diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index 6344f77fc..c045e06bb 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -25,3 +25,7 @@ c0eacf2eb1e1c0b3bd4f71f12fef258f5b249c3f
 da8baf2aa5ce93b958aca90a0ae69f537806324b
 # Run clang-format on most sources
 369f9740de4534c28d0e81ab2afc99decbb9a3e6
+# Get rid of .internal.h convention in LIBC_INTRIN
+86d884cce24d773e298a2714c1e3d91ecab9be45
+# Remove .internal from more header filenames
+31194165d2afca36c2315a6e7ca2f0797dde09e3
diff --git a/.gitattributes b/.gitattributes
index fa3e12742..ffcf7856a 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,4 +1,10 @@
 # -*- conf -*-
 *.gz                         binary
-/build/bootstrap/*.com       binary
+*.so                         binary
+*.dll                        binary
+*.dylib                      binary
+/build/bootstrap/*           binary
+/usr/share/terminfo/*        binary
+/usr/share/terminfo/*/*      binary
 /usr/share/zoneinfo/*        binary
+/usr/share/zoneinfo/*/*      binary
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index c558453d5..7de803d3a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,5 +1,8 @@
 name: build
 
+env:
+  COSMOCC_VERSION: 3.9.2
+
 on:
   push:
     branches:
@@ -19,13 +22,48 @@ jobs:
       matrix:
         mode: ["", tiny, rel, tinylinux, optlinux]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          # Full checkout needed for git-restore-mtime-bare.
+          fetch-depth: 0
+
+      # TODO(jart): fork this action.
+      - uses: chetan/git-restore-mtime-action@v2
+
+      - uses: actions/cache/restore@v4
+        id: cache
+        with:
+          path: |
+            .cosmocc
+            o
+          key: ${{ env.COSMOCC_VERSION }}-${{ matrix.mode }}-${{ github.sha }}
+          restore-keys: |
+            ${{ env.COSMOCC_VERSION }}-${{ matrix.mode }}-
+            ${{ env.COSMOCC_VERSION }}-
+
+      - name: Restore mtimes
+        if: steps.cache.outputs.cache-hit == 'true'
+        run: |
+          while read mtime file; do
+            [ -f "$file" ] && touch -d "@$mtime" "$file"
+          done < o/.mtimes
 
       - name: support ape bins 1
-        run: sudo cp build/bootstrap/ape.elf /usr/bin/ape
+        run: sudo cp -a build/bootstrap/ape.elf /usr/bin/ape
 
       - name: support ape bins 2
         run: sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
 
       - name: make matrix
         run: V=0 make -j2 MODE=${{ matrix.mode }}
+
+      - name: Save mtimes
+        run: |
+          find o -type f -exec stat -c "%Y %n" {} \; > o/.mtimes
+
+      - uses: actions/cache/save@v4
+        with:
+          path: |
+            .cosmocc
+            o
+          key: ${{ env.COSMOCC_VERSION }}-${{ matrix.mode }}-${{ github.sha }}
diff --git a/.github/workflows/nightly-cosmocc.yml b/.github/workflows/nightly-cosmocc.yml
new file mode 100644
index 000000000..69ccb16d2
--- /dev/null
+++ b/.github/workflows/nightly-cosmocc.yml
@@ -0,0 +1,24 @@
+name: Nightly cosmocc
+on:
+  schedule:
+    # https://crontab.guru/#37_4_*_*_*
+    - cron: "37 4 * * *"
+  workflow_dispatch:
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: true
+jobs:
+  build-cosmocc:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: |
+          sudo cp build/bootstrap/ape.elf /usr/bin/ape
+          sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
+      - run: tool/cosmocc/package.sh
+      # https://github.com/actions/upload-artifact/issues/590
+      - uses: actions/upload-artifact@v4.3.5
+        with:
+          name: cosmocc
+          path: cosmocc
+          compression-level: 9
diff --git a/.gitignore b/.gitignore
index 4c767cd51..0c6b21f03 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,3 +15,4 @@ __pycache__
 /tool/emacs/*.elc
 /perf.data
 /perf.data.old
+/qemu*core
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 000000000..6ce0ca591
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,36 @@
+{
+    "C_Cpp.default.compilerPath": ".cosmocc/3.9.2/bin/aarch64-linux-cosmo-c++",
+    "C_Cpp.default.compilerArgs": [
+        "-nostdinc",
+        "-nostdlib",
+        "-iquote.",
+        "-isystemlibc/isystem",
+        "-isystemthird_party/libcxx",
+        "-includelibc/integral/normalize.inc",
+        "-D_COSMO_SOURCE",
+        "-D__aarch64__"
+    ],
+    "[c]": {
+        "editor.tabSize": 2,
+        "editor.insertSpaces": true
+    },
+    "[cpp]": {
+        "editor.tabSize": 2,
+        "editor.insertSpaces": true
+    },
+    "[makefile]": {
+        "editor.tabSize": 8,
+        "editor.insertSpaces": false
+    },
+    "[make]": {
+        "editor.tabSize": 8,
+        "editor.insertSpaces": false
+    },
+    "[assembly]": {
+        "editor.tabSize": 8,
+        "editor.insertSpaces": true
+    },
+    "files.associations": {
+        "log.h": "c"
+    }
+}
diff --git a/Makefile b/Makefile
index 692df3a00..33fbcbdae 100644
--- a/Makefile
+++ b/Makefile
@@ -77,7 +77,8 @@ COMMA := ,
 PWD := $(shell pwd)
 
 # detect wsl2 running cosmopolitan binaries on the host by checking whether:
-# - user ran build/bootstrap/make, in which case make's working directory is in wsl
+# - user ran .cosmocc/current/bin/make, in which case make's working directory
+#   is in wsl
 # - user ran make, in which case cocmd's working directory is in wsl
 ifneq ($(findstring //wsl.localhost/,$(CURDIR) $(PWD)),)
 $(warning wsl2 interop is enabled)
@@ -89,7 +90,7 @@ UNAME_S := $(shell uname -s)
 
 # apple still distributes a 17 year old version of gnu make
 ifeq ($(MAKE_VERSION), 3.81)
-$(error please use build/bootstrap/make)
+$(error please use https://cosmo.zip/pub/cosmos/bin/make)
 endif
 
 LC_ALL = C
@@ -101,23 +102,22 @@ XARGS ?= xargs -P4 -rs8000
 DOT ?= dot
 CLANG = clang
 TMPDIR = o/tmp
-AR = build/bootstrap/ar
-CP = build/bootstrap/cp
-RM = build/bootstrap/rm -f
-GZIP = build/bootstrap/gzip
-ECHO = build/bootstrap/echo
-CHMOD = build/bootstrap/chmod
-TOUCH = build/bootstrap/touch
-PKG = build/bootstrap/package
-MKDEPS = build/bootstrap/mkdeps
-ZIPOBJ = build/bootstrap/zipobj
-ZIPCOPY = build/bootstrap/zipcopy
-PECHECK = build/bootstrap/pecheck
-FIXUPOBJ = build/bootstrap/fixupobj
-MKDIR = build/bootstrap/mkdir -p
-COMPILE = build/bootstrap/compile -V9 -M2048m -P8192 $(QUOTA)
-
-IGNORE := $(shell $(MKDIR) $(TMPDIR))
+AR = $(BOOTSTRAP)/ar.ape
+CP = $(BOOTSTRAP)/cp.ape
+RM = $(BOOTSTRAP)/rm.ape -f
+GZIP = $(BOOTSTRAP)/gzip.ape
+ECHO = $(BOOTSTRAP)/echo.ape
+CHMOD = $(BOOTSTRAP)/chmod.ape
+TOUCH = $(BOOTSTRAP)/touch.ape
+PKG = $(BOOTSTRAP)/package.ape
+MKDEPS = $(BOOTSTRAP)/mkdeps
+ZIPOBJ = $(BOOTSTRAP)/zipobj
+ZIPCOPY = $(BOOTSTRAP)/zipcopy
+PECHECK = $(BOOTSTRAP)/pecheck
+FIXUPOBJ = $(BOOTSTRAP)/fixupobj
+OBJBINCOPY = $(BOOTSTRAP)/objbincopy
+MKDIR = $(BOOTSTRAP)/mkdir.ape -p
+COMPILE = $(BOOTSTRAP)/compile.ape -V9 -M2048m -P8192 $(QUOTA)
 
 # the default build modes is empty string
 # on x86_64 hosts, MODE= is the same as MODE=x86_64
@@ -133,14 +133,13 @@ endif
 
 ifneq ($(findstring aarch64,$(MODE)),)
 ARCH = aarch64
-HOSTS ?= pi studio freebsdarm
+HOSTS ?= pi pi5 studio freebsdarm
 else
 ARCH = x86_64
-HOSTS ?= freebsd rhel7 xnu openbsd netbsd win10
+HOSTS ?= freebsd rhel7 xnu openbsd netbsd win10 luna
 endif
 
 ZIPOBJ_FLAGS += -a$(ARCH)
-IGNORE := $(shell $(MKDIR) $(TMPDIR))
 
 export ADDR2LINE
 export LC_ALL
@@ -149,9 +148,12 @@ export MODE
 export SOURCE_DATE_EPOCH
 export TMPDIR
 
-COSMOCC = .cosmocc/3.3.5
+COSMOCC = .cosmocc/3.9.2
+BOOTSTRAP = $(COSMOCC)/bin
 TOOLCHAIN = $(COSMOCC)/bin/$(ARCH)-linux-cosmo-
-DOWNLOAD := $(shell build/download-cosmocc.sh $(COSMOCC) 3.3.5 db78fd8d3f8706e9dff4be72bf71d37a3f12062f212f407e1c33bc4af3780dd0)
+DOWNLOAD := $(shell build/download-cosmocc.sh $(COSMOCC) 3.9.2 f4ff13af65fcd309f3f1cfd04275996fb7f72a4897726628a8c9cf732e850193)
+
+IGNORE := $(shell $(MKDIR) $(TMPDIR))
 
 AS = $(TOOLCHAIN)as
 CC = $(TOOLCHAIN)gcc
@@ -256,7 +258,6 @@ include third_party/nsync/mem/BUILD.mk		# │  You can now use stdio
 include libc/proc/BUILD.mk			# │  You can now use threads
 include libc/dlopen/BUILD.mk			# │  You can now use processes
 include libc/thread/BUILD.mk			# │  You can finally call malloc()
-include ctl/BUILD.mk				# │
 include third_party/zlib/BUILD.mk		# │
 include libc/stdio/BUILD.mk			# │
 include tool/hello/BUILD.mk			# │
@@ -274,10 +275,16 @@ include libc/BUILD.mk				#─┘
 include libc/sock/BUILD.mk			#─┐
 include net/http/BUILD.mk			# ├──ONLINE RUNTIME
 include third_party/musl/BUILD.mk		# │  You can communicate with the network
+include third_party/regex/BUILD.mk		# │
+include third_party/tr/BUILD.mk			# │
+include third_party/sed/BUILD.mk		# │
+include libc/system/BUILD.mk			# │
 include libc/x/BUILD.mk				# │
 include dsp/scale/BUILD.mk			# │
 include dsp/mpeg/BUILD.mk			# │
 include dsp/tty/BUILD.mk			# │
+include dsp/audio/BUILD.mk			# │
+include dsp/prog/BUILD.mk			# │
 include dsp/BUILD.mk				# │
 include third_party/stb/BUILD.mk		# │
 include third_party/mbedtls/BUILD.mk		# │
@@ -285,14 +292,13 @@ include third_party/ncurses/BUILD.mk		# │
 include third_party/readline/BUILD.mk		# │
 include third_party/libunwind/BUILD.mk		# |
 include third_party/libcxxabi/BUILD.mk		# |
+include third_party/double-conversion/BUILD.mk	# │
+include ctl/BUILD.mk				# │
 include third_party/libcxx/BUILD.mk		# │
 include third_party/openmp/BUILD.mk		# │
-include third_party/double-conversion/BUILD.mk	# │
 include third_party/pcre/BUILD.mk		# │
 include third_party/less/BUILD.mk		# │
-include net/https/BUILD.mk			# │
-include third_party/regex/BUILD.mk		# │
-include third_party/bash/BUILD.mk		#─┘
+include net/https/BUILD.mk			#─┘
 include third_party/tidy/BUILD.mk
 include third_party/BUILD.mk
 include third_party/nsync/testing/BUILD.mk
@@ -311,8 +317,6 @@ include third_party/double-conversion/test/BUILD.mk
 include third_party/lua/BUILD.mk
 include third_party/tree/BUILD.mk
 include third_party/zstd/BUILD.mk
-include third_party/tr/BUILD.mk
-include third_party/sed/BUILD.mk
 include third_party/awk/BUILD.mk
 include third_party/hiredis/BUILD.mk
 include third_party/make/BUILD.mk
@@ -365,6 +369,7 @@ include test/libc/fmt/BUILD.mk
 include test/libc/time/BUILD.mk
 include test/libc/proc/BUILD.mk
 include test/libc/stdio/BUILD.mk
+include test/libc/system/BUILD.mk
 include test/libc/BUILD.mk
 include test/net/http/BUILD.mk
 include test/net/https/BUILD.mk
@@ -428,67 +433,71 @@ HTAGS:	o/$(MODE)/hdrs-old.txt $(filter-out third_party/libcxx/%,$(HDRS)) #o/$(MO
 
 loc: private .UNSANDBOXED = 1
 loc: o/$(MODE)/tool/build/summy
-	find -name \*.h -or -name \*.c -or -name \*.S | \
+	find -name \*.h -or -name \*.hpp -or -name \*.c -or -name \*.cc -or -name \*.cpp -or -name \*.S -or -name \*.mk | \
 	$(XARGS) wc -l | grep total | awk '{print $$1}' | $<
 
-# PLEASE: MAINTAIN TOPOLOGICAL ORDER
-# FROM HIGHEST LEVEL TO LOWEST LEVEL
-COSMOPOLITAN_OBJECTS =			\
-	TOOL_ARGS			\
-	NET_HTTP			\
-	LIBC_SOCK			\
-	LIBC_NT_WS2_32			\
-	LIBC_NT_IPHLPAPI		\
-	LIBC_X				\
-	THIRD_PARTY_GETOPT		\
+COSMOPOLITAN =				\
+	CTL				\
+	DSP_AUDIO			\
+	LIBC_CALLS			\
+	LIBC_DLOPEN			\
+	LIBC_ELF			\
+	LIBC_FMT			\
+	LIBC_INTRIN			\
+	LIBC_IRQ			\
 	LIBC_LOG			\
-	THIRD_PARTY_TZ			\
-	THIRD_PARTY_OPENMP		\
-	THIRD_PARTY_MUSL		\
-	THIRD_PARTY_ZLIB_GZ		\
+	LIBC_MEM			\
+	LIBC_NEXGEN32E			\
+	LIBC_NT_ADVAPI32		\
+	LIBC_NT_BCRYPTPRIMITIVES	\
+	LIBC_NT_COMDLG32		\
+	LIBC_NT_GDI32			\
+	LIBC_NT_IPHLPAPI		\
+	LIBC_NT_KERNEL32		\
+	LIBC_NT_NTDLL			\
+	LIBC_NT_PDH			\
+	LIBC_NT_POWRPROF		\
+	LIBC_NT_PSAPI			\
+	LIBC_NT_REALTIME		\
+	LIBC_NT_SHELL32			\
+	LIBC_NT_SYNCHRONIZATION		\
+	LIBC_NT_USER32			\
+	LIBC_NT_WS2_32			\
+	LIBC_PROC			\
+	LIBC_RUNTIME			\
+	LIBC_SOCK			\
+	LIBC_STDIO			\
+	LIBC_STR			\
+	LIBC_SYSTEM			\
+	LIBC_SYSV			\
+	LIBC_SYSV_CALLS			\
+	LIBC_THREAD			\
+	LIBC_TINYMATH			\
+	LIBC_VGA			\
+	LIBC_X				\
+	NET_HTTP			\
+	THIRD_PARTY_COMPILER_RT		\
+	THIRD_PARTY_DLMALLOC		\
+	THIRD_PARTY_DOUBLECONVERSION	\
+	THIRD_PARTY_GDTOA		\
+	THIRD_PARTY_GETOPT		\
 	THIRD_PARTY_LIBCXXABI		\
 	THIRD_PARTY_LIBUNWIND		\
-	LIBC_STDIO			\
-	THIRD_PARTY_GDTOA		\
-	THIRD_PARTY_REGEX		\
-	LIBC_THREAD			\
-	LIBC_PROC			\
-	THIRD_PARTY_NSYNC_MEM		\
-	CTL				\
-	LIBC_MEM			\
-	THIRD_PARTY_DLMALLOC		\
-	LIBC_DLOPEN			\
-	LIBC_RUNTIME			\
+	THIRD_PARTY_MUSL		\
 	THIRD_PARTY_NSYNC		\
-	LIBC_ELF			\
-	LIBC_IRQ			\
-	LIBC_CALLS			\
-	LIBC_SYSV_CALLS			\
-	LIBC_VGA			\
-	LIBC_NT_PSAPI			\
-	LIBC_NT_POWRPROF		\
-	LIBC_NT_PDH			\
-	LIBC_NT_GDI32			\
-	LIBC_NT_COMDLG32		\
-	LIBC_NT_USER32			\
-	LIBC_NT_NTDLL			\
-	LIBC_NT_ADVAPI32		\
-	LIBC_NT_SYNCHRONIZATION		\
-	LIBC_FMT			\
-	THIRD_PARTY_ZLIB		\
+	THIRD_PARTY_NSYNC_MEM		\
+	THIRD_PARTY_OPENMP		\
 	THIRD_PARTY_PUFF		\
-	THIRD_PARTY_COMPILER_RT		\
-	LIBC_TINYMATH			\
+	THIRD_PARTY_REGEX		\
+	THIRD_PARTY_TZ			\
 	THIRD_PARTY_XED			\
-	LIBC_STR			\
-	LIBC_SYSV			\
-	LIBC_INTRIN			\
-	LIBC_NT_BCRYPTPRIMITIVES	\
-	LIBC_NT_KERNEL32		\
-	LIBC_NEXGEN32E
+	THIRD_PARTY_ZLIB		\
+	THIRD_PARTY_ZLIB_GZ		\
+	TOOL_ARGS			\
 
 COSMOPOLITAN_H_PKGS =			\
 	APE				\
+	DSP_AUDIO			\
 	LIBC				\
 	LIBC_CALLS			\
 	LIBC_ELF			\
@@ -532,14 +541,14 @@ COSMOCC_PKGS =				\
 	THIRD_PARTY_INTEL
 
 o/$(MODE)/cosmopolitan.a:		\
-		$(foreach x,$(COSMOPOLITAN_OBJECTS),$($(x)_A_OBJS))
+		$(call reverse,$(call uniq,$(foreach x,$(COSMOPOLITAN),$($(x)))))
 
 COSMOCC_HDRS =								\
 	$(wildcard libc/integral/*)					\
 	$(foreach x,$(COSMOCC_PKGS),$($(x)_HDRS))			\
 	$(foreach x,$(COSMOCC_PKGS),$($(x)_INCS))
 
-o/cosmocc.h.txt: Makefile
+o/cosmocc.h.txt: Makefile libc $(MAKEFILES) $(call uniq,$(foreach x,$(HDRS) $(INCS),$(dir $(x)))) $(HDRS) $(INCS)
 	$(file >$@, $(call uniq,$(COSMOCC_HDRS)))
 
 COSMOPOLITAN_H_ROOT_HDRS =						\
diff --git a/README.md b/README.md
index 71dfa3af7..75851c8be 100644
--- a/README.md
+++ b/README.md
@@ -3,12 +3,12 @@
 [![build](https://github.com/jart/cosmopolitan/actions/workflows/build.yml/badge.svg)](https://github.com/jart/cosmopolitan/actions/workflows/build.yml)
 # Cosmopolitan
 
-[Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C
+[Cosmopolitan Libc](https://justine.lol/cosmopolitan/index.html) makes C/C++
 a build-once run-anywhere language, like Java, except it doesn't need an
 interpreter or virtual machine. Instead, it reconfigures stock GCC and
 Clang to output a POSIX-approved polyglot format that runs natively on
-Linux + Mac + Windows + FreeBSD + OpenBSD + NetBSD + BIOS with the best
-possible performance and the tiniest footprint imaginable.
+Linux + Mac + Windows + FreeBSD + OpenBSD 7.3 + NetBSD + BIOS with the
+best possible performance and the tiniest footprint imaginable.
 
 ## Background
 
@@ -87,15 +87,22 @@ ape/apeinstall.sh
 ```
 
 You can now build the mono repo with any modern version of GNU Make. To
-make life easier, we've included one in the cosmocc toolchain, which is
-guaranteed to be compatible and furthermore includes our extensions for
-doing build system sandboxing.
+bootstrap your build, you can install Cosmopolitan Make from this site:
+
+https://cosmo.zip/pub/cosmos/bin/make
+
+E.g.:
 
 ```sh
-build/bootstrap/make -j8
+curl -LO https://cosmo.zip/pub/cosmos/bin/make
+./make -j8
 o//examples/hello
 ```
 
+After you've built the repo once, you can also use the make from your
+cosmocc at `.cosmocc/current/bin/make`. You might even prefer to alias
+make to `$COSMO/.cosmocc/current/bin/make`.
+
 Since the Cosmopolitan repository is very large, you might only want to
 build one particular thing. Here's an example of a target that can be
 compiled relatively quickly, which is a simple POSIX test that only
@@ -103,7 +110,7 @@ depends on core LIBC packages.
 
 ```sh
 rm -rf o//libc o//test
-build/bootstrap/make o//test/posix/signal_test
+.cosmocc/current/bin/make o//test/posix/signal_test
 o//test/posix/signal_test
 ```
 
@@ -112,21 +119,21 @@ list out each individual one. For example if you wanted to build and run
 all the unit tests in the `TEST_POSIX` package, you could say:
 
 ```sh
-build/bootstrap/make o//test/posix
+.cosmocc/current/bin/make o//test/posix
 ```
 
 Cosmopolitan provides a variety of build modes. For example, if you want
 really tiny binaries (as small as 12kb in size) then you'd say:
 
 ```sh
-build/bootstrap/make m=tiny
+.cosmocc/current/bin/make m=tiny
 ```
 
 You can furthermore cut out the bloat of other operating systems, and
 have Cosmopolitan become much more similar to Musl Libc.
 
 ```sh
-build/bootstrap/make m=tinylinux
+.cosmocc/current/bin/make m=tinylinux
 ```
 
 For further details, see [//build/config.mk](build/config.mk).
@@ -242,16 +249,16 @@ server. You're welcome to join us! <https://discord.gg/FwAVVu7eJ4>
 
 ## Support Vector
 
-| Platform       | Min Version | Circa |
-| :---           | ---:        | ---:  |
-| AMD            | K8 Venus    | 2005  |
-| Intel          | Core        | 2006  |
-| Linux          | 2.6.18      | 2007  |
-| Windows        | 8 [1]       | 2012  |
-| Darwin (macOS) | 23.1.0+     | 2023  |
-| OpenBSD        | 7           | 2021  |
-| FreeBSD        | 13          | 2020  |
-| NetBSD         | 9.2         | 2021  |
+| Platform       | Min Version    | Circa |
+| :---           | ---:           | ---:  |
+| AMD            | K8             | 2003  |
+| Intel          | Core           | 2006  |
+| Linux          | 2.6.18         | 2007  |
+| Windows        | 8 [1]          | 2012  |
+| Darwin (macOS) | 23.1.0+        | 2023  |
+| OpenBSD        | 7.3 or earlier | 2023  |
+| FreeBSD        | 13             | 2020  |
+| NetBSD         | 9.2            | 2021  |
 
 [1] See our [vista branch](https://github.com/jart/cosmopolitan/tree/vista)
     for a community supported version of Cosmopolitan that works on Windows
diff --git a/ape/BUILD.mk b/ape/BUILD.mk
index 3bbf00e60..3e8ea3137 100644
--- a/ape/BUILD.mk
+++ b/ape/BUILD.mk
@@ -45,10 +45,10 @@ o/$(MODE)/ape: $(APE)
 
 o/$(MODE)/ape/aarch64.lds:			\
 	ape/aarch64.lds				\
-	libc/zip.internal.h			\
+	libc/zip.h				\
 	libc/thread/tls.h			\
 	libc/calls/struct/timespec.h		\
-	libc/macros.internal.h			\
+	libc/macros.h				\
 	libc/str/str.h
 
 APE_LOADER_LDFLAGS =				\
@@ -162,8 +162,8 @@ o/$(MODE)/ape/ape-no-modify-self.o:		\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/thread/tls.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
+		libc/macho.h			\
+		libc/macros.h			\
 		libc/nexgen32e/uart.internal.h	\
 		libc/calls/metalfile.internal.h	\
 		libc/nt/pedef.internal.h	\
@@ -188,8 +188,8 @@ o/$(MODE)/ape/ape-copy-self.o:			\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/thread/tls.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
+		libc/macho.h			\
+		libc/macros.h			\
 		libc/nexgen32e/uart.internal.h	\
 		libc/calls/metalfile.internal.h	\
 		libc/nt/pedef.internal.h	\
@@ -218,10 +218,10 @@ o/$(MODE)/ape/loader-xnu-clang.asm: ape/loader.c
 	@$(COMPILE) -AOBJECTIFY.c $(CLANG) -DSUPPORT_VECTOR=8 -S -g0 $(APE_LOADER_FLAGS)
 
 o/$(MODE)/ape/ape.elf: o/$(MODE)/ape/ape.elf.dbg
-	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy -f -o $@ $<
+	@$(COMPILE) -AOBJBINCOPY -w $(OBJBINCOPY) -f -o $@ $<
 
 o/$(MODE)/ape/ape.macho: o/$(MODE)/ape/ape.elf.dbg
-	@$(COMPILE) -AOBJBINCOPY -w build/bootstrap/objbincopy -fm -o $@ $<
+	@$(COMPILE) -AOBJBINCOPY -w $(OBJBINCOPY) -fm -o $@ $<
 
 APE_LOADER_LDFLAGS =				\
 	-static					\
@@ -246,8 +246,6 @@ o/$(MODE)/ape:	$(APE_CHECKS)			\
 		o/$(MODE)/ape/ape.lds		\
 		o/$(MODE)/ape/ape.elf		\
 		o/$(MODE)/ape/ape.macho		\
-		o/$(MODE)/ape/ape-copy-self.o	\
-		o/$(MODE)/ape/ape-no-modify-self.o
 
 endif
 
@@ -261,8 +259,8 @@ o/$(MODE)/ape/ape.o:				\
 		libc/thread/tls.h		\
 		ape/ape.internal.h		\
 		ape/macros.internal.h		\
-		libc/macho.internal.h		\
-		libc/macros.internal.h		\
+		libc/macho.h			\
+		libc/macros.h			\
 		libc/sysv/consts/prot.h		\
 		libc/nt/pedef.internal.h	\
 		libc/runtime/pc.internal.h	\
@@ -283,7 +281,7 @@ o/$(MODE)/ape/ape.lds:				\
 		libc/dce.h			\
 		libc/elf/def.h			\
 		libc/elf/pf2prot.internal.h	\
-		libc/macros.internal.h		\
+		libc/macros.h			\
 		libc/nt/pedef.internal.h	\
 		libc/str/str.h			\
-		libc/zip.internal.h
+		libc/zip.h
diff --git a/ape/aarch64.lds b/ape/aarch64.lds
index c63ce4295..48562d2a2 100644
--- a/ape/aarch64.lds
+++ b/ape/aarch64.lds
@@ -12,7 +12,7 @@ OUTPUT_FORMAT("elf64-littleaarch64",
 
 SECTIONS {
 
-  . = SEGMENT_START("text-segment", 0x010000000000);
+  . = SEGMENT_START("text-segment", 0x000800000000);
   __executable_start = .;
   . += SIZEOF_HEADERS;
 
@@ -103,10 +103,8 @@ SECTIONS {
     *(.eh_frame_entry .eh_frame_entry.*)
   }
 
-  .eh_frame : ONLY_IF_RO {
-    KEEP(*(.eh_frame))
-    *(.eh_frame.*)
-  }
+  __eh_frame_hdr_start = SIZEOF(.eh_frame_hdr) > 0 ? ADDR(.eh_frame_hdr) : 0;
+  __eh_frame_hdr_end = SIZEOF(.eh_frame_hdr) > 0 ? . : 0;
 
   .gcc_except_table : ONLY_IF_RO {
     *(.gcc_except_table .gcc_except_table.*)
@@ -127,9 +125,11 @@ SECTIONS {
   . += CONSTANT(MAXPAGESIZE);
   . = DATA_SEGMENT_ALIGN(CONSTANT(MAXPAGESIZE), CONSTANT(COMMONPAGESIZE));
 
-  .eh_frame : ONLY_IF_RW {
+  .eh_frame : {
+    __eh_frame_start = .;
     KEEP(*(.eh_frame))
     *(.eh_frame.*)
+    __eh_frame_end = .;
   }
 
   .gnu_extab : ONLY_IF_RW {
@@ -259,6 +259,9 @@ SECTIONS {
   .debug_ranges       0 : { *(.debug_ranges) }
   .debug_macro        0 : { *(.debug_macro) }
   .debug_addr         0 : { *(.debug_addr) }
+  .debug_names        0 : { *(.debug_names) }
+  .debug_loclists     0 : { *(.debug_loclists) }
+  .debug_str_offsets  0 : { *(.debug_str_offsets) }
   .ARM.attributes     0 : { KEEP(*(.ARM.attributes)) KEEP(*(.gnu.attributes)) }
   .note.gnu.arm.ident 0 : { KEEP(*(.note.gnu.arm.ident)) }
 
diff --git a/ape/ape-m1.c b/ape/ape-m1.c
index 8d188404a..2d677f22b 100644
--- a/ape/ape-m1.c
+++ b/ape/ape-m1.c
@@ -16,6 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#ifndef __APPLE__
+#error "ape/ape-m1.c is for apple silicon. chances you want ape/loader.c"
+#endif
+#ifndef __aarch64__
+#error "ape/ape-m1.c is for apple silicon; you want: make o//ape/ape.macho"
+#endif
 #include <assert.h>
 #include <dispatch/dispatch.h>
 #include <dlfcn.h>
diff --git a/ape/ape.S b/ape/ape.S
index 2ec05e963..f274e31f6 100644
--- a/ape/ape.S
+++ b/ape/ape.S
@@ -37,7 +37,7 @@
 #include "libc/calls/metalfile.internal.h"
 #include "libc/dce.h"
 #include "libc/elf/def.h"
-#include "libc/macho.internal.h"
+#include "libc/macho.h"
 #include "libc/nexgen32e/uart.internal.h"
 #include "libc/nt/pedef.internal.h"
 #include "libc/runtime/pc.internal.h"
diff --git a/ape/ape.lds b/ape/ape.lds
index 4e6db724a..ac82bde00 100644
--- a/ape/ape.lds
+++ b/ape/ape.lds
@@ -310,7 +310,7 @@ SECTIONS {
     . = ALIGN(__privileged_end > __privileged_start ? CONSTANT(COMMONPAGESIZE) : 0);
 /*END: morphable code */
     __privileged_start = .;
-    *(.privileged)
+    *(.privileged .privileged.*)
     __privileged_end = .;
 
     KEEP(*(.ape.pad.text))
@@ -329,6 +329,10 @@ SECTIONS {
     *(.ubsan.types)
     *(.ubsan.data)
 
+    __eh_frame_hdr_start_actual = .;
+    *(.eh_frame_hdr)
+    __eh_frame_hdr_end_actual = .;
+
     /* Legal Notices */
     __notices = .;
     KEEP(*(.notice))
@@ -382,6 +386,13 @@ SECTIONS {
     _tbss_end = .;
   } :Tls
 
+  .eh_frame : {
+    __eh_frame_start = .;
+    KEEP(*(.eh_frame))
+    *(.eh_frame.*)
+    __eh_frame_end = .;
+  } :Ram
+
   .data . : {
 /*BEGIN: Read/Write Data */
 #if SupportsWindows()
@@ -430,7 +441,6 @@ SECTIONS {
     KEEP(*(.piro.pad.data))
     *(.igot.plt)
     KEEP(*(.dataepilogue))
-
     . = ALIGN(. != 0 ? CONSTANT(COMMONPAGESIZE) : 0);
 /*END: NT FORK COPYING */
     _edata = .;
@@ -510,6 +520,9 @@ SECTIONS {
   .debug_rnglists    0 : { *(.debug_rnglists) }
   .debug_macro       0 : { *(.debug_macro) }
   .debug_addr        0 : { *(.debug_addr) }
+  .debug_names       0 : { *(.debug_names) }
+  .debug_loclists    0 : { *(.debug_loclists) }
+  .debug_str_offsets 0 : { *(.debug_str_offsets) }
   .gnu.attributes    0 : { KEEP(*(.gnu.attributes)) }
   .GCC.command.line  0 : { *(.GCC.command.line) }
 
@@ -573,11 +586,11 @@ ape_rom_memsz = ape_rom_filesz;
 ape_rom_align = CONSTANT(COMMONPAGESIZE);
 ape_rom_rva = RVA(ape_rom_vaddr);
 
-ape_ram_vaddr = ADDR(.data);
+ape_ram_vaddr = ADDR(.eh_frame);
 ape_ram_offset = ape_ram_vaddr - __executable_start;
-ape_ram_paddr = LOADADDR(.data);
-ape_ram_filesz = ADDR(.bss) - ADDR(.data);
-ape_ram_memsz = _end - ADDR(.data);
+ape_ram_paddr = LOADADDR(.eh_frame);
+ape_ram_filesz = ADDR(.bss) - ADDR(.eh_frame);
+ape_ram_memsz = _end - ADDR(.eh_frame);
 ape_ram_align = CONSTANT(COMMONPAGESIZE);
 ape_ram_rva = RVA(ape_ram_vaddr);
 
@@ -587,7 +600,7 @@ ape_stack_offset = 0;
 ape_stack_vaddr = DEFINED(ape_stack_vaddr) ? ape_stack_vaddr : 0x700000000000;
 ape_stack_paddr = ape_ram_paddr + ape_ram_filesz;
 ape_stack_filesz = 0;
-ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : 8 * 1024 * 1024;
+ape_stack_memsz = DEFINED(ape_stack_memsz) ? ape_stack_memsz : 4 * 1024 * 1024;
 
 ape_note_offset = ape_cod_offset + (ape_note - ape_cod_vaddr);
 ape_note_filesz = ape_note_end - ape_note;
@@ -601,6 +614,9 @@ ape_text_memsz = ape_text_filesz;
 ape_text_align = CONSTANT(COMMONPAGESIZE);
 ape_text_rva = RVA(ape_text_vaddr);
 
+__eh_frame_hdr_start = __eh_frame_hdr_end_actual > __eh_frame_hdr_start_actual ? __eh_frame_hdr_start_actual : 0;
+__eh_frame_hdr_end = __eh_frame_hdr_end_actual > __eh_frame_hdr_start_actual ? __eh_frame_hdr_end_actual : 0;
+
 /* we roundup here because xnu wants the file load segments page-aligned */
 /* but we don't want to add the nop padding to the ape program, so we'll */
 /* let ape.S dd read past the end of the file into the wrapping binaries */
diff --git a/ape/apeinstall.sh b/ape/apeinstall.sh
index 2a0a28590..73f24965f 100755
--- a/ape/apeinstall.sh
+++ b/ape/apeinstall.sh
@@ -10,8 +10,8 @@ if [ ! -f ape/loader.c ]; then
   cd "$COSMO" || exit
 fi
 
-if [ -x build/bootstrap/make ]; then
-  MAKE=build/bootstrap/make
+if [ -x .cosmocc/current/bin/make ]; then
+  MAKE=.cosmocc/current/bin/make
 else
   MAKE=make
 fi
diff --git a/ape/launch.S b/ape/launch.S
index ae2cb58a1..f710fdec7 100644
--- a/ape/launch.S
+++ b/ape/launch.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Calls _start() function of loaded program.
 //
diff --git a/ape/loader-macho.S b/ape/loader-macho.S
index bcecf9dac..e484f0686 100644
--- a/ape/loader-macho.S
+++ b/ape/loader-macho.S
@@ -16,10 +16,10 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macho.internal.h"
+#include "libc/macho.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Apple Mach-O Executable Headers
 //	Fixups are applied by objbincopy
diff --git a/ape/macros.internal.h b/ape/macros.internal.h
index ad354e474..dcfdc75a0 100644
--- a/ape/macros.internal.h
+++ b/ape/macros.internal.h
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #ifndef APE_MACROS_H_
 #define APE_MACROS_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #ifdef __ASSEMBLER__
 /* clang-format off */
 
diff --git a/ape/specification.md b/ape/specification.md
new file mode 100644
index 000000000..9ac4a7a4d
--- /dev/null
+++ b/ape/specification.md
@@ -0,0 +1,703 @@
+# Actually Portable Executable Specification v0.1
+
+Actually Portable Executable (APE) is an executable file format that
+polyglots the Windows Portable Executable (PE) format with a UNIX Sixth
+Edition style shell script that doesn't have a shebang. This makes it
+possible to produce a single file binary that executes on the stock
+installations of the many OSes and architectures.
+
+## Supported OSes and Architectures
+
+- AMD64
+  - Linux
+  - MacOS
+  - Windows
+  - FreeBSD
+  - OpenBSD
+  - NetBSD
+  - BIOS
+
+- ARM64
+  - Linux
+  - MacOS
+  - FreeBSD
+  - Windows (non-native)
+
+## File Header
+
+APE defines three separate file magics, all of which are 8 characters
+long. Any file that starts with one of these magic values can be
+considered an APE program.
+
+### (1) APE MZ Magic
+
+- ASCII: `MZqFpD='`
+- Hex: 4d 5a 71 46 70 44 3d 27
+
+This is the canonical magic used by almost all APE programs. It enables
+maximum portability between OSes. When interpreted as a shell script, it
+is assigning a single quoted string to an unused variable. The shell
+will then ignore subsequent binary content that's placed inside the
+string.
+
+It is strongly recommended that this magic value be immediately followed
+by a newline (\n or hex 0a) character. Some shells, e.g. FreeBSD SH and
+Zsh impose a binary safety check before handing off files that don't
+have a shebang to `/bin/sh`. That check applies to the first line, which
+can't contain NUL characters.
+
+The letters were carefully chosen so as to be valid x86 instructions in
+all operating modes. This makes it possible to store a BIOS bootloader
+disk image inside an APE binary. For example, simple CLI programs built
+with Cosmopolitan Libc will boot from BIOS into long mode if they're
+treated as a floppy disk image.
+
+The letters also allow for the possibility of being treated on x86-64 as
+a flat executable, where the PE / ELF / Mach-O executable structures are
+ignored, and execution simply begins at the beginning of the file,
+similar to how MS-DOS .COM binaries work.
+
+The 0x4a relative offset of the magic causes execution to jump into the
+MS-DOS stub defined by Portable Executable. APE binaries built by Cosmo
+Libc use tricks in the MS-DOS stub to check the operating mode and then
+jump to the appropriate entrypoint, e.g. `_start()`.
+
+#### Decoded as i8086
+
+```asm
+  dec  %bp
+  pop  %dx
+  jno  0x4a
+  jo   0x4a
+```
+
+#### Decoded as i386
+
+```asm
+  push %ebp
+  pop  %edx
+  jno  0x4a
+  jo   0x4a
+```
+
+#### Decoded as x86-64
+
+```asm
+  rex.WRB
+  pop %r10
+  jno 0x4a
+  jo  0x4a
+```
+
+### (2) APE UNIX-Only Magic
+
+- ASCII: `jartsr='`
+- Hex: 6a 61 72 74 73 72 3d 27
+
+Being a novel executable format that was first published in 2020, the
+APE file format is less understood by industry tools compared to the PE,
+ELF, and Mach-O executable file formats, which have been around for
+decades. For this reason, APE programs that use the MZ magic above can
+attract attention from Windows AV software, which may be unwanted by
+developers who aren't interested in targeting the Windows platform.
+Therefore the `jartsr='` magic is defined which enables the creation of
+APE binaries that can safely target all non-Windows platforms. Even
+though this magic is less common, APE interpreters and binfmt-misc
+installations MUST support this.
+
+It is strongly recommended that this magic value be immediately followed
+by a newline (\n or hex 0a) character. Some shells, e.g. FreeBSD SH and
+Zsh impose a binary safety check before handing off files that don't
+have a shebang to `/bin/sh`. That check applies to the first line, which
+can't contain NUL characters.
+
+The letters were carefully chosen so as to be valid x86 instructions in
+all operating modes. This makes it possible to store a BIOS bootloader
+disk image inside an APE binary. For example, simple CLI programs built
+with Cosmopolitan Libc will boot from BIOS into long mode if they're
+treated as a floppy disk image.
+
+The letters also allow for the possibility of being treated on x86-64 as
+a flat executable, where the PE / ELF / Mach-O executable structures are
+ignored, and execution simply begins at the beginning of the file,
+similar to how MS-DOS .COM binaries work.
+
+The 0x78 relative offset of the magic causes execution to jump into the
+MS-DOS stub defined by Portable Executable. APE binaries built by Cosmo
+Libc use tricks in the MS-DOS stub to check the operating mode and then
+jump to the appropriate entrypoint, e.g. `_start()`.
+
+#### Decoded as i8086 / i386 / x86-64
+
+```asm
+  push $0x61
+  jb   0x78
+  jae  0x78
+```
+
+### (3) APE Debug Magic
+
+- ASCII: `APEDBG='`
+- Hex: 41 50 45 44 42 47 3d 27
+
+While APE files must be valid shell scripts, in practice, UNIX systems
+will oftentimes be configured to provide a faster safer alternative to
+loading an APE binary through `/bin/sh`. The Linux Kernel can be patched
+to have execve() recognize the APE format and directly load its embedded
+ELF header. Linux systems can also use binfmt-misc to recognize APE's MZ
+and jartsr magic, and pass them to a userspace program named `ape` that
+acts as an interpreter. In such environments, the need sometimes arises
+to be able to test that the `/bin/sh` is working correctly, in which
+case the `APEDBG='` magic is RECOMMENDED.
+
+APE interpreters, execve() implementations, and binfmt-misc installs
+MUST ignore this magic. If necessary, steps can be taken to help files
+with this magic be passed to `/bin/sh` like a normal shebang-less shell
+script for execution.
+
+## Embedded ELF Header
+
+APE binaries MAY embed an ELF header inside them. Unlike conventional
+executable file formats, this header is not stored at a fixed offset.
+It's instead encoded as octal escape codes in a shell script `printf`
+statement. For example:
+
+```
+printf '\177ELF\2\1\1\011\0\0\0\0\0\0\0\0\2\0\076\0\1\0\0\0\166\105\100\000\000\000\000\000\060\013\000\000\000\000\000\000\000\000\000\000\000\000\000\000\165\312\1\1\100\0\070\0\005\000\0\0\000\000\000\000'
+```
+
+This `printf` statement MUST appear in the first 8192 bytes of the APE
+executable, so as to limit how much of the initial portion of a file an
+interpreter must load.
+
+Multiple such `printf` statements MAY appear in the first 8192 bytes, in
+order to specify multiple architectures. For example, fat binaries built
+by the `apelink` program (provided by Cosmo Libc) will have two encoded
+ELF headers, for AMD64 and ARM64, each of which point into the proper
+file offsets for their respective native code. Therefore, kernels and
+interpreters which load the APE format directly MUST check the
+`e_machine` field of the `Elf64_Ehdr` that's decoded from the octal
+codes, before accepting a `printf` shell statement as valid.
+
+These printf statements MUST always use only unescaped ASCII characters
+or octal escape codes. These printf statements MUST NOT use space saving
+escape codes such as `\n`. For example, rather than saying `\n` it would
+be valid to say `\012` instead. It's also valid to say `\12` but only if
+the encoded characters that follow aren't an octal digit.
+
+For example, the following algorithm may be used for parsing octal:
+
+```c
+static int ape_parse_octal(const unsigned char page[8192], int i, int *pc)
+{
+        int c;
+        if ('0' <= page[i] && page[i] <= '7') {
+                c = page[i++] - '0';
+                if ('0' <= page[i] && page[i] <= '7') {
+                        c *= 8;
+                        c += page[i++] - '0';
+                        if ('0' <= page[i] && page[i] <= '7') {
+                                c *= 8;
+                                c += page[i++] - '0';
+                        }
+                }
+                *pc = c;
+        }
+        return i;
+}
+```
+
+APE aware interpreters SHOULD only take `e_machine` into consideration.
+It is the responsibility of the `_start()` function to detect the OS.
+Therefore, multiple `printf` statements are only embedded in the shell
+script for different CPU architectures.
+
+The OS ABI field of an APE embedded `Elf64_Ehdr` SHOULD be set to
+`ELFOSABI_FREEBSD`, since it's the only UNIX OS APE supports that
+actually checks the field. However different values MAY be chosen for
+binaries that don't intend to have FreeBSD in their support vector.
+
+Counter-intuitively, the ARM64 ELF header is used on the MacOS ARM64
+platform when loading from fat binaries.
+
+## Embedded Mach-O Header (x86-64 only)
+
+APE shell scripts that support MacOS on AMD64 must use the `dd` command
+in a very specific way to specify how the embedded binary Macho-O header
+is copied backward to the start of the file. For example:
+
+```
+dd if="$o" of="$o" bs=8 skip=433      count=66       conv=notrunc
+```
+
+These `dd` statements have traditionally been generated by the GNU as
+and ld.bfd programs by encoding ASCII into 64-bit linker relocations,
+which necessitated a fixed width for integer values. It took several
+iterations over APE's history before we eventually got it right:
+
+- `arg="  9293"` is how we originally had ape do it
+- `arg=$((  9293))` b/c busybox sh disliked quoted space
+- `arg=9293  ` is generated by modern apelink program
+
+Software that parses the APE file format, which needs to extract the
+Macho-O x86-64 header SHOULD support the old binaries that use the
+previous encodings. To make backwards compatibility simple the following
+regular expression may be used, which generalizes to all defined
+formats:
+
+```c
+regcomp(&rx,
+        "bs="              // dd block size arg
+        "(['\"] *)?"       //   #1 optional quote w/ space
+        "(\\$\\(\\( *)?"   //   #2 optional math w/ space
+        "([[:digit:]]+)"   //   #3
+        "( *\\)\\))?"      //   #4 optional math w/ space
+        "( *['\"])?"       //   #5 optional quote w/ space
+        " +"               //
+        "skip="            // dd skip arg
+        "(['\"] *)?"       //   #6 optional quote w/ space
+        "(\\$\\(\\( *)?"   //   #7 optional math w/ space
+        "([[:digit:]]+)"   //   #8
+        "( *\\)\\))?"      //   #9 optional math w/ space
+        "( *['\"])?"       //  #10 optional quote w/ space
+        " +"               //
+        "count="           // dd count arg
+        "(['\"] *)?"       //  #11 optional quote w/ space
+        "(\\$\\(\\( *)?"   //  #12 optional math w/ space
+        "([[:digit:]]+)",  //  #13
+        REG_EXTENDED);
+```
+
+For further details, see the canonical implementation in
+`cosmopolitan/tool/build/assimilate.c`.
+
+## Static Linking
+
+Actually Portable Executables are always statically linked. This
+revision of the specification does not define any facility for storing
+code in dynamic shared objects.
+
+Cosmopolitan Libc provides a solution that enables APE binaries have
+limited access to dlopen(). By manually loading a platform-specific
+executable and asking the OS-specific libc's dlopen() to load
+OS-specific libraries, it becomes possible to use GPUs and GUIs. This
+has worked great for AI projects like llamafile.
+
+There is no way for an Actually Portable Executable to interact with
+OS-specific dynamic shared object extension modules to programming
+languages. For example, a Lua interpreter compiled as an Actually
+Portable Executable would have no way of linking extension libraries
+downloaded from the Lua Rocks package manager. This is primarily because
+different OSes define incompatible ABIs.
+
+While it was possible to polyglot PE+ELF+MachO to create multi-OS
+executables, it simply isn't possible to do that same thing for
+DLL+DYLIB+SO. Therefore, in order to have DSOs, APE would need to either
+choose one of the existing formats or invent one of its own, and then
+develop its own parallel ecosystem of extension software. In the future,
+the APE specification may expand to encompass this. However the focus to
+date has been exclusively on executables with limited dlopen() support.
+
+## Application Binary Interface (ABI)
+
+APE binaries use the System V ABI, as defined by:
+
+- [System V ABI - AMD64 Architecture Processor Supplement](https://gitlab.com/x86-psABIs/x86-64-ABI)
+- AARCH64 has a uniform consensus defined by ARM Limited
+
+There are however a few changes we've had to make.
+
+### No Red Zone
+
+Actually Portable Executables that have Windows and/or bare metal in
+their support vector MUST be compiled using `-mno-red-zone`. This is
+because, on Windows, DLLs and other software lurking in the va-space
+might use tricks like SetThreadContext() to take control of a thread
+whereas on bare metal, it's also generally accepted that kernel-mode
+code cannot assume a red zone either due to hardware interrupts that
+pull the exact same kinds of stunts.
+
+APE software that only has truly System V ABI conformant OSes (e.g.
+Linux) in their support vector MAY use the red zone optimization.
+
+### Thread Local Storage
+
+#### aarch64
+
+Here's the TLS memory layout on aarch64:
+
+```
+           x28
+        %tpidr_el0
+            │
+            │    _Thread_local
+        ┌───┼───┬──────────┬──────────┐
+        │tib│dtv│  .tdata  │  .tbss   │
+        ├───┴───┴──────────┴──────────┘
+        │
+    __get_tls()
+```
+
+The ARM64 code in actually portable executables use the `x28` register
+to store the address of the thread information block. All aarch64 code
+linked into these executables SHOULD be compiled with `-ffixed-x28`
+which is supported by both Clang and GCC.
+
+The runtime library for an actually portable executables MAY choose to
+use `tpidr_el0` instead, if OSes like MacOS aren't being targeted. For
+example, if the goal is to create a Linux-only fat binary linker program
+for Musl Libc, then choosing to use the existing `tpidr_el0` convention
+would be friction-free alternative.
+
+It's not possible for an APE runtime that targets the full range of OSes
+to use the `tpidr_el0` register for TLS because Apple won't allow it. On
+MacOS ARM64 systems, this register can only be used by a runtime to
+implement the `sched_getcpu()` system call. It's reserved by MacOS.
+
+#### x86-64
+
+Here's the TLS memory layout on x86_64:
+
+```
+                          __get_tls()
+                              │
+                             %fs OpenBSD/NetBSD
+           _Thread_local      │
+    ┌───┬──────────┬──────────┼───┐
+    │pad│  .tdata  │  .tbss   │tib│
+    └───┴──────────┴──────────┼───┘
+                              │
+   Linux/FreeBSD/Windows/Mac %gs
+```
+
+Quite possibly the greatest challenge in Actually Portable Executable
+working, has been overcoming the incompatibilities between OSes in how
+thread-local storage works on x86-64. The AMD64 architecture defines two
+special segment registers. Every OS uses one of these segment registers
+to implement TLS support. However not all OSes agree on which register
+to use. Some OSes grant userspace the power to define either of these
+registers to hold any value that is desired. Some OSes only effectively
+allow a single one of them to be changed. Lastly, some OSes, e.g.
+Windows, claim ownership of the memory layout these registers point
+towards too.
+
+Here's a breakdown on how much power is granted to userspace runtimes by
+each OS when it comes to changing amd64 segment registers.
+
+|         | %fs          | %gs          |
+|---------|--------------|--------------|
+| Linux   | unrestricted | unrestricted |
+| MacOS   | inaccessible | unrestricted |
+| Windows | inaccessible | restricted   |
+| FreeBSD | unrestricted | unrestricted |
+| NetBSD  | unrestricted | broken       |
+| OpenBSD | unrestricted | inaccessible |
+
+Therefore, regardless of which register one we choose, some OSes are
+going to be incompatible.
+
+APE binaries are always built with a Linux compiler. So another issue
+arises in the fact that our Linux-flavored GCC and Clang toolchains
+(which are used to produce cross-OS binaries) are also only capable of
+producing TLS instructions that use the %fs convention.
+
+To solve these challenges, the `cosmocc` compiler will rewrite binary
+objects after they've been compiled by GCC, so that the `%gs` register
+is used, rather than `%fs`. Morphing x86-64 binaries after they've been
+compiled is normally difficult, due to the complexity of the machine
+instruction language. However GCC provides `-mno-tls-direct-seg-refs`
+which greatly reduces the complexity of this task. This flag forgoes
+some optimizations to make the generated code simpler. Rather than doing
+clever arithmetic with `%fs` prefixes, the compiler will always generate
+the thread information block address load as a separate instruction.
+
+```c
+// Change AMD code to use %gs:0x30 instead of %fs:0
+// We assume -mno-tls-direct-seg-refs has been used
+static void ChangeTlsFsToGs(unsigned char *p, size_t n) {
+  unsigned char *e = p + n - 9;
+  while (p <= e) {
+    // we're checking for the following expression:
+    //   0144 == p[0] &&           // %fs
+    //   0110 == (p[1] & 0373) &&  // rex.w (and ignore rex.r)
+    //   (0213 == p[2] ||          // mov reg/mem → reg (word-sized)
+    //   0003 == p[2]) &&          // add reg/mem → reg (word-sized)
+    //   0004 == (p[3] & 0307) &&  // mod/rm (4,reg,0) means sib → reg
+    //   0045 == p[4] &&           // sib (5,4,0) → (rbp,rsp,0) → disp32
+    //   0000 == p[5] &&           // displacement (von Neumann endian)
+    //   0000 == p[6] &&           // displacement
+    //   0000 == p[7] &&           // displacement
+    //   0000 == p[8]              // displacement
+    uint64_t w = READ64LE(p) & READ64LE("\377\373\377\307\377\377\377\377");
+    if ((w == READ64LE("\144\110\213\004\045\000\000\000") ||
+         w == READ64LE("\144\110\003\004\045\000\000\000")) &&
+        !p[8]) {
+      p[0] = 0145;  // change %fs to %gs
+      p[5] = 0x30;  // change 0 to 0x30
+      p += 9;
+    } else {
+      ++p;
+    }
+  }
+}
+```
+
+By favoring `%gs` we've now ensured friction-free compatibility for the
+APE runtime on MacOS, Linux, and FreeBSD which are all able to conform
+easily to this convention. However additional work needs to be done at
+runtime when an APE program is started on Windows, OpenBSD, and NetBSD.
+On these platforms, all executable pages must be faulted and morphed to
+fixup the TLS instructions.
+
+On OpenBSD and NetBSD, this is as simple as undoing the example
+operation above. Earlier at compile-time we turned `%fs` into `%gs`.
+Now, at runtime, `%gs` must be turned back into `%fs`. Since the
+executable is morphing itself, this is easier said than done.
+
+OpenBSD for example enforces a `W^X` invariant. Code that's executing
+can't modify itself at the same time. The way Cosmopolitan solves this
+is by defining a special part of the binary called `.text.privileged`.
+This section is aligned to page boundaries. A GNU ld linker script is
+used to ensure that code which morphs code is placed into this section,
+through the use of a header-defined cosmo-specific keyword `privileged`.
+Additionally, the `fixupobj` program is used by the Cosmo build system
+to ensure that compiled objects don't contain privileged functions that
+call non-privileged functions. Needless to say, `mprotect()` needs to be
+a privileged function, so that it can be used to disable the execute bit
+on all other parts of the executable except for the privileged section,
+thereby making it writable. Once this has been done, code can change.
+
+On Windows the displacement bytes of the TLS instruction are changed to
+use the `%gs:0x1480+i*8` ABI where `i` is a number assigned by the WIN32
+`TlsAlloc()` API. This avoids the need to call `TlsGetValue()` which is
+implemented this exact same way under the hood. Even though 0x1480 isn't
+explicitly documented by MSDN, this ABI is believed to be stable because
+MSVC generates binaries that use this offset directly. The only caveat
+is that `TlsAlloc()` must be called as early in the runtime init as
+possible, to ensure an index less than 64 is returned.
+
+### Thread Information Block (TIB)
+
+The Actually Portable Executable Thread Information Block (TIB) is
+defined by this version of the specification as follows:
+
+- The 64-bit TIB self-pointer is stored at offset 0x00.
+- The 64-bit TIB self-pointer is also stored at offset 0x30.
+- The 32-bit `errno` value is stored at offset 0x3c.
+
+All other parts of the thread information block should be considered
+unspecified and therefore reserved for future specifications.
+
+The APE thread information block is aligned on a 64-byte boundary.
+
+Cosmopolitan Libc v3.5.8 (c. 2024-07-21) currently implements a thread
+information block that's 512 bytes in size.
+
+### Foreign Function Calls
+
+Even though APE programs always use the System V ABI, there arises the
+occasional need to interface with foreign functions, e.g. WIN32. The
+`__attribute__((__ms_abi__))` annotation introduced by GCC v6 is used
+for this purpose.
+
+The ability to change a function's ABI on a case-by-case basis is
+surprisingly enough supported by GCC, Clang, NVCC, and even the AMD HIP
+compilers for both UNIX systems and Windows. All of these compilers
+support both the System V ABI and the Microsoft x64 ABI.
+
+APE binaries will actually favor the Microsoft ABI even when running on
+UNIX OSes for certain dlopen() use-cases. For example, if we control the
+code to a CUDA module, which we compile on each OS separately from our
+main APE binary, then any function that's inside the APE binary whose
+pointer may be passed into a foreign module SHOULD be compiled to use
+the Microsoft ABI. This is because in practice the OS-specific module
+may need to be compiled by MSVC, where MS ABI is the *only* ABI, which
+forces our UNIX programs to partially conform. Thankfully, all UNIX
+compilers support doing it on a case-by-case basis.
+
+### Char Signedness
+
+Actually Portable Executable defines `char` as signed.
+
+Therefore conformant APE software MUST use `-fsigned-char` when building
+code for aarch64, as well as any other architecture that (unlike x86-64)
+would otherwise define `char` as being `unsigned char` by default.
+
+This decision was one of the cases where it made sense to offer a more
+consistent runtime experience for fat multi-arch binaries. However you
+SHOULD still write code to assume `char` can go either way. But if all
+you care about is using APE, then you CAN assume `char` is signed.
+
+### Long Double
+
+On AMD64 platforms, APE binaries define `long double` as 80-bit.
+
+On ARM64 platforms, APE binaries define `long double` as 128-bit.
+
+We accept inconsistency in this case, because hardware acceleration is
+far more valuable than stylistic consistency in the case of mathematics.
+
+One challenge arises on AMD64 for supporting `long double` across OSes.
+Unlike UNIX systems, the Windows Executive on x86-64 initializes the x87
+FPU to have double (64-bit) precision rather than 80-bit. That's because
+code compiled by MSVC treats `long double` as though it were `double` to
+prefer always using the more modern SSE instructions. However System V
+requires genuine 80-bit `long double` support on AMD64.
+
+Therefore, if an APE program detects that it's been started on a Windows
+x86-64 system, then it SHOULD use the following assembly to initialize
+the x87 FPU in System V ABI mode.
+
+```asm
+	fldcw	1f(%rip)
+	.rodata
+	.balign	2
+//	8087 FPU Control Word
+//	 IM: Invalid Operation ───────────────┐
+//	 DM: Denormal Operand ───────────────┐│
+//	 ZM: Zero Divide ───────────────────┐││
+//	 OM: Overflow ─────────────────────┐│││
+//	 UM: Underflow ───────────────────┐││││
+//	 PM: Precision ──────────────────┐│││││
+//	 PC: Precision Control ───────┐  ││││││
+//	  {float,∅,double,long double}│  ││││││
+//	 RC: Rounding Control ──────┐ │  ││││││
+//	  {even, →-∞, →+∞, →0}      │┌┤  ││││││
+//	                           ┌┤││  ││││││
+//	                          d││││rr││││││
+1:	.short	0b00000000000000000001101111111
+	.previous
+```
+
+## Executable File Alignment
+
+Actually Portable Executable is a statically-linked flat executable file
+format that is, as a thing in itself, agnostic to file alignments. For
+example, the shell script payload at the beginning of the file and its
+statements have no such requirements. Alignment requirements are however
+imposed by the executable formats that APE wraps.
+
+1. ELF requires that file offsets be congruent with virtual addresses
+   modulo the CPU page size. So when we add a shell script to the start
+   of an executable, we need to round up to the page size in order to
+   maintain ELF's invariant. Although no such roundup is required on the
+   program segments once the invariant is restored. ELF loaders will
+   happily map program headers from arbitrary file intervals (which may
+   overlap) onto arbitrarily virtual intervals (which don't need to be
+   contiguous). In order to do that, the loaders will generally use
+   UNIX's mmap() function which is more restrictive and only accepts
+   addresses and offsets that are page aligned. To make it possible to
+   map an unaligned ELF program header that could potentially start and
+   stop at any byte, ELF loaders round-out the intervals, which means
+   adjacent unrelated data might also get mapped, which may need to be
+   explicitly zero'd. Thanks to the cleverness of ELF, it's possible to
+   have an executable file be very tiny, without needing any alignment
+   bytes, and it'll be loaded into a properly aligned virtual space
+   where segments can be as sparse as we want them to be.
+
+2. PE doesn't care about congruence and instead defines two separate
+   kinds of alignment. First, PE requires that the layout of segment
+   memory inside the file be aligned on at minimum the classic 512 byte
+   MS-DOS page size. This means that, unlike ELF, some alignment padding
+   may need to be encoded into the file, making it slightly larger. Next
+   PE imposes an alignment restriction on segments once they've been
+   mapped into the virtual address space, which must be rounded to the
+   system page size. Like ELF, PE segments need to be properly ordered
+   but they're allowed to drift apart once mapped in a non-contiguous
+   sparsely mapped way. When inserting shell script content at the start
+   of a PE file, the most problematic thing is the need to round up to
+   the 64kb system granularity, which results in a lot of needless bytes
+   of padding being inserted by a naive second-pass linker.
+
+3. Apple's Mach-O format is the strictest of them all. While both ELF
+   and PE are defined in such a way that invites great creativity, XNU
+   will simply refuse to an executable that does anything creative with
+   alignment. All loaded segments need to both start and end on a page
+   aligned address. XNU also wants segments to be contiguous similar to
+   portable executable, except it applies to both the file and virtual
+   spaces, which must follow the same structure.
+
+Actually Portable Executables must conform to the strictest requirements
+demanded by the support vector. Therefore an APE binary that has headers
+for all three of the above executable formats MUST conform to the Apple
+way of doing things. GNU ld linker scripts aren't very good at producing
+ELF binaries that rigidly conform to this simple naive layout. There are
+so many ways things can go wrong, where third party code might slip its
+own custom section name in-between the linker script sections that are
+explicitly defined, thereby causing ELF's powerful features to manifest
+and the resulting content overlapping. The best `ld` flag that helps is
+`--orphan-handling=error` which can help with explaining such mysteries.
+
+While Cosmopolitan was originally defined to just use stock GNU tools,
+this proved intractable over time, and the project has been evolving in
+the direction of building its own. Inventing the `apelink` program was
+what enabled the project to achieve multi-architecture binaries whereas
+previously it was only possible to do multi-OS binaries. In the future,
+our hope is that a fast power linker like Mold can be adapted to produce
+fat APE binaries directly from object files in one pass.
+
+## Position Independent Code
+
+APE doesn't currently support position independent executable formats.
+This is because APE was originally written for the GNU linker, where PIC
+and PIE were after-thoughts and never fully incorporated with the older
+more powerful linker script techniques upon which APE relies. Future
+iterations of this specification are intended to converge on modern
+standards, as our tooling becomes developed enough to support it.
+
+However this only applies to the wrapped executable formats themselves.
+While our convention to date has been to always load ELF programs at the
+4mb mark, this is not guaranteed across OSes and architectures. Programs
+should have no expectations that a program will be loaded to any given
+address. For example, Cosmo currently implements APE on AARCH64 as
+loading executables to a starting address of 0x000800000000. This
+address occupies a sweet spot of requirements.
+
+## Address Space
+
+In order to create a single binary that supports as many platforms as
+possible without needing to be recompiled, there's a very narrow range
+of addresses that can be used. That range is somewhere between 32 bits
+and 39 bits.
+
+- Embedded devices that claim to be 64-bit will oftentimes only support
+  a virtual address space that's 39 bits in size.
+
+- We can't load executable images on AARCH64 beneath 0x100000000 (4gb)
+  because Apple forbids doing that, possibly in an effort to enforce a
+  best practice for spotting 32-bit to 64-bit transition bugs. Please
+  note that this restriction only applies to Apple ARM64 systems. The
+  x86-64 version of XNU will happily load APE binaries to 0x00400000.
+
+- The AMD64 architecture on desktops and servers can usually be counted
+  upon to provide a 47-bit address space. The Linux Kernel for instance
+  grants each userspace program full dominion over addresses 0x00200000
+  through 0x00007fffffffffff provided the hardware supports this. On
+  modern workstations supporting Intel and AMD's new PML5T feature which
+  virtualizes memory using a radix trie that's five layers deep, Linux
+  is able to offer userspace its choice of fixed addresses from
+  0x00200000 through 0x00ffffffffffffff. The only exception to this rule
+  we've encountered so far is that Windows 7 and Windows Vista behaved
+  similar to embedded devices in reducing the number of va bits.
+
+## Page Size
+
+APE software MUST be page size agnostic. For many years the industry had
+converged on a strong consensus of having a page size that's 4096 bytes.
+However this convention was never guaranteed. New computers have become
+extremely popular, such as Apple Silicon, that use a 16kb page size.
+
+By convention, Cosmopolitan Libc currently generates ELF headers for
+x86-64 that are strictly aligned on a 4096-byte page size. On ARM64
+Cosmopolitan is currently implemented to always generate ELF headers
+aligned on a 16kb page size.
+
+In addition to being page size agnostic, APE software that cares about
+working correctly on Windows needs to be aware of the concept of
+allocation granularity. While the page size on Windows is generally 4kb
+in size, memory mappings can only be created on addresses that aligned
+to the system allocation granularity, which is generally 64kb. If you
+use a function like mmap() with Cosmopolitan Libc, then the `addr` and
+`offset` parameters need to be aligned to `sysconf(_SC_GRANSIZE)` or
+else your software won't work on Windows. Windows has other limitations
+too, such as lacking the ability to carve or punch holes in mappings.
diff --git a/ape/start.S b/ape/start.S
index c148966e1..e497fc852 100644
--- a/ape/start.S
+++ b/ape/start.S
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "ape/ape.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #ifdef __aarch64__
 
diff --git a/ape/systemcall.S b/ape/systemcall.S
index c98632fd5..91daedc95 100644
--- a/ape/systemcall.S
+++ b/ape/systemcall.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Invokes system call.
 //
diff --git a/build/bootstrap/ape.aarch64 b/build/bootstrap/ape.aarch64
index 2421e7248..794864ad0 100755
Binary files a/build/bootstrap/ape.aarch64 and b/build/bootstrap/ape.aarch64 differ
diff --git a/build/bootstrap/ape.elf b/build/bootstrap/ape.elf
index 5ffffe84b..db75ffb3a 100755
Binary files a/build/bootstrap/ape.elf and b/build/bootstrap/ape.elf differ
diff --git a/build/bootstrap/ape.macho b/build/bootstrap/ape.macho
index d6d22567b..77bcfb233 100755
Binary files a/build/bootstrap/ape.macho and b/build/bootstrap/ape.macho differ
diff --git a/build/bootstrap/ar b/build/bootstrap/ar
deleted file mode 100755
index 0a671a3b1..000000000
Binary files a/build/bootstrap/ar and /dev/null differ
diff --git a/build/bootstrap/chmod b/build/bootstrap/chmod
deleted file mode 100755
index e42818495..000000000
Binary files a/build/bootstrap/chmod and /dev/null differ
diff --git a/build/bootstrap/cocmd b/build/bootstrap/cocmd
index 58ecb0a0d..f16d26c8d 100755
Binary files a/build/bootstrap/cocmd and b/build/bootstrap/cocmd differ
diff --git a/build/bootstrap/compile b/build/bootstrap/compile
deleted file mode 100755
index 3fb641378..000000000
Binary files a/build/bootstrap/compile and /dev/null differ
diff --git a/build/bootstrap/cp b/build/bootstrap/cp
deleted file mode 100755
index de2d52a67..000000000
Binary files a/build/bootstrap/cp and /dev/null differ
diff --git a/build/bootstrap/echo b/build/bootstrap/echo
deleted file mode 100755
index 6ce62f8bd..000000000
Binary files a/build/bootstrap/echo and /dev/null differ
diff --git a/build/bootstrap/fixupobj b/build/bootstrap/fixupobj
deleted file mode 100755
index b59b55a5b..000000000
Binary files a/build/bootstrap/fixupobj and /dev/null differ
diff --git a/build/bootstrap/gzip b/build/bootstrap/gzip
deleted file mode 100755
index 09bd2306b..000000000
Binary files a/build/bootstrap/gzip and /dev/null differ
diff --git a/build/bootstrap/make b/build/bootstrap/make
deleted file mode 100755
index 48aba621f..000000000
Binary files a/build/bootstrap/make and /dev/null differ
diff --git a/build/bootstrap/mkdeps b/build/bootstrap/mkdeps
deleted file mode 100755
index 30b5e5f06..000000000
Binary files a/build/bootstrap/mkdeps and /dev/null differ
diff --git a/build/bootstrap/mkdir b/build/bootstrap/mkdir
deleted file mode 100755
index 4c359071e..000000000
Binary files a/build/bootstrap/mkdir and /dev/null differ
diff --git a/build/bootstrap/objbincopy b/build/bootstrap/objbincopy
deleted file mode 100755
index 8cce21b7c..000000000
Binary files a/build/bootstrap/objbincopy and /dev/null differ
diff --git a/build/bootstrap/package b/build/bootstrap/package
deleted file mode 100755
index 1c7db4131..000000000
Binary files a/build/bootstrap/package and /dev/null differ
diff --git a/build/bootstrap/pecheck b/build/bootstrap/pecheck
deleted file mode 100755
index 6536a79bf..000000000
Binary files a/build/bootstrap/pecheck and /dev/null differ
diff --git a/build/bootstrap/rm b/build/bootstrap/rm
deleted file mode 100755
index 85f08d8b8..000000000
Binary files a/build/bootstrap/rm and /dev/null differ
diff --git a/build/bootstrap/rollup b/build/bootstrap/rollup
deleted file mode 100755
index 47d2d505c..000000000
Binary files a/build/bootstrap/rollup and /dev/null differ
diff --git a/build/bootstrap/touch b/build/bootstrap/touch
deleted file mode 100755
index 7b6bc4943..000000000
Binary files a/build/bootstrap/touch and /dev/null differ
diff --git a/build/bootstrap/zipcopy b/build/bootstrap/zipcopy
deleted file mode 100755
index 8023194c7..000000000
Binary files a/build/bootstrap/zipcopy and /dev/null differ
diff --git a/build/bootstrap/zipobj b/build/bootstrap/zipobj
deleted file mode 100755
index 019751ea1..000000000
Binary files a/build/bootstrap/zipobj and /dev/null differ
diff --git a/build/config.mk b/build/config.mk
index 5167a824d..c18308725 100644
--- a/build/config.mk
+++ b/build/config.mk
@@ -14,7 +14,6 @@ ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CCFLAGS += -O2 $(BACKTRACES)
 CONFIG_CPPFLAGS += -DSYSDEBUG
-TARGET_ARCH ?= -msse3
 endif
 ifeq ($(MODE), x86_64)
 ENABLE_FTRACE = 1
@@ -64,7 +63,6 @@ ENABLE_FTRACE = 1
 CONFIG_CCFLAGS += $(BACKTRACES) -O
 CONFIG_CPPFLAGS += -DSYSDEBUG -DDWARFLESS
 CONFIG_LDFLAGS += -S
-TARGET_ARCH ?= -msse3
 endif
 
 # Optimized Mode
@@ -84,7 +82,7 @@ ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG
 CONFIG_CCFLAGS += $(BACKTRACES) -O3 -fmerge-all-constants
-TARGET_ARCH ?= -march=native
+CONFIG_TARGET_ARCH ?= -march=native
 endif
 
 # Optimized Linux Mode
@@ -102,7 +100,20 @@ CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
 CONFIG_CCFLAGS += -O3 -fmerge-all-constants
 CONFIG_COPTS += -mred-zone
-TARGET_ARCH ?= -march=native
+CONFIG_TARGET_ARCH ?= -march=native
+endif
+ifeq ($(MODE), x86_64-optlinux)
+CONFIG_OFLAGS ?= -g -ggdb
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS += -O3 -fmerge-all-constants
+CONFIG_COPTS += -mred-zone
+CONFIG_TARGET_ARCH ?= -march=native
+endif
+ifeq ($(MODE), aarch64-optlinux)
+CONFIG_OFLAGS ?= -g -ggdb
+CONFIG_CPPFLAGS += -DNDEBUG -DSYSDEBUG -DSUPPORT_VECTOR=1
+CONFIG_CCFLAGS += -O3 -fmerge-all-constants
+CONFIG_COPTS += -mred-zone
 endif
 
 # Release Mode
@@ -123,7 +134,6 @@ endif
 ifeq ($(MODE), rel)
 CONFIG_CPPFLAGS += -DNDEBUG -DDWARFLESS
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
-TARGET_ARCH ?= -msse3
 PYFLAGS += -O1
 endif
 
@@ -139,18 +149,32 @@ endif
 ifeq ($(MODE), dbg)
 ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
-CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__
-CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline
+OVERRIDE_CFLAGS += -O0
+OVERRIDE_CXXFLAGS += -O0
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__ -Wno-unused-variable -Wno-unused-but-set-variable
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG
+CONFIG_COPTS += -fsanitize=undefined
+OVERRIDE_CCFLAGS += -fno-pie
+QUOTA ?= -C64 -L300
+endif
+ifeq ($(MODE), x86_64-dbg)
+ENABLE_FTRACE = 1
+CONFIG_OFLAGS ?= -g -ggdb
+OVERRIDE_CFLAGS += -O0
+OVERRIDE_CXXFLAGS += -O0
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__ -Wno-unused-variable -Wno-unused-but-set-variable
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG
 CONFIG_COPTS += -fsanitize=undefined
-TARGET_ARCH ?= -msse3
 OVERRIDE_CCFLAGS += -fno-pie
 QUOTA ?= -C64 -L300
 endif
 ifeq ($(MODE), aarch64-dbg)
 ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
-CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__
-CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O0 -fno-inline -fdce
+OVERRIDE_CFLAGS += -O0 -fdce
+OVERRIDE_CXXFLAGS += -O0 -fdce
+CONFIG_CPPFLAGS += -DMODE_DBG -D__SANITIZE_UNDEFINED__ -Wno-unused-variable -Wno-unused-but-set-variable
+CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG
 CONFIG_COPTS += -fsanitize=undefined
 QUOTA ?= -C64 -L300
 endif
@@ -170,7 +194,6 @@ ENABLE_FTRACE = 1
 CONFIG_OFLAGS ?= -g -ggdb
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
 CONFIG_CPPFLAGS += -DSYSDEBUG -DSUPPORT_VECTOR=121
-TARGET_ARCH ?= -msse3
 endif
 
 # Tiny Mode
@@ -200,8 +223,6 @@ CONFIG_CCFLAGS +=			\
 	-momit-leaf-frame-pointer	\
 	-foptimize-sibling-calls	\
 	-DDWARFLESS
-TARGET_ARCH ?=				\
-	-msse3
 PYFLAGS +=				\
 	-O2				\
 	-B
@@ -221,8 +242,6 @@ CONFIG_CCFLAGS +=			\
 	-momit-leaf-frame-pointer	\
 	-foptimize-sibling-calls	\
 	-DDWARFLESS
-TARGET_ARCH ?=				\
-	-msse3
 PYFLAGS +=				\
 	-O2				\
 	-B
@@ -274,8 +293,6 @@ CONFIG_CCFLAGS +=			\
 	-fno-align-jumps		\
 	-fno-align-labels		\
 	-fno-align-loops
-TARGET_ARCH ?=				\
-	-msse3
 endif
 
 # Linux+BSD Tiny Mode
@@ -305,8 +322,6 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=			\
-	-msse3
 endif
 
 # Unix Tiny Mode
@@ -335,8 +350,6 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=			\
-	-msse3
 endif
 
 # Tiny Metallic Unix Mode
@@ -365,8 +378,6 @@ CONFIG_CCFLAGS +=		\
 	-fno-align-jumps	\
 	-fno-align-labels	\
 	-fno-align-loops
-TARGET_ARCH ?=			\
-	-msse3
 endif
 
 # no x87 instructions mode
@@ -388,7 +399,6 @@ ENABLE_FTRACE = 1
 CONFIG_COPTS += -mlong-double-64
 CONFIG_CCFLAGS += $(BACKTRACES) -O2
 CONFIG_CPPFLAGS += -DSYSDEBUG -DNOX87
-TARGET_ARCH ?= -msse3
 endif
 
 # LLVM Mode
@@ -401,7 +411,6 @@ endif
 #
 ifeq ($(MODE), llvm)
 .STRICT = 0
-TARGET_ARCH ?= -msse3
 CONFIG_CCFLAGS += $(BACKTRACES) -DSYSDEBUG -O2
 AS = clang
 CC = clang
@@ -444,7 +453,6 @@ ifeq ($(MODE), ansi)
 CONFIG_CFLAGS += -std=c11
 #CONFIG_CPPFLAGS += -ansi
 CONFIG_CXXFLAGS += -std=c++11
-TARGET_ARCH ?= -msse3
 endif
 
 ifneq ($(ENABLE_FTRACE),)
@@ -502,3 +510,5 @@ ifeq ($(ARCH), aarch64)
 CONFIG_CCFLAGS += -fpatchable-function-entry=7,6
 endif
 endif
+
+TARGET_ARCH ?= $(CONFIG_TARGET_ARCH)
diff --git a/build/definitions.mk b/build/definitions.mk
index 000d0a187..6682f79b7 100644
--- a/build/definitions.mk
+++ b/build/definitions.mk
@@ -92,10 +92,7 @@ DEFAULT_COPTS ?=							\
 	-fno-gnu-unique							\
 	-fstrict-aliasing						\
 	-fstrict-overflow						\
-	-fno-semantic-interposition					\
-	-fno-dwarf2-cfi-asm						\
-	-fno-unwind-tables						\
-	-fno-asynchronous-unwind-tables
+	-fno-semantic-interposition
 
 ifeq ($(ARCH), x86_64)
 # Microsoft says "[a]ny memory below the stack beyond the red zone
@@ -115,14 +112,10 @@ ifeq ($(ARCH), aarch64)
 # - Cosmopolitan Libc uses x28 for thread-local storage because Apple
 #   forbids us from using tpidr_el0 too.
 #
-# - Cosmopolitan currently lacks an implementation of the runtime
-#   libraries needed by the -moutline-atomics flag
-#
 DEFAULT_COPTS +=							\
 	-ffixed-x18							\
 	-ffixed-x28							\
-	-fsigned-char							\
-	-mno-outline-atomics
+	-fsigned-char
 endif
 
 MATHEMATICAL =								\
@@ -139,12 +132,10 @@ DEFAULT_CPPFLAGS +=							\
 	-isystem libc/isystem
 
 DEFAULT_CFLAGS =							\
-	-std=gnu2x
+	-std=gnu23
 
 DEFAULT_CXXFLAGS =							\
-	-std=gnu++20							\
-	-fno-rtti							\
-	-fno-exceptions							\
+	-std=gnu++23							\
 	-fuse-cxa-atexit						\
 	-Wno-int-in-bool-context					\
 	-Wno-narrowing							\
diff --git a/build/download-cosmocc.sh b/build/download-cosmocc.sh
index 13310a4e4..52c89b091 100755
--- a/build/download-cosmocc.sh
+++ b/build/download-cosmocc.sh
@@ -99,3 +99,8 @@ rm -f cosmocc.zip cosmocc.zip.sha256sum
 # commit output directory
 cd "${OLDPWD}" || die
 mv "${OUTPUT_TMP}" "${OUTPUT_DIR}" || die
+
+# update current symlink
+BASE=$(basename "${OUTPUT_DIR}")
+DIR=$(dirname "${OUTPUT_DIR}")
+ln -sfn "$BASE" "$DIR/current"
diff --git a/build/objdump b/build/objdump
index f1acb58a5..358d8f4c8 100755
--- a/build/objdump
+++ b/build/objdump
@@ -6,14 +6,14 @@ if [ -n "$OBJDUMP" ]; then
 fi
 
 find_objdump() {
-  if [ -x .cosmocc/3.3.5/bin/$1-linux-cosmo-objdump ]; then
-    OBJDUMP=.cosmocc/3.3.5/bin/$1-linux-cosmo-objdump
-  elif [ -x .cosmocc/3.3.5/bin/$1-linux-musl-objdump ]; then
-    OBJDUMP=.cosmocc/3.3.5/bin/$1-linux-musl-objdump
-  elif [ -x "$COSMO/.cosmocc/3.3.5/bin/$1-linux-cosmo-objdump" ]; then
-    OBJDUMP="$COSMO/.cosmocc/3.3.5/bin/$1-linux-cosmo-objdump"
-  elif [ -x "$COSMO/.cosmocc/3.3.5/bin/$1-linux-musl-objdump" ]; then
-    OBJDUMP="$COSMO/.cosmocc/3.3.5/bin/$1-linux-musl-objdump"
+  if [ -x .cosmocc/3.9.2/bin/$1-linux-cosmo-objdump ]; then
+    OBJDUMP=.cosmocc/3.9.2/bin/$1-linux-cosmo-objdump
+  elif [ -x .cosmocc/3.9.2/bin/$1-linux-musl-objdump ]; then
+    OBJDUMP=.cosmocc/3.9.2/bin/$1-linux-musl-objdump
+  elif [ -x "$COSMO/.cosmocc/3.9.2/bin/$1-linux-cosmo-objdump" ]; then
+    OBJDUMP="$COSMO/.cosmocc/3.9.2/bin/$1-linux-cosmo-objdump"
+  elif [ -x "$COSMO/.cosmocc/3.9.2/bin/$1-linux-musl-objdump" ]; then
+    OBJDUMP="$COSMO/.cosmocc/3.9.2/bin/$1-linux-musl-objdump"
   else
     echo "error: toolchain not found (try running 'cosmocc --update' or 'make' in the cosmo monorepo)" >&2
     exit 1
diff --git a/build/run b/build/run
index c7fc0c292..079bc9991 100755
--- a/build/run
+++ b/build/run
@@ -4,5 +4,5 @@ UNAMES=$(uname -s)
 if [ x"$UNAMES" = x"Darwin" ] && [ x"$UNAMEM" = x"arm64" ]; then
   exec ape "$@"
 else
-  exec "$@"
+  exec rusage "$@"
 fi
diff --git a/build/sanitycheck b/build/sanitycheck
index 7808571f4..2ed283ee5 100755
--- a/build/sanitycheck
+++ b/build/sanitycheck
@@ -31,7 +31,7 @@ if [ ! -f /proc/sys/fs/binfmt_misc/status ]; then
   exit 0
 fi
 
-if ! build/bootstrap/echo.com -n; then
+if ! build/bootstrap/echo -n; then
   cat <<'EOF' >&2
 
 ERROR
diff --git a/ctl/BUILD.mk b/ctl/BUILD.mk
index ac613db1e..3db733319 100644
--- a/ctl/BUILD.mk
+++ b/ctl/BUILD.mk
@@ -18,7 +18,13 @@ CTL_A_CHECKS =						\
 CTL_A_DIRECTDEPS =					\
 	LIBC_INTRIN					\
 	LIBC_MEM					\
+	LIBC_NEXGEN32E					\
+	LIBC_STDIO					\
 	LIBC_STR					\
+	THIRD_PARTY_DOUBLECONVERSION			\
+	THIRD_PARTY_GDTOA				\
+	THIRD_PARTY_LIBCXXABI				\
+	THIRD_PARTY_LIBUNWIND				\
 
 CTL_A_DEPS := $(call uniq,$(foreach x,$(CTL_A_DIRECTDEPS),$($(x))))
 
@@ -36,6 +42,7 @@ $(CTL_A_OBJS): private					\
 			-Walloca-larger-than=4096	\
 			-ffunction-sections		\
 			-fdata-sections			\
+			-fexceptions			\
 
 CTL_LIBS = $(foreach x,$(CTL_ARTIFACTS),$($(x)))
 CTL_SRCS = $(foreach x,$(CTL_ARTIFACTS),$($(x)_SRCS))
diff --git a/ctl/accumulate.h b/ctl/accumulate.h
new file mode 100644
index 000000000..786e10321
--- /dev/null
+++ b/ctl/accumulate.h
@@ -0,0 +1,28 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ACCUMULATE_H_
+#define CTL_ACCUMULATE_H_
+
+namespace ctl {
+
+template<class InputIt, class T>
+constexpr T
+accumulate(InputIt first, InputIt last, T init)
+{
+    for (; first != last; ++first)
+        init = init + *first;
+    return init;
+}
+
+template<class InputIt, class T, class BinaryOperation>
+constexpr T
+accumulate(InputIt first, InputIt last, T init, BinaryOperation op)
+{
+    for (; first != last; ++first)
+        init = op(init, *first);
+    return init;
+}
+
+} // namespace ctl
+
+#endif // CTL_ACCUMULATE_H_
diff --git a/ctl/add_lvalue_reference.h b/ctl/add_lvalue_reference.h
new file mode 100644
index 000000000..9d0c48b1d
--- /dev/null
+++ b/ctl/add_lvalue_reference.h
@@ -0,0 +1,55 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ADD_LVALUE_REFERENCE_H_
+#define CTL_ADD_LVALUE_REFERENCE_H_
+
+namespace ctl {
+
+template<typename T>
+struct add_lvalue_reference
+{
+    typedef T& type;
+};
+
+template<typename T>
+struct add_lvalue_reference<T&>
+{
+    typedef T& type;
+};
+
+template<typename T>
+struct add_lvalue_reference<T&&>
+{
+    typedef T& type;
+};
+
+template<>
+struct add_lvalue_reference<void>
+{
+    typedef void type;
+};
+
+template<>
+struct add_lvalue_reference<const void>
+{
+    typedef const void type;
+};
+
+template<>
+struct add_lvalue_reference<volatile void>
+{
+    typedef volatile void type;
+};
+
+template<>
+struct add_lvalue_reference<const volatile void>
+{
+    typedef const volatile void type;
+};
+
+template<typename T>
+using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+
+} // namespace ctl
+
+#endif // CTL_ADD_LVALUE_REFERENCE_H_
diff --git a/ctl/add_pointer.h b/ctl/add_pointer.h
new file mode 100644
index 000000000..005a4a09a
--- /dev/null
+++ b/ctl/add_pointer.h
@@ -0,0 +1,43 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ADD_POINTER_H_
+#define CTL_ADD_POINTER_H_
+#include "remove_reference.h"
+
+namespace ctl {
+
+// Primary template
+template<typename T>
+struct add_pointer
+{
+    typedef typename remove_reference<T>::type* type;
+};
+
+// Specialization for functions
+template<typename R, typename... Args>
+struct add_pointer<R(Args...)>
+{
+    typedef R (*type)(Args...);
+};
+
+// Specialization for function references
+template<typename R, typename... Args>
+struct add_pointer<R (&)(Args...)>
+{
+    typedef R (*type)(Args...);
+};
+
+// Specialization for rvalue references to functions
+template<typename R, typename... Args>
+struct add_pointer<R (&&)(Args...)>
+{
+    typedef R (*type)(Args...);
+};
+
+// Helper alias template (C++14 and later)
+template<typename T>
+using add_pointer_t = typename add_pointer<T>::type;
+
+} // namespace ctl
+
+#endif // CTL_ADD_POINTER_H_
diff --git a/ctl/addressof.h b/ctl/addressof.h
new file mode 100644
index 000000000..713598bf8
--- /dev/null
+++ b/ctl/addressof.h
@@ -0,0 +1,29 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ADDRESSOF_H_
+#define CTL_ADDRESSOF_H_
+
+namespace ctl {
+
+template<typename T>
+T*
+addressof(T& arg) noexcept
+{
+    return reinterpret_cast<T*>(
+      &const_cast<char&>(reinterpret_cast<const volatile char&>(arg)));
+}
+
+template<typename R, typename... Args>
+R (*addressof(R (*&arg)(Args...)) noexcept)
+(Args...)
+{
+    return arg;
+}
+
+template<typename T>
+T*
+addressof(T&&) = delete;
+
+} // namespace ctl
+
+#endif // CTL_ADDRESSOF_H_
diff --git a/ctl/advance.h b/ctl/advance.h
new file mode 100644
index 000000000..e0408c680
--- /dev/null
+++ b/ctl/advance.h
@@ -0,0 +1,24 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ADVANCE_H_
+#define CTL_ADVANCE_H_
+
+namespace ctl {
+
+template<class InputIt, class Distance>
+constexpr void
+advance(InputIt& it, Distance n)
+{
+    while (n > 0) {
+        --n;
+        ++it;
+    }
+    while (n < 0) {
+        ++n;
+        --it;
+    }
+}
+
+} // namespace ctl
+
+#endif // CTL_ADVANCE_H_
diff --git a/ctl/all_of.h b/ctl/all_of.h
new file mode 100644
index 000000000..0c258bc4a
--- /dev/null
+++ b/ctl/all_of.h
@@ -0,0 +1,20 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ALL_OF_H_
+#define CTL_ALL_OF_H_
+
+namespace ctl {
+
+template<class InputIt, class UnaryPredicate>
+constexpr bool
+all_of(InputIt first, InputIt last, UnaryPredicate p)
+{
+    for (; first != last; ++first)
+        if (!p(*first))
+            return false;
+    return true;
+}
+
+} // namespace ctl
+
+#endif // CTL_ALL_OF_H_
diff --git a/ctl/allocator.h b/ctl/allocator.h
new file mode 100644
index 000000000..3a593d363
--- /dev/null
+++ b/ctl/allocator.h
@@ -0,0 +1,94 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ALLOCATOR_H_
+#define CTL_ALLOCATOR_H_
+#include "bad_alloc.h"
+#include "integral_constant.h"
+#include "new.h"
+#include "utility.h"
+
+namespace ctl {
+
+template<typename T>
+class allocator
+{
+  public:
+    using value_type = T;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using propagate_on_container_move_assignment = ctl::true_type;
+    using is_always_equal = ctl::true_type;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using reference = T&;
+    using const_reference = const T&;
+
+    constexpr allocator() noexcept = default;
+
+    constexpr allocator(const allocator&) noexcept = default;
+
+    template<class U>
+    constexpr allocator(const allocator<U>&) noexcept
+    {
+    }
+
+    constexpr ~allocator() = default;
+
+    [[nodiscard]] T* allocate(size_type n)
+    {
+        if (n > __SIZE_MAX__ / sizeof(T))
+            throw ctl::bad_alloc();
+        if (auto p = static_cast<T*>(::operator new(
+              n * sizeof(T), ctl::align_val_t(alignof(T)), ctl::nothrow)))
+            return p;
+        throw ctl::bad_alloc();
+    }
+
+    void deallocate(T* p, size_type n) noexcept
+    {
+        ::operator delete(p, n * sizeof(T), ctl::align_val_t(alignof(T)));
+    }
+
+    template<typename U, typename... Args>
+    void construct(U* p, Args&&... args)
+    {
+        ::new (static_cast<void*>(p)) U(ctl::forward<Args>(args)...);
+    }
+
+    template<typename U>
+    void destroy(U* p)
+    {
+        p->~U();
+    }
+
+    size_type max_size() const noexcept
+    {
+        return __SIZE_MAX__ / sizeof(T);
+    }
+
+    allocator& operator=(const allocator&) = default;
+
+    template<typename U>
+    struct rebind
+    {
+        using other = allocator<U>;
+    };
+};
+
+template<class T, class U>
+bool
+operator==(const allocator<T>&, const allocator<U>&) noexcept
+{
+    return true;
+}
+
+template<class T, class U>
+bool
+operator!=(const allocator<T>&, const allocator<U>&) noexcept
+{
+    return false;
+}
+
+} // namespace ctl
+
+#endif // CTL_ALLOCATOR_H_
diff --git a/ctl/allocator_traits.h b/ctl/allocator_traits.h
new file mode 100644
index 000000000..155a71bcf
--- /dev/null
+++ b/ctl/allocator_traits.h
@@ -0,0 +1,70 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ALLOCATOR_TRAITS_H_
+#define CTL_ALLOCATOR_TRAITS_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename Alloc>
+struct allocator_traits
+{
+    using allocator_type = Alloc;
+    using value_type = typename Alloc::value_type;
+    using pointer = typename Alloc::value_type*;
+    using const_pointer = const typename Alloc::value_type*;
+    using void_pointer = void*;
+    using const_void_pointer = const void*;
+    using difference_type = ptrdiff_t;
+    using size_type = size_t;
+
+    using propagate_on_container_copy_assignment = ctl::false_type;
+    using propagate_on_container_move_assignment = ctl::true_type;
+    using propagate_on_container_swap = ctl::false_type;
+    using is_always_equal = ctl::true_type;
+
+    template<typename T>
+    struct rebind_alloc
+    {
+        using other = typename Alloc::template rebind<T>::other;
+    };
+
+    template<typename T>
+    using rebind_traits = allocator_traits<typename rebind_alloc<T>::other>;
+
+    static pointer allocate(Alloc& a, size_type n)
+    {
+        return a.allocate(n);
+    }
+
+    static void deallocate(Alloc& a, pointer p, size_type n)
+    {
+        a.deallocate(p, n);
+    }
+
+    template<typename T, typename... Args>
+    static void construct(Alloc& a, T* p, Args&&... args)
+    {
+        ::new ((void*)p) T(static_cast<Args&&>(args)...);
+    }
+
+    template<typename T>
+    static void destroy(Alloc& a, T* p)
+    {
+        p->~T();
+    }
+
+    static size_type max_size(const Alloc& a) noexcept
+    {
+        return a.max_size();
+    }
+
+    static Alloc select_on_container_copy_construction(const Alloc& a)
+    {
+        return a;
+    }
+};
+
+} // namespace ctl
+
+#endif // CTL_ALLOCATOR_TRAITS_H_
diff --git a/ctl/any_of.h b/ctl/any_of.h
new file mode 100644
index 000000000..09c9bcfbd
--- /dev/null
+++ b/ctl/any_of.h
@@ -0,0 +1,20 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ANY_OF_H_
+#define CTL_ANY_OF_H_
+
+namespace ctl {
+
+template<class InputIt, class UnaryPredicate>
+constexpr bool
+any_of(InputIt first, InputIt last, UnaryPredicate p)
+{
+    for (; first != last; ++first)
+        if (p(*first))
+            return true;
+    return false;
+}
+
+} // namespace ctl
+
+#endif // CTL_ANY_OF_H_
diff --git a/ctl/array.h b/ctl/array.h
new file mode 100644
index 000000000..5e532392f
--- /dev/null
+++ b/ctl/array.h
@@ -0,0 +1,248 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ARRAY_H_
+#define CTL_ARRAY_H_
+#include "initializer_list.h"
+#include "out_of_range.h"
+#include "reverse_iterator.h"
+
+namespace ctl {
+
+template<typename T, size_t N>
+struct array
+{
+    using value_type = T;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using pointer = value_type*;
+    using const_pointer = const value_type*;
+    using iterator = value_type*;
+    using const_iterator = const value_type*;
+    using reverse_iterator = ctl::reverse_iterator<iterator>;
+    using const_reverse_iterator = ctl::reverse_iterator<const_iterator>;
+
+    T elems[N];
+
+    constexpr array() = default;
+
+    constexpr array(std::initializer_list<T> init)
+    {
+        auto it = init.begin();
+        for (size_t i = 0; i < N && it != init.end(); ++i, ++it)
+            elems[i] = *it;
+    }
+
+    constexpr reference at(size_type pos)
+    {
+        if (pos >= N)
+            throw ctl::out_of_range();
+        return elems[pos];
+    }
+
+    constexpr const_reference at(size_type pos) const
+    {
+        if (pos >= N)
+            throw ctl::out_of_range();
+        return elems[pos];
+    }
+
+    constexpr reference operator[](size_type pos)
+    {
+        if (pos >= N)
+            __builtin_trap();
+        return elems[pos];
+    }
+
+    constexpr const_reference operator[](size_type pos) const
+    {
+        if (pos >= N)
+            __builtin_trap();
+        return elems[pos];
+    }
+
+    constexpr reference front()
+    {
+        return elems[0];
+    }
+
+    constexpr const_reference front() const
+    {
+        return elems[0];
+    }
+
+    constexpr reference back()
+    {
+        return elems[N - 1];
+    }
+
+    constexpr const_reference back() const
+    {
+        return elems[N - 1];
+    }
+
+    constexpr T* data() noexcept
+    {
+        return elems;
+    }
+
+    constexpr const T* data() const noexcept
+    {
+        return elems;
+    }
+
+    constexpr iterator begin() noexcept
+    {
+        return elems;
+    }
+
+    constexpr const_iterator begin() const noexcept
+    {
+        return elems;
+    }
+
+    constexpr iterator end() noexcept
+    {
+        return elems + N;
+    }
+
+    constexpr const_iterator end() const noexcept
+    {
+        return elems + N;
+    }
+
+    constexpr reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    constexpr const_reverse_iterator rbegin() const noexcept
+    {
+        return const_reverse_iterator(end());
+    }
+
+    constexpr reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    constexpr const_reverse_iterator rend() const noexcept
+    {
+        return const_reverse_iterator(begin());
+    }
+
+    constexpr const_iterator cbegin() const noexcept
+    {
+        return begin();
+    }
+
+    constexpr const_iterator cend() const noexcept
+    {
+        return end();
+    }
+
+    constexpr const_reverse_iterator crbegin() const noexcept
+    {
+        return rbegin();
+    }
+
+    constexpr const_reverse_iterator crend() const noexcept
+    {
+        return rend();
+    }
+
+    constexpr bool empty() const noexcept
+    {
+        return N == 0;
+    }
+
+    constexpr size_type size() const noexcept
+    {
+        return N;
+    }
+
+    constexpr size_type max_size() const noexcept
+    {
+        return N;
+    }
+
+    void fill(const T& value)
+    {
+        for (size_type i = 0; i < N; ++i) {
+            elems[i] = value;
+        }
+    }
+
+    void swap(array& other) noexcept
+    {
+        for (size_type i = 0; i < N; ++i) {
+            T temp = elems[i];
+            elems[i] = other.elems[i];
+            other.elems[i] = temp;
+        }
+    }
+};
+
+template<typename T, size_t N>
+bool
+operator==(const array<T, N>& lhs, const array<T, N>& rhs)
+{
+    for (size_t i = 0; i < N; ++i) {
+        if (!(lhs[i] == rhs[i]))
+            return false;
+    }
+    return true;
+}
+
+template<typename T, size_t N>
+bool
+operator!=(const array<T, N>& lhs, const array<T, N>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<typename T, size_t N>
+bool
+operator<(const array<T, N>& lhs, const array<T, N>& rhs)
+{
+    for (size_t i = 0; i < N; ++i) {
+        if (lhs[i] < rhs[i])
+            return true;
+        if (rhs[i] < lhs[i])
+            return false;
+    }
+    return false;
+}
+
+template<typename T, size_t N>
+bool
+operator<=(const array<T, N>& lhs, const array<T, N>& rhs)
+{
+    return !(rhs < lhs);
+}
+
+template<typename T, size_t N>
+bool
+operator>(const array<T, N>& lhs, const array<T, N>& rhs)
+{
+    return rhs < lhs;
+}
+
+template<typename T, size_t N>
+bool
+operator>=(const array<T, N>& lhs, const array<T, N>& rhs)
+{
+    return !(lhs < rhs);
+}
+
+template<typename T, size_t N>
+void
+swap(array<T, N>& lhs, array<T, N>& rhs) noexcept
+{
+    lhs.swap(rhs);
+}
+
+} // namespace ctl
+
+#endif // CTL_ARRAY_H_
diff --git a/ctl/back_inserter.h b/ctl/back_inserter.h
new file mode 100644
index 000000000..667f95924
--- /dev/null
+++ b/ctl/back_inserter.h
@@ -0,0 +1,64 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_BACK_INSERTER_H_
+#define CTL_BACK_INSERTER_H_
+#include "iterator.h"
+#include "utility.h"
+
+namespace ctl {
+
+template<class Container>
+class back_insert_iterator
+{
+  protected:
+    Container* container;
+
+  public:
+    using iterator_category = ctl::output_iterator_tag;
+    using value_type = void;
+    using difference_type = void;
+    using pointer = void;
+    using reference = void;
+
+    explicit back_insert_iterator(Container& c) : container(&c)
+    {
+    }
+
+    back_insert_iterator& operator=(const typename Container::value_type& value)
+    {
+        container->push_back(value);
+        return *this;
+    }
+
+    back_insert_iterator& operator=(typename Container::value_type&& value)
+    {
+        container->push_back(ctl::move(value));
+        return *this;
+    }
+
+    back_insert_iterator& operator*()
+    {
+        return *this;
+    }
+
+    back_insert_iterator& operator++()
+    {
+        return *this;
+    }
+
+    back_insert_iterator operator++(int)
+    {
+        return *this;
+    }
+};
+
+template<class Container>
+back_insert_iterator<Container>
+back_inserter(Container& c)
+{
+    return back_insert_iterator<Container>(c);
+}
+
+} // namespace ctl
+
+#endif // CTL_BACK_INSERTER_H_
diff --git a/ctl/bad_alloc.h b/ctl/bad_alloc.h
new file mode 100644
index 000000000..99bcda0be
--- /dev/null
+++ b/ctl/bad_alloc.h
@@ -0,0 +1,23 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_BAD_ALLOC_H_
+#define CTL_BAD_ALLOC_H_
+#include "exception.h"
+
+namespace ctl {
+
+class bad_alloc : public ctl::exception
+{
+  public:
+    bad_alloc() noexcept = default;
+    ~bad_alloc() override = default;
+
+    const char* what() const noexcept override
+    {
+        return "ctl::bad_alloc";
+    }
+};
+
+} // namespace ctl
+
+#endif // CTL_BAD_ALLOC_H_
diff --git a/ctl/conditional.h b/ctl/conditional.h
new file mode 100644
index 000000000..5b63eaa85
--- /dev/null
+++ b/ctl/conditional.h
@@ -0,0 +1,25 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_CONDITIONAL_H_
+#define CTL_CONDITIONAL_H_
+
+namespace ctl {
+
+template<bool B, class T, class F>
+struct conditional
+{
+    typedef T type;
+};
+
+template<class T, class F>
+struct conditional<false, T, F>
+{
+    typedef F type;
+};
+
+template<bool B, typename T, typename F>
+using conditional_t = typename conditional<B, T, F>::type;
+
+} // namespace ctl
+
+#endif // CTL_CONDITIONAL_H_
diff --git a/ctl/copy.h b/ctl/copy.h
new file mode 100644
index 000000000..dd546bce8
--- /dev/null
+++ b/ctl/copy.h
@@ -0,0 +1,22 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_COPY_H_
+#define CTL_COPY_H_
+
+namespace ctl {
+
+template<class InputIt, class OutputIt>
+OutputIt
+copy(InputIt first, InputIt last, OutputIt d_first)
+{
+    while (first != last) {
+        *d_first = *first;
+        ++d_first;
+        ++first;
+    }
+    return d_first;
+}
+
+} // namespace ctl
+
+#endif // CTL_COPY_H_
diff --git a/ctl/decay.h b/ctl/decay.h
new file mode 100644
index 000000000..3944eeba0
--- /dev/null
+++ b/ctl/decay.h
@@ -0,0 +1,36 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_DECAY_H_
+#define CTL_DECAY_H_
+#include "add_pointer.h"
+#include "conditional.h"
+#include "is_array.h"
+#include "is_function.h"
+#include "remove_cv.h"
+#include "remove_extent.h"
+#include "remove_reference.h"
+
+namespace ctl {
+
+template<typename T>
+struct decay
+{
+  private:
+    typedef typename ctl::remove_reference<T>::type U;
+
+  public:
+    typedef typename ctl::conditional<
+      ctl::is_array<U>::value,
+      typename ctl::remove_extent<U>::type*,
+      typename ctl::conditional<ctl::is_function<U>::value,
+                                typename ctl::add_pointer<U>::type,
+                                typename ctl::remove_cv<U>::type>::type>::type
+      type;
+};
+
+template<typename T>
+using decay_t = typename decay<T>::type;
+
+} // namespace ctl
+
+#endif // CTL_DECAY_H_
diff --git a/ctl/default_delete.h b/ctl/default_delete.h
new file mode 100644
index 000000000..4a3458369
--- /dev/null
+++ b/ctl/default_delete.h
@@ -0,0 +1,44 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_DEFAULT_DELETE_H_
+#define CTL_DEFAULT_DELETE_H_
+#include "enable_if.h"
+#include "is_convertible.h"
+
+namespace ctl {
+
+template<typename T>
+struct default_delete
+{
+    constexpr default_delete() noexcept = default;
+    template<typename U,
+             typename = typename ctl::enable_if<
+               ctl::is_convertible<U*, T*>::value>::type>
+    constexpr default_delete(const default_delete<U>&) noexcept
+    {
+    }
+    constexpr void operator()(T* const p) const noexcept
+    {
+        delete p;
+    }
+};
+
+template<typename T>
+struct default_delete<T[]>
+{
+    constexpr default_delete() noexcept = default;
+    template<typename U,
+             typename = typename ctl::enable_if<
+               ctl::is_convertible<U (*)[], T (*)[]>::value>::type>
+    constexpr default_delete(const default_delete<U[]>&) noexcept
+    {
+    }
+    constexpr void operator()(T* const p) const noexcept
+    {
+        delete[] p;
+    }
+};
+
+} // namespace ctl
+
+#endif // CTL_DEFAULT_DELETE_H_
diff --git a/ctl/distance.h b/ctl/distance.h
new file mode 100644
index 000000000..ab06867d9
--- /dev/null
+++ b/ctl/distance.h
@@ -0,0 +1,39 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_DISTANCE_H_
+#define CTL_DISTANCE_H_
+#include "iterator.h"
+#include "iterator_traits.h"
+
+namespace ctl {
+
+template<class InputIter>
+constexpr typename ctl::iterator_traits<InputIter>::difference_type
+distance_impl(InputIter first, InputIter last, input_iterator_tag)
+{
+    typename ctl::iterator_traits<InputIter>::difference_type res(0);
+    for (; first != last; ++first)
+        ++res;
+    return res;
+}
+
+template<class RandIter>
+constexpr typename ctl::iterator_traits<RandIter>::difference_type
+distance_impl(RandIter first, RandIter last, random_access_iterator_tag)
+{
+    return last - first;
+}
+
+template<class InputIter>
+constexpr typename ctl::iterator_traits<InputIter>::difference_type
+distance(InputIter first, InputIter last)
+{
+    return distance_impl(
+      first,
+      last,
+      typename ctl::iterator_traits<InputIter>::iterator_category());
+}
+
+} // namespace ctl
+
+#endif // CTL_DISTANCE_H_
diff --git a/ctl/dubble.cc b/ctl/dubble.cc
new file mode 100644
index 000000000..c80ab6718
--- /dev/null
+++ b/ctl/dubble.cc
@@ -0,0 +1,35 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "dubble.h"
+
+namespace ctl {
+
+const double_conversion::DoubleToStringConverter kDoubleToPrintfG(
+  double_conversion::DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN |
+    double_conversion::DoubleToStringConverter::NO_TRAILING_ZERO,
+  "inf",
+  "nan",
+  'e',
+  -6,
+  10, // let 32-bit ints be represented without exponent
+  6,
+  0,
+  0);
+
+} // namespace ctl
diff --git a/ctl/dubble.h b/ctl/dubble.h
new file mode 100644
index 000000000..88a2f0924
--- /dev/null
+++ b/ctl/dubble.h
@@ -0,0 +1,13 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef COSMOPOLITAN_CTL_DUBBLE_H_
+#define COSMOPOLITAN_CTL_DUBBLE_H_
+#include "third_party/double-conversion/double-to-string.h"
+
+namespace ctl {
+
+extern const double_conversion::DoubleToStringConverter kDoubleToPrintfG;
+
+} // namespace ctl
+
+#endif // COSMOPOLITAN_CTL_DUBBLE_H_
diff --git a/ctl/enable_if.h b/ctl/enable_if.h
new file mode 100644
index 000000000..9c61957a4
--- /dev/null
+++ b/ctl/enable_if.h
@@ -0,0 +1,23 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ENABLE_IF_H_
+#define CTL_ENABLE_IF_H_
+
+namespace ctl {
+
+template<bool B, class T = void>
+struct enable_if
+{};
+
+template<class T>
+struct enable_if<true, T>
+{
+    typedef T type;
+};
+
+template<bool B, class T = void>
+using enable_if_t = typename enable_if<B, T>::type;
+
+} // namespace ctl
+
+#endif // CTL_ENABLE_IF_H_
diff --git a/ctl/exception.h b/ctl/exception.h
new file mode 100644
index 000000000..9c36374e5
--- /dev/null
+++ b/ctl/exception.h
@@ -0,0 +1,22 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_EXCEPTION_H_
+#define CTL_EXCEPTION_H_
+
+namespace ctl {
+
+class exception
+{
+  public:
+    exception() noexcept = default;
+    virtual ~exception() = default;
+
+    virtual const char* what() const noexcept
+    {
+        return "ctl::exception";
+    }
+};
+
+} // namespace ctl
+
+#endif // CTL_EXCEPTION_H_
diff --git a/ctl/fill.h b/ctl/fill.h
new file mode 100644
index 000000000..9d87de776
--- /dev/null
+++ b/ctl/fill.h
@@ -0,0 +1,18 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_FILL_H_
+#define CTL_FILL_H_
+
+namespace ctl {
+
+template<typename ForwardIt, typename T>
+void
+fill(ForwardIt first, ForwardIt last, const T& value)
+{
+    for (; first != last; ++first)
+        *first = value;
+}
+
+} // namespace ctl
+
+#endif // CTL_FILL_H_
diff --git a/ctl/fill_n.h b/ctl/fill_n.h
new file mode 100644
index 000000000..b2dd61b24
--- /dev/null
+++ b/ctl/fill_n.h
@@ -0,0 +1,19 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_FILL_N_H_
+#define CTL_FILL_N_H_
+
+namespace ctl {
+
+template<typename OutputIt, typename Size, typename T>
+OutputIt
+fill_n(OutputIt first, Size count, const T& value)
+{
+    for (; count > 0; --count, ++first)
+        *first = value;
+    return first;
+}
+
+} // namespace ctl
+
+#endif // CTL_FILL_N_H_
diff --git a/ctl/integral_constant.h b/ctl/integral_constant.h
new file mode 100644
index 000000000..047b27354
--- /dev/null
+++ b/ctl/integral_constant.h
@@ -0,0 +1,31 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_INTEGRAL_CONSTANT_H_
+#define CTL_INTEGRAL_CONSTANT_H_
+
+namespace ctl {
+
+template<class T, T v>
+struct integral_constant
+{
+    static constexpr T value = v;
+    typedef T value_type;
+    typedef integral_constant type;
+
+    constexpr operator value_type() const noexcept
+    {
+        return value;
+    }
+
+    constexpr value_type operator()() const noexcept
+    {
+        return value;
+    }
+};
+
+typedef integral_constant<bool, true> true_type;
+typedef integral_constant<bool, false> false_type;
+
+} // namespace ctl
+
+#endif // CTL_INTEGRAL_CONSTANT_H_
diff --git a/ctl/ios.cc b/ctl/ios.cc
new file mode 100644
index 000000000..37547aecb
--- /dev/null
+++ b/ctl/ios.cc
@@ -0,0 +1,39 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ios.h"
+
+namespace ctl {
+
+ios::ios(FILE* file) : file_(file)
+{
+}
+
+ios::~ios() = default;
+
+ios&
+ios::operator=(ios&& other) noexcept
+{
+    if (this != &other) {
+        file_ = other.file_;
+        other.file_ = nullptr;
+    }
+    return *this;
+}
+
+} // namespace ctl
diff --git a/ctl/ios.h b/ctl/ios.h
new file mode 100644
index 000000000..31e82e258
--- /dev/null
+++ b/ctl/ios.h
@@ -0,0 +1,27 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IOS_H_
+#define CTL_IOS_H_
+#include "ios_base.h"
+
+struct FILE;
+
+namespace ctl {
+
+class ios : public ios_base
+{
+  public:
+    explicit ios(FILE*);
+    virtual ~ios();
+
+  protected:
+    ios& operator=(ios&&) noexcept;
+    FILE* file_;
+
+  private:
+    ios(const ios&) = delete;
+};
+
+} // namespace ctl
+
+#endif // CTL_IOS_H_
diff --git a/ctl/ios_base.cc b/ctl/ios_base.cc
new file mode 100644
index 000000000..8ff97b669
--- /dev/null
+++ b/ctl/ios_base.cc
@@ -0,0 +1,118 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ios_base.h"
+
+namespace ctl {
+
+ios_base::ios_base() : state_(goodbit), flags_(skipws | dec)
+{
+}
+
+ios_base::~ios_base() = default;
+
+ios_base::fmtflags
+ios_base::flags() const
+{
+    return static_cast<ios_base::fmtflags>(flags_);
+}
+
+ios_base::fmtflags
+ios_base::flags(fmtflags fmtfl)
+{
+    int old = flags_;
+    flags_ = fmtfl;
+    return static_cast<ios_base::fmtflags>(old);
+}
+
+ios_base::fmtflags
+ios_base::setf(fmtflags fmtfl)
+{
+    int old = flags_;
+    flags_ |= fmtfl;
+    return static_cast<ios_base::fmtflags>(old);
+}
+
+ios_base::fmtflags
+ios_base::setf(fmtflags fmtfl, fmtflags mask)
+{
+    int old = flags_;
+    flags_ = (flags_ & ~mask) | (fmtfl & mask);
+    return static_cast<ios_base::fmtflags>(old);
+}
+
+void
+ios_base::unsetf(fmtflags mask)
+{
+    flags_ &= ~mask;
+}
+
+ios_base::iostate
+ios_base::rdstate() const
+{
+    return static_cast<ios_base::iostate>(state_);
+}
+
+void
+ios_base::clear(int state)
+{
+    state_ = state;
+}
+
+void
+ios_base::setstate(int state)
+{
+    state_ |= state;
+}
+
+bool
+ios_base::good() const
+{
+    return state_ == goodbit;
+}
+
+bool
+ios_base::eof() const
+{
+    return (state_ & eofbit) != 0;
+}
+
+bool
+ios_base::fail() const
+{
+    return (state_ & (failbit | badbit)) != 0;
+}
+
+bool
+ios_base::bad() const
+{
+    return (state_ & badbit) != 0;
+}
+
+bool
+ios_base::operator!() const
+{
+    return fail();
+}
+
+ios_base::operator bool() const
+{
+    return !fail();
+}
+
+} // namespace ctl
diff --git a/ctl/ios_base.h b/ctl/ios_base.h
new file mode 100644
index 000000000..e52114959
--- /dev/null
+++ b/ctl/ios_base.h
@@ -0,0 +1,86 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IOS_BASE_H_
+#define CTL_IOS_BASE_H_
+
+namespace ctl {
+
+class ios_base
+{
+  public:
+    typedef size_t streamsize;
+
+    enum iostate
+    {
+        goodbit = 0,
+        badbit = 1,
+        failbit = 2,
+        eofbit = 4
+    };
+
+    enum fmtflags
+    {
+        boolalpha = 1 << 0,
+        dec = 1 << 1,
+        fixed = 1 << 2,
+        hex = 1 << 3,
+        internal = 1 << 4,
+        left = 1 << 5,
+        oct = 1 << 6,
+        right = 1 << 7,
+        scientific = 1 << 8,
+        showbase = 1 << 9,
+        showpoint = 1 << 10,
+        showpos = 1 << 11,
+        skipws = 1 << 12,
+        unitbuf = 1 << 13,
+        uppercase = 1 << 14,
+        adjustfield = left | right | internal,
+        basefield = dec | oct | hex,
+        floatfield = scientific | fixed
+    };
+
+    enum openmode
+    {
+        app = 1 << 0,
+        binary = 1 << 1,
+        in = 1 << 2,
+        out = 1 << 3,
+        trunc = 1 << 4,
+        ate = 1 << 5
+    };
+
+  protected:
+    ios_base();
+    virtual ~ios_base();
+
+    int state_;
+    int flags_;
+
+  public:
+    fmtflags flags() const;
+    fmtflags flags(fmtflags);
+    fmtflags setf(fmtflags);
+    fmtflags setf(fmtflags, fmtflags);
+    void unsetf(fmtflags);
+
+    iostate rdstate() const;
+    void clear(int = goodbit);
+    void setstate(int);
+
+    bool good() const;
+    bool eof() const;
+    bool fail() const;
+    bool bad() const;
+
+    bool operator!() const;
+    explicit operator bool() const;
+
+  private:
+    ios_base(const ios_base&) = delete;
+    ios_base& operator=(const ios_base&) = delete;
+};
+
+} // namespace ctl
+
+#endif // CTL_IOS_BASE_H_
diff --git a/ctl/is_abstract.h b/ctl/is_abstract.h
new file mode 100644
index 000000000..95360a5f4
--- /dev/null
+++ b/ctl/is_abstract.h
@@ -0,0 +1,18 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_ABSTRACT_H_
+#define CTL_IS_ABSTRACT_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename T>
+struct is_abstract : public ctl::integral_constant<bool, __is_abstract(T)>
+{};
+
+template<typename T>
+inline constexpr bool is_abstract_v = __is_abstract(T);
+
+} // namespace ctl
+
+#endif // CTL_IS_ABSTRACT_H_
diff --git a/ctl/is_array.h b/ctl/is_array.h
new file mode 100644
index 000000000..4888b87a7
--- /dev/null
+++ b/ctl/is_array.h
@@ -0,0 +1,26 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_ARRAY_H_
+#define CTL_IS_ARRAY_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename T>
+struct is_array : ctl::false_type
+{};
+
+template<typename T, size_t N>
+struct is_array<T[N]> : ctl::true_type
+{};
+
+template<typename T>
+struct is_array<T[]> : ctl::true_type
+{};
+
+template<typename T>
+inline constexpr bool is_array_v = is_array<T>::value;
+
+} // namespace ctl
+
+#endif // CTL_IS_ARRAY_H_
diff --git a/ctl/is_base_of.h b/ctl/is_base_of.h
new file mode 100644
index 000000000..82c9961c1
--- /dev/null
+++ b/ctl/is_base_of.h
@@ -0,0 +1,19 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_BASE_OF_H_
+#define CTL_IS_BASE_OF_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename Base, typename Derived>
+struct is_base_of
+  : public ctl::integral_constant<bool, __is_base_of(Base, Derived)>
+{};
+
+template<typename Base, typename Derived>
+inline constexpr bool is_base_of_v = __is_base_of(Base, Derived);
+
+} // namespace ctl
+
+#endif // CTL_IS_BASE_OF_H_
diff --git a/ctl/is_class.h b/ctl/is_class.h
new file mode 100644
index 000000000..f5f78958e
--- /dev/null
+++ b/ctl/is_class.h
@@ -0,0 +1,18 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_CLASS_H_
+#define CTL_IS_CLASS_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename T>
+struct is_class : public ctl::integral_constant<bool, __is_class(T)>
+{};
+
+template<typename T>
+inline constexpr bool is_class_v = __is_class(T);
+
+} // namespace ctl
+
+#endif // CTL_IS_CLASS_H_
diff --git a/ctl/is_constructible.h b/ctl/is_constructible.h
new file mode 100644
index 000000000..0f3c3fce8
--- /dev/null
+++ b/ctl/is_constructible.h
@@ -0,0 +1,19 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_CONSTRUCTIBLE_H_
+#define CTL_IS_CONSTRUCTIBLE_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<class _Tp, class... _Args>
+struct is_constructible
+  : public ctl::integral_constant<bool, __is_constructible(_Tp, _Args...)>
+{};
+
+template<class _Tp, class... _Args>
+inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...);
+
+} // namespace ctl
+
+#endif // CTL_IS_CONSTRUCTIBLE_H_
diff --git a/ctl/is_convertible.h b/ctl/is_convertible.h
new file mode 100644
index 000000000..b485f5769
--- /dev/null
+++ b/ctl/is_convertible.h
@@ -0,0 +1,53 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_CONVERTIBLE_H_
+#define CTL_IS_CONVERTIBLE_H_
+#include "ctl/integral_constant.h"
+#include "ctl/void_t.h"
+
+namespace ctl {
+
+// Declaration of declval
+template<typename T>
+T&&
+declval() noexcept;
+
+namespace detail {
+
+template<typename From, typename To, typename = void>
+struct is_convertible_impl : ctl::false_type
+{};
+
+template<typename From, typename To>
+struct is_convertible_impl<From,
+                           To,
+                           void_t<decltype(static_cast<To>(declval<From>()))>>
+  : true_type
+{};
+
+// Handle void types separately
+template<>
+struct is_convertible_impl<void, void> : ctl::true_type
+{};
+
+template<typename To>
+struct is_convertible_impl<void, To> : ctl::false_type
+{};
+
+template<typename From>
+struct is_convertible_impl<From, void> : ctl::false_type
+{};
+
+} // namespace detail
+
+template<typename From, typename To>
+struct is_convertible : detail::is_convertible_impl<From, To>
+{};
+
+// Helper variable template (C++17 and later)
+template<typename From, typename To>
+inline constexpr bool is_convertible_v = is_convertible<From, To>::value;
+
+} // namespace ctl
+
+#endif // CTL_IS_CONVERTIBLE_H_
diff --git a/ctl/is_empty.h b/ctl/is_empty.h
new file mode 100644
index 000000000..095c069ea
--- /dev/null
+++ b/ctl/is_empty.h
@@ -0,0 +1,18 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_EMPTY_H_
+#define CTL_IS_EMPTY_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename T>
+struct is_empty : public ctl::integral_constant<bool, __is_empty(T)>
+{};
+
+template<typename T>
+inline constexpr bool is_empty_v = __is_empty(T);
+
+} // namespace ctl
+
+#endif // CTL_IS_EMPTY_H_
diff --git a/ctl/is_enum.h b/ctl/is_enum.h
new file mode 100644
index 000000000..19adcd8c3
--- /dev/null
+++ b/ctl/is_enum.h
@@ -0,0 +1,18 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_ENUM_H_
+#define CTL_IS_ENUM_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename T>
+struct is_enum : public ctl::integral_constant<bool, __is_enum(T)>
+{};
+
+template<typename T>
+inline constexpr bool is_enum_v = __is_enum(T);
+
+} // namespace ctl
+
+#endif // CTL_IS_ENUM_H_
diff --git a/ctl/is_function.h b/ctl/is_function.h
new file mode 100644
index 000000000..bee4f85f8
--- /dev/null
+++ b/ctl/is_function.h
@@ -0,0 +1,120 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_FUNCTION_H_
+#define CTL_IS_FUNCTION_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+// Primary template
+template<class>
+struct is_function : ctl::false_type
+{};
+
+// Specializations for various function types
+
+// Regular functions
+template<class Ret, class... Args>
+struct is_function<Ret(Args...)> : ctl::true_type
+{};
+
+// Functions with cv-qualifiers
+template<class Ret, class... Args>
+struct is_function<Ret(Args...) const> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args...) volatile> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args...) const volatile> : ctl::true_type
+{};
+
+// Functions with ref-qualifiers
+template<class Ret, class... Args>
+struct is_function<Ret(Args...)&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args...) const&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args...) volatile&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args...) const volatile&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args...) &&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args...) const&&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args...) volatile&&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args...) const volatile&&> : ctl::true_type
+{};
+
+// Variadic functions
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...)> : ctl::true_type
+{};
+
+// Variadic functions with cv-qualifiers
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...) const> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...) volatile> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...) const volatile> : ctl::true_type
+{};
+
+// Variadic functions with ref-qualifiers
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...)&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...) const&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...) volatile&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...) const volatile&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...) &&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...) const&&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...) volatile&&> : ctl::true_type
+{};
+
+template<class Ret, class... Args>
+struct is_function<Ret(Args..., ...) const volatile&&> : ctl::true_type
+{};
+
+} // namespace ctl
+
+#endif // CTL_IS_FUNCTION_H_
diff --git a/ctl/is_integral.h b/ctl/is_integral.h
new file mode 100644
index 000000000..a68344119
--- /dev/null
+++ b/ctl/is_integral.h
@@ -0,0 +1,78 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_INTEGRAL_H_
+#define CTL_IS_INTEGRAL_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename T>
+struct is_integral : ctl::false_type
+{};
+
+template<>
+struct is_integral<bool> : ctl::true_type
+{};
+
+template<>
+struct is_integral<char> : ctl::true_type
+{};
+
+template<>
+struct is_integral<signed char> : ctl::true_type
+{};
+
+template<>
+struct is_integral<unsigned char> : ctl::true_type
+{};
+
+template<>
+struct is_integral<short> : ctl::true_type
+{};
+
+template<>
+struct is_integral<unsigned short> : ctl::true_type
+{};
+
+template<>
+struct is_integral<int> : ctl::true_type
+{};
+
+template<>
+struct is_integral<unsigned int> : ctl::true_type
+{};
+
+template<>
+struct is_integral<long> : ctl::true_type
+{};
+
+template<>
+struct is_integral<unsigned long> : ctl::true_type
+{};
+
+template<>
+struct is_integral<long long> : ctl::true_type
+{};
+
+template<>
+struct is_integral<unsigned long long> : ctl::true_type
+{};
+
+template<>
+struct is_integral<char16_t> : ctl::true_type
+{};
+
+template<>
+struct is_integral<char32_t> : ctl::true_type
+{};
+
+template<>
+struct is_integral<wchar_t> : ctl::true_type
+{};
+
+template<typename T>
+inline constexpr bool is_integral_v = is_integral<T>::value;
+
+} // namespace ctl
+
+#endif // CTL_IS_INTEGRAL_H_
diff --git a/ctl/is_polymorphic.h b/ctl/is_polymorphic.h
new file mode 100644
index 000000000..499862d1d
--- /dev/null
+++ b/ctl/is_polymorphic.h
@@ -0,0 +1,18 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_POLYMORPHIC_H_
+#define CTL_IS_POLYMORPHIC_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename T>
+struct is_polymorphic : public ctl::integral_constant<bool, __is_polymorphic(T)>
+{};
+
+template<typename T>
+inline constexpr bool is_polymorphic_v = __is_polymorphic(T);
+
+} // namespace ctl
+
+#endif // CTL_IS_POLYMORPHIC_H_
diff --git a/ctl/is_reference.h b/ctl/is_reference.h
new file mode 100644
index 000000000..66ae107b6
--- /dev/null
+++ b/ctl/is_reference.h
@@ -0,0 +1,35 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_REFERENCE_H_
+#define CTL_IS_REFERENCE_H_
+
+namespace ctl {
+
+// Primary template
+template<class T>
+struct is_reference
+{
+    static constexpr bool value = false;
+};
+
+// Specialization for lvalue reference
+template<class T>
+struct is_reference<T&>
+{
+    static constexpr bool value = true;
+};
+
+// Specialization for rvalue reference
+template<class T>
+struct is_reference<T&&>
+{
+    static constexpr bool value = true;
+};
+
+// Helper variable template (C++14 and later)
+template<class T>
+inline constexpr bool is_reference_v = is_reference<T>::value;
+
+} // namespace ctl
+
+#endif // CTL_IS_REFERENCE_H_
diff --git a/ctl/is_same.h b/ctl/is_same.h
new file mode 100644
index 000000000..44c09761b
--- /dev/null
+++ b/ctl/is_same.h
@@ -0,0 +1,25 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_SAME_H_
+#define CTL_IS_SAME_H_
+
+namespace ctl {
+
+template<typename T, typename U>
+struct is_same
+{
+    static constexpr bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T>
+{
+    static constexpr bool value = true;
+};
+
+template<class T, class U>
+inline constexpr bool is_same_v = is_same<T, U>::value;
+
+} // namespace ctl
+
+#endif // CTL_IS_SAME_H_
diff --git a/ctl/is_signed.h b/ctl/is_signed.h
new file mode 100644
index 000000000..2c911ee4c
--- /dev/null
+++ b/ctl/is_signed.h
@@ -0,0 +1,16 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_SIGNED_H_
+#define CTL_IS_SIGNED_H_
+
+namespace ctl {
+
+template<typename T>
+struct is_signed
+{
+    static constexpr bool value = T(0) > T(-1);
+};
+
+} // namespace ctl
+
+#endif // CTL_IS_SIGNED_H_
diff --git a/ctl/is_sorted.h b/ctl/is_sorted.h
new file mode 100644
index 000000000..551cce9da
--- /dev/null
+++ b/ctl/is_sorted.h
@@ -0,0 +1,25 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_SORTED_H_
+#define CTL_IS_SORTED_H_
+
+namespace ctl {
+
+template<typename It, typename Compare>
+bool
+is_sorted(It first, It last, Compare comp)
+{
+    if (first == last)
+        return true;
+    It next = first;
+    while (++next != last) {
+        if (comp(*next, *first))
+            return false;
+        first = next;
+    }
+    return true;
+}
+
+} // namespace ctl
+
+#endif // CTL_IS_SORTED_H_
diff --git a/ctl/is_standard_layout.h b/ctl/is_standard_layout.h
new file mode 100644
index 000000000..0eabab88f
--- /dev/null
+++ b/ctl/is_standard_layout.h
@@ -0,0 +1,19 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_STANDARD_LAYOUT_H_
+#define CTL_IS_STANDARD_LAYOUT_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename T>
+struct is_standard_layout
+  : public ctl::integral_constant<bool, __is_standard_layout(T)>
+{};
+
+template<typename T>
+inline constexpr bool is_standard_layout_v = __is_standard_layout(T);
+
+} // namespace ctl
+
+#endif // CTL_IS_STANDARD_LAYOUT_H_
diff --git a/ctl/is_trivial.h b/ctl/is_trivial.h
new file mode 100644
index 000000000..f2e996bcf
--- /dev/null
+++ b/ctl/is_trivial.h
@@ -0,0 +1,18 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_TRIVIAL_H_
+#define CTL_IS_TRIVIAL_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename T>
+struct is_trivial : public ctl::integral_constant<bool, __is_trivial(T)>
+{};
+
+template<typename T>
+inline constexpr bool is_trivial_v = __is_trivial(T);
+
+} // namespace ctl
+
+#endif // CTL_IS_TRIVIAL_H_
diff --git a/ctl/is_union.h b/ctl/is_union.h
new file mode 100644
index 000000000..ebae27125
--- /dev/null
+++ b/ctl/is_union.h
@@ -0,0 +1,18 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_UNION_H_
+#define CTL_IS_UNION_H_
+#include "integral_constant.h"
+
+namespace ctl {
+
+template<typename T>
+struct is_union : public ctl::integral_constant<bool, __is_union(T)>
+{};
+
+template<typename T>
+inline constexpr bool is_union_v = __is_union(T);
+
+} // namespace ctl
+
+#endif // CTL_IS_UNION_H_
diff --git a/ctl/is_unsigned.h b/ctl/is_unsigned.h
new file mode 100644
index 000000000..02f276a7c
--- /dev/null
+++ b/ctl/is_unsigned.h
@@ -0,0 +1,16 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_UNSIGNED_H_
+#define CTL_IS_UNSIGNED_H_
+
+namespace ctl {
+
+template<typename T>
+struct is_unsigned
+{
+    static constexpr bool value = T(0) < T(-1);
+};
+
+} // namespace ctl
+
+#endif // CTL_IS_UNSIGNED_H_
diff --git a/ctl/is_void.h b/ctl/is_void.h
new file mode 100644
index 000000000..275848d81
--- /dev/null
+++ b/ctl/is_void.h
@@ -0,0 +1,27 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_IS_VOID_H_
+#define CTL_IS_VOID_H_
+#include "integral_constant.h"
+#include "remove_cv.h"
+
+namespace ctl {
+
+template<typename>
+struct is_void_ : public ctl::false_type
+{};
+
+template<>
+struct is_void_<void> : public ctl::true_type
+{};
+
+template<typename _Tp>
+struct is_void : public is_void_<typename ctl::remove_cv<_Tp>::type>::type
+{};
+
+template<typename T>
+inline constexpr bool is_void_v = is_void<T>::value;
+
+} // namespace ctl
+
+#endif // CTL_IS_VOID_H_
diff --git a/ctl/istream.cc b/ctl/istream.cc
new file mode 100644
index 000000000..fa6d0d1db
--- /dev/null
+++ b/ctl/istream.cc
@@ -0,0 +1,238 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "istream.h"
+#include "libc/ctype.h"
+#include "libc/fmt/conv.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "numeric_limits.h"
+#include "string.h"
+#include "utility.h"
+
+namespace ctl {
+
+istream cin(stdin);
+
+istream::~istream() = default;
+
+istream::istream(FILE* file) : ios(file), gcount_(0)
+{
+}
+
+istream::istream(istream&& other) noexcept
+  : ios(other.file_), gcount_(other.gcount_)
+{
+    other.file_ = nullptr;
+    other.gcount_ = 0;
+}
+
+istream&
+istream::operator=(istream&& other) noexcept
+{
+    if (this != &other) {
+        ios::operator=(ctl::move(other));
+        gcount_ = other.gcount_;
+        other.gcount_ = 0;
+    }
+    return *this;
+}
+
+istream&
+istream::operator>>(char& c)
+{
+    gcount_ = 0;
+    int ch = fgetc(file_);
+    if (ch == EOF) {
+        setstate(eofbit | failbit);
+    } else {
+        c = static_cast<char>(ch);
+        gcount_ = 1;
+    }
+    return *this;
+}
+
+istream&
+istream::operator>>(int& n)
+{
+    if (fscanf(file_, "%d", &n) != 1)
+        setstate(failbit);
+    return *this;
+}
+
+istream&
+istream::operator>>(long& n)
+{
+    if (fscanf(file_, "%ld", &n) != 1)
+        setstate(failbit);
+    return *this;
+}
+
+istream&
+istream::operator>>(double& d)
+{
+    if (fscanf(file_, "%f", &d) != 1)
+        setstate(failbit);
+    return *this;
+}
+
+istream&
+istream::operator>>(ctl::string& s)
+{
+    char buffer[1024];
+    if (fscanf(file_, "%1023s", buffer) == 1) {
+        s = buffer;
+    } else {
+        setstate(failbit);
+    }
+    return *this;
+}
+
+istream&
+istream::operator>>(bool& b)
+{
+    char buffer[6];
+    if (fscanf(file_, "%5s", buffer) == 1) {
+        if (strcmp(buffer, "true") == 0 || strcmp(buffer, "1") == 0) {
+            b = true;
+        } else if (strcmp(buffer, "false") == 0 || strcmp(buffer, "0") == 0) {
+            b = false;
+        } else {
+            setstate(failbit);
+        }
+    } else {
+        setstate(failbit);
+    }
+    return *this;
+}
+
+istream&
+istream::operator>>(istream& (*manip)(istream&))
+{
+    return manip(*this);
+}
+
+int
+istream::get()
+{
+    gcount_ = 0;
+    int ch = fgetc(file_);
+    if (ch == EOF) {
+        setstate(eofbit);
+    } else {
+        gcount_ = 1;
+    }
+    return ch;
+}
+
+istream&
+istream::get(char& c)
+{
+    int ch = get();
+    if (ch != EOF)
+        c = static_cast<char>(ch);
+    return *this;
+}
+
+istream&
+istream::getline(char* s, streamsize n)
+{
+    return getline(s, n, '\n');
+}
+
+istream&
+istream::getline(char* s, streamsize n, char delim)
+{
+    gcount_ = 0;
+    if (n <= 0) {
+        setstate(failbit);
+        return *this;
+    }
+    while (gcount_ < n - 1) {
+        int ch = fgetc(file_);
+        if (ch == EOF) {
+            setstate(eofbit);
+            break;
+        }
+        if (ch == delim)
+            break;
+        s[gcount_++] = static_cast<char>(ch);
+    }
+    s[gcount_] = '\0';
+    if (gcount_ == 0)
+        setstate(failbit);
+    return *this;
+}
+
+istream&
+istream::read(char* s, streamsize n)
+{
+    gcount_ = fread(s, 1, n, file_);
+    if (gcount_ < n) {
+        setstate(eofbit);
+        if (gcount_ == 0)
+            setstate(failbit);
+    }
+    return *this;
+}
+
+istream::streamsize
+istream::gcount() const
+{
+    return gcount_;
+}
+
+int
+istream::peek()
+{
+    int ch = fgetc(file_);
+    if (ch != EOF) {
+        ungetc(ch, file_);
+    } else {
+        setstate(eofbit);
+    }
+    return ch;
+}
+
+istream&
+istream::ignore(streamsize n, int delim)
+{
+    gcount_ = 0;
+    while (gcount_ < n) {
+        int ch = fgetc(file_);
+        if (ch == EOF) {
+            setstate(eofbit);
+            break;
+        }
+        ++gcount_;
+        if (ch == delim)
+            break;
+    }
+    return *this;
+}
+
+istream&
+ws(istream& is)
+{
+    int ch;
+    while ((ch = is.peek()) != EOF && isspace(ch))
+        is.get();
+    return is;
+}
+
+} // namespace ctl
diff --git a/ctl/istream.h b/ctl/istream.h
new file mode 100644
index 000000000..f80bc5bf0
--- /dev/null
+++ b/ctl/istream.h
@@ -0,0 +1,53 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ISTREAM_H_
+#define CTL_ISTREAM_H_
+#include "ios.h"
+
+namespace ctl {
+
+struct string;
+
+class istream : public ios
+{
+  public:
+    istream() = delete;
+    explicit istream(FILE*);
+    virtual ~istream();
+
+    istream& operator>>(char&);
+    istream& operator>>(int&);
+    istream& operator>>(long&);
+    istream& operator>>(double&);
+    istream& operator>>(bool&);
+    istream& operator>>(ctl::string&);
+    istream& operator>>(istream& (*)(istream&));
+
+    int get();
+    istream& get(char&);
+    istream& getline(char*, streamsize);
+    istream& getline(char*, streamsize, char);
+    istream& read(char*, streamsize);
+    streamsize gcount() const;
+
+    int peek();
+    istream& ignore(streamsize = 1, int = -1);
+
+    istream(istream&&) noexcept;
+    istream& operator=(istream&&) noexcept;
+
+  private:
+    streamsize gcount_;
+
+    istream(const istream&) = delete;
+    istream& operator=(const istream&) = delete;
+};
+
+extern istream cin;
+
+istream&
+ws(istream& is);
+
+} // namespace ctl
+
+#endif // CTL_ISTREAM_H_
diff --git a/ctl/istringstream.cc b/ctl/istringstream.cc
new file mode 100644
index 000000000..254e5d0d6
--- /dev/null
+++ b/ctl/istringstream.cc
@@ -0,0 +1,222 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "istringstream.h"
+#include "libc/ctype.h"
+#include "libc/fmt/conv.h"
+#include "libc/str/str.h"
+
+namespace ctl {
+
+istringstream::istringstream() : buffer_(), read_pos_(0)
+{
+}
+
+istringstream::istringstream(const ctl::string_view& str)
+  : buffer_(str), read_pos_(0)
+{
+}
+
+ctl::string
+istringstream::str() const
+{
+    return buffer_;
+}
+
+void
+istringstream::str(const ctl::string& s)
+{
+    buffer_ = s;
+    read_pos_ = 0;
+    clear();
+}
+
+istringstream&
+istringstream::operator>>(char& c)
+{
+    if (good() && read_pos_ < buffer_.size()) {
+        c = buffer_[read_pos_++];
+    } else {
+        setstate(ios_base::failbit);
+    }
+    return *this;
+}
+
+istringstream&
+istringstream::operator>>(char* s)
+{
+    if (!good())
+        return *this;
+
+    while (read_pos_ < buffer_.size() && isspace(buffer_[read_pos_]))
+        ++read_pos_;
+
+    size_t start = read_pos_;
+    while (read_pos_ < buffer_.size() && !isspace(buffer_[read_pos_])) {
+        s[read_pos_ - start] = buffer_[read_pos_];
+        ++read_pos_;
+    }
+    s[read_pos_ - start] = '\0';
+
+    if (start == read_pos_) {
+        setstate(ios_base::failbit);
+    } else if (read_pos_ == buffer_.size()) {
+        setstate(ios_base::eofbit);
+    }
+
+    return *this;
+}
+
+istringstream&
+istringstream::operator>>(ctl::string& s)
+{
+    if (!good())
+        return *this;
+
+    s.clear();
+    while (read_pos_ < buffer_.size() && isspace(buffer_[read_pos_]))
+        ++read_pos_;
+
+    while (read_pos_ < buffer_.size() && !isspace(buffer_[read_pos_])) {
+        s.push_back(buffer_[read_pos_]);
+        ++read_pos_;
+    }
+
+    if (s.empty()) {
+        setstate(ios_base::failbit);
+    } else if (read_pos_ == buffer_.size()) {
+        setstate(ios_base::eofbit);
+    }
+
+    return *this;
+}
+
+template<typename T>
+istringstream&
+istringstream::read_numeric(T& value)
+{
+    if (!good())
+        return *this;
+
+    while (read_pos_ < buffer_.size() && isspace(buffer_[read_pos_]))
+        ++read_pos_;
+
+    // size_t start = read_pos_;
+    bool is_negative = false;
+    if (read_pos_ < buffer_.size() &&
+        (buffer_[read_pos_] == '-' || buffer_[read_pos_] == '+')) {
+        is_negative = (buffer_[read_pos_] == '-');
+        ++read_pos_;
+    }
+
+    T result = 0;
+    bool valid = false;
+    while (read_pos_ < buffer_.size() && isdigit(buffer_[read_pos_])) {
+        result = result * 10 + (buffer_[read_pos_] - '0');
+        ++read_pos_;
+        valid = true;
+    }
+
+    if (valid) {
+        value = is_negative ? -result : result;
+        if (read_pos_ == buffer_.size())
+            setstate(ios_base::eofbit);
+    } else {
+        setstate(ios_base::failbit);
+    }
+
+    return *this;
+}
+
+istringstream&
+istringstream::operator>>(short& n)
+{
+    return read_numeric(n);
+}
+
+istringstream&
+istringstream::operator>>(unsigned short& n)
+{
+    return read_numeric(n);
+}
+
+istringstream&
+istringstream::operator>>(int& n)
+{
+    return read_numeric(n);
+}
+
+istringstream&
+istringstream::operator>>(unsigned int& n)
+{
+    return read_numeric(n);
+}
+
+istringstream&
+istringstream::operator>>(long& n)
+{
+    return read_numeric(n);
+}
+
+istringstream&
+istringstream::operator>>(unsigned long& n)
+{
+    return read_numeric(n);
+}
+
+istringstream&
+istringstream::operator>>(float& f)
+{
+    if (!good())
+        return *this;
+
+    char* end;
+    f = strtof(buffer_.c_str() + read_pos_, &end);
+
+    if (end == buffer_.c_str() + read_pos_) {
+        setstate(ios_base::failbit);
+    } else {
+        read_pos_ = end - buffer_.c_str();
+        if (read_pos_ == buffer_.size())
+            setstate(ios_base::eofbit);
+    }
+
+    return *this;
+}
+
+istringstream&
+istringstream::operator>>(double& d)
+{
+    if (!good())
+        return *this;
+
+    char* end;
+    d = strtod(buffer_.c_str() + read_pos_, &end);
+
+    if (end == buffer_.c_str() + read_pos_) {
+        setstate(ios_base::failbit);
+    } else {
+        read_pos_ = end - buffer_.c_str();
+        if (read_pos_ == buffer_.size())
+            setstate(ios_base::eofbit);
+    }
+
+    return *this;
+}
+
+} // namespace ctl
diff --git a/ctl/istringstream.h b/ctl/istringstream.h
new file mode 100644
index 000000000..0ced67333
--- /dev/null
+++ b/ctl/istringstream.h
@@ -0,0 +1,41 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ISTRINGSTREAM_H_
+#define CTL_ISTRINGSTREAM_H_
+#include "ios_base.h"
+#include "string.h"
+
+namespace ctl {
+
+class istringstream : public ios_base
+{
+  public:
+    istringstream();
+    explicit istringstream(const ctl::string_view&);
+
+    string str() const;
+    void str(const string&);
+
+    istringstream& operator>>(char&);
+    istringstream& operator>>(char*);
+    istringstream& operator>>(ctl::string&);
+    istringstream& operator>>(short&);
+    istringstream& operator>>(unsigned short&);
+    istringstream& operator>>(int&);
+    istringstream& operator>>(unsigned int&);
+    istringstream& operator>>(long&);
+    istringstream& operator>>(unsigned long&);
+    istringstream& operator>>(float&);
+    istringstream& operator>>(double&);
+
+  private:
+    ctl::string buffer_;
+    size_t read_pos_;
+
+    template<typename T>
+    istringstream& read_numeric(T&);
+};
+
+} // namespace ctl
+
+#endif // CTL_ISTRINGSTREAM_H_
diff --git a/ctl/iterator.h b/ctl/iterator.h
new file mode 100644
index 000000000..7b9398b22
--- /dev/null
+++ b/ctl/iterator.h
@@ -0,0 +1,28 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_OUTPUT_ITERATOR_TAG_H_
+#define CTL_OUTPUT_ITERATOR_TAG_H_
+
+namespace ctl {
+
+struct input_iterator_tag
+{};
+
+struct output_iterator_tag
+{};
+
+struct forward_iterator_tag : public input_iterator_tag
+{};
+
+struct bidirectional_iterator_tag : public forward_iterator_tag
+{};
+
+struct random_access_iterator_tag : public bidirectional_iterator_tag
+{};
+
+struct contiguous_iterator_tag : public random_access_iterator_tag
+{};
+
+} // namespace ctl
+
+#endif // CTL_OUTPUT_ITERATOR_TAG_H_
diff --git a/ctl/iterator_traits.h b/ctl/iterator_traits.h
new file mode 100644
index 000000000..ecc0fffe0
--- /dev/null
+++ b/ctl/iterator_traits.h
@@ -0,0 +1,42 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_ITERATOR_TRAITS_H_
+#define CTL_ITERATOR_TRAITS_H_
+#include "iterator.h"
+#include "utility.h"
+#include "void_t.h"
+
+namespace ctl {
+
+template<typename Iterator, typename = void>
+struct iterator_traits
+{};
+
+template<typename T>
+struct iterator_traits<T*>
+{
+    using difference_type = ptrdiff_t;
+    using value_type = T;
+    using pointer = T*;
+    using reference = T&;
+    using iterator_category = ctl::random_access_iterator_tag;
+};
+
+template<typename Iterator>
+struct iterator_traits<Iterator,
+                       ctl::void_t<typename Iterator::iterator_category,
+                                   typename Iterator::value_type,
+                                   typename Iterator::difference_type,
+                                   typename Iterator::pointer,
+                                   typename Iterator::reference>>
+{
+    using iterator_category = typename Iterator::iterator_category;
+    using value_type = typename Iterator::value_type;
+    using difference_type = typename Iterator::difference_type;
+    using pointer = typename Iterator::pointer;
+    using reference = typename Iterator::reference;
+};
+
+} // namespace ctl
+
+#endif // CTL_ITERATOR_TRAITS_H_
diff --git a/ctl/lexicographical_compare.h b/ctl/lexicographical_compare.h
new file mode 100644
index 000000000..e1644ecc4
--- /dev/null
+++ b/ctl/lexicographical_compare.h
@@ -0,0 +1,43 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_LEXICOGRAPHICAL_COMPARE_H_
+#define CTL_LEXICOGRAPHICAL_COMPARE_H_
+
+namespace ctl {
+
+template<class InputIt1, class InputIt2>
+bool
+lexicographical_compare(InputIt1 first1,
+                        InputIt1 last1,
+                        InputIt2 first2,
+                        InputIt2 last2)
+{
+    for (; (first1 != last1) && (first2 != last2); ++first1, ++first2) {
+        if (*first1 < *first2)
+            return true;
+        if (*first2 < *first1)
+            return false;
+    }
+    return (first1 == last1) && (first2 != last2);
+}
+
+template<class InputIt1, class InputIt2, class Compare>
+bool
+lexicographical_compare(InputIt1 first1,
+                        InputIt1 last1,
+                        InputIt2 first2,
+                        InputIt2 last2,
+                        Compare comp)
+{
+    for (; (first1 != last1) && (first2 != last2); ++first1, ++first2) {
+        if (comp(*first1, *first2))
+            return true;
+        if (comp(*first2, *first1))
+            return false;
+    }
+    return (first1 == last1) && (first2 != last2);
+}
+
+} // namespace ctl
+
+#endif /* CTL_LEXICOGRAPHICAL_COMPARE_H_ */
diff --git a/ctl/map.h b/ctl/map.h
index ce564793c..32c98d5e1 100644
--- a/ctl/map.h
+++ b/ctl/map.h
@@ -2,6 +2,7 @@
 // vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
 #ifndef CTL_MAP_H_
 #define CTL_MAP_H_
+#include "out_of_range.h"
 #include "set.h"
 
 namespace ctl {
@@ -151,12 +152,12 @@ class map
 
     Value& operator[](const Key& key)
     {
-        return ((data_.insert(make_pair(key, Value()))).first)->second;
+        return ((data_.insert(ctl::make_pair(key, Value()))).first)->second;
     }
 
     Value& operator[](Key&& key)
     {
-        return ((data_.insert(make_pair(ctl::move(key), Value()))).first)
+        return ((data_.insert(ctl::make_pair(ctl::move(key), Value()))).first)
           ->second;
     }
 
@@ -164,7 +165,7 @@ class map
     {
         auto it = find(key);
         if (it == end())
-            __builtin_trap();
+            throw ctl::out_of_range();
         return it->second;
     }
 
@@ -172,7 +173,7 @@ class map
     {
         auto it = find(key);
         if (it == end())
-            __builtin_trap();
+            throw ctl::out_of_range();
         return it->second;
     }
 
@@ -243,7 +244,7 @@ class map
 
     size_type erase(const Key& key)
     {
-        return data_.erase(make_pair(key, Value()));
+        return data_.erase(ctl::make_pair(key, Value()));
     }
 
     void swap(map& other) noexcept
@@ -258,47 +259,47 @@ class map
 
     iterator find(const Key& key)
     {
-        return data_.find(make_pair(key, Value()));
+        return data_.find(ctl::make_pair(key, Value()));
     }
 
     const_iterator find(const Key& key) const
     {
-        return data_.find(make_pair(key, Value()));
+        return data_.find(ctl::make_pair(key, Value()));
     }
 
     size_type count(const Key& key) const
     {
-        return data_.count(make_pair(key, Value()));
+        return data_.count(ctl::make_pair(key, Value()));
     }
 
     iterator lower_bound(const Key& key)
     {
-        return data_.lower_bound(make_pair(key, Value()));
+        return data_.lower_bound(ctl::make_pair(key, Value()));
     }
 
     const_iterator lower_bound(const Key& key) const
     {
-        return data_.lower_bound(make_pair(key, Value()));
+        return data_.lower_bound(ctl::make_pair(key, Value()));
     }
 
     iterator upper_bound(const Key& key)
     {
-        return data_.upper_bound(make_pair(key, Value()));
+        return data_.upper_bound(ctl::make_pair(key, Value()));
     }
 
     const_iterator upper_bound(const Key& key) const
     {
-        return data_.upper_bound(make_pair(key, Value()));
+        return data_.upper_bound(ctl::make_pair(key, Value()));
     }
 
     ctl::pair<iterator, iterator> equal_range(const Key& key)
     {
-        return data_.equal_range(make_pair(key, Value()));
+        return data_.equal_range(ctl::make_pair(key, Value()));
     }
 
     ctl::pair<const_iterator, const_iterator> equal_range(const Key& key) const
     {
-        return data_.equal_range(make_pair(key, Value()));
+        return data_.equal_range(ctl::make_pair(key, Value()));
     }
 
     key_compare key_comp() const
diff --git a/ctl/max.h b/ctl/max.h
new file mode 100644
index 000000000..63a0cb5bd
--- /dev/null
+++ b/ctl/max.h
@@ -0,0 +1,17 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_MAX_H_
+#define CTL_MAX_H_
+
+namespace ctl {
+
+template<class T>
+inline constexpr const T&
+max(const T& a, const T& b)
+{
+    return a < b ? b : a;
+}
+
+} // namespace ctl
+
+#endif /* CTL_MAX_H_ */
diff --git a/ctl/min.h b/ctl/min.h
new file mode 100644
index 000000000..7adfe137f
--- /dev/null
+++ b/ctl/min.h
@@ -0,0 +1,17 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_MIN_H_
+#define CTL_MIN_H_
+
+namespace ctl {
+
+template<class T>
+inline constexpr const T&
+min(const T& a, const T& b)
+{
+    return b < a ? b : a;
+}
+
+} // namespace ctl
+
+#endif /* CTL_MIN_H_ */
diff --git a/ctl/move_backward.h b/ctl/move_backward.h
new file mode 100644
index 000000000..b4d3f2124
--- /dev/null
+++ b/ctl/move_backward.h
@@ -0,0 +1,20 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_MOVE_BACKWARD_H_
+#define CTL_MOVE_BACKWARD_H_
+#include "utility.h"
+
+namespace ctl {
+
+template<typename BidirIt1, typename BidirIt2>
+BidirIt2
+move_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last)
+{
+    while (first != last)
+        *(--d_last) = ctl::move(*(--last));
+    return d_last;
+}
+
+} // namespace ctl
+
+#endif // CTL_MOVE_BACKWARD_H_
diff --git a/ctl/move_iterator.h b/ctl/move_iterator.h
new file mode 100644
index 000000000..2527eca3b
--- /dev/null
+++ b/ctl/move_iterator.h
@@ -0,0 +1,172 @@
+#ifndef CTL_MOVE_ITERATOR_H_
+#define CTL_MOVE_ITERATOR_H_
+#include "iterator_traits.h"
+
+namespace ctl {
+
+template<typename Iterator>
+class move_iterator
+{
+  public:
+    using iterator_type = Iterator;
+    using iterator_category =
+      typename ctl::iterator_traits<Iterator>::iterator_category;
+    using value_type = typename ctl::iterator_traits<Iterator>::value_type;
+    using difference_type =
+      typename ctl::iterator_traits<Iterator>::difference_type;
+    using pointer = Iterator;
+    using reference = value_type&&;
+
+    constexpr move_iterator() : current()
+    {
+    }
+
+    explicit constexpr move_iterator(Iterator i) : current(i)
+    {
+    }
+
+    template<class U>
+    constexpr move_iterator(const move_iterator<U>& u) : current(u.base())
+    {
+    }
+
+    constexpr Iterator base() const
+    {
+        return current;
+    }
+
+    constexpr reference operator*() const
+    {
+        return static_cast<reference>(*current);
+    }
+
+    constexpr pointer operator->() const
+    {
+        return current;
+    }
+
+    constexpr move_iterator& operator++()
+    {
+        ++current;
+        return *this;
+    }
+
+    constexpr move_iterator operator++(int)
+    {
+        move_iterator tmp = *this;
+        ++current;
+        return tmp;
+    }
+
+    constexpr move_iterator& operator--()
+    {
+        --current;
+        return *this;
+    }
+
+    constexpr move_iterator operator--(int)
+    {
+        move_iterator tmp = *this;
+        --current;
+        return tmp;
+    }
+
+    constexpr move_iterator operator+(difference_type n) const
+    {
+        return move_iterator(current + n);
+    }
+
+    constexpr move_iterator& operator+=(difference_type n)
+    {
+        current += n;
+        return *this;
+    }
+
+    constexpr move_iterator operator-(difference_type n) const
+    {
+        return move_iterator(current - n);
+    }
+
+    constexpr move_iterator& operator-=(difference_type n)
+    {
+        current -= n;
+        return *this;
+    }
+
+    constexpr reference operator[](difference_type n) const
+    {
+        return ctl::move(current[n]);
+    }
+
+  private:
+    Iterator current;
+};
+
+template<typename Iterator>
+__attribute__((__always_inline__)) constexpr move_iterator<Iterator>
+make_move_iterator(Iterator i)
+{
+    return move_iterator<Iterator>(i);
+}
+
+template<typename Iterator1, typename Iterator2>
+constexpr bool
+operator==(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y)
+{
+    return x.base() == y.base();
+}
+
+template<typename Iterator1, typename Iterator2>
+constexpr bool
+operator!=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y)
+{
+    return !(x == y);
+}
+
+template<typename Iterator1, typename Iterator2>
+constexpr bool
+operator<(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y)
+{
+    return x.base() < y.base();
+}
+
+template<typename Iterator1, typename Iterator2>
+constexpr bool
+operator<=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y)
+{
+    return !(y < x);
+}
+
+template<typename Iterator1, typename Iterator2>
+constexpr bool
+operator>(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y)
+{
+    return y < x;
+}
+
+template<typename Iterator1, typename Iterator2>
+constexpr bool
+operator>=(const move_iterator<Iterator1>& x, const move_iterator<Iterator2>& y)
+{
+    return !(x < y);
+}
+
+template<typename Iterator>
+constexpr move_iterator<Iterator>
+operator+(typename move_iterator<Iterator>::difference_type n,
+          const move_iterator<Iterator>& x)
+{
+    return x + n;
+}
+
+template<typename Iterator1, typename Iterator2>
+constexpr auto
+operator-(const move_iterator<Iterator1>& x,
+          const move_iterator<Iterator2>& y) -> decltype(x.base() - y.base())
+{
+    return x.base() - y.base();
+}
+
+} // namespace ctl
+
+#endif // CTL_MOVE_ITERATOR_H_
diff --git a/ctl/mutex.h b/ctl/mutex.h
new file mode 100644
index 000000000..19f67a82a
--- /dev/null
+++ b/ctl/mutex.h
@@ -0,0 +1,51 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_MUTEX_H_
+#define CTL_MUTEX_H_
+#include "libc/thread/thread.h"
+
+namespace ctl {
+
+class mutex
+{
+  public:
+    mutex()
+    {
+        if (pthread_mutex_init(&m_, nullptr))
+            __builtin_trap();
+    }
+
+    ~mutex()
+    {
+        if (pthread_mutex_destroy(&m_))
+            __builtin_trap();
+    }
+
+    void lock()
+    {
+        if (pthread_mutex_lock(&m_))
+            __builtin_trap();
+    }
+
+    bool try_lock()
+    {
+        return pthread_mutex_trylock(&m_) == 0;
+    }
+
+    void unlock()
+    {
+        if (pthread_mutex_unlock(&m_))
+            __builtin_trap();
+    }
+
+    // Delete copy constructor and assignment operator
+    mutex(const mutex&) = delete;
+    mutex& operator=(const mutex&) = delete;
+
+  private:
+    pthread_mutex_t m_;
+};
+
+} // namespace ctl
+
+#endif // CTL_MUTEX_H_
diff --git a/ctl/new.cc b/ctl/new.cc
index 638f820a7..044fe4050 100644
--- a/ctl/new.cc
+++ b/ctl/new.cc
@@ -23,7 +23,7 @@
 COSMOPOLITAN_C_START_
 
 static void*
-_ctl_alloc(size_t n, size_t a)
+_ctl_alloc(size_t n, size_t a) noexcept
 {
     void* p;
     if (!(p = memalign(a, n)))
@@ -32,7 +32,16 @@ _ctl_alloc(size_t n, size_t a)
 }
 
 static void*
-_ctl_alloc1(size_t n)
+_ctl_alloc_nothrow(size_t n, size_t a, const ctl::nothrow_t&)
+{
+    void* p;
+    if (!(p = memalign(a, n)))
+        __builtin_trap();
+    return p;
+}
+
+static void*
+_ctl_alloc1(size_t n) noexcept
 {
     void* p;
     if (!(p = malloc(n)))
@@ -41,19 +50,28 @@ _ctl_alloc1(size_t n)
 }
 
 static void*
-_ctl_ret(size_t, void* p)
+_ctl_alloc1_nothrow(size_t n, const ctl::nothrow_t&) noexcept
+{
+    void* p;
+    if (!(p = malloc(n)))
+        __builtin_trap();
+    return p;
+}
+
+static void*
+_ctl_ret(size_t, void* p) noexcept
 {
     return p;
 }
 
 static void
-_ctl_free(void* p)
+_ctl_free(void* p) noexcept
 {
     free(p);
 }
 
 static void
-_ctl_nop(void*, void*)
+_ctl_nop(void*, void*) noexcept
 {
 }
 
@@ -75,23 +93,43 @@ __weak_reference(void*
                  operator new(size_t, ctl::align_val_t),
                  _ctl_alloc);
 
+__weak_reference(void*
+                 operator new(size_t,
+                              ctl::align_val_t,
+                              const ctl::nothrow_t&) noexcept,
+                 _ctl_alloc_nothrow);
+
 __weak_reference(void*
                  operator new[](size_t, ctl::align_val_t),
                  _ctl_alloc);
 
+__weak_reference(void*
+                 operator new[](size_t,
+                                ctl::align_val_t,
+                                const ctl::nothrow_t&) noexcept,
+                 _ctl_alloc_nothrow);
+
 __weak_reference(void*
                  operator new(size_t),
                  _ctl_alloc1);
 
+__weak_reference(void*
+                 operator new(size_t, const ctl::nothrow_t&) noexcept,
+                 _ctl_alloc1_nothrow);
+
 __weak_reference(void*
                  operator new[](size_t),
                  _ctl_alloc1);
 
+__weak_reference(void*
+                 operator new[](size_t, const ctl::nothrow_t&) noexcept,
+                 _ctl_alloc1_nothrow);
+
 // XXX clang-format currently mutilates these for some reason.
 // clang-format off
 
-__weak_reference(void* operator new(size_t, void*), _ctl_ret);
-__weak_reference(void* operator new[](size_t, void*), _ctl_ret);
+__weak_reference(void* operator new(size_t, void*) noexcept, _ctl_ret);
+__weak_reference(void* operator new[](size_t, void*) noexcept, _ctl_ret);
 
 __weak_reference(void operator delete(void*) noexcept, _ctl_free);
 __weak_reference(void operator delete[](void*) noexcept, _ctl_free);
diff --git a/ctl/new.h b/ctl/new.h
index 9993a02f8..d9dd36e95 100644
--- a/ctl/new.h
+++ b/ctl/new.h
@@ -13,18 +13,30 @@ enum class align_val_t : size_t
 {
 };
 
-} // namespace ctl
+struct nothrow_t
+{
+    explicit nothrow_t() = default;
+};
 
-void* operator new(size_t);
-void* operator new[](size_t);
-void* operator new(size_t, ctl::align_val_t);
-void* operator new[](size_t, ctl::align_val_t);
+inline constexpr nothrow_t nothrow{};
+
+} // namespace ctl
 
 // XXX clang-format currently mutilates these for some reason.
 // clang-format off
 
-void* operator new(size_t, void*);
-void* operator new[](size_t, void*);
+void* operator new(size_t);
+void* operator new(size_t, const ctl::nothrow_t&) noexcept;
+void* operator new(size_t, ctl::align_val_t);
+void* operator new(size_t, ctl::align_val_t, const ctl::nothrow_t&) noexcept;
+
+void* operator new[](size_t);
+void* operator new[](size_t, const ctl::nothrow_t&) noexcept;
+void* operator new[](size_t, ctl::align_val_t);
+void* operator new[](size_t, ctl::align_val_t, const ctl::nothrow_t&) noexcept;
+
+void* operator new(size_t, void*) noexcept;
+void* operator new[](size_t, void*) noexcept;
 
 void operator delete(void*) noexcept;
 void operator delete[](void*) noexcept;
diff --git a/ctl/numeric_limits.h b/ctl/numeric_limits.h
new file mode 100644
index 000000000..41aea3ae2
--- /dev/null
+++ b/ctl/numeric_limits.h
@@ -0,0 +1,123 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_NUMERIC_LIMITS_H_
+#define CTL_NUMERIC_LIMITS_H_
+#include "is_integral.h"
+#include "is_unsigned.h"
+
+namespace ctl {
+
+template<typename T>
+class numeric_limits
+{
+    static constexpr T max_signed()
+    {
+        return T(((uintmax_t)1 << (sizeof(T) * 8 - 1)) - 1);
+    }
+
+    static constexpr T max_unsigned()
+    {
+        return T(~T(0));
+    }
+
+  public:
+    static constexpr bool is_specialized = ctl::is_integral<T>::value;
+    static constexpr bool is_signed = !ctl::is_unsigned<T>::value;
+    static constexpr bool is_integer = ctl::is_integral<T>::value;
+    static constexpr bool is_exact = ctl::is_integral<T>::value;
+    static constexpr int digits = sizeof(T) * 8 - (is_signed ? 1 : 0);
+
+    static constexpr T min() noexcept
+    {
+        return is_signed ? T(-max_signed() - 1) : T(0);
+    }
+
+    static constexpr T max() noexcept
+    {
+        return is_signed ? max_signed() : max_unsigned();
+    }
+
+    static constexpr T lowest() noexcept
+    {
+        return min();
+    }
+};
+
+template<>
+struct numeric_limits<bool>
+{
+    static constexpr bool is_specialized = true;
+    static constexpr bool is_signed = false;
+    static constexpr bool is_integer = true;
+    static constexpr bool is_exact = true;
+    static constexpr int digits = 1;
+
+    static constexpr bool min() noexcept
+    {
+        return false;
+    }
+
+    static constexpr bool max() noexcept
+    {
+        return true;
+    }
+
+    static constexpr bool lowest() noexcept
+    {
+        return false;
+    }
+};
+
+template<>
+struct numeric_limits<float>
+{
+    static constexpr bool is_specialized = true;
+    static constexpr bool is_signed = true;
+    static constexpr bool is_integer = false;
+    static constexpr bool is_exact = false;
+    static constexpr int digits = 24;
+
+    static constexpr float min() noexcept
+    {
+        return __FLT_MIN__;
+    }
+
+    static constexpr float max() noexcept
+    {
+        return __FLT_MAX__;
+    }
+
+    static constexpr float lowest() noexcept
+    {
+        return -max();
+    }
+};
+
+template<>
+struct numeric_limits<double>
+{
+    static constexpr bool is_specialized = true;
+    static constexpr bool is_signed = true;
+    static constexpr bool is_integer = false;
+    static constexpr bool is_exact = false;
+    static constexpr int digits = 53;
+
+    static constexpr double min() noexcept
+    {
+        return __DBL_MIN__;
+    }
+
+    static constexpr double max() noexcept
+    {
+        return __DBL_MAX__;
+    }
+
+    static constexpr double lowest() noexcept
+    {
+        return -max();
+    }
+};
+
+} // namespace ctl
+
+#endif // CTL_NUMERIC_LIMITS_H_
diff --git a/ctl/ostream.cc b/ctl/ostream.cc
new file mode 100644
index 000000000..f2ab0b302
--- /dev/null
+++ b/ctl/ostream.cc
@@ -0,0 +1,219 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ostream.h"
+#include "dubble.h"
+#include "libc/fmt/itoa.h"
+#include "libc/stdio/stdio.h"
+#include "string_view.h"
+
+namespace ctl {
+
+extern const double_conversion::DoubleToStringConverter kDoubleToPrintfG;
+
+ostream cout(stdout);
+ostream cerr(stderr);
+
+ostream::~ostream() = default;
+
+ostream::ostream(FILE* file) : ios(file)
+{
+}
+
+ostream::ostream(ostream&& other) noexcept : ios(other.file_)
+{
+    other.file_ = nullptr;
+}
+
+ostream&
+ostream::operator=(ostream&& other) noexcept
+{
+    if (this != &other) {
+        file_ = other.file_;
+        other.file_ = nullptr;
+    }
+    return *this;
+}
+
+ostream&
+ostream::operator<<(const char* str)
+{
+    if (good() && str)
+        if (fputs(str, file_) < 0)
+            setstate(badbit);
+    return *this;
+}
+
+ostream&
+ostream::operator<<(char c)
+{
+    if (good())
+        if (fputc(c, file_) == EOF)
+            setstate(badbit);
+    return *this;
+}
+
+ostream&
+ostream::operator<<(int n)
+{
+    if (good()) {
+        char buf[12];
+        FormatInt32(buf, n);
+        if (fputs(buf, file_) < 0)
+            setstate(badbit);
+    }
+    return *this;
+}
+
+ostream&
+ostream::operator<<(unsigned n)
+{
+    if (good()) {
+        char buf[12];
+        FormatUint32(buf, n);
+        if (fputs(buf, file_) < 0)
+            setstate(badbit);
+    }
+    return *this;
+}
+
+ostream&
+ostream::operator<<(long n)
+{
+    if (good()) {
+        char buf[21];
+        FormatInt64(buf, n);
+        if (fputs(buf, file_) < 0)
+            setstate(badbit);
+    }
+    return *this;
+}
+
+ostream&
+ostream::operator<<(unsigned long n)
+{
+    if (good()) {
+        char buf[21];
+        FormatUint64(buf, n);
+        if (fputs(buf, file_) < 0)
+            setstate(badbit);
+    }
+    return *this;
+}
+
+ostream&
+ostream::operator<<(float f)
+{
+    if (good()) {
+        char buf[128];
+        double_conversion::StringBuilder b(buf, sizeof(buf));
+        kDoubleToPrintfG.ToShortestSingle(f, &b);
+        b.Finalize();
+        if (fputs(buf, file_) < 0)
+            setstate(badbit);
+    }
+    return *this;
+}
+
+ostream&
+ostream::operator<<(double d)
+{
+    if (good()) {
+        char buf[128];
+        double_conversion::StringBuilder b(buf, sizeof(buf));
+        kDoubleToPrintfG.ToShortest(d, &b);
+        b.Finalize();
+        if (fputs(buf, file_) < 0)
+            setstate(badbit);
+    }
+    return *this;
+}
+
+ostream&
+ostream::operator<<(const string_view& s)
+{
+    if (good() && s.size())
+        if (!fwrite(s.data(), s.size(), 1, file_))
+            setstate(badbit);
+    return *this;
+}
+
+ostream&
+ostream::operator<<(bool b)
+{
+    if (good()) {
+        const char* value =
+          (flags() & boolalpha) ? (b ? "true" : "false") : (b ? "1" : "0");
+        if (fputs(value, file_) < 0)
+            setstate(badbit);
+    }
+    return *this;
+}
+
+ostream&
+ostream::operator<<(ostream& (*manip)(ostream&))
+{
+    return manip(*this);
+}
+
+ostream&
+ostream::put(char c)
+{
+    if (good())
+        if (fputc(c, file_) == EOF)
+            setstate(badbit);
+    return *this;
+}
+
+ostream&
+ostream::write(const char* s, streamsize n)
+{
+    if (good())
+        if (fwrite(s, 1, n, file_) != static_cast<size_t>(n))
+            setstate(badbit);
+    return *this;
+}
+
+ostream&
+ostream::flush()
+{
+    if (good())
+        if (fflush(file_) != 0)
+            setstate(badbit);
+    return *this;
+}
+
+ostream&
+endl(ostream& os)
+{
+    return os.put('\n').flush();
+}
+
+ostream&
+ends(ostream& os)
+{
+    return os.put('\0');
+}
+
+ostream&
+flush(ostream& os)
+{
+    return os.flush();
+}
+
+} // namespace ctl
diff --git a/ctl/ostream.h b/ctl/ostream.h
new file mode 100644
index 000000000..c13d5c133
--- /dev/null
+++ b/ctl/ostream.h
@@ -0,0 +1,56 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_OSTREAM_H_
+#define CTL_OSTREAM_H_
+#include "ios.h"
+
+namespace ctl {
+
+struct string_view;
+
+class ostream : public ios
+{
+  public:
+    ostream() = delete;
+    explicit ostream(FILE*);
+    virtual ~ostream();
+
+    ostream& operator<<(const char*);
+    ostream& operator<<(bool);
+    ostream& operator<<(char);
+    ostream& operator<<(int);
+    ostream& operator<<(unsigned);
+    ostream& operator<<(long);
+    ostream& operator<<(unsigned long);
+    ostream& operator<<(float);
+    ostream& operator<<(double);
+    ostream& operator<<(const ctl::string_view&);
+    ostream& operator<<(ostream& (*)(ostream&));
+
+    ostream& put(char);
+    ostream& write(const char*, streamsize);
+    ostream& flush();
+
+    ostream(ostream&&) noexcept;
+    ostream& operator=(ostream&&) noexcept;
+
+  private:
+    ostream(const ostream&) = delete;
+    ostream& operator=(const ostream&) = delete;
+};
+
+extern ostream cout;
+extern ostream cerr;
+
+ostream&
+endl(ostream&);
+
+ostream&
+ends(ostream&);
+
+ostream&
+flush(ostream&);
+
+} // namespace ctl
+
+#endif // CTL_OSTREAM_H_
diff --git a/ctl/ostringstream.cc b/ctl/ostringstream.cc
new file mode 100644
index 000000000..dcf01ff6f
--- /dev/null
+++ b/ctl/ostringstream.cc
@@ -0,0 +1,150 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ostringstream.h"
+#include "dubble.h"
+#include "libc/fmt/itoa.h"
+
+namespace ctl {
+
+extern const double_conversion::DoubleToStringConverter kDoubleToPrintfG;
+
+ostringstream::ostringstream() : buffer_(), write_pos_(0)
+{
+}
+
+ostringstream::ostringstream(const string_view& str)
+  : buffer_(str), write_pos_(0)
+{
+}
+
+string
+ostringstream::str() const
+{
+    return buffer_;
+}
+
+void
+ostringstream::str(const string& s)
+{
+    buffer_ = s;
+    write_pos_ = 0;
+}
+
+void
+ostringstream::clear()
+{
+    ios_base::clear();
+}
+
+ostringstream&
+ostringstream::operator<<(char c)
+{
+    if (good()) {
+        if (write_pos_ < buffer_.size()) {
+            buffer_[write_pos_++] = c;
+        } else {
+            buffer_.push_back(c);
+            ++write_pos_;
+        }
+    }
+    return *this;
+}
+
+ostringstream&
+ostringstream::operator<<(const string_view& s)
+{
+    if (good()) {
+        if (write_pos_ + s.size() <= buffer_.size()) {
+            buffer_.replace(write_pos_, s.size(), s);
+        } else {
+            buffer_.replace(write_pos_, buffer_.size() - write_pos_, s);
+            buffer_.append(s.substr(buffer_.size() - write_pos_));
+        }
+        write_pos_ += s.size();
+    }
+    return *this;
+}
+
+ostringstream&
+ostringstream::operator<<(int n)
+{
+    if (good()) {
+        char buf[12];
+        *this << string_view(buf, FormatInt32(buf, n) - buf);
+    }
+    return *this;
+}
+
+ostringstream&
+ostringstream::operator<<(unsigned n)
+{
+    if (good()) {
+        char buf[12];
+        *this << string_view(buf, FormatUint32(buf, n) - buf);
+    }
+    return *this;
+}
+
+ostringstream&
+ostringstream::operator<<(long n)
+{
+    if (good()) {
+        char buf[21];
+        *this << string_view(buf, FormatInt64(buf, n) - buf);
+    }
+    return *this;
+}
+
+ostringstream&
+ostringstream::operator<<(unsigned long n)
+{
+    if (good()) {
+        char buf[21];
+        *this << string_view(buf, FormatUint64(buf, n) - buf);
+    }
+    return *this;
+}
+
+ostringstream&
+ostringstream::operator<<(float f)
+{
+    if (good()) {
+        char buf[128];
+        double_conversion::StringBuilder b(buf, sizeof(buf));
+        kDoubleToPrintfG.ToShortestSingle(f, &b);
+        b.Finalize();
+        *this << string_view(buf);
+    }
+    return *this;
+}
+
+ostringstream&
+ostringstream::operator<<(double d)
+{
+    if (good()) {
+        char buf[128];
+        double_conversion::StringBuilder b(buf, sizeof(buf));
+        kDoubleToPrintfG.ToShortest(d, &b);
+        b.Finalize();
+        *this << string_view(buf);
+    }
+    return *this;
+}
+
+} // namespace ctl
diff --git a/ctl/ostringstream.h b/ctl/ostringstream.h
new file mode 100644
index 000000000..46ca777fe
--- /dev/null
+++ b/ctl/ostringstream.h
@@ -0,0 +1,36 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_OSTRINGSTREAM_H_
+#define CTL_OSTRINGSTREAM_H_
+#include "ios_base.h"
+#include "string.h"
+
+namespace ctl {
+
+class ostringstream : public ios_base
+{
+  public:
+    ostringstream();
+    explicit ostringstream(const ctl::string_view&);
+
+    ctl::string str() const;
+    void str(const ctl::string& s);
+    void clear();
+
+    ostringstream& operator<<(char);
+    ostringstream& operator<<(const ctl::string_view&);
+    ostringstream& operator<<(int);
+    ostringstream& operator<<(unsigned int);
+    ostringstream& operator<<(long);
+    ostringstream& operator<<(unsigned long);
+    ostringstream& operator<<(float);
+    ostringstream& operator<<(double);
+
+  private:
+    ctl::string buffer_;
+    size_t write_pos_;
+};
+
+} // namespace ctl
+
+#endif // CTL_OSTRINGSTREAM_H_
diff --git a/ctl/out_of_range.h b/ctl/out_of_range.h
new file mode 100644
index 000000000..27b76e82d
--- /dev/null
+++ b/ctl/out_of_range.h
@@ -0,0 +1,23 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_OUT_OF_RANGE_H_
+#define CTL_OUT_OF_RANGE_H_
+#include "exception.h"
+
+namespace ctl {
+
+class out_of_range : public ctl::exception
+{
+  public:
+    out_of_range() noexcept = default;
+    ~out_of_range() override = default;
+
+    const char* what() const noexcept override
+    {
+        return "ctl::out_of_range";
+    }
+};
+
+} // namespace ctl
+
+#endif // CTL_OUT_OF_RANGE_H_
diff --git a/ctl/partition.h b/ctl/partition.h
new file mode 100644
index 000000000..a1db21fb2
--- /dev/null
+++ b/ctl/partition.h
@@ -0,0 +1,29 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_PARTITION_H_
+#define CTL_PARTITION_H_
+#include "utility.h"
+
+namespace ctl {
+
+template<typename RandomIt, typename Compare>
+RandomIt
+partition(RandomIt first, RandomIt last, Compare comp)
+{
+    auto pivot = *ctl::move(last - 1);
+    auto i = first - 1;
+
+    for (auto j = first; j < last - 1; ++j) {
+        if (comp(*j, pivot)) {
+            ++i;
+            ctl::swap(*i, *j);
+        }
+    }
+
+    ctl::swap(*(i + 1), *(last - 1));
+    return i + 1;
+}
+
+} // namespace ctl
+
+#endif // CTL_PARTITION_H_
diff --git a/ctl/remove_cv.h b/ctl/remove_cv.h
new file mode 100644
index 000000000..2801f7d80
--- /dev/null
+++ b/ctl/remove_cv.h
@@ -0,0 +1,49 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_REMOVE_CV_H_
+#define CTL_REMOVE_CV_H_
+
+namespace ctl {
+
+template<class T>
+struct remove_const
+{
+    typedef T type;
+};
+
+template<class T>
+struct remove_const<const T>
+{
+    typedef T type;
+};
+
+template<class T>
+struct remove_volatile
+{
+    typedef T type;
+};
+
+template<class T>
+struct remove_volatile<volatile T>
+{
+    typedef T type;
+};
+
+template<class T>
+struct remove_cv
+{
+    typedef typename remove_volatile<typename remove_const<T>::type>::type type;
+};
+
+template<class T>
+using remove_const_t = typename remove_const<T>::type;
+
+template<class T>
+using remove_volatile_t = typename remove_volatile<T>::type;
+
+template<class T>
+using remove_cv_t = typename remove_cv<T>::type;
+
+} // namespace ctl
+
+#endif // CTL_REMOVE_CV_H_
diff --git a/ctl/remove_extent.h b/ctl/remove_extent.h
new file mode 100644
index 000000000..7aef1d20a
--- /dev/null
+++ b/ctl/remove_extent.h
@@ -0,0 +1,31 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_REMOVE_EXTENT_H_
+#define CTL_REMOVE_EXTENT_H_
+
+namespace ctl {
+
+template<typename T>
+struct remove_extent
+{
+    typedef T type;
+};
+
+template<typename T, size_t N>
+struct remove_extent<T[N]>
+{
+    typedef T type;
+};
+
+template<typename T>
+struct remove_extent<T[]>
+{
+    typedef T type;
+};
+
+template<typename T>
+using remove_extent_t = typename remove_extent<T>::type;
+
+} // namespace ctl
+
+#endif // CTL_REMOVE_EXTENT_H_
diff --git a/ctl/remove_reference.h b/ctl/remove_reference.h
new file mode 100644
index 000000000..3e773e0ce
--- /dev/null
+++ b/ctl/remove_reference.h
@@ -0,0 +1,31 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_REMOVE_REFERENCE_H_
+#define CTL_REMOVE_REFERENCE_H_
+
+namespace ctl {
+
+template<class T>
+struct remove_reference
+{
+    typedef T type;
+};
+
+template<class T>
+struct remove_reference<T&>
+{
+    typedef T type;
+};
+
+template<class T>
+struct remove_reference<T&&>
+{
+    typedef T type;
+};
+
+template<class T>
+using remove_reference_t = typename remove_reference<T>::type;
+
+} // namespace ctl
+
+#endif // CTL_REMOVE_REFERENCE_H_
diff --git a/ctl/require_input_iterator.h b/ctl/require_input_iterator.h
new file mode 100644
index 000000000..221e06a74
--- /dev/null
+++ b/ctl/require_input_iterator.h
@@ -0,0 +1,19 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_REQUIRE_INPUT_ITERATOR_H_
+#define CTL_REQUIRE_INPUT_ITERATOR_H_
+#include "enable_if.h"
+#include "is_convertible.h"
+#include "iterator.h"
+#include "iterator_traits.h"
+
+namespace ctl {
+
+template<typename InputIt>
+using require_input_iterator = typename ctl::enable_if<
+  ctl::is_convertible<typename ctl::iterator_traits<InputIt>::iterator_category,
+                      ctl::input_iterator_tag>::value>::type;
+
+} // namespace ctl
+
+#endif /* CTL_REQUIRE_INPUT_ITERATOR_H_ */
diff --git a/ctl/reverse_iterator.h b/ctl/reverse_iterator.h
new file mode 100644
index 000000000..67d5c23ea
--- /dev/null
+++ b/ctl/reverse_iterator.h
@@ -0,0 +1,184 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_REVERSE_ITERATOR_H_
+#define CTL_REVERSE_ITERATOR_H_
+#include "iterator_traits.h"
+#include "utility.h"
+
+namespace ctl {
+
+template<class Iterator>
+class reverse_iterator
+{
+  public:
+    using iterator_type = Iterator;
+    using iterator_category =
+      typename ctl::iterator_traits<Iterator>::iterator_category;
+    using value_type = typename ctl::iterator_traits<Iterator>::value_type;
+    using difference_type =
+      typename ctl::iterator_traits<Iterator>::difference_type;
+    using pointer = typename ctl::iterator_traits<Iterator>::pointer;
+    using reference = typename ctl::iterator_traits<Iterator>::reference;
+
+    constexpr reverse_iterator() : current()
+    {
+    }
+
+    constexpr explicit reverse_iterator(Iterator x) : current(x)
+    {
+    }
+
+    template<class U>
+    constexpr reverse_iterator(const reverse_iterator<U>& other)
+      : current(other.base())
+    {
+    }
+
+    template<class U>
+    constexpr reverse_iterator& operator=(const reverse_iterator<U>& other)
+    {
+        current = other.base();
+        return *this;
+    }
+
+    constexpr Iterator base() const
+    {
+        return current;
+    }
+
+    constexpr reference operator*() const
+    {
+        Iterator tmp = current;
+        return *--tmp;
+    }
+
+    constexpr pointer operator->() const
+    {
+        return &(operator*());
+    }
+
+    constexpr reverse_iterator& operator++()
+    {
+        --current;
+        return *this;
+    }
+
+    constexpr reverse_iterator operator++(int)
+    {
+        reverse_iterator tmp = *this;
+        --current;
+        return tmp;
+    }
+
+    constexpr reverse_iterator& operator--()
+    {
+        ++current;
+        return *this;
+    }
+
+    constexpr reverse_iterator operator--(int)
+    {
+        reverse_iterator tmp = *this;
+        ++current;
+        return tmp;
+    }
+
+    constexpr reverse_iterator operator+(difference_type n) const
+    {
+        return reverse_iterator(current - n);
+    }
+
+    constexpr reverse_iterator& operator+=(difference_type n)
+    {
+        current -= n;
+        return *this;
+    }
+
+    constexpr reverse_iterator operator-(difference_type n) const
+    {
+        return reverse_iterator(current + n);
+    }
+
+    constexpr reverse_iterator& operator-=(difference_type n)
+    {
+        current += n;
+        return *this;
+    }
+
+    constexpr reference operator[](difference_type n) const
+    {
+        return *(*this + n);
+    }
+
+  protected:
+    Iterator current;
+};
+
+template<class Iterator1, class Iterator2>
+constexpr bool
+operator==(const reverse_iterator<Iterator1>& lhs,
+           const reverse_iterator<Iterator2>& rhs)
+{
+    return lhs.base() == rhs.base();
+}
+
+template<class Iterator1, class Iterator2>
+constexpr bool
+operator!=(const reverse_iterator<Iterator1>& lhs,
+           const reverse_iterator<Iterator2>& rhs)
+{
+    return lhs.base() != rhs.base();
+}
+
+template<class Iterator1, class Iterator2>
+constexpr bool
+operator<(const reverse_iterator<Iterator1>& lhs,
+          const reverse_iterator<Iterator2>& rhs)
+{
+    return rhs.base() < lhs.base();
+}
+
+template<class Iterator1, class Iterator2>
+constexpr bool
+operator<=(const reverse_iterator<Iterator1>& lhs,
+           const reverse_iterator<Iterator2>& rhs)
+{
+    return !(rhs < lhs);
+}
+
+template<class Iterator1, class Iterator2>
+constexpr bool
+operator>(const reverse_iterator<Iterator1>& lhs,
+          const reverse_iterator<Iterator2>& rhs)
+{
+    return rhs < lhs;
+}
+
+template<class Iterator1, class Iterator2>
+constexpr bool
+operator>=(const reverse_iterator<Iterator1>& lhs,
+           const reverse_iterator<Iterator2>& rhs)
+{
+    return !(lhs < rhs);
+}
+
+template<class Iterator>
+constexpr reverse_iterator<Iterator>
+operator+(typename reverse_iterator<Iterator>::difference_type n,
+          const reverse_iterator<Iterator>& it)
+{
+    return reverse_iterator<Iterator>(it.base() - n);
+}
+
+template<class Iterator1, class Iterator2>
+constexpr auto
+operator-(const reverse_iterator<Iterator1>& lhs,
+          const reverse_iterator<Iterator2>& rhs) -> decltype(rhs.base() -
+                                                              lhs.base())
+{
+    return rhs.base() - lhs.base();
+}
+
+} // namespace ctl
+
+#endif // CTL_REVERSE_ITERATOR_H_
diff --git a/ctl/runtime_error.h b/ctl/runtime_error.h
new file mode 100644
index 000000000..29cc5f301
--- /dev/null
+++ b/ctl/runtime_error.h
@@ -0,0 +1,33 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_RUNTIME_ERROR_H_
+#define CTL_RUNTIME_ERROR_H_
+#include "ctl/string.h"
+
+namespace ctl {
+
+class runtime_error
+{
+  public:
+    explicit runtime_error(const string& what_arg) : msg_(what_arg)
+    {
+    }
+
+    explicit runtime_error(const char* what_arg) : msg_(what_arg)
+    {
+    }
+
+    virtual ~runtime_error() noexcept = default;
+
+    virtual const char* what() const noexcept
+    {
+        return msg_.c_str();
+    }
+
+  private:
+    string msg_;
+};
+
+} // namespace ctl
+
+#endif // CTL_RUNTIME_ERROR_H_
diff --git a/ctl/set.h b/ctl/set.h
index 94644d267..2216ca851 100644
--- a/ctl/set.h
+++ b/ctl/set.h
@@ -8,23 +8,39 @@
 
 namespace ctl {
 
-template<typename Key, typename Compare = less<Key>>
+template<typename Key, typename Compare = ctl::less<Key>>
 class set
 {
     struct rbtree
     {
-        rbtree* left;
+        uintptr_t left_;
         rbtree* right;
         rbtree* parent;
-        bool is_red;
         Key value;
 
+        rbtree* left() const
+        {
+            return (rbtree*)(left_ & -2);
+        }
+
+        void left(rbtree* val)
+        {
+            left_ = (uintptr_t)val | (left_ & 1);
+        }
+
+        bool is_red() const
+        {
+            return left_ & 1;
+        }
+
+        void is_red(bool val)
+        {
+            left_ &= -2;
+            left_ |= val;
+        }
+
         rbtree(const Key& val)
-          : left(nullptr)
-          , right(nullptr)
-          , parent(nullptr)
-          , is_red(true)
-          , value(val)
+          : left_(1), right(nullptr), parent(nullptr), value(val)
         {
         }
     };
@@ -85,14 +101,14 @@ class set
         {
             if (node_ == nullptr)
                 __builtin_trap();
-            if (node_->left) {
-                node_ = rightmost(node_->left);
+            if (node_->left()) {
+                node_ = rightmost(node_->left());
             } else {
                 node_type* parent = node_->parent;
                 for (;;) {
                     if (parent == nullptr)
                         break;
-                    if (node_ == parent->left) {
+                    if (node_ == parent->left()) {
                         node_ = parent;
                         parent = parent->parent;
                     } else {
@@ -161,11 +177,11 @@ class set
 
         reverse_iterator& operator++()
         {
-            if (node_->left) {
-                node_ = rightmost(node_->left);
+            if (node_->left()) {
+                node_ = rightmost(node_->left());
             } else {
                 node_type* parent = node_->parent;
-                while (parent && node_ == parent->left) {
+                while (parent && node_ == parent->left()) {
                     node_ = parent;
                     parent = parent->parent;
                 }
@@ -225,8 +241,9 @@ class set
       private:
         friend class set;
         node_type* node_;
+        node_type* root_;
 
-        explicit reverse_iterator(node_type* node) : node_(node)
+        explicit reverse_iterator(node_type* node, node_type* root) : node_(node), root_(root)
         {
         }
     };
@@ -331,17 +348,17 @@ class set
 
     reverse_iterator rbegin()
     {
-        return reverse_iterator(rightmost(root_));
+        return reverse_iterator(rightmost(root_), root_);
     }
 
     const_reverse_iterator rbegin() const
     {
-        return const_reverse_iterator(rightmost(root_));
+        return const_reverse_iterator(rightmost(root_), root_);
     }
 
     const_reverse_iterator crbegin() const
     {
-        return const_reverse_iterator(rightmost(root_));
+        return const_reverse_iterator(rightmost(root_), root_);
     }
 
     iterator end() noexcept
@@ -361,17 +378,17 @@ class set
 
     reverse_iterator rend()
     {
-        return reverse_iterator(nullptr);
+        return reverse_iterator(nullptr, root_);
     }
 
     const_reverse_iterator rend() const
     {
-        return const_reverse_iterator(nullptr);
+        return const_reverse_iterator(nullptr, root_);
     }
 
     const_reverse_iterator crend() const
     {
-        return const_reverse_iterator(nullptr);
+        return const_reverse_iterator(nullptr, root_);
     }
 
     void clear() noexcept
@@ -381,12 +398,12 @@ class set
         size_ = 0;
     }
 
-    pair<iterator, bool> insert(value_type&& value)
+    ctl::pair<iterator, bool> insert(value_type&& value)
     {
         return insert_node(new node_type(ctl::move(value)));
     }
 
-    pair<iterator, bool> insert(const value_type& value)
+    ctl::pair<iterator, bool> insert(const value_type& value)
     {
         return insert_node(new node_type(value));
     }
@@ -415,7 +432,7 @@ class set
     }
 
     template<class... Args>
-    pair<iterator, bool> emplace(Args&&... args)
+    ctl::pair<iterator, bool> emplace(Args&&... args)
     {
         value_type value(ctl::forward<Args>(args)...);
         return insert(ctl::move(value));
@@ -451,12 +468,13 @@ class set
         ctl::swap(size_, other.size_);
     }
 
-    pair<iterator, iterator> equal_range(const key_type& key)
+    ctl::pair<iterator, iterator> equal_range(const key_type& key)
     {
         return { iterator(get_floor(key)), iterator(get_ceiling(key)) };
     }
 
-    pair<const_iterator, const_iterator> equal_range(const key_type& key) const
+    ctl::pair<const_iterator, const_iterator> equal_range(
+      const key_type& key) const
     {
         return { const_iterator(get_floor(key)),
                  const_iterator(get_ceiling(key)) };
@@ -507,7 +525,7 @@ class set
     {
         size_type count = 0;
         if (root_ != nullptr) {
-            if (root_->is_red)
+            if (root_->is_red())
                 // ILLEGAL TREE: root node must be black
                 __builtin_trap();
             int black_height = -1;
@@ -522,8 +540,8 @@ class set
   private:
     static node_type* leftmost(node_type* node) noexcept
     {
-        while (node && node->left)
-            node = node->left;
+        while (node && node->left())
+            node = node->left();
         return node;
     }
 
@@ -534,35 +552,35 @@ class set
         return node;
     }
 
-    static void clearer(node_type* node) noexcept
+    static optimizesize void clearer(node_type* node) noexcept
     {
         node_type* right;
         for (; node; node = right) {
             right = node->right;
-            clearer(node->left);
+            clearer(node->left());
             delete node;
         }
     }
 
-    static node_type* copier(const node_type* node)
+    static optimizesize node_type* copier(const node_type* node)
     {
         if (node == nullptr)
             return nullptr;
         node_type* new_node = new node_type(node->value);
-        new_node->left = copier(node->left);
+        new_node->left(copier(node->left()));
         new_node->right = copier(node->right);
-        if (new_node->left)
-            new_node->left->parent = new_node;
+        if (new_node->left())
+            new_node->left()->parent = new_node;
         if (new_node->right)
             new_node->right->parent = new_node;
         return new_node;
     }
 
-    static size_type tally(const node_type* node)
+    static optimizesize size_type tally(const node_type* node)
     {
         if (node == nullptr)
             return 0;
-        return 1 + tally(node->left) + tally(node->right);
+        return 1 + tally(node->left()) + tally(node->right);
     }
 
     template<typename K>
@@ -571,7 +589,7 @@ class set
         node_type* current = root_;
         while (current != nullptr) {
             if (comp_(key, current->value)) {
-                current = current->left;
+                current = current->left();
             } else if (comp_(current->value, key)) {
                 current = current->right;
             } else {
@@ -589,7 +607,7 @@ class set
         while (current != nullptr) {
             if (!comp_(current->value, key)) {
                 result = current;
-                current = current->left;
+                current = current->left();
             } else {
                 current = current->right;
             }
@@ -605,7 +623,7 @@ class set
         while (current != nullptr) {
             if (comp_(key, current->value)) {
                 result = current;
-                current = current->left;
+                current = current->left();
             } else {
                 current = current->right;
             }
@@ -613,11 +631,11 @@ class set
         return result;
     }
 
-    pair<iterator, bool> insert_node(node_type* node)
+    optimizesize ctl::pair<iterator, bool> insert_node(node_type* node)
     {
         if (root_ == nullptr) {
             root_ = node;
-            root_->is_red = false;
+            root_->is_red(false);
             size_++;
             return { iterator(root_), true };
         }
@@ -626,7 +644,7 @@ class set
         while (current != nullptr) {
             parent = current;
             if (comp_(node->value, current->value)) {
-                current = current->left;
+                current = current->left();
             } else if (comp_(current->value, node->value)) {
                 current = current->right;
             } else {
@@ -635,7 +653,7 @@ class set
             }
         }
         if (comp_(node->value, parent->value)) {
-            parent->left = node;
+            parent->left(node);
         } else {
             parent->right = node;
         }
@@ -645,23 +663,23 @@ class set
         return { iterator(node), true };
     }
 
-    void erase_node(node_type* node)
+    optimizesize void erase_node(node_type* node)
     {
         node_type* y = node;
         node_type* x = nullptr;
         node_type* x_parent = nullptr;
-        bool y_original_color = y->is_red;
-        if (node->left == nullptr) {
+        bool y_original_color = y->is_red();
+        if (node->left() == nullptr) {
             x = node->right;
             transplant(node, node->right);
             x_parent = node->parent;
         } else if (node->right == nullptr) {
-            x = node->left;
-            transplant(node, node->left);
+            x = node->left();
+            transplant(node, node->left());
             x_parent = node->parent;
         } else {
             y = leftmost(node->right);
-            y_original_color = y->is_red;
+            y_original_color = y->is_red();
             x = y->right;
             if (y->parent == node) {
                 if (x)
@@ -674,9 +692,9 @@ class set
                 x_parent = y->parent;
             }
             transplant(node, y);
-            y->left = node->left;
-            y->left->parent = y;
-            y->is_red = node->is_red;
+            y->left(node->left());
+            y->left()->parent = y;
+            y->is_red(node->is_red());
         }
         if (!y_original_color)
             rebalance_after_erase(x, x_parent);
@@ -684,28 +702,28 @@ class set
         --size_;
     }
 
-    void left_rotate(node_type* x)
+    optimizesize void left_rotate(node_type* x)
     {
         node_type* y = x->right;
-        x->right = y->left;
-        if (y->left != nullptr)
-            y->left->parent = x;
+        x->right = y->left();
+        if (y->left() != nullptr)
+            y->left()->parent = x;
         y->parent = x->parent;
         if (x->parent == nullptr) {
             root_ = y;
-        } else if (x == x->parent->left) {
-            x->parent->left = y;
+        } else if (x == x->parent->left()) {
+            x->parent->left(y);
         } else {
             x->parent->right = y;
         }
-        y->left = x;
+        y->left(x);
         x->parent = y;
     }
 
-    void right_rotate(node_type* y)
+    optimizesize void right_rotate(node_type* y)
     {
-        node_type* x = y->left;
-        y->left = x->right;
+        node_type* x = y->left();
+        y->left(x->right);
         if (x->right != nullptr)
             x->right->parent = y;
         x->parent = y->parent;
@@ -714,18 +732,18 @@ class set
         } else if (y == y->parent->right) {
             y->parent->right = x;
         } else {
-            y->parent->left = x;
+            y->parent->left(x);
         }
         x->right = y;
         y->parent = x;
     }
 
-    void transplant(node_type* u, node_type* v)
+    optimizesize void transplant(node_type* u, node_type* v)
     {
         if (u->parent == nullptr) {
             root_ = v;
-        } else if (u == u->parent->left) {
-            u->parent->left = v;
+        } else if (u == u->parent->left()) {
+            u->parent->left(v);
         } else {
             u->parent->right = v;
         }
@@ -733,10 +751,10 @@ class set
             v->parent = u->parent;
     }
 
-    void checker(const node_type* node,
-                 const node_type* parent,
-                 int black_count,
-                 int& black_height) const
+    optimizesize void checker(const node_type* node,
+                              const node_type* parent,
+                              int black_count,
+                              int& black_height) const
     {
         if (node == nullptr) {
             // Leaf nodes are considered black
@@ -752,117 +770,121 @@ class set
             // ILLEGAL TREE: Parent link is incorrect
             __builtin_trap();
         if (parent) {
-            if (parent->left == node && !comp_(node->value, parent->value))
+            if (parent->left() == node && !comp_(node->value, parent->value))
                 // ILLEGAL TREE: Binary search property violated on left child
                 __builtin_trap();
             if (parent->right == node && !comp_(parent->value, node->value))
                 // ILLEGAL TREE: Binary search property violated on right child
                 __builtin_trap();
         }
-        if (!node->is_red) {
+        if (!node->is_red()) {
             black_count++;
-        } else if (parent != nullptr && parent->is_red) {
+        } else if (parent != nullptr && parent->is_red()) {
             // ILLEGAL TREE: Red node has red child
             __builtin_trap();
         }
-        checker(node->left, node, black_count, black_height);
+        checker(node->left(), node, black_count, black_height);
         checker(node->right, node, black_count, black_height);
     }
 
-    void rebalance_after_insert(node_type* node)
+    optimizesize void rebalance_after_insert(node_type* node)
     {
-        node->is_red = true;
-        while (node != root_ && node->parent->is_red) {
-            if (node->parent == node->parent->parent->left) {
+        node->is_red(true);
+        while (node != root_ && node->parent->is_red()) {
+            if (node->parent == node->parent->parent->left()) {
                 node_type* uncle = node->parent->parent->right;
-                if (uncle && uncle->is_red) {
-                    node->parent->is_red = false;
-                    uncle->is_red = false;
-                    node->parent->parent->is_red = true;
+                if (uncle && uncle->is_red()) {
+                    node->parent->is_red(false);
+                    uncle->is_red(false);
+                    node->parent->parent->is_red(true);
                     node = node->parent->parent;
                 } else {
                     if (node == node->parent->right) {
                         node = node->parent;
                         left_rotate(node);
                     }
-                    node->parent->is_red = false;
-                    node->parent->parent->is_red = true;
+                    node->parent->is_red(false);
+                    node->parent->parent->is_red(true);
                     right_rotate(node->parent->parent);
                 }
             } else {
-                node_type* uncle = node->parent->parent->left;
-                if (uncle && uncle->is_red) {
-                    node->parent->is_red = false;
-                    uncle->is_red = false;
-                    node->parent->parent->is_red = true;
+                node_type* uncle = node->parent->parent->left();
+                if (uncle && uncle->is_red()) {
+                    node->parent->is_red(false);
+                    uncle->is_red(false);
+                    node->parent->parent->is_red(true);
                     node = node->parent->parent;
                 } else {
-                    if (node == node->parent->left) {
+                    if (node == node->parent->left()) {
                         node = node->parent;
                         right_rotate(node);
                     }
-                    node->parent->is_red = false;
-                    node->parent->parent->is_red = true;
+                    node->parent->is_red(false);
+                    node->parent->parent->is_red(true);
                     left_rotate(node->parent->parent);
                 }
             }
         }
-        root_->is_red = false;
+        root_->is_red(false);
     }
 
-    void rebalance_after_erase(node_type* node, node_type* parent)
+    optimizesize void rebalance_after_erase(node_type* node, node_type* parent)
     {
-        while (node != root_ && (node == nullptr || !node->is_red)) {
-            if (node == parent->left) {
+        while (node != root_ && (node == nullptr || !node->is_red())) {
+            if (node == parent->left()) {
                 node_type* sibling = parent->right;
-                if (sibling->is_red) {
-                    sibling->is_red = false;
-                    parent->is_red = true;
+                if (sibling->is_red()) {
+                    sibling->is_red(false);
+                    parent->is_red(true);
                     left_rotate(parent);
                     sibling = parent->right;
                 }
-                if ((sibling->left == nullptr || !sibling->left->is_red) &&
-                    (sibling->right == nullptr || !sibling->right->is_red)) {
-                    sibling->is_red = true;
+                if ((sibling->left() == nullptr ||
+                     !sibling->left()->is_red()) &&
+                    (sibling->right == nullptr || !sibling->right->is_red())) {
+                    sibling->is_red(true);
                     node = parent;
                     parent = node->parent;
                 } else {
-                    if (sibling->right == nullptr || !sibling->right->is_red) {
-                        sibling->left->is_red = false;
-                        sibling->is_red = true;
+                    if (sibling->right == nullptr ||
+                        !sibling->right->is_red()) {
+                        sibling->left()->is_red(false);
+                        sibling->is_red(true);
                         right_rotate(sibling);
                         sibling = parent->right;
                     }
-                    sibling->is_red = parent->is_red;
-                    parent->is_red = false;
-                    sibling->right->is_red = false;
+                    sibling->is_red(parent->is_red());
+                    parent->is_red(false);
+                    sibling->right->is_red(false);
                     left_rotate(parent);
                     node = root_;
                     break;
                 }
             } else {
-                node_type* sibling = parent->left;
-                if (sibling->is_red) {
-                    sibling->is_red = false;
-                    parent->is_red = true;
+                node_type* sibling = parent->left();
+                if (sibling->is_red()) {
+                    sibling->is_red(false);
+                    parent->is_red(true);
                     right_rotate(parent);
-                    sibling = parent->left;
+                    sibling = parent->left();
                 }
-                if ((sibling->right == nullptr || !sibling->right->is_red) &&
-                    (sibling->left == nullptr || !sibling->left->is_red)) {
-                    sibling->is_red = true;
+                if ((sibling->right == nullptr || !sibling->right->is_red()) &&
+                    (sibling->left() == nullptr ||
+                     !sibling->left()->is_red())) {
+                    sibling->is_red(true);
                     node = parent;
                     parent = node->parent;
                 } else {
-                    if (sibling->left == nullptr || !sibling->left->is_red) {
-                        sibling->right->is_red = false;
-                        sibling->is_red = true;
+                    if (sibling->left() == nullptr ||
+                        !sibling->left()->is_red()) {
+                        sibling->right->is_red(false);
+                        sibling->is_red(true);
                         left_rotate(sibling);
-                        sibling = parent->left;
+                        sibling = parent->left();
                     }
-                    sibling->is_red = parent->is_red;
-                    parent->is_red = false;
-                    sibling->left->is_red = false;
+                    sibling->is_red(parent->is_red());
+                    parent->is_red(false);
+                    sibling->left()->is_red(false);
                     right_rotate(parent);
                     node = root_;
                     break;
@@ -870,7 +892,7 @@ class set
             }
         }
         if (node != nullptr)
-            node->is_red = false;
+            node->is_red(false);
     }
 
     node_type* root_;
@@ -878,7 +900,7 @@ class set
     Compare comp_;
 };
 
-template<class Key, typename Compare = less<Key>>
+template<class Key, typename Compare = ctl::less<Key>>
 bool
 operator==(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
 {
@@ -893,7 +915,7 @@ operator==(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
     return true;
 }
 
-template<class Key, typename Compare = less<Key>>
+template<class Key, typename Compare = ctl::less<Key>>
 bool
 operator<(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
 {
@@ -908,35 +930,35 @@ operator<(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
     return i == lhs.end() && j != rhs.end();
 }
 
-template<class Key, typename Compare = less<Key>>
+template<class Key, typename Compare = ctl::less<Key>>
 bool
 operator!=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
 {
     return !(lhs == rhs);
 }
 
-template<class Key, typename Compare = less<Key>>
+template<class Key, typename Compare = ctl::less<Key>>
 bool
 operator<=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
 {
     return !(rhs < lhs);
 }
 
-template<class Key, typename Compare = less<Key>>
+template<class Key, typename Compare = ctl::less<Key>>
 bool
 operator>(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
 {
     return rhs < lhs;
 }
 
-template<class Key, typename Compare = less<Key>>
+template<class Key, typename Compare = ctl::less<Key>>
 bool
 operator>=(const set<Key, Compare>& lhs, const set<Key, Compare>& rhs)
 {
     return !(lhs < rhs);
 }
 
-template<class Key, typename Compare = less<Key>>
+template<class Key, typename Compare = ctl::less<Key>>
 void
 swap(set<Key, Compare>& lhs, set<Key, Compare>& rhs) noexcept;
 
diff --git a/ctl/shared_ptr.h b/ctl/shared_ptr.h
new file mode 100644
index 000000000..8aac68070
--- /dev/null
+++ b/ctl/shared_ptr.h
@@ -0,0 +1,618 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_SHARED_PTR_H_
+#define CTL_SHARED_PTR_H_
+
+#include "exception.h"
+#include "is_base_of.h"
+#include "is_constructible.h"
+#include "is_convertible.h"
+#include "remove_extent.h"
+#include "unique_ptr.h"
+
+// XXX currently needed to use placement-new syntax (move to cxx.inc?)
+void*
+operator new(size_t, void*) noexcept;
+
+namespace ctl {
+
+class bad_weak_ptr : public exception
+{
+  public:
+    const char* what() const noexcept override
+    {
+        return "ctl::bad_weak_ptr";
+    }
+};
+
+namespace __ {
+
+template<typename T>
+struct ptr_ref
+{
+    using type = T&;
+};
+
+template<>
+struct ptr_ref<void>
+{
+    using type = void;
+};
+
+static inline __attribute__((always_inline)) void
+incref(size_t* r) noexcept
+{
+#ifdef NDEBUG
+    __atomic_fetch_add(r, 1, __ATOMIC_RELAXED);
+#else
+    ssize_t refs = __atomic_fetch_add(r, 1, __ATOMIC_RELAXED);
+    if (refs < 0)
+        __builtin_trap();
+#endif
+}
+
+static inline __attribute__((always_inline)) bool
+decref(size_t* r) noexcept
+{
+    if (!__atomic_fetch_sub(r, 1, __ATOMIC_RELEASE)) {
+        __atomic_thread_fence(__ATOMIC_ACQUIRE);
+        return true;
+    }
+    return false;
+}
+
+class shared_ref
+{
+  public:
+    constexpr shared_ref() noexcept = default;
+    shared_ref(const shared_ref&) = delete;
+    shared_ref& operator=(const shared_ref&) = delete;
+
+    virtual ~shared_ref() = default;
+
+    void keep_shared() noexcept
+    {
+        incref(&shared);
+    }
+
+    void drop_shared() noexcept
+    {
+        if (decref(&shared)) {
+            dispose();
+            drop_weak();
+        }
+    }
+
+    void keep_weak() noexcept
+    {
+        incref(&weak);
+    }
+
+    void drop_weak() noexcept
+    {
+        if (decref(&weak)) {
+            delete this;
+        }
+    }
+
+    size_t use_count() const noexcept
+    {
+        return __atomic_load_n(&shared, __ATOMIC_RELAXED) + 1;
+    }
+
+    size_t weak_count() const noexcept
+    {
+        return __atomic_load_n(&weak, __ATOMIC_RELAXED);
+    }
+
+  private:
+    virtual void dispose() noexcept = 0;
+
+    size_t shared = 0;
+    size_t weak = 0;
+};
+
+template<typename T, typename D>
+class shared_pointer : public shared_ref
+{
+  public:
+    static shared_pointer* make(T* const p, D d)
+    {
+        return make(unique_ptr<T, D>(p, move(d)));
+    }
+
+    static shared_pointer* make(unique_ptr<T, D> p)
+    {
+        return new shared_pointer(p.release(), move(p.get_deleter()));
+    }
+
+  private:
+    shared_pointer(T* const p, D d) noexcept : p(p), d(move(d))
+    {
+    }
+
+    void dispose() noexcept override
+    {
+        move(d)(p);
+    }
+
+    T* const p;
+    [[no_unique_address]] D d;
+};
+
+template<typename T>
+class shared_emplace : public shared_ref
+{
+  public:
+    union
+    {
+        T t;
+    };
+
+    ~shared_emplace() override
+    {
+    }
+
+    template<typename... Args>
+    void construct(Args&&... args)
+    {
+        ::new (&t) T(forward<Args>(args)...);
+    }
+
+    static unique_ptr<shared_emplace> make()
+    {
+        return unique_ptr(new shared_emplace());
+    }
+
+  private:
+    explicit constexpr shared_emplace() noexcept
+    {
+    }
+
+    void dispose() noexcept override
+    {
+        t.~T();
+    }
+};
+
+template<typename T, typename U>
+concept shared_ptr_compatible = is_convertible_v<U*, T*>;
+
+} // namespace __
+
+template<typename T>
+class weak_ptr;
+
+template<typename T>
+class shared_ptr
+{
+  public:
+    using element_type = remove_extent_t<T>;
+    using weak_type = weak_ptr<T>;
+
+    constexpr shared_ptr() noexcept = default;
+    constexpr shared_ptr(nullptr_t) noexcept
+    {
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    explicit shared_ptr(U* const p) : shared_ptr(p, default_delete<U>())
+    {
+    }
+
+    template<typename U, typename D>
+        requires __::shared_ptr_compatible<T, U>
+    shared_ptr(U*, D);
+
+    template<typename U>
+    shared_ptr(const shared_ptr<U>& r, element_type* p) noexcept
+      : p(p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_shared();
+    }
+
+    template<typename U>
+    shared_ptr(shared_ptr<U>&& r, element_type* p) noexcept : p(p), rc(r.rc)
+    {
+        r.p = nullptr;
+        r.rc = nullptr;
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    shared_ptr(const shared_ptr<U>& r) noexcept : p(r.p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_shared();
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    shared_ptr(shared_ptr<U>&& r) noexcept : p(r.p), rc(r.rc)
+    {
+        r.p = nullptr;
+        r.rc = nullptr;
+    }
+
+    shared_ptr(const shared_ptr& r) noexcept : p(r.p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_shared();
+    }
+
+    shared_ptr(shared_ptr&& r) noexcept : p(r.p), rc(r.rc)
+    {
+        r.p = nullptr;
+        r.rc = nullptr;
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    explicit shared_ptr(const weak_ptr<U>& r) : p(r.p), rc(r.rc)
+    {
+        if (r.expired()) {
+            throw bad_weak_ptr();
+        }
+        rc->keep_shared();
+    }
+
+    template<typename U, typename D>
+        requires __::shared_ptr_compatible<T, U>
+    shared_ptr(unique_ptr<U, D>&& r)
+      : p(r.p), rc(__::shared_pointer<U, D>::make(move(r)))
+    {
+    }
+
+    ~shared_ptr()
+    {
+        if (rc)
+            rc->drop_shared();
+    }
+
+    shared_ptr& operator=(shared_ptr r) noexcept
+    {
+        swap(r);
+        return *this;
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    shared_ptr& operator=(shared_ptr<U> r) noexcept
+    {
+        shared_ptr<T>(move(r)).swap(*this);
+        return *this;
+    }
+
+    void reset() noexcept
+    {
+        shared_ptr().swap(*this);
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    void reset(U* const p2)
+    {
+        shared_ptr<T>(p2).swap(*this);
+    }
+
+    template<typename U, typename D>
+        requires __::shared_ptr_compatible<T, U>
+    void reset(U* const p2, D d)
+    {
+        shared_ptr<T>(p2, d).swap(*this);
+    }
+
+    void swap(shared_ptr& r) noexcept
+    {
+        using ctl::swap;
+        swap(p, r.p);
+        swap(rc, r.rc);
+    }
+
+    element_type* get() const noexcept
+    {
+        return p;
+    }
+
+    typename __::ptr_ref<T>::type operator*() const noexcept
+    {
+        if (!p)
+            __builtin_trap();
+        return *p;
+    }
+
+    T* operator->() const noexcept
+    {
+        if (!p)
+            __builtin_trap();
+        return p;
+    }
+
+    long use_count() const noexcept
+    {
+        return rc ? rc->use_count() : 0;
+    }
+
+    explicit operator bool() const noexcept
+    {
+        return p;
+    }
+
+    template<typename U>
+    bool owner_before(const shared_ptr<U>& r) const noexcept
+    {
+        return rc < r.rc;
+    }
+
+    template<typename U>
+    bool owner_before(const weak_ptr<U>& r) const noexcept
+    {
+        return rc < r.rc;
+    }
+
+  private:
+    template<typename U>
+    friend class weak_ptr;
+
+    template<typename U>
+    friend class shared_ptr;
+
+    template<typename U, typename... Args>
+    friend shared_ptr<U> make_shared(Args&&... args);
+
+    element_type* p = nullptr;
+    __::shared_ref* rc = nullptr;
+};
+
+template<typename T>
+class weak_ptr
+{
+  public:
+    using element_type = remove_extent_t<T>;
+
+    constexpr weak_ptr() noexcept = default;
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    weak_ptr(const shared_ptr<U>& r) noexcept : p(r.p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_weak();
+    }
+
+    weak_ptr(const weak_ptr& r) noexcept : p(r.p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_weak();
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    weak_ptr(const weak_ptr<U>& r) noexcept : p(r.p), rc(r.rc)
+    {
+        if (rc)
+            rc->keep_weak();
+    }
+
+    weak_ptr(weak_ptr&& r) noexcept : p(r.p), rc(r.rc)
+    {
+        r.p = nullptr;
+        r.rc = nullptr;
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    weak_ptr(weak_ptr<U>&& r) noexcept : p(r.p), rc(r.rc)
+    {
+        r.p = nullptr;
+        r.rc = nullptr;
+    }
+
+    ~weak_ptr()
+    {
+        if (rc)
+            rc->drop_weak();
+    }
+
+    long use_count() const noexcept
+    {
+        return rc ? rc->use_count() : 0;
+    }
+
+    bool expired() const noexcept
+    {
+        return !use_count();
+    }
+
+    void reset() noexcept
+    {
+        weak_ptr().swap(*this);
+    }
+
+    void swap(weak_ptr& r) noexcept
+    {
+        using ctl::swap;
+        swap(p, r.p);
+        swap(rc, r.rc);
+    }
+
+    weak_ptr& operator=(weak_ptr r) noexcept
+    {
+        swap(r);
+        return *this;
+    }
+
+    template<typename U>
+        requires __::shared_ptr_compatible<T, U>
+    weak_ptr& operator=(weak_ptr<U> r) noexcept
+    {
+        weak_ptr<T>(move(r)).swap(*this);
+    }
+
+    shared_ptr<T> lock() const noexcept
+    {
+        if (expired())
+            return nullptr;
+        shared_ptr<T> r;
+        r.p = p;
+        r.rc = rc;
+        if (rc)
+            rc->keep_shared();
+        return r;
+    }
+
+    template<typename U>
+    bool owner_before(const weak_ptr<U>& r) const noexcept
+    {
+        return rc < r.rc;
+    }
+
+    template<typename U>
+    bool owner_before(const shared_ptr<U>& r) const noexcept
+    {
+        return rc < r.rc;
+    }
+
+  private:
+    template<typename U>
+    friend class shared_ptr;
+
+    template<typename U, typename... Args>
+    friend shared_ptr<U> make_shared(Args&&...);
+
+    element_type* p = nullptr;
+    __::shared_ref* rc = nullptr;
+};
+
+template<typename T>
+class enable_shared_from_this
+{
+  public:
+    shared_ptr<T> shared_from_this()
+    {
+        return shared_ptr<T>(weak_this);
+    }
+    shared_ptr<T const> shared_from_this() const
+    {
+        return shared_ptr<T>(weak_this);
+    }
+
+    weak_ptr<T> weak_from_this()
+    {
+        return weak_this;
+    }
+    weak_ptr<T const> weak_from_this() const
+    {
+        return weak_this;
+    }
+
+  protected:
+    constexpr enable_shared_from_this() noexcept = default;
+    enable_shared_from_this(const enable_shared_from_this& r) noexcept
+    {
+    }
+    ~enable_shared_from_this() = default;
+
+    enable_shared_from_this& operator=(
+      const enable_shared_from_this& r) noexcept
+    {
+        return *this;
+    }
+
+  private:
+    template<typename U, typename... Args>
+    friend shared_ptr<U> make_shared(Args&&...);
+
+    template<typename U>
+    friend class shared_ptr;
+
+    weak_ptr<T> weak_this;
+};
+
+template<typename T>
+template<typename U, typename D>
+    requires __::shared_ptr_compatible<T, U>
+shared_ptr<T>::shared_ptr(U* const p, D d)
+  : p(p), rc(__::shared_pointer<U, D>::make(p, move(d)))
+{
+    if constexpr (is_base_of_v<enable_shared_from_this<U>, U>) {
+        p->weak_this = *this;
+    }
+}
+
+// Our make_shared supports passing a weak self reference as the first parameter
+// to your constructor, e.g.:
+//
+//     struct Tree : ctl::weak_self_base
+//     {
+//         ctl::shared_ptr<Tree> l, r;
+//         ctl::weak_ptr<Tree> parent;
+//         Tree(weak_ptr<Tree> const& self, auto&& l2, auto&& r2)
+//           : l(ctl::forward<decltype(l2)>(l2)),
+//             r(ctl::forward<decltype(r2)>(r2))
+//         {
+//             if (l) l->parent = self;
+//             if (r) r->parent = self;
+//         }
+//     };
+//
+//     int main() {
+//         auto t = ctl::make_shared<Tree>(
+//             ctl::make_shared<Tree>(nullptr, nullptr), nullptr);
+//         return t->l->parent.lock().get() == t.get() ? 0 : 1;
+//     }
+//
+// As shown, passing the parameter at object construction time lets you complete
+// object construction without needing a separate Init method. But because we go
+// off spec as far as the STL is concerned, there is a potential ambiguity where
+// you might have a constructor with a weak_ptr first parameter that is intended
+// to be something other than a self-reference. So this feature is opt-in by way
+// of inheriting from the following struct.
+struct weak_self_base
+{};
+
+template<typename T, typename... Args>
+shared_ptr<T>
+make_shared(Args&&... args)
+{
+    unique_ptr rc = __::shared_emplace<T>::make();
+    if constexpr (is_base_of_v<weak_self_base, T> &&
+                  is_constructible_v<T, const weak_ptr<T>&, Args...>) {
+        // A __::shared_ref has a virtual weak reference that is owned by all of
+        // the shared references. We can avoid some unnecessary refcount changes
+        // by "borrowing" that reference and passing it to the constructor, then
+        // promoting it to a shared reference by swapping it with the shared_ptr
+        // that we return.
+        weak_ptr<T> w;
+        w.p = &rc->t;
+        w.rc = rc.get();
+        try {
+            rc->construct(const_cast<const weak_ptr<T>&>(w),
+                          forward<Args>(args)...);
+        } catch (...) {
+            w.p = nullptr;
+            w.rc = nullptr;
+            throw;
+        }
+        rc.release();
+        shared_ptr<T> r;
+        swap(r.p, w.p);
+        swap(r.rc, w.rc);
+        return r;
+    } else {
+        rc->construct(forward<Args>(args)...);
+        shared_ptr<T> r;
+        r.p = &rc->t;
+        r.rc = rc.release();
+        if constexpr (is_base_of_v<enable_shared_from_this<T>, T>) {
+            r->weak_this = r;
+        }
+        return r;
+    }
+}
+
+} // namespace ctl
+
+#endif // CTL_SHARED_PTR_H_
diff --git a/ctl/sort.h b/ctl/sort.h
new file mode 100644
index 000000000..fb5a3d6c2
--- /dev/null
+++ b/ctl/sort.h
@@ -0,0 +1,44 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_SORT_H_
+#define CTL_SORT_H_
+#include "iterator_traits.h"
+#include "less.h"
+#include "partition.h"
+
+namespace ctl {
+
+namespace detail {
+
+template<typename RandomIt, typename Compare>
+void
+quicksort(RandomIt first, RandomIt last, Compare comp)
+{
+    if (first < last) {
+        auto pivot = ctl::partition(first, last, comp);
+        quicksort(first, pivot, comp);
+        quicksort(pivot + 1, last, comp);
+    }
+}
+
+} // namespace detail
+
+template<typename RandomIt, typename Compare>
+void
+sort(RandomIt first, RandomIt last, Compare comp)
+{
+    detail::quicksort(first, last, comp);
+}
+
+template<typename RandomIt>
+void
+sort(RandomIt first, RandomIt last)
+{
+    sort(first,
+         last,
+         ctl::less<typename ctl::iterator_traits<RandomIt>::value_type>());
+}
+
+} // namespace ctl
+
+#endif // CTL_SORT_H_
diff --git a/ctl/strcat.cc b/ctl/strcat.cc
index 0e7c49070..a00cf0e59 100644
--- a/ctl/strcat.cc
+++ b/ctl/strcat.cc
@@ -38,9 +38,9 @@ strcat(const string_view lhs, const string_view rhs) noexcept
     if (rhs.n)
         memcpy(res.data() + lhs.n, rhs.p, rhs.n);
     if (res.isbig()) {
-        res.big()->n = lhs.n + rhs.n;
+        res.__b.n = lhs.n + rhs.n;
     } else {
-        res.small()->rem = __::sso_max - lhs.n - rhs.n;
+        res.__s.rem = __::sso_max - lhs.n - rhs.n;
     }
     res.data()[res.size()] = 0;
     return res;
diff --git a/ctl/string.cc b/ctl/string.cc
index 4e292a188..5e14220de 100644
--- a/ctl/string.cc
+++ b/ctl/string.cc
@@ -21,12 +21,15 @@
 #include <__atomic/fence.h>
 #include <stdckdint.h>
 
+#include "libc/mem/mem.h"
+#include "libc/str/str.h"
+
 namespace ctl {
 
 void
 string::destroy_big() noexcept
 {
-    auto* b = big();
+    auto* b = &__b;
     if (b->n) {
         if (b->n >= b->c)
             __builtin_trap();
@@ -42,24 +45,20 @@ void
 string::init_big(const string& s) noexcept
 {
     char* p2;
-#ifndef NDEBUG
-    if (!s.isbig())
+    size_t size = s.size();
+    size_t need = size + 1;
+    size_t capacity = need;
+    if (!(p2 = (char*)malloc(capacity)))
         __builtin_trap();
-#endif
-    if (s.size() >= s.capacity() >> 1) {
-        if (!(p2 = (char*)malloc(s.capacity())))
-            __builtin_trap();
-        set_big_string(p2, s.size(), s.capacity());
-    } else {
-        init_big(string_view(s));
-    }
+    memcpy(p2, s.data(), need);
+    set_big_string(p2, size, capacity);
 }
 
 void
 string::init_big(const string_view s) noexcept
 {
-    size_t need;
     char* p2;
+    size_t need;
     if (ckd_add(&need, s.n, 1 /* nul */ + 15))
         __builtin_trap();
     need &= -16;
@@ -114,7 +113,7 @@ string::reserve(size_t c2) noexcept
             __builtin_trap();
         memcpy(p2, data(), __::string_size);
     } else {
-        if (!(p2 = (char*)realloc(big()->p, c2)))
+        if (!(p2 = (char*)realloc(__b.p, c2)))
             __builtin_trap();
     }
     std::atomic_signal_fence(std::memory_order_seq_cst);
@@ -131,7 +130,7 @@ string::resize(const size_t n2, const char ch) noexcept
     if (n2 > size())
         memset(data() + size(), ch, n2 - size());
     if (isbig()) {
-        big()->p[big()->n = n2] = 0;
+        __b.p[__b.n = n2] = 0;
     } else {
         set_small_size(n2);
         data()[size()] = 0;
@@ -152,9 +151,9 @@ string::append(const char ch) noexcept
     }
     data()[size()] = ch;
     if (isbig()) {
-        ++big()->n;
+        ++__b.n;
     } else {
-        --small()->rem;
+        --__s.rem;
     }
     data()[size()] = 0;
 }
@@ -185,9 +184,9 @@ string::append(const char ch, const size_t size) noexcept
     if (size)
         memset(data() + this->size(), ch, size);
     if (isbig()) {
-        big()->n += size;
+        __b.n += size;
     } else {
-        small()->rem -= size;
+        __s.rem -= size;
     }
     data()[this->size()] = 0;
 }
@@ -199,9 +198,9 @@ string::append(const void* data, const size_t size) noexcept
     if (size)
         memcpy(this->data() + this->size(), data, size);
     if (isbig()) {
-        big()->n += size;
+        __b.n += size;
     } else {
-        small()->rem -= size;
+        __s.rem -= size;
     }
     this->data()[this->size()] = 0;
 }
@@ -212,9 +211,9 @@ string::pop_back() noexcept
     if (!size())
         __builtin_trap();
     if (isbig()) {
-        --big()->n;
+        --__b.n;
     } else {
-        ++small()->rem;
+        ++__s.rem;
     }
     data()[size()] = 0;
 }
@@ -333,7 +332,7 @@ string::replace(const size_t pos,
         memmove(data() + pos + s.n, data() + last, extra);
     memcpy(data() + pos, s.p, s.n);
     if (isbig()) {
-        big()->p[big()->n = need] = 0;
+        __b.p[__b.n = need] = 0;
     } else {
         set_small_size(need);
         data()[size()] = 0;
@@ -357,9 +356,9 @@ string::insert(const size_t i, const string_view s) noexcept
         memmove(data() + i + s.n, data() + i, extra);
     memcpy(data() + i, s.p, s.n);
     if (isbig()) {
-        big()->n += s.n;
+        __b.n += s.n;
     } else {
-        small()->rem -= s.n;
+        __s.rem -= s.n;
     }
     data()[size()] = 0;
     return *this;
@@ -376,7 +375,7 @@ string::erase(const size_t pos, size_t count) noexcept
     if (extra)
         memmove(data() + pos, data() + pos + count, extra);
     if (isbig()) {
-        big()->n = pos + extra;
+        __b.n = pos + extra;
     } else {
         set_small_size(pos + extra);
     }
@@ -384,4 +383,72 @@ string::erase(const size_t pos, size_t count) noexcept
     return *this;
 }
 
+void
+string::append(const ctl::string_view& s, size_t pos, size_t count) noexcept
+{
+    append(s.substr(pos, count));
+}
+
+size_t
+string::find_last_of(char c, size_t pos) const noexcept
+{
+    const char* b = data();
+    size_t n = size();
+    if (pos > n)
+        pos = n;
+    const char* p = (const char*)memrchr(b, c, pos);
+    return p ? p - b : npos;
+}
+
+size_t
+string::find_last_of(ctl::string_view set, size_t pos) const noexcept
+{
+    if (empty() || set.empty())
+        return npos;
+    bool lut[256] = {};
+    for (char c : set)
+        lut[c & 255] = true;
+    const char* b = data();
+    size_t last = size() - 1;
+    if (pos > last)
+        pos = last;
+    for (;;) {
+        if (lut[b[pos] & 255])
+            return pos;
+        if (!pos)
+            return npos;
+        --pos;
+    }
+}
+
+size_t
+string::find_first_of(char c, size_t pos) const noexcept
+{
+    size_t n = size();
+    if (pos >= n)
+        return npos;
+    const char* b = data();
+    const char* p = (const char*)memchr(b + pos, c, n - pos);
+    return p ? p - b : npos;
+}
+
+size_t
+string::find_first_of(ctl::string_view set, size_t pos) const noexcept
+{
+    if (set.empty())
+        return npos;
+    bool lut[256] = {};
+    for (char c : set)
+        lut[c & 255] = true;
+    const char* b = data();
+    size_t n = size();
+    for (;;) {
+        if (pos >= n)
+            return npos;
+        if (lut[b[pos] & 255])
+            return pos;
+        ++pos;
+    }
+}
+
 } // namespace ctl
diff --git a/ctl/string.h b/ctl/string.h
index 6b6935424..e6e736eec 100644
--- a/ctl/string.h
+++ b/ctl/string.h
@@ -2,13 +2,14 @@
 // vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
 #ifndef CTL_STRING_H_
 #define CTL_STRING_H_
+#include "reverse_iterator.h"
 #include "string_view.h"
 
 namespace ctl {
 
 class string;
 
-string strcat(string_view, string_view) noexcept __wur;
+ctl::string strcat(ctl::string_view, ctl::string_view) noexcept __wur;
 
 namespace __ {
 
@@ -44,8 +45,18 @@ struct big_string
 class string
 {
   public:
-    using iterator = char*;
-    using const_iterator = const char*;
+    using value_type = char;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using pointer = value_type*;
+    using const_pointer = const value_type*;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using iterator = pointer;
+    using const_iterator = const_pointer;
+    using reverse_iterator = ctl::reverse_iterator<iterator>;
+    using const_reverse_iterator = ctl::reverse_iterator<const_iterator>;
+
     static constexpr size_t npos = -1;
 
     string() noexcept
@@ -55,7 +66,7 @@ class string
         *(((size_t*)blob) + 2) = __::sso_max << (sizeof(size_t) - 1) * 8;
     }
 
-    string(const string_view s) noexcept
+    string(const ctl::string_view s) noexcept
     {
         if (s.n <= __::sso_max) {
             __builtin_memcpy(blob, s.p, s.n);
@@ -78,7 +89,7 @@ class string
     }
 
     string(const char* const p) noexcept
-      : string(string_view(p, __builtin_strlen(p)))
+      : string(ctl::string_view(p, __builtin_strlen(p)))
     {
     }
 
@@ -93,7 +104,7 @@ class string
     }
 
     string(const char* const p, const size_t n) noexcept
-      : string(string_view(p, n))
+      : string(ctl::string_view(p, n))
     {
     }
 
@@ -114,17 +125,22 @@ class string
     void append(char, size_t) noexcept;
     void append(unsigned long) noexcept;
     void append(const void*, size_t) noexcept;
-    string& insert(size_t, string_view) noexcept;
+    void append(const ctl::string_view&, size_t, size_t = npos) noexcept;
+    string& insert(size_t, ctl::string_view) noexcept;
     string& erase(size_t = 0, size_t = npos) noexcept;
     string substr(size_t = 0, size_t = npos) const noexcept;
-    string& replace(size_t, size_t, string_view) noexcept;
-    bool operator==(string_view) const noexcept;
-    bool operator!=(string_view) const noexcept;
-    bool contains(string_view) const noexcept;
-    bool ends_with(string_view) const noexcept;
-    bool starts_with(string_view) const noexcept;
+    string& replace(size_t, size_t, ctl::string_view) noexcept;
+    bool operator==(ctl::string_view) const noexcept;
+    bool operator!=(ctl::string_view) const noexcept;
+    bool contains(ctl::string_view) const noexcept;
+    bool ends_with(ctl::string_view) const noexcept;
+    bool starts_with(ctl::string_view) const noexcept;
     size_t find(char, size_t = 0) const noexcept;
-    size_t find(string_view, size_t = 0) const noexcept;
+    size_t find(ctl::string_view, size_t = 0) const noexcept;
+    size_t find_first_of(char, size_t = 0) const noexcept;
+    size_t find_first_of(ctl::string_view, size_t = 0) const noexcept;
+    size_t find_last_of(char, size_t = npos) const noexcept;
+    size_t find_last_of(ctl::string_view, size_t = npos) const noexcept;
 
     void swap(string& s) noexcept
     {
@@ -140,7 +156,7 @@ class string
     void clear() noexcept
     {
         if (isbig()) {
-            big()->n = 0;
+            __b.n = 0;
         } else {
             set_small_size(0);
         }
@@ -148,26 +164,26 @@ class string
 
     bool empty() const noexcept
     {
-        return isbig() ? !big()->n : small()->rem >= __::sso_max;
+        return isbig() ? !__b.n : __s.rem >= __::sso_max;
     }
 
-    char* data() noexcept
+    __attribute__((__always_inline__)) char* data() noexcept
     {
-        return isbig() ? big()->p : small()->buf;
+        return isbig() ? __b.p : __s.buf;
     }
 
-    const char* data() const noexcept
+    __attribute__((__always_inline__)) const char* data() const noexcept
     {
-        return isbig() ? big()->p : small()->buf;
+        return isbig() ? __b.p : __s.buf;
     }
 
-    size_t size() const noexcept
+    __attribute__((__always_inline__)) size_t size() const noexcept
     {
 #if 0
-        if (!isbig() && small()->rem > __::sso_max)
+        if (!isbig() && __s.rem > __::sso_max)
             __builtin_trap();
 #endif
-        return isbig() ? big()->n : __::sso_max - small()->rem;
+        return isbig() ? __b.n : __::sso_max - __s.rem;
     }
 
     size_t length() const noexcept
@@ -178,10 +194,10 @@ class string
     size_t capacity() const noexcept
     {
 #if 0
-        if (isbig() && big()->c <= __::sso_max)
+        if (isbig() && __b.c <= __::sso_max)
             __builtin_trap();
 #endif
-        return isbig() ? __::big_mask & big()->c : __::string_size;
+        return isbig() ? __::big_mask & __b.c : __::string_size;
     }
 
     iterator begin() noexcept
@@ -189,9 +205,9 @@ class string
         return data();
     }
 
-    iterator end() noexcept
+    const_iterator begin() const noexcept
     {
-        return data() + size();
+        return data();
     }
 
     const_iterator cbegin() const noexcept
@@ -199,11 +215,51 @@ class string
         return data();
     }
 
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return const_reverse_iterator(end());
+    }
+
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(end());
+    }
+
+    iterator end() noexcept
+    {
+        return data() + size();
+    }
+
+    const_iterator end() const noexcept
+    {
+        return data() + size();
+    }
+
     const_iterator cend() const noexcept
     {
         return data() + size();
     }
 
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    const_reverse_iterator rend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
     char& front()
     {
         if (!size())
@@ -251,14 +307,14 @@ class string
         append(ch);
     }
 
-    void append(const string_view s) noexcept
+    void append(const ctl::string_view& s) noexcept
     {
         append(s.p, s.n);
     }
 
-    operator string_view() const noexcept
+    operator ctl::string_view() const noexcept
     {
-        return string_view(data(), size());
+        return ctl::string_view(data(), size());
     }
 
     string& operator=(const char* s) noexcept
@@ -268,7 +324,7 @@ class string
         return *this;
     }
 
-    string& operator=(const string_view s) noexcept
+    string& operator=(const ctl::string_view s) noexcept
     {
         clear();
         append(s);
@@ -281,38 +337,66 @@ class string
         return *this;
     }
 
-    string& operator+=(const string_view s) noexcept
+    string& operator+=(const char* s) noexcept
     {
         append(s);
         return *this;
     }
 
-    string operator+(const string_view s) const noexcept
+    string& operator+=(const ctl::string s) noexcept
+    {
+        append(s);
+        return *this;
+    }
+
+    string& operator+=(const ctl::string_view s) noexcept
+    {
+        append(s);
+        return *this;
+    }
+
+    string operator+(const char c) const noexcept
+    {
+        char s[2] = { c };
+        return strcat(*this, s);
+    }
+
+    string operator+(const char* s) const noexcept
     {
         return strcat(*this, s);
     }
 
-    int compare(const string_view s) const noexcept
+    string operator+(const string& s) const noexcept
+    {
+        return strcat(*this, s);
+    }
+
+    string operator+(const ctl::string_view s) const noexcept
+    {
+        return strcat(*this, s);
+    }
+
+    int compare(const ctl::string_view s) const noexcept
     {
         return strcmp(*this, s);
     }
 
-    bool operator<(const string_view s) const noexcept
+    bool operator<(const ctl::string_view s) const noexcept
     {
         return compare(s) < 0;
     }
 
-    bool operator<=(const string_view s) const noexcept
+    bool operator<=(const ctl::string_view s) const noexcept
     {
         return compare(s) <= 0;
     }
 
-    bool operator>(const string_view s) const noexcept
+    bool operator>(const ctl::string_view s) const noexcept
     {
         return compare(s) > 0;
     }
 
-    bool operator>=(const string_view s) const noexcept
+    bool operator>=(const ctl::string_view s) const noexcept
     {
         return compare(s) >= 0;
     }
@@ -320,10 +404,10 @@ class string
   private:
     void destroy_big() noexcept;
     void init_big(const string&) noexcept;
-    void init_big(string_view) noexcept;
+    void init_big(ctl::string_view) noexcept;
     void init_big(size_t, char) noexcept;
 
-    bool isbig() const noexcept
+    __attribute__((__always_inline__)) bool isbig() const noexcept
     {
         return *(blob + __::sso_max) & 0x80;
     }
@@ -344,35 +428,7 @@ class string
         __b.c = c2 | ~__::big_mask;
     }
 
-    __::small_string* small() noexcept
-    {
-        if (isbig())
-            __builtin_trap();
-        return &__s;
-    }
-
-    const __::small_string* small() const noexcept
-    {
-        if (isbig())
-            __builtin_trap();
-        return &__s;
-    }
-
-    __::big_string* big() noexcept
-    {
-        if (!isbig())
-            __builtin_trap();
-        return &__b;
-    }
-
-    const __::big_string* big() const noexcept
-    {
-        if (!isbig())
-            __builtin_trap();
-        return &__b;
-    }
-
-    friend string strcat(string_view, string_view) noexcept;
+    friend string strcat(ctl::string_view, ctl::string_view) noexcept;
 
     union
     {
@@ -386,6 +442,33 @@ static_assert(sizeof(string) == __::string_size);
 static_assert(sizeof(__::small_string) == __::string_size);
 static_assert(sizeof(__::big_string) == __::string_size);
 
+ctl::string
+to_string(int) noexcept;
+
+ctl::string
+to_string(long) noexcept;
+
+ctl::string
+to_string(long long) noexcept;
+
+ctl::string
+to_string(unsigned) noexcept;
+
+ctl::string
+to_string(unsigned long) noexcept;
+
+ctl::string
+to_string(unsigned long long) noexcept;
+
+ctl::string
+to_string(float) noexcept;
+
+ctl::string
+to_string(double) noexcept;
+
+ctl::string
+to_string(long double) noexcept;
+
 } // namespace ctl
 
 #pragma GCC diagnostic push
diff --git a/ctl/string_view.cc b/ctl/string_view.cc
index 951f707a9..3dbadbe21 100644
--- a/ctl/string_view.cc
+++ b/ctl/string_view.cc
@@ -108,4 +108,66 @@ string_view::starts_with(const string_view s) const noexcept
     return !memcmp(p, s.p, s.n);
 }
 
+size_t
+string_view::find_last_of(char c, size_t pos) const noexcept
+{
+    const char* b = data();
+    size_t n = size();
+    if (pos > n)
+        pos = n;
+    const char* p = (const char*)memrchr(b, c, pos);
+    return p ? p - b : npos;
+}
+
+size_t
+string_view::find_last_of(ctl::string_view set, size_t pos) const noexcept
+{
+    if (empty() || set.empty())
+        return npos;
+    bool lut[256] = {};
+    for (char c : set)
+        lut[c & 255] = true;
+    const char* b = data();
+    size_t last = size() - 1;
+    if (pos > last)
+        pos = last;
+    for (;;) {
+        if (lut[b[pos] & 255])
+            return pos;
+        if (!pos)
+            return npos;
+        --pos;
+    }
+}
+
+size_t
+string_view::find_first_of(char c, size_t pos) const noexcept
+{
+    size_t n = size();
+    if (pos >= n)
+        return npos;
+    const char* b = data();
+    const char* p = (const char*)memchr(b + pos, c, n - pos);
+    return p ? p - b : npos;
+}
+
+size_t
+string_view::find_first_of(ctl::string_view set, size_t pos) const noexcept
+{
+    if (set.empty())
+        return npos;
+    bool lut[256] = {};
+    for (char c : set)
+        lut[c & 255] = true;
+    const char* b = data();
+    size_t n = size();
+    for (;;) {
+        if (pos >= n)
+            return npos;
+        if (lut[b[pos] & 255])
+            return pos;
+        ++pos;
+    }
+}
+
 } // namespace ctl
diff --git a/ctl/string_view.h b/ctl/string_view.h
index f4807c62c..9c5949f02 100644
--- a/ctl/string_view.h
+++ b/ctl/string_view.h
@@ -1,7 +1,7 @@
 // -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
 // vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-#ifndef COSMOPOLITAN_CTL_STRINGVIEW_H_
-#define COSMOPOLITAN_CTL_STRINGVIEW_H_
+#ifndef CTL_STRINGVIEW_H_
+#define CTL_STRINGVIEW_H_
 #include "utility.h"
 
 namespace ctl {
@@ -45,6 +45,10 @@ struct string_view
     string_view substr(size_t = 0, size_t = npos) const noexcept;
     size_t find(char, size_t = 0) const noexcept;
     size_t find(string_view, size_t = 0) const noexcept;
+    size_t find_first_of(char, size_t = 0) const noexcept;
+    size_t find_first_of(ctl::string_view, size_t = 0) const noexcept;
+    size_t find_last_of(char, size_t = npos) const noexcept;
+    size_t find_last_of(ctl::string_view, size_t = npos) const noexcept;
 
     constexpr string_view& operator=(const string_view s) noexcept
     {
@@ -109,12 +113,12 @@ struct string_view
         return p[n - 1];
     }
 
-    constexpr const_iterator begin() noexcept
+    constexpr const_iterator begin() const noexcept
     {
         return p;
     }
 
-    constexpr const_iterator end() noexcept
+    constexpr const_iterator end() const noexcept
     {
         return p + n;
     }
@@ -157,4 +161,4 @@ struct string_view
 
 } // namespace ctl
 
-#endif // COSMOPOLITAN_CTL_STRINGVIEW_H_
+#endif // CTL_STRINGVIEW_H_
diff --git a/ctl/to_string.cc b/ctl/to_string.cc
new file mode 100644
index 000000000..a66bb7031
--- /dev/null
+++ b/ctl/to_string.cc
@@ -0,0 +1,109 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "dubble.h"
+#include "libc/fmt/itoa.h"
+#include "libc/math.h"
+#include "string.h"
+#include "third_party/gdtoa/gdtoa.h"
+
+namespace ctl {
+
+extern const double_conversion::DoubleToStringConverter kDoubleToPrintfG;
+
+string
+to_string(int value) noexcept
+{
+    char buf[12];
+    return { buf, FormatInt32(buf, value) - buf };
+}
+
+string
+to_string(unsigned value) noexcept
+{
+    char buf[12];
+    return { buf, FormatUint32(buf, value) - buf };
+}
+
+string
+to_string(long value) noexcept
+{
+    char buf[21];
+    return { buf, FormatInt64(buf, value) - buf };
+}
+
+string
+to_string(unsigned long value) noexcept
+{
+    char buf[21];
+    return { buf, FormatUint64(buf, value) - buf };
+}
+
+string
+to_string(long long value) noexcept
+{
+    char buf[21];
+    return { buf, FormatInt64(buf, value) - buf };
+}
+
+string
+to_string(unsigned long long value) noexcept
+{
+    char buf[21];
+    return { buf, FormatUint64(buf, value) - buf };
+}
+
+string
+to_string(float value) noexcept
+{
+    char buf[128];
+    double_conversion::StringBuilder b(buf, sizeof(buf));
+    kDoubleToPrintfG.ToShortestSingle(value, &b);
+    b.Finalize();
+    return string(buf);
+}
+
+string
+to_string(double value) noexcept
+{
+    char buf[128];
+    double_conversion::StringBuilder b(buf, sizeof(buf));
+    kDoubleToPrintfG.ToShortest(value, &b);
+    b.Finalize();
+    return string(buf);
+}
+
+string
+to_string(long double value) noexcept
+{
+#if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
+    return to_string((double)value);
+#else
+    char buf[128];
+#if LDBL_MANT_DIG == 113
+    g_Qfmt_p(buf, &value, 16, 128, NIK(2, 0, 0));
+#elif LDBL_MANT_DIG == 64
+    g_xfmt_p(buf, &value, 16, 128, NIK(2, 0, 0));
+#else
+#error "unsupported long double"
+#endif
+    return string(buf);
+#endif
+}
+
+} // namespace ctl
diff --git a/ctl/tuple.h b/ctl/tuple.h
new file mode 100644
index 000000000..dcea0f15f
--- /dev/null
+++ b/ctl/tuple.h
@@ -0,0 +1,138 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_TUPLE_H_
+#define CTL_TUPLE_H_
+#include "decay.h"
+#include "enable_if.h"
+#include "is_same.h"
+#include "utility.h"
+
+namespace ctl {
+
+// Forward declaration
+template<typename... Types>
+class tuple;
+
+// Base case for tuple
+template<>
+class tuple<>
+{};
+
+// Recursive case for tuple
+template<typename Head, typename... Tail>
+class tuple<Head, Tail...> : public tuple<Tail...>
+{
+    using Base = tuple<Tail...>;
+
+  public:
+    Head head;
+
+    constexpr tuple() : Base(), head()
+    {
+    }
+
+    template<typename H,
+             typename... T,
+             typename = typename ctl::enable_if<
+               !ctl::is_same<typename ctl::decay<H>::type, tuple>::value>::type>
+    constexpr tuple(H&& h, T&&... t)
+      : Base(ctl::forward<T>(t)...), head(ctl::forward<H>(h))
+    {
+    }
+
+    template<typename... UTypes>
+    constexpr tuple(const tuple<UTypes...>& other)
+      : Base(static_cast<const tuple<UTypes...>&>(other)), head(other.head)
+    {
+    }
+
+    template<typename... UTypes>
+    constexpr tuple(tuple<UTypes...>&& other)
+      : Base(static_cast<tuple<UTypes...>&&>(other))
+      , head(ctl::forward<Head>(other.head))
+    {
+    }
+
+    tuple(const tuple&) = default;
+    tuple(tuple&&) = default;
+    tuple& operator=(const tuple&) = default;
+    tuple& operator=(tuple&&) = default;
+};
+
+// Helper struct for getting element type
+template<size_t I, typename T>
+struct tuple_element;
+
+template<size_t I, typename Head, typename... Tail>
+struct tuple_element<I, tuple<Head, Tail...>>
+  : tuple_element<I - 1, tuple<Tail...>>
+{};
+
+template<typename Head, typename... Tail>
+struct tuple_element<0, tuple<Head, Tail...>>
+{
+    using type = Head;
+};
+
+// Helper function to get element
+template<size_t I, typename Head, typename... Tail>
+constexpr typename tuple_element<I, tuple<Head, Tail...>>::type&
+get(tuple<Head, Tail...>& t)
+{
+    if constexpr (I == 0) {
+        return t.head;
+    } else {
+        return get<I - 1>(static_cast<tuple<Tail...>&>(t));
+    }
+}
+
+template<size_t I, typename Head, typename... Tail>
+constexpr const typename tuple_element<I, tuple<Head, Tail...>>::type&
+get(const tuple<Head, Tail...>& t)
+{
+    if constexpr (I == 0) {
+        return t.head;
+    } else {
+        return get<I - 1>(static_cast<const tuple<Tail...>&>(t));
+    }
+}
+
+// Helper function to create a tuple
+template<typename... Types>
+constexpr tuple<typename ctl::decay<Types>::type...>
+make_tuple(Types&&... args)
+{
+    return tuple<typename ctl::decay<Types>::type...>(
+      ctl::forward<Types>(args)...);
+}
+
+// Helper function for tuple comparison
+template<size_t I = 0, typename... TTypes, typename... UTypes>
+constexpr bool
+tuple_equals(const tuple<TTypes...>& t, const tuple<UTypes...>& u)
+{
+    if constexpr (I == sizeof...(TTypes)) {
+        return true;
+    } else {
+        return get<I>(t) == get<I>(u) && tuple_equals<I + 1>(t, u);
+    }
+}
+
+// Equality comparison
+template<typename... TTypes, typename... UTypes>
+constexpr bool
+operator==(const tuple<TTypes...>& t, const tuple<UTypes...>& u)
+{
+    return tuple_equals(t, u);
+}
+
+template<typename... TTypes, typename... UTypes>
+constexpr bool
+operator!=(const tuple<TTypes...>& t, const tuple<UTypes...>& u)
+{
+    return !(t == u);
+}
+
+} // namespace ctl
+
+#endif // CTL_TUPLE_H_
diff --git a/ctl/uninitialized_fill.h b/ctl/uninitialized_fill.h
new file mode 100644
index 000000000..966d948cc
--- /dev/null
+++ b/ctl/uninitialized_fill.h
@@ -0,0 +1,29 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_UNINITIALIZED_FILL_H_
+#define CTL_UNINITIALIZED_FILL_H_
+#include "addressof.h"
+#include "iterator_traits.h"
+
+namespace ctl {
+
+template<typename ForwardIt, typename T>
+void
+uninitialized_fill(ForwardIt first, ForwardIt last, const T& value)
+{
+    using ValueType = typename ctl::iterator_traits<ForwardIt>::value_type;
+    ForwardIt current = first;
+    try {
+        for (; current != last; ++current)
+            ::new (static_cast<void*>(ctl::addressof(*current)))
+              ValueType(value);
+    } catch (...) {
+        for (; first != current; ++first)
+            first->~ValueType();
+        throw;
+    }
+}
+
+} // namespace ctl
+
+#endif // CTL_UNINITIALIZED_FILL_H_
diff --git a/ctl/uninitialized_fill_n.h b/ctl/uninitialized_fill_n.h
new file mode 100644
index 000000000..c0b6102a8
--- /dev/null
+++ b/ctl/uninitialized_fill_n.h
@@ -0,0 +1,52 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_UNINITIALIZED_FILL_N_H_
+#define CTL_UNINITIALIZED_FILL_N_H_
+#include "addressof.h"
+#include "allocator_traits.h"
+#include "iterator_traits.h"
+
+namespace ctl {
+
+template<typename ForwardIt, typename Size, typename T>
+ForwardIt
+uninitialized_fill_n(ForwardIt first, Size n, const T& value)
+{
+    using ValueType = typename ctl::iterator_traits<ForwardIt>::value_type;
+    ForwardIt current = first;
+    try {
+        for (; n > 0; ++current, --n) {
+            ::new (static_cast<void*>(ctl::addressof(*current)))
+              ValueType(value);
+        }
+        return current;
+    } catch (...) {
+        for (; first != current; ++first) {
+            first->~ValueType();
+        }
+        throw;
+    }
+}
+
+template<typename ForwardIt, typename Size, typename T, typename Alloc>
+ForwardIt
+uninitialized_fill_n(ForwardIt first, Size n, const T& value, Alloc& alloc)
+{
+    using AllocTraits = ctl::allocator_traits<Alloc>;
+    ForwardIt current = first;
+    try {
+        for (; n > 0; ++current, --n) {
+            AllocTraits::construct(alloc, ctl::addressof(*current), value);
+        }
+        return current;
+    } catch (...) {
+        for (; first != current; ++first) {
+            AllocTraits::destroy(alloc, ctl::addressof(*first));
+        }
+        throw;
+    }
+}
+
+} // namespace ctl
+
+#endif // CTL_UNINITIALIZED_FILL_N_H_
diff --git a/ctl/uninitialized_move_n.h b/ctl/uninitialized_move_n.h
new file mode 100644
index 000000000..108cc0e11
--- /dev/null
+++ b/ctl/uninitialized_move_n.h
@@ -0,0 +1,52 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_UNINITIALIZED_MOVE_N_H_
+#define CTL_UNINITIALIZED_MOVE_N_H_
+#include "addressof.h"
+#include "allocator_traits.h"
+#include "iterator_traits.h"
+#include "utility.h"
+
+namespace ctl {
+
+template<typename InputIt, typename Size, typename ForwardIt>
+ForwardIt
+uninitialized_move_n(InputIt first, Size n, ForwardIt d_first)
+{
+    using T = typename ctl::iterator_traits<ForwardIt>::value_type;
+    ForwardIt current = d_first;
+    try {
+        for (; n > 0; ++first, (void)++current, --n) {
+            ::new (static_cast<void*>(ctl::addressof(*current)))
+              T(ctl::move(*first));
+        }
+    } catch (...) {
+        for (; d_first != current; ++d_first) {
+            d_first->~T();
+        }
+        throw;
+    }
+    return current;
+}
+
+template<typename InputIt, typename Size, typename ForwardIt, typename Alloc>
+ForwardIt
+uninitialized_move_n(InputIt first, Size n, ForwardIt d_first, Alloc& alloc)
+{
+    using AllocTraits = ctl::allocator_traits<Alloc>;
+    ForwardIt current = d_first;
+    try {
+        for (; n > 0; ++first, (void)++current, --n)
+            AllocTraits::construct(
+              alloc, ctl::addressof(*current), ctl::move(*first));
+    } catch (...) {
+        for (; d_first != current; ++d_first)
+            AllocTraits::destroy(alloc, ctl::addressof(*d_first));
+        throw;
+    }
+    return current;
+}
+
+} // namespace ctl
+
+#endif // CTL_UNINITIALIZED_MOVE_N_H_
diff --git a/ctl/unique_lock.h b/ctl/unique_lock.h
new file mode 100644
index 000000000..6568a408e
--- /dev/null
+++ b/ctl/unique_lock.h
@@ -0,0 +1,147 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_UNIQUE_LOCK_H_
+#define CTL_UNIQUE_LOCK_H_
+#include "mutex.h"
+#include "utility.h"
+
+namespace ctl {
+
+struct defer_lock_t
+{
+    explicit defer_lock_t() = default;
+};
+
+struct try_to_lock_t
+{
+    explicit try_to_lock_t() = default;
+};
+
+struct adopt_lock_t
+{
+    explicit adopt_lock_t() = default;
+};
+
+inline constexpr defer_lock_t defer_lock{};
+inline constexpr try_to_lock_t try_to_lock{};
+inline constexpr adopt_lock_t adopt_lock{};
+
+class unique_lock
+{
+  public:
+    unique_lock() noexcept : mutex_(nullptr), owns_lock_(false)
+    {
+    }
+
+    explicit unique_lock(ctl::mutex& m) : mutex_(&m), owns_lock_(false)
+    {
+        lock();
+    }
+
+    unique_lock(ctl::mutex& m, defer_lock_t) noexcept
+      : mutex_(&m), owns_lock_(false)
+    {
+    }
+
+    unique_lock(ctl::mutex& m, try_to_lock_t)
+      : mutex_(&m), owns_lock_(mutex_->try_lock())
+    {
+    }
+
+    unique_lock(ctl::mutex& m, adopt_lock_t) : mutex_(&m), owns_lock_(true)
+    {
+    }
+
+    ~unique_lock()
+    {
+        if (owns_lock_)
+            mutex_->unlock();
+    }
+
+    unique_lock(const unique_lock&) = delete;
+    unique_lock& operator=(const unique_lock&) = delete;
+
+    unique_lock(unique_lock&& other) noexcept
+      : mutex_(other.mutex_), owns_lock_(other.owns_lock_)
+    {
+        other.mutex_ = nullptr;
+        other.owns_lock_ = false;
+    }
+
+    unique_lock& operator=(unique_lock&& other) noexcept
+    {
+        if (owns_lock_)
+            mutex_->unlock();
+        mutex_ = other.mutex_;
+        owns_lock_ = other.owns_lock_;
+        other.mutex_ = nullptr;
+        other.owns_lock_ = false;
+        return *this;
+    }
+
+    void lock()
+    {
+        if (!mutex_)
+            __builtin_trap();
+        if (owns_lock_)
+            __builtin_trap();
+        mutex_->lock();
+        owns_lock_ = true;
+    }
+
+    bool try_lock()
+    {
+        if (!mutex_)
+            __builtin_trap();
+        if (owns_lock_)
+            __builtin_trap();
+        owns_lock_ = mutex_->try_lock();
+        return owns_lock_;
+    }
+
+    void unlock()
+    {
+        if (!owns_lock_)
+            __builtin_trap();
+        mutex_->unlock();
+        owns_lock_ = false;
+    }
+
+    void swap(unique_lock& other) noexcept
+    {
+        using ctl::swap;
+        swap(mutex_, other.mutex_);
+        swap(owns_lock_, other.owns_lock_);
+    }
+
+    ctl::mutex* release() noexcept
+    {
+        ctl::mutex* result = mutex_;
+        mutex_ = nullptr;
+        owns_lock_ = false;
+        return result;
+    }
+
+    bool owns_lock() const noexcept
+    {
+        return owns_lock_;
+    }
+
+    explicit operator bool() const noexcept
+    {
+        return owns_lock_;
+    }
+
+    ctl::mutex* mutex() const noexcept
+    {
+        return mutex_;
+    }
+
+  private:
+    ctl::mutex* mutex_;
+    bool owns_lock_;
+};
+
+} // namespace ctl
+
+#endif // CTL_UNIQUE_LOCK_H_
diff --git a/ctl/unique_ptr.cc b/ctl/unique_ptr.cc
deleted file mode 100644
index daeda3b1b..000000000
--- a/ctl/unique_ptr.cc
+++ /dev/null
@@ -1,19 +0,0 @@
-// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
-// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-//
-// Copyright 2024 Justine Alexandra Roberts Tunney
-//
-// Permission to use, copy, modify, and/or distribute this software for
-// any purpose with or without fee is hereby granted, provided that the
-// above copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
-// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
-// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
-// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
-// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-// PERFORMANCE OF THIS SOFTWARE.
-
-#include "unique_ptr.h"
diff --git a/ctl/unique_ptr.h b/ctl/unique_ptr.h
index c2ebae7ba..5027d5ec1 100644
--- a/ctl/unique_ptr.h
+++ b/ctl/unique_ptr.h
@@ -1,41 +1,17 @@
 // -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
 // vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-#ifndef COSMOPOLITAN_CTL_UNIQUE_PTR_H_
-#define COSMOPOLITAN_CTL_UNIQUE_PTR_H_
+#ifndef CTL_UNIQUE_PTR_H_
+#define CTL_UNIQUE_PTR_H_
+#include "add_lvalue_reference.h"
+#include "default_delete.h"
+#include "is_convertible.h"
+#include "is_reference.h"
+#include "is_same.h"
 #include "utility.h"
-#include <__type_traits/is_convertible.h>
 
 namespace ctl {
 
-template<typename T>
-struct default_delete
-{
-    constexpr default_delete() noexcept = default;
-    template<typename U>
-    constexpr default_delete(default_delete<U>&&) noexcept
-    {
-    }
-    constexpr void operator()(T* const p) const noexcept
-    {
-        delete p;
-    }
-};
-
-template<typename T>
-struct default_delete<T[]>
-{
-    constexpr default_delete() noexcept = default;
-    template<typename U>
-    constexpr default_delete(default_delete<U>&&) noexcept
-    {
-    }
-    constexpr void operator()(T* const p) const noexcept
-    {
-        delete[] p;
-    }
-};
-
-template<typename T, typename D = default_delete<T>>
+template<typename T, typename D = ctl::default_delete<T>>
 struct unique_ptr
 {
     using pointer = T*;
@@ -49,26 +25,34 @@ struct unique_ptr
     {
     }
 
-    constexpr unique_ptr(const pointer p) noexcept : p(p), d()
+    constexpr explicit unique_ptr(pointer p) noexcept : p(p), d()
     {
     }
 
-    constexpr unique_ptr(const pointer p, auto&& d) noexcept
-      : p(p), d(ctl::forward<decltype(d)>(d))
+    constexpr unique_ptr(pointer p, const D& d) noexcept : p(p), d(d)
+    {
+    }
+
+    constexpr unique_ptr(pointer p, D&& d) noexcept : p(p), d(ctl::move(d))
     {
     }
 
     template<typename U, typename E>
-        requires std::is_convertible_v<U, T> && std::is_convertible_v<E, D>
     constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept
-      : p(u.p), d(ctl::move(u.d))
+      : p(u.release()), d(ctl::forward<E>(u.get_deleter()))
     {
-        u.p = nullptr;
+        static_assert(ctl::is_convertible<typename unique_ptr<U, E>::pointer,
+                                          pointer>::value,
+                      "U* must be implicitly convertible to T*");
+        static_assert(
+          (ctl::is_reference<D>::value && ctl::is_same<D, E>::value) ||
+            (!ctl::is_reference<D>::value && ctl::is_convertible<E, D>::value),
+          "The deleter must be convertible to the target deleter type");
     }
 
     unique_ptr(const unique_ptr&) = delete;
 
-    constexpr ~unique_ptr() /* noexcept */
+    constexpr ~unique_ptr() noexcept
     {
         if (p)
             d(p);
@@ -80,6 +64,20 @@ struct unique_ptr
         return *this;
     }
 
+    template<typename U, typename E>
+    constexpr unique_ptr& operator=(unique_ptr<U, E>&& r) noexcept
+    {
+        reset(r.release());
+        d = ctl::forward<E>(r.get_deleter());
+        return *this;
+    }
+
+    constexpr unique_ptr& operator=(nullptr_t) noexcept
+    {
+        reset();
+        return *this;
+    }
+
     constexpr pointer release() noexcept
     {
         pointer r = p;
@@ -87,12 +85,12 @@ struct unique_ptr
         return r;
     }
 
-    constexpr void reset(const pointer p2 = pointer()) noexcept
+    constexpr void reset(pointer p2 = pointer()) noexcept
     {
-        const pointer r = p;
+        pointer old = p;
         p = p2;
-        if (r)
-            d(r);
+        if (old)
+            d(old);
     }
 
     constexpr void swap(unique_ptr& r) noexcept
@@ -119,20 +117,16 @@ struct unique_ptr
 
     constexpr explicit operator bool() const noexcept
     {
-        return p;
+        return p != nullptr;
     }
 
-    element_type& operator*() const noexcept(noexcept(*ctl::declval<pointer>()))
+    constexpr typename ctl::add_lvalue_reference<T>::type operator*() const
     {
-        if (!p)
-            __builtin_trap();
         return *p;
     }
 
-    pointer operator->() const noexcept
+    constexpr pointer operator->() const noexcept
     {
-        if (!p)
-            __builtin_trap();
         return p;
     }
 };
@@ -148,16 +142,9 @@ template<typename T>
 constexpr unique_ptr<T>
 make_unique_for_overwrite()
 {
-#if 0
-    // You'd think that it'd work like this, but std::unique_ptr does not.
-    return unique_ptr<T>(
-      static_cast<T*>(::operator new(sizeof(T), align_val_t(alignof(T)))));
-#else
     return unique_ptr<T>(new T);
-#endif
 }
 
-// TODO(mrdomino): specializations for T[]
-
 } // namespace ctl
-#endif // COSMOPOLITAN_CTL_UNIQUE_PTR_H_
+
+#endif // CTL_UNIQUE_PTR_H_
diff --git a/ctl/utility.cc b/ctl/utility.cc
deleted file mode 100644
index a4c2a2008..000000000
--- a/ctl/utility.cc
+++ /dev/null
@@ -1,19 +0,0 @@
-// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
-// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-//
-// Copyright 2024 Justine Alexandra Roberts Tunney
-//
-// Permission to use, copy, modify, and/or distribute this software for
-// any purpose with or without fee is hereby granted, provided that the
-// above copyright notice and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
-// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
-// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
-// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
-// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-// PERFORMANCE OF THIS SOFTWARE.
-
-#include "utility.h"
diff --git a/ctl/utility.h b/ctl/utility.h
index 62036ca04..547580f81 100644
--- a/ctl/utility.h
+++ b/ctl/utility.h
@@ -1,7 +1,8 @@
 // -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
 // vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-#ifndef COSMOPOLITAN_CTL_UTILITY_H_
-#define COSMOPOLITAN_CTL_UTILITY_H_
+#ifndef CTL_UTILITY_H_
+#define CTL_UTILITY_H_
+#include "remove_reference.h"
 
 namespace ctl {
 
@@ -18,6 +19,14 @@ using no_infer = typename no_infer_<T>::type;
 
 } // namespace __
 
+template<typename T>
+constexpr T&&
+move(T&& t) noexcept
+{
+    typedef remove_reference_t<T> U;
+    return static_cast<U&&>(t);
+}
+
 template<typename T>
 constexpr T&&
 move(T& t) noexcept
@@ -47,9 +56,8 @@ template<typename T, size_t N>
 constexpr void
 swap(T (&a)[N], T (&b)[N]) noexcept
 {
-    for (size_t i = 0; i < N; ++i) {
+    for (size_t i = 0; i < N; ++i)
         swap(a[i], b[i]);
-    }
 }
 
 template<typename T>
@@ -58,4 +66,4 @@ declval() noexcept;
 
 } // namespace ctl
 
-#endif // COSMOPOLITAN_CTL_UTILITY_H_
+#endif // CTL_UTILITY_H_
diff --git a/ctl/vector.h b/ctl/vector.h
index e86e0d503..8fa55bafa 100644
--- a/ctl/vector.h
+++ b/ctl/vector.h
@@ -1,245 +1,600 @@
 // -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
 // vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
-#ifndef COSMOPOLITAN_CTL_OPTIONAL_H_
-#define COSMOPOLITAN_CTL_OPTIONAL_H_
-#include "new.h"
-#include "utility.h"
+#ifndef CTL_VECTOR_H_
+#define CTL_VECTOR_H_
+#include "allocator.h"
+#include "allocator_traits.h"
+#include "copy.h"
+#include "distance.h"
+#include "equal.h"
+#include "fill_n.h"
+#include "initializer_list.h"
+#include "iterator_traits.h"
+#include "lexicographical_compare.h"
+#include "max.h"
+#include "move_backward.h"
+#include "move_iterator.h"
+#include "out_of_range.h"
+#include "require_input_iterator.h"
+#include "reverse_iterator.h"
+#include "uninitialized_fill.h"
+#include "uninitialized_fill_n.h"
+#include "uninitialized_move_n.h"
 
 namespace ctl {
 
-template<typename T>
-struct vector
+template<typename T, typename Allocator = ctl::allocator<T>>
+class vector
 {
-    size_t n = 0;
-    size_t c = 0;
-    T* p = nullptr;
+  public:
+    using value_type = T;
+    using allocator_type = Allocator;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using pointer = typename ctl::allocator_traits<Allocator>::pointer;
+    using const_pointer =
+      typename ctl::allocator_traits<Allocator>::const_pointer;
+    using iterator = pointer;
+    using const_iterator = const_pointer;
+    using reverse_iterator = ctl::reverse_iterator<iterator>;
+    using const_reverse_iterator = ctl::reverse_iterator<const_iterator>;
 
-    using iterator = T*;
-    using const_iterator = const T*;
-
-    vector() = default;
-
-    ~vector()
+  public:
+    vector() noexcept(noexcept(Allocator()))
+      : alloc_(), data_(nullptr), size_(0), capacity_(0)
     {
-        delete[] p;
+    }
+
+    explicit vector(const Allocator& alloc) noexcept
+      : alloc_(alloc), data_(nullptr), size_(0), capacity_(0)
+    {
+    }
+
+    vector(size_type count,
+           const T& value,
+           const Allocator& alloc = Allocator())
+      : alloc_(alloc), data_(nullptr), size_(0), capacity_(0)
+    {
+        assign(count, value);
+    }
+
+    explicit vector(size_type count, const Allocator& alloc = Allocator())
+      : alloc_(alloc), data_(nullptr), size_(0), capacity_(0)
+    {
+        resize(count);
+    }
+
+    template<class InputIt, typename = ctl::require_input_iterator<InputIt>>
+    vector(InputIt first, InputIt last, const Allocator& alloc = Allocator())
+      : alloc_(alloc), data_(nullptr), size_(0), capacity_(0)
+    {
+        assign(first, last);
     }
 
     vector(const vector& other)
+      : alloc_(ctl::allocator_traits<
+               Allocator>::select_on_container_copy_construction(other.alloc_))
+      , data_(nullptr)
+      , size_(0)
+      , capacity_(0)
     {
-        n = other.n;
-        c = other.c;
-        p = new T[c];
-        for (size_t i = 0; i < n; ++i)
-            new (&p[i]) T(other.p[i]);
+        assign(other.begin(), other.end());
+    }
+
+    vector(const vector& other, const Allocator& alloc)
+      : alloc_(alloc), data_(nullptr), size_(0), capacity_(0)
+    {
+        assign(other.begin(), other.end());
     }
 
     vector(vector&& other) noexcept
+      : alloc_(ctl::move(other.alloc_))
+      , data_(other.data_)
+      , size_(other.size_)
+      , capacity_(other.capacity_)
     {
-        n = other.n;
-        c = other.c;
-        p = other.p;
-        other.n = 0;
-        other.c = 0;
-        other.p = nullptr;
+        other.data_ = nullptr;
+        other.size_ = 0;
+        other.capacity_ = 0;
     }
 
-    explicit vector(size_t count, const T& value = T())
+    vector(vector&& other, const Allocator& alloc)
+      : alloc_(alloc), data_(nullptr), size_(0), capacity_(0)
     {
-        n = count;
-        c = count;
-        p = new T[c];
-        for (size_t i = 0; i < n; ++i)
-            new (&p[i]) T(value);
+        if (alloc_ == other.alloc_) {
+            data_ = other.data_;
+            size_ = other.size_;
+            capacity_ = other.capacity_;
+            other.data_ = nullptr;
+            other.size_ = 0;
+            other.capacity_ = 0;
+        } else {
+            assign(ctl::make_move_iterator(other.begin()),
+                   ctl::make_move_iterator(other.end()));
+        }
+    }
+
+    vector(std::initializer_list<T> init, const Allocator& alloc = Allocator())
+      : alloc_(alloc), data_(nullptr), size_(0), capacity_(0)
+    {
+        assign(init.begin(), init.end());
+    }
+
+    ~vector()
+    {
+        clear();
+        ctl::allocator_traits<Allocator>::deallocate(alloc_, data_, capacity_);
     }
 
     vector& operator=(const vector& other)
     {
         if (this != &other) {
-            T* newData = new T[other.c];
-            for (size_t i = 0; i < other.n; ++i) {
-                newData[i] = other.p[i];
-            }
-            delete[] p;
-            p = newData;
-            n = other.n;
-            c = other.c;
+            if (ctl::allocator_traits<
+                  Allocator>::propagate_on_container_copy_assignment::value)
+                alloc_ = other.alloc_;
+            assign(other.begin(), other.end());
         }
         return *this;
     }
 
-    vector& operator=(vector&& other) noexcept
+    vector& operator=(vector&& other) noexcept(
+      ctl::allocator_traits<Allocator>::is_always_equal::value)
     {
         if (this != &other) {
-            delete[] p;
-            p = other.p;
-            n = other.n;
-            c = other.c;
-            other.p = nullptr;
-            other.n = 0;
-            other.c = 0;
+            clear();
+            ctl::allocator_traits<Allocator>::deallocate(
+              alloc_, data_, capacity_);
+            if (ctl::allocator_traits<
+                  Allocator>::propagate_on_container_move_assignment::value)
+                alloc_ = ctl::move(other.alloc_);
+            data_ = other.data_;
+            size_ = other.size_;
+            capacity_ = other.capacity_;
+            other.data_ = nullptr;
+            other.size_ = 0;
+            other.capacity_ = 0;
         }
         return *this;
     }
 
-    bool empty() const
+    vector& operator=(std::initializer_list<T> ilist)
     {
-        return !n;
+        assign(ilist.begin(), ilist.end());
+        return *this;
     }
 
-    size_t size() const
+    void assign(size_type count, const T& value)
     {
-        return n;
+        clear();
+        if (count > capacity_)
+            reallocate(count);
+        ctl::uninitialized_fill_n(data_, count, value);
+        size_ = count;
     }
 
-    size_t capacity() const
+    template<class InputIt, typename = ctl::require_input_iterator<InputIt>>
+    void assign(InputIt first, InputIt last)
     {
-        return c;
+        clear();
+        for (; first != last; ++first)
+            push_back(*first);
     }
 
-    T& operator[](size_t i)
+    void assign(std::initializer_list<T> ilist)
     {
-        if (i >= n)
+        assign(ilist.begin(), ilist.end());
+    }
+
+    reference at(size_type pos)
+    {
+        if (pos >= size_)
+            throw ctl::out_of_range();
+        return data_[pos];
+    }
+
+    const_reference at(size_type pos) const
+    {
+        if (pos >= size_)
+            throw ctl::out_of_range();
+        return data_[pos];
+    }
+
+    reference operator[](size_type pos)
+    {
+        if (pos >= size_)
             __builtin_trap();
-        return p[i];
+        return data_[pos];
     }
 
-    const T& operator[](size_t i) const
+    const_reference operator[](size_type pos) const
     {
-        if (i >= n)
+        if (pos >= size_)
             __builtin_trap();
-        return p[i];
+        return data_[pos];
     }
 
-    iterator begin()
+    reference front()
     {
-        return p;
+        return data_[0];
     }
 
-    iterator end()
+    const_reference front() const
     {
-        return p + n;
+        return data_[0];
     }
 
-    const_iterator cbegin() const
+    reference back()
     {
-        return p;
+        return data_[size_ - 1];
     }
 
-    const_iterator cend() const
+    const_reference back() const
     {
-        return p + n;
+        return data_[size_ - 1];
     }
 
-    T& front()
+    T* data() noexcept
     {
-        if (!n)
-            __builtin_trap();
-        return p[0];
+        return data_;
     }
 
-    const T& front() const
+    const T* data() const noexcept
     {
-        if (!n)
-            __builtin_trap();
-        return p[0];
+        return data_;
     }
 
-    T& back()
+    iterator begin() noexcept
     {
-        if (!n)
-            __builtin_trap();
-        return p[n - 1];
+        return data_;
     }
 
-    const T& back() const
+    const_iterator begin() const noexcept
     {
-        if (!n)
-            __builtin_trap();
-        return p[n - 1];
+        return data_;
     }
 
-    void clear()
+    const_iterator cbegin() const noexcept
     {
-        for (size_t i = 0; i < n; ++i)
-            p[i].~T();
-        n = 0;
+        return data_;
     }
 
-    void reserve(size_t c2)
+    iterator end() noexcept
     {
-        if (c2 <= c)
-            return;
-        T* newP = new T[c2];
-        for (size_t i = 0; i < n; ++i)
-            newP[i] = ctl::move(p[i]);
-        delete[] p;
-        p = newP;
-        c = c2;
+        return data_ + size_;
     }
 
-    void push_back(const T& e)
+    const_iterator end() const noexcept
     {
-        if (n == c) {
-            size_t c2 = c + 1;
-            c2 += c2 >> 1;
-            reserve(c2);
-        }
-        new (&p[n]) T(e);
-        ++n;
+        return data_ + size_;
     }
 
-    void push_back(T&& e)
+    const_iterator cend() const noexcept
     {
-        if (n == c) {
-            size_t c2 = c + 1;
-            c2 += c2 >> 1;
-            reserve(c2);
-        }
-        new (&p[n]) T(ctl::forward<T>(e));
-        ++n;
+        return data_ + size_;
     }
 
-    template<typename... Args>
-    void emplace_back(Args&&... args)
+    reverse_iterator rbegin() noexcept
     {
-        if (n == c) {
-            size_t c2 = c + 1;
-            c2 += c2 >> 1;
-            reserve(c2);
-        }
-        new (&p[n]) T(ctl::forward<Args>(args)...);
-        ++n;
+        return reverse_iterator(end());
+    }
+
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return const_reverse_iterator(end());
+    }
+
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(end());
+    }
+
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    const_reverse_iterator rend() const noexcept
+    {
+        return const_reverse_iterator(begin());
+    }
+
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(begin());
+    }
+
+    bool empty() const noexcept
+    {
+        return size_ == 0;
+    }
+
+    size_type size() const noexcept
+    {
+        return size_;
+    }
+
+    size_type max_size() const noexcept
+    {
+        return __PTRDIFF_MAX__;
+    }
+
+    size_type capacity() const noexcept
+    {
+        return capacity_;
+    }
+
+    void reserve(size_type new_cap)
+    {
+        if (new_cap > capacity_)
+            reallocate(new_cap);
+    }
+
+    void shrink_to_fit()
+    {
+        if (size_ < capacity_)
+            reallocate(size_);
+    }
+
+    void clear() noexcept
+    {
+        for (size_type i = 0; i < size_; ++i)
+            ctl::allocator_traits<Allocator>::destroy(alloc_, data_ + i);
+        size_ = 0;
+    }
+
+    iterator insert(const_iterator pos, const T& value)
+    {
+        return insert(pos, 1, value);
+    }
+
+    iterator insert(const_iterator pos, T&& value)
+    {
+        difference_type index = pos - begin();
+        if (size_ == capacity_)
+            grow();
+        iterator it = begin() + index;
+        ctl::move_backward(it, end(), end() + 1);
+        *it = ctl::move(value);
+        ++size_;
+        return it;
+    }
+
+    iterator insert(const_iterator pos, size_type count, const T& value)
+    {
+        difference_type index = pos - begin();
+        if (size_ + count > capacity_)
+            reallocate(ctl::max(size_ + count, capacity_ * 2));
+        iterator it = begin() + index;
+        ctl::move_backward(it, end(), end() + count);
+        ctl::fill_n(it, count, value);
+        size_ += count;
+        return it;
+    }
+
+    template<class InputIt, typename = ctl::require_input_iterator<InputIt>>
+    iterator insert(const_iterator pos, InputIt first, InputIt last)
+    {
+        difference_type count = ctl::distance(first, last);
+        difference_type index = pos - begin();
+        if (size_ + count > capacity_)
+            reallocate(ctl::max(size_ + count, capacity_ * 2));
+        iterator it = begin() + index;
+        ctl::move_backward(it, end(), end() + count);
+        ctl::copy(first, last, it);
+        size_ += count;
+        return it;
+    }
+
+    iterator insert(const_iterator pos, std::initializer_list<T> ilist)
+    {
+        return insert(pos, ilist.begin(), ilist.end());
+    }
+
+    template<class... Args>
+    iterator emplace(const_iterator pos, Args&&... args)
+    {
+        difference_type index = pos - begin();
+        if (size_ == capacity_)
+            grow();
+        iterator it = begin() + index;
+        ctl::move_backward(it, end(), end() + 1);
+        ctl::allocator_traits<Allocator>::construct(
+          alloc_, it, ctl::forward<Args>(args)...);
+        ++size_;
+        return it;
+    }
+
+    iterator erase(const_iterator pos)
+    {
+        return erase(pos, pos + 1);
+    }
+
+    constexpr iterator erase(const_iterator first, const_iterator last)
+    {
+        difference_type index = first - begin();
+        difference_type count = last - first;
+        iterator it = begin() + index;
+        for (iterator move_it = it + count; move_it != end(); ++move_it, ++it)
+            *it = ctl::move(*move_it);
+        for (difference_type i = 0; i < count; ++i)
+            ctl::allocator_traits<Allocator>::destroy(alloc_, end() - i - 1);
+        size_ -= count;
+        return begin() + index;
+    }
+
+    void push_back(const T& value)
+    {
+        if (size_ == capacity_)
+            grow();
+        ctl::allocator_traits<Allocator>::construct(
+          alloc_, data_ + size_, value);
+        ++size_;
+    }
+
+    void push_back(T&& value)
+    {
+        if (size_ == capacity_)
+            grow();
+        ctl::allocator_traits<Allocator>::construct(
+          alloc_, data_ + size_, ctl::move(value));
+        ++size_;
+    }
+
+    template<class... Args>
+    reference emplace_back(Args&&... args)
+    {
+        if (size_ == capacity_)
+            grow();
+        ctl::allocator_traits<Allocator>::construct(
+          alloc_, data_ + size_, ctl::forward<Args>(args)...);
+        return data_[size_++];
     }
 
     void pop_back()
     {
-        if (n > 0) {
-            --n;
-            p[n].~T();
+        if (!empty()) {
+            ctl::allocator_traits<Allocator>::destroy(alloc_,
+                                                      data_ + size_ - 1);
+            --size_;
         }
     }
 
-    void resize(size_t n2)
+    void resize(size_type count)
     {
-        if (n2 > n) {
-            reserve(n2);
-            for (size_t i = n; i < n2; ++i)
-                new (&p[i]) T();
-        } else if (n2 < n) {
-            for (size_t i = n2; i < n; ++i)
-                p[i].~T();
-        }
-        n = n2;
+        resize(count, T());
     }
 
-    void swap(vector& other) noexcept
+    void resize(size_type count, const value_type& value)
     {
-        ctl::swap(n, other.n);
-        ctl::swap(c, other.c);
-        ctl::swap(p, other.p);
+        if (count > size_) {
+            if (count > capacity_)
+                reallocate(count);
+            ctl::uninitialized_fill(data_ + size_, data_ + count, value);
+        } else if (count < size_) {
+            for (size_type i = count; i < size_; ++i)
+                ctl::allocator_traits<Allocator>::destroy(alloc_, data_ + i);
+        }
+        size_ = count;
     }
+
+    void swap(vector& other) noexcept(
+      ctl::allocator_traits<Allocator>::is_always_equal::value)
+    {
+        using ctl::swap;
+        swap(alloc_, other.alloc_);
+        swap(data_, other.data_);
+        swap(size_, other.size_);
+        swap(capacity_, other.capacity_);
+    }
+
+    allocator_type get_allocator() const noexcept
+    {
+        return alloc_;
+    }
+
+  private:
+    void grow()
+    {
+        size_type c2;
+        c2 = capacity_;
+        if (c2 < 4)
+            c2 = 4;
+        c2 += c2 >> 1;
+        reallocate(c2);
+    }
+
+    void reallocate(size_type new_capacity)
+    {
+        pointer new_data =
+          ctl::allocator_traits<Allocator>::allocate(alloc_, new_capacity);
+        size_type new_size = size_ < new_capacity ? size_ : new_capacity;
+        try {
+            ctl::uninitialized_move_n(data_, new_size, new_data);
+        } catch (...) {
+            ctl::allocator_traits<Allocator>::deallocate(
+              alloc_, new_data, new_capacity);
+            throw;
+        }
+        for (size_type i = 0; i < size_; ++i)
+            ctl::allocator_traits<Allocator>::destroy(alloc_, data_ + i);
+        ctl::allocator_traits<Allocator>::deallocate(alloc_, data_, capacity_);
+        data_ = new_data;
+        size_ = new_size;
+        capacity_ = new_capacity;
+    }
+
+    [[no_unique_address]] Allocator alloc_;
+    pointer data_;
+    size_type size_;
+    size_type capacity_;
 };
 
+template<class T, class Alloc>
+bool
+operator==(const vector<T, Alloc>& lhs, const vector<T, Alloc>& rhs)
+{
+    return lhs.size() == rhs.size() &&
+           ctl::equal(lhs.begin(), lhs.end(), rhs.begin());
+}
+
+template<class T, class Alloc>
+bool
+operator!=(const vector<T, Alloc>& lhs, const vector<T, Alloc>& rhs)
+{
+    return !(lhs == rhs);
+}
+
+template<class T, class Alloc>
+bool
+operator<(const vector<T, Alloc>& lhs, const vector<T, Alloc>& rhs)
+{
+    return ctl::lexicographical_compare(
+      lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+
+template<class T, class Alloc>
+bool
+operator<=(const vector<T, Alloc>& lhs, const vector<T, Alloc>& rhs)
+{
+    return !(rhs < lhs);
+}
+
+template<class T, class Alloc>
+bool
+operator>(const vector<T, Alloc>& lhs, const vector<T, Alloc>& rhs)
+{
+    return rhs < lhs;
+}
+
+template<class T, class Alloc>
+bool
+operator>=(const vector<T, Alloc>& lhs, const vector<T, Alloc>& rhs)
+{
+    return !(lhs < rhs);
+}
+
+template<class T, class Alloc>
+void
+swap(vector<T, Alloc>& lhs,
+     vector<T, Alloc>& rhs) noexcept(noexcept(lhs.swap(rhs)))
+{
+    lhs.swap(rhs);
+}
+
+template<class InputIt,
+         class Alloc =
+           ctl::allocator<typename ctl::iterator_traits<InputIt>::value_type>>
+vector(InputIt, InputIt, Alloc = Alloc())
+  -> vector<typename ctl::iterator_traits<InputIt>::value_type, Alloc>;
+
+template<class Alloc>
+vector(size_t,
+       const typename ctl::allocator_traits<Alloc>::value_type&,
+       Alloc = Alloc())
+  -> vector<typename ctl::allocator_traits<Alloc>::value_type, Alloc>;
+
 } // namespace ctl
 
-#endif // COSMOPOLITAN_CTL_OPTIONAL_H_
+#endif // CTL_VECTOR_H_
diff --git a/ctl/void_t.h b/ctl/void_t.h
new file mode 100644
index 000000000..c4573260e
--- /dev/null
+++ b/ctl/void_t.h
@@ -0,0 +1,13 @@
+// -*-mode:c++;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8-*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+#ifndef CTL_VOID_T_H_
+#define CTL_VOID_T_H_
+
+namespace ctl {
+
+template<typename... Ts>
+using void_t = void;
+
+} // namespace ctl
+
+#endif // CTL_VOID_T_H_
diff --git a/dsp/BUILD.mk b/dsp/BUILD.mk
index 87e655809..ae2150196 100644
--- a/dsp/BUILD.mk
+++ b/dsp/BUILD.mk
@@ -2,7 +2,9 @@
 #── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
 
 .PHONY:		o/$(MODE)/dsp
-o/$(MODE)/dsp:	o/$(MODE)/dsp/core	\
+o/$(MODE)/dsp:	o/$(MODE)/dsp/audio	\
+		o/$(MODE)/dsp/core	\
 		o/$(MODE)/dsp/mpeg	\
 		o/$(MODE)/dsp/scale	\
+		o/$(MODE)/dsp/prog	\
 		o/$(MODE)/dsp/tty
diff --git a/dsp/audio/BUILD.mk b/dsp/audio/BUILD.mk
new file mode 100644
index 000000000..8265a040c
--- /dev/null
+++ b/dsp/audio/BUILD.mk
@@ -0,0 +1,56 @@
+#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
+#── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
+
+PKGS += DSP_AUDIO
+
+DSP_AUDIO_ARTIFACTS += DSP_AUDIO_A
+DSP_AUDIO = $(DSP_AUDIO_A_DEPS) $(DSP_AUDIO_A)
+DSP_AUDIO_A = o/$(MODE)/dsp/audio/audio.a
+DSP_AUDIO_A_FILES := $(wildcard dsp/audio/*)
+DSP_AUDIO_A_HDRS = $(filter %.h,$(DSP_AUDIO_A_FILES)) dsp/audio/cosmoaudio/cosmoaudio.h
+DSP_AUDIO_A_SRCS = $(filter %.c,$(DSP_AUDIO_A_FILES))
+
+DSP_AUDIO_A_DATA =				\
+	dsp/audio/cosmoaudio/miniaudio.h	\
+	dsp/audio/cosmoaudio/cosmoaudio.c	\
+	dsp/audio/cosmoaudio/cosmoaudio.h	\
+	dsp/audio/cosmoaudio/cosmoaudio.dll	\
+
+DSP_AUDIO_A_OBJS =				\
+	$(DSP_AUDIO_A_SRCS:%.c=o/$(MODE)/%.o)	\
+	$(DSP_AUDIO_A_DATA:%=o/$(MODE)/%.zip.o)	\
+
+DSP_AUDIO_A_CHECKS =				\
+	$(DSP_AUDIO_A).pkg			\
+	$(DSP_AUDIO_A_HDRS:%=o/$(MODE)/%.ok)
+
+DSP_AUDIO_A_DIRECTDEPS =			\
+	LIBC_CALLS				\
+	LIBC_DLOPEN				\
+	LIBC_INTRIN				\
+	LIBC_NEXGEN32E				\
+	LIBC_STR				\
+	LIBC_SYSV				\
+	LIBC_PROC				\
+	LIBC_THREAD				\
+
+DSP_AUDIO_A_DEPS :=				\
+	$(call uniq,$(foreach x,$(DSP_AUDIO_A_DIRECTDEPS),$($(x))))
+
+$(DSP_AUDIO_A):	dsp/audio/			\
+		$(DSP_AUDIO_A).pkg		\
+		$(DSP_AUDIO_A_OBJS)
+
+$(DSP_AUDIO_A).pkg:				\
+		$(DSP_AUDIO_A_OBJS)		\
+		$(foreach x,$(DSP_AUDIO_A_DIRECTDEPS),$($(x)_A).pkg)
+
+DSP_AUDIO_LIBS = $(foreach x,$(DSP_AUDIO_ARTIFACTS),$($(x)))
+DSP_AUDIO_SRCS = $(foreach x,$(DSP_AUDIO_ARTIFACTS),$($(x)_SRCS))
+DSP_AUDIO_HDRS = $(foreach x,$(DSP_AUDIO_ARTIFACTS),$($(x)_HDRS))
+DSP_AUDIO_CHECKS = $(foreach x,$(DSP_AUDIO_ARTIFACTS),$($(x)_CHECKS))
+DSP_AUDIO_OBJS = $(foreach x,$(DSP_AUDIO_ARTIFACTS),$($(x)_OBJS))
+$(DSP_AUDIO_OBJS): $(BUILD_FILES) dsp/audio/BUILD.mk
+
+.PHONY: o/$(MODE)/dsp/audio
+o/$(MODE)/dsp/audio: $(DSP_AUDIO_CHECKS)
diff --git a/dsp/audio/audio.c b/dsp/audio/audio.c
new file mode 100644
index 000000000..f05a6a3b6
--- /dev/null
+++ b/dsp/audio/audio.c
@@ -0,0 +1,358 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "dsp/audio/cosmoaudio/cosmoaudio.h"
+#include "dsp/audio/describe.h"
+#include "libc/calls/blockcancel.internal.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/stat.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/dce.h"
+#include "libc/dlopen/dlfcn.h"
+#include "libc/errno.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/limits.h"
+#include "libc/macros.h"
+#include "libc/proc/posix_spawn.h"
+#include "libc/runtime/runtime.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/temp.h"
+#include "libc/thread/thread.h"
+
+#define COSMOAUDIO_MINIMUM_VERISON 1
+
+#define COSMOAUDIO_DSO_NAME "cosmoaudio." STRINGIFY(COSMOAUDIO_MINIMUM_VERISON)
+
+__static_yoink("dsp/audio/cosmoaudio/miniaudio.h");
+__static_yoink("dsp/audio/cosmoaudio/cosmoaudio.h");
+__static_yoink("dsp/audio/cosmoaudio/cosmoaudio.c");
+__static_yoink("dsp/audio/cosmoaudio/cosmoaudio.dll");
+
+static const struct Source {
+  const char *zip;
+  const char *name;
+} srcs[] = {
+    {"/zip/dsp/audio/cosmoaudio/miniaudio.h", "miniaudio.h"},
+    {"/zip/dsp/audio/cosmoaudio/cosmoaudio.h", "cosmoaudio.h"},
+    {"/zip/dsp/audio/cosmoaudio/cosmoaudio.c", "cosmoaudio.c"},  // must last
+};
+
+static struct {
+  pthread_once_t once;
+  typeof(cosmoaudio_open) *open;
+  typeof(cosmoaudio_close) *close;
+  typeof(cosmoaudio_write) *write;
+  typeof(cosmoaudio_flush) *flush;
+  typeof(cosmoaudio_read) *read;
+  typeof(cosmoaudio_poll) *poll;
+} g_audio;
+
+static const char *cosmoaudio_tmp_dir(void) {
+  const char *tmpdir;
+  if (!(tmpdir = getenv("TMPDIR")) || !*tmpdir)
+    if (!(tmpdir = getenv("HOME")) || !*tmpdir)
+      tmpdir = ".";
+  return tmpdir;
+}
+
+static bool cosmoaudio_app_dir(char *path, size_t size) {
+  strlcpy(path, cosmoaudio_tmp_dir(), size);
+  strlcat(path, "/.cosmo/", size);
+  if (makedirs(path, 0755))
+    return false;
+  return true;
+}
+
+static bool cosmoaudio_dso_path(char *path, size_t size) {
+  if (!cosmoaudio_app_dir(path, size))
+    return false;
+  strlcat(path, COSMOAUDIO_DSO_NAME, size);
+  if (IsWindows()) {
+    strlcat(path, ".dll", size);
+  } else if (IsXnu()) {
+    strlcat(path, ".dylib", size);
+  } else {
+    strlcat(path, ".so", size);
+  }
+  return true;
+}
+
+static bool cosmoaudio_extract(const char *zip, const char *to) {
+  int fdin, fdout;
+  char stage[PATH_MAX];
+  strlcpy(stage, to, sizeof(stage));
+  if (strlcat(stage, ".XXXXXX", sizeof(stage)) >= sizeof(stage)) {
+    errno = ENAMETOOLONG;
+    return false;
+  }
+  if ((fdout = mkostemp(stage, O_CLOEXEC)) == -1)
+    return false;
+  if ((fdin = open(zip, O_RDONLY | O_CLOEXEC)) == -1) {
+    close(fdout);
+    unlink(stage);
+    return false;
+  }
+  if (copyfd(fdin, fdout, -1) == -1) {
+    close(fdin);
+    close(fdout);
+    unlink(stage);
+    return false;
+  }
+  if (close(fdout)) {
+    close(fdin);
+    unlink(stage);
+    return false;
+  }
+  if (close(fdin)) {
+    unlink(stage);
+    return false;
+  }
+  if (rename(stage, to)) {
+    unlink(stage);
+    return false;
+  }
+  return true;
+}
+
+static bool cosmoaudio_build(const char *dso) {
+
+  // extract sauce
+  char src[PATH_MAX];
+  for (int i = 0; i < sizeof(srcs) / sizeof(*srcs); ++i) {
+    if (!cosmoaudio_app_dir(src, PATH_MAX))
+      return false;
+    strlcat(src, srcs[i].name, sizeof(src));
+    if (!cosmoaudio_extract(srcs[i].zip, src))
+      return false;
+  }
+
+  // create temporary name for compiled dso
+  // it'll ensure build operation is atomic
+  int fd;
+  char tmpdso[PATH_MAX];
+  strlcpy(tmpdso, dso, sizeof(tmpdso));
+  strlcat(tmpdso, ".XXXXXX", sizeof(tmpdso));
+  if ((fd = mkostemp(tmpdso, O_CLOEXEC)) != -1) {
+    close(fd);
+  } else {
+    return false;
+  }
+
+  // build cosmoaudio with host c compiler
+  char *args[] = {
+      "cc",                                       //
+      "-w",                                       //
+      "-I.",                                      //
+      "-O2",                                      //
+      "-fPIC",                                    //
+      "-shared",                                  //
+      "-pthread",                                 //
+      "-DNDEBUG",                                 //
+      IsAarch64() ? "-ffixed-x28" : "-DIGNORE1",  //
+      src,                                        //
+      "-o",                                       //
+      tmpdso,                                     //
+      "-lm",                                      //
+      IsNetbsd() ? 0 : "-ldl",                    //
+      NULL,
+  };
+  int pid, ws;
+  errno_t err = posix_spawnp(&pid, args[0], NULL, NULL, args, environ);
+  if (err)
+    return false;
+  while (waitpid(pid, &ws, 0) == -1)
+    if (errno != EINTR)
+      return false;
+  if (ws)
+    return false;
+
+  // move dso to its final destination
+  if (rename(tmpdso, dso))
+    return false;
+
+  return true;
+}
+
+static void *cosmoaudio_dlopen(const char *name) {
+  void *handle;
+  if ((handle = cosmo_dlopen(name, RTLD_NOW))) {
+    typeof(cosmoaudio_version) *version;
+    if ((version = cosmo_dlsym(handle, "cosmoaudio_version")))
+      if (version() >= COSMOAUDIO_MINIMUM_VERISON)
+        return handle;
+    cosmo_dlclose(handle);
+  }
+  return 0;
+}
+
+static void cosmoaudio_setup_impl(void) {
+  void *handle;
+  if (IsOpenbsd())
+    return;  // no dlopen support yet
+  if (IsXnu() && !IsXnuSilicon())
+    return;  // no dlopen support yet
+  if (!(handle = cosmoaudio_dlopen(COSMOAUDIO_DSO_NAME ".so")) &&
+      !(handle = cosmoaudio_dlopen("lib" COSMOAUDIO_DSO_NAME ".so")) &&
+      !(handle = cosmoaudio_dlopen("cosmoaudio.so")) &&
+      !(handle = cosmoaudio_dlopen("libcosmoaudio.so"))) {
+    char dso[PATH_MAX];
+    if (!cosmoaudio_dso_path(dso, sizeof(dso)))
+      return;
+    if ((handle = cosmoaudio_dlopen(dso)))
+      goto WeAreGood;
+    if (IsWindows()) {
+      if (cosmoaudio_extract("/zip/dsp/audio/cosmoaudio/cosmoaudio.dll", dso)) {
+        if ((handle = cosmoaudio_dlopen(dso))) {
+          goto WeAreGood;
+        } else {
+          return;
+        }
+      }
+    }
+    if (!cosmoaudio_build(dso))
+      return;
+    if (!(handle = cosmoaudio_dlopen(dso)))
+      return;
+  }
+WeAreGood:
+  g_audio.open = cosmo_dlsym(handle, "cosmoaudio_open");
+  g_audio.close = cosmo_dlsym(handle, "cosmoaudio_close");
+  g_audio.write = cosmo_dlsym(handle, "cosmoaudio_write");
+  g_audio.flush = cosmo_dlsym(handle, "cosmoaudio_flush");
+  g_audio.read = cosmo_dlsym(handle, "cosmoaudio_read");
+  g_audio.poll = cosmo_dlsym(handle, "cosmoaudio_poll");
+}
+
+static void cosmoaudio_setup(void) {
+  BLOCK_CANCELATION;
+  cosmoaudio_setup_impl();
+  ALLOW_CANCELATION;
+}
+
+static void cosmoaudio_init(void) {
+  pthread_once(&g_audio.once, cosmoaudio_setup);
+}
+
+COSMOAUDIO_ABI int cosmoaudio_open(
+    struct CosmoAudio **out_ca, const struct CosmoAudioOpenOptions *options) {
+  int status;
+  char sbuf[32];
+  char dbuf[256];
+  cosmoaudio_init();
+  if (g_audio.open) {
+    BLOCK_SIGNALS;
+    status = g_audio.open(out_ca, options);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  STRACE("cosmoaudio_open([%p], %s) → %s",
+         out_ca ? *out_ca : (struct CosmoAudio *)-1,
+         cosmoaudio_describe_open_options(dbuf, sizeof(dbuf), options),
+         cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
+
+COSMOAUDIO_ABI int cosmoaudio_close(struct CosmoAudio *ca) {
+  int status;
+  char sbuf[32];
+  if (g_audio.close) {
+    BLOCK_SIGNALS;
+    status = g_audio.close(ca);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  STRACE("cosmoaudio_close(%p) → %s", ca,
+         cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
+
+COSMOAUDIO_ABI int cosmoaudio_write(struct CosmoAudio *ca, const float *data,
+                                    int frames) {
+  int status;
+  char sbuf[32];
+  if (g_audio.write) {
+    BLOCK_SIGNALS;
+    status = g_audio.write(ca, data, frames);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  if (frames <= 0 || frames >= 160)
+    DATATRACE("cosmoaudio_write(%p, %p, %d) → %s", ca, data, frames,
+              cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
+
+COSMOAUDIO_ABI int cosmoaudio_read(struct CosmoAudio *ca, float *data,
+                                   int frames) {
+  int status;
+  char sbuf[32];
+  if (g_audio.read) {
+    BLOCK_SIGNALS;
+    status = g_audio.read(ca, data, frames);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  if (frames <= 0 || frames >= 160)
+    DATATRACE("cosmoaudio_read(%p, %p, %d) → %s", ca, data, frames,
+              cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
+
+COSMOAUDIO_ABI int cosmoaudio_flush(struct CosmoAudio *ca) {
+  int status;
+  char sbuf[32];
+  if (g_audio.flush) {
+    BLOCK_SIGNALS;
+    status = g_audio.flush(ca);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  DATATRACE("cosmoaudio_flush(%p) → %s", ca,
+            cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
+
+COSMOAUDIO_ABI int cosmoaudio_poll(struct CosmoAudio *ca,
+                                   int *in_out_readFrames,
+                                   int *in_out_writeFrames) {
+  int status;
+  char sbuf[32];
+  char fbuf[2][20];
+  if (g_audio.poll) {
+    BLOCK_SIGNALS;
+    status = g_audio.poll(ca, in_out_readFrames, in_out_writeFrames);
+    ALLOW_SIGNALS;
+  } else {
+    status = COSMOAUDIO_ELINK;
+  }
+  DATATRACE("cosmoaudio_poll(%p, %s, %s) → %s", ca,
+            cosmoaudio_describe_poll_frames(fbuf[0], sizeof(fbuf[0]),
+                                            in_out_readFrames),
+            cosmoaudio_describe_poll_frames(fbuf[1], sizeof(fbuf[1]),
+                                            in_out_writeFrames),
+            cosmoaudio_describe_status(sbuf, sizeof(sbuf), status));
+  return status;
+}
diff --git a/dsp/audio/cosmoaudio/.gitignore b/dsp/audio/cosmoaudio/.gitignore
new file mode 100644
index 000000000..87bb5b389
--- /dev/null
+++ b/dsp/audio/cosmoaudio/.gitignore
@@ -0,0 +1,3 @@
+*.o
+/Debug
+/Release
diff --git a/dsp/audio/cosmoaudio/Makefile.msvc b/dsp/audio/cosmoaudio/Makefile.msvc
new file mode 100644
index 000000000..0165c5d16
--- /dev/null
+++ b/dsp/audio/cosmoaudio/Makefile.msvc
@@ -0,0 +1,87 @@
+# Makefile for MSVC x64 Command Line Developer Tools
+#
+#     nmake /f Makefile.msvc check
+#     nmake /f Makefile.msvc MODE=debug check
+#
+# Note: MSVC 2019 makes the DLL 64kb smaller than MSVC 2022.
+
+# Compiler and linker
+CC=cl
+LINK=link
+
+# Build mode (can be overridden from command line)
+!IFNDEF MODE
+MODE=release
+!ENDIF
+
+# Library dependencies.
+TEST_LIBS=OneCore.lib
+
+# Compiler flags
+CFLAGS_COMMON=/nologo /W4 /Gy /EHsc
+CFLAGS_DEBUG=/Od /Zi /MDd /D_DEBUG
+CFLAGS_RELEASE=/O2 /MT /DNDEBUG
+
+!IF "$(MODE)"=="debug"
+CFLAGS=$(CFLAGS_COMMON) $(CFLAGS_DEBUG)
+LDFLAGS=/DEBUG
+OUT_DIR=Debug
+!ELSE
+CFLAGS=$(CFLAGS_COMMON) $(CFLAGS_RELEASE) /GL
+LDFLAGS=/RELEASE /OPT:REF /OPT:ICF /LTCG /INCREMENTAL:NO
+OUT_DIR=Release
+!ENDIF
+
+# Additional flags for DLL
+DLL_CFLAGS=$(CFLAGS) /D_USRDLL /D_WINDLL
+
+# Linker flags
+LDFLAGS=/NOLOGO /SUBSYSTEM:CONSOLE $(LDFLAGS)
+
+# Output file names
+DLL_TARGET=$(OUT_DIR)\cosmoaudio.dll
+TEST_TARGET=$(OUT_DIR)\test.exe
+
+# Source files
+DLL_SOURCES=cosmoaudio.c
+TEST_SOURCES=test.c
+
+# Object files
+DLL_OBJECTS=$(OUT_DIR)\cosmoaudio.obj
+TEST_OBJECTS=$(OUT_DIR)\test.obj
+
+# Default target
+all: $(OUT_DIR) $(DLL_TARGET) $(TEST_TARGET)
+
+# Create output directory
+$(OUT_DIR):
+    if not exist $(OUT_DIR) mkdir $(OUT_DIR)
+
+# Rule to build the DLL
+$(DLL_TARGET): $(OUT_DIR) $(DLL_OBJECTS)
+    $(LINK) /DLL $(LDFLAGS) /OUT:$(DLL_TARGET) $(DLL_OBJECTS)
+
+# Rule to build the test program
+$(TEST_TARGET): $(OUT_DIR) $(TEST_OBJECTS) $(DLL_TARGET)
+    $(LINK) $(LDFLAGS) /OUT:$(TEST_TARGET) $(TEST_OBJECTS) $(DLL_TARGET:.dll=.lib) $(TEST_LIBS)
+
+# Rules to compile .c files to .obj files with header dependencies
+{.}.c{$(OUT_DIR)}.obj:
+    $(CC) $(DLL_CFLAGS) /c /Fo$(OUT_DIR)\ $<
+
+$(OUT_DIR)\test.obj: $(OUT_DIR) test.c cosmoaudio.h
+    $(CC) $(CFLAGS) /c /Fo$(OUT_DIR)\ test.c
+
+$(OUT_DIR)\cosmoaudio.obj: $(OUT_DIR) cosmoaudio.c miniaudio.h cosmoaudio.h
+    $(CC) $(DLL_CFLAGS) /c /Fo$(OUT_DIR)\ cosmoaudio.c
+
+# Clean target
+clean:
+    if exist $(OUT_DIR) rmdir /s /q $(OUT_DIR)
+
+# Run tests (now called 'check')
+check: $(TEST_TARGET)
+    $(TEST_TARGET)
+
+# Phony targets
+.PHONY: all clean check
diff --git a/dsp/audio/cosmoaudio/cosmoaudio.c b/dsp/audio/cosmoaudio/cosmoaudio.c
new file mode 100644
index 000000000..e518a4852
--- /dev/null
+++ b/dsp/audio/cosmoaudio/cosmoaudio.c
@@ -0,0 +1,519 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#define COSMOAUDIO_BUILD
+#include "cosmoaudio.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MA_DEBUG_OUTPUT
+#define MA_DR_MP3_NO_STDIO
+#define MA_NO_DECODING
+#define MA_NO_ENCODING
+#define MA_NO_ENGINE
+#define MA_NO_GENERATION
+#define MA_NO_NODE_GRAPH
+#define MA_NO_RESOURCE_MANAGER
+#define MA_STATIC
+
+#define MINIAUDIO_IMPLEMENTATION
+#include "miniaudio.h"
+
+struct CosmoAudio {
+  enum CosmoAudioDeviceType deviceType;
+  ma_uint32 outputBufferFrames;
+  ma_uint32 inputBufferFrames;
+  int sampleRate;
+  int channels;
+  int isLeft;
+  ma_context context;
+  ma_device device;
+  ma_pcm_rb output;
+  ma_pcm_rb input;
+  ma_event event;
+  ma_log log;
+};
+
+static int read_ring_buffer(ma_log* log, ma_pcm_rb* rb, float* pOutput,
+                            ma_uint32 frameCount, ma_uint32 channels) {
+  ma_result result;
+  ma_uint32 framesRead;
+  ma_uint32 framesToRead;
+  for (framesRead = 0; framesRead < frameCount; framesRead += framesToRead) {
+    framesToRead = frameCount - framesRead;
+    void* pMappedBuffer;
+    result = ma_pcm_rb_acquire_read(rb, &framesToRead, &pMappedBuffer);
+    if (result != MA_SUCCESS) {
+      ma_log_postf(log, MA_LOG_LEVEL_WARNING,
+                   "ma_pcm_rb_acquire_read failed: %s\n",
+                   ma_result_description(result));
+      return COSMOAUDIO_ERROR;
+    }
+    if (!framesToRead)
+      break;
+    memcpy(pOutput + framesRead * channels, pMappedBuffer,
+           framesToRead * channels * sizeof(float));
+    result = ma_pcm_rb_commit_read(rb, framesToRead);
+    if (result != MA_SUCCESS) {
+      if (result == MA_AT_END) {
+        framesRead += framesToRead;
+        break;
+      }
+      ma_log_postf(log, MA_LOG_LEVEL_WARNING,
+                   "ma_pcm_rb_commit_read failed: %s\n",
+                   ma_result_description(result));
+      return COSMOAUDIO_ERROR;
+    }
+  }
+  return framesRead;
+}
+
+static int write_ring_buffer(ma_log* log, ma_pcm_rb* rb, const float* pInput,
+                             ma_uint32 frameCount, ma_uint32 channels) {
+  ma_result result;
+  ma_uint32 framesWritten;
+  ma_uint32 framesToWrite;
+  for (framesWritten = 0; framesWritten < frameCount;
+       framesWritten += framesToWrite) {
+    framesToWrite = frameCount - framesWritten;
+    void* pMappedBuffer;
+    result = ma_pcm_rb_acquire_write(rb, &framesToWrite, &pMappedBuffer);
+    if (result != MA_SUCCESS) {
+      ma_log_postf(log, MA_LOG_LEVEL_WARNING,
+                   "ma_pcm_rb_acquire_write failed: %s\n",
+                   ma_result_description(result));
+      return COSMOAUDIO_ERROR;
+    }
+    if (!framesToWrite)
+      break;
+    memcpy(pMappedBuffer, pInput + framesWritten * channels,
+           framesToWrite * channels * sizeof(float));
+    result = ma_pcm_rb_commit_write(rb, framesToWrite);
+    if (result != MA_SUCCESS) {
+      if (result == MA_AT_END) {
+        framesWritten += framesToWrite;
+        break;
+      }
+      ma_log_postf(log, MA_LOG_LEVEL_WARNING,
+                   "ma_pcm_rb_commit_write failed: %s\n",
+                   ma_result_description(result));
+      return COSMOAUDIO_ERROR;
+    }
+  }
+  return framesWritten;
+}
+
+static void data_callback_f32(ma_device* pDevice, float* pOutput,
+                              const float* pInput, ma_uint32 frameCount) {
+  struct CosmoAudio* ca = (struct CosmoAudio*)pDevice->pUserData;
+  if (ca->deviceType & kCosmoAudioDeviceTypePlayback) {
+    //
+    // "By default, miniaudio will pre-silence the data callback's
+    //  output buffer. If you know that you will always write valid data
+    //  to the output buffer you can disable pre-silencing by setting
+    //  the noPreSilence config option in the device config to true."
+    //
+    //          —Quoth miniaudio documentation § 16.1. Low Level API
+    //
+    if (ca->isLeft) {
+      int framesCopied = read_ring_buffer(&ca->log, &ca->output, pOutput,
+                                          frameCount, ca->channels);
+      if (framesCopied < (int)frameCount)
+        ca->isLeft = 0;
+    } else {
+      // TODO(jart): Maybe we should stretch the audio too short?
+      int frameOffset;
+      int availableFrames = ma_pcm_rb_available_read(&ca->output);
+      if (availableFrames >= (int)frameCount) {
+        frameOffset = 0;
+      } else {
+        frameOffset = frameCount - availableFrames;
+        frameCount = availableFrames;
+      }
+      read_ring_buffer(&ca->log, &ca->output,
+                       pOutput + frameOffset * ca->channels, frameCount,
+                       ca->channels);
+      ca->isLeft = 1;
+    }
+  }
+  if (ca->deviceType & kCosmoAudioDeviceTypeCapture)
+    write_ring_buffer(&ca->log, &ca->input, pInput, frameCount, ca->channels);
+  ma_event_signal(&ca->event);
+}
+
+static void data_callback(ma_device* pDevice, void* pOutput, const void* pInput,
+                          ma_uint32 frameCount) {
+  data_callback_f32(pDevice, (float*)pOutput, (const float*)pInput, frameCount);
+}
+
+/**
+ * Returns current version of cosmo audio library.
+ */
+COSMOAUDIO_ABI int cosmoaudio_version(void) {
+  return 1;
+}
+
+/**
+ * Opens access to speaker and microphone.
+ *
+ * @param out_ca will receive pointer to allocated CosmoAudio object,
+ *     which must be freed by caller with cosmoaudio_close(); if this
+ *     function fails, then this will receive a NULL pointer value so
+ *     that cosmoaudio_close(), cosmoaudio_write() etc. can be called
+ *     without crashing if no error checking is performed
+ * @return 0 on success, or negative error code on failure
+ */
+COSMOAUDIO_ABI int cosmoaudio_open(  //
+    struct CosmoAudio** out_ca,      //
+    const struct CosmoAudioOpenOptions* options) {
+
+  // Validate arguments.
+  if (!out_ca)
+    return COSMOAUDIO_EINVAL;
+  *out_ca = NULL;
+  if (!options)
+    return COSMOAUDIO_EINVAL;
+  if (options->sizeofThis < (int)sizeof(struct CosmoAudioOpenOptions))
+    return COSMOAUDIO_EINVAL;
+  if (options->bufferFrames < 0)
+    return COSMOAUDIO_EINVAL;
+  if (options->sampleRate < 8000)
+    return COSMOAUDIO_EINVAL;
+  if (options->channels < 1)
+    return COSMOAUDIO_EINVAL;
+  if (!options->deviceType)
+    return COSMOAUDIO_EINVAL;
+  if (options->deviceType &
+      ~(kCosmoAudioDeviceTypePlayback | kCosmoAudioDeviceTypeCapture))
+    return COSMOAUDIO_EINVAL;
+
+  // Allocate cosmo audio object.
+  struct CosmoAudio* ca;
+  ca = (struct CosmoAudio*)calloc(1, sizeof(struct CosmoAudio));
+  if (!ca)
+    return COSMOAUDIO_ERROR;
+  ca->channels = options->channels;
+  ca->sampleRate = options->sampleRate;
+  ca->deviceType = options->deviceType;
+
+  // Create win32-style condition variable.
+  if (ma_event_init(&ca->event) != MA_SUCCESS) {
+    free(ca);
+    return COSMOAUDIO_ERROR;
+  }
+
+  // Create audio log.
+  if (ma_log_init(NULL, &ca->log) != MA_SUCCESS) {
+    ma_event_uninit(&ca->event);
+    free(ca);
+    return COSMOAUDIO_ERROR;
+  }
+  if (!options->debugLog)
+    ca->log.callbackCount = 0;
+
+  // Create audio context.
+  ma_context_config contextConfig = ma_context_config_init();
+  contextConfig.pLog = &ca->log;
+  if (ma_context_init(NULL, 0, &contextConfig, &ca->context) != MA_SUCCESS) {
+    ma_event_uninit(&ca->event);
+    ma_log_uninit(&ca->log);
+    free(ca);
+    return COSMOAUDIO_ERROR;
+  }
+
+  // Initialize device.
+  ma_result result;
+  ma_device_config deviceConfig;
+  deviceConfig = ma_device_config_init(ca->deviceType);
+  deviceConfig.sampleRate = ca->sampleRate;
+  if (ca->deviceType & kCosmoAudioDeviceTypeCapture) {
+    deviceConfig.capture.channels = ca->channels;
+    deviceConfig.capture.format = ma_format_f32;
+    deviceConfig.capture.shareMode = ma_share_mode_shared;
+  }
+  if (ca->deviceType & kCosmoAudioDeviceTypePlayback) {
+    deviceConfig.playback.channels = ca->channels;
+    deviceConfig.playback.format = ma_format_f32;
+  }
+  deviceConfig.dataCallback = data_callback;
+  deviceConfig.pUserData = ca;
+  result = ma_device_init(&ca->context, &deviceConfig, &ca->device);
+  if (result != MA_SUCCESS) {
+    ma_context_uninit(&ca->context);
+    ma_event_uninit(&ca->event);
+    ma_log_uninit(&ca->log);
+    free(ca);
+    return COSMOAUDIO_ERROR;
+  }
+
+  // Initialize the speaker ring buffer.
+  int period = ca->device.playback.internalPeriodSizeInFrames;
+  if (!options->bufferFrames) {
+    ca->outputBufferFrames = period * 10;
+  } else if (options->bufferFrames < period * 2) {
+    ca->outputBufferFrames = period * 2;
+  } else {
+    ca->outputBufferFrames = options->bufferFrames;
+  }
+  if (ca->deviceType & kCosmoAudioDeviceTypePlayback) {
+    result = ma_pcm_rb_init(ma_format_f32, ca->channels, ca->outputBufferFrames,
+                            NULL, NULL, &ca->output);
+    if (result != MA_SUCCESS) {
+      ma_device_uninit(&ca->device);
+      ma_context_uninit(&ca->context);
+      ma_event_uninit(&ca->event);
+      ma_log_uninit(&ca->log);
+      free(ca);
+      return COSMOAUDIO_ERROR;
+    }
+    ma_pcm_rb_set_sample_rate(&ca->output, ca->sampleRate);
+  }
+
+  // Initialize the microphone ring buffer.
+  period = ca->device.capture.internalPeriodSizeInFrames;
+  if (!options->bufferFrames) {
+    ca->inputBufferFrames = period * 10;
+  } else if (options->bufferFrames < period * 2) {
+    ca->inputBufferFrames = period * 2;
+  } else {
+    ca->inputBufferFrames = options->bufferFrames;
+  }
+  if (ca->deviceType & kCosmoAudioDeviceTypeCapture) {
+    result = ma_pcm_rb_init(ma_format_f32, ca->channels, ca->inputBufferFrames,
+                            NULL, NULL, &ca->input);
+    if (result != MA_SUCCESS) {
+      ma_device_uninit(&ca->device);
+      if (ca->deviceType & kCosmoAudioDeviceTypePlayback)
+        ma_pcm_rb_uninit(&ca->output);
+      ma_context_uninit(&ca->context);
+      ma_event_uninit(&ca->event);
+      ma_log_uninit(&ca->log);
+      free(ca);
+      return COSMOAUDIO_ERROR;
+    }
+    ma_pcm_rb_set_sample_rate(&ca->output, ca->sampleRate);
+  }
+
+  // Start audio playback.
+  if (ma_device_start(&ca->device) != MA_SUCCESS) {
+    ma_device_uninit(&ca->device);
+    if (ca->deviceType & kCosmoAudioDeviceTypePlayback)
+      ma_pcm_rb_uninit(&ca->output);
+    if (ca->deviceType & kCosmoAudioDeviceTypeCapture)
+      ma_pcm_rb_uninit(&ca->input);
+    ma_context_uninit(&ca->context);
+    ma_event_uninit(&ca->event);
+    ma_log_uninit(&ca->log);
+    free(ca);
+    return COSMOAUDIO_ERROR;
+  }
+
+  *out_ca = ca;
+  return COSMOAUDIO_SUCCESS;
+}
+
+/**
+ * Closes audio device and frees all associated resources.
+ *
+ * This function is non-blocking and will drop buffered audio. In
+ * playback mode, you need to call cosmoaudio_flush() to ensure data
+ * supplied by cosmoaudio_write() gets played on your speaker.
+ *
+ * Calling this function twice on the same object will result in
+ * undefined behavior. Even if this function fails, the `ca` will be
+ * freed to the greatest extent possible.
+ *
+ * @param ca is CosmoAudio object returned earlier by cosmoaudio_open()
+ * @return 0 on success, or negative error code on failure
+ */
+COSMOAUDIO_ABI int cosmoaudio_close(struct CosmoAudio* ca) {
+  if (!ca)
+    return COSMOAUDIO_EINVAL;
+  ma_device_uninit(&ca->device);  // do this first
+  if (ca->deviceType & kCosmoAudioDeviceTypePlayback)
+    ma_pcm_rb_uninit(&ca->output);
+  if (ca->deviceType & kCosmoAudioDeviceTypeCapture)
+    ma_pcm_rb_uninit(&ca->input);
+  ma_context_uninit(&ca->context);
+  ma_event_uninit(&ca->event);
+  ma_log_uninit(&ca->log);
+  free(ca);
+  return COSMOAUDIO_SUCCESS;
+}
+
+/**
+ * Writes raw audio data to speaker.
+ *
+ * The data is written to a ring buffer in real-time, which is then
+ * played back very soon on the audio device. This has tolerence for
+ * a certain amount of buffering, but expects that this function is
+ * repeatedly called at a regular time interval. The caller should
+ * have its own sleep loop for this purpose.
+ *
+ * This function never blocks. Programs that don't have their own timer
+ * can use cosmoaudio_poll() to wait until audio may be written.
+ *
+ * For any given CosmoAudio object, it's assumed that only a single
+ * thread will call this function.
+ *
+ * @param ca is CosmoAudio object returned earlier by cosmoaudio_open()
+ * @param data is pointer to raw audio samples, expected to be in the range
+ *     -1.0 to 1.0, where channels are interleaved
+ * @param frames is the number of frames (i.e. number of samples divided by
+ *     number of channels) from `data` to write to audio device
+ * @return number of frames written, or negative error code on failure
+ */
+COSMOAUDIO_ABI int cosmoaudio_write(struct CosmoAudio* ca, const float* data,
+                                    int frames) {
+  if (!ca)
+    return COSMOAUDIO_EINVAL;
+  if (frames < 0)
+    return COSMOAUDIO_EINVAL;
+  if (!(ca->deviceType & kCosmoAudioDeviceTypePlayback))
+    return COSMOAUDIO_EINVAL;
+  if (1u + frames > ca->outputBufferFrames)
+    return COSMOAUDIO_ENOBUF;
+  if (!frames)
+    return 0;
+  if (!data)
+    return COSMOAUDIO_EINVAL;
+  return write_ring_buffer(&ca->log, &ca->output, data, frames, ca->channels);
+}
+
+/**
+ * Reads raw audio data from microphone.
+ *
+ * The data is read from a ring buffer in real-time, which is then
+ * played back on the audio device. This has tolerence for a certain
+ * amount of buffering (based on the `bufferFrames` parameter passed to
+ * cosmoaudio_open(), which by default assumes this function will be
+ * called at at a regular time interval.
+ *
+ * This function never blocks. Programs that don't have their own timer
+ * can use cosmoaudio_poll() to wait until audio may be read.
+ *
+ * For any given CosmoAudio object, it's assumed that only a single
+ * thread will call this function.
+ *
+ * @param ca is CosmoAudio object returned earlier by cosmoaudio_open()
+ * @param data is pointer to raw audio samples, expected to be in the range
+ *     -1.0 to 1.0, where channels are interleaved
+ * @param frames is the number of frames (i.e. number of samples divided by
+ *     number of channels) from `data` to read from microphone
+ * @return number of frames read, or negative error code on failure
+ */
+COSMOAUDIO_ABI int cosmoaudio_read(struct CosmoAudio* ca, float* data,
+                                   int frames) {
+  if (!ca)
+    return COSMOAUDIO_EINVAL;
+  if (frames < 0)
+    return COSMOAUDIO_EINVAL;
+  if (!(ca->deviceType & kCosmoAudioDeviceTypeCapture))
+    return COSMOAUDIO_EINVAL;
+  if (!frames)
+    return 0;
+  if (!data)
+    return COSMOAUDIO_EINVAL;
+  return read_ring_buffer(&ca->log, &ca->input, data, frames, ca->channels);
+}
+
+/**
+ * Waits until it's possible to read/write audio.
+ *
+ * This function is uninterruptible. All signals are masked throughout
+ * the duration of time this function may block, including cancelation
+ * signals, because this is not a cancelation point. Cosmopolitan Libc
+ * applies this masking in its dlopen wrapper.
+ *
+ * @param ca is CosmoAudio object returned earlier by cosmoaudio_open()
+ * @param in_out_readFrames if non-NULL specifies how many frames of
+ *     capture data be immediately readable by cosmoaudio_read() before
+ *     this can return; it must not exceed the buffer size; on return
+ *     this will be set to the actual number of frames in the buffer;
+ *     if the caller supplies a zero then this call is a non-blocking
+ *     way to query buffer sizes
+ * @param in_out_writeFrames if non-NULL specifies how many frames of
+ *     capture data be immediately writable by cosmoaudio_write() before
+ *     this can return; it must not exceed the buffer size; on return
+ *     this will be set to the actual number of frames in the buffer;
+ *     if the caller supplies a zero then this call is a non-blocking
+ *     way to query buffer sizes
+ * @return 0 on success, or negative error code on error
+ */
+COSMOAUDIO_ABI int cosmoaudio_poll(struct CosmoAudio* ca,
+                                   int* in_out_readFrames,
+                                   int* in_out_writeFrames) {
+  if (!ca)
+    return COSMOAUDIO_EINVAL;
+  if (!in_out_readFrames && !in_out_writeFrames)
+    return COSMOAUDIO_EINVAL;
+  if (in_out_readFrames && !(ca->deviceType & kCosmoAudioDeviceTypeCapture))
+    return COSMOAUDIO_EINVAL;
+  if (in_out_writeFrames && !(ca->deviceType & kCosmoAudioDeviceTypePlayback))
+    return COSMOAUDIO_EINVAL;
+  if (in_out_readFrames && 1u + *in_out_readFrames > ca->inputBufferFrames)
+    return COSMOAUDIO_ENOBUF;
+  if (in_out_writeFrames && 1u + *in_out_writeFrames > ca->outputBufferFrames)
+    return COSMOAUDIO_ENOBUF;
+  for (;;) {
+    int done = 1;
+    ma_uint32 readable = 0;
+    ma_uint32 writable = 0;
+    if (in_out_readFrames) {
+      readable = ma_pcm_rb_available_read(&ca->input);
+      done &= readable >= (ma_uint32)*in_out_readFrames;
+    }
+    if (in_out_writeFrames) {
+      writable = ma_pcm_rb_available_write(&ca->output);
+      done &= writable >= (ma_uint32)*in_out_writeFrames;
+    }
+    if (done) {
+      if (in_out_readFrames)
+        *in_out_readFrames = readable;
+      if (in_out_writeFrames)
+        *in_out_writeFrames = writable;
+      return COSMOAUDIO_SUCCESS;
+    }
+    if (ma_event_wait(&ca->event) != MA_SUCCESS)
+      return COSMOAUDIO_ERROR;
+  }
+}
+
+/**
+ * Waits for written samples to be sent to device.
+ *
+ * This function is only valid to call in playback or duplex mode.
+ *
+ * This function is uninterruptible. All signals are masked throughout
+ * the duration of time this function may block, including cancelation
+ * signals, because this is not a cancelation point. Cosmopolitan Libc
+ * applies this masking in its dlopen wrapper.
+ *
+ * @param ca is CosmoAudio object returned earlier by cosmoaudio_open()
+ * @return 0 on success, or negative error code on failure
+ */
+COSMOAUDIO_ABI int cosmoaudio_flush(struct CosmoAudio* ca) {
+  if (!ca)
+    return COSMOAUDIO_EINVAL;
+  if (!(ca->deviceType & kCosmoAudioDeviceTypePlayback))
+    return COSMOAUDIO_EINVAL;
+  for (;;) {
+    if (!ma_pcm_rb_available_read(&ca->output))
+      return COSMOAUDIO_SUCCESS;
+    if (ma_event_wait(&ca->event) != MA_SUCCESS)
+      return COSMOAUDIO_ERROR;
+  }
+}
diff --git a/dsp/audio/cosmoaudio/cosmoaudio.dll b/dsp/audio/cosmoaudio/cosmoaudio.dll
new file mode 100644
index 000000000..7ef152aa4
Binary files /dev/null and b/dsp/audio/cosmoaudio/cosmoaudio.dll differ
diff --git a/dsp/audio/cosmoaudio/cosmoaudio.h b/dsp/audio/cosmoaudio/cosmoaudio.h
new file mode 100644
index 000000000..40158ab81
--- /dev/null
+++ b/dsp/audio/cosmoaudio/cosmoaudio.h
@@ -0,0 +1,104 @@
+#ifndef COSMOAUDIO_H_
+#define COSMOAUDIO_H_
+
+#ifdef _MSC_VER
+#define COSMOAUDIO_ABI
+#ifdef COSMOAUDIO_BUILD
+#define COSMOAUDIO_API __declspec(dllexport)
+#else
+#define COSMOAUDIO_API __declspec(dllimport)
+#endif
+#else
+#define COSMOAUDIO_API
+#ifdef __x86_64__
+#define COSMOAUDIO_ABI __attribute__((__ms_abi__, __visibility__("default")))
+#else
+#define COSMOAUDIO_ABI __attribute__((__visibility__("default")))
+#endif
+#endif
+
+#define COSMOAUDIO_SUCCESS -0  // no error or nothing written
+#define COSMOAUDIO_ERROR   -1  // unspecified error
+#define COSMOAUDIO_EINVAL  -2  // invalid parameters passed to api
+#define COSMOAUDIO_ELINK   -3  // loading cosmoaudio dso failed
+#define COSMOAUDIO_ENOBUF  -4  // invalid buffering parameters
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct CosmoAudio;
+
+enum CosmoAudioDeviceType {
+  kCosmoAudioDeviceTypePlayback = 1,
+  kCosmoAudioDeviceTypeCapture = 2,
+  kCosmoAudioDeviceTypeDuplex =
+      kCosmoAudioDeviceTypePlayback | kCosmoAudioDeviceTypeCapture,
+};
+
+struct CosmoAudioOpenOptions {
+
+  // This field must be set to sizeof(struct CosmoAudioOpenOptions) or
+  // cosmoaudio_open() will return COSMOAUDIO_EINVAL.
+  int sizeofThis;
+
+  // Whether you want this object to open the speaker or microphone.
+  // Please note that asking for microphone access may cause some OSes
+  // like MacOS to show a popup asking the user for permission.
+  enum CosmoAudioDeviceType deviceType;
+
+  // The sample rate can be 44100 for CD quality, 8000 for telephone
+  // quality, etc. Values below 8000 are currently not supported.
+  int sampleRate;
+
+  // The number of audio channels in each interleaved frame. Should be 1
+  // for mono or 2 for stereo.
+  int channels;
+
+  // Number of frames in each ring buffer. A frame consists of a PCM
+  // sample for each channel. Set to 0 for default. If this is less than
+  // the device period size times two, it'll be increased to that value.
+  int bufferFrames;
+
+  // Enables debug logging if non-zero.
+  int debugLog;
+};
+
+COSMOAUDIO_API int cosmoaudio_version(void) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_open(              //
+    struct CosmoAudio **out_ca,                  //
+    const struct CosmoAudioOpenOptions *options  //
+    ) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_close(  //
+    struct CosmoAudio *ca             //
+    ) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_write(  //
+    struct CosmoAudio *ca,            //
+    const float *samples,             //
+    int frameCount                    //
+    ) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_flush(  //
+    struct CosmoAudio *ca             //
+    ) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_read(  //
+    struct CosmoAudio *ca,           //
+    float *out_samples,              //
+    int frameCount                   //
+    ) COSMOAUDIO_ABI;
+
+COSMOAUDIO_API int cosmoaudio_poll(  //
+    struct CosmoAudio *ca,           //
+    int *in_out_readFrames,          //
+    int *in_out_writeFrames          //
+    ) COSMOAUDIO_ABI;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* COSMOAUDIO_H_ */
diff --git a/dsp/audio/cosmoaudio/miniaudio.h b/dsp/audio/cosmoaudio/miniaudio.h
new file mode 100644
index 000000000..47332e11a
--- /dev/null
+++ b/dsp/audio/cosmoaudio/miniaudio.h
@@ -0,0 +1,92621 @@
+/*
+Audio playback and capture library. Choice of public domain or MIT-0. See license statements at the end of this file.
+miniaudio - v0.11.21 - 2023-11-15
+
+David Reid - mackron@gmail.com
+
+Website:       https://miniaud.io
+Documentation: https://miniaud.io/docs
+GitHub:        https://github.com/mackron/miniaudio
+*/
+
+/*
+1. Introduction
+===============
+miniaudio is a single file library for audio playback and capture. To use it, do the following in
+one .c file:
+
+    ```c
+    #define MINIAUDIO_IMPLEMENTATION
+    #include "miniaudio.h"
+    ```
+
+You can do `#include "miniaudio.h"` in other parts of the program just like any other header.
+
+miniaudio includes both low level and high level APIs. The low level API is good for those who want
+to do all of their mixing themselves and only require a light weight interface to the underlying
+audio device. The high level API is good for those who have complex mixing and effect requirements.
+
+In miniaudio, objects are transparent structures. Unlike many other libraries, there are no handles
+to opaque objects which means you need to allocate memory for objects yourself. In the examples
+presented in this documentation you will often see objects declared on the stack. You need to be
+careful when translating these examples to your own code so that you don't accidentally declare
+your objects on the stack and then cause them to become invalid once the function returns. In
+addition, you must ensure the memory address of your objects remain the same throughout their
+lifetime. You therefore cannot be making copies of your objects.
+
+A config/init pattern is used throughout the entire library. The idea is that you set up a config
+object and pass that into the initialization routine. The advantage to this system is that the
+config object can be initialized with logical defaults and new properties added to it without
+breaking the API. The config object can be allocated on the stack and does not need to be
+maintained after initialization of the corresponding object.
+
+
+1.1. Low Level API
+------------------
+The low level API gives you access to the raw audio data of an audio device. It supports playback,
+capture, full-duplex and loopback (WASAPI only). You can enumerate over devices to determine which
+physical device(s) you want to connect to.
+
+The low level API uses the concept of a "device" as the abstraction for physical devices. The idea
+is that you choose a physical device to emit or capture audio from, and then move data to/from the
+device when miniaudio tells you to. Data is delivered to and from devices asynchronously via a
+callback which you specify when initializing the device.
+
+When initializing the device you first need to configure it. The device configuration allows you to
+specify things like the format of the data delivered via the callback, the size of the internal
+buffer and the ID of the device you want to emit or capture audio from.
+
+Once you have the device configuration set up you can initialize the device. When initializing a
+device you need to allocate memory for the device object beforehand. This gives the application
+complete control over how the memory is allocated. In the example below we initialize a playback
+device on the stack, but you could allocate it on the heap if that suits your situation better.
+
+    ```c
+    void data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
+    {
+        // In playback mode copy data to pOutput. In capture mode read data from pInput. In full-duplex mode, both
+        // pOutput and pInput will be valid and you can move data from pInput into pOutput. Never process more than
+        // frameCount frames.
+    }
+
+    int main()
+    {
+        ma_device_config config = ma_device_config_init(ma_device_type_playback);
+        config.playback.format   = ma_format_f32;   // Set to ma_format_unknown to use the device's native format.
+        config.playback.channels = 2;               // Set to 0 to use the device's native channel count.
+        config.sampleRate        = 48000;           // Set to 0 to use the device's native sample rate.
+        config.dataCallback      = data_callback;   // This function will be called when miniaudio needs more data.
+        config.pUserData         = pMyCustomData;   // Can be accessed from the device object (device.pUserData).
+
+        ma_device device;
+        if (ma_device_init(NULL, &config, &device) != MA_SUCCESS) {
+            return -1;  // Failed to initialize the device.
+        }
+
+        ma_device_start(&device);     // The device is sleeping by default so you'll need to start it manually.
+
+        // Do something here. Probably your program's main loop.
+
+        ma_device_uninit(&device);
+        return 0;
+    }
+    ```
+
+In the example above, `data_callback()` is where audio data is written and read from the device.
+The idea is in playback mode you cause sound to be emitted from the speakers by writing audio data
+to the output buffer (`pOutput` in the example). In capture mode you read data from the input
+buffer (`pInput`) to extract sound captured by the microphone. The `frameCount` parameter tells you
+how many frames can be written to the output buffer and read from the input buffer. A "frame" is
+one sample for each channel. For example, in a stereo stream (2 channels), one frame is 2
+samples: one for the left, one for the right. The channel count is defined by the device config.
+The size in bytes of an individual sample is defined by the sample format which is also specified
+in the device config. Multi-channel audio data is always interleaved, which means the samples for
+each frame are stored next to each other in memory. For example, in a stereo stream the first pair
+of samples will be the left and right samples for the first frame, the second pair of samples will
+be the left and right samples for the second frame, etc.
+
+The configuration of the device is defined by the `ma_device_config` structure. The config object
+is always initialized with `ma_device_config_init()`. It's important to always initialize the
+config with this function as it initializes it with logical defaults and ensures your program
+doesn't break when new members are added to the `ma_device_config` structure. The example above
+uses a fairly simple and standard device configuration. The call to `ma_device_config_init()` takes
+a single parameter, which is whether or not the device is a playback, capture, duplex or loopback
+device (loopback devices are not supported on all backends). The `config.playback.format` member
+sets the sample format which can be one of the following (all formats are native-endian):
+
+    +---------------+----------------------------------------+---------------------------+
+    | Symbol        | Description                            | Range                     |
+    +---------------+----------------------------------------+---------------------------+
+    | ma_format_f32 | 32-bit floating point                  | [-1, 1]                   |
+    | ma_format_s16 | 16-bit signed integer                  | [-32768, 32767]           |
+    | ma_format_s24 | 24-bit signed integer (tightly packed) | [-8388608, 8388607]       |
+    | ma_format_s32 | 32-bit signed integer                  | [-2147483648, 2147483647] |
+    | ma_format_u8  | 8-bit unsigned integer                 | [0, 255]                  |
+    +---------------+----------------------------------------+---------------------------+
+
+The `config.playback.channels` member sets the number of channels to use with the device. The
+channel count cannot exceed MA_MAX_CHANNELS. The `config.sampleRate` member sets the sample rate
+(which must be the same for both playback and capture in full-duplex configurations). This is
+usually set to 44100 or 48000, but can be set to anything. It's recommended to keep this between
+8000 and 384000, however.
+
+Note that leaving the format, channel count and/or sample rate at their default values will result
+in the internal device's native configuration being used which is useful if you want to avoid the
+overhead of miniaudio's automatic data conversion.
+
+In addition to the sample format, channel count and sample rate, the data callback and user data
+pointer are also set via the config. The user data pointer is not passed into the callback as a
+parameter, but is instead set to the `pUserData` member of `ma_device` which you can access
+directly since all miniaudio structures are transparent.
+
+Initializing the device is done with `ma_device_init()`. This will return a result code telling you
+what went wrong, if anything. On success it will return `MA_SUCCESS`. After initialization is
+complete the device will be in a stopped state. To start it, use `ma_device_start()`.
+Uninitializing the device will stop it, which is what the example above does, but you can also stop
+the device with `ma_device_stop()`. To resume the device simply call `ma_device_start()` again.
+Note that it's important to never stop or start the device from inside the callback. This will
+result in a deadlock. Instead you set a variable or signal an event indicating that the device
+needs to stop and handle it in a different thread. The following APIs must never be called inside
+the callback:
+
+    ```c
+    ma_device_init()
+    ma_device_init_ex()
+    ma_device_uninit()
+    ma_device_start()
+    ma_device_stop()
+    ```
+
+You must never try uninitializing and reinitializing a device inside the callback. You must also
+never try to stop and start it from inside the callback. There are a few other things you shouldn't
+do in the callback depending on your requirements, however this isn't so much a thread-safety
+thing, but rather a real-time processing thing which is beyond the scope of this introduction.
+
+The example above demonstrates the initialization of a playback device, but it works exactly the
+same for capture. All you need to do is change the device type from `ma_device_type_playback` to
+`ma_device_type_capture` when setting up the config, like so:
+
+    ```c
+    ma_device_config config = ma_device_config_init(ma_device_type_capture);
+    config.capture.format   = MY_FORMAT;
+    config.capture.channels = MY_CHANNEL_COUNT;
+    ```
+
+In the data callback you just read from the input buffer (`pInput` in the example above) and leave
+the output buffer alone (it will be set to NULL when the device type is set to
+`ma_device_type_capture`).
+
+These are the available device types and how you should handle the buffers in the callback:
+
+    +-------------------------+--------------------------------------------------------+
+    | Device Type             | Callback Behavior                                      |
+    +-------------------------+--------------------------------------------------------+
+    | ma_device_type_playback | Write to output buffer, leave input buffer untouched.  |
+    | ma_device_type_capture  | Read from input buffer, leave output buffer untouched. |
+    | ma_device_type_duplex   | Read from input buffer, write to output buffer.        |
+    | ma_device_type_loopback | Read from input buffer, leave output buffer untouched. |
+    +-------------------------+--------------------------------------------------------+
+
+You will notice in the example above that the sample format and channel count is specified
+separately for playback and capture. This is to support different data formats between the playback
+and capture devices in a full-duplex system. An example may be that you want to capture audio data
+as a monaural stream (one channel), but output sound to a stereo speaker system. Note that if you
+use different formats between playback and capture in a full-duplex configuration you will need to
+convert the data yourself. There are functions available to help you do this which will be
+explained later.
+
+The example above did not specify a physical device to connect to which means it will use the
+operating system's default device. If you have multiple physical devices connected and you want to
+use a specific one you will need to specify the device ID in the configuration, like so:
+
+    ```c
+    config.playback.pDeviceID = pMyPlaybackDeviceID;    // Only if requesting a playback or duplex device.
+    config.capture.pDeviceID = pMyCaptureDeviceID;      // Only if requesting a capture, duplex or loopback device.
+    ```
+
+To retrieve the device ID you will need to perform device enumeration, however this requires the
+use of a new concept called the "context". Conceptually speaking the context sits above the device.
+There is one context to many devices. The purpose of the context is to represent the backend at a
+more global level and to perform operations outside the scope of an individual device. Mainly it is
+used for performing run-time linking against backend libraries, initializing backends and
+enumerating devices. The example below shows how to enumerate devices.
+
+    ```c
+    ma_context context;
+    if (ma_context_init(NULL, 0, NULL, &context) != MA_SUCCESS) {
+        // Error.
+    }
+
+    ma_device_info* pPlaybackInfos;
+    ma_uint32 playbackCount;
+    ma_device_info* pCaptureInfos;
+    ma_uint32 captureCount;
+    if (ma_context_get_devices(&context, &pPlaybackInfos, &playbackCount, &pCaptureInfos, &captureCount) != MA_SUCCESS) {
+        // Error.
+    }
+
+    // Loop over each device info and do something with it. Here we just print the name with their index. You may want
+    // to give the user the opportunity to choose which device they'd prefer.
+    for (ma_uint32 iDevice = 0; iDevice < playbackCount; iDevice += 1) {
+        printf("%d - %s\n", iDevice, pPlaybackInfos[iDevice].name);
+    }
+
+    ma_device_config config = ma_device_config_init(ma_device_type_playback);
+    config.playback.pDeviceID = &pPlaybackInfos[chosenPlaybackDeviceIndex].id;
+    config.playback.format    = MY_FORMAT;
+    config.playback.channels  = MY_CHANNEL_COUNT;
+    config.sampleRate         = MY_SAMPLE_RATE;
+    config.dataCallback       = data_callback;
+    config.pUserData          = pMyCustomData;
+
+    ma_device device;
+    if (ma_device_init(&context, &config, &device) != MA_SUCCESS) {
+        // Error
+    }
+
+    ...
+
+    ma_device_uninit(&device);
+    ma_context_uninit(&context);
+    ```
+
+The first thing we do in this example is initialize a `ma_context` object with `ma_context_init()`.
+The first parameter is a pointer to a list of `ma_backend` values which are used to override the
+default backend priorities. When this is NULL, as in this example, miniaudio's default priorities
+are used. The second parameter is the number of backends listed in the array pointed to by the
+first parameter. The third parameter is a pointer to a `ma_context_config` object which can be
+NULL, in which case defaults are used. The context configuration is used for setting the logging
+callback, custom memory allocation callbacks, user-defined data and some backend-specific
+configurations.
+
+Once the context has been initialized you can enumerate devices. In the example above we use the
+simpler `ma_context_get_devices()`, however you can also use a callback for handling devices by
+using `ma_context_enumerate_devices()`. When using `ma_context_get_devices()` you provide a pointer
+to a pointer that will, upon output, be set to a pointer to a buffer containing a list of
+`ma_device_info` structures. You also provide a pointer to an unsigned integer that will receive
+the number of items in the returned buffer. Do not free the returned buffers as their memory is
+managed internally by miniaudio.
+
+The `ma_device_info` structure contains an `id` member which is the ID you pass to the device
+config. It also contains the name of the device which is useful for presenting a list of devices
+to the user via the UI.
+
+When creating your own context you will want to pass it to `ma_device_init()` when initializing the
+device. Passing in NULL, like we do in the first example, will result in miniaudio creating the
+context for you, which you don't want to do since you've already created a context. Note that
+internally the context is only tracked by it's pointer which means you must not change the location
+of the `ma_context` object. If this is an issue, consider using `malloc()` to allocate memory for
+the context.
+
+
+1.2. High Level API
+-------------------
+The high level API consists of three main parts:
+
+  * Resource management for loading and streaming sounds.
+  * A node graph for advanced mixing and effect processing.
+  * A high level "engine" that wraps around the resource manager and node graph.
+
+The resource manager (`ma_resource_manager`) is used for loading sounds. It supports loading sounds
+fully into memory and also streaming. It will also deal with reference counting for you which
+avoids the same sound being loaded multiple times.
+
+The node graph is used for mixing and effect processing. The idea is that you connect a number of
+nodes into the graph by connecting each node's outputs to another node's inputs. Each node can
+implement it's own effect. By chaining nodes together, advanced mixing and effect processing can
+be achieved.
+
+The engine encapsulates both the resource manager and the node graph to create a simple, easy to
+use high level API. The resource manager and node graph APIs are covered in more later sections of
+this manual.
+
+The code below shows how you can initialize an engine using it's default configuration.
+
+    ```c
+    ma_result result;
+    ma_engine engine;
+
+    result = ma_engine_init(NULL, &engine);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to initialize the engine.
+    }
+    ```
+
+This creates an engine instance which will initialize a device internally which you can access with
+`ma_engine_get_device()`. It will also initialize a resource manager for you which can be accessed
+with `ma_engine_get_resource_manager()`. The engine itself is a node graph (`ma_node_graph`) which
+means you can pass a pointer to the engine object into any of the `ma_node_graph` APIs (with a
+cast). Alternatively, you can use `ma_engine_get_node_graph()` instead of a cast.
+
+Note that all objects in miniaudio, including the `ma_engine` object in the example above, are
+transparent structures. There are no handles to opaque structures in miniaudio which means you need
+to be mindful of how you declare them. In the example above we are declaring it on the stack, but
+this will result in the struct being invalidated once the function encapsulating it returns. If
+allocating the engine on the heap is more appropriate, you can easily do so with a standard call
+to `malloc()` or whatever heap allocation routine you like:
+
+    ```c
+    ma_engine* pEngine = malloc(sizeof(*pEngine));
+    ```
+
+The `ma_engine` API uses the same config/init pattern used all throughout miniaudio. To configure
+an engine, you can fill out a `ma_engine_config` object and pass it into the first parameter of
+`ma_engine_init()`:
+
+    ```c
+    ma_result result;
+    ma_engine engine;
+    ma_engine_config engineConfig;
+
+    engineConfig = ma_engine_config_init();
+    engineConfig.pResourceManager = &myCustomResourceManager;   // <-- Initialized as some earlier stage.
+
+    result = ma_engine_init(&engineConfig, &engine);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+    ```
+
+This creates an engine instance using a custom config. In this particular example it's showing how
+you can specify a custom resource manager rather than having the engine initialize one internally.
+This is particularly useful if you want to have multiple engine's share the same resource manager.
+
+The engine must be uninitialized with `ma_engine_uninit()` when it's no longer needed.
+
+By default the engine will be started, but nothing will be playing because no sounds have been
+initialized. The easiest but least flexible way of playing a sound is like so:
+
+    ```c
+    ma_engine_play_sound(&engine, "my_sound.wav", NULL);
+    ```
+
+This plays what miniaudio calls an "inline" sound. It plays the sound once, and then puts the
+internal sound up for recycling. The last parameter is used to specify which sound group the sound
+should be associated with which will be explained later. This particular way of playing a sound is
+simple, but lacks flexibility and features. A more flexible way of playing a sound is to first
+initialize a sound:
+
+    ```c
+    ma_result result;
+    ma_sound sound;
+
+    result = ma_sound_init_from_file(&engine, "my_sound.wav", 0, NULL, NULL, &sound);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    ma_sound_start(&sound);
+    ```
+
+This returns a `ma_sound` object which represents a single instance of the specified sound file. If
+you want to play the same file multiple times simultaneously, you need to create one sound for each
+instance.
+
+Sounds should be uninitialized with `ma_sound_uninit()`.
+
+Sounds are not started by default. Start a sound with `ma_sound_start()` and stop it with
+`ma_sound_stop()`. When a sound is stopped, it is not rewound to the start. Use
+`ma_sound_seek_to_pcm_frame(&sound, 0)` to seek back to the start of a sound. By default, starting
+and stopping sounds happens immediately, but sometimes it might be convenient to schedule the sound
+the be started and/or stopped at a specific time. This can be done with the following functions:
+
+    ```c
+    ma_sound_set_start_time_in_pcm_frames()
+    ma_sound_set_start_time_in_milliseconds()
+    ma_sound_set_stop_time_in_pcm_frames()
+    ma_sound_set_stop_time_in_milliseconds()
+    ```
+
+The start/stop time needs to be specified based on the absolute timer which is controlled by the
+engine. The current global time time in PCM frames can be retrieved with
+`ma_engine_get_time_in_pcm_frames()`. The engine's global time can be changed with
+`ma_engine_set_time_in_pcm_frames()` for synchronization purposes if required. Note that scheduling
+a start time still requires an explicit call to `ma_sound_start()` before anything will play:
+
+    ```c
+    ma_sound_set_start_time_in_pcm_frames(&sound, ma_engine_get_time_in_pcm_frames(&engine) + (ma_engine_get_sample_rate(&engine) * 2);
+    ma_sound_start(&sound);
+    ```
+
+The third parameter of `ma_sound_init_from_file()` is a set of flags that control how the sound be
+loaded and a few options on which features should be enabled for that sound. By default, the sound
+is synchronously loaded fully into memory straight from the file system without any kind of
+decoding. If you want to decode the sound before storing it in memory, you need to specify the
+`MA_SOUND_FLAG_DECODE` flag. This is useful if you want to incur the cost of decoding at an earlier
+stage, such as a loading stage. Without this option, decoding will happen dynamically at mixing
+time which might be too expensive on the audio thread.
+
+If you want to load the sound asynchronously, you can specify the `MA_SOUND_FLAG_ASYNC` flag. This
+will result in `ma_sound_init_from_file()` returning quickly, but the sound will not start playing
+until the sound has had some audio decoded.
+
+The fourth parameter is a pointer to sound group. A sound group is used as a mechanism to organise
+sounds into groups which have their own effect processing and volume control. An example is a game
+which might have separate groups for sfx, voice and music. Each of these groups have their own
+independent volume control. Use `ma_sound_group_init()` or `ma_sound_group_init_ex()` to initialize
+a sound group.
+
+Sounds and sound groups are nodes in the engine's node graph and can be plugged into any `ma_node`
+API. This makes it possible to connect sounds and sound groups to effect nodes to produce complex
+effect chains.
+
+A sound can have it's volume changed with `ma_sound_set_volume()`. If you prefer decibel volume
+control you can use `ma_volume_db_to_linear()` to convert from decibel representation to linear.
+
+Panning and pitching is supported with `ma_sound_set_pan()` and `ma_sound_set_pitch()`. If you know
+a sound will never have it's pitch changed with `ma_sound_set_pitch()` or via the doppler effect,
+you can specify the `MA_SOUND_FLAG_NO_PITCH` flag when initializing the sound for an optimization.
+
+By default, sounds and sound groups have spatialization enabled. If you don't ever want to
+spatialize your sounds, initialize the sound with the `MA_SOUND_FLAG_NO_SPATIALIZATION` flag. The
+spatialization model is fairly simple and is roughly on feature parity with OpenAL. HRTF and
+environmental occlusion are not currently supported, but planned for the future. The supported
+features include:
+
+  * Sound and listener positioning and orientation with cones
+  * Attenuation models: none, inverse, linear and exponential
+  * Doppler effect
+
+Sounds can be faded in and out with `ma_sound_set_fade_in_pcm_frames()`.
+
+To check if a sound is currently playing, you can use `ma_sound_is_playing()`. To check if a sound
+is at the end, use `ma_sound_at_end()`. Looping of a sound can be controlled with
+`ma_sound_set_looping()`. Use `ma_sound_is_looping()` to check whether or not the sound is looping.
+
+
+
+2. Building
+===========
+miniaudio should work cleanly out of the box without the need to download or install any
+dependencies. See below for platform-specific details.
+
+Note that GCC and Clang require `-msse2`, `-mavx2`, etc. for SIMD optimizations.
+
+If you get errors about undefined references to `__sync_val_compare_and_swap_8`, `__atomic_load_8`,
+etc. you need to link with `-latomic`.
+
+
+2.1. Windows
+------------
+The Windows build should compile cleanly on all popular compilers without the need to configure any
+include paths nor link to any libraries.
+
+The UWP build may require linking to mmdevapi.lib if you get errors about an unresolved external
+symbol for `ActivateAudioInterfaceAsync()`.
+
+
+2.2. macOS and iOS
+------------------
+The macOS build should compile cleanly without the need to download any dependencies nor link to
+any libraries or frameworks. The iOS build needs to be compiled as Objective-C and will need to
+link the relevant frameworks but should compile cleanly out of the box with Xcode. Compiling
+through the command line requires linking to `-lpthread` and `-lm`.
+
+Due to the way miniaudio links to frameworks at runtime, your application may not pass Apple's
+notarization process. To fix this there are two options. The first is to use the
+`MA_NO_RUNTIME_LINKING` option, like so:
+
+    ```c
+    #ifdef __APPLE__
+        #define MA_NO_RUNTIME_LINKING
+    #endif
+    #define MINIAUDIO_IMPLEMENTATION
+    #include "miniaudio.h"
+    ```
+
+This will require linking with `-framework CoreFoundation -framework CoreAudio -framework AudioToolbox`.
+If you get errors about AudioToolbox, try with `-framework AudioUnit` instead. You may get this when
+using older versions of iOS. Alternatively, if you would rather keep using runtime linking you can
+add the following to your entitlements.xcent file:
+
+    ```
+    <key>com.apple.security.cs.allow-dyld-environment-variables</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    ```
+
+See this discussion for more info: https://github.com/mackron/miniaudio/issues/203.
+
+
+2.3. Linux
+----------
+The Linux build only requires linking to `-ldl`, `-lpthread` and `-lm`. You do not need any
+development packages. You may need to link with `-latomic` if you're compiling for 32-bit ARM.
+
+
+2.4. BSD
+--------
+The BSD build only requires linking to `-lpthread` and `-lm`. NetBSD uses audio(4), OpenBSD uses
+sndio and FreeBSD uses OSS. You may need to link with `-latomic` if you're compiling for 32-bit
+ARM.
+
+
+2.5. Android
+------------
+AAudio is the highest priority backend on Android. This should work out of the box without needing
+any kind of compiler configuration. Support for AAudio starts with Android 8 which means older
+versions will fall back to OpenSL|ES which requires API level 16+.
+
+There have been reports that the OpenSL|ES backend fails to initialize on some Android based
+devices due to `dlopen()` failing to open "libOpenSLES.so". If this happens on your platform
+you'll need to disable run-time linking with `MA_NO_RUNTIME_LINKING` and link with -lOpenSLES.
+
+
+2.6. Emscripten
+---------------
+The Emscripten build emits Web Audio JavaScript directly and should compile cleanly out of the box.
+You cannot use `-std=c*` compiler flags, nor `-ansi`.
+
+You can enable the use of AudioWorkets by defining `MA_ENABLE_AUDIO_WORKLETS` and then compiling
+with the following options:
+
+    -sAUDIO_WORKLET=1 -sWASM_WORKERS=1 -sASYNCIFY
+
+An example for compiling with AudioWorklet support might look like this:
+
+    emcc program.c -o bin/program.html -DMA_ENABLE_AUDIO_WORKLETS -sAUDIO_WORKLET=1 -sWASM_WORKERS=1 -sASYNCIFY
+
+To run locally, you'll need to use emrun:
+
+    emrun bin/program.html
+
+
+
+2.7. Build Options
+------------------
+`#define` these options before including miniaudio.h.
+
+    +----------------------------------+--------------------------------------------------------------------+
+    | Option                           | Description                                                        |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_WASAPI                     | Disables the WASAPI backend.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_DSOUND                     | Disables the DirectSound backend.                                  |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_WINMM                      | Disables the WinMM backend.                                        |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_ALSA                       | Disables the ALSA backend.                                         |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_PULSEAUDIO                 | Disables the PulseAudio backend.                                   |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_JACK                       | Disables the JACK backend.                                         |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_COREAUDIO                  | Disables the Core Audio backend.                                   |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_SNDIO                      | Disables the sndio backend.                                        |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_AUDIO4                     | Disables the audio(4) backend.                                     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_OSS                        | Disables the OSS backend.                                          |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_AAUDIO                     | Disables the AAudio backend.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_OPENSL                     | Disables the OpenSL|ES backend.                                    |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_WEBAUDIO                   | Disables the Web Audio backend.                                    |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_NULL                       | Disables the null backend.                                         |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_ONLY_SPECIFIC_BACKENDS | Disables all backends by default and requires `MA_ENABLE_*` to     |
+    |                                  | enable specific backends.                                          |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_WASAPI                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the WASAPI backend.                                         |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_DSOUND                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the DirectSound backend.                                    |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_WINMM                  | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the WinMM backend.                                          |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_ALSA                   | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the ALSA backend.                                           |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_PULSEAUDIO             | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the PulseAudio backend.                                     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_JACK                   | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the JACK backend.                                           |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_COREAUDIO              | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the Core Audio backend.                                     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_SNDIO                  | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the sndio backend.                                          |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_AUDIO4                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the audio(4) backend.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_OSS                    | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the OSS backend.                                            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_AAUDIO                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the AAudio backend.                                         |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_OPENSL                 | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the OpenSL|ES backend.                                      |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_WEBAUDIO               | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the Web Audio backend.                                      |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_ENABLE_NULL                   | Used in conjunction with MA_ENABLE_ONLY_SPECIFIC_BACKENDS to       |
+    |                                  | enable the null backend.                                           |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_DECODING                   | Disables decoding APIs.                                            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_ENCODING                   | Disables encoding APIs.                                            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_WAV                        | Disables the built-in WAV decoder and encoder.                     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_FLAC                       | Disables the built-in FLAC decoder.                                |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_MP3                        | Disables the built-in MP3 decoder.                                 |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_DEVICE_IO                  | Disables playback and recording. This will disable `ma_context`    |
+    |                                  | and `ma_device` APIs. This is useful if you only want to use       |
+    |                                  | miniaudio's data conversion and/or decoding APIs.                  |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_RESOURCE_MANAGER           | Disables the resource manager. When using the engine this will     |
+    |                                  | also disable the following functions:                              |
+    |                                  |                                                                    |
+    |                                  | ```                                                                |
+    |                                  | ma_sound_init_from_file()                                          |
+    |                                  | ma_sound_init_from_file_w()                                        |
+    |                                  | ma_sound_init_copy()                                               |
+    |                                  | ma_engine_play_sound_ex()                                          |
+    |                                  | ma_engine_play_sound()                                             |
+    |                                  | ```                                                                |
+    |                                  |                                                                    |
+    |                                  | The only way to initialize a `ma_sound` object is to initialize it |
+    |                                  | from a data source.                                                |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_NODE_GRAPH                 | Disables the node graph API. This will also disable the engine API |
+    |                                  | because it depends on the node graph.                              |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_ENGINE                     | Disables the engine API.                                           |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_THREADING                  | Disables the `ma_thread`, `ma_mutex`, `ma_semaphore` and           |
+    |                                  | `ma_event` APIs. This option is useful if you only need to use     |
+    |                                  | miniaudio for data conversion, decoding and/or encoding. Some      |
+    |                                  | families of APIs require threading which means the following       |
+    |                                  | options must also be set:                                          |
+    |                                  |                                                                    |
+    |                                  |     ```                                                            |
+    |                                  |     MA_NO_DEVICE_IO                                                |
+    |                                  |     ```                                                            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_GENERATION                 | Disables generation APIs such a `ma_waveform` and `ma_noise`.      |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_SSE2                       | Disables SSE2 optimizations.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_AVX2                       | Disables AVX2 optimizations.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_NEON                       | Disables NEON optimizations.                                       |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_NO_RUNTIME_LINKING            | Disables runtime linking. This is useful for passing Apple's       |
+    |                                  | notarization process. When enabling this, you may need to avoid    |
+    |                                  | using `-std=c89` or `-std=c99` on Linux builds or else you may end |
+    |                                  | up with compilation errors due to conflicts with `timespec` and    |
+    |                                  | `timeval` data types.                                              |
+    |                                  |                                                                    |
+    |                                  | You may need to enable this if your target platform does not allow |
+    |                                  | runtime linking via `dlopen()`.                                    |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_DEBUG_OUTPUT                  | Enable `printf()` output of debug logs (`MA_LOG_LEVEL_DEBUG`).     |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_COINIT_VALUE                  | Windows only. The value to pass to internal calls to               |
+    |                                  | `CoInitializeEx()`. Defaults to `COINIT_MULTITHREADED`.            |
+    +----------------------------------+--------------------------------------------------------------------+
+    | MA_API                           | Controls how public APIs should be decorated. Default is `extern`. |
+    +----------------------------------+--------------------------------------------------------------------+
+
+
+3. Definitions
+==============
+This section defines common terms used throughout miniaudio. Unfortunately there is often ambiguity
+in the use of terms throughout the audio space, so this section is intended to clarify how miniaudio
+uses each term.
+
+3.1. Sample
+-----------
+A sample is a single unit of audio data. If the sample format is f32, then one sample is one 32-bit
+floating point number.
+
+3.2. Frame / PCM Frame
+----------------------
+A frame is a group of samples equal to the number of channels. For a stereo stream a frame is 2
+samples, a mono frame is 1 sample, a 5.1 surround sound frame is 6 samples, etc. The terms "frame"
+and "PCM frame" are the same thing in miniaudio. Note that this is different to a compressed frame.
+If ever miniaudio needs to refer to a compressed frame, such as a FLAC frame, it will always
+clarify what it's referring to with something like "FLAC frame".
+
+3.3. Channel
+------------
+A stream of monaural audio that is emitted from an individual speaker in a speaker system, or
+received from an individual microphone in a microphone system. A stereo stream has two channels (a
+left channel, and a right channel), a 5.1 surround sound system has 6 channels, etc. Some audio
+systems refer to a channel as a complex audio stream that's mixed with other channels to produce
+the final mix - this is completely different to miniaudio's use of the term "channel" and should
+not be confused.
+
+3.4. Sample Rate
+----------------
+The sample rate in miniaudio is always expressed in Hz, such as 44100, 48000, etc. It's the number
+of PCM frames that are processed per second.
+
+3.5. Formats
+------------
+Throughout miniaudio you will see references to different sample formats:
+
+    +---------------+----------------------------------------+---------------------------+
+    | Symbol        | Description                            | Range                     |
+    +---------------+----------------------------------------+---------------------------+
+    | ma_format_f32 | 32-bit floating point                  | [-1, 1]                   |
+    | ma_format_s16 | 16-bit signed integer                  | [-32768, 32767]           |
+    | ma_format_s24 | 24-bit signed integer (tightly packed) | [-8388608, 8388607]       |
+    | ma_format_s32 | 32-bit signed integer                  | [-2147483648, 2147483647] |
+    | ma_format_u8  | 8-bit unsigned integer                 | [0, 255]                  |
+    +---------------+----------------------------------------+---------------------------+
+
+All formats are native-endian.
+
+
+
+4. Data Sources
+===============
+The data source abstraction in miniaudio is used for retrieving audio data from some source. A few
+examples include `ma_decoder`, `ma_noise` and `ma_waveform`. You will need to be familiar with data
+sources in order to make sense of some of the higher level concepts in miniaudio.
+
+The `ma_data_source` API is a generic interface for reading from a data source. Any object that
+implements the data source interface can be plugged into any `ma_data_source` function.
+
+To read data from a data source:
+
+    ```c
+    ma_result result;
+    ma_uint64 framesRead;
+
+    result = ma_data_source_read_pcm_frames(pDataSource, pFramesOut, frameCount, &framesRead);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to read data from the data source.
+    }
+    ```
+
+If you don't need the number of frames that were successfully read you can pass in `NULL` to the
+`pFramesRead` parameter. If this returns a value less than the number of frames requested it means
+the end of the file has been reached. `MA_AT_END` will be returned only when the number of frames
+read is 0.
+
+When calling any data source function, with the exception of `ma_data_source_init()` and
+`ma_data_source_uninit()`, you can pass in any object that implements a data source. For example,
+you could plug in a decoder like so:
+
+    ```c
+    ma_result result;
+    ma_uint64 framesRead;
+    ma_decoder decoder;   // <-- This would be initialized with `ma_decoder_init_*()`.
+
+    result = ma_data_source_read_pcm_frames(&decoder, pFramesOut, frameCount, &framesRead);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to read data from the decoder.
+    }
+    ```
+
+If you want to seek forward you can pass in `NULL` to the `pFramesOut` parameter. Alternatively you
+can use `ma_data_source_seek_pcm_frames()`.
+
+To seek to a specific PCM frame:
+
+    ```c
+    result = ma_data_source_seek_to_pcm_frame(pDataSource, frameIndex);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to seek to PCM frame.
+    }
+    ```
+
+You can retrieve the total length of a data source in PCM frames, but note that some data sources
+may not have the notion of a length, such as noise and waveforms, and others may just not have a
+way of determining the length such as some decoders. To retrieve the length:
+
+    ```c
+    ma_uint64 length;
+
+    result = ma_data_source_get_length_in_pcm_frames(pDataSource, &length);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to retrieve the length.
+    }
+    ```
+
+Care should be taken when retrieving the length of a data source where the underlying decoder is
+pulling data from a data stream with an undefined length, such as internet radio or some kind of
+broadcast. If you do this, `ma_data_source_get_length_in_pcm_frames()` may never return.
+
+The current position of the cursor in PCM frames can also be retrieved:
+
+    ```c
+    ma_uint64 cursor;
+
+    result = ma_data_source_get_cursor_in_pcm_frames(pDataSource, &cursor);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to retrieve the cursor.
+    }
+    ```
+
+You will often need to know the data format that will be returned after reading. This can be
+retrieved like so:
+
+    ```c
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_channel channelMap[MA_MAX_CHANNELS];
+
+    result = ma_data_source_get_data_format(pDataSource, &format, &channels, &sampleRate, channelMap, MA_MAX_CHANNELS);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to retrieve data format.
+    }
+    ```
+
+If you do not need a specific data format property, just pass in NULL to the respective parameter.
+
+There may be cases where you want to implement something like a sound bank where you only want to
+read data within a certain range of the underlying data. To do this you can use a range:
+
+    ```c
+    result = ma_data_source_set_range_in_pcm_frames(pDataSource, rangeBegInFrames, rangeEndInFrames);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to set the range.
+    }
+    ```
+
+This is useful if you have a sound bank where many sounds are stored in the same file and you want
+the data source to only play one of those sub-sounds. Note that once the range is set, everything
+that takes a position, such as cursors and loop points, should always be relatvie to the start of
+the range. When the range is set, any previously defined loop point will be reset.
+
+Custom loop points can also be used with data sources. By default, data sources will loop after
+they reach the end of the data source, but if you need to loop at a specific location, you can do
+the following:
+
+    ```c
+    result = ma_data_set_loop_point_in_pcm_frames(pDataSource, loopBegInFrames, loopEndInFrames);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to set the loop point.
+    }
+    ```
+
+The loop point is relative to the current range.
+
+It's sometimes useful to chain data sources together so that a seamless transition can be achieved.
+To do this, you can use chaining:
+
+    ```c
+    ma_decoder decoder1;
+    ma_decoder decoder2;
+
+    // ... initialize decoders with ma_decoder_init_*() ...
+
+    result = ma_data_source_set_next(&decoder1, &decoder2);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to set the next data source.
+    }
+
+    result = ma_data_source_read_pcm_frames(&decoder1, pFramesOut, frameCount, pFramesRead);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to read from the decoder.
+    }
+    ```
+
+In the example above we're using decoders. When reading from a chain, you always want to read from
+the top level data source in the chain. In the example above, `decoder1` is the top level data
+source in the chain. When `decoder1` reaches the end, `decoder2` will start seamlessly without any
+gaps.
+
+Note that when looping is enabled, only the current data source will be looped. You can loop the
+entire chain by linking in a loop like so:
+
+    ```c
+    ma_data_source_set_next(&decoder1, &decoder2);  // decoder1 -> decoder2
+    ma_data_source_set_next(&decoder2, &decoder1);  // decoder2 -> decoder1 (loop back to the start).
+    ```
+
+Note that setting up chaining is not thread safe, so care needs to be taken if you're dynamically
+changing links while the audio thread is in the middle of reading.
+
+Do not use `ma_decoder_seek_to_pcm_frame()` as a means to reuse a data source to play multiple
+instances of the same sound simultaneously. This can be extremely inefficient depending on the type
+of data source and can result in glitching due to subtle changes to the state of internal filters.
+Instead, initialize multiple data sources for each instance.
+
+
+4.1. Custom Data Sources
+------------------------
+You can implement a custom data source by implementing the functions in `ma_data_source_vtable`.
+Your custom object must have `ma_data_source_base` as it's first member:
+
+    ```c
+    struct my_data_source
+    {
+        ma_data_source_base base;
+        ...
+    };
+    ```
+
+In your initialization routine, you need to call `ma_data_source_init()` in order to set up the
+base object (`ma_data_source_base`):
+
+    ```c
+    static ma_result my_data_source_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+    {
+        // Read data here. Output in the same format returned by my_data_source_get_data_format().
+    }
+
+    static ma_result my_data_source_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+    {
+        // Seek to a specific PCM frame here. Return MA_NOT_IMPLEMENTED if seeking is not supported.
+    }
+
+    static ma_result my_data_source_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+    {
+        // Return the format of the data here.
+    }
+
+    static ma_result my_data_source_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+    {
+        // Retrieve the current position of the cursor here. Return MA_NOT_IMPLEMENTED and set *pCursor to 0 if there is no notion of a cursor.
+    }
+
+    static ma_result my_data_source_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+    {
+        // Retrieve the length in PCM frames here. Return MA_NOT_IMPLEMENTED and set *pLength to 0 if there is no notion of a length or if the length is unknown.
+    }
+
+    static ma_data_source_vtable g_my_data_source_vtable =
+    {
+        my_data_source_read,
+        my_data_source_seek,
+        my_data_source_get_data_format,
+        my_data_source_get_cursor,
+        my_data_source_get_length
+    };
+
+    ma_result my_data_source_init(my_data_source* pMyDataSource)
+    {
+        ma_result result;
+        ma_data_source_config baseConfig;
+
+        baseConfig = ma_data_source_config_init();
+        baseConfig.vtable = &g_my_data_source_vtable;
+
+        result = ma_data_source_init(&baseConfig, &pMyDataSource->base);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        // ... do the initialization of your custom data source here ...
+
+        return MA_SUCCESS;
+    }
+
+    void my_data_source_uninit(my_data_source* pMyDataSource)
+    {
+        // ... do the uninitialization of your custom data source here ...
+
+        // You must uninitialize the base data source.
+        ma_data_source_uninit(&pMyDataSource->base);
+    }
+    ```
+
+Note that `ma_data_source_init()` and `ma_data_source_uninit()` are never called directly outside
+of the custom data source. It's up to the custom data source itself to call these within their own
+init/uninit functions.
+
+
+
+5. Engine
+=========
+The `ma_engine` API is a high level API for managing and mixing sounds and effect processing. The
+`ma_engine` object encapsulates a resource manager and a node graph, both of which will be
+explained in more detail later.
+
+Sounds are called `ma_sound` and are created from an engine. Sounds can be associated with a mixing
+group called `ma_sound_group` which are also created from the engine. Both `ma_sound` and
+`ma_sound_group` objects are nodes within the engine's node graph.
+
+When the engine is initialized, it will normally create a device internally. If you would rather
+manage the device yourself, you can do so and just pass a pointer to it via the engine config when
+you initialize the engine. You can also just use the engine without a device, which again can be
+configured via the engine config.
+
+The most basic way to initialize the engine is with a default config, like so:
+
+    ```c
+    ma_result result;
+    ma_engine engine;
+
+    result = ma_engine_init(NULL, &engine);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to initialize the engine.
+    }
+    ```
+
+This will result in the engine initializing a playback device using the operating system's default
+device. This will be sufficient for many use cases, but if you need more flexibility you'll want to
+configure the engine with an engine config:
+
+    ```c
+    ma_result result;
+    ma_engine engine;
+    ma_engine_config engineConfig;
+
+    engineConfig = ma_engine_config_init();
+    engineConfig.pDevice = &myDevice;
+
+    result = ma_engine_init(&engineConfig, &engine);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to initialize the engine.
+    }
+    ```
+
+In the example above we're passing in a pre-initialized device. Since the caller is the one in
+control of the device's data callback, it's their responsibility to manually call
+`ma_engine_read_pcm_frames()` from inside their data callback:
+
+    ```c
+    void playback_data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
+    {
+        ma_engine_read_pcm_frames(&g_Engine, pOutput, frameCount, NULL);
+    }
+    ```
+
+You can also use the engine independent of a device entirely:
+
+    ```c
+    ma_result result;
+    ma_engine engine;
+    ma_engine_config engineConfig;
+
+    engineConfig = ma_engine_config_init();
+    engineConfig.noDevice   = MA_TRUE;
+    engineConfig.channels   = 2;        // Must be set when not using a device.
+    engineConfig.sampleRate = 48000;    // Must be set when not using a device.
+
+    result = ma_engine_init(&engineConfig, &engine);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to initialize the engine.
+    }
+    ```
+
+Note that when you're not using a device, you must set the channel count and sample rate in the
+config or else miniaudio won't know what to use (miniaudio will use the device to determine this
+normally). When not using a device, you need to use `ma_engine_read_pcm_frames()` to process audio
+data from the engine. This kind of setup is useful if you want to do something like offline
+processing or want to use a different audio system for playback such as SDL.
+
+When a sound is loaded it goes through a resource manager. By default the engine will initialize a
+resource manager internally, but you can also specify a pre-initialized resource manager:
+
+    ```c
+    ma_result result;
+    ma_engine engine1;
+    ma_engine engine2;
+    ma_engine_config engineConfig;
+
+    engineConfig = ma_engine_config_init();
+    engineConfig.pResourceManager = &myResourceManager;
+
+    ma_engine_init(&engineConfig, &engine1);
+    ma_engine_init(&engineConfig, &engine2);
+    ```
+
+In this example we are initializing two engines, both of which are sharing the same resource
+manager. This is especially useful for saving memory when loading the same file across multiple
+engines. If you were not to use a shared resource manager, each engine instance would use their own
+which would result in any sounds that are used between both engine's being loaded twice. By using
+a shared resource manager, it would only be loaded once. Using multiple engine's is useful when you
+need to output to multiple playback devices, such as in a local multiplayer game where each player
+is using their own set of headphones.
+
+By default an engine will be in a started state. To make it so the engine is not automatically
+started you can configure it as such:
+
+    ```c
+    engineConfig.noAutoStart = MA_TRUE;
+
+    // The engine will need to be started manually.
+    ma_engine_start(&engine);
+
+    // Later on the engine can be stopped with ma_engine_stop().
+    ma_engine_stop(&engine);
+    ```
+
+The concept of starting or stopping an engine is only relevant when using the engine with a
+device. Attempting to start or stop an engine that is not associated with a device will result in
+`MA_INVALID_OPERATION`.
+
+The master volume of the engine can be controlled with `ma_engine_set_volume()` which takes a
+linear scale, with 0 resulting in silence and anything above 1 resulting in amplification. If you
+prefer decibel based volume control, use `ma_volume_db_to_linear()` to convert from dB to linear.
+
+When a sound is spatialized, it is done so relative to a listener. An engine can be configured to
+have multiple listeners which can be configured via the config:
+
+    ```c
+    engineConfig.listenerCount = 2;
+    ```
+
+The maximum number of listeners is restricted to `MA_ENGINE_MAX_LISTENERS`. By default, when a
+sound is spatialized, it will be done so relative to the closest listener. You can also pin a sound
+to a specific listener which will be explained later. Listener's have a position, direction, cone,
+and velocity (for doppler effect). A listener is referenced by an index, the meaning of which is up
+to the caller (the index is 0 based and cannot go beyond the listener count, minus 1). The
+position, direction and velocity are all specified in absolute terms:
+
+    ```c
+    ma_engine_listener_set_position(&engine, listenerIndex, worldPosX, worldPosY, worldPosZ);
+    ```
+
+The direction of the listener represents it's forward vector. The listener's up vector can also be
+specified and defaults to +1 on the Y axis.
+
+    ```c
+    ma_engine_listener_set_direction(&engine, listenerIndex, forwardX, forwardY, forwardZ);
+    ma_engine_listener_set_world_up(&engine, listenerIndex, 0, 1, 0);
+    ```
+
+The engine supports directional attenuation. The listener can have a cone the controls how sound is
+attenuated based on the listener's direction. When a sound is between the inner and outer cones, it
+will be attenuated between 1 and the cone's outer gain:
+
+    ```c
+    ma_engine_listener_set_cone(&engine, listenerIndex, innerAngleInRadians, outerAngleInRadians, outerGain);
+    ```
+
+When a sound is inside the inner code, no directional attenuation is applied. When the sound is
+outside of the outer cone, the attenuation will be set to `outerGain` in the example above. When
+the sound is in between the inner and outer cones, the attenuation will be interpolated between 1
+and the outer gain.
+
+The engine's coordinate system follows the OpenGL coordinate system where positive X points right,
+positive Y points up and negative Z points forward.
+
+The simplest and least flexible way to play a sound is like so:
+
+    ```c
+    ma_engine_play_sound(&engine, "my_sound.wav", pGroup);
+    ```
+
+This is a "fire and forget" style of function. The engine will manage the `ma_sound` object
+internally. When the sound finishes playing, it'll be put up for recycling. For more flexibility
+you'll want to initialize a sound object:
+
+    ```c
+    ma_sound sound;
+
+    result = ma_sound_init_from_file(&engine, "my_sound.wav", flags, pGroup, NULL, &sound);
+    if (result != MA_SUCCESS) {
+        return result;  // Failed to load sound.
+    }
+    ```
+
+Sounds need to be uninitialized with `ma_sound_uninit()`.
+
+The example above loads a sound from a file. If the resource manager has been disabled you will not
+be able to use this function and instead you'll need to initialize a sound directly from a data
+source:
+
+    ```c
+    ma_sound sound;
+
+    result = ma_sound_init_from_data_source(&engine, &dataSource, flags, pGroup, &sound);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+    ```
+
+Each `ma_sound` object represents a single instance of the sound. If you want to play the same
+sound multiple times at the same time, you need to initialize a separate `ma_sound` object.
+
+For the most flexibility when initializing sounds, use `ma_sound_init_ex()`. This uses miniaudio's
+standard config/init pattern:
+
+    ```c
+    ma_sound sound;
+    ma_sound_config soundConfig;
+
+    soundConfig = ma_sound_config_init();
+    soundConfig.pFilePath   = NULL; // Set this to load from a file path.
+    soundConfig.pDataSource = NULL; // Set this to initialize from an existing data source.
+    soundConfig.pInitialAttachment = &someNodeInTheNodeGraph;
+    soundConfig.initialAttachmentInputBusIndex = 0;
+    soundConfig.channelsIn  = 1;
+    soundConfig.channelsOut = 0;    // Set to 0 to use the engine's native channel count.
+
+    result = ma_sound_init_ex(&soundConfig, &sound);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+    ```
+
+In the example above, the sound is being initialized without a file nor a data source. This is
+valid, in which case the sound acts as a node in the middle of the node graph. This means you can
+connect other sounds to this sound and allow it to act like a sound group. Indeed, this is exactly
+what a `ma_sound_group` is.
+
+When loading a sound, you specify a set of flags that control how the sound is loaded and what
+features are enabled for that sound. When no flags are set, the sound will be fully loaded into
+memory in exactly the same format as how it's stored on the file system. The resource manager will
+allocate a block of memory and then load the file directly into it. When reading audio data, it
+will be decoded dynamically on the fly. In order to save processing time on the audio thread, it
+might be beneficial to pre-decode the sound. You can do this with the `MA_SOUND_FLAG_DECODE` flag:
+
+    ```c
+    ma_sound_init_from_file(&engine, "my_sound.wav", MA_SOUND_FLAG_DECODE, pGroup, NULL, &sound);
+    ```
+
+By default, sounds will be loaded synchronously, meaning `ma_sound_init_*()` will not return until
+the sound has been fully loaded. If this is prohibitive you can instead load sounds asynchronously
+by specifying the `MA_SOUND_FLAG_ASYNC` flag:
+
+    ```c
+    ma_sound_init_from_file(&engine, "my_sound.wav", MA_SOUND_FLAG_DECODE | MA_SOUND_FLAG_ASYNC, pGroup, NULL, &sound);
+    ```
+
+This will result in `ma_sound_init_*()` returning quickly, but the sound won't yet have been fully
+loaded. When you start the sound, it won't output anything until some sound is available. The sound
+will start outputting audio before the sound has been fully decoded when the `MA_SOUND_FLAG_DECODE`
+is specified.
+
+If you need to wait for an asynchronously loaded sound to be fully loaded, you can use a fence. A
+fence in miniaudio is a simple synchronization mechanism which simply blocks until it's internal
+counter hit's zero. You can specify a fence like so:
+
+    ```c
+    ma_result result;
+    ma_fence fence;
+    ma_sound sounds[4];
+
+    result = ma_fence_init(&fence);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    // Load some sounds asynchronously.
+    for (int iSound = 0; iSound < 4; iSound += 1) {
+        ma_sound_init_from_file(&engine, mySoundFilesPaths[iSound], MA_SOUND_FLAG_DECODE | MA_SOUND_FLAG_ASYNC, pGroup, &fence, &sounds[iSound]);
+    }
+
+    // ... do some other stuff here in the mean time ...
+
+    // Wait for all sounds to finish loading.
+    ma_fence_wait(&fence);
+    ```
+
+If loading the entire sound into memory is prohibitive, you can also configure the engine to stream
+the audio data:
+
+    ```c
+    ma_sound_init_from_file(&engine, "my_sound.wav", MA_SOUND_FLAG_STREAM, pGroup, NULL, &sound);
+    ```
+
+When streaming sounds, 2 seconds worth of audio data is stored in memory. Although it should work
+fine, it's inefficient to use streaming for short sounds. Streaming is useful for things like music
+tracks in games.
+
+When loading a sound from a file path, the engine will reference count the file to prevent it from
+being loaded if it's already in memory. When you uninitialize a sound, the reference count will be
+decremented, and if it hits zero, the sound will be unloaded from memory. This reference counting
+system is not used for streams. The engine will use a 64-bit hash of the file name when comparing
+file paths which means there's a small chance you might encounter a name collision. If this is an
+issue, you'll need to use a different name for one of the colliding file paths, or just not load
+from files and instead load from a data source.
+
+You can use `ma_sound_init_copy()` to initialize a copy of another sound. Note, however, that this
+only works for sounds that were initialized with `ma_sound_init_from_file()` and without the
+`MA_SOUND_FLAG_STREAM` flag.
+
+When you initialize a sound, if you specify a sound group the sound will be attached to that group
+automatically. If you set it to NULL, it will be automatically attached to the engine's endpoint.
+If you would instead rather leave the sound unattached by default, you can can specify the
+`MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT` flag. This is useful if you want to set up a complex node
+graph.
+
+Sounds are not started by default. To start a sound, use `ma_sound_start()`. Stop a sound with
+`ma_sound_stop()`.
+
+Sounds can have their volume controlled with `ma_sound_set_volume()` in the same way as the
+engine's master volume.
+
+Sounds support stereo panning and pitching. Set the pan with `ma_sound_set_pan()`. Setting the pan
+to 0 will result in an unpanned sound. Setting it to -1 will shift everything to the left, whereas
++1 will shift it to the right. The pitch can be controlled with `ma_sound_set_pitch()`. A larger
+value will result in a higher pitch. The pitch must be greater than 0.
+
+The engine supports 3D spatialization of sounds. By default sounds will have spatialization
+enabled, but if a sound does not need to be spatialized it's best to disable it. There are two ways
+to disable spatialization of a sound:
+
+    ```c
+    // Disable spatialization at initialization time via a flag:
+    ma_sound_init_from_file(&engine, "my_sound.wav", MA_SOUND_FLAG_NO_SPATIALIZATION, NULL, NULL, &sound);
+
+    // Dynamically disable or enable spatialization post-initialization:
+    ma_sound_set_spatialization_enabled(&sound, isSpatializationEnabled);
+    ```
+
+By default sounds will be spatialized based on the closest listener. If a sound should always be
+spatialized relative to a specific listener it can be pinned to one:
+
+    ```c
+    ma_sound_set_pinned_listener_index(&sound, listenerIndex);
+    ```
+
+Like listeners, sounds have a position. By default, the position of a sound is in absolute space,
+but it can be changed to be relative to a listener:
+
+    ```c
+    ma_sound_set_positioning(&sound, ma_positioning_relative);
+    ```
+
+Note that relative positioning of a sound only makes sense if there is either only one listener, or
+the sound is pinned to a specific listener. To set the position of a sound:
+
+    ```c
+    ma_sound_set_position(&sound, posX, posY, posZ);
+    ```
+
+The direction works the same way as a listener and represents the sound's forward direction:
+
+    ```c
+    ma_sound_set_direction(&sound, forwardX, forwardY, forwardZ);
+    ```
+
+Sound's also have a cone for controlling directional attenuation. This works exactly the same as
+listeners:
+
+    ```c
+    ma_sound_set_cone(&sound, innerAngleInRadians, outerAngleInRadians, outerGain);
+    ```
+
+The velocity of a sound is used for doppler effect and can be set as such:
+
+    ```c
+    ma_sound_set_velocity(&sound, velocityX, velocityY, velocityZ);
+    ```
+
+The engine supports different attenuation models which can be configured on a per-sound basis. By
+default the attenuation model is set to `ma_attenuation_model_inverse` which is the equivalent to
+OpenAL's `AL_INVERSE_DISTANCE_CLAMPED`. Configure the attenuation model like so:
+
+    ```c
+    ma_sound_set_attenuation_model(&sound, ma_attenuation_model_inverse);
+    ```
+
+The supported attenuation models include the following:
+
+    +----------------------------------+----------------------------------------------+
+    | ma_attenuation_model_none        | No distance attenuation.                     |
+    +----------------------------------+----------------------------------------------+
+    | ma_attenuation_model_inverse     | Equivalent to `AL_INVERSE_DISTANCE_CLAMPED`. |
+    +----------------------------------+----------------------------------------------+
+    | ma_attenuation_model_linear      | Linear attenuation.                          |
+    +----------------------------------+----------------------------------------------+
+    | ma_attenuation_model_exponential | Exponential attenuation.                     |
+    +----------------------------------+----------------------------------------------+
+
+To control how quickly a sound rolls off as it moves away from the listener, you need to configure
+the rolloff:
+
+    ```c
+    ma_sound_set_rolloff(&sound, rolloff);
+    ```
+
+You can control the minimum and maximum gain to apply from spatialization:
+
+    ```c
+    ma_sound_set_min_gain(&sound, minGain);
+    ma_sound_set_max_gain(&sound, maxGain);
+    ```
+
+Likewise, in the calculation of attenuation, you can control the minimum and maximum distances for
+the attenuation calculation. This is useful if you want to ensure sounds don't drop below a certain
+volume after the listener moves further away and to have sounds play a maximum volume when the
+listener is within a certain distance:
+
+    ```c
+    ma_sound_set_min_distance(&sound, minDistance);
+    ma_sound_set_max_distance(&sound, maxDistance);
+    ```
+
+The engine's spatialization system supports doppler effect. The doppler factor can be configure on
+a per-sound basis like so:
+
+    ```c
+    ma_sound_set_doppler_factor(&sound, dopplerFactor);
+    ```
+
+You can fade sounds in and out with `ma_sound_set_fade_in_pcm_frames()` and
+`ma_sound_set_fade_in_milliseconds()`. Set the volume to -1 to use the current volume as the
+starting volume:
+
+    ```c
+    // Fade in over 1 second.
+    ma_sound_set_fade_in_milliseconds(&sound, 0, 1, 1000);
+
+    // ... sometime later ...
+
+    // Fade out over 1 second, starting from the current volume.
+    ma_sound_set_fade_in_milliseconds(&sound, -1, 0, 1000);
+    ```
+
+By default sounds will start immediately, but sometimes for timing and synchronization purposes it
+can be useful to schedule a sound to start or stop:
+
+    ```c
+    // Start the sound in 1 second from now.
+    ma_sound_set_start_time_in_pcm_frames(&sound, ma_engine_get_time_in_pcm_frames(&engine) + (ma_engine_get_sample_rate(&engine) * 1));
+
+    // Stop the sound in 2 seconds from now.
+    ma_sound_set_stop_time_in_pcm_frames(&sound, ma_engine_get_time_in_pcm_frames(&engine) + (ma_engine_get_sample_rate(&engine) * 2));
+    ```
+
+Note that scheduling a start time still requires an explicit call to `ma_sound_start()` before
+anything will play.
+
+The time is specified in global time which is controlled by the engine. You can get the engine's
+current time with `ma_engine_get_time_in_pcm_frames()`. The engine's global time is incremented
+automatically as audio data is read, but it can be reset with `ma_engine_set_time_in_pcm_frames()`
+in case it needs to be resynchronized for some reason.
+
+To determine whether or not a sound is currently playing, use `ma_sound_is_playing()`. This will
+take the scheduled start and stop times into account.
+
+Whether or not a sound should loop can be controlled with `ma_sound_set_looping()`. Sounds will not
+be looping by default. Use `ma_sound_is_looping()` to determine whether or not a sound is looping.
+
+Use `ma_sound_at_end()` to determine whether or not a sound is currently at the end. For a looping
+sound this should never return true. Alternatively, you can configure a callback that will be fired
+when the sound reaches the end. Note that the callback is fired from the audio thread which means
+you cannot be uninitializing sound from the callback. To set the callback you can use
+`ma_sound_set_end_callback()`. Alternatively, if you're using `ma_sound_init_ex()`, you can pass it
+into the config like so:
+
+    ```c
+    soundConfig.endCallback = my_end_callback;
+    soundConfig.pEndCallbackUserData = pMyEndCallbackUserData;
+    ```
+
+The end callback is declared like so:
+
+    ```c
+    void my_end_callback(void* pUserData, ma_sound* pSound)
+    {
+        ...
+    }
+    ```
+
+Internally a sound wraps around a data source. Some APIs exist to control the underlying data
+source, mainly for convenience:
+
+    ```c
+    ma_sound_seek_to_pcm_frame(&sound, frameIndex);
+    ma_sound_get_data_format(&sound, &format, &channels, &sampleRate, pChannelMap, channelMapCapacity);
+    ma_sound_get_cursor_in_pcm_frames(&sound, &cursor);
+    ma_sound_get_length_in_pcm_frames(&sound, &length);
+    ```
+
+Sound groups have the same API as sounds, only they are called `ma_sound_group`, and since they do
+not have any notion of a data source, anything relating to a data source is unavailable.
+
+Internally, sound data is loaded via the `ma_decoder` API which means by default it only supports
+file formats that have built-in support in miniaudio. You can extend this to support any kind of
+file format through the use of custom decoders. To do this you'll need to use a self-managed
+resource manager and configure it appropriately. See the "Resource Management" section below for
+details on how to set this up.
+
+
+6. Resource Management
+======================
+Many programs will want to manage sound resources for things such as reference counting and
+streaming. This is supported by miniaudio via the `ma_resource_manager` API.
+
+The resource manager is mainly responsible for the following:
+
+  * Loading of sound files into memory with reference counting.
+  * Streaming of sound data.
+
+When loading a sound file, the resource manager will give you back a `ma_data_source` compatible
+object called `ma_resource_manager_data_source`. This object can be passed into any
+`ma_data_source` API which is how you can read and seek audio data. When loading a sound file, you
+specify whether or not you want the sound to be fully loaded into memory (and optionally
+pre-decoded) or streamed. When loading into memory, you can also specify whether or not you want
+the data to be loaded asynchronously.
+
+The example below is how you can initialize a resource manager using it's default configuration:
+
+    ```c
+    ma_resource_manager_config config;
+    ma_resource_manager resourceManager;
+
+    config = ma_resource_manager_config_init();
+    result = ma_resource_manager_init(&config, &resourceManager);
+    if (result != MA_SUCCESS) {
+        ma_device_uninit(&device);
+        printf("Failed to initialize the resource manager.");
+        return -1;
+    }
+    ```
+
+You can configure the format, channels and sample rate of the decoded audio data. By default it
+will use the file's native data format, but you can configure it to use a consistent format. This
+is useful for offloading the cost of data conversion to load time rather than dynamically
+converting at mixing time. To do this, you configure the decoded format, channels and sample rate
+like the code below:
+
+    ```c
+    config = ma_resource_manager_config_init();
+    config.decodedFormat     = device.playback.format;
+    config.decodedChannels   = device.playback.channels;
+    config.decodedSampleRate = device.sampleRate;
+    ```
+
+In the code above, the resource manager will be configured so that any decoded audio data will be
+pre-converted at load time to the device's native data format. If instead you used defaults and
+the data format of the file did not match the device's data format, you would need to convert the
+data at mixing time which may be prohibitive in high-performance and large scale scenarios like
+games.
+
+Internally the resource manager uses the `ma_decoder` API to load sounds. This means by default it
+only supports decoders that are built into miniaudio. It's possible to support additional encoding
+formats through the use of custom decoders. To do so, pass in your `ma_decoding_backend_vtable`
+vtables into the resource manager config:
+
+    ```c
+    ma_decoding_backend_vtable* pCustomBackendVTables[] =
+    {
+        &g_ma_decoding_backend_vtable_libvorbis,
+        &g_ma_decoding_backend_vtable_libopus
+    };
+
+    ...
+
+    resourceManagerConfig.ppCustomDecodingBackendVTables = pCustomBackendVTables;
+    resourceManagerConfig.customDecodingBackendCount     = sizeof(pCustomBackendVTables) / sizeof(pCustomBackendVTables[0]);
+    resourceManagerConfig.pCustomDecodingBackendUserData = NULL;
+    ```
+
+This system can allow you to support any kind of file format. See the "Decoding" section for
+details on how to implement custom decoders. The miniaudio repository includes examples for Opus
+via libopus and libopusfile and Vorbis via libvorbis and libvorbisfile.
+
+Asynchronicity is achieved via a job system. When an operation needs to be performed, such as the
+decoding of a page, a job will be posted to a queue which will then be processed by a job thread.
+By default there will be only one job thread running, but this can be configured, like so:
+
+    ```c
+    config = ma_resource_manager_config_init();
+    config.jobThreadCount = MY_JOB_THREAD_COUNT;
+    ```
+
+By default job threads are managed internally by the resource manager, however you can also self
+manage your job threads if, for example, you want to integrate the job processing into your
+existing job infrastructure, or if you simply don't like the way the resource manager does it. To
+do this, just set the job thread count to 0 and process jobs manually. To process jobs, you first
+need to retrieve a job using `ma_resource_manager_next_job()` and then process it using
+`ma_job_process()`:
+
+    ```c
+    config = ma_resource_manager_config_init();
+    config.jobThreadCount = 0;                            // Don't manage any job threads internally.
+    config.flags = MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING; // Optional. Makes `ma_resource_manager_next_job()` non-blocking.
+
+    // ... Initialize your custom job threads ...
+
+    void my_custom_job_thread(...)
+    {
+        for (;;) {
+            ma_job job;
+            ma_result result = ma_resource_manager_next_job(pMyResourceManager, &job);
+            if (result != MA_SUCCESS) {
+                if (result == MA_NO_DATA_AVAILABLE) {
+                    // No jobs are available. Keep going. Will only get this if the resource manager was initialized
+                    // with MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING.
+                    continue;
+                } else if (result == MA_CANCELLED) {
+                    // MA_JOB_TYPE_QUIT was posted. Exit.
+                    break;
+                } else {
+                    // Some other error occurred.
+                    break;
+                }
+            }
+
+            ma_job_process(&job);
+        }
+    }
+    ```
+
+In the example above, the `MA_JOB_TYPE_QUIT` event is the used as the termination
+indicator, but you can use whatever you would like to terminate the thread. The call to
+`ma_resource_manager_next_job()` is blocking by default, but can be configured to be non-blocking
+by initializing the resource manager with the `MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING` configuration
+flag. Note that the `MA_JOB_TYPE_QUIT` will never be removed from the job queue. This
+is to give every thread the opportunity to catch the event and terminate naturally.
+
+When loading a file, it's sometimes convenient to be able to customize how files are opened and
+read instead of using standard `fopen()`, `fclose()`, etc. which is what miniaudio will use by
+default. This can be done by setting `pVFS` member of the resource manager's config:
+
+    ```c
+    // Initialize your custom VFS object. See documentation for VFS for information on how to do this.
+    my_custom_vfs vfs = my_custom_vfs_init();
+
+    config = ma_resource_manager_config_init();
+    config.pVFS = &vfs;
+    ```
+
+This is particularly useful in programs like games where you want to read straight from an archive
+rather than the normal file system. If you do not specify a custom VFS, the resource manager will
+use the operating system's normal file operations.
+
+To load a sound file and create a data source, call `ma_resource_manager_data_source_init()`. When
+loading a sound you need to specify the file path and options for how the sounds should be loaded.
+By default a sound will be loaded synchronously. The returned data source is owned by the caller
+which means the caller is responsible for the allocation and freeing of the data source. Below is
+an example for initializing a data source:
+
+    ```c
+    ma_resource_manager_data_source dataSource;
+    ma_result result = ma_resource_manager_data_source_init(pResourceManager, pFilePath, flags, &dataSource);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    // ...
+
+    // A ma_resource_manager_data_source object is compatible with the `ma_data_source` API. To read data, just call
+    // the `ma_data_source_read_pcm_frames()` like you would with any normal data source.
+    result = ma_data_source_read_pcm_frames(&dataSource, pDecodedData, frameCount, &framesRead);
+    if (result != MA_SUCCESS) {
+        // Failed to read PCM frames.
+    }
+
+    // ...
+
+    ma_resource_manager_data_source_uninit(&dataSource);
+    ```
+
+The `flags` parameter specifies how you want to perform loading of the sound file. It can be a
+combination of the following flags:
+
+    ```
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT
+    ```
+
+When no flags are specified (set to 0), the sound will be fully loaded into memory, but not
+decoded, meaning the raw file data will be stored in memory, and then dynamically decoded when
+`ma_data_source_read_pcm_frames()` is called. To instead decode the audio data before storing it in
+memory, use the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE` flag. By default, the sound file will
+be loaded synchronously, meaning `ma_resource_manager_data_source_init()` will only return after
+the entire file has been loaded. This is good for simplicity, but can be prohibitively slow. You
+can instead load the sound asynchronously using the `MA_RESOURCE_MANAGER_DATA_SOURCE_ASYNC` flag.
+This will result in `ma_resource_manager_data_source_init()` returning quickly, but no data will be
+returned by `ma_data_source_read_pcm_frames()` until some data is available. When no data is
+available because the asynchronous decoding hasn't caught up, `MA_BUSY` will be returned by
+`ma_data_source_read_pcm_frames()`.
+
+For large sounds, it's often prohibitive to store the entire file in memory. To mitigate this, you
+can instead stream audio data which you can do by specifying the
+`MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM` flag. When streaming, data will be decoded in 1
+second pages. When a new page needs to be decoded, a job will be posted to the job queue and then
+subsequently processed in a job thread.
+
+For in-memory sounds, reference counting is used to ensure the data is loaded only once. This means
+multiple calls to `ma_resource_manager_data_source_init()` with the same file path will result in
+the file data only being loaded once. Each call to `ma_resource_manager_data_source_init()` must be
+matched up with a call to `ma_resource_manager_data_source_uninit()`. Sometimes it can be useful
+for a program to register self-managed raw audio data and associate it with a file path. Use the
+`ma_resource_manager_register_*()` and `ma_resource_manager_unregister_*()` APIs to do this.
+`ma_resource_manager_register_decoded_data()` is used to associate a pointer to raw, self-managed
+decoded audio data in the specified data format with the specified name. Likewise,
+`ma_resource_manager_register_encoded_data()` is used to associate a pointer to raw self-managed
+encoded audio data (the raw file data) with the specified name. Note that these names need not be
+actual file paths. When `ma_resource_manager_data_source_init()` is called (without the
+`MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM` flag), the resource manager will look for these
+explicitly registered data buffers and, if found, will use it as the backing data for the data
+source. Note that the resource manager does *not* make a copy of this data so it is up to the
+caller to ensure the pointer stays valid for it's lifetime. Use
+`ma_resource_manager_unregister_data()` to unregister the self-managed data. You can also use
+`ma_resource_manager_register_file()` and `ma_resource_manager_unregister_file()` to register and
+unregister a file. It does not make sense to use the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM`
+flag with a self-managed data pointer.
+
+
+6.1. Asynchronous Loading and Synchronization
+---------------------------------------------
+When loading asynchronously, it can be useful to poll whether or not loading has finished. Use
+`ma_resource_manager_data_source_result()` to determine this. For in-memory sounds, this will
+return `MA_SUCCESS` when the file has been *entirely* decoded. If the sound is still being decoded,
+`MA_BUSY` will be returned. Otherwise, some other error code will be returned if the sound failed
+to load. For streaming data sources, `MA_SUCCESS` will be returned when the first page has been
+decoded and the sound is ready to be played. If the first page is still being decoded, `MA_BUSY`
+will be returned. Otherwise, some other error code will be returned if the sound failed to load.
+
+In addition to polling, you can also use a simple synchronization object called a "fence" to wait
+for asynchronously loaded sounds to finish. This is called `ma_fence`. The advantage to using a
+fence is that it can be used to wait for a group of sounds to finish loading rather than waiting
+for sounds on an individual basis. There are two stages to loading a sound:
+
+  * Initialization of the internal decoder; and
+  * Completion of decoding of the file (the file is fully decoded)
+
+You can specify separate fences for each of the different stages. Waiting for the initialization
+of the internal decoder is important for when you need to know the sample format, channels and
+sample rate of the file.
+
+The example below shows how you could use a fence when loading a number of sounds:
+
+    ```c
+    // This fence will be released when all sounds are finished loading entirely.
+    ma_fence fence;
+    ma_fence_init(&fence);
+
+    // This will be passed into the initialization routine for each sound.
+    ma_resource_manager_pipeline_notifications notifications = ma_resource_manager_pipeline_notifications_init();
+    notifications.done.pFence = &fence;
+
+    // Now load a bunch of sounds:
+    for (iSound = 0; iSound < soundCount; iSound += 1) {
+        ma_resource_manager_data_source_init(pResourceManager, pSoundFilePaths[iSound], flags, &notifications, &pSoundSources[iSound]);
+    }
+
+    // ... DO SOMETHING ELSE WHILE SOUNDS ARE LOADING ...
+
+    // Wait for loading of sounds to finish.
+    ma_fence_wait(&fence);
+    ```
+
+In the example above we used a fence for waiting until the entire file has been fully decoded. If
+you only need to wait for the initialization of the internal decoder to complete, you can use the
+`init` member of the `ma_resource_manager_pipeline_notifications` object:
+
+    ```c
+    notifications.init.pFence = &fence;
+    ```
+
+If a fence is not appropriate for your situation, you can instead use a callback that is fired on
+an individual sound basis. This is done in a very similar way to fences:
+
+    ```c
+    typedef struct
+    {
+        ma_async_notification_callbacks cb;
+        void* pMyData;
+    } my_notification;
+
+    void my_notification_callback(ma_async_notification* pNotification)
+    {
+        my_notification* pMyNotification = (my_notification*)pNotification;
+
+        // Do something in response to the sound finishing loading.
+    }
+
+    ...
+
+    my_notification myCallback;
+    myCallback.cb.onSignal = my_notification_callback;
+    myCallback.pMyData     = pMyData;
+
+    ma_resource_manager_pipeline_notifications notifications = ma_resource_manager_pipeline_notifications_init();
+    notifications.done.pNotification = &myCallback;
+
+    ma_resource_manager_data_source_init(pResourceManager, "my_sound.wav", flags, &notifications, &mySound);
+    ```
+
+In the example above we just extend the `ma_async_notification_callbacks` object and pass an
+instantiation into the `ma_resource_manager_pipeline_notifications` in the same way as we did with
+the fence, only we set `pNotification` instead of `pFence`. You can set both of these at the same
+time and they should both work as expected. If using the `pNotification` system, you need to ensure
+your `ma_async_notification_callbacks` object stays valid.
+
+
+
+6.2. Resource Manager Implementation Details
+--------------------------------------------
+Resources are managed in two main ways:
+
+  * By storing the entire sound inside an in-memory buffer (referred to as a data buffer)
+  * By streaming audio data on the fly (referred to as a data stream)
+
+A resource managed data source (`ma_resource_manager_data_source`) encapsulates a data buffer or
+data stream, depending on whether or not the data source was initialized with the
+`MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM` flag. If so, it will make use of a
+`ma_resource_manager_data_stream` object. Otherwise it will use a `ma_resource_manager_data_buffer`
+object. Both of these objects are data sources which means they can be used with any
+`ma_data_source_*()` API.
+
+Another major feature of the resource manager is the ability to asynchronously decode audio files.
+This relieves the audio thread of time-consuming decoding which can negatively affect scalability
+due to the audio thread needing to complete it's work extremely quickly to avoid glitching.
+Asynchronous decoding is achieved through a job system. There is a central multi-producer,
+multi-consumer, fixed-capacity job queue. When some asynchronous work needs to be done, a job is
+posted to the queue which is then read by a job thread. The number of job threads can be
+configured for improved scalability, and job threads can all run in parallel without needing to
+worry about the order of execution (how this is achieved is explained below).
+
+When a sound is being loaded asynchronously, playback can begin before the sound has been fully
+decoded. This enables the application to start playback of the sound quickly, while at the same
+time allowing to resource manager to keep loading in the background. Since there may be less
+threads than the number of sounds being loaded at a given time, a simple scheduling system is used
+to keep decoding time balanced and fair. The resource manager solves this by splitting decoding
+into chunks called pages. By default, each page is 1 second long. When a page has been decoded, a
+new job will be posted to start decoding the next page. By dividing up decoding into pages, an
+individual sound shouldn't ever delay every other sound from having their first page decoded. Of
+course, when loading many sounds at the same time, there will always be an amount of time required
+to process jobs in the queue so in heavy load situations there will still be some delay. To
+determine if a data source is ready to have some frames read, use
+`ma_resource_manager_data_source_get_available_frames()`. This will return the number of frames
+available starting from the current position.
+
+
+6.2.1. Job Queue
+----------------
+The resource manager uses a job queue which is multi-producer, multi-consumer, and fixed-capacity.
+This job queue is not currently lock-free, and instead uses a spinlock to achieve thread-safety.
+Only a fixed number of jobs can be allocated and inserted into the queue which is done through a
+lock-free data structure for allocating an index into a fixed sized array, with reference counting
+for mitigation of the ABA problem. The reference count is 32-bit.
+
+For many types of jobs it's important that they execute in a specific order. In these cases, jobs
+are executed serially. For the resource manager, serial execution of jobs is only required on a
+per-object basis (per data buffer or per data stream). Each of these objects stores an execution
+counter. When a job is posted it is associated with an execution counter. When the job is
+processed, it checks if the execution counter of the job equals the execution counter of the
+owning object and if so, processes the job. If the counters are not equal, the job will be posted
+back onto the job queue for later processing. When the job finishes processing the execution order
+of the main object is incremented. This system means the no matter how many job threads are
+executing, decoding of an individual sound will always get processed serially. The advantage to
+having multiple threads comes into play when loading multiple sounds at the same time.
+
+The resource manager's job queue is not 100% lock-free and will use a spinlock to achieve
+thread-safety for a very small section of code. This is only relevant when the resource manager
+uses more than one job thread. If only using a single job thread, which is the default, the
+lock should never actually wait in practice. The amount of time spent locking should be quite
+short, but it's something to be aware of for those who have pedantic lock-free requirements and
+need to use more than one job thread. There are plans to remove this lock in a future version.
+
+In addition, posting a job will release a semaphore, which on Win32 is implemented with
+`ReleaseSemaphore` and on POSIX platforms via a condition variable:
+
+    ```c
+    pthread_mutex_lock(&pSemaphore->lock);
+    {
+        pSemaphore->value += 1;
+        pthread_cond_signal(&pSemaphore->cond);
+    }
+    pthread_mutex_unlock(&pSemaphore->lock);
+    ```
+
+Again, this is relevant for those with strict lock-free requirements in the audio thread. To avoid
+this, you can use non-blocking mode (via the `MA_JOB_QUEUE_FLAG_NON_BLOCKING`
+flag) and implement your own job processing routine (see the "Resource Manager" section above for
+details on how to do this).
+
+
+
+6.2.2. Data Buffers
+-------------------
+When the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM` flag is excluded at initialization time, the
+resource manager will try to load the data into an in-memory data buffer. Before doing so, however,
+it will first check if the specified file is already loaded. If so, it will increment a reference
+counter and just use the already loaded data. This saves both time and memory. When the data buffer
+is uninitialized, the reference counter will be decremented. If the counter hits zero, the file
+will be unloaded. This is a detail to keep in mind because it could result in excessive loading and
+unloading of a sound. For example, the following sequence will result in a file be loaded twice,
+once after the other:
+
+    ```c
+    ma_resource_manager_data_source_init(pResourceManager, "my_file", ..., &myDataBuffer0); // Refcount = 1. Initial load.
+    ma_resource_manager_data_source_uninit(&myDataBuffer0);                                 // Refcount = 0. Unloaded.
+
+    ma_resource_manager_data_source_init(pResourceManager, "my_file", ..., &myDataBuffer1); // Refcount = 1. Reloaded because previous uninit() unloaded it.
+    ma_resource_manager_data_source_uninit(&myDataBuffer1);                                 // Refcount = 0. Unloaded.
+    ```
+
+A binary search tree (BST) is used for storing data buffers as it has good balance between
+efficiency and simplicity. The key of the BST is a 64-bit hash of the file path that was passed
+into `ma_resource_manager_data_source_init()`. The advantage of using a hash is that it saves
+memory over storing the entire path, has faster comparisons, and results in a mostly balanced BST
+due to the random nature of the hash. The disadvantages are that file names are case-sensitive and
+there's a small chance of name collisions. If case-sensitivity is an issue, you should normalize
+your file names to upper- or lower-case before initializing your data sources. If name collisions
+become an issue, you'll need to change the name of one of the colliding names or just not use the
+resource manager.
+
+When a sound file has not already been loaded and the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC`
+flag is excluded, the file will be decoded synchronously by the calling thread. There are two
+options for controlling how the audio is stored in the data buffer - encoded or decoded. When the
+`MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE` option is excluded, the raw file data will be stored
+in memory. Otherwise the sound will be decoded before storing it in memory. Synchronous loading is
+a very simple and standard process of simply adding an item to the BST, allocating a block of
+memory and then decoding (if `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE` is specified).
+
+When the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC` flag is specified, loading of the data buffer
+is done asynchronously. In this case, a job is posted to the queue to start loading and then the
+function immediately returns, setting an internal result code to `MA_BUSY`. This result code is
+returned when the program calls `ma_resource_manager_data_source_result()`. When decoding has fully
+completed `MA_SUCCESS` will be returned. This can be used to know if loading has fully completed.
+
+When loading asynchronously, a single job is posted to the queue of the type
+`MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE`. This involves making a copy of the file path and
+associating it with job. When the job is processed by the job thread, it will first load the file
+using the VFS associated with the resource manager. When using a custom VFS, it's important that it
+be completely thread-safe because it will be used from one or more job threads at the same time.
+Individual files should only ever be accessed by one thread at a time, however. After opening the
+file via the VFS, the job will determine whether or not the file is being decoded. If not, it
+simply allocates a block of memory and loads the raw file contents into it and returns. On the
+other hand, when the file is being decoded, it will first allocate a decoder on the heap and
+initialize it. Then it will check if the length of the file is known. If so it will allocate a
+block of memory to store the decoded output and initialize it to silence. If the size is unknown,
+it will allocate room for one page. After memory has been allocated, the first page will be
+decoded. If the sound is shorter than a page, the result code will be set to `MA_SUCCESS` and the
+completion event will be signalled and loading is now complete. If, however, there is more to
+decode, a job with the code `MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE` is posted. This job
+will decode the next page and perform the same process if it reaches the end. If there is more to
+decode, the job will post another `MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE` job which will
+keep on happening until the sound has been fully decoded. For sounds of an unknown length, each
+page will be linked together as a linked list. Internally this is implemented via the
+`ma_paged_audio_buffer` object.
+
+
+6.2.3. Data Streams
+-------------------
+Data streams only ever store two pages worth of data for each instance. They are most useful for
+large sounds like music tracks in games that would consume too much memory if fully decoded in
+memory. After every frame from a page has been read, a job will be posted to load the next page
+which is done from the VFS.
+
+For data streams, the `MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC` flag will determine whether or
+not initialization of the data source waits until the two pages have been decoded. When unset,
+`ma_resource_manager_data_source_init()` will wait until the two pages have been loaded, otherwise
+it will return immediately.
+
+When frames are read from a data stream using `ma_resource_manager_data_source_read_pcm_frames()`,
+`MA_BUSY` will be returned if there are no frames available. If there are some frames available,
+but less than the number requested, `MA_SUCCESS` will be returned, but the actual number of frames
+read will be less than the number requested. Due to the asynchronous nature of data streams,
+seeking is also asynchronous. If the data stream is in the middle of a seek, `MA_BUSY` will be
+returned when trying to read frames.
+
+When `ma_resource_manager_data_source_read_pcm_frames()` results in a page getting fully consumed
+a job is posted to load the next page. This will be posted from the same thread that called
+`ma_resource_manager_data_source_read_pcm_frames()`.
+
+Data streams are uninitialized by posting a job to the queue, but the function won't return until
+that job has been processed. The reason for this is that the caller owns the data stream object and
+therefore miniaudio needs to ensure everything completes before handing back control to the caller.
+Also, if the data stream is uninitialized while pages are in the middle of decoding, they must
+complete before destroying any underlying object and the job system handles this cleanly.
+
+Note that when a new page needs to be loaded, a job will be posted to the resource manager's job
+thread from the audio thread. You must keep in mind the details mentioned in the "Job Queue"
+section above regarding locking when posting an event if you require a strictly lock-free audio
+thread.
+
+
+
+7. Node Graph
+=============
+miniaudio's routing infrastructure follows a node graph paradigm. The idea is that you create a
+node whose outputs are attached to inputs of another node, thereby creating a graph. There are
+different types of nodes, with each node in the graph processing input data to produce output,
+which is then fed through the chain. Each node in the graph can apply their own custom effects. At
+the start of the graph will usually be one or more data source nodes which have no inputs and
+instead pull their data from a data source. At the end of the graph is an endpoint which represents
+the end of the chain and is where the final output is ultimately extracted from.
+
+Each node has a number of input buses and a number of output buses. An output bus from a node is
+attached to an input bus of another. Multiple nodes can connect their output buses to another
+node's input bus, in which case their outputs will be mixed before processing by the node. Below is
+a diagram that illustrates a hypothetical node graph setup:
+
+    ```
+    >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Data flows left to right >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+
+    +---------------+                              +-----------------+
+    | Data Source 1 =----+    +----------+    +----= Low Pass Filter =----+
+    +---------------+    |    |          =----+    +-----------------+    |    +----------+
+                         +----= Splitter |                                +----= ENDPOINT |
+    +---------------+    |    |          =----+    +-----------------+    |    +----------+
+    | Data Source 2 =----+    +----------+    +----=  Echo / Delay   =----+
+    +---------------+                              +-----------------+
+    ```
+
+In the above graph, it starts with two data sources whose outputs are attached to the input of a
+splitter node. It's at this point that the two data sources are mixed. After mixing, the splitter
+performs it's processing routine and produces two outputs which is simply a duplication of the
+input stream. One output is attached to a low pass filter, whereas the other output is attached to
+a echo/delay. The outputs of the the low pass filter and the echo are attached to the endpoint, and
+since they're both connected to the same input bus, they'll be mixed.
+
+Each input bus must be configured to accept the same number of channels, but the number of channels
+used by input buses can be different to the number of channels for output buses in which case
+miniaudio will automatically convert the input data to the output channel count before processing.
+The number of channels of an output bus of one node must match the channel count of the input bus
+it's attached to. The channel counts cannot be changed after the node has been initialized. If you
+attempt to attach an output bus to an input bus with a different channel count, attachment will
+fail.
+
+To use a node graph, you first need to initialize a `ma_node_graph` object. This is essentially a
+container around the entire graph. The `ma_node_graph` object is required for some thread-safety
+issues which will be explained later. A `ma_node_graph` object is initialized using miniaudio's
+standard config/init system:
+
+    ```c
+    ma_node_graph_config nodeGraphConfig = ma_node_graph_config_init(myChannelCount);
+
+    result = ma_node_graph_init(&nodeGraphConfig, NULL, &nodeGraph);    // Second parameter is a pointer to allocation callbacks.
+    if (result != MA_SUCCESS) {
+        // Failed to initialize node graph.
+    }
+    ```
+
+When you initialize the node graph, you're specifying the channel count of the endpoint. The
+endpoint is a special node which has one input bus and one output bus, both of which have the
+same channel count, which is specified in the config. Any nodes that connect directly to the
+endpoint must be configured such that their output buses have the same channel count. When you read
+audio data from the node graph, it'll have the channel count you specified in the config. To read
+data from the graph:
+
+    ```c
+    ma_uint32 framesRead;
+    result = ma_node_graph_read_pcm_frames(&nodeGraph, pFramesOut, frameCount, &framesRead);
+    if (result != MA_SUCCESS) {
+        // Failed to read data from the node graph.
+    }
+    ```
+
+When you read audio data, miniaudio starts at the node graph's endpoint node which then pulls in
+data from it's input attachments, which in turn recursively pull in data from their inputs, and so
+on. At the start of the graph there will be some kind of data source node which will have zero
+inputs and will instead read directly from a data source. The base nodes don't literally need to
+read from a `ma_data_source` object, but they will always have some kind of underlying object that
+sources some kind of audio. The `ma_data_source_node` node can be used to read from a
+`ma_data_source`. Data is always in floating-point format and in the number of channels you
+specified when the graph was initialized. The sample rate is defined by the underlying data sources.
+It's up to you to ensure they use a consistent and appropriate sample rate.
+
+The `ma_node` API is designed to allow custom nodes to be implemented with relative ease, but
+miniaudio includes a few stock nodes for common functionality. This is how you would initialize a
+node which reads directly from a data source (`ma_data_source_node`) which is an example of one
+of the stock nodes that comes with miniaudio:
+
+    ```c
+    ma_data_source_node_config config = ma_data_source_node_config_init(pMyDataSource);
+
+    ma_data_source_node dataSourceNode;
+    result = ma_data_source_node_init(&nodeGraph, &config, NULL, &dataSourceNode);
+    if (result != MA_SUCCESS) {
+        // Failed to create data source node.
+    }
+    ```
+
+The data source node will use the output channel count to determine the channel count of the output
+bus. There will be 1 output bus and 0 input buses (data will be drawn directly from the data
+source). The data source must output to floating-point (`ma_format_f32`) or else an error will be
+returned from `ma_data_source_node_init()`.
+
+By default the node will not be attached to the graph. To do so, use `ma_node_attach_output_bus()`:
+
+    ```c
+    result = ma_node_attach_output_bus(&dataSourceNode, 0, ma_node_graph_get_endpoint(&nodeGraph), 0);
+    if (result != MA_SUCCESS) {
+        // Failed to attach node.
+    }
+    ```
+
+The code above connects the data source node directly to the endpoint. Since the data source node
+has only a single output bus, the index will always be 0. Likewise, the endpoint only has a single
+input bus which means the input bus index will also always be 0.
+
+To detach a specific output bus, use `ma_node_detach_output_bus()`. To detach all output buses, use
+`ma_node_detach_all_output_buses()`. If you want to just move the output bus from one attachment to
+another, you do not need to detach first. You can just call `ma_node_attach_output_bus()` and it'll
+deal with it for you.
+
+Less frequently you may want to create a specialized node. This will be a node where you implement
+your own processing callback to apply a custom effect of some kind. This is similar to initializing
+one of the stock node types, only this time you need to specify a pointer to a vtable containing a
+pointer to the processing function and the number of input and output buses. Example:
+
+    ```c
+    static void my_custom_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+    {
+        // Do some processing of ppFramesIn (one stream of audio data per input bus)
+        const float* pFramesIn_0 = ppFramesIn[0]; // Input bus @ index 0.
+        const float* pFramesIn_1 = ppFramesIn[1]; // Input bus @ index 1.
+        float* pFramesOut_0 = ppFramesOut[0];     // Output bus @ index 0.
+
+        // Do some processing. On input, `pFrameCountIn` will be the number of input frames in each
+        // buffer in `ppFramesIn` and `pFrameCountOut` will be the capacity of each of the buffers
+        // in `ppFramesOut`. On output, `pFrameCountIn` should be set to the number of input frames
+        // your node consumed and `pFrameCountOut` should be set the number of output frames that
+        // were produced.
+        //
+        // You should process as many frames as you can. If your effect consumes input frames at the
+        // same rate as output frames (always the case, unless you're doing resampling), you need
+        // only look at `ppFramesOut` and process that exact number of frames. If you're doing
+        // resampling, you'll need to be sure to set both `pFrameCountIn` and `pFrameCountOut`
+        // properly.
+    }
+
+    static ma_node_vtable my_custom_node_vtable =
+    {
+        my_custom_node_process_pcm_frames, // The function that will be called to process your custom node. This is where you'd implement your effect processing.
+        NULL,   // Optional. A callback for calculating the number of input frames that are required to process a specified number of output frames.
+        2,      // 2 input buses.
+        1,      // 1 output bus.
+        0       // Default flags.
+    };
+
+    ...
+
+    // Each bus needs to have a channel count specified. To do this you need to specify the channel
+    // counts in an array and then pass that into the node config.
+    ma_uint32 inputChannels[2];     // Equal in size to the number of input channels specified in the vtable.
+    ma_uint32 outputChannels[1];    // Equal in size to the number of output channels specified in the vtable.
+
+    inputChannels[0]  = channelsIn;
+    inputChannels[1]  = channelsIn;
+    outputChannels[0] = channelsOut;
+
+    ma_node_config nodeConfig = ma_node_config_init();
+    nodeConfig.vtable          = &my_custom_node_vtable;
+    nodeConfig.pInputChannels  = inputChannels;
+    nodeConfig.pOutputChannels = outputChannels;
+
+    ma_node_base node;
+    result = ma_node_init(&nodeGraph, &nodeConfig, NULL, &node);
+    if (result != MA_SUCCESS) {
+        // Failed to initialize node.
+    }
+    ```
+
+When initializing a custom node, as in the code above, you'll normally just place your vtable in
+static space. The number of input and output buses are specified as part of the vtable. If you need
+a variable number of buses on a per-node bases, the vtable should have the relevant bus count set
+to `MA_NODE_BUS_COUNT_UNKNOWN`. In this case, the bus count should be set in the node config:
+
+    ```c
+    static ma_node_vtable my_custom_node_vtable =
+    {
+        my_custom_node_process_pcm_frames, // The function that will be called process your custom node. This is where you'd implement your effect processing.
+        NULL,   // Optional. A callback for calculating the number of input frames that are required to process a specified number of output frames.
+        MA_NODE_BUS_COUNT_UNKNOWN,  // The number of input buses is determined on a per-node basis.
+        1,      // 1 output bus.
+        0       // Default flags.
+    };
+
+    ...
+
+    ma_node_config nodeConfig = ma_node_config_init();
+    nodeConfig.vtable          = &my_custom_node_vtable;
+    nodeConfig.inputBusCount   = myBusCount;        // <-- Since the vtable specifies MA_NODE_BUS_COUNT_UNKNOWN, the input bus count should be set here.
+    nodeConfig.pInputChannels  = inputChannels;     // <-- Make sure there are nodeConfig.inputBusCount elements in this array.
+    nodeConfig.pOutputChannels = outputChannels;    // <-- The vtable specifies 1 output bus, so there must be 1 element in this array.
+    ```
+
+In the above example it's important to never set the `inputBusCount` and `outputBusCount` members
+to anything other than their defaults if the vtable specifies an explicit count. They can only be
+set if the vtable specifies MA_NODE_BUS_COUNT_UNKNOWN in the relevant bus count.
+
+Most often you'll want to create a structure to encapsulate your node with some extra data. You
+need to make sure the `ma_node_base` object is your first member of the structure:
+
+    ```c
+    typedef struct
+    {
+        ma_node_base base; // <-- Make sure this is always the first member.
+        float someCustomData;
+    } my_custom_node;
+    ```
+
+By doing this, your object will be compatible with all `ma_node` APIs and you can attach it to the
+graph just like any other node.
+
+In the custom processing callback (`my_custom_node_process_pcm_frames()` in the example above), the
+number of channels for each bus is what was specified by the config when the node was initialized
+with `ma_node_init()`. In addition, all attachments to each of the input buses will have been
+pre-mixed by miniaudio. The config allows you to specify different channel counts for each
+individual input and output bus. It's up to the effect to handle it appropriate, and if it can't,
+return an error in it's initialization routine.
+
+Custom nodes can be assigned some flags to describe their behaviour. These are set via the vtable
+and include the following:
+
+    +-----------------------------------------+---------------------------------------------------+
+    | Flag Name                               | Description                                       |
+    +-----------------------------------------+---------------------------------------------------+
+    | MA_NODE_FLAG_PASSTHROUGH                | Useful for nodes that do not do any kind of audio |
+    |                                         | processing, but are instead used for tracking     |
+    |                                         | time, handling events, etc. Also used by the      |
+    |                                         | internal endpoint node. It reads directly from    |
+    |                                         | the input bus to the output bus. Nodes with this  |
+    |                                         | flag must have exactly 1 input bus and 1 output   |
+    |                                         | bus, and both buses must have the same channel    |
+    |                                         | counts.                                           |
+    +-----------------------------------------+---------------------------------------------------+
+    | MA_NODE_FLAG_CONTINUOUS_PROCESSING      | Causes the processing callback to be called even  |
+    |                                         | when no data is available to be read from input   |
+    |                                         | attachments. When a node has at least one input   |
+    |                                         | bus, but there are no inputs attached or the      |
+    |                                         | inputs do not deliver any data, the node's        |
+    |                                         | processing callback will not get fired. This flag |
+    |                                         | will make it so the callback is always fired      |
+    |                                         | regardless of whether or not any input data is    |
+    |                                         | received. This is useful for effects like         |
+    |                                         | echos where there will be a tail of audio data    |
+    |                                         | that still needs to be processed even when the    |
+    |                                         | original data sources have reached their ends. It |
+    |                                         | may also be useful for nodes that must always     |
+    |                                         | have their processing callback fired when there   |
+    |                                         | are no inputs attached.                           |
+    +-----------------------------------------+---------------------------------------------------+
+    | MA_NODE_FLAG_ALLOW_NULL_INPUT           | Used in conjunction with                          |
+    |                                         | `MA_NODE_FLAG_CONTINUOUS_PROCESSING`. When this   |
+    |                                         | is set, the `ppFramesIn` parameter of the         |
+    |                                         | processing callback will be set to NULL when      |
+    |                                         | there are no input frames are available. When     |
+    |                                         | this is unset, silence will be posted to the      |
+    |                                         | processing callback.                              |
+    +-----------------------------------------+---------------------------------------------------+
+    | MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES | Used to tell miniaudio that input and output      |
+    |                                         | frames are processed at different rates. You      |
+    |                                         | should set this for any nodes that perform        |
+    |                                         | resampling.                                       |
+    +-----------------------------------------+---------------------------------------------------+
+    | MA_NODE_FLAG_SILENT_OUTPUT              | Used to tell miniaudio that a node produces only  |
+    |                                         | silent output. This is useful for nodes where you |
+    |                                         | don't want the output to contribute to the final  |
+    |                                         | mix. An example might be if you want split your   |
+    |                                         | stream and have one branch be output to a file.   |
+    |                                         | When using this flag, you should avoid writing to |
+    |                                         | the output buffer of the node's processing        |
+    |                                         | callback because miniaudio will ignore it anyway. |
+    +-----------------------------------------+---------------------------------------------------+
+
+
+If you need to make a copy of an audio stream for effect processing you can use a splitter node
+called `ma_splitter_node`. This takes has 1 input bus and splits the stream into 2 output buses.
+You can use it like this:
+
+    ```c
+    ma_splitter_node_config splitterNodeConfig = ma_splitter_node_config_init(channels);
+
+    ma_splitter_node splitterNode;
+    result = ma_splitter_node_init(&nodeGraph, &splitterNodeConfig, NULL, &splitterNode);
+    if (result != MA_SUCCESS) {
+        // Failed to create node.
+    }
+
+    // Attach your output buses to two different input buses (can be on two different nodes).
+    ma_node_attach_output_bus(&splitterNode, 0, ma_node_graph_get_endpoint(&nodeGraph), 0); // Attach directly to the endpoint.
+    ma_node_attach_output_bus(&splitterNode, 1, &myEffectNode,                          0); // Attach to input bus 0 of some effect node.
+    ```
+
+The volume of an output bus can be configured on a per-bus basis:
+
+    ```c
+    ma_node_set_output_bus_volume(&splitterNode, 0, 0.5f);
+    ma_node_set_output_bus_volume(&splitterNode, 1, 0.5f);
+    ```
+
+In the code above we're using the splitter node from before and changing the volume of each of the
+copied streams.
+
+You can start and stop a node with the following:
+
+    ```c
+    ma_node_set_state(&splitterNode, ma_node_state_started);    // The default state.
+    ma_node_set_state(&splitterNode, ma_node_state_stopped);
+    ```
+
+By default the node is in a started state, but since it won't be connected to anything won't
+actually be invoked by the node graph until it's connected. When you stop a node, data will not be
+read from any of it's input connections. You can use this property to stop a group of sounds
+atomically.
+
+You can configure the initial state of a node in it's config:
+
+    ```c
+    nodeConfig.initialState = ma_node_state_stopped;
+    ```
+
+Note that for the stock specialized nodes, all of their configs will have a `nodeConfig` member
+which is the config to use with the base node. This is where the initial state can be configured
+for specialized nodes:
+
+    ```c
+    dataSourceNodeConfig.nodeConfig.initialState = ma_node_state_stopped;
+    ```
+
+When using a specialized node like `ma_data_source_node` or `ma_splitter_node`, be sure to not
+modify the `vtable` member of the `nodeConfig` object.
+
+
+7.1. Timing
+-----------
+The node graph supports starting and stopping nodes at scheduled times. This is especially useful
+for data source nodes where you want to get the node set up, but only start playback at a specific
+time. There are two clocks: local and global.
+
+A local clock is per-node, whereas the global clock is per graph. Scheduling starts and stops can
+only be done based on the global clock because the local clock will not be running while the node
+is stopped. The global clocks advances whenever `ma_node_graph_read_pcm_frames()` is called. On the
+other hand, the local clock only advances when the node's processing callback is fired, and is
+advanced based on the output frame count.
+
+To retrieve the global time, use `ma_node_graph_get_time()`. The global time can be set with
+`ma_node_graph_set_time()` which might be useful if you want to do seeking on a global timeline.
+Getting and setting the local time is similar. Use `ma_node_get_time()` to retrieve the local time,
+and `ma_node_set_time()` to set the local time. The global and local times will be advanced by the
+audio thread, so care should be taken to avoid data races. Ideally you should avoid calling these
+outside of the node processing callbacks which are always run on the audio thread.
+
+There is basic support for scheduling the starting and stopping of nodes. You can only schedule one
+start and one stop at a time. This is mainly intended for putting nodes into a started or stopped
+state in a frame-exact manner. Without this mechanism, starting and stopping of a node is limited
+to the resolution of a call to `ma_node_graph_read_pcm_frames()` which would typically be in blocks
+of several milliseconds. The following APIs can be used for scheduling node states:
+
+    ```c
+    ma_node_set_state_time()
+    ma_node_get_state_time()
+    ```
+
+The time is absolute and must be based on the global clock. An example is below:
+
+    ```c
+    ma_node_set_state_time(&myNode, ma_node_state_started, sampleRate*1);   // Delay starting to 1 second.
+    ma_node_set_state_time(&myNode, ma_node_state_stopped, sampleRate*5);   // Delay stopping to 5 seconds.
+    ```
+
+An example for changing the state using a relative time.
+
+    ```c
+    ma_node_set_state_time(&myNode, ma_node_state_started, sampleRate*1 + ma_node_graph_get_time(&myNodeGraph));
+    ma_node_set_state_time(&myNode, ma_node_state_stopped, sampleRate*5 + ma_node_graph_get_time(&myNodeGraph));
+    ```
+
+Note that due to the nature of multi-threading the times may not be 100% exact. If this is an
+issue, consider scheduling state changes from within a processing callback. An idea might be to
+have some kind of passthrough trigger node that is used specifically for tracking time and handling
+events.
+
+
+
+7.2. Thread Safety and Locking
+------------------------------
+When processing audio, it's ideal not to have any kind of locking in the audio thread. Since it's
+expected that `ma_node_graph_read_pcm_frames()` would be run on the audio thread, it does so
+without the use of any locks. This section discusses the implementation used by miniaudio and goes
+over some of the compromises employed by miniaudio to achieve this goal. Note that the current
+implementation may not be ideal - feedback and critiques are most welcome.
+
+The node graph API is not *entirely* lock-free. Only `ma_node_graph_read_pcm_frames()` is expected
+to be lock-free. Attachment, detachment and uninitialization of nodes use locks to simplify the
+implementation, but are crafted in a way such that such locking is not required when reading audio
+data from the graph. Locking in these areas are achieved by means of spinlocks.
+
+The main complication with keeping `ma_node_graph_read_pcm_frames()` lock-free stems from the fact
+that a node can be uninitialized, and it's memory potentially freed, while in the middle of being
+processed on the audio thread. There are times when the audio thread will be referencing a node,
+which means the uninitialization process of a node needs to make sure it delays returning until the
+audio thread is finished so that control is not handed back to the caller thereby giving them a
+chance to free the node's memory.
+
+When the audio thread is processing a node, it does so by reading from each of the output buses of
+the node. In order for a node to process data for one of it's output buses, it needs to read from
+each of it's input buses, and so on an so forth. It follows that once all output buses of a node
+are detached, the node as a whole will be disconnected and no further processing will occur unless
+it's output buses are reattached, which won't be happening when the node is being uninitialized.
+By having `ma_node_detach_output_bus()` wait until the audio thread is finished with it, we can
+simplify a few things, at the expense of making `ma_node_detach_output_bus()` a bit slower. By
+doing this, the implementation of `ma_node_uninit()` becomes trivial - just detach all output
+nodes, followed by each of the attachments to each of it's input nodes, and then do any final clean
+up.
+
+With the above design, the worst-case scenario is `ma_node_detach_output_bus()` taking as long as
+it takes to process the output bus being detached. This will happen if it's called at just the
+wrong moment where the audio thread has just iterated it and has just started processing. The
+caller of `ma_node_detach_output_bus()` will stall until the audio thread is finished, which
+includes the cost of recursively processing it's inputs. This is the biggest compromise made with
+the approach taken by miniaudio for it's lock-free processing system. The cost of detaching nodes
+earlier in the pipeline (data sources, for example) will be cheaper than the cost of detaching
+higher level nodes, such as some kind of final post-processing endpoint. If you need to do mass
+detachments, detach starting from the lowest level nodes and work your way towards the final
+endpoint node (but don't try detaching the node graph's endpoint). If the audio thread is not
+running, detachment will be fast and detachment in any order will be the same. The reason nodes
+need to wait for their input attachments to complete is due to the potential for desyncs between
+data sources. If the node was to terminate processing mid way through processing it's inputs,
+there's a chance that some of the underlying data sources will have been read, but then others not.
+That will then result in a potential desynchronization when detaching and reattaching higher-level
+nodes. A possible solution to this is to have an option when detaching to terminate processing
+before processing all input attachments which should be fairly simple.
+
+Another compromise, albeit less significant, is locking when attaching and detaching nodes. This
+locking is achieved by means of a spinlock in order to reduce memory overhead. A lock is present
+for each input bus and output bus. When an output bus is connected to an input bus, both the output
+bus and input bus is locked. This locking is specifically for attaching and detaching across
+different threads and does not affect `ma_node_graph_read_pcm_frames()` in any way. The locking and
+unlocking is mostly self-explanatory, but a slightly less intuitive aspect comes into it when
+considering that iterating over attachments must not break as a result of attaching or detaching a
+node while iteration is occurring.
+
+Attaching and detaching are both quite simple. When an output bus of a node is attached to an input
+bus of another node, it's added to a linked list. Basically, an input bus is a linked list, where
+each item in the list is and output bus. We have some intentional (and convenient) restrictions on
+what can done with the linked list in order to simplify the implementation. First of all, whenever
+something needs to iterate over the list, it must do so in a forward direction. Backwards iteration
+is not supported. Also, items can only be added to the start of the list.
+
+The linked list is a doubly-linked list where each item in the list (an output bus) holds a pointer
+to the next item in the list, and another to the previous item. A pointer to the previous item is
+only required for fast detachment of the node - it is never used in iteration. This is an
+important property because it means from the perspective of iteration, attaching and detaching of
+an item can be done with a single atomic assignment. This is exploited by both the attachment and
+detachment process. When attaching the node, the first thing that is done is the setting of the
+local "next" and "previous" pointers of the node. After that, the item is "attached" to the list
+by simply performing an atomic exchange with the head pointer. After that, the node is "attached"
+to the list from the perspective of iteration. Even though the "previous" pointer of the next item
+hasn't yet been set, from the perspective of iteration it's been attached because iteration will
+only be happening in a forward direction which means the "previous" pointer won't actually ever get
+used. The same general process applies to detachment. See `ma_node_attach_output_bus()` and
+`ma_node_detach_output_bus()` for the implementation of this mechanism.
+
+
+
+8. Decoding
+===========
+The `ma_decoder` API is used for reading audio files. Decoders are completely decoupled from
+devices and can be used independently. Built-in support is included for the following formats:
+
+    +---------+
+    | Format  |
+    +---------+
+    | WAV     |
+    | MP3     |
+    | FLAC    |
+    +---------+
+
+You can disable the built-in decoders by specifying one or more of the following options before the
+miniaudio implementation:
+
+    ```c
+    #define MA_NO_WAV
+    #define MA_NO_MP3
+    #define MA_NO_FLAC
+    ```
+
+miniaudio supports the ability to plug in custom decoders. See the section below for details on how
+to use custom decoders.
+
+A decoder can be initialized from a file with `ma_decoder_init_file()`, a block of memory with
+`ma_decoder_init_memory()`, or from data delivered via callbacks with `ma_decoder_init()`. Here is
+an example for loading a decoder from a file:
+
+    ```c
+    ma_decoder decoder;
+    ma_result result = ma_decoder_init_file("MySong.mp3", NULL, &decoder);
+    if (result != MA_SUCCESS) {
+        return false;   // An error occurred.
+    }
+
+    ...
+
+    ma_decoder_uninit(&decoder);
+    ```
+
+When initializing a decoder, you can optionally pass in a pointer to a `ma_decoder_config` object
+(the `NULL` argument in the example above) which allows you to configure the output format, channel
+count, sample rate and channel map:
+
+    ```c
+    ma_decoder_config config = ma_decoder_config_init(ma_format_f32, 2, 48000);
+    ```
+
+When passing in `NULL` for decoder config in `ma_decoder_init*()`, the output format will be the
+same as that defined by the decoding backend.
+
+Data is read from the decoder as PCM frames. This will output the number of PCM frames actually
+read. If this is less than the requested number of PCM frames it means you've reached the end. The
+return value will be `MA_AT_END` if no samples have been read and the end has been reached.
+
+    ```c
+    ma_result result = ma_decoder_read_pcm_frames(pDecoder, pFrames, framesToRead, &framesRead);
+    if (framesRead < framesToRead) {
+        // Reached the end.
+    }
+    ```
+
+You can also seek to a specific frame like so:
+
+    ```c
+    ma_result result = ma_decoder_seek_to_pcm_frame(pDecoder, targetFrame);
+    if (result != MA_SUCCESS) {
+        return false;   // An error occurred.
+    }
+    ```
+
+If you want to loop back to the start, you can simply seek back to the first PCM frame:
+
+    ```c
+    ma_decoder_seek_to_pcm_frame(pDecoder, 0);
+    ```
+
+When loading a decoder, miniaudio uses a trial and error technique to find the appropriate decoding
+backend. This can be unnecessarily inefficient if the type is already known. In this case you can
+use `encodingFormat` variable in the device config to specify a specific encoding format you want
+to decode:
+
+    ```c
+    decoderConfig.encodingFormat = ma_encoding_format_wav;
+    ```
+
+See the `ma_encoding_format` enum for possible encoding formats.
+
+The `ma_decoder_init_file()` API will try using the file extension to determine which decoding
+backend to prefer.
+
+
+8.1. Custom Decoders
+--------------------
+It's possible to implement a custom decoder and plug it into miniaudio. This is extremely useful
+when you want to use the `ma_decoder` API, but need to support an encoding format that's not one of
+the stock formats supported by miniaudio. This can be put to particularly good use when using the
+`ma_engine` and/or `ma_resource_manager` APIs because they use `ma_decoder` internally. If, for
+example, you wanted to support Opus, you can do so with a custom decoder (there if a reference
+Opus decoder in the "extras" folder of the miniaudio repository which uses libopus + libopusfile).
+
+A custom decoder must implement a data source. A vtable called `ma_decoding_backend_vtable` needs
+to be implemented which is then passed into the decoder config:
+
+    ```c
+    ma_decoding_backend_vtable* pCustomBackendVTables[] =
+    {
+        &g_ma_decoding_backend_vtable_libvorbis,
+        &g_ma_decoding_backend_vtable_libopus
+    };
+
+    ...
+
+    decoderConfig = ma_decoder_config_init_default();
+    decoderConfig.pCustomBackendUserData = NULL;
+    decoderConfig.ppCustomBackendVTables = pCustomBackendVTables;
+    decoderConfig.customBackendCount     = sizeof(pCustomBackendVTables) / sizeof(pCustomBackendVTables[0]);
+    ```
+
+The `ma_decoding_backend_vtable` vtable has the following functions:
+
+    ```
+    onInit
+    onInitFile
+    onInitFileW
+    onInitMemory
+    onUninit
+    ```
+
+There are only two functions that must be implemented - `onInit` and `onUninit`. The other
+functions can be implemented for a small optimization for loading from a file path or memory. If
+these are not specified, miniaudio will deal with it for you via a generic implementation.
+
+When you initialize a custom data source (by implementing the `onInit` function in the vtable) you
+will need to output a pointer to a `ma_data_source` which implements your custom decoder. See the
+section about data sources for details on how to implement this. Alternatively, see the
+"custom_decoders" example in the miniaudio repository.
+
+The `onInit` function takes a pointer to some callbacks for the purpose of reading raw audio data
+from some arbitrary source. You'll use these functions to read from the raw data and perform the
+decoding. When you call them, you will pass in the `pReadSeekTellUserData` pointer to the relevant
+parameter.
+
+The `pConfig` parameter in `onInit` can be used to configure the backend if appropriate. It's only
+used as a hint and can be ignored. However, if any of the properties are relevant to your decoder,
+an optimal implementation will handle the relevant properties appropriately.
+
+If memory allocation is required, it should be done so via the specified allocation callbacks if
+possible (the `pAllocationCallbacks` parameter).
+
+If an error occurs when initializing the decoder, you should leave `ppBackend` unset, or set to
+NULL, and make sure everything is cleaned up appropriately and an appropriate result code returned.
+When multiple custom backends are specified, miniaudio will cycle through the vtables in the order
+they're listed in the array that's passed into the decoder config so it's important that your
+initialization routine is clean.
+
+When a decoder is uninitialized, the `onUninit` callback will be fired which will give you an
+opportunity to clean up and internal data.
+
+
+
+9. Encoding
+===========
+The `ma_encoding` API is used for writing audio files. The only supported output format is WAV.
+This can be disabled by specifying the following option before the implementation of miniaudio:
+
+    ```c
+    #define MA_NO_WAV
+    ```
+
+An encoder can be initialized to write to a file with `ma_encoder_init_file()` or from data
+delivered via callbacks with `ma_encoder_init()`. Below is an example for initializing an encoder
+to output to a file.
+
+    ```c
+    ma_encoder_config config = ma_encoder_config_init(ma_encoding_format_wav, FORMAT, CHANNELS, SAMPLE_RATE);
+    ma_encoder encoder;
+    ma_result result = ma_encoder_init_file("my_file.wav", &config, &encoder);
+    if (result != MA_SUCCESS) {
+        // Error
+    }
+
+    ...
+
+    ma_encoder_uninit(&encoder);
+    ```
+
+When initializing an encoder you must specify a config which is initialized with
+`ma_encoder_config_init()`. Here you must specify the file type, the output sample format, output
+channel count and output sample rate. The following file types are supported:
+
+    +------------------------+-------------+
+    | Enum                   | Description |
+    +------------------------+-------------+
+    | ma_encoding_format_wav | WAV         |
+    +------------------------+-------------+
+
+If the format, channel count or sample rate is not supported by the output file type an error will
+be returned. The encoder will not perform data conversion so you will need to convert it before
+outputting any audio data. To output audio data, use `ma_encoder_write_pcm_frames()`, like in the
+example below:
+
+    ```c
+    ma_uint64 framesWritten;
+    result = ma_encoder_write_pcm_frames(&encoder, pPCMFramesToWrite, framesToWrite, &framesWritten);
+    if (result != MA_SUCCESS) {
+        ... handle error ...
+    }
+    ```
+
+The `framesWritten` variable will contain the number of PCM frames that were actually written. This
+is optionally and you can pass in `NULL` if you need this.
+
+Encoders must be uninitialized with `ma_encoder_uninit()`.
+
+
+
+10. Data Conversion
+===================
+A data conversion API is included with miniaudio which supports the majority of data conversion
+requirements. This supports conversion between sample formats, channel counts (with channel
+mapping) and sample rates.
+
+
+10.1. Sample Format Conversion
+------------------------------
+Conversion between sample formats is achieved with the `ma_pcm_*_to_*()`, `ma_pcm_convert()` and
+`ma_convert_pcm_frames_format()` APIs. Use `ma_pcm_*_to_*()` to convert between two specific
+formats. Use `ma_pcm_convert()` to convert based on a `ma_format` variable. Use
+`ma_convert_pcm_frames_format()` to convert PCM frames where you want to specify the frame count
+and channel count as a variable instead of the total sample count.
+
+
+10.1.1. Dithering
+-----------------
+Dithering can be set using the ditherMode parameter.
+
+The different dithering modes include the following, in order of efficiency:
+
+    +-----------+--------------------------+
+    | Type      | Enum Token               |
+    +-----------+--------------------------+
+    | None      | ma_dither_mode_none      |
+    | Rectangle | ma_dither_mode_rectangle |
+    | Triangle  | ma_dither_mode_triangle  |
+    +-----------+--------------------------+
+
+Note that even if the dither mode is set to something other than `ma_dither_mode_none`, it will be
+ignored for conversions where dithering is not needed. Dithering is available for the following
+conversions:
+
+    ```
+    s16 -> u8
+    s24 -> u8
+    s32 -> u8
+    f32 -> u8
+    s24 -> s16
+    s32 -> s16
+    f32 -> s16
+    ```
+
+Note that it is not an error to pass something other than ma_dither_mode_none for conversions where
+dither is not used. It will just be ignored.
+
+
+
+10.2. Channel Conversion
+------------------------
+Channel conversion is used for channel rearrangement and conversion from one channel count to
+another. The `ma_channel_converter` API is used for channel conversion. Below is an example of
+initializing a simple channel converter which converts from mono to stereo.
+
+    ```c
+    ma_channel_converter_config config = ma_channel_converter_config_init(
+        ma_format,                      // Sample format
+        1,                              // Input channels
+        NULL,                           // Input channel map
+        2,                              // Output channels
+        NULL,                           // Output channel map
+        ma_channel_mix_mode_default);   // The mixing algorithm to use when combining channels.
+
+    result = ma_channel_converter_init(&config, NULL, &converter);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+    ```
+
+To perform the conversion simply call `ma_channel_converter_process_pcm_frames()` like so:
+
+    ```c
+    ma_result result = ma_channel_converter_process_pcm_frames(&converter, pFramesOut, pFramesIn, frameCount);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+    ```
+
+It is up to the caller to ensure the output buffer is large enough to accommodate the new PCM
+frames.
+
+Input and output PCM frames are always interleaved. Deinterleaved layouts are not supported.
+
+
+10.2.1. Channel Mapping
+-----------------------
+In addition to converting from one channel count to another, like the example above, the channel
+converter can also be used to rearrange channels. When initializing the channel converter, you can
+optionally pass in channel maps for both the input and output frames. If the channel counts are the
+same, and each channel map contains the same channel positions with the exception that they're in
+a different order, a simple shuffling of the channels will be performed. If, however, there is not
+a 1:1 mapping of channel positions, or the channel counts differ, the input channels will be mixed
+based on a mixing mode which is specified when initializing the `ma_channel_converter_config`
+object.
+
+When converting from mono to multi-channel, the mono channel is simply copied to each output
+channel. When going the other way around, the audio of each output channel is simply averaged and
+copied to the mono channel.
+
+In more complicated cases blending is used. The `ma_channel_mix_mode_simple` mode will drop excess
+channels and silence extra channels. For example, converting from 4 to 2 channels, the 3rd and 4th
+channels will be dropped, whereas converting from 2 to 4 channels will put silence into the 3rd and
+4th channels.
+
+The `ma_channel_mix_mode_rectangle` mode uses spacial locality based on a rectangle to compute a
+simple distribution between input and output. Imagine sitting in the middle of a room, with
+speakers on the walls representing channel positions. The `MA_CHANNEL_FRONT_LEFT` position can be
+thought of as being in the corner of the front and left walls.
+
+Finally, the `ma_channel_mix_mode_custom_weights` mode can be used to use custom user-defined
+weights. Custom weights can be passed in as the last parameter of
+`ma_channel_converter_config_init()`.
+
+Predefined channel maps can be retrieved with `ma_channel_map_init_standard()`. This takes a
+`ma_standard_channel_map` enum as it's first parameter, which can be one of the following:
+
+    +-----------------------------------+-----------------------------------------------------------+
+    | Name                              | Description                                               |
+    +-----------------------------------+-----------------------------------------------------------+
+    | ma_standard_channel_map_default   | Default channel map used by miniaudio. See below.         |
+    | ma_standard_channel_map_microsoft | Channel map used by Microsoft's bitfield channel maps.    |
+    | ma_standard_channel_map_alsa      | Default ALSA channel map.                                 |
+    | ma_standard_channel_map_rfc3551   | RFC 3551. Based on AIFF.                                  |
+    | ma_standard_channel_map_flac      | FLAC channel map.                                         |
+    | ma_standard_channel_map_vorbis    | Vorbis channel map.                                       |
+    | ma_standard_channel_map_sound4    | FreeBSD's sound(4).                                       |
+    | ma_standard_channel_map_sndio     | sndio channel map. http://www.sndio.org/tips.html.        |
+    | ma_standard_channel_map_webaudio  | https://webaudio.github.io/web-audio-api/#ChannelOrdering |
+    +-----------------------------------+-----------------------------------------------------------+
+
+Below are the channel maps used by default in miniaudio (`ma_standard_channel_map_default`):
+
+    +---------------+---------------------------------+
+    | Channel Count | Mapping                         |
+    +---------------+---------------------------------+
+    | 1 (Mono)      | 0: MA_CHANNEL_MONO              |
+    +---------------+---------------------------------+
+    | 2 (Stereo)    | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT       |
+    +---------------+---------------------------------+
+    | 3             | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER      |
+    +---------------+---------------------------------+
+    | 4 (Surround)  | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER <br> |
+    |               | 3: MA_CHANNEL_BACK_CENTER       |
+    +---------------+---------------------------------+
+    | 5             | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER <br> |
+    |               | 3: MA_CHANNEL_BACK_LEFT    <br> |
+    |               | 4: MA_CHANNEL_BACK_RIGHT        |
+    +---------------+---------------------------------+
+    | 6 (5.1)       | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER <br> |
+    |               | 3: MA_CHANNEL_LFE          <br> |
+    |               | 4: MA_CHANNEL_SIDE_LEFT    <br> |
+    |               | 5: MA_CHANNEL_SIDE_RIGHT        |
+    +---------------+---------------------------------+
+    | 7             | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER <br> |
+    |               | 3: MA_CHANNEL_LFE          <br> |
+    |               | 4: MA_CHANNEL_BACK_CENTER  <br> |
+    |               | 4: MA_CHANNEL_SIDE_LEFT    <br> |
+    |               | 5: MA_CHANNEL_SIDE_RIGHT        |
+    +---------------+---------------------------------+
+    | 8 (7.1)       | 0: MA_CHANNEL_FRONT_LEFT   <br> |
+    |               | 1: MA_CHANNEL_FRONT_RIGHT  <br> |
+    |               | 2: MA_CHANNEL_FRONT_CENTER <br> |
+    |               | 3: MA_CHANNEL_LFE          <br> |
+    |               | 4: MA_CHANNEL_BACK_LEFT    <br> |
+    |               | 5: MA_CHANNEL_BACK_RIGHT   <br> |
+    |               | 6: MA_CHANNEL_SIDE_LEFT    <br> |
+    |               | 7: MA_CHANNEL_SIDE_RIGHT        |
+    +---------------+---------------------------------+
+    | Other         | All channels set to 0. This     |
+    |               | is equivalent to the same       |
+    |               | mapping as the device.          |
+    +---------------+---------------------------------+
+
+
+
+10.3. Resampling
+----------------
+Resampling is achieved with the `ma_resampler` object. To create a resampler object, do something
+like the following:
+
+    ```c
+    ma_resampler_config config = ma_resampler_config_init(
+        ma_format_s16,
+        channels,
+        sampleRateIn,
+        sampleRateOut,
+        ma_resample_algorithm_linear);
+
+    ma_resampler resampler;
+    ma_result result = ma_resampler_init(&config, &resampler);
+    if (result != MA_SUCCESS) {
+        // An error occurred...
+    }
+    ```
+
+Do the following to uninitialize the resampler:
+
+    ```c
+    ma_resampler_uninit(&resampler);
+    ```
+
+The following example shows how data can be processed
+
+    ```c
+    ma_uint64 frameCountIn  = 1000;
+    ma_uint64 frameCountOut = 2000;
+    ma_result result = ma_resampler_process_pcm_frames(&resampler, pFramesIn, &frameCountIn, pFramesOut, &frameCountOut);
+    if (result != MA_SUCCESS) {
+        // An error occurred...
+    }
+
+    // At this point, frameCountIn contains the number of input frames that were consumed and frameCountOut contains the
+    // number of output frames written.
+    ```
+
+To initialize the resampler you first need to set up a config (`ma_resampler_config`) with
+`ma_resampler_config_init()`. You need to specify the sample format you want to use, the number of
+channels, the input and output sample rate, and the algorithm.
+
+The sample format can be either `ma_format_s16` or `ma_format_f32`. If you need a different format
+you will need to perform pre- and post-conversions yourself where necessary. Note that the format
+is the same for both input and output. The format cannot be changed after initialization.
+
+The resampler supports multiple channels and is always interleaved (both input and output). The
+channel count cannot be changed after initialization.
+
+The sample rates can be anything other than zero, and are always specified in hertz. They should be
+set to something like 44100, etc. The sample rate is the only configuration property that can be
+changed after initialization.
+
+The miniaudio resampler has built-in support for the following algorithms:
+
+    +-----------+------------------------------+
+    | Algorithm | Enum Token                   |
+    +-----------+------------------------------+
+    | Linear    | ma_resample_algorithm_linear |
+    | Custom    | ma_resample_algorithm_custom |
+    +-----------+------------------------------+
+
+The algorithm cannot be changed after initialization.
+
+Processing always happens on a per PCM frame basis and always assumes interleaved input and output.
+De-interleaved processing is not supported. To process frames, use
+`ma_resampler_process_pcm_frames()`. On input, this function takes the number of output frames you
+can fit in the output buffer and the number of input frames contained in the input buffer. On
+output these variables contain the number of output frames that were written to the output buffer
+and the number of input frames that were consumed in the process. You can pass in NULL for the
+input buffer in which case it will be treated as an infinitely large buffer of zeros. The output
+buffer can also be NULL, in which case the processing will be treated as seek.
+
+The sample rate can be changed dynamically on the fly. You can change this with explicit sample
+rates with `ma_resampler_set_rate()` and also with a decimal ratio with
+`ma_resampler_set_rate_ratio()`. The ratio is in/out.
+
+Sometimes it's useful to know exactly how many input frames will be required to output a specific
+number of frames. You can calculate this with `ma_resampler_get_required_input_frame_count()`.
+Likewise, it's sometimes useful to know exactly how many frames would be output given a certain
+number of input frames. You can do this with `ma_resampler_get_expected_output_frame_count()`.
+
+Due to the nature of how resampling works, the resampler introduces some latency. This can be
+retrieved in terms of both the input rate and the output rate with
+`ma_resampler_get_input_latency()` and `ma_resampler_get_output_latency()`.
+
+
+10.3.1. Resampling Algorithms
+-----------------------------
+The choice of resampling algorithm depends on your situation and requirements.
+
+
+10.3.1.1. Linear Resampling
+---------------------------
+The linear resampler is the fastest, but comes at the expense of poorer quality. There is, however,
+some control over the quality of the linear resampler which may make it a suitable option depending
+on your requirements.
+
+The linear resampler performs low-pass filtering before or after downsampling or upsampling,
+depending on the sample rates you're converting between. When decreasing the sample rate, the
+low-pass filter will be applied before downsampling. When increasing the rate it will be performed
+after upsampling. By default a fourth order low-pass filter will be applied. This can be configured
+via the `lpfOrder` configuration variable. Setting this to 0 will disable filtering.
+
+The low-pass filter has a cutoff frequency which defaults to half the sample rate of the lowest of
+the input and output sample rates (Nyquist Frequency).
+
+The API for the linear resampler is the same as the main resampler API, only it's called
+`ma_linear_resampler`.
+
+
+10.3.2. Custom Resamplers
+-------------------------
+You can implement a custom resampler by using the `ma_resample_algorithm_custom` resampling
+algorithm and setting a vtable in the resampler config:
+
+    ```c
+    ma_resampler_config config = ma_resampler_config_init(..., ma_resample_algorithm_custom);
+    config.pBackendVTable = &g_customResamplerVTable;
+    ```
+
+Custom resamplers are useful if the stock algorithms are not appropriate for your use case. You
+need to implement the required functions in `ma_resampling_backend_vtable`. Note that not all
+functions in the vtable need to be implemented, but if it's possible to implement, they should be.
+
+You can use the `ma_linear_resampler` object for an example on how to implement the vtable. The
+`onGetHeapSize` callback is used to calculate the size of any internal heap allocation the custom
+resampler will need to make given the supplied config. When you initialize the resampler via the
+`onInit` callback, you'll be given a pointer to a heap allocation which is where you should store
+the heap allocated data. You should not free this data in `onUninit` because miniaudio will manage
+it for you.
+
+The `onProcess` callback is where the actual resampling takes place. On input, `pFrameCountIn`
+points to a variable containing the number of frames in the `pFramesIn` buffer and
+`pFrameCountOut` points to a variable containing the capacity in frames of the `pFramesOut` buffer.
+On output, `pFrameCountIn` should be set to the number of input frames that were fully consumed,
+whereas `pFrameCountOut` should be set to the number of frames that were written to `pFramesOut`.
+
+The `onSetRate` callback is optional and is used for dynamically changing the sample rate. If
+dynamic rate changes are not supported, you can set this callback to NULL.
+
+The `onGetInputLatency` and `onGetOutputLatency` functions are used for retrieving the latency in
+input and output rates respectively. These can be NULL in which case latency calculations will be
+assumed to be NULL.
+
+The `onGetRequiredInputFrameCount` callback is used to give miniaudio a hint as to how many input
+frames are required to be available to produce the given number of output frames. Likewise, the
+`onGetExpectedOutputFrameCount` callback is used to determine how many output frames will be
+produced given the specified number of input frames. miniaudio will use these as a hint, but they
+are optional and can be set to NULL if you're unable to implement them.
+
+
+
+10.4. General Data Conversion
+-----------------------------
+The `ma_data_converter` API can be used to wrap sample format conversion, channel conversion and
+resampling into one operation. This is what miniaudio uses internally to convert between the format
+requested when the device was initialized and the format of the backend's native device. The API
+for general data conversion is very similar to the resampling API. Create a `ma_data_converter`
+object like this:
+
+    ```c
+    ma_data_converter_config config = ma_data_converter_config_init(
+        inputFormat,
+        outputFormat,
+        inputChannels,
+        outputChannels,
+        inputSampleRate,
+        outputSampleRate
+    );
+
+    ma_data_converter converter;
+    ma_result result = ma_data_converter_init(&config, NULL, &converter);
+    if (result != MA_SUCCESS) {
+        // An error occurred...
+    }
+    ```
+
+In the example above we use `ma_data_converter_config_init()` to initialize the config, however
+there's many more properties that can be configured, such as channel maps and resampling quality.
+Something like the following may be more suitable depending on your requirements:
+
+    ```c
+    ma_data_converter_config config = ma_data_converter_config_init_default();
+    config.formatIn = inputFormat;
+    config.formatOut = outputFormat;
+    config.channelsIn = inputChannels;
+    config.channelsOut = outputChannels;
+    config.sampleRateIn = inputSampleRate;
+    config.sampleRateOut = outputSampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_flac, config.channelMapIn, sizeof(config.channelMapIn)/sizeof(config.channelMapIn[0]), config.channelCountIn);
+    config.resampling.linear.lpfOrder = MA_MAX_FILTER_ORDER;
+    ```
+
+Do the following to uninitialize the data converter:
+
+    ```c
+    ma_data_converter_uninit(&converter, NULL);
+    ```
+
+The following example shows how data can be processed
+
+    ```c
+    ma_uint64 frameCountIn  = 1000;
+    ma_uint64 frameCountOut = 2000;
+    ma_result result = ma_data_converter_process_pcm_frames(&converter, pFramesIn, &frameCountIn, pFramesOut, &frameCountOut);
+    if (result != MA_SUCCESS) {
+        // An error occurred...
+    }
+
+    // At this point, frameCountIn contains the number of input frames that were consumed and frameCountOut contains the number
+    // of output frames written.
+    ```
+
+The data converter supports multiple channels and is always interleaved (both input and output).
+The channel count cannot be changed after initialization.
+
+Sample rates can be anything other than zero, and are always specified in hertz. They should be set
+to something like 44100, etc. The sample rate is the only configuration property that can be
+changed after initialization, but only if the `resampling.allowDynamicSampleRate` member of
+`ma_data_converter_config` is set to `MA_TRUE`. To change the sample rate, use
+`ma_data_converter_set_rate()` or `ma_data_converter_set_rate_ratio()`. The ratio must be in/out.
+The resampling algorithm cannot be changed after initialization.
+
+Processing always happens on a per PCM frame basis and always assumes interleaved input and output.
+De-interleaved processing is not supported. To process frames, use
+`ma_data_converter_process_pcm_frames()`. On input, this function takes the number of output frames
+you can fit in the output buffer and the number of input frames contained in the input buffer. On
+output these variables contain the number of output frames that were written to the output buffer
+and the number of input frames that were consumed in the process. You can pass in NULL for the
+input buffer in which case it will be treated as an infinitely large
+buffer of zeros. The output buffer can also be NULL, in which case the processing will be treated
+as seek.
+
+Sometimes it's useful to know exactly how many input frames will be required to output a specific
+number of frames. You can calculate this with `ma_data_converter_get_required_input_frame_count()`.
+Likewise, it's sometimes useful to know exactly how many frames would be output given a certain
+number of input frames. You can do this with `ma_data_converter_get_expected_output_frame_count()`.
+
+Due to the nature of how resampling works, the data converter introduces some latency if resampling
+is required. This can be retrieved in terms of both the input rate and the output rate with
+`ma_data_converter_get_input_latency()` and `ma_data_converter_get_output_latency()`.
+
+
+
+11. Filtering
+=============
+
+11.1. Biquad Filtering
+----------------------
+Biquad filtering is achieved with the `ma_biquad` API. Example:
+
+    ```c
+    ma_biquad_config config = ma_biquad_config_init(ma_format_f32, channels, b0, b1, b2, a0, a1, a2);
+    ma_result result = ma_biquad_init(&config, &biquad);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    ...
+
+    ma_biquad_process_pcm_frames(&biquad, pFramesOut, pFramesIn, frameCount);
+    ```
+
+Biquad filtering is implemented using transposed direct form 2. The numerator coefficients are b0,
+b1 and b2, and the denominator coefficients are a0, a1 and a2. The a0 coefficient is required and
+coefficients must not be pre-normalized.
+
+Supported formats are `ma_format_s16` and `ma_format_f32`. If you need to use a different format
+you need to convert it yourself beforehand. When using `ma_format_s16` the biquad filter will use
+fixed point arithmetic. When using `ma_format_f32`, floating point arithmetic will be used.
+
+Input and output frames are always interleaved.
+
+Filtering can be applied in-place by passing in the same pointer for both the input and output
+buffers, like so:
+
+    ```c
+    ma_biquad_process_pcm_frames(&biquad, pMyData, pMyData, frameCount);
+    ```
+
+If you need to change the values of the coefficients, but maintain the values in the registers you
+can do so with `ma_biquad_reinit()`. This is useful if you need to change the properties of the
+filter while keeping the values of registers valid to avoid glitching. Do not use
+`ma_biquad_init()` for this as it will do a full initialization which involves clearing the
+registers to 0. Note that changing the format or channel count after initialization is invalid and
+will result in an error.
+
+
+11.2. Low-Pass Filtering
+------------------------
+Low-pass filtering is achieved with the following APIs:
+
+    +---------+------------------------------------------+
+    | API     | Description                              |
+    +---------+------------------------------------------+
+    | ma_lpf1 | First order low-pass filter              |
+    | ma_lpf2 | Second order low-pass filter             |
+    | ma_lpf  | High order low-pass filter (Butterworth) |
+    +---------+------------------------------------------+
+
+Low-pass filter example:
+
+    ```c
+    ma_lpf_config config = ma_lpf_config_init(ma_format_f32, channels, sampleRate, cutoffFrequency, order);
+    ma_result result = ma_lpf_init(&config, &lpf);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    ...
+
+    ma_lpf_process_pcm_frames(&lpf, pFramesOut, pFramesIn, frameCount);
+    ```
+
+Supported formats are `ma_format_s16` and` ma_format_f32`. If you need to use a different format
+you need to convert it yourself beforehand. Input and output frames are always interleaved.
+
+Filtering can be applied in-place by passing in the same pointer for both the input and output
+buffers, like so:
+
+    ```c
+    ma_lpf_process_pcm_frames(&lpf, pMyData, pMyData, frameCount);
+    ```
+
+The maximum filter order is limited to `MA_MAX_FILTER_ORDER` which is set to 8. If you need more,
+you can chain first and second order filters together.
+
+    ```c
+    for (iFilter = 0; iFilter < filterCount; iFilter += 1) {
+        ma_lpf2_process_pcm_frames(&lpf2[iFilter], pMyData, pMyData, frameCount);
+    }
+    ```
+
+If you need to change the configuration of the filter, but need to maintain the state of internal
+registers you can do so with `ma_lpf_reinit()`. This may be useful if you need to change the sample
+rate and/or cutoff frequency dynamically while maintaining smooth transitions. Note that changing the
+format or channel count after initialization is invalid and will result in an error.
+
+The `ma_lpf` object supports a configurable order, but if you only need a first order filter you
+may want to consider using `ma_lpf1`. Likewise, if you only need a second order filter you can use
+`ma_lpf2`. The advantage of this is that they're lighter weight and a bit more efficient.
+
+If an even filter order is specified, a series of second order filters will be processed in a
+chain. If an odd filter order is specified, a first order filter will be applied, followed by a
+series of second order filters in a chain.
+
+
+11.3. High-Pass Filtering
+-------------------------
+High-pass filtering is achieved with the following APIs:
+
+    +---------+-------------------------------------------+
+    | API     | Description                               |
+    +---------+-------------------------------------------+
+    | ma_hpf1 | First order high-pass filter              |
+    | ma_hpf2 | Second order high-pass filter             |
+    | ma_hpf  | High order high-pass filter (Butterworth) |
+    +---------+-------------------------------------------+
+
+High-pass filters work exactly the same as low-pass filters, only the APIs are called `ma_hpf1`,
+`ma_hpf2` and `ma_hpf`. See example code for low-pass filters for example usage.
+
+
+11.4. Band-Pass Filtering
+-------------------------
+Band-pass filtering is achieved with the following APIs:
+
+    +---------+-------------------------------+
+    | API     | Description                   |
+    +---------+-------------------------------+
+    | ma_bpf2 | Second order band-pass filter |
+    | ma_bpf  | High order band-pass filter   |
+    +---------+-------------------------------+
+
+Band-pass filters work exactly the same as low-pass filters, only the APIs are called `ma_bpf2` and
+`ma_hpf`. See example code for low-pass filters for example usage. Note that the order for
+band-pass filters must be an even number which means there is no first order band-pass filter,
+unlike low-pass and high-pass filters.
+
+
+11.5. Notch Filtering
+---------------------
+Notch filtering is achieved with the following APIs:
+
+    +-----------+------------------------------------------+
+    | API       | Description                              |
+    +-----------+------------------------------------------+
+    | ma_notch2 | Second order notching filter             |
+    +-----------+------------------------------------------+
+
+
+11.6. Peaking EQ Filtering
+-------------------------
+Peaking filtering is achieved with the following APIs:
+
+    +----------+------------------------------------------+
+    | API      | Description                              |
+    +----------+------------------------------------------+
+    | ma_peak2 | Second order peaking filter              |
+    +----------+------------------------------------------+
+
+
+11.7. Low Shelf Filtering
+-------------------------
+Low shelf filtering is achieved with the following APIs:
+
+    +-------------+------------------------------------------+
+    | API         | Description                              |
+    +-------------+------------------------------------------+
+    | ma_loshelf2 | Second order low shelf filter            |
+    +-------------+------------------------------------------+
+
+Where a high-pass filter is used to eliminate lower frequencies, a low shelf filter can be used to
+just turn them down rather than eliminate them entirely.
+
+
+11.8. High Shelf Filtering
+--------------------------
+High shelf filtering is achieved with the following APIs:
+
+    +-------------+------------------------------------------+
+    | API         | Description                              |
+    +-------------+------------------------------------------+
+    | ma_hishelf2 | Second order high shelf filter           |
+    +-------------+------------------------------------------+
+
+The high shelf filter has the same API as the low shelf filter, only you would use `ma_hishelf`
+instead of `ma_loshelf`. Where a low shelf filter is used to adjust the volume of low frequencies,
+the high shelf filter does the same thing for high frequencies.
+
+
+
+
+12. Waveform and Noise Generation
+=================================
+
+12.1. Waveforms
+---------------
+miniaudio supports generation of sine, square, triangle and sawtooth waveforms. This is achieved
+with the `ma_waveform` API. Example:
+
+    ```c
+    ma_waveform_config config = ma_waveform_config_init(
+        FORMAT,
+        CHANNELS,
+        SAMPLE_RATE,
+        ma_waveform_type_sine,
+        amplitude,
+        frequency);
+
+    ma_waveform waveform;
+    ma_result result = ma_waveform_init(&config, &waveform);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    ...
+
+    ma_waveform_read_pcm_frames(&waveform, pOutput, frameCount);
+    ```
+
+The amplitude, frequency, type, and sample rate can be changed dynamically with
+`ma_waveform_set_amplitude()`, `ma_waveform_set_frequency()`, `ma_waveform_set_type()`, and
+`ma_waveform_set_sample_rate()` respectively.
+
+You can invert the waveform by setting the amplitude to a negative value. You can use this to
+control whether or not a sawtooth has a positive or negative ramp, for example.
+
+Below are the supported waveform types:
+
+    +---------------------------+
+    | Enum Name                 |
+    +---------------------------+
+    | ma_waveform_type_sine     |
+    | ma_waveform_type_square   |
+    | ma_waveform_type_triangle |
+    | ma_waveform_type_sawtooth |
+    +---------------------------+
+
+
+
+12.2. Noise
+-----------
+miniaudio supports generation of white, pink and Brownian noise via the `ma_noise` API. Example:
+
+    ```c
+    ma_noise_config config = ma_noise_config_init(
+        FORMAT,
+        CHANNELS,
+        ma_noise_type_white,
+        SEED,
+        amplitude);
+
+    ma_noise noise;
+    ma_result result = ma_noise_init(&config, &noise);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    ...
+
+    ma_noise_read_pcm_frames(&noise, pOutput, frameCount);
+    ```
+
+The noise API uses simple LCG random number generation. It supports a custom seed which is useful
+for things like automated testing requiring reproducibility. Setting the seed to zero will default
+to `MA_DEFAULT_LCG_SEED`.
+
+The amplitude and seed can be changed dynamically with `ma_noise_set_amplitude()` and
+`ma_noise_set_seed()` respectively.
+
+By default, the noise API will use different values for different channels. So, for example, the
+left side in a stereo stream will be different to the right side. To instead have each channel use
+the same random value, set the `duplicateChannels` member of the noise config to true, like so:
+
+    ```c
+    config.duplicateChannels = MA_TRUE;
+    ```
+
+Below are the supported noise types.
+
+    +------------------------+
+    | Enum Name              |
+    +------------------------+
+    | ma_noise_type_white    |
+    | ma_noise_type_pink     |
+    | ma_noise_type_brownian |
+    +------------------------+
+
+
+
+13. Audio Buffers
+=================
+miniaudio supports reading from a buffer of raw audio data via the `ma_audio_buffer` API. This can
+read from memory that's managed by the application, but can also handle the memory management for
+you internally. Memory management is flexible and should support most use cases.
+
+Audio buffers are initialized using the standard configuration system used everywhere in miniaudio:
+
+    ```c
+    ma_audio_buffer_config config = ma_audio_buffer_config_init(
+        format,
+        channels,
+        sizeInFrames,
+        pExistingData,
+        &allocationCallbacks);
+
+    ma_audio_buffer buffer;
+    result = ma_audio_buffer_init(&config, &buffer);
+    if (result != MA_SUCCESS) {
+        // Error.
+    }
+
+    ...
+
+    ma_audio_buffer_uninit(&buffer);
+    ```
+
+In the example above, the memory pointed to by `pExistingData` will *not* be copied and is how an
+application can do self-managed memory allocation. If you would rather make a copy of the data, use
+`ma_audio_buffer_init_copy()`. To uninitialize the buffer, use `ma_audio_buffer_uninit()`.
+
+Sometimes it can be convenient to allocate the memory for the `ma_audio_buffer` structure and the
+raw audio data in a contiguous block of memory. That is, the raw audio data will be located
+immediately after the `ma_audio_buffer` structure. To do this, use
+`ma_audio_buffer_alloc_and_init()`:
+
+    ```c
+    ma_audio_buffer_config config = ma_audio_buffer_config_init(
+        format,
+        channels,
+        sizeInFrames,
+        pExistingData,
+        &allocationCallbacks);
+
+    ma_audio_buffer* pBuffer
+    result = ma_audio_buffer_alloc_and_init(&config, &pBuffer);
+    if (result != MA_SUCCESS) {
+        // Error
+    }
+
+    ...
+
+    ma_audio_buffer_uninit_and_free(&buffer);
+    ```
+
+If you initialize the buffer with `ma_audio_buffer_alloc_and_init()` you should uninitialize it
+with `ma_audio_buffer_uninit_and_free()`. In the example above, the memory pointed to by
+`pExistingData` will be copied into the buffer, which is contrary to the behavior of
+`ma_audio_buffer_init()`.
+
+An audio buffer has a playback cursor just like a decoder. As you read frames from the buffer, the
+cursor moves forward. The last parameter (`loop`) can be used to determine if the buffer should
+loop. The return value is the number of frames actually read. If this is less than the number of
+frames requested it means the end has been reached. This should never happen if the `loop`
+parameter is set to true. If you want to manually loop back to the start, you can do so with with
+`ma_audio_buffer_seek_to_pcm_frame(pAudioBuffer, 0)`. Below is an example for reading data from an
+audio buffer.
+
+    ```c
+    ma_uint64 framesRead = ma_audio_buffer_read_pcm_frames(pAudioBuffer, pFramesOut, desiredFrameCount, isLooping);
+    if (framesRead < desiredFrameCount) {
+        // If not looping, this means the end has been reached. This should never happen in looping mode with valid input.
+    }
+    ```
+
+Sometimes you may want to avoid the cost of data movement between the internal buffer and the
+output buffer. Instead you can use memory mapping to retrieve a pointer to a segment of data:
+
+    ```c
+    void* pMappedFrames;
+    ma_uint64 frameCount = frameCountToTryMapping;
+    ma_result result = ma_audio_buffer_map(pAudioBuffer, &pMappedFrames, &frameCount);
+    if (result == MA_SUCCESS) {
+        // Map was successful. The value in frameCount will be how many frames were _actually_ mapped, which may be
+        // less due to the end of the buffer being reached.
+        ma_copy_pcm_frames(pFramesOut, pMappedFrames, frameCount, pAudioBuffer->format, pAudioBuffer->channels);
+
+        // You must unmap the buffer.
+        ma_audio_buffer_unmap(pAudioBuffer, frameCount);
+    }
+    ```
+
+When you use memory mapping, the read cursor is increment by the frame count passed in to
+`ma_audio_buffer_unmap()`. If you decide not to process every frame you can pass in a value smaller
+than the value returned by `ma_audio_buffer_map()`. The disadvantage to using memory mapping is
+that it does not handle looping for you. You can determine if the buffer is at the end for the
+purpose of looping with `ma_audio_buffer_at_end()` or by inspecting the return value of
+`ma_audio_buffer_unmap()` and checking if it equals `MA_AT_END`. You should not treat `MA_AT_END`
+as an error when returned by `ma_audio_buffer_unmap()`.
+
+
+
+14. Ring Buffers
+================
+miniaudio supports lock free (single producer, single consumer) ring buffers which are exposed via
+the `ma_rb` and `ma_pcm_rb` APIs. The `ma_rb` API operates on bytes, whereas the `ma_pcm_rb`
+operates on PCM frames. They are otherwise identical as `ma_pcm_rb` is just a wrapper around
+`ma_rb`.
+
+Unlike most other APIs in miniaudio, ring buffers support both interleaved and deinterleaved
+streams. The caller can also allocate their own backing memory for the ring buffer to use
+internally for added flexibility. Otherwise the ring buffer will manage it's internal memory for
+you.
+
+The examples below use the PCM frame variant of the ring buffer since that's most likely the one
+you will want to use. To initialize a ring buffer, do something like the following:
+
+    ```c
+    ma_pcm_rb rb;
+    ma_result result = ma_pcm_rb_init(FORMAT, CHANNELS, BUFFER_SIZE_IN_FRAMES, NULL, NULL, &rb);
+    if (result != MA_SUCCESS) {
+        // Error
+    }
+    ```
+
+The `ma_pcm_rb_init()` function takes the sample format and channel count as parameters because
+it's the PCM variant of the ring buffer API. For the regular ring buffer that operates on bytes you
+would call `ma_rb_init()` which leaves these out and just takes the size of the buffer in bytes
+instead of frames. The fourth parameter is an optional pre-allocated buffer and the fifth parameter
+is a pointer to a `ma_allocation_callbacks` structure for custom memory allocation routines.
+Passing in `NULL` for this results in `MA_MALLOC()` and `MA_FREE()` being used.
+
+Use `ma_pcm_rb_init_ex()` if you need a deinterleaved buffer. The data for each sub-buffer is
+offset from each other based on the stride. To manage your sub-buffers you can use
+`ma_pcm_rb_get_subbuffer_stride()`, `ma_pcm_rb_get_subbuffer_offset()` and
+`ma_pcm_rb_get_subbuffer_ptr()`.
+
+Use `ma_pcm_rb_acquire_read()` and `ma_pcm_rb_acquire_write()` to retrieve a pointer to a section
+of the ring buffer. You specify the number of frames you need, and on output it will set to what
+was actually acquired. If the read or write pointer is positioned such that the number of frames
+requested will require a loop, it will be clamped to the end of the buffer. Therefore, the number
+of frames you're given may be less than the number you requested.
+
+After calling `ma_pcm_rb_acquire_read()` or `ma_pcm_rb_acquire_write()`, you do your work on the
+buffer and then "commit" it with `ma_pcm_rb_commit_read()` or `ma_pcm_rb_commit_write()`. This is
+where the read/write pointers are updated. When you commit you need to pass in the buffer that was
+returned by the earlier call to `ma_pcm_rb_acquire_read()` or `ma_pcm_rb_acquire_write()` and is
+only used for validation. The number of frames passed to `ma_pcm_rb_commit_read()` and
+`ma_pcm_rb_commit_write()` is what's used to increment the pointers, and can be less that what was
+originally requested.
+
+If you want to correct for drift between the write pointer and the read pointer you can use a
+combination of `ma_pcm_rb_pointer_distance()`, `ma_pcm_rb_seek_read()` and
+`ma_pcm_rb_seek_write()`. Note that you can only move the pointers forward, and you should only
+move the read pointer forward via the consumer thread, and the write pointer forward by the
+producer thread. If there is too much space between the pointers, move the read pointer forward. If
+there is too little space between the pointers, move the write pointer forward.
+
+You can use a ring buffer at the byte level instead of the PCM frame level by using the `ma_rb`
+API. This is exactly the same, only you will use the `ma_rb` functions instead of `ma_pcm_rb` and
+instead of frame counts you will pass around byte counts.
+
+The maximum size of the buffer in bytes is `0x7FFFFFFF-(MA_SIMD_ALIGNMENT-1)` due to the most
+significant bit being used to encode a loop flag and the internally managed buffers always being
+aligned to `MA_SIMD_ALIGNMENT`.
+
+Note that the ring buffer is only thread safe when used by a single consumer thread and single
+producer thread.
+
+
+
+15. Backends
+============
+The following backends are supported by miniaudio. These are listed in order of default priority.
+When no backend is specified when initializing a context or device, miniaudio will attempt to use
+each of these backends in the order listed in the table below.
+
+Note that backends that are not usable by the build target will not be included in the build. For
+example, ALSA, which is specific to Linux, will not be included in the Windows build.
+
+    +-------------+-----------------------+--------------------------------------------------------+
+    | Name        | Enum Name             | Supported Operating Systems                            |
+    +-------------+-----------------------+--------------------------------------------------------+
+    | WASAPI      | ma_backend_wasapi     | Windows Vista+                                         |
+    | DirectSound | ma_backend_dsound     | Windows XP+                                            |
+    | WinMM       | ma_backend_winmm      | Windows 95+                                            |
+    | Core Audio  | ma_backend_coreaudio  | macOS, iOS                                             |
+    | sndio       | ma_backend_sndio      | OpenBSD                                                |
+    | audio(4)    | ma_backend_audio4     | NetBSD, OpenBSD                                        |
+    | OSS         | ma_backend_oss        | FreeBSD                                                |
+    | PulseAudio  | ma_backend_pulseaudio | Cross Platform (disabled on Windows, BSD and Android)  |
+    | ALSA        | ma_backend_alsa       | Linux                                                  |
+    | JACK        | ma_backend_jack       | Cross Platform (disabled on BSD and Android)           |
+    | AAudio      | ma_backend_aaudio     | Android 8+                                             |
+    | OpenSL ES   | ma_backend_opensl     | Android (API level 16+)                                |
+    | Web Audio   | ma_backend_webaudio   | Web (via Emscripten)                                   |
+    | Custom      | ma_backend_custom     | Cross Platform                                         |
+    | Null        | ma_backend_null       | Cross Platform (not used on Web)                       |
+    +-------------+-----------------------+--------------------------------------------------------+
+
+Some backends have some nuance details you may want to be aware of.
+
+15.1. WASAPI
+------------
+- Low-latency shared mode will be disabled when using an application-defined sample rate which is
+  different to the device's native sample rate. To work around this, set `wasapi.noAutoConvertSRC`
+  to true in the device config. This is due to IAudioClient3_InitializeSharedAudioStream() failing
+  when the `AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM` flag is specified. Setting wasapi.noAutoConvertSRC
+  will result in miniaudio's internal resampler being used instead which will in turn enable the
+  use of low-latency shared mode.
+
+15.2. PulseAudio
+----------------
+- If you experience bad glitching/noise on Arch Linux, consider this fix from the Arch wiki:
+  https://wiki.archlinux.org/index.php/PulseAudio/Troubleshooting#Glitches,_skips_or_crackling.
+  Alternatively, consider using a different backend such as ALSA.
+
+15.3. Android
+-------------
+- To capture audio on Android, remember to add the RECORD_AUDIO permission to your manifest:
+  `<uses-permission android:name="android.permission.RECORD_AUDIO" />`
+- With OpenSL|ES, only a single ma_context can be active at any given time. This is due to a
+  limitation with OpenSL|ES.
+- With AAudio, only default devices are enumerated. This is due to AAudio not having an enumeration
+  API (devices are enumerated through Java). You can however perform your own device enumeration
+  through Java and then set the ID in the ma_device_id structure (ma_device_id.aaudio) and pass it
+  to ma_device_init().
+- The backend API will perform resampling where possible. The reason for this as opposed to using
+  miniaudio's built-in resampler is to take advantage of any potential device-specific
+  optimizations the driver may implement.
+
+BSD
+---
+- The sndio backend is currently only enabled on OpenBSD builds.
+- The audio(4) backend is supported on OpenBSD, but you may need to disable sndiod before you can
+  use it.
+
+15.4. UWP
+---------
+- UWP only supports default playback and capture devices.
+- UWP requires the Microphone capability to be enabled in the application's manifest (Package.appxmanifest):
+
+    ```
+    <Package ...>
+        ...
+        <Capabilities>
+            <DeviceCapability Name="microphone" />
+        </Capabilities>
+    </Package>
+    ```
+
+15.5. Web Audio / Emscripten
+----------------------------
+- You cannot use `-std=c*` compiler flags, nor `-ansi`. This only applies to the Emscripten build.
+- The first time a context is initialized it will create a global object called "miniaudio" whose
+  primary purpose is to act as a factory for device objects.
+- Currently the Web Audio backend uses ScriptProcessorNode's, but this may need to change later as
+  they've been deprecated.
+- Google has implemented a policy in their browsers that prevent automatic media output without
+  first receiving some kind of user input. The following web page has additional details:
+  https://developers.google.com/web/updates/2017/09/autoplay-policy-changes. Starting the device
+  may fail if you try to start playback without first handling some kind of user input.
+
+
+
+16. Optimization Tips
+=====================
+See below for some tips on improving performance.
+
+16.1. Low Level API
+-------------------
+- In the data callback, if your data is already clipped prior to copying it into the output buffer,
+  set the `noClip` config option in the device config to true. This will disable miniaudio's built
+  in clipping function.
+- By default, miniaudio will pre-silence the data callback's output buffer. If you know that you
+  will always write valid data to the output buffer you can disable pre-silencing by setting the
+  `noPreSilence` config option in the device config to true.
+
+16.2. High Level API
+--------------------
+- If a sound does not require doppler or pitch shifting, consider disabling pitching by
+  initializing the sound with the `MA_SOUND_FLAG_NO_PITCH` flag.
+- If a sound does not require spatialization, disable it by initializing the sound with the
+  `MA_SOUND_FLAG_NO_SPATIALIZATION` flag. It can be re-enabled again post-initialization with
+  `ma_sound_set_spatialization_enabled()`.
+- If you know all of your sounds will always be the same sample rate, set the engine's sample
+  rate to match that of the sounds. Likewise, if you're using a self-managed resource manager,
+  consider setting the decoded sample rate to match your sounds. By configuring everything to
+  use a consistent sample rate, sample rate conversion can be avoided.
+
+
+
+17. Miscellaneous Notes
+=======================
+- Automatic stream routing is enabled on a per-backend basis. Support is explicitly enabled for
+  WASAPI and Core Audio, however other backends such as PulseAudio may naturally support it, though
+  not all have been tested.
+- When compiling with VC6 and earlier, decoding is restricted to files less than 2GB in size. This
+  is due to 64-bit file APIs not being available.
+*/
+
+#ifndef miniaudio_h
+#define miniaudio_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MA_STRINGIFY(x)     #x
+#define MA_XSTRINGIFY(x)    MA_STRINGIFY(x)
+
+#define MA_VERSION_MAJOR    0
+#define MA_VERSION_MINOR    11
+#define MA_VERSION_REVISION 21
+#define MA_VERSION_STRING   MA_XSTRINGIFY(MA_VERSION_MAJOR) "." MA_XSTRINGIFY(MA_VERSION_MINOR) "." MA_XSTRINGIFY(MA_VERSION_REVISION)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(push)
+    #pragma warning(disable:4201)   /* nonstandard extension used: nameless struct/union */
+    #pragma warning(disable:4214)   /* nonstandard extension used: bit field types other than int */
+    #pragma warning(disable:4324)   /* structure was padded due to alignment specifier */
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wpedantic" /* For ISO C99 doesn't support unnamed structs/unions [-Wpedantic] */
+    #if defined(__clang__)
+        #pragma GCC diagnostic ignored "-Wc11-extensions"   /* anonymous unions are a C11 extension */
+    #endif
+#endif
+
+
+
+#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(_M_ARM64) || defined(__powerpc64__)
+    #define MA_SIZEOF_PTR   8
+#else
+    #define MA_SIZEOF_PTR   4
+#endif
+
+#include <stddef.h> /* For size_t. */
+
+/* Sized types. */
+#if defined(MA_USE_STDINT)
+    #include <stdint.h>
+    typedef int8_t   ma_int8;
+    typedef uint8_t  ma_uint8;
+    typedef int16_t  ma_int16;
+    typedef uint16_t ma_uint16;
+    typedef int32_t  ma_int32;
+    typedef uint32_t ma_uint32;
+    typedef int64_t  ma_int64;
+    typedef uint64_t ma_uint64;
+#else
+    typedef   signed char           ma_int8;
+    typedef unsigned char           ma_uint8;
+    typedef   signed short          ma_int16;
+    typedef unsigned short          ma_uint16;
+    typedef   signed int            ma_int32;
+    typedef unsigned int            ma_uint32;
+    #if defined(_MSC_VER) && !defined(__clang__)
+        typedef   signed __int64    ma_int64;
+        typedef unsigned __int64    ma_uint64;
+    #else
+        #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+            #pragma GCC diagnostic push
+            #pragma GCC diagnostic ignored "-Wlong-long"
+            #if defined(__clang__)
+                #pragma GCC diagnostic ignored "-Wc++11-long-long"
+            #endif
+        #endif
+        typedef   signed long long  ma_int64;
+        typedef unsigned long long  ma_uint64;
+        #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+            #pragma GCC diagnostic pop
+        #endif
+    #endif
+#endif  /* MA_USE_STDINT */
+
+#if MA_SIZEOF_PTR == 8
+    typedef ma_uint64           ma_uintptr;
+#else
+    typedef ma_uint32           ma_uintptr;
+#endif
+
+typedef ma_uint8    ma_bool8;
+typedef ma_uint32   ma_bool32;
+#define MA_TRUE     1
+#define MA_FALSE    0
+
+/* These float types are not used universally by miniaudio. It's to simplify some macro expansion for atomic types. */
+typedef float       ma_float;
+typedef double      ma_double;
+
+typedef void* ma_handle;
+typedef void* ma_ptr;
+
+/*
+ma_proc is annoying because when compiling with GCC we get pendantic warnings about converting
+between `void*` and `void (*)()`. We can't use `void (*)()` with MSVC however, because we'll get
+warning C4191 about "type cast between incompatible function types". To work around this I'm going
+to use a different data type depending on the compiler.
+*/
+#if defined(__GNUC__)
+typedef void (*ma_proc)(void);
+#else
+typedef void* ma_proc;
+#endif
+
+#if defined(_MSC_VER) && !defined(_WCHAR_T_DEFINED)
+typedef ma_uint16 wchar_t;
+#endif
+
+/* Define NULL for some compilers. */
+#ifndef NULL
+#define NULL 0
+#endif
+
+#if defined(SIZE_MAX)
+    #define MA_SIZE_MAX    SIZE_MAX
+#else
+    #define MA_SIZE_MAX    0xFFFFFFFF  /* When SIZE_MAX is not defined by the standard library just default to the maximum 32-bit unsigned integer. */
+#endif
+
+
+/* Platform/backend detection. */
+#if defined(_WIN32) || defined(__COSMOPOLITAN__)
+    #define MA_WIN32
+    #if defined(MA_FORCE_UWP) || (defined(WINAPI_FAMILY) && ((defined(WINAPI_FAMILY_PC_APP) && WINAPI_FAMILY == WINAPI_FAMILY_PC_APP) || (defined(WINAPI_FAMILY_PHONE_APP) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)))
+        #define MA_WIN32_UWP
+    #elif defined(WINAPI_FAMILY) && (defined(WINAPI_FAMILY_GAMES) && WINAPI_FAMILY == WINAPI_FAMILY_GAMES)
+        #define MA_WIN32_GDK
+    #else
+        #define MA_WIN32_DESKTOP
+    #endif
+#endif
+#if !defined(_WIN32)    /* If it's not Win32, assume POSIX. */
+    #define MA_POSIX
+
+    /*
+    Use the MA_NO_PTHREAD_IN_HEADER option at your own risk. This is intentionally undocumented.
+    You can use this to avoid including pthread.h in the header section. The downside is that it
+    results in some fixed sized structures being declared for the various types that are used in
+    miniaudio. The risk here is that these types might be too small for a given platform. This
+    risk is yours to take and no support will be offered if you enable this option.
+    */
+    #ifndef MA_NO_PTHREAD_IN_HEADER
+        #include <pthread.h>    /* Unfortunate #include, but needed for pthread_t, pthread_mutex_t and pthread_cond_t types. */
+        typedef pthread_t       ma_pthread_t;
+        typedef pthread_mutex_t ma_pthread_mutex_t;
+        typedef pthread_cond_t  ma_pthread_cond_t;
+    #else
+        typedef ma_uintptr      ma_pthread_t;
+        typedef union           ma_pthread_mutex_t { char __data[40]; ma_uint64 __alignment; } ma_pthread_mutex_t;
+        typedef union           ma_pthread_cond_t  { char __data[48]; ma_uint64 __alignment; } ma_pthread_cond_t;
+    #endif
+
+    #if defined(__unix__)
+        #define MA_UNIX
+    #endif
+    #if defined(__linux__)
+        #define MA_LINUX
+    #endif
+    #if defined(__APPLE__)
+        #define MA_APPLE
+    #endif
+    #if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+        #define MA_BSD
+    #endif
+    #if defined(__ANDROID__)
+        #define MA_ANDROID
+    #endif
+    #if defined(__EMSCRIPTEN__)
+        #define MA_EMSCRIPTEN
+    #endif
+    #if defined(__ORBIS__)
+        #define MA_ORBIS
+    #endif
+    #if defined(__PROSPERO__)
+        #define MA_PROSPERO
+    #endif
+    #if defined(__NX__)
+        #define MA_NX
+    #endif
+    #if defined(__BEOS__) || defined(__HAIKU__)
+        #define MA_BEOS
+    #endif
+    #if defined(__HAIKU__)
+        #define MA_HAIKU
+    #endif
+#endif
+
+#if defined(__has_c_attribute)
+    #if __has_c_attribute(fallthrough)
+        #define MA_FALLTHROUGH [[fallthrough]]
+    #endif
+#endif
+#if !defined(MA_FALLTHROUGH) && defined(__has_attribute) && (defined(__clang__) || defined(__GNUC__))
+    #if __has_attribute(fallthrough)
+        #define MA_FALLTHROUGH __attribute__((fallthrough))
+    #endif
+#endif
+#if !defined(MA_FALLTHROUGH)
+    #define MA_FALLTHROUGH ((void)0)
+#endif
+
+#ifdef _MSC_VER
+    #define MA_INLINE __forceinline
+
+    /* noinline was introduced in Visual Studio 2005. */
+    #if _MSC_VER >= 1400
+        #define MA_NO_INLINE __declspec(noinline)
+    #else
+        #define MA_NO_INLINE
+    #endif
+#elif defined(__GNUC__)
+    /*
+    I've had a bug report where GCC is emitting warnings about functions possibly not being inlineable. This warning happens when
+    the __attribute__((always_inline)) attribute is defined without an "inline" statement. I think therefore there must be some
+    case where "__inline__" is not always defined, thus the compiler emitting these warnings. When using -std=c89 or -ansi on the
+    command line, we cannot use the "inline" keyword and instead need to use "__inline__". In an attempt to work around this issue
+    I am using "__inline__" only when we're compiling in strict ANSI mode.
+    */
+    #if defined(__STRICT_ANSI__)
+        #define MA_GNUC_INLINE_HINT __inline__
+    #else
+        #define MA_GNUC_INLINE_HINT inline
+    #endif
+
+    #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2)) || defined(__clang__)
+        #define MA_INLINE MA_GNUC_INLINE_HINT __attribute__((always_inline))
+        #define MA_NO_INLINE __attribute__((noinline))
+    #else
+        #define MA_INLINE MA_GNUC_INLINE_HINT
+        #define MA_NO_INLINE __attribute__((noinline))
+    #endif
+#elif defined(__WATCOMC__)
+    #define MA_INLINE __inline
+    #define MA_NO_INLINE
+#else
+    #define MA_INLINE
+    #define MA_NO_INLINE
+#endif
+
+/* MA_DLL is not officially supported. You're on your own if you want to use this. */
+#if defined(MA_DLL)
+    #if defined(_WIN32)
+        #define MA_DLL_IMPORT  __declspec(dllimport)
+        #define MA_DLL_EXPORT  __declspec(dllexport)
+        #define MA_DLL_PRIVATE static
+    #else
+        #if defined(__GNUC__) && __GNUC__ >= 4
+            #define MA_DLL_IMPORT  __attribute__((visibility("default")))
+            #define MA_DLL_EXPORT  __attribute__((visibility("default")))
+            #define MA_DLL_PRIVATE __attribute__((visibility("hidden")))
+        #else
+            #define MA_DLL_IMPORT
+            #define MA_DLL_EXPORT
+            #define MA_DLL_PRIVATE static
+        #endif
+    #endif
+#endif
+
+#if !defined(MA_API)
+    #if defined(MA_DLL)
+        #if defined(MINIAUDIO_IMPLEMENTATION) || defined(MA_IMPLEMENTATION)
+            #define MA_API  MA_DLL_EXPORT
+        #else
+            #define MA_API  MA_DLL_IMPORT
+        #endif
+    #else
+        #define MA_API extern
+    #endif
+#endif
+
+#if !defined(MA_STATIC)
+    #if defined(MA_DLL)
+        #define MA_PRIVATE MA_DLL_PRIVATE
+    #else
+        #define MA_PRIVATE static
+    #endif
+#endif
+
+
+/* SIMD alignment in bytes. Currently set to 32 bytes in preparation for future AVX optimizations. */
+#define MA_SIMD_ALIGNMENT  32
+
+/*
+Special wchar_t type to ensure any structures in the public sections that reference it have a
+consistent size across all platforms.
+
+On Windows, wchar_t is 2 bytes, whereas everywhere else it's 4 bytes. Since Windows likes to use
+wchar_t for it's IDs, we need a special explicitly sized wchar type that is always 2 bytes on all
+platforms.
+*/
+#if !defined(MA_POSIX) && defined(MA_WIN32)
+typedef wchar_t     ma_wchar_win32;
+#else
+typedef ma_uint16   ma_wchar_win32;
+#endif
+
+
+
+/*
+Logging Levels
+==============
+Log levels are only used to give logging callbacks some context as to the severity of a log message
+so they can do filtering. All log levels will be posted to registered logging callbacks. If you
+don't want to output a certain log level you can discriminate against the log level in the callback.
+
+MA_LOG_LEVEL_DEBUG
+    Used for debugging. Useful for debug and test builds, but should be disabled in release builds.
+
+MA_LOG_LEVEL_INFO
+    Informational logging. Useful for debugging. This will never be called from within the data
+    callback.
+
+MA_LOG_LEVEL_WARNING
+    Warnings. You should enable this in you development builds and action them when encounted. These
+    logs usually indicate a potential problem or misconfiguration, but still allow you to keep
+    running. This will never be called from within the data callback.
+
+MA_LOG_LEVEL_ERROR
+    Error logging. This will be fired when an operation fails and is subsequently aborted. This can
+    be fired from within the data callback, in which case the device will be stopped. You should
+    always have this log level enabled.
+*/
+typedef enum
+{
+    MA_LOG_LEVEL_DEBUG   = 4,
+    MA_LOG_LEVEL_INFO    = 3,
+    MA_LOG_LEVEL_WARNING = 2,
+    MA_LOG_LEVEL_ERROR   = 1
+} ma_log_level;
+
+/*
+Variables needing to be accessed atomically should be declared with this macro for two reasons:
+
+    1) It allows people who read the code to identify a variable as such; and
+    2) It forces alignment on platforms where it's required or optimal.
+
+Note that for x86/64, alignment is not strictly necessary, but does have some performance
+implications. Where supported by the compiler, alignment will be used, but otherwise if the CPU
+architecture does not require it, it will simply leave it unaligned. This is the case with old
+versions of Visual Studio, which I've confirmed with at least VC6.
+*/
+#if !defined(_MSC_VER) && defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
+    #include <stdalign.h>
+    #define MA_ATOMIC(alignment, type)            _Alignas(alignment) type
+#else
+    #if defined(__GNUC__)
+        /* GCC-style compilers. */
+        #define MA_ATOMIC(alignment, type)        type __attribute__((aligned(alignment)))
+    #elif defined(_MSC_VER) && _MSC_VER > 1200  /* 1200 = VC6. Alignment not supported, but not necessary because x86 is the only supported target. */
+        /* MSVC. */
+        #define MA_ATOMIC(alignment, type)        __declspec(align(alignment)) type
+    #else
+        /* Other compilers. */
+        #define MA_ATOMIC(alignment, type)        type
+    #endif
+#endif
+
+typedef struct ma_context ma_context;
+typedef struct ma_device ma_device;
+
+typedef ma_uint8 ma_channel;
+typedef enum
+{
+    MA_CHANNEL_NONE               = 0,
+    MA_CHANNEL_MONO               = 1,
+    MA_CHANNEL_FRONT_LEFT         = 2,
+    MA_CHANNEL_FRONT_RIGHT        = 3,
+    MA_CHANNEL_FRONT_CENTER       = 4,
+    MA_CHANNEL_LFE                = 5,
+    MA_CHANNEL_BACK_LEFT          = 6,
+    MA_CHANNEL_BACK_RIGHT         = 7,
+    MA_CHANNEL_FRONT_LEFT_CENTER  = 8,
+    MA_CHANNEL_FRONT_RIGHT_CENTER = 9,
+    MA_CHANNEL_BACK_CENTER        = 10,
+    MA_CHANNEL_SIDE_LEFT          = 11,
+    MA_CHANNEL_SIDE_RIGHT         = 12,
+    MA_CHANNEL_TOP_CENTER         = 13,
+    MA_CHANNEL_TOP_FRONT_LEFT     = 14,
+    MA_CHANNEL_TOP_FRONT_CENTER   = 15,
+    MA_CHANNEL_TOP_FRONT_RIGHT    = 16,
+    MA_CHANNEL_TOP_BACK_LEFT      = 17,
+    MA_CHANNEL_TOP_BACK_CENTER    = 18,
+    MA_CHANNEL_TOP_BACK_RIGHT     = 19,
+    MA_CHANNEL_AUX_0              = 20,
+    MA_CHANNEL_AUX_1              = 21,
+    MA_CHANNEL_AUX_2              = 22,
+    MA_CHANNEL_AUX_3              = 23,
+    MA_CHANNEL_AUX_4              = 24,
+    MA_CHANNEL_AUX_5              = 25,
+    MA_CHANNEL_AUX_6              = 26,
+    MA_CHANNEL_AUX_7              = 27,
+    MA_CHANNEL_AUX_8              = 28,
+    MA_CHANNEL_AUX_9              = 29,
+    MA_CHANNEL_AUX_10             = 30,
+    MA_CHANNEL_AUX_11             = 31,
+    MA_CHANNEL_AUX_12             = 32,
+    MA_CHANNEL_AUX_13             = 33,
+    MA_CHANNEL_AUX_14             = 34,
+    MA_CHANNEL_AUX_15             = 35,
+    MA_CHANNEL_AUX_16             = 36,
+    MA_CHANNEL_AUX_17             = 37,
+    MA_CHANNEL_AUX_18             = 38,
+    MA_CHANNEL_AUX_19             = 39,
+    MA_CHANNEL_AUX_20             = 40,
+    MA_CHANNEL_AUX_21             = 41,
+    MA_CHANNEL_AUX_22             = 42,
+    MA_CHANNEL_AUX_23             = 43,
+    MA_CHANNEL_AUX_24             = 44,
+    MA_CHANNEL_AUX_25             = 45,
+    MA_CHANNEL_AUX_26             = 46,
+    MA_CHANNEL_AUX_27             = 47,
+    MA_CHANNEL_AUX_28             = 48,
+    MA_CHANNEL_AUX_29             = 49,
+    MA_CHANNEL_AUX_30             = 50,
+    MA_CHANNEL_AUX_31             = 51,
+    MA_CHANNEL_LEFT               = MA_CHANNEL_FRONT_LEFT,
+    MA_CHANNEL_RIGHT              = MA_CHANNEL_FRONT_RIGHT,
+    MA_CHANNEL_POSITION_COUNT     = (MA_CHANNEL_AUX_31 + 1)
+} _ma_channel_position; /* Do not use `_ma_channel_position` directly. Use `ma_channel` instead. */
+
+typedef enum
+{
+    MA_SUCCESS                        =  0,
+    MA_ERROR                          = -1,  /* A generic error. */
+    MA_INVALID_ARGS                   = -2,
+    MA_INVALID_OPERATION              = -3,
+    MA_OUT_OF_MEMORY                  = -4,
+    MA_OUT_OF_RANGE                   = -5,
+    MA_ACCESS_DENIED                  = -6,
+    MA_DOES_NOT_EXIST                 = -7,
+    MA_ALREADY_EXISTS                 = -8,
+    MA_TOO_MANY_OPEN_FILES            = -9,
+    MA_INVALID_FILE                   = -10,
+    MA_TOO_BIG                        = -11,
+    MA_PATH_TOO_LONG                  = -12,
+    MA_NAME_TOO_LONG                  = -13,
+    MA_NOT_DIRECTORY                  = -14,
+    MA_IS_DIRECTORY                   = -15,
+    MA_DIRECTORY_NOT_EMPTY            = -16,
+    MA_AT_END                         = -17,
+    MA_NO_SPACE                       = -18,
+    MA_BUSY                           = -19,
+    MA_IO_ERROR                       = -20,
+    MA_INTERRUPT                      = -21,
+    MA_UNAVAILABLE                    = -22,
+    MA_ALREADY_IN_USE                 = -23,
+    MA_BAD_ADDRESS                    = -24,
+    MA_BAD_SEEK                       = -25,
+    MA_BAD_PIPE                       = -26,
+    MA_DEADLOCK                       = -27,
+    MA_TOO_MANY_LINKS                 = -28,
+    MA_NOT_IMPLEMENTED                = -29,
+    MA_NO_MESSAGE                     = -30,
+    MA_BAD_MESSAGE                    = -31,
+    MA_NO_DATA_AVAILABLE              = -32,
+    MA_INVALID_DATA                   = -33,
+    MA_TIMEOUT                        = -34,
+    MA_NO_NETWORK                     = -35,
+    MA_NOT_UNIQUE                     = -36,
+    MA_NOT_SOCKET                     = -37,
+    MA_NO_ADDRESS                     = -38,
+    MA_BAD_PROTOCOL                   = -39,
+    MA_PROTOCOL_UNAVAILABLE           = -40,
+    MA_PROTOCOL_NOT_SUPPORTED         = -41,
+    MA_PROTOCOL_FAMILY_NOT_SUPPORTED  = -42,
+    MA_ADDRESS_FAMILY_NOT_SUPPORTED   = -43,
+    MA_SOCKET_NOT_SUPPORTED           = -44,
+    MA_CONNECTION_RESET               = -45,
+    MA_ALREADY_CONNECTED              = -46,
+    MA_NOT_CONNECTED                  = -47,
+    MA_CONNECTION_REFUSED             = -48,
+    MA_NO_HOST                        = -49,
+    MA_IN_PROGRESS                    = -50,
+    MA_CANCELLED                      = -51,
+    MA_MEMORY_ALREADY_MAPPED          = -52,
+
+    /* General non-standard errors. */
+    MA_CRC_MISMATCH                   = -100,
+
+    /* General miniaudio-specific errors. */
+    MA_FORMAT_NOT_SUPPORTED           = -200,
+    MA_DEVICE_TYPE_NOT_SUPPORTED      = -201,
+    MA_SHARE_MODE_NOT_SUPPORTED       = -202,
+    MA_NO_BACKEND                     = -203,
+    MA_NO_DEVICE                      = -204,
+    MA_API_NOT_FOUND                  = -205,
+    MA_INVALID_DEVICE_CONFIG          = -206,
+    MA_LOOP                           = -207,
+    MA_BACKEND_NOT_ENABLED            = -208,
+
+    /* State errors. */
+    MA_DEVICE_NOT_INITIALIZED         = -300,
+    MA_DEVICE_ALREADY_INITIALIZED     = -301,
+    MA_DEVICE_NOT_STARTED             = -302,
+    MA_DEVICE_NOT_STOPPED             = -303,
+
+    /* Operation errors. */
+    MA_FAILED_TO_INIT_BACKEND         = -400,
+    MA_FAILED_TO_OPEN_BACKEND_DEVICE  = -401,
+    MA_FAILED_TO_START_BACKEND_DEVICE = -402,
+    MA_FAILED_TO_STOP_BACKEND_DEVICE  = -403
+} ma_result;
+
+
+#define MA_MIN_CHANNELS                 1
+#ifndef MA_MAX_CHANNELS
+#define MA_MAX_CHANNELS                 254
+#endif
+
+#ifndef MA_MAX_FILTER_ORDER
+#define MA_MAX_FILTER_ORDER             8
+#endif
+
+typedef enum
+{
+    ma_stream_format_pcm = 0
+} ma_stream_format;
+
+typedef enum
+{
+    ma_stream_layout_interleaved = 0,
+    ma_stream_layout_deinterleaved
+} ma_stream_layout;
+
+typedef enum
+{
+    ma_dither_mode_none = 0,
+    ma_dither_mode_rectangle,
+    ma_dither_mode_triangle
+} ma_dither_mode;
+
+typedef enum
+{
+    /*
+    I like to keep these explicitly defined because they're used as a key into a lookup table. When items are
+    added to this, make sure there are no gaps and that they're added to the lookup table in ma_get_bytes_per_sample().
+    */
+    ma_format_unknown = 0,     /* Mainly used for indicating an error, but also used as the default for the output format for decoders. */
+    ma_format_u8      = 1,
+    ma_format_s16     = 2,     /* Seems to be the most widely supported format. */
+    ma_format_s24     = 3,     /* Tightly packed. 3 bytes per sample. */
+    ma_format_s32     = 4,
+    ma_format_f32     = 5,
+    ma_format_count
+} ma_format;
+
+typedef enum
+{
+    /* Standard rates need to be in priority order. */
+    ma_standard_sample_rate_48000  = 48000,     /* Most common */
+    ma_standard_sample_rate_44100  = 44100,
+
+    ma_standard_sample_rate_32000  = 32000,     /* Lows */
+    ma_standard_sample_rate_24000  = 24000,
+    ma_standard_sample_rate_22050  = 22050,
+
+    ma_standard_sample_rate_88200  = 88200,     /* Highs */
+    ma_standard_sample_rate_96000  = 96000,
+    ma_standard_sample_rate_176400 = 176400,
+    ma_standard_sample_rate_192000 = 192000,
+
+    ma_standard_sample_rate_16000  = 16000,     /* Extreme lows */
+    ma_standard_sample_rate_11025  = 11025,
+    ma_standard_sample_rate_8000   = 8000,
+
+    ma_standard_sample_rate_352800 = 352800,    /* Extreme highs */
+    ma_standard_sample_rate_384000 = 384000,
+
+    ma_standard_sample_rate_min    = ma_standard_sample_rate_8000,
+    ma_standard_sample_rate_max    = ma_standard_sample_rate_384000,
+    ma_standard_sample_rate_count  = 14         /* Need to maintain the count manually. Make sure this is updated if items are added to enum. */
+} ma_standard_sample_rate;
+
+
+typedef enum
+{
+    ma_channel_mix_mode_rectangular = 0,   /* Simple averaging based on the plane(s) the channel is sitting on. */
+    ma_channel_mix_mode_simple,            /* Drop excess channels; zeroed out extra channels. */
+    ma_channel_mix_mode_custom_weights,    /* Use custom weights specified in ma_channel_converter_config. */
+    ma_channel_mix_mode_default = ma_channel_mix_mode_rectangular
+} ma_channel_mix_mode;
+
+typedef enum
+{
+    ma_standard_channel_map_microsoft,
+    ma_standard_channel_map_alsa,
+    ma_standard_channel_map_rfc3551,   /* Based off AIFF. */
+    ma_standard_channel_map_flac,
+    ma_standard_channel_map_vorbis,
+    ma_standard_channel_map_sound4,    /* FreeBSD's sound(4). */
+    ma_standard_channel_map_sndio,     /* www.sndio.org/tips.html */
+    ma_standard_channel_map_webaudio = ma_standard_channel_map_flac, /* https://webaudio.github.io/web-audio-api/#ChannelOrdering. Only 1, 2, 4 and 6 channels are defined, but can fill in the gaps with logical assumptions. */
+    ma_standard_channel_map_default = ma_standard_channel_map_microsoft
+} ma_standard_channel_map;
+
+typedef enum
+{
+    ma_performance_profile_low_latency = 0,
+    ma_performance_profile_conservative
+} ma_performance_profile;
+
+
+typedef struct
+{
+    void* pUserData;
+    void* (* onMalloc)(size_t sz, void* pUserData);
+    void* (* onRealloc)(void* p, size_t sz, void* pUserData);
+    void  (* onFree)(void* p, void* pUserData);
+} ma_allocation_callbacks;
+
+typedef struct
+{
+    ma_int32 state;
+} ma_lcg;
+
+
+/*
+Atomics.
+
+These are typesafe structures to prevent errors as a result of forgetting to reference variables atomically. It's too
+easy to introduce subtle bugs where you accidentally do a regular assignment instead of an atomic load/store, etc. By
+using a struct we can enforce the use of atomics at compile time.
+
+These types are declared in the header section because we need to reference them in structs below, but functions for
+using them are only exposed in the implementation section. I do not want these to be part of the public API.
+
+There's a few downsides to this system. The first is that you need to declare a new struct for each type. Below are
+some macros to help with the declarations. They will be named like so:
+
+    ma_atomic_uint32 - atomic ma_uint32
+    ma_atomic_int32  - atomic ma_int32
+    ma_atomic_uint64 - atomic ma_uint64
+    ma_atomic_float  - atomic float
+    ma_atomic_bool32 - atomic ma_bool32
+
+The other downside is that atomic pointers are extremely messy. You need to declare a new struct for each specific
+type of pointer you need to make atomic. For example, an atomic ma_node* will look like this:
+
+    MA_ATOMIC_SAFE_TYPE_IMPL_PTR(node)
+
+Which will declare a type struct that's named like so:
+
+    ma_atomic_ptr_node
+
+Functions to use the atomic types are declared in the implementation section. All atomic functions are prefixed with
+the name of the struct. For example:
+
+    ma_atomic_uint32_set() - Atomic store of ma_uint32
+    ma_atomic_uint32_get() - Atomic load of ma_uint32
+    etc.
+
+For pointer types it's the same, which makes them a bit messy to use due to the length of each function name, but in
+return you get type safety and enforcement of atomic operations.
+*/
+#define MA_ATOMIC_SAFE_TYPE_DECL(c89TypeExtension, typeSize, type) \
+    typedef struct \
+    { \
+        MA_ATOMIC(typeSize, ma_##type) value; \
+    } ma_atomic_##type; \
+
+#define MA_ATOMIC_SAFE_TYPE_DECL_PTR(type) \
+    typedef struct \
+    { \
+        MA_ATOMIC(MA_SIZEOF_PTR, ma_##type*) value; \
+    } ma_atomic_ptr_##type; \
+
+MA_ATOMIC_SAFE_TYPE_DECL(32,  4, uint32)
+MA_ATOMIC_SAFE_TYPE_DECL(i32, 4, int32)
+MA_ATOMIC_SAFE_TYPE_DECL(64,  8, uint64)
+MA_ATOMIC_SAFE_TYPE_DECL(f32, 4, float)
+MA_ATOMIC_SAFE_TYPE_DECL(32,  4, bool32)
+
+
+/* Spinlocks are 32-bit for compatibility reasons. */
+typedef ma_uint32 ma_spinlock;
+
+#ifndef MA_NO_THREADING
+    /* Thread priorities should be ordered such that the default priority of the worker thread is 0. */
+    typedef enum
+    {
+        ma_thread_priority_idle     = -5,
+        ma_thread_priority_lowest   = -4,
+        ma_thread_priority_low      = -3,
+        ma_thread_priority_normal   = -2,
+        ma_thread_priority_high     = -1,
+        ma_thread_priority_highest  =  0,
+        ma_thread_priority_realtime =  1,
+        ma_thread_priority_default  =  0
+    } ma_thread_priority;
+
+    #if defined(MA_POSIX)
+        typedef ma_pthread_t ma_thread;
+    #elif defined(MA_WIN32)
+        typedef ma_handle ma_thread;
+    #endif
+
+    #if defined(MA_POSIX)
+        typedef ma_pthread_mutex_t ma_mutex;
+    #elif defined(MA_WIN32)
+        typedef ma_handle ma_mutex;
+    #endif
+
+    #if defined(MA_POSIX)
+        typedef struct
+        {
+            ma_uint32 value;
+            ma_pthread_mutex_t lock;
+            ma_pthread_cond_t cond;
+        } ma_event;
+    #elif defined(MA_WIN32)
+        typedef ma_handle ma_event;
+    #endif
+
+    #if defined(MA_POSIX)
+        typedef struct
+        {
+            int value;
+            ma_pthread_mutex_t lock;
+            ma_pthread_cond_t cond;
+        } ma_semaphore;
+    #elif defined(MA_WIN32)
+        typedef ma_handle ma_semaphore;
+    #endif
+#else
+    /* MA_NO_THREADING is set which means threading is disabled. Threading is required by some API families. If any of these are enabled we need to throw an error. */
+    #ifndef MA_NO_DEVICE_IO
+        #error "MA_NO_THREADING cannot be used without MA_NO_DEVICE_IO";
+    #endif
+#endif  /* MA_NO_THREADING */
+
+
+/*
+Retrieves the version of miniaudio as separated integers. Each component can be NULL if it's not required.
+*/
+MA_API void ma_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);
+
+/*
+Retrieves the version of miniaudio as a string which can be useful for logging purposes.
+*/
+MA_API const char* ma_version_string(void);
+
+
+/**************************************************************************************************************************************************************
+
+Logging
+
+**************************************************************************************************************************************************************/
+#include <stdarg.h> /* For va_list. */
+
+#if defined(__has_attribute)
+    #if __has_attribute(format)
+        #define MA_ATTRIBUTE_FORMAT(fmt, va) __attribute__((format(printf, fmt, va)))
+    #endif
+#endif
+#ifndef MA_ATTRIBUTE_FORMAT
+#define MA_ATTRIBUTE_FORMAT(fmt, va)
+#endif
+
+#ifndef MA_MAX_LOG_CALLBACKS
+#define MA_MAX_LOG_CALLBACKS    4
+#endif
+
+
+/*
+The callback for handling log messages.
+
+
+Parameters
+----------
+pUserData (in)
+    The user data pointer that was passed into ma_log_register_callback().
+
+logLevel (in)
+    The log level. This can be one of the following:
+
+    +----------------------+
+    | Log Level            |
+    +----------------------+
+    | MA_LOG_LEVEL_DEBUG   |
+    | MA_LOG_LEVEL_INFO    |
+    | MA_LOG_LEVEL_WARNING |
+    | MA_LOG_LEVEL_ERROR   |
+    +----------------------+
+
+pMessage (in)
+    The log message.
+*/
+typedef void (* ma_log_callback_proc)(void* pUserData, ma_uint32 level, const char* pMessage);
+
+typedef struct
+{
+    ma_log_callback_proc onLog;
+    void* pUserData;
+} ma_log_callback;
+
+MA_API ma_log_callback ma_log_callback_init(ma_log_callback_proc onLog, void* pUserData);
+
+
+typedef struct
+{
+    ma_log_callback callbacks[MA_MAX_LOG_CALLBACKS];
+    ma_uint32 callbackCount;
+    ma_allocation_callbacks allocationCallbacks;    /* Need to store these persistently because ma_log_postv() might need to allocate a buffer on the heap. */
+#ifndef MA_NO_THREADING
+    ma_mutex lock;  /* For thread safety just to make it easier and safer for the logging implementation. */
+#endif
+} ma_log;
+
+MA_API ma_result ma_log_init(const ma_allocation_callbacks* pAllocationCallbacks, ma_log* pLog);
+MA_API void ma_log_uninit(ma_log* pLog);
+MA_API ma_result ma_log_register_callback(ma_log* pLog, ma_log_callback callback);
+MA_API ma_result ma_log_unregister_callback(ma_log* pLog, ma_log_callback callback);
+MA_API ma_result ma_log_post(ma_log* pLog, ma_uint32 level, const char* pMessage);
+MA_API ma_result ma_log_postv(ma_log* pLog, ma_uint32 level, const char* pFormat, va_list args);
+MA_API ma_result ma_log_postf(ma_log* pLog, ma_uint32 level, const char* pFormat, ...) MA_ATTRIBUTE_FORMAT(3, 4);
+
+
+/**************************************************************************************************************************************************************
+
+Biquad Filtering
+
+**************************************************************************************************************************************************************/
+typedef union
+{
+    float    f32;
+    ma_int32 s32;
+} ma_biquad_coefficient;
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    double b0;
+    double b1;
+    double b2;
+    double a0;
+    double a1;
+    double a2;
+} ma_biquad_config;
+
+MA_API ma_biquad_config ma_biquad_config_init(ma_format format, ma_uint32 channels, double b0, double b1, double b2, double a0, double a1, double a2);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_biquad_coefficient b0;
+    ma_biquad_coefficient b1;
+    ma_biquad_coefficient b2;
+    ma_biquad_coefficient a1;
+    ma_biquad_coefficient a2;
+    ma_biquad_coefficient* pR1;
+    ma_biquad_coefficient* pR2;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_biquad;
+
+MA_API ma_result ma_biquad_get_heap_size(const ma_biquad_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_biquad_init_preallocated(const ma_biquad_config* pConfig, void* pHeap, ma_biquad* pBQ);
+MA_API ma_result ma_biquad_init(const ma_biquad_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_biquad* pBQ);
+MA_API void ma_biquad_uninit(ma_biquad* pBQ, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_biquad_reinit(const ma_biquad_config* pConfig, ma_biquad* pBQ);
+MA_API ma_result ma_biquad_clear_cache(ma_biquad* pBQ);
+MA_API ma_result ma_biquad_process_pcm_frames(ma_biquad* pBQ, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_biquad_get_latency(const ma_biquad* pBQ);
+
+
+/**************************************************************************************************************************************************************
+
+Low-Pass Filtering
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    double q;
+} ma_lpf1_config, ma_lpf2_config;
+
+MA_API ma_lpf1_config ma_lpf1_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency);
+MA_API ma_lpf2_config ma_lpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_biquad_coefficient a;
+    ma_biquad_coefficient* pR1;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_lpf1;
+
+MA_API ma_result ma_lpf1_get_heap_size(const ma_lpf1_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_lpf1_init_preallocated(const ma_lpf1_config* pConfig, void* pHeap, ma_lpf1* pLPF);
+MA_API ma_result ma_lpf1_init(const ma_lpf1_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf1* pLPF);
+MA_API void ma_lpf1_uninit(ma_lpf1* pLPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_lpf1_reinit(const ma_lpf1_config* pConfig, ma_lpf1* pLPF);
+MA_API ma_result ma_lpf1_clear_cache(ma_lpf1* pLPF);
+MA_API ma_result ma_lpf1_process_pcm_frames(ma_lpf1* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_lpf1_get_latency(const ma_lpf1* pLPF);
+
+typedef struct
+{
+    ma_biquad bq;   /* The second order low-pass filter is implemented as a biquad filter. */
+} ma_lpf2;
+
+MA_API ma_result ma_lpf2_get_heap_size(const ma_lpf2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_lpf2_init_preallocated(const ma_lpf2_config* pConfig, void* pHeap, ma_lpf2* pHPF);
+MA_API ma_result ma_lpf2_init(const ma_lpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf2* pLPF);
+MA_API void ma_lpf2_uninit(ma_lpf2* pLPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_lpf2_reinit(const ma_lpf2_config* pConfig, ma_lpf2* pLPF);
+MA_API ma_result ma_lpf2_clear_cache(ma_lpf2* pLPF);
+MA_API ma_result ma_lpf2_process_pcm_frames(ma_lpf2* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_lpf2_get_latency(const ma_lpf2* pLPF);
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    ma_uint32 order;    /* If set to 0, will be treated as a passthrough (no filtering will be applied). */
+} ma_lpf_config;
+
+MA_API ma_lpf_config ma_lpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint32 lpf1Count;
+    ma_uint32 lpf2Count;
+    ma_lpf1* pLPF1;
+    ma_lpf2* pLPF2;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_lpf;
+
+MA_API ma_result ma_lpf_get_heap_size(const ma_lpf_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_lpf_init_preallocated(const ma_lpf_config* pConfig, void* pHeap, ma_lpf* pLPF);
+MA_API ma_result ma_lpf_init(const ma_lpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf* pLPF);
+MA_API void ma_lpf_uninit(ma_lpf* pLPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_lpf_reinit(const ma_lpf_config* pConfig, ma_lpf* pLPF);
+MA_API ma_result ma_lpf_clear_cache(ma_lpf* pLPF);
+MA_API ma_result ma_lpf_process_pcm_frames(ma_lpf* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_lpf_get_latency(const ma_lpf* pLPF);
+
+
+/**************************************************************************************************************************************************************
+
+High-Pass Filtering
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    double q;
+} ma_hpf1_config, ma_hpf2_config;
+
+MA_API ma_hpf1_config ma_hpf1_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency);
+MA_API ma_hpf2_config ma_hpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_biquad_coefficient a;
+    ma_biquad_coefficient* pR1;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_hpf1;
+
+MA_API ma_result ma_hpf1_get_heap_size(const ma_hpf1_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_hpf1_init_preallocated(const ma_hpf1_config* pConfig, void* pHeap, ma_hpf1* pLPF);
+MA_API ma_result ma_hpf1_init(const ma_hpf1_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf1* pHPF);
+MA_API void ma_hpf1_uninit(ma_hpf1* pHPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_hpf1_reinit(const ma_hpf1_config* pConfig, ma_hpf1* pHPF);
+MA_API ma_result ma_hpf1_process_pcm_frames(ma_hpf1* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_hpf1_get_latency(const ma_hpf1* pHPF);
+
+typedef struct
+{
+    ma_biquad bq;   /* The second order high-pass filter is implemented as a biquad filter. */
+} ma_hpf2;
+
+MA_API ma_result ma_hpf2_get_heap_size(const ma_hpf2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_hpf2_init_preallocated(const ma_hpf2_config* pConfig, void* pHeap, ma_hpf2* pHPF);
+MA_API ma_result ma_hpf2_init(const ma_hpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf2* pHPF);
+MA_API void ma_hpf2_uninit(ma_hpf2* pHPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_hpf2_reinit(const ma_hpf2_config* pConfig, ma_hpf2* pHPF);
+MA_API ma_result ma_hpf2_process_pcm_frames(ma_hpf2* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_hpf2_get_latency(const ma_hpf2* pHPF);
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    ma_uint32 order;    /* If set to 0, will be treated as a passthrough (no filtering will be applied). */
+} ma_hpf_config;
+
+MA_API ma_hpf_config ma_hpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint32 hpf1Count;
+    ma_uint32 hpf2Count;
+    ma_hpf1* pHPF1;
+    ma_hpf2* pHPF2;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_hpf;
+
+MA_API ma_result ma_hpf_get_heap_size(const ma_hpf_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_hpf_init_preallocated(const ma_hpf_config* pConfig, void* pHeap, ma_hpf* pLPF);
+MA_API ma_result ma_hpf_init(const ma_hpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf* pHPF);
+MA_API void ma_hpf_uninit(ma_hpf* pHPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_hpf_reinit(const ma_hpf_config* pConfig, ma_hpf* pHPF);
+MA_API ma_result ma_hpf_process_pcm_frames(ma_hpf* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_hpf_get_latency(const ma_hpf* pHPF);
+
+
+/**************************************************************************************************************************************************************
+
+Band-Pass Filtering
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    double q;
+} ma_bpf2_config;
+
+MA_API ma_bpf2_config ma_bpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q);
+
+typedef struct
+{
+    ma_biquad bq;   /* The second order band-pass filter is implemented as a biquad filter. */
+} ma_bpf2;
+
+MA_API ma_result ma_bpf2_get_heap_size(const ma_bpf2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_bpf2_init_preallocated(const ma_bpf2_config* pConfig, void* pHeap, ma_bpf2* pBPF);
+MA_API ma_result ma_bpf2_init(const ma_bpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf2* pBPF);
+MA_API void ma_bpf2_uninit(ma_bpf2* pBPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_bpf2_reinit(const ma_bpf2_config* pConfig, ma_bpf2* pBPF);
+MA_API ma_result ma_bpf2_process_pcm_frames(ma_bpf2* pBPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_bpf2_get_latency(const ma_bpf2* pBPF);
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double cutoffFrequency;
+    ma_uint32 order;    /* If set to 0, will be treated as a passthrough (no filtering will be applied). */
+} ma_bpf_config;
+
+MA_API ma_bpf_config ma_bpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 bpf2Count;
+    ma_bpf2* pBPF2;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_bpf;
+
+MA_API ma_result ma_bpf_get_heap_size(const ma_bpf_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_bpf_init_preallocated(const ma_bpf_config* pConfig, void* pHeap, ma_bpf* pBPF);
+MA_API ma_result ma_bpf_init(const ma_bpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf* pBPF);
+MA_API void ma_bpf_uninit(ma_bpf* pBPF, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_bpf_reinit(const ma_bpf_config* pConfig, ma_bpf* pBPF);
+MA_API ma_result ma_bpf_process_pcm_frames(ma_bpf* pBPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_bpf_get_latency(const ma_bpf* pBPF);
+
+
+/**************************************************************************************************************************************************************
+
+Notching Filter
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double q;
+    double frequency;
+} ma_notch2_config, ma_notch_config;
+
+MA_API ma_notch2_config ma_notch2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double q, double frequency);
+
+typedef struct
+{
+    ma_biquad bq;
+} ma_notch2;
+
+MA_API ma_result ma_notch2_get_heap_size(const ma_notch2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_notch2_init_preallocated(const ma_notch2_config* pConfig, void* pHeap, ma_notch2* pFilter);
+MA_API ma_result ma_notch2_init(const ma_notch2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_notch2* pFilter);
+MA_API void ma_notch2_uninit(ma_notch2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_notch2_reinit(const ma_notch2_config* pConfig, ma_notch2* pFilter);
+MA_API ma_result ma_notch2_process_pcm_frames(ma_notch2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_notch2_get_latency(const ma_notch2* pFilter);
+
+
+/**************************************************************************************************************************************************************
+
+Peaking EQ Filter
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double gainDB;
+    double q;
+    double frequency;
+} ma_peak2_config, ma_peak_config;
+
+MA_API ma_peak2_config ma_peak2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency);
+
+typedef struct
+{
+    ma_biquad bq;
+} ma_peak2;
+
+MA_API ma_result ma_peak2_get_heap_size(const ma_peak2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_peak2_init_preallocated(const ma_peak2_config* pConfig, void* pHeap, ma_peak2* pFilter);
+MA_API ma_result ma_peak2_init(const ma_peak2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_peak2* pFilter);
+MA_API void ma_peak2_uninit(ma_peak2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_peak2_reinit(const ma_peak2_config* pConfig, ma_peak2* pFilter);
+MA_API ma_result ma_peak2_process_pcm_frames(ma_peak2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_peak2_get_latency(const ma_peak2* pFilter);
+
+
+/**************************************************************************************************************************************************************
+
+Low Shelf Filter
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double gainDB;
+    double shelfSlope;
+    double frequency;
+} ma_loshelf2_config, ma_loshelf_config;
+
+MA_API ma_loshelf2_config ma_loshelf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double shelfSlope, double frequency);
+
+typedef struct
+{
+    ma_biquad bq;
+} ma_loshelf2;
+
+MA_API ma_result ma_loshelf2_get_heap_size(const ma_loshelf2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_loshelf2_init_preallocated(const ma_loshelf2_config* pConfig, void* pHeap, ma_loshelf2* pFilter);
+MA_API ma_result ma_loshelf2_init(const ma_loshelf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_loshelf2* pFilter);
+MA_API void ma_loshelf2_uninit(ma_loshelf2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_loshelf2_reinit(const ma_loshelf2_config* pConfig, ma_loshelf2* pFilter);
+MA_API ma_result ma_loshelf2_process_pcm_frames(ma_loshelf2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_loshelf2_get_latency(const ma_loshelf2* pFilter);
+
+
+/**************************************************************************************************************************************************************
+
+High Shelf Filter
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double gainDB;
+    double shelfSlope;
+    double frequency;
+} ma_hishelf2_config, ma_hishelf_config;
+
+MA_API ma_hishelf2_config ma_hishelf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double shelfSlope, double frequency);
+
+typedef struct
+{
+    ma_biquad bq;
+} ma_hishelf2;
+
+MA_API ma_result ma_hishelf2_get_heap_size(const ma_hishelf2_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_hishelf2_init_preallocated(const ma_hishelf2_config* pConfig, void* pHeap, ma_hishelf2* pFilter);
+MA_API ma_result ma_hishelf2_init(const ma_hishelf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hishelf2* pFilter);
+MA_API void ma_hishelf2_uninit(ma_hishelf2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_hishelf2_reinit(const ma_hishelf2_config* pConfig, ma_hishelf2* pFilter);
+MA_API ma_result ma_hishelf2_process_pcm_frames(ma_hishelf2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_uint32 ma_hishelf2_get_latency(const ma_hishelf2* pFilter);
+
+
+
+/*
+Delay
+*/
+typedef struct
+{
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint32 delayInFrames;
+    ma_bool32 delayStart;       /* Set to true to delay the start of the output; false otherwise. */
+    float wet;                  /* 0..1. Default = 1. */
+    float dry;                  /* 0..1. Default = 1. */
+    float decay;                /* 0..1. Default = 0 (no feedback). Feedback decay. Use this for echo. */
+} ma_delay_config;
+
+MA_API ma_delay_config ma_delay_config_init(ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 delayInFrames, float decay);
+
+
+typedef struct
+{
+    ma_delay_config config;
+    ma_uint32 cursor;               /* Feedback is written to this cursor. Always equal or in front of the read cursor. */
+    ma_uint32 bufferSizeInFrames;
+    float* pBuffer;
+} ma_delay;
+
+MA_API ma_result ma_delay_init(const ma_delay_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_delay* pDelay);
+MA_API void ma_delay_uninit(ma_delay* pDelay, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_delay_process_pcm_frames(ma_delay* pDelay, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount);
+MA_API void ma_delay_set_wet(ma_delay* pDelay, float value);
+MA_API float ma_delay_get_wet(const ma_delay* pDelay);
+MA_API void ma_delay_set_dry(ma_delay* pDelay, float value);
+MA_API float ma_delay_get_dry(const ma_delay* pDelay);
+MA_API void ma_delay_set_decay(ma_delay* pDelay, float value);
+MA_API float ma_delay_get_decay(const ma_delay* pDelay);
+
+
+/* Gainer for smooth volume changes. */
+typedef struct
+{
+    ma_uint32 channels;
+    ma_uint32 smoothTimeInFrames;
+} ma_gainer_config;
+
+MA_API ma_gainer_config ma_gainer_config_init(ma_uint32 channels, ma_uint32 smoothTimeInFrames);
+
+
+typedef struct
+{
+    ma_gainer_config config;
+    ma_uint32 t;
+    float masterVolume;
+    float* pOldGains;
+    float* pNewGains;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_gainer;
+
+MA_API ma_result ma_gainer_get_heap_size(const ma_gainer_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_gainer_init_preallocated(const ma_gainer_config* pConfig, void* pHeap, ma_gainer* pGainer);
+MA_API ma_result ma_gainer_init(const ma_gainer_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_gainer* pGainer);
+MA_API void ma_gainer_uninit(ma_gainer* pGainer, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_gainer_process_pcm_frames(ma_gainer* pGainer, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_result ma_gainer_set_gain(ma_gainer* pGainer, float newGain);
+MA_API ma_result ma_gainer_set_gains(ma_gainer* pGainer, float* pNewGains);
+MA_API ma_result ma_gainer_set_master_volume(ma_gainer* pGainer, float volume);
+MA_API ma_result ma_gainer_get_master_volume(const ma_gainer* pGainer, float* pVolume);
+
+
+
+/* Stereo panner. */
+typedef enum
+{
+    ma_pan_mode_balance = 0,    /* Does not blend one side with the other. Technically just a balance. Compatible with other popular audio engines and therefore the default. */
+    ma_pan_mode_pan             /* A true pan. The sound from one side will "move" to the other side and blend with it. */
+} ma_pan_mode;
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_pan_mode mode;
+    float pan;
+} ma_panner_config;
+
+MA_API ma_panner_config ma_panner_config_init(ma_format format, ma_uint32 channels);
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_pan_mode mode;
+    float pan;  /* -1..1 where 0 is no pan, -1 is left side, +1 is right side. Defaults to 0. */
+} ma_panner;
+
+MA_API ma_result ma_panner_init(const ma_panner_config* pConfig, ma_panner* pPanner);
+MA_API ma_result ma_panner_process_pcm_frames(ma_panner* pPanner, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API void ma_panner_set_mode(ma_panner* pPanner, ma_pan_mode mode);
+MA_API ma_pan_mode ma_panner_get_mode(const ma_panner* pPanner);
+MA_API void ma_panner_set_pan(ma_panner* pPanner, float pan);
+MA_API float ma_panner_get_pan(const ma_panner* pPanner);
+
+
+
+/* Fader. */
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+} ma_fader_config;
+
+MA_API ma_fader_config ma_fader_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate);
+
+typedef struct
+{
+    ma_fader_config config;
+    float volumeBeg;            /* If volumeBeg and volumeEnd is equal to 1, no fading happens (ma_fader_process_pcm_frames() will run as a passthrough). */
+    float volumeEnd;
+    ma_uint64 lengthInFrames;   /* The total length of the fade. */
+    ma_int64  cursorInFrames;   /* The current time in frames. Incremented by ma_fader_process_pcm_frames(). Signed because it'll be offset by startOffsetInFrames in set_fade_ex(). */
+} ma_fader;
+
+MA_API ma_result ma_fader_init(const ma_fader_config* pConfig, ma_fader* pFader);
+MA_API ma_result ma_fader_process_pcm_frames(ma_fader* pFader, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API void ma_fader_get_data_format(const ma_fader* pFader, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate);
+MA_API void ma_fader_set_fade(ma_fader* pFader, float volumeBeg, float volumeEnd, ma_uint64 lengthInFrames);
+MA_API void ma_fader_set_fade_ex(ma_fader* pFader, float volumeBeg, float volumeEnd, ma_uint64 lengthInFrames, ma_int64 startOffsetInFrames);
+MA_API float ma_fader_get_current_volume(const ma_fader* pFader);
+
+
+
+/* Spatializer. */
+typedef struct
+{
+    float x;
+    float y;
+    float z;
+} ma_vec3f;
+
+typedef struct
+{
+    ma_vec3f v;
+    ma_spinlock lock;
+} ma_atomic_vec3f;
+
+typedef enum
+{
+    ma_attenuation_model_none,          /* No distance attenuation and no spatialization. */
+    ma_attenuation_model_inverse,       /* Equivalent to OpenAL's AL_INVERSE_DISTANCE_CLAMPED. */
+    ma_attenuation_model_linear,        /* Linear attenuation. Equivalent to OpenAL's AL_LINEAR_DISTANCE_CLAMPED. */
+    ma_attenuation_model_exponential    /* Exponential attenuation. Equivalent to OpenAL's AL_EXPONENT_DISTANCE_CLAMPED. */
+} ma_attenuation_model;
+
+typedef enum
+{
+    ma_positioning_absolute,
+    ma_positioning_relative
+} ma_positioning;
+
+typedef enum
+{
+    ma_handedness_right,
+    ma_handedness_left
+} ma_handedness;
+
+
+typedef struct
+{
+    ma_uint32 channelsOut;
+    ma_channel* pChannelMapOut;
+    ma_handedness handedness;   /* Defaults to right. Forward is -1 on the Z axis. In a left handed system, forward is +1 on the Z axis. */
+    float coneInnerAngleInRadians;
+    float coneOuterAngleInRadians;
+    float coneOuterGain;
+    float speedOfSound;
+    ma_vec3f worldUp;
+} ma_spatializer_listener_config;
+
+MA_API ma_spatializer_listener_config ma_spatializer_listener_config_init(ma_uint32 channelsOut);
+
+
+typedef struct
+{
+    ma_spatializer_listener_config config;
+    ma_atomic_vec3f position;  /* The absolute position of the listener. */
+    ma_atomic_vec3f direction; /* The direction the listener is facing. The world up vector is config.worldUp. */
+    ma_atomic_vec3f velocity;
+    ma_bool32 isEnabled;
+
+    /* Memory management. */
+    ma_bool32 _ownsHeap;
+    void* _pHeap;
+} ma_spatializer_listener;
+
+MA_API ma_result ma_spatializer_listener_get_heap_size(const ma_spatializer_listener_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_spatializer_listener_init_preallocated(const ma_spatializer_listener_config* pConfig, void* pHeap, ma_spatializer_listener* pListener);
+MA_API ma_result ma_spatializer_listener_init(const ma_spatializer_listener_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_uninit(ma_spatializer_listener* pListener, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_channel* ma_spatializer_listener_get_channel_map(ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_cone(ma_spatializer_listener* pListener, float innerAngleInRadians, float outerAngleInRadians, float outerGain);
+MA_API void ma_spatializer_listener_get_cone(const ma_spatializer_listener* pListener, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain);
+MA_API void ma_spatializer_listener_set_position(ma_spatializer_listener* pListener, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_listener_get_position(const ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_direction(ma_spatializer_listener* pListener, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_listener_get_direction(const ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_velocity(ma_spatializer_listener* pListener, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_listener_get_velocity(const ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_speed_of_sound(ma_spatializer_listener* pListener, float speedOfSound);
+MA_API float ma_spatializer_listener_get_speed_of_sound(const ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_world_up(ma_spatializer_listener* pListener, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_listener_get_world_up(const ma_spatializer_listener* pListener);
+MA_API void ma_spatializer_listener_set_enabled(ma_spatializer_listener* pListener, ma_bool32 isEnabled);
+MA_API ma_bool32 ma_spatializer_listener_is_enabled(const ma_spatializer_listener* pListener);
+
+
+typedef struct
+{
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_channel* pChannelMapIn;
+    ma_attenuation_model attenuationModel;
+    ma_positioning positioning;
+    ma_handedness handedness;           /* Defaults to right. Forward is -1 on the Z axis. In a left handed system, forward is +1 on the Z axis. */
+    float minGain;
+    float maxGain;
+    float minDistance;
+    float maxDistance;
+    float rolloff;
+    float coneInnerAngleInRadians;
+    float coneOuterAngleInRadians;
+    float coneOuterGain;
+    float dopplerFactor;                /* Set to 0 to disable doppler effect. */
+    float directionalAttenuationFactor; /* Set to 0 to disable directional attenuation. */
+    float minSpatializationChannelGain; /* The minimal scaling factor to apply to channel gains when accounting for the direction of the sound relative to the listener. Must be in the range of 0..1. Smaller values means more aggressive directional panning, larger values means more subtle directional panning. */
+    ma_uint32 gainSmoothTimeInFrames;   /* When the gain of a channel changes during spatialization, the transition will be linearly interpolated over this number of frames. */
+} ma_spatializer_config;
+
+MA_API ma_spatializer_config ma_spatializer_config_init(ma_uint32 channelsIn, ma_uint32 channelsOut);
+
+
+typedef struct
+{
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_channel* pChannelMapIn;
+    ma_attenuation_model attenuationModel;
+    ma_positioning positioning;
+    ma_handedness handedness;           /* Defaults to right. Forward is -1 on the Z axis. In a left handed system, forward is +1 on the Z axis. */
+    float minGain;
+    float maxGain;
+    float minDistance;
+    float maxDistance;
+    float rolloff;
+    float coneInnerAngleInRadians;
+    float coneOuterAngleInRadians;
+    float coneOuterGain;
+    float dopplerFactor;                /* Set to 0 to disable doppler effect. */
+    float directionalAttenuationFactor; /* Set to 0 to disable directional attenuation. */
+    ma_uint32 gainSmoothTimeInFrames;   /* When the gain of a channel changes during spatialization, the transition will be linearly interpolated over this number of frames. */
+    ma_atomic_vec3f position;
+    ma_atomic_vec3f direction;
+    ma_atomic_vec3f velocity;  /* For doppler effect. */
+    float dopplerPitch; /* Will be updated by ma_spatializer_process_pcm_frames() and can be used by higher level functions to apply a pitch shift for doppler effect. */
+    float minSpatializationChannelGain;
+    ma_gainer gainer;   /* For smooth gain transitions. */
+    float* pNewChannelGainsOut; /* An offset of _pHeap. Used by ma_spatializer_process_pcm_frames() to store new channel gains. The number of elements in this array is equal to config.channelsOut. */
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_spatializer;
+
+MA_API ma_result ma_spatializer_get_heap_size(const ma_spatializer_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_spatializer_init_preallocated(const ma_spatializer_config* pConfig, void* pHeap, ma_spatializer* pSpatializer);
+MA_API ma_result ma_spatializer_init(const ma_spatializer_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_uninit(ma_spatializer* pSpatializer, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_spatializer_process_pcm_frames(ma_spatializer* pSpatializer, ma_spatializer_listener* pListener, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_result ma_spatializer_set_master_volume(ma_spatializer* pSpatializer, float volume);
+MA_API ma_result ma_spatializer_get_master_volume(const ma_spatializer* pSpatializer, float* pVolume);
+MA_API ma_uint32 ma_spatializer_get_input_channels(const ma_spatializer* pSpatializer);
+MA_API ma_uint32 ma_spatializer_get_output_channels(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_attenuation_model(ma_spatializer* pSpatializer, ma_attenuation_model attenuationModel);
+MA_API ma_attenuation_model ma_spatializer_get_attenuation_model(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_positioning(ma_spatializer* pSpatializer, ma_positioning positioning);
+MA_API ma_positioning ma_spatializer_get_positioning(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_rolloff(ma_spatializer* pSpatializer, float rolloff);
+MA_API float ma_spatializer_get_rolloff(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_min_gain(ma_spatializer* pSpatializer, float minGain);
+MA_API float ma_spatializer_get_min_gain(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_max_gain(ma_spatializer* pSpatializer, float maxGain);
+MA_API float ma_spatializer_get_max_gain(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_min_distance(ma_spatializer* pSpatializer, float minDistance);
+MA_API float ma_spatializer_get_min_distance(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_max_distance(ma_spatializer* pSpatializer, float maxDistance);
+MA_API float ma_spatializer_get_max_distance(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_cone(ma_spatializer* pSpatializer, float innerAngleInRadians, float outerAngleInRadians, float outerGain);
+MA_API void ma_spatializer_get_cone(const ma_spatializer* pSpatializer, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain);
+MA_API void ma_spatializer_set_doppler_factor(ma_spatializer* pSpatializer, float dopplerFactor);
+MA_API float ma_spatializer_get_doppler_factor(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_directional_attenuation_factor(ma_spatializer* pSpatializer, float directionalAttenuationFactor);
+MA_API float ma_spatializer_get_directional_attenuation_factor(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_position(ma_spatializer* pSpatializer, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_get_position(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_direction(ma_spatializer* pSpatializer, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_get_direction(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_set_velocity(ma_spatializer* pSpatializer, float x, float y, float z);
+MA_API ma_vec3f ma_spatializer_get_velocity(const ma_spatializer* pSpatializer);
+MA_API void ma_spatializer_get_relative_position_and_direction(const ma_spatializer* pSpatializer, const ma_spatializer_listener* pListener, ma_vec3f* pRelativePos, ma_vec3f* pRelativeDir);
+
+
+
+/************************************************************************************************************************************************************
+*************************************************************************************************************************************************************
+
+DATA CONVERSION
+===============
+
+This section contains the APIs for data conversion. You will find everything here for channel mapping, sample format conversion, resampling, etc.
+
+*************************************************************************************************************************************************************
+************************************************************************************************************************************************************/
+
+/**************************************************************************************************************************************************************
+
+Resampling
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRateIn;
+    ma_uint32 sampleRateOut;
+    ma_uint32 lpfOrder;         /* The low-pass filter order. Setting this to 0 will disable low-pass filtering. */
+    double    lpfNyquistFactor; /* 0..1. Defaults to 1. 1 = Half the sampling frequency (Nyquist Frequency), 0.5 = Quarter the sampling frequency (half Nyquest Frequency), etc. */
+} ma_linear_resampler_config;
+
+MA_API ma_linear_resampler_config ma_linear_resampler_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);
+
+typedef struct
+{
+    ma_linear_resampler_config config;
+    ma_uint32 inAdvanceInt;
+    ma_uint32 inAdvanceFrac;
+    ma_uint32 inTimeInt;
+    ma_uint32 inTimeFrac;
+    union
+    {
+        float* f32;
+        ma_int16* s16;
+    } x0; /* The previous input frame. */
+    union
+    {
+        float* f32;
+        ma_int16* s16;
+    } x1; /* The next input frame. */
+    ma_lpf lpf;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_linear_resampler;
+
+MA_API ma_result ma_linear_resampler_get_heap_size(const ma_linear_resampler_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_linear_resampler_init_preallocated(const ma_linear_resampler_config* pConfig, void* pHeap, ma_linear_resampler* pResampler);
+MA_API ma_result ma_linear_resampler_init(const ma_linear_resampler_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_linear_resampler* pResampler);
+MA_API void ma_linear_resampler_uninit(ma_linear_resampler* pResampler, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_linear_resampler_process_pcm_frames(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
+MA_API ma_result ma_linear_resampler_set_rate(ma_linear_resampler* pResampler, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);
+MA_API ma_result ma_linear_resampler_set_rate_ratio(ma_linear_resampler* pResampler, float ratioInOut);
+MA_API ma_uint64 ma_linear_resampler_get_input_latency(const ma_linear_resampler* pResampler);
+MA_API ma_uint64 ma_linear_resampler_get_output_latency(const ma_linear_resampler* pResampler);
+MA_API ma_result ma_linear_resampler_get_required_input_frame_count(const ma_linear_resampler* pResampler, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount);
+MA_API ma_result ma_linear_resampler_get_expected_output_frame_count(const ma_linear_resampler* pResampler, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);
+MA_API ma_result ma_linear_resampler_reset(ma_linear_resampler* pResampler);
+
+
+typedef struct ma_resampler_config ma_resampler_config;
+
+typedef void ma_resampling_backend;
+typedef struct
+{
+    ma_result (* onGetHeapSize                )(void* pUserData, const ma_resampler_config* pConfig, size_t* pHeapSizeInBytes);
+    ma_result (* onInit                       )(void* pUserData, const ma_resampler_config* pConfig, void* pHeap, ma_resampling_backend** ppBackend);
+    void      (* onUninit                     )(void* pUserData, ma_resampling_backend* pBackend, const ma_allocation_callbacks* pAllocationCallbacks);
+    ma_result (* onProcess                    )(void* pUserData, ma_resampling_backend* pBackend, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
+    ma_result (* onSetRate                    )(void* pUserData, ma_resampling_backend* pBackend, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);                 /* Optional. Rate changes will be disabled. */
+    ma_uint64 (* onGetInputLatency            )(void* pUserData, const ma_resampling_backend* pBackend);                                                            /* Optional. Latency will be reported as 0. */
+    ma_uint64 (* onGetOutputLatency           )(void* pUserData, const ma_resampling_backend* pBackend);                                                            /* Optional. Latency will be reported as 0. */
+    ma_result (* onGetRequiredInputFrameCount )(void* pUserData, const ma_resampling_backend* pBackend, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount);   /* Optional. Latency mitigation will be disabled. */
+    ma_result (* onGetExpectedOutputFrameCount)(void* pUserData, const ma_resampling_backend* pBackend, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);   /* Optional. Latency mitigation will be disabled. */
+    ma_result (* onReset                      )(void* pUserData, ma_resampling_backend* pBackend);
+} ma_resampling_backend_vtable;
+
+typedef enum
+{
+    ma_resample_algorithm_linear = 0,    /* Fastest, lowest quality. Optional low-pass filtering. Default. */
+    ma_resample_algorithm_custom,
+} ma_resample_algorithm;
+
+struct ma_resampler_config
+{
+    ma_format format;   /* Must be either ma_format_f32 or ma_format_s16. */
+    ma_uint32 channels;
+    ma_uint32 sampleRateIn;
+    ma_uint32 sampleRateOut;
+    ma_resample_algorithm algorithm;    /* When set to ma_resample_algorithm_custom, pBackendVTable will be used. */
+    ma_resampling_backend_vtable* pBackendVTable;
+    void* pBackendUserData;
+    struct
+    {
+        ma_uint32 lpfOrder;
+    } linear;
+};
+
+MA_API ma_resampler_config ma_resampler_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut, ma_resample_algorithm algorithm);
+
+typedef struct
+{
+    ma_resampling_backend* pBackend;
+    ma_resampling_backend_vtable* pBackendVTable;
+    void* pBackendUserData;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRateIn;
+    ma_uint32 sampleRateOut;
+    union
+    {
+        ma_linear_resampler linear;
+    } state;    /* State for stock resamplers so we can avoid a malloc. For stock resamplers, pBackend will point here. */
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_resampler;
+
+MA_API ma_result ma_resampler_get_heap_size(const ma_resampler_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_resampler_init_preallocated(const ma_resampler_config* pConfig, void* pHeap, ma_resampler* pResampler);
+
+/*
+Initializes a new resampler object from a config.
+*/
+MA_API ma_result ma_resampler_init(const ma_resampler_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_resampler* pResampler);
+
+/*
+Uninitializes a resampler.
+*/
+MA_API void ma_resampler_uninit(ma_resampler* pResampler, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Converts the given input data.
+
+Both the input and output frames must be in the format specified in the config when the resampler was initialized.
+
+On input, [pFrameCountOut] contains the number of output frames to process. On output it contains the number of output frames that
+were actually processed, which may be less than the requested amount which will happen if there's not enough input data. You can use
+ma_resampler_get_expected_output_frame_count() to know how many output frames will be processed for a given number of input frames.
+
+On input, [pFrameCountIn] contains the number of input frames contained in [pFramesIn]. On output it contains the number of whole
+input frames that were actually processed. You can use ma_resampler_get_required_input_frame_count() to know how many input frames
+you should provide for a given number of output frames. [pFramesIn] can be NULL, in which case zeroes will be used instead.
+
+If [pFramesOut] is NULL, a seek is performed. In this case, if [pFrameCountOut] is not NULL it will seek by the specified number of
+output frames. Otherwise, if [pFramesCountOut] is NULL and [pFrameCountIn] is not NULL, it will seek by the specified number of input
+frames. When seeking, [pFramesIn] is allowed to NULL, in which case the internal timing state will be updated, but no input will be
+processed. In this case, any internal filter state will be updated as if zeroes were passed in.
+
+It is an error for [pFramesOut] to be non-NULL and [pFrameCountOut] to be NULL.
+
+It is an error for both [pFrameCountOut] and [pFrameCountIn] to be NULL.
+*/
+MA_API ma_result ma_resampler_process_pcm_frames(ma_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
+
+
+/*
+Sets the input and output sample rate.
+*/
+MA_API ma_result ma_resampler_set_rate(ma_resampler* pResampler, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);
+
+/*
+Sets the input and output sample rate as a ratio.
+
+The ration is in/out.
+*/
+MA_API ma_result ma_resampler_set_rate_ratio(ma_resampler* pResampler, float ratio);
+
+/*
+Retrieves the latency introduced by the resampler in input frames.
+*/
+MA_API ma_uint64 ma_resampler_get_input_latency(const ma_resampler* pResampler);
+
+/*
+Retrieves the latency introduced by the resampler in output frames.
+*/
+MA_API ma_uint64 ma_resampler_get_output_latency(const ma_resampler* pResampler);
+
+/*
+Calculates the number of whole input frames that would need to be read from the client in order to output the specified
+number of output frames.
+
+The returned value does not include cached input frames. It only returns the number of extra frames that would need to be
+read from the input buffer in order to output the specified number of output frames.
+*/
+MA_API ma_result ma_resampler_get_required_input_frame_count(const ma_resampler* pResampler, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount);
+
+/*
+Calculates the number of whole output frames that would be output after fully reading and consuming the specified number of
+input frames.
+*/
+MA_API ma_result ma_resampler_get_expected_output_frame_count(const ma_resampler* pResampler, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);
+
+/*
+Resets the resampler's timer and clears it's internal cache.
+*/
+MA_API ma_result ma_resampler_reset(ma_resampler* pResampler);
+
+
+/**************************************************************************************************************************************************************
+
+Channel Conversion
+
+**************************************************************************************************************************************************************/
+typedef enum
+{
+    ma_channel_conversion_path_unknown,
+    ma_channel_conversion_path_passthrough,
+    ma_channel_conversion_path_mono_out,    /* Converting to mono. */
+    ma_channel_conversion_path_mono_in,     /* Converting from mono. */
+    ma_channel_conversion_path_shuffle,     /* Simple shuffle. Will use this when all channels are present in both input and output channel maps, but just in a different order. */
+    ma_channel_conversion_path_weights      /* Blended based on weights. */
+} ma_channel_conversion_path;
+
+typedef enum
+{
+    ma_mono_expansion_mode_duplicate = 0,   /* The default. */
+    ma_mono_expansion_mode_average,         /* Average the mono channel across all channels. */
+    ma_mono_expansion_mode_stereo_only,     /* Duplicate to the left and right channels only and ignore the others. */
+    ma_mono_expansion_mode_default = ma_mono_expansion_mode_duplicate
+} ma_mono_expansion_mode;
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    const ma_channel* pChannelMapIn;
+    const ma_channel* pChannelMapOut;
+    ma_channel_mix_mode mixingMode;
+    ma_bool32 calculateLFEFromSpatialChannels;  /* When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. */
+    float** ppWeights;  /* [in][out]. Only used when mixingMode is set to ma_channel_mix_mode_custom_weights. */
+} ma_channel_converter_config;
+
+MA_API ma_channel_converter_config ma_channel_converter_config_init(ma_format format, ma_uint32 channelsIn, const ma_channel* pChannelMapIn, ma_uint32 channelsOut, const ma_channel* pChannelMapOut, ma_channel_mix_mode mixingMode);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_channel_mix_mode mixingMode;
+    ma_channel_conversion_path conversionPath;
+    ma_channel* pChannelMapIn;
+    ma_channel* pChannelMapOut;
+    ma_uint8* pShuffleTable;    /* Indexed by output channel index. */
+    union
+    {
+        float**    f32;
+        ma_int32** s16;
+    } weights;  /* [in][out] */
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_channel_converter;
+
+MA_API ma_result ma_channel_converter_get_heap_size(const ma_channel_converter_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_channel_converter_init_preallocated(const ma_channel_converter_config* pConfig, void* pHeap, ma_channel_converter* pConverter);
+MA_API ma_result ma_channel_converter_init(const ma_channel_converter_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_channel_converter* pConverter);
+MA_API void ma_channel_converter_uninit(ma_channel_converter* pConverter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_channel_converter_process_pcm_frames(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
+MA_API ma_result ma_channel_converter_get_input_channel_map(const ma_channel_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_channel_converter_get_output_channel_map(const ma_channel_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap);
+
+
+/**************************************************************************************************************************************************************
+
+Data Conversion
+
+**************************************************************************************************************************************************************/
+typedef struct
+{
+    ma_format formatIn;
+    ma_format formatOut;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_uint32 sampleRateIn;
+    ma_uint32 sampleRateOut;
+    ma_channel* pChannelMapIn;
+    ma_channel* pChannelMapOut;
+    ma_dither_mode ditherMode;
+    ma_channel_mix_mode channelMixMode;
+    ma_bool32 calculateLFEFromSpatialChannels;  /* When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. */
+    float** ppChannelWeights;  /* [in][out]. Only used when mixingMode is set to ma_channel_mix_mode_custom_weights. */
+    ma_bool32 allowDynamicSampleRate;
+    ma_resampler_config resampling;
+} ma_data_converter_config;
+
+MA_API ma_data_converter_config ma_data_converter_config_init_default(void);
+MA_API ma_data_converter_config ma_data_converter_config_init(ma_format formatIn, ma_format formatOut, ma_uint32 channelsIn, ma_uint32 channelsOut, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);
+
+
+typedef enum
+{
+    ma_data_converter_execution_path_passthrough,       /* No conversion. */
+    ma_data_converter_execution_path_format_only,       /* Only format conversion. */
+    ma_data_converter_execution_path_channels_only,     /* Only channel conversion. */
+    ma_data_converter_execution_path_resample_only,     /* Only resampling. */
+    ma_data_converter_execution_path_resample_first,    /* All conversions, but resample as the first step. */
+    ma_data_converter_execution_path_channels_first     /* All conversions, but channels as the first step. */
+} ma_data_converter_execution_path;
+
+typedef struct
+{
+    ma_format formatIn;
+    ma_format formatOut;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_uint32 sampleRateIn;
+    ma_uint32 sampleRateOut;
+    ma_dither_mode ditherMode;
+    ma_data_converter_execution_path executionPath; /* The execution path the data converter will follow when processing. */
+    ma_channel_converter channelConverter;
+    ma_resampler resampler;
+    ma_bool8 hasPreFormatConversion;
+    ma_bool8 hasPostFormatConversion;
+    ma_bool8 hasChannelConverter;
+    ma_bool8 hasResampler;
+    ma_bool8 isPassthrough;
+
+    /* Memory management. */
+    ma_bool8 _ownsHeap;
+    void* _pHeap;
+} ma_data_converter;
+
+MA_API ma_result ma_data_converter_get_heap_size(const ma_data_converter_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_data_converter_init_preallocated(const ma_data_converter_config* pConfig, void* pHeap, ma_data_converter* pConverter);
+MA_API ma_result ma_data_converter_init(const ma_data_converter_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_converter* pConverter);
+MA_API void ma_data_converter_uninit(ma_data_converter* pConverter, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_data_converter_process_pcm_frames(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
+MA_API ma_result ma_data_converter_set_rate(ma_data_converter* pConverter, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut);
+MA_API ma_result ma_data_converter_set_rate_ratio(ma_data_converter* pConverter, float ratioInOut);
+MA_API ma_uint64 ma_data_converter_get_input_latency(const ma_data_converter* pConverter);
+MA_API ma_uint64 ma_data_converter_get_output_latency(const ma_data_converter* pConverter);
+MA_API ma_result ma_data_converter_get_required_input_frame_count(const ma_data_converter* pConverter, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount);
+MA_API ma_result ma_data_converter_get_expected_output_frame_count(const ma_data_converter* pConverter, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);
+MA_API ma_result ma_data_converter_get_input_channel_map(const ma_data_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_data_converter_get_output_channel_map(const ma_data_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_data_converter_reset(ma_data_converter* pConverter);
+
+
+/************************************************************************************************************************************************************
+
+Format Conversion
+
+************************************************************************************************************************************************************/
+MA_API void ma_pcm_u8_to_s16(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_u8_to_s24(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_u8_to_s32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_u8_to_f32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s16_to_u8(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s16_to_s24(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s16_to_s32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s16_to_f32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s24_to_u8(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s24_to_s16(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s24_to_s32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s24_to_f32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s32_to_u8(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s32_to_s16(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s32_to_s24(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_s32_to_f32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_f32_to_u8(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_f32_to_s16(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_f32_to_s24(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_f32_to_s32(void* pOut, const void* pIn, ma_uint64 count, ma_dither_mode ditherMode);
+MA_API void ma_pcm_convert(void* pOut, ma_format formatOut, const void* pIn, ma_format formatIn, ma_uint64 sampleCount, ma_dither_mode ditherMode);
+MA_API void ma_convert_pcm_frames_format(void* pOut, ma_format formatOut, const void* pIn, ma_format formatIn, ma_uint64 frameCount, ma_uint32 channels, ma_dither_mode ditherMode);
+
+/*
+Deinterleaves an interleaved buffer.
+*/
+MA_API void ma_deinterleave_pcm_frames(ma_format format, ma_uint32 channels, ma_uint64 frameCount, const void* pInterleavedPCMFrames, void** ppDeinterleavedPCMFrames);
+
+/*
+Interleaves a group of deinterleaved buffers.
+*/
+MA_API void ma_interleave_pcm_frames(ma_format format, ma_uint32 channels, ma_uint64 frameCount, const void** ppDeinterleavedPCMFrames, void* pInterleavedPCMFrames);
+
+
+/************************************************************************************************************************************************************
+
+Channel Maps
+
+************************************************************************************************************************************************************/
+/*
+This is used in the shuffle table to indicate that the channel index is undefined and should be ignored.
+*/
+#define MA_CHANNEL_INDEX_NULL   255
+
+/*
+Retrieves the channel position of the specified channel in the given channel map.
+
+The pChannelMap parameter can be null, in which case miniaudio's default channel map will be assumed.
+*/
+MA_API ma_channel ma_channel_map_get_channel(const ma_channel* pChannelMap, ma_uint32 channelCount, ma_uint32 channelIndex);
+
+/*
+Initializes a blank channel map.
+
+When a blank channel map is specified anywhere it indicates that the native channel map should be used.
+*/
+MA_API void ma_channel_map_init_blank(ma_channel* pChannelMap, ma_uint32 channels);
+
+/*
+Helper for retrieving a standard channel map.
+
+The output channel map buffer must have a capacity of at least `channelMapCap`.
+*/
+MA_API void ma_channel_map_init_standard(ma_standard_channel_map standardChannelMap, ma_channel* pChannelMap, size_t channelMapCap, ma_uint32 channels);
+
+/*
+Copies a channel map.
+
+Both input and output channel map buffers must have a capacity of at at least `channels`.
+*/
+MA_API void ma_channel_map_copy(ma_channel* pOut, const ma_channel* pIn, ma_uint32 channels);
+
+/*
+Copies a channel map if one is specified, otherwise copies the default channel map.
+
+The output buffer must have a capacity of at least `channels`. If not NULL, the input channel map must also have a capacity of at least `channels`.
+*/
+MA_API void ma_channel_map_copy_or_default(ma_channel* pOut, size_t channelMapCapOut, const ma_channel* pIn, ma_uint32 channels);
+
+
+/*
+Determines whether or not a channel map is valid.
+
+A blank channel map is valid (all channels set to MA_CHANNEL_NONE). The way a blank channel map is handled is context specific, but
+is usually treated as a passthrough.
+
+Invalid channel maps:
+  - A channel map with no channels
+  - A channel map with more than one channel and a mono channel
+
+The channel map buffer must have a capacity of at least `channels`.
+*/
+MA_API ma_bool32 ma_channel_map_is_valid(const ma_channel* pChannelMap, ma_uint32 channels);
+
+/*
+Helper for comparing two channel maps for equality.
+
+This assumes the channel count is the same between the two.
+
+Both channels map buffers must have a capacity of at least `channels`.
+*/
+MA_API ma_bool32 ma_channel_map_is_equal(const ma_channel* pChannelMapA, const ma_channel* pChannelMapB, ma_uint32 channels);
+
+/*
+Helper for determining if a channel map is blank (all channels set to MA_CHANNEL_NONE).
+
+The channel map buffer must have a capacity of at least `channels`.
+*/
+MA_API ma_bool32 ma_channel_map_is_blank(const ma_channel* pChannelMap, ma_uint32 channels);
+
+/*
+Helper for determining whether or not a channel is present in the given channel map.
+
+The channel map buffer must have a capacity of at least `channels`.
+*/
+MA_API ma_bool32 ma_channel_map_contains_channel_position(ma_uint32 channels, const ma_channel* pChannelMap, ma_channel channelPosition);
+
+/*
+Find a channel position in the given channel map. Returns MA_TRUE if the channel is found; MA_FALSE otherwise. The
+index of the channel is output to `pChannelIndex`.
+
+The channel map buffer must have a capacity of at least `channels`.
+*/
+MA_API ma_bool32 ma_channel_map_find_channel_position(ma_uint32 channels, const ma_channel* pChannelMap, ma_channel channelPosition, ma_uint32* pChannelIndex);
+
+/*
+Generates a string representing the given channel map.
+
+This is for printing and debugging purposes, not serialization/deserialization.
+
+Returns the length of the string, not including the null terminator.
+*/
+MA_API size_t ma_channel_map_to_string(const ma_channel* pChannelMap, ma_uint32 channels, char* pBufferOut, size_t bufferCap);
+
+/*
+Retrieves a human readable version of a channel position.
+*/
+MA_API const char* ma_channel_position_to_string(ma_channel channel);
+
+
+/************************************************************************************************************************************************************
+
+Conversion Helpers
+
+************************************************************************************************************************************************************/
+
+/*
+High-level helper for doing a full format conversion in one go. Returns the number of output frames. Call this with pOut set to NULL to
+determine the required size of the output buffer. frameCountOut should be set to the capacity of pOut. If pOut is NULL, frameCountOut is
+ignored.
+
+A return value of 0 indicates an error.
+
+This function is useful for one-off bulk conversions, but if you're streaming data you should use the ma_data_converter APIs instead.
+*/
+MA_API ma_uint64 ma_convert_frames(void* pOut, ma_uint64 frameCountOut, ma_format formatOut, ma_uint32 channelsOut, ma_uint32 sampleRateOut, const void* pIn, ma_uint64 frameCountIn, ma_format formatIn, ma_uint32 channelsIn, ma_uint32 sampleRateIn);
+MA_API ma_uint64 ma_convert_frames_ex(void* pOut, ma_uint64 frameCountOut, const void* pIn, ma_uint64 frameCountIn, const ma_data_converter_config* pConfig);
+
+
+/************************************************************************************************************************************************************
+
+Data Source
+
+************************************************************************************************************************************************************/
+typedef void ma_data_source;
+
+#define MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT    0x00000001
+
+typedef struct
+{
+    ma_result (* onRead)(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+    ma_result (* onSeek)(ma_data_source* pDataSource, ma_uint64 frameIndex);
+    ma_result (* onGetDataFormat)(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+    ma_result (* onGetCursor)(ma_data_source* pDataSource, ma_uint64* pCursor);
+    ma_result (* onGetLength)(ma_data_source* pDataSource, ma_uint64* pLength);
+    ma_result (* onSetLooping)(ma_data_source* pDataSource, ma_bool32 isLooping);
+    ma_uint32 flags;
+} ma_data_source_vtable;
+
+typedef ma_data_source* (* ma_data_source_get_next_proc)(ma_data_source* pDataSource);
+
+typedef struct
+{
+    const ma_data_source_vtable* vtable;
+} ma_data_source_config;
+
+MA_API ma_data_source_config ma_data_source_config_init(void);
+
+
+typedef struct
+{
+    const ma_data_source_vtable* vtable;
+    ma_uint64 rangeBegInFrames;
+    ma_uint64 rangeEndInFrames;             /* Set to -1 for unranged (default). */
+    ma_uint64 loopBegInFrames;              /* Relative to rangeBegInFrames. */
+    ma_uint64 loopEndInFrames;              /* Relative to rangeBegInFrames. Set to -1 for the end of the range. */
+    ma_data_source* pCurrent;               /* When non-NULL, the data source being initialized will act as a proxy and will route all operations to pCurrent. Used in conjunction with pNext/onGetNext for seamless chaining. */
+    ma_data_source* pNext;                  /* When set to NULL, onGetNext will be used. */
+    ma_data_source_get_next_proc onGetNext; /* Will be used when pNext is NULL. If both are NULL, no next will be used. */
+    MA_ATOMIC(4, ma_bool32) isLooping;
+} ma_data_source_base;
+
+MA_API ma_result ma_data_source_init(const ma_data_source_config* pConfig, ma_data_source* pDataSource);
+MA_API void ma_data_source_uninit(ma_data_source* pDataSource);
+MA_API ma_result ma_data_source_read_pcm_frames(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);   /* Must support pFramesOut = NULL in which case a forward seek should be performed. */
+MA_API ma_result ma_data_source_seek_pcm_frames(ma_data_source* pDataSource, ma_uint64 frameCount, ma_uint64* pFramesSeeked); /* Can only seek forward. Equivalent to ma_data_source_read_pcm_frames(pDataSource, NULL, frameCount, &framesRead); */
+MA_API ma_result ma_data_source_seek_to_pcm_frame(ma_data_source* pDataSource, ma_uint64 frameIndex);
+MA_API ma_result ma_data_source_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_data_source_get_cursor_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pCursor);
+MA_API ma_result ma_data_source_get_length_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pLength);    /* Returns MA_NOT_IMPLEMENTED if the length is unknown or cannot be determined. Decoders can return this. */
+MA_API ma_result ma_data_source_get_cursor_in_seconds(ma_data_source* pDataSource, float* pCursor);
+MA_API ma_result ma_data_source_get_length_in_seconds(ma_data_source* pDataSource, float* pLength);
+MA_API ma_result ma_data_source_set_looping(ma_data_source* pDataSource, ma_bool32 isLooping);
+MA_API ma_bool32 ma_data_source_is_looping(const ma_data_source* pDataSource);
+MA_API ma_result ma_data_source_set_range_in_pcm_frames(ma_data_source* pDataSource, ma_uint64 rangeBegInFrames, ma_uint64 rangeEndInFrames);
+MA_API void ma_data_source_get_range_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pRangeBegInFrames, ma_uint64* pRangeEndInFrames);
+MA_API ma_result ma_data_source_set_loop_point_in_pcm_frames(ma_data_source* pDataSource, ma_uint64 loopBegInFrames, ma_uint64 loopEndInFrames);
+MA_API void ma_data_source_get_loop_point_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pLoopBegInFrames, ma_uint64* pLoopEndInFrames);
+MA_API ma_result ma_data_source_set_current(ma_data_source* pDataSource, ma_data_source* pCurrentDataSource);
+MA_API ma_data_source* ma_data_source_get_current(const ma_data_source* pDataSource);
+MA_API ma_result ma_data_source_set_next(ma_data_source* pDataSource, ma_data_source* pNextDataSource);
+MA_API ma_data_source* ma_data_source_get_next(const ma_data_source* pDataSource);
+MA_API ma_result ma_data_source_set_next_callback(ma_data_source* pDataSource, ma_data_source_get_next_proc onGetNext);
+MA_API ma_data_source_get_next_proc ma_data_source_get_next_callback(const ma_data_source* pDataSource);
+
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint64 cursor;
+    ma_uint64 sizeInFrames;
+    const void* pData;
+} ma_audio_buffer_ref;
+
+MA_API ma_result ma_audio_buffer_ref_init(ma_format format, ma_uint32 channels, const void* pData, ma_uint64 sizeInFrames, ma_audio_buffer_ref* pAudioBufferRef);
+MA_API void ma_audio_buffer_ref_uninit(ma_audio_buffer_ref* pAudioBufferRef);
+MA_API ma_result ma_audio_buffer_ref_set_data(ma_audio_buffer_ref* pAudioBufferRef, const void* pData, ma_uint64 sizeInFrames);
+MA_API ma_uint64 ma_audio_buffer_ref_read_pcm_frames(ma_audio_buffer_ref* pAudioBufferRef, void* pFramesOut, ma_uint64 frameCount, ma_bool32 loop);
+MA_API ma_result ma_audio_buffer_ref_seek_to_pcm_frame(ma_audio_buffer_ref* pAudioBufferRef, ma_uint64 frameIndex);
+MA_API ma_result ma_audio_buffer_ref_map(ma_audio_buffer_ref* pAudioBufferRef, void** ppFramesOut, ma_uint64* pFrameCount);
+MA_API ma_result ma_audio_buffer_ref_unmap(ma_audio_buffer_ref* pAudioBufferRef, ma_uint64 frameCount);    /* Returns MA_AT_END if the end has been reached. This should be considered successful. */
+MA_API ma_bool32 ma_audio_buffer_ref_at_end(const ma_audio_buffer_ref* pAudioBufferRef);
+MA_API ma_result ma_audio_buffer_ref_get_cursor_in_pcm_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pCursor);
+MA_API ma_result ma_audio_buffer_ref_get_length_in_pcm_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pLength);
+MA_API ma_result ma_audio_buffer_ref_get_available_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pAvailableFrames);
+
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint64 sizeInFrames;
+    const void* pData;  /* If set to NULL, will allocate a block of memory for you. */
+    ma_allocation_callbacks allocationCallbacks;
+} ma_audio_buffer_config;
+
+MA_API ma_audio_buffer_config ma_audio_buffer_config_init(ma_format format, ma_uint32 channels, ma_uint64 sizeInFrames, const void* pData, const ma_allocation_callbacks* pAllocationCallbacks);
+
+typedef struct
+{
+    ma_audio_buffer_ref ref;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_bool32 ownsData;             /* Used to control whether or not miniaudio owns the data buffer. If set to true, pData will be freed in ma_audio_buffer_uninit(). */
+    ma_uint8 _pExtraData[1];        /* For allocating a buffer with the memory located directly after the other memory of the structure. */
+} ma_audio_buffer;
+
+MA_API ma_result ma_audio_buffer_init(const ma_audio_buffer_config* pConfig, ma_audio_buffer* pAudioBuffer);
+MA_API ma_result ma_audio_buffer_init_copy(const ma_audio_buffer_config* pConfig, ma_audio_buffer* pAudioBuffer);
+MA_API ma_result ma_audio_buffer_alloc_and_init(const ma_audio_buffer_config* pConfig, ma_audio_buffer** ppAudioBuffer);  /* Always copies the data. Doesn't make sense to use this otherwise. Use ma_audio_buffer_uninit_and_free() to uninit. */
+MA_API void ma_audio_buffer_uninit(ma_audio_buffer* pAudioBuffer);
+MA_API void ma_audio_buffer_uninit_and_free(ma_audio_buffer* pAudioBuffer);
+MA_API ma_uint64 ma_audio_buffer_read_pcm_frames(ma_audio_buffer* pAudioBuffer, void* pFramesOut, ma_uint64 frameCount, ma_bool32 loop);
+MA_API ma_result ma_audio_buffer_seek_to_pcm_frame(ma_audio_buffer* pAudioBuffer, ma_uint64 frameIndex);
+MA_API ma_result ma_audio_buffer_map(ma_audio_buffer* pAudioBuffer, void** ppFramesOut, ma_uint64* pFrameCount);
+MA_API ma_result ma_audio_buffer_unmap(ma_audio_buffer* pAudioBuffer, ma_uint64 frameCount);    /* Returns MA_AT_END if the end has been reached. This should be considered successful. */
+MA_API ma_bool32 ma_audio_buffer_at_end(const ma_audio_buffer* pAudioBuffer);
+MA_API ma_result ma_audio_buffer_get_cursor_in_pcm_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pCursor);
+MA_API ma_result ma_audio_buffer_get_length_in_pcm_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pLength);
+MA_API ma_result ma_audio_buffer_get_available_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pAvailableFrames);
+
+
+/*
+Paged Audio Buffer
+==================
+A paged audio buffer is made up of a linked list of pages. It's expandable, but not shrinkable. It
+can be used for cases where audio data is streamed in asynchronously while allowing data to be read
+at the same time.
+
+This is lock-free, but not 100% thread safe. You can append a page and read from the buffer across
+simultaneously across different threads, however only one thread at a time can append, and only one
+thread at a time can read and seek.
+*/
+typedef struct ma_paged_audio_buffer_page ma_paged_audio_buffer_page;
+struct ma_paged_audio_buffer_page
+{
+    MA_ATOMIC(MA_SIZEOF_PTR, ma_paged_audio_buffer_page*) pNext;
+    ma_uint64 sizeInFrames;
+    ma_uint8 pAudioData[1];
+};
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_paged_audio_buffer_page head;                                /* Dummy head for the lock-free algorithm. Always has a size of 0. */
+    MA_ATOMIC(MA_SIZEOF_PTR, ma_paged_audio_buffer_page*) pTail;    /* Never null. Initially set to &head. */
+} ma_paged_audio_buffer_data;
+
+MA_API ma_result ma_paged_audio_buffer_data_init(ma_format format, ma_uint32 channels, ma_paged_audio_buffer_data* pData);
+MA_API void ma_paged_audio_buffer_data_uninit(ma_paged_audio_buffer_data* pData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_paged_audio_buffer_page* ma_paged_audio_buffer_data_get_head(ma_paged_audio_buffer_data* pData);
+MA_API ma_paged_audio_buffer_page* ma_paged_audio_buffer_data_get_tail(ma_paged_audio_buffer_data* pData);
+MA_API ma_result ma_paged_audio_buffer_data_get_length_in_pcm_frames(ma_paged_audio_buffer_data* pData, ma_uint64* pLength);
+MA_API ma_result ma_paged_audio_buffer_data_allocate_page(ma_paged_audio_buffer_data* pData, ma_uint64 pageSizeInFrames, const void* pInitialData, const ma_allocation_callbacks* pAllocationCallbacks, ma_paged_audio_buffer_page** ppPage);
+MA_API ma_result ma_paged_audio_buffer_data_free_page(ma_paged_audio_buffer_data* pData, ma_paged_audio_buffer_page* pPage, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_paged_audio_buffer_data_append_page(ma_paged_audio_buffer_data* pData, ma_paged_audio_buffer_page* pPage);
+MA_API ma_result ma_paged_audio_buffer_data_allocate_and_append_page(ma_paged_audio_buffer_data* pData, ma_uint32 pageSizeInFrames, const void* pInitialData, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+typedef struct
+{
+    ma_paged_audio_buffer_data* pData;  /* Must not be null. */
+} ma_paged_audio_buffer_config;
+
+MA_API ma_paged_audio_buffer_config ma_paged_audio_buffer_config_init(ma_paged_audio_buffer_data* pData);
+
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_paged_audio_buffer_data* pData;              /* Audio data is read from here. Cannot be null. */
+    ma_paged_audio_buffer_page* pCurrent;
+    ma_uint64 relativeCursor;                       /* Relative to the current page. */
+    ma_uint64 absoluteCursor;
+} ma_paged_audio_buffer;
+
+MA_API ma_result ma_paged_audio_buffer_init(const ma_paged_audio_buffer_config* pConfig, ma_paged_audio_buffer* pPagedAudioBuffer);
+MA_API void ma_paged_audio_buffer_uninit(ma_paged_audio_buffer* pPagedAudioBuffer);
+MA_API ma_result ma_paged_audio_buffer_read_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);   /* Returns MA_AT_END if no more pages available. */
+MA_API ma_result ma_paged_audio_buffer_seek_to_pcm_frame(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64 frameIndex);
+MA_API ma_result ma_paged_audio_buffer_get_cursor_in_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64* pCursor);
+MA_API ma_result ma_paged_audio_buffer_get_length_in_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64* pLength);
+
+
+
+/************************************************************************************************************************************************************
+
+Ring Buffer
+
+************************************************************************************************************************************************************/
+typedef struct
+{
+    void* pBuffer;
+    ma_uint32 subbufferSizeInBytes;
+    ma_uint32 subbufferCount;
+    ma_uint32 subbufferStrideInBytes;
+    MA_ATOMIC(4, ma_uint32) encodedReadOffset;  /* Most significant bit is the loop flag. Lower 31 bits contains the actual offset in bytes. Must be used atomically. */
+    MA_ATOMIC(4, ma_uint32) encodedWriteOffset; /* Most significant bit is the loop flag. Lower 31 bits contains the actual offset in bytes. Must be used atomically. */
+    ma_bool8 ownsBuffer;                        /* Used to know whether or not miniaudio is responsible for free()-ing the buffer. */
+    ma_bool8 clearOnWriteAcquire;               /* When set, clears the acquired write buffer before returning from ma_rb_acquire_write(). */
+    ma_allocation_callbacks allocationCallbacks;
+} ma_rb;
+
+MA_API ma_result ma_rb_init_ex(size_t subbufferSizeInBytes, size_t subbufferCount, size_t subbufferStrideInBytes, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_rb* pRB);
+MA_API ma_result ma_rb_init(size_t bufferSizeInBytes, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_rb* pRB);
+MA_API void ma_rb_uninit(ma_rb* pRB);
+MA_API void ma_rb_reset(ma_rb* pRB);
+MA_API ma_result ma_rb_acquire_read(ma_rb* pRB, size_t* pSizeInBytes, void** ppBufferOut);
+MA_API ma_result ma_rb_commit_read(ma_rb* pRB, size_t sizeInBytes);
+MA_API ma_result ma_rb_acquire_write(ma_rb* pRB, size_t* pSizeInBytes, void** ppBufferOut);
+MA_API ma_result ma_rb_commit_write(ma_rb* pRB, size_t sizeInBytes);
+MA_API ma_result ma_rb_seek_read(ma_rb* pRB, size_t offsetInBytes);
+MA_API ma_result ma_rb_seek_write(ma_rb* pRB, size_t offsetInBytes);
+MA_API ma_int32 ma_rb_pointer_distance(ma_rb* pRB);    /* Returns the distance between the write pointer and the read pointer. Should never be negative for a correct program. Will return the number of bytes that can be read before the read pointer hits the write pointer. */
+MA_API ma_uint32 ma_rb_available_read(ma_rb* pRB);
+MA_API ma_uint32 ma_rb_available_write(ma_rb* pRB);
+MA_API size_t ma_rb_get_subbuffer_size(ma_rb* pRB);
+MA_API size_t ma_rb_get_subbuffer_stride(ma_rb* pRB);
+MA_API size_t ma_rb_get_subbuffer_offset(ma_rb* pRB, size_t subbufferIndex);
+MA_API void* ma_rb_get_subbuffer_ptr(ma_rb* pRB, size_t subbufferIndex, void* pBuffer);
+
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_rb rb;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate; /* Not required for the ring buffer itself, but useful for associating the data with some sample rate, particularly for data sources. */
+} ma_pcm_rb;
+
+MA_API ma_result ma_pcm_rb_init_ex(ma_format format, ma_uint32 channels, ma_uint32 subbufferSizeInFrames, ma_uint32 subbufferCount, ma_uint32 subbufferStrideInFrames, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_pcm_rb* pRB);
+MA_API ma_result ma_pcm_rb_init(ma_format format, ma_uint32 channels, ma_uint32 bufferSizeInFrames, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_pcm_rb* pRB);
+MA_API void ma_pcm_rb_uninit(ma_pcm_rb* pRB);
+MA_API void ma_pcm_rb_reset(ma_pcm_rb* pRB);
+MA_API ma_result ma_pcm_rb_acquire_read(ma_pcm_rb* pRB, ma_uint32* pSizeInFrames, void** ppBufferOut);
+MA_API ma_result ma_pcm_rb_commit_read(ma_pcm_rb* pRB, ma_uint32 sizeInFrames);
+MA_API ma_result ma_pcm_rb_acquire_write(ma_pcm_rb* pRB, ma_uint32* pSizeInFrames, void** ppBufferOut);
+MA_API ma_result ma_pcm_rb_commit_write(ma_pcm_rb* pRB, ma_uint32 sizeInFrames);
+MA_API ma_result ma_pcm_rb_seek_read(ma_pcm_rb* pRB, ma_uint32 offsetInFrames);
+MA_API ma_result ma_pcm_rb_seek_write(ma_pcm_rb* pRB, ma_uint32 offsetInFrames);
+MA_API ma_int32 ma_pcm_rb_pointer_distance(ma_pcm_rb* pRB); /* Return value is in frames. */
+MA_API ma_uint32 ma_pcm_rb_available_read(ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_available_write(ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_size(ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_stride(ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_offset(ma_pcm_rb* pRB, ma_uint32 subbufferIndex);
+MA_API void* ma_pcm_rb_get_subbuffer_ptr(ma_pcm_rb* pRB, ma_uint32 subbufferIndex, void* pBuffer);
+MA_API ma_format ma_pcm_rb_get_format(const ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_get_channels(const ma_pcm_rb* pRB);
+MA_API ma_uint32 ma_pcm_rb_get_sample_rate(const ma_pcm_rb* pRB);
+MA_API void ma_pcm_rb_set_sample_rate(ma_pcm_rb* pRB, ma_uint32 sampleRate);
+
+
+/*
+The idea of the duplex ring buffer is to act as the intermediary buffer when running two asynchronous devices in a duplex set up. The
+capture device writes to it, and then a playback device reads from it.
+
+At the moment this is just a simple naive implementation, but in the future I want to implement some dynamic resampling to seamlessly
+handle desyncs. Note that the API is work in progress and may change at any time in any version.
+
+The size of the buffer is based on the capture side since that's what'll be written to the buffer. It is based on the capture period size
+in frames. The internal sample rate of the capture device is also needed in order to calculate the size.
+*/
+typedef struct
+{
+    ma_pcm_rb rb;
+} ma_duplex_rb;
+
+MA_API ma_result ma_duplex_rb_init(ma_format captureFormat, ma_uint32 captureChannels, ma_uint32 sampleRate, ma_uint32 captureInternalSampleRate, ma_uint32 captureInternalPeriodSizeInFrames, const ma_allocation_callbacks* pAllocationCallbacks, ma_duplex_rb* pRB);
+MA_API ma_result ma_duplex_rb_uninit(ma_duplex_rb* pRB);
+
+
+/************************************************************************************************************************************************************
+
+Miscellaneous Helpers
+
+************************************************************************************************************************************************************/
+/*
+Retrieves a human readable description of the given result code.
+*/
+MA_API const char* ma_result_description(ma_result result);
+
+/*
+malloc()
+*/
+MA_API void* ma_malloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+calloc()
+*/
+MA_API void* ma_calloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+realloc()
+*/
+MA_API void* ma_realloc(void* p, size_t sz, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+free()
+*/
+MA_API void ma_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Performs an aligned malloc, with the assumption that the alignment is a power of 2.
+*/
+MA_API void* ma_aligned_malloc(size_t sz, size_t alignment, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Free's an aligned malloc'd buffer.
+*/
+MA_API void ma_aligned_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks);
+
+/*
+Retrieves a friendly name for a format.
+*/
+MA_API const char* ma_get_format_name(ma_format format);
+
+/*
+Blends two frames in floating point format.
+*/
+MA_API void ma_blend_f32(float* pOut, float* pInA, float* pInB, float factor, ma_uint32 channels);
+
+/*
+Retrieves the size of a sample in bytes for the given format.
+
+This API is efficient and is implemented using a lookup table.
+
+Thread Safety: SAFE
+  This API is pure.
+*/
+MA_API ma_uint32 ma_get_bytes_per_sample(ma_format format);
+static MA_INLINE ma_uint32 ma_get_bytes_per_frame(ma_format format, ma_uint32 channels) { return ma_get_bytes_per_sample(format) * channels; }
+
+/*
+Converts a log level to a string.
+*/
+MA_API const char* ma_log_level_to_string(ma_uint32 logLevel);
+
+
+
+
+/************************************************************************************************************************************************************
+
+Synchronization
+
+************************************************************************************************************************************************************/
+/*
+Locks a spinlock.
+*/
+MA_API ma_result ma_spinlock_lock(volatile ma_spinlock* pSpinlock);
+
+/*
+Locks a spinlock, but does not yield() when looping.
+*/
+MA_API ma_result ma_spinlock_lock_noyield(volatile ma_spinlock* pSpinlock);
+
+/*
+Unlocks a spinlock.
+*/
+MA_API ma_result ma_spinlock_unlock(volatile ma_spinlock* pSpinlock);
+
+
+#ifndef MA_NO_THREADING
+
+/*
+Creates a mutex.
+
+A mutex must be created from a valid context. A mutex is initially unlocked.
+*/
+MA_API ma_result ma_mutex_init(ma_mutex* pMutex);
+
+/*
+Deletes a mutex.
+*/
+MA_API void ma_mutex_uninit(ma_mutex* pMutex);
+
+/*
+Locks a mutex with an infinite timeout.
+*/
+MA_API void ma_mutex_lock(ma_mutex* pMutex);
+
+/*
+Unlocks a mutex.
+*/
+MA_API void ma_mutex_unlock(ma_mutex* pMutex);
+
+
+/*
+Initializes an auto-reset event.
+*/
+MA_API ma_result ma_event_init(ma_event* pEvent);
+
+/*
+Uninitializes an auto-reset event.
+*/
+MA_API void ma_event_uninit(ma_event* pEvent);
+
+/*
+Waits for the specified auto-reset event to become signalled.
+*/
+MA_API ma_result ma_event_wait(ma_event* pEvent);
+
+/*
+Signals the specified auto-reset event.
+*/
+MA_API ma_result ma_event_signal(ma_event* pEvent);
+#endif  /* MA_NO_THREADING */
+
+
+/*
+Fence
+=====
+This locks while the counter is larger than 0. Counter can be incremented and decremented by any
+thread, but care needs to be taken when waiting. It is possible for one thread to acquire the
+fence just as another thread returns from ma_fence_wait().
+
+The idea behind a fence is to allow you to wait for a group of operations to complete. When an
+operation starts, the counter is incremented which locks the fence. When the operation completes,
+the fence will be released which decrements the counter. ma_fence_wait() will block until the
+counter hits zero.
+
+If threading is disabled, ma_fence_wait() will spin on the counter.
+*/
+typedef struct
+{
+#ifndef MA_NO_THREADING
+    ma_event e;
+#endif
+    ma_uint32 counter;
+} ma_fence;
+
+MA_API ma_result ma_fence_init(ma_fence* pFence);
+MA_API void ma_fence_uninit(ma_fence* pFence);
+MA_API ma_result ma_fence_acquire(ma_fence* pFence);    /* Increment counter. */
+MA_API ma_result ma_fence_release(ma_fence* pFence);    /* Decrement counter. */
+MA_API ma_result ma_fence_wait(ma_fence* pFence);       /* Wait for counter to reach 0. */
+
+
+
+/*
+Notification callback for asynchronous operations.
+*/
+typedef void ma_async_notification;
+
+typedef struct
+{
+    void (* onSignal)(ma_async_notification* pNotification);
+} ma_async_notification_callbacks;
+
+MA_API ma_result ma_async_notification_signal(ma_async_notification* pNotification);
+
+
+/*
+Simple polling notification.
+
+This just sets a variable when the notification has been signalled which is then polled with ma_async_notification_poll_is_signalled()
+*/
+typedef struct
+{
+    ma_async_notification_callbacks cb;
+    ma_bool32 signalled;
+} ma_async_notification_poll;
+
+MA_API ma_result ma_async_notification_poll_init(ma_async_notification_poll* pNotificationPoll);
+MA_API ma_bool32 ma_async_notification_poll_is_signalled(const ma_async_notification_poll* pNotificationPoll);
+
+
+/*
+Event Notification
+
+This uses an ma_event. If threading is disabled (MA_NO_THREADING), initialization will fail.
+*/
+typedef struct
+{
+    ma_async_notification_callbacks cb;
+#ifndef MA_NO_THREADING
+    ma_event e;
+#endif
+} ma_async_notification_event;
+
+MA_API ma_result ma_async_notification_event_init(ma_async_notification_event* pNotificationEvent);
+MA_API ma_result ma_async_notification_event_uninit(ma_async_notification_event* pNotificationEvent);
+MA_API ma_result ma_async_notification_event_wait(ma_async_notification_event* pNotificationEvent);
+MA_API ma_result ma_async_notification_event_signal(ma_async_notification_event* pNotificationEvent);
+
+
+
+
+/************************************************************************************************************************************************************
+
+Job Queue
+
+************************************************************************************************************************************************************/
+
+/*
+Slot Allocator
+--------------
+The idea of the slot allocator is for it to be used in conjunction with a fixed sized buffer. You use the slot allocator to allocator an index that can be used
+as the insertion point for an object.
+
+Slots are reference counted to help mitigate the ABA problem in the lock-free queue we use for tracking jobs.
+
+The slot index is stored in the low 32 bits. The reference counter is stored in the high 32 bits:
+
+    +-----------------+-----------------+
+    | 32 Bits         | 32 Bits         |
+    +-----------------+-----------------+
+    | Reference Count | Slot Index      |
+    +-----------------+-----------------+
+*/
+typedef struct
+{
+    ma_uint32 capacity;    /* The number of slots to make available. */
+} ma_slot_allocator_config;
+
+MA_API ma_slot_allocator_config ma_slot_allocator_config_init(ma_uint32 capacity);
+
+
+typedef struct
+{
+    MA_ATOMIC(4, ma_uint32) bitfield;   /* Must be used atomically because the allocation and freeing routines need to make copies of this which must never be optimized away by the compiler. */
+} ma_slot_allocator_group;
+
+typedef struct
+{
+    ma_slot_allocator_group* pGroups;   /* Slots are grouped in chunks of 32. */
+    ma_uint32* pSlots;                  /* 32 bits for reference counting for ABA mitigation. */
+    ma_uint32 count;                    /* Allocation count. */
+    ma_uint32 capacity;
+
+    /* Memory management. */
+    ma_bool32 _ownsHeap;
+    void* _pHeap;
+} ma_slot_allocator;
+
+MA_API ma_result ma_slot_allocator_get_heap_size(const ma_slot_allocator_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_slot_allocator_init_preallocated(const ma_slot_allocator_config* pConfig, void* pHeap, ma_slot_allocator* pAllocator);
+MA_API ma_result ma_slot_allocator_init(const ma_slot_allocator_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_slot_allocator* pAllocator);
+MA_API void ma_slot_allocator_uninit(ma_slot_allocator* pAllocator, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_slot_allocator_alloc(ma_slot_allocator* pAllocator, ma_uint64* pSlot);
+MA_API ma_result ma_slot_allocator_free(ma_slot_allocator* pAllocator, ma_uint64 slot);
+
+
+typedef struct ma_job ma_job;
+
+/*
+Callback for processing a job. Each job type will have their own processing callback which will be
+called by ma_job_process().
+*/
+typedef ma_result (* ma_job_proc)(ma_job* pJob);
+
+/* When a job type is added here an callback needs to be added go "g_jobVTable" in the implementation section. */
+typedef enum
+{
+    /* Miscellaneous. */
+    MA_JOB_TYPE_QUIT = 0,
+    MA_JOB_TYPE_CUSTOM,
+
+    /* Resource Manager. */
+    MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE,
+    MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE,
+    MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE,
+    MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER,
+    MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER,
+    MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM,
+    MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM,
+    MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_STREAM,
+    MA_JOB_TYPE_RESOURCE_MANAGER_SEEK_DATA_STREAM,
+
+    /* Device. */
+    MA_JOB_TYPE_DEVICE_AAUDIO_REROUTE,
+
+    /* Count. Must always be last. */
+    MA_JOB_TYPE_COUNT
+} ma_job_type;
+
+struct ma_job
+{
+    union
+    {
+        struct
+        {
+            ma_uint16 code;         /* Job type. */
+            ma_uint16 slot;         /* Index into a ma_slot_allocator. */
+            ma_uint32 refcount;
+        } breakup;
+        ma_uint64 allocation;
+    } toc;  /* 8 bytes. We encode the job code into the slot allocation data to save space. */
+    MA_ATOMIC(8, ma_uint64) next; /* refcount + slot for the next item. Does not include the job code. */
+    ma_uint32 order;    /* Execution order. Used to create a data dependency and ensure a job is executed in order. Usage is contextual depending on the job type. */
+
+    union
+    {
+        /* Miscellaneous. */
+        struct
+        {
+            ma_job_proc proc;
+            ma_uintptr data0;
+            ma_uintptr data1;
+        } custom;
+
+        /* Resource Manager */
+        union
+        {
+            struct
+            {
+                /*ma_resource_manager**/ void* pResourceManager;
+                /*ma_resource_manager_data_buffer_node**/ void* pDataBufferNode;
+                char* pFilePath;
+                wchar_t* pFilePathW;
+                ma_uint32 flags;                                /* Resource manager data source flags that were used when initializing the data buffer. */
+                ma_async_notification* pInitNotification;       /* Signalled when the data buffer has been initialized and the format/channels/rate can be retrieved. */
+                ma_async_notification* pDoneNotification;       /* Signalled when the data buffer has been fully decoded. Will be passed through to MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE when decoding. */
+                ma_fence* pInitFence;                           /* Released when initialization of the decoder is complete. */
+                ma_fence* pDoneFence;                           /* Released if initialization of the decoder fails. Passed through to PAGE_DATA_BUFFER_NODE untouched if init is successful. */
+            } loadDataBufferNode;
+            struct
+            {
+                /*ma_resource_manager**/ void* pResourceManager;
+                /*ma_resource_manager_data_buffer_node**/ void* pDataBufferNode;
+                ma_async_notification* pDoneNotification;
+                ma_fence* pDoneFence;
+            } freeDataBufferNode;
+            struct
+            {
+                /*ma_resource_manager**/ void* pResourceManager;
+                /*ma_resource_manager_data_buffer_node**/ void* pDataBufferNode;
+                /*ma_decoder**/ void* pDecoder;
+                ma_async_notification* pDoneNotification;       /* Signalled when the data buffer has been fully decoded. */
+                ma_fence* pDoneFence;                           /* Passed through from LOAD_DATA_BUFFER_NODE and released when the data buffer completes decoding or an error occurs. */
+            } pageDataBufferNode;
+
+            struct
+            {
+                /*ma_resource_manager_data_buffer**/ void* pDataBuffer;
+                ma_async_notification* pInitNotification;       /* Signalled when the data buffer has been initialized and the format/channels/rate can be retrieved. */
+                ma_async_notification* pDoneNotification;       /* Signalled when the data buffer has been fully decoded. */
+                ma_fence* pInitFence;                           /* Released when the data buffer has been initialized and the format/channels/rate can be retrieved. */
+                ma_fence* pDoneFence;                           /* Released when the data buffer has been fully decoded. */
+                ma_uint64 rangeBegInPCMFrames;
+                ma_uint64 rangeEndInPCMFrames;
+                ma_uint64 loopPointBegInPCMFrames;
+                ma_uint64 loopPointEndInPCMFrames;
+                ma_uint32 isLooping;
+            } loadDataBuffer;
+            struct
+            {
+                /*ma_resource_manager_data_buffer**/ void* pDataBuffer;
+                ma_async_notification* pDoneNotification;
+                ma_fence* pDoneFence;
+            } freeDataBuffer;
+
+            struct
+            {
+                /*ma_resource_manager_data_stream**/ void* pDataStream;
+                char* pFilePath;                            /* Allocated when the job is posted, freed by the job thread after loading. */
+                wchar_t* pFilePathW;                        /* ^ As above ^. Only used if pFilePath is NULL. */
+                ma_uint64 initialSeekPoint;
+                ma_async_notification* pInitNotification;   /* Signalled after the first two pages have been decoded and frames can be read from the stream. */
+                ma_fence* pInitFence;
+            } loadDataStream;
+            struct
+            {
+                /*ma_resource_manager_data_stream**/ void* pDataStream;
+                ma_async_notification* pDoneNotification;
+                ma_fence* pDoneFence;
+            } freeDataStream;
+            struct
+            {
+                /*ma_resource_manager_data_stream**/ void* pDataStream;
+                ma_uint32 pageIndex;                    /* The index of the page to decode into. */
+            } pageDataStream;
+            struct
+            {
+                /*ma_resource_manager_data_stream**/ void* pDataStream;
+                ma_uint64 frameIndex;
+            } seekDataStream;
+        } resourceManager;
+
+        /* Device. */
+        union
+        {
+            union
+            {
+                struct
+                {
+                    /*ma_device**/ void* pDevice;
+                    /*ma_device_type*/ ma_uint32 deviceType;
+                } reroute;
+            } aaudio;
+        } device;
+    } data;
+};
+
+MA_API ma_job ma_job_init(ma_uint16 code);
+MA_API ma_result ma_job_process(ma_job* pJob);
+
+
+/*
+When set, ma_job_queue_next() will not wait and no semaphore will be signaled in
+ma_job_queue_post(). ma_job_queue_next() will return MA_NO_DATA_AVAILABLE if nothing is available.
+
+This flag should always be used for platforms that do not support multithreading.
+*/
+typedef enum
+{
+    MA_JOB_QUEUE_FLAG_NON_BLOCKING = 0x00000001
+} ma_job_queue_flags;
+
+typedef struct
+{
+    ma_uint32 flags;
+    ma_uint32 capacity; /* The maximum number of jobs that can fit in the queue at a time. */
+} ma_job_queue_config;
+
+MA_API ma_job_queue_config ma_job_queue_config_init(ma_uint32 flags, ma_uint32 capacity);
+
+
+typedef struct
+{
+    ma_uint32 flags;                /* Flags passed in at initialization time. */
+    ma_uint32 capacity;             /* The maximum number of jobs that can fit in the queue at a time. Set by the config. */
+    MA_ATOMIC(8, ma_uint64) head;   /* The first item in the list. Required for removing from the top of the list. */
+    MA_ATOMIC(8, ma_uint64) tail;   /* The last item in the list. Required for appending to the end of the list. */
+#ifndef MA_NO_THREADING
+    ma_semaphore sem;               /* Only used when MA_JOB_QUEUE_FLAG_NON_BLOCKING is unset. */
+#endif
+    ma_slot_allocator allocator;
+    ma_job* pJobs;
+#ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+    ma_spinlock lock;
+#endif
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_job_queue;
+
+MA_API ma_result ma_job_queue_get_heap_size(const ma_job_queue_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_job_queue_init_preallocated(const ma_job_queue_config* pConfig, void* pHeap, ma_job_queue* pQueue);
+MA_API ma_result ma_job_queue_init(const ma_job_queue_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_job_queue* pQueue);
+MA_API void ma_job_queue_uninit(ma_job_queue* pQueue, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_job_queue_post(ma_job_queue* pQueue, const ma_job* pJob);
+MA_API ma_result ma_job_queue_next(ma_job_queue* pQueue, ma_job* pJob); /* Returns MA_CANCELLED if the next job is a quit job. */
+
+
+
+/************************************************************************************************************************************************************
+*************************************************************************************************************************************************************
+
+DEVICE I/O
+==========
+
+This section contains the APIs for device playback and capture. Here is where you'll find ma_device_init(), etc.
+
+*************************************************************************************************************************************************************
+************************************************************************************************************************************************************/
+#ifndef MA_NO_DEVICE_IO
+/* Some backends are only supported on certain platforms. */
+#if defined(MA_WIN32)
+    #define MA_SUPPORT_WASAPI
+
+    #if defined(MA_WIN32_DESKTOP)   /* DirectSound and WinMM backends are only supported on desktops. */
+        #define MA_SUPPORT_DSOUND
+        #define MA_SUPPORT_WINMM
+
+        /* Don't enable JACK here if compiling with Cosmopolitan. It'll be enabled in the Linux section below. */
+        #if !defined(__COSMOPOLITAN__)
+            #define MA_SUPPORT_JACK    /* JACK is technically supported on Windows, but I don't know how many people use it in practice... */
+        #endif
+    #endif
+#endif
+#if defined(MA_UNIX) && !defined(MA_ORBIS) && !defined(MA_PROSPERO)
+    #if defined(MA_LINUX)
+        #if !defined(MA_ANDROID) && !defined(__COSMOPOLITAN__)   /* ALSA is not supported on Android. */
+            #define MA_SUPPORT_ALSA
+        #endif
+    #endif
+    #if !defined(MA_BSD) && !defined(MA_ANDROID) && !defined(MA_EMSCRIPTEN)
+        #define MA_SUPPORT_PULSEAUDIO
+        #define MA_SUPPORT_JACK
+    #endif
+    #if defined(__OpenBSD__)        /* <-- Change this to "#if defined(MA_BSD)" to enable sndio on all BSD flavors. */
+        #define MA_SUPPORT_SNDIO    /* sndio is only supported on OpenBSD for now. May be expanded later if there's demand. */
+    #endif
+    #if defined(__NetBSD__) || defined(__OpenBSD__)
+        #define MA_SUPPORT_AUDIO4   /* Only support audio(4) on platforms with known support. */
+    #endif
+    #if defined(__FreeBSD__) || defined(__DragonFly__)
+        #define MA_SUPPORT_OSS      /* Only support OSS on specific platforms with known support. */
+    #endif
+#endif
+#if defined(MA_ANDROID)
+    #define MA_SUPPORT_AAUDIO
+    #define MA_SUPPORT_OPENSL
+#endif
+#if defined(MA_APPLE)
+    #define MA_SUPPORT_COREAUDIO
+#endif
+#if defined(MA_EMSCRIPTEN)
+    #define MA_SUPPORT_WEBAUDIO
+#endif
+
+/* All platforms should support custom backends. */
+#define MA_SUPPORT_CUSTOM
+
+/* Explicitly disable the Null backend for Emscripten because it uses a background thread which is not properly supported right now. */
+#if !defined(MA_EMSCRIPTEN)
+#define MA_SUPPORT_NULL
+#endif
+
+
+#if defined(MA_SUPPORT_WASAPI) && !defined(MA_NO_WASAPI) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_WASAPI))
+    #define MA_HAS_WASAPI
+#endif
+#if defined(MA_SUPPORT_DSOUND) && !defined(MA_NO_DSOUND) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_DSOUND))
+    #define MA_HAS_DSOUND
+#endif
+#if defined(MA_SUPPORT_WINMM) && !defined(MA_NO_WINMM) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_WINMM))
+    #define MA_HAS_WINMM
+#endif
+#if defined(MA_SUPPORT_ALSA) && !defined(MA_NO_ALSA) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_ALSA))
+    #define MA_HAS_ALSA
+#endif
+#if defined(MA_SUPPORT_PULSEAUDIO) && !defined(MA_NO_PULSEAUDIO) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_PULSEAUDIO))
+    #define MA_HAS_PULSEAUDIO
+#endif
+#if defined(MA_SUPPORT_JACK) && !defined(MA_NO_JACK) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_JACK))
+    #define MA_HAS_JACK
+#endif
+#if defined(MA_SUPPORT_COREAUDIO) && !defined(MA_NO_COREAUDIO) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_COREAUDIO))
+    #define MA_HAS_COREAUDIO
+#endif
+#if defined(MA_SUPPORT_SNDIO) && !defined(MA_NO_SNDIO) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_SNDIO))
+    #define MA_HAS_SNDIO
+#endif
+#if defined(MA_SUPPORT_AUDIO4) && !defined(MA_NO_AUDIO4) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_AUDIO4))
+    #define MA_HAS_AUDIO4
+#endif
+#if defined(MA_SUPPORT_OSS) && !defined(MA_NO_OSS) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_OSS))
+    #define MA_HAS_OSS
+#endif
+#if defined(MA_SUPPORT_AAUDIO) && !defined(MA_NO_AAUDIO) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_AAUDIO))
+    #define MA_HAS_AAUDIO
+#endif
+#if defined(MA_SUPPORT_OPENSL) && !defined(MA_NO_OPENSL) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_OPENSL))
+    #define MA_HAS_OPENSL
+#endif
+#if defined(MA_SUPPORT_WEBAUDIO) && !defined(MA_NO_WEBAUDIO) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_WEBAUDIO))
+    #define MA_HAS_WEBAUDIO
+#endif
+#if defined(MA_SUPPORT_CUSTOM) && !defined(MA_NO_CUSTOM) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_CUSTOM))
+    #define MA_HAS_CUSTOM
+#endif
+#if defined(MA_SUPPORT_NULL) && !defined(MA_NO_NULL) && (!defined(MA_ENABLE_ONLY_SPECIFIC_BACKENDS) || defined(MA_ENABLE_NULL))
+    #define MA_HAS_NULL
+#endif
+
+typedef enum
+{
+    ma_device_state_uninitialized = 0,
+    ma_device_state_stopped       = 1,  /* The device's default state after initialization. */
+    ma_device_state_started       = 2,  /* The device is started and is requesting and/or delivering audio data. */
+    ma_device_state_starting      = 3,  /* Transitioning from a stopped state to started. */
+    ma_device_state_stopping      = 4   /* Transitioning from a started state to stopped. */
+} ma_device_state;
+
+MA_ATOMIC_SAFE_TYPE_DECL(i32, 4, device_state)
+
+
+#ifdef MA_SUPPORT_WASAPI
+/* We need a IMMNotificationClient object for WASAPI. */
+typedef struct
+{
+    void* lpVtbl;
+    ma_uint32 counter;
+    ma_device* pDevice;
+} ma_IMMNotificationClient;
+#endif
+
+/* Backend enums must be in priority order. */
+typedef enum
+{
+    ma_backend_wasapi,
+    ma_backend_dsound,
+    ma_backend_winmm,
+    ma_backend_coreaudio,
+    ma_backend_sndio,
+    ma_backend_audio4,
+    ma_backend_oss,
+    ma_backend_pulseaudio,
+    ma_backend_alsa,
+    ma_backend_jack,
+    ma_backend_aaudio,
+    ma_backend_opensl,
+    ma_backend_webaudio,
+    ma_backend_custom,  /* <-- Custom backend, with callbacks defined by the context config. */
+    ma_backend_null     /* <-- Must always be the last item. Lowest priority, and used as the terminator for backend enumeration. */
+} ma_backend;
+
+#define MA_BACKEND_COUNT (ma_backend_null+1)
+
+
+/*
+Device job thread. This is used by backends that require asynchronous processing of certain
+operations. It is not used by all backends.
+
+The device job thread is made up of a thread and a job queue. You can post a job to the thread with
+ma_device_job_thread_post(). The thread will do the processing of the job.
+*/
+typedef struct
+{
+    ma_bool32 noThread; /* Set this to true if you want to process jobs yourself. */
+    ma_uint32 jobQueueCapacity;
+    ma_uint32 jobQueueFlags;
+} ma_device_job_thread_config;
+
+MA_API ma_device_job_thread_config ma_device_job_thread_config_init(void);
+
+typedef struct
+{
+    ma_thread thread;
+    ma_job_queue jobQueue;
+    ma_bool32 _hasThread;
+} ma_device_job_thread;
+
+MA_API ma_result ma_device_job_thread_init(const ma_device_job_thread_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_device_job_thread* pJobThread);
+MA_API void ma_device_job_thread_uninit(ma_device_job_thread* pJobThread, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_device_job_thread_post(ma_device_job_thread* pJobThread, const ma_job* pJob);
+MA_API ma_result ma_device_job_thread_next(ma_device_job_thread* pJobThread, ma_job* pJob);
+
+
+
+/* Device notification types. */
+typedef enum
+{
+    ma_device_notification_type_started,
+    ma_device_notification_type_stopped,
+    ma_device_notification_type_rerouted,
+    ma_device_notification_type_interruption_began,
+    ma_device_notification_type_interruption_ended,
+    ma_device_notification_type_unlocked
+} ma_device_notification_type;
+
+typedef struct
+{
+    ma_device* pDevice;
+    ma_device_notification_type type;
+    union
+    {
+        struct
+        {
+            int _unused;
+        } started;
+        struct
+        {
+            int _unused;
+        } stopped;
+        struct
+        {
+            int _unused;
+        } rerouted;
+        struct
+        {
+            int _unused;
+        } interruption;
+    } data;
+} ma_device_notification;
+
+/*
+The notification callback for when the application should be notified of a change to the device.
+
+This callback is used for notifying the application of changes such as when the device has started,
+stopped, rerouted or an interruption has occurred. Note that not all backends will post all
+notification types. For example, some backends will perform automatic stream routing without any
+kind of notification to the host program which means miniaudio will never know about it and will
+never be able to fire the rerouted notification. You should keep this in mind when designing your
+program.
+
+The stopped notification will *not* get fired when a device is rerouted.
+
+
+Parameters
+----------
+pNotification (in)
+    A pointer to a structure containing information about the event. Use the `pDevice` member of
+    this object to retrieve the relevant device. The `type` member can be used to discriminate
+    against each of the notification types.
+
+
+Remarks
+-------
+Do not restart or uninitialize the device from the callback.
+
+Not all notifications will be triggered by all backends, however the started and stopped events
+should be reliable for all backends. Some backends do not have a good way to detect device
+stoppages due to unplugging the device which may result in the stopped callback not getting
+fired. This has been observed with at least one BSD variant.
+
+The rerouted notification is fired *after* the reroute has occurred. The stopped notification will
+*not* get fired when a device is rerouted. The following backends are known to do automatic stream
+rerouting, but do not have a way to be notified of the change:
+
+  * DirectSound
+
+The interruption notifications are used on mobile platforms for detecting when audio is interrupted
+due to things like an incoming phone call. Currently this is only implemented on iOS. None of the
+Android backends will report this notification.
+*/
+typedef void (* ma_device_notification_proc)(const ma_device_notification* pNotification);
+
+
+/*
+The callback for processing audio data from the device.
+
+The data callback is fired by miniaudio whenever the device needs to have more data delivered to a playback device, or when a capture device has some data
+available. This is called as soon as the backend asks for more data which means it may be called with inconsistent frame counts. You cannot assume the
+callback will be fired with a consistent frame count.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the relevant device.
+
+pOutput (out)
+    A pointer to the output buffer that will receive audio data that will later be played back through the speakers. This will be non-null for a playback or
+    full-duplex device and null for a capture and loopback device.
+
+pInput (in)
+    A pointer to the buffer containing input data from a recording device. This will be non-null for a capture, full-duplex or loopback device and null for a
+    playback device.
+
+frameCount (in)
+    The number of PCM frames to process. Note that this will not necessarily be equal to what you requested when you initialized the device. The
+    `periodSizeInFrames` and `periodSizeInMilliseconds` members of the device config are just hints, and are not necessarily exactly what you'll get. You must
+    not assume this will always be the same value each time the callback is fired.
+
+
+Remarks
+-------
+You cannot stop and start the device from inside the callback or else you'll get a deadlock. You must also not uninitialize the device from inside the
+callback. The following APIs cannot be called from inside the callback:
+
+    ma_device_init()
+    ma_device_init_ex()
+    ma_device_uninit()
+    ma_device_start()
+    ma_device_stop()
+
+The proper way to stop the device is to call `ma_device_stop()` from a different thread, normally the main application thread.
+*/
+typedef void (* ma_device_data_proc)(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount);
+
+
+
+
+/*
+DEPRECATED. Use ma_device_notification_proc instead.
+
+The callback for when the device has been stopped.
+
+This will be called when the device is stopped explicitly with `ma_device_stop()` and also called implicitly when the device is stopped through external forces
+such as being unplugged or an internal error occurring.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device that has just stopped.
+
+
+Remarks
+-------
+Do not restart or uninitialize the device from the callback.
+*/
+typedef void (* ma_stop_proc)(ma_device* pDevice);  /* DEPRECATED. Use ma_device_notification_proc instead. */
+
+typedef enum
+{
+    ma_device_type_playback = 1,
+    ma_device_type_capture  = 2,
+    ma_device_type_duplex   = ma_device_type_playback | ma_device_type_capture, /* 3 */
+    ma_device_type_loopback = 4
+} ma_device_type;
+
+typedef enum
+{
+    ma_share_mode_shared = 0,
+    ma_share_mode_exclusive
+} ma_share_mode;
+
+/* iOS/tvOS/watchOS session categories. */
+typedef enum
+{
+    ma_ios_session_category_default = 0,        /* AVAudioSessionCategoryPlayAndRecord. */
+    ma_ios_session_category_none,               /* Leave the session category unchanged. */
+    ma_ios_session_category_ambient,            /* AVAudioSessionCategoryAmbient */
+    ma_ios_session_category_solo_ambient,       /* AVAudioSessionCategorySoloAmbient */
+    ma_ios_session_category_playback,           /* AVAudioSessionCategoryPlayback */
+    ma_ios_session_category_record,             /* AVAudioSessionCategoryRecord */
+    ma_ios_session_category_play_and_record,    /* AVAudioSessionCategoryPlayAndRecord */
+    ma_ios_session_category_multi_route         /* AVAudioSessionCategoryMultiRoute */
+} ma_ios_session_category;
+
+/* iOS/tvOS/watchOS session category options */
+typedef enum
+{
+    ma_ios_session_category_option_mix_with_others                            = 0x01,   /* AVAudioSessionCategoryOptionMixWithOthers */
+    ma_ios_session_category_option_duck_others                                = 0x02,   /* AVAudioSessionCategoryOptionDuckOthers */
+    ma_ios_session_category_option_allow_bluetooth                            = 0x04,   /* AVAudioSessionCategoryOptionAllowBluetooth */
+    ma_ios_session_category_option_default_to_speaker                         = 0x08,   /* AVAudioSessionCategoryOptionDefaultToSpeaker */
+    ma_ios_session_category_option_interrupt_spoken_audio_and_mix_with_others = 0x11,   /* AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers */
+    ma_ios_session_category_option_allow_bluetooth_a2dp                       = 0x20,   /* AVAudioSessionCategoryOptionAllowBluetoothA2DP */
+    ma_ios_session_category_option_allow_air_play                             = 0x40,   /* AVAudioSessionCategoryOptionAllowAirPlay */
+} ma_ios_session_category_option;
+
+/* OpenSL stream types. */
+typedef enum
+{
+    ma_opensl_stream_type_default = 0,              /* Leaves the stream type unset. */
+    ma_opensl_stream_type_voice,                    /* SL_ANDROID_STREAM_VOICE */
+    ma_opensl_stream_type_system,                   /* SL_ANDROID_STREAM_SYSTEM */
+    ma_opensl_stream_type_ring,                     /* SL_ANDROID_STREAM_RING */
+    ma_opensl_stream_type_media,                    /* SL_ANDROID_STREAM_MEDIA */
+    ma_opensl_stream_type_alarm,                    /* SL_ANDROID_STREAM_ALARM */
+    ma_opensl_stream_type_notification              /* SL_ANDROID_STREAM_NOTIFICATION */
+} ma_opensl_stream_type;
+
+/* OpenSL recording presets. */
+typedef enum
+{
+    ma_opensl_recording_preset_default = 0,         /* Leaves the input preset unset. */
+    ma_opensl_recording_preset_generic,             /* SL_ANDROID_RECORDING_PRESET_GENERIC */
+    ma_opensl_recording_preset_camcorder,           /* SL_ANDROID_RECORDING_PRESET_CAMCORDER */
+    ma_opensl_recording_preset_voice_recognition,   /* SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION */
+    ma_opensl_recording_preset_voice_communication, /* SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION */
+    ma_opensl_recording_preset_voice_unprocessed    /* SL_ANDROID_RECORDING_PRESET_UNPROCESSED */
+} ma_opensl_recording_preset;
+
+/* WASAPI audio thread priority characteristics. */
+typedef enum
+{
+    ma_wasapi_usage_default = 0,
+    ma_wasapi_usage_games,
+    ma_wasapi_usage_pro_audio,
+} ma_wasapi_usage;
+
+/* AAudio usage types. */
+typedef enum
+{
+    ma_aaudio_usage_default = 0,                    /* Leaves the usage type unset. */
+    ma_aaudio_usage_media,                          /* AAUDIO_USAGE_MEDIA */
+    ma_aaudio_usage_voice_communication,            /* AAUDIO_USAGE_VOICE_COMMUNICATION */
+    ma_aaudio_usage_voice_communication_signalling, /* AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING */
+    ma_aaudio_usage_alarm,                          /* AAUDIO_USAGE_ALARM */
+    ma_aaudio_usage_notification,                   /* AAUDIO_USAGE_NOTIFICATION */
+    ma_aaudio_usage_notification_ringtone,          /* AAUDIO_USAGE_NOTIFICATION_RINGTONE */
+    ma_aaudio_usage_notification_event,             /* AAUDIO_USAGE_NOTIFICATION_EVENT */
+    ma_aaudio_usage_assistance_accessibility,       /* AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY */
+    ma_aaudio_usage_assistance_navigation_guidance, /* AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE */
+    ma_aaudio_usage_assistance_sonification,        /* AAUDIO_USAGE_ASSISTANCE_SONIFICATION */
+    ma_aaudio_usage_game,                           /* AAUDIO_USAGE_GAME */
+    ma_aaudio_usage_assitant,                       /* AAUDIO_USAGE_ASSISTANT */
+    ma_aaudio_usage_emergency,                      /* AAUDIO_SYSTEM_USAGE_EMERGENCY */
+    ma_aaudio_usage_safety,                         /* AAUDIO_SYSTEM_USAGE_SAFETY */
+    ma_aaudio_usage_vehicle_status,                 /* AAUDIO_SYSTEM_USAGE_VEHICLE_STATUS */
+    ma_aaudio_usage_announcement                    /* AAUDIO_SYSTEM_USAGE_ANNOUNCEMENT */
+} ma_aaudio_usage;
+
+/* AAudio content types. */
+typedef enum
+{
+    ma_aaudio_content_type_default = 0,             /* Leaves the content type unset. */
+    ma_aaudio_content_type_speech,                  /* AAUDIO_CONTENT_TYPE_SPEECH */
+    ma_aaudio_content_type_music,                   /* AAUDIO_CONTENT_TYPE_MUSIC */
+    ma_aaudio_content_type_movie,                   /* AAUDIO_CONTENT_TYPE_MOVIE */
+    ma_aaudio_content_type_sonification             /* AAUDIO_CONTENT_TYPE_SONIFICATION */
+} ma_aaudio_content_type;
+
+/* AAudio input presets. */
+typedef enum
+{
+    ma_aaudio_input_preset_default = 0,             /* Leaves the input preset unset. */
+    ma_aaudio_input_preset_generic,                 /* AAUDIO_INPUT_PRESET_GENERIC */
+    ma_aaudio_input_preset_camcorder,               /* AAUDIO_INPUT_PRESET_CAMCORDER */
+    ma_aaudio_input_preset_voice_recognition,       /* AAUDIO_INPUT_PRESET_VOICE_RECOGNITION */
+    ma_aaudio_input_preset_voice_communication,     /* AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION */
+    ma_aaudio_input_preset_unprocessed,             /* AAUDIO_INPUT_PRESET_UNPROCESSED */
+    ma_aaudio_input_preset_voice_performance        /* AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE */
+} ma_aaudio_input_preset;
+
+typedef enum
+{
+    ma_aaudio_allow_capture_default = 0,            /* Leaves the allowed capture policy unset. */
+    ma_aaudio_allow_capture_by_all,                 /* AAUDIO_ALLOW_CAPTURE_BY_ALL */
+    ma_aaudio_allow_capture_by_system,              /* AAUDIO_ALLOW_CAPTURE_BY_SYSTEM */
+    ma_aaudio_allow_capture_by_none                 /* AAUDIO_ALLOW_CAPTURE_BY_NONE */
+} ma_aaudio_allowed_capture_policy;
+
+typedef union
+{
+    ma_int64 counter;
+    double counterD;
+} ma_timer;
+
+typedef union
+{
+    ma_wchar_win32 wasapi[64];      /* WASAPI uses a wchar_t string for identification. */
+    ma_uint8 dsound[16];            /* DirectSound uses a GUID for identification. */
+    /*UINT_PTR*/ ma_uint32 winmm;   /* When creating a device, WinMM expects a Win32 UINT_PTR for device identification. In practice it's actually just a UINT. */
+    char alsa[256];                 /* ALSA uses a name string for identification. */
+    char pulse[256];                /* PulseAudio uses a name string for identification. */
+    int jack;                       /* JACK always uses default devices. */
+    char coreaudio[256];            /* Core Audio uses a string for identification. */
+    char sndio[256];                /* "snd/0", etc. */
+    char audio4[256];               /* "/dev/audio", etc. */
+    char oss[64];                   /* "dev/dsp0", etc. "dev/dsp" for the default device. */
+    ma_int32 aaudio;                /* AAudio uses a 32-bit integer for identification. */
+    ma_uint32 opensl;               /* OpenSL|ES uses a 32-bit unsigned integer for identification. */
+    char webaudio[32];              /* Web Audio always uses default devices for now, but if this changes it'll be a GUID. */
+    union
+    {
+        int i;
+        char s[256];
+        void* p;
+    } custom;                       /* The custom backend could be anything. Give them a few options. */
+    int nullbackend;                /* The null backend uses an integer for device IDs. */
+} ma_device_id;
+
+
+typedef struct ma_context_config    ma_context_config;
+typedef struct ma_device_config     ma_device_config;
+typedef struct ma_backend_callbacks ma_backend_callbacks;
+
+#define MA_DATA_FORMAT_FLAG_EXCLUSIVE_MODE (1U << 1)    /* If set, this is supported in exclusive mode. Otherwise not natively supported by exclusive mode. */
+
+#ifndef MA_MAX_DEVICE_NAME_LENGTH
+#define MA_MAX_DEVICE_NAME_LENGTH   255
+#endif
+
+typedef struct
+{
+    /* Basic info. This is the only information guaranteed to be filled in during device enumeration. */
+    ma_device_id id;
+    char name[MA_MAX_DEVICE_NAME_LENGTH + 1];   /* +1 for null terminator. */
+    ma_bool32 isDefault;
+
+    ma_uint32 nativeDataFormatCount;
+    struct
+    {
+        ma_format format;       /* Sample format. If set to ma_format_unknown, all sample formats are supported. */
+        ma_uint32 channels;     /* If set to 0, all channels are supported. */
+        ma_uint32 sampleRate;   /* If set to 0, all sample rates are supported. */
+        ma_uint32 flags;        /* A combination of MA_DATA_FORMAT_FLAG_* flags. */
+    } nativeDataFormats[/*ma_format_count * ma_standard_sample_rate_count * MA_MAX_CHANNELS*/ 64];  /* Not sure how big to make this. There can be *many* permutations for virtual devices which can support anything. */
+} ma_device_info;
+
+struct ma_device_config
+{
+    ma_device_type deviceType;
+    ma_uint32 sampleRate;
+    ma_uint32 periodSizeInFrames;
+    ma_uint32 periodSizeInMilliseconds;
+    ma_uint32 periods;
+    ma_performance_profile performanceProfile;
+    ma_bool8 noPreSilencedOutputBuffer; /* When set to true, the contents of the output buffer passed into the data callback will be left undefined rather than initialized to silence. */
+    ma_bool8 noClip;                    /* When set to true, the contents of the output buffer passed into the data callback will not be clipped after returning. Only applies when the playback sample format is f32. */
+    ma_bool8 noDisableDenormals;        /* Do not disable denormals when firing the data callback. */
+    ma_bool8 noFixedSizedCallback;      /* Disables strict fixed-sized data callbacks. Setting this to true will result in the period size being treated only as a hint to the backend. This is an optimization for those who don't need fixed sized callbacks. */
+    ma_device_data_proc dataCallback;
+    ma_device_notification_proc notificationCallback;
+    ma_stop_proc stopCallback;
+    void* pUserData;
+    ma_resampler_config resampling;
+    struct
+    {
+        const ma_device_id* pDeviceID;
+        ma_format format;
+        ma_uint32 channels;
+        ma_channel* pChannelMap;
+        ma_channel_mix_mode channelMixMode;
+        ma_bool32 calculateLFEFromSpatialChannels;  /* When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. */
+        ma_share_mode shareMode;
+    } playback;
+    struct
+    {
+        const ma_device_id* pDeviceID;
+        ma_format format;
+        ma_uint32 channels;
+        ma_channel* pChannelMap;
+        ma_channel_mix_mode channelMixMode;
+        ma_bool32 calculateLFEFromSpatialChannels;  /* When an output LFE channel is present, but no input LFE, set to true to set the output LFE to the average of all spatial channels (LR, FR, etc.). Ignored when an input LFE is present. */
+        ma_share_mode shareMode;
+    } capture;
+
+    struct
+    {
+        ma_wasapi_usage usage;              /* When configured, uses Avrt APIs to set the thread characteristics. */
+        ma_bool8 noAutoConvertSRC;          /* When set to true, disables the use of AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM. */
+        ma_bool8 noDefaultQualitySRC;       /* When set to true, disables the use of AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY. */
+        ma_bool8 noAutoStreamRouting;       /* Disables automatic stream routing. */
+        ma_bool8 noHardwareOffloading;      /* Disables WASAPI's hardware offloading feature. */
+        ma_uint32 loopbackProcessID;        /* The process ID to include or exclude for loopback mode. Set to 0 to capture audio from all processes. Ignored when an explicit device ID is specified. */
+        ma_bool8 loopbackProcessExclude;    /* When set to true, excludes the process specified by loopbackProcessID. By default, the process will be included. */
+    } wasapi;
+    struct
+    {
+        ma_bool32 noMMap;           /* Disables MMap mode. */
+        ma_bool32 noAutoFormat;     /* Opens the ALSA device with SND_PCM_NO_AUTO_FORMAT. */
+        ma_bool32 noAutoChannels;   /* Opens the ALSA device with SND_PCM_NO_AUTO_CHANNELS. */
+        ma_bool32 noAutoResample;   /* Opens the ALSA device with SND_PCM_NO_AUTO_RESAMPLE. */
+    } alsa;
+    struct
+    {
+        const char* pStreamNamePlayback;
+        const char* pStreamNameCapture;
+    } pulse;
+    struct
+    {
+        ma_bool32 allowNominalSampleRateChange; /* Desktop only. When enabled, allows changing of the sample rate at the operating system level. */
+    } coreaudio;
+    struct
+    {
+        ma_opensl_stream_type streamType;
+        ma_opensl_recording_preset recordingPreset;
+        ma_bool32 enableCompatibilityWorkarounds;
+    } opensl;
+    struct
+    {
+        ma_aaudio_usage usage;
+        ma_aaudio_content_type contentType;
+        ma_aaudio_input_preset inputPreset;
+        ma_aaudio_allowed_capture_policy allowedCapturePolicy;
+        ma_bool32 noAutoStartAfterReroute;
+        ma_bool32 enableCompatibilityWorkarounds;
+    } aaudio;
+};
+
+
+/*
+The callback for handling device enumeration. This is fired from `ma_context_enumerate_devices()`.
+
+
+Parameters
+----------
+pContext (in)
+    A pointer to the context performing the enumeration.
+
+deviceType (in)
+    The type of the device being enumerated. This will always be either `ma_device_type_playback` or `ma_device_type_capture`.
+
+pInfo (in)
+    A pointer to a `ma_device_info` containing the ID and name of the enumerated device. Note that this will not include detailed information about the device,
+    only basic information (ID and name). The reason for this is that it would otherwise require opening the backend device to probe for the information which
+    is too inefficient.
+
+pUserData (in)
+    The user data pointer passed into `ma_context_enumerate_devices()`.
+*/
+typedef ma_bool32 (* ma_enum_devices_callback_proc)(ma_context* pContext, ma_device_type deviceType, const ma_device_info* pInfo, void* pUserData);
+
+
+/*
+Describes some basic details about a playback or capture device.
+*/
+typedef struct
+{
+    const ma_device_id* pDeviceID;
+    ma_share_mode shareMode;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_channel channelMap[MA_MAX_CHANNELS];
+    ma_uint32 periodSizeInFrames;
+    ma_uint32 periodSizeInMilliseconds;
+    ma_uint32 periodCount;
+} ma_device_descriptor;
+
+/*
+These are the callbacks required to be implemented for a backend. These callbacks are grouped into two parts: context and device. There is one context
+to many devices. A device is created from a context.
+
+The general flow goes like this:
+
+  1) A context is created with `onContextInit()`
+     1a) Available devices can be enumerated with `onContextEnumerateDevices()` if required.
+     1b) Detailed information about a device can be queried with `onContextGetDeviceInfo()` if required.
+  2) A device is created from the context that was created in the first step using `onDeviceInit()`, and optionally a device ID that was
+     selected from device enumeration via `onContextEnumerateDevices()`.
+  3) A device is started or stopped with `onDeviceStart()` / `onDeviceStop()`
+  4) Data is delivered to and from the device by the backend. This is always done based on the native format returned by the prior call
+     to `onDeviceInit()`. Conversion between the device's native format and the format requested by the application will be handled by
+     miniaudio internally.
+
+Initialization of the context is quite simple. You need to do any necessary initialization of internal objects and then output the
+callbacks defined in this structure.
+
+Once the context has been initialized you can initialize a device. Before doing so, however, the application may want to know which
+physical devices are available. This is where `onContextEnumerateDevices()` comes in. This is fairly simple. For each device, fire the
+given callback with, at a minimum, the basic information filled out in `ma_device_info`. When the callback returns `MA_FALSE`, enumeration
+needs to stop and the `onContextEnumerateDevices()` function returns with a success code.
+
+Detailed device information can be retrieved from a device ID using `onContextGetDeviceInfo()`. This takes as input the device type and ID,
+and on output returns detailed information about the device in `ma_device_info`. The `onContextGetDeviceInfo()` callback must handle the
+case when the device ID is NULL, in which case information about the default device needs to be retrieved.
+
+Once the context has been created and the device ID retrieved (if using anything other than the default device), the device can be created.
+This is a little bit more complicated than initialization of the context due to it's more complicated configuration. When initializing a
+device, a duplex device may be requested. This means a separate data format needs to be specified for both playback and capture. On input,
+the data format is set to what the application wants. On output it's set to the native format which should match as closely as possible to
+the requested format. The conversion between the format requested by the application and the device's native format will be handled
+internally by miniaudio.
+
+On input, if the sample format is set to `ma_format_unknown`, the backend is free to use whatever sample format it desires, so long as it's
+supported by miniaudio. When the channel count is set to 0, the backend should use the device's native channel count. The same applies for
+sample rate. For the channel map, the default should be used when `ma_channel_map_is_blank()` returns true (all channels set to
+`MA_CHANNEL_NONE`). On input, the `periodSizeInFrames` or `periodSizeInMilliseconds` option should always be set. The backend should
+inspect both of these variables. If `periodSizeInFrames` is set, it should take priority, otherwise it needs to be derived from the period
+size in milliseconds (`periodSizeInMilliseconds`) and the sample rate, keeping in mind that the sample rate may be 0, in which case the
+sample rate will need to be determined before calculating the period size in frames. On output, all members of the `ma_device_descriptor`
+object should be set to a valid value, except for `periodSizeInMilliseconds` which is optional (`periodSizeInFrames` *must* be set).
+
+Starting and stopping of the device is done with `onDeviceStart()` and `onDeviceStop()` and should be self-explanatory. If the backend uses
+asynchronous reading and writing, `onDeviceStart()` and `onDeviceStop()` should always be implemented.
+
+The handling of data delivery between the application and the device is the most complicated part of the process. To make this a bit
+easier, some helper callbacks are available. If the backend uses a blocking read/write style of API, the `onDeviceRead()` and
+`onDeviceWrite()` callbacks can optionally be implemented. These are blocking and work just like reading and writing from a file. If the
+backend uses a callback for data delivery, that callback must call `ma_device_handle_backend_data_callback()` from within it's callback.
+This allows miniaudio to then process any necessary data conversion and then pass it to the miniaudio data callback.
+
+If the backend requires absolute flexibility with it's data delivery, it can optionally implement the `onDeviceDataLoop()` callback
+which will allow it to implement the logic that will run on the audio thread. This is much more advanced and is completely optional.
+
+The audio thread should run data delivery logic in a loop while `ma_device_get_state() == ma_device_state_started` and no errors have been
+encountered. Do not start or stop the device here. That will be handled from outside the `onDeviceDataLoop()` callback.
+
+The invocation of the `onDeviceDataLoop()` callback will be handled by miniaudio. When you start the device, miniaudio will fire this
+callback. When the device is stopped, the `ma_device_get_state() == ma_device_state_started` condition will fail and the loop will be terminated
+which will then fall through to the part that stops the device. For an example on how to implement the `onDeviceDataLoop()` callback,
+look at `ma_device_audio_thread__default_read_write()`. Implement the `onDeviceDataLoopWakeup()` callback if you need a mechanism to
+wake up the audio thread.
+
+If the backend supports an optimized retrieval of device information from an initialized `ma_device` object, it should implement the
+`onDeviceGetInfo()` callback. This is optional, in which case it will fall back to `onContextGetDeviceInfo()` which is less efficient.
+*/
+struct ma_backend_callbacks
+{
+    ma_result (* onContextInit)(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks);
+    ma_result (* onContextUninit)(ma_context* pContext);
+    ma_result (* onContextEnumerateDevices)(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData);
+    ma_result (* onContextGetDeviceInfo)(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo);
+    ma_result (* onDeviceInit)(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture);
+    ma_result (* onDeviceUninit)(ma_device* pDevice);
+    ma_result (* onDeviceStart)(ma_device* pDevice);
+    ma_result (* onDeviceStop)(ma_device* pDevice);
+    ma_result (* onDeviceRead)(ma_device* pDevice, void* pFrames, ma_uint32 frameCount, ma_uint32* pFramesRead);
+    ma_result (* onDeviceWrite)(ma_device* pDevice, const void* pFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten);
+    ma_result (* onDeviceDataLoop)(ma_device* pDevice);
+    ma_result (* onDeviceDataLoopWakeup)(ma_device* pDevice);
+    ma_result (* onDeviceGetInfo)(ma_device* pDevice, ma_device_type type, ma_device_info* pDeviceInfo);
+};
+
+struct ma_context_config
+{
+    ma_log* pLog;
+    ma_thread_priority threadPriority;
+    size_t threadStackSize;
+    void* pUserData;
+    ma_allocation_callbacks allocationCallbacks;
+    struct
+    {
+        ma_bool32 useVerboseDeviceEnumeration;
+    } alsa;
+    struct
+    {
+        const char* pApplicationName;
+        const char* pServerName;
+        ma_bool32 tryAutoSpawn; /* Enables autospawning of the PulseAudio daemon if necessary. */
+    } pulse;
+    struct
+    {
+        ma_ios_session_category sessionCategory;
+        ma_uint32 sessionCategoryOptions;
+        ma_bool32 noAudioSessionActivate;   /* iOS only. When set to true, does not perform an explicit [[AVAudioSession sharedInstace] setActive:true] on initialization. */
+        ma_bool32 noAudioSessionDeactivate; /* iOS only. When set to true, does not perform an explicit [[AVAudioSession sharedInstace] setActive:false] on uninitialization. */
+    } coreaudio;
+    struct
+    {
+        const char* pClientName;
+        ma_bool32 tryStartServer;
+    } jack;
+    ma_backend_callbacks custom;
+};
+
+/* WASAPI specific structure for some commands which must run on a common thread due to bugs in WASAPI. */
+typedef struct
+{
+    int code;
+    ma_event* pEvent;   /* This will be signalled when the event is complete. */
+    union
+    {
+        struct
+        {
+            int _unused;
+        } quit;
+        struct
+        {
+            ma_device_type deviceType;
+            void* pAudioClient;
+            void** ppAudioClientService;
+            ma_result* pResult; /* The result from creating the audio client service. */
+        } createAudioClient;
+        struct
+        {
+            ma_device* pDevice;
+            ma_device_type deviceType;
+        } releaseAudioClient;
+    } data;
+} ma_context_command__wasapi;
+
+struct ma_context
+{
+    ma_backend_callbacks callbacks;
+    ma_backend backend;                 /* DirectSound, ALSA, etc. */
+    ma_log* pLog;
+    ma_log log; /* Only used if the log is owned by the context. The pLog member will be set to &log in this case. */
+    ma_thread_priority threadPriority;
+    size_t threadStackSize;
+    void* pUserData;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_mutex deviceEnumLock;            /* Used to make ma_context_get_devices() thread safe. */
+    ma_mutex deviceInfoLock;            /* Used to make ma_context_get_device_info() thread safe. */
+    ma_uint32 deviceInfoCapacity;       /* Total capacity of pDeviceInfos. */
+    ma_uint32 playbackDeviceInfoCount;
+    ma_uint32 captureDeviceInfoCount;
+    ma_device_info* pDeviceInfos;       /* Playback devices first, then capture. */
+
+    union
+    {
+#ifdef MA_SUPPORT_WASAPI
+        struct
+        {
+            ma_thread commandThread;
+            ma_mutex commandLock;
+            ma_semaphore commandSem;
+            ma_uint32 commandIndex;
+            ma_uint32 commandCount;
+            ma_context_command__wasapi commands[4];
+            ma_handle hAvrt;
+            ma_proc AvSetMmThreadCharacteristicsA;
+            ma_proc AvRevertMmThreadcharacteristics;
+            ma_handle hMMDevapi;
+            ma_proc ActivateAudioInterfaceAsync;
+        } wasapi;
+#endif
+#ifdef MA_SUPPORT_DSOUND
+        struct
+        {
+            ma_handle hDSoundDLL;
+            ma_proc DirectSoundCreate;
+            ma_proc DirectSoundEnumerateA;
+            ma_proc DirectSoundCaptureCreate;
+            ma_proc DirectSoundCaptureEnumerateA;
+        } dsound;
+#endif
+#ifdef MA_SUPPORT_WINMM
+        struct
+        {
+            ma_handle hWinMM;
+            ma_proc waveOutGetNumDevs;
+            ma_proc waveOutGetDevCapsA;
+            ma_proc waveOutOpen;
+            ma_proc waveOutClose;
+            ma_proc waveOutPrepareHeader;
+            ma_proc waveOutUnprepareHeader;
+            ma_proc waveOutWrite;
+            ma_proc waveOutReset;
+            ma_proc waveInGetNumDevs;
+            ma_proc waveInGetDevCapsA;
+            ma_proc waveInOpen;
+            ma_proc waveInClose;
+            ma_proc waveInPrepareHeader;
+            ma_proc waveInUnprepareHeader;
+            ma_proc waveInAddBuffer;
+            ma_proc waveInStart;
+            ma_proc waveInReset;
+        } winmm;
+#endif
+#ifdef MA_SUPPORT_ALSA
+        struct
+        {
+            ma_handle asoundSO;
+            ma_proc snd_pcm_open;
+            ma_proc snd_pcm_close;
+            ma_proc snd_pcm_hw_params_sizeof;
+            ma_proc snd_pcm_hw_params_any;
+            ma_proc snd_pcm_hw_params_set_format;
+            ma_proc snd_pcm_hw_params_set_format_first;
+            ma_proc snd_pcm_hw_params_get_format_mask;
+            ma_proc snd_pcm_hw_params_set_channels;
+            ma_proc snd_pcm_hw_params_set_channels_near;
+            ma_proc snd_pcm_hw_params_set_channels_minmax;
+            ma_proc snd_pcm_hw_params_set_rate_resample;
+            ma_proc snd_pcm_hw_params_set_rate;
+            ma_proc snd_pcm_hw_params_set_rate_near;
+            ma_proc snd_pcm_hw_params_set_buffer_size_near;
+            ma_proc snd_pcm_hw_params_set_periods_near;
+            ma_proc snd_pcm_hw_params_set_access;
+            ma_proc snd_pcm_hw_params_get_format;
+            ma_proc snd_pcm_hw_params_get_channels;
+            ma_proc snd_pcm_hw_params_get_channels_min;
+            ma_proc snd_pcm_hw_params_get_channels_max;
+            ma_proc snd_pcm_hw_params_get_rate;
+            ma_proc snd_pcm_hw_params_get_rate_min;
+            ma_proc snd_pcm_hw_params_get_rate_max;
+            ma_proc snd_pcm_hw_params_get_buffer_size;
+            ma_proc snd_pcm_hw_params_get_periods;
+            ma_proc snd_pcm_hw_params_get_access;
+            ma_proc snd_pcm_hw_params_test_format;
+            ma_proc snd_pcm_hw_params_test_channels;
+            ma_proc snd_pcm_hw_params_test_rate;
+            ma_proc snd_pcm_hw_params;
+            ma_proc snd_pcm_sw_params_sizeof;
+            ma_proc snd_pcm_sw_params_current;
+            ma_proc snd_pcm_sw_params_get_boundary;
+            ma_proc snd_pcm_sw_params_set_avail_min;
+            ma_proc snd_pcm_sw_params_set_start_threshold;
+            ma_proc snd_pcm_sw_params_set_stop_threshold;
+            ma_proc snd_pcm_sw_params;
+            ma_proc snd_pcm_format_mask_sizeof;
+            ma_proc snd_pcm_format_mask_test;
+            ma_proc snd_pcm_get_chmap;
+            ma_proc snd_pcm_state;
+            ma_proc snd_pcm_prepare;
+            ma_proc snd_pcm_start;
+            ma_proc snd_pcm_drop;
+            ma_proc snd_pcm_drain;
+            ma_proc snd_pcm_reset;
+            ma_proc snd_device_name_hint;
+            ma_proc snd_device_name_get_hint;
+            ma_proc snd_card_get_index;
+            ma_proc snd_device_name_free_hint;
+            ma_proc snd_pcm_mmap_begin;
+            ma_proc snd_pcm_mmap_commit;
+            ma_proc snd_pcm_recover;
+            ma_proc snd_pcm_readi;
+            ma_proc snd_pcm_writei;
+            ma_proc snd_pcm_avail;
+            ma_proc snd_pcm_avail_update;
+            ma_proc snd_pcm_wait;
+            ma_proc snd_pcm_nonblock;
+            ma_proc snd_pcm_info;
+            ma_proc snd_pcm_info_sizeof;
+            ma_proc snd_pcm_info_get_name;
+            ma_proc snd_pcm_poll_descriptors;
+            ma_proc snd_pcm_poll_descriptors_count;
+            ma_proc snd_pcm_poll_descriptors_revents;
+            ma_proc snd_config_update_free_global;
+
+            ma_mutex internalDeviceEnumLock;
+            ma_bool32 useVerboseDeviceEnumeration;
+        } alsa;
+#endif
+#ifdef MA_SUPPORT_PULSEAUDIO
+        struct
+        {
+            ma_handle pulseSO;
+            ma_proc pa_mainloop_new;
+            ma_proc pa_mainloop_free;
+            ma_proc pa_mainloop_quit;
+            ma_proc pa_mainloop_get_api;
+            ma_proc pa_mainloop_iterate;
+            ma_proc pa_mainloop_wakeup;
+            ma_proc pa_threaded_mainloop_new;
+            ma_proc pa_threaded_mainloop_free;
+            ma_proc pa_threaded_mainloop_start;
+            ma_proc pa_threaded_mainloop_stop;
+            ma_proc pa_threaded_mainloop_lock;
+            ma_proc pa_threaded_mainloop_unlock;
+            ma_proc pa_threaded_mainloop_wait;
+            ma_proc pa_threaded_mainloop_signal;
+            ma_proc pa_threaded_mainloop_accept;
+            ma_proc pa_threaded_mainloop_get_retval;
+            ma_proc pa_threaded_mainloop_get_api;
+            ma_proc pa_threaded_mainloop_in_thread;
+            ma_proc pa_threaded_mainloop_set_name;
+            ma_proc pa_context_new;
+            ma_proc pa_context_unref;
+            ma_proc pa_context_connect;
+            ma_proc pa_context_disconnect;
+            ma_proc pa_context_set_state_callback;
+            ma_proc pa_context_get_state;
+            ma_proc pa_context_get_sink_info_list;
+            ma_proc pa_context_get_source_info_list;
+            ma_proc pa_context_get_sink_info_by_name;
+            ma_proc pa_context_get_source_info_by_name;
+            ma_proc pa_operation_unref;
+            ma_proc pa_operation_get_state;
+            ma_proc pa_channel_map_init_extend;
+            ma_proc pa_channel_map_valid;
+            ma_proc pa_channel_map_compatible;
+            ma_proc pa_stream_new;
+            ma_proc pa_stream_unref;
+            ma_proc pa_stream_connect_playback;
+            ma_proc pa_stream_connect_record;
+            ma_proc pa_stream_disconnect;
+            ma_proc pa_stream_get_state;
+            ma_proc pa_stream_get_sample_spec;
+            ma_proc pa_stream_get_channel_map;
+            ma_proc pa_stream_get_buffer_attr;
+            ma_proc pa_stream_set_buffer_attr;
+            ma_proc pa_stream_get_device_name;
+            ma_proc pa_stream_set_write_callback;
+            ma_proc pa_stream_set_read_callback;
+            ma_proc pa_stream_set_suspended_callback;
+            ma_proc pa_stream_set_moved_callback;
+            ma_proc pa_stream_is_suspended;
+            ma_proc pa_stream_flush;
+            ma_proc pa_stream_drain;
+            ma_proc pa_stream_is_corked;
+            ma_proc pa_stream_cork;
+            ma_proc pa_stream_trigger;
+            ma_proc pa_stream_begin_write;
+            ma_proc pa_stream_write;
+            ma_proc pa_stream_peek;
+            ma_proc pa_stream_drop;
+            ma_proc pa_stream_writable_size;
+            ma_proc pa_stream_readable_size;
+
+            /*pa_mainloop**/ ma_ptr pMainLoop;
+            /*pa_context**/ ma_ptr pPulseContext;
+            char* pApplicationName; /* Set when the context is initialized. Used by devices for their local pa_context objects. */
+            char* pServerName;      /* Set when the context is initialized. Used by devices for their local pa_context objects. */
+        } pulse;
+#endif
+#ifdef MA_SUPPORT_JACK
+        struct
+        {
+            ma_handle jackSO;
+            ma_proc jack_client_open;
+            ma_proc jack_client_close;
+            ma_proc jack_client_name_size;
+            ma_proc jack_set_process_callback;
+            ma_proc jack_set_buffer_size_callback;
+            ma_proc jack_on_shutdown;
+            ma_proc jack_get_sample_rate;
+            ma_proc jack_get_buffer_size;
+            ma_proc jack_get_ports;
+            ma_proc jack_activate;
+            ma_proc jack_deactivate;
+            ma_proc jack_connect;
+            ma_proc jack_port_register;
+            ma_proc jack_port_name;
+            ma_proc jack_port_get_buffer;
+            ma_proc jack_free;
+
+            char* pClientName;
+            ma_bool32 tryStartServer;
+        } jack;
+#endif
+#ifdef MA_SUPPORT_COREAUDIO
+        struct
+        {
+            ma_handle hCoreFoundation;
+            ma_proc CFStringGetCString;
+            ma_proc CFRelease;
+
+            ma_handle hCoreAudio;
+            ma_proc AudioObjectGetPropertyData;
+            ma_proc AudioObjectGetPropertyDataSize;
+            ma_proc AudioObjectSetPropertyData;
+            ma_proc AudioObjectAddPropertyListener;
+            ma_proc AudioObjectRemovePropertyListener;
+
+            ma_handle hAudioUnit;  /* Could possibly be set to AudioToolbox on later versions of macOS. */
+            ma_proc AudioComponentFindNext;
+            ma_proc AudioComponentInstanceDispose;
+            ma_proc AudioComponentInstanceNew;
+            ma_proc AudioOutputUnitStart;
+            ma_proc AudioOutputUnitStop;
+            ma_proc AudioUnitAddPropertyListener;
+            ma_proc AudioUnitGetPropertyInfo;
+            ma_proc AudioUnitGetProperty;
+            ma_proc AudioUnitSetProperty;
+            ma_proc AudioUnitInitialize;
+            ma_proc AudioUnitRender;
+
+            /*AudioComponent*/ ma_ptr component;
+            ma_bool32 noAudioSessionDeactivate; /* For tracking whether or not the iOS audio session should be explicitly deactivated. Set from the config in ma_context_init__coreaudio(). */
+        } coreaudio;
+#endif
+#ifdef MA_SUPPORT_SNDIO
+        struct
+        {
+            ma_handle sndioSO;
+            ma_proc sio_open;
+            ma_proc sio_close;
+            ma_proc sio_setpar;
+            ma_proc sio_getpar;
+            ma_proc sio_getcap;
+            ma_proc sio_start;
+            ma_proc sio_stop;
+            ma_proc sio_read;
+            ma_proc sio_write;
+            ma_proc sio_onmove;
+            ma_proc sio_nfds;
+            ma_proc sio_pollfd;
+            ma_proc sio_revents;
+            ma_proc sio_eof;
+            ma_proc sio_setvol;
+            ma_proc sio_onvol;
+            ma_proc sio_initpar;
+        } sndio;
+#endif
+#ifdef MA_SUPPORT_AUDIO4
+        struct
+        {
+            int _unused;
+        } audio4;
+#endif
+#ifdef MA_SUPPORT_OSS
+        struct
+        {
+            int versionMajor;
+            int versionMinor;
+        } oss;
+#endif
+#ifdef MA_SUPPORT_AAUDIO
+        struct
+        {
+            ma_handle hAAudio; /* libaaudio.so */
+            ma_proc AAudio_createStreamBuilder;
+            ma_proc AAudioStreamBuilder_delete;
+            ma_proc AAudioStreamBuilder_setDeviceId;
+            ma_proc AAudioStreamBuilder_setDirection;
+            ma_proc AAudioStreamBuilder_setSharingMode;
+            ma_proc AAudioStreamBuilder_setFormat;
+            ma_proc AAudioStreamBuilder_setChannelCount;
+            ma_proc AAudioStreamBuilder_setSampleRate;
+            ma_proc AAudioStreamBuilder_setBufferCapacityInFrames;
+            ma_proc AAudioStreamBuilder_setFramesPerDataCallback;
+            ma_proc AAudioStreamBuilder_setDataCallback;
+            ma_proc AAudioStreamBuilder_setErrorCallback;
+            ma_proc AAudioStreamBuilder_setPerformanceMode;
+            ma_proc AAudioStreamBuilder_setUsage;
+            ma_proc AAudioStreamBuilder_setContentType;
+            ma_proc AAudioStreamBuilder_setInputPreset;
+            ma_proc AAudioStreamBuilder_setAllowedCapturePolicy;
+            ma_proc AAudioStreamBuilder_openStream;
+            ma_proc AAudioStream_close;
+            ma_proc AAudioStream_getState;
+            ma_proc AAudioStream_waitForStateChange;
+            ma_proc AAudioStream_getFormat;
+            ma_proc AAudioStream_getChannelCount;
+            ma_proc AAudioStream_getSampleRate;
+            ma_proc AAudioStream_getBufferCapacityInFrames;
+            ma_proc AAudioStream_getFramesPerDataCallback;
+            ma_proc AAudioStream_getFramesPerBurst;
+            ma_proc AAudioStream_requestStart;
+            ma_proc AAudioStream_requestStop;
+            ma_device_job_thread jobThread; /* For processing operations outside of the error callback, specifically device disconnections and rerouting. */
+        } aaudio;
+#endif
+#ifdef MA_SUPPORT_OPENSL
+        struct
+        {
+            ma_handle libOpenSLES;
+            ma_handle SL_IID_ENGINE;
+            ma_handle SL_IID_AUDIOIODEVICECAPABILITIES;
+            ma_handle SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
+            ma_handle SL_IID_RECORD;
+            ma_handle SL_IID_PLAY;
+            ma_handle SL_IID_OUTPUTMIX;
+            ma_handle SL_IID_ANDROIDCONFIGURATION;
+            ma_proc   slCreateEngine;
+        } opensl;
+#endif
+#ifdef MA_SUPPORT_WEBAUDIO
+        struct
+        {
+            int _unused;
+        } webaudio;
+#endif
+#ifdef MA_SUPPORT_NULL
+        struct
+        {
+            int _unused;
+        } null_backend;
+#endif
+    };
+
+    union
+    {
+#if defined(MA_WIN32)
+        struct
+        {
+            /*HMODULE*/ ma_handle hOle32DLL;
+            ma_proc CoInitialize;
+            ma_proc CoInitializeEx;
+            ma_proc CoUninitialize;
+            ma_proc CoCreateInstance;
+            ma_proc CoTaskMemFree;
+            ma_proc PropVariantClear;
+            ma_proc StringFromGUID2;
+
+            /*HMODULE*/ ma_handle hUser32DLL;
+            ma_proc GetForegroundWindow;
+            ma_proc GetDesktopWindow;
+
+            /*HMODULE*/ ma_handle hAdvapi32DLL;
+            ma_proc RegOpenKeyExA;
+            ma_proc RegCloseKey;
+            ma_proc RegQueryValueExA;
+
+            /*HRESULT*/ long CoInitializeResult;
+        } win32;
+#endif
+#ifdef MA_POSIX
+        struct
+        {
+            int _unused;
+        } posix;
+#endif
+        int _unused;
+    };
+};
+
+struct ma_device
+{
+    ma_context* pContext;
+    ma_device_type type;
+    ma_uint32 sampleRate;
+    ma_atomic_device_state state;               /* The state of the device is variable and can change at any time on any thread. Must be used atomically. */
+    ma_device_data_proc onData;                 /* Set once at initialization time and should not be changed after. */
+    ma_device_notification_proc onNotification; /* Set once at initialization time and should not be changed after. */
+    ma_stop_proc onStop;                        /* DEPRECATED. Use the notification callback instead. Set once at initialization time and should not be changed after. */
+    void* pUserData;                            /* Application defined data. */
+    ma_mutex startStopLock;
+    ma_event wakeupEvent;
+    ma_event startEvent;
+    ma_event stopEvent;
+    ma_thread thread;
+    ma_result workResult;                       /* This is set by the worker thread after it's finished doing a job. */
+    ma_bool8 isOwnerOfContext;                  /* When set to true, uninitializing the device will also uninitialize the context. Set to true when NULL is passed into ma_device_init(). */
+    ma_bool8 noPreSilencedOutputBuffer;
+    ma_bool8 noClip;
+    ma_bool8 noDisableDenormals;
+    ma_bool8 noFixedSizedCallback;
+    ma_atomic_float masterVolumeFactor;         /* Linear 0..1. Can be read and written simultaneously by different threads. Must be used atomically. */
+    ma_duplex_rb duplexRB;                      /* Intermediary buffer for duplex device on asynchronous backends. */
+    struct
+    {
+        ma_resample_algorithm algorithm;
+        ma_resampling_backend_vtable* pBackendVTable;
+        void* pBackendUserData;
+        struct
+        {
+            ma_uint32 lpfOrder;
+        } linear;
+    } resampling;
+    struct
+    {
+        ma_device_id* pID;                  /* Set to NULL if using default ID, otherwise set to the address of "id". */
+        ma_device_id id;                    /* If using an explicit device, will be set to a copy of the ID used for initialization. Otherwise cleared to 0. */
+        char name[MA_MAX_DEVICE_NAME_LENGTH + 1];                     /* Maybe temporary. Likely to be replaced with a query API. */
+        ma_share_mode shareMode;            /* Set to whatever was passed in when the device was initialized. */
+        ma_format format;
+        ma_uint32 channels;
+        ma_channel channelMap[MA_MAX_CHANNELS];
+        ma_format internalFormat;
+        ma_uint32 internalChannels;
+        ma_uint32 internalSampleRate;
+        ma_channel internalChannelMap[MA_MAX_CHANNELS];
+        ma_uint32 internalPeriodSizeInFrames;
+        ma_uint32 internalPeriods;
+        ma_channel_mix_mode channelMixMode;
+        ma_bool32 calculateLFEFromSpatialChannels;
+        ma_data_converter converter;
+        void* pIntermediaryBuffer;          /* For implementing fixed sized buffer callbacks. Will be null if using variable sized callbacks. */
+        ma_uint32 intermediaryBufferCap;
+        ma_uint32 intermediaryBufferLen;    /* How many valid frames are sitting in the intermediary buffer. */
+        void* pInputCache;                  /* In external format. Can be null. */
+        ma_uint64 inputCacheCap;
+        ma_uint64 inputCacheConsumed;
+        ma_uint64 inputCacheRemaining;
+    } playback;
+    struct
+    {
+        ma_device_id* pID;                  /* Set to NULL if using default ID, otherwise set to the address of "id". */
+        ma_device_id id;                    /* If using an explicit device, will be set to a copy of the ID used for initialization. Otherwise cleared to 0. */
+        char name[MA_MAX_DEVICE_NAME_LENGTH + 1];                     /* Maybe temporary. Likely to be replaced with a query API. */
+        ma_share_mode shareMode;            /* Set to whatever was passed in when the device was initialized. */
+        ma_format format;
+        ma_uint32 channels;
+        ma_channel channelMap[MA_MAX_CHANNELS];
+        ma_format internalFormat;
+        ma_uint32 internalChannels;
+        ma_uint32 internalSampleRate;
+        ma_channel internalChannelMap[MA_MAX_CHANNELS];
+        ma_uint32 internalPeriodSizeInFrames;
+        ma_uint32 internalPeriods;
+        ma_channel_mix_mode channelMixMode;
+        ma_bool32 calculateLFEFromSpatialChannels;
+        ma_data_converter converter;
+        void* pIntermediaryBuffer;          /* For implementing fixed sized buffer callbacks. Will be null if using variable sized callbacks. */
+        ma_uint32 intermediaryBufferCap;
+        ma_uint32 intermediaryBufferLen;    /* How many valid frames are sitting in the intermediary buffer. */
+    } capture;
+
+    union
+    {
+#ifdef MA_SUPPORT_WASAPI
+        struct
+        {
+            /*IAudioClient**/ ma_ptr pAudioClientPlayback;
+            /*IAudioClient**/ ma_ptr pAudioClientCapture;
+            /*IAudioRenderClient**/ ma_ptr pRenderClient;
+            /*IAudioCaptureClient**/ ma_ptr pCaptureClient;
+            /*IMMDeviceEnumerator**/ ma_ptr pDeviceEnumerator;      /* Used for IMMNotificationClient notifications. Required for detecting default device changes. */
+            ma_IMMNotificationClient notificationClient;
+            /*HANDLE*/ ma_handle hEventPlayback;                    /* Auto reset. Initialized to signaled. */
+            /*HANDLE*/ ma_handle hEventCapture;                     /* Auto reset. Initialized to unsignaled. */
+            ma_uint32 actualBufferSizeInFramesPlayback;             /* Value from GetBufferSize(). internalPeriodSizeInFrames is not set to the _actual_ buffer size when low-latency shared mode is being used due to the way the IAudioClient3 API works. */
+            ma_uint32 actualBufferSizeInFramesCapture;
+            ma_uint32 originalPeriodSizeInFrames;
+            ma_uint32 originalPeriodSizeInMilliseconds;
+            ma_uint32 originalPeriods;
+            ma_performance_profile originalPerformanceProfile;
+            ma_uint32 periodSizeInFramesPlayback;
+            ma_uint32 periodSizeInFramesCapture;
+            void* pMappedBufferCapture;
+            ma_uint32 mappedBufferCaptureCap;
+            ma_uint32 mappedBufferCaptureLen;
+            void* pMappedBufferPlayback;
+            ma_uint32 mappedBufferPlaybackCap;
+            ma_uint32 mappedBufferPlaybackLen;
+            ma_atomic_bool32 isStartedCapture;                      /* Can be read and written simultaneously across different threads. Must be used atomically, and must be 32-bit. */
+            ma_atomic_bool32 isStartedPlayback;                     /* Can be read and written simultaneously across different threads. Must be used atomically, and must be 32-bit. */
+            ma_uint32 loopbackProcessID;
+            ma_bool8 loopbackProcessExclude;
+            ma_bool8 noAutoConvertSRC;                              /* When set to true, disables the use of AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM. */
+            ma_bool8 noDefaultQualitySRC;                           /* When set to true, disables the use of AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY. */
+            ma_bool8 noHardwareOffloading;
+            ma_bool8 allowCaptureAutoStreamRouting;
+            ma_bool8 allowPlaybackAutoStreamRouting;
+            ma_bool8 isDetachedPlayback;
+            ma_bool8 isDetachedCapture;
+            ma_wasapi_usage usage;
+            void* hAvrtHandle;
+            ma_mutex rerouteLock;
+        } wasapi;
+#endif
+#ifdef MA_SUPPORT_DSOUND
+        struct
+        {
+            /*LPDIRECTSOUND*/ ma_ptr pPlayback;
+            /*LPDIRECTSOUNDBUFFER*/ ma_ptr pPlaybackPrimaryBuffer;
+            /*LPDIRECTSOUNDBUFFER*/ ma_ptr pPlaybackBuffer;
+            /*LPDIRECTSOUNDCAPTURE*/ ma_ptr pCapture;
+            /*LPDIRECTSOUNDCAPTUREBUFFER*/ ma_ptr pCaptureBuffer;
+        } dsound;
+#endif
+#ifdef MA_SUPPORT_WINMM
+        struct
+        {
+            /*HWAVEOUT*/ ma_handle hDevicePlayback;
+            /*HWAVEIN*/ ma_handle hDeviceCapture;
+            /*HANDLE*/ ma_handle hEventPlayback;
+            /*HANDLE*/ ma_handle hEventCapture;
+            ma_uint32 fragmentSizeInFrames;
+            ma_uint32 iNextHeaderPlayback;             /* [0,periods). Used as an index into pWAVEHDRPlayback. */
+            ma_uint32 iNextHeaderCapture;              /* [0,periods). Used as an index into pWAVEHDRCapture. */
+            ma_uint32 headerFramesConsumedPlayback;    /* The number of PCM frames consumed in the buffer in pWAVEHEADER[iNextHeader]. */
+            ma_uint32 headerFramesConsumedCapture;     /* ^^^ */
+            /*WAVEHDR**/ ma_uint8* pWAVEHDRPlayback;   /* One instantiation for each period. */
+            /*WAVEHDR**/ ma_uint8* pWAVEHDRCapture;    /* One instantiation for each period. */
+            ma_uint8* pIntermediaryBufferPlayback;
+            ma_uint8* pIntermediaryBufferCapture;
+            ma_uint8* _pHeapData;                      /* Used internally and is used for the heap allocated data for the intermediary buffer and the WAVEHDR structures. */
+        } winmm;
+#endif
+#ifdef MA_SUPPORT_ALSA
+        struct
+        {
+            /*snd_pcm_t**/ ma_ptr pPCMPlayback;
+            /*snd_pcm_t**/ ma_ptr pPCMCapture;
+            /*struct pollfd**/ void* pPollDescriptorsPlayback;
+            /*struct pollfd**/ void* pPollDescriptorsCapture;
+            int pollDescriptorCountPlayback;
+            int pollDescriptorCountCapture;
+            int wakeupfdPlayback;   /* eventfd for waking up from poll() when the playback device is stopped. */
+            int wakeupfdCapture;    /* eventfd for waking up from poll() when the capture device is stopped. */
+            ma_bool8 isUsingMMapPlayback;
+            ma_bool8 isUsingMMapCapture;
+        } alsa;
+#endif
+#ifdef MA_SUPPORT_PULSEAUDIO
+        struct
+        {
+            /*pa_mainloop**/ ma_ptr pMainLoop;
+            /*pa_context**/ ma_ptr pPulseContext;
+            /*pa_stream**/ ma_ptr pStreamPlayback;
+            /*pa_stream**/ ma_ptr pStreamCapture;
+        } pulse;
+#endif
+#ifdef MA_SUPPORT_JACK
+        struct
+        {
+            /*jack_client_t**/ ma_ptr pClient;
+            /*jack_port_t**/ ma_ptr* ppPortsPlayback;
+            /*jack_port_t**/ ma_ptr* ppPortsCapture;
+            float* pIntermediaryBufferPlayback; /* Typed as a float because JACK is always floating point. */
+            float* pIntermediaryBufferCapture;
+        } jack;
+#endif
+#ifdef MA_SUPPORT_COREAUDIO
+        struct
+        {
+            ma_uint32 deviceObjectIDPlayback;
+            ma_uint32 deviceObjectIDCapture;
+            /*AudioUnit*/ ma_ptr audioUnitPlayback;
+            /*AudioUnit*/ ma_ptr audioUnitCapture;
+            /*AudioBufferList**/ ma_ptr pAudioBufferList;   /* Only used for input devices. */
+            ma_uint32 audioBufferCapInFrames;               /* Only used for input devices. The capacity in frames of each buffer in pAudioBufferList. */
+            ma_event stopEvent;
+            ma_uint32 originalPeriodSizeInFrames;
+            ma_uint32 originalPeriodSizeInMilliseconds;
+            ma_uint32 originalPeriods;
+            ma_performance_profile originalPerformanceProfile;
+            ma_bool32 isDefaultPlaybackDevice;
+            ma_bool32 isDefaultCaptureDevice;
+            ma_bool32 isSwitchingPlaybackDevice;   /* <-- Set to true when the default device has changed and miniaudio is in the process of switching. */
+            ma_bool32 isSwitchingCaptureDevice;    /* <-- Set to true when the default device has changed and miniaudio is in the process of switching. */
+            void* pNotificationHandler;             /* Only used on mobile platforms. Obj-C object for handling route changes. */
+        } coreaudio;
+#endif
+#ifdef MA_SUPPORT_SNDIO
+        struct
+        {
+            ma_ptr handlePlayback;
+            ma_ptr handleCapture;
+            ma_bool32 isStartedPlayback;
+            ma_bool32 isStartedCapture;
+        } sndio;
+#endif
+#ifdef MA_SUPPORT_AUDIO4
+        struct
+        {
+            int fdPlayback;
+            int fdCapture;
+        } audio4;
+#endif
+#ifdef MA_SUPPORT_OSS
+        struct
+        {
+            int fdPlayback;
+            int fdCapture;
+        } oss;
+#endif
+#ifdef MA_SUPPORT_AAUDIO
+        struct
+        {
+            /*AAudioStream**/ ma_ptr pStreamPlayback;
+            /*AAudioStream**/ ma_ptr pStreamCapture;
+            ma_aaudio_usage usage;
+            ma_aaudio_content_type contentType;
+            ma_aaudio_input_preset inputPreset;
+            ma_aaudio_allowed_capture_policy allowedCapturePolicy;
+            ma_bool32 noAutoStartAfterReroute;
+        } aaudio;
+#endif
+#ifdef MA_SUPPORT_OPENSL
+        struct
+        {
+            /*SLObjectItf*/ ma_ptr pOutputMixObj;
+            /*SLOutputMixItf*/ ma_ptr pOutputMix;
+            /*SLObjectItf*/ ma_ptr pAudioPlayerObj;
+            /*SLPlayItf*/ ma_ptr pAudioPlayer;
+            /*SLObjectItf*/ ma_ptr pAudioRecorderObj;
+            /*SLRecordItf*/ ma_ptr pAudioRecorder;
+            /*SLAndroidSimpleBufferQueueItf*/ ma_ptr pBufferQueuePlayback;
+            /*SLAndroidSimpleBufferQueueItf*/ ma_ptr pBufferQueueCapture;
+            ma_bool32 isDrainingCapture;
+            ma_bool32 isDrainingPlayback;
+            ma_uint32 currentBufferIndexPlayback;
+            ma_uint32 currentBufferIndexCapture;
+            ma_uint8* pBufferPlayback;      /* This is malloc()'d and is used for storing audio data. Typed as ma_uint8 for easy offsetting. */
+            ma_uint8* pBufferCapture;
+        } opensl;
+#endif
+#ifdef MA_SUPPORT_WEBAUDIO
+        struct
+        {
+            /* AudioWorklets path. */
+            /* EMSCRIPTEN_WEBAUDIO_T */ int audioContext;
+            /* EMSCRIPTEN_WEBAUDIO_T */ int audioWorklet;
+            float* pIntermediaryBuffer;
+            void* pStackBuffer;
+            ma_result initResult;   /* Set to MA_BUSY while initialization is in progress. */
+            int deviceIndex;        /* We store the device in a list on the JavaScript side. This is used to map our C object to the JS object. */
+        } webaudio;
+#endif
+#ifdef MA_SUPPORT_NULL
+        struct
+        {
+            ma_thread deviceThread;
+            ma_event operationEvent;
+            ma_event operationCompletionEvent;
+            ma_semaphore operationSemaphore;
+            ma_uint32 operation;
+            ma_result operationResult;
+            ma_timer timer;
+            double priorRunTime;
+            ma_uint32 currentPeriodFramesRemainingPlayback;
+            ma_uint32 currentPeriodFramesRemainingCapture;
+            ma_uint64 lastProcessedFramePlayback;
+            ma_uint64 lastProcessedFrameCapture;
+            ma_atomic_bool32 isStarted; /* Read and written by multiple threads. Must be used atomically, and must be 32-bit for compiler compatibility. */
+        } null_device;
+#endif
+    };
+};
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(pop)
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic pop  /* For ISO C99 doesn't support unnamed structs/unions [-Wpedantic] */
+#endif
+
+/*
+Initializes a `ma_context_config` object.
+
+
+Return Value
+------------
+A `ma_context_config` initialized to defaults.
+
+
+Remarks
+-------
+You must always use this to initialize the default state of the `ma_context_config` object. Not using this will result in your program breaking when miniaudio
+is updated and new members are added to `ma_context_config`. It also sets logical defaults.
+
+You can override members of the returned object by changing it's members directly.
+
+
+See Also
+--------
+ma_context_init()
+*/
+MA_API ma_context_config ma_context_config_init(void);
+
+/*
+Initializes a context.
+
+The context is used for selecting and initializing an appropriate backend and to represent the backend at a more global level than that of an individual
+device. There is one context to many devices, and a device is created from a context. A context is required to enumerate devices.
+
+
+Parameters
+----------
+backends (in, optional)
+    A list of backends to try initializing, in priority order. Can be NULL, in which case it uses default priority order.
+
+backendCount (in, optional)
+    The number of items in `backend`. Ignored if `backend` is NULL.
+
+pConfig (in, optional)
+    The context configuration.
+
+pContext (in)
+    A pointer to the context object being initialized.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. Do not call this function across multiple threads as some backends read and write to global state.
+
+
+Remarks
+-------
+When `backends` is NULL, the default priority order will be used. Below is a list of backends in priority order:
+
+    |-------------|-----------------------|--------------------------------------------------------|
+    | Name        | Enum Name             | Supported Operating Systems                            |
+    |-------------|-----------------------|--------------------------------------------------------|
+    | WASAPI      | ma_backend_wasapi     | Windows Vista+                                         |
+    | DirectSound | ma_backend_dsound     | Windows XP+                                            |
+    | WinMM       | ma_backend_winmm      | Windows XP+ (may work on older versions, but untested) |
+    | Core Audio  | ma_backend_coreaudio  | macOS, iOS                                             |
+    | ALSA        | ma_backend_alsa       | Linux                                                  |
+    | PulseAudio  | ma_backend_pulseaudio | Cross Platform (disabled on Windows, BSD and Android)  |
+    | JACK        | ma_backend_jack       | Cross Platform (disabled on BSD and Android)           |
+    | sndio       | ma_backend_sndio      | OpenBSD                                                |
+    | audio(4)    | ma_backend_audio4     | NetBSD, OpenBSD                                        |
+    | OSS         | ma_backend_oss        | FreeBSD                                                |
+    | AAudio      | ma_backend_aaudio     | Android 8+                                             |
+    | OpenSL|ES   | ma_backend_opensl     | Android (API level 16+)                                |
+    | Web Audio   | ma_backend_webaudio   | Web (via Emscripten)                                   |
+    | Null        | ma_backend_null       | Cross Platform (not used on Web)                       |
+    |-------------|-----------------------|--------------------------------------------------------|
+
+The context can be configured via the `pConfig` argument. The config object is initialized with `ma_context_config_init()`. Individual configuration settings
+can then be set directly on the structure. Below are the members of the `ma_context_config` object.
+
+    pLog
+        A pointer to the `ma_log` to post log messages to. Can be NULL if the application does not
+        require logging. See the `ma_log` API for details on how to use the logging system.
+
+    threadPriority
+        The desired priority to use for the audio thread. Allowable values include the following:
+
+        |--------------------------------------|
+        | Thread Priority                      |
+        |--------------------------------------|
+        | ma_thread_priority_idle              |
+        | ma_thread_priority_lowest            |
+        | ma_thread_priority_low               |
+        | ma_thread_priority_normal            |
+        | ma_thread_priority_high              |
+        | ma_thread_priority_highest (default) |
+        | ma_thread_priority_realtime          |
+        | ma_thread_priority_default           |
+        |--------------------------------------|
+
+    threadStackSize
+        The desired size of the stack for the audio thread. Defaults to the operating system's default.
+
+    pUserData
+        A pointer to application-defined data. This can be accessed from the context object directly such as `context.pUserData`.
+
+    allocationCallbacks
+        Structure containing custom allocation callbacks. Leaving this at defaults will cause it to use MA_MALLOC, MA_REALLOC and MA_FREE. These allocation
+        callbacks will be used for anything tied to the context, including devices.
+
+    alsa.useVerboseDeviceEnumeration
+        ALSA will typically enumerate many different devices which can be intrusive and not user-friendly. To combat this, miniaudio will enumerate only unique
+        card/device pairs by default. The problem with this is that you lose a bit of flexibility and control. Setting alsa.useVerboseDeviceEnumeration makes
+        it so the ALSA backend includes all devices. Defaults to false.
+
+    pulse.pApplicationName
+        PulseAudio only. The application name to use when initializing the PulseAudio context with `pa_context_new()`.
+
+    pulse.pServerName
+        PulseAudio only. The name of the server to connect to with `pa_context_connect()`.
+
+    pulse.tryAutoSpawn
+        PulseAudio only. Whether or not to try automatically starting the PulseAudio daemon. Defaults to false. If you set this to true, keep in mind that
+        miniaudio uses a trial and error method to find the most appropriate backend, and this will result in the PulseAudio daemon starting which may be
+        intrusive for the end user.
+
+    coreaudio.sessionCategory
+        iOS only. The session category to use for the shared AudioSession instance. Below is a list of allowable values and their Core Audio equivalents.
+
+        |-----------------------------------------|-------------------------------------|
+        | miniaudio Token                         | Core Audio Token                    |
+        |-----------------------------------------|-------------------------------------|
+        | ma_ios_session_category_ambient         | AVAudioSessionCategoryAmbient       |
+        | ma_ios_session_category_solo_ambient    | AVAudioSessionCategorySoloAmbient   |
+        | ma_ios_session_category_playback        | AVAudioSessionCategoryPlayback      |
+        | ma_ios_session_category_record          | AVAudioSessionCategoryRecord        |
+        | ma_ios_session_category_play_and_record | AVAudioSessionCategoryPlayAndRecord |
+        | ma_ios_session_category_multi_route     | AVAudioSessionCategoryMultiRoute    |
+        | ma_ios_session_category_none            | AVAudioSessionCategoryAmbient       |
+        | ma_ios_session_category_default         | AVAudioSessionCategoryAmbient       |
+        |-----------------------------------------|-------------------------------------|
+
+    coreaudio.sessionCategoryOptions
+        iOS only. Session category options to use with the shared AudioSession instance. Below is a list of allowable values and their Core Audio equivalents.
+
+        |---------------------------------------------------------------------------|------------------------------------------------------------------|
+        | miniaudio Token                                                           | Core Audio Token                                                 |
+        |---------------------------------------------------------------------------|------------------------------------------------------------------|
+        | ma_ios_session_category_option_mix_with_others                            | AVAudioSessionCategoryOptionMixWithOthers                        |
+        | ma_ios_session_category_option_duck_others                                | AVAudioSessionCategoryOptionDuckOthers                           |
+        | ma_ios_session_category_option_allow_bluetooth                            | AVAudioSessionCategoryOptionAllowBluetooth                       |
+        | ma_ios_session_category_option_default_to_speaker                         | AVAudioSessionCategoryOptionDefaultToSpeaker                     |
+        | ma_ios_session_category_option_interrupt_spoken_audio_and_mix_with_others | AVAudioSessionCategoryOptionInterruptSpokenAudioAndMixWithOthers |
+        | ma_ios_session_category_option_allow_bluetooth_a2dp                       | AVAudioSessionCategoryOptionAllowBluetoothA2DP                   |
+        | ma_ios_session_category_option_allow_air_play                             | AVAudioSessionCategoryOptionAllowAirPlay                         |
+        |---------------------------------------------------------------------------|------------------------------------------------------------------|
+
+    coreaudio.noAudioSessionActivate
+        iOS only. When set to true, does not perform an explicit [[AVAudioSession sharedInstace] setActive:true] on initialization.
+
+    coreaudio.noAudioSessionDeactivate
+        iOS only. When set to true, does not perform an explicit [[AVAudioSession sharedInstace] setActive:false] on uninitialization.
+
+    jack.pClientName
+        The name of the client to pass to `jack_client_open()`.
+
+    jack.tryStartServer
+        Whether or not to try auto-starting the JACK server. Defaults to false.
+
+
+It is recommended that only a single context is active at any given time because it's a bulky data structure which performs run-time linking for the
+relevant backends every time it's initialized.
+
+The location of the context cannot change throughout it's lifetime. Consider allocating the `ma_context` object with `malloc()` if this is an issue. The
+reason for this is that a pointer to the context is stored in the `ma_device` structure.
+
+
+Example 1 - Default Initialization
+----------------------------------
+The example below shows how to initialize the context using the default configuration.
+
+```c
+ma_context context;
+ma_result result = ma_context_init(NULL, 0, NULL, &context);
+if (result != MA_SUCCESS) {
+    // Error.
+}
+```
+
+
+Example 2 - Custom Configuration
+--------------------------------
+The example below shows how to initialize the context using custom backend priorities and a custom configuration. In this hypothetical example, the program
+wants to prioritize ALSA over PulseAudio on Linux. They also want to avoid using the WinMM backend on Windows because it's latency is too high. They also
+want an error to be returned if no valid backend is available which they achieve by excluding the Null backend.
+
+For the configuration, the program wants to capture any log messages so they can, for example, route it to a log file and user interface.
+
+```c
+ma_backend backends[] = {
+    ma_backend_alsa,
+    ma_backend_pulseaudio,
+    ma_backend_wasapi,
+    ma_backend_dsound
+};
+
+ma_log log;
+ma_log_init(&log);
+ma_log_register_callback(&log, ma_log_callback_init(my_log_callbac, pMyLogUserData));
+
+ma_context_config config = ma_context_config_init();
+config.pLog = &log; // Specify a custom log object in the config so any logs that are posted from ma_context_init() are captured.
+
+ma_context context;
+ma_result result = ma_context_init(backends, sizeof(backends)/sizeof(backends[0]), &config, &context);
+if (result != MA_SUCCESS) {
+    // Error.
+    if (result == MA_NO_BACKEND) {
+        // Couldn't find an appropriate backend.
+    }
+}
+
+// You could also attach a log callback post-initialization:
+ma_log_register_callback(ma_context_get_log(&context), ma_log_callback_init(my_log_callback, pMyLogUserData));
+```
+
+
+See Also
+--------
+ma_context_config_init()
+ma_context_uninit()
+*/
+MA_API ma_result ma_context_init(const ma_backend backends[], ma_uint32 backendCount, const ma_context_config* pConfig, ma_context* pContext);
+
+/*
+Uninitializes a context.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. Do not call this function across multiple threads as some backends read and write to global state.
+
+
+Remarks
+-------
+Results are undefined if you call this while any device created by this context is still active.
+
+
+See Also
+--------
+ma_context_init()
+*/
+MA_API ma_result ma_context_uninit(ma_context* pContext);
+
+/*
+Retrieves the size of the ma_context object.
+
+This is mainly for the purpose of bindings to know how much memory to allocate.
+*/
+MA_API size_t ma_context_sizeof(void);
+
+/*
+Retrieves a pointer to the log object associated with this context.
+
+
+Remarks
+-------
+Pass the returned pointer to `ma_log_post()`, `ma_log_postv()` or `ma_log_postf()` to post a log
+message.
+
+You can attach your own logging callback to the log with `ma_log_register_callback()`
+
+
+Return Value
+------------
+A pointer to the `ma_log` object that the context uses to post log messages. If some error occurs,
+NULL will be returned.
+*/
+MA_API ma_log* ma_context_get_log(ma_context* pContext);
+
+/*
+Enumerates over every device (both playback and capture).
+
+This is a lower-level enumeration function to the easier to use `ma_context_get_devices()`. Use `ma_context_enumerate_devices()` if you would rather not incur
+an internal heap allocation, or it simply suits your code better.
+
+Note that this only retrieves the ID and name/description of the device. The reason for only retrieving basic information is that it would otherwise require
+opening the backend device in order to probe it for more detailed information which can be inefficient. Consider using `ma_context_get_device_info()` for this,
+but don't call it from within the enumeration callback.
+
+Returning false from the callback will stop enumeration. Returning true will continue enumeration.
+
+
+Parameters
+----------
+pContext (in)
+    A pointer to the context performing the enumeration.
+
+callback (in)
+    The callback to fire for each enumerated device.
+
+pUserData (in)
+    A pointer to application-defined data passed to the callback.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Safe. This is guarded using a simple mutex lock.
+
+
+Remarks
+-------
+Do _not_ assume the first enumerated device of a given type is the default device.
+
+Some backends and platforms may only support default playback and capture devices.
+
+In general, you should not do anything complicated from within the callback. In particular, do not try initializing a device from within the callback. Also,
+do not try to call `ma_context_get_device_info()` from within the callback.
+
+Consider using `ma_context_get_devices()` for a simpler and safer API, albeit at the expense of an internal heap allocation.
+
+
+Example 1 - Simple Enumeration
+------------------------------
+ma_bool32 ma_device_enum_callback(ma_context* pContext, ma_device_type deviceType, const ma_device_info* pInfo, void* pUserData)
+{
+    printf("Device Name: %s\n", pInfo->name);
+    return MA_TRUE;
+}
+
+ma_result result = ma_context_enumerate_devices(&context, my_device_enum_callback, pMyUserData);
+if (result != MA_SUCCESS) {
+    // Error.
+}
+
+
+See Also
+--------
+ma_context_get_devices()
+*/
+MA_API ma_result ma_context_enumerate_devices(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData);
+
+/*
+Retrieves basic information about every active playback and/or capture device.
+
+This function will allocate memory internally for the device lists and return a pointer to them through the `ppPlaybackDeviceInfos` and `ppCaptureDeviceInfos`
+parameters. If you do not want to incur the overhead of these allocations consider using `ma_context_enumerate_devices()` which will instead use a callback.
+
+
+Parameters
+----------
+pContext (in)
+    A pointer to the context performing the enumeration.
+
+ppPlaybackDeviceInfos (out)
+    A pointer to a pointer that will receive the address of a buffer containing the list of `ma_device_info` structures for playback devices.
+
+pPlaybackDeviceCount (out)
+    A pointer to an unsigned integer that will receive the number of playback devices.
+
+ppCaptureDeviceInfos (out)
+    A pointer to a pointer that will receive the address of a buffer containing the list of `ma_device_info` structures for capture devices.
+
+pCaptureDeviceCount (out)
+    A pointer to an unsigned integer that will receive the number of capture devices.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. Since each call to this function invalidates the pointers from the previous call, you should not be calling this simultaneously across multiple
+threads. Instead, you need to make a copy of the returned data with your own higher level synchronization.
+
+
+Remarks
+-------
+It is _not_ safe to assume the first device in the list is the default device.
+
+You can pass in NULL for the playback or capture lists in which case they'll be ignored.
+
+The returned pointers will become invalid upon the next call this this function, or when the context is uninitialized. Do not free the returned pointers.
+
+
+See Also
+--------
+ma_context_get_devices()
+*/
+MA_API ma_result ma_context_get_devices(ma_context* pContext, ma_device_info** ppPlaybackDeviceInfos, ma_uint32* pPlaybackDeviceCount, ma_device_info** ppCaptureDeviceInfos, ma_uint32* pCaptureDeviceCount);
+
+/*
+Retrieves information about a device of the given type, with the specified ID and share mode.
+
+
+Parameters
+----------
+pContext (in)
+    A pointer to the context performing the query.
+
+deviceType (in)
+    The type of the device being queried. Must be either `ma_device_type_playback` or `ma_device_type_capture`.
+
+pDeviceID (in)
+    The ID of the device being queried.
+
+pDeviceInfo (out)
+    A pointer to the `ma_device_info` structure that will receive the device information.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Safe. This is guarded using a simple mutex lock.
+
+
+Remarks
+-------
+Do _not_ call this from within the `ma_context_enumerate_devices()` callback.
+
+It's possible for a device to have different information and capabilities depending on whether or not it's opened in shared or exclusive mode. For example, in
+shared mode, WASAPI always uses floating point samples for mixing, but in exclusive mode it can be anything. Therefore, this function allows you to specify
+which share mode you want information for. Note that not all backends and devices support shared or exclusive mode, in which case this function will fail if
+the requested share mode is unsupported.
+
+This leaves pDeviceInfo unmodified in the result of an error.
+*/
+MA_API ma_result ma_context_get_device_info(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo);
+
+/*
+Determines if the given context supports loopback mode.
+
+
+Parameters
+----------
+pContext (in)
+    A pointer to the context getting queried.
+
+
+Return Value
+------------
+MA_TRUE if the context supports loopback mode; MA_FALSE otherwise.
+*/
+MA_API ma_bool32 ma_context_is_loopback_supported(ma_context* pContext);
+
+
+
+/*
+Initializes a device config with default settings.
+
+
+Parameters
+----------
+deviceType (in)
+    The type of the device this config is being initialized for. This must set to one of the following:
+
+    |-------------------------|
+    | Device Type             |
+    |-------------------------|
+    | ma_device_type_playback |
+    | ma_device_type_capture  |
+    | ma_device_type_duplex   |
+    | ma_device_type_loopback |
+    |-------------------------|
+
+
+Return Value
+------------
+A new device config object with default settings. You will typically want to adjust the config after this function returns. See remarks.
+
+
+Thread Safety
+-------------
+Safe.
+
+
+Callback Safety
+---------------
+Safe, but don't try initializing a device in a callback.
+
+
+Remarks
+-------
+The returned config will be initialized to defaults. You will normally want to customize a few variables before initializing the device. See Example 1 for a
+typical configuration which sets the sample format, channel count, sample rate, data callback and user data. These are usually things you will want to change
+before initializing the device.
+
+See `ma_device_init()` for details on specific configuration options.
+
+
+Example 1 - Simple Configuration
+--------------------------------
+The example below is what a program will typically want to configure for each device at a minimum. Notice how `ma_device_config_init()` is called first, and
+then the returned object is modified directly. This is important because it ensures that your program continues to work as new configuration options are added
+to the `ma_device_config` structure.
+
+```c
+ma_device_config config = ma_device_config_init(ma_device_type_playback);
+config.playback.format   = ma_format_f32;
+config.playback.channels = 2;
+config.sampleRate        = 48000;
+config.dataCallback      = ma_data_callback;
+config.pUserData         = pMyUserData;
+```
+
+
+See Also
+--------
+ma_device_init()
+ma_device_init_ex()
+*/
+MA_API ma_device_config ma_device_config_init(ma_device_type deviceType);
+
+
+/*
+Initializes a device.
+
+A device represents a physical audio device. The idea is you send or receive audio data from the device to either play it back through a speaker, or capture it
+from a microphone. Whether or not you should send or receive data from the device (or both) depends on the type of device you are initializing which can be
+playback, capture, full-duplex or loopback. (Note that loopback mode is only supported on select backends.) Sending and receiving audio data to and from the
+device is done via a callback which is fired by miniaudio at periodic time intervals.
+
+The frequency at which data is delivered to and from a device depends on the size of it's period. The size of the period can be defined in terms of PCM frames
+or milliseconds, whichever is more convenient. Generally speaking, the smaller the period, the lower the latency at the expense of higher CPU usage and
+increased risk of glitching due to the more frequent and granular data deliver intervals. The size of a period will depend on your requirements, but
+miniaudio's defaults should work fine for most scenarios. If you're building a game you should leave this fairly small, whereas if you're building a simple
+media player you can make it larger. Note that the period size you request is actually just a hint - miniaudio will tell the backend what you want, but the
+backend is ultimately responsible for what it gives you. You cannot assume you will get exactly what you ask for.
+
+When delivering data to and from a device you need to make sure it's in the correct format which you can set through the device configuration. You just set the
+format that you want to use and miniaudio will perform all of the necessary conversion for you internally. When delivering data to and from the callback you
+can assume the format is the same as what you requested when you initialized the device. See Remarks for more details on miniaudio's data conversion pipeline.
+
+
+Parameters
+----------
+pContext (in, optional)
+    A pointer to the context that owns the device. This can be null, in which case it creates a default context internally.
+
+pConfig (in)
+    A pointer to the device configuration. Cannot be null. See remarks for details.
+
+pDevice (out)
+    A pointer to the device object being initialized.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. It is not safe to call this function simultaneously for different devices because some backends depend on and mutate global state. The same applies to
+calling this at the same time as `ma_device_uninit()`.
+
+
+Callback Safety
+---------------
+Unsafe. It is not safe to call this inside any callback.
+
+
+Remarks
+-------
+Setting `pContext` to NULL will result in miniaudio creating a default context internally and is equivalent to passing in a context initialized like so:
+
+    ```c
+    ma_context_init(NULL, 0, NULL, &context);
+    ```
+
+Do not set `pContext` to NULL if you are needing to open multiple devices. You can, however, use NULL when initializing the first device, and then use
+device.pContext for the initialization of other devices.
+
+The device can be configured via the `pConfig` argument. The config object is initialized with `ma_device_config_init()`. Individual configuration settings can
+then be set directly on the structure. Below are the members of the `ma_device_config` object.
+
+    deviceType
+        Must be `ma_device_type_playback`, `ma_device_type_capture`, `ma_device_type_duplex` of `ma_device_type_loopback`.
+
+    sampleRate
+        The sample rate, in hertz. The most common sample rates are 48000 and 44100. Setting this to 0 will use the device's native sample rate.
+
+    periodSizeInFrames
+        The desired size of a period in PCM frames. If this is 0, `periodSizeInMilliseconds` will be used instead. If both are 0 the default buffer size will
+        be used depending on the selected performance profile. This value affects latency. See below for details.
+
+    periodSizeInMilliseconds
+        The desired size of a period in milliseconds. If this is 0, `periodSizeInFrames` will be used instead. If both are 0 the default buffer size will be
+        used depending on the selected performance profile. The value affects latency. See below for details.
+
+    periods
+        The number of periods making up the device's entire buffer. The total buffer size is `periodSizeInFrames` or `periodSizeInMilliseconds` multiplied by
+        this value. This is just a hint as backends will be the ones who ultimately decide how your periods will be configured.
+
+    performanceProfile
+        A hint to miniaudio as to the performance requirements of your program. Can be either `ma_performance_profile_low_latency` (default) or
+        `ma_performance_profile_conservative`. This mainly affects the size of default buffers and can usually be left at it's default value.
+
+    noPreSilencedOutputBuffer
+        When set to true, the contents of the output buffer passed into the data callback will be left undefined. When set to false (default), the contents of
+        the output buffer will be cleared the zero. You can use this to avoid the overhead of zeroing out the buffer if you can guarantee that your data
+        callback will write to every sample in the output buffer, or if you are doing your own clearing.
+
+    noClip
+        When set to true, the contents of the output buffer are left alone after returning and it will be left up to the backend itself to decide whether or
+        not to clip. When set to false (default), the contents of the output buffer passed into the data callback will be clipped after returning. This only
+        applies when the playback sample format is f32.
+
+    noDisableDenormals
+        By default, miniaudio will disable denormals when the data callback is called. Setting this to true will prevent the disabling of denormals.
+
+    noFixedSizedCallback
+        Allows miniaudio to fire the data callback with any frame count. When this is set to false (the default), the data callback will be fired with a
+        consistent frame count as specified by `periodSizeInFrames` or `periodSizeInMilliseconds`. When set to true, miniaudio will fire the callback with
+        whatever the backend requests, which could be anything.
+
+    dataCallback
+        The callback to fire whenever data is ready to be delivered to or from the device.
+
+    notificationCallback
+        The callback to fire when something has changed with the device, such as whether or not it has been started or stopped.
+
+    pUserData
+        The user data pointer to use with the device. You can access this directly from the device object like `device.pUserData`.
+
+    resampling.algorithm
+        The resampling algorithm to use when miniaudio needs to perform resampling between the rate specified by `sampleRate` and the device's native rate. The
+        default value is `ma_resample_algorithm_linear`, and the quality can be configured with `resampling.linear.lpfOrder`.
+
+    resampling.pBackendVTable
+        A pointer to an optional vtable that can be used for plugging in a custom resampler.
+
+    resampling.pBackendUserData
+        A pointer that will passed to callbacks in pBackendVTable.
+
+    resampling.linear.lpfOrder
+        The linear resampler applies a low-pass filter as part of it's processing for anti-aliasing. This setting controls the order of the filter. The higher
+        the value, the better the quality, in general. Setting this to 0 will disable low-pass filtering altogether. The maximum value is
+        `MA_MAX_FILTER_ORDER`. The default value is `min(4, MA_MAX_FILTER_ORDER)`.
+
+    playback.pDeviceID
+        A pointer to a `ma_device_id` structure containing the ID of the playback device to initialize. Setting this NULL (default) will use the system's
+        default playback device. Retrieve the device ID from the `ma_device_info` structure, which can be retrieved using device enumeration.
+
+    playback.format
+        The sample format to use for playback. When set to `ma_format_unknown` the device's native format will be used. This can be retrieved after
+        initialization from the device object directly with `device.playback.format`.
+
+    playback.channels
+        The number of channels to use for playback. When set to 0 the device's native channel count will be used. This can be retrieved after initialization
+        from the device object directly with `device.playback.channels`.
+
+    playback.pChannelMap
+        The channel map to use for playback. When left empty, the device's native channel map will be used. This can be retrieved after initialization from the
+        device object direct with `device.playback.pChannelMap`. When set, the buffer should contain `channels` items.
+
+    playback.shareMode
+        The preferred share mode to use for playback. Can be either `ma_share_mode_shared` (default) or `ma_share_mode_exclusive`. Note that if you specify
+        exclusive mode, but it's not supported by the backend, initialization will fail. You can then fall back to shared mode if desired by changing this to
+        ma_share_mode_shared and reinitializing.
+
+    capture.pDeviceID
+        A pointer to a `ma_device_id` structure containing the ID of the capture device to initialize. Setting this NULL (default) will use the system's
+        default capture device. Retrieve the device ID from the `ma_device_info` structure, which can be retrieved using device enumeration.
+
+    capture.format
+        The sample format to use for capture. When set to `ma_format_unknown` the device's native format will be used. This can be retrieved after
+        initialization from the device object directly with `device.capture.format`.
+
+    capture.channels
+        The number of channels to use for capture. When set to 0 the device's native channel count will be used. This can be retrieved after initialization
+        from the device object directly with `device.capture.channels`.
+
+    capture.pChannelMap
+        The channel map to use for capture. When left empty, the device's native channel map will be used. This can be retrieved after initialization from the
+        device object direct with `device.capture.pChannelMap`. When set, the buffer should contain `channels` items.
+
+    capture.shareMode
+        The preferred share mode to use for capture. Can be either `ma_share_mode_shared` (default) or `ma_share_mode_exclusive`. Note that if you specify
+        exclusive mode, but it's not supported by the backend, initialization will fail. You can then fall back to shared mode if desired by changing this to
+        ma_share_mode_shared and reinitializing.
+
+    wasapi.noAutoConvertSRC
+        WASAPI only. When set to true, disables WASAPI's automatic resampling and forces the use of miniaudio's resampler. Defaults to false.
+
+    wasapi.noDefaultQualitySRC
+        WASAPI only. Only used when `wasapi.noAutoConvertSRC` is set to false. When set to true, disables the use of `AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY`.
+        You should usually leave this set to false, which is the default.
+
+    wasapi.noAutoStreamRouting
+        WASAPI only. When set to true, disables automatic stream routing on the WASAPI backend. Defaults to false.
+
+    wasapi.noHardwareOffloading
+        WASAPI only. When set to true, disables the use of WASAPI's hardware offloading feature. Defaults to false.
+
+    alsa.noMMap
+        ALSA only. When set to true, disables MMap mode. Defaults to false.
+
+    alsa.noAutoFormat
+        ALSA only. When set to true, disables ALSA's automatic format conversion by including the SND_PCM_NO_AUTO_FORMAT flag. Defaults to false.
+
+    alsa.noAutoChannels
+        ALSA only. When set to true, disables ALSA's automatic channel conversion by including the SND_PCM_NO_AUTO_CHANNELS flag. Defaults to false.
+
+    alsa.noAutoResample
+        ALSA only. When set to true, disables ALSA's automatic resampling by including the SND_PCM_NO_AUTO_RESAMPLE flag. Defaults to false.
+
+    pulse.pStreamNamePlayback
+        PulseAudio only. Sets the stream name for playback.
+
+    pulse.pStreamNameCapture
+        PulseAudio only. Sets the stream name for capture.
+
+    coreaudio.allowNominalSampleRateChange
+        Core Audio only. Desktop only. When enabled, allows the sample rate of the device to be changed at the operating system level. This
+        is disabled by default in order to prevent intrusive changes to the user's system. This is useful if you want to use a sample rate
+        that is known to be natively supported by the hardware thereby avoiding the cost of resampling. When set to true, miniaudio will
+        find the closest match between the sample rate requested in the device config and the sample rates natively supported by the
+        hardware. When set to false, the sample rate currently set by the operating system will always be used.
+
+    opensl.streamType
+        OpenSL only. Explicitly sets the stream type. If left unset (`ma_opensl_stream_type_default`), the
+        stream type will be left unset. Think of this as the type of audio you're playing.
+
+    opensl.recordingPreset
+        OpenSL only. Explicitly sets the type of recording your program will be doing. When left
+        unset, the recording preset will be left unchanged.
+
+    aaudio.usage
+        AAudio only. Explicitly sets the nature of the audio the program will be consuming. When
+        left unset, the usage will be left unchanged.
+
+    aaudio.contentType
+        AAudio only. Sets the content type. When left unset, the content type will be left unchanged.
+
+    aaudio.inputPreset
+        AAudio only. Explicitly sets the type of recording your program will be doing. When left
+        unset, the input preset will be left unchanged.
+
+    aaudio.noAutoStartAfterReroute
+        AAudio only. Controls whether or not the device should be automatically restarted after a
+        stream reroute. When set to false (default) the device will be restarted automatically;
+        otherwise the device will be stopped.
+
+
+Once initialized, the device's config is immutable. If you need to change the config you will need to initialize a new device.
+
+After initializing the device it will be in a stopped state. To start it, use `ma_device_start()`.
+
+If both `periodSizeInFrames` and `periodSizeInMilliseconds` are set to zero, it will default to `MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY` or
+`MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE`, depending on whether or not `performanceProfile` is set to `ma_performance_profile_low_latency` or
+`ma_performance_profile_conservative`.
+
+If you request exclusive mode and the backend does not support it an error will be returned. For robustness, you may want to first try initializing the device
+in exclusive mode, and then fall back to shared mode if required. Alternatively you can just request shared mode (the default if you leave it unset in the
+config) which is the most reliable option. Some backends do not have a practical way of choosing whether or not the device should be exclusive or not (ALSA,
+for example) in which case it just acts as a hint. Unless you have special requirements you should try avoiding exclusive mode as it's intrusive to the user.
+Starting with Windows 10, miniaudio will use low-latency shared mode where possible which may make exclusive mode unnecessary.
+
+When sending or receiving data to/from a device, miniaudio will internally perform a format conversion to convert between the format specified by the config
+and the format used internally by the backend. If you pass in 0 for the sample format, channel count, sample rate _and_ channel map, data transmission will run
+on an optimized pass-through fast path. You can retrieve the format, channel count and sample rate by inspecting the `playback/capture.format`,
+`playback/capture.channels` and `sampleRate` members of the device object.
+
+When compiling for UWP you must ensure you call this function on the main UI thread because the operating system may need to present the user with a message
+asking for permissions. Please refer to the official documentation for ActivateAudioInterfaceAsync() for more information.
+
+ALSA Specific: When initializing the default device, requesting shared mode will try using the "dmix" device for playback and the "dsnoop" device for capture.
+If these fail it will try falling back to the "hw" device.
+
+
+Example 1 - Simple Initialization
+---------------------------------
+This example shows how to initialize a simple playback device using a standard configuration. If you are just needing to do simple playback from the default
+playback device this is usually all you need.
+
+```c
+ma_device_config config = ma_device_config_init(ma_device_type_playback);
+config.playback.format   = ma_format_f32;
+config.playback.channels = 2;
+config.sampleRate        = 48000;
+config.dataCallback      = ma_data_callback;
+config.pMyUserData       = pMyUserData;
+
+ma_device device;
+ma_result result = ma_device_init(NULL, &config, &device);
+if (result != MA_SUCCESS) {
+    // Error
+}
+```
+
+
+Example 2 - Advanced Initialization
+-----------------------------------
+This example shows how you might do some more advanced initialization. In this hypothetical example we want to control the latency by setting the buffer size
+and period count. We also want to allow the user to be able to choose which device to output from which means we need a context so we can perform device
+enumeration.
+
+```c
+ma_context context;
+ma_result result = ma_context_init(NULL, 0, NULL, &context);
+if (result != MA_SUCCESS) {
+    // Error
+}
+
+ma_device_info* pPlaybackDeviceInfos;
+ma_uint32 playbackDeviceCount;
+result = ma_context_get_devices(&context, &pPlaybackDeviceInfos, &playbackDeviceCount, NULL, NULL);
+if (result != MA_SUCCESS) {
+    // Error
+}
+
+// ... choose a device from pPlaybackDeviceInfos ...
+
+ma_device_config config = ma_device_config_init(ma_device_type_playback);
+config.playback.pDeviceID       = pMyChosenDeviceID;    // <-- Get this from the `id` member of one of the `ma_device_info` objects returned by ma_context_get_devices().
+config.playback.format          = ma_format_f32;
+config.playback.channels        = 2;
+config.sampleRate               = 48000;
+config.dataCallback             = ma_data_callback;
+config.pUserData                = pMyUserData;
+config.periodSizeInMilliseconds = 10;
+config.periods                  = 3;
+
+ma_device device;
+result = ma_device_init(&context, &config, &device);
+if (result != MA_SUCCESS) {
+    // Error
+}
+```
+
+
+See Also
+--------
+ma_device_config_init()
+ma_device_uninit()
+ma_device_start()
+ma_context_init()
+ma_context_get_devices()
+ma_context_enumerate_devices()
+*/
+MA_API ma_result ma_device_init(ma_context* pContext, const ma_device_config* pConfig, ma_device* pDevice);
+
+/*
+Initializes a device without a context, with extra parameters for controlling the configuration of the internal self-managed context.
+
+This is the same as `ma_device_init()`, only instead of a context being passed in, the parameters from `ma_context_init()` are passed in instead. This function
+allows you to configure the internally created context.
+
+
+Parameters
+----------
+backends (in, optional)
+    A list of backends to try initializing, in priority order. Can be NULL, in which case it uses default priority order.
+
+backendCount (in, optional)
+    The number of items in `backend`. Ignored if `backend` is NULL.
+
+pContextConfig (in, optional)
+    The context configuration.
+
+pConfig (in)
+    A pointer to the device configuration. Cannot be null. See remarks for details.
+
+pDevice (out)
+    A pointer to the device object being initialized.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. It is not safe to call this function simultaneously for different devices because some backends depend on and mutate global state. The same applies to
+calling this at the same time as `ma_device_uninit()`.
+
+
+Callback Safety
+---------------
+Unsafe. It is not safe to call this inside any callback.
+
+
+Remarks
+-------
+You only need to use this function if you want to configure the context differently to it's defaults. You should never use this function if you want to manage
+your own context.
+
+See the documentation for `ma_context_init()` for information on the different context configuration options.
+
+
+See Also
+--------
+ma_device_init()
+ma_device_uninit()
+ma_device_config_init()
+ma_context_init()
+*/
+MA_API ma_result ma_device_init_ex(const ma_backend backends[], ma_uint32 backendCount, const ma_context_config* pContextConfig, const ma_device_config* pConfig, ma_device* pDevice);
+
+/*
+Uninitializes a device.
+
+This will explicitly stop the device. You do not need to call `ma_device_stop()` beforehand, but it's harmless if you do.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device to stop.
+
+
+Return Value
+------------
+Nothing
+
+
+Thread Safety
+-------------
+Unsafe. As soon as this API is called the device should be considered undefined.
+
+
+Callback Safety
+---------------
+Unsafe. It is not safe to call this inside any callback. Doing this will result in a deadlock.
+
+
+See Also
+--------
+ma_device_init()
+ma_device_stop()
+*/
+MA_API void ma_device_uninit(ma_device* pDevice);
+
+
+/*
+Retrieves a pointer to the context that owns the given device.
+*/
+MA_API ma_context* ma_device_get_context(ma_device* pDevice);
+
+/*
+Helper function for retrieving the log object associated with the context that owns this device.
+*/
+MA_API ma_log* ma_device_get_log(ma_device* pDevice);
+
+
+/*
+Retrieves information about the device.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose information is being retrieved.
+
+type (in)
+    The device type. This parameter is required for duplex devices. When retrieving device
+    information, you are doing so for an individual playback or capture device.
+
+pDeviceInfo (out)
+    A pointer to the `ma_device_info` that will receive the device information.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. This should be considered unsafe because it may be calling into the backend which may or
+may not be safe.
+
+
+Callback Safety
+---------------
+Unsafe. You should avoid calling this in the data callback because it may call into the backend
+which may or may not be safe.
+*/
+MA_API ma_result ma_device_get_info(ma_device* pDevice, ma_device_type type, ma_device_info* pDeviceInfo);
+
+
+/*
+Retrieves the name of the device.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose information is being retrieved.
+
+type (in)
+    The device type. This parameter is required for duplex devices. When retrieving device
+    information, you are doing so for an individual playback or capture device.
+
+pName (out)
+    A pointer to the buffer that will receive the name.
+
+nameCap (in)
+    The capacity of the output buffer, including space for the null terminator.
+
+pLengthNotIncludingNullTerminator (out, optional)
+    A pointer to the variable that will receive the length of the name, not including the null
+    terminator.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. This should be considered unsafe because it may be calling into the backend which may or
+may not be safe.
+
+
+Callback Safety
+---------------
+Unsafe. You should avoid calling this in the data callback because it may call into the backend
+which may or may not be safe.
+
+
+Remarks
+-------
+If the name does not fully fit into the output buffer, it'll be truncated. You can pass in NULL to
+`pName` if you want to first get the length of the name for the purpose of memory allocation of the
+output buffer. Allocating a buffer of size `MA_MAX_DEVICE_NAME_LENGTH + 1` should be enough for
+most cases and will avoid the need for the inefficiency of calling this function twice.
+
+This is implemented in terms of `ma_device_get_info()`.
+*/
+MA_API ma_result ma_device_get_name(ma_device* pDevice, ma_device_type type, char* pName, size_t nameCap, size_t* pLengthNotIncludingNullTerminator);
+
+
+/*
+Starts the device. For playback devices this begins playback. For capture devices it begins recording.
+
+Use `ma_device_stop()` to stop the device.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device to start.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Safe. It's safe to call this from any thread with the exception of the callback thread.
+
+
+Callback Safety
+---------------
+Unsafe. It is not safe to call this inside any callback.
+
+
+Remarks
+-------
+For a playback device, this will retrieve an initial chunk of audio data from the client before returning. The reason for this is to ensure there is valid
+audio data in the buffer, which needs to be done before the device begins playback.
+
+This API waits until the backend device has been started for real by the worker thread. It also waits on a mutex for thread-safety.
+
+Do not call this in any callback.
+
+
+See Also
+--------
+ma_device_stop()
+*/
+MA_API ma_result ma_device_start(ma_device* pDevice);
+
+/*
+Stops the device. For playback devices this stops playback. For capture devices it stops recording.
+
+Use `ma_device_start()` to start the device again.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device to stop.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error code otherwise.
+
+
+Thread Safety
+-------------
+Safe. It's safe to call this from any thread with the exception of the callback thread.
+
+
+Callback Safety
+---------------
+Unsafe. It is not safe to call this inside any callback. Doing this will result in a deadlock.
+
+
+Remarks
+-------
+This API needs to wait on the worker thread to stop the backend device properly before returning. It also waits on a mutex for thread-safety. In addition, some
+backends need to wait for the device to finish playback/recording of the current fragment which can take some time (usually proportionate to the buffer size
+that was specified at initialization time).
+
+Backends are required to either pause the stream in-place or drain the buffer if pausing is not possible. The reason for this is that stopping the device and
+the resuming it with ma_device_start() (which you might do when your program loses focus) may result in a situation where those samples are never output to the
+speakers or received from the microphone which can in turn result in de-syncs.
+
+Do not call this in any callback.
+
+
+See Also
+--------
+ma_device_start()
+*/
+MA_API ma_result ma_device_stop(ma_device* pDevice);
+
+/*
+Determines whether or not the device is started.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose start state is being retrieved.
+
+
+Return Value
+------------
+True if the device is started, false otherwise.
+
+
+Thread Safety
+-------------
+Safe. If another thread calls `ma_device_start()` or `ma_device_stop()` at this same time as this function is called, there's a very small chance the return
+value will be out of sync.
+
+
+Callback Safety
+---------------
+Safe. This is implemented as a simple accessor.
+
+
+See Also
+--------
+ma_device_start()
+ma_device_stop()
+*/
+MA_API ma_bool32 ma_device_is_started(const ma_device* pDevice);
+
+
+/*
+Retrieves the state of the device.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose state is being retrieved.
+
+
+Return Value
+------------
+The current state of the device. The return value will be one of the following:
+
+    +-------------------------------+------------------------------------------------------------------------------+
+    | ma_device_state_uninitialized | Will only be returned if the device is in the middle of initialization.      |
+    +-------------------------------+------------------------------------------------------------------------------+
+    | ma_device_state_stopped       | The device is stopped. The initial state of the device after initialization. |
+    +-------------------------------+------------------------------------------------------------------------------+
+    | ma_device_state_started       | The device started and requesting and/or delivering audio data.              |
+    +-------------------------------+------------------------------------------------------------------------------+
+    | ma_device_state_starting      | The device is in the process of starting.                                    |
+    +-------------------------------+------------------------------------------------------------------------------+
+    | ma_device_state_stopping      | The device is in the process of stopping.                                    |
+    +-------------------------------+------------------------------------------------------------------------------+
+
+
+Thread Safety
+-------------
+Safe. This is implemented as a simple accessor. Note that if the device is started or stopped at the same time as this function is called,
+there's a possibility the return value could be out of sync. See remarks.
+
+
+Callback Safety
+---------------
+Safe. This is implemented as a simple accessor.
+
+
+Remarks
+-------
+The general flow of a devices state goes like this:
+
+    ```
+    ma_device_init()  -> ma_device_state_uninitialized -> ma_device_state_stopped
+    ma_device_start() -> ma_device_state_starting      -> ma_device_state_started
+    ma_device_stop()  -> ma_device_state_stopping      -> ma_device_state_stopped
+    ```
+
+When the state of the device is changed with `ma_device_start()` or `ma_device_stop()` at this same time as this function is called, the
+value returned by this function could potentially be out of sync. If this is significant to your program you need to implement your own
+synchronization.
+*/
+MA_API ma_device_state ma_device_get_state(const ma_device* pDevice);
+
+
+/*
+Performs post backend initialization routines for setting up internal data conversion.
+
+This should be called whenever the backend is initialized. The only time this should be called from
+outside of miniaudio is if you're implementing a custom backend, and you would only do it if you
+are reinitializing the backend due to rerouting or reinitializing for some reason.
+
+
+Parameters
+----------
+pDevice [in]
+    A pointer to the device.
+
+deviceType [in]
+    The type of the device that was just reinitialized.
+
+pPlaybackDescriptor [in]
+    The descriptor of the playback device containing the internal data format and buffer sizes.
+
+pPlaybackDescriptor [in]
+    The descriptor of the capture device containing the internal data format and buffer sizes.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other error otherwise.
+
+
+Thread Safety
+-------------
+Unsafe. This will be reinitializing internal data converters which may be in use by another thread.
+
+
+Callback Safety
+---------------
+Unsafe. This will be reinitializing internal data converters which may be in use by the callback.
+
+
+Remarks
+-------
+For a duplex device, you can call this for only one side of the system. This is why the deviceType
+is specified as a parameter rather than deriving it from the device.
+
+You do not need to call this manually unless you are doing a custom backend, in which case you need
+only do it if you're manually performing rerouting or reinitialization.
+*/
+MA_API ma_result ma_device_post_init(ma_device* pDevice, ma_device_type deviceType, const ma_device_descriptor* pPlaybackDescriptor, const ma_device_descriptor* pCaptureDescriptor);
+
+
+/*
+Sets the master volume factor for the device.
+
+The volume factor must be between 0 (silence) and 1 (full volume). Use `ma_device_set_master_volume_db()` to use decibel notation, where 0 is full volume and
+values less than 0 decreases the volume.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose volume is being set.
+
+volume (in)
+    The new volume factor. Must be >= 0.
+
+
+Return Value
+------------
+MA_SUCCESS if the volume was set successfully.
+MA_INVALID_ARGS if pDevice is NULL.
+MA_INVALID_ARGS if volume is negative.
+
+
+Thread Safety
+-------------
+Safe. This just sets a local member of the device object.
+
+
+Callback Safety
+---------------
+Safe. If you set the volume in the data callback, that data written to the output buffer will have the new volume applied.
+
+
+Remarks
+-------
+This applies the volume factor across all channels.
+
+This does not change the operating system's volume. It only affects the volume for the given `ma_device` object's audio stream.
+
+
+See Also
+--------
+ma_device_get_master_volume()
+ma_device_set_master_volume_db()
+ma_device_get_master_volume_db()
+*/
+MA_API ma_result ma_device_set_master_volume(ma_device* pDevice, float volume);
+
+/*
+Retrieves the master volume factor for the device.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose volume factor is being retrieved.
+
+pVolume (in)
+    A pointer to the variable that will receive the volume factor. The returned value will be in the range of [0, 1].
+
+
+Return Value
+------------
+MA_SUCCESS if successful.
+MA_INVALID_ARGS if pDevice is NULL.
+MA_INVALID_ARGS if pVolume is NULL.
+
+
+Thread Safety
+-------------
+Safe. This just a simple member retrieval.
+
+
+Callback Safety
+---------------
+Safe.
+
+
+Remarks
+-------
+If an error occurs, `*pVolume` will be set to 0.
+
+
+See Also
+--------
+ma_device_set_master_volume()
+ma_device_set_master_volume_gain_db()
+ma_device_get_master_volume_gain_db()
+*/
+MA_API ma_result ma_device_get_master_volume(ma_device* pDevice, float* pVolume);
+
+/*
+Sets the master volume for the device as gain in decibels.
+
+A gain of 0 is full volume, whereas a gain of < 0 will decrease the volume.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose gain is being set.
+
+gainDB (in)
+    The new volume as gain in decibels. Must be less than or equal to 0, where 0 is full volume and anything less than 0 decreases the volume.
+
+
+Return Value
+------------
+MA_SUCCESS if the volume was set successfully.
+MA_INVALID_ARGS if pDevice is NULL.
+MA_INVALID_ARGS if the gain is > 0.
+
+
+Thread Safety
+-------------
+Safe. This just sets a local member of the device object.
+
+
+Callback Safety
+---------------
+Safe. If you set the volume in the data callback, that data written to the output buffer will have the new volume applied.
+
+
+Remarks
+-------
+This applies the gain across all channels.
+
+This does not change the operating system's volume. It only affects the volume for the given `ma_device` object's audio stream.
+
+
+See Also
+--------
+ma_device_get_master_volume_gain_db()
+ma_device_set_master_volume()
+ma_device_get_master_volume()
+*/
+MA_API ma_result ma_device_set_master_volume_db(ma_device* pDevice, float gainDB);
+
+/*
+Retrieves the master gain in decibels.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to the device whose gain is being retrieved.
+
+pGainDB (in)
+    A pointer to the variable that will receive the gain in decibels. The returned value will be <= 0.
+
+
+Return Value
+------------
+MA_SUCCESS if successful.
+MA_INVALID_ARGS if pDevice is NULL.
+MA_INVALID_ARGS if pGainDB is NULL.
+
+
+Thread Safety
+-------------
+Safe. This just a simple member retrieval.
+
+
+Callback Safety
+---------------
+Safe.
+
+
+Remarks
+-------
+If an error occurs, `*pGainDB` will be set to 0.
+
+
+See Also
+--------
+ma_device_set_master_volume_db()
+ma_device_set_master_volume()
+ma_device_get_master_volume()
+*/
+MA_API ma_result ma_device_get_master_volume_db(ma_device* pDevice, float* pGainDB);
+
+
+/*
+Called from the data callback of asynchronous backends to allow miniaudio to process the data and fire the miniaudio data callback.
+
+
+Parameters
+----------
+pDevice (in)
+    A pointer to device whose processing the data callback.
+
+pOutput (out)
+    A pointer to the buffer that will receive the output PCM frame data. On a playback device this must not be NULL. On a duplex device
+    this can be NULL, in which case pInput must not be NULL.
+
+pInput (in)
+    A pointer to the buffer containing input PCM frame data. On a capture device this must not be NULL. On a duplex device this can be
+    NULL, in which case `pOutput` must not be NULL.
+
+frameCount (in)
+    The number of frames being processed.
+
+
+Return Value
+------------
+MA_SUCCESS if successful; any other result code otherwise.
+
+
+Thread Safety
+-------------
+This function should only ever be called from the internal data callback of the backend. It is safe to call this simultaneously between a
+playback and capture device in duplex setups.
+
+
+Callback Safety
+---------------
+Do not call this from the miniaudio data callback. It should only ever be called from the internal data callback of the backend.
+
+
+Remarks
+-------
+If both `pOutput` and `pInput` are NULL, and error will be returned. In duplex scenarios, both `pOutput` and `pInput` can be non-NULL, in
+which case `pInput` will be processed first, followed by `pOutput`.
+
+If you are implementing a custom backend, and that backend uses a callback for data delivery, you'll need to call this from inside that
+callback.
+*/
+MA_API ma_result ma_device_handle_backend_data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount);
+
+
+/*
+Calculates an appropriate buffer size from a descriptor, native sample rate and performance profile.
+
+This function is used by backends for helping determine an appropriately sized buffer to use with
+the device depending on the values of `periodSizeInFrames` and `periodSizeInMilliseconds` in the
+`pDescriptor` object. Since buffer size calculations based on time depends on the sample rate, a
+best guess at the device's native sample rate is also required which is where `nativeSampleRate`
+comes in. In addition, the performance profile is also needed for cases where both the period size
+in frames and milliseconds are both zero.
+
+
+Parameters
+----------
+pDescriptor (in)
+    A pointer to device descriptor whose `periodSizeInFrames` and `periodSizeInMilliseconds` members
+    will be used for the calculation of the buffer size.
+
+nativeSampleRate (in)
+    The device's native sample rate. This is only ever used when the `periodSizeInFrames` member of
+    `pDescriptor` is zero. In this case, `periodSizeInMilliseconds` will be used instead, in which
+    case a sample rate is required to convert to a size in frames.
+
+performanceProfile (in)
+    When both the `periodSizeInFrames` and `periodSizeInMilliseconds` members of `pDescriptor` are
+    zero, miniaudio will fall back to a buffer size based on the performance profile. The profile
+    to use for this calculation is determine by this parameter.
+
+
+Return Value
+------------
+The calculated buffer size in frames.
+
+
+Thread Safety
+-------------
+This is safe so long as nothing modifies `pDescriptor` at the same time. However, this function
+should only ever be called from within the backend's device initialization routine and therefore
+shouldn't have any multithreading concerns.
+
+
+Callback Safety
+---------------
+This is safe to call within the data callback, but there is no reason to ever do this.
+
+
+Remarks
+-------
+If `nativeSampleRate` is zero, this function will fall back to `pDescriptor->sampleRate`. If that
+is also zero, `MA_DEFAULT_SAMPLE_RATE` will be used instead.
+*/
+MA_API ma_uint32 ma_calculate_buffer_size_in_frames_from_descriptor(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile);
+
+
+
+/*
+Retrieves a friendly name for a backend.
+*/
+MA_API const char* ma_get_backend_name(ma_backend backend);
+
+/*
+Retrieves the backend enum from the given name.
+*/
+MA_API ma_result ma_get_backend_from_name(const char* pBackendName, ma_backend* pBackend);
+
+/*
+Determines whether or not the given backend is available by the compilation environment.
+*/
+MA_API ma_bool32 ma_is_backend_enabled(ma_backend backend);
+
+/*
+Retrieves compile-time enabled backends.
+
+
+Parameters
+----------
+pBackends (out, optional)
+    A pointer to the buffer that will receive the enabled backends. Set to NULL to retrieve the backend count. Setting
+    the capacity of the buffer to `MA_BUFFER_COUNT` will guarantee it's large enough for all backends.
+
+backendCap (in)
+    The capacity of the `pBackends` buffer.
+
+pBackendCount (out)
+    A pointer to the variable that will receive the enabled backend count.
+
+
+Return Value
+------------
+MA_SUCCESS if successful.
+MA_INVALID_ARGS if `pBackendCount` is NULL.
+MA_NO_SPACE if the capacity of `pBackends` is not large enough.
+
+If `MA_NO_SPACE` is returned, the `pBackends` buffer will be filled with `*pBackendCount` values.
+
+
+Thread Safety
+-------------
+Safe.
+
+
+Callback Safety
+---------------
+Safe.
+
+
+Remarks
+-------
+If you want to retrieve the number of backends so you can determine the capacity of `pBackends` buffer, you can call
+this function with `pBackends` set to NULL.
+
+This will also enumerate the null backend. If you don't want to include this you need to check for `ma_backend_null`
+when you enumerate over the returned backends and handle it appropriately. Alternatively, you can disable it at
+compile time with `MA_NO_NULL`.
+
+The returned backends are determined based on compile time settings, not the platform it's currently running on. For
+example, PulseAudio will be returned if it was enabled at compile time, even when the user doesn't actually have
+PulseAudio installed.
+
+
+Example 1
+---------
+The example below retrieves the enabled backend count using a fixed sized buffer allocated on the stack. The buffer is
+given a capacity of `MA_BACKEND_COUNT` which will guarantee it'll be large enough to store all available backends.
+Since `MA_BACKEND_COUNT` is always a relatively small value, this should be suitable for most scenarios.
+
+```
+ma_backend enabledBackends[MA_BACKEND_COUNT];
+size_t enabledBackendCount;
+
+result = ma_get_enabled_backends(enabledBackends, MA_BACKEND_COUNT, &enabledBackendCount);
+if (result != MA_SUCCESS) {
+    // Failed to retrieve enabled backends. Should never happen in this example since all inputs are valid.
+}
+```
+
+
+See Also
+--------
+ma_is_backend_enabled()
+*/
+MA_API ma_result ma_get_enabled_backends(ma_backend* pBackends, size_t backendCap, size_t* pBackendCount);
+
+/*
+Determines whether or not loopback mode is support by a backend.
+*/
+MA_API ma_bool32 ma_is_loopback_supported(ma_backend backend);
+
+#endif  /* MA_NO_DEVICE_IO */
+
+
+
+/************************************************************************************************************************************************************
+
+Utilities
+
+************************************************************************************************************************************************************/
+
+/*
+Calculates a buffer size in milliseconds from the specified number of frames and sample rate.
+*/
+MA_API ma_uint32 ma_calculate_buffer_size_in_milliseconds_from_frames(ma_uint32 bufferSizeInFrames, ma_uint32 sampleRate);
+
+/*
+Calculates a buffer size in frames from the specified number of milliseconds and sample rate.
+*/
+MA_API ma_uint32 ma_calculate_buffer_size_in_frames_from_milliseconds(ma_uint32 bufferSizeInMilliseconds, ma_uint32 sampleRate);
+
+/*
+Copies PCM frames from one buffer to another.
+*/
+MA_API void ma_copy_pcm_frames(void* dst, const void* src, ma_uint64 frameCount, ma_format format, ma_uint32 channels);
+
+/*
+Copies silent frames into the given buffer.
+
+Remarks
+-------
+For all formats except `ma_format_u8`, the output buffer will be filled with 0. For `ma_format_u8` it will be filled with 128. The reason for this is that it
+makes more sense for the purpose of mixing to initialize it to the center point.
+*/
+MA_API void ma_silence_pcm_frames(void* p, ma_uint64 frameCount, ma_format format, ma_uint32 channels);
+
+
+/*
+Offsets a pointer by the specified number of PCM frames.
+*/
+MA_API void* ma_offset_pcm_frames_ptr(void* p, ma_uint64 offsetInFrames, ma_format format, ma_uint32 channels);
+MA_API const void* ma_offset_pcm_frames_const_ptr(const void* p, ma_uint64 offsetInFrames, ma_format format, ma_uint32 channels);
+static MA_INLINE float* ma_offset_pcm_frames_ptr_f32(float* p, ma_uint64 offsetInFrames, ma_uint32 channels) { return (float*)ma_offset_pcm_frames_ptr((void*)p, offsetInFrames, ma_format_f32, channels); }
+static MA_INLINE const float* ma_offset_pcm_frames_const_ptr_f32(const float* p, ma_uint64 offsetInFrames, ma_uint32 channels) { return (const float*)ma_offset_pcm_frames_const_ptr((const void*)p, offsetInFrames, ma_format_f32, channels); }
+
+
+/*
+Clips samples.
+*/
+MA_API void ma_clip_samples_u8(ma_uint8* pDst, const ma_int16* pSrc, ma_uint64 count);
+MA_API void ma_clip_samples_s16(ma_int16* pDst, const ma_int32* pSrc, ma_uint64 count);
+MA_API void ma_clip_samples_s24(ma_uint8* pDst, const ma_int64* pSrc, ma_uint64 count);
+MA_API void ma_clip_samples_s32(ma_int32* pDst, const ma_int64* pSrc, ma_uint64 count);
+MA_API void ma_clip_samples_f32(float* pDst, const float* pSrc, ma_uint64 count);
+MA_API void ma_clip_pcm_frames(void* pDst, const void* pSrc, ma_uint64 frameCount, ma_format format, ma_uint32 channels);
+
+/*
+Helper for applying a volume factor to samples.
+
+Note that the source and destination buffers can be the same, in which case it'll perform the operation in-place.
+*/
+MA_API void ma_copy_and_apply_volume_factor_u8(ma_uint8* pSamplesOut, const ma_uint8* pSamplesIn, ma_uint64 sampleCount, float factor);
+MA_API void ma_copy_and_apply_volume_factor_s16(ma_int16* pSamplesOut, const ma_int16* pSamplesIn, ma_uint64 sampleCount, float factor);
+MA_API void ma_copy_and_apply_volume_factor_s24(void* pSamplesOut, const void* pSamplesIn, ma_uint64 sampleCount, float factor);
+MA_API void ma_copy_and_apply_volume_factor_s32(ma_int32* pSamplesOut, const ma_int32* pSamplesIn, ma_uint64 sampleCount, float factor);
+MA_API void ma_copy_and_apply_volume_factor_f32(float* pSamplesOut, const float* pSamplesIn, ma_uint64 sampleCount, float factor);
+
+MA_API void ma_apply_volume_factor_u8(ma_uint8* pSamples, ma_uint64 sampleCount, float factor);
+MA_API void ma_apply_volume_factor_s16(ma_int16* pSamples, ma_uint64 sampleCount, float factor);
+MA_API void ma_apply_volume_factor_s24(void* pSamples, ma_uint64 sampleCount, float factor);
+MA_API void ma_apply_volume_factor_s32(ma_int32* pSamples, ma_uint64 sampleCount, float factor);
+MA_API void ma_apply_volume_factor_f32(float* pSamples, ma_uint64 sampleCount, float factor);
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_u8(ma_uint8* pFramesOut, const ma_uint8* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s16(ma_int16* pFramesOut, const ma_int16* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s24(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s32(ma_int32* pFramesOut, const ma_int32* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float factor);
+
+MA_API void ma_apply_volume_factor_pcm_frames_u8(ma_uint8* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_apply_volume_factor_pcm_frames_s16(ma_int16* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_apply_volume_factor_pcm_frames_s24(void* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_apply_volume_factor_pcm_frames_s32(ma_int32* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_apply_volume_factor_pcm_frames_f32(float* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor);
+MA_API void ma_apply_volume_factor_pcm_frames(void* pFrames, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float factor);
+
+MA_API void ma_copy_and_apply_volume_factor_per_channel_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float* pChannelGains);
+
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_u8(ma_uint8* pDst, const ma_int16* pSrc, ma_uint64 count, float volume);
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s16(ma_int16* pDst, const ma_int32* pSrc, ma_uint64 count, float volume);
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s24(ma_uint8* pDst, const ma_int64* pSrc, ma_uint64 count, float volume);
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s32(ma_int32* pDst, const ma_int64* pSrc, ma_uint64 count, float volume);
+MA_API void ma_copy_and_apply_volume_and_clip_samples_f32(float* pDst, const float* pSrc, ma_uint64 count, float volume);
+MA_API void ma_copy_and_apply_volume_and_clip_pcm_frames(void* pDst, const void* pSrc, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float volume);
+
+
+/*
+Helper for converting a linear factor to gain in decibels.
+*/
+MA_API float ma_volume_linear_to_db(float factor);
+
+/*
+Helper for converting gain in decibels to a linear factor.
+*/
+MA_API float ma_volume_db_to_linear(float gain);
+
+
+/*
+Mixes the specified number of frames in floating point format with a volume factor.
+
+This will run on an optimized path when the volume is equal to 1.
+*/
+MA_API ma_result ma_mix_pcm_frames_f32(float* pDst, const float* pSrc, ma_uint64 frameCount, ma_uint32 channels, float volume);
+
+
+
+
+/************************************************************************************************************************************************************
+
+VFS
+===
+
+The VFS object (virtual file system) is what's used to customize file access. This is useful in cases where stdio FILE* based APIs may not be entirely
+appropriate for a given situation.
+
+************************************************************************************************************************************************************/
+typedef void      ma_vfs;
+typedef ma_handle ma_vfs_file;
+
+typedef enum
+{
+    MA_OPEN_MODE_READ  = 0x00000001,
+    MA_OPEN_MODE_WRITE = 0x00000002
+} ma_open_mode_flags;
+
+typedef enum
+{
+    ma_seek_origin_start,
+    ma_seek_origin_current,
+    ma_seek_origin_end  /* Not used by decoders. */
+} ma_seek_origin;
+
+typedef struct
+{
+    ma_uint64 sizeInBytes;
+} ma_file_info;
+
+typedef struct
+{
+    ma_result (* onOpen) (ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile);
+    ma_result (* onOpenW)(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile);
+    ma_result (* onClose)(ma_vfs* pVFS, ma_vfs_file file);
+    ma_result (* onRead) (ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead);
+    ma_result (* onWrite)(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten);
+    ma_result (* onSeek) (ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin);
+    ma_result (* onTell) (ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor);
+    ma_result (* onInfo) (ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo);
+} ma_vfs_callbacks;
+
+MA_API ma_result ma_vfs_open(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile);
+MA_API ma_result ma_vfs_open_w(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile);
+MA_API ma_result ma_vfs_close(ma_vfs* pVFS, ma_vfs_file file);
+MA_API ma_result ma_vfs_read(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead);
+MA_API ma_result ma_vfs_write(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten);
+MA_API ma_result ma_vfs_seek(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin);
+MA_API ma_result ma_vfs_tell(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor);
+MA_API ma_result ma_vfs_info(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo);
+MA_API ma_result ma_vfs_open_and_read_file(ma_vfs* pVFS, const char* pFilePath, void** ppData, size_t* pSize, const ma_allocation_callbacks* pAllocationCallbacks);
+
+typedef struct
+{
+    ma_vfs_callbacks cb;
+    ma_allocation_callbacks allocationCallbacks;    /* Only used for the wchar_t version of open() on non-Windows platforms. */
+} ma_default_vfs;
+
+MA_API ma_result ma_default_vfs_init(ma_default_vfs* pVFS, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+
+typedef ma_result (* ma_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead);
+typedef ma_result (* ma_seek_proc)(void* pUserData, ma_int64 offset, ma_seek_origin origin);
+typedef ma_result (* ma_tell_proc)(void* pUserData, ma_int64* pCursor);
+
+
+
+#if !defined(MA_NO_DECODING) || !defined(MA_NO_ENCODING)
+typedef enum
+{
+    ma_encoding_format_unknown = 0,
+    ma_encoding_format_wav,
+    ma_encoding_format_flac,
+    ma_encoding_format_mp3,
+    ma_encoding_format_vorbis
+} ma_encoding_format;
+#endif
+
+/************************************************************************************************************************************************************
+
+Decoding
+========
+
+Decoders are independent of the main device API. Decoding APIs can be called freely inside the device's data callback, but they are not thread safe unless
+you do your own synchronization.
+
+************************************************************************************************************************************************************/
+#ifndef MA_NO_DECODING
+typedef struct ma_decoder ma_decoder;
+
+
+typedef struct
+{
+    ma_format preferredFormat;
+    ma_uint32 seekPointCount;   /* Set to > 0 to generate a seektable if the decoding backend supports it. */
+} ma_decoding_backend_config;
+
+MA_API ma_decoding_backend_config ma_decoding_backend_config_init(ma_format preferredFormat, ma_uint32 seekPointCount);
+
+
+typedef struct
+{
+    ma_result (* onInit      )(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend);
+    ma_result (* onInitFile  )(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend);               /* Optional. */
+    ma_result (* onInitFileW )(void* pUserData, const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend);            /* Optional. */
+    ma_result (* onInitMemory)(void* pUserData, const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend);  /* Optional. */
+    void      (* onUninit    )(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks);
+} ma_decoding_backend_vtable;
+
+
+typedef ma_result (* ma_decoder_read_proc)(ma_decoder* pDecoder, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead);         /* Returns the number of bytes read. */
+typedef ma_result (* ma_decoder_seek_proc)(ma_decoder* pDecoder, ma_int64 byteOffset, ma_seek_origin origin);
+typedef ma_result (* ma_decoder_tell_proc)(ma_decoder* pDecoder, ma_int64* pCursor);
+
+typedef struct
+{
+    ma_format format;      /* Set to 0 or ma_format_unknown to use the stream's internal format. */
+    ma_uint32 channels;    /* Set to 0 to use the stream's internal channels. */
+    ma_uint32 sampleRate;  /* Set to 0 to use the stream's internal sample rate. */
+    ma_channel* pChannelMap;
+    ma_channel_mix_mode channelMixMode;
+    ma_dither_mode ditherMode;
+    ma_resampler_config resampling;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_encoding_format encodingFormat;
+    ma_uint32 seekPointCount;   /* When set to > 0, specifies the number of seek points to use for the generation of a seek table. Not all decoding backends support this. */
+    ma_decoding_backend_vtable** ppCustomBackendVTables;
+    ma_uint32 customBackendCount;
+    void* pCustomBackendUserData;
+} ma_decoder_config;
+
+struct ma_decoder
+{
+    ma_data_source_base ds;
+    ma_data_source* pBackend;                   /* The decoding backend we'll be pulling data from. */
+    const ma_decoding_backend_vtable* pBackendVTable; /* The vtable for the decoding backend. This needs to be stored so we can access the onUninit() callback. */
+    void* pBackendUserData;
+    ma_decoder_read_proc onRead;
+    ma_decoder_seek_proc onSeek;
+    ma_decoder_tell_proc onTell;
+    void* pUserData;
+    ma_uint64 readPointerInPCMFrames;      /* In output sample rate. Used for keeping track of how many frames are available for decoding. */
+    ma_format outputFormat;
+    ma_uint32 outputChannels;
+    ma_uint32 outputSampleRate;
+    ma_data_converter converter;    /* Data conversion is achieved by running frames through this. */
+    void* pInputCache;              /* In input format. Can be null if it's not needed. */
+    ma_uint64 inputCacheCap;        /* The capacity of the input cache. */
+    ma_uint64 inputCacheConsumed;   /* The number of frames that have been consumed in the cache. Used for determining the next valid frame. */
+    ma_uint64 inputCacheRemaining;  /* The number of valid frames remaining in the cahce. */
+    ma_allocation_callbacks allocationCallbacks;
+    union
+    {
+        struct
+        {
+            ma_vfs* pVFS;
+            ma_vfs_file file;
+        } vfs;
+        struct
+        {
+            const ma_uint8* pData;
+            size_t dataSize;
+            size_t currentReadPos;
+        } memory;               /* Only used for decoders that were opened against a block of memory. */
+    } data;
+};
+
+MA_API ma_decoder_config ma_decoder_config_init(ma_format outputFormat, ma_uint32 outputChannels, ma_uint32 outputSampleRate);
+MA_API ma_decoder_config ma_decoder_config_init_default(void);
+
+MA_API ma_result ma_decoder_init(ma_decoder_read_proc onRead, ma_decoder_seek_proc onSeek, void* pUserData, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+MA_API ma_result ma_decoder_init_memory(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+MA_API ma_result ma_decoder_init_vfs(ma_vfs* pVFS, const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+MA_API ma_result ma_decoder_init_vfs_w(ma_vfs* pVFS, const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+MA_API ma_result ma_decoder_init_file(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+MA_API ma_result ma_decoder_init_file_w(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder);
+
+/*
+Uninitializes a decoder.
+*/
+MA_API ma_result ma_decoder_uninit(ma_decoder* pDecoder);
+
+/*
+Reads PCM frames from the given decoder.
+
+This is not thread safe without your own synchronization.
+*/
+MA_API ma_result ma_decoder_read_pcm_frames(ma_decoder* pDecoder, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+
+/*
+Seeks to a PCM frame based on it's absolute index.
+
+This is not thread safe without your own synchronization.
+*/
+MA_API ma_result ma_decoder_seek_to_pcm_frame(ma_decoder* pDecoder, ma_uint64 frameIndex);
+
+/*
+Retrieves the decoder's output data format.
+*/
+MA_API ma_result ma_decoder_get_data_format(ma_decoder* pDecoder, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+
+/*
+Retrieves the current position of the read cursor in PCM frames.
+*/
+MA_API ma_result ma_decoder_get_cursor_in_pcm_frames(ma_decoder* pDecoder, ma_uint64* pCursor);
+
+/*
+Retrieves the length of the decoder in PCM frames.
+
+Do not call this on streams of an undefined length, such as internet radio.
+
+If the length is unknown or an error occurs, 0 will be returned.
+
+This will always return 0 for Vorbis decoders. This is due to a limitation with stb_vorbis in push mode which is what miniaudio
+uses internally.
+
+For MP3's, this will decode the entire file. Do not call this in time critical scenarios.
+
+This function is not thread safe without your own synchronization.
+*/
+MA_API ma_result ma_decoder_get_length_in_pcm_frames(ma_decoder* pDecoder, ma_uint64* pLength);
+
+/*
+Retrieves the number of frames that can be read before reaching the end.
+
+This calls `ma_decoder_get_length_in_pcm_frames()` so you need to be aware of the rules for that function, in
+particular ensuring you do not call it on streams of an undefined length, such as internet radio.
+
+If the total length of the decoder cannot be retrieved, such as with Vorbis decoders, `MA_NOT_IMPLEMENTED` will be
+returned.
+*/
+MA_API ma_result ma_decoder_get_available_frames(ma_decoder* pDecoder, ma_uint64* pAvailableFrames);
+
+/*
+Helper for opening and decoding a file into a heap allocated block of memory. Free the returned pointer with ma_free(). On input,
+pConfig should be set to what you want. On output it will be set to what you got.
+*/
+MA_API ma_result ma_decode_from_vfs(ma_vfs* pVFS, const char* pFilePath, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut);
+MA_API ma_result ma_decode_file(const char* pFilePath, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut);
+MA_API ma_result ma_decode_memory(const void* pData, size_t dataSize, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut);
+
+#endif  /* MA_NO_DECODING */
+
+
+/************************************************************************************************************************************************************
+
+Encoding
+========
+
+Encoders do not perform any format conversion for you. If your target format does not support the format, and error will be returned.
+
+************************************************************************************************************************************************************/
+#ifndef MA_NO_ENCODING
+typedef struct ma_encoder ma_encoder;
+
+typedef ma_result (* ma_encoder_write_proc)           (ma_encoder* pEncoder, const void* pBufferIn, size_t bytesToWrite, size_t* pBytesWritten);
+typedef ma_result (* ma_encoder_seek_proc)            (ma_encoder* pEncoder, ma_int64 offset, ma_seek_origin origin);
+typedef ma_result (* ma_encoder_init_proc)            (ma_encoder* pEncoder);
+typedef void      (* ma_encoder_uninit_proc)          (ma_encoder* pEncoder);
+typedef ma_result (* ma_encoder_write_pcm_frames_proc)(ma_encoder* pEncoder, const void* pFramesIn, ma_uint64 frameCount, ma_uint64* pFramesWritten);
+
+typedef struct
+{
+    ma_encoding_format encodingFormat;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_allocation_callbacks allocationCallbacks;
+} ma_encoder_config;
+
+MA_API ma_encoder_config ma_encoder_config_init(ma_encoding_format encodingFormat, ma_format format, ma_uint32 channels, ma_uint32 sampleRate);
+
+struct ma_encoder
+{
+    ma_encoder_config config;
+    ma_encoder_write_proc onWrite;
+    ma_encoder_seek_proc onSeek;
+    ma_encoder_init_proc onInit;
+    ma_encoder_uninit_proc onUninit;
+    ma_encoder_write_pcm_frames_proc onWritePCMFrames;
+    void* pUserData;
+    void* pInternalEncoder;
+    union
+    {
+        struct
+        {
+            ma_vfs* pVFS;
+            ma_vfs_file file;
+        } vfs;
+    } data;
+};
+
+MA_API ma_result ma_encoder_init(ma_encoder_write_proc onWrite, ma_encoder_seek_proc onSeek, void* pUserData, const ma_encoder_config* pConfig, ma_encoder* pEncoder);
+MA_API ma_result ma_encoder_init_vfs(ma_vfs* pVFS, const char* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder);
+MA_API ma_result ma_encoder_init_vfs_w(ma_vfs* pVFS, const wchar_t* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder);
+MA_API ma_result ma_encoder_init_file(const char* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder);
+MA_API ma_result ma_encoder_init_file_w(const wchar_t* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder);
+MA_API void ma_encoder_uninit(ma_encoder* pEncoder);
+MA_API ma_result ma_encoder_write_pcm_frames(ma_encoder* pEncoder, const void* pFramesIn, ma_uint64 frameCount, ma_uint64* pFramesWritten);
+
+#endif /* MA_NO_ENCODING */
+
+
+/************************************************************************************************************************************************************
+
+Generation
+
+************************************************************************************************************************************************************/
+#ifndef MA_NO_GENERATION
+typedef enum
+{
+    ma_waveform_type_sine,
+    ma_waveform_type_square,
+    ma_waveform_type_triangle,
+    ma_waveform_type_sawtooth
+} ma_waveform_type;
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_waveform_type type;
+    double amplitude;
+    double frequency;
+} ma_waveform_config;
+
+MA_API ma_waveform_config ma_waveform_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_waveform_type type, double amplitude, double frequency);
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_waveform_config config;
+    double advance;
+    double time;
+} ma_waveform;
+
+MA_API ma_result ma_waveform_init(const ma_waveform_config* pConfig, ma_waveform* pWaveform);
+MA_API void ma_waveform_uninit(ma_waveform* pWaveform);
+MA_API ma_result ma_waveform_read_pcm_frames(ma_waveform* pWaveform, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_waveform_seek_to_pcm_frame(ma_waveform* pWaveform, ma_uint64 frameIndex);
+MA_API ma_result ma_waveform_set_amplitude(ma_waveform* pWaveform, double amplitude);
+MA_API ma_result ma_waveform_set_frequency(ma_waveform* pWaveform, double frequency);
+MA_API ma_result ma_waveform_set_type(ma_waveform* pWaveform, ma_waveform_type type);
+MA_API ma_result ma_waveform_set_sample_rate(ma_waveform* pWaveform, ma_uint32 sampleRate);
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    double dutyCycle;
+    double amplitude;
+    double frequency;
+} ma_pulsewave_config;
+
+MA_API ma_pulsewave_config ma_pulsewave_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double dutyCycle, double amplitude, double frequency);
+
+typedef struct
+{
+    ma_waveform waveform;
+    ma_pulsewave_config config;
+} ma_pulsewave;
+
+MA_API ma_result ma_pulsewave_init(const ma_pulsewave_config* pConfig, ma_pulsewave* pWaveform);
+MA_API void ma_pulsewave_uninit(ma_pulsewave* pWaveform);
+MA_API ma_result ma_pulsewave_read_pcm_frames(ma_pulsewave* pWaveform, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_pulsewave_seek_to_pcm_frame(ma_pulsewave* pWaveform, ma_uint64 frameIndex);
+MA_API ma_result ma_pulsewave_set_amplitude(ma_pulsewave* pWaveform, double amplitude);
+MA_API ma_result ma_pulsewave_set_frequency(ma_pulsewave* pWaveform, double frequency);
+MA_API ma_result ma_pulsewave_set_sample_rate(ma_pulsewave* pWaveform, ma_uint32 sampleRate);
+MA_API ma_result ma_pulsewave_set_duty_cycle(ma_pulsewave* pWaveform, double dutyCycle);
+
+typedef enum
+{
+    ma_noise_type_white,
+    ma_noise_type_pink,
+    ma_noise_type_brownian
+} ma_noise_type;
+
+
+typedef struct
+{
+    ma_format format;
+    ma_uint32 channels;
+    ma_noise_type type;
+    ma_int32 seed;
+    double amplitude;
+    ma_bool32 duplicateChannels;
+} ma_noise_config;
+
+MA_API ma_noise_config ma_noise_config_init(ma_format format, ma_uint32 channels, ma_noise_type type, ma_int32 seed, double amplitude);
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_noise_config config;
+    ma_lcg lcg;
+    union
+    {
+        struct
+        {
+            double** bin;
+            double* accumulation;
+            ma_uint32* counter;
+        } pink;
+        struct
+        {
+            double* accumulation;
+        } brownian;
+    } state;
+
+    /* Memory management. */
+    void* _pHeap;
+    ma_bool32 _ownsHeap;
+} ma_noise;
+
+MA_API ma_result ma_noise_get_heap_size(const ma_noise_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_noise_init_preallocated(const ma_noise_config* pConfig, void* pHeap, ma_noise* pNoise);
+MA_API ma_result ma_noise_init(const ma_noise_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_noise* pNoise);
+MA_API void ma_noise_uninit(ma_noise* pNoise, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_noise_read_pcm_frames(ma_noise* pNoise, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_noise_set_amplitude(ma_noise* pNoise, double amplitude);
+MA_API ma_result ma_noise_set_seed(ma_noise* pNoise, ma_int32 seed);
+MA_API ma_result ma_noise_set_type(ma_noise* pNoise, ma_noise_type type);
+
+#endif  /* MA_NO_GENERATION */
+
+
+
+/************************************************************************************************************************************************************
+
+Resource Manager
+
+************************************************************************************************************************************************************/
+/* The resource manager cannot be enabled if there is no decoder. */
+#if !defined(MA_NO_RESOURCE_MANAGER) && defined(MA_NO_DECODING)
+#define MA_NO_RESOURCE_MANAGER
+#endif
+
+#ifndef MA_NO_RESOURCE_MANAGER
+typedef struct ma_resource_manager                  ma_resource_manager;
+typedef struct ma_resource_manager_data_buffer_node ma_resource_manager_data_buffer_node;
+typedef struct ma_resource_manager_data_buffer      ma_resource_manager_data_buffer;
+typedef struct ma_resource_manager_data_stream      ma_resource_manager_data_stream;
+typedef struct ma_resource_manager_data_source      ma_resource_manager_data_source;
+
+typedef enum
+{
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM         = 0x00000001,   /* When set, does not load the entire data source in memory. Disk I/O will happen on job threads. */
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE         = 0x00000002,   /* Decode data before storing in memory. When set, decoding is done at the resource manager level rather than the mixing thread. Results in faster mixing, but higher memory usage. */
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC          = 0x00000004,   /* When set, the resource manager will load the data source asynchronously. */
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT      = 0x00000008,   /* When set, waits for initialization of the underlying data source before returning from ma_resource_manager_data_source_init(). */
+    MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH = 0x00000010    /* Gives the resource manager a hint that the length of the data source is unknown and calling `ma_data_source_get_length_in_pcm_frames()` should be avoided. */
+} ma_resource_manager_data_source_flags;
+
+
+/*
+Pipeline notifications used by the resource manager. Made up of both an async notification and a fence, both of which are optional.
+*/
+typedef struct
+{
+    ma_async_notification* pNotification;
+    ma_fence* pFence;
+} ma_resource_manager_pipeline_stage_notification;
+
+typedef struct
+{
+    ma_resource_manager_pipeline_stage_notification init;    /* Initialization of the decoder. */
+    ma_resource_manager_pipeline_stage_notification done;    /* Decoding fully completed. */
+} ma_resource_manager_pipeline_notifications;
+
+MA_API ma_resource_manager_pipeline_notifications ma_resource_manager_pipeline_notifications_init(void);
+
+
+
+/* BEGIN BACKWARDS COMPATIBILITY */
+/* TODO: Remove this block in version 0.12. */
+#if 1
+#define ma_resource_manager_job                         ma_job
+#define ma_resource_manager_job_init                    ma_job_init
+#define MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_FLAG_NON_BLOCKING MA_JOB_QUEUE_FLAG_NON_BLOCKING
+#define ma_resource_manager_job_queue_config            ma_job_queue_config
+#define ma_resource_manager_job_queue_config_init       ma_job_queue_config_init
+#define ma_resource_manager_job_queue                   ma_job_queue
+#define ma_resource_manager_job_queue_get_heap_size     ma_job_queue_get_heap_size
+#define ma_resource_manager_job_queue_init_preallocated ma_job_queue_init_preallocated
+#define ma_resource_manager_job_queue_init              ma_job_queue_init
+#define ma_resource_manager_job_queue_uninit            ma_job_queue_uninit
+#define ma_resource_manager_job_queue_post              ma_job_queue_post
+#define ma_resource_manager_job_queue_next              ma_job_queue_next
+#endif
+/* END BACKWARDS COMPATIBILITY */
+
+
+
+
+/* Maximum job thread count will be restricted to this, but this may be removed later and replaced with a heap allocation thereby removing any limitation. */
+#ifndef MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT
+#define MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT    64
+#endif
+
+typedef enum
+{
+    /* Indicates ma_resource_manager_next_job() should not block. Only valid when the job thread count is 0. */
+    MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING = 0x00000001,
+
+    /* Disables any kind of multithreading. Implicitly enables MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING. */
+    MA_RESOURCE_MANAGER_FLAG_NO_THREADING = 0x00000002
+} ma_resource_manager_flags;
+
+typedef struct
+{
+    const char* pFilePath;
+    const wchar_t* pFilePathW;
+    const ma_resource_manager_pipeline_notifications* pNotifications;
+    ma_uint64 initialSeekPointInPCMFrames;
+    ma_uint64 rangeBegInPCMFrames;
+    ma_uint64 rangeEndInPCMFrames;
+    ma_uint64 loopPointBegInPCMFrames;
+    ma_uint64 loopPointEndInPCMFrames;
+    ma_bool32 isLooping;
+    ma_uint32 flags;
+} ma_resource_manager_data_source_config;
+
+MA_API ma_resource_manager_data_source_config ma_resource_manager_data_source_config_init(void);
+
+
+typedef enum
+{
+    ma_resource_manager_data_supply_type_unknown = 0,   /* Used for determining whether or the data supply has been initialized. */
+    ma_resource_manager_data_supply_type_encoded,       /* Data supply is an encoded buffer. Connector is ma_decoder. */
+    ma_resource_manager_data_supply_type_decoded,       /* Data supply is a decoded buffer. Connector is ma_audio_buffer. */
+    ma_resource_manager_data_supply_type_decoded_paged  /* Data supply is a linked list of decoded buffers. Connector is ma_paged_audio_buffer. */
+} ma_resource_manager_data_supply_type;
+
+typedef struct
+{
+    MA_ATOMIC(4, ma_resource_manager_data_supply_type) type;    /* Read and written from different threads so needs to be accessed atomically. */
+    union
+    {
+        struct
+        {
+            const void* pData;
+            size_t sizeInBytes;
+        } encoded;
+        struct
+        {
+            const void* pData;
+            ma_uint64 totalFrameCount;
+            ma_uint64 decodedFrameCount;
+            ma_format format;
+            ma_uint32 channels;
+            ma_uint32 sampleRate;
+        } decoded;
+        struct
+        {
+            ma_paged_audio_buffer_data data;
+            ma_uint64 decodedFrameCount;
+            ma_uint32 sampleRate;
+        } decodedPaged;
+    } backend;
+} ma_resource_manager_data_supply;
+
+struct ma_resource_manager_data_buffer_node
+{
+    ma_uint32 hashedName32;                         /* The hashed name. This is the key. */
+    ma_uint32 refCount;
+    MA_ATOMIC(4, ma_result) result;                 /* Result from asynchronous loading. When loading set to MA_BUSY. When fully loaded set to MA_SUCCESS. When deleting set to MA_UNAVAILABLE. */
+    MA_ATOMIC(4, ma_uint32) executionCounter;       /* For allocating execution orders for jobs. */
+    MA_ATOMIC(4, ma_uint32) executionPointer;       /* For managing the order of execution for asynchronous jobs relating to this object. Incremented as jobs complete processing. */
+    ma_bool32 isDataOwnedByResourceManager;         /* Set to true when the underlying data buffer was allocated the resource manager. Set to false if it is owned by the application (via ma_resource_manager_register_*()). */
+    ma_resource_manager_data_supply data;
+    ma_resource_manager_data_buffer_node* pParent;
+    ma_resource_manager_data_buffer_node* pChildLo;
+    ma_resource_manager_data_buffer_node* pChildHi;
+};
+
+struct ma_resource_manager_data_buffer
+{
+    ma_data_source_base ds;                         /* Base data source. A data buffer is a data source. */
+    ma_resource_manager* pResourceManager;          /* A pointer to the resource manager that owns this buffer. */
+    ma_resource_manager_data_buffer_node* pNode;    /* The data node. This is reference counted and is what supplies the data. */
+    ma_uint32 flags;                                /* The flags that were passed used to initialize the buffer. */
+    MA_ATOMIC(4, ma_uint32) executionCounter;       /* For allocating execution orders for jobs. */
+    MA_ATOMIC(4, ma_uint32) executionPointer;       /* For managing the order of execution for asynchronous jobs relating to this object. Incremented as jobs complete processing. */
+    ma_uint64 seekTargetInPCMFrames;                /* Only updated by the public API. Never written nor read from the job thread. */
+    ma_bool32 seekToCursorOnNextRead;               /* On the next read we need to seek to the frame cursor. */
+    MA_ATOMIC(4, ma_result) result;                 /* Keeps track of a result of decoding. Set to MA_BUSY while the buffer is still loading. Set to MA_SUCCESS when loading is finished successfully. Otherwise set to some other code. */
+    MA_ATOMIC(4, ma_bool32) isLooping;              /* Can be read and written by different threads at the same time. Must be used atomically. */
+    ma_atomic_bool32 isConnectorInitialized;        /* Used for asynchronous loading to ensure we don't try to initialize the connector multiple times while waiting for the node to fully load. */
+    union
+    {
+        ma_decoder decoder;                 /* Supply type is ma_resource_manager_data_supply_type_encoded */
+        ma_audio_buffer buffer;             /* Supply type is ma_resource_manager_data_supply_type_decoded */
+        ma_paged_audio_buffer pagedBuffer;  /* Supply type is ma_resource_manager_data_supply_type_decoded_paged */
+    } connector;    /* Connects this object to the node's data supply. */
+};
+
+struct ma_resource_manager_data_stream
+{
+    ma_data_source_base ds;                     /* Base data source. A data stream is a data source. */
+    ma_resource_manager* pResourceManager;      /* A pointer to the resource manager that owns this data stream. */
+    ma_uint32 flags;                            /* The flags that were passed used to initialize the stream. */
+    ma_decoder decoder;                         /* Used for filling pages with data. This is only ever accessed by the job thread. The public API should never touch this. */
+    ma_bool32 isDecoderInitialized;             /* Required for determining whether or not the decoder should be uninitialized in MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM. */
+    ma_uint64 totalLengthInPCMFrames;           /* This is calculated when first loaded by the MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM. */
+    ma_uint32 relativeCursor;                   /* The playback cursor, relative to the current page. Only ever accessed by the public API. Never accessed by the job thread. */
+    MA_ATOMIC(8, ma_uint64) absoluteCursor;     /* The playback cursor, in absolute position starting from the start of the file. */
+    ma_uint32 currentPageIndex;                 /* Toggles between 0 and 1. Index 0 is the first half of pPageData. Index 1 is the second half. Only ever accessed by the public API. Never accessed by the job thread. */
+    MA_ATOMIC(4, ma_uint32) executionCounter;   /* For allocating execution orders for jobs. */
+    MA_ATOMIC(4, ma_uint32) executionPointer;   /* For managing the order of execution for asynchronous jobs relating to this object. Incremented as jobs complete processing. */
+
+    /* Written by the public API, read by the job thread. */
+    MA_ATOMIC(4, ma_bool32) isLooping;          /* Whether or not the stream is looping. It's important to set the looping flag at the data stream level for smooth loop transitions. */
+
+    /* Written by the job thread, read by the public API. */
+    void* pPageData;                            /* Buffer containing the decoded data of each page. Allocated once at initialization time. */
+    MA_ATOMIC(4, ma_uint32) pageFrameCount[2];  /* The number of valid PCM frames in each page. Used to determine the last valid frame. */
+
+    /* Written and read by both the public API and the job thread. These must be atomic. */
+    MA_ATOMIC(4, ma_result) result;             /* Result from asynchronous loading. When loading set to MA_BUSY. When initialized set to MA_SUCCESS. When deleting set to MA_UNAVAILABLE. If an error occurs when loading, set to an error code. */
+    MA_ATOMIC(4, ma_bool32) isDecoderAtEnd;     /* Whether or not the decoder has reached the end. */
+    MA_ATOMIC(4, ma_bool32) isPageValid[2];     /* Booleans to indicate whether or not a page is valid. Set to false by the public API, set to true by the job thread. Set to false as the pages are consumed, true when they are filled. */
+    MA_ATOMIC(4, ma_bool32) seekCounter;        /* When 0, no seeking is being performed. When > 0, a seek is being performed and reading should be delayed with MA_BUSY. */
+};
+
+struct ma_resource_manager_data_source
+{
+    union
+    {
+        ma_resource_manager_data_buffer buffer;
+        ma_resource_manager_data_stream stream;
+    } backend;  /* Must be the first item because we need the first item to be the data source callbacks for the buffer or stream. */
+
+    ma_uint32 flags;                          /* The flags that were passed in to ma_resource_manager_data_source_init(). */
+    MA_ATOMIC(4, ma_uint32) executionCounter;     /* For allocating execution orders for jobs. */
+    MA_ATOMIC(4, ma_uint32) executionPointer;     /* For managing the order of execution for asynchronous jobs relating to this object. Incremented as jobs complete processing. */
+};
+
+typedef struct
+{
+    ma_allocation_callbacks allocationCallbacks;
+    ma_log* pLog;
+    ma_format decodedFormat;        /* The decoded format to use. Set to ma_format_unknown (default) to use the file's native format. */
+    ma_uint32 decodedChannels;      /* The decoded channel count to use. Set to 0 (default) to use the file's native channel count. */
+    ma_uint32 decodedSampleRate;    /* the decoded sample rate to use. Set to 0 (default) to use the file's native sample rate. */
+    ma_uint32 jobThreadCount;       /* Set to 0 if you want to self-manage your job threads. Defaults to 1. */
+    size_t jobThreadStackSize;
+    ma_uint32 jobQueueCapacity;     /* The maximum number of jobs that can fit in the queue at a time. Defaults to MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_CAPACITY. Cannot be zero. */
+    ma_uint32 flags;
+    ma_vfs* pVFS;                   /* Can be NULL in which case defaults will be used. */
+    ma_decoding_backend_vtable** ppCustomDecodingBackendVTables;
+    ma_uint32 customDecodingBackendCount;
+    void* pCustomDecodingBackendUserData;
+} ma_resource_manager_config;
+
+MA_API ma_resource_manager_config ma_resource_manager_config_init(void);
+
+struct ma_resource_manager
+{
+    ma_resource_manager_config config;
+    ma_resource_manager_data_buffer_node* pRootDataBufferNode;      /* The root buffer in the binary tree. */
+#ifndef MA_NO_THREADING
+    ma_mutex dataBufferBSTLock;                                     /* For synchronizing access to the data buffer binary tree. */
+    ma_thread jobThreads[MA_RESOURCE_MANAGER_MAX_JOB_THREAD_COUNT]; /* The threads for executing jobs. */
+#endif
+    ma_job_queue jobQueue;                                          /* Multi-consumer, multi-producer job queue for managing jobs for asynchronous decoding and streaming. */
+    ma_default_vfs defaultVFS;                                      /* Only used if a custom VFS is not specified. */
+    ma_log log;                                                     /* Only used if no log was specified in the config. */
+};
+
+/* Init. */
+MA_API ma_result ma_resource_manager_init(const ma_resource_manager_config* pConfig, ma_resource_manager* pResourceManager);
+MA_API void ma_resource_manager_uninit(ma_resource_manager* pResourceManager);
+MA_API ma_log* ma_resource_manager_get_log(ma_resource_manager* pResourceManager);
+
+/* Registration. */
+MA_API ma_result ma_resource_manager_register_file(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags);
+MA_API ma_result ma_resource_manager_register_file_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags);
+MA_API ma_result ma_resource_manager_register_decoded_data(ma_resource_manager* pResourceManager, const char* pName, const void* pData, ma_uint64 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate);  /* Does not copy. Increments the reference count if already exists and returns MA_SUCCESS. */
+MA_API ma_result ma_resource_manager_register_decoded_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName, const void* pData, ma_uint64 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate);
+MA_API ma_result ma_resource_manager_register_encoded_data(ma_resource_manager* pResourceManager, const char* pName, const void* pData, size_t sizeInBytes);    /* Does not copy. Increments the reference count if already exists and returns MA_SUCCESS. */
+MA_API ma_result ma_resource_manager_register_encoded_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName, const void* pData, size_t sizeInBytes);
+MA_API ma_result ma_resource_manager_unregister_file(ma_resource_manager* pResourceManager, const char* pFilePath);
+MA_API ma_result ma_resource_manager_unregister_file_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath);
+MA_API ma_result ma_resource_manager_unregister_data(ma_resource_manager* pResourceManager, const char* pName);
+MA_API ma_result ma_resource_manager_unregister_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName);
+
+/* Data Buffers. */
+MA_API ma_result ma_resource_manager_data_buffer_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_init(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_init_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_init_copy(ma_resource_manager* pResourceManager, const ma_resource_manager_data_buffer* pExistingDataBuffer, ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_uninit(ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_read_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_resource_manager_data_buffer_seek_to_pcm_frame(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64 frameIndex);
+MA_API ma_result ma_resource_manager_data_buffer_get_data_format(ma_resource_manager_data_buffer* pDataBuffer, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_resource_manager_data_buffer_get_cursor_in_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pCursor);
+MA_API ma_result ma_resource_manager_data_buffer_get_length_in_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pLength);
+MA_API ma_result ma_resource_manager_data_buffer_result(const ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_set_looping(ma_resource_manager_data_buffer* pDataBuffer, ma_bool32 isLooping);
+MA_API ma_bool32 ma_resource_manager_data_buffer_is_looping(const ma_resource_manager_data_buffer* pDataBuffer);
+MA_API ma_result ma_resource_manager_data_buffer_get_available_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pAvailableFrames);
+
+/* Data Streams. */
+MA_API ma_result ma_resource_manager_data_stream_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_init(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_init_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_uninit(ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_read_pcm_frames(ma_resource_manager_data_stream* pDataStream, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_resource_manager_data_stream_seek_to_pcm_frame(ma_resource_manager_data_stream* pDataStream, ma_uint64 frameIndex);
+MA_API ma_result ma_resource_manager_data_stream_get_data_format(ma_resource_manager_data_stream* pDataStream, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_resource_manager_data_stream_get_cursor_in_pcm_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pCursor);
+MA_API ma_result ma_resource_manager_data_stream_get_length_in_pcm_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pLength);
+MA_API ma_result ma_resource_manager_data_stream_result(const ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_set_looping(ma_resource_manager_data_stream* pDataStream, ma_bool32 isLooping);
+MA_API ma_bool32 ma_resource_manager_data_stream_is_looping(const ma_resource_manager_data_stream* pDataStream);
+MA_API ma_result ma_resource_manager_data_stream_get_available_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pAvailableFrames);
+
+/* Data Sources. */
+MA_API ma_result ma_resource_manager_data_source_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_init(ma_resource_manager* pResourceManager, const char* pName, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_init_w(ma_resource_manager* pResourceManager, const wchar_t* pName, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_init_copy(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source* pExistingDataSource, ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_uninit(ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_read_pcm_frames(ma_resource_manager_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_resource_manager_data_source_seek_to_pcm_frame(ma_resource_manager_data_source* pDataSource, ma_uint64 frameIndex);
+MA_API ma_result ma_resource_manager_data_source_get_data_format(ma_resource_manager_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_resource_manager_data_source_get_cursor_in_pcm_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pCursor);
+MA_API ma_result ma_resource_manager_data_source_get_length_in_pcm_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pLength);
+MA_API ma_result ma_resource_manager_data_source_result(const ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_set_looping(ma_resource_manager_data_source* pDataSource, ma_bool32 isLooping);
+MA_API ma_bool32 ma_resource_manager_data_source_is_looping(const ma_resource_manager_data_source* pDataSource);
+MA_API ma_result ma_resource_manager_data_source_get_available_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pAvailableFrames);
+
+/* Job management. */
+MA_API ma_result ma_resource_manager_post_job(ma_resource_manager* pResourceManager, const ma_job* pJob);
+MA_API ma_result ma_resource_manager_post_job_quit(ma_resource_manager* pResourceManager);  /* Helper for posting a quit job. */
+MA_API ma_result ma_resource_manager_next_job(ma_resource_manager* pResourceManager, ma_job* pJob);
+MA_API ma_result ma_resource_manager_process_job(ma_resource_manager* pResourceManager, ma_job* pJob);  /* DEPRECATED. Use ma_job_process(). Will be removed in version 0.12. */
+MA_API ma_result ma_resource_manager_process_next_job(ma_resource_manager* pResourceManager);   /* Returns MA_CANCELLED if a MA_JOB_TYPE_QUIT job is found. In non-blocking mode, returns MA_NO_DATA_AVAILABLE if no jobs are available. */
+#endif  /* MA_NO_RESOURCE_MANAGER */
+
+
+
+/************************************************************************************************************************************************************
+
+Node Graph
+
+************************************************************************************************************************************************************/
+#ifndef MA_NO_NODE_GRAPH
+/* Must never exceed 254. */
+#ifndef MA_MAX_NODE_BUS_COUNT
+#define MA_MAX_NODE_BUS_COUNT       254
+#endif
+
+/* Used internally by miniaudio for memory management. Must never exceed MA_MAX_NODE_BUS_COUNT. */
+#ifndef MA_MAX_NODE_LOCAL_BUS_COUNT
+#define MA_MAX_NODE_LOCAL_BUS_COUNT 2
+#endif
+
+/* Use this when the bus count is determined by the node instance rather than the vtable. */
+#define MA_NODE_BUS_COUNT_UNKNOWN   255
+
+typedef struct ma_node_graph ma_node_graph;
+typedef void ma_node;
+
+
+/* Node flags. */
+typedef enum
+{
+    MA_NODE_FLAG_PASSTHROUGH                = 0x00000001,
+    MA_NODE_FLAG_CONTINUOUS_PROCESSING      = 0x00000002,
+    MA_NODE_FLAG_ALLOW_NULL_INPUT           = 0x00000004,
+    MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES = 0x00000008,
+    MA_NODE_FLAG_SILENT_OUTPUT              = 0x00000010
+} ma_node_flags;
+
+
+/* The playback state of a node. Either started or stopped. */
+typedef enum
+{
+    ma_node_state_started = 0,
+    ma_node_state_stopped = 1
+} ma_node_state;
+
+
+typedef struct
+{
+    /*
+    Extended processing callback. This callback is used for effects that process input and output
+    at different rates (i.e. they perform resampling). This is similar to the simple version, only
+    they take two separate frame counts: one for input, and one for output.
+
+    On input, `pFrameCountOut` is equal to the capacity of the output buffer for each bus, whereas
+    `pFrameCountIn` will be equal to the number of PCM frames in each of the buffers in `ppFramesIn`.
+
+    On output, set `pFrameCountOut` to the number of PCM frames that were actually output and set
+    `pFrameCountIn` to the number of input frames that were consumed.
+    */
+    void (* onProcess)(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut);
+
+    /*
+    A callback for retrieving the number of a input frames that are required to output the
+    specified number of output frames. You would only want to implement this when the node performs
+    resampling. This is optional, even for nodes that perform resampling, but it does offer a
+    small reduction in latency as it allows miniaudio to calculate the exact number of input frames
+    to read at a time instead of having to estimate.
+    */
+    ma_result (* onGetRequiredInputFrameCount)(ma_node* pNode, ma_uint32 outputFrameCount, ma_uint32* pInputFrameCount);
+
+    /*
+    The number of input buses. This is how many sub-buffers will be contained in the `ppFramesIn`
+    parameters of the callbacks above.
+    */
+    ma_uint8 inputBusCount;
+
+    /*
+    The number of output buses. This is how many sub-buffers will be contained in the `ppFramesOut`
+    parameters of the callbacks above.
+    */
+    ma_uint8 outputBusCount;
+
+    /*
+    Flags describing characteristics of the node. This is currently just a placeholder for some
+    ideas for later on.
+    */
+    ma_uint32 flags;
+} ma_node_vtable;
+
+typedef struct
+{
+    const ma_node_vtable* vtable;       /* Should never be null. Initialization of the node will fail if so. */
+    ma_node_state initialState;         /* Defaults to ma_node_state_started. */
+    ma_uint32 inputBusCount;            /* Only used if the vtable specifies an input bus count of `MA_NODE_BUS_COUNT_UNKNOWN`, otherwise must be set to `MA_NODE_BUS_COUNT_UNKNOWN` (default). */
+    ma_uint32 outputBusCount;           /* Only used if the vtable specifies an output bus count of `MA_NODE_BUS_COUNT_UNKNOWN`, otherwise  be set to `MA_NODE_BUS_COUNT_UNKNOWN` (default). */
+    const ma_uint32* pInputChannels;    /* The number of elements are determined by the input bus count as determined by the vtable, or `inputBusCount` if the vtable specifies `MA_NODE_BUS_COUNT_UNKNOWN`. */
+    const ma_uint32* pOutputChannels;   /* The number of elements are determined by the output bus count as determined by the vtable, or `outputBusCount` if the vtable specifies `MA_NODE_BUS_COUNT_UNKNOWN`. */
+} ma_node_config;
+
+MA_API ma_node_config ma_node_config_init(void);
+
+
+/*
+A node has multiple output buses. An output bus is attached to an input bus as an item in a linked
+list. Think of the input bus as a linked list, with the output bus being an item in that list.
+*/
+typedef struct ma_node_output_bus ma_node_output_bus;
+struct ma_node_output_bus
+{
+    /* Immutable. */
+    ma_node* pNode;                                         /* The node that owns this output bus. The input node. Will be null for dummy head and tail nodes. */
+    ma_uint8 outputBusIndex;                                /* The index of the output bus on pNode that this output bus represents. */
+    ma_uint8 channels;                                      /* The number of channels in the audio stream for this bus. */
+
+    /* Mutable via multiple threads. Must be used atomically. The weird ordering here is for packing reasons. */
+    ma_uint8 inputNodeInputBusIndex;                        /* The index of the input bus on the input. Required for detaching. Will only be used within the spinlock so does not need to be atomic. */
+    MA_ATOMIC(4, ma_uint32) flags;                          /* Some state flags for tracking the read state of the output buffer. A combination of MA_NODE_OUTPUT_BUS_FLAG_*. */
+    MA_ATOMIC(4, ma_uint32) refCount;                       /* Reference count for some thread-safety when detaching. */
+    MA_ATOMIC(4, ma_bool32) isAttached;                     /* This is used to prevent iteration of nodes that are in the middle of being detached. Used for thread safety. */
+    MA_ATOMIC(4, ma_spinlock) lock;                         /* Unfortunate lock, but significantly simplifies the implementation. Required for thread-safe attaching and detaching. */
+    MA_ATOMIC(4, float) volume;                             /* Linear. */
+    MA_ATOMIC(MA_SIZEOF_PTR, ma_node_output_bus*) pNext;    /* If null, it's the tail node or detached. */
+    MA_ATOMIC(MA_SIZEOF_PTR, ma_node_output_bus*) pPrev;    /* If null, it's the head node or detached. */
+    MA_ATOMIC(MA_SIZEOF_PTR, ma_node*) pInputNode;          /* The node that this output bus is attached to. Required for detaching. */
+};
+
+/*
+A node has multiple input buses. The output buses of a node are connecting to the input busses of
+another. An input bus is essentially just a linked list of output buses.
+*/
+typedef struct ma_node_input_bus ma_node_input_bus;
+struct ma_node_input_bus
+{
+    /* Mutable via multiple threads. */
+    ma_node_output_bus head;                /* Dummy head node for simplifying some lock-free thread-safety stuff. */
+    MA_ATOMIC(4, ma_uint32) nextCounter;    /* This is used to determine whether or not the input bus is finding the next node in the list. Used for thread safety when detaching output buses. */
+    MA_ATOMIC(4, ma_spinlock) lock;         /* Unfortunate lock, but significantly simplifies the implementation. Required for thread-safe attaching and detaching. */
+
+    /* Set once at startup. */
+    ma_uint8 channels;                      /* The number of channels in the audio stream for this bus. */
+};
+
+
+typedef struct ma_node_base ma_node_base;
+struct ma_node_base
+{
+    /* These variables are set once at startup. */
+    ma_node_graph* pNodeGraph;              /* The graph this node belongs to. */
+    const ma_node_vtable* vtable;
+    float* pCachedData;                     /* Allocated on the heap. Fixed size. Needs to be stored on the heap because reading from output buses is done in separate function calls. */
+    ma_uint16 cachedDataCapInFramesPerBus;  /* The capacity of the input data cache in frames, per bus. */
+
+    /* These variables are read and written only from the audio thread. */
+    ma_uint16 cachedFrameCountOut;
+    ma_uint16 cachedFrameCountIn;
+    ma_uint16 consumedFrameCountIn;
+
+    /* These variables are read and written between different threads. */
+    MA_ATOMIC(4, ma_node_state) state;      /* When set to stopped, nothing will be read, regardless of the times in stateTimes. */
+    MA_ATOMIC(8, ma_uint64) stateTimes[2];  /* Indexed by ma_node_state. Specifies the time based on the global clock that a node should be considered to be in the relevant state. */
+    MA_ATOMIC(8, ma_uint64) localTime;      /* The node's local clock. This is just a running sum of the number of output frames that have been processed. Can be modified by any thread with `ma_node_set_time()`. */
+    ma_uint32 inputBusCount;
+    ma_uint32 outputBusCount;
+    ma_node_input_bus* pInputBuses;
+    ma_node_output_bus* pOutputBuses;
+
+    /* Memory management. */
+    ma_node_input_bus _inputBuses[MA_MAX_NODE_LOCAL_BUS_COUNT];
+    ma_node_output_bus _outputBuses[MA_MAX_NODE_LOCAL_BUS_COUNT];
+    void* _pHeap;   /* A heap allocation for internal use only. pInputBuses and/or pOutputBuses will point to this if the bus count exceeds MA_MAX_NODE_LOCAL_BUS_COUNT. */
+    ma_bool32 _ownsHeap;    /* If set to true, the node owns the heap allocation and _pHeap will be freed in ma_node_uninit(). */
+};
+
+MA_API ma_result ma_node_get_heap_size(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_node_init_preallocated(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, void* pHeap, ma_node* pNode);
+MA_API ma_result ma_node_init(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_node* pNode);
+MA_API void ma_node_uninit(ma_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_node_graph* ma_node_get_node_graph(const ma_node* pNode);
+MA_API ma_uint32 ma_node_get_input_bus_count(const ma_node* pNode);
+MA_API ma_uint32 ma_node_get_output_bus_count(const ma_node* pNode);
+MA_API ma_uint32 ma_node_get_input_channels(const ma_node* pNode, ma_uint32 inputBusIndex);
+MA_API ma_uint32 ma_node_get_output_channels(const ma_node* pNode, ma_uint32 outputBusIndex);
+MA_API ma_result ma_node_attach_output_bus(ma_node* pNode, ma_uint32 outputBusIndex, ma_node* pOtherNode, ma_uint32 otherNodeInputBusIndex);
+MA_API ma_result ma_node_detach_output_bus(ma_node* pNode, ma_uint32 outputBusIndex);
+MA_API ma_result ma_node_detach_all_output_buses(ma_node* pNode);
+MA_API ma_result ma_node_set_output_bus_volume(ma_node* pNode, ma_uint32 outputBusIndex, float volume);
+MA_API float ma_node_get_output_bus_volume(const ma_node* pNode, ma_uint32 outputBusIndex);
+MA_API ma_result ma_node_set_state(ma_node* pNode, ma_node_state state);
+MA_API ma_node_state ma_node_get_state(const ma_node* pNode);
+MA_API ma_result ma_node_set_state_time(ma_node* pNode, ma_node_state state, ma_uint64 globalTime);
+MA_API ma_uint64 ma_node_get_state_time(const ma_node* pNode, ma_node_state state);
+MA_API ma_node_state ma_node_get_state_by_time(const ma_node* pNode, ma_uint64 globalTime);
+MA_API ma_node_state ma_node_get_state_by_time_range(const ma_node* pNode, ma_uint64 globalTimeBeg, ma_uint64 globalTimeEnd);
+MA_API ma_uint64 ma_node_get_time(const ma_node* pNode);
+MA_API ma_result ma_node_set_time(ma_node* pNode, ma_uint64 localTime);
+
+
+typedef struct
+{
+    ma_uint32 channels;
+    ma_uint16 nodeCacheCapInFrames;
+} ma_node_graph_config;
+
+MA_API ma_node_graph_config ma_node_graph_config_init(ma_uint32 channels);
+
+
+struct ma_node_graph
+{
+    /* Immutable. */
+    ma_node_base base;                  /* The node graph itself is a node so it can be connected as an input to different node graph. This has zero inputs and calls ma_node_graph_read_pcm_frames() to generate it's output. */
+    ma_node_base endpoint;              /* Special node that all nodes eventually connect to. Data is read from this node in ma_node_graph_read_pcm_frames(). */
+    ma_uint16 nodeCacheCapInFrames;
+
+    /* Read and written by multiple threads. */
+    MA_ATOMIC(4, ma_bool32) isReading;
+};
+
+MA_API ma_result ma_node_graph_init(const ma_node_graph_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_node_graph* pNodeGraph);
+MA_API void ma_node_graph_uninit(ma_node_graph* pNodeGraph, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_node* ma_node_graph_get_endpoint(ma_node_graph* pNodeGraph);
+MA_API ma_result ma_node_graph_read_pcm_frames(ma_node_graph* pNodeGraph, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_uint32 ma_node_graph_get_channels(const ma_node_graph* pNodeGraph);
+MA_API ma_uint64 ma_node_graph_get_time(const ma_node_graph* pNodeGraph);
+MA_API ma_result ma_node_graph_set_time(ma_node_graph* pNodeGraph, ma_uint64 globalTime);
+
+
+
+/* Data source node. 0 input buses, 1 output bus. Used for reading from a data source. */
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_data_source* pDataSource;
+} ma_data_source_node_config;
+
+MA_API ma_data_source_node_config ma_data_source_node_config_init(ma_data_source* pDataSource);
+
+
+typedef struct
+{
+    ma_node_base base;
+    ma_data_source* pDataSource;
+} ma_data_source_node;
+
+MA_API ma_result ma_data_source_node_init(ma_node_graph* pNodeGraph, const ma_data_source_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source_node* pDataSourceNode);
+MA_API void ma_data_source_node_uninit(ma_data_source_node* pDataSourceNode, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_data_source_node_set_looping(ma_data_source_node* pDataSourceNode, ma_bool32 isLooping);
+MA_API ma_bool32 ma_data_source_node_is_looping(ma_data_source_node* pDataSourceNode);
+
+
+/* Splitter Node. 1 input, many outputs. Used for splitting/copying a stream so it can be as input into two separate output nodes. */
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_uint32 channels;
+    ma_uint32 outputBusCount;
+} ma_splitter_node_config;
+
+MA_API ma_splitter_node_config ma_splitter_node_config_init(ma_uint32 channels);
+
+
+typedef struct
+{
+    ma_node_base base;
+} ma_splitter_node;
+
+MA_API ma_result ma_splitter_node_init(ma_node_graph* pNodeGraph, const ma_splitter_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_splitter_node* pSplitterNode);
+MA_API void ma_splitter_node_uninit(ma_splitter_node* pSplitterNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Biquad Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_biquad_config biquad;
+} ma_biquad_node_config;
+
+MA_API ma_biquad_node_config ma_biquad_node_config_init(ma_uint32 channels, float b0, float b1, float b2, float a0, float a1, float a2);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_biquad biquad;
+} ma_biquad_node;
+
+MA_API ma_result ma_biquad_node_init(ma_node_graph* pNodeGraph, const ma_biquad_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_biquad_node* pNode);
+MA_API ma_result ma_biquad_node_reinit(const ma_biquad_config* pConfig, ma_biquad_node* pNode);
+MA_API void ma_biquad_node_uninit(ma_biquad_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Low Pass Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_lpf_config lpf;
+} ma_lpf_node_config;
+
+MA_API ma_lpf_node_config ma_lpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_lpf lpf;
+} ma_lpf_node;
+
+MA_API ma_result ma_lpf_node_init(ma_node_graph* pNodeGraph, const ma_lpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf_node* pNode);
+MA_API ma_result ma_lpf_node_reinit(const ma_lpf_config* pConfig, ma_lpf_node* pNode);
+MA_API void ma_lpf_node_uninit(ma_lpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+High Pass Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_hpf_config hpf;
+} ma_hpf_node_config;
+
+MA_API ma_hpf_node_config ma_hpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_hpf hpf;
+} ma_hpf_node;
+
+MA_API ma_result ma_hpf_node_init(ma_node_graph* pNodeGraph, const ma_hpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf_node* pNode);
+MA_API ma_result ma_hpf_node_reinit(const ma_hpf_config* pConfig, ma_hpf_node* pNode);
+MA_API void ma_hpf_node_uninit(ma_hpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Band Pass Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_bpf_config bpf;
+} ma_bpf_node_config;
+
+MA_API ma_bpf_node_config ma_bpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_bpf bpf;
+} ma_bpf_node;
+
+MA_API ma_result ma_bpf_node_init(ma_node_graph* pNodeGraph, const ma_bpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf_node* pNode);
+MA_API ma_result ma_bpf_node_reinit(const ma_bpf_config* pConfig, ma_bpf_node* pNode);
+MA_API void ma_bpf_node_uninit(ma_bpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Notching Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_notch_config notch;
+} ma_notch_node_config;
+
+MA_API ma_notch_node_config ma_notch_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double q, double frequency);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_notch2 notch;
+} ma_notch_node;
+
+MA_API ma_result ma_notch_node_init(ma_node_graph* pNodeGraph, const ma_notch_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_notch_node* pNode);
+MA_API ma_result ma_notch_node_reinit(const ma_notch_config* pConfig, ma_notch_node* pNode);
+MA_API void ma_notch_node_uninit(ma_notch_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Peaking Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_peak_config peak;
+} ma_peak_node_config;
+
+MA_API ma_peak_node_config ma_peak_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_peak2 peak;
+} ma_peak_node;
+
+MA_API ma_result ma_peak_node_init(ma_node_graph* pNodeGraph, const ma_peak_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_peak_node* pNode);
+MA_API ma_result ma_peak_node_reinit(const ma_peak_config* pConfig, ma_peak_node* pNode);
+MA_API void ma_peak_node_uninit(ma_peak_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+Low Shelf Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_loshelf_config loshelf;
+} ma_loshelf_node_config;
+
+MA_API ma_loshelf_node_config ma_loshelf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_loshelf2 loshelf;
+} ma_loshelf_node;
+
+MA_API ma_result ma_loshelf_node_init(ma_node_graph* pNodeGraph, const ma_loshelf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_loshelf_node* pNode);
+MA_API ma_result ma_loshelf_node_reinit(const ma_loshelf_config* pConfig, ma_loshelf_node* pNode);
+MA_API void ma_loshelf_node_uninit(ma_loshelf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+/*
+High Shelf Filter Node
+*/
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_hishelf_config hishelf;
+} ma_hishelf_node_config;
+
+MA_API ma_hishelf_node_config ma_hishelf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_hishelf2 hishelf;
+} ma_hishelf_node;
+
+MA_API ma_result ma_hishelf_node_init(ma_node_graph* pNodeGraph, const ma_hishelf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hishelf_node* pNode);
+MA_API ma_result ma_hishelf_node_reinit(const ma_hishelf_config* pConfig, ma_hishelf_node* pNode);
+MA_API void ma_hishelf_node_uninit(ma_hishelf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+typedef struct
+{
+    ma_node_config nodeConfig;
+    ma_delay_config delay;
+} ma_delay_node_config;
+
+MA_API ma_delay_node_config ma_delay_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 delayInFrames, float decay);
+
+
+typedef struct
+{
+    ma_node_base baseNode;
+    ma_delay delay;
+} ma_delay_node;
+
+MA_API ma_result ma_delay_node_init(ma_node_graph* pNodeGraph, const ma_delay_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_delay_node* pDelayNode);
+MA_API void ma_delay_node_uninit(ma_delay_node* pDelayNode, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API void ma_delay_node_set_wet(ma_delay_node* pDelayNode, float value);
+MA_API float ma_delay_node_get_wet(const ma_delay_node* pDelayNode);
+MA_API void ma_delay_node_set_dry(ma_delay_node* pDelayNode, float value);
+MA_API float ma_delay_node_get_dry(const ma_delay_node* pDelayNode);
+MA_API void ma_delay_node_set_decay(ma_delay_node* pDelayNode, float value);
+MA_API float ma_delay_node_get_decay(const ma_delay_node* pDelayNode);
+#endif  /* MA_NO_NODE_GRAPH */
+
+
+/* SECTION: miniaudio_engine.h */
+/************************************************************************************************************************************************************
+
+Engine
+
+************************************************************************************************************************************************************/
+#if !defined(MA_NO_ENGINE) && !defined(MA_NO_NODE_GRAPH)
+typedef struct ma_engine ma_engine;
+typedef struct ma_sound  ma_sound;
+
+
+/* Sound flags. */
+typedef enum
+{
+    /* Resource manager flags. */
+    MA_SOUND_FLAG_STREAM                = 0x00000001,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM */
+    MA_SOUND_FLAG_DECODE                = 0x00000002,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE */
+    MA_SOUND_FLAG_ASYNC                 = 0x00000004,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC */
+    MA_SOUND_FLAG_WAIT_INIT             = 0x00000008,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT */
+    MA_SOUND_FLAG_UNKNOWN_LENGTH        = 0x00000010,   /* MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH */
+
+    /* ma_sound specific flags. */
+    MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT = 0x00001000,   /* Do not attach to the endpoint by default. Useful for when setting up nodes in a complex graph system. */
+    MA_SOUND_FLAG_NO_PITCH              = 0x00002000,   /* Disable pitch shifting with ma_sound_set_pitch() and ma_sound_group_set_pitch(). This is an optimization. */
+    MA_SOUND_FLAG_NO_SPATIALIZATION     = 0x00004000    /* Disable spatialization. */
+} ma_sound_flags;
+
+#ifndef MA_ENGINE_MAX_LISTENERS
+#define MA_ENGINE_MAX_LISTENERS             4
+#endif
+
+#define MA_LISTENER_INDEX_CLOSEST           ((ma_uint8)-1)
+
+typedef enum
+{
+    ma_engine_node_type_sound,
+    ma_engine_node_type_group
+} ma_engine_node_type;
+
+typedef struct
+{
+    ma_engine* pEngine;
+    ma_engine_node_type type;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_uint32 sampleRate;               /* Only used when the type is set to ma_engine_node_type_sound. */
+    ma_uint32 volumeSmoothTimeInPCMFrames;  /* The number of frames to smooth over volume changes. Defaults to 0 in which case no smoothing is used. */
+    ma_mono_expansion_mode monoExpansionMode;
+    ma_bool8 isPitchDisabled;           /* Pitching can be explicitly disabled with MA_SOUND_FLAG_NO_PITCH to optimize processing. */
+    ma_bool8 isSpatializationDisabled;  /* Spatialization can be explicitly disabled with MA_SOUND_FLAG_NO_SPATIALIZATION. */
+    ma_uint8 pinnedListenerIndex;       /* The index of the listener this node should always use for spatialization. If set to MA_LISTENER_INDEX_CLOSEST the engine will use the closest listener. */
+} ma_engine_node_config;
+
+MA_API ma_engine_node_config ma_engine_node_config_init(ma_engine* pEngine, ma_engine_node_type type, ma_uint32 flags);
+
+
+/* Base node object for both ma_sound and ma_sound_group. */
+typedef struct
+{
+    ma_node_base baseNode;                              /* Must be the first member for compatiblity with the ma_node API. */
+    ma_engine* pEngine;                                 /* A pointer to the engine. Set based on the value from the config. */
+    ma_uint32 sampleRate;                               /* The sample rate of the input data. For sounds backed by a data source, this will be the data source's sample rate. Otherwise it'll be the engine's sample rate. */
+    ma_uint32 volumeSmoothTimeInPCMFrames;
+    ma_mono_expansion_mode monoExpansionMode;
+    ma_fader fader;
+    ma_linear_resampler resampler;                      /* For pitch shift. */
+    ma_spatializer spatializer;
+    ma_panner panner;
+    ma_gainer volumeGainer;                             /* This will only be used if volumeSmoothTimeInPCMFrames is > 0. */
+    ma_atomic_float volume;                             /* Defaults to 1. */
+    MA_ATOMIC(4, float) pitch;
+    float oldPitch;                                     /* For determining whether or not the resampler needs to be updated to reflect the new pitch. The resampler will be updated on the mixing thread. */
+    float oldDopplerPitch;                              /* For determining whether or not the resampler needs to be updated to take a new doppler pitch into account. */
+    MA_ATOMIC(4, ma_bool32) isPitchDisabled;            /* When set to true, pitching will be disabled which will allow the resampler to be bypassed to save some computation. */
+    MA_ATOMIC(4, ma_bool32) isSpatializationDisabled;   /* Set to false by default. When set to false, will not have spatialisation applied. */
+    MA_ATOMIC(4, ma_uint32) pinnedListenerIndex;        /* The index of the listener this node should always use for spatialization. If set to MA_LISTENER_INDEX_CLOSEST the engine will use the closest listener. */
+
+    /* When setting a fade, it's not done immediately in ma_sound_set_fade(). It's deferred to the audio thread which means we need to store the settings here. */
+    struct
+    {
+        ma_atomic_float volumeBeg;
+        ma_atomic_float volumeEnd;
+        ma_atomic_uint64 fadeLengthInFrames;            /* <-- Defaults to (~(ma_uint64)0) which is used to indicate that no fade should be applied. */
+        ma_atomic_uint64 absoluteGlobalTimeInFrames;    /* <-- The time to start the fade. */
+    } fadeSettings;
+
+    /* Memory management. */
+    ma_bool8 _ownsHeap;
+    void* _pHeap;
+} ma_engine_node;
+
+MA_API ma_result ma_engine_node_get_heap_size(const ma_engine_node_config* pConfig, size_t* pHeapSizeInBytes);
+MA_API ma_result ma_engine_node_init_preallocated(const ma_engine_node_config* pConfig, void* pHeap, ma_engine_node* pEngineNode);
+MA_API ma_result ma_engine_node_init(const ma_engine_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_engine_node* pEngineNode);
+MA_API void ma_engine_node_uninit(ma_engine_node* pEngineNode, const ma_allocation_callbacks* pAllocationCallbacks);
+
+
+#define MA_SOUND_SOURCE_CHANNEL_COUNT   0xFFFFFFFF
+
+/* Callback for when a sound reaches the end. */
+typedef void (* ma_sound_end_proc)(void* pUserData, ma_sound* pSound);
+
+typedef struct
+{
+    const char* pFilePath;                      /* Set this to load from the resource manager. */
+    const wchar_t* pFilePathW;                  /* Set this to load from the resource manager. */
+    ma_data_source* pDataSource;                /* Set this to load from an existing data source. */
+    ma_node* pInitialAttachment;                /* If set, the sound will be attached to an input of this node. This can be set to a ma_sound. If set to NULL, the sound will be attached directly to the endpoint unless MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT is set in `flags`. */
+    ma_uint32 initialAttachmentInputBusIndex;   /* The index of the input bus of pInitialAttachment to attach the sound to. */
+    ma_uint32 channelsIn;                       /* Ignored if using a data source as input (the data source's channel count will be used always). Otherwise, setting to 0 will cause the engine's channel count to be used. */
+    ma_uint32 channelsOut;                      /* Set this to 0 (default) to use the engine's channel count. Set to MA_SOUND_SOURCE_CHANNEL_COUNT to use the data source's channel count (only used if using a data source as input). */
+    ma_mono_expansion_mode monoExpansionMode;   /* Controls how the mono channel should be expanded to other channels when spatialization is disabled on a sound. */
+    ma_uint32 flags;                            /* A combination of MA_SOUND_FLAG_* flags. */
+    ma_uint32 volumeSmoothTimeInPCMFrames;      /* The number of frames to smooth over volume changes. Defaults to 0 in which case no smoothing is used. */
+    ma_uint64 initialSeekPointInPCMFrames;      /* Initializes the sound such that it's seeked to this location by default. */
+    ma_uint64 rangeBegInPCMFrames;
+    ma_uint64 rangeEndInPCMFrames;
+    ma_uint64 loopPointBegInPCMFrames;
+    ma_uint64 loopPointEndInPCMFrames;
+    ma_bool32 isLooping;
+    ma_sound_end_proc endCallback;              /* Fired when the sound reaches the end. Will be fired from the audio thread. Do not restart, uninitialize or otherwise change the state of the sound from here. Instead fire an event or set a variable to indicate to a different thread to change the start of the sound. Will not be fired in response to a scheduled stop with ma_sound_set_stop_time_*(). */
+    void* pEndCallbackUserData;
+#ifndef MA_NO_RESOURCE_MANAGER
+    ma_resource_manager_pipeline_notifications initNotifications;
+#endif
+    ma_fence* pDoneFence;                       /* Deprecated. Use initNotifications instead. Released when the resource manager has finished decoding the entire sound. Not used with streams. */
+} ma_sound_config;
+
+MA_API ma_sound_config ma_sound_config_init(void);                  /* Deprecated. Will be removed in version 0.12. Use ma_sound_config_2() instead. */
+MA_API ma_sound_config ma_sound_config_init_2(ma_engine* pEngine);  /* Will be renamed to ma_sound_config_init() in version 0.12. */
+
+struct ma_sound
+{
+    ma_engine_node engineNode;          /* Must be the first member for compatibility with the ma_node API. */
+    ma_data_source* pDataSource;
+    MA_ATOMIC(8, ma_uint64) seekTarget; /* The PCM frame index to seek to in the mixing thread. Set to (~(ma_uint64)0) to not perform any seeking. */
+    MA_ATOMIC(4, ma_bool32) atEnd;
+    ma_sound_end_proc endCallback;
+    void* pEndCallbackUserData;
+    ma_bool8 ownsDataSource;
+
+    /*
+    We're declaring a resource manager data source object here to save us a malloc when loading a
+    sound via the resource manager, which I *think* will be the most common scenario.
+    */
+#ifndef MA_NO_RESOURCE_MANAGER
+    ma_resource_manager_data_source* pResourceManagerDataSource;
+#endif
+};
+
+/* Structure specifically for sounds played with ma_engine_play_sound(). Making this a separate structure to reduce overhead. */
+typedef struct ma_sound_inlined ma_sound_inlined;
+struct ma_sound_inlined
+{
+    ma_sound sound;
+    ma_sound_inlined* pNext;
+    ma_sound_inlined* pPrev;
+};
+
+/* A sound group is just a sound. */
+typedef ma_sound_config ma_sound_group_config;
+typedef ma_sound        ma_sound_group;
+
+MA_API ma_sound_group_config ma_sound_group_config_init(void);                  /* Deprecated. Will be removed in version 0.12. Use ma_sound_config_2() instead. */
+MA_API ma_sound_group_config ma_sound_group_config_init_2(ma_engine* pEngine);  /* Will be renamed to ma_sound_config_init() in version 0.12. */
+
+typedef void (* ma_engine_process_proc)(void* pUserData, float* pFramesOut, ma_uint64 frameCount);
+
+typedef struct
+{
+#if !defined(MA_NO_RESOURCE_MANAGER)
+    ma_resource_manager* pResourceManager;          /* Can be null in which case a resource manager will be created for you. */
+#endif
+#if !defined(MA_NO_DEVICE_IO)
+    ma_context* pContext;
+    ma_device* pDevice;                             /* If set, the caller is responsible for calling ma_engine_data_callback() in the device's data callback. */
+    ma_device_id* pPlaybackDeviceID;                /* The ID of the playback device to use with the default listener. */
+    ma_device_data_proc dataCallback;               /* Can be null. Can be used to provide a custom device data callback. */
+    ma_device_notification_proc notificationCallback;
+#endif
+    ma_log* pLog;                                   /* When set to NULL, will use the context's log. */
+    ma_uint32 listenerCount;                        /* Must be between 1 and MA_ENGINE_MAX_LISTENERS. */
+    ma_uint32 channels;                             /* The number of channels to use when mixing and spatializing. When set to 0, will use the native channel count of the device. */
+    ma_uint32 sampleRate;                           /* The sample rate. When set to 0 will use the native channel count of the device. */
+    ma_uint32 periodSizeInFrames;                   /* If set to something other than 0, updates will always be exactly this size. The underlying device may be a different size, but from the perspective of the mixer that won't matter.*/
+    ma_uint32 periodSizeInMilliseconds;             /* Used if periodSizeInFrames is unset. */
+    ma_uint32 gainSmoothTimeInFrames;               /* The number of frames to interpolate the gain of spatialized sounds across. If set to 0, will use gainSmoothTimeInMilliseconds. */
+    ma_uint32 gainSmoothTimeInMilliseconds;         /* When set to 0, gainSmoothTimeInFrames will be used. If both are set to 0, a default value will be used. */
+    ma_uint32 defaultVolumeSmoothTimeInPCMFrames;   /* Defaults to 0. Controls the default amount of smoothing to apply to volume changes to sounds. High values means more smoothing at the expense of high latency (will take longer to reach the new volume). */
+    ma_allocation_callbacks allocationCallbacks;
+    ma_bool32 noAutoStart;                          /* When set to true, requires an explicit call to ma_engine_start(). This is false by default, meaning the engine will be started automatically in ma_engine_init(). */
+    ma_bool32 noDevice;                             /* When set to true, don't create a default device. ma_engine_read_pcm_frames() can be called manually to read data. */
+    ma_mono_expansion_mode monoExpansionMode;       /* Controls how the mono channel should be expanded to other channels when spatialization is disabled on a sound. */
+    ma_vfs* pResourceManagerVFS;                    /* A pointer to a pre-allocated VFS object to use with the resource manager. This is ignored if pResourceManager is not NULL. */
+    ma_engine_process_proc onProcess;               /* Fired at the end of each call to ma_engine_read_pcm_frames(). For engine's that manage their own internal device (the default configuration), this will be fired from the audio thread, and you do not need to call ma_engine_read_pcm_frames() manually in order to trigger this. */
+    void* pProcessUserData;                         /* User data that's passed into onProcess. */
+} ma_engine_config;
+
+MA_API ma_engine_config ma_engine_config_init(void);
+
+
+struct ma_engine
+{
+    ma_node_graph nodeGraph;                /* An engine is a node graph. It should be able to be plugged into any ma_node_graph API (with a cast) which means this must be the first member of this struct. */
+#if !defined(MA_NO_RESOURCE_MANAGER)
+    ma_resource_manager* pResourceManager;
+#endif
+#if !defined(MA_NO_DEVICE_IO)
+    ma_device* pDevice;                     /* Optionally set via the config, otherwise allocated by the engine in ma_engine_init(). */
+#endif
+    ma_log* pLog;
+    ma_uint32 sampleRate;
+    ma_uint32 listenerCount;
+    ma_spatializer_listener listeners[MA_ENGINE_MAX_LISTENERS];
+    ma_allocation_callbacks allocationCallbacks;
+    ma_bool8 ownsResourceManager;
+    ma_bool8 ownsDevice;
+    ma_spinlock inlinedSoundLock;               /* For synchronizing access so the inlined sound list. */
+    ma_sound_inlined* pInlinedSoundHead;        /* The first inlined sound. Inlined sounds are tracked in a linked list. */
+    MA_ATOMIC(4, ma_uint32) inlinedSoundCount;  /* The total number of allocated inlined sound objects. Used for debugging. */
+    ma_uint32 gainSmoothTimeInFrames;           /* The number of frames to interpolate the gain of spatialized sounds across. */
+    ma_uint32 defaultVolumeSmoothTimeInPCMFrames;
+    ma_mono_expansion_mode monoExpansionMode;
+    ma_engine_process_proc onProcess;
+    void* pProcessUserData;
+};
+
+MA_API ma_result ma_engine_init(const ma_engine_config* pConfig, ma_engine* pEngine);
+MA_API void ma_engine_uninit(ma_engine* pEngine);
+MA_API ma_result ma_engine_read_pcm_frames(ma_engine* pEngine, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_node_graph* ma_engine_get_node_graph(ma_engine* pEngine);
+#if !defined(MA_NO_RESOURCE_MANAGER)
+MA_API ma_resource_manager* ma_engine_get_resource_manager(ma_engine* pEngine);
+#endif
+MA_API ma_device* ma_engine_get_device(ma_engine* pEngine);
+MA_API ma_log* ma_engine_get_log(ma_engine* pEngine);
+MA_API ma_node* ma_engine_get_endpoint(ma_engine* pEngine);
+MA_API ma_uint64 ma_engine_get_time_in_pcm_frames(const ma_engine* pEngine);
+MA_API ma_uint64 ma_engine_get_time_in_milliseconds(const ma_engine* pEngine);
+MA_API ma_result ma_engine_set_time_in_pcm_frames(ma_engine* pEngine, ma_uint64 globalTime);
+MA_API ma_result ma_engine_set_time_in_milliseconds(ma_engine* pEngine, ma_uint64 globalTime);
+MA_API ma_uint64 ma_engine_get_time(const ma_engine* pEngine);                  /* Deprecated. Use ma_engine_get_time_in_pcm_frames(). Will be removed in version 0.12. */
+MA_API ma_result ma_engine_set_time(ma_engine* pEngine, ma_uint64 globalTime);  /* Deprecated. Use ma_engine_set_time_in_pcm_frames(). Will be removed in version 0.12. */
+MA_API ma_uint32 ma_engine_get_channels(const ma_engine* pEngine);
+MA_API ma_uint32 ma_engine_get_sample_rate(const ma_engine* pEngine);
+
+MA_API ma_result ma_engine_start(ma_engine* pEngine);
+MA_API ma_result ma_engine_stop(ma_engine* pEngine);
+MA_API ma_result ma_engine_set_volume(ma_engine* pEngine, float volume);
+MA_API float ma_engine_get_volume(ma_engine* pEngine);
+MA_API ma_result ma_engine_set_gain_db(ma_engine* pEngine, float gainDB);
+MA_API float ma_engine_get_gain_db(ma_engine* pEngine);
+
+MA_API ma_uint32 ma_engine_get_listener_count(const ma_engine* pEngine);
+MA_API ma_uint32 ma_engine_find_closest_listener(const ma_engine* pEngine, float absolutePosX, float absolutePosY, float absolutePosZ);
+MA_API void ma_engine_listener_set_position(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z);
+MA_API ma_vec3f ma_engine_listener_get_position(const ma_engine* pEngine, ma_uint32 listenerIndex);
+MA_API void ma_engine_listener_set_direction(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z);
+MA_API ma_vec3f ma_engine_listener_get_direction(const ma_engine* pEngine, ma_uint32 listenerIndex);
+MA_API void ma_engine_listener_set_velocity(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z);
+MA_API ma_vec3f ma_engine_listener_get_velocity(const ma_engine* pEngine, ma_uint32 listenerIndex);
+MA_API void ma_engine_listener_set_cone(ma_engine* pEngine, ma_uint32 listenerIndex, float innerAngleInRadians, float outerAngleInRadians, float outerGain);
+MA_API void ma_engine_listener_get_cone(const ma_engine* pEngine, ma_uint32 listenerIndex, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain);
+MA_API void ma_engine_listener_set_world_up(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z);
+MA_API ma_vec3f ma_engine_listener_get_world_up(const ma_engine* pEngine, ma_uint32 listenerIndex);
+MA_API void ma_engine_listener_set_enabled(ma_engine* pEngine, ma_uint32 listenerIndex, ma_bool32 isEnabled);
+MA_API ma_bool32 ma_engine_listener_is_enabled(const ma_engine* pEngine, ma_uint32 listenerIndex);
+
+#ifndef MA_NO_RESOURCE_MANAGER
+MA_API ma_result ma_engine_play_sound_ex(ma_engine* pEngine, const char* pFilePath, ma_node* pNode, ma_uint32 nodeInputBusIndex);
+MA_API ma_result ma_engine_play_sound(ma_engine* pEngine, const char* pFilePath, ma_sound_group* pGroup);   /* Fire and forget. */
+#endif
+
+#ifndef MA_NO_RESOURCE_MANAGER
+MA_API ma_result ma_sound_init_from_file(ma_engine* pEngine, const char* pFilePath, ma_uint32 flags, ma_sound_group* pGroup, ma_fence* pDoneFence, ma_sound* pSound);
+MA_API ma_result ma_sound_init_from_file_w(ma_engine* pEngine, const wchar_t* pFilePath, ma_uint32 flags, ma_sound_group* pGroup, ma_fence* pDoneFence, ma_sound* pSound);
+MA_API ma_result ma_sound_init_copy(ma_engine* pEngine, const ma_sound* pExistingSound, ma_uint32 flags, ma_sound_group* pGroup, ma_sound* pSound);
+#endif
+MA_API ma_result ma_sound_init_from_data_source(ma_engine* pEngine, ma_data_source* pDataSource, ma_uint32 flags, ma_sound_group* pGroup, ma_sound* pSound);
+MA_API ma_result ma_sound_init_ex(ma_engine* pEngine, const ma_sound_config* pConfig, ma_sound* pSound);
+MA_API void ma_sound_uninit(ma_sound* pSound);
+MA_API ma_engine* ma_sound_get_engine(const ma_sound* pSound);
+MA_API ma_data_source* ma_sound_get_data_source(const ma_sound* pSound);
+MA_API ma_result ma_sound_start(ma_sound* pSound);
+MA_API ma_result ma_sound_stop(ma_sound* pSound);
+MA_API ma_result ma_sound_stop_with_fade_in_pcm_frames(ma_sound* pSound, ma_uint64 fadeLengthInFrames);     /* Will overwrite any scheduled stop and fade. */
+MA_API ma_result ma_sound_stop_with_fade_in_milliseconds(ma_sound* pSound, ma_uint64 fadeLengthInFrames);   /* Will overwrite any scheduled stop and fade. */
+MA_API void ma_sound_set_volume(ma_sound* pSound, float volume);
+MA_API float ma_sound_get_volume(const ma_sound* pSound);
+MA_API void ma_sound_set_pan(ma_sound* pSound, float pan);
+MA_API float ma_sound_get_pan(const ma_sound* pSound);
+MA_API void ma_sound_set_pan_mode(ma_sound* pSound, ma_pan_mode panMode);
+MA_API ma_pan_mode ma_sound_get_pan_mode(const ma_sound* pSound);
+MA_API void ma_sound_set_pitch(ma_sound* pSound, float pitch);
+MA_API float ma_sound_get_pitch(const ma_sound* pSound);
+MA_API void ma_sound_set_spatialization_enabled(ma_sound* pSound, ma_bool32 enabled);
+MA_API ma_bool32 ma_sound_is_spatialization_enabled(const ma_sound* pSound);
+MA_API void ma_sound_set_pinned_listener_index(ma_sound* pSound, ma_uint32 listenerIndex);
+MA_API ma_uint32 ma_sound_get_pinned_listener_index(const ma_sound* pSound);
+MA_API ma_uint32 ma_sound_get_listener_index(const ma_sound* pSound);
+MA_API ma_vec3f ma_sound_get_direction_to_listener(const ma_sound* pSound);
+MA_API void ma_sound_set_position(ma_sound* pSound, float x, float y, float z);
+MA_API ma_vec3f ma_sound_get_position(const ma_sound* pSound);
+MA_API void ma_sound_set_direction(ma_sound* pSound, float x, float y, float z);
+MA_API ma_vec3f ma_sound_get_direction(const ma_sound* pSound);
+MA_API void ma_sound_set_velocity(ma_sound* pSound, float x, float y, float z);
+MA_API ma_vec3f ma_sound_get_velocity(const ma_sound* pSound);
+MA_API void ma_sound_set_attenuation_model(ma_sound* pSound, ma_attenuation_model attenuationModel);
+MA_API ma_attenuation_model ma_sound_get_attenuation_model(const ma_sound* pSound);
+MA_API void ma_sound_set_positioning(ma_sound* pSound, ma_positioning positioning);
+MA_API ma_positioning ma_sound_get_positioning(const ma_sound* pSound);
+MA_API void ma_sound_set_rolloff(ma_sound* pSound, float rolloff);
+MA_API float ma_sound_get_rolloff(const ma_sound* pSound);
+MA_API void ma_sound_set_min_gain(ma_sound* pSound, float minGain);
+MA_API float ma_sound_get_min_gain(const ma_sound* pSound);
+MA_API void ma_sound_set_max_gain(ma_sound* pSound, float maxGain);
+MA_API float ma_sound_get_max_gain(const ma_sound* pSound);
+MA_API void ma_sound_set_min_distance(ma_sound* pSound, float minDistance);
+MA_API float ma_sound_get_min_distance(const ma_sound* pSound);
+MA_API void ma_sound_set_max_distance(ma_sound* pSound, float maxDistance);
+MA_API float ma_sound_get_max_distance(const ma_sound* pSound);
+MA_API void ma_sound_set_cone(ma_sound* pSound, float innerAngleInRadians, float outerAngleInRadians, float outerGain);
+MA_API void ma_sound_get_cone(const ma_sound* pSound, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain);
+MA_API void ma_sound_set_doppler_factor(ma_sound* pSound, float dopplerFactor);
+MA_API float ma_sound_get_doppler_factor(const ma_sound* pSound);
+MA_API void ma_sound_set_directional_attenuation_factor(ma_sound* pSound, float directionalAttenuationFactor);
+MA_API float ma_sound_get_directional_attenuation_factor(const ma_sound* pSound);
+MA_API void ma_sound_set_fade_in_pcm_frames(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames);
+MA_API void ma_sound_set_fade_in_milliseconds(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds);
+MA_API void ma_sound_set_fade_start_in_pcm_frames(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames, ma_uint64 absoluteGlobalTimeInFrames);
+MA_API void ma_sound_set_fade_start_in_milliseconds(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds, ma_uint64 absoluteGlobalTimeInMilliseconds);
+MA_API float ma_sound_get_current_fade_volume(const ma_sound* pSound);
+MA_API void ma_sound_set_start_time_in_pcm_frames(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInFrames);
+MA_API void ma_sound_set_start_time_in_milliseconds(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInMilliseconds);
+MA_API void ma_sound_set_stop_time_in_pcm_frames(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInFrames);
+MA_API void ma_sound_set_stop_time_in_milliseconds(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInMilliseconds);
+MA_API void ma_sound_set_stop_time_with_fade_in_pcm_frames(ma_sound* pSound, ma_uint64 stopAbsoluteGlobalTimeInFrames, ma_uint64 fadeLengthInFrames);
+MA_API void ma_sound_set_stop_time_with_fade_in_milliseconds(ma_sound* pSound, ma_uint64 stopAbsoluteGlobalTimeInMilliseconds, ma_uint64 fadeLengthInMilliseconds);
+MA_API ma_bool32 ma_sound_is_playing(const ma_sound* pSound);
+MA_API ma_uint64 ma_sound_get_time_in_pcm_frames(const ma_sound* pSound);
+MA_API ma_uint64 ma_sound_get_time_in_milliseconds(const ma_sound* pSound);
+MA_API void ma_sound_set_looping(ma_sound* pSound, ma_bool32 isLooping);
+MA_API ma_bool32 ma_sound_is_looping(const ma_sound* pSound);
+MA_API ma_bool32 ma_sound_at_end(const ma_sound* pSound);
+MA_API ma_result ma_sound_seek_to_pcm_frame(ma_sound* pSound, ma_uint64 frameIndex); /* Just a wrapper around ma_data_source_seek_to_pcm_frame(). */
+MA_API ma_result ma_sound_get_data_format(ma_sound* pSound, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_sound_get_cursor_in_pcm_frames(ma_sound* pSound, ma_uint64* pCursor);
+MA_API ma_result ma_sound_get_length_in_pcm_frames(ma_sound* pSound, ma_uint64* pLength);
+MA_API ma_result ma_sound_get_cursor_in_seconds(ma_sound* pSound, float* pCursor);
+MA_API ma_result ma_sound_get_length_in_seconds(ma_sound* pSound, float* pLength);
+MA_API ma_result ma_sound_set_end_callback(ma_sound* pSound, ma_sound_end_proc callback, void* pUserData);
+
+MA_API ma_result ma_sound_group_init(ma_engine* pEngine, ma_uint32 flags, ma_sound_group* pParentGroup, ma_sound_group* pGroup);
+MA_API ma_result ma_sound_group_init_ex(ma_engine* pEngine, const ma_sound_group_config* pConfig, ma_sound_group* pGroup);
+MA_API void ma_sound_group_uninit(ma_sound_group* pGroup);
+MA_API ma_engine* ma_sound_group_get_engine(const ma_sound_group* pGroup);
+MA_API ma_result ma_sound_group_start(ma_sound_group* pGroup);
+MA_API ma_result ma_sound_group_stop(ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_volume(ma_sound_group* pGroup, float volume);
+MA_API float ma_sound_group_get_volume(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_pan(ma_sound_group* pGroup, float pan);
+MA_API float ma_sound_group_get_pan(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_pan_mode(ma_sound_group* pGroup, ma_pan_mode panMode);
+MA_API ma_pan_mode ma_sound_group_get_pan_mode(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_pitch(ma_sound_group* pGroup, float pitch);
+MA_API float ma_sound_group_get_pitch(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_spatialization_enabled(ma_sound_group* pGroup, ma_bool32 enabled);
+MA_API ma_bool32 ma_sound_group_is_spatialization_enabled(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_pinned_listener_index(ma_sound_group* pGroup, ma_uint32 listenerIndex);
+MA_API ma_uint32 ma_sound_group_get_pinned_listener_index(const ma_sound_group* pGroup);
+MA_API ma_uint32 ma_sound_group_get_listener_index(const ma_sound_group* pGroup);
+MA_API ma_vec3f ma_sound_group_get_direction_to_listener(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_position(ma_sound_group* pGroup, float x, float y, float z);
+MA_API ma_vec3f ma_sound_group_get_position(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_direction(ma_sound_group* pGroup, float x, float y, float z);
+MA_API ma_vec3f ma_sound_group_get_direction(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_velocity(ma_sound_group* pGroup, float x, float y, float z);
+MA_API ma_vec3f ma_sound_group_get_velocity(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_attenuation_model(ma_sound_group* pGroup, ma_attenuation_model attenuationModel);
+MA_API ma_attenuation_model ma_sound_group_get_attenuation_model(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_positioning(ma_sound_group* pGroup, ma_positioning positioning);
+MA_API ma_positioning ma_sound_group_get_positioning(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_rolloff(ma_sound_group* pGroup, float rolloff);
+MA_API float ma_sound_group_get_rolloff(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_min_gain(ma_sound_group* pGroup, float minGain);
+MA_API float ma_sound_group_get_min_gain(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_max_gain(ma_sound_group* pGroup, float maxGain);
+MA_API float ma_sound_group_get_max_gain(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_min_distance(ma_sound_group* pGroup, float minDistance);
+MA_API float ma_sound_group_get_min_distance(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_max_distance(ma_sound_group* pGroup, float maxDistance);
+MA_API float ma_sound_group_get_max_distance(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_cone(ma_sound_group* pGroup, float innerAngleInRadians, float outerAngleInRadians, float outerGain);
+MA_API void ma_sound_group_get_cone(const ma_sound_group* pGroup, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain);
+MA_API void ma_sound_group_set_doppler_factor(ma_sound_group* pGroup, float dopplerFactor);
+MA_API float ma_sound_group_get_doppler_factor(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_directional_attenuation_factor(ma_sound_group* pGroup, float directionalAttenuationFactor);
+MA_API float ma_sound_group_get_directional_attenuation_factor(const ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_fade_in_pcm_frames(ma_sound_group* pGroup, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames);
+MA_API void ma_sound_group_set_fade_in_milliseconds(ma_sound_group* pGroup, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds);
+MA_API float ma_sound_group_get_current_fade_volume(ma_sound_group* pGroup);
+MA_API void ma_sound_group_set_start_time_in_pcm_frames(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInFrames);
+MA_API void ma_sound_group_set_start_time_in_milliseconds(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInMilliseconds);
+MA_API void ma_sound_group_set_stop_time_in_pcm_frames(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInFrames);
+MA_API void ma_sound_group_set_stop_time_in_milliseconds(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInMilliseconds);
+MA_API ma_bool32 ma_sound_group_is_playing(const ma_sound_group* pGroup);
+MA_API ma_uint64 ma_sound_group_get_time_in_pcm_frames(const ma_sound_group* pGroup);
+#endif  /* MA_NO_ENGINE */
+/* END SECTION: miniaudio_engine.h */
+
+#ifdef __cplusplus
+}
+#endif
+#endif  /* miniaudio_h */
+
+
+/*
+This is for preventing greying out of the implementation section.
+*/
+#if defined(Q_CREATOR_RUN) || defined(__INTELLISENSE__) || defined(__CDT_PARSER__)
+#define MINIAUDIO_IMPLEMENTATION
+#endif
+
+/************************************************************************************************************************************************************
+*************************************************************************************************************************************************************
+
+IMPLEMENTATION
+
+*************************************************************************************************************************************************************
+************************************************************************************************************************************************************/
+#if defined(MINIAUDIO_IMPLEMENTATION) || defined(MA_IMPLEMENTATION)
+#ifndef miniaudio_c
+#define miniaudio_c
+
+#include <assert.h>
+#include <limits.h>         /* For INT_MAX */
+#include <math.h>           /* sin(), etc. */
+#include <stdlib.h>         /* For malloc(), free(), wcstombs(). */
+#include <string.h>         /* For memset() */
+
+#include <stdarg.h>
+#include <stdio.h>
+#if !defined(_MSC_VER) && !defined(__DMC__)
+    #include <strings.h>    /* For strcasecmp(). */
+    #include <wchar.h>      /* For wcslen(), wcsrtombs() */
+#endif
+#ifdef _MSC_VER
+    #include <float.h>      /* For _controlfp_s constants */
+#endif
+
+#if defined(MA_WIN32)
+    #include <windows.h>
+
+    /*
+    There's a possibility that WIN32_LEAN_AND_MEAN has been defined which will exclude some symbols
+    such as STGM_READ and CLSCTL_ALL. We need to check these and define them ourselves if they're
+    unavailable.
+    */
+    #ifndef STGM_READ
+    #define STGM_READ   0x00000000L
+    #endif
+    #ifndef CLSCTX_ALL
+    #define CLSCTX_ALL  23
+    #endif
+
+    /* IUnknown is used by both the WASAPI and DirectSound backends. It easier to just declare our version here. */
+    typedef struct ma_IUnknown  ma_IUnknown;
+#endif
+
+#if !defined(MA_WIN32)
+#include <sched.h>
+#include <sys/time.h>   /* select() (used for ma_sleep()). */
+#include <pthread.h>
+#endif
+
+#ifdef MA_NX
+#include <time.h>       /* For nanosleep() */
+#endif
+
+#include <sys/stat.h>   /* For fstat(), etc. */
+
+#ifdef MA_EMSCRIPTEN
+#include <emscripten/emscripten.h>
+#endif
+
+
+/* Architecture Detection */
+#if !defined(MA_64BIT) && !defined(MA_32BIT)
+#ifdef _WIN32
+#ifdef _WIN64
+#define MA_64BIT
+#else
+#define MA_32BIT
+#endif
+#endif
+#endif
+
+#if !defined(MA_64BIT) && !defined(MA_32BIT)
+#ifdef __GNUC__
+#ifdef __LP64__
+#define MA_64BIT
+#else
+#define MA_32BIT
+#endif
+#endif
+#endif
+
+#if !defined(MA_64BIT) && !defined(MA_32BIT)
+#include <stdint.h>
+#if INTPTR_MAX == INT64_MAX
+#define MA_64BIT
+#else
+#define MA_32BIT
+#endif
+#endif
+
+#if defined(__arm__) || defined(_M_ARM)
+#define MA_ARM32
+#endif
+#if defined(__arm64) || defined(__arm64__) || defined(__aarch64__) || defined(_M_ARM64)
+#define MA_ARM64
+#endif
+
+#if defined(__x86_64__) || defined(_M_X64)
+#define MA_X64
+#elif defined(__i386) || defined(_M_IX86)
+#define MA_X86
+#elif defined(MA_ARM32) || defined(MA_ARM64)
+#define MA_ARM
+#endif
+
+/* Intrinsics Support */
+#if (defined(MA_X64) || defined(MA_X86)) && !defined(__COSMOPOLITAN__)
+    #if defined(_MSC_VER) && !defined(__clang__)
+        /* MSVC. */
+        #if _MSC_VER >= 1400 && !defined(MA_NO_SSE2)   /* 2005 */
+            #define MA_SUPPORT_SSE2
+        #endif
+        /*#if _MSC_VER >= 1600 && !defined(MA_NO_AVX)*/    /* 2010 */
+        /*    #define MA_SUPPORT_AVX*/
+        /*#endif*/
+        #if _MSC_VER >= 1700 && !defined(MA_NO_AVX2)   /* 2012 */
+            #define MA_SUPPORT_AVX2
+        #endif
+    #else
+        /* Assume GNUC-style. */
+        #if defined(__SSE2__) && !defined(MA_NO_SSE2)
+            #define MA_SUPPORT_SSE2
+        #endif
+        /*#if defined(__AVX__) && !defined(MA_NO_AVX)*/
+        /*    #define MA_SUPPORT_AVX*/
+        /*#endif*/
+        #if defined(__AVX2__) && !defined(MA_NO_AVX2)
+            #define MA_SUPPORT_AVX2
+        #endif
+    #endif
+
+    /* If at this point we still haven't determined compiler support for the intrinsics just fall back to __has_include. */
+    #if !defined(__GNUC__) && !defined(__clang__) && defined(__has_include)
+        #if !defined(MA_SUPPORT_SSE2)   && !defined(MA_NO_SSE2)   && __has_include(<emmintrin.h>)
+            #define MA_SUPPORT_SSE2
+        #endif
+        /*#if !defined(MA_SUPPORT_AVX)    && !defined(MA_NO_AVX)    && __has_include(<immintrin.h>)*/
+        /*    #define MA_SUPPORT_AVX*/
+        /*#endif*/
+        #if !defined(MA_SUPPORT_AVX2)   && !defined(MA_NO_AVX2)   && __has_include(<immintrin.h>)
+            #define MA_SUPPORT_AVX2
+        #endif
+    #endif
+
+    #if defined(MA_SUPPORT_AVX2) || defined(MA_SUPPORT_AVX)
+        #include <immintrin.h>
+    #elif defined(MA_SUPPORT_SSE2)
+        #include <emmintrin.h>
+    #endif
+#endif
+
+#if defined(MA_ARM)
+    #if !defined(MA_NO_NEON) && (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
+        #define MA_SUPPORT_NEON
+        #include <arm_neon.h>
+    #endif
+#endif
+
+/* Begin globally disabled warnings. */
+#if defined(_MSC_VER)
+    #pragma warning(push)
+    #pragma warning(disable:4752)   /* found Intel(R) Advanced Vector Extensions; consider using /arch:AVX */
+    #pragma warning(disable:4049)   /* compiler limit : terminating line number emission */
+#endif
+
+#if defined(MA_X64) || defined(MA_X86)
+    #if defined(_MSC_VER) && !defined(__clang__)
+        #if _MSC_VER >= 1400
+            #include <intrin.h>
+            static MA_INLINE void ma_cpuid(int info[4], int fid)
+            {
+                __cpuid(info, fid);
+            }
+        #else
+            #define MA_NO_CPUID
+        #endif
+
+        #if _MSC_VER >= 1600 && (defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 160040219)
+            static MA_INLINE unsigned __int64 ma_xgetbv(int reg)
+            {
+                return _xgetbv(reg);
+            }
+        #else
+            #define MA_NO_XGETBV
+        #endif
+    #elif (defined(__GNUC__) || defined(__clang__)) && !defined(MA_ANDROID)
+        static MA_INLINE void ma_cpuid(int info[4], int fid)
+        {
+            /*
+            It looks like the -fPIC option uses the ebx register which GCC complains about. We can work around this by just using a different register, the
+            specific register of which I'm letting the compiler decide on. The "k" prefix is used to specify a 32-bit register. The {...} syntax is for
+            supporting different assembly dialects.
+
+            What's basically happening is that we're saving and restoring the ebx register manually.
+            */
+            #if defined(MA_X86) && defined(__PIC__)
+                __asm__ __volatile__ (
+                    "xchg{l} {%%}ebx, %k1;"
+                    "cpuid;"
+                    "xchg{l} {%%}ebx, %k1;"
+                    : "=a"(info[0]), "=&r"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0)
+                );
+            #else
+                __asm__ __volatile__ (
+                    "cpuid" : "=a"(info[0]), "=b"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0)
+                );
+            #endif
+        }
+
+        static MA_INLINE ma_uint64 ma_xgetbv(int reg)
+        {
+            unsigned int hi;
+            unsigned int lo;
+
+            __asm__ __volatile__ (
+                "xgetbv" : "=a"(lo), "=d"(hi) : "c"(reg)
+            );
+
+            return ((ma_uint64)hi << 32) | (ma_uint64)lo;
+        }
+    #else
+        #define MA_NO_CPUID
+        #define MA_NO_XGETBV
+    #endif
+#else
+    #define MA_NO_CPUID
+    #define MA_NO_XGETBV
+#endif
+
+static MA_INLINE ma_bool32 ma_has_sse2(void)
+{
+#if defined(MA_SUPPORT_SSE2)
+    #if (defined(MA_X64) || defined(MA_X86)) && !defined(MA_NO_SSE2)
+        #if defined(MA_X64)
+            return MA_TRUE;    /* 64-bit targets always support SSE2. */
+        #elif (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE2__)
+            return MA_TRUE;    /* If the compiler is allowed to freely generate SSE2 code we can assume support. */
+        #else
+            #if defined(MA_NO_CPUID)
+                return MA_FALSE;
+            #else
+                int info[4];
+                ma_cpuid(info, 1);
+                return (info[3] & (1 << 26)) != 0;
+            #endif
+        #endif
+    #else
+        return MA_FALSE;       /* SSE2 is only supported on x86 and x64 architectures. */
+    #endif
+#else
+    return MA_FALSE;           /* No compiler support. */
+#endif
+}
+
+#if 0
+static MA_INLINE ma_bool32 ma_has_avx()
+{
+#if defined(MA_SUPPORT_AVX)
+    #if (defined(MA_X64) || defined(MA_X86)) && !defined(MA_NO_AVX)
+        #if defined(_AVX_) || defined(__AVX__)
+            return MA_TRUE;    /* If the compiler is allowed to freely generate AVX code we can assume support. */
+        #else
+            /* AVX requires both CPU and OS support. */
+            #if defined(MA_NO_CPUID) || defined(MA_NO_XGETBV)
+                return MA_FALSE;
+            #else
+                int info[4];
+                ma_cpuid(info, 1);
+                if (((info[2] & (1 << 27)) != 0) && ((info[2] & (1 << 28)) != 0)) {
+                    ma_uint64 xrc = ma_xgetbv(0);
+                    if ((xrc & 0x06) == 0x06) {
+                        return MA_TRUE;
+                    } else {
+                        return MA_FALSE;
+                    }
+                } else {
+                    return MA_FALSE;
+                }
+            #endif
+        #endif
+    #else
+        return MA_FALSE;       /* AVX is only supported on x86 and x64 architectures. */
+    #endif
+#else
+    return MA_FALSE;           /* No compiler support. */
+#endif
+}
+#endif
+
+static MA_INLINE ma_bool32 ma_has_avx2(void)
+{
+#if defined(MA_SUPPORT_AVX2)
+    #if (defined(MA_X64) || defined(MA_X86)) && !defined(MA_NO_AVX2)
+        #if defined(_AVX2_) || defined(__AVX2__)
+            return MA_TRUE;    /* If the compiler is allowed to freely generate AVX2 code we can assume support. */
+        #else
+            /* AVX2 requires both CPU and OS support. */
+            #if defined(MA_NO_CPUID) || defined(MA_NO_XGETBV)
+                return MA_FALSE;
+            #else
+                int info1[4];
+                int info7[4];
+                ma_cpuid(info1, 1);
+                ma_cpuid(info7, 7);
+                if (((info1[2] & (1 << 27)) != 0) && ((info7[1] & (1 << 5)) != 0)) {
+                    ma_uint64 xrc = ma_xgetbv(0);
+                    if ((xrc & 0x06) == 0x06) {
+                        return MA_TRUE;
+                    } else {
+                        return MA_FALSE;
+                    }
+                } else {
+                    return MA_FALSE;
+                }
+            #endif
+        #endif
+    #else
+        return MA_FALSE;       /* AVX2 is only supported on x86 and x64 architectures. */
+    #endif
+#else
+    return MA_FALSE;           /* No compiler support. */
+#endif
+}
+
+static MA_INLINE ma_bool32 ma_has_neon(void)
+{
+#if defined(MA_SUPPORT_NEON)
+    #if defined(MA_ARM) && !defined(MA_NO_NEON)
+        #if (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
+            return MA_TRUE;    /* If the compiler is allowed to freely generate NEON code we can assume support. */
+        #else
+            /* TODO: Runtime check. */
+            return MA_FALSE;
+        #endif
+    #else
+        return MA_FALSE;       /* NEON is only supported on ARM architectures. */
+    #endif
+#else
+    return MA_FALSE;           /* No compiler support. */
+#endif
+}
+
+#if defined(__has_builtin)
+    #define MA_COMPILER_HAS_BUILTIN(x) __has_builtin(x)
+#else
+    #define MA_COMPILER_HAS_BUILTIN(x) 0
+#endif
+
+#ifndef MA_ASSUME
+    #if MA_COMPILER_HAS_BUILTIN(__builtin_assume)
+        #define MA_ASSUME(x) __builtin_assume(x)
+    #elif MA_COMPILER_HAS_BUILTIN(__builtin_unreachable)
+        #define MA_ASSUME(x) do { if (!(x)) __builtin_unreachable(); } while (0)
+    #elif defined(_MSC_VER)
+        #define MA_ASSUME(x) __assume(x)
+    #else
+        #define MA_ASSUME(x) (void)(x)
+    #endif
+#endif
+
+#ifndef MA_RESTRICT
+    #if defined(__clang__) || defined(__GNUC__) || defined(_MSC_VER)
+        #define MA_RESTRICT __restrict
+    #else
+        #define MA_RESTRICT
+    #endif
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    #define MA_HAS_BYTESWAP16_INTRINSIC
+    #define MA_HAS_BYTESWAP32_INTRINSIC
+    #define MA_HAS_BYTESWAP64_INTRINSIC
+#elif defined(__clang__)
+    #if MA_COMPILER_HAS_BUILTIN(__builtin_bswap16)
+        #define MA_HAS_BYTESWAP16_INTRINSIC
+    #endif
+    #if MA_COMPILER_HAS_BUILTIN(__builtin_bswap32)
+        #define MA_HAS_BYTESWAP32_INTRINSIC
+    #endif
+    #if MA_COMPILER_HAS_BUILTIN(__builtin_bswap64)
+        #define MA_HAS_BYTESWAP64_INTRINSIC
+    #endif
+#elif defined(__GNUC__)
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+        #define MA_HAS_BYTESWAP32_INTRINSIC
+        #define MA_HAS_BYTESWAP64_INTRINSIC
+    #endif
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+        #define MA_HAS_BYTESWAP16_INTRINSIC
+    #endif
+#endif
+
+
+static MA_INLINE ma_bool32 ma_is_little_endian(void)
+{
+#if defined(MA_X86) || defined(MA_X64)
+    return MA_TRUE;
+#else
+    int n = 1;
+    return (*(char*)&n) == 1;
+#endif
+}
+
+static MA_INLINE ma_bool32 ma_is_big_endian(void)
+{
+    return !ma_is_little_endian();
+}
+
+
+static MA_INLINE ma_uint32 ma_swap_endian_uint32(ma_uint32 n)
+{
+#ifdef MA_HAS_BYTESWAP32_INTRINSIC
+    #if defined(_MSC_VER)
+        return _byteswap_ulong(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        #if defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(MA_64BIT)   /* <-- 64-bit inline assembly has not been tested, so disabling for now. */
+            /* Inline assembly optimized implementation for ARM. In my testing, GCC does not generate optimized code with __builtin_bswap32(). */
+            ma_uint32 r;
+            __asm__ __volatile__ (
+            #if defined(MA_64BIT)
+                "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n)   /* <-- This is untested. If someone in the community could test this, that would be appreciated! */
+            #else
+                "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n)
+            #endif
+            );
+            return r;
+        #else
+            return __builtin_bswap32(n);
+        #endif
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & 0xFF000000) >> 24) |
+           ((n & 0x00FF0000) >>  8) |
+           ((n & 0x0000FF00) <<  8) |
+           ((n & 0x000000FF) << 24);
+#endif
+}
+
+
+#if !defined(MA_EMSCRIPTEN)
+#ifdef MA_WIN32
+static void ma_sleep__win32(ma_uint32 milliseconds)
+{
+    Sleep((DWORD)milliseconds);
+}
+#endif
+#ifdef MA_POSIX
+static void ma_sleep__posix(ma_uint32 milliseconds)
+{
+#ifdef MA_EMSCRIPTEN
+    (void)milliseconds;
+    MA_ASSERT(MA_FALSE);  /* The Emscripten build should never sleep. */
+#else
+    #if (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309L) || defined(MA_NX)
+        struct timespec ts;
+        ts.tv_sec  = milliseconds / 1000;
+        ts.tv_nsec = milliseconds % 1000 * 1000000;
+        nanosleep(&ts, NULL);
+    #else
+        struct timeval tv;
+        tv.tv_sec  = milliseconds / 1000;
+        tv.tv_usec = milliseconds % 1000 * 1000;
+        select(0, NULL, NULL, NULL, &tv);
+    #endif
+#endif
+}
+#endif
+
+static MA_INLINE void ma_sleep(ma_uint32 milliseconds)
+{
+#ifdef MA_WIN32
+    ma_sleep__win32(milliseconds);
+#endif
+#ifdef MA_POSIX
+    ma_sleep__posix(milliseconds);
+#endif
+}
+#endif
+
+static MA_INLINE void ma_yield(void)
+{
+#if defined(__i386) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64)
+    /* x86/x64 */
+    #if (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__DMC__)) && !defined(__clang__)
+        #if _MSC_VER >= 1400
+            _mm_pause();
+        #else
+            #if defined(__DMC__)
+                /* Digital Mars does not recognize the PAUSE opcode. Fall back to NOP. */
+                __asm nop;
+            #else
+                __asm pause;
+            #endif
+        #endif
+    #else
+        __asm__ __volatile__ ("pause");
+    #endif
+#elif (defined(__arm__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7) || defined(_M_ARM64) || (defined(_M_ARM) && _M_ARM >= 7) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6T2__)
+    /* ARM */
+    #if defined(_MSC_VER)
+        /* Apparently there is a __yield() intrinsic that's compatible with ARM, but I cannot find documentation for it nor can I find where it's declared. */
+        __yield();
+    #else
+        __asm__ __volatile__ ("yield"); /* ARMv6K/ARMv6T2 and above. */
+    #endif
+#else
+    /* Unknown or unsupported architecture. No-op. */
+#endif
+}
+
+
+#define MA_MM_DENORMALS_ZERO_MASK   0x0040
+#define MA_MM_FLUSH_ZERO_MASK       0x8000
+
+static MA_INLINE unsigned int ma_disable_denormals(void)
+{
+    unsigned int prevState;
+
+    #if defined(_MSC_VER)
+    {
+        /*
+        Older versions of Visual Studio don't support the "safe" versions of _controlfp_s(). I don't
+        know which version of Visual Studio first added support for _controlfp_s(), but I do know
+        that VC6 lacks support. _MSC_VER = 1200 is VC6, but if you get compilation errors on older
+        versions of Visual Studio, let me know and I'll make the necessary adjustment.
+        */
+        #if _MSC_VER <= 1200
+        {
+            prevState = _statusfp();
+            _controlfp(prevState | _DN_FLUSH, _MCW_DN);
+        }
+        #else
+        {
+            unsigned int unused;
+            _controlfp_s(&prevState, 0, 0);
+            _controlfp_s(&unused, prevState | _DN_FLUSH, _MCW_DN);
+        }
+        #endif
+    }
+    #elif defined(MA_X86) || defined(MA_X64)
+    {
+        #if defined(__SSE2__) && !(defined(__TINYC__) || defined(__WATCOMC__) || defined(__COSMOPOLITAN__)) /* <-- Add compilers that lack support for _mm_getcsr() and _mm_setcsr() to this list. */
+        {
+            prevState = _mm_getcsr();
+            _mm_setcsr(prevState | MA_MM_DENORMALS_ZERO_MASK | MA_MM_FLUSH_ZERO_MASK);
+        }
+        #else
+        {
+            /* x88/64, but no support for _mm_getcsr()/_mm_setcsr(). May need to fall back to inlined assembly here. */
+            prevState = 0;
+        }
+        #endif
+    }
+    #else
+    {
+        /* Unknown or unsupported architecture. No-op. */
+        prevState = 0;
+    }
+    #endif
+
+    return prevState;
+}
+
+static MA_INLINE void ma_restore_denormals(unsigned int prevState)
+{
+    #if defined(_MSC_VER)
+    {
+        /* Older versions of Visual Studio do not support _controlfp_s(). See ma_disable_denormals(). */
+        #if _MSC_VER <= 1200
+        {
+            _controlfp(prevState, _MCW_DN);
+        }
+        #else
+        {
+            unsigned int unused;
+            _controlfp_s(&unused, prevState, _MCW_DN);
+        }
+        #endif
+    }
+    #elif defined(MA_X86) || defined(MA_X64)
+    {
+        #if defined(__SSE2__) && !(defined(__TINYC__) || defined(__WATCOMC__) || defined(__COSMOPOLITAN__))   /* <-- Add compilers that lack support for _mm_getcsr() and _mm_setcsr() to this list. */
+        {
+            _mm_setcsr(prevState);
+        }
+        #else
+        {
+            /* x88/64, but no support for _mm_getcsr()/_mm_setcsr(). May need to fall back to inlined assembly here. */
+            (void)prevState;
+        }
+        #endif
+    }
+    #else
+    {
+        /* Unknown or unsupported architecture. No-op. */
+        (void)prevState;
+    }
+    #endif
+}
+
+
+#ifdef MA_ANDROID
+#include <sys/system_properties.h>
+
+int ma_android_sdk_version()
+{
+    char sdkVersion[PROP_VALUE_MAX + 1] = {0, };
+    if (__system_property_get("ro.build.version.sdk", sdkVersion)) {
+        return atoi(sdkVersion);
+    }
+
+    return 0;
+}
+#endif
+
+
+#ifndef MA_COINIT_VALUE
+#define MA_COINIT_VALUE    0   /* 0 = COINIT_MULTITHREADED */
+#endif
+
+
+#ifndef MA_FLT_MAX
+    #ifdef FLT_MAX
+        #define MA_FLT_MAX FLT_MAX
+    #else
+        #define MA_FLT_MAX 3.402823466e+38F
+    #endif
+#endif
+
+
+#ifndef MA_PI
+#define MA_PI      3.14159265358979323846264f
+#endif
+#ifndef MA_PI_D
+#define MA_PI_D    3.14159265358979323846264
+#endif
+#ifndef MA_TAU
+#define MA_TAU     6.28318530717958647693f
+#endif
+#ifndef MA_TAU_D
+#define MA_TAU_D   6.28318530717958647693
+#endif
+
+
+/* The default format when ma_format_unknown (0) is requested when initializing a device. */
+#ifndef MA_DEFAULT_FORMAT
+#define MA_DEFAULT_FORMAT                                   ma_format_f32
+#endif
+
+/* The default channel count to use when 0 is used when initializing a device. */
+#ifndef MA_DEFAULT_CHANNELS
+#define MA_DEFAULT_CHANNELS                                 2
+#endif
+
+/* The default sample rate to use when 0 is used when initializing a device. */
+#ifndef MA_DEFAULT_SAMPLE_RATE
+#define MA_DEFAULT_SAMPLE_RATE                              48000
+#endif
+
+/* Default periods when none is specified in ma_device_init(). More periods means more work on the CPU. */
+#ifndef MA_DEFAULT_PERIODS
+#define MA_DEFAULT_PERIODS                                  3
+#endif
+
+/* The default period size in milliseconds for low latency mode. */
+#ifndef MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY
+#define MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY  10
+#endif
+
+/* The default buffer size in milliseconds for conservative mode. */
+#ifndef MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE
+#define MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE 100
+#endif
+
+/* The default LPF filter order for linear resampling. Note that this is clamped to MA_MAX_FILTER_ORDER. */
+#ifndef MA_DEFAULT_RESAMPLER_LPF_ORDER
+    #if MA_MAX_FILTER_ORDER >= 4
+        #define MA_DEFAULT_RESAMPLER_LPF_ORDER  4
+    #else
+        #define MA_DEFAULT_RESAMPLER_LPF_ORDER  MA_MAX_FILTER_ORDER
+    #endif
+#endif
+
+
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+/* Standard sample rates, in order of priority. */
+static ma_uint32 g_maStandardSampleRatePriorities[] = {
+    (ma_uint32)ma_standard_sample_rate_48000,
+    (ma_uint32)ma_standard_sample_rate_44100,
+
+    (ma_uint32)ma_standard_sample_rate_32000,
+    (ma_uint32)ma_standard_sample_rate_24000,
+    (ma_uint32)ma_standard_sample_rate_22050,
+
+    (ma_uint32)ma_standard_sample_rate_88200,
+    (ma_uint32)ma_standard_sample_rate_96000,
+    (ma_uint32)ma_standard_sample_rate_176400,
+    (ma_uint32)ma_standard_sample_rate_192000,
+
+    (ma_uint32)ma_standard_sample_rate_16000,
+    (ma_uint32)ma_standard_sample_rate_11025,
+    (ma_uint32)ma_standard_sample_rate_8000,
+
+    (ma_uint32)ma_standard_sample_rate_352800,
+    (ma_uint32)ma_standard_sample_rate_384000
+};
+
+static MA_INLINE ma_bool32 ma_is_standard_sample_rate(ma_uint32 sampleRate)
+{
+    ma_uint32 iSampleRate;
+
+    for (iSampleRate = 0; iSampleRate < sizeof(g_maStandardSampleRatePriorities) / sizeof(g_maStandardSampleRatePriorities[0]); iSampleRate += 1) {
+        if (g_maStandardSampleRatePriorities[iSampleRate] == sampleRate) {
+            return MA_TRUE;
+        }
+    }
+
+    /* Getting here means the sample rate is not supported. */
+    return MA_FALSE;
+}
+
+
+static ma_format g_maFormatPriorities[] = {
+    ma_format_s16,         /* Most common */
+    ma_format_f32,
+
+    /*ma_format_s24_32,*/    /* Clean alignment */
+    ma_format_s32,
+
+    ma_format_s24,         /* Unclean alignment */
+
+    ma_format_u8           /* Low quality */
+};
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic pop
+#endif
+
+
+MA_API void ma_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision)
+{
+    if (pMajor) {
+        *pMajor = MA_VERSION_MAJOR;
+    }
+
+    if (pMinor) {
+        *pMinor = MA_VERSION_MINOR;
+    }
+
+    if (pRevision) {
+        *pRevision = MA_VERSION_REVISION;
+    }
+}
+
+MA_API const char* ma_version_string(void)
+{
+    return MA_VERSION_STRING;
+}
+
+
+/******************************************************************************
+
+Standard Library Stuff
+
+******************************************************************************/
+#ifndef MA_ASSERT
+#define MA_ASSERT(condition)            assert(condition)
+#endif
+
+#ifndef MA_MALLOC
+#define MA_MALLOC(sz)                   malloc((sz))
+#endif
+#ifndef MA_REALLOC
+#define MA_REALLOC(p, sz)               realloc((p), (sz))
+#endif
+#ifndef MA_FREE
+#define MA_FREE(p)                      free((p))
+#endif
+
+static MA_INLINE void ma_zero_memory_default(void* p, size_t sz)
+{
+    if (p == NULL) {
+        MA_ASSERT(sz == 0); /* If this is triggered there's an error with the calling code. */
+        return;
+    }
+
+    if (sz > 0) {
+        memset(p, 0, sz);
+    }
+}
+
+
+#ifndef MA_ZERO_MEMORY
+#define MA_ZERO_MEMORY(p, sz)           ma_zero_memory_default((p), (sz))
+#endif
+#ifndef MA_COPY_MEMORY
+#define MA_COPY_MEMORY(dst, src, sz)    memcpy((dst), (src), (sz))
+#endif
+#ifndef MA_MOVE_MEMORY
+#define MA_MOVE_MEMORY(dst, src, sz)    memmove((dst), (src), (sz))
+#endif
+
+#define MA_ZERO_OBJECT(p)               MA_ZERO_MEMORY((p), sizeof(*(p)))
+
+#define ma_countof(x)                   (sizeof(x) / sizeof(x[0]))
+#define ma_max(x, y)                    (((x) > (y)) ? (x) : (y))
+#define ma_min(x, y)                    (((x) < (y)) ? (x) : (y))
+#define ma_abs(x)                       (((x) > 0) ? (x) : -(x))
+#define ma_clamp(x, lo, hi)             (ma_max(lo, ma_min(x, hi)))
+#define ma_offset_ptr(p, offset)        (((ma_uint8*)(p)) + (offset))
+#define ma_align(x, a)                  (((x) + ((a)-1)) & ~((a)-1))
+#define ma_align_64(x)                  ma_align(x, 8)
+
+#define ma_buffer_frame_capacity(buffer, channels, format) (sizeof(buffer) / ma_get_bytes_per_sample(format) / (channels))
+
+static MA_INLINE double ma_sind(double x)
+{
+    /* TODO: Implement custom sin(x). */
+    return sin(x);
+}
+
+static MA_INLINE double ma_expd(double x)
+{
+    /* TODO: Implement custom exp(x). */
+    return exp(x);
+}
+
+static MA_INLINE double ma_logd(double x)
+{
+    /* TODO: Implement custom log(x). */
+    return log(x);
+}
+
+static MA_INLINE double ma_powd(double x, double y)
+{
+    /* TODO: Implement custom pow(x, y). */
+    return pow(x, y);
+}
+
+static MA_INLINE double ma_sqrtd(double x)
+{
+    /* TODO: Implement custom sqrt(x). */
+    return sqrt(x);
+}
+
+
+static MA_INLINE float ma_rsqrtf(float x)
+{
+    #if defined(MA_SUPPORT_SSE2) && !defined(MA_NO_SSE2) && (defined(MA_X64) || (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE2__))
+    {
+        /*
+        For SSE we can use RSQRTSS.
+
+        This Stack Overflow post suggests that compilers don't necessarily generate optimal code
+        when using intrinsics:
+
+            https://web.archive.org/web/20221211012522/https://stackoverflow.com/questions/32687079/getting-fewest-instructions-for-rsqrtss-wrapper
+
+        I'm going to do something similar here, but a bit simpler.
+        */
+        #if defined(__GNUC__) || defined(__clang__)
+        {
+            float result;
+            __asm__ __volatile__("rsqrtss %1, %0" : "=x"(result) : "x"(x));
+            return result;
+        }
+        #else
+        {
+            return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ps1(x)));
+        }
+        #endif
+    }
+    #else
+    {
+        return 1 / (float)ma_sqrtd(x);
+    }
+    #endif
+}
+
+
+static MA_INLINE float ma_sinf(float x)
+{
+    return (float)ma_sind((float)x);
+}
+
+static MA_INLINE double ma_cosd(double x)
+{
+    return ma_sind((MA_PI_D*0.5) - x);
+}
+
+static MA_INLINE float ma_cosf(float x)
+{
+    return (float)ma_cosd((float)x);
+}
+
+static MA_INLINE double ma_log10d(double x)
+{
+    return ma_logd(x) * 0.43429448190325182765;
+}
+
+static MA_INLINE float ma_powf(float x, float y)
+{
+    return (float)ma_powd((double)x, (double)y);
+}
+
+static MA_INLINE float ma_log10f(float x)
+{
+    return (float)ma_log10d((double)x);
+}
+
+
+static MA_INLINE double ma_degrees_to_radians(double degrees)
+{
+    return degrees * 0.01745329252;
+}
+
+static MA_INLINE double ma_radians_to_degrees(double radians)
+{
+    return radians * 57.295779512896;
+}
+
+static MA_INLINE float ma_degrees_to_radians_f(float degrees)
+{
+    return degrees * 0.01745329252f;
+}
+
+static MA_INLINE float ma_radians_to_degrees_f(float radians)
+{
+    return radians * 57.295779512896f;
+}
+
+
+/*
+Return Values:
+  0:  Success
+  22: EINVAL
+  34: ERANGE
+
+Not using symbolic constants for errors because I want to avoid #including errno.h
+
+These are marked as no-inline because of some bad code generation by Clang. None of these functions
+are used in any performance-critical code within miniaudio.
+*/
+MA_API MA_NO_INLINE int ma_strcpy_s(char* dst, size_t dstSizeInBytes, const char* src)
+{
+    size_t i;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstSizeInBytes == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    for (i = 0; i < dstSizeInBytes && src[i] != '\0'; ++i) {
+        dst[i] = src[i];
+    }
+
+    if (i < dstSizeInBytes) {
+        dst[i] = '\0';
+        return 0;
+    }
+
+    dst[0] = '\0';
+    return 34;
+}
+
+MA_API MA_NO_INLINE int ma_wcscpy_s(wchar_t* dst, size_t dstCap, const wchar_t* src)
+{
+    size_t i;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstCap == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    for (i = 0; i < dstCap && src[i] != '\0'; ++i) {
+        dst[i] = src[i];
+    }
+
+    if (i < dstCap) {
+        dst[i] = '\0';
+        return 0;
+    }
+
+    dst[0] = '\0';
+    return 34;
+}
+
+
+MA_API MA_NO_INLINE int ma_strncpy_s(char* dst, size_t dstSizeInBytes, const char* src, size_t count)
+{
+    size_t maxcount;
+    size_t i;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstSizeInBytes == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    maxcount = count;
+    if (count == ((size_t)-1) || count >= dstSizeInBytes) {        /* -1 = _TRUNCATE */
+        maxcount = dstSizeInBytes - 1;
+    }
+
+    for (i = 0; i < maxcount && src[i] != '\0'; ++i) {
+        dst[i] = src[i];
+    }
+
+    if (src[i] == '\0' || i == count || count == ((size_t)-1)) {
+        dst[i] = '\0';
+        return 0;
+    }
+
+    dst[0] = '\0';
+    return 34;
+}
+
+MA_API MA_NO_INLINE int ma_strcat_s(char* dst, size_t dstSizeInBytes, const char* src)
+{
+    char* dstorig;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstSizeInBytes == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    dstorig = dst;
+
+    while (dstSizeInBytes > 0 && dst[0] != '\0') {
+        dst += 1;
+        dstSizeInBytes -= 1;
+    }
+
+    if (dstSizeInBytes == 0) {
+        return 22;  /* Unterminated. */
+    }
+
+
+    while (dstSizeInBytes > 0 && src[0] != '\0') {
+        *dst++ = *src++;
+        dstSizeInBytes -= 1;
+    }
+
+    if (dstSizeInBytes > 0) {
+        dst[0] = '\0';
+    } else {
+        dstorig[0] = '\0';
+        return 34;
+    }
+
+    return 0;
+}
+
+MA_API MA_NO_INLINE int ma_strncat_s(char* dst, size_t dstSizeInBytes, const char* src, size_t count)
+{
+    char* dstorig;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstSizeInBytes == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        return 22;
+    }
+
+    dstorig = dst;
+
+    while (dstSizeInBytes > 0 && dst[0] != '\0') {
+        dst += 1;
+        dstSizeInBytes -= 1;
+    }
+
+    if (dstSizeInBytes == 0) {
+        return 22;  /* Unterminated. */
+    }
+
+
+    if (count == ((size_t)-1)) {        /* _TRUNCATE */
+        count = dstSizeInBytes - 1;
+    }
+
+    while (dstSizeInBytes > 0 && src[0] != '\0' && count > 0) {
+        *dst++ = *src++;
+        dstSizeInBytes -= 1;
+        count -= 1;
+    }
+
+    if (dstSizeInBytes > 0) {
+        dst[0] = '\0';
+    } else {
+        dstorig[0] = '\0';
+        return 34;
+    }
+
+    return 0;
+}
+
+MA_API MA_NO_INLINE int ma_itoa_s(int value, char* dst, size_t dstSizeInBytes, int radix)
+{
+    int sign;
+    unsigned int valueU;
+    char* dstEnd;
+
+    if (dst == NULL || dstSizeInBytes == 0) {
+        return 22;
+    }
+    if (radix < 2 || radix > 36) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    sign = (value < 0 && radix == 10) ? -1 : 1;     /* The negative sign is only used when the base is 10. */
+
+    if (value < 0) {
+        valueU = -value;
+    } else {
+        valueU = value;
+    }
+
+    dstEnd = dst;
+    do
+    {
+        int remainder = valueU % radix;
+        if (remainder > 9) {
+            *dstEnd = (char)((remainder - 10) + 'a');
+        } else {
+            *dstEnd = (char)(remainder + '0');
+        }
+
+        dstEnd += 1;
+        dstSizeInBytes -= 1;
+        valueU /= radix;
+    } while (dstSizeInBytes > 0 && valueU > 0);
+
+    if (dstSizeInBytes == 0) {
+        dst[0] = '\0';
+        return 22;  /* Ran out of room in the output buffer. */
+    }
+
+    if (sign < 0) {
+        *dstEnd++ = '-';
+        dstSizeInBytes -= 1;
+    }
+
+    if (dstSizeInBytes == 0) {
+        dst[0] = '\0';
+        return 22;  /* Ran out of room in the output buffer. */
+    }
+
+    *dstEnd = '\0';
+
+
+    /* At this point the string will be reversed. */
+    dstEnd -= 1;
+    while (dst < dstEnd) {
+        char temp = *dst;
+        *dst = *dstEnd;
+        *dstEnd = temp;
+
+        dst += 1;
+        dstEnd -= 1;
+    }
+
+    return 0;
+}
+
+MA_API MA_NO_INLINE int ma_strcmp(const char* str1, const char* str2)
+{
+    if (str1 == str2) return  0;
+
+    /* These checks differ from the standard implementation. It's not important, but I prefer it just for sanity. */
+    if (str1 == NULL) return -1;
+    if (str2 == NULL) return  1;
+
+    for (;;) {
+        if (str1[0] == '\0') {
+            break;
+        }
+        if (str1[0] != str2[0]) {
+            break;
+        }
+
+        str1 += 1;
+        str2 += 1;
+    }
+
+    return ((unsigned char*)str1)[0] - ((unsigned char*)str2)[0];
+}
+
+MA_API MA_NO_INLINE int ma_strappend(char* dst, size_t dstSize, const char* srcA, const char* srcB)
+{
+    int result;
+
+    result = ma_strncpy_s(dst, dstSize, srcA, (size_t)-1);
+    if (result != 0) {
+        return result;
+    }
+
+    result = ma_strncat_s(dst, dstSize, srcB, (size_t)-1);
+    if (result != 0) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API MA_NO_INLINE char* ma_copy_string(const char* src, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    size_t sz;
+    char* dst;
+
+    if (src == NULL) {
+        return NULL;
+    }
+
+    sz = strlen(src)+1;
+    dst = (char*)ma_malloc(sz, pAllocationCallbacks);
+    if (dst == NULL) {
+        return NULL;
+    }
+
+    ma_strcpy_s(dst, sz, src);
+
+    return dst;
+}
+
+MA_API MA_NO_INLINE wchar_t* ma_copy_string_w(const wchar_t* src, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    size_t sz = wcslen(src)+1;
+    wchar_t* dst = (wchar_t*)ma_malloc(sz * sizeof(*dst), pAllocationCallbacks);
+    if (dst == NULL) {
+        return NULL;
+    }
+
+    ma_wcscpy_s(dst, sz, src);
+
+    return dst;
+}
+
+
+
+#include <errno.h>
+static ma_result ma_result_from_errno(int e)
+{
+    if (e == 0) {
+        return MA_SUCCESS;
+    }
+#ifdef EPERM
+    else if (e == EPERM) { return MA_INVALID_OPERATION; }
+#endif
+#ifdef ENOENT
+    else if (e == ENOENT) { return MA_DOES_NOT_EXIST; }
+#endif
+#ifdef ESRCH
+    else if (e == ESRCH) { return MA_DOES_NOT_EXIST; }
+#endif
+#ifdef EINTR
+    else if (e == EINTR) { return MA_INTERRUPT; }
+#endif
+#ifdef EIO
+    else if (e == EIO) { return MA_IO_ERROR; }
+#endif
+#ifdef ENXIO
+    else if (e == ENXIO) { return MA_DOES_NOT_EXIST; }
+#endif
+#ifdef E2BIG
+    else if (e == E2BIG) { return MA_INVALID_ARGS; }
+#endif
+#ifdef ENOEXEC
+    else if (e == ENOEXEC) { return MA_INVALID_FILE; }
+#endif
+#ifdef EBADF
+    else if (e == EBADF) { return MA_INVALID_FILE; }
+#endif
+#ifdef ECHILD
+    else if (e == ECHILD) { return MA_ERROR; }
+#endif
+#ifdef EAGAIN
+    else if (e == EAGAIN) { return MA_UNAVAILABLE; }
+#endif
+#ifdef ENOMEM
+    else if (e == ENOMEM) { return MA_OUT_OF_MEMORY; }
+#endif
+#ifdef EACCES
+    else if (e == EACCES) { return MA_ACCESS_DENIED; }
+#endif
+#ifdef EFAULT
+    else if (e == EFAULT) { return MA_BAD_ADDRESS; }
+#endif
+#ifdef ENOTBLK
+    else if (e == ENOTBLK) { return MA_ERROR; }
+#endif
+#ifdef EBUSY
+    else if (e == EBUSY) { return MA_BUSY; }
+#endif
+#ifdef EEXIST
+    else if (e == EEXIST) { return MA_ALREADY_EXISTS; }
+#endif
+#ifdef EXDEV
+    else if (e == EXDEV) { return MA_ERROR; }
+#endif
+#ifdef ENODEV
+    else if (e == ENODEV) { return MA_DOES_NOT_EXIST; }
+#endif
+#ifdef ENOTDIR
+    else if (e == ENOTDIR) { return MA_NOT_DIRECTORY; }
+#endif
+#ifdef EISDIR
+    else if (e == EISDIR) { return MA_IS_DIRECTORY; }
+#endif
+#ifdef EINVAL
+    else if (e == EINVAL) { return MA_INVALID_ARGS; }
+#endif
+#ifdef ENFILE
+    else if (e == ENFILE) { return MA_TOO_MANY_OPEN_FILES; }
+#endif
+#ifdef EMFILE
+    else if (e == EMFILE) { return MA_TOO_MANY_OPEN_FILES; }
+#endif
+#ifdef ENOTTY
+    else if (e == ENOTTY) { return MA_INVALID_OPERATION; }
+#endif
+#ifdef ETXTBSY
+    else if (e == ETXTBSY) { return MA_BUSY; }
+#endif
+#ifdef EFBIG
+    else if (e == EFBIG) { return MA_TOO_BIG; }
+#endif
+#ifdef ENOSPC
+    else if (e == ENOSPC) { return MA_NO_SPACE; }
+#endif
+#ifdef ESPIPE
+    else if (e == ESPIPE) { return MA_BAD_SEEK; }
+#endif
+#ifdef EROFS
+    else if (e == EROFS) { return MA_ACCESS_DENIED; }
+#endif
+#ifdef EMLINK
+    else if (e == EMLINK) { return MA_TOO_MANY_LINKS; }
+#endif
+#ifdef EPIPE
+    else if (e == EPIPE) { return MA_BAD_PIPE; }
+#endif
+#ifdef EDOM
+    else if (e == EDOM) { return MA_OUT_OF_RANGE; }
+#endif
+#ifdef ERANGE
+    else if (e == ERANGE) { return MA_OUT_OF_RANGE; }
+#endif
+#ifdef EDEADLK
+    else if (e == EDEADLK) { return MA_DEADLOCK; }
+#endif
+#ifdef ENAMETOOLONG
+    else if (e == ENAMETOOLONG) { return MA_PATH_TOO_LONG; }
+#endif
+#ifdef ENOLCK
+    else if (e == ENOLCK) { return MA_ERROR; }
+#endif
+#ifdef ENOSYS
+    else if (e == ENOSYS) { return MA_NOT_IMPLEMENTED; }
+#endif
+#ifdef ENOTEMPTY
+    else if (e == ENOTEMPTY) { return MA_DIRECTORY_NOT_EMPTY; }
+#endif
+#ifdef ELOOP
+    else if (e == ELOOP) { return MA_TOO_MANY_LINKS; }
+#endif
+#ifdef ENOMSG
+    else if (e == ENOMSG) { return MA_NO_MESSAGE; }
+#endif
+#ifdef EIDRM
+    else if (e == EIDRM) { return MA_ERROR; }
+#endif
+#ifdef ECHRNG
+    else if (e == ECHRNG) { return MA_ERROR; }
+#endif
+#ifdef EL2NSYNC
+    else if (e == EL2NSYNC) { return MA_ERROR; }
+#endif
+#ifdef EL3HLT
+    else if (e == EL3HLT) { return MA_ERROR; }
+#endif
+#ifdef EL3RST
+    else if (e == EL3RST) { return MA_ERROR; }
+#endif
+#ifdef ELNRNG
+    else if (e == ELNRNG) { return MA_OUT_OF_RANGE; }
+#endif
+#ifdef EUNATCH
+    else if (e == EUNATCH) { return MA_ERROR; }
+#endif
+#ifdef ENOCSI
+    else if (e == ENOCSI) { return MA_ERROR; }
+#endif
+#ifdef EL2HLT
+    else if (e == EL2HLT) { return MA_ERROR; }
+#endif
+#ifdef EBADE
+    else if (e == EBADE) { return MA_ERROR; }
+#endif
+#ifdef EBADR
+    else if (e == EBADR) { return MA_ERROR; }
+#endif
+#ifdef EXFULL
+    else if (e == EXFULL) { return MA_ERROR; }
+#endif
+#ifdef ENOANO
+    else if (e == ENOANO) { return MA_ERROR; }
+#endif
+#ifdef EBADRQC
+    else if (e == EBADRQC) { return MA_ERROR; }
+#endif
+#ifdef EBADSLT
+    else if (e == EBADSLT) { return MA_ERROR; }
+#endif
+#ifdef EBFONT
+    else if (e == EBFONT) { return MA_INVALID_FILE; }
+#endif
+#ifdef ENOSTR
+    else if (e == ENOSTR) { return MA_ERROR; }
+#endif
+#ifdef ENODATA
+    else if (e == ENODATA) { return MA_NO_DATA_AVAILABLE; }
+#endif
+#ifdef ETIME
+    else if (e == ETIME) { return MA_TIMEOUT; }
+#endif
+#ifdef ENOSR
+    else if (e == ENOSR) { return MA_NO_DATA_AVAILABLE; }
+#endif
+#ifdef ENONET
+    else if (e == ENONET) { return MA_NO_NETWORK; }
+#endif
+#ifdef ENOPKG
+    else if (e == ENOPKG) { return MA_ERROR; }
+#endif
+#ifdef EREMOTE
+    else if (e == EREMOTE) { return MA_ERROR; }
+#endif
+#ifdef ENOLINK
+    else if (e == ENOLINK) { return MA_ERROR; }
+#endif
+#ifdef EADV
+    else if (e == EADV) { return MA_ERROR; }
+#endif
+#ifdef ESRMNT
+    else if (e == ESRMNT) { return MA_ERROR; }
+#endif
+#ifdef ECOMM
+    else if (e == ECOMM) { return MA_ERROR; }
+#endif
+#ifdef EPROTO
+    else if (e == EPROTO) { return MA_ERROR; }
+#endif
+#ifdef EMULTIHOP
+    else if (e == EMULTIHOP) { return MA_ERROR; }
+#endif
+#ifdef EDOTDOT
+    else if (e == EDOTDOT) { return MA_ERROR; }
+#endif
+#ifdef EBADMSG
+    else if (e == EBADMSG) { return MA_BAD_MESSAGE; }
+#endif
+#ifdef EOVERFLOW
+    else if (e == EOVERFLOW) { return MA_TOO_BIG; }
+#endif
+#ifdef ENOTUNIQ
+    else if (e == ENOTUNIQ) { return MA_NOT_UNIQUE; }
+#endif
+#ifdef EBADFD
+    else if (e == EBADFD) { return MA_ERROR; }
+#endif
+#ifdef EREMCHG
+    else if (e == EREMCHG) { return MA_ERROR; }
+#endif
+#ifdef ELIBACC
+    else if (e == ELIBACC) { return MA_ACCESS_DENIED; }
+#endif
+#ifdef ELIBBAD
+    else if (e == ELIBBAD) { return MA_INVALID_FILE; }
+#endif
+#ifdef ELIBSCN
+    else if (e == ELIBSCN) { return MA_INVALID_FILE; }
+#endif
+#ifdef ELIBMAX
+    else if (e == ELIBMAX) { return MA_ERROR; }
+#endif
+#ifdef ELIBEXEC
+    else if (e == ELIBEXEC) { return MA_ERROR; }
+#endif
+#ifdef EILSEQ
+    else if (e == EILSEQ) { return MA_INVALID_DATA; }
+#endif
+#ifdef ERESTART
+    else if (e == ERESTART) { return MA_ERROR; }
+#endif
+#ifdef ESTRPIPE
+    else if (e == ESTRPIPE) { return MA_ERROR; }
+#endif
+#ifdef EUSERS
+    else if (e == EUSERS) { return MA_ERROR; }
+#endif
+#ifdef ENOTSOCK
+    else if (e == ENOTSOCK) { return MA_NOT_SOCKET; }
+#endif
+#ifdef EDESTADDRREQ
+    else if (e == EDESTADDRREQ) { return MA_NO_ADDRESS; }
+#endif
+#ifdef EMSGSIZE
+    else if (e == EMSGSIZE) { return MA_TOO_BIG; }
+#endif
+#ifdef EPROTOTYPE
+    else if (e == EPROTOTYPE) { return MA_BAD_PROTOCOL; }
+#endif
+#ifdef ENOPROTOOPT
+    else if (e == ENOPROTOOPT) { return MA_PROTOCOL_UNAVAILABLE; }
+#endif
+#ifdef EPROTONOSUPPORT
+    else if (e == EPROTONOSUPPORT) { return MA_PROTOCOL_NOT_SUPPORTED; }
+#endif
+#ifdef ESOCKTNOSUPPORT
+    else if (e == ESOCKTNOSUPPORT) { return MA_SOCKET_NOT_SUPPORTED; }
+#endif
+#ifdef EOPNOTSUPP
+    else if (e == EOPNOTSUPP) { return MA_INVALID_OPERATION; }
+#endif
+#ifdef EPFNOSUPPORT
+    else if (e == EPFNOSUPPORT) { return MA_PROTOCOL_FAMILY_NOT_SUPPORTED; }
+#endif
+#ifdef EAFNOSUPPORT
+    else if (e == EAFNOSUPPORT) { return MA_ADDRESS_FAMILY_NOT_SUPPORTED; }
+#endif
+#ifdef EADDRINUSE
+    else if (e == EADDRINUSE) { return MA_ALREADY_IN_USE; }
+#endif
+#ifdef EADDRNOTAVAIL
+    else if (e == EADDRNOTAVAIL) { return MA_ERROR; }
+#endif
+#ifdef ENETDOWN
+    else if (e == ENETDOWN) { return MA_NO_NETWORK; }
+#endif
+#ifdef ENETUNREACH
+    else if (e == ENETUNREACH) { return MA_NO_NETWORK; }
+#endif
+#ifdef ENETRESET
+    else if (e == ENETRESET) { return MA_NO_NETWORK; }
+#endif
+#ifdef ECONNABORTED
+    else if (e == ECONNABORTED) { return MA_NO_NETWORK; }
+#endif
+#ifdef ECONNRESET
+    else if (e == ECONNRESET) { return MA_CONNECTION_RESET; }
+#endif
+#ifdef ENOBUFS
+    else if (e == ENOBUFS) { return MA_NO_SPACE; }
+#endif
+#ifdef EISCONN
+    else if (e == EISCONN) { return MA_ALREADY_CONNECTED; }
+#endif
+#ifdef ENOTCONN
+    else if (e == ENOTCONN) { return MA_NOT_CONNECTED; }
+#endif
+#ifdef ESHUTDOWN
+    else if (e == ESHUTDOWN) { return MA_ERROR; }
+#endif
+#ifdef ETOOMANYREFS
+    else if (e == ETOOMANYREFS) { return MA_ERROR; }
+#endif
+#ifdef ETIMEDOUT
+    else if (e == ETIMEDOUT) { return MA_TIMEOUT; }
+#endif
+#ifdef ECONNREFUSED
+    else if (e == ECONNREFUSED) { return MA_CONNECTION_REFUSED; }
+#endif
+#ifdef EHOSTDOWN
+    else if (e == EHOSTDOWN) { return MA_NO_HOST; }
+#endif
+#ifdef EHOSTUNREACH
+    else if (e == EHOSTUNREACH) { return MA_NO_HOST; }
+#endif
+#ifdef EALREADY
+    else if (e == EALREADY) { return MA_IN_PROGRESS; }
+#endif
+#ifdef EINPROGRESS
+    else if (e == EINPROGRESS) { return MA_IN_PROGRESS; }
+#endif
+#ifdef ESTALE
+    else if (e == ESTALE) { return MA_INVALID_FILE; }
+#endif
+#ifdef EUCLEAN
+    else if (e == EUCLEAN) { return MA_ERROR; }
+#endif
+#ifdef ENOTNAM
+    else if (e == ENOTNAM) { return MA_ERROR; }
+#endif
+#ifdef ENAVAIL
+    else if (e == ENAVAIL) { return MA_ERROR; }
+#endif
+#ifdef EISNAM
+    else if (e == EISNAM) { return MA_ERROR; }
+#endif
+#ifdef EREMOTEIO
+    else if (e == EREMOTEIO) { return MA_IO_ERROR; }
+#endif
+#ifdef EDQUOT
+    else if (e == EDQUOT) { return MA_NO_SPACE; }
+#endif
+#ifdef ENOMEDIUM
+    else if (e == ENOMEDIUM) { return MA_DOES_NOT_EXIST; }
+#endif
+#ifdef EMEDIUMTYPE
+    else if (e == EMEDIUMTYPE) { return MA_ERROR; }
+#endif
+#ifdef ECANCELED
+    else if (e == ECANCELED) { return MA_CANCELLED; }
+#endif
+#ifdef ENOKEY
+    else if (e == ENOKEY) { return MA_ERROR; }
+#endif
+#ifdef EKEYEXPIRED
+    else if (e == EKEYEXPIRED) { return MA_ERROR; }
+#endif
+#ifdef EKEYREVOKED
+    else if (e == EKEYREVOKED) { return MA_ERROR; }
+#endif
+#ifdef EKEYREJECTED
+    else if (e == EKEYREJECTED) { return MA_ERROR; }
+#endif
+#ifdef EOWNERDEAD
+    else if (e == EOWNERDEAD) { return MA_ERROR; }
+#endif
+#ifdef ENOTRECOVERABLE
+    else if (e == ENOTRECOVERABLE) { return MA_ERROR; }
+#endif
+#ifdef ERFKILL
+    else if (e == ERFKILL) { return MA_ERROR; }
+#endif
+#ifdef EHWPOISON
+    else if (e == EHWPOISON) { return MA_ERROR; }
+#endif
+    else {
+        return MA_ERROR;
+    }
+}
+
+MA_API ma_result ma_fopen(FILE** ppFile, const char* pFilePath, const char* pOpenMode)
+{
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    errno_t err;
+#endif
+
+    if (ppFile != NULL) {
+        *ppFile = NULL;  /* Safety. */
+    }
+
+    if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    err = fopen_s(ppFile, pFilePath, pOpenMode);
+    if (err != 0) {
+        return ma_result_from_errno(err);
+    }
+#else
+#if defined(_WIN32) || defined(__APPLE__)
+    *ppFile = fopen(pFilePath, pOpenMode);
+#else
+    #if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64 && defined(_LARGEFILE64_SOURCE)
+        *ppFile = fopen64(pFilePath, pOpenMode);
+    #else
+        *ppFile = fopen(pFilePath, pOpenMode);
+    #endif
+#endif
+    if (*ppFile == NULL) {
+        ma_result result = ma_result_from_errno(errno);
+        if (result == MA_SUCCESS) {
+            result = MA_ERROR;   /* Just a safety check to make sure we never ever return success when pFile == NULL. */
+        }
+
+        return result;
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+
+
+/*
+_wfopen() isn't always available in all compilation environments.
+
+    * Windows only.
+    * MSVC seems to support it universally as far back as VC6 from what I can tell (haven't checked further back).
+    * MinGW-64 (both 32- and 64-bit) seems to support it.
+    * MinGW wraps it in !defined(__STRICT_ANSI__).
+    * OpenWatcom wraps it in !defined(_NO_EXT_KEYS).
+
+This can be reviewed as compatibility issues arise. The preference is to use _wfopen_s() and _wfopen() as opposed to the wcsrtombs()
+fallback, so if you notice your compiler not detecting this properly I'm happy to look at adding support.
+*/
+#if defined(_WIN32)
+    #if defined(_MSC_VER) || defined(__MINGW64__) || (!defined(__STRICT_ANSI__) && !defined(_NO_EXT_KEYS))
+        #define MA_HAS_WFOPEN
+    #endif
+#endif
+
+MA_API ma_result ma_wfopen(FILE** ppFile, const wchar_t* pFilePath, const wchar_t* pOpenMode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (ppFile != NULL) {
+        *ppFile = NULL;  /* Safety. */
+    }
+
+    if (pFilePath == NULL || pOpenMode == NULL || ppFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_HAS_WFOPEN)
+    {
+        /* Use _wfopen() on Windows. */
+    #if defined(_MSC_VER) && _MSC_VER >= 1400
+        errno_t err = _wfopen_s(ppFile, pFilePath, pOpenMode);
+        if (err != 0) {
+            return ma_result_from_errno(err);
+        }
+    #else
+        *ppFile = _wfopen(pFilePath, pOpenMode);
+        if (*ppFile == NULL) {
+            return ma_result_from_errno(errno);
+        }
+    #endif
+        (void)pAllocationCallbacks;
+    }
+#else
+    /*
+    Use fopen() on anything other than Windows. Requires a conversion. This is annoying because fopen() is locale specific. The only real way I can
+    think of to do this is with wcsrtombs(). Note that wcstombs() is apparently not thread-safe because it uses a static global mbstate_t object for
+    maintaining state. I've checked this with -std=c89 and it works, but if somebody get's a compiler error I'll look into improving compatibility.
+    */
+    {
+        mbstate_t mbs;
+        size_t lenMB;
+        const wchar_t* pFilePathTemp = pFilePath;
+        char* pFilePathMB = NULL;
+        char pOpenModeMB[32] = {0};
+
+        /* Get the length first. */
+        MA_ZERO_OBJECT(&mbs);
+        lenMB = wcsrtombs(NULL, &pFilePathTemp, 0, &mbs);
+        if (lenMB == (size_t)-1) {
+            return ma_result_from_errno(errno);
+        }
+
+        pFilePathMB = (char*)ma_malloc(lenMB + 1, pAllocationCallbacks);
+        if (pFilePathMB == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        pFilePathTemp = pFilePath;
+        MA_ZERO_OBJECT(&mbs);
+        wcsrtombs(pFilePathMB, &pFilePathTemp, lenMB + 1, &mbs);
+
+        /* The open mode should always consist of ASCII characters so we should be able to do a trivial conversion. */
+        {
+            size_t i = 0;
+            for (;;) {
+                if (pOpenMode[i] == 0) {
+                    pOpenModeMB[i] = '\0';
+                    break;
+                }
+
+                pOpenModeMB[i] = (char)pOpenMode[i];
+                i += 1;
+            }
+        }
+
+        *ppFile = fopen(pFilePathMB, pOpenModeMB);
+
+        ma_free(pFilePathMB, pAllocationCallbacks);
+    }
+
+    if (*ppFile == NULL) {
+        return MA_ERROR;
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+
+
+static MA_INLINE void ma_copy_memory_64(void* dst, const void* src, ma_uint64 sizeInBytes)
+{
+#if 0xFFFFFFFFFFFFFFFF <= MA_SIZE_MAX
+    MA_COPY_MEMORY(dst, src, (size_t)sizeInBytes);
+#else
+    while (sizeInBytes > 0) {
+        ma_uint64 bytesToCopyNow = sizeInBytes;
+        if (bytesToCopyNow > MA_SIZE_MAX) {
+            bytesToCopyNow = MA_SIZE_MAX;
+        }
+
+        MA_COPY_MEMORY(dst, src, (size_t)bytesToCopyNow);  /* Safe cast to size_t. */
+
+        sizeInBytes -= bytesToCopyNow;
+        dst = (      void*)((      ma_uint8*)dst + bytesToCopyNow);
+        src = (const void*)((const ma_uint8*)src + bytesToCopyNow);
+    }
+#endif
+}
+
+static MA_INLINE void ma_zero_memory_64(void* dst, ma_uint64 sizeInBytes)
+{
+#if 0xFFFFFFFFFFFFFFFF <= MA_SIZE_MAX
+    MA_ZERO_MEMORY(dst, (size_t)sizeInBytes);
+#else
+    while (sizeInBytes > 0) {
+        ma_uint64 bytesToZeroNow = sizeInBytes;
+        if (bytesToZeroNow > MA_SIZE_MAX) {
+            bytesToZeroNow = MA_SIZE_MAX;
+        }
+
+        MA_ZERO_MEMORY(dst, (size_t)bytesToZeroNow);  /* Safe cast to size_t. */
+
+        sizeInBytes -= bytesToZeroNow;
+        dst = (void*)((ma_uint8*)dst + bytesToZeroNow);
+    }
+#endif
+}
+
+
+/* Thanks to good old Bit Twiddling Hacks for this one: http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2 */
+static MA_INLINE unsigned int ma_next_power_of_2(unsigned int x)
+{
+    x--;
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+    x++;
+
+    return x;
+}
+
+static MA_INLINE unsigned int ma_prev_power_of_2(unsigned int x)
+{
+    return ma_next_power_of_2(x) >> 1;
+}
+
+static MA_INLINE unsigned int ma_round_to_power_of_2(unsigned int x)
+{
+    unsigned int prev = ma_prev_power_of_2(x);
+    unsigned int next = ma_next_power_of_2(x);
+    if ((next - x) > (x - prev)) {
+        return prev;
+    } else {
+        return next;
+    }
+}
+
+static MA_INLINE unsigned int ma_count_set_bits(unsigned int x)
+{
+    unsigned int count = 0;
+    while (x != 0) {
+        if (x & 1) {
+            count += 1;
+        }
+
+        x = x >> 1;
+    }
+
+    return count;
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Allocation Callbacks
+
+**************************************************************************************************************************************************************/
+static void* ma__malloc_default(size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_MALLOC(sz);
+}
+
+static void* ma__realloc_default(void* p, size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_REALLOC(p, sz);
+}
+
+static void ma__free_default(void* p, void* pUserData)
+{
+    (void)pUserData;
+    MA_FREE(p);
+}
+
+static ma_allocation_callbacks ma_allocation_callbacks_init_default(void)
+{
+    ma_allocation_callbacks callbacks;
+    callbacks.pUserData = NULL;
+    callbacks.onMalloc  = ma__malloc_default;
+    callbacks.onRealloc = ma__realloc_default;
+    callbacks.onFree    = ma__free_default;
+
+    return callbacks;
+}
+
+static ma_result ma_allocation_callbacks_init_copy(ma_allocation_callbacks* pDst, const ma_allocation_callbacks* pSrc)
+{
+    if (pDst == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pSrc == NULL) {
+        *pDst = ma_allocation_callbacks_init_default();
+    } else {
+        if (pSrc->pUserData == NULL && pSrc->onFree == NULL && pSrc->onMalloc == NULL && pSrc->onRealloc == NULL) {
+            *pDst = ma_allocation_callbacks_init_default();
+        } else {
+            if (pSrc->onFree == NULL || (pSrc->onMalloc == NULL && pSrc->onRealloc == NULL)) {
+                return MA_INVALID_ARGS;    /* Invalid allocation callbacks. */
+            } else {
+                *pDst = *pSrc;
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+
+/**************************************************************************************************************************************************************
+
+Logging
+
+**************************************************************************************************************************************************************/
+MA_API const char* ma_log_level_to_string(ma_uint32 logLevel)
+{
+    switch (logLevel)
+    {
+        case MA_LOG_LEVEL_DEBUG:   return "DEBUG";
+        case MA_LOG_LEVEL_INFO:    return "INFO";
+        case MA_LOG_LEVEL_WARNING: return "WARNING";
+        case MA_LOG_LEVEL_ERROR:   return "ERROR";
+        default:                   return "ERROR";
+    }
+}
+
+#if defined(MA_DEBUG_OUTPUT)
+#if defined(MA_ANDROID)
+    #include <android/log.h>
+#endif
+
+/* Customize this to use a specific tag in __android_log_print() for debug output messages. */
+#ifndef MA_ANDROID_LOG_TAG
+#define MA_ANDROID_LOG_TAG  "miniaudio"
+#endif
+
+void ma_log_callback_debug(void* pUserData, ma_uint32 level, const char* pMessage)
+{
+    (void)pUserData;
+
+    /* Special handling for some platforms. */
+    #if defined(MA_ANDROID)
+    {
+        /* Android. */
+        __android_log_print(ANDROID_LOG_DEBUG, MA_ANDROID_LOG_TAG, "%s: %s", ma_log_level_to_string(level), pMessage);
+    }
+    #else
+    {
+        /* Everything else. */
+        printf("%s: %s", ma_log_level_to_string(level), pMessage);
+    }
+    #endif
+}
+#endif
+
+MA_API ma_log_callback ma_log_callback_init(ma_log_callback_proc onLog, void* pUserData)
+{
+    ma_log_callback callback;
+
+    MA_ZERO_OBJECT(&callback);
+    callback.onLog     = onLog;
+    callback.pUserData = pUserData;
+
+    return callback;
+}
+
+
+MA_API ma_result ma_log_init(const ma_allocation_callbacks* pAllocationCallbacks, ma_log* pLog)
+{
+    if (pLog == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLog);
+    ma_allocation_callbacks_init_copy(&pLog->allocationCallbacks, pAllocationCallbacks);
+
+    /* We need a mutex for thread safety. */
+    #ifndef MA_NO_THREADING
+    {
+        ma_result result = ma_mutex_init(&pLog->lock);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+    #endif
+
+    /* If we're using debug output, enable it. */
+    #if defined(MA_DEBUG_OUTPUT)
+    {
+        ma_log_register_callback(pLog, ma_log_callback_init(ma_log_callback_debug, NULL)); /* Doesn't really matter if this fails. */
+    }
+    #endif
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_log_uninit(ma_log* pLog)
+{
+    if (pLog == NULL) {
+        return;
+    }
+
+#ifndef MA_NO_THREADING
+    ma_mutex_uninit(&pLog->lock);
+#endif
+}
+
+static void ma_log_lock(ma_log* pLog)
+{
+#ifndef MA_NO_THREADING
+    ma_mutex_lock(&pLog->lock);
+#else
+    (void)pLog;
+#endif
+}
+
+static void ma_log_unlock(ma_log* pLog)
+{
+#ifndef MA_NO_THREADING
+    ma_mutex_unlock(&pLog->lock);
+#else
+    (void)pLog;
+#endif
+}
+
+MA_API ma_result ma_log_register_callback(ma_log* pLog, ma_log_callback callback)
+{
+    ma_result result = MA_SUCCESS;
+
+    if (pLog == NULL || callback.onLog == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_log_lock(pLog);
+    {
+        if (pLog->callbackCount == ma_countof(pLog->callbacks)) {
+            result = MA_OUT_OF_MEMORY;  /* Reached the maximum allowed log callbacks. */
+        } else {
+            pLog->callbacks[pLog->callbackCount] = callback;
+            pLog->callbackCount += 1;
+        }
+    }
+    ma_log_unlock(pLog);
+
+    return result;
+}
+
+MA_API ma_result ma_log_unregister_callback(ma_log* pLog, ma_log_callback callback)
+{
+    if (pLog == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_log_lock(pLog);
+    {
+        ma_uint32 iLog;
+        for (iLog = 0; iLog < pLog->callbackCount; ) {
+            if (pLog->callbacks[iLog].onLog == callback.onLog) {
+                /* Found. Move everything down a slot. */
+                ma_uint32 jLog;
+                for (jLog = iLog; jLog < pLog->callbackCount-1; jLog += 1) {
+                    pLog->callbacks[jLog] = pLog->callbacks[jLog + 1];
+                }
+
+                pLog->callbackCount -= 1;
+            } else {
+                /* Not found. */
+                iLog += 1;
+            }
+        }
+    }
+    ma_log_unlock(pLog);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_log_post(ma_log* pLog, ma_uint32 level, const char* pMessage)
+{
+    if (pLog == NULL || pMessage == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_log_lock(pLog);
+    {
+        ma_uint32 iLog;
+        for (iLog = 0; iLog < pLog->callbackCount; iLog += 1) {
+            if (pLog->callbacks[iLog].onLog) {
+                pLog->callbacks[iLog].onLog(pLog->callbacks[iLog].pUserData, level, pMessage);
+            }
+        }
+    }
+    ma_log_unlock(pLog);
+
+    return MA_SUCCESS;
+}
+
+
+/*
+We need to emulate _vscprintf() for the VC6 build. This can be more efficient, but since it's only VC6, and it's just a
+logging function, I'm happy to keep this simple. In the VC6 build we can implement this in terms of _vsnprintf().
+*/
+#if defined(_MSC_VER) && _MSC_VER < 1900
+static int ma_vscprintf(const ma_allocation_callbacks* pAllocationCallbacks, const char* format, va_list args)
+{
+#if _MSC_VER > 1200
+    return _vscprintf(format, args);
+#else
+    int result;
+    char* pTempBuffer = NULL;
+    size_t tempBufferCap = 1024;
+
+    if (format == NULL) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    for (;;) {
+        char* pNewTempBuffer = (char*)ma_realloc(pTempBuffer, tempBufferCap, pAllocationCallbacks);
+        if (pNewTempBuffer == NULL) {
+            ma_free(pTempBuffer, pAllocationCallbacks);
+            errno = ENOMEM;
+            return -1;  /* Out of memory. */
+        }
+
+        pTempBuffer = pNewTempBuffer;
+
+        result = _vsnprintf(pTempBuffer, tempBufferCap, format, args);
+        ma_free(pTempBuffer, NULL);
+
+        if (result != -1) {
+            break;  /* Got it. */
+        }
+
+        /* Buffer wasn't big enough. Ideally it'd be nice to use an error code to know the reason for sure, but this is reliable enough. */
+        tempBufferCap *= 2;
+    }
+
+    return result;
+#endif
+}
+#endif
+
+MA_API ma_result ma_log_postv(ma_log* pLog, ma_uint32 level, const char* pFormat, va_list args)
+{
+    if (pLog == NULL || pFormat == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || ((!defined(_MSC_VER) || _MSC_VER >= 1900) && !defined(__STRICT_ANSI__) && !defined(_NO_EXT_KEYS)) || (defined(__cplusplus) && __cplusplus >= 201103L)
+    {
+        ma_result result;
+        int length;
+        char  pFormattedMessageStack[1024];
+        char* pFormattedMessageHeap = NULL;
+
+        /* First try formatting into our fixed sized stack allocated buffer. If this is too small we'll fallback to a heap allocation. */
+        length = vsnprintf(pFormattedMessageStack, sizeof(pFormattedMessageStack), pFormat, args);
+        if (length < 0) {
+            return MA_INVALID_OPERATION;    /* An error occurred when trying to convert the buffer. */
+        }
+
+        if ((size_t)length < sizeof(pFormattedMessageStack)) {
+            /* The string was written to the stack. */
+            result = ma_log_post(pLog, level, pFormattedMessageStack);
+        } else {
+            /* The stack buffer was too small, try the heap. */
+            pFormattedMessageHeap = (char*)ma_malloc(length + 1, &pLog->allocationCallbacks);
+            if (pFormattedMessageHeap == NULL) {
+                return MA_OUT_OF_MEMORY;
+            }
+
+            length = vsnprintf(pFormattedMessageHeap, length + 1, pFormat, args);
+            if (length < 0) {
+                ma_free(pFormattedMessageHeap, &pLog->allocationCallbacks);
+                return MA_INVALID_OPERATION;
+            }
+
+            result = ma_log_post(pLog, level, pFormattedMessageHeap);
+            ma_free(pFormattedMessageHeap, &pLog->allocationCallbacks);
+        }
+
+        return result;
+    }
+    #else
+    {
+        /*
+        Without snprintf() we need to first measure the string and then heap allocate it. I'm only aware of Visual Studio having support for this without snprintf(), so we'll
+        need to restrict this branch to Visual Studio. For other compilers we need to just not support formatted logging because I don't want the security risk of overflowing
+        a fixed sized stack allocated buffer.
+        */
+        #if defined(_MSC_VER) && _MSC_VER >= 1200   /* 1200 = VC6 */
+        {
+            ma_result result;
+            int formattedLen;
+            char* pFormattedMessage = NULL;
+            va_list args2;
+
+            #if _MSC_VER >= 1800
+            {
+                va_copy(args2, args);
+            }
+            #else
+            {
+                args2 = args;
+            }
+            #endif
+
+            formattedLen = ma_vscprintf(&pLog->allocationCallbacks, pFormat, args2);
+            va_end(args2);
+
+            if (formattedLen <= 0) {
+                return MA_INVALID_OPERATION;
+            }
+
+            pFormattedMessage = (char*)ma_malloc(formattedLen + 1, &pLog->allocationCallbacks);
+            if (pFormattedMessage == NULL) {
+                return MA_OUT_OF_MEMORY;
+            }
+
+            /* We'll get errors on newer versions of Visual Studio if we try to use vsprintf().  */
+            #if _MSC_VER >= 1400    /* 1400 = Visual Studio 2005 */
+            {
+                vsprintf_s(pFormattedMessage, formattedLen + 1, pFormat, args);
+            }
+            #else
+            {
+                vsprintf(pFormattedMessage, pFormat, args);
+            }
+            #endif
+
+            result = ma_log_post(pLog, level, pFormattedMessage);
+            ma_free(pFormattedMessage, &pLog->allocationCallbacks);
+
+            return result;
+        }
+        #else
+        {
+            /* Can't do anything because we don't have a safe way of to emulate vsnprintf() without a manual solution. */
+            (void)level;
+            (void)args;
+
+            return MA_INVALID_OPERATION;
+        }
+        #endif
+    }
+    #endif
+}
+
+MA_API ma_result ma_log_postf(ma_log* pLog, ma_uint32 level, const char* pFormat, ...)
+{
+    ma_result result;
+    va_list args;
+
+    if (pLog == NULL || pFormat == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    va_start(args, pFormat);
+    {
+        result = ma_log_postv(pLog, level, pFormat, args);
+    }
+    va_end(args);
+
+    return result;
+}
+
+
+
+static MA_INLINE ma_uint8 ma_clip_u8(ma_int32 x)
+{
+    return (ma_uint8)(ma_clamp(x, -128, 127) + 128);
+}
+
+static MA_INLINE ma_int16 ma_clip_s16(ma_int32 x)
+{
+    return (ma_int16)ma_clamp(x, -32768, 32767);
+}
+
+static MA_INLINE ma_int64 ma_clip_s24(ma_int64 x)
+{
+    return (ma_int64)ma_clamp(x, -8388608, 8388607);
+}
+
+static MA_INLINE ma_int32 ma_clip_s32(ma_int64 x)
+{
+    /* This dance is to silence warnings with -std=c89. A good compiler should be able to optimize this away. */
+    ma_int64 clipMin;
+    ma_int64 clipMax;
+    clipMin = -((ma_int64)2147483647 + 1);
+    clipMax =   (ma_int64)2147483647;
+
+    return (ma_int32)ma_clamp(x, clipMin, clipMax);
+}
+
+static MA_INLINE float ma_clip_f32(float x)
+{
+    if (x < -1) return -1;
+    if (x > +1) return +1;
+    return x;
+}
+
+
+static MA_INLINE float ma_mix_f32(float x, float y, float a)
+{
+    return x*(1-a) + y*a;
+}
+static MA_INLINE float ma_mix_f32_fast(float x, float y, float a)
+{
+    float r0 = (y - x);
+    float r1 = r0*a;
+    return x + r1;
+    /*return x + (y - x)*a;*/
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE __m128 ma_mix_f32_fast__sse2(__m128 x, __m128 y, __m128 a)
+{
+    return _mm_add_ps(x, _mm_mul_ps(_mm_sub_ps(y, x), a));
+}
+#endif
+#if defined(MA_SUPPORT_AVX2)
+static MA_INLINE __m256 ma_mix_f32_fast__avx2(__m256 x, __m256 y, __m256 a)
+{
+    return _mm256_add_ps(x, _mm256_mul_ps(_mm256_sub_ps(y, x), a));
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE float32x4_t ma_mix_f32_fast__neon(float32x4_t x, float32x4_t y, float32x4_t a)
+{
+    return vaddq_f32(x, vmulq_f32(vsubq_f32(y, x), a));
+}
+#endif
+
+
+static MA_INLINE double ma_mix_f64(double x, double y, double a)
+{
+    return x*(1-a) + y*a;
+}
+static MA_INLINE double ma_mix_f64_fast(double x, double y, double a)
+{
+    return x + (y - x)*a;
+}
+
+static MA_INLINE float ma_scale_to_range_f32(float x, float lo, float hi)
+{
+    return lo + x*(hi-lo);
+}
+
+
+/*
+Greatest common factor using Euclid's algorithm iteratively.
+*/
+static MA_INLINE ma_uint32 ma_gcf_u32(ma_uint32 a, ma_uint32 b)
+{
+    for (;;) {
+        if (b == 0) {
+            break;
+        } else {
+            ma_uint32 t = a;
+            a = b;
+            b = t % a;
+        }
+    }
+
+    return a;
+}
+
+
+static ma_uint32 ma_ffs_32(ma_uint32 x)
+{
+    ma_uint32 i;
+
+    /* Just a naive implementation just to get things working for now. Will optimize this later. */
+    for (i = 0; i < 32; i += 1) {
+        if ((x & (1 << i)) != 0) {
+            return i;
+        }
+    }
+
+    return i;
+}
+
+static MA_INLINE ma_int16 ma_float_to_fixed_16(float x)
+{
+    return (ma_int16)(x * (1 << 8));
+}
+
+
+
+/*
+Random Number Generation
+
+miniaudio uses the LCG random number generation algorithm. This is good enough for audio.
+
+Note that miniaudio's global LCG implementation uses global state which is _not_ thread-local. When this is called across
+multiple threads, results will be unpredictable. However, it won't crash and results will still be random enough for
+miniaudio's purposes.
+*/
+#ifndef MA_DEFAULT_LCG_SEED
+#define MA_DEFAULT_LCG_SEED 4321
+#endif
+
+#define MA_LCG_M   2147483647
+#define MA_LCG_A   48271
+#define MA_LCG_C   0
+
+static ma_lcg g_maLCG = {MA_DEFAULT_LCG_SEED}; /* Non-zero initial seed. Use ma_seed() to use an explicit seed. */
+
+static MA_INLINE void ma_lcg_seed(ma_lcg* pLCG, ma_int32 seed)
+{
+    MA_ASSERT(pLCG != NULL);
+    pLCG->state = seed;
+}
+
+static MA_INLINE ma_int32 ma_lcg_rand_s32(ma_lcg* pLCG)
+{
+    pLCG->state = (MA_LCG_A * pLCG->state + MA_LCG_C) % MA_LCG_M;
+    return pLCG->state;
+}
+
+static MA_INLINE ma_uint32 ma_lcg_rand_u32(ma_lcg* pLCG)
+{
+    return (ma_uint32)ma_lcg_rand_s32(pLCG);
+}
+
+static MA_INLINE ma_int16 ma_lcg_rand_s16(ma_lcg* pLCG)
+{
+    return (ma_int16)(ma_lcg_rand_s32(pLCG) & 0xFFFF);
+}
+
+static MA_INLINE double ma_lcg_rand_f64(ma_lcg* pLCG)
+{
+    return ma_lcg_rand_s32(pLCG) / (double)0x7FFFFFFF;
+}
+
+static MA_INLINE float ma_lcg_rand_f32(ma_lcg* pLCG)
+{
+    return (float)ma_lcg_rand_f64(pLCG);
+}
+
+static MA_INLINE float ma_lcg_rand_range_f32(ma_lcg* pLCG, float lo, float hi)
+{
+    return ma_scale_to_range_f32(ma_lcg_rand_f32(pLCG), lo, hi);
+}
+
+static MA_INLINE ma_int32 ma_lcg_rand_range_s32(ma_lcg* pLCG, ma_int32 lo, ma_int32 hi)
+{
+    if (lo == hi) {
+        return lo;
+    }
+
+    return lo + ma_lcg_rand_u32(pLCG) / (0xFFFFFFFF / (hi - lo + 1) + 1);
+}
+
+
+
+static MA_INLINE void ma_seed(ma_int32 seed)
+{
+    ma_lcg_seed(&g_maLCG, seed);
+}
+
+static MA_INLINE ma_int32 ma_rand_s32(void)
+{
+    return ma_lcg_rand_s32(&g_maLCG);
+}
+
+static MA_INLINE ma_uint32 ma_rand_u32(void)
+{
+    return ma_lcg_rand_u32(&g_maLCG);
+}
+
+static MA_INLINE double ma_rand_f64(void)
+{
+    return ma_lcg_rand_f64(&g_maLCG);
+}
+
+static MA_INLINE float ma_rand_f32(void)
+{
+    return ma_lcg_rand_f32(&g_maLCG);
+}
+
+static MA_INLINE float ma_rand_range_f32(float lo, float hi)
+{
+    return ma_lcg_rand_range_f32(&g_maLCG, lo, hi);
+}
+
+static MA_INLINE ma_int32 ma_rand_range_s32(ma_int32 lo, ma_int32 hi)
+{
+    return ma_lcg_rand_range_s32(&g_maLCG, lo, hi);
+}
+
+
+static MA_INLINE float ma_dither_f32_rectangle(float ditherMin, float ditherMax)
+{
+    return ma_rand_range_f32(ditherMin, ditherMax);
+}
+
+static MA_INLINE float ma_dither_f32_triangle(float ditherMin, float ditherMax)
+{
+    float a = ma_rand_range_f32(ditherMin, 0);
+    float b = ma_rand_range_f32(0, ditherMax);
+    return a + b;
+}
+
+static MA_INLINE float ma_dither_f32(ma_dither_mode ditherMode, float ditherMin, float ditherMax)
+{
+    if (ditherMode == ma_dither_mode_rectangle) {
+        return ma_dither_f32_rectangle(ditherMin, ditherMax);
+    }
+    if (ditherMode == ma_dither_mode_triangle) {
+        return ma_dither_f32_triangle(ditherMin, ditherMax);
+    }
+
+    return 0;
+}
+
+static MA_INLINE ma_int32 ma_dither_s32(ma_dither_mode ditherMode, ma_int32 ditherMin, ma_int32 ditherMax)
+{
+    if (ditherMode == ma_dither_mode_rectangle) {
+        ma_int32 a = ma_rand_range_s32(ditherMin, ditherMax);
+        return a;
+    }
+    if (ditherMode == ma_dither_mode_triangle) {
+        ma_int32 a = ma_rand_range_s32(ditherMin, 0);
+        ma_int32 b = ma_rand_range_s32(0, ditherMax);
+        return a + b;
+    }
+
+    return 0;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Atomics
+
+**************************************************************************************************************************************************************/
+/* ma_atomic.h begin */
+#ifndef ma_atomic_h
+#if defined(__cplusplus)
+extern "C" {
+#endif
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wlong-long"
+    #if defined(__clang__)
+        #pragma GCC diagnostic ignored "-Wc++11-long-long"
+    #endif
+#endif
+typedef int ma_atomic_memory_order;
+#define MA_ATOMIC_HAS_8
+#define MA_ATOMIC_HAS_16
+#define MA_ATOMIC_HAS_32
+#define MA_ATOMIC_HAS_64
+#if (defined(_MSC_VER) ) || defined(__WATCOMC__) || defined(__DMC__)
+    #define MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, intrin, ma_atomicType, msvcType)   \
+        ma_atomicType result; \
+        switch (order) \
+        { \
+            case ma_atomic_memory_order_relaxed: \
+            { \
+                result = (ma_atomicType)intrin##_nf((volatile msvcType*)dst, (msvcType)src); \
+            } break; \
+            case ma_atomic_memory_order_consume: \
+            case ma_atomic_memory_order_acquire: \
+            { \
+                result = (ma_atomicType)intrin##_acq((volatile msvcType*)dst, (msvcType)src); \
+            } break; \
+            case ma_atomic_memory_order_release: \
+            { \
+                result = (ma_atomicType)intrin##_rel((volatile msvcType*)dst, (msvcType)src); \
+            } break; \
+            case ma_atomic_memory_order_acq_rel: \
+            case ma_atomic_memory_order_seq_cst: \
+            default: \
+            { \
+                result = (ma_atomicType)intrin((volatile msvcType*)dst, (msvcType)src); \
+            } break; \
+        } \
+        return result;
+    #define MA_ATOMIC_MSVC_ARM_INTRINSIC_COMPARE_EXCHANGE(ptr, expected, desired, order, intrin, ma_atomicType, msvcType)   \
+        ma_atomicType result; \
+        switch (order) \
+        { \
+            case ma_atomic_memory_order_relaxed: \
+            { \
+                result = (ma_atomicType)intrin##_nf((volatile msvcType*)ptr, (msvcType)expected, (msvcType)desired); \
+            } break; \
+            case ma_atomic_memory_order_consume: \
+            case ma_atomic_memory_order_acquire: \
+            { \
+                result = (ma_atomicType)intrin##_acq((volatile msvcType*)ptr, (msvcType)expected, (msvcType)desired); \
+            } break; \
+            case ma_atomic_memory_order_release: \
+            { \
+                result = (ma_atomicType)intrin##_rel((volatile msvcType*)ptr, (msvcType)expected, (msvcType)desired); \
+            } break; \
+            case ma_atomic_memory_order_acq_rel: \
+            case ma_atomic_memory_order_seq_cst: \
+            default: \
+            { \
+                result = (ma_atomicType)intrin((volatile msvcType*)ptr, (msvcType)expected, (msvcType)desired); \
+            } break; \
+        } \
+        return result;
+    #define ma_atomic_memory_order_relaxed  0
+    #define ma_atomic_memory_order_consume  1
+    #define ma_atomic_memory_order_acquire  2
+    #define ma_atomic_memory_order_release  3
+    #define ma_atomic_memory_order_acq_rel  4
+    #define ma_atomic_memory_order_seq_cst  5
+    #if _MSC_VER < 1600 && defined(MA_X86)
+        #define MA_ATOMIC_MSVC_USE_INLINED_ASSEMBLY
+    #endif
+    #if _MSC_VER < 1600
+        #undef MA_ATOMIC_HAS_8
+        #undef MA_ATOMIC_HAS_16
+    #endif
+    #if !defined(MA_ATOMIC_MSVC_USE_INLINED_ASSEMBLY)
+        #include <intrin.h>
+    #endif
+    #if defined(MA_ATOMIC_MSVC_USE_INLINED_ASSEMBLY)
+        #if defined(MA_ATOMIC_HAS_8)
+            static MA_INLINE ma_uint8 __stdcall ma_atomic_compare_and_swap_8(volatile ma_uint8* dst, ma_uint8 expected, ma_uint8 desired)
+            {
+                ma_uint8 result = 0;
+                __asm {
+                    mov ecx, dst
+                    mov al,  expected
+                    mov dl,  desired
+                    lock cmpxchg [ecx], dl
+                    mov result, al
+                }
+                return result;
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_16)
+            static MA_INLINE ma_uint16 __stdcall ma_atomic_compare_and_swap_16(volatile ma_uint16* dst, ma_uint16 expected, ma_uint16 desired)
+            {
+                ma_uint16 result = 0;
+                __asm {
+                    mov ecx, dst
+                    mov ax,  expected
+                    mov dx,  desired
+                    lock cmpxchg [ecx], dx
+                    mov result, ax
+                }
+                return result;
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_32)
+            static MA_INLINE ma_uint32 __stdcall ma_atomic_compare_and_swap_32(volatile ma_uint32* dst, ma_uint32 expected, ma_uint32 desired)
+            {
+                ma_uint32 result = 0;
+                __asm {
+                    mov ecx, dst
+                    mov eax, expected
+                    mov edx, desired
+                    lock cmpxchg [ecx], edx
+                    mov result, eax
+                }
+                return result;
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_64)
+            static MA_INLINE ma_uint64 __stdcall ma_atomic_compare_and_swap_64(volatile ma_uint64* dst, ma_uint64 expected, ma_uint64 desired)
+            {
+                ma_uint32 resultEAX = 0;
+                ma_uint32 resultEDX = 0;
+                __asm {
+                    mov esi, dst
+                    mov eax, dword ptr expected
+                    mov edx, dword ptr expected + 4
+                    mov ebx, dword ptr desired
+                    mov ecx, dword ptr desired + 4
+                    lock cmpxchg8b qword ptr [esi]
+                    mov resultEAX, eax
+                    mov resultEDX, edx
+                }
+                return ((ma_uint64)resultEDX << 32) | resultEAX;
+            }
+        #endif
+    #else
+        #if defined(MA_ATOMIC_HAS_8)
+            #define ma_atomic_compare_and_swap_8( dst, expected, desired) (ma_uint8 )_InterlockedCompareExchange8((volatile char*)dst, (char)desired, (char)expected)
+        #endif
+        #if defined(MA_ATOMIC_HAS_16)
+            #define ma_atomic_compare_and_swap_16(dst, expected, desired) (ma_uint16)_InterlockedCompareExchange16((volatile short*)dst, (short)desired, (short)expected)
+        #endif
+        #if defined(MA_ATOMIC_HAS_32)
+            #define ma_atomic_compare_and_swap_32(dst, expected, desired) (ma_uint32)_InterlockedCompareExchange((volatile long*)dst, (long)desired, (long)expected)
+        #endif
+        #if defined(MA_ATOMIC_HAS_64)
+            #define ma_atomic_compare_and_swap_64(dst, expected, desired) (ma_uint64)_InterlockedCompareExchange64((volatile ma_int64*)dst, (ma_int64)desired, (ma_int64)expected)
+        #endif
+    #endif
+    #if defined(MA_ATOMIC_MSVC_USE_INLINED_ASSEMBLY)
+        #if defined(MA_ATOMIC_HAS_8)
+            static MA_INLINE ma_uint8 __stdcall ma_atomic_exchange_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+            {
+                ma_uint8 result = 0;
+                (void)order;
+                __asm {
+                    mov ecx, dst
+                    mov al,  src
+                    lock xchg [ecx], al
+                    mov result, al
+                }
+                return result;
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_16)
+            static MA_INLINE ma_uint16 __stdcall ma_atomic_exchange_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+            {
+                ma_uint16 result = 0;
+                (void)order;
+                __asm {
+                    mov ecx, dst
+                    mov ax,  src
+                    lock xchg [ecx], ax
+                    mov result, ax
+                }
+                return result;
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_32)
+            static MA_INLINE ma_uint32 __stdcall ma_atomic_exchange_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+            {
+                ma_uint32 result = 0;
+                (void)order;
+                __asm {
+                    mov ecx, dst
+                    mov eax, src
+                    lock xchg [ecx], eax
+                    mov result, eax
+                }
+                return result;
+            }
+        #endif
+    #else
+        #if defined(MA_ATOMIC_HAS_8)
+            static MA_INLINE ma_uint8 __stdcall ma_atomic_exchange_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+            {
+            #if defined(MA_ARM)
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchange8, ma_uint8, char);
+            #else
+                (void)order;
+                return (ma_uint8)_InterlockedExchange8((volatile char*)dst, (char)src);
+            #endif
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_16)
+            static MA_INLINE ma_uint16 __stdcall ma_atomic_exchange_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+            {
+            #if defined(MA_ARM)
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchange16, ma_uint16, short);
+            #else
+                (void)order;
+                return (ma_uint16)_InterlockedExchange16((volatile short*)dst, (short)src);
+            #endif
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_32)
+            static MA_INLINE ma_uint32 __stdcall ma_atomic_exchange_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+            {
+            #if defined(MA_ARM)
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchange, ma_uint32, long);
+            #else
+                (void)order;
+                return (ma_uint32)_InterlockedExchange((volatile long*)dst, (long)src);
+            #endif
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_64) && defined(MA_64BIT)
+            static MA_INLINE ma_uint64 __stdcall ma_atomic_exchange_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+            {
+            #if defined(MA_ARM)
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchange64, ma_uint64, long long);
+            #else
+                (void)order;
+                return (ma_uint64)_InterlockedExchange64((volatile long long*)dst, (long long)src);
+            #endif
+            }
+        #else
+        #endif
+    #endif
+    #if defined(MA_ATOMIC_HAS_64) && !defined(MA_64BIT)
+        static MA_INLINE ma_uint64 __stdcall ma_atomic_exchange_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            ma_uint64 oldValue;
+            do {
+                oldValue = *dst;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, src) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+    #endif
+    #if defined(MA_ATOMIC_MSVC_USE_INLINED_ASSEMBLY)
+        #if defined(MA_ATOMIC_HAS_8)
+            static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_add_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+            {
+                ma_uint8 result = 0;
+                (void)order;
+                __asm {
+                    mov ecx, dst
+                    mov al,  src
+                    lock xadd [ecx], al
+                    mov result, al
+                }
+                return result;
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_16)
+            static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_add_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+            {
+                ma_uint16 result = 0;
+                (void)order;
+                __asm {
+                    mov ecx, dst
+                    mov ax,  src
+                    lock xadd [ecx], ax
+                    mov result, ax
+                }
+                return result;
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_32)
+            static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_add_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+            {
+                ma_uint32 result = 0;
+                (void)order;
+                __asm {
+                    mov ecx, dst
+                    mov eax, src
+                    lock xadd [ecx], eax
+                    mov result, eax
+                }
+                return result;
+            }
+        #endif
+    #else
+        #if defined(MA_ATOMIC_HAS_8)
+            static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_add_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+            {
+            #if defined(MA_ARM)
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchangeAdd8, ma_uint8, char);
+            #else
+                (void)order;
+                return (ma_uint8)_InterlockedExchangeAdd8((volatile char*)dst, (char)src);
+            #endif
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_16)
+            static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_add_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+            {
+            #if defined(MA_ARM)
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchangeAdd16, ma_uint16, short);
+            #else
+                (void)order;
+                return (ma_uint16)_InterlockedExchangeAdd16((volatile short*)dst, (short)src);
+            #endif
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_32)
+            static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_add_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+            {
+            #if defined(MA_ARM)
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchangeAdd, ma_uint32, long);
+            #else
+                (void)order;
+                return (ma_uint32)_InterlockedExchangeAdd((volatile long*)dst, (long)src);
+            #endif
+            }
+        #endif
+        #if defined(MA_ATOMIC_HAS_64) && defined(MA_64BIT)
+            static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_add_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+            {
+            #if defined(MA_ARM)
+                MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedExchangeAdd64, ma_uint64, long long);
+            #else
+                (void)order;
+                return (ma_uint64)_InterlockedExchangeAdd64((volatile long long*)dst, (long long)src);
+            #endif
+            }
+        #else
+        #endif
+    #endif
+    #if defined(MA_ATOMIC_HAS_64) && !defined(MA_64BIT)
+        static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_add_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            ma_uint64 oldValue;
+            ma_uint64 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue + src;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+    #endif
+    #if defined(MA_ATOMIC_MSVC_USE_INLINED_ASSEMBLY)
+        static MA_INLINE void __stdcall ma_atomic_thread_fence(ma_atomic_memory_order order)
+        {
+            (void)order;
+            __asm {
+                lock add [esp], 0
+            }
+        }
+    #else
+        #if defined(MA_X64)
+            #define ma_atomic_thread_fence(order)   __faststorefence(), (void)order
+        #elif defined(MA_ARM64)
+            #define ma_atomic_thread_fence(order)   __dmb(_ARM64_BARRIER_ISH), (void)order
+        #else
+            static MA_INLINE void ma_atomic_thread_fence(ma_atomic_memory_order order)
+            {
+                volatile ma_uint32 barrier = 0;
+                ma_atomic_fetch_add_explicit_32(&barrier, 0, order);
+            }
+        #endif
+    #endif
+    #define ma_atomic_compiler_fence()      ma_atomic_thread_fence(ma_atomic_memory_order_seq_cst)
+    #define ma_atomic_signal_fence(order)   ma_atomic_thread_fence(order)
+    #if defined(MA_ATOMIC_HAS_8)
+        static MA_INLINE ma_uint8 ma_atomic_load_explicit_8(volatile const ma_uint8* ptr, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC_COMPARE_EXCHANGE(ptr, 0, 0, order, _InterlockedCompareExchange8, ma_uint8, char);
+        #else
+            (void)order;
+            return ma_atomic_compare_and_swap_8((volatile ma_uint8*)ptr, 0, 0);
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_16)
+        static MA_INLINE ma_uint16 ma_atomic_load_explicit_16(volatile const ma_uint16* ptr, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC_COMPARE_EXCHANGE(ptr, 0, 0, order, _InterlockedCompareExchange16, ma_uint16, short);
+        #else
+            (void)order;
+            return ma_atomic_compare_and_swap_16((volatile ma_uint16*)ptr, 0, 0);
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_32)
+        static MA_INLINE ma_uint32 ma_atomic_load_explicit_32(volatile const ma_uint32* ptr, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC_COMPARE_EXCHANGE(ptr, 0, 0, order, _InterlockedCompareExchange, ma_uint32, long);
+        #else
+            (void)order;
+            return ma_atomic_compare_and_swap_32((volatile ma_uint32*)ptr, 0, 0);
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_64)
+        static MA_INLINE ma_uint64 ma_atomic_load_explicit_64(volatile const ma_uint64* ptr, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC_COMPARE_EXCHANGE(ptr, 0, 0, order, _InterlockedCompareExchange64, ma_uint64, long long);
+        #else
+            (void)order;
+            return ma_atomic_compare_and_swap_64((volatile ma_uint64*)ptr, 0, 0);
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_8)
+        #define ma_atomic_store_explicit_8( dst, src, order) (void)ma_atomic_exchange_explicit_8 (dst, src, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_16)
+        #define ma_atomic_store_explicit_16(dst, src, order) (void)ma_atomic_exchange_explicit_16(dst, src, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_32)
+        #define ma_atomic_store_explicit_32(dst, src, order) (void)ma_atomic_exchange_explicit_32(dst, src, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_64)
+        #define ma_atomic_store_explicit_64(dst, src, order) (void)ma_atomic_exchange_explicit_64(dst, src, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_8)
+        static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_sub_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            ma_uint8 oldValue;
+            ma_uint8 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint8)(oldValue - src);
+            } while (ma_atomic_compare_and_swap_8(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_16)
+        static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_sub_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            ma_uint16 oldValue;
+            ma_uint16 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint16)(oldValue - src);
+            } while (ma_atomic_compare_and_swap_16(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_32)
+        static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_sub_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            ma_uint32 oldValue;
+            ma_uint32 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue - src;
+            } while (ma_atomic_compare_and_swap_32(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_64)
+        static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_sub_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            ma_uint64 oldValue;
+            ma_uint64 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue - src;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_8)
+        static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_and_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedAnd8, ma_uint8, char);
+        #else
+            ma_uint8 oldValue;
+            ma_uint8 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint8)(oldValue & src);
+            } while (ma_atomic_compare_and_swap_8(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_16)
+        static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_and_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedAnd16, ma_uint16, short);
+        #else
+            ma_uint16 oldValue;
+            ma_uint16 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint16)(oldValue & src);
+            } while (ma_atomic_compare_and_swap_16(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_32)
+        static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_and_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedAnd, ma_uint32, long);
+        #else
+            ma_uint32 oldValue;
+            ma_uint32 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue & src;
+            } while (ma_atomic_compare_and_swap_32(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_64)
+        static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_and_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedAnd64, ma_uint64, long long);
+        #else
+            ma_uint64 oldValue;
+            ma_uint64 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue & src;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_8)
+        static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_xor_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedXor8, ma_uint8, char);
+        #else
+            ma_uint8 oldValue;
+            ma_uint8 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint8)(oldValue ^ src);
+            } while (ma_atomic_compare_and_swap_8(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_16)
+        static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_xor_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedXor16, ma_uint16, short);
+        #else
+            ma_uint16 oldValue;
+            ma_uint16 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint16)(oldValue ^ src);
+            } while (ma_atomic_compare_and_swap_16(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_32)
+        static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_xor_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedXor, ma_uint32, long);
+        #else
+            ma_uint32 oldValue;
+            ma_uint32 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue ^ src;
+            } while (ma_atomic_compare_and_swap_32(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_64)
+        static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_xor_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedXor64, ma_uint64, long long);
+        #else
+            ma_uint64 oldValue;
+            ma_uint64 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue ^ src;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_8)
+        static MA_INLINE ma_uint8 __stdcall ma_atomic_fetch_or_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedOr8, ma_uint8, char);
+        #else
+            ma_uint8 oldValue;
+            ma_uint8 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint8)(oldValue | src);
+            } while (ma_atomic_compare_and_swap_8(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_16)
+        static MA_INLINE ma_uint16 __stdcall ma_atomic_fetch_or_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedOr16, ma_uint16, short);
+        #else
+            ma_uint16 oldValue;
+            ma_uint16 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint16)(oldValue | src);
+            } while (ma_atomic_compare_and_swap_16(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_32)
+        static MA_INLINE ma_uint32 __stdcall ma_atomic_fetch_or_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedOr, ma_uint32, long);
+        #else
+            ma_uint32 oldValue;
+            ma_uint32 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue | src;
+            } while (ma_atomic_compare_and_swap_32(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_64)
+        static MA_INLINE ma_uint64 __stdcall ma_atomic_fetch_or_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_ARM)
+            MA_ATOMIC_MSVC_ARM_INTRINSIC(dst, src, order, _InterlockedOr64, ma_uint64, long long);
+        #else
+            ma_uint64 oldValue;
+            ma_uint64 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue | src;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        #endif
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_8)
+        #define ma_atomic_test_and_set_explicit_8( dst, order) ma_atomic_exchange_explicit_8 (dst, 1, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_16)
+        #define ma_atomic_test_and_set_explicit_16(dst, order) ma_atomic_exchange_explicit_16(dst, 1, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_32)
+        #define ma_atomic_test_and_set_explicit_32(dst, order) ma_atomic_exchange_explicit_32(dst, 1, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_64)
+        #define ma_atomic_test_and_set_explicit_64(dst, order) ma_atomic_exchange_explicit_64(dst, 1, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_8)
+        #define ma_atomic_clear_explicit_8( dst, order) ma_atomic_store_explicit_8 (dst, 0, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_16)
+        #define ma_atomic_clear_explicit_16(dst, order) ma_atomic_store_explicit_16(dst, 0, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_32)
+        #define ma_atomic_clear_explicit_32(dst, order) ma_atomic_store_explicit_32(dst, 0, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_64)
+        #define ma_atomic_clear_explicit_64(dst, order) ma_atomic_store_explicit_64(dst, 0, order)
+    #endif
+    #if defined(MA_ATOMIC_HAS_8)
+        typedef ma_uint8 ma_atomic_flag;
+        #define ma_atomic_flag_test_and_set_explicit(ptr, order)    (ma_bool32)ma_atomic_test_and_set_explicit_8(ptr, order)
+        #define ma_atomic_flag_clear_explicit(ptr, order)           ma_atomic_clear_explicit_8(ptr, order)
+        #define c89atoimc_flag_load_explicit(ptr, order)            ma_atomic_load_explicit_8(ptr, order)
+    #else
+        typedef ma_uint32 ma_atomic_flag;
+        #define ma_atomic_flag_test_and_set_explicit(ptr, order)    (ma_bool32)ma_atomic_test_and_set_explicit_32(ptr, order)
+        #define ma_atomic_flag_clear_explicit(ptr, order)           ma_atomic_clear_explicit_32(ptr, order)
+        #define c89atoimc_flag_load_explicit(ptr, order)            ma_atomic_load_explicit_32(ptr, order)
+    #endif
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)))
+    #define MA_ATOMIC_HAS_NATIVE_COMPARE_EXCHANGE
+    #define MA_ATOMIC_HAS_NATIVE_IS_LOCK_FREE
+    #define ma_atomic_memory_order_relaxed                          __ATOMIC_RELAXED
+    #define ma_atomic_memory_order_consume                          __ATOMIC_CONSUME
+    #define ma_atomic_memory_order_acquire                          __ATOMIC_ACQUIRE
+    #define ma_atomic_memory_order_release                          __ATOMIC_RELEASE
+    #define ma_atomic_memory_order_acq_rel                          __ATOMIC_ACQ_REL
+    #define ma_atomic_memory_order_seq_cst                          __ATOMIC_SEQ_CST
+    #define ma_atomic_compiler_fence()                              __asm__ __volatile__("":::"memory")
+    #define ma_atomic_thread_fence(order)                           __atomic_thread_fence(order)
+    #define ma_atomic_signal_fence(order)                           __atomic_signal_fence(order)
+    #define ma_atomic_is_lock_free_8(ptr)                           __atomic_is_lock_free(1, ptr)
+    #define ma_atomic_is_lock_free_16(ptr)                          __atomic_is_lock_free(2, ptr)
+    #define ma_atomic_is_lock_free_32(ptr)                          __atomic_is_lock_free(4, ptr)
+    #define ma_atomic_is_lock_free_64(ptr)                          __atomic_is_lock_free(8, ptr)
+    #define ma_atomic_test_and_set_explicit_8( dst, order)          __atomic_exchange_n(dst, 1, order)
+    #define ma_atomic_test_and_set_explicit_16(dst, order)          __atomic_exchange_n(dst, 1, order)
+    #define ma_atomic_test_and_set_explicit_32(dst, order)          __atomic_exchange_n(dst, 1, order)
+    #define ma_atomic_test_and_set_explicit_64(dst, order)          __atomic_exchange_n(dst, 1, order)
+    #define ma_atomic_clear_explicit_8( dst, order)                 __atomic_store_n(dst, 0, order)
+    #define ma_atomic_clear_explicit_16(dst, order)                 __atomic_store_n(dst, 0, order)
+    #define ma_atomic_clear_explicit_32(dst, order)                 __atomic_store_n(dst, 0, order)
+    #define ma_atomic_clear_explicit_64(dst, order)                 __atomic_store_n(dst, 0, order)
+    #define ma_atomic_store_explicit_8( dst, src, order)            __atomic_store_n(dst, src, order)
+    #define ma_atomic_store_explicit_16(dst, src, order)            __atomic_store_n(dst, src, order)
+    #define ma_atomic_store_explicit_32(dst, src, order)            __atomic_store_n(dst, src, order)
+    #define ma_atomic_store_explicit_64(dst, src, order)            __atomic_store_n(dst, src, order)
+    #define ma_atomic_load_explicit_8( dst, order)                  __atomic_load_n(dst, order)
+    #define ma_atomic_load_explicit_16(dst, order)                  __atomic_load_n(dst, order)
+    #define ma_atomic_load_explicit_32(dst, order)                  __atomic_load_n(dst, order)
+    #define ma_atomic_load_explicit_64(dst, order)                  __atomic_load_n(dst, order)
+    #define ma_atomic_exchange_explicit_8( dst, src, order)         __atomic_exchange_n(dst, src, order)
+    #define ma_atomic_exchange_explicit_16(dst, src, order)         __atomic_exchange_n(dst, src, order)
+    #define ma_atomic_exchange_explicit_32(dst, src, order)         __atomic_exchange_n(dst, src, order)
+    #define ma_atomic_exchange_explicit_64(dst, src, order)         __atomic_exchange_n(dst, src, order)
+    #define ma_atomic_compare_exchange_strong_explicit_8( dst, expected, desired, successOrder, failureOrder)   __atomic_compare_exchange_n(dst, expected, desired, 0, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_strong_explicit_16(dst, expected, desired, successOrder, failureOrder)   __atomic_compare_exchange_n(dst, expected, desired, 0, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_strong_explicit_32(dst, expected, desired, successOrder, failureOrder)   __atomic_compare_exchange_n(dst, expected, desired, 0, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_strong_explicit_64(dst, expected, desired, successOrder, failureOrder)   __atomic_compare_exchange_n(dst, expected, desired, 0, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_8( dst, expected, desired, successOrder, failureOrder)     __atomic_compare_exchange_n(dst, expected, desired, 1, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_16(dst, expected, desired, successOrder, failureOrder)     __atomic_compare_exchange_n(dst, expected, desired, 1, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_32(dst, expected, desired, successOrder, failureOrder)     __atomic_compare_exchange_n(dst, expected, desired, 1, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_64(dst, expected, desired, successOrder, failureOrder)     __atomic_compare_exchange_n(dst, expected, desired, 1, successOrder, failureOrder)
+    #define ma_atomic_fetch_add_explicit_8( dst, src, order)        __atomic_fetch_add(dst, src, order)
+    #define ma_atomic_fetch_add_explicit_16(dst, src, order)        __atomic_fetch_add(dst, src, order)
+    #define ma_atomic_fetch_add_explicit_32(dst, src, order)        __atomic_fetch_add(dst, src, order)
+    #define ma_atomic_fetch_add_explicit_64(dst, src, order)        __atomic_fetch_add(dst, src, order)
+    #define ma_atomic_fetch_sub_explicit_8( dst, src, order)        __atomic_fetch_sub(dst, src, order)
+    #define ma_atomic_fetch_sub_explicit_16(dst, src, order)        __atomic_fetch_sub(dst, src, order)
+    #define ma_atomic_fetch_sub_explicit_32(dst, src, order)        __atomic_fetch_sub(dst, src, order)
+    #define ma_atomic_fetch_sub_explicit_64(dst, src, order)        __atomic_fetch_sub(dst, src, order)
+    #define ma_atomic_fetch_or_explicit_8( dst, src, order)         __atomic_fetch_or(dst, src, order)
+    #define ma_atomic_fetch_or_explicit_16(dst, src, order)         __atomic_fetch_or(dst, src, order)
+    #define ma_atomic_fetch_or_explicit_32(dst, src, order)         __atomic_fetch_or(dst, src, order)
+    #define ma_atomic_fetch_or_explicit_64(dst, src, order)         __atomic_fetch_or(dst, src, order)
+    #define ma_atomic_fetch_xor_explicit_8( dst, src, order)        __atomic_fetch_xor(dst, src, order)
+    #define ma_atomic_fetch_xor_explicit_16(dst, src, order)        __atomic_fetch_xor(dst, src, order)
+    #define ma_atomic_fetch_xor_explicit_32(dst, src, order)        __atomic_fetch_xor(dst, src, order)
+    #define ma_atomic_fetch_xor_explicit_64(dst, src, order)        __atomic_fetch_xor(dst, src, order)
+    #define ma_atomic_fetch_and_explicit_8( dst, src, order)        __atomic_fetch_and(dst, src, order)
+    #define ma_atomic_fetch_and_explicit_16(dst, src, order)        __atomic_fetch_and(dst, src, order)
+    #define ma_atomic_fetch_and_explicit_32(dst, src, order)        __atomic_fetch_and(dst, src, order)
+    #define ma_atomic_fetch_and_explicit_64(dst, src, order)        __atomic_fetch_and(dst, src, order)
+    static MA_INLINE ma_uint8 ma_atomic_compare_and_swap_8(volatile ma_uint8* dst, ma_uint8 expected, ma_uint8 desired)
+    {
+        __atomic_compare_exchange_n(dst, &expected, desired, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+        return expected;
+    }
+    static MA_INLINE ma_uint16 ma_atomic_compare_and_swap_16(volatile ma_uint16* dst, ma_uint16 expected, ma_uint16 desired)
+    {
+        __atomic_compare_exchange_n(dst, &expected, desired, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+        return expected;
+    }
+    static MA_INLINE ma_uint32 ma_atomic_compare_and_swap_32(volatile ma_uint32* dst, ma_uint32 expected, ma_uint32 desired)
+    {
+        __atomic_compare_exchange_n(dst, &expected, desired, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+        return expected;
+    }
+    static MA_INLINE ma_uint64 ma_atomic_compare_and_swap_64(volatile ma_uint64* dst, ma_uint64 expected, ma_uint64 desired)
+    {
+        __atomic_compare_exchange_n(dst, &expected, desired, 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+        return expected;
+    }
+    typedef ma_uint8 ma_atomic_flag;
+    #define ma_atomic_flag_test_and_set_explicit(dst, order)        (ma_bool32)__atomic_test_and_set(dst, order)
+    #define ma_atomic_flag_clear_explicit(dst, order)               __atomic_clear(dst, order)
+    #define c89atoimc_flag_load_explicit(ptr, order)                ma_atomic_load_explicit_8(ptr, order)
+#else
+    #define ma_atomic_memory_order_relaxed  1
+    #define ma_atomic_memory_order_consume  2
+    #define ma_atomic_memory_order_acquire  3
+    #define ma_atomic_memory_order_release  4
+    #define ma_atomic_memory_order_acq_rel  5
+    #define ma_atomic_memory_order_seq_cst  6
+    #define ma_atomic_compiler_fence() __asm__ __volatile__("":::"memory")
+    #if defined(__GNUC__)
+        #define ma_atomic_thread_fence(order) __sync_synchronize(), (void)order
+        static MA_INLINE ma_uint8 ma_atomic_exchange_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            if (order > ma_atomic_memory_order_acquire) {
+                __sync_synchronize();
+            }
+            return __sync_lock_test_and_set(dst, src);
+        }
+        static MA_INLINE ma_uint16 ma_atomic_exchange_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            ma_uint16 oldValue;
+            do {
+                oldValue = *dst;
+            } while (__sync_val_compare_and_swap(dst, oldValue, src) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint32 ma_atomic_exchange_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            ma_uint32 oldValue;
+            do {
+                oldValue = *dst;
+            } while (__sync_val_compare_and_swap(dst, oldValue, src) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint64 ma_atomic_exchange_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            ma_uint64 oldValue;
+            do {
+                oldValue = *dst;
+            } while (__sync_val_compare_and_swap(dst, oldValue, src) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_add_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_add(dst, src);
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_add_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_add(dst, src);
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_add_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_add(dst, src);
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_add_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_add(dst, src);
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_sub_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_sub(dst, src);
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_sub_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_sub(dst, src);
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_sub_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_sub(dst, src);
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_sub_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_sub(dst, src);
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_or_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_or(dst, src);
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_or_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_or(dst, src);
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_or_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_or(dst, src);
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_or_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_or(dst, src);
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_xor_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_xor(dst, src);
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_xor_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_xor(dst, src);
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_xor_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_xor(dst, src);
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_xor_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_xor(dst, src);
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_and_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_and(dst, src);
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_and_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_and(dst, src);
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_and_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_and(dst, src);
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_and_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            (void)order;
+            return __sync_fetch_and_and(dst, src);
+        }
+        #define ma_atomic_compare_and_swap_8( dst, expected, desired)   __sync_val_compare_and_swap(dst, expected, desired)
+        #define ma_atomic_compare_and_swap_16(dst, expected, desired)   __sync_val_compare_and_swap(dst, expected, desired)
+        #define ma_atomic_compare_and_swap_32(dst, expected, desired)   __sync_val_compare_and_swap(dst, expected, desired)
+        #define ma_atomic_compare_and_swap_64(dst, expected, desired)   __sync_val_compare_and_swap(dst, expected, desired)
+    #else
+        #if defined(MA_X86)
+            #define ma_atomic_thread_fence(order) __asm__ __volatile__("lock; addl $0, (%%esp)" ::: "memory", "cc")
+        #elif defined(MA_X64)
+            #define ma_atomic_thread_fence(order) __asm__ __volatile__("lock; addq $0, (%%rsp)" ::: "memory", "cc")
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+        static MA_INLINE ma_uint8 ma_atomic_compare_and_swap_8(volatile ma_uint8* dst, ma_uint8 expected, ma_uint8 desired)
+        {
+            ma_uint8 result;
+        #if defined(MA_X86) || defined(MA_X64)
+            __asm__ __volatile__("lock; cmpxchg %3, %0" : "+m"(*dst), "=a"(result) : "a"(expected), "d"(desired) : "cc");
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint16 ma_atomic_compare_and_swap_16(volatile ma_uint16* dst, ma_uint16 expected, ma_uint16 desired)
+        {
+            ma_uint16 result;
+        #if defined(MA_X86) || defined(MA_X64)
+            __asm__ __volatile__("lock; cmpxchg %3, %0" : "+m"(*dst), "=a"(result) : "a"(expected), "d"(desired) : "cc");
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint32 ma_atomic_compare_and_swap_32(volatile ma_uint32* dst, ma_uint32 expected, ma_uint32 desired)
+        {
+            ma_uint32 result;
+        #if defined(MA_X86) || defined(MA_X64)
+            __asm__ __volatile__("lock; cmpxchg %3, %0" : "+m"(*dst), "=a"(result) : "a"(expected), "d"(desired) : "cc");
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint64 ma_atomic_compare_and_swap_64(volatile ma_uint64* dst, ma_uint64 expected, ma_uint64 desired)
+        {
+            volatile ma_uint64 result;
+        #if defined(MA_X86)
+            ma_uint32 resultEAX;
+            ma_uint32 resultEDX;
+            __asm__ __volatile__("push %%ebx; xchg %5, %%ebx; lock; cmpxchg8b %0; pop %%ebx" : "+m"(*dst), "=a"(resultEAX), "=d"(resultEDX) : "a"(expected & 0xFFFFFFFF), "d"(expected >> 32), "r"(desired & 0xFFFFFFFF), "c"(desired >> 32) : "cc");
+            result = ((ma_uint64)resultEDX << 32) | resultEAX;
+        #elif defined(MA_X64)
+            __asm__ __volatile__("lock; cmpxchg %3, %0" : "+m"(*dst), "=a"(result) : "a"(expected), "d"(desired) : "cc");
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint8 ma_atomic_exchange_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            ma_uint8 result = 0;
+            (void)order;
+        #if defined(MA_X86) || defined(MA_X64)
+            __asm__ __volatile__("lock; xchg %1, %0" : "+m"(*dst), "=a"(result) : "a"(src));
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint16 ma_atomic_exchange_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            ma_uint16 result = 0;
+            (void)order;
+        #if defined(MA_X86) || defined(MA_X64)
+            __asm__ __volatile__("lock; xchg %1, %0" : "+m"(*dst), "=a"(result) : "a"(src));
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint32 ma_atomic_exchange_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            ma_uint32 result;
+            (void)order;
+        #if defined(MA_X86) || defined(MA_X64)
+            __asm__ __volatile__("lock; xchg %1, %0" : "+m"(*dst), "=a"(result) : "a"(src));
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint64 ma_atomic_exchange_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            ma_uint64 result;
+            (void)order;
+        #if defined(MA_X86)
+            do {
+                result = *dst;
+            } while (ma_atomic_compare_and_swap_64(dst, result, src) != result);
+        #elif defined(MA_X64)
+            __asm__ __volatile__("lock; xchg %1, %0" : "+m"(*dst), "=a"(result) : "a"(src));
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_add_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            ma_uint8 result;
+            (void)order;
+        #if defined(MA_X86) || defined(MA_X64)
+            __asm__ __volatile__("lock; xadd %1, %0" : "+m"(*dst), "=a"(result) : "a"(src) : "cc");
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_add_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            ma_uint16 result;
+            (void)order;
+        #if defined(MA_X86) || defined(MA_X64)
+            __asm__ __volatile__("lock; xadd %1, %0" : "+m"(*dst), "=a"(result) : "a"(src) : "cc");
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_add_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            ma_uint32 result;
+            (void)order;
+        #if defined(MA_X86) || defined(MA_X64)
+            __asm__ __volatile__("lock; xadd %1, %0" : "+m"(*dst), "=a"(result) : "a"(src) : "cc");
+        #else
+            #error Unsupported architecture. Please submit a feature request.
+        #endif
+            return result;
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_add_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+        #if defined(MA_X86)
+            ma_uint64 oldValue;
+            ma_uint64 newValue;
+            (void)order;
+            do {
+                oldValue = *dst;
+                newValue = oldValue + src;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, newValue) != oldValue);
+            return oldValue;
+        #elif defined(MA_X64)
+            ma_uint64 result;
+            (void)order;
+            __asm__ __volatile__("lock; xadd %1, %0" : "+m"(*dst), "=a"(result) : "a"(src) : "cc");
+            return result;
+        #endif
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_sub_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            ma_uint8 oldValue;
+            ma_uint8 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint8)(oldValue - src);
+            } while (ma_atomic_compare_and_swap_8(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_sub_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            ma_uint16 oldValue;
+            ma_uint16 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint16)(oldValue - src);
+            } while (ma_atomic_compare_and_swap_16(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_sub_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            ma_uint32 oldValue;
+            ma_uint32 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue - src;
+            } while (ma_atomic_compare_and_swap_32(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_sub_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            ma_uint64 oldValue;
+            ma_uint64 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue - src;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_and_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            ma_uint8 oldValue;
+            ma_uint8 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint8)(oldValue & src);
+            } while (ma_atomic_compare_and_swap_8(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_and_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            ma_uint16 oldValue;
+            ma_uint16 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint16)(oldValue & src);
+            } while (ma_atomic_compare_and_swap_16(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_and_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            ma_uint32 oldValue;
+            ma_uint32 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue & src;
+            } while (ma_atomic_compare_and_swap_32(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_and_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            ma_uint64 oldValue;
+            ma_uint64 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue & src;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_xor_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            ma_uint8 oldValue;
+            ma_uint8 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint8)(oldValue ^ src);
+            } while (ma_atomic_compare_and_swap_8(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_xor_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            ma_uint16 oldValue;
+            ma_uint16 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint16)(oldValue ^ src);
+            } while (ma_atomic_compare_and_swap_16(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_xor_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            ma_uint32 oldValue;
+            ma_uint32 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue ^ src;
+            } while (ma_atomic_compare_and_swap_32(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_xor_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            ma_uint64 oldValue;
+            ma_uint64 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue ^ src;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint8 ma_atomic_fetch_or_explicit_8(volatile ma_uint8* dst, ma_uint8 src, ma_atomic_memory_order order)
+        {
+            ma_uint8 oldValue;
+            ma_uint8 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint8)(oldValue | src);
+            } while (ma_atomic_compare_and_swap_8(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint16 ma_atomic_fetch_or_explicit_16(volatile ma_uint16* dst, ma_uint16 src, ma_atomic_memory_order order)
+        {
+            ma_uint16 oldValue;
+            ma_uint16 newValue;
+            do {
+                oldValue = *dst;
+                newValue = (ma_uint16)(oldValue | src);
+            } while (ma_atomic_compare_and_swap_16(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint32 ma_atomic_fetch_or_explicit_32(volatile ma_uint32* dst, ma_uint32 src, ma_atomic_memory_order order)
+        {
+            ma_uint32 oldValue;
+            ma_uint32 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue | src;
+            } while (ma_atomic_compare_and_swap_32(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+        static MA_INLINE ma_uint64 ma_atomic_fetch_or_explicit_64(volatile ma_uint64* dst, ma_uint64 src, ma_atomic_memory_order order)
+        {
+            ma_uint64 oldValue;
+            ma_uint64 newValue;
+            do {
+                oldValue = *dst;
+                newValue = oldValue | src;
+            } while (ma_atomic_compare_and_swap_64(dst, oldValue, newValue) != oldValue);
+            (void)order;
+            return oldValue;
+        }
+    #endif
+    #define ma_atomic_signal_fence(order)                           ma_atomic_thread_fence(order)
+    static MA_INLINE ma_uint8 ma_atomic_load_explicit_8(volatile const ma_uint8* ptr, ma_atomic_memory_order order)
+    {
+        (void)order;
+        return ma_atomic_compare_and_swap_8((ma_uint8*)ptr, 0, 0);
+    }
+    static MA_INLINE ma_uint16 ma_atomic_load_explicit_16(volatile const ma_uint16* ptr, ma_atomic_memory_order order)
+    {
+        (void)order;
+        return ma_atomic_compare_and_swap_16((ma_uint16*)ptr, 0, 0);
+    }
+    static MA_INLINE ma_uint32 ma_atomic_load_explicit_32(volatile const ma_uint32* ptr, ma_atomic_memory_order order)
+    {
+        (void)order;
+        return ma_atomic_compare_and_swap_32((ma_uint32*)ptr, 0, 0);
+    }
+    static MA_INLINE ma_uint64 ma_atomic_load_explicit_64(volatile const ma_uint64* ptr, ma_atomic_memory_order order)
+    {
+        (void)order;
+        return ma_atomic_compare_and_swap_64((ma_uint64*)ptr, 0, 0);
+    }
+    #define ma_atomic_store_explicit_8( dst, src, order)            (void)ma_atomic_exchange_explicit_8 (dst, src, order)
+    #define ma_atomic_store_explicit_16(dst, src, order)            (void)ma_atomic_exchange_explicit_16(dst, src, order)
+    #define ma_atomic_store_explicit_32(dst, src, order)            (void)ma_atomic_exchange_explicit_32(dst, src, order)
+    #define ma_atomic_store_explicit_64(dst, src, order)            (void)ma_atomic_exchange_explicit_64(dst, src, order)
+    #define ma_atomic_test_and_set_explicit_8( dst, order)          ma_atomic_exchange_explicit_8 (dst, 1, order)
+    #define ma_atomic_test_and_set_explicit_16(dst, order)          ma_atomic_exchange_explicit_16(dst, 1, order)
+    #define ma_atomic_test_and_set_explicit_32(dst, order)          ma_atomic_exchange_explicit_32(dst, 1, order)
+    #define ma_atomic_test_and_set_explicit_64(dst, order)          ma_atomic_exchange_explicit_64(dst, 1, order)
+    #define ma_atomic_clear_explicit_8( dst, order)                 ma_atomic_store_explicit_8 (dst, 0, order)
+    #define ma_atomic_clear_explicit_16(dst, order)                 ma_atomic_store_explicit_16(dst, 0, order)
+    #define ma_atomic_clear_explicit_32(dst, order)                 ma_atomic_store_explicit_32(dst, 0, order)
+    #define ma_atomic_clear_explicit_64(dst, order)                 ma_atomic_store_explicit_64(dst, 0, order)
+    typedef ma_uint8 ma_atomic_flag;
+    #define ma_atomic_flag_test_and_set_explicit(ptr, order)        (ma_bool32)ma_atomic_test_and_set_explicit_8(ptr, order)
+    #define ma_atomic_flag_clear_explicit(ptr, order)               ma_atomic_clear_explicit_8(ptr, order)
+    #define c89atoimc_flag_load_explicit(ptr, order)                ma_atomic_load_explicit_8(ptr, order)
+#endif
+#if !defined(MA_ATOMIC_HAS_NATIVE_COMPARE_EXCHANGE)
+    #if defined(MA_ATOMIC_HAS_8)
+        static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_8(volatile ma_uint8* dst, ma_uint8* expected, ma_uint8 desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+        {
+            ma_uint8 expectedValue;
+            ma_uint8 result;
+            (void)successOrder;
+            (void)failureOrder;
+            expectedValue = ma_atomic_load_explicit_8(expected, ma_atomic_memory_order_seq_cst);
+            result = ma_atomic_compare_and_swap_8(dst, expectedValue, desired);
+            if (result == expectedValue) {
+                return 1;
+            } else {
+                ma_atomic_store_explicit_8(expected, result, failureOrder);
+                return 0;
+            }
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_16)
+        static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_16(volatile ma_uint16* dst, ma_uint16* expected, ma_uint16 desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+        {
+            ma_uint16 expectedValue;
+            ma_uint16 result;
+            (void)successOrder;
+            (void)failureOrder;
+            expectedValue = ma_atomic_load_explicit_16(expected, ma_atomic_memory_order_seq_cst);
+            result = ma_atomic_compare_and_swap_16(dst, expectedValue, desired);
+            if (result == expectedValue) {
+                return 1;
+            } else {
+                ma_atomic_store_explicit_16(expected, result, failureOrder);
+                return 0;
+            }
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_32)
+        static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_32(volatile ma_uint32* dst, ma_uint32* expected, ma_uint32 desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+        {
+            ma_uint32 expectedValue;
+            ma_uint32 result;
+            (void)successOrder;
+            (void)failureOrder;
+            expectedValue = ma_atomic_load_explicit_32(expected, ma_atomic_memory_order_seq_cst);
+            result = ma_atomic_compare_and_swap_32(dst, expectedValue, desired);
+            if (result == expectedValue) {
+                return 1;
+            } else {
+                ma_atomic_store_explicit_32(expected, result, failureOrder);
+                return 0;
+            }
+        }
+    #endif
+    #if defined(MA_ATOMIC_HAS_64)
+        static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_64(volatile ma_uint64* dst, volatile ma_uint64* expected, ma_uint64 desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+        {
+            ma_uint64 expectedValue;
+            ma_uint64 result;
+            (void)successOrder;
+            (void)failureOrder;
+            expectedValue = ma_atomic_load_explicit_64(expected, ma_atomic_memory_order_seq_cst);
+            result = ma_atomic_compare_and_swap_64(dst, expectedValue, desired);
+            if (result == expectedValue) {
+                return 1;
+            } else {
+                ma_atomic_store_explicit_64(expected, result, failureOrder);
+                return 0;
+            }
+        }
+    #endif
+    #define ma_atomic_compare_exchange_weak_explicit_8( dst, expected, desired, successOrder, failureOrder) ma_atomic_compare_exchange_strong_explicit_8 (dst, expected, desired, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_16(dst, expected, desired, successOrder, failureOrder) ma_atomic_compare_exchange_strong_explicit_16(dst, expected, desired, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_32(dst, expected, desired, successOrder, failureOrder) ma_atomic_compare_exchange_strong_explicit_32(dst, expected, desired, successOrder, failureOrder)
+    #define ma_atomic_compare_exchange_weak_explicit_64(dst, expected, desired, successOrder, failureOrder) ma_atomic_compare_exchange_strong_explicit_64(dst, expected, desired, successOrder, failureOrder)
+#endif
+#if !defined(MA_ATOMIC_HAS_NATIVE_IS_LOCK_FREE)
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_8(volatile void* ptr)
+    {
+        (void)ptr;
+        return 1;
+    }
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_16(volatile void* ptr)
+    {
+        (void)ptr;
+        return 1;
+    }
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_32(volatile void* ptr)
+    {
+        (void)ptr;
+        return 1;
+    }
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_64(volatile void* ptr)
+    {
+        (void)ptr;
+    #if defined(MA_64BIT)
+        return 1;
+    #else
+        #if defined(MA_X86) || defined(MA_X64)
+            return 1;
+        #else
+            return 0;
+        #endif
+    #endif
+    }
+#endif
+#if defined(MA_64BIT)
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_ptr(volatile void** ptr)
+    {
+        return ma_atomic_is_lock_free_64((volatile ma_uint64*)ptr);
+    }
+    static MA_INLINE void* ma_atomic_load_explicit_ptr(volatile void** ptr, ma_atomic_memory_order order)
+    {
+        return (void*)ma_atomic_load_explicit_64((volatile ma_uint64*)ptr, order);
+    }
+    static MA_INLINE void ma_atomic_store_explicit_ptr(volatile void** dst, void* src, ma_atomic_memory_order order)
+    {
+        ma_atomic_store_explicit_64((volatile ma_uint64*)dst, (ma_uint64)src, order);
+    }
+    static MA_INLINE void* ma_atomic_exchange_explicit_ptr(volatile void** dst, void* src, ma_atomic_memory_order order)
+    {
+        return (void*)ma_atomic_exchange_explicit_64((volatile ma_uint64*)dst, (ma_uint64)src, order);
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_ptr(volatile void** dst, void** expected, void* desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        return ma_atomic_compare_exchange_strong_explicit_64((volatile ma_uint64*)dst, (ma_uint64*)expected, (ma_uint64)desired, successOrder, failureOrder);
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_weak_explicit_ptr(volatile void** dst, void** expected, void* desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        return ma_atomic_compare_exchange_weak_explicit_64((volatile ma_uint64*)dst, (ma_uint64*)expected, (ma_uint64)desired, successOrder, failureOrder);
+    }
+    static MA_INLINE void* ma_atomic_compare_and_swap_ptr(volatile void** dst, void* expected, void* desired)
+    {
+        return (void*)ma_atomic_compare_and_swap_64((volatile ma_uint64*)dst, (ma_uint64)expected, (ma_uint64)desired);
+    }
+#elif defined(MA_32BIT)
+    static MA_INLINE ma_bool32 ma_atomic_is_lock_free_ptr(volatile void** ptr)
+    {
+        return ma_atomic_is_lock_free_32((volatile ma_uint32*)ptr);
+    }
+    static MA_INLINE void* ma_atomic_load_explicit_ptr(volatile void** ptr, ma_atomic_memory_order order)
+    {
+        return (void*)ma_atomic_load_explicit_32((volatile ma_uint32*)ptr, order);
+    }
+    static MA_INLINE void ma_atomic_store_explicit_ptr(volatile void** dst, void* src, ma_atomic_memory_order order)
+    {
+        ma_atomic_store_explicit_32((volatile ma_uint32*)dst, (ma_uint32)src, order);
+    }
+    static MA_INLINE void* ma_atomic_exchange_explicit_ptr(volatile void** dst, void* src, ma_atomic_memory_order order)
+    {
+        return (void*)ma_atomic_exchange_explicit_32((volatile ma_uint32*)dst, (ma_uint32)src, order);
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_ptr(volatile void** dst, void** expected, void* desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        return ma_atomic_compare_exchange_strong_explicit_32((volatile ma_uint32*)dst, (ma_uint32*)expected, (ma_uint32)desired, successOrder, failureOrder);
+    }
+    static MA_INLINE ma_bool32 ma_atomic_compare_exchange_weak_explicit_ptr(volatile void** dst, void** expected, void* desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+    {
+        return ma_atomic_compare_exchange_weak_explicit_32((volatile ma_uint32*)dst, (ma_uint32*)expected, (ma_uint32)desired, successOrder, failureOrder);
+    }
+    static MA_INLINE void* ma_atomic_compare_and_swap_ptr(volatile void** dst, void* expected, void* desired)
+    {
+        return (void*)ma_atomic_compare_and_swap_32((volatile ma_uint32*)dst, (ma_uint32)expected, (ma_uint32)desired);
+    }
+#else
+    #error Unsupported architecture.
+#endif
+#define ma_atomic_flag_test_and_set(ptr)                                ma_atomic_flag_test_and_set_explicit(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_flag_clear(ptr)                                       ma_atomic_flag_clear_explicit(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_ptr(dst, src)                                   ma_atomic_store_explicit_ptr((volatile void**)dst, (void*)src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_ptr(ptr)                                         ma_atomic_load_explicit_ptr((volatile void**)ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_ptr(dst, src)                                ma_atomic_exchange_explicit_ptr((volatile void**)dst, (void*)src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_ptr(dst, expected, desired)   ma_atomic_compare_exchange_strong_explicit_ptr((volatile void**)dst, (void**)expected, (void*)desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_ptr(dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_ptr((volatile void**)dst, (void**)expected, (void*)desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_test_and_set_8( ptr)                                  ma_atomic_test_and_set_explicit_8( ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_test_and_set_16(ptr)                                  ma_atomic_test_and_set_explicit_16(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_test_and_set_32(ptr)                                  ma_atomic_test_and_set_explicit_32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_test_and_set_64(ptr)                                  ma_atomic_test_and_set_explicit_64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_clear_8( ptr)                                         ma_atomic_clear_explicit_8( ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_clear_16(ptr)                                         ma_atomic_clear_explicit_16(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_clear_32(ptr)                                         ma_atomic_clear_explicit_32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_clear_64(ptr)                                         ma_atomic_clear_explicit_64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_8( dst, src)                                    ma_atomic_store_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_16(dst, src)                                    ma_atomic_store_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_32(dst, src)                                    ma_atomic_store_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_64(dst, src)                                    ma_atomic_store_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_8( ptr)                                          ma_atomic_load_explicit_8( ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_16(ptr)                                          ma_atomic_load_explicit_16(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_32(ptr)                                          ma_atomic_load_explicit_32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_64(ptr)                                          ma_atomic_load_explicit_64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_8( dst, src)                                 ma_atomic_exchange_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_16(dst, src)                                 ma_atomic_exchange_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_32(dst, src)                                 ma_atomic_exchange_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_64(dst, src)                                 ma_atomic_exchange_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_8( dst, expected, desired)    ma_atomic_compare_exchange_strong_explicit_8( dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_16(dst, expected, desired)    ma_atomic_compare_exchange_strong_explicit_16(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_32(dst, expected, desired)    ma_atomic_compare_exchange_strong_explicit_32(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_64(dst, expected, desired)    ma_atomic_compare_exchange_strong_explicit_64(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_8(  dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_8( dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_16( dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_16(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_32( dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_32(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_64( dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_64(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_8( dst, src)                                ma_atomic_fetch_add_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_16(dst, src)                                ma_atomic_fetch_add_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_32(dst, src)                                ma_atomic_fetch_add_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_64(dst, src)                                ma_atomic_fetch_add_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_8( dst, src)                                ma_atomic_fetch_sub_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_16(dst, src)                                ma_atomic_fetch_sub_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_32(dst, src)                                ma_atomic_fetch_sub_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_64(dst, src)                                ma_atomic_fetch_sub_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_8( dst, src)                                 ma_atomic_fetch_or_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_16(dst, src)                                 ma_atomic_fetch_or_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_32(dst, src)                                 ma_atomic_fetch_or_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_64(dst, src)                                 ma_atomic_fetch_or_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_8( dst, src)                                ma_atomic_fetch_xor_explicit_8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_16(dst, src)                                ma_atomic_fetch_xor_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_32(dst, src)                                ma_atomic_fetch_xor_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_64(dst, src)                                ma_atomic_fetch_xor_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_8( dst, src)                                ma_atomic_fetch_and_explicit_8 (dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_16(dst, src)                                ma_atomic_fetch_and_explicit_16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_32(dst, src)                                ma_atomic_fetch_and_explicit_32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_64(dst, src)                                ma_atomic_fetch_and_explicit_64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_test_and_set_explicit_i8( ptr, order)                 (ma_int8 )ma_atomic_test_and_set_explicit_8( (ma_uint8* )ptr, order)
+#define ma_atomic_test_and_set_explicit_i16(ptr, order)                 (ma_int16)ma_atomic_test_and_set_explicit_16((ma_uint16*)ptr, order)
+#define ma_atomic_test_and_set_explicit_i32(ptr, order)                 (ma_int32)ma_atomic_test_and_set_explicit_32((ma_uint32*)ptr, order)
+#define ma_atomic_test_and_set_explicit_i64(ptr, order)                 (ma_int64)ma_atomic_test_and_set_explicit_64((ma_uint64*)ptr, order)
+#define ma_atomic_clear_explicit_i8( ptr, order)                        ma_atomic_clear_explicit_8( (ma_uint8* )ptr, order)
+#define ma_atomic_clear_explicit_i16(ptr, order)                        ma_atomic_clear_explicit_16((ma_uint16*)ptr, order)
+#define ma_atomic_clear_explicit_i32(ptr, order)                        ma_atomic_clear_explicit_32((ma_uint32*)ptr, order)
+#define ma_atomic_clear_explicit_i64(ptr, order)                        ma_atomic_clear_explicit_64((ma_uint64*)ptr, order)
+#define ma_atomic_store_explicit_i8( dst, src, order)                   ma_atomic_store_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_store_explicit_i16(dst, src, order)                   ma_atomic_store_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_store_explicit_i32(dst, src, order)                   ma_atomic_store_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_store_explicit_i64(dst, src, order)                   ma_atomic_store_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_load_explicit_i8( ptr, order)                         (ma_int8 )ma_atomic_load_explicit_8( (ma_uint8* )ptr, order)
+#define ma_atomic_load_explicit_i16(ptr, order)                         (ma_int16)ma_atomic_load_explicit_16((ma_uint16*)ptr, order)
+#define ma_atomic_load_explicit_i32(ptr, order)                         (ma_int32)ma_atomic_load_explicit_32((ma_uint32*)ptr, order)
+#define ma_atomic_load_explicit_i64(ptr, order)                         (ma_int64)ma_atomic_load_explicit_64((ma_uint64*)ptr, order)
+#define ma_atomic_exchange_explicit_i8( dst, src, order)                (ma_int8 )ma_atomic_exchange_explicit_8 ((ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_exchange_explicit_i16(dst, src, order)                (ma_int16)ma_atomic_exchange_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_exchange_explicit_i32(dst, src, order)                (ma_int32)ma_atomic_exchange_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_exchange_explicit_i64(dst, src, order)                (ma_int64)ma_atomic_exchange_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_compare_exchange_strong_explicit_i8( dst, expected, desired, successOrder, failureOrder)  ma_atomic_compare_exchange_strong_explicit_8( (ma_uint8* )dst, (ma_uint8* )expected, (ma_uint8 )desired, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_strong_explicit_i16(dst, expected, desired, successOrder, failureOrder)  ma_atomic_compare_exchange_strong_explicit_16((ma_uint16*)dst, (ma_uint16*)expected, (ma_uint16)desired, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_strong_explicit_i32(dst, expected, desired, successOrder, failureOrder)  ma_atomic_compare_exchange_strong_explicit_32((ma_uint32*)dst, (ma_uint32*)expected, (ma_uint32)desired, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_strong_explicit_i64(dst, expected, desired, successOrder, failureOrder)  ma_atomic_compare_exchange_strong_explicit_64((ma_uint64*)dst, (ma_uint64*)expected, (ma_uint64)desired, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_weak_explicit_i8( dst, expected, desired, successOrder, failureOrder)    ma_atomic_compare_exchange_weak_explicit_8( (ma_uint8* )dst, (ma_uint8* )expected, (ma_uint8 )desired, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_weak_explicit_i16(dst, expected, desired, successOrder, failureOrder)    ma_atomic_compare_exchange_weak_explicit_16((ma_uint16*)dst, (ma_uint16*)expected, (ma_uint16)desired, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_weak_explicit_i32(dst, expected, desired, successOrder, failureOrder)    ma_atomic_compare_exchange_weak_explicit_32((ma_uint32*)dst, (ma_uint32*)expected, (ma_uint32)desired, successOrder, failureOrder)
+#define ma_atomic_compare_exchange_weak_explicit_i64(dst, expected, desired, successOrder, failureOrder)    ma_atomic_compare_exchange_weak_explicit_64((ma_uint64*)dst, (ma_uint64*)expected, (ma_uint64)desired, successOrder, failureOrder)
+#define ma_atomic_fetch_add_explicit_i8( dst, src, order)               (ma_int8 )ma_atomic_fetch_add_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_fetch_add_explicit_i16(dst, src, order)               (ma_int16)ma_atomic_fetch_add_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_fetch_add_explicit_i32(dst, src, order)               (ma_int32)ma_atomic_fetch_add_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_fetch_add_explicit_i64(dst, src, order)               (ma_int64)ma_atomic_fetch_add_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_fetch_sub_explicit_i8( dst, src, order)               (ma_int8 )ma_atomic_fetch_sub_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_fetch_sub_explicit_i16(dst, src, order)               (ma_int16)ma_atomic_fetch_sub_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_fetch_sub_explicit_i32(dst, src, order)               (ma_int32)ma_atomic_fetch_sub_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_fetch_sub_explicit_i64(dst, src, order)               (ma_int64)ma_atomic_fetch_sub_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_fetch_or_explicit_i8( dst, src, order)                (ma_int8 )ma_atomic_fetch_or_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_fetch_or_explicit_i16(dst, src, order)                (ma_int16)ma_atomic_fetch_or_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_fetch_or_explicit_i32(dst, src, order)                (ma_int32)ma_atomic_fetch_or_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_fetch_or_explicit_i64(dst, src, order)                (ma_int64)ma_atomic_fetch_or_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_fetch_xor_explicit_i8( dst, src, order)               (ma_int8 )ma_atomic_fetch_xor_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_fetch_xor_explicit_i16(dst, src, order)               (ma_int16)ma_atomic_fetch_xor_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_fetch_xor_explicit_i32(dst, src, order)               (ma_int32)ma_atomic_fetch_xor_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_fetch_xor_explicit_i64(dst, src, order)               (ma_int64)ma_atomic_fetch_xor_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_fetch_and_explicit_i8( dst, src, order)               (ma_int8 )ma_atomic_fetch_and_explicit_8( (ma_uint8* )dst, (ma_uint8 )src, order)
+#define ma_atomic_fetch_and_explicit_i16(dst, src, order)               (ma_int16)ma_atomic_fetch_and_explicit_16((ma_uint16*)dst, (ma_uint16)src, order)
+#define ma_atomic_fetch_and_explicit_i32(dst, src, order)               (ma_int32)ma_atomic_fetch_and_explicit_32((ma_uint32*)dst, (ma_uint32)src, order)
+#define ma_atomic_fetch_and_explicit_i64(dst, src, order)               (ma_int64)ma_atomic_fetch_and_explicit_64((ma_uint64*)dst, (ma_uint64)src, order)
+#define ma_atomic_test_and_set_i8( ptr)                                 ma_atomic_test_and_set_explicit_i8( ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_test_and_set_i16(ptr)                                 ma_atomic_test_and_set_explicit_i16(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_test_and_set_i32(ptr)                                 ma_atomic_test_and_set_explicit_i32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_test_and_set_i64(ptr)                                 ma_atomic_test_and_set_explicit_i64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_clear_i8( ptr)                                        ma_atomic_clear_explicit_i8( ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_clear_i16(ptr)                                        ma_atomic_clear_explicit_i16(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_clear_i32(ptr)                                        ma_atomic_clear_explicit_i32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_clear_i64(ptr)                                        ma_atomic_clear_explicit_i64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_i8( dst, src)                                   ma_atomic_store_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_i16(dst, src)                                   ma_atomic_store_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_i32(dst, src)                                   ma_atomic_store_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_i64(dst, src)                                   ma_atomic_store_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_i8( ptr)                                         ma_atomic_load_explicit_i8( ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_i16(ptr)                                         ma_atomic_load_explicit_i16(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_i32(ptr)                                         ma_atomic_load_explicit_i32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_i64(ptr)                                         ma_atomic_load_explicit_i64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_i8( dst, src)                                ma_atomic_exchange_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_i16(dst, src)                                ma_atomic_exchange_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_i32(dst, src)                                ma_atomic_exchange_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_i64(dst, src)                                ma_atomic_exchange_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_i8( dst, expected, desired)   ma_atomic_compare_exchange_strong_explicit_i8( dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_i16(dst, expected, desired)   ma_atomic_compare_exchange_strong_explicit_i16(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_i32(dst, expected, desired)   ma_atomic_compare_exchange_strong_explicit_i32(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_i64(dst, expected, desired)   ma_atomic_compare_exchange_strong_explicit_i64(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_i8( dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_i8( dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_i16(dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_i16(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_i32(dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_i32(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_i64(dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_i64(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_i8( dst, src)                               ma_atomic_fetch_add_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_i16(dst, src)                               ma_atomic_fetch_add_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_i32(dst, src)                               ma_atomic_fetch_add_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_i64(dst, src)                               ma_atomic_fetch_add_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_i8( dst, src)                               ma_atomic_fetch_sub_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_i16(dst, src)                               ma_atomic_fetch_sub_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_i32(dst, src)                               ma_atomic_fetch_sub_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_i64(dst, src)                               ma_atomic_fetch_sub_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_i8( dst, src)                                ma_atomic_fetch_or_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_i16(dst, src)                                ma_atomic_fetch_or_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_i32(dst, src)                                ma_atomic_fetch_or_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_i64(dst, src)                                ma_atomic_fetch_or_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_i8( dst, src)                               ma_atomic_fetch_xor_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_i16(dst, src)                               ma_atomic_fetch_xor_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_i32(dst, src)                               ma_atomic_fetch_xor_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_i64(dst, src)                               ma_atomic_fetch_xor_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_i8( dst, src)                               ma_atomic_fetch_and_explicit_i8( dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_i16(dst, src)                               ma_atomic_fetch_and_explicit_i16(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_i32(dst, src)                               ma_atomic_fetch_and_explicit_i32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_i64(dst, src)                               ma_atomic_fetch_and_explicit_i64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_and_swap_i8( dst, expected, dedsired)         (ma_int8 )ma_atomic_compare_and_swap_8( (ma_uint8* )dst, (ma_uint8 )expected, (ma_uint8 )dedsired)
+#define ma_atomic_compare_and_swap_i16(dst, expected, dedsired)         (ma_int16)ma_atomic_compare_and_swap_16((ma_uint16*)dst, (ma_uint16)expected, (ma_uint16)dedsired)
+#define ma_atomic_compare_and_swap_i32(dst, expected, dedsired)         (ma_int32)ma_atomic_compare_and_swap_32((ma_uint32*)dst, (ma_uint32)expected, (ma_uint32)dedsired)
+#define ma_atomic_compare_and_swap_i64(dst, expected, dedsired)         (ma_int64)ma_atomic_compare_and_swap_64((ma_uint64*)dst, (ma_uint64)expected, (ma_uint64)dedsired)
+typedef union
+{
+    ma_uint32 i;
+    float f;
+} ma_atomic_if32;
+typedef union
+{
+    ma_uint64 i;
+    double f;
+} ma_atomic_if64;
+#define ma_atomic_clear_explicit_f32(ptr, order)                        ma_atomic_clear_explicit_32((ma_uint32*)ptr, order)
+#define ma_atomic_clear_explicit_f64(ptr, order)                        ma_atomic_clear_explicit_64((ma_uint64*)ptr, order)
+static MA_INLINE void ma_atomic_store_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 x;
+    x.f = src;
+    ma_atomic_store_explicit_32((volatile ma_uint32*)dst, x.i, order);
+}
+static MA_INLINE void ma_atomic_store_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 x;
+    x.f = src;
+    ma_atomic_store_explicit_64((volatile ma_uint64*)dst, x.i, order);
+}
+static MA_INLINE float ma_atomic_load_explicit_f32(volatile const float* ptr, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    r.i = ma_atomic_load_explicit_32((volatile const ma_uint32*)ptr, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_load_explicit_f64(volatile const double* ptr, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    r.i = ma_atomic_load_explicit_64((volatile const ma_uint64*)ptr, order);
+    return r.f;
+}
+static MA_INLINE float ma_atomic_exchange_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_exchange_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_exchange_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_exchange_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_f32(volatile float* dst, float* expected, float desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+{
+    ma_atomic_if32 d;
+    d.f = desired;
+    return ma_atomic_compare_exchange_strong_explicit_32((volatile ma_uint32*)dst, (ma_uint32*)expected, d.i, successOrder, failureOrder);
+}
+static MA_INLINE ma_bool32 ma_atomic_compare_exchange_strong_explicit_f64(volatile double* dst, double* expected, double desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+{
+    ma_atomic_if64 d;
+    d.f = desired;
+    return ma_atomic_compare_exchange_strong_explicit_64((volatile ma_uint64*)dst, (ma_uint64*)expected, d.i, successOrder, failureOrder);
+}
+static MA_INLINE ma_bool32 ma_atomic_compare_exchange_weak_explicit_f32(volatile float* dst, float* expected, float desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+{
+    ma_atomic_if32 d;
+    d.f = desired;
+    return ma_atomic_compare_exchange_weak_explicit_32((volatile ma_uint32*)dst, (ma_uint32*)expected, d.i, successOrder, failureOrder);
+}
+static MA_INLINE ma_bool32 ma_atomic_compare_exchange_weak_explicit_f64(volatile double* dst, double* expected, double desired, ma_atomic_memory_order successOrder, ma_atomic_memory_order failureOrder)
+{
+    ma_atomic_if64 d;
+    d.f = desired;
+    return ma_atomic_compare_exchange_weak_explicit_64((volatile ma_uint64*)dst, (ma_uint64*)expected, d.i, successOrder, failureOrder);
+}
+static MA_INLINE float ma_atomic_fetch_add_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_add_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_fetch_add_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_add_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE float ma_atomic_fetch_sub_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_sub_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_fetch_sub_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_sub_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE float ma_atomic_fetch_or_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_or_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_fetch_or_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_or_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE float ma_atomic_fetch_xor_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_xor_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_fetch_xor_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_xor_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE float ma_atomic_fetch_and_explicit_f32(volatile float* dst, float src, ma_atomic_memory_order order)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_and_explicit_32((volatile ma_uint32*)dst, x.i, order);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_fetch_and_explicit_f64(volatile double* dst, double src, ma_atomic_memory_order order)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 x;
+    x.f = src;
+    r.i = ma_atomic_fetch_and_explicit_64((volatile ma_uint64*)dst, x.i, order);
+    return r.f;
+}
+#define ma_atomic_clear_f32(ptr)                                        (float )ma_atomic_clear_explicit_f32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_clear_f64(ptr)                                        (double)ma_atomic_clear_explicit_f64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_f32(dst, src)                                   ma_atomic_store_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_store_f64(dst, src)                                   ma_atomic_store_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_f32(ptr)                                         (float )ma_atomic_load_explicit_f32(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_load_f64(ptr)                                         (double)ma_atomic_load_explicit_f64(ptr, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_f32(dst, src)                                (float )ma_atomic_exchange_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_exchange_f64(dst, src)                                (double)ma_atomic_exchange_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_f32(dst, expected, desired)   ma_atomic_compare_exchange_strong_explicit_f32(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_strong_f64(dst, expected, desired)   ma_atomic_compare_exchange_strong_explicit_f64(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_f32(dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_f32(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_compare_exchange_weak_f64(dst, expected, desired)     ma_atomic_compare_exchange_weak_explicit_f64(dst, expected, desired, ma_atomic_memory_order_seq_cst, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_f32(dst, src)                               ma_atomic_fetch_add_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_add_f64(dst, src)                               ma_atomic_fetch_add_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_f32(dst, src)                               ma_atomic_fetch_sub_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_sub_f64(dst, src)                               ma_atomic_fetch_sub_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_f32(dst, src)                                ma_atomic_fetch_or_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_or_f64(dst, src)                                ma_atomic_fetch_or_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_f32(dst, src)                               ma_atomic_fetch_xor_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_xor_f64(dst, src)                               ma_atomic_fetch_xor_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_f32(dst, src)                               ma_atomic_fetch_and_explicit_f32(dst, src, ma_atomic_memory_order_seq_cst)
+#define ma_atomic_fetch_and_f64(dst, src)                               ma_atomic_fetch_and_explicit_f64(dst, src, ma_atomic_memory_order_seq_cst)
+static MA_INLINE float ma_atomic_compare_and_swap_f32(volatile float* dst, float expected, float desired)
+{
+    ma_atomic_if32 r;
+    ma_atomic_if32 e, d;
+    e.f = expected;
+    d.f = desired;
+    r.i = ma_atomic_compare_and_swap_32((volatile ma_uint32*)dst, e.i, d.i);
+    return r.f;
+}
+static MA_INLINE double ma_atomic_compare_and_swap_f64(volatile double* dst, double expected, double desired)
+{
+    ma_atomic_if64 r;
+    ma_atomic_if64 e, d;
+    e.f = expected;
+    d.f = desired;
+    r.i = ma_atomic_compare_and_swap_64((volatile ma_uint64*)dst, e.i, d.i);
+    return r.f;
+}
+typedef ma_atomic_flag ma_atomic_spinlock;
+static MA_INLINE void ma_atomic_spinlock_lock(volatile ma_atomic_spinlock* pSpinlock)
+{
+    for (;;) {
+        if (ma_atomic_flag_test_and_set_explicit(pSpinlock, ma_atomic_memory_order_acquire) == 0) {
+            break;
+        }
+        while (c89atoimc_flag_load_explicit(pSpinlock, ma_atomic_memory_order_relaxed) == 1) {
+        }
+    }
+}
+static MA_INLINE void ma_atomic_spinlock_unlock(volatile ma_atomic_spinlock* pSpinlock)
+{
+    ma_atomic_flag_clear_explicit(pSpinlock, ma_atomic_memory_order_release);
+}
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic pop
+#endif
+#if defined(__cplusplus)
+}
+#endif
+#endif
+/* ma_atomic.h end */
+
+#define MA_ATOMIC_SAFE_TYPE_IMPL(c89TypeExtension, type) \
+    static MA_INLINE ma_##type ma_atomic_##type##_get(ma_atomic_##type* x) \
+    { \
+        return (ma_##type)ma_atomic_load_##c89TypeExtension(&x->value); \
+    } \
+    static MA_INLINE void ma_atomic_##type##_set(ma_atomic_##type* x, ma_##type value) \
+    { \
+        ma_atomic_store_##c89TypeExtension(&x->value, value); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_exchange(ma_atomic_##type* x, ma_##type value) \
+    { \
+        return (ma_##type)ma_atomic_exchange_##c89TypeExtension(&x->value, value); \
+    } \
+    static MA_INLINE ma_bool32 ma_atomic_##type##_compare_exchange(ma_atomic_##type* x, ma_##type* expected, ma_##type desired) \
+    { \
+        return ma_atomic_compare_exchange_weak_##c89TypeExtension(&x->value, expected, desired); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_fetch_add(ma_atomic_##type* x, ma_##type y) \
+    { \
+        return (ma_##type)ma_atomic_fetch_add_##c89TypeExtension(&x->value, y); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_fetch_sub(ma_atomic_##type* x, ma_##type y) \
+    { \
+        return (ma_##type)ma_atomic_fetch_sub_##c89TypeExtension(&x->value, y); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_fetch_or(ma_atomic_##type* x, ma_##type y) \
+    { \
+        return (ma_##type)ma_atomic_fetch_or_##c89TypeExtension(&x->value, y); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_fetch_xor(ma_atomic_##type* x, ma_##type y) \
+    { \
+        return (ma_##type)ma_atomic_fetch_xor_##c89TypeExtension(&x->value, y); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_fetch_and(ma_atomic_##type* x, ma_##type y) \
+    { \
+        return (ma_##type)ma_atomic_fetch_and_##c89TypeExtension(&x->value, y); \
+    } \
+    static MA_INLINE ma_##type ma_atomic_##type##_compare_and_swap(ma_atomic_##type* x, ma_##type expected, ma_##type desired) \
+    { \
+        return (ma_##type)ma_atomic_compare_and_swap_##c89TypeExtension(&x->value, expected, desired); \
+    } \
+
+#define MA_ATOMIC_SAFE_TYPE_IMPL_PTR(type) \
+    static MA_INLINE ma_##type* ma_atomic_ptr_##type##_get(ma_atomic_ptr_##type* x) \
+    { \
+        return ma_atomic_load_ptr((void**)&x->value); \
+    } \
+    static MA_INLINE void ma_atomic_ptr_##type##_set(ma_atomic_ptr_##type* x, ma_##type* value) \
+    { \
+        ma_atomic_store_ptr((void**)&x->value, (void*)value); \
+    } \
+    static MA_INLINE ma_##type* ma_atomic_ptr_##type##_exchange(ma_atomic_ptr_##type* x, ma_##type* value) \
+    { \
+        return ma_atomic_exchange_ptr((void**)&x->value, (void*)value); \
+    } \
+    static MA_INLINE ma_bool32 ma_atomic_ptr_##type##_compare_exchange(ma_atomic_ptr_##type* x, ma_##type** expected, ma_##type* desired) \
+    { \
+        return ma_atomic_compare_exchange_weak_ptr((void**)&x->value, (void*)expected, (void*)desired); \
+    } \
+    static MA_INLINE ma_##type* ma_atomic_ptr_##type##_compare_and_swap(ma_atomic_ptr_##type* x, ma_##type* expected, ma_##type* desired) \
+    { \
+        return (ma_##type*)ma_atomic_compare_and_swap_ptr((void**)&x->value, (void*)expected, (void*)desired); \
+    } \
+
+MA_ATOMIC_SAFE_TYPE_IMPL(32,  uint32)
+MA_ATOMIC_SAFE_TYPE_IMPL(i32, int32)
+MA_ATOMIC_SAFE_TYPE_IMPL(64,  uint64)
+MA_ATOMIC_SAFE_TYPE_IMPL(f32, float)
+MA_ATOMIC_SAFE_TYPE_IMPL(32,  bool32)
+
+#if !defined(MA_NO_DEVICE_IO)
+MA_ATOMIC_SAFE_TYPE_IMPL(i32, device_state)
+#endif
+
+
+MA_API ma_uint64 ma_calculate_frame_count_after_resampling(ma_uint32 sampleRateOut, ma_uint32 sampleRateIn, ma_uint64 frameCountIn)
+{
+    /* This is based on the calculation in ma_linear_resampler_get_expected_output_frame_count(). */
+    ma_uint64 outputFrameCount;
+    ma_uint64 preliminaryInputFrameCountFromFrac;
+    ma_uint64 preliminaryInputFrameCount;
+
+    if (sampleRateIn == 0 || sampleRateOut == 0 || frameCountIn == 0) {
+        return 0;
+    }
+
+    if (sampleRateOut == sampleRateIn) {
+        return frameCountIn;
+    }
+
+    outputFrameCount = (frameCountIn * sampleRateOut) / sampleRateIn;
+
+    preliminaryInputFrameCountFromFrac = (outputFrameCount * (sampleRateIn / sampleRateOut)) / sampleRateOut;
+    preliminaryInputFrameCount         = (outputFrameCount * (sampleRateIn % sampleRateOut)) + preliminaryInputFrameCountFromFrac;
+
+    if (preliminaryInputFrameCount <= frameCountIn) {
+        outputFrameCount += 1;
+    }
+
+    return outputFrameCount;
+}
+
+#ifndef MA_DATA_CONVERTER_STACK_BUFFER_SIZE
+#define MA_DATA_CONVERTER_STACK_BUFFER_SIZE     4096
+#endif
+
+
+
+#if defined(MA_WIN32)
+static ma_result ma_result_from_GetLastError(DWORD error)
+{
+    switch (error)
+    {
+        case ERROR_SUCCESS:             return MA_SUCCESS;
+        case ERROR_PATH_NOT_FOUND:      return MA_DOES_NOT_EXIST;
+        case ERROR_TOO_MANY_OPEN_FILES: return MA_TOO_MANY_OPEN_FILES;
+        case ERROR_NOT_ENOUGH_MEMORY:   return MA_OUT_OF_MEMORY;
+        case ERROR_DISK_FULL:           return MA_NO_SPACE;
+        case ERROR_HANDLE_EOF:          return MA_AT_END;
+        case ERROR_NEGATIVE_SEEK:       return MA_BAD_SEEK;
+        case ERROR_INVALID_PARAMETER:   return MA_INVALID_ARGS;
+        case ERROR_ACCESS_DENIED:       return MA_ACCESS_DENIED;
+        case ERROR_SEM_TIMEOUT:         return MA_TIMEOUT;
+        case ERROR_FILE_NOT_FOUND:      return MA_DOES_NOT_EXIST;
+        default: break;
+    }
+
+    return MA_ERROR;
+}
+#endif  /* MA_WIN32 */
+
+
+/*******************************************************************************
+
+Threading
+
+*******************************************************************************/
+static MA_INLINE ma_result ma_spinlock_lock_ex(volatile ma_spinlock* pSpinlock, ma_bool32 yield)
+{
+    if (pSpinlock == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (;;) {
+        if (ma_atomic_exchange_explicit_32(pSpinlock, 1, ma_atomic_memory_order_acquire) == 0) {
+            break;
+        }
+
+        while (ma_atomic_load_explicit_32(pSpinlock, ma_atomic_memory_order_relaxed) == 1) {
+            if (yield) {
+                ma_yield();
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spinlock_lock(volatile ma_spinlock* pSpinlock)
+{
+    return ma_spinlock_lock_ex(pSpinlock, MA_TRUE);
+}
+
+MA_API ma_result ma_spinlock_lock_noyield(volatile ma_spinlock* pSpinlock)
+{
+    return ma_spinlock_lock_ex(pSpinlock, MA_FALSE);
+}
+
+MA_API ma_result ma_spinlock_unlock(volatile ma_spinlock* pSpinlock)
+{
+    if (pSpinlock == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_store_explicit_32(pSpinlock, 0, ma_atomic_memory_order_release);
+    return MA_SUCCESS;
+}
+
+
+#ifndef MA_NO_THREADING
+#if defined(MA_POSIX)
+    #define MA_THREADCALL
+    typedef void* ma_thread_result;
+#elif defined(MA_WIN32)
+    #define MA_THREADCALL WINAPI
+    typedef unsigned long ma_thread_result;
+#endif
+
+typedef ma_thread_result (MA_THREADCALL * ma_thread_entry_proc)(void* pData);
+
+#ifdef MA_POSIX
+static ma_result ma_thread_create__posix(ma_thread* pThread, ma_thread_priority priority, size_t stackSize, ma_thread_entry_proc entryProc, void* pData)
+{
+    int result;
+    pthread_attr_t* pAttr = NULL;
+
+#if !defined(__EMSCRIPTEN__)
+    /* Try setting the thread priority. It's not critical if anything fails here. */
+    pthread_attr_t attr;
+    if (pthread_attr_init(&attr) == 0) {
+        int scheduler = -1;
+
+        /* We successfully initialized our attributes object so we can assign the pointer so it's passed into pthread_create(). */
+        pAttr = &attr;
+
+        /* We need to set the scheduler policy. Only do this if the OS supports pthread_attr_setschedpolicy() */
+        #if !defined(MA_BEOS)
+        {
+            if (priority == ma_thread_priority_idle) {
+            #ifdef SCHED_IDLE
+                if (pthread_attr_setschedpolicy(&attr, SCHED_IDLE) == 0) {
+                    scheduler = SCHED_IDLE;
+                }
+            #endif
+            } else if (priority == ma_thread_priority_realtime) {
+            #ifdef SCHED_FIFO
+                if (pthread_attr_setschedpolicy(&attr, SCHED_FIFO) == 0) {
+                    scheduler = SCHED_FIFO;
+                }
+            #endif
+            #ifdef MA_LINUX
+            } else {
+                scheduler = sched_getscheduler(0);
+            #endif
+            }
+        }
+        #endif
+
+        if (stackSize > 0) {
+            pthread_attr_setstacksize(&attr, stackSize);
+        }
+
+        if (scheduler != -1) {
+            int priorityMin = sched_get_priority_min(scheduler);
+            int priorityMax = sched_get_priority_max(scheduler);
+            int priorityStep = (priorityMax - priorityMin) / 7;  /* 7 = number of priorities supported by miniaudio. */
+
+            struct sched_param sched;
+            if (pthread_attr_getschedparam(&attr, &sched) == 0) {
+                if (priority == ma_thread_priority_idle) {
+                    sched.sched_priority = priorityMin;
+                } else if (priority == ma_thread_priority_realtime) {
+                    sched.sched_priority = priorityMax;
+                } else {
+                    sched.sched_priority += ((int)priority + 5) * priorityStep;  /* +5 because the lowest priority is -5. */
+                    if (sched.sched_priority < priorityMin) {
+                        sched.sched_priority = priorityMin;
+                    }
+                    if (sched.sched_priority > priorityMax) {
+                        sched.sched_priority = priorityMax;
+                    }
+                }
+
+                /* I'm not treating a failure of setting the priority as a critical error so not checking the return value here. */
+                pthread_attr_setschedparam(&attr, &sched);
+            }
+        }
+    }
+#else
+    /* It's the emscripten build. We'll have a few unused parameters. */
+    (void)priority;
+    (void)stackSize;
+#endif
+
+    result = pthread_create((pthread_t*)pThread, pAttr, entryProc, pData);
+
+    /* The thread attributes object is no longer required. */
+    if (pAttr != NULL) {
+        pthread_attr_destroy(pAttr);
+    }
+
+    if (result != 0) {
+        return ma_result_from_errno(result);
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_thread_wait__posix(ma_thread* pThread)
+{
+    pthread_join((pthread_t)*pThread, NULL);
+}
+
+
+static ma_result ma_mutex_init__posix(ma_mutex* pMutex)
+{
+    int result;
+    
+    if (pMutex == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pMutex);
+
+    result = pthread_mutex_init((pthread_mutex_t*)pMutex, NULL);
+    if (result != 0) {
+        return ma_result_from_errno(result);
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_mutex_uninit__posix(ma_mutex* pMutex)
+{
+    pthread_mutex_destroy((pthread_mutex_t*)pMutex);
+}
+
+static void ma_mutex_lock__posix(ma_mutex* pMutex)
+{
+    pthread_mutex_lock((pthread_mutex_t*)pMutex);
+}
+
+static void ma_mutex_unlock__posix(ma_mutex* pMutex)
+{
+    pthread_mutex_unlock((pthread_mutex_t*)pMutex);
+}
+
+
+static ma_result ma_event_init__posix(ma_event* pEvent)
+{
+    int result;
+
+    result = pthread_mutex_init((pthread_mutex_t*)&pEvent->lock, NULL);
+    if (result != 0) {
+        return ma_result_from_errno(result);
+    }
+
+    result = pthread_cond_init((pthread_cond_t*)&pEvent->cond, NULL);
+    if (result != 0) {
+        pthread_mutex_destroy((pthread_mutex_t*)&pEvent->lock);
+        return ma_result_from_errno(result);
+    }
+
+    pEvent->value = 0;
+    return MA_SUCCESS;
+}
+
+static void ma_event_uninit__posix(ma_event* pEvent)
+{
+    pthread_cond_destroy((pthread_cond_t*)&pEvent->cond);
+    pthread_mutex_destroy((pthread_mutex_t*)&pEvent->lock);
+}
+
+static ma_result ma_event_wait__posix(ma_event* pEvent)
+{
+    pthread_mutex_lock((pthread_mutex_t*)&pEvent->lock);
+    {
+        while (pEvent->value == 0) {
+            pthread_cond_wait((pthread_cond_t*)&pEvent->cond, (pthread_mutex_t*)&pEvent->lock);
+        }
+        pEvent->value = 0;  /* Auto-reset. */
+    }
+    pthread_mutex_unlock((pthread_mutex_t*)&pEvent->lock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_event_signal__posix(ma_event* pEvent)
+{
+    pthread_mutex_lock((pthread_mutex_t*)&pEvent->lock);
+    {
+        pEvent->value = 1;
+        pthread_cond_signal((pthread_cond_t*)&pEvent->cond);
+    }
+    pthread_mutex_unlock((pthread_mutex_t*)&pEvent->lock);
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_semaphore_init__posix(int initialValue, ma_semaphore* pSemaphore)
+{
+    int result;
+
+    if (pSemaphore == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pSemaphore->value = initialValue;
+
+    result = pthread_mutex_init((pthread_mutex_t*)&pSemaphore->lock, NULL);
+    if (result != 0) {
+        return ma_result_from_errno(result);  /* Failed to create mutex. */
+    }
+
+    result = pthread_cond_init((pthread_cond_t*)&pSemaphore->cond, NULL);
+    if (result != 0) {
+        pthread_mutex_destroy((pthread_mutex_t*)&pSemaphore->lock);
+        return ma_result_from_errno(result);  /* Failed to create condition variable. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_semaphore_uninit__posix(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        return;
+    }
+
+    pthread_cond_destroy((pthread_cond_t*)&pSemaphore->cond);
+    pthread_mutex_destroy((pthread_mutex_t*)&pSemaphore->lock);
+}
+
+static ma_result ma_semaphore_wait__posix(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pthread_mutex_lock((pthread_mutex_t*)&pSemaphore->lock);
+    {
+        /* We need to wait on a condition variable before escaping. We can't return from this function until the semaphore has been signaled. */
+        while (pSemaphore->value == 0) {
+            pthread_cond_wait((pthread_cond_t*)&pSemaphore->cond, (pthread_mutex_t*)&pSemaphore->lock);
+        }
+
+        pSemaphore->value -= 1;
+    }
+    pthread_mutex_unlock((pthread_mutex_t*)&pSemaphore->lock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_semaphore_release__posix(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pthread_mutex_lock((pthread_mutex_t*)&pSemaphore->lock);
+    {
+        pSemaphore->value += 1;
+        pthread_cond_signal((pthread_cond_t*)&pSemaphore->cond);
+    }
+    pthread_mutex_unlock((pthread_mutex_t*)&pSemaphore->lock);
+
+    return MA_SUCCESS;
+}
+#elif defined(MA_WIN32)
+static int ma_thread_priority_to_win32(ma_thread_priority priority)
+{
+    switch (priority) {
+        case ma_thread_priority_idle:     return THREAD_PRIORITY_IDLE;
+        case ma_thread_priority_lowest:   return THREAD_PRIORITY_LOWEST;
+        case ma_thread_priority_low:      return THREAD_PRIORITY_BELOW_NORMAL;
+        case ma_thread_priority_normal:   return THREAD_PRIORITY_NORMAL;
+        case ma_thread_priority_high:     return THREAD_PRIORITY_ABOVE_NORMAL;
+        case ma_thread_priority_highest:  return THREAD_PRIORITY_HIGHEST;
+        case ma_thread_priority_realtime: return THREAD_PRIORITY_TIME_CRITICAL;
+        default:                          return THREAD_PRIORITY_NORMAL;
+    }
+}
+
+static ma_result ma_thread_create__win32(ma_thread* pThread, ma_thread_priority priority, size_t stackSize, ma_thread_entry_proc entryProc, void* pData)
+{
+    DWORD threadID; /* Not used. Only used for passing into CreateThread() so it doesn't fail on Windows 98. */
+
+    *pThread = CreateThread(NULL, stackSize, entryProc, pData, 0, &threadID);
+    if (*pThread == NULL) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    SetThreadPriority((HANDLE)*pThread, ma_thread_priority_to_win32(priority));
+
+    return MA_SUCCESS;
+}
+
+static void ma_thread_wait__win32(ma_thread* pThread)
+{
+    WaitForSingleObject((HANDLE)*pThread, INFINITE);
+    CloseHandle((HANDLE)*pThread);
+}
+
+
+static ma_result ma_mutex_init__win32(ma_mutex* pMutex)
+{
+    *pMutex = CreateEventA(NULL, FALSE, TRUE, NULL);
+    if (*pMutex == NULL) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_mutex_uninit__win32(ma_mutex* pMutex)
+{
+    CloseHandle((HANDLE)*pMutex);
+}
+
+static void ma_mutex_lock__win32(ma_mutex* pMutex)
+{
+    WaitForSingleObject((HANDLE)*pMutex, INFINITE);
+}
+
+static void ma_mutex_unlock__win32(ma_mutex* pMutex)
+{
+    SetEvent((HANDLE)*pMutex);
+}
+
+
+static ma_result ma_event_init__win32(ma_event* pEvent)
+{
+    *pEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+    if (*pEvent == NULL) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_event_uninit__win32(ma_event* pEvent)
+{
+    CloseHandle((HANDLE)*pEvent);
+}
+
+static ma_result ma_event_wait__win32(ma_event* pEvent)
+{
+    DWORD result = WaitForSingleObject((HANDLE)*pEvent, INFINITE);
+    if (result == WAIT_OBJECT_0) {
+        return MA_SUCCESS;
+    }
+
+    if (result == WAIT_TIMEOUT) {
+        return MA_TIMEOUT;
+    }
+
+    return ma_result_from_GetLastError(GetLastError());
+}
+
+static ma_result ma_event_signal__win32(ma_event* pEvent)
+{
+    BOOL result = SetEvent((HANDLE)*pEvent);
+    if (result == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_semaphore_init__win32(int initialValue, ma_semaphore* pSemaphore)
+{
+    *pSemaphore = CreateSemaphoreW(NULL, (LONG)initialValue, LONG_MAX, NULL);
+    if (*pSemaphore == NULL) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_semaphore_uninit__win32(ma_semaphore* pSemaphore)
+{
+    CloseHandle((HANDLE)*pSemaphore);
+}
+
+static ma_result ma_semaphore_wait__win32(ma_semaphore* pSemaphore)
+{
+    DWORD result = WaitForSingleObject((HANDLE)*pSemaphore, INFINITE);
+    if (result == WAIT_OBJECT_0) {
+        return MA_SUCCESS;
+    }
+
+    if (result == WAIT_TIMEOUT) {
+        return MA_TIMEOUT;
+    }
+
+    return ma_result_from_GetLastError(GetLastError());
+}
+
+static ma_result ma_semaphore_release__win32(ma_semaphore* pSemaphore)
+{
+    BOOL result = ReleaseSemaphore((HANDLE)*pSemaphore, 1, NULL);
+    if (result == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+#endif
+
+typedef struct
+{
+    ma_thread_entry_proc entryProc;
+    void* pData;
+    ma_allocation_callbacks allocationCallbacks;
+} ma_thread_proxy_data;
+
+static ma_thread_result MA_THREADCALL ma_thread_entry_proxy(void* pData)
+{
+    ma_thread_proxy_data* pProxyData = (ma_thread_proxy_data*)pData;
+    ma_thread_entry_proc entryProc;
+    void* pEntryProcData;
+    ma_thread_result result;
+
+    #if defined(MA_ON_THREAD_ENTRY)
+        MA_ON_THREAD_ENTRY
+    #endif
+
+    entryProc = pProxyData->entryProc;
+    pEntryProcData = pProxyData->pData;
+
+    /* Free the proxy data before getting into the real thread entry proc. */
+    ma_free(pProxyData, &pProxyData->allocationCallbacks);
+
+    result = entryProc(pEntryProcData);
+
+    #if defined(MA_ON_THREAD_EXIT)
+        MA_ON_THREAD_EXIT
+    #endif
+
+    return result;
+}
+
+static ma_result ma_thread_create(ma_thread* pThread, ma_thread_priority priority, size_t stackSize, ma_thread_entry_proc entryProc, void* pData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_result result;
+    ma_thread_proxy_data* pProxyData;
+
+    if (pThread == NULL || entryProc == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pProxyData = (ma_thread_proxy_data*)ma_malloc(sizeof(*pProxyData), pAllocationCallbacks);   /* Will be freed by the proxy entry proc. */
+    if (pProxyData == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+#if defined(MA_THREAD_DEFAULT_STACK_SIZE)
+    if (stackSize == 0) {
+        stackSize = MA_THREAD_DEFAULT_STACK_SIZE;
+    }
+#endif
+
+    pProxyData->entryProc = entryProc;
+    pProxyData->pData     = pData;
+    ma_allocation_callbacks_init_copy(&pProxyData->allocationCallbacks, pAllocationCallbacks);
+
+#if defined(MA_POSIX)
+    result = ma_thread_create__posix(pThread, priority, stackSize, ma_thread_entry_proxy, pProxyData);
+#elif defined(MA_WIN32)
+    result = ma_thread_create__win32(pThread, priority, stackSize, ma_thread_entry_proxy, pProxyData);
+#endif
+
+    if (result != MA_SUCCESS) {
+        ma_free(pProxyData, pAllocationCallbacks);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_thread_wait(ma_thread* pThread)
+{
+    if (pThread == NULL) {
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_thread_wait__posix(pThread);
+#elif defined(MA_WIN32)
+    ma_thread_wait__win32(pThread);
+#endif
+}
+
+
+MA_API ma_result ma_mutex_init(ma_mutex* pMutex)
+{
+    if (pMutex == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_mutex_init__posix(pMutex);
+#elif defined(MA_WIN32)
+    return ma_mutex_init__win32(pMutex);
+#endif
+}
+
+MA_API void ma_mutex_uninit(ma_mutex* pMutex)
+{
+    if (pMutex == NULL) {
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_mutex_uninit__posix(pMutex);
+#elif defined(MA_WIN32)
+    ma_mutex_uninit__win32(pMutex);
+#endif
+}
+
+MA_API void ma_mutex_lock(ma_mutex* pMutex)
+{
+    if (pMutex == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_mutex_lock__posix(pMutex);
+#elif defined(MA_WIN32)
+    ma_mutex_lock__win32(pMutex);
+#endif
+}
+
+MA_API void ma_mutex_unlock(ma_mutex* pMutex)
+{
+    if (pMutex == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_mutex_unlock__posix(pMutex);
+#elif defined(MA_WIN32)
+    ma_mutex_unlock__win32(pMutex);
+#endif
+}
+
+
+MA_API ma_result ma_event_init(ma_event* pEvent)
+{
+    if (pEvent == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_event_init__posix(pEvent);
+#elif defined(MA_WIN32)
+    return ma_event_init__win32(pEvent);
+#endif
+}
+
+#if 0
+static ma_result ma_event_alloc_and_init(ma_event** ppEvent, ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_result result;
+    ma_event* pEvent;
+
+    if (ppEvent == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *ppEvent = NULL;
+
+    pEvent = ma_malloc(sizeof(*pEvent), pAllocationCallbacks);
+    if (pEvent == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_event_init(pEvent);
+    if (result != MA_SUCCESS) {
+        ma_free(pEvent, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppEvent = pEvent;
+    return result;
+}
+#endif
+
+MA_API void ma_event_uninit(ma_event* pEvent)
+{
+    if (pEvent == NULL) {
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_event_uninit__posix(pEvent);
+#elif defined(MA_WIN32)
+    ma_event_uninit__win32(pEvent);
+#endif
+}
+
+#if 0
+static void ma_event_uninit_and_free(ma_event* pEvent, ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pEvent == NULL) {
+        return;
+    }
+
+    ma_event_uninit(pEvent);
+    ma_free(pEvent, pAllocationCallbacks);
+}
+#endif
+
+MA_API ma_result ma_event_wait(ma_event* pEvent)
+{
+    if (pEvent == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert to the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_event_wait__posix(pEvent);
+#elif defined(MA_WIN32)
+    return ma_event_wait__win32(pEvent);
+#endif
+}
+
+MA_API ma_result ma_event_signal(ma_event* pEvent)
+{
+    if (pEvent == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert to the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_event_signal__posix(pEvent);
+#elif defined(MA_WIN32)
+    return ma_event_signal__win32(pEvent);
+#endif
+}
+
+
+MA_API ma_result ma_semaphore_init(int initialValue, ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_semaphore_init__posix(initialValue, pSemaphore);
+#elif defined(MA_WIN32)
+    return ma_semaphore_init__win32(initialValue, pSemaphore);
+#endif
+}
+
+MA_API void ma_semaphore_uninit(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return;
+    }
+
+#if defined(MA_POSIX)
+    ma_semaphore_uninit__posix(pSemaphore);
+#elif defined(MA_WIN32)
+    ma_semaphore_uninit__win32(pSemaphore);
+#endif
+}
+
+MA_API ma_result ma_semaphore_wait(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_semaphore_wait__posix(pSemaphore);
+#elif defined(MA_WIN32)
+    return ma_semaphore_wait__win32(pSemaphore);
+#endif
+}
+
+MA_API ma_result ma_semaphore_release(ma_semaphore* pSemaphore)
+{
+    if (pSemaphore == NULL) {
+        MA_ASSERT(MA_FALSE);    /* Fire an assert so the caller is aware of this bug. */
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_POSIX)
+    return ma_semaphore_release__posix(pSemaphore);
+#elif defined(MA_WIN32)
+    return ma_semaphore_release__win32(pSemaphore);
+#endif
+}
+#else
+/* MA_NO_THREADING is set which means threading is disabled. Threading is required by some API families. If any of these are enabled we need to throw an error. */
+#ifndef MA_NO_DEVICE_IO
+#error "MA_NO_THREADING cannot be used without MA_NO_DEVICE_IO";
+#endif
+#endif  /* MA_NO_THREADING */
+
+
+
+#define MA_FENCE_COUNTER_MAX    0x7FFFFFFF
+
+MA_API ma_result ma_fence_init(ma_fence* pFence)
+{
+    if (pFence == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFence);
+    pFence->counter = 0;
+
+    #ifndef MA_NO_THREADING
+    {
+        ma_result result;
+
+        result = ma_event_init(&pFence->e);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+    #endif
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_fence_uninit(ma_fence* pFence)
+{
+    if (pFence == NULL) {
+        return;
+    }
+
+    #ifndef MA_NO_THREADING
+    {
+        ma_event_uninit(&pFence->e);
+    }
+    #endif
+
+    MA_ZERO_OBJECT(pFence);
+}
+
+MA_API ma_result ma_fence_acquire(ma_fence* pFence)
+{
+    if (pFence == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (;;) {
+        ma_uint32 oldCounter = ma_atomic_load_32(&pFence->counter);
+        ma_uint32 newCounter = oldCounter + 1;
+
+        /* Make sure we're not about to exceed our maximum value. */
+        if (newCounter > MA_FENCE_COUNTER_MAX) {
+            MA_ASSERT(MA_FALSE);
+            return MA_OUT_OF_RANGE;
+        }
+
+        if (ma_atomic_compare_exchange_weak_32(&pFence->counter, &oldCounter, newCounter)) {
+            return MA_SUCCESS;
+        } else {
+            if (oldCounter == MA_FENCE_COUNTER_MAX) {
+                MA_ASSERT(MA_FALSE);
+                return MA_OUT_OF_RANGE; /* The other thread took the last available slot. Abort. */
+            }
+        }
+    }
+
+    /* Should never get here. */
+    /*return MA_SUCCESS;*/
+}
+
+MA_API ma_result ma_fence_release(ma_fence* pFence)
+{
+    if (pFence == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (;;) {
+        ma_uint32 oldCounter = ma_atomic_load_32(&pFence->counter);
+        ma_uint32 newCounter = oldCounter - 1;
+
+        if (oldCounter == 0) {
+            MA_ASSERT(MA_FALSE);
+            return MA_INVALID_OPERATION;    /* Acquire/release mismatch. */
+        }
+
+        if (ma_atomic_compare_exchange_weak_32(&pFence->counter, &oldCounter, newCounter)) {
+            #ifndef MA_NO_THREADING
+            {
+                if (newCounter == 0) {
+                    ma_event_signal(&pFence->e);    /* <-- ma_fence_wait() will be waiting on this. */
+                }
+            }
+            #endif
+
+            return MA_SUCCESS;
+        } else {
+            if (oldCounter == 0) {
+                MA_ASSERT(MA_FALSE);
+                return MA_INVALID_OPERATION;    /* Another thread has taken the 0 slot. Acquire/release mismatch. */
+            }
+        }
+    }
+
+    /* Should never get here. */
+    /*return MA_SUCCESS;*/
+}
+
+MA_API ma_result ma_fence_wait(ma_fence* pFence)
+{
+    if (pFence == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (;;) {
+        ma_uint32 counter;
+
+        counter = ma_atomic_load_32(&pFence->counter);
+        if (counter == 0) {
+            /*
+            Counter has hit zero. By the time we get here some other thread may have acquired the
+            fence again, but that is where the caller needs to take care with how they se the fence.
+            */
+            return MA_SUCCESS;
+        }
+
+        /* Getting here means the counter is > 0. We'll need to wait for something to happen. */
+        #ifndef MA_NO_THREADING
+        {
+            ma_result result;
+
+            result = ma_event_wait(&pFence->e);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+        #endif
+    }
+
+    /* Should never get here. */
+    /*return MA_INVALID_OPERATION;*/
+}
+
+
+MA_API ma_result ma_async_notification_signal(ma_async_notification* pNotification)
+{
+    ma_async_notification_callbacks* pNotificationCallbacks = (ma_async_notification_callbacks*)pNotification;
+
+    if (pNotification == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pNotificationCallbacks->onSignal == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    pNotificationCallbacks->onSignal(pNotification);
+    return MA_INVALID_ARGS;
+}
+
+
+static void ma_async_notification_poll__on_signal(ma_async_notification* pNotification)
+{
+    ((ma_async_notification_poll*)pNotification)->signalled = MA_TRUE;
+}
+
+MA_API ma_result ma_async_notification_poll_init(ma_async_notification_poll* pNotificationPoll)
+{
+    if (pNotificationPoll == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pNotificationPoll->cb.onSignal = ma_async_notification_poll__on_signal;
+    pNotificationPoll->signalled = MA_FALSE;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_bool32 ma_async_notification_poll_is_signalled(const ma_async_notification_poll* pNotificationPoll)
+{
+    if (pNotificationPoll == NULL) {
+        return MA_FALSE;
+    }
+
+    return pNotificationPoll->signalled;
+}
+
+
+static void ma_async_notification_event__on_signal(ma_async_notification* pNotification)
+{
+    ma_async_notification_event_signal((ma_async_notification_event*)pNotification);
+}
+
+MA_API ma_result ma_async_notification_event_init(ma_async_notification_event* pNotificationEvent)
+{
+    if (pNotificationEvent == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pNotificationEvent->cb.onSignal = ma_async_notification_event__on_signal;
+
+    #ifndef MA_NO_THREADING
+    {
+        ma_result result;
+
+        result = ma_event_init(&pNotificationEvent->e);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        return MA_NOT_IMPLEMENTED;  /* Threading is disabled. */
+    }
+    #endif
+}
+
+MA_API ma_result ma_async_notification_event_uninit(ma_async_notification_event* pNotificationEvent)
+{
+    if (pNotificationEvent == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #ifndef MA_NO_THREADING
+    {
+        ma_event_uninit(&pNotificationEvent->e);
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        return MA_NOT_IMPLEMENTED;  /* Threading is disabled. */
+    }
+    #endif
+}
+
+MA_API ma_result ma_async_notification_event_wait(ma_async_notification_event* pNotificationEvent)
+{
+    if (pNotificationEvent == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #ifndef MA_NO_THREADING
+    {
+        return ma_event_wait(&pNotificationEvent->e);
+    }
+    #else
+    {
+        return MA_NOT_IMPLEMENTED;  /* Threading is disabled. */
+    }
+    #endif
+}
+
+MA_API ma_result ma_async_notification_event_signal(ma_async_notification_event* pNotificationEvent)
+{
+    if (pNotificationEvent == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #ifndef MA_NO_THREADING
+    {
+        return ma_event_signal(&pNotificationEvent->e);
+    }
+    #else
+    {
+        return MA_NOT_IMPLEMENTED;  /* Threading is disabled. */
+    }
+    #endif
+}
+
+
+
+/************************************************************************************************************************************************************
+
+Job Queue
+
+************************************************************************************************************************************************************/
+MA_API ma_slot_allocator_config ma_slot_allocator_config_init(ma_uint32 capacity)
+{
+    ma_slot_allocator_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.capacity = capacity;
+
+    return config;
+}
+
+
+static MA_INLINE ma_uint32 ma_slot_allocator_calculate_group_capacity(ma_uint32 slotCapacity)
+{
+    ma_uint32 cap = slotCapacity / 32;
+    if ((slotCapacity % 32) != 0) {
+        cap += 1;
+    }
+
+    return cap;
+}
+
+static MA_INLINE ma_uint32 ma_slot_allocator_group_capacity(const ma_slot_allocator* pAllocator)
+{
+    return ma_slot_allocator_calculate_group_capacity(pAllocator->capacity);
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t groupsOffset;
+    size_t slotsOffset;
+} ma_slot_allocator_heap_layout;
+
+static ma_result ma_slot_allocator_get_heap_layout(const ma_slot_allocator_config* pConfig, ma_slot_allocator_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->capacity == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Groups. */
+    pHeapLayout->groupsOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(ma_slot_allocator_calculate_group_capacity(pConfig->capacity) * sizeof(ma_slot_allocator_group));
+
+    /* Slots. */
+    pHeapLayout->slotsOffset  = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(pConfig->capacity * sizeof(ma_uint32));
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_slot_allocator_get_heap_size(const ma_slot_allocator_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_slot_allocator_heap_layout layout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_slot_allocator_get_heap_layout(pConfig, &layout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = layout.sizeInBytes;
+
+    return result;
+}
+
+MA_API ma_result ma_slot_allocator_init_preallocated(const ma_slot_allocator_config* pConfig, void* pHeap, ma_slot_allocator* pAllocator)
+{
+    ma_result result;
+    ma_slot_allocator_heap_layout heapLayout;
+
+    if (pAllocator == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pAllocator);
+
+    if (pHeap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_slot_allocator_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pAllocator->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pAllocator->pGroups  = (ma_slot_allocator_group*)ma_offset_ptr(pHeap, heapLayout.groupsOffset);
+    pAllocator->pSlots   = (ma_uint32*)ma_offset_ptr(pHeap, heapLayout.slotsOffset);
+    pAllocator->capacity = pConfig->capacity;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_slot_allocator_init(const ma_slot_allocator_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_slot_allocator* pAllocator)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_slot_allocator_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the size of the heap allocation. */
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_slot_allocator_init_preallocated(pConfig, pHeap, pAllocator);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pAllocator->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_slot_allocator_uninit(ma_slot_allocator* pAllocator, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocator == NULL) {
+        return;
+    }
+
+    if (pAllocator->_ownsHeap) {
+        ma_free(pAllocator->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_slot_allocator_alloc(ma_slot_allocator* pAllocator, ma_uint64* pSlot)
+{
+    ma_uint32 iAttempt;
+    const ma_uint32 maxAttempts = 2;    /* The number of iterations to perform until returning MA_OUT_OF_MEMORY if no slots can be found. */
+
+    if (pAllocator == NULL || pSlot == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iAttempt = 0; iAttempt < maxAttempts; iAttempt += 1) {
+        /* We need to acquire a suitable bitfield first. This is a bitfield that's got an available slot within it. */
+        ma_uint32 iGroup;
+        for (iGroup = 0; iGroup < ma_slot_allocator_group_capacity(pAllocator); iGroup += 1) {
+            /* CAS */
+            for (;;) {
+                ma_uint32 oldBitfield;
+                ma_uint32 newBitfield;
+                ma_uint32 bitOffset;
+
+                oldBitfield = ma_atomic_load_32(&pAllocator->pGroups[iGroup].bitfield);  /* <-- This copy must happen. The compiler must not optimize this away. */
+
+                /* Fast check to see if anything is available. */
+                if (oldBitfield == 0xFFFFFFFF) {
+                    break;  /* No available bits in this bitfield. */
+                }
+
+                bitOffset = ma_ffs_32(~oldBitfield);
+                MA_ASSERT(bitOffset < 32);
+
+                newBitfield = oldBitfield | (1 << bitOffset);
+
+                if (ma_atomic_compare_and_swap_32(&pAllocator->pGroups[iGroup].bitfield, oldBitfield, newBitfield) == oldBitfield) {
+                    ma_uint32 slotIndex;
+
+                    /* Increment the counter as soon as possible to have other threads report out-of-memory sooner than later. */
+                    ma_atomic_fetch_add_32(&pAllocator->count, 1);
+
+                    /* The slot index is required for constructing the output value. */
+                    slotIndex = (iGroup << 5) + bitOffset;  /* iGroup << 5 = iGroup * 32 */
+                    if (slotIndex >= pAllocator->capacity) {
+                        return MA_OUT_OF_MEMORY;
+                    }
+
+                    /* Increment the reference count before constructing the output value. */
+                    pAllocator->pSlots[slotIndex] += 1;
+
+                    /* Construct the output value. */
+                    *pSlot = (((ma_uint64)pAllocator->pSlots[slotIndex] << 32) | slotIndex);
+
+                    return MA_SUCCESS;
+                }
+            }
+        }
+
+        /* We weren't able to find a slot. If it's because we've reached our capacity we need to return MA_OUT_OF_MEMORY. Otherwise we need to do another iteration and try again. */
+        if (pAllocator->count < pAllocator->capacity) {
+            ma_yield();
+        } else {
+            return MA_OUT_OF_MEMORY;
+        }
+    }
+
+    /* We couldn't find a slot within the maximum number of attempts. */
+    return MA_OUT_OF_MEMORY;
+}
+
+MA_API ma_result ma_slot_allocator_free(ma_slot_allocator* pAllocator, ma_uint64 slot)
+{
+    ma_uint32 iGroup;
+    ma_uint32 iBit;
+
+    if (pAllocator == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    iGroup = (ma_uint32)((slot & 0xFFFFFFFF) >> 5);   /* slot / 32 */
+    iBit   = (ma_uint32)((slot & 0xFFFFFFFF) & 31);   /* slot % 32 */
+
+    if (iGroup >= ma_slot_allocator_group_capacity(pAllocator)) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ASSERT(iBit < 32);   /* This must be true due to the logic we used to actually calculate it. */
+
+    while (ma_atomic_load_32(&pAllocator->count) > 0) {
+        /* CAS */
+        ma_uint32 oldBitfield;
+        ma_uint32 newBitfield;
+
+        oldBitfield = ma_atomic_load_32(&pAllocator->pGroups[iGroup].bitfield);  /* <-- This copy must happen. The compiler must not optimize this away. */
+        newBitfield = oldBitfield & ~(1 << iBit);
+
+        /* Debugging for checking for double-frees. */
+        #if defined(MA_DEBUG_OUTPUT)
+        {
+            if ((oldBitfield & (1 << iBit)) == 0) {
+                MA_ASSERT(MA_FALSE);    /* Double free detected.*/
+            }
+        }
+        #endif
+
+        if (ma_atomic_compare_and_swap_32(&pAllocator->pGroups[iGroup].bitfield, oldBitfield, newBitfield) == oldBitfield) {
+            ma_atomic_fetch_sub_32(&pAllocator->count, 1);
+            return MA_SUCCESS;
+        }
+    }
+
+    /* Getting here means there are no allocations available for freeing. */
+    return MA_INVALID_OPERATION;
+}
+
+
+#define MA_JOB_ID_NONE      ~((ma_uint64)0)
+#define MA_JOB_SLOT_NONE    (ma_uint16)(~0)
+
+static MA_INLINE ma_uint32 ma_job_extract_refcount(ma_uint64 toc)
+{
+    return (ma_uint32)(toc >> 32);
+}
+
+static MA_INLINE ma_uint16 ma_job_extract_slot(ma_uint64 toc)
+{
+    return (ma_uint16)(toc & 0x0000FFFF);
+}
+
+static MA_INLINE ma_uint16 ma_job_extract_code(ma_uint64 toc)
+{
+    return (ma_uint16)((toc & 0xFFFF0000) >> 16);
+}
+
+static MA_INLINE ma_uint64 ma_job_toc_to_allocation(ma_uint64 toc)
+{
+    return ((ma_uint64)ma_job_extract_refcount(toc) << 32) | (ma_uint64)ma_job_extract_slot(toc);
+}
+
+static MA_INLINE ma_uint64 ma_job_set_refcount(ma_uint64 toc, ma_uint32 refcount)
+{
+    /* Clear the reference count first. */
+    toc = toc & ~((ma_uint64)0xFFFFFFFF << 32);
+    toc = toc |  ((ma_uint64)refcount   << 32);
+
+    return toc;
+}
+
+
+MA_API ma_job ma_job_init(ma_uint16 code)
+{
+    ma_job job;
+
+    MA_ZERO_OBJECT(&job);
+    job.toc.breakup.code = code;
+    job.toc.breakup.slot = MA_JOB_SLOT_NONE;    /* Temp value. Will be allocated when posted to a queue. */
+    job.next             = MA_JOB_ID_NONE;
+
+    return job;
+}
+
+
+static ma_result ma_job_process__noop(ma_job* pJob);
+static ma_result ma_job_process__quit(ma_job* pJob);
+static ma_result ma_job_process__custom(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__load_data_buffer_node(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__free_data_buffer_node(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__page_data_buffer_node(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__load_data_buffer(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__free_data_buffer(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__load_data_stream(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__free_data_stream(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__page_data_stream(ma_job* pJob);
+static ma_result ma_job_process__resource_manager__seek_data_stream(ma_job* pJob);
+
+#if !defined(MA_NO_DEVICE_IO)
+static ma_result ma_job_process__device__aaudio_reroute(ma_job* pJob);
+#endif
+
+static ma_job_proc g_jobVTable[MA_JOB_TYPE_COUNT] =
+{
+    /* Miscellaneous. */
+    ma_job_process__quit,                                       /* MA_JOB_TYPE_QUIT */
+    ma_job_process__custom,                                     /* MA_JOB_TYPE_CUSTOM */
+
+    /* Resource Manager. */
+    ma_job_process__resource_manager__load_data_buffer_node,    /* MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE */
+    ma_job_process__resource_manager__free_data_buffer_node,    /* MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE */
+    ma_job_process__resource_manager__page_data_buffer_node,    /* MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE */
+    ma_job_process__resource_manager__load_data_buffer,         /* MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER */
+    ma_job_process__resource_manager__free_data_buffer,         /* MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER */
+    ma_job_process__resource_manager__load_data_stream,         /* MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM */
+    ma_job_process__resource_manager__free_data_stream,         /* MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM */
+    ma_job_process__resource_manager__page_data_stream,         /* MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_STREAM */
+    ma_job_process__resource_manager__seek_data_stream,         /* MA_JOB_TYPE_RESOURCE_MANAGER_SEEK_DATA_STREAM */
+
+    /* Device. */
+#if !defined(MA_NO_DEVICE_IO)
+    ma_job_process__device__aaudio_reroute                      /*MA_JOB_TYPE_DEVICE_AAUDIO_REROUTE*/
+#endif
+};
+
+MA_API ma_result ma_job_process(ma_job* pJob)
+{
+    if (pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pJob->toc.breakup.code >= MA_JOB_TYPE_COUNT) {
+        return MA_INVALID_OPERATION;
+    }
+
+    return g_jobVTable[pJob->toc.breakup.code](pJob);
+}
+
+static ma_result ma_job_process__noop(ma_job* pJob)
+{
+    MA_ASSERT(pJob != NULL);
+
+    /* No-op. */
+    (void)pJob;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_job_process__quit(ma_job* pJob)
+{
+    return ma_job_process__noop(pJob);
+}
+
+static ma_result ma_job_process__custom(ma_job* pJob)
+{
+    MA_ASSERT(pJob != NULL);
+
+    /* No-op if there's no callback. */
+    if (pJob->data.custom.proc == NULL) {
+        return MA_SUCCESS;
+    }
+
+    return pJob->data.custom.proc(pJob);
+}
+
+
+
+MA_API ma_job_queue_config ma_job_queue_config_init(ma_uint32 flags, ma_uint32 capacity)
+{
+    ma_job_queue_config config;
+
+    config.flags    = flags;
+    config.capacity = capacity;
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t allocatorOffset;
+    size_t jobsOffset;
+} ma_job_queue_heap_layout;
+
+static ma_result ma_job_queue_get_heap_layout(const ma_job_queue_config* pConfig, ma_job_queue_heap_layout* pHeapLayout)
+{
+    ma_result result;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->capacity == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Allocator. */
+    {
+        ma_slot_allocator_config allocatorConfig;
+        size_t allocatorHeapSizeInBytes;
+
+        allocatorConfig = ma_slot_allocator_config_init(pConfig->capacity);
+        result = ma_slot_allocator_get_heap_size(&allocatorConfig, &allocatorHeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->allocatorOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes    += allocatorHeapSizeInBytes;
+    }
+
+    /* Jobs. */
+    pHeapLayout->jobsOffset   = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(pConfig->capacity * sizeof(ma_job));
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_job_queue_get_heap_size(const ma_job_queue_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_job_queue_heap_layout layout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_job_queue_get_heap_layout(pConfig, &layout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = layout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_job_queue_init_preallocated(const ma_job_queue_config* pConfig, void* pHeap, ma_job_queue* pQueue)
+{
+    ma_result result;
+    ma_job_queue_heap_layout heapLayout;
+    ma_slot_allocator_config allocatorConfig;
+
+    if (pQueue == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pQueue);
+
+    result = ma_job_queue_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pQueue->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pQueue->flags    = pConfig->flags;
+    pQueue->capacity = pConfig->capacity;
+    pQueue->pJobs    = (ma_job*)ma_offset_ptr(pHeap, heapLayout.jobsOffset);
+
+    allocatorConfig = ma_slot_allocator_config_init(pConfig->capacity);
+    result = ma_slot_allocator_init_preallocated(&allocatorConfig, ma_offset_ptr(pHeap, heapLayout.allocatorOffset), &pQueue->allocator);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* We need a semaphore if we're running in non-blocking mode. If threading is disabled we need to return an error. */
+    if ((pQueue->flags & MA_JOB_QUEUE_FLAG_NON_BLOCKING) == 0) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_semaphore_init(0, &pQueue->sem);
+        }
+        #else
+        {
+            /* Threading is disabled and we've requested non-blocking mode. */
+            return MA_INVALID_OPERATION;
+        }
+        #endif
+    }
+
+    /*
+    Our queue needs to be initialized with a free standing node. This should always be slot 0. Required for the lock free algorithm. The first job in the queue is
+    just a dummy item for giving us the first item in the list which is stored in the "next" member.
+    */
+    ma_slot_allocator_alloc(&pQueue->allocator, &pQueue->head);  /* Will never fail. */
+    pQueue->pJobs[ma_job_extract_slot(pQueue->head)].next = MA_JOB_ID_NONE;
+    pQueue->tail = pQueue->head;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_job_queue_init(const ma_job_queue_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_job_queue* pQueue)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_job_queue_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_job_queue_init_preallocated(pConfig, pHeap, pQueue);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pQueue->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_job_queue_uninit(ma_job_queue* pQueue, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pQueue == NULL) {
+        return;
+    }
+
+    /* All we need to do is uninitialize the semaphore. */
+    if ((pQueue->flags & MA_JOB_QUEUE_FLAG_NON_BLOCKING) == 0) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_semaphore_uninit(&pQueue->sem);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never get here. Should have been checked at initialization time. */
+        }
+        #endif
+    }
+
+    ma_slot_allocator_uninit(&pQueue->allocator, pAllocationCallbacks);
+
+    if (pQueue->_ownsHeap) {
+        ma_free(pQueue->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static ma_bool32 ma_job_queue_cas(volatile ma_uint64* dst, ma_uint64 expected, ma_uint64 desired)
+{
+    /* The new counter is taken from the expected value. */
+    return ma_atomic_compare_and_swap_64(dst, expected, ma_job_set_refcount(desired, ma_job_extract_refcount(expected) + 1)) == expected;
+}
+
+MA_API ma_result ma_job_queue_post(ma_job_queue* pQueue, const ma_job* pJob)
+{
+    /*
+    Lock free queue implementation based on the paper by Michael and Scott: Nonblocking Algorithms and Preemption-Safe Locking on Multiprogrammed Shared Memory Multiprocessors
+    */
+    ma_result result;
+    ma_uint64 slot;
+    ma_uint64 tail;
+    ma_uint64 next;
+
+    if (pQueue == NULL || pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* We need a new slot. */
+    result = ma_slot_allocator_alloc(&pQueue->allocator, &slot);
+    if (result != MA_SUCCESS) {
+        return result;  /* Probably ran out of slots. If so, MA_OUT_OF_MEMORY will be returned. */
+    }
+
+    /* At this point we should have a slot to place the job. */
+    MA_ASSERT(ma_job_extract_slot(slot) < pQueue->capacity);
+
+    /* We need to put the job into memory before we do anything. */
+    pQueue->pJobs[ma_job_extract_slot(slot)]                  = *pJob;
+    pQueue->pJobs[ma_job_extract_slot(slot)].toc.allocation   = slot;                    /* This will overwrite the job code. */
+    pQueue->pJobs[ma_job_extract_slot(slot)].toc.breakup.code = pJob->toc.breakup.code;  /* The job code needs to be applied again because the line above overwrote it. */
+    pQueue->pJobs[ma_job_extract_slot(slot)].next             = MA_JOB_ID_NONE;          /* Reset for safety. */
+
+    #ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+    ma_spinlock_lock(&pQueue->lock);
+    #endif
+    {
+        /* The job is stored in memory so now we need to add it to our linked list. We only ever add items to the end of the list. */
+        for (;;) {
+            tail = ma_atomic_load_64(&pQueue->tail);
+            next = ma_atomic_load_64(&pQueue->pJobs[ma_job_extract_slot(tail)].next);
+
+            if (ma_job_toc_to_allocation(tail) == ma_job_toc_to_allocation(ma_atomic_load_64(&pQueue->tail))) {
+                if (ma_job_extract_slot(next) == 0xFFFF) {
+                    if (ma_job_queue_cas(&pQueue->pJobs[ma_job_extract_slot(tail)].next, next, slot)) {
+                        break;
+                    }
+                } else {
+                    ma_job_queue_cas(&pQueue->tail, tail, ma_job_extract_slot(next));
+                }
+            }
+        }
+        ma_job_queue_cas(&pQueue->tail, tail, slot);
+    }
+    #ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+    ma_spinlock_unlock(&pQueue->lock);
+    #endif
+
+
+    /* Signal the semaphore as the last step if we're using synchronous mode. */
+    if ((pQueue->flags & MA_JOB_QUEUE_FLAG_NON_BLOCKING) == 0) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_semaphore_release(&pQueue->sem);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never get here. Should have been checked at initialization time. */
+        }
+        #endif
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_job_queue_next(ma_job_queue* pQueue, ma_job* pJob)
+{
+    ma_uint64 head;
+    ma_uint64 tail;
+    ma_uint64 next;
+
+    if (pQueue == NULL || pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If we're running in synchronous mode we'll need to wait on a semaphore. */
+    if ((pQueue->flags & MA_JOB_QUEUE_FLAG_NON_BLOCKING) == 0) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_semaphore_wait(&pQueue->sem);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never get here. Should have been checked at initialization time. */
+        }
+        #endif
+    }
+
+    #ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+    ma_spinlock_lock(&pQueue->lock);
+    #endif
+    {
+        /*
+        BUG: In lock-free mode, multiple threads can be in this section of code. The "head" variable in the loop below
+        is stored. One thread can fall through to the freeing of this item while another is still using "head" for the
+        retrieval of the "next" variable.
+
+        The slot allocator might need to make use of some reference counting to ensure it's only truely freed when
+        there are no more references to the item. This must be fixed before removing these locks.
+        */
+
+        /* Now we need to remove the root item from the list. */
+        for (;;) {
+            head = ma_atomic_load_64(&pQueue->head);
+            tail = ma_atomic_load_64(&pQueue->tail);
+            next = ma_atomic_load_64(&pQueue->pJobs[ma_job_extract_slot(head)].next);
+
+            if (ma_job_toc_to_allocation(head) == ma_job_toc_to_allocation(ma_atomic_load_64(&pQueue->head))) {
+                if (ma_job_extract_slot(head) == ma_job_extract_slot(tail)) {
+                    if (ma_job_extract_slot(next) == 0xFFFF) {
+                        #ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+                        ma_spinlock_unlock(&pQueue->lock);
+                        #endif
+                        return MA_NO_DATA_AVAILABLE;
+                    }
+                    ma_job_queue_cas(&pQueue->tail, tail, ma_job_extract_slot(next));
+                } else {
+                    *pJob = pQueue->pJobs[ma_job_extract_slot(next)];
+                    if (ma_job_queue_cas(&pQueue->head, head, ma_job_extract_slot(next))) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    #ifndef MA_USE_EXPERIMENTAL_LOCK_FREE_JOB_QUEUE
+    ma_spinlock_unlock(&pQueue->lock);
+    #endif
+
+    ma_slot_allocator_free(&pQueue->allocator, head);
+
+    /*
+    If it's a quit job make sure it's put back on the queue to ensure other threads have an opportunity to detect it and terminate naturally. We
+    could instead just leave it on the queue, but that would involve fiddling with the lock-free code above and I want to keep that as simple as
+    possible.
+    */
+    if (pJob->toc.breakup.code == MA_JOB_TYPE_QUIT) {
+        ma_job_queue_post(pQueue, pJob);
+        return MA_CANCELLED;    /* Return a cancelled status just in case the thread is checking return codes and not properly checking for a quit job. */
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+/*******************************************************************************
+
+Dynamic Linking
+
+*******************************************************************************/
+#ifdef MA_POSIX
+    /* No need for dlfcn.h if we're not using runtime linking. */
+    #ifndef MA_NO_RUNTIME_LINKING
+        #include <dlfcn.h>
+    #endif
+#endif
+
+MA_API ma_handle ma_dlopen(ma_log* pLog, const char* filename)
+{
+#ifndef MA_NO_RUNTIME_LINKING
+    ma_handle handle;
+
+    ma_log_postf(pLog, MA_LOG_LEVEL_DEBUG, "Loading library: %s\n", filename);
+
+    #ifdef MA_WIN32
+        /* From MSDN: Desktop applications cannot use LoadPackagedLibrary; if a desktop application calls this function it fails with APPMODEL_ERROR_NO_PACKAGE.*/
+        #if !defined(MA_WIN32_UWP) || !(defined(WINAPI_FAMILY) && ((defined(WINAPI_FAMILY_PHONE_APP) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)))
+            handle = (ma_handle)LoadLibraryA(filename);
+        #else
+            /* *sigh* It appears there is no ANSI version of LoadPackagedLibrary()... */
+            WCHAR filenameW[4096];
+            if (MultiByteToWideChar(CP_UTF8, 0, filename, -1, filenameW, sizeof(filenameW)) == 0) {
+                handle = NULL;
+            } else {
+                handle = (ma_handle)LoadPackagedLibrary(filenameW, 0);
+            }
+        #endif
+    #else
+        handle = (ma_handle)dlopen(filename, RTLD_NOW);
+    #endif
+
+    /*
+    I'm not considering failure to load a library an error nor a warning because seamlessly falling through to a lower-priority
+    backend is a deliberate design choice. Instead I'm logging it as an informational message.
+    */
+    if (handle == NULL) {
+        ma_log_postf(pLog, MA_LOG_LEVEL_INFO, "Failed to load library: %s\n", filename);
+    }
+
+    return handle;
+#else
+    /* Runtime linking is disabled. */
+    (void)pLog;
+    (void)filename;
+    return NULL;
+#endif
+}
+
+MA_API void ma_dlclose(ma_log* pLog, ma_handle handle)
+{
+#ifndef MA_NO_RUNTIME_LINKING
+    #ifdef MA_WIN32
+        FreeLibrary((HMODULE)handle);
+    #else
+        dlclose((void*)handle);
+    #endif
+
+    (void)pLog;
+#else
+    /* Runtime linking is disabled. */
+    (void)pLog;
+    (void)handle;
+#endif
+}
+
+MA_API ma_proc ma_dlsym(ma_log* pLog, ma_handle handle, const char* symbol)
+{
+#ifndef MA_NO_RUNTIME_LINKING
+    ma_proc proc;
+
+    ma_log_postf(pLog, MA_LOG_LEVEL_DEBUG, "Loading symbol: %s\n", symbol);
+
+#ifdef _WIN32
+    proc = (ma_proc)GetProcAddress((HMODULE)handle, symbol);
+#else
+#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wpedantic"
+#endif
+    proc = (ma_proc)dlsym((void*)handle, symbol);
+#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+    #pragma GCC diagnostic pop
+#endif
+#endif
+
+    if (proc == NULL) {
+        ma_log_postf(pLog, MA_LOG_LEVEL_WARNING, "Failed to load symbol: %s\n", symbol);
+    }
+
+    (void)pLog; /* It's possible for pContext to be unused. */
+    return proc;
+#else
+    /* Runtime linking is disabled. */
+    (void)pLog;
+    (void)handle;
+    (void)symbol;
+    return NULL;
+#endif
+}
+
+
+
+/************************************************************************************************************************************************************
+*************************************************************************************************************************************************************
+
+DEVICE I/O
+==========
+
+*************************************************************************************************************************************************************
+************************************************************************************************************************************************************/
+
+/* Disable run-time linking on certain backends and platforms. */
+#ifndef MA_NO_RUNTIME_LINKING
+    #if defined(MA_EMSCRIPTEN) || defined(MA_ORBIS) || defined(MA_PROSPERO)
+        #define MA_NO_RUNTIME_LINKING
+    #endif
+#endif
+
+#ifndef MA_NO_DEVICE_IO
+
+#if defined(MA_APPLE) && (__MAC_OS_X_VERSION_MIN_REQUIRED < 101200)
+    #include <mach/mach_time.h> /* For mach_absolute_time() */
+#endif
+
+#ifdef MA_POSIX
+    #include <sys/types.h>
+    #include <unistd.h>
+
+    /* No need for dlfcn.h if we're not using runtime linking. */
+    #ifndef MA_NO_RUNTIME_LINKING
+        #include <dlfcn.h>
+    #endif
+#endif
+
+
+
+MA_API void ma_device_info_add_native_data_format(ma_device_info* pDeviceInfo, ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 flags)
+{
+    if (pDeviceInfo == NULL) {
+        return;
+    }
+
+    if (pDeviceInfo->nativeDataFormatCount < ma_countof(pDeviceInfo->nativeDataFormats)) {
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = format;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = sampleRate;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = flags;
+        pDeviceInfo->nativeDataFormatCount += 1;
+    }
+}
+
+
+typedef struct
+{
+    ma_backend backend;
+    const char* pName;
+} ma_backend_info;
+
+static ma_backend_info gBackendInfo[] = /* Indexed by the backend enum. Must be in the order backends are declared in the ma_backend enum. */
+{
+    {ma_backend_wasapi,     "WASAPI"},
+    {ma_backend_dsound,     "DirectSound"},
+    {ma_backend_winmm,      "WinMM"},
+    {ma_backend_coreaudio,  "Core Audio"},
+    {ma_backend_sndio,      "sndio"},
+    {ma_backend_audio4,     "audio(4)"},
+    {ma_backend_oss,        "OSS"},
+    {ma_backend_pulseaudio, "PulseAudio"},
+    {ma_backend_alsa,       "ALSA"},
+    {ma_backend_jack,       "JACK"},
+    {ma_backend_aaudio,     "AAudio"},
+    {ma_backend_opensl,     "OpenSL|ES"},
+    {ma_backend_webaudio,   "Web Audio"},
+    {ma_backend_custom,     "Custom"},
+    {ma_backend_null,       "Null"}
+};
+
+MA_API const char* ma_get_backend_name(ma_backend backend)
+{
+    if (backend < 0 || backend >= (int)ma_countof(gBackendInfo)) {
+        return "Unknown";
+    }
+
+    return gBackendInfo[backend].pName;
+}
+
+MA_API ma_result ma_get_backend_from_name(const char* pBackendName, ma_backend* pBackend)
+{
+    size_t iBackend;
+
+    if (pBackendName == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iBackend = 0; iBackend < ma_countof(gBackendInfo); iBackend += 1) {
+        if (ma_strcmp(pBackendName, gBackendInfo[iBackend].pName) == 0) {
+            if (pBackend != NULL) {
+                *pBackend = gBackendInfo[iBackend].backend;
+            }
+
+            return MA_SUCCESS;
+        }
+    }
+
+    /* Getting here means the backend name is unknown. */
+    return MA_INVALID_ARGS;
+}
+
+MA_API ma_bool32 ma_is_backend_enabled(ma_backend backend)
+{
+    /*
+    This looks a little bit gross, but we want all backends to be included in the switch to avoid warnings on some compilers
+    about some enums not being handled by the switch statement.
+    */
+    switch (backend)
+    {
+        case ma_backend_wasapi:
+        #if defined(MA_HAS_WASAPI)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_dsound:
+        #if defined(MA_HAS_DSOUND)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_winmm:
+        #if defined(MA_HAS_WINMM)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_coreaudio:
+        #if defined(MA_HAS_COREAUDIO)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_sndio:
+        #if defined(MA_HAS_SNDIO)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_audio4:
+        #if defined(MA_HAS_AUDIO4)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_oss:
+        #if defined(MA_HAS_OSS)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_pulseaudio:
+        #if defined(MA_HAS_PULSEAUDIO)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_alsa:
+        #if defined(MA_HAS_ALSA)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_jack:
+        #if defined(MA_HAS_JACK)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_aaudio:
+        #if defined(MA_HAS_AAUDIO)
+            #if defined(MA_ANDROID)
+            {
+                return ma_android_sdk_version() >= 26;
+            }
+            #else
+                return MA_FALSE;
+            #endif
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_opensl:
+        #if defined(MA_HAS_OPENSL)
+            #if defined(MA_ANDROID)
+            {
+                return ma_android_sdk_version() >= 9;
+            }
+            #else
+                return MA_TRUE;
+            #endif
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_webaudio:
+        #if defined(MA_HAS_WEBAUDIO)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_custom:
+        #if defined(MA_HAS_CUSTOM)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+        case ma_backend_null:
+        #if defined(MA_HAS_NULL)
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+
+        default: return MA_FALSE;
+    }
+}
+
+MA_API ma_result ma_get_enabled_backends(ma_backend* pBackends, size_t backendCap, size_t* pBackendCount)
+{
+    size_t backendCount;
+    size_t iBackend;
+    ma_result result = MA_SUCCESS;
+
+    if (pBackendCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    backendCount = 0;
+
+    for (iBackend = 0; iBackend <= ma_backend_null; iBackend += 1) {
+        ma_backend backend = (ma_backend)iBackend;
+
+        if (ma_is_backend_enabled(backend)) {
+            /* The backend is enabled. Try adding it to the list. If there's no room, MA_NO_SPACE needs to be returned. */
+            if (backendCount == backendCap) {
+                result = MA_NO_SPACE;
+                break;
+            } else {
+                pBackends[backendCount] = backend;
+                backendCount += 1;
+            }
+        }
+    }
+
+    if (pBackendCount != NULL) {
+        *pBackendCount = backendCount;
+    }
+
+    return result;
+}
+
+MA_API ma_bool32 ma_is_loopback_supported(ma_backend backend)
+{
+    switch (backend)
+    {
+        case ma_backend_wasapi:     return MA_TRUE;
+        case ma_backend_dsound:     return MA_FALSE;
+        case ma_backend_winmm:      return MA_FALSE;
+        case ma_backend_coreaudio:  return MA_FALSE;
+        case ma_backend_sndio:      return MA_FALSE;
+        case ma_backend_audio4:     return MA_FALSE;
+        case ma_backend_oss:        return MA_FALSE;
+        case ma_backend_pulseaudio: return MA_FALSE;
+        case ma_backend_alsa:       return MA_FALSE;
+        case ma_backend_jack:       return MA_FALSE;
+        case ma_backend_aaudio:     return MA_FALSE;
+        case ma_backend_opensl:     return MA_FALSE;
+        case ma_backend_webaudio:   return MA_FALSE;
+        case ma_backend_custom:     return MA_FALSE;    /* <-- Will depend on the implementation of the backend. */
+        case ma_backend_null:       return MA_FALSE;
+        default:                    return MA_FALSE;
+    }
+}
+
+
+
+#if defined(MA_WIN32)
+/* WASAPI error codes. */
+#define MA_AUDCLNT_E_NOT_INITIALIZED              ((HRESULT)0x88890001)
+#define MA_AUDCLNT_E_ALREADY_INITIALIZED          ((HRESULT)0x88890002)
+#define MA_AUDCLNT_E_WRONG_ENDPOINT_TYPE          ((HRESULT)0x88890003)
+#define MA_AUDCLNT_E_DEVICE_INVALIDATED           ((HRESULT)0x88890004)
+#define MA_AUDCLNT_E_NOT_STOPPED                  ((HRESULT)0x88890005)
+#define MA_AUDCLNT_E_BUFFER_TOO_LARGE             ((HRESULT)0x88890006)
+#define MA_AUDCLNT_E_OUT_OF_ORDER                 ((HRESULT)0x88890007)
+#define MA_AUDCLNT_E_UNSUPPORTED_FORMAT           ((HRESULT)0x88890008)
+#define MA_AUDCLNT_E_INVALID_SIZE                 ((HRESULT)0x88890009)
+#define MA_AUDCLNT_E_DEVICE_IN_USE                ((HRESULT)0x8889000A)
+#define MA_AUDCLNT_E_BUFFER_OPERATION_PENDING     ((HRESULT)0x8889000B)
+#define MA_AUDCLNT_E_THREAD_NOT_REGISTERED        ((HRESULT)0x8889000C)
+#define MA_AUDCLNT_E_NO_SINGLE_PROCESS            ((HRESULT)0x8889000D)
+#define MA_AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED   ((HRESULT)0x8889000E)
+#define MA_AUDCLNT_E_ENDPOINT_CREATE_FAILED       ((HRESULT)0x8889000F)
+#define MA_AUDCLNT_E_SERVICE_NOT_RUNNING          ((HRESULT)0x88890010)
+#define MA_AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED     ((HRESULT)0x88890011)
+#define MA_AUDCLNT_E_EXCLUSIVE_MODE_ONLY          ((HRESULT)0x88890012)
+#define MA_AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL ((HRESULT)0x88890013)
+#define MA_AUDCLNT_E_EVENTHANDLE_NOT_SET          ((HRESULT)0x88890014)
+#define MA_AUDCLNT_E_INCORRECT_BUFFER_SIZE        ((HRESULT)0x88890015)
+#define MA_AUDCLNT_E_BUFFER_SIZE_ERROR            ((HRESULT)0x88890016)
+#define MA_AUDCLNT_E_CPUUSAGE_EXCEEDED            ((HRESULT)0x88890017)
+#define MA_AUDCLNT_E_BUFFER_ERROR                 ((HRESULT)0x88890018)
+#define MA_AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED      ((HRESULT)0x88890019)
+#define MA_AUDCLNT_E_INVALID_DEVICE_PERIOD        ((HRESULT)0x88890020)
+#define MA_AUDCLNT_E_INVALID_STREAM_FLAG          ((HRESULT)0x88890021)
+#define MA_AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE ((HRESULT)0x88890022)
+#define MA_AUDCLNT_E_OUT_OF_OFFLOAD_RESOURCES     ((HRESULT)0x88890023)
+#define MA_AUDCLNT_E_OFFLOAD_MODE_ONLY            ((HRESULT)0x88890024)
+#define MA_AUDCLNT_E_NONOFFLOAD_MODE_ONLY         ((HRESULT)0x88890025)
+#define MA_AUDCLNT_E_RESOURCES_INVALIDATED        ((HRESULT)0x88890026)
+#define MA_AUDCLNT_E_RAW_MODE_UNSUPPORTED         ((HRESULT)0x88890027)
+#define MA_AUDCLNT_E_ENGINE_PERIODICITY_LOCKED    ((HRESULT)0x88890028)
+#define MA_AUDCLNT_E_ENGINE_FORMAT_LOCKED         ((HRESULT)0x88890029)
+#define MA_AUDCLNT_E_HEADTRACKING_ENABLED         ((HRESULT)0x88890030)
+#define MA_AUDCLNT_E_HEADTRACKING_UNSUPPORTED     ((HRESULT)0x88890040)
+#define MA_AUDCLNT_S_BUFFER_EMPTY                 ((HRESULT)0x08890001)
+#define MA_AUDCLNT_S_THREAD_ALREADY_REGISTERED    ((HRESULT)0x08890002)
+#define MA_AUDCLNT_S_POSITION_STALLED             ((HRESULT)0x08890003)
+
+#define MA_DS_OK                                  ((HRESULT)0)
+#define MA_DS_NO_VIRTUALIZATION                   ((HRESULT)0x0878000A)
+#define MA_DSERR_ALLOCATED                        ((HRESULT)0x8878000A)
+#define MA_DSERR_CONTROLUNAVAIL                   ((HRESULT)0x8878001E)
+#define MA_DSERR_INVALIDPARAM                     ((HRESULT)0x80070057) /*E_INVALIDARG*/
+#define MA_DSERR_INVALIDCALL                      ((HRESULT)0x88780032)
+#define MA_DSERR_GENERIC                          ((HRESULT)0x80004005) /*E_FAIL*/
+#define MA_DSERR_PRIOLEVELNEEDED                  ((HRESULT)0x88780046)
+#define MA_DSERR_OUTOFMEMORY                      ((HRESULT)0x8007000E) /*E_OUTOFMEMORY*/
+#define MA_DSERR_BADFORMAT                        ((HRESULT)0x88780064)
+#define MA_DSERR_UNSUPPORTED                      ((HRESULT)0x80004001) /*E_NOTIMPL*/
+#define MA_DSERR_NODRIVER                         ((HRESULT)0x88780078)
+#define MA_DSERR_ALREADYINITIALIZED               ((HRESULT)0x88780082)
+#define MA_DSERR_NOAGGREGATION                    ((HRESULT)0x80040110) /*CLASS_E_NOAGGREGATION*/
+#define MA_DSERR_BUFFERLOST                       ((HRESULT)0x88780096)
+#define MA_DSERR_OTHERAPPHASPRIO                  ((HRESULT)0x887800A0)
+#define MA_DSERR_UNINITIALIZED                    ((HRESULT)0x887800AA)
+#define MA_DSERR_NOINTERFACE                      ((HRESULT)0x80004002) /*E_NOINTERFACE*/
+#define MA_DSERR_ACCESSDENIED                     ((HRESULT)0x80070005) /*E_ACCESSDENIED*/
+#define MA_DSERR_BUFFERTOOSMALL                   ((HRESULT)0x887800B4)
+#define MA_DSERR_DS8_REQUIRED                     ((HRESULT)0x887800BE)
+#define MA_DSERR_SENDLOOP                         ((HRESULT)0x887800C8)
+#define MA_DSERR_BADSENDBUFFERGUID                ((HRESULT)0x887800D2)
+#define MA_DSERR_OBJECTNOTFOUND                   ((HRESULT)0x88781161)
+#define MA_DSERR_FXUNAVAILABLE                    ((HRESULT)0x887800DC)
+
+static ma_result ma_result_from_HRESULT(HRESULT hr)
+{
+    switch (hr)
+    {
+        case NOERROR:                                   return MA_SUCCESS;
+        /*case S_OK:                                      return MA_SUCCESS;*/
+
+        case E_POINTER:                                 return MA_INVALID_ARGS;
+        case E_UNEXPECTED:                              return MA_ERROR;
+        case E_NOTIMPL:                                 return MA_NOT_IMPLEMENTED;
+        case E_OUTOFMEMORY:                             return MA_OUT_OF_MEMORY;
+        case E_INVALIDARG:                              return MA_INVALID_ARGS;
+        case E_NOINTERFACE:                             return MA_API_NOT_FOUND;
+        case E_HANDLE:                                  return MA_INVALID_ARGS;
+        case E_ABORT:                                   return MA_ERROR;
+        case E_FAIL:                                    return MA_ERROR;
+        case E_ACCESSDENIED:                            return MA_ACCESS_DENIED;
+
+        /* WASAPI */
+        case MA_AUDCLNT_E_NOT_INITIALIZED:              return MA_DEVICE_NOT_INITIALIZED;
+        case MA_AUDCLNT_E_ALREADY_INITIALIZED:          return MA_DEVICE_ALREADY_INITIALIZED;
+        case MA_AUDCLNT_E_WRONG_ENDPOINT_TYPE:          return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_DEVICE_INVALIDATED:           return MA_UNAVAILABLE;
+        case MA_AUDCLNT_E_NOT_STOPPED:                  return MA_DEVICE_NOT_STOPPED;
+        case MA_AUDCLNT_E_BUFFER_TOO_LARGE:             return MA_TOO_BIG;
+        case MA_AUDCLNT_E_OUT_OF_ORDER:                 return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_UNSUPPORTED_FORMAT:           return MA_FORMAT_NOT_SUPPORTED;
+        case MA_AUDCLNT_E_INVALID_SIZE:                 return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_DEVICE_IN_USE:                return MA_BUSY;
+        case MA_AUDCLNT_E_BUFFER_OPERATION_PENDING:     return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_THREAD_NOT_REGISTERED:        return MA_DOES_NOT_EXIST;
+        case MA_AUDCLNT_E_NO_SINGLE_PROCESS:            return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED:   return MA_SHARE_MODE_NOT_SUPPORTED;
+        case MA_AUDCLNT_E_ENDPOINT_CREATE_FAILED:       return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+        case MA_AUDCLNT_E_SERVICE_NOT_RUNNING:          return MA_NOT_CONNECTED;
+        case MA_AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED:     return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_EXCLUSIVE_MODE_ONLY:          return MA_SHARE_MODE_NOT_SUPPORTED;
+        case MA_AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL: return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_EVENTHANDLE_NOT_SET:          return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_INCORRECT_BUFFER_SIZE:        return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_BUFFER_SIZE_ERROR:            return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_CPUUSAGE_EXCEEDED:            return MA_ERROR;
+        case MA_AUDCLNT_E_BUFFER_ERROR:                 return MA_ERROR;
+        case MA_AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED:      return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_INVALID_DEVICE_PERIOD:        return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_INVALID_STREAM_FLAG:          return MA_INVALID_ARGS;
+        case MA_AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE: return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_OUT_OF_OFFLOAD_RESOURCES:     return MA_OUT_OF_MEMORY;
+        case MA_AUDCLNT_E_OFFLOAD_MODE_ONLY:            return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_NONOFFLOAD_MODE_ONLY:         return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_RESOURCES_INVALIDATED:        return MA_INVALID_DATA;
+        case MA_AUDCLNT_E_RAW_MODE_UNSUPPORTED:         return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_ENGINE_PERIODICITY_LOCKED:    return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_ENGINE_FORMAT_LOCKED:         return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_HEADTRACKING_ENABLED:         return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_E_HEADTRACKING_UNSUPPORTED:     return MA_INVALID_OPERATION;
+        case MA_AUDCLNT_S_BUFFER_EMPTY:                 return MA_NO_SPACE;
+        case MA_AUDCLNT_S_THREAD_ALREADY_REGISTERED:    return MA_ALREADY_EXISTS;
+        case MA_AUDCLNT_S_POSITION_STALLED:             return MA_ERROR;
+
+        /* DirectSound */
+        /*case MA_DS_OK:                                  return MA_SUCCESS;*/          /* S_OK */
+        case MA_DS_NO_VIRTUALIZATION:                   return MA_SUCCESS;
+        case MA_DSERR_ALLOCATED:                        return MA_ALREADY_IN_USE;
+        case MA_DSERR_CONTROLUNAVAIL:                   return MA_INVALID_OPERATION;
+        /*case MA_DSERR_INVALIDPARAM:                    return MA_INVALID_ARGS;*/      /* E_INVALIDARG */
+        case MA_DSERR_INVALIDCALL:                      return MA_INVALID_OPERATION;
+        /*case MA_DSERR_GENERIC:                          return MA_ERROR;*/            /* E_FAIL */
+        case MA_DSERR_PRIOLEVELNEEDED:                  return MA_INVALID_OPERATION;
+        /*case MA_DSERR_OUTOFMEMORY:                      return MA_OUT_OF_MEMORY;*/    /* E_OUTOFMEMORY */
+        case MA_DSERR_BADFORMAT:                        return MA_FORMAT_NOT_SUPPORTED;
+        /*case MA_DSERR_UNSUPPORTED:                      return MA_NOT_IMPLEMENTED;*/  /* E_NOTIMPL */
+        case MA_DSERR_NODRIVER:                         return MA_FAILED_TO_INIT_BACKEND;
+        case MA_DSERR_ALREADYINITIALIZED:               return MA_DEVICE_ALREADY_INITIALIZED;
+        case MA_DSERR_NOAGGREGATION:                    return MA_ERROR;
+        case MA_DSERR_BUFFERLOST:                       return MA_UNAVAILABLE;
+        case MA_DSERR_OTHERAPPHASPRIO:                  return MA_ACCESS_DENIED;
+        case MA_DSERR_UNINITIALIZED:                    return MA_DEVICE_NOT_INITIALIZED;
+        /*case MA_DSERR_NOINTERFACE:                      return MA_API_NOT_FOUND;*/    /* E_NOINTERFACE */
+        /*case MA_DSERR_ACCESSDENIED:                     return MA_ACCESS_DENIED;*/    /* E_ACCESSDENIED */
+        case MA_DSERR_BUFFERTOOSMALL:                   return MA_NO_SPACE;
+        case MA_DSERR_DS8_REQUIRED:                     return MA_INVALID_OPERATION;
+        case MA_DSERR_SENDLOOP:                         return MA_DEADLOCK;
+        case MA_DSERR_BADSENDBUFFERGUID:                return MA_INVALID_ARGS;
+        case MA_DSERR_OBJECTNOTFOUND:                   return MA_NO_DEVICE;
+        case MA_DSERR_FXUNAVAILABLE:                    return MA_UNAVAILABLE;
+
+        default:                                        return MA_ERROR;
+    }
+}
+
+/* PROPVARIANT */
+#define MA_VT_LPWSTR    31
+#define MA_VT_BLOB      65
+
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(push)
+    #pragma warning(disable:4201)   /* nonstandard extension used: nameless struct/union */
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wpedantic" /* For ISO C99 doesn't support unnamed structs/unions [-Wpedantic] */
+    #if defined(__clang__)
+        #pragma GCC diagnostic ignored "-Wc11-extensions"   /* anonymous unions are a C11 extension */
+    #endif
+#endif
+typedef struct
+{
+    WORD vt;
+    WORD wReserved1;
+    WORD wReserved2;
+    WORD wReserved3;
+    union
+    {
+        struct
+        {
+            ULONG cbSize;
+            BYTE* pBlobData;
+        } blob;
+        WCHAR* pwszVal;
+        char pad[16];   /* Just to ensure the size of the struct matches the official version. */
+    };
+} MA_PROPVARIANT;
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(pop)
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic pop
+#endif
+
+typedef HRESULT (WINAPI * MA_PFN_CoInitialize)(void* pvReserved);
+typedef HRESULT (WINAPI * MA_PFN_CoInitializeEx)(void* pvReserved, DWORD  dwCoInit);
+typedef void    (WINAPI * MA_PFN_CoUninitialize)(void);
+typedef HRESULT (WINAPI * MA_PFN_CoCreateInstance)(const IID* rclsid, void* pUnkOuter, DWORD dwClsContext, const IID* riid, void* ppv);
+typedef void    (WINAPI * MA_PFN_CoTaskMemFree)(void* pv);
+typedef HRESULT (WINAPI * MA_PFN_PropVariantClear)(MA_PROPVARIANT *pvar);
+typedef int     (WINAPI * MA_PFN_StringFromGUID2)(const GUID* const rguid, WCHAR* lpsz, int cchMax);
+
+typedef HWND    (WINAPI * MA_PFN_GetForegroundWindow)(void);
+typedef HWND    (WINAPI * MA_PFN_GetDesktopWindow)(void);
+
+#if defined(MA_WIN32_DESKTOP)
+/* Microsoft documents these APIs as returning LSTATUS, but the Win32 API shipping with some compilers do not define it. It's just a LONG. */
+typedef LONG    (WINAPI * MA_PFN_RegOpenKeyExA)(HKEY hKey, const char* lpSubKey, DWORD ulOptions, DWORD samDesired, HKEY* phkResult);
+typedef LONG    (WINAPI * MA_PFN_RegCloseKey)(HKEY hKey);
+typedef LONG    (WINAPI * MA_PFN_RegQueryValueExA)(HKEY hKey, const char* lpValueName, DWORD* lpReserved, DWORD* lpType, BYTE* lpData, DWORD* lpcbData);
+#endif  /* MA_WIN32_DESKTOP */
+
+
+MA_API size_t ma_strlen_WCHAR(const WCHAR* str)
+{
+    size_t len = 0;
+    while (str[len] != '\0') {
+        len += 1;
+    }
+
+    return len;
+}
+
+MA_API int ma_strcmp_WCHAR(const WCHAR *s1, const WCHAR *s2)
+{
+    while (*s1 != '\0' && *s1 == *s2) {
+        s1 += 1;
+        s2 += 1;
+    }
+
+    return *s1 - *s2;
+}
+
+MA_API int ma_strcpy_s_WCHAR(WCHAR* dst, size_t dstCap, const WCHAR* src)
+{
+    size_t i;
+
+    if (dst == 0) {
+        return 22;
+    }
+    if (dstCap == 0) {
+        return 34;
+    }
+    if (src == 0) {
+        dst[0] = '\0';
+        return 22;
+    }
+
+    for (i = 0; i < dstCap && src[i] != '\0'; ++i) {
+        dst[i] = src[i];
+    }
+
+    if (i < dstCap) {
+        dst[i] = '\0';
+        return 0;
+    }
+
+    dst[0] = '\0';
+    return 34;
+}
+#endif  /* MA_WIN32 */
+
+
+#define MA_DEFAULT_PLAYBACK_DEVICE_NAME    "Default Playback Device"
+#define MA_DEFAULT_CAPTURE_DEVICE_NAME     "Default Capture Device"
+
+
+
+
+/*******************************************************************************
+
+Timing
+
+*******************************************************************************/
+#if defined(MA_WIN32) && !defined(MA_POSIX)
+    static LARGE_INTEGER g_ma_TimerFrequency;   /* <-- Initialized to zero since it's static. */
+    static void ma_timer_init(ma_timer* pTimer)
+    {
+        LARGE_INTEGER counter;
+
+        if (g_ma_TimerFrequency.QuadPart == 0) {
+            QueryPerformanceFrequency(&g_ma_TimerFrequency);
+        }
+
+        QueryPerformanceCounter(&counter);
+        pTimer->counter = counter.QuadPart;
+    }
+
+    static double ma_timer_get_time_in_seconds(ma_timer* pTimer)
+    {
+        LARGE_INTEGER counter;
+        if (!QueryPerformanceCounter(&counter)) {
+            return 0;
+        }
+
+        return (double)(counter.QuadPart - pTimer->counter) / g_ma_TimerFrequency.QuadPart;
+    }
+#elif defined(MA_APPLE) && (__MAC_OS_X_VERSION_MIN_REQUIRED < 101200)
+    static ma_uint64 g_ma_TimerFrequency = 0;
+    static void ma_timer_init(ma_timer* pTimer)
+    {
+        mach_timebase_info_data_t baseTime;
+        mach_timebase_info(&baseTime);
+        g_ma_TimerFrequency = (baseTime.denom * 1e9) / baseTime.numer;
+
+        pTimer->counter = mach_absolute_time();
+    }
+
+    static double ma_timer_get_time_in_seconds(ma_timer* pTimer)
+    {
+        ma_uint64 newTimeCounter = mach_absolute_time();
+        ma_uint64 oldTimeCounter = pTimer->counter;
+
+        return (newTimeCounter - oldTimeCounter) / g_ma_TimerFrequency;
+    }
+#elif defined(MA_EMSCRIPTEN)
+    static MA_INLINE void ma_timer_init(ma_timer* pTimer)
+    {
+        pTimer->counterD = emscripten_get_now();
+    }
+
+    static MA_INLINE double ma_timer_get_time_in_seconds(ma_timer* pTimer)
+    {
+        return (emscripten_get_now() - pTimer->counterD) / 1000;    /* Emscripten is in milliseconds. */
+    }
+#else
+    #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309L
+        #if defined(CLOCK_MONOTONIC)
+            #define MA_CLOCK_ID CLOCK_MONOTONIC
+        #else
+            #define MA_CLOCK_ID CLOCK_REALTIME
+        #endif
+
+        static void ma_timer_init(ma_timer* pTimer)
+        {
+            struct timespec newTime;
+            clock_gettime(MA_CLOCK_ID, &newTime);
+
+            pTimer->counter = (newTime.tv_sec * 1000000000) + newTime.tv_nsec;
+        }
+
+        static double ma_timer_get_time_in_seconds(ma_timer* pTimer)
+        {
+            ma_uint64 newTimeCounter;
+            ma_uint64 oldTimeCounter;
+
+            struct timespec newTime;
+            clock_gettime(MA_CLOCK_ID, &newTime);
+
+            newTimeCounter = (newTime.tv_sec * 1000000000) + newTime.tv_nsec;
+            oldTimeCounter = pTimer->counter;
+
+            return (newTimeCounter - oldTimeCounter) / 1000000000.0;
+        }
+    #else
+        static void ma_timer_init(ma_timer* pTimer)
+        {
+            struct timeval newTime;
+            gettimeofday(&newTime, NULL);
+
+            pTimer->counter = (newTime.tv_sec * 1000000) + newTime.tv_usec;
+        }
+
+        static double ma_timer_get_time_in_seconds(ma_timer* pTimer)
+        {
+            ma_uint64 newTimeCounter;
+            ma_uint64 oldTimeCounter;
+
+            struct timeval newTime;
+            gettimeofday(&newTime, NULL);
+
+            newTimeCounter = (newTime.tv_sec * 1000000) + newTime.tv_usec;
+            oldTimeCounter = pTimer->counter;
+
+            return (newTimeCounter - oldTimeCounter) / 1000000.0;
+        }
+    #endif
+#endif
+
+
+
+#if 0
+static ma_uint32 ma_get_closest_standard_sample_rate(ma_uint32 sampleRateIn)
+{
+    ma_uint32 closestRate = 0;
+    ma_uint32 closestDiff = 0xFFFFFFFF;
+    size_t iStandardRate;
+
+    for (iStandardRate = 0; iStandardRate < ma_countof(g_maStandardSampleRatePriorities); ++iStandardRate) {
+        ma_uint32 standardRate = g_maStandardSampleRatePriorities[iStandardRate];
+        ma_uint32 diff;
+
+        if (sampleRateIn > standardRate) {
+            diff = sampleRateIn - standardRate;
+        } else {
+            diff = standardRate - sampleRateIn;
+        }
+
+        if (diff == 0) {
+            return standardRate;    /* The input sample rate is a standard rate. */
+        }
+
+        if (closestDiff > diff) {
+            closestDiff = diff;
+            closestRate = standardRate;
+        }
+    }
+
+    return closestRate;
+}
+#endif
+
+
+static MA_INLINE unsigned int ma_device_disable_denormals(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (!pDevice->noDisableDenormals) {
+        return ma_disable_denormals();
+    } else {
+        return 0;
+    }
+}
+
+static MA_INLINE void ma_device_restore_denormals(ma_device* pDevice, unsigned int prevState)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (!pDevice->noDisableDenormals) {
+        ma_restore_denormals(prevState);
+    } else {
+        /* Do nothing. */
+        (void)prevState;
+    }
+}
+
+static ma_device_notification ma_device_notification_init(ma_device* pDevice, ma_device_notification_type type)
+{
+    ma_device_notification notification;
+
+    MA_ZERO_OBJECT(&notification);
+    notification.pDevice = pDevice;
+    notification.type    = type;
+
+    return notification;
+}
+
+static void ma_device__on_notification(ma_device_notification notification)
+{
+    MA_ASSERT(notification.pDevice != NULL);
+
+    if (notification.pDevice->onNotification != NULL) {
+        notification.pDevice->onNotification(&notification);
+    }
+
+    /* TEMP FOR COMPATIBILITY: If it's a stopped notification, fire the onStop callback as well. This is only for backwards compatibility and will be removed. */
+    if (notification.pDevice->onStop != NULL && notification.type == ma_device_notification_type_stopped) {
+        notification.pDevice->onStop(notification.pDevice);
+    }
+}
+
+static void ma_device__on_notification_started(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_started));
+}
+
+static void ma_device__on_notification_stopped(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_stopped));
+}
+
+/* Not all platforms support reroute notifications. */
+#if !defined(MA_EMSCRIPTEN)
+static void ma_device__on_notification_rerouted(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_rerouted));
+}
+#endif
+
+#if defined(MA_EMSCRIPTEN)
+EMSCRIPTEN_KEEPALIVE
+void ma_device__on_notification_unlocked(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_unlocked));
+}
+#endif
+
+
+static void ma_device__on_data_inner(ma_device* pDevice, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
+{
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pDevice->onData != NULL);
+
+    if (!pDevice->noPreSilencedOutputBuffer && pFramesOut != NULL) {
+        ma_silence_pcm_frames(pFramesOut, frameCount, pDevice->playback.format, pDevice->playback.channels);
+    }
+
+    pDevice->onData(pDevice, pFramesOut, pFramesIn, frameCount);
+}
+
+static void ma_device__on_data(ma_device* pDevice, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* Don't read more data from the client if we're in the process of stopping. */
+    if (ma_device_get_state(pDevice) == ma_device_state_stopping) {
+        return;
+    }
+
+    if (pDevice->noFixedSizedCallback) {
+        /* Fast path. Not using a fixed sized callback. Process directly from the specified buffers. */
+        ma_device__on_data_inner(pDevice, pFramesOut, pFramesIn, frameCount);
+    } else {
+        /* Slow path. Using a fixed sized callback. Need to use the intermediary buffer. */
+        ma_uint32 totalFramesProcessed = 0;
+
+        while (totalFramesProcessed < frameCount) {
+            ma_uint32 totalFramesRemaining = frameCount - totalFramesProcessed;
+            ma_uint32 framesToProcessThisIteration = 0;
+
+            if (pFramesIn != NULL) {
+                /* Capturing. Write to the intermediary buffer. If there's no room, fire the callback to empty it. */
+                if (pDevice->capture.intermediaryBufferLen < pDevice->capture.intermediaryBufferCap) {
+                    /* There's some room left in the intermediary buffer. Write to it without firing the callback. */
+                    framesToProcessThisIteration = totalFramesRemaining;
+                    if (framesToProcessThisIteration > pDevice->capture.intermediaryBufferCap - pDevice->capture.intermediaryBufferLen) {
+                        framesToProcessThisIteration = pDevice->capture.intermediaryBufferCap - pDevice->capture.intermediaryBufferLen;
+                    }
+
+                    ma_copy_pcm_frames(
+                        ma_offset_pcm_frames_ptr(pDevice->capture.pIntermediaryBuffer, pDevice->capture.intermediaryBufferLen, pDevice->capture.format, pDevice->capture.channels),
+                        ma_offset_pcm_frames_const_ptr(pFramesIn, totalFramesProcessed, pDevice->capture.format, pDevice->capture.channels),
+                        framesToProcessThisIteration,
+                        pDevice->capture.format, pDevice->capture.channels);
+
+                    pDevice->capture.intermediaryBufferLen += framesToProcessThisIteration;
+                }
+
+                if (pDevice->capture.intermediaryBufferLen == pDevice->capture.intermediaryBufferCap) {
+                    /* No room left in the intermediary buffer. Fire the data callback. */
+                    if (pDevice->type == ma_device_type_duplex) {
+                        /* We'll do the duplex data callback later after we've processed the playback data. */
+                    } else {
+                        ma_device__on_data_inner(pDevice, NULL, pDevice->capture.pIntermediaryBuffer, pDevice->capture.intermediaryBufferCap);
+
+                        /* The intermediary buffer has just been drained. */
+                        pDevice->capture.intermediaryBufferLen = 0;
+                    }
+                }
+            }
+
+            if (pFramesOut != NULL) {
+                /* Playing back. Read from the intermediary buffer. If there's nothing in it, fire the callback to fill it. */
+                if (pDevice->playback.intermediaryBufferLen > 0) {
+                    /* There's some content in the intermediary buffer. Read from that without firing the callback. */
+                    if (pDevice->type == ma_device_type_duplex) {
+                        /* The frames processed this iteration for a duplex device will always be based on the capture side. Leave it unmodified. */
+                    } else {
+                        framesToProcessThisIteration = totalFramesRemaining;
+                        if (framesToProcessThisIteration > pDevice->playback.intermediaryBufferLen) {
+                            framesToProcessThisIteration = pDevice->playback.intermediaryBufferLen;
+                        }
+                    }
+
+                    ma_copy_pcm_frames(
+                        ma_offset_pcm_frames_ptr(pFramesOut, totalFramesProcessed, pDevice->playback.format, pDevice->playback.channels),
+                        ma_offset_pcm_frames_ptr(pDevice->playback.pIntermediaryBuffer, pDevice->playback.intermediaryBufferCap - pDevice->playback.intermediaryBufferLen, pDevice->playback.format, pDevice->playback.channels),
+                        framesToProcessThisIteration,
+                        pDevice->playback.format, pDevice->playback.channels);
+
+                    pDevice->playback.intermediaryBufferLen -= framesToProcessThisIteration;
+                }
+
+                if (pDevice->playback.intermediaryBufferLen == 0) {
+                    /* There's nothing in the intermediary buffer. Fire the data callback to fill it. */
+                    if (pDevice->type == ma_device_type_duplex) {
+                        /* In duplex mode, the data callback will be fired later. Nothing to do here. */
+                    } else {
+                        ma_device__on_data_inner(pDevice, pDevice->playback.pIntermediaryBuffer, NULL, pDevice->playback.intermediaryBufferCap);
+
+                        /* The intermediary buffer has just been filled. */
+                        pDevice->playback.intermediaryBufferLen = pDevice->playback.intermediaryBufferCap;
+                    }
+                }
+            }
+
+            /* If we're in duplex mode we might need to do a refill of the data. */
+            if (pDevice->type == ma_device_type_duplex) {
+                if (pDevice->capture.intermediaryBufferLen == pDevice->capture.intermediaryBufferCap) {
+                    ma_device__on_data_inner(pDevice, pDevice->playback.pIntermediaryBuffer, pDevice->capture.pIntermediaryBuffer, pDevice->capture.intermediaryBufferCap);
+
+                    pDevice->playback.intermediaryBufferLen = pDevice->playback.intermediaryBufferCap;  /* The playback buffer will have just been filled. */
+                    pDevice->capture.intermediaryBufferLen  = 0;                                        /* The intermediary buffer has just been drained. */
+                }
+            }
+
+            /* Make sure this is only incremented once in the duplex case. */
+            totalFramesProcessed += framesToProcessThisIteration;
+        }
+    }
+}
+
+static void ma_device__handle_data_callback(ma_device* pDevice, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
+{
+    float masterVolumeFactor;
+
+    ma_device_get_master_volume(pDevice, &masterVolumeFactor);  /* Use ma_device_get_master_volume() to ensure the volume is loaded atomically. */
+
+    if (pDevice->onData) {
+        unsigned int prevDenormalState = ma_device_disable_denormals(pDevice);
+        {
+            /* Volume control of input makes things a bit awkward because the input buffer is read-only. We'll need to use a temp buffer and loop in this case. */
+            if (pFramesIn != NULL && masterVolumeFactor < 1) {
+                ma_uint8 tempFramesIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                ma_uint32 bpfCapture  = ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels);
+                ma_uint32 bpfPlayback = ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+                ma_uint32 totalFramesProcessed = 0;
+                while (totalFramesProcessed < frameCount) {
+                    ma_uint32 framesToProcessThisIteration = frameCount - totalFramesProcessed;
+                    if (framesToProcessThisIteration > sizeof(tempFramesIn)/bpfCapture) {
+                        framesToProcessThisIteration = sizeof(tempFramesIn)/bpfCapture;
+                    }
+
+                    ma_copy_and_apply_volume_factor_pcm_frames(tempFramesIn, ma_offset_ptr(pFramesIn, totalFramesProcessed*bpfCapture), framesToProcessThisIteration, pDevice->capture.format, pDevice->capture.channels, masterVolumeFactor);
+
+                    ma_device__on_data(pDevice, ma_offset_ptr(pFramesOut, totalFramesProcessed*bpfPlayback), tempFramesIn, framesToProcessThisIteration);
+
+                    totalFramesProcessed += framesToProcessThisIteration;
+                }
+            } else {
+                ma_device__on_data(pDevice, pFramesOut, pFramesIn, frameCount);
+            }
+
+            /* Volume control and clipping for playback devices. */
+            if (pFramesOut != NULL) {
+                if (masterVolumeFactor < 1) {
+                    if (pFramesIn == NULL) {    /* <-- In full-duplex situations, the volume will have been applied to the input samples before the data callback. Applying it again post-callback will incorrectly compound it. */
+                        ma_apply_volume_factor_pcm_frames(pFramesOut, frameCount, pDevice->playback.format, pDevice->playback.channels, masterVolumeFactor);
+                    }
+                }
+
+                if (!pDevice->noClip && pDevice->playback.format == ma_format_f32) {
+                    ma_clip_samples_f32((float*)pFramesOut, (const float*)pFramesOut, frameCount * pDevice->playback.channels);   /* Intentionally specifying the same pointer for both input and output for in-place processing. */
+                }
+            }
+        }
+        ma_device_restore_denormals(pDevice, prevDenormalState);
+    }
+}
+
+
+
+/* A helper function for reading sample data from the client. */
+static void ma_device__read_frames_from_client(ma_device* pDevice, ma_uint32 frameCount, void* pFramesOut)
+{
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(frameCount > 0);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pDevice->playback.converter.isPassthrough) {
+        ma_device__handle_data_callback(pDevice, pFramesOut, NULL, frameCount);
+    } else {
+        ma_result result;
+        ma_uint64 totalFramesReadOut;
+        void* pRunningFramesOut;
+
+        totalFramesReadOut = 0;
+        pRunningFramesOut  = pFramesOut;
+
+        /*
+        We run slightly different logic depending on whether or not we're using a heap-allocated
+        buffer for caching input data. This will be the case if the data converter does not have
+        the ability to retrieve the required input frame count for a given output frame count.
+        */
+        if (pDevice->playback.pInputCache != NULL) {
+            while (totalFramesReadOut < frameCount) {
+                ma_uint64 framesToReadThisIterationIn;
+                ma_uint64 framesToReadThisIterationOut;
+
+                /* If there's any data available in the cache, that needs to get processed first. */
+                if (pDevice->playback.inputCacheRemaining > 0) {
+                    framesToReadThisIterationOut = (frameCount - totalFramesReadOut);
+                    framesToReadThisIterationIn  = framesToReadThisIterationOut;
+                    if (framesToReadThisIterationIn > pDevice->playback.inputCacheRemaining) {
+                        framesToReadThisIterationIn = pDevice->playback.inputCacheRemaining;
+                    }
+
+                    result = ma_data_converter_process_pcm_frames(&pDevice->playback.converter, ma_offset_pcm_frames_ptr(pDevice->playback.pInputCache, pDevice->playback.inputCacheConsumed, pDevice->playback.format, pDevice->playback.channels), &framesToReadThisIterationIn, pRunningFramesOut, &framesToReadThisIterationOut);
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+
+                    pDevice->playback.inputCacheConsumed  += framesToReadThisIterationIn;
+                    pDevice->playback.inputCacheRemaining -= framesToReadThisIterationIn;
+
+                    totalFramesReadOut += framesToReadThisIterationOut;
+                    pRunningFramesOut   = ma_offset_ptr(pRunningFramesOut, framesToReadThisIterationOut * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+
+                    if (framesToReadThisIterationIn == 0 && framesToReadThisIterationOut == 0) {
+                        break;  /* We're done. */
+                    }
+                }
+
+                /* Getting here means there's no data in the cache and we need to fill it up with data from the client. */
+                if (pDevice->playback.inputCacheRemaining == 0) {
+                    ma_device__handle_data_callback(pDevice, pDevice->playback.pInputCache, NULL, (ma_uint32)pDevice->playback.inputCacheCap);
+
+                    pDevice->playback.inputCacheConsumed  = 0;
+                    pDevice->playback.inputCacheRemaining = pDevice->playback.inputCacheCap;
+                }
+            }
+        } else {
+            while (totalFramesReadOut < frameCount) {
+                ma_uint8 pIntermediaryBuffer[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In client format. */
+                ma_uint64 intermediaryBufferCap = sizeof(pIntermediaryBuffer) / ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+                ma_uint64 framesToReadThisIterationIn;
+                ma_uint64 framesReadThisIterationIn;
+                ma_uint64 framesToReadThisIterationOut;
+                ma_uint64 framesReadThisIterationOut;
+                ma_uint64 requiredInputFrameCount;
+
+                framesToReadThisIterationOut = (frameCount - totalFramesReadOut);
+                framesToReadThisIterationIn = framesToReadThisIterationOut;
+                if (framesToReadThisIterationIn > intermediaryBufferCap) {
+                    framesToReadThisIterationIn = intermediaryBufferCap;
+                }
+
+                ma_data_converter_get_required_input_frame_count(&pDevice->playback.converter, framesToReadThisIterationOut, &requiredInputFrameCount);
+                if (framesToReadThisIterationIn > requiredInputFrameCount) {
+                    framesToReadThisIterationIn = requiredInputFrameCount;
+                }
+
+                if (framesToReadThisIterationIn > 0) {
+                    ma_device__handle_data_callback(pDevice, pIntermediaryBuffer, NULL, (ma_uint32)framesToReadThisIterationIn);
+                }
+
+                /*
+                At this point we have our decoded data in input format and now we need to convert to output format. Note that even if we didn't read any
+                input frames, we still want to try processing frames because there may some output frames generated from cached input data.
+                */
+                framesReadThisIterationIn  = framesToReadThisIterationIn;
+                framesReadThisIterationOut = framesToReadThisIterationOut;
+                result = ma_data_converter_process_pcm_frames(&pDevice->playback.converter, pIntermediaryBuffer, &framesReadThisIterationIn, pRunningFramesOut, &framesReadThisIterationOut);
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+
+                totalFramesReadOut += framesReadThisIterationOut;
+                pRunningFramesOut   = ma_offset_ptr(pRunningFramesOut, framesReadThisIterationOut * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+
+                if (framesReadThisIterationIn == 0 && framesReadThisIterationOut == 0) {
+                    break;  /* We're done. */
+                }
+            }
+        }
+    }
+}
+
+/* A helper for sending sample data to the client. */
+static void ma_device__send_frames_to_client(ma_device* pDevice, ma_uint32 frameCountInDeviceFormat, const void* pFramesInDeviceFormat)
+{
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(frameCountInDeviceFormat > 0);
+    MA_ASSERT(pFramesInDeviceFormat != NULL);
+
+    if (pDevice->capture.converter.isPassthrough) {
+        ma_device__handle_data_callback(pDevice, NULL, pFramesInDeviceFormat, frameCountInDeviceFormat);
+    } else {
+        ma_result result;
+        ma_uint8 pFramesInClientFormat[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+        ma_uint64 framesInClientFormatCap = sizeof(pFramesInClientFormat) / ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels);
+        ma_uint64 totalDeviceFramesProcessed = 0;
+        ma_uint64 totalClientFramesProcessed = 0;
+        const void* pRunningFramesInDeviceFormat = pFramesInDeviceFormat;
+
+        /* We just keep going until we've exhaused all of our input frames and cannot generate any more output frames. */
+        for (;;) {
+            ma_uint64 deviceFramesProcessedThisIteration;
+            ma_uint64 clientFramesProcessedThisIteration;
+
+            deviceFramesProcessedThisIteration = (frameCountInDeviceFormat - totalDeviceFramesProcessed);
+            clientFramesProcessedThisIteration = framesInClientFormatCap;
+
+            result = ma_data_converter_process_pcm_frames(&pDevice->capture.converter, pRunningFramesInDeviceFormat, &deviceFramesProcessedThisIteration, pFramesInClientFormat, &clientFramesProcessedThisIteration);
+            if (result != MA_SUCCESS) {
+                break;
+            }
+
+            if (clientFramesProcessedThisIteration > 0) {
+                ma_device__handle_data_callback(pDevice, NULL, pFramesInClientFormat, (ma_uint32)clientFramesProcessedThisIteration);    /* Safe cast. */
+            }
+
+            pRunningFramesInDeviceFormat = ma_offset_ptr(pRunningFramesInDeviceFormat, deviceFramesProcessedThisIteration * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels));
+            totalDeviceFramesProcessed  += deviceFramesProcessedThisIteration;
+            totalClientFramesProcessed  += clientFramesProcessedThisIteration;
+
+            /* This is just to silence a warning. I might want to use this variable later so leaving in place for now. */
+            (void)totalClientFramesProcessed;
+
+            if (deviceFramesProcessedThisIteration == 0 && clientFramesProcessedThisIteration == 0) {
+                break;  /* We're done. */
+            }
+        }
+    }
+}
+
+static ma_result ma_device__handle_duplex_callback_capture(ma_device* pDevice, ma_uint32 frameCountInDeviceFormat, const void* pFramesInDeviceFormat, ma_pcm_rb* pRB)
+{
+    ma_result result;
+    ma_uint32 totalDeviceFramesProcessed = 0;
+    const void* pRunningFramesInDeviceFormat = pFramesInDeviceFormat;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(frameCountInDeviceFormat > 0);
+    MA_ASSERT(pFramesInDeviceFormat != NULL);
+    MA_ASSERT(pRB != NULL);
+
+    /* Write to the ring buffer. The ring buffer is in the client format which means we need to convert. */
+    for (;;) {
+        ma_uint32 framesToProcessInDeviceFormat = (frameCountInDeviceFormat - totalDeviceFramesProcessed);
+        ma_uint32 framesToProcessInClientFormat = MA_DATA_CONVERTER_STACK_BUFFER_SIZE / ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels);
+        ma_uint64 framesProcessedInDeviceFormat;
+        ma_uint64 framesProcessedInClientFormat;
+        void* pFramesInClientFormat;
+
+        result = ma_pcm_rb_acquire_write(pRB, &framesToProcessInClientFormat, &pFramesInClientFormat);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "Failed to acquire capture PCM frames from ring buffer.");
+            break;
+        }
+
+        if (framesToProcessInClientFormat == 0) {
+            if (ma_pcm_rb_pointer_distance(pRB) == (ma_int32)ma_pcm_rb_get_subbuffer_size(pRB)) {
+                break;  /* Overrun. Not enough room in the ring buffer for input frame. Excess frames are dropped. */
+            }
+        }
+
+        /* Convert. */
+        framesProcessedInDeviceFormat = framesToProcessInDeviceFormat;
+        framesProcessedInClientFormat = framesToProcessInClientFormat;
+        result = ma_data_converter_process_pcm_frames(&pDevice->capture.converter, pRunningFramesInDeviceFormat, &framesProcessedInDeviceFormat, pFramesInClientFormat, &framesProcessedInClientFormat);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        result = ma_pcm_rb_commit_write(pRB, (ma_uint32)framesProcessedInClientFormat);  /* Safe cast. */
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "Failed to commit capture PCM frames to ring buffer.");
+            break;
+        }
+
+        pRunningFramesInDeviceFormat = ma_offset_ptr(pRunningFramesInDeviceFormat, framesProcessedInDeviceFormat * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels));
+        totalDeviceFramesProcessed += (ma_uint32)framesProcessedInDeviceFormat; /* Safe cast. */
+
+        /* We're done when we're unable to process any client nor device frames. */
+        if (framesProcessedInClientFormat == 0 && framesProcessedInDeviceFormat == 0) {
+            break;  /* Done. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device__handle_duplex_callback_playback(ma_device* pDevice, ma_uint32 frameCount, void* pFramesInInternalFormat, ma_pcm_rb* pRB)
+{
+    ma_result result;
+    ma_uint8 silentInputFrames[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+    ma_uint32 totalFramesReadOut = 0;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(frameCount > 0);
+    MA_ASSERT(pFramesInInternalFormat != NULL);
+    MA_ASSERT(pRB != NULL);
+    MA_ASSERT(pDevice->playback.pInputCache != NULL);
+
+    /*
+    Sitting in the ring buffer should be captured data from the capture callback in external format. If there's not enough data in there for
+    the whole frameCount frames we just use silence instead for the input data.
+    */
+    MA_ZERO_MEMORY(silentInputFrames, sizeof(silentInputFrames));
+
+    while (totalFramesReadOut < frameCount && ma_device_is_started(pDevice)) {
+        /*
+        We should have a buffer allocated on the heap. Any playback frames still sitting in there
+        need to be sent to the internal device before we process any more data from the client.
+        */
+        if (pDevice->playback.inputCacheRemaining > 0) {
+            ma_uint64 framesConvertedIn  = pDevice->playback.inputCacheRemaining;
+            ma_uint64 framesConvertedOut = (frameCount - totalFramesReadOut);
+            ma_data_converter_process_pcm_frames(&pDevice->playback.converter, ma_offset_pcm_frames_ptr(pDevice->playback.pInputCache, pDevice->playback.inputCacheConsumed, pDevice->playback.format, pDevice->playback.channels), &framesConvertedIn, pFramesInInternalFormat, &framesConvertedOut);
+
+            pDevice->playback.inputCacheConsumed  += framesConvertedIn;
+            pDevice->playback.inputCacheRemaining -= framesConvertedIn;
+
+            totalFramesReadOut        += (ma_uint32)framesConvertedOut; /* Safe cast. */
+            pFramesInInternalFormat    = ma_offset_ptr(pFramesInInternalFormat, framesConvertedOut * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+        }
+
+        /* If there's no more data in the cache we'll need to fill it with some. */
+        if (totalFramesReadOut < frameCount && pDevice->playback.inputCacheRemaining == 0) {
+            ma_uint32 inputFrameCount;
+            void* pInputFrames;
+
+            inputFrameCount = (ma_uint32)pDevice->playback.inputCacheCap;
+            result = ma_pcm_rb_acquire_read(pRB, &inputFrameCount, &pInputFrames);
+            if (result == MA_SUCCESS) {
+                if (inputFrameCount > 0) {
+                    ma_device__handle_data_callback(pDevice, pDevice->playback.pInputCache, pInputFrames, inputFrameCount);
+                } else {
+                    if (ma_pcm_rb_pointer_distance(pRB) == 0) {
+                        break;  /* Underrun. */
+                    }
+                }
+            } else {
+                /* No capture data available. Feed in silence. */
+                inputFrameCount = (ma_uint32)ma_min(pDevice->playback.inputCacheCap, sizeof(silentInputFrames) / ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels));
+                ma_device__handle_data_callback(pDevice, pDevice->playback.pInputCache, silentInputFrames, inputFrameCount);
+            }
+
+            pDevice->playback.inputCacheConsumed  = 0;
+            pDevice->playback.inputCacheRemaining = inputFrameCount;
+
+            result = ma_pcm_rb_commit_read(pRB, inputFrameCount);
+            if (result != MA_SUCCESS) {
+                return result;  /* Should never happen. */
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+/* A helper for changing the state of the device. */
+static MA_INLINE void ma_device__set_state(ma_device* pDevice, ma_device_state newState)
+{
+    ma_atomic_device_state_set(&pDevice->state, newState);
+}
+
+
+#if defined(MA_WIN32)
+    static GUID MA_GUID_KSDATAFORMAT_SUBTYPE_PCM        = {0x00000001, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
+    static GUID MA_GUID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT = {0x00000003, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
+    /*static GUID MA_GUID_KSDATAFORMAT_SUBTYPE_ALAW       = {0x00000006, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};*/
+    /*static GUID MA_GUID_KSDATAFORMAT_SUBTYPE_MULAW      = {0x00000007, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};*/
+#endif
+
+
+
+MA_API ma_uint32 ma_get_format_priority_index(ma_format format) /* Lower = better. */
+{
+    ma_uint32 i;
+    for (i = 0; i < ma_countof(g_maFormatPriorities); ++i) {
+        if (g_maFormatPriorities[i] == format) {
+            return i;
+        }
+    }
+
+    /* Getting here means the format could not be found or is equal to ma_format_unknown. */
+    return (ma_uint32)-1;
+}
+
+static ma_result ma_device__post_init_setup(ma_device* pDevice, ma_device_type deviceType);
+
+static ma_bool32 ma_device_descriptor_is_valid(const ma_device_descriptor* pDeviceDescriptor)
+{
+    if (pDeviceDescriptor == NULL) {
+        return MA_FALSE;
+    }
+
+    if (pDeviceDescriptor->format == ma_format_unknown) {
+        return MA_FALSE;
+    }
+
+    if (pDeviceDescriptor->channels == 0 || pDeviceDescriptor->channels > MA_MAX_CHANNELS) {
+        return MA_FALSE;
+    }
+
+    if (pDeviceDescriptor->sampleRate == 0) {
+        return MA_FALSE;
+    }
+
+    return MA_TRUE;
+}
+
+
+static ma_result ma_device_audio_thread__default_read_write(ma_device* pDevice)
+{
+    ma_result result = MA_SUCCESS;
+    ma_bool32 exitLoop = MA_FALSE;
+    ma_uint8  capturedDeviceData[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+    ma_uint8  playbackDeviceData[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+    ma_uint32 capturedDeviceDataCapInFrames = 0;
+    ma_uint32 playbackDeviceDataCapInFrames = 0;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* Just some quick validation on the device type and the available callbacks. */
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+        if (pDevice->pContext->callbacks.onDeviceRead == NULL) {
+            return MA_NOT_IMPLEMENTED;
+        }
+
+        capturedDeviceDataCapInFrames = sizeof(capturedDeviceData) / ma_get_bytes_per_frame(pDevice->capture.internalFormat,  pDevice->capture.internalChannels);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->pContext->callbacks.onDeviceWrite == NULL) {
+            return MA_NOT_IMPLEMENTED;
+        }
+
+        playbackDeviceDataCapInFrames = sizeof(playbackDeviceData) / ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    }
+
+    /* NOTE: The device was started outside of this function, in the worker thread. */
+
+    while (ma_device_get_state(pDevice) == ma_device_state_started && !exitLoop) {
+        switch (pDevice->type) {
+            case ma_device_type_duplex:
+            {
+                /* The process is: onDeviceRead() -> convert -> callback -> convert -> onDeviceWrite() */
+                ma_uint32 totalCapturedDeviceFramesProcessed = 0;
+                ma_uint32 capturedDevicePeriodSizeInFrames = ma_min(pDevice->capture.internalPeriodSizeInFrames, pDevice->playback.internalPeriodSizeInFrames);
+
+                while (totalCapturedDeviceFramesProcessed < capturedDevicePeriodSizeInFrames) {
+                    ma_uint32 capturedDeviceFramesRemaining;
+                    ma_uint32 capturedDeviceFramesProcessed;
+                    ma_uint32 capturedDeviceFramesToProcess;
+                    ma_uint32 capturedDeviceFramesToTryProcessing = capturedDevicePeriodSizeInFrames - totalCapturedDeviceFramesProcessed;
+                    if (capturedDeviceFramesToTryProcessing > capturedDeviceDataCapInFrames) {
+                        capturedDeviceFramesToTryProcessing = capturedDeviceDataCapInFrames;
+                    }
+
+                    result = pDevice->pContext->callbacks.onDeviceRead(pDevice, capturedDeviceData, capturedDeviceFramesToTryProcessing, &capturedDeviceFramesToProcess);
+                    if (result != MA_SUCCESS) {
+                        exitLoop = MA_TRUE;
+                        break;
+                    }
+
+                    capturedDeviceFramesRemaining = capturedDeviceFramesToProcess;
+                    capturedDeviceFramesProcessed = 0;
+
+                    /* At this point we have our captured data in device format and we now need to convert it to client format. */
+                    for (;;) {
+                        ma_uint8  capturedClientData[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                        ma_uint8  playbackClientData[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                        ma_uint32 capturedClientDataCapInFrames = sizeof(capturedClientData) / ma_get_bytes_per_frame(pDevice->capture.format,  pDevice->capture.channels);
+                        ma_uint32 playbackClientDataCapInFrames = sizeof(playbackClientData) / ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+                        ma_uint64 capturedClientFramesToProcessThisIteration = ma_min(capturedClientDataCapInFrames, playbackClientDataCapInFrames);
+                        ma_uint64 capturedDeviceFramesToProcessThisIteration = capturedDeviceFramesRemaining;
+                        ma_uint8* pRunningCapturedDeviceFrames = ma_offset_ptr(capturedDeviceData, capturedDeviceFramesProcessed * ma_get_bytes_per_frame(pDevice->capture.internalFormat,  pDevice->capture.internalChannels));
+
+                        /* Convert capture data from device format to client format. */
+                        result = ma_data_converter_process_pcm_frames(&pDevice->capture.converter, pRunningCapturedDeviceFrames, &capturedDeviceFramesToProcessThisIteration, capturedClientData, &capturedClientFramesToProcessThisIteration);
+                        if (result != MA_SUCCESS) {
+                            break;
+                        }
+
+                        /*
+                        If we weren't able to generate any output frames it must mean we've exhaused all of our input. The only time this would not be the case is if capturedClientData was too small
+                        which should never be the case when it's of the size MA_DATA_CONVERTER_STACK_BUFFER_SIZE.
+                        */
+                        if (capturedClientFramesToProcessThisIteration == 0) {
+                            break;
+                        }
+
+                        ma_device__handle_data_callback(pDevice, playbackClientData, capturedClientData, (ma_uint32)capturedClientFramesToProcessThisIteration);    /* Safe cast .*/
+
+                        capturedDeviceFramesProcessed += (ma_uint32)capturedDeviceFramesToProcessThisIteration; /* Safe cast. */
+                        capturedDeviceFramesRemaining -= (ma_uint32)capturedDeviceFramesToProcessThisIteration; /* Safe cast. */
+
+                        /* At this point the playbackClientData buffer should be holding data that needs to be written to the device. */
+                        for (;;) {
+                            ma_uint64 convertedClientFrameCount = capturedClientFramesToProcessThisIteration;
+                            ma_uint64 convertedDeviceFrameCount = playbackDeviceDataCapInFrames;
+                            result = ma_data_converter_process_pcm_frames(&pDevice->playback.converter, playbackClientData, &convertedClientFrameCount, playbackDeviceData, &convertedDeviceFrameCount);
+                            if (result != MA_SUCCESS) {
+                                break;
+                            }
+
+                            result = pDevice->pContext->callbacks.onDeviceWrite(pDevice, playbackDeviceData, (ma_uint32)convertedDeviceFrameCount, NULL);   /* Safe cast. */
+                            if (result != MA_SUCCESS) {
+                                exitLoop = MA_TRUE;
+                                break;
+                            }
+
+                            capturedClientFramesToProcessThisIteration -= (ma_uint32)convertedClientFrameCount;  /* Safe cast. */
+                            if (capturedClientFramesToProcessThisIteration == 0) {
+                                break;
+                            }
+                        }
+
+                        /* In case an error happened from ma_device_write__null()... */
+                        if (result != MA_SUCCESS) {
+                            exitLoop = MA_TRUE;
+                            break;
+                        }
+                    }
+
+                    /* Make sure we don't get stuck in the inner loop. */
+                    if (capturedDeviceFramesProcessed == 0) {
+                        break;
+                    }
+
+                    totalCapturedDeviceFramesProcessed += capturedDeviceFramesProcessed;
+                }
+            } break;
+
+            case ma_device_type_capture:
+            case ma_device_type_loopback:
+            {
+                ma_uint32 periodSizeInFrames = pDevice->capture.internalPeriodSizeInFrames;
+                ma_uint32 framesReadThisPeriod = 0;
+                while (framesReadThisPeriod < periodSizeInFrames) {
+                    ma_uint32 framesRemainingInPeriod = periodSizeInFrames - framesReadThisPeriod;
+                    ma_uint32 framesProcessed;
+                    ma_uint32 framesToReadThisIteration = framesRemainingInPeriod;
+                    if (framesToReadThisIteration > capturedDeviceDataCapInFrames) {
+                        framesToReadThisIteration = capturedDeviceDataCapInFrames;
+                    }
+
+                    result = pDevice->pContext->callbacks.onDeviceRead(pDevice, capturedDeviceData, framesToReadThisIteration, &framesProcessed);
+                    if (result != MA_SUCCESS) {
+                        exitLoop = MA_TRUE;
+                        break;
+                    }
+
+                    /* Make sure we don't get stuck in the inner loop. */
+                    if (framesProcessed == 0) {
+                        break;
+                    }
+
+                    ma_device__send_frames_to_client(pDevice, framesProcessed, capturedDeviceData);
+
+                    framesReadThisPeriod += framesProcessed;
+                }
+            } break;
+
+            case ma_device_type_playback:
+            {
+                /* We write in chunks of the period size, but use a stack allocated buffer for the intermediary. */
+                ma_uint32 periodSizeInFrames = pDevice->playback.internalPeriodSizeInFrames;
+                ma_uint32 framesWrittenThisPeriod = 0;
+                while (framesWrittenThisPeriod < periodSizeInFrames) {
+                    ma_uint32 framesRemainingInPeriod = periodSizeInFrames - framesWrittenThisPeriod;
+                    ma_uint32 framesProcessed;
+                    ma_uint32 framesToWriteThisIteration = framesRemainingInPeriod;
+                    if (framesToWriteThisIteration > playbackDeviceDataCapInFrames) {
+                        framesToWriteThisIteration = playbackDeviceDataCapInFrames;
+                    }
+
+                    ma_device__read_frames_from_client(pDevice, framesToWriteThisIteration, playbackDeviceData);
+
+                    result = pDevice->pContext->callbacks.onDeviceWrite(pDevice, playbackDeviceData, framesToWriteThisIteration, &framesProcessed);
+                    if (result != MA_SUCCESS) {
+                        exitLoop = MA_TRUE;
+                        break;
+                    }
+
+                    /* Make sure we don't get stuck in the inner loop. */
+                    if (framesProcessed == 0) {
+                        break;
+                    }
+
+                    framesWrittenThisPeriod += framesProcessed;
+                }
+            } break;
+
+            /* Should never get here. */
+            default: break;
+        }
+    }
+
+    return result;
+}
+
+
+
+/*******************************************************************************
+
+Null Backend
+
+*******************************************************************************/
+#ifdef MA_HAS_NULL
+
+#define MA_DEVICE_OP_NONE__NULL    0
+#define MA_DEVICE_OP_START__NULL   1
+#define MA_DEVICE_OP_SUSPEND__NULL 2
+#define MA_DEVICE_OP_KILL__NULL    3
+
+static ma_thread_result MA_THREADCALL ma_device_thread__null(void* pData)
+{
+    ma_device* pDevice = (ma_device*)pData;
+    MA_ASSERT(pDevice != NULL);
+
+    for (;;) {  /* Keep the thread alive until the device is uninitialized. */
+        ma_uint32 operation;
+
+        /* Wait for an operation to be requested. */
+        ma_event_wait(&pDevice->null_device.operationEvent);
+
+        /* At this point an event should have been triggered. */
+        operation = pDevice->null_device.operation;
+
+        /* Starting the device needs to put the thread into a loop. */
+        if (operation == MA_DEVICE_OP_START__NULL) {
+            /* Reset the timer just in case. */
+            ma_timer_init(&pDevice->null_device.timer);
+
+            /* Getting here means a suspend or kill operation has been requested. */
+            pDevice->null_device.operationResult = MA_SUCCESS;
+            ma_event_signal(&pDevice->null_device.operationCompletionEvent);
+            ma_semaphore_release(&pDevice->null_device.operationSemaphore);
+            continue;
+        }
+
+        /* Suspending the device means we need to stop the timer and just continue the loop. */
+        if (operation == MA_DEVICE_OP_SUSPEND__NULL) {
+            /* We need to add the current run time to the prior run time, then reset the timer. */
+            pDevice->null_device.priorRunTime += ma_timer_get_time_in_seconds(&pDevice->null_device.timer);
+            ma_timer_init(&pDevice->null_device.timer);
+
+            /* We're done. */
+            pDevice->null_device.operationResult = MA_SUCCESS;
+            ma_event_signal(&pDevice->null_device.operationCompletionEvent);
+            ma_semaphore_release(&pDevice->null_device.operationSemaphore);
+            continue;
+        }
+
+        /* Killing the device means we need to get out of this loop so that this thread can terminate. */
+        if (operation == MA_DEVICE_OP_KILL__NULL) {
+            pDevice->null_device.operationResult = MA_SUCCESS;
+            ma_event_signal(&pDevice->null_device.operationCompletionEvent);
+            ma_semaphore_release(&pDevice->null_device.operationSemaphore);
+            break;
+        }
+
+        /* Getting a signal on a "none" operation probably means an error. Return invalid operation. */
+        if (operation == MA_DEVICE_OP_NONE__NULL) {
+            MA_ASSERT(MA_FALSE);  /* <-- Trigger this in debug mode to ensure developers are aware they're doing something wrong (or there's a bug in a miniaudio). */
+            pDevice->null_device.operationResult = MA_INVALID_OPERATION;
+            ma_event_signal(&pDevice->null_device.operationCompletionEvent);
+            ma_semaphore_release(&pDevice->null_device.operationSemaphore);
+            continue;   /* Continue the loop. Don't terminate. */
+        }
+    }
+
+    return (ma_thread_result)0;
+}
+
+static ma_result ma_device_do_operation__null(ma_device* pDevice, ma_uint32 operation)
+{
+    ma_result result;
+
+    /*
+    TODO: Need to review this and consider just using mutual exclusion. I think the original motivation
+    for this was to just post the event to a queue and return immediately, but that has since changed
+    and now this function is synchronous. I think this can be simplified to just use a mutex.
+    */
+
+    /*
+    The first thing to do is wait for an operation slot to become available. We only have a single slot for this, but we could extend this later
+    to support queing of operations.
+    */
+    result = ma_semaphore_wait(&pDevice->null_device.operationSemaphore);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to wait for the event. */
+    }
+
+    /*
+    When we get here it means the background thread is not referencing the operation code and it can be changed. After changing this we need to
+    signal an event to the worker thread to let it know that it can start work.
+    */
+    pDevice->null_device.operation = operation;
+
+    /* Once the operation code has been set, the worker thread can start work. */
+    if (ma_event_signal(&pDevice->null_device.operationEvent) != MA_SUCCESS) {
+        return MA_ERROR;
+    }
+
+    /* We want everything to be synchronous so we're going to wait for the worker thread to complete it's operation. */
+    if (ma_event_wait(&pDevice->null_device.operationCompletionEvent) != MA_SUCCESS) {
+        return MA_ERROR;
+    }
+
+    return pDevice->null_device.operationResult;
+}
+
+static ma_uint64 ma_device_get_total_run_time_in_frames__null(ma_device* pDevice)
+{
+    ma_uint32 internalSampleRate;
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        internalSampleRate = pDevice->capture.internalSampleRate;
+    } else {
+        internalSampleRate = pDevice->playback.internalSampleRate;
+    }
+
+    return (ma_uint64)((pDevice->null_device.priorRunTime + ma_timer_get_time_in_seconds(&pDevice->null_device.timer)) * internalSampleRate);
+}
+
+static ma_result ma_context_enumerate_devices__null(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 cbResult = MA_TRUE;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Playback. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), "NULL Playback Device", (size_t)-1);
+        deviceInfo.isDefault = MA_TRUE; /* Only one playback and capture device for the null backend, so might as well mark as default. */
+        cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), "NULL Capture Device", (size_t)-1);
+        deviceInfo.isDefault = MA_TRUE; /* Only one playback and capture device for the null backend, so might as well mark as default. */
+        cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+    }
+
+    (void)cbResult; /* Silence a static analysis warning. */
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__null(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pContext != NULL);
+
+    if (pDeviceID != NULL && pDeviceID->nullbackend != 0) {
+        return MA_NO_DEVICE;   /* Don't know the device. */
+    }
+
+    /* Name / Description */
+    if (deviceType == ma_device_type_playback) {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), "NULL Playback Device", (size_t)-1);
+    } else {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), "NULL Capture Device", (size_t)-1);
+    }
+
+    pDeviceInfo->isDefault = MA_TRUE;   /* Only one playback and capture device for the null backend, so might as well mark as default. */
+
+    /* Support everything on the null backend. */
+    pDeviceInfo->nativeDataFormats[0].format     = ma_format_unknown;
+    pDeviceInfo->nativeDataFormats[0].channels   = 0;
+    pDeviceInfo->nativeDataFormats[0].sampleRate = 0;
+    pDeviceInfo->nativeDataFormats[0].flags      = 0;
+    pDeviceInfo->nativeDataFormatCount = 1;
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_uninit__null(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* Keep it clean and wait for the device thread to finish before returning. */
+    ma_device_do_operation__null(pDevice, MA_DEVICE_OP_KILL__NULL);
+
+    /* Wait for the thread to finish before continuing. */
+    ma_thread_wait(&pDevice->null_device.deviceThread);
+
+    /* At this point the loop in the device thread is as good as terminated so we can uninitialize our events. */
+    ma_semaphore_uninit(&pDevice->null_device.operationSemaphore);
+    ma_event_uninit(&pDevice->null_device.operationCompletionEvent);
+    ma_event_uninit(&pDevice->null_device.operationEvent);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__null(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->null_device);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* The null backend supports everything exactly as we specify it. */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        pDescriptorCapture->format     = (pDescriptorCapture->format     != ma_format_unknown) ? pDescriptorCapture->format     : MA_DEFAULT_FORMAT;
+        pDescriptorCapture->channels   = (pDescriptorCapture->channels   != 0)                 ? pDescriptorCapture->channels   : MA_DEFAULT_CHANNELS;
+        pDescriptorCapture->sampleRate = (pDescriptorCapture->sampleRate != 0)                 ? pDescriptorCapture->sampleRate : MA_DEFAULT_SAMPLE_RATE;
+
+        if (pDescriptorCapture->channelMap[0] == MA_CHANNEL_NONE) {
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pDescriptorCapture->channelMap, ma_countof(pDescriptorCapture->channelMap), pDescriptorCapture->channels);
+        }
+
+        pDescriptorCapture->periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptorCapture, pDescriptorCapture->sampleRate, pConfig->performanceProfile);
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        pDescriptorPlayback->format     = (pDescriptorPlayback->format     != ma_format_unknown) ? pDescriptorPlayback->format     : MA_DEFAULT_FORMAT;
+        pDescriptorPlayback->channels   = (pDescriptorPlayback->channels   != 0)                 ? pDescriptorPlayback->channels   : MA_DEFAULT_CHANNELS;
+        pDescriptorPlayback->sampleRate = (pDescriptorPlayback->sampleRate != 0)                 ? pDescriptorPlayback->sampleRate : MA_DEFAULT_SAMPLE_RATE;
+
+        if (pDescriptorPlayback->channelMap[0] == MA_CHANNEL_NONE) {
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pDescriptorPlayback->channelMap, ma_countof(pDescriptorCapture->channelMap), pDescriptorPlayback->channels);
+        }
+
+        pDescriptorPlayback->periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptorPlayback, pDescriptorPlayback->sampleRate, pConfig->performanceProfile);
+    }
+
+    /*
+    In order to get timing right, we need to create a thread that does nothing but keeps track of the timer. This timer is started when the
+    first period is "written" to it, and then stopped in ma_device_stop__null().
+    */
+    result = ma_event_init(&pDevice->null_device.operationEvent);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_event_init(&pDevice->null_device.operationCompletionEvent);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_semaphore_init(1, &pDevice->null_device.operationSemaphore);    /* <-- It's important that the initial value is set to 1. */
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_thread_create(&pDevice->null_device.deviceThread, pDevice->pContext->threadPriority, 0, ma_device_thread__null, pDevice, &pDevice->pContext->allocationCallbacks);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__null(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    ma_device_do_operation__null(pDevice, MA_DEVICE_OP_START__NULL);
+
+    ma_atomic_bool32_set(&pDevice->null_device.isStarted, MA_TRUE);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__null(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    ma_device_do_operation__null(pDevice, MA_DEVICE_OP_SUSPEND__NULL);
+
+    ma_atomic_bool32_set(&pDevice->null_device.isStarted, MA_FALSE);
+    return MA_SUCCESS;
+}
+
+static ma_bool32 ma_device_is_started__null(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    return ma_atomic_bool32_get(&pDevice->null_device.isStarted);
+}
+
+static ma_result ma_device_write__null(ma_device* pDevice, const void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 totalPCMFramesProcessed;
+    ma_bool32 wasStartedOnEntry;
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    wasStartedOnEntry = ma_device_is_started__null(pDevice);
+
+    /* Keep going until everything has been read. */
+    totalPCMFramesProcessed = 0;
+    while (totalPCMFramesProcessed < frameCount) {
+        ma_uint64 targetFrame;
+
+        /* If there are any frames remaining in the current period, consume those first. */
+        if (pDevice->null_device.currentPeriodFramesRemainingPlayback > 0) {
+            ma_uint32 framesRemaining = (frameCount - totalPCMFramesProcessed);
+            ma_uint32 framesToProcess = pDevice->null_device.currentPeriodFramesRemainingPlayback;
+            if (framesToProcess > framesRemaining) {
+                framesToProcess = framesRemaining;
+            }
+
+            /* We don't actually do anything with pPCMFrames, so just mark it as unused to prevent a warning. */
+            (void)pPCMFrames;
+
+            pDevice->null_device.currentPeriodFramesRemainingPlayback -= framesToProcess;
+            totalPCMFramesProcessed += framesToProcess;
+        }
+
+        /* If we've consumed the current period we'll need to mark it as such an ensure the device is started if it's not already. */
+        if (pDevice->null_device.currentPeriodFramesRemainingPlayback == 0) {
+            pDevice->null_device.currentPeriodFramesRemainingPlayback = 0;
+
+            if (!ma_device_is_started__null(pDevice) && !wasStartedOnEntry) {
+                result = ma_device_start__null(pDevice);
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+            }
+        }
+
+        /* If we've consumed the whole buffer we can return now. */
+        MA_ASSERT(totalPCMFramesProcessed <= frameCount);
+        if (totalPCMFramesProcessed == frameCount) {
+            break;
+        }
+
+        /* Getting here means we've still got more frames to consume, we but need to wait for it to become available. */
+        targetFrame = pDevice->null_device.lastProcessedFramePlayback;
+        for (;;) {
+            ma_uint64 currentFrame;
+
+            /* Stop waiting if the device has been stopped. */
+            if (!ma_device_is_started__null(pDevice)) {
+                break;
+            }
+
+            currentFrame = ma_device_get_total_run_time_in_frames__null(pDevice);
+            if (currentFrame >= targetFrame) {
+                break;
+            }
+
+            /* Getting here means we haven't yet reached the target sample, so continue waiting. */
+            ma_sleep(10);
+        }
+
+        pDevice->null_device.lastProcessedFramePlayback          += pDevice->playback.internalPeriodSizeInFrames;
+        pDevice->null_device.currentPeriodFramesRemainingPlayback = pDevice->playback.internalPeriodSizeInFrames;
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = totalPCMFramesProcessed;
+    }
+
+    return result;
+}
+
+static ma_result ma_device_read__null(ma_device* pDevice, void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 totalPCMFramesProcessed;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    /* Keep going until everything has been read. */
+    totalPCMFramesProcessed = 0;
+    while (totalPCMFramesProcessed < frameCount) {
+        ma_uint64 targetFrame;
+
+        /* If there are any frames remaining in the current period, consume those first. */
+        if (pDevice->null_device.currentPeriodFramesRemainingCapture > 0) {
+            ma_uint32 bpf = ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+            ma_uint32 framesRemaining = (frameCount - totalPCMFramesProcessed);
+            ma_uint32 framesToProcess = pDevice->null_device.currentPeriodFramesRemainingCapture;
+            if (framesToProcess > framesRemaining) {
+                framesToProcess = framesRemaining;
+            }
+
+            /* We need to ensure the output buffer is zeroed. */
+            MA_ZERO_MEMORY(ma_offset_ptr(pPCMFrames, totalPCMFramesProcessed*bpf), framesToProcess*bpf);
+
+            pDevice->null_device.currentPeriodFramesRemainingCapture -= framesToProcess;
+            totalPCMFramesProcessed += framesToProcess;
+        }
+
+        /* If we've consumed the current period we'll need to mark it as such an ensure the device is started if it's not already. */
+        if (pDevice->null_device.currentPeriodFramesRemainingCapture == 0) {
+            pDevice->null_device.currentPeriodFramesRemainingCapture = 0;
+        }
+
+        /* If we've consumed the whole buffer we can return now. */
+        MA_ASSERT(totalPCMFramesProcessed <= frameCount);
+        if (totalPCMFramesProcessed == frameCount) {
+            break;
+        }
+
+        /* Getting here means we've still got more frames to consume, we but need to wait for it to become available. */
+        targetFrame = pDevice->null_device.lastProcessedFrameCapture + pDevice->capture.internalPeriodSizeInFrames;
+        for (;;) {
+            ma_uint64 currentFrame;
+
+            /* Stop waiting if the device has been stopped. */
+            if (!ma_device_is_started__null(pDevice)) {
+                break;
+            }
+
+            currentFrame = ma_device_get_total_run_time_in_frames__null(pDevice);
+            if (currentFrame >= targetFrame) {
+                break;
+            }
+
+            /* Getting here means we haven't yet reached the target sample, so continue waiting. */
+            ma_sleep(10);
+        }
+
+        pDevice->null_device.lastProcessedFrameCapture          += pDevice->capture.internalPeriodSizeInFrames;
+        pDevice->null_device.currentPeriodFramesRemainingCapture = pDevice->capture.internalPeriodSizeInFrames;
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalPCMFramesProcessed;
+    }
+
+    return result;
+}
+
+static ma_result ma_context_uninit__null(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_null);
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__null(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+    (void)pContext;
+
+    pCallbacks->onContextInit             = ma_context_init__null;
+    pCallbacks->onContextUninit           = ma_context_uninit__null;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__null;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__null;
+    pCallbacks->onDeviceInit              = ma_device_init__null;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__null;
+    pCallbacks->onDeviceStart             = ma_device_start__null;
+    pCallbacks->onDeviceStop              = ma_device_stop__null;
+    pCallbacks->onDeviceRead              = ma_device_read__null;
+    pCallbacks->onDeviceWrite             = ma_device_write__null;
+    pCallbacks->onDeviceDataLoop          = NULL;   /* Our backend is asynchronous with a blocking read-write API which means we can get miniaudio to deal with the audio thread. */
+
+    /* The null backend always works. */
+    return MA_SUCCESS;
+}
+#endif
+
+
+
+/*******************************************************************************
+
+WIN32 COMMON
+
+*******************************************************************************/
+#if defined(MA_WIN32)
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    #define ma_CoInitializeEx(pContext, pvReserved, dwCoInit)                          ((pContext->win32.CoInitializeEx) ? ((MA_PFN_CoInitializeEx)pContext->win32.CoInitializeEx)(pvReserved, dwCoInit) : ((MA_PFN_CoInitialize)pContext->win32.CoInitialize)(pvReserved))
+    #define ma_CoUninitialize(pContext)                                                ((MA_PFN_CoUninitialize)pContext->win32.CoUninitialize)()
+    #define ma_CoCreateInstance(pContext, rclsid, pUnkOuter, dwClsContext, riid, ppv)  ((MA_PFN_CoCreateInstance)pContext->win32.CoCreateInstance)(rclsid, pUnkOuter, dwClsContext, riid, ppv)
+    #define ma_CoTaskMemFree(pContext, pv)                                             ((MA_PFN_CoTaskMemFree)pContext->win32.CoTaskMemFree)(pv)
+    #define ma_PropVariantClear(pContext, pvar)                                        ((MA_PFN_PropVariantClear)pContext->win32.PropVariantClear)(pvar)
+#else
+    #define ma_CoInitializeEx(pContext, pvReserved, dwCoInit)                          CoInitializeEx(pvReserved, dwCoInit)
+    #define ma_CoUninitialize(pContext)                                                CoUninitialize()
+    #define ma_CoCreateInstance(pContext, rclsid, pUnkOuter, dwClsContext, riid, ppv)  CoCreateInstance(rclsid, pUnkOuter, dwClsContext, riid, ppv)
+    #define ma_CoTaskMemFree(pContext, pv)                                             CoTaskMemFree(pv)
+    #define ma_PropVariantClear(pContext, pvar)                                        PropVariantClear(pvar)
+#endif
+
+#if !defined(MAXULONG_PTR) && !defined(__WATCOMC__)
+typedef size_t DWORD_PTR;
+#endif
+
+#if !defined(WAVE_FORMAT_1M08)
+#define WAVE_FORMAT_1M08    0x00000001
+#define WAVE_FORMAT_1S08    0x00000002
+#define WAVE_FORMAT_1M16    0x00000004
+#define WAVE_FORMAT_1S16    0x00000008
+#define WAVE_FORMAT_2M08    0x00000010
+#define WAVE_FORMAT_2S08    0x00000020
+#define WAVE_FORMAT_2M16    0x00000040
+#define WAVE_FORMAT_2S16    0x00000080
+#define WAVE_FORMAT_4M08    0x00000100
+#define WAVE_FORMAT_4S08    0x00000200
+#define WAVE_FORMAT_4M16    0x00000400
+#define WAVE_FORMAT_4S16    0x00000800
+#endif
+
+#if !defined(WAVE_FORMAT_44M08)
+#define WAVE_FORMAT_44M08   0x00000100
+#define WAVE_FORMAT_44S08   0x00000200
+#define WAVE_FORMAT_44M16   0x00000400
+#define WAVE_FORMAT_44S16   0x00000800
+#define WAVE_FORMAT_48M08   0x00001000
+#define WAVE_FORMAT_48S08   0x00002000
+#define WAVE_FORMAT_48M16   0x00004000
+#define WAVE_FORMAT_48S16   0x00008000
+#define WAVE_FORMAT_96M08   0x00010000
+#define WAVE_FORMAT_96S08   0x00020000
+#define WAVE_FORMAT_96M16   0x00040000
+#define WAVE_FORMAT_96S16   0x00080000
+#endif
+
+#ifndef SPEAKER_FRONT_LEFT
+#define SPEAKER_FRONT_LEFT            0x1
+#define SPEAKER_FRONT_RIGHT           0x2
+#define SPEAKER_FRONT_CENTER          0x4
+#define SPEAKER_LOW_FREQUENCY         0x8
+#define SPEAKER_BACK_LEFT             0x10
+#define SPEAKER_BACK_RIGHT            0x20
+#define SPEAKER_FRONT_LEFT_OF_CENTER  0x40
+#define SPEAKER_FRONT_RIGHT_OF_CENTER 0x80
+#define SPEAKER_BACK_CENTER           0x100
+#define SPEAKER_SIDE_LEFT             0x200
+#define SPEAKER_SIDE_RIGHT            0x400
+#define SPEAKER_TOP_CENTER            0x800
+#define SPEAKER_TOP_FRONT_LEFT        0x1000
+#define SPEAKER_TOP_FRONT_CENTER      0x2000
+#define SPEAKER_TOP_FRONT_RIGHT       0x4000
+#define SPEAKER_TOP_BACK_LEFT         0x8000
+#define SPEAKER_TOP_BACK_CENTER       0x10000
+#define SPEAKER_TOP_BACK_RIGHT        0x20000
+#endif
+
+/*
+Implement our own version of MA_WAVEFORMATEXTENSIBLE so we can avoid a header. Be careful with this
+because MA_WAVEFORMATEX has an extra two bytes over standard WAVEFORMATEX due to padding. The
+standard version uses tight packing, but for compiler compatibility we're not doing that with ours.
+*/
+typedef struct
+{
+    WORD wFormatTag;
+    WORD nChannels;
+    DWORD nSamplesPerSec;
+    DWORD nAvgBytesPerSec;
+    WORD nBlockAlign;
+    WORD wBitsPerSample;
+    WORD cbSize;
+} MA_WAVEFORMATEX;
+
+typedef struct
+{
+    WORD wFormatTag;
+    WORD nChannels;
+    DWORD nSamplesPerSec;
+    DWORD nAvgBytesPerSec;
+    WORD nBlockAlign;
+    WORD wBitsPerSample;
+    WORD cbSize;
+    union
+    {
+        WORD wValidBitsPerSample;
+        WORD wSamplesPerBlock;
+        WORD wReserved;
+    } Samples;
+    DWORD dwChannelMask;
+    GUID SubFormat;
+} MA_WAVEFORMATEXTENSIBLE;
+
+
+
+#ifndef WAVE_FORMAT_EXTENSIBLE
+#define WAVE_FORMAT_EXTENSIBLE  0xFFFE
+#endif
+
+#ifndef WAVE_FORMAT_PCM
+#define WAVE_FORMAT_PCM         1
+#endif
+
+#ifndef WAVE_FORMAT_IEEE_FLOAT
+#define WAVE_FORMAT_IEEE_FLOAT  0x0003
+#endif
+
+/* Converts an individual Win32-style channel identifier (SPEAKER_FRONT_LEFT, etc.) to miniaudio. */
+static ma_uint8 ma_channel_id_to_ma__win32(DWORD id)
+{
+    switch (id)
+    {
+        case SPEAKER_FRONT_LEFT:            return MA_CHANNEL_FRONT_LEFT;
+        case SPEAKER_FRONT_RIGHT:           return MA_CHANNEL_FRONT_RIGHT;
+        case SPEAKER_FRONT_CENTER:          return MA_CHANNEL_FRONT_CENTER;
+        case SPEAKER_LOW_FREQUENCY:         return MA_CHANNEL_LFE;
+        case SPEAKER_BACK_LEFT:             return MA_CHANNEL_BACK_LEFT;
+        case SPEAKER_BACK_RIGHT:            return MA_CHANNEL_BACK_RIGHT;
+        case SPEAKER_FRONT_LEFT_OF_CENTER:  return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case SPEAKER_FRONT_RIGHT_OF_CENTER: return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case SPEAKER_BACK_CENTER:           return MA_CHANNEL_BACK_CENTER;
+        case SPEAKER_SIDE_LEFT:             return MA_CHANNEL_SIDE_LEFT;
+        case SPEAKER_SIDE_RIGHT:            return MA_CHANNEL_SIDE_RIGHT;
+        case SPEAKER_TOP_CENTER:            return MA_CHANNEL_TOP_CENTER;
+        case SPEAKER_TOP_FRONT_LEFT:        return MA_CHANNEL_TOP_FRONT_LEFT;
+        case SPEAKER_TOP_FRONT_CENTER:      return MA_CHANNEL_TOP_FRONT_CENTER;
+        case SPEAKER_TOP_FRONT_RIGHT:       return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case SPEAKER_TOP_BACK_LEFT:         return MA_CHANNEL_TOP_BACK_LEFT;
+        case SPEAKER_TOP_BACK_CENTER:       return MA_CHANNEL_TOP_BACK_CENTER;
+        case SPEAKER_TOP_BACK_RIGHT:        return MA_CHANNEL_TOP_BACK_RIGHT;
+        default: return 0;
+    }
+}
+
+/* Converts an individual miniaudio channel identifier (MA_CHANNEL_FRONT_LEFT, etc.) to Win32-style. */
+static DWORD ma_channel_id_to_win32(DWORD id)
+{
+    switch (id)
+    {
+        case MA_CHANNEL_MONO:               return SPEAKER_FRONT_CENTER;
+        case MA_CHANNEL_FRONT_LEFT:         return SPEAKER_FRONT_LEFT;
+        case MA_CHANNEL_FRONT_RIGHT:        return SPEAKER_FRONT_RIGHT;
+        case MA_CHANNEL_FRONT_CENTER:       return SPEAKER_FRONT_CENTER;
+        case MA_CHANNEL_LFE:                return SPEAKER_LOW_FREQUENCY;
+        case MA_CHANNEL_BACK_LEFT:          return SPEAKER_BACK_LEFT;
+        case MA_CHANNEL_BACK_RIGHT:         return SPEAKER_BACK_RIGHT;
+        case MA_CHANNEL_FRONT_LEFT_CENTER:  return SPEAKER_FRONT_LEFT_OF_CENTER;
+        case MA_CHANNEL_FRONT_RIGHT_CENTER: return SPEAKER_FRONT_RIGHT_OF_CENTER;
+        case MA_CHANNEL_BACK_CENTER:        return SPEAKER_BACK_CENTER;
+        case MA_CHANNEL_SIDE_LEFT:          return SPEAKER_SIDE_LEFT;
+        case MA_CHANNEL_SIDE_RIGHT:         return SPEAKER_SIDE_RIGHT;
+        case MA_CHANNEL_TOP_CENTER:         return SPEAKER_TOP_CENTER;
+        case MA_CHANNEL_TOP_FRONT_LEFT:     return SPEAKER_TOP_FRONT_LEFT;
+        case MA_CHANNEL_TOP_FRONT_CENTER:   return SPEAKER_TOP_FRONT_CENTER;
+        case MA_CHANNEL_TOP_FRONT_RIGHT:    return SPEAKER_TOP_FRONT_RIGHT;
+        case MA_CHANNEL_TOP_BACK_LEFT:      return SPEAKER_TOP_BACK_LEFT;
+        case MA_CHANNEL_TOP_BACK_CENTER:    return SPEAKER_TOP_BACK_CENTER;
+        case MA_CHANNEL_TOP_BACK_RIGHT:     return SPEAKER_TOP_BACK_RIGHT;
+        default: return 0;
+    }
+}
+
+/* Converts a channel mapping to a Win32-style channel mask. */
+static DWORD ma_channel_map_to_channel_mask__win32(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    DWORD dwChannelMask = 0;
+    ma_uint32 iChannel;
+
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        dwChannelMask |= ma_channel_id_to_win32(pChannelMap[iChannel]);
+    }
+
+    return dwChannelMask;
+}
+
+/* Converts a Win32-style channel mask to a miniaudio channel map. */
+static void ma_channel_mask_to_channel_map__win32(DWORD dwChannelMask, ma_uint32 channels, ma_channel* pChannelMap)
+{
+    /* If the channel mask is set to 0, just assume a default Win32 channel map. */
+    if (dwChannelMask == 0) {
+        ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pChannelMap, channels, channels);
+    } else {
+        if (channels == 1 && (dwChannelMask & SPEAKER_FRONT_CENTER) != 0) {
+            pChannelMap[0] = MA_CHANNEL_MONO;
+        } else {
+            /* Just iterate over each bit. */
+            ma_uint32 iChannel = 0;
+            ma_uint32 iBit;
+
+            for (iBit = 0; iBit < 32 && iChannel < channels; ++iBit) {
+                DWORD bitValue = (dwChannelMask & (1UL << iBit));
+                if (bitValue != 0) {
+                    /* The bit is set. */
+                    pChannelMap[iChannel] = ma_channel_id_to_ma__win32(bitValue);
+                    iChannel += 1;
+                }
+            }
+        }
+    }
+}
+
+#ifdef __cplusplus
+static ma_bool32 ma_is_guid_equal(const void* a, const void* b)
+{
+    return IsEqualGUID(*(const GUID*)a, *(const GUID*)b);
+}
+#else
+#define ma_is_guid_equal(a, b) IsEqualGUID((const GUID*)a, (const GUID*)b)
+#endif
+
+static MA_INLINE ma_bool32 ma_is_guid_null(const void* guid)
+{
+    static GUID nullguid = {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}};
+    return ma_is_guid_equal(guid, &nullguid);
+}
+
+static ma_format ma_format_from_WAVEFORMATEX(const MA_WAVEFORMATEX* pWF)
+{
+    MA_ASSERT(pWF != NULL);
+
+    if (pWF->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
+        const MA_WAVEFORMATEXTENSIBLE* pWFEX = (const MA_WAVEFORMATEXTENSIBLE*)pWF;
+        if (ma_is_guid_equal(&pWFEX->SubFormat, &MA_GUID_KSDATAFORMAT_SUBTYPE_PCM)) {
+            if (pWFEX->Samples.wValidBitsPerSample == 32) {
+                return ma_format_s32;
+            }
+            if (pWFEX->Samples.wValidBitsPerSample == 24) {
+                if (pWFEX->wBitsPerSample == 32) {
+                    return ma_format_s32;
+                }
+                if (pWFEX->wBitsPerSample == 24) {
+                    return ma_format_s24;
+                }
+            }
+            if (pWFEX->Samples.wValidBitsPerSample == 16) {
+                return ma_format_s16;
+            }
+            if (pWFEX->Samples.wValidBitsPerSample == 8) {
+                return ma_format_u8;
+            }
+        }
+        if (ma_is_guid_equal(&pWFEX->SubFormat, &MA_GUID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)) {
+            if (pWFEX->Samples.wValidBitsPerSample == 32) {
+                return ma_format_f32;
+            }
+            /*
+            if (pWFEX->Samples.wValidBitsPerSample == 64) {
+                return ma_format_f64;
+            }
+            */
+        }
+    } else {
+        if (pWF->wFormatTag == WAVE_FORMAT_PCM) {
+            if (pWF->wBitsPerSample == 32) {
+                return ma_format_s32;
+            }
+            if (pWF->wBitsPerSample == 24) {
+                return ma_format_s24;
+            }
+            if (pWF->wBitsPerSample == 16) {
+                return ma_format_s16;
+            }
+            if (pWF->wBitsPerSample == 8) {
+                return ma_format_u8;
+            }
+        }
+        if (pWF->wFormatTag == WAVE_FORMAT_IEEE_FLOAT) {
+            if (pWF->wBitsPerSample == 32) {
+                return ma_format_f32;
+            }
+            if (pWF->wBitsPerSample == 64) {
+                /*return ma_format_f64;*/
+            }
+        }
+    }
+
+    return ma_format_unknown;
+}
+#endif
+
+
+/*******************************************************************************
+
+WASAPI Backend
+
+*******************************************************************************/
+#ifdef MA_HAS_WASAPI
+#if 0
+#if defined(_MSC_VER)
+    #pragma warning(push)
+    #pragma warning(disable:4091)   /* 'typedef ': ignored on left of '' when no variable is declared */
+#endif
+#include <audioclient.h>
+#include <mmdeviceapi.h>
+#if defined(_MSC_VER)
+    #pragma warning(pop)
+#endif
+#endif  /* 0 */
+
+static ma_result ma_device_reroute__wasapi(ma_device* pDevice, ma_device_type deviceType);
+
+/* Some compilers don't define VerifyVersionInfoW. Need to write this ourselves. */
+#define MA_WIN32_WINNT_VISTA    0x0600
+#define MA_VER_MINORVERSION     0x01
+#define MA_VER_MAJORVERSION     0x02
+#define MA_VER_SERVICEPACKMAJOR 0x20
+#define MA_VER_GREATER_EQUAL    0x03
+
+typedef struct  {
+    DWORD dwOSVersionInfoSize;
+    DWORD dwMajorVersion;
+    DWORD dwMinorVersion;
+    DWORD dwBuildNumber;
+    DWORD dwPlatformId;
+    WCHAR szCSDVersion[128];
+    WORD  wServicePackMajor;
+    WORD  wServicePackMinor;
+    WORD  wSuiteMask;
+    BYTE  wProductType;
+    BYTE  wReserved;
+} ma_OSVERSIONINFOEXW;
+
+typedef BOOL      (WINAPI * ma_PFNVerifyVersionInfoW) (ma_OSVERSIONINFOEXW* lpVersionInfo, DWORD dwTypeMask, DWORDLONG dwlConditionMask);
+typedef ULONGLONG (WINAPI * ma_PFNVerSetConditionMask)(ULONGLONG dwlConditionMask, DWORD dwTypeBitMask, BYTE dwConditionMask);
+
+
+#ifndef PROPERTYKEY_DEFINED
+#define PROPERTYKEY_DEFINED
+#ifndef __WATCOMC__
+typedef struct
+{
+    GUID fmtid;
+    DWORD pid;
+} PROPERTYKEY;
+#endif
+#endif
+
+/* Some compilers don't define PropVariantInit(). We just do this ourselves since it's just a memset(). */
+static MA_INLINE void ma_PropVariantInit(MA_PROPVARIANT* pProp)
+{
+    MA_ZERO_OBJECT(pProp);
+}
+
+
+static const PROPERTYKEY MA_PKEY_Device_FriendlyName             = {{0xA45C254E, 0xDF1C, 0x4EFD, {0x80, 0x20, 0x67, 0xD1, 0x46, 0xA8, 0x50, 0xE0}}, 14};
+static const PROPERTYKEY MA_PKEY_AudioEngine_DeviceFormat        = {{0xF19F064D, 0x82C,  0x4E27, {0xBC, 0x73, 0x68, 0x82, 0xA1, 0xBB, 0x8E, 0x4C}},  0};
+
+static const IID MA_IID_IUnknown                                 = {0x00000000, 0x0000, 0x0000, {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}; /* 00000000-0000-0000-C000-000000000046 */
+#if !defined(MA_WIN32_DESKTOP) && !defined(MA_WIN32_GDK)
+static const IID MA_IID_IAgileObject                             = {0x94EA2B94, 0xE9CC, 0x49E0, {0xC0, 0xFF, 0xEE, 0x64, 0xCA, 0x8F, 0x5B, 0x90}}; /* 94EA2B94-E9CC-49E0-C0FF-EE64CA8F5B90 */
+#endif
+
+static const IID MA_IID_IAudioClient                             = {0x1CB9AD4C, 0xDBFA, 0x4C32, {0xB1, 0x78, 0xC2, 0xF5, 0x68, 0xA7, 0x03, 0xB2}}; /* 1CB9AD4C-DBFA-4C32-B178-C2F568A703B2 = __uuidof(IAudioClient) */
+static const IID MA_IID_IAudioClient2                            = {0x726778CD, 0xF60A, 0x4EDA, {0x82, 0xDE, 0xE4, 0x76, 0x10, 0xCD, 0x78, 0xAA}}; /* 726778CD-F60A-4EDA-82DE-E47610CD78AA = __uuidof(IAudioClient2) */
+static const IID MA_IID_IAudioClient3                            = {0x7ED4EE07, 0x8E67, 0x4CD4, {0x8C, 0x1A, 0x2B, 0x7A, 0x59, 0x87, 0xAD, 0x42}}; /* 7ED4EE07-8E67-4CD4-8C1A-2B7A5987AD42 = __uuidof(IAudioClient3) */
+static const IID MA_IID_IAudioRenderClient                       = {0xF294ACFC, 0x3146, 0x4483, {0xA7, 0xBF, 0xAD, 0xDC, 0xA7, 0xC2, 0x60, 0xE2}}; /* F294ACFC-3146-4483-A7BF-ADDCA7C260E2 = __uuidof(IAudioRenderClient) */
+static const IID MA_IID_IAudioCaptureClient                      = {0xC8ADBD64, 0xE71E, 0x48A0, {0xA4, 0xDE, 0x18, 0x5C, 0x39, 0x5C, 0xD3, 0x17}}; /* C8ADBD64-E71E-48A0-A4DE-185C395CD317 = __uuidof(IAudioCaptureClient) */
+static const IID MA_IID_IMMNotificationClient                    = {0x7991EEC9, 0x7E89, 0x4D85, {0x83, 0x90, 0x6C, 0x70, 0x3C, 0xEC, 0x60, 0xC0}}; /* 7991EEC9-7E89-4D85-8390-6C703CEC60C0 = __uuidof(IMMNotificationClient) */
+#if !defined(MA_WIN32_DESKTOP) && !defined(MA_WIN32_GDK)
+static const IID MA_IID_DEVINTERFACE_AUDIO_RENDER                = {0xE6327CAD, 0xDCEC, 0x4949, {0xAE, 0x8A, 0x99, 0x1E, 0x97, 0x6A, 0x79, 0xD2}}; /* E6327CAD-DCEC-4949-AE8A-991E976A79D2 */
+static const IID MA_IID_DEVINTERFACE_AUDIO_CAPTURE               = {0x2EEF81BE, 0x33FA, 0x4800, {0x96, 0x70, 0x1C, 0xD4, 0x74, 0x97, 0x2C, 0x3F}}; /* 2EEF81BE-33FA-4800-9670-1CD474972C3F */
+static const IID MA_IID_IActivateAudioInterfaceCompletionHandler = {0x41D949AB, 0x9862, 0x444A, {0x80, 0xF6, 0xC2, 0x61, 0x33, 0x4D, 0xA5, 0xEB}}; /* 41D949AB-9862-444A-80F6-C261334DA5EB */
+#endif
+
+static const IID MA_CLSID_MMDeviceEnumerator                     = {0xBCDE0395, 0xE52F, 0x467C, {0x8E, 0x3D, 0xC4, 0x57, 0x92, 0x91, 0x69, 0x2E}}; /* BCDE0395-E52F-467C-8E3D-C4579291692E = __uuidof(MMDeviceEnumerator) */
+static const IID MA_IID_IMMDeviceEnumerator                      = {0xA95664D2, 0x9614, 0x4F35, {0xA7, 0x46, 0xDE, 0x8D, 0xB6, 0x36, 0x17, 0xE6}}; /* A95664D2-9614-4F35-A746-DE8DB63617E6 = __uuidof(IMMDeviceEnumerator) */
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+#define MA_MM_DEVICE_STATE_ACTIVE                          1
+#define MA_MM_DEVICE_STATE_DISABLED                        2
+#define MA_MM_DEVICE_STATE_NOTPRESENT                      4
+#define MA_MM_DEVICE_STATE_UNPLUGGED                       8
+
+typedef struct ma_IMMDeviceEnumerator                      ma_IMMDeviceEnumerator;
+typedef struct ma_IMMDeviceCollection                      ma_IMMDeviceCollection;
+typedef struct ma_IMMDevice                                ma_IMMDevice;
+#else
+typedef struct ma_IActivateAudioInterfaceCompletionHandler ma_IActivateAudioInterfaceCompletionHandler;
+typedef struct ma_IActivateAudioInterfaceAsyncOperation    ma_IActivateAudioInterfaceAsyncOperation;
+#endif
+typedef struct ma_IPropertyStore                           ma_IPropertyStore;
+typedef struct ma_IAudioClient                             ma_IAudioClient;
+typedef struct ma_IAudioClient2                            ma_IAudioClient2;
+typedef struct ma_IAudioClient3                            ma_IAudioClient3;
+typedef struct ma_IAudioRenderClient                       ma_IAudioRenderClient;
+typedef struct ma_IAudioCaptureClient                      ma_IAudioCaptureClient;
+
+typedef ma_int64                                           MA_REFERENCE_TIME;
+
+#define MA_AUDCLNT_STREAMFLAGS_CROSSPROCESS                0x00010000
+#define MA_AUDCLNT_STREAMFLAGS_LOOPBACK                    0x00020000
+#define MA_AUDCLNT_STREAMFLAGS_EVENTCALLBACK               0x00040000
+#define MA_AUDCLNT_STREAMFLAGS_NOPERSIST                   0x00080000
+#define MA_AUDCLNT_STREAMFLAGS_RATEADJUST                  0x00100000
+#define MA_AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY         0x08000000
+#define MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM              0x80000000
+#define MA_AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED          0x10000000
+#define MA_AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE               0x20000000
+#define MA_AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED    0x40000000
+
+/* Buffer flags. */
+#define MA_AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY          1
+#define MA_AUDCLNT_BUFFERFLAGS_SILENT                      2
+#define MA_AUDCLNT_BUFFERFLAGS_TIMESTAMP_ERROR             4
+
+typedef enum
+{
+    ma_eRender  = 0,
+    ma_eCapture = 1,
+    ma_eAll     = 2
+} ma_EDataFlow;
+
+typedef enum
+{
+    ma_eConsole        = 0,
+    ma_eMultimedia     = 1,
+    ma_eCommunications = 2
+} ma_ERole;
+
+typedef enum
+{
+    MA_AUDCLNT_SHAREMODE_SHARED,
+    MA_AUDCLNT_SHAREMODE_EXCLUSIVE
+} MA_AUDCLNT_SHAREMODE;
+
+typedef enum
+{
+    MA_AudioCategory_Other = 0  /* <-- miniaudio is only caring about Other. */
+} MA_AUDIO_STREAM_CATEGORY;
+
+typedef struct
+{
+    ma_uint32 cbSize;
+    BOOL bIsOffload;
+    MA_AUDIO_STREAM_CATEGORY eCategory;
+} ma_AudioClientProperties;
+
+/* IUnknown */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IUnknown* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IUnknown* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IUnknown* pThis);
+} ma_IUnknownVtbl;
+struct ma_IUnknown
+{
+    ma_IUnknownVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IUnknown_QueryInterface(ma_IUnknown* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IUnknown_AddRef(ma_IUnknown* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IUnknown_Release(ma_IUnknown* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    /* IMMNotificationClient */
+    typedef struct
+    {
+        /* IUnknown */
+        HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IMMNotificationClient* pThis, const IID* const riid, void** ppObject);
+        ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IMMNotificationClient* pThis);
+        ULONG   (STDMETHODCALLTYPE * Release)       (ma_IMMNotificationClient* pThis);
+
+        /* IMMNotificationClient */
+        HRESULT (STDMETHODCALLTYPE * OnDeviceStateChanged)  (ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID, DWORD dwNewState);
+        HRESULT (STDMETHODCALLTYPE * OnDeviceAdded)         (ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID);
+        HRESULT (STDMETHODCALLTYPE * OnDeviceRemoved)       (ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID);
+        HRESULT (STDMETHODCALLTYPE * OnDefaultDeviceChanged)(ma_IMMNotificationClient* pThis, ma_EDataFlow dataFlow, ma_ERole role, const WCHAR* pDefaultDeviceID);
+        HRESULT (STDMETHODCALLTYPE * OnPropertyValueChanged)(ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID, const PROPERTYKEY key);
+    } ma_IMMNotificationClientVtbl;
+
+    /* IMMDeviceEnumerator */
+    typedef struct
+    {
+        /* IUnknown */
+        HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IMMDeviceEnumerator* pThis, const IID* const riid, void** ppObject);
+        ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IMMDeviceEnumerator* pThis);
+        ULONG   (STDMETHODCALLTYPE * Release)       (ma_IMMDeviceEnumerator* pThis);
+
+        /* IMMDeviceEnumerator */
+        HRESULT (STDMETHODCALLTYPE * EnumAudioEndpoints)                    (ma_IMMDeviceEnumerator* pThis, ma_EDataFlow dataFlow, DWORD dwStateMask, ma_IMMDeviceCollection** ppDevices);
+        HRESULT (STDMETHODCALLTYPE * GetDefaultAudioEndpoint)               (ma_IMMDeviceEnumerator* pThis, ma_EDataFlow dataFlow, ma_ERole role, ma_IMMDevice** ppEndpoint);
+        HRESULT (STDMETHODCALLTYPE * GetDevice)                             (ma_IMMDeviceEnumerator* pThis, const WCHAR* pID, ma_IMMDevice** ppDevice);
+        HRESULT (STDMETHODCALLTYPE * RegisterEndpointNotificationCallback)  (ma_IMMDeviceEnumerator* pThis, ma_IMMNotificationClient* pClient);
+        HRESULT (STDMETHODCALLTYPE * UnregisterEndpointNotificationCallback)(ma_IMMDeviceEnumerator* pThis, ma_IMMNotificationClient* pClient);
+    } ma_IMMDeviceEnumeratorVtbl;
+    struct ma_IMMDeviceEnumerator
+    {
+        ma_IMMDeviceEnumeratorVtbl* lpVtbl;
+    };
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_QueryInterface(ma_IMMDeviceEnumerator* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+    static MA_INLINE ULONG   ma_IMMDeviceEnumerator_AddRef(ma_IMMDeviceEnumerator* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+    static MA_INLINE ULONG   ma_IMMDeviceEnumerator_Release(ma_IMMDeviceEnumerator* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_EnumAudioEndpoints(ma_IMMDeviceEnumerator* pThis, ma_EDataFlow dataFlow, DWORD dwStateMask, ma_IMMDeviceCollection** ppDevices) { return pThis->lpVtbl->EnumAudioEndpoints(pThis, dataFlow, dwStateMask, ppDevices); }
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_GetDefaultAudioEndpoint(ma_IMMDeviceEnumerator* pThis, ma_EDataFlow dataFlow, ma_ERole role, ma_IMMDevice** ppEndpoint) { return pThis->lpVtbl->GetDefaultAudioEndpoint(pThis, dataFlow, role, ppEndpoint); }
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_GetDevice(ma_IMMDeviceEnumerator* pThis, const WCHAR* pID, ma_IMMDevice** ppDevice) { return pThis->lpVtbl->GetDevice(pThis, pID, ppDevice); }
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_RegisterEndpointNotificationCallback(ma_IMMDeviceEnumerator* pThis, ma_IMMNotificationClient* pClient) { return pThis->lpVtbl->RegisterEndpointNotificationCallback(pThis, pClient); }
+    static MA_INLINE HRESULT ma_IMMDeviceEnumerator_UnregisterEndpointNotificationCallback(ma_IMMDeviceEnumerator* pThis, ma_IMMNotificationClient* pClient) { return pThis->lpVtbl->UnregisterEndpointNotificationCallback(pThis, pClient); }
+
+
+    /* IMMDeviceCollection */
+    typedef struct
+    {
+        /* IUnknown */
+        HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IMMDeviceCollection* pThis, const IID* const riid, void** ppObject);
+        ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IMMDeviceCollection* pThis);
+        ULONG   (STDMETHODCALLTYPE * Release)       (ma_IMMDeviceCollection* pThis);
+
+        /* IMMDeviceCollection */
+        HRESULT (STDMETHODCALLTYPE * GetCount)(ma_IMMDeviceCollection* pThis, UINT* pDevices);
+        HRESULT (STDMETHODCALLTYPE * Item)    (ma_IMMDeviceCollection* pThis, UINT nDevice, ma_IMMDevice** ppDevice);
+    } ma_IMMDeviceCollectionVtbl;
+    struct ma_IMMDeviceCollection
+    {
+        ma_IMMDeviceCollectionVtbl* lpVtbl;
+    };
+    static MA_INLINE HRESULT ma_IMMDeviceCollection_QueryInterface(ma_IMMDeviceCollection* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+    static MA_INLINE ULONG   ma_IMMDeviceCollection_AddRef(ma_IMMDeviceCollection* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+    static MA_INLINE ULONG   ma_IMMDeviceCollection_Release(ma_IMMDeviceCollection* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+    static MA_INLINE HRESULT ma_IMMDeviceCollection_GetCount(ma_IMMDeviceCollection* pThis, UINT* pDevices)                               { return pThis->lpVtbl->GetCount(pThis, pDevices); }
+    static MA_INLINE HRESULT ma_IMMDeviceCollection_Item(ma_IMMDeviceCollection* pThis, UINT nDevice, ma_IMMDevice** ppDevice)            { return pThis->lpVtbl->Item(pThis, nDevice, ppDevice); }
+
+
+    /* IMMDevice */
+    typedef struct
+    {
+        /* IUnknown */
+        HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IMMDevice* pThis, const IID* const riid, void** ppObject);
+        ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IMMDevice* pThis);
+        ULONG   (STDMETHODCALLTYPE * Release)       (ma_IMMDevice* pThis);
+
+        /* IMMDevice */
+        HRESULT (STDMETHODCALLTYPE * Activate)         (ma_IMMDevice* pThis, const IID* const iid, DWORD dwClsCtx, MA_PROPVARIANT* pActivationParams, void** ppInterface);
+        HRESULT (STDMETHODCALLTYPE * OpenPropertyStore)(ma_IMMDevice* pThis, DWORD stgmAccess, ma_IPropertyStore** ppProperties);
+        HRESULT (STDMETHODCALLTYPE * GetId)            (ma_IMMDevice* pThis, WCHAR** pID);
+        HRESULT (STDMETHODCALLTYPE * GetState)         (ma_IMMDevice* pThis, DWORD *pState);
+    } ma_IMMDeviceVtbl;
+    struct ma_IMMDevice
+    {
+        ma_IMMDeviceVtbl* lpVtbl;
+    };
+    static MA_INLINE HRESULT ma_IMMDevice_QueryInterface(ma_IMMDevice* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+    static MA_INLINE ULONG   ma_IMMDevice_AddRef(ma_IMMDevice* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+    static MA_INLINE ULONG   ma_IMMDevice_Release(ma_IMMDevice* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+    static MA_INLINE HRESULT ma_IMMDevice_Activate(ma_IMMDevice* pThis, const IID* const iid, DWORD dwClsCtx, MA_PROPVARIANT* pActivationParams, void** ppInterface) { return pThis->lpVtbl->Activate(pThis, iid, dwClsCtx, pActivationParams, ppInterface); }
+    static MA_INLINE HRESULT ma_IMMDevice_OpenPropertyStore(ma_IMMDevice* pThis, DWORD stgmAccess, ma_IPropertyStore** ppProperties) { return pThis->lpVtbl->OpenPropertyStore(pThis, stgmAccess, ppProperties); }
+    static MA_INLINE HRESULT ma_IMMDevice_GetId(ma_IMMDevice* pThis, WCHAR** pID)                                     { return pThis->lpVtbl->GetId(pThis, pID); }
+    static MA_INLINE HRESULT ma_IMMDevice_GetState(ma_IMMDevice* pThis, DWORD *pState)                                { return pThis->lpVtbl->GetState(pThis, pState); }
+#else
+    /* IActivateAudioInterfaceAsyncOperation */
+    typedef struct
+    {
+        /* IUnknown */
+        HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IActivateAudioInterfaceAsyncOperation* pThis, const IID* const riid, void** ppObject);
+        ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IActivateAudioInterfaceAsyncOperation* pThis);
+        ULONG   (STDMETHODCALLTYPE * Release)       (ma_IActivateAudioInterfaceAsyncOperation* pThis);
+
+        /* IActivateAudioInterfaceAsyncOperation */
+        HRESULT (STDMETHODCALLTYPE * GetActivateResult)(ma_IActivateAudioInterfaceAsyncOperation* pThis, HRESULT *pActivateResult, ma_IUnknown** ppActivatedInterface);
+    } ma_IActivateAudioInterfaceAsyncOperationVtbl;
+    struct ma_IActivateAudioInterfaceAsyncOperation
+    {
+        ma_IActivateAudioInterfaceAsyncOperationVtbl* lpVtbl;
+    };
+    static MA_INLINE HRESULT ma_IActivateAudioInterfaceAsyncOperation_QueryInterface(ma_IActivateAudioInterfaceAsyncOperation* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+    static MA_INLINE ULONG   ma_IActivateAudioInterfaceAsyncOperation_AddRef(ma_IActivateAudioInterfaceAsyncOperation* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+    static MA_INLINE ULONG   ma_IActivateAudioInterfaceAsyncOperation_Release(ma_IActivateAudioInterfaceAsyncOperation* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+    static MA_INLINE HRESULT ma_IActivateAudioInterfaceAsyncOperation_GetActivateResult(ma_IActivateAudioInterfaceAsyncOperation* pThis, HRESULT *pActivateResult, ma_IUnknown** ppActivatedInterface) { return pThis->lpVtbl->GetActivateResult(pThis, pActivateResult, ppActivatedInterface); }
+#endif
+
+/* IPropertyStore */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IPropertyStore* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IPropertyStore* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IPropertyStore* pThis);
+
+    /* IPropertyStore */
+    HRESULT (STDMETHODCALLTYPE * GetCount)(ma_IPropertyStore* pThis, DWORD* pPropCount);
+    HRESULT (STDMETHODCALLTYPE * GetAt)   (ma_IPropertyStore* pThis, DWORD propIndex, PROPERTYKEY* pPropKey);
+    HRESULT (STDMETHODCALLTYPE * GetValue)(ma_IPropertyStore* pThis, const PROPERTYKEY* const pKey, MA_PROPVARIANT* pPropVar);
+    HRESULT (STDMETHODCALLTYPE * SetValue)(ma_IPropertyStore* pThis, const PROPERTYKEY* const pKey, const MA_PROPVARIANT* const pPropVar);
+    HRESULT (STDMETHODCALLTYPE * Commit)  (ma_IPropertyStore* pThis);
+} ma_IPropertyStoreVtbl;
+struct ma_IPropertyStore
+{
+    ma_IPropertyStoreVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IPropertyStore_QueryInterface(ma_IPropertyStore* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IPropertyStore_AddRef(ma_IPropertyStore* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IPropertyStore_Release(ma_IPropertyStore* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IPropertyStore_GetCount(ma_IPropertyStore* pThis, DWORD* pPropCount)                            { return pThis->lpVtbl->GetCount(pThis, pPropCount); }
+static MA_INLINE HRESULT ma_IPropertyStore_GetAt(ma_IPropertyStore* pThis, DWORD propIndex, PROPERTYKEY* pPropKey)          { return pThis->lpVtbl->GetAt(pThis, propIndex, pPropKey); }
+static MA_INLINE HRESULT ma_IPropertyStore_GetValue(ma_IPropertyStore* pThis, const PROPERTYKEY* const pKey, MA_PROPVARIANT* pPropVar) { return pThis->lpVtbl->GetValue(pThis, pKey, pPropVar); }
+static MA_INLINE HRESULT ma_IPropertyStore_SetValue(ma_IPropertyStore* pThis, const PROPERTYKEY* const pKey, const MA_PROPVARIANT* const pPropVar) { return pThis->lpVtbl->SetValue(pThis, pKey, pPropVar); }
+static MA_INLINE HRESULT ma_IPropertyStore_Commit(ma_IPropertyStore* pThis)                                                 { return pThis->lpVtbl->Commit(pThis); }
+
+
+/* IAudioClient */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IAudioClient* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IAudioClient* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IAudioClient* pThis);
+
+    /* IAudioClient */
+    HRESULT (STDMETHODCALLTYPE * Initialize)       (ma_IAudioClient* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid);
+    HRESULT (STDMETHODCALLTYPE * GetBufferSize)    (ma_IAudioClient* pThis, ma_uint32* pNumBufferFrames);
+    HRESULT (STDMETHODCALLTYPE * GetStreamLatency) (ma_IAudioClient* pThis, MA_REFERENCE_TIME* pLatency);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentPadding)(ma_IAudioClient* pThis, ma_uint32* pNumPaddingFrames);
+    HRESULT (STDMETHODCALLTYPE * IsFormatSupported)(ma_IAudioClient* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch);
+    HRESULT (STDMETHODCALLTYPE * GetMixFormat)     (ma_IAudioClient* pThis, MA_WAVEFORMATEX** ppDeviceFormat);
+    HRESULT (STDMETHODCALLTYPE * GetDevicePeriod)  (ma_IAudioClient* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod);
+    HRESULT (STDMETHODCALLTYPE * Start)            (ma_IAudioClient* pThis);
+    HRESULT (STDMETHODCALLTYPE * Stop)             (ma_IAudioClient* pThis);
+    HRESULT (STDMETHODCALLTYPE * Reset)            (ma_IAudioClient* pThis);
+    HRESULT (STDMETHODCALLTYPE * SetEventHandle)   (ma_IAudioClient* pThis, HANDLE eventHandle);
+    HRESULT (STDMETHODCALLTYPE * GetService)       (ma_IAudioClient* pThis, const IID* const riid, void** pp);
+} ma_IAudioClientVtbl;
+struct ma_IAudioClient
+{
+    ma_IAudioClientVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IAudioClient_QueryInterface(ma_IAudioClient* pThis, const IID* const riid, void** ppObject)    { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IAudioClient_AddRef(ma_IAudioClient* pThis)                                                    { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IAudioClient_Release(ma_IAudioClient* pThis)                                                   { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient_Initialize(ma_IAudioClient* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid) { return pThis->lpVtbl->Initialize(pThis, shareMode, streamFlags, bufferDuration, periodicity, pFormat, pAudioSessionGuid); }
+static MA_INLINE HRESULT ma_IAudioClient_GetBufferSize(ma_IAudioClient* pThis, ma_uint32* pNumBufferFrames)                { return pThis->lpVtbl->GetBufferSize(pThis, pNumBufferFrames); }
+static MA_INLINE HRESULT ma_IAudioClient_GetStreamLatency(ma_IAudioClient* pThis, MA_REFERENCE_TIME* pLatency)             { return pThis->lpVtbl->GetStreamLatency(pThis, pLatency); }
+static MA_INLINE HRESULT ma_IAudioClient_GetCurrentPadding(ma_IAudioClient* pThis, ma_uint32* pNumPaddingFrames)           { return pThis->lpVtbl->GetCurrentPadding(pThis, pNumPaddingFrames); }
+static MA_INLINE HRESULT ma_IAudioClient_IsFormatSupported(ma_IAudioClient* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch) { return pThis->lpVtbl->IsFormatSupported(pThis, shareMode, pFormat, ppClosestMatch); }
+static MA_INLINE HRESULT ma_IAudioClient_GetMixFormat(ma_IAudioClient* pThis, MA_WAVEFORMATEX** ppDeviceFormat)            { return pThis->lpVtbl->GetMixFormat(pThis, ppDeviceFormat); }
+static MA_INLINE HRESULT ma_IAudioClient_GetDevicePeriod(ma_IAudioClient* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod) { return pThis->lpVtbl->GetDevicePeriod(pThis, pDefaultDevicePeriod, pMinimumDevicePeriod); }
+static MA_INLINE HRESULT ma_IAudioClient_Start(ma_IAudioClient* pThis)                                                     { return pThis->lpVtbl->Start(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient_Stop(ma_IAudioClient* pThis)                                                      { return pThis->lpVtbl->Stop(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient_Reset(ma_IAudioClient* pThis)                                                     { return pThis->lpVtbl->Reset(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient_SetEventHandle(ma_IAudioClient* pThis, HANDLE eventHandle)                        { return pThis->lpVtbl->SetEventHandle(pThis, eventHandle); }
+static MA_INLINE HRESULT ma_IAudioClient_GetService(ma_IAudioClient* pThis, const IID* const riid, void** pp)              { return pThis->lpVtbl->GetService(pThis, riid, pp); }
+
+/* IAudioClient2 */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IAudioClient2* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IAudioClient2* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IAudioClient2* pThis);
+
+    /* IAudioClient */
+    HRESULT (STDMETHODCALLTYPE * Initialize)       (ma_IAudioClient2* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid);
+    HRESULT (STDMETHODCALLTYPE * GetBufferSize)    (ma_IAudioClient2* pThis, ma_uint32* pNumBufferFrames);
+    HRESULT (STDMETHODCALLTYPE * GetStreamLatency) (ma_IAudioClient2* pThis, MA_REFERENCE_TIME* pLatency);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentPadding)(ma_IAudioClient2* pThis, ma_uint32* pNumPaddingFrames);
+    HRESULT (STDMETHODCALLTYPE * IsFormatSupported)(ma_IAudioClient2* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch);
+    HRESULT (STDMETHODCALLTYPE * GetMixFormat)     (ma_IAudioClient2* pThis, MA_WAVEFORMATEX** ppDeviceFormat);
+    HRESULT (STDMETHODCALLTYPE * GetDevicePeriod)  (ma_IAudioClient2* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod);
+    HRESULT (STDMETHODCALLTYPE * Start)            (ma_IAudioClient2* pThis);
+    HRESULT (STDMETHODCALLTYPE * Stop)             (ma_IAudioClient2* pThis);
+    HRESULT (STDMETHODCALLTYPE * Reset)            (ma_IAudioClient2* pThis);
+    HRESULT (STDMETHODCALLTYPE * SetEventHandle)   (ma_IAudioClient2* pThis, HANDLE eventHandle);
+    HRESULT (STDMETHODCALLTYPE * GetService)       (ma_IAudioClient2* pThis, const IID* const riid, void** pp);
+
+    /* IAudioClient2 */
+    HRESULT (STDMETHODCALLTYPE * IsOffloadCapable)   (ma_IAudioClient2* pThis, MA_AUDIO_STREAM_CATEGORY category, BOOL* pOffloadCapable);
+    HRESULT (STDMETHODCALLTYPE * SetClientProperties)(ma_IAudioClient2* pThis, const ma_AudioClientProperties* pProperties);
+    HRESULT (STDMETHODCALLTYPE * GetBufferSizeLimits)(ma_IAudioClient2* pThis, const MA_WAVEFORMATEX* pFormat, BOOL eventDriven, MA_REFERENCE_TIME* pMinBufferDuration, MA_REFERENCE_TIME* pMaxBufferDuration);
+} ma_IAudioClient2Vtbl;
+struct ma_IAudioClient2
+{
+    ma_IAudioClient2Vtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IAudioClient2_QueryInterface(ma_IAudioClient2* pThis, const IID* const riid, void** ppObject)    { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IAudioClient2_AddRef(ma_IAudioClient2* pThis)                                                    { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IAudioClient2_Release(ma_IAudioClient2* pThis)                                                   { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient2_Initialize(ma_IAudioClient2* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid) { return pThis->lpVtbl->Initialize(pThis, shareMode, streamFlags, bufferDuration, periodicity, pFormat, pAudioSessionGuid); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetBufferSize(ma_IAudioClient2* pThis, ma_uint32* pNumBufferFrames)                { return pThis->lpVtbl->GetBufferSize(pThis, pNumBufferFrames); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetStreamLatency(ma_IAudioClient2* pThis, MA_REFERENCE_TIME* pLatency)             { return pThis->lpVtbl->GetStreamLatency(pThis, pLatency); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetCurrentPadding(ma_IAudioClient2* pThis, ma_uint32* pNumPaddingFrames)           { return pThis->lpVtbl->GetCurrentPadding(pThis, pNumPaddingFrames); }
+static MA_INLINE HRESULT ma_IAudioClient2_IsFormatSupported(ma_IAudioClient2* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch) { return pThis->lpVtbl->IsFormatSupported(pThis, shareMode, pFormat, ppClosestMatch); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetMixFormat(ma_IAudioClient2* pThis, MA_WAVEFORMATEX** ppDeviceFormat)            { return pThis->lpVtbl->GetMixFormat(pThis, ppDeviceFormat); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetDevicePeriod(ma_IAudioClient2* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod) { return pThis->lpVtbl->GetDevicePeriod(pThis, pDefaultDevicePeriod, pMinimumDevicePeriod); }
+static MA_INLINE HRESULT ma_IAudioClient2_Start(ma_IAudioClient2* pThis)                                                     { return pThis->lpVtbl->Start(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient2_Stop(ma_IAudioClient2* pThis)                                                      { return pThis->lpVtbl->Stop(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient2_Reset(ma_IAudioClient2* pThis)                                                     { return pThis->lpVtbl->Reset(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient2_SetEventHandle(ma_IAudioClient2* pThis, HANDLE eventHandle)                        { return pThis->lpVtbl->SetEventHandle(pThis, eventHandle); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetService(ma_IAudioClient2* pThis, const IID* const riid, void** pp)              { return pThis->lpVtbl->GetService(pThis, riid, pp); }
+static MA_INLINE HRESULT ma_IAudioClient2_IsOffloadCapable(ma_IAudioClient2* pThis, MA_AUDIO_STREAM_CATEGORY category, BOOL* pOffloadCapable) { return pThis->lpVtbl->IsOffloadCapable(pThis, category, pOffloadCapable); }
+static MA_INLINE HRESULT ma_IAudioClient2_SetClientProperties(ma_IAudioClient2* pThis, const ma_AudioClientProperties* pProperties)           { return pThis->lpVtbl->SetClientProperties(pThis, pProperties); }
+static MA_INLINE HRESULT ma_IAudioClient2_GetBufferSizeLimits(ma_IAudioClient2* pThis, const MA_WAVEFORMATEX* pFormat, BOOL eventDriven, MA_REFERENCE_TIME* pMinBufferDuration, MA_REFERENCE_TIME* pMaxBufferDuration) { return pThis->lpVtbl->GetBufferSizeLimits(pThis, pFormat, eventDriven, pMinBufferDuration, pMaxBufferDuration); }
+
+
+/* IAudioClient3 */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IAudioClient3* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IAudioClient3* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IAudioClient3* pThis);
+
+    /* IAudioClient */
+    HRESULT (STDMETHODCALLTYPE * Initialize)       (ma_IAudioClient3* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid);
+    HRESULT (STDMETHODCALLTYPE * GetBufferSize)    (ma_IAudioClient3* pThis, ma_uint32* pNumBufferFrames);
+    HRESULT (STDMETHODCALLTYPE * GetStreamLatency) (ma_IAudioClient3* pThis, MA_REFERENCE_TIME* pLatency);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentPadding)(ma_IAudioClient3* pThis, ma_uint32* pNumPaddingFrames);
+    HRESULT (STDMETHODCALLTYPE * IsFormatSupported)(ma_IAudioClient3* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch);
+    HRESULT (STDMETHODCALLTYPE * GetMixFormat)     (ma_IAudioClient3* pThis, MA_WAVEFORMATEX** ppDeviceFormat);
+    HRESULT (STDMETHODCALLTYPE * GetDevicePeriod)  (ma_IAudioClient3* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod);
+    HRESULT (STDMETHODCALLTYPE * Start)            (ma_IAudioClient3* pThis);
+    HRESULT (STDMETHODCALLTYPE * Stop)             (ma_IAudioClient3* pThis);
+    HRESULT (STDMETHODCALLTYPE * Reset)            (ma_IAudioClient3* pThis);
+    HRESULT (STDMETHODCALLTYPE * SetEventHandle)   (ma_IAudioClient3* pThis, HANDLE eventHandle);
+    HRESULT (STDMETHODCALLTYPE * GetService)       (ma_IAudioClient3* pThis, const IID* const riid, void** pp);
+
+    /* IAudioClient2 */
+    HRESULT (STDMETHODCALLTYPE * IsOffloadCapable)   (ma_IAudioClient3* pThis, MA_AUDIO_STREAM_CATEGORY category, BOOL* pOffloadCapable);
+    HRESULT (STDMETHODCALLTYPE * SetClientProperties)(ma_IAudioClient3* pThis, const ma_AudioClientProperties* pProperties);
+    HRESULT (STDMETHODCALLTYPE * GetBufferSizeLimits)(ma_IAudioClient3* pThis, const MA_WAVEFORMATEX* pFormat, BOOL eventDriven, MA_REFERENCE_TIME* pMinBufferDuration, MA_REFERENCE_TIME* pMaxBufferDuration);
+
+    /* IAudioClient3 */
+    HRESULT (STDMETHODCALLTYPE * GetSharedModeEnginePeriod)       (ma_IAudioClient3* pThis, const MA_WAVEFORMATEX* pFormat, ma_uint32* pDefaultPeriodInFrames, ma_uint32* pFundamentalPeriodInFrames, ma_uint32* pMinPeriodInFrames, ma_uint32* pMaxPeriodInFrames);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentSharedModeEnginePeriod)(ma_IAudioClient3* pThis, MA_WAVEFORMATEX** ppFormat, ma_uint32* pCurrentPeriodInFrames);
+    HRESULT (STDMETHODCALLTYPE * InitializeSharedAudioStream)     (ma_IAudioClient3* pThis, DWORD streamFlags, ma_uint32 periodInFrames, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid);
+} ma_IAudioClient3Vtbl;
+struct ma_IAudioClient3
+{
+    ma_IAudioClient3Vtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IAudioClient3_QueryInterface(ma_IAudioClient3* pThis, const IID* const riid, void** ppObject)    { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IAudioClient3_AddRef(ma_IAudioClient3* pThis)                                                    { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IAudioClient3_Release(ma_IAudioClient3* pThis)                                                   { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient3_Initialize(ma_IAudioClient3* pThis, MA_AUDCLNT_SHAREMODE shareMode, DWORD streamFlags, MA_REFERENCE_TIME bufferDuration, MA_REFERENCE_TIME periodicity, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGuid) { return pThis->lpVtbl->Initialize(pThis, shareMode, streamFlags, bufferDuration, periodicity, pFormat, pAudioSessionGuid); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetBufferSize(ma_IAudioClient3* pThis, ma_uint32* pNumBufferFrames)                { return pThis->lpVtbl->GetBufferSize(pThis, pNumBufferFrames); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetStreamLatency(ma_IAudioClient3* pThis, MA_REFERENCE_TIME* pLatency)             { return pThis->lpVtbl->GetStreamLatency(pThis, pLatency); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetCurrentPadding(ma_IAudioClient3* pThis, ma_uint32* pNumPaddingFrames)           { return pThis->lpVtbl->GetCurrentPadding(pThis, pNumPaddingFrames); }
+static MA_INLINE HRESULT ma_IAudioClient3_IsFormatSupported(ma_IAudioClient3* pThis, MA_AUDCLNT_SHAREMODE shareMode, const MA_WAVEFORMATEX* pFormat, MA_WAVEFORMATEX** ppClosestMatch) { return pThis->lpVtbl->IsFormatSupported(pThis, shareMode, pFormat, ppClosestMatch); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetMixFormat(ma_IAudioClient3* pThis, MA_WAVEFORMATEX** ppDeviceFormat)               { return pThis->lpVtbl->GetMixFormat(pThis, ppDeviceFormat); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetDevicePeriod(ma_IAudioClient3* pThis, MA_REFERENCE_TIME* pDefaultDevicePeriod, MA_REFERENCE_TIME* pMinimumDevicePeriod) { return pThis->lpVtbl->GetDevicePeriod(pThis, pDefaultDevicePeriod, pMinimumDevicePeriod); }
+static MA_INLINE HRESULT ma_IAudioClient3_Start(ma_IAudioClient3* pThis)                                                     { return pThis->lpVtbl->Start(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient3_Stop(ma_IAudioClient3* pThis)                                                      { return pThis->lpVtbl->Stop(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient3_Reset(ma_IAudioClient3* pThis)                                                     { return pThis->lpVtbl->Reset(pThis); }
+static MA_INLINE HRESULT ma_IAudioClient3_SetEventHandle(ma_IAudioClient3* pThis, HANDLE eventHandle)                        { return pThis->lpVtbl->SetEventHandle(pThis, eventHandle); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetService(ma_IAudioClient3* pThis, const IID* const riid, void** pp)              { return pThis->lpVtbl->GetService(pThis, riid, pp); }
+static MA_INLINE HRESULT ma_IAudioClient3_IsOffloadCapable(ma_IAudioClient3* pThis, MA_AUDIO_STREAM_CATEGORY category, BOOL* pOffloadCapable) { return pThis->lpVtbl->IsOffloadCapable(pThis, category, pOffloadCapable); }
+static MA_INLINE HRESULT ma_IAudioClient3_SetClientProperties(ma_IAudioClient3* pThis, const ma_AudioClientProperties* pProperties)           { return pThis->lpVtbl->SetClientProperties(pThis, pProperties); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetBufferSizeLimits(ma_IAudioClient3* pThis, const MA_WAVEFORMATEX* pFormat, BOOL eventDriven, MA_REFERENCE_TIME* pMinBufferDuration, MA_REFERENCE_TIME* pMaxBufferDuration) { return pThis->lpVtbl->GetBufferSizeLimits(pThis, pFormat, eventDriven, pMinBufferDuration, pMaxBufferDuration); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetSharedModeEnginePeriod(ma_IAudioClient3* pThis, const MA_WAVEFORMATEX* pFormat, ma_uint32* pDefaultPeriodInFrames, ma_uint32* pFundamentalPeriodInFrames, ma_uint32* pMinPeriodInFrames, ma_uint32* pMaxPeriodInFrames) { return pThis->lpVtbl->GetSharedModeEnginePeriod(pThis, pFormat, pDefaultPeriodInFrames, pFundamentalPeriodInFrames, pMinPeriodInFrames, pMaxPeriodInFrames); }
+static MA_INLINE HRESULT ma_IAudioClient3_GetCurrentSharedModeEnginePeriod(ma_IAudioClient3* pThis, MA_WAVEFORMATEX** ppFormat, ma_uint32* pCurrentPeriodInFrames) { return pThis->lpVtbl->GetCurrentSharedModeEnginePeriod(pThis, ppFormat, pCurrentPeriodInFrames); }
+static MA_INLINE HRESULT ma_IAudioClient3_InitializeSharedAudioStream(ma_IAudioClient3* pThis, DWORD streamFlags, ma_uint32 periodInFrames, const MA_WAVEFORMATEX* pFormat, const GUID* pAudioSessionGUID) { return pThis->lpVtbl->InitializeSharedAudioStream(pThis, streamFlags, periodInFrames, pFormat, pAudioSessionGUID); }
+
+
+/* IAudioRenderClient */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IAudioRenderClient* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IAudioRenderClient* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IAudioRenderClient* pThis);
+
+    /* IAudioRenderClient */
+    HRESULT (STDMETHODCALLTYPE * GetBuffer)    (ma_IAudioRenderClient* pThis, ma_uint32 numFramesRequested, BYTE** ppData);
+    HRESULT (STDMETHODCALLTYPE * ReleaseBuffer)(ma_IAudioRenderClient* pThis, ma_uint32 numFramesWritten, DWORD dwFlags);
+} ma_IAudioRenderClientVtbl;
+struct ma_IAudioRenderClient
+{
+    ma_IAudioRenderClientVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IAudioRenderClient_QueryInterface(ma_IAudioRenderClient* pThis, const IID* const riid, void** ppObject)   { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IAudioRenderClient_AddRef(ma_IAudioRenderClient* pThis)                                                   { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IAudioRenderClient_Release(ma_IAudioRenderClient* pThis)                                                  { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IAudioRenderClient_GetBuffer(ma_IAudioRenderClient* pThis, ma_uint32 numFramesRequested, BYTE** ppData)   { return pThis->lpVtbl->GetBuffer(pThis, numFramesRequested, ppData); }
+static MA_INLINE HRESULT ma_IAudioRenderClient_ReleaseBuffer(ma_IAudioRenderClient* pThis, ma_uint32 numFramesWritten, DWORD dwFlags) { return pThis->lpVtbl->ReleaseBuffer(pThis, numFramesWritten, dwFlags); }
+
+
+/* IAudioCaptureClient */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IAudioCaptureClient* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IAudioCaptureClient* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IAudioCaptureClient* pThis);
+
+    /* IAudioRenderClient */
+    HRESULT (STDMETHODCALLTYPE * GetBuffer)        (ma_IAudioCaptureClient* pThis, BYTE** ppData, ma_uint32* pNumFramesToRead, DWORD* pFlags, ma_uint64* pDevicePosition, ma_uint64* pQPCPosition);
+    HRESULT (STDMETHODCALLTYPE * ReleaseBuffer)    (ma_IAudioCaptureClient* pThis, ma_uint32 numFramesRead);
+    HRESULT (STDMETHODCALLTYPE * GetNextPacketSize)(ma_IAudioCaptureClient* pThis, ma_uint32* pNumFramesInNextPacket);
+} ma_IAudioCaptureClientVtbl;
+struct ma_IAudioCaptureClient
+{
+    ma_IAudioCaptureClientVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IAudioCaptureClient_QueryInterface(ma_IAudioCaptureClient* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IAudioCaptureClient_AddRef(ma_IAudioCaptureClient* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IAudioCaptureClient_Release(ma_IAudioCaptureClient* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IAudioCaptureClient_GetBuffer(ma_IAudioCaptureClient* pThis, BYTE** ppData, ma_uint32* pNumFramesToRead, DWORD* pFlags, ma_uint64* pDevicePosition, ma_uint64* pQPCPosition) { return pThis->lpVtbl->GetBuffer(pThis, ppData, pNumFramesToRead, pFlags, pDevicePosition, pQPCPosition); }
+static MA_INLINE HRESULT ma_IAudioCaptureClient_ReleaseBuffer(ma_IAudioCaptureClient* pThis, ma_uint32 numFramesRead)                 { return pThis->lpVtbl->ReleaseBuffer(pThis, numFramesRead); }
+static MA_INLINE HRESULT ma_IAudioCaptureClient_GetNextPacketSize(ma_IAudioCaptureClient* pThis, ma_uint32* pNumFramesInNextPacket)   { return pThis->lpVtbl->GetNextPacketSize(pThis, pNumFramesInNextPacket); }
+
+#if defined(MA_WIN32_UWP)
+/* mmdevapi Functions */
+typedef HRESULT (WINAPI * MA_PFN_ActivateAudioInterfaceAsync)(const wchar_t* deviceInterfacePath, const IID* riid, MA_PROPVARIANT* activationParams, ma_IActivateAudioInterfaceCompletionHandler* completionHandler, ma_IActivateAudioInterfaceAsyncOperation** activationOperation);
+#endif
+
+/* Avrt Functions */
+typedef HANDLE (WINAPI * MA_PFN_AvSetMmThreadCharacteristicsA)(const char* TaskName, DWORD* TaskIndex);
+typedef BOOL   (WINAPI * MA_PFN_AvRevertMmThreadCharacteristics)(HANDLE AvrtHandle);
+
+#if !defined(MA_WIN32_DESKTOP) && !defined(MA_WIN32_GDK)
+typedef struct ma_completion_handler_uwp ma_completion_handler_uwp;
+
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_completion_handler_uwp* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_completion_handler_uwp* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_completion_handler_uwp* pThis);
+
+    /* IActivateAudioInterfaceCompletionHandler */
+    HRESULT (STDMETHODCALLTYPE * ActivateCompleted)(ma_completion_handler_uwp* pThis, ma_IActivateAudioInterfaceAsyncOperation* pActivateOperation);
+} ma_completion_handler_uwp_vtbl;
+struct ma_completion_handler_uwp
+{
+    ma_completion_handler_uwp_vtbl* lpVtbl;
+    MA_ATOMIC(4, ma_uint32) counter;
+    HANDLE hEvent;
+};
+
+static HRESULT STDMETHODCALLTYPE ma_completion_handler_uwp_QueryInterface(ma_completion_handler_uwp* pThis, const IID* const riid, void** ppObject)
+{
+    /*
+    We need to "implement" IAgileObject which is just an indicator that's used internally by WASAPI for some multithreading management. To
+    "implement" this, we just make sure we return pThis when the IAgileObject is requested.
+    */
+    if (!ma_is_guid_equal(riid, &MA_IID_IUnknown) && !ma_is_guid_equal(riid, &MA_IID_IActivateAudioInterfaceCompletionHandler) && !ma_is_guid_equal(riid, &MA_IID_IAgileObject)) {
+        *ppObject = NULL;
+        return E_NOINTERFACE;
+    }
+
+    /* Getting here means the IID is IUnknown or IMMNotificationClient. */
+    *ppObject = (void*)pThis;
+    ((ma_completion_handler_uwp_vtbl*)pThis->lpVtbl)->AddRef(pThis);
+    return S_OK;
+}
+
+static ULONG STDMETHODCALLTYPE ma_completion_handler_uwp_AddRef(ma_completion_handler_uwp* pThis)
+{
+    return (ULONG)ma_atomic_fetch_add_32(&pThis->counter, 1) + 1;
+}
+
+static ULONG STDMETHODCALLTYPE ma_completion_handler_uwp_Release(ma_completion_handler_uwp* pThis)
+{
+    ma_uint32 newRefCount = ma_atomic_fetch_sub_32(&pThis->counter, 1) - 1;
+    if (newRefCount == 0) {
+        return 0;   /* We don't free anything here because we never allocate the object on the heap. */
+    }
+
+    return (ULONG)newRefCount;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_completion_handler_uwp_ActivateCompleted(ma_completion_handler_uwp* pThis, ma_IActivateAudioInterfaceAsyncOperation* pActivateOperation)
+{
+    (void)pActivateOperation;
+    SetEvent(pThis->hEvent);
+    return S_OK;
+}
+
+
+static ma_completion_handler_uwp_vtbl g_maCompletionHandlerVtblInstance = {
+    ma_completion_handler_uwp_QueryInterface,
+    ma_completion_handler_uwp_AddRef,
+    ma_completion_handler_uwp_Release,
+    ma_completion_handler_uwp_ActivateCompleted
+};
+
+static ma_result ma_completion_handler_uwp_init(ma_completion_handler_uwp* pHandler)
+{
+    MA_ASSERT(pHandler != NULL);
+    MA_ZERO_OBJECT(pHandler);
+
+    pHandler->lpVtbl = &g_maCompletionHandlerVtblInstance;
+    pHandler->counter = 1;
+    pHandler->hEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
+    if (pHandler->hEvent == NULL) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_completion_handler_uwp_uninit(ma_completion_handler_uwp* pHandler)
+{
+    if (pHandler->hEvent != NULL) {
+        CloseHandle(pHandler->hEvent);
+    }
+}
+
+static void ma_completion_handler_uwp_wait(ma_completion_handler_uwp* pHandler)
+{
+    WaitForSingleObject((HANDLE)pHandler->hEvent, INFINITE);
+}
+#endif  /* !MA_WIN32_DESKTOP */
+
+/* We need a virtual table for our notification client object that's used for detecting changes to the default device. */
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_QueryInterface(ma_IMMNotificationClient* pThis, const IID* const riid, void** ppObject)
+{
+    /*
+    We care about two interfaces - IUnknown and IMMNotificationClient. If the requested IID is something else
+    we just return E_NOINTERFACE. Otherwise we need to increment the reference counter and return S_OK.
+    */
+    if (!ma_is_guid_equal(riid, &MA_IID_IUnknown) && !ma_is_guid_equal(riid, &MA_IID_IMMNotificationClient)) {
+        *ppObject = NULL;
+        return E_NOINTERFACE;
+    }
+
+    /* Getting here means the IID is IUnknown or IMMNotificationClient. */
+    *ppObject = (void*)pThis;
+    ((ma_IMMNotificationClientVtbl*)pThis->lpVtbl)->AddRef(pThis);
+    return S_OK;
+}
+
+static ULONG STDMETHODCALLTYPE ma_IMMNotificationClient_AddRef(ma_IMMNotificationClient* pThis)
+{
+    return (ULONG)ma_atomic_fetch_add_32(&pThis->counter, 1) + 1;
+}
+
+static ULONG STDMETHODCALLTYPE ma_IMMNotificationClient_Release(ma_IMMNotificationClient* pThis)
+{
+    ma_uint32 newRefCount = ma_atomic_fetch_sub_32(&pThis->counter, 1) - 1;
+    if (newRefCount == 0) {
+        return 0;   /* We don't free anything here because we never allocate the object on the heap. */
+    }
+
+    return (ULONG)newRefCount;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_OnDeviceStateChanged(ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID, DWORD dwNewState)
+{
+    ma_bool32 isThisDevice = MA_FALSE;
+    ma_bool32 isCapture    = MA_FALSE;
+    ma_bool32 isPlayback   = MA_FALSE;
+
+#ifdef MA_DEBUG_OUTPUT
+    /*ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "IMMNotificationClient_OnDeviceStateChanged(pDeviceID=%S, dwNewState=%u)\n", (pDeviceID != NULL) ? pDeviceID : L"(NULL)", (unsigned int)dwNewState);*/
+#endif
+
+    /*
+    There have been reports of a hang when a playback device is disconnected. The idea with this code is to explicitly stop the device if we detect
+    that the device is disabled or has been unplugged.
+    */
+    if (pThis->pDevice->wasapi.allowCaptureAutoStreamRouting && (pThis->pDevice->type == ma_device_type_capture || pThis->pDevice->type == ma_device_type_duplex || pThis->pDevice->type == ma_device_type_loopback)) {
+        isCapture = MA_TRUE;
+        if (ma_strcmp_WCHAR(pThis->pDevice->capture.id.wasapi, pDeviceID) == 0) {
+            isThisDevice = MA_TRUE;
+        }
+    }
+
+    if (pThis->pDevice->wasapi.allowPlaybackAutoStreamRouting && (pThis->pDevice->type == ma_device_type_playback || pThis->pDevice->type == ma_device_type_duplex)) {
+        isPlayback = MA_TRUE;
+        if (ma_strcmp_WCHAR(pThis->pDevice->playback.id.wasapi, pDeviceID) == 0) {
+            isThisDevice = MA_TRUE;
+        }
+    }
+
+
+    /*
+    If the device ID matches our device we need to mark our device as detached and stop it. When a
+    device is added in OnDeviceAdded(), we'll restart it. We only mark it as detached if the device
+    was started at the time of being removed.
+    */
+    if (isThisDevice) {
+        if ((dwNewState & MA_MM_DEVICE_STATE_ACTIVE) == 0) {
+            /*
+            Unplugged or otherwise unavailable. Mark as detached if we were in a playing state. We'll
+            use this to determine whether or not we need to automatically start the device when it's
+            plugged back in again.
+            */
+            if (ma_device_get_state(pThis->pDevice) == ma_device_state_started) {
+                if (isPlayback) {
+                    pThis->pDevice->wasapi.isDetachedPlayback = MA_TRUE;
+                }
+                if (isCapture) {
+                    pThis->pDevice->wasapi.isDetachedCapture = MA_TRUE;
+                }
+
+                ma_device_stop(pThis->pDevice);
+            }
+        }
+
+        if ((dwNewState & MA_MM_DEVICE_STATE_ACTIVE) != 0) {
+            /* The device was activated. If we were detached, we need to start it again. */
+            ma_bool8 tryRestartingDevice = MA_FALSE;
+
+            if (isPlayback) {
+                if (pThis->pDevice->wasapi.isDetachedPlayback) {
+                    pThis->pDevice->wasapi.isDetachedPlayback = MA_FALSE;
+                    ma_device_reroute__wasapi(pThis->pDevice, ma_device_type_playback);
+                    tryRestartingDevice = MA_TRUE;
+                }
+            }
+
+            if (isCapture) {
+                if (pThis->pDevice->wasapi.isDetachedCapture) {
+                    pThis->pDevice->wasapi.isDetachedCapture = MA_FALSE;
+                    ma_device_reroute__wasapi(pThis->pDevice, (pThis->pDevice->type == ma_device_type_loopback) ? ma_device_type_loopback : ma_device_type_capture);
+                    tryRestartingDevice = MA_TRUE;
+                }
+            }
+
+            if (tryRestartingDevice) {
+                if (pThis->pDevice->wasapi.isDetachedPlayback == MA_FALSE && pThis->pDevice->wasapi.isDetachedCapture == MA_FALSE) {
+                    ma_device_start(pThis->pDevice);
+                }
+            }
+        }
+    }
+
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_OnDeviceAdded(ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID)
+{
+#ifdef MA_DEBUG_OUTPUT
+    /*ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "IMMNotificationClient_OnDeviceAdded(pDeviceID=%S)\n", (pDeviceID != NULL) ? pDeviceID : L"(NULL)");*/
+#endif
+
+    /* We don't need to worry about this event for our purposes. */
+    (void)pThis;
+    (void)pDeviceID;
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_OnDeviceRemoved(ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID)
+{
+#ifdef MA_DEBUG_OUTPUT
+    /*ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "IMMNotificationClient_OnDeviceRemoved(pDeviceID=%S)\n", (pDeviceID != NULL) ? pDeviceID : L"(NULL)");*/
+#endif
+
+    /* We don't need to worry about this event for our purposes. */
+    (void)pThis;
+    (void)pDeviceID;
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_OnDefaultDeviceChanged(ma_IMMNotificationClient* pThis, ma_EDataFlow dataFlow, ma_ERole role, const WCHAR* pDefaultDeviceID)
+{
+#ifdef MA_DEBUG_OUTPUT
+    /*ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "IMMNotificationClient_OnDefaultDeviceChanged(dataFlow=%d, role=%d, pDefaultDeviceID=%S)\n", dataFlow, role, (pDefaultDeviceID != NULL) ? pDefaultDeviceID : L"(NULL)");*/
+#endif
+
+    (void)role;
+
+    /* We only care about devices with the same data flow as the current device. */
+    if ((pThis->pDevice->type == ma_device_type_playback && dataFlow != ma_eRender)  ||
+        (pThis->pDevice->type == ma_device_type_capture  && dataFlow != ma_eCapture) ||
+        (pThis->pDevice->type == ma_device_type_loopback && dataFlow != ma_eRender)) {
+        ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Stream rerouting abandoned because dataFlow does match device type.\n");
+        return S_OK;
+    }
+
+    /* We need to consider dataFlow as ma_eCapture if device is ma_device_type_loopback */
+    if (pThis->pDevice->type == ma_device_type_loopback) {
+        dataFlow = ma_eCapture;
+    }
+
+    /* Don't do automatic stream routing if we're not allowed. */
+    if ((dataFlow == ma_eRender  && pThis->pDevice->wasapi.allowPlaybackAutoStreamRouting == MA_FALSE) ||
+        (dataFlow == ma_eCapture && pThis->pDevice->wasapi.allowCaptureAutoStreamRouting  == MA_FALSE)) {
+        ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Stream rerouting abandoned because automatic stream routing has been disabled by the device config.\n");
+        return S_OK;
+    }
+
+    /*
+    Not currently supporting automatic stream routing in exclusive mode. This is not working correctly on my machine due to
+    AUDCLNT_E_DEVICE_IN_USE errors when reinitializing the device. If this is a bug in miniaudio, we can try re-enabling this once
+    it's fixed.
+    */
+    if ((dataFlow == ma_eRender  && pThis->pDevice->playback.shareMode == ma_share_mode_exclusive) ||
+        (dataFlow == ma_eCapture && pThis->pDevice->capture.shareMode  == ma_share_mode_exclusive)) {
+        ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Stream rerouting abandoned because the device shared mode is exclusive.\n");
+        return S_OK;
+    }
+
+
+
+    /*
+    Second attempt at device rerouting. We're going to retrieve the device's state at the time of
+    the route change. We're then going to stop the device, reinitialize the device, and then start
+    it again if the state before stopping was ma_device_state_started.
+    */
+    {
+        ma_uint32 previousState = ma_device_get_state(pThis->pDevice);
+        ma_bool8 restartDevice = MA_FALSE;
+
+        if (previousState == ma_device_state_uninitialized || previousState == ma_device_state_starting) {
+            ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Stream rerouting abandoned because the device is in the process of starting.\n");
+            return S_OK;
+        }
+
+        if (previousState == ma_device_state_started) {
+            ma_device_stop(pThis->pDevice);
+            restartDevice = MA_TRUE;
+        }
+
+        if (pDefaultDeviceID != NULL) { /* <-- The input device ID will be null if there's no other device available. */
+            ma_mutex_lock(&pThis->pDevice->wasapi.rerouteLock);
+            {
+                if (dataFlow == ma_eRender) {
+                    ma_device_reroute__wasapi(pThis->pDevice, ma_device_type_playback);
+
+                    if (pThis->pDevice->wasapi.isDetachedPlayback) {
+                        pThis->pDevice->wasapi.isDetachedPlayback = MA_FALSE;
+
+                        if (pThis->pDevice->type == ma_device_type_duplex && pThis->pDevice->wasapi.isDetachedCapture) {
+                            restartDevice = MA_FALSE;   /* It's a duplex device and the capture side is detached. We cannot be restarting the device just yet. */
+                        }
+                        else {
+                            restartDevice = MA_TRUE;    /* It's not a duplex device, or the capture side is also attached so we can go ahead and restart the device. */
+                        }
+                    }
+                }
+                else {
+                    ma_device_reroute__wasapi(pThis->pDevice, (pThis->pDevice->type == ma_device_type_loopback) ? ma_device_type_loopback : ma_device_type_capture);
+
+                    if (pThis->pDevice->wasapi.isDetachedCapture) {
+                        pThis->pDevice->wasapi.isDetachedCapture = MA_FALSE;
+
+                        if (pThis->pDevice->type == ma_device_type_duplex && pThis->pDevice->wasapi.isDetachedPlayback) {
+                            restartDevice = MA_FALSE;   /* It's a duplex device and the playback side is detached. We cannot be restarting the device just yet. */
+                        }
+                        else {
+                            restartDevice = MA_TRUE;    /* It's not a duplex device, or the playback side is also attached so we can go ahead and restart the device. */
+                        }
+                    }
+                }
+            }
+            ma_mutex_unlock(&pThis->pDevice->wasapi.rerouteLock);
+
+            if (restartDevice) {
+                ma_device_start(pThis->pDevice);
+            }
+        }
+    }
+
+    return S_OK;
+}
+
+static HRESULT STDMETHODCALLTYPE ma_IMMNotificationClient_OnPropertyValueChanged(ma_IMMNotificationClient* pThis, const WCHAR* pDeviceID, const PROPERTYKEY key)
+{
+#ifdef MA_DEBUG_OUTPUT
+    /*ma_log_postf(ma_device_get_log(pThis->pDevice), MA_LOG_LEVEL_DEBUG, "IMMNotificationClient_OnPropertyValueChanged(pDeviceID=%S)\n", (pDeviceID != NULL) ? pDeviceID : L"(NULL)");*/
+#endif
+
+    (void)pThis;
+    (void)pDeviceID;
+    (void)key;
+    return S_OK;
+}
+
+static ma_IMMNotificationClientVtbl g_maNotificationCientVtbl = {
+    ma_IMMNotificationClient_QueryInterface,
+    ma_IMMNotificationClient_AddRef,
+    ma_IMMNotificationClient_Release,
+    ma_IMMNotificationClient_OnDeviceStateChanged,
+    ma_IMMNotificationClient_OnDeviceAdded,
+    ma_IMMNotificationClient_OnDeviceRemoved,
+    ma_IMMNotificationClient_OnDefaultDeviceChanged,
+    ma_IMMNotificationClient_OnPropertyValueChanged
+};
+#endif  /* MA_WIN32_DESKTOP */
+
+static const char* ma_to_usage_string__wasapi(ma_wasapi_usage usage)
+{
+    switch (usage)
+    {
+        case ma_wasapi_usage_default:   return NULL;
+        case ma_wasapi_usage_games:     return "Games";
+        case ma_wasapi_usage_pro_audio: return "Pro Audio";
+        default: break;
+    }
+
+    return NULL;
+}
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+typedef ma_IMMDevice ma_WASAPIDeviceInterface;
+#else
+typedef ma_IUnknown ma_WASAPIDeviceInterface;
+#endif
+
+
+#define MA_CONTEXT_COMMAND_QUIT__WASAPI                 1
+#define MA_CONTEXT_COMMAND_CREATE_IAUDIOCLIENT__WASAPI  2
+#define MA_CONTEXT_COMMAND_RELEASE_IAUDIOCLIENT__WASAPI 3
+
+static ma_context_command__wasapi ma_context_init_command__wasapi(int code)
+{
+    ma_context_command__wasapi cmd;
+
+    MA_ZERO_OBJECT(&cmd);
+    cmd.code = code;
+
+    return cmd;
+}
+
+static ma_result ma_context_post_command__wasapi(ma_context* pContext, const ma_context_command__wasapi* pCmd)
+{
+    /* For now we are doing everything synchronously, but I might relax this later if the need arises. */
+    ma_result result;
+    ma_bool32 isUsingLocalEvent = MA_FALSE;
+    ma_event localEvent;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pCmd     != NULL);
+
+    if (pCmd->pEvent == NULL) {
+        isUsingLocalEvent = MA_TRUE;
+
+        result = ma_event_init(&localEvent);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to create the event for this command. */
+        }
+    }
+
+    /* Here is where we add the command to the list. If there's not enough room we'll spin until there is. */
+    ma_mutex_lock(&pContext->wasapi.commandLock);
+    {
+        ma_uint32 index;
+
+        /* Spin until we've got some space available. */
+        while (pContext->wasapi.commandCount == ma_countof(pContext->wasapi.commands)) {
+            ma_yield();
+        }
+
+        /* Space is now available. Can safely add to the list. */
+        index = (pContext->wasapi.commandIndex + pContext->wasapi.commandCount) % ma_countof(pContext->wasapi.commands);
+        pContext->wasapi.commands[index]        = *pCmd;
+        pContext->wasapi.commands[index].pEvent = &localEvent;
+        pContext->wasapi.commandCount += 1;
+
+        /* Now that the command has been added, release the semaphore so ma_context_next_command__wasapi() can return. */
+        ma_semaphore_release(&pContext->wasapi.commandSem);
+    }
+    ma_mutex_unlock(&pContext->wasapi.commandLock);
+
+    if (isUsingLocalEvent) {
+        ma_event_wait(&localEvent);
+        ma_event_uninit(&localEvent);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_next_command__wasapi(ma_context* pContext, ma_context_command__wasapi* pCmd)
+{
+    ma_result result = MA_SUCCESS;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pCmd     != NULL);
+
+    result = ma_semaphore_wait(&pContext->wasapi.commandSem);
+    if (result == MA_SUCCESS) {
+        ma_mutex_lock(&pContext->wasapi.commandLock);
+        {
+            *pCmd = pContext->wasapi.commands[pContext->wasapi.commandIndex];
+            pContext->wasapi.commandIndex  = (pContext->wasapi.commandIndex + 1) % ma_countof(pContext->wasapi.commands);
+            pContext->wasapi.commandCount -= 1;
+        }
+        ma_mutex_unlock(&pContext->wasapi.commandLock);
+    }
+
+    return result;
+}
+
+static ma_thread_result MA_THREADCALL ma_context_command_thread__wasapi(void* pUserData)
+{
+    ma_result result;
+    ma_context* pContext = (ma_context*)pUserData;
+    MA_ASSERT(pContext != NULL);
+
+    for (;;) {
+        ma_context_command__wasapi cmd;
+        result = ma_context_next_command__wasapi(pContext, &cmd);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        switch (cmd.code)
+        {
+            case MA_CONTEXT_COMMAND_QUIT__WASAPI:
+            {
+                /* Do nothing. Handled after the switch. */
+            } break;
+
+            case MA_CONTEXT_COMMAND_CREATE_IAUDIOCLIENT__WASAPI:
+            {
+                if (cmd.data.createAudioClient.deviceType == ma_device_type_playback) {
+                    *cmd.data.createAudioClient.pResult = ma_result_from_HRESULT(ma_IAudioClient_GetService((ma_IAudioClient*)cmd.data.createAudioClient.pAudioClient, &MA_IID_IAudioRenderClient, cmd.data.createAudioClient.ppAudioClientService));
+                } else {
+                    *cmd.data.createAudioClient.pResult = ma_result_from_HRESULT(ma_IAudioClient_GetService((ma_IAudioClient*)cmd.data.createAudioClient.pAudioClient, &MA_IID_IAudioCaptureClient, cmd.data.createAudioClient.ppAudioClientService));
+                }
+            } break;
+
+            case MA_CONTEXT_COMMAND_RELEASE_IAUDIOCLIENT__WASAPI:
+            {
+                if (cmd.data.releaseAudioClient.deviceType == ma_device_type_playback) {
+                    if (cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientPlayback != NULL) {
+                        ma_IAudioClient_Release((ma_IAudioClient*)cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientPlayback);
+                        cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientPlayback = NULL;
+                    }
+                }
+
+                if (cmd.data.releaseAudioClient.deviceType == ma_device_type_capture) {
+                    if (cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientCapture != NULL) {
+                        ma_IAudioClient_Release((ma_IAudioClient*)cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientCapture);
+                        cmd.data.releaseAudioClient.pDevice->wasapi.pAudioClientCapture = NULL;
+                    }
+                }
+            } break;
+
+            default:
+            {
+                /* Unknown command. Ignore it, but trigger an assert in debug mode so we're aware of it. */
+                MA_ASSERT(MA_FALSE);
+            } break;
+        }
+
+        if (cmd.pEvent != NULL) {
+            ma_event_signal(cmd.pEvent);
+        }
+
+        if (cmd.code == MA_CONTEXT_COMMAND_QUIT__WASAPI) {
+            break;  /* Received a quit message. Get out of here. */
+        }
+    }
+
+    return (ma_thread_result)0;
+}
+
+static ma_result ma_device_create_IAudioClient_service__wasapi(ma_context* pContext, ma_device_type deviceType, ma_IAudioClient* pAudioClient, void** ppAudioClientService)
+{
+    ma_result result;
+    ma_result cmdResult;
+    ma_context_command__wasapi cmd = ma_context_init_command__wasapi(MA_CONTEXT_COMMAND_CREATE_IAUDIOCLIENT__WASAPI);
+    cmd.data.createAudioClient.deviceType           = deviceType;
+    cmd.data.createAudioClient.pAudioClient         = (void*)pAudioClient;
+    cmd.data.createAudioClient.ppAudioClientService = ppAudioClientService;
+    cmd.data.createAudioClient.pResult              = &cmdResult;   /* Declared locally, but won't be dereferenced after this function returns since execution of the command will wait here. */
+
+    result = ma_context_post_command__wasapi(pContext, &cmd);  /* This will not return until the command has actually been run. */
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return *cmd.data.createAudioClient.pResult;
+}
+
+#if 0   /* Not used at the moment, but leaving here for future use. */
+static ma_result ma_device_release_IAudioClient_service__wasapi(ma_device* pDevice, ma_device_type deviceType)
+{
+    ma_result result;
+    ma_context_command__wasapi cmd = ma_context_init_command__wasapi(MA_CONTEXT_COMMAND_RELEASE_IAUDIOCLIENT__WASAPI);
+    cmd.data.releaseAudioClient.pDevice    = pDevice;
+    cmd.data.releaseAudioClient.deviceType = deviceType;
+
+    result = ma_context_post_command__wasapi(pDevice->pContext, &cmd);  /* This will not return until the command has actually been run. */
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+static void ma_add_native_data_format_to_device_info_from_WAVEFORMATEX(const MA_WAVEFORMATEX* pWF, ma_share_mode shareMode, ma_device_info* pInfo)
+{
+    MA_ASSERT(pWF != NULL);
+    MA_ASSERT(pInfo != NULL);
+
+    if (pInfo->nativeDataFormatCount >= ma_countof(pInfo->nativeDataFormats)) {
+        return; /* Too many data formats. Need to ignore this one. Don't think this should ever happen with WASAPI. */
+    }
+
+    pInfo->nativeDataFormats[pInfo->nativeDataFormatCount].format     = ma_format_from_WAVEFORMATEX(pWF);
+    pInfo->nativeDataFormats[pInfo->nativeDataFormatCount].channels   = pWF->nChannels;
+    pInfo->nativeDataFormats[pInfo->nativeDataFormatCount].sampleRate = pWF->nSamplesPerSec;
+    pInfo->nativeDataFormats[pInfo->nativeDataFormatCount].flags      = (shareMode == ma_share_mode_exclusive) ? MA_DATA_FORMAT_FLAG_EXCLUSIVE_MODE : 0;
+    pInfo->nativeDataFormatCount += 1;
+}
+
+static ma_result ma_context_get_device_info_from_IAudioClient__wasapi(ma_context* pContext, /*ma_IMMDevice**/void* pMMDevice, ma_IAudioClient* pAudioClient, ma_device_info* pInfo)
+{
+    HRESULT hr;
+    MA_WAVEFORMATEX* pWF = NULL;
+
+    MA_ASSERT(pAudioClient != NULL);
+    MA_ASSERT(pInfo != NULL);
+
+    /* Shared Mode. We use GetMixFormat() here. */
+    hr = ma_IAudioClient_GetMixFormat((ma_IAudioClient*)pAudioClient, (MA_WAVEFORMATEX**)&pWF);
+    if (SUCCEEDED(hr)) {
+        ma_add_native_data_format_to_device_info_from_WAVEFORMATEX(pWF, ma_share_mode_shared, pInfo);
+    } else {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to retrieve mix format for device info retrieval.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    /*
+    Exlcusive Mode. We repeatedly call IsFormatSupported() here. This is not currently supported on
+    UWP. Failure to retrieve the exclusive mode format is not considered an error, so from here on
+    out, MA_SUCCESS is guaranteed to be returned.
+    */
+    #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    {
+        ma_IPropertyStore *pProperties;
+
+        /*
+        The first thing to do is get the format from PKEY_AudioEngine_DeviceFormat. This should give us a channel count we assume is
+        correct which will simplify our searching.
+        */
+        hr = ma_IMMDevice_OpenPropertyStore((ma_IMMDevice*)pMMDevice, STGM_READ, &pProperties);
+        if (SUCCEEDED(hr)) {
+            MA_PROPVARIANT var;
+            ma_PropVariantInit(&var);
+
+            hr = ma_IPropertyStore_GetValue(pProperties, &MA_PKEY_AudioEngine_DeviceFormat, &var);
+            if (SUCCEEDED(hr)) {
+                pWF = (MA_WAVEFORMATEX*)var.blob.pBlobData;
+
+                /*
+                In my testing, the format returned by PKEY_AudioEngine_DeviceFormat is suitable for exclusive mode so we check this format
+                first. If this fails, fall back to a search.
+                */
+                hr = ma_IAudioClient_IsFormatSupported((ma_IAudioClient*)pAudioClient, MA_AUDCLNT_SHAREMODE_EXCLUSIVE, pWF, NULL);
+                if (SUCCEEDED(hr)) {
+                    /* The format returned by PKEY_AudioEngine_DeviceFormat is supported. */
+                    ma_add_native_data_format_to_device_info_from_WAVEFORMATEX(pWF, ma_share_mode_exclusive, pInfo);
+                } else {
+                    /*
+                    The format returned by PKEY_AudioEngine_DeviceFormat is not supported, so fall back to a search. We assume the channel
+                    count returned by MA_PKEY_AudioEngine_DeviceFormat is valid and correct. For simplicity we're only returning one format.
+                    */
+                    ma_uint32 channels = pWF->nChannels;
+                    ma_channel defaultChannelMap[MA_MAX_CHANNELS];
+                    MA_WAVEFORMATEXTENSIBLE wf;
+                    ma_bool32 found;
+                    ma_uint32 iFormat;
+
+                    /* Make sure we don't overflow the channel map. */
+                    if (channels > MA_MAX_CHANNELS) {
+                        channels = MA_MAX_CHANNELS;
+                    }
+
+                    ma_channel_map_init_standard(ma_standard_channel_map_microsoft, defaultChannelMap, ma_countof(defaultChannelMap), channels);
+
+                    MA_ZERO_OBJECT(&wf);
+                    wf.cbSize     = sizeof(wf);
+                    wf.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
+                    wf.nChannels  = (WORD)channels;
+                    wf.dwChannelMask     = ma_channel_map_to_channel_mask__win32(defaultChannelMap, channels);
+
+                    found = MA_FALSE;
+                    for (iFormat = 0; iFormat < ma_countof(g_maFormatPriorities); ++iFormat) {
+                        ma_format format = g_maFormatPriorities[iFormat];
+                        ma_uint32 iSampleRate;
+
+                        wf.wBitsPerSample       = (WORD)(ma_get_bytes_per_sample(format)*8);
+                        wf.nBlockAlign          = (WORD)(wf.nChannels * wf.wBitsPerSample / 8);
+                        wf.nAvgBytesPerSec      = wf.nBlockAlign * wf.nSamplesPerSec;
+                        wf.Samples.wValidBitsPerSample = /*(format == ma_format_s24_32) ? 24 :*/ wf.wBitsPerSample;
+                        if (format == ma_format_f32) {
+                            wf.SubFormat = MA_GUID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
+                        } else {
+                            wf.SubFormat = MA_GUID_KSDATAFORMAT_SUBTYPE_PCM;
+                        }
+
+                        for (iSampleRate = 0; iSampleRate < ma_countof(g_maStandardSampleRatePriorities); ++iSampleRate) {
+                            wf.nSamplesPerSec = g_maStandardSampleRatePriorities[iSampleRate];
+
+                            hr = ma_IAudioClient_IsFormatSupported((ma_IAudioClient*)pAudioClient, MA_AUDCLNT_SHAREMODE_EXCLUSIVE, (MA_WAVEFORMATEX*)&wf, NULL);
+                            if (SUCCEEDED(hr)) {
+                                ma_add_native_data_format_to_device_info_from_WAVEFORMATEX((MA_WAVEFORMATEX*)&wf, ma_share_mode_exclusive, pInfo);
+                                found = MA_TRUE;
+                                break;
+                            }
+                        }
+
+                        if (found) {
+                            break;
+                        }
+                    }
+
+                    ma_PropVariantClear(pContext, &var);
+
+                    if (!found) {
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "[WASAPI] Failed to find suitable device format for device info retrieval.");
+                    }
+                }
+            } else {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "[WASAPI] Failed to retrieve device format for device info retrieval.");
+            }
+
+            ma_IPropertyStore_Release(pProperties);
+        } else {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "[WASAPI] Failed to open property store for device info retrieval.");
+        }
+    }
+    #else
+    {
+        (void)pMMDevice;    /* Unused. */
+    }
+    #endif
+
+    return MA_SUCCESS;
+}
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+static ma_EDataFlow ma_device_type_to_EDataFlow(ma_device_type deviceType)
+{
+    if (deviceType == ma_device_type_playback) {
+        return ma_eRender;
+    } else if (deviceType == ma_device_type_capture) {
+        return ma_eCapture;
+    } else {
+        MA_ASSERT(MA_FALSE);
+        return ma_eRender; /* Should never hit this. */
+    }
+}
+
+static ma_result ma_context_create_IMMDeviceEnumerator__wasapi(ma_context* pContext, ma_IMMDeviceEnumerator** ppDeviceEnumerator)
+{
+    HRESULT hr;
+    ma_IMMDeviceEnumerator* pDeviceEnumerator;
+
+    MA_ASSERT(pContext           != NULL);
+    MA_ASSERT(ppDeviceEnumerator != NULL);
+
+    *ppDeviceEnumerator = NULL; /* Safety. */
+
+    hr = ma_CoCreateInstance(pContext, &MA_CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, &MA_IID_IMMDeviceEnumerator, (void**)&pDeviceEnumerator);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create device enumerator.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    *ppDeviceEnumerator = pDeviceEnumerator;
+
+    return MA_SUCCESS;
+}
+
+static WCHAR* ma_context_get_default_device_id_from_IMMDeviceEnumerator__wasapi(ma_context* pContext, ma_IMMDeviceEnumerator* pDeviceEnumerator, ma_device_type deviceType)
+{
+    HRESULT hr;
+    ma_IMMDevice* pMMDefaultDevice = NULL;
+    WCHAR* pDefaultDeviceID = NULL;
+    ma_EDataFlow dataFlow;
+    ma_ERole role;
+
+    MA_ASSERT(pContext          != NULL);
+    MA_ASSERT(pDeviceEnumerator != NULL);
+
+    (void)pContext;
+
+    /* Grab the EDataFlow type from the device type. */
+    dataFlow = ma_device_type_to_EDataFlow(deviceType);
+
+    /* The role is always eConsole, but we may make this configurable later. */
+    role = ma_eConsole;
+
+    hr = ma_IMMDeviceEnumerator_GetDefaultAudioEndpoint(pDeviceEnumerator, dataFlow, role, &pMMDefaultDevice);
+    if (FAILED(hr)) {
+        return NULL;
+    }
+
+    hr = ma_IMMDevice_GetId(pMMDefaultDevice, &pDefaultDeviceID);
+
+    ma_IMMDevice_Release(pMMDefaultDevice);
+    pMMDefaultDevice = NULL;
+
+    if (FAILED(hr)) {
+        return NULL;
+    }
+
+    return pDefaultDeviceID;
+}
+
+static WCHAR* ma_context_get_default_device_id__wasapi(ma_context* pContext, ma_device_type deviceType)    /* Free the returned pointer with ma_CoTaskMemFree() */
+{
+    ma_result result;
+    ma_IMMDeviceEnumerator* pDeviceEnumerator;
+    WCHAR* pDefaultDeviceID = NULL;
+
+    MA_ASSERT(pContext != NULL);
+
+    result = ma_context_create_IMMDeviceEnumerator__wasapi(pContext, &pDeviceEnumerator);
+    if (result != MA_SUCCESS) {
+        return NULL;
+    }
+
+    pDefaultDeviceID = ma_context_get_default_device_id_from_IMMDeviceEnumerator__wasapi(pContext, pDeviceEnumerator, deviceType);
+
+    ma_IMMDeviceEnumerator_Release(pDeviceEnumerator);
+    return pDefaultDeviceID;
+}
+
+static ma_result ma_context_get_MMDevice__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_IMMDevice** ppMMDevice)
+{
+    ma_IMMDeviceEnumerator* pDeviceEnumerator;
+    HRESULT hr;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppMMDevice != NULL);
+
+    hr = ma_CoCreateInstance(pContext, &MA_CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, &MA_IID_IMMDeviceEnumerator, (void**)&pDeviceEnumerator);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create IMMDeviceEnumerator.\n");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    if (pDeviceID == NULL) {
+        hr = ma_IMMDeviceEnumerator_GetDefaultAudioEndpoint(pDeviceEnumerator, (deviceType == ma_device_type_capture) ? ma_eCapture : ma_eRender, ma_eConsole, ppMMDevice);
+    } else {
+        hr = ma_IMMDeviceEnumerator_GetDevice(pDeviceEnumerator, pDeviceID->wasapi, ppMMDevice);
+    }
+
+    ma_IMMDeviceEnumerator_Release(pDeviceEnumerator);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to retrieve IMMDevice.\n");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_id_from_MMDevice__wasapi(ma_context* pContext, ma_IMMDevice* pMMDevice, ma_device_id* pDeviceID)
+{
+    WCHAR* pDeviceIDString;
+    HRESULT hr;
+
+    MA_ASSERT(pDeviceID != NULL);
+
+    hr = ma_IMMDevice_GetId(pMMDevice, &pDeviceIDString);
+    if (SUCCEEDED(hr)) {
+        size_t idlen = ma_strlen_WCHAR(pDeviceIDString);
+        if (idlen+1 > ma_countof(pDeviceID->wasapi)) {
+            ma_CoTaskMemFree(pContext, pDeviceIDString);
+            MA_ASSERT(MA_FALSE);  /* NOTE: If this is triggered, please report it. It means the format of the ID must haved change and is too long to fit in our fixed sized buffer. */
+            return MA_ERROR;
+        }
+
+        MA_COPY_MEMORY(pDeviceID->wasapi, pDeviceIDString, idlen * sizeof(wchar_t));
+        pDeviceID->wasapi[idlen] = '\0';
+
+        ma_CoTaskMemFree(pContext, pDeviceIDString);
+
+        return MA_SUCCESS;
+    }
+
+    return MA_ERROR;
+}
+
+static ma_result ma_context_get_device_info_from_MMDevice__wasapi(ma_context* pContext, ma_IMMDevice* pMMDevice, WCHAR* pDefaultDeviceID, ma_bool32 onlySimpleInfo, ma_device_info* pInfo)
+{
+    ma_result result;
+    HRESULT hr;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pMMDevice != NULL);
+    MA_ASSERT(pInfo != NULL);
+
+    /* ID. */
+    result = ma_context_get_device_id_from_MMDevice__wasapi(pContext, pMMDevice, &pInfo->id);
+    if (result == MA_SUCCESS) {
+        if (pDefaultDeviceID != NULL) {
+            if (ma_strcmp_WCHAR(pInfo->id.wasapi, pDefaultDeviceID) == 0) {
+                pInfo->isDefault = MA_TRUE;
+            }
+        }
+    }
+
+    /* Description / Friendly Name */
+    {
+        ma_IPropertyStore *pProperties;
+        hr = ma_IMMDevice_OpenPropertyStore(pMMDevice, STGM_READ, &pProperties);
+        if (SUCCEEDED(hr)) {
+            MA_PROPVARIANT var;
+
+            ma_PropVariantInit(&var);
+            hr = ma_IPropertyStore_GetValue(pProperties, &MA_PKEY_Device_FriendlyName, &var);
+            if (SUCCEEDED(hr)) {
+                WideCharToMultiByte(CP_UTF8, 0, var.pwszVal, -1, pInfo->name, sizeof(pInfo->name), 0, FALSE);
+                ma_PropVariantClear(pContext, &var);
+            }
+
+            ma_IPropertyStore_Release(pProperties);
+        }
+    }
+
+    /* Format */
+    if (!onlySimpleInfo) {
+        ma_IAudioClient* pAudioClient;
+        hr = ma_IMMDevice_Activate(pMMDevice, &MA_IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&pAudioClient);
+        if (SUCCEEDED(hr)) {
+            result = ma_context_get_device_info_from_IAudioClient__wasapi(pContext, pMMDevice, pAudioClient, pInfo);
+
+            ma_IAudioClient_Release(pAudioClient);
+            return result;
+        } else {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to activate audio client for device info retrieval.");
+            return ma_result_from_HRESULT(hr);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_enumerate_devices_by_type__wasapi(ma_context* pContext, ma_IMMDeviceEnumerator* pDeviceEnumerator, ma_device_type deviceType, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_result result = MA_SUCCESS;
+    UINT deviceCount;
+    HRESULT hr;
+    ma_uint32 iDevice;
+    WCHAR* pDefaultDeviceID = NULL;
+    ma_IMMDeviceCollection* pDeviceCollection = NULL;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Grab the default device. We use this to know whether or not flag the returned device info as being the default. */
+    pDefaultDeviceID = ma_context_get_default_device_id_from_IMMDeviceEnumerator__wasapi(pContext, pDeviceEnumerator, deviceType);
+
+    /* We need to enumerate the devices which returns a device collection. */
+    hr = ma_IMMDeviceEnumerator_EnumAudioEndpoints(pDeviceEnumerator, ma_device_type_to_EDataFlow(deviceType), MA_MM_DEVICE_STATE_ACTIVE, &pDeviceCollection);
+    if (SUCCEEDED(hr)) {
+        hr = ma_IMMDeviceCollection_GetCount(pDeviceCollection, &deviceCount);
+        if (FAILED(hr)) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to get device count.\n");
+            result = ma_result_from_HRESULT(hr);
+            goto done;
+        }
+
+        for (iDevice = 0; iDevice < deviceCount; ++iDevice) {
+            ma_device_info deviceInfo;
+            ma_IMMDevice* pMMDevice;
+
+            MA_ZERO_OBJECT(&deviceInfo);
+
+            hr = ma_IMMDeviceCollection_Item(pDeviceCollection, iDevice, &pMMDevice);
+            if (SUCCEEDED(hr)) {
+                result = ma_context_get_device_info_from_MMDevice__wasapi(pContext, pMMDevice, pDefaultDeviceID, MA_TRUE, &deviceInfo);   /* MA_TRUE = onlySimpleInfo. */
+
+                ma_IMMDevice_Release(pMMDevice);
+                if (result == MA_SUCCESS) {
+                    ma_bool32 cbResult = callback(pContext, deviceType, &deviceInfo, pUserData);
+                    if (cbResult == MA_FALSE) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+done:
+    if (pDefaultDeviceID != NULL) {
+        ma_CoTaskMemFree(pContext, pDefaultDeviceID);
+        pDefaultDeviceID = NULL;
+    }
+
+    if (pDeviceCollection != NULL) {
+        ma_IMMDeviceCollection_Release(pDeviceCollection);
+        pDeviceCollection = NULL;
+    }
+
+    return result;
+}
+
+static ma_result ma_context_get_IAudioClient_Desktop__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, MA_PROPVARIANT* pActivationParams, ma_IAudioClient** ppAudioClient, ma_IMMDevice** ppMMDevice)
+{
+    ma_result result;
+    HRESULT hr;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppAudioClient != NULL);
+    MA_ASSERT(ppMMDevice != NULL);
+
+    result = ma_context_get_MMDevice__wasapi(pContext, deviceType, pDeviceID, ppMMDevice);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    hr = ma_IMMDevice_Activate(*ppMMDevice, &MA_IID_IAudioClient, CLSCTX_ALL, pActivationParams, (void**)ppAudioClient);
+    if (FAILED(hr)) {
+        return ma_result_from_HRESULT(hr);
+    }
+
+    return MA_SUCCESS;
+}
+#else
+static ma_result ma_context_get_IAudioClient_UWP__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, MA_PROPVARIANT* pActivationParams, ma_IAudioClient** ppAudioClient, ma_IUnknown** ppActivatedInterface)
+{
+    ma_IActivateAudioInterfaceAsyncOperation *pAsyncOp = NULL;
+    ma_completion_handler_uwp completionHandler;
+    IID iid;
+    WCHAR* iidStr;
+    HRESULT hr;
+    ma_result result;
+    HRESULT activateResult;
+    ma_IUnknown* pActivatedInterface;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppAudioClient != NULL);
+
+    if (pDeviceID != NULL) {
+        iidStr = (WCHAR*)pDeviceID->wasapi;
+    } else {
+        if (deviceType == ma_device_type_capture) {
+            iid = MA_IID_DEVINTERFACE_AUDIO_CAPTURE;
+        } else {
+            iid = MA_IID_DEVINTERFACE_AUDIO_RENDER;
+        }
+
+    #if defined(__cplusplus)
+        hr = StringFromIID(iid, &iidStr);
+    #else
+        hr = StringFromIID(&iid, &iidStr);
+    #endif
+        if (FAILED(hr)) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to convert device IID to string for ActivateAudioInterfaceAsync(). Out of memory.\n");
+            return ma_result_from_HRESULT(hr);
+        }
+    }
+
+    result = ma_completion_handler_uwp_init(&completionHandler);
+    if (result != MA_SUCCESS) {
+        ma_CoTaskMemFree(pContext, iidStr);
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create event for waiting for ActivateAudioInterfaceAsync().\n");
+        return result;
+    }
+
+    hr = ((MA_PFN_ActivateAudioInterfaceAsync)pContext->wasapi.ActivateAudioInterfaceAsync)(iidStr, &MA_IID_IAudioClient, pActivationParams, (ma_IActivateAudioInterfaceCompletionHandler*)&completionHandler, (ma_IActivateAudioInterfaceAsyncOperation**)&pAsyncOp);
+    if (FAILED(hr)) {
+        ma_completion_handler_uwp_uninit(&completionHandler);
+        ma_CoTaskMemFree(pContext, iidStr);
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] ActivateAudioInterfaceAsync() failed.\n");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    if (pDeviceID == NULL) {
+        ma_CoTaskMemFree(pContext, iidStr);
+    }
+
+    /* Wait for the async operation for finish. */
+    ma_completion_handler_uwp_wait(&completionHandler);
+    ma_completion_handler_uwp_uninit(&completionHandler);
+
+    hr = ma_IActivateAudioInterfaceAsyncOperation_GetActivateResult(pAsyncOp, &activateResult, &pActivatedInterface);
+    ma_IActivateAudioInterfaceAsyncOperation_Release(pAsyncOp);
+
+    if (FAILED(hr) || FAILED(activateResult)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to activate device.\n");
+        return FAILED(hr) ? ma_result_from_HRESULT(hr) : ma_result_from_HRESULT(activateResult);
+    }
+
+    /* Here is where we grab the IAudioClient interface. */
+    hr = ma_IUnknown_QueryInterface(pActivatedInterface, &MA_IID_IAudioClient, (void**)ppAudioClient);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to query IAudioClient interface.\n");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    if (ppActivatedInterface) {
+        *ppActivatedInterface = pActivatedInterface;
+    } else {
+        ma_IUnknown_Release(pActivatedInterface);
+    }
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+/* https://docs.microsoft.com/en-us/windows/win32/api/audioclientactivationparams/ne-audioclientactivationparams-audioclient_activation_type */
+typedef enum
+{
+    MA_AUDIOCLIENT_ACTIVATION_TYPE_DEFAULT,
+    MA_AUDIOCLIENT_ACTIVATION_TYPE_PROCESS_LOOPBACK
+} MA_AUDIOCLIENT_ACTIVATION_TYPE;
+
+/* https://docs.microsoft.com/en-us/windows/win32/api/audioclientactivationparams/ne-audioclientactivationparams-process_loopback_mode */
+typedef enum
+{
+    MA_PROCESS_LOOPBACK_MODE_INCLUDE_TARGET_PROCESS_TREE,
+    MA_PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE
+} MA_PROCESS_LOOPBACK_MODE;
+
+/* https://docs.microsoft.com/en-us/windows/win32/api/audioclientactivationparams/ns-audioclientactivationparams-audioclient_process_loopback_params */
+typedef struct
+{
+    DWORD TargetProcessId;
+    MA_PROCESS_LOOPBACK_MODE ProcessLoopbackMode;
+} MA_AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS;
+
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(push)
+    #pragma warning(disable:4201)   /* nonstandard extension used: nameless struct/union */
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wpedantic" /* For ISO C99 doesn't support unnamed structs/unions [-Wpedantic] */
+    #if defined(__clang__)
+        #pragma GCC diagnostic ignored "-Wc11-extensions"   /* anonymous unions are a C11 extension */
+    #endif
+#endif
+/* https://docs.microsoft.com/en-us/windows/win32/api/audioclientactivationparams/ns-audioclientactivationparams-audioclient_activation_params */
+typedef struct
+{
+    MA_AUDIOCLIENT_ACTIVATION_TYPE ActivationType;
+    union
+    {
+        MA_AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS ProcessLoopbackParams;
+    };
+} MA_AUDIOCLIENT_ACTIVATION_PARAMS;
+#if defined(_MSC_VER) && !defined(__clang__)
+    #pragma warning(pop)
+#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))
+    #pragma GCC diagnostic pop
+#endif
+
+#define MA_VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK L"VAD\\Process_Loopback"
+
+static ma_result ma_context_get_IAudioClient__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_uint32 loopbackProcessID, ma_bool32 loopbackProcessExclude, ma_IAudioClient** ppAudioClient, ma_WASAPIDeviceInterface** ppDeviceInterface)
+{
+    ma_result result;
+    ma_bool32 usingProcessLoopback = MA_FALSE;
+    MA_AUDIOCLIENT_ACTIVATION_PARAMS audioclientActivationParams;
+    MA_PROPVARIANT activationParams;
+    MA_PROPVARIANT* pActivationParams = NULL;
+    ma_device_id virtualDeviceID;
+
+    /* Activation parameters specific to loopback mode. Note that process-specific loopback will only work when a default device ID is specified. */
+    if (deviceType == ma_device_type_loopback && loopbackProcessID != 0 && pDeviceID == NULL) {
+        usingProcessLoopback = MA_TRUE;
+    }
+
+    if (usingProcessLoopback) {
+        MA_ZERO_OBJECT(&audioclientActivationParams);
+        audioclientActivationParams.ActivationType                            = MA_AUDIOCLIENT_ACTIVATION_TYPE_PROCESS_LOOPBACK;
+        audioclientActivationParams.ProcessLoopbackParams.ProcessLoopbackMode = (loopbackProcessExclude) ? MA_PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE : MA_PROCESS_LOOPBACK_MODE_INCLUDE_TARGET_PROCESS_TREE;
+        audioclientActivationParams.ProcessLoopbackParams.TargetProcessId     = (DWORD)loopbackProcessID;
+
+        ma_PropVariantInit(&activationParams);
+        activationParams.vt             = MA_VT_BLOB;
+        activationParams.blob.cbSize    = sizeof(audioclientActivationParams);
+        activationParams.blob.pBlobData = (BYTE*)&audioclientActivationParams;
+        pActivationParams = &activationParams;
+
+        /* When requesting a specific device ID we need to use a special device ID. */
+        MA_COPY_MEMORY(virtualDeviceID.wasapi, MA_VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK, (wcslen(MA_VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK) + 1) * sizeof(wchar_t)); /* +1 for the null terminator. */
+        pDeviceID = &virtualDeviceID;
+    } else {
+        pActivationParams = NULL;   /* No activation parameters required. */
+    }
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    result = ma_context_get_IAudioClient_Desktop__wasapi(pContext, deviceType, pDeviceID, pActivationParams, ppAudioClient, ppDeviceInterface);
+#else
+    result = ma_context_get_IAudioClient_UWP__wasapi(pContext, deviceType, pDeviceID, pActivationParams, ppAudioClient, ppDeviceInterface);
+#endif
+
+    /*
+    If loopback mode was requested with a process ID and initialization failed, it could be because it's
+    trying to run on an older version of Windows where it's not supported. We need to let the caller
+    know about this with a log message.
+    */
+    if (result != MA_SUCCESS) {
+        if (usingProcessLoopback) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Loopback mode requested to %s process ID %u, but initialization failed. Support for this feature begins with Windows 10 Build 20348. Confirm your version of Windows or consider not using process-specific loopback.\n", (loopbackProcessExclude) ? "exclude" : "include", loopbackProcessID);
+        }
+    }
+
+    return result;
+}
+
+
+static ma_result ma_context_enumerate_devices__wasapi(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    /* Different enumeration for desktop and UWP. */
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    /* Desktop */
+    HRESULT hr;
+    ma_IMMDeviceEnumerator* pDeviceEnumerator;
+
+    hr = ma_CoCreateInstance(pContext, &MA_CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, &MA_IID_IMMDeviceEnumerator, (void**)&pDeviceEnumerator);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create device enumerator.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    ma_context_enumerate_devices_by_type__wasapi(pContext, pDeviceEnumerator, ma_device_type_playback, callback, pUserData);
+    ma_context_enumerate_devices_by_type__wasapi(pContext, pDeviceEnumerator, ma_device_type_capture,  callback, pUserData);
+
+    ma_IMMDeviceEnumerator_Release(pDeviceEnumerator);
+#else
+    /*
+    UWP
+
+    The MMDevice API is only supported on desktop applications. For now, while I'm still figuring out how to properly enumerate
+    over devices without using MMDevice, I'm restricting devices to defaults.
+
+    Hint: DeviceInformation::FindAllAsync() with DeviceClass.AudioCapture/AudioRender. https://blogs.windows.com/buildingapps/2014/05/15/real-time-audio-in-windows-store-and-windows-phone-apps/
+    */
+    if (callback) {
+        ma_bool32 cbResult = MA_TRUE;
+
+        /* Playback. */
+        if (cbResult) {
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+            deviceInfo.isDefault = MA_TRUE;
+            cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+        }
+
+        /* Capture. */
+        if (cbResult) {
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+            deviceInfo.isDefault = MA_TRUE;
+            cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+        }
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    ma_result result;
+    ma_IMMDevice* pMMDevice = NULL;
+    WCHAR* pDefaultDeviceID = NULL;
+
+    result = ma_context_get_MMDevice__wasapi(pContext, deviceType, pDeviceID, &pMMDevice);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* We need the default device ID so we can set the isDefault flag in the device info. */
+    pDefaultDeviceID = ma_context_get_default_device_id__wasapi(pContext, deviceType);
+
+    result = ma_context_get_device_info_from_MMDevice__wasapi(pContext, pMMDevice, pDefaultDeviceID, MA_FALSE, pDeviceInfo);   /* MA_FALSE = !onlySimpleInfo. */
+
+    if (pDefaultDeviceID != NULL) {
+        ma_CoTaskMemFree(pContext, pDefaultDeviceID);
+        pDefaultDeviceID = NULL;
+    }
+
+    ma_IMMDevice_Release(pMMDevice);
+
+    return result;
+#else
+    ma_IAudioClient* pAudioClient;
+    ma_result result;
+
+    /* UWP currently only uses default devices. */
+    if (deviceType == ma_device_type_playback) {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+    result = ma_context_get_IAudioClient_UWP__wasapi(pContext, deviceType, pDeviceID, NULL, &pAudioClient, NULL);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_context_get_device_info_from_IAudioClient__wasapi(pContext, NULL, pAudioClient, pDeviceInfo);
+
+    pDeviceInfo->isDefault = MA_TRUE;  /* UWP only supports default devices. */
+
+    ma_IAudioClient_Release(pAudioClient);
+    return result;
+#endif
+}
+
+static ma_result ma_device_uninit__wasapi(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    if (pDevice->wasapi.pDeviceEnumerator) {
+        ((ma_IMMDeviceEnumerator*)pDevice->wasapi.pDeviceEnumerator)->lpVtbl->UnregisterEndpointNotificationCallback((ma_IMMDeviceEnumerator*)pDevice->wasapi.pDeviceEnumerator, &pDevice->wasapi.notificationClient);
+        ma_IMMDeviceEnumerator_Release((ma_IMMDeviceEnumerator*)pDevice->wasapi.pDeviceEnumerator);
+    }
+#endif
+
+    if (pDevice->wasapi.pRenderClient) {
+        if (pDevice->wasapi.pMappedBufferPlayback != NULL) {
+            ma_IAudioRenderClient_ReleaseBuffer((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient, pDevice->wasapi.mappedBufferPlaybackCap, 0);
+            pDevice->wasapi.pMappedBufferPlayback   = NULL;
+            pDevice->wasapi.mappedBufferPlaybackCap = 0;
+            pDevice->wasapi.mappedBufferPlaybackLen = 0;
+        }
+
+        ma_IAudioRenderClient_Release((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient);
+    }
+    if (pDevice->wasapi.pCaptureClient) {
+        if (pDevice->wasapi.pMappedBufferCapture != NULL) {
+            ma_IAudioCaptureClient_ReleaseBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, pDevice->wasapi.mappedBufferCaptureCap);
+            pDevice->wasapi.pMappedBufferCapture   = NULL;
+            pDevice->wasapi.mappedBufferCaptureCap = 0;
+            pDevice->wasapi.mappedBufferCaptureLen = 0;
+        }
+
+        ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient);
+    }
+
+    if (pDevice->wasapi.pAudioClientPlayback) {
+        ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback);
+    }
+    if (pDevice->wasapi.pAudioClientCapture) {
+        ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+    }
+
+    if (pDevice->wasapi.hEventPlayback) {
+        CloseHandle((HANDLE)pDevice->wasapi.hEventPlayback);
+    }
+    if (pDevice->wasapi.hEventCapture) {
+        CloseHandle((HANDLE)pDevice->wasapi.hEventCapture);
+    }
+
+    return MA_SUCCESS;
+}
+
+
+typedef struct
+{
+    /* Input. */
+    ma_format formatIn;
+    ma_uint32 channelsIn;
+    ma_uint32 sampleRateIn;
+    ma_channel channelMapIn[MA_MAX_CHANNELS];
+    ma_uint32 periodSizeInFramesIn;
+    ma_uint32 periodSizeInMillisecondsIn;
+    ma_uint32 periodsIn;
+    ma_share_mode shareMode;
+    ma_performance_profile performanceProfile;
+    ma_bool32 noAutoConvertSRC;
+    ma_bool32 noDefaultQualitySRC;
+    ma_bool32 noHardwareOffloading;
+    ma_uint32 loopbackProcessID;
+    ma_bool32 loopbackProcessExclude;
+
+    /* Output. */
+    ma_IAudioClient* pAudioClient;
+    ma_IAudioRenderClient* pRenderClient;
+    ma_IAudioCaptureClient* pCaptureClient;
+    ma_format formatOut;
+    ma_uint32 channelsOut;
+    ma_uint32 sampleRateOut;
+    ma_channel channelMapOut[MA_MAX_CHANNELS];
+    ma_uint32 periodSizeInFramesOut;
+    ma_uint32 periodsOut;
+    ma_bool32 usingAudioClient3;
+    char deviceName[256];
+    ma_device_id id;
+} ma_device_init_internal_data__wasapi;
+
+static ma_result ma_device_init_internal__wasapi(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_init_internal_data__wasapi* pData)
+{
+    HRESULT hr;
+    ma_result result = MA_SUCCESS;
+    const char* errorMsg = "";
+    MA_AUDCLNT_SHAREMODE shareMode = MA_AUDCLNT_SHAREMODE_SHARED;
+    DWORD streamFlags = 0;
+    MA_REFERENCE_TIME periodDurationInMicroseconds;
+    ma_bool32 wasInitializedUsingIAudioClient3 = MA_FALSE;
+    MA_WAVEFORMATEXTENSIBLE wf;
+    ma_WASAPIDeviceInterface* pDeviceInterface = NULL;
+    ma_IAudioClient2* pAudioClient2;
+    ma_uint32 nativeSampleRate;
+    ma_bool32 usingProcessLoopback = MA_FALSE;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pData != NULL);
+
+    /* This function is only used to initialize one device type: either playback, capture or loopback. Never full-duplex. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    usingProcessLoopback = deviceType == ma_device_type_loopback && pData->loopbackProcessID != 0 && pDeviceID == NULL;
+
+    pData->pAudioClient = NULL;
+    pData->pRenderClient = NULL;
+    pData->pCaptureClient = NULL;
+
+    streamFlags = MA_AUDCLNT_STREAMFLAGS_EVENTCALLBACK;
+    if (!pData->noAutoConvertSRC && pData->sampleRateIn != 0 && pData->shareMode != ma_share_mode_exclusive) {    /* <-- Exclusive streams must use the native sample rate. */
+        streamFlags |= MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM;
+    }
+    if (!pData->noDefaultQualitySRC && pData->sampleRateIn != 0 && (streamFlags & MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM) != 0) {
+        streamFlags |= MA_AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY;
+    }
+    if (deviceType == ma_device_type_loopback) {
+        streamFlags |= MA_AUDCLNT_STREAMFLAGS_LOOPBACK;
+    }
+
+    result = ma_context_get_IAudioClient__wasapi(pContext, deviceType, pDeviceID, pData->loopbackProcessID, pData->loopbackProcessExclude, &pData->pAudioClient, &pDeviceInterface);
+    if (result != MA_SUCCESS) {
+        goto done;
+    }
+
+    MA_ZERO_OBJECT(&wf);
+
+    /* Try enabling hardware offloading. */
+    if (!pData->noHardwareOffloading) {
+        hr = ma_IAudioClient_QueryInterface(pData->pAudioClient, &MA_IID_IAudioClient2, (void**)&pAudioClient2);
+        if (SUCCEEDED(hr)) {
+            BOOL isHardwareOffloadingSupported = 0;
+            hr = ma_IAudioClient2_IsOffloadCapable(pAudioClient2, MA_AudioCategory_Other, &isHardwareOffloadingSupported);
+            if (SUCCEEDED(hr) && isHardwareOffloadingSupported) {
+                ma_AudioClientProperties clientProperties;
+                MA_ZERO_OBJECT(&clientProperties);
+                clientProperties.cbSize = sizeof(clientProperties);
+                clientProperties.bIsOffload = 1;
+                clientProperties.eCategory = MA_AudioCategory_Other;
+                ma_IAudioClient2_SetClientProperties(pAudioClient2, &clientProperties);
+            }
+
+            pAudioClient2->lpVtbl->Release(pAudioClient2);
+        }
+    }
+
+    /* Here is where we try to determine the best format to use with the device. If the client if wanting exclusive mode, first try finding the best format for that. If this fails, fall back to shared mode. */
+    result = MA_FORMAT_NOT_SUPPORTED;
+    if (pData->shareMode == ma_share_mode_exclusive) {
+    #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+        /* In exclusive mode on desktop we always use the backend's native format. */
+        ma_IPropertyStore* pStore = NULL;
+        hr = ma_IMMDevice_OpenPropertyStore(pDeviceInterface, STGM_READ, &pStore);
+        if (SUCCEEDED(hr)) {
+            MA_PROPVARIANT prop;
+            ma_PropVariantInit(&prop);
+            hr = ma_IPropertyStore_GetValue(pStore, &MA_PKEY_AudioEngine_DeviceFormat, &prop);
+            if (SUCCEEDED(hr)) {
+                MA_WAVEFORMATEX* pActualFormat = (MA_WAVEFORMATEX*)prop.blob.pBlobData;
+                hr = ma_IAudioClient_IsFormatSupported((ma_IAudioClient*)pData->pAudioClient, MA_AUDCLNT_SHAREMODE_EXCLUSIVE, pActualFormat, NULL);
+                if (SUCCEEDED(hr)) {
+                    MA_COPY_MEMORY(&wf, pActualFormat, sizeof(MA_WAVEFORMATEXTENSIBLE));
+                }
+
+                ma_PropVariantClear(pContext, &prop);
+            }
+
+            ma_IPropertyStore_Release(pStore);
+        }
+    #else
+        /*
+        I do not know how to query the device's native format on UWP so for now I'm just disabling support for
+        exclusive mode. The alternative is to enumerate over different formats and check IsFormatSupported()
+        until you find one that works.
+
+        TODO: Add support for exclusive mode to UWP.
+        */
+        hr = S_FALSE;
+    #endif
+
+        if (hr == S_OK) {
+            shareMode = MA_AUDCLNT_SHAREMODE_EXCLUSIVE;
+            result = MA_SUCCESS;
+        } else {
+            result = MA_SHARE_MODE_NOT_SUPPORTED;
+        }
+    } else {
+        /* In shared mode we are always using the format reported by the operating system. */
+        MA_WAVEFORMATEXTENSIBLE* pNativeFormat = NULL;
+        hr = ma_IAudioClient_GetMixFormat((ma_IAudioClient*)pData->pAudioClient, (MA_WAVEFORMATEX**)&pNativeFormat);
+        if (hr != S_OK) {
+            /* When using process-specific loopback, GetMixFormat() seems to always fail. */
+            if (usingProcessLoopback) {
+                wf.wFormatTag      = WAVE_FORMAT_IEEE_FLOAT;
+                wf.nChannels       = 2;
+                wf.nSamplesPerSec  = 44100;
+                wf.wBitsPerSample  = 32;
+                wf.nBlockAlign     = wf.nChannels * wf.wBitsPerSample / 8;
+                wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;
+                wf.cbSize          = sizeof(MA_WAVEFORMATEX);
+
+                result = MA_SUCCESS;
+            } else {
+                result = MA_FORMAT_NOT_SUPPORTED;
+            }
+        } else {
+            /*
+            I've seen cases where cbSize will be set to sizeof(WAVEFORMATEX) even though the structure itself
+            is given the format tag of WAVE_FORMAT_EXTENSIBLE. If the format tag is WAVE_FORMAT_EXTENSIBLE
+            want to make sure we copy the whole WAVEFORMATEXTENSIBLE structure. Otherwise we'll have to be
+            safe and only copy the WAVEFORMATEX part.
+            */
+            if (pNativeFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
+                MA_COPY_MEMORY(&wf, pNativeFormat, sizeof(MA_WAVEFORMATEXTENSIBLE));
+            } else {
+                /* I've seen a case where cbSize was set to 0. Assume sizeof(WAVEFORMATEX) in this case. */
+                size_t cbSize = pNativeFormat->cbSize;
+                if (cbSize == 0) {
+                    cbSize = sizeof(MA_WAVEFORMATEX);
+                }
+
+                /* Make sure we don't copy more than the capacity of `wf`. */
+                if (cbSize > sizeof(wf)) {
+                    cbSize = sizeof(wf);
+                }
+
+                MA_COPY_MEMORY(&wf, pNativeFormat, cbSize);
+            }
+
+            result = MA_SUCCESS;
+        }
+
+        ma_CoTaskMemFree(pContext, pNativeFormat);
+
+        shareMode = MA_AUDCLNT_SHAREMODE_SHARED;
+    }
+
+    /* Return an error if we still haven't found a format. */
+    if (result != MA_SUCCESS) {
+        errorMsg = "[WASAPI] Failed to find best device mix format.";
+        goto done;
+    }
+
+    /*
+    Override the native sample rate with the one requested by the caller, but only if we're not using the default sample rate. We'll use
+    WASAPI to perform the sample rate conversion.
+    */
+    nativeSampleRate = wf.nSamplesPerSec;
+    if (streamFlags & MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM) {
+        wf.nSamplesPerSec = (pData->sampleRateIn != 0) ? pData->sampleRateIn : MA_DEFAULT_SAMPLE_RATE;
+        wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;
+    }
+
+    pData->formatOut = ma_format_from_WAVEFORMATEX((MA_WAVEFORMATEX*)&wf);
+    if (pData->formatOut == ma_format_unknown) {
+        /*
+        The format isn't supported. This is almost certainly because the exclusive mode format isn't supported by miniaudio. We need to return MA_SHARE_MODE_NOT_SUPPORTED
+        in this case so that the caller can detect it and fall back to shared mode if desired. We should never get here if shared mode was requested, but just for
+        completeness we'll check for it and return MA_FORMAT_NOT_SUPPORTED.
+        */
+        if (shareMode == MA_AUDCLNT_SHAREMODE_EXCLUSIVE) {
+            result = MA_SHARE_MODE_NOT_SUPPORTED;
+        } else {
+            result = MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        errorMsg = "[WASAPI] Native format not supported.";
+        goto done;
+    }
+
+    pData->channelsOut = wf.nChannels;
+    pData->sampleRateOut = wf.nSamplesPerSec;
+
+    /*
+    Get the internal channel map based on the channel mask. There is a possibility that GetMixFormat() returns
+    a WAVEFORMATEX instead of a WAVEFORMATEXTENSIBLE, in which case the channel mask will be undefined. In this
+    case we'll just use the default channel map.
+    */
+    if (wf.wFormatTag == WAVE_FORMAT_EXTENSIBLE || wf.cbSize >= sizeof(MA_WAVEFORMATEXTENSIBLE)) {
+        ma_channel_mask_to_channel_map__win32(wf.dwChannelMask, pData->channelsOut, pData->channelMapOut);
+    } else {
+        ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pData->channelMapOut, ma_countof(pData->channelMapOut), pData->channelsOut);
+    }
+
+    /* Period size. */
+    pData->periodsOut = (pData->periodsIn != 0) ? pData->periodsIn : MA_DEFAULT_PERIODS;
+    pData->periodSizeInFramesOut = pData->periodSizeInFramesIn;
+    if (pData->periodSizeInFramesOut == 0) {
+        if (pData->periodSizeInMillisecondsIn == 0) {
+            if (pData->performanceProfile == ma_performance_profile_low_latency) {
+                pData->periodSizeInFramesOut = ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY, wf.nSamplesPerSec);
+            } else {
+                pData->periodSizeInFramesOut = ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE, wf.nSamplesPerSec);
+            }
+        } else {
+            pData->periodSizeInFramesOut = ma_calculate_buffer_size_in_frames_from_milliseconds(pData->periodSizeInMillisecondsIn, wf.nSamplesPerSec);
+        }
+    }
+
+    periodDurationInMicroseconds = ((ma_uint64)pData->periodSizeInFramesOut * 1000 * 1000) / wf.nSamplesPerSec;
+
+
+    /* Slightly different initialization for shared and exclusive modes. We try exclusive mode first, and if it fails, fall back to shared mode. */
+    if (shareMode == MA_AUDCLNT_SHAREMODE_EXCLUSIVE) {
+        MA_REFERENCE_TIME bufferDuration = periodDurationInMicroseconds * pData->periodsOut * 10;
+
+        /*
+        If the periodicy is too small, Initialize() will fail with AUDCLNT_E_INVALID_DEVICE_PERIOD. In this case we should just keep increasing
+        it and trying it again.
+        */
+        hr = E_FAIL;
+        for (;;) {
+            hr = ma_IAudioClient_Initialize((ma_IAudioClient*)pData->pAudioClient, shareMode, streamFlags, bufferDuration, bufferDuration, (MA_WAVEFORMATEX*)&wf, NULL);
+            if (hr == MA_AUDCLNT_E_INVALID_DEVICE_PERIOD) {
+                if (bufferDuration > 500*10000) {
+                    break;
+                } else {
+                    if (bufferDuration == 0) {  /* <-- Just a sanity check to prevent an infinit loop. Should never happen, but it makes me feel better. */
+                        break;
+                    }
+
+                    bufferDuration = bufferDuration * 2;
+                    continue;
+                }
+            } else {
+                break;
+            }
+        }
+
+        if (hr == MA_AUDCLNT_E_BUFFER_SIZE_NOT_ALIGNED) {
+            ma_uint32 bufferSizeInFrames;
+            hr = ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pData->pAudioClient, &bufferSizeInFrames);
+            if (SUCCEEDED(hr)) {
+                bufferDuration = (MA_REFERENCE_TIME)((10000.0 * 1000 / wf.nSamplesPerSec * bufferSizeInFrames) + 0.5);
+
+                /* Unfortunately we need to release and re-acquire the audio client according to MSDN. Seems silly - why not just call IAudioClient_Initialize() again?! */
+                ma_IAudioClient_Release((ma_IAudioClient*)pData->pAudioClient);
+
+            #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+                hr = ma_IMMDevice_Activate(pDeviceInterface, &MA_IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&pData->pAudioClient);
+            #else
+                hr = ma_IUnknown_QueryInterface(pDeviceInterface, &MA_IID_IAudioClient, (void**)&pData->pAudioClient);
+            #endif
+
+                if (SUCCEEDED(hr)) {
+                    hr = ma_IAudioClient_Initialize((ma_IAudioClient*)pData->pAudioClient, shareMode, streamFlags, bufferDuration, bufferDuration, (MA_WAVEFORMATEX*)&wf, NULL);
+                }
+            }
+        }
+
+        if (FAILED(hr)) {
+            /* Failed to initialize in exclusive mode. Don't fall back to shared mode - instead tell the client about it. They can reinitialize in shared mode if they want. */
+            if (hr == E_ACCESSDENIED) {
+                errorMsg = "[WASAPI] Failed to initialize device in exclusive mode. Access denied.", result = MA_ACCESS_DENIED;
+            } else if (hr == MA_AUDCLNT_E_DEVICE_IN_USE) {
+                errorMsg = "[WASAPI] Failed to initialize device in exclusive mode. Device in use.", result = MA_BUSY;
+            } else {
+                errorMsg = "[WASAPI] Failed to initialize device in exclusive mode."; result = ma_result_from_HRESULT(hr);
+            }
+            goto done;
+        }
+    }
+
+    if (shareMode == MA_AUDCLNT_SHAREMODE_SHARED) {
+        /*
+        Low latency shared mode via IAudioClient3.
+
+        NOTE
+        ====
+        Contrary to the documentation on MSDN (https://docs.microsoft.com/en-us/windows/win32/api/audioclient/nf-audioclient-iaudioclient3-initializesharedaudiostream), the
+        use of AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM and AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY with IAudioClient3_InitializeSharedAudioStream() absolutely does not work. Using
+        any of these flags will result in HRESULT code 0x88890021. The other problem is that calling IAudioClient3_GetSharedModeEnginePeriod() with a sample rate different to
+        that returned by IAudioClient_GetMixFormat() also results in an error. I'm therefore disabling low-latency shared mode with AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM.
+        */
+        #ifndef MA_WASAPI_NO_LOW_LATENCY_SHARED_MODE
+        {
+            if ((streamFlags & MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM) == 0 || nativeSampleRate == wf.nSamplesPerSec) {
+                ma_IAudioClient3* pAudioClient3 = NULL;
+                hr = ma_IAudioClient_QueryInterface(pData->pAudioClient, &MA_IID_IAudioClient3, (void**)&pAudioClient3);
+                if (SUCCEEDED(hr)) {
+                    ma_uint32 defaultPeriodInFrames;
+                    ma_uint32 fundamentalPeriodInFrames;
+                    ma_uint32 minPeriodInFrames;
+                    ma_uint32 maxPeriodInFrames;
+                    hr = ma_IAudioClient3_GetSharedModeEnginePeriod(pAudioClient3, (MA_WAVEFORMATEX*)&wf, &defaultPeriodInFrames, &fundamentalPeriodInFrames, &minPeriodInFrames, &maxPeriodInFrames);
+                    if (SUCCEEDED(hr)) {
+                        ma_uint32 desiredPeriodInFrames = pData->periodSizeInFramesOut;
+                        ma_uint32 actualPeriodInFrames  = desiredPeriodInFrames;
+
+                        /* Make sure the period size is a multiple of fundamentalPeriodInFrames. */
+                        actualPeriodInFrames = actualPeriodInFrames / fundamentalPeriodInFrames;
+                        actualPeriodInFrames = actualPeriodInFrames * fundamentalPeriodInFrames;
+
+                        /* The period needs to be clamped between minPeriodInFrames and maxPeriodInFrames. */
+                        actualPeriodInFrames = ma_clamp(actualPeriodInFrames, minPeriodInFrames, maxPeriodInFrames);
+
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] Trying IAudioClient3_InitializeSharedAudioStream(actualPeriodInFrames=%d)\n", actualPeriodInFrames);
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "    defaultPeriodInFrames=%d\n", defaultPeriodInFrames);
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "    fundamentalPeriodInFrames=%d\n", fundamentalPeriodInFrames);
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "    minPeriodInFrames=%d\n", minPeriodInFrames);
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "    maxPeriodInFrames=%d\n", maxPeriodInFrames);
+
+                        /* If the client requested a largish buffer than we don't actually want to use low latency shared mode because it forces small buffers. */
+                        if (actualPeriodInFrames >= desiredPeriodInFrames) {
+                            /*
+                            MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | MA_AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY must not be in the stream flags. If either of these are specified,
+                            IAudioClient3_InitializeSharedAudioStream() will fail.
+                            */
+                            hr = ma_IAudioClient3_InitializeSharedAudioStream(pAudioClient3, streamFlags & ~(MA_AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | MA_AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY), actualPeriodInFrames, (MA_WAVEFORMATEX*)&wf, NULL);
+                            if (SUCCEEDED(hr)) {
+                                wasInitializedUsingIAudioClient3 = MA_TRUE;
+                                pData->periodSizeInFramesOut = actualPeriodInFrames;
+
+                                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] Using IAudioClient3\n");
+                                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "    periodSizeInFramesOut=%d\n", pData->periodSizeInFramesOut);
+                            } else {
+                                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] IAudioClient3_InitializeSharedAudioStream failed. Falling back to IAudioClient.\n");
+                            }
+                        } else {
+                            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] Not using IAudioClient3 because the desired period size is larger than the maximum supported by IAudioClient3.\n");
+                        }
+                    } else {
+                        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] IAudioClient3_GetSharedModeEnginePeriod failed. Falling back to IAudioClient.\n");
+                    }
+
+                    ma_IAudioClient3_Release(pAudioClient3);
+                    pAudioClient3 = NULL;
+                }
+            }
+        }
+        #else
+        {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[WASAPI] Not using IAudioClient3 because MA_WASAPI_NO_LOW_LATENCY_SHARED_MODE is enabled.\n");
+        }
+        #endif
+
+        /* If we don't have an IAudioClient3 then we need to use the normal initialization routine. */
+        if (!wasInitializedUsingIAudioClient3) {
+            MA_REFERENCE_TIME bufferDuration = periodDurationInMicroseconds * pData->periodsOut * 10;   /* <-- Multiply by 10 for microseconds to 100-nanoseconds. */
+            hr = ma_IAudioClient_Initialize((ma_IAudioClient*)pData->pAudioClient, shareMode, streamFlags, bufferDuration, 0, (const MA_WAVEFORMATEX*)&wf, NULL);
+            if (FAILED(hr)) {
+                if (hr == E_ACCESSDENIED) {
+                    errorMsg = "[WASAPI] Failed to initialize device. Access denied.", result = MA_ACCESS_DENIED;
+                } else if (hr == MA_AUDCLNT_E_DEVICE_IN_USE) {
+                    errorMsg = "[WASAPI] Failed to initialize device. Device in use.", result = MA_BUSY;
+                } else {
+                    errorMsg = "[WASAPI] Failed to initialize device.", result = ma_result_from_HRESULT(hr);
+                }
+
+                goto done;
+            }
+        }
+    }
+
+    if (!wasInitializedUsingIAudioClient3) {
+        ma_uint32 bufferSizeInFrames = 0;
+        hr = ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pData->pAudioClient, &bufferSizeInFrames);
+        if (FAILED(hr)) {
+            errorMsg = "[WASAPI] Failed to get audio client's actual buffer size.", result = ma_result_from_HRESULT(hr);
+            goto done;
+        }
+
+        /*
+        When using process loopback mode, retrieval of the buffer size seems to result in totally
+        incorrect values. In this case we'll just assume it's the same size as what we requested
+        when we initialized the client.
+        */
+        if (usingProcessLoopback) {
+            bufferSizeInFrames = (ma_uint32)((periodDurationInMicroseconds * pData->periodsOut) * pData->sampleRateOut / 1000000);
+        }
+
+        pData->periodSizeInFramesOut = bufferSizeInFrames / pData->periodsOut;
+    }
+
+    pData->usingAudioClient3 = wasInitializedUsingIAudioClient3;
+
+
+    if (deviceType == ma_device_type_playback) {
+        result = ma_device_create_IAudioClient_service__wasapi(pContext, deviceType, (ma_IAudioClient*)pData->pAudioClient, (void**)&pData->pRenderClient);
+    } else {
+        result = ma_device_create_IAudioClient_service__wasapi(pContext, deviceType, (ma_IAudioClient*)pData->pAudioClient, (void**)&pData->pCaptureClient);
+    }
+
+    /*if (FAILED(hr)) {*/
+    if (result != MA_SUCCESS) {
+        errorMsg = "[WASAPI] Failed to get audio client service.";
+        goto done;
+    }
+
+
+    /* Grab the name of the device. */
+    #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    {
+        ma_IPropertyStore *pProperties;
+        hr = ma_IMMDevice_OpenPropertyStore(pDeviceInterface, STGM_READ, &pProperties);
+        if (SUCCEEDED(hr)) {
+            MA_PROPVARIANT varName;
+            ma_PropVariantInit(&varName);
+            hr = ma_IPropertyStore_GetValue(pProperties, &MA_PKEY_Device_FriendlyName, &varName);
+            if (SUCCEEDED(hr)) {
+                WideCharToMultiByte(CP_UTF8, 0, varName.pwszVal, -1, pData->deviceName, sizeof(pData->deviceName), 0, FALSE);
+                ma_PropVariantClear(pContext, &varName);
+            }
+
+            ma_IPropertyStore_Release(pProperties);
+        }
+    }
+    #endif
+
+    /*
+    For the WASAPI backend we need to know the actual IDs of the device in order to do automatic
+    stream routing so that IDs can be compared and we can determine which device has been detached
+    and whether or not it matches with our ma_device.
+    */
+    #if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    {
+        /* Desktop */
+        ma_context_get_device_id_from_MMDevice__wasapi(pContext, pDeviceInterface, &pData->id);
+    }
+    #else
+    {
+        /* UWP */
+        /* TODO: Implement me. Need to figure out how to get the ID of the default device. */
+    }
+    #endif
+
+done:
+    /* Clean up. */
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    if (pDeviceInterface != NULL) {
+        ma_IMMDevice_Release(pDeviceInterface);
+    }
+#else
+    if (pDeviceInterface != NULL) {
+        ma_IUnknown_Release(pDeviceInterface);
+    }
+#endif
+
+    if (result != MA_SUCCESS) {
+        if (pData->pRenderClient) {
+            ma_IAudioRenderClient_Release((ma_IAudioRenderClient*)pData->pRenderClient);
+            pData->pRenderClient = NULL;
+        }
+        if (pData->pCaptureClient) {
+            ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pData->pCaptureClient);
+            pData->pCaptureClient = NULL;
+        }
+        if (pData->pAudioClient) {
+            ma_IAudioClient_Release((ma_IAudioClient*)pData->pAudioClient);
+            pData->pAudioClient = NULL;
+        }
+
+        if (errorMsg != NULL && errorMsg[0] != '\0') {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "%s\n", errorMsg);
+        }
+
+        return result;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+static ma_result ma_device_reinit__wasapi(ma_device* pDevice, ma_device_type deviceType)
+{
+    ma_device_init_internal_data__wasapi data;
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* We only re-initialize the playback or capture device. Never a full-duplex device. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+
+    /*
+    Before reinitializing the device we need to free the previous audio clients.
+
+    There's a known memory leak here. We will be calling this from the routing change callback that
+    is fired by WASAPI. If we attempt to release the IAudioClient we will deadlock. In my opinion
+    this is a bug. I'm not sure what I need to do to handle this cleanly, but I think we'll probably
+    need some system where we post an event, but delay the execution of it until the callback has
+    returned. I'm not sure how to do this reliably, however. I have set up some infrastructure for
+    a command thread which might be useful for this.
+    */
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_loopback) {
+        if (pDevice->wasapi.pCaptureClient) {
+            ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient);
+            pDevice->wasapi.pCaptureClient = NULL;
+        }
+
+        if (pDevice->wasapi.pAudioClientCapture) {
+            /*ma_device_release_IAudioClient_service__wasapi(pDevice, ma_device_type_capture);*/
+            pDevice->wasapi.pAudioClientCapture = NULL;
+        }
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        if (pDevice->wasapi.pRenderClient) {
+            ma_IAudioRenderClient_Release((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient);
+            pDevice->wasapi.pRenderClient = NULL;
+        }
+
+        if (pDevice->wasapi.pAudioClientPlayback) {
+            /*ma_device_release_IAudioClient_service__wasapi(pDevice, ma_device_type_playback);*/
+            pDevice->wasapi.pAudioClientPlayback = NULL;
+        }
+    }
+
+
+    if (deviceType == ma_device_type_playback) {
+        data.formatIn               = pDevice->playback.format;
+        data.channelsIn             = pDevice->playback.channels;
+        MA_COPY_MEMORY(data.channelMapIn, pDevice->playback.channelMap, sizeof(pDevice->playback.channelMap));
+        data.shareMode              = pDevice->playback.shareMode;
+    } else {
+        data.formatIn               = pDevice->capture.format;
+        data.channelsIn             = pDevice->capture.channels;
+        MA_COPY_MEMORY(data.channelMapIn, pDevice->capture.channelMap, sizeof(pDevice->capture.channelMap));
+        data.shareMode              = pDevice->capture.shareMode;
+    }
+
+    data.sampleRateIn               = pDevice->sampleRate;
+    data.periodSizeInFramesIn       = pDevice->wasapi.originalPeriodSizeInFrames;
+    data.periodSizeInMillisecondsIn = pDevice->wasapi.originalPeriodSizeInMilliseconds;
+    data.periodsIn                  = pDevice->wasapi.originalPeriods;
+    data.performanceProfile         = pDevice->wasapi.originalPerformanceProfile;
+    data.noAutoConvertSRC           = pDevice->wasapi.noAutoConvertSRC;
+    data.noDefaultQualitySRC        = pDevice->wasapi.noDefaultQualitySRC;
+    data.noHardwareOffloading       = pDevice->wasapi.noHardwareOffloading;
+    data.loopbackProcessID          = pDevice->wasapi.loopbackProcessID;
+    data.loopbackProcessExclude     = pDevice->wasapi.loopbackProcessExclude;
+    result = ma_device_init_internal__wasapi(pDevice->pContext, deviceType, NULL, &data);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* At this point we have some new objects ready to go. We need to uninitialize the previous ones and then set the new ones. */
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_loopback) {
+        pDevice->wasapi.pAudioClientCapture         = data.pAudioClient;
+        pDevice->wasapi.pCaptureClient              = data.pCaptureClient;
+
+        pDevice->capture.internalFormat             = data.formatOut;
+        pDevice->capture.internalChannels           = data.channelsOut;
+        pDevice->capture.internalSampleRate         = data.sampleRateOut;
+        MA_COPY_MEMORY(pDevice->capture.internalChannelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDevice->capture.internalPeriodSizeInFrames = data.periodSizeInFramesOut;
+        pDevice->capture.internalPeriods            = data.periodsOut;
+        ma_strcpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), data.deviceName);
+
+        ma_IAudioClient_SetEventHandle((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture, (HANDLE)pDevice->wasapi.hEventCapture);
+
+        pDevice->wasapi.periodSizeInFramesCapture = data.periodSizeInFramesOut;
+        ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture, &pDevice->wasapi.actualBufferSizeInFramesCapture);
+
+        /* We must always have a valid ID. */
+        ma_strcpy_s_WCHAR(pDevice->capture.id.wasapi, sizeof(pDevice->capture.id.wasapi), data.id.wasapi);
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        pDevice->wasapi.pAudioClientPlayback         = data.pAudioClient;
+        pDevice->wasapi.pRenderClient                = data.pRenderClient;
+
+        pDevice->playback.internalFormat             = data.formatOut;
+        pDevice->playback.internalChannels           = data.channelsOut;
+        pDevice->playback.internalSampleRate         = data.sampleRateOut;
+        MA_COPY_MEMORY(pDevice->playback.internalChannelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDevice->playback.internalPeriodSizeInFrames = data.periodSizeInFramesOut;
+        pDevice->playback.internalPeriods            = data.periodsOut;
+        ma_strcpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), data.deviceName);
+
+        ma_IAudioClient_SetEventHandle((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback, (HANDLE)pDevice->wasapi.hEventPlayback);
+
+        pDevice->wasapi.periodSizeInFramesPlayback = data.periodSizeInFramesOut;
+        ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback, &pDevice->wasapi.actualBufferSizeInFramesPlayback);
+
+        /* We must always have a valid ID because rerouting will look at it. */
+        ma_strcpy_s_WCHAR(pDevice->playback.id.wasapi, sizeof(pDevice->playback.id.wasapi), data.id.wasapi);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__wasapi(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result = MA_SUCCESS;
+
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    HRESULT hr;
+    ma_IMMDeviceEnumerator* pDeviceEnumerator;
+#endif
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->wasapi);
+    pDevice->wasapi.usage                  = pConfig->wasapi.usage;
+    pDevice->wasapi.noAutoConvertSRC       = pConfig->wasapi.noAutoConvertSRC;
+    pDevice->wasapi.noDefaultQualitySRC    = pConfig->wasapi.noDefaultQualitySRC;
+    pDevice->wasapi.noHardwareOffloading   = pConfig->wasapi.noHardwareOffloading;
+    pDevice->wasapi.loopbackProcessID      = pConfig->wasapi.loopbackProcessID;
+    pDevice->wasapi.loopbackProcessExclude = pConfig->wasapi.loopbackProcessExclude;
+
+    /* Exclusive mode is not allowed with loopback. */
+    if (pConfig->deviceType == ma_device_type_loopback && pConfig->playback.shareMode == ma_share_mode_exclusive) {
+        return MA_INVALID_DEVICE_CONFIG;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) {
+        ma_device_init_internal_data__wasapi data;
+        data.formatIn                   = pDescriptorCapture->format;
+        data.channelsIn                 = pDescriptorCapture->channels;
+        data.sampleRateIn               = pDescriptorCapture->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDescriptorCapture->channelMap, sizeof(pDescriptorCapture->channelMap));
+        data.periodSizeInFramesIn       = pDescriptorCapture->periodSizeInFrames;
+        data.periodSizeInMillisecondsIn = pDescriptorCapture->periodSizeInMilliseconds;
+        data.periodsIn                  = pDescriptorCapture->periodCount;
+        data.shareMode                  = pDescriptorCapture->shareMode;
+        data.performanceProfile         = pConfig->performanceProfile;
+        data.noAutoConvertSRC           = pConfig->wasapi.noAutoConvertSRC;
+        data.noDefaultQualitySRC        = pConfig->wasapi.noDefaultQualitySRC;
+        data.noHardwareOffloading       = pConfig->wasapi.noHardwareOffloading;
+        data.loopbackProcessID          = pConfig->wasapi.loopbackProcessID;
+        data.loopbackProcessExclude     = pConfig->wasapi.loopbackProcessExclude;
+
+        result = ma_device_init_internal__wasapi(pDevice->pContext, (pConfig->deviceType == ma_device_type_loopback) ? ma_device_type_loopback : ma_device_type_capture, pDescriptorCapture->pDeviceID, &data);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pDevice->wasapi.pAudioClientCapture              = data.pAudioClient;
+        pDevice->wasapi.pCaptureClient                   = data.pCaptureClient;
+        pDevice->wasapi.originalPeriodSizeInMilliseconds = pDescriptorCapture->periodSizeInMilliseconds;
+        pDevice->wasapi.originalPeriodSizeInFrames       = pDescriptorCapture->periodSizeInFrames;
+        pDevice->wasapi.originalPeriods                  = pDescriptorCapture->periodCount;
+        pDevice->wasapi.originalPerformanceProfile       = pConfig->performanceProfile;
+
+        /*
+        The event for capture needs to be manual reset for the same reason as playback. We keep the initial state set to unsignaled,
+        however, because we want to block until we actually have something for the first call to ma_device_read().
+        */
+        pDevice->wasapi.hEventCapture = (ma_handle)CreateEventA(NULL, FALSE, FALSE, NULL);  /* Auto reset, unsignaled by default. */
+        if (pDevice->wasapi.hEventCapture == NULL) {
+            result = ma_result_from_GetLastError(GetLastError());
+
+            if (pDevice->wasapi.pCaptureClient != NULL) {
+                ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient);
+                pDevice->wasapi.pCaptureClient = NULL;
+            }
+            if (pDevice->wasapi.pAudioClientCapture != NULL) {
+                ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+                pDevice->wasapi.pAudioClientCapture = NULL;
+            }
+
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create event for capture.");
+            return result;
+        }
+        ma_IAudioClient_SetEventHandle((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture, (HANDLE)pDevice->wasapi.hEventCapture);
+
+        pDevice->wasapi.periodSizeInFramesCapture = data.periodSizeInFramesOut;
+        ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture, &pDevice->wasapi.actualBufferSizeInFramesCapture);
+
+        /* We must always have a valid ID. */
+        ma_strcpy_s_WCHAR(pDevice->capture.id.wasapi, sizeof(pDevice->capture.id.wasapi), data.id.wasapi);
+
+        /* The descriptor needs to be updated with actual values. */
+        pDescriptorCapture->format             = data.formatOut;
+        pDescriptorCapture->channels           = data.channelsOut;
+        pDescriptorCapture->sampleRate         = data.sampleRateOut;
+        MA_COPY_MEMORY(pDescriptorCapture->channelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDescriptorCapture->periodSizeInFrames = data.periodSizeInFramesOut;
+        pDescriptorCapture->periodCount        = data.periodsOut;
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_device_init_internal_data__wasapi data;
+        data.formatIn                   = pDescriptorPlayback->format;
+        data.channelsIn                 = pDescriptorPlayback->channels;
+        data.sampleRateIn               = pDescriptorPlayback->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDescriptorPlayback->channelMap, sizeof(pDescriptorPlayback->channelMap));
+        data.periodSizeInFramesIn       = pDescriptorPlayback->periodSizeInFrames;
+        data.periodSizeInMillisecondsIn = pDescriptorPlayback->periodSizeInMilliseconds;
+        data.periodsIn                  = pDescriptorPlayback->periodCount;
+        data.shareMode                  = pDescriptorPlayback->shareMode;
+        data.performanceProfile         = pConfig->performanceProfile;
+        data.noAutoConvertSRC           = pConfig->wasapi.noAutoConvertSRC;
+        data.noDefaultQualitySRC        = pConfig->wasapi.noDefaultQualitySRC;
+        data.noHardwareOffloading       = pConfig->wasapi.noHardwareOffloading;
+        data.loopbackProcessID          = pConfig->wasapi.loopbackProcessID;
+        data.loopbackProcessExclude     = pConfig->wasapi.loopbackProcessExclude;
+
+        result = ma_device_init_internal__wasapi(pDevice->pContext, ma_device_type_playback, pDescriptorPlayback->pDeviceID, &data);
+        if (result != MA_SUCCESS) {
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                if (pDevice->wasapi.pCaptureClient != NULL) {
+                    ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient);
+                    pDevice->wasapi.pCaptureClient = NULL;
+                }
+                if (pDevice->wasapi.pAudioClientCapture != NULL) {
+                    ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+                    pDevice->wasapi.pAudioClientCapture = NULL;
+                }
+
+                CloseHandle((HANDLE)pDevice->wasapi.hEventCapture);
+                pDevice->wasapi.hEventCapture = NULL;
+            }
+            return result;
+        }
+
+        pDevice->wasapi.pAudioClientPlayback             = data.pAudioClient;
+        pDevice->wasapi.pRenderClient                    = data.pRenderClient;
+        pDevice->wasapi.originalPeriodSizeInMilliseconds = pDescriptorPlayback->periodSizeInMilliseconds;
+        pDevice->wasapi.originalPeriodSizeInFrames       = pDescriptorPlayback->periodSizeInFrames;
+        pDevice->wasapi.originalPeriods                  = pDescriptorPlayback->periodCount;
+        pDevice->wasapi.originalPerformanceProfile       = pConfig->performanceProfile;
+
+        /*
+        The event for playback is needs to be manual reset because we want to explicitly control the fact that it becomes signalled
+        only after the whole available space has been filled, never before.
+
+        The playback event also needs to be initially set to a signaled state so that the first call to ma_device_write() is able
+        to get passed WaitForMultipleObjects().
+        */
+        pDevice->wasapi.hEventPlayback = (ma_handle)CreateEventA(NULL, FALSE, TRUE, NULL);  /* Auto reset, signaled by default. */
+        if (pDevice->wasapi.hEventPlayback == NULL) {
+            result = ma_result_from_GetLastError(GetLastError());
+
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                if (pDevice->wasapi.pCaptureClient != NULL) {
+                    ma_IAudioCaptureClient_Release((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient);
+                    pDevice->wasapi.pCaptureClient = NULL;
+                }
+                if (pDevice->wasapi.pAudioClientCapture != NULL) {
+                    ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+                    pDevice->wasapi.pAudioClientCapture = NULL;
+                }
+
+                CloseHandle((HANDLE)pDevice->wasapi.hEventCapture);
+                pDevice->wasapi.hEventCapture = NULL;
+            }
+
+            if (pDevice->wasapi.pRenderClient != NULL) {
+                ma_IAudioRenderClient_Release((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient);
+                pDevice->wasapi.pRenderClient = NULL;
+            }
+            if (pDevice->wasapi.pAudioClientPlayback != NULL) {
+                ma_IAudioClient_Release((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback);
+                pDevice->wasapi.pAudioClientPlayback = NULL;
+            }
+
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create event for playback.");
+            return result;
+        }
+        ma_IAudioClient_SetEventHandle((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback, (HANDLE)pDevice->wasapi.hEventPlayback);
+
+        pDevice->wasapi.periodSizeInFramesPlayback = data.periodSizeInFramesOut;
+        ma_IAudioClient_GetBufferSize((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback, &pDevice->wasapi.actualBufferSizeInFramesPlayback);
+
+        /* We must always have a valid ID because rerouting will look at it. */
+        ma_strcpy_s_WCHAR(pDevice->playback.id.wasapi, sizeof(pDevice->playback.id.wasapi), data.id.wasapi);
+
+        /* The descriptor needs to be updated with actual values. */
+        pDescriptorPlayback->format             = data.formatOut;
+        pDescriptorPlayback->channels           = data.channelsOut;
+        pDescriptorPlayback->sampleRate         = data.sampleRateOut;
+        MA_COPY_MEMORY(pDescriptorPlayback->channelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDescriptorPlayback->periodSizeInFrames = data.periodSizeInFramesOut;
+        pDescriptorPlayback->periodCount        = data.periodsOut;
+    }
+
+    /*
+    We need to register a notification client to detect when the device has been disabled, unplugged or re-routed (when the default device changes). When
+    we are connecting to the default device we want to do automatic stream routing when the device is disabled or unplugged. Otherwise we want to just
+    stop the device outright and let the application handle it.
+    */
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    if (pConfig->wasapi.noAutoStreamRouting == MA_FALSE) {
+        if ((pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) && pConfig->capture.pDeviceID == NULL) {
+            pDevice->wasapi.allowCaptureAutoStreamRouting = MA_TRUE;
+        }
+        if ((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pConfig->playback.pDeviceID == NULL) {
+            pDevice->wasapi.allowPlaybackAutoStreamRouting = MA_TRUE;
+        }
+    }
+
+    ma_mutex_init(&pDevice->wasapi.rerouteLock);
+
+    hr = ma_CoCreateInstance(pDevice->pContext, &MA_CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, &MA_IID_IMMDeviceEnumerator, (void**)&pDeviceEnumerator);
+    if (FAILED(hr)) {
+        ma_device_uninit__wasapi(pDevice);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to create device enumerator.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    pDevice->wasapi.notificationClient.lpVtbl  = (void*)&g_maNotificationCientVtbl;
+    pDevice->wasapi.notificationClient.counter = 1;
+    pDevice->wasapi.notificationClient.pDevice = pDevice;
+
+    hr = pDeviceEnumerator->lpVtbl->RegisterEndpointNotificationCallback(pDeviceEnumerator, &pDevice->wasapi.notificationClient);
+    if (SUCCEEDED(hr)) {
+        pDevice->wasapi.pDeviceEnumerator = (ma_ptr)pDeviceEnumerator;
+    } else {
+        /* Not the end of the world if we fail to register the notification callback. We just won't support automatic stream routing. */
+        ma_IMMDeviceEnumerator_Release(pDeviceEnumerator);
+    }
+#endif
+
+    ma_atomic_bool32_set(&pDevice->wasapi.isStartedCapture,  MA_FALSE);
+    ma_atomic_bool32_set(&pDevice->wasapi.isStartedPlayback, MA_FALSE);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device__get_available_frames__wasapi(ma_device* pDevice, ma_IAudioClient* pAudioClient, ma_uint32* pFrameCount)
+{
+    ma_uint32 paddingFramesCount;
+    HRESULT hr;
+    ma_share_mode shareMode;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pFrameCount != NULL);
+
+    *pFrameCount = 0;
+
+    if ((ma_ptr)pAudioClient != pDevice->wasapi.pAudioClientPlayback && (ma_ptr)pAudioClient != pDevice->wasapi.pAudioClientCapture) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /*
+    I've had a report that GetCurrentPadding() is returning a frame count of 0 which is preventing
+    higher level function calls from doing anything because it thinks nothing is available. I have
+    taken a look at the documentation and it looks like this is unnecessary in exclusive mode.
+
+    From Microsoft's documentation:
+
+        For an exclusive-mode rendering or capture stream that was initialized with the
+        AUDCLNT_STREAMFLAGS_EVENTCALLBACK flag, the client typically has no use for the padding
+        value reported by GetCurrentPadding. Instead, the client accesses an entire buffer during
+        each processing pass.
+
+    Considering this, I'm going to skip GetCurrentPadding() for exclusive mode and just report the
+    entire buffer. This depends on the caller making sure they wait on the event handler.
+    */
+    shareMode = ((ma_ptr)pAudioClient == pDevice->wasapi.pAudioClientPlayback) ? pDevice->playback.shareMode : pDevice->capture.shareMode;
+    if (shareMode == ma_share_mode_shared) {
+        /* Shared mode. */
+        hr = ma_IAudioClient_GetCurrentPadding(pAudioClient, &paddingFramesCount);
+        if (FAILED(hr)) {
+            return ma_result_from_HRESULT(hr);
+        }
+
+        if ((ma_ptr)pAudioClient == pDevice->wasapi.pAudioClientPlayback) {
+            *pFrameCount = pDevice->wasapi.actualBufferSizeInFramesPlayback - paddingFramesCount;
+        } else {
+            *pFrameCount = paddingFramesCount;
+        }
+    } else {
+        /* Exclusive mode. */
+        if ((ma_ptr)pAudioClient == pDevice->wasapi.pAudioClientPlayback) {
+            *pFrameCount = pDevice->wasapi.actualBufferSizeInFramesPlayback;
+        } else {
+            *pFrameCount = pDevice->wasapi.actualBufferSizeInFramesCapture;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_reroute__wasapi(ma_device* pDevice, ma_device_type deviceType)
+{
+    ma_result result;
+
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "=== CHANGING DEVICE ===\n");
+
+    result = ma_device_reinit__wasapi(pDevice, deviceType);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[WASAPI] Reinitializing device after route change failed.\n");
+        return result;
+    }
+
+    ma_device__post_init_setup(pDevice, deviceType);
+    ma_device__on_notification_rerouted(pDevice);
+
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "=== DEVICE CHANGED ===\n");
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__wasapi_nolock(ma_device* pDevice)
+{
+    HRESULT hr;
+
+    if (pDevice->pContext->wasapi.hAvrt) {
+        const char* pTaskName = ma_to_usage_string__wasapi(pDevice->wasapi.usage);
+        if (pTaskName) {
+            DWORD idx = 0;
+            pDevice->wasapi.hAvrtHandle = (ma_handle)((MA_PFN_AvSetMmThreadCharacteristicsA)pDevice->pContext->wasapi.AvSetMmThreadCharacteristicsA)(pTaskName, &idx);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+        hr = ma_IAudioClient_Start((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+        if (FAILED(hr)) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to start internal capture device. HRESULT = %d.", (int)hr);
+            return ma_result_from_HRESULT(hr);
+        }
+
+        ma_atomic_bool32_set(&pDevice->wasapi.isStartedCapture, MA_TRUE);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        hr = ma_IAudioClient_Start((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback);
+        if (FAILED(hr)) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to start internal playback device. HRESULT = %d.", (int)hr);
+            return ma_result_from_HRESULT(hr);
+        }
+
+        ma_atomic_bool32_set(&pDevice->wasapi.isStartedPlayback, MA_TRUE);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__wasapi(ma_device* pDevice)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* Wait for any rerouting to finish before attempting to start the device. */
+    ma_mutex_lock(&pDevice->wasapi.rerouteLock);
+    {
+        result = ma_device_start__wasapi_nolock(pDevice);
+    }
+    ma_mutex_unlock(&pDevice->wasapi.rerouteLock);
+
+    return result;
+}
+
+static ma_result ma_device_stop__wasapi_nolock(ma_device* pDevice)
+{
+    ma_result result;
+    HRESULT hr;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->wasapi.hAvrtHandle) {
+        ((MA_PFN_AvRevertMmThreadCharacteristics)pDevice->pContext->wasapi.AvRevertMmThreadcharacteristics)((HANDLE)pDevice->wasapi.hAvrtHandle);
+        pDevice->wasapi.hAvrtHandle = NULL;
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+        hr = ma_IAudioClient_Stop((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to stop internal capture device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* The audio client needs to be reset otherwise restarting will fail. */
+        hr = ma_IAudioClient_Reset((ma_IAudioClient*)pDevice->wasapi.pAudioClientCapture);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to reset internal capture device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* If we have a mapped buffer we need to release it. */
+        if (pDevice->wasapi.pMappedBufferCapture != NULL) {
+            ma_IAudioCaptureClient_ReleaseBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, pDevice->wasapi.mappedBufferCaptureCap);
+            pDevice->wasapi.pMappedBufferCapture = NULL;
+            pDevice->wasapi.mappedBufferCaptureCap = 0;
+            pDevice->wasapi.mappedBufferCaptureLen = 0;
+        }
+
+        ma_atomic_bool32_set(&pDevice->wasapi.isStartedCapture, MA_FALSE);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /*
+        The buffer needs to be drained before stopping the device. Not doing this will result in the last few frames not getting output to
+        the speakers. This is a problem for very short sounds because it'll result in a significant portion of it not getting played.
+        */
+        if (ma_atomic_bool32_get(&pDevice->wasapi.isStartedPlayback)) {
+            /* We need to make sure we put a timeout here or else we'll risk getting stuck in a deadlock in some cases. */
+            DWORD waitTime = pDevice->wasapi.actualBufferSizeInFramesPlayback / pDevice->playback.internalSampleRate;
+
+            if (pDevice->playback.shareMode == ma_share_mode_exclusive) {
+                WaitForSingleObject((HANDLE)pDevice->wasapi.hEventPlayback, waitTime);
+            }
+            else {
+                ma_uint32 prevFramesAvaialablePlayback = (ma_uint32)-1;
+                ma_uint32 framesAvailablePlayback;
+                for (;;) {
+                    result = ma_device__get_available_frames__wasapi(pDevice, (ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback, &framesAvailablePlayback);
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+
+                    if (framesAvailablePlayback >= pDevice->wasapi.actualBufferSizeInFramesPlayback) {
+                        break;
+                    }
+
+                    /*
+                    Just a safety check to avoid an infinite loop. If this iteration results in a situation where the number of available frames
+                    has not changed, get out of the loop. I don't think this should ever happen, but I think it's nice to have just in case.
+                    */
+                    if (framesAvailablePlayback == prevFramesAvaialablePlayback) {
+                        break;
+                    }
+                    prevFramesAvaialablePlayback = framesAvailablePlayback;
+
+                    WaitForSingleObject((HANDLE)pDevice->wasapi.hEventPlayback, waitTime * 1000);
+                    ResetEvent((HANDLE)pDevice->wasapi.hEventPlayback); /* Manual reset. */
+                }
+            }
+        }
+
+        hr = ma_IAudioClient_Stop((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to stop internal playback device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* The audio client needs to be reset otherwise restarting will fail. */
+        hr = ma_IAudioClient_Reset((ma_IAudioClient*)pDevice->wasapi.pAudioClientPlayback);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to reset internal playback device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        if (pDevice->wasapi.pMappedBufferPlayback != NULL) {
+            ma_IAudioRenderClient_ReleaseBuffer((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient, pDevice->wasapi.mappedBufferPlaybackCap, 0);
+            pDevice->wasapi.pMappedBufferPlayback = NULL;
+            pDevice->wasapi.mappedBufferPlaybackCap = 0;
+            pDevice->wasapi.mappedBufferPlaybackLen = 0;
+        }
+
+        ma_atomic_bool32_set(&pDevice->wasapi.isStartedPlayback, MA_FALSE);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__wasapi(ma_device* pDevice)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* Wait for any rerouting to finish before attempting to stop the device. */
+    ma_mutex_lock(&pDevice->wasapi.rerouteLock);
+    {
+        result = ma_device_stop__wasapi_nolock(pDevice);
+    }
+    ma_mutex_unlock(&pDevice->wasapi.rerouteLock);
+
+    return result;
+}
+
+
+#ifndef MA_WASAPI_WAIT_TIMEOUT_MILLISECONDS
+#define MA_WASAPI_WAIT_TIMEOUT_MILLISECONDS 5000
+#endif
+
+static ma_result ma_device_read__wasapi(ma_device* pDevice, void* pFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 totalFramesProcessed = 0;
+
+    /*
+    When reading, we need to get a buffer and process all of it before releasing it. Because the
+    frame count (frameCount) can be different to the size of the buffer, we'll need to cache the
+    pointer to the buffer.
+    */
+
+    /* Keep running until we've processed the requested number of frames. */
+    while (ma_device_get_state(pDevice) == ma_device_state_started && totalFramesProcessed < frameCount) {
+        ma_uint32 framesRemaining = frameCount - totalFramesProcessed;
+
+        /* If we have a mapped data buffer, consume that first. */
+        if (pDevice->wasapi.pMappedBufferCapture != NULL) {
+            /* We have a cached data pointer so consume that before grabbing another one from WASAPI. */
+            ma_uint32 framesToProcessNow = framesRemaining;
+            if (framesToProcessNow > pDevice->wasapi.mappedBufferCaptureLen) {
+                framesToProcessNow = pDevice->wasapi.mappedBufferCaptureLen;
+            }
+
+            /* Now just copy the data over to the output buffer. */
+            ma_copy_pcm_frames(
+                ma_offset_pcm_frames_ptr(pFrames, totalFramesProcessed, pDevice->capture.internalFormat, pDevice->capture.internalChannels),
+                ma_offset_pcm_frames_const_ptr(pDevice->wasapi.pMappedBufferCapture, pDevice->wasapi.mappedBufferCaptureCap - pDevice->wasapi.mappedBufferCaptureLen, pDevice->capture.internalFormat, pDevice->capture.internalChannels),
+                framesToProcessNow,
+                pDevice->capture.internalFormat, pDevice->capture.internalChannels
+            );
+
+            totalFramesProcessed                   += framesToProcessNow;
+            pDevice->wasapi.mappedBufferCaptureLen -= framesToProcessNow;
+
+            /* If the data buffer has been fully consumed we need to release it. */
+            if (pDevice->wasapi.mappedBufferCaptureLen == 0) {
+                ma_IAudioCaptureClient_ReleaseBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, pDevice->wasapi.mappedBufferCaptureCap);
+                pDevice->wasapi.pMappedBufferCapture   = NULL;
+                pDevice->wasapi.mappedBufferCaptureCap = 0;
+            }
+        } else {
+            /* We don't have any cached data pointer, so grab another one. */
+            HRESULT hr;
+            DWORD flags = 0;
+
+            /* First just ask WASAPI for a data buffer. If it's not available, we'll wait for more. */
+            hr = ma_IAudioCaptureClient_GetBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, (BYTE**)&pDevice->wasapi.pMappedBufferCapture, &pDevice->wasapi.mappedBufferCaptureCap, &flags, NULL, NULL);
+            if (hr == S_OK) {
+                /* We got a data buffer. Continue to the next loop iteration which will then read from the mapped pointer. */
+                pDevice->wasapi.mappedBufferCaptureLen = pDevice->wasapi.mappedBufferCaptureCap;
+
+                /*
+                There have been reports that indicate that at times the AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY is reported for every
+                call to IAudioCaptureClient_GetBuffer() above which results in spamming of the debug messages below. To partially
+                work around this, I'm only outputting these messages when MA_DEBUG_OUTPUT is explicitly defined. The better solution
+                would be to figure out why the flag is always getting reported.
+                */
+                #if defined(MA_DEBUG_OUTPUT)
+                {
+                    if (flags != 0) {
+                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Capture Flags: %ld\n", flags);
+
+                        if ((flags & MA_AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY) != 0) {
+                            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Data discontinuity (possible overrun). Attempting recovery. mappedBufferCaptureCap=%d\n", pDevice->wasapi.mappedBufferCaptureCap);
+                        }
+                    }
+                }
+                #endif
+
+                /* Overrun detection. */
+                if ((flags & MA_AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY) != 0) {
+                    /* Glitched. Probably due to an overrun. */
+
+                    /*
+                    If we got an overrun it probably means we're straddling the end of the buffer. In normal capture
+                    mode this is the fault of the client application because they're responsible for ensuring data is
+                    processed fast enough. In duplex mode, however, the processing of audio is tied to the playback
+                    device, so this can possibly be the result of a timing de-sync.
+
+                    In capture mode we're not going to do any kind of recovery because the real fix is for the client
+                    application to process faster. In duplex mode, we'll treat this as a desync and reset the buffers
+                    to prevent a never-ending sequence of glitches due to straddling the end of the buffer.
+                    */
+                    if (pDevice->type == ma_device_type_duplex) {
+                        /*
+                        Experiment:
+
+                        If we empty out the *entire* buffer we may end up putting ourselves into an underrun position
+                        which isn't really any better than the overrun we're probably in right now. Instead we'll just
+                        empty out about half.
+                        */
+                        ma_uint32 i;
+                        ma_uint32 periodCount = (pDevice->wasapi.actualBufferSizeInFramesCapture / pDevice->wasapi.periodSizeInFramesCapture);
+                        ma_uint32 iterationCount = periodCount / 2;
+                        if ((periodCount % 2) > 0) {
+                            iterationCount += 1;
+                        }
+
+                        for (i = 0; i < iterationCount; i += 1) {
+                            hr = ma_IAudioCaptureClient_ReleaseBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, pDevice->wasapi.mappedBufferCaptureCap);
+                            if (FAILED(hr)) {
+                                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Data discontinuity recovery: IAudioCaptureClient_ReleaseBuffer() failed with %ld.\n", hr);
+                                break;
+                            }
+
+                            flags = 0;
+                            hr = ma_IAudioCaptureClient_GetBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, (BYTE**)&pDevice->wasapi.pMappedBufferCapture, &pDevice->wasapi.mappedBufferCaptureCap, &flags, NULL, NULL);
+                            if (hr == MA_AUDCLNT_S_BUFFER_EMPTY || FAILED(hr)) {
+                                /*
+                                The buffer has been completely emptied or an error occurred. In this case we'll need
+                                to reset the state of the mapped buffer which will trigger the next iteration to get
+                                a fresh buffer from WASAPI.
+                                */
+                                pDevice->wasapi.pMappedBufferCapture   = NULL;
+                                pDevice->wasapi.mappedBufferCaptureCap = 0;
+                                pDevice->wasapi.mappedBufferCaptureLen = 0;
+
+                                if (hr == MA_AUDCLNT_S_BUFFER_EMPTY) {
+                                    if ((flags & MA_AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY) != 0) {
+                                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Data discontinuity recovery: Buffer emptied, and data discontinuity still reported.\n");
+                                    } else {
+                                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Data discontinuity recovery: Buffer emptied.\n");
+                                    }
+                                }
+
+                                if (FAILED(hr)) {
+                                    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[WASAPI] Data discontinuity recovery: IAudioCaptureClient_GetBuffer() failed with %ld.\n", hr);
+                                }
+
+                                break;
+                            }
+                        }
+
+                        /* If at this point we have a valid buffer mapped, make sure the buffer length is set appropriately. */
+                        if (pDevice->wasapi.pMappedBufferCapture != NULL) {
+                            pDevice->wasapi.mappedBufferCaptureLen = pDevice->wasapi.mappedBufferCaptureCap;
+                        }
+                    }
+                }
+
+                continue;
+            } else {
+                if (hr == MA_AUDCLNT_S_BUFFER_EMPTY || hr == MA_AUDCLNT_E_BUFFER_ERROR) {
+                    /*
+                    No data is available. We need to wait for more. There's two situations to consider
+                    here. The first is normal capture mode. If this times out it probably means the
+                    microphone isn't delivering data for whatever reason. In this case we'll just
+                    abort the read and return whatever we were able to get. The other situations is
+                    loopback mode, in which case a timeout probably just means the nothing is playing
+                    through the speakers.
+                    */
+
+                    /* Experiment: Use a shorter timeout for loopback mode. */
+                    DWORD timeoutInMilliseconds = MA_WASAPI_WAIT_TIMEOUT_MILLISECONDS;
+                    if (pDevice->type == ma_device_type_loopback) {
+                        timeoutInMilliseconds = 10;
+                    }
+
+                    if (WaitForSingleObject((HANDLE)pDevice->wasapi.hEventCapture, timeoutInMilliseconds) != WAIT_OBJECT_0) {
+                        if (pDevice->type == ma_device_type_loopback) {
+                            continue;   /* Keep waiting in loopback mode. */
+                        } else {
+                            result = MA_ERROR;
+                            break;      /* Wait failed. */
+                        }
+                    }
+
+                    /* At this point we should be able to loop back to the start of the loop and try retrieving a data buffer again. */
+                } else {
+                    /* An error occurred and we need to abort. */
+                    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to retrieve internal buffer from capture device in preparation for reading from the device. HRESULT = %d. Stopping device.\n", (int)hr);
+                    result = ma_result_from_HRESULT(hr);
+                    break;
+                }
+            }
+        }
+    }
+
+    /*
+    If we were unable to process the entire requested frame count, but we still have a mapped buffer,
+    there's a good chance either an error occurred or the device was stopped mid-read. In this case
+    we'll need to make sure the buffer is released.
+    */
+    if (totalFramesProcessed < frameCount && pDevice->wasapi.pMappedBufferCapture != NULL) {
+        ma_IAudioCaptureClient_ReleaseBuffer((ma_IAudioCaptureClient*)pDevice->wasapi.pCaptureClient, pDevice->wasapi.mappedBufferCaptureCap);
+        pDevice->wasapi.pMappedBufferCapture   = NULL;
+        pDevice->wasapi.mappedBufferCaptureCap = 0;
+        pDevice->wasapi.mappedBufferCaptureLen = 0;
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesProcessed;
+    }
+
+    return result;
+}
+
+static ma_result ma_device_write__wasapi(ma_device* pDevice, const void* pFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 totalFramesProcessed = 0;
+
+    /* Keep writing to the device until it's stopped or we've consumed all of our input. */
+    while (ma_device_get_state(pDevice) == ma_device_state_started && totalFramesProcessed < frameCount) {
+        ma_uint32 framesRemaining = frameCount - totalFramesProcessed;
+
+        /*
+        We're going to do this in a similar way to capture. We'll first check if the cached data pointer
+        is valid, and if so, read from that. Otherwise We will call IAudioRenderClient_GetBuffer() with
+        a requested buffer size equal to our actual period size. If it returns AUDCLNT_E_BUFFER_TOO_LARGE
+        it means we need to wait for some data to become available.
+        */
+        if (pDevice->wasapi.pMappedBufferPlayback != NULL) {
+            /* We still have some space available in the mapped data buffer. Write to it. */
+            ma_uint32 framesToProcessNow = framesRemaining;
+            if (framesToProcessNow > (pDevice->wasapi.mappedBufferPlaybackCap - pDevice->wasapi.mappedBufferPlaybackLen)) {
+                framesToProcessNow = (pDevice->wasapi.mappedBufferPlaybackCap - pDevice->wasapi.mappedBufferPlaybackLen);
+            }
+
+            /* Now just copy the data over to the output buffer. */
+            ma_copy_pcm_frames(
+                ma_offset_pcm_frames_ptr(pDevice->wasapi.pMappedBufferPlayback, pDevice->wasapi.mappedBufferPlaybackLen, pDevice->playback.internalFormat, pDevice->playback.internalChannels),
+                ma_offset_pcm_frames_const_ptr(pFrames, totalFramesProcessed, pDevice->playback.internalFormat, pDevice->playback.internalChannels),
+                framesToProcessNow,
+                pDevice->playback.internalFormat, pDevice->playback.internalChannels
+            );
+
+            totalFramesProcessed                    += framesToProcessNow;
+            pDevice->wasapi.mappedBufferPlaybackLen += framesToProcessNow;
+
+            /* If the data buffer has been fully consumed we need to release it. */
+            if (pDevice->wasapi.mappedBufferPlaybackLen == pDevice->wasapi.mappedBufferPlaybackCap) {
+                ma_IAudioRenderClient_ReleaseBuffer((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient, pDevice->wasapi.mappedBufferPlaybackCap, 0);
+                pDevice->wasapi.pMappedBufferPlayback   = NULL;
+                pDevice->wasapi.mappedBufferPlaybackCap = 0;
+                pDevice->wasapi.mappedBufferPlaybackLen = 0;
+
+                /*
+                In exclusive mode we need to wait here. Exclusive mode is weird because GetBuffer() never
+                seems to return AUDCLNT_E_BUFFER_TOO_LARGE, which is what we normally use to determine
+                whether or not we need to wait for more data.
+                */
+                if (pDevice->playback.shareMode == ma_share_mode_exclusive) {
+                    if (WaitForSingleObject((HANDLE)pDevice->wasapi.hEventPlayback, MA_WASAPI_WAIT_TIMEOUT_MILLISECONDS) != WAIT_OBJECT_0) {
+                        result = MA_ERROR;
+                        break;   /* Wait failed. Probably timed out. */
+                    }
+                }
+            }
+        } else {
+            /* We don't have a mapped data buffer so we'll need to get one. */
+            HRESULT hr;
+            ma_uint32 bufferSizeInFrames;
+
+            /* Special rules for exclusive mode. */
+            if (pDevice->playback.shareMode == ma_share_mode_exclusive) {
+                bufferSizeInFrames = pDevice->wasapi.actualBufferSizeInFramesPlayback;
+            } else {
+                bufferSizeInFrames = pDevice->wasapi.periodSizeInFramesPlayback;
+            }
+
+            hr = ma_IAudioRenderClient_GetBuffer((ma_IAudioRenderClient*)pDevice->wasapi.pRenderClient, bufferSizeInFrames, (BYTE**)&pDevice->wasapi.pMappedBufferPlayback);
+            if (hr == S_OK) {
+                /* We have data available. */
+                pDevice->wasapi.mappedBufferPlaybackCap = bufferSizeInFrames;
+                pDevice->wasapi.mappedBufferPlaybackLen = 0;
+            } else {
+                if (hr == MA_AUDCLNT_E_BUFFER_TOO_LARGE || hr == MA_AUDCLNT_E_BUFFER_ERROR) {
+                    /* Not enough data available. We need to wait for more. */
+                    if (WaitForSingleObject((HANDLE)pDevice->wasapi.hEventPlayback, MA_WASAPI_WAIT_TIMEOUT_MILLISECONDS) != WAIT_OBJECT_0) {
+                        result = MA_ERROR;
+                        break;   /* Wait failed. Probably timed out. */
+                    }
+                } else {
+                    /* Some error occurred. We'll need to abort. */
+                    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WASAPI] Failed to retrieve internal buffer from playback device in preparation for writing to the device. HRESULT = %d. Stopping device.\n", (int)hr);
+                    result = ma_result_from_HRESULT(hr);
+                    break;
+                }
+            }
+        }
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = totalFramesProcessed;
+    }
+
+    return result;
+}
+
+static ma_result ma_device_data_loop_wakeup__wasapi(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+        SetEvent((HANDLE)pDevice->wasapi.hEventCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        SetEvent((HANDLE)pDevice->wasapi.hEventPlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_uninit__wasapi(ma_context* pContext)
+{
+    ma_context_command__wasapi cmd = ma_context_init_command__wasapi(MA_CONTEXT_COMMAND_QUIT__WASAPI);
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_wasapi);
+
+    ma_context_post_command__wasapi(pContext, &cmd);
+    ma_thread_wait(&pContext->wasapi.commandThread);
+
+    if (pContext->wasapi.hAvrt) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->wasapi.hAvrt);
+        pContext->wasapi.hAvrt = NULL;
+    }
+
+    #if defined(MA_WIN32_UWP)
+    {
+        if (pContext->wasapi.hMMDevapi) {
+            ma_dlclose(ma_context_get_log(pContext), pContext->wasapi.hMMDevapi);
+            pContext->wasapi.hMMDevapi = NULL;
+        }
+    }
+    #endif
+
+    /* Only after the thread has been terminated can we uninitialize the sync objects for the command thread. */
+    ma_semaphore_uninit(&pContext->wasapi.commandSem);
+    ma_mutex_uninit(&pContext->wasapi.commandLock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__wasapi(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    ma_result result = MA_SUCCESS;
+
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+#ifdef MA_WIN32_DESKTOP
+    /*
+    WASAPI is only supported in Vista SP1 and newer. The reason for SP1 and not the base version of Vista is that event-driven
+    exclusive mode does not work until SP1.
+
+    Unfortunately older compilers don't define these functions so we need to dynamically load them in order to avoid a link error.
+    */
+    {
+        ma_OSVERSIONINFOEXW osvi;
+        ma_handle kernel32DLL;
+        ma_PFNVerifyVersionInfoW _VerifyVersionInfoW;
+        ma_PFNVerSetConditionMask _VerSetConditionMask;
+
+        kernel32DLL = ma_dlopen(ma_context_get_log(pContext), "kernel32.dll");
+        if (kernel32DLL == NULL) {
+            return MA_NO_BACKEND;
+        }
+
+        _VerifyVersionInfoW  = (ma_PFNVerifyVersionInfoW )ma_dlsym(ma_context_get_log(pContext), kernel32DLL, "VerifyVersionInfoW");
+        _VerSetConditionMask = (ma_PFNVerSetConditionMask)ma_dlsym(ma_context_get_log(pContext), kernel32DLL, "VerSetConditionMask");
+        if (_VerifyVersionInfoW == NULL || _VerSetConditionMask == NULL) {
+            ma_dlclose(ma_context_get_log(pContext), kernel32DLL);
+            return MA_NO_BACKEND;
+        }
+
+        MA_ZERO_OBJECT(&osvi);
+        osvi.dwOSVersionInfoSize = sizeof(osvi);
+        osvi.dwMajorVersion = ((MA_WIN32_WINNT_VISTA >> 8) & 0xFF);
+        osvi.dwMinorVersion = ((MA_WIN32_WINNT_VISTA >> 0) & 0xFF);
+        osvi.wServicePackMajor = 1;
+        if (_VerifyVersionInfoW(&osvi, MA_VER_MAJORVERSION | MA_VER_MINORVERSION | MA_VER_SERVICEPACKMAJOR, _VerSetConditionMask(_VerSetConditionMask(_VerSetConditionMask(0, MA_VER_MAJORVERSION, MA_VER_GREATER_EQUAL), MA_VER_MINORVERSION, MA_VER_GREATER_EQUAL), MA_VER_SERVICEPACKMAJOR, MA_VER_GREATER_EQUAL))) {
+            result = MA_SUCCESS;
+        } else {
+            result = MA_NO_BACKEND;
+        }
+
+        ma_dlclose(ma_context_get_log(pContext), kernel32DLL);
+    }
+#endif
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    MA_ZERO_OBJECT(&pContext->wasapi);
+
+
+    #if defined(MA_WIN32_UWP)
+    {
+        /* Link to mmdevapi so we can get access to ActivateAudioInterfaceAsync(). */
+        pContext->wasapi.hMMDevapi = ma_dlopen(ma_context_get_log(pContext), "mmdevapi.dll");
+        if (pContext->wasapi.hMMDevapi) {
+            pContext->wasapi.ActivateAudioInterfaceAsync = ma_dlsym(ma_context_get_log(pContext), pContext->wasapi.hMMDevapi, "ActivateAudioInterfaceAsync");
+            if (pContext->wasapi.ActivateAudioInterfaceAsync == NULL) {
+                ma_dlclose(ma_context_get_log(pContext), pContext->wasapi.hMMDevapi);
+                return MA_NO_BACKEND;   /* ActivateAudioInterfaceAsync() could not be loaded. */
+            }
+        } else {
+            return MA_NO_BACKEND;   /* Failed to load mmdevapi.dll which is required for ActivateAudioInterfaceAsync() */
+        }
+    }
+    #endif
+
+    /* Optionally use the Avrt API to specify the audio thread's latency sensitivity requirements */
+    pContext->wasapi.hAvrt = ma_dlopen(ma_context_get_log(pContext), "avrt.dll");
+    if (pContext->wasapi.hAvrt) {
+        pContext->wasapi.AvSetMmThreadCharacteristicsA   = ma_dlsym(ma_context_get_log(pContext), pContext->wasapi.hAvrt, "AvSetMmThreadCharacteristicsA");
+        pContext->wasapi.AvRevertMmThreadcharacteristics = ma_dlsym(ma_context_get_log(pContext), pContext->wasapi.hAvrt, "AvRevertMmThreadCharacteristics");
+
+        /* If either function could not be found, disable use of avrt entirely. */
+        if (!pContext->wasapi.AvSetMmThreadCharacteristicsA || !pContext->wasapi.AvRevertMmThreadcharacteristics) {
+            pContext->wasapi.AvSetMmThreadCharacteristicsA   = NULL;
+            pContext->wasapi.AvRevertMmThreadcharacteristics = NULL;
+            ma_dlclose(ma_context_get_log(pContext), pContext->wasapi.hAvrt);
+            pContext->wasapi.hAvrt = NULL;
+        }
+    }
+
+
+    /*
+    Annoyingly, WASAPI does not allow you to release an IAudioClient object from a different thread
+    than the one that retrieved it with GetService(). This can result in a deadlock in two
+    situations:
+
+        1) When calling ma_device_uninit() from a different thread to ma_device_init(); and
+        2) When uninitializing and reinitializing the internal IAudioClient object in response to
+           automatic stream routing.
+
+    We could define ma_device_uninit() such that it must be called on the same thread as
+    ma_device_init(). We could also just not release the IAudioClient when performing automatic
+    stream routing to avoid the deadlock. Neither of these are acceptable solutions in my view so
+    we're going to have to work around this with a worker thread. This is not ideal, but I can't
+    think of a better way to do this.
+
+    More information about this can be found here:
+
+        https://docs.microsoft.com/en-us/windows/win32/api/audioclient/nn-audioclient-iaudiorenderclient
+
+    Note this section:
+
+        When releasing an IAudioRenderClient interface instance, the client must call the interface's
+        Release method from the same thread as the call to IAudioClient::GetService that created the
+        object.
+    */
+    {
+        result = ma_mutex_init(&pContext->wasapi.commandLock);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_semaphore_init(0, &pContext->wasapi.commandSem);
+        if (result != MA_SUCCESS) {
+            ma_mutex_uninit(&pContext->wasapi.commandLock);
+            return result;
+        }
+
+        result = ma_thread_create(&pContext->wasapi.commandThread, ma_thread_priority_normal, 0, ma_context_command_thread__wasapi, pContext, &pContext->allocationCallbacks);
+        if (result != MA_SUCCESS) {
+            ma_semaphore_uninit(&pContext->wasapi.commandSem);
+            ma_mutex_uninit(&pContext->wasapi.commandLock);
+            return result;
+        }
+    }
+
+
+    pCallbacks->onContextInit             = ma_context_init__wasapi;
+    pCallbacks->onContextUninit           = ma_context_uninit__wasapi;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__wasapi;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__wasapi;
+    pCallbacks->onDeviceInit              = ma_device_init__wasapi;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__wasapi;
+    pCallbacks->onDeviceStart             = ma_device_start__wasapi;
+    pCallbacks->onDeviceStop              = ma_device_stop__wasapi;
+    pCallbacks->onDeviceRead              = ma_device_read__wasapi;
+    pCallbacks->onDeviceWrite             = ma_device_write__wasapi;
+    pCallbacks->onDeviceDataLoop          = NULL;
+    pCallbacks->onDeviceDataLoopWakeup    = ma_device_data_loop_wakeup__wasapi;
+
+    return MA_SUCCESS;
+}
+#endif
+
+/******************************************************************************
+
+DirectSound Backend
+
+******************************************************************************/
+#ifdef MA_HAS_DSOUND
+/*#include <dsound.h>*/
+
+/*static const GUID MA_GUID_IID_DirectSoundNotify = {0xb0210783, 0x89cd, 0x11d0, {0xaf, 0x08, 0x00, 0xa0, 0xc9, 0x25, 0xcd, 0x16}};*/
+
+/* miniaudio only uses priority or exclusive modes. */
+#define MA_DSSCL_NORMAL                 1
+#define MA_DSSCL_PRIORITY               2
+#define MA_DSSCL_EXCLUSIVE              3
+#define MA_DSSCL_WRITEPRIMARY           4
+
+#define MA_DSCAPS_PRIMARYMONO           0x00000001
+#define MA_DSCAPS_PRIMARYSTEREO         0x00000002
+#define MA_DSCAPS_PRIMARY8BIT           0x00000004
+#define MA_DSCAPS_PRIMARY16BIT          0x00000008
+#define MA_DSCAPS_CONTINUOUSRATE        0x00000010
+#define MA_DSCAPS_EMULDRIVER            0x00000020
+#define MA_DSCAPS_CERTIFIED             0x00000040
+#define MA_DSCAPS_SECONDARYMONO         0x00000100
+#define MA_DSCAPS_SECONDARYSTEREO       0x00000200
+#define MA_DSCAPS_SECONDARY8BIT         0x00000400
+#define MA_DSCAPS_SECONDARY16BIT        0x00000800
+
+#define MA_DSBCAPS_PRIMARYBUFFER        0x00000001
+#define MA_DSBCAPS_STATIC               0x00000002
+#define MA_DSBCAPS_LOCHARDWARE          0x00000004
+#define MA_DSBCAPS_LOCSOFTWARE          0x00000008
+#define MA_DSBCAPS_CTRL3D               0x00000010
+#define MA_DSBCAPS_CTRLFREQUENCY        0x00000020
+#define MA_DSBCAPS_CTRLPAN              0x00000040
+#define MA_DSBCAPS_CTRLVOLUME           0x00000080
+#define MA_DSBCAPS_CTRLPOSITIONNOTIFY   0x00000100
+#define MA_DSBCAPS_CTRLFX               0x00000200
+#define MA_DSBCAPS_STICKYFOCUS          0x00004000
+#define MA_DSBCAPS_GLOBALFOCUS          0x00008000
+#define MA_DSBCAPS_GETCURRENTPOSITION2  0x00010000
+#define MA_DSBCAPS_MUTE3DATMAXDISTANCE  0x00020000
+#define MA_DSBCAPS_LOCDEFER             0x00040000
+#define MA_DSBCAPS_TRUEPLAYPOSITION     0x00080000
+
+#define MA_DSBPLAY_LOOPING              0x00000001
+#define MA_DSBPLAY_LOCHARDWARE          0x00000002
+#define MA_DSBPLAY_LOCSOFTWARE          0x00000004
+#define MA_DSBPLAY_TERMINATEBY_TIME     0x00000008
+#define MA_DSBPLAY_TERMINATEBY_DISTANCE 0x00000010
+#define MA_DSBPLAY_TERMINATEBY_PRIORITY 0x00000020
+
+#define MA_DSCBSTART_LOOPING            0x00000001
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwBufferBytes;
+    DWORD dwReserved;
+    MA_WAVEFORMATEX* lpwfxFormat;
+    GUID guid3DAlgorithm;
+} MA_DSBUFFERDESC;
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwBufferBytes;
+    DWORD dwReserved;
+    MA_WAVEFORMATEX* lpwfxFormat;
+    DWORD dwFXCount;
+    void* lpDSCFXDesc;  /* <-- miniaudio doesn't use this, so set to void*. */
+} MA_DSCBUFFERDESC;
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwMinSecondarySampleRate;
+    DWORD dwMaxSecondarySampleRate;
+    DWORD dwPrimaryBuffers;
+    DWORD dwMaxHwMixingAllBuffers;
+    DWORD dwMaxHwMixingStaticBuffers;
+    DWORD dwMaxHwMixingStreamingBuffers;
+    DWORD dwFreeHwMixingAllBuffers;
+    DWORD dwFreeHwMixingStaticBuffers;
+    DWORD dwFreeHwMixingStreamingBuffers;
+    DWORD dwMaxHw3DAllBuffers;
+    DWORD dwMaxHw3DStaticBuffers;
+    DWORD dwMaxHw3DStreamingBuffers;
+    DWORD dwFreeHw3DAllBuffers;
+    DWORD dwFreeHw3DStaticBuffers;
+    DWORD dwFreeHw3DStreamingBuffers;
+    DWORD dwTotalHwMemBytes;
+    DWORD dwFreeHwMemBytes;
+    DWORD dwMaxContigFreeHwMemBytes;
+    DWORD dwUnlockTransferRateHwBuffers;
+    DWORD dwPlayCpuOverheadSwBuffers;
+    DWORD dwReserved1;
+    DWORD dwReserved2;
+} MA_DSCAPS;
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwBufferBytes;
+    DWORD dwUnlockTransferRate;
+    DWORD dwPlayCpuOverhead;
+} MA_DSBCAPS;
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwFormats;
+    DWORD dwChannels;
+} MA_DSCCAPS;
+
+typedef struct
+{
+    DWORD dwSize;
+    DWORD dwFlags;
+    DWORD dwBufferBytes;
+    DWORD dwReserved;
+} MA_DSCBCAPS;
+
+typedef struct
+{
+    DWORD  dwOffset;
+    HANDLE hEventNotify;
+} MA_DSBPOSITIONNOTIFY;
+
+typedef struct ma_IDirectSound              ma_IDirectSound;
+typedef struct ma_IDirectSoundBuffer        ma_IDirectSoundBuffer;
+typedef struct ma_IDirectSoundCapture       ma_IDirectSoundCapture;
+typedef struct ma_IDirectSoundCaptureBuffer ma_IDirectSoundCaptureBuffer;
+typedef struct ma_IDirectSoundNotify        ma_IDirectSoundNotify;
+
+
+/*
+COM objects. The way these work is that you have a vtable (a list of function pointers, kind of
+like how C++ works internally), and then you have a structure with a single member, which is a
+pointer to the vtable. The vtable is where the methods of the object are defined. Methods need
+to be in a specific order, and parent classes need to have their methods declared first.
+*/
+
+/* IDirectSound */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IDirectSound* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IDirectSound* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IDirectSound* pThis);
+
+    /* IDirectSound */
+    HRESULT (STDMETHODCALLTYPE * CreateSoundBuffer)   (ma_IDirectSound* pThis, const MA_DSBUFFERDESC* pDSBufferDesc, ma_IDirectSoundBuffer** ppDSBuffer, void* pUnkOuter);
+    HRESULT (STDMETHODCALLTYPE * GetCaps)             (ma_IDirectSound* pThis, MA_DSCAPS* pDSCaps);
+    HRESULT (STDMETHODCALLTYPE * DuplicateSoundBuffer)(ma_IDirectSound* pThis, ma_IDirectSoundBuffer* pDSBufferOriginal, ma_IDirectSoundBuffer** ppDSBufferDuplicate);
+    HRESULT (STDMETHODCALLTYPE * SetCooperativeLevel) (ma_IDirectSound* pThis, HWND hwnd, DWORD dwLevel);
+    HRESULT (STDMETHODCALLTYPE * Compact)             (ma_IDirectSound* pThis);
+    HRESULT (STDMETHODCALLTYPE * GetSpeakerConfig)    (ma_IDirectSound* pThis, DWORD* pSpeakerConfig);
+    HRESULT (STDMETHODCALLTYPE * SetSpeakerConfig)    (ma_IDirectSound* pThis, DWORD dwSpeakerConfig);
+    HRESULT (STDMETHODCALLTYPE * Initialize)          (ma_IDirectSound* pThis, const GUID* pGuidDevice);
+} ma_IDirectSoundVtbl;
+struct ma_IDirectSound
+{
+    ma_IDirectSoundVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IDirectSound_QueryInterface(ma_IDirectSound* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IDirectSound_AddRef(ma_IDirectSound* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IDirectSound_Release(ma_IDirectSound* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IDirectSound_CreateSoundBuffer(ma_IDirectSound* pThis, const MA_DSBUFFERDESC* pDSBufferDesc, ma_IDirectSoundBuffer** ppDSBuffer, void* pUnkOuter) { return pThis->lpVtbl->CreateSoundBuffer(pThis, pDSBufferDesc, ppDSBuffer, pUnkOuter); }
+static MA_INLINE HRESULT ma_IDirectSound_GetCaps(ma_IDirectSound* pThis, MA_DSCAPS* pDSCaps)                            { return pThis->lpVtbl->GetCaps(pThis, pDSCaps); }
+static MA_INLINE HRESULT ma_IDirectSound_DuplicateSoundBuffer(ma_IDirectSound* pThis, ma_IDirectSoundBuffer* pDSBufferOriginal, ma_IDirectSoundBuffer** ppDSBufferDuplicate) { return pThis->lpVtbl->DuplicateSoundBuffer(pThis, pDSBufferOriginal, ppDSBufferDuplicate); }
+static MA_INLINE HRESULT ma_IDirectSound_SetCooperativeLevel(ma_IDirectSound* pThis, HWND hwnd, DWORD dwLevel)          { return pThis->lpVtbl->SetCooperativeLevel(pThis, hwnd, dwLevel); }
+static MA_INLINE HRESULT ma_IDirectSound_Compact(ma_IDirectSound* pThis)                                                { return pThis->lpVtbl->Compact(pThis); }
+static MA_INLINE HRESULT ma_IDirectSound_GetSpeakerConfig(ma_IDirectSound* pThis, DWORD* pSpeakerConfig)                { return pThis->lpVtbl->GetSpeakerConfig(pThis, pSpeakerConfig); }
+static MA_INLINE HRESULT ma_IDirectSound_SetSpeakerConfig(ma_IDirectSound* pThis, DWORD dwSpeakerConfig)                { return pThis->lpVtbl->SetSpeakerConfig(pThis, dwSpeakerConfig); }
+static MA_INLINE HRESULT ma_IDirectSound_Initialize(ma_IDirectSound* pThis, const GUID* pGuidDevice)                    { return pThis->lpVtbl->Initialize(pThis, pGuidDevice); }
+
+
+/* IDirectSoundBuffer */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IDirectSoundBuffer* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IDirectSoundBuffer* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IDirectSoundBuffer* pThis);
+
+    /* IDirectSoundBuffer */
+    HRESULT (STDMETHODCALLTYPE * GetCaps)           (ma_IDirectSoundBuffer* pThis, MA_DSBCAPS* pDSBufferCaps);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentPosition)(ma_IDirectSoundBuffer* pThis, DWORD* pCurrentPlayCursor, DWORD* pCurrentWriteCursor);
+    HRESULT (STDMETHODCALLTYPE * GetFormat)         (ma_IDirectSoundBuffer* pThis, MA_WAVEFORMATEX* pFormat, DWORD dwSizeAllocated, DWORD* pSizeWritten);
+    HRESULT (STDMETHODCALLTYPE * GetVolume)         (ma_IDirectSoundBuffer* pThis, LONG* pVolume);
+    HRESULT (STDMETHODCALLTYPE * GetPan)            (ma_IDirectSoundBuffer* pThis, LONG* pPan);
+    HRESULT (STDMETHODCALLTYPE * GetFrequency)      (ma_IDirectSoundBuffer* pThis, DWORD* pFrequency);
+    HRESULT (STDMETHODCALLTYPE * GetStatus)         (ma_IDirectSoundBuffer* pThis, DWORD* pStatus);
+    HRESULT (STDMETHODCALLTYPE * Initialize)        (ma_IDirectSoundBuffer* pThis, ma_IDirectSound* pDirectSound, const MA_DSBUFFERDESC* pDSBufferDesc);
+    HRESULT (STDMETHODCALLTYPE * Lock)              (ma_IDirectSoundBuffer* pThis, DWORD dwOffset, DWORD dwBytes, void** ppAudioPtr1, DWORD* pAudioBytes1, void** ppAudioPtr2, DWORD* pAudioBytes2, DWORD dwFlags);
+    HRESULT (STDMETHODCALLTYPE * Play)              (ma_IDirectSoundBuffer* pThis, DWORD dwReserved1, DWORD dwPriority, DWORD dwFlags);
+    HRESULT (STDMETHODCALLTYPE * SetCurrentPosition)(ma_IDirectSoundBuffer* pThis, DWORD dwNewPosition);
+    HRESULT (STDMETHODCALLTYPE * SetFormat)         (ma_IDirectSoundBuffer* pThis, const MA_WAVEFORMATEX* pFormat);
+    HRESULT (STDMETHODCALLTYPE * SetVolume)         (ma_IDirectSoundBuffer* pThis, LONG volume);
+    HRESULT (STDMETHODCALLTYPE * SetPan)            (ma_IDirectSoundBuffer* pThis, LONG pan);
+    HRESULT (STDMETHODCALLTYPE * SetFrequency)      (ma_IDirectSoundBuffer* pThis, DWORD dwFrequency);
+    HRESULT (STDMETHODCALLTYPE * Stop)              (ma_IDirectSoundBuffer* pThis);
+    HRESULT (STDMETHODCALLTYPE * Unlock)            (ma_IDirectSoundBuffer* pThis, void* pAudioPtr1, DWORD dwAudioBytes1, void* pAudioPtr2, DWORD dwAudioBytes2);
+    HRESULT (STDMETHODCALLTYPE * Restore)           (ma_IDirectSoundBuffer* pThis);
+} ma_IDirectSoundBufferVtbl;
+struct ma_IDirectSoundBuffer
+{
+    ma_IDirectSoundBufferVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_QueryInterface(ma_IDirectSoundBuffer* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IDirectSoundBuffer_AddRef(ma_IDirectSoundBuffer* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IDirectSoundBuffer_Release(ma_IDirectSoundBuffer* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetCaps(ma_IDirectSoundBuffer* pThis, MA_DSBCAPS* pDSBufferCaps)                     { return pThis->lpVtbl->GetCaps(pThis, pDSBufferCaps); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetCurrentPosition(ma_IDirectSoundBuffer* pThis, DWORD* pCurrentPlayCursor, DWORD* pCurrentWriteCursor) { return pThis->lpVtbl->GetCurrentPosition(pThis, pCurrentPlayCursor, pCurrentWriteCursor); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetFormat(ma_IDirectSoundBuffer* pThis, MA_WAVEFORMATEX* pFormat, DWORD dwSizeAllocated, DWORD* pSizeWritten) { return pThis->lpVtbl->GetFormat(pThis, pFormat, dwSizeAllocated, pSizeWritten); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetVolume(ma_IDirectSoundBuffer* pThis, LONG* pVolume)                               { return pThis->lpVtbl->GetVolume(pThis, pVolume); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetPan(ma_IDirectSoundBuffer* pThis, LONG* pPan)                                     { return pThis->lpVtbl->GetPan(pThis, pPan); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetFrequency(ma_IDirectSoundBuffer* pThis, DWORD* pFrequency)                        { return pThis->lpVtbl->GetFrequency(pThis, pFrequency); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_GetStatus(ma_IDirectSoundBuffer* pThis, DWORD* pStatus)                              { return pThis->lpVtbl->GetStatus(pThis, pStatus); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Initialize(ma_IDirectSoundBuffer* pThis, ma_IDirectSound* pDirectSound, const MA_DSBUFFERDESC* pDSBufferDesc) { return pThis->lpVtbl->Initialize(pThis, pDirectSound, pDSBufferDesc); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Lock(ma_IDirectSoundBuffer* pThis, DWORD dwOffset, DWORD dwBytes, void** ppAudioPtr1, DWORD* pAudioBytes1, void** ppAudioPtr2, DWORD* pAudioBytes2, DWORD dwFlags) { return pThis->lpVtbl->Lock(pThis, dwOffset, dwBytes, ppAudioPtr1, pAudioBytes1, ppAudioPtr2, pAudioBytes2, dwFlags); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Play(ma_IDirectSoundBuffer* pThis, DWORD dwReserved1, DWORD dwPriority, DWORD dwFlags) { return pThis->lpVtbl->Play(pThis, dwReserved1, dwPriority, dwFlags); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_SetCurrentPosition(ma_IDirectSoundBuffer* pThis, DWORD dwNewPosition)                { return pThis->lpVtbl->SetCurrentPosition(pThis, dwNewPosition); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_SetFormat(ma_IDirectSoundBuffer* pThis, const MA_WAVEFORMATEX* pFormat)              { return pThis->lpVtbl->SetFormat(pThis, pFormat); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_SetVolume(ma_IDirectSoundBuffer* pThis, LONG volume)                                 { return pThis->lpVtbl->SetVolume(pThis, volume); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_SetPan(ma_IDirectSoundBuffer* pThis, LONG pan)                                       { return pThis->lpVtbl->SetPan(pThis, pan); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_SetFrequency(ma_IDirectSoundBuffer* pThis, DWORD dwFrequency)                        { return pThis->lpVtbl->SetFrequency(pThis, dwFrequency); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Stop(ma_IDirectSoundBuffer* pThis)                                                   { return pThis->lpVtbl->Stop(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Unlock(ma_IDirectSoundBuffer* pThis, void* pAudioPtr1, DWORD dwAudioBytes1, void* pAudioPtr2, DWORD dwAudioBytes2) { return pThis->lpVtbl->Unlock(pThis, pAudioPtr1, dwAudioBytes1, pAudioPtr2, dwAudioBytes2); }
+static MA_INLINE HRESULT ma_IDirectSoundBuffer_Restore(ma_IDirectSoundBuffer* pThis)                                                { return pThis->lpVtbl->Restore(pThis); }
+
+
+/* IDirectSoundCapture */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IDirectSoundCapture* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IDirectSoundCapture* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IDirectSoundCapture* pThis);
+
+    /* IDirectSoundCapture */
+    HRESULT (STDMETHODCALLTYPE * CreateCaptureBuffer)(ma_IDirectSoundCapture* pThis, const MA_DSCBUFFERDESC* pDSCBufferDesc, ma_IDirectSoundCaptureBuffer** ppDSCBuffer, void* pUnkOuter);
+    HRESULT (STDMETHODCALLTYPE * GetCaps)            (ma_IDirectSoundCapture* pThis, MA_DSCCAPS* pDSCCaps);
+    HRESULT (STDMETHODCALLTYPE * Initialize)         (ma_IDirectSoundCapture* pThis, const GUID* pGuidDevice);
+} ma_IDirectSoundCaptureVtbl;
+struct ma_IDirectSoundCapture
+{
+    ma_IDirectSoundCaptureVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IDirectSoundCapture_QueryInterface     (ma_IDirectSoundCapture* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IDirectSoundCapture_AddRef             (ma_IDirectSoundCapture* pThis)                                    { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IDirectSoundCapture_Release            (ma_IDirectSoundCapture* pThis)                                    { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundCapture_CreateCaptureBuffer(ma_IDirectSoundCapture* pThis, const MA_DSCBUFFERDESC* pDSCBufferDesc, ma_IDirectSoundCaptureBuffer** ppDSCBuffer, void* pUnkOuter) { return pThis->lpVtbl->CreateCaptureBuffer(pThis, pDSCBufferDesc, ppDSCBuffer, pUnkOuter); }
+static MA_INLINE HRESULT ma_IDirectSoundCapture_GetCaps            (ma_IDirectSoundCapture* pThis, MA_DSCCAPS* pDSCCaps)              { return pThis->lpVtbl->GetCaps(pThis, pDSCCaps); }
+static MA_INLINE HRESULT ma_IDirectSoundCapture_Initialize         (ma_IDirectSoundCapture* pThis, const GUID* pGuidDevice)           { return pThis->lpVtbl->Initialize(pThis, pGuidDevice); }
+
+
+/* IDirectSoundCaptureBuffer */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IDirectSoundCaptureBuffer* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IDirectSoundCaptureBuffer* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IDirectSoundCaptureBuffer* pThis);
+
+    /* IDirectSoundCaptureBuffer */
+    HRESULT (STDMETHODCALLTYPE * GetCaps)           (ma_IDirectSoundCaptureBuffer* pThis, MA_DSCBCAPS* pDSCBCaps);
+    HRESULT (STDMETHODCALLTYPE * GetCurrentPosition)(ma_IDirectSoundCaptureBuffer* pThis, DWORD* pCapturePosition, DWORD* pReadPosition);
+    HRESULT (STDMETHODCALLTYPE * GetFormat)         (ma_IDirectSoundCaptureBuffer* pThis, MA_WAVEFORMATEX* pFormat, DWORD dwSizeAllocated, DWORD* pSizeWritten);
+    HRESULT (STDMETHODCALLTYPE * GetStatus)         (ma_IDirectSoundCaptureBuffer* pThis, DWORD* pStatus);
+    HRESULT (STDMETHODCALLTYPE * Initialize)        (ma_IDirectSoundCaptureBuffer* pThis, ma_IDirectSoundCapture* pDirectSoundCapture, const MA_DSCBUFFERDESC* pDSCBufferDesc);
+    HRESULT (STDMETHODCALLTYPE * Lock)              (ma_IDirectSoundCaptureBuffer* pThis, DWORD dwOffset, DWORD dwBytes, void** ppAudioPtr1, DWORD* pAudioBytes1, void** ppAudioPtr2, DWORD* pAudioBytes2, DWORD dwFlags);
+    HRESULT (STDMETHODCALLTYPE * Start)             (ma_IDirectSoundCaptureBuffer* pThis, DWORD dwFlags);
+    HRESULT (STDMETHODCALLTYPE * Stop)              (ma_IDirectSoundCaptureBuffer* pThis);
+    HRESULT (STDMETHODCALLTYPE * Unlock)            (ma_IDirectSoundCaptureBuffer* pThis, void* pAudioPtr1, DWORD dwAudioBytes1, void* pAudioPtr2, DWORD dwAudioBytes2);
+} ma_IDirectSoundCaptureBufferVtbl;
+struct ma_IDirectSoundCaptureBuffer
+{
+    ma_IDirectSoundCaptureBufferVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_QueryInterface(ma_IDirectSoundCaptureBuffer* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IDirectSoundCaptureBuffer_AddRef(ma_IDirectSoundCaptureBuffer* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IDirectSoundCaptureBuffer_Release(ma_IDirectSoundCaptureBuffer* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_GetCaps(ma_IDirectSoundCaptureBuffer* pThis, MA_DSCBCAPS* pDSCBCaps)                        { return pThis->lpVtbl->GetCaps(pThis, pDSCBCaps); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_GetCurrentPosition(ma_IDirectSoundCaptureBuffer* pThis, DWORD* pCapturePosition, DWORD* pReadPosition) { return pThis->lpVtbl->GetCurrentPosition(pThis, pCapturePosition, pReadPosition); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_GetFormat(ma_IDirectSoundCaptureBuffer* pThis, MA_WAVEFORMATEX* pFormat, DWORD dwSizeAllocated, DWORD* pSizeWritten) { return pThis->lpVtbl->GetFormat(pThis, pFormat, dwSizeAllocated, pSizeWritten); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_GetStatus(ma_IDirectSoundCaptureBuffer* pThis, DWORD* pStatus)                              { return pThis->lpVtbl->GetStatus(pThis, pStatus); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_Initialize(ma_IDirectSoundCaptureBuffer* pThis, ma_IDirectSoundCapture* pDirectSoundCapture, const MA_DSCBUFFERDESC* pDSCBufferDesc) { return pThis->lpVtbl->Initialize(pThis, pDirectSoundCapture, pDSCBufferDesc); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_Lock(ma_IDirectSoundCaptureBuffer* pThis, DWORD dwOffset, DWORD dwBytes, void** ppAudioPtr1, DWORD* pAudioBytes1, void** ppAudioPtr2, DWORD* pAudioBytes2, DWORD dwFlags) { return pThis->lpVtbl->Lock(pThis, dwOffset, dwBytes, ppAudioPtr1, pAudioBytes1, ppAudioPtr2, pAudioBytes2, dwFlags); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_Start(ma_IDirectSoundCaptureBuffer* pThis, DWORD dwFlags)                                   { return pThis->lpVtbl->Start(pThis, dwFlags); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_Stop(ma_IDirectSoundCaptureBuffer* pThis)                                                   { return pThis->lpVtbl->Stop(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundCaptureBuffer_Unlock(ma_IDirectSoundCaptureBuffer* pThis, void* pAudioPtr1, DWORD dwAudioBytes1, void* pAudioPtr2, DWORD dwAudioBytes2) { return pThis->lpVtbl->Unlock(pThis, pAudioPtr1, dwAudioBytes1, pAudioPtr2, dwAudioBytes2); }
+
+
+/* IDirectSoundNotify */
+typedef struct
+{
+    /* IUnknown */
+    HRESULT (STDMETHODCALLTYPE * QueryInterface)(ma_IDirectSoundNotify* pThis, const IID* const riid, void** ppObject);
+    ULONG   (STDMETHODCALLTYPE * AddRef)        (ma_IDirectSoundNotify* pThis);
+    ULONG   (STDMETHODCALLTYPE * Release)       (ma_IDirectSoundNotify* pThis);
+
+    /* IDirectSoundNotify */
+    HRESULT (STDMETHODCALLTYPE * SetNotificationPositions)(ma_IDirectSoundNotify* pThis, DWORD dwPositionNotifies, const MA_DSBPOSITIONNOTIFY* pPositionNotifies);
+} ma_IDirectSoundNotifyVtbl;
+struct ma_IDirectSoundNotify
+{
+    ma_IDirectSoundNotifyVtbl* lpVtbl;
+};
+static MA_INLINE HRESULT ma_IDirectSoundNotify_QueryInterface(ma_IDirectSoundNotify* pThis, const IID* const riid, void** ppObject) { return pThis->lpVtbl->QueryInterface(pThis, riid, ppObject); }
+static MA_INLINE ULONG   ma_IDirectSoundNotify_AddRef(ma_IDirectSoundNotify* pThis)                                                 { return pThis->lpVtbl->AddRef(pThis); }
+static MA_INLINE ULONG   ma_IDirectSoundNotify_Release(ma_IDirectSoundNotify* pThis)                                                { return pThis->lpVtbl->Release(pThis); }
+static MA_INLINE HRESULT ma_IDirectSoundNotify_SetNotificationPositions(ma_IDirectSoundNotify* pThis, DWORD dwPositionNotifies, const MA_DSBPOSITIONNOTIFY* pPositionNotifies) { return pThis->lpVtbl->SetNotificationPositions(pThis, dwPositionNotifies, pPositionNotifies); }
+
+
+typedef BOOL    (CALLBACK * ma_DSEnumCallbackAProc)             (GUID* pDeviceGUID, const char* pDeviceDescription, const char* pModule, void* pContext);
+typedef HRESULT (WINAPI   * ma_DirectSoundCreateProc)           (const GUID* pcGuidDevice, ma_IDirectSound** ppDS8, ma_IUnknown* pUnkOuter);
+typedef HRESULT (WINAPI   * ma_DirectSoundEnumerateAProc)       (ma_DSEnumCallbackAProc pDSEnumCallback, void* pContext);
+typedef HRESULT (WINAPI   * ma_DirectSoundCaptureCreateProc)    (const GUID* pcGuidDevice, ma_IDirectSoundCapture** ppDSC8, ma_IUnknown* pUnkOuter);
+typedef HRESULT (WINAPI   * ma_DirectSoundCaptureEnumerateAProc)(ma_DSEnumCallbackAProc pDSEnumCallback, void* pContext);
+
+static ma_uint32 ma_get_best_sample_rate_within_range(ma_uint32 sampleRateMin, ma_uint32 sampleRateMax)
+{
+    /* Normalize the range in case we were given something stupid. */
+    if (sampleRateMin < (ma_uint32)ma_standard_sample_rate_min) {
+        sampleRateMin = (ma_uint32)ma_standard_sample_rate_min;
+    }
+    if (sampleRateMax > (ma_uint32)ma_standard_sample_rate_max) {
+        sampleRateMax = (ma_uint32)ma_standard_sample_rate_max;
+    }
+    if (sampleRateMin > sampleRateMax) {
+        sampleRateMin = sampleRateMax;
+    }
+
+    if (sampleRateMin == sampleRateMax) {
+        return sampleRateMax;
+    } else {
+        size_t iStandardRate;
+        for (iStandardRate = 0; iStandardRate < ma_countof(g_maStandardSampleRatePriorities); ++iStandardRate) {
+            ma_uint32 standardRate = g_maStandardSampleRatePriorities[iStandardRate];
+            if (standardRate >= sampleRateMin && standardRate <= sampleRateMax) {
+                return standardRate;
+            }
+        }
+    }
+
+    /* Should never get here. */
+    MA_ASSERT(MA_FALSE);
+    return 0;
+}
+
+/*
+Retrieves the channel count and channel map for the given speaker configuration. If the speaker configuration is unknown,
+the channel count and channel map will be left unmodified.
+*/
+static void ma_get_channels_from_speaker_config__dsound(DWORD speakerConfig, WORD* pChannelsOut, DWORD* pChannelMapOut)
+{
+    WORD  channels;
+    DWORD channelMap;
+
+    channels = 0;
+    if (pChannelsOut != NULL) {
+        channels = *pChannelsOut;
+    }
+
+    channelMap = 0;
+    if (pChannelMapOut != NULL) {
+        channelMap = *pChannelMapOut;
+    }
+
+    /*
+    The speaker configuration is a combination of speaker config and speaker geometry. The lower 8 bits is what we care about. The upper
+    16 bits is for the geometry.
+    */
+    switch ((BYTE)(speakerConfig)) {
+        case 1 /*DSSPEAKER_HEADPHONE*/:                          channels = 2; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT; break;
+        case 2 /*DSSPEAKER_MONO*/:                               channels = 1; channelMap = SPEAKER_FRONT_CENTER; break;
+        case 3 /*DSSPEAKER_QUAD*/:                               channels = 4; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; break;
+        case 4 /*DSSPEAKER_STEREO*/:                             channels = 2; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT; break;
+        case 5 /*DSSPEAKER_SURROUND*/:                           channels = 4; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_BACK_CENTER; break;
+        case 6 /*DSSPEAKER_5POINT1_BACK*/ /*DSSPEAKER_5POINT1*/: channels = 6; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT; break;
+        case 7 /*DSSPEAKER_7POINT1_WIDE*/ /*DSSPEAKER_7POINT1*/: channels = 8; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_FRONT_LEFT_OF_CENTER | SPEAKER_FRONT_RIGHT_OF_CENTER; break;
+        case 8 /*DSSPEAKER_7POINT1_SURROUND*/:                   channels = 8; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT | SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT; break;
+        case 9 /*DSSPEAKER_5POINT1_SURROUND*/:                   channels = 6; channelMap = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY | SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT; break;
+        default: break;
+    }
+
+    if (pChannelsOut != NULL) {
+        *pChannelsOut = channels;
+    }
+
+    if (pChannelMapOut != NULL) {
+        *pChannelMapOut = channelMap;
+    }
+}
+
+
+static ma_result ma_context_create_IDirectSound__dsound(ma_context* pContext, ma_share_mode shareMode, const ma_device_id* pDeviceID, ma_IDirectSound** ppDirectSound)
+{
+    ma_IDirectSound* pDirectSound;
+    HWND hWnd;
+    HRESULT hr;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppDirectSound != NULL);
+
+    *ppDirectSound = NULL;
+    pDirectSound = NULL;
+
+    if (FAILED(((ma_DirectSoundCreateProc)pContext->dsound.DirectSoundCreate)((pDeviceID == NULL) ? NULL : (const GUID*)pDeviceID->dsound, &pDirectSound, NULL))) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[DirectSound] DirectSoundCreate() failed for playback device.");
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+
+    /* The cooperative level must be set before doing anything else. */
+    hWnd = ((MA_PFN_GetForegroundWindow)pContext->win32.GetForegroundWindow)();
+    if (hWnd == 0) {
+        hWnd = ((MA_PFN_GetDesktopWindow)pContext->win32.GetDesktopWindow)();
+    }
+
+    hr = ma_IDirectSound_SetCooperativeLevel(pDirectSound, hWnd, (shareMode == ma_share_mode_exclusive) ? MA_DSSCL_EXCLUSIVE : MA_DSSCL_PRIORITY);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSound_SetCooperateiveLevel() failed for playback device.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    *ppDirectSound = pDirectSound;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_create_IDirectSoundCapture__dsound(ma_context* pContext, ma_share_mode shareMode, const ma_device_id* pDeviceID, ma_IDirectSoundCapture** ppDirectSoundCapture)
+{
+    ma_IDirectSoundCapture* pDirectSoundCapture;
+    HRESULT hr;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppDirectSoundCapture != NULL);
+
+    /* DirectSound does not support exclusive mode for capture. */
+    if (shareMode == ma_share_mode_exclusive) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    *ppDirectSoundCapture = NULL;
+    pDirectSoundCapture = NULL;
+
+    hr = ((ma_DirectSoundCaptureCreateProc)pContext->dsound.DirectSoundCaptureCreate)((pDeviceID == NULL) ? NULL : (const GUID*)pDeviceID->dsound, &pDirectSoundCapture, NULL);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[DirectSound] DirectSoundCaptureCreate() failed for capture device.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    *ppDirectSoundCapture = pDirectSoundCapture;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_format_info_for_IDirectSoundCapture__dsound(ma_context* pContext, ma_IDirectSoundCapture* pDirectSoundCapture, WORD* pChannels, WORD* pBitsPerSample, DWORD* pSampleRate)
+{
+    HRESULT hr;
+    MA_DSCCAPS caps;
+    WORD bitsPerSample;
+    DWORD sampleRate;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pDirectSoundCapture != NULL);
+
+    if (pChannels) {
+        *pChannels = 0;
+    }
+    if (pBitsPerSample) {
+        *pBitsPerSample = 0;
+    }
+    if (pSampleRate) {
+        *pSampleRate = 0;
+    }
+
+    MA_ZERO_OBJECT(&caps);
+    caps.dwSize = sizeof(caps);
+    hr = ma_IDirectSoundCapture_GetCaps(pDirectSoundCapture, &caps);
+    if (FAILED(hr)) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundCapture_GetCaps() failed for capture device.");
+        return ma_result_from_HRESULT(hr);
+    }
+
+    if (pChannels) {
+        *pChannels = (WORD)caps.dwChannels;
+    }
+
+    /* The device can support multiple formats. We just go through the different formats in order of priority and pick the first one. This the same type of system as the WinMM backend. */
+    bitsPerSample = 16;
+    sampleRate = 48000;
+
+    if (caps.dwChannels == 1) {
+        if ((caps.dwFormats & WAVE_FORMAT_48M16) != 0) {
+            sampleRate = 48000;
+        } else if ((caps.dwFormats & WAVE_FORMAT_44M16) != 0) {
+            sampleRate = 44100;
+        } else if ((caps.dwFormats & WAVE_FORMAT_2M16) != 0) {
+            sampleRate = 22050;
+        } else if ((caps.dwFormats & WAVE_FORMAT_1M16) != 0) {
+            sampleRate = 11025;
+        } else if ((caps.dwFormats & WAVE_FORMAT_96M16) != 0) {
+            sampleRate = 96000;
+        } else {
+            bitsPerSample = 8;
+            if ((caps.dwFormats & WAVE_FORMAT_48M08) != 0) {
+                sampleRate = 48000;
+            } else if ((caps.dwFormats & WAVE_FORMAT_44M08) != 0) {
+                sampleRate = 44100;
+            } else if ((caps.dwFormats & WAVE_FORMAT_2M08) != 0) {
+                sampleRate = 22050;
+            } else if ((caps.dwFormats & WAVE_FORMAT_1M08) != 0) {
+                sampleRate = 11025;
+            } else if ((caps.dwFormats & WAVE_FORMAT_96M08) != 0) {
+                sampleRate = 96000;
+            } else {
+                bitsPerSample = 16;  /* Didn't find it. Just fall back to 16-bit. */
+            }
+        }
+    } else if (caps.dwChannels == 2) {
+        if ((caps.dwFormats & WAVE_FORMAT_48S16) != 0) {
+            sampleRate = 48000;
+        } else if ((caps.dwFormats & WAVE_FORMAT_44S16) != 0) {
+            sampleRate = 44100;
+        } else if ((caps.dwFormats & WAVE_FORMAT_2S16) != 0) {
+            sampleRate = 22050;
+        } else if ((caps.dwFormats & WAVE_FORMAT_1S16) != 0) {
+            sampleRate = 11025;
+        } else if ((caps.dwFormats & WAVE_FORMAT_96S16) != 0) {
+            sampleRate = 96000;
+        } else {
+            bitsPerSample = 8;
+            if ((caps.dwFormats & WAVE_FORMAT_48S08) != 0) {
+                sampleRate = 48000;
+            } else if ((caps.dwFormats & WAVE_FORMAT_44S08) != 0) {
+                sampleRate = 44100;
+            } else if ((caps.dwFormats & WAVE_FORMAT_2S08) != 0) {
+                sampleRate = 22050;
+            } else if ((caps.dwFormats & WAVE_FORMAT_1S08) != 0) {
+                sampleRate = 11025;
+            } else if ((caps.dwFormats & WAVE_FORMAT_96S08) != 0) {
+                sampleRate = 96000;
+            } else {
+                bitsPerSample = 16;  /* Didn't find it. Just fall back to 16-bit. */
+            }
+        }
+    }
+
+    if (pBitsPerSample) {
+        *pBitsPerSample = bitsPerSample;
+    }
+    if (pSampleRate) {
+        *pSampleRate = sampleRate;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+typedef struct
+{
+    ma_context* pContext;
+    ma_device_type deviceType;
+    ma_enum_devices_callback_proc callback;
+    void* pUserData;
+    ma_bool32 terminated;
+} ma_context_enumerate_devices_callback_data__dsound;
+
+static BOOL CALLBACK ma_context_enumerate_devices_callback__dsound(GUID* lpGuid, const char* lpcstrDescription, const char* lpcstrModule, void* lpContext)
+{
+    ma_context_enumerate_devices_callback_data__dsound* pData = (ma_context_enumerate_devices_callback_data__dsound*)lpContext;
+    ma_device_info deviceInfo;
+
+    (void)lpcstrModule;
+
+    MA_ZERO_OBJECT(&deviceInfo);
+
+    /* ID. */
+    if (lpGuid != NULL) {
+        MA_COPY_MEMORY(deviceInfo.id.dsound, lpGuid, 16);
+    } else {
+        MA_ZERO_MEMORY(deviceInfo.id.dsound, 16);
+        deviceInfo.isDefault = MA_TRUE;
+    }
+
+    /* Name / Description */
+    ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), lpcstrDescription, (size_t)-1);
+
+
+    /* Call the callback function, but make sure we stop enumerating if the callee requested so. */
+    MA_ASSERT(pData != NULL);
+    pData->terminated = (pData->callback(pData->pContext, pData->deviceType, &deviceInfo, pData->pUserData) == MA_FALSE);
+    if (pData->terminated) {
+        return FALSE;   /* Stop enumeration. */
+    } else {
+        return TRUE;    /* Continue enumeration. */
+    }
+}
+
+static ma_result ma_context_enumerate_devices__dsound(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_context_enumerate_devices_callback_data__dsound data;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    data.pContext = pContext;
+    data.callback = callback;
+    data.pUserData = pUserData;
+    data.terminated = MA_FALSE;
+
+    /* Playback. */
+    if (!data.terminated) {
+        data.deviceType = ma_device_type_playback;
+        ((ma_DirectSoundEnumerateAProc)pContext->dsound.DirectSoundEnumerateA)(ma_context_enumerate_devices_callback__dsound, &data);
+    }
+
+    /* Capture. */
+    if (!data.terminated) {
+        data.deviceType = ma_device_type_capture;
+        ((ma_DirectSoundCaptureEnumerateAProc)pContext->dsound.DirectSoundCaptureEnumerateA)(ma_context_enumerate_devices_callback__dsound, &data);
+    }
+
+    return MA_SUCCESS;
+}
+
+
+typedef struct
+{
+    const ma_device_id* pDeviceID;
+    ma_device_info* pDeviceInfo;
+    ma_bool32 found;
+} ma_context_get_device_info_callback_data__dsound;
+
+static BOOL CALLBACK ma_context_get_device_info_callback__dsound(GUID* lpGuid, const char* lpcstrDescription, const char* lpcstrModule, void* lpContext)
+{
+    ma_context_get_device_info_callback_data__dsound* pData = (ma_context_get_device_info_callback_data__dsound*)lpContext;
+    MA_ASSERT(pData != NULL);
+
+    if ((pData->pDeviceID == NULL || ma_is_guid_null(pData->pDeviceID->dsound)) && (lpGuid == NULL || ma_is_guid_null(lpGuid))) {
+        /* Default device. */
+        ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), lpcstrDescription, (size_t)-1);
+        pData->pDeviceInfo->isDefault = MA_TRUE;
+        pData->found = MA_TRUE;
+        return FALSE;   /* Stop enumeration. */
+    } else {
+        /* Not the default device. */
+        if (lpGuid != NULL && pData->pDeviceID != NULL) {
+            if (memcmp(pData->pDeviceID->dsound, lpGuid, sizeof(pData->pDeviceID->dsound)) == 0) {
+                ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), lpcstrDescription, (size_t)-1);
+                pData->found = MA_TRUE;
+                return FALSE;   /* Stop enumeration. */
+            }
+        }
+    }
+
+    (void)lpcstrModule;
+    return TRUE;
+}
+
+static ma_result ma_context_get_device_info__dsound(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_result result;
+    HRESULT hr;
+
+    if (pDeviceID != NULL) {
+        ma_context_get_device_info_callback_data__dsound data;
+
+        /* ID. */
+        MA_COPY_MEMORY(pDeviceInfo->id.dsound, pDeviceID->dsound, 16);
+
+        /* Name / Description. This is retrieved by enumerating over each device until we find that one that matches the input ID. */
+        data.pDeviceID = pDeviceID;
+        data.pDeviceInfo = pDeviceInfo;
+        data.found = MA_FALSE;
+        if (deviceType == ma_device_type_playback) {
+            ((ma_DirectSoundEnumerateAProc)pContext->dsound.DirectSoundEnumerateA)(ma_context_get_device_info_callback__dsound, &data);
+        } else {
+            ((ma_DirectSoundCaptureEnumerateAProc)pContext->dsound.DirectSoundCaptureEnumerateA)(ma_context_get_device_info_callback__dsound, &data);
+        }
+
+        if (!data.found) {
+            return MA_NO_DEVICE;
+        }
+    } else {
+        /* I don't think there's a way to get the name of the default device with DirectSound. In this case we just need to use defaults. */
+
+        /* ID */
+        MA_ZERO_MEMORY(pDeviceInfo->id.dsound, 16);
+
+        /* Name / Description */
+        if (deviceType == ma_device_type_playback) {
+            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+        } else {
+            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+        }
+
+        pDeviceInfo->isDefault = MA_TRUE;
+    }
+
+    /* Retrieving detailed information is slightly different depending on the device type. */
+    if (deviceType == ma_device_type_playback) {
+        /* Playback. */
+        ma_IDirectSound* pDirectSound;
+        MA_DSCAPS caps;
+        WORD channels;
+
+        result = ma_context_create_IDirectSound__dsound(pContext, ma_share_mode_shared, pDeviceID, &pDirectSound);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        MA_ZERO_OBJECT(&caps);
+        caps.dwSize = sizeof(caps);
+        hr = ma_IDirectSound_GetCaps(pDirectSound, &caps);
+        if (FAILED(hr)) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSound_GetCaps() failed for playback device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+
+        /* Channels. Only a single channel count is reported for DirectSound. */
+        if ((caps.dwFlags & MA_DSCAPS_PRIMARYSTEREO) != 0) {
+            /* It supports at least stereo, but could support more. */
+            DWORD speakerConfig;
+
+            channels = 2;
+
+            /* Look at the speaker configuration to get a better idea on the channel count. */
+            hr = ma_IDirectSound_GetSpeakerConfig(pDirectSound, &speakerConfig);
+            if (SUCCEEDED(hr)) {
+                ma_get_channels_from_speaker_config__dsound(speakerConfig, &channels, NULL);
+            }
+        } else {
+            /* It does not support stereo, which means we are stuck with mono. */
+            channels = 1;
+        }
+
+
+        /*
+        In DirectSound, our native formats are centered around sample rates. All formats are supported, and we're only reporting a single channel
+        count. However, DirectSound can report a range of supported sample rates. We're only going to include standard rates known by miniaudio
+        in order to keep the size of this within reason.
+        */
+        if ((caps.dwFlags & MA_DSCAPS_CONTINUOUSRATE) != 0) {
+            /* Multiple sample rates are supported. We'll report in order of our preferred sample rates. */
+            size_t iStandardSampleRate;
+            for (iStandardSampleRate = 0; iStandardSampleRate < ma_countof(g_maStandardSampleRatePriorities); iStandardSampleRate += 1) {
+                ma_uint32 sampleRate = g_maStandardSampleRatePriorities[iStandardSampleRate];
+                if (sampleRate >= caps.dwMinSecondarySampleRate && sampleRate <= caps.dwMaxSecondarySampleRate) {
+                    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = ma_format_unknown;
+                    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+                    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = sampleRate;
+                    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = 0;
+                    pDeviceInfo->nativeDataFormatCount += 1;
+                }
+            }
+        } else {
+            /* Only a single sample rate is supported. */
+            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = ma_format_unknown;
+            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = caps.dwMaxSecondarySampleRate;
+            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = 0;
+            pDeviceInfo->nativeDataFormatCount += 1;
+        }
+
+        ma_IDirectSound_Release(pDirectSound);
+    } else {
+        /*
+        Capture. This is a little different to playback due to the say the supported formats are reported. Technically capture
+        devices can support a number of different formats, but for simplicity and consistency with ma_device_init() I'm just
+        reporting the best format.
+        */
+        ma_IDirectSoundCapture* pDirectSoundCapture;
+        WORD channels;
+        WORD bitsPerSample;
+        DWORD sampleRate;
+
+        result = ma_context_create_IDirectSoundCapture__dsound(pContext, ma_share_mode_shared, pDeviceID, &pDirectSoundCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_context_get_format_info_for_IDirectSoundCapture__dsound(pContext, pDirectSoundCapture, &channels, &bitsPerSample, &sampleRate);
+        if (result != MA_SUCCESS) {
+            ma_IDirectSoundCapture_Release(pDirectSoundCapture);
+            return result;
+        }
+
+        ma_IDirectSoundCapture_Release(pDirectSoundCapture);
+
+        /* The format is always an integer format and is based on the bits per sample. */
+        if (bitsPerSample == 8) {
+            pDeviceInfo->nativeDataFormats[0].format = ma_format_u8;
+        } else if (bitsPerSample == 16) {
+            pDeviceInfo->nativeDataFormats[0].format = ma_format_s16;
+        } else if (bitsPerSample == 24) {
+            pDeviceInfo->nativeDataFormats[0].format = ma_format_s24;
+        } else if (bitsPerSample == 32) {
+            pDeviceInfo->nativeDataFormats[0].format = ma_format_s32;
+        } else {
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        pDeviceInfo->nativeDataFormats[0].channels   = channels;
+        pDeviceInfo->nativeDataFormats[0].sampleRate = sampleRate;
+        pDeviceInfo->nativeDataFormats[0].flags      = 0;
+        pDeviceInfo->nativeDataFormatCount = 1;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+static ma_result ma_device_uninit__dsound(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->dsound.pCaptureBuffer != NULL) {
+        ma_IDirectSoundCaptureBuffer_Release((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer);
+    }
+    if (pDevice->dsound.pCapture != NULL) {
+        ma_IDirectSoundCapture_Release((ma_IDirectSoundCapture*)pDevice->dsound.pCapture);
+    }
+
+    if (pDevice->dsound.pPlaybackBuffer != NULL) {
+        ma_IDirectSoundBuffer_Release((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer);
+    }
+    if (pDevice->dsound.pPlaybackPrimaryBuffer != NULL) {
+        ma_IDirectSoundBuffer_Release((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackPrimaryBuffer);
+    }
+    if (pDevice->dsound.pPlayback != NULL) {
+        ma_IDirectSound_Release((ma_IDirectSound*)pDevice->dsound.pPlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_config_to_WAVEFORMATEXTENSIBLE(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, const ma_channel* pChannelMap, MA_WAVEFORMATEXTENSIBLE* pWF)
+{
+    GUID subformat;
+
+    if (format == ma_format_unknown) {
+        format = MA_DEFAULT_FORMAT;
+    }
+
+    if (channels == 0) {
+        channels = MA_DEFAULT_CHANNELS;
+    }
+
+    if (sampleRate == 0) {
+        sampleRate = MA_DEFAULT_SAMPLE_RATE;
+    }
+
+    switch (format)
+    {
+        case ma_format_u8:
+        case ma_format_s16:
+        case ma_format_s24:
+        /*case ma_format_s24_32:*/
+        case ma_format_s32:
+        {
+            subformat = MA_GUID_KSDATAFORMAT_SUBTYPE_PCM;
+        } break;
+
+        case ma_format_f32:
+        {
+            subformat = MA_GUID_KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
+        } break;
+
+        default:
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    MA_ZERO_OBJECT(pWF);
+    pWF->cbSize                      = sizeof(*pWF);
+    pWF->wFormatTag                  = WAVE_FORMAT_EXTENSIBLE;
+    pWF->nChannels                   = (WORD)channels;
+    pWF->nSamplesPerSec              = (DWORD)sampleRate;
+    pWF->wBitsPerSample              = (WORD)(ma_get_bytes_per_sample(format)*8);
+    pWF->nBlockAlign                 = (WORD)(pWF->nChannels * pWF->wBitsPerSample / 8);
+    pWF->nAvgBytesPerSec             = pWF->nBlockAlign * pWF->nSamplesPerSec;
+    pWF->Samples.wValidBitsPerSample = pWF->wBitsPerSample;
+    pWF->dwChannelMask               = ma_channel_map_to_channel_mask__win32(pChannelMap, channels);
+    pWF->SubFormat                   = subformat;
+
+    return MA_SUCCESS;
+}
+
+static ma_uint32 ma_calculate_period_size_in_frames_from_descriptor__dsound(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+    /*
+    DirectSound has a minimum period size of 20ms. In practice, this doesn't seem to be enough for
+    reliable glitch-free processing so going to use 30ms instead.
+    */
+    ma_uint32 minPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(30, nativeSampleRate);
+    ma_uint32 periodSizeInFrames;
+
+    periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, nativeSampleRate, performanceProfile);
+    if (periodSizeInFrames < minPeriodSizeInFrames) {
+        periodSizeInFrames = minPeriodSizeInFrames;
+    }
+
+    return periodSizeInFrames;
+}
+
+static ma_result ma_device_init__dsound(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+    HRESULT hr;
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->dsound);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /*
+    Unfortunately DirectSound uses different APIs and data structures for playback and catpure devices. We need to initialize
+    the capture device first because we'll want to match it's buffer size and period count on the playback side if we're using
+    full-duplex mode.
+    */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        MA_WAVEFORMATEXTENSIBLE wf;
+        MA_DSCBUFFERDESC descDS;
+        ma_uint32 periodSizeInFrames;
+        ma_uint32 periodCount;
+        char rawdata[1024]; /* <-- Ugly hack to avoid a malloc() due to a crappy DirectSound API. */
+        MA_WAVEFORMATEXTENSIBLE* pActualFormat;
+
+        result = ma_config_to_WAVEFORMATEXTENSIBLE(pDescriptorCapture->format, pDescriptorCapture->channels, pDescriptorCapture->sampleRate, pDescriptorCapture->channelMap, &wf);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_context_create_IDirectSoundCapture__dsound(pDevice->pContext, pDescriptorCapture->shareMode, pDescriptorCapture->pDeviceID, (ma_IDirectSoundCapture**)&pDevice->dsound.pCapture);
+        if (result != MA_SUCCESS) {
+            ma_device_uninit__dsound(pDevice);
+            return result;
+        }
+
+        result = ma_context_get_format_info_for_IDirectSoundCapture__dsound(pDevice->pContext, (ma_IDirectSoundCapture*)pDevice->dsound.pCapture, &wf.nChannels, &wf.wBitsPerSample, &wf.nSamplesPerSec);
+        if (result != MA_SUCCESS) {
+            ma_device_uninit__dsound(pDevice);
+            return result;
+        }
+
+        wf.nBlockAlign                 = (WORD)(wf.nChannels * wf.wBitsPerSample / 8);
+        wf.nAvgBytesPerSec             = wf.nBlockAlign * wf.nSamplesPerSec;
+        wf.Samples.wValidBitsPerSample = wf.wBitsPerSample;
+        wf.SubFormat                   = MA_GUID_KSDATAFORMAT_SUBTYPE_PCM;
+
+        /* The size of the buffer must be a clean multiple of the period count. */
+        periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__dsound(pDescriptorCapture, wf.nSamplesPerSec, pConfig->performanceProfile);
+        periodCount = (pDescriptorCapture->periodCount > 0) ? pDescriptorCapture->periodCount : MA_DEFAULT_PERIODS;
+
+        MA_ZERO_OBJECT(&descDS);
+        descDS.dwSize        = sizeof(descDS);
+        descDS.dwFlags       = 0;
+        descDS.dwBufferBytes = periodSizeInFrames * periodCount * wf.nBlockAlign;
+        descDS.lpwfxFormat   = (MA_WAVEFORMATEX*)&wf;
+        hr = ma_IDirectSoundCapture_CreateCaptureBuffer((ma_IDirectSoundCapture*)pDevice->dsound.pCapture, &descDS, (ma_IDirectSoundCaptureBuffer**)&pDevice->dsound.pCaptureBuffer, NULL);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundCapture_CreateCaptureBuffer() failed for capture device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* Get the _actual_ properties of the buffer. */
+        pActualFormat = (MA_WAVEFORMATEXTENSIBLE*)rawdata;
+        hr = ma_IDirectSoundCaptureBuffer_GetFormat((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, (MA_WAVEFORMATEX*)pActualFormat, sizeof(rawdata), NULL);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to retrieve the actual format of the capture device's buffer.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* We can now start setting the output data formats. */
+        pDescriptorCapture->format     = ma_format_from_WAVEFORMATEX((MA_WAVEFORMATEX*)pActualFormat);
+        pDescriptorCapture->channels   = pActualFormat->nChannels;
+        pDescriptorCapture->sampleRate = pActualFormat->nSamplesPerSec;
+
+        /* Get the native channel map based on the channel mask. */
+        if (pActualFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
+            ma_channel_mask_to_channel_map__win32(pActualFormat->dwChannelMask, pDescriptorCapture->channels, pDescriptorCapture->channelMap);
+        } else {
+            ma_channel_mask_to_channel_map__win32(wf.dwChannelMask, pDescriptorCapture->channels, pDescriptorCapture->channelMap);
+        }
+
+        /*
+        After getting the actual format the size of the buffer in frames may have actually changed. However, we want this to be as close to what the
+        user has asked for as possible, so let's go ahead and release the old capture buffer and create a new one in this case.
+        */
+        if (periodSizeInFrames != (descDS.dwBufferBytes / ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels) / periodCount)) {
+            descDS.dwBufferBytes = periodSizeInFrames * ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels) * periodCount;
+            ma_IDirectSoundCaptureBuffer_Release((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer);
+
+            hr = ma_IDirectSoundCapture_CreateCaptureBuffer((ma_IDirectSoundCapture*)pDevice->dsound.pCapture, &descDS, (ma_IDirectSoundCaptureBuffer**)&pDevice->dsound.pCaptureBuffer, NULL);
+            if (FAILED(hr)) {
+                ma_device_uninit__dsound(pDevice);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Second attempt at IDirectSoundCapture_CreateCaptureBuffer() failed for capture device.");
+                return ma_result_from_HRESULT(hr);
+            }
+        }
+
+        /* DirectSound should give us a buffer exactly the size we asked for. */
+        pDescriptorCapture->periodSizeInFrames = periodSizeInFrames;
+        pDescriptorCapture->periodCount        = periodCount;
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        MA_WAVEFORMATEXTENSIBLE wf;
+        MA_DSBUFFERDESC descDSPrimary;
+        MA_DSCAPS caps;
+        char rawdata[1024]; /* <-- Ugly hack to avoid a malloc() due to a crappy DirectSound API. */
+        MA_WAVEFORMATEXTENSIBLE* pActualFormat;
+        ma_uint32 periodSizeInFrames;
+        ma_uint32 periodCount;
+        MA_DSBUFFERDESC descDS;
+        WORD nativeChannelCount;
+        DWORD nativeChannelMask = 0;
+
+        result = ma_config_to_WAVEFORMATEXTENSIBLE(pDescriptorPlayback->format, pDescriptorPlayback->channels, pDescriptorPlayback->sampleRate, pDescriptorPlayback->channelMap, &wf);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_context_create_IDirectSound__dsound(pDevice->pContext, pDescriptorPlayback->shareMode, pDescriptorPlayback->pDeviceID, (ma_IDirectSound**)&pDevice->dsound.pPlayback);
+        if (result != MA_SUCCESS) {
+            ma_device_uninit__dsound(pDevice);
+            return result;
+        }
+
+        MA_ZERO_OBJECT(&descDSPrimary);
+        descDSPrimary.dwSize  = sizeof(MA_DSBUFFERDESC);
+        descDSPrimary.dwFlags = MA_DSBCAPS_PRIMARYBUFFER | MA_DSBCAPS_CTRLVOLUME;
+        hr = ma_IDirectSound_CreateSoundBuffer((ma_IDirectSound*)pDevice->dsound.pPlayback, &descDSPrimary, (ma_IDirectSoundBuffer**)&pDevice->dsound.pPlaybackPrimaryBuffer, NULL);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSound_CreateSoundBuffer() failed for playback device's primary buffer.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+
+        /* We may want to make some adjustments to the format if we are using defaults. */
+        MA_ZERO_OBJECT(&caps);
+        caps.dwSize = sizeof(caps);
+        hr = ma_IDirectSound_GetCaps((ma_IDirectSound*)pDevice->dsound.pPlayback, &caps);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSound_GetCaps() failed for playback device.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        if ((caps.dwFlags & MA_DSCAPS_PRIMARYSTEREO) != 0) {
+            DWORD speakerConfig;
+
+            /* It supports at least stereo, but could support more. */
+            nativeChannelCount = 2;
+
+            /* Look at the speaker configuration to get a better idea on the channel count. */
+            if (SUCCEEDED(ma_IDirectSound_GetSpeakerConfig((ma_IDirectSound*)pDevice->dsound.pPlayback, &speakerConfig))) {
+                ma_get_channels_from_speaker_config__dsound(speakerConfig, &nativeChannelCount, &nativeChannelMask);
+            }
+        } else {
+            /* It does not support stereo, which means we are stuck with mono. */
+            nativeChannelCount = 1;
+            nativeChannelMask  = 0x00000001;
+        }
+
+        if (pDescriptorPlayback->channels == 0) {
+            wf.nChannels = nativeChannelCount;
+            wf.dwChannelMask    = nativeChannelMask;
+        }
+
+        if (pDescriptorPlayback->sampleRate == 0) {
+            /* We base the sample rate on the values returned by GetCaps(). */
+            if ((caps.dwFlags & MA_DSCAPS_CONTINUOUSRATE) != 0) {
+                wf.nSamplesPerSec = ma_get_best_sample_rate_within_range(caps.dwMinSecondarySampleRate, caps.dwMaxSecondarySampleRate);
+            } else {
+                wf.nSamplesPerSec = caps.dwMaxSecondarySampleRate;
+            }
+        }
+
+        wf.nBlockAlign     = (WORD)(wf.nChannels * wf.wBitsPerSample / 8);
+        wf.nAvgBytesPerSec = wf.nBlockAlign * wf.nSamplesPerSec;
+
+        /*
+        From MSDN:
+
+        The method succeeds even if the hardware does not support the requested format; DirectSound sets the buffer to the closest
+        supported format. To determine whether this has happened, an application can call the GetFormat method for the primary buffer
+        and compare the result with the format that was requested with the SetFormat method.
+        */
+        hr = ma_IDirectSoundBuffer_SetFormat((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackPrimaryBuffer, (MA_WAVEFORMATEX*)&wf);
+        if (FAILED(hr)) {
+            /*
+            If setting of the format failed we'll try again with some fallback settings. On Windows 98 I have
+            observed that IEEE_FLOAT does not work. We'll therefore enforce PCM. I also had issues where a
+            sample rate of 48000 did not work correctly. Not sure if it was a driver issue or not, but will
+            use 44100 for the sample rate.
+            */
+            wf.cbSize          = 18;    /* NOTE: Don't use sizeof(MA_WAVEFORMATEX) here because it's got an extra 2 bytes due to padding. */
+            wf.wFormatTag      = WAVE_FORMAT_PCM;
+            wf.wBitsPerSample  = 16;
+            wf.nChannels       = nativeChannelCount;
+            wf.nSamplesPerSec  = 44100;
+            wf.nBlockAlign     = wf.nChannels * (wf.wBitsPerSample / 8);
+            wf.nAvgBytesPerSec = wf.nSamplesPerSec * wf.nBlockAlign;
+
+            hr = ma_IDirectSoundBuffer_SetFormat((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackPrimaryBuffer, (MA_WAVEFORMATEX*)&wf);
+            if (FAILED(hr)) {
+                ma_device_uninit__dsound(pDevice);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to set format of playback device's primary buffer.");
+                return ma_result_from_HRESULT(hr);
+            }
+        }
+
+        /* Get the _actual_ properties of the buffer. */
+        pActualFormat = (MA_WAVEFORMATEXTENSIBLE*)rawdata;
+        hr = ma_IDirectSoundBuffer_GetFormat((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackPrimaryBuffer, (MA_WAVEFORMATEX*)pActualFormat, sizeof(rawdata), NULL);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to retrieve the actual format of the playback device's primary buffer.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* We now have enough information to start setting some output properties. */
+        pDescriptorPlayback->format     = ma_format_from_WAVEFORMATEX((MA_WAVEFORMATEX*)pActualFormat);
+        pDescriptorPlayback->channels   = pActualFormat->nChannels;
+        pDescriptorPlayback->sampleRate = pActualFormat->nSamplesPerSec;
+
+        /* Get the internal channel map based on the channel mask. */
+        if (pActualFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
+            ma_channel_mask_to_channel_map__win32(pActualFormat->dwChannelMask, pDescriptorPlayback->channels, pDescriptorPlayback->channelMap);
+        } else {
+            ma_channel_mask_to_channel_map__win32(wf.dwChannelMask, pDescriptorPlayback->channels, pDescriptorPlayback->channelMap);
+        }
+
+        /* The size of the buffer must be a clean multiple of the period count. */
+        periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__dsound(pDescriptorPlayback, pDescriptorPlayback->sampleRate, pConfig->performanceProfile);
+        periodCount = (pDescriptorPlayback->periodCount > 0) ? pDescriptorPlayback->periodCount : MA_DEFAULT_PERIODS;
+
+        /*
+        Meaning of dwFlags (from MSDN):
+
+        DSBCAPS_CTRLPOSITIONNOTIFY
+          The buffer has position notification capability.
+
+        DSBCAPS_GLOBALFOCUS
+          With this flag set, an application using DirectSound can continue to play its buffers if the user switches focus to
+          another application, even if the new application uses DirectSound.
+
+        DSBCAPS_GETCURRENTPOSITION2
+          In the first version of DirectSound, the play cursor was significantly ahead of the actual playing sound on emulated
+          sound cards; it was directly behind the write cursor. Now, if the DSBCAPS_GETCURRENTPOSITION2 flag is specified, the
+          application can get a more accurate play cursor.
+        */
+        MA_ZERO_OBJECT(&descDS);
+        descDS.dwSize = sizeof(descDS);
+        descDS.dwFlags = MA_DSBCAPS_CTRLPOSITIONNOTIFY | MA_DSBCAPS_GLOBALFOCUS | MA_DSBCAPS_GETCURRENTPOSITION2;
+        descDS.dwBufferBytes = periodSizeInFrames * periodCount * ma_get_bytes_per_frame(pDescriptorPlayback->format, pDescriptorPlayback->channels);
+        descDS.lpwfxFormat = (MA_WAVEFORMATEX*)pActualFormat;
+        hr = ma_IDirectSound_CreateSoundBuffer((ma_IDirectSound*)pDevice->dsound.pPlayback, &descDS, (ma_IDirectSoundBuffer**)&pDevice->dsound.pPlaybackBuffer, NULL);
+        if (FAILED(hr)) {
+            ma_device_uninit__dsound(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSound_CreateSoundBuffer() failed for playback device's secondary buffer.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        /* DirectSound should give us a buffer exactly the size we asked for. */
+        pDescriptorPlayback->periodSizeInFrames = periodSizeInFrames;
+        pDescriptorPlayback->periodCount        = periodCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_data_loop__dsound(ma_device* pDevice)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 bpfDeviceCapture  = ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+    ma_uint32 bpfDevicePlayback = ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    HRESULT hr;
+    DWORD lockOffsetInBytesCapture;
+    DWORD lockSizeInBytesCapture;
+    DWORD mappedSizeInBytesCapture;
+    DWORD mappedDeviceFramesProcessedCapture;
+    void* pMappedDeviceBufferCapture;
+    DWORD lockOffsetInBytesPlayback;
+    DWORD lockSizeInBytesPlayback;
+    DWORD mappedSizeInBytesPlayback;
+    void* pMappedDeviceBufferPlayback;
+    DWORD prevReadCursorInBytesCapture = 0;
+    DWORD prevPlayCursorInBytesPlayback = 0;
+    ma_bool32 physicalPlayCursorLoopFlagPlayback = 0;
+    DWORD virtualWriteCursorInBytesPlayback = 0;
+    ma_bool32 virtualWriteCursorLoopFlagPlayback = 0;
+    ma_bool32 isPlaybackDeviceStarted = MA_FALSE;
+    ma_uint32 framesWrittenToPlaybackDevice = 0;   /* For knowing whether or not the playback device needs to be started. */
+    ma_uint32 waitTimeInMilliseconds = 1;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* The first thing to do is start the capture device. The playback device is only started after the first period is written. */
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        hr = ma_IDirectSoundCaptureBuffer_Start((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, MA_DSCBSTART_LOOPING);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundCaptureBuffer_Start() failed.");
+            return ma_result_from_HRESULT(hr);
+        }
+    }
+
+    while (ma_device_get_state(pDevice) == ma_device_state_started) {
+        switch (pDevice->type)
+        {
+            case ma_device_type_duplex:
+            {
+                DWORD physicalCaptureCursorInBytes;
+                DWORD physicalReadCursorInBytes;
+                hr = ma_IDirectSoundCaptureBuffer_GetCurrentPosition((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, &physicalCaptureCursorInBytes, &physicalReadCursorInBytes);
+                if (FAILED(hr)) {
+                    return ma_result_from_HRESULT(hr);
+                }
+
+                /* If nothing is available we just sleep for a bit and return from this iteration. */
+                if (physicalReadCursorInBytes == prevReadCursorInBytesCapture) {
+                    ma_sleep(waitTimeInMilliseconds);
+                    continue; /* Nothing is available in the capture buffer. */
+                }
+
+                /*
+                The current position has moved. We need to map all of the captured samples and write them to the playback device, making sure
+                we don't return until every frame has been copied over.
+                */
+                if (prevReadCursorInBytesCapture < physicalReadCursorInBytes) {
+                    /* The capture position has not looped. This is the simple case. */
+                    lockOffsetInBytesCapture = prevReadCursorInBytesCapture;
+                    lockSizeInBytesCapture   = (physicalReadCursorInBytes - prevReadCursorInBytesCapture);
+                } else {
+                    /*
+                    The capture position has looped. This is the more complex case. Map to the end of the buffer. If this does not return anything,
+                    do it again from the start.
+                    */
+                    if (prevReadCursorInBytesCapture < pDevice->capture.internalPeriodSizeInFrames*pDevice->capture.internalPeriods*bpfDeviceCapture) {
+                        /* Lock up to the end of the buffer. */
+                        lockOffsetInBytesCapture = prevReadCursorInBytesCapture;
+                        lockSizeInBytesCapture   = (pDevice->capture.internalPeriodSizeInFrames*pDevice->capture.internalPeriods*bpfDeviceCapture) - prevReadCursorInBytesCapture;
+                    } else {
+                        /* Lock starting from the start of the buffer. */
+                        lockOffsetInBytesCapture = 0;
+                        lockSizeInBytesCapture   = physicalReadCursorInBytes;
+                    }
+                }
+
+                if (lockSizeInBytesCapture == 0) {
+                    ma_sleep(waitTimeInMilliseconds);
+                    continue; /* Nothing is available in the capture buffer. */
+                }
+
+                hr = ma_IDirectSoundCaptureBuffer_Lock((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, lockOffsetInBytesCapture, lockSizeInBytesCapture, &pMappedDeviceBufferCapture, &mappedSizeInBytesCapture, NULL, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to map buffer from capture device in preparation for writing to the device.");
+                    return ma_result_from_HRESULT(hr);
+                }
+
+
+                /* At this point we have some input data that we need to output. We do not return until every mapped frame of the input data is written to the playback device. */
+                mappedDeviceFramesProcessedCapture = 0;
+
+                for (;;) {  /* Keep writing to the playback device. */
+                    ma_uint8  inputFramesInClientFormat[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                    ma_uint32 inputFramesInClientFormatCap = sizeof(inputFramesInClientFormat) / ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels);
+                    ma_uint8  outputFramesInClientFormat[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                    ma_uint32 outputFramesInClientFormatCap = sizeof(outputFramesInClientFormat) / ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+                    ma_uint32 outputFramesInClientFormatCount;
+                    ma_uint32 outputFramesInClientFormatConsumed = 0;
+                    ma_uint64 clientCapturedFramesToProcess = ma_min(inputFramesInClientFormatCap, outputFramesInClientFormatCap);
+                    ma_uint64 deviceCapturedFramesToProcess = (mappedSizeInBytesCapture / bpfDeviceCapture) - mappedDeviceFramesProcessedCapture;
+                    void* pRunningMappedDeviceBufferCapture = ma_offset_ptr(pMappedDeviceBufferCapture, mappedDeviceFramesProcessedCapture * bpfDeviceCapture);
+
+                    result = ma_data_converter_process_pcm_frames(&pDevice->capture.converter, pRunningMappedDeviceBufferCapture, &deviceCapturedFramesToProcess, inputFramesInClientFormat, &clientCapturedFramesToProcess);
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+
+                    outputFramesInClientFormatCount     = (ma_uint32)clientCapturedFramesToProcess;
+                    mappedDeviceFramesProcessedCapture += (ma_uint32)deviceCapturedFramesToProcess;
+
+                    ma_device__handle_data_callback(pDevice, outputFramesInClientFormat, inputFramesInClientFormat, (ma_uint32)clientCapturedFramesToProcess);
+
+                    /* At this point we have input and output data in client format. All we need to do now is convert it to the output device format. This may take a few passes. */
+                    for (;;) {
+                        ma_uint32 framesWrittenThisIteration;
+                        DWORD physicalPlayCursorInBytes;
+                        DWORD physicalWriteCursorInBytes;
+                        DWORD availableBytesPlayback;
+                        DWORD silentPaddingInBytes = 0; /* <-- Must be initialized to 0. */
+
+                        /* We need the physical play and write cursors. */
+                        if (FAILED(ma_IDirectSoundBuffer_GetCurrentPosition((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, &physicalPlayCursorInBytes, &physicalWriteCursorInBytes))) {
+                            break;
+                        }
+
+                        if (physicalPlayCursorInBytes < prevPlayCursorInBytesPlayback) {
+                            physicalPlayCursorLoopFlagPlayback = !physicalPlayCursorLoopFlagPlayback;
+                        }
+                        prevPlayCursorInBytesPlayback  = physicalPlayCursorInBytes;
+
+                        /* If there's any bytes available for writing we can do that now. The space between the virtual cursor position and play cursor. */
+                        if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
+                            /* Same loop iteration. The available bytes wraps all the way around from the virtual write cursor to the physical play cursor. */
+                            if (physicalPlayCursorInBytes <= virtualWriteCursorInBytesPlayback) {
+                                availableBytesPlayback  = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
+                                availableBytesPlayback += physicalPlayCursorInBytes;    /* Wrap around. */
+                            } else {
+                                /* This is an error. */
+                                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Duplex/Playback): Play cursor has moved in front of the write cursor (same loop iteration). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, virtualWriteCursorInBytesPlayback);
+                                availableBytesPlayback = 0;
+                            }
+                        } else {
+                            /* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
+                            if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
+                                availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
+                            } else {
+                                /* This is an error. */
+                                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Duplex/Playback): Write cursor has moved behind the play cursor (different loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, virtualWriteCursorInBytesPlayback);
+                                availableBytesPlayback = 0;
+                            }
+                        }
+
+                        /* If there's no room available for writing we need to wait for more. */
+                        if (availableBytesPlayback == 0) {
+                            /* If we haven't started the device yet, this will never get beyond 0. In this case we need to get the device started. */
+                            if (!isPlaybackDeviceStarted) {
+                                hr = ma_IDirectSoundBuffer_Play((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0, 0, MA_DSBPLAY_LOOPING);
+                                if (FAILED(hr)) {
+                                    ma_IDirectSoundCaptureBuffer_Stop((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer);
+                                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Play() failed.");
+                                    return ma_result_from_HRESULT(hr);
+                                }
+                                isPlaybackDeviceStarted = MA_TRUE;
+                            } else {
+                                ma_sleep(waitTimeInMilliseconds);
+                                continue;
+                            }
+                        }
+
+
+                        /* Getting here means there room available somewhere. We limit this to either the end of the buffer or the physical play cursor, whichever is closest. */
+                        lockOffsetInBytesPlayback = virtualWriteCursorInBytesPlayback;
+                        if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
+                            /* Same loop iteration. Go up to the end of the buffer. */
+                            lockSizeInBytesPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
+                        } else {
+                            /* Different loop iterations. Go up to the physical play cursor. */
+                            lockSizeInBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
+                        }
+
+                        hr = ma_IDirectSoundBuffer_Lock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, lockOffsetInBytesPlayback, lockSizeInBytesPlayback, &pMappedDeviceBufferPlayback, &mappedSizeInBytesPlayback, NULL, NULL, 0);
+                        if (FAILED(hr)) {
+                            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to map buffer from playback device in preparation for writing to the device.");
+                            result = ma_result_from_HRESULT(hr);
+                            break;
+                        }
+
+                        /*
+                        Experiment: If the playback buffer is being starved, pad it with some silence to get it back in sync. This will cause a glitch, but it may prevent
+                        endless glitching due to it constantly running out of data.
+                        */
+                        if (isPlaybackDeviceStarted) {
+                            DWORD bytesQueuedForPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - availableBytesPlayback;
+                            if (bytesQueuedForPlayback < (pDevice->playback.internalPeriodSizeInFrames*bpfDevicePlayback)) {
+                                silentPaddingInBytes   = (pDevice->playback.internalPeriodSizeInFrames*2*bpfDevicePlayback) - bytesQueuedForPlayback;
+                                if (silentPaddingInBytes > lockSizeInBytesPlayback) {
+                                    silentPaddingInBytes = lockSizeInBytesPlayback;
+                                }
+
+                                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Duplex/Playback) Playback buffer starved. availableBytesPlayback=%ld, silentPaddingInBytes=%ld\n", availableBytesPlayback, silentPaddingInBytes);
+                            }
+                        }
+
+                        /* At this point we have a buffer for output. */
+                        if (silentPaddingInBytes > 0) {
+                            MA_ZERO_MEMORY(pMappedDeviceBufferPlayback, silentPaddingInBytes);
+                            framesWrittenThisIteration = silentPaddingInBytes/bpfDevicePlayback;
+                        } else {
+                            ma_uint64 convertedFrameCountIn  = (outputFramesInClientFormatCount - outputFramesInClientFormatConsumed);
+                            ma_uint64 convertedFrameCountOut = mappedSizeInBytesPlayback/bpfDevicePlayback;
+                            void* pConvertedFramesIn  = ma_offset_ptr(outputFramesInClientFormat, outputFramesInClientFormatConsumed * bpfDevicePlayback);
+                            void* pConvertedFramesOut = pMappedDeviceBufferPlayback;
+
+                            result = ma_data_converter_process_pcm_frames(&pDevice->playback.converter, pConvertedFramesIn, &convertedFrameCountIn, pConvertedFramesOut, &convertedFrameCountOut);
+                            if (result != MA_SUCCESS) {
+                                break;
+                            }
+
+                            outputFramesInClientFormatConsumed += (ma_uint32)convertedFrameCountOut;
+                            framesWrittenThisIteration          = (ma_uint32)convertedFrameCountOut;
+                        }
+
+
+                        hr = ma_IDirectSoundBuffer_Unlock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, pMappedDeviceBufferPlayback, framesWrittenThisIteration*bpfDevicePlayback, NULL, 0);
+                        if (FAILED(hr)) {
+                            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to unlock internal buffer from playback device after writing to the device.");
+                            result = ma_result_from_HRESULT(hr);
+                            break;
+                        }
+
+                        virtualWriteCursorInBytesPlayback += framesWrittenThisIteration*bpfDevicePlayback;
+                        if ((virtualWriteCursorInBytesPlayback/bpfDevicePlayback) == pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods) {
+                            virtualWriteCursorInBytesPlayback  = 0;
+                            virtualWriteCursorLoopFlagPlayback = !virtualWriteCursorLoopFlagPlayback;
+                        }
+
+                        /*
+                        We may need to start the device. We want two full periods to be written before starting the playback device. Having an extra period adds
+                        a bit of a buffer to prevent the playback buffer from getting starved.
+                        */
+                        framesWrittenToPlaybackDevice += framesWrittenThisIteration;
+                        if (!isPlaybackDeviceStarted && framesWrittenToPlaybackDevice >= (pDevice->playback.internalPeriodSizeInFrames*2)) {
+                            hr = ma_IDirectSoundBuffer_Play((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0, 0, MA_DSBPLAY_LOOPING);
+                            if (FAILED(hr)) {
+                                ma_IDirectSoundCaptureBuffer_Stop((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer);
+                                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Play() failed.");
+                                return ma_result_from_HRESULT(hr);
+                            }
+                            isPlaybackDeviceStarted = MA_TRUE;
+                        }
+
+                        if (framesWrittenThisIteration < mappedSizeInBytesPlayback/bpfDevicePlayback) {
+                            break;  /* We're finished with the output data.*/
+                        }
+                    }
+
+                    if (clientCapturedFramesToProcess == 0) {
+                        break;  /* We just consumed every input sample. */
+                    }
+                }
+
+
+                /* At this point we're done with the mapped portion of the capture buffer. */
+                hr = ma_IDirectSoundCaptureBuffer_Unlock((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, pMappedDeviceBufferCapture, mappedSizeInBytesCapture, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to unlock internal buffer from capture device after reading from the device.");
+                    return ma_result_from_HRESULT(hr);
+                }
+                prevReadCursorInBytesCapture = (lockOffsetInBytesCapture + mappedSizeInBytesCapture);
+            } break;
+
+
+
+            case ma_device_type_capture:
+            {
+                DWORD physicalCaptureCursorInBytes;
+                DWORD physicalReadCursorInBytes;
+                hr = ma_IDirectSoundCaptureBuffer_GetCurrentPosition((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, &physicalCaptureCursorInBytes, &physicalReadCursorInBytes);
+                if (FAILED(hr)) {
+                    return MA_ERROR;
+                }
+
+                /* If the previous capture position is the same as the current position we need to wait a bit longer. */
+                if (prevReadCursorInBytesCapture == physicalReadCursorInBytes) {
+                    ma_sleep(waitTimeInMilliseconds);
+                    continue;
+                }
+
+                /* Getting here means we have capture data available. */
+                if (prevReadCursorInBytesCapture < physicalReadCursorInBytes) {
+                    /* The capture position has not looped. This is the simple case. */
+                    lockOffsetInBytesCapture = prevReadCursorInBytesCapture;
+                    lockSizeInBytesCapture   = (physicalReadCursorInBytes - prevReadCursorInBytesCapture);
+                } else {
+                    /*
+                    The capture position has looped. This is the more complex case. Map to the end of the buffer. If this does not return anything,
+                    do it again from the start.
+                    */
+                    if (prevReadCursorInBytesCapture < pDevice->capture.internalPeriodSizeInFrames*pDevice->capture.internalPeriods*bpfDeviceCapture) {
+                        /* Lock up to the end of the buffer. */
+                        lockOffsetInBytesCapture = prevReadCursorInBytesCapture;
+                        lockSizeInBytesCapture   = (pDevice->capture.internalPeriodSizeInFrames*pDevice->capture.internalPeriods*bpfDeviceCapture) - prevReadCursorInBytesCapture;
+                    } else {
+                        /* Lock starting from the start of the buffer. */
+                        lockOffsetInBytesCapture = 0;
+                        lockSizeInBytesCapture   = physicalReadCursorInBytes;
+                    }
+                }
+
+                if (lockSizeInBytesCapture < pDevice->capture.internalPeriodSizeInFrames) {
+                    ma_sleep(waitTimeInMilliseconds);
+                    continue; /* Nothing is available in the capture buffer. */
+                }
+
+                hr = ma_IDirectSoundCaptureBuffer_Lock((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, lockOffsetInBytesCapture, lockSizeInBytesCapture, &pMappedDeviceBufferCapture, &mappedSizeInBytesCapture, NULL, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to map buffer from capture device in preparation for writing to the device.");
+                    result = ma_result_from_HRESULT(hr);
+                }
+
+                if (lockSizeInBytesCapture != mappedSizeInBytesCapture) {
+                    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[DirectSound] (Capture) lockSizeInBytesCapture=%ld != mappedSizeInBytesCapture=%ld\n", lockSizeInBytesCapture, mappedSizeInBytesCapture);
+                }
+
+                ma_device__send_frames_to_client(pDevice, mappedSizeInBytesCapture/bpfDeviceCapture, pMappedDeviceBufferCapture);
+
+                hr = ma_IDirectSoundCaptureBuffer_Unlock((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer, pMappedDeviceBufferCapture, mappedSizeInBytesCapture, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to unlock internal buffer from capture device after reading from the device.");
+                    return ma_result_from_HRESULT(hr);
+                }
+                prevReadCursorInBytesCapture = lockOffsetInBytesCapture + mappedSizeInBytesCapture;
+
+                if (prevReadCursorInBytesCapture == (pDevice->capture.internalPeriodSizeInFrames*pDevice->capture.internalPeriods*bpfDeviceCapture)) {
+                    prevReadCursorInBytesCapture = 0;
+                }
+            } break;
+
+
+
+            case ma_device_type_playback:
+            {
+                DWORD availableBytesPlayback;
+                DWORD physicalPlayCursorInBytes;
+                DWORD physicalWriteCursorInBytes;
+                hr = ma_IDirectSoundBuffer_GetCurrentPosition((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, &physicalPlayCursorInBytes, &physicalWriteCursorInBytes);
+                if (FAILED(hr)) {
+                    break;
+                }
+
+                if (physicalPlayCursorInBytes < prevPlayCursorInBytesPlayback) {
+                    physicalPlayCursorLoopFlagPlayback = !physicalPlayCursorLoopFlagPlayback;
+                }
+                prevPlayCursorInBytesPlayback  = physicalPlayCursorInBytes;
+
+                /* If there's any bytes available for writing we can do that now. The space between the virtual cursor position and play cursor. */
+                if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
+                    /* Same loop iteration. The available bytes wraps all the way around from the virtual write cursor to the physical play cursor. */
+                    if (physicalPlayCursorInBytes <= virtualWriteCursorInBytesPlayback) {
+                        availableBytesPlayback  = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
+                        availableBytesPlayback += physicalPlayCursorInBytes;    /* Wrap around. */
+                    } else {
+                        /* This is an error. */
+                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Playback): Play cursor has moved in front of the write cursor (same loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, virtualWriteCursorInBytesPlayback);
+                        availableBytesPlayback = 0;
+                    }
+                } else {
+                    /* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
+                    if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
+                        availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
+                    } else {
+                        /* This is an error. */
+                        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[DirectSound] (Playback): Write cursor has moved behind the play cursor (different loop iterations). physicalPlayCursorInBytes=%ld, virtualWriteCursorInBytes=%ld.\n", physicalPlayCursorInBytes, virtualWriteCursorInBytesPlayback);
+                        availableBytesPlayback = 0;
+                    }
+                }
+
+                /* If there's no room available for writing we need to wait for more. */
+                if (availableBytesPlayback < pDevice->playback.internalPeriodSizeInFrames) {
+                    /* If we haven't started the device yet, this will never get beyond 0. In this case we need to get the device started. */
+                    if (availableBytesPlayback == 0 && !isPlaybackDeviceStarted) {
+                        hr = ma_IDirectSoundBuffer_Play((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0, 0, MA_DSBPLAY_LOOPING);
+                        if (FAILED(hr)) {
+                            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Play() failed.");
+                            return ma_result_from_HRESULT(hr);
+                        }
+                        isPlaybackDeviceStarted = MA_TRUE;
+                    } else {
+                        ma_sleep(waitTimeInMilliseconds);
+                        continue;
+                    }
+                }
+
+                /* Getting here means there room available somewhere. We limit this to either the end of the buffer or the physical play cursor, whichever is closest. */
+                lockOffsetInBytesPlayback = virtualWriteCursorInBytesPlayback;
+                if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
+                    /* Same loop iteration. Go up to the end of the buffer. */
+                    lockSizeInBytesPlayback = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
+                } else {
+                    /* Different loop iterations. Go up to the physical play cursor. */
+                    lockSizeInBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
+                }
+
+                hr = ma_IDirectSoundBuffer_Lock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, lockOffsetInBytesPlayback, lockSizeInBytesPlayback, &pMappedDeviceBufferPlayback, &mappedSizeInBytesPlayback, NULL, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to map buffer from playback device in preparation for writing to the device.");
+                    result = ma_result_from_HRESULT(hr);
+                    break;
+                }
+
+                /* At this point we have a buffer for output. */
+                ma_device__read_frames_from_client(pDevice, (mappedSizeInBytesPlayback/bpfDevicePlayback), pMappedDeviceBufferPlayback);
+
+                hr = ma_IDirectSoundBuffer_Unlock((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, pMappedDeviceBufferPlayback, mappedSizeInBytesPlayback, NULL, 0);
+                if (FAILED(hr)) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] Failed to unlock internal buffer from playback device after writing to the device.");
+                    result = ma_result_from_HRESULT(hr);
+                    break;
+                }
+
+                virtualWriteCursorInBytesPlayback += mappedSizeInBytesPlayback;
+                if (virtualWriteCursorInBytesPlayback == pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) {
+                    virtualWriteCursorInBytesPlayback  = 0;
+                    virtualWriteCursorLoopFlagPlayback = !virtualWriteCursorLoopFlagPlayback;
+                }
+
+                /*
+                We may need to start the device. We want two full periods to be written before starting the playback device. Having an extra period adds
+                a bit of a buffer to prevent the playback buffer from getting starved.
+                */
+                framesWrittenToPlaybackDevice += mappedSizeInBytesPlayback/bpfDevicePlayback;
+                if (!isPlaybackDeviceStarted && framesWrittenToPlaybackDevice >= pDevice->playback.internalPeriodSizeInFrames) {
+                    hr = ma_IDirectSoundBuffer_Play((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0, 0, MA_DSBPLAY_LOOPING);
+                    if (FAILED(hr)) {
+                        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Play() failed.");
+                        return ma_result_from_HRESULT(hr);
+                    }
+                    isPlaybackDeviceStarted = MA_TRUE;
+                }
+            } break;
+
+
+            default: return MA_INVALID_ARGS;   /* Invalid device type. */
+        }
+
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    /* Getting here means the device is being stopped. */
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        hr = ma_IDirectSoundCaptureBuffer_Stop((ma_IDirectSoundCaptureBuffer*)pDevice->dsound.pCaptureBuffer);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundCaptureBuffer_Stop() failed.");
+            return ma_result_from_HRESULT(hr);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /* The playback device should be drained before stopping. All we do is wait until the available bytes is equal to the size of the buffer. */
+        if (isPlaybackDeviceStarted) {
+            for (;;) {
+                DWORD availableBytesPlayback = 0;
+                DWORD physicalPlayCursorInBytes;
+                DWORD physicalWriteCursorInBytes;
+                hr = ma_IDirectSoundBuffer_GetCurrentPosition((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, &physicalPlayCursorInBytes, &physicalWriteCursorInBytes);
+                if (FAILED(hr)) {
+                    break;
+                }
+
+                if (physicalPlayCursorInBytes < prevPlayCursorInBytesPlayback) {
+                    physicalPlayCursorLoopFlagPlayback = !physicalPlayCursorLoopFlagPlayback;
+                }
+                prevPlayCursorInBytesPlayback  = physicalPlayCursorInBytes;
+
+                if (physicalPlayCursorLoopFlagPlayback == virtualWriteCursorLoopFlagPlayback) {
+                    /* Same loop iteration. The available bytes wraps all the way around from the virtual write cursor to the physical play cursor. */
+                    if (physicalPlayCursorInBytes <= virtualWriteCursorInBytesPlayback) {
+                        availableBytesPlayback  = (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback) - virtualWriteCursorInBytesPlayback;
+                        availableBytesPlayback += physicalPlayCursorInBytes;    /* Wrap around. */
+                    } else {
+                        break;
+                    }
+                } else {
+                    /* Different loop iterations. The available bytes only goes from the virtual write cursor to the physical play cursor. */
+                    if (physicalPlayCursorInBytes >= virtualWriteCursorInBytesPlayback) {
+                        availableBytesPlayback = physicalPlayCursorInBytes - virtualWriteCursorInBytesPlayback;
+                    } else {
+                        break;
+                    }
+                }
+
+                if (availableBytesPlayback >= (pDevice->playback.internalPeriodSizeInFrames*pDevice->playback.internalPeriods*bpfDevicePlayback)) {
+                    break;
+                }
+
+                ma_sleep(waitTimeInMilliseconds);
+            }
+        }
+
+        hr = ma_IDirectSoundBuffer_Stop((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer);
+        if (FAILED(hr)) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[DirectSound] IDirectSoundBuffer_Stop() failed.");
+            return ma_result_from_HRESULT(hr);
+        }
+
+        ma_IDirectSoundBuffer_SetCurrentPosition((ma_IDirectSoundBuffer*)pDevice->dsound.pPlaybackBuffer, 0);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__dsound(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_dsound);
+
+    ma_dlclose(ma_context_get_log(pContext), pContext->dsound.hDSoundDLL);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__dsound(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+    pContext->dsound.hDSoundDLL = ma_dlopen(ma_context_get_log(pContext), "dsound.dll");
+    if (pContext->dsound.hDSoundDLL == NULL) {
+        return MA_API_NOT_FOUND;
+    }
+
+    pContext->dsound.DirectSoundCreate            = ma_dlsym(ma_context_get_log(pContext), pContext->dsound.hDSoundDLL, "DirectSoundCreate");
+    pContext->dsound.DirectSoundEnumerateA        = ma_dlsym(ma_context_get_log(pContext), pContext->dsound.hDSoundDLL, "DirectSoundEnumerateA");
+    pContext->dsound.DirectSoundCaptureCreate     = ma_dlsym(ma_context_get_log(pContext), pContext->dsound.hDSoundDLL, "DirectSoundCaptureCreate");
+    pContext->dsound.DirectSoundCaptureEnumerateA = ma_dlsym(ma_context_get_log(pContext), pContext->dsound.hDSoundDLL, "DirectSoundCaptureEnumerateA");
+
+    /*
+    We need to support all functions or nothing. DirectSound with Windows 95 seems to not work too
+    well in my testing. For example, it's missing DirectSoundCaptureEnumerateA(). This is a convenient
+    place to just disable the DirectSound backend for Windows 95.
+    */
+    if (pContext->dsound.DirectSoundCreate            == NULL ||
+        pContext->dsound.DirectSoundEnumerateA        == NULL ||
+        pContext->dsound.DirectSoundCaptureCreate     == NULL ||
+        pContext->dsound.DirectSoundCaptureEnumerateA == NULL) {
+        return MA_API_NOT_FOUND;
+    }
+
+    pCallbacks->onContextInit             = ma_context_init__dsound;
+    pCallbacks->onContextUninit           = ma_context_uninit__dsound;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__dsound;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__dsound;
+    pCallbacks->onDeviceInit              = ma_device_init__dsound;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__dsound;
+    pCallbacks->onDeviceStart             = NULL;   /* Not used. Started in onDeviceDataLoop. */
+    pCallbacks->onDeviceStop              = NULL;   /* Not used. Stopped in onDeviceDataLoop. */
+    pCallbacks->onDeviceRead              = NULL;   /* Not used. Data is read directly in onDeviceDataLoop. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not used. Data is written directly in onDeviceDataLoop. */
+    pCallbacks->onDeviceDataLoop          = ma_device_data_loop__dsound;
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+
+/******************************************************************************
+
+WinMM Backend
+
+******************************************************************************/
+#ifdef MA_HAS_WINMM
+
+/*
+Some build configurations will exclude the WinMM API. An example is when WIN32_LEAN_AND_MEAN
+is defined. We need to define the types and functions we need manually.
+*/
+#define MA_MMSYSERR_NOERROR     0
+#define MA_MMSYSERR_ERROR       1
+#define MA_MMSYSERR_BADDEVICEID 2
+#define MA_MMSYSERR_INVALHANDLE 5
+#define MA_MMSYSERR_NOMEM       7
+#define MA_MMSYSERR_INVALFLAG   10
+#define MA_MMSYSERR_INVALPARAM  11
+#define MA_MMSYSERR_HANDLEBUSY  12
+
+#define MA_CALLBACK_EVENT       0x00050000
+#define MA_WAVE_ALLOWSYNC       0x0002
+
+#define MA_WHDR_DONE            0x00000001
+#define MA_WHDR_PREPARED        0x00000002
+#define MA_WHDR_BEGINLOOP       0x00000004
+#define MA_WHDR_ENDLOOP         0x00000008
+#define MA_WHDR_INQUEUE         0x00000010
+
+#define MA_MAXPNAMELEN          32
+
+typedef void* MA_HWAVEIN;
+typedef void* MA_HWAVEOUT;
+typedef UINT MA_MMRESULT;
+typedef UINT MA_MMVERSION;
+
+typedef struct
+{
+    WORD wMid;
+    WORD wPid;
+    MA_MMVERSION vDriverVersion;
+    CHAR szPname[MA_MAXPNAMELEN];
+    DWORD dwFormats;
+    WORD wChannels;
+    WORD wReserved1;
+} MA_WAVEINCAPSA;
+
+typedef struct
+{
+    WORD wMid;
+    WORD wPid;
+    MA_MMVERSION vDriverVersion;
+    CHAR szPname[MA_MAXPNAMELEN];
+    DWORD dwFormats;
+    WORD wChannels;
+    WORD wReserved1;
+    DWORD dwSupport;
+} MA_WAVEOUTCAPSA;
+
+typedef struct tagWAVEHDR
+{
+    char* lpData;
+    DWORD dwBufferLength;
+    DWORD dwBytesRecorded;
+    DWORD_PTR dwUser;
+    DWORD dwFlags;
+    DWORD dwLoops;
+    struct tagWAVEHDR* lpNext;
+    DWORD_PTR reserved;
+} MA_WAVEHDR;
+
+typedef struct
+{
+    WORD wMid;
+    WORD wPid;
+    MA_MMVERSION vDriverVersion;
+    CHAR szPname[MA_MAXPNAMELEN];
+    DWORD dwFormats;
+    WORD wChannels;
+    WORD wReserved1;
+    DWORD dwSupport;
+    GUID ManufacturerGuid;
+    GUID ProductGuid;
+    GUID NameGuid;
+} MA_WAVEOUTCAPS2A;
+
+typedef struct
+{
+    WORD wMid;
+    WORD wPid;
+    MA_MMVERSION vDriverVersion;
+    CHAR szPname[MA_MAXPNAMELEN];
+    DWORD dwFormats;
+    WORD wChannels;
+    WORD wReserved1;
+    GUID ManufacturerGuid;
+    GUID ProductGuid;
+    GUID NameGuid;
+} MA_WAVEINCAPS2A;
+
+typedef UINT        (WINAPI * MA_PFN_waveOutGetNumDevs)(void);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutGetDevCapsA)(ma_uintptr uDeviceID, MA_WAVEOUTCAPSA* pwoc, UINT cbwoc);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutOpen)(MA_HWAVEOUT* phwo, UINT uDeviceID, const MA_WAVEFORMATEX* pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutClose)(MA_HWAVEOUT hwo);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutPrepareHeader)(MA_HWAVEOUT hwo, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutUnprepareHeader)(MA_HWAVEOUT hwo, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutWrite)(MA_HWAVEOUT hwo, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveOutReset)(MA_HWAVEOUT hwo);
+typedef UINT        (WINAPI * MA_PFN_waveInGetNumDevs)(void);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInGetDevCapsA)(ma_uintptr uDeviceID, MA_WAVEINCAPSA* pwic, UINT cbwic);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInOpen)(MA_HWAVEIN* phwi, UINT uDeviceID, const MA_WAVEFORMATEX* pwfx, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInClose)(MA_HWAVEIN hwi);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInPrepareHeader)(MA_HWAVEIN hwi, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInUnprepareHeader)(MA_HWAVEIN hwi, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInAddBuffer)(MA_HWAVEIN hwi, MA_WAVEHDR* pwh, UINT cbwh);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInStart)(MA_HWAVEIN hwi);
+typedef MA_MMRESULT (WINAPI * MA_PFN_waveInReset)(MA_HWAVEIN hwi);
+
+static ma_result ma_result_from_MMRESULT(MA_MMRESULT resultMM)
+{
+    switch (resultMM)
+    {
+        case MA_MMSYSERR_NOERROR:       return MA_SUCCESS;
+        case MA_MMSYSERR_BADDEVICEID:   return MA_INVALID_ARGS;
+        case MA_MMSYSERR_INVALHANDLE:   return MA_INVALID_ARGS;
+        case MA_MMSYSERR_NOMEM:         return MA_OUT_OF_MEMORY;
+        case MA_MMSYSERR_INVALFLAG:     return MA_INVALID_ARGS;
+        case MA_MMSYSERR_INVALPARAM:    return MA_INVALID_ARGS;
+        case MA_MMSYSERR_HANDLEBUSY:    return MA_BUSY;
+        case MA_MMSYSERR_ERROR:         return MA_ERROR;
+        default:                        return MA_ERROR;
+    }
+}
+
+static char* ma_find_last_character(char* str, char ch)
+{
+    char* last;
+
+    if (str == NULL) {
+        return NULL;
+    }
+
+    last = NULL;
+    while (*str != '\0') {
+        if (*str == ch) {
+            last = str;
+        }
+
+        str += 1;
+    }
+
+    return last;
+}
+
+static ma_uint32 ma_get_period_size_in_bytes(ma_uint32 periodSizeInFrames, ma_format format, ma_uint32 channels)
+{
+    return periodSizeInFrames * ma_get_bytes_per_frame(format, channels);
+}
+
+
+/*
+Our own "WAVECAPS" structure that contains generic information shared between WAVEOUTCAPS2 and WAVEINCAPS2 so
+we can do things generically and typesafely. Names are being kept the same for consistency.
+*/
+typedef struct
+{
+    CHAR szPname[MA_MAXPNAMELEN];
+    DWORD dwFormats;
+    WORD wChannels;
+    GUID NameGuid;
+} MA_WAVECAPSA;
+
+static ma_result ma_get_best_info_from_formats_flags__winmm(DWORD dwFormats, WORD channels, WORD* pBitsPerSample, DWORD* pSampleRate)
+{
+    WORD bitsPerSample = 0;
+    DWORD sampleRate = 0;
+
+    if (pBitsPerSample) {
+        *pBitsPerSample = 0;
+    }
+    if (pSampleRate) {
+        *pSampleRate = 0;
+    }
+
+    if (channels == 1) {
+        bitsPerSample = 16;
+        if ((dwFormats & WAVE_FORMAT_48M16) != 0) {
+            sampleRate = 48000;
+        } else if ((dwFormats & WAVE_FORMAT_44M16) != 0) {
+            sampleRate = 44100;
+        } else if ((dwFormats & WAVE_FORMAT_2M16) != 0) {
+            sampleRate = 22050;
+        } else if ((dwFormats & WAVE_FORMAT_1M16) != 0) {
+            sampleRate = 11025;
+        } else if ((dwFormats & WAVE_FORMAT_96M16) != 0) {
+            sampleRate = 96000;
+        } else {
+            bitsPerSample = 8;
+            if ((dwFormats & WAVE_FORMAT_48M08) != 0) {
+                sampleRate = 48000;
+            } else if ((dwFormats & WAVE_FORMAT_44M08) != 0) {
+                sampleRate = 44100;
+            } else if ((dwFormats & WAVE_FORMAT_2M08) != 0) {
+                sampleRate = 22050;
+            } else if ((dwFormats & WAVE_FORMAT_1M08) != 0) {
+                sampleRate = 11025;
+            } else if ((dwFormats & WAVE_FORMAT_96M08) != 0) {
+                sampleRate = 96000;
+            } else {
+                return MA_FORMAT_NOT_SUPPORTED;
+            }
+        }
+    } else {
+        bitsPerSample = 16;
+        if ((dwFormats & WAVE_FORMAT_48S16) != 0) {
+            sampleRate = 48000;
+        } else if ((dwFormats & WAVE_FORMAT_44S16) != 0) {
+            sampleRate = 44100;
+        } else if ((dwFormats & WAVE_FORMAT_2S16) != 0) {
+            sampleRate = 22050;
+        } else if ((dwFormats & WAVE_FORMAT_1S16) != 0) {
+            sampleRate = 11025;
+        } else if ((dwFormats & WAVE_FORMAT_96S16) != 0) {
+            sampleRate = 96000;
+        } else {
+            bitsPerSample = 8;
+            if ((dwFormats & WAVE_FORMAT_48S08) != 0) {
+                sampleRate = 48000;
+            } else if ((dwFormats & WAVE_FORMAT_44S08) != 0) {
+                sampleRate = 44100;
+            } else if ((dwFormats & WAVE_FORMAT_2S08) != 0) {
+                sampleRate = 22050;
+            } else if ((dwFormats & WAVE_FORMAT_1S08) != 0) {
+                sampleRate = 11025;
+            } else if ((dwFormats & WAVE_FORMAT_96S08) != 0) {
+                sampleRate = 96000;
+            } else {
+                return MA_FORMAT_NOT_SUPPORTED;
+            }
+        }
+    }
+
+    if (pBitsPerSample) {
+        *pBitsPerSample = bitsPerSample;
+    }
+    if (pSampleRate) {
+        *pSampleRate = sampleRate;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_formats_flags_to_WAVEFORMATEX__winmm(DWORD dwFormats, WORD channels, MA_WAVEFORMATEX* pWF)
+{
+    ma_result result;
+
+    MA_ASSERT(pWF != NULL);
+
+    MA_ZERO_OBJECT(pWF);
+    pWF->cbSize     = sizeof(*pWF);
+    pWF->wFormatTag = WAVE_FORMAT_PCM;
+    pWF->nChannels  = (WORD)channels;
+    if (pWF->nChannels > 2) {
+        pWF->nChannels = 2;
+    }
+
+    result = ma_get_best_info_from_formats_flags__winmm(dwFormats, channels, &pWF->wBitsPerSample, &pWF->nSamplesPerSec);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pWF->nBlockAlign     = (WORD)(pWF->nChannels * pWF->wBitsPerSample / 8);
+    pWF->nAvgBytesPerSec = pWF->nBlockAlign * pWF->nSamplesPerSec;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info_from_WAVECAPS(ma_context* pContext, MA_WAVECAPSA* pCaps, ma_device_info* pDeviceInfo)
+{
+    WORD bitsPerSample;
+    DWORD sampleRate;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pCaps != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    /*
+    Name / Description
+
+    Unfortunately the name specified in WAVE(OUT/IN)CAPS2 is limited to 31 characters. This results in an unprofessional looking
+    situation where the names of the devices are truncated. To help work around this, we need to look at the name GUID and try
+    looking in the registry for the full name. If we can't find it there, we need to just fall back to the default name.
+    */
+
+    /* Set the default to begin with. */
+    ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), pCaps->szPname, (size_t)-1);
+
+    /*
+    Now try the registry. There's a few things to consider here:
+    - The name GUID can be null, in which we case we just need to stick to the original 31 characters.
+    - If the name GUID is not present in the registry we'll also need to stick to the original 31 characters.
+    - I like consistency, so I want the returned device names to be consistent with those returned by WASAPI and DirectSound. The
+      problem, however is that WASAPI and DirectSound use "<component> (<name>)" format (such as "Speakers (High Definition Audio)"),
+      but WinMM does not specificy the component name. From my admittedly limited testing, I've notice the component name seems to
+      usually fit within the 31 characters of the fixed sized buffer, so what I'm going to do is parse that string for the component
+      name, and then concatenate the name from the registry.
+    */
+    if (!ma_is_guid_null(&pCaps->NameGuid)) {
+        WCHAR guidStrW[256];
+        if (((MA_PFN_StringFromGUID2)pContext->win32.StringFromGUID2)(&pCaps->NameGuid, guidStrW, ma_countof(guidStrW)) > 0) {
+            char guidStr[256];
+            char keyStr[1024];
+            HKEY hKey;
+
+            WideCharToMultiByte(CP_UTF8, 0, guidStrW, -1, guidStr, sizeof(guidStr), 0, FALSE);
+
+            ma_strcpy_s(keyStr, sizeof(keyStr), "SYSTEM\\CurrentControlSet\\Control\\MediaCategories\\");
+            ma_strcat_s(keyStr, sizeof(keyStr), guidStr);
+
+            if (((MA_PFN_RegOpenKeyExA)pContext->win32.RegOpenKeyExA)(HKEY_LOCAL_MACHINE, keyStr, 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
+                BYTE nameFromReg[512];
+                DWORD nameFromRegSize = sizeof(nameFromReg);
+                LONG resultWin32 = ((MA_PFN_RegQueryValueExA)pContext->win32.RegQueryValueExA)(hKey, "Name", 0, NULL, (BYTE*)nameFromReg, (DWORD*)&nameFromRegSize);
+                ((MA_PFN_RegCloseKey)pContext->win32.RegCloseKey)(hKey);
+
+                if (resultWin32 == ERROR_SUCCESS) {
+                    /* We have the value from the registry, so now we need to construct the name string. */
+                    char name[1024];
+                    if (ma_strcpy_s(name, sizeof(name), pDeviceInfo->name) == 0) {
+                        char* nameBeg = ma_find_last_character(name, '(');
+                        if (nameBeg != NULL) {
+                            size_t leadingLen = (nameBeg - name);
+                            ma_strncpy_s(nameBeg + 1, sizeof(name) - leadingLen, (const char*)nameFromReg, (size_t)-1);
+
+                            /* The closing ")", if it can fit. */
+                            if (leadingLen + nameFromRegSize < sizeof(name)-1) {
+                                ma_strcat_s(name, sizeof(name), ")");
+                            }
+
+                            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), name, (size_t)-1);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+
+    result = ma_get_best_info_from_formats_flags__winmm(pCaps->dwFormats, pCaps->wChannels, &bitsPerSample, &sampleRate);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (bitsPerSample == 8) {
+        pDeviceInfo->nativeDataFormats[0].format = ma_format_u8;
+    } else if (bitsPerSample == 16) {
+        pDeviceInfo->nativeDataFormats[0].format = ma_format_s16;
+    } else if (bitsPerSample == 24) {
+        pDeviceInfo->nativeDataFormats[0].format = ma_format_s24;
+    } else if (bitsPerSample == 32) {
+        pDeviceInfo->nativeDataFormats[0].format = ma_format_s32;
+    } else {
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+    pDeviceInfo->nativeDataFormats[0].channels   = pCaps->wChannels;
+    pDeviceInfo->nativeDataFormats[0].sampleRate = sampleRate;
+    pDeviceInfo->nativeDataFormats[0].flags      = 0;
+    pDeviceInfo->nativeDataFormatCount = 1;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info_from_WAVEOUTCAPS2(ma_context* pContext, MA_WAVEOUTCAPS2A* pCaps, ma_device_info* pDeviceInfo)
+{
+    MA_WAVECAPSA caps;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pCaps != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    MA_COPY_MEMORY(caps.szPname, pCaps->szPname, sizeof(caps.szPname));
+    caps.dwFormats = pCaps->dwFormats;
+    caps.wChannels = pCaps->wChannels;
+    caps.NameGuid  = pCaps->NameGuid;
+    return ma_context_get_device_info_from_WAVECAPS(pContext, &caps, pDeviceInfo);
+}
+
+static ma_result ma_context_get_device_info_from_WAVEINCAPS2(ma_context* pContext, MA_WAVEINCAPS2A* pCaps, ma_device_info* pDeviceInfo)
+{
+    MA_WAVECAPSA caps;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pCaps != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    MA_COPY_MEMORY(caps.szPname, pCaps->szPname, sizeof(caps.szPname));
+    caps.dwFormats = pCaps->dwFormats;
+    caps.wChannels = pCaps->wChannels;
+    caps.NameGuid  = pCaps->NameGuid;
+    return ma_context_get_device_info_from_WAVECAPS(pContext, &caps, pDeviceInfo);
+}
+
+
+static ma_result ma_context_enumerate_devices__winmm(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    UINT playbackDeviceCount;
+    UINT captureDeviceCount;
+    UINT iPlaybackDevice;
+    UINT iCaptureDevice;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Playback. */
+    playbackDeviceCount = ((MA_PFN_waveOutGetNumDevs)pContext->winmm.waveOutGetNumDevs)();
+    for (iPlaybackDevice = 0; iPlaybackDevice < playbackDeviceCount; ++iPlaybackDevice) {
+        MA_MMRESULT result;
+        MA_WAVEOUTCAPS2A caps;
+
+        MA_ZERO_OBJECT(&caps);
+
+        result = ((MA_PFN_waveOutGetDevCapsA)pContext->winmm.waveOutGetDevCapsA)(iPlaybackDevice, (MA_WAVEOUTCAPSA*)&caps, sizeof(caps));
+        if (result == MA_MMSYSERR_NOERROR) {
+            ma_device_info deviceInfo;
+
+            MA_ZERO_OBJECT(&deviceInfo);
+            deviceInfo.id.winmm = iPlaybackDevice;
+
+            /* The first enumerated device is the default device. */
+            if (iPlaybackDevice == 0) {
+                deviceInfo.isDefault = MA_TRUE;
+            }
+
+            if (ma_context_get_device_info_from_WAVEOUTCAPS2(pContext, &caps, &deviceInfo) == MA_SUCCESS) {
+                ma_bool32 cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+                if (cbResult == MA_FALSE) {
+                    return MA_SUCCESS; /* Enumeration was stopped. */
+                }
+            }
+        }
+    }
+
+    /* Capture. */
+    captureDeviceCount = ((MA_PFN_waveInGetNumDevs)pContext->winmm.waveInGetNumDevs)();
+    for (iCaptureDevice = 0; iCaptureDevice < captureDeviceCount; ++iCaptureDevice) {
+        MA_MMRESULT result;
+        MA_WAVEINCAPS2A caps;
+
+        MA_ZERO_OBJECT(&caps);
+
+        result = ((MA_PFN_waveInGetDevCapsA)pContext->winmm.waveInGetDevCapsA)(iCaptureDevice, (MA_WAVEINCAPSA*)&caps, sizeof(caps));
+        if (result == MA_MMSYSERR_NOERROR) {
+            ma_device_info deviceInfo;
+
+            MA_ZERO_OBJECT(&deviceInfo);
+            deviceInfo.id.winmm = iCaptureDevice;
+
+            /* The first enumerated device is the default device. */
+            if (iCaptureDevice == 0) {
+                deviceInfo.isDefault = MA_TRUE;
+            }
+
+            if (ma_context_get_device_info_from_WAVEINCAPS2(pContext, &caps, &deviceInfo) == MA_SUCCESS) {
+                ma_bool32 cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+                if (cbResult == MA_FALSE) {
+                    return MA_SUCCESS; /* Enumeration was stopped. */
+                }
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__winmm(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    UINT winMMDeviceID;
+
+    MA_ASSERT(pContext != NULL);
+
+    winMMDeviceID = 0;
+    if (pDeviceID != NULL) {
+        winMMDeviceID = (UINT)pDeviceID->winmm;
+    }
+
+    pDeviceInfo->id.winmm = winMMDeviceID;
+
+    /* The first ID is the default device. */
+    if (winMMDeviceID == 0) {
+        pDeviceInfo->isDefault = MA_TRUE;
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        MA_MMRESULT result;
+        MA_WAVEOUTCAPS2A caps;
+
+        MA_ZERO_OBJECT(&caps);
+
+        result = ((MA_PFN_waveOutGetDevCapsA)pContext->winmm.waveOutGetDevCapsA)(winMMDeviceID, (MA_WAVEOUTCAPSA*)&caps, sizeof(caps));
+        if (result == MA_MMSYSERR_NOERROR) {
+            return ma_context_get_device_info_from_WAVEOUTCAPS2(pContext, &caps, pDeviceInfo);
+        }
+    } else {
+        MA_MMRESULT result;
+        MA_WAVEINCAPS2A caps;
+
+        MA_ZERO_OBJECT(&caps);
+
+        result = ((MA_PFN_waveInGetDevCapsA)pContext->winmm.waveInGetDevCapsA)(winMMDeviceID, (MA_WAVEINCAPSA*)&caps, sizeof(caps));
+        if (result == MA_MMSYSERR_NOERROR) {
+            return ma_context_get_device_info_from_WAVEINCAPS2(pContext, &caps, pDeviceInfo);
+        }
+    }
+
+    return MA_NO_DEVICE;
+}
+
+
+static ma_result ma_device_uninit__winmm(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((MA_PFN_waveInClose)pDevice->pContext->winmm.waveInClose)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture);
+        CloseHandle((HANDLE)pDevice->winmm.hEventCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ((MA_PFN_waveOutReset)pDevice->pContext->winmm.waveOutReset)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback);
+        ((MA_PFN_waveOutClose)pDevice->pContext->winmm.waveOutClose)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback);
+        CloseHandle((HANDLE)pDevice->winmm.hEventPlayback);
+    }
+
+    ma_free(pDevice->winmm._pHeapData, &pDevice->pContext->allocationCallbacks);
+
+    MA_ZERO_OBJECT(&pDevice->winmm);   /* Safety. */
+
+    return MA_SUCCESS;
+}
+
+static ma_uint32 ma_calculate_period_size_in_frames_from_descriptor__winmm(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+    /* WinMM has a minimum period size of 40ms. */
+    ma_uint32 minPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(40, nativeSampleRate);
+    ma_uint32 periodSizeInFrames;
+
+    periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, nativeSampleRate, performanceProfile);
+    if (periodSizeInFrames < minPeriodSizeInFrames) {
+        periodSizeInFrames = minPeriodSizeInFrames;
+    }
+
+    return periodSizeInFrames;
+}
+
+static ma_result ma_device_init__winmm(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    const char* errorMsg = "";
+    ma_result errorCode = MA_ERROR;
+    ma_result result = MA_SUCCESS;
+    ma_uint32 heapSize;
+    UINT winMMDeviceIDPlayback = 0;
+    UINT winMMDeviceIDCapture  = 0;
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->winmm);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* No exlusive mode with WinMM. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    if (pDescriptorPlayback->pDeviceID != NULL) {
+        winMMDeviceIDPlayback = (UINT)pDescriptorPlayback->pDeviceID->winmm;
+    }
+    if (pDescriptorCapture->pDeviceID != NULL) {
+        winMMDeviceIDCapture = (UINT)pDescriptorCapture->pDeviceID->winmm;
+    }
+
+    /* The capture device needs to be initialized first. */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        MA_WAVEINCAPSA caps;
+        MA_WAVEFORMATEX wf;
+        MA_MMRESULT resultMM;
+
+        /* We use an event to know when a new fragment needs to be enqueued. */
+        pDevice->winmm.hEventCapture = (ma_handle)CreateEventA(NULL, TRUE, TRUE, NULL);
+        if (pDevice->winmm.hEventCapture == NULL) {
+            errorMsg = "[WinMM] Failed to create event for fragment enqueing for the capture device.", errorCode = ma_result_from_GetLastError(GetLastError());
+            goto on_error;
+        }
+
+        /* The format should be based on the device's actual format. */
+        if (((MA_PFN_waveInGetDevCapsA)pDevice->pContext->winmm.waveInGetDevCapsA)(winMMDeviceIDCapture, &caps, sizeof(caps)) != MA_MMSYSERR_NOERROR) {
+            errorMsg = "[WinMM] Failed to retrieve internal device caps.", errorCode = MA_FORMAT_NOT_SUPPORTED;
+            goto on_error;
+        }
+
+        result = ma_formats_flags_to_WAVEFORMATEX__winmm(caps.dwFormats, caps.wChannels, &wf);
+        if (result != MA_SUCCESS) {
+            errorMsg = "[WinMM] Could not find appropriate format for internal device.", errorCode = result;
+            goto on_error;
+        }
+
+        resultMM = ((MA_PFN_waveInOpen)pDevice->pContext->winmm.waveInOpen)((MA_HWAVEIN*)&pDevice->winmm.hDeviceCapture, winMMDeviceIDCapture, &wf, (DWORD_PTR)pDevice->winmm.hEventCapture, (DWORD_PTR)pDevice, MA_CALLBACK_EVENT | MA_WAVE_ALLOWSYNC);
+        if (resultMM != MA_MMSYSERR_NOERROR) {
+            errorMsg = "[WinMM] Failed to open capture device.", errorCode = MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+            goto on_error;
+        }
+
+        pDescriptorCapture->format             = ma_format_from_WAVEFORMATEX(&wf);
+        pDescriptorCapture->channels           = wf.nChannels;
+        pDescriptorCapture->sampleRate         = wf.nSamplesPerSec;
+        ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pDescriptorCapture->channelMap, ma_countof(pDescriptorCapture->channelMap), pDescriptorCapture->channels);
+        pDescriptorCapture->periodCount        = pDescriptorCapture->periodCount;
+        pDescriptorCapture->periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__winmm(pDescriptorCapture, pDescriptorCapture->sampleRate, pConfig->performanceProfile);
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        MA_WAVEOUTCAPSA caps;
+        MA_WAVEFORMATEX wf;
+        MA_MMRESULT resultMM;
+
+        /* We use an event to know when a new fragment needs to be enqueued. */
+        pDevice->winmm.hEventPlayback = (ma_handle)CreateEventA(NULL, TRUE, TRUE, NULL);
+        if (pDevice->winmm.hEventPlayback == NULL) {
+            errorMsg = "[WinMM] Failed to create event for fragment enqueing for the playback device.", errorCode = ma_result_from_GetLastError(GetLastError());
+            goto on_error;
+        }
+
+        /* The format should be based on the device's actual format. */
+        if (((MA_PFN_waveOutGetDevCapsA)pDevice->pContext->winmm.waveOutGetDevCapsA)(winMMDeviceIDPlayback, &caps, sizeof(caps)) != MA_MMSYSERR_NOERROR) {
+            errorMsg = "[WinMM] Failed to retrieve internal device caps.", errorCode = MA_FORMAT_NOT_SUPPORTED;
+            goto on_error;
+        }
+
+        result = ma_formats_flags_to_WAVEFORMATEX__winmm(caps.dwFormats, caps.wChannels, &wf);
+        if (result != MA_SUCCESS) {
+            errorMsg = "[WinMM] Could not find appropriate format for internal device.", errorCode = result;
+            goto on_error;
+        }
+
+        resultMM = ((MA_PFN_waveOutOpen)pDevice->pContext->winmm.waveOutOpen)((MA_HWAVEOUT*)&pDevice->winmm.hDevicePlayback, winMMDeviceIDPlayback, &wf, (DWORD_PTR)pDevice->winmm.hEventPlayback, (DWORD_PTR)pDevice, MA_CALLBACK_EVENT | MA_WAVE_ALLOWSYNC);
+        if (resultMM != MA_MMSYSERR_NOERROR) {
+            errorMsg = "[WinMM] Failed to open playback device.", errorCode = MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+            goto on_error;
+        }
+
+        pDescriptorPlayback->format             = ma_format_from_WAVEFORMATEX(&wf);
+        pDescriptorPlayback->channels           = wf.nChannels;
+        pDescriptorPlayback->sampleRate         = wf.nSamplesPerSec;
+        ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pDescriptorPlayback->channelMap, ma_countof(pDescriptorPlayback->channelMap), pDescriptorPlayback->channels);
+        pDescriptorPlayback->periodCount        = pDescriptorPlayback->periodCount;
+        pDescriptorPlayback->periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__winmm(pDescriptorPlayback, pDescriptorPlayback->sampleRate, pConfig->performanceProfile);
+    }
+
+    /*
+    The heap allocated data is allocated like so:
+
+    [Capture WAVEHDRs][Playback WAVEHDRs][Capture Intermediary Buffer][Playback Intermediary Buffer]
+    */
+    heapSize = 0;
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        heapSize += sizeof(MA_WAVEHDR)*pDescriptorCapture->periodCount + (pDescriptorCapture->periodSizeInFrames * pDescriptorCapture->periodCount * ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels));
+    }
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        heapSize += sizeof(MA_WAVEHDR)*pDescriptorPlayback->periodCount + (pDescriptorPlayback->periodSizeInFrames * pDescriptorPlayback->periodCount * ma_get_bytes_per_frame(pDescriptorPlayback->format, pDescriptorPlayback->channels));
+    }
+
+    pDevice->winmm._pHeapData = (ma_uint8*)ma_calloc(heapSize, &pDevice->pContext->allocationCallbacks);
+    if (pDevice->winmm._pHeapData == NULL) {
+        errorMsg = "[WinMM] Failed to allocate memory for the intermediary buffer.", errorCode = MA_OUT_OF_MEMORY;
+        goto on_error;
+    }
+
+    MA_ZERO_MEMORY(pDevice->winmm._pHeapData, heapSize);
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_uint32 iPeriod;
+
+        if (pConfig->deviceType == ma_device_type_capture) {
+            pDevice->winmm.pWAVEHDRCapture            = pDevice->winmm._pHeapData;
+            pDevice->winmm.pIntermediaryBufferCapture = pDevice->winmm._pHeapData + (sizeof(MA_WAVEHDR)*(pDescriptorCapture->periodCount));
+        } else {
+            pDevice->winmm.pWAVEHDRCapture            = pDevice->winmm._pHeapData;
+            pDevice->winmm.pIntermediaryBufferCapture = pDevice->winmm._pHeapData + (sizeof(MA_WAVEHDR)*(pDescriptorCapture->periodCount + pDescriptorPlayback->periodCount));
+        }
+
+        /* Prepare headers. */
+        for (iPeriod = 0; iPeriod < pDescriptorCapture->periodCount; ++iPeriod) {
+            ma_uint32 periodSizeInBytes = ma_get_period_size_in_bytes(pDescriptorCapture->periodSizeInFrames, pDescriptorCapture->format, pDescriptorCapture->channels);
+
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod].lpData         = (char*)(pDevice->winmm.pIntermediaryBufferCapture + (periodSizeInBytes*iPeriod));
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod].dwBufferLength = periodSizeInBytes;
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod].dwFlags        = 0L;
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod].dwLoops        = 0L;
+            ((MA_PFN_waveInPrepareHeader)pDevice->pContext->winmm.waveInPrepareHeader)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod], sizeof(MA_WAVEHDR));
+
+            /*
+            The user data of the MA_WAVEHDR structure is a single flag the controls whether or not it is ready for writing. Consider it to be named "isLocked". A value of 0 means
+            it's unlocked and available for writing. A value of 1 means it's locked.
+            */
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod].dwUser = 0;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_uint32 iPeriod;
+
+        if (pConfig->deviceType == ma_device_type_playback) {
+            pDevice->winmm.pWAVEHDRPlayback            = pDevice->winmm._pHeapData;
+            pDevice->winmm.pIntermediaryBufferPlayback = pDevice->winmm._pHeapData + (sizeof(MA_WAVEHDR)*pDescriptorPlayback->periodCount);
+        } else {
+            pDevice->winmm.pWAVEHDRPlayback            = pDevice->winmm._pHeapData + (sizeof(MA_WAVEHDR)*(pDescriptorCapture->periodCount));
+            pDevice->winmm.pIntermediaryBufferPlayback = pDevice->winmm._pHeapData + (sizeof(MA_WAVEHDR)*(pDescriptorCapture->periodCount + pDescriptorPlayback->periodCount)) + (pDescriptorCapture->periodSizeInFrames*pDescriptorCapture->periodCount*ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels));
+        }
+
+        /* Prepare headers. */
+        for (iPeriod = 0; iPeriod < pDescriptorPlayback->periodCount; ++iPeriod) {
+            ma_uint32 periodSizeInBytes = ma_get_period_size_in_bytes(pDescriptorPlayback->periodSizeInFrames, pDescriptorPlayback->format, pDescriptorPlayback->channels);
+
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod].lpData         = (char*)(pDevice->winmm.pIntermediaryBufferPlayback + (periodSizeInBytes*iPeriod));
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod].dwBufferLength = periodSizeInBytes;
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod].dwFlags        = 0L;
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod].dwLoops        = 0L;
+            ((MA_PFN_waveOutPrepareHeader)pDevice->pContext->winmm.waveOutPrepareHeader)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod], sizeof(MA_WAVEHDR));
+
+            /*
+            The user data of the MA_WAVEHDR structure is a single flag the controls whether or not it is ready for writing. Consider it to be named "isLocked". A value of 0 means
+            it's unlocked and available for writing. A value of 1 means it's locked.
+            */
+            ((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod].dwUser = 0;
+        }
+    }
+
+    return MA_SUCCESS;
+
+on_error:
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->winmm.pWAVEHDRCapture != NULL) {
+            ma_uint32 iPeriod;
+            for (iPeriod = 0; iPeriod < pDescriptorCapture->periodCount; ++iPeriod) {
+                ((MA_PFN_waveInUnprepareHeader)pDevice->pContext->winmm.waveInUnprepareHeader)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod], sizeof(MA_WAVEHDR));
+            }
+        }
+
+        ((MA_PFN_waveInClose)pDevice->pContext->winmm.waveInClose)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->winmm.pWAVEHDRCapture != NULL) {
+            ma_uint32 iPeriod;
+            for (iPeriod = 0; iPeriod < pDescriptorPlayback->periodCount; ++iPeriod) {
+                ((MA_PFN_waveOutUnprepareHeader)pDevice->pContext->winmm.waveOutUnprepareHeader)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback)[iPeriod], sizeof(MA_WAVEHDR));
+            }
+        }
+
+        ((MA_PFN_waveOutClose)pDevice->pContext->winmm.waveOutClose)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback);
+    }
+
+    ma_free(pDevice->winmm._pHeapData, &pDevice->pContext->allocationCallbacks);
+
+    if (errorMsg != NULL && errorMsg[0] != '\0') {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "%s", errorMsg);
+    }
+
+    return errorCode;
+}
+
+static ma_result ma_device_start__winmm(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        MA_MMRESULT resultMM;
+        MA_WAVEHDR* pWAVEHDR;
+        ma_uint32 iPeriod;
+
+        pWAVEHDR = (MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture;
+
+        /* Make sure the event is reset to a non-signaled state to ensure we don't prematurely return from WaitForSingleObject(). */
+        ResetEvent((HANDLE)pDevice->winmm.hEventCapture);
+
+        /* To start the device we attach all of the buffers and then start it. As the buffers are filled with data we will get notifications. */
+        for (iPeriod = 0; iPeriod < pDevice->capture.internalPeriods; ++iPeriod) {
+            resultMM = ((MA_PFN_waveInAddBuffer)pDevice->pContext->winmm.waveInAddBuffer)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[iPeriod], sizeof(MA_WAVEHDR));
+            if (resultMM != MA_MMSYSERR_NOERROR) {
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WinMM] Failed to attach input buffers to capture device in preparation for capture.");
+                return ma_result_from_MMRESULT(resultMM);
+            }
+
+            /* Make sure all of the buffers start out locked. We don't want to access them until the backend tells us we can. */
+            pWAVEHDR[iPeriod].dwUser = 1;   /* 1 = locked. */
+        }
+
+        /* Capture devices need to be explicitly started, unlike playback devices. */
+        resultMM = ((MA_PFN_waveInStart)pDevice->pContext->winmm.waveInStart)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture);
+        if (resultMM != MA_MMSYSERR_NOERROR) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WinMM] Failed to start backend device.");
+            return ma_result_from_MMRESULT(resultMM);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /* Don't need to do anything for playback. It'll be started automatically in ma_device_start__winmm(). */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__winmm(ma_device* pDevice)
+{
+    MA_MMRESULT resultMM;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->winmm.hDeviceCapture == NULL) {
+            return MA_INVALID_ARGS;
+        }
+
+        resultMM = ((MA_PFN_waveInReset)pDevice->pContext->winmm.waveInReset)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture);
+        if (resultMM != MA_MMSYSERR_NOERROR) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[WinMM] WARNING: Failed to reset capture device.");
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_uint32 iPeriod;
+        MA_WAVEHDR* pWAVEHDR;
+
+        if (pDevice->winmm.hDevicePlayback == NULL) {
+            return MA_INVALID_ARGS;
+        }
+
+        /* We need to drain the device. To do this we just loop over each header and if it's locked just wait for the event. */
+        pWAVEHDR = (MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback;
+        for (iPeriod = 0; iPeriod < pDevice->playback.internalPeriods; iPeriod += 1) {
+            if (pWAVEHDR[iPeriod].dwUser == 1) { /* 1 = locked. */
+                if (WaitForSingleObject((HANDLE)pDevice->winmm.hEventPlayback, INFINITE) != WAIT_OBJECT_0) {
+                    break;  /* An error occurred so just abandon ship and stop the device without draining. */
+                }
+
+                pWAVEHDR[iPeriod].dwUser = 0;
+            }
+        }
+
+        resultMM = ((MA_PFN_waveOutReset)pDevice->pContext->winmm.waveOutReset)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback);
+        if (resultMM != MA_MMSYSERR_NOERROR) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[WinMM] WARNING: Failed to reset playback device.");
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_write__winmm(ma_device* pDevice, const void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    ma_result result = MA_SUCCESS;
+    MA_MMRESULT resultMM;
+    ma_uint32 totalFramesWritten;
+    MA_WAVEHDR* pWAVEHDR;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pPCMFrames != NULL);
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    pWAVEHDR = (MA_WAVEHDR*)pDevice->winmm.pWAVEHDRPlayback;
+
+    /* Keep processing as much data as possible. */
+    totalFramesWritten = 0;
+    while (totalFramesWritten < frameCount) {
+        /* If the current header has some space available we need to write part of it. */
+        if (pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwUser == 0) { /* 0 = unlocked. */
+            /*
+            This header has room in it. We copy as much of it as we can. If we end up fully consuming the buffer we need to
+            write it out and move on to the next iteration.
+            */
+            ma_uint32 bpf = ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+            ma_uint32 framesRemainingInHeader = (pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwBufferLength/bpf) - pDevice->winmm.headerFramesConsumedPlayback;
+
+            ma_uint32 framesToCopy = ma_min(framesRemainingInHeader, (frameCount - totalFramesWritten));
+            const void* pSrc = ma_offset_ptr(pPCMFrames, totalFramesWritten*bpf);
+            void* pDst = ma_offset_ptr(pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].lpData, pDevice->winmm.headerFramesConsumedPlayback*bpf);
+            MA_COPY_MEMORY(pDst, pSrc, framesToCopy*bpf);
+
+            pDevice->winmm.headerFramesConsumedPlayback += framesToCopy;
+            totalFramesWritten += framesToCopy;
+
+            /* If we've consumed the buffer entirely we need to write it out to the device. */
+            if (pDevice->winmm.headerFramesConsumedPlayback == (pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwBufferLength/bpf)) {
+                pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwUser = 1;            /* 1 = locked. */
+                pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwFlags &= ~MA_WHDR_DONE; /* <-- Need to make sure the WHDR_DONE flag is unset. */
+
+                /* Make sure the event is reset to a non-signaled state to ensure we don't prematurely return from WaitForSingleObject(). */
+                ResetEvent((HANDLE)pDevice->winmm.hEventPlayback);
+
+                /* The device will be started here. */
+                resultMM = ((MA_PFN_waveOutWrite)pDevice->pContext->winmm.waveOutWrite)((MA_HWAVEOUT)pDevice->winmm.hDevicePlayback, &pWAVEHDR[pDevice->winmm.iNextHeaderPlayback], sizeof(MA_WAVEHDR));
+                if (resultMM != MA_MMSYSERR_NOERROR) {
+                    result = ma_result_from_MMRESULT(resultMM);
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WinMM] waveOutWrite() failed.");
+                    break;
+                }
+
+                /* Make sure we move to the next header. */
+                pDevice->winmm.iNextHeaderPlayback = (pDevice->winmm.iNextHeaderPlayback + 1) % pDevice->playback.internalPeriods;
+                pDevice->winmm.headerFramesConsumedPlayback = 0;
+            }
+
+            /* If at this point we have consumed the entire input buffer we can return. */
+            MA_ASSERT(totalFramesWritten <= frameCount);
+            if (totalFramesWritten == frameCount) {
+                break;
+            }
+
+            /* Getting here means there's more to process. */
+            continue;
+        }
+
+        /* Getting here means there isn't enough room in the buffer and we need to wait for one to become available. */
+        if (WaitForSingleObject((HANDLE)pDevice->winmm.hEventPlayback, INFINITE) != WAIT_OBJECT_0) {
+            result = MA_ERROR;
+            break;
+        }
+
+        /* Something happened. If the next buffer has been marked as done we need to reset a bit of state. */
+        if ((pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwFlags & MA_WHDR_DONE) != 0) {
+            pWAVEHDR[pDevice->winmm.iNextHeaderPlayback].dwUser = 0;    /* 0 = unlocked (make it available for writing). */
+            pDevice->winmm.headerFramesConsumedPlayback = 0;
+        }
+
+        /* If the device has been stopped we need to break. */
+        if (ma_device_get_state(pDevice) != ma_device_state_started) {
+            break;
+        }
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = totalFramesWritten;
+    }
+
+    return result;
+}
+
+static ma_result ma_device_read__winmm(ma_device* pDevice, void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    MA_MMRESULT resultMM;
+    ma_uint32 totalFramesRead;
+    MA_WAVEHDR* pWAVEHDR;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pPCMFrames != NULL);
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    pWAVEHDR = (MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture;
+
+    /* Keep processing as much data as possible. */
+    totalFramesRead = 0;
+    while (totalFramesRead < frameCount) {
+        /* If the current header has some space available we need to write part of it. */
+        if (pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwUser == 0) { /* 0 = unlocked. */
+            /* The buffer is available for reading. If we fully consume it we need to add it back to the buffer. */
+            ma_uint32 bpf = ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+            ma_uint32 framesRemainingInHeader = (pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwBufferLength/bpf) - pDevice->winmm.headerFramesConsumedCapture;
+
+            ma_uint32 framesToCopy = ma_min(framesRemainingInHeader, (frameCount - totalFramesRead));
+            const void* pSrc = ma_offset_ptr(pWAVEHDR[pDevice->winmm.iNextHeaderCapture].lpData, pDevice->winmm.headerFramesConsumedCapture*bpf);
+            void* pDst = ma_offset_ptr(pPCMFrames, totalFramesRead*bpf);
+            MA_COPY_MEMORY(pDst, pSrc, framesToCopy*bpf);
+
+            pDevice->winmm.headerFramesConsumedCapture += framesToCopy;
+            totalFramesRead += framesToCopy;
+
+            /* If we've consumed the buffer entirely we need to add it back to the device. */
+            if (pDevice->winmm.headerFramesConsumedCapture == (pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwBufferLength/bpf)) {
+                pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwUser = 1;            /* 1 = locked. */
+                pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwFlags &= ~MA_WHDR_DONE; /* <-- Need to make sure the WHDR_DONE flag is unset. */
+
+                /* Make sure the event is reset to a non-signaled state to ensure we don't prematurely return from WaitForSingleObject(). */
+                ResetEvent((HANDLE)pDevice->winmm.hEventCapture);
+
+                /* The device will be started here. */
+                resultMM = ((MA_PFN_waveInAddBuffer)pDevice->pContext->winmm.waveInAddBuffer)((MA_HWAVEIN)pDevice->winmm.hDeviceCapture, &((MA_WAVEHDR*)pDevice->winmm.pWAVEHDRCapture)[pDevice->winmm.iNextHeaderCapture], sizeof(MA_WAVEHDR));
+                if (resultMM != MA_MMSYSERR_NOERROR) {
+                    result = ma_result_from_MMRESULT(resultMM);
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[WinMM] waveInAddBuffer() failed.");
+                    break;
+                }
+
+                /* Make sure we move to the next header. */
+                pDevice->winmm.iNextHeaderCapture = (pDevice->winmm.iNextHeaderCapture + 1) % pDevice->capture.internalPeriods;
+                pDevice->winmm.headerFramesConsumedCapture = 0;
+            }
+
+            /* If at this point we have filled the entire input buffer we can return. */
+            MA_ASSERT(totalFramesRead <= frameCount);
+            if (totalFramesRead == frameCount) {
+                break;
+            }
+
+            /* Getting here means there's more to process. */
+            continue;
+        }
+
+        /* Getting here means there isn't enough any data left to send to the client which means we need to wait for more. */
+        if (WaitForSingleObject((HANDLE)pDevice->winmm.hEventCapture, INFINITE) != WAIT_OBJECT_0) {
+            result = MA_ERROR;
+            break;
+        }
+
+        /* Something happened. If the next buffer has been marked as done we need to reset a bit of state. */
+        if ((pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwFlags & MA_WHDR_DONE) != 0) {
+            pWAVEHDR[pDevice->winmm.iNextHeaderCapture].dwUser = 0;    /* 0 = unlocked (make it available for reading). */
+            pDevice->winmm.headerFramesConsumedCapture = 0;
+        }
+
+        /* If the device has been stopped we need to break. */
+        if (ma_device_get_state(pDevice) != ma_device_state_started) {
+            break;
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesRead;
+    }
+
+    return result;
+}
+
+static ma_result ma_context_uninit__winmm(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_winmm);
+
+    ma_dlclose(ma_context_get_log(pContext), pContext->winmm.hWinMM);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__winmm(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+    pContext->winmm.hWinMM = ma_dlopen(ma_context_get_log(pContext), "winmm.dll");
+    if (pContext->winmm.hWinMM == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    pContext->winmm.waveOutGetNumDevs      = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutGetNumDevs");
+    pContext->winmm.waveOutGetDevCapsA     = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutGetDevCapsA");
+    pContext->winmm.waveOutOpen            = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutOpen");
+    pContext->winmm.waveOutClose           = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutClose");
+    pContext->winmm.waveOutPrepareHeader   = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutPrepareHeader");
+    pContext->winmm.waveOutUnprepareHeader = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutUnprepareHeader");
+    pContext->winmm.waveOutWrite           = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutWrite");
+    pContext->winmm.waveOutReset           = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveOutReset");
+    pContext->winmm.waveInGetNumDevs       = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInGetNumDevs");
+    pContext->winmm.waveInGetDevCapsA      = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInGetDevCapsA");
+    pContext->winmm.waveInOpen             = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInOpen");
+    pContext->winmm.waveInClose            = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInClose");
+    pContext->winmm.waveInPrepareHeader    = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInPrepareHeader");
+    pContext->winmm.waveInUnprepareHeader  = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInUnprepareHeader");
+    pContext->winmm.waveInAddBuffer        = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInAddBuffer");
+    pContext->winmm.waveInStart            = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInStart");
+    pContext->winmm.waveInReset            = ma_dlsym(ma_context_get_log(pContext), pContext->winmm.hWinMM, "waveInReset");
+
+    pCallbacks->onContextInit             = ma_context_init__winmm;
+    pCallbacks->onContextUninit           = ma_context_uninit__winmm;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__winmm;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__winmm;
+    pCallbacks->onDeviceInit              = ma_device_init__winmm;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__winmm;
+    pCallbacks->onDeviceStart             = ma_device_start__winmm;
+    pCallbacks->onDeviceStop              = ma_device_stop__winmm;
+    pCallbacks->onDeviceRead              = ma_device_read__winmm;
+    pCallbacks->onDeviceWrite             = ma_device_write__winmm;
+    pCallbacks->onDeviceDataLoop          = NULL;   /* This is a blocking read-write API, so this can be NULL since miniaudio will manage the audio thread for us. */
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+
+
+/******************************************************************************
+
+ALSA Backend
+
+******************************************************************************/
+#ifdef MA_HAS_ALSA
+
+#include <poll.h>           /* poll(), struct pollfd */
+#include <sys/eventfd.h>    /* eventfd() */
+
+#ifdef MA_NO_RUNTIME_LINKING
+
+/* asoundlib.h marks some functions with "inline" which isn't always supported. Need to emulate it. */
+#if !defined(__cplusplus)
+    #if defined(__STRICT_ANSI__)
+        #if !defined(inline)
+            #define inline __inline__ __attribute__((always_inline))
+            #define MA_INLINE_DEFINED
+        #endif
+    #endif
+#endif
+#include <alsa/asoundlib.h>
+#if defined(MA_INLINE_DEFINED)
+    #undef inline
+    #undef MA_INLINE_DEFINED
+#endif
+
+typedef snd_pcm_uframes_t                       ma_snd_pcm_uframes_t;
+typedef snd_pcm_sframes_t                       ma_snd_pcm_sframes_t;
+typedef snd_pcm_stream_t                        ma_snd_pcm_stream_t;
+typedef snd_pcm_format_t                        ma_snd_pcm_format_t;
+typedef snd_pcm_access_t                        ma_snd_pcm_access_t;
+typedef snd_pcm_t                               ma_snd_pcm_t;
+typedef snd_pcm_hw_params_t                     ma_snd_pcm_hw_params_t;
+typedef snd_pcm_sw_params_t                     ma_snd_pcm_sw_params_t;
+typedef snd_pcm_format_mask_t                   ma_snd_pcm_format_mask_t;
+typedef snd_pcm_info_t                          ma_snd_pcm_info_t;
+typedef snd_pcm_channel_area_t                  ma_snd_pcm_channel_area_t;
+typedef snd_pcm_chmap_t                         ma_snd_pcm_chmap_t;
+typedef snd_pcm_state_t                         ma_snd_pcm_state_t;
+
+/* snd_pcm_stream_t */
+#define MA_SND_PCM_STREAM_PLAYBACK              SND_PCM_STREAM_PLAYBACK
+#define MA_SND_PCM_STREAM_CAPTURE               SND_PCM_STREAM_CAPTURE
+
+/* snd_pcm_format_t */
+#define MA_SND_PCM_FORMAT_UNKNOWN               SND_PCM_FORMAT_UNKNOWN
+#define MA_SND_PCM_FORMAT_U8                    SND_PCM_FORMAT_U8
+#define MA_SND_PCM_FORMAT_S16_LE                SND_PCM_FORMAT_S16_LE
+#define MA_SND_PCM_FORMAT_S16_BE                SND_PCM_FORMAT_S16_BE
+#define MA_SND_PCM_FORMAT_S24_LE                SND_PCM_FORMAT_S24_LE
+#define MA_SND_PCM_FORMAT_S24_BE                SND_PCM_FORMAT_S24_BE
+#define MA_SND_PCM_FORMAT_S32_LE                SND_PCM_FORMAT_S32_LE
+#define MA_SND_PCM_FORMAT_S32_BE                SND_PCM_FORMAT_S32_BE
+#define MA_SND_PCM_FORMAT_FLOAT_LE              SND_PCM_FORMAT_FLOAT_LE
+#define MA_SND_PCM_FORMAT_FLOAT_BE              SND_PCM_FORMAT_FLOAT_BE
+#define MA_SND_PCM_FORMAT_FLOAT64_LE            SND_PCM_FORMAT_FLOAT64_LE
+#define MA_SND_PCM_FORMAT_FLOAT64_BE            SND_PCM_FORMAT_FLOAT64_BE
+#define MA_SND_PCM_FORMAT_MU_LAW                SND_PCM_FORMAT_MU_LAW
+#define MA_SND_PCM_FORMAT_A_LAW                 SND_PCM_FORMAT_A_LAW
+#define MA_SND_PCM_FORMAT_S24_3LE               SND_PCM_FORMAT_S24_3LE
+#define MA_SND_PCM_FORMAT_S24_3BE               SND_PCM_FORMAT_S24_3BE
+
+/* ma_snd_pcm_access_t */
+#define MA_SND_PCM_ACCESS_MMAP_INTERLEAVED      SND_PCM_ACCESS_MMAP_INTERLEAVED
+#define MA_SND_PCM_ACCESS_MMAP_NONINTERLEAVED   SND_PCM_ACCESS_MMAP_NONINTERLEAVED
+#define MA_SND_PCM_ACCESS_MMAP_COMPLEX          SND_PCM_ACCESS_MMAP_COMPLEX
+#define MA_SND_PCM_ACCESS_RW_INTERLEAVED        SND_PCM_ACCESS_RW_INTERLEAVED
+#define MA_SND_PCM_ACCESS_RW_NONINTERLEAVED     SND_PCM_ACCESS_RW_NONINTERLEAVED
+
+/* Channel positions. */
+#define MA_SND_CHMAP_UNKNOWN                    SND_CHMAP_UNKNOWN
+#define MA_SND_CHMAP_NA                         SND_CHMAP_NA
+#define MA_SND_CHMAP_MONO                       SND_CHMAP_MONO
+#define MA_SND_CHMAP_FL                         SND_CHMAP_FL
+#define MA_SND_CHMAP_FR                         SND_CHMAP_FR
+#define MA_SND_CHMAP_RL                         SND_CHMAP_RL
+#define MA_SND_CHMAP_RR                         SND_CHMAP_RR
+#define MA_SND_CHMAP_FC                         SND_CHMAP_FC
+#define MA_SND_CHMAP_LFE                        SND_CHMAP_LFE
+#define MA_SND_CHMAP_SL                         SND_CHMAP_SL
+#define MA_SND_CHMAP_SR                         SND_CHMAP_SR
+#define MA_SND_CHMAP_RC                         SND_CHMAP_RC
+#define MA_SND_CHMAP_FLC                        SND_CHMAP_FLC
+#define MA_SND_CHMAP_FRC                        SND_CHMAP_FRC
+#define MA_SND_CHMAP_RLC                        SND_CHMAP_RLC
+#define MA_SND_CHMAP_RRC                        SND_CHMAP_RRC
+#define MA_SND_CHMAP_FLW                        SND_CHMAP_FLW
+#define MA_SND_CHMAP_FRW                        SND_CHMAP_FRW
+#define MA_SND_CHMAP_FLH                        SND_CHMAP_FLH
+#define MA_SND_CHMAP_FCH                        SND_CHMAP_FCH
+#define MA_SND_CHMAP_FRH                        SND_CHMAP_FRH
+#define MA_SND_CHMAP_TC                         SND_CHMAP_TC
+#define MA_SND_CHMAP_TFL                        SND_CHMAP_TFL
+#define MA_SND_CHMAP_TFR                        SND_CHMAP_TFR
+#define MA_SND_CHMAP_TFC                        SND_CHMAP_TFC
+#define MA_SND_CHMAP_TRL                        SND_CHMAP_TRL
+#define MA_SND_CHMAP_TRR                        SND_CHMAP_TRR
+#define MA_SND_CHMAP_TRC                        SND_CHMAP_TRC
+#define MA_SND_CHMAP_TFLC                       SND_CHMAP_TFLC
+#define MA_SND_CHMAP_TFRC                       SND_CHMAP_TFRC
+#define MA_SND_CHMAP_TSL                        SND_CHMAP_TSL
+#define MA_SND_CHMAP_TSR                        SND_CHMAP_TSR
+#define MA_SND_CHMAP_LLFE                       SND_CHMAP_LLFE
+#define MA_SND_CHMAP_RLFE                       SND_CHMAP_RLFE
+#define MA_SND_CHMAP_BC                         SND_CHMAP_BC
+#define MA_SND_CHMAP_BLC                        SND_CHMAP_BLC
+#define MA_SND_CHMAP_BRC                        SND_CHMAP_BRC
+
+/* Open mode flags. */
+#define MA_SND_PCM_NO_AUTO_RESAMPLE             SND_PCM_NO_AUTO_RESAMPLE
+#define MA_SND_PCM_NO_AUTO_CHANNELS             SND_PCM_NO_AUTO_CHANNELS
+#define MA_SND_PCM_NO_AUTO_FORMAT               SND_PCM_NO_AUTO_FORMAT
+#else
+#include <errno.h>  /* For EPIPE, etc. */
+typedef unsigned long                           ma_snd_pcm_uframes_t;
+typedef long                                    ma_snd_pcm_sframes_t;
+typedef int                                     ma_snd_pcm_stream_t;
+typedef int                                     ma_snd_pcm_format_t;
+typedef int                                     ma_snd_pcm_access_t;
+typedef int                                     ma_snd_pcm_state_t;
+typedef struct ma_snd_pcm_t                     ma_snd_pcm_t;
+typedef struct ma_snd_pcm_hw_params_t           ma_snd_pcm_hw_params_t;
+typedef struct ma_snd_pcm_sw_params_t           ma_snd_pcm_sw_params_t;
+typedef struct ma_snd_pcm_format_mask_t         ma_snd_pcm_format_mask_t;
+typedef struct ma_snd_pcm_info_t                ma_snd_pcm_info_t;
+typedef struct
+{
+    void* addr;
+    unsigned int first;
+    unsigned int step;
+} ma_snd_pcm_channel_area_t;
+typedef struct
+{
+    unsigned int channels;
+    unsigned int pos[1];
+} ma_snd_pcm_chmap_t;
+
+/* snd_pcm_state_t */
+#define MA_SND_PCM_STATE_OPEN                  0
+#define MA_SND_PCM_STATE_SETUP                 1
+#define MA_SND_PCM_STATE_PREPARED              2
+#define MA_SND_PCM_STATE_RUNNING               3
+#define MA_SND_PCM_STATE_XRUN                  4
+#define MA_SND_PCM_STATE_DRAINING              5
+#define MA_SND_PCM_STATE_PAUSED                6
+#define MA_SND_PCM_STATE_SUSPENDED             7
+#define MA_SND_PCM_STATE_DISCONNECTED          8
+
+/* snd_pcm_stream_t */
+#define MA_SND_PCM_STREAM_PLAYBACK             0
+#define MA_SND_PCM_STREAM_CAPTURE              1
+
+/* snd_pcm_format_t */
+#define MA_SND_PCM_FORMAT_UNKNOWN              -1
+#define MA_SND_PCM_FORMAT_U8                   1
+#define MA_SND_PCM_FORMAT_S16_LE               2
+#define MA_SND_PCM_FORMAT_S16_BE               3
+#define MA_SND_PCM_FORMAT_S24_LE               6
+#define MA_SND_PCM_FORMAT_S24_BE               7
+#define MA_SND_PCM_FORMAT_S32_LE               10
+#define MA_SND_PCM_FORMAT_S32_BE               11
+#define MA_SND_PCM_FORMAT_FLOAT_LE             14
+#define MA_SND_PCM_FORMAT_FLOAT_BE             15
+#define MA_SND_PCM_FORMAT_FLOAT64_LE           16
+#define MA_SND_PCM_FORMAT_FLOAT64_BE           17
+#define MA_SND_PCM_FORMAT_MU_LAW               20
+#define MA_SND_PCM_FORMAT_A_LAW                21
+#define MA_SND_PCM_FORMAT_S24_3LE              32
+#define MA_SND_PCM_FORMAT_S24_3BE              33
+
+/* snd_pcm_access_t */
+#define MA_SND_PCM_ACCESS_MMAP_INTERLEAVED     0
+#define MA_SND_PCM_ACCESS_MMAP_NONINTERLEAVED  1
+#define MA_SND_PCM_ACCESS_MMAP_COMPLEX         2
+#define MA_SND_PCM_ACCESS_RW_INTERLEAVED       3
+#define MA_SND_PCM_ACCESS_RW_NONINTERLEAVED    4
+
+/* Channel positions. */
+#define MA_SND_CHMAP_UNKNOWN                   0
+#define MA_SND_CHMAP_NA                        1
+#define MA_SND_CHMAP_MONO                      2
+#define MA_SND_CHMAP_FL                        3
+#define MA_SND_CHMAP_FR                        4
+#define MA_SND_CHMAP_RL                        5
+#define MA_SND_CHMAP_RR                        6
+#define MA_SND_CHMAP_FC                        7
+#define MA_SND_CHMAP_LFE                       8
+#define MA_SND_CHMAP_SL                        9
+#define MA_SND_CHMAP_SR                        10
+#define MA_SND_CHMAP_RC                        11
+#define MA_SND_CHMAP_FLC                       12
+#define MA_SND_CHMAP_FRC                       13
+#define MA_SND_CHMAP_RLC                       14
+#define MA_SND_CHMAP_RRC                       15
+#define MA_SND_CHMAP_FLW                       16
+#define MA_SND_CHMAP_FRW                       17
+#define MA_SND_CHMAP_FLH                       18
+#define MA_SND_CHMAP_FCH                       19
+#define MA_SND_CHMAP_FRH                       20
+#define MA_SND_CHMAP_TC                        21
+#define MA_SND_CHMAP_TFL                       22
+#define MA_SND_CHMAP_TFR                       23
+#define MA_SND_CHMAP_TFC                       24
+#define MA_SND_CHMAP_TRL                       25
+#define MA_SND_CHMAP_TRR                       26
+#define MA_SND_CHMAP_TRC                       27
+#define MA_SND_CHMAP_TFLC                      28
+#define MA_SND_CHMAP_TFRC                      29
+#define MA_SND_CHMAP_TSL                       30
+#define MA_SND_CHMAP_TSR                       31
+#define MA_SND_CHMAP_LLFE                      32
+#define MA_SND_CHMAP_RLFE                      33
+#define MA_SND_CHMAP_BC                        34
+#define MA_SND_CHMAP_BLC                       35
+#define MA_SND_CHMAP_BRC                       36
+
+/* Open mode flags. */
+#define MA_SND_PCM_NO_AUTO_RESAMPLE            0x00010000
+#define MA_SND_PCM_NO_AUTO_CHANNELS            0x00020000
+#define MA_SND_PCM_NO_AUTO_FORMAT              0x00040000
+#endif
+
+typedef int                  (* ma_snd_pcm_open_proc)                          (ma_snd_pcm_t **pcm, const char *name, ma_snd_pcm_stream_t stream, int mode);
+typedef int                  (* ma_snd_pcm_close_proc)                         (ma_snd_pcm_t *pcm);
+typedef size_t               (* ma_snd_pcm_hw_params_sizeof_proc)              (void);
+typedef int                  (* ma_snd_pcm_hw_params_any_proc)                 (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params);
+typedef int                  (* ma_snd_pcm_hw_params_set_format_proc)          (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, ma_snd_pcm_format_t val);
+typedef int                  (* ma_snd_pcm_hw_params_set_format_first_proc)    (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, ma_snd_pcm_format_t *format);
+typedef void                 (* ma_snd_pcm_hw_params_get_format_mask_proc)     (ma_snd_pcm_hw_params_t *params, ma_snd_pcm_format_mask_t *mask);
+typedef int                  (* ma_snd_pcm_hw_params_set_channels_proc)        (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int val);
+typedef int                  (* ma_snd_pcm_hw_params_set_channels_near_proc)   (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int *val);
+typedef int                  (* ma_snd_pcm_hw_params_set_channels_minmax_proc) (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int *minimum, unsigned int *maximum);
+typedef int                  (* ma_snd_pcm_hw_params_set_rate_resample_proc)   (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int val);
+typedef int                  (* ma_snd_pcm_hw_params_set_rate_proc)            (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int val, int dir);
+typedef int                  (* ma_snd_pcm_hw_params_set_rate_near_proc)       (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_set_buffer_size_near_proc)(ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, ma_snd_pcm_uframes_t *val);
+typedef int                  (* ma_snd_pcm_hw_params_set_periods_near_proc)    (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_set_access_proc)          (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, ma_snd_pcm_access_t _access);
+typedef int                  (* ma_snd_pcm_hw_params_get_format_proc)          (const ma_snd_pcm_hw_params_t *params, ma_snd_pcm_format_t *format);
+typedef int                  (* ma_snd_pcm_hw_params_get_channels_proc)        (const ma_snd_pcm_hw_params_t *params, unsigned int *val);
+typedef int                  (* ma_snd_pcm_hw_params_get_channels_min_proc)    (const ma_snd_pcm_hw_params_t *params, unsigned int *val);
+typedef int                  (* ma_snd_pcm_hw_params_get_channels_max_proc)    (const ma_snd_pcm_hw_params_t *params, unsigned int *val);
+typedef int                  (* ma_snd_pcm_hw_params_get_rate_proc)            (const ma_snd_pcm_hw_params_t *params, unsigned int *rate, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_get_rate_min_proc)        (const ma_snd_pcm_hw_params_t *params, unsigned int *rate, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_get_rate_max_proc)        (const ma_snd_pcm_hw_params_t *params, unsigned int *rate, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_get_buffer_size_proc)     (const ma_snd_pcm_hw_params_t *params, ma_snd_pcm_uframes_t *val);
+typedef int                  (* ma_snd_pcm_hw_params_get_periods_proc)         (const ma_snd_pcm_hw_params_t *params, unsigned int *val, int *dir);
+typedef int                  (* ma_snd_pcm_hw_params_get_access_proc)          (const ma_snd_pcm_hw_params_t *params, ma_snd_pcm_access_t *_access);
+typedef int                  (* ma_snd_pcm_hw_params_test_format_proc)         (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, ma_snd_pcm_format_t val);
+typedef int                  (* ma_snd_pcm_hw_params_test_channels_proc)       (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int val);
+typedef int                  (* ma_snd_pcm_hw_params_test_rate_proc)           (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params, unsigned int val, int dir);
+typedef int                  (* ma_snd_pcm_hw_params_proc)                     (ma_snd_pcm_t *pcm, ma_snd_pcm_hw_params_t *params);
+typedef size_t               (* ma_snd_pcm_sw_params_sizeof_proc)              (void);
+typedef int                  (* ma_snd_pcm_sw_params_current_proc)             (ma_snd_pcm_t *pcm, ma_snd_pcm_sw_params_t *params);
+typedef int                  (* ma_snd_pcm_sw_params_get_boundary_proc)        (const ma_snd_pcm_sw_params_t *params, ma_snd_pcm_uframes_t* val);
+typedef int                  (* ma_snd_pcm_sw_params_set_avail_min_proc)       (ma_snd_pcm_t *pcm, ma_snd_pcm_sw_params_t *params, ma_snd_pcm_uframes_t val);
+typedef int                  (* ma_snd_pcm_sw_params_set_start_threshold_proc) (ma_snd_pcm_t *pcm, ma_snd_pcm_sw_params_t *params, ma_snd_pcm_uframes_t val);
+typedef int                  (* ma_snd_pcm_sw_params_set_stop_threshold_proc)  (ma_snd_pcm_t *pcm, ma_snd_pcm_sw_params_t *params, ma_snd_pcm_uframes_t val);
+typedef int                  (* ma_snd_pcm_sw_params_proc)                     (ma_snd_pcm_t *pcm, ma_snd_pcm_sw_params_t *params);
+typedef size_t               (* ma_snd_pcm_format_mask_sizeof_proc)            (void);
+typedef int                  (* ma_snd_pcm_format_mask_test_proc)              (const ma_snd_pcm_format_mask_t *mask, ma_snd_pcm_format_t val);
+typedef ma_snd_pcm_chmap_t * (* ma_snd_pcm_get_chmap_proc)                     (ma_snd_pcm_t *pcm);
+typedef ma_snd_pcm_state_t   (* ma_snd_pcm_state_proc)                         (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_prepare_proc)                       (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_start_proc)                         (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_drop_proc)                          (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_drain_proc)                         (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_reset_proc)                         (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_device_name_hint_proc)                  (int card, const char *iface, void ***hints);
+typedef char *               (* ma_snd_device_name_get_hint_proc)              (const void *hint, const char *id);
+typedef int                  (* ma_snd_card_get_index_proc)                    (const char *name);
+typedef int                  (* ma_snd_device_name_free_hint_proc)             (void **hints);
+typedef int                  (* ma_snd_pcm_mmap_begin_proc)                    (ma_snd_pcm_t *pcm, const ma_snd_pcm_channel_area_t **areas, ma_snd_pcm_uframes_t *offset, ma_snd_pcm_uframes_t *frames);
+typedef ma_snd_pcm_sframes_t (* ma_snd_pcm_mmap_commit_proc)                   (ma_snd_pcm_t *pcm, ma_snd_pcm_uframes_t offset, ma_snd_pcm_uframes_t frames);
+typedef int                  (* ma_snd_pcm_recover_proc)                       (ma_snd_pcm_t *pcm, int err, int silent);
+typedef ma_snd_pcm_sframes_t (* ma_snd_pcm_readi_proc)                         (ma_snd_pcm_t *pcm, void *buffer, ma_snd_pcm_uframes_t size);
+typedef ma_snd_pcm_sframes_t (* ma_snd_pcm_writei_proc)                        (ma_snd_pcm_t *pcm, const void *buffer, ma_snd_pcm_uframes_t size);
+typedef ma_snd_pcm_sframes_t (* ma_snd_pcm_avail_proc)                         (ma_snd_pcm_t *pcm);
+typedef ma_snd_pcm_sframes_t (* ma_snd_pcm_avail_update_proc)                  (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_wait_proc)                          (ma_snd_pcm_t *pcm, int timeout);
+typedef int                  (* ma_snd_pcm_nonblock_proc)                      (ma_snd_pcm_t *pcm, int nonblock);
+typedef int                  (* ma_snd_pcm_info_proc)                          (ma_snd_pcm_t *pcm, ma_snd_pcm_info_t* info);
+typedef size_t               (* ma_snd_pcm_info_sizeof_proc)                   (void);
+typedef const char*          (* ma_snd_pcm_info_get_name_proc)                 (const ma_snd_pcm_info_t* info);
+typedef int                  (* ma_snd_pcm_poll_descriptors_proc)              (ma_snd_pcm_t *pcm, struct pollfd *pfds, unsigned int space);
+typedef int                  (* ma_snd_pcm_poll_descriptors_count_proc)        (ma_snd_pcm_t *pcm);
+typedef int                  (* ma_snd_pcm_poll_descriptors_revents_proc)      (ma_snd_pcm_t *pcm, struct pollfd *pfds, unsigned int nfds, unsigned short *revents);
+typedef int                  (* ma_snd_config_update_free_global_proc)         (void);
+
+/* This array specifies each of the common devices that can be used for both playback and capture. */
+static const char* g_maCommonDeviceNamesALSA[] = {
+    "default",
+    "null",
+    "pulse",
+    "jack"
+};
+
+/* This array allows us to blacklist specific playback devices. */
+static const char* g_maBlacklistedPlaybackDeviceNamesALSA[] = {
+    ""
+};
+
+/* This array allows us to blacklist specific capture devices. */
+static const char* g_maBlacklistedCaptureDeviceNamesALSA[] = {
+    ""
+};
+
+
+static ma_snd_pcm_format_t ma_convert_ma_format_to_alsa_format(ma_format format)
+{
+    ma_snd_pcm_format_t ALSAFormats[] = {
+        MA_SND_PCM_FORMAT_UNKNOWN,     /* ma_format_unknown */
+        MA_SND_PCM_FORMAT_U8,          /* ma_format_u8 */
+        MA_SND_PCM_FORMAT_S16_LE,      /* ma_format_s16 */
+        MA_SND_PCM_FORMAT_S24_3LE,     /* ma_format_s24 */
+        MA_SND_PCM_FORMAT_S32_LE,      /* ma_format_s32 */
+        MA_SND_PCM_FORMAT_FLOAT_LE     /* ma_format_f32 */
+    };
+
+    if (ma_is_big_endian()) {
+        ALSAFormats[0] = MA_SND_PCM_FORMAT_UNKNOWN;
+        ALSAFormats[1] = MA_SND_PCM_FORMAT_U8;
+        ALSAFormats[2] = MA_SND_PCM_FORMAT_S16_BE;
+        ALSAFormats[3] = MA_SND_PCM_FORMAT_S24_3BE;
+        ALSAFormats[4] = MA_SND_PCM_FORMAT_S32_BE;
+        ALSAFormats[5] = MA_SND_PCM_FORMAT_FLOAT_BE;
+    }
+
+    return ALSAFormats[format];
+}
+
+static ma_format ma_format_from_alsa(ma_snd_pcm_format_t formatALSA)
+{
+    if (ma_is_little_endian()) {
+        switch (formatALSA) {
+            case MA_SND_PCM_FORMAT_S16_LE:   return ma_format_s16;
+            case MA_SND_PCM_FORMAT_S24_3LE:  return ma_format_s24;
+            case MA_SND_PCM_FORMAT_S32_LE:   return ma_format_s32;
+            case MA_SND_PCM_FORMAT_FLOAT_LE: return ma_format_f32;
+            default: break;
+        }
+    } else {
+        switch (formatALSA) {
+            case MA_SND_PCM_FORMAT_S16_BE:   return ma_format_s16;
+            case MA_SND_PCM_FORMAT_S24_3BE:  return ma_format_s24;
+            case MA_SND_PCM_FORMAT_S32_BE:   return ma_format_s32;
+            case MA_SND_PCM_FORMAT_FLOAT_BE: return ma_format_f32;
+            default: break;
+        }
+    }
+
+    /* Endian agnostic. */
+    switch (formatALSA) {
+        case MA_SND_PCM_FORMAT_U8: return ma_format_u8;
+        default: return ma_format_unknown;
+    }
+}
+
+static ma_channel ma_convert_alsa_channel_position_to_ma_channel(unsigned int alsaChannelPos)
+{
+    switch (alsaChannelPos)
+    {
+        case MA_SND_CHMAP_MONO: return MA_CHANNEL_MONO;
+        case MA_SND_CHMAP_FL:   return MA_CHANNEL_FRONT_LEFT;
+        case MA_SND_CHMAP_FR:   return MA_CHANNEL_FRONT_RIGHT;
+        case MA_SND_CHMAP_RL:   return MA_CHANNEL_BACK_LEFT;
+        case MA_SND_CHMAP_RR:   return MA_CHANNEL_BACK_RIGHT;
+        case MA_SND_CHMAP_FC:   return MA_CHANNEL_FRONT_CENTER;
+        case MA_SND_CHMAP_LFE:  return MA_CHANNEL_LFE;
+        case MA_SND_CHMAP_SL:   return MA_CHANNEL_SIDE_LEFT;
+        case MA_SND_CHMAP_SR:   return MA_CHANNEL_SIDE_RIGHT;
+        case MA_SND_CHMAP_RC:   return MA_CHANNEL_BACK_CENTER;
+        case MA_SND_CHMAP_FLC:  return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case MA_SND_CHMAP_FRC:  return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case MA_SND_CHMAP_RLC:  return 0;
+        case MA_SND_CHMAP_RRC:  return 0;
+        case MA_SND_CHMAP_FLW:  return 0;
+        case MA_SND_CHMAP_FRW:  return 0;
+        case MA_SND_CHMAP_FLH:  return 0;
+        case MA_SND_CHMAP_FCH:  return 0;
+        case MA_SND_CHMAP_FRH:  return 0;
+        case MA_SND_CHMAP_TC:   return MA_CHANNEL_TOP_CENTER;
+        case MA_SND_CHMAP_TFL:  return MA_CHANNEL_TOP_FRONT_LEFT;
+        case MA_SND_CHMAP_TFR:  return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case MA_SND_CHMAP_TFC:  return MA_CHANNEL_TOP_FRONT_CENTER;
+        case MA_SND_CHMAP_TRL:  return MA_CHANNEL_TOP_BACK_LEFT;
+        case MA_SND_CHMAP_TRR:  return MA_CHANNEL_TOP_BACK_RIGHT;
+        case MA_SND_CHMAP_TRC:  return MA_CHANNEL_TOP_BACK_CENTER;
+        default: break;
+    }
+
+    return 0;
+}
+
+static ma_bool32 ma_is_common_device_name__alsa(const char* name)
+{
+    size_t iName;
+    for (iName = 0; iName < ma_countof(g_maCommonDeviceNamesALSA); ++iName) {
+        if (ma_strcmp(name, g_maCommonDeviceNamesALSA[iName]) == 0) {
+            return MA_TRUE;
+        }
+    }
+
+    return MA_FALSE;
+}
+
+
+static ma_bool32 ma_is_playback_device_blacklisted__alsa(const char* name)
+{
+    size_t iName;
+    for (iName = 0; iName < ma_countof(g_maBlacklistedPlaybackDeviceNamesALSA); ++iName) {
+        if (ma_strcmp(name, g_maBlacklistedPlaybackDeviceNamesALSA[iName]) == 0) {
+            return MA_TRUE;
+        }
+    }
+
+    return MA_FALSE;
+}
+
+static ma_bool32 ma_is_capture_device_blacklisted__alsa(const char* name)
+{
+    size_t iName;
+    for (iName = 0; iName < ma_countof(g_maBlacklistedCaptureDeviceNamesALSA); ++iName) {
+        if (ma_strcmp(name, g_maBlacklistedCaptureDeviceNamesALSA[iName]) == 0) {
+            return MA_TRUE;
+        }
+    }
+
+    return MA_FALSE;
+}
+
+static ma_bool32 ma_is_device_blacklisted__alsa(ma_device_type deviceType, const char* name)
+{
+    if (deviceType == ma_device_type_playback) {
+        return ma_is_playback_device_blacklisted__alsa(name);
+    } else {
+        return ma_is_capture_device_blacklisted__alsa(name);
+    }
+}
+
+
+static const char* ma_find_char(const char* str, char c, int* index)
+{
+    int i = 0;
+    for (;;) {
+        if (str[i] == '\0') {
+            if (index) *index = -1;
+            return NULL;
+        }
+
+        if (str[i] == c) {
+            if (index) *index = i;
+            return str + i;
+        }
+
+        i += 1;
+    }
+
+    /* Should never get here, but treat it as though the character was not found to make me feel better inside. */
+    if (index) *index = -1;
+    return NULL;
+}
+
+static ma_bool32 ma_is_device_name_in_hw_format__alsa(const char* hwid)
+{
+    /* This function is just checking whether or not hwid is in "hw:%d,%d" format. */
+
+    int commaPos;
+    const char* dev;
+    int i;
+
+    if (hwid == NULL) {
+        return MA_FALSE;
+    }
+
+    if (hwid[0] != 'h' || hwid[1] != 'w' || hwid[2] != ':') {
+        return MA_FALSE;
+    }
+
+    hwid += 3;
+
+    dev = ma_find_char(hwid, ',', &commaPos);
+    if (dev == NULL) {
+        return MA_FALSE;
+    } else {
+        dev += 1;   /* Skip past the ",". */
+    }
+
+    /* Check if the part between the ":" and the "," contains only numbers. If not, return false. */
+    for (i = 0; i < commaPos; ++i) {
+        if (hwid[i] < '0' || hwid[i] > '9') {
+            return MA_FALSE;
+        }
+    }
+
+    /* Check if everything after the "," is numeric. If not, return false. */
+    i = 0;
+    while (dev[i] != '\0') {
+        if (dev[i] < '0' || dev[i] > '9') {
+            return MA_FALSE;
+        }
+        i += 1;
+    }
+
+    return MA_TRUE;
+}
+
+static int ma_convert_device_name_to_hw_format__alsa(ma_context* pContext, char* dst, size_t dstSize, const char* src)  /* Returns 0 on success, non-0 on error. */
+{
+    /* src should look something like this: "hw:CARD=I82801AAICH,DEV=0" */
+
+    int colonPos;
+    int commaPos;
+    char card[256];
+    const char* dev;
+    int cardIndex;
+
+    if (dst == NULL) {
+        return -1;
+    }
+    if (dstSize < 7) {
+        return -1;     /* Absolute minimum size of the output buffer is 7 bytes. */
+    }
+
+    *dst = '\0';    /* Safety. */
+    if (src == NULL) {
+        return -1;
+    }
+
+    /* If the input name is already in "hw:%d,%d" format, just return that verbatim. */
+    if (ma_is_device_name_in_hw_format__alsa(src)) {
+        return ma_strcpy_s(dst, dstSize, src);
+    }
+
+    src = ma_find_char(src, ':', &colonPos);
+    if (src == NULL) {
+        return -1;  /* Couldn't find a colon */
+    }
+
+    dev = ma_find_char(src, ',', &commaPos);
+    if (dev == NULL) {
+        dev = "0";
+        ma_strncpy_s(card, sizeof(card), src+6, (size_t)-1);   /* +6 = ":CARD=" */
+    } else {
+        dev = dev + 5;  /* +5 = ",DEV=" */
+        ma_strncpy_s(card, sizeof(card), src+6, commaPos-6);   /* +6 = ":CARD=" */
+    }
+
+    cardIndex = ((ma_snd_card_get_index_proc)pContext->alsa.snd_card_get_index)(card);
+    if (cardIndex < 0) {
+        return -2;  /* Failed to retrieve the card index. */
+    }
+
+
+    /* Construction. */
+    dst[0] = 'h'; dst[1] = 'w'; dst[2] = ':';
+    if (ma_itoa_s(cardIndex, dst+3, dstSize-3, 10) != 0) {
+        return -3;
+    }
+    if (ma_strcat_s(dst, dstSize, ",") != 0) {
+        return -3;
+    }
+    if (ma_strcat_s(dst, dstSize, dev) != 0) {
+        return -3;
+    }
+
+    return 0;
+}
+
+static ma_bool32 ma_does_id_exist_in_list__alsa(ma_device_id* pUniqueIDs, ma_uint32 count, const char* pHWID)
+{
+    ma_uint32 i;
+
+    MA_ASSERT(pHWID != NULL);
+
+    for (i = 0; i < count; ++i) {
+        if (ma_strcmp(pUniqueIDs[i].alsa, pHWID) == 0) {
+            return MA_TRUE;
+        }
+    }
+
+    return MA_FALSE;
+}
+
+
+static ma_result ma_context_open_pcm__alsa(ma_context* pContext, ma_share_mode shareMode, ma_device_type deviceType, const ma_device_id* pDeviceID, int openMode, ma_snd_pcm_t** ppPCM)
+{
+    ma_snd_pcm_t* pPCM;
+    ma_snd_pcm_stream_t stream;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppPCM != NULL);
+
+    *ppPCM = NULL;
+    pPCM = NULL;
+
+    stream = (deviceType == ma_device_type_playback) ? MA_SND_PCM_STREAM_PLAYBACK : MA_SND_PCM_STREAM_CAPTURE;
+
+    if (pDeviceID == NULL) {
+        ma_bool32 isDeviceOpen;
+        size_t i;
+
+        /*
+        We're opening the default device. I don't know if trying anything other than "default" is necessary, but it makes
+        me feel better to try as hard as we can get to get _something_ working.
+        */
+        const char* defaultDeviceNames[] = {
+            "default",
+            NULL,
+            NULL,
+            NULL,
+            NULL,
+            NULL,
+            NULL
+        };
+
+        if (shareMode == ma_share_mode_exclusive) {
+            defaultDeviceNames[1] = "hw";
+            defaultDeviceNames[2] = "hw:0";
+            defaultDeviceNames[3] = "hw:0,0";
+        } else {
+            if (deviceType == ma_device_type_playback) {
+                defaultDeviceNames[1] = "dmix";
+                defaultDeviceNames[2] = "dmix:0";
+                defaultDeviceNames[3] = "dmix:0,0";
+            } else {
+                defaultDeviceNames[1] = "dsnoop";
+                defaultDeviceNames[2] = "dsnoop:0";
+                defaultDeviceNames[3] = "dsnoop:0,0";
+            }
+            defaultDeviceNames[4] = "hw";
+            defaultDeviceNames[5] = "hw:0";
+            defaultDeviceNames[6] = "hw:0,0";
+        }
+
+        isDeviceOpen = MA_FALSE;
+        for (i = 0; i < ma_countof(defaultDeviceNames); ++i) {
+            if (defaultDeviceNames[i] != NULL && defaultDeviceNames[i][0] != '\0') {
+                if (((ma_snd_pcm_open_proc)pContext->alsa.snd_pcm_open)(&pPCM, defaultDeviceNames[i], stream, openMode) == 0) {
+                    isDeviceOpen = MA_TRUE;
+                    break;
+                }
+            }
+        }
+
+        if (!isDeviceOpen) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[ALSA] snd_pcm_open() failed when trying to open an appropriate default device.");
+            return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+        }
+    } else {
+        /*
+        We're trying to open a specific device. There's a few things to consider here:
+
+        miniaudio recongnizes a special format of device id that excludes the "hw", "dmix", etc. prefix. It looks like this: ":0,0", ":0,1", etc. When
+        an ID of this format is specified, it indicates to miniaudio that it can try different combinations of plugins ("hw", "dmix", etc.) until it
+        finds an appropriate one that works. This comes in very handy when trying to open a device in shared mode ("dmix"), vs exclusive mode ("hw").
+        */
+
+        /* May end up needing to make small adjustments to the ID, so make a copy. */
+        ma_device_id deviceID = *pDeviceID;
+        int resultALSA = -ENODEV;
+
+        if (deviceID.alsa[0] != ':') {
+            /* The ID is not in ":0,0" format. Use the ID exactly as-is. */
+            resultALSA = ((ma_snd_pcm_open_proc)pContext->alsa.snd_pcm_open)(&pPCM, deviceID.alsa, stream, openMode);
+        } else {
+            char hwid[256];
+
+            /* The ID is in ":0,0" format. Try different plugins depending on the shared mode. */
+            if (deviceID.alsa[1] == '\0') {
+                deviceID.alsa[0] = '\0';  /* An ID of ":" should be converted to "". */
+            }
+
+            if (shareMode == ma_share_mode_shared) {
+                if (deviceType == ma_device_type_playback) {
+                    ma_strcpy_s(hwid, sizeof(hwid), "dmix");
+                } else {
+                    ma_strcpy_s(hwid, sizeof(hwid), "dsnoop");
+                }
+
+                if (ma_strcat_s(hwid, sizeof(hwid), deviceID.alsa) == 0) {
+                    resultALSA = ((ma_snd_pcm_open_proc)pContext->alsa.snd_pcm_open)(&pPCM, hwid, stream, openMode);
+                }
+            }
+
+            /* If at this point we still don't have an open device it means we're either preferencing exclusive mode or opening with "dmix"/"dsnoop" failed. */
+            if (resultALSA != 0) {
+                ma_strcpy_s(hwid, sizeof(hwid), "hw");
+                if (ma_strcat_s(hwid, sizeof(hwid), deviceID.alsa) == 0) {
+                    resultALSA = ((ma_snd_pcm_open_proc)pContext->alsa.snd_pcm_open)(&pPCM, hwid, stream, openMode);
+                }
+            }
+        }
+
+        if (resultALSA < 0) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[ALSA] snd_pcm_open() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+    }
+
+    *ppPCM = pPCM;
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_enumerate_devices__alsa(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    int resultALSA;
+    ma_bool32 cbResult = MA_TRUE;
+    char** ppDeviceHints;
+    ma_device_id* pUniqueIDs = NULL;
+    ma_uint32 uniqueIDCount = 0;
+    char** ppNextDeviceHint;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    ma_mutex_lock(&pContext->alsa.internalDeviceEnumLock);
+
+    resultALSA = ((ma_snd_device_name_hint_proc)pContext->alsa.snd_device_name_hint)(-1, "pcm", (void***)&ppDeviceHints);
+    if (resultALSA < 0) {
+        ma_mutex_unlock(&pContext->alsa.internalDeviceEnumLock);
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    ppNextDeviceHint = ppDeviceHints;
+    while (*ppNextDeviceHint != NULL) {
+        char* NAME = ((ma_snd_device_name_get_hint_proc)pContext->alsa.snd_device_name_get_hint)(*ppNextDeviceHint, "NAME");
+        char* DESC = ((ma_snd_device_name_get_hint_proc)pContext->alsa.snd_device_name_get_hint)(*ppNextDeviceHint, "DESC");
+        char* IOID = ((ma_snd_device_name_get_hint_proc)pContext->alsa.snd_device_name_get_hint)(*ppNextDeviceHint, "IOID");
+        ma_device_type deviceType = ma_device_type_playback;
+        ma_bool32 stopEnumeration = MA_FALSE;
+        char hwid[sizeof(pUniqueIDs->alsa)];
+        ma_device_info deviceInfo;
+
+        if ((IOID == NULL || ma_strcmp(IOID, "Output") == 0)) {
+            deviceType = ma_device_type_playback;
+        }
+        if ((IOID != NULL && ma_strcmp(IOID, "Input" ) == 0)) {
+            deviceType = ma_device_type_capture;
+        }
+
+        if (NAME != NULL) {
+            if (pContext->alsa.useVerboseDeviceEnumeration) {
+                /* Verbose mode. Use the name exactly as-is. */
+                ma_strncpy_s(hwid, sizeof(hwid), NAME, (size_t)-1);
+            } else {
+                /* Simplified mode. Use ":%d,%d" format. */
+                if (ma_convert_device_name_to_hw_format__alsa(pContext, hwid, sizeof(hwid), NAME) == 0) {
+                    /*
+                    At this point, hwid looks like "hw:0,0". In simplified enumeration mode, we actually want to strip off the
+                    plugin name so it looks like ":0,0". The reason for this is that this special format is detected at device
+                    initialization time and is used as an indicator to try and use the most appropriate plugin depending on the
+                    device type and sharing mode.
+                    */
+                    char* dst = hwid;
+                    char* src = hwid+2;
+                    while ((*dst++ = *src++));
+                } else {
+                    /* Conversion to "hw:%d,%d" failed. Just use the name as-is. */
+                    ma_strncpy_s(hwid, sizeof(hwid), NAME, (size_t)-1);
+                }
+
+                if (ma_does_id_exist_in_list__alsa(pUniqueIDs, uniqueIDCount, hwid)) {
+                    goto next_device;   /* The device has already been enumerated. Move on to the next one. */
+                } else {
+                    /* The device has not yet been enumerated. Make sure it's added to our list so that it's not enumerated again. */
+                    size_t newCapacity = sizeof(*pUniqueIDs) * (uniqueIDCount + 1);
+                    ma_device_id* pNewUniqueIDs = (ma_device_id*)ma_realloc(pUniqueIDs, newCapacity, &pContext->allocationCallbacks);
+                    if (pNewUniqueIDs == NULL) {
+                        goto next_device;   /* Failed to allocate memory. */
+                    }
+
+                    pUniqueIDs = pNewUniqueIDs;
+                    MA_COPY_MEMORY(pUniqueIDs[uniqueIDCount].alsa, hwid, sizeof(hwid));
+                    uniqueIDCount += 1;
+                }
+            }
+        } else {
+            MA_ZERO_MEMORY(hwid, sizeof(hwid));
+        }
+
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.id.alsa, sizeof(deviceInfo.id.alsa), hwid, (size_t)-1);
+
+        /*
+        There's no good way to determine whether or not a device is the default on Linux. We're just going to do something simple and
+        just use the name of "default" as the indicator.
+        */
+        if (ma_strcmp(deviceInfo.id.alsa, "default") == 0) {
+            deviceInfo.isDefault = MA_TRUE;
+        }
+
+
+        /*
+        DESC is the friendly name. We treat this slightly differently depending on whether or not we are using verbose
+        device enumeration. In verbose mode we want to take the entire description so that the end-user can distinguish
+        between the subdevices of each card/dev pair. In simplified mode, however, we only want the first part of the
+        description.
+
+        The value in DESC seems to be split into two lines, with the first line being the name of the device and the
+        second line being a description of the device. I don't like having the description be across two lines because
+        it makes formatting ugly and annoying. I'm therefore deciding to put it all on a single line with the second line
+        being put into parentheses. In simplified mode I'm just stripping the second line entirely.
+        */
+        if (DESC != NULL) {
+            int lfPos;
+            const char* line2 = ma_find_char(DESC, '\n', &lfPos);
+            if (line2 != NULL) {
+                line2 += 1; /* Skip past the new-line character. */
+
+                if (pContext->alsa.useVerboseDeviceEnumeration) {
+                    /* Verbose mode. Put the second line in brackets. */
+                    ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), DESC, lfPos);
+                    ma_strcat_s (deviceInfo.name, sizeof(deviceInfo.name), " (");
+                    ma_strcat_s (deviceInfo.name, sizeof(deviceInfo.name), line2);
+                    ma_strcat_s (deviceInfo.name, sizeof(deviceInfo.name), ")");
+                } else {
+                    /* Simplified mode. Strip the second line entirely. */
+                    ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), DESC, lfPos);
+                }
+            } else {
+                /* There's no second line. Just copy the whole description. */
+                ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), DESC, (size_t)-1);
+            }
+        }
+
+        if (!ma_is_device_blacklisted__alsa(deviceType, NAME)) {
+            cbResult = callback(pContext, deviceType, &deviceInfo, pUserData);
+        }
+
+        /*
+        Some devices are both playback and capture, but they are only enumerated by ALSA once. We need to fire the callback
+        again for the other device type in this case. We do this for known devices and where the IOID hint is NULL, which
+        means both Input and Output.
+        */
+        if (cbResult) {
+            if (ma_is_common_device_name__alsa(NAME) || IOID == NULL) {
+                if (deviceType == ma_device_type_playback) {
+                    if (!ma_is_capture_device_blacklisted__alsa(NAME)) {
+                        cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+                    }
+                } else {
+                    if (!ma_is_playback_device_blacklisted__alsa(NAME)) {
+                        cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+                    }
+                }
+            }
+        }
+
+        if (cbResult == MA_FALSE) {
+            stopEnumeration = MA_TRUE;
+        }
+
+    next_device:
+        free(NAME);
+        free(DESC);
+        free(IOID);
+        ppNextDeviceHint += 1;
+
+        /* We need to stop enumeration if the callback returned false. */
+        if (stopEnumeration) {
+            break;
+        }
+    }
+
+    ma_free(pUniqueIDs, &pContext->allocationCallbacks);
+    ((ma_snd_device_name_free_hint_proc)pContext->alsa.snd_device_name_free_hint)((void**)ppDeviceHints);
+
+    ma_mutex_unlock(&pContext->alsa.internalDeviceEnumLock);
+
+    return MA_SUCCESS;
+}
+
+
+typedef struct
+{
+    ma_device_type deviceType;
+    const ma_device_id* pDeviceID;
+    ma_share_mode shareMode;
+    ma_device_info* pDeviceInfo;
+    ma_bool32 foundDevice;
+} ma_context_get_device_info_enum_callback_data__alsa;
+
+static ma_bool32 ma_context_get_device_info_enum_callback__alsa(ma_context* pContext, ma_device_type deviceType, const ma_device_info* pDeviceInfo, void* pUserData)
+{
+    ma_context_get_device_info_enum_callback_data__alsa* pData = (ma_context_get_device_info_enum_callback_data__alsa*)pUserData;
+    MA_ASSERT(pData != NULL);
+
+    (void)pContext;
+
+    if (pData->pDeviceID == NULL && ma_strcmp(pDeviceInfo->id.alsa, "default") == 0) {
+        ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), pDeviceInfo->name, (size_t)-1);
+        pData->foundDevice = MA_TRUE;
+    } else {
+        if (pData->deviceType == deviceType && (pData->pDeviceID != NULL && ma_strcmp(pData->pDeviceID->alsa, pDeviceInfo->id.alsa) == 0)) {
+            ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), pDeviceInfo->name, (size_t)-1);
+            pData->foundDevice = MA_TRUE;
+        }
+    }
+
+    /* Keep enumerating until we have found the device. */
+    return !pData->foundDevice;
+}
+
+static void ma_context_test_rate_and_add_native_data_format__alsa(ma_context* pContext, ma_snd_pcm_t* pPCM, ma_snd_pcm_hw_params_t* pHWParams, ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 flags, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pPCM        != NULL);
+    MA_ASSERT(pHWParams   != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    if (pDeviceInfo->nativeDataFormatCount < ma_countof(pDeviceInfo->nativeDataFormats) && ((ma_snd_pcm_hw_params_test_rate_proc)pContext->alsa.snd_pcm_hw_params_test_rate)(pPCM, pHWParams, sampleRate, 0) == 0) {
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = format;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = sampleRate;
+        pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = flags;
+        pDeviceInfo->nativeDataFormatCount += 1;
+    }
+}
+
+static void ma_context_iterate_rates_and_add_native_data_format__alsa(ma_context* pContext, ma_snd_pcm_t* pPCM, ma_snd_pcm_hw_params_t* pHWParams, ma_format format, ma_uint32 channels, ma_uint32 flags, ma_device_info* pDeviceInfo)
+{
+    ma_uint32 iSampleRate;
+    unsigned int minSampleRate;
+    unsigned int maxSampleRate;
+    int sampleRateDir;  /* Not used. Just passed into snd_pcm_hw_params_get_rate_min/max(). */
+
+    /* There could be a range. */
+    ((ma_snd_pcm_hw_params_get_rate_min_proc)pContext->alsa.snd_pcm_hw_params_get_rate_min)(pHWParams, &minSampleRate, &sampleRateDir);
+    ((ma_snd_pcm_hw_params_get_rate_max_proc)pContext->alsa.snd_pcm_hw_params_get_rate_max)(pHWParams, &maxSampleRate, &sampleRateDir);
+
+    /* Make sure our sample rates are clamped to sane values. Stupid devices like "pulse" will reports rates like "1" which is ridiculus. */
+    minSampleRate = ma_clamp(minSampleRate, (unsigned int)ma_standard_sample_rate_min, (unsigned int)ma_standard_sample_rate_max);
+    maxSampleRate = ma_clamp(maxSampleRate, (unsigned int)ma_standard_sample_rate_min, (unsigned int)ma_standard_sample_rate_max);
+
+    for (iSampleRate = 0; iSampleRate < ma_countof(g_maStandardSampleRatePriorities); iSampleRate += 1) {
+        ma_uint32 standardSampleRate = g_maStandardSampleRatePriorities[iSampleRate];
+
+        if (standardSampleRate >= minSampleRate && standardSampleRate <= maxSampleRate) {
+            ma_context_test_rate_and_add_native_data_format__alsa(pContext, pPCM, pHWParams, format, channels, standardSampleRate, flags, pDeviceInfo);
+        }
+    }
+
+    /* Now make sure our min and max rates are included just in case they aren't in the range of our standard rates. */
+    if (!ma_is_standard_sample_rate(minSampleRate)) {
+        ma_context_test_rate_and_add_native_data_format__alsa(pContext, pPCM, pHWParams, format, channels, minSampleRate, flags, pDeviceInfo);
+    }
+
+    if (!ma_is_standard_sample_rate(maxSampleRate) && maxSampleRate != minSampleRate) {
+        ma_context_test_rate_and_add_native_data_format__alsa(pContext, pPCM, pHWParams, format, channels, maxSampleRate, flags, pDeviceInfo);
+    }
+}
+
+static ma_result ma_context_get_device_info__alsa(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_context_get_device_info_enum_callback_data__alsa data;
+    ma_result result;
+    int resultALSA;
+    ma_snd_pcm_t* pPCM;
+    ma_snd_pcm_hw_params_t* pHWParams;
+    ma_uint32 iFormat;
+    ma_uint32 iChannel;
+
+    MA_ASSERT(pContext != NULL);
+
+    /* We just enumerate to find basic information about the device. */
+    data.deviceType  = deviceType;
+    data.pDeviceID   = pDeviceID;
+    data.pDeviceInfo = pDeviceInfo;
+    data.foundDevice = MA_FALSE;
+    result = ma_context_enumerate_devices__alsa(pContext, ma_context_get_device_info_enum_callback__alsa, &data);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (!data.foundDevice) {
+        return MA_NO_DEVICE;
+    }
+
+    if (ma_strcmp(pDeviceInfo->id.alsa, "default") == 0) {
+        pDeviceInfo->isDefault = MA_TRUE;
+    }
+
+    /* For detailed info we need to open the device. */
+    result = ma_context_open_pcm__alsa(pContext, ma_share_mode_shared, deviceType, pDeviceID, 0, &pPCM);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* We need to initialize a HW parameters object in order to know what formats are supported. */
+    pHWParams = (ma_snd_pcm_hw_params_t*)ma_calloc(((ma_snd_pcm_hw_params_sizeof_proc)pContext->alsa.snd_pcm_hw_params_sizeof)(), &pContext->allocationCallbacks);
+    if (pHWParams == NULL) {
+        ((ma_snd_pcm_close_proc)pContext->alsa.snd_pcm_close)(pPCM);
+        return MA_OUT_OF_MEMORY;
+    }
+
+    resultALSA = ((ma_snd_pcm_hw_params_any_proc)pContext->alsa.snd_pcm_hw_params_any)(pPCM, pHWParams);
+    if (resultALSA < 0) {
+        ma_free(pHWParams, &pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to initialize hardware parameters. snd_pcm_hw_params_any() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    /*
+    Some ALSA devices can support many permutations of formats, channels and rates. We only support
+    a fixed number of permutations which means we need to employ some strategies to ensure the best
+    combinations are returned. An example is the "pulse" device which can do it's own data conversion
+    in software and as a result can support any combination of format, channels and rate.
+
+    We want to ensure the the first data formats are the best. We have a list of favored sample
+    formats and sample rates, so these will be the basis of our iteration.
+    */
+
+    /* Formats. We just iterate over our standard formats and test them, making sure we reset the configuration space each iteration. */
+    for (iFormat = 0; iFormat < ma_countof(g_maFormatPriorities); iFormat += 1) {
+        ma_format format = g_maFormatPriorities[iFormat];
+
+        /*
+        For each format we need to make sure we reset the configuration space so we don't return
+        channel counts and rates that aren't compatible with a format.
+        */
+        ((ma_snd_pcm_hw_params_any_proc)pContext->alsa.snd_pcm_hw_params_any)(pPCM, pHWParams);
+
+        /* Test the format first. If this fails it means the format is not supported and we can skip it. */
+        if (((ma_snd_pcm_hw_params_test_format_proc)pContext->alsa.snd_pcm_hw_params_test_format)(pPCM, pHWParams, ma_convert_ma_format_to_alsa_format(format)) == 0) {
+            /* The format is supported. */
+            unsigned int minChannels;
+            unsigned int maxChannels;
+
+            /*
+            The configuration space needs to be restricted to this format so we can get an accurate
+            picture of which sample rates and channel counts are support with this format.
+            */
+            ((ma_snd_pcm_hw_params_set_format_proc)pContext->alsa.snd_pcm_hw_params_set_format)(pPCM, pHWParams, ma_convert_ma_format_to_alsa_format(format));
+
+            /* Now we need to check for supported channels. */
+            ((ma_snd_pcm_hw_params_get_channels_min_proc)pContext->alsa.snd_pcm_hw_params_get_channels_min)(pHWParams, &minChannels);
+            ((ma_snd_pcm_hw_params_get_channels_max_proc)pContext->alsa.snd_pcm_hw_params_get_channels_max)(pHWParams, &maxChannels);
+
+            if (minChannels > MA_MAX_CHANNELS) {
+                continue;   /* Too many channels. */
+            }
+            if (maxChannels < MA_MIN_CHANNELS) {
+                continue;   /* Not enough channels. */
+            }
+
+            /*
+            Make sure the channel count is clamped. This is mainly intended for the max channels
+            because some devices can report an unbound maximum.
+            */
+            minChannels = ma_clamp(minChannels, MA_MIN_CHANNELS, MA_MAX_CHANNELS);
+            maxChannels = ma_clamp(maxChannels, MA_MIN_CHANNELS, MA_MAX_CHANNELS);
+
+            if (minChannels == MA_MIN_CHANNELS && maxChannels == MA_MAX_CHANNELS) {
+                /* The device supports all channels. Don't iterate over every single one. Instead just set the channels to 0 which means all channels are supported. */
+                ma_context_iterate_rates_and_add_native_data_format__alsa(pContext, pPCM, pHWParams, format, 0, 0, pDeviceInfo);    /* Intentionally setting the channel count to 0 as that means all channels are supported. */
+            } else {
+                /* The device only supports a specific set of channels. We need to iterate over all of them. */
+                for (iChannel = minChannels; iChannel <= maxChannels; iChannel += 1) {
+                    /* Test the channel before applying it to the configuration space. */
+                    unsigned int channels = iChannel;
+
+                    /* Make sure our channel range is reset before testing again or else we'll always fail the test. */
+                    ((ma_snd_pcm_hw_params_any_proc)pContext->alsa.snd_pcm_hw_params_any)(pPCM, pHWParams);
+                    ((ma_snd_pcm_hw_params_set_format_proc)pContext->alsa.snd_pcm_hw_params_set_format)(pPCM, pHWParams, ma_convert_ma_format_to_alsa_format(format));
+
+                    if (((ma_snd_pcm_hw_params_test_channels_proc)pContext->alsa.snd_pcm_hw_params_test_channels)(pPCM, pHWParams, channels) == 0) {
+                        /* The channel count is supported. */
+
+                        /* The configuration space now needs to be restricted to the channel count before extracting the sample rate. */
+                        ((ma_snd_pcm_hw_params_set_channels_proc)pContext->alsa.snd_pcm_hw_params_set_channels)(pPCM, pHWParams, channels);
+
+                        /* Only after the configuration space has been restricted to the specific channel count should we iterate over our sample rates. */
+                        ma_context_iterate_rates_and_add_native_data_format__alsa(pContext, pPCM, pHWParams, format, channels, 0, pDeviceInfo);
+                    } else {
+                        /* The channel count is not supported. Skip. */
+                    }
+                }
+            }
+        } else {
+            /* The format is not supported. Skip. */
+        }
+    }
+
+    ma_free(pHWParams, &pContext->allocationCallbacks);
+
+    ((ma_snd_pcm_close_proc)pContext->alsa.snd_pcm_close)(pPCM);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_uninit__alsa(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if ((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture);
+        close(pDevice->alsa.wakeupfdCapture);
+        ma_free(pDevice->alsa.pPollDescriptorsCapture, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if ((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback);
+        close(pDevice->alsa.wakeupfdPlayback);
+        ma_free(pDevice->alsa.pPollDescriptorsPlayback, &pDevice->pContext->allocationCallbacks);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init_by_type__alsa(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptor, ma_device_type deviceType)
+{
+    ma_result result;
+    int resultALSA;
+    ma_snd_pcm_t* pPCM;
+    ma_bool32 isUsingMMap;
+    ma_snd_pcm_format_t formatALSA;
+    ma_format internalFormat;
+    ma_uint32 internalChannels;
+    ma_uint32 internalSampleRate;
+    ma_channel internalChannelMap[MA_MAX_CHANNELS];
+    ma_uint32 internalPeriodSizeInFrames;
+    ma_uint32 internalPeriods;
+    int openMode;
+    ma_snd_pcm_hw_params_t* pHWParams;
+    ma_snd_pcm_sw_params_t* pSWParams;
+    ma_snd_pcm_uframes_t bufferBoundary;
+    int pollDescriptorCount;
+    struct pollfd* pPollDescriptors;
+    int wakeupfd;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(deviceType != ma_device_type_duplex); /* This function should only be called for playback _or_ capture, never duplex. */
+    MA_ASSERT(pDevice != NULL);
+
+    formatALSA = ma_convert_ma_format_to_alsa_format(pDescriptor->format);
+
+    openMode = 0;
+    if (pConfig->alsa.noAutoResample) {
+        openMode |= MA_SND_PCM_NO_AUTO_RESAMPLE;
+    }
+    if (pConfig->alsa.noAutoChannels) {
+        openMode |= MA_SND_PCM_NO_AUTO_CHANNELS;
+    }
+    if (pConfig->alsa.noAutoFormat) {
+        openMode |= MA_SND_PCM_NO_AUTO_FORMAT;
+    }
+
+    result = ma_context_open_pcm__alsa(pDevice->pContext, pDescriptor->shareMode, deviceType, pDescriptor->pDeviceID, openMode, &pPCM);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+
+    /* Hardware parameters. */
+    pHWParams = (ma_snd_pcm_hw_params_t*)ma_calloc(((ma_snd_pcm_hw_params_sizeof_proc)pDevice->pContext->alsa.snd_pcm_hw_params_sizeof)(), &pDevice->pContext->allocationCallbacks);
+    if (pHWParams == NULL) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to allocate memory for hardware parameters.");
+        return MA_OUT_OF_MEMORY;
+    }
+
+    resultALSA = ((ma_snd_pcm_hw_params_any_proc)pDevice->pContext->alsa.snd_pcm_hw_params_any)(pPCM, pHWParams);
+    if (resultALSA < 0) {
+        ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to initialize hardware parameters. snd_pcm_hw_params_any() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    /* MMAP Mode. Try using interleaved MMAP access. If this fails, fall back to standard readi/writei. */
+    isUsingMMap = MA_FALSE;
+#if 0   /* NOTE: MMAP mode temporarily disabled. */
+    if (deviceType != ma_device_type_capture) {    /* <-- Disabling MMAP mode for capture devices because I apparently do not have a device that supports it which means I can't test it... Contributions welcome. */
+        if (!pConfig->alsa.noMMap) {
+            if (((ma_snd_pcm_hw_params_set_access_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_access)(pPCM, pHWParams, MA_SND_PCM_ACCESS_MMAP_INTERLEAVED) == 0) {
+                pDevice->alsa.isUsingMMap = MA_TRUE;
+            }
+        }
+    }
+#endif
+
+    if (!isUsingMMap) {
+        resultALSA = ((ma_snd_pcm_hw_params_set_access_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_access)(pPCM, pHWParams, MA_SND_PCM_ACCESS_RW_INTERLEAVED);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set access mode to neither SND_PCM_ACCESS_MMAP_INTERLEAVED nor SND_PCM_ACCESS_RW_INTERLEAVED. snd_pcm_hw_params_set_access() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+    }
+
+    /*
+    Most important properties first. The documentation for OSS (yes, I know this is ALSA!) recommends format, channels, then sample rate. I can't
+    find any documentation for ALSA specifically, so I'm going to copy the recommendation for OSS.
+    */
+
+    /* Format. */
+    {
+        /*
+        At this point we should have a list of supported formats, so now we need to find the best one. We first check if the requested format is
+        supported, and if so, use that one. If it's not supported, we just run though a list of formats and try to find the best one.
+        */
+        if (formatALSA == MA_SND_PCM_FORMAT_UNKNOWN || ((ma_snd_pcm_hw_params_test_format_proc)pDevice->pContext->alsa.snd_pcm_hw_params_test_format)(pPCM, pHWParams, formatALSA) != 0) {
+            /* We're either requesting the native format or the specified format is not supported. */
+            size_t iFormat;
+
+            formatALSA = MA_SND_PCM_FORMAT_UNKNOWN;
+            for (iFormat = 0; iFormat < ma_countof(g_maFormatPriorities); ++iFormat) {
+                if (((ma_snd_pcm_hw_params_test_format_proc)pDevice->pContext->alsa.snd_pcm_hw_params_test_format)(pPCM, pHWParams, ma_convert_ma_format_to_alsa_format(g_maFormatPriorities[iFormat])) == 0) {
+                    formatALSA = ma_convert_ma_format_to_alsa_format(g_maFormatPriorities[iFormat]);
+                    break;
+                }
+            }
+
+            if (formatALSA == MA_SND_PCM_FORMAT_UNKNOWN) {
+                ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+                ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Format not supported. The device does not support any miniaudio formats.");
+                return MA_FORMAT_NOT_SUPPORTED;
+            }
+        }
+
+        resultALSA = ((ma_snd_pcm_hw_params_set_format_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_format)(pPCM, pHWParams, formatALSA);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Format not supported. snd_pcm_hw_params_set_format() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        internalFormat = ma_format_from_alsa(formatALSA);
+        if (internalFormat == ma_format_unknown) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] The chosen format is not supported by miniaudio.");
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+    }
+
+    /* Channels. */
+    {
+        unsigned int channels = pDescriptor->channels;
+        if (channels == 0) {
+            channels = MA_DEFAULT_CHANNELS;
+        }
+
+        resultALSA = ((ma_snd_pcm_hw_params_set_channels_near_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_channels_near)(pPCM, pHWParams, &channels);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set channel count. snd_pcm_hw_params_set_channels_near() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        internalChannels = (ma_uint32)channels;
+    }
+
+    /* Sample Rate */
+    {
+        unsigned int sampleRate;
+
+        /*
+        It appears there's either a bug in ALSA, a bug in some drivers, or I'm doing something silly; but having resampling enabled causes
+        problems with some device configurations when used in conjunction with MMAP access mode. To fix this problem we need to disable
+        resampling.
+
+        To reproduce this problem, open the "plug:dmix" device, and set the sample rate to 44100. Internally, it looks like dmix uses a
+        sample rate of 48000. The hardware parameters will get set correctly with no errors, but it looks like the 44100 -> 48000 resampling
+        doesn't work properly - but only with MMAP access mode. You will notice skipping/crackling in the audio, and it'll run at a slightly
+        faster rate.
+
+        miniaudio has built-in support for sample rate conversion (albeit low quality at the moment), so disabling resampling should be fine
+        for us. The only problem is that it won't be taking advantage of any kind of hardware-accelerated resampling and it won't be very
+        good quality until I get a chance to improve the quality of miniaudio's software sample rate conversion.
+
+        I don't currently know if the dmix plugin is the only one with this error. Indeed, this is the only one I've been able to reproduce
+        this error with. In the future, we may want to restrict the disabling of resampling to only known bad plugins.
+        */
+        ((ma_snd_pcm_hw_params_set_rate_resample_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_rate_resample)(pPCM, pHWParams, 0);
+
+        sampleRate = pDescriptor->sampleRate;
+        if (sampleRate == 0) {
+            sampleRate = MA_DEFAULT_SAMPLE_RATE;
+        }
+
+        resultALSA = ((ma_snd_pcm_hw_params_set_rate_near_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_rate_near)(pPCM, pHWParams, &sampleRate, 0);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Sample rate not supported. snd_pcm_hw_params_set_rate_near() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        internalSampleRate = (ma_uint32)sampleRate;
+    }
+
+    /* Periods. */
+    {
+        ma_uint32 periods = pDescriptor->periodCount;
+
+        resultALSA = ((ma_snd_pcm_hw_params_set_periods_near_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_periods_near)(pPCM, pHWParams, &periods, NULL);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set period count. snd_pcm_hw_params_set_periods_near() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        internalPeriods = periods;
+    }
+
+    /* Buffer Size */
+    {
+        ma_snd_pcm_uframes_t actualBufferSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, internalSampleRate, pConfig->performanceProfile) * internalPeriods;
+
+        resultALSA = ((ma_snd_pcm_hw_params_set_buffer_size_near_proc)pDevice->pContext->alsa.snd_pcm_hw_params_set_buffer_size_near)(pPCM, pHWParams, &actualBufferSizeInFrames);
+        if (resultALSA < 0) {
+            ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set buffer size for device. snd_pcm_hw_params_set_buffer_size() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        internalPeriodSizeInFrames = actualBufferSizeInFrames / internalPeriods;
+    }
+
+    /* Apply hardware parameters. */
+    resultALSA = ((ma_snd_pcm_hw_params_proc)pDevice->pContext->alsa.snd_pcm_hw_params)(pPCM, pHWParams);
+    if (resultALSA < 0) {
+        ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set hardware parameters. snd_pcm_hw_params() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    ma_free(pHWParams, &pDevice->pContext->allocationCallbacks);
+    pHWParams = NULL;
+
+
+    /* Software parameters. */
+    pSWParams = (ma_snd_pcm_sw_params_t*)ma_calloc(((ma_snd_pcm_sw_params_sizeof_proc)pDevice->pContext->alsa.snd_pcm_sw_params_sizeof)(), &pDevice->pContext->allocationCallbacks);
+    if (pSWParams == NULL) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to allocate memory for software parameters.");
+        return MA_OUT_OF_MEMORY;
+    }
+
+    resultALSA = ((ma_snd_pcm_sw_params_current_proc)pDevice->pContext->alsa.snd_pcm_sw_params_current)(pPCM, pSWParams);
+    if (resultALSA < 0) {
+        ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to initialize software parameters. snd_pcm_sw_params_current() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    resultALSA = ((ma_snd_pcm_sw_params_set_avail_min_proc)pDevice->pContext->alsa.snd_pcm_sw_params_set_avail_min)(pPCM, pSWParams, ma_prev_power_of_2(internalPeriodSizeInFrames));
+    if (resultALSA < 0) {
+        ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] snd_pcm_sw_params_set_avail_min() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    resultALSA = ((ma_snd_pcm_sw_params_get_boundary_proc)pDevice->pContext->alsa.snd_pcm_sw_params_get_boundary)(pSWParams, &bufferBoundary);
+    if (resultALSA < 0) {
+        bufferBoundary = internalPeriodSizeInFrames * internalPeriods;
+    }
+
+    if (deviceType == ma_device_type_playback && !isUsingMMap) {   /* Only playback devices in writei/readi mode need a start threshold. */
+        /*
+        Subtle detail here with the start threshold. When in playback-only mode (no full-duplex) we can set the start threshold to
+        the size of a period. But for full-duplex we need to set it such that it is at least two periods.
+        */
+        resultALSA = ((ma_snd_pcm_sw_params_set_start_threshold_proc)pDevice->pContext->alsa.snd_pcm_sw_params_set_start_threshold)(pPCM, pSWParams, internalPeriodSizeInFrames*2);
+        if (resultALSA < 0) {
+            ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set start threshold for playback device. snd_pcm_sw_params_set_start_threshold() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        resultALSA = ((ma_snd_pcm_sw_params_set_stop_threshold_proc)pDevice->pContext->alsa.snd_pcm_sw_params_set_stop_threshold)(pPCM, pSWParams, bufferBoundary);
+        if (resultALSA < 0) { /* Set to boundary to loop instead of stop in the event of an xrun. */
+            ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+            ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set stop threshold for playback device. snd_pcm_sw_params_set_stop_threshold() failed.");
+            return ma_result_from_errno(-resultALSA);
+        }
+    }
+
+    resultALSA = ((ma_snd_pcm_sw_params_proc)pDevice->pContext->alsa.snd_pcm_sw_params)(pPCM, pSWParams);
+    if (resultALSA < 0) {
+        ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to set software parameters. snd_pcm_sw_params() failed.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+    ma_free(pSWParams, &pDevice->pContext->allocationCallbacks);
+    pSWParams = NULL;
+
+
+    /* Grab the internal channel map. For now we're not going to bother trying to change the channel map and instead just do it ourselves. */
+    {
+        ma_snd_pcm_chmap_t* pChmap = NULL;
+        if (pDevice->pContext->alsa.snd_pcm_get_chmap != NULL) {
+            pChmap = ((ma_snd_pcm_get_chmap_proc)pDevice->pContext->alsa.snd_pcm_get_chmap)(pPCM);
+        }
+
+        if (pChmap != NULL) {
+            ma_uint32 iChannel;
+
+            /* There are cases where the returned channel map can have a different channel count than was returned by snd_pcm_hw_params_set_channels_near(). */
+            if (pChmap->channels >= internalChannels) {
+                /* Drop excess channels. */
+                for (iChannel = 0; iChannel < internalChannels; ++iChannel) {
+                    internalChannelMap[iChannel] = ma_convert_alsa_channel_position_to_ma_channel(pChmap->pos[iChannel]);
+                }
+            } else {
+                ma_uint32 i;
+
+                /*
+                Excess channels use defaults. Do an initial fill with defaults, overwrite the first pChmap->channels, validate to ensure there are no duplicate
+                channels. If validation fails, fall back to defaults.
+                */
+                ma_bool32 isValid = MA_TRUE;
+
+                /* Fill with defaults. */
+                ma_channel_map_init_standard(ma_standard_channel_map_alsa, internalChannelMap, ma_countof(internalChannelMap), internalChannels);
+
+                /* Overwrite first pChmap->channels channels. */
+                for (iChannel = 0; iChannel < pChmap->channels; ++iChannel) {
+                    internalChannelMap[iChannel] = ma_convert_alsa_channel_position_to_ma_channel(pChmap->pos[iChannel]);
+                }
+
+                /* Validate. */
+                for (i = 0; i < internalChannels && isValid; ++i) {
+                    ma_uint32 j;
+                    for (j = i+1; j < internalChannels; ++j) {
+                        if (internalChannelMap[i] == internalChannelMap[j]) {
+                            isValid = MA_FALSE;
+                            break;
+                        }
+                    }
+                }
+
+                /* If our channel map is invalid, fall back to defaults. */
+                if (!isValid) {
+                    ma_channel_map_init_standard(ma_standard_channel_map_alsa, internalChannelMap, ma_countof(internalChannelMap), internalChannels);
+                }
+            }
+
+            free(pChmap);
+            pChmap = NULL;
+        } else {
+            /* Could not retrieve the channel map. Fall back to a hard-coded assumption. */
+            ma_channel_map_init_standard(ma_standard_channel_map_alsa, internalChannelMap, ma_countof(internalChannelMap), internalChannels);
+        }
+    }
+
+
+    /*
+    We need to retrieve the poll descriptors so we can use poll() to wait for data to become
+    available for reading or writing. There's no well defined maximum for this so we're just going
+    to allocate this on the heap.
+    */
+    pollDescriptorCount = ((ma_snd_pcm_poll_descriptors_count_proc)pDevice->pContext->alsa.snd_pcm_poll_descriptors_count)(pPCM);
+    if (pollDescriptorCount <= 0) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to retrieve poll descriptors count.");
+        return MA_ERROR;
+    }
+
+    pPollDescriptors = (struct pollfd*)ma_malloc(sizeof(*pPollDescriptors) * (pollDescriptorCount + 1), &pDevice->pContext->allocationCallbacks);   /* +1 because we want room for the wakeup descriptor. */
+    if (pPollDescriptors == NULL) {
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to allocate memory for poll descriptors.");
+        return MA_OUT_OF_MEMORY;
+    }
+
+    /*
+    We need an eventfd to wakeup from poll() and avoid a deadlock in situations where the driver
+    never returns from writei() and readi(). This has been observed with the "pulse" device.
+    */
+    wakeupfd = eventfd(0, 0);
+    if (wakeupfd < 0) {
+        ma_free(pPollDescriptors, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to create eventfd for poll wakeup.");
+        return ma_result_from_errno(errno);
+    }
+
+    /* We'll place the wakeup fd at the start of the buffer. */
+    pPollDescriptors[0].fd      = wakeupfd;
+    pPollDescriptors[0].events  = POLLIN;    /* We only care about waiting to read from the wakeup file descriptor. */
+    pPollDescriptors[0].revents = 0;
+
+    /* We can now extract the PCM poll descriptors which we place after the wakeup descriptor. */
+    pollDescriptorCount = ((ma_snd_pcm_poll_descriptors_proc)pDevice->pContext->alsa.snd_pcm_poll_descriptors)(pPCM, pPollDescriptors + 1, pollDescriptorCount);    /* +1 because we want to place these descriptors after the wakeup descriptor. */
+    if (pollDescriptorCount <= 0) {
+        close(wakeupfd);
+        ma_free(pPollDescriptors, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to retrieve poll descriptors.");
+        return MA_ERROR;
+    }
+
+    if (deviceType == ma_device_type_capture) {
+        pDevice->alsa.pollDescriptorCountCapture = pollDescriptorCount;
+        pDevice->alsa.pPollDescriptorsCapture = pPollDescriptors;
+        pDevice->alsa.wakeupfdCapture = wakeupfd;
+    } else {
+        pDevice->alsa.pollDescriptorCountPlayback = pollDescriptorCount;
+        pDevice->alsa.pPollDescriptorsPlayback = pPollDescriptors;
+        pDevice->alsa.wakeupfdPlayback = wakeupfd;
+    }
+
+
+    /* We're done. Prepare the device. */
+    resultALSA = ((ma_snd_pcm_prepare_proc)pDevice->pContext->alsa.snd_pcm_prepare)(pPCM);
+    if (resultALSA < 0) {
+        close(wakeupfd);
+        ma_free(pPollDescriptors, &pDevice->pContext->allocationCallbacks);
+        ((ma_snd_pcm_close_proc)pDevice->pContext->alsa.snd_pcm_close)(pPCM);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to prepare device.");
+        return ma_result_from_errno(-resultALSA);
+    }
+
+
+    if (deviceType == ma_device_type_capture) {
+        pDevice->alsa.pPCMCapture         = (ma_ptr)pPCM;
+        pDevice->alsa.isUsingMMapCapture  = isUsingMMap;
+    } else {
+        pDevice->alsa.pPCMPlayback        = (ma_ptr)pPCM;
+        pDevice->alsa.isUsingMMapPlayback = isUsingMMap;
+    }
+
+    pDescriptor->format             = internalFormat;
+    pDescriptor->channels           = internalChannels;
+    pDescriptor->sampleRate         = internalSampleRate;
+    ma_channel_map_copy(pDescriptor->channelMap, internalChannelMap, ma_min(internalChannels, MA_MAX_CHANNELS));
+    pDescriptor->periodSizeInFrames = internalPeriodSizeInFrames;
+    pDescriptor->periodCount        = internalPeriods;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__alsa(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->alsa);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_by_type__alsa(pDevice, pConfig, pDescriptorCapture, ma_device_type_capture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_by_type__alsa(pDevice, pConfig, pDescriptorPlayback, ma_device_type_playback);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__alsa(ma_device* pDevice)
+{
+    int resultALSA;
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        resultALSA = ((ma_snd_pcm_start_proc)pDevice->pContext->alsa.snd_pcm_start)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture);
+        if (resultALSA < 0) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to start capture device.");
+            return ma_result_from_errno(-resultALSA);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /* Don't need to do anything for playback because it'll be started automatically when enough data has been written. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__alsa(ma_device* pDevice)
+{
+    /*
+    The stop callback will get called on the worker thread after read/write__alsa() has returned. At this point there is
+    a small chance that our wakeupfd has not been cleared. We'll clear that out now if applicable.
+    */
+    int resultPoll;
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Dropping capture device...\n");
+        ((ma_snd_pcm_drop_proc)pDevice->pContext->alsa.snd_pcm_drop)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture);
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Dropping capture device successful.\n");
+
+        /* We need to prepare the device again, otherwise we won't be able to restart the device. */
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing capture device...\n");
+        if (((ma_snd_pcm_prepare_proc)pDevice->pContext->alsa.snd_pcm_prepare)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture) < 0) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing capture device failed.\n");
+        } else {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing capture device successful.\n");
+        }
+
+    /* Clear the wakeupfd. */
+    resultPoll = poll((struct pollfd*)pDevice->alsa.pPollDescriptorsCapture, 1, 0);
+    if (resultPoll > 0) {
+        ma_uint64 t;
+        read(((struct pollfd*)pDevice->alsa.pPollDescriptorsCapture)[0].fd, &t, sizeof(t));
+    }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Dropping playback device...\n");
+        ((ma_snd_pcm_drop_proc)pDevice->pContext->alsa.snd_pcm_drop)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback);
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Dropping playback device successful.\n");
+
+        /* We need to prepare the device again, otherwise we won't be able to restart the device. */
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing playback device...\n");
+        if (((ma_snd_pcm_prepare_proc)pDevice->pContext->alsa.snd_pcm_prepare)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback) < 0) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing playback device failed.\n");
+        } else {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Preparing playback device successful.\n");
+        }
+
+        /* Clear the wakeupfd. */
+    resultPoll = poll((struct pollfd*)pDevice->alsa.pPollDescriptorsPlayback, 1, 0);
+    if (resultPoll > 0) {
+        ma_uint64 t;
+        read(((struct pollfd*)pDevice->alsa.pPollDescriptorsPlayback)[0].fd, &t, sizeof(t));
+    }
+
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_wait__alsa(ma_device* pDevice, ma_snd_pcm_t* pPCM, struct pollfd* pPollDescriptors, int pollDescriptorCount, short requiredEvent)
+{
+    for (;;) {
+        unsigned short revents;
+        int resultALSA;
+        int resultPoll = poll(pPollDescriptors, pollDescriptorCount, -1);
+        if (resultPoll < 0) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] poll() failed.\n");
+            return ma_result_from_errno(errno);
+        }
+
+        /*
+        Before checking the ALSA poll descriptor flag we need to check if the wakeup descriptor
+        has had it's POLLIN flag set. If so, we need to actually read the data and then exit
+        function. The wakeup descriptor will be the first item in the descriptors buffer.
+        */
+        if ((pPollDescriptors[0].revents & POLLIN) != 0) {
+            ma_uint64 t;
+            int resultRead = read(pPollDescriptors[0].fd, &t, sizeof(t));    /* <-- Important that we read here so that the next write() does not block. */
+            if (resultRead < 0) {
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] read() failed.\n");
+                return ma_result_from_errno(errno);
+            }
+
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] POLLIN set for wakeupfd\n");
+            return MA_DEVICE_NOT_STARTED;
+        }
+
+        /*
+        Getting here means that some data should be able to be read. We need to use ALSA to
+        translate the revents flags for us.
+        */
+        resultALSA = ((ma_snd_pcm_poll_descriptors_revents_proc)pDevice->pContext->alsa.snd_pcm_poll_descriptors_revents)(pPCM, pPollDescriptors + 1, pollDescriptorCount - 1, &revents);   /* +1, -1 to ignore the wakeup descriptor. */
+        if (resultALSA < 0) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] snd_pcm_poll_descriptors_revents() failed.\n");
+            return ma_result_from_errno(-resultALSA);
+        }
+
+        if ((revents & POLLERR) != 0) {
+            ma_snd_pcm_state_t state = ((ma_snd_pcm_state_proc)pDevice->pContext->alsa.snd_pcm_state)(pPCM);
+            if (state == MA_SND_PCM_STATE_XRUN) {
+                /* The PCM is in a xrun state. This will be recovered from at a higher level. We can disregard this. */
+        } else {
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_WARNING, "[ALSA] POLLERR detected. status = %d\n", ((ma_snd_pcm_state_proc)pDevice->pContext->alsa.snd_pcm_state)(pPCM));
+            }
+        }
+
+        if ((revents & requiredEvent) == requiredEvent) {
+            break;  /* We're done. Data available for reading or writing. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_wait_read__alsa(ma_device* pDevice)
+{
+    return ma_device_wait__alsa(pDevice, (ma_snd_pcm_t*)pDevice->alsa.pPCMCapture, (struct pollfd*)pDevice->alsa.pPollDescriptorsCapture, pDevice->alsa.pollDescriptorCountCapture + 1, POLLIN); /* +1 to account for the wakeup descriptor. */
+}
+
+static ma_result ma_device_wait_write__alsa(ma_device* pDevice)
+{
+    return ma_device_wait__alsa(pDevice, (ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback, (struct pollfd*)pDevice->alsa.pPollDescriptorsPlayback, pDevice->alsa.pollDescriptorCountPlayback + 1, POLLOUT); /* +1 to account for the wakeup descriptor. */
+}
+
+static ma_result ma_device_read__alsa(ma_device* pDevice, void* pFramesOut, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    ma_snd_pcm_sframes_t resultALSA = 0;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    while (ma_device_get_state(pDevice) == ma_device_state_started) {
+        ma_result result;
+
+        /* The first thing to do is wait for data to become available for reading. This will return an error code if the device has been stopped. */
+        result = ma_device_wait_read__alsa(pDevice);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        /* Getting here means we should have data available. */
+        resultALSA = ((ma_snd_pcm_readi_proc)pDevice->pContext->alsa.snd_pcm_readi)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture, pFramesOut, frameCount);
+        if (resultALSA >= 0) {
+            break;  /* Success. */
+        } else {
+            if (resultALSA == -EAGAIN) {
+                /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "EGAIN (read)\n");*/
+                continue;   /* Try again. */
+            } else if (resultALSA == -EPIPE) {
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "EPIPE (read)\n");
+
+                /* Overrun. Recover and try again. If this fails we need to return an error. */
+                resultALSA = ((ma_snd_pcm_recover_proc)pDevice->pContext->alsa.snd_pcm_recover)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture, resultALSA, MA_TRUE);
+                if (resultALSA < 0) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to recover device after overrun.");
+                    return ma_result_from_errno((int)-resultALSA);
+                }
+
+                resultALSA = ((ma_snd_pcm_start_proc)pDevice->pContext->alsa.snd_pcm_start)((ma_snd_pcm_t*)pDevice->alsa.pPCMCapture);
+                if (resultALSA < 0) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to start device after underrun.");
+                    return ma_result_from_errno((int)-resultALSA);
+                }
+
+                continue;   /* Try reading again. */
+            }
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = resultALSA;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_write__alsa(ma_device* pDevice, const void* pFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    ma_snd_pcm_sframes_t resultALSA = 0;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pFrames != NULL);
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    while (ma_device_get_state(pDevice) == ma_device_state_started) {
+        ma_result result;
+
+        /* The first thing to do is wait for space to become available for writing. This will return an error code if the device has been stopped. */
+        result = ma_device_wait_write__alsa(pDevice);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        resultALSA = ((ma_snd_pcm_writei_proc)pDevice->pContext->alsa.snd_pcm_writei)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback, pFrames, frameCount);
+        if (resultALSA >= 0) {
+            break;  /* Success. */
+        } else {
+            if (resultALSA == -EAGAIN) {
+                /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "EGAIN (write)\n");*/
+                continue;   /* Try again. */
+            } else if (resultALSA == -EPIPE) {
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "EPIPE (write)\n");
+
+                /* Underrun. Recover and try again. If this fails we need to return an error. */
+                resultALSA = ((ma_snd_pcm_recover_proc)pDevice->pContext->alsa.snd_pcm_recover)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback, resultALSA, MA_TRUE);    /* MA_TRUE=silent (don't print anything on error). */
+                if (resultALSA < 0) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to recover device after underrun.");
+                    return ma_result_from_errno((int)-resultALSA);
+                }
+
+                /*
+                In my testing I have had a situation where writei() does not automatically restart the device even though I've set it
+                up as such in the software parameters. What will happen is writei() will block indefinitely even though the number of
+                frames is well beyond the auto-start threshold. To work around this I've needed to add an explicit start here. Not sure
+                if this is me just being stupid and not recovering the device properly, but this definitely feels like something isn't
+                quite right here.
+                */
+                resultALSA = ((ma_snd_pcm_start_proc)pDevice->pContext->alsa.snd_pcm_start)((ma_snd_pcm_t*)pDevice->alsa.pPCMPlayback);
+                if (resultALSA < 0) {
+                    ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] Failed to start device after underrun.");
+                    return ma_result_from_errno((int)-resultALSA);
+                }
+
+                continue;   /* Try writing again. */
+            }
+        }
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = resultALSA;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_data_loop_wakeup__alsa(ma_device* pDevice)
+{
+    ma_uint64 t = 1;
+    int resultWrite = 0;
+
+    MA_ASSERT(pDevice != NULL);
+
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Waking up...\n");
+
+    /* Write to an eventfd to trigger a wakeup from poll() and abort any reading or writing. */
+    if (pDevice->alsa.pPollDescriptorsCapture != NULL) {
+        resultWrite = write(pDevice->alsa.wakeupfdCapture, &t, sizeof(t));
+    }
+    if (pDevice->alsa.pPollDescriptorsPlayback != NULL) {
+        resultWrite = write(pDevice->alsa.wakeupfdPlayback, &t, sizeof(t));
+    }
+
+    if (resultWrite < 0) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[ALSA] write() failed.\n");
+        return ma_result_from_errno(errno);
+    }
+
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[ALSA] Waking up completed successfully.\n");
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__alsa(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_alsa);
+
+    /* Clean up memory for memory leak checkers. */
+    ((ma_snd_config_update_free_global_proc)pContext->alsa.snd_config_update_free_global)();
+
+#ifndef MA_NO_RUNTIME_LINKING
+    ma_dlclose(ma_context_get_log(pContext), pContext->alsa.asoundSO);
+#endif
+
+    ma_mutex_uninit(&pContext->alsa.internalDeviceEnumLock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__alsa(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    ma_result result;
+#ifndef MA_NO_RUNTIME_LINKING
+    const char* libasoundNames[] = {
+        "libasound.so.2",
+        "libasound.so"
+    };
+    size_t i;
+
+    for (i = 0; i < ma_countof(libasoundNames); ++i) {
+        pContext->alsa.asoundSO = ma_dlopen(ma_context_get_log(pContext), libasoundNames[i]);
+        if (pContext->alsa.asoundSO != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->alsa.asoundSO == NULL) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "[ALSA] Failed to open shared object.\n");
+        return MA_NO_BACKEND;
+    }
+
+    pContext->alsa.snd_pcm_open                           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_open");
+    pContext->alsa.snd_pcm_close                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_close");
+    pContext->alsa.snd_pcm_hw_params_sizeof               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_sizeof");
+    pContext->alsa.snd_pcm_hw_params_any                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_any");
+    pContext->alsa.snd_pcm_hw_params_set_format           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_format");
+    pContext->alsa.snd_pcm_hw_params_set_format_first     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_format_first");
+    pContext->alsa.snd_pcm_hw_params_get_format_mask      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_format_mask");
+    pContext->alsa.snd_pcm_hw_params_set_channels         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_channels");
+    pContext->alsa.snd_pcm_hw_params_set_channels_near    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_channels_near");
+    pContext->alsa.snd_pcm_hw_params_set_channels_minmax  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_channels_minmax");
+    pContext->alsa.snd_pcm_hw_params_set_rate_resample    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_rate_resample");
+    pContext->alsa.snd_pcm_hw_params_set_rate             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_rate");
+    pContext->alsa.snd_pcm_hw_params_set_rate_near        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_rate_near");
+    pContext->alsa.snd_pcm_hw_params_set_buffer_size_near = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_buffer_size_near");
+    pContext->alsa.snd_pcm_hw_params_set_periods_near     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_periods_near");
+    pContext->alsa.snd_pcm_hw_params_set_access           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_set_access");
+    pContext->alsa.snd_pcm_hw_params_get_format           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_format");
+    pContext->alsa.snd_pcm_hw_params_get_channels         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_channels");
+    pContext->alsa.snd_pcm_hw_params_get_channels_min     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_channels_min");
+    pContext->alsa.snd_pcm_hw_params_get_channels_max     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_channels_max");
+    pContext->alsa.snd_pcm_hw_params_get_rate             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_rate");
+    pContext->alsa.snd_pcm_hw_params_get_rate_min         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_rate_min");
+    pContext->alsa.snd_pcm_hw_params_get_rate_max         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_rate_max");
+    pContext->alsa.snd_pcm_hw_params_get_buffer_size      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_buffer_size");
+    pContext->alsa.snd_pcm_hw_params_get_periods          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_periods");
+    pContext->alsa.snd_pcm_hw_params_get_access           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_get_access");
+    pContext->alsa.snd_pcm_hw_params_test_format          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_test_format");
+    pContext->alsa.snd_pcm_hw_params_test_channels        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_test_channels");
+    pContext->alsa.snd_pcm_hw_params_test_rate            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params_test_rate");
+    pContext->alsa.snd_pcm_hw_params                      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_hw_params");
+    pContext->alsa.snd_pcm_sw_params_sizeof               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_sizeof");
+    pContext->alsa.snd_pcm_sw_params_current              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_current");
+    pContext->alsa.snd_pcm_sw_params_get_boundary         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_get_boundary");
+    pContext->alsa.snd_pcm_sw_params_set_avail_min        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_set_avail_min");
+    pContext->alsa.snd_pcm_sw_params_set_start_threshold  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_set_start_threshold");
+    pContext->alsa.snd_pcm_sw_params_set_stop_threshold   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params_set_stop_threshold");
+    pContext->alsa.snd_pcm_sw_params                      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_sw_params");
+    pContext->alsa.snd_pcm_format_mask_sizeof             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_format_mask_sizeof");
+    pContext->alsa.snd_pcm_format_mask_test               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_format_mask_test");
+    pContext->alsa.snd_pcm_get_chmap                      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_get_chmap");
+    pContext->alsa.snd_pcm_state                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_state");
+    pContext->alsa.snd_pcm_prepare                        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_prepare");
+    pContext->alsa.snd_pcm_start                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_start");
+    pContext->alsa.snd_pcm_drop                           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_drop");
+    pContext->alsa.snd_pcm_drain                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_drain");
+    pContext->alsa.snd_pcm_reset                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_reset");
+    pContext->alsa.snd_device_name_hint                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_device_name_hint");
+    pContext->alsa.snd_device_name_get_hint               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_device_name_get_hint");
+    pContext->alsa.snd_card_get_index                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_card_get_index");
+    pContext->alsa.snd_device_name_free_hint              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_device_name_free_hint");
+    pContext->alsa.snd_pcm_mmap_begin                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_mmap_begin");
+    pContext->alsa.snd_pcm_mmap_commit                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_mmap_commit");
+    pContext->alsa.snd_pcm_recover                        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_recover");
+    pContext->alsa.snd_pcm_readi                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_readi");
+    pContext->alsa.snd_pcm_writei                         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_writei");
+    pContext->alsa.snd_pcm_avail                          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_avail");
+    pContext->alsa.snd_pcm_avail_update                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_avail_update");
+    pContext->alsa.snd_pcm_wait                           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_wait");
+    pContext->alsa.snd_pcm_nonblock                       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_nonblock");
+    pContext->alsa.snd_pcm_info                           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_info");
+    pContext->alsa.snd_pcm_info_sizeof                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_info_sizeof");
+    pContext->alsa.snd_pcm_info_get_name                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_info_get_name");
+    pContext->alsa.snd_pcm_poll_descriptors               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_poll_descriptors");
+    pContext->alsa.snd_pcm_poll_descriptors_count         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_poll_descriptors_count");
+    pContext->alsa.snd_pcm_poll_descriptors_revents       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_pcm_poll_descriptors_revents");
+    pContext->alsa.snd_config_update_free_global          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->alsa.asoundSO, "snd_config_update_free_global");
+#else
+    /* The system below is just for type safety. */
+    ma_snd_pcm_open_proc                           _snd_pcm_open                           = snd_pcm_open;
+    ma_snd_pcm_close_proc                          _snd_pcm_close                          = snd_pcm_close;
+    ma_snd_pcm_hw_params_sizeof_proc               _snd_pcm_hw_params_sizeof               = snd_pcm_hw_params_sizeof;
+    ma_snd_pcm_hw_params_any_proc                  _snd_pcm_hw_params_any                  = snd_pcm_hw_params_any;
+    ma_snd_pcm_hw_params_set_format_proc           _snd_pcm_hw_params_set_format           = snd_pcm_hw_params_set_format;
+    ma_snd_pcm_hw_params_set_format_first_proc     _snd_pcm_hw_params_set_format_first     = snd_pcm_hw_params_set_format_first;
+    ma_snd_pcm_hw_params_get_format_mask_proc      _snd_pcm_hw_params_get_format_mask      = snd_pcm_hw_params_get_format_mask;
+    ma_snd_pcm_hw_params_set_channels_proc         _snd_pcm_hw_params_set_channels         = snd_pcm_hw_params_set_channels;
+    ma_snd_pcm_hw_params_set_channels_near_proc    _snd_pcm_hw_params_set_channels_near    = snd_pcm_hw_params_set_channels_near;
+    ma_snd_pcm_hw_params_set_rate_resample_proc    _snd_pcm_hw_params_set_rate_resample    = snd_pcm_hw_params_set_rate_resample;
+    ma_snd_pcm_hw_params_set_rate_near             _snd_pcm_hw_params_set_rate             = snd_pcm_hw_params_set_rate;
+    ma_snd_pcm_hw_params_set_rate_near_proc        _snd_pcm_hw_params_set_rate_near        = snd_pcm_hw_params_set_rate_near;
+    ma_snd_pcm_hw_params_set_rate_minmax_proc      _snd_pcm_hw_params_set_rate_minmax      = snd_pcm_hw_params_set_rate_minmax;
+    ma_snd_pcm_hw_params_set_buffer_size_near_proc _snd_pcm_hw_params_set_buffer_size_near = snd_pcm_hw_params_set_buffer_size_near;
+    ma_snd_pcm_hw_params_set_periods_near_proc     _snd_pcm_hw_params_set_periods_near     = snd_pcm_hw_params_set_periods_near;
+    ma_snd_pcm_hw_params_set_access_proc           _snd_pcm_hw_params_set_access           = snd_pcm_hw_params_set_access;
+    ma_snd_pcm_hw_params_get_format_proc           _snd_pcm_hw_params_get_format           = snd_pcm_hw_params_get_format;
+    ma_snd_pcm_hw_params_get_channels_proc         _snd_pcm_hw_params_get_channels         = snd_pcm_hw_params_get_channels;
+    ma_snd_pcm_hw_params_get_channels_min_proc     _snd_pcm_hw_params_get_channels_min     = snd_pcm_hw_params_get_channels_min;
+    ma_snd_pcm_hw_params_get_channels_max_proc     _snd_pcm_hw_params_get_channels_max     = snd_pcm_hw_params_get_channels_max;
+    ma_snd_pcm_hw_params_get_rate_proc             _snd_pcm_hw_params_get_rate             = snd_pcm_hw_params_get_rate;
+    ma_snd_pcm_hw_params_get_rate_min_proc         _snd_pcm_hw_params_get_rate_min         = snd_pcm_hw_params_get_rate_min;
+    ma_snd_pcm_hw_params_get_rate_max_proc         _snd_pcm_hw_params_get_rate_max         = snd_pcm_hw_params_get_rate_max;
+    ma_snd_pcm_hw_params_get_buffer_size_proc      _snd_pcm_hw_params_get_buffer_size      = snd_pcm_hw_params_get_buffer_size;
+    ma_snd_pcm_hw_params_get_periods_proc          _snd_pcm_hw_params_get_periods          = snd_pcm_hw_params_get_periods;
+    ma_snd_pcm_hw_params_get_access_proc           _snd_pcm_hw_params_get_access           = snd_pcm_hw_params_get_access;
+    ma_snd_pcm_hw_params_test_format_proc          _snd_pcm_hw_params_test_format          = snd_pcm_hw_params_test_format;
+    ma_snd_pcm_hw_params_test_channels_proc        _snd_pcm_hw_params_test_channels        = snd_pcm_hw_params_test_channels;
+    ma_snd_pcm_hw_params_test_rate_proc            _snd_pcm_hw_params_test_rate            = snd_pcm_hw_params_test_rate;
+    ma_snd_pcm_hw_params_proc                      _snd_pcm_hw_params                      = snd_pcm_hw_params;
+    ma_snd_pcm_sw_params_sizeof_proc               _snd_pcm_sw_params_sizeof               = snd_pcm_sw_params_sizeof;
+    ma_snd_pcm_sw_params_current_proc              _snd_pcm_sw_params_current              = snd_pcm_sw_params_current;
+    ma_snd_pcm_sw_params_get_boundary_proc         _snd_pcm_sw_params_get_boundary         = snd_pcm_sw_params_get_boundary;
+    ma_snd_pcm_sw_params_set_avail_min_proc        _snd_pcm_sw_params_set_avail_min        = snd_pcm_sw_params_set_avail_min;
+    ma_snd_pcm_sw_params_set_start_threshold_proc  _snd_pcm_sw_params_set_start_threshold  = snd_pcm_sw_params_set_start_threshold;
+    ma_snd_pcm_sw_params_set_stop_threshold_proc   _snd_pcm_sw_params_set_stop_threshold   = snd_pcm_sw_params_set_stop_threshold;
+    ma_snd_pcm_sw_params_proc                      _snd_pcm_sw_params                      = snd_pcm_sw_params;
+    ma_snd_pcm_format_mask_sizeof_proc             _snd_pcm_format_mask_sizeof             = snd_pcm_format_mask_sizeof;
+    ma_snd_pcm_format_mask_test_proc               _snd_pcm_format_mask_test               = snd_pcm_format_mask_test;
+    ma_snd_pcm_get_chmap_proc                      _snd_pcm_get_chmap                      = snd_pcm_get_chmap;
+    ma_snd_pcm_state_proc                          _snd_pcm_state                          = snd_pcm_state;
+    ma_snd_pcm_prepare_proc                        _snd_pcm_prepare                        = snd_pcm_prepare;
+    ma_snd_pcm_start_proc                          _snd_pcm_start                          = snd_pcm_start;
+    ma_snd_pcm_drop_proc                           _snd_pcm_drop                           = snd_pcm_drop;
+    ma_snd_pcm_drain_proc                          _snd_pcm_drain                          = snd_pcm_drain;
+    ma_snd_pcm_reset_proc                          _snd_pcm_reset                          = snd_pcm_reset;
+    ma_snd_device_name_hint_proc                   _snd_device_name_hint                   = snd_device_name_hint;
+    ma_snd_device_name_get_hint_proc               _snd_device_name_get_hint               = snd_device_name_get_hint;
+    ma_snd_card_get_index_proc                     _snd_card_get_index                     = snd_card_get_index;
+    ma_snd_device_name_free_hint_proc              _snd_device_name_free_hint              = snd_device_name_free_hint;
+    ma_snd_pcm_mmap_begin_proc                     _snd_pcm_mmap_begin                     = snd_pcm_mmap_begin;
+    ma_snd_pcm_mmap_commit_proc                    _snd_pcm_mmap_commit                    = snd_pcm_mmap_commit;
+    ma_snd_pcm_recover_proc                        _snd_pcm_recover                        = snd_pcm_recover;
+    ma_snd_pcm_readi_proc                          _snd_pcm_readi                          = snd_pcm_readi;
+    ma_snd_pcm_writei_proc                         _snd_pcm_writei                         = snd_pcm_writei;
+    ma_snd_pcm_avail_proc                          _snd_pcm_avail                          = snd_pcm_avail;
+    ma_snd_pcm_avail_update_proc                   _snd_pcm_avail_update                   = snd_pcm_avail_update;
+    ma_snd_pcm_wait_proc                           _snd_pcm_wait                           = snd_pcm_wait;
+    ma_snd_pcm_nonblock_proc                       _snd_pcm_nonblock                       = snd_pcm_nonblock;
+    ma_snd_pcm_info_proc                           _snd_pcm_info                           = snd_pcm_info;
+    ma_snd_pcm_info_sizeof_proc                    _snd_pcm_info_sizeof                    = snd_pcm_info_sizeof;
+    ma_snd_pcm_info_get_name_proc                  _snd_pcm_info_get_name                  = snd_pcm_info_get_name;
+    ma_snd_pcm_poll_descriptors                    _snd_pcm_poll_descriptors               = snd_pcm_poll_descriptors;
+    ma_snd_pcm_poll_descriptors_count              _snd_pcm_poll_descriptors_count         = snd_pcm_poll_descriptors_count;
+    ma_snd_pcm_poll_descriptors_revents            _snd_pcm_poll_descriptors_revents       = snd_pcm_poll_descriptors_revents;
+    ma_snd_config_update_free_global_proc          _snd_config_update_free_global          = snd_config_update_free_global;
+
+    pContext->alsa.snd_pcm_open                           = (ma_proc)_snd_pcm_open;
+    pContext->alsa.snd_pcm_close                          = (ma_proc)_snd_pcm_close;
+    pContext->alsa.snd_pcm_hw_params_sizeof               = (ma_proc)_snd_pcm_hw_params_sizeof;
+    pContext->alsa.snd_pcm_hw_params_any                  = (ma_proc)_snd_pcm_hw_params_any;
+    pContext->alsa.snd_pcm_hw_params_set_format           = (ma_proc)_snd_pcm_hw_params_set_format;
+    pContext->alsa.snd_pcm_hw_params_set_format_first     = (ma_proc)_snd_pcm_hw_params_set_format_first;
+    pContext->alsa.snd_pcm_hw_params_get_format_mask      = (ma_proc)_snd_pcm_hw_params_get_format_mask;
+    pContext->alsa.snd_pcm_hw_params_set_channels         = (ma_proc)_snd_pcm_hw_params_set_channels;
+    pContext->alsa.snd_pcm_hw_params_set_channels_near    = (ma_proc)_snd_pcm_hw_params_set_channels_near;
+    pContext->alsa.snd_pcm_hw_params_set_channels_minmax  = (ma_proc)_snd_pcm_hw_params_set_channels_minmax;
+    pContext->alsa.snd_pcm_hw_params_set_rate_resample    = (ma_proc)_snd_pcm_hw_params_set_rate_resample;
+    pContext->alsa.snd_pcm_hw_params_set_rate             = (ma_proc)_snd_pcm_hw_params_set_rate;
+    pContext->alsa.snd_pcm_hw_params_set_rate_near        = (ma_proc)_snd_pcm_hw_params_set_rate_near;
+    pContext->alsa.snd_pcm_hw_params_set_buffer_size_near = (ma_proc)_snd_pcm_hw_params_set_buffer_size_near;
+    pContext->alsa.snd_pcm_hw_params_set_periods_near     = (ma_proc)_snd_pcm_hw_params_set_periods_near;
+    pContext->alsa.snd_pcm_hw_params_set_access           = (ma_proc)_snd_pcm_hw_params_set_access;
+    pContext->alsa.snd_pcm_hw_params_get_format           = (ma_proc)_snd_pcm_hw_params_get_format;
+    pContext->alsa.snd_pcm_hw_params_get_channels         = (ma_proc)_snd_pcm_hw_params_get_channels;
+    pContext->alsa.snd_pcm_hw_params_get_channels_min     = (ma_proc)_snd_pcm_hw_params_get_channels_min;
+    pContext->alsa.snd_pcm_hw_params_get_channels_max     = (ma_proc)_snd_pcm_hw_params_get_channels_max;
+    pContext->alsa.snd_pcm_hw_params_get_rate             = (ma_proc)_snd_pcm_hw_params_get_rate;
+    pContext->alsa.snd_pcm_hw_params_get_rate_min         = (ma_proc)_snd_pcm_hw_params_get_rate_min;
+    pContext->alsa.snd_pcm_hw_params_get_rate_max         = (ma_proc)_snd_pcm_hw_params_get_rate_max;
+    pContext->alsa.snd_pcm_hw_params_get_buffer_size      = (ma_proc)_snd_pcm_hw_params_get_buffer_size;
+    pContext->alsa.snd_pcm_hw_params_get_periods          = (ma_proc)_snd_pcm_hw_params_get_periods;
+    pContext->alsa.snd_pcm_hw_params_get_access           = (ma_proc)_snd_pcm_hw_params_get_access;
+    pContext->alsa.snd_pcm_hw_params_test_format          = (ma_proc)_snd_pcm_hw_params_test_format;
+    pContext->alsa.snd_pcm_hw_params_test_channels        = (ma_proc)_snd_pcm_hw_params_test_channels;
+    pContext->alsa.snd_pcm_hw_params_test_rate            = (ma_proc)_snd_pcm_hw_params_test_rate;
+    pContext->alsa.snd_pcm_hw_params                      = (ma_proc)_snd_pcm_hw_params;
+    pContext->alsa.snd_pcm_sw_params_sizeof               = (ma_proc)_snd_pcm_sw_params_sizeof;
+    pContext->alsa.snd_pcm_sw_params_current              = (ma_proc)_snd_pcm_sw_params_current;
+    pContext->alsa.snd_pcm_sw_params_get_boundary         = (ma_proc)_snd_pcm_sw_params_get_boundary;
+    pContext->alsa.snd_pcm_sw_params_set_avail_min        = (ma_proc)_snd_pcm_sw_params_set_avail_min;
+    pContext->alsa.snd_pcm_sw_params_set_start_threshold  = (ma_proc)_snd_pcm_sw_params_set_start_threshold;
+    pContext->alsa.snd_pcm_sw_params_set_stop_threshold   = (ma_proc)_snd_pcm_sw_params_set_stop_threshold;
+    pContext->alsa.snd_pcm_sw_params                      = (ma_proc)_snd_pcm_sw_params;
+    pContext->alsa.snd_pcm_format_mask_sizeof             = (ma_proc)_snd_pcm_format_mask_sizeof;
+    pContext->alsa.snd_pcm_format_mask_test               = (ma_proc)_snd_pcm_format_mask_test;
+    pContext->alsa.snd_pcm_get_chmap                      = (ma_proc)_snd_pcm_get_chmap;
+    pContext->alsa.snd_pcm_state                          = (ma_proc)_snd_pcm_state;
+    pContext->alsa.snd_pcm_prepare                        = (ma_proc)_snd_pcm_prepare;
+    pContext->alsa.snd_pcm_start                          = (ma_proc)_snd_pcm_start;
+    pContext->alsa.snd_pcm_drop                           = (ma_proc)_snd_pcm_drop;
+    pContext->alsa.snd_pcm_drain                          = (ma_proc)_snd_pcm_drain;
+    pContext->alsa.snd_pcm_reset                          = (ma_proc)_snd_pcm_reset;
+    pContext->alsa.snd_device_name_hint                   = (ma_proc)_snd_device_name_hint;
+    pContext->alsa.snd_device_name_get_hint               = (ma_proc)_snd_device_name_get_hint;
+    pContext->alsa.snd_card_get_index                     = (ma_proc)_snd_card_get_index;
+    pContext->alsa.snd_device_name_free_hint              = (ma_proc)_snd_device_name_free_hint;
+    pContext->alsa.snd_pcm_mmap_begin                     = (ma_proc)_snd_pcm_mmap_begin;
+    pContext->alsa.snd_pcm_mmap_commit                    = (ma_proc)_snd_pcm_mmap_commit;
+    pContext->alsa.snd_pcm_recover                        = (ma_proc)_snd_pcm_recover;
+    pContext->alsa.snd_pcm_readi                          = (ma_proc)_snd_pcm_readi;
+    pContext->alsa.snd_pcm_writei                         = (ma_proc)_snd_pcm_writei;
+    pContext->alsa.snd_pcm_avail                          = (ma_proc)_snd_pcm_avail;
+    pContext->alsa.snd_pcm_avail_update                   = (ma_proc)_snd_pcm_avail_update;
+    pContext->alsa.snd_pcm_wait                           = (ma_proc)_snd_pcm_wait;
+    pContext->alsa.snd_pcm_nonblock                       = (ma_proc)_snd_pcm_nonblock;
+    pContext->alsa.snd_pcm_info                           = (ma_proc)_snd_pcm_info;
+    pContext->alsa.snd_pcm_info_sizeof                    = (ma_proc)_snd_pcm_info_sizeof;
+    pContext->alsa.snd_pcm_info_get_name                  = (ma_proc)_snd_pcm_info_get_name;
+    pContext->alsa.snd_pcm_poll_descriptors               = (ma_proc)_snd_pcm_poll_descriptors;
+    pContext->alsa.snd_pcm_poll_descriptors_count         = (ma_proc)_snd_pcm_poll_descriptors_count;
+    pContext->alsa.snd_pcm_poll_descriptors_revents       = (ma_proc)_snd_pcm_poll_descriptors_revents;
+    pContext->alsa.snd_config_update_free_global          = (ma_proc)_snd_config_update_free_global;
+#endif
+
+    pContext->alsa.useVerboseDeviceEnumeration = pConfig->alsa.useVerboseDeviceEnumeration;
+
+    result = ma_mutex_init(&pContext->alsa.internalDeviceEnumLock);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[ALSA] WARNING: Failed to initialize mutex for internal device enumeration.");
+        return result;
+    }
+
+    pCallbacks->onContextInit             = ma_context_init__alsa;
+    pCallbacks->onContextUninit           = ma_context_uninit__alsa;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__alsa;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__alsa;
+    pCallbacks->onDeviceInit              = ma_device_init__alsa;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__alsa;
+    pCallbacks->onDeviceStart             = ma_device_start__alsa;
+    pCallbacks->onDeviceStop              = ma_device_stop__alsa;
+    pCallbacks->onDeviceRead              = ma_device_read__alsa;
+    pCallbacks->onDeviceWrite             = ma_device_write__alsa;
+    pCallbacks->onDeviceDataLoop          = NULL;
+    pCallbacks->onDeviceDataLoopWakeup    = ma_device_data_loop_wakeup__alsa;
+
+    return MA_SUCCESS;
+}
+#endif  /* ALSA */
+
+
+
+/******************************************************************************
+
+PulseAudio Backend
+
+******************************************************************************/
+#ifdef MA_HAS_PULSEAUDIO
+/*
+The PulseAudio API, along with Apple's Core Audio, is the worst of the maintream audio APIs. This is a brief description of what's going on
+in the PulseAudio backend. I apologize if this gets a bit ranty for your liking - you might want to skip this discussion.
+
+PulseAudio has something they call the "Simple API", which unfortunately isn't suitable for miniaudio. I've not seen anywhere where it
+allows you to enumerate over devices, nor does it seem to support the ability to stop and start streams. Looking at the documentation, it
+appears as though the stream is constantly running and you prevent sound from being emitted or captured by simply not calling the read or
+write functions. This is not a professional solution as it would be much better to *actually* stop the underlying stream. Perhaps the
+simple API has some smarts to do this automatically, but I'm not sure. Another limitation with the simple API is that it seems inefficient
+when you want to have multiple streams to a single context. For these reasons, miniaudio is not using the simple API.
+
+Since we're not using the simple API, we're left with the asynchronous API as our only other option. And boy, is this where it starts to
+get fun, and I don't mean that in a good way...
+
+The problems start with the very name of the API - "asynchronous". Yes, this is an asynchronous oriented API which means your commands
+don't immediately take effect. You instead need to issue your commands, and then wait for them to complete. The waiting mechanism is
+enabled through the use of a "main loop". In the asychronous API you cannot get away from the main loop, and the main loop is where almost
+all of PulseAudio's problems stem from.
+
+When you first initialize PulseAudio you need an object referred to as "main loop". You can implement this yourself by defining your own
+vtable, but it's much easier to just use one of the built-in main loop implementations. There's two generic implementations called
+pa_mainloop and pa_threaded_mainloop, and another implementation specific to GLib called pa_glib_mainloop. We're using pa_threaded_mainloop
+because it simplifies management of the worker thread. The idea of the main loop object is pretty self explanatory - you're supposed to use
+it to implement a worker thread which runs in a loop. The main loop is where operations are actually executed.
+
+To initialize the main loop, you just use `pa_threaded_mainloop_new()`. This is the first function you'll call. You can then get a pointer
+to the vtable with `pa_threaded_mainloop_get_api()` (the main loop vtable is called `pa_mainloop_api`). Again, you can bypass the threaded
+main loop object entirely and just implement `pa_mainloop_api` directly, but there's no need for it unless you're doing something extremely
+specialized such as if you want to integrate it into your application's existing main loop infrastructure.
+
+(EDIT 2021-01-26: miniaudio is no longer using `pa_threaded_mainloop` due to this issue: https://github.com/mackron/miniaudio/issues/262.
+It is now using `pa_mainloop` which turns out to be a simpler solution anyway. The rest of this rant still applies, however.)
+
+Once you have your main loop vtable (the `pa_mainloop_api` object) you can create the PulseAudio context. This is very similar to
+miniaudio's context and they map to each other quite well. You have one context to many streams, which is basically the same as miniaudio's
+one `ma_context` to many `ma_device`s. Here's where it starts to get annoying, however. When you first create the PulseAudio context, which
+is done with `pa_context_new()`, it's not actually connected to anything. When you connect, you call `pa_context_connect()`. However, if
+you remember, PulseAudio is an asynchronous API. That means you cannot just assume the context is connected after `pa_context_context()`
+has returned. You instead need to wait for it to connect. To do this, you need to either wait for a callback to get fired, which you can
+set with `pa_context_set_state_callback()`, or you can continuously poll the context's state. Either way, you need to run this in a loop.
+All objects from here out are created from the context, and, I believe, you can't be creating these objects until the context is connected.
+This waiting loop is therefore unavoidable. In order for the waiting to ever complete, however, the main loop needs to be running. Before
+attempting to connect the context, the main loop needs to be started with `pa_threaded_mainloop_start()`.
+
+The reason for this asynchronous design is to support cases where you're connecting to a remote server, say through a local network or an
+internet connection. However, the *VAST* majority of cases don't involve this at all - they just connect to a local "server" running on the
+host machine. The fact that this would be the default rather than making `pa_context_connect()` synchronous tends to boggle the mind.
+
+Once the context has been created and connected you can start creating a stream. A PulseAudio stream is analogous to miniaudio's device.
+The initialization of a stream is fairly standard - you configure some attributes (analogous to miniaudio's device config) and then call
+`pa_stream_new()` to actually create it. Here is where we start to get into "operations". When configuring the stream, you can get
+information about the source (such as sample format, sample rate, etc.), however it's not synchronous. Instead, a `pa_operation` object
+is returned from `pa_context_get_source_info_by_name()` (capture) or `pa_context_get_sink_info_by_name()` (playback). Then, you need to
+run a loop (again!) to wait for the operation to complete which you can determine via a callback or polling, just like we did with the
+context. Then, as an added bonus, you need to decrement the reference counter of the `pa_operation` object to ensure memory is cleaned up.
+All of that just to retrieve basic information about a device!
+
+Once the basic information about the device has been retrieved, miniaudio can now create the stream with `ma_stream_new()`. Like the
+context, this needs to be connected. But we need to be careful here, because we're now about to introduce one of the most horrific design
+choices in PulseAudio.
+
+PulseAudio allows you to specify a callback that is fired when data can be written to or read from a stream. The language is important here
+because PulseAudio takes it literally, specifically the "can be". You would think these callbacks would be appropriate as the place for
+writing and reading data to and from the stream, and that would be right, except when it's not. When you initialize the stream, you can
+set a flag that tells PulseAudio to not start the stream automatically. This is required because miniaudio does not auto-start devices
+straight after initialization - you need to call `ma_device_start()` manually. The problem is that even when this flag is specified,
+PulseAudio will immediately fire it's write or read callback. This is *technically* correct (based on the wording in the documentation)
+because indeed, data *can* be written at this point. The problem is that it's not *practical*. It makes sense that the write/read callback
+would be where a program will want to write or read data to or from the stream, but when it's called before the application has even
+requested that the stream be started, it's just not practical because the program probably isn't ready for any kind of data delivery at
+that point (it may still need to load files or whatnot). Instead, this callback should only be fired when the application requests the
+stream be started which is how it works with literally *every* other callback-based audio API. Since miniaudio forbids firing of the data
+callback until the device has been started (as it should be with *all* callback based APIs), logic needs to be added to ensure miniaudio
+doesn't just blindly fire the application-defined data callback from within the PulseAudio callback before the stream has actually been
+started. The device state is used for this - if the state is anything other than `ma_device_state_starting` or `ma_device_state_started`, the main data
+callback is not fired.
+
+This, unfortunately, is not the end of the problems with the PulseAudio write callback. Any normal callback based audio API will
+continuously fire the callback at regular intervals based on the size of the internal buffer. This will only ever be fired when the device
+is running, and will be fired regardless of whether or not the user actually wrote anything to the device/stream. This not the case in
+PulseAudio. In PulseAudio, the data callback will *only* be called if you wrote something to it previously. That means, if you don't call
+`pa_stream_write()`, the callback will not get fired. On the surface you wouldn't think this would matter because you should be always
+writing data, and if you don't have anything to write, just write silence. That's fine until you want to drain the stream. You see, if
+you're continuously writing data to the stream, the stream will never get drained! That means in order to drain the stream, you need to
+*not* write data to it! But remember, when you don't write data to the stream, the callback won't get fired again! Why is draining
+important? Because that's how we've defined stopping to work in miniaudio. In miniaudio, stopping the device requires it to be drained
+before returning from ma_device_stop(). So we've stopped the device, which requires us to drain, but draining requires us to *not* write
+data to the stream (or else it won't ever complete draining), but not writing to the stream means the callback won't get fired again!
+
+This becomes a problem when stopping and then restarting the device. When the device is stopped, it's drained, which requires us to *not*
+write anything to the stream. But then, since we didn't write anything to it, the write callback will *never* get called again if we just
+resume the stream naively. This means that starting the stream requires us to write data to the stream from outside the callback. This
+disconnect is something PulseAudio has got seriously wrong - there should only ever be a single source of data delivery, that being the
+callback. (I have tried using `pa_stream_flush()` to trigger the write callback to fire, but this just doesn't work for some reason.)
+
+Once you've created the stream, you need to connect it which involves the whole waiting procedure. This is the same process as the context,
+only this time you'll poll for the state with `pa_stream_get_status()`. The starting and stopping of a streaming is referred to as
+"corking" in PulseAudio. The analogy is corking a barrel. To start the stream, you uncork it, to stop it you cork it. Personally I think
+it's silly - why would you not just call it "starting" and "stopping" like any other normal audio API? Anyway, the act of corking is, you
+guessed it, asynchronous. This means you'll need our waiting loop as usual. Again, why this asynchronous design is the default is
+absolutely beyond me. Would it really be that hard to just make it run synchronously?
+
+Teardown is pretty simple (what?!). It's just a matter of calling the relevant `_unref()` function on each object in reverse order that
+they were initialized in.
+
+That's about it from the PulseAudio side. A bit ranty, I know, but they really need to fix that main loop and callback system. They're
+embarrassingly unpractical. The main loop thing is an easy fix - have synchronous versions of all APIs. If an application wants these to
+run asynchronously, they can execute them in a separate thread themselves. The desire to run these asynchronously is such a niche
+requirement - it makes no sense to make it the default. The stream write callback needs to be change, or an alternative provided, that is
+constantly fired, regardless of whether or not `pa_stream_write()` has been called, and it needs to take a pointer to a buffer as a
+parameter which the program just writes to directly rather than having to call `pa_stream_writable_size()` and `pa_stream_write()`. These
+changes alone will change PulseAudio from one of the worst audio APIs to one of the best.
+*/
+
+
+/*
+It is assumed pulseaudio.h is available when linking at compile time. When linking at compile time, we use the declarations in the header
+to check for type safety. We cannot do this when linking at run time because the header might not be available.
+*/
+#ifdef MA_NO_RUNTIME_LINKING
+
+/* pulseaudio.h marks some functions with "inline" which isn't always supported. Need to emulate it. */
+#if !defined(__cplusplus)
+    #if defined(__STRICT_ANSI__)
+        #if !defined(inline)
+            #define inline __inline__ __attribute__((always_inline))
+            #define MA_INLINE_DEFINED
+        #endif
+    #endif
+#endif
+#include <pulse/pulseaudio.h>
+#if defined(MA_INLINE_DEFINED)
+    #undef inline
+    #undef MA_INLINE_DEFINED
+#endif
+
+#define MA_PA_OK                                       PA_OK
+#define MA_PA_ERR_ACCESS                               PA_ERR_ACCESS
+#define MA_PA_ERR_INVALID                              PA_ERR_INVALID
+#define MA_PA_ERR_NOENTITY                             PA_ERR_NOENTITY
+#define MA_PA_ERR_NOTSUPPORTED                         PA_ERR_NOTSUPPORTED
+
+#define MA_PA_CHANNELS_MAX                             PA_CHANNELS_MAX
+#define MA_PA_RATE_MAX                                 PA_RATE_MAX
+
+typedef pa_context_flags_t ma_pa_context_flags_t;
+#define MA_PA_CONTEXT_NOFLAGS                          PA_CONTEXT_NOFLAGS
+#define MA_PA_CONTEXT_NOAUTOSPAWN                      PA_CONTEXT_NOAUTOSPAWN
+#define MA_PA_CONTEXT_NOFAIL                           PA_CONTEXT_NOFAIL
+
+typedef pa_stream_flags_t ma_pa_stream_flags_t;
+#define MA_PA_STREAM_NOFLAGS                           PA_STREAM_NOFLAGS
+#define MA_PA_STREAM_START_CORKED                      PA_STREAM_START_CORKED
+#define MA_PA_STREAM_INTERPOLATE_TIMING                PA_STREAM_INTERPOLATE_TIMING
+#define MA_PA_STREAM_NOT_MONOTONIC                     PA_STREAM_NOT_MONOTONIC
+#define MA_PA_STREAM_AUTO_TIMING_UPDATE                PA_STREAM_AUTO_TIMING_UPDATE
+#define MA_PA_STREAM_NO_REMAP_CHANNELS                 PA_STREAM_NO_REMAP_CHANNELS
+#define MA_PA_STREAM_NO_REMIX_CHANNELS                 PA_STREAM_NO_REMIX_CHANNELS
+#define MA_PA_STREAM_FIX_FORMAT                        PA_STREAM_FIX_FORMAT
+#define MA_PA_STREAM_FIX_RATE                          PA_STREAM_FIX_RATE
+#define MA_PA_STREAM_FIX_CHANNELS                      PA_STREAM_FIX_CHANNELS
+#define MA_PA_STREAM_DONT_MOVE                         PA_STREAM_DONT_MOVE
+#define MA_PA_STREAM_VARIABLE_RATE                     PA_STREAM_VARIABLE_RATE
+#define MA_PA_STREAM_PEAK_DETECT                       PA_STREAM_PEAK_DETECT
+#define MA_PA_STREAM_START_MUTED                       PA_STREAM_START_MUTED
+#define MA_PA_STREAM_ADJUST_LATENCY                    PA_STREAM_ADJUST_LATENCY
+#define MA_PA_STREAM_EARLY_REQUESTS                    PA_STREAM_EARLY_REQUESTS
+#define MA_PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND         PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND
+#define MA_PA_STREAM_START_UNMUTED                     PA_STREAM_START_UNMUTED
+#define MA_PA_STREAM_FAIL_ON_SUSPEND                   PA_STREAM_FAIL_ON_SUSPEND
+#define MA_PA_STREAM_RELATIVE_VOLUME                   PA_STREAM_RELATIVE_VOLUME
+#define MA_PA_STREAM_PASSTHROUGH                       PA_STREAM_PASSTHROUGH
+
+typedef pa_sink_flags_t ma_pa_sink_flags_t;
+#define MA_PA_SINK_NOFLAGS                             PA_SINK_NOFLAGS
+#define MA_PA_SINK_HW_VOLUME_CTRL                      PA_SINK_HW_VOLUME_CTRL
+#define MA_PA_SINK_LATENCY                             PA_SINK_LATENCY
+#define MA_PA_SINK_HARDWARE                            PA_SINK_HARDWARE
+#define MA_PA_SINK_NETWORK                             PA_SINK_NETWORK
+#define MA_PA_SINK_HW_MUTE_CTRL                        PA_SINK_HW_MUTE_CTRL
+#define MA_PA_SINK_DECIBEL_VOLUME                      PA_SINK_DECIBEL_VOLUME
+#define MA_PA_SINK_FLAT_VOLUME                         PA_SINK_FLAT_VOLUME
+#define MA_PA_SINK_DYNAMIC_LATENCY                     PA_SINK_DYNAMIC_LATENCY
+#define MA_PA_SINK_SET_FORMATS                         PA_SINK_SET_FORMATS
+
+typedef pa_source_flags_t ma_pa_source_flags_t;
+#define MA_PA_SOURCE_NOFLAGS                           PA_SOURCE_NOFLAGS
+#define MA_PA_SOURCE_HW_VOLUME_CTRL                    PA_SOURCE_HW_VOLUME_CTRL
+#define MA_PA_SOURCE_LATENCY                           PA_SOURCE_LATENCY
+#define MA_PA_SOURCE_HARDWARE                          PA_SOURCE_HARDWARE
+#define MA_PA_SOURCE_NETWORK                           PA_SOURCE_NETWORK
+#define MA_PA_SOURCE_HW_MUTE_CTRL                      PA_SOURCE_HW_MUTE_CTRL
+#define MA_PA_SOURCE_DECIBEL_VOLUME                    PA_SOURCE_DECIBEL_VOLUME
+#define MA_PA_SOURCE_DYNAMIC_LATENCY                   PA_SOURCE_DYNAMIC_LATENCY
+#define MA_PA_SOURCE_FLAT_VOLUME                       PA_SOURCE_FLAT_VOLUME
+
+typedef pa_context_state_t ma_pa_context_state_t;
+#define MA_PA_CONTEXT_UNCONNECTED                      PA_CONTEXT_UNCONNECTED
+#define MA_PA_CONTEXT_CONNECTING                       PA_CONTEXT_CONNECTING
+#define MA_PA_CONTEXT_AUTHORIZING                      PA_CONTEXT_AUTHORIZING
+#define MA_PA_CONTEXT_SETTING_NAME                     PA_CONTEXT_SETTING_NAME
+#define MA_PA_CONTEXT_READY                            PA_CONTEXT_READY
+#define MA_PA_CONTEXT_FAILED                           PA_CONTEXT_FAILED
+#define MA_PA_CONTEXT_TERMINATED                       PA_CONTEXT_TERMINATED
+
+typedef pa_stream_state_t ma_pa_stream_state_t;
+#define MA_PA_STREAM_UNCONNECTED                       PA_STREAM_UNCONNECTED
+#define MA_PA_STREAM_CREATING                          PA_STREAM_CREATING
+#define MA_PA_STREAM_READY                             PA_STREAM_READY
+#define MA_PA_STREAM_FAILED                            PA_STREAM_FAILED
+#define MA_PA_STREAM_TERMINATED                        PA_STREAM_TERMINATED
+
+typedef pa_operation_state_t ma_pa_operation_state_t;
+#define MA_PA_OPERATION_RUNNING                        PA_OPERATION_RUNNING
+#define MA_PA_OPERATION_DONE                           PA_OPERATION_DONE
+#define MA_PA_OPERATION_CANCELLED                      PA_OPERATION_CANCELLED
+
+typedef pa_sink_state_t ma_pa_sink_state_t;
+#define MA_PA_SINK_INVALID_STATE                       PA_SINK_INVALID_STATE
+#define MA_PA_SINK_RUNNING                             PA_SINK_RUNNING
+#define MA_PA_SINK_IDLE                                PA_SINK_IDLE
+#define MA_PA_SINK_SUSPENDED                           PA_SINK_SUSPENDED
+
+typedef pa_source_state_t ma_pa_source_state_t;
+#define MA_PA_SOURCE_INVALID_STATE                     PA_SOURCE_INVALID_STATE
+#define MA_PA_SOURCE_RUNNING                           PA_SOURCE_RUNNING
+#define MA_PA_SOURCE_IDLE                              PA_SOURCE_IDLE
+#define MA_PA_SOURCE_SUSPENDED                         PA_SOURCE_SUSPENDED
+
+typedef pa_seek_mode_t ma_pa_seek_mode_t;
+#define MA_PA_SEEK_RELATIVE                            PA_SEEK_RELATIVE
+#define MA_PA_SEEK_ABSOLUTE                            PA_SEEK_ABSOLUTE
+#define MA_PA_SEEK_RELATIVE_ON_READ                    PA_SEEK_RELATIVE_ON_READ
+#define MA_PA_SEEK_RELATIVE_END                        PA_SEEK_RELATIVE_END
+
+typedef pa_channel_position_t ma_pa_channel_position_t;
+#define MA_PA_CHANNEL_POSITION_INVALID                 PA_CHANNEL_POSITION_INVALID
+#define MA_PA_CHANNEL_POSITION_MONO                    PA_CHANNEL_POSITION_MONO
+#define MA_PA_CHANNEL_POSITION_FRONT_LEFT              PA_CHANNEL_POSITION_FRONT_LEFT
+#define MA_PA_CHANNEL_POSITION_FRONT_RIGHT             PA_CHANNEL_POSITION_FRONT_RIGHT
+#define MA_PA_CHANNEL_POSITION_FRONT_CENTER            PA_CHANNEL_POSITION_FRONT_CENTER
+#define MA_PA_CHANNEL_POSITION_REAR_CENTER             PA_CHANNEL_POSITION_REAR_CENTER
+#define MA_PA_CHANNEL_POSITION_REAR_LEFT               PA_CHANNEL_POSITION_REAR_LEFT
+#define MA_PA_CHANNEL_POSITION_REAR_RIGHT              PA_CHANNEL_POSITION_REAR_RIGHT
+#define MA_PA_CHANNEL_POSITION_LFE                     PA_CHANNEL_POSITION_LFE
+#define MA_PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER    PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
+#define MA_PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER   PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
+#define MA_PA_CHANNEL_POSITION_SIDE_LEFT               PA_CHANNEL_POSITION_SIDE_LEFT
+#define MA_PA_CHANNEL_POSITION_SIDE_RIGHT              PA_CHANNEL_POSITION_SIDE_RIGHT
+#define MA_PA_CHANNEL_POSITION_AUX0                    PA_CHANNEL_POSITION_AUX0
+#define MA_PA_CHANNEL_POSITION_AUX1                    PA_CHANNEL_POSITION_AUX1
+#define MA_PA_CHANNEL_POSITION_AUX2                    PA_CHANNEL_POSITION_AUX2
+#define MA_PA_CHANNEL_POSITION_AUX3                    PA_CHANNEL_POSITION_AUX3
+#define MA_PA_CHANNEL_POSITION_AUX4                    PA_CHANNEL_POSITION_AUX4
+#define MA_PA_CHANNEL_POSITION_AUX5                    PA_CHANNEL_POSITION_AUX5
+#define MA_PA_CHANNEL_POSITION_AUX6                    PA_CHANNEL_POSITION_AUX6
+#define MA_PA_CHANNEL_POSITION_AUX7                    PA_CHANNEL_POSITION_AUX7
+#define MA_PA_CHANNEL_POSITION_AUX8                    PA_CHANNEL_POSITION_AUX8
+#define MA_PA_CHANNEL_POSITION_AUX9                    PA_CHANNEL_POSITION_AUX9
+#define MA_PA_CHANNEL_POSITION_AUX10                   PA_CHANNEL_POSITION_AUX10
+#define MA_PA_CHANNEL_POSITION_AUX11                   PA_CHANNEL_POSITION_AUX11
+#define MA_PA_CHANNEL_POSITION_AUX12                   PA_CHANNEL_POSITION_AUX12
+#define MA_PA_CHANNEL_POSITION_AUX13                   PA_CHANNEL_POSITION_AUX13
+#define MA_PA_CHANNEL_POSITION_AUX14                   PA_CHANNEL_POSITION_AUX14
+#define MA_PA_CHANNEL_POSITION_AUX15                   PA_CHANNEL_POSITION_AUX15
+#define MA_PA_CHANNEL_POSITION_AUX16                   PA_CHANNEL_POSITION_AUX16
+#define MA_PA_CHANNEL_POSITION_AUX17                   PA_CHANNEL_POSITION_AUX17
+#define MA_PA_CHANNEL_POSITION_AUX18                   PA_CHANNEL_POSITION_AUX18
+#define MA_PA_CHANNEL_POSITION_AUX19                   PA_CHANNEL_POSITION_AUX19
+#define MA_PA_CHANNEL_POSITION_AUX20                   PA_CHANNEL_POSITION_AUX20
+#define MA_PA_CHANNEL_POSITION_AUX21                   PA_CHANNEL_POSITION_AUX21
+#define MA_PA_CHANNEL_POSITION_AUX22                   PA_CHANNEL_POSITION_AUX22
+#define MA_PA_CHANNEL_POSITION_AUX23                   PA_CHANNEL_POSITION_AUX23
+#define MA_PA_CHANNEL_POSITION_AUX24                   PA_CHANNEL_POSITION_AUX24
+#define MA_PA_CHANNEL_POSITION_AUX25                   PA_CHANNEL_POSITION_AUX25
+#define MA_PA_CHANNEL_POSITION_AUX26                   PA_CHANNEL_POSITION_AUX26
+#define MA_PA_CHANNEL_POSITION_AUX27                   PA_CHANNEL_POSITION_AUX27
+#define MA_PA_CHANNEL_POSITION_AUX28                   PA_CHANNEL_POSITION_AUX28
+#define MA_PA_CHANNEL_POSITION_AUX29                   PA_CHANNEL_POSITION_AUX29
+#define MA_PA_CHANNEL_POSITION_AUX30                   PA_CHANNEL_POSITION_AUX30
+#define MA_PA_CHANNEL_POSITION_AUX31                   PA_CHANNEL_POSITION_AUX31
+#define MA_PA_CHANNEL_POSITION_TOP_CENTER              PA_CHANNEL_POSITION_TOP_CENTER
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_LEFT          PA_CHANNEL_POSITION_TOP_FRONT_LEFT
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_RIGHT         PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_CENTER        PA_CHANNEL_POSITION_TOP_FRONT_CENTER
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_LEFT           PA_CHANNEL_POSITION_TOP_REAR_LEFT
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_RIGHT          PA_CHANNEL_POSITION_TOP_REAR_RIGHT
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_CENTER         PA_CHANNEL_POSITION_TOP_REAR_CENTER
+#define MA_PA_CHANNEL_POSITION_LEFT                    PA_CHANNEL_POSITION_LEFT
+#define MA_PA_CHANNEL_POSITION_RIGHT                   PA_CHANNEL_POSITION_RIGHT
+#define MA_PA_CHANNEL_POSITION_CENTER                  PA_CHANNEL_POSITION_CENTER
+#define MA_PA_CHANNEL_POSITION_SUBWOOFER               PA_CHANNEL_POSITION_SUBWOOFER
+
+typedef pa_channel_map_def_t ma_pa_channel_map_def_t;
+#define MA_PA_CHANNEL_MAP_AIFF                         PA_CHANNEL_MAP_AIFF
+#define MA_PA_CHANNEL_MAP_ALSA                         PA_CHANNEL_MAP_ALSA
+#define MA_PA_CHANNEL_MAP_AUX                          PA_CHANNEL_MAP_AUX
+#define MA_PA_CHANNEL_MAP_WAVEEX                       PA_CHANNEL_MAP_WAVEEX
+#define MA_PA_CHANNEL_MAP_OSS                          PA_CHANNEL_MAP_OSS
+#define MA_PA_CHANNEL_MAP_DEFAULT                      PA_CHANNEL_MAP_DEFAULT
+
+typedef pa_sample_format_t ma_pa_sample_format_t;
+#define MA_PA_SAMPLE_INVALID                           PA_SAMPLE_INVALID
+#define MA_PA_SAMPLE_U8                                PA_SAMPLE_U8
+#define MA_PA_SAMPLE_ALAW                              PA_SAMPLE_ALAW
+#define MA_PA_SAMPLE_ULAW                              PA_SAMPLE_ULAW
+#define MA_PA_SAMPLE_S16LE                             PA_SAMPLE_S16LE
+#define MA_PA_SAMPLE_S16BE                             PA_SAMPLE_S16BE
+#define MA_PA_SAMPLE_FLOAT32LE                         PA_SAMPLE_FLOAT32LE
+#define MA_PA_SAMPLE_FLOAT32BE                         PA_SAMPLE_FLOAT32BE
+#define MA_PA_SAMPLE_S32LE                             PA_SAMPLE_S32LE
+#define MA_PA_SAMPLE_S32BE                             PA_SAMPLE_S32BE
+#define MA_PA_SAMPLE_S24LE                             PA_SAMPLE_S24LE
+#define MA_PA_SAMPLE_S24BE                             PA_SAMPLE_S24BE
+#define MA_PA_SAMPLE_S24_32LE                          PA_SAMPLE_S24_32LE
+#define MA_PA_SAMPLE_S24_32BE                          PA_SAMPLE_S24_32BE
+
+typedef pa_mainloop             ma_pa_mainloop;
+typedef pa_threaded_mainloop    ma_pa_threaded_mainloop;
+typedef pa_mainloop_api         ma_pa_mainloop_api;
+typedef pa_context              ma_pa_context;
+typedef pa_operation            ma_pa_operation;
+typedef pa_stream               ma_pa_stream;
+typedef pa_spawn_api            ma_pa_spawn_api;
+typedef pa_buffer_attr          ma_pa_buffer_attr;
+typedef pa_channel_map          ma_pa_channel_map;
+typedef pa_cvolume              ma_pa_cvolume;
+typedef pa_sample_spec          ma_pa_sample_spec;
+typedef pa_sink_info            ma_pa_sink_info;
+typedef pa_source_info          ma_pa_source_info;
+
+typedef pa_context_notify_cb_t  ma_pa_context_notify_cb_t;
+typedef pa_sink_info_cb_t       ma_pa_sink_info_cb_t;
+typedef pa_source_info_cb_t     ma_pa_source_info_cb_t;
+typedef pa_stream_success_cb_t  ma_pa_stream_success_cb_t;
+typedef pa_stream_request_cb_t  ma_pa_stream_request_cb_t;
+typedef pa_stream_notify_cb_t   ma_pa_stream_notify_cb_t;
+typedef pa_free_cb_t            ma_pa_free_cb_t;
+#else
+#define MA_PA_OK                                       0
+#define MA_PA_ERR_ACCESS                               1
+#define MA_PA_ERR_INVALID                              2
+#define MA_PA_ERR_NOENTITY                             5
+#define MA_PA_ERR_NOTSUPPORTED                         19
+
+#define MA_PA_CHANNELS_MAX                             32
+#define MA_PA_RATE_MAX                                 384000
+
+typedef int ma_pa_context_flags_t;
+#define MA_PA_CONTEXT_NOFLAGS                          0x00000000
+#define MA_PA_CONTEXT_NOAUTOSPAWN                      0x00000001
+#define MA_PA_CONTEXT_NOFAIL                           0x00000002
+
+typedef int ma_pa_stream_flags_t;
+#define MA_PA_STREAM_NOFLAGS                           0x00000000
+#define MA_PA_STREAM_START_CORKED                      0x00000001
+#define MA_PA_STREAM_INTERPOLATE_TIMING                0x00000002
+#define MA_PA_STREAM_NOT_MONOTONIC                     0x00000004
+#define MA_PA_STREAM_AUTO_TIMING_UPDATE                0x00000008
+#define MA_PA_STREAM_NO_REMAP_CHANNELS                 0x00000010
+#define MA_PA_STREAM_NO_REMIX_CHANNELS                 0x00000020
+#define MA_PA_STREAM_FIX_FORMAT                        0x00000040
+#define MA_PA_STREAM_FIX_RATE                          0x00000080
+#define MA_PA_STREAM_FIX_CHANNELS                      0x00000100
+#define MA_PA_STREAM_DONT_MOVE                         0x00000200
+#define MA_PA_STREAM_VARIABLE_RATE                     0x00000400
+#define MA_PA_STREAM_PEAK_DETECT                       0x00000800
+#define MA_PA_STREAM_START_MUTED                       0x00001000
+#define MA_PA_STREAM_ADJUST_LATENCY                    0x00002000
+#define MA_PA_STREAM_EARLY_REQUESTS                    0x00004000
+#define MA_PA_STREAM_DONT_INHIBIT_AUTO_SUSPEND         0x00008000
+#define MA_PA_STREAM_START_UNMUTED                     0x00010000
+#define MA_PA_STREAM_FAIL_ON_SUSPEND                   0x00020000
+#define MA_PA_STREAM_RELATIVE_VOLUME                   0x00040000
+#define MA_PA_STREAM_PASSTHROUGH                       0x00080000
+
+typedef int ma_pa_sink_flags_t;
+#define MA_PA_SINK_NOFLAGS                             0x00000000
+#define MA_PA_SINK_HW_VOLUME_CTRL                      0x00000001
+#define MA_PA_SINK_LATENCY                             0x00000002
+#define MA_PA_SINK_HARDWARE                            0x00000004
+#define MA_PA_SINK_NETWORK                             0x00000008
+#define MA_PA_SINK_HW_MUTE_CTRL                        0x00000010
+#define MA_PA_SINK_DECIBEL_VOLUME                      0x00000020
+#define MA_PA_SINK_FLAT_VOLUME                         0x00000040
+#define MA_PA_SINK_DYNAMIC_LATENCY                     0x00000080
+#define MA_PA_SINK_SET_FORMATS                         0x00000100
+
+typedef int ma_pa_source_flags_t;
+#define MA_PA_SOURCE_NOFLAGS                           0x00000000
+#define MA_PA_SOURCE_HW_VOLUME_CTRL                    0x00000001
+#define MA_PA_SOURCE_LATENCY                           0x00000002
+#define MA_PA_SOURCE_HARDWARE                          0x00000004
+#define MA_PA_SOURCE_NETWORK                           0x00000008
+#define MA_PA_SOURCE_HW_MUTE_CTRL                      0x00000010
+#define MA_PA_SOURCE_DECIBEL_VOLUME                    0x00000020
+#define MA_PA_SOURCE_DYNAMIC_LATENCY                   0x00000040
+#define MA_PA_SOURCE_FLAT_VOLUME                       0x00000080
+
+typedef int ma_pa_context_state_t;
+#define MA_PA_CONTEXT_UNCONNECTED                      0
+#define MA_PA_CONTEXT_CONNECTING                       1
+#define MA_PA_CONTEXT_AUTHORIZING                      2
+#define MA_PA_CONTEXT_SETTING_NAME                     3
+#define MA_PA_CONTEXT_READY                            4
+#define MA_PA_CONTEXT_FAILED                           5
+#define MA_PA_CONTEXT_TERMINATED                       6
+
+typedef int ma_pa_stream_state_t;
+#define MA_PA_STREAM_UNCONNECTED                       0
+#define MA_PA_STREAM_CREATING                          1
+#define MA_PA_STREAM_READY                             2
+#define MA_PA_STREAM_FAILED                            3
+#define MA_PA_STREAM_TERMINATED                        4
+
+typedef int ma_pa_operation_state_t;
+#define MA_PA_OPERATION_RUNNING                        0
+#define MA_PA_OPERATION_DONE                           1
+#define MA_PA_OPERATION_CANCELLED                      2
+
+typedef int ma_pa_sink_state_t;
+#define MA_PA_SINK_INVALID_STATE                       -1
+#define MA_PA_SINK_RUNNING                             0
+#define MA_PA_SINK_IDLE                                1
+#define MA_PA_SINK_SUSPENDED                           2
+
+typedef int ma_pa_source_state_t;
+#define MA_PA_SOURCE_INVALID_STATE                     -1
+#define MA_PA_SOURCE_RUNNING                           0
+#define MA_PA_SOURCE_IDLE                              1
+#define MA_PA_SOURCE_SUSPENDED                         2
+
+typedef int ma_pa_seek_mode_t;
+#define MA_PA_SEEK_RELATIVE                            0
+#define MA_PA_SEEK_ABSOLUTE                            1
+#define MA_PA_SEEK_RELATIVE_ON_READ                    2
+#define MA_PA_SEEK_RELATIVE_END                        3
+
+typedef int ma_pa_channel_position_t;
+#define MA_PA_CHANNEL_POSITION_INVALID                 -1
+#define MA_PA_CHANNEL_POSITION_MONO                    0
+#define MA_PA_CHANNEL_POSITION_FRONT_LEFT              1
+#define MA_PA_CHANNEL_POSITION_FRONT_RIGHT             2
+#define MA_PA_CHANNEL_POSITION_FRONT_CENTER            3
+#define MA_PA_CHANNEL_POSITION_REAR_CENTER             4
+#define MA_PA_CHANNEL_POSITION_REAR_LEFT               5
+#define MA_PA_CHANNEL_POSITION_REAR_RIGHT              6
+#define MA_PA_CHANNEL_POSITION_LFE                     7
+#define MA_PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER    8
+#define MA_PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER   9
+#define MA_PA_CHANNEL_POSITION_SIDE_LEFT               10
+#define MA_PA_CHANNEL_POSITION_SIDE_RIGHT              11
+#define MA_PA_CHANNEL_POSITION_AUX0                    12
+#define MA_PA_CHANNEL_POSITION_AUX1                    13
+#define MA_PA_CHANNEL_POSITION_AUX2                    14
+#define MA_PA_CHANNEL_POSITION_AUX3                    15
+#define MA_PA_CHANNEL_POSITION_AUX4                    16
+#define MA_PA_CHANNEL_POSITION_AUX5                    17
+#define MA_PA_CHANNEL_POSITION_AUX6                    18
+#define MA_PA_CHANNEL_POSITION_AUX7                    19
+#define MA_PA_CHANNEL_POSITION_AUX8                    20
+#define MA_PA_CHANNEL_POSITION_AUX9                    21
+#define MA_PA_CHANNEL_POSITION_AUX10                   22
+#define MA_PA_CHANNEL_POSITION_AUX11                   23
+#define MA_PA_CHANNEL_POSITION_AUX12                   24
+#define MA_PA_CHANNEL_POSITION_AUX13                   25
+#define MA_PA_CHANNEL_POSITION_AUX14                   26
+#define MA_PA_CHANNEL_POSITION_AUX15                   27
+#define MA_PA_CHANNEL_POSITION_AUX16                   28
+#define MA_PA_CHANNEL_POSITION_AUX17                   29
+#define MA_PA_CHANNEL_POSITION_AUX18                   30
+#define MA_PA_CHANNEL_POSITION_AUX19                   31
+#define MA_PA_CHANNEL_POSITION_AUX20                   32
+#define MA_PA_CHANNEL_POSITION_AUX21                   33
+#define MA_PA_CHANNEL_POSITION_AUX22                   34
+#define MA_PA_CHANNEL_POSITION_AUX23                   35
+#define MA_PA_CHANNEL_POSITION_AUX24                   36
+#define MA_PA_CHANNEL_POSITION_AUX25                   37
+#define MA_PA_CHANNEL_POSITION_AUX26                   38
+#define MA_PA_CHANNEL_POSITION_AUX27                   39
+#define MA_PA_CHANNEL_POSITION_AUX28                   40
+#define MA_PA_CHANNEL_POSITION_AUX29                   41
+#define MA_PA_CHANNEL_POSITION_AUX30                   42
+#define MA_PA_CHANNEL_POSITION_AUX31                   43
+#define MA_PA_CHANNEL_POSITION_TOP_CENTER              44
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_LEFT          45
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_RIGHT         46
+#define MA_PA_CHANNEL_POSITION_TOP_FRONT_CENTER        47
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_LEFT           48
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_RIGHT          49
+#define MA_PA_CHANNEL_POSITION_TOP_REAR_CENTER         50
+#define MA_PA_CHANNEL_POSITION_LEFT                    MA_PA_CHANNEL_POSITION_FRONT_LEFT
+#define MA_PA_CHANNEL_POSITION_RIGHT                   MA_PA_CHANNEL_POSITION_FRONT_RIGHT
+#define MA_PA_CHANNEL_POSITION_CENTER                  MA_PA_CHANNEL_POSITION_FRONT_CENTER
+#define MA_PA_CHANNEL_POSITION_SUBWOOFER               MA_PA_CHANNEL_POSITION_LFE
+
+typedef int ma_pa_channel_map_def_t;
+#define MA_PA_CHANNEL_MAP_AIFF                         0
+#define MA_PA_CHANNEL_MAP_ALSA                         1
+#define MA_PA_CHANNEL_MAP_AUX                          2
+#define MA_PA_CHANNEL_MAP_WAVEEX                       3
+#define MA_PA_CHANNEL_MAP_OSS                          4
+#define MA_PA_CHANNEL_MAP_DEFAULT                      MA_PA_CHANNEL_MAP_AIFF
+
+typedef int ma_pa_sample_format_t;
+#define MA_PA_SAMPLE_INVALID                           -1
+#define MA_PA_SAMPLE_U8                                0
+#define MA_PA_SAMPLE_ALAW                              1
+#define MA_PA_SAMPLE_ULAW                              2
+#define MA_PA_SAMPLE_S16LE                             3
+#define MA_PA_SAMPLE_S16BE                             4
+#define MA_PA_SAMPLE_FLOAT32LE                         5
+#define MA_PA_SAMPLE_FLOAT32BE                         6
+#define MA_PA_SAMPLE_S32LE                             7
+#define MA_PA_SAMPLE_S32BE                             8
+#define MA_PA_SAMPLE_S24LE                             9
+#define MA_PA_SAMPLE_S24BE                             10
+#define MA_PA_SAMPLE_S24_32LE                          11
+#define MA_PA_SAMPLE_S24_32BE                          12
+
+typedef struct ma_pa_mainloop           ma_pa_mainloop;
+typedef struct ma_pa_threaded_mainloop  ma_pa_threaded_mainloop;
+typedef struct ma_pa_mainloop_api       ma_pa_mainloop_api;
+typedef struct ma_pa_context            ma_pa_context;
+typedef struct ma_pa_operation          ma_pa_operation;
+typedef struct ma_pa_stream             ma_pa_stream;
+typedef struct ma_pa_spawn_api          ma_pa_spawn_api;
+
+typedef struct
+{
+    ma_uint32 maxlength;
+    ma_uint32 tlength;
+    ma_uint32 prebuf;
+    ma_uint32 minreq;
+    ma_uint32 fragsize;
+} ma_pa_buffer_attr;
+
+typedef struct
+{
+    ma_uint8 channels;
+    ma_pa_channel_position_t map[MA_PA_CHANNELS_MAX];
+} ma_pa_channel_map;
+
+typedef struct
+{
+    ma_uint8 channels;
+    ma_uint32 values[MA_PA_CHANNELS_MAX];
+} ma_pa_cvolume;
+
+typedef struct
+{
+    ma_pa_sample_format_t format;
+    ma_uint32 rate;
+    ma_uint8 channels;
+} ma_pa_sample_spec;
+
+typedef struct
+{
+    const char* name;
+    ma_uint32 index;
+    const char* description;
+    ma_pa_sample_spec sample_spec;
+    ma_pa_channel_map channel_map;
+    ma_uint32 owner_module;
+    ma_pa_cvolume volume;
+    int mute;
+    ma_uint32 monitor_source;
+    const char* monitor_source_name;
+    ma_uint64 latency;
+    const char* driver;
+    ma_pa_sink_flags_t flags;
+    void* proplist;
+    ma_uint64 configured_latency;
+    ma_uint32 base_volume;
+    ma_pa_sink_state_t state;
+    ma_uint32 n_volume_steps;
+    ma_uint32 card;
+    ma_uint32 n_ports;
+    void** ports;
+    void* active_port;
+    ma_uint8 n_formats;
+    void** formats;
+} ma_pa_sink_info;
+
+typedef struct
+{
+    const char *name;
+    ma_uint32 index;
+    const char *description;
+    ma_pa_sample_spec sample_spec;
+    ma_pa_channel_map channel_map;
+    ma_uint32 owner_module;
+    ma_pa_cvolume volume;
+    int mute;
+    ma_uint32 monitor_of_sink;
+    const char *monitor_of_sink_name;
+    ma_uint64 latency;
+    const char *driver;
+    ma_pa_source_flags_t flags;
+    void* proplist;
+    ma_uint64 configured_latency;
+    ma_uint32 base_volume;
+    ma_pa_source_state_t state;
+    ma_uint32 n_volume_steps;
+    ma_uint32 card;
+    ma_uint32 n_ports;
+    void** ports;
+    void* active_port;
+    ma_uint8 n_formats;
+    void** formats;
+} ma_pa_source_info;
+
+typedef void (* ma_pa_context_notify_cb_t)(ma_pa_context* c, void* userdata);
+typedef void (* ma_pa_sink_info_cb_t)     (ma_pa_context* c, const ma_pa_sink_info* i, int eol, void* userdata);
+typedef void (* ma_pa_source_info_cb_t)   (ma_pa_context* c, const ma_pa_source_info* i, int eol, void* userdata);
+typedef void (* ma_pa_stream_success_cb_t)(ma_pa_stream* s, int success, void* userdata);
+typedef void (* ma_pa_stream_request_cb_t)(ma_pa_stream* s, size_t nbytes, void* userdata);
+typedef void (* ma_pa_stream_notify_cb_t) (ma_pa_stream* s, void* userdata);
+typedef void (* ma_pa_free_cb_t)          (void* p);
+#endif
+
+
+typedef ma_pa_mainloop*          (* ma_pa_mainloop_new_proc)                   (void);
+typedef void                     (* ma_pa_mainloop_free_proc)                  (ma_pa_mainloop* m);
+typedef void                     (* ma_pa_mainloop_quit_proc)                  (ma_pa_mainloop* m, int retval);
+typedef ma_pa_mainloop_api*      (* ma_pa_mainloop_get_api_proc)               (ma_pa_mainloop* m);
+typedef int                      (* ma_pa_mainloop_iterate_proc)               (ma_pa_mainloop* m, int block, int* retval);
+typedef void                     (* ma_pa_mainloop_wakeup_proc)                (ma_pa_mainloop* m);
+typedef ma_pa_threaded_mainloop* (* ma_pa_threaded_mainloop_new_proc)          (void);
+typedef void                     (* ma_pa_threaded_mainloop_free_proc)         (ma_pa_threaded_mainloop* m);
+typedef int                      (* ma_pa_threaded_mainloop_start_proc)        (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_stop_proc)         (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_lock_proc)         (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_unlock_proc)       (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_wait_proc)         (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_signal_proc)       (ma_pa_threaded_mainloop* m, int wait_for_accept);
+typedef void                     (* ma_pa_threaded_mainloop_accept_proc)       (ma_pa_threaded_mainloop* m);
+typedef int                      (* ma_pa_threaded_mainloop_get_retval_proc)   (ma_pa_threaded_mainloop* m);
+typedef ma_pa_mainloop_api*      (* ma_pa_threaded_mainloop_get_api_proc)      (ma_pa_threaded_mainloop* m);
+typedef int                      (* ma_pa_threaded_mainloop_in_thread_proc)    (ma_pa_threaded_mainloop* m);
+typedef void                     (* ma_pa_threaded_mainloop_set_name_proc)     (ma_pa_threaded_mainloop* m, const char* name);
+typedef ma_pa_context*           (* ma_pa_context_new_proc)                    (ma_pa_mainloop_api* mainloop, const char* name);
+typedef void                     (* ma_pa_context_unref_proc)                  (ma_pa_context* c);
+typedef int                      (* ma_pa_context_connect_proc)                (ma_pa_context* c, const char* server, ma_pa_context_flags_t flags, const ma_pa_spawn_api* api);
+typedef void                     (* ma_pa_context_disconnect_proc)             (ma_pa_context* c);
+typedef void                     (* ma_pa_context_set_state_callback_proc)     (ma_pa_context* c, ma_pa_context_notify_cb_t cb, void* userdata);
+typedef ma_pa_context_state_t    (* ma_pa_context_get_state_proc)              (ma_pa_context* c);
+typedef ma_pa_operation*         (* ma_pa_context_get_sink_info_list_proc)     (ma_pa_context* c, ma_pa_sink_info_cb_t cb, void* userdata);
+typedef ma_pa_operation*         (* ma_pa_context_get_source_info_list_proc)   (ma_pa_context* c, ma_pa_source_info_cb_t cb, void* userdata);
+typedef ma_pa_operation*         (* ma_pa_context_get_sink_info_by_name_proc)  (ma_pa_context* c, const char* name, ma_pa_sink_info_cb_t cb, void* userdata);
+typedef ma_pa_operation*         (* ma_pa_context_get_source_info_by_name_proc)(ma_pa_context* c, const char* name, ma_pa_source_info_cb_t cb, void* userdata);
+typedef void                     (* ma_pa_operation_unref_proc)                (ma_pa_operation* o);
+typedef ma_pa_operation_state_t  (* ma_pa_operation_get_state_proc)            (ma_pa_operation* o);
+typedef ma_pa_channel_map*       (* ma_pa_channel_map_init_extend_proc)        (ma_pa_channel_map* m, unsigned channels, ma_pa_channel_map_def_t def);
+typedef int                      (* ma_pa_channel_map_valid_proc)              (const ma_pa_channel_map* m);
+typedef int                      (* ma_pa_channel_map_compatible_proc)         (const ma_pa_channel_map* m, const ma_pa_sample_spec* ss);
+typedef ma_pa_stream*            (* ma_pa_stream_new_proc)                     (ma_pa_context* c, const char* name, const ma_pa_sample_spec* ss, const ma_pa_channel_map* map);
+typedef void                     (* ma_pa_stream_unref_proc)                   (ma_pa_stream* s);
+typedef int                      (* ma_pa_stream_connect_playback_proc)        (ma_pa_stream* s, const char* dev, const ma_pa_buffer_attr* attr, ma_pa_stream_flags_t flags, const ma_pa_cvolume* volume, ma_pa_stream* sync_stream);
+typedef int                      (* ma_pa_stream_connect_record_proc)          (ma_pa_stream* s, const char* dev, const ma_pa_buffer_attr* attr, ma_pa_stream_flags_t flags);
+typedef int                      (* ma_pa_stream_disconnect_proc)              (ma_pa_stream* s);
+typedef ma_pa_stream_state_t     (* ma_pa_stream_get_state_proc)               (ma_pa_stream* s);
+typedef const ma_pa_sample_spec* (* ma_pa_stream_get_sample_spec_proc)         (ma_pa_stream* s);
+typedef const ma_pa_channel_map* (* ma_pa_stream_get_channel_map_proc)         (ma_pa_stream* s);
+typedef const ma_pa_buffer_attr* (* ma_pa_stream_get_buffer_attr_proc)         (ma_pa_stream* s);
+typedef ma_pa_operation*         (* ma_pa_stream_set_buffer_attr_proc)         (ma_pa_stream* s, const ma_pa_buffer_attr* attr, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef const char*              (* ma_pa_stream_get_device_name_proc)         (ma_pa_stream* s);
+typedef void                     (* ma_pa_stream_set_write_callback_proc)      (ma_pa_stream* s, ma_pa_stream_request_cb_t cb, void* userdata);
+typedef void                     (* ma_pa_stream_set_read_callback_proc)       (ma_pa_stream* s, ma_pa_stream_request_cb_t cb, void* userdata);
+typedef void                     (* ma_pa_stream_set_suspended_callback_proc)  (ma_pa_stream* s, ma_pa_stream_notify_cb_t cb, void* userdata);
+typedef void                     (* ma_pa_stream_set_moved_callback_proc)      (ma_pa_stream* s, ma_pa_stream_notify_cb_t cb, void* userdata);
+typedef int                      (* ma_pa_stream_is_suspended_proc)            (const ma_pa_stream* s);
+typedef ma_pa_operation*         (* ma_pa_stream_flush_proc)                   (ma_pa_stream* s, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef ma_pa_operation*         (* ma_pa_stream_drain_proc)                   (ma_pa_stream* s, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef int                      (* ma_pa_stream_is_corked_proc)               (ma_pa_stream* s);
+typedef ma_pa_operation*         (* ma_pa_stream_cork_proc)                    (ma_pa_stream* s, int b, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef ma_pa_operation*         (* ma_pa_stream_trigger_proc)                 (ma_pa_stream* s, ma_pa_stream_success_cb_t cb, void* userdata);
+typedef int                      (* ma_pa_stream_begin_write_proc)             (ma_pa_stream* s, void** data, size_t* nbytes);
+typedef int                      (* ma_pa_stream_write_proc)                   (ma_pa_stream* s, const void* data, size_t nbytes, ma_pa_free_cb_t free_cb, int64_t offset, ma_pa_seek_mode_t seek);
+typedef int                      (* ma_pa_stream_peek_proc)                    (ma_pa_stream* s, const void** data, size_t* nbytes);
+typedef int                      (* ma_pa_stream_drop_proc)                    (ma_pa_stream* s);
+typedef size_t                   (* ma_pa_stream_writable_size_proc)           (ma_pa_stream* s);
+typedef size_t                   (* ma_pa_stream_readable_size_proc)           (ma_pa_stream* s);
+
+typedef struct
+{
+    ma_uint32 count;
+    ma_uint32 capacity;
+    ma_device_info* pInfo;
+} ma_pulse_device_enum_data;
+
+static ma_result ma_result_from_pulse(int result)
+{
+    if (result < 0) {
+        return MA_ERROR;
+    }
+
+    switch (result) {
+        case MA_PA_OK:           return MA_SUCCESS;
+        case MA_PA_ERR_ACCESS:   return MA_ACCESS_DENIED;
+        case MA_PA_ERR_INVALID:  return MA_INVALID_ARGS;
+        case MA_PA_ERR_NOENTITY: return MA_NO_DEVICE;
+        default:                 return MA_ERROR;
+    }
+}
+
+#if 0
+static ma_pa_sample_format_t ma_format_to_pulse(ma_format format)
+{
+    if (ma_is_little_endian()) {
+        switch (format) {
+            case ma_format_s16: return MA_PA_SAMPLE_S16LE;
+            case ma_format_s24: return MA_PA_SAMPLE_S24LE;
+            case ma_format_s32: return MA_PA_SAMPLE_S32LE;
+            case ma_format_f32: return MA_PA_SAMPLE_FLOAT32LE;
+            default: break;
+        }
+    } else {
+        switch (format) {
+            case ma_format_s16: return MA_PA_SAMPLE_S16BE;
+            case ma_format_s24: return MA_PA_SAMPLE_S24BE;
+            case ma_format_s32: return MA_PA_SAMPLE_S32BE;
+            case ma_format_f32: return MA_PA_SAMPLE_FLOAT32BE;
+            default: break;
+        }
+    }
+
+    /* Endian agnostic. */
+    switch (format) {
+        case ma_format_u8: return MA_PA_SAMPLE_U8;
+        default: return MA_PA_SAMPLE_INVALID;
+    }
+}
+#endif
+
+static ma_format ma_format_from_pulse(ma_pa_sample_format_t format)
+{
+    if (ma_is_little_endian()) {
+        switch (format) {
+            case MA_PA_SAMPLE_S16LE:     return ma_format_s16;
+            case MA_PA_SAMPLE_S24LE:     return ma_format_s24;
+            case MA_PA_SAMPLE_S32LE:     return ma_format_s32;
+            case MA_PA_SAMPLE_FLOAT32LE: return ma_format_f32;
+            default: break;
+        }
+    } else {
+        switch (format) {
+            case MA_PA_SAMPLE_S16BE:     return ma_format_s16;
+            case MA_PA_SAMPLE_S24BE:     return ma_format_s24;
+            case MA_PA_SAMPLE_S32BE:     return ma_format_s32;
+            case MA_PA_SAMPLE_FLOAT32BE: return ma_format_f32;
+            default: break;
+        }
+    }
+
+    /* Endian agnostic. */
+    switch (format) {
+        case MA_PA_SAMPLE_U8: return ma_format_u8;
+        default: return ma_format_unknown;
+    }
+}
+
+static ma_channel ma_channel_position_from_pulse(ma_pa_channel_position_t position)
+{
+    switch (position)
+    {
+        case MA_PA_CHANNEL_POSITION_INVALID:               return MA_CHANNEL_NONE;
+        case MA_PA_CHANNEL_POSITION_MONO:                  return MA_CHANNEL_MONO;
+        case MA_PA_CHANNEL_POSITION_FRONT_LEFT:            return MA_CHANNEL_FRONT_LEFT;
+        case MA_PA_CHANNEL_POSITION_FRONT_RIGHT:           return MA_CHANNEL_FRONT_RIGHT;
+        case MA_PA_CHANNEL_POSITION_FRONT_CENTER:          return MA_CHANNEL_FRONT_CENTER;
+        case MA_PA_CHANNEL_POSITION_REAR_CENTER:           return MA_CHANNEL_BACK_CENTER;
+        case MA_PA_CHANNEL_POSITION_REAR_LEFT:             return MA_CHANNEL_BACK_LEFT;
+        case MA_PA_CHANNEL_POSITION_REAR_RIGHT:            return MA_CHANNEL_BACK_RIGHT;
+        case MA_PA_CHANNEL_POSITION_LFE:                   return MA_CHANNEL_LFE;
+        case MA_PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER:  return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case MA_PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER: return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case MA_PA_CHANNEL_POSITION_SIDE_LEFT:             return MA_CHANNEL_SIDE_LEFT;
+        case MA_PA_CHANNEL_POSITION_SIDE_RIGHT:            return MA_CHANNEL_SIDE_RIGHT;
+        case MA_PA_CHANNEL_POSITION_AUX0:                  return MA_CHANNEL_AUX_0;
+        case MA_PA_CHANNEL_POSITION_AUX1:                  return MA_CHANNEL_AUX_1;
+        case MA_PA_CHANNEL_POSITION_AUX2:                  return MA_CHANNEL_AUX_2;
+        case MA_PA_CHANNEL_POSITION_AUX3:                  return MA_CHANNEL_AUX_3;
+        case MA_PA_CHANNEL_POSITION_AUX4:                  return MA_CHANNEL_AUX_4;
+        case MA_PA_CHANNEL_POSITION_AUX5:                  return MA_CHANNEL_AUX_5;
+        case MA_PA_CHANNEL_POSITION_AUX6:                  return MA_CHANNEL_AUX_6;
+        case MA_PA_CHANNEL_POSITION_AUX7:                  return MA_CHANNEL_AUX_7;
+        case MA_PA_CHANNEL_POSITION_AUX8:                  return MA_CHANNEL_AUX_8;
+        case MA_PA_CHANNEL_POSITION_AUX9:                  return MA_CHANNEL_AUX_9;
+        case MA_PA_CHANNEL_POSITION_AUX10:                 return MA_CHANNEL_AUX_10;
+        case MA_PA_CHANNEL_POSITION_AUX11:                 return MA_CHANNEL_AUX_11;
+        case MA_PA_CHANNEL_POSITION_AUX12:                 return MA_CHANNEL_AUX_12;
+        case MA_PA_CHANNEL_POSITION_AUX13:                 return MA_CHANNEL_AUX_13;
+        case MA_PA_CHANNEL_POSITION_AUX14:                 return MA_CHANNEL_AUX_14;
+        case MA_PA_CHANNEL_POSITION_AUX15:                 return MA_CHANNEL_AUX_15;
+        case MA_PA_CHANNEL_POSITION_AUX16:                 return MA_CHANNEL_AUX_16;
+        case MA_PA_CHANNEL_POSITION_AUX17:                 return MA_CHANNEL_AUX_17;
+        case MA_PA_CHANNEL_POSITION_AUX18:                 return MA_CHANNEL_AUX_18;
+        case MA_PA_CHANNEL_POSITION_AUX19:                 return MA_CHANNEL_AUX_19;
+        case MA_PA_CHANNEL_POSITION_AUX20:                 return MA_CHANNEL_AUX_20;
+        case MA_PA_CHANNEL_POSITION_AUX21:                 return MA_CHANNEL_AUX_21;
+        case MA_PA_CHANNEL_POSITION_AUX22:                 return MA_CHANNEL_AUX_22;
+        case MA_PA_CHANNEL_POSITION_AUX23:                 return MA_CHANNEL_AUX_23;
+        case MA_PA_CHANNEL_POSITION_AUX24:                 return MA_CHANNEL_AUX_24;
+        case MA_PA_CHANNEL_POSITION_AUX25:                 return MA_CHANNEL_AUX_25;
+        case MA_PA_CHANNEL_POSITION_AUX26:                 return MA_CHANNEL_AUX_26;
+        case MA_PA_CHANNEL_POSITION_AUX27:                 return MA_CHANNEL_AUX_27;
+        case MA_PA_CHANNEL_POSITION_AUX28:                 return MA_CHANNEL_AUX_28;
+        case MA_PA_CHANNEL_POSITION_AUX29:                 return MA_CHANNEL_AUX_29;
+        case MA_PA_CHANNEL_POSITION_AUX30:                 return MA_CHANNEL_AUX_30;
+        case MA_PA_CHANNEL_POSITION_AUX31:                 return MA_CHANNEL_AUX_31;
+        case MA_PA_CHANNEL_POSITION_TOP_CENTER:            return MA_CHANNEL_TOP_CENTER;
+        case MA_PA_CHANNEL_POSITION_TOP_FRONT_LEFT:        return MA_CHANNEL_TOP_FRONT_LEFT;
+        case MA_PA_CHANNEL_POSITION_TOP_FRONT_RIGHT:       return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case MA_PA_CHANNEL_POSITION_TOP_FRONT_CENTER:      return MA_CHANNEL_TOP_FRONT_CENTER;
+        case MA_PA_CHANNEL_POSITION_TOP_REAR_LEFT:         return MA_CHANNEL_TOP_BACK_LEFT;
+        case MA_PA_CHANNEL_POSITION_TOP_REAR_RIGHT:        return MA_CHANNEL_TOP_BACK_RIGHT;
+        case MA_PA_CHANNEL_POSITION_TOP_REAR_CENTER:       return MA_CHANNEL_TOP_BACK_CENTER;
+        default: return MA_CHANNEL_NONE;
+    }
+}
+
+#if 0
+static ma_pa_channel_position_t ma_channel_position_to_pulse(ma_channel position)
+{
+    switch (position)
+    {
+        case MA_CHANNEL_NONE:               return MA_PA_CHANNEL_POSITION_INVALID;
+        case MA_CHANNEL_FRONT_LEFT:         return MA_PA_CHANNEL_POSITION_FRONT_LEFT;
+        case MA_CHANNEL_FRONT_RIGHT:        return MA_PA_CHANNEL_POSITION_FRONT_RIGHT;
+        case MA_CHANNEL_FRONT_CENTER:       return MA_PA_CHANNEL_POSITION_FRONT_CENTER;
+        case MA_CHANNEL_LFE:                return MA_PA_CHANNEL_POSITION_LFE;
+        case MA_CHANNEL_BACK_LEFT:          return MA_PA_CHANNEL_POSITION_REAR_LEFT;
+        case MA_CHANNEL_BACK_RIGHT:         return MA_PA_CHANNEL_POSITION_REAR_RIGHT;
+        case MA_CHANNEL_FRONT_LEFT_CENTER:  return MA_PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER;
+        case MA_CHANNEL_FRONT_RIGHT_CENTER: return MA_PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER;
+        case MA_CHANNEL_BACK_CENTER:        return MA_PA_CHANNEL_POSITION_REAR_CENTER;
+        case MA_CHANNEL_SIDE_LEFT:          return MA_PA_CHANNEL_POSITION_SIDE_LEFT;
+        case MA_CHANNEL_SIDE_RIGHT:         return MA_PA_CHANNEL_POSITION_SIDE_RIGHT;
+        case MA_CHANNEL_TOP_CENTER:         return MA_PA_CHANNEL_POSITION_TOP_CENTER;
+        case MA_CHANNEL_TOP_FRONT_LEFT:     return MA_PA_CHANNEL_POSITION_TOP_FRONT_LEFT;
+        case MA_CHANNEL_TOP_FRONT_CENTER:   return MA_PA_CHANNEL_POSITION_TOP_FRONT_CENTER;
+        case MA_CHANNEL_TOP_FRONT_RIGHT:    return MA_PA_CHANNEL_POSITION_TOP_FRONT_RIGHT;
+        case MA_CHANNEL_TOP_BACK_LEFT:      return MA_PA_CHANNEL_POSITION_TOP_REAR_LEFT;
+        case MA_CHANNEL_TOP_BACK_CENTER:    return MA_PA_CHANNEL_POSITION_TOP_REAR_CENTER;
+        case MA_CHANNEL_TOP_BACK_RIGHT:     return MA_PA_CHANNEL_POSITION_TOP_REAR_RIGHT;
+        case MA_CHANNEL_19:                 return MA_PA_CHANNEL_POSITION_AUX18;
+        case MA_CHANNEL_20:                 return MA_PA_CHANNEL_POSITION_AUX19;
+        case MA_CHANNEL_21:                 return MA_PA_CHANNEL_POSITION_AUX20;
+        case MA_CHANNEL_22:                 return MA_PA_CHANNEL_POSITION_AUX21;
+        case MA_CHANNEL_23:                 return MA_PA_CHANNEL_POSITION_AUX22;
+        case MA_CHANNEL_24:                 return MA_PA_CHANNEL_POSITION_AUX23;
+        case MA_CHANNEL_25:                 return MA_PA_CHANNEL_POSITION_AUX24;
+        case MA_CHANNEL_26:                 return MA_PA_CHANNEL_POSITION_AUX25;
+        case MA_CHANNEL_27:                 return MA_PA_CHANNEL_POSITION_AUX26;
+        case MA_CHANNEL_28:                 return MA_PA_CHANNEL_POSITION_AUX27;
+        case MA_CHANNEL_29:                 return MA_PA_CHANNEL_POSITION_AUX28;
+        case MA_CHANNEL_30:                 return MA_PA_CHANNEL_POSITION_AUX29;
+        case MA_CHANNEL_31:                 return MA_PA_CHANNEL_POSITION_AUX30;
+        case MA_CHANNEL_32:                 return MA_PA_CHANNEL_POSITION_AUX31;
+        default: return (ma_pa_channel_position_t)position;
+    }
+}
+#endif
+
+static ma_result ma_wait_for_operation__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_pa_operation* pOP)
+{
+    int resultPA;
+    ma_pa_operation_state_t state;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pOP != NULL);
+
+    for (;;) {
+        state = ((ma_pa_operation_get_state_proc)pContext->pulse.pa_operation_get_state)(pOP);
+        if (state != MA_PA_OPERATION_RUNNING) {
+            break;  /* Done. */
+        }
+
+        resultPA = ((ma_pa_mainloop_iterate_proc)pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pMainLoop, 1, NULL);
+        if (resultPA < 0) {
+            return ma_result_from_pulse(resultPA);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_wait_for_operation_and_unref__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_pa_operation* pOP)
+{
+    ma_result result;
+
+    if (pOP == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_wait_for_operation__pulse(pContext, pMainLoop, pOP);
+    ((ma_pa_operation_unref_proc)pContext->pulse.pa_operation_unref)(pOP);
+
+    return result;
+}
+
+static ma_result ma_wait_for_pa_context_to_connect__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_ptr pPulseContext)
+{
+    int resultPA;
+    ma_pa_context_state_t state;
+
+    for (;;) {
+        state = ((ma_pa_context_get_state_proc)pContext->pulse.pa_context_get_state)((ma_pa_context*)pPulseContext);
+        if (state == MA_PA_CONTEXT_READY) {
+            break;  /* Done. */
+        }
+
+        if (state == MA_PA_CONTEXT_FAILED || state == MA_PA_CONTEXT_TERMINATED) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] An error occurred while connecting the PulseAudio context.");
+            return MA_ERROR;
+        }
+
+        resultPA = ((ma_pa_mainloop_iterate_proc)pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pMainLoop, 1, NULL);
+        if (resultPA < 0) {
+            return ma_result_from_pulse(resultPA);
+        }
+    }
+
+    /* Should never get here. */
+    return MA_SUCCESS;
+}
+
+static ma_result ma_wait_for_pa_stream_to_connect__pulse(ma_context* pContext, ma_ptr pMainLoop, ma_ptr pStream)
+{
+    int resultPA;
+    ma_pa_stream_state_t state;
+
+    for (;;) {
+        state = ((ma_pa_stream_get_state_proc)pContext->pulse.pa_stream_get_state)((ma_pa_stream*)pStream);
+        if (state == MA_PA_STREAM_READY) {
+            break;  /* Done. */
+        }
+
+        if (state == MA_PA_STREAM_FAILED || state == MA_PA_STREAM_TERMINATED) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] An error occurred while connecting the PulseAudio stream.");
+            return MA_ERROR;
+        }
+
+        resultPA = ((ma_pa_mainloop_iterate_proc)pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pMainLoop, 1, NULL);
+        if (resultPA < 0) {
+            return ma_result_from_pulse(resultPA);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_init_pa_mainloop_and_pa_context__pulse(ma_context* pContext, const char* pApplicationName, const char* pServerName, ma_bool32 tryAutoSpawn, ma_ptr* ppMainLoop, ma_ptr* ppPulseContext)
+{
+    ma_result result;
+    ma_ptr pMainLoop;
+    ma_ptr pPulseContext;
+
+    MA_ASSERT(ppMainLoop     != NULL);
+    MA_ASSERT(ppPulseContext != NULL);
+
+    /* The PulseAudio context maps well to miniaudio's notion of a context. The pa_context object will be initialized as part of the ma_context. */
+    pMainLoop = ((ma_pa_mainloop_new_proc)pContext->pulse.pa_mainloop_new)();
+    if (pMainLoop == NULL) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to create mainloop.");
+        return MA_FAILED_TO_INIT_BACKEND;
+    }
+
+    pPulseContext = ((ma_pa_context_new_proc)pContext->pulse.pa_context_new)(((ma_pa_mainloop_get_api_proc)pContext->pulse.pa_mainloop_get_api)((ma_pa_mainloop*)pMainLoop), pApplicationName);
+    if (pPulseContext == NULL) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to create PulseAudio context.");
+        ((ma_pa_mainloop_free_proc)pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)(pMainLoop));
+        return MA_FAILED_TO_INIT_BACKEND;
+    }
+
+    /* Now we need to connect to the context. Everything is asynchronous so we need to wait for it to connect before returning. */
+    result = ma_result_from_pulse(((ma_pa_context_connect_proc)pContext->pulse.pa_context_connect)((ma_pa_context*)pPulseContext, pServerName, (tryAutoSpawn) ? 0 : MA_PA_CONTEXT_NOAUTOSPAWN, NULL));
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to connect PulseAudio context.");
+        ((ma_pa_mainloop_free_proc)pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)(pMainLoop));
+        return result;
+    }
+
+    /* Since ma_context_init() runs synchronously we need to wait for the PulseAudio context to connect before we return. */
+    result = ma_wait_for_pa_context_to_connect__pulse(pContext, pMainLoop, pPulseContext);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[PulseAudio] Waiting for connection failed.");
+        ((ma_pa_mainloop_free_proc)pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)(pMainLoop));
+        return result;
+    }
+
+    *ppMainLoop     = pMainLoop;
+    *ppPulseContext = pPulseContext;
+
+    return MA_SUCCESS;
+}
+
+
+static void ma_device_sink_info_callback(ma_pa_context* pPulseContext, const ma_pa_sink_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_pa_sink_info* pInfoOut;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    /*
+    There has been a report that indicates that pInfo can be null which results
+    in a null pointer dereference below. We'll check for this for safety.
+    */
+    if (pInfo == NULL) {
+        return;
+    }
+
+    pInfoOut = (ma_pa_sink_info*)pUserData;
+    MA_ASSERT(pInfoOut != NULL);
+
+    *pInfoOut = *pInfo;
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static void ma_device_source_info_callback(ma_pa_context* pPulseContext, const ma_pa_source_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_pa_source_info* pInfoOut;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    /*
+    There has been a report that indicates that pInfo can be null which results
+    in a null pointer dereference below. We'll check for this for safety.
+    */
+    if (pInfo == NULL) {
+        return;
+    }
+
+    pInfoOut = (ma_pa_source_info*)pUserData;
+    MA_ASSERT(pInfoOut != NULL);
+
+    *pInfoOut = *pInfo;
+
+    (void)pPulseContext; /* Unused. */
+}
+
+#if 0
+static void ma_device_sink_name_callback(ma_pa_context* pPulseContext, const ma_pa_sink_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_device* pDevice;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), pInfo->description, (size_t)-1);
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static void ma_device_source_name_callback(ma_pa_context* pPulseContext, const ma_pa_source_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_device* pDevice;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), pInfo->description, (size_t)-1);
+
+    (void)pPulseContext; /* Unused. */
+}
+#endif
+
+static ma_result ma_context_get_sink_info__pulse(ma_context* pContext, const char* pDeviceName, ma_pa_sink_info* pSinkInfo)
+{
+    ma_pa_operation* pOP;
+
+    pOP = ((ma_pa_context_get_sink_info_by_name_proc)pContext->pulse.pa_context_get_sink_info_by_name)((ma_pa_context*)pContext->pulse.pPulseContext, pDeviceName, ma_device_sink_info_callback, pSinkInfo);
+    if (pOP == NULL) {
+        return MA_ERROR;
+    }
+
+    return ma_wait_for_operation_and_unref__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+}
+
+static ma_result ma_context_get_source_info__pulse(ma_context* pContext, const char* pDeviceName, ma_pa_source_info* pSourceInfo)
+{
+    ma_pa_operation* pOP;
+
+    pOP = ((ma_pa_context_get_source_info_by_name_proc)pContext->pulse.pa_context_get_source_info_by_name)((ma_pa_context*)pContext->pulse.pPulseContext, pDeviceName, ma_device_source_info_callback, pSourceInfo);
+    if (pOP == NULL) {
+        return MA_ERROR;
+    }
+
+    return ma_wait_for_operation_and_unref__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+}
+
+static ma_result ma_context_get_default_device_index__pulse(ma_context* pContext, ma_device_type deviceType, ma_uint32* pIndex)
+{
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pIndex   != NULL);
+
+    if (pIndex != NULL) {
+        *pIndex = (ma_uint32)-1;
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        ma_pa_sink_info sinkInfo;
+        result = ma_context_get_sink_info__pulse(pContext, NULL, &sinkInfo);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        if (pIndex != NULL) {
+            *pIndex = sinkInfo.index;
+        }
+    }
+
+    if (deviceType == ma_device_type_capture) {
+        ma_pa_source_info sourceInfo;
+        result = ma_context_get_source_info__pulse(pContext, NULL, &sourceInfo);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        if (pIndex != NULL) {
+            *pIndex = sourceInfo.index;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+typedef struct
+{
+    ma_context* pContext;
+    ma_enum_devices_callback_proc callback;
+    void* pUserData;
+    ma_bool32 isTerminated;
+    ma_uint32 defaultDeviceIndexPlayback;
+    ma_uint32 defaultDeviceIndexCapture;
+} ma_context_enumerate_devices_callback_data__pulse;
+
+static void ma_context_enumerate_devices_sink_callback__pulse(ma_pa_context* pPulseContext, const ma_pa_sink_info* pSinkInfo, int endOfList, void* pUserData)
+{
+    ma_context_enumerate_devices_callback_data__pulse* pData = (ma_context_enumerate_devices_callback_data__pulse*)pUserData;
+    ma_device_info deviceInfo;
+
+    MA_ASSERT(pData != NULL);
+
+    if (endOfList || pData->isTerminated) {
+        return;
+    }
+
+    MA_ZERO_OBJECT(&deviceInfo);
+
+    /* The name from PulseAudio is the ID for miniaudio. */
+    if (pSinkInfo->name != NULL) {
+        ma_strncpy_s(deviceInfo.id.pulse, sizeof(deviceInfo.id.pulse), pSinkInfo->name, (size_t)-1);
+    }
+
+    /* The description from PulseAudio is the name for miniaudio. */
+    if (pSinkInfo->description != NULL) {
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), pSinkInfo->description, (size_t)-1);
+    }
+
+    if (pSinkInfo->index == pData->defaultDeviceIndexPlayback) {
+        deviceInfo.isDefault = MA_TRUE;
+    }
+
+    pData->isTerminated = !pData->callback(pData->pContext, ma_device_type_playback, &deviceInfo, pData->pUserData);
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static void ma_context_enumerate_devices_source_callback__pulse(ma_pa_context* pPulseContext, const ma_pa_source_info* pSourceInfo, int endOfList, void* pUserData)
+{
+    ma_context_enumerate_devices_callback_data__pulse* pData = (ma_context_enumerate_devices_callback_data__pulse*)pUserData;
+    ma_device_info deviceInfo;
+
+    MA_ASSERT(pData != NULL);
+
+    if (endOfList || pData->isTerminated) {
+        return;
+    }
+
+    MA_ZERO_OBJECT(&deviceInfo);
+
+    /* The name from PulseAudio is the ID for miniaudio. */
+    if (pSourceInfo->name != NULL) {
+        ma_strncpy_s(deviceInfo.id.pulse, sizeof(deviceInfo.id.pulse), pSourceInfo->name, (size_t)-1);
+    }
+
+    /* The description from PulseAudio is the name for miniaudio. */
+    if (pSourceInfo->description != NULL) {
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), pSourceInfo->description, (size_t)-1);
+    }
+
+    if (pSourceInfo->index == pData->defaultDeviceIndexCapture) {
+        deviceInfo.isDefault = MA_TRUE;
+    }
+
+    pData->isTerminated = !pData->callback(pData->pContext, ma_device_type_capture, &deviceInfo, pData->pUserData);
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static ma_result ma_context_enumerate_devices__pulse(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_result result = MA_SUCCESS;
+    ma_context_enumerate_devices_callback_data__pulse callbackData;
+    ma_pa_operation* pOP = NULL;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    callbackData.pContext = pContext;
+    callbackData.callback = callback;
+    callbackData.pUserData = pUserData;
+    callbackData.isTerminated = MA_FALSE;
+    callbackData.defaultDeviceIndexPlayback = (ma_uint32)-1;
+    callbackData.defaultDeviceIndexCapture  = (ma_uint32)-1;
+
+    /* We need to get the index of the default devices. */
+    ma_context_get_default_device_index__pulse(pContext, ma_device_type_playback, &callbackData.defaultDeviceIndexPlayback);
+    ma_context_get_default_device_index__pulse(pContext, ma_device_type_capture,  &callbackData.defaultDeviceIndexCapture);
+
+    /* Playback. */
+    if (!callbackData.isTerminated) {
+        pOP = ((ma_pa_context_get_sink_info_list_proc)pContext->pulse.pa_context_get_sink_info_list)((ma_pa_context*)(pContext->pulse.pPulseContext), ma_context_enumerate_devices_sink_callback__pulse, &callbackData);
+        if (pOP == NULL) {
+            result = MA_ERROR;
+            goto done;
+        }
+
+        result = ma_wait_for_operation__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+        ((ma_pa_operation_unref_proc)pContext->pulse.pa_operation_unref)(pOP);
+
+        if (result != MA_SUCCESS) {
+            goto done;
+        }
+    }
+
+
+    /* Capture. */
+    if (!callbackData.isTerminated) {
+        pOP = ((ma_pa_context_get_source_info_list_proc)pContext->pulse.pa_context_get_source_info_list)((ma_pa_context*)(pContext->pulse.pPulseContext), ma_context_enumerate_devices_source_callback__pulse, &callbackData);
+        if (pOP == NULL) {
+            result = MA_ERROR;
+            goto done;
+        }
+
+        result = ma_wait_for_operation__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+        ((ma_pa_operation_unref_proc)pContext->pulse.pa_operation_unref)(pOP);
+
+        if (result != MA_SUCCESS) {
+            goto done;
+        }
+    }
+
+done:
+    return result;
+}
+
+
+typedef struct
+{
+    ma_device_info* pDeviceInfo;
+    ma_uint32 defaultDeviceIndex;
+    ma_bool32 foundDevice;
+} ma_context_get_device_info_callback_data__pulse;
+
+static void ma_context_get_device_info_sink_callback__pulse(ma_pa_context* pPulseContext, const ma_pa_sink_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_context_get_device_info_callback_data__pulse* pData = (ma_context_get_device_info_callback_data__pulse*)pUserData;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    MA_ASSERT(pData != NULL);
+    pData->foundDevice = MA_TRUE;
+
+    if (pInfo->name != NULL) {
+        ma_strncpy_s(pData->pDeviceInfo->id.pulse, sizeof(pData->pDeviceInfo->id.pulse), pInfo->name, (size_t)-1);
+    }
+
+    if (pInfo->description != NULL) {
+        ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), pInfo->description, (size_t)-1);
+    }
+
+    /*
+    We're just reporting a single data format here. I think technically PulseAudio might support
+    all formats, but I don't trust that PulseAudio will do *anything* right, so I'm just going to
+    report the "native" device format.
+    */
+    pData->pDeviceInfo->nativeDataFormats[0].format     = ma_format_from_pulse(pInfo->sample_spec.format);
+    pData->pDeviceInfo->nativeDataFormats[0].channels   = pInfo->sample_spec.channels;
+    pData->pDeviceInfo->nativeDataFormats[0].sampleRate = pInfo->sample_spec.rate;
+    pData->pDeviceInfo->nativeDataFormats[0].flags      = 0;
+    pData->pDeviceInfo->nativeDataFormatCount = 1;
+
+    if (pData->defaultDeviceIndex == pInfo->index) {
+        pData->pDeviceInfo->isDefault = MA_TRUE;
+    }
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static void ma_context_get_device_info_source_callback__pulse(ma_pa_context* pPulseContext, const ma_pa_source_info* pInfo, int endOfList, void* pUserData)
+{
+    ma_context_get_device_info_callback_data__pulse* pData = (ma_context_get_device_info_callback_data__pulse*)pUserData;
+
+    if (endOfList > 0) {
+        return;
+    }
+
+    MA_ASSERT(pData != NULL);
+    pData->foundDevice = MA_TRUE;
+
+    if (pInfo->name != NULL) {
+        ma_strncpy_s(pData->pDeviceInfo->id.pulse, sizeof(pData->pDeviceInfo->id.pulse), pInfo->name, (size_t)-1);
+    }
+
+    if (pInfo->description != NULL) {
+        ma_strncpy_s(pData->pDeviceInfo->name, sizeof(pData->pDeviceInfo->name), pInfo->description, (size_t)-1);
+    }
+
+    /*
+    We're just reporting a single data format here. I think technically PulseAudio might support
+    all formats, but I don't trust that PulseAudio will do *anything* right, so I'm just going to
+    report the "native" device format.
+    */
+    pData->pDeviceInfo->nativeDataFormats[0].format     = ma_format_from_pulse(pInfo->sample_spec.format);
+    pData->pDeviceInfo->nativeDataFormats[0].channels   = pInfo->sample_spec.channels;
+    pData->pDeviceInfo->nativeDataFormats[0].sampleRate = pInfo->sample_spec.rate;
+    pData->pDeviceInfo->nativeDataFormats[0].flags      = 0;
+    pData->pDeviceInfo->nativeDataFormatCount = 1;
+
+    if (pData->defaultDeviceIndex == pInfo->index) {
+        pData->pDeviceInfo->isDefault = MA_TRUE;
+    }
+
+    (void)pPulseContext; /* Unused. */
+}
+
+static ma_result ma_context_get_device_info__pulse(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_result result = MA_SUCCESS;
+    ma_context_get_device_info_callback_data__pulse callbackData;
+    ma_pa_operation* pOP = NULL;
+    const char* pDeviceName = NULL;
+
+    MA_ASSERT(pContext != NULL);
+
+    callbackData.pDeviceInfo = pDeviceInfo;
+    callbackData.foundDevice = MA_FALSE;
+
+    if (pDeviceID != NULL) {
+        pDeviceName = pDeviceID->pulse;
+    } else {
+        pDeviceName = NULL;
+    }
+
+    result = ma_context_get_default_device_index__pulse(pContext, deviceType, &callbackData.defaultDeviceIndex);
+
+    if (deviceType == ma_device_type_playback) {
+        pOP = ((ma_pa_context_get_sink_info_by_name_proc)pContext->pulse.pa_context_get_sink_info_by_name)((ma_pa_context*)(pContext->pulse.pPulseContext), pDeviceName, ma_context_get_device_info_sink_callback__pulse, &callbackData);
+    } else {
+        pOP = ((ma_pa_context_get_source_info_by_name_proc)pContext->pulse.pa_context_get_source_info_by_name)((ma_pa_context*)(pContext->pulse.pPulseContext), pDeviceName, ma_context_get_device_info_source_callback__pulse, &callbackData);
+    }
+
+    if (pOP != NULL) {
+        ma_wait_for_operation_and_unref__pulse(pContext, pContext->pulse.pMainLoop, pOP);
+    } else {
+        result = MA_ERROR;
+        goto done;
+    }
+
+    if (!callbackData.foundDevice) {
+        result = MA_NO_DEVICE;
+        goto done;
+    }
+
+done:
+    return result;
+}
+
+static ma_result ma_device_uninit__pulse(ma_device* pDevice)
+{
+    ma_context* pContext;
+
+    MA_ASSERT(pDevice != NULL);
+
+    pContext = pDevice->pContext;
+    MA_ASSERT(pContext != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((ma_pa_stream_disconnect_proc)pContext->pulse.pa_stream_disconnect)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+        ((ma_pa_stream_unref_proc)pContext->pulse.pa_stream_unref)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ((ma_pa_stream_disconnect_proc)pContext->pulse.pa_stream_disconnect)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+        ((ma_pa_stream_unref_proc)pContext->pulse.pa_stream_unref)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+    }
+
+    if (pDevice->type == ma_device_type_duplex) {
+        ma_duplex_rb_uninit(&pDevice->duplexRB);
+    }
+
+    ((ma_pa_context_disconnect_proc)pContext->pulse.pa_context_disconnect)((ma_pa_context*)pDevice->pulse.pPulseContext);
+    ((ma_pa_context_unref_proc)pContext->pulse.pa_context_unref)((ma_pa_context*)pDevice->pulse.pPulseContext);
+    ((ma_pa_mainloop_free_proc)pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)pDevice->pulse.pMainLoop);
+
+    return MA_SUCCESS;
+}
+
+static ma_pa_buffer_attr ma_device__pa_buffer_attr_new(ma_uint32 periodSizeInFrames, ma_uint32 periods, const ma_pa_sample_spec* ss)
+{
+    ma_pa_buffer_attr attr;
+    attr.maxlength = periodSizeInFrames * periods * ma_get_bytes_per_frame(ma_format_from_pulse(ss->format), ss->channels);
+    attr.tlength   = attr.maxlength / periods;
+    attr.prebuf    = (ma_uint32)-1;
+    attr.minreq    = (ma_uint32)-1;
+    attr.fragsize  = attr.maxlength / periods;
+
+    return attr;
+}
+
+static ma_pa_stream* ma_device__pa_stream_new__pulse(ma_device* pDevice, const char* pStreamName, const ma_pa_sample_spec* ss, const ma_pa_channel_map* cmap)
+{
+    static int g_StreamCounter = 0;
+    char actualStreamName[256];
+
+    if (pStreamName != NULL) {
+        ma_strncpy_s(actualStreamName, sizeof(actualStreamName), pStreamName, (size_t)-1);
+    } else {
+        ma_strcpy_s(actualStreamName, sizeof(actualStreamName), "miniaudio:");
+        ma_itoa_s(g_StreamCounter, actualStreamName + 8, sizeof(actualStreamName)-8, 10);  /* 8 = strlen("miniaudio:") */
+    }
+    g_StreamCounter += 1;
+
+    return ((ma_pa_stream_new_proc)pDevice->pContext->pulse.pa_stream_new)((ma_pa_context*)pDevice->pulse.pPulseContext, actualStreamName, ss, cmap);
+}
+
+
+static void ma_device_on_read__pulse(ma_pa_stream* pStream, size_t byteCount, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    ma_uint32 bpf;
+    ma_uint32 deviceState;
+    ma_uint64 frameCount;
+    ma_uint64 framesProcessed;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    Don't do anything if the device isn't initialized yet. Yes, this can happen because PulseAudio
+    can fire this callback before the stream has even started. Ridiculous.
+    */
+    deviceState = ma_device_get_state(pDevice);
+    if (deviceState != ma_device_state_starting && deviceState != ma_device_state_started) {
+        return;
+    }
+
+    bpf = ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+    MA_ASSERT(bpf > 0);
+
+    frameCount = byteCount / bpf;
+    framesProcessed = 0;
+
+    while (ma_device_get_state(pDevice) == ma_device_state_started && framesProcessed < frameCount) {
+        const void* pMappedPCMFrames;
+        size_t bytesMapped;
+        ma_uint64 framesMapped;
+
+        int pulseResult = ((ma_pa_stream_peek_proc)pDevice->pContext->pulse.pa_stream_peek)(pStream, &pMappedPCMFrames, &bytesMapped);
+        if (pulseResult < 0) {
+            break; /* Failed to map. Abort. */
+        }
+
+        framesMapped = bytesMapped / bpf;
+        if (framesMapped > 0) {
+            if (pMappedPCMFrames != NULL) {
+                ma_device_handle_backend_data_callback(pDevice, NULL, pMappedPCMFrames, framesMapped);
+            } else {
+                /* It's a hole. */
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[PulseAudio] ma_device_on_read__pulse: Hole.\n");
+            }
+
+            pulseResult = ((ma_pa_stream_drop_proc)pDevice->pContext->pulse.pa_stream_drop)(pStream);
+            if (pulseResult < 0) {
+                break;  /* Failed to drop the buffer. */
+            }
+
+            framesProcessed += framesMapped;
+
+        } else {
+            /* Nothing was mapped. Just abort. */
+            break;
+        }
+    }
+}
+
+static ma_result ma_device_write_to_stream__pulse(ma_device* pDevice, ma_pa_stream* pStream, ma_uint64* pFramesProcessed)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 framesProcessed = 0;
+    size_t bytesMapped;
+    ma_uint32 bpf;
+    ma_uint32 deviceState;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pStream != NULL);
+
+    bpf = ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    MA_ASSERT(bpf > 0);
+
+    deviceState = ma_device_get_state(pDevice);
+
+    bytesMapped = ((ma_pa_stream_writable_size_proc)pDevice->pContext->pulse.pa_stream_writable_size)(pStream);
+    if (bytesMapped != (size_t)-1) {
+        if (bytesMapped > 0) {
+            ma_uint64 framesMapped;
+            void* pMappedPCMFrames;
+            int pulseResult = ((ma_pa_stream_begin_write_proc)pDevice->pContext->pulse.pa_stream_begin_write)(pStream, &pMappedPCMFrames, &bytesMapped);
+            if (pulseResult < 0) {
+                result = ma_result_from_pulse(pulseResult);
+                goto done;
+            }
+
+            framesMapped = bytesMapped / bpf;
+
+            if (deviceState == ma_device_state_started || deviceState == ma_device_state_starting) {  /* Check for starting state just in case this is being used to do the initial fill. */
+                ma_device_handle_backend_data_callback(pDevice, pMappedPCMFrames, NULL, framesMapped);
+            } else {
+                /* Device is not started. Write silence. */
+                ma_silence_pcm_frames(pMappedPCMFrames, framesMapped, pDevice->playback.format, pDevice->playback.channels);
+            }
+
+            pulseResult = ((ma_pa_stream_write_proc)pDevice->pContext->pulse.pa_stream_write)(pStream, pMappedPCMFrames, bytesMapped, NULL, 0, MA_PA_SEEK_RELATIVE);
+            if (pulseResult < 0) {
+                result = ma_result_from_pulse(pulseResult);
+                goto done;  /* Failed to write data to stream. */
+            }
+
+            framesProcessed += framesMapped;
+        } else {
+            result = MA_SUCCESS;  /* No data available for writing. */
+            goto done;
+        }
+    } else {
+        result = MA_ERROR;  /* Failed to retrieve the writable size. Abort. */
+        goto done;
+    }
+
+done:
+    if (pFramesProcessed != NULL) {
+        *pFramesProcessed = framesProcessed;
+    }
+
+    return result;
+}
+
+static void ma_device_on_write__pulse(ma_pa_stream* pStream, size_t byteCount, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    ma_uint32 bpf;
+    ma_uint64 frameCount;
+    ma_uint64 framesProcessed;
+    ma_uint32 deviceState;
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    Don't do anything if the device isn't initialized yet. Yes, this can happen because PulseAudio
+    can fire this callback before the stream has even started. Ridiculous.
+    */
+    deviceState = ma_device_get_state(pDevice);
+    if (deviceState != ma_device_state_starting && deviceState != ma_device_state_started) {
+        return;
+    }
+
+    bpf = ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    MA_ASSERT(bpf > 0);
+
+    frameCount = byteCount / bpf;
+    framesProcessed = 0;
+
+    while (framesProcessed < frameCount) {
+        ma_uint64 framesProcessedThisIteration;
+
+        /* Don't keep trying to process frames if the device isn't started. */
+        deviceState = ma_device_get_state(pDevice);
+        if (deviceState != ma_device_state_starting && deviceState != ma_device_state_started) {
+            break;
+        }
+
+        result = ma_device_write_to_stream__pulse(pDevice, pStream, &framesProcessedThisIteration);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        framesProcessed += framesProcessedThisIteration;
+    }
+}
+
+static void ma_device_on_suspended__pulse(ma_pa_stream* pStream, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    int suspended;
+
+    (void)pStream;
+
+    suspended = ((ma_pa_stream_is_suspended_proc)pDevice->pContext->pulse.pa_stream_is_suspended)(pStream);
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[Pulse] Device suspended state changed. pa_stream_is_suspended() returned %d.\n", suspended);
+
+    if (suspended < 0) {
+        return;
+    }
+
+    if (suspended == 1) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[Pulse] Device suspended state changed. Suspended.\n");
+        ma_device__on_notification_stopped(pDevice);
+    } else {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "[Pulse] Device suspended state changed. Resumed.\n");
+        ma_device__on_notification_started(pDevice);
+    }
+}
+
+static void ma_device_on_rerouted__pulse(ma_pa_stream* pStream, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+
+    (void)pStream;
+    (void)pUserData;
+
+    ma_device__on_notification_rerouted(pDevice);
+}
+
+static ma_uint32 ma_calculate_period_size_in_frames_from_descriptor__pulse(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+    /*
+    There have been reports from users where buffers of < ~20ms result glitches when running through
+    PipeWire. To work around this we're going to have to use a different default buffer size.
+    */
+    const ma_uint32 defaultPeriodSizeInMilliseconds_LowLatency   = 25;
+    const ma_uint32 defaultPeriodSizeInMilliseconds_Conservative = MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE;
+
+    MA_ASSERT(nativeSampleRate != 0);
+
+    if (pDescriptor->periodSizeInFrames == 0) {
+        if (pDescriptor->periodSizeInMilliseconds == 0) {
+            if (performanceProfile == ma_performance_profile_low_latency) {
+                return ma_calculate_buffer_size_in_frames_from_milliseconds(defaultPeriodSizeInMilliseconds_LowLatency, nativeSampleRate);
+            } else {
+                return ma_calculate_buffer_size_in_frames_from_milliseconds(defaultPeriodSizeInMilliseconds_Conservative, nativeSampleRate);
+            }
+        } else {
+            return ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptor->periodSizeInMilliseconds, nativeSampleRate);
+        }
+    } else {
+        return pDescriptor->periodSizeInFrames;
+    }
+}
+
+static ma_result ma_device_init__pulse(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    /*
+    Notes for PulseAudio:
+
+      - When both the period size in frames and milliseconds are 0, we default to miniaudio's
+        default buffer sizes rather than leaving it up to PulseAudio because I don't trust
+        PulseAudio to give us any kind of reasonable latency by default.
+
+      - Do not ever, *ever* forget to use MA_PA_STREAM_ADJUST_LATENCY. If you don't specify this
+        flag, capture mode will just not work properly until you open another PulseAudio app.
+    */
+
+    ma_result result = MA_SUCCESS;
+    int error = 0;
+    const char* devPlayback = NULL;
+    const char* devCapture  = NULL;
+    ma_format format = ma_format_unknown;
+    ma_uint32 channels = 0;
+    ma_uint32 sampleRate = 0;
+    ma_pa_sink_info sinkInfo;
+    ma_pa_source_info sourceInfo;
+    ma_pa_sample_spec ss;
+    ma_pa_channel_map cmap;
+    ma_pa_buffer_attr attr;
+    const ma_pa_sample_spec* pActualSS   = NULL;
+    const ma_pa_buffer_attr* pActualAttr = NULL;
+    ma_uint32 iChannel;
+    ma_pa_stream_flags_t streamFlags;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ZERO_OBJECT(&pDevice->pulse);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* No exclusive mode with the PulseAudio backend. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pConfig->playback.shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pConfig->capture.shareMode  == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        if (pDescriptorPlayback->pDeviceID != NULL) {
+            devPlayback = pDescriptorPlayback->pDeviceID->pulse;
+        }
+
+        format     = pDescriptorPlayback->format;
+        channels   = pDescriptorPlayback->channels;
+        sampleRate = pDescriptorPlayback->sampleRate;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) {
+        if (pDescriptorCapture->pDeviceID != NULL) {
+            devCapture = pDescriptorCapture->pDeviceID->pulse;
+        }
+
+        format     = pDescriptorCapture->format;
+        channels   = pDescriptorCapture->channels;
+        sampleRate = pDescriptorCapture->sampleRate;
+    }
+
+
+
+    result = ma_init_pa_mainloop_and_pa_context__pulse(pDevice->pContext, pDevice->pContext->pulse.pApplicationName, pDevice->pContext->pulse.pServerName, MA_FALSE, &pDevice->pulse.pMainLoop, &pDevice->pulse.pPulseContext);
+    if (result != MA_SUCCESS) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to initialize PA mainloop and context for device.\n");
+        return result;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        result = ma_context_get_source_info__pulse(pDevice->pContext, devCapture, &sourceInfo);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to retrieve source info for capture device.");
+            goto on_error0;
+        }
+
+        ss   = sourceInfo.sample_spec;
+        cmap = sourceInfo.channel_map;
+
+        /* Use the requested channel count if we have one. */
+        if (pDescriptorCapture->channels != 0) {
+            ss.channels = pDescriptorCapture->channels;
+        }
+
+        /* Use a default channel map. */
+        ((ma_pa_channel_map_init_extend_proc)pDevice->pContext->pulse.pa_channel_map_init_extend)(&cmap, ss.channels, MA_PA_CHANNEL_MAP_DEFAULT);
+
+        /* Use the requested sample rate if one was specified. */
+        if (pDescriptorCapture->sampleRate != 0) {
+            ss.rate = pDescriptorCapture->sampleRate;
+        }
+        streamFlags = MA_PA_STREAM_START_CORKED | MA_PA_STREAM_ADJUST_LATENCY;
+
+        if (ma_format_from_pulse(ss.format) == ma_format_unknown) {
+            if (ma_is_little_endian()) {
+                ss.format = MA_PA_SAMPLE_FLOAT32LE;
+            } else {
+                ss.format = MA_PA_SAMPLE_FLOAT32BE;
+            }
+            streamFlags |= MA_PA_STREAM_FIX_FORMAT;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.format not supported by miniaudio. Defaulting to PA_SAMPLE_FLOAT32.\n");
+        }
+        if (ss.rate == 0) {
+            ss.rate = MA_DEFAULT_SAMPLE_RATE;
+            streamFlags |= MA_PA_STREAM_FIX_RATE;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.rate = 0. Defaulting to %d.\n", ss.rate);
+        }
+        if (ss.channels == 0) {
+            ss.channels = MA_DEFAULT_CHANNELS;
+            streamFlags |= MA_PA_STREAM_FIX_CHANNELS;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.channels = 0. Defaulting to %d.\n", ss.channels);
+        }
+
+        /* We now have enough information to calculate our actual period size in frames. */
+        pDescriptorCapture->periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__pulse(pDescriptorCapture, ss.rate, pConfig->performanceProfile);
+
+        attr = ma_device__pa_buffer_attr_new(pDescriptorCapture->periodSizeInFrames, pDescriptorCapture->periodCount, &ss);
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Capture attr: maxlength=%d, tlength=%d, prebuf=%d, minreq=%d, fragsize=%d; periodSizeInFrames=%d\n", attr.maxlength, attr.tlength, attr.prebuf, attr.minreq, attr.fragsize, pDescriptorCapture->periodSizeInFrames);
+
+        pDevice->pulse.pStreamCapture = ma_device__pa_stream_new__pulse(pDevice, pConfig->pulse.pStreamNameCapture, &ss, &cmap);
+        if (pDevice->pulse.pStreamCapture == NULL) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to create PulseAudio capture stream.\n");
+            result = MA_ERROR;
+            goto on_error0;
+        }
+
+
+        /* The callback needs to be set before connecting the stream. */
+        ((ma_pa_stream_set_read_callback_proc)pDevice->pContext->pulse.pa_stream_set_read_callback)((ma_pa_stream*)pDevice->pulse.pStreamCapture, ma_device_on_read__pulse, pDevice);
+
+        /* State callback for checking when the device has been corked. */
+        ((ma_pa_stream_set_suspended_callback_proc)pDevice->pContext->pulse.pa_stream_set_suspended_callback)((ma_pa_stream*)pDevice->pulse.pStreamCapture, ma_device_on_suspended__pulse, pDevice);
+
+        /* Rerouting notification. */
+        ((ma_pa_stream_set_moved_callback_proc)pDevice->pContext->pulse.pa_stream_set_moved_callback)((ma_pa_stream*)pDevice->pulse.pStreamCapture, ma_device_on_rerouted__pulse, pDevice);
+
+
+        /* Connect after we've got all of our internal state set up. */
+        if (devCapture != NULL) {
+            streamFlags |= MA_PA_STREAM_DONT_MOVE;
+        }
+
+        error = ((ma_pa_stream_connect_record_proc)pDevice->pContext->pulse.pa_stream_connect_record)((ma_pa_stream*)pDevice->pulse.pStreamCapture, devCapture, &attr, streamFlags);
+        if (error != MA_PA_OK) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to connect PulseAudio capture stream.");
+            result = ma_result_from_pulse(error);
+            goto on_error1;
+        }
+
+        result = ma_wait_for_pa_stream_to_connect__pulse(pDevice->pContext, pDevice->pulse.pMainLoop, (ma_pa_stream*)pDevice->pulse.pStreamCapture);
+        if (result != MA_SUCCESS) {
+            goto on_error2;
+        }
+
+
+        /* Internal format. */
+        pActualSS = ((ma_pa_stream_get_sample_spec_proc)pDevice->pContext->pulse.pa_stream_get_sample_spec)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+        if (pActualSS != NULL) {
+            ss = *pActualSS;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Capture sample spec: format=%s, channels=%d, rate=%d\n", ma_get_format_name(ma_format_from_pulse(ss.format)), ss.channels, ss.rate);
+        } else {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Failed to retrieve capture sample spec.\n");
+        }
+
+        pDescriptorCapture->format     = ma_format_from_pulse(ss.format);
+        pDescriptorCapture->channels   = ss.channels;
+        pDescriptorCapture->sampleRate = ss.rate;
+
+        if (pDescriptorCapture->format == ma_format_unknown || pDescriptorCapture->channels == 0 || pDescriptorCapture->sampleRate == 0) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Capture sample spec is invalid. Device unusable by miniaudio. format=%s, channels=%d, sampleRate=%d.\n", ma_get_format_name(pDescriptorCapture->format), pDescriptorCapture->channels, pDescriptorCapture->sampleRate);
+            result = MA_ERROR;
+            goto on_error4;
+        }
+
+        /* Internal channel map. */
+
+        /*
+        Bug in PipeWire. There have been reports that PipeWire is returning AUX channels when reporting
+        the channel map. To somewhat workaround this, I'm hacking in a hard coded channel map for mono
+        and stereo. In this case it should be safe to assume mono = MONO and stereo = LEFT/RIGHT. For
+        all other channel counts we need to just put up with whatever PipeWire reports and hope it gets
+        fixed sooner than later. I might remove this hack later.
+        */
+        if (pDescriptorCapture->channels > 2) {
+            for (iChannel = 0; iChannel < pDescriptorCapture->channels; ++iChannel) {
+                pDescriptorCapture->channelMap[iChannel] = ma_channel_position_from_pulse(cmap.map[iChannel]);
+            }
+        } else {
+            /* Hack for mono and stereo. */
+            if (pDescriptorCapture->channels == 1) {
+                pDescriptorCapture->channelMap[0] = MA_CHANNEL_MONO;
+            } else if (pDescriptorCapture->channels == 2) {
+                pDescriptorCapture->channelMap[0] = MA_CHANNEL_FRONT_LEFT;
+                pDescriptorCapture->channelMap[1] = MA_CHANNEL_FRONT_RIGHT;
+            } else {
+                MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+            }
+        }
+
+
+        /* Buffer. */
+        pActualAttr = ((ma_pa_stream_get_buffer_attr_proc)pDevice->pContext->pulse.pa_stream_get_buffer_attr)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+        if (pActualAttr != NULL) {
+            attr = *pActualAttr;
+        }
+
+        if (attr.fragsize > 0) {
+            pDescriptorCapture->periodCount = ma_max(attr.maxlength / attr.fragsize, 1);
+        } else {
+            pDescriptorCapture->periodCount = 1;
+        }
+
+        pDescriptorCapture->periodSizeInFrames = attr.maxlength / ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels) / pDescriptorCapture->periodCount;
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Capture actual attr: maxlength=%d, tlength=%d, prebuf=%d, minreq=%d, fragsize=%d; periodSizeInFrames=%d\n", attr.maxlength, attr.tlength, attr.prebuf, attr.minreq, attr.fragsize, pDescriptorCapture->periodSizeInFrames);
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        result = ma_context_get_sink_info__pulse(pDevice->pContext, devPlayback, &sinkInfo);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to retrieve sink info for playback device.\n");
+            goto on_error2;
+        }
+
+        ss   = sinkInfo.sample_spec;
+        cmap = sinkInfo.channel_map;
+
+        /* Use the requested channel count if we have one. */
+        if (pDescriptorPlayback->channels != 0) {
+            ss.channels = pDescriptorPlayback->channels;
+        }
+
+        /* Use a default channel map. */
+        ((ma_pa_channel_map_init_extend_proc)pDevice->pContext->pulse.pa_channel_map_init_extend)(&cmap, ss.channels, MA_PA_CHANNEL_MAP_DEFAULT);
+
+
+        /* Use the requested sample rate if one was specified. */
+        if (pDescriptorPlayback->sampleRate != 0) {
+            ss.rate = pDescriptorPlayback->sampleRate;
+        }
+
+        streamFlags = MA_PA_STREAM_START_CORKED | MA_PA_STREAM_ADJUST_LATENCY;
+        if (ma_format_from_pulse(ss.format) == ma_format_unknown) {
+            if (ma_is_little_endian()) {
+                ss.format = MA_PA_SAMPLE_FLOAT32LE;
+            } else {
+                ss.format = MA_PA_SAMPLE_FLOAT32BE;
+            }
+            streamFlags |= MA_PA_STREAM_FIX_FORMAT;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.format not supported by miniaudio. Defaulting to PA_SAMPLE_FLOAT32.\n");
+        }
+        if (ss.rate == 0) {
+            ss.rate = MA_DEFAULT_SAMPLE_RATE;
+            streamFlags |= MA_PA_STREAM_FIX_RATE;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.rate = 0. Defaulting to %d.\n", ss.rate);
+        }
+        if (ss.channels == 0) {
+            ss.channels = MA_DEFAULT_CHANNELS;
+            streamFlags |= MA_PA_STREAM_FIX_CHANNELS;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] sample_spec.channels = 0. Defaulting to %d.\n", ss.channels);
+        }
+
+        /* We now have enough information to calculate the actual buffer size in frames. */
+        pDescriptorPlayback->periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__pulse(pDescriptorPlayback, ss.rate, pConfig->performanceProfile);
+
+        attr = ma_device__pa_buffer_attr_new(pDescriptorPlayback->periodSizeInFrames, pDescriptorPlayback->periodCount, &ss);
+
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Playback attr: maxlength=%d, tlength=%d, prebuf=%d, minreq=%d, fragsize=%d; periodSizeInFrames=%d\n", attr.maxlength, attr.tlength, attr.prebuf, attr.minreq, attr.fragsize, pDescriptorPlayback->periodSizeInFrames);
+
+        pDevice->pulse.pStreamPlayback = ma_device__pa_stream_new__pulse(pDevice, pConfig->pulse.pStreamNamePlayback, &ss, &cmap);
+        if (pDevice->pulse.pStreamPlayback == NULL) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to create PulseAudio playback stream.\n");
+            result = MA_ERROR;
+            goto on_error2;
+        }
+
+
+        /*
+        Note that this callback will be fired as soon as the stream is connected, even though it's started as corked. The callback needs to handle a
+        device state of ma_device_state_uninitialized.
+        */
+        ((ma_pa_stream_set_write_callback_proc)pDevice->pContext->pulse.pa_stream_set_write_callback)((ma_pa_stream*)pDevice->pulse.pStreamPlayback, ma_device_on_write__pulse, pDevice);
+
+        /* State callback for checking when the device has been corked. */
+        ((ma_pa_stream_set_suspended_callback_proc)pDevice->pContext->pulse.pa_stream_set_suspended_callback)((ma_pa_stream*)pDevice->pulse.pStreamPlayback, ma_device_on_suspended__pulse, pDevice);
+
+        /* Rerouting notification. */
+        ((ma_pa_stream_set_moved_callback_proc)pDevice->pContext->pulse.pa_stream_set_moved_callback)((ma_pa_stream*)pDevice->pulse.pStreamPlayback, ma_device_on_rerouted__pulse, pDevice);
+
+
+        /* Connect after we've got all of our internal state set up. */
+        if (devPlayback != NULL) {
+            streamFlags |= MA_PA_STREAM_DONT_MOVE;
+        }
+
+        error = ((ma_pa_stream_connect_playback_proc)pDevice->pContext->pulse.pa_stream_connect_playback)((ma_pa_stream*)pDevice->pulse.pStreamPlayback, devPlayback, &attr, streamFlags, NULL, NULL);
+        if (error != MA_PA_OK) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to connect PulseAudio playback stream.");
+            result = ma_result_from_pulse(error);
+            goto on_error3;
+        }
+
+        result = ma_wait_for_pa_stream_to_connect__pulse(pDevice->pContext, pDevice->pulse.pMainLoop, (ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+        if (result != MA_SUCCESS) {
+            goto on_error3;
+        }
+
+
+        /* Internal format. */
+        pActualSS = ((ma_pa_stream_get_sample_spec_proc)pDevice->pContext->pulse.pa_stream_get_sample_spec)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+        if (pActualSS != NULL) {
+            ss = *pActualSS;
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Playback sample spec: format=%s, channels=%d, rate=%d\n", ma_get_format_name(ma_format_from_pulse(ss.format)), ss.channels, ss.rate);
+        } else {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Failed to retrieve playback sample spec.\n");
+        }
+
+        pDescriptorPlayback->format     = ma_format_from_pulse(ss.format);
+        pDescriptorPlayback->channels   = ss.channels;
+        pDescriptorPlayback->sampleRate = ss.rate;
+
+        if (pDescriptorPlayback->format == ma_format_unknown || pDescriptorPlayback->channels == 0 || pDescriptorPlayback->sampleRate == 0) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Playback sample spec is invalid. Device unusable by miniaudio. format=%s, channels=%d, sampleRate=%d.\n", ma_get_format_name(pDescriptorPlayback->format), pDescriptorPlayback->channels, pDescriptorPlayback->sampleRate);
+            result = MA_ERROR;
+            goto on_error4;
+        }
+
+        /* Internal channel map. */
+
+        /*
+        Bug in PipeWire. There have been reports that PipeWire is returning AUX channels when reporting
+        the channel map. To somewhat workaround this, I'm hacking in a hard coded channel map for mono
+        and stereo. In this case it should be safe to assume mono = MONO and stereo = LEFT/RIGHT. For
+        all other channel counts we need to just put up with whatever PipeWire reports and hope it gets
+        fixed sooner than later. I might remove this hack later.
+        */
+        if (pDescriptorPlayback->channels > 2) {
+            for (iChannel = 0; iChannel < pDescriptorPlayback->channels; ++iChannel) {
+                pDescriptorPlayback->channelMap[iChannel] = ma_channel_position_from_pulse(cmap.map[iChannel]);
+            }
+        } else {
+            /* Hack for mono and stereo. */
+            if (pDescriptorPlayback->channels == 1) {
+                pDescriptorPlayback->channelMap[0] = MA_CHANNEL_MONO;
+            } else if (pDescriptorPlayback->channels == 2) {
+                pDescriptorPlayback->channelMap[0] = MA_CHANNEL_FRONT_LEFT;
+                pDescriptorPlayback->channelMap[1] = MA_CHANNEL_FRONT_RIGHT;
+            } else {
+                MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+            }
+        }
+
+
+        /* Buffer. */
+        pActualAttr = ((ma_pa_stream_get_buffer_attr_proc)pDevice->pContext->pulse.pa_stream_get_buffer_attr)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+        if (pActualAttr != NULL) {
+            attr = *pActualAttr;
+        }
+
+        if (attr.tlength > 0) {
+            pDescriptorPlayback->periodCount = ma_max(attr.maxlength / attr.tlength, 1);
+        } else {
+            pDescriptorPlayback->periodCount = 1;
+        }
+
+        pDescriptorPlayback->periodSizeInFrames = attr.maxlength / ma_get_bytes_per_frame(pDescriptorPlayback->format, pDescriptorPlayback->channels) / pDescriptorPlayback->periodCount;
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Playback actual attr: maxlength=%d, tlength=%d, prebuf=%d, minreq=%d, fragsize=%d; internalPeriodSizeInFrames=%d\n", attr.maxlength, attr.tlength, attr.prebuf, attr.minreq, attr.fragsize, pDescriptorPlayback->periodSizeInFrames);
+    }
+
+
+    /*
+    We need a ring buffer for handling duplex mode. We can use the main duplex ring buffer in the main
+    part of the ma_device struct. We cannot, however, depend on ma_device_init() initializing this for
+    us later on because that will only do it if it's a fully asynchronous backend - i.e. the
+    onDeviceDataLoop callback is NULL, which is not the case for PulseAudio.
+    */
+    if (pConfig->deviceType == ma_device_type_duplex) {
+        ma_format rbFormat     = (format != ma_format_unknown) ? format     : pDescriptorCapture->format;
+        ma_uint32 rbChannels   = (channels   > 0)              ? channels   : pDescriptorCapture->channels;
+        ma_uint32 rbSampleRate = (sampleRate > 0)              ? sampleRate : pDescriptorCapture->sampleRate;
+
+        result = ma_duplex_rb_init(rbFormat, rbChannels, rbSampleRate, pDescriptorCapture->sampleRate, pDescriptorCapture->periodSizeInFrames, &pDevice->pContext->allocationCallbacks, &pDevice->duplexRB);
+        if (result != MA_SUCCESS) {
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to initialize ring buffer. %s.\n", ma_result_description(result));
+            goto on_error4;
+        }
+    }
+
+    return MA_SUCCESS;
+
+
+on_error4:
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ((ma_pa_stream_disconnect_proc)pDevice->pContext->pulse.pa_stream_disconnect)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+    }
+on_error3:
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ((ma_pa_stream_unref_proc)pDevice->pContext->pulse.pa_stream_unref)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+    }
+on_error2:
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ((ma_pa_stream_disconnect_proc)pDevice->pContext->pulse.pa_stream_disconnect)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+    }
+on_error1:
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ((ma_pa_stream_unref_proc)pDevice->pContext->pulse.pa_stream_unref)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+    }
+on_error0:
+    return result;
+}
+
+
+static void ma_pulse_operation_complete_callback(ma_pa_stream* pStream, int success, void* pUserData)
+{
+    ma_bool32* pIsSuccessful = (ma_bool32*)pUserData;
+    MA_ASSERT(pIsSuccessful != NULL);
+
+    *pIsSuccessful = (ma_bool32)success;
+
+    (void)pStream; /* Unused. */
+}
+
+static ma_result ma_device__cork_stream__pulse(ma_device* pDevice, ma_device_type deviceType, int cork)
+{
+    ma_context* pContext = pDevice->pContext;
+    ma_bool32 wasSuccessful;
+    ma_pa_stream* pStream;
+    ma_pa_operation* pOP;
+    ma_result result;
+
+    /* This should not be called with a duplex device type. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    wasSuccessful = MA_FALSE;
+
+    pStream = (ma_pa_stream*)((deviceType == ma_device_type_capture) ? pDevice->pulse.pStreamCapture : pDevice->pulse.pStreamPlayback);
+    MA_ASSERT(pStream != NULL);
+
+    pOP = ((ma_pa_stream_cork_proc)pContext->pulse.pa_stream_cork)(pStream, cork, ma_pulse_operation_complete_callback, &wasSuccessful);
+    if (pOP == NULL) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to cork PulseAudio stream.");
+        return MA_ERROR;
+    }
+
+    result = ma_wait_for_operation_and_unref__pulse(pDevice->pContext, pDevice->pulse.pMainLoop, pOP);
+    if (result != MA_SUCCESS) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] An error occurred while waiting for the PulseAudio stream to cork.");
+        return result;
+    }
+
+    if (!wasSuccessful) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[PulseAudio] Failed to %s PulseAudio stream.", (cork) ? "stop" : "start");
+        return MA_ERROR;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__pulse(ma_device* pDevice)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        result = ma_device__cork_stream__pulse(pDevice, ma_device_type_capture, 0);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /*
+        We need to fill some data before uncorking. Not doing this will result in the write callback
+        never getting fired. We're not going to abort if writing fails because I still want the device
+        to get uncorked.
+        */
+        ma_device_write_to_stream__pulse(pDevice, (ma_pa_stream*)(pDevice->pulse.pStreamPlayback), NULL);   /* No need to check the result here. Always want to fall through an uncork.*/
+
+        result = ma_device__cork_stream__pulse(pDevice, ma_device_type_playback, 0);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__pulse(ma_device* pDevice)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        result = ma_device__cork_stream__pulse(pDevice, ma_device_type_capture, 1);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        /*
+        Ideally we would drain the device here, but there's been cases where PulseAudio seems to be
+        broken on some systems to the point where no audio processing seems to happen. When this
+        happens, draining never completes and we get stuck here. For now I'm disabling draining of
+        the device so we don't just freeze the application.
+        */
+    #if 0
+        ma_pa_operation* pOP = ((ma_pa_stream_drain_proc)pDevice->pContext->pulse.pa_stream_drain)((ma_pa_stream*)pDevice->pulse.pStreamPlayback, ma_pulse_operation_complete_callback, &wasSuccessful);
+        ma_wait_for_operation_and_unref__pulse(pDevice->pContext, pDevice->pulse.pMainLoop, pOP);
+    #endif
+
+        result = ma_device__cork_stream__pulse(pDevice, ma_device_type_playback, 1);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_data_loop__pulse(ma_device* pDevice)
+{
+    int resultPA;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* NOTE: Don't start the device here. It'll be done at a higher level. */
+
+    /*
+    All data is handled through callbacks. All we need to do is iterate over the main loop and let
+    the callbacks deal with it.
+    */
+    while (ma_device_get_state(pDevice) == ma_device_state_started) {
+        resultPA = ((ma_pa_mainloop_iterate_proc)pDevice->pContext->pulse.pa_mainloop_iterate)((ma_pa_mainloop*)pDevice->pulse.pMainLoop, 1, NULL);
+        if (resultPA < 0) {
+            break;
+        }
+    }
+
+    /* NOTE: Don't stop the device here. It'll be done at a higher level. */
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_data_loop_wakeup__pulse(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    ((ma_pa_mainloop_wakeup_proc)pDevice->pContext->pulse.pa_mainloop_wakeup)((ma_pa_mainloop*)pDevice->pulse.pMainLoop);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__pulse(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_pulseaudio);
+
+    ((ma_pa_context_disconnect_proc)pContext->pulse.pa_context_disconnect)((ma_pa_context*)pContext->pulse.pPulseContext);
+    ((ma_pa_context_unref_proc)pContext->pulse.pa_context_unref)((ma_pa_context*)pContext->pulse.pPulseContext);
+    ((ma_pa_mainloop_free_proc)pContext->pulse.pa_mainloop_free)((ma_pa_mainloop*)pContext->pulse.pMainLoop);
+
+    ma_free(pContext->pulse.pServerName, &pContext->allocationCallbacks);
+    ma_free(pContext->pulse.pApplicationName, &pContext->allocationCallbacks);
+
+#ifndef MA_NO_RUNTIME_LINKING
+    ma_dlclose(ma_context_get_log(pContext), pContext->pulse.pulseSO);
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__pulse(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    ma_result result;
+#ifndef MA_NO_RUNTIME_LINKING
+    const char* libpulseNames[] = {
+        "libpulse.so",
+        "libpulse.so.0"
+    };
+    size_t i;
+
+    for (i = 0; i < ma_countof(libpulseNames); ++i) {
+        pContext->pulse.pulseSO = ma_dlopen(ma_context_get_log(pContext), libpulseNames[i]);
+        if (pContext->pulse.pulseSO != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->pulse.pulseSO == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    pContext->pulse.pa_mainloop_new                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_new");
+    pContext->pulse.pa_mainloop_free                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_free");
+    pContext->pulse.pa_mainloop_quit                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_quit");
+    pContext->pulse.pa_mainloop_get_api                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_get_api");
+    pContext->pulse.pa_mainloop_iterate                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_iterate");
+    pContext->pulse.pa_mainloop_wakeup                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_mainloop_wakeup");
+    pContext->pulse.pa_threaded_mainloop_new           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_new");
+    pContext->pulse.pa_threaded_mainloop_free          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_free");
+    pContext->pulse.pa_threaded_mainloop_start         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_start");
+    pContext->pulse.pa_threaded_mainloop_stop          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_stop");
+    pContext->pulse.pa_threaded_mainloop_lock          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_lock");
+    pContext->pulse.pa_threaded_mainloop_unlock        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_unlock");
+    pContext->pulse.pa_threaded_mainloop_wait          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_wait");
+    pContext->pulse.pa_threaded_mainloop_signal        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_signal");
+    pContext->pulse.pa_threaded_mainloop_accept        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_accept");
+    pContext->pulse.pa_threaded_mainloop_get_retval    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_get_retval");
+    pContext->pulse.pa_threaded_mainloop_get_api       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_get_api");
+    pContext->pulse.pa_threaded_mainloop_in_thread     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_in_thread");
+    pContext->pulse.pa_threaded_mainloop_set_name      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_threaded_mainloop_set_name");
+    pContext->pulse.pa_context_new                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_new");
+    pContext->pulse.pa_context_unref                   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_unref");
+    pContext->pulse.pa_context_connect                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_connect");
+    pContext->pulse.pa_context_disconnect              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_disconnect");
+    pContext->pulse.pa_context_set_state_callback      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_set_state_callback");
+    pContext->pulse.pa_context_get_state               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_state");
+    pContext->pulse.pa_context_get_sink_info_list      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_sink_info_list");
+    pContext->pulse.pa_context_get_source_info_list    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_source_info_list");
+    pContext->pulse.pa_context_get_sink_info_by_name   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_sink_info_by_name");
+    pContext->pulse.pa_context_get_source_info_by_name = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_context_get_source_info_by_name");
+    pContext->pulse.pa_operation_unref                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_operation_unref");
+    pContext->pulse.pa_operation_get_state             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_operation_get_state");
+    pContext->pulse.pa_channel_map_init_extend         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_channel_map_init_extend");
+    pContext->pulse.pa_channel_map_valid               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_channel_map_valid");
+    pContext->pulse.pa_channel_map_compatible          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_channel_map_compatible");
+    pContext->pulse.pa_stream_new                      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_new");
+    pContext->pulse.pa_stream_unref                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_unref");
+    pContext->pulse.pa_stream_connect_playback         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_connect_playback");
+    pContext->pulse.pa_stream_connect_record           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_connect_record");
+    pContext->pulse.pa_stream_disconnect               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_disconnect");
+    pContext->pulse.pa_stream_get_state                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_state");
+    pContext->pulse.pa_stream_get_sample_spec          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_sample_spec");
+    pContext->pulse.pa_stream_get_channel_map          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_channel_map");
+    pContext->pulse.pa_stream_get_buffer_attr          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_buffer_attr");
+    pContext->pulse.pa_stream_set_buffer_attr          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_buffer_attr");
+    pContext->pulse.pa_stream_get_device_name          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_get_device_name");
+    pContext->pulse.pa_stream_set_write_callback       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_write_callback");
+    pContext->pulse.pa_stream_set_read_callback        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_read_callback");
+    pContext->pulse.pa_stream_set_suspended_callback   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_suspended_callback");
+    pContext->pulse.pa_stream_set_moved_callback       = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_set_moved_callback");
+    pContext->pulse.pa_stream_is_suspended             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_is_suspended");
+    pContext->pulse.pa_stream_flush                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_flush");
+    pContext->pulse.pa_stream_drain                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_drain");
+    pContext->pulse.pa_stream_is_corked                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_is_corked");
+    pContext->pulse.pa_stream_cork                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_cork");
+    pContext->pulse.pa_stream_trigger                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_trigger");
+    pContext->pulse.pa_stream_begin_write              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_begin_write");
+    pContext->pulse.pa_stream_write                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_write");
+    pContext->pulse.pa_stream_peek                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_peek");
+    pContext->pulse.pa_stream_drop                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_drop");
+    pContext->pulse.pa_stream_writable_size            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_writable_size");
+    pContext->pulse.pa_stream_readable_size            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->pulse.pulseSO, "pa_stream_readable_size");
+#else
+    /* This strange assignment system is just for type safety. */
+    ma_pa_mainloop_new_proc                    _pa_mainloop_new                   = pa_mainloop_new;
+    ma_pa_mainloop_free_proc                   _pa_mainloop_free                  = pa_mainloop_free;
+    ma_pa_mainloop_quit_proc                   _pa_mainloop_quit                  = pa_mainloop_quit;
+    ma_pa_mainloop_get_api_proc                _pa_mainloop_get_api               = pa_mainloop_get_api;
+    ma_pa_mainloop_iterate_proc                _pa_mainloop_iterate               = pa_mainloop_iterate;
+    ma_pa_mainloop_wakeup_proc                 _pa_mainloop_wakeup                = pa_mainloop_wakeup;
+    ma_pa_threaded_mainloop_new_proc           _pa_threaded_mainloop_new          = pa_threaded_mainloop_new;
+    ma_pa_threaded_mainloop_free_proc          _pa_threaded_mainloop_free         = pa_threaded_mainloop_free;
+    ma_pa_threaded_mainloop_start_proc         _pa_threaded_mainloop_start        = pa_threaded_mainloop_start;
+    ma_pa_threaded_mainloop_stop_proc          _pa_threaded_mainloop_stop         = pa_threaded_mainloop_stop;
+    ma_pa_threaded_mainloop_lock_proc          _pa_threaded_mainloop_lock         = pa_threaded_mainloop_lock;
+    ma_pa_threaded_mainloop_unlock_proc        _pa_threaded_mainloop_unlock       = pa_threaded_mainloop_unlock;
+    ma_pa_threaded_mainloop_wait_proc          _pa_threaded_mainloop_wait         = pa_threaded_mainloop_wait;
+    ma_pa_threaded_mainloop_signal_proc        _pa_threaded_mainloop_signal       = pa_threaded_mainloop_signal;
+    ma_pa_threaded_mainloop_accept_proc        _pa_threaded_mainloop_accept       = pa_threaded_mainloop_accept;
+    ma_pa_threaded_mainloop_get_retval_proc    _pa_threaded_mainloop_get_retval   = pa_threaded_mainloop_get_retval;
+    ma_pa_threaded_mainloop_get_api_proc       _pa_threaded_mainloop_get_api      = pa_threaded_mainloop_get_api;
+    ma_pa_threaded_mainloop_in_thread_proc     _pa_threaded_mainloop_in_thread    = pa_threaded_mainloop_in_thread;
+    ma_pa_threaded_mainloop_set_name_proc      _pa_threaded_mainloop_set_name     = pa_threaded_mainloop_set_name;
+    ma_pa_context_new_proc                     _pa_context_new                    = pa_context_new;
+    ma_pa_context_unref_proc                   _pa_context_unref                  = pa_context_unref;
+    ma_pa_context_connect_proc                 _pa_context_connect                = pa_context_connect;
+    ma_pa_context_disconnect_proc              _pa_context_disconnect             = pa_context_disconnect;
+    ma_pa_context_set_state_callback_proc      _pa_context_set_state_callback     = pa_context_set_state_callback;
+    ma_pa_context_get_state_proc               _pa_context_get_state              = pa_context_get_state;
+    ma_pa_context_get_sink_info_list_proc      _pa_context_get_sink_info_list     = pa_context_get_sink_info_list;
+    ma_pa_context_get_source_info_list_proc    _pa_context_get_source_info_list   = pa_context_get_source_info_list;
+    ma_pa_context_get_sink_info_by_name_proc   _pa_context_get_sink_info_by_name  = pa_context_get_sink_info_by_name;
+    ma_pa_context_get_source_info_by_name_proc _pa_context_get_source_info_by_name= pa_context_get_source_info_by_name;
+    ma_pa_operation_unref_proc                 _pa_operation_unref                = pa_operation_unref;
+    ma_pa_operation_get_state_proc             _pa_operation_get_state            = pa_operation_get_state;
+    ma_pa_channel_map_init_extend_proc         _pa_channel_map_init_extend        = pa_channel_map_init_extend;
+    ma_pa_channel_map_valid_proc               _pa_channel_map_valid              = pa_channel_map_valid;
+    ma_pa_channel_map_compatible_proc          _pa_channel_map_compatible         = pa_channel_map_compatible;
+    ma_pa_stream_new_proc                      _pa_stream_new                     = pa_stream_new;
+    ma_pa_stream_unref_proc                    _pa_stream_unref                   = pa_stream_unref;
+    ma_pa_stream_connect_playback_proc         _pa_stream_connect_playback        = pa_stream_connect_playback;
+    ma_pa_stream_connect_record_proc           _pa_stream_connect_record          = pa_stream_connect_record;
+    ma_pa_stream_disconnect_proc               _pa_stream_disconnect              = pa_stream_disconnect;
+    ma_pa_stream_get_state_proc                _pa_stream_get_state               = pa_stream_get_state;
+    ma_pa_stream_get_sample_spec_proc          _pa_stream_get_sample_spec         = pa_stream_get_sample_spec;
+    ma_pa_stream_get_channel_map_proc          _pa_stream_get_channel_map         = pa_stream_get_channel_map;
+    ma_pa_stream_get_buffer_attr_proc          _pa_stream_get_buffer_attr         = pa_stream_get_buffer_attr;
+    ma_pa_stream_set_buffer_attr_proc          _pa_stream_set_buffer_attr         = pa_stream_set_buffer_attr;
+    ma_pa_stream_get_device_name_proc          _pa_stream_get_device_name         = pa_stream_get_device_name;
+    ma_pa_stream_set_write_callback_proc       _pa_stream_set_write_callback      = pa_stream_set_write_callback;
+    ma_pa_stream_set_read_callback_proc        _pa_stream_set_read_callback       = pa_stream_set_read_callback;
+    ma_pa_stream_set_suspended_callback_proc   _pa_stream_set_suspended_callback  = pa_stream_set_suspended_callback;
+    ma_pa_stream_set_moved_callback_proc       _pa_stream_set_moved_callback      = pa_stream_set_moved_callback;
+    ma_pa_stream_is_suspended_proc             _pa_stream_is_suspended            = pa_stream_is_suspended;
+    ma_pa_stream_flush_proc                    _pa_stream_flush                   = pa_stream_flush;
+    ma_pa_stream_drain_proc                    _pa_stream_drain                   = pa_stream_drain;
+    ma_pa_stream_is_corked_proc                _pa_stream_is_corked               = pa_stream_is_corked;
+    ma_pa_stream_cork_proc                     _pa_stream_cork                    = pa_stream_cork;
+    ma_pa_stream_trigger_proc                  _pa_stream_trigger                 = pa_stream_trigger;
+    ma_pa_stream_begin_write_proc              _pa_stream_begin_write             = pa_stream_begin_write;
+    ma_pa_stream_write_proc                    _pa_stream_write                   = pa_stream_write;
+    ma_pa_stream_peek_proc                     _pa_stream_peek                    = pa_stream_peek;
+    ma_pa_stream_drop_proc                     _pa_stream_drop                    = pa_stream_drop;
+    ma_pa_stream_writable_size_proc            _pa_stream_writable_size           = pa_stream_writable_size;
+    ma_pa_stream_readable_size_proc            _pa_stream_readable_size           = pa_stream_readable_size;
+
+    pContext->pulse.pa_mainloop_new                    = (ma_proc)_pa_mainloop_new;
+    pContext->pulse.pa_mainloop_free                   = (ma_proc)_pa_mainloop_free;
+    pContext->pulse.pa_mainloop_quit                   = (ma_proc)_pa_mainloop_quit;
+    pContext->pulse.pa_mainloop_get_api                = (ma_proc)_pa_mainloop_get_api;
+    pContext->pulse.pa_mainloop_iterate                = (ma_proc)_pa_mainloop_iterate;
+    pContext->pulse.pa_mainloop_wakeup                 = (ma_proc)_pa_mainloop_wakeup;
+    pContext->pulse.pa_threaded_mainloop_new           = (ma_proc)_pa_threaded_mainloop_new;
+    pContext->pulse.pa_threaded_mainloop_free          = (ma_proc)_pa_threaded_mainloop_free;
+    pContext->pulse.pa_threaded_mainloop_start         = (ma_proc)_pa_threaded_mainloop_start;
+    pContext->pulse.pa_threaded_mainloop_stop          = (ma_proc)_pa_threaded_mainloop_stop;
+    pContext->pulse.pa_threaded_mainloop_lock          = (ma_proc)_pa_threaded_mainloop_lock;
+    pContext->pulse.pa_threaded_mainloop_unlock        = (ma_proc)_pa_threaded_mainloop_unlock;
+    pContext->pulse.pa_threaded_mainloop_wait          = (ma_proc)_pa_threaded_mainloop_wait;
+    pContext->pulse.pa_threaded_mainloop_signal        = (ma_proc)_pa_threaded_mainloop_signal;
+    pContext->pulse.pa_threaded_mainloop_accept        = (ma_proc)_pa_threaded_mainloop_accept;
+    pContext->pulse.pa_threaded_mainloop_get_retval    = (ma_proc)_pa_threaded_mainloop_get_retval;
+    pContext->pulse.pa_threaded_mainloop_get_api       = (ma_proc)_pa_threaded_mainloop_get_api;
+    pContext->pulse.pa_threaded_mainloop_in_thread     = (ma_proc)_pa_threaded_mainloop_in_thread;
+    pContext->pulse.pa_threaded_mainloop_set_name      = (ma_proc)_pa_threaded_mainloop_set_name;
+    pContext->pulse.pa_context_new                     = (ma_proc)_pa_context_new;
+    pContext->pulse.pa_context_unref                   = (ma_proc)_pa_context_unref;
+    pContext->pulse.pa_context_connect                 = (ma_proc)_pa_context_connect;
+    pContext->pulse.pa_context_disconnect              = (ma_proc)_pa_context_disconnect;
+    pContext->pulse.pa_context_set_state_callback      = (ma_proc)_pa_context_set_state_callback;
+    pContext->pulse.pa_context_get_state               = (ma_proc)_pa_context_get_state;
+    pContext->pulse.pa_context_get_sink_info_list      = (ma_proc)_pa_context_get_sink_info_list;
+    pContext->pulse.pa_context_get_source_info_list    = (ma_proc)_pa_context_get_source_info_list;
+    pContext->pulse.pa_context_get_sink_info_by_name   = (ma_proc)_pa_context_get_sink_info_by_name;
+    pContext->pulse.pa_context_get_source_info_by_name = (ma_proc)_pa_context_get_source_info_by_name;
+    pContext->pulse.pa_operation_unref                 = (ma_proc)_pa_operation_unref;
+    pContext->pulse.pa_operation_get_state             = (ma_proc)_pa_operation_get_state;
+    pContext->pulse.pa_channel_map_init_extend         = (ma_proc)_pa_channel_map_init_extend;
+    pContext->pulse.pa_channel_map_valid               = (ma_proc)_pa_channel_map_valid;
+    pContext->pulse.pa_channel_map_compatible          = (ma_proc)_pa_channel_map_compatible;
+    pContext->pulse.pa_stream_new                      = (ma_proc)_pa_stream_new;
+    pContext->pulse.pa_stream_unref                    = (ma_proc)_pa_stream_unref;
+    pContext->pulse.pa_stream_connect_playback         = (ma_proc)_pa_stream_connect_playback;
+    pContext->pulse.pa_stream_connect_record           = (ma_proc)_pa_stream_connect_record;
+    pContext->pulse.pa_stream_disconnect               = (ma_proc)_pa_stream_disconnect;
+    pContext->pulse.pa_stream_get_state                = (ma_proc)_pa_stream_get_state;
+    pContext->pulse.pa_stream_get_sample_spec          = (ma_proc)_pa_stream_get_sample_spec;
+    pContext->pulse.pa_stream_get_channel_map          = (ma_proc)_pa_stream_get_channel_map;
+    pContext->pulse.pa_stream_get_buffer_attr          = (ma_proc)_pa_stream_get_buffer_attr;
+    pContext->pulse.pa_stream_set_buffer_attr          = (ma_proc)_pa_stream_set_buffer_attr;
+    pContext->pulse.pa_stream_get_device_name          = (ma_proc)_pa_stream_get_device_name;
+    pContext->pulse.pa_stream_set_write_callback       = (ma_proc)_pa_stream_set_write_callback;
+    pContext->pulse.pa_stream_set_read_callback        = (ma_proc)_pa_stream_set_read_callback;
+    pContext->pulse.pa_stream_set_suspended_callback   = (ma_proc)_pa_stream_set_suspended_callback;
+    pContext->pulse.pa_stream_set_moved_callback       = (ma_proc)_pa_stream_set_moved_callback;
+    pContext->pulse.pa_stream_is_suspended             = (ma_proc)_pa_stream_is_suspended;
+    pContext->pulse.pa_stream_flush                    = (ma_proc)_pa_stream_flush;
+    pContext->pulse.pa_stream_drain                    = (ma_proc)_pa_stream_drain;
+    pContext->pulse.pa_stream_is_corked                = (ma_proc)_pa_stream_is_corked;
+    pContext->pulse.pa_stream_cork                     = (ma_proc)_pa_stream_cork;
+    pContext->pulse.pa_stream_trigger                  = (ma_proc)_pa_stream_trigger;
+    pContext->pulse.pa_stream_begin_write              = (ma_proc)_pa_stream_begin_write;
+    pContext->pulse.pa_stream_write                    = (ma_proc)_pa_stream_write;
+    pContext->pulse.pa_stream_peek                     = (ma_proc)_pa_stream_peek;
+    pContext->pulse.pa_stream_drop                     = (ma_proc)_pa_stream_drop;
+    pContext->pulse.pa_stream_writable_size            = (ma_proc)_pa_stream_writable_size;
+    pContext->pulse.pa_stream_readable_size            = (ma_proc)_pa_stream_readable_size;
+#endif
+
+    /* We need to make a copy of the application and server names so we can pass them to the pa_context of each device. */
+    pContext->pulse.pApplicationName = ma_copy_string(pConfig->pulse.pApplicationName, &pContext->allocationCallbacks);
+    if (pContext->pulse.pApplicationName == NULL && pConfig->pulse.pApplicationName != NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    pContext->pulse.pServerName = ma_copy_string(pConfig->pulse.pServerName, &pContext->allocationCallbacks);
+    if (pContext->pulse.pServerName == NULL && pConfig->pulse.pServerName != NULL) {
+        ma_free(pContext->pulse.pApplicationName, &pContext->allocationCallbacks);
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_init_pa_mainloop_and_pa_context__pulse(pContext, pConfig->pulse.pApplicationName, pConfig->pulse.pServerName, pConfig->pulse.tryAutoSpawn, &pContext->pulse.pMainLoop, &pContext->pulse.pPulseContext);
+    if (result != MA_SUCCESS) {
+        ma_free(pContext->pulse.pServerName, &pContext->allocationCallbacks);
+        ma_free(pContext->pulse.pApplicationName, &pContext->allocationCallbacks);
+    #ifndef MA_NO_RUNTIME_LINKING
+        ma_dlclose(ma_context_get_log(pContext), pContext->pulse.pulseSO);
+    #endif
+        return result;
+    }
+
+    /* With pa_mainloop we run a synchronous backend, but we implement our own main loop. */
+    pCallbacks->onContextInit             = ma_context_init__pulse;
+    pCallbacks->onContextUninit           = ma_context_uninit__pulse;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__pulse;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__pulse;
+    pCallbacks->onDeviceInit              = ma_device_init__pulse;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__pulse;
+    pCallbacks->onDeviceStart             = ma_device_start__pulse;
+    pCallbacks->onDeviceStop              = ma_device_stop__pulse;
+    pCallbacks->onDeviceRead              = NULL;   /* Not used because we're implementing onDeviceDataLoop. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not used because we're implementing onDeviceDataLoop. */
+    pCallbacks->onDeviceDataLoop          = ma_device_data_loop__pulse;
+    pCallbacks->onDeviceDataLoopWakeup    = ma_device_data_loop_wakeup__pulse;
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+/******************************************************************************
+
+JACK Backend
+
+******************************************************************************/
+#ifdef MA_HAS_JACK
+
+/* It is assumed jack.h is available when compile-time linking is being used. */
+#ifdef MA_NO_RUNTIME_LINKING
+#include <jack/jack.h>
+
+typedef jack_nframes_t              ma_jack_nframes_t;
+typedef jack_options_t              ma_jack_options_t;
+typedef jack_status_t               ma_jack_status_t;
+typedef jack_client_t               ma_jack_client_t;
+typedef jack_port_t                 ma_jack_port_t;
+typedef JackProcessCallback         ma_JackProcessCallback;
+typedef JackBufferSizeCallback      ma_JackBufferSizeCallback;
+typedef JackShutdownCallback        ma_JackShutdownCallback;
+#define MA_JACK_DEFAULT_AUDIO_TYPE  JACK_DEFAULT_AUDIO_TYPE
+#define ma_JackNoStartServer        JackNoStartServer
+#define ma_JackPortIsInput          JackPortIsInput
+#define ma_JackPortIsOutput         JackPortIsOutput
+#define ma_JackPortIsPhysical       JackPortIsPhysical
+#else
+typedef ma_uint32               ma_jack_nframes_t;
+typedef int                     ma_jack_options_t;
+typedef int                     ma_jack_status_t;
+typedef struct ma_jack_client_t ma_jack_client_t;
+typedef struct ma_jack_port_t   ma_jack_port_t;
+typedef int  (* ma_JackProcessCallback)   (ma_jack_nframes_t nframes, void* arg);
+typedef int  (* ma_JackBufferSizeCallback)(ma_jack_nframes_t nframes, void* arg);
+typedef void (* ma_JackShutdownCallback)  (void* arg);
+#define MA_JACK_DEFAULT_AUDIO_TYPE "32 bit float mono audio"
+#define ma_JackNoStartServer       1
+#define ma_JackPortIsInput         1
+#define ma_JackPortIsOutput        2
+#define ma_JackPortIsPhysical      4
+#endif
+
+typedef ma_jack_client_t* (* ma_jack_client_open_proc)             (const char* client_name, ma_jack_options_t options, ma_jack_status_t* status, ...);
+typedef int               (* ma_jack_client_close_proc)            (ma_jack_client_t* client);
+typedef int               (* ma_jack_client_name_size_proc)        (void);
+typedef int               (* ma_jack_set_process_callback_proc)    (ma_jack_client_t* client, ma_JackProcessCallback process_callback, void* arg);
+typedef int               (* ma_jack_set_buffer_size_callback_proc)(ma_jack_client_t* client, ma_JackBufferSizeCallback bufsize_callback, void* arg);
+typedef void              (* ma_jack_on_shutdown_proc)             (ma_jack_client_t* client, ma_JackShutdownCallback function, void* arg);
+typedef ma_jack_nframes_t (* ma_jack_get_sample_rate_proc)         (ma_jack_client_t* client);
+typedef ma_jack_nframes_t (* ma_jack_get_buffer_size_proc)         (ma_jack_client_t* client);
+typedef const char**      (* ma_jack_get_ports_proc)               (ma_jack_client_t* client, const char* port_name_pattern, const char* type_name_pattern, unsigned long flags);
+typedef int               (* ma_jack_activate_proc)                (ma_jack_client_t* client);
+typedef int               (* ma_jack_deactivate_proc)              (ma_jack_client_t* client);
+typedef int               (* ma_jack_connect_proc)                 (ma_jack_client_t* client, const char* source_port, const char* destination_port);
+typedef ma_jack_port_t*   (* ma_jack_port_register_proc)           (ma_jack_client_t* client, const char* port_name, const char* port_type, unsigned long flags, unsigned long buffer_size);
+typedef const char*       (* ma_jack_port_name_proc)               (const ma_jack_port_t* port);
+typedef void*             (* ma_jack_port_get_buffer_proc)         (ma_jack_port_t* port, ma_jack_nframes_t nframes);
+typedef void              (* ma_jack_free_proc)                    (void* ptr);
+
+static ma_result ma_context_open_client__jack(ma_context* pContext, ma_jack_client_t** ppClient)
+{
+    size_t maxClientNameSize;
+    char clientName[256];
+    ma_jack_status_t status;
+    ma_jack_client_t* pClient;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppClient != NULL);
+
+    if (ppClient) {
+        *ppClient = NULL;
+    }
+
+    maxClientNameSize = ((ma_jack_client_name_size_proc)pContext->jack.jack_client_name_size)(); /* Includes null terminator. */
+    ma_strncpy_s(clientName, ma_min(sizeof(clientName), maxClientNameSize), (pContext->jack.pClientName != NULL) ? pContext->jack.pClientName : "miniaudio", (size_t)-1);
+
+    pClient = ((ma_jack_client_open_proc)pContext->jack.jack_client_open)(clientName, (pContext->jack.tryStartServer) ? 0 : ma_JackNoStartServer, &status, NULL);
+    if (pClient == NULL) {
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+
+    if (ppClient) {
+        *ppClient = pClient;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_enumerate_devices__jack(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 cbResult = MA_TRUE;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Playback. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+        deviceInfo.isDefault = MA_TRUE;    /* JACK only uses default devices. */
+        cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+        deviceInfo.isDefault = MA_TRUE;    /* JACK only uses default devices. */
+        cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+    }
+
+    (void)cbResult; /* For silencing a static analysis warning. */
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__jack(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_jack_client_t* pClient;
+    ma_result result;
+    const char** ppPorts;
+
+    MA_ASSERT(pContext != NULL);
+
+    if (pDeviceID != NULL && pDeviceID->jack != 0) {
+        return MA_NO_DEVICE;   /* Don't know the device. */
+    }
+
+    /* Name / Description */
+    if (deviceType == ma_device_type_playback) {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+    /* Jack only uses default devices. */
+    pDeviceInfo->isDefault = MA_TRUE;
+
+    /* Jack only supports f32 and has a specific channel count and sample rate. */
+    pDeviceInfo->nativeDataFormats[0].format = ma_format_f32;
+
+    /* The channel count and sample rate can only be determined by opening the device. */
+    result = ma_context_open_client__jack(pContext, &pClient);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[JACK] Failed to open client.");
+        return result;
+    }
+
+    pDeviceInfo->nativeDataFormats[0].sampleRate = ((ma_jack_get_sample_rate_proc)pContext->jack.jack_get_sample_rate)((ma_jack_client_t*)pClient);
+    pDeviceInfo->nativeDataFormats[0].channels   = 0;
+
+    ppPorts = ((ma_jack_get_ports_proc)pContext->jack.jack_get_ports)((ma_jack_client_t*)pClient, NULL, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsPhysical | ((deviceType == ma_device_type_playback) ? ma_JackPortIsInput : ma_JackPortIsOutput));
+    if (ppPorts == NULL) {
+        ((ma_jack_client_close_proc)pContext->jack.jack_client_close)((ma_jack_client_t*)pClient);
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[JACK] Failed to query physical ports.");
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+
+    while (ppPorts[pDeviceInfo->nativeDataFormats[0].channels] != NULL) {
+        pDeviceInfo->nativeDataFormats[0].channels += 1;
+    }
+
+    pDeviceInfo->nativeDataFormats[0].flags = 0;
+    pDeviceInfo->nativeDataFormatCount = 1;
+
+    ((ma_jack_free_proc)pContext->jack.jack_free)((void*)ppPorts);
+    ((ma_jack_client_close_proc)pContext->jack.jack_client_close)((ma_jack_client_t*)pClient);
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_uninit__jack(ma_device* pDevice)
+{
+    ma_context* pContext;
+
+    MA_ASSERT(pDevice != NULL);
+
+    pContext = pDevice->pContext;
+    MA_ASSERT(pContext != NULL);
+
+    if (pDevice->jack.pClient != NULL) {
+        ((ma_jack_client_close_proc)pContext->jack.jack_client_close)((ma_jack_client_t*)pDevice->jack.pClient);
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_free(pDevice->jack.pIntermediaryBufferCapture, &pDevice->pContext->allocationCallbacks);
+        ma_free(pDevice->jack.ppPortsCapture, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_free(pDevice->jack.pIntermediaryBufferPlayback, &pDevice->pContext->allocationCallbacks);
+        ma_free(pDevice->jack.ppPortsPlayback, &pDevice->pContext->allocationCallbacks);
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_device__jack_shutdown_callback(void* pUserData)
+{
+    /* JACK died. Stop the device. */
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    ma_device_stop(pDevice);
+}
+
+static int ma_device__jack_buffer_size_callback(ma_jack_nframes_t frameCount, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        size_t newBufferSize = frameCount * (pDevice->capture.internalChannels * ma_get_bytes_per_sample(pDevice->capture.internalFormat));
+        float* pNewBuffer = (float*)ma_calloc(newBufferSize, &pDevice->pContext->allocationCallbacks);
+        if (pNewBuffer == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        ma_free(pDevice->jack.pIntermediaryBufferCapture, &pDevice->pContext->allocationCallbacks);
+
+        pDevice->jack.pIntermediaryBufferCapture = pNewBuffer;
+        pDevice->playback.internalPeriodSizeInFrames = frameCount;
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        size_t newBufferSize = frameCount * (pDevice->playback.internalChannels * ma_get_bytes_per_sample(pDevice->playback.internalFormat));
+        float* pNewBuffer = (float*)ma_calloc(newBufferSize, &pDevice->pContext->allocationCallbacks);
+        if (pNewBuffer == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        ma_free(pDevice->jack.pIntermediaryBufferPlayback, &pDevice->pContext->allocationCallbacks);
+
+        pDevice->jack.pIntermediaryBufferPlayback = pNewBuffer;
+        pDevice->playback.internalPeriodSizeInFrames = frameCount;
+    }
+
+    return 0;
+}
+
+static int ma_device__jack_process_callback(ma_jack_nframes_t frameCount, void* pUserData)
+{
+    ma_device* pDevice;
+    ma_context* pContext;
+    ma_uint32 iChannel;
+
+    pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    pContext = pDevice->pContext;
+    MA_ASSERT(pContext != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        /* Channels need to be interleaved. */
+        for (iChannel = 0; iChannel < pDevice->capture.internalChannels; ++iChannel) {
+            const float* pSrc = (const float*)((ma_jack_port_get_buffer_proc)pContext->jack.jack_port_get_buffer)((ma_jack_port_t*)pDevice->jack.ppPortsCapture[iChannel], frameCount);
+            if (pSrc != NULL) {
+                float* pDst = pDevice->jack.pIntermediaryBufferCapture + iChannel;
+                ma_jack_nframes_t iFrame;
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    *pDst = *pSrc;
+
+                    pDst += pDevice->capture.internalChannels;
+                    pSrc += 1;
+                }
+            }
+        }
+
+        ma_device_handle_backend_data_callback(pDevice, NULL, pDevice->jack.pIntermediaryBufferCapture, frameCount);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_device_handle_backend_data_callback(pDevice, pDevice->jack.pIntermediaryBufferPlayback, NULL, frameCount);
+
+        /* Channels need to be deinterleaved. */
+        for (iChannel = 0; iChannel < pDevice->playback.internalChannels; ++iChannel) {
+            float* pDst = (float*)((ma_jack_port_get_buffer_proc)pContext->jack.jack_port_get_buffer)((ma_jack_port_t*)pDevice->jack.ppPortsPlayback[iChannel], frameCount);
+            if (pDst != NULL) {
+                const float* pSrc = pDevice->jack.pIntermediaryBufferPlayback + iChannel;
+                ma_jack_nframes_t iFrame;
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    *pDst = *pSrc;
+
+                    pDst += 1;
+                    pSrc += pDevice->playback.internalChannels;
+                }
+            }
+        }
+    }
+
+    return 0;
+}
+
+static ma_result ma_device_init__jack(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+    ma_uint32 periodSizeInFrames;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDevice != NULL);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Loopback mode not supported.");
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* Only supporting default devices with JACK. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->pDeviceID != NULL && pDescriptorPlayback->pDeviceID->jack != 0) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->pDeviceID  != NULL && pDescriptorCapture->pDeviceID->jack  != 0)) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Only default devices are supported.");
+        return MA_NO_DEVICE;
+    }
+
+    /* No exclusive mode with the JACK backend. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive)) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Exclusive mode not supported.");
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    /* Open the client. */
+    result = ma_context_open_client__jack(pDevice->pContext, (ma_jack_client_t**)&pDevice->jack.pClient);
+    if (result != MA_SUCCESS) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to open client.");
+        return result;
+    }
+
+    /* Callbacks. */
+    if (((ma_jack_set_process_callback_proc)pDevice->pContext->jack.jack_set_process_callback)((ma_jack_client_t*)pDevice->jack.pClient, ma_device__jack_process_callback, pDevice) != 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to set process callback.");
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+    if (((ma_jack_set_buffer_size_callback_proc)pDevice->pContext->jack.jack_set_buffer_size_callback)((ma_jack_client_t*)pDevice->jack.pClient, ma_device__jack_buffer_size_callback, pDevice) != 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to set buffer size callback.");
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+
+    ((ma_jack_on_shutdown_proc)pDevice->pContext->jack.jack_on_shutdown)((ma_jack_client_t*)pDevice->jack.pClient, ma_device__jack_shutdown_callback, pDevice);
+
+
+    /* The buffer size in frames can change. */
+    periodSizeInFrames = ((ma_jack_get_buffer_size_proc)pDevice->pContext->jack.jack_get_buffer_size)((ma_jack_client_t*)pDevice->jack.pClient);
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_uint32 iPort;
+        const char** ppPorts;
+
+        pDescriptorCapture->format     = ma_format_f32;
+        pDescriptorCapture->channels   = 0;
+        pDescriptorCapture->sampleRate = ((ma_jack_get_sample_rate_proc)pDevice->pContext->jack.jack_get_sample_rate)((ma_jack_client_t*)pDevice->jack.pClient);
+        ma_channel_map_init_standard(ma_standard_channel_map_alsa, pDescriptorCapture->channelMap, ma_countof(pDescriptorCapture->channelMap), pDescriptorCapture->channels);
+
+        ppPorts = ((ma_jack_get_ports_proc)pDevice->pContext->jack.jack_get_ports)((ma_jack_client_t*)pDevice->jack.pClient, NULL, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsPhysical | ma_JackPortIsOutput);
+        if (ppPorts == NULL) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to query physical ports.");
+            return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+        }
+
+        /* Need to count the number of ports first so we can allocate some memory. */
+        while (ppPorts[pDescriptorCapture->channels] != NULL) {
+            pDescriptorCapture->channels += 1;
+        }
+
+        pDevice->jack.ppPortsCapture = (ma_ptr*)ma_malloc(sizeof(*pDevice->jack.ppPortsCapture) * pDescriptorCapture->channels, &pDevice->pContext->allocationCallbacks);
+        if (pDevice->jack.ppPortsCapture == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        for (iPort = 0; iPort < pDescriptorCapture->channels; iPort += 1) {
+            char name[64];
+            ma_strcpy_s(name, sizeof(name), "capture");
+            ma_itoa_s((int)iPort, name+7, sizeof(name)-7, 10); /* 7 = length of "capture" */
+
+            pDevice->jack.ppPortsCapture[iPort] = ((ma_jack_port_register_proc)pDevice->pContext->jack.jack_port_register)((ma_jack_client_t*)pDevice->jack.pClient, name, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsInput, 0);
+            if (pDevice->jack.ppPortsCapture[iPort] == NULL) {
+                ((ma_jack_free_proc)pDevice->pContext->jack.jack_free)((void*)ppPorts);
+                ma_device_uninit__jack(pDevice);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to register ports.");
+                return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+            }
+        }
+
+        ((ma_jack_free_proc)pDevice->pContext->jack.jack_free)((void*)ppPorts);
+
+        pDescriptorCapture->periodSizeInFrames = periodSizeInFrames;
+        pDescriptorCapture->periodCount        = 1; /* There's no notion of a period in JACK. Just set to 1. */
+
+        pDevice->jack.pIntermediaryBufferCapture = (float*)ma_calloc(pDescriptorCapture->periodSizeInFrames * ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels), &pDevice->pContext->allocationCallbacks);
+        if (pDevice->jack.pIntermediaryBufferCapture == NULL) {
+            ma_device_uninit__jack(pDevice);
+            return MA_OUT_OF_MEMORY;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_uint32 iPort;
+        const char** ppPorts;
+
+        pDescriptorPlayback->format     = ma_format_f32;
+        pDescriptorPlayback->channels   = 0;
+        pDescriptorPlayback->sampleRate = ((ma_jack_get_sample_rate_proc)pDevice->pContext->jack.jack_get_sample_rate)((ma_jack_client_t*)pDevice->jack.pClient);
+        ma_channel_map_init_standard(ma_standard_channel_map_alsa, pDescriptorPlayback->channelMap, ma_countof(pDescriptorPlayback->channelMap), pDescriptorPlayback->channels);
+
+        ppPorts = ((ma_jack_get_ports_proc)pDevice->pContext->jack.jack_get_ports)((ma_jack_client_t*)pDevice->jack.pClient, NULL, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsPhysical | ma_JackPortIsInput);
+        if (ppPorts == NULL) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to query physical ports.");
+            return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+        }
+
+        /* Need to count the number of ports first so we can allocate some memory. */
+        while (ppPorts[pDescriptorPlayback->channels] != NULL) {
+            pDescriptorPlayback->channels += 1;
+        }
+
+        pDevice->jack.ppPortsPlayback = (ma_ptr*)ma_malloc(sizeof(*pDevice->jack.ppPortsPlayback) * pDescriptorPlayback->channels, &pDevice->pContext->allocationCallbacks);
+        if (pDevice->jack.ppPortsPlayback == NULL) {
+            ma_free(pDevice->jack.ppPortsCapture, &pDevice->pContext->allocationCallbacks);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        for (iPort = 0; iPort < pDescriptorPlayback->channels; iPort += 1) {
+            char name[64];
+            ma_strcpy_s(name, sizeof(name), "playback");
+            ma_itoa_s((int)iPort, name+8, sizeof(name)-8, 10); /* 8 = length of "playback" */
+
+            pDevice->jack.ppPortsPlayback[iPort] = ((ma_jack_port_register_proc)pDevice->pContext->jack.jack_port_register)((ma_jack_client_t*)pDevice->jack.pClient, name, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsOutput, 0);
+            if (pDevice->jack.ppPortsPlayback[iPort] == NULL) {
+                ((ma_jack_free_proc)pDevice->pContext->jack.jack_free)((void*)ppPorts);
+                ma_device_uninit__jack(pDevice);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to register ports.");
+                return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+            }
+        }
+
+        ((ma_jack_free_proc)pDevice->pContext->jack.jack_free)((void*)ppPorts);
+
+        pDescriptorPlayback->periodSizeInFrames = periodSizeInFrames;
+        pDescriptorPlayback->periodCount        = 1;   /* There's no notion of a period in JACK. Just set to 1. */
+
+        pDevice->jack.pIntermediaryBufferPlayback = (float*)ma_calloc(pDescriptorPlayback->periodSizeInFrames * ma_get_bytes_per_frame(pDescriptorPlayback->format, pDescriptorPlayback->channels), &pDevice->pContext->allocationCallbacks);
+        if (pDevice->jack.pIntermediaryBufferPlayback == NULL) {
+            ma_device_uninit__jack(pDevice);
+            return MA_OUT_OF_MEMORY;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_start__jack(ma_device* pDevice)
+{
+    ma_context* pContext = pDevice->pContext;
+    int resultJACK;
+    size_t i;
+
+    resultJACK = ((ma_jack_activate_proc)pContext->jack.jack_activate)((ma_jack_client_t*)pDevice->jack.pClient);
+    if (resultJACK != 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to activate the JACK client.");
+        return MA_FAILED_TO_START_BACKEND_DEVICE;
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        const char** ppServerPorts = ((ma_jack_get_ports_proc)pContext->jack.jack_get_ports)((ma_jack_client_t*)pDevice->jack.pClient, NULL, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsPhysical | ma_JackPortIsOutput);
+        if (ppServerPorts == NULL) {
+            ((ma_jack_deactivate_proc)pContext->jack.jack_deactivate)((ma_jack_client_t*)pDevice->jack.pClient);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to retrieve physical ports.");
+            return MA_ERROR;
+        }
+
+        for (i = 0; ppServerPorts[i] != NULL; ++i) {
+            const char* pServerPort = ppServerPorts[i];
+            const char* pClientPort = ((ma_jack_port_name_proc)pContext->jack.jack_port_name)((ma_jack_port_t*)pDevice->jack.ppPortsCapture[i]);
+
+            resultJACK = ((ma_jack_connect_proc)pContext->jack.jack_connect)((ma_jack_client_t*)pDevice->jack.pClient, pServerPort, pClientPort);
+            if (resultJACK != 0) {
+                ((ma_jack_free_proc)pContext->jack.jack_free)((void*)ppServerPorts);
+                ((ma_jack_deactivate_proc)pContext->jack.jack_deactivate)((ma_jack_client_t*)pDevice->jack.pClient);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to connect ports.");
+                return MA_ERROR;
+            }
+        }
+
+        ((ma_jack_free_proc)pContext->jack.jack_free)((void*)ppServerPorts);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        const char** ppServerPorts = ((ma_jack_get_ports_proc)pContext->jack.jack_get_ports)((ma_jack_client_t*)pDevice->jack.pClient, NULL, MA_JACK_DEFAULT_AUDIO_TYPE, ma_JackPortIsPhysical | ma_JackPortIsInput);
+        if (ppServerPorts == NULL) {
+            ((ma_jack_deactivate_proc)pContext->jack.jack_deactivate)((ma_jack_client_t*)pDevice->jack.pClient);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to retrieve physical ports.");
+            return MA_ERROR;
+        }
+
+        for (i = 0; ppServerPorts[i] != NULL; ++i) {
+            const char* pServerPort = ppServerPorts[i];
+            const char* pClientPort = ((ma_jack_port_name_proc)pContext->jack.jack_port_name)((ma_jack_port_t*)pDevice->jack.ppPortsPlayback[i]);
+
+            resultJACK = ((ma_jack_connect_proc)pContext->jack.jack_connect)((ma_jack_client_t*)pDevice->jack.pClient, pClientPort, pServerPort);
+            if (resultJACK != 0) {
+                ((ma_jack_free_proc)pContext->jack.jack_free)((void*)ppServerPorts);
+                ((ma_jack_deactivate_proc)pContext->jack.jack_deactivate)((ma_jack_client_t*)pDevice->jack.pClient);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] Failed to connect ports.");
+                return MA_ERROR;
+            }
+        }
+
+        ((ma_jack_free_proc)pContext->jack.jack_free)((void*)ppServerPorts);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__jack(ma_device* pDevice)
+{
+    ma_context* pContext = pDevice->pContext;
+
+    if (((ma_jack_deactivate_proc)pContext->jack.jack_deactivate)((ma_jack_client_t*)pDevice->jack.pClient) != 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[JACK] An error occurred when deactivating the JACK client.");
+        return MA_ERROR;
+    }
+
+    ma_device__on_notification_stopped(pDevice);
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_uninit__jack(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_jack);
+
+    ma_free(pContext->jack.pClientName, &pContext->allocationCallbacks);
+    pContext->jack.pClientName = NULL;
+
+#ifndef MA_NO_RUNTIME_LINKING
+    ma_dlclose(ma_context_get_log(pContext), pContext->jack.jackSO);
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__jack(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+#ifndef MA_NO_RUNTIME_LINKING
+    const char* libjackNames[] = {
+#if defined(MA_WIN32)
+        "libjack.dll",
+        "libjack64.dll"
+#endif
+#if defined(MA_UNIX)
+        "libjack.so",
+        "libjack.so.0"
+#endif
+    };
+    size_t i;
+
+    for (i = 0; i < ma_countof(libjackNames); ++i) {
+        pContext->jack.jackSO = ma_dlopen(ma_context_get_log(pContext), libjackNames[i]);
+        if (pContext->jack.jackSO != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->jack.jackSO == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    pContext->jack.jack_client_open              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_client_open");
+    pContext->jack.jack_client_close             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_client_close");
+    pContext->jack.jack_client_name_size         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_client_name_size");
+    pContext->jack.jack_set_process_callback     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_set_process_callback");
+    pContext->jack.jack_set_buffer_size_callback = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_set_buffer_size_callback");
+    pContext->jack.jack_on_shutdown              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_on_shutdown");
+    pContext->jack.jack_get_sample_rate          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_get_sample_rate");
+    pContext->jack.jack_get_buffer_size          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_get_buffer_size");
+    pContext->jack.jack_get_ports                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_get_ports");
+    pContext->jack.jack_activate                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_activate");
+    pContext->jack.jack_deactivate               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_deactivate");
+    pContext->jack.jack_connect                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_connect");
+    pContext->jack.jack_port_register            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_port_register");
+    pContext->jack.jack_port_name                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_port_name");
+    pContext->jack.jack_port_get_buffer          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_port_get_buffer");
+    pContext->jack.jack_free                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->jack.jackSO, "jack_free");
+#else
+    /*
+    This strange assignment system is here just to ensure type safety of miniaudio's function pointer
+    types. If anything differs slightly the compiler should throw a warning.
+    */
+    ma_jack_client_open_proc              _jack_client_open              = jack_client_open;
+    ma_jack_client_close_proc             _jack_client_close             = jack_client_close;
+    ma_jack_client_name_size_proc         _jack_client_name_size         = jack_client_name_size;
+    ma_jack_set_process_callback_proc     _jack_set_process_callback     = jack_set_process_callback;
+    ma_jack_set_buffer_size_callback_proc _jack_set_buffer_size_callback = jack_set_buffer_size_callback;
+    ma_jack_on_shutdown_proc              _jack_on_shutdown              = jack_on_shutdown;
+    ma_jack_get_sample_rate_proc          _jack_get_sample_rate          = jack_get_sample_rate;
+    ma_jack_get_buffer_size_proc          _jack_get_buffer_size          = jack_get_buffer_size;
+    ma_jack_get_ports_proc                _jack_get_ports                = jack_get_ports;
+    ma_jack_activate_proc                 _jack_activate                 = jack_activate;
+    ma_jack_deactivate_proc               _jack_deactivate               = jack_deactivate;
+    ma_jack_connect_proc                  _jack_connect                  = jack_connect;
+    ma_jack_port_register_proc            _jack_port_register            = jack_port_register;
+    ma_jack_port_name_proc                _jack_port_name                = jack_port_name;
+    ma_jack_port_get_buffer_proc          _jack_port_get_buffer          = jack_port_get_buffer;
+    ma_jack_free_proc                     _jack_free                     = jack_free;
+
+    pContext->jack.jack_client_open              = (ma_proc)_jack_client_open;
+    pContext->jack.jack_client_close             = (ma_proc)_jack_client_close;
+    pContext->jack.jack_client_name_size         = (ma_proc)_jack_client_name_size;
+    pContext->jack.jack_set_process_callback     = (ma_proc)_jack_set_process_callback;
+    pContext->jack.jack_set_buffer_size_callback = (ma_proc)_jack_set_buffer_size_callback;
+    pContext->jack.jack_on_shutdown              = (ma_proc)_jack_on_shutdown;
+    pContext->jack.jack_get_sample_rate          = (ma_proc)_jack_get_sample_rate;
+    pContext->jack.jack_get_buffer_size          = (ma_proc)_jack_get_buffer_size;
+    pContext->jack.jack_get_ports                = (ma_proc)_jack_get_ports;
+    pContext->jack.jack_activate                 = (ma_proc)_jack_activate;
+    pContext->jack.jack_deactivate               = (ma_proc)_jack_deactivate;
+    pContext->jack.jack_connect                  = (ma_proc)_jack_connect;
+    pContext->jack.jack_port_register            = (ma_proc)_jack_port_register;
+    pContext->jack.jack_port_name                = (ma_proc)_jack_port_name;
+    pContext->jack.jack_port_get_buffer          = (ma_proc)_jack_port_get_buffer;
+    pContext->jack.jack_free                     = (ma_proc)_jack_free;
+#endif
+
+    if (pConfig->jack.pClientName != NULL) {
+        pContext->jack.pClientName = ma_copy_string(pConfig->jack.pClientName, &pContext->allocationCallbacks);
+    }
+    pContext->jack.tryStartServer = pConfig->jack.tryStartServer;
+
+    /*
+    Getting here means the JACK library is installed, but it doesn't necessarily mean it's usable. We need to quickly test this by connecting
+    a temporary client.
+    */
+    {
+        ma_jack_client_t* pDummyClient;
+        ma_result result = ma_context_open_client__jack(pContext, &pDummyClient);
+        if (result != MA_SUCCESS) {
+            ma_free(pContext->jack.pClientName, &pContext->allocationCallbacks);
+        #ifndef MA_NO_RUNTIME_LINKING
+            ma_dlclose(ma_context_get_log(pContext), pContext->jack.jackSO);
+        #endif
+            return MA_NO_BACKEND;
+        }
+
+        ((ma_jack_client_close_proc)pContext->jack.jack_client_close)((ma_jack_client_t*)pDummyClient);
+    }
+
+
+    pCallbacks->onContextInit             = ma_context_init__jack;
+    pCallbacks->onContextUninit           = ma_context_uninit__jack;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__jack;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__jack;
+    pCallbacks->onDeviceInit              = ma_device_init__jack;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__jack;
+    pCallbacks->onDeviceStart             = ma_device_start__jack;
+    pCallbacks->onDeviceStop              = ma_device_stop__jack;
+    pCallbacks->onDeviceRead              = NULL;   /* Not used because JACK is asynchronous. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not used because JACK is asynchronous. */
+    pCallbacks->onDeviceDataLoop          = NULL;   /* Not used because JACK is asynchronous. */
+
+    return MA_SUCCESS;
+}
+#endif  /* JACK */
+
+
+
+/******************************************************************************
+
+Core Audio Backend
+
+References
+==========
+- Technical Note TN2091: Device input using the HAL Output Audio Unit
+    https://developer.apple.com/library/archive/technotes/tn2091/_index.html
+
+******************************************************************************/
+#ifdef MA_HAS_COREAUDIO
+#include <TargetConditionals.h>
+
+#if defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1
+    #define MA_APPLE_MOBILE
+    #if defined(TARGET_OS_TV) && TARGET_OS_TV == 1
+        #define MA_APPLE_TV
+    #endif
+    #if defined(TARGET_OS_WATCH) && TARGET_OS_WATCH == 1
+        #define MA_APPLE_WATCH
+    #endif
+    #if __has_feature(objc_arc)
+        #define MA_BRIDGE_TRANSFER  __bridge_transfer
+        #define MA_BRIDGE_RETAINED  __bridge_retained
+    #else
+        #define MA_BRIDGE_TRANSFER
+        #define MA_BRIDGE_RETAINED
+    #endif
+#else
+    #define MA_APPLE_DESKTOP
+#endif
+
+#if defined(MA_APPLE_DESKTOP)
+#include <CoreAudio/CoreAudio.h>
+#else
+#include <AVFoundation/AVFoundation.h>
+#endif
+
+#include <AudioToolbox/AudioToolbox.h>
+
+/* CoreFoundation */
+typedef Boolean (* ma_CFStringGetCString_proc)(CFStringRef theString, char* buffer, CFIndex bufferSize, CFStringEncoding encoding);
+typedef void (* ma_CFRelease_proc)(CFTypeRef cf);
+
+/* CoreAudio */
+#if defined(MA_APPLE_DESKTOP)
+typedef OSStatus (* ma_AudioObjectGetPropertyData_proc)(AudioObjectID inObjectID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* ioDataSize, void* outData);
+typedef OSStatus (* ma_AudioObjectGetPropertyDataSize_proc)(AudioObjectID inObjectID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32* outDataSize);
+typedef OSStatus (* ma_AudioObjectSetPropertyData_proc)(AudioObjectID inObjectID, const AudioObjectPropertyAddress* inAddress, UInt32 inQualifierDataSize, const void* inQualifierData, UInt32 inDataSize, const void* inData);
+typedef OSStatus (* ma_AudioObjectAddPropertyListener_proc)(AudioObjectID inObjectID, const AudioObjectPropertyAddress* inAddress, AudioObjectPropertyListenerProc inListener, void* inClientData);
+typedef OSStatus (* ma_AudioObjectRemovePropertyListener_proc)(AudioObjectID inObjectID, const AudioObjectPropertyAddress* inAddress, AudioObjectPropertyListenerProc inListener, void* inClientData);
+#endif
+
+/* AudioToolbox */
+typedef AudioComponent (* ma_AudioComponentFindNext_proc)(AudioComponent inComponent, const AudioComponentDescription* inDesc);
+typedef OSStatus (* ma_AudioComponentInstanceDispose_proc)(AudioComponentInstance inInstance);
+typedef OSStatus (* ma_AudioComponentInstanceNew_proc)(AudioComponent inComponent, AudioComponentInstance* outInstance);
+typedef OSStatus (* ma_AudioOutputUnitStart_proc)(AudioUnit inUnit);
+typedef OSStatus (* ma_AudioOutputUnitStop_proc)(AudioUnit inUnit);
+typedef OSStatus (* ma_AudioUnitAddPropertyListener_proc)(AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitPropertyListenerProc inProc, void* inProcUserData);
+typedef OSStatus (* ma_AudioUnitGetPropertyInfo_proc)(AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitScope inScope, AudioUnitElement inElement, UInt32* outDataSize, Boolean* outWriteable);
+typedef OSStatus (* ma_AudioUnitGetProperty_proc)(AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitScope inScope, AudioUnitElement inElement, void* outData, UInt32* ioDataSize);
+typedef OSStatus (* ma_AudioUnitSetProperty_proc)(AudioUnit inUnit, AudioUnitPropertyID inID, AudioUnitScope inScope, AudioUnitElement inElement, const void* inData, UInt32 inDataSize);
+typedef OSStatus (* ma_AudioUnitInitialize_proc)(AudioUnit inUnit);
+typedef OSStatus (* ma_AudioUnitRender_proc)(AudioUnit inUnit, AudioUnitRenderActionFlags* ioActionFlags, const AudioTimeStamp* inTimeStamp, UInt32 inOutputBusNumber, UInt32 inNumberFrames, AudioBufferList* ioData);
+
+
+#define MA_COREAUDIO_OUTPUT_BUS    0
+#define MA_COREAUDIO_INPUT_BUS     1
+
+#if defined(MA_APPLE_DESKTOP)
+static ma_result ma_device_reinit_internal__coreaudio(ma_device* pDevice, ma_device_type deviceType, ma_bool32 disposePreviousAudioUnit);
+#endif
+
+/*
+Core Audio
+
+So far, Core Audio has been the worst backend to work with due to being both unintuitive and having almost no documentation
+apart from comments in the headers (which admittedly are quite good). For my own purposes, and for anybody out there whose
+needing to figure out how this darn thing works, I'm going to outline a few things here.
+
+Since miniaudio is a fairly low-level API, one of the things it needs is control over specific devices, and it needs to be
+able to identify whether or not it can be used as playback and/or capture. The AudioObject API is the only one I've seen
+that supports this level of detail. There was some public domain sample code I stumbled across that used the AudioComponent
+and AudioUnit APIs, but I couldn't see anything that gave low-level control over device selection and capabilities (the
+distinction between playback and capture in particular). Therefore, miniaudio is using the AudioObject API.
+
+Most (all?) functions in the AudioObject API take a AudioObjectID as it's input. This is the device identifier. When
+retrieving global information, such as the device list, you use kAudioObjectSystemObject. When retrieving device-specific
+data, you pass in the ID for that device. In order to retrieve device-specific IDs you need to enumerate over each of the
+devices. This is done using the AudioObjectGetPropertyDataSize() and AudioObjectGetPropertyData() APIs which seem to be
+the central APIs for retrieving information about the system and specific devices.
+
+To use the AudioObjectGetPropertyData() API you need to use the notion of a property address. A property address is a
+structure with three variables and is used to identify which property you are getting or setting. The first is the "selector"
+which is basically the specific property that you're wanting to retrieve or set. The second is the "scope", which is
+typically set to kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyScopeInput for input-specific properties and
+kAudioObjectPropertyScopeOutput for output-specific properties. The last is the "element" which is always set to
+kAudioObjectPropertyElementMain in miniaudio's case. I don't know of any cases where this would be set to anything different.
+
+Back to the earlier issue of device retrieval, you first use the AudioObjectGetPropertyDataSize() API to retrieve the size
+of the raw data which is just a list of AudioDeviceID's. You use the kAudioObjectSystemObject AudioObjectID, and a property
+address with the kAudioHardwarePropertyDevices selector and the kAudioObjectPropertyScopeGlobal scope. Once you have the
+size, allocate a block of memory of that size and then call AudioObjectGetPropertyData(). The data is just a list of
+AudioDeviceID's so just do "dataSize/sizeof(AudioDeviceID)" to know the device count.
+*/
+
+#if defined(MA_APPLE_MOBILE)
+static void ma_device__on_notification_interruption_began(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_interruption_began));
+}
+
+static void ma_device__on_notification_interruption_ended(ma_device* pDevice)
+{
+    ma_device__on_notification(ma_device_notification_init(pDevice, ma_device_notification_type_interruption_ended));
+}
+#endif
+
+static ma_result ma_result_from_OSStatus(OSStatus status)
+{
+    switch (status)
+    {
+        case noErr:                                   return MA_SUCCESS;
+    #if defined(MA_APPLE_DESKTOP)
+        case kAudioHardwareNotRunningError:           return MA_DEVICE_NOT_STARTED;
+        case kAudioHardwareUnspecifiedError:          return MA_ERROR;
+        case kAudioHardwareUnknownPropertyError:      return MA_INVALID_ARGS;
+        case kAudioHardwareBadPropertySizeError:      return MA_INVALID_OPERATION;
+        case kAudioHardwareIllegalOperationError:     return MA_INVALID_OPERATION;
+        case kAudioHardwareBadObjectError:            return MA_INVALID_ARGS;
+        case kAudioHardwareBadDeviceError:            return MA_INVALID_ARGS;
+        case kAudioHardwareBadStreamError:            return MA_INVALID_ARGS;
+        case kAudioHardwareUnsupportedOperationError: return MA_INVALID_OPERATION;
+        case kAudioDeviceUnsupportedFormatError:      return MA_FORMAT_NOT_SUPPORTED;
+        case kAudioDevicePermissionsError:            return MA_ACCESS_DENIED;
+    #endif
+        default:                                      return MA_ERROR;
+    }
+}
+
+#if 0
+static ma_channel ma_channel_from_AudioChannelBitmap(AudioChannelBitmap bit)
+{
+    switch (bit)
+    {
+        case kAudioChannelBit_Left:                 return MA_CHANNEL_LEFT;
+        case kAudioChannelBit_Right:                return MA_CHANNEL_RIGHT;
+        case kAudioChannelBit_Center:               return MA_CHANNEL_FRONT_CENTER;
+        case kAudioChannelBit_LFEScreen:            return MA_CHANNEL_LFE;
+        case kAudioChannelBit_LeftSurround:         return MA_CHANNEL_BACK_LEFT;
+        case kAudioChannelBit_RightSurround:        return MA_CHANNEL_BACK_RIGHT;
+        case kAudioChannelBit_LeftCenter:           return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case kAudioChannelBit_RightCenter:          return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case kAudioChannelBit_CenterSurround:       return MA_CHANNEL_BACK_CENTER;
+        case kAudioChannelBit_LeftSurroundDirect:   return MA_CHANNEL_SIDE_LEFT;
+        case kAudioChannelBit_RightSurroundDirect:  return MA_CHANNEL_SIDE_RIGHT;
+        case kAudioChannelBit_TopCenterSurround:    return MA_CHANNEL_TOP_CENTER;
+        case kAudioChannelBit_VerticalHeightLeft:   return MA_CHANNEL_TOP_FRONT_LEFT;
+        case kAudioChannelBit_VerticalHeightCenter: return MA_CHANNEL_TOP_FRONT_CENTER;
+        case kAudioChannelBit_VerticalHeightRight:  return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case kAudioChannelBit_TopBackLeft:          return MA_CHANNEL_TOP_BACK_LEFT;
+        case kAudioChannelBit_TopBackCenter:        return MA_CHANNEL_TOP_BACK_CENTER;
+        case kAudioChannelBit_TopBackRight:         return MA_CHANNEL_TOP_BACK_RIGHT;
+        default:                                    return MA_CHANNEL_NONE;
+    }
+}
+#endif
+
+static ma_result ma_format_from_AudioStreamBasicDescription(const AudioStreamBasicDescription* pDescription, ma_format* pFormatOut)
+{
+    MA_ASSERT(pDescription != NULL);
+    MA_ASSERT(pFormatOut != NULL);
+
+    *pFormatOut = ma_format_unknown;   /* Safety. */
+
+    /* There's a few things miniaudio doesn't support. */
+    if (pDescription->mFormatID != kAudioFormatLinearPCM) {
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    /* We don't support any non-packed formats that are aligned high. */
+    if ((pDescription->mFormatFlags & kLinearPCMFormatFlagIsAlignedHigh) != 0) {
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    /* Only supporting native-endian. */
+    if ((ma_is_little_endian() && (pDescription->mFormatFlags & kAudioFormatFlagIsBigEndian) != 0) || (ma_is_big_endian() && (pDescription->mFormatFlags & kAudioFormatFlagIsBigEndian) == 0)) {
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    /* We are not currently supporting non-interleaved formats (this will be added in a future version of miniaudio). */
+    /*if ((pDescription->mFormatFlags & kAudioFormatFlagIsNonInterleaved) != 0) {
+        return MA_FORMAT_NOT_SUPPORTED;
+    }*/
+
+    if ((pDescription->mFormatFlags & kLinearPCMFormatFlagIsFloat) != 0) {
+        if (pDescription->mBitsPerChannel == 32) {
+            *pFormatOut = ma_format_f32;
+            return MA_SUCCESS;
+        }
+    } else {
+        if ((pDescription->mFormatFlags & kLinearPCMFormatFlagIsSignedInteger) != 0) {
+            if (pDescription->mBitsPerChannel == 16) {
+                *pFormatOut = ma_format_s16;
+                return MA_SUCCESS;
+            } else if (pDescription->mBitsPerChannel == 24) {
+                if (pDescription->mBytesPerFrame == (pDescription->mBitsPerChannel/8 * pDescription->mChannelsPerFrame)) {
+                    *pFormatOut = ma_format_s24;
+                    return MA_SUCCESS;
+                } else {
+                    if (pDescription->mBytesPerFrame/pDescription->mChannelsPerFrame == sizeof(ma_int32)) {
+                        /* TODO: Implement ma_format_s24_32. */
+                        /**pFormatOut = ma_format_s24_32;*/
+                        /*return MA_SUCCESS;*/
+                        return MA_FORMAT_NOT_SUPPORTED;
+                    }
+                }
+            } else if (pDescription->mBitsPerChannel == 32) {
+                *pFormatOut = ma_format_s32;
+                return MA_SUCCESS;
+            }
+        } else {
+            if (pDescription->mBitsPerChannel == 8) {
+                *pFormatOut = ma_format_u8;
+                return MA_SUCCESS;
+            }
+        }
+    }
+
+    /* Getting here means the format is not supported. */
+    return MA_FORMAT_NOT_SUPPORTED;
+}
+
+#if defined(MA_APPLE_DESKTOP)
+static ma_channel ma_channel_from_AudioChannelLabel(AudioChannelLabel label)
+{
+    switch (label)
+    {
+        case kAudioChannelLabel_Unknown:              return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Unused:               return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_UseCoordinates:       return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Left:                 return MA_CHANNEL_LEFT;
+        case kAudioChannelLabel_Right:                return MA_CHANNEL_RIGHT;
+        case kAudioChannelLabel_Center:               return MA_CHANNEL_FRONT_CENTER;
+        case kAudioChannelLabel_LFEScreen:            return MA_CHANNEL_LFE;
+        case kAudioChannelLabel_LeftSurround:         return MA_CHANNEL_BACK_LEFT;
+        case kAudioChannelLabel_RightSurround:        return MA_CHANNEL_BACK_RIGHT;
+        case kAudioChannelLabel_LeftCenter:           return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case kAudioChannelLabel_RightCenter:          return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case kAudioChannelLabel_CenterSurround:       return MA_CHANNEL_BACK_CENTER;
+        case kAudioChannelLabel_LeftSurroundDirect:   return MA_CHANNEL_SIDE_LEFT;
+        case kAudioChannelLabel_RightSurroundDirect:  return MA_CHANNEL_SIDE_RIGHT;
+        case kAudioChannelLabel_TopCenterSurround:    return MA_CHANNEL_TOP_CENTER;
+        case kAudioChannelLabel_VerticalHeightLeft:   return MA_CHANNEL_TOP_FRONT_LEFT;
+        case kAudioChannelLabel_VerticalHeightCenter: return MA_CHANNEL_TOP_FRONT_CENTER;
+        case kAudioChannelLabel_VerticalHeightRight:  return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case kAudioChannelLabel_TopBackLeft:          return MA_CHANNEL_TOP_BACK_LEFT;
+        case kAudioChannelLabel_TopBackCenter:        return MA_CHANNEL_TOP_BACK_CENTER;
+        case kAudioChannelLabel_TopBackRight:         return MA_CHANNEL_TOP_BACK_RIGHT;
+        case kAudioChannelLabel_RearSurroundLeft:     return MA_CHANNEL_BACK_LEFT;
+        case kAudioChannelLabel_RearSurroundRight:    return MA_CHANNEL_BACK_RIGHT;
+        case kAudioChannelLabel_LeftWide:             return MA_CHANNEL_SIDE_LEFT;
+        case kAudioChannelLabel_RightWide:            return MA_CHANNEL_SIDE_RIGHT;
+        case kAudioChannelLabel_LFE2:                 return MA_CHANNEL_LFE;
+        case kAudioChannelLabel_LeftTotal:            return MA_CHANNEL_LEFT;
+        case kAudioChannelLabel_RightTotal:           return MA_CHANNEL_RIGHT;
+        case kAudioChannelLabel_HearingImpaired:      return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Narration:            return MA_CHANNEL_MONO;
+        case kAudioChannelLabel_Mono:                 return MA_CHANNEL_MONO;
+        case kAudioChannelLabel_DialogCentricMix:     return MA_CHANNEL_MONO;
+        case kAudioChannelLabel_CenterSurroundDirect: return MA_CHANNEL_BACK_CENTER;
+        case kAudioChannelLabel_Haptic:               return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Ambisonic_W:          return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Ambisonic_X:          return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Ambisonic_Y:          return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Ambisonic_Z:          return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_MS_Mid:               return MA_CHANNEL_LEFT;
+        case kAudioChannelLabel_MS_Side:              return MA_CHANNEL_RIGHT;
+        case kAudioChannelLabel_XY_X:                 return MA_CHANNEL_LEFT;
+        case kAudioChannelLabel_XY_Y:                 return MA_CHANNEL_RIGHT;
+        case kAudioChannelLabel_HeadphonesLeft:       return MA_CHANNEL_LEFT;
+        case kAudioChannelLabel_HeadphonesRight:      return MA_CHANNEL_RIGHT;
+        case kAudioChannelLabel_ClickTrack:           return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_ForeignLanguage:      return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Discrete:             return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_Discrete_0:           return MA_CHANNEL_AUX_0;
+        case kAudioChannelLabel_Discrete_1:           return MA_CHANNEL_AUX_1;
+        case kAudioChannelLabel_Discrete_2:           return MA_CHANNEL_AUX_2;
+        case kAudioChannelLabel_Discrete_3:           return MA_CHANNEL_AUX_3;
+        case kAudioChannelLabel_Discrete_4:           return MA_CHANNEL_AUX_4;
+        case kAudioChannelLabel_Discrete_5:           return MA_CHANNEL_AUX_5;
+        case kAudioChannelLabel_Discrete_6:           return MA_CHANNEL_AUX_6;
+        case kAudioChannelLabel_Discrete_7:           return MA_CHANNEL_AUX_7;
+        case kAudioChannelLabel_Discrete_8:           return MA_CHANNEL_AUX_8;
+        case kAudioChannelLabel_Discrete_9:           return MA_CHANNEL_AUX_9;
+        case kAudioChannelLabel_Discrete_10:          return MA_CHANNEL_AUX_10;
+        case kAudioChannelLabel_Discrete_11:          return MA_CHANNEL_AUX_11;
+        case kAudioChannelLabel_Discrete_12:          return MA_CHANNEL_AUX_12;
+        case kAudioChannelLabel_Discrete_13:          return MA_CHANNEL_AUX_13;
+        case kAudioChannelLabel_Discrete_14:          return MA_CHANNEL_AUX_14;
+        case kAudioChannelLabel_Discrete_15:          return MA_CHANNEL_AUX_15;
+        case kAudioChannelLabel_Discrete_65535:       return MA_CHANNEL_NONE;
+
+    #if 0   /* Introduced in a later version of macOS. */
+        case kAudioChannelLabel_HOA_ACN:              return MA_CHANNEL_NONE;
+        case kAudioChannelLabel_HOA_ACN_0:            return MA_CHANNEL_AUX_0;
+        case kAudioChannelLabel_HOA_ACN_1:            return MA_CHANNEL_AUX_1;
+        case kAudioChannelLabel_HOA_ACN_2:            return MA_CHANNEL_AUX_2;
+        case kAudioChannelLabel_HOA_ACN_3:            return MA_CHANNEL_AUX_3;
+        case kAudioChannelLabel_HOA_ACN_4:            return MA_CHANNEL_AUX_4;
+        case kAudioChannelLabel_HOA_ACN_5:            return MA_CHANNEL_AUX_5;
+        case kAudioChannelLabel_HOA_ACN_6:            return MA_CHANNEL_AUX_6;
+        case kAudioChannelLabel_HOA_ACN_7:            return MA_CHANNEL_AUX_7;
+        case kAudioChannelLabel_HOA_ACN_8:            return MA_CHANNEL_AUX_8;
+        case kAudioChannelLabel_HOA_ACN_9:            return MA_CHANNEL_AUX_9;
+        case kAudioChannelLabel_HOA_ACN_10:           return MA_CHANNEL_AUX_10;
+        case kAudioChannelLabel_HOA_ACN_11:           return MA_CHANNEL_AUX_11;
+        case kAudioChannelLabel_HOA_ACN_12:           return MA_CHANNEL_AUX_12;
+        case kAudioChannelLabel_HOA_ACN_13:           return MA_CHANNEL_AUX_13;
+        case kAudioChannelLabel_HOA_ACN_14:           return MA_CHANNEL_AUX_14;
+        case kAudioChannelLabel_HOA_ACN_15:           return MA_CHANNEL_AUX_15;
+        case kAudioChannelLabel_HOA_ACN_65024:        return MA_CHANNEL_NONE;
+    #endif
+
+        default:                                      return MA_CHANNEL_NONE;
+    }
+}
+
+static ma_result ma_get_channel_map_from_AudioChannelLayout(AudioChannelLayout* pChannelLayout, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    MA_ASSERT(pChannelLayout != NULL);
+
+    if (pChannelLayout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelDescriptions) {
+        UInt32 iChannel;
+        for (iChannel = 0; iChannel < pChannelLayout->mNumberChannelDescriptions && iChannel < channelMapCap; ++iChannel) {
+            pChannelMap[iChannel] = ma_channel_from_AudioChannelLabel(pChannelLayout->mChannelDescriptions[iChannel].mChannelLabel);
+        }
+    } else
+#if 0
+    if (pChannelLayout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelBitmap) {
+        /* This is the same kind of system that's used by Windows audio APIs. */
+        UInt32 iChannel = 0;
+        UInt32 iBit;
+        AudioChannelBitmap bitmap = pChannelLayout->mChannelBitmap;
+        for (iBit = 0; iBit < 32 && iChannel < channelMapCap; ++iBit) {
+            AudioChannelBitmap bit = bitmap & (1 << iBit);
+            if (bit != 0) {
+                pChannelMap[iChannel++] = ma_channel_from_AudioChannelBit(bit);
+            }
+        }
+    } else
+#endif
+    {
+        /*
+        Need to use the tag to determine the channel map. For now I'm just assuming a default channel map, but later on this should
+        be updated to determine the mapping based on the tag.
+        */
+        UInt32 channelCount;
+
+        /* Our channel map retrieval APIs below take 32-bit integers, so we'll want to clamp the channel map capacity. */
+        if (channelMapCap > 0xFFFFFFFF) {
+            channelMapCap = 0xFFFFFFFF;
+        }
+
+        channelCount = ma_min(AudioChannelLayoutTag_GetNumberOfChannels(pChannelLayout->mChannelLayoutTag), (UInt32)channelMapCap);
+
+        switch (pChannelLayout->mChannelLayoutTag)
+        {
+            case kAudioChannelLayoutTag_Mono:
+            case kAudioChannelLayoutTag_Stereo:
+            case kAudioChannelLayoutTag_StereoHeadphones:
+            case kAudioChannelLayoutTag_MatrixStereo:
+            case kAudioChannelLayoutTag_MidSide:
+            case kAudioChannelLayoutTag_XY:
+            case kAudioChannelLayoutTag_Binaural:
+            case kAudioChannelLayoutTag_Ambisonic_B_Format:
+            {
+                ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, channelCount);
+            } break;
+
+            case kAudioChannelLayoutTag_Octagonal:
+            {
+                pChannelMap[7] = MA_CHANNEL_SIDE_RIGHT;
+                pChannelMap[6] = MA_CHANNEL_SIDE_LEFT;
+            } MA_FALLTHROUGH; /* Intentional fallthrough. */
+            case kAudioChannelLayoutTag_Hexagonal:
+            {
+                pChannelMap[5] = MA_CHANNEL_BACK_CENTER;
+            } MA_FALLTHROUGH; /* Intentional fallthrough. */
+            case kAudioChannelLayoutTag_Pentagonal:
+            {
+                pChannelMap[4] = MA_CHANNEL_FRONT_CENTER;
+            } MA_FALLTHROUGH; /* Intentional fallthrough. */
+            case kAudioChannelLayoutTag_Quadraphonic:
+            {
+                pChannelMap[3] = MA_CHANNEL_BACK_RIGHT;
+                pChannelMap[2] = MA_CHANNEL_BACK_LEFT;
+                pChannelMap[1] = MA_CHANNEL_RIGHT;
+                pChannelMap[0] = MA_CHANNEL_LEFT;
+            } break;
+
+            /* TODO: Add support for more tags here. */
+
+            default:
+            {
+                ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, channelCount);
+            } break;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+#if (defined(MAC_OS_VERSION_12_0) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_VERSION_12_0) || \
+    (defined(__IPHONE_15_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_15_0)
+#define AUDIO_OBJECT_PROPERTY_ELEMENT kAudioObjectPropertyElementMain
+#else
+/* kAudioObjectPropertyElementMaster is deprecated. */
+#define AUDIO_OBJECT_PROPERTY_ELEMENT kAudioObjectPropertyElementMaster
+#endif
+
+static ma_result ma_get_device_object_ids__coreaudio(ma_context* pContext, UInt32* pDeviceCount, AudioObjectID** ppDeviceObjectIDs) /* NOTE: Free the returned buffer with ma_free(). */
+{
+    AudioObjectPropertyAddress propAddressDevices;
+    UInt32 deviceObjectsDataSize;
+    OSStatus status;
+    AudioObjectID* pDeviceObjectIDs;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pDeviceCount != NULL);
+    MA_ASSERT(ppDeviceObjectIDs != NULL);
+
+    /* Safety. */
+    *pDeviceCount = 0;
+    *ppDeviceObjectIDs = NULL;
+
+    propAddressDevices.mSelector = kAudioHardwarePropertyDevices;
+    propAddressDevices.mScope    = kAudioObjectPropertyScopeGlobal;
+    propAddressDevices.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    status = ((ma_AudioObjectGetPropertyDataSize_proc)pContext->coreaudio.AudioObjectGetPropertyDataSize)(kAudioObjectSystemObject, &propAddressDevices, 0, NULL, &deviceObjectsDataSize);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    pDeviceObjectIDs = (AudioObjectID*)ma_malloc(deviceObjectsDataSize, &pContext->allocationCallbacks);
+    if (pDeviceObjectIDs == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(kAudioObjectSystemObject, &propAddressDevices, 0, NULL, &deviceObjectsDataSize, pDeviceObjectIDs);
+    if (status != noErr) {
+        ma_free(pDeviceObjectIDs, &pContext->allocationCallbacks);
+        return ma_result_from_OSStatus(status);
+    }
+
+    *pDeviceCount = deviceObjectsDataSize / sizeof(AudioObjectID);
+    *ppDeviceObjectIDs = pDeviceObjectIDs;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_get_AudioObject_uid_as_CFStringRef(ma_context* pContext, AudioObjectID objectID, CFStringRef* pUID)
+{
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+
+    MA_ASSERT(pContext != NULL);
+
+    propAddress.mSelector = kAudioDevicePropertyDeviceUID;
+    propAddress.mScope    = kAudioObjectPropertyScopeGlobal;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    dataSize = sizeof(*pUID);
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(objectID, &propAddress, 0, NULL, &dataSize, pUID);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_get_AudioObject_uid(ma_context* pContext, AudioObjectID objectID, size_t bufferSize, char* bufferOut)
+{
+    CFStringRef uid;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+    result = ma_get_AudioObject_uid_as_CFStringRef(pContext, objectID, &uid);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (!((ma_CFStringGetCString_proc)pContext->coreaudio.CFStringGetCString)(uid, bufferOut, bufferSize, kCFStringEncodingUTF8)) {
+        return MA_ERROR;
+    }
+
+    ((ma_CFRelease_proc)pContext->coreaudio.CFRelease)(uid);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_get_AudioObject_name(ma_context* pContext, AudioObjectID objectID, size_t bufferSize, char* bufferOut)
+{
+    AudioObjectPropertyAddress propAddress;
+    CFStringRef deviceName = NULL;
+    UInt32 dataSize;
+    OSStatus status;
+
+    MA_ASSERT(pContext != NULL);
+
+    propAddress.mSelector = kAudioDevicePropertyDeviceNameCFString;
+    propAddress.mScope    = kAudioObjectPropertyScopeGlobal;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    dataSize = sizeof(deviceName);
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(objectID, &propAddress, 0, NULL, &dataSize, &deviceName);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    if (!((ma_CFStringGetCString_proc)pContext->coreaudio.CFStringGetCString)(deviceName, bufferOut, bufferSize, kCFStringEncodingUTF8)) {
+        return MA_ERROR;
+    }
+
+    ((ma_CFRelease_proc)pContext->coreaudio.CFRelease)(deviceName);
+    return MA_SUCCESS;
+}
+
+static ma_bool32 ma_does_AudioObject_support_scope(ma_context* pContext, AudioObjectID deviceObjectID, AudioObjectPropertyScope scope)
+{
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+    AudioBufferList* pBufferList;
+    ma_bool32 isSupported;
+
+    MA_ASSERT(pContext != NULL);
+
+    /* To know whether or not a device is an input device we need ot look at the stream configuration. If it has an output channel it's a playback device. */
+    propAddress.mSelector = kAudioDevicePropertyStreamConfiguration;
+    propAddress.mScope    = scope;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    status = ((ma_AudioObjectGetPropertyDataSize_proc)pContext->coreaudio.AudioObjectGetPropertyDataSize)(deviceObjectID, &propAddress, 0, NULL, &dataSize);
+    if (status != noErr) {
+        return MA_FALSE;
+    }
+
+    pBufferList = (AudioBufferList*)ma_malloc(dataSize, &pContext->allocationCallbacks);
+    if (pBufferList == NULL) {
+        return MA_FALSE;   /* Out of memory. */
+    }
+
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, pBufferList);
+    if (status != noErr) {
+        ma_free(pBufferList, &pContext->allocationCallbacks);
+        return MA_FALSE;
+    }
+
+    isSupported = MA_FALSE;
+    if (pBufferList->mNumberBuffers > 0) {
+        isSupported = MA_TRUE;
+    }
+
+    ma_free(pBufferList, &pContext->allocationCallbacks);
+    return isSupported;
+}
+
+static ma_bool32 ma_does_AudioObject_support_playback(ma_context* pContext, AudioObjectID deviceObjectID)
+{
+    return ma_does_AudioObject_support_scope(pContext, deviceObjectID, kAudioObjectPropertyScopeOutput);
+}
+
+static ma_bool32 ma_does_AudioObject_support_capture(ma_context* pContext, AudioObjectID deviceObjectID)
+{
+    return ma_does_AudioObject_support_scope(pContext, deviceObjectID, kAudioObjectPropertyScopeInput);
+}
+
+
+static ma_result ma_get_AudioObject_stream_descriptions(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, UInt32* pDescriptionCount, AudioStreamRangedDescription** ppDescriptions) /* NOTE: Free the returned pointer with ma_free(). */
+{
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+    AudioStreamRangedDescription* pDescriptions;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pDescriptionCount != NULL);
+    MA_ASSERT(ppDescriptions != NULL);
+
+    /*
+    TODO: Experiment with kAudioStreamPropertyAvailablePhysicalFormats instead of (or in addition to) kAudioStreamPropertyAvailableVirtualFormats. My
+          MacBook Pro uses s24/32 format, however, which miniaudio does not currently support.
+    */
+    propAddress.mSelector = kAudioStreamPropertyAvailableVirtualFormats; /*kAudioStreamPropertyAvailablePhysicalFormats;*/
+    propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    status = ((ma_AudioObjectGetPropertyDataSize_proc)pContext->coreaudio.AudioObjectGetPropertyDataSize)(deviceObjectID, &propAddress, 0, NULL, &dataSize);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    pDescriptions = (AudioStreamRangedDescription*)ma_malloc(dataSize, &pContext->allocationCallbacks);
+    if (pDescriptions == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, pDescriptions);
+    if (status != noErr) {
+        ma_free(pDescriptions, &pContext->allocationCallbacks);
+        return ma_result_from_OSStatus(status);
+    }
+
+    *pDescriptionCount = dataSize / sizeof(*pDescriptions);
+    *ppDescriptions = pDescriptions;
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_get_AudioObject_channel_layout(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, AudioChannelLayout** ppChannelLayout)   /* NOTE: Free the returned pointer with ma_free(). */
+{
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+    AudioChannelLayout* pChannelLayout;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(ppChannelLayout != NULL);
+
+    *ppChannelLayout = NULL;    /* Safety. */
+
+    propAddress.mSelector = kAudioDevicePropertyPreferredChannelLayout;
+    propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    status = ((ma_AudioObjectGetPropertyDataSize_proc)pContext->coreaudio.AudioObjectGetPropertyDataSize)(deviceObjectID, &propAddress, 0, NULL, &dataSize);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    pChannelLayout = (AudioChannelLayout*)ma_malloc(dataSize, &pContext->allocationCallbacks);
+    if (pChannelLayout == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, pChannelLayout);
+    if (status != noErr) {
+        ma_free(pChannelLayout, &pContext->allocationCallbacks);
+        return ma_result_from_OSStatus(status);
+    }
+
+    *ppChannelLayout = pChannelLayout;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_get_AudioObject_channel_count(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_uint32* pChannelCount)
+{
+    AudioChannelLayout* pChannelLayout;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pChannelCount != NULL);
+
+    *pChannelCount = 0; /* Safety. */
+
+    result = ma_get_AudioObject_channel_layout(pContext, deviceObjectID, deviceType, &pChannelLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pChannelLayout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelDescriptions) {
+        *pChannelCount = pChannelLayout->mNumberChannelDescriptions;
+    } else if (pChannelLayout->mChannelLayoutTag == kAudioChannelLayoutTag_UseChannelBitmap) {
+        *pChannelCount = ma_count_set_bits(pChannelLayout->mChannelBitmap);
+    } else {
+        *pChannelCount = AudioChannelLayoutTag_GetNumberOfChannels(pChannelLayout->mChannelLayoutTag);
+    }
+
+    ma_free(pChannelLayout, &pContext->allocationCallbacks);
+    return MA_SUCCESS;
+}
+
+#if 0
+static ma_result ma_get_AudioObject_channel_map(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    AudioChannelLayout* pChannelLayout;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+    result = ma_get_AudioObject_channel_layout(pContext, deviceObjectID, deviceType, &pChannelLayout);
+    if (result != MA_SUCCESS) {
+        return result;  /* Rather than always failing here, would it be more robust to simply assume a default? */
+    }
+
+    result = ma_get_channel_map_from_AudioChannelLayout(pChannelLayout, pChannelMap, channelMapCap);
+    if (result != MA_SUCCESS) {
+        ma_free(pChannelLayout, &pContext->allocationCallbacks);
+        return result;
+    }
+
+    ma_free(pChannelLayout, &pContext->allocationCallbacks);
+    return result;
+}
+#endif
+
+static ma_result ma_get_AudioObject_sample_rates(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, UInt32* pSampleRateRangesCount, AudioValueRange** ppSampleRateRanges)   /* NOTE: Free the returned pointer with ma_free(). */
+{
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+    AudioValueRange* pSampleRateRanges;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pSampleRateRangesCount != NULL);
+    MA_ASSERT(ppSampleRateRanges != NULL);
+
+    /* Safety. */
+    *pSampleRateRangesCount = 0;
+    *ppSampleRateRanges = NULL;
+
+    propAddress.mSelector = kAudioDevicePropertyAvailableNominalSampleRates;
+    propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    status = ((ma_AudioObjectGetPropertyDataSize_proc)pContext->coreaudio.AudioObjectGetPropertyDataSize)(deviceObjectID, &propAddress, 0, NULL, &dataSize);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    pSampleRateRanges = (AudioValueRange*)ma_malloc(dataSize, &pContext->allocationCallbacks);
+    if (pSampleRateRanges == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, pSampleRateRanges);
+    if (status != noErr) {
+        ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+        return ma_result_from_OSStatus(status);
+    }
+
+    *pSampleRateRangesCount = dataSize / sizeof(*pSampleRateRanges);
+    *ppSampleRateRanges = pSampleRateRanges;
+    return MA_SUCCESS;
+}
+
+#if 0
+static ma_result ma_get_AudioObject_get_closest_sample_rate(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_uint32 sampleRateIn, ma_uint32* pSampleRateOut)
+{
+    UInt32 sampleRateRangeCount;
+    AudioValueRange* pSampleRateRanges;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pSampleRateOut != NULL);
+
+    *pSampleRateOut = 0;    /* Safety. */
+
+    result = ma_get_AudioObject_sample_rates(pContext, deviceObjectID, deviceType, &sampleRateRangeCount, &pSampleRateRanges);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (sampleRateRangeCount == 0) {
+        ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+        return MA_ERROR;   /* Should never hit this case should we? */
+    }
+
+    if (sampleRateIn == 0) {
+        /* Search in order of miniaudio's preferred priority. */
+        UInt32 iMALSampleRate;
+        for (iMALSampleRate = 0; iMALSampleRate < ma_countof(g_maStandardSampleRatePriorities); ++iMALSampleRate) {
+            ma_uint32 malSampleRate = g_maStandardSampleRatePriorities[iMALSampleRate];
+            UInt32 iCASampleRate;
+            for (iCASampleRate = 0; iCASampleRate < sampleRateRangeCount; ++iCASampleRate) {
+                AudioValueRange caSampleRate = pSampleRateRanges[iCASampleRate];
+                if (caSampleRate.mMinimum <= malSampleRate && caSampleRate.mMaximum >= malSampleRate) {
+                    *pSampleRateOut = malSampleRate;
+                    ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+                    return MA_SUCCESS;
+                }
+            }
+        }
+
+        /*
+        If we get here it means none of miniaudio's standard sample rates matched any of the supported sample rates from the device. In this
+        case we just fall back to the first one reported by Core Audio.
+        */
+        MA_ASSERT(sampleRateRangeCount > 0);
+
+        *pSampleRateOut = pSampleRateRanges[0].mMinimum;
+        ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+        return MA_SUCCESS;
+    } else {
+        /* Find the closest match to this sample rate. */
+        UInt32 currentAbsoluteDifference = INT32_MAX;
+        UInt32 iCurrentClosestRange = (UInt32)-1;
+        UInt32 iRange;
+        for (iRange = 0; iRange < sampleRateRangeCount; ++iRange) {
+            if (pSampleRateRanges[iRange].mMinimum <= sampleRateIn && pSampleRateRanges[iRange].mMaximum >= sampleRateIn) {
+                *pSampleRateOut = sampleRateIn;
+                ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+                return MA_SUCCESS;
+            } else {
+                UInt32 absoluteDifference;
+                if (pSampleRateRanges[iRange].mMinimum > sampleRateIn) {
+                    absoluteDifference = pSampleRateRanges[iRange].mMinimum - sampleRateIn;
+                } else {
+                    absoluteDifference = sampleRateIn - pSampleRateRanges[iRange].mMaximum;
+                }
+
+                if (currentAbsoluteDifference > absoluteDifference) {
+                    currentAbsoluteDifference = absoluteDifference;
+                    iCurrentClosestRange = iRange;
+                }
+            }
+        }
+
+        MA_ASSERT(iCurrentClosestRange != (UInt32)-1);
+
+        *pSampleRateOut = pSampleRateRanges[iCurrentClosestRange].mMinimum;
+        ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+        return MA_SUCCESS;
+    }
+
+    /* Should never get here, but it would mean we weren't able to find any suitable sample rates. */
+    /*ma_free(pSampleRateRanges, &pContext->allocationCallbacks);*/
+    /*return MA_ERROR;*/
+}
+#endif
+
+static ma_result ma_get_AudioObject_closest_buffer_size_in_frames(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_uint32 bufferSizeInFramesIn, ma_uint32* pBufferSizeInFramesOut)
+{
+    AudioObjectPropertyAddress propAddress;
+    AudioValueRange bufferSizeRange;
+    UInt32 dataSize;
+    OSStatus status;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pBufferSizeInFramesOut != NULL);
+
+    *pBufferSizeInFramesOut = 0;    /* Safety. */
+
+    propAddress.mSelector = kAudioDevicePropertyBufferFrameSizeRange;
+    propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    dataSize = sizeof(bufferSizeRange);
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, &bufferSizeRange);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    /* This is just a clamp. */
+    if (bufferSizeInFramesIn < bufferSizeRange.mMinimum) {
+        *pBufferSizeInFramesOut = (ma_uint32)bufferSizeRange.mMinimum;
+    } else if (bufferSizeInFramesIn > bufferSizeRange.mMaximum) {
+        *pBufferSizeInFramesOut = (ma_uint32)bufferSizeRange.mMaximum;
+    } else {
+        *pBufferSizeInFramesOut = bufferSizeInFramesIn;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_set_AudioObject_buffer_size_in_frames(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_uint32* pPeriodSizeInOut)
+{
+    ma_result result;
+    ma_uint32 chosenBufferSizeInFrames;
+    AudioObjectPropertyAddress propAddress;
+    UInt32 dataSize;
+    OSStatus status;
+
+    MA_ASSERT(pContext != NULL);
+
+    result = ma_get_AudioObject_closest_buffer_size_in_frames(pContext, deviceObjectID, deviceType, *pPeriodSizeInOut, &chosenBufferSizeInFrames);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Try setting the size of the buffer... If this fails we just use whatever is currently set. */
+    propAddress.mSelector = kAudioDevicePropertyBufferFrameSize;
+    propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+    propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+    ((ma_AudioObjectSetPropertyData_proc)pContext->coreaudio.AudioObjectSetPropertyData)(deviceObjectID, &propAddress, 0, NULL, sizeof(chosenBufferSizeInFrames), &chosenBufferSizeInFrames);
+
+    /* Get the actual size of the buffer. */
+    dataSize = sizeof(*pPeriodSizeInOut);
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(deviceObjectID, &propAddress, 0, NULL, &dataSize, &chosenBufferSizeInFrames);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    *pPeriodSizeInOut = chosenBufferSizeInFrames;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_find_default_AudioObjectID(ma_context* pContext, ma_device_type deviceType, AudioObjectID* pDeviceObjectID)
+{
+    AudioObjectPropertyAddress propAddressDefaultDevice;
+    UInt32 defaultDeviceObjectIDSize = sizeof(AudioObjectID);
+    AudioObjectID defaultDeviceObjectID;
+    OSStatus status;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pDeviceObjectID != NULL);
+
+    /* Safety. */
+    *pDeviceObjectID = 0;
+
+    propAddressDefaultDevice.mScope = kAudioObjectPropertyScopeGlobal;
+    propAddressDefaultDevice.mElement = AUDIO_OBJECT_PROPERTY_ELEMENT;
+    if (deviceType == ma_device_type_playback) {
+        propAddressDefaultDevice.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
+    } else {
+        propAddressDefaultDevice.mSelector = kAudioHardwarePropertyDefaultInputDevice;
+    }
+
+    defaultDeviceObjectIDSize = sizeof(AudioObjectID);
+    status = ((ma_AudioObjectGetPropertyData_proc)pContext->coreaudio.AudioObjectGetPropertyData)(kAudioObjectSystemObject, &propAddressDefaultDevice, 0, NULL, &defaultDeviceObjectIDSize, &defaultDeviceObjectID);
+    if (status == noErr) {
+        *pDeviceObjectID = defaultDeviceObjectID;
+        return MA_SUCCESS;
+    }
+
+    /* If we get here it means we couldn't find the device. */
+    return MA_NO_DEVICE;
+}
+
+static ma_result ma_find_AudioObjectID(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, AudioObjectID* pDeviceObjectID)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pDeviceObjectID != NULL);
+
+    /* Safety. */
+    *pDeviceObjectID = 0;
+
+    if (pDeviceID == NULL) {
+        /* Default device. */
+        return ma_find_default_AudioObjectID(pContext, deviceType, pDeviceObjectID);
+    } else {
+        /* Explicit device. */
+        UInt32 deviceCount;
+        AudioObjectID* pDeviceObjectIDs;
+        ma_result result;
+        UInt32 iDevice;
+
+        result = ma_get_device_object_ids__coreaudio(pContext, &deviceCount, &pDeviceObjectIDs);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        for (iDevice = 0; iDevice < deviceCount; ++iDevice) {
+            AudioObjectID deviceObjectID = pDeviceObjectIDs[iDevice];
+
+            char uid[256];
+            if (ma_get_AudioObject_uid(pContext, deviceObjectID, sizeof(uid), uid) != MA_SUCCESS) {
+                continue;
+            }
+
+            if (deviceType == ma_device_type_playback) {
+                if (ma_does_AudioObject_support_playback(pContext, deviceObjectID)) {
+                    if (strcmp(uid, pDeviceID->coreaudio) == 0) {
+                        *pDeviceObjectID = deviceObjectID;
+                        ma_free(pDeviceObjectIDs, &pContext->allocationCallbacks);
+                        return MA_SUCCESS;
+                    }
+                }
+            } else {
+                if (ma_does_AudioObject_support_capture(pContext, deviceObjectID)) {
+                    if (strcmp(uid, pDeviceID->coreaudio) == 0) {
+                        *pDeviceObjectID = deviceObjectID;
+                        ma_free(pDeviceObjectIDs, &pContext->allocationCallbacks);
+                        return MA_SUCCESS;
+                    }
+                }
+            }
+        }
+
+        ma_free(pDeviceObjectIDs, &pContext->allocationCallbacks);
+    }
+
+    /* If we get here it means we couldn't find the device. */
+    return MA_NO_DEVICE;
+}
+
+
+static ma_result ma_find_best_format__coreaudio(ma_context* pContext, AudioObjectID deviceObjectID, ma_device_type deviceType, ma_format format, ma_uint32 channels, ma_uint32 sampleRate, const AudioStreamBasicDescription* pOrigFormat, AudioStreamBasicDescription* pFormat)
+{
+    UInt32 deviceFormatDescriptionCount;
+    AudioStreamRangedDescription* pDeviceFormatDescriptions;
+    ma_result result;
+    ma_uint32 desiredSampleRate;
+    ma_uint32 desiredChannelCount;
+    ma_format desiredFormat;
+    AudioStreamBasicDescription bestDeviceFormatSoFar;
+    ma_bool32 hasSupportedFormat;
+    UInt32 iFormat;
+
+    result = ma_get_AudioObject_stream_descriptions(pContext, deviceObjectID, deviceType, &deviceFormatDescriptionCount, &pDeviceFormatDescriptions);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    desiredSampleRate = sampleRate;
+    if (desiredSampleRate == 0) {
+        desiredSampleRate = pOrigFormat->mSampleRate;
+    }
+
+    desiredChannelCount = channels;
+    if (desiredChannelCount == 0) {
+        desiredChannelCount = pOrigFormat->mChannelsPerFrame;
+    }
+
+    desiredFormat = format;
+    if (desiredFormat == ma_format_unknown) {
+        result = ma_format_from_AudioStreamBasicDescription(pOrigFormat, &desiredFormat);
+        if (result != MA_SUCCESS || desiredFormat == ma_format_unknown) {
+            desiredFormat = g_maFormatPriorities[0];
+        }
+    }
+
+    /*
+    If we get here it means we don't have an exact match to what the client is asking for. We'll need to find the closest one. The next
+    loop will check for formats that have the same sample rate to what we're asking for. If there is, we prefer that one in all cases.
+    */
+    MA_ZERO_OBJECT(&bestDeviceFormatSoFar);
+
+    hasSupportedFormat = MA_FALSE;
+    for (iFormat = 0; iFormat < deviceFormatDescriptionCount; ++iFormat) {
+        ma_format formatFromDescription;
+        ma_result formatResult = ma_format_from_AudioStreamBasicDescription(&pDeviceFormatDescriptions[iFormat].mFormat, &formatFromDescription);
+        if (formatResult == MA_SUCCESS && formatFromDescription != ma_format_unknown) {
+            hasSupportedFormat = MA_TRUE;
+            bestDeviceFormatSoFar = pDeviceFormatDescriptions[iFormat].mFormat;
+            break;
+        }
+    }
+
+    if (!hasSupportedFormat) {
+        ma_free(pDeviceFormatDescriptions, &pContext->allocationCallbacks);
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+
+    for (iFormat = 0; iFormat < deviceFormatDescriptionCount; ++iFormat) {
+        AudioStreamBasicDescription thisDeviceFormat = pDeviceFormatDescriptions[iFormat].mFormat;
+        ma_format thisSampleFormat;
+        ma_result formatResult;
+        ma_format bestSampleFormatSoFar;
+
+        /* If the format is not supported by miniaudio we need to skip this one entirely. */
+        formatResult = ma_format_from_AudioStreamBasicDescription(&pDeviceFormatDescriptions[iFormat].mFormat, &thisSampleFormat);
+        if (formatResult != MA_SUCCESS || thisSampleFormat == ma_format_unknown) {
+            continue;   /* The format is not supported by miniaudio. Skip. */
+        }
+
+        ma_format_from_AudioStreamBasicDescription(&bestDeviceFormatSoFar, &bestSampleFormatSoFar);
+
+        /* Getting here means the format is supported by miniaudio which makes this format a candidate. */
+        if (thisDeviceFormat.mSampleRate != desiredSampleRate) {
+            /*
+            The sample rate does not match, but this format could still be usable, although it's a very low priority. If the best format
+            so far has an equal sample rate we can just ignore this one.
+            */
+            if (bestDeviceFormatSoFar.mSampleRate == desiredSampleRate) {
+                continue;   /* The best sample rate so far has the same sample rate as what we requested which means it's still the best so far. Skip this format. */
+            } else {
+                /* In this case, neither the best format so far nor this one have the same sample rate. Check the channel count next. */
+                if (thisDeviceFormat.mChannelsPerFrame != desiredChannelCount) {
+                    /* This format has a different sample rate _and_ a different channel count. */
+                    if (bestDeviceFormatSoFar.mChannelsPerFrame == desiredChannelCount) {
+                        continue;   /* No change to the best format. */
+                    } else {
+                        /*
+                        Both this format and the best so far have different sample rates and different channel counts. Whichever has the
+                        best format is the new best.
+                        */
+                        if (ma_get_format_priority_index(thisSampleFormat) < ma_get_format_priority_index(bestSampleFormatSoFar)) {
+                            bestDeviceFormatSoFar = thisDeviceFormat;
+                            continue;
+                        } else {
+                            continue;   /* No change to the best format. */
+                        }
+                    }
+                } else {
+                    /* This format has a different sample rate but the desired channel count. */
+                    if (bestDeviceFormatSoFar.mChannelsPerFrame == desiredChannelCount) {
+                        /* Both this format and the best so far have the desired channel count. Whichever has the best format is the new best. */
+                        if (ma_get_format_priority_index(thisSampleFormat) < ma_get_format_priority_index(bestSampleFormatSoFar)) {
+                            bestDeviceFormatSoFar = thisDeviceFormat;
+                            continue;
+                        } else {
+                            continue;   /* No change to the best format for now. */
+                        }
+                    } else {
+                        /* This format has the desired channel count, but the best so far does not. We have a new best. */
+                        bestDeviceFormatSoFar = thisDeviceFormat;
+                        continue;
+                    }
+                }
+            }
+        } else {
+            /*
+            The sample rates match which makes this format a very high priority contender. If the best format so far has a different
+            sample rate it needs to be replaced with this one.
+            */
+            if (bestDeviceFormatSoFar.mSampleRate != desiredSampleRate) {
+                bestDeviceFormatSoFar = thisDeviceFormat;
+                continue;
+            } else {
+                /* In this case both this format and the best format so far have the same sample rate. Check the channel count next. */
+                if (thisDeviceFormat.mChannelsPerFrame == desiredChannelCount) {
+                    /*
+                    In this case this format has the same channel count as what the client is requesting. If the best format so far has
+                    a different count, this one becomes the new best.
+                    */
+                    if (bestDeviceFormatSoFar.mChannelsPerFrame != desiredChannelCount) {
+                        bestDeviceFormatSoFar = thisDeviceFormat;
+                        continue;
+                    } else {
+                        /* In this case both this format and the best so far have the ideal sample rate and channel count. Check the format. */
+                        if (thisSampleFormat == desiredFormat) {
+                            bestDeviceFormatSoFar = thisDeviceFormat;
+                            break;  /* Found the exact match. */
+                        } else {
+                            /* The formats are different. The new best format is the one with the highest priority format according to miniaudio. */
+                            if (ma_get_format_priority_index(thisSampleFormat) < ma_get_format_priority_index(bestSampleFormatSoFar)) {
+                                bestDeviceFormatSoFar = thisDeviceFormat;
+                                continue;
+                            } else {
+                                continue;   /* No change to the best format for now. */
+                            }
+                        }
+                    }
+                } else {
+                    /*
+                    In this case the channel count is different to what the client has requested. If the best so far has the same channel
+                    count as the requested count then it remains the best.
+                    */
+                    if (bestDeviceFormatSoFar.mChannelsPerFrame == desiredChannelCount) {
+                        continue;
+                    } else {
+                        /*
+                        This is the case where both have the same sample rate (good) but different channel counts. Right now both have about
+                        the same priority, but we need to compare the format now.
+                        */
+                        if (thisSampleFormat == bestSampleFormatSoFar) {
+                            if (ma_get_format_priority_index(thisSampleFormat) < ma_get_format_priority_index(bestSampleFormatSoFar)) {
+                                bestDeviceFormatSoFar = thisDeviceFormat;
+                                continue;
+                            } else {
+                                continue;   /* No change to the best format for now. */
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    *pFormat = bestDeviceFormatSoFar;
+
+    ma_free(pDeviceFormatDescriptions, &pContext->allocationCallbacks);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_get_AudioUnit_channel_map(ma_context* pContext, AudioUnit audioUnit, ma_device_type deviceType, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    AudioUnitScope deviceScope;
+    AudioUnitElement deviceBus;
+    UInt32 channelLayoutSize;
+    OSStatus status;
+    AudioChannelLayout* pChannelLayout;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+    if (deviceType == ma_device_type_playback) {
+        deviceScope = kAudioUnitScope_Input;
+        deviceBus = MA_COREAUDIO_OUTPUT_BUS;
+    } else {
+        deviceScope = kAudioUnitScope_Output;
+        deviceBus = MA_COREAUDIO_INPUT_BUS;
+    }
+
+    status = ((ma_AudioUnitGetPropertyInfo_proc)pContext->coreaudio.AudioUnitGetPropertyInfo)(audioUnit, kAudioUnitProperty_AudioChannelLayout, deviceScope, deviceBus, &channelLayoutSize, NULL);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+    pChannelLayout = (AudioChannelLayout*)ma_malloc(channelLayoutSize, &pContext->allocationCallbacks);
+    if (pChannelLayout == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    status = ((ma_AudioUnitGetProperty_proc)pContext->coreaudio.AudioUnitGetProperty)(audioUnit, kAudioUnitProperty_AudioChannelLayout, deviceScope, deviceBus, pChannelLayout, &channelLayoutSize);
+    if (status != noErr) {
+        ma_free(pChannelLayout, &pContext->allocationCallbacks);
+        return ma_result_from_OSStatus(status);
+    }
+
+    result = ma_get_channel_map_from_AudioChannelLayout(pChannelLayout, pChannelMap, channelMapCap);
+    if (result != MA_SUCCESS) {
+        ma_free(pChannelLayout, &pContext->allocationCallbacks);
+        return result;
+    }
+
+    ma_free(pChannelLayout, &pContext->allocationCallbacks);
+    return MA_SUCCESS;
+}
+#endif /* MA_APPLE_DESKTOP */
+
+
+#if !defined(MA_APPLE_DESKTOP)
+static void ma_AVAudioSessionPortDescription_to_device_info(AVAudioSessionPortDescription* pPortDesc, ma_device_info* pInfo)
+{
+    MA_ZERO_OBJECT(pInfo);
+    ma_strncpy_s(pInfo->name,         sizeof(pInfo->name),         [pPortDesc.portName UTF8String], (size_t)-1);
+    ma_strncpy_s(pInfo->id.coreaudio, sizeof(pInfo->id.coreaudio), [pPortDesc.UID      UTF8String], (size_t)-1);
+}
+#endif
+
+static ma_result ma_context_enumerate_devices__coreaudio(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+#if defined(MA_APPLE_DESKTOP)
+    UInt32 deviceCount;
+    AudioObjectID* pDeviceObjectIDs;
+    AudioObjectID defaultDeviceObjectIDPlayback;
+    AudioObjectID defaultDeviceObjectIDCapture;
+    ma_result result;
+    UInt32 iDevice;
+
+    ma_find_default_AudioObjectID(pContext, ma_device_type_playback, &defaultDeviceObjectIDPlayback);   /* OK if this fails. */
+    ma_find_default_AudioObjectID(pContext, ma_device_type_capture,  &defaultDeviceObjectIDCapture);    /* OK if this fails. */
+
+    result = ma_get_device_object_ids__coreaudio(pContext, &deviceCount, &pDeviceObjectIDs);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    for (iDevice = 0; iDevice < deviceCount; ++iDevice) {
+        AudioObjectID deviceObjectID = pDeviceObjectIDs[iDevice];
+        ma_device_info info;
+
+        MA_ZERO_OBJECT(&info);
+        if (ma_get_AudioObject_uid(pContext, deviceObjectID, sizeof(info.id.coreaudio), info.id.coreaudio) != MA_SUCCESS) {
+            continue;
+        }
+        if (ma_get_AudioObject_name(pContext, deviceObjectID, sizeof(info.name), info.name) != MA_SUCCESS) {
+            continue;
+        }
+
+        if (ma_does_AudioObject_support_playback(pContext, deviceObjectID)) {
+            if (deviceObjectID == defaultDeviceObjectIDPlayback) {
+                info.isDefault = MA_TRUE;
+            }
+
+            if (!callback(pContext, ma_device_type_playback, &info, pUserData)) {
+                break;
+            }
+        }
+        if (ma_does_AudioObject_support_capture(pContext, deviceObjectID)) {
+            if (deviceObjectID == defaultDeviceObjectIDCapture) {
+                info.isDefault = MA_TRUE;
+            }
+
+            if (!callback(pContext, ma_device_type_capture, &info, pUserData)) {
+                break;
+            }
+        }
+    }
+
+    ma_free(pDeviceObjectIDs, &pContext->allocationCallbacks);
+#else
+    ma_device_info info;
+    NSArray *pInputs  = [[[AVAudioSession sharedInstance] currentRoute] inputs];
+    NSArray *pOutputs = [[[AVAudioSession sharedInstance] currentRoute] outputs];
+
+    for (AVAudioSessionPortDescription* pPortDesc in pOutputs) {
+        ma_AVAudioSessionPortDescription_to_device_info(pPortDesc, &info);
+        if (!callback(pContext, ma_device_type_playback, &info, pUserData)) {
+            return MA_SUCCESS;
+        }
+    }
+
+    for (AVAudioSessionPortDescription* pPortDesc in pInputs) {
+        ma_AVAudioSessionPortDescription_to_device_info(pPortDesc, &info);
+        if (!callback(pContext, ma_device_type_capture, &info, pUserData)) {
+            return MA_SUCCESS;
+        }
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__coreaudio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+#if defined(MA_APPLE_DESKTOP)
+    /* Desktop */
+    {
+        AudioObjectID deviceObjectID;
+        AudioObjectID defaultDeviceObjectID;
+        UInt32 streamDescriptionCount;
+        AudioStreamRangedDescription* pStreamDescriptions;
+        UInt32 iStreamDescription;
+        UInt32 sampleRateRangeCount;
+        AudioValueRange* pSampleRateRanges;
+
+        ma_find_default_AudioObjectID(pContext, deviceType, &defaultDeviceObjectID);     /* OK if this fails. */
+
+        result = ma_find_AudioObjectID(pContext, deviceType, pDeviceID, &deviceObjectID);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_get_AudioObject_uid(pContext, deviceObjectID, sizeof(pDeviceInfo->id.coreaudio), pDeviceInfo->id.coreaudio);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_get_AudioObject_name(pContext, deviceObjectID, sizeof(pDeviceInfo->name), pDeviceInfo->name);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        if (deviceObjectID == defaultDeviceObjectID) {
+            pDeviceInfo->isDefault = MA_TRUE;
+        }
+
+        /*
+        There could be a large number of permutations here. Fortunately there is only a single channel count
+        being reported which reduces this quite a bit. For sample rates we're only reporting those that are
+        one of miniaudio's recognized "standard" rates. If there are still more formats than can fit into
+        our fixed sized array we'll just need to truncate them. This is unlikely and will probably only happen
+        if some driver performs software data conversion and therefore reports every possible format and
+        sample rate.
+        */
+        pDeviceInfo->nativeDataFormatCount = 0;
+
+        /* Formats. */
+        {
+            ma_format uniqueFormats[ma_format_count];
+            ma_uint32 uniqueFormatCount = 0;
+            ma_uint32 channels;
+
+            /* Channels. */
+            result = ma_get_AudioObject_channel_count(pContext, deviceObjectID, deviceType, &channels);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+
+            /* Formats. */
+            result = ma_get_AudioObject_stream_descriptions(pContext, deviceObjectID, deviceType, &streamDescriptionCount, &pStreamDescriptions);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+
+            for (iStreamDescription = 0; iStreamDescription < streamDescriptionCount; ++iStreamDescription) {
+                ma_format format;
+                ma_bool32 hasFormatBeenHandled = MA_FALSE;
+                ma_uint32 iOutputFormat;
+                ma_uint32 iSampleRate;
+
+                result = ma_format_from_AudioStreamBasicDescription(&pStreamDescriptions[iStreamDescription].mFormat, &format);
+                if (result != MA_SUCCESS) {
+                    continue;
+                }
+
+                MA_ASSERT(format != ma_format_unknown);
+
+                /* Make sure the format isn't already in the output list. */
+                for (iOutputFormat = 0; iOutputFormat < uniqueFormatCount; ++iOutputFormat) {
+                    if (uniqueFormats[iOutputFormat] == format) {
+                        hasFormatBeenHandled = MA_TRUE;
+                        break;
+                    }
+                }
+
+                /* If we've already handled this format just skip it. */
+                if (hasFormatBeenHandled) {
+                    continue;
+                }
+
+                uniqueFormats[uniqueFormatCount] = format;
+                uniqueFormatCount += 1;
+
+                /* Sample Rates */
+                result = ma_get_AudioObject_sample_rates(pContext, deviceObjectID, deviceType, &sampleRateRangeCount, &pSampleRateRanges);
+                if (result != MA_SUCCESS) {
+                    return result;
+                }
+
+                /*
+                Annoyingly Core Audio reports a sample rate range. We just get all the standard rates that are
+                between this range.
+                */
+                for (iSampleRate = 0; iSampleRate < sampleRateRangeCount; ++iSampleRate) {
+                    ma_uint32 iStandardSampleRate;
+                    for (iStandardSampleRate = 0; iStandardSampleRate < ma_countof(g_maStandardSampleRatePriorities); iStandardSampleRate += 1) {
+                        ma_uint32 standardSampleRate = g_maStandardSampleRatePriorities[iStandardSampleRate];
+                        if (standardSampleRate >= pSampleRateRanges[iSampleRate].mMinimum && standardSampleRate <= pSampleRateRanges[iSampleRate].mMaximum) {
+                            /* We have a new data format. Add it to the list. */
+                            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = format;
+                            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+                            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = standardSampleRate;
+                            pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = 0;
+                            pDeviceInfo->nativeDataFormatCount += 1;
+
+                            if (pDeviceInfo->nativeDataFormatCount >= ma_countof(pDeviceInfo->nativeDataFormats)) {
+                                break;  /* No more room for any more formats. */
+                            }
+                        }
+                    }
+                }
+
+                ma_free(pSampleRateRanges, &pContext->allocationCallbacks);
+
+                if (pDeviceInfo->nativeDataFormatCount >= ma_countof(pDeviceInfo->nativeDataFormats)) {
+                    break;  /* No more room for any more formats. */
+                }
+            }
+
+            ma_free(pStreamDescriptions, &pContext->allocationCallbacks);
+        }
+    }
+#else
+    /* Mobile */
+    {
+        AudioComponentDescription desc;
+        AudioComponent component;
+        AudioUnit audioUnit;
+        OSStatus status;
+        AudioUnitScope formatScope;
+        AudioUnitElement formatElement;
+        AudioStreamBasicDescription bestFormat;
+        UInt32 propSize;
+
+        /* We want to ensure we use a consistent device name to device enumeration. */
+        if (pDeviceID != NULL && pDeviceID->coreaudio[0] != '\0') {
+            ma_bool32 found = MA_FALSE;
+            if (deviceType == ma_device_type_playback) {
+                NSArray *pOutputs = [[[AVAudioSession sharedInstance] currentRoute] outputs];
+                for (AVAudioSessionPortDescription* pPortDesc in pOutputs) {
+                    if (strcmp(pDeviceID->coreaudio, [pPortDesc.UID UTF8String]) == 0) {
+                        ma_AVAudioSessionPortDescription_to_device_info(pPortDesc, pDeviceInfo);
+                        found = MA_TRUE;
+                        break;
+                    }
+                }
+            } else {
+                NSArray *pInputs = [[[AVAudioSession sharedInstance] currentRoute] inputs];
+                for (AVAudioSessionPortDescription* pPortDesc in pInputs) {
+                    if (strcmp(pDeviceID->coreaudio, [pPortDesc.UID UTF8String]) == 0) {
+                        ma_AVAudioSessionPortDescription_to_device_info(pPortDesc, pDeviceInfo);
+                        found = MA_TRUE;
+                        break;
+                    }
+                }
+            }
+
+            if (!found) {
+                return MA_DOES_NOT_EXIST;
+            }
+        } else {
+            if (deviceType == ma_device_type_playback) {
+                ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+            } else {
+                ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+            }
+        }
+
+
+        /*
+        Retrieving device information is more annoying on mobile than desktop. For simplicity I'm locking this down to whatever format is
+        reported on a temporary I/O unit. The problem, however, is that this doesn't return a value for the sample rate which we need to
+        retrieve from the AVAudioSession shared instance.
+        */
+        desc.componentType = kAudioUnitType_Output;
+        desc.componentSubType = kAudioUnitSubType_RemoteIO;
+        desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+        desc.componentFlags = 0;
+        desc.componentFlagsMask = 0;
+
+        component = ((ma_AudioComponentFindNext_proc)pContext->coreaudio.AudioComponentFindNext)(NULL, &desc);
+        if (component == NULL) {
+            return MA_FAILED_TO_INIT_BACKEND;
+        }
+
+        status = ((ma_AudioComponentInstanceNew_proc)pContext->coreaudio.AudioComponentInstanceNew)(component, &audioUnit);
+        if (status != noErr) {
+            return ma_result_from_OSStatus(status);
+        }
+
+        formatScope   = (deviceType == ma_device_type_playback) ? kAudioUnitScope_Input : kAudioUnitScope_Output;
+        formatElement = (deviceType == ma_device_type_playback) ? MA_COREAUDIO_OUTPUT_BUS : MA_COREAUDIO_INPUT_BUS;
+
+        propSize = sizeof(bestFormat);
+        status = ((ma_AudioUnitGetProperty_proc)pContext->coreaudio.AudioUnitGetProperty)(audioUnit, kAudioUnitProperty_StreamFormat, formatScope, formatElement, &bestFormat, &propSize);
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(audioUnit);
+        audioUnit = NULL;
+
+        /* Only a single format is being reported for iOS. */
+        pDeviceInfo->nativeDataFormatCount = 1;
+
+        result = ma_format_from_AudioStreamBasicDescription(&bestFormat, &pDeviceInfo->nativeDataFormats[0].format);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pDeviceInfo->nativeDataFormats[0].channels = bestFormat.mChannelsPerFrame;
+
+        /*
+        It looks like Apple are wanting to push the whole AVAudioSession thing. Thus, we need to use that to determine device settings. To do
+        this we just get the shared instance and inspect.
+        */
+        @autoreleasepool {
+            AVAudioSession* pAudioSession = [AVAudioSession sharedInstance];
+            MA_ASSERT(pAudioSession != NULL);
+
+            pDeviceInfo->nativeDataFormats[0].sampleRate = (ma_uint32)pAudioSession.sampleRate;
+        }
+    }
+#endif
+
+    (void)pDeviceInfo; /* Unused. */
+    return MA_SUCCESS;
+}
+
+static AudioBufferList* ma_allocate_AudioBufferList__coreaudio(ma_uint32 sizeInFrames, ma_format format, ma_uint32 channels, ma_stream_layout layout, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    AudioBufferList* pBufferList;
+    UInt32 audioBufferSizeInBytes;
+    size_t allocationSize;
+
+    MA_ASSERT(sizeInFrames > 0);
+    MA_ASSERT(format != ma_format_unknown);
+    MA_ASSERT(channels > 0);
+
+    allocationSize = sizeof(AudioBufferList) - sizeof(AudioBuffer);  /* Subtract sizeof(AudioBuffer) because that part is dynamically sized. */
+    if (layout == ma_stream_layout_interleaved) {
+        /* Interleaved case. This is the simple case because we just have one buffer. */
+        allocationSize += sizeof(AudioBuffer) * 1;
+    } else {
+        /* Non-interleaved case. This is the more complex case because there's more than one buffer. */
+        allocationSize += sizeof(AudioBuffer) * channels;
+    }
+
+    allocationSize += sizeInFrames * ma_get_bytes_per_frame(format, channels);
+
+    pBufferList = (AudioBufferList*)ma_malloc(allocationSize, pAllocationCallbacks);
+    if (pBufferList == NULL) {
+        return NULL;
+    }
+
+    audioBufferSizeInBytes = (UInt32)(sizeInFrames * ma_get_bytes_per_sample(format));
+
+    if (layout == ma_stream_layout_interleaved) {
+        pBufferList->mNumberBuffers = 1;
+        pBufferList->mBuffers[0].mNumberChannels = channels;
+        pBufferList->mBuffers[0].mDataByteSize   = audioBufferSizeInBytes * channels;
+        pBufferList->mBuffers[0].mData           = (ma_uint8*)pBufferList + sizeof(AudioBufferList);
+    } else {
+        ma_uint32 iBuffer;
+        pBufferList->mNumberBuffers = channels;
+        for (iBuffer = 0; iBuffer < pBufferList->mNumberBuffers; ++iBuffer) {
+            pBufferList->mBuffers[iBuffer].mNumberChannels = 1;
+            pBufferList->mBuffers[iBuffer].mDataByteSize   = audioBufferSizeInBytes;
+            pBufferList->mBuffers[iBuffer].mData           = (ma_uint8*)pBufferList + ((sizeof(AudioBufferList) - sizeof(AudioBuffer)) + (sizeof(AudioBuffer) * channels)) + (audioBufferSizeInBytes * iBuffer);
+        }
+    }
+
+    return pBufferList;
+}
+
+static ma_result ma_device_realloc_AudioBufferList__coreaudio(ma_device* pDevice, ma_uint32 sizeInFrames, ma_format format, ma_uint32 channels, ma_stream_layout layout)
+{
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(format != ma_format_unknown);
+    MA_ASSERT(channels > 0);
+
+    /* Only resize the buffer if necessary. */
+    if (pDevice->coreaudio.audioBufferCapInFrames < sizeInFrames) {
+        AudioBufferList* pNewAudioBufferList;
+
+        pNewAudioBufferList = ma_allocate_AudioBufferList__coreaudio(sizeInFrames, format, channels, layout, &pDevice->pContext->allocationCallbacks);
+        if (pNewAudioBufferList == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        /* At this point we'll have a new AudioBufferList and we can free the old one. */
+        ma_free(pDevice->coreaudio.pAudioBufferList, &pDevice->pContext->allocationCallbacks);
+        pDevice->coreaudio.pAudioBufferList = pNewAudioBufferList;
+        pDevice->coreaudio.audioBufferCapInFrames = sizeInFrames;
+    }
+
+    /* Getting here means the capacity of the audio is fine. */
+    return MA_SUCCESS;
+}
+
+
+static OSStatus ma_on_output__coreaudio(void* pUserData, AudioUnitRenderActionFlags* pActionFlags, const AudioTimeStamp* pTimeStamp, UInt32 busNumber, UInt32 frameCount, AudioBufferList* pBufferList)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    ma_stream_layout layout;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "INFO: Output Callback: busNumber=%d, frameCount=%d, mNumberBuffers=%d\n", (int)busNumber, (int)frameCount, (int)pBufferList->mNumberBuffers);*/
+
+    /* We need to check whether or not we are outputting interleaved or non-interleaved samples. The way we do this is slightly different for each type. */
+    layout = ma_stream_layout_interleaved;
+    if (pBufferList->mBuffers[0].mNumberChannels != pDevice->playback.internalChannels) {
+        layout = ma_stream_layout_deinterleaved;
+    }
+
+    if (layout == ma_stream_layout_interleaved) {
+        /* For now we can assume everything is interleaved. */
+        UInt32 iBuffer;
+        for (iBuffer = 0; iBuffer < pBufferList->mNumberBuffers; ++iBuffer) {
+            if (pBufferList->mBuffers[iBuffer].mNumberChannels == pDevice->playback.internalChannels) {
+                ma_uint32 frameCountForThisBuffer = pBufferList->mBuffers[iBuffer].mDataByteSize / ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+                if (frameCountForThisBuffer > 0) {
+                    ma_device_handle_backend_data_callback(pDevice, pBufferList->mBuffers[iBuffer].mData, NULL, frameCountForThisBuffer);
+                }
+
+                /*a_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "  frameCount=%d, mNumberChannels=%d, mDataByteSize=%d\n", (int)frameCount, (int)pBufferList->mBuffers[iBuffer].mNumberChannels, (int)pBufferList->mBuffers[iBuffer].mDataByteSize);*/
+            } else {
+                /*
+                This case is where the number of channels in the output buffer do not match our internal channels. It could mean that it's
+                not interleaved, in which case we can't handle right now since miniaudio does not yet support non-interleaved streams. We just
+                output silence here.
+                */
+                MA_ZERO_MEMORY(pBufferList->mBuffers[iBuffer].mData, pBufferList->mBuffers[iBuffer].mDataByteSize);
+                /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "  WARNING: Outputting silence. frameCount=%d, mNumberChannels=%d, mDataByteSize=%d\n", (int)frameCount, (int)pBufferList->mBuffers[iBuffer].mNumberChannels, (int)pBufferList->mBuffers[iBuffer].mDataByteSize);*/
+            }
+        }
+    } else {
+        /* This is the deinterleaved case. We need to update each buffer in groups of internalChannels. This assumes each buffer is the same size. */
+        MA_ASSERT(pDevice->playback.internalChannels <= MA_MAX_CHANNELS);   /* This should heve been validated at initialization time. */
+
+        /*
+        For safety we'll check that the internal channels is a multiple of the buffer count. If it's not it means something
+        very strange has happened and we're not going to support it.
+        */
+        if ((pBufferList->mNumberBuffers % pDevice->playback.internalChannels) == 0) {
+            ma_uint8 tempBuffer[4096];
+            UInt32 iBuffer;
+
+            for (iBuffer = 0; iBuffer < pBufferList->mNumberBuffers; iBuffer += pDevice->playback.internalChannels) {
+                ma_uint32 frameCountPerBuffer = pBufferList->mBuffers[iBuffer].mDataByteSize / ma_get_bytes_per_sample(pDevice->playback.internalFormat);
+                ma_uint32 framesRemaining = frameCountPerBuffer;
+
+                while (framesRemaining > 0) {
+                    void* ppDeinterleavedBuffers[MA_MAX_CHANNELS];
+                    ma_uint32 iChannel;
+                    ma_uint32 framesToRead = sizeof(tempBuffer) / ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+                    if (framesToRead > framesRemaining) {
+                        framesToRead = framesRemaining;
+                    }
+
+                    ma_device_handle_backend_data_callback(pDevice, tempBuffer, NULL, framesToRead);
+
+                    for (iChannel = 0; iChannel < pDevice->playback.internalChannels; ++iChannel) {
+                        ppDeinterleavedBuffers[iChannel] = (void*)ma_offset_ptr(pBufferList->mBuffers[iBuffer+iChannel].mData, (frameCountPerBuffer - framesRemaining) * ma_get_bytes_per_sample(pDevice->playback.internalFormat));
+                    }
+
+                    ma_deinterleave_pcm_frames(pDevice->playback.internalFormat, pDevice->playback.internalChannels, framesToRead, tempBuffer, ppDeinterleavedBuffers);
+
+                    framesRemaining -= framesToRead;
+                }
+            }
+        }
+    }
+
+    (void)pActionFlags;
+    (void)pTimeStamp;
+    (void)busNumber;
+    (void)frameCount;
+
+    return noErr;
+}
+
+static OSStatus ma_on_input__coreaudio(void* pUserData, AudioUnitRenderActionFlags* pActionFlags, const AudioTimeStamp* pTimeStamp, UInt32 busNumber, UInt32 frameCount, AudioBufferList* pUnusedBufferList)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    AudioBufferList* pRenderedBufferList;
+    ma_result result;
+    ma_stream_layout layout;
+    ma_uint32 iBuffer;
+    OSStatus status;
+
+    MA_ASSERT(pDevice != NULL);
+
+    pRenderedBufferList = (AudioBufferList*)pDevice->coreaudio.pAudioBufferList;
+    MA_ASSERT(pRenderedBufferList);
+
+    /* We need to check whether or not we are outputting interleaved or non-interleaved samples. The way we do this is slightly different for each type. */
+    layout = ma_stream_layout_interleaved;
+    if (pRenderedBufferList->mBuffers[0].mNumberChannels != pDevice->capture.internalChannels) {
+        layout = ma_stream_layout_deinterleaved;
+    }
+
+    /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "INFO: Input Callback: busNumber=%d, frameCount=%d, mNumberBuffers=%d\n", (int)busNumber, (int)frameCount, (int)pRenderedBufferList->mNumberBuffers);*/
+
+    /*
+    There has been a situation reported where frame count passed into this function is greater than the capacity of
+    our capture buffer. There doesn't seem to be a reliable way to determine what the maximum frame count will be,
+    so we need to instead resort to dynamically reallocating our buffer to ensure it's large enough to capture the
+    number of frames requested by this callback.
+    */
+    result = ma_device_realloc_AudioBufferList__coreaudio(pDevice, frameCount, pDevice->capture.internalFormat, pDevice->capture.internalChannels, layout);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "Failed to allocate AudioBufferList for capture.\n");
+        return noErr;
+    }
+
+    pRenderedBufferList = (AudioBufferList*)pDevice->coreaudio.pAudioBufferList;
+    MA_ASSERT(pRenderedBufferList);
+
+    /*
+    When you call AudioUnitRender(), Core Audio tries to be helpful by setting the mDataByteSize to the number of bytes
+    that were actually rendered. The problem with this is that the next call can fail with -50 due to the size no longer
+    being set to the capacity of the buffer, but instead the size in bytes of the previous render. This will cause a
+    problem when a future call to this callback specifies a larger number of frames.
+
+    To work around this we need to explicitly set the size of each buffer to their respective size in bytes.
+    */
+    for (iBuffer = 0; iBuffer < pRenderedBufferList->mNumberBuffers; ++iBuffer) {
+        pRenderedBufferList->mBuffers[iBuffer].mDataByteSize = pDevice->coreaudio.audioBufferCapInFrames * ma_get_bytes_per_sample(pDevice->capture.internalFormat) * pRenderedBufferList->mBuffers[iBuffer].mNumberChannels;
+    }
+
+    status = ((ma_AudioUnitRender_proc)pDevice->pContext->coreaudio.AudioUnitRender)((AudioUnit)pDevice->coreaudio.audioUnitCapture, pActionFlags, pTimeStamp, busNumber, frameCount, pRenderedBufferList);
+    if (status != noErr) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "  ERROR: AudioUnitRender() failed with %d.\n", (int)status);
+        return status;
+    }
+
+    if (layout == ma_stream_layout_interleaved) {
+        for (iBuffer = 0; iBuffer < pRenderedBufferList->mNumberBuffers; ++iBuffer) {
+            if (pRenderedBufferList->mBuffers[iBuffer].mNumberChannels == pDevice->capture.internalChannels) {
+                ma_device_handle_backend_data_callback(pDevice, NULL, pRenderedBufferList->mBuffers[iBuffer].mData, frameCount);
+                /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "  mDataByteSize=%d.\n", (int)pRenderedBufferList->mBuffers[iBuffer].mDataByteSize);*/
+            } else {
+                /*
+                This case is where the number of channels in the output buffer do not match our internal channels. It could mean that it's
+                not interleaved, in which case we can't handle right now since miniaudio does not yet support non-interleaved streams.
+                */
+                ma_uint8 silentBuffer[4096];
+                ma_uint32 framesRemaining;
+
+                MA_ZERO_MEMORY(silentBuffer, sizeof(silentBuffer));
+
+                framesRemaining = frameCount;
+                while (framesRemaining > 0) {
+                    ma_uint32 framesToSend = sizeof(silentBuffer) / ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+                    if (framesToSend > framesRemaining) {
+                        framesToSend = framesRemaining;
+                    }
+
+                    ma_device_handle_backend_data_callback(pDevice, NULL, silentBuffer, framesToSend);
+
+                    framesRemaining -= framesToSend;
+                }
+
+                /*ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_DEBUG, "  WARNING: Outputting silence. frameCount=%d, mNumberChannels=%d, mDataByteSize=%d\n", (int)frameCount, (int)pRenderedBufferList->mBuffers[iBuffer].mNumberChannels, (int)pRenderedBufferList->mBuffers[iBuffer].mDataByteSize);*/
+            }
+        }
+    } else {
+        /* This is the deinterleaved case. We need to interleave the audio data before sending it to the client. This assumes each buffer is the same size. */
+        MA_ASSERT(pDevice->capture.internalChannels <= MA_MAX_CHANNELS);    /* This should have been validated at initialization time. */
+
+        /*
+        For safety we'll check that the internal channels is a multiple of the buffer count. If it's not it means something
+        very strange has happened and we're not going to support it.
+        */
+        if ((pRenderedBufferList->mNumberBuffers % pDevice->capture.internalChannels) == 0) {
+            ma_uint8 tempBuffer[4096];
+            for (iBuffer = 0; iBuffer < pRenderedBufferList->mNumberBuffers; iBuffer += pDevice->capture.internalChannels) {
+                ma_uint32 framesRemaining = frameCount;
+                while (framesRemaining > 0) {
+                    void* ppDeinterleavedBuffers[MA_MAX_CHANNELS];
+                    ma_uint32 iChannel;
+                    ma_uint32 framesToSend = sizeof(tempBuffer) / ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+                    if (framesToSend > framesRemaining) {
+                        framesToSend = framesRemaining;
+                    }
+
+                    for (iChannel = 0; iChannel < pDevice->capture.internalChannels; ++iChannel) {
+                        ppDeinterleavedBuffers[iChannel] = (void*)ma_offset_ptr(pRenderedBufferList->mBuffers[iBuffer+iChannel].mData, (frameCount - framesRemaining) * ma_get_bytes_per_sample(pDevice->capture.internalFormat));
+                    }
+
+                    ma_interleave_pcm_frames(pDevice->capture.internalFormat, pDevice->capture.internalChannels, framesToSend, (const void**)ppDeinterleavedBuffers, tempBuffer);
+                    ma_device_handle_backend_data_callback(pDevice, NULL, tempBuffer, framesToSend);
+
+                    framesRemaining -= framesToSend;
+                }
+            }
+        }
+    }
+
+    (void)pActionFlags;
+    (void)pTimeStamp;
+    (void)busNumber;
+    (void)frameCount;
+    (void)pUnusedBufferList;
+
+    return noErr;
+}
+
+static void on_start_stop__coreaudio(void* pUserData, AudioUnit audioUnit, AudioUnitPropertyID propertyID, AudioUnitScope scope, AudioUnitElement element)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    /* Don't do anything if it looks like we're just reinitializing due to a device switch. */
+    if (((audioUnit == pDevice->coreaudio.audioUnitPlayback) && pDevice->coreaudio.isSwitchingPlaybackDevice) ||
+        ((audioUnit == pDevice->coreaudio.audioUnitCapture)  && pDevice->coreaudio.isSwitchingCaptureDevice)) {
+        return;
+    }
+
+    /*
+    There's been a report of a deadlock here when triggered by ma_device_uninit(). It looks like
+    AudioUnitGetProprty (called below) and AudioComponentInstanceDispose (called in ma_device_uninit)
+    can try waiting on the same lock. I'm going to try working around this by not calling any Core
+    Audio APIs in the callback when the device has been stopped or uninitialized.
+    */
+    if (ma_device_get_state(pDevice) == ma_device_state_uninitialized || ma_device_get_state(pDevice) == ma_device_state_stopping || ma_device_get_state(pDevice) == ma_device_state_stopped) {
+        ma_device__on_notification_stopped(pDevice);
+    } else {
+        UInt32 isRunning;
+        UInt32 isRunningSize = sizeof(isRunning);
+        OSStatus status = ((ma_AudioUnitGetProperty_proc)pDevice->pContext->coreaudio.AudioUnitGetProperty)(audioUnit, kAudioOutputUnitProperty_IsRunning, scope, element, &isRunning, &isRunningSize);
+        if (status != noErr) {
+            goto done; /* Don't really know what to do in this case... just ignore it, I suppose... */
+        }
+
+        if (!isRunning) {
+            /*
+            The stop event is a bit annoying in Core Audio because it will be called when we automatically switch the default device. Some scenarios to consider:
+
+            1) When the device is unplugged, this will be called _before_ the default device change notification.
+            2) When the device is changed via the default device change notification, this will be called _after_ the switch.
+
+            For case #1, we just check if there's a new default device available. If so, we just ignore the stop event. For case #2 we check a flag.
+            */
+            if (((audioUnit == pDevice->coreaudio.audioUnitPlayback) && pDevice->coreaudio.isDefaultPlaybackDevice) ||
+                ((audioUnit == pDevice->coreaudio.audioUnitCapture)  && pDevice->coreaudio.isDefaultCaptureDevice)) {
+                /*
+                It looks like the device is switching through an external event, such as the user unplugging the device or changing the default device
+                via the operating system's sound settings. If we're re-initializing the device, we just terminate because we want the stopping of the
+                device to be seamless to the client (we don't want them receiving the stopped event and thinking that the device has stopped when it
+                hasn't!).
+                */
+                if (((audioUnit == pDevice->coreaudio.audioUnitPlayback) && pDevice->coreaudio.isSwitchingPlaybackDevice) ||
+                    ((audioUnit == pDevice->coreaudio.audioUnitCapture)  && pDevice->coreaudio.isSwitchingCaptureDevice)) {
+                    goto done;
+                }
+
+                /*
+                Getting here means the device is not reinitializing which means it may have been unplugged. From what I can see, it looks like Core Audio
+                will try switching to the new default device seamlessly. We need to somehow find a way to determine whether or not Core Audio will most
+                likely be successful in switching to the new device.
+
+                TODO: Try to predict if Core Audio will switch devices. If not, the stopped callback needs to be posted.
+                */
+                goto done;
+            }
+
+            /* Getting here means we need to stop the device. */
+            ma_device__on_notification_stopped(pDevice);
+        }
+    }
+
+    (void)propertyID; /* Unused. */
+
+done:
+    /* Always signal the stop event. It's possible for the "else" case to get hit which can happen during an interruption. */
+    ma_event_signal(&pDevice->coreaudio.stopEvent);
+}
+
+#if defined(MA_APPLE_DESKTOP)
+static ma_spinlock g_DeviceTrackingInitLock_CoreAudio = 0;  /* A spinlock for mutal exclusion of the init/uninit of the global tracking data. Initialization to 0 is what we need. */
+static ma_uint32   g_DeviceTrackingInitCounter_CoreAudio = 0;
+static ma_mutex    g_DeviceTrackingMutex_CoreAudio;
+static ma_device** g_ppTrackedDevices_CoreAudio = NULL;
+static ma_uint32   g_TrackedDeviceCap_CoreAudio = 0;
+static ma_uint32   g_TrackedDeviceCount_CoreAudio = 0;
+
+static OSStatus ma_default_device_changed__coreaudio(AudioObjectID objectID, UInt32 addressCount, const AudioObjectPropertyAddress* pAddresses, void* pUserData)
+{
+    ma_device_type deviceType;
+
+    /* Not sure if I really need to check this, but it makes me feel better. */
+    if (addressCount == 0) {
+        return noErr;
+    }
+
+    if (pAddresses[0].mSelector == kAudioHardwarePropertyDefaultOutputDevice) {
+        deviceType = ma_device_type_playback;
+    } else if (pAddresses[0].mSelector == kAudioHardwarePropertyDefaultInputDevice) {
+        deviceType = ma_device_type_capture;
+    } else {
+        return noErr;   /* Should never hit this. */
+    }
+
+    ma_mutex_lock(&g_DeviceTrackingMutex_CoreAudio);
+    {
+        ma_uint32 iDevice;
+        for (iDevice = 0; iDevice < g_TrackedDeviceCount_CoreAudio; iDevice += 1) {
+            ma_result reinitResult;
+            ma_device* pDevice;
+
+            pDevice = g_ppTrackedDevices_CoreAudio[iDevice];
+            if (pDevice->type == deviceType || pDevice->type == ma_device_type_duplex) {
+                if (deviceType == ma_device_type_playback) {
+                    pDevice->coreaudio.isSwitchingPlaybackDevice = MA_TRUE;
+                    reinitResult = ma_device_reinit_internal__coreaudio(pDevice, deviceType, MA_TRUE);
+                    pDevice->coreaudio.isSwitchingPlaybackDevice = MA_FALSE;
+                } else {
+                    pDevice->coreaudio.isSwitchingCaptureDevice = MA_TRUE;
+                    reinitResult = ma_device_reinit_internal__coreaudio(pDevice, deviceType, MA_TRUE);
+                    pDevice->coreaudio.isSwitchingCaptureDevice = MA_FALSE;
+                }
+
+                if (reinitResult == MA_SUCCESS) {
+                    ma_device__post_init_setup(pDevice, deviceType);
+
+                    /* Restart the device if required. If this fails we need to stop the device entirely. */
+                    if (ma_device_get_state(pDevice) == ma_device_state_started) {
+                        OSStatus status;
+                        if (deviceType == ma_device_type_playback) {
+                            status = ((ma_AudioOutputUnitStart_proc)pDevice->pContext->coreaudio.AudioOutputUnitStart)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+                            if (status != noErr) {
+                                if (pDevice->type == ma_device_type_duplex) {
+                                    ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+                                }
+                                ma_device__set_state(pDevice, ma_device_state_stopped);
+                            }
+                        } else if (deviceType == ma_device_type_capture) {
+                            status = ((ma_AudioOutputUnitStart_proc)pDevice->pContext->coreaudio.AudioOutputUnitStart)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+                            if (status != noErr) {
+                                if (pDevice->type == ma_device_type_duplex) {
+                                    ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+                                }
+                                ma_device__set_state(pDevice, ma_device_state_stopped);
+                            }
+                        }
+                    }
+
+                    ma_device__on_notification_rerouted(pDevice);
+                }
+            }
+        }
+    }
+    ma_mutex_unlock(&g_DeviceTrackingMutex_CoreAudio);
+
+    /* Unused parameters. */
+    (void)objectID;
+    (void)pUserData;
+
+    return noErr;
+}
+
+static ma_result ma_context__init_device_tracking__coreaudio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+
+    ma_spinlock_lock(&g_DeviceTrackingInitLock_CoreAudio);
+    {
+        /* Don't do anything if we've already initializd device tracking. */
+        if (g_DeviceTrackingInitCounter_CoreAudio == 0) {
+            AudioObjectPropertyAddress propAddress;
+            propAddress.mScope    = kAudioObjectPropertyScopeGlobal;
+            propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+            ma_mutex_init(&g_DeviceTrackingMutex_CoreAudio);
+
+            propAddress.mSelector = kAudioHardwarePropertyDefaultInputDevice;
+            ((ma_AudioObjectAddPropertyListener_proc)pContext->coreaudio.AudioObjectAddPropertyListener)(kAudioObjectSystemObject, &propAddress, &ma_default_device_changed__coreaudio, NULL);
+
+            propAddress.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
+            ((ma_AudioObjectAddPropertyListener_proc)pContext->coreaudio.AudioObjectAddPropertyListener)(kAudioObjectSystemObject, &propAddress, &ma_default_device_changed__coreaudio, NULL);
+
+        }
+        g_DeviceTrackingInitCounter_CoreAudio += 1;
+    }
+    ma_spinlock_unlock(&g_DeviceTrackingInitLock_CoreAudio);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context__uninit_device_tracking__coreaudio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+
+    ma_spinlock_lock(&g_DeviceTrackingInitLock_CoreAudio);
+    {
+        if (g_DeviceTrackingInitCounter_CoreAudio > 0)
+            g_DeviceTrackingInitCounter_CoreAudio -= 1;
+
+        if (g_DeviceTrackingInitCounter_CoreAudio == 0) {
+            AudioObjectPropertyAddress propAddress;
+            propAddress.mScope    = kAudioObjectPropertyScopeGlobal;
+            propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+            propAddress.mSelector = kAudioHardwarePropertyDefaultInputDevice;
+            ((ma_AudioObjectRemovePropertyListener_proc)pContext->coreaudio.AudioObjectRemovePropertyListener)(kAudioObjectSystemObject, &propAddress, &ma_default_device_changed__coreaudio, NULL);
+
+            propAddress.mSelector = kAudioHardwarePropertyDefaultOutputDevice;
+            ((ma_AudioObjectRemovePropertyListener_proc)pContext->coreaudio.AudioObjectRemovePropertyListener)(kAudioObjectSystemObject, &propAddress, &ma_default_device_changed__coreaudio, NULL);
+
+            /* At this point there should be no tracked devices. If not there's an error somewhere. */
+            if (g_ppTrackedDevices_CoreAudio != NULL) {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "You have uninitialized all contexts while an associated device is still active.");
+                ma_spinlock_unlock(&g_DeviceTrackingInitLock_CoreAudio);
+                return MA_INVALID_OPERATION;
+            }
+
+            ma_mutex_uninit(&g_DeviceTrackingMutex_CoreAudio);
+        }
+    }
+    ma_spinlock_unlock(&g_DeviceTrackingInitLock_CoreAudio);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device__track__coreaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    ma_mutex_lock(&g_DeviceTrackingMutex_CoreAudio);
+    {
+        /* Allocate memory if required. */
+        if (g_TrackedDeviceCap_CoreAudio <= g_TrackedDeviceCount_CoreAudio) {
+            ma_uint32 newCap;
+            ma_device** ppNewDevices;
+
+            newCap = g_TrackedDeviceCap_CoreAudio * 2;
+            if (newCap == 0) {
+                newCap = 1;
+            }
+
+            ppNewDevices = (ma_device**)ma_realloc(g_ppTrackedDevices_CoreAudio, sizeof(*g_ppTrackedDevices_CoreAudio)*newCap, &pDevice->pContext->allocationCallbacks);
+            if (ppNewDevices == NULL) {
+                ma_mutex_unlock(&g_DeviceTrackingMutex_CoreAudio);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            g_ppTrackedDevices_CoreAudio = ppNewDevices;
+            g_TrackedDeviceCap_CoreAudio = newCap;
+        }
+
+        g_ppTrackedDevices_CoreAudio[g_TrackedDeviceCount_CoreAudio] = pDevice;
+        g_TrackedDeviceCount_CoreAudio += 1;
+    }
+    ma_mutex_unlock(&g_DeviceTrackingMutex_CoreAudio);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device__untrack__coreaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    ma_mutex_lock(&g_DeviceTrackingMutex_CoreAudio);
+    {
+        ma_uint32 iDevice;
+        for (iDevice = 0; iDevice < g_TrackedDeviceCount_CoreAudio; iDevice += 1) {
+            if (g_ppTrackedDevices_CoreAudio[iDevice] == pDevice) {
+                /* We've found the device. We now need to remove it from the list. */
+                ma_uint32 jDevice;
+                for (jDevice = iDevice; jDevice < g_TrackedDeviceCount_CoreAudio-1; jDevice += 1) {
+                    g_ppTrackedDevices_CoreAudio[jDevice] = g_ppTrackedDevices_CoreAudio[jDevice+1];
+                }
+
+                g_TrackedDeviceCount_CoreAudio -= 1;
+
+                /* If there's nothing else in the list we need to free memory. */
+                if (g_TrackedDeviceCount_CoreAudio == 0) {
+                    ma_free(g_ppTrackedDevices_CoreAudio, &pDevice->pContext->allocationCallbacks);
+                    g_ppTrackedDevices_CoreAudio = NULL;
+                    g_TrackedDeviceCap_CoreAudio = 0;
+                }
+
+                break;
+            }
+        }
+    }
+    ma_mutex_unlock(&g_DeviceTrackingMutex_CoreAudio);
+
+    return MA_SUCCESS;
+}
+#endif
+
+#if defined(MA_APPLE_MOBILE)
+@interface ma_ios_notification_handler:NSObject {
+    ma_device* m_pDevice;
+}
+@end
+
+@implementation ma_ios_notification_handler
+-(id)init:(ma_device*)pDevice
+{
+    self = [super init];
+    m_pDevice = pDevice;
+
+    /* For route changes. */
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handle_route_change:) name:AVAudioSessionRouteChangeNotification object:[AVAudioSession sharedInstance]];
+
+    /* For interruptions. */
+    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handle_interruption:) name:AVAudioSessionInterruptionNotification object:[AVAudioSession sharedInstance]];
+
+    return self;
+}
+
+-(void)dealloc
+{
+    [self remove_handler];
+
+    #if defined(__has_feature)
+        #if !__has_feature(objc_arc)
+            [super dealloc];
+        #endif
+    #endif
+}
+
+-(void)remove_handler
+{
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:AVAudioSessionRouteChangeNotification object:nil];
+    [[NSNotificationCenter defaultCenter] removeObserver:self name:AVAudioSessionInterruptionNotification object:nil];
+}
+
+-(void)handle_interruption:(NSNotification*)pNotification
+{
+    NSInteger type = [[[pNotification userInfo] objectForKey:AVAudioSessionInterruptionTypeKey] integerValue];
+    switch (type)
+    {
+        case AVAudioSessionInterruptionTypeBegan:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Interruption: AVAudioSessionInterruptionTypeBegan\n");
+
+            /*
+            Core Audio will have stopped the internal device automatically, but we need explicitly
+            stop it at a higher level to ensure miniaudio-specific state is updated for consistency.
+            */
+            ma_device_stop(m_pDevice);
+
+            /*
+            Fire the notification after the device has been stopped to ensure it's in the correct
+            state when the notification handler is invoked.
+            */
+            ma_device__on_notification_interruption_began(m_pDevice);
+        } break;
+
+        case AVAudioSessionInterruptionTypeEnded:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Interruption: AVAudioSessionInterruptionTypeEnded\n");
+            ma_device__on_notification_interruption_ended(m_pDevice);
+        } break;
+    }
+}
+
+-(void)handle_route_change:(NSNotification*)pNotification
+{
+    AVAudioSession* pSession = [AVAudioSession sharedInstance];
+
+    NSInteger reason = [[[pNotification userInfo] objectForKey:AVAudioSessionRouteChangeReasonKey] integerValue];
+    switch (reason)
+    {
+        case AVAudioSessionRouteChangeReasonOldDeviceUnavailable:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonOldDeviceUnavailable\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonNewDeviceAvailable:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonNewDeviceAvailable\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonNoSuitableRouteForCategory:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonNoSuitableRouteForCategory\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonWakeFromSleep:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonWakeFromSleep\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonOverride:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonOverride\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonCategoryChange:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonCategoryChange\n");
+        } break;
+
+        case AVAudioSessionRouteChangeReasonUnknown:
+        default:
+        {
+            ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_INFO, "[Core Audio] Route Changed: AVAudioSessionRouteChangeReasonUnknown\n");
+        } break;
+    }
+
+    ma_log_postf(ma_device_get_log(m_pDevice), MA_LOG_LEVEL_DEBUG, "[Core Audio] Changing Route. inputNumberChannels=%d; outputNumberOfChannels=%d\n", (int)pSession.inputNumberOfChannels, (int)pSession.outputNumberOfChannels);
+
+    /* Let the application know about the route change. */
+    ma_device__on_notification_rerouted(m_pDevice);
+}
+@end
+#endif
+
+static ma_result ma_device_uninit__coreaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_uninitialized);
+
+#if defined(MA_APPLE_DESKTOP)
+    /*
+    Make sure we're no longer tracking the device. It doesn't matter if we call this for a non-default device because it'll
+    just gracefully ignore it.
+    */
+    ma_device__untrack__coreaudio(pDevice);
+#endif
+#if defined(MA_APPLE_MOBILE)
+    if (pDevice->coreaudio.pNotificationHandler != NULL) {
+        ma_ios_notification_handler* pNotificationHandler = (MA_BRIDGE_TRANSFER ma_ios_notification_handler*)pDevice->coreaudio.pNotificationHandler;
+        [pNotificationHandler remove_handler];
+    }
+#endif
+
+    if (pDevice->coreaudio.audioUnitCapture != NULL) {
+        ((ma_AudioComponentInstanceDispose_proc)pDevice->pContext->coreaudio.AudioComponentInstanceDispose)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+    }
+    if (pDevice->coreaudio.audioUnitPlayback != NULL) {
+        ((ma_AudioComponentInstanceDispose_proc)pDevice->pContext->coreaudio.AudioComponentInstanceDispose)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+    }
+
+    if (pDevice->coreaudio.pAudioBufferList) {
+        ma_free(pDevice->coreaudio.pAudioBufferList, &pDevice->pContext->allocationCallbacks);
+    }
+
+    return MA_SUCCESS;
+}
+
+typedef struct
+{
+    ma_bool32 allowNominalSampleRateChange;
+
+    /* Input. */
+    ma_format formatIn;
+    ma_uint32 channelsIn;
+    ma_uint32 sampleRateIn;
+    ma_channel channelMapIn[MA_MAX_CHANNELS];
+    ma_uint32 periodSizeInFramesIn;
+    ma_uint32 periodSizeInMillisecondsIn;
+    ma_uint32 periodsIn;
+    ma_share_mode shareMode;
+    ma_performance_profile performanceProfile;
+    ma_bool32 registerStopEvent;
+
+    /* Output. */
+#if defined(MA_APPLE_DESKTOP)
+    AudioObjectID deviceObjectID;
+#endif
+    AudioComponent component;
+    AudioUnit audioUnit;
+    AudioBufferList* pAudioBufferList;  /* Only used for input devices. */
+    ma_format formatOut;
+    ma_uint32 channelsOut;
+    ma_uint32 sampleRateOut;
+    ma_channel channelMapOut[MA_MAX_CHANNELS];
+    ma_uint32 periodSizeInFramesOut;
+    ma_uint32 periodsOut;
+    char deviceName[256];
+} ma_device_init_internal_data__coreaudio;
+
+static ma_result ma_device_init_internal__coreaudio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_init_internal_data__coreaudio* pData, void* pDevice_DoNotReference)   /* <-- pDevice is typed as void* intentionally so as to avoid accidentally referencing it. */
+{
+    ma_result result;
+    OSStatus status;
+    UInt32 enableIOFlag;
+    AudioStreamBasicDescription bestFormat;
+    UInt32 actualPeriodSizeInFrames;
+    AURenderCallbackStruct callbackInfo;
+#if defined(MA_APPLE_DESKTOP)
+    AudioObjectID deviceObjectID;
+#endif
+
+    /* This API should only be used for a single device type: playback or capture. No full-duplex mode. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(deviceType == ma_device_type_playback || deviceType == ma_device_type_capture);
+
+#if defined(MA_APPLE_DESKTOP)
+    pData->deviceObjectID = 0;
+#endif
+    pData->component = NULL;
+    pData->audioUnit = NULL;
+    pData->pAudioBufferList = NULL;
+
+#if defined(MA_APPLE_DESKTOP)
+    result = ma_find_AudioObjectID(pContext, deviceType, pDeviceID, &deviceObjectID);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pData->deviceObjectID = deviceObjectID;
+#endif
+
+    /* Core audio doesn't really use the notion of a period so we can leave this unmodified, but not too over the top. */
+    pData->periodsOut = pData->periodsIn;
+    if (pData->periodsOut == 0) {
+        pData->periodsOut = MA_DEFAULT_PERIODS;
+    }
+    if (pData->periodsOut > 16) {
+        pData->periodsOut = 16;
+    }
+
+
+    /* Audio unit. */
+    status = ((ma_AudioComponentInstanceNew_proc)pContext->coreaudio.AudioComponentInstanceNew)((AudioComponent)pContext->coreaudio.component, (AudioUnit*)&pData->audioUnit);
+    if (status != noErr) {
+        return ma_result_from_OSStatus(status);
+    }
+
+
+    /* The input/output buses need to be explicitly enabled and disabled. We set the flag based on the output unit first, then we just swap it for input. */
+    enableIOFlag = 1;
+    if (deviceType == ma_device_type_capture) {
+        enableIOFlag = 0;
+    }
+
+    status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, MA_COREAUDIO_OUTPUT_BUS, &enableIOFlag, sizeof(enableIOFlag));
+    if (status != noErr) {
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+        return ma_result_from_OSStatus(status);
+    }
+
+    enableIOFlag = (enableIOFlag == 0) ? 1 : 0;
+    status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, MA_COREAUDIO_INPUT_BUS, &enableIOFlag, sizeof(enableIOFlag));
+    if (status != noErr) {
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+        return ma_result_from_OSStatus(status);
+    }
+
+
+    /* Set the device to use with this audio unit. This is only used on desktop since we are using defaults on mobile. */
+#if defined(MA_APPLE_DESKTOP)
+    status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &deviceObjectID, sizeof(deviceObjectID));
+    if (status != noErr) {
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+        return ma_result_from_OSStatus(result);
+    }
+#else
+    /*
+    For some reason it looks like Apple is only allowing selection of the input device. There does not appear to be any way to change
+    the default output route. I have no idea why this is like this, but for now we'll only be able to configure capture devices.
+    */
+    if (pDeviceID != NULL) {
+        if (deviceType == ma_device_type_capture) {
+            ma_bool32 found = MA_FALSE;
+            NSArray *pInputs = [[[AVAudioSession sharedInstance] currentRoute] inputs];
+            for (AVAudioSessionPortDescription* pPortDesc in pInputs) {
+                if (strcmp(pDeviceID->coreaudio, [pPortDesc.UID UTF8String]) == 0) {
+                    [[AVAudioSession sharedInstance] setPreferredInput:pPortDesc error:nil];
+                    found = MA_TRUE;
+                    break;
+                }
+            }
+
+            if (found == MA_FALSE) {
+                return MA_DOES_NOT_EXIST;
+            }
+        }
+    }
+#endif
+
+    /*
+    Format. This is the hardest part of initialization because there's a few variables to take into account.
+      1) The format must be supported by the device.
+      2) The format must be supported miniaudio.
+      3) There's a priority that miniaudio prefers.
+
+    Ideally we would like to use a format that's as close to the hardware as possible so we can get as close to a passthrough as possible. The
+    most important property is the sample rate. miniaudio can do format conversion for any sample rate and channel count, but cannot do the same
+    for the sample data format. If the sample data format is not supported by miniaudio it must be ignored completely.
+
+    On mobile platforms this is a bit different. We just force the use of whatever the audio unit's current format is set to.
+    */
+    {
+        AudioStreamBasicDescription origFormat;
+        UInt32 origFormatSize = sizeof(origFormat);
+        AudioUnitScope   formatScope   = (deviceType == ma_device_type_playback) ? kAudioUnitScope_Input : kAudioUnitScope_Output;
+        AudioUnitElement formatElement = (deviceType == ma_device_type_playback) ? MA_COREAUDIO_OUTPUT_BUS : MA_COREAUDIO_INPUT_BUS;
+
+        if (deviceType == ma_device_type_playback) {
+            status = ((ma_AudioUnitGetProperty_proc)pContext->coreaudio.AudioUnitGetProperty)(pData->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, MA_COREAUDIO_OUTPUT_BUS, &origFormat, &origFormatSize);
+        } else {
+            status = ((ma_AudioUnitGetProperty_proc)pContext->coreaudio.AudioUnitGetProperty)(pData->audioUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input, MA_COREAUDIO_INPUT_BUS, &origFormat, &origFormatSize);
+        }
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+
+    #if defined(MA_APPLE_DESKTOP)
+        result = ma_find_best_format__coreaudio(pContext, deviceObjectID, deviceType, pData->formatIn, pData->channelsIn, pData->sampleRateIn, &origFormat, &bestFormat);
+        if (result != MA_SUCCESS) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return result;
+        }
+
+        /*
+        Technical Note TN2091: Device input using the HAL Output Audio Unit
+            https://developer.apple.com/library/archive/technotes/tn2091/_index.html
+
+        This documentation says the following:
+
+            The internal AudioConverter can handle any *simple* conversion. Typically, this means that a client can specify ANY
+            variant of the PCM formats. Consequently, the device's sample rate should match the desired sample rate. If sample rate
+            conversion is needed, it can be accomplished by buffering the input and converting the data on a separate thread with
+            another AudioConverter.
+
+        The important part here is the mention that it can handle *simple* conversions, which does *not* include sample rate. We
+        therefore want to ensure the sample rate stays consistent. This document is specifically for input, but I'm going to play it
+        safe and apply the same rule to output as well.
+
+        I have tried going against the documentation by setting the sample rate anyway, but this just results in AudioUnitRender()
+        returning a result code of -10863. I have also tried changing the format directly on the input scope on the input bus, but
+        this just results in `ca_require: IsStreamFormatWritable(inScope, inElement) NotWritable` when trying to set the format.
+
+        Something that does seem to work, however, has been setting the nominal sample rate on the deivce object. The problem with
+        this, however, is that it actually changes the sample rate at the operating system level and not just the application. This
+        could be intrusive to the user, however, so I don't think it's wise to make this the default. Instead I'm making this a
+        configuration option. When the `coreaudio.allowNominalSampleRateChange` config option is set to true, changing the sample
+        rate will be allowed. Otherwise it'll be fixed to the current sample rate. To check the system-defined sample rate, run
+        the Audio MIDI Setup program that comes installed on macOS and observe how the sample rate changes as the sample rate is
+        changed by miniaudio.
+        */
+        if (pData->allowNominalSampleRateChange) {
+            AudioValueRange sampleRateRange;
+            AudioObjectPropertyAddress propAddress;
+
+            sampleRateRange.mMinimum = bestFormat.mSampleRate;
+            sampleRateRange.mMaximum = bestFormat.mSampleRate;
+
+            propAddress.mSelector = kAudioDevicePropertyNominalSampleRate;
+            propAddress.mScope    = (deviceType == ma_device_type_playback) ? kAudioObjectPropertyScopeOutput : kAudioObjectPropertyScopeInput;
+            propAddress.mElement  = AUDIO_OBJECT_PROPERTY_ELEMENT;
+
+            status = ((ma_AudioObjectSetPropertyData_proc)pContext->coreaudio.AudioObjectSetPropertyData)(deviceObjectID, &propAddress, 0, NULL, sizeof(sampleRateRange), &sampleRateRange);
+            if (status != noErr) {
+                bestFormat.mSampleRate = origFormat.mSampleRate;
+            }
+        } else {
+            bestFormat.mSampleRate = origFormat.mSampleRate;
+        }
+
+        status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioUnitProperty_StreamFormat, formatScope, formatElement, &bestFormat, sizeof(bestFormat));
+        if (status != noErr) {
+            /* We failed to set the format, so fall back to the current format of the audio unit. */
+            bestFormat = origFormat;
+        }
+    #else
+        bestFormat = origFormat;
+
+        /*
+        Sample rate is a little different here because for some reason kAudioUnitProperty_StreamFormat returns 0... Oh well. We need to instead try
+        setting the sample rate to what the user has requested and then just see the results of it. Need to use some Objective-C here for this since
+        it depends on Apple's AVAudioSession API. To do this we just get the shared AVAudioSession instance and then set it. Note that from what I
+        can tell, it looks like the sample rate is shared between playback and capture for everything.
+        */
+        @autoreleasepool {
+            AVAudioSession* pAudioSession = [AVAudioSession sharedInstance];
+            MA_ASSERT(pAudioSession != NULL);
+
+            [pAudioSession setPreferredSampleRate:(double)pData->sampleRateIn error:nil];
+            bestFormat.mSampleRate = pAudioSession.sampleRate;
+
+            /*
+            I've had a report that the channel count returned by AudioUnitGetProperty above is inconsistent with
+            AVAudioSession outputNumberOfChannels. I'm going to try using the AVAudioSession values instead.
+            */
+            if (deviceType == ma_device_type_playback) {
+                bestFormat.mChannelsPerFrame = (UInt32)pAudioSession.outputNumberOfChannels;
+            }
+            if (deviceType == ma_device_type_capture) {
+                bestFormat.mChannelsPerFrame = (UInt32)pAudioSession.inputNumberOfChannels;
+            }
+        }
+
+        status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioUnitProperty_StreamFormat, formatScope, formatElement, &bestFormat, sizeof(bestFormat));
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+    #endif
+
+        result = ma_format_from_AudioStreamBasicDescription(&bestFormat, &pData->formatOut);
+        if (result != MA_SUCCESS) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return result;
+        }
+
+        if (pData->formatOut == ma_format_unknown) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        pData->channelsOut   = bestFormat.mChannelsPerFrame;
+        pData->sampleRateOut = bestFormat.mSampleRate;
+    }
+
+    /* Clamp the channel count for safety. */
+    if (pData->channelsOut > MA_MAX_CHANNELS) {
+        pData->channelsOut = MA_MAX_CHANNELS;
+    }
+
+    /*
+    Internal channel map. This is weird in my testing. If I use the AudioObject to get the
+    channel map, the channel descriptions are set to "Unknown" for some reason. To work around
+    this it looks like retrieving it from the AudioUnit will work. However, and this is where
+    it gets weird, it doesn't seem to work with capture devices, nor at all on iOS... Therefore
+    I'm going to fall back to a default assumption in these cases.
+    */
+#if defined(MA_APPLE_DESKTOP)
+    result = ma_get_AudioUnit_channel_map(pContext, pData->audioUnit, deviceType, pData->channelMapOut, pData->channelsOut);
+    if (result != MA_SUCCESS) {
+    #if 0
+        /* Try falling back to the channel map from the AudioObject. */
+        result = ma_get_AudioObject_channel_map(pContext, deviceObjectID, deviceType, pData->channelMapOut, pData->channelsOut);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    #else
+        /* Fall back to default assumptions. */
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pData->channelMapOut, ma_countof(pData->channelMapOut), pData->channelsOut);
+    #endif
+    }
+#else
+    /* TODO: Figure out how to get the channel map using AVAudioSession. */
+    ma_channel_map_init_standard(ma_standard_channel_map_default, pData->channelMapOut, ma_countof(pData->channelMapOut), pData->channelsOut);
+#endif
+
+
+    /* Buffer size. Not allowing this to be configurable on iOS. */
+    if (pData->periodSizeInFramesIn == 0) {
+        if (pData->periodSizeInMillisecondsIn == 0) {
+            if (pData->performanceProfile == ma_performance_profile_low_latency) {
+                actualPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY, pData->sampleRateOut);
+            } else {
+                actualPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE, pData->sampleRateOut);
+            }
+        } else {
+            actualPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(pData->periodSizeInMillisecondsIn, pData->sampleRateOut);
+        }
+    } else {
+        actualPeriodSizeInFrames = pData->periodSizeInFramesIn;
+    }
+
+#if defined(MA_APPLE_DESKTOP)
+    result = ma_set_AudioObject_buffer_size_in_frames(pContext, deviceObjectID, deviceType, &actualPeriodSizeInFrames);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+#else
+    /*
+    On iOS, the size of the IO buffer needs to be specified in seconds and is a floating point
+    number. I don't trust any potential truncation errors due to converting from float to integer
+    so I'm going to explicitly set the actual period size to the next power of 2.
+    */
+    @autoreleasepool {
+        AVAudioSession* pAudioSession = [AVAudioSession sharedInstance];
+        MA_ASSERT(pAudioSession != NULL);
+
+        [pAudioSession setPreferredIOBufferDuration:((float)actualPeriodSizeInFrames / pAudioSession.sampleRate) error:nil];
+        actualPeriodSizeInFrames = ma_next_power_of_2((ma_uint32)(pAudioSession.IOBufferDuration * pAudioSession.sampleRate));
+    }
+#endif
+
+
+    /*
+    During testing I discovered that the buffer size can be too big. You'll get an error like this:
+
+      kAudioUnitErr_TooManyFramesToProcess : inFramesToProcess=4096, mMaxFramesPerSlice=512
+
+    Note how inFramesToProcess is smaller than mMaxFramesPerSlice. To fix, we need to set kAudioUnitProperty_MaximumFramesPerSlice to that
+    of the size of our buffer, or do it the other way around and set our buffer size to the kAudioUnitProperty_MaximumFramesPerSlice.
+    */
+    status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0, &actualPeriodSizeInFrames, sizeof(actualPeriodSizeInFrames));
+    if (status != noErr) {
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+        return ma_result_from_OSStatus(status);
+    }
+
+    pData->periodSizeInFramesOut = (ma_uint32)actualPeriodSizeInFrames;
+
+    /* We need a buffer list if this is an input device. We render into this in the input callback. */
+    if (deviceType == ma_device_type_capture) {
+        ma_bool32 isInterleaved = (bestFormat.mFormatFlags & kAudioFormatFlagIsNonInterleaved) == 0;
+        AudioBufferList* pBufferList;
+
+        pBufferList = ma_allocate_AudioBufferList__coreaudio(pData->periodSizeInFramesOut, pData->formatOut, pData->channelsOut, (isInterleaved) ? ma_stream_layout_interleaved : ma_stream_layout_deinterleaved, &pContext->allocationCallbacks);
+        if (pBufferList == NULL) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        pData->pAudioBufferList = pBufferList;
+    }
+
+    /* Callbacks. */
+    callbackInfo.inputProcRefCon = pDevice_DoNotReference;
+    if (deviceType == ma_device_type_playback) {
+        callbackInfo.inputProc = ma_on_output__coreaudio;
+        status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Global, 0, &callbackInfo, sizeof(callbackInfo));
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+    } else {
+        callbackInfo.inputProc = ma_on_input__coreaudio;
+        status = ((ma_AudioUnitSetProperty_proc)pContext->coreaudio.AudioUnitSetProperty)(pData->audioUnit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &callbackInfo, sizeof(callbackInfo));
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    /* We need to listen for stop events. */
+    if (pData->registerStopEvent) {
+        status = ((ma_AudioUnitAddPropertyListener_proc)pContext->coreaudio.AudioUnitAddPropertyListener)(pData->audioUnit, kAudioOutputUnitProperty_IsRunning, on_start_stop__coreaudio, pDevice_DoNotReference);
+        if (status != noErr) {
+            ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    /* Initialize the audio unit. */
+    status = ((ma_AudioUnitInitialize_proc)pContext->coreaudio.AudioUnitInitialize)(pData->audioUnit);
+    if (status != noErr) {
+        ma_free(pData->pAudioBufferList, &pContext->allocationCallbacks);
+        pData->pAudioBufferList = NULL;
+        ((ma_AudioComponentInstanceDispose_proc)pContext->coreaudio.AudioComponentInstanceDispose)(pData->audioUnit);
+        return ma_result_from_OSStatus(status);
+    }
+
+    /* Grab the name. */
+#if defined(MA_APPLE_DESKTOP)
+    ma_get_AudioObject_name(pContext, deviceObjectID, sizeof(pData->deviceName), pData->deviceName);
+#else
+    if (deviceType == ma_device_type_playback) {
+        ma_strcpy_s(pData->deviceName, sizeof(pData->deviceName), MA_DEFAULT_PLAYBACK_DEVICE_NAME);
+    } else {
+        ma_strcpy_s(pData->deviceName, sizeof(pData->deviceName), MA_DEFAULT_CAPTURE_DEVICE_NAME);
+    }
+#endif
+
+    return result;
+}
+
+#if defined(MA_APPLE_DESKTOP)
+static ma_result ma_device_reinit_internal__coreaudio(ma_device* pDevice, ma_device_type deviceType, ma_bool32 disposePreviousAudioUnit)
+{
+    ma_device_init_internal_data__coreaudio data;
+    ma_result result;
+
+    /* This should only be called for playback or capture, not duplex. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    data.allowNominalSampleRateChange = MA_FALSE;   /* Don't change the nominal sample rate when switching devices. */
+
+    if (deviceType == ma_device_type_capture) {
+        data.formatIn               = pDevice->capture.format;
+        data.channelsIn             = pDevice->capture.channels;
+        data.sampleRateIn           = pDevice->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDevice->capture.channelMap, sizeof(pDevice->capture.channelMap));
+        data.shareMode              = pDevice->capture.shareMode;
+        data.performanceProfile     = pDevice->coreaudio.originalPerformanceProfile;
+        data.registerStopEvent      = MA_TRUE;
+
+        if (disposePreviousAudioUnit) {
+            ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+            ((ma_AudioComponentInstanceDispose_proc)pDevice->pContext->coreaudio.AudioComponentInstanceDispose)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+        }
+        if (pDevice->coreaudio.pAudioBufferList) {
+            ma_free(pDevice->coreaudio.pAudioBufferList, &pDevice->pContext->allocationCallbacks);
+        }
+    } else if (deviceType == ma_device_type_playback) {
+        data.formatIn               = pDevice->playback.format;
+        data.channelsIn             = pDevice->playback.channels;
+        data.sampleRateIn           = pDevice->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDevice->playback.channelMap, sizeof(pDevice->playback.channelMap));
+        data.shareMode              = pDevice->playback.shareMode;
+        data.performanceProfile     = pDevice->coreaudio.originalPerformanceProfile;
+        data.registerStopEvent      = (pDevice->type != ma_device_type_duplex);
+
+        if (disposePreviousAudioUnit) {
+            ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+            ((ma_AudioComponentInstanceDispose_proc)pDevice->pContext->coreaudio.AudioComponentInstanceDispose)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+        }
+    }
+    data.periodSizeInFramesIn       = pDevice->coreaudio.originalPeriodSizeInFrames;
+    data.periodSizeInMillisecondsIn = pDevice->coreaudio.originalPeriodSizeInMilliseconds;
+    data.periodsIn                  = pDevice->coreaudio.originalPeriods;
+
+    /* Need at least 3 periods for duplex. */
+    if (data.periodsIn < 3 && pDevice->type == ma_device_type_duplex) {
+        data.periodsIn = 3;
+    }
+
+    result = ma_device_init_internal__coreaudio(pDevice->pContext, deviceType, NULL, &data, (void*)pDevice);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (deviceType == ma_device_type_capture) {
+    #if defined(MA_APPLE_DESKTOP)
+        pDevice->coreaudio.deviceObjectIDCapture     = (ma_uint32)data.deviceObjectID;
+        ma_get_AudioObject_uid(pDevice->pContext, pDevice->coreaudio.deviceObjectIDCapture, sizeof(pDevice->capture.id.coreaudio), pDevice->capture.id.coreaudio);
+    #endif
+        pDevice->coreaudio.audioUnitCapture          = (ma_ptr)data.audioUnit;
+        pDevice->coreaudio.pAudioBufferList          = (ma_ptr)data.pAudioBufferList;
+        pDevice->coreaudio.audioBufferCapInFrames    = data.periodSizeInFramesOut;
+
+        pDevice->capture.internalFormat              = data.formatOut;
+        pDevice->capture.internalChannels            = data.channelsOut;
+        pDevice->capture.internalSampleRate          = data.sampleRateOut;
+        MA_COPY_MEMORY(pDevice->capture.internalChannelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDevice->capture.internalPeriodSizeInFrames  = data.periodSizeInFramesOut;
+        pDevice->capture.internalPeriods             = data.periodsOut;
+    } else if (deviceType == ma_device_type_playback) {
+    #if defined(MA_APPLE_DESKTOP)
+        pDevice->coreaudio.deviceObjectIDPlayback    = (ma_uint32)data.deviceObjectID;
+        ma_get_AudioObject_uid(pDevice->pContext, pDevice->coreaudio.deviceObjectIDPlayback, sizeof(pDevice->playback.id.coreaudio), pDevice->playback.id.coreaudio);
+    #endif
+        pDevice->coreaudio.audioUnitPlayback         = (ma_ptr)data.audioUnit;
+
+        pDevice->playback.internalFormat             = data.formatOut;
+        pDevice->playback.internalChannels           = data.channelsOut;
+        pDevice->playback.internalSampleRate         = data.sampleRateOut;
+        MA_COPY_MEMORY(pDevice->playback.internalChannelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDevice->playback.internalPeriodSizeInFrames = data.periodSizeInFramesOut;
+        pDevice->playback.internalPeriods            = data.periodsOut;
+    }
+
+    return MA_SUCCESS;
+}
+#endif /* MA_APPLE_DESKTOP */
+
+static ma_result ma_device_init__coreaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pConfig != NULL);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* No exclusive mode with the Core Audio backend for now. */
+    if (((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    /* Capture needs to be initialized first. */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_device_init_internal_data__coreaudio data;
+        data.allowNominalSampleRateChange = pConfig->coreaudio.allowNominalSampleRateChange;
+        data.formatIn                     = pDescriptorCapture->format;
+        data.channelsIn                   = pDescriptorCapture->channels;
+        data.sampleRateIn                 = pDescriptorCapture->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDescriptorCapture->channelMap, sizeof(pDescriptorCapture->channelMap));
+        data.periodSizeInFramesIn         = pDescriptorCapture->periodSizeInFrames;
+        data.periodSizeInMillisecondsIn   = pDescriptorCapture->periodSizeInMilliseconds;
+        data.periodsIn                    = pDescriptorCapture->periodCount;
+        data.shareMode                    = pDescriptorCapture->shareMode;
+        data.performanceProfile           = pConfig->performanceProfile;
+        data.registerStopEvent            = MA_TRUE;
+
+        /* Need at least 3 periods for duplex. */
+        if (data.periodsIn < 3 && pConfig->deviceType == ma_device_type_duplex) {
+            data.periodsIn = 3;
+        }
+
+        result = ma_device_init_internal__coreaudio(pDevice->pContext, ma_device_type_capture, pDescriptorCapture->pDeviceID, &data, (void*)pDevice);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pDevice->coreaudio.isDefaultCaptureDevice           = (pConfig->capture.pDeviceID == NULL);
+    #if defined(MA_APPLE_DESKTOP)
+        pDevice->coreaudio.deviceObjectIDCapture            = (ma_uint32)data.deviceObjectID;
+    #endif
+        pDevice->coreaudio.audioUnitCapture                 = (ma_ptr)data.audioUnit;
+        pDevice->coreaudio.pAudioBufferList                 = (ma_ptr)data.pAudioBufferList;
+        pDevice->coreaudio.audioBufferCapInFrames           = data.periodSizeInFramesOut;
+        pDevice->coreaudio.originalPeriodSizeInFrames       = pDescriptorCapture->periodSizeInFrames;
+        pDevice->coreaudio.originalPeriodSizeInMilliseconds = pDescriptorCapture->periodSizeInMilliseconds;
+        pDevice->coreaudio.originalPeriods                  = pDescriptorCapture->periodCount;
+        pDevice->coreaudio.originalPerformanceProfile       = pConfig->performanceProfile;
+
+        pDescriptorCapture->format                          = data.formatOut;
+        pDescriptorCapture->channels                        = data.channelsOut;
+        pDescriptorCapture->sampleRate                      = data.sampleRateOut;
+        MA_COPY_MEMORY(pDescriptorCapture->channelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDescriptorCapture->periodSizeInFrames              = data.periodSizeInFramesOut;
+        pDescriptorCapture->periodCount                     = data.periodsOut;
+
+    #if defined(MA_APPLE_DESKTOP)
+        ma_get_AudioObject_uid(pDevice->pContext, pDevice->coreaudio.deviceObjectIDCapture, sizeof(pDevice->capture.id.coreaudio), pDevice->capture.id.coreaudio);
+
+        /*
+        If we are using the default device we'll need to listen for changes to the system's default device so we can seemlessly
+        switch the device in the background.
+        */
+        if (pConfig->capture.pDeviceID == NULL) {
+            ma_device__track__coreaudio(pDevice);
+        }
+    #endif
+    }
+
+    /* Playback. */
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_device_init_internal_data__coreaudio data;
+        data.allowNominalSampleRateChange   = pConfig->coreaudio.allowNominalSampleRateChange;
+        data.formatIn                       = pDescriptorPlayback->format;
+        data.channelsIn                     = pDescriptorPlayback->channels;
+        data.sampleRateIn                   = pDescriptorPlayback->sampleRate;
+        MA_COPY_MEMORY(data.channelMapIn, pDescriptorPlayback->channelMap, sizeof(pDescriptorPlayback->channelMap));
+        data.shareMode                      = pDescriptorPlayback->shareMode;
+        data.performanceProfile             = pConfig->performanceProfile;
+
+        /* In full-duplex mode we want the playback buffer to be the same size as the capture buffer. */
+        if (pConfig->deviceType == ma_device_type_duplex) {
+            data.periodSizeInFramesIn       = pDescriptorCapture->periodSizeInFrames;
+            data.periodsIn                  = pDescriptorCapture->periodCount;
+            data.registerStopEvent          = MA_FALSE;
+        } else {
+            data.periodSizeInFramesIn       = pDescriptorPlayback->periodSizeInFrames;
+            data.periodSizeInMillisecondsIn = pDescriptorPlayback->periodSizeInMilliseconds;
+            data.periodsIn                  = pDescriptorPlayback->periodCount;
+            data.registerStopEvent          = MA_TRUE;
+        }
+
+        result = ma_device_init_internal__coreaudio(pDevice->pContext, ma_device_type_playback, pDescriptorPlayback->pDeviceID, &data, (void*)pDevice);
+        if (result != MA_SUCCESS) {
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                ((ma_AudioComponentInstanceDispose_proc)pDevice->pContext->coreaudio.AudioComponentInstanceDispose)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+                if (pDevice->coreaudio.pAudioBufferList) {
+                    ma_free(pDevice->coreaudio.pAudioBufferList, &pDevice->pContext->allocationCallbacks);
+                }
+            }
+            return result;
+        }
+
+        pDevice->coreaudio.isDefaultPlaybackDevice          = (pConfig->playback.pDeviceID == NULL);
+    #if defined(MA_APPLE_DESKTOP)
+        pDevice->coreaudio.deviceObjectIDPlayback           = (ma_uint32)data.deviceObjectID;
+    #endif
+        pDevice->coreaudio.audioUnitPlayback                = (ma_ptr)data.audioUnit;
+        pDevice->coreaudio.originalPeriodSizeInFrames       = pDescriptorPlayback->periodSizeInFrames;
+        pDevice->coreaudio.originalPeriodSizeInMilliseconds = pDescriptorPlayback->periodSizeInMilliseconds;
+        pDevice->coreaudio.originalPeriods                  = pDescriptorPlayback->periodCount;
+        pDevice->coreaudio.originalPerformanceProfile       = pConfig->performanceProfile;
+
+        pDescriptorPlayback->format                         = data.formatOut;
+        pDescriptorPlayback->channels                       = data.channelsOut;
+        pDescriptorPlayback->sampleRate                     = data.sampleRateOut;
+        MA_COPY_MEMORY(pDescriptorPlayback->channelMap, data.channelMapOut, sizeof(data.channelMapOut));
+        pDescriptorPlayback->periodSizeInFrames             = data.periodSizeInFramesOut;
+        pDescriptorPlayback->periodCount                    = data.periodsOut;
+
+    #if defined(MA_APPLE_DESKTOP)
+        ma_get_AudioObject_uid(pDevice->pContext, pDevice->coreaudio.deviceObjectIDPlayback, sizeof(pDevice->playback.id.coreaudio), pDevice->playback.id.coreaudio);
+
+        /*
+        If we are using the default device we'll need to listen for changes to the system's default device so we can seemlessly
+        switch the device in the background.
+        */
+        if (pDescriptorPlayback->pDeviceID == NULL && (pConfig->deviceType != ma_device_type_duplex || pDescriptorCapture->pDeviceID != NULL)) {
+            ma_device__track__coreaudio(pDevice);
+        }
+    #endif
+    }
+
+
+
+    /*
+    When stopping the device, a callback is called on another thread. We need to wait for this callback
+    before returning from ma_device_stop(). This event is used for this.
+    */
+    ma_event_init(&pDevice->coreaudio.stopEvent);
+
+    /*
+    We need to detect when a route has changed so we can update the data conversion pipeline accordingly. This is done
+    differently on non-Desktop Apple platforms.
+    */
+#if defined(MA_APPLE_MOBILE)
+    pDevice->coreaudio.pNotificationHandler = (MA_BRIDGE_RETAINED void*)[[ma_ios_notification_handler alloc] init:pDevice];
+#endif
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_start__coreaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        OSStatus status = ((ma_AudioOutputUnitStart_proc)pDevice->pContext->coreaudio.AudioOutputUnitStart)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+        if (status != noErr) {
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        OSStatus status = ((ma_AudioOutputUnitStart_proc)pDevice->pContext->coreaudio.AudioOutputUnitStart)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+        if (status != noErr) {
+            if (pDevice->type == ma_device_type_duplex) {
+                ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+            }
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__coreaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* It's not clear from the documentation whether or not AudioOutputUnitStop() actually drains the device or not. */
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        OSStatus status = ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitCapture);
+        if (status != noErr) {
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        OSStatus status = ((ma_AudioOutputUnitStop_proc)pDevice->pContext->coreaudio.AudioOutputUnitStop)((AudioUnit)pDevice->coreaudio.audioUnitPlayback);
+        if (status != noErr) {
+            return ma_result_from_OSStatus(status);
+        }
+    }
+
+    /* We need to wait for the callback to finish before returning. */
+    ma_event_wait(&pDevice->coreaudio.stopEvent);
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_uninit__coreaudio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_coreaudio);
+
+#if defined(MA_APPLE_MOBILE)
+    if (!pContext->coreaudio.noAudioSessionDeactivate) {
+        if (![[AVAudioSession sharedInstance] setActive:false error:nil]) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "Failed to deactivate audio session.");
+            return MA_FAILED_TO_INIT_BACKEND;
+        }
+    }
+#endif
+
+#if !defined(MA_NO_RUNTIME_LINKING) && !defined(MA_APPLE_MOBILE)
+    ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit);
+    ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio);
+    ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+#endif
+
+#if !defined(MA_APPLE_MOBILE)
+    ma_context__uninit_device_tracking__coreaudio(pContext);
+#endif
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+#if defined(MA_APPLE_MOBILE) && defined(__IPHONE_12_0)
+static AVAudioSessionCategory ma_to_AVAudioSessionCategory(ma_ios_session_category category)
+{
+    /* The "default" and "none" categories are treated different and should not be used as an input into this function. */
+    MA_ASSERT(category != ma_ios_session_category_default);
+    MA_ASSERT(category != ma_ios_session_category_none);
+
+    switch (category) {
+        case ma_ios_session_category_ambient:         return AVAudioSessionCategoryAmbient;
+        case ma_ios_session_category_solo_ambient:    return AVAudioSessionCategorySoloAmbient;
+        case ma_ios_session_category_playback:        return AVAudioSessionCategoryPlayback;
+        case ma_ios_session_category_record:          return AVAudioSessionCategoryRecord;
+        case ma_ios_session_category_play_and_record: return AVAudioSessionCategoryPlayAndRecord;
+        case ma_ios_session_category_multi_route:     return AVAudioSessionCategoryMultiRoute;
+        case ma_ios_session_category_none:            return AVAudioSessionCategoryAmbient;
+        case ma_ios_session_category_default:         return AVAudioSessionCategoryAmbient;
+        default:                                      return AVAudioSessionCategoryAmbient;
+    }
+}
+#endif
+
+static ma_result ma_context_init__coreaudio(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+#if !defined(MA_APPLE_MOBILE)
+    ma_result result;
+#endif
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pContext != NULL);
+
+#if defined(MA_APPLE_MOBILE)
+    @autoreleasepool {
+        AVAudioSession* pAudioSession = [AVAudioSession sharedInstance];
+        AVAudioSessionCategoryOptions options = pConfig->coreaudio.sessionCategoryOptions;
+
+        MA_ASSERT(pAudioSession != NULL);
+
+        if (pConfig->coreaudio.sessionCategory == ma_ios_session_category_default) {
+            /*
+            I'm going to use trial and error to determine our default session category. First we'll try PlayAndRecord. If that fails
+            we'll try Playback and if that fails we'll try record. If all of these fail we'll just not set the category.
+            */
+        #if !defined(MA_APPLE_TV) && !defined(MA_APPLE_WATCH)
+            options |= AVAudioSessionCategoryOptionDefaultToSpeaker;
+        #endif
+
+            if ([pAudioSession setCategory: AVAudioSessionCategoryPlayAndRecord withOptions:options error:nil]) {
+                /* Using PlayAndRecord */
+            } else if ([pAudioSession setCategory: AVAudioSessionCategoryPlayback withOptions:options error:nil]) {
+                /* Using Playback */
+            } else if ([pAudioSession setCategory: AVAudioSessionCategoryRecord withOptions:options error:nil]) {
+                /* Using Record */
+            } else {
+                /* Leave as default? */
+            }
+        } else {
+            if (pConfig->coreaudio.sessionCategory != ma_ios_session_category_none) {
+            #if defined(__IPHONE_12_0)
+                if (![pAudioSession setCategory: ma_to_AVAudioSessionCategory(pConfig->coreaudio.sessionCategory) withOptions:options error:nil]) {
+                    return MA_INVALID_OPERATION;    /* Failed to set session category. */
+                }
+            #else
+                /* Ignore the session category on version 11 and older, but post a warning. */
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "Session category only supported in iOS 12 and newer.");
+            #endif
+            }
+        }
+
+        if (!pConfig->coreaudio.noAudioSessionActivate) {
+            if (![pAudioSession setActive:true error:nil]) {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "Failed to activate audio session.");
+                return MA_FAILED_TO_INIT_BACKEND;
+            }
+        }
+    }
+#endif
+
+#if !defined(MA_NO_RUNTIME_LINKING) && !defined(MA_APPLE_MOBILE)
+    pContext->coreaudio.hCoreFoundation = ma_dlopen(ma_context_get_log(pContext), "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation");
+    if (pContext->coreaudio.hCoreFoundation == NULL) {
+        return MA_API_NOT_FOUND;
+    }
+
+    pContext->coreaudio.CFStringGetCString = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation, "CFStringGetCString");
+    pContext->coreaudio.CFRelease          = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation, "CFRelease");
+
+
+    pContext->coreaudio.hCoreAudio = ma_dlopen(ma_context_get_log(pContext), "/System/Library/Frameworks/CoreAudio.framework/CoreAudio");
+    if (pContext->coreaudio.hCoreAudio == NULL) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+        return MA_API_NOT_FOUND;
+    }
+
+    pContext->coreaudio.AudioObjectGetPropertyData        = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio, "AudioObjectGetPropertyData");
+    pContext->coreaudio.AudioObjectGetPropertyDataSize    = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio, "AudioObjectGetPropertyDataSize");
+    pContext->coreaudio.AudioObjectSetPropertyData        = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio, "AudioObjectSetPropertyData");
+    pContext->coreaudio.AudioObjectAddPropertyListener    = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio, "AudioObjectAddPropertyListener");
+    pContext->coreaudio.AudioObjectRemovePropertyListener = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio, "AudioObjectRemovePropertyListener");
+
+    /*
+    It looks like Apple has moved some APIs from AudioUnit into AudioToolbox on more recent versions of macOS. They are still
+    defined in AudioUnit, but just in case they decide to remove them from there entirely I'm going to implement a fallback.
+    The way it'll work is that it'll first try AudioUnit, and if the required symbols are not present there we'll fall back to
+    AudioToolbox.
+    */
+    pContext->coreaudio.hAudioUnit = ma_dlopen(ma_context_get_log(pContext), "/System/Library/Frameworks/AudioUnit.framework/AudioUnit");
+    if (pContext->coreaudio.hAudioUnit == NULL) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio);
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+        return MA_API_NOT_FOUND;
+    }
+
+    if (ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioComponentFindNext") == NULL) {
+        /* Couldn't find the required symbols in AudioUnit, so fall back to AudioToolbox. */
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit);
+        pContext->coreaudio.hAudioUnit = ma_dlopen(ma_context_get_log(pContext), "/System/Library/Frameworks/AudioToolbox.framework/AudioToolbox");
+        if (pContext->coreaudio.hAudioUnit == NULL) {
+            ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio);
+            ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+            return MA_API_NOT_FOUND;
+        }
+    }
+
+    pContext->coreaudio.AudioComponentFindNext            = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioComponentFindNext");
+    pContext->coreaudio.AudioComponentInstanceDispose     = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioComponentInstanceDispose");
+    pContext->coreaudio.AudioComponentInstanceNew         = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioComponentInstanceNew");
+    pContext->coreaudio.AudioOutputUnitStart              = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioOutputUnitStart");
+    pContext->coreaudio.AudioOutputUnitStop               = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioOutputUnitStop");
+    pContext->coreaudio.AudioUnitAddPropertyListener      = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitAddPropertyListener");
+    pContext->coreaudio.AudioUnitGetPropertyInfo          = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitGetPropertyInfo");
+    pContext->coreaudio.AudioUnitGetProperty              = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitGetProperty");
+    pContext->coreaudio.AudioUnitSetProperty              = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitSetProperty");
+    pContext->coreaudio.AudioUnitInitialize               = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitInitialize");
+    pContext->coreaudio.AudioUnitRender                   = ma_dlsym(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit, "AudioUnitRender");
+#else
+    pContext->coreaudio.CFStringGetCString                = (ma_proc)CFStringGetCString;
+    pContext->coreaudio.CFRelease                         = (ma_proc)CFRelease;
+
+    #if defined(MA_APPLE_DESKTOP)
+    pContext->coreaudio.AudioObjectGetPropertyData        = (ma_proc)AudioObjectGetPropertyData;
+    pContext->coreaudio.AudioObjectGetPropertyDataSize    = (ma_proc)AudioObjectGetPropertyDataSize;
+    pContext->coreaudio.AudioObjectSetPropertyData        = (ma_proc)AudioObjectSetPropertyData;
+    pContext->coreaudio.AudioObjectAddPropertyListener    = (ma_proc)AudioObjectAddPropertyListener;
+    pContext->coreaudio.AudioObjectRemovePropertyListener = (ma_proc)AudioObjectRemovePropertyListener;
+    #endif
+
+    pContext->coreaudio.AudioComponentFindNext            = (ma_proc)AudioComponentFindNext;
+    pContext->coreaudio.AudioComponentInstanceDispose     = (ma_proc)AudioComponentInstanceDispose;
+    pContext->coreaudio.AudioComponentInstanceNew         = (ma_proc)AudioComponentInstanceNew;
+    pContext->coreaudio.AudioOutputUnitStart              = (ma_proc)AudioOutputUnitStart;
+    pContext->coreaudio.AudioOutputUnitStop               = (ma_proc)AudioOutputUnitStop;
+    pContext->coreaudio.AudioUnitAddPropertyListener      = (ma_proc)AudioUnitAddPropertyListener;
+    pContext->coreaudio.AudioUnitGetPropertyInfo          = (ma_proc)AudioUnitGetPropertyInfo;
+    pContext->coreaudio.AudioUnitGetProperty              = (ma_proc)AudioUnitGetProperty;
+    pContext->coreaudio.AudioUnitSetProperty              = (ma_proc)AudioUnitSetProperty;
+    pContext->coreaudio.AudioUnitInitialize               = (ma_proc)AudioUnitInitialize;
+    pContext->coreaudio.AudioUnitRender                   = (ma_proc)AudioUnitRender;
+#endif
+
+    /* Audio component. */
+    {
+        AudioComponentDescription desc;
+        desc.componentType         = kAudioUnitType_Output;
+    #if defined(MA_APPLE_DESKTOP)
+        desc.componentSubType      = kAudioUnitSubType_HALOutput;
+    #else
+        desc.componentSubType      = kAudioUnitSubType_RemoteIO;
+    #endif
+        desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+        desc.componentFlags        = 0;
+        desc.componentFlagsMask    = 0;
+
+        pContext->coreaudio.component = ((ma_AudioComponentFindNext_proc)pContext->coreaudio.AudioComponentFindNext)(NULL, &desc);
+        if (pContext->coreaudio.component == NULL) {
+        #if !defined(MA_NO_RUNTIME_LINKING) && !defined(MA_APPLE_MOBILE)
+            ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit);
+            ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio);
+            ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+        #endif
+            return MA_FAILED_TO_INIT_BACKEND;
+        }
+    }
+
+#if !defined(MA_APPLE_MOBILE)
+    result = ma_context__init_device_tracking__coreaudio(pContext);
+    if (result != MA_SUCCESS) {
+    #if !defined(MA_NO_RUNTIME_LINKING) && !defined(MA_APPLE_MOBILE)
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hAudioUnit);
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreAudio);
+        ma_dlclose(ma_context_get_log(pContext), pContext->coreaudio.hCoreFoundation);
+    #endif
+        return result;
+    }
+#endif
+
+    pContext->coreaudio.noAudioSessionDeactivate = pConfig->coreaudio.noAudioSessionDeactivate;
+
+    pCallbacks->onContextInit             = ma_context_init__coreaudio;
+    pCallbacks->onContextUninit           = ma_context_uninit__coreaudio;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__coreaudio;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__coreaudio;
+    pCallbacks->onDeviceInit              = ma_device_init__coreaudio;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__coreaudio;
+    pCallbacks->onDeviceStart             = ma_device_start__coreaudio;
+    pCallbacks->onDeviceStop              = ma_device_stop__coreaudio;
+    pCallbacks->onDeviceRead              = NULL;
+    pCallbacks->onDeviceWrite             = NULL;
+    pCallbacks->onDeviceDataLoop          = NULL;
+
+    return MA_SUCCESS;
+}
+#endif  /* Core Audio */
+
+
+
+/******************************************************************************
+
+sndio Backend
+
+******************************************************************************/
+#ifdef MA_HAS_SNDIO
+#include <fcntl.h>
+
+/*
+Only supporting OpenBSD. This did not work very well at all on FreeBSD when I tried it. Not sure if this is due
+to miniaudio's implementation or if it's some kind of system configuration issue, but basically the default device
+just doesn't emit any sound, or at times you'll hear tiny pieces. I will consider enabling this when there's
+demand for it or if I can get it tested and debugged more thoroughly.
+*/
+#if 0
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#include <sys/audioio.h>
+#endif
+#if defined(__FreeBSD__) || defined(__DragonFly__)
+#include <sys/soundcard.h>
+#endif
+#endif
+
+#define MA_SIO_DEVANY   "default"
+#define MA_SIO_PLAY     1
+#define MA_SIO_REC      2
+#define MA_SIO_NENC     8
+#define MA_SIO_NCHAN    8
+#define MA_SIO_NRATE    16
+#define MA_SIO_NCONF    4
+
+struct ma_sio_hdl; /* <-- Opaque */
+
+struct ma_sio_par
+{
+    unsigned int bits;
+    unsigned int bps;
+    unsigned int sig;
+    unsigned int le;
+    unsigned int msb;
+    unsigned int rchan;
+    unsigned int pchan;
+    unsigned int rate;
+    unsigned int bufsz;
+    unsigned int xrun;
+    unsigned int round;
+    unsigned int appbufsz;
+    int __pad[3];
+    unsigned int __magic;
+};
+
+struct ma_sio_enc
+{
+    unsigned int bits;
+    unsigned int bps;
+    unsigned int sig;
+    unsigned int le;
+    unsigned int msb;
+};
+
+struct ma_sio_conf
+{
+    unsigned int enc;
+    unsigned int rchan;
+    unsigned int pchan;
+    unsigned int rate;
+};
+
+struct ma_sio_cap
+{
+    struct ma_sio_enc enc[MA_SIO_NENC];
+    unsigned int rchan[MA_SIO_NCHAN];
+    unsigned int pchan[MA_SIO_NCHAN];
+    unsigned int rate[MA_SIO_NRATE];
+    int __pad[7];
+    unsigned int nconf;
+    struct ma_sio_conf confs[MA_SIO_NCONF];
+};
+
+typedef struct ma_sio_hdl* (* ma_sio_open_proc)   (const char*, unsigned int, int);
+typedef void               (* ma_sio_close_proc)  (struct ma_sio_hdl*);
+typedef int                (* ma_sio_setpar_proc) (struct ma_sio_hdl*, struct ma_sio_par*);
+typedef int                (* ma_sio_getpar_proc) (struct ma_sio_hdl*, struct ma_sio_par*);
+typedef int                (* ma_sio_getcap_proc) (struct ma_sio_hdl*, struct ma_sio_cap*);
+typedef size_t             (* ma_sio_write_proc)  (struct ma_sio_hdl*, const void*, size_t);
+typedef size_t             (* ma_sio_read_proc)   (struct ma_sio_hdl*, void*, size_t);
+typedef int                (* ma_sio_start_proc)  (struct ma_sio_hdl*);
+typedef int                (* ma_sio_stop_proc)   (struct ma_sio_hdl*);
+typedef int                (* ma_sio_initpar_proc)(struct ma_sio_par*);
+
+static ma_uint32 ma_get_standard_sample_rate_priority_index__sndio(ma_uint32 sampleRate)   /* Lower = higher priority */
+{
+    ma_uint32 i;
+    for (i = 0; i < ma_countof(g_maStandardSampleRatePriorities); ++i) {
+        if (g_maStandardSampleRatePriorities[i] == sampleRate) {
+            return i;
+        }
+    }
+
+    return (ma_uint32)-1;
+}
+
+static ma_format ma_format_from_sio_enc__sndio(unsigned int bits, unsigned int bps, unsigned int sig, unsigned int le, unsigned int msb)
+{
+    /* We only support native-endian right now. */
+    if ((ma_is_little_endian() && le == 0) || (ma_is_big_endian() && le == 1)) {
+        return ma_format_unknown;
+    }
+
+    if (bits ==  8 && bps == 1 && sig == 0) {
+        return ma_format_u8;
+    }
+    if (bits == 16 && bps == 2 && sig == 1) {
+        return ma_format_s16;
+    }
+    if (bits == 24 && bps == 3 && sig == 1) {
+        return ma_format_s24;
+    }
+    if (bits == 24 && bps == 4 && sig == 1 && msb == 0) {
+        /*return ma_format_s24_32;*/
+    }
+    if (bits == 32 && bps == 4 && sig == 1) {
+        return ma_format_s32;
+    }
+
+    return ma_format_unknown;
+}
+
+static ma_format ma_find_best_format_from_sio_cap__sndio(struct ma_sio_cap* caps)
+{
+    ma_format bestFormat;
+    unsigned int iConfig;
+
+    MA_ASSERT(caps != NULL);
+
+    bestFormat = ma_format_unknown;
+    for (iConfig = 0; iConfig < caps->nconf; iConfig += 1) {
+        unsigned int iEncoding;
+        for (iEncoding = 0; iEncoding < MA_SIO_NENC; iEncoding += 1) {
+            unsigned int bits;
+            unsigned int bps;
+            unsigned int sig;
+            unsigned int le;
+            unsigned int msb;
+            ma_format format;
+
+            if ((caps->confs[iConfig].enc & (1UL << iEncoding)) == 0) {
+                continue;
+            }
+
+            bits = caps->enc[iEncoding].bits;
+            bps  = caps->enc[iEncoding].bps;
+            sig  = caps->enc[iEncoding].sig;
+            le   = caps->enc[iEncoding].le;
+            msb  = caps->enc[iEncoding].msb;
+            format = ma_format_from_sio_enc__sndio(bits, bps, sig, le, msb);
+            if (format == ma_format_unknown) {
+                continue;   /* Format not supported. */
+            }
+
+            if (bestFormat == ma_format_unknown) {
+                bestFormat = format;
+            } else {
+                if (ma_get_format_priority_index(bestFormat) > ma_get_format_priority_index(format)) {    /* <-- Lower = better. */
+                    bestFormat = format;
+                }
+            }
+        }
+    }
+
+    return bestFormat;
+}
+
+static ma_uint32 ma_find_best_channels_from_sio_cap__sndio(struct ma_sio_cap* caps, ma_device_type deviceType, ma_format requiredFormat)
+{
+    ma_uint32 maxChannels;
+    unsigned int iConfig;
+
+    MA_ASSERT(caps != NULL);
+    MA_ASSERT(requiredFormat != ma_format_unknown);
+
+    /* Just pick whatever configuration has the most channels. */
+    maxChannels = 0;
+    for (iConfig = 0; iConfig < caps->nconf; iConfig += 1) {
+        /* The encoding should be of requiredFormat. */
+        unsigned int iEncoding;
+        for (iEncoding = 0; iEncoding < MA_SIO_NENC; iEncoding += 1) {
+            unsigned int iChannel;
+            unsigned int bits;
+            unsigned int bps;
+            unsigned int sig;
+            unsigned int le;
+            unsigned int msb;
+            ma_format format;
+
+            if ((caps->confs[iConfig].enc & (1UL << iEncoding)) == 0) {
+                continue;
+            }
+
+            bits = caps->enc[iEncoding].bits;
+            bps  = caps->enc[iEncoding].bps;
+            sig  = caps->enc[iEncoding].sig;
+            le   = caps->enc[iEncoding].le;
+            msb  = caps->enc[iEncoding].msb;
+            format = ma_format_from_sio_enc__sndio(bits, bps, sig, le, msb);
+            if (format != requiredFormat) {
+                continue;
+            }
+
+            /* Getting here means the format is supported. Iterate over each channel count and grab the biggest one. */
+            for (iChannel = 0; iChannel < MA_SIO_NCHAN; iChannel += 1) {
+                unsigned int chan = 0;
+                unsigned int channels;
+
+                if (deviceType == ma_device_type_playback) {
+                    chan = caps->confs[iConfig].pchan;
+                } else {
+                    chan = caps->confs[iConfig].rchan;
+                }
+
+                if ((chan & (1UL << iChannel)) == 0) {
+                    continue;
+                }
+
+                if (deviceType == ma_device_type_playback) {
+                    channels = caps->pchan[iChannel];
+                } else {
+                    channels = caps->rchan[iChannel];
+                }
+
+                if (maxChannels < channels) {
+                    maxChannels = channels;
+                }
+            }
+        }
+    }
+
+    return maxChannels;
+}
+
+static ma_uint32 ma_find_best_sample_rate_from_sio_cap__sndio(struct ma_sio_cap* caps, ma_device_type deviceType, ma_format requiredFormat, ma_uint32 requiredChannels)
+{
+    ma_uint32 firstSampleRate;
+    ma_uint32 bestSampleRate;
+    unsigned int iConfig;
+
+    MA_ASSERT(caps != NULL);
+    MA_ASSERT(requiredFormat != ma_format_unknown);
+    MA_ASSERT(requiredChannels > 0);
+    MA_ASSERT(requiredChannels <= MA_MAX_CHANNELS);
+
+    firstSampleRate = 0; /* <-- If the device does not support a standard rate we'll fall back to the first one that's found. */
+    bestSampleRate  = 0;
+
+    for (iConfig = 0; iConfig < caps->nconf; iConfig += 1) {
+        /* The encoding should be of requiredFormat. */
+        unsigned int iEncoding;
+        for (iEncoding = 0; iEncoding < MA_SIO_NENC; iEncoding += 1) {
+            unsigned int iChannel;
+            unsigned int bits;
+            unsigned int bps;
+            unsigned int sig;
+            unsigned int le;
+            unsigned int msb;
+            ma_format format;
+
+            if ((caps->confs[iConfig].enc & (1UL << iEncoding)) == 0) {
+                continue;
+            }
+
+            bits = caps->enc[iEncoding].bits;
+            bps  = caps->enc[iEncoding].bps;
+            sig  = caps->enc[iEncoding].sig;
+            le   = caps->enc[iEncoding].le;
+            msb  = caps->enc[iEncoding].msb;
+            format = ma_format_from_sio_enc__sndio(bits, bps, sig, le, msb);
+            if (format != requiredFormat) {
+                continue;
+            }
+
+            /* Getting here means the format is supported. Iterate over each channel count and grab the biggest one. */
+            for (iChannel = 0; iChannel < MA_SIO_NCHAN; iChannel += 1) {
+                unsigned int chan = 0;
+                unsigned int channels;
+                unsigned int iRate;
+
+                if (deviceType == ma_device_type_playback) {
+                    chan = caps->confs[iConfig].pchan;
+                } else {
+                    chan = caps->confs[iConfig].rchan;
+                }
+
+                if ((chan & (1UL << iChannel)) == 0) {
+                    continue;
+                }
+
+                if (deviceType == ma_device_type_playback) {
+                    channels = caps->pchan[iChannel];
+                } else {
+                    channels = caps->rchan[iChannel];
+                }
+
+                if (channels != requiredChannels) {
+                    continue;
+                }
+
+                /* Getting here means we have found a compatible encoding/channel pair. */
+                for (iRate = 0; iRate < MA_SIO_NRATE; iRate += 1) {
+                    ma_uint32 rate = (ma_uint32)caps->rate[iRate];
+                    ma_uint32 ratePriority;
+
+                    if (firstSampleRate == 0) {
+                        firstSampleRate = rate;
+                    }
+
+                    /* Disregard this rate if it's not a standard one. */
+                    ratePriority = ma_get_standard_sample_rate_priority_index__sndio(rate);
+                    if (ratePriority == (ma_uint32)-1) {
+                        continue;
+                    }
+
+                    if (ma_get_standard_sample_rate_priority_index__sndio(bestSampleRate) > ratePriority) {   /* Lower = better. */
+                        bestSampleRate = rate;
+                    }
+                }
+            }
+        }
+    }
+
+    /* If a standard sample rate was not found just fall back to the first one that was iterated. */
+    if (bestSampleRate == 0) {
+        bestSampleRate = firstSampleRate;
+    }
+
+    return bestSampleRate;
+}
+
+
+static ma_result ma_context_enumerate_devices__sndio(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 isTerminating = MA_FALSE;
+    struct ma_sio_hdl* handle;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* sndio doesn't seem to have a good device enumeration API, so I'm therefore only enumerating over default devices for now. */
+
+    /* Playback. */
+    if (!isTerminating) {
+        handle = ((ma_sio_open_proc)pContext->sndio.sio_open)(MA_SIO_DEVANY, MA_SIO_PLAY, 0);
+        if (handle != NULL) {
+            /* Supports playback. */
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            ma_strcpy_s(deviceInfo.id.sndio, sizeof(deviceInfo.id.sndio), MA_SIO_DEVANY);
+            ma_strcpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME);
+
+            isTerminating = !callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+
+            ((ma_sio_close_proc)pContext->sndio.sio_close)(handle);
+        }
+    }
+
+    /* Capture. */
+    if (!isTerminating) {
+        handle = ((ma_sio_open_proc)pContext->sndio.sio_open)(MA_SIO_DEVANY, MA_SIO_REC, 0);
+        if (handle != NULL) {
+            /* Supports capture. */
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            ma_strcpy_s(deviceInfo.id.sndio, sizeof(deviceInfo.id.sndio), "default");
+            ma_strcpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME);
+
+            isTerminating = !callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+
+            ((ma_sio_close_proc)pContext->sndio.sio_close)(handle);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__sndio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    char devid[256];
+    struct ma_sio_hdl* handle;
+    struct ma_sio_cap caps;
+    unsigned int iConfig;
+
+    MA_ASSERT(pContext != NULL);
+
+    /* We need to open the device before we can get information about it. */
+    if (pDeviceID == NULL) {
+        ma_strcpy_s(devid, sizeof(devid), MA_SIO_DEVANY);
+        ma_strcpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), (deviceType == ma_device_type_playback) ? MA_DEFAULT_PLAYBACK_DEVICE_NAME : MA_DEFAULT_CAPTURE_DEVICE_NAME);
+    } else {
+        ma_strcpy_s(devid, sizeof(devid), pDeviceID->sndio);
+        ma_strcpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), devid);
+    }
+
+    handle = ((ma_sio_open_proc)pContext->sndio.sio_open)(devid, (deviceType == ma_device_type_playback) ? MA_SIO_PLAY : MA_SIO_REC, 0);
+    if (handle == NULL) {
+        return MA_NO_DEVICE;
+    }
+
+    if (((ma_sio_getcap_proc)pContext->sndio.sio_getcap)(handle, &caps) == 0) {
+        return MA_ERROR;
+    }
+
+    pDeviceInfo->nativeDataFormatCount = 0;
+
+    for (iConfig = 0; iConfig < caps.nconf; iConfig += 1) {
+        /*
+        The main thing we care about is that the encoding is supported by miniaudio. If it is, we want to give
+        preference to some formats over others.
+        */
+        unsigned int iEncoding;
+        unsigned int iChannel;
+        unsigned int iRate;
+
+        for (iEncoding = 0; iEncoding < MA_SIO_NENC; iEncoding += 1) {
+            unsigned int bits;
+            unsigned int bps;
+            unsigned int sig;
+            unsigned int le;
+            unsigned int msb;
+            ma_format format;
+
+            if ((caps.confs[iConfig].enc & (1UL << iEncoding)) == 0) {
+                continue;
+            }
+
+            bits = caps.enc[iEncoding].bits;
+            bps  = caps.enc[iEncoding].bps;
+            sig  = caps.enc[iEncoding].sig;
+            le   = caps.enc[iEncoding].le;
+            msb  = caps.enc[iEncoding].msb;
+            format = ma_format_from_sio_enc__sndio(bits, bps, sig, le, msb);
+            if (format == ma_format_unknown) {
+                continue;   /* Format not supported. */
+            }
+
+
+            /* Channels. */
+            for (iChannel = 0; iChannel < MA_SIO_NCHAN; iChannel += 1) {
+                unsigned int chan = 0;
+                unsigned int channels;
+
+                if (deviceType == ma_device_type_playback) {
+                    chan = caps.confs[iConfig].pchan;
+                } else {
+                    chan = caps.confs[iConfig].rchan;
+                }
+
+                if ((chan & (1UL << iChannel)) == 0) {
+                    continue;
+                }
+
+                if (deviceType == ma_device_type_playback) {
+                    channels = caps.pchan[iChannel];
+                } else {
+                    channels = caps.rchan[iChannel];
+                }
+
+
+                /* Sample Rates. */
+                for (iRate = 0; iRate < MA_SIO_NRATE; iRate += 1) {
+                    if ((caps.confs[iConfig].rate & (1UL << iRate)) != 0) {
+                        ma_device_info_add_native_data_format(pDeviceInfo, format, channels, caps.rate[iRate], 0);
+                    }
+                }
+            }
+        }
+    }
+
+    ((ma_sio_close_proc)pContext->sndio.sio_close)(handle);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_uninit__sndio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)pDevice->sndio.handleCapture);
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init_handle__sndio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptor, ma_device_type deviceType)
+{
+    const char* pDeviceName;
+    ma_ptr handle;
+    int openFlags = 0;
+    struct ma_sio_cap caps;
+    struct ma_sio_par par;
+    const ma_device_id* pDeviceID;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_format internalFormat;
+    ma_uint32 internalChannels;
+    ma_uint32 internalSampleRate;
+    ma_uint32 internalPeriodSizeInFrames;
+    ma_uint32 internalPeriods;
+
+    MA_ASSERT(pConfig    != NULL);
+    MA_ASSERT(deviceType != ma_device_type_duplex);
+    MA_ASSERT(pDevice    != NULL);
+
+    if (deviceType == ma_device_type_capture) {
+        openFlags = MA_SIO_REC;
+    } else {
+        openFlags = MA_SIO_PLAY;
+    }
+
+    pDeviceID  = pDescriptor->pDeviceID;
+    format     = pDescriptor->format;
+    channels   = pDescriptor->channels;
+    sampleRate = pDescriptor->sampleRate;
+
+    pDeviceName = MA_SIO_DEVANY;
+    if (pDeviceID != NULL) {
+        pDeviceName = pDeviceID->sndio;
+    }
+
+    handle = (ma_ptr)((ma_sio_open_proc)pDevice->pContext->sndio.sio_open)(pDeviceName, openFlags, 0);
+    if (handle == NULL) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to open device.");
+        return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+    }
+
+    /* We need to retrieve the device caps to determine the most appropriate format to use. */
+    if (((ma_sio_getcap_proc)pDevice->pContext->sndio.sio_getcap)((struct ma_sio_hdl*)handle, &caps) == 0) {
+        ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)handle);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to retrieve device caps.");
+        return MA_ERROR;
+    }
+
+    /*
+    Note: sndio reports a huge range of available channels. This is inconvenient for us because there's no real
+    way, as far as I can tell, to get the _actual_ channel count of the device. I'm therefore restricting this
+    to the requested channels, regardless of whether or not the default channel count is requested.
+
+    For hardware devices, I'm suspecting only a single channel count will be reported and we can safely use the
+    value returned by ma_find_best_channels_from_sio_cap__sndio().
+    */
+    if (deviceType == ma_device_type_capture) {
+        if (format == ma_format_unknown) {
+            format = ma_find_best_format_from_sio_cap__sndio(&caps);
+        }
+
+        if (channels == 0) {
+            if (strlen(pDeviceName) > strlen("rsnd/") && strncmp(pDeviceName, "rsnd/", strlen("rsnd/")) == 0) {
+                channels = ma_find_best_channels_from_sio_cap__sndio(&caps, deviceType, format);
+            } else {
+                channels = MA_DEFAULT_CHANNELS;
+            }
+        }
+    } else {
+        if (format == ma_format_unknown) {
+            format = ma_find_best_format_from_sio_cap__sndio(&caps);
+        }
+
+        if (channels == 0) {
+            if (strlen(pDeviceName) > strlen("rsnd/") && strncmp(pDeviceName, "rsnd/", strlen("rsnd/")) == 0) {
+                channels = ma_find_best_channels_from_sio_cap__sndio(&caps, deviceType, format);
+            } else {
+                channels = MA_DEFAULT_CHANNELS;
+            }
+        }
+    }
+
+    if (sampleRate == 0) {
+        sampleRate = ma_find_best_sample_rate_from_sio_cap__sndio(&caps, pConfig->deviceType, format, channels);
+    }
+
+
+    ((ma_sio_initpar_proc)pDevice->pContext->sndio.sio_initpar)(&par);
+    par.msb = 0;
+    par.le  = ma_is_little_endian();
+
+    switch (format) {
+        case ma_format_u8:
+        {
+            par.bits = 8;
+            par.bps  = 1;
+            par.sig  = 0;
+        } break;
+
+        case ma_format_s24:
+        {
+            par.bits = 24;
+            par.bps  = 3;
+            par.sig  = 1;
+        } break;
+
+        case ma_format_s32:
+        {
+            par.bits = 32;
+            par.bps  = 4;
+            par.sig  = 1;
+        } break;
+
+        case ma_format_s16:
+        case ma_format_f32:
+        case ma_format_unknown:
+        default:
+        {
+            par.bits = 16;
+            par.bps  = 2;
+            par.sig  = 1;
+        } break;
+    }
+
+    if (deviceType == ma_device_type_capture) {
+        par.rchan = channels;
+    } else {
+        par.pchan = channels;
+    }
+
+    par.rate = sampleRate;
+
+    internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, par.rate, pConfig->performanceProfile);
+
+    par.round    = internalPeriodSizeInFrames;
+    par.appbufsz = par.round * pDescriptor->periodCount;
+
+    if (((ma_sio_setpar_proc)pDevice->pContext->sndio.sio_setpar)((struct ma_sio_hdl*)handle, &par) == 0) {
+        ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)handle);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to set buffer size.");
+        return MA_ERROR;
+    }
+
+    if (((ma_sio_getpar_proc)pDevice->pContext->sndio.sio_getpar)((struct ma_sio_hdl*)handle, &par) == 0) {
+        ((ma_sio_close_proc)pDevice->pContext->sndio.sio_close)((struct ma_sio_hdl*)handle);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to retrieve buffer size.");
+        return MA_ERROR;
+    }
+
+    internalFormat             = ma_format_from_sio_enc__sndio(par.bits, par.bps, par.sig, par.le, par.msb);
+    internalChannels           = (deviceType == ma_device_type_capture) ? par.rchan : par.pchan;
+    internalSampleRate         = par.rate;
+    internalPeriods            = par.appbufsz / par.round;
+    internalPeriodSizeInFrames = par.round;
+
+    if (deviceType == ma_device_type_capture) {
+        pDevice->sndio.handleCapture  = handle;
+    } else {
+        pDevice->sndio.handlePlayback = handle;
+    }
+
+    pDescriptor->format             = internalFormat;
+    pDescriptor->channels           = internalChannels;
+    pDescriptor->sampleRate         = internalSampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_sndio, pDescriptor->channelMap, ma_countof(pDescriptor->channelMap), internalChannels);
+    pDescriptor->periodSizeInFrames = internalPeriodSizeInFrames;
+    pDescriptor->periodCount        = internalPeriods;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__sndio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->sndio);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_handle__sndio(pDevice, pConfig, pDescriptorCapture, ma_device_type_capture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_handle__sndio(pDevice, pConfig, pDescriptorPlayback, ma_device_type_playback);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__sndio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_start_proc)pDevice->pContext->sndio.sio_start)((struct ma_sio_hdl*)pDevice->sndio.handleCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_start_proc)pDevice->pContext->sndio.sio_start)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback);   /* <-- Doesn't actually playback until data is written. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__sndio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    From the documentation:
+
+        The sio_stop() function puts the audio subsystem in the same state as before sio_start() is called. It stops recording, drains the play buffer and then
+        stops playback. If samples to play are queued but playback hasn't started yet then playback is forced immediately; playback will actually stop once the
+        buffer is drained. In no case are samples in the play buffer discarded.
+
+    Therefore, sio_stop() performs all of the necessary draining for us.
+    */
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_stop_proc)pDevice->pContext->sndio.sio_stop)((struct ma_sio_hdl*)pDevice->sndio.handleCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ((ma_sio_stop_proc)pDevice->pContext->sndio.sio_stop)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_write__sndio(ma_device* pDevice, const void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    int result;
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    result = ((ma_sio_write_proc)pDevice->pContext->sndio.sio_write)((struct ma_sio_hdl*)pDevice->sndio.handlePlayback, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+    if (result == 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to send data from the client to the device.");
+        return MA_IO_ERROR;
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_read__sndio(ma_device* pDevice, void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    int result;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    result = ((ma_sio_read_proc)pDevice->pContext->sndio.sio_read)((struct ma_sio_hdl*)pDevice->sndio.handleCapture, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels));
+    if (result == 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[sndio] Failed to read data from the device to be sent to the device.");
+        return MA_IO_ERROR;
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__sndio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_sndio);
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__sndio(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+#ifndef MA_NO_RUNTIME_LINKING
+    const char* libsndioNames[] = {
+        "libsndio.so"
+    };
+    size_t i;
+
+    for (i = 0; i < ma_countof(libsndioNames); ++i) {
+        pContext->sndio.sndioSO = ma_dlopen(ma_context_get_log(pContext), libsndioNames[i]);
+        if (pContext->sndio.sndioSO != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->sndio.sndioSO == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    pContext->sndio.sio_open    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_open");
+    pContext->sndio.sio_close   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_close");
+    pContext->sndio.sio_setpar  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_setpar");
+    pContext->sndio.sio_getpar  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_getpar");
+    pContext->sndio.sio_getcap  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_getcap");
+    pContext->sndio.sio_write   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_write");
+    pContext->sndio.sio_read    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_read");
+    pContext->sndio.sio_start   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_start");
+    pContext->sndio.sio_stop    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_stop");
+    pContext->sndio.sio_initpar = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->sndio.sndioSO, "sio_initpar");
+#else
+    pContext->sndio.sio_open    = sio_open;
+    pContext->sndio.sio_close   = sio_close;
+    pContext->sndio.sio_setpar  = sio_setpar;
+    pContext->sndio.sio_getpar  = sio_getpar;
+    pContext->sndio.sio_getcap  = sio_getcap;
+    pContext->sndio.sio_write   = sio_write;
+    pContext->sndio.sio_read    = sio_read;
+    pContext->sndio.sio_start   = sio_start;
+    pContext->sndio.sio_stop    = sio_stop;
+    pContext->sndio.sio_initpar = sio_initpar;
+#endif
+
+    pCallbacks->onContextInit             = ma_context_init__sndio;
+    pCallbacks->onContextUninit           = ma_context_uninit__sndio;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__sndio;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__sndio;
+    pCallbacks->onDeviceInit              = ma_device_init__sndio;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__sndio;
+    pCallbacks->onDeviceStart             = ma_device_start__sndio;
+    pCallbacks->onDeviceStop              = ma_device_stop__sndio;
+    pCallbacks->onDeviceRead              = ma_device_read__sndio;
+    pCallbacks->onDeviceWrite             = ma_device_write__sndio;
+    pCallbacks->onDeviceDataLoop          = NULL;
+
+    (void)pConfig;
+    return MA_SUCCESS;
+}
+#endif  /* sndio */
+
+
+
+/******************************************************************************
+
+audio(4) Backend
+
+******************************************************************************/
+#ifdef MA_HAS_AUDIO4
+#include <fcntl.h>
+#include <poll.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/audioio.h>
+
+#if defined(__OpenBSD__)
+    #include <sys/param.h>
+    #if defined(OpenBSD) && OpenBSD >= 201709
+        #define MA_AUDIO4_USE_NEW_API
+    #endif
+#endif
+
+static void ma_construct_device_id__audio4(char* id, size_t idSize, const char* base, int deviceIndex)
+{
+    size_t baseLen;
+
+    MA_ASSERT(id != NULL);
+    MA_ASSERT(idSize > 0);
+    MA_ASSERT(deviceIndex >= 0);
+
+    baseLen = strlen(base);
+    MA_ASSERT(idSize > baseLen);
+
+    ma_strcpy_s(id, idSize, base);
+    ma_itoa_s(deviceIndex, id+baseLen, idSize-baseLen, 10);
+}
+
+static ma_result ma_extract_device_index_from_id__audio4(const char* id, const char* base, int* pIndexOut)
+{
+    size_t idLen;
+    size_t baseLen;
+    const char* deviceIndexStr;
+
+    MA_ASSERT(id != NULL);
+    MA_ASSERT(base != NULL);
+    MA_ASSERT(pIndexOut != NULL);
+
+    idLen = strlen(id);
+    baseLen = strlen(base);
+    if (idLen <= baseLen) {
+        return MA_ERROR;   /* Doesn't look like the id starts with the base. */
+    }
+
+    if (strncmp(id, base, baseLen) != 0) {
+        return MA_ERROR;   /* ID does not begin with base. */
+    }
+
+    deviceIndexStr = id + baseLen;
+    if (deviceIndexStr[0] == '\0') {
+        return MA_ERROR;   /* No index specified in the ID. */
+    }
+
+    if (pIndexOut) {
+        *pIndexOut = atoi(deviceIndexStr);
+    }
+
+    return MA_SUCCESS;
+}
+
+
+#if !defined(MA_AUDIO4_USE_NEW_API)    /* Old API */
+static ma_format ma_format_from_encoding__audio4(unsigned int encoding, unsigned int precision)
+{
+    if (precision == 8 && (encoding == AUDIO_ENCODING_ULINEAR || encoding == AUDIO_ENCODING_ULINEAR || encoding == AUDIO_ENCODING_ULINEAR_LE || encoding == AUDIO_ENCODING_ULINEAR_BE)) {
+        return ma_format_u8;
+    } else {
+        if (ma_is_little_endian() && encoding == AUDIO_ENCODING_SLINEAR_LE) {
+            if (precision == 16) {
+                return ma_format_s16;
+            } else if (precision == 24) {
+                return ma_format_s24;
+            } else if (precision == 32) {
+                return ma_format_s32;
+            }
+        } else if (ma_is_big_endian() && encoding == AUDIO_ENCODING_SLINEAR_BE) {
+            if (precision == 16) {
+                return ma_format_s16;
+            } else if (precision == 24) {
+                return ma_format_s24;
+            } else if (precision == 32) {
+                return ma_format_s32;
+            }
+        }
+    }
+
+    return ma_format_unknown;  /* Encoding not supported. */
+}
+
+static void ma_encoding_from_format__audio4(ma_format format, unsigned int* pEncoding, unsigned int* pPrecision)
+{
+    MA_ASSERT(pEncoding  != NULL);
+    MA_ASSERT(pPrecision != NULL);
+
+    switch (format)
+    {
+        case ma_format_u8:
+        {
+            *pEncoding = AUDIO_ENCODING_ULINEAR;
+            *pPrecision = 8;
+        } break;
+
+        case ma_format_s24:
+        {
+            *pEncoding = (ma_is_little_endian()) ? AUDIO_ENCODING_SLINEAR_LE : AUDIO_ENCODING_SLINEAR_BE;
+            *pPrecision = 24;
+        } break;
+
+        case ma_format_s32:
+        {
+            *pEncoding = (ma_is_little_endian()) ? AUDIO_ENCODING_SLINEAR_LE : AUDIO_ENCODING_SLINEAR_BE;
+            *pPrecision = 32;
+        } break;
+
+        case ma_format_s16:
+        case ma_format_f32:
+        case ma_format_unknown:
+        default:
+        {
+            *pEncoding = (ma_is_little_endian()) ? AUDIO_ENCODING_SLINEAR_LE : AUDIO_ENCODING_SLINEAR_BE;
+            *pPrecision = 16;
+        } break;
+    }
+}
+
+static ma_format ma_format_from_prinfo__audio4(struct audio_prinfo* prinfo)
+{
+    return ma_format_from_encoding__audio4(prinfo->encoding, prinfo->precision);
+}
+
+static ma_format ma_best_format_from_fd__audio4(int fd, ma_format preferredFormat)
+{
+    audio_encoding_t encoding;
+    ma_uint32 iFormat;
+    int counter = 0;
+
+    /* First check to see if the preferred format is supported. */
+    if (preferredFormat != ma_format_unknown) {
+        counter = 0;
+        for (;;) {
+            MA_ZERO_OBJECT(&encoding);
+            encoding.index = counter;
+            if (ioctl(fd, AUDIO_GETENC, &encoding) < 0) {
+                break;
+            }
+
+            if (preferredFormat == ma_format_from_encoding__audio4(encoding.encoding, encoding.precision)) {
+                return preferredFormat;  /* Found the preferred format. */
+            }
+
+            /* Getting here means this encoding does not match our preferred format so we need to more on to the next encoding. */
+            counter += 1;
+        }
+    }
+
+    /* Getting here means our preferred format is not supported, so fall back to our standard priorities. */
+    for (iFormat = 0; iFormat < ma_countof(g_maFormatPriorities); iFormat += 1) {
+        ma_format format = g_maFormatPriorities[iFormat];
+
+        counter = 0;
+        for (;;) {
+            MA_ZERO_OBJECT(&encoding);
+            encoding.index = counter;
+            if (ioctl(fd, AUDIO_GETENC, &encoding) < 0) {
+                break;
+            }
+
+            if (format == ma_format_from_encoding__audio4(encoding.encoding, encoding.precision)) {
+                return format;  /* Found a workable format. */
+            }
+
+            /* Getting here means this encoding does not match our preferred format so we need to more on to the next encoding. */
+            counter += 1;
+        }
+    }
+
+    /* Getting here means not appropriate format was found. */
+    return ma_format_unknown;
+}
+#else
+static ma_format ma_format_from_swpar__audio4(struct audio_swpar* par)
+{
+    if (par->bits == 8 && par->bps == 1 && par->sig == 0) {
+        return ma_format_u8;
+    }
+    if (par->bits == 16 && par->bps == 2 && par->sig == 1 && par->le == ma_is_little_endian()) {
+        return ma_format_s16;
+    }
+    if (par->bits == 24 && par->bps == 3 && par->sig == 1 && par->le == ma_is_little_endian()) {
+        return ma_format_s24;
+    }
+    if (par->bits == 32 && par->bps == 4 && par->sig == 1 && par->le == ma_is_little_endian()) {
+        return ma_format_f32;
+    }
+
+    /* Format not supported. */
+    return ma_format_unknown;
+}
+#endif
+
+static ma_result ma_context_get_device_info_from_fd__audio4(ma_context* pContext, ma_device_type deviceType, int fd, ma_device_info* pDeviceInfo)
+{
+    audio_device_t fdDevice;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(fd >= 0);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    (void)pContext;
+    (void)deviceType;
+
+    if (ioctl(fd, AUDIO_GETDEV, &fdDevice) < 0) {
+        return MA_ERROR;   /* Failed to retrieve device info. */
+    }
+
+    /* Name. */
+    ma_strcpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), fdDevice.name);
+
+    #if !defined(MA_AUDIO4_USE_NEW_API)
+    {
+        audio_info_t fdInfo;
+        int counter = 0;
+        ma_uint32 channels;
+        ma_uint32 sampleRate;
+
+        if (ioctl(fd, AUDIO_GETINFO, &fdInfo) < 0) {
+            return MA_ERROR;
+        }
+
+        if (deviceType == ma_device_type_playback) {
+            channels   = fdInfo.play.channels;
+            sampleRate = fdInfo.play.sample_rate;
+        } else {
+            channels   = fdInfo.record.channels;
+            sampleRate = fdInfo.record.sample_rate;
+        }
+
+        /* Supported formats. We get this by looking at the encodings. */
+        pDeviceInfo->nativeDataFormatCount = 0;
+        for (;;) {
+            audio_encoding_t encoding;
+            ma_format format;
+
+            MA_ZERO_OBJECT(&encoding);
+            encoding.index = counter;
+            if (ioctl(fd, AUDIO_GETENC, &encoding) < 0) {
+                break;
+            }
+
+            format = ma_format_from_encoding__audio4(encoding.encoding, encoding.precision);
+            if (format != ma_format_unknown) {
+                ma_device_info_add_native_data_format(pDeviceInfo, format, channels, sampleRate, 0);
+            }
+
+            counter += 1;
+        }
+    }
+    #else
+    {
+        struct audio_swpar fdPar;
+        ma_format format;
+        ma_uint32 channels;
+        ma_uint32 sampleRate;
+
+        if (ioctl(fd, AUDIO_GETPAR, &fdPar) < 0) {
+            return MA_ERROR;
+        }
+
+        format = ma_format_from_swpar__audio4(&fdPar);
+        if (format == ma_format_unknown) {
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        if (deviceType == ma_device_type_playback) {
+            channels = fdPar.pchan;
+        } else {
+            channels = fdPar.rchan;
+        }
+
+        sampleRate = fdPar.rate;
+
+        pDeviceInfo->nativeDataFormatCount = 0;
+        ma_device_info_add_native_data_format(pDeviceInfo, format, channels, sampleRate, 0);
+    }
+    #endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_enumerate_devices__audio4(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    const int maxDevices = 64;
+    char devpath[256];
+    int iDevice;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /*
+    Every device will be named "/dev/audioN", with a "/dev/audioctlN" equivalent. We use the "/dev/audioctlN"
+    version here since we can open it even when another process has control of the "/dev/audioN" device.
+    */
+    for (iDevice = 0; iDevice < maxDevices; ++iDevice) {
+        struct stat st;
+        int fd;
+        ma_bool32 isTerminating = MA_FALSE;
+
+        ma_strcpy_s(devpath, sizeof(devpath), "/dev/audioctl");
+        ma_itoa_s(iDevice, devpath+strlen(devpath), sizeof(devpath)-strlen(devpath), 10);
+
+        if (stat(devpath, &st) < 0) {
+            break;
+        }
+
+        /* The device exists, but we need to check if it's usable as playback and/or capture. */
+
+        /* Playback. */
+        if (!isTerminating) {
+            fd = open(devpath, O_RDONLY, 0);
+            if (fd >= 0) {
+                /* Supports playback. */
+                ma_device_info deviceInfo;
+                MA_ZERO_OBJECT(&deviceInfo);
+                ma_construct_device_id__audio4(deviceInfo.id.audio4, sizeof(deviceInfo.id.audio4), "/dev/audio", iDevice);
+                if (ma_context_get_device_info_from_fd__audio4(pContext, ma_device_type_playback, fd, &deviceInfo) == MA_SUCCESS) {
+                    isTerminating = !callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+                }
+
+                close(fd);
+            }
+        }
+
+        /* Capture. */
+        if (!isTerminating) {
+            fd = open(devpath, O_WRONLY, 0);
+            if (fd >= 0) {
+                /* Supports capture. */
+                ma_device_info deviceInfo;
+                MA_ZERO_OBJECT(&deviceInfo);
+                ma_construct_device_id__audio4(deviceInfo.id.audio4, sizeof(deviceInfo.id.audio4), "/dev/audio", iDevice);
+                if (ma_context_get_device_info_from_fd__audio4(pContext, ma_device_type_capture, fd, &deviceInfo) == MA_SUCCESS) {
+                    isTerminating = !callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+                }
+
+                close(fd);
+            }
+        }
+
+        if (isTerminating) {
+            break;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__audio4(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    int fd = -1;
+    int deviceIndex = -1;
+    char ctlid[256];
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+    /*
+    We need to open the "/dev/audioctlN" device to get the info. To do this we need to extract the number
+    from the device ID which will be in "/dev/audioN" format.
+    */
+    if (pDeviceID == NULL) {
+        /* Default device. */
+        ma_strcpy_s(ctlid, sizeof(ctlid), "/dev/audioctl");
+    } else {
+        /* Specific device. We need to convert from "/dev/audioN" to "/dev/audioctlN". */
+        result = ma_extract_device_index_from_id__audio4(pDeviceID->audio4, "/dev/audio", &deviceIndex);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        ma_construct_device_id__audio4(ctlid, sizeof(ctlid), "/dev/audioctl", deviceIndex);
+    }
+
+    fd = open(ctlid, (deviceType == ma_device_type_playback) ? O_WRONLY : O_RDONLY, 0);
+    if (fd == -1) {
+        return MA_NO_DEVICE;
+    }
+
+    if (deviceIndex == -1) {
+        ma_strcpy_s(pDeviceInfo->id.audio4, sizeof(pDeviceInfo->id.audio4), "/dev/audio");
+    } else {
+        ma_construct_device_id__audio4(pDeviceInfo->id.audio4, sizeof(pDeviceInfo->id.audio4), "/dev/audio", deviceIndex);
+    }
+
+    result = ma_context_get_device_info_from_fd__audio4(pContext, deviceType, fd, pDeviceInfo);
+
+    close(fd);
+    return result;
+}
+
+static ma_result ma_device_uninit__audio4(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        close(pDevice->audio4.fdCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        close(pDevice->audio4.fdPlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init_fd__audio4(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptor, ma_device_type deviceType)
+{
+    const char* pDefaultDeviceNames[] = {
+        "/dev/audio",
+        "/dev/audio0"
+    };
+    const char* pDefaultDeviceCtlNames[] = {
+        "/dev/audioctl",
+        "/dev/audioctl0"
+    };
+    int fd;
+    int fdFlags = 0;
+    size_t iDefaultDevice = (size_t)-1;
+    ma_format internalFormat;
+    ma_uint32 internalChannels;
+    ma_uint32 internalSampleRate;
+    ma_uint32 internalPeriodSizeInFrames;
+    ma_uint32 internalPeriods;
+
+    MA_ASSERT(pConfig    != NULL);
+    MA_ASSERT(deviceType != ma_device_type_duplex);
+    MA_ASSERT(pDevice    != NULL);
+
+    /* The first thing to do is open the file. */
+    if (deviceType == ma_device_type_capture) {
+        fdFlags = O_RDONLY;
+    } else {
+        fdFlags = O_WRONLY;
+    }
+    /*fdFlags |= O_NONBLOCK;*/
+
+    /* Find the index of the default device as a start. We'll use this index later. Set it to (size_t)-1 otherwise. */
+    if (pDescriptor->pDeviceID == NULL) {
+        /* Default device. */
+        for (iDefaultDevice = 0; iDefaultDevice < ma_countof(pDefaultDeviceNames); ++iDefaultDevice) {
+            fd = open(pDefaultDeviceNames[iDefaultDevice], fdFlags, 0);
+            if (fd != -1) {
+                break;
+            }
+        }
+    } else {
+        /* Specific device. */
+        fd = open(pDescriptor->pDeviceID->audio4, fdFlags, 0);
+
+        for (iDefaultDevice = 0; iDefaultDevice < ma_countof(pDefaultDeviceNames); iDefaultDevice += 1) {
+            if (ma_strcmp(pDefaultDeviceNames[iDefaultDevice], pDescriptor->pDeviceID->audio4) == 0) {
+                break;
+            }
+        }
+
+        if (iDefaultDevice == ma_countof(pDefaultDeviceNames)) {
+            iDefaultDevice = (size_t)-1;
+        }
+    }
+
+    if (fd == -1) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to open device.");
+        return ma_result_from_errno(errno);
+    }
+
+    #if !defined(MA_AUDIO4_USE_NEW_API)    /* Old API */
+    {
+        audio_info_t fdInfo;
+        int fdInfoResult = -1;
+
+        /*
+        The documentation is a little bit unclear to me as to how it handles formats. It says the
+        following:
+
+            Regardless of formats supported by underlying driver, the audio driver accepts the
+            following formats.
+
+        By then the next sentence says this:
+
+            `encoding` and `precision` are one of the values obtained by AUDIO_GETENC.
+
+        It sounds like a direct contradiction to me. I'm going to play this safe any only use the
+        best sample format returned by AUDIO_GETENC. If the requested format is supported we'll
+        use that, but otherwise we'll just use our standard format priorities to pick an
+        appropriate one.
+        */
+        AUDIO_INITINFO(&fdInfo);
+
+        /*
+        Get the default format from the audioctl file if we're asking for a default device. If we
+        retrieve it from /dev/audio it'll default to mono 8000Hz.
+        */
+        if (iDefaultDevice != (size_t)-1) {
+            /* We're using a default device. Get the info from the /dev/audioctl file instead of /dev/audio. */
+            int fdctl = open(pDefaultDeviceCtlNames[iDefaultDevice], fdFlags, 0);
+            if (fdctl != -1) {
+                fdInfoResult = ioctl(fdctl, AUDIO_GETINFO, &fdInfo);
+                close(fdctl);
+            }
+        }
+
+        if (fdInfoResult == -1) {
+            /* We still don't have the default device info so just retrieve it from the main audio device. */
+            if (ioctl(fd, AUDIO_GETINFO, &fdInfo) < 0) {
+                close(fd);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] AUDIO_GETINFO failed.");
+                return ma_result_from_errno(errno);
+            }
+        }
+
+        /* We get the driver to do as much of the data conversion as possible. */
+        if (deviceType == ma_device_type_capture) {
+            fdInfo.mode = AUMODE_RECORD;
+            ma_encoding_from_format__audio4(ma_best_format_from_fd__audio4(fd, pDescriptor->format), &fdInfo.record.encoding, &fdInfo.record.precision);
+
+            if (pDescriptor->channels != 0) {
+                fdInfo.record.channels = ma_clamp(pDescriptor->channels, 1, 12);    /* From the documentation: `channels` ranges from 1 to 12. */
+            }
+
+            if (pDescriptor->sampleRate != 0) {
+                fdInfo.record.sample_rate = ma_clamp(pDescriptor->sampleRate, 1000, 192000);    /* From the documentation: `frequency` ranges from 1000Hz to 192000Hz. (They mean `sample_rate` instead of `frequency`.) */
+            }
+        } else {
+            fdInfo.mode = AUMODE_PLAY;
+            ma_encoding_from_format__audio4(ma_best_format_from_fd__audio4(fd, pDescriptor->format), &fdInfo.play.encoding, &fdInfo.play.precision);
+
+            if (pDescriptor->channels != 0) {
+                fdInfo.play.channels = ma_clamp(pDescriptor->channels, 1, 12);    /* From the documentation: `channels` ranges from 1 to 12. */
+            }
+
+            if (pDescriptor->sampleRate != 0) {
+                fdInfo.play.sample_rate = ma_clamp(pDescriptor->sampleRate, 1000, 192000);    /* From the documentation: `frequency` ranges from 1000Hz to 192000Hz. (They mean `sample_rate` instead of `frequency`.) */
+            }
+        }
+
+        if (ioctl(fd, AUDIO_SETINFO, &fdInfo) < 0) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to set device format. AUDIO_SETINFO failed.");
+            return ma_result_from_errno(errno);
+        }
+
+        if (ioctl(fd, AUDIO_GETINFO, &fdInfo) < 0) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] AUDIO_GETINFO failed.");
+            return ma_result_from_errno(errno);
+        }
+
+        if (deviceType == ma_device_type_capture) {
+            internalFormat     = ma_format_from_prinfo__audio4(&fdInfo.record);
+            internalChannels   = fdInfo.record.channels;
+            internalSampleRate = fdInfo.record.sample_rate;
+        } else {
+            internalFormat     = ma_format_from_prinfo__audio4(&fdInfo.play);
+            internalChannels   = fdInfo.play.channels;
+            internalSampleRate = fdInfo.play.sample_rate;
+        }
+
+        if (internalFormat == ma_format_unknown) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] The device's internal device format is not supported by miniaudio. The device is unusable.");
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        /* Buffer. */
+        {
+            ma_uint32 internalPeriodSizeInBytes;
+
+            internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, internalSampleRate, pConfig->performanceProfile);
+
+            internalPeriodSizeInBytes = internalPeriodSizeInFrames * ma_get_bytes_per_frame(internalFormat, internalChannels);
+            if (internalPeriodSizeInBytes < 16) {
+                internalPeriodSizeInBytes = 16;
+            }
+
+            internalPeriods = pDescriptor->periodCount;
+            if (internalPeriods < 2) {
+                internalPeriods = 2;
+            }
+
+            /* What miniaudio calls a period, audio4 calls a block. */
+            AUDIO_INITINFO(&fdInfo);
+            fdInfo.hiwat     = internalPeriods;
+            fdInfo.lowat     = internalPeriods-1;
+            fdInfo.blocksize = internalPeriodSizeInBytes;
+            if (ioctl(fd, AUDIO_SETINFO, &fdInfo) < 0) {
+                close(fd);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to set internal buffer size. AUDIO_SETINFO failed.");
+                return ma_result_from_errno(errno);
+            }
+
+            internalPeriods            = fdInfo.hiwat;
+            internalPeriodSizeInFrames = fdInfo.blocksize / ma_get_bytes_per_frame(internalFormat, internalChannels);
+        }
+    }
+    #else
+    {
+        struct audio_swpar fdPar;
+
+        /* We need to retrieve the format of the device so we can know the channel count and sample rate. Then we can calculate the buffer size. */
+        if (ioctl(fd, AUDIO_GETPAR, &fdPar) < 0) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to retrieve initial device parameters.");
+            return ma_result_from_errno(errno);
+        }
+
+        internalFormat     = ma_format_from_swpar__audio4(&fdPar);
+        internalChannels   = (deviceType == ma_device_type_capture) ? fdPar.rchan : fdPar.pchan;
+        internalSampleRate = fdPar.rate;
+
+        if (internalFormat == ma_format_unknown) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] The device's internal device format is not supported by miniaudio. The device is unusable.");
+            return MA_FORMAT_NOT_SUPPORTED;
+        }
+
+        /* Buffer. */
+        {
+            ma_uint32 internalPeriodSizeInBytes;
+
+            internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, internalSampleRate, pConfig->performanceProfile);
+
+            /* What miniaudio calls a period, audio4 calls a block. */
+            internalPeriodSizeInBytes = internalPeriodSizeInFrames * ma_get_bytes_per_frame(internalFormat, internalChannels);
+            if (internalPeriodSizeInBytes < 16) {
+                internalPeriodSizeInBytes = 16;
+            }
+
+            fdPar.nblks = pDescriptor->periodCount;
+            fdPar.round = internalPeriodSizeInBytes;
+
+            if (ioctl(fd, AUDIO_SETPAR, &fdPar) < 0) {
+                close(fd);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to set device parameters.");
+                return ma_result_from_errno(errno);
+            }
+
+            if (ioctl(fd, AUDIO_GETPAR, &fdPar) < 0) {
+                close(fd);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to retrieve actual device parameters.");
+                return ma_result_from_errno(errno);
+            }
+        }
+
+        internalFormat             = ma_format_from_swpar__audio4(&fdPar);
+        internalChannels           = (deviceType == ma_device_type_capture) ? fdPar.rchan : fdPar.pchan;
+        internalSampleRate         = fdPar.rate;
+        internalPeriods            = fdPar.nblks;
+        internalPeriodSizeInFrames = fdPar.round / ma_get_bytes_per_frame(internalFormat, internalChannels);
+    }
+    #endif
+
+    if (internalFormat == ma_format_unknown) {
+        close(fd);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] The device's internal device format is not supported by miniaudio. The device is unusable.");
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    if (deviceType == ma_device_type_capture) {
+        pDevice->audio4.fdCapture  = fd;
+    } else {
+        pDevice->audio4.fdPlayback = fd;
+    }
+
+    pDescriptor->format             = internalFormat;
+    pDescriptor->channels           = internalChannels;
+    pDescriptor->sampleRate         = internalSampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_sound4, pDescriptor->channelMap, ma_countof(pDescriptor->channelMap), internalChannels);
+    pDescriptor->periodSizeInFrames = internalPeriodSizeInFrames;
+    pDescriptor->periodCount        = internalPeriods;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__audio4(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->audio4);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    pDevice->audio4.fdCapture  = -1;
+    pDevice->audio4.fdPlayback = -1;
+
+    /*
+    The version of the operating system dictates whether or not the device is exclusive or shared. NetBSD
+    introduced in-kernel mixing which means it's shared. All other BSD flavours are exclusive as far as
+    I'm aware.
+    */
+#if defined(__NetBSD_Version__) && __NetBSD_Version__ >= 800000000
+    /* NetBSD 8.0+ */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+#else
+    /* All other flavors. */
+#endif
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_fd__audio4(pDevice, pConfig, pDescriptorCapture, ma_device_type_capture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_fd__audio4(pDevice, pConfig, pDescriptorPlayback, ma_device_type_playback);
+        if (result != MA_SUCCESS) {
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                close(pDevice->audio4.fdCapture);
+            }
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__audio4(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->audio4.fdCapture == -1) {
+            return MA_INVALID_ARGS;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->audio4.fdPlayback == -1) {
+            return MA_INVALID_ARGS;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop_fd__audio4(ma_device* pDevice, int fd)
+{
+    if (fd == -1) {
+        return MA_INVALID_ARGS;
+    }
+
+#if !defined(MA_AUDIO4_USE_NEW_API)
+    if (ioctl(fd, AUDIO_FLUSH, 0) < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to stop device. AUDIO_FLUSH failed.");
+        return ma_result_from_errno(errno);
+    }
+#else
+    if (ioctl(fd, AUDIO_STOP, 0) < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to stop device. AUDIO_STOP failed.");
+        return ma_result_from_errno(errno);
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__audio4(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_result result;
+
+        result = ma_device_stop_fd__audio4(pDevice, pDevice->audio4.fdCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_result result;
+
+        /* Drain the device first. If this fails we'll just need to flush without draining. Unfortunately draining isn't available on newer version of OpenBSD. */
+    #if !defined(MA_AUDIO4_USE_NEW_API)
+        ioctl(pDevice->audio4.fdPlayback, AUDIO_DRAIN, 0);
+    #endif
+
+        /* Here is where the device is stopped immediately. */
+        result = ma_device_stop_fd__audio4(pDevice, pDevice->audio4.fdPlayback);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_write__audio4(ma_device* pDevice, const void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    int result;
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    result = write(pDevice->audio4.fdPlayback, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+    if (result < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to write data to the device.");
+        return ma_result_from_errno(errno);
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = (ma_uint32)result / ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_read__audio4(ma_device* pDevice, void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    int result;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    result = read(pDevice->audio4.fdCapture, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels));
+    if (result < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[audio4] Failed to read data from the device.");
+        return ma_result_from_errno(errno);
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = (ma_uint32)result / ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__audio4(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_audio4);
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__audio4(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+    pCallbacks->onContextInit             = ma_context_init__audio4;
+    pCallbacks->onContextUninit           = ma_context_uninit__audio4;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__audio4;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__audio4;
+    pCallbacks->onDeviceInit              = ma_device_init__audio4;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__audio4;
+    pCallbacks->onDeviceStart             = ma_device_start__audio4;
+    pCallbacks->onDeviceStop              = ma_device_stop__audio4;
+    pCallbacks->onDeviceRead              = ma_device_read__audio4;
+    pCallbacks->onDeviceWrite             = ma_device_write__audio4;
+    pCallbacks->onDeviceDataLoop          = NULL;
+
+    return MA_SUCCESS;
+}
+#endif  /* audio4 */
+
+
+/******************************************************************************
+
+OSS Backend
+
+******************************************************************************/
+#ifdef MA_HAS_OSS
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/soundcard.h>
+
+#ifndef SNDCTL_DSP_HALT
+#define SNDCTL_DSP_HALT SNDCTL_DSP_RESET
+#endif
+
+#define MA_OSS_DEFAULT_DEVICE_NAME  "/dev/dsp"
+
+static int ma_open_temp_device__oss()
+{
+    /* The OSS sample code uses "/dev/mixer" as the device for getting system properties so I'm going to do the same. */
+    int fd = open("/dev/mixer", O_RDONLY, 0);
+    if (fd >= 0) {
+        return fd;
+    }
+
+    return -1;
+}
+
+static ma_result ma_context_open_device__oss(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_share_mode shareMode, int* pfd)
+{
+    const char* deviceName;
+    int flags;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pfd != NULL);
+    (void)pContext;
+
+    *pfd = -1;
+
+    /* This function should only be called for playback or capture, not duplex. */
+    if (deviceType == ma_device_type_duplex) {
+        return MA_INVALID_ARGS;
+    }
+
+    deviceName = MA_OSS_DEFAULT_DEVICE_NAME;
+    if (pDeviceID != NULL) {
+        deviceName = pDeviceID->oss;
+    }
+
+    flags = (deviceType == ma_device_type_playback) ? O_WRONLY : O_RDONLY;
+    if (shareMode == ma_share_mode_exclusive) {
+        flags |= O_EXCL;
+    }
+
+    *pfd = open(deviceName, flags, 0);
+    if (*pfd == -1) {
+        return ma_result_from_errno(errno);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_enumerate_devices__oss(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    int fd;
+    oss_sysinfo si;
+    int result;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    fd = ma_open_temp_device__oss();
+    if (fd == -1) {
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open a temporary device for retrieving system information used for device enumeration.");
+        return MA_NO_BACKEND;
+    }
+
+    result = ioctl(fd, SNDCTL_SYSINFO, &si);
+    if (result != -1) {
+        int iAudioDevice;
+        for (iAudioDevice = 0; iAudioDevice < si.numaudios; ++iAudioDevice) {
+            oss_audioinfo ai;
+            ai.dev = iAudioDevice;
+            result = ioctl(fd, SNDCTL_AUDIOINFO, &ai);
+            if (result != -1) {
+                if (ai.devnode[0] != '\0') {    /* <-- Can be blank, according to documentation. */
+                    ma_device_info deviceInfo;
+                    ma_bool32 isTerminating = MA_FALSE;
+
+                    MA_ZERO_OBJECT(&deviceInfo);
+
+                    /* ID */
+                    ma_strncpy_s(deviceInfo.id.oss, sizeof(deviceInfo.id.oss), ai.devnode, (size_t)-1);
+
+                    /*
+                    The human readable device name should be in the "ai.handle" variable, but it can
+                    sometimes be empty in which case we just fall back to "ai.name" which is less user
+                    friendly, but usually has a value.
+                    */
+                    if (ai.handle[0] != '\0') {
+                        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), ai.handle, (size_t)-1);
+                    } else {
+                        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), ai.name, (size_t)-1);
+                    }
+
+                    /* The device can be both playback and capture. */
+                    if (!isTerminating && (ai.caps & PCM_CAP_OUTPUT) != 0) {
+                        isTerminating = !callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+                    }
+                    if (!isTerminating && (ai.caps & PCM_CAP_INPUT) != 0) {
+                        isTerminating = !callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+                    }
+
+                    if (isTerminating) {
+                        break;
+                    }
+                }
+            }
+        }
+    } else {
+        close(fd);
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to retrieve system information for device enumeration.");
+        return MA_NO_BACKEND;
+    }
+
+    close(fd);
+    return MA_SUCCESS;
+}
+
+static void ma_context_add_native_data_format__oss(ma_context* pContext, oss_audioinfo* pAudioInfo, ma_format format, ma_device_info* pDeviceInfo)
+{
+    unsigned int minChannels;
+    unsigned int maxChannels;
+    unsigned int iRate;
+
+    MA_ASSERT(pContext    != NULL);
+    MA_ASSERT(pAudioInfo  != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    /* If we support all channels we just report 0. */
+    minChannels = ma_clamp(pAudioInfo->min_channels, MA_MIN_CHANNELS, MA_MAX_CHANNELS);
+    maxChannels = ma_clamp(pAudioInfo->max_channels, MA_MIN_CHANNELS, MA_MAX_CHANNELS);
+
+    /*
+    OSS has this annoying thing where sample rates can be reported in two ways. We prefer explicitness,
+    which OSS has in the form of nrates/rates, however there are times where nrates can be 0, in which
+    case we'll need to use min_rate and max_rate and report only standard rates.
+    */
+    if (pAudioInfo->nrates > 0) {
+        for (iRate = 0; iRate < pAudioInfo->nrates; iRate += 1) {
+            unsigned int rate = pAudioInfo->rates[iRate];
+
+            if (minChannels == MA_MIN_CHANNELS && maxChannels == MA_MAX_CHANNELS) {
+                ma_device_info_add_native_data_format(pDeviceInfo, format, 0, rate, 0);   /* Set the channel count to 0 to indicate that all channel counts are supported. */
+            } else {
+                unsigned int iChannel;
+                for (iChannel = minChannels; iChannel <= maxChannels; iChannel += 1) {
+                     ma_device_info_add_native_data_format(pDeviceInfo, format, iChannel, rate, 0);
+                }
+            }
+        }
+    } else {
+        for (iRate = 0; iRate < ma_countof(g_maStandardSampleRatePriorities); iRate += 1) {
+            ma_uint32 standardRate = g_maStandardSampleRatePriorities[iRate];
+
+            if (standardRate >= (ma_uint32)pAudioInfo->min_rate && standardRate <= (ma_uint32)pAudioInfo->max_rate) {
+                if (minChannels == MA_MIN_CHANNELS && maxChannels == MA_MAX_CHANNELS) {
+                    ma_device_info_add_native_data_format(pDeviceInfo, format, 0, standardRate, 0);   /* Set the channel count to 0 to indicate that all channel counts are supported. */
+                } else {
+                    unsigned int iChannel;
+                    for (iChannel = minChannels; iChannel <= maxChannels; iChannel += 1) {
+                         ma_device_info_add_native_data_format(pDeviceInfo, format, iChannel, standardRate, 0);
+                    }
+                }
+            }
+        }
+    }
+}
+
+static ma_result ma_context_get_device_info__oss(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_bool32 foundDevice;
+    int fdTemp;
+    oss_sysinfo si;
+    int result;
+
+    MA_ASSERT(pContext != NULL);
+
+    /* Handle the default device a little differently. */
+    if (pDeviceID == NULL) {
+        if (deviceType == ma_device_type_playback) {
+            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+        } else {
+            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+        }
+
+        return MA_SUCCESS;
+    }
+
+
+    /* If we get here it means we are _not_ using the default device. */
+    foundDevice = MA_FALSE;
+
+    fdTemp = ma_open_temp_device__oss();
+    if (fdTemp == -1) {
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open a temporary device for retrieving system information used for device enumeration.");
+        return MA_NO_BACKEND;
+    }
+
+    result = ioctl(fdTemp, SNDCTL_SYSINFO, &si);
+    if (result != -1) {
+        int iAudioDevice;
+        for (iAudioDevice = 0; iAudioDevice < si.numaudios; ++iAudioDevice) {
+            oss_audioinfo ai;
+            ai.dev = iAudioDevice;
+            result = ioctl(fdTemp, SNDCTL_AUDIOINFO, &ai);
+            if (result != -1) {
+                if (ma_strcmp(ai.devnode, pDeviceID->oss) == 0) {
+                    /* It has the same name, so now just confirm the type. */
+                    if ((deviceType == ma_device_type_playback && ((ai.caps & PCM_CAP_OUTPUT) != 0)) ||
+                        (deviceType == ma_device_type_capture  && ((ai.caps & PCM_CAP_INPUT)  != 0))) {
+                        unsigned int formatMask;
+
+                        /* ID */
+                        ma_strncpy_s(pDeviceInfo->id.oss, sizeof(pDeviceInfo->id.oss), ai.devnode, (size_t)-1);
+
+                        /*
+                        The human readable device name should be in the "ai.handle" variable, but it can
+                        sometimes be empty in which case we just fall back to "ai.name" which is less user
+                        friendly, but usually has a value.
+                        */
+                        if (ai.handle[0] != '\0') {
+                            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), ai.handle, (size_t)-1);
+                        } else {
+                            ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), ai.name, (size_t)-1);
+                        }
+
+
+                        pDeviceInfo->nativeDataFormatCount = 0;
+
+                        if (deviceType == ma_device_type_playback) {
+                            formatMask = ai.oformats;
+                        } else {
+                            formatMask = ai.iformats;
+                        }
+
+                        if (((formatMask & AFMT_S16_LE) != 0 && ma_is_little_endian()) || (AFMT_S16_BE && ma_is_big_endian())) {
+                            ma_context_add_native_data_format__oss(pContext, &ai, ma_format_s16, pDeviceInfo);
+                        }
+                        if (((formatMask & AFMT_S32_LE) != 0 && ma_is_little_endian()) || (AFMT_S32_BE && ma_is_big_endian())) {
+                            ma_context_add_native_data_format__oss(pContext, &ai, ma_format_s32, pDeviceInfo);
+                        }
+                        if ((formatMask & AFMT_U8) != 0) {
+                            ma_context_add_native_data_format__oss(pContext, &ai, ma_format_u8, pDeviceInfo);
+                        }
+
+                        foundDevice = MA_TRUE;
+                        break;
+                    }
+                }
+            }
+        }
+    } else {
+        close(fdTemp);
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to retrieve system information for device enumeration.");
+        return MA_NO_BACKEND;
+    }
+
+
+    close(fdTemp);
+
+    if (!foundDevice) {
+        return MA_NO_DEVICE;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_uninit__oss(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        close(pDevice->oss.fdCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        close(pDevice->oss.fdPlayback);
+    }
+
+    return MA_SUCCESS;
+}
+
+static int ma_format_to_oss(ma_format format)
+{
+    int ossFormat = AFMT_U8;
+    switch (format) {
+        case ma_format_s16: ossFormat = (ma_is_little_endian()) ? AFMT_S16_LE : AFMT_S16_BE; break;
+        case ma_format_s24: ossFormat = (ma_is_little_endian()) ? AFMT_S32_LE : AFMT_S32_BE; break;
+        case ma_format_s32: ossFormat = (ma_is_little_endian()) ? AFMT_S32_LE : AFMT_S32_BE; break;
+        case ma_format_f32: ossFormat = (ma_is_little_endian()) ? AFMT_S16_LE : AFMT_S16_BE; break;
+        case ma_format_u8:
+        default: ossFormat = AFMT_U8; break;
+    }
+
+    return ossFormat;
+}
+
+static ma_format ma_format_from_oss(int ossFormat)
+{
+    if (ossFormat == AFMT_U8) {
+        return ma_format_u8;
+    } else {
+        if (ma_is_little_endian()) {
+            switch (ossFormat) {
+                case AFMT_S16_LE: return ma_format_s16;
+                case AFMT_S32_LE: return ma_format_s32;
+                default: return ma_format_unknown;
+            }
+        } else {
+            switch (ossFormat) {
+                case AFMT_S16_BE: return ma_format_s16;
+                case AFMT_S32_BE: return ma_format_s32;
+                default: return ma_format_unknown;
+            }
+        }
+    }
+
+    return ma_format_unknown;
+}
+
+static ma_result ma_device_init_fd__oss(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptor, ma_device_type deviceType)
+{
+    ma_result result;
+    int ossResult;
+    int fd;
+    const ma_device_id* pDeviceID = NULL;
+    ma_share_mode shareMode;
+    int ossFormat;
+    int ossChannels;
+    int ossSampleRate;
+    int ossFragment;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(deviceType != ma_device_type_duplex);
+
+    pDeviceID     = pDescriptor->pDeviceID;
+    shareMode     = pDescriptor->shareMode;
+    ossFormat     = ma_format_to_oss((pDescriptor->format != ma_format_unknown) ? pDescriptor->format : ma_format_s16); /* Use s16 by default because OSS doesn't like floating point. */
+    ossChannels   = (int)(pDescriptor->channels   > 0) ? pDescriptor->channels   : MA_DEFAULT_CHANNELS;
+    ossSampleRate = (int)(pDescriptor->sampleRate > 0) ? pDescriptor->sampleRate : MA_DEFAULT_SAMPLE_RATE;
+
+    result = ma_context_open_device__oss(pDevice->pContext, deviceType, pDeviceID, shareMode, &fd);
+    if (result != MA_SUCCESS) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open device.");
+        return result;
+    }
+
+    /*
+    The OSS documantation is very clear about the order we should be initializing the device's properties:
+      1) Format
+      2) Channels
+      3) Sample rate.
+    */
+
+    /* Format. */
+    ossResult = ioctl(fd, SNDCTL_DSP_SETFMT, &ossFormat);
+    if (ossResult == -1) {
+        close(fd);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to set format.");
+        return ma_result_from_errno(errno);
+    }
+
+    /* Channels. */
+    ossResult = ioctl(fd, SNDCTL_DSP_CHANNELS, &ossChannels);
+    if (ossResult == -1) {
+        close(fd);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to set channel count.");
+        return ma_result_from_errno(errno);
+    }
+
+    /* Sample Rate. */
+    ossResult = ioctl(fd, SNDCTL_DSP_SPEED, &ossSampleRate);
+    if (ossResult == -1) {
+        close(fd);
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to set sample rate.");
+        return ma_result_from_errno(errno);
+    }
+
+    /*
+    Buffer.
+
+    The documentation says that the fragment settings should be set as soon as possible, but I'm not sure if
+    it should be done before or after format/channels/rate.
+
+    OSS wants the fragment size in bytes and a power of 2. When setting, we specify the power, not the actual
+    value.
+    */
+    {
+        ma_uint32 periodSizeInFrames;
+        ma_uint32 periodSizeInBytes;
+        ma_uint32 ossFragmentSizePower;
+
+        periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, (ma_uint32)ossSampleRate, pConfig->performanceProfile);
+
+        periodSizeInBytes = ma_round_to_power_of_2(periodSizeInFrames * ma_get_bytes_per_frame(ma_format_from_oss(ossFormat), ossChannels));
+        if (periodSizeInBytes < 16) {
+            periodSizeInBytes = 16;
+        }
+
+        ossFragmentSizePower = 4;
+        periodSizeInBytes >>= 4;
+        while (periodSizeInBytes >>= 1) {
+            ossFragmentSizePower += 1;
+        }
+
+        ossFragment = (int)((pConfig->periods << 16) | ossFragmentSizePower);
+        ossResult = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &ossFragment);
+        if (ossResult == -1) {
+            close(fd);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to set fragment size and period count.");
+            return ma_result_from_errno(errno);
+        }
+    }
+
+    /* Internal settings. */
+    if (deviceType == ma_device_type_capture) {
+        pDevice->oss.fdCapture  = fd;
+    } else {
+        pDevice->oss.fdPlayback = fd;
+    }
+
+    pDescriptor->format             = ma_format_from_oss(ossFormat);
+    pDescriptor->channels           = ossChannels;
+    pDescriptor->sampleRate         = ossSampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_sound4, pDescriptor->channelMap, ma_countof(pDescriptor->channelMap), pDescriptor->channels);
+    pDescriptor->periodCount        = (ma_uint32)(ossFragment >> 16);
+    pDescriptor->periodSizeInFrames = (ma_uint32)(1 << (ossFragment & 0xFFFF)) / ma_get_bytes_per_frame(pDescriptor->format, pDescriptor->channels);
+
+    if (pDescriptor->format == ma_format_unknown) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] The device's internal format is not supported by miniaudio.");
+        return MA_FORMAT_NOT_SUPPORTED;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__oss(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    MA_ASSERT(pDevice  != NULL);
+    MA_ASSERT(pConfig  != NULL);
+
+    MA_ZERO_OBJECT(&pDevice->oss);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_fd__oss(pDevice, pConfig, pDescriptorCapture, ma_device_type_capture);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open device.");
+            return result;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_result result = ma_device_init_fd__oss(pDevice, pConfig, pDescriptorPlayback, ma_device_type_playback);
+        if (result != MA_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open device.");
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+/*
+Note on Starting and Stopping
+=============================
+In the past I was using SNDCTL_DSP_HALT to stop the device, however this results in issues when
+trying to resume the device again. If we use SNDCTL_DSP_HALT, the next write() or read() will
+fail. Instead what we need to do is just not write or read to and from the device when the
+device is not running.
+
+As a result, both the start and stop functions for OSS are just empty stubs. The starting and
+stopping logic is handled by ma_device_write__oss() and ma_device_read__oss(). These will check
+the device state, and if the device is stopped they will simply not do any kind of processing.
+
+The downside to this technique is that I've noticed a fairly lengthy delay in stopping the
+device, up to a second. This is on a virtual machine, and as such might just be due to the
+virtual drivers, but I'm not fully sure. I am not sure how to work around this problem so for
+the moment that's just how it's going to have to be.
+
+When starting the device, OSS will automatically start it when write() or read() is called.
+*/
+static ma_result ma_device_start__oss(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* The device is automatically started with reading and writing. */
+    (void)pDevice;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__oss(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /* See note above on why this is empty. */
+    (void)pDevice;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_write__oss(ma_device* pDevice, const void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesWritten)
+{
+    int resultOSS;
+    ma_uint32 deviceState;
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    /* Don't do any processing if the device is stopped. */
+    deviceState = ma_device_get_state(pDevice);
+    if (deviceState != ma_device_state_started && deviceState != ma_device_state_starting) {
+        return MA_SUCCESS;
+    }
+
+    resultOSS = write(pDevice->oss.fdPlayback, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+    if (resultOSS < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to send data from the client to the device.");
+        return ma_result_from_errno(errno);
+    }
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = (ma_uint32)resultOSS / ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_read__oss(ma_device* pDevice, void* pPCMFrames, ma_uint32 frameCount, ma_uint32* pFramesRead)
+{
+    int resultOSS;
+    ma_uint32 deviceState;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    /* Don't do any processing if the device is stopped. */
+    deviceState = ma_device_get_state(pDevice);
+    if (deviceState != ma_device_state_started && deviceState != ma_device_state_starting) {
+        return MA_SUCCESS;
+    }
+
+    resultOSS = read(pDevice->oss.fdCapture, pPCMFrames, frameCount * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels));
+    if (resultOSS < 0) {
+        ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OSS] Failed to read data from the device to be sent to the client.");
+        return ma_result_from_errno(errno);
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = (ma_uint32)resultOSS / ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__oss(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_oss);
+
+    (void)pContext;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__oss(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    int fd;
+    int ossVersion;
+    int result;
+
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+    /* Try opening a temporary device first so we can get version information. This is closed at the end. */
+    fd = ma_open_temp_device__oss();
+    if (fd == -1) {
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to open temporary device for retrieving system properties.");   /* Looks liks OSS isn't installed, or there are no available devices. */
+        return MA_NO_BACKEND;
+    }
+
+    /* Grab the OSS version. */
+    ossVersion = 0;
+    result = ioctl(fd, OSS_GETVERSION, &ossVersion);
+    if (result == -1) {
+        close(fd);
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_ERROR, "[OSS] Failed to retrieve OSS version.");
+        return MA_NO_BACKEND;
+    }
+
+    /* The file handle to temp device is no longer needed. Close ASAP. */
+    close(fd);
+
+    pContext->oss.versionMajor = ((ossVersion & 0xFF0000) >> 16);
+    pContext->oss.versionMinor = ((ossVersion & 0x00FF00) >> 8);
+
+    pCallbacks->onContextInit             = ma_context_init__oss;
+    pCallbacks->onContextUninit           = ma_context_uninit__oss;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__oss;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__oss;
+    pCallbacks->onDeviceInit              = ma_device_init__oss;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__oss;
+    pCallbacks->onDeviceStart             = ma_device_start__oss;
+    pCallbacks->onDeviceStop              = ma_device_stop__oss;
+    pCallbacks->onDeviceRead              = ma_device_read__oss;
+    pCallbacks->onDeviceWrite             = ma_device_write__oss;
+    pCallbacks->onDeviceDataLoop          = NULL;
+
+    return MA_SUCCESS;
+}
+#endif  /* OSS */
+
+
+
+
+
+/******************************************************************************
+
+AAudio Backend
+
+******************************************************************************/
+#ifdef MA_HAS_AAUDIO
+
+/*#include <AAudio/AAudio.h>*/
+
+typedef int32_t                                         ma_aaudio_result_t;
+typedef int32_t                                         ma_aaudio_direction_t;
+typedef int32_t                                         ma_aaudio_sharing_mode_t;
+typedef int32_t                                         ma_aaudio_format_t;
+typedef int32_t                                         ma_aaudio_stream_state_t;
+typedef int32_t                                         ma_aaudio_performance_mode_t;
+typedef int32_t                                         ma_aaudio_usage_t;
+typedef int32_t                                         ma_aaudio_content_type_t;
+typedef int32_t                                         ma_aaudio_input_preset_t;
+typedef int32_t                                         ma_aaudio_allowed_capture_policy_t;
+typedef int32_t                                         ma_aaudio_data_callback_result_t;
+typedef struct ma_AAudioStreamBuilder_t*                ma_AAudioStreamBuilder;
+typedef struct ma_AAudioStream_t*                       ma_AAudioStream;
+
+#define MA_AAUDIO_UNSPECIFIED                           0
+
+/* Result codes. miniaudio only cares about the success code. */
+#define MA_AAUDIO_OK                                    0
+
+/* Directions. */
+#define MA_AAUDIO_DIRECTION_OUTPUT                      0
+#define MA_AAUDIO_DIRECTION_INPUT                       1
+
+/* Sharing modes. */
+#define MA_AAUDIO_SHARING_MODE_EXCLUSIVE                0
+#define MA_AAUDIO_SHARING_MODE_SHARED                   1
+
+/* Formats. */
+#define MA_AAUDIO_FORMAT_PCM_I16                        1
+#define MA_AAUDIO_FORMAT_PCM_FLOAT                      2
+
+/* Stream states. */
+#define MA_AAUDIO_STREAM_STATE_UNINITIALIZED            0
+#define MA_AAUDIO_STREAM_STATE_UNKNOWN                  1
+#define MA_AAUDIO_STREAM_STATE_OPEN                     2
+#define MA_AAUDIO_STREAM_STATE_STARTING                 3
+#define MA_AAUDIO_STREAM_STATE_STARTED                  4
+#define MA_AAUDIO_STREAM_STATE_PAUSING                  5
+#define MA_AAUDIO_STREAM_STATE_PAUSED                   6
+#define MA_AAUDIO_STREAM_STATE_FLUSHING                 7
+#define MA_AAUDIO_STREAM_STATE_FLUSHED                  8
+#define MA_AAUDIO_STREAM_STATE_STOPPING                 9
+#define MA_AAUDIO_STREAM_STATE_STOPPED                  10
+#define MA_AAUDIO_STREAM_STATE_CLOSING                  11
+#define MA_AAUDIO_STREAM_STATE_CLOSED                   12
+#define MA_AAUDIO_STREAM_STATE_DISCONNECTED             13
+
+/* Performance modes. */
+#define MA_AAUDIO_PERFORMANCE_MODE_NONE                 10
+#define MA_AAUDIO_PERFORMANCE_MODE_POWER_SAVING         11
+#define MA_AAUDIO_PERFORMANCE_MODE_LOW_LATENCY          12
+
+/* Usage types. */
+#define MA_AAUDIO_USAGE_MEDIA                           1
+#define MA_AAUDIO_USAGE_VOICE_COMMUNICATION             2
+#define MA_AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING  3
+#define MA_AAUDIO_USAGE_ALARM                           4
+#define MA_AAUDIO_USAGE_NOTIFICATION                    5
+#define MA_AAUDIO_USAGE_NOTIFICATION_RINGTONE           6
+#define MA_AAUDIO_USAGE_NOTIFICATION_EVENT              10
+#define MA_AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY        11
+#define MA_AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE  12
+#define MA_AAUDIO_USAGE_ASSISTANCE_SONIFICATION         13
+#define MA_AAUDIO_USAGE_GAME                            14
+#define MA_AAUDIO_USAGE_ASSISTANT                       16
+#define MA_AAUDIO_SYSTEM_USAGE_EMERGENCY                1000
+#define MA_AAUDIO_SYSTEM_USAGE_SAFETY                   1001
+#define MA_AAUDIO_SYSTEM_USAGE_VEHICLE_STATUS           1002
+#define MA_AAUDIO_SYSTEM_USAGE_ANNOUNCEMENT             1003
+
+/* Content types. */
+#define MA_AAUDIO_CONTENT_TYPE_SPEECH                   1
+#define MA_AAUDIO_CONTENT_TYPE_MUSIC                    2
+#define MA_AAUDIO_CONTENT_TYPE_MOVIE                    3
+#define MA_AAUDIO_CONTENT_TYPE_SONIFICATION             4
+
+/* Input presets. */
+#define MA_AAUDIO_INPUT_PRESET_GENERIC                  1
+#define MA_AAUDIO_INPUT_PRESET_CAMCORDER                5
+#define MA_AAUDIO_INPUT_PRESET_VOICE_RECOGNITION        6
+#define MA_AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION      7
+#define MA_AAUDIO_INPUT_PRESET_UNPROCESSED              9
+#define MA_AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE        10
+
+/* Allowed Capture Policies */
+#define MA_AAUDIO_ALLOW_CAPTURE_BY_ALL                  1
+#define MA_AAUDIO_ALLOW_CAPTURE_BY_SYSTEM               2
+#define MA_AAUDIO_ALLOW_CAPTURE_BY_NONE                 3
+
+/* Callback results. */
+#define MA_AAUDIO_CALLBACK_RESULT_CONTINUE              0
+#define MA_AAUDIO_CALLBACK_RESULT_STOP                  1
+
+
+typedef ma_aaudio_data_callback_result_t (* ma_AAudioStream_dataCallback) (ma_AAudioStream* pStream, void* pUserData, void* pAudioData, int32_t numFrames);
+typedef void                             (* ma_AAudioStream_errorCallback)(ma_AAudioStream *pStream, void *pUserData, ma_aaudio_result_t error);
+
+typedef ma_aaudio_result_t       (* MA_PFN_AAudio_createStreamBuilder)                   (ma_AAudioStreamBuilder** ppBuilder);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStreamBuilder_delete)                   (ma_AAudioStreamBuilder* pBuilder);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setDeviceId)              (ma_AAudioStreamBuilder* pBuilder, int32_t deviceId);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setDirection)             (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_direction_t direction);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setSharingMode)           (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_sharing_mode_t sharingMode);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setFormat)                (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_format_t format);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setChannelCount)          (ma_AAudioStreamBuilder* pBuilder, int32_t channelCount);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setSampleRate)            (ma_AAudioStreamBuilder* pBuilder, int32_t sampleRate);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setBufferCapacityInFrames)(ma_AAudioStreamBuilder* pBuilder, int32_t numFrames);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setFramesPerDataCallback) (ma_AAudioStreamBuilder* pBuilder, int32_t numFrames);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setDataCallback)          (ma_AAudioStreamBuilder* pBuilder, ma_AAudioStream_dataCallback callback, void* pUserData);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setErrorCallback)         (ma_AAudioStreamBuilder* pBuilder, ma_AAudioStream_errorCallback callback, void* pUserData);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setPerformanceMode)       (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_performance_mode_t mode);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setUsage)                 (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_usage_t contentType);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setContentType)           (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_content_type_t contentType);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setInputPreset)           (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_input_preset_t inputPreset);
+typedef void                     (* MA_PFN_AAudioStreamBuilder_setAllowedCapturePolicy)  (ma_AAudioStreamBuilder* pBuilder, ma_aaudio_allowed_capture_policy_t policy);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStreamBuilder_openStream)               (ma_AAudioStreamBuilder* pBuilder, ma_AAudioStream** ppStream);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStream_close)                           (ma_AAudioStream* pStream);
+typedef ma_aaudio_stream_state_t (* MA_PFN_AAudioStream_getState)                        (ma_AAudioStream* pStream);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStream_waitForStateChange)              (ma_AAudioStream* pStream, ma_aaudio_stream_state_t inputState, ma_aaudio_stream_state_t* pNextState, int64_t timeoutInNanoseconds);
+typedef ma_aaudio_format_t       (* MA_PFN_AAudioStream_getFormat)                       (ma_AAudioStream* pStream);
+typedef int32_t                  (* MA_PFN_AAudioStream_getChannelCount)                 (ma_AAudioStream* pStream);
+typedef int32_t                  (* MA_PFN_AAudioStream_getSampleRate)                   (ma_AAudioStream* pStream);
+typedef int32_t                  (* MA_PFN_AAudioStream_getBufferCapacityInFrames)       (ma_AAudioStream* pStream);
+typedef int32_t                  (* MA_PFN_AAudioStream_getFramesPerDataCallback)        (ma_AAudioStream* pStream);
+typedef int32_t                  (* MA_PFN_AAudioStream_getFramesPerBurst)               (ma_AAudioStream* pStream);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStream_requestStart)                    (ma_AAudioStream* pStream);
+typedef ma_aaudio_result_t       (* MA_PFN_AAudioStream_requestStop)                     (ma_AAudioStream* pStream);
+
+static ma_result ma_result_from_aaudio(ma_aaudio_result_t resultAA)
+{
+    switch (resultAA)
+    {
+        case MA_AAUDIO_OK: return MA_SUCCESS;
+        default: break;
+    }
+
+    return MA_ERROR;
+}
+
+static ma_aaudio_usage_t ma_to_usage__aaudio(ma_aaudio_usage usage)
+{
+    switch (usage) {
+        case ma_aaudio_usage_media:                          return MA_AAUDIO_USAGE_MEDIA;
+        case ma_aaudio_usage_voice_communication:            return MA_AAUDIO_USAGE_VOICE_COMMUNICATION;
+        case ma_aaudio_usage_voice_communication_signalling: return MA_AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING;
+        case ma_aaudio_usage_alarm:                          return MA_AAUDIO_USAGE_ALARM;
+        case ma_aaudio_usage_notification:                   return MA_AAUDIO_USAGE_NOTIFICATION;
+        case ma_aaudio_usage_notification_ringtone:          return MA_AAUDIO_USAGE_NOTIFICATION_RINGTONE;
+        case ma_aaudio_usage_notification_event:             return MA_AAUDIO_USAGE_NOTIFICATION_EVENT;
+        case ma_aaudio_usage_assistance_accessibility:       return MA_AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY;
+        case ma_aaudio_usage_assistance_navigation_guidance: return MA_AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE;
+        case ma_aaudio_usage_assistance_sonification:        return MA_AAUDIO_USAGE_ASSISTANCE_SONIFICATION;
+        case ma_aaudio_usage_game:                           return MA_AAUDIO_USAGE_GAME;
+        case ma_aaudio_usage_assitant:                       return MA_AAUDIO_USAGE_ASSISTANT;
+        case ma_aaudio_usage_emergency:                      return MA_AAUDIO_SYSTEM_USAGE_EMERGENCY;
+        case ma_aaudio_usage_safety:                         return MA_AAUDIO_SYSTEM_USAGE_SAFETY;
+        case ma_aaudio_usage_vehicle_status:                 return MA_AAUDIO_SYSTEM_USAGE_VEHICLE_STATUS;
+        case ma_aaudio_usage_announcement:                   return MA_AAUDIO_SYSTEM_USAGE_ANNOUNCEMENT;
+        default: break;
+    }
+
+    return MA_AAUDIO_USAGE_MEDIA;
+}
+
+static ma_aaudio_content_type_t ma_to_content_type__aaudio(ma_aaudio_content_type contentType)
+{
+    switch (contentType) {
+        case ma_aaudio_content_type_speech:       return MA_AAUDIO_CONTENT_TYPE_SPEECH;
+        case ma_aaudio_content_type_music:        return MA_AAUDIO_CONTENT_TYPE_MUSIC;
+        case ma_aaudio_content_type_movie:        return MA_AAUDIO_CONTENT_TYPE_MOVIE;
+        case ma_aaudio_content_type_sonification: return MA_AAUDIO_CONTENT_TYPE_SONIFICATION;
+        default: break;
+    }
+
+    return MA_AAUDIO_CONTENT_TYPE_SPEECH;
+}
+
+static ma_aaudio_input_preset_t ma_to_input_preset__aaudio(ma_aaudio_input_preset inputPreset)
+{
+    switch (inputPreset) {
+        case ma_aaudio_input_preset_generic:             return MA_AAUDIO_INPUT_PRESET_GENERIC;
+        case ma_aaudio_input_preset_camcorder:           return MA_AAUDIO_INPUT_PRESET_CAMCORDER;
+        case ma_aaudio_input_preset_voice_recognition:   return MA_AAUDIO_INPUT_PRESET_VOICE_RECOGNITION;
+        case ma_aaudio_input_preset_voice_communication: return MA_AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION;
+        case ma_aaudio_input_preset_unprocessed:         return MA_AAUDIO_INPUT_PRESET_UNPROCESSED;
+        case ma_aaudio_input_preset_voice_performance:   return MA_AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE;
+        default: break;
+    }
+
+    return MA_AAUDIO_INPUT_PRESET_GENERIC;
+}
+
+static ma_aaudio_allowed_capture_policy_t ma_to_allowed_capture_policy__aaudio(ma_aaudio_allowed_capture_policy allowedCapturePolicy)
+{
+    switch (allowedCapturePolicy) {
+        case ma_aaudio_allow_capture_by_all:    return MA_AAUDIO_ALLOW_CAPTURE_BY_ALL;
+        case ma_aaudio_allow_capture_by_system: return MA_AAUDIO_ALLOW_CAPTURE_BY_SYSTEM;
+        case ma_aaudio_allow_capture_by_none:   return MA_AAUDIO_ALLOW_CAPTURE_BY_NONE;
+        default: break;
+    }
+
+    return MA_AAUDIO_ALLOW_CAPTURE_BY_ALL;
+}
+
+static void ma_stream_error_callback__aaudio(ma_AAudioStream* pStream, void* pUserData, ma_aaudio_result_t error)
+{
+    ma_result result;
+    ma_job job;
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    (void)error;
+
+    ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[AAudio] ERROR CALLBACK: error=%d, AAudioStream_getState()=%d\n", error, ((MA_PFN_AAudioStream_getState)pDevice->pContext->aaudio.AAudioStream_getState)(pStream));
+
+    /*
+    When we get an error, we'll assume that the stream is in an erroneous state and needs to be restarted. From the documentation,
+    we cannot do this from the error callback. Therefore we are going to use an event thread for the AAudio backend to do this
+    cleanly and safely.
+    */
+    job = ma_job_init(MA_JOB_TYPE_DEVICE_AAUDIO_REROUTE);
+    job.data.device.aaudio.reroute.pDevice = pDevice;
+
+    if (pStream == pDevice->aaudio.pStreamCapture) {
+        job.data.device.aaudio.reroute.deviceType = ma_device_type_capture;
+    }
+    else {
+        job.data.device.aaudio.reroute.deviceType = ma_device_type_playback;
+    }
+
+    result = ma_device_job_thread_post(&pDevice->pContext->aaudio.jobThread, &job);
+    if (result != MA_SUCCESS) {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[AAudio] Device Disconnected. Failed to post job for rerouting.\n");
+        return;
+    }
+}
+
+static ma_aaudio_data_callback_result_t ma_stream_data_callback_capture__aaudio(ma_AAudioStream* pStream, void* pUserData, void* pAudioData, int32_t frameCount)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    ma_device_handle_backend_data_callback(pDevice, NULL, pAudioData, frameCount);
+
+    (void)pStream;
+    return MA_AAUDIO_CALLBACK_RESULT_CONTINUE;
+}
+
+static ma_aaudio_data_callback_result_t ma_stream_data_callback_playback__aaudio(ma_AAudioStream* pStream, void* pUserData, void* pAudioData, int32_t frameCount)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    MA_ASSERT(pDevice != NULL);
+
+    ma_device_handle_backend_data_callback(pDevice, pAudioData, NULL, frameCount);
+
+    (void)pStream;
+    return MA_AAUDIO_CALLBACK_RESULT_CONTINUE;
+}
+
+static ma_result ma_create_and_configure_AAudioStreamBuilder__aaudio(ma_context* pContext, const ma_device_id* pDeviceID, ma_device_type deviceType, ma_share_mode shareMode, const ma_device_descriptor* pDescriptor, const ma_device_config* pConfig, ma_device* pDevice, ma_AAudioStreamBuilder** ppBuilder)
+{
+    ma_AAudioStreamBuilder* pBuilder;
+    ma_aaudio_result_t resultAA;
+
+    /* Safety. */
+    *ppBuilder = NULL;
+
+    resultAA = ((MA_PFN_AAudio_createStreamBuilder)pContext->aaudio.AAudio_createStreamBuilder)(&pBuilder);
+    if (resultAA != MA_AAUDIO_OK) {
+        return ma_result_from_aaudio(resultAA);
+    }
+
+    if (pDeviceID != NULL) {
+        ((MA_PFN_AAudioStreamBuilder_setDeviceId)pContext->aaudio.AAudioStreamBuilder_setDeviceId)(pBuilder, pDeviceID->aaudio);
+    }
+
+    ((MA_PFN_AAudioStreamBuilder_setDirection)pContext->aaudio.AAudioStreamBuilder_setDirection)(pBuilder, (deviceType == ma_device_type_playback) ? MA_AAUDIO_DIRECTION_OUTPUT : MA_AAUDIO_DIRECTION_INPUT);
+    ((MA_PFN_AAudioStreamBuilder_setSharingMode)pContext->aaudio.AAudioStreamBuilder_setSharingMode)(pBuilder, (shareMode == ma_share_mode_shared) ? MA_AAUDIO_SHARING_MODE_SHARED : MA_AAUDIO_SHARING_MODE_EXCLUSIVE);
+
+
+    /* If we have a device descriptor make sure we configure the stream builder to take our requested parameters. */
+    if (pDescriptor != NULL) {
+        MA_ASSERT(pConfig != NULL); /* We must have a device config if we also have a descriptor. The config is required for AAudio specific configuration options. */
+
+        if (pDescriptor->sampleRate != 0) {
+            ((MA_PFN_AAudioStreamBuilder_setSampleRate)pContext->aaudio.AAudioStreamBuilder_setSampleRate)(pBuilder, pDescriptor->sampleRate);
+        }
+
+        if (deviceType == ma_device_type_capture) {
+            if (pDescriptor->channels != 0) {
+                ((MA_PFN_AAudioStreamBuilder_setChannelCount)pContext->aaudio.AAudioStreamBuilder_setChannelCount)(pBuilder, pDescriptor->channels);
+            }
+            if (pDescriptor->format != ma_format_unknown) {
+                ((MA_PFN_AAudioStreamBuilder_setFormat)pContext->aaudio.AAudioStreamBuilder_setFormat)(pBuilder, (pDescriptor->format == ma_format_s16) ? MA_AAUDIO_FORMAT_PCM_I16 : MA_AAUDIO_FORMAT_PCM_FLOAT);
+            }
+        } else {
+            if (pDescriptor->channels != 0) {
+                ((MA_PFN_AAudioStreamBuilder_setChannelCount)pContext->aaudio.AAudioStreamBuilder_setChannelCount)(pBuilder, pDescriptor->channels);
+            }
+            if (pDescriptor->format != ma_format_unknown) {
+                ((MA_PFN_AAudioStreamBuilder_setFormat)pContext->aaudio.AAudioStreamBuilder_setFormat)(pBuilder, (pDescriptor->format == ma_format_s16) ? MA_AAUDIO_FORMAT_PCM_I16 : MA_AAUDIO_FORMAT_PCM_FLOAT);
+            }
+        }
+
+
+        /*
+        There have been reports where setting the frames per data callback results in an error
+        later on from Android. To address this, I'm experimenting with simply not setting it on
+        anything from Android 11 and earlier. Suggestions welcome on how we might be able to make
+        this more targetted.
+        */
+        if (!pConfig->aaudio.enableCompatibilityWorkarounds || ma_android_sdk_version() > 30) {
+            /*
+            AAudio is annoying when it comes to it's buffer calculation stuff because it doesn't let you
+            retrieve the actual sample rate until after you've opened the stream. But you need to configure
+            the buffer capacity before you open the stream... :/
+
+            To solve, we're just going to assume MA_DEFAULT_SAMPLE_RATE (48000) and move on.
+            */
+            ma_uint32 bufferCapacityInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, pDescriptor->sampleRate, pConfig->performanceProfile) * pDescriptor->periodCount;
+
+            ((MA_PFN_AAudioStreamBuilder_setBufferCapacityInFrames)pContext->aaudio.AAudioStreamBuilder_setBufferCapacityInFrames)(pBuilder, bufferCapacityInFrames);
+            ((MA_PFN_AAudioStreamBuilder_setFramesPerDataCallback)pContext->aaudio.AAudioStreamBuilder_setFramesPerDataCallback)(pBuilder, bufferCapacityInFrames / pDescriptor->periodCount);
+        }
+
+        if (deviceType == ma_device_type_capture) {
+            if (pConfig->aaudio.inputPreset != ma_aaudio_input_preset_default && pContext->aaudio.AAudioStreamBuilder_setInputPreset != NULL) {
+                ((MA_PFN_AAudioStreamBuilder_setInputPreset)pContext->aaudio.AAudioStreamBuilder_setInputPreset)(pBuilder, ma_to_input_preset__aaudio(pConfig->aaudio.inputPreset));
+            }
+
+            ((MA_PFN_AAudioStreamBuilder_setDataCallback)pContext->aaudio.AAudioStreamBuilder_setDataCallback)(pBuilder, ma_stream_data_callback_capture__aaudio, (void*)pDevice);
+        } else {
+            if (pConfig->aaudio.usage != ma_aaudio_usage_default && pContext->aaudio.AAudioStreamBuilder_setUsage != NULL) {
+                ((MA_PFN_AAudioStreamBuilder_setUsage)pContext->aaudio.AAudioStreamBuilder_setUsage)(pBuilder, ma_to_usage__aaudio(pConfig->aaudio.usage));
+            }
+
+            if (pConfig->aaudio.contentType != ma_aaudio_content_type_default && pContext->aaudio.AAudioStreamBuilder_setContentType != NULL) {
+                ((MA_PFN_AAudioStreamBuilder_setContentType)pContext->aaudio.AAudioStreamBuilder_setContentType)(pBuilder, ma_to_content_type__aaudio(pConfig->aaudio.contentType));
+            }
+
+            if (pConfig->aaudio.allowedCapturePolicy != ma_aaudio_allow_capture_default && pContext->aaudio.AAudioStreamBuilder_setAllowedCapturePolicy != NULL) {
+                ((MA_PFN_AAudioStreamBuilder_setAllowedCapturePolicy)pContext->aaudio.AAudioStreamBuilder_setAllowedCapturePolicy)(pBuilder, ma_to_allowed_capture_policy__aaudio(pConfig->aaudio.allowedCapturePolicy));
+            }
+
+            ((MA_PFN_AAudioStreamBuilder_setDataCallback)pContext->aaudio.AAudioStreamBuilder_setDataCallback)(pBuilder, ma_stream_data_callback_playback__aaudio, (void*)pDevice);
+        }
+
+        /* Not sure how this affects things, but since there's a mapping between miniaudio's performance profiles and AAudio's performance modes, let go ahead and set it. */
+        ((MA_PFN_AAudioStreamBuilder_setPerformanceMode)pContext->aaudio.AAudioStreamBuilder_setPerformanceMode)(pBuilder, (pConfig->performanceProfile == ma_performance_profile_low_latency) ? MA_AAUDIO_PERFORMANCE_MODE_LOW_LATENCY : MA_AAUDIO_PERFORMANCE_MODE_NONE);
+
+        /* We need to set an error callback to detect device changes. */
+        if (pDevice != NULL) {  /* <-- pDevice should never be null if pDescriptor is not null, which is always the case if we hit this branch. Check anyway for safety. */
+            ((MA_PFN_AAudioStreamBuilder_setErrorCallback)pContext->aaudio.AAudioStreamBuilder_setErrorCallback)(pBuilder, ma_stream_error_callback__aaudio, (void*)pDevice);
+        }
+    }
+
+    *ppBuilder = pBuilder;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_open_stream_and_close_builder__aaudio(ma_context* pContext, ma_AAudioStreamBuilder* pBuilder, ma_AAudioStream** ppStream)
+{
+    ma_result result;
+
+    result = ma_result_from_aaudio(((MA_PFN_AAudioStreamBuilder_openStream)pContext->aaudio.AAudioStreamBuilder_openStream)(pBuilder, ppStream));
+    ((MA_PFN_AAudioStreamBuilder_delete)pContext->aaudio.AAudioStreamBuilder_delete)(pBuilder);
+
+    return result;
+}
+
+static ma_result ma_open_stream_basic__aaudio(ma_context* pContext, const ma_device_id* pDeviceID, ma_device_type deviceType, ma_share_mode shareMode, ma_AAudioStream** ppStream)
+{
+    ma_result result;
+    ma_AAudioStreamBuilder* pBuilder;
+
+    *ppStream = NULL;
+
+    result = ma_create_and_configure_AAudioStreamBuilder__aaudio(pContext, pDeviceID, deviceType, shareMode, NULL, NULL, NULL, &pBuilder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_open_stream_and_close_builder__aaudio(pContext, pBuilder, ppStream);
+}
+
+static ma_result ma_open_stream__aaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_type deviceType, const ma_device_descriptor* pDescriptor, ma_AAudioStream** ppStream)
+{
+    ma_result result;
+    ma_AAudioStreamBuilder* pBuilder;
+
+    MA_ASSERT(pDevice != NULL);
+    MA_ASSERT(pDescriptor != NULL);
+    MA_ASSERT(deviceType != ma_device_type_duplex);   /* This function should not be called for a full-duplex device type. */
+
+    *ppStream = NULL;
+
+    result = ma_create_and_configure_AAudioStreamBuilder__aaudio(pDevice->pContext, pDescriptor->pDeviceID, deviceType, pDescriptor->shareMode, pDescriptor, pConfig, pDevice, &pBuilder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_open_stream_and_close_builder__aaudio(pDevice->pContext, pBuilder, ppStream);
+}
+
+static ma_result ma_close_stream__aaudio(ma_context* pContext, ma_AAudioStream* pStream)
+{
+    return ma_result_from_aaudio(((MA_PFN_AAudioStream_close)pContext->aaudio.AAudioStream_close)(pStream));
+}
+
+static ma_bool32 ma_has_default_device__aaudio(ma_context* pContext, ma_device_type deviceType)
+{
+    /* The only way to know this is to try creating a stream. */
+    ma_AAudioStream* pStream;
+    ma_result result = ma_open_stream_basic__aaudio(pContext, NULL, deviceType, ma_share_mode_shared, &pStream);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+
+    ma_close_stream__aaudio(pContext, pStream);
+    return MA_TRUE;
+}
+
+static ma_result ma_wait_for_simple_state_transition__aaudio(ma_context* pContext, ma_AAudioStream* pStream, ma_aaudio_stream_state_t oldState, ma_aaudio_stream_state_t newState)
+{
+    ma_aaudio_stream_state_t actualNewState;
+    ma_aaudio_result_t resultAA = ((MA_PFN_AAudioStream_waitForStateChange)pContext->aaudio.AAudioStream_waitForStateChange)(pStream, oldState, &actualNewState, 5000000000); /* 5 second timeout. */
+    if (resultAA != MA_AAUDIO_OK) {
+        return ma_result_from_aaudio(resultAA);
+    }
+
+    if (newState != actualNewState) {
+        return MA_ERROR;   /* Failed to transition into the expected state. */
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_enumerate_devices__aaudio(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 cbResult = MA_TRUE;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Unfortunately AAudio does not have an enumeration API. Therefore I'm only going to report default devices, but only if it can instantiate a stream. */
+
+    /* Playback. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        deviceInfo.id.aaudio = MA_AAUDIO_UNSPECIFIED;
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+
+        if (ma_has_default_device__aaudio(pContext, ma_device_type_playback)) {
+            cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+        }
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        deviceInfo.id.aaudio = MA_AAUDIO_UNSPECIFIED;
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+
+        if (ma_has_default_device__aaudio(pContext, ma_device_type_capture)) {
+            cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_context_add_native_data_format_from_AAudioStream_ex__aaudio(ma_context* pContext, ma_AAudioStream* pStream, ma_format format, ma_uint32 flags, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pContext    != NULL);
+    MA_ASSERT(pStream     != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = format;
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = ((MA_PFN_AAudioStream_getChannelCount)pContext->aaudio.AAudioStream_getChannelCount)(pStream);
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = ((MA_PFN_AAudioStream_getSampleRate)pContext->aaudio.AAudioStream_getSampleRate)(pStream);
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = flags;
+    pDeviceInfo->nativeDataFormatCount += 1;
+}
+
+static void ma_context_add_native_data_format_from_AAudioStream__aaudio(ma_context* pContext, ma_AAudioStream* pStream, ma_uint32 flags, ma_device_info* pDeviceInfo)
+{
+    /* AAudio supports s16 and f32. */
+    ma_context_add_native_data_format_from_AAudioStream_ex__aaudio(pContext, pStream, ma_format_f32, flags, pDeviceInfo);
+    ma_context_add_native_data_format_from_AAudioStream_ex__aaudio(pContext, pStream, ma_format_s16, flags, pDeviceInfo);
+}
+
+static ma_result ma_context_get_device_info__aaudio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_AAudioStream* pStream;
+    ma_result result;
+
+    MA_ASSERT(pContext != NULL);
+
+    /* ID */
+    if (pDeviceID != NULL) {
+        pDeviceInfo->id.aaudio = pDeviceID->aaudio;
+    } else {
+        pDeviceInfo->id.aaudio = MA_AAUDIO_UNSPECIFIED;
+    }
+
+    /* Name */
+    if (deviceType == ma_device_type_playback) {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+
+    pDeviceInfo->nativeDataFormatCount = 0;
+
+    /* We'll need to open the device to get accurate sample rate and channel count information. */
+    result = ma_open_stream_basic__aaudio(pContext, pDeviceID, deviceType, ma_share_mode_shared, &pStream);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    ma_context_add_native_data_format_from_AAudioStream__aaudio(pContext, pStream, 0, pDeviceInfo);
+
+    ma_close_stream__aaudio(pContext, pStream);
+    pStream = NULL;
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_device_uninit__aaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_close_stream__aaudio(pDevice->pContext, (ma_AAudioStream*)pDevice->aaudio.pStreamCapture);
+        pDevice->aaudio.pStreamCapture = NULL;
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_close_stream__aaudio(pDevice->pContext, (ma_AAudioStream*)pDevice->aaudio.pStreamPlayback);
+        pDevice->aaudio.pStreamPlayback = NULL;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init_by_type__aaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_type deviceType, ma_device_descriptor* pDescriptor, ma_AAudioStream** ppStream)
+{
+    ma_result result;
+    int32_t bufferCapacityInFrames;
+    int32_t framesPerDataCallback;
+    ma_AAudioStream* pStream;
+
+    MA_ASSERT(pDevice     != NULL);
+    MA_ASSERT(pConfig     != NULL);
+    MA_ASSERT(pDescriptor != NULL);
+
+    *ppStream = NULL;   /* Safety. */
+
+    /* First step is to open the stream. From there we'll be able to extract the internal configuration. */
+    result = ma_open_stream__aaudio(pDevice, pConfig, deviceType, pDescriptor, &pStream);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to open the AAudio stream. */
+    }
+
+    /* Now extract the internal configuration. */
+    pDescriptor->format     = (((MA_PFN_AAudioStream_getFormat)pDevice->pContext->aaudio.AAudioStream_getFormat)(pStream) == MA_AAUDIO_FORMAT_PCM_I16) ? ma_format_s16 : ma_format_f32;
+    pDescriptor->channels   = ((MA_PFN_AAudioStream_getChannelCount)pDevice->pContext->aaudio.AAudioStream_getChannelCount)(pStream);
+    pDescriptor->sampleRate = ((MA_PFN_AAudioStream_getSampleRate)pDevice->pContext->aaudio.AAudioStream_getSampleRate)(pStream);
+
+    /* For the channel map we need to be sure we don't overflow any buffers. */
+    if (pDescriptor->channels <= MA_MAX_CHANNELS) {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pDescriptor->channelMap, ma_countof(pDescriptor->channelMap), pDescriptor->channels); /* <-- Cannot find info on channel order, so assuming a default. */
+    } else {
+        ma_channel_map_init_blank(pDescriptor->channelMap, MA_MAX_CHANNELS); /* Too many channels. Use a blank channel map. */
+    }
+
+    bufferCapacityInFrames = ((MA_PFN_AAudioStream_getBufferCapacityInFrames)pDevice->pContext->aaudio.AAudioStream_getBufferCapacityInFrames)(pStream);
+    framesPerDataCallback = ((MA_PFN_AAudioStream_getFramesPerDataCallback)pDevice->pContext->aaudio.AAudioStream_getFramesPerDataCallback)(pStream);
+
+    if (framesPerDataCallback > 0) {
+        pDescriptor->periodSizeInFrames = framesPerDataCallback;
+        pDescriptor->periodCount        = bufferCapacityInFrames / framesPerDataCallback;
+    } else {
+        pDescriptor->periodSizeInFrames = bufferCapacityInFrames;
+        pDescriptor->periodCount        = 1;
+    }
+
+    *ppStream = pStream;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__aaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    pDevice->aaudio.usage                   = pConfig->aaudio.usage;
+    pDevice->aaudio.contentType             = pConfig->aaudio.contentType;
+    pDevice->aaudio.inputPreset             = pConfig->aaudio.inputPreset;
+    pDevice->aaudio.allowedCapturePolicy    = pConfig->aaudio.allowedCapturePolicy;
+    pDevice->aaudio.noAutoStartAfterReroute = pConfig->aaudio.noAutoStartAfterReroute;
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        result = ma_device_init_by_type__aaudio(pDevice, pConfig, ma_device_type_capture, pDescriptorCapture, (ma_AAudioStream**)&pDevice->aaudio.pStreamCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        result = ma_device_init_by_type__aaudio(pDevice, pConfig, ma_device_type_playback, pDescriptorPlayback, (ma_AAudioStream**)&pDevice->aaudio.pStreamPlayback);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start_stream__aaudio(ma_device* pDevice, ma_AAudioStream* pStream)
+{
+    ma_aaudio_result_t resultAA;
+    ma_aaudio_stream_state_t currentState;
+
+    MA_ASSERT(pDevice != NULL);
+
+    resultAA = ((MA_PFN_AAudioStream_requestStart)pDevice->pContext->aaudio.AAudioStream_requestStart)(pStream);
+    if (resultAA != MA_AAUDIO_OK) {
+        return ma_result_from_aaudio(resultAA);
+    }
+
+    /* Do we actually need to wait for the device to transition into it's started state? */
+
+    /* The device should be in either a starting or started state. If it's not set to started we need to wait for it to transition. It should go from starting to started. */
+    currentState = ((MA_PFN_AAudioStream_getState)pDevice->pContext->aaudio.AAudioStream_getState)(pStream);
+    if (currentState != MA_AAUDIO_STREAM_STATE_STARTED) {
+        ma_result result;
+
+        if (currentState != MA_AAUDIO_STREAM_STATE_STARTING) {
+            return MA_ERROR;   /* Expecting the stream to be a starting or started state. */
+        }
+
+        result = ma_wait_for_simple_state_transition__aaudio(pDevice->pContext, pStream, currentState, MA_AAUDIO_STREAM_STATE_STARTED);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop_stream__aaudio(ma_device* pDevice, ma_AAudioStream* pStream)
+{
+    ma_aaudio_result_t resultAA;
+    ma_aaudio_stream_state_t currentState;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    From the AAudio documentation:
+
+        The stream will stop after all of the data currently buffered has been played.
+
+    This maps with miniaudio's requirement that device's be drained which means we don't need to implement any draining logic.
+    */
+    currentState = ((MA_PFN_AAudioStream_getState)pDevice->pContext->aaudio.AAudioStream_getState)(pStream);
+    if (currentState == MA_AAUDIO_STREAM_STATE_DISCONNECTED) {
+        return MA_SUCCESS;  /* The device is disconnected. Don't try stopping it. */
+    }
+
+    resultAA = ((MA_PFN_AAudioStream_requestStop)pDevice->pContext->aaudio.AAudioStream_requestStop)(pStream);
+    if (resultAA != MA_AAUDIO_OK) {
+        return ma_result_from_aaudio(resultAA);
+    }
+
+    /* The device should be in either a stopping or stopped state. If it's not set to started we need to wait for it to transition. It should go from stopping to stopped. */
+    currentState = ((MA_PFN_AAudioStream_getState)pDevice->pContext->aaudio.AAudioStream_getState)(pStream);
+    if (currentState != MA_AAUDIO_STREAM_STATE_STOPPED) {
+        ma_result result;
+
+        if (currentState != MA_AAUDIO_STREAM_STATE_STOPPING) {
+            return MA_ERROR;   /* Expecting the stream to be a stopping or stopped state. */
+        }
+
+        result = ma_wait_for_simple_state_transition__aaudio(pDevice->pContext, pStream, currentState, MA_AAUDIO_STREAM_STATE_STOPPED);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_start__aaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_result result = ma_device_start_stream__aaudio(pDevice, (ma_AAudioStream*)pDevice->aaudio.pStreamCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_result result = ma_device_start_stream__aaudio(pDevice, (ma_AAudioStream*)pDevice->aaudio.pStreamPlayback);
+        if (result != MA_SUCCESS) {
+            if (pDevice->type == ma_device_type_duplex) {
+                ma_device_stop_stream__aaudio(pDevice, (ma_AAudioStream*)pDevice->aaudio.pStreamCapture);
+            }
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__aaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_result result = ma_device_stop_stream__aaudio(pDevice, (ma_AAudioStream*)pDevice->aaudio.pStreamCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_result result = ma_device_stop_stream__aaudio(pDevice, (ma_AAudioStream*)pDevice->aaudio.pStreamPlayback);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    ma_device__on_notification_stopped(pDevice);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_reinit__aaudio(ma_device* pDevice, ma_device_type deviceType)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    /* The first thing to do is close the streams. */
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex) {
+        ma_close_stream__aaudio(pDevice->pContext, (ma_AAudioStream*)pDevice->aaudio.pStreamCapture);
+        pDevice->aaudio.pStreamCapture = NULL;
+    }
+
+    if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+        ma_close_stream__aaudio(pDevice->pContext, (ma_AAudioStream*)pDevice->aaudio.pStreamPlayback);
+        pDevice->aaudio.pStreamPlayback = NULL;
+    }
+
+    /* Now we need to reinitialize each streams. The hardest part with this is just filling output the config and descriptors. */
+    {
+        ma_device_config deviceConfig;
+        ma_device_descriptor descriptorPlayback;
+        ma_device_descriptor descriptorCapture;
+
+        deviceConfig = ma_device_config_init(deviceType);
+        deviceConfig.playback.pDeviceID             = NULL; /* Only doing rerouting with default devices. */
+        deviceConfig.playback.shareMode             = pDevice->playback.shareMode;
+        deviceConfig.playback.format                = pDevice->playback.format;
+        deviceConfig.playback.channels              = pDevice->playback.channels;
+        deviceConfig.capture.pDeviceID              = NULL; /* Only doing rerouting with default devices. */
+        deviceConfig.capture.shareMode              = pDevice->capture.shareMode;
+        deviceConfig.capture.format                 = pDevice->capture.format;
+        deviceConfig.capture.channels               = pDevice->capture.channels;
+        deviceConfig.sampleRate                     = pDevice->sampleRate;
+        deviceConfig.aaudio.usage                   = pDevice->aaudio.usage;
+        deviceConfig.aaudio.contentType             = pDevice->aaudio.contentType;
+        deviceConfig.aaudio.inputPreset             = pDevice->aaudio.inputPreset;
+        deviceConfig.aaudio.allowedCapturePolicy    = pDevice->aaudio.allowedCapturePolicy;
+        deviceConfig.aaudio.noAutoStartAfterReroute = pDevice->aaudio.noAutoStartAfterReroute;
+        deviceConfig.periods                        = 1;
+
+        /* Try to get an accurate period size. */
+        if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+            deviceConfig.periodSizeInFrames = pDevice->playback.internalPeriodSizeInFrames;
+        } else {
+            deviceConfig.periodSizeInFrames = pDevice->capture.internalPeriodSizeInFrames;
+        }
+
+        if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+            descriptorCapture.pDeviceID           = deviceConfig.capture.pDeviceID;
+            descriptorCapture.shareMode           = deviceConfig.capture.shareMode;
+            descriptorCapture.format              = deviceConfig.capture.format;
+            descriptorCapture.channels            = deviceConfig.capture.channels;
+            descriptorCapture.sampleRate          = deviceConfig.sampleRate;
+            descriptorCapture.periodSizeInFrames  = deviceConfig.periodSizeInFrames;
+            descriptorCapture.periodCount         = deviceConfig.periods;
+        }
+
+        if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+            descriptorPlayback.pDeviceID          = deviceConfig.playback.pDeviceID;
+            descriptorPlayback.shareMode          = deviceConfig.playback.shareMode;
+            descriptorPlayback.format             = deviceConfig.playback.format;
+            descriptorPlayback.channels           = deviceConfig.playback.channels;
+            descriptorPlayback.sampleRate         = deviceConfig.sampleRate;
+            descriptorPlayback.periodSizeInFrames = deviceConfig.periodSizeInFrames;
+            descriptorPlayback.periodCount        = deviceConfig.periods;
+        }
+
+        result = ma_device_init__aaudio(pDevice, &deviceConfig, &descriptorPlayback, &descriptorCapture);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_device_post_init(pDevice, deviceType, &descriptorPlayback, &descriptorCapture);
+        if (result != MA_SUCCESS) {
+            ma_device_uninit__aaudio(pDevice);
+            return result;
+        }
+
+        /* We'll only ever do this in response to a reroute. */
+        ma_device__on_notification_rerouted(pDevice);
+
+        /* If the device is started, start the streams. Maybe make this configurable? */
+        if (ma_device_get_state(pDevice) == ma_device_state_started) {
+            if (pDevice->aaudio.noAutoStartAfterReroute == MA_FALSE) {
+                ma_device_start__aaudio(pDevice);
+            } else {
+                ma_device_stop(pDevice);    /* Do a full device stop so we set internal state correctly. */
+            }
+        }
+
+        return MA_SUCCESS;
+    }
+}
+
+static ma_result ma_device_get_info__aaudio(ma_device* pDevice, ma_device_type type, ma_device_info* pDeviceInfo)
+{
+    ma_AAudioStream* pStream = NULL;
+
+    MA_ASSERT(pDevice     != NULL);
+    MA_ASSERT(type        != ma_device_type_duplex);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    if (type == ma_device_type_playback) {
+        pStream = (ma_AAudioStream*)pDevice->aaudio.pStreamCapture;
+        pDeviceInfo->id.aaudio = pDevice->capture.id.aaudio;
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);     /* Only supporting default devices. */
+    }
+    if (type == ma_device_type_capture) {
+        pStream = (ma_AAudioStream*)pDevice->aaudio.pStreamPlayback;
+        pDeviceInfo->id.aaudio = pDevice->playback.id.aaudio;
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);    /* Only supporting default devices. */
+    }
+
+    /* Safety. Should never happen. */
+    if (pStream == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    pDeviceInfo->nativeDataFormatCount = 0;
+    ma_context_add_native_data_format_from_AAudioStream__aaudio(pDevice->pContext, pStream, 0, pDeviceInfo);
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_uninit__aaudio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_aaudio);
+
+    ma_device_job_thread_uninit(&pContext->aaudio.jobThread, &pContext->allocationCallbacks);
+
+    ma_dlclose(ma_context_get_log(pContext), pContext->aaudio.hAAudio);
+    pContext->aaudio.hAAudio = NULL;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__aaudio(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    size_t i;
+    const char* libNames[] = {
+        "libaaudio.so"
+    };
+
+    for (i = 0; i < ma_countof(libNames); ++i) {
+        pContext->aaudio.hAAudio = ma_dlopen(ma_context_get_log(pContext), libNames[i]);
+        if (pContext->aaudio.hAAudio != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->aaudio.hAAudio == NULL) {
+        return MA_FAILED_TO_INIT_BACKEND;
+    }
+
+    pContext->aaudio.AAudio_createStreamBuilder                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudio_createStreamBuilder");
+    pContext->aaudio.AAudioStreamBuilder_delete                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_delete");
+    pContext->aaudio.AAudioStreamBuilder_setDeviceId               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setDeviceId");
+    pContext->aaudio.AAudioStreamBuilder_setDirection              = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setDirection");
+    pContext->aaudio.AAudioStreamBuilder_setSharingMode            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setSharingMode");
+    pContext->aaudio.AAudioStreamBuilder_setFormat                 = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setFormat");
+    pContext->aaudio.AAudioStreamBuilder_setChannelCount           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setChannelCount");
+    pContext->aaudio.AAudioStreamBuilder_setSampleRate             = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setSampleRate");
+    pContext->aaudio.AAudioStreamBuilder_setBufferCapacityInFrames = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setBufferCapacityInFrames");
+    pContext->aaudio.AAudioStreamBuilder_setFramesPerDataCallback  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setFramesPerDataCallback");
+    pContext->aaudio.AAudioStreamBuilder_setDataCallback           = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setDataCallback");
+    pContext->aaudio.AAudioStreamBuilder_setErrorCallback          = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setErrorCallback");
+    pContext->aaudio.AAudioStreamBuilder_setPerformanceMode        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setPerformanceMode");
+    pContext->aaudio.AAudioStreamBuilder_setUsage                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setUsage");
+    pContext->aaudio.AAudioStreamBuilder_setContentType            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setContentType");
+    pContext->aaudio.AAudioStreamBuilder_setInputPreset            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setInputPreset");
+    pContext->aaudio.AAudioStreamBuilder_setAllowedCapturePolicy   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_setAllowedCapturePolicy");
+    pContext->aaudio.AAudioStreamBuilder_openStream                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStreamBuilder_openStream");
+    pContext->aaudio.AAudioStream_close                            = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_close");
+    pContext->aaudio.AAudioStream_getState                         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getState");
+    pContext->aaudio.AAudioStream_waitForStateChange               = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_waitForStateChange");
+    pContext->aaudio.AAudioStream_getFormat                        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getFormat");
+    pContext->aaudio.AAudioStream_getChannelCount                  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getChannelCount");
+    pContext->aaudio.AAudioStream_getSampleRate                    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getSampleRate");
+    pContext->aaudio.AAudioStream_getBufferCapacityInFrames        = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getBufferCapacityInFrames");
+    pContext->aaudio.AAudioStream_getFramesPerDataCallback         = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getFramesPerDataCallback");
+    pContext->aaudio.AAudioStream_getFramesPerBurst                = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_getFramesPerBurst");
+    pContext->aaudio.AAudioStream_requestStart                     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_requestStart");
+    pContext->aaudio.AAudioStream_requestStop                      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->aaudio.hAAudio, "AAudioStream_requestStop");
+
+
+    pCallbacks->onContextInit             = ma_context_init__aaudio;
+    pCallbacks->onContextUninit           = ma_context_uninit__aaudio;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__aaudio;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__aaudio;
+    pCallbacks->onDeviceInit              = ma_device_init__aaudio;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__aaudio;
+    pCallbacks->onDeviceStart             = ma_device_start__aaudio;
+    pCallbacks->onDeviceStop              = ma_device_stop__aaudio;
+    pCallbacks->onDeviceRead              = NULL;   /* Not used because AAudio is asynchronous. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not used because AAudio is asynchronous. */
+    pCallbacks->onDeviceDataLoop          = NULL;   /* Not used because AAudio is asynchronous. */
+    pCallbacks->onDeviceGetInfo           = ma_device_get_info__aaudio;
+
+
+    /* We need a job thread so we can deal with rerouting. */
+    {
+        ma_result result;
+        ma_device_job_thread_config jobThreadConfig;
+
+        jobThreadConfig = ma_device_job_thread_config_init();
+
+        result = ma_device_job_thread_init(&jobThreadConfig, &pContext->allocationCallbacks, &pContext->aaudio.jobThread);
+        if (result != MA_SUCCESS) {
+            ma_dlclose(ma_context_get_log(pContext), pContext->aaudio.hAAudio);
+            pContext->aaudio.hAAudio = NULL;
+            return result;
+        }
+    }
+
+
+    (void)pConfig;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_job_process__device__aaudio_reroute(ma_job* pJob)
+{
+    ma_device* pDevice;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDevice = (ma_device*)pJob->data.device.aaudio.reroute.pDevice;
+    MA_ASSERT(pDevice != NULL);
+
+    /* Here is where we need to reroute the device. To do this we need to uninitialize the stream and reinitialize it. */
+    return ma_device_reinit__aaudio(pDevice, (ma_device_type)pJob->data.device.aaudio.reroute.deviceType);
+}
+#else
+/* Getting here means there is no AAudio backend so we need a no-op job implementation. */
+static ma_result ma_job_process__device__aaudio_reroute(ma_job* pJob)
+{
+    return ma_job_process__noop(pJob);
+}
+#endif  /* AAudio */
+
+
+/******************************************************************************
+
+OpenSL|ES Backend
+
+******************************************************************************/
+#ifdef MA_HAS_OPENSL
+#include <SLES/OpenSLES.h>
+#ifdef MA_ANDROID
+#include <SLES/OpenSLES_Android.h>
+#endif
+
+typedef SLresult (SLAPIENTRY * ma_slCreateEngine_proc)(SLObjectItf* pEngine, SLuint32 numOptions, SLEngineOption* pEngineOptions, SLuint32 numInterfaces, SLInterfaceID* pInterfaceIds, SLboolean* pInterfaceRequired);
+
+/* OpenSL|ES has one-per-application objects :( */
+static SLObjectItf g_maEngineObjectSL    = NULL;
+static SLEngineItf g_maEngineSL          = NULL;
+static ma_uint32   g_maOpenSLInitCounter = 0;
+static ma_spinlock g_maOpenSLSpinlock    = 0;   /* For init/uninit. */
+
+#define MA_OPENSL_OBJ(p)         (*((SLObjectItf)(p)))
+#define MA_OPENSL_OUTPUTMIX(p)   (*((SLOutputMixItf)(p)))
+#define MA_OPENSL_PLAY(p)        (*((SLPlayItf)(p)))
+#define MA_OPENSL_RECORD(p)      (*((SLRecordItf)(p)))
+
+#ifdef MA_ANDROID
+#define MA_OPENSL_BUFFERQUEUE(p) (*((SLAndroidSimpleBufferQueueItf)(p)))
+#else
+#define MA_OPENSL_BUFFERQUEUE(p) (*((SLBufferQueueItf)(p)))
+#endif
+
+static ma_result ma_result_from_OpenSL(SLuint32 result)
+{
+    switch (result)
+    {
+        case SL_RESULT_SUCCESS:                 return MA_SUCCESS;
+        case SL_RESULT_PRECONDITIONS_VIOLATED:  return MA_ERROR;
+        case SL_RESULT_PARAMETER_INVALID:       return MA_INVALID_ARGS;
+        case SL_RESULT_MEMORY_FAILURE:          return MA_OUT_OF_MEMORY;
+        case SL_RESULT_RESOURCE_ERROR:          return MA_INVALID_DATA;
+        case SL_RESULT_RESOURCE_LOST:           return MA_ERROR;
+        case SL_RESULT_IO_ERROR:                return MA_IO_ERROR;
+        case SL_RESULT_BUFFER_INSUFFICIENT:     return MA_NO_SPACE;
+        case SL_RESULT_CONTENT_CORRUPTED:       return MA_INVALID_DATA;
+        case SL_RESULT_CONTENT_UNSUPPORTED:     return MA_FORMAT_NOT_SUPPORTED;
+        case SL_RESULT_CONTENT_NOT_FOUND:       return MA_ERROR;
+        case SL_RESULT_PERMISSION_DENIED:       return MA_ACCESS_DENIED;
+        case SL_RESULT_FEATURE_UNSUPPORTED:     return MA_NOT_IMPLEMENTED;
+        case SL_RESULT_INTERNAL_ERROR:          return MA_ERROR;
+        case SL_RESULT_UNKNOWN_ERROR:           return MA_ERROR;
+        case SL_RESULT_OPERATION_ABORTED:       return MA_ERROR;
+        case SL_RESULT_CONTROL_LOST:            return MA_ERROR;
+        default:                                return MA_ERROR;
+    }
+}
+
+/* Converts an individual OpenSL-style channel identifier (SL_SPEAKER_FRONT_LEFT, etc.) to miniaudio. */
+static ma_uint8 ma_channel_id_to_ma__opensl(SLuint32 id)
+{
+    switch (id)
+    {
+        case SL_SPEAKER_FRONT_LEFT:            return MA_CHANNEL_FRONT_LEFT;
+        case SL_SPEAKER_FRONT_RIGHT:           return MA_CHANNEL_FRONT_RIGHT;
+        case SL_SPEAKER_FRONT_CENTER:          return MA_CHANNEL_FRONT_CENTER;
+        case SL_SPEAKER_LOW_FREQUENCY:         return MA_CHANNEL_LFE;
+        case SL_SPEAKER_BACK_LEFT:             return MA_CHANNEL_BACK_LEFT;
+        case SL_SPEAKER_BACK_RIGHT:            return MA_CHANNEL_BACK_RIGHT;
+        case SL_SPEAKER_FRONT_LEFT_OF_CENTER:  return MA_CHANNEL_FRONT_LEFT_CENTER;
+        case SL_SPEAKER_FRONT_RIGHT_OF_CENTER: return MA_CHANNEL_FRONT_RIGHT_CENTER;
+        case SL_SPEAKER_BACK_CENTER:           return MA_CHANNEL_BACK_CENTER;
+        case SL_SPEAKER_SIDE_LEFT:             return MA_CHANNEL_SIDE_LEFT;
+        case SL_SPEAKER_SIDE_RIGHT:            return MA_CHANNEL_SIDE_RIGHT;
+        case SL_SPEAKER_TOP_CENTER:            return MA_CHANNEL_TOP_CENTER;
+        case SL_SPEAKER_TOP_FRONT_LEFT:        return MA_CHANNEL_TOP_FRONT_LEFT;
+        case SL_SPEAKER_TOP_FRONT_CENTER:      return MA_CHANNEL_TOP_FRONT_CENTER;
+        case SL_SPEAKER_TOP_FRONT_RIGHT:       return MA_CHANNEL_TOP_FRONT_RIGHT;
+        case SL_SPEAKER_TOP_BACK_LEFT:         return MA_CHANNEL_TOP_BACK_LEFT;
+        case SL_SPEAKER_TOP_BACK_CENTER:       return MA_CHANNEL_TOP_BACK_CENTER;
+        case SL_SPEAKER_TOP_BACK_RIGHT:        return MA_CHANNEL_TOP_BACK_RIGHT;
+        default: return 0;
+    }
+}
+
+/* Converts an individual miniaudio channel identifier (MA_CHANNEL_FRONT_LEFT, etc.) to OpenSL-style. */
+static SLuint32 ma_channel_id_to_opensl(ma_uint8 id)
+{
+    switch (id)
+    {
+        case MA_CHANNEL_MONO:               return SL_SPEAKER_FRONT_CENTER;
+        case MA_CHANNEL_FRONT_LEFT:         return SL_SPEAKER_FRONT_LEFT;
+        case MA_CHANNEL_FRONT_RIGHT:        return SL_SPEAKER_FRONT_RIGHT;
+        case MA_CHANNEL_FRONT_CENTER:       return SL_SPEAKER_FRONT_CENTER;
+        case MA_CHANNEL_LFE:                return SL_SPEAKER_LOW_FREQUENCY;
+        case MA_CHANNEL_BACK_LEFT:          return SL_SPEAKER_BACK_LEFT;
+        case MA_CHANNEL_BACK_RIGHT:         return SL_SPEAKER_BACK_RIGHT;
+        case MA_CHANNEL_FRONT_LEFT_CENTER:  return SL_SPEAKER_FRONT_LEFT_OF_CENTER;
+        case MA_CHANNEL_FRONT_RIGHT_CENTER: return SL_SPEAKER_FRONT_RIGHT_OF_CENTER;
+        case MA_CHANNEL_BACK_CENTER:        return SL_SPEAKER_BACK_CENTER;
+        case MA_CHANNEL_SIDE_LEFT:          return SL_SPEAKER_SIDE_LEFT;
+        case MA_CHANNEL_SIDE_RIGHT:         return SL_SPEAKER_SIDE_RIGHT;
+        case MA_CHANNEL_TOP_CENTER:         return SL_SPEAKER_TOP_CENTER;
+        case MA_CHANNEL_TOP_FRONT_LEFT:     return SL_SPEAKER_TOP_FRONT_LEFT;
+        case MA_CHANNEL_TOP_FRONT_CENTER:   return SL_SPEAKER_TOP_FRONT_CENTER;
+        case MA_CHANNEL_TOP_FRONT_RIGHT:    return SL_SPEAKER_TOP_FRONT_RIGHT;
+        case MA_CHANNEL_TOP_BACK_LEFT:      return SL_SPEAKER_TOP_BACK_LEFT;
+        case MA_CHANNEL_TOP_BACK_CENTER:    return SL_SPEAKER_TOP_BACK_CENTER;
+        case MA_CHANNEL_TOP_BACK_RIGHT:     return SL_SPEAKER_TOP_BACK_RIGHT;
+        default: return 0;
+    }
+}
+
+/* Converts a channel mapping to an OpenSL-style channel mask. */
+static SLuint32 ma_channel_map_to_channel_mask__opensl(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    SLuint32 channelMask = 0;
+    ma_uint32 iChannel;
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        channelMask |= ma_channel_id_to_opensl(pChannelMap[iChannel]);
+    }
+
+    return channelMask;
+}
+
+/* Converts an OpenSL-style channel mask to a miniaudio channel map. */
+static void ma_channel_mask_to_channel_map__opensl(SLuint32 channelMask, ma_uint32 channels, ma_channel* pChannelMap)
+{
+    if (channels == 1 && channelMask == 0) {
+        pChannelMap[0] = MA_CHANNEL_MONO;
+    } else if (channels == 2 && channelMask == 0) {
+        pChannelMap[0] = MA_CHANNEL_FRONT_LEFT;
+        pChannelMap[1] = MA_CHANNEL_FRONT_RIGHT;
+    } else {
+        if (channels == 1 && (channelMask & SL_SPEAKER_FRONT_CENTER) != 0) {
+            pChannelMap[0] = MA_CHANNEL_MONO;
+        } else {
+            /* Just iterate over each bit. */
+            ma_uint32 iChannel = 0;
+            ma_uint32 iBit;
+            for (iBit = 0; iBit < 32 && iChannel < channels; ++iBit) {
+                SLuint32 bitValue = (channelMask & (1UL << iBit));
+                if (bitValue != 0) {
+                    /* The bit is set. */
+                    pChannelMap[iChannel] = ma_channel_id_to_ma__opensl(bitValue);
+                    iChannel += 1;
+                }
+            }
+        }
+    }
+}
+
+static SLuint32 ma_round_to_standard_sample_rate__opensl(SLuint32 samplesPerSec)
+{
+    if (samplesPerSec <= SL_SAMPLINGRATE_8) {
+        return SL_SAMPLINGRATE_8;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_11_025) {
+        return SL_SAMPLINGRATE_11_025;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_12) {
+        return SL_SAMPLINGRATE_12;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_16) {
+        return SL_SAMPLINGRATE_16;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_22_05) {
+        return SL_SAMPLINGRATE_22_05;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_24) {
+        return SL_SAMPLINGRATE_24;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_32) {
+        return SL_SAMPLINGRATE_32;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_44_1) {
+        return SL_SAMPLINGRATE_44_1;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_48) {
+        return SL_SAMPLINGRATE_48;
+    }
+
+    /* Android doesn't support more than 48000. */
+#ifndef MA_ANDROID
+    if (samplesPerSec <= SL_SAMPLINGRATE_64) {
+        return SL_SAMPLINGRATE_64;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_88_2) {
+        return SL_SAMPLINGRATE_88_2;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_96) {
+        return SL_SAMPLINGRATE_96;
+    }
+    if (samplesPerSec <= SL_SAMPLINGRATE_192) {
+        return SL_SAMPLINGRATE_192;
+    }
+#endif
+
+    return SL_SAMPLINGRATE_16;
+}
+
+
+static SLint32 ma_to_stream_type__opensl(ma_opensl_stream_type streamType)
+{
+    switch (streamType) {
+        case ma_opensl_stream_type_voice:        return SL_ANDROID_STREAM_VOICE;
+        case ma_opensl_stream_type_system:       return SL_ANDROID_STREAM_SYSTEM;
+        case ma_opensl_stream_type_ring:         return SL_ANDROID_STREAM_RING;
+        case ma_opensl_stream_type_media:        return SL_ANDROID_STREAM_MEDIA;
+        case ma_opensl_stream_type_alarm:        return SL_ANDROID_STREAM_ALARM;
+        case ma_opensl_stream_type_notification: return SL_ANDROID_STREAM_NOTIFICATION;
+        default: break;
+    }
+
+    return SL_ANDROID_STREAM_VOICE;
+}
+
+static SLint32 ma_to_recording_preset__opensl(ma_opensl_recording_preset recordingPreset)
+{
+    switch (recordingPreset) {
+        case ma_opensl_recording_preset_generic:             return SL_ANDROID_RECORDING_PRESET_GENERIC;
+        case ma_opensl_recording_preset_camcorder:           return SL_ANDROID_RECORDING_PRESET_CAMCORDER;
+        case ma_opensl_recording_preset_voice_recognition:   return SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION;
+        case ma_opensl_recording_preset_voice_communication: return SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION;
+        case ma_opensl_recording_preset_voice_unprocessed:   return SL_ANDROID_RECORDING_PRESET_UNPROCESSED;
+        default: break;
+    }
+
+    return SL_ANDROID_RECORDING_PRESET_NONE;
+}
+
+
+static ma_result ma_context_enumerate_devices__opensl(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 cbResult;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it and then attempted to enumerate devices. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /*
+    TODO: Test Me.
+
+    This is currently untested, so for now we are just returning default devices.
+    */
+#if 0 && !defined(MA_ANDROID)
+    ma_bool32 isTerminated = MA_FALSE;
+
+    SLuint32 pDeviceIDs[128];
+    SLint32 deviceCount = sizeof(pDeviceIDs) / sizeof(pDeviceIDs[0]);
+
+    SLAudioIODeviceCapabilitiesItf deviceCaps;
+    SLresult resultSL = (*g_maEngineObjectSL)->GetInterface(g_maEngineObjectSL, (SLInterfaceID)pContext->opensl.SL_IID_AUDIOIODEVICECAPABILITIES, &deviceCaps);
+    if (resultSL != SL_RESULT_SUCCESS) {
+        /* The interface may not be supported so just report a default device. */
+        goto return_default_device;
+    }
+
+    /* Playback */
+    if (!isTerminated) {
+        resultSL = (*deviceCaps)->GetAvailableAudioOutputs(deviceCaps, &deviceCount, pDeviceIDs);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        for (SLint32 iDevice = 0; iDevice < deviceCount; ++iDevice) {
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            deviceInfo.id.opensl = pDeviceIDs[iDevice];
+
+            SLAudioOutputDescriptor desc;
+            resultSL = (*deviceCaps)->QueryAudioOutputCapabilities(deviceCaps, deviceInfo.id.opensl, &desc);
+            if (resultSL == SL_RESULT_SUCCESS) {
+                ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), (const char*)desc.pDeviceName, (size_t)-1);
+
+                ma_bool32 cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+                if (cbResult == MA_FALSE) {
+                    isTerminated = MA_TRUE;
+                    break;
+                }
+            }
+        }
+    }
+
+    /* Capture */
+    if (!isTerminated) {
+        resultSL = (*deviceCaps)->GetAvailableAudioInputs(deviceCaps, &deviceCount, pDeviceIDs);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        for (SLint32 iDevice = 0; iDevice < deviceCount; ++iDevice) {
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            deviceInfo.id.opensl = pDeviceIDs[iDevice];
+
+            SLAudioInputDescriptor desc;
+            resultSL = (*deviceCaps)->QueryAudioInputCapabilities(deviceCaps, deviceInfo.id.opensl, &desc);
+            if (resultSL == SL_RESULT_SUCCESS) {
+                ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), (const char*)desc.deviceName, (size_t)-1);
+
+                ma_bool32 cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+                if (cbResult == MA_FALSE) {
+                    isTerminated = MA_TRUE;
+                    break;
+                }
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+#else
+    goto return_default_device;
+#endif
+
+return_default_device:;
+    cbResult = MA_TRUE;
+
+    /* Playback. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        deviceInfo.id.opensl = SL_DEFAULTDEVICEID_AUDIOOUTPUT;
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+        cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        deviceInfo.id.opensl = SL_DEFAULTDEVICEID_AUDIOINPUT;
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+        cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_context_add_data_format_ex__opensl(ma_context* pContext, ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pContext    != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].format     = format;
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].channels   = channels;
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].sampleRate = sampleRate;
+    pDeviceInfo->nativeDataFormats[pDeviceInfo->nativeDataFormatCount].flags      = 0;
+    pDeviceInfo->nativeDataFormatCount += 1;
+}
+
+static void ma_context_add_data_format__opensl(ma_context* pContext, ma_format format, ma_device_info* pDeviceInfo)
+{
+    ma_uint32 minChannels   = 1;
+    ma_uint32 maxChannels   = 2;
+    ma_uint32 minSampleRate = (ma_uint32)ma_standard_sample_rate_8000;
+    ma_uint32 maxSampleRate = (ma_uint32)ma_standard_sample_rate_48000;
+    ma_uint32 iChannel;
+    ma_uint32 iSampleRate;
+
+    MA_ASSERT(pContext    != NULL);
+    MA_ASSERT(pDeviceInfo != NULL);
+
+    /*
+    Each sample format can support mono and stereo, and we'll support a small subset of standard
+    rates (up to 48000). A better solution would be to somehow find a native sample rate.
+    */
+    for (iChannel = minChannels; iChannel < maxChannels; iChannel += 1) {
+        for (iSampleRate = 0; iSampleRate < ma_countof(g_maStandardSampleRatePriorities); iSampleRate += 1) {
+            ma_uint32 standardSampleRate = g_maStandardSampleRatePriorities[iSampleRate];
+            if (standardSampleRate >= minSampleRate && standardSampleRate <= maxSampleRate) {
+                ma_context_add_data_format_ex__opensl(pContext, format, iChannel, standardSampleRate, pDeviceInfo);
+            }
+        }
+    }
+}
+
+static ma_result ma_context_get_device_info__opensl(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pContext != NULL);
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it and then attempted to get device info. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /*
+    TODO: Test Me.
+
+    This is currently untested, so for now we are just returning default devices.
+    */
+#if 0 && !defined(MA_ANDROID)
+    SLAudioIODeviceCapabilitiesItf deviceCaps;
+    SLresult resultSL = (*g_maEngineObjectSL)->GetInterface(g_maEngineObjectSL, (SLInterfaceID)pContext->opensl.SL_IID_AUDIOIODEVICECAPABILITIES, &deviceCaps);
+    if (resultSL != SL_RESULT_SUCCESS) {
+        /* The interface may not be supported so just report a default device. */
+        goto return_default_device;
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        SLAudioOutputDescriptor desc;
+        resultSL = (*deviceCaps)->QueryAudioOutputCapabilities(deviceCaps, pDeviceID->opensl, &desc);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), (const char*)desc.pDeviceName, (size_t)-1);
+    } else {
+        SLAudioInputDescriptor desc;
+        resultSL = (*deviceCaps)->QueryAudioInputCapabilities(deviceCaps, pDeviceID->opensl, &desc);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), (const char*)desc.deviceName, (size_t)-1);
+    }
+
+    goto return_detailed_info;
+#else
+    goto return_default_device;
+#endif
+
+return_default_device:
+    if (pDeviceID != NULL) {
+        if ((deviceType == ma_device_type_playback && pDeviceID->opensl != SL_DEFAULTDEVICEID_AUDIOOUTPUT) ||
+            (deviceType == ma_device_type_capture  && pDeviceID->opensl != SL_DEFAULTDEVICEID_AUDIOINPUT)) {
+            return MA_NO_DEVICE;   /* Don't know the device. */
+        }
+    }
+
+    /* ID and Name / Description */
+    if (deviceType == ma_device_type_playback) {
+        pDeviceInfo->id.opensl = SL_DEFAULTDEVICEID_AUDIOOUTPUT;
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        pDeviceInfo->id.opensl = SL_DEFAULTDEVICEID_AUDIOINPUT;
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+    pDeviceInfo->isDefault = MA_TRUE;
+
+    goto return_detailed_info;
+
+
+return_detailed_info:
+
+    /*
+    For now we're just outputting a set of values that are supported by the API but not necessarily supported
+    by the device natively. Later on we should work on this so that it more closely reflects the device's
+    actual native format.
+    */
+    pDeviceInfo->nativeDataFormatCount = 0;
+#if defined(MA_ANDROID) && __ANDROID_API__ >= 21
+    ma_context_add_data_format__opensl(pContext, ma_format_f32, pDeviceInfo);
+#endif
+    ma_context_add_data_format__opensl(pContext, ma_format_s16, pDeviceInfo);
+    ma_context_add_data_format__opensl(pContext, ma_format_u8,  pDeviceInfo);
+
+    return MA_SUCCESS;
+}
+
+
+#ifdef MA_ANDROID
+/*void ma_buffer_queue_callback_capture__opensl_android(SLAndroidSimpleBufferQueueItf pBufferQueue, SLuint32 eventFlags, const void* pBuffer, SLuint32 bufferSize, SLuint32 dataUsed, void* pContext)*/
+static void ma_buffer_queue_callback_capture__opensl_android(SLAndroidSimpleBufferQueueItf pBufferQueue, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    size_t periodSizeInBytes;
+    ma_uint8* pBuffer;
+    SLresult resultSL;
+
+    MA_ASSERT(pDevice != NULL);
+
+    (void)pBufferQueue;
+
+    /*
+    For now, don't do anything unless the buffer was fully processed. From what I can tell, it looks like
+    OpenSL|ES 1.1 improves on buffer queues to the point that we could much more intelligently handle this,
+    but unfortunately it looks like Android is only supporting OpenSL|ES 1.0.1 for now :(
+    */
+
+    /* Don't do anything if the device is not started. */
+    if (ma_device_get_state(pDevice) != ma_device_state_started) {
+        return;
+    }
+
+    /* Don't do anything if the device is being drained. */
+    if (pDevice->opensl.isDrainingCapture) {
+        return;
+    }
+
+    periodSizeInBytes = pDevice->capture.internalPeriodSizeInFrames * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+    pBuffer = pDevice->opensl.pBufferCapture + (pDevice->opensl.currentBufferIndexCapture * periodSizeInBytes);
+
+    ma_device_handle_backend_data_callback(pDevice, NULL, pBuffer, pDevice->capture.internalPeriodSizeInFrames);
+
+    resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueueCapture)->Enqueue((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueueCapture, pBuffer, periodSizeInBytes);
+    if (resultSL != SL_RESULT_SUCCESS) {
+        return;
+    }
+
+    pDevice->opensl.currentBufferIndexCapture = (pDevice->opensl.currentBufferIndexCapture + 1) % pDevice->capture.internalPeriods;
+}
+
+static void ma_buffer_queue_callback_playback__opensl_android(SLAndroidSimpleBufferQueueItf pBufferQueue, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    size_t periodSizeInBytes;
+    ma_uint8* pBuffer;
+    SLresult resultSL;
+
+    MA_ASSERT(pDevice != NULL);
+
+    (void)pBufferQueue;
+
+    /* Don't do anything if the device is not started. */
+    if (ma_device_get_state(pDevice) != ma_device_state_started) {
+        return;
+    }
+
+    /* Don't do anything if the device is being drained. */
+    if (pDevice->opensl.isDrainingPlayback) {
+        return;
+    }
+
+    periodSizeInBytes = pDevice->playback.internalPeriodSizeInFrames * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+    pBuffer = pDevice->opensl.pBufferPlayback + (pDevice->opensl.currentBufferIndexPlayback * periodSizeInBytes);
+
+    ma_device_handle_backend_data_callback(pDevice, pBuffer, NULL, pDevice->playback.internalPeriodSizeInFrames);
+
+    resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueuePlayback)->Enqueue((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueuePlayback, pBuffer, periodSizeInBytes);
+    if (resultSL != SL_RESULT_SUCCESS) {
+        return;
+    }
+
+    pDevice->opensl.currentBufferIndexPlayback = (pDevice->opensl.currentBufferIndexPlayback + 1) % pDevice->playback.internalPeriods;
+}
+#endif
+
+static ma_result ma_device_uninit__opensl(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it before uninitializing the device. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->opensl.pAudioRecorderObj) {
+            MA_OPENSL_OBJ(pDevice->opensl.pAudioRecorderObj)->Destroy((SLObjectItf)pDevice->opensl.pAudioRecorderObj);
+        }
+
+        ma_free(pDevice->opensl.pBufferCapture, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        if (pDevice->opensl.pAudioPlayerObj) {
+            MA_OPENSL_OBJ(pDevice->opensl.pAudioPlayerObj)->Destroy((SLObjectItf)pDevice->opensl.pAudioPlayerObj);
+        }
+        if (pDevice->opensl.pOutputMixObj) {
+            MA_OPENSL_OBJ(pDevice->opensl.pOutputMixObj)->Destroy((SLObjectItf)pDevice->opensl.pOutputMixObj);
+        }
+
+        ma_free(pDevice->opensl.pBufferPlayback, &pDevice->pContext->allocationCallbacks);
+    }
+
+    return MA_SUCCESS;
+}
+
+#if defined(MA_ANDROID) && __ANDROID_API__ >= 21
+typedef SLAndroidDataFormat_PCM_EX  ma_SLDataFormat_PCM;
+#else
+typedef SLDataFormat_PCM            ma_SLDataFormat_PCM;
+#endif
+
+static ma_result ma_SLDataFormat_PCM_init__opensl(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, const ma_channel* channelMap, ma_SLDataFormat_PCM* pDataFormat)
+{
+    /* We need to convert our format/channels/rate so that they aren't set to default. */
+    if (format == ma_format_unknown) {
+        format = MA_DEFAULT_FORMAT;
+    }
+    if (channels == 0) {
+        channels = MA_DEFAULT_CHANNELS;
+    }
+    if (sampleRate == 0) {
+        sampleRate = MA_DEFAULT_SAMPLE_RATE;
+    }
+
+#if defined(MA_ANDROID) && __ANDROID_API__ >= 21
+    if (format == ma_format_f32) {
+        pDataFormat->formatType     = SL_ANDROID_DATAFORMAT_PCM_EX;
+        pDataFormat->representation = SL_ANDROID_PCM_REPRESENTATION_FLOAT;
+    } else {
+        pDataFormat->formatType = SL_DATAFORMAT_PCM;
+    }
+#else
+    pDataFormat->formatType = SL_DATAFORMAT_PCM;
+#endif
+
+    pDataFormat->numChannels   = channels;
+    ((SLDataFormat_PCM*)pDataFormat)->samplesPerSec = ma_round_to_standard_sample_rate__opensl(sampleRate * 1000);  /* In millihertz. Annoyingly, the sample rate variable is named differently between SLAndroidDataFormat_PCM_EX and SLDataFormat_PCM */
+    pDataFormat->bitsPerSample = ma_get_bytes_per_sample(format) * 8;
+    pDataFormat->channelMask   = ma_channel_map_to_channel_mask__opensl(channelMap, channels);
+    pDataFormat->endianness    = (ma_is_little_endian()) ? SL_BYTEORDER_LITTLEENDIAN : SL_BYTEORDER_BIGENDIAN;
+
+    /*
+    Android has a few restrictions on the format as documented here: https://developer.android.com/ndk/guides/audio/opensl-for-android.html
+     - Only mono and stereo is supported.
+     - Only u8 and s16 formats are supported.
+     - Maximum sample rate of 48000.
+    */
+#ifdef MA_ANDROID
+    if (pDataFormat->numChannels > 2) {
+        pDataFormat->numChannels = 2;
+    }
+#if __ANDROID_API__ >= 21
+    if (pDataFormat->formatType == SL_ANDROID_DATAFORMAT_PCM_EX) {
+        /* It's floating point. */
+        MA_ASSERT(pDataFormat->representation == SL_ANDROID_PCM_REPRESENTATION_FLOAT);
+        if (pDataFormat->bitsPerSample > 32) {
+            pDataFormat->bitsPerSample = 32;
+        }
+    } else {
+        if (pDataFormat->bitsPerSample > 16) {
+            pDataFormat->bitsPerSample = 16;
+        }
+    }
+#else
+    if (pDataFormat->bitsPerSample > 16) {
+        pDataFormat->bitsPerSample = 16;
+    }
+#endif
+    if (((SLDataFormat_PCM*)pDataFormat)->samplesPerSec > SL_SAMPLINGRATE_48) {
+        ((SLDataFormat_PCM*)pDataFormat)->samplesPerSec = SL_SAMPLINGRATE_48;
+    }
+#endif
+
+    pDataFormat->containerSize = pDataFormat->bitsPerSample;  /* Always tightly packed for now. */
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_deconstruct_SLDataFormat_PCM__opensl(ma_SLDataFormat_PCM* pDataFormat, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_bool32 isFloatingPoint = MA_FALSE;
+#if defined(MA_ANDROID) && __ANDROID_API__ >= 21
+    if (pDataFormat->formatType == SL_ANDROID_DATAFORMAT_PCM_EX) {
+        MA_ASSERT(pDataFormat->representation == SL_ANDROID_PCM_REPRESENTATION_FLOAT);
+        isFloatingPoint = MA_TRUE;
+    }
+#endif
+    if (isFloatingPoint) {
+        if (pDataFormat->bitsPerSample == 32) {
+            *pFormat = ma_format_f32;
+        }
+    } else {
+        if (pDataFormat->bitsPerSample == 8) {
+            *pFormat = ma_format_u8;
+        } else if (pDataFormat->bitsPerSample == 16) {
+            *pFormat = ma_format_s16;
+        } else if (pDataFormat->bitsPerSample == 24) {
+            *pFormat = ma_format_s24;
+        } else if (pDataFormat->bitsPerSample == 32) {
+            *pFormat = ma_format_s32;
+        }
+    }
+
+    *pChannels   = pDataFormat->numChannels;
+    *pSampleRate = ((SLDataFormat_PCM*)pDataFormat)->samplesPerSec / 1000;
+    ma_channel_mask_to_channel_map__opensl(pDataFormat->channelMask, ma_min(pDataFormat->numChannels, channelMapCap), pChannelMap);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_init__opensl(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+#ifdef MA_ANDROID
+    SLDataLocator_AndroidSimpleBufferQueue queue;
+    SLresult resultSL;
+    size_t bufferSizeInBytes;
+    SLInterfaceID itfIDs[2];
+    const SLboolean itfIDsRequired[] = {
+        SL_BOOLEAN_TRUE,    /* SL_IID_ANDROIDSIMPLEBUFFERQUEUE */
+        SL_BOOLEAN_FALSE    /* SL_IID_ANDROIDCONFIGURATION */
+    };
+#endif
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it and then attempted to initialize a new device. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /*
+    For now, only supporting Android implementations of OpenSL|ES since that's the only one I've
+    been able to test with and I currently depend on Android-specific extensions (simple buffer
+    queues).
+    */
+#ifdef MA_ANDROID
+    itfIDs[0] = (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
+    itfIDs[1] = (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDCONFIGURATION;
+
+    /* No exclusive mode with OpenSL|ES. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    /* Now we can start initializing the device properly. */
+    MA_ASSERT(pDevice != NULL);
+    MA_ZERO_OBJECT(&pDevice->opensl);
+
+    queue.locatorType = SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE;
+
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        ma_SLDataFormat_PCM pcm;
+        SLDataLocator_IODevice locatorDevice;
+        SLDataSource source;
+        SLDataSink sink;
+        SLAndroidConfigurationItf pRecorderConfig;
+
+        ma_SLDataFormat_PCM_init__opensl(pDescriptorCapture->format, pDescriptorCapture->channels, pDescriptorCapture->sampleRate, pDescriptorCapture->channelMap, &pcm);
+
+        locatorDevice.locatorType = SL_DATALOCATOR_IODEVICE;
+        locatorDevice.deviceType  = SL_IODEVICE_AUDIOINPUT;
+        locatorDevice.deviceID    = SL_DEFAULTDEVICEID_AUDIOINPUT;  /* Must always use the default device with Android. */
+        locatorDevice.device      = NULL;
+
+        source.pLocator = &locatorDevice;
+        source.pFormat  = NULL;
+
+        queue.numBuffers = pDescriptorCapture->periodCount;
+
+        sink.pLocator = &queue;
+        sink.pFormat  = (SLDataFormat_PCM*)&pcm;
+
+        resultSL = (*g_maEngineSL)->CreateAudioRecorder(g_maEngineSL, (SLObjectItf*)&pDevice->opensl.pAudioRecorderObj, &source, &sink, ma_countof(itfIDs), itfIDs, itfIDsRequired);
+        if (resultSL == SL_RESULT_CONTENT_UNSUPPORTED || resultSL == SL_RESULT_PARAMETER_INVALID) {
+            /* Unsupported format. Fall back to something safer and try again. If this fails, just abort. */
+            pcm.formatType    = SL_DATAFORMAT_PCM;
+            pcm.numChannels   = 1;
+            ((SLDataFormat_PCM*)&pcm)->samplesPerSec = SL_SAMPLINGRATE_16;  /* The name of the sample rate variable is different between SLAndroidDataFormat_PCM_EX and SLDataFormat_PCM. */
+            pcm.bitsPerSample = 16;
+            pcm.containerSize = pcm.bitsPerSample;  /* Always tightly packed for now. */
+            pcm.channelMask   = 0;
+            resultSL = (*g_maEngineSL)->CreateAudioRecorder(g_maEngineSL, (SLObjectItf*)&pDevice->opensl.pAudioRecorderObj, &source, &sink, ma_countof(itfIDs), itfIDs, itfIDsRequired);
+        }
+
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to create audio recorder.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+
+        /* Set the recording preset before realizing the player. */
+        if (pConfig->opensl.recordingPreset != ma_opensl_recording_preset_default) {
+            resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioRecorderObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioRecorderObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDCONFIGURATION, &pRecorderConfig);
+            if (resultSL == SL_RESULT_SUCCESS) {
+                SLint32 recordingPreset = ma_to_recording_preset__opensl(pConfig->opensl.recordingPreset);
+                resultSL = (*pRecorderConfig)->SetConfiguration(pRecorderConfig, SL_ANDROID_KEY_RECORDING_PRESET, &recordingPreset, sizeof(SLint32));
+                if (resultSL != SL_RESULT_SUCCESS) {
+                    /* Failed to set the configuration. Just keep going. */
+                }
+            }
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioRecorderObj)->Realize((SLObjectItf)pDevice->opensl.pAudioRecorderObj, SL_BOOLEAN_FALSE);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to realize audio recorder.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioRecorderObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioRecorderObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_RECORD, &pDevice->opensl.pAudioRecorder);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to retrieve SL_IID_RECORD interface.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioRecorderObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioRecorderObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &pDevice->opensl.pBufferQueueCapture);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to retrieve SL_IID_ANDROIDSIMPLEBUFFERQUEUE interface.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueueCapture)->RegisterCallback((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueueCapture, ma_buffer_queue_callback_capture__opensl_android, pDevice);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to register buffer queue callback.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        /* The internal format is determined by the "pcm" object. */
+        ma_deconstruct_SLDataFormat_PCM__opensl(&pcm, &pDescriptorCapture->format, &pDescriptorCapture->channels, &pDescriptorCapture->sampleRate, pDescriptorCapture->channelMap, ma_countof(pDescriptorCapture->channelMap));
+
+        /* Buffer. */
+        pDescriptorCapture->periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptorCapture, pDescriptorCapture->sampleRate, pConfig->performanceProfile);
+        pDevice->opensl.currentBufferIndexCapture = 0;
+
+        bufferSizeInBytes = pDescriptorCapture->periodSizeInFrames * ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels) * pDescriptorCapture->periodCount;
+        pDevice->opensl.pBufferCapture = (ma_uint8*)ma_calloc(bufferSizeInBytes, &pDevice->pContext->allocationCallbacks);
+        if (pDevice->opensl.pBufferCapture == NULL) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to allocate memory for data buffer.");
+            return MA_OUT_OF_MEMORY;
+        }
+        MA_ZERO_MEMORY(pDevice->opensl.pBufferCapture, bufferSizeInBytes);
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        ma_SLDataFormat_PCM pcm;
+        SLDataSource source;
+        SLDataLocator_OutputMix outmixLocator;
+        SLDataSink sink;
+        SLAndroidConfigurationItf pPlayerConfig;
+
+        ma_SLDataFormat_PCM_init__opensl(pDescriptorPlayback->format, pDescriptorPlayback->channels, pDescriptorPlayback->sampleRate, pDescriptorPlayback->channelMap, &pcm);
+
+        resultSL = (*g_maEngineSL)->CreateOutputMix(g_maEngineSL, (SLObjectItf*)&pDevice->opensl.pOutputMixObj, 0, NULL, NULL);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to create output mix.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pOutputMixObj)->Realize((SLObjectItf)pDevice->opensl.pOutputMixObj, SL_BOOLEAN_FALSE);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to realize output mix object.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pOutputMixObj)->GetInterface((SLObjectItf)pDevice->opensl.pOutputMixObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_OUTPUTMIX, &pDevice->opensl.pOutputMix);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to retrieve SL_IID_OUTPUTMIX interface.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        /* Set the output device. */
+        if (pDescriptorPlayback->pDeviceID != NULL) {
+            SLuint32 deviceID_OpenSL = pDescriptorPlayback->pDeviceID->opensl;
+            MA_OPENSL_OUTPUTMIX(pDevice->opensl.pOutputMix)->ReRoute((SLOutputMixItf)pDevice->opensl.pOutputMix, 1, &deviceID_OpenSL);
+        }
+
+        queue.numBuffers = pDescriptorPlayback->periodCount;
+
+        source.pLocator = &queue;
+        source.pFormat  = (SLDataFormat_PCM*)&pcm;
+
+        outmixLocator.locatorType = SL_DATALOCATOR_OUTPUTMIX;
+        outmixLocator.outputMix   = (SLObjectItf)pDevice->opensl.pOutputMixObj;
+
+        sink.pLocator = &outmixLocator;
+        sink.pFormat  = NULL;
+
+        resultSL = (*g_maEngineSL)->CreateAudioPlayer(g_maEngineSL, (SLObjectItf*)&pDevice->opensl.pAudioPlayerObj, &source, &sink, ma_countof(itfIDs), itfIDs, itfIDsRequired);
+        if (resultSL == SL_RESULT_CONTENT_UNSUPPORTED || resultSL == SL_RESULT_PARAMETER_INVALID) {
+            /* Unsupported format. Fall back to something safer and try again. If this fails, just abort. */
+            pcm.formatType = SL_DATAFORMAT_PCM;
+            pcm.numChannels = 2;
+            ((SLDataFormat_PCM*)&pcm)->samplesPerSec = SL_SAMPLINGRATE_16;
+            pcm.bitsPerSample = 16;
+            pcm.containerSize = pcm.bitsPerSample;  /* Always tightly packed for now. */
+            pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
+            resultSL = (*g_maEngineSL)->CreateAudioPlayer(g_maEngineSL, (SLObjectItf*)&pDevice->opensl.pAudioPlayerObj, &source, &sink, ma_countof(itfIDs), itfIDs, itfIDsRequired);
+        }
+
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to create audio player.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+
+        /* Set the stream type before realizing the player. */
+        if (pConfig->opensl.streamType != ma_opensl_stream_type_default) {
+            resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioPlayerObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioPlayerObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDCONFIGURATION, &pPlayerConfig);
+            if (resultSL == SL_RESULT_SUCCESS) {
+                SLint32 streamType = ma_to_stream_type__opensl(pConfig->opensl.streamType);
+                resultSL = (*pPlayerConfig)->SetConfiguration(pPlayerConfig, SL_ANDROID_KEY_STREAM_TYPE, &streamType, sizeof(SLint32));
+                if (resultSL != SL_RESULT_SUCCESS) {
+                    /* Failed to set the configuration. Just keep going. */
+                }
+            }
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioPlayerObj)->Realize((SLObjectItf)pDevice->opensl.pAudioPlayerObj, SL_BOOLEAN_FALSE);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to realize audio player.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioPlayerObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioPlayerObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_PLAY, &pDevice->opensl.pAudioPlayer);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to retrieve SL_IID_PLAY interface.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_OBJ(pDevice->opensl.pAudioPlayerObj)->GetInterface((SLObjectItf)pDevice->opensl.pAudioPlayerObj, (SLInterfaceID)pDevice->pContext->opensl.SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &pDevice->opensl.pBufferQueuePlayback);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to retrieve SL_IID_ANDROIDSIMPLEBUFFERQUEUE interface.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueuePlayback)->RegisterCallback((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueuePlayback, ma_buffer_queue_callback_playback__opensl_android, pDevice);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to register buffer queue callback.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        /* The internal format is determined by the "pcm" object. */
+        ma_deconstruct_SLDataFormat_PCM__opensl(&pcm, &pDescriptorPlayback->format, &pDescriptorPlayback->channels, &pDescriptorPlayback->sampleRate, pDescriptorPlayback->channelMap, ma_countof(pDescriptorPlayback->channelMap));
+
+        /* Buffer. */
+        pDescriptorPlayback->periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptorPlayback, pDescriptorPlayback->sampleRate, pConfig->performanceProfile);
+        pDevice->opensl.currentBufferIndexPlayback   = 0;
+
+        bufferSizeInBytes = pDescriptorPlayback->periodSizeInFrames * ma_get_bytes_per_frame(pDescriptorPlayback->format, pDescriptorPlayback->channels) * pDescriptorPlayback->periodCount;
+        pDevice->opensl.pBufferPlayback = (ma_uint8*)ma_calloc(bufferSizeInBytes, &pDevice->pContext->allocationCallbacks);
+        if (pDevice->opensl.pBufferPlayback == NULL) {
+            ma_device_uninit__opensl(pDevice);
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to allocate memory for data buffer.");
+            return MA_OUT_OF_MEMORY;
+        }
+        MA_ZERO_MEMORY(pDevice->opensl.pBufferPlayback, bufferSizeInBytes);
+    }
+
+    return MA_SUCCESS;
+#else
+    return MA_NO_BACKEND;   /* Non-Android implementations are not supported. */
+#endif
+}
+
+static ma_result ma_device_start__opensl(ma_device* pDevice)
+{
+    SLresult resultSL;
+    size_t periodSizeInBytes;
+    ma_uint32 iPeriod;
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it and then attempted to start the device. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        resultSL = MA_OPENSL_RECORD(pDevice->opensl.pAudioRecorder)->SetRecordState((SLRecordItf)pDevice->opensl.pAudioRecorder, SL_RECORDSTATE_RECORDING);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to start internal capture device.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        periodSizeInBytes = pDevice->capture.internalPeriodSizeInFrames * ma_get_bytes_per_frame(pDevice->capture.internalFormat, pDevice->capture.internalChannels);
+        for (iPeriod = 0; iPeriod < pDevice->capture.internalPeriods; ++iPeriod) {
+            resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueueCapture)->Enqueue((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueueCapture, pDevice->opensl.pBufferCapture + (periodSizeInBytes * iPeriod), periodSizeInBytes);
+            if (resultSL != SL_RESULT_SUCCESS) {
+                MA_OPENSL_RECORD(pDevice->opensl.pAudioRecorder)->SetRecordState((SLRecordItf)pDevice->opensl.pAudioRecorder, SL_RECORDSTATE_STOPPED);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to enqueue buffer for capture device.");
+                return ma_result_from_OpenSL(resultSL);
+            }
+        }
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        resultSL = MA_OPENSL_PLAY(pDevice->opensl.pAudioPlayer)->SetPlayState((SLPlayItf)pDevice->opensl.pAudioPlayer, SL_PLAYSTATE_PLAYING);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to start internal playback device.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        /* In playback mode (no duplex) we need to load some initial buffers. In duplex mode we need to enqueue silent buffers. */
+        if (pDevice->type == ma_device_type_duplex) {
+            MA_ZERO_MEMORY(pDevice->opensl.pBufferPlayback, pDevice->playback.internalPeriodSizeInFrames * pDevice->playback.internalPeriods * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels));
+        } else {
+            ma_device__read_frames_from_client(pDevice, pDevice->playback.internalPeriodSizeInFrames * pDevice->playback.internalPeriods, pDevice->opensl.pBufferPlayback);
+        }
+
+        periodSizeInBytes = pDevice->playback.internalPeriodSizeInFrames * ma_get_bytes_per_frame(pDevice->playback.internalFormat, pDevice->playback.internalChannels);
+        for (iPeriod = 0; iPeriod < pDevice->playback.internalPeriods; ++iPeriod) {
+            resultSL = MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueuePlayback)->Enqueue((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueuePlayback, pDevice->opensl.pBufferPlayback + (periodSizeInBytes * iPeriod), periodSizeInBytes);
+            if (resultSL != SL_RESULT_SUCCESS) {
+                MA_OPENSL_PLAY(pDevice->opensl.pAudioPlayer)->SetPlayState((SLPlayItf)pDevice->opensl.pAudioPlayer, SL_PLAYSTATE_STOPPED);
+                ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to enqueue buffer for playback device.");
+                return ma_result_from_OpenSL(resultSL);
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_drain__opensl(ma_device* pDevice, ma_device_type deviceType)
+{
+    SLAndroidSimpleBufferQueueItf pBufferQueue;
+
+    MA_ASSERT(deviceType == ma_device_type_capture || deviceType == ma_device_type_playback);
+
+    if (pDevice->type == ma_device_type_capture) {
+        pBufferQueue = (SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueueCapture;
+        pDevice->opensl.isDrainingCapture  = MA_TRUE;
+    } else {
+        pBufferQueue = (SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueuePlayback;
+        pDevice->opensl.isDrainingPlayback = MA_TRUE;
+    }
+
+    for (;;) {
+        SLAndroidSimpleBufferQueueState state;
+
+        MA_OPENSL_BUFFERQUEUE(pBufferQueue)->GetState(pBufferQueue, &state);
+        if (state.count == 0) {
+            break;
+        }
+
+        ma_sleep(10);
+    }
+
+    if (pDevice->type == ma_device_type_capture) {
+        pDevice->opensl.isDrainingCapture  = MA_FALSE;
+    } else {
+        pDevice->opensl.isDrainingPlayback = MA_FALSE;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__opensl(ma_device* pDevice)
+{
+    SLresult resultSL;
+
+    MA_ASSERT(pDevice != NULL);
+
+    MA_ASSERT(g_maOpenSLInitCounter > 0); /* <-- If you trigger this it means you've either not initialized the context, or you've uninitialized it before stopping/uninitializing the device. */
+    if (g_maOpenSLInitCounter == 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex) {
+        ma_device_drain__opensl(pDevice, ma_device_type_capture);
+
+        resultSL = MA_OPENSL_RECORD(pDevice->opensl.pAudioRecorder)->SetRecordState((SLRecordItf)pDevice->opensl.pAudioRecorder, SL_RECORDSTATE_STOPPED);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to stop internal capture device.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueueCapture)->Clear((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueueCapture);
+    }
+
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_device_drain__opensl(pDevice, ma_device_type_playback);
+
+        resultSL = MA_OPENSL_PLAY(pDevice->opensl.pAudioPlayer)->SetPlayState((SLPlayItf)pDevice->opensl.pAudioPlayer, SL_PLAYSTATE_STOPPED);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            ma_log_post(ma_device_get_log(pDevice), MA_LOG_LEVEL_ERROR, "[OpenSL] Failed to stop internal playback device.");
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        MA_OPENSL_BUFFERQUEUE(pDevice->opensl.pBufferQueuePlayback)->Clear((SLAndroidSimpleBufferQueueItf)pDevice->opensl.pBufferQueuePlayback);
+    }
+
+    /* Make sure the client is aware that the device has stopped. There may be an OpenSL|ES callback for this, but I haven't found it. */
+    ma_device__on_notification_stopped(pDevice);
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_context_uninit__opensl(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_opensl);
+    (void)pContext;
+
+    /* Uninit global data. */
+    ma_spinlock_lock(&g_maOpenSLSpinlock);
+    {
+        MA_ASSERT(g_maOpenSLInitCounter > 0);   /* If you've triggered this, it means you have ma_context_init/uninit mismatch. Each successful call to ma_context_init() must be matched up with a call to ma_context_uninit(). */
+
+        g_maOpenSLInitCounter -= 1;
+        if (g_maOpenSLInitCounter == 0) {
+            (*g_maEngineObjectSL)->Destroy(g_maEngineObjectSL);
+        }
+    }
+    ma_spinlock_unlock(&g_maOpenSLSpinlock);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_dlsym_SLInterfaceID__opensl(ma_context* pContext, const char* pName, ma_handle* pHandle)
+{
+    /* We need to return an error if the symbol cannot be found. This is important because there have been reports that some symbols do not exist. */
+    ma_handle* p = (ma_handle*)ma_dlsym(ma_context_get_log(pContext), pContext->opensl.libOpenSLES, pName);
+    if (p == NULL) {
+        ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_INFO, "[OpenSL] Cannot find symbol %s", pName);
+        return MA_NO_BACKEND;
+    }
+
+    *pHandle = *p;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init_engine_nolock__opensl(ma_context* pContext)
+{
+    g_maOpenSLInitCounter += 1;
+    if (g_maOpenSLInitCounter == 1) {
+        SLresult resultSL;
+
+        resultSL = ((ma_slCreateEngine_proc)pContext->opensl.slCreateEngine)(&g_maEngineObjectSL, 0, NULL, 0, NULL, NULL);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            g_maOpenSLInitCounter -= 1;
+            return ma_result_from_OpenSL(resultSL);
+        }
+
+        (*g_maEngineObjectSL)->Realize(g_maEngineObjectSL, SL_BOOLEAN_FALSE);
+
+        resultSL = (*g_maEngineObjectSL)->GetInterface(g_maEngineObjectSL, (SLInterfaceID)pContext->opensl.SL_IID_ENGINE, &g_maEngineSL);
+        if (resultSL != SL_RESULT_SUCCESS) {
+            (*g_maEngineObjectSL)->Destroy(g_maEngineObjectSL);
+            g_maOpenSLInitCounter -= 1;
+            return ma_result_from_OpenSL(resultSL);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__opensl(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    ma_result result;
+
+#if !defined(MA_NO_RUNTIME_LINKING)
+    size_t i;
+    const char* libOpenSLESNames[] = {
+        "libOpenSLES.so"
+    };
+#endif
+
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig;
+
+#if !defined(MA_NO_RUNTIME_LINKING)
+    /*
+    Dynamically link against libOpenSLES.so. I have now had multiple reports that SL_IID_ANDROIDSIMPLEBUFFERQUEUE cannot be found. One
+    report was happening at compile time and another at runtime. To try working around this, I'm going to link to libOpenSLES at runtime
+    and extract the symbols rather than reference them directly. This should, hopefully, fix these issues as the compiler won't see any
+    references to the symbols and will hopefully skip the checks.
+    */
+    for (i = 0; i < ma_countof(libOpenSLESNames); i += 1) {
+        pContext->opensl.libOpenSLES = ma_dlopen(ma_context_get_log(pContext), libOpenSLESNames[i]);
+        if (pContext->opensl.libOpenSLES != NULL) {
+            break;
+        }
+    }
+
+    if (pContext->opensl.libOpenSLES == NULL) {
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_INFO, "[OpenSL] Could not find libOpenSLES.so");
+        return MA_NO_BACKEND;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_ENGINE", &pContext->opensl.SL_IID_ENGINE);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_AUDIOIODEVICECAPABILITIES", &pContext->opensl.SL_IID_AUDIOIODEVICECAPABILITIES);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_ANDROIDSIMPLEBUFFERQUEUE", &pContext->opensl.SL_IID_ANDROIDSIMPLEBUFFERQUEUE);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_RECORD", &pContext->opensl.SL_IID_RECORD);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_PLAY", &pContext->opensl.SL_IID_PLAY);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_OUTPUTMIX", &pContext->opensl.SL_IID_OUTPUTMIX);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    result = ma_dlsym_SLInterfaceID__opensl(pContext, "SL_IID_ANDROIDCONFIGURATION", &pContext->opensl.SL_IID_ANDROIDCONFIGURATION);
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        return result;
+    }
+
+    pContext->opensl.slCreateEngine = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->opensl.libOpenSLES, "slCreateEngine");
+    if (pContext->opensl.slCreateEngine == NULL) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_INFO, "[OpenSL] Cannot find symbol slCreateEngine.");
+        return MA_NO_BACKEND;
+    }
+#else
+    pContext->opensl.SL_IID_ENGINE                    = (ma_handle)SL_IID_ENGINE;
+    pContext->opensl.SL_IID_AUDIOIODEVICECAPABILITIES = (ma_handle)SL_IID_AUDIOIODEVICECAPABILITIES;
+    pContext->opensl.SL_IID_ANDROIDSIMPLEBUFFERQUEUE  = (ma_handle)SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
+    pContext->opensl.SL_IID_RECORD                    = (ma_handle)SL_IID_RECORD;
+    pContext->opensl.SL_IID_PLAY                      = (ma_handle)SL_IID_PLAY;
+    pContext->opensl.SL_IID_OUTPUTMIX                 = (ma_handle)SL_IID_OUTPUTMIX;
+    pContext->opensl.SL_IID_ANDROIDCONFIGURATION      = (ma_handle)SL_IID_ANDROIDCONFIGURATION;
+    pContext->opensl.slCreateEngine                   = (ma_proc)slCreateEngine;
+#endif
+
+
+    /* Initialize global data first if applicable. */
+    ma_spinlock_lock(&g_maOpenSLSpinlock);
+    {
+        result = ma_context_init_engine_nolock__opensl(pContext);
+    }
+    ma_spinlock_unlock(&g_maOpenSLSpinlock);
+
+    if (result != MA_SUCCESS) {
+        ma_dlclose(ma_context_get_log(pContext), pContext->opensl.libOpenSLES);
+        ma_log_post(ma_context_get_log(pContext), MA_LOG_LEVEL_INFO, "[OpenSL] Failed to initialize OpenSL engine.");
+        return result;
+    }
+
+    pCallbacks->onContextInit             = ma_context_init__opensl;
+    pCallbacks->onContextUninit           = ma_context_uninit__opensl;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__opensl;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__opensl;
+    pCallbacks->onDeviceInit              = ma_device_init__opensl;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__opensl;
+    pCallbacks->onDeviceStart             = ma_device_start__opensl;
+    pCallbacks->onDeviceStop              = ma_device_stop__opensl;
+    pCallbacks->onDeviceRead              = NULL;   /* Not needed because OpenSL|ES is asynchronous. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not needed because OpenSL|ES is asynchronous. */
+    pCallbacks->onDeviceDataLoop          = NULL;   /* Not needed because OpenSL|ES is asynchronous. */
+
+    return MA_SUCCESS;
+}
+#endif  /* OpenSL|ES */
+
+
+/******************************************************************************
+
+Web Audio Backend
+
+******************************************************************************/
+#ifdef MA_HAS_WEBAUDIO
+#include <emscripten/emscripten.h>
+
+#if (__EMSCRIPTEN_major__ > 3) || (__EMSCRIPTEN_major__ == 3 && (__EMSCRIPTEN_minor__ > 1 || (__EMSCRIPTEN_minor__ == 1 && __EMSCRIPTEN_tiny__ >= 32)))
+    #include <emscripten/webaudio.h>
+    #define MA_SUPPORT_AUDIO_WORKLETS
+#endif
+
+/*
+TODO: Version 0.12: Swap this logic around so that AudioWorklets are used by default. Add MA_NO_AUDIO_WORKLETS.
+*/
+#if defined(MA_ENABLE_AUDIO_WORKLETS) && defined(MA_SUPPORT_AUDIO_WORKLETS)
+    #define MA_USE_AUDIO_WORKLETS
+#endif
+
+/* The thread stack size must be a multiple of 16. */
+#ifndef MA_AUDIO_WORKLETS_THREAD_STACK_SIZE
+#define MA_AUDIO_WORKLETS_THREAD_STACK_SIZE 16384
+#endif
+
+#if defined(MA_USE_AUDIO_WORKLETS)
+#define MA_WEBAUDIO_LATENCY_HINT_BALANCED       "balanced"
+#define MA_WEBAUDIO_LATENCY_HINT_INTERACTIVE    "interactive"
+#define MA_WEBAUDIO_LATENCY_HINT_PLAYBACK       "playback"
+#endif
+
+static ma_bool32 ma_is_capture_supported__webaudio()
+{
+    return EM_ASM_INT({
+        return (navigator.mediaDevices !== undefined && navigator.mediaDevices.getUserMedia !== undefined);
+    }, 0) != 0; /* Must pass in a dummy argument for C99 compatibility. */
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+void* EMSCRIPTEN_KEEPALIVE ma_malloc_emscripten(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_malloc(sz, pAllocationCallbacks);
+}
+
+void EMSCRIPTEN_KEEPALIVE ma_free_emscripten(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_free(p, pAllocationCallbacks);
+}
+
+void EMSCRIPTEN_KEEPALIVE ma_device_process_pcm_frames_capture__webaudio(ma_device* pDevice, int frameCount, float* pFrames)
+{
+    ma_device_handle_backend_data_callback(pDevice, NULL, pFrames, (ma_uint32)frameCount);
+}
+
+void EMSCRIPTEN_KEEPALIVE ma_device_process_pcm_frames_playback__webaudio(ma_device* pDevice, int frameCount, float* pFrames)
+{
+    ma_device_handle_backend_data_callback(pDevice, pFrames, NULL, (ma_uint32)frameCount);
+}
+#ifdef __cplusplus
+}
+#endif
+
+static ma_result ma_context_enumerate_devices__webaudio(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_bool32 cbResult = MA_TRUE;
+
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(callback != NULL);
+
+    /* Only supporting default devices for now. */
+
+    /* Playback. */
+    if (cbResult) {
+        ma_device_info deviceInfo;
+        MA_ZERO_OBJECT(&deviceInfo);
+        ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+        deviceInfo.isDefault = MA_TRUE;    /* Only supporting default devices. */
+        cbResult = callback(pContext, ma_device_type_playback, &deviceInfo, pUserData);
+    }
+
+    /* Capture. */
+    if (cbResult) {
+        if (ma_is_capture_supported__webaudio()) {
+            ma_device_info deviceInfo;
+            MA_ZERO_OBJECT(&deviceInfo);
+            ma_strncpy_s(deviceInfo.name, sizeof(deviceInfo.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+            deviceInfo.isDefault = MA_TRUE;    /* Only supporting default devices. */
+            cbResult = callback(pContext, ma_device_type_capture, &deviceInfo, pUserData);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_get_device_info__webaudio(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    MA_ASSERT(pContext != NULL);
+
+    if (deviceType == ma_device_type_capture && !ma_is_capture_supported__webaudio()) {
+        return MA_NO_DEVICE;
+    }
+
+    MA_ZERO_MEMORY(pDeviceInfo->id.webaudio, sizeof(pDeviceInfo->id.webaudio));
+
+    /* Only supporting default devices for now. */
+    (void)pDeviceID;
+    if (deviceType == ma_device_type_playback) {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+    } else {
+        ma_strncpy_s(pDeviceInfo->name, sizeof(pDeviceInfo->name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+    }
+
+    /* Only supporting default devices. */
+    pDeviceInfo->isDefault = MA_TRUE;
+
+    /* Web Audio can support any number of channels and sample rates. It only supports f32 formats, however. */
+    pDeviceInfo->nativeDataFormats[0].flags      = 0;
+    pDeviceInfo->nativeDataFormats[0].format     = ma_format_unknown;
+    pDeviceInfo->nativeDataFormats[0].channels   = 0; /* All channels are supported. */
+    pDeviceInfo->nativeDataFormats[0].sampleRate = EM_ASM_INT({
+        try {
+            var temp = new (window.AudioContext || window.webkitAudioContext)();
+            var sampleRate = temp.sampleRate;
+            temp.close();
+            return sampleRate;
+        } catch(e) {
+            return 0;
+        }
+    }, 0);  /* Must pass in a dummy argument for C99 compatibility. */
+
+    if (pDeviceInfo->nativeDataFormats[0].sampleRate == 0) {
+        return MA_NO_DEVICE;
+    }
+
+    pDeviceInfo->nativeDataFormatCount = 1;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_uninit__webaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    #if defined(MA_USE_AUDIO_WORKLETS)
+    {
+        EM_ASM({
+            var device = miniaudio.get_device_by_index($0);
+
+            if (device.streamNode !== undefined) {
+                device.streamNode.disconnect();
+                device.streamNode = undefined;
+            }
+        }, pDevice->webaudio.deviceIndex);
+
+        emscripten_destroy_web_audio_node(pDevice->webaudio.audioWorklet);
+        emscripten_destroy_audio_context(pDevice->webaudio.audioContext);
+        ma_free(pDevice->webaudio.pStackBuffer, &pDevice->pContext->allocationCallbacks);
+    }
+    #else
+    {
+        EM_ASM({
+            var device = miniaudio.get_device_by_index($0);
+
+            /* Make sure all nodes are disconnected and marked for collection. */
+            if (device.scriptNode !== undefined) {
+                device.scriptNode.onaudioprocess = function(e) {};  /* We want to reset the callback to ensure it doesn't get called after AudioContext.close() has returned. Shouldn't happen since we're disconnecting, but just to be safe... */
+                device.scriptNode.disconnect();
+                device.scriptNode = undefined;
+            }
+
+            if (device.streamNode !== undefined) {
+                device.streamNode.disconnect();
+                device.streamNode = undefined;
+            }
+
+            /*
+            Stop the device. I think there is a chance the callback could get fired after calling this, hence why we want
+            to clear the callback before closing.
+            */
+            device.webaudio.close();
+            device.webaudio = undefined;
+            device.pDevice = undefined;
+        }, pDevice->webaudio.deviceIndex);
+    }
+    #endif
+
+    /* Clean up the device on the JS side. */
+    EM_ASM({
+        miniaudio.untrack_device_by_index($0);
+    }, pDevice->webaudio.deviceIndex);
+
+    ma_free(pDevice->webaudio.pIntermediaryBuffer, &pDevice->pContext->allocationCallbacks);
+
+    return MA_SUCCESS;
+}
+
+#if !defined(MA_USE_AUDIO_WORKLETS)
+static ma_uint32 ma_calculate_period_size_in_frames_from_descriptor__webaudio(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+    /*
+    There have been reports of the default buffer size being too small on some browsers. If we're using
+    the default buffer size, we'll make sure the period size is bigger than our standard defaults.
+    */
+    ma_uint32 periodSizeInFrames;
+
+    if (nativeSampleRate == 0) {
+        nativeSampleRate = MA_DEFAULT_SAMPLE_RATE;
+    }
+
+    if (pDescriptor->periodSizeInFrames == 0) {
+        if (pDescriptor->periodSizeInMilliseconds == 0) {
+            if (performanceProfile == ma_performance_profile_low_latency) {
+                periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(33, nativeSampleRate);  /* 1 frame @ 30 FPS */
+            } else {
+                periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(333, nativeSampleRate);
+            }
+        } else {
+            periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptor->periodSizeInMilliseconds, nativeSampleRate);
+        }
+    } else {
+        periodSizeInFrames = pDescriptor->periodSizeInFrames;
+    }
+
+    /* The size of the buffer must be a power of 2 and between 256 and 16384. */
+    if (periodSizeInFrames < 256) {
+        periodSizeInFrames = 256;
+    } else if (periodSizeInFrames > 16384) {
+        periodSizeInFrames = 16384;
+    } else {
+        periodSizeInFrames = ma_next_power_of_2(periodSizeInFrames);
+    }
+
+    return periodSizeInFrames;
+}
+#endif
+
+
+#if defined(MA_USE_AUDIO_WORKLETS)
+typedef struct
+{
+    ma_device* pDevice;
+    const ma_device_config* pConfig;
+    ma_device_descriptor* pDescriptorPlayback;
+    ma_device_descriptor* pDescriptorCapture;
+} ma_audio_worklet_thread_initialized_data;
+
+static EM_BOOL ma_audio_worklet_process_callback__webaudio(int inputCount, const AudioSampleFrame* pInputs, int outputCount, AudioSampleFrame* pOutputs, int paramCount, const AudioParamFrame* pParams, void* pUserData)
+{
+    ma_device* pDevice = (ma_device*)pUserData;
+    ma_uint32 frameCount;
+
+    (void)paramCount;
+    (void)pParams;
+
+    if (ma_device_get_state(pDevice) != ma_device_state_started) {
+        return EM_TRUE;
+    }
+
+    /*
+    The Emscripten documentation says that it'll always be 128 frames being passed in. Hard coding it like that feels
+    like a very bad idea to me. Even if it's hard coded in the backend, the API and documentation should always refer
+    to variables instead of a hard coded number. In any case, will follow along for the time being.
+
+    Unfortunately the audio data is not interleaved so we'll need to convert it before we give the data to miniaudio
+    for further processing.
+    */
+    frameCount = 128;
+
+    if (inputCount > 0) {
+        /* Input data needs to be interleaved before we hand it to the client. */
+        for (ma_uint32 iChannel = 0; iChannel < pDevice->capture.internalChannels; iChannel += 1) {
+            for (ma_uint32 iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                pDevice->webaudio.pIntermediaryBuffer[iFrame*pDevice->capture.internalChannels + iChannel] = pInputs[0].data[frameCount*iChannel + iFrame];
+            }
+        }
+
+        ma_device_process_pcm_frames_capture__webaudio(pDevice, frameCount, pDevice->webaudio.pIntermediaryBuffer);
+    }
+
+    if (outputCount > 0) {
+        /* If it's a capture-only device, we'll need to output silence. */
+        if (pDevice->type == ma_device_type_capture) {
+            MA_ZERO_MEMORY(pOutputs[0].data, frameCount * pDevice->playback.internalChannels * sizeof(float));
+        } else {
+            ma_device_process_pcm_frames_playback__webaudio(pDevice, frameCount, pDevice->webaudio.pIntermediaryBuffer);
+
+            /* We've read the data from the client. Now we need to deinterleave the buffer and output to the output buffer. */
+            for (ma_uint32 iChannel = 0; iChannel < pDevice->playback.internalChannels; iChannel += 1) {
+                for (ma_uint32 iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                    pOutputs[0].data[frameCount*iChannel + iFrame] = pDevice->webaudio.pIntermediaryBuffer[iFrame*pDevice->playback.internalChannels + iChannel];
+                }
+            }
+        }
+    }
+
+    return EM_TRUE;
+}
+
+
+static void ma_audio_worklet_processor_created__webaudio(EMSCRIPTEN_WEBAUDIO_T audioContext, EM_BOOL success, void* pUserData)
+{
+    ma_audio_worklet_thread_initialized_data* pParameters = (ma_audio_worklet_thread_initialized_data*)pUserData;
+    EmscriptenAudioWorkletNodeCreateOptions audioWorkletOptions;
+    int channels = 0;
+    size_t intermediaryBufferSizeInFrames;
+    int sampleRate;
+
+    if (success == EM_FALSE) {
+        pParameters->pDevice->webaudio.initResult = MA_ERROR;
+        ma_free(pParameters, &pParameters->pDevice->pContext->allocationCallbacks);
+        return;
+    }
+
+    /* The next step is to initialize the audio worklet node. */
+    MA_ZERO_OBJECT(&audioWorkletOptions);
+
+    /*
+    The way channel counts work with Web Audio is confusing. As far as I can tell, there's no way to know the channel
+    count from MediaStreamAudioSourceNode (what we use for capture)? The only way to have control is to configure an
+    output channel count on the capture side. This is slightly confusing for capture mode because intuitively you
+    wouldn't actually connect an output to an input-only node, but this is what we'll have to do in order to have
+    proper control over the channel count. In the capture case, we'll have to output silence to it's output node.
+    */
+    if (pParameters->pConfig->deviceType == ma_device_type_capture) {
+        channels = (int)((pParameters->pDescriptorCapture->channels > 0) ? pParameters->pDescriptorCapture->channels : MA_DEFAULT_CHANNELS);
+        audioWorkletOptions.numberOfInputs = 1;
+    } else {
+        channels = (int)((pParameters->pDescriptorPlayback->channels > 0) ? pParameters->pDescriptorPlayback->channels : MA_DEFAULT_CHANNELS);
+
+        if (pParameters->pConfig->deviceType == ma_device_type_duplex) {
+            audioWorkletOptions.numberOfInputs = 1;
+        } else {
+            audioWorkletOptions.numberOfInputs = 0;
+        }
+    }
+
+    audioWorkletOptions.numberOfOutputs = 1;
+    audioWorkletOptions.outputChannelCounts = &channels;
+
+
+    /*
+    Now that we know the channel count to use we can allocate the intermediary buffer. The
+    intermediary buffer is used for interleaving and deinterleaving.
+    */
+    intermediaryBufferSizeInFrames = 128;
+
+    pParameters->pDevice->webaudio.pIntermediaryBuffer = (float*)ma_malloc(intermediaryBufferSizeInFrames * (ma_uint32)channels * sizeof(float), &pParameters->pDevice->pContext->allocationCallbacks);
+    if (pParameters->pDevice->webaudio.pIntermediaryBuffer == NULL) {
+        pParameters->pDevice->webaudio.initResult = MA_OUT_OF_MEMORY;
+        ma_free(pParameters, &pParameters->pDevice->pContext->allocationCallbacks);
+        return;
+    }
+
+
+    pParameters->pDevice->webaudio.audioWorklet = emscripten_create_wasm_audio_worklet_node(audioContext, "miniaudio", &audioWorkletOptions, &ma_audio_worklet_process_callback__webaudio, pParameters->pDevice);
+
+    /* With the audio worklet initialized we can now attach it to the graph. */
+    if (pParameters->pConfig->deviceType == ma_device_type_capture || pParameters->pConfig->deviceType == ma_device_type_duplex) {
+        ma_result attachmentResult = (ma_result)EM_ASM_INT({
+            var getUserMediaResult = 0;
+            var audioWorklet = emscriptenGetAudioObject($0);
+            var audioContext = emscriptenGetAudioObject($1);
+
+            navigator.mediaDevices.getUserMedia({audio:true, video:false})
+                .then(function(stream) {
+                    audioContext.streamNode = audioContext.createMediaStreamSource(stream);
+                    audioContext.streamNode.connect(audioWorklet);
+                    audioWorklet.connect(audioContext.destination);
+                    getUserMediaResult = 0;   /* 0 = MA_SUCCESS */
+                })
+                .catch(function(error) {
+                    console.log("navigator.mediaDevices.getUserMedia Failed: " + error);
+                    getUserMediaResult = -1;  /* -1 = MA_ERROR */
+                });
+
+            return getUserMediaResult;
+        }, pParameters->pDevice->webaudio.audioWorklet, audioContext);
+
+        if (attachmentResult != MA_SUCCESS) {
+            ma_log_postf(ma_device_get_log(pParameters->pDevice), MA_LOG_LEVEL_ERROR, "Web Audio: Failed to connect capture node.");
+            emscripten_destroy_web_audio_node(pParameters->pDevice->webaudio.audioWorklet);
+            pParameters->pDevice->webaudio.initResult = attachmentResult;
+            ma_free(pParameters, &pParameters->pDevice->pContext->allocationCallbacks);
+            return;
+        }
+    }
+
+    /* If it's playback only we can now attach the worklet node to the graph. This has already been done for the duplex case. */
+    if (pParameters->pConfig->deviceType == ma_device_type_playback) {
+        ma_result attachmentResult = (ma_result)EM_ASM_INT({
+            var audioWorklet = emscriptenGetAudioObject($0);
+            var audioContext = emscriptenGetAudioObject($1);
+            audioWorklet.connect(audioContext.destination);
+            return 0;   /* 0 = MA_SUCCESS */
+        }, pParameters->pDevice->webaudio.audioWorklet, audioContext);
+
+        if (attachmentResult != MA_SUCCESS) {
+            ma_log_postf(ma_device_get_log(pParameters->pDevice), MA_LOG_LEVEL_ERROR, "Web Audio: Failed to connect playback node.");
+            pParameters->pDevice->webaudio.initResult = attachmentResult;
+            ma_free(pParameters, &pParameters->pDevice->pContext->allocationCallbacks);
+            return;
+        }
+    }
+
+    /* We need to update the descriptors so that they reflect the internal data format. Both capture and playback should be the same. */
+    sampleRate = EM_ASM_INT({ return emscriptenGetAudioObject($0).sampleRate; }, audioContext);
+
+    if (pParameters->pDescriptorCapture != NULL) {
+        pParameters->pDescriptorCapture->format              = ma_format_f32;
+        pParameters->pDescriptorCapture->channels            = (ma_uint32)channels;
+        pParameters->pDescriptorCapture->sampleRate          = (ma_uint32)sampleRate;
+        ma_channel_map_init_standard(ma_standard_channel_map_webaudio, pParameters->pDescriptorCapture->channelMap, ma_countof(pParameters->pDescriptorCapture->channelMap), pParameters->pDescriptorCapture->channels);
+        pParameters->pDescriptorCapture->periodSizeInFrames  = intermediaryBufferSizeInFrames;
+        pParameters->pDescriptorCapture->periodCount         = 1;
+    }
+
+    if (pParameters->pDescriptorPlayback != NULL) {
+        pParameters->pDescriptorPlayback->format             = ma_format_f32;
+        pParameters->pDescriptorPlayback->channels           = (ma_uint32)channels;
+        pParameters->pDescriptorPlayback->sampleRate         = (ma_uint32)sampleRate;
+        ma_channel_map_init_standard(ma_standard_channel_map_webaudio, pParameters->pDescriptorPlayback->channelMap, ma_countof(pParameters->pDescriptorPlayback->channelMap), pParameters->pDescriptorPlayback->channels);
+        pParameters->pDescriptorPlayback->periodSizeInFrames = intermediaryBufferSizeInFrames;
+        pParameters->pDescriptorPlayback->periodCount        = 1;
+    }
+
+    /* At this point we're done and we can return. */
+    ma_log_postf(ma_device_get_log(pParameters->pDevice), MA_LOG_LEVEL_DEBUG, "AudioWorklets: Created worklet node: %d\n", pParameters->pDevice->webaudio.audioWorklet);
+    pParameters->pDevice->webaudio.initResult = MA_SUCCESS;
+    ma_free(pParameters, &pParameters->pDevice->pContext->allocationCallbacks);
+}
+
+static void ma_audio_worklet_thread_initialized__webaudio(EMSCRIPTEN_WEBAUDIO_T audioContext, EM_BOOL success, void* pUserData)
+{
+    ma_audio_worklet_thread_initialized_data* pParameters = (ma_audio_worklet_thread_initialized_data*)pUserData;
+    WebAudioWorkletProcessorCreateOptions workletProcessorOptions;
+
+    MA_ASSERT(pParameters != NULL);
+
+    if (success == EM_FALSE) {
+        pParameters->pDevice->webaudio.initResult = MA_ERROR;
+        return;
+    }
+
+    MA_ZERO_OBJECT(&workletProcessorOptions);
+    workletProcessorOptions.name = "miniaudio"; /* I'm not entirely sure what to call this. Does this need to be globally unique, or does it need only be unique for a given AudioContext? */
+
+    emscripten_create_wasm_audio_worklet_processor_async(audioContext, &workletProcessorOptions, ma_audio_worklet_processor_created__webaudio, pParameters);
+}
+#endif
+
+static ma_result ma_device_init__webaudio(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
+{
+    if (pConfig->deviceType == ma_device_type_loopback) {
+        return MA_DEVICE_TYPE_NOT_SUPPORTED;
+    }
+
+    /* No exclusive mode with Web Audio. */
+    if (((pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) && pDescriptorPlayback->shareMode == ma_share_mode_exclusive) ||
+        ((pConfig->deviceType == ma_device_type_capture  || pConfig->deviceType == ma_device_type_duplex) && pDescriptorCapture->shareMode  == ma_share_mode_exclusive)) {
+        return MA_SHARE_MODE_NOT_SUPPORTED;
+    }
+
+    /*
+    With AudioWorklets we'll have just a single AudioContext. I'm not sure why I'm not doing this for ScriptProcessorNode so
+    it might be worthwhile to look into that as well.
+    */
+    #if defined(MA_USE_AUDIO_WORKLETS)
+    {
+        EmscriptenWebAudioCreateAttributes audioContextAttributes;
+        ma_audio_worklet_thread_initialized_data* pInitParameters;
+        void* pStackBuffer;
+
+        if (pConfig->performanceProfile == ma_performance_profile_conservative) {
+            audioContextAttributes.latencyHint = MA_WEBAUDIO_LATENCY_HINT_PLAYBACK;
+        } else {
+            audioContextAttributes.latencyHint = MA_WEBAUDIO_LATENCY_HINT_INTERACTIVE;
+        }
+
+        /*
+        In my testing, Firefox does not seem to capture audio data properly if the sample rate is set
+        to anything other than 48K. This does not seem to be the case for other browsers. For this reason,
+        if the device type is anything other than playback, we'll leave the sample rate as-is and let the
+        browser pick the appropriate rate for us.
+        */
+        if (pConfig->deviceType == ma_device_type_playback) {
+            audioContextAttributes.sampleRate = pDescriptorPlayback->sampleRate;
+        } else {
+            audioContextAttributes.sampleRate = 0;
+        }
+
+        /* It's not clear if this can return an error. None of the tests in the Emscripten repository check for this, so neither am I for now. */
+        pDevice->webaudio.audioContext = emscripten_create_audio_context(&audioContextAttributes);
+
+
+        /*
+        With the context created we can now create the worklet. We can only have a single worklet per audio
+        context which means we'll need to craft this appropriately to handle duplex devices correctly.
+        */
+
+        /*
+        We now need to create a worker thread. This is a bit weird because we need to allocate our
+        own buffer for the thread's stack. The stack needs to be aligned to 16 bytes. I'm going to
+        allocate this on the heap to keep it simple.
+        */
+        pStackBuffer = ma_aligned_malloc(MA_AUDIO_WORKLETS_THREAD_STACK_SIZE, 16, &pDevice->pContext->allocationCallbacks);
+        if (pStackBuffer == NULL) {
+            emscripten_destroy_audio_context(pDevice->webaudio.audioContext);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        /* Our thread initialization parameters need to be allocated on the heap so they don't go out of scope. */
+        pInitParameters = (ma_audio_worklet_thread_initialized_data*)ma_malloc(sizeof(*pInitParameters), &pDevice->pContext->allocationCallbacks);
+        if (pInitParameters == NULL) {
+            ma_free(pStackBuffer, &pDevice->pContext->allocationCallbacks);
+            emscripten_destroy_audio_context(pDevice->webaudio.audioContext);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        pInitParameters->pDevice = pDevice;
+        pInitParameters->pConfig = pConfig;
+        pInitParameters->pDescriptorPlayback = pDescriptorPlayback;
+        pInitParameters->pDescriptorCapture  = pDescriptorCapture;
+
+        /*
+        We need to flag the device as not yet initialized so we can wait on it later. Unfortunately all of
+        the Emscripten WebAudio stuff is asynchronous.
+        */
+        pDevice->webaudio.initResult = MA_BUSY;
+        {
+            emscripten_start_wasm_audio_worklet_thread_async(pDevice->webaudio.audioContext, pStackBuffer, MA_AUDIO_WORKLETS_THREAD_STACK_SIZE, ma_audio_worklet_thread_initialized__webaudio, pInitParameters);
+        }
+        while (pDevice->webaudio.initResult == MA_BUSY) { emscripten_sleep(1); }    /* We must wait for initialization to complete. We're just spinning here. The emscripten_sleep() call is why we need to build with `-sASYNCIFY`. */
+
+        /* Initialization is now complete. Descriptors were updated when the worklet was initialized. */
+        if (pDevice->webaudio.initResult != MA_SUCCESS) {
+            ma_free(pStackBuffer, &pDevice->pContext->allocationCallbacks);
+            emscripten_destroy_audio_context(pDevice->webaudio.audioContext);
+            return pDevice->webaudio.initResult;
+        }
+
+        /* We need to add an entry to the miniaudio.devices list on the JS side so we can do some JS/C interop. */
+        pDevice->webaudio.deviceIndex = EM_ASM_INT({
+            return miniaudio.track_device({
+                webaudio: emscriptenGetAudioObject($0),
+                state:    1 /* 1 = ma_device_state_stopped */
+            });
+        }, pDevice->webaudio.audioContext);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* ScriptProcessorNode. This path requires us to do almost everything in JS, but we'll do as much as we can in C. */
+        ma_uint32 deviceIndex;
+        ma_uint32 channels;
+        ma_uint32 sampleRate;
+        ma_uint32 periodSizeInFrames;
+
+        /* The channel count will depend on the device type. If it's a capture, use it's, otherwise use the playback side. */
+        if (pConfig->deviceType == ma_device_type_capture) {
+            channels = (pDescriptorCapture->channels  > 0) ? pDescriptorCapture->channels  : MA_DEFAULT_CHANNELS;
+        } else {
+            channels = (pDescriptorPlayback->channels > 0) ? pDescriptorPlayback->channels : MA_DEFAULT_CHANNELS;
+        }
+
+        /*
+        When testing in Firefox, I've seen it where capture mode fails if the sample rate is changed to anything other than it's
+        native rate. For this reason we're leaving the sample rate untouched for capture devices.
+        */
+        if (pConfig->deviceType == ma_device_type_playback) {
+            sampleRate = pDescriptorPlayback->sampleRate;
+        } else {
+            sampleRate = 0; /* Let the browser decide when capturing. */
+        }
+
+        /* The period size needs to be a power of 2. */
+        if (pConfig->deviceType == ma_device_type_capture) {
+            periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__webaudio(pDescriptorCapture, sampleRate, pConfig->performanceProfile);
+        } else {
+            periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__webaudio(pDescriptorPlayback, sampleRate, pConfig->performanceProfile);
+        }
+
+        /* We need an intermediary buffer for doing interleaving and deinterleaving. */
+        pDevice->webaudio.pIntermediaryBuffer = (float*)ma_malloc(periodSizeInFrames * channels * sizeof(float), &pDevice->pContext->allocationCallbacks);
+        if (pDevice->webaudio.pIntermediaryBuffer == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        deviceIndex = EM_ASM_INT({
+            var deviceType = $0;
+            var channels   = $1;
+            var sampleRate = $2;
+            var bufferSize = $3;
+            var pIntermediaryBuffer = $4;
+            var pDevice    = $5;
+
+            if (typeof(window.miniaudio) === 'undefined') {
+                return -1;  /* Context not initialized. */
+            }
+
+            var device = {};
+
+            /* First thing we need is an AudioContext. */
+            var audioContextOptions = {};
+            if (deviceType == window.miniaudio.device_type.playback && sampleRate != 0) {
+                audioContextOptions.sampleRate = sampleRate;
+            }
+
+            device.webaudio = new (window.AudioContext || window.webkitAudioContext)(audioContextOptions);
+            device.webaudio.suspend();  /* The AudioContext must be created in a suspended state. */
+            device.state = window.miniaudio.device_state.stopped;
+
+            /*
+            We need to create a ScriptProcessorNode. The channel situation is the same as the AudioWorklet path in that we
+            need to specify an output and configure the channel count there.
+            */
+            var channelCountIn  = 0;
+            var channelCountOut = channels;
+            if (deviceType != window.miniaudio.device_type.playback) {
+                channelCountIn  = channels;
+            }
+
+            device.scriptNode = device.webaudio.createScriptProcessor(bufferSize, channelCountIn, channelCountOut);
+
+            /* The node processing callback. */
+            device.scriptNode.onaudioprocess = function(e) {
+                if (device.intermediaryBufferView == null || device.intermediaryBufferView.length == 0) {
+                    device.intermediaryBufferView = new Float32Array(Module.HEAPF32.buffer, pIntermediaryBuffer, bufferSize * channels);
+                }
+
+                /* Do the capture side first. */
+                if (deviceType == miniaudio.device_type.capture || deviceType == miniaudio.device_type.duplex) {
+                    /* The data must be interleaved before being processed miniaudio. */
+                    for (var iChannel = 0; iChannel < channels; iChannel += 1) {
+                        var inputBuffer = e.inputBuffer.getChannelData(iChannel);
+                        var intermediaryBuffer = device.intermediaryBufferView;
+
+                        for (var iFrame = 0; iFrame < bufferSize; iFrame += 1) {
+                            intermediaryBuffer[iFrame*channels + iChannel] = inputBuffer[iFrame];
+                        }
+                    }
+
+                    _ma_device_process_pcm_frames_capture__webaudio(pDevice, bufferSize, pIntermediaryBuffer);
+                }
+
+                if (deviceType == miniaudio.device_type.playback || deviceType == miniaudio.device_type.duplex) {
+                    _ma_device_process_pcm_frames_playback__webaudio(pDevice, bufferSize, pIntermediaryBuffer);
+
+                    for (var iChannel = 0; iChannel < e.outputBuffer.numberOfChannels; ++iChannel) {
+                        var outputBuffer = e.outputBuffer.getChannelData(iChannel);
+                        var intermediaryBuffer = device.intermediaryBufferView;
+
+                        for (var iFrame = 0; iFrame < bufferSize; iFrame += 1) {
+                            outputBuffer[iFrame] = intermediaryBuffer[iFrame*channels + iChannel];
+                        }
+                    }
+                } else {
+                    /* It's a capture-only device. Make sure the output is silenced. */
+                    for (var iChannel = 0; iChannel < e.outputBuffer.numberOfChannels; ++iChannel) {
+                        e.outputBuffer.getChannelData(iChannel).fill(0.0);
+                    }
+                }
+            };
+
+            /* Now we need to connect our node to the graph. */
+            if (deviceType == miniaudio.device_type.capture || deviceType == miniaudio.device_type.duplex) {
+                navigator.mediaDevices.getUserMedia({audio:true, video:false})
+                    .then(function(stream) {
+                        device.streamNode = device.webaudio.createMediaStreamSource(stream);
+                        device.streamNode.connect(device.scriptNode);
+                        device.scriptNode.connect(device.webaudio.destination);
+                    })
+                    .catch(function(error) {
+                        console.log("Failed to get user media: " + error);
+                    });
+            }
+
+            if (deviceType == miniaudio.device_type.playback) {
+                device.scriptNode.connect(device.webaudio.destination);
+            }
+
+            device.pDevice = pDevice;
+
+            return miniaudio.track_device(device);
+        }, pConfig->deviceType, channels, sampleRate, periodSizeInFrames, pDevice->webaudio.pIntermediaryBuffer, pDevice);
+
+        if (deviceIndex < 0) {
+            return MA_FAILED_TO_OPEN_BACKEND_DEVICE;
+        }
+
+        pDevice->webaudio.deviceIndex = deviceIndex;
+
+        /* Grab the sample rate from the audio context directly. */
+        sampleRate = (ma_uint32)EM_ASM_INT({ return miniaudio.get_device_by_index($0).webaudio.sampleRate; }, deviceIndex);
+
+        if (pDescriptorCapture != NULL) {
+            pDescriptorCapture->format              = ma_format_f32;
+            pDescriptorCapture->channels            = channels;
+            pDescriptorCapture->sampleRate          = sampleRate;
+            ma_channel_map_init_standard(ma_standard_channel_map_webaudio, pDescriptorCapture->channelMap, ma_countof(pDescriptorCapture->channelMap), pDescriptorCapture->channels);
+            pDescriptorCapture->periodSizeInFrames  = periodSizeInFrames;
+            pDescriptorCapture->periodCount         = 1;
+        }
+
+        if (pDescriptorPlayback != NULL) {
+            pDescriptorPlayback->format             = ma_format_f32;
+            pDescriptorPlayback->channels           = channels;
+            pDescriptorPlayback->sampleRate         = sampleRate;
+            ma_channel_map_init_standard(ma_standard_channel_map_webaudio, pDescriptorPlayback->channelMap, ma_countof(pDescriptorPlayback->channelMap), pDescriptorPlayback->channels);
+            pDescriptorPlayback->periodSizeInFrames = periodSizeInFrames;
+            pDescriptorPlayback->periodCount        = 1;
+        }
+
+        return MA_SUCCESS;
+    }
+    #endif
+}
+
+static ma_result ma_device_start__webaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    EM_ASM({
+        var device = miniaudio.get_device_by_index($0);
+        device.webaudio.resume();
+        device.state = miniaudio.device_state.started;
+    }, pDevice->webaudio.deviceIndex);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_device_stop__webaudio(ma_device* pDevice)
+{
+    MA_ASSERT(pDevice != NULL);
+
+    /*
+    From the WebAudio API documentation for AudioContext.suspend():
+
+        Suspends the progression of AudioContext's currentTime, allows any current context processing blocks that are already processed to be played to the
+        destination, and then allows the system to release its claim on audio hardware.
+
+    I read this to mean that "any current context processing blocks" are processed by suspend() - i.e. They they are drained. We therefore shouldn't need to
+    do any kind of explicit draining.
+    */
+    EM_ASM({
+        var device = miniaudio.get_device_by_index($0);
+        device.webaudio.suspend();
+        device.state = miniaudio.device_state.stopped;
+    }, pDevice->webaudio.deviceIndex);
+
+    ma_device__on_notification_stopped(pDevice);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_uninit__webaudio(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+    MA_ASSERT(pContext->backend == ma_backend_webaudio);
+
+    (void)pContext; /* Unused. */
+
+    /* Remove the global miniaudio object from window if there are no more references to it. */
+    EM_ASM({
+        if (typeof(window.miniaudio) !== 'undefined') {
+            window.miniaudio.referenceCount -= 1;
+            if (window.miniaudio.referenceCount === 0) {
+                delete window.miniaudio;
+            }
+        }
+    });
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init__webaudio(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
+{
+    int resultFromJS;
+
+    MA_ASSERT(pContext != NULL);
+
+    (void)pConfig; /* Unused. */
+
+    /* Here is where our global JavaScript object is initialized. */
+    resultFromJS = EM_ASM_INT({
+        if (typeof window === 'undefined' || (window.AudioContext || window.webkitAudioContext) === undefined) {
+            return 0;   /* Web Audio not supported. */
+        }
+
+        if (typeof(window.miniaudio) === 'undefined') {
+            window.miniaudio = {
+                referenceCount: 0
+            };
+
+            /* Device types. */
+            window.miniaudio.device_type = {};
+            window.miniaudio.device_type.playback = $0;
+            window.miniaudio.device_type.capture  = $1;
+            window.miniaudio.device_type.duplex   = $2;
+
+            /* Device states. */
+            window.miniaudio.device_state = {};
+            window.miniaudio.device_state.stopped = $3;
+            window.miniaudio.device_state.started = $4;
+
+            /* Device cache for mapping devices to indexes for JavaScript/C interop. */
+            miniaudio.devices = [];
+
+            miniaudio.track_device = function(device) {
+                /* Try inserting into a free slot first. */
+                for (var iDevice = 0; iDevice < miniaudio.devices.length; ++iDevice) {
+                    if (miniaudio.devices[iDevice] == null) {
+                        miniaudio.devices[iDevice] = device;
+                        return iDevice;
+                    }
+                }
+
+                /* Getting here means there is no empty slots in the array so we just push to the end. */
+                miniaudio.devices.push(device);
+                return miniaudio.devices.length - 1;
+            };
+
+            miniaudio.untrack_device_by_index = function(deviceIndex) {
+                /* We just set the device's slot to null. The slot will get reused in the next call to ma_track_device. */
+                miniaudio.devices[deviceIndex] = null;
+
+                /* Trim the array if possible. */
+                while (miniaudio.devices.length > 0) {
+                    if (miniaudio.devices[miniaudio.devices.length-1] == null) {
+                        miniaudio.devices.pop();
+                    } else {
+                        break;
+                    }
+                }
+            };
+
+            miniaudio.untrack_device = function(device) {
+                for (var iDevice = 0; iDevice < miniaudio.devices.length; ++iDevice) {
+                    if (miniaudio.devices[iDevice] == device) {
+                        return miniaudio.untrack_device_by_index(iDevice);
+                    }
+                }
+            };
+
+            miniaudio.get_device_by_index = function(deviceIndex) {
+                return miniaudio.devices[deviceIndex];
+            };
+
+            miniaudio.unlock_event_types = (function(){
+                return ['touchend', 'click'];
+            })();
+
+            miniaudio.unlock = function() {
+                for(var i = 0; i < miniaudio.devices.length; ++i) {
+                    var device = miniaudio.devices[i];
+                    if (device != null &&
+                        device.webaudio != null &&
+                        device.state === window.miniaudio.device_state.started) {
+
+                        device.webaudio.resume().then(() => {
+                                Module._ma_device__on_notification_unlocked(device.pDevice);
+                            },
+                            (error) => {console.error("Failed to resume audiocontext", error);
+                            });
+                    }
+                }
+                miniaudio.unlock_event_types.map(function(event_type) {
+                    document.removeEventListener(event_type, miniaudio.unlock, true);
+                });
+            };
+
+            miniaudio.unlock_event_types.map(function(event_type) {
+                document.addEventListener(event_type, miniaudio.unlock, true);
+            });
+        }
+
+        window.miniaudio.referenceCount += 1;
+
+        return 1;
+    }, ma_device_type_playback, ma_device_type_capture, ma_device_type_duplex, ma_device_state_stopped, ma_device_state_started);
+
+    if (resultFromJS != 1) {
+        return MA_FAILED_TO_INIT_BACKEND;
+    }
+
+    pCallbacks->onContextInit             = ma_context_init__webaudio;
+    pCallbacks->onContextUninit           = ma_context_uninit__webaudio;
+    pCallbacks->onContextEnumerateDevices = ma_context_enumerate_devices__webaudio;
+    pCallbacks->onContextGetDeviceInfo    = ma_context_get_device_info__webaudio;
+    pCallbacks->onDeviceInit              = ma_device_init__webaudio;
+    pCallbacks->onDeviceUninit            = ma_device_uninit__webaudio;
+    pCallbacks->onDeviceStart             = ma_device_start__webaudio;
+    pCallbacks->onDeviceStop              = ma_device_stop__webaudio;
+    pCallbacks->onDeviceRead              = NULL;   /* Not needed because WebAudio is asynchronous. */
+    pCallbacks->onDeviceWrite             = NULL;   /* Not needed because WebAudio is asynchronous. */
+    pCallbacks->onDeviceDataLoop          = NULL;   /* Not needed because WebAudio is asynchronous. */
+
+    return MA_SUCCESS;
+}
+#endif  /* Web Audio */
+
+
+
+static ma_bool32 ma__is_channel_map_valid(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    /* A blank channel map should be allowed, in which case it should use an appropriate default which will depend on context. */
+    if (pChannelMap != NULL && pChannelMap[0] != MA_CHANNEL_NONE) {
+        ma_uint32 iChannel;
+
+        if (channels == 0 || channels > MA_MAX_CHANNELS) {
+            return MA_FALSE;   /* Channel count out of range. */
+        }
+
+        /* A channel cannot be present in the channel map more than once. */
+        for (iChannel = 0; iChannel < channels; ++iChannel) {
+            ma_uint32 jChannel;
+            for (jChannel = iChannel + 1; jChannel < channels; ++jChannel) {
+                if (pChannelMap[iChannel] == pChannelMap[jChannel]) {
+                    return MA_FALSE;
+                }
+            }
+        }
+    }
+
+    return MA_TRUE;
+}
+
+
+static ma_bool32 ma_context_is_backend_asynchronous(ma_context* pContext)
+{
+    MA_ASSERT(pContext != NULL);
+
+    if (pContext->callbacks.onDeviceRead == NULL && pContext->callbacks.onDeviceWrite == NULL) {
+        if (pContext->callbacks.onDeviceDataLoop == NULL) {
+            return MA_TRUE;
+        } else {
+            return MA_FALSE;
+        }
+    } else {
+        return MA_FALSE;
+    }
+}
+
+
+static ma_result ma_device__post_init_setup(ma_device* pDevice, ma_device_type deviceType)
+{
+    ma_result result;
+
+    MA_ASSERT(pDevice != NULL);
+
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+        if (pDevice->capture.format == ma_format_unknown) {
+            pDevice->capture.format = pDevice->capture.internalFormat;
+        }
+        if (pDevice->capture.channels == 0) {
+            pDevice->capture.channels = pDevice->capture.internalChannels;
+        }
+        if (pDevice->capture.channelMap[0] == MA_CHANNEL_NONE) {
+            MA_ASSERT(pDevice->capture.channels <= MA_MAX_CHANNELS);
+            if (pDevice->capture.internalChannels == pDevice->capture.channels) {
+                ma_channel_map_copy(pDevice->capture.channelMap, pDevice->capture.internalChannelMap, pDevice->capture.channels);
+            } else {
+                if (pDevice->capture.channelMixMode == ma_channel_mix_mode_simple) {
+                    ma_channel_map_init_blank(pDevice->capture.channelMap, pDevice->capture.channels);
+                } else {
+                    ma_channel_map_init_standard(ma_standard_channel_map_default, pDevice->capture.channelMap, ma_countof(pDevice->capture.channelMap), pDevice->capture.channels);
+                }
+            }
+        }
+    }
+
+    if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+        if (pDevice->playback.format == ma_format_unknown) {
+            pDevice->playback.format = pDevice->playback.internalFormat;
+        }
+        if (pDevice->playback.channels == 0) {
+            pDevice->playback.channels = pDevice->playback.internalChannels;
+        }
+        if (pDevice->playback.channelMap[0] == MA_CHANNEL_NONE) {
+            MA_ASSERT(pDevice->playback.channels <= MA_MAX_CHANNELS);
+            if (pDevice->playback.internalChannels == pDevice->playback.channels) {
+                ma_channel_map_copy(pDevice->playback.channelMap, pDevice->playback.internalChannelMap, pDevice->playback.channels);
+            } else {
+                if (pDevice->playback.channelMixMode == ma_channel_mix_mode_simple) {
+                    ma_channel_map_init_blank(pDevice->playback.channelMap, pDevice->playback.channels);
+                } else {
+                    ma_channel_map_init_standard(ma_standard_channel_map_default, pDevice->playback.channelMap, ma_countof(pDevice->playback.channelMap), pDevice->playback.channels);
+                }
+            }
+        }
+    }
+
+    if (pDevice->sampleRate == 0) {
+        if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+            pDevice->sampleRate = pDevice->capture.internalSampleRate;
+        } else {
+            pDevice->sampleRate = pDevice->playback.internalSampleRate;
+        }
+    }
+
+    /* Data converters. */
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+        /* Converting from internal device format to client format. */
+        ma_data_converter_config converterConfig = ma_data_converter_config_init_default();
+        converterConfig.formatIn                        = pDevice->capture.internalFormat;
+        converterConfig.channelsIn                      = pDevice->capture.internalChannels;
+        converterConfig.sampleRateIn                    = pDevice->capture.internalSampleRate;
+        converterConfig.pChannelMapIn                   = pDevice->capture.internalChannelMap;
+        converterConfig.formatOut                       = pDevice->capture.format;
+        converterConfig.channelsOut                     = pDevice->capture.channels;
+        converterConfig.sampleRateOut                   = pDevice->sampleRate;
+        converterConfig.pChannelMapOut                  = pDevice->capture.channelMap;
+        converterConfig.channelMixMode                  = pDevice->capture.channelMixMode;
+        converterConfig.calculateLFEFromSpatialChannels = pDevice->capture.calculateLFEFromSpatialChannels;
+        converterConfig.allowDynamicSampleRate          = MA_FALSE;
+        converterConfig.resampling.algorithm            = pDevice->resampling.algorithm;
+        converterConfig.resampling.linear.lpfOrder      = pDevice->resampling.linear.lpfOrder;
+        converterConfig.resampling.pBackendVTable       = pDevice->resampling.pBackendVTable;
+        converterConfig.resampling.pBackendUserData     = pDevice->resampling.pBackendUserData;
+
+        /* Make sure the old converter is uninitialized first. */
+        if (ma_device_get_state(pDevice) != ma_device_state_uninitialized) {
+            ma_data_converter_uninit(&pDevice->capture.converter, &pDevice->pContext->allocationCallbacks);
+        }
+
+        result = ma_data_converter_init(&converterConfig, &pDevice->pContext->allocationCallbacks, &pDevice->capture.converter);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+        /* Converting from client format to device format. */
+        ma_data_converter_config converterConfig = ma_data_converter_config_init_default();
+        converterConfig.formatIn                        = pDevice->playback.format;
+        converterConfig.channelsIn                      = pDevice->playback.channels;
+        converterConfig.sampleRateIn                    = pDevice->sampleRate;
+        converterConfig.pChannelMapIn                   = pDevice->playback.channelMap;
+        converterConfig.formatOut                       = pDevice->playback.internalFormat;
+        converterConfig.channelsOut                     = pDevice->playback.internalChannels;
+        converterConfig.sampleRateOut                   = pDevice->playback.internalSampleRate;
+        converterConfig.pChannelMapOut                  = pDevice->playback.internalChannelMap;
+        converterConfig.channelMixMode                  = pDevice->playback.channelMixMode;
+        converterConfig.calculateLFEFromSpatialChannels = pDevice->playback.calculateLFEFromSpatialChannels;
+        converterConfig.allowDynamicSampleRate          = MA_FALSE;
+        converterConfig.resampling.algorithm            = pDevice->resampling.algorithm;
+        converterConfig.resampling.linear.lpfOrder      = pDevice->resampling.linear.lpfOrder;
+        converterConfig.resampling.pBackendVTable       = pDevice->resampling.pBackendVTable;
+        converterConfig.resampling.pBackendUserData     = pDevice->resampling.pBackendUserData;
+
+        /* Make sure the old converter is uninitialized first. */
+        if (ma_device_get_state(pDevice) != ma_device_state_uninitialized) {
+            ma_data_converter_uninit(&pDevice->playback.converter, &pDevice->pContext->allocationCallbacks);
+        }
+
+        result = ma_data_converter_init(&converterConfig, &pDevice->pContext->allocationCallbacks, &pDevice->playback.converter);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+
+    /*
+    If the device is doing playback (ma_device_type_playback or ma_device_type_duplex), there's
+    a couple of situations where we'll need a heap allocated cache.
+
+    The first is a duplex device for backends that use a callback for data delivery. The reason
+    this is needed is that the input stage needs to have a buffer to place the input data while it
+    waits for the playback stage, after which the miniaudio data callback will get fired. This is
+    not needed for backends that use a blocking API because miniaudio manages temporary buffers on
+    the stack to achieve this.
+
+    The other situation is when the data converter does not have the ability to query the number
+    of input frames that are required in order to process a given number of output frames. When
+    performing data conversion, it's useful if miniaudio know exactly how many frames it needs
+    from the client in order to generate a given number of output frames. This way, only exactly
+    the number of frames are needed to be read from the client which means no cache is necessary.
+    On the other hand, if miniaudio doesn't know how many frames to read, it is forced to read
+    in fixed sized chunks and then cache any residual unused input frames, those of which will be
+    processed at a later stage.
+    */
+    if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+        ma_uint64 unused;
+
+        pDevice->playback.inputCacheConsumed  = 0;
+        pDevice->playback.inputCacheRemaining = 0;
+
+        if (pDevice->type == ma_device_type_duplex ||                                                                       /* Duplex. backend may decide to use ma_device_handle_backend_data_callback() which will require this cache. */
+            ma_data_converter_get_required_input_frame_count(&pDevice->playback.converter, 1, &unused) != MA_SUCCESS)       /* Data conversion required input frame calculation not supported. */
+        {
+            /* We need a heap allocated cache. We want to size this based on the period size. */
+            void* pNewInputCache;
+            ma_uint64 newInputCacheCap;
+            ma_uint64 newInputCacheSizeInBytes;
+
+            newInputCacheCap = ma_calculate_frame_count_after_resampling(pDevice->playback.internalSampleRate, pDevice->sampleRate, pDevice->playback.internalPeriodSizeInFrames);
+
+            newInputCacheSizeInBytes = newInputCacheCap * ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+            if (newInputCacheSizeInBytes > MA_SIZE_MAX) {
+                ma_free(pDevice->playback.pInputCache, &pDevice->pContext->allocationCallbacks);
+                pDevice->playback.pInputCache   = NULL;
+                pDevice->playback.inputCacheCap = 0;
+                return MA_OUT_OF_MEMORY;    /* Allocation too big. Should never hit this, but makes the cast below safer for 32-bit builds. */
+            }
+
+            pNewInputCache = ma_realloc(pDevice->playback.pInputCache, (size_t)newInputCacheSizeInBytes, &pDevice->pContext->allocationCallbacks);
+            if (pNewInputCache == NULL) {
+                ma_free(pDevice->playback.pInputCache, &pDevice->pContext->allocationCallbacks);
+                pDevice->playback.pInputCache   = NULL;
+                pDevice->playback.inputCacheCap = 0;
+                return MA_OUT_OF_MEMORY;
+            }
+
+            pDevice->playback.pInputCache   = pNewInputCache;
+            pDevice->playback.inputCacheCap = newInputCacheCap;
+        } else {
+            /* Heap allocation not required. Make sure we clear out the old cache just in case this function was called in response to a route change. */
+            ma_free(pDevice->playback.pInputCache, &pDevice->pContext->allocationCallbacks);
+            pDevice->playback.pInputCache   = NULL;
+            pDevice->playback.inputCacheCap = 0;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_device_post_init(ma_device* pDevice, ma_device_type deviceType, const ma_device_descriptor* pDescriptorPlayback, const ma_device_descriptor* pDescriptorCapture)
+{
+    ma_result result;
+
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Capture. */
+    if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+        if (ma_device_descriptor_is_valid(pDescriptorCapture) == MA_FALSE) {
+            return MA_INVALID_ARGS;
+        }
+
+        pDevice->capture.internalFormat             = pDescriptorCapture->format;
+        pDevice->capture.internalChannels           = pDescriptorCapture->channels;
+        pDevice->capture.internalSampleRate         = pDescriptorCapture->sampleRate;
+        MA_COPY_MEMORY(pDevice->capture.internalChannelMap, pDescriptorCapture->channelMap, sizeof(pDescriptorCapture->channelMap));
+        pDevice->capture.internalPeriodSizeInFrames = pDescriptorCapture->periodSizeInFrames;
+        pDevice->capture.internalPeriods            = pDescriptorCapture->periodCount;
+
+        if (pDevice->capture.internalPeriodSizeInFrames == 0) {
+            pDevice->capture.internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptorCapture->periodSizeInMilliseconds, pDescriptorCapture->sampleRate);
+        }
+    }
+
+    /* Playback. */
+    if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+        if (ma_device_descriptor_is_valid(pDescriptorPlayback) == MA_FALSE) {
+            return MA_INVALID_ARGS;
+        }
+
+        pDevice->playback.internalFormat             = pDescriptorPlayback->format;
+        pDevice->playback.internalChannels           = pDescriptorPlayback->channels;
+        pDevice->playback.internalSampleRate         = pDescriptorPlayback->sampleRate;
+        MA_COPY_MEMORY(pDevice->playback.internalChannelMap, pDescriptorPlayback->channelMap, sizeof(pDescriptorPlayback->channelMap));
+        pDevice->playback.internalPeriodSizeInFrames = pDescriptorPlayback->periodSizeInFrames;
+        pDevice->playback.internalPeriods            = pDescriptorPlayback->periodCount;
+
+        if (pDevice->playback.internalPeriodSizeInFrames == 0) {
+            pDevice->playback.internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptorPlayback->periodSizeInMilliseconds, pDescriptorPlayback->sampleRate);
+        }
+    }
+
+    /*
+    The name of the device can be retrieved from device info. This may be temporary and replaced with a `ma_device_get_info(pDevice, deviceType)` instead.
+    For loopback devices, we need to retrieve the name of the playback device.
+    */
+    {
+        ma_device_info deviceInfo;
+
+        if (deviceType == ma_device_type_capture || deviceType == ma_device_type_duplex || deviceType == ma_device_type_loopback) {
+            result = ma_device_get_info(pDevice, (deviceType == ma_device_type_loopback) ? ma_device_type_playback : ma_device_type_capture, &deviceInfo);
+            if (result == MA_SUCCESS) {
+                ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), deviceInfo.name, (size_t)-1);
+            } else {
+                /* We failed to retrieve the device info. Fall back to a default name. */
+                if (pDescriptorCapture->pDeviceID == NULL) {
+                    ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+                } else {
+                    ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), "Capture Device", (size_t)-1);
+                }
+            }
+        }
+
+        if (deviceType == ma_device_type_playback || deviceType == ma_device_type_duplex) {
+            result = ma_device_get_info(pDevice, ma_device_type_playback, &deviceInfo);
+            if (result == MA_SUCCESS) {
+                ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), deviceInfo.name, (size_t)-1);
+            } else {
+                /* We failed to retrieve the device info. Fall back to a default name. */
+                if (pDescriptorPlayback->pDeviceID == NULL) {
+                    ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+                } else {
+                    ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), "Playback Device", (size_t)-1);
+                }
+            }
+        }
+    }
+
+    /* Update data conversion. */
+    return ma_device__post_init_setup(pDevice, deviceType); /* TODO: Should probably rename ma_device__post_init_setup() to something better. */
+}
+
+
+static ma_thread_result MA_THREADCALL ma_worker_thread(void* pData)
+{
+    ma_device* pDevice = (ma_device*)pData;
+#ifdef MA_WIN32
+    HRESULT CoInitializeResult;
+#endif
+
+    MA_ASSERT(pDevice != NULL);
+
+#ifdef MA_WIN32
+    CoInitializeResult = ma_CoInitializeEx(pDevice->pContext, NULL, MA_COINIT_VALUE);
+#endif
+
+    /*
+    When the device is being initialized it's initial state is set to ma_device_state_uninitialized. Before returning from
+    ma_device_init(), the state needs to be set to something valid. In miniaudio the device's default state immediately
+    after initialization is stopped, so therefore we need to mark the device as such. miniaudio will wait on the worker
+    thread to signal an event to know when the worker thread is ready for action.
+    */
+    ma_device__set_state(pDevice, ma_device_state_stopped);
+    ma_event_signal(&pDevice->stopEvent);
+
+    for (;;) {  /* <-- This loop just keeps the thread alive. The main audio loop is inside. */
+        ma_result startResult;
+        ma_result stopResult;   /* <-- This will store the result from onDeviceStop(). If it returns an error, we don't fire the stopped notification callback. */
+
+        /* We wait on an event to know when something has requested that the device be started and the main loop entered. */
+        ma_event_wait(&pDevice->wakeupEvent);
+
+        /* Default result code. */
+        pDevice->workResult = MA_SUCCESS;
+
+        /* If the reason for the wake up is that we are terminating, just break from the loop. */
+        if (ma_device_get_state(pDevice) == ma_device_state_uninitialized) {
+            break;
+        }
+
+        /*
+        Getting to this point means the device is wanting to get started. The function that has requested that the device
+        be started will be waiting on an event (pDevice->startEvent) which means we need to make sure we signal the event
+        in both the success and error case. It's important that the state of the device is set _before_ signaling the event.
+        */
+        MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_starting);
+
+        /* If the device has a start callback, start it now. */
+        if (pDevice->pContext->callbacks.onDeviceStart != NULL) {
+            startResult = pDevice->pContext->callbacks.onDeviceStart(pDevice);
+        } else {
+            startResult = MA_SUCCESS;
+        }
+
+        /*
+        If starting was not successful we'll need to loop back to the start and wait for something
+        to happen (pDevice->wakeupEvent).
+        */
+        if (startResult != MA_SUCCESS) {
+            pDevice->workResult = startResult;
+            ma_event_signal(&pDevice->startEvent);  /* <-- Always signal the start event so ma_device_start() can return as it'll be waiting on it. */
+            continue;
+        }
+
+        /* Make sure the state is set appropriately. */
+        ma_device__set_state(pDevice, ma_device_state_started); /* <-- Set this before signaling the event so that the state is always guaranteed to be good after ma_device_start() has returned. */
+        ma_event_signal(&pDevice->startEvent);
+
+        ma_device__on_notification_started(pDevice);
+
+        if (pDevice->pContext->callbacks.onDeviceDataLoop != NULL) {
+            pDevice->pContext->callbacks.onDeviceDataLoop(pDevice);
+        } else {
+            /* The backend is not using a custom main loop implementation, so now fall back to the blocking read-write implementation. */
+            ma_device_audio_thread__default_read_write(pDevice);
+        }
+
+        /* Getting here means we have broken from the main loop which happens the application has requested that device be stopped. */
+        if (pDevice->pContext->callbacks.onDeviceStop != NULL) {
+            stopResult = pDevice->pContext->callbacks.onDeviceStop(pDevice);
+        } else {
+            stopResult = MA_SUCCESS;    /* No stop callback with the backend. Just assume successful. */
+        }
+
+        /*
+        After the device has stopped, make sure an event is posted. Don't post a stopped event if
+        stopping failed. This can happen on some backends when the underlying stream has been
+        stopped due to the device being physically unplugged or disabled via an OS setting.
+        */
+        if (stopResult == MA_SUCCESS) {
+            ma_device__on_notification_stopped(pDevice);
+        }
+
+        /* If we stopped because the device has been uninitialized, abort now. */
+        if (ma_device_get_state(pDevice) == ma_device_state_uninitialized) {
+            break;
+        }
+
+        /* A function somewhere is waiting for the device to have stopped for real so we need to signal an event to allow it to continue. */
+        ma_device__set_state(pDevice, ma_device_state_stopped);
+        ma_event_signal(&pDevice->stopEvent);
+    }
+
+#ifdef MA_WIN32
+    if (CoInitializeResult == S_OK) {
+        ma_CoUninitialize(pDevice->pContext);
+    }
+#endif
+
+    return (ma_thread_result)0;
+}
+
+
+/* Helper for determining whether or not the given device is initialized. */
+static ma_bool32 ma_device__is_initialized(ma_device* pDevice)
+{
+    if (pDevice == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_device_get_state(pDevice) != ma_device_state_uninitialized;
+}
+
+
+#ifdef MA_WIN32
+static ma_result ma_context_uninit_backend_apis__win32(ma_context* pContext)
+{
+    /* For some reason UWP complains when CoUninitialize() is called. I'm just not going to call it on UWP. */
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    if (pContext->win32.CoInitializeResult == S_OK) {
+        ma_CoUninitialize(pContext);
+    }
+
+    #if defined(MA_WIN32_DESKTOP)
+        ma_dlclose(ma_context_get_log(pContext), pContext->win32.hUser32DLL);
+        ma_dlclose(ma_context_get_log(pContext), pContext->win32.hAdvapi32DLL);
+    #endif
+
+    ma_dlclose(ma_context_get_log(pContext), pContext->win32.hOle32DLL);
+#else
+    (void)pContext;
+#endif
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init_backend_apis__win32(ma_context* pContext)
+{
+#if defined(MA_WIN32_DESKTOP) || defined(MA_WIN32_GDK)
+    #if defined(MA_WIN32_DESKTOP)
+        /* User32.dll */
+        pContext->win32.hUser32DLL = ma_dlopen(ma_context_get_log(pContext), "user32.dll");
+        if (pContext->win32.hUser32DLL == NULL) {
+            return MA_FAILED_TO_INIT_BACKEND;
+        }
+
+        pContext->win32.GetForegroundWindow = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hUser32DLL, "GetForegroundWindow");
+        pContext->win32.GetDesktopWindow    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hUser32DLL, "GetDesktopWindow");
+
+
+        /* Advapi32.dll */
+        pContext->win32.hAdvapi32DLL = ma_dlopen(ma_context_get_log(pContext), "advapi32.dll");
+        if (pContext->win32.hAdvapi32DLL == NULL) {
+            return MA_FAILED_TO_INIT_BACKEND;
+        }
+
+        pContext->win32.RegOpenKeyExA    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hAdvapi32DLL, "RegOpenKeyExA");
+        pContext->win32.RegCloseKey      = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hAdvapi32DLL, "RegCloseKey");
+        pContext->win32.RegQueryValueExA = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hAdvapi32DLL, "RegQueryValueExA");
+    #endif
+
+    /* Ole32.dll */
+    pContext->win32.hOle32DLL = ma_dlopen(ma_context_get_log(pContext), "ole32.dll");
+    if (pContext->win32.hOle32DLL == NULL) {
+        return MA_FAILED_TO_INIT_BACKEND;
+    }
+
+    pContext->win32.CoInitialize     = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "CoInitialize");
+    pContext->win32.CoInitializeEx   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "CoInitializeEx");
+    pContext->win32.CoUninitialize   = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "CoUninitialize");
+    pContext->win32.CoCreateInstance = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "CoCreateInstance");
+    pContext->win32.CoTaskMemFree    = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "CoTaskMemFree");
+    pContext->win32.PropVariantClear = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "PropVariantClear");
+    pContext->win32.StringFromGUID2  = (ma_proc)ma_dlsym(ma_context_get_log(pContext), pContext->win32.hOle32DLL, "StringFromGUID2");
+#else
+    (void)pContext; /* Unused. */
+#endif
+
+    pContext->win32.CoInitializeResult = ma_CoInitializeEx(pContext, NULL, MA_COINIT_VALUE);
+    return MA_SUCCESS;
+}
+#else
+static ma_result ma_context_uninit_backend_apis__nix(ma_context* pContext)
+{
+    (void)pContext;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_context_init_backend_apis__nix(ma_context* pContext)
+{
+    (void)pContext;
+
+    return MA_SUCCESS;
+}
+#endif
+
+static ma_result ma_context_init_backend_apis(ma_context* pContext)
+{
+    ma_result result;
+#ifdef MA_WIN32
+    result = ma_context_init_backend_apis__win32(pContext);
+#else
+    result = ma_context_init_backend_apis__nix(pContext);
+#endif
+
+    return result;
+}
+
+static ma_result ma_context_uninit_backend_apis(ma_context* pContext)
+{
+    ma_result result;
+#ifdef MA_WIN32
+    result = ma_context_uninit_backend_apis__win32(pContext);
+#else
+    result = ma_context_uninit_backend_apis__nix(pContext);
+#endif
+
+    return result;
+}
+
+
+/* The default capacity doesn't need to be too big. */
+#ifndef MA_DEFAULT_DEVICE_JOB_QUEUE_CAPACITY
+#define MA_DEFAULT_DEVICE_JOB_QUEUE_CAPACITY    32
+#endif
+
+MA_API ma_device_job_thread_config ma_device_job_thread_config_init(void)
+{
+    ma_device_job_thread_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.noThread         = MA_FALSE;
+    config.jobQueueCapacity = MA_DEFAULT_DEVICE_JOB_QUEUE_CAPACITY;
+    config.jobQueueFlags    = 0;
+
+    return config;
+}
+
+
+static ma_thread_result MA_THREADCALL ma_device_job_thread_entry(void* pUserData)
+{
+    ma_device_job_thread* pJobThread = (ma_device_job_thread*)pUserData;
+    MA_ASSERT(pJobThread != NULL);
+
+    for (;;) {
+        ma_result result;
+        ma_job job;
+
+        result = ma_device_job_thread_next(pJobThread, &job);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        if (job.toc.breakup.code == MA_JOB_TYPE_QUIT) {
+            break;
+        }
+
+        ma_job_process(&job);
+    }
+
+    return (ma_thread_result)0;
+}
+
+MA_API ma_result ma_device_job_thread_init(const ma_device_job_thread_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_device_job_thread* pJobThread)
+{
+    ma_result result;
+    ma_job_queue_config jobQueueConfig;
+
+    if (pJobThread == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pJobThread);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+
+    /* Initialize the job queue before the thread to ensure it's in a valid state. */
+    jobQueueConfig = ma_job_queue_config_init(pConfig->jobQueueFlags, pConfig->jobQueueCapacity);
+
+    result = ma_job_queue_init(&jobQueueConfig, pAllocationCallbacks, &pJobThread->jobQueue);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize job queue. */
+    }
+
+
+    /* The thread needs to be initialized after the job queue to ensure the thread doesn't try to access it prematurely. */
+    if (pConfig->noThread == MA_FALSE) {
+        result = ma_thread_create(&pJobThread->thread, ma_thread_priority_normal, 0, ma_device_job_thread_entry, pJobThread, pAllocationCallbacks);
+        if (result != MA_SUCCESS) {
+            ma_job_queue_uninit(&pJobThread->jobQueue, pAllocationCallbacks);
+            return result;  /* Failed to create the job thread. */
+        }
+
+        pJobThread->_hasThread = MA_TRUE;
+    } else {
+        pJobThread->_hasThread = MA_FALSE;
+    }
+
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_device_job_thread_uninit(ma_device_job_thread* pJobThread, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pJobThread == NULL) {
+        return;
+    }
+
+    /* The first thing to do is post a quit message to the job queue. If we're using a thread we'll need to wait for it. */
+    {
+        ma_job job = ma_job_init(MA_JOB_TYPE_QUIT);
+        ma_device_job_thread_post(pJobThread, &job);
+    }
+
+    /* Wait for the thread to terminate naturally. */
+    if (pJobThread->_hasThread) {
+        ma_thread_wait(&pJobThread->thread);
+    }
+
+    /* At this point the thread should be terminated so we can safely uninitialize the job queue. */
+    ma_job_queue_uninit(&pJobThread->jobQueue, pAllocationCallbacks);
+}
+
+MA_API ma_result ma_device_job_thread_post(ma_device_job_thread* pJobThread, const ma_job* pJob)
+{
+    if (pJobThread == NULL || pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_job_queue_post(&pJobThread->jobQueue, pJob);
+}
+
+MA_API ma_result ma_device_job_thread_next(ma_device_job_thread* pJobThread, ma_job* pJob)
+{
+    if (pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pJob);
+
+    if (pJobThread == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_job_queue_next(&pJobThread->jobQueue, pJob);
+}
+
+
+
+MA_API ma_context_config ma_context_config_init(void)
+{
+    ma_context_config config;
+    MA_ZERO_OBJECT(&config);
+
+    return config;
+}
+
+MA_API ma_result ma_context_init(const ma_backend backends[], ma_uint32 backendCount, const ma_context_config* pConfig, ma_context* pContext)
+{
+    ma_result result;
+    ma_context_config defaultConfig;
+    ma_backend defaultBackends[ma_backend_null+1];
+    ma_uint32 iBackend;
+    ma_backend* pBackendsToIterate;
+    ma_uint32 backendsToIterateCount;
+
+    if (pContext == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pContext);
+
+    /* Always make sure the config is set first to ensure properties are available as soon as possible. */
+    if (pConfig == NULL) {
+        defaultConfig = ma_context_config_init();
+        pConfig = &defaultConfig;
+    }
+
+    /* Allocation callbacks need to come first because they'll be passed around to other areas. */
+    result = ma_allocation_callbacks_init_copy(&pContext->allocationCallbacks, &pConfig->allocationCallbacks);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Get a lot set up first so we can start logging ASAP. */
+    if (pConfig->pLog != NULL) {
+        pContext->pLog = pConfig->pLog;
+    } else {
+        result = ma_log_init(&pContext->allocationCallbacks, &pContext->log);
+        if (result == MA_SUCCESS) {
+            pContext->pLog = &pContext->log;
+        } else {
+            pContext->pLog = NULL;  /* Logging is not available. */
+        }
+    }
+
+    pContext->threadPriority  = pConfig->threadPriority;
+    pContext->threadStackSize = pConfig->threadStackSize;
+    pContext->pUserData       = pConfig->pUserData;
+
+    /* Backend APIs need to be initialized first. This is where external libraries will be loaded and linked. */
+    result = ma_context_init_backend_apis(pContext);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    for (iBackend = 0; iBackend <= ma_backend_null; ++iBackend) {
+        defaultBackends[iBackend] = (ma_backend)iBackend;
+    }
+
+    pBackendsToIterate = (ma_backend*)backends;
+    backendsToIterateCount = backendCount;
+    if (pBackendsToIterate == NULL) {
+        pBackendsToIterate = (ma_backend*)defaultBackends;
+        backendsToIterateCount = ma_countof(defaultBackends);
+    }
+
+    MA_ASSERT(pBackendsToIterate != NULL);
+
+    for (iBackend = 0; iBackend < backendsToIterateCount; iBackend += 1) {
+        ma_backend backend = pBackendsToIterate[iBackend];
+
+        /* Make sure all callbacks are reset so we don't accidentally drag in any from previously failed initialization attempts. */
+        MA_ZERO_OBJECT(&pContext->callbacks);
+
+        /* These backends are using the new callback system. */
+        switch (backend) {
+        #ifdef MA_HAS_WASAPI
+            case ma_backend_wasapi:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__wasapi;
+            } break;
+        #endif
+        #ifdef MA_HAS_DSOUND
+            case ma_backend_dsound:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__dsound;
+            } break;
+        #endif
+        #ifdef MA_HAS_WINMM
+            case ma_backend_winmm:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__winmm;
+            } break;
+        #endif
+        #ifdef MA_HAS_COREAUDIO
+            case ma_backend_coreaudio:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__coreaudio;
+            } break;
+        #endif
+        #ifdef MA_HAS_SNDIO
+            case ma_backend_sndio:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__sndio;
+            } break;
+        #endif
+        #ifdef MA_HAS_AUDIO4
+            case ma_backend_audio4:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__audio4;
+            } break;
+        #endif
+        #ifdef MA_HAS_OSS
+            case ma_backend_oss:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__oss;
+            } break;
+        #endif
+        #ifdef MA_HAS_PULSEAUDIO
+            case ma_backend_pulseaudio:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__pulse;
+            } break;
+        #endif
+        #ifdef MA_HAS_ALSA
+            case ma_backend_alsa:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__alsa;
+            } break;
+        #endif
+        #ifdef MA_HAS_JACK
+            case ma_backend_jack:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__jack;
+            } break;
+        #endif
+        #ifdef MA_HAS_AAUDIO
+            case ma_backend_aaudio:
+            {
+                if (ma_is_backend_enabled(backend)) {
+                    pContext->callbacks.onContextInit = ma_context_init__aaudio;
+                }
+            } break;
+        #endif
+        #ifdef MA_HAS_OPENSL
+            case ma_backend_opensl:
+            {
+                if (ma_is_backend_enabled(backend)) {
+                    pContext->callbacks.onContextInit = ma_context_init__opensl;
+                }
+            } break;
+        #endif
+        #ifdef MA_HAS_WEBAUDIO
+            case ma_backend_webaudio:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__webaudio;
+            } break;
+        #endif
+        #ifdef MA_HAS_CUSTOM
+            case ma_backend_custom:
+            {
+                /* Slightly different logic for custom backends. Custom backends can optionally set all of their callbacks in the config. */
+                pContext->callbacks = pConfig->custom;
+            } break;
+        #endif
+        #ifdef MA_HAS_NULL
+            case ma_backend_null:
+            {
+                pContext->callbacks.onContextInit = ma_context_init__null;
+            } break;
+        #endif
+
+            default: break;
+        }
+
+        if (pContext->callbacks.onContextInit != NULL) {
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "Attempting to initialize %s backend...\n", ma_get_backend_name(backend));
+            result = pContext->callbacks.onContextInit(pContext, pConfig, &pContext->callbacks);
+        } else {
+            /* Getting here means the onContextInit callback is not set which means the backend is not enabled. Special case for the custom backend. */
+            if (backend != ma_backend_custom) {
+                result = MA_BACKEND_NOT_ENABLED;
+            } else {
+            #if !defined(MA_HAS_CUSTOM)
+                result = MA_BACKEND_NOT_ENABLED;
+            #else
+                result = MA_NO_BACKEND;
+            #endif
+            }
+        }
+
+        /* If this iteration was successful, return. */
+        if (result == MA_SUCCESS) {
+            result = ma_mutex_init(&pContext->deviceEnumLock);
+            if (result != MA_SUCCESS) {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "Failed to initialize mutex for device enumeration. ma_context_get_devices() is not thread safe.\n");
+            }
+
+            result = ma_mutex_init(&pContext->deviceInfoLock);
+            if (result != MA_SUCCESS) {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_WARNING, "Failed to initialize mutex for device info retrieval. ma_context_get_device_info() is not thread safe.\n");
+            }
+
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "System Architecture:\n");
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "  Endian: %s\n", ma_is_little_endian() ? "LE"  : "BE");
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "  SSE2:   %s\n", ma_has_sse2()         ? "YES" : "NO");
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "  AVX2:   %s\n", ma_has_avx2()         ? "YES" : "NO");
+            ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "  NEON:   %s\n", ma_has_neon()         ? "YES" : "NO");
+
+            pContext->backend = backend;
+            return result;
+        } else {
+            if (result == MA_BACKEND_NOT_ENABLED) {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "%s backend is disabled.\n", ma_get_backend_name(backend));
+            } else {
+                ma_log_postf(ma_context_get_log(pContext), MA_LOG_LEVEL_DEBUG, "Failed to initialize %s backend.\n", ma_get_backend_name(backend));
+            }
+        }
+    }
+
+    /* If we get here it means an error occurred. */
+    MA_ZERO_OBJECT(pContext);  /* Safety. */
+    return MA_NO_BACKEND;
+}
+
+MA_API ma_result ma_context_uninit(ma_context* pContext)
+{
+    if (pContext == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pContext->callbacks.onContextUninit != NULL) {
+        pContext->callbacks.onContextUninit(pContext);
+    }
+
+    ma_mutex_uninit(&pContext->deviceEnumLock);
+    ma_mutex_uninit(&pContext->deviceInfoLock);
+    ma_free(pContext->pDeviceInfos, &pContext->allocationCallbacks);
+    ma_context_uninit_backend_apis(pContext);
+
+    if (pContext->pLog == &pContext->log) {
+        ma_log_uninit(&pContext->log);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API size_t ma_context_sizeof(void)
+{
+    return sizeof(ma_context);
+}
+
+
+MA_API ma_log* ma_context_get_log(ma_context* pContext)
+{
+    if (pContext == NULL) {
+        return NULL;
+    }
+
+    return pContext->pLog;
+}
+
+
+MA_API ma_result ma_context_enumerate_devices(ma_context* pContext, ma_enum_devices_callback_proc callback, void* pUserData)
+{
+    ma_result result;
+
+    if (pContext == NULL || callback == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pContext->callbacks.onContextEnumerateDevices == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    ma_mutex_lock(&pContext->deviceEnumLock);
+    {
+        result = pContext->callbacks.onContextEnumerateDevices(pContext, callback, pUserData);
+    }
+    ma_mutex_unlock(&pContext->deviceEnumLock);
+
+    return result;
+}
+
+
+static ma_bool32 ma_context_get_devices__enum_callback(ma_context* pContext, ma_device_type deviceType, const ma_device_info* pInfo, void* pUserData)
+{
+    /*
+    We need to insert the device info into our main internal buffer. Where it goes depends on the device type. If it's a capture device
+    it's just appended to the end. If it's a playback device it's inserted just before the first capture device.
+    */
+
+    /*
+    First make sure we have room. Since the number of devices we add to the list is usually relatively small I've decided to use a
+    simple fixed size increment for buffer expansion.
+    */
+    const ma_uint32 bufferExpansionCount = 2;
+    const ma_uint32 totalDeviceInfoCount = pContext->playbackDeviceInfoCount + pContext->captureDeviceInfoCount;
+
+    if (totalDeviceInfoCount >= pContext->deviceInfoCapacity) {
+        ma_uint32 newCapacity = pContext->deviceInfoCapacity + bufferExpansionCount;
+        ma_device_info* pNewInfos = (ma_device_info*)ma_realloc(pContext->pDeviceInfos, sizeof(*pContext->pDeviceInfos)*newCapacity, &pContext->allocationCallbacks);
+        if (pNewInfos == NULL) {
+            return MA_FALSE;   /* Out of memory. */
+        }
+
+        pContext->pDeviceInfos = pNewInfos;
+        pContext->deviceInfoCapacity = newCapacity;
+    }
+
+    if (deviceType == ma_device_type_playback) {
+        /* Playback. Insert just before the first capture device. */
+
+        /* The first thing to do is move all of the capture devices down a slot. */
+        ma_uint32 iFirstCaptureDevice = pContext->playbackDeviceInfoCount;
+        size_t iCaptureDevice;
+        for (iCaptureDevice = totalDeviceInfoCount; iCaptureDevice > iFirstCaptureDevice; --iCaptureDevice) {
+            pContext->pDeviceInfos[iCaptureDevice] = pContext->pDeviceInfos[iCaptureDevice-1];
+        }
+
+        /* Now just insert where the first capture device was before moving it down a slot. */
+        pContext->pDeviceInfos[iFirstCaptureDevice] = *pInfo;
+        pContext->playbackDeviceInfoCount += 1;
+    } else {
+        /* Capture. Insert at the end. */
+        pContext->pDeviceInfos[totalDeviceInfoCount] = *pInfo;
+        pContext->captureDeviceInfoCount += 1;
+    }
+
+    (void)pUserData;
+    return MA_TRUE;
+}
+
+MA_API ma_result ma_context_get_devices(ma_context* pContext, ma_device_info** ppPlaybackDeviceInfos, ma_uint32* pPlaybackDeviceCount, ma_device_info** ppCaptureDeviceInfos, ma_uint32* pCaptureDeviceCount)
+{
+    ma_result result;
+
+    /* Safety. */
+    if (ppPlaybackDeviceInfos != NULL) *ppPlaybackDeviceInfos = NULL;
+    if (pPlaybackDeviceCount  != NULL) *pPlaybackDeviceCount  = 0;
+    if (ppCaptureDeviceInfos  != NULL) *ppCaptureDeviceInfos  = NULL;
+    if (pCaptureDeviceCount   != NULL) *pCaptureDeviceCount   = 0;
+
+    if (pContext == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pContext->callbacks.onContextEnumerateDevices == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* Note that we don't use ma_context_enumerate_devices() here because we want to do locking at a higher level. */
+    ma_mutex_lock(&pContext->deviceEnumLock);
+    {
+        /* Reset everything first. */
+        pContext->playbackDeviceInfoCount = 0;
+        pContext->captureDeviceInfoCount = 0;
+
+        /* Now enumerate over available devices. */
+        result = pContext->callbacks.onContextEnumerateDevices(pContext, ma_context_get_devices__enum_callback, NULL);
+        if (result == MA_SUCCESS) {
+            /* Playback devices. */
+            if (ppPlaybackDeviceInfos != NULL) {
+                *ppPlaybackDeviceInfos = pContext->pDeviceInfos;
+            }
+            if (pPlaybackDeviceCount != NULL) {
+                *pPlaybackDeviceCount = pContext->playbackDeviceInfoCount;
+            }
+
+            /* Capture devices. */
+            if (ppCaptureDeviceInfos != NULL) {
+                *ppCaptureDeviceInfos = pContext->pDeviceInfos;
+                /* Capture devices come after playback devices. */
+                if (pContext->playbackDeviceInfoCount > 0) {
+                    /* Conditional, because NULL+0 is undefined behavior. */
+                    *ppCaptureDeviceInfos += pContext->playbackDeviceInfoCount;
+                }
+            }
+            if (pCaptureDeviceCount != NULL) {
+                *pCaptureDeviceCount = pContext->captureDeviceInfoCount;
+            }
+        }
+    }
+    ma_mutex_unlock(&pContext->deviceEnumLock);
+
+    return result;
+}
+
+MA_API ma_result ma_context_get_device_info(ma_context* pContext, ma_device_type deviceType, const ma_device_id* pDeviceID, ma_device_info* pDeviceInfo)
+{
+    ma_result result;
+    ma_device_info deviceInfo;
+
+    /* NOTE: Do not clear pDeviceInfo on entry. The reason is the pDeviceID may actually point to pDeviceInfo->id which will break things. */
+    if (pContext == NULL || pDeviceInfo == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(&deviceInfo);
+
+    /* Help the backend out by copying over the device ID if we have one. */
+    if (pDeviceID != NULL) {
+        MA_COPY_MEMORY(&deviceInfo.id, pDeviceID, sizeof(*pDeviceID));
+    }
+
+    if (pContext->callbacks.onContextGetDeviceInfo == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    ma_mutex_lock(&pContext->deviceInfoLock);
+    {
+        result = pContext->callbacks.onContextGetDeviceInfo(pContext, deviceType, pDeviceID, &deviceInfo);
+    }
+    ma_mutex_unlock(&pContext->deviceInfoLock);
+
+    *pDeviceInfo = deviceInfo;
+    return result;
+}
+
+MA_API ma_bool32 ma_context_is_loopback_supported(ma_context* pContext)
+{
+    if (pContext == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_is_loopback_supported(pContext->backend);
+}
+
+
+MA_API ma_device_config ma_device_config_init(ma_device_type deviceType)
+{
+    ma_device_config config;
+    MA_ZERO_OBJECT(&config);
+    config.deviceType = deviceType;
+    config.resampling = ma_resampler_config_init(ma_format_unknown, 0, 0, 0, ma_resample_algorithm_linear); /* Format/channels/rate don't matter here. */
+
+    return config;
+}
+
+MA_API ma_result ma_device_init(ma_context* pContext, const ma_device_config* pConfig, ma_device* pDevice)
+{
+    ma_result result;
+    ma_device_descriptor descriptorPlayback;
+    ma_device_descriptor descriptorCapture;
+
+    /* The context can be null, in which case we self-manage it. */
+    if (pContext == NULL) {
+        return ma_device_init_ex(NULL, 0, NULL, pConfig, pDevice);
+    }
+
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDevice);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Check that we have our callbacks defined. */
+    if (pContext->callbacks.onDeviceInit == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* Basic config validation. */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex) {
+        if (pConfig->capture.channels > MA_MAX_CHANNELS) {
+            return MA_INVALID_ARGS;
+        }
+
+        if (!ma__is_channel_map_valid(pConfig->capture.pChannelMap, pConfig->capture.channels)) {
+            return MA_INVALID_ARGS;
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) {
+        if (pConfig->playback.channels > MA_MAX_CHANNELS) {
+            return MA_INVALID_ARGS;
+        }
+
+        if (!ma__is_channel_map_valid(pConfig->playback.pChannelMap, pConfig->playback.channels)) {
+            return MA_INVALID_ARGS;
+        }
+    }
+
+    pDevice->pContext = pContext;
+
+    /* Set the user data and log callback ASAP to ensure it is available for the entire initialization process. */
+    pDevice->pUserData      = pConfig->pUserData;
+    pDevice->onData         = pConfig->dataCallback;
+    pDevice->onNotification = pConfig->notificationCallback;
+    pDevice->onStop         = pConfig->stopCallback;
+
+    if (pConfig->playback.pDeviceID != NULL) {
+        MA_COPY_MEMORY(&pDevice->playback.id, pConfig->playback.pDeviceID, sizeof(pDevice->playback.id));
+        pDevice->playback.pID = &pDevice->playback.id;
+    } else {
+        pDevice->playback.pID = NULL;
+    }
+
+    if (pConfig->capture.pDeviceID != NULL) {
+        MA_COPY_MEMORY(&pDevice->capture.id, pConfig->capture.pDeviceID, sizeof(pDevice->capture.id));
+        pDevice->capture.pID = &pDevice->capture.id;
+    } else {
+        pDevice->capture.pID = NULL;
+    }
+
+    pDevice->noPreSilencedOutputBuffer   = pConfig->noPreSilencedOutputBuffer;
+    pDevice->noClip                      = pConfig->noClip;
+    pDevice->noDisableDenormals          = pConfig->noDisableDenormals;
+    pDevice->noFixedSizedCallback        = pConfig->noFixedSizedCallback;
+    ma_atomic_float_set(&pDevice->masterVolumeFactor, 1);
+
+    pDevice->type                        = pConfig->deviceType;
+    pDevice->sampleRate                  = pConfig->sampleRate;
+    pDevice->resampling.algorithm        = pConfig->resampling.algorithm;
+    pDevice->resampling.linear.lpfOrder  = pConfig->resampling.linear.lpfOrder;
+    pDevice->resampling.pBackendVTable   = pConfig->resampling.pBackendVTable;
+    pDevice->resampling.pBackendUserData = pConfig->resampling.pBackendUserData;
+
+    pDevice->capture.shareMode           = pConfig->capture.shareMode;
+    pDevice->capture.format              = pConfig->capture.format;
+    pDevice->capture.channels            = pConfig->capture.channels;
+    ma_channel_map_copy_or_default(pDevice->capture.channelMap, ma_countof(pDevice->capture.channelMap), pConfig->capture.pChannelMap, pConfig->capture.channels);
+    pDevice->capture.channelMixMode      = pConfig->capture.channelMixMode;
+    pDevice->capture.calculateLFEFromSpatialChannels = pConfig->capture.calculateLFEFromSpatialChannels;
+
+    pDevice->playback.shareMode          = pConfig->playback.shareMode;
+    pDevice->playback.format             = pConfig->playback.format;
+    pDevice->playback.channels           = pConfig->playback.channels;
+    ma_channel_map_copy_or_default(pDevice->playback.channelMap, ma_countof(pDevice->playback.channelMap), pConfig->playback.pChannelMap, pConfig->playback.channels);
+    pDevice->playback.channelMixMode     = pConfig->playback.channelMixMode;
+    pDevice->playback.calculateLFEFromSpatialChannels = pConfig->playback.calculateLFEFromSpatialChannels;
+
+    result = ma_mutex_init(&pDevice->startStopLock);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /*
+    When the device is started, the worker thread is the one that does the actual startup of the backend device. We
+    use a semaphore to wait for the background thread to finish the work. The same applies for stopping the device.
+
+    Each of these semaphores is released internally by the worker thread when the work is completed. The start
+    semaphore is also used to wake up the worker thread.
+    */
+    result = ma_event_init(&pDevice->wakeupEvent);
+    if (result != MA_SUCCESS) {
+        ma_mutex_uninit(&pDevice->startStopLock);
+        return result;
+    }
+
+    result = ma_event_init(&pDevice->startEvent);
+    if (result != MA_SUCCESS) {
+        ma_event_uninit(&pDevice->wakeupEvent);
+        ma_mutex_uninit(&pDevice->startStopLock);
+        return result;
+    }
+
+    result = ma_event_init(&pDevice->stopEvent);
+    if (result != MA_SUCCESS) {
+        ma_event_uninit(&pDevice->startEvent);
+        ma_event_uninit(&pDevice->wakeupEvent);
+        ma_mutex_uninit(&pDevice->startStopLock);
+        return result;
+    }
+
+
+    MA_ZERO_OBJECT(&descriptorPlayback);
+    descriptorPlayback.pDeviceID                = pConfig->playback.pDeviceID;
+    descriptorPlayback.shareMode                = pConfig->playback.shareMode;
+    descriptorPlayback.format                   = pConfig->playback.format;
+    descriptorPlayback.channels                 = pConfig->playback.channels;
+    descriptorPlayback.sampleRate               = pConfig->sampleRate;
+    ma_channel_map_copy_or_default(descriptorPlayback.channelMap, ma_countof(descriptorPlayback.channelMap), pConfig->playback.pChannelMap, pConfig->playback.channels);
+    descriptorPlayback.periodSizeInFrames       = pConfig->periodSizeInFrames;
+    descriptorPlayback.periodSizeInMilliseconds = pConfig->periodSizeInMilliseconds;
+    descriptorPlayback.periodCount              = pConfig->periods;
+
+    if (descriptorPlayback.periodCount == 0) {
+        descriptorPlayback.periodCount = MA_DEFAULT_PERIODS;
+    }
+
+
+    MA_ZERO_OBJECT(&descriptorCapture);
+    descriptorCapture.pDeviceID                 = pConfig->capture.pDeviceID;
+    descriptorCapture.shareMode                 = pConfig->capture.shareMode;
+    descriptorCapture.format                    = pConfig->capture.format;
+    descriptorCapture.channels                  = pConfig->capture.channels;
+    descriptorCapture.sampleRate                = pConfig->sampleRate;
+    ma_channel_map_copy_or_default(descriptorCapture.channelMap, ma_countof(descriptorCapture.channelMap), pConfig->capture.pChannelMap, pConfig->capture.channels);
+    descriptorCapture.periodSizeInFrames        = pConfig->periodSizeInFrames;
+    descriptorCapture.periodSizeInMilliseconds  = pConfig->periodSizeInMilliseconds;
+    descriptorCapture.periodCount               = pConfig->periods;
+
+    if (descriptorCapture.periodCount == 0) {
+        descriptorCapture.periodCount = MA_DEFAULT_PERIODS;
+    }
+
+
+    result = pContext->callbacks.onDeviceInit(pDevice, pConfig, &descriptorPlayback, &descriptorCapture);
+    if (result != MA_SUCCESS) {
+        ma_event_uninit(&pDevice->startEvent);
+        ma_event_uninit(&pDevice->wakeupEvent);
+        ma_mutex_uninit(&pDevice->startStopLock);
+        return result;
+    }
+
+#if 0
+    /*
+    On output the descriptors will contain the *actual* data format of the device. We need this to know how to convert the data between
+    the requested format and the internal format.
+    */
+    if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) {
+        if (!ma_device_descriptor_is_valid(&descriptorCapture)) {
+            ma_device_uninit(pDevice);
+            return MA_INVALID_ARGS;
+        }
+
+        pDevice->capture.internalFormat             = descriptorCapture.format;
+        pDevice->capture.internalChannels           = descriptorCapture.channels;
+        pDevice->capture.internalSampleRate         = descriptorCapture.sampleRate;
+        ma_channel_map_copy(pDevice->capture.internalChannelMap, descriptorCapture.channelMap, descriptorCapture.channels);
+        pDevice->capture.internalPeriodSizeInFrames = descriptorCapture.periodSizeInFrames;
+        pDevice->capture.internalPeriods            = descriptorCapture.periodCount;
+
+        if (pDevice->capture.internalPeriodSizeInFrames == 0) {
+            pDevice->capture.internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(descriptorCapture.periodSizeInMilliseconds, descriptorCapture.sampleRate);
+        }
+    }
+
+    if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+        if (!ma_device_descriptor_is_valid(&descriptorPlayback)) {
+            ma_device_uninit(pDevice);
+            return MA_INVALID_ARGS;
+        }
+
+        pDevice->playback.internalFormat             = descriptorPlayback.format;
+        pDevice->playback.internalChannels           = descriptorPlayback.channels;
+        pDevice->playback.internalSampleRate         = descriptorPlayback.sampleRate;
+        ma_channel_map_copy(pDevice->playback.internalChannelMap, descriptorPlayback.channelMap, descriptorPlayback.channels);
+        pDevice->playback.internalPeriodSizeInFrames = descriptorPlayback.periodSizeInFrames;
+        pDevice->playback.internalPeriods            = descriptorPlayback.periodCount;
+
+        if (pDevice->playback.internalPeriodSizeInFrames == 0) {
+            pDevice->playback.internalPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(descriptorPlayback.periodSizeInMilliseconds, descriptorPlayback.sampleRate);
+        }
+    }
+
+
+    /*
+    The name of the device can be retrieved from device info. This may be temporary and replaced with a `ma_device_get_info(pDevice, deviceType)` instead.
+    For loopback devices, we need to retrieve the name of the playback device.
+    */
+    {
+        ma_device_info deviceInfo;
+
+        if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) {
+            result = ma_device_get_info(pDevice, (pConfig->deviceType == ma_device_type_loopback) ? ma_device_type_playback : ma_device_type_capture, &deviceInfo);
+            if (result == MA_SUCCESS) {
+                ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), deviceInfo.name, (size_t)-1);
+            } else {
+                /* We failed to retrieve the device info. Fall back to a default name. */
+                if (descriptorCapture.pDeviceID == NULL) {
+                    ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), MA_DEFAULT_CAPTURE_DEVICE_NAME, (size_t)-1);
+                } else {
+                    ma_strncpy_s(pDevice->capture.name, sizeof(pDevice->capture.name), "Capture Device", (size_t)-1);
+                }
+            }
+        }
+
+        if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+            result = ma_device_get_info(pDevice, ma_device_type_playback, &deviceInfo);
+            if (result == MA_SUCCESS) {
+                ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), deviceInfo.name, (size_t)-1);
+            } else {
+                /* We failed to retrieve the device info. Fall back to a default name. */
+                if (descriptorPlayback.pDeviceID == NULL) {
+                    ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), MA_DEFAULT_PLAYBACK_DEVICE_NAME, (size_t)-1);
+                } else {
+                    ma_strncpy_s(pDevice->playback.name, sizeof(pDevice->playback.name), "Playback Device", (size_t)-1);
+                }
+            }
+        }
+    }
+
+
+    ma_device__post_init_setup(pDevice, pConfig->deviceType);
+#endif
+
+    result = ma_device_post_init(pDevice, pConfig->deviceType, &descriptorPlayback, &descriptorCapture);
+    if (result != MA_SUCCESS) {
+        ma_device_uninit(pDevice);
+        return result;
+    }
+
+
+    /*
+    If we're using fixed sized callbacks we'll need to make use of an intermediary buffer. Needs to
+    be done after post_init_setup() because we'll need access to the sample rate.
+    */
+    if (pConfig->noFixedSizedCallback == MA_FALSE) {
+        /* We're using a fixed sized data callback so we'll need an intermediary buffer. */
+        ma_uint32 intermediaryBufferCap = pConfig->periodSizeInFrames;
+        if (intermediaryBufferCap == 0) {
+            intermediaryBufferCap = ma_calculate_buffer_size_in_frames_from_milliseconds(pConfig->periodSizeInMilliseconds, pDevice->sampleRate);
+        }
+
+        if (pConfig->deviceType == ma_device_type_capture || pConfig->deviceType == ma_device_type_duplex || pConfig->deviceType == ma_device_type_loopback) {
+            ma_uint32 intermediaryBufferSizeInBytes;
+
+            pDevice->capture.intermediaryBufferLen = 0;
+            pDevice->capture.intermediaryBufferCap = intermediaryBufferCap;
+            if (pDevice->capture.intermediaryBufferCap == 0) {
+                pDevice->capture.intermediaryBufferCap = pDevice->capture.internalPeriodSizeInFrames;
+            }
+
+            intermediaryBufferSizeInBytes = pDevice->capture.intermediaryBufferCap * ma_get_bytes_per_frame(pDevice->capture.format, pDevice->capture.channels);
+
+            pDevice->capture.pIntermediaryBuffer = ma_malloc((size_t)intermediaryBufferSizeInBytes, &pContext->allocationCallbacks);
+            if (pDevice->capture.pIntermediaryBuffer == NULL) {
+                ma_device_uninit(pDevice);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            /* Silence the buffer for safety. */
+            ma_silence_pcm_frames(pDevice->capture.pIntermediaryBuffer, pDevice->capture.intermediaryBufferCap, pDevice->capture.format, pDevice->capture.channels);
+            pDevice->capture.intermediaryBufferLen = pDevice->capture.intermediaryBufferCap;
+        }
+
+        if (pConfig->deviceType == ma_device_type_playback || pConfig->deviceType == ma_device_type_duplex) {
+            ma_uint64 intermediaryBufferSizeInBytes;
+
+            pDevice->playback.intermediaryBufferLen = 0;
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                pDevice->playback.intermediaryBufferCap = pDevice->capture.intermediaryBufferCap;   /* In duplex mode, make sure the intermediary buffer is always the same size as the capture side. */
+            } else {
+                pDevice->playback.intermediaryBufferCap = intermediaryBufferCap;
+                if (pDevice->playback.intermediaryBufferCap == 0) {
+                    pDevice->playback.intermediaryBufferCap = pDevice->playback.internalPeriodSizeInFrames;
+                }
+            }
+
+            intermediaryBufferSizeInBytes = pDevice->playback.intermediaryBufferCap * ma_get_bytes_per_frame(pDevice->playback.format, pDevice->playback.channels);
+
+            pDevice->playback.pIntermediaryBuffer = ma_malloc((size_t)intermediaryBufferSizeInBytes, &pContext->allocationCallbacks);
+            if (pDevice->playback.pIntermediaryBuffer == NULL) {
+                ma_device_uninit(pDevice);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            /* Silence the buffer for safety. */
+            ma_silence_pcm_frames(pDevice->playback.pIntermediaryBuffer, pDevice->playback.intermediaryBufferCap, pDevice->playback.format, pDevice->playback.channels);
+            pDevice->playback.intermediaryBufferLen = 0;
+        }
+    } else {
+        /* Not using a fixed sized data callback so no need for an intermediary buffer. */
+    }
+
+
+    /* Some backends don't require the worker thread. */
+    if (!ma_context_is_backend_asynchronous(pContext)) {
+        /* The worker thread. */
+        result = ma_thread_create(&pDevice->thread, pContext->threadPriority, pContext->threadStackSize, ma_worker_thread, pDevice, &pContext->allocationCallbacks);
+        if (result != MA_SUCCESS) {
+            ma_device_uninit(pDevice);
+            return result;
+        }
+
+        /* Wait for the worker thread to put the device into it's stopped state for real. */
+        ma_event_wait(&pDevice->stopEvent);
+        MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_stopped);
+    } else {
+        /*
+        If the backend is asynchronous and the device is duplex, we'll need an intermediary ring buffer. Note that this needs to be done
+        after ma_device__post_init_setup().
+        */
+        if (ma_context_is_backend_asynchronous(pContext)) {
+            if (pConfig->deviceType == ma_device_type_duplex) {
+                result = ma_duplex_rb_init(pDevice->capture.format, pDevice->capture.channels, pDevice->sampleRate, pDevice->capture.internalSampleRate, pDevice->capture.internalPeriodSizeInFrames, &pDevice->pContext->allocationCallbacks, &pDevice->duplexRB);
+                if (result != MA_SUCCESS) {
+                    ma_device_uninit(pDevice);
+                    return result;
+                }
+            }
+        }
+
+        ma_device__set_state(pDevice, ma_device_state_stopped);
+    }
+
+    /* Log device information. */
+    {
+        ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[%s]\n", ma_get_backend_name(pDevice->pContext->backend));
+        if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+            char name[MA_MAX_DEVICE_NAME_LENGTH + 1];
+            ma_device_get_name(pDevice, (pDevice->type == ma_device_type_loopback) ? ma_device_type_playback : ma_device_type_capture, name, sizeof(name), NULL);
+
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "  %s (%s)\n", name, "Capture");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Format:      %s -> %s\n", ma_get_format_name(pDevice->capture.internalFormat), ma_get_format_name(pDevice->capture.format));
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Channels:    %d -> %d\n", pDevice->capture.internalChannels, pDevice->capture.channels);
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Sample Rate: %d -> %d\n", pDevice->capture.internalSampleRate, pDevice->sampleRate);
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Buffer Size: %d*%d (%d)\n", pDevice->capture.internalPeriodSizeInFrames, pDevice->capture.internalPeriods, (pDevice->capture.internalPeriodSizeInFrames * pDevice->capture.internalPeriods));
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Conversion:\n");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Pre Format Conversion:  %s\n", pDevice->capture.converter.hasPreFormatConversion  ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Post Format Conversion: %s\n", pDevice->capture.converter.hasPostFormatConversion ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Routing:        %s\n", pDevice->capture.converter.hasChannelConverter     ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Resampling:             %s\n", pDevice->capture.converter.hasResampler            ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Passthrough:            %s\n", pDevice->capture.converter.isPassthrough           ? "YES" : "NO");
+            {
+                char channelMapStr[1024];
+                ma_channel_map_to_string(pDevice->capture.internalChannelMap, pDevice->capture.internalChannels, channelMapStr, sizeof(channelMapStr));
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Map In:         {%s}\n", channelMapStr);
+
+                ma_channel_map_to_string(pDevice->capture.channelMap, pDevice->capture.channels, channelMapStr, sizeof(channelMapStr));
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Map Out:        {%s}\n", channelMapStr);
+            }
+        }
+        if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+            char name[MA_MAX_DEVICE_NAME_LENGTH + 1];
+            ma_device_get_name(pDevice, ma_device_type_playback, name, sizeof(name), NULL);
+
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "  %s (%s)\n", name, "Playback");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Format:      %s -> %s\n", ma_get_format_name(pDevice->playback.format), ma_get_format_name(pDevice->playback.internalFormat));
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Channels:    %d -> %d\n", pDevice->playback.channels, pDevice->playback.internalChannels);
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Sample Rate: %d -> %d\n", pDevice->sampleRate, pDevice->playback.internalSampleRate);
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Buffer Size: %d*%d (%d)\n", pDevice->playback.internalPeriodSizeInFrames, pDevice->playback.internalPeriods, (pDevice->playback.internalPeriodSizeInFrames * pDevice->playback.internalPeriods));
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "    Conversion:\n");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Pre Format Conversion:  %s\n", pDevice->playback.converter.hasPreFormatConversion  ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Post Format Conversion: %s\n", pDevice->playback.converter.hasPostFormatConversion ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Routing:        %s\n", pDevice->playback.converter.hasChannelConverter     ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Resampling:             %s\n", pDevice->playback.converter.hasResampler            ? "YES" : "NO");
+            ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Passthrough:            %s\n", pDevice->playback.converter.isPassthrough           ? "YES" : "NO");
+            {
+                char channelMapStr[1024];
+                ma_channel_map_to_string(pDevice->playback.channelMap, pDevice->playback.channels, channelMapStr, sizeof(channelMapStr));
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Map In:         {%s}\n", channelMapStr);
+
+                ma_channel_map_to_string(pDevice->playback.internalChannelMap, pDevice->playback.internalChannels, channelMapStr, sizeof(channelMapStr));
+                ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "      Channel Map Out:        {%s}\n", channelMapStr);
+            }
+        }
+    }
+
+    MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_stopped);
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_device_init_ex(const ma_backend backends[], ma_uint32 backendCount, const ma_context_config* pContextConfig, const ma_device_config* pConfig, ma_device* pDevice)
+{
+    ma_result result;
+    ma_context* pContext;
+    ma_backend defaultBackends[ma_backend_null+1];
+    ma_uint32 iBackend;
+    ma_backend* pBackendsToIterate;
+    ma_uint32 backendsToIterateCount;
+    ma_allocation_callbacks allocationCallbacks;
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pContextConfig != NULL) {
+        result = ma_allocation_callbacks_init_copy(&allocationCallbacks, &pContextConfig->allocationCallbacks);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    } else {
+        allocationCallbacks = ma_allocation_callbacks_init_default();
+    }
+
+    pContext = (ma_context*)ma_malloc(sizeof(*pContext), &allocationCallbacks);
+    if (pContext == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    for (iBackend = 0; iBackend <= ma_backend_null; ++iBackend) {
+        defaultBackends[iBackend] = (ma_backend)iBackend;
+    }
+
+    pBackendsToIterate = (ma_backend*)backends;
+    backendsToIterateCount = backendCount;
+    if (pBackendsToIterate == NULL) {
+        pBackendsToIterate = (ma_backend*)defaultBackends;
+        backendsToIterateCount = ma_countof(defaultBackends);
+    }
+
+    result = MA_NO_BACKEND;
+
+    for (iBackend = 0; iBackend < backendsToIterateCount; ++iBackend) {
+        /*
+        This is a hack for iOS. If the context config is null, there's a good chance the
+        `ma_device_init(NULL, &deviceConfig, pDevice);` pattern is being used. In this
+        case, set the session category based on the device type.
+        */
+    #if defined(MA_APPLE_MOBILE)
+        ma_context_config contextConfig;
+
+        if (pContextConfig == NULL) {
+            contextConfig = ma_context_config_init();
+            switch (pConfig->deviceType) {
+                case ma_device_type_duplex: {
+                    contextConfig.coreaudio.sessionCategory = ma_ios_session_category_play_and_record;
+                } break;
+                case ma_device_type_capture: {
+                    contextConfig.coreaudio.sessionCategory = ma_ios_session_category_record;
+                } break;
+                case ma_device_type_playback:
+                default: {
+                    contextConfig.coreaudio.sessionCategory = ma_ios_session_category_playback;
+                } break;
+            }
+
+            pContextConfig = &contextConfig;
+        }
+    #endif
+
+        result = ma_context_init(&pBackendsToIterate[iBackend], 1, pContextConfig, pContext);
+        if (result == MA_SUCCESS) {
+            result = ma_device_init(pContext, pConfig, pDevice);
+            if (result == MA_SUCCESS) {
+                break;  /* Success. */
+            } else {
+                ma_context_uninit(pContext);   /* Failure. */
+            }
+        }
+    }
+
+    if (result != MA_SUCCESS) {
+        ma_free(pContext, &allocationCallbacks);
+        return result;
+    }
+
+    pDevice->isOwnerOfContext = MA_TRUE;
+    return result;
+}
+
+MA_API void ma_device_uninit(ma_device* pDevice)
+{
+    if (!ma_device__is_initialized(pDevice)) {
+        return;
+    }
+
+    /*
+    It's possible for the miniaudio side of the device and the backend to not be in sync due to
+    system-level situations such as the computer being put into sleep mode and the backend not
+    notifying miniaudio of the fact the device has stopped. It's possible for this to result in a
+    deadlock due to miniaudio thinking the device is in a running state, when in fact it's not
+    running at all. For this reason I am no longer explicitly stopping the device. I don't think
+    this should affect anyone in practice since uninitializing the backend will naturally stop the
+    device anyway.
+    */
+    #if 0
+    {
+        /* Make sure the device is stopped first. The backends will probably handle this naturally, but I like to do it explicitly for my own sanity. */
+        if (ma_device_is_started(pDevice)) {
+            ma_device_stop(pDevice);
+        }
+    }
+    #endif
+
+    /* Putting the device into an uninitialized state will make the worker thread return. */
+    ma_device__set_state(pDevice, ma_device_state_uninitialized);
+
+    /* Wake up the worker thread and wait for it to properly terminate. */
+    if (!ma_context_is_backend_asynchronous(pDevice->pContext)) {
+        ma_event_signal(&pDevice->wakeupEvent);
+        ma_thread_wait(&pDevice->thread);
+    }
+
+    if (pDevice->pContext->callbacks.onDeviceUninit != NULL) {
+        pDevice->pContext->callbacks.onDeviceUninit(pDevice);
+    }
+
+
+    ma_event_uninit(&pDevice->stopEvent);
+    ma_event_uninit(&pDevice->startEvent);
+    ma_event_uninit(&pDevice->wakeupEvent);
+    ma_mutex_uninit(&pDevice->startStopLock);
+
+    if (ma_context_is_backend_asynchronous(pDevice->pContext)) {
+        if (pDevice->type == ma_device_type_duplex) {
+            ma_duplex_rb_uninit(&pDevice->duplexRB);
+        }
+    }
+
+    if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_duplex || pDevice->type == ma_device_type_loopback) {
+        ma_data_converter_uninit(&pDevice->capture.converter, &pDevice->pContext->allocationCallbacks);
+    }
+    if (pDevice->type == ma_device_type_playback || pDevice->type == ma_device_type_duplex) {
+        ma_data_converter_uninit(&pDevice->playback.converter, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if (pDevice->playback.pInputCache != NULL) {
+        ma_free(pDevice->playback.pInputCache, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if (pDevice->capture.pIntermediaryBuffer != NULL) {
+        ma_free(pDevice->capture.pIntermediaryBuffer, &pDevice->pContext->allocationCallbacks);
+    }
+    if (pDevice->playback.pIntermediaryBuffer != NULL) {
+        ma_free(pDevice->playback.pIntermediaryBuffer, &pDevice->pContext->allocationCallbacks);
+    }
+
+    if (pDevice->isOwnerOfContext) {
+        ma_allocation_callbacks allocationCallbacks = pDevice->pContext->allocationCallbacks;
+
+        ma_context_uninit(pDevice->pContext);
+        ma_free(pDevice->pContext, &allocationCallbacks);
+    }
+
+    MA_ZERO_OBJECT(pDevice);
+}
+
+MA_API ma_context* ma_device_get_context(ma_device* pDevice)
+{
+    if (pDevice == NULL) {
+        return NULL;
+    }
+
+    return pDevice->pContext;
+}
+
+MA_API ma_log* ma_device_get_log(ma_device* pDevice)
+{
+    return ma_context_get_log(ma_device_get_context(pDevice));
+}
+
+MA_API ma_result ma_device_get_info(ma_device* pDevice, ma_device_type type, ma_device_info* pDeviceInfo)
+{
+    if (pDeviceInfo == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDeviceInfo);
+
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If the onDeviceGetInfo() callback is set, use that. Otherwise we'll fall back to ma_context_get_device_info(). */
+    if (pDevice->pContext->callbacks.onDeviceGetInfo != NULL) {
+        return pDevice->pContext->callbacks.onDeviceGetInfo(pDevice, type, pDeviceInfo);
+    }
+
+    /* Getting here means onDeviceGetInfo is not implemented so we need to fall back to an alternative. */
+    if (type == ma_device_type_playback) {
+        return ma_context_get_device_info(pDevice->pContext, type, pDevice->playback.pID, pDeviceInfo);
+    } else {
+        return ma_context_get_device_info(pDevice->pContext, type, pDevice->capture.pID, pDeviceInfo);
+    }
+}
+
+MA_API ma_result ma_device_get_name(ma_device* pDevice, ma_device_type type, char* pName, size_t nameCap, size_t* pLengthNotIncludingNullTerminator)
+{
+    ma_result result;
+    ma_device_info deviceInfo;
+
+    if (pLengthNotIncludingNullTerminator != NULL) {
+        *pLengthNotIncludingNullTerminator = 0;
+    }
+
+    if (pName != NULL && nameCap > 0) {
+        pName[0] = '\0';
+    }
+
+    result = ma_device_get_info(pDevice, type, &deviceInfo);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pName != NULL) {
+        ma_strncpy_s(pName, nameCap, deviceInfo.name, (size_t)-1);
+
+        /*
+        For safety, make sure the length is based on the truncated output string rather than the
+        source. Otherwise the caller might assume the output buffer contains more content than it
+        actually does.
+        */
+        if (pLengthNotIncludingNullTerminator != NULL) {
+            *pLengthNotIncludingNullTerminator = strlen(pName);
+        }
+    } else {
+        /* Name not specified. Just report the length of the source string. */
+        if (pLengthNotIncludingNullTerminator != NULL) {
+            *pLengthNotIncludingNullTerminator = strlen(deviceInfo.name);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_device_start(ma_device* pDevice)
+{
+    ma_result result;
+
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_device_get_state(pDevice) == ma_device_state_uninitialized) {
+        return MA_INVALID_OPERATION;    /* Not initialized. */
+    }
+
+    if (ma_device_get_state(pDevice) == ma_device_state_started) {
+        return MA_SUCCESS;  /* Already started. */
+    }
+
+    ma_mutex_lock(&pDevice->startStopLock);
+    {
+        /* Starting and stopping are wrapped in a mutex which means we can assert that the device is in a stopped or paused state. */
+        MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_stopped);
+
+        ma_device__set_state(pDevice, ma_device_state_starting);
+
+        /* Asynchronous backends need to be handled differently. */
+        if (ma_context_is_backend_asynchronous(pDevice->pContext)) {
+            if (pDevice->pContext->callbacks.onDeviceStart != NULL) {
+                result = pDevice->pContext->callbacks.onDeviceStart(pDevice);
+            } else {
+                result = MA_INVALID_OPERATION;
+            }
+
+            if (result == MA_SUCCESS) {
+                ma_device__set_state(pDevice, ma_device_state_started);
+                ma_device__on_notification_started(pDevice);
+            }
+        } else {
+            /*
+            Synchronous backends are started by signaling an event that's being waited on in the worker thread. We first wake up the
+            thread and then wait for the start event.
+            */
+            ma_event_signal(&pDevice->wakeupEvent);
+
+            /*
+            Wait for the worker thread to finish starting the device. Note that the worker thread will be the one who puts the device
+            into the started state. Don't call ma_device__set_state() here.
+            */
+            ma_event_wait(&pDevice->startEvent);
+            result = pDevice->workResult;
+        }
+
+        /* We changed the state from stopped to started, so if we failed, make sure we put the state back to stopped. */
+        if (result != MA_SUCCESS) {
+            ma_device__set_state(pDevice, ma_device_state_stopped);
+        }
+    }
+    ma_mutex_unlock(&pDevice->startStopLock);
+
+    return result;
+}
+
+MA_API ma_result ma_device_stop(ma_device* pDevice)
+{
+    ma_result result;
+
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_device_get_state(pDevice) == ma_device_state_uninitialized) {
+        return MA_INVALID_OPERATION;    /* Not initialized. */
+    }
+
+    if (ma_device_get_state(pDevice) == ma_device_state_stopped) {
+        return MA_SUCCESS;  /* Already stopped. */
+    }
+
+    ma_mutex_lock(&pDevice->startStopLock);
+    {
+        /* Starting and stopping are wrapped in a mutex which means we can assert that the device is in a started or paused state. */
+        MA_ASSERT(ma_device_get_state(pDevice) == ma_device_state_started);
+
+        ma_device__set_state(pDevice, ma_device_state_stopping);
+
+        /* Asynchronous backends need to be handled differently. */
+        if (ma_context_is_backend_asynchronous(pDevice->pContext)) {
+            /* Asynchronous backends must have a stop operation. */
+            if (pDevice->pContext->callbacks.onDeviceStop != NULL) {
+                result = pDevice->pContext->callbacks.onDeviceStop(pDevice);
+            } else {
+                result = MA_INVALID_OPERATION;
+            }
+
+            ma_device__set_state(pDevice, ma_device_state_stopped);
+        } else {
+            /*
+            Synchronous backends. The stop callback is always called from the worker thread. Do not call the stop callback here. If
+            the backend is implementing it's own audio thread loop we'll need to wake it up if required. Note that we need to make
+            sure the state of the device is *not* playing right now, which it shouldn't be since we set it above. This is super
+            important though, so I'm asserting it here as well for extra safety in case we accidentally change something later.
+            */
+            MA_ASSERT(ma_device_get_state(pDevice) != ma_device_state_started);
+
+            if (pDevice->pContext->callbacks.onDeviceDataLoopWakeup != NULL) {
+                pDevice->pContext->callbacks.onDeviceDataLoopWakeup(pDevice);
+            }
+
+            /*
+            We need to wait for the worker thread to become available for work before returning. Note that the worker thread will be
+            the one who puts the device into the stopped state. Don't call ma_device__set_state() here.
+            */
+            ma_event_wait(&pDevice->stopEvent);
+            result = MA_SUCCESS;
+        }
+
+        /*
+        This is a safety measure to ensure the internal buffer has been cleared so any leftover
+        does not get played the next time the device starts. Ideally this should be drained by
+        the backend first.
+        */
+        pDevice->playback.intermediaryBufferLen = 0;
+        pDevice->playback.inputCacheConsumed    = 0;
+        pDevice->playback.inputCacheRemaining   = 0;
+    }
+    ma_mutex_unlock(&pDevice->startStopLock);
+
+    return result;
+}
+
+MA_API ma_bool32 ma_device_is_started(const ma_device* pDevice)
+{
+    return ma_device_get_state(pDevice) == ma_device_state_started;
+}
+
+MA_API ma_device_state ma_device_get_state(const ma_device* pDevice)
+{
+    if (pDevice == NULL) {
+        return ma_device_state_uninitialized;
+    }
+
+    return ma_atomic_device_state_get((ma_atomic_device_state*)&pDevice->state);   /* Naughty cast to get rid of a const warning. */
+}
+
+MA_API ma_result ma_device_set_master_volume(ma_device* pDevice, float volume)
+{
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (volume < 0.0f) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_float_set(&pDevice->masterVolumeFactor, volume);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_device_get_master_volume(ma_device* pDevice, float* pVolume)
+{
+    if (pVolume == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDevice == NULL) {
+        *pVolume = 0;
+        return MA_INVALID_ARGS;
+    }
+
+    *pVolume = ma_atomic_float_get(&pDevice->masterVolumeFactor);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_device_set_master_volume_db(ma_device* pDevice, float gainDB)
+{
+    if (gainDB > 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_device_set_master_volume(pDevice, ma_volume_db_to_linear(gainDB));
+}
+
+MA_API ma_result ma_device_get_master_volume_db(ma_device* pDevice, float* pGainDB)
+{
+    float factor;
+    ma_result result;
+
+    if (pGainDB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_device_get_master_volume(pDevice, &factor);
+    if (result != MA_SUCCESS) {
+        *pGainDB = 0;
+        return result;
+    }
+
+    *pGainDB = ma_volume_linear_to_db(factor);
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_device_handle_backend_data_callback(ma_device* pDevice, void* pOutput, const void* pInput, ma_uint32 frameCount)
+{
+    if (pDevice == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pOutput == NULL && pInput == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDevice->type == ma_device_type_duplex) {
+        if (pInput != NULL) {
+            ma_device__handle_duplex_callback_capture(pDevice, frameCount, pInput, &pDevice->duplexRB.rb);
+        }
+
+        if (pOutput != NULL) {
+            ma_device__handle_duplex_callback_playback(pDevice, frameCount, pOutput, &pDevice->duplexRB.rb);
+        }
+    } else {
+        if (pDevice->type == ma_device_type_capture || pDevice->type == ma_device_type_loopback) {
+            if (pInput == NULL) {
+                return MA_INVALID_ARGS;
+            }
+
+            ma_device__send_frames_to_client(pDevice, frameCount, pInput);
+        }
+
+        if (pDevice->type == ma_device_type_playback) {
+            if (pOutput == NULL) {
+                return MA_INVALID_ARGS;
+            }
+
+            ma_device__read_frames_from_client(pDevice, frameCount, pOutput);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_calculate_buffer_size_in_frames_from_descriptor(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+    if (pDescriptor == NULL) {
+        return 0;
+    }
+
+    /*
+    We must have a non-0 native sample rate, but some backends don't allow retrieval of this at the
+    time when the size of the buffer needs to be determined. In this case we need to just take a best
+    guess and move on. We'll try using the sample rate in pDescriptor first. If that's not set we'll
+    just fall back to MA_DEFAULT_SAMPLE_RATE.
+    */
+    if (nativeSampleRate == 0) {
+        nativeSampleRate = pDescriptor->sampleRate;
+    }
+    if (nativeSampleRate == 0) {
+        nativeSampleRate = MA_DEFAULT_SAMPLE_RATE;
+    }
+
+    MA_ASSERT(nativeSampleRate != 0);
+
+    if (pDescriptor->periodSizeInFrames == 0) {
+        if (pDescriptor->periodSizeInMilliseconds == 0) {
+            if (performanceProfile == ma_performance_profile_low_latency) {
+                return ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_LOW_LATENCY, nativeSampleRate);
+            } else {
+                return ma_calculate_buffer_size_in_frames_from_milliseconds(MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE, nativeSampleRate);
+            }
+        } else {
+            return ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptor->periodSizeInMilliseconds, nativeSampleRate);
+        }
+    } else {
+        return pDescriptor->periodSizeInFrames;
+    }
+}
+#endif  /* MA_NO_DEVICE_IO */
+
+
+MA_API ma_uint32 ma_calculate_buffer_size_in_milliseconds_from_frames(ma_uint32 bufferSizeInFrames, ma_uint32 sampleRate)
+{
+    /* Prevent a division by zero. */
+    if (sampleRate == 0) {
+        return 0;
+    }
+
+    return bufferSizeInFrames*1000 / sampleRate;
+}
+
+MA_API ma_uint32 ma_calculate_buffer_size_in_frames_from_milliseconds(ma_uint32 bufferSizeInMilliseconds, ma_uint32 sampleRate)
+{
+    /* Prevent a division by zero. */
+    if (sampleRate == 0) {
+        return 0;
+    }
+
+    return bufferSizeInMilliseconds*sampleRate / 1000;
+}
+
+MA_API void ma_copy_pcm_frames(void* dst, const void* src, ma_uint64 frameCount, ma_format format, ma_uint32 channels)
+{
+    if (dst == src) {
+        return; /* No-op. */
+    }
+
+    ma_copy_memory_64(dst, src, frameCount * ma_get_bytes_per_frame(format, channels));
+}
+
+MA_API void ma_silence_pcm_frames(void* p, ma_uint64 frameCount, ma_format format, ma_uint32 channels)
+{
+    if (format == ma_format_u8) {
+        ma_uint64 sampleCount = frameCount * channels;
+        ma_uint64 iSample;
+        for (iSample = 0; iSample < sampleCount; iSample += 1) {
+            ((ma_uint8*)p)[iSample] = 128;
+        }
+    } else {
+        ma_zero_memory_64(p, frameCount * ma_get_bytes_per_frame(format, channels));
+    }
+}
+
+MA_API void* ma_offset_pcm_frames_ptr(void* p, ma_uint64 offsetInFrames, ma_format format, ma_uint32 channels)
+{
+    return ma_offset_ptr(p, offsetInFrames * ma_get_bytes_per_frame(format, channels));
+}
+
+MA_API const void* ma_offset_pcm_frames_const_ptr(const void* p, ma_uint64 offsetInFrames, ma_format format, ma_uint32 channels)
+{
+    return ma_offset_ptr(p, offsetInFrames * ma_get_bytes_per_frame(format, channels));
+}
+
+
+MA_API void ma_clip_samples_u8(ma_uint8* pDst, const ma_int16* pSrc, ma_uint64 count)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_u8(pSrc[iSample]);
+    }
+}
+
+MA_API void ma_clip_samples_s16(ma_int16* pDst, const ma_int32* pSrc, ma_uint64 count)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_s16(pSrc[iSample]);
+    }
+}
+
+MA_API void ma_clip_samples_s24(ma_uint8* pDst, const ma_int64* pSrc, ma_uint64 count)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        ma_int64 s = ma_clip_s24(pSrc[iSample]);
+        pDst[iSample*3 + 0] = (ma_uint8)((s & 0x000000FF) >>  0);
+        pDst[iSample*3 + 1] = (ma_uint8)((s & 0x0000FF00) >>  8);
+        pDst[iSample*3 + 2] = (ma_uint8)((s & 0x00FF0000) >> 16);
+    }
+}
+
+MA_API void ma_clip_samples_s32(ma_int32* pDst, const ma_int64* pSrc, ma_uint64 count)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_s32(pSrc[iSample]);
+    }
+}
+
+MA_API void ma_clip_samples_f32(float* pDst, const float* pSrc, ma_uint64 count)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_f32(pSrc[iSample]);
+    }
+}
+
+MA_API void ma_clip_pcm_frames(void* pDst, const void* pSrc, ma_uint64 frameCount, ma_format format, ma_uint32 channels)
+{
+    ma_uint64 sampleCount;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    sampleCount = frameCount * channels;
+
+    switch (format) {
+        case ma_format_u8:  ma_clip_samples_u8( (ma_uint8*)pDst, (const ma_int16*)pSrc, sampleCount); break;
+        case ma_format_s16: ma_clip_samples_s16((ma_int16*)pDst, (const ma_int32*)pSrc, sampleCount); break;
+        case ma_format_s24: ma_clip_samples_s24((ma_uint8*)pDst, (const ma_int64*)pSrc, sampleCount); break;
+        case ma_format_s32: ma_clip_samples_s32((ma_int32*)pDst, (const ma_int64*)pSrc, sampleCount); break;
+        case ma_format_f32: ma_clip_samples_f32((   float*)pDst, (const    float*)pSrc, sampleCount); break;
+
+        /* Do nothing if we don't know the format. We're including these here to silence a compiler warning about enums not being handled by the switch. */
+        case ma_format_unknown:
+        case ma_format_count:
+            break;
+    }
+}
+
+
+MA_API void ma_copy_and_apply_volume_factor_u8(ma_uint8* pSamplesOut, const ma_uint8* pSamplesIn, ma_uint64 sampleCount, float factor)
+{
+    ma_uint64 iSample;
+
+    if (pSamplesOut == NULL || pSamplesIn == NULL) {
+        return;
+    }
+
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamplesOut[iSample] = (ma_uint8)(pSamplesIn[iSample] * factor);
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_factor_s16(ma_int16* pSamplesOut, const ma_int16* pSamplesIn, ma_uint64 sampleCount, float factor)
+{
+    ma_uint64 iSample;
+
+    if (pSamplesOut == NULL || pSamplesIn == NULL) {
+        return;
+    }
+
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamplesOut[iSample] = (ma_int16)(pSamplesIn[iSample] * factor);
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_factor_s24(void* pSamplesOut, const void* pSamplesIn, ma_uint64 sampleCount, float factor)
+{
+    ma_uint64 iSample;
+    ma_uint8* pSamplesOut8;
+    ma_uint8* pSamplesIn8;
+
+    if (pSamplesOut == NULL || pSamplesIn == NULL) {
+        return;
+    }
+
+    pSamplesOut8 = (ma_uint8*)pSamplesOut;
+    pSamplesIn8  = (ma_uint8*)pSamplesIn;
+
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        ma_int32 sampleS32;
+
+        sampleS32 = (ma_int32)(((ma_uint32)(pSamplesIn8[iSample*3+0]) << 8) | ((ma_uint32)(pSamplesIn8[iSample*3+1]) << 16) | ((ma_uint32)(pSamplesIn8[iSample*3+2])) << 24);
+        sampleS32 = (ma_int32)(sampleS32 * factor);
+
+        pSamplesOut8[iSample*3+0] = (ma_uint8)(((ma_uint32)sampleS32 & 0x0000FF00) >>  8);
+        pSamplesOut8[iSample*3+1] = (ma_uint8)(((ma_uint32)sampleS32 & 0x00FF0000) >> 16);
+        pSamplesOut8[iSample*3+2] = (ma_uint8)(((ma_uint32)sampleS32 & 0xFF000000) >> 24);
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_factor_s32(ma_int32* pSamplesOut, const ma_int32* pSamplesIn, ma_uint64 sampleCount, float factor)
+{
+    ma_uint64 iSample;
+
+    if (pSamplesOut == NULL || pSamplesIn == NULL) {
+        return;
+    }
+
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamplesOut[iSample] = (ma_int32)(pSamplesIn[iSample] * factor);
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_factor_f32(float* pSamplesOut, const float* pSamplesIn, ma_uint64 sampleCount, float factor)
+{
+    ma_uint64 iSample;
+
+    if (pSamplesOut == NULL || pSamplesIn == NULL) {
+        return;
+    }
+
+    if (factor == 1) {
+        if (pSamplesOut == pSamplesIn) {
+            /* In place. No-op. */
+        } else {
+            /* Just a copy. */
+            for (iSample = 0; iSample < sampleCount; iSample += 1) {
+                pSamplesOut[iSample] = pSamplesIn[iSample];
+            }
+        }
+    } else {
+        for (iSample = 0; iSample < sampleCount; iSample += 1) {
+            pSamplesOut[iSample] = pSamplesIn[iSample] * factor;
+        }
+    }
+}
+
+MA_API void ma_apply_volume_factor_u8(ma_uint8* pSamples, ma_uint64 sampleCount, float factor)
+{
+    ma_copy_and_apply_volume_factor_u8(pSamples, pSamples, sampleCount, factor);
+}
+
+MA_API void ma_apply_volume_factor_s16(ma_int16* pSamples, ma_uint64 sampleCount, float factor)
+{
+    ma_copy_and_apply_volume_factor_s16(pSamples, pSamples, sampleCount, factor);
+}
+
+MA_API void ma_apply_volume_factor_s24(void* pSamples, ma_uint64 sampleCount, float factor)
+{
+    ma_copy_and_apply_volume_factor_s24(pSamples, pSamples, sampleCount, factor);
+}
+
+MA_API void ma_apply_volume_factor_s32(ma_int32* pSamples, ma_uint64 sampleCount, float factor)
+{
+    ma_copy_and_apply_volume_factor_s32(pSamples, pSamples, sampleCount, factor);
+}
+
+MA_API void ma_apply_volume_factor_f32(float* pSamples, ma_uint64 sampleCount, float factor)
+{
+    ma_copy_and_apply_volume_factor_f32(pSamples, pSamples, sampleCount, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_u8(ma_uint8* pFramesOut, const ma_uint8* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_u8(pFramesOut, pFramesIn, frameCount*channels, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s16(ma_int16* pFramesOut, const ma_int16* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_s16(pFramesOut, pFramesIn, frameCount*channels, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s24(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_s24(pFramesOut, pFramesIn, frameCount*channels, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_s32(ma_int32* pFramesOut, const ma_int32* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_s32(pFramesOut, pFramesIn, frameCount*channels, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_f32(pFramesOut, pFramesIn, frameCount*channels, factor);
+}
+
+MA_API void ma_copy_and_apply_volume_factor_pcm_frames(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float factor)
+{
+    switch (format)
+    {
+    case ma_format_u8:  ma_copy_and_apply_volume_factor_pcm_frames_u8 ((ma_uint8*)pFramesOut, (const ma_uint8*)pFramesIn, frameCount, channels, factor); return;
+    case ma_format_s16: ma_copy_and_apply_volume_factor_pcm_frames_s16((ma_int16*)pFramesOut, (const ma_int16*)pFramesIn, frameCount, channels, factor); return;
+    case ma_format_s24: ma_copy_and_apply_volume_factor_pcm_frames_s24(           pFramesOut,                  pFramesIn, frameCount, channels, factor); return;
+    case ma_format_s32: ma_copy_and_apply_volume_factor_pcm_frames_s32((ma_int32*)pFramesOut, (const ma_int32*)pFramesIn, frameCount, channels, factor); return;
+    case ma_format_f32: ma_copy_and_apply_volume_factor_pcm_frames_f32(   (float*)pFramesOut,    (const float*)pFramesIn, frameCount, channels, factor); return;
+    default: return;    /* Do nothing. */
+    }
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames_u8(ma_uint8* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames_u8(pFrames, pFrames, frameCount, channels, factor);
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames_s16(ma_int16* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames_s16(pFrames, pFrames, frameCount, channels, factor);
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames_s24(void* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames_s24(pFrames, pFrames, frameCount, channels, factor);
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames_s32(ma_int32* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames_s32(pFrames, pFrames, frameCount, channels, factor);
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames_f32(float* pFrames, ma_uint64 frameCount, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames_f32(pFrames, pFrames, frameCount, channels, factor);
+}
+
+MA_API void ma_apply_volume_factor_pcm_frames(void* pFramesOut, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float factor)
+{
+    ma_copy_and_apply_volume_factor_pcm_frames(pFramesOut, pFramesOut, frameCount, format, channels, factor);
+}
+
+
+MA_API void ma_copy_and_apply_volume_factor_per_channel_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, ma_uint32 channels, float* pChannelGains)
+{
+    ma_uint64 iFrame;
+
+    if (channels == 2) {
+        /* TODO: Do an optimized implementation for stereo and mono. Can do a SIMD optimized implementation as well. */
+    }
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            pFramesOut[iFrame * channels + iChannel] = pFramesIn[iFrame * channels + iChannel] * pChannelGains[iChannel];
+        }
+    }
+}
+
+
+
+static MA_INLINE ma_int16 ma_apply_volume_unclipped_u8(ma_int16 x, ma_int16 volume)
+{
+    return (ma_int16)(((ma_int32)x * (ma_int32)volume) >> 8);
+}
+
+static MA_INLINE ma_int32 ma_apply_volume_unclipped_s16(ma_int32 x, ma_int16 volume)
+{
+    return (ma_int32)((x * volume) >> 8);
+}
+
+static MA_INLINE ma_int64 ma_apply_volume_unclipped_s24(ma_int64 x, ma_int16 volume)
+{
+    return (ma_int64)((x * volume) >> 8);
+}
+
+static MA_INLINE ma_int64 ma_apply_volume_unclipped_s32(ma_int64 x, ma_int16 volume)
+{
+    return (ma_int64)((x * volume) >> 8);
+}
+
+static MA_INLINE float ma_apply_volume_unclipped_f32(float x, float volume)
+{
+    return x * volume;
+}
+
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_u8(ma_uint8* pDst, const ma_int16* pSrc, ma_uint64 count, float volume)
+{
+    ma_uint64 iSample;
+    ma_int16  volumeFixed;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    volumeFixed = ma_float_to_fixed_16(volume);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_u8(ma_apply_volume_unclipped_u8(pSrc[iSample], volumeFixed));
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s16(ma_int16* pDst, const ma_int32* pSrc, ma_uint64 count, float volume)
+{
+    ma_uint64 iSample;
+    ma_int16  volumeFixed;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    volumeFixed = ma_float_to_fixed_16(volume);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_s16(ma_apply_volume_unclipped_s16(pSrc[iSample], volumeFixed));
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s24(ma_uint8* pDst, const ma_int64* pSrc, ma_uint64 count, float volume)
+{
+    ma_uint64 iSample;
+    ma_int16  volumeFixed;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    volumeFixed = ma_float_to_fixed_16(volume);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        ma_int64 s = ma_clip_s24(ma_apply_volume_unclipped_s24(pSrc[iSample], volumeFixed));
+        pDst[iSample*3 + 0] = (ma_uint8)((s & 0x000000FF) >>  0);
+        pDst[iSample*3 + 1] = (ma_uint8)((s & 0x0000FF00) >>  8);
+        pDst[iSample*3 + 2] = (ma_uint8)((s & 0x00FF0000) >> 16);
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_s32(ma_int32* pDst, const ma_int64* pSrc, ma_uint64 count, float volume)
+{
+    ma_uint64 iSample;
+    ma_int16  volumeFixed;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    volumeFixed = ma_float_to_fixed_16(volume);
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_s32(ma_apply_volume_unclipped_s32(pSrc[iSample], volumeFixed));
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_and_clip_samples_f32(float* pDst, const float* pSrc, ma_uint64 count, float volume)
+{
+    ma_uint64 iSample;
+
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    /* For the f32 case we need to make sure this supports in-place processing where the input and output buffers are the same. */
+
+    for (iSample = 0; iSample < count; iSample += 1) {
+        pDst[iSample] = ma_clip_f32(ma_apply_volume_unclipped_f32(pSrc[iSample], volume));
+    }
+}
+
+MA_API void ma_copy_and_apply_volume_and_clip_pcm_frames(void* pDst, const void* pSrc, ma_uint64 frameCount, ma_format format, ma_uint32 channels, float volume)
+{
+    MA_ASSERT(pDst != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    if (volume == 1) {
+        ma_clip_pcm_frames(pDst, pSrc, frameCount, format, channels);   /* Optimized case for volume = 1. */
+    } else if (volume == 0) {
+        ma_silence_pcm_frames(pDst, frameCount, format, channels);      /* Optimized case for volume = 0. */
+    } else {
+        ma_uint64 sampleCount = frameCount * channels;
+
+        switch (format) {
+            case ma_format_u8:  ma_copy_and_apply_volume_and_clip_samples_u8( (ma_uint8*)pDst, (const ma_int16*)pSrc, sampleCount, volume); break;
+            case ma_format_s16: ma_copy_and_apply_volume_and_clip_samples_s16((ma_int16*)pDst, (const ma_int32*)pSrc, sampleCount, volume); break;
+            case ma_format_s24: ma_copy_and_apply_volume_and_clip_samples_s24((ma_uint8*)pDst, (const ma_int64*)pSrc, sampleCount, volume); break;
+            case ma_format_s32: ma_copy_and_apply_volume_and_clip_samples_s32((ma_int32*)pDst, (const ma_int64*)pSrc, sampleCount, volume); break;
+            case ma_format_f32: ma_copy_and_apply_volume_and_clip_samples_f32((   float*)pDst, (const    float*)pSrc, sampleCount, volume); break;
+
+            /* Do nothing if we don't know the format. We're including these here to silence a compiler warning about enums not being handled by the switch. */
+            case ma_format_unknown:
+            case ma_format_count:
+                break;
+        }
+    }
+}
+
+
+
+MA_API float ma_volume_linear_to_db(float factor)
+{
+    return 20*ma_log10f(factor);
+}
+
+MA_API float ma_volume_db_to_linear(float gain)
+{
+    return ma_powf(10, gain/20.0f);
+}
+
+
+MA_API ma_result ma_mix_pcm_frames_f32(float* pDst, const float* pSrc, ma_uint64 frameCount, ma_uint32 channels, float volume)
+{
+    ma_uint64 iSample;
+    ma_uint64 sampleCount;
+
+    if (pDst == NULL || pSrc == NULL || channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (volume == 0) {
+        return MA_SUCCESS;  /* No changes if the volume is 0. */
+    }
+
+    sampleCount = frameCount * channels;
+
+    if (volume == 1) {
+        for (iSample = 0; iSample < sampleCount; iSample += 1) {
+            pDst[iSample] += pSrc[iSample];
+        }
+    } else {
+        for (iSample = 0; iSample < sampleCount; iSample += 1) {
+            pDst[iSample] += ma_apply_volume_unclipped_f32(pSrc[iSample], volume);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Format Conversion
+
+**************************************************************************************************************************************************************/
+
+static MA_INLINE ma_int16 ma_pcm_sample_f32_to_s16(float x)
+{
+    return (ma_int16)(x * 32767.0f);
+}
+
+static MA_INLINE ma_int16 ma_pcm_sample_u8_to_s16_no_scale(ma_uint8 x)
+{
+    return (ma_int16)((ma_int16)x - 128);
+}
+
+static MA_INLINE ma_int64 ma_pcm_sample_s24_to_s32_no_scale(const ma_uint8* x)
+{
+    return (ma_int64)(((ma_uint64)x[0] << 40) | ((ma_uint64)x[1] << 48) | ((ma_uint64)x[2] << 56)) >> 40;  /* Make sure the sign bits are maintained. */
+}
+
+static MA_INLINE void ma_pcm_sample_s32_to_s24_no_scale(ma_int64 x, ma_uint8* s24)
+{
+    s24[0] = (ma_uint8)((x & 0x000000FF) >>  0);
+    s24[1] = (ma_uint8)((x & 0x0000FF00) >>  8);
+    s24[2] = (ma_uint8)((x & 0x00FF0000) >> 16);
+}
+
+
+/* u8 */
+MA_API void ma_pcm_u8_to_u8(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    (void)ditherMode;
+    ma_copy_memory_64(dst, src, count * sizeof(ma_uint8));
+}
+
+
+static MA_INLINE void ma_pcm_u8_to_s16__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const ma_uint8* src_u8 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        ma_int16 x = src_u8[i];
+        x = (ma_int16)(x - 128);
+        x = (ma_int16)(x << 8);
+        dst_s16[i] = x;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_u8_to_s16__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s16__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_u8_to_s16__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_u8_to_s16__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_u8_to_s16(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_u8_to_s16__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_u8_to_s16__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_u8_to_s16__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_u8_to_s16__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_u8_to_s24__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_s24 = (ma_uint8*)dst;
+    const ma_uint8* src_u8 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        ma_int16 x = src_u8[i];
+        x = (ma_int16)(x - 128);
+
+        dst_s24[i*3+0] = 0;
+        dst_s24[i*3+1] = 0;
+        dst_s24[i*3+2] = (ma_uint8)((ma_int8)x);
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_u8_to_s24__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s24__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_u8_to_s24__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_u8_to_s24__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_u8_to_s24(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_u8_to_s24__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_u8_to_s24__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_u8_to_s24__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_u8_to_s24__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_u8_to_s32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int32* dst_s32 = (ma_int32*)dst;
+    const ma_uint8* src_u8 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        ma_int32 x = src_u8[i];
+        x = x - 128;
+        x = x << 24;
+        dst_s32[i] = x;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_u8_to_s32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_u8_to_s32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_u8_to_s32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_u8_to_s32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_u8_to_s32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_u8_to_s32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_u8_to_s32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_u8_to_s32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_u8_to_f32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    float* dst_f32 = (float*)dst;
+    const ma_uint8* src_u8 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        float x = (float)src_u8[i];
+        x = x * 0.00784313725490196078f;    /* 0..255 to 0..2 */
+        x = x - 1;                          /* 0..2 to -1..1 */
+
+        dst_f32[i] = x;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_u8_to_f32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_f32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_u8_to_f32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_u8_to_f32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_u8_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_u8_to_f32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_u8_to_f32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_u8_to_f32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_u8_to_f32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_u8_to_f32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+static MA_INLINE void ma_pcm_interleave_u8__reference(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const ma_uint8** src_u8 = (const ma_uint8**)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_u8[iFrame*channels + iChannel] = src_u8[iChannel][iFrame];
+        }
+    }
+}
+#else
+static MA_INLINE void ma_pcm_interleave_u8__optimized(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const ma_uint8** src_u8 = (const ma_uint8**)src;
+
+    if (channels == 1) {
+        ma_copy_memory_64(dst, src[0], frameCount * sizeof(ma_uint8));
+    } else if (channels == 2) {
+        ma_uint64 iFrame;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            dst_u8[iFrame*2 + 0] = src_u8[0][iFrame];
+            dst_u8[iFrame*2 + 1] = src_u8[1][iFrame];
+        }
+    } else {
+        ma_uint64 iFrame;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            ma_uint32 iChannel;
+            for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                dst_u8[iFrame*channels + iChannel] = src_u8[iChannel][iFrame];
+            }
+        }
+    }
+}
+#endif
+
+MA_API void ma_pcm_interleave_u8(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_interleave_u8__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_interleave_u8__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_deinterleave_u8__reference(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_uint8** dst_u8 = (ma_uint8**)dst;
+    const ma_uint8* src_u8 = (const ma_uint8*)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_u8[iChannel][iFrame] = src_u8[iFrame*channels + iChannel];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_deinterleave_u8__optimized(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_deinterleave_u8__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_deinterleave_u8(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_deinterleave_u8__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_deinterleave_u8__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+/* s16 */
+static MA_INLINE void ma_pcm_s16_to_u8__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const ma_int16* src_s16 = (const ma_int16*)src;
+
+    if (ditherMode == ma_dither_mode_none) {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int16 x = src_s16[i];
+            x = (ma_int16)(x >> 8);
+            x = (ma_int16)(x + 128);
+            dst_u8[i] = (ma_uint8)x;
+        }
+    } else {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int16 x = src_s16[i];
+
+            /* Dither. Don't overflow. */
+            ma_int32 dither = ma_dither_s32(ditherMode, -0x80, 0x7F);
+            if ((x + dither) <= 0x7FFF) {
+                x = (ma_int16)(x + dither);
+            } else {
+                x = 0x7FFF;
+            }
+
+            x = (ma_int16)(x >> 8);
+            x = (ma_int16)(x + 128);
+            dst_u8[i] = (ma_uint8)x;
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_s16_to_u8__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_u8__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s16_to_u8__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s16_to_u8__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s16_to_u8(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s16_to_u8__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s16_to_u8__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s16_to_u8__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s16_to_u8__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+MA_API void ma_pcm_s16_to_s16(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    (void)ditherMode;
+    ma_copy_memory_64(dst, src, count * sizeof(ma_int16));
+}
+
+
+static MA_INLINE void ma_pcm_s16_to_s24__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_s24 = (ma_uint8*)dst;
+    const ma_int16* src_s16 = (const ma_int16*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        dst_s24[i*3+0] = 0;
+        dst_s24[i*3+1] = (ma_uint8)(src_s16[i] & 0xFF);
+        dst_s24[i*3+2] = (ma_uint8)(src_s16[i] >> 8);
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_s16_to_s24__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s24__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s16_to_s24__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s16_to_s24__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s16_to_s24(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s16_to_s24__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s16_to_s24__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s16_to_s24__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s16_to_s24__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s16_to_s32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int32* dst_s32 = (ma_int32*)dst;
+    const ma_int16* src_s16 = (const ma_int16*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        dst_s32[i] = src_s16[i] << 16;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_s16_to_s32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s16_to_s32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s16_to_s32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s16_to_s32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s16_to_s32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s16_to_s32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s16_to_s32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s16_to_s32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s16_to_f32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    float* dst_f32 = (float*)dst;
+    const ma_int16* src_s16 = (const ma_int16*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        float x = (float)src_s16[i];
+
+#if 0
+        /* The accurate way. */
+        x = x + 32768.0f;                   /* -32768..32767 to 0..65535 */
+        x = x * 0.00003051804379339284f;    /* 0..65535 to 0..2 */
+        x = x - 1;                          /* 0..2 to -1..1 */
+#else
+        /* The fast way. */
+        x = x * 0.000030517578125f;         /* -32768..32767 to -1..0.999969482421875 */
+#endif
+
+        dst_f32[i] = x;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_s16_to_f32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_f32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s16_to_f32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s16_to_f32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s16_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s16_to_f32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s16_to_f32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s16_to_f32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s16_to_f32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s16_to_f32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_interleave_s16__reference(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const ma_int16** src_s16 = (const ma_int16**)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_s16[iFrame*channels + iChannel] = src_s16[iChannel][iFrame];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_interleave_s16__optimized(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_interleave_s16__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_interleave_s16(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_interleave_s16__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_interleave_s16__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_deinterleave_s16__reference(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_int16** dst_s16 = (ma_int16**)dst;
+    const ma_int16* src_s16 = (const ma_int16*)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_s16[iChannel][iFrame] = src_s16[iFrame*channels + iChannel];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_deinterleave_s16__optimized(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_deinterleave_s16__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_deinterleave_s16(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_deinterleave_s16__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_deinterleave_s16__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+/* s24 */
+static MA_INLINE void ma_pcm_s24_to_u8__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const ma_uint8* src_s24 = (const ma_uint8*)src;
+
+    if (ditherMode == ma_dither_mode_none) {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            dst_u8[i] = (ma_uint8)((ma_int8)src_s24[i*3 + 2] + 128);
+        }
+    } else {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = (ma_int32)(((ma_uint32)(src_s24[i*3+0]) << 8) | ((ma_uint32)(src_s24[i*3+1]) << 16) | ((ma_uint32)(src_s24[i*3+2])) << 24);
+
+            /* Dither. Don't overflow. */
+            ma_int32 dither = ma_dither_s32(ditherMode, -0x800000, 0x7FFFFF);
+            if ((ma_int64)x + dither <= 0x7FFFFFFF) {
+                x = x + dither;
+            } else {
+                x = 0x7FFFFFFF;
+            }
+
+            x = x >> 24;
+            x = x + 128;
+            dst_u8[i] = (ma_uint8)x;
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_s24_to_u8__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_u8__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s24_to_u8__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s24_to_u8__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s24_to_u8(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s24_to_u8__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s24_to_u8__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s24_to_u8__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s24_to_u8__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s24_to_s16__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const ma_uint8* src_s24 = (const ma_uint8*)src;
+
+    if (ditherMode == ma_dither_mode_none) {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_uint16 dst_lo =            ((ma_uint16)src_s24[i*3 + 1]);
+            ma_uint16 dst_hi = (ma_uint16)((ma_uint16)src_s24[i*3 + 2] << 8);
+            dst_s16[i] = (ma_int16)(dst_lo | dst_hi);
+        }
+    } else {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = (ma_int32)(((ma_uint32)(src_s24[i*3+0]) << 8) | ((ma_uint32)(src_s24[i*3+1]) << 16) | ((ma_uint32)(src_s24[i*3+2])) << 24);
+
+            /* Dither. Don't overflow. */
+            ma_int32 dither = ma_dither_s32(ditherMode, -0x8000, 0x7FFF);
+            if ((ma_int64)x + dither <= 0x7FFFFFFF) {
+                x = x + dither;
+            } else {
+                x = 0x7FFFFFFF;
+            }
+
+            x = x >> 16;
+            dst_s16[i] = (ma_int16)x;
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_s24_to_s16__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s16__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s24_to_s16__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s24_to_s16__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s24_to_s16(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s24_to_s16__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s24_to_s16__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s24_to_s16__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s24_to_s16__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+MA_API void ma_pcm_s24_to_s24(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    (void)ditherMode;
+
+    ma_copy_memory_64(dst, src, count * 3);
+}
+
+
+static MA_INLINE void ma_pcm_s24_to_s32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int32* dst_s32 = (ma_int32*)dst;
+    const ma_uint8* src_s24 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        dst_s32[i] = (ma_int32)(((ma_uint32)(src_s24[i*3+0]) << 8) | ((ma_uint32)(src_s24[i*3+1]) << 16) | ((ma_uint32)(src_s24[i*3+2])) << 24);
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_s24_to_s32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s24_to_s32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s24_to_s32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s24_to_s32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s24_to_s32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s24_to_s32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s24_to_s32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s24_to_s32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s24_to_f32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    float* dst_f32 = (float*)dst;
+    const ma_uint8* src_s24 = (const ma_uint8*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        float x = (float)(((ma_int32)(((ma_uint32)(src_s24[i*3+0]) << 8) | ((ma_uint32)(src_s24[i*3+1]) << 16) | ((ma_uint32)(src_s24[i*3+2])) << 24)) >> 8);
+
+#if 0
+        /* The accurate way. */
+        x = x + 8388608.0f;                 /* -8388608..8388607 to 0..16777215 */
+        x = x * 0.00000011920929665621f;    /* 0..16777215 to 0..2 */
+        x = x - 1;                          /* 0..2 to -1..1 */
+#else
+        /* The fast way. */
+        x = x * 0.00000011920928955078125f; /* -8388608..8388607 to -1..0.999969482421875 */
+#endif
+
+        dst_f32[i] = x;
+    }
+
+    (void)ditherMode;
+}
+
+static MA_INLINE void ma_pcm_s24_to_f32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_f32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s24_to_f32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s24_to_f32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s24_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s24_to_f32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s24_to_f32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s24_to_f32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s24_to_f32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s24_to_f32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_interleave_s24__reference(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_uint8* dst8 = (ma_uint8*)dst;
+    const ma_uint8** src8 = (const ma_uint8**)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst8[iFrame*3*channels + iChannel*3 + 0] = src8[iChannel][iFrame*3 + 0];
+            dst8[iFrame*3*channels + iChannel*3 + 1] = src8[iChannel][iFrame*3 + 1];
+            dst8[iFrame*3*channels + iChannel*3 + 2] = src8[iChannel][iFrame*3 + 2];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_interleave_s24__optimized(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_interleave_s24__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_interleave_s24(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_interleave_s24__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_interleave_s24__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_deinterleave_s24__reference(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_uint8** dst8 = (ma_uint8**)dst;
+    const ma_uint8* src8 = (const ma_uint8*)src;
+
+    ma_uint32 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst8[iChannel][iFrame*3 + 0] = src8[iFrame*3*channels + iChannel*3 + 0];
+            dst8[iChannel][iFrame*3 + 1] = src8[iFrame*3*channels + iChannel*3 + 1];
+            dst8[iChannel][iFrame*3 + 2] = src8[iFrame*3*channels + iChannel*3 + 2];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_deinterleave_s24__optimized(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_deinterleave_s24__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_deinterleave_s24(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_deinterleave_s24__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_deinterleave_s24__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+
+/* s32 */
+static MA_INLINE void ma_pcm_s32_to_u8__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const ma_int32* src_s32 = (const ma_int32*)src;
+
+    if (ditherMode == ma_dither_mode_none) {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = src_s32[i];
+            x = x >> 24;
+            x = x + 128;
+            dst_u8[i] = (ma_uint8)x;
+        }
+    } else {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = src_s32[i];
+
+            /* Dither. Don't overflow. */
+            ma_int32 dither = ma_dither_s32(ditherMode, -0x800000, 0x7FFFFF);
+            if ((ma_int64)x + dither <= 0x7FFFFFFF) {
+                x = x + dither;
+            } else {
+                x = 0x7FFFFFFF;
+            }
+
+            x = x >> 24;
+            x = x + 128;
+            dst_u8[i] = (ma_uint8)x;
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_s32_to_u8__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_u8__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s32_to_u8__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s32_to_u8__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s32_to_u8(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s32_to_u8__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s32_to_u8__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s32_to_u8__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s32_to_u8__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s32_to_s16__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const ma_int32* src_s32 = (const ma_int32*)src;
+
+    if (ditherMode == ma_dither_mode_none) {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = src_s32[i];
+            x = x >> 16;
+            dst_s16[i] = (ma_int16)x;
+        }
+    } else {
+        ma_uint64 i;
+        for (i = 0; i < count; i += 1) {
+            ma_int32 x = src_s32[i];
+
+            /* Dither. Don't overflow. */
+            ma_int32 dither = ma_dither_s32(ditherMode, -0x8000, 0x7FFF);
+            if ((ma_int64)x + dither <= 0x7FFFFFFF) {
+                x = x + dither;
+            } else {
+                x = 0x7FFFFFFF;
+            }
+
+            x = x >> 16;
+            dst_s16[i] = (ma_int16)x;
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_s32_to_s16__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s16__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s32_to_s16__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s32_to_s16__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s16__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s32_to_s16(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s32_to_s16__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s32_to_s16__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s32_to_s16__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s32_to_s16__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_s32_to_s24__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_s24 = (ma_uint8*)dst;
+    const ma_int32* src_s32 = (const ma_int32*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        ma_uint32 x = (ma_uint32)src_s32[i];
+        dst_s24[i*3+0] = (ma_uint8)((x & 0x0000FF00) >>  8);
+        dst_s24[i*3+1] = (ma_uint8)((x & 0x00FF0000) >> 16);
+        dst_s24[i*3+2] = (ma_uint8)((x & 0xFF000000) >> 24);
+    }
+
+    (void)ditherMode;   /* No dithering for s32 -> s24. */
+}
+
+static MA_INLINE void ma_pcm_s32_to_s24__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s24__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s32_to_s24__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s32_to_s24__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s32_to_s24(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s32_to_s24__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s32_to_s24__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s32_to_s24__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s32_to_s24__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+MA_API void ma_pcm_s32_to_s32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    (void)ditherMode;
+
+    ma_copy_memory_64(dst, src, count * sizeof(ma_int32));
+}
+
+
+static MA_INLINE void ma_pcm_s32_to_f32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    float* dst_f32 = (float*)dst;
+    const ma_int32* src_s32 = (const ma_int32*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        double x = src_s32[i];
+
+#if 0
+        x = x + 2147483648.0;
+        x = x * 0.0000000004656612873077392578125;
+        x = x - 1;
+#else
+        x = x / 2147483648.0;
+#endif
+
+        dst_f32[i] = (float)x;
+    }
+
+    (void)ditherMode;   /* No dithering for s32 -> f32. */
+}
+
+static MA_INLINE void ma_pcm_s32_to_f32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_f32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_s32_to_f32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_s32_to_f32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_s32_to_f32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_s32_to_f32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_s32_to_f32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_s32_to_f32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_s32_to_f32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_s32_to_f32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_interleave_s32__reference(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_int32* dst_s32 = (ma_int32*)dst;
+    const ma_int32** src_s32 = (const ma_int32**)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_s32[iFrame*channels + iChannel] = src_s32[iChannel][iFrame];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_interleave_s32__optimized(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_interleave_s32__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_interleave_s32(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_interleave_s32__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_interleave_s32__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_deinterleave_s32__reference(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_int32** dst_s32 = (ma_int32**)dst;
+    const ma_int32* src_s32 = (const ma_int32*)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_s32[iChannel][iFrame] = src_s32[iFrame*channels + iChannel];
+        }
+    }
+}
+
+static MA_INLINE void ma_pcm_deinterleave_s32__optimized(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_deinterleave_s32__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_deinterleave_s32(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_deinterleave_s32__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_deinterleave_s32__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+/* f32 */
+static MA_INLINE void ma_pcm_f32_to_u8__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint64 i;
+
+    ma_uint8* dst_u8 = (ma_uint8*)dst;
+    const float* src_f32 = (const float*)src;
+
+    float ditherMin = 0;
+    float ditherMax = 0;
+    if (ditherMode != ma_dither_mode_none) {
+        ditherMin = 1.0f / -128;
+        ditherMax = 1.0f /  127;
+    }
+
+    for (i = 0; i < count; i += 1) {
+        float x = src_f32[i];
+        x = x + ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+        x = x + 1;                                  /* -1..1 to 0..2 */
+        x = x * 127.5f;                             /* 0..2 to 0..255 */
+
+        dst_u8[i] = (ma_uint8)x;
+    }
+}
+
+static MA_INLINE void ma_pcm_f32_to_u8__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_u8__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_f32_to_u8__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_f32_to_u8__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_u8__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_f32_to_u8(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_f32_to_u8__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_f32_to_u8__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_f32_to_u8__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_f32_to_u8__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+static MA_INLINE void ma_pcm_f32_to_s16__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint64 i;
+
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const float* src_f32 = (const float*)src;
+
+    float ditherMin = 0;
+    float ditherMax = 0;
+    if (ditherMode != ma_dither_mode_none) {
+        ditherMin = 1.0f / -32768;
+        ditherMax = 1.0f /  32767;
+    }
+
+    for (i = 0; i < count; i += 1) {
+        float x = src_f32[i];
+        x = x + ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+
+#if 0
+        /* The accurate way. */
+        x = x + 1;                                  /* -1..1 to 0..2 */
+        x = x * 32767.5f;                           /* 0..2 to 0..65535 */
+        x = x - 32768.0f;                           /* 0...65535 to -32768..32767 */
+#else
+        /* The fast way. */
+        x = x * 32767.0f;                           /* -1..1 to -32767..32767 */
+#endif
+
+        dst_s16[i] = (ma_int16)x;
+    }
+}
+#else
+static MA_INLINE void ma_pcm_f32_to_s16__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint64 i;
+    ma_uint64 i4;
+    ma_uint64 count4;
+
+    ma_int16* dst_s16 = (ma_int16*)dst;
+    const float* src_f32 = (const float*)src;
+
+    float ditherMin = 0;
+    float ditherMax = 0;
+    if (ditherMode != ma_dither_mode_none) {
+        ditherMin = 1.0f / -32768;
+        ditherMax = 1.0f /  32767;
+    }
+
+    /* Unrolled. */
+    i = 0;
+    count4 = count >> 2;
+    for (i4 = 0; i4 < count4; i4 += 1) {
+        float d0 = ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        float d1 = ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        float d2 = ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        float d3 = ma_dither_f32(ditherMode, ditherMin, ditherMax);
+
+        float x0 = src_f32[i+0];
+        float x1 = src_f32[i+1];
+        float x2 = src_f32[i+2];
+        float x3 = src_f32[i+3];
+
+        x0 = x0 + d0;
+        x1 = x1 + d1;
+        x2 = x2 + d2;
+        x3 = x3 + d3;
+
+        x0 = ((x0 < -1) ? -1 : ((x0 > 1) ? 1 : x0));
+        x1 = ((x1 < -1) ? -1 : ((x1 > 1) ? 1 : x1));
+        x2 = ((x2 < -1) ? -1 : ((x2 > 1) ? 1 : x2));
+        x3 = ((x3 < -1) ? -1 : ((x3 > 1) ? 1 : x3));
+
+        x0 = x0 * 32767.0f;
+        x1 = x1 * 32767.0f;
+        x2 = x2 * 32767.0f;
+        x3 = x3 * 32767.0f;
+
+        dst_s16[i+0] = (ma_int16)x0;
+        dst_s16[i+1] = (ma_int16)x1;
+        dst_s16[i+2] = (ma_int16)x2;
+        dst_s16[i+3] = (ma_int16)x3;
+
+        i += 4;
+    }
+
+    /* Leftover. */
+    for (; i < count; i += 1) {
+        float x = src_f32[i];
+        x = x + ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+        x = x * 32767.0f;                           /* -1..1 to -32767..32767 */
+
+        dst_s16[i] = (ma_int16)x;
+    }
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_f32_to_s16__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint64 i;
+    ma_uint64 i8;
+    ma_uint64 count8;
+    ma_int16* dst_s16;
+    const float* src_f32;
+    float ditherMin;
+    float ditherMax;
+
+    /* Both the input and output buffers need to be aligned to 16 bytes. */
+    if ((((ma_uintptr)dst & 15) != 0) || (((ma_uintptr)src & 15) != 0)) {
+        ma_pcm_f32_to_s16__optimized(dst, src, count, ditherMode);
+        return;
+    }
+
+    dst_s16 = (ma_int16*)dst;
+    src_f32 = (const float*)src;
+
+    ditherMin = 0;
+    ditherMax = 0;
+    if (ditherMode != ma_dither_mode_none) {
+        ditherMin = 1.0f / -32768;
+        ditherMax = 1.0f /  32767;
+    }
+
+    i = 0;
+
+    /* SSE2. SSE allows us to output 8 s16's at a time which means our loop is unrolled 8 times. */
+    count8 = count >> 3;
+    for (i8 = 0; i8 < count8; i8 += 1) {
+        __m128 d0;
+        __m128 d1;
+        __m128 x0;
+        __m128 x1;
+
+        if (ditherMode == ma_dither_mode_none) {
+            d0 = _mm_set1_ps(0);
+            d1 = _mm_set1_ps(0);
+        } else if (ditherMode == ma_dither_mode_rectangle) {
+            d0 = _mm_set_ps(
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax)
+            );
+            d1 = _mm_set_ps(
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax),
+                ma_dither_f32_rectangle(ditherMin, ditherMax)
+            );
+        } else {
+            d0 = _mm_set_ps(
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax)
+            );
+            d1 = _mm_set_ps(
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax),
+                ma_dither_f32_triangle(ditherMin, ditherMax)
+            );
+        }
+
+        x0 = *((__m128*)(src_f32 + i) + 0);
+        x1 = *((__m128*)(src_f32 + i) + 1);
+
+        x0 = _mm_add_ps(x0, d0);
+        x1 = _mm_add_ps(x1, d1);
+
+        x0 = _mm_mul_ps(x0, _mm_set1_ps(32767.0f));
+        x1 = _mm_mul_ps(x1, _mm_set1_ps(32767.0f));
+
+        _mm_stream_si128(((__m128i*)(dst_s16 + i)), _mm_packs_epi32(_mm_cvttps_epi32(x0), _mm_cvttps_epi32(x1)));
+
+        i += 8;
+    }
+
+
+    /* Leftover. */
+    for (; i < count; i += 1) {
+        float x = src_f32[i];
+        x = x + ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+        x = x * 32767.0f;                           /* -1..1 to -32767..32767 */
+
+        dst_s16[i] = (ma_int16)x;
+    }
+}
+#endif  /* SSE2 */
+
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_f32_to_s16__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint64 i;
+    ma_uint64 i8;
+    ma_uint64 count8;
+    ma_int16* dst_s16;
+    const float* src_f32;
+    float ditherMin;
+    float ditherMax;
+
+    if (!ma_has_neon()) {
+        ma_pcm_f32_to_s16__optimized(dst, src, count, ditherMode);
+        return;
+    }
+
+    /* Both the input and output buffers need to be aligned to 16 bytes. */
+    if ((((ma_uintptr)dst & 15) != 0) || (((ma_uintptr)src & 15) != 0)) {
+        ma_pcm_f32_to_s16__optimized(dst, src, count, ditherMode);
+        return;
+    }
+
+    dst_s16 = (ma_int16*)dst;
+    src_f32 = (const float*)src;
+
+    ditherMin = 0;
+    ditherMax = 0;
+    if (ditherMode != ma_dither_mode_none) {
+        ditherMin = 1.0f / -32768;
+        ditherMax = 1.0f /  32767;
+    }
+
+    i = 0;
+
+    /* NEON. NEON allows us to output 8 s16's at a time which means our loop is unrolled 8 times. */
+    count8 = count >> 3;
+    for (i8 = 0; i8 < count8; i8 += 1) {
+        float32x4_t d0;
+        float32x4_t d1;
+        float32x4_t x0;
+        float32x4_t x1;
+        int32x4_t i0;
+        int32x4_t i1;
+
+        if (ditherMode == ma_dither_mode_none) {
+            d0 = vmovq_n_f32(0);
+            d1 = vmovq_n_f32(0);
+        } else if (ditherMode == ma_dither_mode_rectangle) {
+            float d0v[4];
+            float d1v[4];
+
+            d0v[0] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d0v[1] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d0v[2] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d0v[3] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d0 = vld1q_f32(d0v);
+
+            d1v[0] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d1v[1] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d1v[2] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d1v[3] = ma_dither_f32_rectangle(ditherMin, ditherMax);
+            d1 = vld1q_f32(d1v);
+        } else {
+            float d0v[4];
+            float d1v[4];
+
+            d0v[0] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d0v[1] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d0v[2] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d0v[3] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d0 = vld1q_f32(d0v);
+
+            d1v[0] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d1v[1] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d1v[2] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d1v[3] = ma_dither_f32_triangle(ditherMin, ditherMax);
+            d1 = vld1q_f32(d1v);
+        }
+
+        x0 = *((float32x4_t*)(src_f32 + i) + 0);
+        x1 = *((float32x4_t*)(src_f32 + i) + 1);
+
+        x0 = vaddq_f32(x0, d0);
+        x1 = vaddq_f32(x1, d1);
+
+        x0 = vmulq_n_f32(x0, 32767.0f);
+        x1 = vmulq_n_f32(x1, 32767.0f);
+
+        i0 = vcvtq_s32_f32(x0);
+        i1 = vcvtq_s32_f32(x1);
+        *((int16x8_t*)(dst_s16 + i)) = vcombine_s16(vqmovn_s32(i0), vqmovn_s32(i1));
+
+        i += 8;
+    }
+
+
+    /* Leftover. */
+    for (; i < count; i += 1) {
+        float x = src_f32[i];
+        x = x + ma_dither_f32(ditherMode, ditherMin, ditherMax);
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+        x = x * 32767.0f;                           /* -1..1 to -32767..32767 */
+
+        dst_s16[i] = (ma_int16)x;
+    }
+}
+#endif  /* Neon */
+#endif  /* MA_USE_REFERENCE_CONVERSION_APIS */
+
+MA_API void ma_pcm_f32_to_s16(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_f32_to_s16__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_f32_to_s16__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_f32_to_s16__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_f32_to_s16__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_f32_to_s24__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_uint8* dst_s24 = (ma_uint8*)dst;
+    const float* src_f32 = (const float*)src;
+
+    ma_uint64 i;
+    for (i = 0; i < count; i += 1) {
+        ma_int32 r;
+        float x = src_f32[i];
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+
+#if 0
+        /* The accurate way. */
+        x = x + 1;                                  /* -1..1 to 0..2 */
+        x = x * 8388607.5f;                         /* 0..2 to 0..16777215 */
+        x = x - 8388608.0f;                         /* 0..16777215 to -8388608..8388607 */
+#else
+        /* The fast way. */
+        x = x * 8388607.0f;                         /* -1..1 to -8388607..8388607 */
+#endif
+
+        r = (ma_int32)x;
+        dst_s24[(i*3)+0] = (ma_uint8)((r & 0x0000FF) >>  0);
+        dst_s24[(i*3)+1] = (ma_uint8)((r & 0x00FF00) >>  8);
+        dst_s24[(i*3)+2] = (ma_uint8)((r & 0xFF0000) >> 16);
+    }
+
+    (void)ditherMode;   /* No dithering for f32 -> s24. */
+}
+
+static MA_INLINE void ma_pcm_f32_to_s24__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s24__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_f32_to_s24__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_f32_to_s24__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s24__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_f32_to_s24(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_f32_to_s24__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_f32_to_s24__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_f32_to_s24__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_f32_to_s24__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+static MA_INLINE void ma_pcm_f32_to_s32__reference(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_int32* dst_s32 = (ma_int32*)dst;
+    const float* src_f32 = (const float*)src;
+
+    ma_uint32 i;
+    for (i = 0; i < count; i += 1) {
+        double x = src_f32[i];
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));    /* clip */
+
+#if 0
+        /* The accurate way. */
+        x = x + 1;                                  /* -1..1 to 0..2 */
+        x = x * 2147483647.5;                       /* 0..2 to 0..4294967295 */
+        x = x - 2147483648.0;                       /* 0...4294967295 to -2147483648..2147483647 */
+#else
+        /* The fast way. */
+        x = x * 2147483647.0;                       /* -1..1 to -2147483647..2147483647 */
+#endif
+
+        dst_s32[i] = (ma_int32)x;
+    }
+
+    (void)ditherMode;   /* No dithering for f32 -> s32. */
+}
+
+static MA_INLINE void ma_pcm_f32_to_s32__optimized(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s32__reference(dst, src, count, ditherMode);
+}
+
+#if defined(MA_SUPPORT_SSE2)
+static MA_INLINE void ma_pcm_f32_to_s32__sse2(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+#if defined(MA_SUPPORT_NEON)
+static MA_INLINE void ma_pcm_f32_to_s32__neon(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    ma_pcm_f32_to_s32__optimized(dst, src, count, ditherMode);
+}
+#endif
+
+MA_API void ma_pcm_f32_to_s32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_f32_to_s32__reference(dst, src, count, ditherMode);
+#else
+    #  if defined(MA_SUPPORT_SSE2)
+        if (ma_has_sse2()) {
+            ma_pcm_f32_to_s32__sse2(dst, src, count, ditherMode);
+        } else
+    #elif defined(MA_SUPPORT_NEON)
+        if (ma_has_neon()) {
+            ma_pcm_f32_to_s32__neon(dst, src, count, ditherMode);
+        } else
+    #endif
+        {
+            ma_pcm_f32_to_s32__optimized(dst, src, count, ditherMode);
+        }
+#endif
+}
+
+
+MA_API void ma_pcm_f32_to_f32(void* dst, const void* src, ma_uint64 count, ma_dither_mode ditherMode)
+{
+    (void)ditherMode;
+
+    ma_copy_memory_64(dst, src, count * sizeof(float));
+}
+
+
+static void ma_pcm_interleave_f32__reference(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    float* dst_f32 = (float*)dst;
+    const float** src_f32 = (const float**)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_f32[iFrame*channels + iChannel] = src_f32[iChannel][iFrame];
+        }
+    }
+}
+
+static void ma_pcm_interleave_f32__optimized(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_interleave_f32__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_interleave_f32(void* dst, const void** src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_interleave_f32__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_interleave_f32__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+static void ma_pcm_deinterleave_f32__reference(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    float** dst_f32 = (float**)dst;
+    const float* src_f32 = (const float*)src;
+
+    ma_uint64 iFrame;
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; iChannel += 1) {
+            dst_f32[iChannel][iFrame] = src_f32[iFrame*channels + iChannel];
+        }
+    }
+}
+
+static void ma_pcm_deinterleave_f32__optimized(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+    ma_pcm_deinterleave_f32__reference(dst, src, frameCount, channels);
+}
+
+MA_API void ma_pcm_deinterleave_f32(void** dst, const void* src, ma_uint64 frameCount, ma_uint32 channels)
+{
+#ifdef MA_USE_REFERENCE_CONVERSION_APIS
+    ma_pcm_deinterleave_f32__reference(dst, src, frameCount, channels);
+#else
+    ma_pcm_deinterleave_f32__optimized(dst, src, frameCount, channels);
+#endif
+}
+
+
+MA_API void ma_pcm_convert(void* pOut, ma_format formatOut, const void* pIn, ma_format formatIn, ma_uint64 sampleCount, ma_dither_mode ditherMode)
+{
+    if (formatOut == formatIn) {
+        ma_copy_memory_64(pOut, pIn, sampleCount * ma_get_bytes_per_sample(formatOut));
+        return;
+    }
+
+    switch (formatIn)
+    {
+        case ma_format_u8:
+        {
+            switch (formatOut)
+            {
+                case ma_format_s16: ma_pcm_u8_to_s16(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s24: ma_pcm_u8_to_s24(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s32: ma_pcm_u8_to_s32(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_f32: ma_pcm_u8_to_f32(pOut, pIn, sampleCount, ditherMode); return;
+                default: break;
+            }
+        } break;
+
+        case ma_format_s16:
+        {
+            switch (formatOut)
+            {
+                case ma_format_u8:  ma_pcm_s16_to_u8( pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s24: ma_pcm_s16_to_s24(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s32: ma_pcm_s16_to_s32(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_f32: ma_pcm_s16_to_f32(pOut, pIn, sampleCount, ditherMode); return;
+                default: break;
+            }
+        } break;
+
+        case ma_format_s24:
+        {
+            switch (formatOut)
+            {
+                case ma_format_u8:  ma_pcm_s24_to_u8( pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s16: ma_pcm_s24_to_s16(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s32: ma_pcm_s24_to_s32(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_f32: ma_pcm_s24_to_f32(pOut, pIn, sampleCount, ditherMode); return;
+                default: break;
+            }
+        } break;
+
+        case ma_format_s32:
+        {
+            switch (formatOut)
+            {
+                case ma_format_u8:  ma_pcm_s32_to_u8( pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s16: ma_pcm_s32_to_s16(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s24: ma_pcm_s32_to_s24(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_f32: ma_pcm_s32_to_f32(pOut, pIn, sampleCount, ditherMode); return;
+                default: break;
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            switch (formatOut)
+            {
+                case ma_format_u8:  ma_pcm_f32_to_u8( pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s16: ma_pcm_f32_to_s16(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s24: ma_pcm_f32_to_s24(pOut, pIn, sampleCount, ditherMode); return;
+                case ma_format_s32: ma_pcm_f32_to_s32(pOut, pIn, sampleCount, ditherMode); return;
+                default: break;
+            }
+        } break;
+
+        default: break;
+    }
+}
+
+MA_API void ma_convert_pcm_frames_format(void* pOut, ma_format formatOut, const void* pIn, ma_format formatIn, ma_uint64 frameCount, ma_uint32 channels, ma_dither_mode ditherMode)
+{
+    ma_pcm_convert(pOut, formatOut, pIn, formatIn, frameCount * channels, ditherMode);
+}
+
+MA_API void ma_deinterleave_pcm_frames(ma_format format, ma_uint32 channels, ma_uint64 frameCount, const void* pInterleavedPCMFrames, void** ppDeinterleavedPCMFrames)
+{
+    if (pInterleavedPCMFrames == NULL || ppDeinterleavedPCMFrames == NULL) {
+        return; /* Invalid args. */
+    }
+
+    /* For efficiency we do this per format. */
+    switch (format) {
+        case ma_format_s16:
+        {
+            const ma_int16* pSrcS16 = (const ma_int16*)pInterleavedPCMFrames;
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                    ma_int16* pDstS16 = (ma_int16*)ppDeinterleavedPCMFrames[iChannel];
+                    pDstS16[iPCMFrame] = pSrcS16[iPCMFrame*channels+iChannel];
+                }
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            const float* pSrcF32 = (const float*)pInterleavedPCMFrames;
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                    float* pDstF32 = (float*)ppDeinterleavedPCMFrames[iChannel];
+                    pDstF32[iPCMFrame] = pSrcF32[iPCMFrame*channels+iChannel];
+                }
+            }
+        } break;
+
+        default:
+        {
+            ma_uint32 sampleSizeInBytes = ma_get_bytes_per_sample(format);
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                          void* pDst = ma_offset_ptr(ppDeinterleavedPCMFrames[iChannel], iPCMFrame*sampleSizeInBytes);
+                    const void* pSrc = ma_offset_ptr(pInterleavedPCMFrames, (iPCMFrame*channels+iChannel)*sampleSizeInBytes);
+                    memcpy(pDst, pSrc, sampleSizeInBytes);
+                }
+            }
+        } break;
+    }
+}
+
+MA_API void ma_interleave_pcm_frames(ma_format format, ma_uint32 channels, ma_uint64 frameCount, const void** ppDeinterleavedPCMFrames, void* pInterleavedPCMFrames)
+{
+    switch (format)
+    {
+        case ma_format_s16:
+        {
+            ma_int16* pDstS16 = (ma_int16*)pInterleavedPCMFrames;
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                    const ma_int16* pSrcS16 = (const ma_int16*)ppDeinterleavedPCMFrames[iChannel];
+                    pDstS16[iPCMFrame*channels+iChannel] = pSrcS16[iPCMFrame];
+                }
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            float* pDstF32 = (float*)pInterleavedPCMFrames;
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                    const float* pSrcF32 = (const float*)ppDeinterleavedPCMFrames[iChannel];
+                    pDstF32[iPCMFrame*channels+iChannel] = pSrcF32[iPCMFrame];
+                }
+            }
+        } break;
+
+        default:
+        {
+            ma_uint32 sampleSizeInBytes = ma_get_bytes_per_sample(format);
+            ma_uint64 iPCMFrame;
+            for (iPCMFrame = 0; iPCMFrame < frameCount; ++iPCMFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < channels; ++iChannel) {
+                          void* pDst = ma_offset_ptr(pInterleavedPCMFrames, (iPCMFrame*channels+iChannel)*sampleSizeInBytes);
+                    const void* pSrc = ma_offset_ptr(ppDeinterleavedPCMFrames[iChannel], iPCMFrame*sampleSizeInBytes);
+                    memcpy(pDst, pSrc, sampleSizeInBytes);
+                }
+            }
+        } break;
+    }
+}
+
+
+/**************************************************************************************************************************************************************
+
+Biquad Filter
+
+**************************************************************************************************************************************************************/
+#ifndef MA_BIQUAD_FIXED_POINT_SHIFT
+#define MA_BIQUAD_FIXED_POINT_SHIFT 14
+#endif
+
+static ma_int32 ma_biquad_float_to_fp(double x)
+{
+    return (ma_int32)(x * (1 << MA_BIQUAD_FIXED_POINT_SHIFT));
+}
+
+MA_API ma_biquad_config ma_biquad_config_init(ma_format format, ma_uint32 channels, double b0, double b1, double b2, double a0, double a1, double a2)
+{
+    ma_biquad_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.b0 = b0;
+    config.b1 = b1;
+    config.b2 = b2;
+    config.a0 = a0;
+    config.a1 = a1;
+    config.a2 = a2;
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t r1Offset;
+    size_t r2Offset;
+} ma_biquad_heap_layout;
+
+static ma_result ma_biquad_get_heap_layout(const ma_biquad_config* pConfig, ma_biquad_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* R0 */
+    pHeapLayout->r1Offset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(ma_biquad_coefficient) * pConfig->channels;
+
+    /* R1 */
+    pHeapLayout->r2Offset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(ma_biquad_coefficient) * pConfig->channels;
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_biquad_get_heap_size(const ma_biquad_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_biquad_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_biquad_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_biquad_init_preallocated(const ma_biquad_config* pConfig, void* pHeap, ma_biquad* pBQ)
+{
+    ma_result result;
+    ma_biquad_heap_layout heapLayout;
+
+    if (pBQ == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pBQ);
+
+    result = ma_biquad_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pBQ->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pBQ->pR1 = (ma_biquad_coefficient*)ma_offset_ptr(pHeap, heapLayout.r1Offset);
+    pBQ->pR2 = (ma_biquad_coefficient*)ma_offset_ptr(pHeap, heapLayout.r2Offset);
+
+    return ma_biquad_reinit(pConfig, pBQ);
+}
+
+MA_API ma_result ma_biquad_init(const ma_biquad_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_biquad* pBQ)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_biquad_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_biquad_init_preallocated(pConfig, pHeap, pBQ);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pBQ->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_biquad_uninit(ma_biquad* pBQ, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pBQ == NULL) {
+        return;
+    }
+
+    if (pBQ->_ownsHeap) {
+        ma_free(pBQ->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_biquad_reinit(const ma_biquad_config* pConfig, ma_biquad* pBQ)
+{
+    if (pBQ == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->a0 == 0) {
+        return MA_INVALID_ARGS; /* Division by zero. */
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pBQ->format != ma_format_unknown && pBQ->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pBQ->channels != 0 && pBQ->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+
+    pBQ->format   = pConfig->format;
+    pBQ->channels = pConfig->channels;
+
+    /* Normalize. */
+    if (pConfig->format == ma_format_f32) {
+        pBQ->b0.f32 = (float)(pConfig->b0 / pConfig->a0);
+        pBQ->b1.f32 = (float)(pConfig->b1 / pConfig->a0);
+        pBQ->b2.f32 = (float)(pConfig->b2 / pConfig->a0);
+        pBQ->a1.f32 = (float)(pConfig->a1 / pConfig->a0);
+        pBQ->a2.f32 = (float)(pConfig->a2 / pConfig->a0);
+    } else {
+        pBQ->b0.s32 = ma_biquad_float_to_fp(pConfig->b0 / pConfig->a0);
+        pBQ->b1.s32 = ma_biquad_float_to_fp(pConfig->b1 / pConfig->a0);
+        pBQ->b2.s32 = ma_biquad_float_to_fp(pConfig->b2 / pConfig->a0);
+        pBQ->a1.s32 = ma_biquad_float_to_fp(pConfig->a1 / pConfig->a0);
+        pBQ->a2.s32 = ma_biquad_float_to_fp(pConfig->a2 / pConfig->a0);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_biquad_clear_cache(ma_biquad* pBQ)
+{
+    if (pBQ == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pBQ->format == ma_format_f32) {
+        pBQ->pR1->f32 = 0;
+        pBQ->pR2->f32 = 0;
+    } else {
+        pBQ->pR1->s32 = 0;
+        pBQ->pR2->s32 = 0;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_biquad_process_pcm_frame_f32__direct_form_2_transposed(ma_biquad* pBQ, float* pY, const float* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pBQ->channels;
+    const float b0 = pBQ->b0.f32;
+    const float b1 = pBQ->b1.f32;
+    const float b2 = pBQ->b2.f32;
+    const float a1 = pBQ->a1.f32;
+    const float a2 = pBQ->a2.f32;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        float r1 = pBQ->pR1[c].f32;
+        float r2 = pBQ->pR2[c].f32;
+        float x  = pX[c];
+        float y;
+
+        y  = b0*x        + r1;
+        r1 = b1*x - a1*y + r2;
+        r2 = b2*x - a2*y;
+
+        pY[c]           = y;
+        pBQ->pR1[c].f32 = r1;
+        pBQ->pR2[c].f32 = r2;
+    }
+}
+
+static MA_INLINE void ma_biquad_process_pcm_frame_f32(ma_biquad* pBQ, float* pY, const float* pX)
+{
+    ma_biquad_process_pcm_frame_f32__direct_form_2_transposed(pBQ, pY, pX);
+}
+
+static MA_INLINE void ma_biquad_process_pcm_frame_s16__direct_form_2_transposed(ma_biquad* pBQ, ma_int16* pY, const ma_int16* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pBQ->channels;
+    const ma_int32 b0 = pBQ->b0.s32;
+    const ma_int32 b1 = pBQ->b1.s32;
+    const ma_int32 b2 = pBQ->b2.s32;
+    const ma_int32 a1 = pBQ->a1.s32;
+    const ma_int32 a2 = pBQ->a2.s32;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        ma_int32 r1 = pBQ->pR1[c].s32;
+        ma_int32 r2 = pBQ->pR2[c].s32;
+        ma_int32 x  = pX[c];
+        ma_int32 y;
+
+        y  = (b0*x        + r1) >> MA_BIQUAD_FIXED_POINT_SHIFT;
+        r1 = (b1*x - a1*y + r2);
+        r2 = (b2*x - a2*y);
+
+        pY[c]           = (ma_int16)ma_clamp(y, -32768, 32767);
+        pBQ->pR1[c].s32 = r1;
+        pBQ->pR2[c].s32 = r2;
+    }
+}
+
+static MA_INLINE void ma_biquad_process_pcm_frame_s16(ma_biquad* pBQ, ma_int16* pY, const ma_int16* pX)
+{
+    ma_biquad_process_pcm_frame_s16__direct_form_2_transposed(pBQ, pY, pX);
+}
+
+MA_API ma_result ma_biquad_process_pcm_frames(ma_biquad* pBQ, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint32 n;
+
+    if (pBQ == NULL || pFramesOut == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Note that the logic below needs to support in-place filtering. That is, it must support the case where pFramesOut and pFramesIn are the same. */
+
+    if (pBQ->format == ma_format_f32) {
+        /* */ float* pY = (      float*)pFramesOut;
+        const float* pX = (const float*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_biquad_process_pcm_frame_f32__direct_form_2_transposed(pBQ, pY, pX);
+            pY += pBQ->channels;
+            pX += pBQ->channels;
+        }
+    } else if (pBQ->format == ma_format_s16) {
+        /* */ ma_int16* pY = (      ma_int16*)pFramesOut;
+        const ma_int16* pX = (const ma_int16*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_biquad_process_pcm_frame_s16__direct_form_2_transposed(pBQ, pY, pX);
+            pY += pBQ->channels;
+            pX += pBQ->channels;
+        }
+    } else {
+        MA_ASSERT(MA_FALSE);
+        return MA_INVALID_ARGS; /* Format not supported. Should never hit this because it's checked in ma_biquad_init() and ma_biquad_reinit(). */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_biquad_get_latency(const ma_biquad* pBQ)
+{
+    if (pBQ == NULL) {
+        return 0;
+    }
+
+    return 2;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Low-Pass Filter
+
+**************************************************************************************************************************************************************/
+MA_API ma_lpf1_config ma_lpf1_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency)
+{
+    ma_lpf1_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.q = 0.5;
+
+    return config;
+}
+
+MA_API ma_lpf2_config ma_lpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q)
+{
+    ma_lpf2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.q = q;
+
+    /* Q cannot be 0 or else it'll result in a division by 0. In this case just default to 0.707107. */
+    if (config.q == 0) {
+        config.q = 0.707107;
+    }
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t r1Offset;
+} ma_lpf1_heap_layout;
+
+static ma_result ma_lpf1_get_heap_layout(const ma_lpf1_config* pConfig, ma_lpf1_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* R1 */
+    pHeapLayout->r1Offset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(ma_biquad_coefficient) * pConfig->channels;
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf1_get_heap_size(const ma_lpf1_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_lpf1_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_lpf1_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf1_init_preallocated(const ma_lpf1_config* pConfig, void* pHeap, ma_lpf1* pLPF)
+{
+    ma_result result;
+    ma_lpf1_heap_layout heapLayout;
+
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLPF);
+
+    result = ma_lpf1_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pLPF->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pLPF->pR1 = (ma_biquad_coefficient*)ma_offset_ptr(pHeap, heapLayout.r1Offset);
+
+    return ma_lpf1_reinit(pConfig, pLPF);
+}
+
+MA_API ma_result ma_lpf1_init(const ma_lpf1_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf1* pLPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_lpf1_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_lpf1_init_preallocated(pConfig, pHeap, pLPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pLPF->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_lpf1_uninit(ma_lpf1* pLPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pLPF == NULL) {
+        return;
+    }
+
+    if (pLPF->_ownsHeap) {
+        ma_free(pLPF->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_lpf1_reinit(const ma_lpf1_config* pConfig, ma_lpf1* pLPF)
+{
+    double a;
+
+    if (pLPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pLPF->format != ma_format_unknown && pLPF->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pLPF->channels != 0 && pLPF->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+    pLPF->format   = pConfig->format;
+    pLPF->channels = pConfig->channels;
+
+    a = ma_expd(-2 * MA_PI_D * pConfig->cutoffFrequency / pConfig->sampleRate);
+    if (pConfig->format == ma_format_f32) {
+        pLPF->a.f32 = (float)a;
+    } else {
+        pLPF->a.s32 = ma_biquad_float_to_fp(a);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf1_clear_cache(ma_lpf1* pLPF)
+{
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pLPF->format == ma_format_f32) {
+        pLPF->a.f32 = 0;
+    } else {
+        pLPF->a.s32 = 0;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_lpf1_process_pcm_frame_f32(ma_lpf1* pLPF, float* pY, const float* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pLPF->channels;
+    const float a = pLPF->a.f32;
+    const float b = 1 - a;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        float r1 = pLPF->pR1[c].f32;
+        float x  = pX[c];
+        float y;
+
+        y = b*x + a*r1;
+
+        pY[c]           = y;
+        pLPF->pR1[c].f32 = y;
+    }
+}
+
+static MA_INLINE void ma_lpf1_process_pcm_frame_s16(ma_lpf1* pLPF, ma_int16* pY, const ma_int16* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pLPF->channels;
+    const ma_int32 a = pLPF->a.s32;
+    const ma_int32 b = ((1 << MA_BIQUAD_FIXED_POINT_SHIFT) - a);
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        ma_int32 r1 = pLPF->pR1[c].s32;
+        ma_int32 x  = pX[c];
+        ma_int32 y;
+
+        y = (b*x + a*r1) >> MA_BIQUAD_FIXED_POINT_SHIFT;
+
+        pY[c]            = (ma_int16)y;
+        pLPF->pR1[c].s32 = (ma_int32)y;
+    }
+}
+
+MA_API ma_result ma_lpf1_process_pcm_frames(ma_lpf1* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint32 n;
+
+    if (pLPF == NULL || pFramesOut == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Note that the logic below needs to support in-place filtering. That is, it must support the case where pFramesOut and pFramesIn are the same. */
+
+    if (pLPF->format == ma_format_f32) {
+        /* */ float* pY = (      float*)pFramesOut;
+        const float* pX = (const float*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_lpf1_process_pcm_frame_f32(pLPF, pY, pX);
+            pY += pLPF->channels;
+            pX += pLPF->channels;
+        }
+    } else if (pLPF->format == ma_format_s16) {
+        /* */ ma_int16* pY = (      ma_int16*)pFramesOut;
+        const ma_int16* pX = (const ma_int16*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_lpf1_process_pcm_frame_s16(pLPF, pY, pX);
+            pY += pLPF->channels;
+            pX += pLPF->channels;
+        }
+    } else {
+        MA_ASSERT(MA_FALSE);
+        return MA_INVALID_ARGS; /* Format not supported. Should never hit this because it's checked in ma_biquad_init() and ma_biquad_reinit(). */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_lpf1_get_latency(const ma_lpf1* pLPF)
+{
+    if (pLPF == NULL) {
+        return 0;
+    }
+
+    return 1;
+}
+
+
+static MA_INLINE ma_biquad_config ma_lpf2__get_biquad_config(const ma_lpf2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double q;
+    double w;
+    double s;
+    double c;
+    double a;
+
+    MA_ASSERT(pConfig != NULL);
+
+    q = pConfig->q;
+    w = 2 * MA_PI_D * pConfig->cutoffFrequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    a = s / (2*q);
+
+    bqConfig.b0 = (1 - c) / 2;
+    bqConfig.b1 =  1 - c;
+    bqConfig.b2 = (1 - c) / 2;
+    bqConfig.a0 =  1 + a;
+    bqConfig.a1 = -2 * c;
+    bqConfig.a2 =  1 - a;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_lpf2_get_heap_size(const ma_lpf2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_lpf2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_lpf2_init_preallocated(const ma_lpf2_config* pConfig, void* pHeap, ma_lpf2* pLPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLPF);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_lpf2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pLPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf2_init(const ma_lpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf2* pLPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_lpf2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_lpf2_init_preallocated(pConfig, pHeap, pLPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pLPF->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_lpf2_uninit(ma_lpf2* pLPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pLPF == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pLPF->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_lpf2_reinit(const ma_lpf2_config* pConfig, ma_lpf2* pLPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pLPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_lpf2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pLPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf2_clear_cache(ma_lpf2* pLPF)
+{
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_biquad_clear_cache(&pLPF->bq);
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_lpf2_process_pcm_frame_s16(ma_lpf2* pLPF, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pLPF->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_lpf2_process_pcm_frame_f32(ma_lpf2* pLPF, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pLPF->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_lpf2_process_pcm_frames(ma_lpf2* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pLPF->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_lpf2_get_latency(const ma_lpf2* pLPF)
+{
+    if (pLPF == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pLPF->bq);
+}
+
+
+MA_API ma_lpf_config ma_lpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_lpf_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format          = format;
+    config.channels        = channels;
+    config.sampleRate      = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.order           = ma_min(order, MA_MAX_FILTER_ORDER);
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t lpf1Offset;
+    size_t lpf2Offset;  /* Offset of the first second order filter. Subsequent filters will come straight after, and will each have the same heap size. */
+} ma_lpf_heap_layout;
+
+static void ma_lpf_calculate_sub_lpf_counts(ma_uint32 order, ma_uint32* pLPF1Count, ma_uint32* pLPF2Count)
+{
+    MA_ASSERT(pLPF1Count != NULL);
+    MA_ASSERT(pLPF2Count != NULL);
+
+    *pLPF1Count = order % 2;
+    *pLPF2Count = order / 2;
+}
+
+static ma_result ma_lpf_get_heap_layout(const ma_lpf_config* pConfig, ma_lpf_heap_layout* pHeapLayout)
+{
+    ma_result result;
+    ma_uint32 lpf1Count;
+    ma_uint32 lpf2Count;
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_lpf_calculate_sub_lpf_counts(pConfig->order, &lpf1Count, &lpf2Count);
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* LPF 1 */
+    pHeapLayout->lpf1Offset = pHeapLayout->sizeInBytes;
+    for (ilpf1 = 0; ilpf1 < lpf1Count; ilpf1 += 1) {
+        size_t lpf1HeapSizeInBytes;
+        ma_lpf1_config lpf1Config = ma_lpf1_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency);
+
+        result = ma_lpf1_get_heap_size(&lpf1Config, &lpf1HeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += sizeof(ma_lpf1) + lpf1HeapSizeInBytes;
+    }
+
+    /* LPF 2*/
+    pHeapLayout->lpf2Offset = pHeapLayout->sizeInBytes;
+    for (ilpf2 = 0; ilpf2 < lpf2Count; ilpf2 += 1) {
+        size_t lpf2HeapSizeInBytes;
+        ma_lpf2_config lpf2Config = ma_lpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, 0.707107);   /* <-- The "q" parameter does not matter for the purpose of calculating the heap size. */
+
+        result = ma_lpf2_get_heap_size(&lpf2Config, &lpf2HeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += sizeof(ma_lpf2) + lpf2HeapSizeInBytes;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_lpf_reinit__internal(const ma_lpf_config* pConfig, void* pHeap, ma_lpf* pLPF, ma_bool32 isNew)
+{
+    ma_result result;
+    ma_uint32 lpf1Count;
+    ma_uint32 lpf2Count;
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+    ma_lpf_heap_layout heapLayout;  /* Only used if isNew is true. */
+
+    if (pLPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pLPF->format != ma_format_unknown && pLPF->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pLPF->channels != 0 && pLPF->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_lpf_calculate_sub_lpf_counts(pConfig->order, &lpf1Count, &lpf2Count);
+
+    /* The filter order can't change between reinits. */
+    if (!isNew) {
+        if (pLPF->lpf1Count != lpf1Count || pLPF->lpf2Count != lpf2Count) {
+            return MA_INVALID_OPERATION;
+        }
+    }
+
+    if (isNew) {
+        result = ma_lpf_get_heap_layout(pConfig, &heapLayout);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pLPF->_pHeap = pHeap;
+        MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+        pLPF->pLPF1 = (ma_lpf1*)ma_offset_ptr(pHeap, heapLayout.lpf1Offset);
+        pLPF->pLPF2 = (ma_lpf2*)ma_offset_ptr(pHeap, heapLayout.lpf2Offset);
+    } else {
+        MA_ZERO_OBJECT(&heapLayout);    /* To silence a compiler warning. */
+    }
+
+    for (ilpf1 = 0; ilpf1 < lpf1Count; ilpf1 += 1) {
+        ma_lpf1_config lpf1Config = ma_lpf1_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency);
+
+        if (isNew) {
+            size_t lpf1HeapSizeInBytes;
+
+            result = ma_lpf1_get_heap_size(&lpf1Config, &lpf1HeapSizeInBytes);
+            if (result == MA_SUCCESS) {
+                result = ma_lpf1_init_preallocated(&lpf1Config, ma_offset_ptr(pHeap, heapLayout.lpf1Offset + (sizeof(ma_lpf1) * lpf1Count) + (ilpf1 * lpf1HeapSizeInBytes)), &pLPF->pLPF1[ilpf1]);
+            }
+        } else {
+            result = ma_lpf1_reinit(&lpf1Config, &pLPF->pLPF1[ilpf1]);
+        }
+
+        if (result != MA_SUCCESS) {
+            ma_uint32 jlpf1;
+
+            for (jlpf1 = 0; jlpf1 < ilpf1; jlpf1 += 1) {
+                ma_lpf1_uninit(&pLPF->pLPF1[jlpf1], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            return result;
+        }
+    }
+
+    for (ilpf2 = 0; ilpf2 < lpf2Count; ilpf2 += 1) {
+        ma_lpf2_config lpf2Config;
+        double q;
+        double a;
+
+        /* Tempting to use 0.707107, but won't result in a Butterworth filter if the order is > 2. */
+        if (lpf1Count == 1) {
+            a = (1 + ilpf2*1) * (MA_PI_D/(pConfig->order*1));   /* Odd order. */
+        } else {
+            a = (1 + ilpf2*2) * (MA_PI_D/(pConfig->order*2));   /* Even order. */
+        }
+        q = 1 / (2*ma_cosd(a));
+
+        lpf2Config = ma_lpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, q);
+
+        if (isNew) {
+            size_t lpf2HeapSizeInBytes;
+
+            result = ma_lpf2_get_heap_size(&lpf2Config, &lpf2HeapSizeInBytes);
+            if (result == MA_SUCCESS) {
+                result = ma_lpf2_init_preallocated(&lpf2Config, ma_offset_ptr(pHeap, heapLayout.lpf2Offset + (sizeof(ma_lpf2) * lpf2Count) + (ilpf2 * lpf2HeapSizeInBytes)), &pLPF->pLPF2[ilpf2]);
+            }
+        } else {
+            result = ma_lpf2_reinit(&lpf2Config, &pLPF->pLPF2[ilpf2]);
+        }
+
+        if (result != MA_SUCCESS) {
+            ma_uint32 jlpf1;
+            ma_uint32 jlpf2;
+
+            for (jlpf1 = 0; jlpf1 < lpf1Count; jlpf1 += 1) {
+                ma_lpf1_uninit(&pLPF->pLPF1[jlpf1], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            for (jlpf2 = 0; jlpf2 < ilpf2; jlpf2 += 1) {
+                ma_lpf2_uninit(&pLPF->pLPF2[jlpf2], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            return result;
+        }
+    }
+
+    pLPF->lpf1Count  = lpf1Count;
+    pLPF->lpf2Count  = lpf2Count;
+    pLPF->format     = pConfig->format;
+    pLPF->channels   = pConfig->channels;
+    pLPF->sampleRate = pConfig->sampleRate;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_lpf_get_heap_size(const ma_lpf_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_lpf_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_lpf_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return result;
+}
+
+MA_API ma_result ma_lpf_init_preallocated(const ma_lpf_config* pConfig, void* pHeap, ma_lpf* pLPF)
+{
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLPF);
+
+    return ma_lpf_reinit__internal(pConfig, pHeap, pLPF, /*isNew*/MA_TRUE);
+}
+
+MA_API ma_result ma_lpf_init(const ma_lpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf* pLPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_lpf_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_lpf_init_preallocated(pConfig, pHeap, pLPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pLPF->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_lpf_uninit(ma_lpf* pLPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    if (pLPF == NULL) {
+        return;
+    }
+
+    for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+        ma_lpf1_uninit(&pLPF->pLPF1[ilpf1], pAllocationCallbacks);
+    }
+
+    for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+        ma_lpf2_uninit(&pLPF->pLPF2[ilpf2], pAllocationCallbacks);
+    }
+
+    if (pLPF->_ownsHeap) {
+        ma_free(pLPF->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_lpf_reinit(const ma_lpf_config* pConfig, ma_lpf* pLPF)
+{
+    return ma_lpf_reinit__internal(pConfig, NULL, pLPF, /*isNew*/MA_FALSE);
+}
+
+MA_API ma_result ma_lpf_clear_cache(ma_lpf* pLPF)
+{
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+        ma_lpf1_clear_cache(&pLPF->pLPF1[ilpf1]);
+    }
+
+    for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+        ma_lpf2_clear_cache(&pLPF->pLPF2[ilpf2]);
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_lpf_process_pcm_frame_f32(ma_lpf* pLPF, float* pY, const void* pX)
+{
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    MA_ASSERT(pLPF->format == ma_format_f32);
+
+    MA_MOVE_MEMORY(pY, pX, ma_get_bytes_per_frame(pLPF->format, pLPF->channels));
+
+    for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+        ma_lpf1_process_pcm_frame_f32(&pLPF->pLPF1[ilpf1], pY, pY);
+    }
+
+    for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+        ma_lpf2_process_pcm_frame_f32(&pLPF->pLPF2[ilpf2], pY, pY);
+    }
+}
+
+static MA_INLINE void ma_lpf_process_pcm_frame_s16(ma_lpf* pLPF, ma_int16* pY, const ma_int16* pX)
+{
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    MA_ASSERT(pLPF->format == ma_format_s16);
+
+    MA_MOVE_MEMORY(pY, pX, ma_get_bytes_per_frame(pLPF->format, pLPF->channels));
+
+    for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+        ma_lpf1_process_pcm_frame_s16(&pLPF->pLPF1[ilpf1], pY, pY);
+    }
+
+    for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+        ma_lpf2_process_pcm_frame_s16(&pLPF->pLPF2[ilpf2], pY, pY);
+    }
+}
+
+MA_API ma_result ma_lpf_process_pcm_frames(ma_lpf* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_result result;
+    ma_uint32 ilpf1;
+    ma_uint32 ilpf2;
+
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Faster path for in-place. */
+    if (pFramesOut == pFramesIn) {
+        for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+            result = ma_lpf1_process_pcm_frames(&pLPF->pLPF1[ilpf1], pFramesOut, pFramesOut, frameCount);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+
+        for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+            result = ma_lpf2_process_pcm_frames(&pLPF->pLPF2[ilpf2], pFramesOut, pFramesOut, frameCount);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+    }
+
+    /* Slightly slower path for copying. */
+    if (pFramesOut != pFramesIn) {
+        ma_uint32 iFrame;
+
+        /*  */ if (pLPF->format == ma_format_f32) {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                ma_lpf_process_pcm_frame_f32(pLPF, pFramesOutF32, pFramesInF32);
+                pFramesOutF32 += pLPF->channels;
+                pFramesInF32  += pLPF->channels;
+            }
+        } else if (pLPF->format == ma_format_s16) {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                ma_lpf_process_pcm_frame_s16(pLPF, pFramesOutS16, pFramesInS16);
+                pFramesOutS16 += pLPF->channels;
+                pFramesInS16  += pLPF->channels;
+            }
+        } else {
+            MA_ASSERT(MA_FALSE);
+            return MA_INVALID_OPERATION;    /* Should never hit this. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_lpf_get_latency(const ma_lpf* pLPF)
+{
+    if (pLPF == NULL) {
+        return 0;
+    }
+
+    return pLPF->lpf2Count*2 + pLPF->lpf1Count;
+}
+
+
+/**************************************************************************************************************************************************************
+
+High-Pass Filtering
+
+**************************************************************************************************************************************************************/
+MA_API ma_hpf1_config ma_hpf1_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency)
+{
+    ma_hpf1_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+
+    return config;
+}
+
+MA_API ma_hpf2_config ma_hpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q)
+{
+    ma_hpf2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.q = q;
+
+    /* Q cannot be 0 or else it'll result in a division by 0. In this case just default to 0.707107. */
+    if (config.q == 0) {
+        config.q = 0.707107;
+    }
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t r1Offset;
+} ma_hpf1_heap_layout;
+
+static ma_result ma_hpf1_get_heap_layout(const ma_hpf1_config* pConfig, ma_hpf1_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* R1 */
+    pHeapLayout->r1Offset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(ma_biquad_coefficient) * pConfig->channels;
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_hpf1_get_heap_size(const ma_hpf1_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_hpf1_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_hpf1_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_hpf1_init_preallocated(const ma_hpf1_config* pConfig, void* pHeap, ma_hpf1* pLPF)
+{
+    ma_result result;
+    ma_hpf1_heap_layout heapLayout;
+
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLPF);
+
+    result = ma_hpf1_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pLPF->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pLPF->pR1 = (ma_biquad_coefficient*)ma_offset_ptr(pHeap, heapLayout.r1Offset);
+
+    return ma_hpf1_reinit(pConfig, pLPF);
+}
+
+MA_API ma_result ma_hpf1_init(const ma_hpf1_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf1* pLPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_hpf1_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_hpf1_init_preallocated(pConfig, pHeap, pLPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pLPF->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_hpf1_uninit(ma_hpf1* pHPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pHPF == NULL) {
+        return;
+    }
+
+    if (pHPF->_ownsHeap) {
+        ma_free(pHPF->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_hpf1_reinit(const ma_hpf1_config* pConfig, ma_hpf1* pHPF)
+{
+    double a;
+
+    if (pHPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pHPF->format != ma_format_unknown && pHPF->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pHPF->channels != 0 && pHPF->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+    pHPF->format   = pConfig->format;
+    pHPF->channels = pConfig->channels;
+
+    a = ma_expd(-2 * MA_PI_D * pConfig->cutoffFrequency / pConfig->sampleRate);
+    if (pConfig->format == ma_format_f32) {
+        pHPF->a.f32 = (float)a;
+    } else {
+        pHPF->a.s32 = ma_biquad_float_to_fp(a);
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_hpf1_process_pcm_frame_f32(ma_hpf1* pHPF, float* pY, const float* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pHPF->channels;
+    const float a = 1 - pHPF->a.f32;
+    const float b = 1 - a;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        float r1 = pHPF->pR1[c].f32;
+        float x  = pX[c];
+        float y;
+
+        y = b*x - a*r1;
+
+        pY[c]            = y;
+        pHPF->pR1[c].f32 = y;
+    }
+}
+
+static MA_INLINE void ma_hpf1_process_pcm_frame_s16(ma_hpf1* pHPF, ma_int16* pY, const ma_int16* pX)
+{
+    ma_uint32 c;
+    const ma_uint32 channels = pHPF->channels;
+    const ma_int32 a = ((1 << MA_BIQUAD_FIXED_POINT_SHIFT) - pHPF->a.s32);
+    const ma_int32 b = ((1 << MA_BIQUAD_FIXED_POINT_SHIFT) - a);
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        ma_int32 r1 = pHPF->pR1[c].s32;
+        ma_int32 x  = pX[c];
+        ma_int32 y;
+
+        y = (b*x - a*r1) >> MA_BIQUAD_FIXED_POINT_SHIFT;
+
+        pY[c]            = (ma_int16)y;
+        pHPF->pR1[c].s32 = (ma_int32)y;
+    }
+}
+
+MA_API ma_result ma_hpf1_process_pcm_frames(ma_hpf1* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint32 n;
+
+    if (pHPF == NULL || pFramesOut == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Note that the logic below needs to support in-place filtering. That is, it must support the case where pFramesOut and pFramesIn are the same. */
+
+    if (pHPF->format == ma_format_f32) {
+        /* */ float* pY = (      float*)pFramesOut;
+        const float* pX = (const float*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_hpf1_process_pcm_frame_f32(pHPF, pY, pX);
+            pY += pHPF->channels;
+            pX += pHPF->channels;
+        }
+    } else if (pHPF->format == ma_format_s16) {
+        /* */ ma_int16* pY = (      ma_int16*)pFramesOut;
+        const ma_int16* pX = (const ma_int16*)pFramesIn;
+
+        for (n = 0; n < frameCount; n += 1) {
+            ma_hpf1_process_pcm_frame_s16(pHPF, pY, pX);
+            pY += pHPF->channels;
+            pX += pHPF->channels;
+        }
+    } else {
+        MA_ASSERT(MA_FALSE);
+        return MA_INVALID_ARGS; /* Format not supported. Should never hit this because it's checked in ma_biquad_init() and ma_biquad_reinit(). */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_hpf1_get_latency(const ma_hpf1* pHPF)
+{
+    if (pHPF == NULL) {
+        return 0;
+    }
+
+    return 1;
+}
+
+
+static MA_INLINE ma_biquad_config ma_hpf2__get_biquad_config(const ma_hpf2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double q;
+    double w;
+    double s;
+    double c;
+    double a;
+
+    MA_ASSERT(pConfig != NULL);
+
+    q = pConfig->q;
+    w = 2 * MA_PI_D * pConfig->cutoffFrequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    a = s / (2*q);
+
+    bqConfig.b0 =  (1 + c) / 2;
+    bqConfig.b1 = -(1 + c);
+    bqConfig.b2 =  (1 + c) / 2;
+    bqConfig.a0 =   1 + a;
+    bqConfig.a1 =  -2 * c;
+    bqConfig.a2 =   1 - a;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_hpf2_get_heap_size(const ma_hpf2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_hpf2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_hpf2_init_preallocated(const ma_hpf2_config* pConfig, void* pHeap, ma_hpf2* pHPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pHPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pHPF);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_hpf2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pHPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_hpf2_init(const ma_hpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf2* pHPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_hpf2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_hpf2_init_preallocated(pConfig, pHeap, pHPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pHPF->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_hpf2_uninit(ma_hpf2* pHPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pHPF == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pHPF->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_hpf2_reinit(const ma_hpf2_config* pConfig, ma_hpf2* pHPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pHPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_hpf2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pHPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_hpf2_process_pcm_frame_s16(ma_hpf2* pHPF, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pHPF->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_hpf2_process_pcm_frame_f32(ma_hpf2* pHPF, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pHPF->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_hpf2_process_pcm_frames(ma_hpf2* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pHPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pHPF->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_hpf2_get_latency(const ma_hpf2* pHPF)
+{
+    if (pHPF == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pHPF->bq);
+}
+
+
+MA_API ma_hpf_config ma_hpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_hpf_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format          = format;
+    config.channels        = channels;
+    config.sampleRate      = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.order           = ma_min(order, MA_MAX_FILTER_ORDER);
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t hpf1Offset;
+    size_t hpf2Offset;  /* Offset of the first second order filter. Subsequent filters will come straight after, and will each have the same heap size. */
+} ma_hpf_heap_layout;
+
+static void ma_hpf_calculate_sub_hpf_counts(ma_uint32 order, ma_uint32* pHPF1Count, ma_uint32* pHPF2Count)
+{
+    MA_ASSERT(pHPF1Count != NULL);
+    MA_ASSERT(pHPF2Count != NULL);
+
+    *pHPF1Count = order % 2;
+    *pHPF2Count = order / 2;
+}
+
+static ma_result ma_hpf_get_heap_layout(const ma_hpf_config* pConfig, ma_hpf_heap_layout* pHeapLayout)
+{
+    ma_result result;
+    ma_uint32 hpf1Count;
+    ma_uint32 hpf2Count;
+    ma_uint32 ihpf1;
+    ma_uint32 ihpf2;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_hpf_calculate_sub_hpf_counts(pConfig->order, &hpf1Count, &hpf2Count);
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* HPF 1 */
+    pHeapLayout->hpf1Offset = pHeapLayout->sizeInBytes;
+    for (ihpf1 = 0; ihpf1 < hpf1Count; ihpf1 += 1) {
+        size_t hpf1HeapSizeInBytes;
+        ma_hpf1_config hpf1Config = ma_hpf1_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency);
+
+        result = ma_hpf1_get_heap_size(&hpf1Config, &hpf1HeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += sizeof(ma_hpf1) + hpf1HeapSizeInBytes;
+    }
+
+    /* HPF 2*/
+    pHeapLayout->hpf2Offset = pHeapLayout->sizeInBytes;
+    for (ihpf2 = 0; ihpf2 < hpf2Count; ihpf2 += 1) {
+        size_t hpf2HeapSizeInBytes;
+        ma_hpf2_config hpf2Config = ma_hpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, 0.707107);   /* <-- The "q" parameter does not matter for the purpose of calculating the heap size. */
+
+        result = ma_hpf2_get_heap_size(&hpf2Config, &hpf2HeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += sizeof(ma_hpf2) + hpf2HeapSizeInBytes;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_hpf_reinit__internal(const ma_hpf_config* pConfig, void* pHeap, ma_hpf* pHPF, ma_bool32 isNew)
+{
+    ma_result result;
+    ma_uint32 hpf1Count;
+    ma_uint32 hpf2Count;
+    ma_uint32 ihpf1;
+    ma_uint32 ihpf2;
+    ma_hpf_heap_layout heapLayout;  /* Only used if isNew is true. */
+
+    if (pHPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pHPF->format != ma_format_unknown && pHPF->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pHPF->channels != 0 && pHPF->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_hpf_calculate_sub_hpf_counts(pConfig->order, &hpf1Count, &hpf2Count);
+
+    /* The filter order can't change between reinits. */
+    if (!isNew) {
+        if (pHPF->hpf1Count != hpf1Count || pHPF->hpf2Count != hpf2Count) {
+            return MA_INVALID_OPERATION;
+        }
+    }
+
+    if (isNew) {
+        result = ma_hpf_get_heap_layout(pConfig, &heapLayout);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHPF->_pHeap = pHeap;
+        MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+        pHPF->pHPF1 = (ma_hpf1*)ma_offset_ptr(pHeap, heapLayout.hpf1Offset);
+        pHPF->pHPF2 = (ma_hpf2*)ma_offset_ptr(pHeap, heapLayout.hpf2Offset);
+    } else {
+        MA_ZERO_OBJECT(&heapLayout);    /* To silence a compiler warning. */
+    }
+
+    for (ihpf1 = 0; ihpf1 < hpf1Count; ihpf1 += 1) {
+        ma_hpf1_config hpf1Config = ma_hpf1_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency);
+
+        if (isNew) {
+            size_t hpf1HeapSizeInBytes;
+
+            result = ma_hpf1_get_heap_size(&hpf1Config, &hpf1HeapSizeInBytes);
+            if (result == MA_SUCCESS) {
+                result = ma_hpf1_init_preallocated(&hpf1Config, ma_offset_ptr(pHeap, heapLayout.hpf1Offset + (sizeof(ma_hpf1) * hpf1Count) + (ihpf1 * hpf1HeapSizeInBytes)), &pHPF->pHPF1[ihpf1]);
+            }
+        } else {
+            result = ma_hpf1_reinit(&hpf1Config, &pHPF->pHPF1[ihpf1]);
+        }
+
+        if (result != MA_SUCCESS) {
+            ma_uint32 jhpf1;
+
+            for (jhpf1 = 0; jhpf1 < ihpf1; jhpf1 += 1) {
+                ma_hpf1_uninit(&pHPF->pHPF1[jhpf1], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            return result;
+        }
+    }
+
+    for (ihpf2 = 0; ihpf2 < hpf2Count; ihpf2 += 1) {
+        ma_hpf2_config hpf2Config;
+        double q;
+        double a;
+
+        /* Tempting to use 0.707107, but won't result in a Butterworth filter if the order is > 2. */
+        if (hpf1Count == 1) {
+            a = (1 + ihpf2*1) * (MA_PI_D/(pConfig->order*1));   /* Odd order. */
+        } else {
+            a = (1 + ihpf2*2) * (MA_PI_D/(pConfig->order*2));   /* Even order. */
+        }
+        q = 1 / (2*ma_cosd(a));
+
+        hpf2Config = ma_hpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, q);
+
+        if (isNew) {
+            size_t hpf2HeapSizeInBytes;
+
+            result = ma_hpf2_get_heap_size(&hpf2Config, &hpf2HeapSizeInBytes);
+            if (result == MA_SUCCESS) {
+                result = ma_hpf2_init_preallocated(&hpf2Config, ma_offset_ptr(pHeap, heapLayout.hpf2Offset + (sizeof(ma_hpf2) * hpf2Count) + (ihpf2 * hpf2HeapSizeInBytes)), &pHPF->pHPF2[ihpf2]);
+            }
+        } else {
+            result = ma_hpf2_reinit(&hpf2Config, &pHPF->pHPF2[ihpf2]);
+        }
+
+        if (result != MA_SUCCESS) {
+            ma_uint32 jhpf1;
+            ma_uint32 jhpf2;
+
+            for (jhpf1 = 0; jhpf1 < hpf1Count; jhpf1 += 1) {
+                ma_hpf1_uninit(&pHPF->pHPF1[jhpf1], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            for (jhpf2 = 0; jhpf2 < ihpf2; jhpf2 += 1) {
+                ma_hpf2_uninit(&pHPF->pHPF2[jhpf2], NULL);  /* No need for allocation callbacks here since we used a preallocated heap allocation. */
+            }
+
+            return result;
+        }
+    }
+
+    pHPF->hpf1Count  = hpf1Count;
+    pHPF->hpf2Count  = hpf2Count;
+    pHPF->format     = pConfig->format;
+    pHPF->channels   = pConfig->channels;
+    pHPF->sampleRate = pConfig->sampleRate;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_hpf_get_heap_size(const ma_hpf_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_hpf_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_hpf_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return result;
+}
+
+MA_API ma_result ma_hpf_init_preallocated(const ma_hpf_config* pConfig, void* pHeap, ma_hpf* pLPF)
+{
+    if (pLPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pLPF);
+
+    return ma_hpf_reinit__internal(pConfig, pHeap, pLPF, /*isNew*/MA_TRUE);
+}
+
+MA_API ma_result ma_hpf_init(const ma_hpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf* pHPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_hpf_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_hpf_init_preallocated(pConfig, pHeap, pHPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pHPF->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_hpf_uninit(ma_hpf* pHPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_uint32 ihpf1;
+    ma_uint32 ihpf2;
+
+    if (pHPF == NULL) {
+        return;
+    }
+
+    for (ihpf1 = 0; ihpf1 < pHPF->hpf1Count; ihpf1 += 1) {
+        ma_hpf1_uninit(&pHPF->pHPF1[ihpf1], pAllocationCallbacks);
+    }
+
+    for (ihpf2 = 0; ihpf2 < pHPF->hpf2Count; ihpf2 += 1) {
+        ma_hpf2_uninit(&pHPF->pHPF2[ihpf2], pAllocationCallbacks);
+    }
+
+    if (pHPF->_ownsHeap) {
+        ma_free(pHPF->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_hpf_reinit(const ma_hpf_config* pConfig, ma_hpf* pHPF)
+{
+    return ma_hpf_reinit__internal(pConfig, NULL, pHPF, /*isNew*/MA_FALSE);
+}
+
+MA_API ma_result ma_hpf_process_pcm_frames(ma_hpf* pHPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_result result;
+    ma_uint32 ihpf1;
+    ma_uint32 ihpf2;
+
+    if (pHPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Faster path for in-place. */
+    if (pFramesOut == pFramesIn) {
+        for (ihpf1 = 0; ihpf1 < pHPF->hpf1Count; ihpf1 += 1) {
+            result = ma_hpf1_process_pcm_frames(&pHPF->pHPF1[ihpf1], pFramesOut, pFramesOut, frameCount);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+
+        for (ihpf2 = 0; ihpf2 < pHPF->hpf2Count; ihpf2 += 1) {
+            result = ma_hpf2_process_pcm_frames(&pHPF->pHPF2[ihpf2], pFramesOut, pFramesOut, frameCount);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+    }
+
+    /* Slightly slower path for copying. */
+    if (pFramesOut != pFramesIn) {
+        ma_uint32 iFrame;
+
+        /*  */ if (pHPF->format == ma_format_f32) {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                MA_COPY_MEMORY(pFramesOutF32, pFramesInF32, ma_get_bytes_per_frame(pHPF->format, pHPF->channels));
+
+                for (ihpf1 = 0; ihpf1 < pHPF->hpf1Count; ihpf1 += 1) {
+                    ma_hpf1_process_pcm_frame_f32(&pHPF->pHPF1[ihpf1], pFramesOutF32, pFramesOutF32);
+                }
+
+                for (ihpf2 = 0; ihpf2 < pHPF->hpf2Count; ihpf2 += 1) {
+                    ma_hpf2_process_pcm_frame_f32(&pHPF->pHPF2[ihpf2], pFramesOutF32, pFramesOutF32);
+                }
+
+                pFramesOutF32 += pHPF->channels;
+                pFramesInF32  += pHPF->channels;
+            }
+        } else if (pHPF->format == ma_format_s16) {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                MA_COPY_MEMORY(pFramesOutS16, pFramesInS16, ma_get_bytes_per_frame(pHPF->format, pHPF->channels));
+
+                for (ihpf1 = 0; ihpf1 < pHPF->hpf1Count; ihpf1 += 1) {
+                    ma_hpf1_process_pcm_frame_s16(&pHPF->pHPF1[ihpf1], pFramesOutS16, pFramesOutS16);
+                }
+
+                for (ihpf2 = 0; ihpf2 < pHPF->hpf2Count; ihpf2 += 1) {
+                    ma_hpf2_process_pcm_frame_s16(&pHPF->pHPF2[ihpf2], pFramesOutS16, pFramesOutS16);
+                }
+
+                pFramesOutS16 += pHPF->channels;
+                pFramesInS16  += pHPF->channels;
+            }
+        } else {
+            MA_ASSERT(MA_FALSE);
+            return MA_INVALID_OPERATION;    /* Should never hit this. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_hpf_get_latency(const ma_hpf* pHPF)
+{
+    if (pHPF == NULL) {
+        return 0;
+    }
+
+    return pHPF->hpf2Count*2 + pHPF->hpf1Count;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Band-Pass Filtering
+
+**************************************************************************************************************************************************************/
+MA_API ma_bpf2_config ma_bpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q)
+{
+    ma_bpf2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.q = q;
+
+    /* Q cannot be 0 or else it'll result in a division by 0. In this case just default to 0.707107. */
+    if (config.q == 0) {
+        config.q = 0.707107;
+    }
+
+    return config;
+}
+
+
+static MA_INLINE ma_biquad_config ma_bpf2__get_biquad_config(const ma_bpf2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double q;
+    double w;
+    double s;
+    double c;
+    double a;
+
+    MA_ASSERT(pConfig != NULL);
+
+    q = pConfig->q;
+    w = 2 * MA_PI_D * pConfig->cutoffFrequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    a = s / (2*q);
+
+    bqConfig.b0 =  q * a;
+    bqConfig.b1 =  0;
+    bqConfig.b2 = -q * a;
+    bqConfig.a0 =  1 + a;
+    bqConfig.a1 = -2 * c;
+    bqConfig.a2 =  1 - a;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_bpf2_get_heap_size(const ma_bpf2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_bpf2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_bpf2_init_preallocated(const ma_bpf2_config* pConfig, void* pHeap, ma_bpf2* pBPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pBPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pBPF);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_bpf2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pBPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_bpf2_init(const ma_bpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf2* pBPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_bpf2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_bpf2_init_preallocated(pConfig, pHeap, pBPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pBPF->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_bpf2_uninit(ma_bpf2* pBPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pBPF == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pBPF->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_bpf2_reinit(const ma_bpf2_config* pConfig, ma_bpf2* pBPF)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pBPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_bpf2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pBPF->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_bpf2_process_pcm_frame_s16(ma_bpf2* pBPF, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pBPF->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_bpf2_process_pcm_frame_f32(ma_bpf2* pBPF, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pBPF->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_bpf2_process_pcm_frames(ma_bpf2* pBPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pBPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pBPF->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_bpf2_get_latency(const ma_bpf2* pBPF)
+{
+    if (pBPF == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pBPF->bq);
+}
+
+
+MA_API ma_bpf_config ma_bpf_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_bpf_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format          = format;
+    config.channels        = channels;
+    config.sampleRate      = sampleRate;
+    config.cutoffFrequency = cutoffFrequency;
+    config.order           = ma_min(order, MA_MAX_FILTER_ORDER);
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t bpf2Offset;
+} ma_bpf_heap_layout;
+
+static ma_result ma_bpf_get_heap_layout(const ma_bpf_config* pConfig, ma_bpf_heap_layout* pHeapLayout)
+{
+    ma_result result;
+    ma_uint32 bpf2Count;
+    ma_uint32 ibpf2;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* We must have an even number of order. */
+    if ((pConfig->order & 0x1) != 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    bpf2Count = pConfig->channels / 2;
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* BPF 2 */
+    pHeapLayout->bpf2Offset = pHeapLayout->sizeInBytes;
+    for (ibpf2 = 0; ibpf2 < bpf2Count; ibpf2 += 1) {
+        size_t bpf2HeapSizeInBytes;
+        ma_bpf2_config bpf2Config = ma_bpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, 0.707107);   /* <-- The "q" parameter does not matter for the purpose of calculating the heap size. */
+
+        result = ma_bpf2_get_heap_size(&bpf2Config, &bpf2HeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += sizeof(ma_bpf2) + bpf2HeapSizeInBytes;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_bpf_reinit__internal(const ma_bpf_config* pConfig, void* pHeap, ma_bpf* pBPF, ma_bool32 isNew)
+{
+    ma_result result;
+    ma_uint32 bpf2Count;
+    ma_uint32 ibpf2;
+    ma_bpf_heap_layout heapLayout;  /* Only used if isNew is true. */
+
+    if (pBPF == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only supporting f32 and s16. */
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The format cannot be changed after initialization. */
+    if (pBPF->format != ma_format_unknown && pBPF->format != pConfig->format) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The channel count cannot be changed after initialization. */
+    if (pBPF->channels != 0 && pBPF->channels != pConfig->channels) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pConfig->order > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* We must have an even number of order. */
+    if ((pConfig->order & 0x1) != 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    bpf2Count = pConfig->order / 2;
+
+    /* The filter order can't change between reinits. */
+    if (!isNew) {
+        if (pBPF->bpf2Count != bpf2Count) {
+            return MA_INVALID_OPERATION;
+        }
+    }
+
+    if (isNew) {
+        result = ma_bpf_get_heap_layout(pConfig, &heapLayout);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pBPF->_pHeap = pHeap;
+        MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+        pBPF->pBPF2 = (ma_bpf2*)ma_offset_ptr(pHeap, heapLayout.bpf2Offset);
+    } else {
+        MA_ZERO_OBJECT(&heapLayout);
+    }
+
+    for (ibpf2 = 0; ibpf2 < bpf2Count; ibpf2 += 1) {
+        ma_bpf2_config bpf2Config;
+        double q;
+
+        /* TODO: Calculate Q to make this a proper Butterworth filter. */
+        q = 0.707107;
+
+        bpf2Config = ma_bpf2_config_init(pConfig->format, pConfig->channels, pConfig->sampleRate, pConfig->cutoffFrequency, q);
+
+        if (isNew) {
+            size_t bpf2HeapSizeInBytes;
+
+            result = ma_bpf2_get_heap_size(&bpf2Config, &bpf2HeapSizeInBytes);
+            if (result == MA_SUCCESS) {
+                result = ma_bpf2_init_preallocated(&bpf2Config, ma_offset_ptr(pHeap, heapLayout.bpf2Offset + (sizeof(ma_bpf2) * bpf2Count) + (ibpf2 * bpf2HeapSizeInBytes)), &pBPF->pBPF2[ibpf2]);
+            }
+        } else {
+            result = ma_bpf2_reinit(&bpf2Config, &pBPF->pBPF2[ibpf2]);
+        }
+
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    pBPF->bpf2Count = bpf2Count;
+    pBPF->format    = pConfig->format;
+    pBPF->channels  = pConfig->channels;
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_bpf_get_heap_size(const ma_bpf_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_bpf_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_bpf_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_bpf_init_preallocated(const ma_bpf_config* pConfig, void* pHeap, ma_bpf* pBPF)
+{
+    if (pBPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pBPF);
+
+    return ma_bpf_reinit__internal(pConfig, pHeap, pBPF, /*isNew*/MA_TRUE);
+}
+
+MA_API ma_result ma_bpf_init(const ma_bpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf* pBPF)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_bpf_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_bpf_init_preallocated(pConfig, pHeap, pBPF);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pBPF->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_bpf_uninit(ma_bpf* pBPF, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_uint32 ibpf2;
+
+    if (pBPF == NULL) {
+        return;
+    }
+
+    for (ibpf2 = 0; ibpf2 < pBPF->bpf2Count; ibpf2 += 1) {
+        ma_bpf2_uninit(&pBPF->pBPF2[ibpf2], pAllocationCallbacks);
+    }
+
+    if (pBPF->_ownsHeap) {
+        ma_free(pBPF->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_bpf_reinit(const ma_bpf_config* pConfig, ma_bpf* pBPF)
+{
+    return ma_bpf_reinit__internal(pConfig, NULL, pBPF, /*isNew*/MA_FALSE);
+}
+
+MA_API ma_result ma_bpf_process_pcm_frames(ma_bpf* pBPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_result result;
+    ma_uint32 ibpf2;
+
+    if (pBPF == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Faster path for in-place. */
+    if (pFramesOut == pFramesIn) {
+        for (ibpf2 = 0; ibpf2 < pBPF->bpf2Count; ibpf2 += 1) {
+            result = ma_bpf2_process_pcm_frames(&pBPF->pBPF2[ibpf2], pFramesOut, pFramesOut, frameCount);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+        }
+    }
+
+    /* Slightly slower path for copying. */
+    if (pFramesOut != pFramesIn) {
+        ma_uint32 iFrame;
+
+        /*  */ if (pBPF->format == ma_format_f32) {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                MA_COPY_MEMORY(pFramesOutF32, pFramesInF32, ma_get_bytes_per_frame(pBPF->format, pBPF->channels));
+
+                for (ibpf2 = 0; ibpf2 < pBPF->bpf2Count; ibpf2 += 1) {
+                    ma_bpf2_process_pcm_frame_f32(&pBPF->pBPF2[ibpf2], pFramesOutF32, pFramesOutF32);
+                }
+
+                pFramesOutF32 += pBPF->channels;
+                pFramesInF32  += pBPF->channels;
+            }
+        } else if (pBPF->format == ma_format_s16) {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                MA_COPY_MEMORY(pFramesOutS16, pFramesInS16, ma_get_bytes_per_frame(pBPF->format, pBPF->channels));
+
+                for (ibpf2 = 0; ibpf2 < pBPF->bpf2Count; ibpf2 += 1) {
+                    ma_bpf2_process_pcm_frame_s16(&pBPF->pBPF2[ibpf2], pFramesOutS16, pFramesOutS16);
+                }
+
+                pFramesOutS16 += pBPF->channels;
+                pFramesInS16  += pBPF->channels;
+            }
+        } else {
+            MA_ASSERT(MA_FALSE);
+            return MA_INVALID_OPERATION;    /* Should never hit this. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint32 ma_bpf_get_latency(const ma_bpf* pBPF)
+{
+    if (pBPF == NULL) {
+        return 0;
+    }
+
+    return pBPF->bpf2Count*2;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Notching Filter
+
+**************************************************************************************************************************************************************/
+MA_API ma_notch2_config ma_notch2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double q, double frequency)
+{
+    ma_notch2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.q          = q;
+    config.frequency  = frequency;
+
+    if (config.q == 0) {
+        config.q = 0.707107;
+    }
+
+    return config;
+}
+
+
+static MA_INLINE ma_biquad_config ma_notch2__get_biquad_config(const ma_notch2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double q;
+    double w;
+    double s;
+    double c;
+    double a;
+
+    MA_ASSERT(pConfig != NULL);
+
+    q = pConfig->q;
+    w = 2 * MA_PI_D * pConfig->frequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    a = s / (2*q);
+
+    bqConfig.b0 =  1;
+    bqConfig.b1 = -2 * c;
+    bqConfig.b2 =  1;
+    bqConfig.a0 =  1 + a;
+    bqConfig.a1 = -2 * c;
+    bqConfig.a2 =  1 - a;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_notch2_get_heap_size(const ma_notch2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_notch2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_notch2_init_preallocated(const ma_notch2_config* pConfig, void* pHeap, ma_notch2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFilter);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_notch2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_notch2_init(const ma_notch2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_notch2* pFilter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_notch2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_notch2_init_preallocated(pConfig, pHeap, pFilter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pFilter->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_notch2_uninit(ma_notch2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFilter == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pFilter->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_notch2_reinit(const ma_notch2_config* pConfig, ma_notch2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_notch2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_notch2_process_pcm_frame_s16(ma_notch2* pFilter, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_notch2_process_pcm_frame_f32(ma_notch2* pFilter, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_notch2_process_pcm_frames(ma_notch2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pFilter->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_notch2_get_latency(const ma_notch2* pFilter)
+{
+    if (pFilter == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pFilter->bq);
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Peaking EQ Filter
+
+**************************************************************************************************************************************************************/
+MA_API ma_peak2_config ma_peak2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency)
+{
+    ma_peak2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.gainDB     = gainDB;
+    config.q          = q;
+    config.frequency  = frequency;
+
+    if (config.q == 0) {
+        config.q = 0.707107;
+    }
+
+    return config;
+}
+
+
+static MA_INLINE ma_biquad_config ma_peak2__get_biquad_config(const ma_peak2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double q;
+    double w;
+    double s;
+    double c;
+    double a;
+    double A;
+
+    MA_ASSERT(pConfig != NULL);
+
+    q = pConfig->q;
+    w = 2 * MA_PI_D * pConfig->frequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    a = s / (2*q);
+    A = ma_powd(10, (pConfig->gainDB / 40));
+
+    bqConfig.b0 =  1 + (a * A);
+    bqConfig.b1 = -2 * c;
+    bqConfig.b2 =  1 - (a * A);
+    bqConfig.a0 =  1 + (a / A);
+    bqConfig.a1 = -2 * c;
+    bqConfig.a2 =  1 - (a / A);
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_peak2_get_heap_size(const ma_peak2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_peak2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_peak2_init_preallocated(const ma_peak2_config* pConfig, void* pHeap, ma_peak2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFilter);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_peak2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_peak2_init(const ma_peak2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_peak2* pFilter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_peak2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_peak2_init_preallocated(pConfig, pHeap, pFilter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pFilter->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_peak2_uninit(ma_peak2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFilter == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pFilter->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_peak2_reinit(const ma_peak2_config* pConfig, ma_peak2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_peak2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_peak2_process_pcm_frame_s16(ma_peak2* pFilter, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_peak2_process_pcm_frame_f32(ma_peak2* pFilter, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_peak2_process_pcm_frames(ma_peak2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pFilter->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_peak2_get_latency(const ma_peak2* pFilter)
+{
+    if (pFilter == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pFilter->bq);
+}
+
+
+/**************************************************************************************************************************************************************
+
+Low Shelf Filter
+
+**************************************************************************************************************************************************************/
+MA_API ma_loshelf2_config ma_loshelf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double shelfSlope, double frequency)
+{
+    ma_loshelf2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.gainDB     = gainDB;
+    config.shelfSlope = shelfSlope;
+    config.frequency  = frequency;
+
+    return config;
+}
+
+
+static MA_INLINE ma_biquad_config ma_loshelf2__get_biquad_config(const ma_loshelf2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double w;
+    double s;
+    double c;
+    double A;
+    double S;
+    double a;
+    double sqrtA;
+
+    MA_ASSERT(pConfig != NULL);
+
+    w = 2 * MA_PI_D * pConfig->frequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    A = ma_powd(10, (pConfig->gainDB / 40));
+    S = pConfig->shelfSlope;
+    a = s/2 * ma_sqrtd((A + 1/A) * (1/S - 1) + 2);
+    sqrtA = 2*ma_sqrtd(A)*a;
+
+    bqConfig.b0 =  A * ((A + 1) - (A - 1)*c + sqrtA);
+    bqConfig.b1 =  2 * A * ((A - 1) - (A + 1)*c);
+    bqConfig.b2 =  A * ((A + 1) - (A - 1)*c - sqrtA);
+    bqConfig.a0 =  (A + 1) + (A - 1)*c + sqrtA;
+    bqConfig.a1 = -2 * ((A - 1) + (A + 1)*c);
+    bqConfig.a2 =  (A + 1) + (A - 1)*c - sqrtA;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_loshelf2_get_heap_size(const ma_loshelf2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_loshelf2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_loshelf2_init_preallocated(const ma_loshelf2_config* pConfig, void* pHeap, ma_loshelf2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFilter);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_loshelf2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_loshelf2_init(const ma_loshelf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_loshelf2* pFilter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_loshelf2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_loshelf2_init_preallocated(pConfig, pHeap, pFilter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pFilter->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_loshelf2_uninit(ma_loshelf2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFilter == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pFilter->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_loshelf2_reinit(const ma_loshelf2_config* pConfig, ma_loshelf2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_loshelf2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_loshelf2_process_pcm_frame_s16(ma_loshelf2* pFilter, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_loshelf2_process_pcm_frame_f32(ma_loshelf2* pFilter, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_loshelf2_process_pcm_frames(ma_loshelf2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pFilter->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_loshelf2_get_latency(const ma_loshelf2* pFilter)
+{
+    if (pFilter == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pFilter->bq);
+}
+
+
+/**************************************************************************************************************************************************************
+
+High Shelf Filter
+
+**************************************************************************************************************************************************************/
+MA_API ma_hishelf2_config ma_hishelf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double shelfSlope, double frequency)
+{
+    ma_hishelf2_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.gainDB     = gainDB;
+    config.shelfSlope = shelfSlope;
+    config.frequency  = frequency;
+
+    return config;
+}
+
+
+static MA_INLINE ma_biquad_config ma_hishelf2__get_biquad_config(const ma_hishelf2_config* pConfig)
+{
+    ma_biquad_config bqConfig;
+    double w;
+    double s;
+    double c;
+    double A;
+    double S;
+    double a;
+    double sqrtA;
+
+    MA_ASSERT(pConfig != NULL);
+
+    w = 2 * MA_PI_D * pConfig->frequency / pConfig->sampleRate;
+    s = ma_sind(w);
+    c = ma_cosd(w);
+    A = ma_powd(10, (pConfig->gainDB / 40));
+    S = pConfig->shelfSlope;
+    a = s/2 * ma_sqrtd((A + 1/A) * (1/S - 1) + 2);
+    sqrtA = 2*ma_sqrtd(A)*a;
+
+    bqConfig.b0 =  A * ((A + 1) + (A - 1)*c + sqrtA);
+    bqConfig.b1 = -2 * A * ((A - 1) + (A + 1)*c);
+    bqConfig.b2 =  A * ((A + 1) + (A - 1)*c - sqrtA);
+    bqConfig.a0 =  (A + 1) - (A - 1)*c + sqrtA;
+    bqConfig.a1 =  2 * ((A - 1) - (A + 1)*c);
+    bqConfig.a2 =  (A + 1) - (A - 1)*c - sqrtA;
+
+    bqConfig.format   = pConfig->format;
+    bqConfig.channels = pConfig->channels;
+
+    return bqConfig;
+}
+
+MA_API ma_result ma_hishelf2_get_heap_size(const ma_hishelf2_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_biquad_config bqConfig;
+    bqConfig = ma_hishelf2__get_biquad_config(pConfig);
+
+    return ma_biquad_get_heap_size(&bqConfig, pHeapSizeInBytes);
+}
+
+MA_API ma_result ma_hishelf2_init_preallocated(const ma_hishelf2_config* pConfig, void* pHeap, ma_hishelf2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFilter);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_hishelf2__get_biquad_config(pConfig);
+    result = ma_biquad_init_preallocated(&bqConfig, pHeap, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_hishelf2_init(const ma_hishelf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hishelf2* pFilter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_hishelf2_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_hishelf2_init_preallocated(pConfig, pHeap, pFilter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pFilter->bq._ownsHeap = MA_TRUE;    /* <-- This will cause the biquad to take ownership of the heap and free it when it's uninitialized. */
+    return MA_SUCCESS;
+}
+
+MA_API void ma_hishelf2_uninit(ma_hishelf2* pFilter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFilter == NULL) {
+        return;
+    }
+
+    ma_biquad_uninit(&pFilter->bq, pAllocationCallbacks);   /* <-- This will free the heap allocation. */
+}
+
+MA_API ma_result ma_hishelf2_reinit(const ma_hishelf2_config* pConfig, ma_hishelf2* pFilter)
+{
+    ma_result result;
+    ma_biquad_config bqConfig;
+
+    if (pFilter == NULL || pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    bqConfig = ma_hishelf2__get_biquad_config(pConfig);
+    result = ma_biquad_reinit(&bqConfig, &pFilter->bq);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static MA_INLINE void ma_hishelf2_process_pcm_frame_s16(ma_hishelf2* pFilter, ma_int16* pFrameOut, const ma_int16* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_s16(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+static MA_INLINE void ma_hishelf2_process_pcm_frame_f32(ma_hishelf2* pFilter, float* pFrameOut, const float* pFrameIn)
+{
+    ma_biquad_process_pcm_frame_f32(&pFilter->bq, pFrameOut, pFrameIn);
+}
+
+MA_API ma_result ma_hishelf2_process_pcm_frames(ma_hishelf2* pFilter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pFilter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_biquad_process_pcm_frames(&pFilter->bq, pFramesOut, pFramesIn, frameCount);
+}
+
+MA_API ma_uint32 ma_hishelf2_get_latency(const ma_hishelf2* pFilter)
+{
+    if (pFilter == NULL) {
+        return 0;
+    }
+
+    return ma_biquad_get_latency(&pFilter->bq);
+}
+
+
+
+/*
+Delay
+*/
+MA_API ma_delay_config ma_delay_config_init(ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 delayInFrames, float decay)
+{
+    ma_delay_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.channels      = channels;
+    config.sampleRate    = sampleRate;
+    config.delayInFrames = delayInFrames;
+    config.delayStart    = (decay == 0) ? MA_TRUE : MA_FALSE;   /* Delay the start if it looks like we're not configuring an echo. */
+    config.wet           = 1;
+    config.dry           = 1;
+    config.decay         = decay;
+
+    return config;
+}
+
+
+MA_API ma_result ma_delay_init(const ma_delay_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_delay* pDelay)
+{
+    if (pDelay == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDelay);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->decay < 0 || pConfig->decay > 1) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDelay->config             = *pConfig;
+    pDelay->bufferSizeInFrames = pConfig->delayInFrames;
+    pDelay->cursor             = 0;
+
+    pDelay->pBuffer = (float*)ma_malloc((size_t)(pDelay->bufferSizeInFrames * ma_get_bytes_per_frame(ma_format_f32, pConfig->channels)), pAllocationCallbacks);
+    if (pDelay->pBuffer == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    ma_silence_pcm_frames(pDelay->pBuffer, pDelay->bufferSizeInFrames, ma_format_f32, pConfig->channels);
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_delay_uninit(ma_delay* pDelay, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pDelay == NULL) {
+        return;
+    }
+
+    ma_free(pDelay->pBuffer, pAllocationCallbacks);
+}
+
+MA_API ma_result ma_delay_process_pcm_frames(ma_delay* pDelay, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
+{
+    ma_uint32 iFrame;
+    ma_uint32 iChannel;
+    float* pFramesOutF32 = (float*)pFramesOut;
+    const float* pFramesInF32 = (const float*)pFramesIn;
+
+    if (pDelay == NULL || pFramesOut == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannel = 0; iChannel < pDelay->config.channels; iChannel += 1) {
+            ma_uint32 iBuffer = (pDelay->cursor * pDelay->config.channels) + iChannel;
+
+            if (pDelay->config.delayStart) {
+                /* Delayed start. */
+
+                /* Read */
+                pFramesOutF32[iChannel] = pDelay->pBuffer[iBuffer] * pDelay->config.wet;
+
+                /* Feedback */
+                pDelay->pBuffer[iBuffer] = (pDelay->pBuffer[iBuffer] * pDelay->config.decay) + (pFramesInF32[iChannel] * pDelay->config.dry);
+            } else {
+                /* Immediate start */
+
+                /* Feedback */
+                pDelay->pBuffer[iBuffer] = (pDelay->pBuffer[iBuffer] * pDelay->config.decay) + (pFramesInF32[iChannel] * pDelay->config.dry);
+
+                /* Read */
+                pFramesOutF32[iChannel] = pDelay->pBuffer[iBuffer] * pDelay->config.wet;
+            }
+        }
+
+        pDelay->cursor = (pDelay->cursor + 1) % pDelay->bufferSizeInFrames;
+
+        pFramesOutF32 += pDelay->config.channels;
+        pFramesInF32  += pDelay->config.channels;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_delay_set_wet(ma_delay* pDelay, float value)
+{
+    if (pDelay == NULL) {
+        return;
+    }
+
+    pDelay->config.wet = value;
+}
+
+MA_API float ma_delay_get_wet(const ma_delay* pDelay)
+{
+    if (pDelay == NULL) {
+        return 0;
+    }
+
+    return pDelay->config.wet;
+}
+
+MA_API void ma_delay_set_dry(ma_delay* pDelay, float value)
+{
+    if (pDelay == NULL) {
+        return;
+    }
+
+    pDelay->config.dry = value;
+}
+
+MA_API float ma_delay_get_dry(const ma_delay* pDelay)
+{
+    if (pDelay == NULL) {
+        return 0;
+    }
+
+    return pDelay->config.dry;
+}
+
+MA_API void ma_delay_set_decay(ma_delay* pDelay, float value)
+{
+    if (pDelay == NULL) {
+        return;
+    }
+
+    pDelay->config.decay = value;
+}
+
+MA_API float ma_delay_get_decay(const ma_delay* pDelay)
+{
+    if (pDelay == NULL) {
+        return 0;
+    }
+
+    return pDelay->config.decay;
+}
+
+
+MA_API ma_gainer_config ma_gainer_config_init(ma_uint32 channels, ma_uint32 smoothTimeInFrames)
+{
+    ma_gainer_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.channels           = channels;
+    config.smoothTimeInFrames = smoothTimeInFrames;
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t oldGainsOffset;
+    size_t newGainsOffset;
+} ma_gainer_heap_layout;
+
+static ma_result ma_gainer_get_heap_layout(const ma_gainer_config* pConfig, ma_gainer_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Old gains. */
+    pHeapLayout->oldGainsOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(float) * pConfig->channels;
+
+    /* New gains. */
+    pHeapLayout->newGainsOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += sizeof(float) * pConfig->channels;
+
+    /* Alignment. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_gainer_get_heap_size(const ma_gainer_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_gainer_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_gainer_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_gainer_init_preallocated(const ma_gainer_config* pConfig, void* pHeap, ma_gainer* pGainer)
+{
+    ma_result result;
+    ma_gainer_heap_layout heapLayout;
+    ma_uint32 iChannel;
+
+    if (pGainer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pGainer);
+
+    if (pConfig == NULL || pHeap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_gainer_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pGainer->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pGainer->pOldGains = (float*)ma_offset_ptr(pHeap, heapLayout.oldGainsOffset);
+    pGainer->pNewGains = (float*)ma_offset_ptr(pHeap, heapLayout.newGainsOffset);
+    pGainer->masterVolume = 1;
+
+    pGainer->config = *pConfig;
+    pGainer->t      = (ma_uint32)-1;  /* No interpolation by default. */
+
+    for (iChannel = 0; iChannel < pConfig->channels; iChannel += 1) {
+        pGainer->pOldGains[iChannel] = 1;
+        pGainer->pNewGains[iChannel] = 1;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_gainer_init(const ma_gainer_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_gainer* pGainer)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_gainer_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the size of the heap allocation. */
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_gainer_init_preallocated(pConfig, pHeap, pGainer);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pGainer->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_gainer_uninit(ma_gainer* pGainer, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pGainer == NULL) {
+        return;
+    }
+
+    if (pGainer->_ownsHeap) {
+        ma_free(pGainer->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static float ma_gainer_calculate_current_gain(const ma_gainer* pGainer, ma_uint32 channel)
+{
+    float a = (float)pGainer->t / pGainer->config.smoothTimeInFrames;
+    return ma_mix_f32_fast(pGainer->pOldGains[channel], pGainer->pNewGains[channel], a);
+}
+
+static /*__attribute__((noinline))*/ ma_result ma_gainer_process_pcm_frames_internal(ma_gainer * pGainer, void* MA_RESTRICT pFramesOut, const void* MA_RESTRICT pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannel;
+    ma_uint64 interpolatedFrameCount;
+
+    MA_ASSERT(pGainer != NULL);
+
+    /*
+    We don't necessarily need to apply a linear interpolation for the entire frameCount frames. When
+    linear interpolation is not needed we can do a simple volume adjustment which will be more
+    efficient than a lerp with an alpha value of 1.
+
+    To do this, all we need to do is determine how many frames need to have a lerp applied. Then we
+    just process that number of frames with linear interpolation. After that we run on an optimized
+    path which just applies the new gains without a lerp.
+    */
+    if (pGainer->t >= pGainer->config.smoothTimeInFrames) {
+        interpolatedFrameCount = 0;
+    } else {
+        interpolatedFrameCount = pGainer->t - pGainer->config.smoothTimeInFrames;
+        if (interpolatedFrameCount > frameCount) {
+            interpolatedFrameCount = frameCount;
+        }
+    }
+
+    /*
+    Start off with our interpolated frames. When we do this, we'll adjust frameCount and our pointers
+    so that the fast path can work naturally without consideration of the interpolated path.
+    */
+    if (interpolatedFrameCount > 0) {
+        /* We can allow the input and output buffers to be null in which case we'll just update the internal timer. */
+        if (pFramesOut != NULL && pFramesIn != NULL) {
+            /*
+            All we're really doing here is moving the old gains towards the new gains. We don't want to
+            be modifying the gains inside the ma_gainer object because that will break things. Instead
+            we can make a copy here on the stack. For extreme channel counts we can fall back to a slower
+            implementation which just uses a standard lerp.
+            */
+            float* pFramesOutF32 = (float*)pFramesOut;
+            const float* pFramesInF32 = (const float*)pFramesIn;
+            float a = (float)pGainer->t / pGainer->config.smoothTimeInFrames;
+            float d = 1.0f / pGainer->config.smoothTimeInFrames;
+
+            if (pGainer->config.channels <= 32) {
+                float pRunningGain[32];
+                float pRunningGainDelta[32];    /* Could this be heap-allocated as part of the ma_gainer object? */
+
+                /* Initialize the running gain. */
+                for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                    float t = (pGainer->pNewGains[iChannel] - pGainer->pOldGains[iChannel]) * pGainer->masterVolume;
+                    pRunningGainDelta[iChannel] = t * d;
+                    pRunningGain[iChannel] = (pGainer->pOldGains[iChannel] * pGainer->masterVolume) + (t * a);
+                }
+
+                iFrame = 0;
+
+                /* Optimized paths for common channel counts. This is mostly just experimenting with some SIMD ideas. It's not necessarily final. */
+                if (pGainer->config.channels == 2) {
+                #if defined(MA_SUPPORT_SSE2)
+                    if (ma_has_sse2()) {
+                        ma_uint64 unrolledLoopCount = interpolatedFrameCount >> 1;
+
+                        /* Expand some arrays so we can have a clean SIMD loop below. */
+                        __m128 runningGainDelta0 = _mm_set_ps(pRunningGainDelta[1], pRunningGainDelta[0], pRunningGainDelta[1], pRunningGainDelta[0]);
+                        __m128 runningGain0      = _mm_set_ps(pRunningGain[1] + pRunningGainDelta[1], pRunningGain[0] + pRunningGainDelta[0], pRunningGain[1], pRunningGain[0]);
+
+                        for (; iFrame < unrolledLoopCount; iFrame += 1) {
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*4 + 0], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*4 + 0]), runningGain0));
+                            runningGain0 = _mm_add_ps(runningGain0, runningGainDelta0);
+                        }
+
+                        iFrame = unrolledLoopCount << 1;
+                    } else
+                #endif
+                    {
+                        /*
+                        Two different scalar implementations here. Clang (and I assume GCC) will vectorize
+                        both of these, but the bottom version results in a nicer vectorization with less
+                        instructions emitted. The problem, however, is that the bottom version runs slower
+                        when compiled with MSVC. The top version will be partially vectorized by MSVC.
+                        */
+                    #if defined(_MSC_VER) && !defined(__clang__)
+                        ma_uint64 unrolledLoopCount = interpolatedFrameCount >> 1;
+
+                        /* Expand some arrays so we can have a clean 4x SIMD operation in the loop. */
+                        pRunningGainDelta[2] = pRunningGainDelta[0];
+                        pRunningGainDelta[3] = pRunningGainDelta[1];
+                        pRunningGain[2] = pRunningGain[0] + pRunningGainDelta[0];
+                        pRunningGain[3] = pRunningGain[1] + pRunningGainDelta[1];
+
+                        for (; iFrame < unrolledLoopCount; iFrame += 1) {
+                            pFramesOutF32[iFrame*4 + 0] = pFramesInF32[iFrame*4 + 0] * pRunningGain[0];
+                            pFramesOutF32[iFrame*4 + 1] = pFramesInF32[iFrame*4 + 1] * pRunningGain[1];
+                            pFramesOutF32[iFrame*4 + 2] = pFramesInF32[iFrame*4 + 2] * pRunningGain[2];
+                            pFramesOutF32[iFrame*4 + 3] = pFramesInF32[iFrame*4 + 3] * pRunningGain[3];
+
+                            /* Move the running gain forward towards the new gain. */
+                            pRunningGain[0] += pRunningGainDelta[0];
+                            pRunningGain[1] += pRunningGainDelta[1];
+                            pRunningGain[2] += pRunningGainDelta[2];
+                            pRunningGain[3] += pRunningGainDelta[3];
+                        }
+
+                        iFrame = unrolledLoopCount << 1;
+                    #else
+                        for (; iFrame < interpolatedFrameCount; iFrame += 1) {
+                            for (iChannel = 0; iChannel < 2; iChannel += 1) {
+                                pFramesOutF32[iFrame*2 + iChannel] = pFramesInF32[iFrame*2 + iChannel] * pRunningGain[iChannel];
+                            }
+
+                            for (iChannel = 0; iChannel < 2; iChannel += 1) {
+                                pRunningGain[iChannel] += pRunningGainDelta[iChannel];
+                            }
+                        }
+                    #endif
+                    }
+                } else if (pGainer->config.channels == 6) {
+                #if defined(MA_SUPPORT_SSE2)
+                    if (ma_has_sse2()) {
+                        /*
+                        For 6 channels things are a bit more complicated because 6 isn't cleanly divisible by 4. We need to do 2 frames
+                        at a time, meaning we'll be doing 12 samples in a group. Like the stereo case we'll need to expand some arrays
+                        so we can do clean 4x SIMD operations.
+                        */
+                        ma_uint64 unrolledLoopCount = interpolatedFrameCount >> 1;
+
+                        /* Expand some arrays so we can have a clean SIMD loop below. */
+                        __m128 runningGainDelta0 = _mm_set_ps(pRunningGainDelta[3], pRunningGainDelta[2], pRunningGainDelta[1], pRunningGainDelta[0]);
+                        __m128 runningGainDelta1 = _mm_set_ps(pRunningGainDelta[1], pRunningGainDelta[0], pRunningGainDelta[5], pRunningGainDelta[4]);
+                        __m128 runningGainDelta2 = _mm_set_ps(pRunningGainDelta[5], pRunningGainDelta[4], pRunningGainDelta[3], pRunningGainDelta[2]);
+
+                        __m128 runningGain0      = _mm_set_ps(pRunningGain[3],                        pRunningGain[2],                        pRunningGain[1],                        pRunningGain[0]);
+                        __m128 runningGain1      = _mm_set_ps(pRunningGain[1] + pRunningGainDelta[1], pRunningGain[0] + pRunningGainDelta[0], pRunningGain[5],                        pRunningGain[4]);
+                        __m128 runningGain2      = _mm_set_ps(pRunningGain[5] + pRunningGainDelta[5], pRunningGain[4] + pRunningGainDelta[4], pRunningGain[3] + pRunningGainDelta[3], pRunningGain[2] + pRunningGainDelta[2]);
+
+                        for (; iFrame < unrolledLoopCount; iFrame += 1) {
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*12 + 0], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*12 + 0]), runningGain0));
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*12 + 4], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*12 + 4]), runningGain1));
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*12 + 8], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*12 + 8]), runningGain2));
+
+                            runningGain0 = _mm_add_ps(runningGain0, runningGainDelta0);
+                            runningGain1 = _mm_add_ps(runningGain1, runningGainDelta1);
+                            runningGain2 = _mm_add_ps(runningGain2, runningGainDelta2);
+                        }
+
+                        iFrame = unrolledLoopCount << 1;
+                    } else
+                #endif
+                    {
+                        for (; iFrame < interpolatedFrameCount; iFrame += 1) {
+                            for (iChannel = 0; iChannel < 6; iChannel += 1) {
+                                pFramesOutF32[iFrame*6 + iChannel] = pFramesInF32[iFrame*6 + iChannel] * pRunningGain[iChannel];
+                            }
+
+                            /* Move the running gain forward towards the new gain. */
+                            for (iChannel = 0; iChannel < 6; iChannel += 1) {
+                                pRunningGain[iChannel] += pRunningGainDelta[iChannel];
+                            }
+                        }
+                    }
+                } else if (pGainer->config.channels == 8) {
+                    /* For 8 channels we can just go over frame by frame and do all eight channels as 2 separate 4x SIMD operations. */
+                #if defined(MA_SUPPORT_SSE2)
+                    if (ma_has_sse2()) {
+                        __m128 runningGainDelta0 = _mm_loadu_ps(&pRunningGainDelta[0]);
+                        __m128 runningGainDelta1 = _mm_loadu_ps(&pRunningGainDelta[4]);
+                        __m128 runningGain0      = _mm_loadu_ps(&pRunningGain[0]);
+                        __m128 runningGain1      = _mm_loadu_ps(&pRunningGain[4]);
+
+                        for (; iFrame < interpolatedFrameCount; iFrame += 1) {
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*8 + 0], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*8 + 0]), runningGain0));
+                            _mm_storeu_ps(&pFramesOutF32[iFrame*8 + 4], _mm_mul_ps(_mm_loadu_ps(&pFramesInF32[iFrame*8 + 4]), runningGain1));
+
+                            runningGain0 = _mm_add_ps(runningGain0, runningGainDelta0);
+                            runningGain1 = _mm_add_ps(runningGain1, runningGainDelta1);
+                        }
+                    } else
+                #endif
+                    {
+                        /* This is crafted so that it auto-vectorizes when compiled with Clang. */
+                        for (; iFrame < interpolatedFrameCount; iFrame += 1) {
+                            for (iChannel = 0; iChannel < 8; iChannel += 1) {
+                                pFramesOutF32[iFrame*8 + iChannel] = pFramesInF32[iFrame*8 + iChannel] * pRunningGain[iChannel];
+                            }
+
+                            /* Move the running gain forward towards the new gain. */
+                            for (iChannel = 0; iChannel < 8; iChannel += 1) {
+                                pRunningGain[iChannel] += pRunningGainDelta[iChannel];
+                            }
+                        }
+                    }
+                }
+
+                for (; iFrame < interpolatedFrameCount; iFrame += 1) {
+                    for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                        pFramesOutF32[iFrame*pGainer->config.channels + iChannel] = pFramesInF32[iFrame*pGainer->config.channels + iChannel] * pRunningGain[iChannel];
+                        pRunningGain[iChannel] += pRunningGainDelta[iChannel];
+                    }
+                }
+            } else {
+                /* Slower path for extreme channel counts where we can't fit enough on the stack. We could also move this to the heap as part of the ma_gainer object which might even be better since it'll only be updated when the gains actually change. */
+                for (iFrame = 0; iFrame < interpolatedFrameCount; iFrame += 1) {
+                    for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                        pFramesOutF32[iFrame*pGainer->config.channels + iChannel] = pFramesInF32[iFrame*pGainer->config.channels + iChannel] * ma_mix_f32_fast(pGainer->pOldGains[iChannel], pGainer->pNewGains[iChannel], a) * pGainer->masterVolume;
+                    }
+
+                    a += d;
+                }
+            }
+        }
+
+        /* Make sure the timer is updated. */
+        pGainer->t = (ma_uint32)ma_min(pGainer->t + interpolatedFrameCount, pGainer->config.smoothTimeInFrames);
+
+        /* Adjust our arguments so the next part can work normally. */
+        frameCount -= interpolatedFrameCount;
+        pFramesOut  = ma_offset_ptr(pFramesOut, interpolatedFrameCount * sizeof(float));
+        pFramesIn   = ma_offset_ptr(pFramesIn,  interpolatedFrameCount * sizeof(float));
+    }
+
+    /* All we need to do here is apply the new gains using an optimized path. */
+    if (pFramesOut != NULL && pFramesIn != NULL) {
+        if (pGainer->config.channels <= 32) {
+            float gains[32];
+            for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                gains[iChannel] = pGainer->pNewGains[iChannel] * pGainer->masterVolume;
+            }
+
+            ma_copy_and_apply_volume_factor_per_channel_f32((float*)pFramesOut, (const float*)pFramesIn, frameCount, pGainer->config.channels, gains);
+        } else {
+            /* Slow path. Too many channels to fit on the stack. Need to apply a master volume as a separate path. */
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                    ((float*)pFramesOut)[iFrame*pGainer->config.channels + iChannel] = ((const float*)pFramesIn)[iFrame*pGainer->config.channels + iChannel] * pGainer->pNewGains[iChannel] * pGainer->masterVolume;
+                }
+            }
+        }
+    }
+
+    /* Now that some frames have been processed we need to make sure future changes to the gain are interpolated. */
+    if (pGainer->t == (ma_uint32)-1) {
+        pGainer->t  = (ma_uint32)ma_min(pGainer->config.smoothTimeInFrames, frameCount);
+    }
+
+#if 0
+    if (pGainer->t >= pGainer->config.smoothTimeInFrames) {
+        /* Fast path. No gain calculation required. */
+        ma_copy_and_apply_volume_factor_per_channel_f32(pFramesOutF32, pFramesInF32, frameCount, pGainer->config.channels, pGainer->pNewGains);
+        ma_apply_volume_factor_f32(pFramesOutF32, frameCount * pGainer->config.channels, pGainer->masterVolume);
+
+        /* Now that some frames have been processed we need to make sure future changes to the gain are interpolated. */
+        if (pGainer->t == (ma_uint32)-1) {
+            pGainer->t = pGainer->config.smoothTimeInFrames;
+        }
+    } else {
+        /* Slow path. Need to interpolate the gain for each channel individually. */
+
+        /* We can allow the input and output buffers to be null in which case we'll just update the internal timer. */
+        if (pFramesOut != NULL && pFramesIn != NULL) {
+            float a = (float)pGainer->t / pGainer->config.smoothTimeInFrames;
+            float d = 1.0f / pGainer->config.smoothTimeInFrames;
+            ma_uint32 channelCount = pGainer->config.channels;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channelCount; iChannel += 1) {
+                    pFramesOutF32[iChannel] = pFramesInF32[iChannel] * ma_mix_f32_fast(pGainer->pOldGains[iChannel], pGainer->pNewGains[iChannel], a) * pGainer->masterVolume;
+                }
+
+                pFramesOutF32 += channelCount;
+                pFramesInF32  += channelCount;
+
+                a += d;
+                if (a > 1) {
+                    a = 1;
+                }
+            }
+        }
+
+        pGainer->t = (ma_uint32)ma_min(pGainer->t + frameCount, pGainer->config.smoothTimeInFrames);
+
+    #if 0   /* Reference implementation. */
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            /* We can allow the input and output buffers to be null in which case we'll just update the internal timer. */
+            if (pFramesOut != NULL && pFramesIn != NULL) {
+                for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+                    pFramesOutF32[iFrame * pGainer->config.channels + iChannel] = pFramesInF32[iFrame * pGainer->config.channels + iChannel] * ma_gainer_calculate_current_gain(pGainer, iChannel) * pGainer->masterVolume;
+                }
+            }
+
+            /* Move interpolation time forward, but don't go beyond our smoothing time. */
+            pGainer->t = ma_min(pGainer->t + 1, pGainer->config.smoothTimeInFrames);
+        }
+    #endif
+    }
+#endif
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_gainer_process_pcm_frames(ma_gainer* pGainer, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pGainer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    ma_gainer_process_pcm_frames_internal() marks pFramesOut and pFramesIn with MA_RESTRICT which
+    helps with auto-vectorization.
+    */
+    return ma_gainer_process_pcm_frames_internal(pGainer, pFramesOut, pFramesIn, frameCount);
+}
+
+static void ma_gainer_set_gain_by_index(ma_gainer* pGainer, float newGain, ma_uint32 iChannel)
+{
+    pGainer->pOldGains[iChannel] = ma_gainer_calculate_current_gain(pGainer, iChannel);
+    pGainer->pNewGains[iChannel] = newGain;
+}
+
+static void ma_gainer_reset_smoothing_time(ma_gainer* pGainer)
+{
+    if (pGainer->t == (ma_uint32)-1) {
+        pGainer->t = pGainer->config.smoothTimeInFrames;    /* No smoothing required for initial gains setting. */
+    } else {
+        pGainer->t = 0;
+    }
+}
+
+MA_API ma_result ma_gainer_set_gain(ma_gainer* pGainer, float newGain)
+{
+    ma_uint32 iChannel;
+
+    if (pGainer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+        ma_gainer_set_gain_by_index(pGainer, newGain, iChannel);
+    }
+
+    /* The smoothing time needs to be reset to ensure we always interpolate by the configured smoothing time, but only if it's not the first setting. */
+    ma_gainer_reset_smoothing_time(pGainer);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_gainer_set_gains(ma_gainer* pGainer, float* pNewGains)
+{
+    ma_uint32 iChannel;
+
+    if (pGainer == NULL || pNewGains == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iChannel = 0; iChannel < pGainer->config.channels; iChannel += 1) {
+        ma_gainer_set_gain_by_index(pGainer, pNewGains[iChannel], iChannel);
+    }
+
+    /* The smoothing time needs to be reset to ensure we always interpolate by the configured smoothing time, but only if it's not the first setting. */
+    ma_gainer_reset_smoothing_time(pGainer);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_gainer_set_master_volume(ma_gainer* pGainer, float volume)
+{
+    if (pGainer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pGainer->masterVolume = volume;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_gainer_get_master_volume(const ma_gainer* pGainer, float* pVolume)
+{
+    if (pGainer == NULL || pVolume == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pVolume = pGainer->masterVolume;
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_panner_config ma_panner_config_init(ma_format format, ma_uint32 channels)
+{
+    ma_panner_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format   = format;
+    config.channels = channels;
+    config.mode     = ma_pan_mode_balance;  /* Set to balancing mode by default because it's consistent with other audio engines and most likely what the caller is expecting. */
+    config.pan      = 0;
+
+    return config;
+}
+
+
+MA_API ma_result ma_panner_init(const ma_panner_config* pConfig, ma_panner* pPanner)
+{
+    if (pPanner == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pPanner);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pPanner->format   = pConfig->format;
+    pPanner->channels = pConfig->channels;
+    pPanner->mode     = pConfig->mode;
+    pPanner->pan      = pConfig->pan;
+
+    return MA_SUCCESS;
+}
+
+static void ma_stereo_balance_pcm_frames_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, float pan)
+{
+    ma_uint64 iFrame;
+
+    if (pan > 0) {
+        float factor = 1.0f - pan;
+        if (pFramesOut == pFramesIn) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                pFramesOut[iFrame*2 + 0] = pFramesIn[iFrame*2 + 0] * factor;
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                pFramesOut[iFrame*2 + 0] = pFramesIn[iFrame*2 + 0] * factor;
+                pFramesOut[iFrame*2 + 1] = pFramesIn[iFrame*2 + 1];
+            }
+        }
+    } else {
+        float factor = 1.0f + pan;
+        if (pFramesOut == pFramesIn) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                pFramesOut[iFrame*2 + 1] = pFramesIn[iFrame*2 + 1] * factor;
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                pFramesOut[iFrame*2 + 0] = pFramesIn[iFrame*2 + 0];
+                pFramesOut[iFrame*2 + 1] = pFramesIn[iFrame*2 + 1] * factor;
+            }
+        }
+    }
+}
+
+static void ma_stereo_balance_pcm_frames(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_format format, float pan)
+{
+    if (pan == 0) {
+        /* Fast path. No panning required. */
+        if (pFramesOut == pFramesIn) {
+            /* No-op */
+        } else {
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, format, 2);
+        }
+
+        return;
+    }
+
+    switch (format) {
+        case ma_format_f32: ma_stereo_balance_pcm_frames_f32((float*)pFramesOut, (float*)pFramesIn, frameCount, pan); break;
+
+        /* Unknown format. Just copy. */
+        default:
+        {
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, format, 2);
+        } break;
+    }
+}
+
+
+static void ma_stereo_pan_pcm_frames_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, float pan)
+{
+    ma_uint64 iFrame;
+
+    if (pan > 0) {
+        float factorL0 = 1.0f - pan;
+        float factorL1 = 0.0f + pan;
+
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float sample0 = (pFramesIn[iFrame*2 + 0] * factorL0);
+            float sample1 = (pFramesIn[iFrame*2 + 0] * factorL1) + pFramesIn[iFrame*2 + 1];
+
+            pFramesOut[iFrame*2 + 0] = sample0;
+            pFramesOut[iFrame*2 + 1] = sample1;
+        }
+    } else {
+        float factorR0 = 0.0f - pan;
+        float factorR1 = 1.0f + pan;
+
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float sample0 = pFramesIn[iFrame*2 + 0] + (pFramesIn[iFrame*2 + 1] * factorR0);
+            float sample1 =                           (pFramesIn[iFrame*2 + 1] * factorR1);
+
+            pFramesOut[iFrame*2 + 0] = sample0;
+            pFramesOut[iFrame*2 + 1] = sample1;
+        }
+    }
+}
+
+static void ma_stereo_pan_pcm_frames(void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount, ma_format format, float pan)
+{
+    if (pan == 0) {
+        /* Fast path. No panning required. */
+        if (pFramesOut == pFramesIn) {
+            /* No-op */
+        } else {
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, format, 2);
+        }
+
+        return;
+    }
+
+    switch (format) {
+        case ma_format_f32: ma_stereo_pan_pcm_frames_f32((float*)pFramesOut, (float*)pFramesIn, frameCount, pan); break;
+
+        /* Unknown format. Just copy. */
+        default:
+        {
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, format, 2);
+        } break;
+    }
+}
+
+MA_API ma_result ma_panner_process_pcm_frames(ma_panner* pPanner, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pPanner == NULL || pFramesOut == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pPanner->channels == 2) {
+        /* Stereo case. For now assume channel 0 is left and channel right is 1, but should probably add support for a channel map. */
+        if (pPanner->mode == ma_pan_mode_balance) {
+            ma_stereo_balance_pcm_frames(pFramesOut, pFramesIn, frameCount, pPanner->format, pPanner->pan);
+        } else {
+            ma_stereo_pan_pcm_frames(pFramesOut, pFramesIn, frameCount, pPanner->format, pPanner->pan);
+        }
+    } else {
+        if (pPanner->channels == 1) {
+            /* Panning has no effect on mono streams. */
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, pPanner->format, pPanner->channels);
+        } else {
+            /* For now we're not going to support non-stereo set ups. Not sure how I want to handle this case just yet. */
+            ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, pPanner->format, pPanner->channels);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_panner_set_mode(ma_panner* pPanner, ma_pan_mode mode)
+{
+    if (pPanner == NULL) {
+        return;
+    }
+
+    pPanner->mode = mode;
+}
+
+MA_API ma_pan_mode ma_panner_get_mode(const ma_panner* pPanner)
+{
+    if (pPanner == NULL) {
+        return ma_pan_mode_balance;
+    }
+
+    return pPanner->mode;
+}
+
+MA_API void ma_panner_set_pan(ma_panner* pPanner, float pan)
+{
+    if (pPanner == NULL) {
+        return;
+    }
+
+    pPanner->pan = ma_clamp(pan, -1.0f, 1.0f);
+}
+
+MA_API float ma_panner_get_pan(const ma_panner* pPanner)
+{
+    if (pPanner == NULL) {
+        return 0;
+    }
+
+    return pPanner->pan;
+}
+
+
+
+
+MA_API ma_fader_config ma_fader_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    ma_fader_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+
+    return config;
+}
+
+
+MA_API ma_result ma_fader_init(const ma_fader_config* pConfig, ma_fader* pFader)
+{
+    if (pFader == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFader);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Only f32 is supported for now. */
+    if (pConfig->format != ma_format_f32) {
+        return MA_INVALID_ARGS;
+    }
+
+    pFader->config         = *pConfig;
+    pFader->volumeBeg      = 1;
+    pFader->volumeEnd      = 1;
+    pFader->lengthInFrames = 0;
+    pFader->cursorInFrames = 0;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_fader_process_pcm_frames(ma_fader* pFader, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pFader == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If the cursor is still negative we need to just copy the absolute number of those frames, but no more than frameCount. */
+    if (pFader->cursorInFrames < 0) {
+        ma_uint64 absCursorInFrames = (ma_uint64)0 - pFader->cursorInFrames;
+        if (absCursorInFrames > frameCount) {
+            absCursorInFrames = frameCount;
+        }
+
+        ma_copy_pcm_frames(pFramesOut, pFramesIn, absCursorInFrames, pFader->config.format, pFader->config.channels);
+
+        pFader->cursorInFrames += absCursorInFrames;
+        frameCount -= absCursorInFrames;
+        pFramesOut  = ma_offset_ptr(pFramesOut, ma_get_bytes_per_frame(pFader->config.format, pFader->config.channels)*absCursorInFrames);
+        pFramesIn   = ma_offset_ptr(pFramesIn,  ma_get_bytes_per_frame(pFader->config.format, pFader->config.channels)*absCursorInFrames);
+    }
+
+    if (pFader->cursorInFrames >= 0) {
+        /*
+        For now we need to clamp frameCount so that the cursor never overflows 32-bits. This is required for
+        the conversion to a float which we use for the linear interpolation. This might be changed later.
+        */
+        if (frameCount + pFader->cursorInFrames > UINT_MAX) {
+            frameCount = UINT_MAX - pFader->cursorInFrames;
+        }
+
+        /* Optimized path if volumeBeg and volumeEnd are equal. */
+        if (pFader->volumeBeg == pFader->volumeEnd) {
+            if (pFader->volumeBeg == 1) {
+                /* Straight copy. */
+                ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, pFader->config.format, pFader->config.channels);
+            } else {
+                /* Copy with volume. */
+                ma_copy_and_apply_volume_and_clip_pcm_frames(pFramesOut, pFramesIn, frameCount, pFader->config.format, pFader->config.channels, pFader->volumeBeg);
+            }
+        } else {
+            /* Slower path. Volumes are different, so may need to do an interpolation. */
+            if ((ma_uint64)pFader->cursorInFrames >= pFader->lengthInFrames) {
+                /* Fast path. We've gone past the end of the fade period so just apply the end volume to all samples. */
+                ma_copy_and_apply_volume_and_clip_pcm_frames(pFramesOut, pFramesIn, frameCount, pFader->config.format, pFader->config.channels, pFader->volumeEnd);
+            } else {
+                /* Slow path. This is where we do the actual fading. */
+                ma_uint64 iFrame;
+                ma_uint32 iChannel;
+
+                /* For now we only support f32. Support for other formats might be added later. */
+                if (pFader->config.format == ma_format_f32) {
+                    const float* pFramesInF32  = (const float*)pFramesIn;
+                    /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+
+                    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                        float a = (ma_uint32)ma_min(pFader->cursorInFrames + iFrame, pFader->lengthInFrames) / (float)((ma_uint32)pFader->lengthInFrames);   /* Safe cast due to the frameCount clamp at the top of this function. */
+                        float volume = ma_mix_f32_fast(pFader->volumeBeg, pFader->volumeEnd, a);
+
+                        for (iChannel = 0; iChannel < pFader->config.channels; iChannel += 1) {
+                            pFramesOutF32[iFrame*pFader->config.channels + iChannel] = pFramesInF32[iFrame*pFader->config.channels + iChannel] * volume;
+                        }
+                    }
+                } else {
+                    return MA_NOT_IMPLEMENTED;
+                }
+            }
+        }
+    }
+
+    pFader->cursorInFrames += frameCount;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_fader_get_data_format(const ma_fader* pFader, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate)
+{
+    if (pFader == NULL) {
+        return;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pFader->config.format;
+    }
+
+    if (pChannels != NULL) {
+        *pChannels = pFader->config.channels;
+    }
+
+    if (pSampleRate != NULL) {
+        *pSampleRate = pFader->config.sampleRate;
+    }
+}
+
+MA_API void ma_fader_set_fade(ma_fader* pFader, float volumeBeg, float volumeEnd, ma_uint64 lengthInFrames)
+{
+    ma_fader_set_fade_ex(pFader, volumeBeg, volumeEnd, lengthInFrames, 0);
+}
+
+MA_API void ma_fader_set_fade_ex(ma_fader* pFader, float volumeBeg, float volumeEnd, ma_uint64 lengthInFrames, ma_int64 startOffsetInFrames)
+{
+    if (pFader == NULL) {
+        return;
+    }
+
+    /* If the volume is negative, use current volume. */
+    if (volumeBeg < 0) {
+        volumeBeg = ma_fader_get_current_volume(pFader);
+    }
+
+    /*
+    The length needs to be clamped to 32-bits due to how we convert it to a float for linear
+    interpolation reasons. I might change this requirement later, but for now it's not important.
+    */
+    if (lengthInFrames > UINT_MAX) {
+        lengthInFrames = UINT_MAX;
+    }
+
+    /* The start offset needs to be clamped to ensure it doesn't overflow a signed number. */
+    if (startOffsetInFrames > INT_MAX) {
+        startOffsetInFrames = INT_MAX;
+    }
+
+    pFader->volumeBeg      = volumeBeg;
+    pFader->volumeEnd      = volumeEnd;
+    pFader->lengthInFrames = lengthInFrames;
+    pFader->cursorInFrames = -startOffsetInFrames;
+}
+
+MA_API float ma_fader_get_current_volume(const ma_fader* pFader)
+{
+    if (pFader == NULL) {
+        return 0.0f;
+    }
+
+    /* Any frames prior to the start of the fade period will be at unfaded volume. */
+    if (pFader->cursorInFrames < 0) {
+        return 1.0f;
+    }
+
+    /* The current volume depends on the position of the cursor. */
+    if (pFader->cursorInFrames == 0) {
+        return pFader->volumeBeg;
+    } else if ((ma_uint64)pFader->cursorInFrames >= pFader->lengthInFrames) {   /* Safe case because the < 0 case was checked above. */
+        return pFader->volumeEnd;
+    } else {
+        /* The cursor is somewhere inside the fading period. We can figure this out with a simple linear interpoluation between volumeBeg and volumeEnd based on our cursor position. */
+        return ma_mix_f32_fast(pFader->volumeBeg, pFader->volumeEnd, (ma_uint32)pFader->cursorInFrames / (float)((ma_uint32)pFader->lengthInFrames));    /* Safe cast to uint32 because we clamp it in ma_fader_process_pcm_frames(). */
+    }
+}
+
+
+
+
+
+MA_API ma_vec3f ma_vec3f_init_3f(float x, float y, float z)
+{
+    ma_vec3f v;
+
+    v.x = x;
+    v.y = y;
+    v.z = z;
+
+    return v;
+}
+
+MA_API ma_vec3f ma_vec3f_sub(ma_vec3f a, ma_vec3f b)
+{
+    return ma_vec3f_init_3f(
+        a.x - b.x,
+        a.y - b.y,
+        a.z - b.z
+    );
+}
+
+MA_API ma_vec3f ma_vec3f_neg(ma_vec3f a)
+{
+    return ma_vec3f_init_3f(
+        -a.x,
+        -a.y,
+        -a.z
+    );
+}
+
+MA_API float ma_vec3f_dot(ma_vec3f a, ma_vec3f b)
+{
+    return a.x*b.x + a.y*b.y + a.z*b.z;
+}
+
+MA_API float ma_vec3f_len2(ma_vec3f v)
+{
+    return ma_vec3f_dot(v, v);
+}
+
+MA_API float ma_vec3f_len(ma_vec3f v)
+{
+    return (float)ma_sqrtd(ma_vec3f_len2(v));
+}
+
+
+
+MA_API float ma_vec3f_dist(ma_vec3f a, ma_vec3f b)
+{
+    return ma_vec3f_len(ma_vec3f_sub(a, b));
+}
+
+MA_API ma_vec3f ma_vec3f_normalize(ma_vec3f v)
+{
+    float invLen;
+    float len2 = ma_vec3f_len2(v);
+    if (len2 == 0) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    invLen = ma_rsqrtf(len2);
+    v.x *= invLen;
+    v.y *= invLen;
+    v.z *= invLen;
+
+    return v;
+}
+
+MA_API ma_vec3f ma_vec3f_cross(ma_vec3f a, ma_vec3f b)
+{
+    return ma_vec3f_init_3f(
+        a.y*b.z - a.z*b.y,
+        a.z*b.x - a.x*b.z,
+        a.x*b.y - a.y*b.x
+    );
+}
+
+
+MA_API void ma_atomic_vec3f_init(ma_atomic_vec3f* v, ma_vec3f value)
+{
+    v->v = value;
+    v->lock = 0;    /* Important this is initialized to 0. */
+}
+
+MA_API void ma_atomic_vec3f_set(ma_atomic_vec3f* v, ma_vec3f value)
+{
+    ma_spinlock_lock(&v->lock);
+    {
+        v->v = value;
+    }
+    ma_spinlock_unlock(&v->lock);
+}
+
+MA_API ma_vec3f ma_atomic_vec3f_get(ma_atomic_vec3f* v)
+{
+    ma_vec3f r;
+
+    ma_spinlock_lock(&v->lock);
+    {
+        r = v->v;
+    }
+    ma_spinlock_unlock(&v->lock);
+
+    return r;
+}
+
+
+
+static void ma_channel_map_apply_f32(float* pFramesOut, const ma_channel* pChannelMapOut, ma_uint32 channelsOut, const float* pFramesIn, const ma_channel* pChannelMapIn, ma_uint32 channelsIn, ma_uint64 frameCount, ma_channel_mix_mode mode, ma_mono_expansion_mode monoExpansionMode);
+static ma_bool32 ma_is_spatial_channel_position(ma_channel channelPosition);
+
+
+#ifndef MA_DEFAULT_SPEED_OF_SOUND
+#define MA_DEFAULT_SPEED_OF_SOUND   343.3f
+#endif
+
+/*
+These vectors represent the direction that speakers are facing from the center point. They're used
+for panning in the spatializer. Must be normalized.
+*/
+static ma_vec3f g_maChannelDirections[MA_CHANNEL_POSITION_COUNT] = {
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_NONE */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_MONO */
+    {-0.7071f,  0.0f,    -0.7071f },  /* MA_CHANNEL_FRONT_LEFT */
+    {+0.7071f,  0.0f,    -0.7071f },  /* MA_CHANNEL_FRONT_RIGHT */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_FRONT_CENTER */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_LFE */
+    {-0.7071f,  0.0f,    +0.7071f },  /* MA_CHANNEL_BACK_LEFT */
+    {+0.7071f,  0.0f,    +0.7071f },  /* MA_CHANNEL_BACK_RIGHT */
+    {-0.3162f,  0.0f,    -0.9487f },  /* MA_CHANNEL_FRONT_LEFT_CENTER */
+    {+0.3162f,  0.0f,    -0.9487f },  /* MA_CHANNEL_FRONT_RIGHT_CENTER */
+    { 0.0f,     0.0f,    +1.0f    },  /* MA_CHANNEL_BACK_CENTER */
+    {-1.0f,     0.0f,     0.0f    },  /* MA_CHANNEL_SIDE_LEFT */
+    {+1.0f,     0.0f,     0.0f    },  /* MA_CHANNEL_SIDE_RIGHT */
+    { 0.0f,    +1.0f,     0.0f    },  /* MA_CHANNEL_TOP_CENTER */
+    {-0.5774f, +0.5774f, -0.5774f },  /* MA_CHANNEL_TOP_FRONT_LEFT */
+    { 0.0f,    +0.7071f, -0.7071f },  /* MA_CHANNEL_TOP_FRONT_CENTER */
+    {+0.5774f, +0.5774f, -0.5774f },  /* MA_CHANNEL_TOP_FRONT_RIGHT */
+    {-0.5774f, +0.5774f, +0.5774f },  /* MA_CHANNEL_TOP_BACK_LEFT */
+    { 0.0f,    +0.7071f, +0.7071f },  /* MA_CHANNEL_TOP_BACK_CENTER */
+    {+0.5774f, +0.5774f, +0.5774f },  /* MA_CHANNEL_TOP_BACK_RIGHT */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_0 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_1 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_2 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_3 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_4 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_5 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_6 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_7 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_8 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_9 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_10 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_11 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_12 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_13 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_14 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_15 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_16 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_17 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_18 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_19 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_20 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_21 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_22 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_23 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_24 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_25 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_26 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_27 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_28 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_29 */
+    { 0.0f,     0.0f,    -1.0f    },  /* MA_CHANNEL_AUX_30 */
+    { 0.0f,     0.0f,    -1.0f    }   /* MA_CHANNEL_AUX_31 */
+};
+
+static ma_vec3f ma_get_channel_direction(ma_channel channel)
+{
+    if (channel >= MA_CHANNEL_POSITION_COUNT) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    } else {
+        return g_maChannelDirections[channel];
+    }
+}
+
+
+
+static float ma_attenuation_inverse(float distance, float minDistance, float maxDistance, float rolloff)
+{
+    if (minDistance >= maxDistance) {
+        return 1;   /* To avoid division by zero. Do not attenuate. */
+    }
+
+    return minDistance / (minDistance + rolloff * (ma_clamp(distance, minDistance, maxDistance) - minDistance));
+}
+
+static float ma_attenuation_linear(float distance, float minDistance, float maxDistance, float rolloff)
+{
+    if (minDistance >= maxDistance) {
+        return 1;   /* To avoid division by zero. Do not attenuate. */
+    }
+
+    return 1 - rolloff * (ma_clamp(distance, minDistance, maxDistance) - minDistance) / (maxDistance - minDistance);
+}
+
+static float ma_attenuation_exponential(float distance, float minDistance, float maxDistance, float rolloff)
+{
+    if (minDistance >= maxDistance) {
+        return 1;   /* To avoid division by zero. Do not attenuate. */
+    }
+
+    return (float)ma_powd(ma_clamp(distance, minDistance, maxDistance) / minDistance, -rolloff);
+}
+
+
+/*
+Dopper Effect calculation taken from the OpenAL spec, with two main differences:
+
+  1) The source to listener vector will have already been calcualted at an earlier step so we can
+     just use that directly. We need only the position of the source relative to the origin.
+
+  2) We don't scale by a frequency because we actually just want the ratio which we'll plug straight
+     into the resampler directly.
+*/
+static float ma_doppler_pitch(ma_vec3f relativePosition, ma_vec3f sourceVelocity, ma_vec3f listenVelocity, float speedOfSound, float dopplerFactor)
+{
+    float len;
+    float vls;
+    float vss;
+
+    len = ma_vec3f_len(relativePosition);
+
+    /*
+    There's a case where the position of the source will be right on top of the listener in which
+    case the length will be 0 and we'll end up with a division by zero. We can just return a ratio
+    of 1.0 in this case. This is not considered in the OpenAL spec, but is necessary.
+    */
+    if (len == 0) {
+        return 1.0;
+    }
+
+    vls = ma_vec3f_dot(relativePosition, listenVelocity) / len;
+    vss = ma_vec3f_dot(relativePosition, sourceVelocity) / len;
+
+    vls = ma_min(vls, speedOfSound / dopplerFactor);
+    vss = ma_min(vss, speedOfSound / dopplerFactor);
+
+    return (speedOfSound - dopplerFactor*vls) / (speedOfSound - dopplerFactor*vss);
+}
+
+
+static void ma_get_default_channel_map_for_spatializer(ma_channel* pChannelMap, size_t channelMapCap, ma_uint32 channelCount)
+{
+    /*
+    Special case for stereo. Want to default the left and right speakers to side left and side
+    right so that they're facing directly down the X axis rather than slightly forward. Not
+    doing this will result in sounds being quieter when behind the listener. This might
+    actually be good for some scenerios, but I don't think it's an appropriate default because
+    it can be a bit unexpected.
+    */
+    if (channelCount == 2) {
+        pChannelMap[0] = MA_CHANNEL_SIDE_LEFT;
+        pChannelMap[1] = MA_CHANNEL_SIDE_RIGHT;
+    } else {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, channelCount);
+    }
+}
+
+
+MA_API ma_spatializer_listener_config ma_spatializer_listener_config_init(ma_uint32 channelsOut)
+{
+    ma_spatializer_listener_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.channelsOut             = channelsOut;
+    config.pChannelMapOut          = NULL;
+    config.handedness              = ma_handedness_right;
+    config.worldUp                 = ma_vec3f_init_3f(0, 1,  0);
+    config.coneInnerAngleInRadians = 6.283185f; /* 360 degrees. */
+    config.coneOuterAngleInRadians = 6.283185f; /* 360 degrees. */
+    config.coneOuterGain           = 0;
+    config.speedOfSound            = 343.3f;    /* Same as OpenAL. Used for doppler effect. */
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t channelMapOutOffset;
+} ma_spatializer_listener_heap_layout;
+
+static ma_result ma_spatializer_listener_get_heap_layout(const ma_spatializer_listener_config* pConfig, ma_spatializer_listener_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channelsOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Channel map. We always need this, even for passthroughs. */
+    pHeapLayout->channelMapOutOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(sizeof(*pConfig->pChannelMapOut) * pConfig->channelsOut);
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_spatializer_listener_get_heap_size(const ma_spatializer_listener_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_spatializer_listener_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_spatializer_listener_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spatializer_listener_init_preallocated(const ma_spatializer_listener_config* pConfig, void* pHeap, ma_spatializer_listener* pListener)
+{
+    ma_result result;
+    ma_spatializer_listener_heap_layout heapLayout;
+
+    if (pListener == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pListener);
+
+    result = ma_spatializer_listener_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pListener->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pListener->config    = *pConfig;
+    ma_atomic_vec3f_init(&pListener->position,  ma_vec3f_init_3f(0, 0, 0));
+    ma_atomic_vec3f_init(&pListener->direction, ma_vec3f_init_3f(0, 0, -1));
+    ma_atomic_vec3f_init(&pListener->velocity,  ma_vec3f_init_3f(0, 0,  0));
+    pListener->isEnabled = MA_TRUE;
+
+    /* Swap the forward direction if we're left handed (it was initialized based on right handed). */
+    if (pListener->config.handedness == ma_handedness_left) {
+        ma_vec3f negDir = ma_vec3f_neg(ma_spatializer_listener_get_direction(pListener));
+        ma_spatializer_listener_set_direction(pListener, negDir.x, negDir.y, negDir.z);
+    }
+
+
+    /* We must always have a valid channel map. */
+    pListener->config.pChannelMapOut = (ma_channel*)ma_offset_ptr(pHeap, heapLayout.channelMapOutOffset);
+
+    /* Use a slightly different default channel map for stereo. */
+    if (pConfig->pChannelMapOut == NULL) {
+        ma_get_default_channel_map_for_spatializer(pListener->config.pChannelMapOut, pConfig->channelsOut, pConfig->channelsOut);
+    } else {
+        ma_channel_map_copy_or_default(pListener->config.pChannelMapOut, pConfig->channelsOut, pConfig->pChannelMapOut, pConfig->channelsOut);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spatializer_listener_init(const ma_spatializer_listener_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_spatializer_listener* pListener)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_spatializer_listener_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_spatializer_listener_init_preallocated(pConfig, pHeap, pListener);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pListener->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_spatializer_listener_uninit(ma_spatializer_listener* pListener, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    if (pListener->_ownsHeap) {
+        ma_free(pListener->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_channel* ma_spatializer_listener_get_channel_map(ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return NULL;
+    }
+
+    return pListener->config.pChannelMapOut;
+}
+
+MA_API void ma_spatializer_listener_set_cone(ma_spatializer_listener* pListener, float innerAngleInRadians, float outerAngleInRadians, float outerGain)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    pListener->config.coneInnerAngleInRadians = innerAngleInRadians;
+    pListener->config.coneOuterAngleInRadians = outerAngleInRadians;
+    pListener->config.coneOuterGain           = outerGain;
+}
+
+MA_API void ma_spatializer_listener_get_cone(const ma_spatializer_listener* pListener, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    if (pInnerAngleInRadians != NULL) {
+        *pInnerAngleInRadians = pListener->config.coneInnerAngleInRadians;
+    }
+
+    if (pOuterAngleInRadians != NULL) {
+        *pOuterAngleInRadians = pListener->config.coneOuterAngleInRadians;
+    }
+
+    if (pOuterGain != NULL) {
+        *pOuterGain = pListener->config.coneOuterGain;
+    }
+}
+
+MA_API void ma_spatializer_listener_set_position(ma_spatializer_listener* pListener, float x, float y, float z)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pListener->position, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_listener_get_position(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pListener->position); /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_listener_set_direction(ma_spatializer_listener* pListener, float x, float y, float z)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pListener->direction, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_listener_get_direction(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pListener->direction);    /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_listener_set_velocity(ma_spatializer_listener* pListener, float x, float y, float z)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pListener->velocity, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_listener_get_velocity(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pListener->velocity); /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_listener_set_speed_of_sound(ma_spatializer_listener* pListener, float speedOfSound)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    pListener->config.speedOfSound = speedOfSound;
+}
+
+MA_API float ma_spatializer_listener_get_speed_of_sound(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return 0;
+    }
+
+    return pListener->config.speedOfSound;
+}
+
+MA_API void ma_spatializer_listener_set_world_up(ma_spatializer_listener* pListener, float x, float y, float z)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    pListener->config.worldUp = ma_vec3f_init_3f(x, y, z);
+}
+
+MA_API ma_vec3f ma_spatializer_listener_get_world_up(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return ma_vec3f_init_3f(0, 1, 0);
+    }
+
+    return pListener->config.worldUp;
+}
+
+MA_API void ma_spatializer_listener_set_enabled(ma_spatializer_listener* pListener, ma_bool32 isEnabled)
+{
+    if (pListener == NULL) {
+        return;
+    }
+
+    pListener->isEnabled = isEnabled;
+}
+
+MA_API ma_bool32 ma_spatializer_listener_is_enabled(const ma_spatializer_listener* pListener)
+{
+    if (pListener == NULL) {
+        return MA_FALSE;
+    }
+
+    return pListener->isEnabled;
+}
+
+
+
+
+MA_API ma_spatializer_config ma_spatializer_config_init(ma_uint32 channelsIn, ma_uint32 channelsOut)
+{
+    ma_spatializer_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.channelsIn                   = channelsIn;
+    config.channelsOut                  = channelsOut;
+    config.pChannelMapIn                = NULL;
+    config.attenuationModel             = ma_attenuation_model_inverse;
+    config.positioning                  = ma_positioning_absolute;
+    config.handedness                   = ma_handedness_right;
+    config.minGain                      = 0;
+    config.maxGain                      = 1;
+    config.minDistance                  = 1;
+    config.maxDistance                  = MA_FLT_MAX;
+    config.rolloff                      = 1;
+    config.coneInnerAngleInRadians      = 6.283185f; /* 360 degrees. */
+    config.coneOuterAngleInRadians      = 6.283185f; /* 360 degress. */
+    config.coneOuterGain                = 0.0f;
+    config.dopplerFactor                = 1;
+    config.directionalAttenuationFactor = 1;
+    config.minSpatializationChannelGain = 0.2f;
+    config.gainSmoothTimeInFrames       = 360;       /* 7.5ms @ 48K. */
+
+    return config;
+}
+
+
+static ma_gainer_config ma_spatializer_gainer_config_init(const ma_spatializer_config* pConfig)
+{
+    MA_ASSERT(pConfig != NULL);
+    return ma_gainer_config_init(pConfig->channelsOut, pConfig->gainSmoothTimeInFrames);
+}
+
+static ma_result ma_spatializer_validate_config(const ma_spatializer_config* pConfig)
+{
+    MA_ASSERT(pConfig != NULL);
+
+    if (pConfig->channelsIn == 0 || pConfig->channelsOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    return MA_SUCCESS;
+}
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t channelMapInOffset;
+    size_t newChannelGainsOffset;
+    size_t gainerOffset;
+} ma_spatializer_heap_layout;
+
+static ma_result ma_spatializer_get_heap_layout(const ma_spatializer_config* pConfig, ma_spatializer_heap_layout* pHeapLayout)
+{
+    ma_result result;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_spatializer_validate_config(pConfig);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Channel map. */
+    pHeapLayout->channelMapInOffset = MA_SIZE_MAX;  /* <-- MA_SIZE_MAX indicates no allocation necessary. */
+    if (pConfig->pChannelMapIn != NULL) {
+        pHeapLayout->channelMapInOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(sizeof(*pConfig->pChannelMapIn) * pConfig->channelsIn);
+    }
+
+    /* New channel gains for output. */
+    pHeapLayout->newChannelGainsOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(sizeof(float) * pConfig->channelsOut);
+
+    /* Gainer. */
+    {
+        size_t gainerHeapSizeInBytes;
+        ma_gainer_config gainerConfig;
+
+        gainerConfig = ma_spatializer_gainer_config_init(pConfig);
+
+        result = ma_gainer_get_heap_size(&gainerConfig, &gainerHeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->gainerOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(gainerHeapSizeInBytes);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spatializer_get_heap_size(const ma_spatializer_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_spatializer_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;  /* Safety. */
+
+    result = ma_spatializer_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_spatializer_init_preallocated(const ma_spatializer_config* pConfig, void* pHeap, ma_spatializer* pSpatializer)
+{
+    ma_result result;
+    ma_spatializer_heap_layout heapLayout;
+    ma_gainer_config gainerConfig;
+
+    if (pSpatializer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pSpatializer);
+
+    if (pConfig == NULL || pHeap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_spatializer_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pSpatializer->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pSpatializer->channelsIn                   = pConfig->channelsIn;
+    pSpatializer->channelsOut                  = pConfig->channelsOut;
+    pSpatializer->attenuationModel             = pConfig->attenuationModel;
+    pSpatializer->positioning                  = pConfig->positioning;
+    pSpatializer->handedness                   = pConfig->handedness;
+    pSpatializer->minGain                      = pConfig->minGain;
+    pSpatializer->maxGain                      = pConfig->maxGain;
+    pSpatializer->minDistance                  = pConfig->minDistance;
+    pSpatializer->maxDistance                  = pConfig->maxDistance;
+    pSpatializer->rolloff                      = pConfig->rolloff;
+    pSpatializer->coneInnerAngleInRadians      = pConfig->coneInnerAngleInRadians;
+    pSpatializer->coneOuterAngleInRadians      = pConfig->coneOuterAngleInRadians;
+    pSpatializer->coneOuterGain                = pConfig->coneOuterGain;
+    pSpatializer->dopplerFactor                = pConfig->dopplerFactor;
+    pSpatializer->minSpatializationChannelGain = pConfig->minSpatializationChannelGain;
+    pSpatializer->directionalAttenuationFactor = pConfig->directionalAttenuationFactor;
+    pSpatializer->gainSmoothTimeInFrames       = pConfig->gainSmoothTimeInFrames;
+    ma_atomic_vec3f_init(&pSpatializer->position,  ma_vec3f_init_3f(0, 0,  0));
+    ma_atomic_vec3f_init(&pSpatializer->direction, ma_vec3f_init_3f(0, 0, -1));
+    ma_atomic_vec3f_init(&pSpatializer->velocity,  ma_vec3f_init_3f(0, 0,  0));
+    pSpatializer->dopplerPitch                 = 1;
+
+    /* Swap the forward direction if we're left handed (it was initialized based on right handed). */
+    if (pSpatializer->handedness == ma_handedness_left) {
+        ma_vec3f negDir = ma_vec3f_neg(ma_spatializer_get_direction(pSpatializer));
+        ma_spatializer_set_direction(pSpatializer, negDir.x, negDir.y, negDir.z);
+    }
+
+    /* Channel map. This will be on the heap. */
+    if (pConfig->pChannelMapIn != NULL) {
+        pSpatializer->pChannelMapIn = (ma_channel*)ma_offset_ptr(pHeap, heapLayout.channelMapInOffset);
+        ma_channel_map_copy_or_default(pSpatializer->pChannelMapIn, pSpatializer->channelsIn, pConfig->pChannelMapIn, pSpatializer->channelsIn);
+    }
+
+    /* New channel gains for output channels. */
+    pSpatializer->pNewChannelGainsOut = (float*)ma_offset_ptr(pHeap, heapLayout.newChannelGainsOffset);
+
+    /* Gainer. */
+    gainerConfig = ma_spatializer_gainer_config_init(pConfig);
+
+    result = ma_gainer_init_preallocated(&gainerConfig, ma_offset_ptr(pHeap, heapLayout.gainerOffset), &pSpatializer->gainer);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the gainer. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spatializer_init(const ma_spatializer_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_spatializer* pSpatializer)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    /* We'll need a heap allocation to retrieve the size. */
+    result = ma_spatializer_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_spatializer_init_preallocated(pConfig, pHeap, pSpatializer);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pSpatializer->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_spatializer_uninit(ma_spatializer* pSpatializer, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_gainer_uninit(&pSpatializer->gainer, pAllocationCallbacks);
+
+    if (pSpatializer->_ownsHeap) {
+        ma_free(pSpatializer->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static float ma_calculate_angular_gain(ma_vec3f dirA, ma_vec3f dirB, float coneInnerAngleInRadians, float coneOuterAngleInRadians, float coneOuterGain)
+{
+    /*
+    Angular attenuation.
+
+    Unlike distance gain, the math for this is not specified by the OpenAL spec so we'll just go ahead and figure
+    this out for ourselves at the expense of possibly being inconsistent with other implementations.
+
+    To do cone attenuation, I'm just using the same math that we'd use to implement a basic spotlight in OpenGL. We
+    just need to get the direction from the source to the listener and then do a dot product against that and the
+    direction of the spotlight. Then we just compare that dot product against the cosine of the inner and outer
+    angles. If the dot product is greater than the the outer angle, we just use coneOuterGain. If it's less than
+    the inner angle, we just use a gain of 1. Otherwise we linearly interpolate between 1 and coneOuterGain.
+    */
+    if (coneInnerAngleInRadians < 6.283185f) {
+        float angularGain = 1;
+        float cutoffInner = (float)ma_cosd(coneInnerAngleInRadians*0.5f);
+        float cutoffOuter = (float)ma_cosd(coneOuterAngleInRadians*0.5f);
+        float d;
+
+        d = ma_vec3f_dot(dirA, dirB);
+
+        if (d > cutoffInner) {
+            /* It's inside the inner angle. */
+            angularGain = 1;
+        } else {
+            /* It's outside the inner angle. */
+            if (d > cutoffOuter) {
+                /* It's between the inner and outer angle. We need to linearly interpolate between 1 and coneOuterGain. */
+                angularGain = ma_mix_f32(coneOuterGain, 1, (d - cutoffOuter) / (cutoffInner - cutoffOuter));
+            } else {
+                /* It's outside the outer angle. */
+                angularGain = coneOuterGain;
+            }
+        }
+
+        /*printf("d = %f; cutoffInner = %f; cutoffOuter = %f; angularGain = %f\n", d, cutoffInner, cutoffOuter, angularGain);*/
+        return angularGain;
+    } else {
+        /* Inner angle is 360 degrees so no need to do any attenuation. */
+        return 1;
+    }
+}
+
+MA_API ma_result ma_spatializer_process_pcm_frames(ma_spatializer* pSpatializer, ma_spatializer_listener* pListener, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_channel* pChannelMapIn  = pSpatializer->pChannelMapIn;
+    ma_channel* pChannelMapOut = pListener->config.pChannelMapOut;
+
+    if (pSpatializer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If we're not spatializing we need to run an optimized path. */
+    if (ma_atomic_load_i32(&pSpatializer->attenuationModel) == ma_attenuation_model_none) {
+        if (ma_spatializer_listener_is_enabled(pListener)) {
+            /* No attenuation is required, but we'll need to do some channel conversion. */
+            if (pSpatializer->channelsIn == pSpatializer->channelsOut) {
+                ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, ma_format_f32, pSpatializer->channelsIn);
+            } else {
+                ma_channel_map_apply_f32((float*)pFramesOut, pChannelMapOut, pSpatializer->channelsOut, (const float*)pFramesIn, pChannelMapIn, pSpatializer->channelsIn, frameCount, ma_channel_mix_mode_rectangular, ma_mono_expansion_mode_default);   /* Safe casts to float* because f32 is the only supported format. */
+            }
+        } else {
+            /* The listener is disabled. Output silence. */
+            ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, pSpatializer->channelsOut);
+        }
+
+        /*
+        We're not doing attenuation so don't bother with doppler for now. I'm not sure if this is
+        the correct thinking so might need to review this later.
+        */
+        pSpatializer->dopplerPitch = 1;
+    } else {
+        /*
+        Let's first determine which listener the sound is closest to. Need to keep in mind that we
+        might not have a world or any listeners, in which case we just spatializer based on the
+        listener being positioned at the origin (0, 0, 0).
+        */
+        ma_vec3f relativePosNormalized;
+        ma_vec3f relativePos;   /* The position relative to the listener. */
+        ma_vec3f relativeDir;   /* The direction of the sound, relative to the listener. */
+        ma_vec3f listenerVel;   /* The volocity of the listener. For doppler pitch calculation. */
+        float speedOfSound;
+        float distance = 0;
+        float gain = 1;
+        ma_uint32 iChannel;
+        const ma_uint32 channelsOut = pSpatializer->channelsOut;
+        const ma_uint32 channelsIn  = pSpatializer->channelsIn;
+        float minDistance = ma_spatializer_get_min_distance(pSpatializer);
+        float maxDistance = ma_spatializer_get_max_distance(pSpatializer);
+        float rolloff = ma_spatializer_get_rolloff(pSpatializer);
+        float dopplerFactor = ma_spatializer_get_doppler_factor(pSpatializer);
+
+        /*
+        We'll need the listener velocity for doppler pitch calculations. The speed of sound is
+        defined by the listener, so we'll grab that here too.
+        */
+        if (pListener != NULL) {
+            listenerVel  = ma_spatializer_listener_get_velocity(pListener);
+            speedOfSound = pListener->config.speedOfSound;
+        } else {
+            listenerVel  = ma_vec3f_init_3f(0, 0, 0);
+            speedOfSound = MA_DEFAULT_SPEED_OF_SOUND;
+        }
+
+        if (pListener == NULL || ma_spatializer_get_positioning(pSpatializer) == ma_positioning_relative) {
+            /* There's no listener or we're using relative positioning. */
+            relativePos = ma_spatializer_get_position(pSpatializer);
+            relativeDir = ma_spatializer_get_direction(pSpatializer);
+        } else {
+            /*
+            We've found a listener and we're using absolute positioning. We need to transform the
+            sound's position and direction so that it's relative to listener. Later on we'll use
+            this for determining the factors to apply to each channel to apply the panning effect.
+            */
+            ma_spatializer_get_relative_position_and_direction(pSpatializer, pListener, &relativePos, &relativeDir);
+        }
+
+        distance = ma_vec3f_len(relativePos);
+
+        /* We've gathered the data, so now we can apply some spatialization. */
+        switch (ma_spatializer_get_attenuation_model(pSpatializer)) {
+            case ma_attenuation_model_inverse:
+            {
+                gain = ma_attenuation_inverse(distance, minDistance, maxDistance, rolloff);
+            } break;
+            case ma_attenuation_model_linear:
+            {
+                gain = ma_attenuation_linear(distance, minDistance, maxDistance, rolloff);
+            } break;
+            case ma_attenuation_model_exponential:
+            {
+                gain = ma_attenuation_exponential(distance, minDistance, maxDistance, rolloff);
+            } break;
+            case ma_attenuation_model_none:
+            default:
+            {
+                gain = 1;
+            } break;
+        }
+
+        /* Normalize the position. */
+        if (distance > 0.001f) {
+            float distanceInv = 1/distance;
+            relativePosNormalized    = relativePos;
+            relativePosNormalized.x *= distanceInv;
+            relativePosNormalized.y *= distanceInv;
+            relativePosNormalized.z *= distanceInv;
+        } else {
+            distance = 0;
+            relativePosNormalized = ma_vec3f_init_3f(0, 0, 0);
+        }
+
+        /*
+        Angular attenuation.
+
+        Unlike distance gain, the math for this is not specified by the OpenAL spec so we'll just go ahead and figure
+        this out for ourselves at the expense of possibly being inconsistent with other implementations.
+
+        To do cone attenuation, I'm just using the same math that we'd use to implement a basic spotlight in OpenGL. We
+        just need to get the direction from the source to the listener and then do a dot product against that and the
+        direction of the spotlight. Then we just compare that dot product against the cosine of the inner and outer
+        angles. If the dot product is greater than the the outer angle, we just use coneOuterGain. If it's less than
+        the inner angle, we just use a gain of 1. Otherwise we linearly interpolate between 1 and coneOuterGain.
+        */
+        if (distance > 0) {
+            /* Source anglular gain. */
+            float spatializerConeInnerAngle;
+            float spatializerConeOuterAngle;
+            float spatializerConeOuterGain;
+            ma_spatializer_get_cone(pSpatializer, &spatializerConeInnerAngle, &spatializerConeOuterAngle, &spatializerConeOuterGain);
+
+            gain *= ma_calculate_angular_gain(relativeDir, ma_vec3f_neg(relativePosNormalized), spatializerConeInnerAngle, spatializerConeOuterAngle, spatializerConeOuterGain);
+
+            /*
+            We're supporting angular gain on the listener as well for those who want to reduce the volume of sounds that
+            are positioned behind the listener. On default settings, this will have no effect.
+            */
+            if (pListener != NULL && pListener->config.coneInnerAngleInRadians < 6.283185f) {
+                ma_vec3f listenerDirection;
+                float listenerInnerAngle;
+                float listenerOuterAngle;
+                float listenerOuterGain;
+
+                if (pListener->config.handedness == ma_handedness_right) {
+                    listenerDirection = ma_vec3f_init_3f(0, 0, -1);
+                } else {
+                    listenerDirection = ma_vec3f_init_3f(0, 0, +1);
+                }
+
+                listenerInnerAngle = pListener->config.coneInnerAngleInRadians;
+                listenerOuterAngle = pListener->config.coneOuterAngleInRadians;
+                listenerOuterGain  = pListener->config.coneOuterGain;
+
+                gain *= ma_calculate_angular_gain(listenerDirection, relativePosNormalized, listenerInnerAngle, listenerOuterAngle, listenerOuterGain);
+            }
+        } else {
+            /* The sound is right on top of the listener. Don't do any angular attenuation. */
+        }
+
+
+        /* Clamp the gain. */
+        gain = ma_clamp(gain, ma_spatializer_get_min_gain(pSpatializer), ma_spatializer_get_max_gain(pSpatializer));
+
+        /*
+        The gain needs to be applied per-channel here. The spatialization code below will be changing the per-channel
+        gains which will then eventually be passed into the gainer which will deal with smoothing the gain transitions
+        to avoid harsh changes in gain.
+        */
+        for (iChannel = 0; iChannel < channelsOut; iChannel += 1) {
+            pSpatializer->pNewChannelGainsOut[iChannel] = gain;
+        }
+
+        /*
+        Convert to our output channel count. If the listener is disabled we just output silence here. We cannot ignore
+        the whole section of code here because we need to update some internal spatialization state.
+        */
+        if (ma_spatializer_listener_is_enabled(pListener)) {
+            ma_channel_map_apply_f32((float*)pFramesOut, pChannelMapOut, channelsOut, (const float*)pFramesIn, pChannelMapIn, channelsIn, frameCount, ma_channel_mix_mode_rectangular, ma_mono_expansion_mode_default);
+        } else {
+            ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, pSpatializer->channelsOut);
+        }
+
+
+        /*
+        Panning. This is where we'll apply the gain and convert to the output channel count. We have an optimized path for
+        when we're converting to a mono stream. In that case we don't really need to do any panning - we just apply the
+        gain to the final output.
+        */
+        /*printf("distance=%f; gain=%f\n", distance, gain);*/
+
+        /* We must have a valid channel map here to ensure we spatialize properly. */
+        MA_ASSERT(pChannelMapOut != NULL);
+
+        /*
+        We're not converting to mono so we'll want to apply some panning. This is where the feeling of something being
+        to the left, right, infront or behind the listener is calculated. I'm just using a basic model here. Note that
+        the code below is not based on any specific algorithm. I'm just implementing this off the top of my head and
+        seeing how it goes. There might be better ways to do this.
+
+        To determine the direction of the sound relative to a speaker I'm using dot products. Each speaker is given a
+        direction. For example, the left channel in a stereo system will be -1 on the X axis and the right channel will
+        be +1 on the X axis. A dot product is performed against the direction vector of the channel and the normalized
+        position of the sound.
+        */
+
+        /*
+        Calculate our per-channel gains. We do this based on the normalized relative position of the sound and it's
+        relation to the direction of the channel.
+        */
+        if (distance > 0) {
+            ma_vec3f unitPos = relativePos;
+            float distanceInv = 1/distance;
+            unitPos.x *= distanceInv;
+            unitPos.y *= distanceInv;
+            unitPos.z *= distanceInv;
+
+            for (iChannel = 0; iChannel < channelsOut; iChannel += 1) {
+                ma_channel channelOut;
+                float d;
+                float dMin;
+
+                channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannel);
+                if (ma_is_spatial_channel_position(channelOut)) {
+                    d = ma_mix_f32_fast(1, ma_vec3f_dot(unitPos, ma_get_channel_direction(channelOut)), ma_spatializer_get_directional_attenuation_factor(pSpatializer));
+                } else {
+                    d = 1;  /* It's not a spatial channel so there's no real notion of direction. */
+                }
+
+                /*
+                In my testing, if the panning effect is too aggressive it makes spatialization feel uncomfortable.
+                The "dMin" variable below is used to control the aggressiveness of the panning effect. When set to
+                0, panning will be most extreme and any sounds that are positioned on the opposite side of the
+                speaker will be completely silent from that speaker. Not only does this feel uncomfortable, it
+                doesn't even remotely represent the real world at all because sounds that come from your right side
+                are still clearly audible from your left side. Setting "dMin" to 1 will result in no panning at
+                all, which is also not ideal. By setting it to something greater than 0, the spatialization effect
+                becomes much less dramatic and a lot more bearable.
+
+                Summary: 0 = more extreme panning; 1 = no panning.
+                */
+                dMin = pSpatializer->minSpatializationChannelGain;
+
+                /*
+                At this point, "d" will be positive if the sound is on the same side as the channel and negative if
+                it's on the opposite side. It will be in the range of -1..1. There's two ways I can think of to
+                calculate a panning value. The first is to simply convert it to 0..1, however this has a problem
+                which I'm not entirely happy with. Considering a stereo system, when a sound is positioned right
+                in front of the listener it'll result in each speaker getting a gain of 0.5. I don't know if I like
+                the idea of having a scaling factor of 0.5 being applied to a sound when it's sitting right in front
+                of the listener. I would intuitively expect that to be played at full volume, or close to it.
+
+                The second idea I think of is to only apply a reduction in gain when the sound is on the opposite
+                side of the speaker. That is, reduce the gain only when the dot product is negative. The problem
+                with this is that there will not be any attenuation as the sound sweeps around the 180 degrees
+                where the dot product is positive. The idea with this option is that you leave the gain at 1 when
+                the sound is being played on the same side as the speaker and then you just reduce the volume when
+                the sound is on the other side.
+
+                The summarize, I think the first option should give a better sense of spatialization, but the second
+                option is better for preserving the sound's power.
+
+                UPDATE: In my testing, I find the first option to sound better. You can feel the sense of space a
+                bit better, but you can also hear the reduction in volume when it's right in front.
+                */
+                #if 1
+                {
+                    /*
+                    Scale the dot product from -1..1 to 0..1. Will result in a sound directly in front losing power
+                    by being played at 0.5 gain.
+                    */
+                    d = (d + 1) * 0.5f;  /* -1..1 to 0..1 */
+                    d = ma_max(d, dMin);
+                    pSpatializer->pNewChannelGainsOut[iChannel] *= d;
+                }
+                #else
+                {
+                    /*
+                    Only reduce the volume of the sound if it's on the opposite side. This path keeps the volume more
+                    consistent, but comes at the expense of a worse sense of space and positioning.
+                    */
+                    if (d < 0) {
+                        d += 1; /* Move into the positive range. */
+                        d = ma_max(d, dMin);
+                        channelGainsOut[iChannel] *= d;
+                    }
+                }
+                #endif
+            }
+        } else {
+            /* Assume the sound is right on top of us. Don't do any panning. */
+        }
+
+        /* Now we need to apply the volume to each channel. This needs to run through the gainer to ensure we get a smooth volume transition. */
+        ma_gainer_set_gains(&pSpatializer->gainer, pSpatializer->pNewChannelGainsOut);
+        ma_gainer_process_pcm_frames(&pSpatializer->gainer, pFramesOut, pFramesOut, frameCount);
+
+        /*
+        Before leaving we'll want to update our doppler pitch so that the caller can apply some
+        pitch shifting if they desire. Note that we need to negate the relative position here
+        because the doppler calculation needs to be source-to-listener, but ours is listener-to-
+        source.
+        */
+        if (dopplerFactor > 0) {
+            pSpatializer->dopplerPitch = ma_doppler_pitch(ma_vec3f_sub(ma_spatializer_listener_get_position(pListener), ma_spatializer_get_position(pSpatializer)), ma_spatializer_get_velocity(pSpatializer), listenerVel, speedOfSound, dopplerFactor);
+        } else {
+            pSpatializer->dopplerPitch = 1;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_spatializer_set_master_volume(ma_spatializer* pSpatializer, float volume)
+{
+    if (pSpatializer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_gainer_set_master_volume(&pSpatializer->gainer, volume);
+}
+
+MA_API ma_result ma_spatializer_get_master_volume(const ma_spatializer* pSpatializer, float* pVolume)
+{
+    if (pSpatializer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_gainer_get_master_volume(&pSpatializer->gainer, pVolume);
+}
+
+MA_API ma_uint32 ma_spatializer_get_input_channels(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return pSpatializer->channelsIn;
+}
+
+MA_API ma_uint32 ma_spatializer_get_output_channels(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return pSpatializer->channelsOut;
+}
+
+MA_API void ma_spatializer_set_attenuation_model(ma_spatializer* pSpatializer, ma_attenuation_model attenuationModel)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_i32(&pSpatializer->attenuationModel, attenuationModel);
+}
+
+MA_API ma_attenuation_model ma_spatializer_get_attenuation_model(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return ma_attenuation_model_none;
+    }
+
+    return (ma_attenuation_model)ma_atomic_load_i32(&pSpatializer->attenuationModel);
+}
+
+MA_API void ma_spatializer_set_positioning(ma_spatializer* pSpatializer, ma_positioning positioning)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_i32(&pSpatializer->positioning, positioning);
+}
+
+MA_API ma_positioning ma_spatializer_get_positioning(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return ma_positioning_absolute;
+    }
+
+    return (ma_positioning)ma_atomic_load_i32(&pSpatializer->positioning);
+}
+
+MA_API void ma_spatializer_set_rolloff(ma_spatializer* pSpatializer, float rolloff)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->rolloff, rolloff);
+}
+
+MA_API float ma_spatializer_get_rolloff(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->rolloff);
+}
+
+MA_API void ma_spatializer_set_min_gain(ma_spatializer* pSpatializer, float minGain)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->minGain, minGain);
+}
+
+MA_API float ma_spatializer_get_min_gain(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->minGain);
+}
+
+MA_API void ma_spatializer_set_max_gain(ma_spatializer* pSpatializer, float maxGain)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->maxGain, maxGain);
+}
+
+MA_API float ma_spatializer_get_max_gain(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->maxGain);
+}
+
+MA_API void ma_spatializer_set_min_distance(ma_spatializer* pSpatializer, float minDistance)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->minDistance, minDistance);
+}
+
+MA_API float ma_spatializer_get_min_distance(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->minDistance);
+}
+
+MA_API void ma_spatializer_set_max_distance(ma_spatializer* pSpatializer, float maxDistance)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->maxDistance, maxDistance);
+}
+
+MA_API float ma_spatializer_get_max_distance(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->maxDistance);
+}
+
+MA_API void ma_spatializer_set_cone(ma_spatializer* pSpatializer, float innerAngleInRadians, float outerAngleInRadians, float outerGain)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->coneInnerAngleInRadians, innerAngleInRadians);
+    ma_atomic_exchange_f32(&pSpatializer->coneOuterAngleInRadians, outerAngleInRadians);
+    ma_atomic_exchange_f32(&pSpatializer->coneOuterGain,           outerGain);
+}
+
+MA_API void ma_spatializer_get_cone(const ma_spatializer* pSpatializer, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    if (pInnerAngleInRadians != NULL) {
+        *pInnerAngleInRadians = ma_atomic_load_f32(&pSpatializer->coneInnerAngleInRadians);
+    }
+
+    if (pOuterAngleInRadians != NULL) {
+        *pOuterAngleInRadians = ma_atomic_load_f32(&pSpatializer->coneOuterAngleInRadians);
+    }
+
+    if (pOuterGain != NULL) {
+        *pOuterGain = ma_atomic_load_f32(&pSpatializer->coneOuterGain);
+    }
+}
+
+MA_API void ma_spatializer_set_doppler_factor(ma_spatializer* pSpatializer, float dopplerFactor)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->dopplerFactor, dopplerFactor);
+}
+
+MA_API float ma_spatializer_get_doppler_factor(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 1;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->dopplerFactor);
+}
+
+MA_API void ma_spatializer_set_directional_attenuation_factor(ma_spatializer* pSpatializer, float directionalAttenuationFactor)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_f32(&pSpatializer->directionalAttenuationFactor, directionalAttenuationFactor);
+}
+
+MA_API float ma_spatializer_get_directional_attenuation_factor(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return 1;
+    }
+
+    return ma_atomic_load_f32(&pSpatializer->directionalAttenuationFactor);
+}
+
+MA_API void ma_spatializer_set_position(ma_spatializer* pSpatializer, float x, float y, float z)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pSpatializer->position, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_get_position(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pSpatializer->position);  /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_set_direction(ma_spatializer* pSpatializer, float x, float y, float z)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pSpatializer->direction, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_get_direction(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pSpatializer->direction); /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_set_velocity(ma_spatializer* pSpatializer, float x, float y, float z)
+{
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    ma_atomic_vec3f_set(&pSpatializer->velocity, ma_vec3f_init_3f(x, y, z));
+}
+
+MA_API ma_vec3f ma_spatializer_get_velocity(const ma_spatializer* pSpatializer)
+{
+    if (pSpatializer == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_atomic_vec3f_get((ma_atomic_vec3f*)&pSpatializer->velocity);  /* Naughty const-cast. It's just for atomically loading the vec3 which should be safe. */
+}
+
+MA_API void ma_spatializer_get_relative_position_and_direction(const ma_spatializer* pSpatializer, const ma_spatializer_listener* pListener, ma_vec3f* pRelativePos, ma_vec3f* pRelativeDir)
+{
+    if (pRelativePos != NULL) {
+        pRelativePos->x = 0;
+        pRelativePos->y = 0;
+        pRelativePos->z = 0;
+    }
+
+    if (pRelativeDir != NULL) {
+        pRelativeDir->x = 0;
+        pRelativeDir->y = 0;
+        pRelativeDir->z = -1;
+    }
+
+    if (pSpatializer == NULL) {
+        return;
+    }
+
+    if (pListener == NULL || ma_spatializer_get_positioning(pSpatializer) == ma_positioning_relative) {
+        /* There's no listener or we're using relative positioning. */
+        if (pRelativePos != NULL) {
+            *pRelativePos = ma_spatializer_get_position(pSpatializer);
+        }
+        if (pRelativeDir != NULL) {
+            *pRelativeDir = ma_spatializer_get_direction(pSpatializer);
+        }
+    } else {
+        ma_vec3f spatializerPosition;
+        ma_vec3f spatializerDirection;
+        ma_vec3f listenerPosition;
+        ma_vec3f listenerDirection;
+        ma_vec3f v;
+        ma_vec3f axisX;
+        ma_vec3f axisY;
+        ma_vec3f axisZ;
+        float m[4][4];
+
+        spatializerPosition  = ma_spatializer_get_position(pSpatializer);
+        spatializerDirection = ma_spatializer_get_direction(pSpatializer);
+        listenerPosition     = ma_spatializer_listener_get_position(pListener);
+        listenerDirection    = ma_spatializer_listener_get_direction(pListener);
+
+        /*
+        We need to calcualte the right vector from our forward and up vectors. This is done with
+        a cross product.
+        */
+        axisZ = ma_vec3f_normalize(listenerDirection);                                  /* Normalization required here because we can't trust the caller. */
+        axisX = ma_vec3f_normalize(ma_vec3f_cross(axisZ, pListener->config.worldUp));   /* Normalization required here because the world up vector may not be perpendicular with the forward vector. */
+
+        /*
+        The calculation of axisX above can result in a zero-length vector if the listener is
+        looking straight up on the Y axis. We'll need to fall back to a +X in this case so that
+        the calculations below don't fall apart. This is where a quaternion based listener and
+        sound orientation would come in handy.
+        */
+        if (ma_vec3f_len2(axisX) == 0) {
+            axisX = ma_vec3f_init_3f(1, 0, 0);
+        }
+
+        axisY = ma_vec3f_cross(axisX, axisZ);                                           /* No normalization is required here because axisX and axisZ are unit length and perpendicular. */
+
+        /*
+        We need to swap the X axis if we're left handed because otherwise the cross product above
+        will have resulted in it pointing in the wrong direction (right handed was assumed in the
+        cross products above).
+        */
+        if (pListener->config.handedness == ma_handedness_left) {
+            axisX = ma_vec3f_neg(axisX);
+        }
+
+        /* Lookat. */
+        m[0][0] =  axisX.x; m[1][0] =  axisX.y; m[2][0] =  axisX.z; m[3][0] = -ma_vec3f_dot(axisX,               listenerPosition);
+        m[0][1] =  axisY.x; m[1][1] =  axisY.y; m[2][1] =  axisY.z; m[3][1] = -ma_vec3f_dot(axisY,               listenerPosition);
+        m[0][2] = -axisZ.x; m[1][2] = -axisZ.y; m[2][2] = -axisZ.z; m[3][2] = -ma_vec3f_dot(ma_vec3f_neg(axisZ), listenerPosition);
+        m[0][3] = 0;        m[1][3] = 0;        m[2][3] = 0;        m[3][3] = 1;
+
+        /*
+        Multiply the lookat matrix by the spatializer position to transform it to listener
+        space. This allows calculations to work based on the sound being relative to the
+        origin which makes things simpler.
+        */
+        if (pRelativePos != NULL) {
+            v = spatializerPosition;
+            pRelativePos->x = m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * 1;
+            pRelativePos->y = m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * 1;
+            pRelativePos->z = m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * 1;
+        }
+
+        /*
+        The direction of the sound needs to also be transformed so that it's relative to the
+        rotation of the listener.
+        */
+        if (pRelativeDir != NULL) {
+            v = spatializerDirection;
+            pRelativeDir->x = m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z;
+            pRelativeDir->y = m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z;
+            pRelativeDir->z = m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z;
+        }
+    }
+}
+
+
+
+
+/**************************************************************************************************************************************************************
+
+Resampling
+
+**************************************************************************************************************************************************************/
+MA_API ma_linear_resampler_config ma_linear_resampler_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    ma_linear_resampler_config config;
+    MA_ZERO_OBJECT(&config);
+    config.format           = format;
+    config.channels         = channels;
+    config.sampleRateIn     = sampleRateIn;
+    config.sampleRateOut    = sampleRateOut;
+    config.lpfOrder         = ma_min(MA_DEFAULT_RESAMPLER_LPF_ORDER, MA_MAX_FILTER_ORDER);
+    config.lpfNyquistFactor = 1;
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t x0Offset;
+    size_t x1Offset;
+    size_t lpfOffset;
+} ma_linear_resampler_heap_layout;
+
+
+static void ma_linear_resampler_adjust_timer_for_new_rate(ma_linear_resampler* pResampler, ma_uint32 oldSampleRateOut, ma_uint32 newSampleRateOut)
+{
+    /*
+    So what's happening here? Basically we need to adjust the fractional component of the time advance based on the new rate. The old time advance will
+    be based on the old sample rate, but we are needing to adjust it to that it's based on the new sample rate.
+    */
+    ma_uint32 oldRateTimeWhole = pResampler->inTimeFrac / oldSampleRateOut;  /* <-- This should almost never be anything other than 0, but leaving it here to make this more general and robust just in case. */
+    ma_uint32 oldRateTimeFract = pResampler->inTimeFrac % oldSampleRateOut;
+
+    pResampler->inTimeFrac =
+         (oldRateTimeWhole * newSampleRateOut) +
+        ((oldRateTimeFract * newSampleRateOut) / oldSampleRateOut);
+
+    /* Make sure the fractional part is less than the output sample rate. */
+    pResampler->inTimeInt += pResampler->inTimeFrac / pResampler->config.sampleRateOut;
+    pResampler->inTimeFrac = pResampler->inTimeFrac % pResampler->config.sampleRateOut;
+}
+
+static ma_result ma_linear_resampler_set_rate_internal(ma_linear_resampler* pResampler, void* pHeap, ma_linear_resampler_heap_layout* pHeapLayout, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut, ma_bool32 isResamplerAlreadyInitialized)
+{
+    ma_result result;
+    ma_uint32 gcf;
+    ma_uint32 lpfSampleRate;
+    double lpfCutoffFrequency;
+    ma_lpf_config lpfConfig;
+    ma_uint32 oldSampleRateOut; /* Required for adjusting time advance down the bottom. */
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (sampleRateIn == 0 || sampleRateOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    oldSampleRateOut = pResampler->config.sampleRateOut;
+
+    pResampler->config.sampleRateIn  = sampleRateIn;
+    pResampler->config.sampleRateOut = sampleRateOut;
+
+    /* Simplify the sample rate. */
+    gcf = ma_gcf_u32(pResampler->config.sampleRateIn, pResampler->config.sampleRateOut);
+    pResampler->config.sampleRateIn  /= gcf;
+    pResampler->config.sampleRateOut /= gcf;
+
+    /* Always initialize the low-pass filter, even when the order is 0. */
+    if (pResampler->config.lpfOrder > MA_MAX_FILTER_ORDER) {
+        return MA_INVALID_ARGS;
+    }
+
+    lpfSampleRate      = (ma_uint32)(ma_max(pResampler->config.sampleRateIn, pResampler->config.sampleRateOut));
+    lpfCutoffFrequency = (   double)(ma_min(pResampler->config.sampleRateIn, pResampler->config.sampleRateOut) * 0.5 * pResampler->config.lpfNyquistFactor);
+
+    lpfConfig = ma_lpf_config_init(pResampler->config.format, pResampler->config.channels, lpfSampleRate, lpfCutoffFrequency, pResampler->config.lpfOrder);
+
+    /*
+    If the resampler is alreay initialized we don't want to do a fresh initialization of the low-pass filter because it will result in the cached frames
+    getting cleared. Instead we re-initialize the filter which will maintain any cached frames.
+    */
+    if (isResamplerAlreadyInitialized) {
+        result = ma_lpf_reinit(&lpfConfig, &pResampler->lpf);
+    } else {
+        result = ma_lpf_init_preallocated(&lpfConfig, ma_offset_ptr(pHeap, pHeapLayout->lpfOffset), &pResampler->lpf);
+    }
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+
+    pResampler->inAdvanceInt  = pResampler->config.sampleRateIn / pResampler->config.sampleRateOut;
+    pResampler->inAdvanceFrac = pResampler->config.sampleRateIn % pResampler->config.sampleRateOut;
+
+    /* Our timer was based on the old rate. We need to adjust it so that it's based on the new rate. */
+    ma_linear_resampler_adjust_timer_for_new_rate(pResampler, oldSampleRateOut, pResampler->config.sampleRateOut);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_linear_resampler_get_heap_layout(const ma_linear_resampler_config* pConfig, ma_linear_resampler_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->format != ma_format_f32 && pConfig->format != ma_format_s16) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* x0 */
+    pHeapLayout->x0Offset = pHeapLayout->sizeInBytes;
+    if (pConfig->format == ma_format_f32) {
+        pHeapLayout->sizeInBytes += sizeof(float) * pConfig->channels;
+    } else {
+        pHeapLayout->sizeInBytes += sizeof(ma_int16) * pConfig->channels;
+    }
+
+    /* x1 */
+    pHeapLayout->x1Offset = pHeapLayout->sizeInBytes;
+    if (pConfig->format == ma_format_f32) {
+        pHeapLayout->sizeInBytes += sizeof(float) * pConfig->channels;
+    } else {
+        pHeapLayout->sizeInBytes += sizeof(ma_int16) * pConfig->channels;
+    }
+
+    /* LPF */
+    pHeapLayout->lpfOffset = ma_align_64(pHeapLayout->sizeInBytes);
+    {
+        ma_result result;
+        size_t lpfHeapSizeInBytes;
+        ma_lpf_config lpfConfig = ma_lpf_config_init(pConfig->format, pConfig->channels, 1, 1, pConfig->lpfOrder);  /* Sample rate and cutoff frequency do not matter. */
+
+        result = ma_lpf_get_heap_size(&lpfConfig, &lpfHeapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += lpfHeapSizeInBytes;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_linear_resampler_get_heap_size(const ma_linear_resampler_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_linear_resampler_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_linear_resampler_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_linear_resampler_init_preallocated(const ma_linear_resampler_config* pConfig, void* pHeap, ma_linear_resampler* pResampler)
+{
+    ma_result result;
+    ma_linear_resampler_heap_layout heapLayout;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pResampler);
+
+    result = ma_linear_resampler_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pResampler->config = *pConfig;
+
+    pResampler->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    if (pConfig->format == ma_format_f32) {
+        pResampler->x0.f32 = (float*)ma_offset_ptr(pHeap, heapLayout.x0Offset);
+        pResampler->x1.f32 = (float*)ma_offset_ptr(pHeap, heapLayout.x1Offset);
+    } else {
+        pResampler->x0.s16 = (ma_int16*)ma_offset_ptr(pHeap, heapLayout.x0Offset);
+        pResampler->x1.s16 = (ma_int16*)ma_offset_ptr(pHeap, heapLayout.x1Offset);
+    }
+
+    /* Setting the rate will set up the filter and time advances for us. */
+    result = ma_linear_resampler_set_rate_internal(pResampler, pHeap, &heapLayout, pConfig->sampleRateIn, pConfig->sampleRateOut, /* isResamplerAlreadyInitialized = */ MA_FALSE);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pResampler->inTimeInt  = 1;  /* Set this to one to force an input sample to always be loaded for the first output frame. */
+    pResampler->inTimeFrac = 0;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_linear_resampler_init(const ma_linear_resampler_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_linear_resampler* pResampler)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_linear_resampler_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_linear_resampler_init_preallocated(pConfig, pHeap, pResampler);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pResampler->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_linear_resampler_uninit(ma_linear_resampler* pResampler, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pResampler == NULL) {
+        return;
+    }
+
+    ma_lpf_uninit(&pResampler->lpf, pAllocationCallbacks);
+
+    if (pResampler->_ownsHeap) {
+        ma_free(pResampler->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static MA_INLINE ma_int16 ma_linear_resampler_mix_s16(ma_int16 x, ma_int16 y, ma_int32 a, const ma_int32 shift)
+{
+    ma_int32 b;
+    ma_int32 c;
+    ma_int32 r;
+
+    MA_ASSERT(a <= (1<<shift));
+
+    b = x * ((1<<shift) - a);
+    c = y * a;
+    r = b + c;
+
+    return (ma_int16)(r >> shift);
+}
+
+static void ma_linear_resampler_interpolate_frame_s16(ma_linear_resampler* pResampler, ma_int16* MA_RESTRICT pFrameOut)
+{
+    ma_uint32 c;
+    ma_uint32 a;
+    const ma_uint32 channels = pResampler->config.channels;
+    const ma_uint32 shift = 12;
+
+    MA_ASSERT(pResampler != NULL);
+    MA_ASSERT(pFrameOut  != NULL);
+
+    a = (pResampler->inTimeFrac << shift) / pResampler->config.sampleRateOut;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        ma_int16 s = ma_linear_resampler_mix_s16(pResampler->x0.s16[c], pResampler->x1.s16[c], a, shift);
+        pFrameOut[c] = s;
+    }
+}
+
+
+static void ma_linear_resampler_interpolate_frame_f32(ma_linear_resampler* pResampler, float* MA_RESTRICT pFrameOut)
+{
+    ma_uint32 c;
+    float a;
+    const ma_uint32 channels = pResampler->config.channels;
+
+    MA_ASSERT(pResampler != NULL);
+    MA_ASSERT(pFrameOut  != NULL);
+
+    a = (float)pResampler->inTimeFrac / pResampler->config.sampleRateOut;
+
+    MA_ASSUME(channels > 0);
+    for (c = 0; c < channels; c += 1) {
+        float s = ma_mix_f32_fast(pResampler->x0.f32[c], pResampler->x1.f32[c], a);
+        pFrameOut[c] = s;
+    }
+}
+
+static ma_result ma_linear_resampler_process_pcm_frames_s16_downsample(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    const ma_int16* pFramesInS16;
+    /* */ ma_int16* pFramesOutS16;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+
+    MA_ASSERT(pResampler     != NULL);
+    MA_ASSERT(pFrameCountIn  != NULL);
+    MA_ASSERT(pFrameCountOut != NULL);
+
+    pFramesInS16       = (const ma_int16*)pFramesIn;
+    pFramesOutS16      = (      ma_int16*)pFramesOut;
+    frameCountIn       = *pFrameCountIn;
+    frameCountOut      = *pFrameCountOut;
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    while (framesProcessedOut < frameCountOut) {
+        /* Before interpolating we need to load the buffers. When doing this we need to ensure we run every input sample through the filter. */
+        while (pResampler->inTimeInt > 0 && frameCountIn > framesProcessedIn) {
+            ma_uint32 iChannel;
+
+            if (pFramesInS16 != NULL) {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.s16[iChannel] = pResampler->x1.s16[iChannel];
+                    pResampler->x1.s16[iChannel] = pFramesInS16[iChannel];
+                }
+                pFramesInS16 += pResampler->config.channels;
+            } else {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.s16[iChannel] = pResampler->x1.s16[iChannel];
+                    pResampler->x1.s16[iChannel] = 0;
+                }
+            }
+
+            /* Filter. Do not apply filtering if sample rates are the same or else you'll get dangerous glitching. */
+            if (pResampler->config.sampleRateIn != pResampler->config.sampleRateOut) {
+                ma_lpf_process_pcm_frame_s16(&pResampler->lpf, pResampler->x1.s16, pResampler->x1.s16);
+            }
+
+            framesProcessedIn     += 1;
+            pResampler->inTimeInt -= 1;
+        }
+
+        if (pResampler->inTimeInt > 0) {
+            break;  /* Ran out of input data. */
+        }
+
+        /* Getting here means the frames have been loaded and filtered and we can generate the next output frame. */
+        if (pFramesOutS16 != NULL) {
+            MA_ASSERT(pResampler->inTimeInt == 0);
+            ma_linear_resampler_interpolate_frame_s16(pResampler, pFramesOutS16);
+
+            pFramesOutS16 += pResampler->config.channels;
+        }
+
+        framesProcessedOut += 1;
+
+        /* Advance time forward. */
+        pResampler->inTimeInt  += pResampler->inAdvanceInt;
+        pResampler->inTimeFrac += pResampler->inAdvanceFrac;
+        if (pResampler->inTimeFrac >= pResampler->config.sampleRateOut) {
+            pResampler->inTimeFrac -= pResampler->config.sampleRateOut;
+            pResampler->inTimeInt  += 1;
+        }
+    }
+
+    *pFrameCountIn  = framesProcessedIn;
+    *pFrameCountOut = framesProcessedOut;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_linear_resampler_process_pcm_frames_s16_upsample(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    const ma_int16* pFramesInS16;
+    /* */ ma_int16* pFramesOutS16;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+
+    MA_ASSERT(pResampler     != NULL);
+    MA_ASSERT(pFrameCountIn  != NULL);
+    MA_ASSERT(pFrameCountOut != NULL);
+
+    pFramesInS16       = (const ma_int16*)pFramesIn;
+    pFramesOutS16      = (      ma_int16*)pFramesOut;
+    frameCountIn       = *pFrameCountIn;
+    frameCountOut      = *pFrameCountOut;
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    while (framesProcessedOut < frameCountOut) {
+        /* Before interpolating we need to load the buffers. */
+        while (pResampler->inTimeInt > 0 && frameCountIn > framesProcessedIn) {
+            ma_uint32 iChannel;
+
+            if (pFramesInS16 != NULL) {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.s16[iChannel] = pResampler->x1.s16[iChannel];
+                    pResampler->x1.s16[iChannel] = pFramesInS16[iChannel];
+                }
+                pFramesInS16 += pResampler->config.channels;
+            } else {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.s16[iChannel] = pResampler->x1.s16[iChannel];
+                    pResampler->x1.s16[iChannel] = 0;
+                }
+            }
+
+            framesProcessedIn     += 1;
+            pResampler->inTimeInt -= 1;
+        }
+
+        if (pResampler->inTimeInt > 0) {
+            break;  /* Ran out of input data. */
+        }
+
+        /* Getting here means the frames have been loaded and we can generate the next output frame. */
+        if (pFramesOutS16 != NULL) {
+            MA_ASSERT(pResampler->inTimeInt == 0);
+            ma_linear_resampler_interpolate_frame_s16(pResampler, pFramesOutS16);
+
+            /* Filter. Do not apply filtering if sample rates are the same or else you'll get dangerous glitching. */
+            if (pResampler->config.sampleRateIn != pResampler->config.sampleRateOut) {
+                ma_lpf_process_pcm_frame_s16(&pResampler->lpf, pFramesOutS16, pFramesOutS16);
+            }
+
+            pFramesOutS16 += pResampler->config.channels;
+        }
+
+        framesProcessedOut += 1;
+
+        /* Advance time forward. */
+        pResampler->inTimeInt  += pResampler->inAdvanceInt;
+        pResampler->inTimeFrac += pResampler->inAdvanceFrac;
+        if (pResampler->inTimeFrac >= pResampler->config.sampleRateOut) {
+            pResampler->inTimeFrac -= pResampler->config.sampleRateOut;
+            pResampler->inTimeInt  += 1;
+        }
+    }
+
+    *pFrameCountIn  = framesProcessedIn;
+    *pFrameCountOut = framesProcessedOut;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_linear_resampler_process_pcm_frames_s16(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    MA_ASSERT(pResampler != NULL);
+
+    if (pResampler->config.sampleRateIn > pResampler->config.sampleRateOut) {
+        return ma_linear_resampler_process_pcm_frames_s16_downsample(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    } else {
+        return ma_linear_resampler_process_pcm_frames_s16_upsample(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    }
+}
+
+
+static ma_result ma_linear_resampler_process_pcm_frames_f32_downsample(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    const float* pFramesInF32;
+    /* */ float* pFramesOutF32;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+
+    MA_ASSERT(pResampler     != NULL);
+    MA_ASSERT(pFrameCountIn  != NULL);
+    MA_ASSERT(pFrameCountOut != NULL);
+
+    pFramesInF32       = (const float*)pFramesIn;
+    pFramesOutF32      = (      float*)pFramesOut;
+    frameCountIn       = *pFrameCountIn;
+    frameCountOut      = *pFrameCountOut;
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    while (framesProcessedOut < frameCountOut) {
+        /* Before interpolating we need to load the buffers. When doing this we need to ensure we run every input sample through the filter. */
+        while (pResampler->inTimeInt > 0 && frameCountIn > framesProcessedIn) {
+            ma_uint32 iChannel;
+
+            if (pFramesInF32 != NULL) {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.f32[iChannel] = pResampler->x1.f32[iChannel];
+                    pResampler->x1.f32[iChannel] = pFramesInF32[iChannel];
+                }
+                pFramesInF32 += pResampler->config.channels;
+            } else {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.f32[iChannel] = pResampler->x1.f32[iChannel];
+                    pResampler->x1.f32[iChannel] = 0;
+                }
+            }
+
+            /* Filter. Do not apply filtering if sample rates are the same or else you'll get dangerous glitching. */
+            if (pResampler->config.sampleRateIn != pResampler->config.sampleRateOut) {
+                ma_lpf_process_pcm_frame_f32(&pResampler->lpf, pResampler->x1.f32, pResampler->x1.f32);
+            }
+
+            framesProcessedIn     += 1;
+            pResampler->inTimeInt -= 1;
+        }
+
+        if (pResampler->inTimeInt > 0) {
+            break;  /* Ran out of input data. */
+        }
+
+        /* Getting here means the frames have been loaded and filtered and we can generate the next output frame. */
+        if (pFramesOutF32 != NULL) {
+            MA_ASSERT(pResampler->inTimeInt == 0);
+            ma_linear_resampler_interpolate_frame_f32(pResampler, pFramesOutF32);
+
+            pFramesOutF32 += pResampler->config.channels;
+        }
+
+        framesProcessedOut += 1;
+
+        /* Advance time forward. */
+        pResampler->inTimeInt  += pResampler->inAdvanceInt;
+        pResampler->inTimeFrac += pResampler->inAdvanceFrac;
+        if (pResampler->inTimeFrac >= pResampler->config.sampleRateOut) {
+            pResampler->inTimeFrac -= pResampler->config.sampleRateOut;
+            pResampler->inTimeInt  += 1;
+        }
+    }
+
+    *pFrameCountIn  = framesProcessedIn;
+    *pFrameCountOut = framesProcessedOut;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_linear_resampler_process_pcm_frames_f32_upsample(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    const float* pFramesInF32;
+    /* */ float* pFramesOutF32;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+
+    MA_ASSERT(pResampler     != NULL);
+    MA_ASSERT(pFrameCountIn  != NULL);
+    MA_ASSERT(pFrameCountOut != NULL);
+
+    pFramesInF32       = (const float*)pFramesIn;
+    pFramesOutF32      = (      float*)pFramesOut;
+    frameCountIn       = *pFrameCountIn;
+    frameCountOut      = *pFrameCountOut;
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    while (framesProcessedOut < frameCountOut) {
+        /* Before interpolating we need to load the buffers. */
+        while (pResampler->inTimeInt > 0 && frameCountIn > framesProcessedIn) {
+            ma_uint32 iChannel;
+
+            if (pFramesInF32 != NULL) {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.f32[iChannel] = pResampler->x1.f32[iChannel];
+                    pResampler->x1.f32[iChannel] = pFramesInF32[iChannel];
+                }
+                pFramesInF32 += pResampler->config.channels;
+            } else {
+                for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+                    pResampler->x0.f32[iChannel] = pResampler->x1.f32[iChannel];
+                    pResampler->x1.f32[iChannel] = 0;
+                }
+            }
+
+            framesProcessedIn     += 1;
+            pResampler->inTimeInt -= 1;
+        }
+
+        if (pResampler->inTimeInt > 0) {
+            break;  /* Ran out of input data. */
+        }
+
+        /* Getting here means the frames have been loaded and we can generate the next output frame. */
+        if (pFramesOutF32 != NULL) {
+            MA_ASSERT(pResampler->inTimeInt == 0);
+            ma_linear_resampler_interpolate_frame_f32(pResampler, pFramesOutF32);
+
+            /* Filter. Do not apply filtering if sample rates are the same or else you'll get dangerous glitching. */
+            if (pResampler->config.sampleRateIn != pResampler->config.sampleRateOut) {
+                ma_lpf_process_pcm_frame_f32(&pResampler->lpf, pFramesOutF32, pFramesOutF32);
+            }
+
+            pFramesOutF32 += pResampler->config.channels;
+        }
+
+        framesProcessedOut += 1;
+
+        /* Advance time forward. */
+        pResampler->inTimeInt  += pResampler->inAdvanceInt;
+        pResampler->inTimeFrac += pResampler->inAdvanceFrac;
+        if (pResampler->inTimeFrac >= pResampler->config.sampleRateOut) {
+            pResampler->inTimeFrac -= pResampler->config.sampleRateOut;
+            pResampler->inTimeInt  += 1;
+        }
+    }
+
+    *pFrameCountIn  = framesProcessedIn;
+    *pFrameCountOut = framesProcessedOut;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_linear_resampler_process_pcm_frames_f32(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    MA_ASSERT(pResampler != NULL);
+
+    if (pResampler->config.sampleRateIn > pResampler->config.sampleRateOut) {
+        return ma_linear_resampler_process_pcm_frames_f32_downsample(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    } else {
+        return ma_linear_resampler_process_pcm_frames_f32_upsample(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    }
+}
+
+
+MA_API ma_result ma_linear_resampler_process_pcm_frames(ma_linear_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*  */ if (pResampler->config.format == ma_format_s16) {
+        return ma_linear_resampler_process_pcm_frames_s16(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    } else if (pResampler->config.format == ma_format_f32) {
+        return ma_linear_resampler_process_pcm_frames_f32(pResampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    } else {
+        /* Should never get here. Getting here means the format is not supported and you didn't check the return value of ma_linear_resampler_init(). */
+        MA_ASSERT(MA_FALSE);
+        return MA_INVALID_ARGS;
+    }
+}
+
+
+MA_API ma_result ma_linear_resampler_set_rate(ma_linear_resampler* pResampler, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    return ma_linear_resampler_set_rate_internal(pResampler, NULL, NULL, sampleRateIn, sampleRateOut, /* isResamplerAlreadyInitialized = */ MA_TRUE);
+}
+
+MA_API ma_result ma_linear_resampler_set_rate_ratio(ma_linear_resampler* pResampler, float ratioInOut)
+{
+    ma_uint32 n;
+    ma_uint32 d;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ratioInOut <= 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    d = 1000000;
+    n = (ma_uint32)(ratioInOut * d);
+
+    if (n == 0) {
+        return MA_INVALID_ARGS; /* Ratio too small. */
+    }
+
+    MA_ASSERT(n != 0);
+
+    return ma_linear_resampler_set_rate(pResampler, n, d);
+}
+
+MA_API ma_uint64 ma_linear_resampler_get_input_latency(const ma_linear_resampler* pResampler)
+{
+    if (pResampler == NULL) {
+        return 0;
+    }
+
+    return 1 + ma_lpf_get_latency(&pResampler->lpf);
+}
+
+MA_API ma_uint64 ma_linear_resampler_get_output_latency(const ma_linear_resampler* pResampler)
+{
+    if (pResampler == NULL) {
+        return 0;
+    }
+
+    return ma_linear_resampler_get_input_latency(pResampler) * pResampler->config.sampleRateOut / pResampler->config.sampleRateIn;
+}
+
+MA_API ma_result ma_linear_resampler_get_required_input_frame_count(const ma_linear_resampler* pResampler, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount)
+{
+    ma_uint64 inputFrameCount;
+
+    if (pInputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pInputFrameCount = 0;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (outputFrameCount == 0) {
+        return MA_SUCCESS;
+    }
+
+    /* Any whole input frames are consumed before the first output frame is generated. */
+    inputFrameCount = pResampler->inTimeInt;
+    outputFrameCount -= 1;
+
+    /* The rest of the output frames can be calculated in constant time. */
+    inputFrameCount += outputFrameCount * pResampler->inAdvanceInt;
+    inputFrameCount += (pResampler->inTimeFrac + (outputFrameCount * pResampler->inAdvanceFrac)) / pResampler->config.sampleRateOut;
+
+    *pInputFrameCount = inputFrameCount;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_linear_resampler_get_expected_output_frame_count(const ma_linear_resampler* pResampler, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount)
+{
+    ma_uint64 outputFrameCount;
+    ma_uint64 preliminaryInputFrameCountFromFrac;
+    ma_uint64 preliminaryInputFrameCount;
+
+    if (pOutputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pOutputFrameCount = 0;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    The first step is to get a preliminary output frame count. This will either be exactly equal to what we need, or less by 1. We need to
+    determine how many input frames will be consumed by this value. If it's greater than our original input frame count it means we won't
+    be able to generate an extra frame because we will have run out of input data. Otherwise we will have enough input for the generation
+    of an extra output frame. This add-by-one logic is necessary due to how the data loading logic works when processing frames.
+    */
+    outputFrameCount = (inputFrameCount * pResampler->config.sampleRateOut) / pResampler->config.sampleRateIn;
+
+    /*
+    We need to determine how many *whole* input frames will have been processed to generate our preliminary output frame count. This is
+    used in the logic below to determine whether or not we need to add an extra output frame.
+    */
+    preliminaryInputFrameCountFromFrac = (pResampler->inTimeFrac + outputFrameCount*pResampler->inAdvanceFrac) / pResampler->config.sampleRateOut;
+    preliminaryInputFrameCount         = (pResampler->inTimeInt  + outputFrameCount*pResampler->inAdvanceInt ) + preliminaryInputFrameCountFromFrac;
+
+    /*
+    If the total number of *whole* input frames that would be required to generate our preliminary output frame count is greather than
+    the amount of whole input frames we have available as input we need to *not* add an extra output frame as there won't be enough data
+    to actually process. Otherwise we need to add the extra output frame.
+    */
+    if (preliminaryInputFrameCount <= inputFrameCount) {
+        outputFrameCount += 1;
+    }
+
+    *pOutputFrameCount = outputFrameCount;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_linear_resampler_reset(ma_linear_resampler* pResampler)
+{
+    ma_uint32 iChannel;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Timers need to be cleared back to zero. */
+    pResampler->inTimeInt  = 1;  /* Set this to one to force an input sample to always be loaded for the first output frame. */
+    pResampler->inTimeFrac = 0;
+
+    /* Cached samples need to be cleared. */
+    if (pResampler->config.format == ma_format_f32) {
+        for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+            pResampler->x0.f32[iChannel] = 0;
+            pResampler->x1.f32[iChannel] = 0;
+        }
+    } else {
+        for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+            pResampler->x0.s16[iChannel] = 0;
+            pResampler->x1.s16[iChannel] = 0;
+        }
+    }
+
+    /* The low pass filter needs to have it's cache reset. */
+    ma_lpf_clear_cache(&pResampler->lpf);
+
+    return MA_SUCCESS;
+}
+
+
+
+/* Linear resampler backend vtable. */
+static ma_linear_resampler_config ma_resampling_backend_get_config__linear(const ma_resampler_config* pConfig)
+{
+    ma_linear_resampler_config linearConfig;
+
+    linearConfig = ma_linear_resampler_config_init(pConfig->format, pConfig->channels, pConfig->sampleRateIn, pConfig->sampleRateOut);
+    linearConfig.lpfOrder = pConfig->linear.lpfOrder;
+
+    return linearConfig;
+}
+
+static ma_result ma_resampling_backend_get_heap_size__linear(void* pUserData, const ma_resampler_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_linear_resampler_config linearConfig;
+
+    (void)pUserData;
+
+    linearConfig = ma_resampling_backend_get_config__linear(pConfig);
+
+    return ma_linear_resampler_get_heap_size(&linearConfig, pHeapSizeInBytes);
+}
+
+static ma_result ma_resampling_backend_init__linear(void* pUserData, const ma_resampler_config* pConfig, void* pHeap, ma_resampling_backend** ppBackend)
+{
+    ma_resampler* pResampler = (ma_resampler*)pUserData;
+    ma_result result;
+    ma_linear_resampler_config linearConfig;
+
+    (void)pUserData;
+
+    linearConfig = ma_resampling_backend_get_config__linear(pConfig);
+
+    result = ma_linear_resampler_init_preallocated(&linearConfig, pHeap, &pResampler->state.linear);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *ppBackend = &pResampler->state.linear;
+
+    return MA_SUCCESS;
+}
+
+static void ma_resampling_backend_uninit__linear(void* pUserData, ma_resampling_backend* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    (void)pUserData;
+
+    ma_linear_resampler_uninit((ma_linear_resampler*)pBackend, pAllocationCallbacks);
+}
+
+static ma_result ma_resampling_backend_process__linear(void* pUserData, ma_resampling_backend* pBackend, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_process_pcm_frames((ma_linear_resampler*)pBackend, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+}
+
+static ma_result ma_resampling_backend_set_rate__linear(void* pUserData, ma_resampling_backend* pBackend, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_set_rate((ma_linear_resampler*)pBackend, sampleRateIn, sampleRateOut);
+}
+
+static ma_uint64 ma_resampling_backend_get_input_latency__linear(void* pUserData, const ma_resampling_backend* pBackend)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_get_input_latency((const ma_linear_resampler*)pBackend);
+}
+
+static ma_uint64 ma_resampling_backend_get_output_latency__linear(void* pUserData, const ma_resampling_backend* pBackend)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_get_output_latency((const ma_linear_resampler*)pBackend);
+}
+
+static ma_result ma_resampling_backend_get_required_input_frame_count__linear(void* pUserData, const ma_resampling_backend* pBackend, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_get_required_input_frame_count((const ma_linear_resampler*)pBackend, outputFrameCount, pInputFrameCount);
+}
+
+static ma_result ma_resampling_backend_get_expected_output_frame_count__linear(void* pUserData, const ma_resampling_backend* pBackend, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_get_expected_output_frame_count((const ma_linear_resampler*)pBackend, inputFrameCount, pOutputFrameCount);
+}
+
+static ma_result ma_resampling_backend_reset__linear(void* pUserData, ma_resampling_backend* pBackend)
+{
+    (void)pUserData;
+
+    return ma_linear_resampler_reset((ma_linear_resampler*)pBackend);
+}
+
+static ma_resampling_backend_vtable g_ma_linear_resampler_vtable =
+{
+    ma_resampling_backend_get_heap_size__linear,
+    ma_resampling_backend_init__linear,
+    ma_resampling_backend_uninit__linear,
+    ma_resampling_backend_process__linear,
+    ma_resampling_backend_set_rate__linear,
+    ma_resampling_backend_get_input_latency__linear,
+    ma_resampling_backend_get_output_latency__linear,
+    ma_resampling_backend_get_required_input_frame_count__linear,
+    ma_resampling_backend_get_expected_output_frame_count__linear,
+    ma_resampling_backend_reset__linear
+};
+
+
+
+MA_API ma_resampler_config ma_resampler_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut, ma_resample_algorithm algorithm)
+{
+    ma_resampler_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format = format;
+    config.channels = channels;
+    config.sampleRateIn = sampleRateIn;
+    config.sampleRateOut = sampleRateOut;
+    config.algorithm = algorithm;
+
+    /* Linear. */
+    config.linear.lpfOrder = ma_min(MA_DEFAULT_RESAMPLER_LPF_ORDER, MA_MAX_FILTER_ORDER);
+
+    return config;
+}
+
+static ma_result ma_resampler_get_vtable(const ma_resampler_config* pConfig, ma_resampler* pResampler, ma_resampling_backend_vtable** ppVTable, void** ppUserData)
+{
+    MA_ASSERT(pConfig    != NULL);
+    MA_ASSERT(ppVTable   != NULL);
+    MA_ASSERT(ppUserData != NULL);
+
+    /* Safety. */
+    *ppVTable   = NULL;
+    *ppUserData = NULL;
+
+    switch (pConfig->algorithm)
+    {
+        case ma_resample_algorithm_linear:
+        {
+            *ppVTable   = &g_ma_linear_resampler_vtable;
+            *ppUserData = pResampler;
+        } break;
+
+        case ma_resample_algorithm_custom:
+        {
+            *ppVTable   = pConfig->pBackendVTable;
+            *ppUserData = pConfig->pBackendUserData;
+        } break;
+
+        default: return MA_INVALID_ARGS;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resampler_get_heap_size(const ma_resampler_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_resampling_backend_vtable* pVTable;
+    void* pVTableUserData;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_resampler_get_vtable(pConfig, NULL, &pVTable, &pVTableUserData);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pVTable == NULL || pVTable->onGetHeapSize == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    result = pVTable->onGetHeapSize(pVTableUserData, pConfig, pHeapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resampler_init_preallocated(const ma_resampler_config* pConfig, void* pHeap, ma_resampler* pResampler)
+{
+    ma_result result;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pResampler);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pResampler->_pHeap        = pHeap;
+    pResampler->format        = pConfig->format;
+    pResampler->channels      = pConfig->channels;
+    pResampler->sampleRateIn  = pConfig->sampleRateIn;
+    pResampler->sampleRateOut = pConfig->sampleRateOut;
+
+    result = ma_resampler_get_vtable(pConfig, pResampler, &pResampler->pBackendVTable, &pResampler->pBackendUserData);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onInit == NULL) {
+        return MA_NOT_IMPLEMENTED;  /* onInit not implemented. */
+    }
+
+    result = pResampler->pBackendVTable->onInit(pResampler->pBackendUserData, pConfig, pHeap, &pResampler->pBackend);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resampler_init(const ma_resampler_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_resampler* pResampler)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_resampler_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_resampler_init_preallocated(pConfig, pHeap, pResampler);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pResampler->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_resampler_uninit(ma_resampler* pResampler, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pResampler == NULL) {
+        return;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onUninit == NULL) {
+        return;
+    }
+
+    pResampler->pBackendVTable->onUninit(pResampler->pBackendUserData, pResampler->pBackend, pAllocationCallbacks);
+
+    if (pResampler->_ownsHeap) {
+        ma_free(pResampler->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_resampler_process_pcm_frames(ma_resampler* pResampler, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFrameCountOut == NULL && pFrameCountIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onProcess == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pResampler->pBackendVTable->onProcess(pResampler->pBackendUserData, pResampler->pBackend, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+}
+
+MA_API ma_result ma_resampler_set_rate(ma_resampler* pResampler, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    ma_result result;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (sampleRateIn == 0 || sampleRateOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onSetRate == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    result = pResampler->pBackendVTable->onSetRate(pResampler->pBackendUserData, pResampler->pBackend, sampleRateIn, sampleRateOut);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pResampler->sampleRateIn  = sampleRateIn;
+    pResampler->sampleRateOut = sampleRateOut;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resampler_set_rate_ratio(ma_resampler* pResampler, float ratio)
+{
+    ma_uint32 n;
+    ma_uint32 d;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ratio <= 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    d = 1000;
+    n = (ma_uint32)(ratio * d);
+
+    if (n == 0) {
+        return MA_INVALID_ARGS; /* Ratio too small. */
+    }
+
+    MA_ASSERT(n != 0);
+
+    return ma_resampler_set_rate(pResampler, n, d);
+}
+
+MA_API ma_uint64 ma_resampler_get_input_latency(const ma_resampler* pResampler)
+{
+    if (pResampler == NULL) {
+        return 0;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onGetInputLatency == NULL) {
+        return 0;
+    }
+
+    return pResampler->pBackendVTable->onGetInputLatency(pResampler->pBackendUserData, pResampler->pBackend);
+}
+
+MA_API ma_uint64 ma_resampler_get_output_latency(const ma_resampler* pResampler)
+{
+    if (pResampler == NULL) {
+        return 0;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onGetOutputLatency == NULL) {
+        return 0;
+    }
+
+    return pResampler->pBackendVTable->onGetOutputLatency(pResampler->pBackendUserData, pResampler->pBackend);
+}
+
+MA_API ma_result ma_resampler_get_required_input_frame_count(const ma_resampler* pResampler, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount)
+{
+    if (pInputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pInputFrameCount = 0;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onGetRequiredInputFrameCount == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pResampler->pBackendVTable->onGetRequiredInputFrameCount(pResampler->pBackendUserData, pResampler->pBackend, outputFrameCount, pInputFrameCount);
+}
+
+MA_API ma_result ma_resampler_get_expected_output_frame_count(const ma_resampler* pResampler, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount)
+{
+    if (pOutputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pOutputFrameCount = 0;
+
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onGetExpectedOutputFrameCount == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pResampler->pBackendVTable->onGetExpectedOutputFrameCount(pResampler->pBackendUserData, pResampler->pBackend, inputFrameCount, pOutputFrameCount);
+}
+
+MA_API ma_result ma_resampler_reset(ma_resampler* pResampler)
+{
+    if (pResampler == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onReset == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pResampler->pBackendVTable->onReset(pResampler->pBackendUserData, pResampler->pBackend);
+}
+
+/**************************************************************************************************************************************************************
+
+Channel Conversion
+
+**************************************************************************************************************************************************************/
+#ifndef MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT
+#define MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT  12
+#endif
+
+#define MA_PLANE_LEFT      0
+#define MA_PLANE_RIGHT     1
+#define MA_PLANE_FRONT     2
+#define MA_PLANE_BACK      3
+#define MA_PLANE_BOTTOM    4
+#define MA_PLANE_TOP       5
+
+static float g_maChannelPlaneRatios[MA_CHANNEL_POSITION_COUNT][6] = {
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_NONE */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_MONO */
+    { 0.5f,  0.0f,  0.5f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_FRONT_LEFT */
+    { 0.0f,  0.5f,  0.5f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_FRONT_RIGHT */
+    { 0.0f,  0.0f,  1.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_FRONT_CENTER */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_LFE */
+    { 0.5f,  0.0f,  0.0f,  0.5f,  0.0f,  0.0f},  /* MA_CHANNEL_BACK_LEFT */
+    { 0.0f,  0.5f,  0.0f,  0.5f,  0.0f,  0.0f},  /* MA_CHANNEL_BACK_RIGHT */
+    { 0.25f, 0.0f,  0.75f, 0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_FRONT_LEFT_CENTER */
+    { 0.0f,  0.25f, 0.75f, 0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_FRONT_RIGHT_CENTER */
+    { 0.0f,  0.0f,  0.0f,  1.0f,  0.0f,  0.0f},  /* MA_CHANNEL_BACK_CENTER */
+    { 1.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_SIDE_LEFT */
+    { 0.0f,  1.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_SIDE_RIGHT */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  1.0f},  /* MA_CHANNEL_TOP_CENTER */
+    { 0.33f, 0.0f,  0.33f, 0.0f,  0.0f,  0.34f}, /* MA_CHANNEL_TOP_FRONT_LEFT */
+    { 0.0f,  0.0f,  0.5f,  0.0f,  0.0f,  0.5f},  /* MA_CHANNEL_TOP_FRONT_CENTER */
+    { 0.0f,  0.33f, 0.33f, 0.0f,  0.0f,  0.34f}, /* MA_CHANNEL_TOP_FRONT_RIGHT */
+    { 0.33f, 0.0f,  0.0f,  0.33f, 0.0f,  0.34f}, /* MA_CHANNEL_TOP_BACK_LEFT */
+    { 0.0f,  0.0f,  0.0f,  0.5f,  0.0f,  0.5f},  /* MA_CHANNEL_TOP_BACK_CENTER */
+    { 0.0f,  0.33f, 0.0f,  0.33f, 0.0f,  0.34f}, /* MA_CHANNEL_TOP_BACK_RIGHT */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_0 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_1 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_2 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_3 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_4 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_5 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_6 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_7 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_8 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_9 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_10 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_11 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_12 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_13 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_14 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_15 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_16 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_17 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_18 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_19 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_20 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_21 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_22 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_23 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_24 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_25 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_26 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_27 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_28 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_29 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_30 */
+    { 0.0f,  0.0f,  0.0f,  0.0f,  0.0f,  0.0f},  /* MA_CHANNEL_AUX_31 */
+};
+
+static float ma_calculate_channel_position_rectangular_weight(ma_channel channelPositionA, ma_channel channelPositionB)
+{
+    /*
+    Imagine the following simplified example: You have a single input speaker which is the front/left speaker which you want to convert to
+    the following output configuration:
+
+     - front/left
+     - side/left
+     - back/left
+
+    The front/left output is easy - it the same speaker position so it receives the full contribution of the front/left input. The amount
+    of contribution to apply to the side/left and back/left speakers, however, is a bit more complicated.
+
+    Imagine the front/left speaker as emitting audio from two planes - the front plane and the left plane. You can think of the front/left
+    speaker emitting half of it's total volume from the front, and the other half from the left. Since part of it's volume is being emitted
+    from the left side, and the side/left and back/left channels also emit audio from the left plane, one would expect that they would
+    receive some amount of contribution from front/left speaker. The amount of contribution depends on how many planes are shared between
+    the two speakers. Note that in the examples below I've added a top/front/left speaker as an example just to show how the math works
+    across 3 spatial dimensions.
+
+    The first thing to do is figure out how each speaker's volume is spread over each of plane:
+     - front/left:     2 planes (front and left)      = 1/2 = half it's total volume on each plane
+     - side/left:      1 plane (left only)            = 1/1 = entire volume from left plane
+     - back/left:      2 planes (back and left)       = 1/2 = half it's total volume on each plane
+     - top/front/left: 3 planes (top, front and left) = 1/3 = one third it's total volume on each plane
+
+    The amount of volume each channel contributes to each of it's planes is what controls how much it is willing to given and take to other
+    channels on the same plane. The volume that is willing to the given by one channel is multiplied by the volume that is willing to be
+    taken by the other to produce the final contribution.
+    */
+
+    /* Contribution = Sum(Volume to Give * Volume to Take) */
+    float contribution =
+        g_maChannelPlaneRatios[channelPositionA][0] * g_maChannelPlaneRatios[channelPositionB][0] +
+        g_maChannelPlaneRatios[channelPositionA][1] * g_maChannelPlaneRatios[channelPositionB][1] +
+        g_maChannelPlaneRatios[channelPositionA][2] * g_maChannelPlaneRatios[channelPositionB][2] +
+        g_maChannelPlaneRatios[channelPositionA][3] * g_maChannelPlaneRatios[channelPositionB][3] +
+        g_maChannelPlaneRatios[channelPositionA][4] * g_maChannelPlaneRatios[channelPositionB][4] +
+        g_maChannelPlaneRatios[channelPositionA][5] * g_maChannelPlaneRatios[channelPositionB][5];
+
+    return contribution;
+}
+
+MA_API ma_channel_converter_config ma_channel_converter_config_init(ma_format format, ma_uint32 channelsIn, const ma_channel* pChannelMapIn, ma_uint32 channelsOut, const ma_channel* pChannelMapOut, ma_channel_mix_mode mixingMode)
+{
+    ma_channel_converter_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format         = format;
+    config.channelsIn     = channelsIn;
+    config.channelsOut    = channelsOut;
+    config.pChannelMapIn  = pChannelMapIn;
+    config.pChannelMapOut = pChannelMapOut;
+    config.mixingMode     = mixingMode;
+
+    return config;
+}
+
+static ma_int32 ma_channel_converter_float_to_fixed(float x)
+{
+    return (ma_int32)(x * (1<<MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT));
+}
+
+static ma_uint32 ma_channel_map_get_spatial_channel_count(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    ma_uint32 spatialChannelCount = 0;
+    ma_uint32 iChannel;
+
+    MA_ASSERT(pChannelMap != NULL);
+    MA_ASSERT(channels > 0);
+
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        if (ma_is_spatial_channel_position(ma_channel_map_get_channel(pChannelMap, channels, iChannel))) {
+            spatialChannelCount++;
+        }
+    }
+
+    return spatialChannelCount;
+}
+
+static ma_bool32 ma_is_spatial_channel_position(ma_channel channelPosition)
+{
+    int i;
+
+    if (channelPosition == MA_CHANNEL_NONE || channelPosition == MA_CHANNEL_MONO || channelPosition == MA_CHANNEL_LFE) {
+        return MA_FALSE;
+    }
+
+    if (channelPosition >= MA_CHANNEL_AUX_0 && channelPosition <= MA_CHANNEL_AUX_31) {
+        return MA_FALSE;
+    }
+
+    for (i = 0; i < 6; ++i) {   /* Each side of a cube. */
+        if (g_maChannelPlaneRatios[channelPosition][i] != 0) {
+            return MA_TRUE;
+        }
+    }
+
+    return MA_FALSE;
+}
+
+
+static ma_bool32 ma_channel_map_is_passthrough(const ma_channel* pChannelMapIn, ma_uint32 channelsIn, const ma_channel* pChannelMapOut, ma_uint32 channelsOut)
+{
+    if (channelsOut == channelsIn) {
+        return ma_channel_map_is_equal(pChannelMapOut, pChannelMapIn, channelsOut);
+    } else {
+        return MA_FALSE;    /* Channel counts differ, so cannot be a passthrough. */
+    }
+}
+
+static ma_channel_conversion_path ma_channel_map_get_conversion_path(const ma_channel* pChannelMapIn, ma_uint32 channelsIn, const ma_channel* pChannelMapOut, ma_uint32 channelsOut, ma_channel_mix_mode mode)
+{
+    if (ma_channel_map_is_passthrough(pChannelMapIn, channelsIn, pChannelMapOut, channelsOut)) {
+        return ma_channel_conversion_path_passthrough;
+    }
+
+    if (channelsOut == 1 && (pChannelMapOut == NULL || pChannelMapOut[0] == MA_CHANNEL_MONO)) {
+        return ma_channel_conversion_path_mono_out;
+    }
+
+    if (channelsIn == 1 && (pChannelMapIn == NULL || pChannelMapIn[0] == MA_CHANNEL_MONO)) {
+        return ma_channel_conversion_path_mono_in;
+    }
+
+    if (mode == ma_channel_mix_mode_custom_weights) {
+        return ma_channel_conversion_path_weights;
+    }
+
+    /*
+    We can use a simple shuffle if both channel maps have the same channel count and all channel
+    positions are present in both.
+    */
+    if (channelsIn == channelsOut) {
+        ma_uint32 iChannelIn;
+        ma_bool32 areAllChannelPositionsPresent = MA_TRUE;
+        for (iChannelIn = 0; iChannelIn < channelsIn; ++iChannelIn) {
+            ma_bool32 isInputChannelPositionInOutput = MA_FALSE;
+            if (ma_channel_map_contains_channel_position(channelsOut, pChannelMapOut, ma_channel_map_get_channel(pChannelMapIn, channelsIn, iChannelIn))) {
+                isInputChannelPositionInOutput = MA_TRUE;
+                break;
+            }
+
+            if (!isInputChannelPositionInOutput) {
+                areAllChannelPositionsPresent = MA_FALSE;
+                break;
+            }
+        }
+
+        if (areAllChannelPositionsPresent) {
+            return ma_channel_conversion_path_shuffle;
+        }
+    }
+
+    /* Getting here means we'll need to use weights. */
+    return ma_channel_conversion_path_weights;
+}
+
+
+static ma_result ma_channel_map_build_shuffle_table(const ma_channel* pChannelMapIn, ma_uint32 channelCountIn, const ma_channel* pChannelMapOut, ma_uint32 channelCountOut, ma_uint8* pShuffleTable)
+{
+    ma_uint32 iChannelIn;
+    ma_uint32 iChannelOut;
+
+    if (pShuffleTable == NULL || channelCountIn == 0 || channelCountOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    When building the shuffle table we just do a 1:1 mapping based on the first occurance of a channel. If the
+    input channel has more than one occurance of a channel position, the second one will be ignored.
+    */
+    for (iChannelOut = 0; iChannelOut < channelCountOut; iChannelOut += 1) {
+        ma_channel channelOut;
+
+        /* Default to MA_CHANNEL_INDEX_NULL so that if a mapping is not found it'll be set appropriately. */
+        pShuffleTable[iChannelOut] = MA_CHANNEL_INDEX_NULL;
+
+        channelOut = ma_channel_map_get_channel(pChannelMapOut, channelCountOut, iChannelOut);
+        for (iChannelIn = 0; iChannelIn < channelCountIn; iChannelIn += 1) {
+            ma_channel channelIn;
+
+            channelIn = ma_channel_map_get_channel(pChannelMapIn, channelCountIn, iChannelIn);
+            if (channelOut == channelIn) {
+                pShuffleTable[iChannelOut] = (ma_uint8)iChannelIn;
+                break;
+            }
+
+            /*
+            Getting here means the channels don't exactly match, but we are going to support some
+            relaxed matching for practicality. If, for example, there are two stereo channel maps,
+            but one uses front left/right and the other uses side left/right, it makes logical
+            sense to just map these. The way we'll do it is we'll check if there is a logical
+            corresponding mapping, and if so, apply it, but we will *not* break from the loop,
+            thereby giving the loop a chance to find an exact match later which will take priority.
+            */
+            switch (channelOut)
+            {
+                /* Left channels. */
+                case MA_CHANNEL_FRONT_LEFT:
+                case MA_CHANNEL_SIDE_LEFT:
+                {
+                    switch (channelIn) {
+                        case MA_CHANNEL_FRONT_LEFT:
+                        case MA_CHANNEL_SIDE_LEFT:
+                        {
+                            pShuffleTable[iChannelOut] = (ma_uint8)iChannelIn;
+                        } break;
+                    }
+                } break;
+
+                /* Right channels. */
+                case MA_CHANNEL_FRONT_RIGHT:
+                case MA_CHANNEL_SIDE_RIGHT:
+                {
+                    switch (channelIn) {
+                        case MA_CHANNEL_FRONT_RIGHT:
+                        case MA_CHANNEL_SIDE_RIGHT:
+                        {
+                            pShuffleTable[iChannelOut] = (ma_uint8)iChannelIn;
+                        } break;
+                    }
+                } break;
+
+                default: break;
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static void ma_channel_map_apply_shuffle_table_u8(ma_uint8* pFramesOut, ma_uint32 channelsOut, const ma_uint8* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+            ma_uint8 iChannelIn = pShuffleTable[iChannelOut];
+            if (iChannelIn < channelsIn) {  /* For safety, and to deal with MA_CHANNEL_INDEX_NULL. */
+                pFramesOut[iChannelOut] = pFramesIn[iChannelIn];
+            } else {
+                pFramesOut[iChannelOut] = 0;
+            }
+        }
+
+        pFramesOut += channelsOut;
+        pFramesIn  += channelsIn;
+    }
+}
+
+static void ma_channel_map_apply_shuffle_table_s16(ma_int16* pFramesOut, ma_uint32 channelsOut, const ma_int16* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+            ma_uint8 iChannelIn = pShuffleTable[iChannelOut];
+            if (iChannelIn < channelsIn) {  /* For safety, and to deal with MA_CHANNEL_INDEX_NULL. */
+                pFramesOut[iChannelOut] = pFramesIn[iChannelIn];
+            } else {
+                pFramesOut[iChannelOut] = 0;
+            }
+        }
+
+        pFramesOut += channelsOut;
+        pFramesIn  += channelsIn;
+    }
+}
+
+static void ma_channel_map_apply_shuffle_table_s24(ma_uint8* pFramesOut, ma_uint32 channelsOut, const ma_uint8* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+            ma_uint8 iChannelIn = pShuffleTable[iChannelOut];
+            if (iChannelIn < channelsIn) {  /* For safety, and to deal with MA_CHANNEL_INDEX_NULL. */
+                pFramesOut[iChannelOut*3 + 0] = pFramesIn[iChannelIn*3 + 0];
+                pFramesOut[iChannelOut*3 + 1] = pFramesIn[iChannelIn*3 + 1];
+                pFramesOut[iChannelOut*3 + 2] = pFramesIn[iChannelIn*3 + 2];
+            } else {
+                pFramesOut[iChannelOut*3 + 0] = 0;
+            }   pFramesOut[iChannelOut*3 + 1] = 0;
+        }       pFramesOut[iChannelOut*3 + 2] = 0;
+
+        pFramesOut += channelsOut*3;
+        pFramesIn  += channelsIn*3;
+    }
+}
+
+static void ma_channel_map_apply_shuffle_table_s32(ma_int32* pFramesOut, ma_uint32 channelsOut, const ma_int32* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+            ma_uint8 iChannelIn = pShuffleTable[iChannelOut];
+            if (iChannelIn < channelsIn) {  /* For safety, and to deal with MA_CHANNEL_INDEX_NULL. */
+                pFramesOut[iChannelOut] = pFramesIn[iChannelIn];
+            } else {
+                pFramesOut[iChannelOut] = 0;
+            }
+        }
+
+        pFramesOut += channelsOut;
+        pFramesIn  += channelsIn;
+    }
+}
+
+static void ma_channel_map_apply_shuffle_table_f32(float* pFramesOut, ma_uint32 channelsOut, const float* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+            ma_uint8 iChannelIn = pShuffleTable[iChannelOut];
+            if (iChannelIn < channelsIn) {  /* For safety, and to deal with MA_CHANNEL_INDEX_NULL. */
+                pFramesOut[iChannelOut] = pFramesIn[iChannelIn];
+            } else {
+                pFramesOut[iChannelOut] = 0;
+            }
+        }
+
+        pFramesOut += channelsOut;
+        pFramesIn  += channelsIn;
+    }
+}
+
+static ma_result ma_channel_map_apply_shuffle_table(void* pFramesOut, ma_uint32 channelsOut, const void* pFramesIn, ma_uint32 channelsIn, ma_uint64 frameCount, const ma_uint8* pShuffleTable, ma_format format)
+{
+    if (pFramesOut == NULL || pFramesIn == NULL || channelsOut == 0 || pShuffleTable == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    switch (format)
+    {
+        case ma_format_u8:
+        {
+            ma_channel_map_apply_shuffle_table_u8((ma_uint8*)pFramesOut, channelsOut, (const ma_uint8*)pFramesIn, channelsIn, frameCount, pShuffleTable);
+        } break;
+
+        case ma_format_s16:
+        {
+            ma_channel_map_apply_shuffle_table_s16((ma_int16*)pFramesOut, channelsOut, (const ma_int16*)pFramesIn, channelsIn, frameCount, pShuffleTable);
+        } break;
+
+        case ma_format_s24:
+        {
+            ma_channel_map_apply_shuffle_table_s24((ma_uint8*)pFramesOut, channelsOut, (const ma_uint8*)pFramesIn, channelsIn, frameCount, pShuffleTable);
+        } break;
+
+        case ma_format_s32:
+        {
+            ma_channel_map_apply_shuffle_table_s32((ma_int32*)pFramesOut, channelsOut, (const ma_int32*)pFramesIn, channelsIn, frameCount, pShuffleTable);
+        } break;
+
+        case ma_format_f32:
+        {
+            ma_channel_map_apply_shuffle_table_f32((float*)pFramesOut, channelsOut, (const float*)pFramesIn, channelsIn, frameCount, pShuffleTable);
+        } break;
+
+        default: return MA_INVALID_ARGS;    /* Unknown format. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_channel_map_apply_mono_out_f32(float* pFramesOut, const float* pFramesIn, const ma_channel* pChannelMapIn, ma_uint32 channelsIn, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelIn;
+    ma_uint32 accumulationCount;
+
+    if (pFramesOut == NULL || pFramesIn == NULL || channelsIn == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* In this case the output stream needs to be the average of all channels, ignoring NONE. */
+
+    /* A quick pre-processing step to get the accumulation counter since we're ignoring NONE channels. */
+    accumulationCount = 0;
+    for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+        if (ma_channel_map_get_channel(pChannelMapIn, channelsIn, iChannelIn) != MA_CHANNEL_NONE) {
+            accumulationCount += 1;
+        }
+    }
+
+    if (accumulationCount > 0) {    /* <-- Prevent a division by zero. */
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float accumulation = 0;
+
+            for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                ma_channel channelIn = ma_channel_map_get_channel(pChannelMapIn, channelsIn, iChannelIn);
+                if (channelIn != MA_CHANNEL_NONE) {
+                    accumulation += pFramesIn[iChannelIn];
+                }
+            }
+
+            pFramesOut[0] = accumulation / accumulationCount;
+            pFramesOut += 1;
+            pFramesIn  += channelsIn;
+        }
+    } else {
+        ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, 1);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_channel_map_apply_mono_in_f32(float* MA_RESTRICT pFramesOut, const ma_channel* pChannelMapOut, ma_uint32 channelsOut, const float* MA_RESTRICT pFramesIn, ma_uint64 frameCount, ma_mono_expansion_mode monoExpansionMode)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannelOut;
+
+    if (pFramesOut == NULL || channelsOut == 0 || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Note that the MA_CHANNEL_NONE channel must be ignored in all cases. */
+    switch (monoExpansionMode)
+    {
+        case ma_mono_expansion_mode_average:
+        {
+            float weight;
+            ma_uint32 validChannelCount = 0;
+
+            for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                if (channelOut != MA_CHANNEL_NONE) {
+                    validChannelCount += 1;
+                }
+            }
+
+            weight = 1.0f / validChannelCount;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                    ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                    if (channelOut != MA_CHANNEL_NONE) {
+                        pFramesOut[iChannelOut] = pFramesIn[0] * weight;
+                    }
+                }
+
+                pFramesOut += channelsOut;
+                pFramesIn  += 1;
+            }
+        } break;
+
+        case ma_mono_expansion_mode_stereo_only:
+        {
+            if (channelsOut >= 2) {
+                ma_uint32 iChannelLeft  = (ma_uint32)-1;
+                ma_uint32 iChannelRight = (ma_uint32)-1;
+
+                /*
+                We first need to find our stereo channels. We prefer front-left and front-right, but
+                if they're not available, we'll also try side-left and side-right. If neither are
+                available we'll fall through to the default case below.
+                */
+                for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                    ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                    if (channelOut == MA_CHANNEL_SIDE_LEFT) {
+                        iChannelLeft  = iChannelOut;
+                    }
+                    if (channelOut == MA_CHANNEL_SIDE_RIGHT) {
+                        iChannelRight = iChannelOut;
+                    }
+                }
+
+                for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                    ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                    if (channelOut == MA_CHANNEL_FRONT_LEFT) {
+                        iChannelLeft  = iChannelOut;
+                    }
+                    if (channelOut == MA_CHANNEL_FRONT_RIGHT) {
+                        iChannelRight = iChannelOut;
+                    }
+                }
+
+
+                if (iChannelLeft != (ma_uint32)-1 && iChannelRight != (ma_uint32)-1) {
+                    /* We found our stereo channels so we can duplicate the signal across those channels. */
+                    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                            ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                            if (channelOut != MA_CHANNEL_NONE) {
+                                if (iChannelOut == iChannelLeft || iChannelOut == iChannelRight) {
+                                    pFramesOut[iChannelOut] = pFramesIn[0];
+                                } else {
+                                    pFramesOut[iChannelOut] = 0.0f;
+                                }
+                            }
+                        }
+
+                        pFramesOut += channelsOut;
+                        pFramesIn  += 1;
+                    }
+
+                    break;  /* Get out of the switch. */
+                } else {
+                    /* Fallthrough. Does not have left and right channels. */
+                    goto default_handler;
+                }
+            } else {
+                /* Fallthrough. Does not have stereo channels. */
+                goto default_handler;
+            }
+        };  /* Fallthrough. See comments above. */
+
+        case ma_mono_expansion_mode_duplicate:
+        default:
+        {
+            default_handler:
+            {
+                if (channelsOut <= MA_MAX_CHANNELS) {
+                    ma_bool32 hasEmptyChannel = MA_FALSE;
+                    ma_channel channelPositions[MA_MAX_CHANNELS];
+                    for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                        channelPositions[iChannelOut] = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                        if (channelPositions[iChannelOut] == MA_CHANNEL_NONE) {
+                            hasEmptyChannel = MA_TRUE;
+                        }
+                    }
+
+                    if (hasEmptyChannel == MA_FALSE) {
+                        /*
+                        Faster path when there's no MA_CHANNEL_NONE channel positions. This should hopefully
+                        help the compiler with auto-vectorization.m
+                        */
+                        if (channelsOut == 2) {
+                        #if defined(MA_SUPPORT_SSE2)
+                            if (ma_has_sse2()) {
+                                /* We want to do two frames in each iteration. */
+                                ma_uint64 unrolledFrameCount = frameCount >> 1;
+
+                                for (iFrame = 0; iFrame < unrolledFrameCount; iFrame += 1) {
+                                    __m128 in0 = _mm_set1_ps(pFramesIn[iFrame*2 + 0]);
+                                    __m128 in1 = _mm_set1_ps(pFramesIn[iFrame*2 + 1]);
+                                    _mm_storeu_ps(&pFramesOut[iFrame*4 + 0], _mm_shuffle_ps(in0, in1, _MM_SHUFFLE(0, 0, 0, 0)));
+                                }
+
+                                /* Tail. */
+                                iFrame = unrolledFrameCount << 1;
+                                goto generic_on_fastpath;
+                            } else
+                        #endif
+                            {
+                                for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                                    for (iChannelOut = 0; iChannelOut < 2; iChannelOut += 1) {
+                                        pFramesOut[iFrame*2 + iChannelOut] = pFramesIn[iFrame];
+                                    }
+                                }
+                            }
+                        } else if (channelsOut == 6) {
+                        #if defined(MA_SUPPORT_SSE2)
+                            if (ma_has_sse2()) {
+                                /* We want to do two frames in each iteration so we can have a multiple of 4 samples. */
+                                ma_uint64 unrolledFrameCount = frameCount >> 1;
+
+                                for (iFrame = 0; iFrame < unrolledFrameCount; iFrame += 1) {
+                                    __m128 in0 = _mm_set1_ps(pFramesIn[iFrame*2 + 0]);
+                                    __m128 in1 = _mm_set1_ps(pFramesIn[iFrame*2 + 1]);
+
+                                    _mm_storeu_ps(&pFramesOut[iFrame*12 + 0], in0);
+                                    _mm_storeu_ps(&pFramesOut[iFrame*12 + 4], _mm_shuffle_ps(in0, in1, _MM_SHUFFLE(0, 0, 0, 0)));
+                                    _mm_storeu_ps(&pFramesOut[iFrame*12 + 8], in1);
+                                }
+
+                                /* Tail. */
+                                iFrame = unrolledFrameCount << 1;
+                                goto generic_on_fastpath;
+                            } else
+                        #endif
+                            {
+                                for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                                    for (iChannelOut = 0; iChannelOut < 6; iChannelOut += 1) {
+                                        pFramesOut[iFrame*6 + iChannelOut] = pFramesIn[iFrame];
+                                    }
+                                }
+                            }
+                        } else if (channelsOut == 8) {
+                        #if defined(MA_SUPPORT_SSE2)
+                            if (ma_has_sse2()) {
+                                for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                                    __m128 in = _mm_set1_ps(pFramesIn[iFrame]);
+                                    _mm_storeu_ps(&pFramesOut[iFrame*8 + 0], in);
+                                    _mm_storeu_ps(&pFramesOut[iFrame*8 + 4], in);
+                                }
+                            } else
+                        #endif
+                            {
+                                for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                                    for (iChannelOut = 0; iChannelOut < 8; iChannelOut += 1) {
+                                        pFramesOut[iFrame*8 + iChannelOut] = pFramesIn[iFrame];
+                                    }
+                                }
+                            }
+                        } else {
+                            iFrame = 0;
+
+                            #if defined(MA_SUPPORT_SSE2)    /* For silencing a warning with non-x86 builds. */
+                            generic_on_fastpath:
+                            #endif
+                            {
+                                for (; iFrame < frameCount; iFrame += 1) {
+                                    for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                                        pFramesOut[iFrame*channelsOut + iChannelOut] = pFramesIn[iFrame];
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        /* Slow path. Need to handle MA_CHANNEL_NONE. */
+                        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                            for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                                if (channelPositions[iChannelOut] != MA_CHANNEL_NONE) {
+                                    pFramesOut[iFrame*channelsOut + iChannelOut] = pFramesIn[iFrame];
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    /* Slow path. Too many channels to store on the stack. */
+                    for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                        for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                            ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                            if (channelOut != MA_CHANNEL_NONE) {
+                                pFramesOut[iFrame*channelsOut + iChannelOut] = pFramesIn[iFrame];
+                            }
+                        }
+                    }
+                }
+            }
+        } break;
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_channel_map_apply_f32(float* pFramesOut, const ma_channel* pChannelMapOut, ma_uint32 channelsOut, const float* pFramesIn, const ma_channel* pChannelMapIn, ma_uint32 channelsIn, ma_uint64 frameCount, ma_channel_mix_mode mode, ma_mono_expansion_mode monoExpansionMode)
+{
+    ma_channel_conversion_path conversionPath = ma_channel_map_get_conversion_path(pChannelMapIn, channelsIn, pChannelMapOut, channelsOut, mode);
+
+    /* Optimized Path: Passthrough */
+    if (conversionPath == ma_channel_conversion_path_passthrough) {
+        ma_copy_pcm_frames(pFramesOut, pFramesIn, frameCount, ma_format_f32, channelsOut);
+        return;
+    }
+
+    /* Special Path: Mono Output. */
+    if (conversionPath == ma_channel_conversion_path_mono_out) {
+        ma_channel_map_apply_mono_out_f32(pFramesOut, pFramesIn, pChannelMapIn, channelsIn, frameCount);
+        return;
+    }
+
+    /* Special Path: Mono Input. */
+    if (conversionPath == ma_channel_conversion_path_mono_in) {
+        ma_channel_map_apply_mono_in_f32(pFramesOut, pChannelMapOut, channelsOut, pFramesIn, frameCount, monoExpansionMode);
+        return;
+    }
+
+    /* Getting here means we aren't running on an optimized conversion path. */
+    if (channelsOut <= MA_MAX_CHANNELS) {
+        ma_result result;
+
+        if (mode == ma_channel_mix_mode_simple) {
+            ma_channel shuffleTable[MA_MAX_CHANNELS];
+
+            result = ma_channel_map_build_shuffle_table(pChannelMapIn, channelsIn, pChannelMapOut, channelsOut, shuffleTable);
+            if (result != MA_SUCCESS) {
+                return;
+            }
+
+            result = ma_channel_map_apply_shuffle_table(pFramesOut, channelsOut, pFramesIn, channelsIn, frameCount, shuffleTable, ma_format_f32);
+            if (result != MA_SUCCESS) {
+                return;
+            }
+        } else {
+            ma_uint32 iFrame;
+            ma_uint32 iChannelOut;
+            ma_uint32 iChannelIn;
+            float weights[32][32];  /* Do not use MA_MAX_CHANNELS here! */
+
+            /*
+            If we have a small enough number of channels, pre-compute the weights. Otherwise we'll just need to
+            fall back to a slower path because otherwise we'll run out of stack space.
+            */
+            if (channelsIn <= ma_countof(weights) && channelsOut <= ma_countof(weights)) {
+                /* Pre-compute weights. */
+                for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                    ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+                    for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                        ma_channel channelIn = ma_channel_map_get_channel(pChannelMapIn, channelsIn, iChannelIn);
+                        weights[iChannelOut][iChannelIn] = ma_calculate_channel_position_rectangular_weight(channelOut, channelIn);
+                    }
+                }
+
+                iFrame = 0;
+
+                /* Experiment: Try an optimized unroll for some specific cases to see how it improves performance. RESULT: Good gains. */
+                if (channelsOut == 8) {
+                    /* Experiment 2: Expand the inner loop to see what kind of different it makes. RESULT: Small, but worthwhile gain. */
+                    if (channelsIn == 2) {
+                        for (; iFrame < frameCount; iFrame += 1) {
+                            float accumulation[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+                            accumulation[0] += pFramesIn[iFrame*2 + 0] * weights[0][0];
+                            accumulation[1] += pFramesIn[iFrame*2 + 0] * weights[1][0];
+                            accumulation[2] += pFramesIn[iFrame*2 + 0] * weights[2][0];
+                            accumulation[3] += pFramesIn[iFrame*2 + 0] * weights[3][0];
+                            accumulation[4] += pFramesIn[iFrame*2 + 0] * weights[4][0];
+                            accumulation[5] += pFramesIn[iFrame*2 + 0] * weights[5][0];
+                            accumulation[6] += pFramesIn[iFrame*2 + 0] * weights[6][0];
+                            accumulation[7] += pFramesIn[iFrame*2 + 0] * weights[7][0];
+
+                            accumulation[0] += pFramesIn[iFrame*2 + 1] * weights[0][1];
+                            accumulation[1] += pFramesIn[iFrame*2 + 1] * weights[1][1];
+                            accumulation[2] += pFramesIn[iFrame*2 + 1] * weights[2][1];
+                            accumulation[3] += pFramesIn[iFrame*2 + 1] * weights[3][1];
+                            accumulation[4] += pFramesIn[iFrame*2 + 1] * weights[4][1];
+                            accumulation[5] += pFramesIn[iFrame*2 + 1] * weights[5][1];
+                            accumulation[6] += pFramesIn[iFrame*2 + 1] * weights[6][1];
+                            accumulation[7] += pFramesIn[iFrame*2 + 1] * weights[7][1];
+
+                            pFramesOut[iFrame*8 + 0] = accumulation[0];
+                            pFramesOut[iFrame*8 + 1] = accumulation[1];
+                            pFramesOut[iFrame*8 + 2] = accumulation[2];
+                            pFramesOut[iFrame*8 + 3] = accumulation[3];
+                            pFramesOut[iFrame*8 + 4] = accumulation[4];
+                            pFramesOut[iFrame*8 + 5] = accumulation[5];
+                            pFramesOut[iFrame*8 + 6] = accumulation[6];
+                            pFramesOut[iFrame*8 + 7] = accumulation[7];
+                        }
+                    } else {
+                        /* When outputting to 8 channels, we can do everything in groups of two 4x SIMD operations. */
+                        for (; iFrame < frameCount; iFrame += 1) {
+                            float accumulation[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+                            for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                                accumulation[0] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[0][iChannelIn];
+                                accumulation[1] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[1][iChannelIn];
+                                accumulation[2] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[2][iChannelIn];
+                                accumulation[3] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[3][iChannelIn];
+                                accumulation[4] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[4][iChannelIn];
+                                accumulation[5] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[5][iChannelIn];
+                                accumulation[6] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[6][iChannelIn];
+                                accumulation[7] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[7][iChannelIn];
+                            }
+
+                            pFramesOut[iFrame*8 + 0] = accumulation[0];
+                            pFramesOut[iFrame*8 + 1] = accumulation[1];
+                            pFramesOut[iFrame*8 + 2] = accumulation[2];
+                            pFramesOut[iFrame*8 + 3] = accumulation[3];
+                            pFramesOut[iFrame*8 + 4] = accumulation[4];
+                            pFramesOut[iFrame*8 + 5] = accumulation[5];
+                            pFramesOut[iFrame*8 + 6] = accumulation[6];
+                            pFramesOut[iFrame*8 + 7] = accumulation[7];
+                        }
+                    }
+                } else if (channelsOut == 6) {
+                    /*
+                    When outputting to 6 channels we unfortunately don't have a nice multiple of 4 to do 4x SIMD operations. Instead we'll
+                    expand our weights and do two frames at a time.
+                    */
+                    for (; iFrame < frameCount; iFrame += 1) {
+                        float accumulation[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+                        for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                            accumulation[0] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[0][iChannelIn];
+                            accumulation[1] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[1][iChannelIn];
+                            accumulation[2] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[2][iChannelIn];
+                            accumulation[3] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[3][iChannelIn];
+                            accumulation[4] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[4][iChannelIn];
+                            accumulation[5] += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[5][iChannelIn];
+                        }
+
+                        pFramesOut[iFrame*6 + 0] = accumulation[0];
+                        pFramesOut[iFrame*6 + 1] = accumulation[1];
+                        pFramesOut[iFrame*6 + 2] = accumulation[2];
+                        pFramesOut[iFrame*6 + 3] = accumulation[3];
+                        pFramesOut[iFrame*6 + 4] = accumulation[4];
+                        pFramesOut[iFrame*6 + 5] = accumulation[5];
+                    }
+                }
+
+                /* Leftover frames. */
+                for (; iFrame < frameCount; iFrame += 1) {
+                    for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                        float accumulation = 0;
+
+                        for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                            accumulation += pFramesIn[iFrame*channelsIn + iChannelIn] * weights[iChannelOut][iChannelIn];
+                        }
+
+                        pFramesOut[iFrame*channelsOut + iChannelOut] = accumulation;
+                    }
+                }
+            } else {
+                /* Cannot pre-compute weights because not enough room in stack-allocated buffer. */
+                for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                    for (iChannelOut = 0; iChannelOut < channelsOut; iChannelOut += 1) {
+                        float accumulation = 0;
+                        ma_channel channelOut = ma_channel_map_get_channel(pChannelMapOut, channelsOut, iChannelOut);
+
+                        for (iChannelIn = 0; iChannelIn < channelsIn; iChannelIn += 1) {
+                            ma_channel channelIn = ma_channel_map_get_channel(pChannelMapIn, channelsIn, iChannelIn);
+                            accumulation += pFramesIn[iFrame*channelsIn + iChannelIn] * ma_calculate_channel_position_rectangular_weight(channelOut, channelIn);
+                        }
+
+                        pFramesOut[iFrame*channelsOut + iChannelOut] = accumulation;
+                    }
+                }
+            }
+        }
+    } else {
+        /* Fall back to silence. If you hit this, what are you doing with so many channels?! */
+        ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, channelsOut);
+    }
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t channelMapInOffset;
+    size_t channelMapOutOffset;
+    size_t shuffleTableOffset;
+    size_t weightsOffset;
+} ma_channel_converter_heap_layout;
+
+static ma_channel_conversion_path ma_channel_converter_config_get_conversion_path(const ma_channel_converter_config* pConfig)
+{
+    return ma_channel_map_get_conversion_path(pConfig->pChannelMapIn, pConfig->channelsIn, pConfig->pChannelMapOut, pConfig->channelsOut, pConfig->mixingMode);
+}
+
+static ma_result ma_channel_converter_get_heap_layout(const ma_channel_converter_config* pConfig, ma_channel_converter_heap_layout* pHeapLayout)
+{
+    ma_channel_conversion_path conversionPath;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channelsIn == 0 || pConfig->channelsOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (!ma_channel_map_is_valid(pConfig->pChannelMapIn, pConfig->channelsIn)) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (!ma_channel_map_is_valid(pConfig->pChannelMapOut, pConfig->channelsOut)) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Input channel map. Only need to allocate this if we have an input channel map (otherwise default channel map is assumed). */
+    pHeapLayout->channelMapInOffset = pHeapLayout->sizeInBytes;
+    if (pConfig->pChannelMapIn != NULL) {
+        pHeapLayout->sizeInBytes += sizeof(ma_channel) * pConfig->channelsIn;
+    }
+
+    /* Output channel map. Only need to allocate this if we have an output channel map (otherwise default channel map is assumed). */
+    pHeapLayout->channelMapOutOffset = pHeapLayout->sizeInBytes;
+    if (pConfig->pChannelMapOut != NULL) {
+        pHeapLayout->sizeInBytes += sizeof(ma_channel) * pConfig->channelsOut;
+    }
+
+    /* Alignment for the next section. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    /* Whether or not we use weights of a shuffle table depends on the channel map themselves and the algorithm we've chosen. */
+    conversionPath = ma_channel_converter_config_get_conversion_path(pConfig);
+
+    /* Shuffle table */
+    pHeapLayout->shuffleTableOffset = pHeapLayout->sizeInBytes;
+    if (conversionPath == ma_channel_conversion_path_shuffle) {
+        pHeapLayout->sizeInBytes += sizeof(ma_uint8) * pConfig->channelsOut;
+    }
+
+    /* Weights */
+    pHeapLayout->weightsOffset = pHeapLayout->sizeInBytes;
+    if (conversionPath == ma_channel_conversion_path_weights) {
+        pHeapLayout->sizeInBytes += sizeof(float*) * pConfig->channelsIn;
+        pHeapLayout->sizeInBytes += sizeof(float ) * pConfig->channelsIn * pConfig->channelsOut;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_channel_converter_get_heap_size(const ma_channel_converter_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_channel_converter_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_channel_converter_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_channel_converter_init_preallocated(const ma_channel_converter_config* pConfig, void* pHeap, ma_channel_converter* pConverter)
+{
+    ma_result result;
+    ma_channel_converter_heap_layout heapLayout;
+
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pConverter);
+
+    result = ma_channel_converter_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pConverter->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pConverter->_pHeap, heapLayout.sizeInBytes);
+
+    pConverter->format      = pConfig->format;
+    pConverter->channelsIn  = pConfig->channelsIn;
+    pConverter->channelsOut = pConfig->channelsOut;
+    pConverter->mixingMode  = pConfig->mixingMode;
+
+    if (pConfig->pChannelMapIn != NULL) {
+        pConverter->pChannelMapIn = (ma_channel*)ma_offset_ptr(pHeap, heapLayout.channelMapInOffset);
+        ma_channel_map_copy_or_default(pConverter->pChannelMapIn, pConfig->channelsIn, pConfig->pChannelMapIn, pConfig->channelsIn);
+    } else {
+        pConverter->pChannelMapIn = NULL;   /* Use default channel map. */
+    }
+
+    if (pConfig->pChannelMapOut != NULL) {
+        pConverter->pChannelMapOut = (ma_channel*)ma_offset_ptr(pHeap, heapLayout.channelMapOutOffset);
+        ma_channel_map_copy_or_default(pConverter->pChannelMapOut, pConfig->channelsOut, pConfig->pChannelMapOut, pConfig->channelsOut);
+    } else {
+        pConverter->pChannelMapOut = NULL;  /* Use default channel map. */
+    }
+
+    pConverter->conversionPath = ma_channel_converter_config_get_conversion_path(pConfig);
+
+    if (pConverter->conversionPath == ma_channel_conversion_path_shuffle) {
+        pConverter->pShuffleTable = (ma_uint8*)ma_offset_ptr(pHeap, heapLayout.shuffleTableOffset);
+        ma_channel_map_build_shuffle_table(pConverter->pChannelMapIn, pConverter->channelsIn, pConverter->pChannelMapOut, pConverter->channelsOut, pConverter->pShuffleTable);
+    }
+
+    if (pConverter->conversionPath == ma_channel_conversion_path_weights) {
+        ma_uint32 iChannelIn;
+        ma_uint32 iChannelOut;
+
+        if (pConverter->format == ma_format_f32) {
+            pConverter->weights.f32 = (float**   )ma_offset_ptr(pHeap, heapLayout.weightsOffset);
+            for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; iChannelIn += 1) {
+                pConverter->weights.f32[iChannelIn] = (float*)ma_offset_ptr(pHeap, heapLayout.weightsOffset + ((sizeof(float*) * pConverter->channelsIn) + (sizeof(float) * pConverter->channelsOut * iChannelIn)));
+            }
+        } else {
+            pConverter->weights.s16 = (ma_int32**)ma_offset_ptr(pHeap, heapLayout.weightsOffset);
+            for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; iChannelIn += 1) {
+                pConverter->weights.s16[iChannelIn] = (ma_int32*)ma_offset_ptr(pHeap, heapLayout.weightsOffset + ((sizeof(ma_int32*) * pConverter->channelsIn) + (sizeof(ma_int32) * pConverter->channelsOut * iChannelIn)));
+            }
+        }
+
+        /* Silence our weights by default. */
+        for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; iChannelIn += 1) {
+            for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; iChannelOut += 1) {
+                if (pConverter->format == ma_format_f32) {
+                    pConverter->weights.f32[iChannelIn][iChannelOut] = 0.0f;
+                } else {
+                    pConverter->weights.s16[iChannelIn][iChannelOut] = 0;
+                }
+            }
+        }
+
+        /*
+        We now need to fill out our weights table. This is determined by the mixing mode.
+        */
+
+        /* In all cases we need to make sure all channels that are present in both channel maps have a 1:1 mapping. */
+        for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+            ma_channel channelPosIn = ma_channel_map_get_channel(pConverter->pChannelMapIn, pConverter->channelsIn, iChannelIn);
+
+            for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                ma_channel channelPosOut = ma_channel_map_get_channel(pConverter->pChannelMapOut, pConverter->channelsOut, iChannelOut);
+
+                if (channelPosIn == channelPosOut) {
+                    float weight = 1;
+
+                    if (pConverter->format == ma_format_f32) {
+                        pConverter->weights.f32[iChannelIn][iChannelOut] = weight;
+                    } else {
+                        pConverter->weights.s16[iChannelIn][iChannelOut] = ma_channel_converter_float_to_fixed(weight);
+                    }
+                }
+            }
+        }
+
+        switch (pConverter->mixingMode)
+        {
+            case ma_channel_mix_mode_custom_weights:
+            {
+                if (pConfig->ppWeights == NULL) {
+                    return MA_INVALID_ARGS; /* Config specified a custom weights mixing mode, but no custom weights have been specified. */
+                }
+
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; iChannelIn += 1) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; iChannelOut += 1) {
+                        float weight = pConfig->ppWeights[iChannelIn][iChannelOut];
+
+                        if (pConverter->format == ma_format_f32) {
+                            pConverter->weights.f32[iChannelIn][iChannelOut] = weight;
+                        } else {
+                            pConverter->weights.s16[iChannelIn][iChannelOut] = ma_channel_converter_float_to_fixed(weight);
+                        }
+                    }
+                }
+            } break;
+
+            case ma_channel_mix_mode_simple:
+            {
+                /*
+                In simple mode, only set weights for channels that have exactly matching types, leave the rest at
+                zero. The 1:1 mappings have already been covered before this switch statement.
+                */
+            } break;
+
+            case ma_channel_mix_mode_rectangular:
+            default:
+            {
+                /* Unmapped input channels. */
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    ma_channel channelPosIn = ma_channel_map_get_channel(pConverter->pChannelMapIn, pConverter->channelsIn, iChannelIn);
+
+                    if (ma_is_spatial_channel_position(channelPosIn)) {
+                        if (!ma_channel_map_contains_channel_position(pConverter->channelsOut, pConverter->pChannelMapOut, channelPosIn)) {
+                            for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                                ma_channel channelPosOut = ma_channel_map_get_channel(pConverter->pChannelMapOut, pConverter->channelsOut, iChannelOut);
+
+                                if (ma_is_spatial_channel_position(channelPosOut)) {
+                                    float weight = 0;
+                                    if (pConverter->mixingMode == ma_channel_mix_mode_rectangular) {
+                                        weight = ma_calculate_channel_position_rectangular_weight(channelPosIn, channelPosOut);
+                                    }
+
+                                    /* Only apply the weight if we haven't already got some contribution from the respective channels. */
+                                    if (pConverter->format == ma_format_f32) {
+                                        if (pConverter->weights.f32[iChannelIn][iChannelOut] == 0) {
+                                            pConverter->weights.f32[iChannelIn][iChannelOut] = weight;
+                                        }
+                                    } else {
+                                        if (pConverter->weights.s16[iChannelIn][iChannelOut] == 0) {
+                                            pConverter->weights.s16[iChannelIn][iChannelOut] = ma_channel_converter_float_to_fixed(weight);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                /* Unmapped output channels. */
+                for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                    ma_channel channelPosOut = ma_channel_map_get_channel(pConverter->pChannelMapOut, pConverter->channelsOut, iChannelOut);
+
+                    if (ma_is_spatial_channel_position(channelPosOut)) {
+                        if (!ma_channel_map_contains_channel_position(pConverter->channelsIn, pConverter->pChannelMapIn, channelPosOut)) {
+                            for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                                ma_channel channelPosIn = ma_channel_map_get_channel(pConverter->pChannelMapIn, pConverter->channelsIn, iChannelIn);
+
+                                if (ma_is_spatial_channel_position(channelPosIn)) {
+                                    float weight = 0;
+                                    if (pConverter->mixingMode == ma_channel_mix_mode_rectangular) {
+                                        weight = ma_calculate_channel_position_rectangular_weight(channelPosIn, channelPosOut);
+                                    }
+
+                                    /* Only apply the weight if we haven't already got some contribution from the respective channels. */
+                                    if (pConverter->format == ma_format_f32) {
+                                        if (pConverter->weights.f32[iChannelIn][iChannelOut] == 0) {
+                                            pConverter->weights.f32[iChannelIn][iChannelOut] = weight;
+                                        }
+                                    } else {
+                                        if (pConverter->weights.s16[iChannelIn][iChannelOut] == 0) {
+                                            pConverter->weights.s16[iChannelIn][iChannelOut] = ma_channel_converter_float_to_fixed(weight);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                /* If LFE is in the output channel map but was not present in the input channel map, configure its weight now */
+                if (pConfig->calculateLFEFromSpatialChannels) {
+                    if (!ma_channel_map_contains_channel_position(pConverter->channelsIn, pConverter->pChannelMapIn, MA_CHANNEL_LFE)) {
+                        ma_uint32 spatialChannelCount = ma_channel_map_get_spatial_channel_count(pConverter->pChannelMapIn, pConverter->channelsIn);
+                        ma_uint32 iChannelOutLFE;
+
+                        if (spatialChannelCount > 0 && ma_channel_map_find_channel_position(pConverter->channelsOut, pConverter->pChannelMapOut, MA_CHANNEL_LFE, &iChannelOutLFE)) {
+                            const float weightForLFE = 1.0f / spatialChannelCount;
+                            for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                                const ma_channel channelPosIn = ma_channel_map_get_channel(pConverter->pChannelMapIn, pConverter->channelsIn, iChannelIn);
+                                if (ma_is_spatial_channel_position(channelPosIn)) {
+                                    if (pConverter->format == ma_format_f32) {
+                                        if (pConverter->weights.f32[iChannelIn][iChannelOutLFE] == 0) {
+                                            pConverter->weights.f32[iChannelIn][iChannelOutLFE] = weightForLFE;
+                                        }
+                                    } else {
+                                        if (pConverter->weights.s16[iChannelIn][iChannelOutLFE] == 0) {
+                                            pConverter->weights.s16[iChannelIn][iChannelOutLFE] = ma_channel_converter_float_to_fixed(weightForLFE);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            } break;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_channel_converter_init(const ma_channel_converter_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_channel_converter* pConverter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_channel_converter_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_channel_converter_init_preallocated(pConfig, pHeap, pConverter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pConverter->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_channel_converter_uninit(ma_channel_converter* pConverter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pConverter == NULL) {
+        return;
+    }
+
+    if (pConverter->_ownsHeap) {
+        ma_free(pConverter->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static ma_result ma_channel_converter_process_pcm_frames__passthrough(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+    MA_ASSERT(pFramesIn  != NULL);
+
+    ma_copy_memory_64(pFramesOut, pFramesIn, frameCount * ma_get_bytes_per_frame(pConverter->format, pConverter->channelsOut));
+    return MA_SUCCESS;
+}
+
+static ma_result ma_channel_converter_process_pcm_frames__shuffle(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+    MA_ASSERT(pFramesIn  != NULL);
+    MA_ASSERT(pConverter->channelsIn == pConverter->channelsOut);
+
+    return ma_channel_map_apply_shuffle_table(pFramesOut, pConverter->channelsOut, pFramesIn, pConverter->channelsIn, frameCount, pConverter->pShuffleTable, pConverter->format);
+}
+
+static ma_result ma_channel_converter_process_pcm_frames__mono_in(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+    MA_ASSERT(pFramesIn  != NULL);
+    MA_ASSERT(pConverter->channelsIn == 1);
+
+    switch (pConverter->format)
+    {
+        case ma_format_u8:
+        {
+            /* */ ma_uint8* pFramesOutU8 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInU8  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < pConverter->channelsOut; iChannel += 1) {
+                    pFramesOutU8[iFrame*pConverter->channelsOut + iChannel] = pFramesInU8[iFrame];
+                }
+            }
+        } break;
+
+        case ma_format_s16:
+        {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            if (pConverter->channelsOut == 2) {
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    pFramesOutS16[iFrame*2 + 0] = pFramesInS16[iFrame];
+                    pFramesOutS16[iFrame*2 + 1] = pFramesInS16[iFrame];
+                }
+            } else {
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    ma_uint32 iChannel;
+                    for (iChannel = 0; iChannel < pConverter->channelsOut; iChannel += 1) {
+                        pFramesOutS16[iFrame*pConverter->channelsOut + iChannel] = pFramesInS16[iFrame];
+                    }
+                }
+            }
+        } break;
+
+        case ma_format_s24:
+        {
+            /* */ ma_uint8* pFramesOutS24 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInS24  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < pConverter->channelsOut; iChannel += 1) {
+                    ma_uint64 iSampleOut = iFrame*pConverter->channelsOut + iChannel;
+                    ma_uint64 iSampleIn  = iFrame;
+                    pFramesOutS24[iSampleOut*3 + 0] = pFramesInS24[iSampleIn*3 + 0];
+                    pFramesOutS24[iSampleOut*3 + 1] = pFramesInS24[iSampleIn*3 + 1];
+                    pFramesOutS24[iSampleOut*3 + 2] = pFramesInS24[iSampleIn*3 + 2];
+                }
+            }
+        } break;
+
+        case ma_format_s32:
+        {
+            /* */ ma_int32* pFramesOutS32 = (      ma_int32*)pFramesOut;
+            const ma_int32* pFramesInS32  = (const ma_int32*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_uint32 iChannel;
+                for (iChannel = 0; iChannel < pConverter->channelsOut; iChannel += 1) {
+                    pFramesOutS32[iFrame*pConverter->channelsOut + iChannel] = pFramesInS32[iFrame];
+                }
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            if (pConverter->channelsOut == 2) {
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    pFramesOutF32[iFrame*2 + 0] = pFramesInF32[iFrame];
+                    pFramesOutF32[iFrame*2 + 1] = pFramesInF32[iFrame];
+                }
+            } else {
+                for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                    ma_uint32 iChannel;
+                    for (iChannel = 0; iChannel < pConverter->channelsOut; iChannel += 1) {
+                        pFramesOutF32[iFrame*pConverter->channelsOut + iChannel] = pFramesInF32[iFrame];
+                    }
+                }
+            }
+        } break;
+
+        default: return MA_INVALID_OPERATION;   /* Unknown format. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_channel_converter_process_pcm_frames__mono_out(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannel;
+
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+    MA_ASSERT(pFramesIn  != NULL);
+    MA_ASSERT(pConverter->channelsOut == 1);
+
+    switch (pConverter->format)
+    {
+        case ma_format_u8:
+        {
+            /* */ ma_uint8* pFramesOutU8 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInU8  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_int32 t = 0;
+                for (iChannel = 0; iChannel < pConverter->channelsIn; iChannel += 1) {
+                    t += ma_pcm_sample_u8_to_s16_no_scale(pFramesInU8[iFrame*pConverter->channelsIn + iChannel]);
+                }
+
+                pFramesOutU8[iFrame] = ma_clip_u8(t / pConverter->channelsOut);
+            }
+        } break;
+
+        case ma_format_s16:
+        {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_int32 t = 0;
+                for (iChannel = 0; iChannel < pConverter->channelsIn; iChannel += 1) {
+                    t += pFramesInS16[iFrame*pConverter->channelsIn + iChannel];
+                }
+
+                pFramesOutS16[iFrame] = (ma_int16)(t / pConverter->channelsIn);
+            }
+        } break;
+
+        case ma_format_s24:
+        {
+            /* */ ma_uint8* pFramesOutS24 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInS24  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_int64 t = 0;
+                for (iChannel = 0; iChannel < pConverter->channelsIn; iChannel += 1) {
+                    t += ma_pcm_sample_s24_to_s32_no_scale(&pFramesInS24[(iFrame*pConverter->channelsIn + iChannel)*3]);
+                }
+
+                ma_pcm_sample_s32_to_s24_no_scale(t / pConverter->channelsIn, &pFramesOutS24[iFrame*3]);
+            }
+        } break;
+
+        case ma_format_s32:
+        {
+            /* */ ma_int32* pFramesOutS32 = (      ma_int32*)pFramesOut;
+            const ma_int32* pFramesInS32  = (const ma_int32*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                ma_int64 t = 0;
+                for (iChannel = 0; iChannel < pConverter->channelsIn; iChannel += 1) {
+                    t += pFramesInS32[iFrame*pConverter->channelsIn + iChannel];
+                }
+
+                pFramesOutS32[iFrame] = (ma_int32)(t / pConverter->channelsIn);
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; ++iFrame) {
+                float t = 0;
+                for (iChannel = 0; iChannel < pConverter->channelsIn; iChannel += 1) {
+                    t += pFramesInF32[iFrame*pConverter->channelsIn + iChannel];
+                }
+
+                pFramesOutF32[iFrame] = t / pConverter->channelsIn;
+            }
+        } break;
+
+        default: return MA_INVALID_OPERATION;   /* Unknown format. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_channel_converter_process_pcm_frames__weights(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    ma_uint32 iFrame;
+    ma_uint32 iChannelIn;
+    ma_uint32 iChannelOut;
+
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+    MA_ASSERT(pFramesIn  != NULL);
+
+    /* This is the more complicated case. Each of the output channels is accumulated with 0 or more input channels. */
+
+    /* Clear. */
+    ma_zero_memory_64(pFramesOut, frameCount * ma_get_bytes_per_frame(pConverter->format, pConverter->channelsOut));
+
+    /* Accumulate. */
+    switch (pConverter->format)
+    {
+        case ma_format_u8:
+        {
+            /* */ ma_uint8* pFramesOutU8 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInU8  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                        ma_int16 u8_O = ma_pcm_sample_u8_to_s16_no_scale(pFramesOutU8[iFrame*pConverter->channelsOut + iChannelOut]);
+                        ma_int16 u8_I = ma_pcm_sample_u8_to_s16_no_scale(pFramesInU8 [iFrame*pConverter->channelsIn  + iChannelIn ]);
+                        ma_int32 s    = (ma_int32)ma_clamp(u8_O + ((u8_I * pConverter->weights.s16[iChannelIn][iChannelOut]) >> MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT), -128, 127);
+                        pFramesOutU8[iFrame*pConverter->channelsOut + iChannelOut] = ma_clip_u8((ma_int16)s);
+                    }
+                }
+            }
+        } break;
+
+        case ma_format_s16:
+        {
+            /* */ ma_int16* pFramesOutS16 = (      ma_int16*)pFramesOut;
+            const ma_int16* pFramesInS16  = (const ma_int16*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                        ma_int32 s = pFramesOutS16[iFrame*pConverter->channelsOut + iChannelOut];
+                        s += (pFramesInS16[iFrame*pConverter->channelsIn + iChannelIn] * pConverter->weights.s16[iChannelIn][iChannelOut]) >> MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT;
+
+                        pFramesOutS16[iFrame*pConverter->channelsOut + iChannelOut] = (ma_int16)ma_clamp(s, -32768, 32767);
+                    }
+                }
+            }
+        } break;
+
+        case ma_format_s24:
+        {
+            /* */ ma_uint8* pFramesOutS24 = (      ma_uint8*)pFramesOut;
+            const ma_uint8* pFramesInS24  = (const ma_uint8*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                        ma_int64 s24_O = ma_pcm_sample_s24_to_s32_no_scale(&pFramesOutS24[(iFrame*pConverter->channelsOut + iChannelOut)*3]);
+                        ma_int64 s24_I = ma_pcm_sample_s24_to_s32_no_scale(&pFramesInS24 [(iFrame*pConverter->channelsIn  + iChannelIn )*3]);
+                        ma_int64 s24   = (ma_int32)ma_clamp(s24_O + ((s24_I * pConverter->weights.s16[iChannelIn][iChannelOut]) >> MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT), -8388608, 8388607);
+                        ma_pcm_sample_s32_to_s24_no_scale(s24, &pFramesOutS24[(iFrame*pConverter->channelsOut + iChannelOut)*3]);
+                    }
+                }
+            }
+        } break;
+
+        case ma_format_s32:
+        {
+            /* */ ma_int32* pFramesOutS32 = (      ma_int32*)pFramesOut;
+            const ma_int32* pFramesInS32  = (const ma_int32*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                        ma_int64 s = pFramesOutS32[iFrame*pConverter->channelsOut + iChannelOut];
+                        s += ((ma_int64)pFramesInS32[iFrame*pConverter->channelsIn + iChannelIn] * pConverter->weights.s16[iChannelIn][iChannelOut]) >> MA_CHANNEL_CONVERTER_FIXED_POINT_SHIFT;
+
+                        pFramesOutS32[iFrame*pConverter->channelsOut + iChannelOut] = ma_clip_s32(s);
+                    }
+                }
+            }
+        } break;
+
+        case ma_format_f32:
+        {
+            /* */ float* pFramesOutF32 = (      float*)pFramesOut;
+            const float* pFramesInF32  = (const float*)pFramesIn;
+
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannelIn = 0; iChannelIn < pConverter->channelsIn; ++iChannelIn) {
+                    for (iChannelOut = 0; iChannelOut < pConverter->channelsOut; ++iChannelOut) {
+                        pFramesOutF32[iFrame*pConverter->channelsOut + iChannelOut] += pFramesInF32[iFrame*pConverter->channelsIn + iChannelIn] * pConverter->weights.f32[iChannelIn][iChannelOut];
+                    }
+                }
+            }
+        } break;
+
+        default: return MA_INVALID_OPERATION;   /* Unknown format. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_channel_converter_process_pcm_frames(ma_channel_converter* pConverter, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount)
+{
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFramesOut == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFramesIn == NULL) {
+        ma_zero_memory_64(pFramesOut, frameCount * ma_get_bytes_per_frame(pConverter->format, pConverter->channelsOut));
+        return MA_SUCCESS;
+    }
+
+    switch (pConverter->conversionPath)
+    {
+        case ma_channel_conversion_path_passthrough: return ma_channel_converter_process_pcm_frames__passthrough(pConverter, pFramesOut, pFramesIn, frameCount);
+        case ma_channel_conversion_path_mono_out:    return ma_channel_converter_process_pcm_frames__mono_out(pConverter, pFramesOut, pFramesIn, frameCount);
+        case ma_channel_conversion_path_mono_in:     return ma_channel_converter_process_pcm_frames__mono_in(pConverter, pFramesOut, pFramesIn, frameCount);
+        case ma_channel_conversion_path_shuffle:     return ma_channel_converter_process_pcm_frames__shuffle(pConverter, pFramesOut, pFramesIn, frameCount);
+        case ma_channel_conversion_path_weights:
+        default:
+        {
+            return ma_channel_converter_process_pcm_frames__weights(pConverter, pFramesOut, pFramesIn, frameCount);
+        }
+    }
+}
+
+MA_API ma_result ma_channel_converter_get_input_channel_map(const ma_channel_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pConverter == NULL || pChannelMap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_channel_map_copy_or_default(pChannelMap, channelMapCap, pConverter->pChannelMapIn, pConverter->channelsIn);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_channel_converter_get_output_channel_map(const ma_channel_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pConverter == NULL || pChannelMap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_channel_map_copy_or_default(pChannelMap, channelMapCap, pConverter->pChannelMapOut, pConverter->channelsOut);
+
+    return MA_SUCCESS;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Data Conversion
+
+**************************************************************************************************************************************************************/
+MA_API ma_data_converter_config ma_data_converter_config_init_default(void)
+{
+    ma_data_converter_config config;
+    MA_ZERO_OBJECT(&config);
+
+    config.ditherMode = ma_dither_mode_none;
+    config.resampling.algorithm = ma_resample_algorithm_linear;
+    config.allowDynamicSampleRate = MA_FALSE; /* Disable dynamic sample rates by default because dynamic rate adjustments should be quite rare and it allows an optimization for cases when the in and out sample rates are the same. */
+
+    /* Linear resampling defaults. */
+    config.resampling.linear.lpfOrder = 1;
+
+    return config;
+}
+
+MA_API ma_data_converter_config ma_data_converter_config_init(ma_format formatIn, ma_format formatOut, ma_uint32 channelsIn, ma_uint32 channelsOut, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    ma_data_converter_config config = ma_data_converter_config_init_default();
+    config.formatIn      = formatIn;
+    config.formatOut     = formatOut;
+    config.channelsIn    = channelsIn;
+    config.channelsOut   = channelsOut;
+    config.sampleRateIn  = sampleRateIn;
+    config.sampleRateOut = sampleRateOut;
+
+    return config;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t channelConverterOffset;
+    size_t resamplerOffset;
+} ma_data_converter_heap_layout;
+
+static ma_bool32 ma_data_converter_config_is_resampler_required(const ma_data_converter_config* pConfig)
+{
+    MA_ASSERT(pConfig != NULL);
+
+    return pConfig->allowDynamicSampleRate || pConfig->sampleRateIn != pConfig->sampleRateOut;
+}
+
+static ma_format ma_data_converter_config_get_mid_format(const ma_data_converter_config* pConfig)
+{
+    MA_ASSERT(pConfig != NULL);
+
+    /*
+    We want to avoid as much data conversion as possible. The channel converter and linear
+    resampler both support s16 and f32 natively. We need to decide on the format to use for this
+    stage. We call this the mid format because it's used in the middle stage of the conversion
+    pipeline. If the output format is either s16 or f32 we use that one. If that is not the case it
+    will do the same thing for the input format. If it's neither we just use f32. If we are using a
+    custom resampling backend, we can only guarantee that f32 will be supported so we'll be forced
+    to use that if resampling is required.
+    */
+    if (ma_data_converter_config_is_resampler_required(pConfig) && pConfig->resampling.algorithm != ma_resample_algorithm_linear) {
+        return ma_format_f32;  /* <-- Force f32 since that is the only one we can guarantee will be supported by the resampler. */
+    } else {
+        /*  */ if (pConfig->formatOut == ma_format_s16 || pConfig->formatOut == ma_format_f32) {
+            return pConfig->formatOut;
+        } else if (pConfig->formatIn  == ma_format_s16 || pConfig->formatIn  == ma_format_f32) {
+            return pConfig->formatIn;
+        } else {
+            return ma_format_f32;
+        }
+    }
+}
+
+static ma_channel_converter_config ma_channel_converter_config_init_from_data_converter_config(const ma_data_converter_config* pConfig)
+{
+    ma_channel_converter_config channelConverterConfig;
+
+    MA_ASSERT(pConfig != NULL);
+
+    channelConverterConfig = ma_channel_converter_config_init(ma_data_converter_config_get_mid_format(pConfig), pConfig->channelsIn, pConfig->pChannelMapIn, pConfig->channelsOut, pConfig->pChannelMapOut, pConfig->channelMixMode);
+    channelConverterConfig.ppWeights = pConfig->ppChannelWeights;
+    channelConverterConfig.calculateLFEFromSpatialChannels = pConfig->calculateLFEFromSpatialChannels;
+
+    return channelConverterConfig;
+}
+
+static ma_resampler_config ma_resampler_config_init_from_data_converter_config(const ma_data_converter_config* pConfig)
+{
+    ma_resampler_config resamplerConfig;
+    ma_uint32 resamplerChannels;
+
+    MA_ASSERT(pConfig != NULL);
+
+    /* The resampler is the most expensive part of the conversion process, so we need to do it at the stage where the channel count is at it's lowest. */
+    if (pConfig->channelsIn < pConfig->channelsOut) {
+        resamplerChannels = pConfig->channelsIn;
+    } else {
+        resamplerChannels = pConfig->channelsOut;
+    }
+
+    resamplerConfig = ma_resampler_config_init(ma_data_converter_config_get_mid_format(pConfig), resamplerChannels, pConfig->sampleRateIn, pConfig->sampleRateOut, pConfig->resampling.algorithm);
+    resamplerConfig.linear           = pConfig->resampling.linear;
+    resamplerConfig.pBackendVTable   = pConfig->resampling.pBackendVTable;
+    resamplerConfig.pBackendUserData = pConfig->resampling.pBackendUserData;
+
+    return resamplerConfig;
+}
+
+static ma_result ma_data_converter_get_heap_layout(const ma_data_converter_config* pConfig, ma_data_converter_heap_layout* pHeapLayout)
+{
+    ma_result result;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channelsIn == 0 || pConfig->channelsOut == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Channel converter. */
+    pHeapLayout->channelConverterOffset = pHeapLayout->sizeInBytes;
+    {
+        size_t heapSizeInBytes;
+        ma_channel_converter_config channelConverterConfig = ma_channel_converter_config_init_from_data_converter_config(pConfig);
+
+        result = ma_channel_converter_get_heap_size(&channelConverterConfig, &heapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += heapSizeInBytes;
+    }
+
+    /* Resampler. */
+    pHeapLayout->resamplerOffset = pHeapLayout->sizeInBytes;
+    if (ma_data_converter_config_is_resampler_required(pConfig)) {
+        size_t heapSizeInBytes;
+        ma_resampler_config resamplerConfig = ma_resampler_config_init_from_data_converter_config(pConfig);
+
+        result = ma_resampler_get_heap_size(&resamplerConfig, &heapSizeInBytes);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->sizeInBytes += heapSizeInBytes;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_get_heap_size(const ma_data_converter_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_data_converter_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_data_converter_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_init_preallocated(const ma_data_converter_config* pConfig, void* pHeap, ma_data_converter* pConverter)
+{
+    ma_result result;
+    ma_data_converter_heap_layout heapLayout;
+    ma_format midFormat;
+    ma_bool32 isResamplingRequired;
+
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pConverter);
+
+    result = ma_data_converter_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pConverter->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pConverter->formatIn      = pConfig->formatIn;
+    pConverter->formatOut     = pConfig->formatOut;
+    pConverter->channelsIn    = pConfig->channelsIn;
+    pConverter->channelsOut   = pConfig->channelsOut;
+    pConverter->sampleRateIn  = pConfig->sampleRateIn;
+    pConverter->sampleRateOut = pConfig->sampleRateOut;
+    pConverter->ditherMode    = pConfig->ditherMode;
+
+    /*
+    Determine if resampling is required. We need to do this so we can determine an appropriate
+    mid format to use. If resampling is required, the mid format must be ma_format_f32 since
+    that is the only one that is guaranteed to supported by custom resampling backends.
+    */
+    isResamplingRequired = ma_data_converter_config_is_resampler_required(pConfig);
+    midFormat = ma_data_converter_config_get_mid_format(pConfig);
+
+
+    /* Channel converter. We always initialize this, but we check if it configures itself as a passthrough to determine whether or not it's needed. */
+    {
+        ma_channel_converter_config channelConverterConfig = ma_channel_converter_config_init_from_data_converter_config(pConfig);
+
+        result = ma_channel_converter_init_preallocated(&channelConverterConfig, ma_offset_ptr(pHeap, heapLayout.channelConverterOffset), &pConverter->channelConverter);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        /* If the channel converter is not a passthrough we need to enable it. Otherwise we can skip it. */
+        if (pConverter->channelConverter.conversionPath != ma_channel_conversion_path_passthrough) {
+            pConverter->hasChannelConverter = MA_TRUE;
+        }
+    }
+
+
+    /* Resampler. */
+    if (isResamplingRequired) {
+        ma_resampler_config resamplerConfig = ma_resampler_config_init_from_data_converter_config(pConfig);
+
+        result = ma_resampler_init_preallocated(&resamplerConfig, ma_offset_ptr(pHeap, heapLayout.resamplerOffset), &pConverter->resampler);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pConverter->hasResampler = MA_TRUE;
+    }
+
+
+    /* We can simplify pre- and post-format conversion if we have neither channel conversion nor resampling. */
+    if (pConverter->hasChannelConverter == MA_FALSE && pConverter->hasResampler == MA_FALSE) {
+        /* We have neither channel conversion nor resampling so we'll only need one of pre- or post-format conversion, or none if the input and output formats are the same. */
+        if (pConverter->formatIn == pConverter->formatOut) {
+            /* The formats are the same so we can just pass through. */
+            pConverter->hasPreFormatConversion  = MA_FALSE;
+            pConverter->hasPostFormatConversion = MA_FALSE;
+        } else {
+            /* The formats are different so we need to do either pre- or post-format conversion. It doesn't matter which. */
+            pConverter->hasPreFormatConversion  = MA_FALSE;
+            pConverter->hasPostFormatConversion = MA_TRUE;
+        }
+    } else {
+        /* We have a channel converter and/or resampler so we'll need channel conversion based on the mid format. */
+        if (pConverter->formatIn != midFormat) {
+            pConverter->hasPreFormatConversion  = MA_TRUE;
+        }
+        if (pConverter->formatOut != midFormat) {
+            pConverter->hasPostFormatConversion = MA_TRUE;
+        }
+    }
+
+    /* We can enable passthrough optimizations if applicable. Note that we'll only be able to do this if the sample rate is static. */
+    if (pConverter->hasPreFormatConversion  == MA_FALSE &&
+        pConverter->hasPostFormatConversion == MA_FALSE &&
+        pConverter->hasChannelConverter     == MA_FALSE &&
+        pConverter->hasResampler            == MA_FALSE) {
+        pConverter->isPassthrough = MA_TRUE;
+    }
+
+
+    /* We now need to determine our execution path. */
+    if (pConverter->isPassthrough) {
+        pConverter->executionPath = ma_data_converter_execution_path_passthrough;
+    } else {
+        if (pConverter->channelsIn < pConverter->channelsOut) {
+            /* Do resampling first, if necessary. */
+            MA_ASSERT(pConverter->hasChannelConverter == MA_TRUE);
+
+            if (pConverter->hasResampler) {
+                pConverter->executionPath = ma_data_converter_execution_path_resample_first;
+            } else {
+                pConverter->executionPath = ma_data_converter_execution_path_channels_only;
+            }
+        } else {
+            /* Do channel conversion first, if necessary. */
+            if (pConverter->hasChannelConverter) {
+                if (pConverter->hasResampler) {
+                    pConverter->executionPath = ma_data_converter_execution_path_channels_first;
+                } else {
+                    pConverter->executionPath = ma_data_converter_execution_path_channels_only;
+                }
+            } else {
+                /* Channel routing not required. */
+                if (pConverter->hasResampler) {
+                    pConverter->executionPath = ma_data_converter_execution_path_resample_only;
+                } else {
+                    pConverter->executionPath = ma_data_converter_execution_path_format_only;
+                }
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_init(const ma_data_converter_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_converter* pConverter)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_data_converter_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_data_converter_init_preallocated(pConfig, pHeap, pConverter);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pConverter->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_data_converter_uninit(ma_data_converter* pConverter, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pConverter == NULL) {
+        return;
+    }
+
+    if (pConverter->hasResampler) {
+        ma_resampler_uninit(&pConverter->resampler, pAllocationCallbacks);
+    }
+
+    ma_channel_converter_uninit(&pConverter->channelConverter, pAllocationCallbacks);
+
+    if (pConverter->_ownsHeap) {
+        ma_free(pConverter->_pHeap, pAllocationCallbacks);
+    }
+}
+
+static ma_result ma_data_converter_process_pcm_frames__passthrough(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 frameCount;
+
+    MA_ASSERT(pConverter != NULL);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    frameCount = ma_min(frameCountIn, frameCountOut);
+
+    if (pFramesOut != NULL) {
+        if (pFramesIn != NULL) {
+            ma_copy_memory_64(pFramesOut, pFramesIn, frameCount * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        } else {
+            ma_zero_memory_64(pFramesOut,            frameCount * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = frameCount;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_data_converter_process_pcm_frames__format_only(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 frameCount;
+
+    MA_ASSERT(pConverter != NULL);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    frameCount = ma_min(frameCountIn, frameCountOut);
+
+    if (pFramesOut != NULL) {
+        if (pFramesIn != NULL) {
+            ma_convert_pcm_frames_format(pFramesOut, pConverter->formatOut, pFramesIn, pConverter->formatIn, frameCount, pConverter->channelsIn, pConverter->ditherMode);
+        } else {
+            ma_zero_memory_64(pFramesOut, frameCount * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = frameCount;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_data_converter_process_pcm_frames__resample_with_format_conversion(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+
+    MA_ASSERT(pConverter != NULL);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    while (framesProcessedOut < frameCountOut) {
+        ma_uint8 pTempBufferOut[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+        const ma_uint32 tempBufferOutCap = sizeof(pTempBufferOut) / ma_get_bytes_per_frame(pConverter->resampler.format, pConverter->resampler.channels);
+        const void* pFramesInThisIteration;
+        /* */ void* pFramesOutThisIteration;
+        ma_uint64 frameCountInThisIteration;
+        ma_uint64 frameCountOutThisIteration;
+
+        if (pFramesIn != NULL) {
+            pFramesInThisIteration = ma_offset_ptr(pFramesIn, framesProcessedIn * ma_get_bytes_per_frame(pConverter->formatIn, pConverter->channelsIn));
+        } else {
+            pFramesInThisIteration = NULL;
+        }
+
+        if (pFramesOut != NULL) {
+            pFramesOutThisIteration = ma_offset_ptr(pFramesOut, framesProcessedOut * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        } else {
+            pFramesOutThisIteration = NULL;
+        }
+
+        /* Do a pre format conversion if necessary. */
+        if (pConverter->hasPreFormatConversion) {
+            ma_uint8 pTempBufferIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+            const ma_uint32 tempBufferInCap = sizeof(pTempBufferIn) / ma_get_bytes_per_frame(pConverter->resampler.format, pConverter->resampler.channels);
+
+            frameCountInThisIteration  = (frameCountIn - framesProcessedIn);
+            if (frameCountInThisIteration > tempBufferInCap) {
+                frameCountInThisIteration = tempBufferInCap;
+            }
+
+            if (pConverter->hasPostFormatConversion) {
+               if (frameCountInThisIteration > tempBufferOutCap) {
+                   frameCountInThisIteration = tempBufferOutCap;
+               }
+            }
+
+            if (pFramesInThisIteration != NULL) {
+                ma_convert_pcm_frames_format(pTempBufferIn, pConverter->resampler.format, pFramesInThisIteration, pConverter->formatIn, frameCountInThisIteration, pConverter->channelsIn, pConverter->ditherMode);
+            } else {
+                MA_ZERO_MEMORY(pTempBufferIn, sizeof(pTempBufferIn));
+            }
+
+            frameCountOutThisIteration = (frameCountOut - framesProcessedOut);
+
+            if (pConverter->hasPostFormatConversion) {
+                /* Both input and output conversion required. Output to the temp buffer. */
+                if (frameCountOutThisIteration > tempBufferOutCap) {
+                    frameCountOutThisIteration = tempBufferOutCap;
+                }
+
+                result = ma_resampler_process_pcm_frames(&pConverter->resampler, pTempBufferIn, &frameCountInThisIteration, pTempBufferOut, &frameCountOutThisIteration);
+            } else {
+                /* Only pre-format required. Output straight to the output buffer. */
+                result = ma_resampler_process_pcm_frames(&pConverter->resampler, pTempBufferIn, &frameCountInThisIteration, pFramesOutThisIteration, &frameCountOutThisIteration);
+            }
+
+            if (result != MA_SUCCESS) {
+                break;
+            }
+        } else {
+            /* No pre-format required. Just read straight from the input buffer. */
+            MA_ASSERT(pConverter->hasPostFormatConversion == MA_TRUE);
+
+            frameCountInThisIteration  = (frameCountIn  - framesProcessedIn);
+            frameCountOutThisIteration = (frameCountOut - framesProcessedOut);
+            if (frameCountOutThisIteration > tempBufferOutCap) {
+                frameCountOutThisIteration = tempBufferOutCap;
+            }
+
+            result = ma_resampler_process_pcm_frames(&pConverter->resampler, pFramesInThisIteration, &frameCountInThisIteration, pTempBufferOut, &frameCountOutThisIteration);
+            if (result != MA_SUCCESS) {
+                break;
+            }
+        }
+
+        /* If we are doing a post format conversion we need to do that now. */
+        if (pConverter->hasPostFormatConversion) {
+            if (pFramesOutThisIteration != NULL) {
+                ma_convert_pcm_frames_format(pFramesOutThisIteration, pConverter->formatOut, pTempBufferOut, pConverter->resampler.format, frameCountOutThisIteration, pConverter->resampler.channels, pConverter->ditherMode);
+            }
+        }
+
+        framesProcessedIn  += frameCountInThisIteration;
+        framesProcessedOut += frameCountOutThisIteration;
+
+        MA_ASSERT(framesProcessedIn  <= frameCountIn);
+        MA_ASSERT(framesProcessedOut <= frameCountOut);
+
+        if (frameCountOutThisIteration == 0) {
+            break;  /* Consumed all of our input data. */
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = framesProcessedIn;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = framesProcessedOut;
+    }
+
+    return result;
+}
+
+static ma_result ma_data_converter_process_pcm_frames__resample_only(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    MA_ASSERT(pConverter != NULL);
+
+    if (pConverter->hasPreFormatConversion == MA_FALSE && pConverter->hasPostFormatConversion == MA_FALSE) {
+        /* Neither pre- nor post-format required. This is simple case where only resampling is required. */
+        return ma_resampler_process_pcm_frames(&pConverter->resampler, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    } else {
+        /* Format conversion required. */
+        return ma_data_converter_process_pcm_frames__resample_with_format_conversion(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+    }
+}
+
+static ma_result ma_data_converter_process_pcm_frames__channels_only(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_result result;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 frameCount;
+
+    MA_ASSERT(pConverter != NULL);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    frameCount = ma_min(frameCountIn, frameCountOut);
+
+    if (pConverter->hasPreFormatConversion == MA_FALSE && pConverter->hasPostFormatConversion == MA_FALSE) {
+        /* No format conversion required. */
+        result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pFramesOut, pFramesIn, frameCount);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    } else {
+        /* Format conversion required. */
+        ma_uint64 framesProcessed = 0;
+
+        while (framesProcessed < frameCount) {
+            ma_uint8 pTempBufferOut[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+            const ma_uint32 tempBufferOutCap = sizeof(pTempBufferOut) / ma_get_bytes_per_frame(pConverter->channelConverter.format, pConverter->channelConverter.channelsOut);
+            const void* pFramesInThisIteration;
+            /* */ void* pFramesOutThisIteration;
+            ma_uint64 frameCountThisIteration;
+
+            if (pFramesIn != NULL) {
+                pFramesInThisIteration = ma_offset_ptr(pFramesIn, framesProcessed * ma_get_bytes_per_frame(pConverter->formatIn, pConverter->channelsIn));
+            } else {
+                pFramesInThisIteration = NULL;
+            }
+
+            if (pFramesOut != NULL) {
+                pFramesOutThisIteration = ma_offset_ptr(pFramesOut, framesProcessed * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+            } else {
+                pFramesOutThisIteration = NULL;
+            }
+
+            /* Do a pre format conversion if necessary. */
+            if (pConverter->hasPreFormatConversion) {
+                ma_uint8 pTempBufferIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+                const ma_uint32 tempBufferInCap = sizeof(pTempBufferIn) / ma_get_bytes_per_frame(pConverter->channelConverter.format, pConverter->channelConverter.channelsIn);
+
+                frameCountThisIteration = (frameCount - framesProcessed);
+                if (frameCountThisIteration > tempBufferInCap) {
+                    frameCountThisIteration = tempBufferInCap;
+                }
+
+                if (pConverter->hasPostFormatConversion) {
+                    if (frameCountThisIteration > tempBufferOutCap) {
+                        frameCountThisIteration = tempBufferOutCap;
+                    }
+                }
+
+                if (pFramesInThisIteration != NULL) {
+                    ma_convert_pcm_frames_format(pTempBufferIn, pConverter->channelConverter.format, pFramesInThisIteration, pConverter->formatIn, frameCountThisIteration, pConverter->channelsIn, pConverter->ditherMode);
+                } else {
+                    MA_ZERO_MEMORY(pTempBufferIn, sizeof(pTempBufferIn));
+                }
+
+                if (pConverter->hasPostFormatConversion) {
+                    /* Both input and output conversion required. Output to the temp buffer. */
+                    result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pTempBufferOut, pTempBufferIn, frameCountThisIteration);
+                } else {
+                    /* Only pre-format required. Output straight to the output buffer. */
+                    result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pFramesOutThisIteration, pTempBufferIn, frameCountThisIteration);
+                }
+
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+            } else {
+                /* No pre-format required. Just read straight from the input buffer. */
+                MA_ASSERT(pConverter->hasPostFormatConversion == MA_TRUE);
+
+                frameCountThisIteration = (frameCount - framesProcessed);
+                if (frameCountThisIteration > tempBufferOutCap) {
+                    frameCountThisIteration = tempBufferOutCap;
+                }
+
+                result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pTempBufferOut, pFramesInThisIteration, frameCountThisIteration);
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+            }
+
+            /* If we are doing a post format conversion we need to do that now. */
+            if (pConverter->hasPostFormatConversion) {
+                if (pFramesOutThisIteration != NULL) {
+                    ma_convert_pcm_frames_format(pFramesOutThisIteration, pConverter->formatOut, pTempBufferOut, pConverter->channelConverter.format, frameCountThisIteration, pConverter->channelConverter.channelsOut, pConverter->ditherMode);
+                }
+            }
+
+            framesProcessed += frameCountThisIteration;
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = frameCount;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_data_converter_process_pcm_frames__resample_first(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_result result;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+    ma_uint8  pTempBufferIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];   /* In resampler format. */
+    ma_uint64 tempBufferInCap;
+    ma_uint8  pTempBufferMid[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In resampler format, channel converter input format. */
+    ma_uint64 tempBufferMidCap;
+    ma_uint8  pTempBufferOut[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In channel converter output format. */
+    ma_uint64 tempBufferOutCap;
+
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pConverter->resampler.format   == pConverter->channelConverter.format);
+    MA_ASSERT(pConverter->resampler.channels == pConverter->channelConverter.channelsIn);
+    MA_ASSERT(pConverter->resampler.channels <  pConverter->channelConverter.channelsOut);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    tempBufferInCap  = sizeof(pTempBufferIn)  / ma_get_bytes_per_frame(pConverter->resampler.format, pConverter->resampler.channels);
+    tempBufferMidCap = sizeof(pTempBufferIn)  / ma_get_bytes_per_frame(pConverter->resampler.format, pConverter->resampler.channels);
+    tempBufferOutCap = sizeof(pTempBufferOut) / ma_get_bytes_per_frame(pConverter->channelConverter.format, pConverter->channelConverter.channelsOut);
+
+    while (framesProcessedOut < frameCountOut) {
+        ma_uint64 frameCountInThisIteration;
+        ma_uint64 frameCountOutThisIteration;
+        const void* pRunningFramesIn = NULL;
+        void* pRunningFramesOut = NULL;
+        const void* pResampleBufferIn;
+        void* pChannelsBufferOut;
+
+        if (pFramesIn != NULL) {
+            pRunningFramesIn  = ma_offset_ptr(pFramesIn,  framesProcessedIn  * ma_get_bytes_per_frame(pConverter->formatIn, pConverter->channelsIn));
+        }
+        if (pFramesOut != NULL) {
+            pRunningFramesOut = ma_offset_ptr(pFramesOut, framesProcessedOut * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        }
+
+        /* Run input data through the resampler and output it to the temporary buffer. */
+        frameCountInThisIteration = (frameCountIn - framesProcessedIn);
+
+        if (pConverter->hasPreFormatConversion) {
+            if (frameCountInThisIteration > tempBufferInCap) {
+                frameCountInThisIteration = tempBufferInCap;
+            }
+        }
+
+        frameCountOutThisIteration = (frameCountOut - framesProcessedOut);
+        if (frameCountOutThisIteration > tempBufferMidCap) {
+            frameCountOutThisIteration = tempBufferMidCap;
+        }
+
+        /* We can't read more frames than can fit in the output buffer. */
+        if (pConverter->hasPostFormatConversion) {
+            if (frameCountOutThisIteration > tempBufferOutCap) {
+                frameCountOutThisIteration = tempBufferOutCap;
+            }
+        }
+
+        /* We need to ensure we don't try to process too many input frames that we run out of room in the output buffer. If this happens we'll end up glitching. */
+
+        /*
+        We need to try to predict how many input frames will be required for the resampler. If the
+        resampler can tell us, we'll use that. Otherwise we'll need to make a best guess. The further
+        off we are from this, the more wasted format conversions we'll end up doing.
+        */
+        #if 1
+        {
+            ma_uint64 requiredInputFrameCount;
+
+            result = ma_resampler_get_required_input_frame_count(&pConverter->resampler, frameCountOutThisIteration, &requiredInputFrameCount);
+            if (result != MA_SUCCESS) {
+                /* Fall back to a best guess. */
+                requiredInputFrameCount = (frameCountOutThisIteration * pConverter->resampler.sampleRateIn) / pConverter->resampler.sampleRateOut;
+            }
+
+            if (frameCountInThisIteration > requiredInputFrameCount) {
+                frameCountInThisIteration = requiredInputFrameCount;
+            }
+        }
+        #endif
+
+        if (pConverter->hasPreFormatConversion) {
+            if (pFramesIn != NULL) {
+                ma_convert_pcm_frames_format(pTempBufferIn, pConverter->resampler.format, pRunningFramesIn, pConverter->formatIn, frameCountInThisIteration, pConverter->channelsIn, pConverter->ditherMode);
+                pResampleBufferIn = pTempBufferIn;
+            } else {
+                pResampleBufferIn = NULL;
+            }
+        } else {
+            pResampleBufferIn = pRunningFramesIn;
+        }
+
+        result = ma_resampler_process_pcm_frames(&pConverter->resampler, pResampleBufferIn, &frameCountInThisIteration, pTempBufferMid, &frameCountOutThisIteration);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+
+        /*
+        The input data has been resampled so now we need to run it through the channel converter. The input data is always contained in pTempBufferMid. We only need to do
+        this part if we have an output buffer.
+        */
+        if (pFramesOut != NULL) {
+            if (pConverter->hasPostFormatConversion) {
+                pChannelsBufferOut = pTempBufferOut;
+            } else {
+                pChannelsBufferOut = pRunningFramesOut;
+            }
+
+            result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pChannelsBufferOut, pTempBufferMid, frameCountOutThisIteration);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+
+            /* Finally we do post format conversion. */
+            if (pConverter->hasPostFormatConversion) {
+                ma_convert_pcm_frames_format(pRunningFramesOut, pConverter->formatOut, pChannelsBufferOut, pConverter->channelConverter.format, frameCountOutThisIteration, pConverter->channelConverter.channelsOut, pConverter->ditherMode);
+            }
+        }
+
+
+        framesProcessedIn  += frameCountInThisIteration;
+        framesProcessedOut += frameCountOutThisIteration;
+
+        MA_ASSERT(framesProcessedIn  <= frameCountIn);
+        MA_ASSERT(framesProcessedOut <= frameCountOut);
+
+        if (frameCountOutThisIteration == 0) {
+            break;  /* Consumed all of our input data. */
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = framesProcessedIn;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = framesProcessedOut;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_data_converter_process_pcm_frames__channels_first(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    ma_result result;
+    ma_uint64 frameCountIn;
+    ma_uint64 frameCountOut;
+    ma_uint64 framesProcessedIn;
+    ma_uint64 framesProcessedOut;
+    ma_uint8  pTempBufferIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];   /* In resampler format. */
+    ma_uint64 tempBufferInCap;
+    ma_uint8  pTempBufferMid[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In resampler format, channel converter input format. */
+    ma_uint64 tempBufferMidCap;
+    ma_uint8  pTempBufferOut[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In channel converter output format. */
+    ma_uint64 tempBufferOutCap;
+
+    MA_ASSERT(pConverter != NULL);
+    MA_ASSERT(pConverter->resampler.format   == pConverter->channelConverter.format);
+    MA_ASSERT(pConverter->resampler.channels == pConverter->channelConverter.channelsOut);
+    MA_ASSERT(pConverter->resampler.channels <= pConverter->channelConverter.channelsIn);
+
+    frameCountIn = 0;
+    if (pFrameCountIn != NULL) {
+        frameCountIn = *pFrameCountIn;
+    }
+
+    frameCountOut = 0;
+    if (pFrameCountOut != NULL) {
+        frameCountOut = *pFrameCountOut;
+    }
+
+    framesProcessedIn  = 0;
+    framesProcessedOut = 0;
+
+    tempBufferInCap  = sizeof(pTempBufferIn)  / ma_get_bytes_per_frame(pConverter->channelConverter.format, pConverter->channelConverter.channelsIn);
+    tempBufferMidCap = sizeof(pTempBufferIn)  / ma_get_bytes_per_frame(pConverter->channelConverter.format, pConverter->channelConverter.channelsOut);
+    tempBufferOutCap = sizeof(pTempBufferOut) / ma_get_bytes_per_frame(pConverter->resampler.format, pConverter->resampler.channels);
+
+    while (framesProcessedOut < frameCountOut) {
+        ma_uint64 frameCountInThisIteration;
+        ma_uint64 frameCountOutThisIteration;
+        const void* pRunningFramesIn = NULL;
+        void* pRunningFramesOut = NULL;
+        const void* pChannelsBufferIn;
+        void* pResampleBufferOut;
+
+        if (pFramesIn != NULL) {
+            pRunningFramesIn  = ma_offset_ptr(pFramesIn,  framesProcessedIn  * ma_get_bytes_per_frame(pConverter->formatIn, pConverter->channelsIn));
+        }
+        if (pFramesOut != NULL) {
+            pRunningFramesOut = ma_offset_ptr(pFramesOut, framesProcessedOut * ma_get_bytes_per_frame(pConverter->formatOut, pConverter->channelsOut));
+        }
+
+        /*
+        Before doing any processing we need to determine how many frames we should try processing
+        this iteration, for both input and output. The resampler requires us to perform format and
+        channel conversion before passing any data into it. If we get our input count wrong, we'll
+        end up peforming redundant pre-processing. This isn't the end of the world, but it does
+        result in some inefficiencies proportionate to how far our estimates are off.
+
+        If the resampler has a means to calculate exactly how much we'll need, we'll use that.
+        Otherwise we'll make a best guess. In order to do this, we'll need to calculate the output
+        frame count first.
+        */
+        frameCountOutThisIteration = (frameCountOut - framesProcessedOut);
+        if (frameCountOutThisIteration > tempBufferMidCap) {
+            frameCountOutThisIteration = tempBufferMidCap;
+        }
+
+        if (pConverter->hasPostFormatConversion) {
+            if (frameCountOutThisIteration > tempBufferOutCap) {
+                frameCountOutThisIteration = tempBufferOutCap;
+            }
+        }
+
+        /* Now that we have the output frame count we can determine the input frame count. */
+        frameCountInThisIteration = (frameCountIn - framesProcessedIn);
+        if (pConverter->hasPreFormatConversion) {
+            if (frameCountInThisIteration > tempBufferInCap) {
+                frameCountInThisIteration = tempBufferInCap;
+            }
+        }
+
+        if (frameCountInThisIteration > tempBufferMidCap) {
+            frameCountInThisIteration = tempBufferMidCap;
+        }
+
+        #if 1
+        {
+            ma_uint64 requiredInputFrameCount;
+
+            result = ma_resampler_get_required_input_frame_count(&pConverter->resampler, frameCountOutThisIteration, &requiredInputFrameCount);
+            if (result != MA_SUCCESS) {
+                /* Fall back to a best guess. */
+                requiredInputFrameCount = (frameCountOutThisIteration * pConverter->resampler.sampleRateIn) / pConverter->resampler.sampleRateOut;
+            }
+
+            if (frameCountInThisIteration > requiredInputFrameCount) {
+                frameCountInThisIteration = requiredInputFrameCount;
+            }
+        }
+        #endif
+
+
+        /* Pre format conversion. */
+        if (pConverter->hasPreFormatConversion) {
+            if (pRunningFramesIn != NULL) {
+                ma_convert_pcm_frames_format(pTempBufferIn, pConverter->channelConverter.format, pRunningFramesIn, pConverter->formatIn, frameCountInThisIteration, pConverter->channelsIn, pConverter->ditherMode);
+                pChannelsBufferIn = pTempBufferIn;
+            } else {
+                pChannelsBufferIn = NULL;
+            }
+        } else {
+            pChannelsBufferIn = pRunningFramesIn;
+        }
+
+
+        /* Channel conversion. */
+        result = ma_channel_converter_process_pcm_frames(&pConverter->channelConverter, pTempBufferMid, pChannelsBufferIn, frameCountInThisIteration);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+
+        /* Resampling. */
+        if (pConverter->hasPostFormatConversion) {
+            pResampleBufferOut = pTempBufferOut;
+        } else {
+            pResampleBufferOut = pRunningFramesOut;
+        }
+
+        result = ma_resampler_process_pcm_frames(&pConverter->resampler, pTempBufferMid, &frameCountInThisIteration, pResampleBufferOut, &frameCountOutThisIteration);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+
+        /* Post format conversion. */
+        if (pConverter->hasPostFormatConversion) {
+            if (pRunningFramesOut != NULL) {
+                ma_convert_pcm_frames_format(pRunningFramesOut, pConverter->formatOut, pResampleBufferOut, pConverter->resampler.format, frameCountOutThisIteration, pConverter->channelsOut, pConverter->ditherMode);
+            }
+        }
+
+
+        framesProcessedIn  += frameCountInThisIteration;
+        framesProcessedOut += frameCountOutThisIteration;
+
+        MA_ASSERT(framesProcessedIn  <= frameCountIn);
+        MA_ASSERT(framesProcessedOut <= frameCountOut);
+
+        if (frameCountOutThisIteration == 0) {
+            break;  /* Consumed all of our input data. */
+        }
+    }
+
+    if (pFrameCountIn != NULL) {
+        *pFrameCountIn = framesProcessedIn;
+    }
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = framesProcessedOut;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_process_pcm_frames(ma_data_converter* pConverter, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
+{
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    switch (pConverter->executionPath)
+    {
+        case ma_data_converter_execution_path_passthrough:    return ma_data_converter_process_pcm_frames__passthrough(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        case ma_data_converter_execution_path_format_only:    return ma_data_converter_process_pcm_frames__format_only(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        case ma_data_converter_execution_path_channels_only:  return ma_data_converter_process_pcm_frames__channels_only(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        case ma_data_converter_execution_path_resample_only:  return ma_data_converter_process_pcm_frames__resample_only(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        case ma_data_converter_execution_path_resample_first: return ma_data_converter_process_pcm_frames__resample_first(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        case ma_data_converter_execution_path_channels_first: return ma_data_converter_process_pcm_frames__channels_first(pConverter, pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
+        default: return MA_INVALID_OPERATION;   /* Should never hit this. */
+    }
+}
+
+MA_API ma_result ma_data_converter_set_rate(ma_data_converter* pConverter, ma_uint32 sampleRateIn, ma_uint32 sampleRateOut)
+{
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasResampler == MA_FALSE) {
+        return MA_INVALID_OPERATION;    /* Dynamic resampling not enabled. */
+    }
+
+    return ma_resampler_set_rate(&pConverter->resampler, sampleRateIn, sampleRateOut);
+}
+
+MA_API ma_result ma_data_converter_set_rate_ratio(ma_data_converter* pConverter, float ratioInOut)
+{
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasResampler == MA_FALSE) {
+        return MA_INVALID_OPERATION;    /* Dynamic resampling not enabled. */
+    }
+
+    return ma_resampler_set_rate_ratio(&pConverter->resampler, ratioInOut);
+}
+
+MA_API ma_uint64 ma_data_converter_get_input_latency(const ma_data_converter* pConverter)
+{
+    if (pConverter == NULL) {
+        return 0;
+    }
+
+    if (pConverter->hasResampler) {
+        return ma_resampler_get_input_latency(&pConverter->resampler);
+    }
+
+    return 0;   /* No latency without a resampler. */
+}
+
+MA_API ma_uint64 ma_data_converter_get_output_latency(const ma_data_converter* pConverter)
+{
+    if (pConverter == NULL) {
+        return 0;
+    }
+
+    if (pConverter->hasResampler) {
+        return ma_resampler_get_output_latency(&pConverter->resampler);
+    }
+
+    return 0;   /* No latency without a resampler. */
+}
+
+MA_API ma_result ma_data_converter_get_required_input_frame_count(const ma_data_converter* pConverter, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount)
+{
+    if (pInputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pInputFrameCount = 0;
+
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasResampler) {
+        return ma_resampler_get_required_input_frame_count(&pConverter->resampler, outputFrameCount, pInputFrameCount);
+    } else {
+        *pInputFrameCount = outputFrameCount;   /* 1:1 */
+        return MA_SUCCESS;
+    }
+}
+
+MA_API ma_result ma_data_converter_get_expected_output_frame_count(const ma_data_converter* pConverter, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount)
+{
+    if (pOutputFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pOutputFrameCount = 0;
+
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasResampler) {
+        return ma_resampler_get_expected_output_frame_count(&pConverter->resampler, inputFrameCount, pOutputFrameCount);
+    } else {
+        *pOutputFrameCount = inputFrameCount;   /* 1:1 */
+        return MA_SUCCESS;
+    }
+}
+
+MA_API ma_result ma_data_converter_get_input_channel_map(const ma_data_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pConverter == NULL || pChannelMap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasChannelConverter) {
+        ma_channel_converter_get_output_channel_map(&pConverter->channelConverter, pChannelMap, channelMapCap);
+    } else {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pConverter->channelsOut);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_get_output_channel_map(const ma_data_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pConverter == NULL || pChannelMap == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConverter->hasChannelConverter) {
+        ma_channel_converter_get_input_channel_map(&pConverter->channelConverter, pChannelMap, channelMapCap);
+    } else {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pConverter->channelsIn);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_converter_reset(ma_data_converter* pConverter)
+{
+    if (pConverter == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* There's nothing to do if we're not resampling. */
+    if (pConverter->hasResampler == MA_FALSE) {
+        return MA_SUCCESS;
+    }
+
+    return ma_resampler_reset(&pConverter->resampler);
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Channel Maps
+
+**************************************************************************************************************************************************************/
+static ma_channel ma_channel_map_init_standard_channel(ma_standard_channel_map standardChannelMap, ma_uint32 channelCount, ma_uint32 channelIndex);
+
+MA_API ma_channel ma_channel_map_get_channel(const ma_channel* pChannelMap, ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    if (pChannelMap == NULL) {
+        return ma_channel_map_init_standard_channel(ma_standard_channel_map_default, channelCount, channelIndex);
+    } else {
+        if (channelIndex >= channelCount) {
+            return MA_CHANNEL_NONE;
+        }
+
+        return pChannelMap[channelIndex];
+    }
+}
+
+MA_API void ma_channel_map_init_blank(ma_channel* pChannelMap, ma_uint32 channels)
+{
+    if (pChannelMap == NULL) {
+        return;
+    }
+
+    MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channels);
+}
+
+
+static ma_channel ma_channel_map_init_standard_channel_microsoft(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    if (channelCount == 0 || channelIndex >= channelCount) {
+        return MA_CHANNEL_NONE;
+    }
+
+    /* This is the Microsoft channel map. Based off the speaker configurations mentioned here: https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ksmedia/ns-ksmedia-ksaudio_channel_config */
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3: /* No defined, but best guess. */
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+            #ifndef MA_USE_QUAD_MICROSOFT_CHANNEL_MAP
+                /* Surround. Using the Surround profile has the advantage of the 3rd channel (MA_CHANNEL_FRONT_CENTER) mapping nicely with higher channel counts. */
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_BACK_CENTER;
+            #else
+                /* Quad. */
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            #endif
+            }
+        } break;
+
+        case 5: /* Not defined, but best guess. */
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 6:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_SIDE_LEFT;
+                case 5: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+
+        case 7: /* Not defined, but best guess. */
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_BACK_CENTER;
+                case 5: return MA_CHANNEL_SIDE_LEFT;
+                case 6: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+
+        case 8:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_BACK_LEFT;
+                case 5: return MA_CHANNEL_BACK_RIGHT;
+                case 6: return MA_CHANNEL_SIDE_LEFT;
+                case 7: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+    }
+
+    if (channelCount > 8) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 8));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_alsa(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 5:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 6:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+                case 5: return MA_CHANNEL_LFE;
+            }
+        } break;
+
+        case 7:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+                case 5: return MA_CHANNEL_LFE;
+                case 6: return MA_CHANNEL_BACK_CENTER;
+            }
+        } break;
+
+        case 8:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+                case 5: return MA_CHANNEL_LFE;
+                case 6: return MA_CHANNEL_SIDE_LEFT;
+                case 7: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+    }
+
+    if (channelCount > 8) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 8));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_rfc3551(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_BACK_CENTER;
+            }
+        } break;
+
+        case 5:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 6:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_SIDE_LEFT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_FRONT_RIGHT;
+                case 4: return MA_CHANNEL_SIDE_RIGHT;
+                case 5: return MA_CHANNEL_BACK_CENTER;
+            }
+        } break;
+    }
+
+    if (channelCount > 6) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 6));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_flac(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 5:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 6:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_BACK_LEFT;
+                case 5: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 7:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_BACK_CENTER;
+                case 5: return MA_CHANNEL_SIDE_LEFT;
+                case 6: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+
+        case 8:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_LFE;
+                case 4: return MA_CHANNEL_BACK_LEFT;
+                case 5: return MA_CHANNEL_BACK_RIGHT;
+                case 6: return MA_CHANNEL_SIDE_LEFT;
+                case 7: return MA_CHANNEL_SIDE_RIGHT;
+            }
+        } break;
+    }
+
+    if (channelCount > 8) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 8));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_vorbis(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 5:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 6:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+                case 5: return MA_CHANNEL_LFE;
+            }
+        } break;
+
+        case 7:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_SIDE_LEFT;
+                case 4: return MA_CHANNEL_SIDE_RIGHT;
+                case 5: return MA_CHANNEL_BACK_CENTER;
+                case 6: return MA_CHANNEL_LFE;
+            }
+        } break;
+
+        case 8:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_SIDE_LEFT;
+                case 4: return MA_CHANNEL_SIDE_RIGHT;
+                case 5: return MA_CHANNEL_BACK_LEFT;
+                case 6: return MA_CHANNEL_BACK_RIGHT;
+                case 7: return MA_CHANNEL_LFE;
+            }
+        } break;
+    }
+
+    if (channelCount > 8) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 8));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_sound4(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 5:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 6:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_BACK_LEFT;
+                case 4: return MA_CHANNEL_BACK_RIGHT;
+                case 5: return MA_CHANNEL_LFE;
+            }
+        } break;
+
+        case 7:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_SIDE_LEFT;
+                case 4: return MA_CHANNEL_SIDE_RIGHT;
+                case 5: return MA_CHANNEL_BACK_CENTER;
+                case 6: return MA_CHANNEL_LFE;
+            }
+        } break;
+
+        case 8:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_CENTER;
+                case 2: return MA_CHANNEL_FRONT_RIGHT;
+                case 3: return MA_CHANNEL_SIDE_LEFT;
+                case 4: return MA_CHANNEL_SIDE_RIGHT;
+                case 5: return MA_CHANNEL_BACK_LEFT;
+                case 6: return MA_CHANNEL_BACK_RIGHT;
+                case 7: return MA_CHANNEL_LFE;
+            }
+        } break;
+    }
+
+    if (channelCount > 8) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 8));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+static ma_channel ma_channel_map_init_standard_channel_sndio(ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    switch (channelCount)
+    {
+        case 0: return MA_CHANNEL_NONE;
+
+        case 1:
+        {
+            return MA_CHANNEL_MONO;
+        } break;
+
+        case 2:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+            }
+        } break;
+
+        case 3: /* No defined, but best guess. */
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 4:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+            }
+        } break;
+
+        case 5: /* Not defined, but best guess. */
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+            }
+        } break;
+
+        case 6:
+        default:
+        {
+            switch (channelIndex) {
+                case 0: return MA_CHANNEL_FRONT_LEFT;
+                case 1: return MA_CHANNEL_FRONT_RIGHT;
+                case 2: return MA_CHANNEL_BACK_LEFT;
+                case 3: return MA_CHANNEL_BACK_RIGHT;
+                case 4: return MA_CHANNEL_FRONT_CENTER;
+                case 5: return MA_CHANNEL_LFE;
+            }
+        } break;
+    }
+
+    if (channelCount > 6) {
+        if (channelIndex < 32) {    /* We have 32 AUX channels. */
+            return (ma_channel)(MA_CHANNEL_AUX_0 + (channelIndex - 6));
+        }
+    }
+
+    /* Getting here means we don't know how to map the channel position so just return MA_CHANNEL_NONE. */
+    return MA_CHANNEL_NONE;
+}
+
+
+static ma_channel ma_channel_map_init_standard_channel(ma_standard_channel_map standardChannelMap, ma_uint32 channelCount, ma_uint32 channelIndex)
+{
+    if (channelCount == 0 || channelIndex >= channelCount) {
+        return MA_CHANNEL_NONE;
+    }
+
+    switch (standardChannelMap)
+    {
+        case ma_standard_channel_map_alsa:
+        {
+            return ma_channel_map_init_standard_channel_alsa(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_rfc3551:
+        {
+            return ma_channel_map_init_standard_channel_rfc3551(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_flac:
+        {
+            return ma_channel_map_init_standard_channel_flac(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_vorbis:
+        {
+            return ma_channel_map_init_standard_channel_vorbis(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_sound4:
+        {
+            return ma_channel_map_init_standard_channel_sound4(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_sndio:
+        {
+            return ma_channel_map_init_standard_channel_sndio(channelCount, channelIndex);
+        } break;
+
+        case ma_standard_channel_map_microsoft: /* Also default. */
+        /*case ma_standard_channel_map_default;*/
+        default:
+        {
+            return ma_channel_map_init_standard_channel_microsoft(channelCount, channelIndex);
+        } break;
+    }
+}
+
+MA_API void ma_channel_map_init_standard(ma_standard_channel_map standardChannelMap, ma_channel* pChannelMap, size_t channelMapCap, ma_uint32 channels)
+{
+    ma_uint32 iChannel;
+
+    if (pChannelMap == NULL || channelMapCap == 0 || channels == 0) {
+        return;
+    }
+
+    for (iChannel = 0; iChannel < channels; iChannel += 1) {
+        if (channelMapCap == 0) {
+            break;  /* Ran out of room. */
+        }
+
+        pChannelMap[0] = ma_channel_map_init_standard_channel(standardChannelMap, channels, iChannel);
+        pChannelMap   += 1;
+        channelMapCap -= 1;
+    }
+}
+
+MA_API void ma_channel_map_copy(ma_channel* pOut, const ma_channel* pIn, ma_uint32 channels)
+{
+    if (pOut != NULL && pIn != NULL && channels > 0) {
+        MA_COPY_MEMORY(pOut, pIn, sizeof(*pOut) * channels);
+    }
+}
+
+MA_API void ma_channel_map_copy_or_default(ma_channel* pOut, size_t channelMapCapOut, const ma_channel* pIn, ma_uint32 channels)
+{
+    if (pOut == NULL || channels == 0) {
+        return;
+    }
+
+    if (pIn != NULL) {
+        ma_channel_map_copy(pOut, pIn, channels);
+    } else {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pOut, channelMapCapOut, channels);
+    }
+}
+
+MA_API ma_bool32 ma_channel_map_is_valid(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    /* A channel count of 0 is invalid. */
+    if (channels == 0) {
+        return MA_FALSE;
+    }
+
+    /* It does not make sense to have a mono channel when there is more than 1 channel. */
+    if (channels > 1) {
+        ma_uint32 iChannel;
+        for (iChannel = 0; iChannel < channels; ++iChannel) {
+            if (ma_channel_map_get_channel(pChannelMap, channels, iChannel) == MA_CHANNEL_MONO) {
+                return MA_FALSE;
+            }
+        }
+    }
+
+    return MA_TRUE;
+}
+
+MA_API ma_bool32 ma_channel_map_is_equal(const ma_channel* pChannelMapA, const ma_channel* pChannelMapB, ma_uint32 channels)
+{
+    ma_uint32 iChannel;
+
+    if (pChannelMapA == pChannelMapB) {
+        return MA_TRUE;
+    }
+
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        if (ma_channel_map_get_channel(pChannelMapA, channels, iChannel) != ma_channel_map_get_channel(pChannelMapB, channels, iChannel)) {
+            return MA_FALSE;
+        }
+    }
+
+    return MA_TRUE;
+}
+
+MA_API ma_bool32 ma_channel_map_is_blank(const ma_channel* pChannelMap, ma_uint32 channels)
+{
+    ma_uint32 iChannel;
+
+    /* A null channel map is equivalent to the default channel map. */
+    if (pChannelMap == NULL) {
+        return MA_FALSE;
+    }
+
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        if (pChannelMap[iChannel] != MA_CHANNEL_NONE) {
+            return MA_FALSE;
+        }
+    }
+
+    return MA_TRUE;
+}
+
+MA_API ma_bool32 ma_channel_map_contains_channel_position(ma_uint32 channels, const ma_channel* pChannelMap, ma_channel channelPosition)
+{
+    return ma_channel_map_find_channel_position(channels, pChannelMap, channelPosition, NULL);
+}
+
+MA_API ma_bool32 ma_channel_map_find_channel_position(ma_uint32 channels, const ma_channel* pChannelMap, ma_channel channelPosition, ma_uint32* pChannelIndex)
+{
+    ma_uint32 iChannel;
+
+    if (pChannelIndex != NULL) {
+        *pChannelIndex = (ma_uint32)-1;
+    }
+
+    for (iChannel = 0; iChannel < channels; ++iChannel) {
+        if (ma_channel_map_get_channel(pChannelMap, channels, iChannel) == channelPosition) {
+            if (pChannelIndex != NULL) {
+                *pChannelIndex = iChannel;
+            }
+
+            return MA_TRUE;
+        }
+    }
+
+    /* Getting here means the channel position was not found. */
+    return MA_FALSE;
+}
+
+MA_API size_t ma_channel_map_to_string(const ma_channel* pChannelMap, ma_uint32 channels, char* pBufferOut, size_t bufferCap)
+{
+    size_t len;
+    ma_uint32 iChannel;
+
+    len = 0;
+
+    for (iChannel = 0; iChannel < channels; iChannel += 1) {
+        const char* pChannelStr = ma_channel_position_to_string(ma_channel_map_get_channel(pChannelMap, channels, iChannel));
+        size_t channelStrLen = strlen(pChannelStr);
+
+        /* Append the string if necessary. */
+        if (pBufferOut != NULL && bufferCap > len + channelStrLen) {
+            MA_COPY_MEMORY(pBufferOut + len, pChannelStr, channelStrLen);
+        }
+        len += channelStrLen;
+
+        /* Append a space if it's not the last item. */
+        if (iChannel+1 < channels) {
+            if (pBufferOut != NULL && bufferCap > len + 1) {
+                pBufferOut[len] = ' ';
+            }
+            len += 1;
+        }
+    }
+
+    /* Null terminate. Don't increment the length here. */
+    if (pBufferOut != NULL && bufferCap > len + 1) {
+        pBufferOut[len] = '\0';
+    }
+
+    return len;
+}
+
+MA_API const char* ma_channel_position_to_string(ma_channel channel)
+{
+    switch (channel)
+    {
+        case MA_CHANNEL_NONE              : return "CHANNEL_NONE";
+        case MA_CHANNEL_MONO              : return "CHANNEL_MONO";
+        case MA_CHANNEL_FRONT_LEFT        : return "CHANNEL_FRONT_LEFT";
+        case MA_CHANNEL_FRONT_RIGHT       : return "CHANNEL_FRONT_RIGHT";
+        case MA_CHANNEL_FRONT_CENTER      : return "CHANNEL_FRONT_CENTER";
+        case MA_CHANNEL_LFE               : return "CHANNEL_LFE";
+        case MA_CHANNEL_BACK_LEFT         : return "CHANNEL_BACK_LEFT";
+        case MA_CHANNEL_BACK_RIGHT        : return "CHANNEL_BACK_RIGHT";
+        case MA_CHANNEL_FRONT_LEFT_CENTER : return "CHANNEL_FRONT_LEFT_CENTER ";
+        case MA_CHANNEL_FRONT_RIGHT_CENTER: return "CHANNEL_FRONT_RIGHT_CENTER";
+        case MA_CHANNEL_BACK_CENTER       : return "CHANNEL_BACK_CENTER";
+        case MA_CHANNEL_SIDE_LEFT         : return "CHANNEL_SIDE_LEFT";
+        case MA_CHANNEL_SIDE_RIGHT        : return "CHANNEL_SIDE_RIGHT";
+        case MA_CHANNEL_TOP_CENTER        : return "CHANNEL_TOP_CENTER";
+        case MA_CHANNEL_TOP_FRONT_LEFT    : return "CHANNEL_TOP_FRONT_LEFT";
+        case MA_CHANNEL_TOP_FRONT_CENTER  : return "CHANNEL_TOP_FRONT_CENTER";
+        case MA_CHANNEL_TOP_FRONT_RIGHT   : return "CHANNEL_TOP_FRONT_RIGHT";
+        case MA_CHANNEL_TOP_BACK_LEFT     : return "CHANNEL_TOP_BACK_LEFT";
+        case MA_CHANNEL_TOP_BACK_CENTER   : return "CHANNEL_TOP_BACK_CENTER";
+        case MA_CHANNEL_TOP_BACK_RIGHT    : return "CHANNEL_TOP_BACK_RIGHT";
+        case MA_CHANNEL_AUX_0             : return "CHANNEL_AUX_0";
+        case MA_CHANNEL_AUX_1             : return "CHANNEL_AUX_1";
+        case MA_CHANNEL_AUX_2             : return "CHANNEL_AUX_2";
+        case MA_CHANNEL_AUX_3             : return "CHANNEL_AUX_3";
+        case MA_CHANNEL_AUX_4             : return "CHANNEL_AUX_4";
+        case MA_CHANNEL_AUX_5             : return "CHANNEL_AUX_5";
+        case MA_CHANNEL_AUX_6             : return "CHANNEL_AUX_6";
+        case MA_CHANNEL_AUX_7             : return "CHANNEL_AUX_7";
+        case MA_CHANNEL_AUX_8             : return "CHANNEL_AUX_8";
+        case MA_CHANNEL_AUX_9             : return "CHANNEL_AUX_9";
+        case MA_CHANNEL_AUX_10            : return "CHANNEL_AUX_10";
+        case MA_CHANNEL_AUX_11            : return "CHANNEL_AUX_11";
+        case MA_CHANNEL_AUX_12            : return "CHANNEL_AUX_12";
+        case MA_CHANNEL_AUX_13            : return "CHANNEL_AUX_13";
+        case MA_CHANNEL_AUX_14            : return "CHANNEL_AUX_14";
+        case MA_CHANNEL_AUX_15            : return "CHANNEL_AUX_15";
+        case MA_CHANNEL_AUX_16            : return "CHANNEL_AUX_16";
+        case MA_CHANNEL_AUX_17            : return "CHANNEL_AUX_17";
+        case MA_CHANNEL_AUX_18            : return "CHANNEL_AUX_18";
+        case MA_CHANNEL_AUX_19            : return "CHANNEL_AUX_19";
+        case MA_CHANNEL_AUX_20            : return "CHANNEL_AUX_20";
+        case MA_CHANNEL_AUX_21            : return "CHANNEL_AUX_21";
+        case MA_CHANNEL_AUX_22            : return "CHANNEL_AUX_22";
+        case MA_CHANNEL_AUX_23            : return "CHANNEL_AUX_23";
+        case MA_CHANNEL_AUX_24            : return "CHANNEL_AUX_24";
+        case MA_CHANNEL_AUX_25            : return "CHANNEL_AUX_25";
+        case MA_CHANNEL_AUX_26            : return "CHANNEL_AUX_26";
+        case MA_CHANNEL_AUX_27            : return "CHANNEL_AUX_27";
+        case MA_CHANNEL_AUX_28            : return "CHANNEL_AUX_28";
+        case MA_CHANNEL_AUX_29            : return "CHANNEL_AUX_29";
+        case MA_CHANNEL_AUX_30            : return "CHANNEL_AUX_30";
+        case MA_CHANNEL_AUX_31            : return "CHANNEL_AUX_31";
+        default: break;
+    }
+
+    return "UNKNOWN";
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Conversion Helpers
+
+**************************************************************************************************************************************************************/
+MA_API ma_uint64 ma_convert_frames(void* pOut, ma_uint64 frameCountOut, ma_format formatOut, ma_uint32 channelsOut, ma_uint32 sampleRateOut, const void* pIn, ma_uint64 frameCountIn, ma_format formatIn, ma_uint32 channelsIn, ma_uint32 sampleRateIn)
+{
+    ma_data_converter_config config;
+
+    config = ma_data_converter_config_init(formatIn, formatOut, channelsIn, channelsOut, sampleRateIn, sampleRateOut);
+    config.resampling.linear.lpfOrder = ma_min(MA_DEFAULT_RESAMPLER_LPF_ORDER, MA_MAX_FILTER_ORDER);
+
+    return ma_convert_frames_ex(pOut, frameCountOut, pIn, frameCountIn, &config);
+}
+
+MA_API ma_uint64 ma_convert_frames_ex(void* pOut, ma_uint64 frameCountOut, const void* pIn, ma_uint64 frameCountIn, const ma_data_converter_config* pConfig)
+{
+    ma_result result;
+    ma_data_converter converter;
+
+    if (frameCountIn == 0 || pConfig == NULL) {
+        return 0;
+    }
+
+    result = ma_data_converter_init(pConfig, NULL, &converter);
+    if (result != MA_SUCCESS) {
+        return 0;   /* Failed to initialize the data converter. */
+    }
+
+    if (pOut == NULL) {
+        result = ma_data_converter_get_expected_output_frame_count(&converter, frameCountIn, &frameCountOut);
+        if (result != MA_SUCCESS) {
+            if (result == MA_NOT_IMPLEMENTED) {
+                /* No way to calculate the number of frames, so we'll need to brute force it and loop. */
+                frameCountOut = 0;
+
+                while (frameCountIn > 0) {
+                    ma_uint64 framesProcessedIn  = frameCountIn;
+                    ma_uint64 framesProcessedOut = 0xFFFFFFFF;
+
+                    result = ma_data_converter_process_pcm_frames(&converter, pIn, &framesProcessedIn, NULL, &framesProcessedOut);
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+
+                    frameCountIn  -= framesProcessedIn;
+                }
+            }
+        }
+    } else {
+        result = ma_data_converter_process_pcm_frames(&converter, pIn, &frameCountIn, pOut, &frameCountOut);
+        if (result != MA_SUCCESS) {
+            frameCountOut = 0;
+        }
+    }
+
+    ma_data_converter_uninit(&converter, NULL);
+    return frameCountOut;
+}
+
+
+/**************************************************************************************************************************************************************
+
+Ring Buffer
+
+**************************************************************************************************************************************************************/
+static MA_INLINE ma_uint32 ma_rb__extract_offset_in_bytes(ma_uint32 encodedOffset)
+{
+    return encodedOffset & 0x7FFFFFFF;
+}
+
+static MA_INLINE ma_uint32 ma_rb__extract_offset_loop_flag(ma_uint32 encodedOffset)
+{
+    return encodedOffset & 0x80000000;
+}
+
+static MA_INLINE void* ma_rb__get_read_ptr(ma_rb* pRB)
+{
+    MA_ASSERT(pRB != NULL);
+    return ma_offset_ptr(pRB->pBuffer, ma_rb__extract_offset_in_bytes(ma_atomic_load_32(&pRB->encodedReadOffset)));
+}
+
+static MA_INLINE void* ma_rb__get_write_ptr(ma_rb* pRB)
+{
+    MA_ASSERT(pRB != NULL);
+    return ma_offset_ptr(pRB->pBuffer, ma_rb__extract_offset_in_bytes(ma_atomic_load_32(&pRB->encodedWriteOffset)));
+}
+
+static MA_INLINE ma_uint32 ma_rb__construct_offset(ma_uint32 offsetInBytes, ma_uint32 offsetLoopFlag)
+{
+    return offsetLoopFlag | offsetInBytes;
+}
+
+static MA_INLINE void ma_rb__deconstruct_offset(ma_uint32 encodedOffset, ma_uint32* pOffsetInBytes, ma_uint32* pOffsetLoopFlag)
+{
+    MA_ASSERT(pOffsetInBytes != NULL);
+    MA_ASSERT(pOffsetLoopFlag != NULL);
+
+    *pOffsetInBytes  = ma_rb__extract_offset_in_bytes(encodedOffset);
+    *pOffsetLoopFlag = ma_rb__extract_offset_loop_flag(encodedOffset);
+}
+
+
+MA_API ma_result ma_rb_init_ex(size_t subbufferSizeInBytes, size_t subbufferCount, size_t subbufferStrideInBytes, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_rb* pRB)
+{
+    ma_result result;
+    const ma_uint32 maxSubBufferSize = 0x7FFFFFFF - (MA_SIMD_ALIGNMENT-1);
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (subbufferSizeInBytes == 0 || subbufferCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (subbufferSizeInBytes > maxSubBufferSize) {
+        return MA_INVALID_ARGS;    /* Maximum buffer size is ~2GB. The most significant bit is a flag for use internally. */
+    }
+
+
+    MA_ZERO_OBJECT(pRB);
+
+    result = ma_allocation_callbacks_init_copy(&pRB->allocationCallbacks, pAllocationCallbacks);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pRB->subbufferSizeInBytes = (ma_uint32)subbufferSizeInBytes;
+    pRB->subbufferCount = (ma_uint32)subbufferCount;
+
+    if (pOptionalPreallocatedBuffer != NULL) {
+        pRB->subbufferStrideInBytes = (ma_uint32)subbufferStrideInBytes;
+        pRB->pBuffer = pOptionalPreallocatedBuffer;
+    } else {
+        size_t bufferSizeInBytes;
+
+        /*
+        Here is where we allocate our own buffer. We always want to align this to MA_SIMD_ALIGNMENT for future SIMD optimization opportunity. To do this
+        we need to make sure the stride is a multiple of MA_SIMD_ALIGNMENT.
+        */
+        pRB->subbufferStrideInBytes = (pRB->subbufferSizeInBytes + (MA_SIMD_ALIGNMENT-1)) & ~MA_SIMD_ALIGNMENT;
+
+        bufferSizeInBytes = (size_t)pRB->subbufferCount*pRB->subbufferStrideInBytes;
+        pRB->pBuffer = ma_aligned_malloc(bufferSizeInBytes, MA_SIMD_ALIGNMENT, &pRB->allocationCallbacks);
+        if (pRB->pBuffer == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        MA_ZERO_MEMORY(pRB->pBuffer, bufferSizeInBytes);
+        pRB->ownsBuffer = MA_TRUE;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_rb_init(size_t bufferSizeInBytes, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_rb* pRB)
+{
+    return ma_rb_init_ex(bufferSizeInBytes, 1, 0, pOptionalPreallocatedBuffer, pAllocationCallbacks, pRB);
+}
+
+MA_API void ma_rb_uninit(ma_rb* pRB)
+{
+    if (pRB == NULL) {
+        return;
+    }
+
+    if (pRB->ownsBuffer) {
+        ma_aligned_free(pRB->pBuffer, &pRB->allocationCallbacks);
+    }
+}
+
+MA_API void ma_rb_reset(ma_rb* pRB)
+{
+    if (pRB == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_32(&pRB->encodedReadOffset, 0);
+    ma_atomic_exchange_32(&pRB->encodedWriteOffset, 0);
+}
+
+MA_API ma_result ma_rb_acquire_read(ma_rb* pRB, size_t* pSizeInBytes, void** ppBufferOut)
+{
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    size_t bytesAvailable;
+    size_t bytesRequested;
+
+    if (pRB == NULL || pSizeInBytes == NULL || ppBufferOut == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The returned buffer should never move ahead of the write pointer. */
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    /*
+    The number of bytes available depends on whether or not the read and write pointers are on the same loop iteration. If so, we
+    can only read up to the write pointer. If not, we can only read up to the end of the buffer.
+    */
+    if (readOffsetLoopFlag == writeOffsetLoopFlag) {
+        bytesAvailable = writeOffsetInBytes - readOffsetInBytes;
+    } else {
+        bytesAvailable = pRB->subbufferSizeInBytes - readOffsetInBytes;
+    }
+
+    bytesRequested = *pSizeInBytes;
+    if (bytesRequested > bytesAvailable) {
+        bytesRequested = bytesAvailable;
+    }
+
+    *pSizeInBytes = bytesRequested;
+    (*ppBufferOut) = ma_rb__get_read_ptr(pRB);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_rb_commit_read(ma_rb* pRB, size_t sizeInBytes)
+{
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    ma_uint32 newReadOffsetInBytes;
+    ma_uint32 newReadOffsetLoopFlag;
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    /* Check that sizeInBytes is correct. It should never go beyond the end of the buffer. */
+    newReadOffsetInBytes = (ma_uint32)(readOffsetInBytes + sizeInBytes);
+    if (newReadOffsetInBytes > pRB->subbufferSizeInBytes) {
+        return MA_INVALID_ARGS;    /* <-- sizeInBytes will cause the read offset to overflow. */
+    }
+
+    /* Move the read pointer back to the start if necessary. */
+    newReadOffsetLoopFlag = readOffsetLoopFlag;
+    if (newReadOffsetInBytes == pRB->subbufferSizeInBytes) {
+        newReadOffsetInBytes = 0;
+        newReadOffsetLoopFlag ^= 0x80000000;
+    }
+
+    ma_atomic_exchange_32(&pRB->encodedReadOffset, ma_rb__construct_offset(newReadOffsetLoopFlag, newReadOffsetInBytes));
+
+    if (ma_rb_pointer_distance(pRB) == 0) {
+        return MA_AT_END;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+MA_API ma_result ma_rb_acquire_write(ma_rb* pRB, size_t* pSizeInBytes, void** ppBufferOut)
+{
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+    size_t bytesAvailable;
+    size_t bytesRequested;
+
+    if (pRB == NULL || pSizeInBytes == NULL || ppBufferOut == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The returned buffer should never overtake the read buffer. */
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    /*
+    In the case of writing, if the write pointer and the read pointer are on the same loop iteration we can only
+    write up to the end of the buffer. Otherwise we can only write up to the read pointer. The write pointer should
+    never overtake the read pointer.
+    */
+    if (writeOffsetLoopFlag == readOffsetLoopFlag) {
+        bytesAvailable = pRB->subbufferSizeInBytes - writeOffsetInBytes;
+    } else {
+        bytesAvailable = readOffsetInBytes - writeOffsetInBytes;
+    }
+
+    bytesRequested = *pSizeInBytes;
+    if (bytesRequested > bytesAvailable) {
+        bytesRequested = bytesAvailable;
+    }
+
+    *pSizeInBytes = bytesRequested;
+    *ppBufferOut  = ma_rb__get_write_ptr(pRB);
+
+    /* Clear the buffer if desired. */
+    if (pRB->clearOnWriteAcquire) {
+        MA_ZERO_MEMORY(*ppBufferOut, *pSizeInBytes);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_rb_commit_write(ma_rb* pRB, size_t sizeInBytes)
+{
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+    ma_uint32 newWriteOffsetInBytes;
+    ma_uint32 newWriteOffsetLoopFlag;
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    /* Check that sizeInBytes is correct. It should never go beyond the end of the buffer. */
+    newWriteOffsetInBytes = (ma_uint32)(writeOffsetInBytes + sizeInBytes);
+    if (newWriteOffsetInBytes > pRB->subbufferSizeInBytes) {
+        return MA_INVALID_ARGS;    /* <-- sizeInBytes will cause the read offset to overflow. */
+    }
+
+    /* Move the read pointer back to the start if necessary. */
+    newWriteOffsetLoopFlag = writeOffsetLoopFlag;
+    if (newWriteOffsetInBytes == pRB->subbufferSizeInBytes) {
+        newWriteOffsetInBytes = 0;
+        newWriteOffsetLoopFlag ^= 0x80000000;
+    }
+
+    ma_atomic_exchange_32(&pRB->encodedWriteOffset, ma_rb__construct_offset(newWriteOffsetLoopFlag, newWriteOffsetInBytes));
+
+    if (ma_rb_pointer_distance(pRB) == 0) {
+        return MA_AT_END;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+MA_API ma_result ma_rb_seek_read(ma_rb* pRB, size_t offsetInBytes)
+{
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+    ma_uint32 newReadOffsetInBytes;
+    ma_uint32 newReadOffsetLoopFlag;
+
+    if (pRB == NULL || offsetInBytes > pRB->subbufferSizeInBytes) {
+        return MA_INVALID_ARGS;
+    }
+
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    newReadOffsetLoopFlag = readOffsetLoopFlag;
+
+    /* We cannot go past the write buffer. */
+    if (readOffsetLoopFlag == writeOffsetLoopFlag) {
+        if ((readOffsetInBytes + offsetInBytes) > writeOffsetInBytes) {
+            newReadOffsetInBytes = writeOffsetInBytes;
+        } else {
+            newReadOffsetInBytes = (ma_uint32)(readOffsetInBytes + offsetInBytes);
+        }
+    } else {
+        /* May end up looping. */
+        if ((readOffsetInBytes + offsetInBytes) >= pRB->subbufferSizeInBytes) {
+            newReadOffsetInBytes = (ma_uint32)(readOffsetInBytes + offsetInBytes) - pRB->subbufferSizeInBytes;
+            newReadOffsetLoopFlag ^= 0x80000000;    /* <-- Looped. */
+        } else {
+            newReadOffsetInBytes = (ma_uint32)(readOffsetInBytes + offsetInBytes);
+        }
+    }
+
+    ma_atomic_exchange_32(&pRB->encodedReadOffset, ma_rb__construct_offset(newReadOffsetInBytes, newReadOffsetLoopFlag));
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_rb_seek_write(ma_rb* pRB, size_t offsetInBytes)
+{
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+    ma_uint32 newWriteOffsetInBytes;
+    ma_uint32 newWriteOffsetLoopFlag;
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    newWriteOffsetLoopFlag = writeOffsetLoopFlag;
+
+    /* We cannot go past the write buffer. */
+    if (readOffsetLoopFlag == writeOffsetLoopFlag) {
+        /* May end up looping. */
+        if ((writeOffsetInBytes + offsetInBytes) >= pRB->subbufferSizeInBytes) {
+            newWriteOffsetInBytes = (ma_uint32)(writeOffsetInBytes + offsetInBytes) - pRB->subbufferSizeInBytes;
+            newWriteOffsetLoopFlag ^= 0x80000000;    /* <-- Looped. */
+        } else {
+            newWriteOffsetInBytes = (ma_uint32)(writeOffsetInBytes + offsetInBytes);
+        }
+    } else {
+        if ((writeOffsetInBytes + offsetInBytes) > readOffsetInBytes) {
+            newWriteOffsetInBytes = readOffsetInBytes;
+        } else {
+            newWriteOffsetInBytes = (ma_uint32)(writeOffsetInBytes + offsetInBytes);
+        }
+    }
+
+    ma_atomic_exchange_32(&pRB->encodedWriteOffset, ma_rb__construct_offset(newWriteOffsetInBytes, newWriteOffsetLoopFlag));
+    return MA_SUCCESS;
+}
+
+MA_API ma_int32 ma_rb_pointer_distance(ma_rb* pRB)
+{
+    ma_uint32 readOffset;
+    ma_uint32 readOffsetInBytes;
+    ma_uint32 readOffsetLoopFlag;
+    ma_uint32 writeOffset;
+    ma_uint32 writeOffsetInBytes;
+    ma_uint32 writeOffsetLoopFlag;
+
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    readOffset = ma_atomic_load_32(&pRB->encodedReadOffset);
+    ma_rb__deconstruct_offset(readOffset, &readOffsetInBytes, &readOffsetLoopFlag);
+
+    writeOffset = ma_atomic_load_32(&pRB->encodedWriteOffset);
+    ma_rb__deconstruct_offset(writeOffset, &writeOffsetInBytes, &writeOffsetLoopFlag);
+
+    if (readOffsetLoopFlag == writeOffsetLoopFlag) {
+        return writeOffsetInBytes - readOffsetInBytes;
+    } else {
+        return writeOffsetInBytes + (pRB->subbufferSizeInBytes - readOffsetInBytes);
+    }
+}
+
+MA_API ma_uint32 ma_rb_available_read(ma_rb* pRB)
+{
+    ma_int32 dist;
+
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    dist = ma_rb_pointer_distance(pRB);
+    if (dist < 0) {
+        return 0;
+    }
+
+    return dist;
+}
+
+MA_API ma_uint32 ma_rb_available_write(ma_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return (ma_uint32)(ma_rb_get_subbuffer_size(pRB) - ma_rb_pointer_distance(pRB));
+}
+
+MA_API size_t ma_rb_get_subbuffer_size(ma_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return pRB->subbufferSizeInBytes;
+}
+
+MA_API size_t ma_rb_get_subbuffer_stride(ma_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    if (pRB->subbufferStrideInBytes == 0) {
+        return (size_t)pRB->subbufferSizeInBytes;
+    }
+
+    return (size_t)pRB->subbufferStrideInBytes;
+}
+
+MA_API size_t ma_rb_get_subbuffer_offset(ma_rb* pRB, size_t subbufferIndex)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return subbufferIndex * ma_rb_get_subbuffer_stride(pRB);
+}
+
+MA_API void* ma_rb_get_subbuffer_ptr(ma_rb* pRB, size_t subbufferIndex, void* pBuffer)
+{
+    if (pRB == NULL) {
+        return NULL;
+    }
+
+    return ma_offset_ptr(pBuffer, ma_rb_get_subbuffer_offset(pRB, subbufferIndex));
+}
+
+
+
+static ma_result ma_pcm_rb_data_source__on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    /* Since there's no notion of an end, we don't ever want to return MA_AT_END here. But it is possible to return 0. */
+    ma_pcm_rb* pRB = (ma_pcm_rb*)pDataSource;
+    ma_result result;
+    ma_uint64 totalFramesRead;
+
+    MA_ASSERT(pRB != NULL);
+
+    /* We need to run this in a loop since the ring buffer itself may loop. */
+    totalFramesRead = 0;
+    while (totalFramesRead < frameCount) {
+        void* pMappedBuffer;
+        ma_uint32 mappedFrameCount;
+        ma_uint64 framesToRead = frameCount - totalFramesRead;
+        if (framesToRead > 0xFFFFFFFF) {
+            framesToRead = 0xFFFFFFFF;
+        }
+
+        mappedFrameCount = (ma_uint32)framesToRead;
+        result = ma_pcm_rb_acquire_read(pRB, &mappedFrameCount, &pMappedBuffer);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        if (mappedFrameCount == 0) {
+            break;  /* <-- End of ring buffer. */
+        }
+
+        ma_copy_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, pRB->format, pRB->channels), pMappedBuffer, mappedFrameCount, pRB->format, pRB->channels);
+
+        result = ma_pcm_rb_commit_read(pRB, mappedFrameCount);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        totalFramesRead += mappedFrameCount;
+    }
+
+    *pFramesRead = totalFramesRead;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_pcm_rb_data_source__on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_pcm_rb* pRB = (ma_pcm_rb*)pDataSource;
+    MA_ASSERT(pRB != NULL);
+
+    if (pFormat != NULL) {
+        *pFormat = pRB->format;
+    }
+
+    if (pChannels != NULL) {
+        *pChannels = pRB->channels;
+    }
+
+    if (pSampleRate != NULL) {
+        *pSampleRate = pRB->sampleRate;
+    }
+
+    /* Just assume the default channel map. */
+    if (pChannelMap != NULL) {
+        ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pRB->channels);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_data_source_vtable ma_gRBDataSourceVTable =
+{
+    ma_pcm_rb_data_source__on_read,
+    NULL,   /* onSeek */
+    ma_pcm_rb_data_source__on_get_data_format,
+    NULL,   /* onGetCursor */
+    NULL,   /* onGetLength */
+    NULL,   /* onSetLooping */
+    0
+};
+
+static MA_INLINE ma_uint32 ma_pcm_rb_get_bpf(ma_pcm_rb* pRB)
+{
+    MA_ASSERT(pRB != NULL);
+
+    return ma_get_bytes_per_frame(pRB->format, pRB->channels);
+}
+
+MA_API ma_result ma_pcm_rb_init_ex(ma_format format, ma_uint32 channels, ma_uint32 subbufferSizeInFrames, ma_uint32 subbufferCount, ma_uint32 subbufferStrideInFrames, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_pcm_rb* pRB)
+{
+    ma_uint32 bpf;
+    ma_result result;
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pRB);
+
+    bpf = ma_get_bytes_per_frame(format, channels);
+    if (bpf == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_rb_init_ex(subbufferSizeInFrames*bpf, subbufferCount, subbufferStrideInFrames*bpf, pOptionalPreallocatedBuffer, pAllocationCallbacks, &pRB->rb);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pRB->format     = format;
+    pRB->channels   = channels;
+    pRB->sampleRate = 0;    /* The sample rate is not passed in as a parameter. */
+
+    /* The PCM ring buffer is a data source. We need to get that set up as well. */
+    {
+        ma_data_source_config dataSourceConfig = ma_data_source_config_init();
+        dataSourceConfig.vtable = &ma_gRBDataSourceVTable;
+
+        result = ma_data_source_init(&dataSourceConfig, &pRB->ds);
+        if (result != MA_SUCCESS) {
+            ma_rb_uninit(&pRB->rb);
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pcm_rb_init(ma_format format, ma_uint32 channels, ma_uint32 bufferSizeInFrames, void* pOptionalPreallocatedBuffer, const ma_allocation_callbacks* pAllocationCallbacks, ma_pcm_rb* pRB)
+{
+    return ma_pcm_rb_init_ex(format, channels, bufferSizeInFrames, 1, 0, pOptionalPreallocatedBuffer, pAllocationCallbacks, pRB);
+}
+
+MA_API void ma_pcm_rb_uninit(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return;
+    }
+
+    ma_data_source_uninit(&pRB->ds);
+    ma_rb_uninit(&pRB->rb);
+}
+
+MA_API void ma_pcm_rb_reset(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return;
+    }
+
+    ma_rb_reset(&pRB->rb);
+}
+
+MA_API ma_result ma_pcm_rb_acquire_read(ma_pcm_rb* pRB, ma_uint32* pSizeInFrames, void** ppBufferOut)
+{
+    size_t sizeInBytes;
+    ma_result result;
+
+    if (pRB == NULL || pSizeInFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    sizeInBytes = *pSizeInFrames * ma_pcm_rb_get_bpf(pRB);
+
+    result = ma_rb_acquire_read(&pRB->rb, &sizeInBytes, ppBufferOut);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pSizeInFrames = (ma_uint32)(sizeInBytes / (size_t)ma_pcm_rb_get_bpf(pRB));
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pcm_rb_commit_read(ma_pcm_rb* pRB, ma_uint32 sizeInFrames)
+{
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_rb_commit_read(&pRB->rb, sizeInFrames * ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_result ma_pcm_rb_acquire_write(ma_pcm_rb* pRB, ma_uint32* pSizeInFrames, void** ppBufferOut)
+{
+    size_t sizeInBytes;
+    ma_result result;
+
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    sizeInBytes = *pSizeInFrames * ma_pcm_rb_get_bpf(pRB);
+
+    result = ma_rb_acquire_write(&pRB->rb, &sizeInBytes, ppBufferOut);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pSizeInFrames = (ma_uint32)(sizeInBytes / ma_pcm_rb_get_bpf(pRB));
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pcm_rb_commit_write(ma_pcm_rb* pRB, ma_uint32 sizeInFrames)
+{
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_rb_commit_write(&pRB->rb, sizeInFrames * ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_result ma_pcm_rb_seek_read(ma_pcm_rb* pRB, ma_uint32 offsetInFrames)
+{
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_rb_seek_read(&pRB->rb, offsetInFrames * ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_result ma_pcm_rb_seek_write(ma_pcm_rb* pRB, ma_uint32 offsetInFrames)
+{
+    if (pRB == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_rb_seek_write(&pRB->rb, offsetInFrames * ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_int32 ma_pcm_rb_pointer_distance(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return ma_rb_pointer_distance(&pRB->rb) / ma_pcm_rb_get_bpf(pRB);
+}
+
+MA_API ma_uint32 ma_pcm_rb_available_read(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return ma_rb_available_read(&pRB->rb) / ma_pcm_rb_get_bpf(pRB);
+}
+
+MA_API ma_uint32 ma_pcm_rb_available_write(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return ma_rb_available_write(&pRB->rb) / ma_pcm_rb_get_bpf(pRB);
+}
+
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_size(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return (ma_uint32)(ma_rb_get_subbuffer_size(&pRB->rb) / ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_stride(ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return (ma_uint32)(ma_rb_get_subbuffer_stride(&pRB->rb) / ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API ma_uint32 ma_pcm_rb_get_subbuffer_offset(ma_pcm_rb* pRB, ma_uint32 subbufferIndex)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return (ma_uint32)(ma_rb_get_subbuffer_offset(&pRB->rb, subbufferIndex) / ma_pcm_rb_get_bpf(pRB));
+}
+
+MA_API void* ma_pcm_rb_get_subbuffer_ptr(ma_pcm_rb* pRB, ma_uint32 subbufferIndex, void* pBuffer)
+{
+    if (pRB == NULL) {
+        return NULL;
+    }
+
+    return ma_rb_get_subbuffer_ptr(&pRB->rb, subbufferIndex, pBuffer);
+}
+
+MA_API ma_format ma_pcm_rb_get_format(const ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return ma_format_unknown;
+    }
+
+    return pRB->format;
+}
+
+MA_API ma_uint32 ma_pcm_rb_get_channels(const ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return pRB->channels;
+}
+
+MA_API ma_uint32 ma_pcm_rb_get_sample_rate(const ma_pcm_rb* pRB)
+{
+    if (pRB == NULL) {
+        return 0;
+    }
+
+    return pRB->sampleRate;
+}
+
+MA_API void ma_pcm_rb_set_sample_rate(ma_pcm_rb* pRB, ma_uint32 sampleRate)
+{
+    if (pRB == NULL) {
+        return;
+    }
+
+    pRB->sampleRate = sampleRate;
+}
+
+
+
+MA_API ma_result ma_duplex_rb_init(ma_format captureFormat, ma_uint32 captureChannels, ma_uint32 sampleRate, ma_uint32 captureInternalSampleRate, ma_uint32 captureInternalPeriodSizeInFrames, const ma_allocation_callbacks* pAllocationCallbacks, ma_duplex_rb* pRB)
+{
+    ma_result result;
+    ma_uint32 sizeInFrames;
+
+    sizeInFrames = (ma_uint32)ma_calculate_frame_count_after_resampling(sampleRate, captureInternalSampleRate, captureInternalPeriodSizeInFrames * 5);
+    if (sizeInFrames == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_pcm_rb_init(captureFormat, captureChannels, sizeInFrames, NULL, pAllocationCallbacks, &pRB->rb);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Seek forward a bit so we have a bit of a buffer in case of desyncs. */
+    ma_pcm_rb_seek_write((ma_pcm_rb*)pRB, captureInternalPeriodSizeInFrames * 2);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_duplex_rb_uninit(ma_duplex_rb* pRB)
+{
+    ma_pcm_rb_uninit((ma_pcm_rb*)pRB);
+    return MA_SUCCESS;
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Miscellaneous Helpers
+
+**************************************************************************************************************************************************************/
+MA_API const char* ma_result_description(ma_result result)
+{
+    switch (result)
+    {
+        case MA_SUCCESS:                       return "No error";
+        case MA_ERROR:                         return "Unknown error";
+        case MA_INVALID_ARGS:                  return "Invalid argument";
+        case MA_INVALID_OPERATION:             return "Invalid operation";
+        case MA_OUT_OF_MEMORY:                 return "Out of memory";
+        case MA_OUT_OF_RANGE:                  return "Out of range";
+        case MA_ACCESS_DENIED:                 return "Permission denied";
+        case MA_DOES_NOT_EXIST:                return "Resource does not exist";
+        case MA_ALREADY_EXISTS:                return "Resource already exists";
+        case MA_TOO_MANY_OPEN_FILES:           return "Too many open files";
+        case MA_INVALID_FILE:                  return "Invalid file";
+        case MA_TOO_BIG:                       return "Too large";
+        case MA_PATH_TOO_LONG:                 return "Path too long";
+        case MA_NAME_TOO_LONG:                 return "Name too long";
+        case MA_NOT_DIRECTORY:                 return "Not a directory";
+        case MA_IS_DIRECTORY:                  return "Is a directory";
+        case MA_DIRECTORY_NOT_EMPTY:           return "Directory not empty";
+        case MA_AT_END:                        return "At end";
+        case MA_NO_SPACE:                      return "No space available";
+        case MA_BUSY:                          return "Device or resource busy";
+        case MA_IO_ERROR:                      return "Input/output error";
+        case MA_INTERRUPT:                     return "Interrupted";
+        case MA_UNAVAILABLE:                   return "Resource unavailable";
+        case MA_ALREADY_IN_USE:                return "Resource already in use";
+        case MA_BAD_ADDRESS:                   return "Bad address";
+        case MA_BAD_SEEK:                      return "Illegal seek";
+        case MA_BAD_PIPE:                      return "Broken pipe";
+        case MA_DEADLOCK:                      return "Deadlock";
+        case MA_TOO_MANY_LINKS:                return "Too many links";
+        case MA_NOT_IMPLEMENTED:               return "Not implemented";
+        case MA_NO_MESSAGE:                    return "No message of desired type";
+        case MA_BAD_MESSAGE:                   return "Invalid message";
+        case MA_NO_DATA_AVAILABLE:             return "No data available";
+        case MA_INVALID_DATA:                  return "Invalid data";
+        case MA_TIMEOUT:                       return "Timeout";
+        case MA_NO_NETWORK:                    return "Network unavailable";
+        case MA_NOT_UNIQUE:                    return "Not unique";
+        case MA_NOT_SOCKET:                    return "Socket operation on non-socket";
+        case MA_NO_ADDRESS:                    return "Destination address required";
+        case MA_BAD_PROTOCOL:                  return "Protocol wrong type for socket";
+        case MA_PROTOCOL_UNAVAILABLE:          return "Protocol not available";
+        case MA_PROTOCOL_NOT_SUPPORTED:        return "Protocol not supported";
+        case MA_PROTOCOL_FAMILY_NOT_SUPPORTED: return "Protocol family not supported";
+        case MA_ADDRESS_FAMILY_NOT_SUPPORTED:  return "Address family not supported";
+        case MA_SOCKET_NOT_SUPPORTED:          return "Socket type not supported";
+        case MA_CONNECTION_RESET:              return "Connection reset";
+        case MA_ALREADY_CONNECTED:             return "Already connected";
+        case MA_NOT_CONNECTED:                 return "Not connected";
+        case MA_CONNECTION_REFUSED:            return "Connection refused";
+        case MA_NO_HOST:                       return "No host";
+        case MA_IN_PROGRESS:                   return "Operation in progress";
+        case MA_CANCELLED:                     return "Operation cancelled";
+        case MA_MEMORY_ALREADY_MAPPED:         return "Memory already mapped";
+
+        case MA_FORMAT_NOT_SUPPORTED:          return "Format not supported";
+        case MA_DEVICE_TYPE_NOT_SUPPORTED:     return "Device type not supported";
+        case MA_SHARE_MODE_NOT_SUPPORTED:      return "Share mode not supported";
+        case MA_NO_BACKEND:                    return "No backend";
+        case MA_NO_DEVICE:                     return "No device";
+        case MA_API_NOT_FOUND:                 return "API not found";
+        case MA_INVALID_DEVICE_CONFIG:         return "Invalid device config";
+
+        case MA_DEVICE_NOT_INITIALIZED:        return "Device not initialized";
+        case MA_DEVICE_NOT_STARTED:            return "Device not started";
+
+        case MA_FAILED_TO_INIT_BACKEND:        return "Failed to initialize backend";
+        case MA_FAILED_TO_OPEN_BACKEND_DEVICE: return "Failed to open backend device";
+        case MA_FAILED_TO_START_BACKEND_DEVICE: return "Failed to start backend device";
+        case MA_FAILED_TO_STOP_BACKEND_DEVICE: return "Failed to stop backend device";
+
+        default:                               return "Unknown error";
+    }
+}
+
+MA_API void* ma_malloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        if (pAllocationCallbacks->onMalloc != NULL) {
+            return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData);
+        } else {
+            return NULL;    /* Do not fall back to the default implementation. */
+        }
+    } else {
+        return ma__malloc_default(sz, NULL);
+    }
+}
+
+MA_API void* ma_calloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    void* p = ma_malloc(sz, pAllocationCallbacks);
+    if (p != NULL) {
+        MA_ZERO_MEMORY(p, sz);
+    }
+
+    return p;
+}
+
+MA_API void* ma_realloc(void* p, size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        if (pAllocationCallbacks->onRealloc != NULL) {
+            return pAllocationCallbacks->onRealloc(p, sz, pAllocationCallbacks->pUserData);
+        } else {
+            return NULL;    /* Do not fall back to the default implementation. */
+        }
+    } else {
+        return ma__realloc_default(p, sz, NULL);
+    }
+}
+
+MA_API void ma_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (p == NULL) {
+        return;
+    }
+
+    if (pAllocationCallbacks != NULL) {
+        if (pAllocationCallbacks->onFree != NULL) {
+            pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+        } else {
+            return; /* Do no fall back to the default implementation. */
+        }
+    } else {
+        ma__free_default(p, NULL);
+    }
+}
+
+MA_API void* ma_aligned_malloc(size_t sz, size_t alignment, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    size_t extraBytes;
+    void* pUnaligned;
+    void* pAligned;
+
+    if (alignment == 0) {
+        return 0;
+    }
+
+    extraBytes = alignment-1 + sizeof(void*);
+
+    pUnaligned = ma_malloc(sz + extraBytes, pAllocationCallbacks);
+    if (pUnaligned == NULL) {
+        return NULL;
+    }
+
+    pAligned = (void*)(((ma_uintptr)pUnaligned + extraBytes) & ~((ma_uintptr)(alignment-1)));
+    ((void**)pAligned)[-1] = pUnaligned;
+
+    return pAligned;
+}
+
+MA_API void ma_aligned_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_free(((void**)p)[-1], pAllocationCallbacks);
+}
+
+MA_API const char* ma_get_format_name(ma_format format)
+{
+    switch (format)
+    {
+        case ma_format_unknown: return "Unknown";
+        case ma_format_u8:      return "8-bit Unsigned Integer";
+        case ma_format_s16:     return "16-bit Signed Integer";
+        case ma_format_s24:     return "24-bit Signed Integer (Tightly Packed)";
+        case ma_format_s32:     return "32-bit Signed Integer";
+        case ma_format_f32:     return "32-bit IEEE Floating Point";
+        default:                return "Invalid";
+    }
+}
+
+MA_API void ma_blend_f32(float* pOut, float* pInA, float* pInB, float factor, ma_uint32 channels)
+{
+    ma_uint32 i;
+    for (i = 0; i < channels; ++i) {
+        pOut[i] = ma_mix_f32(pInA[i], pInB[i], factor);
+    }
+}
+
+
+MA_API ma_uint32 ma_get_bytes_per_sample(ma_format format)
+{
+    ma_uint32 sizes[] = {
+        0,  /* unknown */
+        1,  /* u8 */
+        2,  /* s16 */
+        3,  /* s24 */
+        4,  /* s32 */
+        4,  /* f32 */
+    };
+    return sizes[format];
+}
+
+
+
+#define MA_DATA_SOURCE_DEFAULT_RANGE_BEG        0
+#define MA_DATA_SOURCE_DEFAULT_RANGE_END        ~((ma_uint64)0)
+#define MA_DATA_SOURCE_DEFAULT_LOOP_POINT_BEG   0
+#define MA_DATA_SOURCE_DEFAULT_LOOP_POINT_END   ~((ma_uint64)0)
+
+MA_API ma_data_source_config ma_data_source_config_init(void)
+{
+    ma_data_source_config config;
+
+    MA_ZERO_OBJECT(&config);
+
+    return config;
+}
+
+
+MA_API ma_result ma_data_source_init(const ma_data_source_config* pConfig, ma_data_source* pDataSource)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDataSourceBase);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDataSourceBase->vtable           = pConfig->vtable;
+    pDataSourceBase->rangeBegInFrames = MA_DATA_SOURCE_DEFAULT_RANGE_BEG;
+    pDataSourceBase->rangeEndInFrames = MA_DATA_SOURCE_DEFAULT_RANGE_END;
+    pDataSourceBase->loopBegInFrames  = MA_DATA_SOURCE_DEFAULT_LOOP_POINT_BEG;
+    pDataSourceBase->loopEndInFrames  = MA_DATA_SOURCE_DEFAULT_LOOP_POINT_END;
+    pDataSourceBase->pCurrent         = pDataSource;    /* Always read from ourself by default. */
+    pDataSourceBase->pNext            = NULL;
+    pDataSourceBase->onGetNext        = NULL;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_data_source_uninit(ma_data_source* pDataSource)
+{
+    if (pDataSource == NULL) {
+        return;
+    }
+
+    /*
+    This is placeholder in case we need this later. Data sources need to call this in their
+    uninitialization routine to ensure things work later on if something is added here.
+    */
+}
+
+static ma_result ma_data_source_resolve_current(ma_data_source* pDataSource, ma_data_source** ppCurrentDataSource)
+{
+    ma_data_source_base* pCurrentDataSource = (ma_data_source_base*)pDataSource;
+
+    MA_ASSERT(pDataSource         != NULL);
+    MA_ASSERT(ppCurrentDataSource != NULL);
+
+    if (pCurrentDataSource->pCurrent == NULL) {
+        /*
+        The current data source is NULL. If we're using this in the context of a chain we need to return NULL
+        here so that we don't end up looping. Otherwise we just return the data source itself.
+        */
+        if (pCurrentDataSource->pNext != NULL || pCurrentDataSource->onGetNext != NULL) {
+            pCurrentDataSource = NULL;
+        } else {
+            pCurrentDataSource = (ma_data_source_base*)pDataSource; /* Not being used in a chain. Make sure we just always read from the data source itself at all times. */
+        }
+    } else {
+        pCurrentDataSource = (ma_data_source_base*)pCurrentDataSource->pCurrent;
+    }
+
+    *ppCurrentDataSource = pCurrentDataSource;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_data_source_read_pcm_frames_within_range(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+    ma_result result;
+    ma_uint64 framesRead = 0;
+    ma_bool32 loop = ma_data_source_is_looping(pDataSource);
+
+    if (pDataSourceBase == NULL) {
+        return MA_AT_END;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSourceBase->vtable->flags & MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT) != 0 || (pDataSourceBase->rangeEndInFrames == ~((ma_uint64)0) && (pDataSourceBase->loopEndInFrames == ~((ma_uint64)0) || loop == MA_FALSE))) {
+        /* Either the data source is self-managing the range, or no range is set - just read like normal. The data source itself will tell us when the end is reached. */
+        result = pDataSourceBase->vtable->onRead(pDataSourceBase, pFramesOut, frameCount, &framesRead);
+    } else {
+        /* Need to clamp to within the range. */
+        ma_uint64 relativeCursor;
+        ma_uint64 absoluteCursor;
+
+        result = ma_data_source_get_cursor_in_pcm_frames(pDataSourceBase, &relativeCursor);
+        if (result != MA_SUCCESS) {
+            /* Failed to retrieve the cursor. Cannot read within a range or loop points. Just read like normal - this may happen for things like noise data sources where it doesn't really matter. */
+            result = pDataSourceBase->vtable->onRead(pDataSourceBase, pFramesOut, frameCount, &framesRead);
+        } else {
+            ma_uint64 rangeBeg;
+            ma_uint64 rangeEnd;
+
+            /* We have the cursor. We need to make sure we don't read beyond our range. */
+            rangeBeg = pDataSourceBase->rangeBegInFrames;
+            rangeEnd = pDataSourceBase->rangeEndInFrames;
+
+            absoluteCursor = rangeBeg + relativeCursor;
+
+            /* If looping, make sure we're within range. */
+            if (loop) {
+                if (pDataSourceBase->loopEndInFrames != ~((ma_uint64)0)) {
+                    rangeEnd = ma_min(rangeEnd, pDataSourceBase->rangeBegInFrames + pDataSourceBase->loopEndInFrames);
+                }
+            }
+
+            if (frameCount > (rangeEnd - absoluteCursor) && rangeEnd != ~((ma_uint64)0)) {
+                frameCount = (rangeEnd - absoluteCursor);
+            }
+
+            /*
+            If the cursor is sitting on the end of the range the frame count will be set to 0 which can
+            result in MA_INVALID_ARGS. In this case, we don't want to try reading, but instead return
+            MA_AT_END so the higher level function can know about it.
+            */
+            if (frameCount > 0) {
+                result = pDataSourceBase->vtable->onRead(pDataSourceBase, pFramesOut, frameCount, &framesRead);
+            } else {
+                result = MA_AT_END; /* The cursor is sitting on the end of the range which means we're at the end. */
+            }
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = framesRead;
+    }
+
+    /* We need to make sure MA_AT_END is returned if we hit the end of the range. */
+    if (result == MA_SUCCESS && framesRead == 0) {
+        result  = MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_data_source_read_pcm_frames(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+    ma_data_source_base* pCurrentDataSource;
+    void* pRunningFramesOut = pFramesOut;
+    ma_uint64 totalFramesProcessed = 0;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 emptyLoopCounter = 0; /* Keeps track of how many times 0 frames have been read. For infinite loop detection of sounds with no audio data. */
+    ma_bool32 loop;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDataSourceBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    loop = ma_data_source_is_looping(pDataSource);
+
+    /*
+    We need to know the data format so we can advance the output buffer as we read frames. If this
+    fails, chaining will not work and we'll just read as much as we can from the current source.
+    */
+    if (ma_data_source_get_data_format(pDataSource, &format, &channels, NULL, NULL, 0) != MA_SUCCESS) {
+        result = ma_data_source_resolve_current(pDataSource, (ma_data_source**)&pCurrentDataSource);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        return ma_data_source_read_pcm_frames_within_range(pCurrentDataSource, pFramesOut, frameCount, pFramesRead);
+    }
+
+    /*
+    Looping is a bit of a special case. When the `loop` argument is true, chaining will not work and
+    only the current data source will be read from.
+    */
+
+    /* Keep reading until we've read as many frames as possible. */
+    while (totalFramesProcessed < frameCount) {
+        ma_uint64 framesProcessed;
+        ma_uint64 framesRemaining = frameCount - totalFramesProcessed;
+
+        /* We need to resolve the data source that we'll actually be reading from. */
+        result = ma_data_source_resolve_current(pDataSource, (ma_data_source**)&pCurrentDataSource);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        if (pCurrentDataSource == NULL) {
+            break;
+        }
+
+        result = ma_data_source_read_pcm_frames_within_range(pCurrentDataSource, pRunningFramesOut, framesRemaining, &framesProcessed);
+        totalFramesProcessed += framesProcessed;
+
+        /*
+        If we encounted an error from the read callback, make sure it's propagated to the caller. The caller may need to know whether or not MA_BUSY is returned which is
+        not necessarily considered an error.
+        */
+        if (result != MA_SUCCESS && result != MA_AT_END) {
+            break;
+        }
+
+        /*
+        We can determine if we've reached the end by checking if ma_data_source_read_pcm_frames_within_range() returned
+        MA_AT_END. To loop back to the start, all we need to do is seek back to the first frame.
+        */
+        if (result == MA_AT_END) {
+            /*
+            The result needs to be reset back to MA_SUCCESS (from MA_AT_END) so that we don't
+            accidentally return MA_AT_END when data has been read in prior loop iterations. at the
+            end of this function, the result will be checked for MA_SUCCESS, and if the total
+            number of frames processed is 0, will be explicitly set to MA_AT_END.
+            */
+            result = MA_SUCCESS;
+
+            /*
+            We reached the end. If we're looping, we just loop back to the start of the current
+            data source. If we're not looping we need to check if we have another in the chain, and
+            if so, switch to it.
+            */
+            if (loop) {
+                if (framesProcessed == 0) {
+                    emptyLoopCounter += 1;
+                    if (emptyLoopCounter > 1) {
+                        break;  /* Infinite loop detected. Get out. */
+                    }
+                } else {
+                    emptyLoopCounter = 0;
+                }
+
+                result = ma_data_source_seek_to_pcm_frame(pCurrentDataSource, pCurrentDataSource->loopBegInFrames);
+                if (result != MA_SUCCESS) {
+                    break;  /* Failed to loop. Abort. */
+                }
+
+                /* Don't return MA_AT_END for looping sounds. */
+                result = MA_SUCCESS;
+            } else {
+                if (pCurrentDataSource->pNext != NULL) {
+                    pDataSourceBase->pCurrent = pCurrentDataSource->pNext;
+                } else if (pCurrentDataSource->onGetNext != NULL) {
+                    pDataSourceBase->pCurrent = pCurrentDataSource->onGetNext(pCurrentDataSource);
+                    if (pDataSourceBase->pCurrent == NULL) {
+                        break;  /* Our callback did not return a next data source. We're done. */
+                    }
+                } else {
+                    /* Reached the end of the chain. We're done. */
+                    break;
+                }
+
+                /* The next data source needs to be rewound to ensure data is read in looping scenarios. */
+                result = ma_data_source_seek_to_pcm_frame(pDataSourceBase->pCurrent, 0);
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+            }
+        }
+
+        if (pRunningFramesOut != NULL) {
+            pRunningFramesOut = ma_offset_ptr(pRunningFramesOut, framesProcessed * ma_get_bytes_per_frame(format, channels));
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesProcessed;
+    }
+
+    MA_ASSERT(!(result == MA_AT_END && totalFramesProcessed > 0));  /* We should never be returning MA_AT_END if we read some data. */
+
+    if (result == MA_SUCCESS && totalFramesProcessed == 0) {
+        result  = MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_data_source_seek_pcm_frames(ma_data_source* pDataSource, ma_uint64 frameCount, ma_uint64* pFramesSeeked)
+{
+    return ma_data_source_read_pcm_frames(pDataSource, NULL, frameCount, pFramesSeeked);
+}
+
+MA_API ma_result ma_data_source_seek_to_pcm_frame(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSourceBase == NULL) {
+        return MA_SUCCESS;
+    }
+
+    if (pDataSourceBase->vtable->onSeek == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    if (frameIndex > pDataSourceBase->rangeEndInFrames) {
+        return MA_INVALID_OPERATION;    /* Trying to seek to far forward. */
+    }
+
+    return pDataSourceBase->vtable->onSeek(pDataSource, pDataSourceBase->rangeBegInFrames + frameIndex);
+}
+
+MA_API ma_result ma_data_source_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+    ma_result result;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+
+    /* Initialize to defaults for safety just in case the data source does not implement this callback. */
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pDataSourceBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDataSourceBase->vtable->onGetDataFormat == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    result = pDataSourceBase->vtable->onGetDataFormat(pDataSource, &format, &channels, &sampleRate, pChannelMap, channelMapCap);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = format;
+    }
+    if (pChannels != NULL) {
+        *pChannels = channels;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = sampleRate;
+    }
+
+    /* Channel map was passed in directly to the callback. This is safe due to the channelMapCap parameter. */
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_source_get_cursor_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+    ma_result result;
+    ma_uint64 cursor;
+
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    if (pDataSourceBase == NULL) {
+        return MA_SUCCESS;
+    }
+
+    if (pDataSourceBase->vtable->onGetCursor == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    result = pDataSourceBase->vtable->onGetCursor(pDataSourceBase, &cursor);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* The cursor needs to be made relative to the start of the range. */
+    if (cursor < pDataSourceBase->rangeBegInFrames) {   /* Safety check so we don't return some huge number. */
+        *pCursor = 0;
+    } else {
+        *pCursor = cursor - pDataSourceBase->rangeBegInFrames;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_source_get_length_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    if (pDataSourceBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    If we have a range defined we'll use that to determine the length. This is one of rare times
+    where we'll actually trust the caller. If they've set the range, I think it's mostly safe to
+    assume they've set it based on some higher level knowledge of the structure of the sound bank.
+    */
+    if (pDataSourceBase->rangeEndInFrames != ~((ma_uint64)0)) {
+        *pLength = pDataSourceBase->rangeEndInFrames - pDataSourceBase->rangeBegInFrames;
+        return MA_SUCCESS;
+    }
+
+    /*
+    Getting here means a range is not defined so we'll need to get the data source itself to tell
+    us the length.
+    */
+    if (pDataSourceBase->vtable->onGetLength == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pDataSourceBase->vtable->onGetLength(pDataSource, pLength);
+}
+
+MA_API ma_result ma_data_source_get_cursor_in_seconds(ma_data_source* pDataSource, float* pCursor)
+{
+    ma_result result;
+    ma_uint64 cursorInPCMFrames;
+    ma_uint32 sampleRate;
+
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    result = ma_data_source_get_cursor_in_pcm_frames(pDataSource, &cursorInPCMFrames);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_data_source_get_data_format(pDataSource, NULL, NULL, &sampleRate, NULL, 0);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* VC6 does not support division of unsigned 64-bit integers with floating point numbers. Need to use a signed number. This shouldn't effect anything in practice. */
+    *pCursor = (ma_int64)cursorInPCMFrames / (float)sampleRate;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_source_get_length_in_seconds(ma_data_source* pDataSource, float* pLength)
+{
+    ma_result result;
+    ma_uint64 lengthInPCMFrames;
+    ma_uint32 sampleRate;
+
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    result = ma_data_source_get_length_in_pcm_frames(pDataSource, &lengthInPCMFrames);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_data_source_get_data_format(pDataSource, NULL, NULL, &sampleRate, NULL, 0);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* VC6 does not support division of unsigned 64-bit integers with floating point numbers. Need to use a signed number. This shouldn't effect anything in practice. */
+    *pLength = (ma_int64)lengthInPCMFrames / (float)sampleRate;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_data_source_set_looping(ma_data_source* pDataSource, ma_bool32 isLooping)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_exchange_32(&pDataSourceBase->isLooping, isLooping);
+
+    /* If there's no callback for this just treat it as a successful no-op. */
+    if (pDataSourceBase->vtable->onSetLooping == NULL) {
+        return MA_SUCCESS;
+    }
+
+    return pDataSourceBase->vtable->onSetLooping(pDataSource, isLooping);
+}
+
+MA_API ma_bool32 ma_data_source_is_looping(const ma_data_source* pDataSource)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_atomic_load_32(&pDataSourceBase->isLooping);
+}
+
+MA_API ma_result ma_data_source_set_range_in_pcm_frames(ma_data_source* pDataSource, ma_uint64 rangeBegInFrames, ma_uint64 rangeEndInFrames)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+    ma_result result;
+    ma_uint64 relativeCursor;
+    ma_uint64 absoluteCursor;
+    ma_bool32 doSeekAdjustment = MA_FALSE;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (rangeEndInFrames < rangeBegInFrames) {
+        return MA_INVALID_ARGS; /* The end of the range must come after the beginning. */
+    }
+
+    /*
+    We may need to adjust the position of the cursor to ensure it's clamped to the range. Grab it now
+    so we can calculate it's absolute position before we change the range.
+    */
+    result = ma_data_source_get_cursor_in_pcm_frames(pDataSource, &relativeCursor);
+    if (result == MA_SUCCESS) {
+        doSeekAdjustment = MA_TRUE;
+        absoluteCursor = relativeCursor + pDataSourceBase->rangeBegInFrames;
+    } else {
+        /*
+        We couldn't get the position of the cursor. It probably means the data source has no notion
+        of a cursor. We'll just leave it at position 0. Don't treat this as an error.
+        */
+        doSeekAdjustment = MA_FALSE;
+        relativeCursor = 0;
+        absoluteCursor = 0;
+    }
+
+    pDataSourceBase->rangeBegInFrames = rangeBegInFrames;
+    pDataSourceBase->rangeEndInFrames = rangeEndInFrames;
+
+    /*
+    The commented out logic below was intended to maintain loop points in response to a change in the
+    range. However, this is not useful because it results in the sound breaking when you move the range
+    outside of the old loop points. I'm simplifying this by simply resetting the loop points. The
+    caller is expected to update their loop points if they change the range.
+
+    In practice this should be mostly a non-issue because the majority of the time the range will be
+    set once right after initialization.
+    */
+    pDataSourceBase->loopBegInFrames = 0;
+    pDataSourceBase->loopEndInFrames = ~((ma_uint64)0);
+
+
+    /*
+    Seek to within range. Note that our seek positions here are relative to the new range. We don't want
+    do do this if we failed to retrieve the cursor earlier on because it probably means the data source
+    has no notion of a cursor. In practice the seek would probably fail (which we silently ignore), but
+    I'm just not even going to attempt it.
+    */
+    if (doSeekAdjustment) {
+        if (absoluteCursor < rangeBegInFrames) {
+            ma_data_source_seek_to_pcm_frame(pDataSource, 0);
+        } else if (absoluteCursor > rangeEndInFrames) {
+            ma_data_source_seek_to_pcm_frame(pDataSource, rangeEndInFrames - rangeBegInFrames);
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_data_source_get_range_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pRangeBegInFrames, ma_uint64* pRangeEndInFrames)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return;
+    }
+
+    if (pRangeBegInFrames != NULL) {
+        *pRangeBegInFrames = pDataSourceBase->rangeBegInFrames;
+    }
+
+    if (pRangeEndInFrames != NULL) {
+        *pRangeEndInFrames = pDataSourceBase->rangeEndInFrames;
+    }
+}
+
+MA_API ma_result ma_data_source_set_loop_point_in_pcm_frames(ma_data_source* pDataSource, ma_uint64 loopBegInFrames, ma_uint64 loopEndInFrames)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (loopEndInFrames < loopBegInFrames) {
+        return MA_INVALID_ARGS; /* The end of the loop point must come after the beginning. */
+    }
+
+    if (loopEndInFrames > pDataSourceBase->rangeEndInFrames && loopEndInFrames != ~((ma_uint64)0)) {
+        return MA_INVALID_ARGS; /* The end of the loop point must not go beyond the range. */
+    }
+
+    pDataSourceBase->loopBegInFrames = loopBegInFrames;
+    pDataSourceBase->loopEndInFrames = loopEndInFrames;
+
+    /* The end cannot exceed the range. */
+    if (pDataSourceBase->loopEndInFrames > (pDataSourceBase->rangeEndInFrames - pDataSourceBase->rangeBegInFrames) && pDataSourceBase->loopEndInFrames != ~((ma_uint64)0)) {
+        pDataSourceBase->loopEndInFrames = (pDataSourceBase->rangeEndInFrames - pDataSourceBase->rangeBegInFrames);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_data_source_get_loop_point_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pLoopBegInFrames, ma_uint64* pLoopEndInFrames)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return;
+    }
+
+    if (pLoopBegInFrames != NULL) {
+        *pLoopBegInFrames = pDataSourceBase->loopBegInFrames;
+    }
+
+    if (pLoopEndInFrames != NULL) {
+        *pLoopEndInFrames = pDataSourceBase->loopEndInFrames;
+    }
+}
+
+MA_API ma_result ma_data_source_set_current(ma_data_source* pDataSource, ma_data_source* pCurrentDataSource)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDataSourceBase->pCurrent = pCurrentDataSource;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_data_source* ma_data_source_get_current(const ma_data_source* pDataSource)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return NULL;
+    }
+
+    return pDataSourceBase->pCurrent;
+}
+
+MA_API ma_result ma_data_source_set_next(ma_data_source* pDataSource, ma_data_source* pNextDataSource)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDataSourceBase->pNext = pNextDataSource;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_data_source* ma_data_source_get_next(const ma_data_source* pDataSource)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return NULL;
+    }
+
+    return pDataSourceBase->pNext;
+}
+
+MA_API ma_result ma_data_source_set_next_callback(ma_data_source* pDataSource, ma_data_source_get_next_proc onGetNext)
+{
+    ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDataSourceBase->onGetNext = onGetNext;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_data_source_get_next_proc ma_data_source_get_next_callback(const ma_data_source* pDataSource)
+{
+    const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
+
+    if (pDataSource == NULL) {
+        return NULL;
+    }
+
+    return pDataSourceBase->onGetNext;
+}
+
+
+static ma_result ma_audio_buffer_ref__data_source_on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_audio_buffer_ref* pAudioBufferRef = (ma_audio_buffer_ref*)pDataSource;
+    ma_uint64 framesRead = ma_audio_buffer_ref_read_pcm_frames(pAudioBufferRef, pFramesOut, frameCount, MA_FALSE);
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = framesRead;
+    }
+
+    if (framesRead < frameCount || framesRead == 0) {
+        return MA_AT_END;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_audio_buffer_ref__data_source_on_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_audio_buffer_ref_seek_to_pcm_frame((ma_audio_buffer_ref*)pDataSource, frameIndex);
+}
+
+static ma_result ma_audio_buffer_ref__data_source_on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_audio_buffer_ref* pAudioBufferRef = (ma_audio_buffer_ref*)pDataSource;
+
+    *pFormat     = pAudioBufferRef->format;
+    *pChannels   = pAudioBufferRef->channels;
+    *pSampleRate = pAudioBufferRef->sampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pAudioBufferRef->channels);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_audio_buffer_ref__data_source_on_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    ma_audio_buffer_ref* pAudioBufferRef = (ma_audio_buffer_ref*)pDataSource;
+
+    *pCursor = pAudioBufferRef->cursor;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_audio_buffer_ref__data_source_on_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    ma_audio_buffer_ref* pAudioBufferRef = (ma_audio_buffer_ref*)pDataSource;
+
+    *pLength = pAudioBufferRef->sizeInFrames;
+
+    return MA_SUCCESS;
+}
+
+static ma_data_source_vtable g_ma_audio_buffer_ref_data_source_vtable =
+{
+    ma_audio_buffer_ref__data_source_on_read,
+    ma_audio_buffer_ref__data_source_on_seek,
+    ma_audio_buffer_ref__data_source_on_get_data_format,
+    ma_audio_buffer_ref__data_source_on_get_cursor,
+    ma_audio_buffer_ref__data_source_on_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+MA_API ma_result ma_audio_buffer_ref_init(ma_format format, ma_uint32 channels, const void* pData, ma_uint64 sizeInFrames, ma_audio_buffer_ref* pAudioBufferRef)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pAudioBufferRef);
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_audio_buffer_ref_data_source_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pAudioBufferRef->ds);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pAudioBufferRef->format       = format;
+    pAudioBufferRef->channels     = channels;
+    pAudioBufferRef->sampleRate   = 0;  /* TODO: Version 0.12. Set this to sampleRate. */
+    pAudioBufferRef->cursor       = 0;
+    pAudioBufferRef->sizeInFrames = sizeInFrames;
+    pAudioBufferRef->pData        = pData;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_audio_buffer_ref_uninit(ma_audio_buffer_ref* pAudioBufferRef)
+{
+    if (pAudioBufferRef == NULL) {
+        return;
+    }
+
+    ma_data_source_uninit(&pAudioBufferRef->ds);
+}
+
+MA_API ma_result ma_audio_buffer_ref_set_data(ma_audio_buffer_ref* pAudioBufferRef, const void* pData, ma_uint64 sizeInFrames)
+{
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pAudioBufferRef->cursor       = 0;
+    pAudioBufferRef->sizeInFrames = sizeInFrames;
+    pAudioBufferRef->pData        = pData;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint64 ma_audio_buffer_ref_read_pcm_frames(ma_audio_buffer_ref* pAudioBufferRef, void* pFramesOut, ma_uint64 frameCount, ma_bool32 loop)
+{
+    ma_uint64 totalFramesRead = 0;
+
+    if (pAudioBufferRef == NULL) {
+        return 0;
+    }
+
+    if (frameCount == 0) {
+        return 0;
+    }
+
+    while (totalFramesRead < frameCount) {
+        ma_uint64 framesAvailable = pAudioBufferRef->sizeInFrames - pAudioBufferRef->cursor;
+        ma_uint64 framesRemaining = frameCount - totalFramesRead;
+        ma_uint64 framesToRead;
+
+        framesToRead = framesRemaining;
+        if (framesToRead > framesAvailable) {
+            framesToRead = framesAvailable;
+        }
+
+        if (pFramesOut != NULL) {
+            ma_copy_pcm_frames(ma_offset_ptr(pFramesOut, totalFramesRead * ma_get_bytes_per_frame(pAudioBufferRef->format, pAudioBufferRef->channels)), ma_offset_ptr(pAudioBufferRef->pData, pAudioBufferRef->cursor * ma_get_bytes_per_frame(pAudioBufferRef->format, pAudioBufferRef->channels)), framesToRead, pAudioBufferRef->format, pAudioBufferRef->channels);
+        }
+
+        totalFramesRead += framesToRead;
+
+        pAudioBufferRef->cursor += framesToRead;
+        if (pAudioBufferRef->cursor == pAudioBufferRef->sizeInFrames) {
+            if (loop) {
+                pAudioBufferRef->cursor = 0;
+            } else {
+                break;  /* We've reached the end and we're not looping. Done. */
+            }
+        }
+
+        MA_ASSERT(pAudioBufferRef->cursor < pAudioBufferRef->sizeInFrames);
+    }
+
+    return totalFramesRead;
+}
+
+MA_API ma_result ma_audio_buffer_ref_seek_to_pcm_frame(ma_audio_buffer_ref* pAudioBufferRef, ma_uint64 frameIndex)
+{
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (frameIndex > pAudioBufferRef->sizeInFrames) {
+        return MA_INVALID_ARGS;
+    }
+
+    pAudioBufferRef->cursor = (size_t)frameIndex;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_audio_buffer_ref_map(ma_audio_buffer_ref* pAudioBufferRef, void** ppFramesOut, ma_uint64* pFrameCount)
+{
+    ma_uint64 framesAvailable;
+    ma_uint64 frameCount = 0;
+
+    if (ppFramesOut != NULL) {
+        *ppFramesOut = NULL;    /* Safety. */
+    }
+
+    if (pFrameCount != NULL) {
+        frameCount = *pFrameCount;
+        *pFrameCount = 0;       /* Safety. */
+    }
+
+    if (pAudioBufferRef == NULL || ppFramesOut == NULL || pFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    framesAvailable = pAudioBufferRef->sizeInFrames - pAudioBufferRef->cursor;
+    if (frameCount > framesAvailable) {
+        frameCount = framesAvailable;
+    }
+
+    *ppFramesOut = ma_offset_ptr(pAudioBufferRef->pData, pAudioBufferRef->cursor * ma_get_bytes_per_frame(pAudioBufferRef->format, pAudioBufferRef->channels));
+    *pFrameCount = frameCount;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_audio_buffer_ref_unmap(ma_audio_buffer_ref* pAudioBufferRef, ma_uint64 frameCount)
+{
+    ma_uint64 framesAvailable;
+
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    framesAvailable = pAudioBufferRef->sizeInFrames - pAudioBufferRef->cursor;
+    if (frameCount > framesAvailable) {
+        return MA_INVALID_ARGS;   /* The frame count was too big. This should never happen in an unmapping. Need to make sure the caller is aware of this. */
+    }
+
+    pAudioBufferRef->cursor += frameCount;
+
+    if (pAudioBufferRef->cursor == pAudioBufferRef->sizeInFrames) {
+        return MA_AT_END;   /* Successful. Need to tell the caller that the end has been reached so that it can loop if desired. */
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+MA_API ma_bool32 ma_audio_buffer_ref_at_end(const ma_audio_buffer_ref* pAudioBufferRef)
+{
+    if (pAudioBufferRef == NULL) {
+        return MA_FALSE;
+    }
+
+    return pAudioBufferRef->cursor == pAudioBufferRef->sizeInFrames;
+}
+
+MA_API ma_result ma_audio_buffer_ref_get_cursor_in_pcm_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = pAudioBufferRef->cursor;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_audio_buffer_ref_get_length_in_pcm_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = pAudioBufferRef->sizeInFrames;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_audio_buffer_ref_get_available_frames(const ma_audio_buffer_ref* pAudioBufferRef, ma_uint64* pAvailableFrames)
+{
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pAudioBufferRef == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pAudioBufferRef->sizeInFrames <= pAudioBufferRef->cursor) {
+        *pAvailableFrames = 0;
+    } else {
+        *pAvailableFrames = pAudioBufferRef->sizeInFrames - pAudioBufferRef->cursor;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+
+MA_API ma_audio_buffer_config ma_audio_buffer_config_init(ma_format format, ma_uint32 channels, ma_uint64 sizeInFrames, const void* pData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_audio_buffer_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format       = format;
+    config.channels     = channels;
+    config.sampleRate   = 0;    /* TODO: Version 0.12. Set this to sampleRate. */
+    config.sizeInFrames = sizeInFrames;
+    config.pData        = pData;
+    ma_allocation_callbacks_init_copy(&config.allocationCallbacks, pAllocationCallbacks);
+
+    return config;
+}
+
+static ma_result ma_audio_buffer_init_ex(const ma_audio_buffer_config* pConfig, ma_bool32 doCopy, ma_audio_buffer* pAudioBuffer)
+{
+    ma_result result;
+
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_MEMORY(pAudioBuffer, sizeof(*pAudioBuffer) - sizeof(pAudioBuffer->_pExtraData));   /* Safety. Don't overwrite the extra data. */
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->sizeInFrames == 0) {
+        return MA_INVALID_ARGS; /* Not allowing buffer sizes of 0 frames. */
+    }
+
+    result = ma_audio_buffer_ref_init(pConfig->format, pConfig->channels, NULL, 0, &pAudioBuffer->ref);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* TODO: Version 0.12. Set this in ma_audio_buffer_ref_init() instead of here. */
+    pAudioBuffer->ref.sampleRate = pConfig->sampleRate;
+
+    ma_allocation_callbacks_init_copy(&pAudioBuffer->allocationCallbacks, &pConfig->allocationCallbacks);
+
+    if (doCopy) {
+        ma_uint64 allocationSizeInBytes;
+        void* pData;
+
+        allocationSizeInBytes = pConfig->sizeInFrames * ma_get_bytes_per_frame(pConfig->format, pConfig->channels);
+        if (allocationSizeInBytes > MA_SIZE_MAX) {
+            return MA_OUT_OF_MEMORY;    /* Too big. */
+        }
+
+        pData = ma_malloc((size_t)allocationSizeInBytes, &pAudioBuffer->allocationCallbacks);   /* Safe cast to size_t. */
+        if (pData == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        if (pConfig->pData != NULL) {
+            ma_copy_pcm_frames(pData, pConfig->pData, pConfig->sizeInFrames, pConfig->format, pConfig->channels);
+        } else {
+            ma_silence_pcm_frames(pData, pConfig->sizeInFrames, pConfig->format, pConfig->channels);
+        }
+
+        ma_audio_buffer_ref_set_data(&pAudioBuffer->ref, pData, pConfig->sizeInFrames);
+        pAudioBuffer->ownsData = MA_TRUE;
+    } else {
+        ma_audio_buffer_ref_set_data(&pAudioBuffer->ref, pConfig->pData, pConfig->sizeInFrames);
+        pAudioBuffer->ownsData = MA_FALSE;
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_audio_buffer_uninit_ex(ma_audio_buffer* pAudioBuffer, ma_bool32 doFree)
+{
+    if (pAudioBuffer == NULL) {
+        return;
+    }
+
+    if (pAudioBuffer->ownsData && pAudioBuffer->ref.pData != &pAudioBuffer->_pExtraData[0]) {
+        ma_free((void*)pAudioBuffer->ref.pData, &pAudioBuffer->allocationCallbacks);    /* Naugty const cast, but OK in this case since we've guarded it with the ownsData check. */
+    }
+
+    if (doFree) {
+        ma_free(pAudioBuffer, &pAudioBuffer->allocationCallbacks);
+    }
+
+    ma_audio_buffer_ref_uninit(&pAudioBuffer->ref);
+}
+
+MA_API ma_result ma_audio_buffer_init(const ma_audio_buffer_config* pConfig, ma_audio_buffer* pAudioBuffer)
+{
+    return ma_audio_buffer_init_ex(pConfig, MA_FALSE, pAudioBuffer);
+}
+
+MA_API ma_result ma_audio_buffer_init_copy(const ma_audio_buffer_config* pConfig, ma_audio_buffer* pAudioBuffer)
+{
+    return ma_audio_buffer_init_ex(pConfig, MA_TRUE, pAudioBuffer);
+}
+
+MA_API ma_result ma_audio_buffer_alloc_and_init(const ma_audio_buffer_config* pConfig, ma_audio_buffer** ppAudioBuffer)
+{
+    ma_result result;
+    ma_audio_buffer* pAudioBuffer;
+    ma_audio_buffer_config innerConfig; /* We'll be making some changes to the config, so need to make a copy. */
+    ma_uint64 allocationSizeInBytes;
+
+    if (ppAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *ppAudioBuffer = NULL;  /* Safety. */
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    innerConfig = *pConfig;
+    ma_allocation_callbacks_init_copy(&innerConfig.allocationCallbacks, &pConfig->allocationCallbacks);
+
+    allocationSizeInBytes = sizeof(*pAudioBuffer) - sizeof(pAudioBuffer->_pExtraData) + (pConfig->sizeInFrames * ma_get_bytes_per_frame(pConfig->format, pConfig->channels));
+    if (allocationSizeInBytes > MA_SIZE_MAX) {
+        return MA_OUT_OF_MEMORY;    /* Too big. */
+    }
+
+    pAudioBuffer = (ma_audio_buffer*)ma_malloc((size_t)allocationSizeInBytes, &innerConfig.allocationCallbacks);  /* Safe cast to size_t. */
+    if (pAudioBuffer == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    if (pConfig->pData != NULL) {
+        ma_copy_pcm_frames(&pAudioBuffer->_pExtraData[0], pConfig->pData, pConfig->sizeInFrames, pConfig->format, pConfig->channels);
+    } else {
+        ma_silence_pcm_frames(&pAudioBuffer->_pExtraData[0], pConfig->sizeInFrames, pConfig->format, pConfig->channels);
+    }
+
+    innerConfig.pData = &pAudioBuffer->_pExtraData[0];
+
+    result = ma_audio_buffer_init_ex(&innerConfig, MA_FALSE, pAudioBuffer);
+    if (result != MA_SUCCESS) {
+        ma_free(pAudioBuffer, &innerConfig.allocationCallbacks);
+        return result;
+    }
+
+    *ppAudioBuffer = pAudioBuffer;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_audio_buffer_uninit(ma_audio_buffer* pAudioBuffer)
+{
+    ma_audio_buffer_uninit_ex(pAudioBuffer, MA_FALSE);
+}
+
+MA_API void ma_audio_buffer_uninit_and_free(ma_audio_buffer* pAudioBuffer)
+{
+    ma_audio_buffer_uninit_ex(pAudioBuffer, MA_TRUE);
+}
+
+MA_API ma_uint64 ma_audio_buffer_read_pcm_frames(ma_audio_buffer* pAudioBuffer, void* pFramesOut, ma_uint64 frameCount, ma_bool32 loop)
+{
+    if (pAudioBuffer == NULL) {
+        return 0;
+    }
+
+    return ma_audio_buffer_ref_read_pcm_frames(&pAudioBuffer->ref, pFramesOut, frameCount, loop);
+}
+
+MA_API ma_result ma_audio_buffer_seek_to_pcm_frame(ma_audio_buffer* pAudioBuffer, ma_uint64 frameIndex)
+{
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_seek_to_pcm_frame(&pAudioBuffer->ref, frameIndex);
+}
+
+MA_API ma_result ma_audio_buffer_map(ma_audio_buffer* pAudioBuffer, void** ppFramesOut, ma_uint64* pFrameCount)
+{
+    if (ppFramesOut != NULL) {
+        *ppFramesOut = NULL;    /* Safety. */
+    }
+
+    if (pAudioBuffer == NULL) {
+        if (pFrameCount != NULL) {
+            *pFrameCount = 0;
+        }
+
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_map(&pAudioBuffer->ref, ppFramesOut, pFrameCount);
+}
+
+MA_API ma_result ma_audio_buffer_unmap(ma_audio_buffer* pAudioBuffer, ma_uint64 frameCount)
+{
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_unmap(&pAudioBuffer->ref, frameCount);
+}
+
+MA_API ma_bool32 ma_audio_buffer_at_end(const ma_audio_buffer* pAudioBuffer)
+{
+    if (pAudioBuffer == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_audio_buffer_ref_at_end(&pAudioBuffer->ref);
+}
+
+MA_API ma_result ma_audio_buffer_get_cursor_in_pcm_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pCursor)
+{
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_get_cursor_in_pcm_frames(&pAudioBuffer->ref, pCursor);
+}
+
+MA_API ma_result ma_audio_buffer_get_length_in_pcm_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pLength)
+{
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_get_length_in_pcm_frames(&pAudioBuffer->ref, pLength);
+}
+
+MA_API ma_result ma_audio_buffer_get_available_frames(const ma_audio_buffer* pAudioBuffer, ma_uint64* pAvailableFrames)
+{
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_audio_buffer_ref_get_available_frames(&pAudioBuffer->ref, pAvailableFrames);
+}
+
+
+
+
+
+MA_API ma_result ma_paged_audio_buffer_data_init(ma_format format, ma_uint32 channels, ma_paged_audio_buffer_data* pData)
+{
+    if (pData == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pData);
+
+    pData->format   = format;
+    pData->channels = channels;
+    pData->pTail    = &pData->head;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_paged_audio_buffer_data_uninit(ma_paged_audio_buffer_data* pData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_paged_audio_buffer_page* pPage;
+
+    if (pData == NULL) {
+        return;
+    }
+
+    /* All pages need to be freed. */
+    pPage = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pData->head.pNext);
+    while (pPage != NULL) {
+        ma_paged_audio_buffer_page* pNext = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pPage->pNext);
+
+        ma_free(pPage, pAllocationCallbacks);
+        pPage = pNext;
+    }
+}
+
+MA_API ma_paged_audio_buffer_page* ma_paged_audio_buffer_data_get_head(ma_paged_audio_buffer_data* pData)
+{
+    if (pData == NULL) {
+        return NULL;
+    }
+
+    return &pData->head;
+}
+
+MA_API ma_paged_audio_buffer_page* ma_paged_audio_buffer_data_get_tail(ma_paged_audio_buffer_data* pData)
+{
+    if (pData == NULL) {
+        return NULL;
+    }
+
+    return pData->pTail;
+}
+
+MA_API ma_result ma_paged_audio_buffer_data_get_length_in_pcm_frames(ma_paged_audio_buffer_data* pData, ma_uint64* pLength)
+{
+    ma_paged_audio_buffer_page* pPage;
+
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    if (pData == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Calculate the length from the linked list. */
+    for (pPage = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pData->head.pNext); pPage != NULL; pPage = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pPage->pNext)) {
+        *pLength += pPage->sizeInFrames;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_data_allocate_page(ma_paged_audio_buffer_data* pData, ma_uint64 pageSizeInFrames, const void* pInitialData, const ma_allocation_callbacks* pAllocationCallbacks, ma_paged_audio_buffer_page** ppPage)
+{
+    ma_paged_audio_buffer_page* pPage;
+    ma_uint64 allocationSize;
+
+    if (ppPage == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *ppPage = NULL;
+
+    if (pData == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    allocationSize = sizeof(*pPage) + (pageSizeInFrames * ma_get_bytes_per_frame(pData->format, pData->channels));
+    if (allocationSize > MA_SIZE_MAX) {
+        return MA_OUT_OF_MEMORY;    /* Too big. */
+    }
+
+    pPage = (ma_paged_audio_buffer_page*)ma_malloc((size_t)allocationSize, pAllocationCallbacks);   /* Safe cast to size_t. */
+    if (pPage == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    pPage->pNext = NULL;
+    pPage->sizeInFrames = pageSizeInFrames;
+
+    if (pInitialData != NULL) {
+        ma_copy_pcm_frames(pPage->pAudioData, pInitialData, pageSizeInFrames, pData->format, pData->channels);
+    }
+
+    *ppPage = pPage;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_data_free_page(ma_paged_audio_buffer_data* pData, ma_paged_audio_buffer_page* pPage, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pData == NULL || pPage == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* It's assumed the page is not attached to the list. */
+    ma_free(pPage, pAllocationCallbacks);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_data_append_page(ma_paged_audio_buffer_data* pData, ma_paged_audio_buffer_page* pPage)
+{
+    if (pData == NULL || pPage == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* This function assumes the page has been filled with audio data by this point. As soon as we append, the page will be available for reading. */
+
+    /* First thing to do is update the tail. */
+    for (;;) {
+        ma_paged_audio_buffer_page* pOldTail = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pData->pTail);
+        ma_paged_audio_buffer_page* pNewTail = pPage;
+
+        if (ma_atomic_compare_exchange_weak_ptr((volatile void**)&pData->pTail, (void**)&pOldTail, pNewTail)) {
+            /* Here is where we append the page to the list. After this, the page is attached to the list and ready to be read from. */
+            ma_atomic_exchange_ptr(&pOldTail->pNext, pPage);
+            break;  /* Done. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_data_allocate_and_append_page(ma_paged_audio_buffer_data* pData, ma_uint32 pageSizeInFrames, const void* pInitialData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_result result;
+    ma_paged_audio_buffer_page* pPage;
+
+    result = ma_paged_audio_buffer_data_allocate_page(pData, pageSizeInFrames, pInitialData, pAllocationCallbacks, &pPage);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_paged_audio_buffer_data_append_page(pData, pPage);    /* <-- Should never fail. */
+}
+
+
+MA_API ma_paged_audio_buffer_config ma_paged_audio_buffer_config_init(ma_paged_audio_buffer_data* pData)
+{
+    ma_paged_audio_buffer_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.pData = pData;
+
+    return config;
+}
+
+
+static ma_result ma_paged_audio_buffer__data_source_on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_paged_audio_buffer_read_pcm_frames((ma_paged_audio_buffer*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_paged_audio_buffer__data_source_on_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_paged_audio_buffer_seek_to_pcm_frame((ma_paged_audio_buffer*)pDataSource, frameIndex);
+}
+
+static ma_result ma_paged_audio_buffer__data_source_on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_paged_audio_buffer* pPagedAudioBuffer = (ma_paged_audio_buffer*)pDataSource;
+
+    *pFormat     = pPagedAudioBuffer->pData->format;
+    *pChannels   = pPagedAudioBuffer->pData->channels;
+    *pSampleRate = 0;   /* There is no notion of a sample rate with audio buffers. */
+    ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pPagedAudioBuffer->pData->channels);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_paged_audio_buffer__data_source_on_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_paged_audio_buffer_get_cursor_in_pcm_frames((ma_paged_audio_buffer*)pDataSource, pCursor);
+}
+
+static ma_result ma_paged_audio_buffer__data_source_on_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_paged_audio_buffer_get_length_in_pcm_frames((ma_paged_audio_buffer*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_paged_audio_buffer_data_source_vtable =
+{
+    ma_paged_audio_buffer__data_source_on_read,
+    ma_paged_audio_buffer__data_source_on_seek,
+    ma_paged_audio_buffer__data_source_on_get_data_format,
+    ma_paged_audio_buffer__data_source_on_get_cursor,
+    ma_paged_audio_buffer__data_source_on_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+MA_API ma_result ma_paged_audio_buffer_init(const ma_paged_audio_buffer_config* pConfig, ma_paged_audio_buffer* pPagedAudioBuffer)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pPagedAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pPagedAudioBuffer);
+
+    /* A config is required for the format and channel count. */
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->pData == NULL) {
+        return MA_INVALID_ARGS; /* No underlying data specified. */
+    }
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_paged_audio_buffer_data_source_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pPagedAudioBuffer->ds);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pPagedAudioBuffer->pData          = pConfig->pData;
+    pPagedAudioBuffer->pCurrent       = ma_paged_audio_buffer_data_get_head(pConfig->pData);
+    pPagedAudioBuffer->relativeCursor = 0;
+    pPagedAudioBuffer->absoluteCursor = 0;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_paged_audio_buffer_uninit(ma_paged_audio_buffer* pPagedAudioBuffer)
+{
+    if (pPagedAudioBuffer == NULL) {
+        return;
+    }
+
+    /* Nothing to do. The data needs to be deleted separately. */
+}
+
+MA_API ma_result ma_paged_audio_buffer_read_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 totalFramesRead = 0;
+    ma_format format;
+    ma_uint32 channels;
+
+    if (pPagedAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    format   = pPagedAudioBuffer->pData->format;
+    channels = pPagedAudioBuffer->pData->channels;
+
+    while (totalFramesRead < frameCount) {
+        /* Read from the current page. The buffer should never be in a state where this is NULL. */
+        ma_uint64 framesRemainingInCurrentPage;
+        ma_uint64 framesRemainingToRead = frameCount - totalFramesRead;
+        ma_uint64 framesToReadThisIteration;
+
+        MA_ASSERT(pPagedAudioBuffer->pCurrent != NULL);
+
+        framesRemainingInCurrentPage = pPagedAudioBuffer->pCurrent->sizeInFrames - pPagedAudioBuffer->relativeCursor;
+
+        framesToReadThisIteration = ma_min(framesRemainingInCurrentPage, framesRemainingToRead);
+        ma_copy_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, format, channels), ma_offset_pcm_frames_ptr(pPagedAudioBuffer->pCurrent->pAudioData, pPagedAudioBuffer->relativeCursor, format, channels), framesToReadThisIteration, format, channels);
+        totalFramesRead += framesToReadThisIteration;
+
+        pPagedAudioBuffer->absoluteCursor += framesToReadThisIteration;
+        pPagedAudioBuffer->relativeCursor += framesToReadThisIteration;
+
+        /* Move to the next page if necessary. If there's no more pages, we need to return MA_AT_END. */
+        MA_ASSERT(pPagedAudioBuffer->relativeCursor <= pPagedAudioBuffer->pCurrent->sizeInFrames);
+
+        if (pPagedAudioBuffer->relativeCursor == pPagedAudioBuffer->pCurrent->sizeInFrames) {
+            /* We reached the end of the page. Need to move to the next. If there's no more pages, we're done. */
+            ma_paged_audio_buffer_page* pNext = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pPagedAudioBuffer->pCurrent->pNext);
+            if (pNext == NULL) {
+                result = MA_AT_END;
+                break;  /* We've reached the end. */
+            } else {
+                pPagedAudioBuffer->pCurrent       = pNext;
+                pPagedAudioBuffer->relativeCursor = 0;
+            }
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesRead;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_paged_audio_buffer_seek_to_pcm_frame(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64 frameIndex)
+{
+    if (pPagedAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (frameIndex == pPagedAudioBuffer->absoluteCursor) {
+        return MA_SUCCESS;  /* Nothing to do. */
+    }
+
+    if (frameIndex < pPagedAudioBuffer->absoluteCursor) {
+        /* Moving backwards. Need to move the cursor back to the start, and then move forward. */
+        pPagedAudioBuffer->pCurrent       = ma_paged_audio_buffer_data_get_head(pPagedAudioBuffer->pData);
+        pPagedAudioBuffer->absoluteCursor = 0;
+        pPagedAudioBuffer->relativeCursor = 0;
+
+        /* Fall through to the forward seeking section below. */
+    }
+
+    if (frameIndex > pPagedAudioBuffer->absoluteCursor) {
+        /* Moving forward. */
+        ma_paged_audio_buffer_page* pPage;
+        ma_uint64 runningCursor = 0;
+
+        for (pPage = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&ma_paged_audio_buffer_data_get_head(pPagedAudioBuffer->pData)->pNext); pPage != NULL; pPage = (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(&pPage->pNext)) {
+            ma_uint64 pageRangeBeg = runningCursor;
+            ma_uint64 pageRangeEnd = pageRangeBeg + pPage->sizeInFrames;
+
+            if (frameIndex >= pageRangeBeg) {
+                if (frameIndex < pageRangeEnd || (frameIndex == pageRangeEnd && pPage == (ma_paged_audio_buffer_page*)ma_atomic_load_ptr(ma_paged_audio_buffer_data_get_tail(pPagedAudioBuffer->pData)))) {  /* A small edge case - allow seeking to the very end of the buffer. */
+                    /* We found the page. */
+                    pPagedAudioBuffer->pCurrent       = pPage;
+                    pPagedAudioBuffer->absoluteCursor = frameIndex;
+                    pPagedAudioBuffer->relativeCursor = frameIndex - pageRangeBeg;
+                    return MA_SUCCESS;
+                }
+            }
+
+            runningCursor = pageRangeEnd;
+        }
+
+        /* Getting here means we tried seeking too far forward. Don't change any state. */
+        return MA_BAD_SEEK;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_get_cursor_in_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;   /* Safety. */
+
+    if (pPagedAudioBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = pPagedAudioBuffer->absoluteCursor;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_paged_audio_buffer_get_length_in_pcm_frames(ma_paged_audio_buffer* pPagedAudioBuffer, ma_uint64* pLength)
+{
+    return ma_paged_audio_buffer_data_get_length_in_pcm_frames(pPagedAudioBuffer->pData, pLength);
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+VFS
+
+**************************************************************************************************************************************************************/
+MA_API ma_result ma_vfs_open(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pFile = NULL;
+
+    if (pVFS == NULL || pFilePath == NULL || openMode == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onOpen == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onOpen(pVFS, pFilePath, openMode, pFile);
+}
+
+MA_API ma_result ma_vfs_open_w(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pFile = NULL;
+
+    if (pVFS == NULL || pFilePath == NULL || openMode == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onOpenW == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onOpenW(pVFS, pFilePath, openMode, pFile);
+}
+
+MA_API ma_result ma_vfs_close(ma_vfs* pVFS, ma_vfs_file file)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pVFS == NULL || file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onClose == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onClose(pVFS, file);
+}
+
+MA_API ma_result ma_vfs_read(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+    ma_result result;
+    size_t bytesRead = 0;
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = 0;
+    }
+
+    if (pVFS == NULL || file == NULL || pDst == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onRead == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    result = pCallbacks->onRead(pVFS, file, pDst, sizeInBytes, &bytesRead);
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = bytesRead;
+    }
+
+    if (result == MA_SUCCESS && bytesRead == 0 && sizeInBytes > 0) {
+        result  = MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_vfs_write(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pBytesWritten != NULL) {
+        *pBytesWritten = 0;
+    }
+
+    if (pVFS == NULL || file == NULL || pSrc == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onWrite == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onWrite(pVFS, file, pSrc, sizeInBytes, pBytesWritten);
+}
+
+MA_API ma_result ma_vfs_seek(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pVFS == NULL || file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onSeek == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onSeek(pVFS, file, offset, origin);
+}
+
+MA_API ma_result ma_vfs_tell(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    if (pVFS == NULL || file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onTell == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onTell(pVFS, file, pCursor);
+}
+
+MA_API ma_result ma_vfs_info(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo)
+{
+    ma_vfs_callbacks* pCallbacks = (ma_vfs_callbacks*)pVFS;
+
+    if (pInfo == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pInfo);
+
+    if (pVFS == NULL || file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pCallbacks->onInfo == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pCallbacks->onInfo(pVFS, file, pInfo);
+}
+
+
+#if !defined(MA_USE_WIN32_FILEIO) && (defined(MA_WIN32) && defined(MA_WIN32_DESKTOP) && !defined(MA_NO_WIN32_FILEIO) && !defined(MA_POSIX))
+    #define MA_USE_WIN32_FILEIO
+#endif
+
+#if defined(MA_USE_WIN32_FILEIO)
+/*
+We need to dynamically load SetFilePointer or SetFilePointerEx because older versions of Windows do
+not have the Ex version. We therefore need to do some dynamic branching depending on what's available.
+
+We load these when we load our first file from the default VFS. It's left open for the life of the
+program and is left to the OS to uninitialize when the program terminates.
+*/
+typedef DWORD (__stdcall * ma_SetFilePointer_proc)(HANDLE hFile, LONG lDistanceToMove, LONG* lpDistanceToMoveHigh, DWORD dwMoveMethod);
+typedef BOOL  (__stdcall * ma_SetFilePointerEx_proc)(HANDLE hFile, LARGE_INTEGER liDistanceToMove, LARGE_INTEGER* lpNewFilePointer, DWORD dwMoveMethod);
+
+static ma_handle hKernel32DLL = NULL;
+static ma_SetFilePointer_proc   ma_SetFilePointer   = NULL;
+static ma_SetFilePointerEx_proc ma_SetFilePointerEx = NULL;
+
+static void ma_win32_fileio_init(void)
+{
+    if (hKernel32DLL == NULL) {
+        hKernel32DLL = ma_dlopen(NULL, "kernel32.dll");
+        if (hKernel32DLL != NULL) {
+            ma_SetFilePointer   = (ma_SetFilePointer_proc)  ma_dlsym(NULL, hKernel32DLL, "SetFilePointer");
+            ma_SetFilePointerEx = (ma_SetFilePointerEx_proc)ma_dlsym(NULL, hKernel32DLL, "SetFilePointerEx");
+        }
+    }
+}
+
+static void ma_default_vfs__get_open_settings_win32(ma_uint32 openMode, DWORD* pDesiredAccess, DWORD* pShareMode, DWORD* pCreationDisposition)
+{
+    *pDesiredAccess = 0;
+    if ((openMode & MA_OPEN_MODE_READ) != 0) {
+        *pDesiredAccess |= GENERIC_READ;
+    }
+    if ((openMode & MA_OPEN_MODE_WRITE) != 0) {
+        *pDesiredAccess |= GENERIC_WRITE;
+    }
+
+    *pShareMode = 0;
+    if ((openMode & MA_OPEN_MODE_READ) != 0) {
+        *pShareMode |= FILE_SHARE_READ;
+    }
+
+    if ((openMode & MA_OPEN_MODE_WRITE) != 0) {
+        *pCreationDisposition = CREATE_ALWAYS;  /* Opening in write mode. Truncate. */
+    } else {
+        *pCreationDisposition = OPEN_EXISTING;  /* Opening in read mode. File must exist. */
+    }
+}
+
+static ma_result ma_default_vfs_open__win32(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    HANDLE hFile;
+    DWORD dwDesiredAccess;
+    DWORD dwShareMode;
+    DWORD dwCreationDisposition;
+
+    (void)pVFS;
+
+    /* Load some Win32 symbols dynamically so we can dynamically check for the existence of SetFilePointerEx. */
+    ma_win32_fileio_init();
+
+    ma_default_vfs__get_open_settings_win32(openMode, &dwDesiredAccess, &dwShareMode, &dwCreationDisposition);
+
+    hFile = CreateFileA(pFilePath, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (hFile == INVALID_HANDLE_VALUE) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    *pFile = hFile;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_open_w__win32(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    HANDLE hFile;
+    DWORD dwDesiredAccess;
+    DWORD dwShareMode;
+    DWORD dwCreationDisposition;
+
+    (void)pVFS;
+
+    /* Load some Win32 symbols dynamically so we can dynamically check for the existence of SetFilePointerEx. */
+    ma_win32_fileio_init();
+
+    ma_default_vfs__get_open_settings_win32(openMode, &dwDesiredAccess, &dwShareMode, &dwCreationDisposition);
+
+    hFile = CreateFileW(pFilePath, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (hFile == INVALID_HANDLE_VALUE) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    *pFile = hFile;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_close__win32(ma_vfs* pVFS, ma_vfs_file file)
+{
+    (void)pVFS;
+
+    if (CloseHandle((HANDLE)file) == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_default_vfs_read__win32(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead)
+{
+    ma_result result = MA_SUCCESS;
+    size_t totalBytesRead;
+
+    (void)pVFS;
+
+    totalBytesRead = 0;
+    while (totalBytesRead < sizeInBytes) {
+        size_t bytesRemaining;
+        DWORD bytesToRead;
+        DWORD bytesRead;
+        BOOL readResult;
+
+        bytesRemaining = sizeInBytes - totalBytesRead;
+        if (bytesRemaining >= 0xFFFFFFFF) {
+            bytesToRead = 0xFFFFFFFF;
+        } else {
+            bytesToRead = (DWORD)bytesRemaining;
+        }
+
+        readResult = ReadFile((HANDLE)file, ma_offset_ptr(pDst, totalBytesRead), bytesToRead, &bytesRead, NULL);
+        if (readResult == 1 && bytesRead == 0) {
+            result = MA_AT_END;
+            break;  /* EOF */
+        }
+
+        totalBytesRead += bytesRead;
+
+        if (bytesRead < bytesToRead) {
+            break;  /* EOF */
+        }
+
+        if (readResult == 0) {
+            result = ma_result_from_GetLastError(GetLastError());
+            break;
+        }
+    }
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = totalBytesRead;
+    }
+
+    return result;
+}
+
+static ma_result ma_default_vfs_write__win32(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten)
+{
+    ma_result result = MA_SUCCESS;
+    size_t totalBytesWritten;
+
+    (void)pVFS;
+
+    totalBytesWritten = 0;
+    while (totalBytesWritten < sizeInBytes) {
+        size_t bytesRemaining;
+        DWORD bytesToWrite;
+        DWORD bytesWritten;
+        BOOL writeResult;
+
+        bytesRemaining = sizeInBytes - totalBytesWritten;
+        if (bytesRemaining >= 0xFFFFFFFF) {
+            bytesToWrite = 0xFFFFFFFF;
+        } else {
+            bytesToWrite = (DWORD)bytesRemaining;
+        }
+
+        writeResult = WriteFile((HANDLE)file, ma_offset_ptr(pSrc, totalBytesWritten), bytesToWrite, &bytesWritten, NULL);
+        totalBytesWritten += bytesWritten;
+
+        if (writeResult == 0) {
+            result = ma_result_from_GetLastError(GetLastError());
+            break;
+        }
+    }
+
+    if (pBytesWritten != NULL) {
+        *pBytesWritten = totalBytesWritten;
+    }
+
+    return result;
+}
+
+
+static ma_result ma_default_vfs_seek__win32(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin)
+{
+    LARGE_INTEGER liDistanceToMove;
+    DWORD dwMoveMethod;
+    BOOL result;
+
+    (void)pVFS;
+
+    liDistanceToMove.QuadPart = offset;
+
+    /*  */ if (origin == ma_seek_origin_current) {
+        dwMoveMethod = FILE_CURRENT;
+    } else if (origin == ma_seek_origin_end) {
+        dwMoveMethod = FILE_END;
+    } else {
+        dwMoveMethod = FILE_BEGIN;
+    }
+
+    if (ma_SetFilePointerEx != NULL) {
+        result = ma_SetFilePointerEx((HANDLE)file, liDistanceToMove, NULL, dwMoveMethod);
+    } else if (ma_SetFilePointer != NULL) {
+        /* No SetFilePointerEx() so restrict to 31 bits. */
+        if (origin > 0x7FFFFFFF) {
+            return MA_OUT_OF_RANGE;
+        }
+
+        result = ma_SetFilePointer((HANDLE)file, (LONG)liDistanceToMove.QuadPart, NULL, dwMoveMethod);
+    } else {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    if (result == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_tell__win32(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor)
+{
+    LARGE_INTEGER liZero;
+    LARGE_INTEGER liTell;
+    BOOL result;
+
+    (void)pVFS;
+
+    liZero.QuadPart = 0;
+
+    if (ma_SetFilePointerEx != NULL) {
+        result = ma_SetFilePointerEx((HANDLE)file, liZero, &liTell, FILE_CURRENT);
+    } else if (ma_SetFilePointer != NULL) {
+        LONG tell;
+
+        result = ma_SetFilePointer((HANDLE)file, (LONG)liZero.QuadPart, &tell, FILE_CURRENT);
+        liTell.QuadPart = tell;
+    } else {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    if (result == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    if (pCursor != NULL) {
+        *pCursor = liTell.QuadPart;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_info__win32(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo)
+{
+    BY_HANDLE_FILE_INFORMATION fi;
+    BOOL result;
+
+    (void)pVFS;
+
+    result = GetFileInformationByHandle((HANDLE)file, &fi);
+    if (result == 0) {
+        return ma_result_from_GetLastError(GetLastError());
+    }
+
+    pInfo->sizeInBytes = ((ma_uint64)fi.nFileSizeHigh << 32) | ((ma_uint64)fi.nFileSizeLow);
+
+    return MA_SUCCESS;
+}
+#else
+static ma_result ma_default_vfs_open__stdio(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    ma_result result;
+    FILE* pFileStd;
+    const char* pOpenModeStr;
+
+    MA_ASSERT(pFilePath != NULL);
+    MA_ASSERT(openMode  != 0);
+    MA_ASSERT(pFile     != NULL);
+
+    (void)pVFS;
+
+    if ((openMode & MA_OPEN_MODE_READ) != 0) {
+        if ((openMode & MA_OPEN_MODE_WRITE) != 0) {
+            pOpenModeStr = "r+";
+        } else {
+            pOpenModeStr = "rb";
+        }
+    } else {
+        pOpenModeStr = "wb";
+    }
+
+    result = ma_fopen(&pFileStd, pFilePath, pOpenModeStr);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pFile = pFileStd;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_open_w__stdio(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    ma_result result;
+    FILE* pFileStd;
+    const wchar_t* pOpenModeStr;
+
+    MA_ASSERT(pFilePath != NULL);
+    MA_ASSERT(openMode  != 0);
+    MA_ASSERT(pFile     != NULL);
+
+    (void)pVFS;
+
+    if ((openMode & MA_OPEN_MODE_READ) != 0) {
+        if ((openMode & MA_OPEN_MODE_WRITE) != 0) {
+            pOpenModeStr = L"r+";
+        } else {
+            pOpenModeStr = L"rb";
+        }
+    } else {
+        pOpenModeStr = L"wb";
+    }
+
+    result = ma_wfopen(&pFileStd, pFilePath, pOpenModeStr, (pVFS != NULL) ? &((ma_default_vfs*)pVFS)->allocationCallbacks : NULL);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pFile = pFileStd;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_close__stdio(ma_vfs* pVFS, ma_vfs_file file)
+{
+    MA_ASSERT(file != NULL);
+
+    (void)pVFS;
+
+    fclose((FILE*)file);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_read__stdio(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead)
+{
+    size_t result;
+
+    MA_ASSERT(file != NULL);
+    MA_ASSERT(pDst != NULL);
+
+    (void)pVFS;
+
+    result = fread(pDst, 1, sizeInBytes, (FILE*)file);
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = result;
+    }
+
+    if (result != sizeInBytes) {
+        if (result == 0 && feof((FILE*)file)) {
+            return MA_AT_END;
+        } else {
+            return ma_result_from_errno(ferror((FILE*)file));
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_write__stdio(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten)
+{
+    size_t result;
+
+    MA_ASSERT(file != NULL);
+    MA_ASSERT(pSrc != NULL);
+
+    (void)pVFS;
+
+    result = fwrite(pSrc, 1, sizeInBytes, (FILE*)file);
+
+    if (pBytesWritten != NULL) {
+        *pBytesWritten = result;
+    }
+
+    if (result != sizeInBytes) {
+        return ma_result_from_errno(ferror((FILE*)file));
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_seek__stdio(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin)
+{
+    int result;
+    int whence;
+
+    MA_ASSERT(file != NULL);
+
+    (void)pVFS;
+
+    if (origin == ma_seek_origin_start) {
+        whence = SEEK_SET;
+    } else if (origin == ma_seek_origin_end) {
+        whence = SEEK_END;
+    } else {
+        whence = SEEK_CUR;
+    }
+
+#if defined(_WIN32)
+    #if defined(_MSC_VER) && _MSC_VER > 1200
+        result = _fseeki64((FILE*)file, offset, whence);
+    #else
+        /* No _fseeki64() so restrict to 31 bits. */
+        if (origin > 0x7FFFFFFF) {
+            return MA_OUT_OF_RANGE;
+        }
+
+        result = fseek((FILE*)file, (int)offset, whence);
+    #endif
+#else
+    result = fseek((FILE*)file, (long int)offset, whence);
+#endif
+    if (result != 0) {
+        return MA_ERROR;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_default_vfs_tell__stdio(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor)
+{
+    ma_int64 result;
+
+    MA_ASSERT(file    != NULL);
+    MA_ASSERT(pCursor != NULL);
+
+    (void)pVFS;
+
+#if defined(_WIN32)
+    #if defined(_MSC_VER) && _MSC_VER > 1200
+        result = _ftelli64((FILE*)file);
+    #else
+        result = ftell((FILE*)file);
+    #endif
+#else
+    result = ftell((FILE*)file);
+#endif
+
+    *pCursor = result;
+
+    return MA_SUCCESS;
+}
+
+#if !defined(_MSC_VER) && !((defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 1) || defined(_XOPEN_SOURCE) || defined(_POSIX_SOURCE)) && !defined(MA_BSD)
+int fileno(FILE *stream);
+#endif
+
+static ma_result ma_default_vfs_info__stdio(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo)
+{
+    int fd;
+    struct stat info;
+
+    MA_ASSERT(file  != NULL);
+    MA_ASSERT(pInfo != NULL);
+
+    (void)pVFS;
+
+#if defined(_MSC_VER)
+    fd = _fileno((FILE*)file);
+#else
+    fd =  fileno((FILE*)file);
+#endif
+
+    if (fstat(fd, &info) != 0) {
+        return ma_result_from_errno(errno);
+    }
+
+    pInfo->sizeInBytes = info.st_size;
+
+    return MA_SUCCESS;
+}
+#endif
+
+
+static ma_result ma_default_vfs_open(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    if (pFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pFile = NULL;
+
+    if (pFilePath == NULL || openMode == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_open__win32(pVFS, pFilePath, openMode, pFile);
+#else
+    return ma_default_vfs_open__stdio(pVFS, pFilePath, openMode, pFile);
+#endif
+}
+
+static ma_result ma_default_vfs_open_w(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    if (pFile == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pFile = NULL;
+
+    if (pFilePath == NULL || openMode == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_open_w__win32(pVFS, pFilePath, openMode, pFile);
+#else
+    return ma_default_vfs_open_w__stdio(pVFS, pFilePath, openMode, pFile);
+#endif
+}
+
+static ma_result ma_default_vfs_close(ma_vfs* pVFS, ma_vfs_file file)
+{
+    if (file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_close__win32(pVFS, file);
+#else
+    return ma_default_vfs_close__stdio(pVFS, file);
+#endif
+}
+
+static ma_result ma_default_vfs_read(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead)
+{
+    if (pBytesRead != NULL) {
+        *pBytesRead = 0;
+    }
+
+    if (file == NULL || pDst == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_read__win32(pVFS, file, pDst, sizeInBytes, pBytesRead);
+#else
+    return ma_default_vfs_read__stdio(pVFS, file, pDst, sizeInBytes, pBytesRead);
+#endif
+}
+
+static ma_result ma_default_vfs_write(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten)
+{
+    if (pBytesWritten != NULL) {
+        *pBytesWritten = 0;
+    }
+
+    if (file == NULL || pSrc == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_write__win32(pVFS, file, pSrc, sizeInBytes, pBytesWritten);
+#else
+    return ma_default_vfs_write__stdio(pVFS, file, pSrc, sizeInBytes, pBytesWritten);
+#endif
+}
+
+static ma_result ma_default_vfs_seek(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin)
+{
+    if (file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_seek__win32(pVFS, file, offset, origin);
+#else
+    return ma_default_vfs_seek__stdio(pVFS, file, offset, origin);
+#endif
+}
+
+static ma_result ma_default_vfs_tell(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    if (file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_tell__win32(pVFS, file, pCursor);
+#else
+    return ma_default_vfs_tell__stdio(pVFS, file, pCursor);
+#endif
+}
+
+static ma_result ma_default_vfs_info(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo)
+{
+    if (pInfo == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pInfo);
+
+    if (file == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+#if defined(MA_USE_WIN32_FILEIO)
+    return ma_default_vfs_info__win32(pVFS, file, pInfo);
+#else
+    return ma_default_vfs_info__stdio(pVFS, file, pInfo);
+#endif
+}
+
+
+MA_API ma_result ma_default_vfs_init(ma_default_vfs* pVFS, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pVFS == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pVFS->cb.onOpen  = ma_default_vfs_open;
+    pVFS->cb.onOpenW = ma_default_vfs_open_w;
+    pVFS->cb.onClose = ma_default_vfs_close;
+    pVFS->cb.onRead  = ma_default_vfs_read;
+    pVFS->cb.onWrite = ma_default_vfs_write;
+    pVFS->cb.onSeek  = ma_default_vfs_seek;
+    pVFS->cb.onTell  = ma_default_vfs_tell;
+    pVFS->cb.onInfo  = ma_default_vfs_info;
+    ma_allocation_callbacks_init_copy(&pVFS->allocationCallbacks, pAllocationCallbacks);
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_vfs_or_default_open(ma_vfs* pVFS, const char* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_open(pVFS, pFilePath, openMode, pFile);
+    } else {
+        return ma_default_vfs_open(pVFS, pFilePath, openMode, pFile);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_open_w(ma_vfs* pVFS, const wchar_t* pFilePath, ma_uint32 openMode, ma_vfs_file* pFile)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_open_w(pVFS, pFilePath, openMode, pFile);
+    } else {
+        return ma_default_vfs_open_w(pVFS, pFilePath, openMode, pFile);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_close(ma_vfs* pVFS, ma_vfs_file file)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_close(pVFS, file);
+    } else {
+        return ma_default_vfs_close(pVFS, file);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_read(ma_vfs* pVFS, ma_vfs_file file, void* pDst, size_t sizeInBytes, size_t* pBytesRead)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_read(pVFS, file, pDst, sizeInBytes, pBytesRead);
+    } else {
+        return ma_default_vfs_read(pVFS, file, pDst, sizeInBytes, pBytesRead);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_write(ma_vfs* pVFS, ma_vfs_file file, const void* pSrc, size_t sizeInBytes, size_t* pBytesWritten)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_write(pVFS, file, pSrc, sizeInBytes, pBytesWritten);
+    } else {
+        return ma_default_vfs_write(pVFS, file, pSrc, sizeInBytes, pBytesWritten);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_seek(ma_vfs* pVFS, ma_vfs_file file, ma_int64 offset, ma_seek_origin origin)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_seek(pVFS, file, offset, origin);
+    } else {
+        return ma_default_vfs_seek(pVFS, file, offset, origin);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_tell(ma_vfs* pVFS, ma_vfs_file file, ma_int64* pCursor)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_tell(pVFS, file, pCursor);
+    } else {
+        return ma_default_vfs_tell(pVFS, file, pCursor);
+    }
+}
+
+MA_API ma_result ma_vfs_or_default_info(ma_vfs* pVFS, ma_vfs_file file, ma_file_info* pInfo)
+{
+    if (pVFS != NULL) {
+        return ma_vfs_info(pVFS, file, pInfo);
+    } else {
+        return ma_default_vfs_info(pVFS, file, pInfo);
+    }
+}
+
+
+
+static ma_result ma_vfs_open_and_read_file_ex(ma_vfs* pVFS, const char* pFilePath, const wchar_t* pFilePathW, void** ppData, size_t* pSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_result result;
+    ma_vfs_file file;
+    ma_file_info info;
+    void* pData;
+    size_t bytesRead;
+
+    if (ppData != NULL) {
+        *ppData = NULL;
+    }
+    if (pSize != NULL) {
+        *pSize = 0;
+    }
+
+    if (ppData == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFilePath != NULL) {
+        result = ma_vfs_or_default_open(pVFS, pFilePath, MA_OPEN_MODE_READ, &file);
+    } else {
+        result = ma_vfs_or_default_open_w(pVFS, pFilePathW, MA_OPEN_MODE_READ, &file);
+    }
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_vfs_or_default_info(pVFS, file, &info);
+    if (result != MA_SUCCESS) {
+        ma_vfs_or_default_close(pVFS, file);
+        return result;
+    }
+
+    if (info.sizeInBytes > MA_SIZE_MAX) {
+        ma_vfs_or_default_close(pVFS, file);
+        return MA_TOO_BIG;
+    }
+
+    pData = ma_malloc((size_t)info.sizeInBytes, pAllocationCallbacks);  /* Safe cast. */
+    if (pData == NULL) {
+        ma_vfs_or_default_close(pVFS, file);
+        return result;
+    }
+
+    result = ma_vfs_or_default_read(pVFS, file, pData, (size_t)info.sizeInBytes, &bytesRead);  /* Safe cast. */
+    ma_vfs_or_default_close(pVFS, file);
+
+    if (result != MA_SUCCESS) {
+        ma_free(pData, pAllocationCallbacks);
+        return result;
+    }
+
+    if (pSize != NULL) {
+        *pSize = bytesRead;
+    }
+
+    MA_ASSERT(ppData != NULL);
+    *ppData = pData;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_vfs_open_and_read_file(ma_vfs* pVFS, const char* pFilePath, void** ppData, size_t* pSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_vfs_open_and_read_file_ex(pVFS, pFilePath, NULL, ppData, pSize, pAllocationCallbacks);
+}
+
+MA_API ma_result ma_vfs_open_and_read_file_w(ma_vfs* pVFS, const wchar_t* pFilePath, void** ppData, size_t* pSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_vfs_open_and_read_file_ex(pVFS, NULL, pFilePath, ppData, pSize, pAllocationCallbacks);
+}
+
+
+
+/**************************************************************************************************************************************************************
+
+Decoding and Encoding Headers. These are auto-generated from a tool.
+
+**************************************************************************************************************************************************************/
+#if !defined(MA_NO_WAV) && (!defined(MA_NO_DECODING) || !defined(MA_NO_ENCODING))
+/* dr_wav_h begin */
+#ifndef ma_dr_wav_h
+#define ma_dr_wav_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define MA_DR_WAV_STRINGIFY(x)      #x
+#define MA_DR_WAV_XSTRINGIFY(x)     MA_DR_WAV_STRINGIFY(x)
+#define MA_DR_WAV_VERSION_MAJOR     0
+#define MA_DR_WAV_VERSION_MINOR     13
+#define MA_DR_WAV_VERSION_REVISION  13
+#define MA_DR_WAV_VERSION_STRING    MA_DR_WAV_XSTRINGIFY(MA_DR_WAV_VERSION_MAJOR) "." MA_DR_WAV_XSTRINGIFY(MA_DR_WAV_VERSION_MINOR) "." MA_DR_WAV_XSTRINGIFY(MA_DR_WAV_VERSION_REVISION)
+#include <stddef.h>
+#define MA_DR_WAVE_FORMAT_PCM          0x1
+#define MA_DR_WAVE_FORMAT_ADPCM        0x2
+#define MA_DR_WAVE_FORMAT_IEEE_FLOAT   0x3
+#define MA_DR_WAVE_FORMAT_ALAW         0x6
+#define MA_DR_WAVE_FORMAT_MULAW        0x7
+#define MA_DR_WAVE_FORMAT_DVI_ADPCM    0x11
+#define MA_DR_WAVE_FORMAT_EXTENSIBLE   0xFFFE
+#define MA_DR_WAV_SEQUENTIAL            0x00000001
+#define MA_DR_WAV_WITH_METADATA         0x00000002
+MA_API void ma_dr_wav_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);
+MA_API const char* ma_dr_wav_version_string(void);
+typedef enum
+{
+    ma_dr_wav_seek_origin_start,
+    ma_dr_wav_seek_origin_current
+} ma_dr_wav_seek_origin;
+typedef enum
+{
+    ma_dr_wav_container_riff,
+    ma_dr_wav_container_rifx,
+    ma_dr_wav_container_w64,
+    ma_dr_wav_container_rf64,
+    ma_dr_wav_container_aiff
+} ma_dr_wav_container;
+typedef struct
+{
+    union
+    {
+        ma_uint8 fourcc[4];
+        ma_uint8 guid[16];
+    } id;
+    ma_uint64 sizeInBytes;
+    unsigned int paddingSize;
+} ma_dr_wav_chunk_header;
+typedef struct
+{
+    ma_uint16 formatTag;
+    ma_uint16 channels;
+    ma_uint32 sampleRate;
+    ma_uint32 avgBytesPerSec;
+    ma_uint16 blockAlign;
+    ma_uint16 bitsPerSample;
+    ma_uint16 extendedSize;
+    ma_uint16 validBitsPerSample;
+    ma_uint32 channelMask;
+    ma_uint8 subFormat[16];
+} ma_dr_wav_fmt;
+MA_API ma_uint16 ma_dr_wav_fmt_get_format(const ma_dr_wav_fmt* pFMT);
+typedef size_t (* ma_dr_wav_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead);
+typedef size_t (* ma_dr_wav_write_proc)(void* pUserData, const void* pData, size_t bytesToWrite);
+typedef ma_bool32 (* ma_dr_wav_seek_proc)(void* pUserData, int offset, ma_dr_wav_seek_origin origin);
+typedef ma_uint64 (* ma_dr_wav_chunk_proc)(void* pChunkUserData, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pReadSeekUserData, const ma_dr_wav_chunk_header* pChunkHeader, ma_dr_wav_container container, const ma_dr_wav_fmt* pFMT);
+typedef struct
+{
+    const ma_uint8* data;
+    size_t dataSize;
+    size_t currentReadPos;
+} ma_dr_wav__memory_stream;
+typedef struct
+{
+    void** ppData;
+    size_t* pDataSize;
+    size_t dataSize;
+    size_t dataCapacity;
+    size_t currentWritePos;
+} ma_dr_wav__memory_stream_write;
+typedef struct
+{
+    ma_dr_wav_container container;
+    ma_uint32 format;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint32 bitsPerSample;
+} ma_dr_wav_data_format;
+typedef enum
+{
+    ma_dr_wav_metadata_type_none                        = 0,
+    ma_dr_wav_metadata_type_unknown                     = 1 << 0,
+    ma_dr_wav_metadata_type_smpl                        = 1 << 1,
+    ma_dr_wav_metadata_type_inst                        = 1 << 2,
+    ma_dr_wav_metadata_type_cue                         = 1 << 3,
+    ma_dr_wav_metadata_type_acid                        = 1 << 4,
+    ma_dr_wav_metadata_type_bext                        = 1 << 5,
+    ma_dr_wav_metadata_type_list_label                  = 1 << 6,
+    ma_dr_wav_metadata_type_list_note                   = 1 << 7,
+    ma_dr_wav_metadata_type_list_labelled_cue_region    = 1 << 8,
+    ma_dr_wav_metadata_type_list_info_software          = 1 << 9,
+    ma_dr_wav_metadata_type_list_info_copyright         = 1 << 10,
+    ma_dr_wav_metadata_type_list_info_title             = 1 << 11,
+    ma_dr_wav_metadata_type_list_info_artist            = 1 << 12,
+    ma_dr_wav_metadata_type_list_info_comment           = 1 << 13,
+    ma_dr_wav_metadata_type_list_info_date              = 1 << 14,
+    ma_dr_wav_metadata_type_list_info_genre             = 1 << 15,
+    ma_dr_wav_metadata_type_list_info_album             = 1 << 16,
+    ma_dr_wav_metadata_type_list_info_tracknumber       = 1 << 17,
+    ma_dr_wav_metadata_type_list_all_info_strings       = ma_dr_wav_metadata_type_list_info_software
+                                                    | ma_dr_wav_metadata_type_list_info_copyright
+                                                    | ma_dr_wav_metadata_type_list_info_title
+                                                    | ma_dr_wav_metadata_type_list_info_artist
+                                                    | ma_dr_wav_metadata_type_list_info_comment
+                                                    | ma_dr_wav_metadata_type_list_info_date
+                                                    | ma_dr_wav_metadata_type_list_info_genre
+                                                    | ma_dr_wav_metadata_type_list_info_album
+                                                    | ma_dr_wav_metadata_type_list_info_tracknumber,
+    ma_dr_wav_metadata_type_list_all_adtl               = ma_dr_wav_metadata_type_list_label
+                                                    | ma_dr_wav_metadata_type_list_note
+                                                    | ma_dr_wav_metadata_type_list_labelled_cue_region,
+    ma_dr_wav_metadata_type_all                         = -2,
+    ma_dr_wav_metadata_type_all_including_unknown       = -1
+} ma_dr_wav_metadata_type;
+typedef enum
+{
+    ma_dr_wav_smpl_loop_type_forward  = 0,
+    ma_dr_wav_smpl_loop_type_pingpong = 1,
+    ma_dr_wav_smpl_loop_type_backward = 2
+} ma_dr_wav_smpl_loop_type;
+typedef struct
+{
+    ma_uint32 cuePointId;
+    ma_uint32 type;
+    ma_uint32 firstSampleByteOffset;
+    ma_uint32 lastSampleByteOffset;
+    ma_uint32 sampleFraction;
+    ma_uint32 playCount;
+} ma_dr_wav_smpl_loop;
+typedef struct
+{
+    ma_uint32 manufacturerId;
+    ma_uint32 productId;
+    ma_uint32 samplePeriodNanoseconds;
+    ma_uint32 midiUnityNote;
+    ma_uint32 midiPitchFraction;
+    ma_uint32 smpteFormat;
+    ma_uint32 smpteOffset;
+    ma_uint32 sampleLoopCount;
+    ma_uint32 samplerSpecificDataSizeInBytes;
+    ma_dr_wav_smpl_loop* pLoops;
+    ma_uint8* pSamplerSpecificData;
+} ma_dr_wav_smpl;
+typedef struct
+{
+    ma_int8 midiUnityNote;
+    ma_int8 fineTuneCents;
+    ma_int8 gainDecibels;
+    ma_int8 lowNote;
+    ma_int8 highNote;
+    ma_int8 lowVelocity;
+    ma_int8 highVelocity;
+} ma_dr_wav_inst;
+typedef struct
+{
+    ma_uint32 id;
+    ma_uint32 playOrderPosition;
+    ma_uint8 dataChunkId[4];
+    ma_uint32 chunkStart;
+    ma_uint32 blockStart;
+    ma_uint32 sampleByteOffset;
+} ma_dr_wav_cue_point;
+typedef struct
+{
+    ma_uint32 cuePointCount;
+    ma_dr_wav_cue_point *pCuePoints;
+} ma_dr_wav_cue;
+typedef enum
+{
+    ma_dr_wav_acid_flag_one_shot      = 1,
+    ma_dr_wav_acid_flag_root_note_set = 2,
+    ma_dr_wav_acid_flag_stretch       = 4,
+    ma_dr_wav_acid_flag_disk_based    = 8,
+    ma_dr_wav_acid_flag_acidizer      = 16
+} ma_dr_wav_acid_flag;
+typedef struct
+{
+    ma_uint32 flags;
+    ma_uint16 midiUnityNote;
+    ma_uint16 reserved1;
+    float reserved2;
+    ma_uint32 numBeats;
+    ma_uint16 meterDenominator;
+    ma_uint16 meterNumerator;
+    float tempo;
+} ma_dr_wav_acid;
+typedef struct
+{
+    ma_uint32 cuePointId;
+    ma_uint32 stringLength;
+    char* pString;
+} ma_dr_wav_list_label_or_note;
+typedef struct
+{
+    char* pDescription;
+    char* pOriginatorName;
+    char* pOriginatorReference;
+    char  pOriginationDate[10];
+    char  pOriginationTime[8];
+    ma_uint64 timeReference;
+    ma_uint16 version;
+    char* pCodingHistory;
+    ma_uint32 codingHistorySize;
+    ma_uint8* pUMID;
+    ma_uint16 loudnessValue;
+    ma_uint16 loudnessRange;
+    ma_uint16 maxTruePeakLevel;
+    ma_uint16 maxMomentaryLoudness;
+    ma_uint16 maxShortTermLoudness;
+} ma_dr_wav_bext;
+typedef struct
+{
+    ma_uint32 stringLength;
+    char* pString;
+} ma_dr_wav_list_info_text;
+typedef struct
+{
+    ma_uint32 cuePointId;
+    ma_uint32 sampleLength;
+    ma_uint8 purposeId[4];
+    ma_uint16 country;
+    ma_uint16 language;
+    ma_uint16 dialect;
+    ma_uint16 codePage;
+    ma_uint32 stringLength;
+    char* pString;
+} ma_dr_wav_list_labelled_cue_region;
+typedef enum
+{
+    ma_dr_wav_metadata_location_invalid,
+    ma_dr_wav_metadata_location_top_level,
+    ma_dr_wav_metadata_location_inside_info_list,
+    ma_dr_wav_metadata_location_inside_adtl_list
+} ma_dr_wav_metadata_location;
+typedef struct
+{
+    ma_uint8 id[4];
+    ma_dr_wav_metadata_location chunkLocation;
+    ma_uint32 dataSizeInBytes;
+    ma_uint8* pData;
+} ma_dr_wav_unknown_metadata;
+typedef struct
+{
+    ma_dr_wav_metadata_type type;
+    union
+    {
+        ma_dr_wav_cue cue;
+        ma_dr_wav_smpl smpl;
+        ma_dr_wav_acid acid;
+        ma_dr_wav_inst inst;
+        ma_dr_wav_bext bext;
+        ma_dr_wav_list_label_or_note labelOrNote;
+        ma_dr_wav_list_labelled_cue_region labelledCueRegion;
+        ma_dr_wav_list_info_text infoText;
+        ma_dr_wav_unknown_metadata unknown;
+    } data;
+} ma_dr_wav_metadata;
+typedef struct
+{
+    ma_dr_wav_read_proc onRead;
+    ma_dr_wav_write_proc onWrite;
+    ma_dr_wav_seek_proc onSeek;
+    void* pUserData;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_dr_wav_container container;
+    ma_dr_wav_fmt fmt;
+    ma_uint32 sampleRate;
+    ma_uint16 channels;
+    ma_uint16 bitsPerSample;
+    ma_uint16 translatedFormatTag;
+    ma_uint64 totalPCMFrameCount;
+    ma_uint64 dataChunkDataSize;
+    ma_uint64 dataChunkDataPos;
+    ma_uint64 bytesRemaining;
+    ma_uint64 readCursorInPCMFrames;
+    ma_uint64 dataChunkDataSizeTargetWrite;
+    ma_bool32 isSequentialWrite;
+    ma_dr_wav_metadata* pMetadata;
+    ma_uint32 metadataCount;
+    ma_dr_wav__memory_stream memoryStream;
+    ma_dr_wav__memory_stream_write memoryStreamWrite;
+    struct
+    {
+        ma_uint32 bytesRemainingInBlock;
+        ma_uint16 predictor[2];
+        ma_int32  delta[2];
+        ma_int32  cachedFrames[4];
+        ma_uint32 cachedFrameCount;
+        ma_int32  prevFrames[2][2];
+    } msadpcm;
+    struct
+    {
+        ma_uint32 bytesRemainingInBlock;
+        ma_int32  predictor[2];
+        ma_int32  stepIndex[2];
+        ma_int32  cachedFrames[16];
+        ma_uint32 cachedFrameCount;
+    } ima;
+    struct
+    {
+        ma_bool8 isLE;
+        ma_bool8 isUnsigned;
+    } aiff;
+} ma_dr_wav;
+MA_API ma_bool32 ma_dr_wav_init(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_ex(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_chunk_proc onChunk, void* pReadSeekUserData, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_with_metadata(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_write(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_dr_wav_write_proc onWrite, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_write_sequential(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_dr_wav_write_proc onWrite, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_write_sequential_pcm_frames(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, ma_dr_wav_write_proc onWrite, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_write_with_metadata(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_dr_wav_write_proc onWrite, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks, ma_dr_wav_metadata* pMetadata, ma_uint32 metadataCount);
+MA_API ma_uint64 ma_dr_wav_target_write_size_bytes(const ma_dr_wav_data_format* pFormat, ma_uint64 totalFrameCount, ma_dr_wav_metadata* pMetadata, ma_uint32 metadataCount);
+MA_API ma_dr_wav_metadata* ma_dr_wav_take_ownership_of_metadata(ma_dr_wav* pWav);
+MA_API ma_result ma_dr_wav_uninit(ma_dr_wav* pWav);
+MA_API size_t ma_dr_wav_read_raw(ma_dr_wav* pWav, size_t bytesToRead, void* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_le(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_be(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut);
+MA_API ma_bool32 ma_dr_wav_seek_to_pcm_frame(ma_dr_wav* pWav, ma_uint64 targetFrameIndex);
+MA_API ma_result ma_dr_wav_get_cursor_in_pcm_frames(ma_dr_wav* pWav, ma_uint64* pCursor);
+MA_API ma_result ma_dr_wav_get_length_in_pcm_frames(ma_dr_wav* pWav, ma_uint64* pLength);
+MA_API size_t ma_dr_wav_write_raw(ma_dr_wav* pWav, size_t bytesToWrite, const void* pData);
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData);
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames_le(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData);
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames_be(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData);
+#ifndef MA_DR_WAV_NO_CONVERSION_API
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16le(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16be(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut);
+MA_API void ma_dr_wav_u8_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s24_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s32_to_s16(ma_int16* pOut, const ma_int32* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_f32_to_s16(ma_int16* pOut, const float* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_f64_to_s16(ma_int16* pOut, const double* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_alaw_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_mulaw_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32le(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32be(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut);
+MA_API void ma_dr_wav_u8_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s16_to_f32(float* pOut, const ma_int16* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s24_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s32_to_f32(float* pOut, const ma_int32* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_alaw_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_mulaw_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32le(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut);
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32be(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut);
+MA_API void ma_dr_wav_u8_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s16_to_s32(ma_int32* pOut, const ma_int16* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_s24_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_f32_to_s32(ma_int32* pOut, const float* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_f64_to_s32(ma_int32* pOut, const double* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_alaw_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount);
+MA_API void ma_dr_wav_mulaw_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount);
+#endif
+#ifndef MA_DR_WAV_NO_STDIO
+MA_API ma_bool32 ma_dr_wav_init_file(ma_dr_wav* pWav, const char* filename, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_ex(ma_dr_wav* pWav, const char* filename, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_ex_w(ma_dr_wav* pWav, const wchar_t* filename, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_with_metadata(ma_dr_wav* pWav, const char* filename, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_with_metadata_w(ma_dr_wav* pWav, const wchar_t* filename, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_pcm_frames(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_pcm_frames_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API ma_bool32 ma_dr_wav_init_memory(ma_dr_wav* pWav, const void* data, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_memory_ex(ma_dr_wav* pWav, const void* data, size_t dataSize, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_memory_with_metadata(ma_dr_wav* pWav, const void* data, size_t dataSize, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_memory_write(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_memory_write_sequential(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_wav_init_memory_write_sequential_pcm_frames(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifndef MA_DR_WAV_NO_CONVERSION_API
+MA_API ma_int16* ma_dr_wav_open_and_read_pcm_frames_s16(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_wav_open_and_read_pcm_frames_f32(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int32* ma_dr_wav_open_and_read_pcm_frames_s32(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifndef MA_DR_WAV_NO_STDIO
+MA_API ma_int16* ma_dr_wav_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_wav_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int32* ma_dr_wav_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_wav_open_file_and_read_pcm_frames_s16_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_wav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int32* ma_dr_wav_open_file_and_read_pcm_frames_s32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API ma_int16* ma_dr_wav_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_wav_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int32* ma_dr_wav_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API void ma_dr_wav_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_uint16 ma_dr_wav_bytes_to_u16(const ma_uint8* data);
+MA_API ma_int16 ma_dr_wav_bytes_to_s16(const ma_uint8* data);
+MA_API ma_uint32 ma_dr_wav_bytes_to_u32(const ma_uint8* data);
+MA_API ma_int32 ma_dr_wav_bytes_to_s32(const ma_uint8* data);
+MA_API ma_uint64 ma_dr_wav_bytes_to_u64(const ma_uint8* data);
+MA_API ma_int64 ma_dr_wav_bytes_to_s64(const ma_uint8* data);
+MA_API float ma_dr_wav_bytes_to_f32(const ma_uint8* data);
+MA_API ma_bool32 ma_dr_wav_guid_equal(const ma_uint8 a[16], const ma_uint8 b[16]);
+MA_API ma_bool32 ma_dr_wav_fourcc_equal(const ma_uint8* a, const char* b);
+#ifdef __cplusplus
+}
+#endif
+#endif
+/* dr_wav_h end */
+#endif  /* MA_NO_WAV */
+
+#if !defined(MA_NO_FLAC) && !defined(MA_NO_DECODING)
+/* dr_flac_h begin */
+#ifndef ma_dr_flac_h
+#define ma_dr_flac_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define MA_DR_FLAC_STRINGIFY(x)      #x
+#define MA_DR_FLAC_XSTRINGIFY(x)     MA_DR_FLAC_STRINGIFY(x)
+#define MA_DR_FLAC_VERSION_MAJOR     0
+#define MA_DR_FLAC_VERSION_MINOR     12
+#define MA_DR_FLAC_VERSION_REVISION  42
+#define MA_DR_FLAC_VERSION_STRING    MA_DR_FLAC_XSTRINGIFY(MA_DR_FLAC_VERSION_MAJOR) "." MA_DR_FLAC_XSTRINGIFY(MA_DR_FLAC_VERSION_MINOR) "." MA_DR_FLAC_XSTRINGIFY(MA_DR_FLAC_VERSION_REVISION)
+#include <stddef.h>
+#if defined(_MSC_VER) && _MSC_VER >= 1700
+    #define MA_DR_FLAC_DEPRECATED       __declspec(deprecated)
+#elif (defined(__GNUC__) && __GNUC__ >= 4)
+    #define MA_DR_FLAC_DEPRECATED       __attribute__((deprecated))
+#elif defined(__has_feature)
+    #if __has_feature(attribute_deprecated)
+        #define MA_DR_FLAC_DEPRECATED   __attribute__((deprecated))
+    #else
+        #define MA_DR_FLAC_DEPRECATED
+    #endif
+#else
+    #define MA_DR_FLAC_DEPRECATED
+#endif
+MA_API void ma_dr_flac_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);
+MA_API const char* ma_dr_flac_version_string(void);
+#ifndef MA_DR_FLAC_BUFFER_SIZE
+#define MA_DR_FLAC_BUFFER_SIZE   4096
+#endif
+#ifdef MA_64BIT
+typedef ma_uint64 ma_dr_flac_cache_t;
+#else
+typedef ma_uint32 ma_dr_flac_cache_t;
+#endif
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_STREAMINFO       0
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_PADDING          1
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_APPLICATION      2
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_SEEKTABLE        3
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_VORBIS_COMMENT   4
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_CUESHEET         5
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_PICTURE          6
+#define MA_DR_FLAC_METADATA_BLOCK_TYPE_INVALID          127
+#define MA_DR_FLAC_PICTURE_TYPE_OTHER                   0
+#define MA_DR_FLAC_PICTURE_TYPE_FILE_ICON               1
+#define MA_DR_FLAC_PICTURE_TYPE_OTHER_FILE_ICON         2
+#define MA_DR_FLAC_PICTURE_TYPE_COVER_FRONT             3
+#define MA_DR_FLAC_PICTURE_TYPE_COVER_BACK              4
+#define MA_DR_FLAC_PICTURE_TYPE_LEAFLET_PAGE            5
+#define MA_DR_FLAC_PICTURE_TYPE_MEDIA                   6
+#define MA_DR_FLAC_PICTURE_TYPE_LEAD_ARTIST             7
+#define MA_DR_FLAC_PICTURE_TYPE_ARTIST                  8
+#define MA_DR_FLAC_PICTURE_TYPE_CONDUCTOR               9
+#define MA_DR_FLAC_PICTURE_TYPE_BAND                    10
+#define MA_DR_FLAC_PICTURE_TYPE_COMPOSER                11
+#define MA_DR_FLAC_PICTURE_TYPE_LYRICIST                12
+#define MA_DR_FLAC_PICTURE_TYPE_RECORDING_LOCATION      13
+#define MA_DR_FLAC_PICTURE_TYPE_DURING_RECORDING        14
+#define MA_DR_FLAC_PICTURE_TYPE_DURING_PERFORMANCE      15
+#define MA_DR_FLAC_PICTURE_TYPE_SCREEN_CAPTURE          16
+#define MA_DR_FLAC_PICTURE_TYPE_BRIGHT_COLORED_FISH     17
+#define MA_DR_FLAC_PICTURE_TYPE_ILLUSTRATION            18
+#define MA_DR_FLAC_PICTURE_TYPE_BAND_LOGOTYPE           19
+#define MA_DR_FLAC_PICTURE_TYPE_PUBLISHER_LOGOTYPE      20
+typedef enum
+{
+    ma_dr_flac_container_native,
+    ma_dr_flac_container_ogg,
+    ma_dr_flac_container_unknown
+} ma_dr_flac_container;
+typedef enum
+{
+    ma_dr_flac_seek_origin_start,
+    ma_dr_flac_seek_origin_current
+} ma_dr_flac_seek_origin;
+typedef struct
+{
+    ma_uint64 firstPCMFrame;
+    ma_uint64 flacFrameOffset;
+    ma_uint16 pcmFrameCount;
+} ma_dr_flac_seekpoint;
+typedef struct
+{
+    ma_uint16 minBlockSizeInPCMFrames;
+    ma_uint16 maxBlockSizeInPCMFrames;
+    ma_uint32 minFrameSizeInPCMFrames;
+    ma_uint32 maxFrameSizeInPCMFrames;
+    ma_uint32 sampleRate;
+    ma_uint8  channels;
+    ma_uint8  bitsPerSample;
+    ma_uint64 totalPCMFrameCount;
+    ma_uint8  md5[16];
+} ma_dr_flac_streaminfo;
+typedef struct
+{
+    ma_uint32 type;
+    const void* pRawData;
+    ma_uint32 rawDataSize;
+    union
+    {
+        ma_dr_flac_streaminfo streaminfo;
+        struct
+        {
+            int unused;
+        } padding;
+        struct
+        {
+            ma_uint32 id;
+            const void* pData;
+            ma_uint32 dataSize;
+        } application;
+        struct
+        {
+            ma_uint32 seekpointCount;
+            const ma_dr_flac_seekpoint* pSeekpoints;
+        } seektable;
+        struct
+        {
+            ma_uint32 vendorLength;
+            const char* vendor;
+            ma_uint32 commentCount;
+            const void* pComments;
+        } vorbis_comment;
+        struct
+        {
+            char catalog[128];
+            ma_uint64 leadInSampleCount;
+            ma_bool32 isCD;
+            ma_uint8 trackCount;
+            const void* pTrackData;
+        } cuesheet;
+        struct
+        {
+            ma_uint32 type;
+            ma_uint32 mimeLength;
+            const char* mime;
+            ma_uint32 descriptionLength;
+            const char* description;
+            ma_uint32 width;
+            ma_uint32 height;
+            ma_uint32 colorDepth;
+            ma_uint32 indexColorCount;
+            ma_uint32 pictureDataSize;
+            const ma_uint8* pPictureData;
+        } picture;
+    } data;
+} ma_dr_flac_metadata;
+typedef size_t (* ma_dr_flac_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead);
+typedef ma_bool32 (* ma_dr_flac_seek_proc)(void* pUserData, int offset, ma_dr_flac_seek_origin origin);
+typedef void (* ma_dr_flac_meta_proc)(void* pUserData, ma_dr_flac_metadata* pMetadata);
+typedef struct
+{
+    const ma_uint8* data;
+    size_t dataSize;
+    size_t currentReadPos;
+} ma_dr_flac__memory_stream;
+typedef struct
+{
+    ma_dr_flac_read_proc onRead;
+    ma_dr_flac_seek_proc onSeek;
+    void* pUserData;
+    size_t unalignedByteCount;
+    ma_dr_flac_cache_t unalignedCache;
+    ma_uint32 nextL2Line;
+    ma_uint32 consumedBits;
+    ma_dr_flac_cache_t cacheL2[MA_DR_FLAC_BUFFER_SIZE/sizeof(ma_dr_flac_cache_t)];
+    ma_dr_flac_cache_t cache;
+    ma_uint16 crc16;
+    ma_dr_flac_cache_t crc16Cache;
+    ma_uint32 crc16CacheIgnoredBytes;
+} ma_dr_flac_bs;
+typedef struct
+{
+    ma_uint8 subframeType;
+    ma_uint8 wastedBitsPerSample;
+    ma_uint8 lpcOrder;
+    ma_int32* pSamplesS32;
+} ma_dr_flac_subframe;
+typedef struct
+{
+    ma_uint64 pcmFrameNumber;
+    ma_uint32 flacFrameNumber;
+    ma_uint32 sampleRate;
+    ma_uint16 blockSizeInPCMFrames;
+    ma_uint8 channelAssignment;
+    ma_uint8 bitsPerSample;
+    ma_uint8 crc8;
+} ma_dr_flac_frame_header;
+typedef struct
+{
+    ma_dr_flac_frame_header header;
+    ma_uint32 pcmFramesRemaining;
+    ma_dr_flac_subframe subframes[8];
+} ma_dr_flac_frame;
+typedef struct
+{
+    ma_dr_flac_meta_proc onMeta;
+    void* pUserDataMD;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_uint32 sampleRate;
+    ma_uint8 channels;
+    ma_uint8 bitsPerSample;
+    ma_uint16 maxBlockSizeInPCMFrames;
+    ma_uint64 totalPCMFrameCount;
+    ma_dr_flac_container container;
+    ma_uint32 seekpointCount;
+    ma_dr_flac_frame currentFLACFrame;
+    ma_uint64 currentPCMFrame;
+    ma_uint64 firstFLACFramePosInBytes;
+    ma_dr_flac__memory_stream memoryStream;
+    ma_int32* pDecodedSamples;
+    ma_dr_flac_seekpoint* pSeekpoints;
+    void* _oggbs;
+    ma_bool32 _noSeekTableSeek    : 1;
+    ma_bool32 _noBinarySearchSeek : 1;
+    ma_bool32 _noBruteForceSeek   : 1;
+    ma_dr_flac_bs bs;
+    ma_uint8 pExtraData[1];
+} ma_dr_flac;
+MA_API ma_dr_flac* ma_dr_flac_open(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_relaxed(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_container container, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_with_metadata(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_with_metadata_relaxed(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, ma_dr_flac_container container, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API void ma_dr_flac_close(ma_dr_flac* pFlac);
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_s32(ma_dr_flac* pFlac, ma_uint64 framesToRead, ma_int32* pBufferOut);
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_s16(ma_dr_flac* pFlac, ma_uint64 framesToRead, ma_int16* pBufferOut);
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_f32(ma_dr_flac* pFlac, ma_uint64 framesToRead, float* pBufferOut);
+MA_API ma_bool32 ma_dr_flac_seek_to_pcm_frame(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex);
+#ifndef MA_DR_FLAC_NO_STDIO
+MA_API ma_dr_flac* ma_dr_flac_open_file(const char* pFileName, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_file_w(const wchar_t* pFileName, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_file_with_metadata(const char* pFileName, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_file_with_metadata_w(const wchar_t* pFileName, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API ma_dr_flac* ma_dr_flac_open_memory(const void* pData, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_dr_flac* ma_dr_flac_open_memory_with_metadata(const void* pData, size_t dataSize, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int32* ma_dr_flac_open_and_read_pcm_frames_s32(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_flac_open_and_read_pcm_frames_s16(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_flac_open_and_read_pcm_frames_f32(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, void* pUserData, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifndef MA_DR_FLAC_NO_STDIO
+MA_API ma_int32* ma_dr_flac_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_flac_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_flac_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API ma_int32* ma_dr_flac_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_flac_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_flac_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API void ma_dr_flac_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks);
+typedef struct
+{
+    ma_uint32 countRemaining;
+    const char* pRunningData;
+} ma_dr_flac_vorbis_comment_iterator;
+MA_API void ma_dr_flac_init_vorbis_comment_iterator(ma_dr_flac_vorbis_comment_iterator* pIter, ma_uint32 commentCount, const void* pComments);
+MA_API const char* ma_dr_flac_next_vorbis_comment(ma_dr_flac_vorbis_comment_iterator* pIter, ma_uint32* pCommentLengthOut);
+typedef struct
+{
+    ma_uint32 countRemaining;
+    const char* pRunningData;
+} ma_dr_flac_cuesheet_track_iterator;
+typedef struct
+{
+    ma_uint64 offset;
+    ma_uint8 index;
+    ma_uint8 reserved[3];
+} ma_dr_flac_cuesheet_track_index;
+typedef struct
+{
+    ma_uint64 offset;
+    ma_uint8 trackNumber;
+    char ISRC[12];
+    ma_bool8 isAudio;
+    ma_bool8 preEmphasis;
+    ma_uint8 indexCount;
+    const ma_dr_flac_cuesheet_track_index* pIndexPoints;
+} ma_dr_flac_cuesheet_track;
+MA_API void ma_dr_flac_init_cuesheet_track_iterator(ma_dr_flac_cuesheet_track_iterator* pIter, ma_uint32 trackCount, const void* pTrackData);
+MA_API ma_bool32 ma_dr_flac_next_cuesheet_track(ma_dr_flac_cuesheet_track_iterator* pIter, ma_dr_flac_cuesheet_track* pCuesheetTrack);
+#ifdef __cplusplus
+}
+#endif
+#endif
+/* dr_flac_h end */
+#endif  /* MA_NO_FLAC */
+
+#if !defined(MA_NO_MP3) && !defined(MA_NO_DECODING)
+/* dr_mp3_h begin */
+#ifndef ma_dr_mp3_h
+#define ma_dr_mp3_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define MA_DR_MP3_STRINGIFY(x)      #x
+#define MA_DR_MP3_XSTRINGIFY(x)     MA_DR_MP3_STRINGIFY(x)
+#define MA_DR_MP3_VERSION_MAJOR     0
+#define MA_DR_MP3_VERSION_MINOR     6
+#define MA_DR_MP3_VERSION_REVISION  38
+#define MA_DR_MP3_VERSION_STRING    MA_DR_MP3_XSTRINGIFY(MA_DR_MP3_VERSION_MAJOR) "." MA_DR_MP3_XSTRINGIFY(MA_DR_MP3_VERSION_MINOR) "." MA_DR_MP3_XSTRINGIFY(MA_DR_MP3_VERSION_REVISION)
+#include <stddef.h>
+#define MA_DR_MP3_MAX_PCM_FRAMES_PER_MP3_FRAME  1152
+#define MA_DR_MP3_MAX_SAMPLES_PER_FRAME         (MA_DR_MP3_MAX_PCM_FRAMES_PER_MP3_FRAME*2)
+MA_API void ma_dr_mp3_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);
+MA_API const char* ma_dr_mp3_version_string(void);
+typedef struct
+{
+    int frame_bytes, channels, hz, layer, bitrate_kbps;
+} ma_dr_mp3dec_frame_info;
+typedef struct
+{
+    float mdct_overlap[2][9*32], qmf_state[15*2*32];
+    int reserv, free_format_bytes;
+    ma_uint8 header[4], reserv_buf[511];
+} ma_dr_mp3dec;
+MA_API void ma_dr_mp3dec_init(ma_dr_mp3dec *dec);
+MA_API int ma_dr_mp3dec_decode_frame(ma_dr_mp3dec *dec, const ma_uint8 *mp3, int mp3_bytes, void *pcm, ma_dr_mp3dec_frame_info *info);
+MA_API void ma_dr_mp3dec_f32_to_s16(const float *in, ma_int16 *out, size_t num_samples);
+typedef enum
+{
+    ma_dr_mp3_seek_origin_start,
+    ma_dr_mp3_seek_origin_current
+} ma_dr_mp3_seek_origin;
+typedef struct
+{
+    ma_uint64 seekPosInBytes;
+    ma_uint64 pcmFrameIndex;
+    ma_uint16 mp3FramesToDiscard;
+    ma_uint16 pcmFramesToDiscard;
+} ma_dr_mp3_seek_point;
+typedef size_t (* ma_dr_mp3_read_proc)(void* pUserData, void* pBufferOut, size_t bytesToRead);
+typedef ma_bool32 (* ma_dr_mp3_seek_proc)(void* pUserData, int offset, ma_dr_mp3_seek_origin origin);
+typedef struct
+{
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+} ma_dr_mp3_config;
+typedef struct
+{
+    ma_dr_mp3dec decoder;
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_dr_mp3_read_proc onRead;
+    ma_dr_mp3_seek_proc onSeek;
+    void* pUserData;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_uint32 mp3FrameChannels;
+    ma_uint32 mp3FrameSampleRate;
+    ma_uint32 pcmFramesConsumedInMP3Frame;
+    ma_uint32 pcmFramesRemainingInMP3Frame;
+    ma_uint8 pcmFrames[sizeof(float)*MA_DR_MP3_MAX_SAMPLES_PER_FRAME];
+    ma_uint64 currentPCMFrame;
+    ma_uint64 streamCursor;
+    ma_dr_mp3_seek_point* pSeekPoints;
+    ma_uint32 seekPointCount;
+    size_t dataSize;
+    size_t dataCapacity;
+    size_t dataConsumed;
+    ma_uint8* pData;
+    ma_bool32 atEnd : 1;
+    struct
+    {
+        const ma_uint8* pData;
+        size_t dataSize;
+        size_t currentReadPos;
+    } memory;
+} ma_dr_mp3;
+MA_API ma_bool32 ma_dr_mp3_init(ma_dr_mp3* pMP3, ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_mp3_init_memory(ma_dr_mp3* pMP3, const void* pData, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifndef MA_DR_MP3_NO_STDIO
+MA_API ma_bool32 ma_dr_mp3_init_file(ma_dr_mp3* pMP3, const char* pFilePath, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_bool32 ma_dr_mp3_init_file_w(ma_dr_mp3* pMP3, const wchar_t* pFilePath, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API void ma_dr_mp3_uninit(ma_dr_mp3* pMP3);
+MA_API ma_uint64 ma_dr_mp3_read_pcm_frames_f32(ma_dr_mp3* pMP3, ma_uint64 framesToRead, float* pBufferOut);
+MA_API ma_uint64 ma_dr_mp3_read_pcm_frames_s16(ma_dr_mp3* pMP3, ma_uint64 framesToRead, ma_int16* pBufferOut);
+MA_API ma_bool32 ma_dr_mp3_seek_to_pcm_frame(ma_dr_mp3* pMP3, ma_uint64 frameIndex);
+MA_API ma_uint64 ma_dr_mp3_get_pcm_frame_count(ma_dr_mp3* pMP3);
+MA_API ma_uint64 ma_dr_mp3_get_mp3_frame_count(ma_dr_mp3* pMP3);
+MA_API ma_bool32 ma_dr_mp3_get_mp3_and_pcm_frame_count(ma_dr_mp3* pMP3, ma_uint64* pMP3FrameCount, ma_uint64* pPCMFrameCount);
+MA_API ma_bool32 ma_dr_mp3_calculate_seek_points(ma_dr_mp3* pMP3, ma_uint32* pSeekPointCount, ma_dr_mp3_seek_point* pSeekPoints);
+MA_API ma_bool32 ma_dr_mp3_bind_seek_table(ma_dr_mp3* pMP3, ma_uint32 seekPointCount, ma_dr_mp3_seek_point* pSeekPoints);
+MA_API float* ma_dr_mp3_open_and_read_pcm_frames_f32(ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, void* pUserData, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_mp3_open_and_read_pcm_frames_s16(ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, void* pUserData, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API float* ma_dr_mp3_open_memory_and_read_pcm_frames_f32(const void* pData, size_t dataSize, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_mp3_open_memory_and_read_pcm_frames_s16(const void* pData, size_t dataSize, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifndef MA_DR_MP3_NO_STDIO
+MA_API float* ma_dr_mp3_open_file_and_read_pcm_frames_f32(const char* filePath, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_int16* ma_dr_mp3_open_file_and_read_pcm_frames_s16(const char* filePath, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks);
+#endif
+MA_API void* ma_dr_mp3_malloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API void ma_dr_mp3_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks);
+#ifdef __cplusplus
+}
+#endif
+#endif
+/* dr_mp3_h end */
+#endif  /* MA_NO_MP3 */
+
+
+/**************************************************************************************************************************************************************
+
+Decoding
+
+**************************************************************************************************************************************************************/
+#ifndef MA_NO_DECODING
+
+static ma_result ma_decoder_read_bytes(ma_decoder* pDecoder, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    return pDecoder->onRead(pDecoder, pBufferOut, bytesToRead, pBytesRead);
+}
+
+static ma_result ma_decoder_seek_bytes(ma_decoder* pDecoder, ma_int64 byteOffset, ma_seek_origin origin)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    return pDecoder->onSeek(pDecoder, byteOffset, origin);
+}
+
+static ma_result ma_decoder_tell_bytes(ma_decoder* pDecoder, ma_int64* pCursor)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pDecoder->onTell == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    return pDecoder->onTell(pDecoder, pCursor);
+}
+
+
+MA_API ma_decoding_backend_config ma_decoding_backend_config_init(ma_format preferredFormat, ma_uint32 seekPointCount)
+{
+    ma_decoding_backend_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.preferredFormat = preferredFormat;
+    config.seekPointCount  = seekPointCount;
+
+    return config;
+}
+
+
+MA_API ma_decoder_config ma_decoder_config_init(ma_format outputFormat, ma_uint32 outputChannels, ma_uint32 outputSampleRate)
+{
+    ma_decoder_config config;
+    MA_ZERO_OBJECT(&config);
+    config.format         = outputFormat;
+    config.channels       = outputChannels;
+    config.sampleRate     = outputSampleRate;
+    config.resampling     = ma_resampler_config_init(ma_format_unknown, 0, 0, 0, ma_resample_algorithm_linear); /* Format/channels/rate doesn't matter here. */
+    config.encodingFormat = ma_encoding_format_unknown;
+
+    /* Note that we are intentionally leaving the channel map empty here which will cause the default channel map to be used. */
+
+    return config;
+}
+
+MA_API ma_decoder_config ma_decoder_config_init_default()
+{
+    return ma_decoder_config_init(ma_format_unknown, 0, 0);
+}
+
+MA_API ma_decoder_config ma_decoder_config_init_copy(const ma_decoder_config* pConfig)
+{
+    ma_decoder_config config;
+    if (pConfig != NULL) {
+        config = *pConfig;
+    } else {
+        MA_ZERO_OBJECT(&config);
+    }
+
+    return config;
+}
+
+static ma_result ma_decoder__init_data_converter(ma_decoder* pDecoder, const ma_decoder_config* pConfig)
+{
+    ma_result result;
+    ma_data_converter_config converterConfig;
+    ma_format internalFormat;
+    ma_uint32 internalChannels;
+    ma_uint32 internalSampleRate;
+    ma_channel internalChannelMap[MA_MAX_CHANNELS];
+
+    MA_ASSERT(pDecoder != NULL);
+    MA_ASSERT(pConfig  != NULL);
+
+    result = ma_data_source_get_data_format(pDecoder->pBackend, &internalFormat, &internalChannels, &internalSampleRate, internalChannelMap, ma_countof(internalChannelMap));
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the internal data format. */
+    }
+
+
+    /* Make sure we're not asking for too many channels. */
+    if (pConfig->channels > MA_MAX_CHANNELS) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The internal channels should have already been validated at a higher level, but we'll do it again explicitly here for safety. */
+    if (internalChannels > MA_MAX_CHANNELS) {
+        return MA_INVALID_ARGS;
+    }
+
+
+    /* Output format. */
+    if (pConfig->format == ma_format_unknown) {
+        pDecoder->outputFormat = internalFormat;
+    } else {
+        pDecoder->outputFormat = pConfig->format;
+    }
+
+    if (pConfig->channels == 0) {
+        pDecoder->outputChannels = internalChannels;
+    } else {
+        pDecoder->outputChannels = pConfig->channels;
+    }
+
+    if (pConfig->sampleRate == 0) {
+        pDecoder->outputSampleRate = internalSampleRate;
+    } else {
+        pDecoder->outputSampleRate = pConfig->sampleRate;
+    }
+
+    converterConfig = ma_data_converter_config_init(
+        internalFormat,     pDecoder->outputFormat,
+        internalChannels,   pDecoder->outputChannels,
+        internalSampleRate, pDecoder->outputSampleRate
+    );
+    converterConfig.pChannelMapIn          = internalChannelMap;
+    converterConfig.pChannelMapOut         = pConfig->pChannelMap;
+    converterConfig.channelMixMode         = pConfig->channelMixMode;
+    converterConfig.ditherMode             = pConfig->ditherMode;
+    converterConfig.allowDynamicSampleRate = MA_FALSE;   /* Never allow dynamic sample rate conversion. Setting this to true will disable passthrough optimizations. */
+    converterConfig.resampling             = pConfig->resampling;
+
+    result = ma_data_converter_init(&converterConfig, &pDecoder->allocationCallbacks, &pDecoder->converter);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /*
+    Now that we have the decoder we need to determine whether or not we need a heap-allocated cache. We'll
+    need this if the data converter does not support calculation of the required input frame count. To
+    determine support for this we'll just run a test.
+    */
+    {
+        ma_uint64 unused;
+
+        result = ma_data_converter_get_required_input_frame_count(&pDecoder->converter, 1, &unused);
+        if (result != MA_SUCCESS) {
+            /*
+            We were unable to calculate the required input frame count which means we'll need to use
+            a heap-allocated cache.
+            */
+            ma_uint64 inputCacheCapSizeInBytes;
+
+            pDecoder->inputCacheCap = MA_DATA_CONVERTER_STACK_BUFFER_SIZE / ma_get_bytes_per_frame(internalFormat, internalChannels);
+
+            /* Not strictly necessary, but keeping here for safety in case we change the default value of pDecoder->inputCacheCap. */
+            inputCacheCapSizeInBytes = pDecoder->inputCacheCap * ma_get_bytes_per_frame(internalFormat, internalChannels);
+            if (inputCacheCapSizeInBytes > MA_SIZE_MAX) {
+                ma_data_converter_uninit(&pDecoder->converter, &pDecoder->allocationCallbacks);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            pDecoder->pInputCache = ma_malloc((size_t)inputCacheCapSizeInBytes, &pDecoder->allocationCallbacks);    /* Safe cast to size_t. */
+            if (pDecoder->pInputCache == NULL) {
+                ma_data_converter_uninit(&pDecoder->converter, &pDecoder->allocationCallbacks);
+                return MA_OUT_OF_MEMORY;
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+
+static ma_result ma_decoder_internal_on_read__custom(void* pUserData, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead)
+{
+    ma_decoder* pDecoder = (ma_decoder*)pUserData;
+    MA_ASSERT(pDecoder != NULL);
+
+    return ma_decoder_read_bytes(pDecoder, pBufferOut, bytesToRead, pBytesRead);
+}
+
+static ma_result ma_decoder_internal_on_seek__custom(void* pUserData, ma_int64 offset, ma_seek_origin origin)
+{
+    ma_decoder* pDecoder = (ma_decoder*)pUserData;
+    MA_ASSERT(pDecoder != NULL);
+
+    return ma_decoder_seek_bytes(pDecoder, offset, origin);
+}
+
+static ma_result ma_decoder_internal_on_tell__custom(void* pUserData, ma_int64* pCursor)
+{
+    ma_decoder* pDecoder = (ma_decoder*)pUserData;
+    MA_ASSERT(pDecoder != NULL);
+
+    return ma_decoder_tell_bytes(pDecoder, pCursor);
+}
+
+
+static ma_result ma_decoder_init_from_vtable__internal(const ma_decoding_backend_vtable* pVTable, void* pVTableUserData, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoding_backend_config backendConfig;
+    ma_data_source* pBackend;
+
+    MA_ASSERT(pVTable  != NULL);
+    MA_ASSERT(pConfig  != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pVTable->onInit == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    backendConfig = ma_decoding_backend_config_init(pConfig->format, pConfig->seekPointCount);
+
+    result = pVTable->onInit(pVTableUserData, ma_decoder_internal_on_read__custom, ma_decoder_internal_on_seek__custom, ma_decoder_internal_on_tell__custom, pDecoder, &backendConfig, &pDecoder->allocationCallbacks, &pBackend);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the backend from this vtable. */
+    }
+
+    /* Getting here means we were able to initialize the backend so we can now initialize the decoder. */
+    pDecoder->pBackend         = pBackend;
+    pDecoder->pBackendVTable   = pVTable;
+    pDecoder->pBackendUserData = pConfig->pCustomBackendUserData;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder_init_from_file__internal(const ma_decoding_backend_vtable* pVTable, void* pVTableUserData, const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoding_backend_config backendConfig;
+    ma_data_source* pBackend;
+
+    MA_ASSERT(pVTable  != NULL);
+    MA_ASSERT(pConfig  != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pVTable->onInitFile == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    backendConfig = ma_decoding_backend_config_init(pConfig->format, pConfig->seekPointCount);
+
+    result = pVTable->onInitFile(pVTableUserData, pFilePath, &backendConfig, &pDecoder->allocationCallbacks, &pBackend);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the backend from this vtable. */
+    }
+
+    /* Getting here means we were able to initialize the backend so we can now initialize the decoder. */
+    pDecoder->pBackend         = pBackend;
+    pDecoder->pBackendVTable   = pVTable;
+    pDecoder->pBackendUserData = pConfig->pCustomBackendUserData;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder_init_from_file_w__internal(const ma_decoding_backend_vtable* pVTable, void* pVTableUserData, const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoding_backend_config backendConfig;
+    ma_data_source* pBackend;
+
+    MA_ASSERT(pVTable  != NULL);
+    MA_ASSERT(pConfig  != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pVTable->onInitFileW == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    backendConfig = ma_decoding_backend_config_init(pConfig->format, pConfig->seekPointCount);
+
+    result = pVTable->onInitFileW(pVTableUserData, pFilePath, &backendConfig, &pDecoder->allocationCallbacks, &pBackend);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the backend from this vtable. */
+    }
+
+    /* Getting here means we were able to initialize the backend so we can now initialize the decoder. */
+    pDecoder->pBackend         = pBackend;
+    pDecoder->pBackendVTable   = pVTable;
+    pDecoder->pBackendUserData = pConfig->pCustomBackendUserData;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder_init_from_memory__internal(const ma_decoding_backend_vtable* pVTable, void* pVTableUserData, const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoding_backend_config backendConfig;
+    ma_data_source* pBackend;
+
+    MA_ASSERT(pVTable  != NULL);
+    MA_ASSERT(pConfig  != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pVTable->onInitMemory == NULL) {
+        return MA_NOT_IMPLEMENTED;
+    }
+
+    backendConfig = ma_decoding_backend_config_init(pConfig->format, pConfig->seekPointCount);
+
+    result = pVTable->onInitMemory(pVTableUserData, pData, dataSize, &backendConfig, &pDecoder->allocationCallbacks, &pBackend);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the backend from this vtable. */
+    }
+
+    /* Getting here means we were able to initialize the backend so we can now initialize the decoder. */
+    pDecoder->pBackend         = pBackend;
+    pDecoder->pBackendVTable   = pVTable;
+    pDecoder->pBackendUserData = pConfig->pCustomBackendUserData;
+
+    return MA_SUCCESS;
+}
+
+
+
+static ma_result ma_decoder_init_custom__internal(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = MA_NO_BACKEND;
+    size_t ivtable;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pConfig->ppCustomBackendVTables == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    /* The order each backend is listed is what defines the priority. */
+    for (ivtable = 0; ivtable < pConfig->customBackendCount; ivtable += 1) {
+        const ma_decoding_backend_vtable* pVTable = pConfig->ppCustomBackendVTables[ivtable];
+        if (pVTable != NULL) {
+            result = ma_decoder_init_from_vtable__internal(pVTable, pConfig->pCustomBackendUserData, pConfig, pDecoder);
+            if (result == MA_SUCCESS) {
+                return MA_SUCCESS;
+            } else {
+                /* Initialization failed. Move on to the next one, but seek back to the start first so the next vtable starts from the first byte of the file. */
+                result = ma_decoder_seek_bytes(pDecoder, 0, ma_seek_origin_start);
+                if (result != MA_SUCCESS) {
+                    return result;  /* Failed to seek back to the start. */
+                }
+            }
+        } else {
+            /* No vtable. */
+        }
+    }
+
+    /* Getting here means we couldn't find a backend. */
+    return MA_NO_BACKEND;
+}
+
+static ma_result ma_decoder_init_custom_from_file__internal(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = MA_NO_BACKEND;
+    size_t ivtable;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pConfig->ppCustomBackendVTables == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    /* The order each backend is listed is what defines the priority. */
+    for (ivtable = 0; ivtable < pConfig->customBackendCount; ivtable += 1) {
+        const ma_decoding_backend_vtable* pVTable = pConfig->ppCustomBackendVTables[ivtable];
+        if (pVTable != NULL) {
+            result = ma_decoder_init_from_file__internal(pVTable, pConfig->pCustomBackendUserData, pFilePath, pConfig, pDecoder);
+            if (result == MA_SUCCESS) {
+                return MA_SUCCESS;
+            }
+        } else {
+            /* No vtable. */
+        }
+    }
+
+    /* Getting here means we couldn't find a backend. */
+    return MA_NO_BACKEND;
+}
+
+static ma_result ma_decoder_init_custom_from_file_w__internal(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = MA_NO_BACKEND;
+    size_t ivtable;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pConfig->ppCustomBackendVTables == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    /* The order each backend is listed is what defines the priority. */
+    for (ivtable = 0; ivtable < pConfig->customBackendCount; ivtable += 1) {
+        const ma_decoding_backend_vtable* pVTable = pConfig->ppCustomBackendVTables[ivtable];
+        if (pVTable != NULL) {
+            result = ma_decoder_init_from_file_w__internal(pVTable, pConfig->pCustomBackendUserData, pFilePath, pConfig, pDecoder);
+            if (result == MA_SUCCESS) {
+                return MA_SUCCESS;
+            }
+        } else {
+            /* No vtable. */
+        }
+    }
+
+    /* Getting here means we couldn't find a backend. */
+    return MA_NO_BACKEND;
+}
+
+static ma_result ma_decoder_init_custom_from_memory__internal(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = MA_NO_BACKEND;
+    size_t ivtable;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pConfig->ppCustomBackendVTables == NULL) {
+        return MA_NO_BACKEND;
+    }
+
+    /* The order each backend is listed is what defines the priority. */
+    for (ivtable = 0; ivtable < pConfig->customBackendCount; ivtable += 1) {
+        const ma_decoding_backend_vtable* pVTable = pConfig->ppCustomBackendVTables[ivtable];
+        if (pVTable != NULL) {
+            result = ma_decoder_init_from_memory__internal(pVTable, pConfig->pCustomBackendUserData, pData, dataSize, pConfig, pDecoder);
+            if (result == MA_SUCCESS) {
+                return MA_SUCCESS;
+            }
+        } else {
+            /* No vtable. */
+        }
+    }
+
+    /* Getting here means we couldn't find a backend. */
+    return MA_NO_BACKEND;
+}
+
+
+/* WAV */
+#ifdef ma_dr_wav_h
+#define MA_HAS_WAV
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_read_proc onRead;
+    ma_seek_proc onSeek;
+    ma_tell_proc onTell;
+    void* pReadSeekTellUserData;
+    ma_format format;           /* Can be f32, s16 or s32. */
+#if !defined(MA_NO_WAV)
+    ma_dr_wav dr;
+#endif
+} ma_wav;
+
+MA_API ma_result ma_wav_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav);
+MA_API ma_result ma_wav_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav);
+MA_API ma_result ma_wav_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav);
+MA_API ma_result ma_wav_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav);
+MA_API void ma_wav_uninit(ma_wav* pWav, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_wav_read_pcm_frames(ma_wav* pWav, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_wav_seek_to_pcm_frame(ma_wav* pWav, ma_uint64 frameIndex);
+MA_API ma_result ma_wav_get_data_format(ma_wav* pWav, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_wav_get_cursor_in_pcm_frames(ma_wav* pWav, ma_uint64* pCursor);
+MA_API ma_result ma_wav_get_length_in_pcm_frames(ma_wav* pWav, ma_uint64* pLength);
+
+
+static ma_result ma_wav_ds_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_wav_read_pcm_frames((ma_wav*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_wav_ds_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_wav_seek_to_pcm_frame((ma_wav*)pDataSource, frameIndex);
+}
+
+static ma_result ma_wav_ds_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_wav_get_data_format((ma_wav*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_wav_ds_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_wav_get_cursor_in_pcm_frames((ma_wav*)pDataSource, pCursor);
+}
+
+static ma_result ma_wav_ds_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_wav_get_length_in_pcm_frames((ma_wav*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_wav_ds_vtable =
+{
+    ma_wav_ds_read,
+    ma_wav_ds_seek,
+    ma_wav_ds_get_data_format,
+    ma_wav_ds_get_cursor,
+    ma_wav_ds_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+
+#if !defined(MA_NO_WAV)
+static size_t ma_wav_dr_callback__read(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    ma_wav* pWav = (ma_wav*)pUserData;
+    ma_result result;
+    size_t bytesRead;
+
+    MA_ASSERT(pWav != NULL);
+
+    result = pWav->onRead(pWav->pReadSeekTellUserData, pBufferOut, bytesToRead, &bytesRead);
+    (void)result;
+
+    return bytesRead;
+}
+
+static ma_bool32 ma_wav_dr_callback__seek(void* pUserData, int offset, ma_dr_wav_seek_origin origin)
+{
+    ma_wav* pWav = (ma_wav*)pUserData;
+    ma_result result;
+    ma_seek_origin maSeekOrigin;
+
+    MA_ASSERT(pWav != NULL);
+
+    maSeekOrigin = ma_seek_origin_start;
+    if (origin == ma_dr_wav_seek_origin_current) {
+        maSeekOrigin =  ma_seek_origin_current;
+    }
+
+    result = pWav->onSeek(pWav->pReadSeekTellUserData, offset, maSeekOrigin);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+
+    return MA_TRUE;
+}
+#endif
+
+static ma_result ma_wav_init_internal(const ma_decoding_backend_config* pConfig, ma_wav* pWav)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pWav);
+    pWav->format = ma_format_unknown;   /* Use closest match to source file by default. */
+
+    if (pConfig != NULL && (pConfig->preferredFormat == ma_format_f32 || pConfig->preferredFormat == ma_format_s16 || pConfig->preferredFormat == ma_format_s32)) {
+        pWav->format = pConfig->preferredFormat;
+    } else {
+        /* Getting here means something other than f32 and s16 was specified. Just leave this unset to use the default format. */
+    }
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_wav_ds_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pWav->ds);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the base data source. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_wav_post_init(ma_wav* pWav)
+{
+    /*
+    If an explicit format was not specified, try picking the closest match based on the internal
+    format. The format needs to be supported by miniaudio.
+    */
+    if (pWav->format == ma_format_unknown) {
+        switch (pWav->dr.translatedFormatTag)
+        {
+            case MA_DR_WAVE_FORMAT_PCM:
+            {
+                if (pWav->dr.bitsPerSample == 8) {
+                    pWav->format = ma_format_u8;
+                } else if (pWav->dr.bitsPerSample == 16) {
+                    pWav->format = ma_format_s16;
+                } else if (pWav->dr.bitsPerSample == 24) {
+                    pWav->format = ma_format_s24;
+                } else if (pWav->dr.bitsPerSample == 32) {
+                    pWav->format = ma_format_s32;
+                }
+            } break;
+
+            case MA_DR_WAVE_FORMAT_IEEE_FLOAT:
+            {
+                if (pWav->dr.bitsPerSample == 32) {
+                    pWav->format = ma_format_f32;
+                }
+            } break;
+
+            default: break;
+        }
+
+        /* Fall back to f32 if we couldn't find anything. */
+        if (pWav->format == ma_format_unknown) {
+            pWav->format =  ma_format_f32;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_wav_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav)
+{
+    ma_result result;
+
+    result = ma_wav_init_internal(pConfig, pWav);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (onRead == NULL || onSeek == NULL) {
+        return MA_INVALID_ARGS; /* onRead and onSeek are mandatory. */
+    }
+
+    pWav->onRead = onRead;
+    pWav->onSeek = onSeek;
+    pWav->onTell = onTell;
+    pWav->pReadSeekTellUserData = pReadSeekTellUserData;
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_bool32 wavResult;
+
+        wavResult = ma_dr_wav_init(&pWav->dr, ma_wav_dr_callback__read, ma_wav_dr_callback__seek, pWav, pAllocationCallbacks);
+        if (wavResult != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_wav_post_init(pWav);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. */
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav)
+{
+    ma_result result;
+
+    result = ma_wav_init_internal(pConfig, pWav);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_bool32 wavResult;
+
+        wavResult = ma_dr_wav_init_file(&pWav->dr, pFilePath, pAllocationCallbacks);
+        if (wavResult != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_wav_post_init(pWav);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav)
+{
+    ma_result result;
+
+    result = ma_wav_init_internal(pConfig, pWav);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_bool32 wavResult;
+
+        wavResult = ma_dr_wav_init_file_w(&pWav->dr, pFilePath, pAllocationCallbacks);
+        if (wavResult != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_wav_post_init(pWav);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_wav* pWav)
+{
+    ma_result result;
+
+    result = ma_wav_init_internal(pConfig, pWav);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_bool32 wavResult;
+
+        wavResult = ma_dr_wav_init_memory(&pWav->dr, pData, dataSize, pAllocationCallbacks);
+        if (wavResult != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_wav_post_init(pWav);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. */
+        (void)pData;
+        (void)dataSize;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API void ma_wav_uninit(ma_wav* pWav, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pWav == NULL) {
+        return;
+    }
+
+    (void)pAllocationCallbacks;
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_dr_wav_uninit(&pWav->dr);
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+    }
+    #endif
+
+    ma_data_source_uninit(&pWav->ds);
+}
+
+MA_API ma_result ma_wav_read_pcm_frames(ma_wav* pWav, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        /* We always use floating point format. */
+        ma_result result = MA_SUCCESS;  /* Must be initialized to MA_SUCCESS. */
+        ma_uint64 totalFramesRead = 0;
+        ma_format format;
+
+        ma_wav_get_data_format(pWav, &format, NULL, NULL, NULL, 0);
+
+        switch (format)
+        {
+            case ma_format_f32:
+            {
+                totalFramesRead = ma_dr_wav_read_pcm_frames_f32(&pWav->dr, frameCount, (float*)pFramesOut);
+            } break;
+
+            case ma_format_s16:
+            {
+                totalFramesRead = ma_dr_wav_read_pcm_frames_s16(&pWav->dr, frameCount, (ma_int16*)pFramesOut);
+            } break;
+
+            case ma_format_s32:
+            {
+                totalFramesRead = ma_dr_wav_read_pcm_frames_s32(&pWav->dr, frameCount, (ma_int32*)pFramesOut);
+            } break;
+
+            /* Fallback to a raw read. */
+            case ma_format_unknown: return MA_INVALID_OPERATION; /* <-- this should never be hit because initialization would just fall back to a supported format. */
+            default:
+            {
+                totalFramesRead = ma_dr_wav_read_pcm_frames(&pWav->dr, frameCount, pFramesOut);
+            } break;
+        }
+
+        /* In the future we'll update ma_dr_wav to return MA_AT_END for us. */
+        if (totalFramesRead == 0) {
+            result = MA_AT_END;
+        }
+
+        if (pFramesRead != NULL) {
+            *pFramesRead = totalFramesRead;
+        }
+
+        if (result == MA_SUCCESS && totalFramesRead == 0) {
+            result  = MA_AT_END;
+        }
+
+        return result;
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)pFramesOut;
+        (void)frameCount;
+        (void)pFramesRead;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_seek_to_pcm_frame(ma_wav* pWav, ma_uint64 frameIndex)
+{
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_bool32 wavResult;
+
+        wavResult = ma_dr_wav_seek_to_pcm_frame(&pWav->dr, frameIndex);
+        if (wavResult != MA_TRUE) {
+            return MA_ERROR;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)frameIndex;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_get_data_format(ma_wav* pWav, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* Defaults for safety. */
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pWav == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pWav->format;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        if (pChannels != NULL) {
+            *pChannels = pWav->dr.channels;
+        }
+
+        if (pSampleRate != NULL) {
+            *pSampleRate = pWav->dr.sampleRate;
+        }
+
+        if (pChannelMap != NULL) {
+            ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pChannelMap, channelMapCap, pWav->dr.channels);
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_get_cursor_in_pcm_frames(ma_wav* pWav, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;   /* Safety. */
+
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_result wavResult = ma_dr_wav_get_cursor_in_pcm_frames(&pWav->dr, pCursor);
+        if (wavResult != MA_SUCCESS) {
+            return (ma_result)wavResult;    /* ma_dr_wav result codes map to miniaudio's. */
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_wav_get_length_in_pcm_frames(ma_wav* pWav, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;   /* Safety. */
+
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_WAV)
+    {
+        ma_result wavResult = ma_dr_wav_get_length_in_pcm_frames(&pWav->dr, pLength);
+        if (wavResult != MA_SUCCESS) {
+            return (ma_result)wavResult;    /* ma_dr_wav result codes map to miniaudio's. */
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* wav is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+
+static ma_result ma_decoding_backend_init__wav(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_wav* pWav;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pWav = (ma_wav*)ma_malloc(sizeof(*pWav), pAllocationCallbacks);
+    if (pWav == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_wav_init(onRead, onSeek, onTell, pReadSeekTellUserData, pConfig, pAllocationCallbacks, pWav);
+    if (result != MA_SUCCESS) {
+        ma_free(pWav, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pWav;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file__wav(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_wav* pWav;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pWav = (ma_wav*)ma_malloc(sizeof(*pWav), pAllocationCallbacks);
+    if (pWav == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_wav_init_file(pFilePath, pConfig, pAllocationCallbacks, pWav);
+    if (result != MA_SUCCESS) {
+        ma_free(pWav, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pWav;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file_w__wav(void* pUserData, const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_wav* pWav;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pWav = (ma_wav*)ma_malloc(sizeof(*pWav), pAllocationCallbacks);
+    if (pWav == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_wav_init_file_w(pFilePath, pConfig, pAllocationCallbacks, pWav);
+    if (result != MA_SUCCESS) {
+        ma_free(pWav, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pWav;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_memory__wav(void* pUserData, const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_wav* pWav;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pWav = (ma_wav*)ma_malloc(sizeof(*pWav), pAllocationCallbacks);
+    if (pWav == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_wav_init_memory(pData, dataSize, pConfig, pAllocationCallbacks, pWav);
+    if (result != MA_SUCCESS) {
+        ma_free(pWav, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pWav;
+
+    return MA_SUCCESS;
+}
+
+static void ma_decoding_backend_uninit__wav(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_wav* pWav = (ma_wav*)pBackend;
+
+    (void)pUserData;
+
+    ma_wav_uninit(pWav, pAllocationCallbacks);
+    ma_free(pWav, pAllocationCallbacks);
+}
+
+static ma_decoding_backend_vtable g_ma_decoding_backend_vtable_wav =
+{
+    ma_decoding_backend_init__wav,
+    ma_decoding_backend_init_file__wav,
+    ma_decoding_backend_init_file_w__wav,
+    ma_decoding_backend_init_memory__wav,
+    ma_decoding_backend_uninit__wav
+};
+
+static ma_result ma_decoder_init_wav__internal(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_vtable__internal(&g_ma_decoding_backend_vtable_wav, NULL, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_wav_from_file__internal(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file__internal(&g_ma_decoding_backend_vtable_wav, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_wav_from_file_w__internal(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file_w__internal(&g_ma_decoding_backend_vtable_wav, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_wav_from_memory__internal(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_memory__internal(&g_ma_decoding_backend_vtable_wav, NULL, pData, dataSize, pConfig, pDecoder);
+}
+#endif  /* ma_dr_wav_h */
+
+/* FLAC */
+#ifdef ma_dr_flac_h
+#define MA_HAS_FLAC
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_read_proc onRead;
+    ma_seek_proc onSeek;
+    ma_tell_proc onTell;
+    void* pReadSeekTellUserData;
+    ma_format format;           /* Can be f32, s16 or s32. */
+#if !defined(MA_NO_FLAC)
+    ma_dr_flac* dr;
+#endif
+} ma_flac;
+
+MA_API ma_result ma_flac_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac);
+MA_API ma_result ma_flac_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac);
+MA_API ma_result ma_flac_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac);
+MA_API ma_result ma_flac_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac);
+MA_API void ma_flac_uninit(ma_flac* pFlac, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_flac_read_pcm_frames(ma_flac* pFlac, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_flac_seek_to_pcm_frame(ma_flac* pFlac, ma_uint64 frameIndex);
+MA_API ma_result ma_flac_get_data_format(ma_flac* pFlac, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_flac_get_cursor_in_pcm_frames(ma_flac* pFlac, ma_uint64* pCursor);
+MA_API ma_result ma_flac_get_length_in_pcm_frames(ma_flac* pFlac, ma_uint64* pLength);
+
+
+static ma_result ma_flac_ds_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_flac_read_pcm_frames((ma_flac*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_flac_ds_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_flac_seek_to_pcm_frame((ma_flac*)pDataSource, frameIndex);
+}
+
+static ma_result ma_flac_ds_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_flac_get_data_format((ma_flac*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_flac_ds_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_flac_get_cursor_in_pcm_frames((ma_flac*)pDataSource, pCursor);
+}
+
+static ma_result ma_flac_ds_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_flac_get_length_in_pcm_frames((ma_flac*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_flac_ds_vtable =
+{
+    ma_flac_ds_read,
+    ma_flac_ds_seek,
+    ma_flac_ds_get_data_format,
+    ma_flac_ds_get_cursor,
+    ma_flac_ds_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+
+#if !defined(MA_NO_FLAC)
+static size_t ma_flac_dr_callback__read(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    ma_flac* pFlac = (ma_flac*)pUserData;
+    ma_result result;
+    size_t bytesRead;
+
+    MA_ASSERT(pFlac != NULL);
+
+    result = pFlac->onRead(pFlac->pReadSeekTellUserData, pBufferOut, bytesToRead, &bytesRead);
+    (void)result;
+
+    return bytesRead;
+}
+
+static ma_bool32 ma_flac_dr_callback__seek(void* pUserData, int offset, ma_dr_flac_seek_origin origin)
+{
+    ma_flac* pFlac = (ma_flac*)pUserData;
+    ma_result result;
+    ma_seek_origin maSeekOrigin;
+
+    MA_ASSERT(pFlac != NULL);
+
+    maSeekOrigin = ma_seek_origin_start;
+    if (origin == ma_dr_flac_seek_origin_current) {
+        maSeekOrigin =  ma_seek_origin_current;
+    }
+
+    result = pFlac->onSeek(pFlac->pReadSeekTellUserData, offset, maSeekOrigin);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+
+    return MA_TRUE;
+}
+#endif
+
+static ma_result ma_flac_init_internal(const ma_decoding_backend_config* pConfig, ma_flac* pFlac)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pFlac == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pFlac);
+    pFlac->format = ma_format_f32;    /* f32 by default. */
+
+    if (pConfig != NULL && (pConfig->preferredFormat == ma_format_f32 || pConfig->preferredFormat == ma_format_s16 || pConfig->preferredFormat == ma_format_s32)) {
+        pFlac->format = pConfig->preferredFormat;
+    } else {
+        /* Getting here means something other than f32 and s16 was specified. Just leave this unset to use the default format. */
+    }
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_flac_ds_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pFlac->ds);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the base data source. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_flac_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac)
+{
+    ma_result result;
+
+    result = ma_flac_init_internal(pConfig, pFlac);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (onRead == NULL || onSeek == NULL) {
+        return MA_INVALID_ARGS; /* onRead and onSeek are mandatory. */
+    }
+
+    pFlac->onRead = onRead;
+    pFlac->onSeek = onSeek;
+    pFlac->onTell = onTell;
+    pFlac->pReadSeekTellUserData = pReadSeekTellUserData;
+
+    #if !defined(MA_NO_FLAC)
+    {
+        pFlac->dr = ma_dr_flac_open(ma_flac_dr_callback__read, ma_flac_dr_callback__seek, pFlac, pAllocationCallbacks);
+        if (pFlac->dr == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. */
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac)
+{
+    ma_result result;
+
+    result = ma_flac_init_internal(pConfig, pFlac);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        pFlac->dr = ma_dr_flac_open_file(pFilePath, pAllocationCallbacks);
+        if (pFlac->dr == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac)
+{
+    ma_result result;
+
+    result = ma_flac_init_internal(pConfig, pFlac);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        pFlac->dr = ma_dr_flac_open_file_w(pFilePath, pAllocationCallbacks);
+        if (pFlac->dr == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_flac* pFlac)
+{
+    ma_result result;
+
+    result = ma_flac_init_internal(pConfig, pFlac);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        pFlac->dr = ma_dr_flac_open_memory(pData, dataSize, pAllocationCallbacks);
+        if (pFlac->dr == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. */
+        (void)pData;
+        (void)dataSize;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API void ma_flac_uninit(ma_flac* pFlac, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFlac == NULL) {
+        return;
+    }
+
+    (void)pAllocationCallbacks;
+
+    #if !defined(MA_NO_FLAC)
+    {
+        ma_dr_flac_close(pFlac->dr);
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+    }
+    #endif
+
+    ma_data_source_uninit(&pFlac->ds);
+}
+
+MA_API ma_result ma_flac_read_pcm_frames(ma_flac* pFlac, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFlac == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        /* We always use floating point format. */
+        ma_result result = MA_SUCCESS;  /* Must be initialized to MA_SUCCESS. */
+        ma_uint64 totalFramesRead = 0;
+        ma_format format;
+
+        ma_flac_get_data_format(pFlac, &format, NULL, NULL, NULL, 0);
+
+        switch (format)
+        {
+            case ma_format_f32:
+            {
+                totalFramesRead = ma_dr_flac_read_pcm_frames_f32(pFlac->dr, frameCount, (float*)pFramesOut);
+            } break;
+
+            case ma_format_s16:
+            {
+                totalFramesRead = ma_dr_flac_read_pcm_frames_s16(pFlac->dr, frameCount, (ma_int16*)pFramesOut);
+            } break;
+
+            case ma_format_s32:
+            {
+                totalFramesRead = ma_dr_flac_read_pcm_frames_s32(pFlac->dr, frameCount, (ma_int32*)pFramesOut);
+            } break;
+
+            case ma_format_u8:
+            case ma_format_s24:
+            case ma_format_unknown:
+            default:
+            {
+                return MA_INVALID_OPERATION;
+            };
+        }
+
+        /* In the future we'll update ma_dr_flac to return MA_AT_END for us. */
+        if (totalFramesRead == 0) {
+            result = MA_AT_END;
+        }
+
+        if (pFramesRead != NULL) {
+            *pFramesRead = totalFramesRead;
+        }
+
+        if (result == MA_SUCCESS && totalFramesRead == 0) {
+            result  = MA_AT_END;
+        }
+
+        return result;
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)pFramesOut;
+        (void)frameCount;
+        (void)pFramesRead;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_seek_to_pcm_frame(ma_flac* pFlac, ma_uint64 frameIndex)
+{
+    if (pFlac == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        ma_bool32 flacResult;
+
+        flacResult = ma_dr_flac_seek_to_pcm_frame(pFlac->dr, frameIndex);
+        if (flacResult != MA_TRUE) {
+            return MA_ERROR;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)frameIndex;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_get_data_format(ma_flac* pFlac, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* Defaults for safety. */
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pFlac == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pFlac->format;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        if (pChannels != NULL) {
+            *pChannels = pFlac->dr->channels;
+        }
+
+        if (pSampleRate != NULL) {
+            *pSampleRate = pFlac->dr->sampleRate;
+        }
+
+        if (pChannelMap != NULL) {
+            ma_channel_map_init_standard(ma_standard_channel_map_microsoft, pChannelMap, channelMapCap, pFlac->dr->channels);
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_get_cursor_in_pcm_frames(ma_flac* pFlac, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;   /* Safety. */
+
+    if (pFlac == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        *pCursor = pFlac->dr->currentPCMFrame;
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_flac_get_length_in_pcm_frames(ma_flac* pFlac, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;   /* Safety. */
+
+    if (pFlac == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_FLAC)
+    {
+        *pLength = pFlac->dr->totalPCMFrameCount;
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* flac is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+
+static ma_result ma_decoding_backend_init__flac(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_flac* pFlac;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pFlac = (ma_flac*)ma_malloc(sizeof(*pFlac), pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_flac_init(onRead, onSeek, onTell, pReadSeekTellUserData, pConfig, pAllocationCallbacks, pFlac);
+    if (result != MA_SUCCESS) {
+        ma_free(pFlac, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pFlac;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file__flac(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_flac* pFlac;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pFlac = (ma_flac*)ma_malloc(sizeof(*pFlac), pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_flac_init_file(pFilePath, pConfig, pAllocationCallbacks, pFlac);
+    if (result != MA_SUCCESS) {
+        ma_free(pFlac, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pFlac;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file_w__flac(void* pUserData, const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_flac* pFlac;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pFlac = (ma_flac*)ma_malloc(sizeof(*pFlac), pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_flac_init_file_w(pFilePath, pConfig, pAllocationCallbacks, pFlac);
+    if (result != MA_SUCCESS) {
+        ma_free(pFlac, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pFlac;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_memory__flac(void* pUserData, const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_flac* pFlac;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pFlac = (ma_flac*)ma_malloc(sizeof(*pFlac), pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_flac_init_memory(pData, dataSize, pConfig, pAllocationCallbacks, pFlac);
+    if (result != MA_SUCCESS) {
+        ma_free(pFlac, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pFlac;
+
+    return MA_SUCCESS;
+}
+
+static void ma_decoding_backend_uninit__flac(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_flac* pFlac = (ma_flac*)pBackend;
+
+    (void)pUserData;
+
+    ma_flac_uninit(pFlac, pAllocationCallbacks);
+    ma_free(pFlac, pAllocationCallbacks);
+}
+
+static ma_decoding_backend_vtable g_ma_decoding_backend_vtable_flac =
+{
+    ma_decoding_backend_init__flac,
+    ma_decoding_backend_init_file__flac,
+    ma_decoding_backend_init_file_w__flac,
+    ma_decoding_backend_init_memory__flac,
+    ma_decoding_backend_uninit__flac
+};
+
+static ma_result ma_decoder_init_flac__internal(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_vtable__internal(&g_ma_decoding_backend_vtable_flac, NULL, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_flac_from_file__internal(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file__internal(&g_ma_decoding_backend_vtable_flac, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_flac_from_file_w__internal(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file_w__internal(&g_ma_decoding_backend_vtable_flac, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_flac_from_memory__internal(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_memory__internal(&g_ma_decoding_backend_vtable_flac, NULL, pData, dataSize, pConfig, pDecoder);
+}
+#endif  /* ma_dr_flac_h */
+
+/* MP3 */
+#ifdef ma_dr_mp3_h
+#define MA_HAS_MP3
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_read_proc onRead;
+    ma_seek_proc onSeek;
+    ma_tell_proc onTell;
+    void* pReadSeekTellUserData;
+    ma_format format;           /* Can be f32 or s16. */
+#if !defined(MA_NO_MP3)
+    ma_dr_mp3 dr;
+    ma_uint32 seekPointCount;
+    ma_dr_mp3_seek_point* pSeekPoints;  /* Only used if seek table generation is used. */
+#endif
+} ma_mp3;
+
+MA_API ma_result ma_mp3_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3);
+MA_API ma_result ma_mp3_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3);
+MA_API ma_result ma_mp3_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3);
+MA_API ma_result ma_mp3_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3);
+MA_API void ma_mp3_uninit(ma_mp3* pMP3, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_mp3_read_pcm_frames(ma_mp3* pMP3, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_mp3_seek_to_pcm_frame(ma_mp3* pMP3, ma_uint64 frameIndex);
+MA_API ma_result ma_mp3_get_data_format(ma_mp3* pMP3, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_mp3_get_cursor_in_pcm_frames(ma_mp3* pMP3, ma_uint64* pCursor);
+MA_API ma_result ma_mp3_get_length_in_pcm_frames(ma_mp3* pMP3, ma_uint64* pLength);
+
+
+static ma_result ma_mp3_ds_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_mp3_read_pcm_frames((ma_mp3*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_mp3_ds_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_mp3_seek_to_pcm_frame((ma_mp3*)pDataSource, frameIndex);
+}
+
+static ma_result ma_mp3_ds_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_mp3_get_data_format((ma_mp3*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_mp3_ds_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_mp3_get_cursor_in_pcm_frames((ma_mp3*)pDataSource, pCursor);
+}
+
+static ma_result ma_mp3_ds_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_mp3_get_length_in_pcm_frames((ma_mp3*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_mp3_ds_vtable =
+{
+    ma_mp3_ds_read,
+    ma_mp3_ds_seek,
+    ma_mp3_ds_get_data_format,
+    ma_mp3_ds_get_cursor,
+    ma_mp3_ds_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+
+#if !defined(MA_NO_MP3)
+static size_t ma_mp3_dr_callback__read(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    ma_mp3* pMP3 = (ma_mp3*)pUserData;
+    ma_result result;
+    size_t bytesRead;
+
+    MA_ASSERT(pMP3 != NULL);
+
+    result = pMP3->onRead(pMP3->pReadSeekTellUserData, pBufferOut, bytesToRead, &bytesRead);
+    (void)result;
+
+    return bytesRead;
+}
+
+static ma_bool32 ma_mp3_dr_callback__seek(void* pUserData, int offset, ma_dr_mp3_seek_origin origin)
+{
+    ma_mp3* pMP3 = (ma_mp3*)pUserData;
+    ma_result result;
+    ma_seek_origin maSeekOrigin;
+
+    MA_ASSERT(pMP3 != NULL);
+
+    maSeekOrigin = ma_seek_origin_start;
+    if (origin == ma_dr_mp3_seek_origin_current) {
+        maSeekOrigin =  ma_seek_origin_current;
+    }
+
+    result = pMP3->onSeek(pMP3->pReadSeekTellUserData, offset, maSeekOrigin);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+
+    return MA_TRUE;
+}
+#endif
+
+static ma_result ma_mp3_init_internal(const ma_decoding_backend_config* pConfig, ma_mp3* pMP3)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pMP3 == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pMP3);
+    pMP3->format = ma_format_f32;    /* f32 by default. */
+
+    if (pConfig != NULL && (pConfig->preferredFormat == ma_format_f32 || pConfig->preferredFormat == ma_format_s16)) {
+        pMP3->format = pConfig->preferredFormat;
+    } else {
+        /* Getting here means something other than f32 and s16 was specified. Just leave this unset to use the default format. */
+    }
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_mp3_ds_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pMP3->ds);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the base data source. */
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_mp3_generate_seek_table(ma_mp3* pMP3, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 mp3Result;
+    ma_uint32 seekPointCount = 0;
+    ma_dr_mp3_seek_point* pSeekPoints = NULL;
+
+    MA_ASSERT(pMP3    != NULL);
+    MA_ASSERT(pConfig != NULL);
+
+    seekPointCount = pConfig->seekPointCount;
+    if (seekPointCount > 0) {
+        pSeekPoints = (ma_dr_mp3_seek_point*)ma_malloc(sizeof(*pMP3->pSeekPoints) * seekPointCount, pAllocationCallbacks);
+        if (pSeekPoints == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    }
+
+    mp3Result = ma_dr_mp3_calculate_seek_points(&pMP3->dr, &seekPointCount, pSeekPoints);
+    if (mp3Result != MA_TRUE) {
+        ma_free(pSeekPoints, pAllocationCallbacks);
+        return MA_ERROR;
+    }
+
+    mp3Result = ma_dr_mp3_bind_seek_table(&pMP3->dr, seekPointCount, pSeekPoints);
+    if (mp3Result != MA_TRUE) {
+        ma_free(pSeekPoints, pAllocationCallbacks);
+        return MA_ERROR;
+    }
+
+    pMP3->seekPointCount = seekPointCount;
+    pMP3->pSeekPoints    = pSeekPoints;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_mp3_post_init(ma_mp3* pMP3, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_result result;
+
+    result = ma_mp3_generate_seek_table(pMP3, pConfig, pAllocationCallbacks);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_mp3_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3)
+{
+    ma_result result;
+
+    result = ma_mp3_init_internal(pConfig, pMP3);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (onRead == NULL || onSeek == NULL) {
+        return MA_INVALID_ARGS; /* onRead and onSeek are mandatory. */
+    }
+
+    pMP3->onRead = onRead;
+    pMP3->onSeek = onSeek;
+    pMP3->onTell = onTell;
+    pMP3->pReadSeekTellUserData = pReadSeekTellUserData;
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_bool32 mp3Result;
+
+        mp3Result = ma_dr_mp3_init(&pMP3->dr, ma_mp3_dr_callback__read, ma_mp3_dr_callback__seek, pMP3, pAllocationCallbacks);
+        if (mp3Result != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_mp3_post_init(pMP3, pConfig, pAllocationCallbacks);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. */
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3)
+{
+    ma_result result;
+
+    result = ma_mp3_init_internal(pConfig, pMP3);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_bool32 mp3Result;
+
+        mp3Result = ma_dr_mp3_init_file(&pMP3->dr, pFilePath, pAllocationCallbacks);
+        if (mp3Result != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_mp3_post_init(pMP3, pConfig, pAllocationCallbacks);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_init_file_w(const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3)
+{
+    ma_result result;
+
+    result = ma_mp3_init_internal(pConfig, pMP3);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_bool32 mp3Result;
+
+        mp3Result = ma_dr_mp3_init_file_w(&pMP3->dr, pFilePath, pAllocationCallbacks);
+        if (mp3Result != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_mp3_post_init(pMP3, pConfig, pAllocationCallbacks);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_mp3* pMP3)
+{
+    ma_result result;
+
+    result = ma_mp3_init_internal(pConfig, pMP3);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_bool32 mp3Result;
+
+        mp3Result = ma_dr_mp3_init_memory(&pMP3->dr, pData, dataSize, pAllocationCallbacks);
+        if (mp3Result != MA_TRUE) {
+            return MA_INVALID_FILE;
+        }
+
+        ma_mp3_post_init(pMP3, pConfig, pAllocationCallbacks);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. */
+        (void)pData;
+        (void)dataSize;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API void ma_mp3_uninit(ma_mp3* pMP3, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pMP3 == NULL) {
+        return;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_dr_mp3_uninit(&pMP3->dr);
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+    }
+    #endif
+
+    /* Seek points need to be freed after the MP3 decoder has been uninitialized to ensure they're no longer being referenced. */
+    ma_free(pMP3->pSeekPoints, pAllocationCallbacks);
+
+    ma_data_source_uninit(&pMP3->ds);
+}
+
+MA_API ma_result ma_mp3_read_pcm_frames(ma_mp3* pMP3, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pMP3 == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        /* We always use floating point format. */
+        ma_result result = MA_SUCCESS;  /* Must be initialized to MA_SUCCESS. */
+        ma_uint64 totalFramesRead = 0;
+        ma_format format;
+
+        ma_mp3_get_data_format(pMP3, &format, NULL, NULL, NULL, 0);
+
+        switch (format)
+        {
+            case ma_format_f32:
+            {
+                totalFramesRead = ma_dr_mp3_read_pcm_frames_f32(&pMP3->dr, frameCount, (float*)pFramesOut);
+            } break;
+
+            case ma_format_s16:
+            {
+                totalFramesRead = ma_dr_mp3_read_pcm_frames_s16(&pMP3->dr, frameCount, (ma_int16*)pFramesOut);
+            } break;
+
+            case ma_format_u8:
+            case ma_format_s24:
+            case ma_format_s32:
+            case ma_format_unknown:
+            default:
+            {
+                return MA_INVALID_OPERATION;
+            };
+        }
+
+        /* In the future we'll update ma_dr_mp3 to return MA_AT_END for us. */
+        if (totalFramesRead == 0) {
+            result = MA_AT_END;
+        }
+
+        if (pFramesRead != NULL) {
+            *pFramesRead = totalFramesRead;
+        }
+
+        return result;
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)pFramesOut;
+        (void)frameCount;
+        (void)pFramesRead;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_seek_to_pcm_frame(ma_mp3* pMP3, ma_uint64 frameIndex)
+{
+    if (pMP3 == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        ma_bool32 mp3Result;
+
+        mp3Result = ma_dr_mp3_seek_to_pcm_frame(&pMP3->dr, frameIndex);
+        if (mp3Result != MA_TRUE) {
+            return MA_ERROR;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)frameIndex;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_get_data_format(ma_mp3* pMP3, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* Defaults for safety. */
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pMP3 == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pMP3->format;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        if (pChannels != NULL) {
+            *pChannels = pMP3->dr.channels;
+        }
+
+        if (pSampleRate != NULL) {
+            *pSampleRate = pMP3->dr.sampleRate;
+        }
+
+        if (pChannelMap != NULL) {
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pMP3->dr.channels);
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_get_cursor_in_pcm_frames(ma_mp3* pMP3, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;   /* Safety. */
+
+    if (pMP3 == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        *pCursor = pMP3->dr.currentPCMFrame;
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_mp3_get_length_in_pcm_frames(ma_mp3* pMP3, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;   /* Safety. */
+
+    if (pMP3 == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_MP3)
+    {
+        *pLength = ma_dr_mp3_get_pcm_frame_count(&pMP3->dr);
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* mp3 is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+
+static ma_result ma_decoding_backend_init__mp3(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_mp3* pMP3;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pMP3 = (ma_mp3*)ma_malloc(sizeof(*pMP3), pAllocationCallbacks);
+    if (pMP3 == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_mp3_init(onRead, onSeek, onTell, pReadSeekTellUserData, pConfig, pAllocationCallbacks, pMP3);
+    if (result != MA_SUCCESS) {
+        ma_free(pMP3, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pMP3;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file__mp3(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_mp3* pMP3;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pMP3 = (ma_mp3*)ma_malloc(sizeof(*pMP3), pAllocationCallbacks);
+    if (pMP3 == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_mp3_init_file(pFilePath, pConfig, pAllocationCallbacks, pMP3);
+    if (result != MA_SUCCESS) {
+        ma_free(pMP3, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pMP3;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file_w__mp3(void* pUserData, const wchar_t* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_mp3* pMP3;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pMP3 = (ma_mp3*)ma_malloc(sizeof(*pMP3), pAllocationCallbacks);
+    if (pMP3 == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_mp3_init_file_w(pFilePath, pConfig, pAllocationCallbacks, pMP3);
+    if (result != MA_SUCCESS) {
+        ma_free(pMP3, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pMP3;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_memory__mp3(void* pUserData, const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_mp3* pMP3;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pMP3 = (ma_mp3*)ma_malloc(sizeof(*pMP3), pAllocationCallbacks);
+    if (pMP3 == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_mp3_init_memory(pData, dataSize, pConfig, pAllocationCallbacks, pMP3);
+    if (result != MA_SUCCESS) {
+        ma_free(pMP3, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pMP3;
+
+    return MA_SUCCESS;
+}
+
+static void ma_decoding_backend_uninit__mp3(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_mp3* pMP3 = (ma_mp3*)pBackend;
+
+    (void)pUserData;
+
+    ma_mp3_uninit(pMP3, pAllocationCallbacks);
+    ma_free(pMP3, pAllocationCallbacks);
+}
+
+static ma_decoding_backend_vtable g_ma_decoding_backend_vtable_mp3 =
+{
+    ma_decoding_backend_init__mp3,
+    ma_decoding_backend_init_file__mp3,
+    ma_decoding_backend_init_file_w__mp3,
+    ma_decoding_backend_init_memory__mp3,
+    ma_decoding_backend_uninit__mp3
+};
+
+static ma_result ma_decoder_init_mp3__internal(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_vtable__internal(&g_ma_decoding_backend_vtable_mp3, NULL, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_mp3_from_file__internal(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file__internal(&g_ma_decoding_backend_vtable_mp3, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_mp3_from_file_w__internal(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file_w__internal(&g_ma_decoding_backend_vtable_mp3, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_mp3_from_memory__internal(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_memory__internal(&g_ma_decoding_backend_vtable_mp3, NULL, pData, dataSize, pConfig, pDecoder);
+}
+#endif  /* ma_dr_mp3_h */
+
+/* Vorbis */
+#ifdef STB_VORBIS_INCLUDE_STB_VORBIS_H
+#define MA_HAS_VORBIS
+
+/* The size in bytes of each chunk of data to read from the Vorbis stream. */
+#define MA_VORBIS_DATA_CHUNK_SIZE  4096
+
+typedef struct
+{
+    ma_data_source_base ds;
+    ma_read_proc onRead;
+    ma_seek_proc onSeek;
+    ma_tell_proc onTell;
+    void* pReadSeekTellUserData;
+    ma_allocation_callbacks allocationCallbacks;    /* Store the allocation callbacks within the structure because we may need to dynamically expand a buffer in ma_stbvorbis_read_pcm_frames() when using push mode. */
+    ma_format format;               /* Only f32 is allowed with stb_vorbis. */
+    ma_uint32 channels;
+    ma_uint32 sampleRate;
+    ma_uint64 cursor;
+#if !defined(MA_NO_VORBIS)
+    stb_vorbis* stb;
+    ma_bool32 usingPushMode;
+    struct
+    {
+        ma_uint8* pData;
+        size_t dataSize;
+        size_t dataCapacity;
+        size_t audioStartOffsetInBytes;
+        ma_uint32 framesConsumed;   /* The number of frames consumed in ppPacketData. */
+        ma_uint32 framesRemaining;  /* The number of frames remaining in ppPacketData. */
+        float** ppPacketData;
+    } push;
+#endif
+} ma_stbvorbis;
+
+MA_API ma_result ma_stbvorbis_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis);
+MA_API ma_result ma_stbvorbis_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis);
+MA_API ma_result ma_stbvorbis_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis);
+MA_API void ma_stbvorbis_uninit(ma_stbvorbis* pVorbis, const ma_allocation_callbacks* pAllocationCallbacks);
+MA_API ma_result ma_stbvorbis_read_pcm_frames(ma_stbvorbis* pVorbis, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead);
+MA_API ma_result ma_stbvorbis_seek_to_pcm_frame(ma_stbvorbis* pVorbis, ma_uint64 frameIndex);
+MA_API ma_result ma_stbvorbis_get_data_format(ma_stbvorbis* pVorbis, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_stbvorbis_get_cursor_in_pcm_frames(ma_stbvorbis* pVorbis, ma_uint64* pCursor);
+MA_API ma_result ma_stbvorbis_get_length_in_pcm_frames(ma_stbvorbis* pVorbis, ma_uint64* pLength);
+
+
+static ma_result ma_stbvorbis_ds_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_stbvorbis_read_pcm_frames((ma_stbvorbis*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_stbvorbis_ds_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_stbvorbis_seek_to_pcm_frame((ma_stbvorbis*)pDataSource, frameIndex);
+}
+
+static ma_result ma_stbvorbis_ds_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_stbvorbis_get_data_format((ma_stbvorbis*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_stbvorbis_ds_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_stbvorbis_get_cursor_in_pcm_frames((ma_stbvorbis*)pDataSource, pCursor);
+}
+
+static ma_result ma_stbvorbis_ds_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_stbvorbis_get_length_in_pcm_frames((ma_stbvorbis*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_stbvorbis_ds_vtable =
+{
+    ma_stbvorbis_ds_read,
+    ma_stbvorbis_ds_seek,
+    ma_stbvorbis_ds_get_data_format,
+    ma_stbvorbis_ds_get_cursor,
+    ma_stbvorbis_ds_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+
+static ma_result ma_stbvorbis_init_internal(const ma_decoding_backend_config* pConfig, ma_stbvorbis* pVorbis)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    (void)pConfig;
+
+    if (pVorbis == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pVorbis);
+    pVorbis->format = ma_format_f32;    /* Only supporting f32. */
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_stbvorbis_ds_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pVorbis->ds);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the base data source. */
+    }
+
+    return MA_SUCCESS;
+}
+
+#if !defined(MA_NO_VORBIS)
+static ma_result ma_stbvorbis_post_init(ma_stbvorbis* pVorbis)
+{
+    stb_vorbis_info info;
+
+    MA_ASSERT(pVorbis != NULL);
+
+    info = stb_vorbis_get_info(pVorbis->stb);
+
+    pVorbis->channels   = info.channels;
+    pVorbis->sampleRate = info.sample_rate;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_stbvorbis_init_internal_decoder_push(ma_stbvorbis* pVorbis)
+{
+    ma_result result;
+    stb_vorbis* stb;
+    size_t dataSize = 0;
+    size_t dataCapacity = 0;
+    ma_uint8* pData = NULL; /* <-- Must be initialized to NULL. */
+
+    for (;;) {
+        int vorbisError;
+        int consumedDataSize;   /* <-- Fill by stb_vorbis_open_pushdata(). */
+        size_t bytesRead;
+        ma_uint8* pNewData;
+
+        /* Allocate memory for the new chunk. */
+        dataCapacity += MA_VORBIS_DATA_CHUNK_SIZE;
+        pNewData = (ma_uint8*)ma_realloc(pData, dataCapacity, &pVorbis->allocationCallbacks);
+        if (pNewData == NULL) {
+            ma_free(pData, &pVorbis->allocationCallbacks);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        pData = pNewData;
+
+        /* Read in the next chunk. */
+        result = pVorbis->onRead(pVorbis->pReadSeekTellUserData, ma_offset_ptr(pData, dataSize), (dataCapacity - dataSize), &bytesRead);
+        dataSize += bytesRead;
+
+        if (result != MA_SUCCESS) {
+            ma_free(pData, &pVorbis->allocationCallbacks);
+            return result;
+        }
+
+        /* We have a maximum of 31 bits with stb_vorbis. */
+        if (dataSize > INT_MAX) {
+            ma_free(pData, &pVorbis->allocationCallbacks);
+            return MA_TOO_BIG;
+        }
+
+        stb = stb_vorbis_open_pushdata(pData, (int)dataSize, &consumedDataSize, &vorbisError, NULL);
+        if (stb != NULL) {
+            /*
+            Successfully opened the Vorbis decoder. We might have some leftover unprocessed
+            data so we'll need to move that down to the front.
+            */
+            dataSize -= (size_t)consumedDataSize;   /* Consume the data. */
+            MA_MOVE_MEMORY(pData, ma_offset_ptr(pData, consumedDataSize), dataSize);
+
+            /*
+            We need to track the start point so we can seek back to the start of the audio
+            data when seeking.
+            */
+            pVorbis->push.audioStartOffsetInBytes = consumedDataSize;
+
+            break;
+        } else {
+            /* Failed to open the decoder. */
+            if (vorbisError == VORBIS_need_more_data) {
+                continue;
+            } else {
+                ma_free(pData, &pVorbis->allocationCallbacks);
+                return MA_ERROR;   /* Failed to open the stb_vorbis decoder. */
+            }
+        }
+    }
+
+    MA_ASSERT(stb != NULL);
+    pVorbis->stb = stb;
+    pVorbis->push.pData = pData;
+    pVorbis->push.dataSize = dataSize;
+    pVorbis->push.dataCapacity = dataCapacity;
+
+    return MA_SUCCESS;
+}
+#endif
+
+MA_API ma_result ma_stbvorbis_init(ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis)
+{
+    ma_result result;
+
+    result = ma_stbvorbis_init_internal(pConfig, pVorbis);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (onRead == NULL || onSeek == NULL) {
+        return MA_INVALID_ARGS; /* onRead and onSeek are mandatory. */
+    }
+
+    pVorbis->onRead = onRead;
+    pVorbis->onSeek = onSeek;
+    pVorbis->onTell = onTell;
+    pVorbis->pReadSeekTellUserData = pReadSeekTellUserData;
+    ma_allocation_callbacks_init_copy(&pVorbis->allocationCallbacks, pAllocationCallbacks);
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        /*
+        stb_vorbis lacks a callback based API for it's pulling API which means we're stuck with the
+        pushing API. In order for us to be able to successfully initialize the decoder we need to
+        supply it with enough data. We need to keep loading data until we have enough.
+        */
+        result = ma_stbvorbis_init_internal_decoder_push(pVorbis);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pVorbis->usingPushMode = MA_TRUE;
+
+        result = ma_stbvorbis_post_init(pVorbis);
+        if (result != MA_SUCCESS) {
+            stb_vorbis_close(pVorbis->stb);
+            ma_free(pVorbis->push.pData, pAllocationCallbacks);
+            return result;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. */
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_init_file(const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis)
+{
+    ma_result result;
+
+    result = ma_stbvorbis_init_internal(pConfig, pVorbis);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        (void)pAllocationCallbacks; /* Don't know how to make use of this with stb_vorbis. */
+
+        /* We can use stb_vorbis' pull mode for file based streams. */
+        pVorbis->stb = stb_vorbis_open_filename(pFilePath, NULL, NULL);
+        if (pVorbis->stb == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        pVorbis->usingPushMode = MA_FALSE;
+
+        result = ma_stbvorbis_post_init(pVorbis);
+        if (result != MA_SUCCESS) {
+            stb_vorbis_close(pVorbis->stb);
+            return result;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. */
+        (void)pFilePath;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_init_memory(const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_stbvorbis* pVorbis)
+{
+    ma_result result;
+
+    result = ma_stbvorbis_init_internal(pConfig, pVorbis);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        (void)pAllocationCallbacks;
+
+        /* stb_vorbis uses an int as it's size specifier, restricting it to 32-bit even on 64-bit systems. *sigh*. */
+        if (dataSize > INT_MAX) {
+            return MA_TOO_BIG;
+        }
+
+        pVorbis->stb = stb_vorbis_open_memory((const unsigned char*)pData, (int)dataSize, NULL, NULL);
+        if (pVorbis->stb == NULL) {
+            return MA_INVALID_FILE;
+        }
+
+        pVorbis->usingPushMode = MA_FALSE;
+
+        result = ma_stbvorbis_post_init(pVorbis);
+        if (result != MA_SUCCESS) {
+            stb_vorbis_close(pVorbis->stb);
+            return result;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. */
+        (void)pData;
+        (void)dataSize;
+        (void)pAllocationCallbacks;
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API void ma_stbvorbis_uninit(ma_stbvorbis* pVorbis, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pVorbis == NULL) {
+        return;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        stb_vorbis_close(pVorbis->stb);
+
+        /* We'll have to clear some memory if we're using push mode. */
+        if (pVorbis->usingPushMode) {
+            ma_free(pVorbis->push.pData, pAllocationCallbacks);
+        }
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+    }
+    #endif
+
+    ma_data_source_uninit(&pVorbis->ds);
+}
+
+MA_API ma_result ma_stbvorbis_read_pcm_frames(ma_stbvorbis* pVorbis, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pVorbis == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        /* We always use floating point format. */
+        ma_result result = MA_SUCCESS;  /* Must be initialized to MA_SUCCESS. */
+        ma_uint64 totalFramesRead = 0;
+        ma_format format;
+        ma_uint32 channels;
+
+        ma_stbvorbis_get_data_format(pVorbis, &format, &channels, NULL, NULL, 0);
+
+        if (format == ma_format_f32) {
+            /* We read differently depending on whether or not we're using push mode. */
+            if (pVorbis->usingPushMode) {
+                /* Push mode. This is the complex case. */
+                float* pFramesOutF32 = (float*)pFramesOut;
+
+                while (totalFramesRead < frameCount) {
+                    /* The first thing to do is read from any already-cached frames. */
+                    ma_uint32 framesToReadFromCache = (ma_uint32)ma_min(pVorbis->push.framesRemaining, (frameCount - totalFramesRead));  /* Safe cast because pVorbis->framesRemaining is 32-bit. */
+
+                    /* The output pointer can be null in which case we just treate it as a seek. */
+                    if (pFramesOut != NULL) {
+                        ma_uint64 iFrame;
+                        for (iFrame = 0; iFrame < framesToReadFromCache; iFrame += 1) {
+                            ma_uint32 iChannel;
+                            for (iChannel = 0; iChannel < pVorbis->channels; iChannel += 1) {
+                                pFramesOutF32[iChannel] = pVorbis->push.ppPacketData[iChannel][pVorbis->push.framesConsumed + iFrame];
+                            }
+
+                            pFramesOutF32 += pVorbis->channels;
+                        }
+                    }
+
+                    /* Update pointers and counters. */
+                    pVorbis->push.framesConsumed  += framesToReadFromCache;
+                    pVorbis->push.framesRemaining -= framesToReadFromCache;
+                    totalFramesRead               += framesToReadFromCache;
+
+                    /* Don't bother reading any more frames right now if we've just finished loading. */
+                    if (totalFramesRead == frameCount) {
+                        break;
+                    }
+
+                    MA_ASSERT(pVorbis->push.framesRemaining == 0);
+
+                    /* Getting here means we've run out of cached frames. We'll need to load some more. */
+                    for (;;) {
+                        int samplesRead = 0;
+                        int consumedDataSize;
+
+                        /* We need to case dataSize to an int, so make sure we can do it safely. */
+                        if (pVorbis->push.dataSize > INT_MAX) {
+                            break;  /* Too big. */
+                        }
+
+                        consumedDataSize = stb_vorbis_decode_frame_pushdata(pVorbis->stb, pVorbis->push.pData, (int)pVorbis->push.dataSize, NULL, &pVorbis->push.ppPacketData, &samplesRead);
+                        if (consumedDataSize != 0) {
+                            /* Successfully decoded a Vorbis frame. Consume the data. */
+                            pVorbis->push.dataSize -= (size_t)consumedDataSize;
+                            MA_MOVE_MEMORY(pVorbis->push.pData, ma_offset_ptr(pVorbis->push.pData, consumedDataSize), pVorbis->push.dataSize);
+
+                            pVorbis->push.framesConsumed  = 0;
+                            pVorbis->push.framesRemaining = samplesRead;
+
+                            break;
+                        } else {
+                            /* Not enough data. Read more. */
+                            size_t bytesRead;
+
+                            /* Expand the data buffer if necessary. */
+                            if (pVorbis->push.dataCapacity == pVorbis->push.dataSize) {
+                                size_t newCap = pVorbis->push.dataCapacity + MA_VORBIS_DATA_CHUNK_SIZE;
+                                ma_uint8* pNewData;
+
+                                pNewData = (ma_uint8*)ma_realloc(pVorbis->push.pData, newCap, &pVorbis->allocationCallbacks);
+                                if (pNewData == NULL) {
+                                    result = MA_OUT_OF_MEMORY;
+                                    break;
+                                }
+
+                                pVorbis->push.pData = pNewData;
+                                pVorbis->push.dataCapacity = newCap;
+                            }
+
+                            /* We should have enough room to load some data. */
+                            result = pVorbis->onRead(pVorbis->pReadSeekTellUserData, ma_offset_ptr(pVorbis->push.pData, pVorbis->push.dataSize), (pVorbis->push.dataCapacity - pVorbis->push.dataSize), &bytesRead);
+                            pVorbis->push.dataSize += bytesRead;
+
+                            if (result != MA_SUCCESS) {
+                                break;  /* Failed to read any data. Get out. */
+                            }
+                        }
+                    }
+
+                    /* If we don't have a success code at this point it means we've encounted an error or the end of the file has been reached (probably the latter). */
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+                }
+            } else {
+                /* Pull mode. This is the simple case, but we still need to run in a loop because stb_vorbis loves using 32-bit instead of 64-bit. */
+                while (totalFramesRead < frameCount) {
+                    ma_uint64 framesRemaining = (frameCount - totalFramesRead);
+                    int framesRead;
+
+                    if (framesRemaining > INT_MAX) {
+                        framesRemaining = INT_MAX;
+                    }
+
+                    framesRead = stb_vorbis_get_samples_float_interleaved(pVorbis->stb, channels, (float*)ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, format, channels), (int)framesRemaining * channels);   /* Safe cast. */
+                    totalFramesRead += framesRead;
+
+                    if (framesRead < (int)framesRemaining) {
+                        break;  /* Nothing left to read. Get out. */
+                    }
+                }
+            }
+        } else {
+            result = MA_INVALID_ARGS;
+        }
+
+        pVorbis->cursor += totalFramesRead;
+
+        if (totalFramesRead == 0) {
+            result = MA_AT_END;
+        }
+
+        if (pFramesRead != NULL) {
+            *pFramesRead = totalFramesRead;
+        }
+
+        if (result == MA_SUCCESS && totalFramesRead == 0) {
+            result  = MA_AT_END;
+        }
+
+        return result;
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)pFramesOut;
+        (void)frameCount;
+        (void)pFramesRead;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_seek_to_pcm_frame(ma_stbvorbis* pVorbis, ma_uint64 frameIndex)
+{
+    if (pVorbis == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        /* Different seeking methods depending on whether or not we're using push mode. */
+        if (pVorbis->usingPushMode) {
+            /* Push mode. This is the complex case. */
+            ma_result result;
+            float buffer[4096];
+
+            /* If we're seeking backwards, we need to seek back to the start and then brute-force forward. */
+            if (frameIndex < pVorbis->cursor) {
+                if (frameIndex > 0x7FFFFFFF) {
+                    return MA_INVALID_ARGS; /* Trying to seek beyond the 32-bit maximum of stb_vorbis. */
+                }
+
+                /*
+                This is wildly inefficient due to me having trouble getting sample exact seeking working
+                robustly with stb_vorbis_flush_pushdata(). The only way I can think to make this work
+                perfectly is to reinitialize the decoder. Note that we only enter this path when seeking
+                backwards. This will hopefully be removed once we get our own Vorbis decoder implemented.
+                */
+                stb_vorbis_close(pVorbis->stb);
+                ma_free(pVorbis->push.pData, &pVorbis->allocationCallbacks);
+
+                MA_ZERO_OBJECT(&pVorbis->push);
+
+                /* Seek to the start of the file. */
+                result = pVorbis->onSeek(pVorbis->pReadSeekTellUserData, 0, ma_seek_origin_start);
+                if (result != MA_SUCCESS) {
+                    return result;
+                }
+
+                result = ma_stbvorbis_init_internal_decoder_push(pVorbis);
+                if (result != MA_SUCCESS) {
+                    return result;
+                }
+
+                /* At this point we should be sitting on the first frame. */
+                pVorbis->cursor = 0;
+            }
+
+            /* We're just brute-forcing this for now. */
+            while (pVorbis->cursor < frameIndex) {
+                ma_uint64 framesRead;
+                ma_uint64 framesToRead = ma_countof(buffer)/pVorbis->channels;
+                if (framesToRead > (frameIndex - pVorbis->cursor)) {
+                    framesToRead = (frameIndex - pVorbis->cursor);
+                }
+
+                result = ma_stbvorbis_read_pcm_frames(pVorbis, buffer, framesToRead, &framesRead);
+                if (result != MA_SUCCESS) {
+                    return result;
+                }
+            }
+        } else {
+            /* Pull mode. This is the simple case. */
+            int vorbisResult;
+
+            if (frameIndex > UINT_MAX) {
+                return MA_INVALID_ARGS; /* Trying to seek beyond the 32-bit maximum of stb_vorbis. */
+            }
+
+            vorbisResult = stb_vorbis_seek(pVorbis->stb, (unsigned int)frameIndex);  /* Safe cast. */
+            if (vorbisResult == 0) {
+                return MA_ERROR;    /* See failed. */
+            }
+
+            pVorbis->cursor = frameIndex;
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+
+        (void)frameIndex;
+
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_get_data_format(ma_stbvorbis* pVorbis, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* Defaults for safety. */
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pVorbis == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pVorbis->format;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        if (pChannels != NULL) {
+            *pChannels = pVorbis->channels;
+        }
+
+        if (pSampleRate != NULL) {
+            *pSampleRate = pVorbis->sampleRate;
+        }
+
+        if (pChannelMap != NULL) {
+            ma_channel_map_init_standard(ma_standard_channel_map_vorbis, pChannelMap, channelMapCap, pVorbis->channels);
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_get_cursor_in_pcm_frames(ma_stbvorbis* pVorbis, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;   /* Safety. */
+
+    if (pVorbis == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        *pCursor = pVorbis->cursor;
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+MA_API ma_result ma_stbvorbis_get_length_in_pcm_frames(ma_stbvorbis* pVorbis, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;   /* Safety. */
+
+    if (pVorbis == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_VORBIS)
+    {
+        if (pVorbis->usingPushMode) {
+            *pLength = 0;   /* I don't know of a good way to determine this reliably with stb_vorbis and push mode. */
+        } else {
+            *pLength = stb_vorbis_stream_length_in_samples(pVorbis->stb);
+        }
+
+        return MA_SUCCESS;
+    }
+    #else
+    {
+        /* vorbis is disabled. Should never hit this since initialization would have failed. */
+        MA_ASSERT(MA_FALSE);
+        return MA_NOT_IMPLEMENTED;
+    }
+    #endif
+}
+
+
+static ma_result ma_decoding_backend_init__stbvorbis(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_stbvorbis* pVorbis;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pVorbis = (ma_stbvorbis*)ma_malloc(sizeof(*pVorbis), pAllocationCallbacks);
+    if (pVorbis == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_stbvorbis_init(onRead, onSeek, onTell, pReadSeekTellUserData, pConfig, pAllocationCallbacks, pVorbis);
+    if (result != MA_SUCCESS) {
+        ma_free(pVorbis, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pVorbis;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_file__stbvorbis(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_stbvorbis* pVorbis;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pVorbis = (ma_stbvorbis*)ma_malloc(sizeof(*pVorbis), pAllocationCallbacks);
+    if (pVorbis == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_stbvorbis_init_file(pFilePath, pConfig, pAllocationCallbacks, pVorbis);
+    if (result != MA_SUCCESS) {
+        ma_free(pVorbis, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pVorbis;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoding_backend_init_memory__stbvorbis(void* pUserData, const void* pData, size_t dataSize, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
+{
+    ma_result result;
+    ma_stbvorbis* pVorbis;
+
+    (void)pUserData;    /* For now not using pUserData, but once we start storing the vorbis decoder state within the ma_decoder structure this will be set to the decoder so we can avoid a malloc. */
+
+    /* For now we're just allocating the decoder backend on the heap. */
+    pVorbis = (ma_stbvorbis*)ma_malloc(sizeof(*pVorbis), pAllocationCallbacks);
+    if (pVorbis == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_stbvorbis_init_memory(pData, dataSize, pConfig, pAllocationCallbacks, pVorbis);
+    if (result != MA_SUCCESS) {
+        ma_free(pVorbis, pAllocationCallbacks);
+        return result;
+    }
+
+    *ppBackend = pVorbis;
+
+    return MA_SUCCESS;
+}
+
+static void ma_decoding_backend_uninit__stbvorbis(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_stbvorbis* pVorbis = (ma_stbvorbis*)pBackend;
+
+    (void)pUserData;
+
+    ma_stbvorbis_uninit(pVorbis, pAllocationCallbacks);
+    ma_free(pVorbis, pAllocationCallbacks);
+}
+
+static ma_decoding_backend_vtable g_ma_decoding_backend_vtable_stbvorbis =
+{
+    ma_decoding_backend_init__stbvorbis,
+    ma_decoding_backend_init_file__stbvorbis,
+    NULL, /* onInitFileW() */
+    ma_decoding_backend_init_memory__stbvorbis,
+    ma_decoding_backend_uninit__stbvorbis
+};
+
+static ma_result ma_decoder_init_vorbis__internal(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_vtable__internal(&g_ma_decoding_backend_vtable_stbvorbis, NULL, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_vorbis_from_file__internal(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file__internal(&g_ma_decoding_backend_vtable_stbvorbis, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_vorbis_from_file_w__internal(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_file_w__internal(&g_ma_decoding_backend_vtable_stbvorbis, NULL, pFilePath, pConfig, pDecoder);
+}
+
+static ma_result ma_decoder_init_vorbis_from_memory__internal(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    return ma_decoder_init_from_memory__internal(&g_ma_decoding_backend_vtable_stbvorbis, NULL, pData, dataSize, pConfig, pDecoder);
+}
+#endif  /* STB_VORBIS_INCLUDE_STB_VORBIS_H */
+
+
+
+static ma_result ma_decoder__init_allocation_callbacks(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    if (pConfig != NULL) {
+        return ma_allocation_callbacks_init_copy(&pDecoder->allocationCallbacks, &pConfig->allocationCallbacks);
+    } else {
+        pDecoder->allocationCallbacks = ma_allocation_callbacks_init_default();
+        return MA_SUCCESS;
+    }
+}
+
+static ma_result ma_decoder__data_source_on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_decoder_read_pcm_frames((ma_decoder*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_decoder__data_source_on_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_decoder_seek_to_pcm_frame((ma_decoder*)pDataSource, frameIndex);
+}
+
+static ma_result ma_decoder__data_source_on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_decoder_get_data_format((ma_decoder*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_decoder__data_source_on_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_decoder_get_cursor_in_pcm_frames((ma_decoder*)pDataSource, pCursor);
+}
+
+static ma_result ma_decoder__data_source_on_get_length(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_decoder_get_length_in_pcm_frames((ma_decoder*)pDataSource, pLength);
+}
+
+static ma_data_source_vtable g_ma_decoder_data_source_vtable =
+{
+    ma_decoder__data_source_on_read,
+    ma_decoder__data_source_on_seek,
+    ma_decoder__data_source_on_get_data_format,
+    ma_decoder__data_source_on_get_cursor,
+    ma_decoder__data_source_on_get_length,
+    NULL,   /* onSetLooping */
+    0
+};
+
+static ma_result ma_decoder__preinit(ma_decoder_read_proc onRead, ma_decoder_seek_proc onSeek, ma_decoder_tell_proc onTell, void* pUserData, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    MA_ASSERT(pConfig != NULL);
+
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDecoder);
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_decoder_data_source_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pDecoder->ds);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pDecoder->onRead    = onRead;
+    pDecoder->onSeek    = onSeek;
+    pDecoder->onTell    = onTell;
+    pDecoder->pUserData = pUserData;
+
+    result = ma_decoder__init_allocation_callbacks(pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        ma_data_source_uninit(&pDecoder->ds);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder__postinit(const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+
+    result = ma_decoder__init_data_converter(pDecoder, pConfig);
+
+    /* If we failed post initialization we need to uninitialize the decoder before returning to prevent a memory leak. */
+    if (result != MA_SUCCESS) {
+        ma_decoder_uninit(pDecoder);
+        return result;
+    }
+
+    return result;
+}
+
+
+static ma_result ma_decoder_init__internal(ma_decoder_read_proc onRead, ma_decoder_seek_proc onSeek, void* pUserData, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = MA_NO_BACKEND;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pDecoder != NULL);
+
+    /* Silence some warnings in the case that we don't have any decoder backends enabled. */
+    (void)onRead;
+    (void)onSeek;
+    (void)pUserData;
+
+
+    /* If we've specified a specific encoding type, try that first. */
+    if (pConfig->encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (pConfig->encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav__internal(pConfig, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (pConfig->encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac__internal(pConfig, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (pConfig->encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3__internal(pConfig, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (pConfig->encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis__internal(pConfig, pDecoder);
+        }
+    #endif
+
+        /* If we weren't able to initialize the decoder, seek back to the start to give the next attempts a clean start. */
+        if (result != MA_SUCCESS) {
+            onSeek(pDecoder, 0, ma_seek_origin_start);
+        }
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we couldn't load a specific decoding backend based on the encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_custom__internal(pConfig, pDecoder);
+            if (result != MA_SUCCESS) {
+                onSeek(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (pConfig->encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+    #ifdef MA_HAS_WAV
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_wav__internal(pConfig, pDecoder);
+            if (result != MA_SUCCESS) {
+                onSeek(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_flac__internal(pConfig, pDecoder);
+            if (result != MA_SUCCESS) {
+                onSeek(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_mp3__internal(pConfig, pDecoder);
+            if (result != MA_SUCCESS) {
+                onSeek(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_vorbis__internal(pConfig, pDecoder);
+            if (result != MA_SUCCESS) {
+                onSeek(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    }
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_decoder__postinit(pConfig, pDecoder);
+}
+
+MA_API ma_result ma_decoder_init(ma_decoder_read_proc onRead, ma_decoder_seek_proc onSeek, void* pUserData, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_decoder_config config;
+    ma_result result;
+
+    config = ma_decoder_config_init_copy(pConfig);
+
+    result = ma_decoder__preinit(onRead, onSeek, NULL, pUserData, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_decoder_init__internal(onRead, onSeek, pUserData, &config, pDecoder);
+}
+
+
+static ma_result ma_decoder__on_read_memory(ma_decoder* pDecoder, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead)
+{
+    size_t bytesRemaining;
+
+    MA_ASSERT(pDecoder->data.memory.dataSize >= pDecoder->data.memory.currentReadPos);
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = 0;
+    }
+
+    bytesRemaining = pDecoder->data.memory.dataSize - pDecoder->data.memory.currentReadPos;
+    if (bytesToRead > bytesRemaining) {
+        bytesToRead = bytesRemaining;
+    }
+
+    if (bytesRemaining == 0) {
+        return MA_AT_END;
+    }
+
+    if (bytesToRead > 0) {
+        MA_COPY_MEMORY(pBufferOut, pDecoder->data.memory.pData + pDecoder->data.memory.currentReadPos, bytesToRead);
+        pDecoder->data.memory.currentReadPos += bytesToRead;
+    }
+
+    if (pBytesRead != NULL) {
+        *pBytesRead = bytesToRead;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder__on_seek_memory(ma_decoder* pDecoder, ma_int64 byteOffset, ma_seek_origin origin)
+{
+    if (byteOffset > 0 && (ma_uint64)byteOffset > MA_SIZE_MAX) {
+        return MA_BAD_SEEK;
+    }
+
+    if (origin == ma_seek_origin_current) {
+        if (byteOffset > 0) {
+            if (pDecoder->data.memory.currentReadPos + byteOffset > pDecoder->data.memory.dataSize) {
+                byteOffset = (ma_int64)(pDecoder->data.memory.dataSize - pDecoder->data.memory.currentReadPos);  /* Trying to seek too far forward. */
+            }
+
+            pDecoder->data.memory.currentReadPos += (size_t)byteOffset;
+        } else {
+            if (pDecoder->data.memory.currentReadPos < (size_t)-byteOffset) {
+                byteOffset = -(ma_int64)pDecoder->data.memory.currentReadPos;  /* Trying to seek too far backwards. */
+            }
+
+            pDecoder->data.memory.currentReadPos -= (size_t)-byteOffset;
+        }
+    } else {
+        if (origin == ma_seek_origin_end) {
+            if (byteOffset < 0) {
+                byteOffset = -byteOffset;
+            }
+
+            if (byteOffset > (ma_int64)pDecoder->data.memory.dataSize) {
+                pDecoder->data.memory.currentReadPos = 0;   /* Trying to seek too far back. */
+            } else {
+                pDecoder->data.memory.currentReadPos = pDecoder->data.memory.dataSize - (size_t)byteOffset;
+            }
+        } else {
+            if ((size_t)byteOffset <= pDecoder->data.memory.dataSize) {
+                pDecoder->data.memory.currentReadPos = (size_t)byteOffset;
+            } else {
+                pDecoder->data.memory.currentReadPos = pDecoder->data.memory.dataSize;  /* Trying to seek too far forward. */
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder__on_tell_memory(ma_decoder* pDecoder, ma_int64* pCursor)
+{
+    MA_ASSERT(pDecoder != NULL);
+    MA_ASSERT(pCursor  != NULL);
+
+    *pCursor = (ma_int64)pDecoder->data.memory.currentReadPos;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder__preinit_memory_wrapper(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result = ma_decoder__preinit(ma_decoder__on_read_memory, ma_decoder__on_seek_memory, ma_decoder__on_tell_memory, NULL, pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pData == NULL || dataSize == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDecoder->data.memory.pData = (const ma_uint8*)pData;
+    pDecoder->data.memory.dataSize = dataSize;
+    pDecoder->data.memory.currentReadPos = 0;
+
+    (void)pConfig;
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_init_memory(const void* pData, size_t dataSize, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init_copy(pConfig);
+
+    result = ma_decoder__preinit(NULL, NULL, NULL, NULL, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pData == NULL || dataSize == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If the backend has support for loading from a file path we'll want to use that. If that all fails we'll fall back to the VFS path. */
+    result = MA_NO_BACKEND;
+
+    if (config.encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (config.encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav_from_memory__internal(pData, dataSize, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (config.encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac_from_memory__internal(pData, dataSize, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (config.encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3_from_memory__internal(pData, dataSize, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (config.encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis_from_memory__internal(pData, dataSize, &config, pDecoder);
+        }
+    #endif
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we weren't able to initialize a decoder of a specific encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        result = ma_decoder_init_custom_from_memory__internal(pData, dataSize, &config, pDecoder);
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (result != MA_SUCCESS && config.encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+        /* Use trial and error for stock decoders. */
+        if (result != MA_SUCCESS) {
+        #ifdef MA_HAS_WAV
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_wav_from_memory__internal(pData, dataSize, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_FLAC
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_flac_from_memory__internal(pData, dataSize, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_MP3
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_mp3_from_memory__internal(pData, dataSize, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_VORBIS
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_vorbis_from_memory__internal(pData, dataSize, &config, pDecoder);
+            }
+        #endif
+        }
+    }
+
+    /*
+    If at this point we still haven't successfully initialized the decoder it most likely means
+    the backend doesn't have an implementation for loading from a file path. We'll try using
+    miniaudio's built-in file IO for loading file.
+    */
+    if (result == MA_SUCCESS) {
+        /* Initialization was successful. Finish up. */
+        result = ma_decoder__postinit(&config, pDecoder);
+        if (result != MA_SUCCESS) {
+            /*
+            The backend was initialized successfully, but for some reason post-initialization failed. This is most likely
+            due to an out of memory error. We're going to abort with an error here and not try to recover.
+            */
+            if (pDecoder->pBackendVTable != NULL && pDecoder->pBackendVTable->onUninit != NULL) {
+                pDecoder->pBackendVTable->onUninit(pDecoder->pBackendUserData, &pDecoder->pBackend, &pDecoder->allocationCallbacks);
+            }
+
+            return result;
+        }
+    } else {
+        /* Probably no implementation for loading from a block of memory. Use miniaudio's abstraction instead. */
+        result = ma_decoder__preinit_memory_wrapper(pData, dataSize, &config, pDecoder);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        result = ma_decoder_init__internal(ma_decoder__on_read_memory, ma_decoder__on_seek_memory, NULL, &config, pDecoder);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+
+#if defined(MA_HAS_WAV)    || \
+    defined(MA_HAS_MP3)    || \
+    defined(MA_HAS_FLAC)   || \
+    defined(MA_HAS_VORBIS) || \
+    defined(MA_HAS_OPUS)
+#define MA_HAS_PATH_API
+#endif
+
+#if defined(MA_HAS_PATH_API)
+static const char* ma_path_file_name(const char* path)
+{
+    const char* fileName;
+
+    if (path == NULL) {
+        return NULL;
+    }
+
+    fileName = path;
+
+    /* We just loop through the path until we find the last slash. */
+    while (path[0] != '\0') {
+        if (path[0] == '/' || path[0] == '\\') {
+            fileName = path;
+        }
+
+        path += 1;
+    }
+
+    /* At this point the file name is sitting on a slash, so just move forward. */
+    while (fileName[0] != '\0' && (fileName[0] == '/' || fileName[0] == '\\')) {
+        fileName += 1;
+    }
+
+    return fileName;
+}
+
+static const wchar_t* ma_path_file_name_w(const wchar_t* path)
+{
+    const wchar_t* fileName;
+
+    if (path == NULL) {
+        return NULL;
+    }
+
+    fileName = path;
+
+    /* We just loop through the path until we find the last slash. */
+    while (path[0] != '\0') {
+        if (path[0] == '/' || path[0] == '\\') {
+            fileName = path;
+        }
+
+        path += 1;
+    }
+
+    /* At this point the file name is sitting on a slash, so just move forward. */
+    while (fileName[0] != '\0' && (fileName[0] == '/' || fileName[0] == '\\')) {
+        fileName += 1;
+    }
+
+    return fileName;
+}
+
+
+static const char* ma_path_extension(const char* path)
+{
+    const char* extension;
+    const char* lastOccurance;
+
+    if (path == NULL) {
+        path = "";
+    }
+
+    extension = ma_path_file_name(path);
+    lastOccurance = NULL;
+
+    /* Just find the last '.' and return. */
+    while (extension[0] != '\0') {
+        if (extension[0] == '.') {
+            extension += 1;
+            lastOccurance = extension;
+        }
+
+        extension += 1;
+    }
+
+    return (lastOccurance != NULL) ? lastOccurance : extension;
+}
+
+static const wchar_t* ma_path_extension_w(const wchar_t* path)
+{
+    const wchar_t* extension;
+    const wchar_t* lastOccurance;
+
+    if (path == NULL) {
+        path = L"";
+    }
+
+    extension = ma_path_file_name_w(path);
+    lastOccurance = NULL;
+
+    /* Just find the last '.' and return. */
+    while (extension[0] != '\0') {
+        if (extension[0] == '.') {
+            extension += 1;
+            lastOccurance = extension;
+        }
+
+        extension += 1;
+    }
+
+    return (lastOccurance != NULL) ? lastOccurance : extension;
+}
+
+
+static ma_bool32 ma_path_extension_equal(const char* path, const char* extension)
+{
+    const char* ext1;
+    const char* ext2;
+
+    if (path == NULL || extension == NULL) {
+        return MA_FALSE;
+    }
+
+    ext1 = extension;
+    ext2 = ma_path_extension(path);
+
+#if defined(_MSC_VER) || defined(__DMC__)
+    return _stricmp(ext1, ext2) == 0;
+#else
+    return strcasecmp(ext1, ext2) == 0;
+#endif
+}
+
+static ma_bool32 ma_path_extension_equal_w(const wchar_t* path, const wchar_t* extension)
+{
+    const wchar_t* ext1;
+    const wchar_t* ext2;
+
+    if (path == NULL || extension == NULL) {
+        return MA_FALSE;
+    }
+
+    ext1 = extension;
+    ext2 = ma_path_extension_w(path);
+
+#if defined(_MSC_VER) || defined(__WATCOMC__) || defined(__DMC__)
+    return _wcsicmp(ext1, ext2) == 0;
+#else
+    /*
+    I'm not aware of a wide character version of strcasecmp(). I'm therefore converting the extensions to multibyte strings and comparing those. This
+    isn't the most efficient way to do it, but it should work OK.
+    */
+    {
+        char ext1MB[4096];
+        char ext2MB[4096];
+        const wchar_t* pext1 = ext1;
+        const wchar_t* pext2 = ext2;
+        mbstate_t mbs1;
+        mbstate_t mbs2;
+
+        MA_ZERO_OBJECT(&mbs1);
+        MA_ZERO_OBJECT(&mbs2);
+
+        if (wcsrtombs(ext1MB, &pext1, sizeof(ext1MB), &mbs1) == (size_t)-1) {
+            return MA_FALSE;
+        }
+        if (wcsrtombs(ext2MB, &pext2, sizeof(ext2MB), &mbs2) == (size_t)-1) {
+            return MA_FALSE;
+        }
+
+        return strcasecmp(ext1MB, ext2MB) == 0;
+    }
+#endif
+}
+#endif  /* MA_HAS_PATH_API */
+
+
+
+static ma_result ma_decoder__on_read_vfs(ma_decoder* pDecoder, void* pBufferOut, size_t bytesToRead, size_t* pBytesRead)
+{
+    MA_ASSERT(pDecoder   != NULL);
+    MA_ASSERT(pBufferOut != NULL);
+
+    return ma_vfs_or_default_read(pDecoder->data.vfs.pVFS, pDecoder->data.vfs.file, pBufferOut, bytesToRead, pBytesRead);
+}
+
+static ma_result ma_decoder__on_seek_vfs(ma_decoder* pDecoder, ma_int64 offset, ma_seek_origin origin)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    return ma_vfs_or_default_seek(pDecoder->data.vfs.pVFS, pDecoder->data.vfs.file, offset, origin);
+}
+
+static ma_result ma_decoder__on_tell_vfs(ma_decoder* pDecoder, ma_int64* pCursor)
+{
+    MA_ASSERT(pDecoder != NULL);
+
+    return ma_vfs_or_default_tell(pDecoder->data.vfs.pVFS, pDecoder->data.vfs.file, pCursor);
+}
+
+static ma_result ma_decoder__preinit_vfs(ma_vfs* pVFS, const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_vfs_file file;
+
+    result = ma_decoder__preinit(ma_decoder__on_read_vfs, ma_decoder__on_seek_vfs, ma_decoder__on_tell_vfs, NULL, pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFilePath == NULL || pFilePath[0] == '\0') {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_vfs_or_default_open(pVFS, pFilePath, MA_OPEN_MODE_READ, &file);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pDecoder->data.vfs.pVFS = pVFS;
+    pDecoder->data.vfs.file = file;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_init_vfs(ma_vfs* pVFS, const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init_copy(pConfig);
+    result = ma_decoder__preinit_vfs(pVFS, pFilePath, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = MA_NO_BACKEND;
+
+    if (config.encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (config.encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (config.encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (config.encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (config.encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis__internal(&config, pDecoder);
+        }
+    #endif
+
+        /* Make sure we seek back to the start if we didn't initialize a decoder successfully so the next attempts have a fresh start. */
+        if (result != MA_SUCCESS) {
+            ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+        }
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we weren't able to initialize a decoder of a specific encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_custom__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (config.encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+    #ifdef MA_HAS_WAV
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "wav")) {
+            result = ma_decoder_init_wav__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "flac")) {
+            result = ma_decoder_init_flac__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "mp3")) {
+            result = ma_decoder_init_mp3__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    }
+
+    /* If we still haven't got a result just use trial and error. Otherwise we can finish up. */
+    if (result != MA_SUCCESS) {
+        result = ma_decoder_init__internal(ma_decoder__on_read_vfs, ma_decoder__on_seek_vfs, NULL, &config, pDecoder);
+    } else {
+        result = ma_decoder__postinit(&config, pDecoder);
+    }
+
+    if (result != MA_SUCCESS) {
+        if (pDecoder->data.vfs.file != NULL) {   /* <-- Will be reset to NULL if ma_decoder_uninit() is called in one of the steps above which allows us to avoid a double close of the file. */
+            ma_vfs_or_default_close(pVFS, pDecoder->data.vfs.file);
+        }
+
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_decoder__preinit_vfs_w(ma_vfs* pVFS, const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_vfs_file file;
+
+    result = ma_decoder__preinit(ma_decoder__on_read_vfs, ma_decoder__on_seek_vfs, ma_decoder__on_tell_vfs, NULL, pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFilePath == NULL || pFilePath[0] == '\0') {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_vfs_or_default_open_w(pVFS, pFilePath, MA_OPEN_MODE_READ, &file);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pDecoder->data.vfs.pVFS = pVFS;
+    pDecoder->data.vfs.file = file;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_init_vfs_w(ma_vfs* pVFS, const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init_copy(pConfig);
+    result = ma_decoder__preinit_vfs_w(pVFS, pFilePath, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = MA_NO_BACKEND;
+
+    if (config.encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (config.encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (config.encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (config.encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3__internal(&config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (config.encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis__internal(&config, pDecoder);
+        }
+    #endif
+
+        /* Make sure we seek back to the start if we didn't initialize a decoder successfully so the next attempts have a fresh start. */
+        if (result != MA_SUCCESS) {
+            ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+        }
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we weren't able to initialize a decoder of a specific encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        if (result != MA_SUCCESS) {
+            result = ma_decoder_init_custom__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (config.encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+    #ifdef MA_HAS_WAV
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"wav")) {
+            result = ma_decoder_init_wav__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"flac")) {
+            result = ma_decoder_init_flac__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"mp3")) {
+            result = ma_decoder_init_mp3__internal(&config, pDecoder);
+            if (result != MA_SUCCESS) {
+                ma_decoder__on_seek_vfs(pDecoder, 0, ma_seek_origin_start);
+            }
+        }
+    #endif
+    }
+
+    /* If we still haven't got a result just use trial and error. Otherwise we can finish up. */
+    if (result != MA_SUCCESS) {
+        result = ma_decoder_init__internal(ma_decoder__on_read_vfs, ma_decoder__on_seek_vfs, NULL, &config, pDecoder);
+    } else {
+        result = ma_decoder__postinit(&config, pDecoder);
+    }
+
+    if (result != MA_SUCCESS) {
+        ma_vfs_or_default_close(pVFS, pDecoder->data.vfs.file);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_decoder__preinit_file(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+
+    result = ma_decoder__preinit(NULL, NULL, NULL, NULL, pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFilePath == NULL || pFilePath[0] == '\0') {
+        return MA_INVALID_ARGS;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_init_file(const char* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init_copy(pConfig);
+    result = ma_decoder__preinit_file(pFilePath, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* If the backend has support for loading from a file path we'll want to use that. If that all fails we'll fall back to the VFS path. */
+    result = MA_NO_BACKEND;
+
+    if (config.encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (config.encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (config.encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (config.encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (config.encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we weren't able to initialize a decoder of a specific encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        result = ma_decoder_init_custom_from_file__internal(pFilePath, &config, pDecoder);
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (result != MA_SUCCESS && config.encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+        /* First try loading based on the file extension so we don't waste time opening and closing files. */
+    #ifdef MA_HAS_WAV
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "wav")) {
+            result = ma_decoder_init_wav_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "flac")) {
+            result = ma_decoder_init_flac_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "mp3")) {
+            result = ma_decoder_init_mp3_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (result != MA_SUCCESS && ma_path_extension_equal(pFilePath, "ogg")) {
+            result = ma_decoder_init_vorbis_from_file__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+
+        /*
+        If we still haven't got a result just use trial and error. Custom decoders have already been attempted, so here we
+        need only iterate over our stock decoders.
+        */
+        if (result != MA_SUCCESS) {
+        #ifdef MA_HAS_WAV
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_wav_from_file__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_FLAC
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_flac_from_file__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_MP3
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_mp3_from_file__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_VORBIS
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_vorbis_from_file__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        }
+    }
+
+    /*
+    If at this point we still haven't successfully initialized the decoder it most likely means
+    the backend doesn't have an implementation for loading from a file path. We'll try using
+    miniaudio's built-in file IO for loading file.
+    */
+    if (result == MA_SUCCESS) {
+        /* Initialization was successful. Finish up. */
+        result = ma_decoder__postinit(&config, pDecoder);
+        if (result != MA_SUCCESS) {
+            /*
+            The backend was initialized successfully, but for some reason post-initialization failed. This is most likely
+            due to an out of memory error. We're going to abort with an error here and not try to recover.
+            */
+            if (pDecoder->pBackendVTable != NULL && pDecoder->pBackendVTable->onUninit != NULL) {
+                pDecoder->pBackendVTable->onUninit(pDecoder->pBackendUserData, &pDecoder->pBackend, &pDecoder->allocationCallbacks);
+            }
+
+            return result;
+        }
+    } else {
+        /* Probably no implementation for loading from a file path. Use miniaudio's file IO instead. */
+        result = ma_decoder_init_vfs(NULL, pFilePath, pConfig, pDecoder);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_decoder__preinit_file_w(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+
+    result = ma_decoder__preinit(NULL, NULL, NULL, NULL, pConfig, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFilePath == NULL || pFilePath[0] == '\0') {
+        return MA_INVALID_ARGS;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_init_file_w(const wchar_t* pFilePath, const ma_decoder_config* pConfig, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init_copy(pConfig);
+    result = ma_decoder__preinit_file_w(pFilePath, &config, pDecoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* If the backend has support for loading from a file path we'll want to use that. If that all fails we'll fall back to the VFS path. */
+    result = MA_NO_BACKEND;
+
+    if (config.encodingFormat != ma_encoding_format_unknown) {
+    #ifdef MA_HAS_WAV
+        if (config.encodingFormat == ma_encoding_format_wav) {
+            result = ma_decoder_init_wav_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (config.encodingFormat == ma_encoding_format_flac) {
+            result = ma_decoder_init_flac_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (config.encodingFormat == ma_encoding_format_mp3) {
+            result = ma_decoder_init_mp3_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (config.encodingFormat == ma_encoding_format_vorbis) {
+            result = ma_decoder_init_vorbis_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    }
+
+    if (result != MA_SUCCESS) {
+        /* Getting here means we weren't able to initialize a decoder of a specific encoding format. */
+
+        /*
+        We use trial and error to open a decoder. We prioritize custom decoders so that if they
+        implement the same encoding format they take priority over the built-in decoders.
+        */
+        result = ma_decoder_init_custom_from_file_w__internal(pFilePath, &config, pDecoder);
+
+        /*
+        If we get to this point and we still haven't found a decoder, and the caller has requested a
+        specific encoding format, there's no hope for it. Abort.
+        */
+        if (result != MA_SUCCESS && config.encodingFormat != ma_encoding_format_unknown) {
+            return MA_NO_BACKEND;
+        }
+
+        /* First try loading based on the file extension so we don't waste time opening and closing files. */
+    #ifdef MA_HAS_WAV
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"wav")) {
+            result = ma_decoder_init_wav_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_FLAC
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"flac")) {
+            result = ma_decoder_init_flac_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_MP3
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"mp3")) {
+            result = ma_decoder_init_mp3_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+    #ifdef MA_HAS_VORBIS
+        if (result != MA_SUCCESS && ma_path_extension_equal_w(pFilePath, L"ogg")) {
+            result = ma_decoder_init_vorbis_from_file_w__internal(pFilePath, &config, pDecoder);
+        }
+    #endif
+
+        /*
+        If we still haven't got a result just use trial and error. Custom decoders have already been attempted, so here we
+        need only iterate over our stock decoders.
+        */
+        if (result != MA_SUCCESS) {
+        #ifdef MA_HAS_WAV
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_wav_from_file_w__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_FLAC
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_flac_from_file_w__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_MP3
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_mp3_from_file_w__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        #ifdef MA_HAS_VORBIS
+            if (result != MA_SUCCESS) {
+                result = ma_decoder_init_vorbis_from_file_w__internal(pFilePath, &config, pDecoder);
+            }
+        #endif
+        }
+    }
+
+    /*
+    If at this point we still haven't successfully initialized the decoder it most likely means
+    the backend doesn't have an implementation for loading from a file path. We'll try using
+    miniaudio's built-in file IO for loading file.
+    */
+    if (result == MA_SUCCESS) {
+        /* Initialization was successful. Finish up. */
+        result = ma_decoder__postinit(&config, pDecoder);
+        if (result != MA_SUCCESS) {
+            /*
+            The backend was initialized successfully, but for some reason post-initialization failed. This is most likely
+            due to an out of memory error. We're going to abort with an error here and not try to recover.
+            */
+            if (pDecoder->pBackendVTable != NULL && pDecoder->pBackendVTable->onUninit != NULL) {
+                pDecoder->pBackendVTable->onUninit(pDecoder->pBackendUserData, &pDecoder->pBackend, &pDecoder->allocationCallbacks);
+            }
+
+            return result;
+        }
+    } else {
+        /* Probably no implementation for loading from a file path. Use miniaudio's file IO instead. */
+        result = ma_decoder_init_vfs_w(NULL, pFilePath, pConfig, pDecoder);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_uninit(ma_decoder* pDecoder)
+{
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDecoder->pBackend != NULL) {
+        if (pDecoder->pBackendVTable != NULL && pDecoder->pBackendVTable->onUninit != NULL) {
+            pDecoder->pBackendVTable->onUninit(pDecoder->pBackendUserData, pDecoder->pBackend, &pDecoder->allocationCallbacks);
+        }
+    }
+
+    if (pDecoder->onRead == ma_decoder__on_read_vfs) {
+        ma_vfs_or_default_close(pDecoder->data.vfs.pVFS, pDecoder->data.vfs.file);
+        pDecoder->data.vfs.file = NULL;
+    }
+
+    ma_data_converter_uninit(&pDecoder->converter, &pDecoder->allocationCallbacks);
+    ma_data_source_uninit(&pDecoder->ds);
+
+    if (pDecoder->pInputCache != NULL) {
+        ma_free(pDecoder->pInputCache, &pDecoder->allocationCallbacks);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_read_pcm_frames(ma_decoder* pDecoder, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 totalFramesReadOut;
+    void* pRunningFramesOut;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;   /* Safety. */
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDecoder->pBackend == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* Fast path. */
+    if (pDecoder->converter.isPassthrough) {
+        result = ma_data_source_read_pcm_frames(pDecoder->pBackend, pFramesOut, frameCount, &totalFramesReadOut);
+    } else {
+        /*
+        Getting here means we need to do data conversion. If we're seeking forward and are _not_ doing resampling we can run this in a fast path. If we're doing resampling we
+        need to run through each sample because we need to ensure it's internal cache is updated.
+        */
+        if (pFramesOut == NULL && pDecoder->converter.hasResampler == MA_FALSE) {
+            result = ma_data_source_read_pcm_frames(pDecoder->pBackend, NULL, frameCount, &totalFramesReadOut);
+        } else {
+            /* Slow path. Need to run everything through the data converter. */
+            ma_format internalFormat;
+            ma_uint32 internalChannels;
+
+            totalFramesReadOut = 0;
+            pRunningFramesOut  = pFramesOut;
+
+            result = ma_data_source_get_data_format(pDecoder->pBackend, &internalFormat, &internalChannels, NULL, NULL, 0);
+            if (result != MA_SUCCESS) {
+                return result;   /* Failed to retrieve the internal format and channel count. */
+            }
+
+            /*
+            We run a different path depending on whether or not we are using a heap-allocated
+            intermediary buffer or not. If the data converter does not support the calculation of
+            the required number of input frames, we'll use the heap-allocated path. Otherwise we'll
+            use the stack-allocated path.
+            */
+            if (pDecoder->pInputCache != NULL) {
+                /* We don't have a way of determining the required number of input frames, so need to persistently store input data in a cache. */
+                while (totalFramesReadOut < frameCount) {
+                    ma_uint64 framesToReadThisIterationIn;
+                    ma_uint64 framesToReadThisIterationOut;
+
+                    /* If there's any data available in the cache, that needs to get processed first. */
+                    if (pDecoder->inputCacheRemaining > 0) {
+                        framesToReadThisIterationOut = (frameCount - totalFramesReadOut);
+                        framesToReadThisIterationIn  = framesToReadThisIterationOut;
+                        if (framesToReadThisIterationIn > pDecoder->inputCacheRemaining) {
+                            framesToReadThisIterationIn = pDecoder->inputCacheRemaining;
+                        }
+
+                        result = ma_data_converter_process_pcm_frames(&pDecoder->converter, ma_offset_pcm_frames_ptr(pDecoder->pInputCache, pDecoder->inputCacheConsumed, internalFormat, internalChannels), &framesToReadThisIterationIn, pRunningFramesOut, &framesToReadThisIterationOut);
+                        if (result != MA_SUCCESS) {
+                            break;
+                        }
+
+                        pDecoder->inputCacheConsumed  += framesToReadThisIterationIn;
+                        pDecoder->inputCacheRemaining -= framesToReadThisIterationIn;
+
+                        totalFramesReadOut += framesToReadThisIterationOut;
+
+                        if (pRunningFramesOut != NULL) {
+                            pRunningFramesOut = ma_offset_ptr(pRunningFramesOut, framesToReadThisIterationOut * ma_get_bytes_per_frame(pDecoder->outputFormat, pDecoder->outputChannels));
+                        }
+
+                        if (framesToReadThisIterationIn == 0 && framesToReadThisIterationOut == 0) {
+                            break;  /* We're done. */
+                        }
+                    }
+
+                    /* Getting here means there's no data in the cache and we need to fill it up from the data source. */
+                    if (pDecoder->inputCacheRemaining == 0) {
+                        pDecoder->inputCacheConsumed = 0;
+
+                        result = ma_data_source_read_pcm_frames(pDecoder->pBackend, pDecoder->pInputCache, pDecoder->inputCacheCap, &pDecoder->inputCacheRemaining);
+                        if (result != MA_SUCCESS) {
+                            break;
+                        }
+                    }
+                }
+            } else {
+                /* We have a way of determining the required number of input frames so just use the stack. */
+                while (totalFramesReadOut < frameCount) {
+                    ma_uint8 pIntermediaryBuffer[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];  /* In internal format. */
+                    ma_uint64 intermediaryBufferCap = sizeof(pIntermediaryBuffer) / ma_get_bytes_per_frame(internalFormat, internalChannels);
+                    ma_uint64 framesToReadThisIterationIn;
+                    ma_uint64 framesReadThisIterationIn;
+                    ma_uint64 framesToReadThisIterationOut;
+                    ma_uint64 framesReadThisIterationOut;
+                    ma_uint64 requiredInputFrameCount;
+
+                    framesToReadThisIterationOut = (frameCount - totalFramesReadOut);
+                    framesToReadThisIterationIn = framesToReadThisIterationOut;
+                    if (framesToReadThisIterationIn > intermediaryBufferCap) {
+                        framesToReadThisIterationIn = intermediaryBufferCap;
+                    }
+
+                    ma_data_converter_get_required_input_frame_count(&pDecoder->converter, framesToReadThisIterationOut, &requiredInputFrameCount);
+                    if (framesToReadThisIterationIn > requiredInputFrameCount) {
+                        framesToReadThisIterationIn = requiredInputFrameCount;
+                    }
+
+                    if (requiredInputFrameCount > 0) {
+                        result = ma_data_source_read_pcm_frames(pDecoder->pBackend, pIntermediaryBuffer, framesToReadThisIterationIn, &framesReadThisIterationIn);
+                    } else {
+                        framesReadThisIterationIn = 0;
+                    }
+
+                    /*
+                    At this point we have our decoded data in input format and now we need to convert to output format. Note that even if we didn't read any
+                    input frames, we still want to try processing frames because there may some output frames generated from cached input data.
+                    */
+                    framesReadThisIterationOut = framesToReadThisIterationOut;
+                    result = ma_data_converter_process_pcm_frames(&pDecoder->converter, pIntermediaryBuffer, &framesReadThisIterationIn, pRunningFramesOut, &framesReadThisIterationOut);
+                    if (result != MA_SUCCESS) {
+                        break;
+                    }
+
+                    totalFramesReadOut += framesReadThisIterationOut;
+
+                    if (pRunningFramesOut != NULL) {
+                        pRunningFramesOut = ma_offset_ptr(pRunningFramesOut, framesReadThisIterationOut * ma_get_bytes_per_frame(pDecoder->outputFormat, pDecoder->outputChannels));
+                    }
+
+                    if (framesReadThisIterationIn == 0 && framesReadThisIterationOut == 0) {
+                        break;  /* We're done. */
+                    }
+                }
+            }
+        }
+    }
+
+    pDecoder->readPointerInPCMFrames += totalFramesReadOut;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesReadOut;
+    }
+
+    if (result == MA_SUCCESS && totalFramesReadOut == 0) {
+        result =  MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_decoder_seek_to_pcm_frame(ma_decoder* pDecoder, ma_uint64 frameIndex)
+{
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDecoder->pBackend != NULL) {
+        ma_result result;
+        ma_uint64 internalFrameIndex;
+        ma_uint32 internalSampleRate;
+        ma_uint64 currentFrameIndex;
+
+        result = ma_data_source_get_data_format(pDecoder->pBackend, NULL, NULL, &internalSampleRate, NULL, 0);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to retrieve the internal sample rate. */
+        }
+
+        if (internalSampleRate == pDecoder->outputSampleRate) {
+            internalFrameIndex = frameIndex;
+        } else {
+            internalFrameIndex = ma_calculate_frame_count_after_resampling(internalSampleRate, pDecoder->outputSampleRate, frameIndex);
+        }
+
+        /* Only seek if we're requesting a different frame to what we're currently sitting on. */
+        ma_data_source_get_cursor_in_pcm_frames(pDecoder->pBackend, &currentFrameIndex);
+        if (currentFrameIndex != internalFrameIndex) {
+            result = ma_data_source_seek_to_pcm_frame(pDecoder->pBackend, internalFrameIndex);
+            if (result == MA_SUCCESS) {
+                pDecoder->readPointerInPCMFrames = frameIndex;
+            }
+
+            /* Reset the data converter so that any cached data in the resampler is cleared. */
+            ma_data_converter_reset(&pDecoder->converter);
+        }
+
+        return result;
+    }
+
+    /* Should never get here, but if we do it means onSeekToPCMFrame was not set by the backend. */
+    return MA_INVALID_ARGS;
+}
+
+MA_API ma_result ma_decoder_get_data_format(ma_decoder* pDecoder, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFormat != NULL) {
+        *pFormat = pDecoder->outputFormat;
+    }
+
+    if (pChannels != NULL) {
+        *pChannels = pDecoder->outputChannels;
+    }
+
+    if (pSampleRate != NULL) {
+        *pSampleRate = pDecoder->outputSampleRate;
+    }
+
+    if (pChannelMap != NULL) {
+        ma_data_converter_get_output_channel_map(&pDecoder->converter, pChannelMap, channelMapCap);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_get_cursor_in_pcm_frames(ma_decoder* pDecoder, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = pDecoder->readPointerInPCMFrames;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decoder_get_length_in_pcm_frames(ma_decoder* pDecoder, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDecoder->pBackend != NULL) {
+        ma_result result;
+        ma_uint64 internalLengthInPCMFrames;
+        ma_uint32 internalSampleRate;
+
+        result = ma_data_source_get_length_in_pcm_frames(pDecoder->pBackend, &internalLengthInPCMFrames);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to retrieve the internal length. */
+        }
+
+        result = ma_data_source_get_data_format(pDecoder->pBackend, NULL, NULL, &internalSampleRate, NULL, 0);
+        if (result != MA_SUCCESS) {
+            return result;   /* Failed to retrieve the internal sample rate. */
+        }
+
+        if (internalSampleRate == pDecoder->outputSampleRate) {
+            *pLength = internalLengthInPCMFrames;
+        } else {
+            *pLength = ma_calculate_frame_count_after_resampling(pDecoder->outputSampleRate, internalSampleRate, internalLengthInPCMFrames);
+        }
+
+        return MA_SUCCESS;
+    } else {
+        return MA_NO_BACKEND;
+    }
+}
+
+MA_API ma_result ma_decoder_get_available_frames(ma_decoder* pDecoder, ma_uint64* pAvailableFrames)
+{
+    ma_result result;
+    ma_uint64 totalFrameCount;
+
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pDecoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_decoder_get_length_in_pcm_frames(pDecoder, &totalFrameCount);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (totalFrameCount <= pDecoder->readPointerInPCMFrames) {
+        *pAvailableFrames = 0;
+    } else {
+        *pAvailableFrames = totalFrameCount - pDecoder->readPointerInPCMFrames;
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_decoder__full_decode_and_uninit(ma_decoder* pDecoder, ma_decoder_config* pConfigOut, ma_uint64* pFrameCountOut, void** ppPCMFramesOut)
+{
+    ma_result result;
+    ma_uint64 totalFrameCount;
+    ma_uint64 bpf;
+    ma_uint64 dataCapInFrames;
+    void* pPCMFramesOut;
+
+    MA_ASSERT(pDecoder != NULL);
+
+    totalFrameCount = 0;
+    bpf = ma_get_bytes_per_frame(pDecoder->outputFormat, pDecoder->outputChannels);
+
+    /* The frame count is unknown until we try reading. Thus, we just run in a loop. */
+    dataCapInFrames = 0;
+    pPCMFramesOut = NULL;
+    for (;;) {
+        ma_uint64 frameCountToTryReading;
+        ma_uint64 framesJustRead;
+
+        /* Make room if there's not enough. */
+        if (totalFrameCount == dataCapInFrames) {
+            void* pNewPCMFramesOut;
+            ma_uint64 newDataCapInFrames = dataCapInFrames*2;
+            if (newDataCapInFrames == 0) {
+                newDataCapInFrames = 4096;
+            }
+
+            if ((newDataCapInFrames * bpf) > MA_SIZE_MAX) {
+                ma_free(pPCMFramesOut, &pDecoder->allocationCallbacks);
+                return MA_TOO_BIG;
+            }
+
+            pNewPCMFramesOut = (void*)ma_realloc(pPCMFramesOut, (size_t)(newDataCapInFrames * bpf), &pDecoder->allocationCallbacks);
+            if (pNewPCMFramesOut == NULL) {
+                ma_free(pPCMFramesOut, &pDecoder->allocationCallbacks);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            dataCapInFrames = newDataCapInFrames;
+            pPCMFramesOut = pNewPCMFramesOut;
+        }
+
+        frameCountToTryReading = dataCapInFrames - totalFrameCount;
+        MA_ASSERT(frameCountToTryReading > 0);
+
+        result = ma_decoder_read_pcm_frames(pDecoder, (ma_uint8*)pPCMFramesOut + (totalFrameCount * bpf), frameCountToTryReading, &framesJustRead);
+        totalFrameCount += framesJustRead;
+
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        if (framesJustRead < frameCountToTryReading) {
+            break;
+        }
+    }
+
+
+    if (pConfigOut != NULL) {
+        pConfigOut->format     = pDecoder->outputFormat;
+        pConfigOut->channels   = pDecoder->outputChannels;
+        pConfigOut->sampleRate = pDecoder->outputSampleRate;
+    }
+
+    if (ppPCMFramesOut != NULL) {
+        *ppPCMFramesOut = pPCMFramesOut;
+    } else {
+        ma_free(pPCMFramesOut, &pDecoder->allocationCallbacks);
+    }
+
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = totalFrameCount;
+    }
+
+    ma_decoder_uninit(pDecoder);
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_decode_from_vfs(ma_vfs* pVFS, const char* pFilePath, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut)
+{
+    ma_result result;
+    ma_decoder_config config;
+    ma_decoder decoder;
+
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = 0;
+    }
+    if (ppPCMFramesOut != NULL) {
+        *ppPCMFramesOut = NULL;
+    }
+
+    config = ma_decoder_config_init_copy(pConfig);
+
+    result = ma_decoder_init_vfs(pVFS, pFilePath, &config, &decoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_decoder__full_decode_and_uninit(&decoder, pConfig, pFrameCountOut, ppPCMFramesOut);
+
+    return result;
+}
+
+MA_API ma_result ma_decode_file(const char* pFilePath, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut)
+{
+    return ma_decode_from_vfs(NULL, pFilePath, pConfig, pFrameCountOut, ppPCMFramesOut);
+}
+
+MA_API ma_result ma_decode_memory(const void* pData, size_t dataSize, ma_decoder_config* pConfig, ma_uint64* pFrameCountOut, void** ppPCMFramesOut)
+{
+    ma_decoder_config config;
+    ma_decoder decoder;
+    ma_result result;
+
+    if (pFrameCountOut != NULL) {
+        *pFrameCountOut = 0;
+    }
+    if (ppPCMFramesOut != NULL) {
+        *ppPCMFramesOut = NULL;
+    }
+
+    if (pData == NULL || dataSize == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    config = ma_decoder_config_init_copy(pConfig);
+
+    result = ma_decoder_init_memory(pData, dataSize, &config, &decoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_decoder__full_decode_and_uninit(&decoder, pConfig, pFrameCountOut, ppPCMFramesOut);
+}
+#endif  /* MA_NO_DECODING */
+
+
+#ifndef MA_NO_ENCODING
+
+#if defined(MA_HAS_WAV)
+static size_t ma_encoder__internal_on_write_wav(void* pUserData, const void* pData, size_t bytesToWrite)
+{
+    ma_encoder* pEncoder = (ma_encoder*)pUserData;
+    size_t bytesWritten = 0;
+
+    MA_ASSERT(pEncoder != NULL);
+
+    pEncoder->onWrite(pEncoder, pData, bytesToWrite, &bytesWritten);
+    return bytesWritten;
+}
+
+static ma_bool32 ma_encoder__internal_on_seek_wav(void* pUserData, int offset, ma_dr_wav_seek_origin origin)
+{
+    ma_encoder* pEncoder = (ma_encoder*)pUserData;
+    ma_result result;
+
+    MA_ASSERT(pEncoder != NULL);
+
+    result = pEncoder->onSeek(pEncoder, offset, (origin == ma_dr_wav_seek_origin_start) ? ma_seek_origin_start : ma_seek_origin_current);
+    if (result != MA_SUCCESS) {
+        return MA_FALSE;
+    } else {
+        return MA_TRUE;
+    }
+}
+
+static ma_result ma_encoder__on_init_wav(ma_encoder* pEncoder)
+{
+    ma_dr_wav_data_format wavFormat;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_dr_wav* pWav;
+
+    MA_ASSERT(pEncoder != NULL);
+
+    pWav = (ma_dr_wav*)ma_malloc(sizeof(*pWav), &pEncoder->config.allocationCallbacks);
+    if (pWav == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    wavFormat.container     = ma_dr_wav_container_riff;
+    wavFormat.channels      = pEncoder->config.channels;
+    wavFormat.sampleRate    = pEncoder->config.sampleRate;
+    wavFormat.bitsPerSample = ma_get_bytes_per_sample(pEncoder->config.format) * 8;
+    if (pEncoder->config.format == ma_format_f32) {
+        wavFormat.format    = MA_DR_WAVE_FORMAT_IEEE_FLOAT;
+    } else {
+        wavFormat.format    = MA_DR_WAVE_FORMAT_PCM;
+    }
+
+    allocationCallbacks.pUserData = pEncoder->config.allocationCallbacks.pUserData;
+    allocationCallbacks.onMalloc  = pEncoder->config.allocationCallbacks.onMalloc;
+    allocationCallbacks.onRealloc = pEncoder->config.allocationCallbacks.onRealloc;
+    allocationCallbacks.onFree    = pEncoder->config.allocationCallbacks.onFree;
+
+    if (!ma_dr_wav_init_write(pWav, &wavFormat, ma_encoder__internal_on_write_wav, ma_encoder__internal_on_seek_wav, pEncoder, &allocationCallbacks)) {
+        return MA_ERROR;
+    }
+
+    pEncoder->pInternalEncoder = pWav;
+
+    return MA_SUCCESS;
+}
+
+static void ma_encoder__on_uninit_wav(ma_encoder* pEncoder)
+{
+    ma_dr_wav* pWav;
+
+    MA_ASSERT(pEncoder != NULL);
+
+    pWav = (ma_dr_wav*)pEncoder->pInternalEncoder;
+    MA_ASSERT(pWav != NULL);
+
+    ma_dr_wav_uninit(pWav);
+    ma_free(pWav, &pEncoder->config.allocationCallbacks);
+}
+
+static ma_result ma_encoder__on_write_pcm_frames_wav(ma_encoder* pEncoder, const void* pFramesIn, ma_uint64 frameCount, ma_uint64* pFramesWritten)
+{
+    ma_dr_wav* pWav;
+    ma_uint64 framesWritten;
+
+    MA_ASSERT(pEncoder != NULL);
+
+    pWav = (ma_dr_wav*)pEncoder->pInternalEncoder;
+    MA_ASSERT(pWav != NULL);
+
+    framesWritten = ma_dr_wav_write_pcm_frames(pWav, frameCount, pFramesIn);
+
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = framesWritten;
+    }
+
+    return MA_SUCCESS;
+}
+#endif
+
+MA_API ma_encoder_config ma_encoder_config_init(ma_encoding_format encodingFormat, ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    ma_encoder_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.encodingFormat = encodingFormat;
+    config.format = format;
+    config.channels = channels;
+    config.sampleRate = sampleRate;
+
+    return config;
+}
+
+MA_API ma_result ma_encoder_preinit(const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    ma_result result;
+
+    if (pEncoder == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pEncoder);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->format == ma_format_unknown || pConfig->channels == 0 || pConfig->sampleRate == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pEncoder->config = *pConfig;
+
+    result = ma_allocation_callbacks_init_copy(&pEncoder->config.allocationCallbacks, &pConfig->allocationCallbacks);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_encoder_init__internal(ma_encoder_write_proc onWrite, ma_encoder_seek_proc onSeek, void* pUserData, ma_encoder* pEncoder)
+{
+    ma_result result = MA_SUCCESS;
+
+    /* This assumes ma_encoder_preinit() has been called prior. */
+    MA_ASSERT(pEncoder != NULL);
+
+    if (onWrite == NULL || onSeek == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pEncoder->onWrite   = onWrite;
+    pEncoder->onSeek    = onSeek;
+    pEncoder->pUserData = pUserData;
+
+    switch (pEncoder->config.encodingFormat)
+    {
+        case ma_encoding_format_wav:
+        {
+        #if defined(MA_HAS_WAV)
+            pEncoder->onInit           = ma_encoder__on_init_wav;
+            pEncoder->onUninit         = ma_encoder__on_uninit_wav;
+            pEncoder->onWritePCMFrames = ma_encoder__on_write_pcm_frames_wav;
+        #else
+            result = MA_NO_BACKEND;
+        #endif
+        } break;
+
+        default:
+        {
+            result = MA_INVALID_ARGS;
+        } break;
+    }
+
+    /* Getting here means we should have our backend callbacks set up. */
+    if (result == MA_SUCCESS) {
+        result = pEncoder->onInit(pEncoder);
+    }
+
+    return result;
+}
+
+static ma_result ma_encoder__on_write_vfs(ma_encoder* pEncoder, const void* pBufferIn, size_t bytesToWrite, size_t* pBytesWritten)
+{
+    return ma_vfs_or_default_write(pEncoder->data.vfs.pVFS, pEncoder->data.vfs.file, pBufferIn, bytesToWrite, pBytesWritten);
+}
+
+static ma_result ma_encoder__on_seek_vfs(ma_encoder* pEncoder, ma_int64 offset, ma_seek_origin origin)
+{
+    return ma_vfs_or_default_seek(pEncoder->data.vfs.pVFS, pEncoder->data.vfs.file, offset, origin);
+}
+
+MA_API ma_result ma_encoder_init_vfs(ma_vfs* pVFS, const char* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    ma_result result;
+    ma_vfs_file file;
+
+    result = ma_encoder_preinit(pConfig, pEncoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Now open the file. If this fails we don't need to uninitialize the encoder. */
+    result = ma_vfs_or_default_open(pVFS, pFilePath, MA_OPEN_MODE_WRITE, &file);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pEncoder->data.vfs.pVFS = pVFS;
+    pEncoder->data.vfs.file = file;
+
+    result = ma_encoder_init__internal(ma_encoder__on_write_vfs, ma_encoder__on_seek_vfs, NULL, pEncoder);
+    if (result != MA_SUCCESS) {
+        ma_vfs_or_default_close(pVFS, file);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_encoder_init_vfs_w(ma_vfs* pVFS, const wchar_t* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    ma_result result;
+    ma_vfs_file file;
+
+    result = ma_encoder_preinit(pConfig, pEncoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Now open the file. If this fails we don't need to uninitialize the encoder. */
+    result = ma_vfs_or_default_open_w(pVFS, pFilePath, MA_OPEN_MODE_WRITE, &file);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pEncoder->data.vfs.pVFS = pVFS;
+    pEncoder->data.vfs.file = file;
+
+    result = ma_encoder_init__internal(ma_encoder__on_write_vfs, ma_encoder__on_seek_vfs, NULL, pEncoder);
+    if (result != MA_SUCCESS) {
+        ma_vfs_or_default_close(pVFS, file);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_encoder_init_file(const char* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    return ma_encoder_init_vfs(NULL, pFilePath, pConfig, pEncoder);
+}
+
+MA_API ma_result ma_encoder_init_file_w(const wchar_t* pFilePath, const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    return ma_encoder_init_vfs_w(NULL, pFilePath, pConfig, pEncoder);
+}
+
+MA_API ma_result ma_encoder_init(ma_encoder_write_proc onWrite, ma_encoder_seek_proc onSeek, void* pUserData, const ma_encoder_config* pConfig, ma_encoder* pEncoder)
+{
+    ma_result result;
+
+    result = ma_encoder_preinit(pConfig, pEncoder);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_encoder_init__internal(onWrite, onSeek, pUserData, pEncoder);
+}
+
+
+MA_API void ma_encoder_uninit(ma_encoder* pEncoder)
+{
+    if (pEncoder == NULL) {
+        return;
+    }
+
+    if (pEncoder->onUninit) {
+        pEncoder->onUninit(pEncoder);
+    }
+
+    /* If we have a file handle, close it. */
+    if (pEncoder->onWrite == ma_encoder__on_write_vfs) {
+        ma_vfs_or_default_close(pEncoder->data.vfs.pVFS, pEncoder->data.vfs.file);
+        pEncoder->data.vfs.file = NULL;
+    }
+}
+
+
+MA_API ma_result ma_encoder_write_pcm_frames(ma_encoder* pEncoder, const void* pFramesIn, ma_uint64 frameCount, ma_uint64* pFramesWritten)
+{
+    if (pFramesWritten != NULL) {
+        *pFramesWritten = 0;
+    }
+
+    if (pEncoder == NULL || pFramesIn == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return pEncoder->onWritePCMFrames(pEncoder, pFramesIn, frameCount, pFramesWritten);
+}
+#endif  /* MA_NO_ENCODING */
+
+
+
+/**************************************************************************************************************************************************************
+
+Generation
+
+**************************************************************************************************************************************************************/
+#ifndef MA_NO_GENERATION
+MA_API ma_waveform_config ma_waveform_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, ma_waveform_type type, double amplitude, double frequency)
+{
+    ma_waveform_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.type       = type;
+    config.amplitude  = amplitude;
+    config.frequency  = frequency;
+
+    return config;
+}
+
+static ma_result ma_waveform__data_source_on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_waveform_read_pcm_frames((ma_waveform*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_waveform__data_source_on_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_waveform_seek_to_pcm_frame((ma_waveform*)pDataSource, frameIndex);
+}
+
+static ma_result ma_waveform__data_source_on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_waveform* pWaveform = (ma_waveform*)pDataSource;
+
+    *pFormat     = pWaveform->config.format;
+    *pChannels   = pWaveform->config.channels;
+    *pSampleRate = pWaveform->config.sampleRate;
+    ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pWaveform->config.channels);
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_waveform__data_source_on_get_cursor(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    ma_waveform* pWaveform = (ma_waveform*)pDataSource;
+
+    *pCursor = (ma_uint64)(pWaveform->time / pWaveform->advance);
+
+    return MA_SUCCESS;
+}
+
+static double ma_waveform__calculate_advance(ma_uint32 sampleRate, double frequency)
+{
+    return (1.0 / (sampleRate / frequency));
+}
+
+static void ma_waveform__update_advance(ma_waveform* pWaveform)
+{
+    pWaveform->advance = ma_waveform__calculate_advance(pWaveform->config.sampleRate, pWaveform->config.frequency);
+}
+
+static ma_data_source_vtable g_ma_waveform_data_source_vtable =
+{
+    ma_waveform__data_source_on_read,
+    ma_waveform__data_source_on_seek,
+    ma_waveform__data_source_on_get_data_format,
+    ma_waveform__data_source_on_get_cursor,
+    NULL,   /* onGetLength. There's no notion of a length in waveforms. */
+    NULL,   /* onSetLooping */
+    0
+};
+
+MA_API ma_result ma_waveform_init(const ma_waveform_config* pConfig, ma_waveform* pWaveform)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pWaveform);
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_waveform_data_source_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pWaveform->ds);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pWaveform->config  = *pConfig;
+    pWaveform->advance = ma_waveform__calculate_advance(pWaveform->config.sampleRate, pWaveform->config.frequency);
+    pWaveform->time    = 0;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_waveform_uninit(ma_waveform* pWaveform)
+{
+    if (pWaveform == NULL) {
+        return;
+    }
+
+    ma_data_source_uninit(&pWaveform->ds);
+}
+
+MA_API ma_result ma_waveform_set_amplitude(ma_waveform* pWaveform, double amplitude)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.amplitude = amplitude;
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_waveform_set_frequency(ma_waveform* pWaveform, double frequency)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.frequency = frequency;
+    ma_waveform__update_advance(pWaveform);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_waveform_set_type(ma_waveform* pWaveform, ma_waveform_type type)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.type = type;
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_waveform_set_sample_rate(ma_waveform* pWaveform, ma_uint32 sampleRate)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.sampleRate = sampleRate;
+    ma_waveform__update_advance(pWaveform);
+
+    return MA_SUCCESS;
+}
+
+static float ma_waveform_sine_f32(double time, double amplitude)
+{
+    return (float)(ma_sind(MA_TAU_D * time) * amplitude);
+}
+
+static ma_int16 ma_waveform_sine_s16(double time, double amplitude)
+{
+    return ma_pcm_sample_f32_to_s16(ma_waveform_sine_f32(time, amplitude));
+}
+
+static float ma_waveform_square_f32(double time, double dutyCycle, double amplitude)
+{
+    double f = time - (ma_int64)time;
+    double r;
+
+    if (f < dutyCycle) {
+        r =  amplitude;
+    } else {
+        r = -amplitude;
+    }
+
+    return (float)r;
+}
+
+static ma_int16 ma_waveform_square_s16(double time, double dutyCycle, double amplitude)
+{
+    return ma_pcm_sample_f32_to_s16(ma_waveform_square_f32(time, dutyCycle, amplitude));
+}
+
+static float ma_waveform_triangle_f32(double time, double amplitude)
+{
+    double f = time - (ma_int64)time;
+    double r;
+
+    r = 2 * ma_abs(2 * (f - 0.5)) - 1;
+
+    return (float)(r * amplitude);
+}
+
+static ma_int16 ma_waveform_triangle_s16(double time, double amplitude)
+{
+    return ma_pcm_sample_f32_to_s16(ma_waveform_triangle_f32(time, amplitude));
+}
+
+static float ma_waveform_sawtooth_f32(double time, double amplitude)
+{
+    double f = time - (ma_int64)time;
+    double r;
+
+    r = 2 * (f - 0.5);
+
+    return (float)(r * amplitude);
+}
+
+static ma_int16 ma_waveform_sawtooth_s16(double time, double amplitude)
+{
+    return ma_pcm_sample_f32_to_s16(ma_waveform_sawtooth_f32(time, amplitude));
+}
+
+static void ma_waveform_read_pcm_frames__sine(ma_waveform* pWaveform, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint64 iChannel;
+    ma_uint32 bps = ma_get_bytes_per_sample(pWaveform->config.format);
+    ma_uint32 bpf = bps * pWaveform->config.channels;
+
+    MA_ASSERT(pWaveform  != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pWaveform->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_sine_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutF32[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else if (pWaveform->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            ma_int16 s = ma_waveform_sine_s16(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutS16[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else {
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_sine_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pWaveform->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+            }
+        }
+    }
+}
+
+static void ma_waveform_read_pcm_frames__square(ma_waveform* pWaveform, double dutyCycle, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint64 iChannel;
+    ma_uint32 bps = ma_get_bytes_per_sample(pWaveform->config.format);
+    ma_uint32 bpf = bps * pWaveform->config.channels;
+
+    MA_ASSERT(pWaveform  != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pWaveform->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_square_f32(pWaveform->time, dutyCycle, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutF32[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else if (pWaveform->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            ma_int16 s = ma_waveform_square_s16(pWaveform->time, dutyCycle, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutS16[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else {
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_square_f32(pWaveform->time, dutyCycle, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pWaveform->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+            }
+        }
+    }
+}
+
+static void ma_waveform_read_pcm_frames__triangle(ma_waveform* pWaveform, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint64 iChannel;
+    ma_uint32 bps = ma_get_bytes_per_sample(pWaveform->config.format);
+    ma_uint32 bpf = bps * pWaveform->config.channels;
+
+    MA_ASSERT(pWaveform  != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pWaveform->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_triangle_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutF32[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else if (pWaveform->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            ma_int16 s = ma_waveform_triangle_s16(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutS16[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else {
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_triangle_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pWaveform->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+            }
+        }
+    }
+}
+
+static void ma_waveform_read_pcm_frames__sawtooth(ma_waveform* pWaveform, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint64 iChannel;
+    ma_uint32 bps = ma_get_bytes_per_sample(pWaveform->config.format);
+    ma_uint32 bpf = bps * pWaveform->config.channels;
+
+    MA_ASSERT(pWaveform  != NULL);
+    MA_ASSERT(pFramesOut != NULL);
+
+    if (pWaveform->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_sawtooth_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutF32[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else if (pWaveform->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            ma_int16 s = ma_waveform_sawtooth_s16(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                pFramesOutS16[iFrame*pWaveform->config.channels + iChannel] = s;
+            }
+        }
+    } else {
+        for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+            float s = ma_waveform_sawtooth_f32(pWaveform->time, pWaveform->config.amplitude);
+            pWaveform->time += pWaveform->advance;
+
+            for (iChannel = 0; iChannel < pWaveform->config.channels; iChannel += 1) {
+                ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pWaveform->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+            }
+        }
+    }
+}
+
+MA_API ma_result ma_waveform_read_pcm_frames(ma_waveform* pWaveform, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFramesOut != NULL) {
+        switch (pWaveform->config.type)
+        {
+            case ma_waveform_type_sine:
+            {
+                ma_waveform_read_pcm_frames__sine(pWaveform, pFramesOut, frameCount);
+            } break;
+
+            case ma_waveform_type_square:
+            {
+                ma_waveform_read_pcm_frames__square(pWaveform, 0.5, pFramesOut, frameCount);
+            } break;
+
+            case ma_waveform_type_triangle:
+            {
+                ma_waveform_read_pcm_frames__triangle(pWaveform, pFramesOut, frameCount);
+            } break;
+
+            case ma_waveform_type_sawtooth:
+            {
+                ma_waveform_read_pcm_frames__sawtooth(pWaveform, pFramesOut, frameCount);
+            } break;
+
+            default: return MA_INVALID_OPERATION;   /* Unknown waveform type. */
+        }
+    } else {
+        pWaveform->time += pWaveform->advance * (ma_int64)frameCount; /* Cast to int64 required for VC6. Won't affect anything in practice. */
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_waveform_seek_to_pcm_frame(ma_waveform* pWaveform, ma_uint64 frameIndex)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->time = pWaveform->advance * (ma_int64)frameIndex;    /* Casting for VC6. Won't be an issue in practice. */
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_pulsewave_config ma_pulsewave_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double dutyCycle, double amplitude, double frequency)
+{
+    ma_pulsewave_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.format     = format;
+    config.channels   = channels;
+    config.sampleRate = sampleRate;
+    config.dutyCycle  = dutyCycle;
+    config.amplitude  = amplitude;
+    config.frequency  = frequency;
+
+    return config;
+}
+
+MA_API ma_result ma_pulsewave_init(const ma_pulsewave_config* pConfig, ma_pulsewave* pWaveform)
+{
+    ma_result result;
+    ma_waveform_config config;
+
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pWaveform);
+
+    config = ma_waveform_config_init(
+        pConfig->format,
+        pConfig->channels,
+        pConfig->sampleRate,
+        ma_waveform_type_square,
+        pConfig->amplitude,
+        pConfig->frequency
+    );
+
+    result = ma_waveform_init(&config, &pWaveform->waveform);
+    ma_pulsewave_set_duty_cycle(pWaveform, pConfig->dutyCycle);
+
+    return result;
+}
+
+MA_API void ma_pulsewave_uninit(ma_pulsewave* pWaveform)
+{
+    if (pWaveform == NULL) {
+        return;
+    }
+
+    ma_waveform_uninit(&pWaveform->waveform);
+}
+
+MA_API ma_result ma_pulsewave_read_pcm_frames(ma_pulsewave* pWaveform, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pFramesOut != NULL) {
+        ma_waveform_read_pcm_frames__square(&pWaveform->waveform, pWaveform->config.dutyCycle, pFramesOut, frameCount);
+    } else {
+        pWaveform->waveform.time += pWaveform->waveform.advance * (ma_int64)frameCount; /* Cast to int64 required for VC6. Won't affect anything in practice. */
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = frameCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pulsewave_seek_to_pcm_frame(ma_pulsewave* pWaveform, ma_uint64 frameIndex)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_waveform_seek_to_pcm_frame(&pWaveform->waveform, frameIndex);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pulsewave_set_amplitude(ma_pulsewave* pWaveform, double amplitude)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.amplitude = amplitude;
+    ma_waveform_set_amplitude(&pWaveform->waveform, amplitude);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pulsewave_set_frequency(ma_pulsewave* pWaveform, double frequency)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.frequency = frequency;
+    ma_waveform_set_frequency(&pWaveform->waveform, frequency);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pulsewave_set_sample_rate(ma_pulsewave* pWaveform, ma_uint32 sampleRate)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.sampleRate = sampleRate;
+    ma_waveform_set_sample_rate(&pWaveform->waveform, sampleRate);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_pulsewave_set_duty_cycle(ma_pulsewave* pWaveform, double dutyCycle)
+{
+    if (pWaveform == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pWaveform->config.dutyCycle = dutyCycle;
+
+    return MA_SUCCESS;
+}
+
+
+
+MA_API ma_noise_config ma_noise_config_init(ma_format format, ma_uint32 channels, ma_noise_type type, ma_int32 seed, double amplitude)
+{
+    ma_noise_config config;
+    MA_ZERO_OBJECT(&config);
+
+    config.format    = format;
+    config.channels  = channels;
+    config.type      = type;
+    config.seed      = seed;
+    config.amplitude = amplitude;
+
+    if (config.seed == 0) {
+        config.seed = MA_DEFAULT_LCG_SEED;
+    }
+
+    return config;
+}
+
+
+static ma_result ma_noise__data_source_on_read(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_noise_read_pcm_frames((ma_noise*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_noise__data_source_on_seek(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    /* No-op. Just pretend to be successful. */
+    (void)pDataSource;
+    (void)frameIndex;
+    return MA_SUCCESS;
+}
+
+static ma_result ma_noise__data_source_on_get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    ma_noise* pNoise = (ma_noise*)pDataSource;
+
+    *pFormat     = pNoise->config.format;
+    *pChannels   = pNoise->config.channels;
+    *pSampleRate = 0;   /* There is no notion of sample rate with noise generation. */
+    ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pNoise->config.channels);
+
+    return MA_SUCCESS;
+}
+
+static ma_data_source_vtable g_ma_noise_data_source_vtable =
+{
+    ma_noise__data_source_on_read,
+    ma_noise__data_source_on_seek,  /* No-op for noise. */
+    ma_noise__data_source_on_get_data_format,
+    NULL,   /* onGetCursor. No notion of a cursor for noise. */
+    NULL,   /* onGetLength. No notion of a length for noise. */
+    NULL,   /* onSetLooping */
+    0
+};
+
+
+#ifndef MA_PINK_NOISE_BIN_SIZE
+#define MA_PINK_NOISE_BIN_SIZE 16
+#endif
+
+typedef struct
+{
+    size_t sizeInBytes;
+    struct
+    {
+        size_t binOffset;
+        size_t accumulationOffset;
+        size_t counterOffset;
+    } pink;
+    struct
+    {
+        size_t accumulationOffset;
+    } brownian;
+} ma_noise_heap_layout;
+
+static ma_result ma_noise_get_heap_layout(const ma_noise_config* pConfig, ma_noise_heap_layout* pHeapLayout)
+{
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Pink. */
+    if (pConfig->type == ma_noise_type_pink) {
+        /* bin */
+        pHeapLayout->pink.binOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += sizeof(double*) * pConfig->channels;
+        pHeapLayout->sizeInBytes += sizeof(double ) * pConfig->channels * MA_PINK_NOISE_BIN_SIZE;
+
+        /* accumulation */
+        pHeapLayout->pink.accumulationOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += sizeof(double) * pConfig->channels;
+
+        /* counter */
+        pHeapLayout->pink.counterOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += sizeof(ma_uint32) * pConfig->channels;
+    }
+
+    /* Brownian. */
+    if (pConfig->type == ma_noise_type_brownian) {
+        /* accumulation */
+        pHeapLayout->brownian.accumulationOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += sizeof(double) * pConfig->channels;
+    }
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_noise_get_heap_size(const ma_noise_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_noise_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_noise_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_noise_init_preallocated(const ma_noise_config* pConfig, void* pHeap, ma_noise* pNoise)
+{
+    ma_result result;
+    ma_noise_heap_layout heapLayout;
+    ma_data_source_config dataSourceConfig;
+    ma_uint32 iChannel;
+
+    if (pNoise == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNoise);
+
+    result = ma_noise_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pNoise->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pNoise->_pHeap, heapLayout.sizeInBytes);
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_noise_data_source_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pNoise->ds);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pNoise->config = *pConfig;
+    ma_lcg_seed(&pNoise->lcg, pConfig->seed);
+
+    if (pNoise->config.type == ma_noise_type_pink) {
+        pNoise->state.pink.bin          = (double**  )ma_offset_ptr(pHeap, heapLayout.pink.binOffset);
+        pNoise->state.pink.accumulation = (double*   )ma_offset_ptr(pHeap, heapLayout.pink.accumulationOffset);
+        pNoise->state.pink.counter      = (ma_uint32*)ma_offset_ptr(pHeap, heapLayout.pink.counterOffset);
+
+        for (iChannel = 0; iChannel < pConfig->channels; iChannel += 1) {
+            pNoise->state.pink.bin[iChannel]          = (double*)ma_offset_ptr(pHeap, heapLayout.pink.binOffset + (sizeof(double*) * pConfig->channels) + (sizeof(double) * MA_PINK_NOISE_BIN_SIZE * iChannel));
+            pNoise->state.pink.accumulation[iChannel] = 0;
+            pNoise->state.pink.counter[iChannel]      = 1;
+        }
+    }
+
+    if (pNoise->config.type == ma_noise_type_brownian) {
+        pNoise->state.brownian.accumulation = (double*)ma_offset_ptr(pHeap, heapLayout.brownian.accumulationOffset);
+
+        for (iChannel = 0; iChannel < pConfig->channels; iChannel += 1) {
+            pNoise->state.brownian.accumulation[iChannel] = 0;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_noise_init(const ma_noise_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_noise* pNoise)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_noise_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_noise_init_preallocated(pConfig, pHeap, pNoise);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pNoise->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_noise_uninit(ma_noise* pNoise, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pNoise == NULL) {
+        return;
+    }
+
+    ma_data_source_uninit(&pNoise->ds);
+
+    if (pNoise->_ownsHeap) {
+        ma_free(pNoise->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_result ma_noise_set_amplitude(ma_noise* pNoise, double amplitude)
+{
+    if (pNoise == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pNoise->config.amplitude = amplitude;
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_noise_set_seed(ma_noise* pNoise, ma_int32 seed)
+{
+    if (pNoise == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pNoise->lcg.state = seed;
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_noise_set_type(ma_noise* pNoise, ma_noise_type type)
+{
+    if (pNoise == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    This function should never have been implemented in the first place. Changing the type dynamically is not
+    supported. Instead you need to uninitialize and reinitiailize a fresh `ma_noise` object. This function
+    will be removed in version 0.12.
+    */
+    MA_ASSERT(MA_FALSE);
+    (void)type;
+
+    return MA_INVALID_OPERATION;
+}
+
+static MA_INLINE float ma_noise_f32_white(ma_noise* pNoise)
+{
+    return (float)(ma_lcg_rand_f64(&pNoise->lcg) * pNoise->config.amplitude);
+}
+
+static MA_INLINE ma_int16 ma_noise_s16_white(ma_noise* pNoise)
+{
+    return ma_pcm_sample_f32_to_s16(ma_noise_f32_white(pNoise));
+}
+
+static MA_INLINE ma_uint64 ma_noise_read_pcm_frames__white(ma_noise* pNoise, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannel;
+    const ma_uint32 channels = pNoise->config.channels;
+    MA_ASSUME(channels > 0);
+
+    if (pNoise->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_white(pNoise);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = ma_noise_f32_white(pNoise);
+                }
+            }
+        }
+    } else if (pNoise->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                ma_int16 s = ma_noise_s16_white(pNoise);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = ma_noise_s16_white(pNoise);
+                }
+            }
+        }
+    } else {
+        const ma_uint32 bps = ma_get_bytes_per_sample(pNoise->config.format);
+        const ma_uint32 bpf = bps * channels;
+
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_white(pNoise);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    float s = ma_noise_f32_white(pNoise);
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        }
+    }
+
+    return frameCount;
+}
+
+
+static MA_INLINE unsigned int ma_tzcnt32(unsigned int x)
+{
+    unsigned int n;
+
+    /* Special case for odd numbers since they should happen about half the time. */
+    if (x & 0x1)  {
+        return 0;
+    }
+
+    if (x == 0) {
+        return sizeof(x) << 3;
+    }
+
+    n = 1;
+    if ((x & 0x0000FFFF) == 0) { x >>= 16; n += 16; }
+    if ((x & 0x000000FF) == 0) { x >>=  8; n +=  8; }
+    if ((x & 0x0000000F) == 0) { x >>=  4; n +=  4; }
+    if ((x & 0x00000003) == 0) { x >>=  2; n +=  2; }
+    n -= x & 0x00000001;
+
+    return n;
+}
+
+/*
+Pink noise generation based on Tonic (public domain) with modifications. https://github.com/TonicAudio/Tonic/blob/master/src/Tonic/Noise.h
+
+This is basically _the_ reference for pink noise from what I've found: http://www.firstpr.com.au/dsp/pink-noise/
+*/
+static MA_INLINE float ma_noise_f32_pink(ma_noise* pNoise, ma_uint32 iChannel)
+{
+    double result;
+    double binPrev;
+    double binNext;
+    unsigned int ibin;
+
+    ibin = ma_tzcnt32(pNoise->state.pink.counter[iChannel]) & (MA_PINK_NOISE_BIN_SIZE - 1);
+
+    binPrev = pNoise->state.pink.bin[iChannel][ibin];
+    binNext = ma_lcg_rand_f64(&pNoise->lcg);
+    pNoise->state.pink.bin[iChannel][ibin] = binNext;
+
+    pNoise->state.pink.accumulation[iChannel] += (binNext - binPrev);
+    pNoise->state.pink.counter[iChannel]      += 1;
+
+    result = (ma_lcg_rand_f64(&pNoise->lcg) + pNoise->state.pink.accumulation[iChannel]);
+    result /= 10;
+
+    return (float)(result * pNoise->config.amplitude);
+}
+
+static MA_INLINE ma_int16 ma_noise_s16_pink(ma_noise* pNoise, ma_uint32 iChannel)
+{
+    return ma_pcm_sample_f32_to_s16(ma_noise_f32_pink(pNoise, iChannel));
+}
+
+static MA_INLINE ma_uint64 ma_noise_read_pcm_frames__pink(ma_noise* pNoise, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannel;
+    const ma_uint32 channels = pNoise->config.channels;
+    MA_ASSUME(channels > 0);
+
+    if (pNoise->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_pink(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = ma_noise_f32_pink(pNoise, iChannel);
+                }
+            }
+        }
+    } else if (pNoise->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                ma_int16 s = ma_noise_s16_pink(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = ma_noise_s16_pink(pNoise, iChannel);
+                }
+            }
+        }
+    } else {
+        const ma_uint32 bps = ma_get_bytes_per_sample(pNoise->config.format);
+        const ma_uint32 bpf = bps * channels;
+
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_pink(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    float s = ma_noise_f32_pink(pNoise, iChannel);
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        }
+    }
+
+    return frameCount;
+}
+
+
+static MA_INLINE float ma_noise_f32_brownian(ma_noise* pNoise, ma_uint32 iChannel)
+{
+    double result;
+
+    result = (ma_lcg_rand_f64(&pNoise->lcg) + pNoise->state.brownian.accumulation[iChannel]);
+    result /= 1.005; /* Don't escape the -1..1 range on average. */
+
+    pNoise->state.brownian.accumulation[iChannel] = result;
+    result /= 20;
+
+    return (float)(result * pNoise->config.amplitude);
+}
+
+static MA_INLINE ma_int16 ma_noise_s16_brownian(ma_noise* pNoise, ma_uint32 iChannel)
+{
+    return ma_pcm_sample_f32_to_s16(ma_noise_f32_brownian(pNoise, iChannel));
+}
+
+static MA_INLINE ma_uint64 ma_noise_read_pcm_frames__brownian(ma_noise* pNoise, void* pFramesOut, ma_uint64 frameCount)
+{
+    ma_uint64 iFrame;
+    ma_uint32 iChannel;
+    const ma_uint32 channels = pNoise->config.channels;
+    MA_ASSUME(channels > 0);
+
+    if (pNoise->config.format == ma_format_f32) {
+        float* pFramesOutF32 = (float*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_brownian(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutF32[iFrame*channels + iChannel] = ma_noise_f32_brownian(pNoise, iChannel);
+                }
+            }
+        }
+    } else if (pNoise->config.format == ma_format_s16) {
+        ma_int16* pFramesOutS16 = (ma_int16*)pFramesOut;
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                ma_int16 s = ma_noise_s16_brownian(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = s;
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    pFramesOutS16[iFrame*channels + iChannel] = ma_noise_s16_brownian(pNoise, iChannel);
+                }
+            }
+        }
+    } else {
+        const ma_uint32 bps = ma_get_bytes_per_sample(pNoise->config.format);
+        const ma_uint32 bpf = bps * channels;
+
+        if (pNoise->config.duplicateChannels) {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                float s = ma_noise_f32_brownian(pNoise, 0);
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        } else {
+            for (iFrame = 0; iFrame < frameCount; iFrame += 1) {
+                for (iChannel = 0; iChannel < channels; iChannel += 1) {
+                    float s = ma_noise_f32_brownian(pNoise, iChannel);
+                    ma_pcm_convert(ma_offset_ptr(pFramesOut, iFrame*bpf + iChannel*bps), pNoise->config.format, &s, ma_format_f32, 1, ma_dither_mode_none);
+                }
+            }
+        }
+    }
+
+    return frameCount;
+}
+
+MA_API ma_result ma_noise_read_pcm_frames(ma_noise* pNoise, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_uint64 framesRead = 0;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pNoise == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The output buffer is allowed to be NULL. Since we aren't tracking cursors or anything we can just do nothing and pretend to be successful. */
+    if (pFramesOut == NULL) {
+        framesRead = frameCount;
+    } else {
+        switch (pNoise->config.type) {
+            case ma_noise_type_white:    framesRead = ma_noise_read_pcm_frames__white   (pNoise, pFramesOut, frameCount); break;
+            case ma_noise_type_pink:     framesRead = ma_noise_read_pcm_frames__pink    (pNoise, pFramesOut, frameCount); break;
+            case ma_noise_type_brownian: framesRead = ma_noise_read_pcm_frames__brownian(pNoise, pFramesOut, frameCount); break;
+            default: return MA_INVALID_OPERATION;   /* Unknown noise type. */
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = framesRead;
+    }
+
+    return MA_SUCCESS;
+}
+#endif /* MA_NO_GENERATION */
+
+
+
+#ifndef MA_NO_RESOURCE_MANAGER
+#ifndef MA_RESOURCE_MANAGER_PAGE_SIZE_IN_MILLISECONDS
+#define MA_RESOURCE_MANAGER_PAGE_SIZE_IN_MILLISECONDS   1000
+#endif
+
+#ifndef MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_CAPACITY
+#define MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_CAPACITY          1024
+#endif
+
+MA_API ma_resource_manager_pipeline_notifications ma_resource_manager_pipeline_notifications_init(void)
+{
+    ma_resource_manager_pipeline_notifications notifications;
+
+    MA_ZERO_OBJECT(&notifications);
+
+    return notifications;
+}
+
+static void ma_resource_manager_pipeline_notifications_signal_all_notifications(const ma_resource_manager_pipeline_notifications* pPipelineNotifications)
+{
+    if (pPipelineNotifications == NULL) {
+        return;
+    }
+
+    if (pPipelineNotifications->init.pNotification) { ma_async_notification_signal(pPipelineNotifications->init.pNotification); }
+    if (pPipelineNotifications->done.pNotification) { ma_async_notification_signal(pPipelineNotifications->done.pNotification); }
+}
+
+static void ma_resource_manager_pipeline_notifications_acquire_all_fences(const ma_resource_manager_pipeline_notifications* pPipelineNotifications)
+{
+    if (pPipelineNotifications == NULL) {
+        return;
+    }
+
+    if (pPipelineNotifications->init.pFence != NULL) { ma_fence_acquire(pPipelineNotifications->init.pFence); }
+    if (pPipelineNotifications->done.pFence != NULL) { ma_fence_acquire(pPipelineNotifications->done.pFence); }
+}
+
+static void ma_resource_manager_pipeline_notifications_release_all_fences(const ma_resource_manager_pipeline_notifications* pPipelineNotifications)
+{
+    if (pPipelineNotifications == NULL) {
+        return;
+    }
+
+    if (pPipelineNotifications->init.pFence != NULL) { ma_fence_release(pPipelineNotifications->init.pFence); }
+    if (pPipelineNotifications->done.pFence != NULL) { ma_fence_release(pPipelineNotifications->done.pFence); }
+}
+
+
+
+#ifndef MA_DEFAULT_HASH_SEED
+#define MA_DEFAULT_HASH_SEED    42
+#endif
+
+/* MurmurHash3. Based on code from https://github.com/PeterScott/murmur3/blob/master/murmur3.c (public domain). */
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic push
+    #if __GNUC__ >= 7
+    #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+    #endif
+#endif
+
+static MA_INLINE ma_uint32 ma_rotl32(ma_uint32 x, ma_int8 r)
+{
+    return (x << r) | (x >> (32 - r));
+}
+
+static MA_INLINE ma_uint32 ma_hash_getblock(const ma_uint32* blocks, int i)
+{
+    ma_uint32 block;
+
+    /* Try silencing a sanitization warning about unaligned access by doing a memcpy() instead of assignment. */
+    MA_COPY_MEMORY(&block, ma_offset_ptr(blocks, i * sizeof(block)), sizeof(block));
+
+    if (ma_is_little_endian()) {
+        return block;
+    } else {
+        return ma_swap_endian_uint32(block);
+    }
+}
+
+static MA_INLINE ma_uint32 ma_hash_fmix32(ma_uint32 h)
+{
+    h ^= h >> 16;
+    h *= 0x85ebca6b;
+    h ^= h >> 13;
+    h *= 0xc2b2ae35;
+    h ^= h >> 16;
+
+    return h;
+}
+
+static ma_uint32 ma_hash_32(const void* key, int len, ma_uint32 seed)
+{
+    const ma_uint8* data = (const ma_uint8*)key;
+    const ma_uint32* blocks;
+    const ma_uint8* tail;
+    const int nblocks = len / 4;
+    ma_uint32 h1 = seed;
+    ma_uint32 c1 = 0xcc9e2d51;
+    ma_uint32 c2 = 0x1b873593;
+    ma_uint32 k1;
+    int i;
+
+    blocks = (const ma_uint32 *)(data + nblocks*4);
+
+    for(i = -nblocks; i; i++) {
+        k1 = ma_hash_getblock(blocks,i);
+
+        k1 *= c1;
+        k1 = ma_rotl32(k1, 15);
+        k1 *= c2;
+
+        h1 ^= k1;
+        h1 = ma_rotl32(h1, 13);
+        h1 = h1*5 + 0xe6546b64;
+    }
+
+
+    tail = (const ma_uint8*)(data + nblocks*4);
+
+    k1 = 0;
+    switch(len & 3) {
+        case 3: k1 ^= tail[2] << 16;
+        case 2: k1 ^= tail[1] << 8;
+        case 1: k1 ^= tail[0];
+                k1 *= c1; k1 = ma_rotl32(k1, 15); k1 *= c2; h1 ^= k1;
+    };
+
+
+    h1 ^= len;
+    h1  = ma_hash_fmix32(h1);
+
+    return h1;
+}
+
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic push
+#endif
+/* End MurmurHash3 */
+
+static ma_uint32 ma_hash_string_32(const char* str)
+{
+    return ma_hash_32(str, (int)strlen(str), MA_DEFAULT_HASH_SEED);
+}
+
+static ma_uint32 ma_hash_string_w_32(const wchar_t* str)
+{
+    return ma_hash_32(str, (int)wcslen(str) * sizeof(*str), MA_DEFAULT_HASH_SEED);
+}
+
+
+
+
+/*
+Basic BST Functions
+*/
+static ma_result ma_resource_manager_data_buffer_node_search(ma_resource_manager* pResourceManager, ma_uint32 hashedName32, ma_resource_manager_data_buffer_node** ppDataBufferNode)
+{
+    ma_resource_manager_data_buffer_node* pCurrentNode;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(ppDataBufferNode != NULL);
+
+    pCurrentNode = pResourceManager->pRootDataBufferNode;
+    while (pCurrentNode != NULL) {
+        if (hashedName32 == pCurrentNode->hashedName32) {
+            break;  /* Found. */
+        } else if (hashedName32 < pCurrentNode->hashedName32) {
+            pCurrentNode = pCurrentNode->pChildLo;
+        } else {
+            pCurrentNode = pCurrentNode->pChildHi;
+        }
+    }
+
+    *ppDataBufferNode = pCurrentNode;
+
+    if (pCurrentNode == NULL) {
+        return MA_DOES_NOT_EXIST;
+    } else {
+        return MA_SUCCESS;
+    }
+}
+
+static ma_result ma_resource_manager_data_buffer_node_insert_point(ma_resource_manager* pResourceManager, ma_uint32 hashedName32, ma_resource_manager_data_buffer_node** ppInsertPoint)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager_data_buffer_node* pCurrentNode;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(ppInsertPoint    != NULL);
+
+    *ppInsertPoint = NULL;
+
+    if (pResourceManager->pRootDataBufferNode == NULL) {
+        return MA_SUCCESS;  /* No items. */
+    }
+
+    /* We need to find the node that will become the parent of the new node. If a node is found that already has the same hashed name we need to return MA_ALREADY_EXISTS. */
+    pCurrentNode = pResourceManager->pRootDataBufferNode;
+    while (pCurrentNode != NULL) {
+        if (hashedName32 == pCurrentNode->hashedName32) {
+            result = MA_ALREADY_EXISTS;
+            break;
+        } else {
+            if (hashedName32 < pCurrentNode->hashedName32) {
+                if (pCurrentNode->pChildLo == NULL) {
+                    result = MA_SUCCESS;
+                    break;
+                } else {
+                    pCurrentNode = pCurrentNode->pChildLo;
+                }
+            } else {
+                if (pCurrentNode->pChildHi == NULL) {
+                    result = MA_SUCCESS;
+                    break;
+                } else {
+                    pCurrentNode = pCurrentNode->pChildHi;
+                }
+            }
+        }
+    }
+
+    *ppInsertPoint = pCurrentNode;
+    return result;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_insert_at(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, ma_resource_manager_data_buffer_node* pInsertPoint)
+{
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    /* The key must have been set before calling this function. */
+    MA_ASSERT(pDataBufferNode->hashedName32 != 0);
+
+    if (pInsertPoint == NULL) {
+        /* It's the first node. */
+        pResourceManager->pRootDataBufferNode = pDataBufferNode;
+    } else {
+        /* It's not the first node. It needs to be inserted. */
+        if (pDataBufferNode->hashedName32 < pInsertPoint->hashedName32) {
+            MA_ASSERT(pInsertPoint->pChildLo == NULL);
+            pInsertPoint->pChildLo = pDataBufferNode;
+        } else {
+            MA_ASSERT(pInsertPoint->pChildHi == NULL);
+            pInsertPoint->pChildHi = pDataBufferNode;
+        }
+    }
+
+    pDataBufferNode->pParent = pInsertPoint;
+
+    return MA_SUCCESS;
+}
+
+#if 0   /* Unused for now. */
+static ma_result ma_resource_manager_data_buffer_node_insert(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    ma_result result;
+    ma_resource_manager_data_buffer_node* pInsertPoint;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    result = ma_resource_manager_data_buffer_node_insert_point(pResourceManager, pDataBufferNode->hashedName32, &pInsertPoint);
+    if (result != MA_SUCCESS) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_resource_manager_data_buffer_node_insert_at(pResourceManager, pDataBufferNode, pInsertPoint);
+}
+#endif
+
+static MA_INLINE ma_resource_manager_data_buffer_node* ma_resource_manager_data_buffer_node_find_min(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    ma_resource_manager_data_buffer_node* pCurrentNode;
+
+    MA_ASSERT(pDataBufferNode != NULL);
+
+    pCurrentNode = pDataBufferNode;
+    while (pCurrentNode->pChildLo != NULL) {
+        pCurrentNode = pCurrentNode->pChildLo;
+    }
+
+    return pCurrentNode;
+}
+
+static MA_INLINE ma_resource_manager_data_buffer_node* ma_resource_manager_data_buffer_node_find_max(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    ma_resource_manager_data_buffer_node* pCurrentNode;
+
+    MA_ASSERT(pDataBufferNode != NULL);
+
+    pCurrentNode = pDataBufferNode;
+    while (pCurrentNode->pChildHi != NULL) {
+        pCurrentNode = pCurrentNode->pChildHi;
+    }
+
+    return pCurrentNode;
+}
+
+static MA_INLINE ma_resource_manager_data_buffer_node* ma_resource_manager_data_buffer_node_find_inorder_successor(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pDataBufferNode           != NULL);
+    MA_ASSERT(pDataBufferNode->pChildHi != NULL);
+
+    return ma_resource_manager_data_buffer_node_find_min(pDataBufferNode->pChildHi);
+}
+
+static MA_INLINE ma_resource_manager_data_buffer_node* ma_resource_manager_data_buffer_node_find_inorder_predecessor(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pDataBufferNode           != NULL);
+    MA_ASSERT(pDataBufferNode->pChildLo != NULL);
+
+    return ma_resource_manager_data_buffer_node_find_max(pDataBufferNode->pChildLo);
+}
+
+static ma_result ma_resource_manager_data_buffer_node_remove(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    if (pDataBufferNode->pChildLo == NULL) {
+        if (pDataBufferNode->pChildHi == NULL) {
+            /* Simple case - deleting a buffer with no children. */
+            if (pDataBufferNode->pParent == NULL) {
+                MA_ASSERT(pResourceManager->pRootDataBufferNode == pDataBufferNode);    /* There is only a single buffer in the tree which should be equal to the root node. */
+                pResourceManager->pRootDataBufferNode = NULL;
+            } else {
+                if (pDataBufferNode->pParent->pChildLo == pDataBufferNode) {
+                    pDataBufferNode->pParent->pChildLo = NULL;
+                } else {
+                    pDataBufferNode->pParent->pChildHi = NULL;
+                }
+            }
+        } else {
+            /* Node has one child - pChildHi != NULL. */
+            pDataBufferNode->pChildHi->pParent = pDataBufferNode->pParent;
+
+            if (pDataBufferNode->pParent == NULL) {
+                MA_ASSERT(pResourceManager->pRootDataBufferNode == pDataBufferNode);
+                pResourceManager->pRootDataBufferNode = pDataBufferNode->pChildHi;
+            } else {
+                if (pDataBufferNode->pParent->pChildLo == pDataBufferNode) {
+                    pDataBufferNode->pParent->pChildLo = pDataBufferNode->pChildHi;
+                } else {
+                    pDataBufferNode->pParent->pChildHi = pDataBufferNode->pChildHi;
+                }
+            }
+        }
+    } else {
+        if (pDataBufferNode->pChildHi == NULL) {
+            /* Node has one child - pChildLo != NULL. */
+            pDataBufferNode->pChildLo->pParent = pDataBufferNode->pParent;
+
+            if (pDataBufferNode->pParent == NULL) {
+                MA_ASSERT(pResourceManager->pRootDataBufferNode == pDataBufferNode);
+                pResourceManager->pRootDataBufferNode = pDataBufferNode->pChildLo;
+            } else {
+                if (pDataBufferNode->pParent->pChildLo == pDataBufferNode) {
+                    pDataBufferNode->pParent->pChildLo = pDataBufferNode->pChildLo;
+                } else {
+                    pDataBufferNode->pParent->pChildHi = pDataBufferNode->pChildLo;
+                }
+            }
+        } else {
+            /* Complex case - deleting a node with two children. */
+            ma_resource_manager_data_buffer_node* pReplacementDataBufferNode;
+
+            /* For now we are just going to use the in-order successor as the replacement, but we may want to try to keep this balanced by switching between the two. */
+            pReplacementDataBufferNode = ma_resource_manager_data_buffer_node_find_inorder_successor(pDataBufferNode);
+            MA_ASSERT(pReplacementDataBufferNode != NULL);
+
+            /*
+            Now that we have our replacement node we can make the change. The simple way to do this would be to just exchange the values, and then remove the replacement
+            node, however we track specific nodes via pointers which means we can't just swap out the values. We need to instead just change the pointers around. The
+            replacement node should have at most 1 child. Therefore, we can detach it in terms of our simpler cases above. What we're essentially doing is detaching the
+            replacement node and reinserting it into the same position as the deleted node.
+            */
+            MA_ASSERT(pReplacementDataBufferNode->pParent  != NULL);  /* The replacement node should never be the root which means it should always have a parent. */
+            MA_ASSERT(pReplacementDataBufferNode->pChildLo == NULL);  /* Because we used in-order successor. This would be pChildHi == NULL if we used in-order predecessor. */
+
+            if (pReplacementDataBufferNode->pChildHi == NULL) {
+                if (pReplacementDataBufferNode->pParent->pChildLo == pReplacementDataBufferNode) {
+                    pReplacementDataBufferNode->pParent->pChildLo = NULL;
+                } else {
+                    pReplacementDataBufferNode->pParent->pChildHi = NULL;
+                }
+            } else {
+                pReplacementDataBufferNode->pChildHi->pParent = pReplacementDataBufferNode->pParent;
+                if (pReplacementDataBufferNode->pParent->pChildLo == pReplacementDataBufferNode) {
+                    pReplacementDataBufferNode->pParent->pChildLo = pReplacementDataBufferNode->pChildHi;
+                } else {
+                    pReplacementDataBufferNode->pParent->pChildHi = pReplacementDataBufferNode->pChildHi;
+                }
+            }
+
+
+            /* The replacement node has essentially been detached from the binary tree, so now we need to replace the old data buffer with it. The first thing to update is the parent */
+            if (pDataBufferNode->pParent != NULL) {
+                if (pDataBufferNode->pParent->pChildLo == pDataBufferNode) {
+                    pDataBufferNode->pParent->pChildLo = pReplacementDataBufferNode;
+                } else {
+                    pDataBufferNode->pParent->pChildHi = pReplacementDataBufferNode;
+                }
+            }
+
+            /* Now need to update the replacement node's pointers. */
+            pReplacementDataBufferNode->pParent  = pDataBufferNode->pParent;
+            pReplacementDataBufferNode->pChildLo = pDataBufferNode->pChildLo;
+            pReplacementDataBufferNode->pChildHi = pDataBufferNode->pChildHi;
+
+            /* Now the children of the replacement node need to have their parent pointers updated. */
+            if (pReplacementDataBufferNode->pChildLo != NULL) {
+                pReplacementDataBufferNode->pChildLo->pParent = pReplacementDataBufferNode;
+            }
+            if (pReplacementDataBufferNode->pChildHi != NULL) {
+                pReplacementDataBufferNode->pChildHi->pParent = pReplacementDataBufferNode;
+            }
+
+            /* Now the root node needs to be updated. */
+            if (pResourceManager->pRootDataBufferNode == pDataBufferNode) {
+                pResourceManager->pRootDataBufferNode = pReplacementDataBufferNode;
+            }
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+#if 0   /* Unused for now. */
+static ma_result ma_resource_manager_data_buffer_node_remove_by_key(ma_resource_manager* pResourceManager, ma_uint32 hashedName32)
+{
+    ma_result result;
+    ma_resource_manager_data_buffer_node* pDataBufferNode;
+
+    result = ma_resource_manager_data_buffer_search(pResourceManager, hashedName32, &pDataBufferNode);
+    if (result != MA_SUCCESS) {
+        return result;  /* Could not find the data buffer. */
+    }
+
+    return ma_resource_manager_data_buffer_remove(pResourceManager, pDataBufferNode);
+}
+#endif
+
+static ma_resource_manager_data_supply_type ma_resource_manager_data_buffer_node_get_data_supply_type(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    return (ma_resource_manager_data_supply_type)ma_atomic_load_i32(&pDataBufferNode->data.type);
+}
+
+static void ma_resource_manager_data_buffer_node_set_data_supply_type(ma_resource_manager_data_buffer_node* pDataBufferNode, ma_resource_manager_data_supply_type supplyType)
+{
+    ma_atomic_exchange_i32(&pDataBufferNode->data.type, supplyType);
+}
+
+static ma_result ma_resource_manager_data_buffer_node_increment_ref(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, ma_uint32* pNewRefCount)
+{
+    ma_uint32 refCount;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    (void)pResourceManager;
+
+    refCount = ma_atomic_fetch_add_32(&pDataBufferNode->refCount, 1) + 1;
+
+    if (pNewRefCount != NULL) {
+        *pNewRefCount = refCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_decrement_ref(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, ma_uint32* pNewRefCount)
+{
+    ma_uint32 refCount;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    (void)pResourceManager;
+
+    refCount = ma_atomic_fetch_sub_32(&pDataBufferNode->refCount, 1) - 1;
+
+    if (pNewRefCount != NULL) {
+        *pNewRefCount = refCount;
+    }
+
+    return MA_SUCCESS;
+}
+
+static void ma_resource_manager_data_buffer_node_free(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+
+    if (pDataBufferNode->isDataOwnedByResourceManager) {
+        if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBufferNode) == ma_resource_manager_data_supply_type_encoded) {
+            ma_free((void*)pDataBufferNode->data.backend.encoded.pData, &pResourceManager->config.allocationCallbacks);
+            pDataBufferNode->data.backend.encoded.pData       = NULL;
+            pDataBufferNode->data.backend.encoded.sizeInBytes = 0;
+        } else if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBufferNode) == ma_resource_manager_data_supply_type_decoded) {
+            ma_free((void*)pDataBufferNode->data.backend.decoded.pData, &pResourceManager->config.allocationCallbacks);
+            pDataBufferNode->data.backend.decoded.pData           = NULL;
+            pDataBufferNode->data.backend.decoded.totalFrameCount = 0;
+        } else if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBufferNode) == ma_resource_manager_data_supply_type_decoded_paged) {
+            ma_paged_audio_buffer_data_uninit(&pDataBufferNode->data.backend.decodedPaged.data, &pResourceManager->config.allocationCallbacks);
+        } else {
+            /* Should never hit this if the node was successfully initialized. */
+            MA_ASSERT(pDataBufferNode->result != MA_SUCCESS);
+        }
+    }
+
+    /* The data buffer itself needs to be freed. */
+    ma_free(pDataBufferNode, &pResourceManager->config.allocationCallbacks);
+}
+
+static ma_result ma_resource_manager_data_buffer_node_result(const ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pDataBufferNode != NULL);
+
+    return (ma_result)ma_atomic_load_i32((ma_result*)&pDataBufferNode->result);    /* Need a naughty const-cast here. */
+}
+
+
+static ma_bool32 ma_resource_manager_is_threading_enabled(const ma_resource_manager* pResourceManager)
+{
+    MA_ASSERT(pResourceManager != NULL);
+
+    return (pResourceManager->config.flags & MA_RESOURCE_MANAGER_FLAG_NO_THREADING) == 0;
+}
+
+
+typedef struct
+{
+    union
+    {
+        ma_async_notification_event e;
+        ma_async_notification_poll p;
+    } backend;  /* Must be the first member. */
+    ma_resource_manager* pResourceManager;
+} ma_resource_manager_inline_notification;
+
+static ma_result ma_resource_manager_inline_notification_init(ma_resource_manager* pResourceManager, ma_resource_manager_inline_notification* pNotification)
+{
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pNotification    != NULL);
+
+    pNotification->pResourceManager = pResourceManager;
+
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        return ma_async_notification_event_init(&pNotification->backend.e);
+    } else {
+        return ma_async_notification_poll_init(&pNotification->backend.p);
+    }
+}
+
+static void ma_resource_manager_inline_notification_uninit(ma_resource_manager_inline_notification* pNotification)
+{
+    MA_ASSERT(pNotification != NULL);
+
+    if (ma_resource_manager_is_threading_enabled(pNotification->pResourceManager)) {
+        ma_async_notification_event_uninit(&pNotification->backend.e);
+    } else {
+        /* No need to uninitialize a polling notification. */
+    }
+}
+
+static void ma_resource_manager_inline_notification_wait(ma_resource_manager_inline_notification* pNotification)
+{
+    MA_ASSERT(pNotification != NULL);
+
+    if (ma_resource_manager_is_threading_enabled(pNotification->pResourceManager)) {
+        ma_async_notification_event_wait(&pNotification->backend.e);
+    } else {
+        while (ma_async_notification_poll_is_signalled(&pNotification->backend.p) == MA_FALSE) {
+            ma_result result = ma_resource_manager_process_next_job(pNotification->pResourceManager);
+            if (result == MA_NO_DATA_AVAILABLE || result == MA_CANCELLED) {
+                break;
+            }
+        }
+    }
+}
+
+static void ma_resource_manager_inline_notification_wait_and_uninit(ma_resource_manager_inline_notification* pNotification)
+{
+    ma_resource_manager_inline_notification_wait(pNotification);
+    ma_resource_manager_inline_notification_uninit(pNotification);
+}
+
+
+static void ma_resource_manager_data_buffer_bst_lock(ma_resource_manager* pResourceManager)
+{
+    MA_ASSERT(pResourceManager != NULL);
+
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_mutex_lock(&pResourceManager->dataBufferBSTLock);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+        }
+        #endif
+    } else {
+        /* Threading not enabled. Do nothing. */
+    }
+}
+
+static void ma_resource_manager_data_buffer_bst_unlock(ma_resource_manager* pResourceManager)
+{
+    MA_ASSERT(pResourceManager != NULL);
+
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_mutex_unlock(&pResourceManager->dataBufferBSTLock);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+        }
+        #endif
+    } else {
+        /* Threading not enabled. Do nothing. */
+    }
+}
+
+#ifndef MA_NO_THREADING
+static ma_thread_result MA_THREADCALL ma_resource_manager_job_thread(void* pUserData)
+{
+    ma_resource_manager* pResourceManager = (ma_resource_manager*)pUserData;
+    MA_ASSERT(pResourceManager != NULL);
+
+    for (;;) {
+        ma_result result;
+        ma_job job;
+
+        result = ma_resource_manager_next_job(pResourceManager, &job);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        /* Terminate if we got a quit message. */
+        if (job.toc.breakup.code == MA_JOB_TYPE_QUIT) {
+            break;
+        }
+
+        ma_job_process(&job);
+    }
+
+    return (ma_thread_result)0;
+}
+#endif
+
+MA_API ma_resource_manager_config ma_resource_manager_config_init(void)
+{
+    ma_resource_manager_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.decodedFormat     = ma_format_unknown;
+    config.decodedChannels   = 0;
+    config.decodedSampleRate = 0;
+    config.jobThreadCount    = 1;   /* A single miniaudio-managed job thread by default. */
+    config.jobQueueCapacity  = MA_JOB_TYPE_RESOURCE_MANAGER_QUEUE_CAPACITY;
+
+    /* Flags. */
+    config.flags = 0;
+    #ifdef MA_NO_THREADING
+    {
+        /* Threading is disabled at compile time so disable threading at runtime as well by default. */
+        config.flags |= MA_RESOURCE_MANAGER_FLAG_NO_THREADING;
+        config.jobThreadCount = 0;
+    }
+    #endif
+
+    return config;
+}
+
+
+MA_API ma_result ma_resource_manager_init(const ma_resource_manager_config* pConfig, ma_resource_manager* pResourceManager)
+{
+    ma_result result;
+    ma_job_queue_config jobQueueConfig;
+
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pResourceManager);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #ifndef MA_NO_THREADING
+    {
+        if (pConfig->jobThreadCount > ma_countof(pResourceManager->jobThreads)) {
+            return MA_INVALID_ARGS; /* Requesting too many job threads. */
+        }
+    }
+    #endif
+
+    pResourceManager->config = *pConfig;
+    ma_allocation_callbacks_init_copy(&pResourceManager->config.allocationCallbacks, &pConfig->allocationCallbacks);
+
+    /* Get the log set up early so we can start using it as soon as possible. */
+    if (pResourceManager->config.pLog == NULL) {
+        result = ma_log_init(&pResourceManager->config.allocationCallbacks, &pResourceManager->log);
+        if (result == MA_SUCCESS) {
+            pResourceManager->config.pLog = &pResourceManager->log;
+        } else {
+            pResourceManager->config.pLog = NULL;   /* Logging is unavailable. */
+        }
+    }
+
+    if (pResourceManager->config.pVFS == NULL) {
+        result = ma_default_vfs_init(&pResourceManager->defaultVFS, &pResourceManager->config.allocationCallbacks);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to initialize the default file system. */
+        }
+
+        pResourceManager->config.pVFS = &pResourceManager->defaultVFS;
+    }
+
+    /* If threading has been disabled at compile time, enfore it at run time as well. */
+    #ifdef MA_NO_THREADING
+    {
+        pResourceManager->config.flags |= MA_RESOURCE_MANAGER_FLAG_NO_THREADING;
+    }
+    #endif
+
+    /* We need to force MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING if MA_RESOURCE_MANAGER_FLAG_NO_THREADING is set. */
+    if ((pResourceManager->config.flags & MA_RESOURCE_MANAGER_FLAG_NO_THREADING) != 0) {
+        pResourceManager->config.flags |= MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING;
+
+        /* We cannot allow job threads when MA_RESOURCE_MANAGER_FLAG_NO_THREADING has been set. This is an invalid use case. */
+        if (pResourceManager->config.jobThreadCount > 0) {
+            return MA_INVALID_ARGS;
+        }
+    }
+
+    /* Job queue. */
+    jobQueueConfig.capacity = pResourceManager->config.jobQueueCapacity;
+    jobQueueConfig.flags    = 0;
+    if ((pResourceManager->config.flags & MA_RESOURCE_MANAGER_FLAG_NON_BLOCKING) != 0) {
+        if (pResourceManager->config.jobThreadCount > 0) {
+            return MA_INVALID_ARGS; /* Non-blocking mode is only valid for self-managed job threads. */
+        }
+
+        jobQueueConfig.flags |= MA_JOB_QUEUE_FLAG_NON_BLOCKING;
+    }
+
+    result = ma_job_queue_init(&jobQueueConfig, &pResourceManager->config.allocationCallbacks, &pResourceManager->jobQueue);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+
+    /* Custom decoding backends. */
+    if (pConfig->ppCustomDecodingBackendVTables != NULL && pConfig->customDecodingBackendCount > 0) {
+        size_t sizeInBytes = sizeof(*pResourceManager->config.ppCustomDecodingBackendVTables) * pConfig->customDecodingBackendCount;
+
+        pResourceManager->config.ppCustomDecodingBackendVTables = (ma_decoding_backend_vtable**)ma_malloc(sizeInBytes, &pResourceManager->config.allocationCallbacks);
+        if (pResourceManager->config.ppCustomDecodingBackendVTables == NULL) {
+            ma_job_queue_uninit(&pResourceManager->jobQueue, &pResourceManager->config.allocationCallbacks);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        MA_COPY_MEMORY(pResourceManager->config.ppCustomDecodingBackendVTables, pConfig->ppCustomDecodingBackendVTables, sizeInBytes);
+
+        pResourceManager->config.customDecodingBackendCount     = pConfig->customDecodingBackendCount;
+        pResourceManager->config.pCustomDecodingBackendUserData = pConfig->pCustomDecodingBackendUserData;
+    }
+
+
+
+    /* Here is where we initialize our threading stuff. We don't do this if we don't support threading. */
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_uint32 iJobThread;
+
+            /* Data buffer lock. */
+            result = ma_mutex_init(&pResourceManager->dataBufferBSTLock);
+            if (result != MA_SUCCESS) {
+                ma_job_queue_uninit(&pResourceManager->jobQueue, &pResourceManager->config.allocationCallbacks);
+                return result;
+            }
+
+            /* Create the job threads last to ensure the threads has access to valid data. */
+            for (iJobThread = 0; iJobThread < pResourceManager->config.jobThreadCount; iJobThread += 1) {
+                result = ma_thread_create(&pResourceManager->jobThreads[iJobThread], ma_thread_priority_normal, pResourceManager->config.jobThreadStackSize, ma_resource_manager_job_thread, pResourceManager, &pResourceManager->config.allocationCallbacks);
+                if (result != MA_SUCCESS) {
+                    ma_mutex_uninit(&pResourceManager->dataBufferBSTLock);
+                    ma_job_queue_uninit(&pResourceManager->jobQueue, &pResourceManager->config.allocationCallbacks);
+                    return result;
+                }
+            }
+        }
+        #else
+        {
+            /* Threading is disabled at compile time. We should never get here because validation checks should have already been performed. */
+            MA_ASSERT(MA_FALSE);
+        }
+        #endif
+    }
+
+    return MA_SUCCESS;
+}
+
+
+static void ma_resource_manager_delete_all_data_buffer_nodes(ma_resource_manager* pResourceManager)
+{
+    MA_ASSERT(pResourceManager);
+
+    /* If everything was done properly, there shouldn't be any active data buffers. */
+    while (pResourceManager->pRootDataBufferNode != NULL) {
+        ma_resource_manager_data_buffer_node* pDataBufferNode = pResourceManager->pRootDataBufferNode;
+        ma_resource_manager_data_buffer_node_remove(pResourceManager, pDataBufferNode);
+
+        /* The data buffer has been removed from the BST, so now we need to free it's data. */
+        ma_resource_manager_data_buffer_node_free(pResourceManager, pDataBufferNode);
+    }
+}
+
+MA_API void ma_resource_manager_uninit(ma_resource_manager* pResourceManager)
+{
+    if (pResourceManager == NULL) {
+        return;
+    }
+
+    /*
+    Job threads need to be killed first. To do this we need to post a quit message to the message queue and then wait for the thread. The quit message will never be removed from the
+    queue which means it will never not be returned after being encounted for the first time which means all threads will eventually receive it.
+    */
+    ma_resource_manager_post_job_quit(pResourceManager);
+
+    /* Wait for every job to finish before continuing to ensure nothing is sill trying to access any of our objects below. */
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_uint32 iJobThread;
+
+            for (iJobThread = 0; iJobThread < pResourceManager->config.jobThreadCount; iJobThread += 1) {
+                ma_thread_wait(&pResourceManager->jobThreads[iJobThread]);
+            }
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+        }
+        #endif
+    }
+
+    /* At this point the thread should have returned and no other thread should be accessing our data. We can now delete all data buffers. */
+    ma_resource_manager_delete_all_data_buffer_nodes(pResourceManager);
+
+    /* The job queue is no longer needed. */
+    ma_job_queue_uninit(&pResourceManager->jobQueue, &pResourceManager->config.allocationCallbacks);
+
+    /* We're no longer doing anything with data buffers so the lock can now be uninitialized. */
+    if (ma_resource_manager_is_threading_enabled(pResourceManager)) {
+        #ifndef MA_NO_THREADING
+        {
+            ma_mutex_uninit(&pResourceManager->dataBufferBSTLock);
+        }
+        #else
+        {
+            MA_ASSERT(MA_FALSE);    /* Should never hit this. */
+        }
+        #endif
+    }
+
+    ma_free(pResourceManager->config.ppCustomDecodingBackendVTables, &pResourceManager->config.allocationCallbacks);
+
+    if (pResourceManager->config.pLog == &pResourceManager->log) {
+        ma_log_uninit(&pResourceManager->log);
+    }
+}
+
+MA_API ma_log* ma_resource_manager_get_log(ma_resource_manager* pResourceManager)
+{
+    if (pResourceManager == NULL) {
+        return NULL;
+    }
+
+    return pResourceManager->config.pLog;
+}
+
+
+
+MA_API ma_resource_manager_data_source_config ma_resource_manager_data_source_config_init(void)
+{
+    ma_resource_manager_data_source_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.rangeBegInPCMFrames     = MA_DATA_SOURCE_DEFAULT_RANGE_BEG;
+    config.rangeEndInPCMFrames     = MA_DATA_SOURCE_DEFAULT_RANGE_END;
+    config.loopPointBegInPCMFrames = MA_DATA_SOURCE_DEFAULT_LOOP_POINT_BEG;
+    config.loopPointEndInPCMFrames = MA_DATA_SOURCE_DEFAULT_LOOP_POINT_END;
+    config.isLooping               = MA_FALSE;
+
+    return config;
+}
+
+
+static ma_decoder_config ma_resource_manager__init_decoder_config(ma_resource_manager* pResourceManager)
+{
+    ma_decoder_config config;
+
+    config = ma_decoder_config_init(pResourceManager->config.decodedFormat, pResourceManager->config.decodedChannels, pResourceManager->config.decodedSampleRate);
+    config.allocationCallbacks    = pResourceManager->config.allocationCallbacks;
+    config.ppCustomBackendVTables = pResourceManager->config.ppCustomDecodingBackendVTables;
+    config.customBackendCount     = pResourceManager->config.customDecodingBackendCount;
+    config.pCustomBackendUserData = pResourceManager->config.pCustomDecodingBackendUserData;
+
+    return config;
+}
+
+static ma_result ma_resource_manager__init_decoder(ma_resource_manager* pResourceManager, const char* pFilePath, const wchar_t* pFilePathW, ma_decoder* pDecoder)
+{
+    ma_result result;
+    ma_decoder_config config;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pFilePath        != NULL || pFilePathW != NULL);
+    MA_ASSERT(pDecoder         != NULL);
+
+    config = ma_resource_manager__init_decoder_config(pResourceManager);
+
+    if (pFilePath != NULL) {
+        result = ma_decoder_init_vfs(pResourceManager->config.pVFS, pFilePath, &config, pDecoder);
+        if (result != MA_SUCCESS) {
+            ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to load file \"%s\". %s.\n", pFilePath, ma_result_description(result));
+            return result;
+        }
+    } else {
+        result = ma_decoder_init_vfs_w(pResourceManager->config.pVFS, pFilePathW, &config, pDecoder);
+        if (result != MA_SUCCESS) {
+            #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(_MSC_VER)
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to load file \"%ls\". %s.\n", pFilePathW, ma_result_description(result));
+            #endif
+            return result;
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_bool32 ma_resource_manager_data_buffer_has_connector(ma_resource_manager_data_buffer* pDataBuffer)
+{
+    return ma_atomic_bool32_get(&pDataBuffer->isConnectorInitialized);
+}
+
+static ma_data_source* ma_resource_manager_data_buffer_get_connector(ma_resource_manager_data_buffer* pDataBuffer)
+{
+    if (ma_resource_manager_data_buffer_has_connector(pDataBuffer) == MA_FALSE) {
+        return NULL;    /* Connector not yet initialized. */
+    }
+
+    switch (pDataBuffer->pNode->data.type)
+    {
+        case ma_resource_manager_data_supply_type_encoded:       return &pDataBuffer->connector.decoder;
+        case ma_resource_manager_data_supply_type_decoded:       return &pDataBuffer->connector.buffer;
+        case ma_resource_manager_data_supply_type_decoded_paged: return &pDataBuffer->connector.pagedBuffer;
+
+        case ma_resource_manager_data_supply_type_unknown:
+        default:
+        {
+            ma_log_postf(ma_resource_manager_get_log(pDataBuffer->pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to retrieve data buffer connector. Unknown data supply type.\n");
+            return NULL;
+        };
+    };
+}
+
+static ma_result ma_resource_manager_data_buffer_init_connector(ma_resource_manager_data_buffer* pDataBuffer, const ma_resource_manager_data_source_config* pConfig, ma_async_notification* pInitNotification, ma_fence* pInitFence)
+{
+    ma_result result;
+
+    MA_ASSERT(pDataBuffer != NULL);
+    MA_ASSERT(pConfig     != NULL);
+    MA_ASSERT(ma_resource_manager_data_buffer_has_connector(pDataBuffer) == MA_FALSE);
+
+    /* The underlying data buffer must be initialized before we'll be able to know how to initialize the backend. */
+    result = ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode);
+    if (result != MA_SUCCESS && result != MA_BUSY) {
+        return result;  /* The data buffer is in an erroneous state. */
+    }
+
+    /*
+    We need to initialize either a ma_decoder or an ma_audio_buffer depending on whether or not the backing data is encoded or decoded. These act as the
+    "instance" to the data and are used to form the connection between underlying data buffer and the data source. If the data buffer is decoded, we can use
+    an ma_audio_buffer. This enables us to use memory mapping when mixing which saves us a bit of data movement overhead.
+    */
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode))
+    {
+        case ma_resource_manager_data_supply_type_encoded:          /* Connector is a decoder. */
+        {
+            ma_decoder_config config;
+            config = ma_resource_manager__init_decoder_config(pDataBuffer->pResourceManager);
+            result = ma_decoder_init_memory(pDataBuffer->pNode->data.backend.encoded.pData, pDataBuffer->pNode->data.backend.encoded.sizeInBytes, &config, &pDataBuffer->connector.decoder);
+        } break;
+
+        case ma_resource_manager_data_supply_type_decoded:          /* Connector is an audio buffer. */
+        {
+            ma_audio_buffer_config config;
+            config = ma_audio_buffer_config_init(pDataBuffer->pNode->data.backend.decoded.format, pDataBuffer->pNode->data.backend.decoded.channels, pDataBuffer->pNode->data.backend.decoded.totalFrameCount, pDataBuffer->pNode->data.backend.decoded.pData, NULL);
+            result = ma_audio_buffer_init(&config, &pDataBuffer->connector.buffer);
+        } break;
+
+        case ma_resource_manager_data_supply_type_decoded_paged:    /* Connector is a paged audio buffer. */
+        {
+            ma_paged_audio_buffer_config config;
+            config = ma_paged_audio_buffer_config_init(&pDataBuffer->pNode->data.backend.decodedPaged.data);
+            result = ma_paged_audio_buffer_init(&config, &pDataBuffer->connector.pagedBuffer);
+        } break;
+
+        case ma_resource_manager_data_supply_type_unknown:
+        default:
+        {
+            /* Unknown data supply type. Should never happen. Need to post an error here. */
+            return MA_INVALID_ARGS;
+        };
+    }
+
+    /*
+    Initialization of the connector is when we can fire the init notification. This will give the application access to
+    the format/channels/rate of the data source.
+    */
+    if (result == MA_SUCCESS) {
+        /*
+        The resource manager supports the ability to set the range and loop settings via a config at
+        initialization time. This results in an case where the ranges could be set explicitly via
+        ma_data_source_set_*() before we get to this point here. If this happens, we'll end up
+        hitting a case where we just override those settings which results in what feels like a bug.
+
+        To address this we only change the relevant properties if they're not equal to defaults. If
+        they're equal to defaults there's no need to change them anyway. If they're *not* set to the
+        default values, we can assume the user has set the range and loop settings via the config. If
+        they're doing their own calls to ma_data_source_set_*() in addition to setting them via the
+        config, that's entirely on the caller and any synchronization issue becomes their problem.
+        */
+        if (pConfig->rangeBegInPCMFrames != MA_DATA_SOURCE_DEFAULT_RANGE_BEG || pConfig->rangeEndInPCMFrames != MA_DATA_SOURCE_DEFAULT_RANGE_END) {
+            ma_data_source_set_range_in_pcm_frames(pDataBuffer, pConfig->rangeBegInPCMFrames, pConfig->rangeEndInPCMFrames);
+        }
+
+        if (pConfig->loopPointBegInPCMFrames != MA_DATA_SOURCE_DEFAULT_LOOP_POINT_BEG || pConfig->loopPointEndInPCMFrames != MA_DATA_SOURCE_DEFAULT_LOOP_POINT_END) {
+            ma_data_source_set_loop_point_in_pcm_frames(pDataBuffer, pConfig->loopPointBegInPCMFrames, pConfig->loopPointEndInPCMFrames);
+        }
+
+        if (pConfig->isLooping != MA_FALSE) {
+            ma_data_source_set_looping(pDataBuffer, pConfig->isLooping);
+        }
+
+        ma_atomic_bool32_set(&pDataBuffer->isConnectorInitialized, MA_TRUE);
+
+        if (pInitNotification != NULL) {
+            ma_async_notification_signal(pInitNotification);
+        }
+
+        if (pInitFence != NULL) {
+            ma_fence_release(pInitFence);
+        }
+    }
+
+    /* At this point the backend should be initialized. We do *not* want to set pDataSource->result here - that needs to be done at a higher level to ensure it's done as the last step. */
+    return result;
+}
+
+static ma_result ma_resource_manager_data_buffer_uninit_connector(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBuffer      != NULL);
+
+    (void)pResourceManager;
+
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode))
+    {
+        case ma_resource_manager_data_supply_type_encoded:          /* Connector is a decoder. */
+        {
+            ma_decoder_uninit(&pDataBuffer->connector.decoder);
+        } break;
+
+        case ma_resource_manager_data_supply_type_decoded:          /* Connector is an audio buffer. */
+        {
+            ma_audio_buffer_uninit(&pDataBuffer->connector.buffer);
+        } break;
+
+        case ma_resource_manager_data_supply_type_decoded_paged:    /* Connector is a paged audio buffer. */
+        {
+            ma_paged_audio_buffer_uninit(&pDataBuffer->connector.pagedBuffer);
+        } break;
+
+        case ma_resource_manager_data_supply_type_unknown:
+        default:
+        {
+            /* Unknown data supply type. Should never happen. Need to post an error here. */
+            return MA_INVALID_ARGS;
+        };
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_uint32 ma_resource_manager_data_buffer_node_next_execution_order(ma_resource_manager_data_buffer_node* pDataBufferNode)
+{
+    MA_ASSERT(pDataBufferNode != NULL);
+    return ma_atomic_fetch_add_32(&pDataBufferNode->executionCounter, 1);
+}
+
+static ma_result ma_resource_manager_data_buffer_node_init_supply_encoded(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, const char* pFilePath, const wchar_t* pFilePathW)
+{
+    ma_result result;
+    size_t dataSizeInBytes;
+    void* pData;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+    MA_ASSERT(pFilePath != NULL || pFilePathW != NULL);
+
+    result = ma_vfs_open_and_read_file_ex(pResourceManager->config.pVFS, pFilePath, pFilePathW, &pData, &dataSizeInBytes, &pResourceManager->config.allocationCallbacks);
+    if (result != MA_SUCCESS) {
+        if (pFilePath != NULL) {
+            ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to load file \"%s\". %s.\n", pFilePath, ma_result_description(result));
+        } else {
+            #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(_MSC_VER)
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to load file \"%ls\". %s.\n", pFilePathW, ma_result_description(result));
+            #endif
+        }
+
+        return result;
+    }
+
+    pDataBufferNode->data.backend.encoded.pData       = pData;
+    pDataBufferNode->data.backend.encoded.sizeInBytes = dataSizeInBytes;
+    ma_resource_manager_data_buffer_node_set_data_supply_type(pDataBufferNode, ma_resource_manager_data_supply_type_encoded);  /* <-- Must be set last. */
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_init_supply_decoded(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, const char* pFilePath, const wchar_t* pFilePathW, ma_uint32 flags, ma_decoder** ppDecoder)
+{
+    ma_result result = MA_SUCCESS;
+    ma_decoder* pDecoder;
+    ma_uint64 totalFrameCount;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+    MA_ASSERT(ppDecoder         != NULL);
+    MA_ASSERT(pFilePath != NULL || pFilePathW != NULL);
+
+    *ppDecoder = NULL;  /* For safety. */
+
+    pDecoder = (ma_decoder*)ma_malloc(sizeof(*pDecoder), &pResourceManager->config.allocationCallbacks);
+    if (pDecoder == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_resource_manager__init_decoder(pResourceManager, pFilePath, pFilePathW, pDecoder);
+    if (result != MA_SUCCESS) {
+        ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+        return result;
+    }
+
+    /*
+    At this point we have the decoder and we now need to initialize the data supply. This will
+    be either a decoded buffer, or a decoded paged buffer. A regular buffer is just one big heap
+    allocated buffer, whereas a paged buffer is a linked list of paged-sized buffers. The latter
+    is used when the length of a sound is unknown until a full decode has been performed.
+    */
+    if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH) == 0) {
+        result = ma_decoder_get_length_in_pcm_frames(pDecoder, &totalFrameCount);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    } else {
+        totalFrameCount = 0;
+    }
+
+    if (totalFrameCount > 0) {
+        /* It's a known length. The data supply is a regular decoded buffer. */
+        ma_uint64 dataSizeInBytes;
+        void* pData;
+
+        dataSizeInBytes = totalFrameCount * ma_get_bytes_per_frame(pDecoder->outputFormat, pDecoder->outputChannels);
+        if (dataSizeInBytes > MA_SIZE_MAX) {
+            ma_decoder_uninit(pDecoder);
+            ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+            return MA_TOO_BIG;
+        }
+
+        pData = ma_malloc((size_t)dataSizeInBytes, &pResourceManager->config.allocationCallbacks);
+        if (pData == NULL) {
+            ma_decoder_uninit(pDecoder);
+            ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+            return MA_OUT_OF_MEMORY;
+        }
+
+        /* The buffer needs to be initialized to silence in case the caller reads from it. */
+        ma_silence_pcm_frames(pData, totalFrameCount, pDecoder->outputFormat, pDecoder->outputChannels);
+
+        /* Data has been allocated and the data supply can now be initialized. */
+        pDataBufferNode->data.backend.decoded.pData             = pData;
+        pDataBufferNode->data.backend.decoded.totalFrameCount   = totalFrameCount;
+        pDataBufferNode->data.backend.decoded.format            = pDecoder->outputFormat;
+        pDataBufferNode->data.backend.decoded.channels          = pDecoder->outputChannels;
+        pDataBufferNode->data.backend.decoded.sampleRate        = pDecoder->outputSampleRate;
+        pDataBufferNode->data.backend.decoded.decodedFrameCount = 0;
+        ma_resource_manager_data_buffer_node_set_data_supply_type(pDataBufferNode, ma_resource_manager_data_supply_type_decoded);  /* <-- Must be set last. */
+    } else {
+        /*
+        It's an unknown length. The data supply is a paged decoded buffer. Setting this up is
+        actually easier than the non-paged decoded buffer because we just need to initialize
+        a ma_paged_audio_buffer object.
+        */
+        result = ma_paged_audio_buffer_data_init(pDecoder->outputFormat, pDecoder->outputChannels, &pDataBufferNode->data.backend.decodedPaged.data);
+        if (result != MA_SUCCESS) {
+            ma_decoder_uninit(pDecoder);
+            ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+            return result;
+        }
+
+        pDataBufferNode->data.backend.decodedPaged.sampleRate        = pDecoder->outputSampleRate;
+        pDataBufferNode->data.backend.decodedPaged.decodedFrameCount = 0;
+        ma_resource_manager_data_buffer_node_set_data_supply_type(pDataBufferNode, ma_resource_manager_data_supply_type_decoded_paged);  /* <-- Must be set last. */
+    }
+
+    *ppDecoder = pDecoder;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_decode_next_page(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, ma_decoder* pDecoder)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 pageSizeInFrames;
+    ma_uint64 framesToTryReading;
+    ma_uint64 framesRead;
+
+    MA_ASSERT(pResourceManager != NULL);
+    MA_ASSERT(pDataBufferNode  != NULL);
+    MA_ASSERT(pDecoder         != NULL);
+
+    /* We need to know the size of a page in frames to know how many frames to decode. */
+    pageSizeInFrames = MA_RESOURCE_MANAGER_PAGE_SIZE_IN_MILLISECONDS * (pDecoder->outputSampleRate/1000);
+    framesToTryReading = pageSizeInFrames;
+
+    /*
+    Here is where we do the decoding of the next page. We'll run a slightly different path depending
+    on whether or not we're using a flat or paged buffer because the allocation of the page differs
+    between the two. For a flat buffer it's an offset to an already-allocated buffer. For a paged
+    buffer, we need to allocate a new page and attach it to the linked list.
+    */
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBufferNode))
+    {
+        case ma_resource_manager_data_supply_type_decoded:
+        {
+            /* The destination buffer is an offset to the existing buffer. Don't read more than we originally retrieved when we first initialized the decoder. */
+            void* pDst;
+            ma_uint64 framesRemaining = pDataBufferNode->data.backend.decoded.totalFrameCount - pDataBufferNode->data.backend.decoded.decodedFrameCount;
+            if (framesToTryReading > framesRemaining) {
+                framesToTryReading = framesRemaining;
+            }
+
+            if (framesToTryReading > 0) {
+                pDst = ma_offset_ptr(
+                    pDataBufferNode->data.backend.decoded.pData,
+                    pDataBufferNode->data.backend.decoded.decodedFrameCount * ma_get_bytes_per_frame(pDataBufferNode->data.backend.decoded.format, pDataBufferNode->data.backend.decoded.channels)
+                );
+                MA_ASSERT(pDst != NULL);
+
+                result = ma_decoder_read_pcm_frames(pDecoder, pDst, framesToTryReading, &framesRead);
+                if (framesRead > 0) {
+                    pDataBufferNode->data.backend.decoded.decodedFrameCount += framesRead;
+                }
+            } else {
+                framesRead = 0;
+            }
+        } break;
+
+        case ma_resource_manager_data_supply_type_decoded_paged:
+        {
+            /* The destination buffer is a freshly allocated page. */
+            ma_paged_audio_buffer_page* pPage;
+
+            result = ma_paged_audio_buffer_data_allocate_page(&pDataBufferNode->data.backend.decodedPaged.data, framesToTryReading, NULL, &pResourceManager->config.allocationCallbacks, &pPage);
+            if (result != MA_SUCCESS) {
+                return result;
+            }
+
+            result = ma_decoder_read_pcm_frames(pDecoder, pPage->pAudioData, framesToTryReading, &framesRead);
+            if (framesRead > 0) {
+                pPage->sizeInFrames = framesRead;
+
+                result = ma_paged_audio_buffer_data_append_page(&pDataBufferNode->data.backend.decodedPaged.data, pPage);
+                if (result == MA_SUCCESS) {
+                    pDataBufferNode->data.backend.decodedPaged.decodedFrameCount += framesRead;
+                } else {
+                    /* Failed to append the page. Just abort and set the status to MA_AT_END. */
+                    ma_paged_audio_buffer_data_free_page(&pDataBufferNode->data.backend.decodedPaged.data, pPage, &pResourceManager->config.allocationCallbacks);
+                    result = MA_AT_END;
+                }
+            } else {
+                /* No frames were read. Free the page and just set the status to MA_AT_END. */
+                ma_paged_audio_buffer_data_free_page(&pDataBufferNode->data.backend.decodedPaged.data, pPage, &pResourceManager->config.allocationCallbacks);
+                result = MA_AT_END;
+            }
+        } break;
+
+        case ma_resource_manager_data_supply_type_encoded:
+        case ma_resource_manager_data_supply_type_unknown:
+        default:
+        {
+            /* Unexpected data supply type. */
+            ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Unexpected data supply type (%d) when decoding page.", ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBufferNode));
+            return MA_ERROR;
+        };
+    }
+
+    if (result == MA_SUCCESS && framesRead == 0) {
+        result = MA_AT_END;
+    }
+
+    return result;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_acquire_critical_section(ma_resource_manager* pResourceManager, const char* pFilePath, const wchar_t* pFilePathW, ma_uint32 hashedName32, ma_uint32 flags, const ma_resource_manager_data_supply* pExistingData, ma_fence* pInitFence, ma_fence* pDoneFence, ma_resource_manager_inline_notification* pInitNotification, ma_resource_manager_data_buffer_node** ppDataBufferNode)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager_data_buffer_node* pDataBufferNode = NULL;
+    ma_resource_manager_data_buffer_node* pInsertPoint;
+
+    if (ppDataBufferNode != NULL) {
+        *ppDataBufferNode = NULL;
+    }
+
+    result = ma_resource_manager_data_buffer_node_insert_point(pResourceManager, hashedName32, &pInsertPoint);
+    if (result == MA_ALREADY_EXISTS) {
+        /* The node already exists. We just need to increment the reference count. */
+        pDataBufferNode = pInsertPoint;
+
+        result = ma_resource_manager_data_buffer_node_increment_ref(pResourceManager, pDataBufferNode, NULL);
+        if (result != MA_SUCCESS) {
+            return result;  /* Should never happen. Failed to increment the reference count. */
+        }
+
+        result = MA_ALREADY_EXISTS;
+        goto done;
+    } else {
+        /*
+        The node does not already exist. We need to post a LOAD_DATA_BUFFER_NODE job here. This
+        needs to be done inside the critical section to ensure an uninitialization of the node
+        does not occur before initialization on another thread.
+        */
+        pDataBufferNode = (ma_resource_manager_data_buffer_node*)ma_malloc(sizeof(*pDataBufferNode), &pResourceManager->config.allocationCallbacks);
+        if (pDataBufferNode == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+
+        MA_ZERO_OBJECT(pDataBufferNode);
+        pDataBufferNode->hashedName32 = hashedName32;
+        pDataBufferNode->refCount     = 1;        /* Always set to 1 by default (this is our first reference). */
+
+        if (pExistingData == NULL) {
+            pDataBufferNode->data.type    = ma_resource_manager_data_supply_type_unknown;    /* <-- We won't know this until we start decoding. */
+            pDataBufferNode->result       = MA_BUSY;  /* Must be set to MA_BUSY before we leave the critical section, so might as well do it now. */
+            pDataBufferNode->isDataOwnedByResourceManager = MA_TRUE;
+        } else {
+            pDataBufferNode->data         = *pExistingData;
+            pDataBufferNode->result       = MA_SUCCESS;   /* Not loading asynchronously, so just set the status */
+            pDataBufferNode->isDataOwnedByResourceManager = MA_FALSE;
+        }
+
+        result = ma_resource_manager_data_buffer_node_insert_at(pResourceManager, pDataBufferNode, pInsertPoint);
+        if (result != MA_SUCCESS) {
+            ma_free(pDataBufferNode, &pResourceManager->config.allocationCallbacks);
+            return result;  /* Should never happen. Failed to insert the data buffer into the BST. */
+        }
+
+        /*
+        Here is where we'll post the job, but only if we're loading asynchronously. If we're
+        loading synchronously we'll defer loading to a later stage, outside of the critical
+        section.
+        */
+        if (pDataBufferNode->isDataOwnedByResourceManager && (flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC) != 0) {
+            /* Loading asynchronously. Post the job. */
+            ma_job job;
+            char* pFilePathCopy = NULL;
+            wchar_t* pFilePathWCopy = NULL;
+
+            /* We need a copy of the file path. We should probably make this more efficient, but for now we'll do a transient memory allocation. */
+            if (pFilePath != NULL) {
+                pFilePathCopy = ma_copy_string(pFilePath, &pResourceManager->config.allocationCallbacks);
+            } else {
+                pFilePathWCopy = ma_copy_string_w(pFilePathW, &pResourceManager->config.allocationCallbacks);
+            }
+
+            if (pFilePathCopy == NULL && pFilePathWCopy == NULL) {
+                ma_resource_manager_data_buffer_node_remove(pResourceManager, pDataBufferNode);
+                ma_free(pDataBufferNode, &pResourceManager->config.allocationCallbacks);
+                return MA_OUT_OF_MEMORY;
+            }
+
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                ma_resource_manager_inline_notification_init(pResourceManager, pInitNotification);
+            }
+
+            /* Acquire init and done fences before posting the job. These will be unacquired by the job thread. */
+            if (pInitFence != NULL) { ma_fence_acquire(pInitFence); }
+            if (pDoneFence != NULL) { ma_fence_acquire(pDoneFence); }
+
+            /* We now have everything we need to post the job to the job thread. */
+            job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE);
+            job.order = ma_resource_manager_data_buffer_node_next_execution_order(pDataBufferNode);
+            job.data.resourceManager.loadDataBufferNode.pResourceManager  = pResourceManager;
+            job.data.resourceManager.loadDataBufferNode.pDataBufferNode   = pDataBufferNode;
+            job.data.resourceManager.loadDataBufferNode.pFilePath         = pFilePathCopy;
+            job.data.resourceManager.loadDataBufferNode.pFilePathW        = pFilePathWCopy;
+            job.data.resourceManager.loadDataBufferNode.flags             = flags;
+            job.data.resourceManager.loadDataBufferNode.pInitNotification = ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) ? pInitNotification : NULL;
+            job.data.resourceManager.loadDataBufferNode.pDoneNotification = NULL;
+            job.data.resourceManager.loadDataBufferNode.pInitFence        = pInitFence;
+            job.data.resourceManager.loadDataBufferNode.pDoneFence        = pDoneFence;
+
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                result = ma_job_process(&job);
+            } else {
+                result = ma_resource_manager_post_job(pResourceManager, &job);
+            }
+
+            if (result != MA_SUCCESS) {
+                /* Failed to post job. Probably ran out of memory. */
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to post MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER_NODE job. %s.\n", ma_result_description(result));
+
+                /*
+                Fences were acquired before posting the job, but since the job was not able to
+                be posted, we need to make sure we release them so nothing gets stuck waiting.
+                */
+                if (pInitFence != NULL) { ma_fence_release(pInitFence); }
+                if (pDoneFence != NULL) { ma_fence_release(pDoneFence); }
+
+                if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                    ma_resource_manager_inline_notification_uninit(pInitNotification);
+                } else {
+                    /* These will have been freed by the job thread, but with WAIT_INIT they will already have happend sinced the job has already been handled. */
+                    ma_free(pFilePathCopy,  &pResourceManager->config.allocationCallbacks);
+                    ma_free(pFilePathWCopy, &pResourceManager->config.allocationCallbacks);
+                }
+
+                ma_resource_manager_data_buffer_node_remove(pResourceManager, pDataBufferNode);
+                ma_free(pDataBufferNode, &pResourceManager->config.allocationCallbacks);
+
+                return result;
+            }
+        }
+    }
+
+done:
+    if (ppDataBufferNode != NULL) {
+        *ppDataBufferNode = pDataBufferNode;
+    }
+
+    return result;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_acquire(ma_resource_manager* pResourceManager, const char* pFilePath, const wchar_t* pFilePathW, ma_uint32 hashedName32, ma_uint32 flags, const ma_resource_manager_data_supply* pExistingData, ma_fence* pInitFence, ma_fence* pDoneFence, ma_resource_manager_data_buffer_node** ppDataBufferNode)
+{
+    ma_result result = MA_SUCCESS;
+    ma_bool32 nodeAlreadyExists = MA_FALSE;
+    ma_resource_manager_data_buffer_node* pDataBufferNode = NULL;
+    ma_resource_manager_inline_notification initNotification;   /* Used when the WAIT_INIT flag is set. */
+
+    if (ppDataBufferNode != NULL) {
+        *ppDataBufferNode = NULL;   /* Safety. */
+    }
+
+    if (pResourceManager == NULL || (pFilePath == NULL && pFilePathW == NULL && hashedName32 == 0)) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If we're specifying existing data, it must be valid. */
+    if (pExistingData != NULL && pExistingData->type == ma_resource_manager_data_supply_type_unknown) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If we don't support threading, remove the ASYNC flag to make the rest of this a bit simpler. */
+    if (ma_resource_manager_is_threading_enabled(pResourceManager) == MA_FALSE) {
+        flags &= ~MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC;
+    }
+
+    if (hashedName32 == 0) {
+        if (pFilePath != NULL) {
+            hashedName32 = ma_hash_string_32(pFilePath);
+        } else {
+            hashedName32 = ma_hash_string_w_32(pFilePathW);
+        }
+    }
+
+    /*
+    Here is where we either increment the node's reference count or allocate a new one and add it
+    to the BST. When allocating a new node, we need to make sure the LOAD_DATA_BUFFER_NODE job is
+    posted inside the critical section just in case the caller immediately uninitializes the node
+    as this will ensure the FREE_DATA_BUFFER_NODE job is given an execution order such that the
+    node is not uninitialized before initialization.
+    */
+    ma_resource_manager_data_buffer_bst_lock(pResourceManager);
+    {
+        result = ma_resource_manager_data_buffer_node_acquire_critical_section(pResourceManager, pFilePath, pFilePathW, hashedName32, flags, pExistingData, pInitFence, pDoneFence, &initNotification, &pDataBufferNode);
+    }
+    ma_resource_manager_data_buffer_bst_unlock(pResourceManager);
+
+    if (result == MA_ALREADY_EXISTS) {
+        nodeAlreadyExists = MA_TRUE;
+        result = MA_SUCCESS;
+    } else {
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    /*
+    If we're loading synchronously, we'll need to load everything now. When loading asynchronously,
+    a job will have been posted inside the BST critical section so that an uninitialization can be
+    allocated an appropriate execution order thereby preventing it from being uninitialized before
+    the node is initialized by the decoding thread(s).
+    */
+    if (nodeAlreadyExists == MA_FALSE) {    /* Don't need to try loading anything if the node already exists. */
+        if (pFilePath == NULL && pFilePathW == NULL) {
+            /*
+            If this path is hit, it means a buffer is being copied (i.e. initialized from only the
+            hashed name), but that node has been freed in the meantime, probably from some other
+            thread. This is an invalid operation.
+            */
+            ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Cloning data buffer node failed because the source node was released. The source node must remain valid until the cloning has completed.\n");
+            result = MA_INVALID_OPERATION;
+            goto done;
+        }
+
+        if (pDataBufferNode->isDataOwnedByResourceManager) {
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC) == 0) {
+                /* Loading synchronously. Load the sound in it's entirety here. */
+                if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE) == 0) {
+                    /* No decoding. This is the simple case - just store the file contents in memory. */
+                    result = ma_resource_manager_data_buffer_node_init_supply_encoded(pResourceManager, pDataBufferNode, pFilePath, pFilePathW);
+                    if (result != MA_SUCCESS) {
+                        goto done;
+                    }
+                } else {
+                    /* Decoding. We do this the same way as we do when loading asynchronously. */
+                    ma_decoder* pDecoder;
+                    result = ma_resource_manager_data_buffer_node_init_supply_decoded(pResourceManager, pDataBufferNode, pFilePath, pFilePathW, flags, &pDecoder);
+                    if (result != MA_SUCCESS) {
+                        goto done;
+                    }
+
+                    /* We have the decoder, now decode page by page just like we do when loading asynchronously. */
+                    for (;;) {
+                        /* Decode next page. */
+                        result = ma_resource_manager_data_buffer_node_decode_next_page(pResourceManager, pDataBufferNode, pDecoder);
+                        if (result != MA_SUCCESS) {
+                            break;  /* Will return MA_AT_END when the last page has been decoded. */
+                        }
+                    }
+
+                    /* Reaching the end needs to be considered successful. */
+                    if (result == MA_AT_END) {
+                        result  = MA_SUCCESS;
+                    }
+
+                    /*
+                    At this point the data buffer is either fully decoded or some error occurred. Either
+                    way, the decoder is no longer necessary.
+                    */
+                    ma_decoder_uninit(pDecoder);
+                    ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+                }
+
+                /* Getting here means we were successful. Make sure the status of the node is updated accordingly. */
+                ma_atomic_exchange_i32(&pDataBufferNode->result, result);
+            } else {
+                /* Loading asynchronously. We may need to wait for initialization. */
+                if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                    ma_resource_manager_inline_notification_wait(&initNotification);
+                }
+            }
+        } else {
+            /* The data is not managed by the resource manager so there's nothing else to do. */
+            MA_ASSERT(pExistingData != NULL);
+        }
+    }
+
+done:
+    /* If we failed to initialize the data buffer we need to free it. */
+    if (result != MA_SUCCESS) {
+        if (nodeAlreadyExists == MA_FALSE) {
+            ma_resource_manager_data_buffer_node_remove(pResourceManager, pDataBufferNode);
+            ma_free(pDataBufferNode, &pResourceManager->config.allocationCallbacks);
+        }
+    }
+
+    /*
+    The init notification needs to be uninitialized. This will be used if the node does not already
+    exist, and we've specified ASYNC | WAIT_INIT.
+    */
+    if (nodeAlreadyExists == MA_FALSE && pDataBufferNode->isDataOwnedByResourceManager && (flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC) != 0) {
+        if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+            ma_resource_manager_inline_notification_uninit(&initNotification);
+        }
+    }
+
+    if (ppDataBufferNode != NULL) {
+        *ppDataBufferNode = pDataBufferNode;
+    }
+
+    return result;
+}
+
+static ma_result ma_resource_manager_data_buffer_node_unacquire(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, const char* pName, const wchar_t* pNameW)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 refCount = 0xFFFFFFFF; /* The new reference count of the node after decrementing. Initialize to non-0 to be safe we don't fall into the freeing path. */
+    ma_uint32 hashedName32 = 0;
+
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pDataBufferNode == NULL) {
+        if (pName == NULL && pNameW == NULL) {
+            return MA_INVALID_ARGS;
+        }
+
+        if (pName != NULL) {
+            hashedName32 = ma_hash_string_32(pName);
+        } else {
+            hashedName32 = ma_hash_string_w_32(pNameW);
+        }
+    }
+
+    /*
+    The first thing to do is decrement the reference counter of the node. Then, if the reference
+    count is zero, we need to free the node. If the node is still in the process of loading, we'll
+    need to post a job to the job queue to free the node. Otherwise we'll just do it here.
+    */
+    ma_resource_manager_data_buffer_bst_lock(pResourceManager);
+    {
+        /* Might need to find the node. Must be done inside the critical section. */
+        if (pDataBufferNode == NULL) {
+            result = ma_resource_manager_data_buffer_node_search(pResourceManager, hashedName32, &pDataBufferNode);
+            if (result != MA_SUCCESS) {
+                goto stage2;    /* Couldn't find the node. */
+            }
+        }
+
+        result = ma_resource_manager_data_buffer_node_decrement_ref(pResourceManager, pDataBufferNode, &refCount);
+        if (result != MA_SUCCESS) {
+            goto stage2;    /* Should never happen. */
+        }
+
+        if (refCount == 0) {
+            result = ma_resource_manager_data_buffer_node_remove(pResourceManager, pDataBufferNode);
+            if (result != MA_SUCCESS) {
+                goto stage2;  /* An error occurred when trying to remove the data buffer. This should never happen. */
+            }
+        }
+    }
+    ma_resource_manager_data_buffer_bst_unlock(pResourceManager);
+
+stage2:
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /*
+    Here is where we need to free the node. We don't want to do this inside the critical section
+    above because we want to keep that as small as possible for multi-threaded efficiency.
+    */
+    if (refCount == 0) {
+        if (ma_resource_manager_data_buffer_node_result(pDataBufferNode) == MA_BUSY) {
+            /* The sound is still loading. We need to delay the freeing of the node to a safe time. */
+            ma_job job;
+
+            /* We need to mark the node as unavailable for the sake of the resource manager worker threads. */
+            ma_atomic_exchange_i32(&pDataBufferNode->result, MA_UNAVAILABLE);
+
+            job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE);
+            job.order = ma_resource_manager_data_buffer_node_next_execution_order(pDataBufferNode);
+            job.data.resourceManager.freeDataBufferNode.pResourceManager = pResourceManager;
+            job.data.resourceManager.freeDataBufferNode.pDataBufferNode  = pDataBufferNode;
+
+            result = ma_resource_manager_post_job(pResourceManager, &job);
+            if (result != MA_SUCCESS) {
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to post MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER_NODE job. %s.\n", ma_result_description(result));
+                return result;
+            }
+
+            /* If we don't support threading, process the job queue here. */
+            if (ma_resource_manager_is_threading_enabled(pResourceManager) == MA_FALSE) {
+                while (ma_resource_manager_data_buffer_node_result(pDataBufferNode) == MA_BUSY) {
+                    result = ma_resource_manager_process_next_job(pResourceManager);
+                    if (result == MA_NO_DATA_AVAILABLE || result == MA_CANCELLED) {
+                        result = MA_SUCCESS;
+                        break;
+                    }
+                }
+            } else {
+                /* Threading is enabled. The job queue will deal with the rest of the cleanup from here. */
+            }
+        } else {
+            /* The sound isn't loading so we can just free the node here. */
+            ma_resource_manager_data_buffer_node_free(pResourceManager, pDataBufferNode);
+        }
+    }
+
+    return result;
+}
+
+
+
+static ma_uint32 ma_resource_manager_data_buffer_next_execution_order(ma_resource_manager_data_buffer* pDataBuffer)
+{
+    MA_ASSERT(pDataBuffer != NULL);
+    return ma_atomic_fetch_add_32(&pDataBuffer->executionCounter, 1);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__read_pcm_frames(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_resource_manager_data_buffer_read_pcm_frames((ma_resource_manager_data_buffer*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__seek_to_pcm_frame(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_resource_manager_data_buffer_seek_to_pcm_frame((ma_resource_manager_data_buffer*)pDataSource, frameIndex);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_resource_manager_data_buffer_get_data_format((ma_resource_manager_data_buffer*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__get_cursor_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_resource_manager_data_buffer_get_cursor_in_pcm_frames((ma_resource_manager_data_buffer*)pDataSource, pCursor);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__get_length_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_resource_manager_data_buffer_get_length_in_pcm_frames((ma_resource_manager_data_buffer*)pDataSource, pLength);
+}
+
+static ma_result ma_resource_manager_data_buffer_cb__set_looping(ma_data_source* pDataSource, ma_bool32 isLooping)
+{
+    ma_resource_manager_data_buffer* pDataBuffer = (ma_resource_manager_data_buffer*)pDataSource;
+    MA_ASSERT(pDataBuffer != NULL);
+
+    ma_atomic_exchange_32(&pDataBuffer->isLooping, isLooping);
+
+    /* The looping state needs to be set on the connector as well or else looping won't work when we read audio data. */
+    ma_data_source_set_looping(ma_resource_manager_data_buffer_get_connector(pDataBuffer), isLooping);
+
+    return MA_SUCCESS;
+}
+
+static ma_data_source_vtable g_ma_resource_manager_data_buffer_vtable =
+{
+    ma_resource_manager_data_buffer_cb__read_pcm_frames,
+    ma_resource_manager_data_buffer_cb__seek_to_pcm_frame,
+    ma_resource_manager_data_buffer_cb__get_data_format,
+    ma_resource_manager_data_buffer_cb__get_cursor_in_pcm_frames,
+    ma_resource_manager_data_buffer_cb__get_length_in_pcm_frames,
+    ma_resource_manager_data_buffer_cb__set_looping,
+    0
+};
+
+static ma_result ma_resource_manager_data_buffer_init_ex_internal(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_uint32 hashedName32, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager_data_buffer_node* pDataBufferNode;
+    ma_data_source_config dataSourceConfig;
+    ma_bool32 async;
+    ma_uint32 flags;
+    ma_resource_manager_pipeline_notifications notifications;
+
+    if (pDataBuffer == NULL) {
+        if (pConfig != NULL && pConfig->pNotifications != NULL) {
+            ma_resource_manager_pipeline_notifications_signal_all_notifications(pConfig->pNotifications);
+        }
+
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDataBuffer);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->pNotifications != NULL) {
+        notifications = *pConfig->pNotifications;   /* From here on out we should be referencing `notifications` instead of `pNotifications`. Set this to NULL to catch errors at testing time. */
+    } else {
+        MA_ZERO_OBJECT(&notifications);
+    }
+
+    /* For safety, always remove the ASYNC flag if threading is disabled on the resource manager. */
+    flags = pConfig->flags;
+    if (ma_resource_manager_is_threading_enabled(pResourceManager) == MA_FALSE) {
+        flags &= ~MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC;
+    }
+
+    async = (flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC) != 0;
+
+    /*
+    Fences need to be acquired before doing anything. These must be acquired and released outside of
+    the node to ensure there's no holes where ma_fence_wait() could prematurely return before the
+    data buffer has completed initialization.
+
+    When loading asynchronously, the node acquisition routine below will acquire the fences on this
+    thread and then release them on the async thread when the operation is complete.
+
+    These fences are always released at the "done" tag at the end of this function. They'll be
+    acquired a second if loading asynchronously. This double acquisition system is just done to
+    simplify code maintanence.
+    */
+    ma_resource_manager_pipeline_notifications_acquire_all_fences(&notifications);
+    {
+        /* We first need to acquire a node. If ASYNC is not set, this will not return until the entire sound has been loaded. */
+        result = ma_resource_manager_data_buffer_node_acquire(pResourceManager, pConfig->pFilePath, pConfig->pFilePathW, hashedName32, flags, NULL, notifications.init.pFence, notifications.done.pFence, &pDataBufferNode);
+        if (result != MA_SUCCESS) {
+            ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+            goto done;
+        }
+
+        dataSourceConfig = ma_data_source_config_init();
+        dataSourceConfig.vtable = &g_ma_resource_manager_data_buffer_vtable;
+
+        result = ma_data_source_init(&dataSourceConfig, &pDataBuffer->ds);
+        if (result != MA_SUCCESS) {
+            ma_resource_manager_data_buffer_node_unacquire(pResourceManager, pDataBufferNode, NULL, NULL);
+            ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+            goto done;
+        }
+
+        pDataBuffer->pResourceManager = pResourceManager;
+        pDataBuffer->pNode  = pDataBufferNode;
+        pDataBuffer->flags  = flags;
+        pDataBuffer->result = MA_BUSY;  /* Always default to MA_BUSY for safety. It'll be overwritten when loading completes or an error occurs. */
+
+        /* If we're loading asynchronously we need to post a job to the job queue to initialize the connector. */
+        if (async == MA_FALSE || ma_resource_manager_data_buffer_node_result(pDataBufferNode) == MA_SUCCESS) {
+            /* Loading synchronously or the data has already been fully loaded. We can just initialize the connector from here without a job. */
+            result = ma_resource_manager_data_buffer_init_connector(pDataBuffer, pConfig, NULL, NULL);
+            ma_atomic_exchange_i32(&pDataBuffer->result, result);
+
+            ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+            goto done;
+        } else {
+            /* The node's data supply isn't initialized yet. The caller has requested that we load asynchronously so we need to post a job to do this. */
+            ma_job job;
+            ma_resource_manager_inline_notification initNotification;   /* Used when the WAIT_INIT flag is set. */
+
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                ma_resource_manager_inline_notification_init(pResourceManager, &initNotification);
+            }
+
+            /*
+            The status of the data buffer needs to be set to MA_BUSY before posting the job so that the
+            worker thread is aware of it's busy state. If the LOAD_DATA_BUFFER job sees a status other
+            than MA_BUSY, it'll assume an error and fall through to an early exit.
+            */
+            ma_atomic_exchange_i32(&pDataBuffer->result, MA_BUSY);
+
+            /* Acquire fences a second time. These will be released by the async thread. */
+            ma_resource_manager_pipeline_notifications_acquire_all_fences(&notifications);
+
+            job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER);
+            job.order = ma_resource_manager_data_buffer_next_execution_order(pDataBuffer);
+            job.data.resourceManager.loadDataBuffer.pDataBuffer             = pDataBuffer;
+            job.data.resourceManager.loadDataBuffer.pInitNotification       = ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) ? &initNotification : notifications.init.pNotification;
+            job.data.resourceManager.loadDataBuffer.pDoneNotification       = notifications.done.pNotification;
+            job.data.resourceManager.loadDataBuffer.pInitFence              = notifications.init.pFence;
+            job.data.resourceManager.loadDataBuffer.pDoneFence              = notifications.done.pFence;
+            job.data.resourceManager.loadDataBuffer.rangeBegInPCMFrames     = pConfig->rangeBegInPCMFrames;
+            job.data.resourceManager.loadDataBuffer.rangeEndInPCMFrames     = pConfig->rangeEndInPCMFrames;
+            job.data.resourceManager.loadDataBuffer.loopPointBegInPCMFrames = pConfig->loopPointBegInPCMFrames;
+            job.data.resourceManager.loadDataBuffer.loopPointEndInPCMFrames = pConfig->loopPointEndInPCMFrames;
+            job.data.resourceManager.loadDataBuffer.isLooping               = pConfig->isLooping;
+
+            /* If we need to wait for initialization to complete we can just process the job in place. */
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                result = ma_job_process(&job);
+            } else {
+                result = ma_resource_manager_post_job(pResourceManager, &job);
+            }
+
+            if (result != MA_SUCCESS) {
+                /* We failed to post the job. Most likely there isn't enough room in the queue's buffer. */
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to post MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER job. %s.\n", ma_result_description(result));
+                ma_atomic_exchange_i32(&pDataBuffer->result, result);
+
+                /* Release the fences after the result has been set on the data buffer. */
+                ma_resource_manager_pipeline_notifications_release_all_fences(&notifications);
+            } else {
+                if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                    ma_resource_manager_inline_notification_wait(&initNotification);
+
+                    if (notifications.init.pNotification != NULL) {
+                        ma_async_notification_signal(notifications.init.pNotification);
+                    }
+
+                    /* NOTE: Do not release the init fence here. It will have been done by the job. */
+
+                    /* Make sure we return an error if initialization failed on the async thread. */
+                    result = ma_resource_manager_data_buffer_result(pDataBuffer);
+                    if (result == MA_BUSY) {
+                        result  = MA_SUCCESS;
+                    }
+                }
+            }
+
+            if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+                ma_resource_manager_inline_notification_uninit(&initNotification);
+            }
+        }
+
+        if (result != MA_SUCCESS) {
+            ma_resource_manager_data_buffer_node_unacquire(pResourceManager, pDataBufferNode, NULL, NULL);
+            goto done;
+        }
+    }
+done:
+    if (result == MA_SUCCESS) {
+        if (pConfig->initialSeekPointInPCMFrames > 0) {
+            ma_resource_manager_data_buffer_seek_to_pcm_frame(pDataBuffer, pConfig->initialSeekPointInPCMFrames);
+        }
+    }
+
+    ma_resource_manager_pipeline_notifications_release_all_fences(&notifications);
+
+    return result;
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    return ma_resource_manager_data_buffer_init_ex_internal(pResourceManager, pConfig, 0, pDataBuffer);
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_init(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePath      = pFilePath;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_buffer_init_ex(pResourceManager, &config, pDataBuffer);
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_init_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePathW     = pFilePath;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_buffer_init_ex(pResourceManager, &config, pDataBuffer);
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_init_copy(ma_resource_manager* pResourceManager, const ma_resource_manager_data_buffer* pExistingDataBuffer, ma_resource_manager_data_buffer* pDataBuffer)
+{
+    ma_resource_manager_data_source_config config;
+
+    if (pExistingDataBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ASSERT(pExistingDataBuffer->pNode != NULL);  /* <-- If you've triggered this, you've passed in an invalid existing data buffer. */
+
+    config = ma_resource_manager_data_source_config_init();
+    config.flags = pExistingDataBuffer->flags;
+
+    return ma_resource_manager_data_buffer_init_ex_internal(pResourceManager, &config, pExistingDataBuffer->pNode->hashedName32, pDataBuffer);
+}
+
+static ma_result ma_resource_manager_data_buffer_uninit_internal(ma_resource_manager_data_buffer* pDataBuffer)
+{
+    MA_ASSERT(pDataBuffer != NULL);
+
+    /* The connector should be uninitialized first. */
+    ma_resource_manager_data_buffer_uninit_connector(pDataBuffer->pResourceManager, pDataBuffer);
+
+    /* With the connector uninitialized we can unacquire the node. */
+    ma_resource_manager_data_buffer_node_unacquire(pDataBuffer->pResourceManager, pDataBuffer->pNode, NULL, NULL);
+
+    /* The base data source needs to be uninitialized as well. */
+    ma_data_source_uninit(&pDataBuffer->ds);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_uninit(ma_resource_manager_data_buffer* pDataBuffer)
+{
+    ma_result result;
+
+    if (pDataBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_buffer_result(pDataBuffer) == MA_SUCCESS) {
+        /* The data buffer can be deleted synchronously. */
+        return ma_resource_manager_data_buffer_uninit_internal(pDataBuffer);
+    } else {
+        /*
+        The data buffer needs to be deleted asynchronously because it's still loading. With the status set to MA_UNAVAILABLE, no more pages will
+        be loaded and the uninitialization should happen fairly quickly. Since the caller owns the data buffer, we need to wait for this event
+        to get processed before returning.
+        */
+        ma_resource_manager_inline_notification notification;
+        ma_job job;
+
+        /*
+        We need to mark the node as unavailable so we don't try reading from it anymore, but also to
+        let the loading thread know that it needs to abort it's loading procedure.
+        */
+        ma_atomic_exchange_i32(&pDataBuffer->result, MA_UNAVAILABLE);
+
+        result = ma_resource_manager_inline_notification_init(pDataBuffer->pResourceManager, &notification);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to create the notification. This should rarely, if ever, happen. */
+        }
+
+        job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER);
+        job.order = ma_resource_manager_data_buffer_next_execution_order(pDataBuffer);
+        job.data.resourceManager.freeDataBuffer.pDataBuffer       = pDataBuffer;
+        job.data.resourceManager.freeDataBuffer.pDoneNotification = &notification;
+        job.data.resourceManager.freeDataBuffer.pDoneFence        = NULL;
+
+        result = ma_resource_manager_post_job(pDataBuffer->pResourceManager, &job);
+        if (result != MA_SUCCESS) {
+            ma_resource_manager_inline_notification_uninit(&notification);
+            return result;
+        }
+
+        ma_resource_manager_inline_notification_wait_and_uninit(&notification);
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_read_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 framesRead = 0;
+    ma_bool32 isDecodedBufferBusy = MA_FALSE;
+
+    /* Safety. */
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    We cannot be using the data buffer after it's been uninitialized. If you trigger this assert it means you're trying to read from the data buffer after
+    it's been uninitialized or is in the process of uninitializing.
+    */
+    MA_ASSERT(ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) != MA_UNAVAILABLE);
+
+    /* If the node is not initialized we need to abort with a busy code. */
+    if (ma_resource_manager_data_buffer_has_connector(pDataBuffer) == MA_FALSE) {
+        return MA_BUSY; /* Still loading. */
+    }
+
+    /*
+    If we've got a seek scheduled we'll want to do that before reading. However, for paged buffers, there's
+    a chance that the sound hasn't yet been decoded up to the seek point will result in the seek failing. If
+    this happens, we need to keep the seek scheduled and return MA_BUSY.
+    */
+    if (pDataBuffer->seekToCursorOnNextRead) {
+        pDataBuffer->seekToCursorOnNextRead = MA_FALSE;
+
+        result = ma_data_source_seek_to_pcm_frame(ma_resource_manager_data_buffer_get_connector(pDataBuffer), pDataBuffer->seekTargetInPCMFrames);
+        if (result != MA_SUCCESS) {
+            if (result == MA_BAD_SEEK && ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode) == ma_resource_manager_data_supply_type_decoded_paged) {
+                pDataBuffer->seekToCursorOnNextRead = MA_TRUE;  /* Keep the seek scheduled. We just haven't loaded enough data yet to do the seek properly. */
+                return MA_BUSY;
+            }
+
+            return result;
+        }
+    }
+
+    /*
+    For decoded buffers (not paged) we need to check beforehand how many frames we have available. We cannot
+    exceed this amount. We'll read as much as we can, and then return MA_BUSY.
+    */
+    if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode) == ma_resource_manager_data_supply_type_decoded) {
+        ma_uint64 availableFrames;
+
+        isDecodedBufferBusy = (ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) == MA_BUSY);
+
+        if (ma_resource_manager_data_buffer_get_available_frames(pDataBuffer, &availableFrames) == MA_SUCCESS) {
+            /* Don't try reading more than the available frame count. */
+            if (frameCount > availableFrames) {
+                frameCount = availableFrames;
+
+                /*
+                If there's no frames available we want to set the status to MA_AT_END. The logic below
+                will check if the node is busy, and if so, change it to MA_BUSY. The reason we do this
+                is because we don't want to call `ma_data_source_read_pcm_frames()` if the frame count
+                is 0 because that'll result in a situation where it's possible MA_AT_END won't get
+                returned.
+                */
+                if (frameCount == 0) {
+                    result = MA_AT_END;
+                }
+            } else {
+                isDecodedBufferBusy = MA_FALSE; /* We have enough frames available in the buffer to avoid a MA_BUSY status. */
+            }
+        }
+    }
+
+    /* Don't attempt to read anything if we've got no frames available. */
+    if (frameCount > 0) {
+        result = ma_data_source_read_pcm_frames(ma_resource_manager_data_buffer_get_connector(pDataBuffer), pFramesOut, frameCount, &framesRead);
+    }
+
+    /*
+    If we returned MA_AT_END, but the node is still loading, we don't want to return that code or else the caller will interpret the sound
+    as at the end and terminate decoding.
+    */
+    if (result == MA_AT_END) {
+        if (ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) == MA_BUSY) {
+            result = MA_BUSY;
+        }
+    }
+
+    if (isDecodedBufferBusy) {
+        result = MA_BUSY;
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = framesRead;
+    }
+
+    if (result == MA_SUCCESS && framesRead == 0) {
+        result  = MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_seek_to_pcm_frame(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64 frameIndex)
+{
+    ma_result result;
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) != MA_UNAVAILABLE);
+
+    /* If we haven't yet got a connector we need to abort. */
+    if (ma_resource_manager_data_buffer_has_connector(pDataBuffer) == MA_FALSE) {
+        pDataBuffer->seekTargetInPCMFrames = frameIndex;
+        pDataBuffer->seekToCursorOnNextRead = MA_TRUE;
+        return MA_BUSY; /* Still loading. */
+    }
+
+    result = ma_data_source_seek_to_pcm_frame(ma_resource_manager_data_buffer_get_connector(pDataBuffer), frameIndex);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pDataBuffer->seekTargetInPCMFrames = ~(ma_uint64)0; /* <-- For identification purposes. */
+    pDataBuffer->seekToCursorOnNextRead = MA_FALSE;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_get_data_format(ma_resource_manager_data_buffer* pDataBuffer, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) != MA_UNAVAILABLE);
+
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode))
+    {
+        case ma_resource_manager_data_supply_type_encoded:
+        {
+            return ma_data_source_get_data_format(&pDataBuffer->connector.decoder, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+        };
+
+        case ma_resource_manager_data_supply_type_decoded:
+        {
+            *pFormat     = pDataBuffer->pNode->data.backend.decoded.format;
+            *pChannels   = pDataBuffer->pNode->data.backend.decoded.channels;
+            *pSampleRate = pDataBuffer->pNode->data.backend.decoded.sampleRate;
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pDataBuffer->pNode->data.backend.decoded.channels);
+            return MA_SUCCESS;
+        };
+
+        case ma_resource_manager_data_supply_type_decoded_paged:
+        {
+            *pFormat     = pDataBuffer->pNode->data.backend.decodedPaged.data.format;
+            *pChannels   = pDataBuffer->pNode->data.backend.decodedPaged.data.channels;
+            *pSampleRate = pDataBuffer->pNode->data.backend.decodedPaged.sampleRate;
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pDataBuffer->pNode->data.backend.decoded.channels);
+            return MA_SUCCESS;
+        };
+
+        case ma_resource_manager_data_supply_type_unknown:
+        {
+            return MA_BUSY; /* Still loading. */
+        };
+
+        default:
+        {
+            /* Unknown supply type. Should never hit this. */
+            return MA_INVALID_ARGS;
+        }
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_get_cursor_in_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pCursor)
+{
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) != MA_UNAVAILABLE);
+
+    if (pDataBuffer == NULL || pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode))
+    {
+        case ma_resource_manager_data_supply_type_encoded:
+        {
+            return ma_decoder_get_cursor_in_pcm_frames(&pDataBuffer->connector.decoder, pCursor);
+        };
+
+        case ma_resource_manager_data_supply_type_decoded:
+        {
+            return ma_audio_buffer_get_cursor_in_pcm_frames(&pDataBuffer->connector.buffer, pCursor);
+        };
+
+        case ma_resource_manager_data_supply_type_decoded_paged:
+        {
+            return ma_paged_audio_buffer_get_cursor_in_pcm_frames(&pDataBuffer->connector.pagedBuffer, pCursor);
+        };
+
+        case ma_resource_manager_data_supply_type_unknown:
+        {
+            return MA_BUSY;
+        };
+
+        default:
+        {
+            return MA_INVALID_ARGS;
+        }
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_get_length_in_pcm_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pLength)
+{
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) != MA_UNAVAILABLE);
+
+    if (pDataBuffer == NULL || pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode) == ma_resource_manager_data_supply_type_unknown) {
+        return MA_BUSY; /* Still loading. */
+    }
+
+    return ma_data_source_get_length_in_pcm_frames(ma_resource_manager_data_buffer_get_connector(pDataBuffer), pLength);
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_result(const ma_resource_manager_data_buffer* pDataBuffer)
+{
+    if (pDataBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return (ma_result)ma_atomic_load_i32((ma_result*)&pDataBuffer->result);    /* Need a naughty const-cast here. */
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_set_looping(ma_resource_manager_data_buffer* pDataBuffer, ma_bool32 isLooping)
+{
+    return ma_data_source_set_looping(pDataBuffer, isLooping);
+}
+
+MA_API ma_bool32 ma_resource_manager_data_buffer_is_looping(const ma_resource_manager_data_buffer* pDataBuffer)
+{
+    return ma_data_source_is_looping(pDataBuffer);
+}
+
+MA_API ma_result ma_resource_manager_data_buffer_get_available_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pAvailableFrames)
+{
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pDataBuffer == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode) == ma_resource_manager_data_supply_type_unknown) {
+        if (ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode) == MA_BUSY) {
+            return MA_BUSY;
+        } else {
+            return MA_INVALID_OPERATION;    /* No connector. */
+        }
+    }
+
+    switch (ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode))
+    {
+        case ma_resource_manager_data_supply_type_encoded:
+        {
+            return ma_decoder_get_available_frames(&pDataBuffer->connector.decoder, pAvailableFrames);
+        };
+
+        case ma_resource_manager_data_supply_type_decoded:
+        {
+            return ma_audio_buffer_get_available_frames(&pDataBuffer->connector.buffer, pAvailableFrames);
+        };
+
+        case ma_resource_manager_data_supply_type_decoded_paged:
+        {
+            ma_uint64 cursor;
+            ma_paged_audio_buffer_get_cursor_in_pcm_frames(&pDataBuffer->connector.pagedBuffer, &cursor);
+
+            if (pDataBuffer->pNode->data.backend.decodedPaged.decodedFrameCount > cursor) {
+                *pAvailableFrames = pDataBuffer->pNode->data.backend.decodedPaged.decodedFrameCount - cursor;
+            } else {
+                *pAvailableFrames = 0;
+            }
+
+            return MA_SUCCESS;
+        };
+
+        case ma_resource_manager_data_supply_type_unknown:
+        default:
+        {
+            /* Unknown supply type. Should never hit this. */
+            return MA_INVALID_ARGS;
+        }
+    }
+}
+
+MA_API ma_result ma_resource_manager_register_file(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags)
+{
+    return ma_resource_manager_data_buffer_node_acquire(pResourceManager, pFilePath, NULL, 0, flags, NULL, NULL, NULL, NULL);
+}
+
+MA_API ma_result ma_resource_manager_register_file_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags)
+{
+    return ma_resource_manager_data_buffer_node_acquire(pResourceManager, NULL, pFilePath, 0, flags, NULL, NULL, NULL, NULL);
+}
+
+
+static ma_result ma_resource_manager_register_data(ma_resource_manager* pResourceManager, const char* pName, const wchar_t* pNameW, ma_resource_manager_data_supply* pExistingData)
+{
+    return ma_resource_manager_data_buffer_node_acquire(pResourceManager, pName, pNameW, 0, 0, pExistingData, NULL, NULL, NULL);
+}
+
+static ma_result ma_resource_manager_register_decoded_data_internal(ma_resource_manager* pResourceManager, const char* pName, const wchar_t* pNameW, const void* pData, ma_uint64 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    ma_resource_manager_data_supply data;
+    data.type                            = ma_resource_manager_data_supply_type_decoded;
+    data.backend.decoded.pData           = pData;
+    data.backend.decoded.totalFrameCount = frameCount;
+    data.backend.decoded.format          = format;
+    data.backend.decoded.channels        = channels;
+    data.backend.decoded.sampleRate      = sampleRate;
+
+    return ma_resource_manager_register_data(pResourceManager, pName, pNameW, &data);
+}
+
+MA_API ma_result ma_resource_manager_register_decoded_data(ma_resource_manager* pResourceManager, const char* pName, const void* pData, ma_uint64 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    return ma_resource_manager_register_decoded_data_internal(pResourceManager, pName, NULL, pData, frameCount, format, channels, sampleRate);
+}
+
+MA_API ma_result ma_resource_manager_register_decoded_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName, const void* pData, ma_uint64 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    return ma_resource_manager_register_decoded_data_internal(pResourceManager, NULL, pName, pData, frameCount, format, channels, sampleRate);
+}
+
+
+static ma_result ma_resource_manager_register_encoded_data_internal(ma_resource_manager* pResourceManager, const char* pName, const wchar_t* pNameW, const void* pData, size_t sizeInBytes)
+{
+    ma_resource_manager_data_supply data;
+    data.type                        = ma_resource_manager_data_supply_type_encoded;
+    data.backend.encoded.pData       = pData;
+    data.backend.encoded.sizeInBytes = sizeInBytes;
+
+    return ma_resource_manager_register_data(pResourceManager, pName, pNameW, &data);
+}
+
+MA_API ma_result ma_resource_manager_register_encoded_data(ma_resource_manager* pResourceManager, const char* pName, const void* pData, size_t sizeInBytes)
+{
+    return ma_resource_manager_register_encoded_data_internal(pResourceManager, pName, NULL, pData, sizeInBytes);
+}
+
+MA_API ma_result ma_resource_manager_register_encoded_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName, const void* pData, size_t sizeInBytes)
+{
+    return ma_resource_manager_register_encoded_data_internal(pResourceManager, NULL, pName, pData, sizeInBytes);
+}
+
+
+MA_API ma_result ma_resource_manager_unregister_file(ma_resource_manager* pResourceManager, const char* pFilePath)
+{
+    return ma_resource_manager_unregister_data(pResourceManager, pFilePath);
+}
+
+MA_API ma_result ma_resource_manager_unregister_file_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath)
+{
+    return ma_resource_manager_unregister_data_w(pResourceManager, pFilePath);
+}
+
+MA_API ma_result ma_resource_manager_unregister_data(ma_resource_manager* pResourceManager, const char* pName)
+{
+    return ma_resource_manager_data_buffer_node_unacquire(pResourceManager, NULL, pName, NULL);
+}
+
+MA_API ma_result ma_resource_manager_unregister_data_w(ma_resource_manager* pResourceManager, const wchar_t* pName)
+{
+    return ma_resource_manager_data_buffer_node_unacquire(pResourceManager, NULL, NULL, pName);
+}
+
+
+static ma_uint32 ma_resource_manager_data_stream_next_execution_order(ma_resource_manager_data_stream* pDataStream)
+{
+    MA_ASSERT(pDataStream != NULL);
+    return ma_atomic_fetch_add_32(&pDataStream->executionCounter, 1);
+}
+
+static ma_bool32 ma_resource_manager_data_stream_is_decoder_at_end(const ma_resource_manager_data_stream* pDataStream)
+{
+    MA_ASSERT(pDataStream != NULL);
+    return ma_atomic_load_32((ma_bool32*)&pDataStream->isDecoderAtEnd);
+}
+
+static ma_uint32 ma_resource_manager_data_stream_seek_counter(const ma_resource_manager_data_stream* pDataStream)
+{
+    MA_ASSERT(pDataStream != NULL);
+    return ma_atomic_load_32((ma_uint32*)&pDataStream->seekCounter);
+}
+
+
+static ma_result ma_resource_manager_data_stream_cb__read_pcm_frames(ma_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    return ma_resource_manager_data_stream_read_pcm_frames((ma_resource_manager_data_stream*)pDataSource, pFramesOut, frameCount, pFramesRead);
+}
+
+static ma_result ma_resource_manager_data_stream_cb__seek_to_pcm_frame(ma_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    return ma_resource_manager_data_stream_seek_to_pcm_frame((ma_resource_manager_data_stream*)pDataSource, frameIndex);
+}
+
+static ma_result ma_resource_manager_data_stream_cb__get_data_format(ma_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    return ma_resource_manager_data_stream_get_data_format((ma_resource_manager_data_stream*)pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+static ma_result ma_resource_manager_data_stream_cb__get_cursor_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pCursor)
+{
+    return ma_resource_manager_data_stream_get_cursor_in_pcm_frames((ma_resource_manager_data_stream*)pDataSource, pCursor);
+}
+
+static ma_result ma_resource_manager_data_stream_cb__get_length_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pLength)
+{
+    return ma_resource_manager_data_stream_get_length_in_pcm_frames((ma_resource_manager_data_stream*)pDataSource, pLength);
+}
+
+static ma_result ma_resource_manager_data_stream_cb__set_looping(ma_data_source* pDataSource, ma_bool32 isLooping)
+{
+    ma_resource_manager_data_stream* pDataStream = (ma_resource_manager_data_stream*)pDataSource;
+    MA_ASSERT(pDataStream != NULL);
+
+    ma_atomic_exchange_32(&pDataStream->isLooping, isLooping);
+
+    return MA_SUCCESS;
+}
+
+static ma_data_source_vtable g_ma_resource_manager_data_stream_vtable =
+{
+    ma_resource_manager_data_stream_cb__read_pcm_frames,
+    ma_resource_manager_data_stream_cb__seek_to_pcm_frame,
+    ma_resource_manager_data_stream_cb__get_data_format,
+    ma_resource_manager_data_stream_cb__get_cursor_in_pcm_frames,
+    ma_resource_manager_data_stream_cb__get_length_in_pcm_frames,
+    ma_resource_manager_data_stream_cb__set_looping,
+    0 /*MA_DATA_SOURCE_SELF_MANAGED_RANGE_AND_LOOP_POINT*/
+};
+
+static void ma_resource_manager_data_stream_set_absolute_cursor(ma_resource_manager_data_stream* pDataStream, ma_uint64 absoluteCursor)
+{
+    /* Loop if possible. */
+    if (absoluteCursor > pDataStream->totalLengthInPCMFrames && pDataStream->totalLengthInPCMFrames > 0) {
+        absoluteCursor = absoluteCursor % pDataStream->totalLengthInPCMFrames;
+    }
+
+    ma_atomic_exchange_64(&pDataStream->absoluteCursor, absoluteCursor);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_stream* pDataStream)
+{
+    ma_result result;
+    ma_data_source_config dataSourceConfig;
+    char* pFilePathCopy = NULL;
+    wchar_t* pFilePathWCopy = NULL;
+    ma_job job;
+    ma_bool32 waitBeforeReturning = MA_FALSE;
+    ma_resource_manager_inline_notification waitNotification;
+    ma_resource_manager_pipeline_notifications notifications;
+
+    if (pDataStream == NULL) {
+        if (pConfig != NULL && pConfig->pNotifications != NULL) {
+            ma_resource_manager_pipeline_notifications_signal_all_notifications(pConfig->pNotifications);
+        }
+
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDataStream);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->pNotifications != NULL) {
+        notifications = *pConfig->pNotifications;    /* From here on out, `notifications` should be used instead of `pNotifications`. Setting this to NULL to catch any errors at testing time. */
+    } else {
+        MA_ZERO_OBJECT(&notifications);
+    }
+
+    dataSourceConfig = ma_data_source_config_init();
+    dataSourceConfig.vtable = &g_ma_resource_manager_data_stream_vtable;
+
+    result = ma_data_source_init(&dataSourceConfig, &pDataStream->ds);
+    if (result != MA_SUCCESS) {
+        ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+        return result;
+    }
+
+    pDataStream->pResourceManager = pResourceManager;
+    pDataStream->flags            = pConfig->flags;
+    pDataStream->result           = MA_BUSY;
+
+    ma_data_source_set_range_in_pcm_frames(pDataStream, pConfig->rangeBegInPCMFrames, pConfig->rangeEndInPCMFrames);
+    ma_data_source_set_loop_point_in_pcm_frames(pDataStream, pConfig->loopPointBegInPCMFrames, pConfig->loopPointEndInPCMFrames);
+    ma_data_source_set_looping(pDataStream, pConfig->isLooping);
+
+    if (pResourceManager == NULL || (pConfig->pFilePath == NULL && pConfig->pFilePathW == NULL)) {
+        ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+        return MA_INVALID_ARGS;
+    }
+
+    /* We want all access to the VFS and the internal decoder to happen on the job thread just to keep things easier to manage for the VFS.  */
+
+    /* We need a copy of the file path. We should probably make this more efficient, but for now we'll do a transient memory allocation. */
+    if (pConfig->pFilePath != NULL) {
+        pFilePathCopy  = ma_copy_string(pConfig->pFilePath, &pResourceManager->config.allocationCallbacks);
+    } else {
+        pFilePathWCopy = ma_copy_string_w(pConfig->pFilePathW, &pResourceManager->config.allocationCallbacks);
+    }
+
+    if (pFilePathCopy == NULL && pFilePathWCopy == NULL) {
+        ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+        return MA_OUT_OF_MEMORY;
+    }
+
+    /*
+    We need to check for the presence of MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC. If it's not set, we need to wait before returning. Otherwise we
+    can return immediately. Likewise, we'll also check for MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT and do the same.
+    */
+    if ((pConfig->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC) == 0 || (pConfig->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) {
+        waitBeforeReturning = MA_TRUE;
+        ma_resource_manager_inline_notification_init(pResourceManager, &waitNotification);
+    }
+
+    ma_resource_manager_pipeline_notifications_acquire_all_fences(&notifications);
+
+    /* Set the absolute cursor to our initial seek position so retrieval of the cursor returns a good value. */
+    ma_resource_manager_data_stream_set_absolute_cursor(pDataStream, pConfig->initialSeekPointInPCMFrames);
+
+    /* We now have everything we need to post the job. This is the last thing we need to do from here. The rest will be done by the job thread. */
+    job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_STREAM);
+    job.order = ma_resource_manager_data_stream_next_execution_order(pDataStream);
+    job.data.resourceManager.loadDataStream.pDataStream       = pDataStream;
+    job.data.resourceManager.loadDataStream.pFilePath         = pFilePathCopy;
+    job.data.resourceManager.loadDataStream.pFilePathW        = pFilePathWCopy;
+    job.data.resourceManager.loadDataStream.initialSeekPoint  = pConfig->initialSeekPointInPCMFrames;
+    job.data.resourceManager.loadDataStream.pInitNotification = (waitBeforeReturning == MA_TRUE) ? &waitNotification : notifications.init.pNotification;
+    job.data.resourceManager.loadDataStream.pInitFence        = notifications.init.pFence;
+    result = ma_resource_manager_post_job(pResourceManager, &job);
+    if (result != MA_SUCCESS) {
+        ma_resource_manager_pipeline_notifications_signal_all_notifications(&notifications);
+        ma_resource_manager_pipeline_notifications_release_all_fences(&notifications);
+
+        if (waitBeforeReturning) {
+            ma_resource_manager_inline_notification_uninit(&waitNotification);
+        }
+
+        ma_free(pFilePathCopy,  &pResourceManager->config.allocationCallbacks);
+        ma_free(pFilePathWCopy, &pResourceManager->config.allocationCallbacks);
+        return result;
+    }
+
+    /* Wait if needed. */
+    if (waitBeforeReturning) {
+        ma_resource_manager_inline_notification_wait_and_uninit(&waitNotification);
+
+        if (notifications.init.pNotification != NULL) {
+            ma_async_notification_signal(notifications.init.pNotification);
+        }
+
+        /*
+        If there was an error during initialization make sure we return that result here. We don't want to do this
+        if we're not waiting because it will most likely be in a busy state.
+        */
+        if (pDataStream->result != MA_SUCCESS) {
+            return pDataStream->result;
+        }
+
+        /* NOTE: Do not release pInitFence here. That will be done by the job. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_stream_init(ma_resource_manager* pResourceManager, const char* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_stream* pDataStream)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePath      = pFilePath;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_stream_init_ex(pResourceManager, &config, pDataStream);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_init_w(ma_resource_manager* pResourceManager, const wchar_t* pFilePath, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_stream* pDataStream)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePathW     = pFilePath;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_stream_init_ex(pResourceManager, &config, pDataStream);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_uninit(ma_resource_manager_data_stream* pDataStream)
+{
+    ma_resource_manager_inline_notification freeEvent;
+    ma_job job;
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The first thing to do is set the result to unavailable. This will prevent future page decoding. */
+    ma_atomic_exchange_i32(&pDataStream->result, MA_UNAVAILABLE);
+
+    /*
+    We need to post a job to ensure we're not in the middle or decoding or anything. Because the object is owned by the caller, we'll need
+    to wait for it to complete before returning which means we need an event.
+    */
+    ma_resource_manager_inline_notification_init(pDataStream->pResourceManager, &freeEvent);
+
+    job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_STREAM);
+    job.order = ma_resource_manager_data_stream_next_execution_order(pDataStream);
+    job.data.resourceManager.freeDataStream.pDataStream       = pDataStream;
+    job.data.resourceManager.freeDataStream.pDoneNotification = &freeEvent;
+    job.data.resourceManager.freeDataStream.pDoneFence        = NULL;
+    ma_resource_manager_post_job(pDataStream->pResourceManager, &job);
+
+    /* We need to wait for the job to finish processing before we return. */
+    ma_resource_manager_inline_notification_wait_and_uninit(&freeEvent);
+
+    return MA_SUCCESS;
+}
+
+
+static ma_uint32 ma_resource_manager_data_stream_get_page_size_in_frames(ma_resource_manager_data_stream* pDataStream)
+{
+    MA_ASSERT(pDataStream != NULL);
+    MA_ASSERT(pDataStream->isDecoderInitialized == MA_TRUE);
+
+    return MA_RESOURCE_MANAGER_PAGE_SIZE_IN_MILLISECONDS * (pDataStream->decoder.outputSampleRate/1000);
+}
+
+static void* ma_resource_manager_data_stream_get_page_data_pointer(ma_resource_manager_data_stream* pDataStream, ma_uint32 pageIndex, ma_uint32 relativeCursor)
+{
+    MA_ASSERT(pDataStream != NULL);
+    MA_ASSERT(pDataStream->isDecoderInitialized == MA_TRUE);
+    MA_ASSERT(pageIndex == 0 || pageIndex == 1);
+
+    return ma_offset_ptr(pDataStream->pPageData, ((ma_resource_manager_data_stream_get_page_size_in_frames(pDataStream) * pageIndex) + relativeCursor) * ma_get_bytes_per_frame(pDataStream->decoder.outputFormat, pDataStream->decoder.outputChannels));
+}
+
+static void ma_resource_manager_data_stream_fill_page(ma_resource_manager_data_stream* pDataStream, ma_uint32 pageIndex)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 pageSizeInFrames;
+    ma_uint64 totalFramesReadForThisPage = 0;
+    void* pPageData = ma_resource_manager_data_stream_get_page_data_pointer(pDataStream, pageIndex, 0);
+
+    pageSizeInFrames = ma_resource_manager_data_stream_get_page_size_in_frames(pDataStream);
+
+    /* The decoder needs to inherit the stream's looping and range state. */
+    {
+        ma_uint64 rangeBeg;
+        ma_uint64 rangeEnd;
+        ma_uint64 loopPointBeg;
+        ma_uint64 loopPointEnd;
+
+        ma_data_source_set_looping(&pDataStream->decoder, ma_resource_manager_data_stream_is_looping(pDataStream));
+
+        ma_data_source_get_range_in_pcm_frames(pDataStream, &rangeBeg, &rangeEnd);
+        ma_data_source_set_range_in_pcm_frames(&pDataStream->decoder, rangeBeg, rangeEnd);
+
+        ma_data_source_get_loop_point_in_pcm_frames(pDataStream, &loopPointBeg, &loopPointEnd);
+        ma_data_source_set_loop_point_in_pcm_frames(&pDataStream->decoder, loopPointBeg, loopPointEnd);
+    }
+
+    /* Just read straight from the decoder. It will deal with ranges and looping for us. */
+    result = ma_data_source_read_pcm_frames(&pDataStream->decoder, pPageData, pageSizeInFrames, &totalFramesReadForThisPage);
+    if (result == MA_AT_END || totalFramesReadForThisPage < pageSizeInFrames) {
+        ma_atomic_exchange_32(&pDataStream->isDecoderAtEnd, MA_TRUE);
+    }
+
+    ma_atomic_exchange_32(&pDataStream->pageFrameCount[pageIndex], (ma_uint32)totalFramesReadForThisPage);
+    ma_atomic_exchange_32(&pDataStream->isPageValid[pageIndex], MA_TRUE);
+}
+
+static void ma_resource_manager_data_stream_fill_pages(ma_resource_manager_data_stream* pDataStream)
+{
+    ma_uint32 iPage;
+
+    MA_ASSERT(pDataStream != NULL);
+
+    for (iPage = 0; iPage < 2; iPage += 1) {
+        ma_resource_manager_data_stream_fill_page(pDataStream, iPage);
+    }
+}
+
+
+static ma_result ma_resource_manager_data_stream_map(ma_resource_manager_data_stream* pDataStream, void** ppFramesOut, ma_uint64* pFrameCount)
+{
+    ma_uint64 framesAvailable;
+    ma_uint64 frameCount = 0;
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) != MA_UNAVAILABLE);
+
+    if (pFrameCount != NULL) {
+        frameCount = *pFrameCount;
+        *pFrameCount = 0;
+    }
+    if (ppFramesOut != NULL) {
+        *ppFramesOut = NULL;
+    }
+
+    if (pDataStream == NULL || ppFramesOut == NULL || pFrameCount == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* Don't attempt to read while we're in the middle of seeking. Tell the caller that we're busy. */
+    if (ma_resource_manager_data_stream_seek_counter(pDataStream) > 0) {
+        return MA_BUSY;
+    }
+
+    /* If the page we're on is invalid it means we've caught up to the job thread. */
+    if (ma_atomic_load_32(&pDataStream->isPageValid[pDataStream->currentPageIndex]) == MA_FALSE) {
+        framesAvailable = 0;
+    } else {
+        /*
+        The page we're on is valid so we must have some frames available. We need to make sure that we don't overflow into the next page, even if it's valid. The reason is
+        that the unmap process will only post an update for one page at a time. Keeping mapping tied to page boundaries makes this simpler.
+        */
+        ma_uint32 currentPageFrameCount = ma_atomic_load_32(&pDataStream->pageFrameCount[pDataStream->currentPageIndex]);
+        MA_ASSERT(currentPageFrameCount >= pDataStream->relativeCursor);
+
+        framesAvailable = currentPageFrameCount - pDataStream->relativeCursor;
+    }
+
+    /* If there's no frames available and the result is set to MA_AT_END we need to return MA_AT_END. */
+    if (framesAvailable == 0) {
+        if (ma_resource_manager_data_stream_is_decoder_at_end(pDataStream)) {
+            return MA_AT_END;
+        } else {
+            return MA_BUSY; /* There are no frames available, but we're not marked as EOF so we might have caught up to the job thread. Need to return MA_BUSY and wait for more data. */
+        }
+    }
+
+    MA_ASSERT(framesAvailable > 0);
+
+    if (frameCount > framesAvailable) {
+        frameCount = framesAvailable;
+    }
+
+    *ppFramesOut = ma_resource_manager_data_stream_get_page_data_pointer(pDataStream, pDataStream->currentPageIndex, pDataStream->relativeCursor);
+    *pFrameCount = frameCount;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_resource_manager_data_stream_unmap(ma_resource_manager_data_stream* pDataStream, ma_uint64 frameCount)
+{
+    ma_uint32 newRelativeCursor;
+    ma_uint32 pageSizeInFrames;
+    ma_job job;
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) != MA_UNAVAILABLE);
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* The frame count should always fit inside a 32-bit integer. */
+    if (frameCount > 0xFFFFFFFF) {
+        return MA_INVALID_ARGS;
+    }
+
+    pageSizeInFrames = ma_resource_manager_data_stream_get_page_size_in_frames(pDataStream);
+
+    /* The absolute cursor needs to be updated for ma_resource_manager_data_stream_get_cursor_in_pcm_frames(). */
+    ma_resource_manager_data_stream_set_absolute_cursor(pDataStream, ma_atomic_load_64(&pDataStream->absoluteCursor) + frameCount);
+
+    /* Here is where we need to check if we need to load a new page, and if so, post a job to load it. */
+    newRelativeCursor = pDataStream->relativeCursor + (ma_uint32)frameCount;
+
+    /* If the new cursor has flowed over to the next page we need to mark the old one as invalid and post an event for it. */
+    if (newRelativeCursor >= pageSizeInFrames) {
+        newRelativeCursor -= pageSizeInFrames;
+
+        /* Here is where we post the job start decoding. */
+        job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_STREAM);
+        job.order = ma_resource_manager_data_stream_next_execution_order(pDataStream);
+        job.data.resourceManager.pageDataStream.pDataStream = pDataStream;
+        job.data.resourceManager.pageDataStream.pageIndex   = pDataStream->currentPageIndex;
+
+        /* The page needs to be marked as invalid so that the public API doesn't try reading from it. */
+        ma_atomic_exchange_32(&pDataStream->isPageValid[pDataStream->currentPageIndex], MA_FALSE);
+
+        /* Before posting the job we need to make sure we set some state. */
+        pDataStream->relativeCursor   = newRelativeCursor;
+        pDataStream->currentPageIndex = (pDataStream->currentPageIndex + 1) & 0x01;
+        return ma_resource_manager_post_job(pDataStream->pResourceManager, &job);
+    } else {
+        /* We haven't moved into a new page so we can just move the cursor forward. */
+        pDataStream->relativeCursor = newRelativeCursor;
+        return MA_SUCCESS;
+    }
+}
+
+
+MA_API ma_result ma_resource_manager_data_stream_read_pcm_frames(ma_resource_manager_data_stream* pDataStream, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 totalFramesProcessed;
+    ma_format format;
+    ma_uint32 channels;
+
+    /* Safety. */
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (frameCount == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) != MA_UNAVAILABLE);
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* Don't attempt to read while we're in the middle of seeking. Tell the caller that we're busy. */
+    if (ma_resource_manager_data_stream_seek_counter(pDataStream) > 0) {
+        return MA_BUSY;
+    }
+
+    ma_resource_manager_data_stream_get_data_format(pDataStream, &format, &channels, NULL, NULL, 0);
+
+    /* Reading is implemented in terms of map/unmap. We need to run this in a loop because mapping is clamped against page boundaries. */
+    totalFramesProcessed = 0;
+    while (totalFramesProcessed < frameCount) {
+        void* pMappedFrames;
+        ma_uint64 mappedFrameCount;
+
+        mappedFrameCount = frameCount - totalFramesProcessed;
+        result = ma_resource_manager_data_stream_map(pDataStream, &pMappedFrames, &mappedFrameCount);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        /* Copy the mapped data to the output buffer if we have one. It's allowed for pFramesOut to be NULL in which case a relative forward seek is performed. */
+        if (pFramesOut != NULL) {
+            ma_copy_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, totalFramesProcessed, format, channels), pMappedFrames, mappedFrameCount, format, channels);
+        }
+
+        totalFramesProcessed += mappedFrameCount;
+
+        result = ma_resource_manager_data_stream_unmap(pDataStream, mappedFrameCount);
+        if (result != MA_SUCCESS) {
+            break;  /* This is really bad - will only get an error here if we failed to post a job to the queue for loading the next page. */
+        }
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesProcessed;
+    }
+
+    if (result == MA_SUCCESS && totalFramesProcessed == 0) {
+        result  = MA_AT_END;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_resource_manager_data_stream_seek_to_pcm_frame(ma_resource_manager_data_stream* pDataStream, ma_uint64 frameIndex)
+{
+    ma_job job;
+    ma_result streamResult;
+
+    streamResult = ma_resource_manager_data_stream_result(pDataStream);
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(streamResult != MA_UNAVAILABLE);
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (streamResult != MA_SUCCESS && streamResult != MA_BUSY) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* If we're not already seeking and we're sitting on the same frame, just make this a no-op. */
+    if (ma_atomic_load_32(&pDataStream->seekCounter) == 0) {
+        if (ma_atomic_load_64(&pDataStream->absoluteCursor) == frameIndex) {
+            return MA_SUCCESS;
+        }
+    }
+
+
+    /* Increment the seek counter first to indicate to read_paged_pcm_frames() and map_paged_pcm_frames() that we are in the middle of a seek and MA_BUSY should be returned. */
+    ma_atomic_fetch_add_32(&pDataStream->seekCounter, 1);
+
+    /* Update the absolute cursor so that ma_resource_manager_data_stream_get_cursor_in_pcm_frames() returns the new position. */
+    ma_resource_manager_data_stream_set_absolute_cursor(pDataStream, frameIndex);
+
+    /*
+    We need to clear our currently loaded pages so that the stream starts playback from the new seek point as soon as possible. These are for the purpose of the public
+    API and will be ignored by the seek job. The seek job will operate on the assumption that both pages have been marked as invalid and the cursor is at the start of
+    the first page.
+    */
+    pDataStream->relativeCursor   = 0;
+    pDataStream->currentPageIndex = 0;
+    ma_atomic_exchange_32(&pDataStream->isPageValid[0], MA_FALSE);
+    ma_atomic_exchange_32(&pDataStream->isPageValid[1], MA_FALSE);
+
+    /* Make sure the data stream is not marked as at the end or else if we seek in response to hitting the end, we won't be able to read any more data. */
+    ma_atomic_exchange_32(&pDataStream->isDecoderAtEnd, MA_FALSE);
+
+    /*
+    The public API is not allowed to touch the internal decoder so we need to use a job to perform the seek. When seeking, the job thread will assume both pages
+    are invalid and any content contained within them will be discarded and replaced with newly decoded data.
+    */
+    job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_SEEK_DATA_STREAM);
+    job.order = ma_resource_manager_data_stream_next_execution_order(pDataStream);
+    job.data.resourceManager.seekDataStream.pDataStream = pDataStream;
+    job.data.resourceManager.seekDataStream.frameIndex  = frameIndex;
+    return ma_resource_manager_post_job(pDataStream->pResourceManager, &job);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_get_data_format(ma_resource_manager_data_stream* pDataStream, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) != MA_UNAVAILABLE);
+
+    if (pFormat != NULL) {
+        *pFormat = ma_format_unknown;
+    }
+
+    if (pChannels != NULL) {
+        *pChannels = 0;
+    }
+
+    if (pSampleRate != NULL) {
+        *pSampleRate = 0;
+    }
+
+    if (pChannelMap != NULL) {
+        MA_ZERO_MEMORY(pChannelMap, sizeof(*pChannelMap) * channelMapCap);
+    }
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /*
+    We're being a little bit naughty here and accessing the internal decoder from the public API. The output data format is constant, and we've defined this function
+    such that the application is responsible for ensuring it's not called while uninitializing so it should be safe.
+    */
+    return ma_data_source_get_data_format(&pDataStream->decoder, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_get_cursor_in_pcm_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pCursor)
+{
+    ma_result result;
+
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pCursor = 0;
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) != MA_UNAVAILABLE);
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    If the stream is in an erroneous state we need to return an invalid operation. We can allow
+    this to be called when the data stream is in a busy state because the caller may have asked
+    for an initial seek position and it's convenient to return that as the cursor position.
+    */
+    result = ma_resource_manager_data_stream_result(pDataStream);
+    if (result != MA_SUCCESS && result != MA_BUSY) {
+        return MA_INVALID_OPERATION;
+    }
+
+    *pCursor = ma_atomic_load_64(&pDataStream->absoluteCursor);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_stream_get_length_in_pcm_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pLength)
+{
+    ma_result streamResult;
+
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pLength = 0;
+
+    streamResult = ma_resource_manager_data_stream_result(pDataStream);
+
+    /* We cannot be using the data source after it's been uninitialized. */
+    MA_ASSERT(streamResult != MA_UNAVAILABLE);
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (streamResult != MA_SUCCESS) {
+        return streamResult;
+    }
+
+    /*
+    We most definitely do not want to be calling ma_decoder_get_length_in_pcm_frames() directly. Instead we want to use a cached value that we
+    calculated when we initialized it on the job thread.
+    */
+    *pLength = pDataStream->totalLengthInPCMFrames;
+    if (*pLength == 0) {
+        return MA_NOT_IMPLEMENTED;  /* Some decoders may not have a known length. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_stream_result(const ma_resource_manager_data_stream* pDataStream)
+{
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return (ma_result)ma_atomic_load_i32(&pDataStream->result);
+}
+
+MA_API ma_result ma_resource_manager_data_stream_set_looping(ma_resource_manager_data_stream* pDataStream, ma_bool32 isLooping)
+{
+    return ma_data_source_set_looping(pDataStream, isLooping);
+}
+
+MA_API ma_bool32 ma_resource_manager_data_stream_is_looping(const ma_resource_manager_data_stream* pDataStream)
+{
+    if (pDataStream == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_atomic_load_32((ma_bool32*)&pDataStream->isLooping);   /* Naughty const-cast. Value won't change from here in practice (maybe from another thread). */
+}
+
+MA_API ma_result ma_resource_manager_data_stream_get_available_frames(ma_resource_manager_data_stream* pDataStream, ma_uint64* pAvailableFrames)
+{
+    ma_uint32 pageIndex0;
+    ma_uint32 pageIndex1;
+    ma_uint32 relativeCursor;
+    ma_uint64 availableFrames;
+
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pDataStream == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pageIndex0     =  pDataStream->currentPageIndex;
+    pageIndex1     = (pDataStream->currentPageIndex + 1) & 0x01;
+    relativeCursor =  pDataStream->relativeCursor;
+
+    availableFrames = 0;
+    if (ma_atomic_load_32(&pDataStream->isPageValid[pageIndex0])) {
+        availableFrames += ma_atomic_load_32(&pDataStream->pageFrameCount[pageIndex0]) - relativeCursor;
+        if (ma_atomic_load_32(&pDataStream->isPageValid[pageIndex1])) {
+            availableFrames += ma_atomic_load_32(&pDataStream->pageFrameCount[pageIndex1]);
+        }
+    }
+
+    *pAvailableFrames = availableFrames;
+    return MA_SUCCESS;
+}
+
+
+static ma_result ma_resource_manager_data_source_preinit(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_source* pDataSource)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDataSource);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pDataSource->flags = pConfig->flags;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_resource_manager_data_source_init_ex(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source_config* pConfig, ma_resource_manager_data_source* pDataSource)
+{
+    ma_result result;
+
+    result = ma_resource_manager_data_source_preinit(pResourceManager, pConfig, pDataSource);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* The data source itself is just a data stream or a data buffer. */
+    if ((pConfig->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_init_ex(pResourceManager, pConfig, &pDataSource->backend.stream);
+    } else {
+        return ma_resource_manager_data_buffer_init_ex(pResourceManager, pConfig, &pDataSource->backend.buffer);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_init(ma_resource_manager* pResourceManager, const char* pName, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_source* pDataSource)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePath      = pName;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_source_init_ex(pResourceManager, &config, pDataSource);
+}
+
+MA_API ma_result ma_resource_manager_data_source_init_w(ma_resource_manager* pResourceManager, const wchar_t* pName, ma_uint32 flags, const ma_resource_manager_pipeline_notifications* pNotifications, ma_resource_manager_data_source* pDataSource)
+{
+    ma_resource_manager_data_source_config config;
+
+    config = ma_resource_manager_data_source_config_init();
+    config.pFilePathW     = pName;
+    config.flags          = flags;
+    config.pNotifications = pNotifications;
+
+    return ma_resource_manager_data_source_init_ex(pResourceManager, &config, pDataSource);
+}
+
+MA_API ma_result ma_resource_manager_data_source_init_copy(ma_resource_manager* pResourceManager, const ma_resource_manager_data_source* pExistingDataSource, ma_resource_manager_data_source* pDataSource)
+{
+    ma_result result;
+    ma_resource_manager_data_source_config config;
+
+    if (pExistingDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    config = ma_resource_manager_data_source_config_init();
+    config.flags = pExistingDataSource->flags;
+
+    result = ma_resource_manager_data_source_preinit(pResourceManager, &config, pDataSource);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Copying can only be done from data buffers. Streams cannot be copied. */
+    if ((pExistingDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return MA_INVALID_OPERATION;
+    }
+
+    return ma_resource_manager_data_buffer_init_copy(pResourceManager, &pExistingDataSource->backend.buffer, &pDataSource->backend.buffer);
+}
+
+MA_API ma_result ma_resource_manager_data_source_uninit(ma_resource_manager_data_source* pDataSource)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* All we need to is uninitialize the underlying data buffer or data stream. */
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_uninit(&pDataSource->backend.stream);
+    } else {
+        return ma_resource_manager_data_buffer_uninit(&pDataSource->backend.buffer);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_read_pcm_frames(ma_resource_manager_data_source* pDataSource, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    /* Safety. */
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_read_pcm_frames(&pDataSource->backend.stream, pFramesOut, frameCount, pFramesRead);
+    } else {
+        return ma_resource_manager_data_buffer_read_pcm_frames(&pDataSource->backend.buffer, pFramesOut, frameCount, pFramesRead);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_seek_to_pcm_frame(ma_resource_manager_data_source* pDataSource, ma_uint64 frameIndex)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_seek_to_pcm_frame(&pDataSource->backend.stream, frameIndex);
+    } else {
+        return ma_resource_manager_data_buffer_seek_to_pcm_frame(&pDataSource->backend.buffer, frameIndex);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_map(ma_resource_manager_data_source* pDataSource, void** ppFramesOut, ma_uint64* pFrameCount)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_map(&pDataSource->backend.stream, ppFramesOut, pFrameCount);
+    } else {
+        return MA_NOT_IMPLEMENTED;  /* Mapping not supported with data buffers. */
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_unmap(ma_resource_manager_data_source* pDataSource, ma_uint64 frameCount)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_unmap(&pDataSource->backend.stream, frameCount);
+    } else {
+        return MA_NOT_IMPLEMENTED;  /* Mapping not supported with data buffers. */
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_get_data_format(ma_resource_manager_data_source* pDataSource, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_get_data_format(&pDataSource->backend.stream, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+    } else {
+        return ma_resource_manager_data_buffer_get_data_format(&pDataSource->backend.buffer, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_get_cursor_in_pcm_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pCursor)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_get_cursor_in_pcm_frames(&pDataSource->backend.stream, pCursor);
+    } else {
+        return ma_resource_manager_data_buffer_get_cursor_in_pcm_frames(&pDataSource->backend.buffer, pCursor);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_get_length_in_pcm_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pLength)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_get_length_in_pcm_frames(&pDataSource->backend.stream, pLength);
+    } else {
+        return ma_resource_manager_data_buffer_get_length_in_pcm_frames(&pDataSource->backend.buffer, pLength);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_result(const ma_resource_manager_data_source* pDataSource)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_result(&pDataSource->backend.stream);
+    } else {
+        return ma_resource_manager_data_buffer_result(&pDataSource->backend.buffer);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_set_looping(ma_resource_manager_data_source* pDataSource, ma_bool32 isLooping)
+{
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_set_looping(&pDataSource->backend.stream, isLooping);
+    } else {
+        return ma_resource_manager_data_buffer_set_looping(&pDataSource->backend.buffer, isLooping);
+    }
+}
+
+MA_API ma_bool32 ma_resource_manager_data_source_is_looping(const ma_resource_manager_data_source* pDataSource)
+{
+    if (pDataSource == NULL) {
+        return MA_FALSE;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_is_looping(&pDataSource->backend.stream);
+    } else {
+        return ma_resource_manager_data_buffer_is_looping(&pDataSource->backend.buffer);
+    }
+}
+
+MA_API ma_result ma_resource_manager_data_source_get_available_frames(ma_resource_manager_data_source* pDataSource, ma_uint64* pAvailableFrames)
+{
+    if (pAvailableFrames == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pAvailableFrames = 0;
+
+    if (pDataSource == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if ((pDataSource->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM) != 0) {
+        return ma_resource_manager_data_stream_get_available_frames(&pDataSource->backend.stream, pAvailableFrames);
+    } else {
+        return ma_resource_manager_data_buffer_get_available_frames(&pDataSource->backend.buffer, pAvailableFrames);
+    }
+}
+
+
+MA_API ma_result ma_resource_manager_post_job(ma_resource_manager* pResourceManager, const ma_job* pJob)
+{
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_job_queue_post(&pResourceManager->jobQueue, pJob);
+}
+
+MA_API ma_result ma_resource_manager_post_job_quit(ma_resource_manager* pResourceManager)
+{
+    ma_job job = ma_job_init(MA_JOB_TYPE_QUIT);
+    return ma_resource_manager_post_job(pResourceManager, &job);
+}
+
+MA_API ma_result ma_resource_manager_next_job(ma_resource_manager* pResourceManager, ma_job* pJob)
+{
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_job_queue_next(&pResourceManager->jobQueue, pJob);
+}
+
+
+static ma_result ma_job_process__resource_manager__load_data_buffer_node(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_buffer_node* pDataBufferNode;
+
+    MA_ASSERT(pJob != NULL);
+
+    pResourceManager = (ma_resource_manager*)pJob->data.resourceManager.loadDataBufferNode.pResourceManager;
+    MA_ASSERT(pResourceManager != NULL);
+
+    pDataBufferNode = (ma_resource_manager_data_buffer_node*)pJob->data.resourceManager.loadDataBufferNode.pDataBufferNode;
+    MA_ASSERT(pDataBufferNode != NULL);
+    MA_ASSERT(pDataBufferNode->isDataOwnedByResourceManager == MA_TRUE);  /* The data should always be owned by the resource manager. */
+
+    /* The data buffer is not getting deleted, but we may be getting executed out of order. If so, we need to push the job back onto the queue and return. */
+    if (pJob->order != ma_atomic_load_32(&pDataBufferNode->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Attempting to execute out of order. Probably interleaved with a MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER job. */
+    }
+
+    /* First thing we need to do is check whether or not the data buffer is getting deleted. If so we just abort. */
+    if (ma_resource_manager_data_buffer_node_result(pDataBufferNode) != MA_BUSY) {
+        result = ma_resource_manager_data_buffer_node_result(pDataBufferNode);    /* The data buffer may be getting deleted before it's even been loaded. */
+        goto done;
+    }
+
+    /*
+    We're ready to start loading. Essentially what we're doing here is initializing the data supply
+    of the node. Once this is complete, data buffers can have their connectors initialized which
+    will allow then to have audio data read from them.
+
+    Note that when the data supply type has been moved away from "unknown", that is when other threads
+    will determine that the node is available for data delivery and the data buffer connectors can be
+    initialized. Therefore, it's important that it is set after the data supply has been initialized.
+    */
+    if ((pJob->data.resourceManager.loadDataBufferNode.flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE) != 0) {
+        /*
+        Decoding. This is the complex case because we're not going to be doing the entire decoding
+        process here. Instead it's going to be split of multiple jobs and loaded in pages. The
+        reason for this is to evenly distribute decoding time across multiple sounds, rather than
+        having one huge sound hog all the available processing resources.
+
+        The first thing we do is initialize a decoder. This is allocated on the heap and is passed
+        around to the paging jobs. When the last paging job has completed it's processing, it'll
+        free the decoder for us.
+
+        This job does not do any actual decoding. It instead just posts a PAGE_DATA_BUFFER_NODE job
+        which is where the actual decoding work will be done. However, once this job is complete,
+        the node will be in a state where data buffer connectors can be initialized.
+        */
+        ma_decoder* pDecoder;   /* <-- Free'd on the last page decode. */
+        ma_job pageDataBufferNodeJob;
+
+        /* Allocate the decoder by initializing a decoded data supply. */
+        result = ma_resource_manager_data_buffer_node_init_supply_decoded(pResourceManager, pDataBufferNode, pJob->data.resourceManager.loadDataBufferNode.pFilePath, pJob->data.resourceManager.loadDataBufferNode.pFilePathW, pJob->data.resourceManager.loadDataBufferNode.flags, &pDecoder);
+
+        /*
+        Don't ever propagate an MA_BUSY result code or else the resource manager will think the
+        node is just busy decoding rather than in an error state. This should never happen, but
+        including this logic for safety just in case.
+        */
+        if (result == MA_BUSY) {
+            result  = MA_ERROR;
+        }
+
+        if (result != MA_SUCCESS) {
+            if (pJob->data.resourceManager.loadDataBufferNode.pFilePath != NULL) {
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to initialize data supply for \"%s\". %s.\n", pJob->data.resourceManager.loadDataBufferNode.pFilePath, ma_result_description(result));
+            } else {
+                #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(_MSC_VER)
+                    ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_WARNING, "Failed to initialize data supply for \"%ls\", %s.\n", pJob->data.resourceManager.loadDataBufferNode.pFilePathW, ma_result_description(result));
+                #endif
+            }
+
+            goto done;
+        }
+
+        /*
+        At this point the node's data supply is initialized and other threads can start initializing
+        their data buffer connectors. However, no data will actually be available until we start to
+        actually decode it. To do this, we need to post a paging job which is where the decoding
+        work is done.
+
+        Note that if an error occurred at an earlier point, this section will have been skipped.
+        */
+        pageDataBufferNodeJob = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE);
+        pageDataBufferNodeJob.order = ma_resource_manager_data_buffer_node_next_execution_order(pDataBufferNode);
+        pageDataBufferNodeJob.data.resourceManager.pageDataBufferNode.pResourceManager  = pResourceManager;
+        pageDataBufferNodeJob.data.resourceManager.pageDataBufferNode.pDataBufferNode   = pDataBufferNode;
+        pageDataBufferNodeJob.data.resourceManager.pageDataBufferNode.pDecoder          = pDecoder;
+        pageDataBufferNodeJob.data.resourceManager.pageDataBufferNode.pDoneNotification = pJob->data.resourceManager.loadDataBufferNode.pDoneNotification;
+        pageDataBufferNodeJob.data.resourceManager.pageDataBufferNode.pDoneFence        = pJob->data.resourceManager.loadDataBufferNode.pDoneFence;
+
+        /* The job has been set up so it can now be posted. */
+        result = ma_resource_manager_post_job(pResourceManager, &pageDataBufferNodeJob);
+
+        /*
+        When we get here, we want to make sure the result code is set to MA_BUSY. The reason for
+        this is that the result will be copied over to the node's internal result variable. In
+        this case, since the decoding is still in-progress, we need to make sure the result code
+        is set to MA_BUSY.
+        */
+        if (result != MA_SUCCESS) {
+            ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to post MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE job. %s\n", ma_result_description(result));
+            ma_decoder_uninit(pDecoder);
+            ma_free(pDecoder, &pResourceManager->config.allocationCallbacks);
+        } else {
+            result = MA_BUSY;
+        }
+    } else {
+        /* No decoding. This is the simple case. We need only read the file content into memory and we're done. */
+        result = ma_resource_manager_data_buffer_node_init_supply_encoded(pResourceManager, pDataBufferNode, pJob->data.resourceManager.loadDataBufferNode.pFilePath, pJob->data.resourceManager.loadDataBufferNode.pFilePathW);
+    }
+
+
+done:
+    /* File paths are no longer needed. */
+    ma_free(pJob->data.resourceManager.loadDataBufferNode.pFilePath,  &pResourceManager->config.allocationCallbacks);
+    ma_free(pJob->data.resourceManager.loadDataBufferNode.pFilePathW, &pResourceManager->config.allocationCallbacks);
+
+    /*
+    We need to set the result to at the very end to ensure no other threads try reading the data before we've fully initialized the object. Other threads
+    are going to be inspecting this variable to determine whether or not they're ready to read data. We can only change the result if it's set to MA_BUSY
+    because otherwise we may be changing away from an error code which would be bad. An example is if the application creates a data buffer, but then
+    immediately deletes it before we've got to this point. In this case, pDataBuffer->result will be MA_UNAVAILABLE, and setting it to MA_SUCCESS or any
+    other error code would cause the buffer to look like it's in a state that it's not.
+    */
+    ma_atomic_compare_and_swap_i32(&pDataBufferNode->result, MA_BUSY, result);
+
+    /* At this point initialization is complete and we can signal the notification if any. */
+    if (pJob->data.resourceManager.loadDataBufferNode.pInitNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.loadDataBufferNode.pInitNotification);
+    }
+    if (pJob->data.resourceManager.loadDataBufferNode.pInitFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.loadDataBufferNode.pInitFence);
+    }
+
+    /* If we have a success result it means we've fully loaded the buffer. This will happen in the non-decoding case. */
+    if (result != MA_BUSY) {
+        if (pJob->data.resourceManager.loadDataBufferNode.pDoneNotification != NULL) {
+            ma_async_notification_signal(pJob->data.resourceManager.loadDataBufferNode.pDoneNotification);
+        }
+        if (pJob->data.resourceManager.loadDataBufferNode.pDoneFence != NULL) {
+            ma_fence_release(pJob->data.resourceManager.loadDataBufferNode.pDoneFence);
+        }
+    }
+
+    /* Increment the node's execution pointer so that the next jobs can be processed. This is how we keep decoding of pages in-order. */
+    ma_atomic_fetch_add_32(&pDataBufferNode->executionPointer, 1);
+
+    /* A busy result should be considered successful from the point of view of the job system. */
+    if (result == MA_BUSY) {
+        result  = MA_SUCCESS;
+    }
+
+    return result;
+}
+
+static ma_result ma_job_process__resource_manager__free_data_buffer_node(ma_job* pJob)
+{
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_buffer_node* pDataBufferNode;
+
+    MA_ASSERT(pJob != NULL);
+
+    pResourceManager = (ma_resource_manager*)pJob->data.resourceManager.freeDataBufferNode.pResourceManager;
+    MA_ASSERT(pResourceManager != NULL);
+
+    pDataBufferNode = (ma_resource_manager_data_buffer_node*)pJob->data.resourceManager.freeDataBufferNode.pDataBufferNode;
+    MA_ASSERT(pDataBufferNode != NULL);
+
+    if (pJob->order != ma_atomic_load_32(&pDataBufferNode->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    ma_resource_manager_data_buffer_node_free(pResourceManager, pDataBufferNode);
+
+    /* The event needs to be signalled last. */
+    if (pJob->data.resourceManager.freeDataBufferNode.pDoneNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.freeDataBufferNode.pDoneNotification);
+    }
+
+    if (pJob->data.resourceManager.freeDataBufferNode.pDoneFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.freeDataBufferNode.pDoneFence);
+    }
+
+    ma_atomic_fetch_add_32(&pDataBufferNode->executionPointer, 1);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_job_process__resource_manager__page_data_buffer_node(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_buffer_node* pDataBufferNode;
+
+    MA_ASSERT(pJob != NULL);
+
+    pResourceManager = (ma_resource_manager*)pJob->data.resourceManager.pageDataBufferNode.pResourceManager;
+    MA_ASSERT(pResourceManager != NULL);
+
+    pDataBufferNode = (ma_resource_manager_data_buffer_node*)pJob->data.resourceManager.pageDataBufferNode.pDataBufferNode;
+    MA_ASSERT(pDataBufferNode != NULL);
+
+    if (pJob->order != ma_atomic_load_32(&pDataBufferNode->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    /* Don't do any more decoding if the data buffer has started the uninitialization process. */
+    result = ma_resource_manager_data_buffer_node_result(pDataBufferNode);
+    if (result != MA_BUSY) {
+        goto done;
+    }
+
+    /* We're ready to decode the next page. */
+    result = ma_resource_manager_data_buffer_node_decode_next_page(pResourceManager, pDataBufferNode, (ma_decoder*)pJob->data.resourceManager.pageDataBufferNode.pDecoder);
+
+    /*
+    If we have a success code by this point, we want to post another job. We're going to set the
+    result back to MA_BUSY to make it clear that there's still more to load.
+    */
+    if (result == MA_SUCCESS) {
+        ma_job newJob;
+        newJob = *pJob; /* Everything is the same as the input job, except the execution order. */
+        newJob.order = ma_resource_manager_data_buffer_node_next_execution_order(pDataBufferNode);   /* We need a fresh execution order. */
+
+        result = ma_resource_manager_post_job(pResourceManager, &newJob);
+
+        /* Since the sound isn't yet fully decoded we want the status to be set to busy. */
+        if (result == MA_SUCCESS) {
+            result  = MA_BUSY;
+        }
+    }
+
+done:
+    /* If there's still more to decode the result will be set to MA_BUSY. Otherwise we can free the decoder. */
+    if (result != MA_BUSY) {
+        ma_decoder_uninit((ma_decoder*)pJob->data.resourceManager.pageDataBufferNode.pDecoder);
+        ma_free(pJob->data.resourceManager.pageDataBufferNode.pDecoder, &pResourceManager->config.allocationCallbacks);
+    }
+
+    /* If we reached the end we need to treat it as successful. */
+    if (result == MA_AT_END) {
+        result  = MA_SUCCESS;
+    }
+
+    /* Make sure we set the result of node in case some error occurred. */
+    ma_atomic_compare_and_swap_i32(&pDataBufferNode->result, MA_BUSY, result);
+
+    /* Signal the notification after setting the result in case the notification callback wants to inspect the result code. */
+    if (result != MA_BUSY) {
+        if (pJob->data.resourceManager.pageDataBufferNode.pDoneNotification != NULL) {
+            ma_async_notification_signal(pJob->data.resourceManager.pageDataBufferNode.pDoneNotification);
+        }
+
+        if (pJob->data.resourceManager.pageDataBufferNode.pDoneFence != NULL) {
+            ma_fence_release(pJob->data.resourceManager.pageDataBufferNode.pDoneFence);
+        }
+    }
+
+    ma_atomic_fetch_add_32(&pDataBufferNode->executionPointer, 1);
+    return result;
+}
+
+
+static ma_result ma_job_process__resource_manager__load_data_buffer(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_buffer* pDataBuffer;
+    ma_resource_manager_data_supply_type dataSupplyType = ma_resource_manager_data_supply_type_unknown;
+    ma_bool32 isConnectorInitialized = MA_FALSE;
+
+    /*
+    All we're doing here is checking if the node has finished loading. If not, we just re-post the job
+    and keep waiting. Otherwise we increment the execution counter and set the buffer's result code.
+    */
+    MA_ASSERT(pJob != NULL);
+
+    pDataBuffer = (ma_resource_manager_data_buffer*)pJob->data.resourceManager.loadDataBuffer.pDataBuffer;
+    MA_ASSERT(pDataBuffer != NULL);
+
+    pResourceManager = pDataBuffer->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataBuffer->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Attempting to execute out of order. Probably interleaved with a MA_JOB_TYPE_RESOURCE_MANAGER_FREE_DATA_BUFFER job. */
+    }
+
+    /*
+    First thing we need to do is check whether or not the data buffer is getting deleted. If so we
+    just abort, but making sure we increment the execution pointer.
+    */
+    result = ma_resource_manager_data_buffer_result(pDataBuffer);
+    if (result != MA_BUSY) {
+        goto done;  /* <-- This will ensure the exucution pointer is incremented. */
+    } else {
+        result = MA_SUCCESS;    /* <-- Make sure this is reset. */
+    }
+
+    /* Try initializing the connector if we haven't already. */
+    isConnectorInitialized = ma_resource_manager_data_buffer_has_connector(pDataBuffer);
+    if (isConnectorInitialized == MA_FALSE) {
+        dataSupplyType = ma_resource_manager_data_buffer_node_get_data_supply_type(pDataBuffer->pNode);
+
+        if (dataSupplyType != ma_resource_manager_data_supply_type_unknown) {
+            /* We can now initialize the connector. If this fails, we need to abort. It's very rare for this to fail. */
+            ma_resource_manager_data_source_config dataSourceConfig;    /* For setting initial looping state and range. */
+            dataSourceConfig = ma_resource_manager_data_source_config_init();
+            dataSourceConfig.rangeBegInPCMFrames     = pJob->data.resourceManager.loadDataBuffer.rangeBegInPCMFrames;
+            dataSourceConfig.rangeEndInPCMFrames     = pJob->data.resourceManager.loadDataBuffer.rangeEndInPCMFrames;
+            dataSourceConfig.loopPointBegInPCMFrames = pJob->data.resourceManager.loadDataBuffer.loopPointBegInPCMFrames;
+            dataSourceConfig.loopPointEndInPCMFrames = pJob->data.resourceManager.loadDataBuffer.loopPointEndInPCMFrames;
+            dataSourceConfig.isLooping               = pJob->data.resourceManager.loadDataBuffer.isLooping;
+
+            result = ma_resource_manager_data_buffer_init_connector(pDataBuffer, &dataSourceConfig, pJob->data.resourceManager.loadDataBuffer.pInitNotification, pJob->data.resourceManager.loadDataBuffer.pInitFence);
+            if (result != MA_SUCCESS) {
+                ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to initialize connector for data buffer. %s.\n", ma_result_description(result));
+                goto done;
+            }
+        } else {
+            /* Don't have a known data supply type. Most likely the data buffer node is still loading, but it could be that an error occurred. */
+        }
+    } else {
+        /* The connector is already initialized. Nothing to do here. */
+    }
+
+    /*
+    If the data node is still loading, we need to repost the job and *not* increment the execution
+    pointer (i.e. we need to not fall through to the "done" label).
+
+    There is a hole between here and the where the data connector is initialized where the data
+    buffer node may have finished initializing. We need to check for this by checking the result of
+    the data buffer node and whether or not we had an unknown data supply type at the time of
+    trying to initialize the data connector.
+    */
+    result = ma_resource_manager_data_buffer_node_result(pDataBuffer->pNode);
+    if (result == MA_BUSY || (result == MA_SUCCESS && isConnectorInitialized == MA_FALSE && dataSupplyType == ma_resource_manager_data_supply_type_unknown)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);
+    }
+
+done:
+    /* Only move away from a busy code so that we don't trash any existing error codes. */
+    ma_atomic_compare_and_swap_i32(&pDataBuffer->result, MA_BUSY, result);
+
+    /* Only signal the other threads after the result has been set just for cleanliness sake. */
+    if (pJob->data.resourceManager.loadDataBuffer.pDoneNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.loadDataBuffer.pDoneNotification);
+    }
+    if (pJob->data.resourceManager.loadDataBuffer.pDoneFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.loadDataBuffer.pDoneFence);
+    }
+
+    /*
+    If at this point the data buffer has not had it's connector initialized, it means the
+    notification event was never signalled which means we need to signal it here.
+    */
+    if (ma_resource_manager_data_buffer_has_connector(pDataBuffer) == MA_FALSE && result != MA_SUCCESS) {
+        if (pJob->data.resourceManager.loadDataBuffer.pInitNotification != NULL) {
+            ma_async_notification_signal(pJob->data.resourceManager.loadDataBuffer.pInitNotification);
+        }
+        if (pJob->data.resourceManager.loadDataBuffer.pInitFence != NULL) {
+            ma_fence_release(pJob->data.resourceManager.loadDataBuffer.pInitFence);
+        }
+    }
+
+    ma_atomic_fetch_add_32(&pDataBuffer->executionPointer, 1);
+    return result;
+}
+
+static ma_result ma_job_process__resource_manager__free_data_buffer(ma_job* pJob)
+{
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_buffer* pDataBuffer;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDataBuffer = (ma_resource_manager_data_buffer*)pJob->data.resourceManager.freeDataBuffer.pDataBuffer;
+    MA_ASSERT(pDataBuffer != NULL);
+
+    pResourceManager = pDataBuffer->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataBuffer->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    ma_resource_manager_data_buffer_uninit_internal(pDataBuffer);
+
+    /* The event needs to be signalled last. */
+    if (pJob->data.resourceManager.freeDataBuffer.pDoneNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.freeDataBuffer.pDoneNotification);
+    }
+
+    if (pJob->data.resourceManager.freeDataBuffer.pDoneFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.freeDataBuffer.pDoneFence);
+    }
+
+    ma_atomic_fetch_add_32(&pDataBuffer->executionPointer, 1);
+    return MA_SUCCESS;
+}
+
+static ma_result ma_job_process__resource_manager__load_data_stream(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_decoder_config decoderConfig;
+    ma_uint32 pageBufferSizeInBytes;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_stream* pDataStream;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDataStream = (ma_resource_manager_data_stream*)pJob->data.resourceManager.loadDataStream.pDataStream;
+    MA_ASSERT(pDataStream != NULL);
+
+    pResourceManager = pDataStream->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataStream->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_BUSY) {
+        result = MA_INVALID_OPERATION;  /* Most likely the data stream is being uninitialized. */
+        goto done;
+    }
+
+    /* We need to initialize the decoder first so we can determine the size of the pages. */
+    decoderConfig = ma_resource_manager__init_decoder_config(pResourceManager);
+
+    if (pJob->data.resourceManager.loadDataStream.pFilePath != NULL) {
+        result = ma_decoder_init_vfs(pResourceManager->config.pVFS, pJob->data.resourceManager.loadDataStream.pFilePath, &decoderConfig, &pDataStream->decoder);
+    } else {
+        result = ma_decoder_init_vfs_w(pResourceManager->config.pVFS, pJob->data.resourceManager.loadDataStream.pFilePathW, &decoderConfig, &pDataStream->decoder);
+    }
+    if (result != MA_SUCCESS) {
+        goto done;
+    }
+
+    /* Retrieve the total length of the file before marking the decoder as loaded. */
+    if ((pDataStream->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH) == 0) {
+        result = ma_decoder_get_length_in_pcm_frames(&pDataStream->decoder, &pDataStream->totalLengthInPCMFrames);
+        if (result != MA_SUCCESS) {
+            goto done;  /* Failed to retrieve the length. */
+        }
+    } else {
+        pDataStream->totalLengthInPCMFrames = 0;
+    }
+
+    /*
+    Only mark the decoder as initialized when the length of the decoder has been retrieved because that can possibly require a scan over the whole file
+    and we don't want to have another thread trying to access the decoder while it's scanning.
+    */
+    pDataStream->isDecoderInitialized = MA_TRUE;
+
+    /* We have the decoder so we can now initialize our page buffer. */
+    pageBufferSizeInBytes = ma_resource_manager_data_stream_get_page_size_in_frames(pDataStream) * 2 * ma_get_bytes_per_frame(pDataStream->decoder.outputFormat, pDataStream->decoder.outputChannels);
+
+    pDataStream->pPageData = ma_malloc(pageBufferSizeInBytes, &pResourceManager->config.allocationCallbacks);
+    if (pDataStream->pPageData == NULL) {
+        ma_decoder_uninit(&pDataStream->decoder);
+        result = MA_OUT_OF_MEMORY;
+        goto done;
+    }
+
+    /* Seek to our initial seek point before filling the initial pages. */
+    ma_decoder_seek_to_pcm_frame(&pDataStream->decoder, pJob->data.resourceManager.loadDataStream.initialSeekPoint);
+
+    /* We have our decoder and our page buffer, so now we need to fill our pages. */
+    ma_resource_manager_data_stream_fill_pages(pDataStream);
+
+    /* And now we're done. We want to make sure the result is MA_SUCCESS. */
+    result = MA_SUCCESS;
+
+done:
+    ma_free(pJob->data.resourceManager.loadDataStream.pFilePath,  &pResourceManager->config.allocationCallbacks);
+    ma_free(pJob->data.resourceManager.loadDataStream.pFilePathW, &pResourceManager->config.allocationCallbacks);
+
+    /* We can only change the status away from MA_BUSY. If it's set to anything else it means an error has occurred somewhere or the uninitialization process has started (most likely). */
+    ma_atomic_compare_and_swap_i32(&pDataStream->result, MA_BUSY, result);
+
+    /* Only signal the other threads after the result has been set just for cleanliness sake. */
+    if (pJob->data.resourceManager.loadDataStream.pInitNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.loadDataStream.pInitNotification);
+    }
+    if (pJob->data.resourceManager.loadDataStream.pInitFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.loadDataStream.pInitFence);
+    }
+
+    ma_atomic_fetch_add_32(&pDataStream->executionPointer, 1);
+    return result;
+}
+
+static ma_result ma_job_process__resource_manager__free_data_stream(ma_job* pJob)
+{
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_stream* pDataStream;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDataStream = (ma_resource_manager_data_stream*)pJob->data.resourceManager.freeDataStream.pDataStream;
+    MA_ASSERT(pDataStream != NULL);
+
+    pResourceManager = pDataStream->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataStream->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    /* If our status is not MA_UNAVAILABLE we have a bug somewhere. */
+    MA_ASSERT(ma_resource_manager_data_stream_result(pDataStream) == MA_UNAVAILABLE);
+
+    if (pDataStream->isDecoderInitialized) {
+        ma_decoder_uninit(&pDataStream->decoder);
+    }
+
+    if (pDataStream->pPageData != NULL) {
+        ma_free(pDataStream->pPageData, &pResourceManager->config.allocationCallbacks);
+        pDataStream->pPageData = NULL;  /* Just in case... */
+    }
+
+    ma_data_source_uninit(&pDataStream->ds);
+
+    /* The event needs to be signalled last. */
+    if (pJob->data.resourceManager.freeDataStream.pDoneNotification != NULL) {
+        ma_async_notification_signal(pJob->data.resourceManager.freeDataStream.pDoneNotification);
+    }
+    if (pJob->data.resourceManager.freeDataStream.pDoneFence != NULL) {
+        ma_fence_release(pJob->data.resourceManager.freeDataStream.pDoneFence);
+    }
+
+    /*ma_atomic_fetch_add_32(&pDataStream->executionPointer, 1);*/
+    return MA_SUCCESS;
+}
+
+static ma_result ma_job_process__resource_manager__page_data_stream(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_stream* pDataStream;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDataStream = (ma_resource_manager_data_stream*)pJob->data.resourceManager.pageDataStream.pDataStream;
+    MA_ASSERT(pDataStream != NULL);
+
+    pResourceManager = pDataStream->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataStream->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    /* For streams, the status should be MA_SUCCESS. */
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS) {
+        result = MA_INVALID_OPERATION;
+        goto done;
+    }
+
+    ma_resource_manager_data_stream_fill_page(pDataStream, pJob->data.resourceManager.pageDataStream.pageIndex);
+
+done:
+    ma_atomic_fetch_add_32(&pDataStream->executionPointer, 1);
+    return result;
+}
+
+static ma_result ma_job_process__resource_manager__seek_data_stream(ma_job* pJob)
+{
+    ma_result result = MA_SUCCESS;
+    ma_resource_manager* pResourceManager;
+    ma_resource_manager_data_stream* pDataStream;
+
+    MA_ASSERT(pJob != NULL);
+
+    pDataStream = (ma_resource_manager_data_stream*)pJob->data.resourceManager.seekDataStream.pDataStream;
+    MA_ASSERT(pDataStream != NULL);
+
+    pResourceManager = pDataStream->pResourceManager;
+
+    if (pJob->order != ma_atomic_load_32(&pDataStream->executionPointer)) {
+        return ma_resource_manager_post_job(pResourceManager, pJob);    /* Out of order. */
+    }
+
+    /* For streams the status should be MA_SUCCESS for this to do anything. */
+    if (ma_resource_manager_data_stream_result(pDataStream) != MA_SUCCESS || pDataStream->isDecoderInitialized == MA_FALSE) {
+        result = MA_INVALID_OPERATION;
+        goto done;
+    }
+
+    /*
+    With seeking we just assume both pages are invalid and the relative frame cursor at position 0. This is basically exactly the same as loading, except
+    instead of initializing the decoder, we seek to a frame.
+    */
+    ma_decoder_seek_to_pcm_frame(&pDataStream->decoder, pJob->data.resourceManager.seekDataStream.frameIndex);
+
+    /* After seeking we'll need to reload the pages. */
+    ma_resource_manager_data_stream_fill_pages(pDataStream);
+
+    /* We need to let the public API know that we're done seeking. */
+    ma_atomic_fetch_sub_32(&pDataStream->seekCounter, 1);
+
+done:
+    ma_atomic_fetch_add_32(&pDataStream->executionPointer, 1);
+    return result;
+}
+
+MA_API ma_result ma_resource_manager_process_job(ma_resource_manager* pResourceManager, ma_job* pJob)
+{
+    if (pResourceManager == NULL || pJob == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_job_process(pJob);
+}
+
+MA_API ma_result ma_resource_manager_process_next_job(ma_resource_manager* pResourceManager)
+{
+    ma_result result;
+    ma_job job;
+
+    if (pResourceManager == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* This will return MA_CANCELLED if the next job is a quit job. */
+    result = ma_resource_manager_next_job(pResourceManager, &job);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return ma_job_process(&job);
+}
+#else
+/* We'll get here if the resource manager is being excluded from the build. We need to define the job processing callbacks as no-ops. */
+static ma_result ma_job_process__resource_manager__load_data_buffer_node(ma_job* pJob) { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__free_data_buffer_node(ma_job* pJob) { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__page_data_buffer_node(ma_job* pJob) { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__load_data_buffer(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__free_data_buffer(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__load_data_stream(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__free_data_stream(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__page_data_stream(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+static ma_result ma_job_process__resource_manager__seek_data_stream(ma_job* pJob)      { return ma_job_process__noop(pJob); }
+#endif  /* MA_NO_RESOURCE_MANAGER */
+
+
+#ifndef MA_NO_NODE_GRAPH
+/* 10ms @ 48K = 480. Must never exceed 65535. */
+#ifndef MA_DEFAULT_NODE_CACHE_CAP_IN_FRAMES_PER_BUS
+#define MA_DEFAULT_NODE_CACHE_CAP_IN_FRAMES_PER_BUS 480
+#endif
+
+
+static ma_result ma_node_read_pcm_frames(ma_node* pNode, ma_uint32 outputBusIndex, float* pFramesOut, ma_uint32 frameCount, ma_uint32* pFramesRead, ma_uint64 globalTime);
+
+MA_API void ma_debug_fill_pcm_frames_with_sine_wave(float* pFramesOut, ma_uint32 frameCount, ma_format format, ma_uint32 channels, ma_uint32 sampleRate)
+{
+    #ifndef MA_NO_GENERATION
+    {
+        ma_waveform_config waveformConfig;
+        ma_waveform waveform;
+
+        waveformConfig = ma_waveform_config_init(format, channels, sampleRate, ma_waveform_type_sine, 1.0, 400);
+        ma_waveform_init(&waveformConfig, &waveform);
+        ma_waveform_read_pcm_frames(&waveform, pFramesOut, frameCount, NULL);
+    }
+    #else
+    {
+        (void)pFramesOut;
+        (void)frameCount;
+        (void)format;
+        (void)channels;
+        (void)sampleRate;
+        #if defined(MA_DEBUG_OUTPUT)
+        {
+            #if _MSC_VER
+                #pragma message ("ma_debug_fill_pcm_frames_with_sine_wave() will do nothing because MA_NO_GENERATION is enabled.")
+            #endif
+        }
+        #endif
+    }
+    #endif
+}
+
+
+
+MA_API ma_node_graph_config ma_node_graph_config_init(ma_uint32 channels)
+{
+    ma_node_graph_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.channels             = channels;
+    config.nodeCacheCapInFrames = MA_DEFAULT_NODE_CACHE_CAP_IN_FRAMES_PER_BUS;
+
+    return config;
+}
+
+
+static void ma_node_graph_set_is_reading(ma_node_graph* pNodeGraph, ma_bool32 isReading)
+{
+    MA_ASSERT(pNodeGraph != NULL);
+    ma_atomic_exchange_32(&pNodeGraph->isReading, isReading);
+}
+
+#if 0
+static ma_bool32 ma_node_graph_is_reading(ma_node_graph* pNodeGraph)
+{
+    MA_ASSERT(pNodeGraph != NULL);
+    return ma_atomic_load_32(&pNodeGraph->isReading);
+}
+#endif
+
+
+static void ma_node_graph_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_node_graph* pNodeGraph = (ma_node_graph*)pNode;
+    ma_uint64 framesRead;
+
+    ma_node_graph_read_pcm_frames(pNodeGraph, ppFramesOut[0], *pFrameCountOut, &framesRead);
+
+    *pFrameCountOut = (ma_uint32)framesRead;    /* Safe cast. */
+
+    (void)ppFramesIn;
+    (void)pFrameCountIn;
+}
+
+static ma_node_vtable g_node_graph_node_vtable =
+{
+    ma_node_graph_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    0,      /* 0 input buses. */
+    1,      /* 1 output bus. */
+    0       /* Flags. */
+};
+
+static void ma_node_graph_endpoint_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    MA_ASSERT(pNode != NULL);
+    MA_ASSERT(ma_node_get_input_bus_count(pNode)  == 1);
+    MA_ASSERT(ma_node_get_output_bus_count(pNode) == 1);
+
+    /* Input channel count needs to be the same as the output channel count. */
+    MA_ASSERT(ma_node_get_input_channels(pNode, 0) == ma_node_get_output_channels(pNode, 0));
+
+    /* We don't need to do anything here because it's a passthrough. */
+    (void)pNode;
+    (void)ppFramesIn;
+    (void)pFrameCountIn;
+    (void)ppFramesOut;
+    (void)pFrameCountOut;
+
+#if 0
+    /* The data has already been mixed. We just need to move it to the output buffer. */
+    if (ppFramesIn != NULL) {
+        ma_copy_pcm_frames(ppFramesOut[0], ppFramesIn[0], *pFrameCountOut, ma_format_f32, ma_node_get_output_channels(pNode, 0));
+    }
+#endif
+}
+
+static ma_node_vtable g_node_graph_endpoint_vtable =
+{
+    ma_node_graph_endpoint_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* 1 input bus. */
+    1,      /* 1 output bus. */
+    MA_NODE_FLAG_PASSTHROUGH    /* Flags. The endpoint is a passthrough. */
+};
+
+MA_API ma_result ma_node_graph_init(const ma_node_graph_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_node_graph* pNodeGraph)
+{
+    ma_result result;
+    ma_node_config baseConfig;
+    ma_node_config endpointConfig;
+
+    if (pNodeGraph == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNodeGraph);
+    pNodeGraph->nodeCacheCapInFrames = pConfig->nodeCacheCapInFrames;
+    if (pNodeGraph->nodeCacheCapInFrames == 0) {
+        pNodeGraph->nodeCacheCapInFrames = MA_DEFAULT_NODE_CACHE_CAP_IN_FRAMES_PER_BUS;
+    }
+
+
+    /* Base node so we can use the node graph as a node into another graph. */
+    baseConfig = ma_node_config_init();
+    baseConfig.vtable = &g_node_graph_node_vtable;
+    baseConfig.pOutputChannels = &pConfig->channels;
+
+    result = ma_node_init(pNodeGraph, &baseConfig, pAllocationCallbacks, &pNodeGraph->base);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+
+    /* Endpoint. */
+    endpointConfig = ma_node_config_init();
+    endpointConfig.vtable          = &g_node_graph_endpoint_vtable;
+    endpointConfig.pInputChannels  = &pConfig->channels;
+    endpointConfig.pOutputChannels = &pConfig->channels;
+
+    result = ma_node_init(pNodeGraph, &endpointConfig, pAllocationCallbacks, &pNodeGraph->endpoint);
+    if (result != MA_SUCCESS) {
+        ma_node_uninit(&pNodeGraph->base, pAllocationCallbacks);
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_node_graph_uninit(ma_node_graph* pNodeGraph, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pNodeGraph == NULL) {
+        return;
+    }
+
+    ma_node_uninit(&pNodeGraph->endpoint, pAllocationCallbacks);
+}
+
+MA_API ma_node* ma_node_graph_get_endpoint(ma_node_graph* pNodeGraph)
+{
+    if (pNodeGraph == NULL) {
+        return NULL;
+    }
+
+    return &pNodeGraph->endpoint;
+}
+
+MA_API ma_result ma_node_graph_read_pcm_frames(ma_node_graph* pNodeGraph, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint64 totalFramesRead;
+    ma_uint32 channels;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;   /* Safety. */
+    }
+
+    if (pNodeGraph == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    channels = ma_node_get_output_channels(&pNodeGraph->endpoint, 0);
+
+
+    /* We'll be nice and try to do a full read of all frameCount frames. */
+    totalFramesRead = 0;
+    while (totalFramesRead < frameCount) {
+        ma_uint32 framesJustRead;
+        ma_uint64 framesToRead = frameCount - totalFramesRead;
+
+        if (framesToRead > 0xFFFFFFFF) {
+            framesToRead = 0xFFFFFFFF;
+        }
+
+        ma_node_graph_set_is_reading(pNodeGraph, MA_TRUE);
+        {
+            result = ma_node_read_pcm_frames(&pNodeGraph->endpoint, 0, (float*)ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, ma_format_f32, channels), (ma_uint32)framesToRead, &framesJustRead, ma_node_get_time(&pNodeGraph->endpoint));
+        }
+        ma_node_graph_set_is_reading(pNodeGraph, MA_FALSE);
+
+        totalFramesRead += framesJustRead;
+
+        if (result != MA_SUCCESS) {
+            break;
+        }
+
+        /* Abort if we weren't able to read any frames or else we risk getting stuck in a loop. */
+        if (framesJustRead == 0) {
+            break;
+        }
+    }
+
+    /* Let's go ahead and silence any leftover frames just for some added safety to ensure the caller doesn't try emitting garbage out of the speakers. */
+    if (totalFramesRead < frameCount) {
+        ma_silence_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, totalFramesRead, ma_format_f32, channels), (frameCount - totalFramesRead), ma_format_f32, channels);
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = totalFramesRead;
+    }
+
+    return result;
+}
+
+MA_API ma_uint32 ma_node_graph_get_channels(const ma_node_graph* pNodeGraph)
+{
+    if (pNodeGraph == NULL) {
+        return 0;
+    }
+
+    return ma_node_get_output_channels(&pNodeGraph->endpoint, 0);
+}
+
+MA_API ma_uint64 ma_node_graph_get_time(const ma_node_graph* pNodeGraph)
+{
+    if (pNodeGraph == NULL) {
+        return 0;
+    }
+
+    return ma_node_get_time(&pNodeGraph->endpoint); /* Global time is just the local time of the endpoint. */
+}
+
+MA_API ma_result ma_node_graph_set_time(ma_node_graph* pNodeGraph, ma_uint64 globalTime)
+{
+    if (pNodeGraph == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_node_set_time(&pNodeGraph->endpoint, globalTime); /* Global time is just the local time of the endpoint. */
+}
+
+
+#define MA_NODE_OUTPUT_BUS_FLAG_HAS_READ    0x01    /* Whether or not this bus ready to read more data. Only used on nodes with multiple output buses. */
+
+static ma_result ma_node_output_bus_init(ma_node* pNode, ma_uint32 outputBusIndex, ma_uint32 channels, ma_node_output_bus* pOutputBus)
+{
+    MA_ASSERT(pOutputBus != NULL);
+    MA_ASSERT(outputBusIndex < MA_MAX_NODE_BUS_COUNT);
+    MA_ASSERT(outputBusIndex < ma_node_get_output_bus_count(pNode));
+    MA_ASSERT(channels < 256);
+
+    MA_ZERO_OBJECT(pOutputBus);
+
+    if (channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pOutputBus->pNode          = pNode;
+    pOutputBus->outputBusIndex = (ma_uint8)outputBusIndex;
+    pOutputBus->channels       = (ma_uint8)channels;
+    pOutputBus->flags          = MA_NODE_OUTPUT_BUS_FLAG_HAS_READ; /* <-- Important that this flag is set by default. */
+    pOutputBus->volume         = 1;
+
+    return MA_SUCCESS;
+}
+
+static void ma_node_output_bus_lock(ma_node_output_bus* pOutputBus)
+{
+    ma_spinlock_lock(&pOutputBus->lock);
+}
+
+static void ma_node_output_bus_unlock(ma_node_output_bus* pOutputBus)
+{
+    ma_spinlock_unlock(&pOutputBus->lock);
+}
+
+
+static ma_uint32 ma_node_output_bus_get_channels(const ma_node_output_bus* pOutputBus)
+{
+    return pOutputBus->channels;
+}
+
+
+static void ma_node_output_bus_set_has_read(ma_node_output_bus* pOutputBus, ma_bool32 hasRead)
+{
+    if (hasRead) {
+        ma_atomic_fetch_or_32(&pOutputBus->flags, MA_NODE_OUTPUT_BUS_FLAG_HAS_READ);
+    } else {
+        ma_atomic_fetch_and_32(&pOutputBus->flags, (ma_uint32)~MA_NODE_OUTPUT_BUS_FLAG_HAS_READ);
+    }
+}
+
+static ma_bool32 ma_node_output_bus_has_read(ma_node_output_bus* pOutputBus)
+{
+    return (ma_atomic_load_32(&pOutputBus->flags) & MA_NODE_OUTPUT_BUS_FLAG_HAS_READ) != 0;
+}
+
+
+static void ma_node_output_bus_set_is_attached(ma_node_output_bus* pOutputBus, ma_bool32 isAttached)
+{
+    ma_atomic_exchange_32(&pOutputBus->isAttached, isAttached);
+}
+
+static ma_bool32 ma_node_output_bus_is_attached(ma_node_output_bus* pOutputBus)
+{
+    return ma_atomic_load_32(&pOutputBus->isAttached);
+}
+
+
+static ma_result ma_node_output_bus_set_volume(ma_node_output_bus* pOutputBus, float volume)
+{
+    MA_ASSERT(pOutputBus != NULL);
+
+    if (volume < 0.0f) {
+        volume = 0.0f;
+    }
+
+    ma_atomic_exchange_f32(&pOutputBus->volume, volume);
+
+    return MA_SUCCESS;
+}
+
+static float ma_node_output_bus_get_volume(const ma_node_output_bus* pOutputBus)
+{
+    return ma_atomic_load_f32((float*)&pOutputBus->volume);
+}
+
+
+static ma_result ma_node_input_bus_init(ma_uint32 channels, ma_node_input_bus* pInputBus)
+{
+    MA_ASSERT(pInputBus != NULL);
+    MA_ASSERT(channels < 256);
+
+    MA_ZERO_OBJECT(pInputBus);
+
+    if (channels == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pInputBus->channels = (ma_uint8)channels;
+
+    return MA_SUCCESS;
+}
+
+static void ma_node_input_bus_lock(ma_node_input_bus* pInputBus)
+{
+    MA_ASSERT(pInputBus != NULL);
+
+    ma_spinlock_lock(&pInputBus->lock);
+}
+
+static void ma_node_input_bus_unlock(ma_node_input_bus* pInputBus)
+{
+    MA_ASSERT(pInputBus != NULL);
+
+    ma_spinlock_unlock(&pInputBus->lock);
+}
+
+
+static void ma_node_input_bus_next_begin(ma_node_input_bus* pInputBus)
+{
+    ma_atomic_fetch_add_32(&pInputBus->nextCounter, 1);
+}
+
+static void ma_node_input_bus_next_end(ma_node_input_bus* pInputBus)
+{
+    ma_atomic_fetch_sub_32(&pInputBus->nextCounter, 1);
+}
+
+static ma_uint32 ma_node_input_bus_get_next_counter(ma_node_input_bus* pInputBus)
+{
+    return ma_atomic_load_32(&pInputBus->nextCounter);
+}
+
+
+static ma_uint32 ma_node_input_bus_get_channels(const ma_node_input_bus* pInputBus)
+{
+    return pInputBus->channels;
+}
+
+
+static void ma_node_input_bus_detach__no_output_bus_lock(ma_node_input_bus* pInputBus, ma_node_output_bus* pOutputBus)
+{
+    MA_ASSERT(pInputBus  != NULL);
+    MA_ASSERT(pOutputBus != NULL);
+
+    /*
+    Mark the output bus as detached first. This will prevent future iterations on the audio thread
+    from iterating this output bus.
+    */
+    ma_node_output_bus_set_is_attached(pOutputBus, MA_FALSE);
+
+    /*
+    We cannot use the output bus lock here since it'll be getting used at a higher level, but we do
+    still need to use the input bus lock since we'll be updating pointers on two different output
+    buses. The same rules apply here as the attaching case. Although we're using a lock here, we're
+    *not* using a lock when iterating over the list in the audio thread. We therefore need to craft
+    this in a way such that the iteration on the audio thread doesn't break.
+
+    The the first thing to do is swap out the "next" pointer of the previous output bus with the
+    new "next" output bus. This is the operation that matters for iteration on the audio thread.
+    After that, the previous pointer on the new "next" pointer needs to be updated, after which
+    point the linked list will be in a good state.
+    */
+    ma_node_input_bus_lock(pInputBus);
+    {
+        ma_node_output_bus* pOldPrev = (ma_node_output_bus*)ma_atomic_load_ptr(&pOutputBus->pPrev);
+        ma_node_output_bus* pOldNext = (ma_node_output_bus*)ma_atomic_load_ptr(&pOutputBus->pNext);
+
+        if (pOldPrev != NULL) {
+            ma_atomic_exchange_ptr(&pOldPrev->pNext, pOldNext); /* <-- This is where the output bus is detached from the list. */
+        }
+        if (pOldNext != NULL) {
+            ma_atomic_exchange_ptr(&pOldNext->pPrev, pOldPrev); /* <-- This is required for detachment. */
+        }
+    }
+    ma_node_input_bus_unlock(pInputBus);
+
+    /* At this point the output bus is detached and the linked list is completely unaware of it. Reset some data for safety. */
+    ma_atomic_exchange_ptr(&pOutputBus->pNext, NULL);   /* Using atomic exchanges here, mainly for the benefit of analysis tools which don't always recognize spinlocks. */
+    ma_atomic_exchange_ptr(&pOutputBus->pPrev, NULL);   /* As above. */
+    pOutputBus->pInputNode             = NULL;
+    pOutputBus->inputNodeInputBusIndex = 0;
+
+
+    /*
+    For thread-safety reasons, we don't want to be returning from this straight away. We need to
+    wait for the audio thread to finish with the output bus. There's two things we need to wait
+    for. The first is the part that selects the next output bus in the list, and the other is the
+    part that reads from the output bus. Basically all we're doing is waiting for the input bus
+    to stop referencing the output bus.
+
+    We're doing this part last because we want the section above to run while the audio thread
+    is finishing up with the output bus, just for efficiency reasons. We marked the output bus as
+    detached right at the top of this function which is going to prevent the audio thread from
+    iterating the output bus again.
+    */
+
+    /* Part 1: Wait for the current iteration to complete. */
+    while (ma_node_input_bus_get_next_counter(pInputBus) > 0) {
+        ma_yield();
+    }
+
+    /* Part 2: Wait for any reads to complete. */
+    while (ma_atomic_load_32(&pOutputBus->refCount) > 0) {
+        ma_yield();
+    }
+
+    /*
+    At this point we're done detaching and we can be guaranteed that the audio thread is not going
+    to attempt to reference this output bus again (until attached again).
+    */
+}
+
+#if 0   /* Not used at the moment, but leaving here in case I need it later. */
+static void ma_node_input_bus_detach(ma_node_input_bus* pInputBus, ma_node_output_bus* pOutputBus)
+{
+    MA_ASSERT(pInputBus  != NULL);
+    MA_ASSERT(pOutputBus != NULL);
+
+    ma_node_output_bus_lock(pOutputBus);
+    {
+        ma_node_input_bus_detach__no_output_bus_lock(pInputBus, pOutputBus);
+    }
+    ma_node_output_bus_unlock(pOutputBus);
+}
+#endif
+
+static void ma_node_input_bus_attach(ma_node_input_bus* pInputBus, ma_node_output_bus* pOutputBus, ma_node* pNewInputNode, ma_uint32 inputNodeInputBusIndex)
+{
+    MA_ASSERT(pInputBus  != NULL);
+    MA_ASSERT(pOutputBus != NULL);
+
+    ma_node_output_bus_lock(pOutputBus);
+    {
+        ma_node_output_bus* pOldInputNode = (ma_node_output_bus*)ma_atomic_load_ptr(&pOutputBus->pInputNode);
+
+        /* Detach from any existing attachment first if necessary. */
+        if (pOldInputNode != NULL) {
+            ma_node_input_bus_detach__no_output_bus_lock(pInputBus, pOutputBus);
+        }
+
+        /*
+        At this point we can be sure the output bus is not attached to anything. The linked list in the
+        old input bus has been updated so that pOutputBus will not get iterated again.
+        */
+        pOutputBus->pInputNode             = pNewInputNode;                     /* No need for an atomic assignment here because modification of this variable always happens within a lock. */
+        pOutputBus->inputNodeInputBusIndex = (ma_uint8)inputNodeInputBusIndex;
+
+        /*
+        Now we need to attach the output bus to the linked list. This involves updating two pointers on
+        two different output buses so I'm going to go ahead and keep this simple and just use a lock.
+        There are ways to do this without a lock, but it's just too hard to maintain for it's value.
+
+        Although we're locking here, it's important to remember that we're *not* locking when iterating
+        and reading audio data since that'll be running on the audio thread. As a result we need to be
+        careful how we craft this so that we don't break iteration. What we're going to do is always
+        attach the new item so that it becomes the first item in the list. That way, as we're iterating
+        we won't break any links in the list and iteration will continue safely. The detaching case will
+        also be crafted in a way as to not break list iteration. It's important to remember to use
+        atomic exchanges here since no locking is happening on the audio thread during iteration.
+        */
+        ma_node_input_bus_lock(pInputBus);
+        {
+            ma_node_output_bus* pNewPrev = &pInputBus->head;
+            ma_node_output_bus* pNewNext = (ma_node_output_bus*)ma_atomic_load_ptr(&pInputBus->head.pNext);
+
+            /* Update the local output bus. */
+            ma_atomic_exchange_ptr(&pOutputBus->pPrev, pNewPrev);
+            ma_atomic_exchange_ptr(&pOutputBus->pNext, pNewNext);
+
+            /* Update the other output buses to point back to the local output bus. */
+            ma_atomic_exchange_ptr(&pInputBus->head.pNext, pOutputBus); /* <-- This is where the output bus is actually attached to the input bus. */
+
+            /* Do the previous pointer last. This is only used for detachment. */
+            if (pNewNext != NULL) {
+                ma_atomic_exchange_ptr(&pNewNext->pPrev,  pOutputBus);
+            }
+        }
+        ma_node_input_bus_unlock(pInputBus);
+
+        /*
+        Mark the node as attached last. This is used to controlling whether or the output bus will be
+        iterated on the audio thread. Mainly required for detachment purposes.
+        */
+        ma_node_output_bus_set_is_attached(pOutputBus, MA_TRUE);
+    }
+    ma_node_output_bus_unlock(pOutputBus);
+}
+
+static ma_node_output_bus* ma_node_input_bus_next(ma_node_input_bus* pInputBus, ma_node_output_bus* pOutputBus)
+{
+    ma_node_output_bus* pNext;
+
+    MA_ASSERT(pInputBus != NULL);
+
+    if (pOutputBus == NULL) {
+        return NULL;
+    }
+
+    ma_node_input_bus_next_begin(pInputBus);
+    {
+        pNext = pOutputBus;
+        for (;;) {
+            pNext = (ma_node_output_bus*)ma_atomic_load_ptr(&pNext->pNext);
+            if (pNext == NULL) {
+                break;      /* Reached the end. */
+            }
+
+            if (ma_node_output_bus_is_attached(pNext) == MA_FALSE) {
+                continue;   /* The node is not attached. Keep checking. */
+            }
+
+            /* The next node has been selected. */
+            break;
+        }
+
+        /* We need to increment the reference count of the selected node. */
+        if (pNext != NULL) {
+            ma_atomic_fetch_add_32(&pNext->refCount, 1);
+        }
+
+        /* The previous node is no longer being referenced. */
+        ma_atomic_fetch_sub_32(&pOutputBus->refCount, 1);
+    }
+    ma_node_input_bus_next_end(pInputBus);
+
+    return pNext;
+}
+
+static ma_node_output_bus* ma_node_input_bus_first(ma_node_input_bus* pInputBus)
+{
+    return ma_node_input_bus_next(pInputBus, &pInputBus->head);
+}
+
+
+
+static ma_result ma_node_input_bus_read_pcm_frames(ma_node* pInputNode, ma_node_input_bus* pInputBus, float* pFramesOut, ma_uint32 frameCount, ma_uint32* pFramesRead, ma_uint64 globalTime)
+{
+    ma_result result = MA_SUCCESS;
+    ma_node_output_bus* pOutputBus;
+    ma_node_output_bus* pFirst;
+    ma_uint32 inputChannels;
+    ma_bool32 doesOutputBufferHaveContent = MA_FALSE;
+
+    (void)pInputNode;   /* Not currently used. */
+
+    /*
+    This will be called from the audio thread which means we can't be doing any locking. Basically,
+    this function will not perfom any locking, whereas attaching and detaching will, but crafted in
+    such a way that we don't need to perform any locking here. The important thing to remember is
+    to always iterate in a forward direction.
+
+    In order to process any data we need to first read from all input buses. That's where this
+    function comes in. This iterates over each of the attachments and accumulates/mixes them. We
+    also convert the channels to the nodes output channel count before mixing. We want to do this
+    channel conversion so that the caller of this function can invoke the processing callback
+    without having to do it themselves.
+
+    When we iterate over each of the attachments on the input bus, we need to read as much data as
+    we can from each of them so that we don't end up with holes between each of the attachments. To
+    do this, we need to read from each attachment in a loop and read as many frames as we can, up
+    to `frameCount`.
+    */
+    MA_ASSERT(pInputNode  != NULL);
+    MA_ASSERT(pFramesRead != NULL); /* pFramesRead is critical and must always be specified. On input it's undefined and on output it'll be set to the number of frames actually read. */
+
+    *pFramesRead = 0;   /* Safety. */
+
+    inputChannels = ma_node_input_bus_get_channels(pInputBus);
+
+    /*
+    We need to be careful with how we call ma_node_input_bus_first() and ma_node_input_bus_next(). They
+    are both critical to our lock-free thread-safety system. We can only call ma_node_input_bus_first()
+    once per iteration, however we have an optimization to checks whether or not it's the first item in
+    the list. We therefore need to store a pointer to the first item rather than repeatedly calling
+    ma_node_input_bus_first(). It's safe to keep hold of this pointer, so long as we don't dereference it
+    after calling ma_node_input_bus_next(), which we won't be.
+    */
+    pFirst = ma_node_input_bus_first(pInputBus);
+    if (pFirst == NULL) {
+        return MA_SUCCESS;  /* No attachments. Read nothing. */
+    }
+
+    for (pOutputBus = pFirst; pOutputBus != NULL; pOutputBus = ma_node_input_bus_next(pInputBus, pOutputBus)) {
+        ma_uint32 framesProcessed = 0;
+        ma_bool32 isSilentOutput = MA_FALSE;
+
+        MA_ASSERT(pOutputBus->pNode != NULL);
+        MA_ASSERT(((ma_node_base*)pOutputBus->pNode)->vtable != NULL);
+
+        isSilentOutput = (((ma_node_base*)pOutputBus->pNode)->vtable->flags & MA_NODE_FLAG_SILENT_OUTPUT) != 0;
+
+        if (pFramesOut != NULL) {
+            /* Read. */
+            float temp[MA_DATA_CONVERTER_STACK_BUFFER_SIZE / sizeof(float)];
+            ma_uint32 tempCapInFrames = ma_countof(temp) / inputChannels;
+
+            while (framesProcessed < frameCount) {
+                float* pRunningFramesOut;
+                ma_uint32 framesToRead;
+                ma_uint32 framesJustRead;
+
+                framesToRead = frameCount - framesProcessed;
+                if (framesToRead > tempCapInFrames) {
+                    framesToRead = tempCapInFrames;
+                }
+
+                pRunningFramesOut = ma_offset_pcm_frames_ptr_f32(pFramesOut, framesProcessed, inputChannels);
+
+                if (doesOutputBufferHaveContent == MA_FALSE) {
+                    /* Fast path. First attachment. We just read straight into the output buffer (no mixing required). */
+                    result = ma_node_read_pcm_frames(pOutputBus->pNode, pOutputBus->outputBusIndex, pRunningFramesOut, framesToRead, &framesJustRead, globalTime + framesProcessed);
+                } else {
+                    /* Slow path. Not the first attachment. Mixing required. */
+                    result = ma_node_read_pcm_frames(pOutputBus->pNode, pOutputBus->outputBusIndex, temp, framesToRead, &framesJustRead, globalTime + framesProcessed);
+                    if (result == MA_SUCCESS || result == MA_AT_END) {
+                        if (isSilentOutput == MA_FALSE) {   /* Don't mix if the node outputs silence. */
+                            ma_mix_pcm_frames_f32(pRunningFramesOut, temp, framesJustRead, inputChannels, /*volume*/1);
+                        }
+                    }
+                }
+
+                framesProcessed += framesJustRead;
+
+                /* If we reached the end or otherwise failed to read any data we need to finish up with this output node. */
+                if (result != MA_SUCCESS) {
+                    break;
+                }
+
+                /* If we didn't read anything, abort so we don't get stuck in a loop. */
+                if (framesJustRead == 0) {
+                    break;
+                }
+            }
+
+            /* If it's the first attachment we didn't do any mixing. Any leftover samples need to be silenced. */
+            if (pOutputBus == pFirst && framesProcessed < frameCount) {
+                ma_silence_pcm_frames(ma_offset_pcm_frames_ptr(pFramesOut, framesProcessed, ma_format_f32, inputChannels), (frameCount - framesProcessed), ma_format_f32, inputChannels);
+            }
+
+            if (isSilentOutput == MA_FALSE) {
+                doesOutputBufferHaveContent = MA_TRUE;
+            }
+        } else {
+            /* Seek. */
+            ma_node_read_pcm_frames(pOutputBus->pNode, pOutputBus->outputBusIndex, NULL, frameCount, &framesProcessed, globalTime);
+        }
+    }
+
+    /* If we didn't output anything, output silence. */
+    if (doesOutputBufferHaveContent == MA_FALSE && pFramesOut != NULL) {
+        ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, inputChannels);
+    }
+
+    /* In this path we always "process" the entire amount. */
+    *pFramesRead = frameCount;
+
+    return result;
+}
+
+
+MA_API ma_node_config ma_node_config_init(void)
+{
+    ma_node_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.initialState   = ma_node_state_started;    /* Nodes are started by default. */
+    config.inputBusCount  = MA_NODE_BUS_COUNT_UNKNOWN;
+    config.outputBusCount = MA_NODE_BUS_COUNT_UNKNOWN;
+
+    return config;
+}
+
+
+
+static ma_result ma_node_detach_full(ma_node* pNode);
+
+static float* ma_node_get_cached_input_ptr(ma_node* pNode, ma_uint32 inputBusIndex)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_uint32 iInputBus;
+    float* pBasePtr;
+
+    MA_ASSERT(pNodeBase != NULL);
+
+    /* Input data is stored at the front of the buffer. */
+    pBasePtr = pNodeBase->pCachedData;
+    for (iInputBus = 0; iInputBus < inputBusIndex; iInputBus += 1) {
+        pBasePtr += pNodeBase->cachedDataCapInFramesPerBus * ma_node_input_bus_get_channels(&pNodeBase->pInputBuses[iInputBus]);
+    }
+
+    return pBasePtr;
+}
+
+static float* ma_node_get_cached_output_ptr(ma_node* pNode, ma_uint32 outputBusIndex)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_uint32 iInputBus;
+    ma_uint32 iOutputBus;
+    float* pBasePtr;
+
+    MA_ASSERT(pNodeBase != NULL);
+
+    /* Cached output data starts after the input data. */
+    pBasePtr = pNodeBase->pCachedData;
+    for (iInputBus = 0; iInputBus < ma_node_get_input_bus_count(pNodeBase); iInputBus += 1) {
+        pBasePtr += pNodeBase->cachedDataCapInFramesPerBus * ma_node_input_bus_get_channels(&pNodeBase->pInputBuses[iInputBus]);
+    }
+
+    for (iOutputBus = 0; iOutputBus < outputBusIndex; iOutputBus += 1) {
+        pBasePtr += pNodeBase->cachedDataCapInFramesPerBus * ma_node_output_bus_get_channels(&pNodeBase->pOutputBuses[iOutputBus]);
+    }
+
+    return pBasePtr;
+}
+
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t inputBusOffset;
+    size_t outputBusOffset;
+    size_t cachedDataOffset;
+    ma_uint32 inputBusCount;    /* So it doesn't have to be calculated twice. */
+    ma_uint32 outputBusCount;   /* So it doesn't have to be calculated twice. */
+} ma_node_heap_layout;
+
+static ma_result ma_node_translate_bus_counts(const ma_node_config* pConfig, ma_uint32* pInputBusCount, ma_uint32* pOutputBusCount)
+{
+    ma_uint32 inputBusCount;
+    ma_uint32 outputBusCount;
+
+    MA_ASSERT(pConfig != NULL);
+    MA_ASSERT(pInputBusCount  != NULL);
+    MA_ASSERT(pOutputBusCount != NULL);
+
+    /* Bus counts are determined by the vtable, unless they're set to `MA_NODE_BUS_COUNT_UNKNWON`, in which case they're taken from the config. */
+    if (pConfig->vtable->inputBusCount == MA_NODE_BUS_COUNT_UNKNOWN) {
+        inputBusCount = pConfig->inputBusCount;
+    } else {
+        inputBusCount = pConfig->vtable->inputBusCount;
+
+        if (pConfig->inputBusCount != MA_NODE_BUS_COUNT_UNKNOWN && pConfig->inputBusCount != pConfig->vtable->inputBusCount) {
+            return MA_INVALID_ARGS; /* Invalid configuration. You must not specify a conflicting bus count between the node's config and the vtable. */
+        }
+    }
+
+    if (pConfig->vtable->outputBusCount == MA_NODE_BUS_COUNT_UNKNOWN) {
+        outputBusCount = pConfig->outputBusCount;
+    } else {
+        outputBusCount = pConfig->vtable->outputBusCount;
+
+        if (pConfig->outputBusCount != MA_NODE_BUS_COUNT_UNKNOWN && pConfig->outputBusCount != pConfig->vtable->outputBusCount) {
+            return MA_INVALID_ARGS; /* Invalid configuration. You must not specify a conflicting bus count between the node's config and the vtable. */
+        }
+    }
+
+    /* Bus counts must be within limits. */
+    if (inputBusCount > MA_MAX_NODE_BUS_COUNT || outputBusCount > MA_MAX_NODE_BUS_COUNT) {
+        return MA_INVALID_ARGS;
+    }
+
+
+    /* We must have channel counts for each bus. */
+    if ((inputBusCount > 0 && pConfig->pInputChannels == NULL) || (outputBusCount > 0 && pConfig->pOutputChannels == NULL)) {
+        return MA_INVALID_ARGS; /* You must specify channel counts for each input and output bus. */
+    }
+
+
+    /* Some special rules for passthrough nodes. */
+    if ((pConfig->vtable->flags & MA_NODE_FLAG_PASSTHROUGH) != 0) {
+        if ((pConfig->vtable->inputBusCount != 0 && pConfig->vtable->inputBusCount != 1) || pConfig->vtable->outputBusCount != 1) {
+            return MA_INVALID_ARGS; /* Passthrough nodes must have exactly 1 output bus and either 0 or 1 input bus. */
+        }
+
+        if (pConfig->pInputChannels[0] != pConfig->pOutputChannels[0]) {
+            return MA_INVALID_ARGS; /* Passthrough nodes must have the same number of channels between input and output nodes. */
+        }
+    }
+
+
+    *pInputBusCount  = inputBusCount;
+    *pOutputBusCount = outputBusCount;
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_node_get_heap_layout(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, ma_node_heap_layout* pHeapLayout)
+{
+    ma_result result;
+    ma_uint32 inputBusCount;
+    ma_uint32 outputBusCount;
+
+    MA_ASSERT(pHeapLayout != NULL);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL || pConfig->vtable == NULL || pConfig->vtable->onProcess == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_node_translate_bus_counts(pConfig, &inputBusCount, &outputBusCount);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    /* Input buses. */
+    if (inputBusCount > MA_MAX_NODE_LOCAL_BUS_COUNT) {
+        pHeapLayout->inputBusOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(sizeof(ma_node_input_bus) * inputBusCount);
+    } else {
+        pHeapLayout->inputBusOffset = MA_SIZE_MAX;  /* MA_SIZE_MAX indicates that no heap allocation is required for the input bus. */
+    }
+
+    /* Output buses. */
+    if (outputBusCount > MA_MAX_NODE_LOCAL_BUS_COUNT) {
+        pHeapLayout->outputBusOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(sizeof(ma_node_output_bus) * outputBusCount);
+    } else {
+        pHeapLayout->outputBusOffset = MA_SIZE_MAX;
+    }
+
+    /*
+    Cached audio data.
+
+    We need to allocate memory for a caching both input and output data. We have an optimization
+    where no caching is necessary for specific conditions:
+
+        - The node has 0 inputs and 1 output.
+
+    When a node meets the above conditions, no cache is allocated.
+
+    The size choice for this buffer is a little bit finicky. We don't want to be too wasteful by
+    allocating too much, but at the same time we want it be large enough so that enough frames can
+    be processed for each call to ma_node_read_pcm_frames() so that it keeps things efficient. For
+    now I'm going with 10ms @ 48K which is 480 frames per bus. This is configurable at compile
+    time. It might also be worth investigating whether or not this can be configured at run time.
+    */
+    if (inputBusCount == 0 && outputBusCount == 1) {
+        /* Fast path. No cache needed. */
+        pHeapLayout->cachedDataOffset = MA_SIZE_MAX;
+    } else {
+        /* Slow path. Cache needed. */
+        size_t cachedDataSizeInBytes = 0;
+        ma_uint32 iBus;
+
+        for (iBus = 0; iBus < inputBusCount; iBus += 1) {
+            cachedDataSizeInBytes += pNodeGraph->nodeCacheCapInFrames * ma_get_bytes_per_frame(ma_format_f32, pConfig->pInputChannels[iBus]);
+        }
+
+        for (iBus = 0; iBus < outputBusCount; iBus += 1) {
+            cachedDataSizeInBytes += pNodeGraph->nodeCacheCapInFrames * ma_get_bytes_per_frame(ma_format_f32, pConfig->pOutputChannels[iBus]);
+        }
+
+        pHeapLayout->cachedDataOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(cachedDataSizeInBytes);
+    }
+
+
+    /*
+    Not technically part of the heap, but we can output the input and output bus counts so we can
+    avoid a redundant call to ma_node_translate_bus_counts().
+    */
+    pHeapLayout->inputBusCount  = inputBusCount;
+    pHeapLayout->outputBusCount = outputBusCount;
+
+    /* Make sure allocation size is aligned. */
+    pHeapLayout->sizeInBytes = ma_align_64(pHeapLayout->sizeInBytes);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_get_heap_size(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_node_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_node_get_heap_layout(pNodeGraph, pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_init_preallocated(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, void* pHeap, ma_node* pNode)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_result result;
+    ma_node_heap_layout heapLayout;
+    ma_uint32 iInputBus;
+    ma_uint32 iOutputBus;
+
+    if (pNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNodeBase);
+
+    result = ma_node_get_heap_layout(pNodeGraph, pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pNodeBase->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pNodeBase->pNodeGraph     = pNodeGraph;
+    pNodeBase->vtable         = pConfig->vtable;
+    pNodeBase->state          = pConfig->initialState;
+    pNodeBase->stateTimes[ma_node_state_started] = 0;
+    pNodeBase->stateTimes[ma_node_state_stopped] = (ma_uint64)(ma_int64)-1; /* Weird casting for VC6 compatibility. */
+    pNodeBase->inputBusCount  = heapLayout.inputBusCount;
+    pNodeBase->outputBusCount = heapLayout.outputBusCount;
+
+    if (heapLayout.inputBusOffset != MA_SIZE_MAX) {
+        pNodeBase->pInputBuses = (ma_node_input_bus*)ma_offset_ptr(pHeap, heapLayout.inputBusOffset);
+    } else {
+        pNodeBase->pInputBuses = pNodeBase->_inputBuses;
+    }
+
+    if (heapLayout.outputBusOffset != MA_SIZE_MAX) {
+        pNodeBase->pOutputBuses = (ma_node_output_bus*)ma_offset_ptr(pHeap, heapLayout.outputBusOffset);
+    } else {
+        pNodeBase->pOutputBuses = pNodeBase->_outputBuses;
+    }
+
+    if (heapLayout.cachedDataOffset != MA_SIZE_MAX) {
+        pNodeBase->pCachedData = (float*)ma_offset_ptr(pHeap, heapLayout.cachedDataOffset);
+        pNodeBase->cachedDataCapInFramesPerBus = pNodeGraph->nodeCacheCapInFrames;
+    } else {
+        pNodeBase->pCachedData = NULL;
+    }
+
+
+
+    /* We need to run an initialization step for each input and output bus. */
+    for (iInputBus = 0; iInputBus < ma_node_get_input_bus_count(pNodeBase); iInputBus += 1) {
+        result = ma_node_input_bus_init(pConfig->pInputChannels[iInputBus], &pNodeBase->pInputBuses[iInputBus]);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+    for (iOutputBus = 0; iOutputBus < ma_node_get_output_bus_count(pNodeBase); iOutputBus += 1) {
+        result = ma_node_output_bus_init(pNodeBase, iOutputBus, pConfig->pOutputChannels[iOutputBus], &pNodeBase->pOutputBuses[iOutputBus]);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+    }
+
+
+    /* The cached data needs to be initialized to silence (or a sine wave tone if we're debugging). */
+    if (pNodeBase->pCachedData != NULL) {
+        ma_uint32 iBus;
+
+    #if 1   /* Toggle this between 0 and 1 to turn debugging on or off. 1 = fill with a sine wave for debugging; 0 = fill with silence. */
+        /* For safety we'll go ahead and default the buffer to silence. */
+        for (iBus = 0; iBus < ma_node_get_input_bus_count(pNodeBase); iBus += 1) {
+            ma_silence_pcm_frames(ma_node_get_cached_input_ptr(pNode, iBus), pNodeBase->cachedDataCapInFramesPerBus, ma_format_f32, ma_node_input_bus_get_channels(&pNodeBase->pInputBuses[iBus]));
+        }
+        for (iBus = 0; iBus < ma_node_get_output_bus_count(pNodeBase); iBus += 1) {
+            ma_silence_pcm_frames(ma_node_get_cached_output_ptr(pNode, iBus), pNodeBase->cachedDataCapInFramesPerBus, ma_format_f32, ma_node_output_bus_get_channels(&pNodeBase->pOutputBuses[iBus]));
+        }
+    #else
+        /* For debugging. Default to a sine wave. */
+        for (iBus = 0; iBus < ma_node_get_input_bus_count(pNodeBase); iBus += 1) {
+            ma_debug_fill_pcm_frames_with_sine_wave(ma_node_get_cached_input_ptr(pNode, iBus), pNodeBase->cachedDataCapInFramesPerBus, ma_format_f32, ma_node_input_bus_get_channels(&pNodeBase->pInputBuses[iBus]), 48000);
+        }
+        for (iBus = 0; iBus < ma_node_get_output_bus_count(pNodeBase); iBus += 1) {
+            ma_debug_fill_pcm_frames_with_sine_wave(ma_node_get_cached_output_ptr(pNode, iBus), pNodeBase->cachedDataCapInFramesPerBus, ma_format_f32, ma_node_output_bus_get_channels(&pNodeBase->pOutputBuses[iBus]), 48000);
+        }
+    #endif
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_init(ma_node_graph* pNodeGraph, const ma_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_node* pNode)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_node_get_heap_size(pNodeGraph, pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_node_init_preallocated(pNodeGraph, pConfig, pHeap, pNode);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    ((ma_node_base*)pNode)->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_node_uninit(ma_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+
+    if (pNodeBase == NULL) {
+        return;
+    }
+
+    /*
+    The first thing we need to do is fully detach the node. This will detach all inputs and
+    outputs. We need to do this first because it will sever the connection with the node graph and
+    allow us to complete uninitialization without needing to worry about thread-safety with the
+    audio thread. The detachment process will wait for any local processing of the node to finish.
+    */
+    ma_node_detach_full(pNode);
+
+    /*
+    At this point the node should be completely unreferenced by the node graph and we can finish up
+    the uninitialization process without needing to worry about thread-safety.
+    */
+    if (pNodeBase->_ownsHeap) {
+        ma_free(pNodeBase->_pHeap, pAllocationCallbacks);
+    }
+}
+
+MA_API ma_node_graph* ma_node_get_node_graph(const ma_node* pNode)
+{
+    if (pNode == NULL) {
+        return NULL;
+    }
+
+    return ((const ma_node_base*)pNode)->pNodeGraph;
+}
+
+MA_API ma_uint32 ma_node_get_input_bus_count(const ma_node* pNode)
+{
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    return ((ma_node_base*)pNode)->inputBusCount;
+}
+
+MA_API ma_uint32 ma_node_get_output_bus_count(const ma_node* pNode)
+{
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    return ((ma_node_base*)pNode)->outputBusCount;
+}
+
+
+MA_API ma_uint32 ma_node_get_input_channels(const ma_node* pNode, ma_uint32 inputBusIndex)
+{
+    const ma_node_base* pNodeBase = (const ma_node_base*)pNode;
+
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    if (inputBusIndex >= ma_node_get_input_bus_count(pNode)) {
+        return 0;   /* Invalid bus index. */
+    }
+
+    return ma_node_input_bus_get_channels(&pNodeBase->pInputBuses[inputBusIndex]);
+}
+
+MA_API ma_uint32 ma_node_get_output_channels(const ma_node* pNode, ma_uint32 outputBusIndex)
+{
+    const ma_node_base* pNodeBase = (const ma_node_base*)pNode;
+
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNode)) {
+        return 0;   /* Invalid bus index. */
+    }
+
+    return ma_node_output_bus_get_channels(&pNodeBase->pOutputBuses[outputBusIndex]);
+}
+
+
+static ma_result ma_node_detach_full(ma_node* pNode)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_uint32 iInputBus;
+
+    if (pNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /*
+    Make sure the node is completely detached first. This will not return until the output bus is
+    guaranteed to no longer be referenced by the audio thread.
+    */
+    ma_node_detach_all_output_buses(pNode);
+
+    /*
+    At this point all output buses will have been detached from the graph and we can be guaranteed
+    that none of it's input nodes will be getting processed by the graph. We can detach these
+    without needing to worry about the audio thread touching them.
+    */
+    for (iInputBus = 0; iInputBus < ma_node_get_input_bus_count(pNode); iInputBus += 1) {
+        ma_node_input_bus* pInputBus;
+        ma_node_output_bus* pOutputBus;
+
+        pInputBus = &pNodeBase->pInputBuses[iInputBus];
+
+        /*
+        This is important. We cannot be using ma_node_input_bus_first() or ma_node_input_bus_next(). Those
+        functions are specifically for the audio thread. We'll instead just manually iterate using standard
+        linked list logic. We don't need to worry about the audio thread referencing these because the step
+        above severed the connection to the graph.
+        */
+        for (pOutputBus = (ma_node_output_bus*)ma_atomic_load_ptr(&pInputBus->head.pNext); pOutputBus != NULL; pOutputBus = (ma_node_output_bus*)ma_atomic_load_ptr(&pOutputBus->pNext)) {
+            ma_node_detach_output_bus(pOutputBus->pNode, pOutputBus->outputBusIndex);   /* This won't do any waiting in practice and should be efficient. */
+        }
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_detach_output_bus(ma_node* pNode, ma_uint32 outputBusIndex)
+{
+    ma_result result = MA_SUCCESS;
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_node_base* pInputNodeBase;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNode)) {
+        return MA_INVALID_ARGS; /* Invalid output bus index. */
+    }
+
+    /* We need to lock the output bus because we need to inspect the input node and grab it's input bus. */
+    ma_node_output_bus_lock(&pNodeBase->pOutputBuses[outputBusIndex]);
+    {
+        pInputNodeBase = (ma_node_base*)pNodeBase->pOutputBuses[outputBusIndex].pInputNode;
+        if (pInputNodeBase != NULL) {
+            ma_node_input_bus_detach__no_output_bus_lock(&pInputNodeBase->pInputBuses[pNodeBase->pOutputBuses[outputBusIndex].inputNodeInputBusIndex], &pNodeBase->pOutputBuses[outputBusIndex]);
+        }
+    }
+    ma_node_output_bus_unlock(&pNodeBase->pOutputBuses[outputBusIndex]);
+
+    return result;
+}
+
+MA_API ma_result ma_node_detach_all_output_buses(ma_node* pNode)
+{
+    ma_uint32 iOutputBus;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    for (iOutputBus = 0; iOutputBus < ma_node_get_output_bus_count(pNode); iOutputBus += 1) {
+        ma_node_detach_output_bus(pNode, iOutputBus);
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_attach_output_bus(ma_node* pNode, ma_uint32 outputBusIndex, ma_node* pOtherNode, ma_uint32 otherNodeInputBusIndex)
+{
+    ma_node_base* pNodeBase  = (ma_node_base*)pNode;
+    ma_node_base* pOtherNodeBase = (ma_node_base*)pOtherNode;
+
+    if (pNodeBase == NULL || pOtherNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pNodeBase == pOtherNodeBase) {
+        return MA_INVALID_OPERATION;    /* Cannot attach a node to itself. */
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNode) || otherNodeInputBusIndex >= ma_node_get_input_bus_count(pOtherNode)) {
+        return MA_INVALID_OPERATION;    /* Invalid bus index. */
+    }
+
+    /* The output channel count of the output node must be the same as the input channel count of the input node. */
+    if (ma_node_get_output_channels(pNode, outputBusIndex) != ma_node_get_input_channels(pOtherNode, otherNodeInputBusIndex)) {
+        return MA_INVALID_OPERATION;    /* Channel count is incompatible. */
+    }
+
+    /* This will deal with detaching if the output bus is already attached to something. */
+    ma_node_input_bus_attach(&pOtherNodeBase->pInputBuses[otherNodeInputBusIndex], &pNodeBase->pOutputBuses[outputBusIndex], pOtherNode, otherNodeInputBusIndex);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_node_set_output_bus_volume(ma_node* pNode, ma_uint32 outputBusIndex, float volume)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+
+    if (pNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNode)) {
+        return MA_INVALID_ARGS; /* Invalid bus index. */
+    }
+
+    return ma_node_output_bus_set_volume(&pNodeBase->pOutputBuses[outputBusIndex], volume);
+}
+
+MA_API float ma_node_get_output_bus_volume(const ma_node* pNode, ma_uint32 outputBusIndex)
+{
+    const ma_node_base* pNodeBase = (const ma_node_base*)pNode;
+
+    if (pNodeBase == NULL) {
+        return 0;
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNode)) {
+        return 0;   /* Invalid bus index. */
+    }
+
+    return ma_node_output_bus_get_volume(&pNodeBase->pOutputBuses[outputBusIndex]);
+}
+
+MA_API ma_result ma_node_set_state(ma_node* pNode, ma_node_state state)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+
+    if (pNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_exchange_i32(&pNodeBase->state, state);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_node_state ma_node_get_state(const ma_node* pNode)
+{
+    const ma_node_base* pNodeBase = (const ma_node_base*)pNode;
+
+    if (pNodeBase == NULL) {
+        return ma_node_state_stopped;
+    }
+
+    return (ma_node_state)ma_atomic_load_i32(&pNodeBase->state);
+}
+
+MA_API ma_result ma_node_set_state_time(ma_node* pNode, ma_node_state state, ma_uint64 globalTime)
+{
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Validation check for safety since we'll be using this as an index into stateTimes[]. */
+    if (state != ma_node_state_started && state != ma_node_state_stopped) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_exchange_64(&((ma_node_base*)pNode)->stateTimes[state], globalTime);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_uint64 ma_node_get_state_time(const ma_node* pNode, ma_node_state state)
+{
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    /* Validation check for safety since we'll be using this as an index into stateTimes[]. */
+    if (state != ma_node_state_started && state != ma_node_state_stopped) {
+        return 0;
+    }
+
+    return ma_atomic_load_64(&((ma_node_base*)pNode)->stateTimes[state]);
+}
+
+MA_API ma_node_state ma_node_get_state_by_time(const ma_node* pNode, ma_uint64 globalTime)
+{
+    if (pNode == NULL) {
+        return ma_node_state_stopped;
+    }
+
+    return ma_node_get_state_by_time_range(pNode, globalTime, globalTime);
+}
+
+MA_API ma_node_state ma_node_get_state_by_time_range(const ma_node* pNode, ma_uint64 globalTimeBeg, ma_uint64 globalTimeEnd)
+{
+    ma_node_state state;
+
+    if (pNode == NULL) {
+        return ma_node_state_stopped;
+    }
+
+    state = ma_node_get_state(pNode);
+
+    /* An explicitly stopped node is always stopped. */
+    if (state == ma_node_state_stopped) {
+        return ma_node_state_stopped;
+    }
+
+    /*
+    Getting here means the node is marked as started, but it may still not be truly started due to
+    it's start time not having been reached yet. Also, the stop time may have also been reached in
+    which case it'll be considered stopped.
+    */
+    if (ma_node_get_state_time(pNode, ma_node_state_started) > globalTimeBeg) {
+        return ma_node_state_stopped;   /* Start time has not yet been reached. */
+    }
+
+    if (ma_node_get_state_time(pNode, ma_node_state_stopped) <= globalTimeEnd) {
+        return ma_node_state_stopped;   /* Stop time has been reached. */
+    }
+
+    /* Getting here means the node is marked as started and is within it's start/stop times. */
+    return ma_node_state_started;
+}
+
+MA_API ma_uint64 ma_node_get_time(const ma_node* pNode)
+{
+    if (pNode == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_64(&((ma_node_base*)pNode)->localTime);
+}
+
+MA_API ma_result ma_node_set_time(ma_node* pNode, ma_uint64 localTime)
+{
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_exchange_64(&((ma_node_base*)pNode)->localTime, localTime);
+
+    return MA_SUCCESS;
+}
+
+
+
+static void ma_node_process_pcm_frames_internal(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+
+    if (pNodeBase->vtable->onProcess) {
+        pNodeBase->vtable->onProcess(pNode, ppFramesIn, pFrameCountIn, ppFramesOut, pFrameCountOut);
+    }
+}
+
+static ma_result ma_node_read_pcm_frames(ma_node* pNode, ma_uint32 outputBusIndex, float* pFramesOut, ma_uint32 frameCount, ma_uint32* pFramesRead, ma_uint64 globalTime)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_result result = MA_SUCCESS;
+    ma_uint32 iInputBus;
+    ma_uint32 iOutputBus;
+    ma_uint32 inputBusCount;
+    ma_uint32 outputBusCount;
+    ma_uint32 totalFramesRead = 0;
+    float* ppFramesIn[MA_MAX_NODE_BUS_COUNT];
+    float* ppFramesOut[MA_MAX_NODE_BUS_COUNT];
+    ma_uint64 globalTimeBeg;
+    ma_uint64 globalTimeEnd;
+    ma_uint64 startTime;
+    ma_uint64 stopTime;
+    ma_uint32 timeOffsetBeg;
+    ma_uint32 timeOffsetEnd;
+    ma_uint32 frameCountIn;
+    ma_uint32 frameCountOut;
+
+    /*
+    pFramesRead is mandatory. It must be used to determine how many frames were read. It's normal and
+    expected that the number of frames read may be different to that requested. Therefore, the caller
+    must look at this value to correctly determine how many frames were read.
+    */
+    MA_ASSERT(pFramesRead != NULL); /* <-- If you've triggered this assert, you're using this function wrong. You *must* use this variable and inspect it after the call returns. */
+    if (pFramesRead == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pFramesRead = 0;   /* Safety. */
+
+    if (pNodeBase == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (outputBusIndex >= ma_node_get_output_bus_count(pNodeBase)) {
+        return MA_INVALID_ARGS; /* Invalid output bus index. */
+    }
+
+    /* Don't do anything if we're in a stopped state. */
+    if (ma_node_get_state_by_time_range(pNode, globalTime, globalTime + frameCount) != ma_node_state_started) {
+        return MA_SUCCESS;  /* We're in a stopped state. This is not an error - we just need to not read anything. */
+    }
+
+
+    globalTimeBeg = globalTime;
+    globalTimeEnd = globalTime + frameCount;
+    startTime = ma_node_get_state_time(pNode, ma_node_state_started);
+    stopTime  = ma_node_get_state_time(pNode, ma_node_state_stopped);
+
+    /*
+    At this point we know that we are inside our start/stop times. However, we may need to adjust
+    our frame count and output pointer to accommodate since we could be straddling the time period
+    that this function is getting called for.
+
+    It's possible (and likely) that the start time does not line up with the output buffer. We
+    therefore need to offset it by a number of frames to accommodate. The same thing applies for
+    the stop time.
+    */
+    timeOffsetBeg = (globalTimeBeg < startTime) ? (ma_uint32)(globalTimeEnd - startTime) : 0;
+    timeOffsetEnd = (globalTimeEnd > stopTime)  ? (ma_uint32)(globalTimeEnd - stopTime)  : 0;
+
+    /* Trim based on the start offset. We need to silence the start of the buffer. */
+    if (timeOffsetBeg > 0) {
+        ma_silence_pcm_frames(pFramesOut, timeOffsetBeg, ma_format_f32, ma_node_get_output_channels(pNode, outputBusIndex));
+        pFramesOut += timeOffsetBeg * ma_node_get_output_channels(pNode, outputBusIndex);
+        frameCount -= timeOffsetBeg;
+    }
+
+    /* Trim based on the end offset. We don't need to silence the tail section because we'll just have a reduced value written to pFramesRead. */
+    if (timeOffsetEnd > 0) {
+        frameCount -= timeOffsetEnd;
+    }
+
+
+    /* We run on different paths depending on the bus counts. */
+    inputBusCount  = ma_node_get_input_bus_count(pNode);
+    outputBusCount = ma_node_get_output_bus_count(pNode);
+
+    /*
+    Run a simplified path when there are no inputs and one output. In this case there's nothing to
+    actually read and we can go straight to output. This is a very common scenario because the vast
+    majority of data source nodes will use this setup so this optimization I think is worthwhile.
+    */
+    if (inputBusCount == 0 && outputBusCount == 1) {
+        /* Fast path. No need to read from input and no need for any caching. */
+        frameCountIn  = 0;
+        frameCountOut = frameCount;    /* Just read as much as we can. The callback will return what was actually read. */
+
+        ppFramesOut[0] = pFramesOut;
+
+        /*
+        If it's a passthrough we won't be expecting the callback to output anything, so we'll
+        need to pre-silence the output buffer.
+        */
+        if ((pNodeBase->vtable->flags & MA_NODE_FLAG_PASSTHROUGH) != 0) {
+            ma_silence_pcm_frames(pFramesOut, frameCount, ma_format_f32, ma_node_get_output_channels(pNode, outputBusIndex));
+        }
+
+        ma_node_process_pcm_frames_internal(pNode, NULL, &frameCountIn, ppFramesOut, &frameCountOut);
+        totalFramesRead = frameCountOut;
+    } else {
+        /* Slow path. Need to read input data. */
+        if ((pNodeBase->vtable->flags & MA_NODE_FLAG_PASSTHROUGH) != 0) {
+            /*
+            Fast path. We're running a passthrough. We need to read directly into the output buffer, but
+            still fire the callback so that event handling and trigger nodes can do their thing. Since
+            it's a passthrough there's no need for any kind of caching logic.
+            */
+            MA_ASSERT(outputBusCount == inputBusCount);
+            MA_ASSERT(outputBusCount == 1);
+            MA_ASSERT(outputBusIndex == 0);
+
+            /* We just read directly from input bus to output buffer, and then afterwards fire the callback. */
+            ppFramesOut[0] = pFramesOut;
+            ppFramesIn[0] = ppFramesOut[0];
+
+            result = ma_node_input_bus_read_pcm_frames(pNodeBase, &pNodeBase->pInputBuses[0], ppFramesIn[0], frameCount, &totalFramesRead, globalTime);
+            if (result == MA_SUCCESS) {
+                /* Even though it's a passthrough, we still need to fire the callback. */
+                frameCountIn  = totalFramesRead;
+                frameCountOut = totalFramesRead;
+
+                if (totalFramesRead > 0) {
+                    ma_node_process_pcm_frames_internal(pNode, (const float**)ppFramesIn, &frameCountIn, ppFramesOut, &frameCountOut);  /* From GCC: expected 'const float **' but argument is of type 'float **'. Shouldn't this be implicit? Excplicit cast to silence the warning. */
+                }
+
+                /*
+                A passthrough should never have modified the input and output frame counts. If you're
+                triggering these assers you need to fix your processing callback.
+                */
+                MA_ASSERT(frameCountIn  == totalFramesRead);
+                MA_ASSERT(frameCountOut == totalFramesRead);
+            }
+        } else {
+            /* Slow path. Need to do caching. */
+            ma_uint32 framesToProcessIn;
+            ma_uint32 framesToProcessOut;
+            ma_bool32 consumeNullInput = MA_FALSE;
+
+            /*
+            We use frameCount as a basis for the number of frames to read since that's what's being
+            requested, however we still need to clamp it to whatever can fit in the cache.
+
+            This will also be used as the basis for determining how many input frames to read. This is
+            not ideal because it can result in too many input frames being read which introduces latency.
+            To solve this, nodes can implement an optional callback called onGetRequiredInputFrameCount
+            which is used as hint to miniaudio as to how many input frames it needs to read at a time. This
+            callback is completely optional, and if it's not set, miniaudio will assume `frameCount`.
+
+            This function will be called multiple times for each period of time, once for each output node.
+            We cannot read from each input node each time this function is called. Instead we need to check
+            whether or not this is first output bus to be read from for this time period, and if so, read
+            from our input data.
+
+            To determine whether or not we're ready to read data, we check a flag. There will be one flag
+            for each output. When the flag is set, it means data has been read previously and that we're
+            ready to advance time forward for our input nodes by reading fresh data.
+            */
+            framesToProcessOut = frameCount;
+            if (framesToProcessOut > pNodeBase->cachedDataCapInFramesPerBus) {
+                framesToProcessOut = pNodeBase->cachedDataCapInFramesPerBus;
+            }
+
+            framesToProcessIn  = frameCount;
+            if (pNodeBase->vtable->onGetRequiredInputFrameCount) {
+                pNodeBase->vtable->onGetRequiredInputFrameCount(pNode, framesToProcessOut, &framesToProcessIn); /* <-- It does not matter if this fails. */
+            }
+            if (framesToProcessIn > pNodeBase->cachedDataCapInFramesPerBus) {
+                framesToProcessIn = pNodeBase->cachedDataCapInFramesPerBus;
+            }
+
+
+            MA_ASSERT(framesToProcessIn  <= 0xFFFF);
+            MA_ASSERT(framesToProcessOut <= 0xFFFF);
+
+            if (ma_node_output_bus_has_read(&pNodeBase->pOutputBuses[outputBusIndex])) {
+                /* Getting here means we need to do another round of processing. */
+                pNodeBase->cachedFrameCountOut = 0;
+
+                for (;;) {
+                    frameCountOut = 0;
+
+                    /*
+                    We need to prepare our output frame pointers for processing. In the same iteration we need
+                    to mark every output bus as unread so that future calls to this function for different buses
+                    for the current time period don't pull in data when they should instead be reading from cache.
+                    */
+                    for (iOutputBus = 0; iOutputBus < outputBusCount; iOutputBus += 1) {
+                        ma_node_output_bus_set_has_read(&pNodeBase->pOutputBuses[iOutputBus], MA_FALSE); /* <-- This is what tells the next calls to this function for other output buses for this time period to read from cache instead of pulling in more data. */
+                        ppFramesOut[iOutputBus] = ma_node_get_cached_output_ptr(pNode, iOutputBus);
+                    }
+
+                    /* We only need to read from input buses if there isn't already some data in the cache. */
+                    if (pNodeBase->cachedFrameCountIn == 0) {
+                        ma_uint32 maxFramesReadIn = 0;
+
+                        /* Here is where we pull in data from the input buses. This is what will trigger an advance in time. */
+                        for (iInputBus = 0; iInputBus < inputBusCount; iInputBus += 1) {
+                            ma_uint32 framesRead;
+
+                            /* The first thing to do is get the offset within our bulk allocation to store this input data. */
+                            ppFramesIn[iInputBus] = ma_node_get_cached_input_ptr(pNode, iInputBus);
+
+                            /* Once we've determined our destination pointer we can read. Note that we must inspect the number of frames read and fill any leftovers with silence for safety. */
+                            result = ma_node_input_bus_read_pcm_frames(pNodeBase, &pNodeBase->pInputBuses[iInputBus], ppFramesIn[iInputBus], framesToProcessIn, &framesRead, globalTime);
+                            if (result != MA_SUCCESS) {
+                                /* It doesn't really matter if we fail because we'll just fill with silence. */
+                                framesRead = 0; /* Just for safety, but I don't think it's really needed. */
+                            }
+
+                            /* TODO: Minor optimization opportunity here. If no frames were read and the buffer is already filled with silence, no need to re-silence it. */
+                            /* Any leftover frames need to silenced for safety. */
+                            if (framesRead < framesToProcessIn) {
+                                ma_silence_pcm_frames(ppFramesIn[iInputBus] + (framesRead * ma_node_get_input_channels(pNodeBase, iInputBus)), (framesToProcessIn - framesRead), ma_format_f32, ma_node_get_input_channels(pNodeBase, iInputBus));
+                            }
+
+                            maxFramesReadIn = ma_max(maxFramesReadIn, framesRead);
+                        }
+
+                        /* This was a fresh load of input data so reset our consumption counter. */
+                        pNodeBase->consumedFrameCountIn = 0;
+
+                        /*
+                        We don't want to keep processing if there's nothing to process, so set the number of cached
+                        input frames to the maximum number we read from each attachment (the lesser will be padded
+                        with silence). If we didn't read anything, this will be set to 0 and the entire buffer will
+                        have been assigned to silence. This being equal to 0 is an important property for us because
+                        it allows us to detect when NULL can be passed into the processing callback for the input
+                        buffer for the purpose of continuous processing.
+                        */
+                        pNodeBase->cachedFrameCountIn = (ma_uint16)maxFramesReadIn;
+                    } else {
+                        /* We don't need to read anything, but we do need to prepare our input frame pointers. */
+                        for (iInputBus = 0; iInputBus < inputBusCount; iInputBus += 1) {
+                            ppFramesIn[iInputBus] = ma_node_get_cached_input_ptr(pNode, iInputBus) + (pNodeBase->consumedFrameCountIn * ma_node_get_input_channels(pNodeBase, iInputBus));
+                        }
+                    }
+
+                    /*
+                    At this point we have our input data so now we need to do some processing. Sneaky little
+                    optimization here - we can set the pointer to the output buffer for this output bus so
+                    that the final copy into the output buffer is done directly by onProcess().
+                    */
+                    if (pFramesOut != NULL) {
+                        ppFramesOut[outputBusIndex] = ma_offset_pcm_frames_ptr_f32(pFramesOut, pNodeBase->cachedFrameCountOut, ma_node_get_output_channels(pNode, outputBusIndex));
+                    }
+
+
+                    /* Give the processing function the entire capacity of the output buffer. */
+                    frameCountOut = (framesToProcessOut - pNodeBase->cachedFrameCountOut);
+
+                    /*
+                    We need to treat nodes with continuous processing a little differently. For these ones,
+                    we always want to fire the callback with the requested number of frames, regardless of
+                    pNodeBase->cachedFrameCountIn, which could be 0. Also, we want to check if we can pass
+                    in NULL for the input buffer to the callback.
+                    */
+                    if ((pNodeBase->vtable->flags & MA_NODE_FLAG_CONTINUOUS_PROCESSING) != 0) {
+                        /* We're using continuous processing. Make sure we specify the whole frame count at all times. */
+                        frameCountIn = framesToProcessIn;    /* Give the processing function as much input data as we've got in the buffer, including any silenced padding from short reads. */
+
+                        if ((pNodeBase->vtable->flags & MA_NODE_FLAG_ALLOW_NULL_INPUT) != 0 && pNodeBase->consumedFrameCountIn == 0 && pNodeBase->cachedFrameCountIn == 0) {
+                            consumeNullInput = MA_TRUE;
+                        } else {
+                            consumeNullInput = MA_FALSE;
+                        }
+
+                        /*
+                        Since we're using continuous processing we're always passing in a full frame count
+                        regardless of how much input data was read. If this is greater than what we read as
+                        input, we'll end up with an underflow. We instead need to make sure our cached frame
+                        count is set to the number of frames we'll be passing to the data callback. Not
+                        doing this will result in an underflow when we "consume" the cached data later on.
+
+                        Note that this check needs to be done after the "consumeNullInput" check above because
+                        we use the property of cachedFrameCountIn being 0 to determine whether or not we
+                        should be passing in a null pointer to the processing callback for when the node is
+                        configured with MA_NODE_FLAG_ALLOW_NULL_INPUT.
+                        */
+                        if (pNodeBase->cachedFrameCountIn < (ma_uint16)frameCountIn) {
+                            pNodeBase->cachedFrameCountIn = (ma_uint16)frameCountIn;
+                        }
+                    } else {
+                        frameCountIn = pNodeBase->cachedFrameCountIn;  /* Give the processing function as much valid input data as we've got. */
+                        consumeNullInput = MA_FALSE;
+                    }
+
+                    /*
+                    Process data slightly differently depending on whether or not we're consuming NULL
+                    input (checked just above).
+                    */
+                    if (consumeNullInput) {
+                        ma_node_process_pcm_frames_internal(pNode, NULL, &frameCountIn, ppFramesOut, &frameCountOut);
+                    } else {
+                        /*
+                        We want to skip processing if there's no input data, but we can only do that safely if
+                        we know that there is no chance of any output frames being produced. If continuous
+                        processing is being used, this won't be a problem because the input frame count will
+                        always be non-0. However, if continuous processing is *not* enabled and input and output
+                        data is processed at different rates, we still need to process that last input frame
+                        because there could be a few excess output frames needing to be produced from cached
+                        data. The `MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES` flag is used as the indicator for
+                        determining whether or not we need to process the node even when there are no input
+                        frames available right now.
+                        */
+                        if (frameCountIn > 0 || (pNodeBase->vtable->flags & MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES) != 0) {
+                            ma_node_process_pcm_frames_internal(pNode, (const float**)ppFramesIn, &frameCountIn, ppFramesOut, &frameCountOut);    /* From GCC: expected 'const float **' but argument is of type 'float **'. Shouldn't this be implicit? Excplicit cast to silence the warning. */
+                        } else {
+                            frameCountOut = 0;  /* No data was processed. */
+                        }
+                    }
+
+                    /*
+                    Thanks to our sneaky optimization above we don't need to do any data copying directly into
+                    the output buffer - the onProcess() callback just did that for us. We do, however, need to
+                    apply the number of input and output frames that were processed. Note that due to continuous
+                    processing above, we need to do explicit checks here. If we just consumed a NULL input
+                    buffer it means that no actual input data was processed from the internal buffers and we
+                    don't want to be modifying any counters.
+                    */
+                    if (consumeNullInput == MA_FALSE) {
+                        pNodeBase->consumedFrameCountIn += (ma_uint16)frameCountIn;
+                        pNodeBase->cachedFrameCountIn   -= (ma_uint16)frameCountIn;
+                    }
+
+                    /* The cached output frame count is always equal to what we just read. */
+                    pNodeBase->cachedFrameCountOut += (ma_uint16)frameCountOut;
+
+                    /* If we couldn't process any data, we're done. The loop needs to be terminated here or else we'll get stuck in a loop. */
+                    if (pNodeBase->cachedFrameCountOut == framesToProcessOut || (frameCountOut == 0 && frameCountIn == 0)) {
+                        break;
+                    }
+                }
+            } else {
+                /*
+                We're not needing to read anything from the input buffer so just read directly from our
+                already-processed data.
+                */
+                if (pFramesOut != NULL) {
+                    ma_copy_pcm_frames(pFramesOut, ma_node_get_cached_output_ptr(pNodeBase, outputBusIndex), pNodeBase->cachedFrameCountOut, ma_format_f32, ma_node_get_output_channels(pNodeBase, outputBusIndex));
+                }
+            }
+
+            /* The number of frames read is always equal to the number of cached output frames. */
+            totalFramesRead = pNodeBase->cachedFrameCountOut;
+
+            /* Now that we've read the data, make sure our read flag is set. */
+            ma_node_output_bus_set_has_read(&pNodeBase->pOutputBuses[outputBusIndex], MA_TRUE);
+        }
+    }
+
+    /* Apply volume, if necessary. */
+    ma_apply_volume_factor_f32(pFramesOut, totalFramesRead * ma_node_get_output_channels(pNodeBase, outputBusIndex), ma_node_output_bus_get_volume(&pNodeBase->pOutputBuses[outputBusIndex]));
+
+    /* Advance our local time forward. */
+    ma_atomic_fetch_add_64(&pNodeBase->localTime, (ma_uint64)totalFramesRead);
+
+    *pFramesRead = totalFramesRead + timeOffsetBeg; /* Must include the silenced section at the start of the buffer. */
+    return result;
+}
+
+
+
+
+/* Data source node. */
+MA_API ma_data_source_node_config ma_data_source_node_config_init(ma_data_source* pDataSource)
+{
+    ma_data_source_node_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.nodeConfig  = ma_node_config_init();
+    config.pDataSource = pDataSource;
+
+    return config;
+}
+
+
+static void ma_data_source_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_data_source_node* pDataSourceNode = (ma_data_source_node*)pNode;
+    ma_format format;
+    ma_uint32 channels;
+    ma_uint32 frameCount;
+    ma_uint64 framesRead = 0;
+
+    MA_ASSERT(pDataSourceNode != NULL);
+    MA_ASSERT(pDataSourceNode->pDataSource != NULL);
+    MA_ASSERT(ma_node_get_input_bus_count(pDataSourceNode)  == 0);
+    MA_ASSERT(ma_node_get_output_bus_count(pDataSourceNode) == 1);
+
+    /* We don't want to read from ppFramesIn at all. Instead we read from the data source. */
+    (void)ppFramesIn;
+    (void)pFrameCountIn;
+
+    frameCount = *pFrameCountOut;
+
+    /* miniaudio should never be calling this with a frame count of zero. */
+    MA_ASSERT(frameCount > 0);
+
+    if (ma_data_source_get_data_format(pDataSourceNode->pDataSource, &format, &channels, NULL, NULL, 0) == MA_SUCCESS) { /* <-- Don't care about sample rate here. */
+        /* The node graph system requires samples be in floating point format. This is checked in ma_data_source_node_init(). */
+        MA_ASSERT(format == ma_format_f32);
+        (void)format;   /* Just to silence some static analysis tools. */
+
+        ma_data_source_read_pcm_frames(pDataSourceNode->pDataSource, ppFramesOut[0], frameCount, &framesRead);
+    }
+
+    *pFrameCountOut = (ma_uint32)framesRead;
+}
+
+static ma_node_vtable g_ma_data_source_node_vtable =
+{
+    ma_data_source_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    0,      /* 0 input buses. */
+    1,      /* 1 output bus. */
+    0
+};
+
+MA_API ma_result ma_data_source_node_init(ma_node_graph* pNodeGraph, const ma_data_source_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source_node* pDataSourceNode)
+{
+    ma_result result;
+    ma_format format;   /* For validating the format, which must be ma_format_f32. */
+    ma_uint32 channels; /* For specifying the channel count of the output bus. */
+    ma_node_config baseConfig;
+
+    if (pDataSourceNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDataSourceNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    result = ma_data_source_get_data_format(pConfig->pDataSource, &format, &channels, NULL, NULL, 0);    /* Don't care about sample rate. This will check pDataSource for NULL. */
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    MA_ASSERT(format == ma_format_f32); /* <-- If you've triggered this it means your data source is not outputting floating-point samples. You must configure your data source to use ma_format_f32. */
+    if (format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* Invalid format. */
+    }
+
+    /* The channel count is defined by the data source. If the caller has manually changed the channels we just ignore it. */
+    baseConfig = pConfig->nodeConfig;
+    baseConfig.vtable = &g_ma_data_source_node_vtable;  /* Explicitly set the vtable here to prevent callers from setting it incorrectly. */
+
+    /*
+    The channel count is defined by the data source. It is invalid for the caller to manually set
+    the channel counts in the config. `ma_data_source_node_config_init()` will have defaulted the
+    channel count pointer to NULL which is how it must remain. If you trigger any of these asserts
+    it means you're explicitly setting the channel count. Instead, configure the output channel
+    count of your data source to be the necessary channel count.
+    */
+    if (baseConfig.pOutputChannels != NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    baseConfig.pOutputChannels = &channels;
+
+    result = ma_node_init(pNodeGraph, &baseConfig, pAllocationCallbacks, &pDataSourceNode->base);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    pDataSourceNode->pDataSource = pConfig->pDataSource;
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_data_source_node_uninit(ma_data_source_node* pDataSourceNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_node_uninit(&pDataSourceNode->base, pAllocationCallbacks);
+}
+
+MA_API ma_result ma_data_source_node_set_looping(ma_data_source_node* pDataSourceNode, ma_bool32 isLooping)
+{
+    if (pDataSourceNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_data_source_set_looping(pDataSourceNode->pDataSource, isLooping);
+}
+
+MA_API ma_bool32 ma_data_source_node_is_looping(ma_data_source_node* pDataSourceNode)
+{
+    if (pDataSourceNode == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_data_source_is_looping(pDataSourceNode->pDataSource);
+}
+
+
+
+/* Splitter Node. */
+MA_API ma_splitter_node_config ma_splitter_node_config_init(ma_uint32 channels)
+{
+    ma_splitter_node_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.nodeConfig     = ma_node_config_init();
+    config.channels       = channels;
+    config.outputBusCount = 2;
+
+    return config;
+}
+
+
+static void ma_splitter_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_node_base* pNodeBase = (ma_node_base*)pNode;
+    ma_uint32 iOutputBus;
+    ma_uint32 channels;
+
+    MA_ASSERT(pNodeBase != NULL);
+    MA_ASSERT(ma_node_get_input_bus_count(pNodeBase) == 1);
+
+    /* We don't need to consider the input frame count - it'll be the same as the output frame count and we process everything. */
+    (void)pFrameCountIn;
+
+    /* NOTE: This assumes the same number of channels for all inputs and outputs. This was checked in ma_splitter_node_init(). */
+    channels = ma_node_get_input_channels(pNodeBase, 0);
+
+    /* Splitting is just copying the first input bus and copying it over to each output bus. */
+    for (iOutputBus = 0; iOutputBus < ma_node_get_output_bus_count(pNodeBase); iOutputBus += 1) {
+        ma_copy_pcm_frames(ppFramesOut[iOutputBus], ppFramesIn[0], *pFrameCountOut, ma_format_f32, channels);
+    }
+}
+
+static ma_node_vtable g_ma_splitter_node_vtable =
+{
+    ma_splitter_node_process_pcm_frames,
+    NULL,                       /* onGetRequiredInputFrameCount */
+    1,                          /* 1 input bus. */
+    MA_NODE_BUS_COUNT_UNKNOWN,  /* The output bus count is specified on a per-node basis. */
+    0
+};
+
+MA_API ma_result ma_splitter_node_init(ma_node_graph* pNodeGraph, const ma_splitter_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_splitter_node* pSplitterNode)
+{
+    ma_result result;
+    ma_node_config baseConfig;
+    ma_uint32 pInputChannels[1];
+    ma_uint32 pOutputChannels[MA_MAX_NODE_BUS_COUNT];
+    ma_uint32 iOutputBus;
+
+    if (pSplitterNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pSplitterNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->outputBusCount > MA_MAX_NODE_BUS_COUNT) {
+        return MA_INVALID_ARGS; /* Too many output buses. */
+    }
+
+    /* Splitters require the same number of channels between inputs and outputs. */
+    pInputChannels[0]  = pConfig->channels;
+    for (iOutputBus = 0; iOutputBus < pConfig->outputBusCount; iOutputBus += 1) {
+        pOutputChannels[iOutputBus] = pConfig->channels;
+    }
+
+    baseConfig = pConfig->nodeConfig;
+    baseConfig.vtable = &g_ma_splitter_node_vtable;
+    baseConfig.pInputChannels  = pInputChannels;
+    baseConfig.pOutputChannels = pOutputChannels;
+    baseConfig.outputBusCount  = pConfig->outputBusCount;
+
+    result = ma_node_init(pNodeGraph, &baseConfig, pAllocationCallbacks, &pSplitterNode->base);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to initialize the base node. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API void ma_splitter_node_uninit(ma_splitter_node* pSplitterNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_node_uninit(pSplitterNode, pAllocationCallbacks);
+}
+
+
+/*
+Biquad Node
+*/
+MA_API ma_biquad_node_config ma_biquad_node_config_init(ma_uint32 channels, float b0, float b1, float b2, float a0, float a1, float a2)
+{
+    ma_biquad_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.biquad = ma_biquad_config_init(ma_format_f32, channels, b0, b1, b2, a0, a1, a2);
+
+    return config;
+}
+
+static void ma_biquad_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_biquad_node* pLPFNode = (ma_biquad_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_biquad_process_pcm_frames(&pLPFNode->biquad, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_biquad_node_vtable =
+{
+    ma_biquad_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_biquad_node_init(ma_node_graph* pNodeGraph, const ma_biquad_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_biquad_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->biquad.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_biquad_init(&pConfig->biquad, pAllocationCallbacks, &pNode->biquad);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_biquad_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->biquad.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->biquad.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_biquad_node_reinit(const ma_biquad_config* pConfig, ma_biquad_node* pNode)
+{
+    ma_biquad_node* pLPFNode = (ma_biquad_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+
+    return ma_biquad_reinit(pConfig, &pLPFNode->biquad);
+}
+
+MA_API void ma_biquad_node_uninit(ma_biquad_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_biquad_node* pLPFNode = (ma_biquad_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_biquad_uninit(&pLPFNode->biquad, pAllocationCallbacks);
+}
+
+
+
+/*
+Low Pass Filter Node
+*/
+MA_API ma_lpf_node_config ma_lpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_lpf_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.lpf = ma_lpf_config_init(ma_format_f32, channels, sampleRate, cutoffFrequency, order);
+
+    return config;
+}
+
+static void ma_lpf_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_lpf_node* pLPFNode = (ma_lpf_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_lpf_process_pcm_frames(&pLPFNode->lpf, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_lpf_node_vtable =
+{
+    ma_lpf_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_lpf_node_init(ma_node_graph* pNodeGraph, const ma_lpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->lpf.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_lpf_init(&pConfig->lpf, pAllocationCallbacks, &pNode->lpf);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_lpf_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->lpf.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->lpf.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_lpf_node_reinit(const ma_lpf_config* pConfig, ma_lpf_node* pNode)
+{
+    ma_lpf_node* pLPFNode = (ma_lpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_lpf_reinit(pConfig, &pLPFNode->lpf);
+}
+
+MA_API void ma_lpf_node_uninit(ma_lpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_lpf_node* pLPFNode = (ma_lpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_lpf_uninit(&pLPFNode->lpf, pAllocationCallbacks);
+}
+
+
+
+/*
+High Pass Filter Node
+*/
+MA_API ma_hpf_node_config ma_hpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_hpf_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.hpf = ma_hpf_config_init(ma_format_f32, channels, sampleRate, cutoffFrequency, order);
+
+    return config;
+}
+
+static void ma_hpf_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_hpf_node* pHPFNode = (ma_hpf_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_hpf_process_pcm_frames(&pHPFNode->hpf, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_hpf_node_vtable =
+{
+    ma_hpf_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_hpf_node_init(ma_node_graph* pNodeGraph, const ma_hpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hpf_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->hpf.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_hpf_init(&pConfig->hpf, pAllocationCallbacks, &pNode->hpf);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_hpf_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->hpf.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->hpf.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_hpf_node_reinit(const ma_hpf_config* pConfig, ma_hpf_node* pNode)
+{
+    ma_hpf_node* pHPFNode = (ma_hpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_hpf_reinit(pConfig, &pHPFNode->hpf);
+}
+
+MA_API void ma_hpf_node_uninit(ma_hpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_hpf_node* pHPFNode = (ma_hpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_hpf_uninit(&pHPFNode->hpf, pAllocationCallbacks);
+}
+
+
+
+
+/*
+Band Pass Filter Node
+*/
+MA_API ma_bpf_node_config ma_bpf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, ma_uint32 order)
+{
+    ma_bpf_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.bpf = ma_bpf_config_init(ma_format_f32, channels, sampleRate, cutoffFrequency, order);
+
+    return config;
+}
+
+static void ma_bpf_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_bpf_node* pBPFNode = (ma_bpf_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_bpf_process_pcm_frames(&pBPFNode->bpf, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_bpf_node_vtable =
+{
+    ma_bpf_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_bpf_node_init(ma_node_graph* pNodeGraph, const ma_bpf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_bpf_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->bpf.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_bpf_init(&pConfig->bpf, pAllocationCallbacks, &pNode->bpf);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_bpf_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->bpf.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->bpf.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_bpf_node_reinit(const ma_bpf_config* pConfig, ma_bpf_node* pNode)
+{
+    ma_bpf_node* pBPFNode = (ma_bpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_bpf_reinit(pConfig, &pBPFNode->bpf);
+}
+
+MA_API void ma_bpf_node_uninit(ma_bpf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bpf_node* pBPFNode = (ma_bpf_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_bpf_uninit(&pBPFNode->bpf, pAllocationCallbacks);
+}
+
+
+
+/*
+Notching Filter Node
+*/
+MA_API ma_notch_node_config ma_notch_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double q, double frequency)
+{
+    ma_notch_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.notch = ma_notch2_config_init(ma_format_f32, channels, sampleRate, q, frequency);
+
+    return config;
+}
+
+static void ma_notch_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_notch_node* pBPFNode = (ma_notch_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_notch2_process_pcm_frames(&pBPFNode->notch, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_notch_node_vtable =
+{
+    ma_notch_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_notch_node_init(ma_node_graph* pNodeGraph, const ma_notch_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_notch_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->notch.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_notch2_init(&pConfig->notch, pAllocationCallbacks, &pNode->notch);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_notch_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->notch.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->notch.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_notch_node_reinit(const ma_notch_config* pConfig, ma_notch_node* pNode)
+{
+    ma_notch_node* pNotchNode = (ma_notch_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_notch2_reinit(pConfig, &pNotchNode->notch);
+}
+
+MA_API void ma_notch_node_uninit(ma_notch_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_notch_node* pNotchNode = (ma_notch_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_notch2_uninit(&pNotchNode->notch, pAllocationCallbacks);
+}
+
+
+
+/*
+Peaking Filter Node
+*/
+MA_API ma_peak_node_config ma_peak_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency)
+{
+    ma_peak_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.peak = ma_peak2_config_init(ma_format_f32, channels, sampleRate, gainDB, q, frequency);
+
+    return config;
+}
+
+static void ma_peak_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_peak_node* pBPFNode = (ma_peak_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_peak2_process_pcm_frames(&pBPFNode->peak, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_peak_node_vtable =
+{
+    ma_peak_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_peak_node_init(ma_node_graph* pNodeGraph, const ma_peak_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_peak_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->peak.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_peak2_init(&pConfig->peak, pAllocationCallbacks, &pNode->peak);
+    if (result != MA_SUCCESS) {
+        ma_node_uninit(pNode, pAllocationCallbacks);
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_peak_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->peak.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->peak.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_peak_node_reinit(const ma_peak_config* pConfig, ma_peak_node* pNode)
+{
+    ma_peak_node* pPeakNode = (ma_peak_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_peak2_reinit(pConfig, &pPeakNode->peak);
+}
+
+MA_API void ma_peak_node_uninit(ma_peak_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_peak_node* pPeakNode = (ma_peak_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_peak2_uninit(&pPeakNode->peak, pAllocationCallbacks);
+}
+
+
+
+/*
+Low Shelf Filter Node
+*/
+MA_API ma_loshelf_node_config ma_loshelf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency)
+{
+    ma_loshelf_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.loshelf = ma_loshelf2_config_init(ma_format_f32, channels, sampleRate, gainDB, q, frequency);
+
+    return config;
+}
+
+static void ma_loshelf_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_loshelf_node* pBPFNode = (ma_loshelf_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_loshelf2_process_pcm_frames(&pBPFNode->loshelf, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_loshelf_node_vtable =
+{
+    ma_loshelf_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_loshelf_node_init(ma_node_graph* pNodeGraph, const ma_loshelf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_loshelf_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->loshelf.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_loshelf2_init(&pConfig->loshelf, pAllocationCallbacks, &pNode->loshelf);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_loshelf_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->loshelf.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->loshelf.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_loshelf_node_reinit(const ma_loshelf_config* pConfig, ma_loshelf_node* pNode)
+{
+    ma_loshelf_node* pLoshelfNode = (ma_loshelf_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_loshelf2_reinit(pConfig, &pLoshelfNode->loshelf);
+}
+
+MA_API void ma_loshelf_node_uninit(ma_loshelf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_loshelf_node* pLoshelfNode = (ma_loshelf_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_loshelf2_uninit(&pLoshelfNode->loshelf, pAllocationCallbacks);
+}
+
+
+
+/*
+High Shelf Filter Node
+*/
+MA_API ma_hishelf_node_config ma_hishelf_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, double gainDB, double q, double frequency)
+{
+    ma_hishelf_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.hishelf = ma_hishelf2_config_init(ma_format_f32, channels, sampleRate, gainDB, q, frequency);
+
+    return config;
+}
+
+static void ma_hishelf_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_hishelf_node* pBPFNode = (ma_hishelf_node*)pNode;
+
+    MA_ASSERT(pNode != NULL);
+    (void)pFrameCountIn;
+
+    ma_hishelf2_process_pcm_frames(&pBPFNode->hishelf, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_hishelf_node_vtable =
+{
+    ma_hishelf_node_process_pcm_frames,
+    NULL,   /* onGetRequiredInputFrameCount */
+    1,      /* One input. */
+    1,      /* One output. */
+    0       /* Default flags. */
+};
+
+MA_API ma_result ma_hishelf_node_init(ma_node_graph* pNodeGraph, const ma_hishelf_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_hishelf_node* pNode)
+{
+    ma_result result;
+    ma_node_config baseNodeConfig;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pNode);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->hishelf.format != ma_format_f32) {
+        return MA_INVALID_ARGS; /* The format must be f32. */
+    }
+
+    result = ma_hishelf2_init(&pConfig->hishelf, pAllocationCallbacks, &pNode->hishelf);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseNodeConfig = ma_node_config_init();
+    baseNodeConfig.vtable          = &g_ma_hishelf_node_vtable;
+    baseNodeConfig.pInputChannels  = &pConfig->hishelf.channels;
+    baseNodeConfig.pOutputChannels = &pConfig->hishelf.channels;
+
+    result = ma_node_init(pNodeGraph, &baseNodeConfig, pAllocationCallbacks, pNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return result;
+}
+
+MA_API ma_result ma_hishelf_node_reinit(const ma_hishelf_config* pConfig, ma_hishelf_node* pNode)
+{
+    ma_hishelf_node* pHishelfNode = (ma_hishelf_node*)pNode;
+
+    if (pNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_hishelf2_reinit(pConfig, &pHishelfNode->hishelf);
+}
+
+MA_API void ma_hishelf_node_uninit(ma_hishelf_node* pNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_hishelf_node* pHishelfNode = (ma_hishelf_node*)pNode;
+
+    if (pNode == NULL) {
+        return;
+    }
+
+    ma_node_uninit(pNode, pAllocationCallbacks);
+    ma_hishelf2_uninit(&pHishelfNode->hishelf, pAllocationCallbacks);
+}
+
+
+
+
+MA_API ma_delay_node_config ma_delay_node_config_init(ma_uint32 channels, ma_uint32 sampleRate, ma_uint32 delayInFrames, float decay)
+{
+    ma_delay_node_config config;
+
+    config.nodeConfig = ma_node_config_init();
+    config.delay = ma_delay_config_init(channels, sampleRate, delayInFrames, decay);
+
+    return config;
+}
+
+
+static void ma_delay_node_process_pcm_frames(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_delay_node* pDelayNode = (ma_delay_node*)pNode;
+
+    (void)pFrameCountIn;
+
+    ma_delay_process_pcm_frames(&pDelayNode->delay, ppFramesOut[0], ppFramesIn[0], *pFrameCountOut);
+}
+
+static ma_node_vtable g_ma_delay_node_vtable =
+{
+    ma_delay_node_process_pcm_frames,
+    NULL,
+    1,  /* 1 input channels. */
+    1,  /* 1 output channel. */
+    MA_NODE_FLAG_CONTINUOUS_PROCESSING  /* Delay requires continuous processing to ensure the tail get's processed. */
+};
+
+MA_API ma_result ma_delay_node_init(ma_node_graph* pNodeGraph, const ma_delay_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_delay_node* pDelayNode)
+{
+    ma_result result;
+    ma_node_config baseConfig;
+
+    if (pDelayNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pDelayNode);
+
+    result = ma_delay_init(&pConfig->delay, pAllocationCallbacks, &pDelayNode->delay);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    baseConfig = pConfig->nodeConfig;
+    baseConfig.vtable          = &g_ma_delay_node_vtable;
+    baseConfig.pInputChannels  = &pConfig->delay.channels;
+    baseConfig.pOutputChannels = &pConfig->delay.channels;
+
+    result = ma_node_init(pNodeGraph, &baseConfig, pAllocationCallbacks, &pDelayNode->baseNode);
+    if (result != MA_SUCCESS) {
+        ma_delay_uninit(&pDelayNode->delay, pAllocationCallbacks);
+        return result;
+    }
+
+    return result;
+}
+
+MA_API void ma_delay_node_uninit(ma_delay_node* pDelayNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pDelayNode == NULL) {
+        return;
+    }
+
+    /* The base node is always uninitialized first. */
+    ma_node_uninit(pDelayNode, pAllocationCallbacks);
+    ma_delay_uninit(&pDelayNode->delay, pAllocationCallbacks);
+}
+
+MA_API void ma_delay_node_set_wet(ma_delay_node* pDelayNode, float value)
+{
+    if (pDelayNode == NULL) {
+        return;
+    }
+
+    ma_delay_set_wet(&pDelayNode->delay, value);
+}
+
+MA_API float ma_delay_node_get_wet(const ma_delay_node* pDelayNode)
+{
+    if (pDelayNode == NULL) {
+        return 0;
+    }
+
+    return ma_delay_get_wet(&pDelayNode->delay);
+}
+
+MA_API void ma_delay_node_set_dry(ma_delay_node* pDelayNode, float value)
+{
+    if (pDelayNode == NULL) {
+        return;
+    }
+
+    ma_delay_set_dry(&pDelayNode->delay, value);
+}
+
+MA_API float ma_delay_node_get_dry(const ma_delay_node* pDelayNode)
+{
+    if (pDelayNode == NULL) {
+        return 0;
+    }
+
+    return ma_delay_get_dry(&pDelayNode->delay);
+}
+
+MA_API void ma_delay_node_set_decay(ma_delay_node* pDelayNode, float value)
+{
+    if (pDelayNode == NULL) {
+        return;
+    }
+
+    ma_delay_set_decay(&pDelayNode->delay, value);
+}
+
+MA_API float ma_delay_node_get_decay(const ma_delay_node* pDelayNode)
+{
+    if (pDelayNode == NULL) {
+        return 0;
+    }
+
+    return ma_delay_get_decay(&pDelayNode->delay);
+}
+#endif  /* MA_NO_NODE_GRAPH */
+
+
+/* SECTION: miniaudio_engine.c */
+#if !defined(MA_NO_ENGINE) && !defined(MA_NO_NODE_GRAPH)
+/**************************************************************************************************************************************************************
+
+Engine
+
+**************************************************************************************************************************************************************/
+#define MA_SEEK_TARGET_NONE         (~(ma_uint64)0)
+
+
+static void ma_sound_set_at_end(ma_sound* pSound, ma_bool32 atEnd)
+{
+    MA_ASSERT(pSound != NULL);
+    ma_atomic_exchange_32(&pSound->atEnd, atEnd);
+
+    /* Fire any callbacks or events. */
+    if (atEnd) {
+        if (pSound->endCallback != NULL) {
+            pSound->endCallback(pSound->pEndCallbackUserData, pSound);
+        }
+    }
+}
+
+static ma_bool32 ma_sound_get_at_end(const ma_sound* pSound)
+{
+    MA_ASSERT(pSound != NULL);
+    return ma_atomic_load_32(&pSound->atEnd);
+}
+
+
+MA_API ma_engine_node_config ma_engine_node_config_init(ma_engine* pEngine, ma_engine_node_type type, ma_uint32 flags)
+{
+    ma_engine_node_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.pEngine                  = pEngine;
+    config.type                     = type;
+    config.isPitchDisabled          = (flags & MA_SOUND_FLAG_NO_PITCH) != 0;
+    config.isSpatializationDisabled = (flags & MA_SOUND_FLAG_NO_SPATIALIZATION) != 0;
+    config.monoExpansionMode        = pEngine->monoExpansionMode;
+
+    return config;
+}
+
+
+static void ma_engine_node_update_pitch_if_required(ma_engine_node* pEngineNode)
+{
+    ma_bool32 isUpdateRequired = MA_FALSE;
+    float newPitch;
+
+    MA_ASSERT(pEngineNode != NULL);
+
+    newPitch = ma_atomic_load_explicit_f32(&pEngineNode->pitch, ma_atomic_memory_order_acquire);
+
+    if (pEngineNode->oldPitch != newPitch) {
+        pEngineNode->oldPitch  = newPitch;
+        isUpdateRequired = MA_TRUE;
+    }
+
+    if (pEngineNode->oldDopplerPitch != pEngineNode->spatializer.dopplerPitch) {
+        pEngineNode->oldDopplerPitch  = pEngineNode->spatializer.dopplerPitch;
+        isUpdateRequired = MA_TRUE;
+    }
+
+    if (isUpdateRequired) {
+        float basePitch = (float)pEngineNode->sampleRate / ma_engine_get_sample_rate(pEngineNode->pEngine);
+        ma_linear_resampler_set_rate_ratio(&pEngineNode->resampler, basePitch * pEngineNode->oldPitch * pEngineNode->oldDopplerPitch);
+    }
+}
+
+static ma_bool32 ma_engine_node_is_pitching_enabled(const ma_engine_node* pEngineNode)
+{
+    MA_ASSERT(pEngineNode != NULL);
+
+    /* Don't try to be clever by skiping resampling in the pitch=1 case or else you'll glitch when moving away from 1. */
+    return !ma_atomic_load_explicit_32(&pEngineNode->isPitchDisabled, ma_atomic_memory_order_acquire);
+}
+
+static ma_bool32 ma_engine_node_is_spatialization_enabled(const ma_engine_node* pEngineNode)
+{
+    MA_ASSERT(pEngineNode != NULL);
+
+    return !ma_atomic_load_explicit_32(&pEngineNode->isSpatializationDisabled, ma_atomic_memory_order_acquire);
+}
+
+static ma_uint64 ma_engine_node_get_required_input_frame_count(const ma_engine_node* pEngineNode, ma_uint64 outputFrameCount)
+{
+    ma_uint64 inputFrameCount = 0;
+
+    if (ma_engine_node_is_pitching_enabled(pEngineNode)) {
+        ma_result result = ma_linear_resampler_get_required_input_frame_count(&pEngineNode->resampler, outputFrameCount, &inputFrameCount);
+        if (result != MA_SUCCESS) {
+            inputFrameCount = 0;
+        }
+    } else {
+        inputFrameCount = outputFrameCount;    /* No resampling, so 1:1. */
+    }
+
+    return inputFrameCount;
+}
+
+static ma_result ma_engine_node_set_volume(ma_engine_node* pEngineNode, float volume)
+{
+    if (pEngineNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    ma_atomic_float_set(&pEngineNode->volume, volume);
+
+    /* If we're not smoothing we should bypass the volume gainer entirely. */
+    if (pEngineNode->volumeSmoothTimeInPCMFrames == 0) {
+        /* We should always have an active spatializer because it can be enabled and disabled dynamically. We can just use that for hodling our volume. */
+        ma_spatializer_set_master_volume(&pEngineNode->spatializer, volume);
+    } else {
+        /* We're using volume smoothing, so apply the master volume to the gainer. */
+        ma_gainer_set_gain(&pEngineNode->volumeGainer, volume);
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_engine_node_get_volume(const ma_engine_node* pEngineNode, float* pVolume)
+{
+    if (pVolume == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pVolume = 0.0f;
+
+    if (pEngineNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pVolume = ma_atomic_float_get((ma_atomic_float*)&pEngineNode->volume);
+
+    return MA_SUCCESS;
+}
+
+
+static void ma_engine_node_process_pcm_frames__general(ma_engine_node* pEngineNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    ma_uint32 frameCountIn;
+    ma_uint32 frameCountOut;
+    ma_uint32 totalFramesProcessedIn;
+    ma_uint32 totalFramesProcessedOut;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_bool32 isPitchingEnabled;
+    ma_bool32 isFadingEnabled;
+    ma_bool32 isSpatializationEnabled;
+    ma_bool32 isPanningEnabled;
+    ma_bool32 isVolumeSmoothingEnabled;
+
+    frameCountIn  = *pFrameCountIn;
+    frameCountOut = *pFrameCountOut;
+
+    channelsIn  = ma_spatializer_get_input_channels(&pEngineNode->spatializer);
+    channelsOut = ma_spatializer_get_output_channels(&pEngineNode->spatializer);
+
+    totalFramesProcessedIn  = 0;
+    totalFramesProcessedOut = 0;
+
+    /* Update the fader if applicable. */
+    {
+        ma_uint64 fadeLengthInFrames = ma_atomic_uint64_get(&pEngineNode->fadeSettings.fadeLengthInFrames);
+        if (fadeLengthInFrames != ~(ma_uint64)0) {
+            float fadeVolumeBeg = ma_atomic_float_get(&pEngineNode->fadeSettings.volumeBeg);
+            float fadeVolumeEnd = ma_atomic_float_get(&pEngineNode->fadeSettings.volumeEnd);
+            ma_int64 fadeStartOffsetInFrames = (ma_int64)ma_atomic_uint64_get(&pEngineNode->fadeSettings.absoluteGlobalTimeInFrames);
+            if (fadeStartOffsetInFrames == (ma_int64)(~(ma_uint64)0)) {
+                fadeStartOffsetInFrames = 0;
+            } else {
+                fadeStartOffsetInFrames -= ma_engine_get_time_in_pcm_frames(pEngineNode->pEngine);
+            }
+
+            ma_fader_set_fade_ex(&pEngineNode->fader, fadeVolumeBeg, fadeVolumeEnd, fadeLengthInFrames, fadeStartOffsetInFrames);
+
+            /* Reset the fade length so we don't erroneously apply it again. */
+            ma_atomic_uint64_set(&pEngineNode->fadeSettings.fadeLengthInFrames, ~(ma_uint64)0);
+        }
+    }
+
+    isPitchingEnabled        = ma_engine_node_is_pitching_enabled(pEngineNode);
+    isFadingEnabled          = pEngineNode->fader.volumeBeg != 1 || pEngineNode->fader.volumeEnd != 1;
+    isSpatializationEnabled  = ma_engine_node_is_spatialization_enabled(pEngineNode);
+    isPanningEnabled         = pEngineNode->panner.pan != 0 && channelsOut != 1;
+    isVolumeSmoothingEnabled = pEngineNode->volumeSmoothTimeInPCMFrames > 0;
+
+    /* Keep going while we've still got data available for processing. */
+    while (totalFramesProcessedOut < frameCountOut) {
+        /*
+        We need to process in a specific order. We always do resampling first because it's likely
+        we're going to be increasing the channel count after spatialization. Also, I want to do
+        fading based on the output sample rate.
+
+        We'll first read into a buffer from the resampler. Then we'll do all processing that
+        operates on the on the input channel count. We'll then get the spatializer to output to
+        the output buffer and then do all effects from that point directly in the output buffer
+        in-place.
+
+        Note that we're always running the resampler if pitching is enabled, even when the pitch
+        is 1. If we try to be clever and skip resampling when the pitch is 1, we'll get a glitch
+        when we move away from 1, back to 1, and then away from 1 again. We'll want to implement
+        any pitch=1 optimizations in the resampler itself.
+
+        There's a small optimization here that we'll utilize since it might be a fairly common
+        case. When the input and output channel counts are the same, we'll read straight into the
+        output buffer from the resampler and do everything in-place.
+        */
+        const float* pRunningFramesIn;
+        float* pRunningFramesOut;
+        float* pWorkingBuffer;   /* This is the buffer that we'll be processing frames in. This is in input channels. */
+        float temp[MA_DATA_CONVERTER_STACK_BUFFER_SIZE / sizeof(float)];
+        ma_uint32 tempCapInFrames = ma_countof(temp) / channelsIn;
+        ma_uint32 framesAvailableIn;
+        ma_uint32 framesAvailableOut;
+        ma_uint32 framesJustProcessedIn;
+        ma_uint32 framesJustProcessedOut;
+        ma_bool32 isWorkingBufferValid = MA_FALSE;
+
+        framesAvailableIn  = frameCountIn  - totalFramesProcessedIn;
+        framesAvailableOut = frameCountOut - totalFramesProcessedOut;
+
+        pRunningFramesIn  = ma_offset_pcm_frames_const_ptr_f32(ppFramesIn[0], totalFramesProcessedIn, channelsIn);
+        pRunningFramesOut = ma_offset_pcm_frames_ptr_f32(ppFramesOut[0], totalFramesProcessedOut, channelsOut);
+
+        if (channelsIn == channelsOut) {
+            /* Fast path. Channel counts are the same. No need for an intermediary input buffer. */
+            pWorkingBuffer = pRunningFramesOut;
+        } else {
+            /* Slow path. Channel counts are different. Need to use an intermediary input buffer. */
+            pWorkingBuffer = temp;
+            if (framesAvailableOut > tempCapInFrames) {
+                framesAvailableOut = tempCapInFrames;
+            }
+        }
+
+        /* First is resampler. */
+        if (isPitchingEnabled) {
+            ma_uint64 resampleFrameCountIn  = framesAvailableIn;
+            ma_uint64 resampleFrameCountOut = framesAvailableOut;
+
+            ma_linear_resampler_process_pcm_frames(&pEngineNode->resampler, pRunningFramesIn, &resampleFrameCountIn, pWorkingBuffer, &resampleFrameCountOut);
+            isWorkingBufferValid = MA_TRUE;
+
+            framesJustProcessedIn  = (ma_uint32)resampleFrameCountIn;
+            framesJustProcessedOut = (ma_uint32)resampleFrameCountOut;
+        } else {
+            framesJustProcessedIn  = ma_min(framesAvailableIn, framesAvailableOut);
+            framesJustProcessedOut = framesJustProcessedIn; /* When no resampling is being performed, the number of output frames is the same as input frames. */
+        }
+
+        /* Fading. */
+        if (isFadingEnabled) {
+            if (isWorkingBufferValid) {
+                ma_fader_process_pcm_frames(&pEngineNode->fader, pWorkingBuffer, pWorkingBuffer, framesJustProcessedOut);   /* In-place processing. */
+            } else {
+                ma_fader_process_pcm_frames(&pEngineNode->fader, pWorkingBuffer, pRunningFramesIn, framesJustProcessedOut);
+                isWorkingBufferValid = MA_TRUE;
+            }
+        }
+
+        /*
+        If we're using smoothing, we won't be applying volume via the spatializer, but instead from a ma_gainer. In this case
+        we'll want to apply our volume now.
+        */
+        if (isVolumeSmoothingEnabled) {
+            if (isWorkingBufferValid) {
+                ma_gainer_process_pcm_frames(&pEngineNode->volumeGainer, pWorkingBuffer, pWorkingBuffer, framesJustProcessedOut);
+            } else {
+                ma_gainer_process_pcm_frames(&pEngineNode->volumeGainer, pWorkingBuffer, pRunningFramesIn, framesJustProcessedOut);
+                isWorkingBufferValid = MA_TRUE;
+            }
+        }
+
+        /*
+        If at this point we still haven't actually done anything with the working buffer we need
+        to just read straight from the input buffer.
+        */
+        if (isWorkingBufferValid == MA_FALSE) {
+            pWorkingBuffer = (float*)pRunningFramesIn;  /* Naughty const cast, but it's safe at this point because we won't ever be writing to it from this point out. */
+        }
+
+        /* Spatialization. */
+        if (isSpatializationEnabled) {
+            ma_uint32 iListener;
+
+            /*
+            When determining the listener to use, we first check to see if the sound is pinned to a
+            specific listener. If so, we use that. Otherwise we just use the closest listener.
+            */
+            if (pEngineNode->pinnedListenerIndex != MA_LISTENER_INDEX_CLOSEST && pEngineNode->pinnedListenerIndex < ma_engine_get_listener_count(pEngineNode->pEngine)) {
+                iListener = pEngineNode->pinnedListenerIndex;
+            } else {
+                ma_vec3f spatializerPosition = ma_spatializer_get_position(&pEngineNode->spatializer);
+                iListener = ma_engine_find_closest_listener(pEngineNode->pEngine, spatializerPosition.x, spatializerPosition.y, spatializerPosition.z);
+            }
+
+            ma_spatializer_process_pcm_frames(&pEngineNode->spatializer, &pEngineNode->pEngine->listeners[iListener], pRunningFramesOut, pWorkingBuffer, framesJustProcessedOut);
+        } else {
+            /* No spatialization, but we still need to do channel conversion and master volume. */
+            float volume;
+            ma_engine_node_get_volume(pEngineNode, &volume);    /* Should never fail. */
+
+            if (channelsIn == channelsOut) {
+                /* No channel conversion required. Just copy straight to the output buffer. */
+                if (isVolumeSmoothingEnabled) {
+                    /* Volume has already been applied. Just copy straight to the output buffer. */
+                    ma_copy_pcm_frames(pRunningFramesOut, pWorkingBuffer, framesJustProcessedOut * channelsOut, ma_format_f32, channelsOut);
+                } else {
+                    /* Volume has not been applied yet. Copy and apply volume in the same pass. */
+                    ma_copy_and_apply_volume_factor_f32(pRunningFramesOut, pWorkingBuffer, framesJustProcessedOut * channelsOut, volume);
+                }
+            } else {
+                /* Channel conversion required. TODO: Add support for channel maps here. */
+                ma_channel_map_apply_f32(pRunningFramesOut, NULL, channelsOut, pWorkingBuffer, NULL, channelsIn, framesJustProcessedOut, ma_channel_mix_mode_simple, pEngineNode->monoExpansionMode);
+
+                /* If we're using smoothing, the volume will have already been applied. */
+                if (!isVolumeSmoothingEnabled) {
+                    ma_apply_volume_factor_f32(pRunningFramesOut, framesJustProcessedOut * channelsOut, volume);
+                }
+            }
+        }
+
+        /* At this point we can guarantee that the output buffer contains valid data. We can process everything in place now. */
+
+        /* Panning. */
+        if (isPanningEnabled) {
+            ma_panner_process_pcm_frames(&pEngineNode->panner, pRunningFramesOut, pRunningFramesOut, framesJustProcessedOut);   /* In-place processing. */
+        }
+
+        /* We're done for this chunk. */
+        totalFramesProcessedIn  += framesJustProcessedIn;
+        totalFramesProcessedOut += framesJustProcessedOut;
+
+        /* If we didn't process any output frames this iteration it means we've either run out of input data, or run out of room in the output buffer. */
+        if (framesJustProcessedOut == 0) {
+            break;
+        }
+    }
+
+    /* At this point we're done processing. */
+    *pFrameCountIn  = totalFramesProcessedIn;
+    *pFrameCountOut = totalFramesProcessedOut;
+}
+
+static void ma_engine_node_process_pcm_frames__sound(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    /* For sounds, we need to first read from the data source. Then we need to apply the engine effects (pan, pitch, fades, etc.). */
+    ma_result result = MA_SUCCESS;
+    ma_sound* pSound = (ma_sound*)pNode;
+    ma_uint32 frameCount = *pFrameCountOut;
+    ma_uint32 totalFramesRead = 0;
+    ma_format dataSourceFormat;
+    ma_uint32 dataSourceChannels;
+    ma_uint8 temp[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
+    ma_uint32 tempCapInFrames;
+    ma_uint64 seekTarget;
+
+    /* This is a data source node which means no input buses. */
+    (void)ppFramesIn;
+    (void)pFrameCountIn;
+
+    /* If we're marked at the end we need to stop the sound and do nothing. */
+    if (ma_sound_at_end(pSound)) {
+        ma_sound_stop(pSound);
+        *pFrameCountOut = 0;
+        return;
+    }
+
+    /* If we're seeking, do so now before reading. */
+    seekTarget = ma_atomic_load_64(&pSound->seekTarget);
+    if (seekTarget != MA_SEEK_TARGET_NONE) {
+        ma_data_source_seek_to_pcm_frame(pSound->pDataSource, seekTarget);
+
+        /* Any time-dependant effects need to have their times updated. */
+        ma_node_set_time(pSound, seekTarget);
+
+        ma_atomic_exchange_64(&pSound->seekTarget, MA_SEEK_TARGET_NONE);
+    }
+
+    /*
+    We want to update the pitch once. For sounds, this can be either at the start or at the end. If
+    we don't force this to only ever be updating once, we could end up in a situation where
+    retrieving the required input frame count ends up being different to what we actually retrieve.
+    What could happen is that the required input frame count is calculated, the pitch is update,
+    and then this processing function is called resulting in a different number of input frames
+    being processed. Do not call this in ma_engine_node_process_pcm_frames__general() or else
+    you'll hit the aforementioned bug.
+    */
+    ma_engine_node_update_pitch_if_required(&pSound->engineNode);
+
+    /*
+    For the convenience of the caller, we're doing to allow data sources to use non-floating-point formats and channel counts that differ
+    from the main engine.
+    */
+    result = ma_data_source_get_data_format(pSound->pDataSource, &dataSourceFormat, &dataSourceChannels, NULL, NULL, 0);
+    if (result == MA_SUCCESS) {
+        tempCapInFrames = sizeof(temp) / ma_get_bytes_per_frame(dataSourceFormat, dataSourceChannels);
+
+        /* Keep reading until we've read as much as was requested or we reach the end of the data source. */
+        while (totalFramesRead < frameCount) {
+            ma_uint32 framesRemaining = frameCount - totalFramesRead;
+            ma_uint32 framesToRead;
+            ma_uint64 framesJustRead;
+            ma_uint32 frameCountIn;
+            ma_uint32 frameCountOut;
+            const float* pRunningFramesIn;
+            float* pRunningFramesOut;
+
+            /*
+            The first thing we need to do is read into the temporary buffer. We can calculate exactly
+            how many input frames we'll need after resampling.
+            */
+            framesToRead = (ma_uint32)ma_engine_node_get_required_input_frame_count(&pSound->engineNode, framesRemaining);
+            if (framesToRead > tempCapInFrames) {
+                framesToRead = tempCapInFrames;
+            }
+
+            result = ma_data_source_read_pcm_frames(pSound->pDataSource, temp, framesToRead, &framesJustRead);
+
+            /* If we reached the end of the sound we'll want to mark it as at the end and stop it. This should never be returned for looping sounds. */
+            if (result == MA_AT_END) {
+                ma_sound_set_at_end(pSound, MA_TRUE);   /* This will be set to false in ma_sound_start(). */
+            }
+
+            pRunningFramesOut = ma_offset_pcm_frames_ptr_f32(ppFramesOut[0], totalFramesRead, ma_engine_get_channels(ma_sound_get_engine(pSound)));
+
+            frameCountIn = (ma_uint32)framesJustRead;
+            frameCountOut = framesRemaining;
+
+            /* Convert if necessary. */
+            if (dataSourceFormat == ma_format_f32) {
+                /* Fast path. No data conversion necessary. */
+                pRunningFramesIn = (float*)temp;
+                ma_engine_node_process_pcm_frames__general(&pSound->engineNode, &pRunningFramesIn, &frameCountIn, &pRunningFramesOut, &frameCountOut);
+            } else {
+                /* Slow path. Need to do sample format conversion to f32. If we give the f32 buffer the same count as the first temp buffer, we're guaranteed it'll be large enough. */
+                float tempf32[MA_DATA_CONVERTER_STACK_BUFFER_SIZE]; /* Do not do `MA_DATA_CONVERTER_STACK_BUFFER_SIZE/sizeof(float)` here like we've done in other places. */
+                ma_convert_pcm_frames_format(tempf32, ma_format_f32, temp, dataSourceFormat, framesJustRead, dataSourceChannels, ma_dither_mode_none);
+
+                /* Now that we have our samples in f32 format we can process like normal. */
+                pRunningFramesIn = tempf32;
+                ma_engine_node_process_pcm_frames__general(&pSound->engineNode, &pRunningFramesIn, &frameCountIn, &pRunningFramesOut, &frameCountOut);
+            }
+
+            /* We should have processed all of our input frames since we calculated the required number of input frames at the top. */
+            MA_ASSERT(frameCountIn == framesJustRead);
+            totalFramesRead += (ma_uint32)frameCountOut;   /* Safe cast. */
+
+            if (result != MA_SUCCESS || ma_sound_at_end(pSound)) {
+                break;  /* Might have reached the end. */
+            }
+        }
+    }
+
+    *pFrameCountOut = totalFramesRead;
+}
+
+static void ma_engine_node_process_pcm_frames__group(ma_node* pNode, const float** ppFramesIn, ma_uint32* pFrameCountIn, float** ppFramesOut, ma_uint32* pFrameCountOut)
+{
+    /*
+    Make sure the pitch is updated before trying to read anything. It's important that this is done
+    only once and not in ma_engine_node_process_pcm_frames__general(). The reason for this is that
+    ma_engine_node_process_pcm_frames__general() will call ma_engine_node_get_required_input_frame_count(),
+    and if another thread modifies the pitch just after that call it can result in a glitch due to
+    the input rate changing.
+    */
+    ma_engine_node_update_pitch_if_required((ma_engine_node*)pNode);
+
+    /* For groups, the input data has already been read and we just need to apply the effect. */
+    ma_engine_node_process_pcm_frames__general((ma_engine_node*)pNode, ppFramesIn, pFrameCountIn, ppFramesOut, pFrameCountOut);
+}
+
+static ma_result ma_engine_node_get_required_input_frame_count__group(ma_node* pNode, ma_uint32 outputFrameCount, ma_uint32* pInputFrameCount)
+{
+    ma_uint64 inputFrameCount;
+
+    MA_ASSERT(pInputFrameCount != NULL);
+
+    /* Our pitch will affect this calculation. We need to update it. */
+    ma_engine_node_update_pitch_if_required((ma_engine_node*)pNode);
+
+    inputFrameCount = ma_engine_node_get_required_input_frame_count((ma_engine_node*)pNode, outputFrameCount);
+    if (inputFrameCount > 0xFFFFFFFF) {
+        inputFrameCount = 0xFFFFFFFF;    /* Will never happen because miniaudio will only ever process in relatively small chunks. */
+    }
+
+    *pInputFrameCount = (ma_uint32)inputFrameCount;
+
+    return MA_SUCCESS;
+}
+
+
+static ma_node_vtable g_ma_engine_node_vtable__sound =
+{
+    ma_engine_node_process_pcm_frames__sound,
+    NULL,   /* onGetRequiredInputFrameCount */
+    0,      /* Sounds are data source nodes which means they have zero inputs (their input is drawn from the data source itself). */
+    1,      /* Sounds have one output bus. */
+    0       /* Default flags. */
+};
+
+static ma_node_vtable g_ma_engine_node_vtable__group =
+{
+    ma_engine_node_process_pcm_frames__group,
+    ma_engine_node_get_required_input_frame_count__group,
+    1,      /* Groups have one input bus. */
+    1,      /* Groups have one output bus. */
+    MA_NODE_FLAG_DIFFERENT_PROCESSING_RATES /* The engine node does resampling so should let miniaudio know about it. */
+};
+
+
+
+static ma_node_config ma_engine_node_base_node_config_init(const ma_engine_node_config* pConfig)
+{
+    ma_node_config baseNodeConfig;
+
+    if (pConfig->type == ma_engine_node_type_sound) {
+        /* Sound. */
+        baseNodeConfig = ma_node_config_init();
+        baseNodeConfig.vtable       = &g_ma_engine_node_vtable__sound;
+        baseNodeConfig.initialState = ma_node_state_stopped;    /* Sounds are stopped by default. */
+    } else {
+        /* Group. */
+        baseNodeConfig = ma_node_config_init();
+        baseNodeConfig.vtable       = &g_ma_engine_node_vtable__group;
+        baseNodeConfig.initialState = ma_node_state_started;    /* Groups are started by default. */
+    }
+
+    return baseNodeConfig;
+}
+
+static ma_spatializer_config ma_engine_node_spatializer_config_init(const ma_node_config* pBaseNodeConfig)
+{
+    return ma_spatializer_config_init(pBaseNodeConfig->pInputChannels[0], pBaseNodeConfig->pOutputChannels[0]);
+}
+
+typedef struct
+{
+    size_t sizeInBytes;
+    size_t baseNodeOffset;
+    size_t resamplerOffset;
+    size_t spatializerOffset;
+    size_t gainerOffset;
+} ma_engine_node_heap_layout;
+
+static ma_result ma_engine_node_get_heap_layout(const ma_engine_node_config* pConfig, ma_engine_node_heap_layout* pHeapLayout)
+{
+    ma_result result;
+    size_t tempHeapSize;
+    ma_node_config baseNodeConfig;
+    ma_linear_resampler_config resamplerConfig;
+    ma_spatializer_config spatializerConfig;
+    ma_gainer_config gainerConfig;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_channel defaultStereoChannelMap[2] = {MA_CHANNEL_SIDE_LEFT, MA_CHANNEL_SIDE_RIGHT};  /* <-- Consistent with the default channel map of a stereo listener. Means channel conversion can run on a fast path. */
+
+    MA_ASSERT(pHeapLayout);
+
+    MA_ZERO_OBJECT(pHeapLayout);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    if (pConfig->pEngine == NULL) {
+        return MA_INVALID_ARGS; /* An engine must be specified. */
+    }
+
+    pHeapLayout->sizeInBytes = 0;
+
+    channelsIn  = (pConfig->channelsIn  != 0) ? pConfig->channelsIn  : ma_engine_get_channels(pConfig->pEngine);
+    channelsOut = (pConfig->channelsOut != 0) ? pConfig->channelsOut : ma_engine_get_channels(pConfig->pEngine);
+
+
+    /* Base node. */
+    baseNodeConfig = ma_engine_node_base_node_config_init(pConfig);
+    baseNodeConfig.pInputChannels  = &channelsIn;
+    baseNodeConfig.pOutputChannels = &channelsOut;
+
+    result = ma_node_get_heap_size(ma_engine_get_node_graph(pConfig->pEngine), &baseNodeConfig, &tempHeapSize);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the size of the heap for the base node. */
+    }
+
+    pHeapLayout->baseNodeOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(tempHeapSize);
+
+
+    /* Resmapler. */
+    resamplerConfig = ma_linear_resampler_config_init(ma_format_f32, channelsIn, 1, 1); /* Input and output sample rates don't affect the calculation of the heap size. */
+    resamplerConfig.lpfOrder = 0;
+
+    result = ma_linear_resampler_get_heap_size(&resamplerConfig, &tempHeapSize);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the size of the heap for the resampler. */
+    }
+
+    pHeapLayout->resamplerOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(tempHeapSize);
+
+
+    /* Spatializer. */
+    spatializerConfig = ma_engine_node_spatializer_config_init(&baseNodeConfig);
+
+    if (spatializerConfig.channelsIn == 2) {
+        spatializerConfig.pChannelMapIn = defaultStereoChannelMap;
+    }
+
+    result = ma_spatializer_get_heap_size(&spatializerConfig, &tempHeapSize);
+    if (result != MA_SUCCESS) {
+        return result;  /* Failed to retrieve the size of the heap for the spatializer. */
+    }
+
+    pHeapLayout->spatializerOffset = pHeapLayout->sizeInBytes;
+    pHeapLayout->sizeInBytes += ma_align_64(tempHeapSize);
+
+
+    /* Gainer. Will not be used if we are not using smoothing. */
+    if (pConfig->volumeSmoothTimeInPCMFrames > 0) {
+        gainerConfig = ma_gainer_config_init(channelsIn, pConfig->volumeSmoothTimeInPCMFrames);
+
+        result = ma_gainer_get_heap_size(&gainerConfig, &tempHeapSize);
+        if (result != MA_SUCCESS) {
+            return result;
+        }
+
+        pHeapLayout->gainerOffset = pHeapLayout->sizeInBytes;
+        pHeapLayout->sizeInBytes += ma_align_64(tempHeapSize);
+    }
+
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_engine_node_get_heap_size(const ma_engine_node_config* pConfig, size_t* pHeapSizeInBytes)
+{
+    ma_result result;
+    ma_engine_node_heap_layout heapLayout;
+
+    if (pHeapSizeInBytes == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    *pHeapSizeInBytes = 0;
+
+    result = ma_engine_node_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    *pHeapSizeInBytes = heapLayout.sizeInBytes;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_engine_node_init_preallocated(const ma_engine_node_config* pConfig, void* pHeap, ma_engine_node* pEngineNode)
+{
+    ma_result result;
+    ma_engine_node_heap_layout heapLayout;
+    ma_node_config baseNodeConfig;
+    ma_linear_resampler_config resamplerConfig;
+    ma_fader_config faderConfig;
+    ma_spatializer_config spatializerConfig;
+    ma_panner_config pannerConfig;
+    ma_gainer_config gainerConfig;
+    ma_uint32 channelsIn;
+    ma_uint32 channelsOut;
+    ma_channel defaultStereoChannelMap[2] = {MA_CHANNEL_SIDE_LEFT, MA_CHANNEL_SIDE_RIGHT};  /* <-- Consistent with the default channel map of a stereo listener. Means channel conversion can run on a fast path. */
+
+    if (pEngineNode == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pEngineNode);
+
+    result = ma_engine_node_get_heap_layout(pConfig, &heapLayout);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pConfig->pinnedListenerIndex != MA_LISTENER_INDEX_CLOSEST && pConfig->pinnedListenerIndex >= ma_engine_get_listener_count(pConfig->pEngine)) {
+        return MA_INVALID_ARGS; /* Invalid listener. */
+    }
+
+    pEngineNode->_pHeap = pHeap;
+    MA_ZERO_MEMORY(pHeap, heapLayout.sizeInBytes);
+
+    pEngineNode->pEngine                     = pConfig->pEngine;
+    pEngineNode->sampleRate                  = (pConfig->sampleRate > 0) ? pConfig->sampleRate : ma_engine_get_sample_rate(pEngineNode->pEngine);
+    pEngineNode->volumeSmoothTimeInPCMFrames = pConfig->volumeSmoothTimeInPCMFrames;
+    pEngineNode->monoExpansionMode           = pConfig->monoExpansionMode;
+    ma_atomic_float_set(&pEngineNode->volume, 1);
+    pEngineNode->pitch                       = 1;
+    pEngineNode->oldPitch                    = 1;
+    pEngineNode->oldDopplerPitch             = 1;
+    pEngineNode->isPitchDisabled             = pConfig->isPitchDisabled;
+    pEngineNode->isSpatializationDisabled    = pConfig->isSpatializationDisabled;
+    pEngineNode->pinnedListenerIndex         = pConfig->pinnedListenerIndex;
+    ma_atomic_float_set(&pEngineNode->fadeSettings.volumeBeg, 1);
+    ma_atomic_float_set(&pEngineNode->fadeSettings.volumeEnd, 1);
+    ma_atomic_uint64_set(&pEngineNode->fadeSettings.fadeLengthInFrames, (~(ma_uint64)0));
+    ma_atomic_uint64_set(&pEngineNode->fadeSettings.absoluteGlobalTimeInFrames, (~(ma_uint64)0));   /* <-- Indicates that the fade should start immediately. */
+
+    channelsIn  = (pConfig->channelsIn  != 0) ? pConfig->channelsIn  : ma_engine_get_channels(pConfig->pEngine);
+    channelsOut = (pConfig->channelsOut != 0) ? pConfig->channelsOut : ma_engine_get_channels(pConfig->pEngine);
+
+    /*
+    If the sample rate of the sound is different to the engine, make sure pitching is enabled so that the resampler
+    is activated. Not doing this will result in the sound not being resampled if MA_SOUND_FLAG_NO_PITCH is used.
+    */
+    if (pEngineNode->sampleRate != ma_engine_get_sample_rate(pEngineNode->pEngine)) {
+        pEngineNode->isPitchDisabled = MA_FALSE;
+    }
+
+
+    /* Base node. */
+    baseNodeConfig = ma_engine_node_base_node_config_init(pConfig);
+    baseNodeConfig.pInputChannels  = &channelsIn;
+    baseNodeConfig.pOutputChannels = &channelsOut;
+
+    result = ma_node_init_preallocated(&pConfig->pEngine->nodeGraph, &baseNodeConfig, ma_offset_ptr(pHeap, heapLayout.baseNodeOffset), &pEngineNode->baseNode);
+    if (result != MA_SUCCESS) {
+        goto error0;
+    }
+
+
+    /*
+    We can now initialize the effects we need in order to implement the engine node. There's a
+    defined order of operations here, mainly centered around when we convert our channels from the
+    data source's native channel count to the engine's channel count. As a rule, we want to do as
+    much computation as possible before spatialization because there's a chance that will increase
+    the channel count, thereby increasing the amount of work needing to be done to process.
+    */
+
+    /* We'll always do resampling first. */
+    resamplerConfig = ma_linear_resampler_config_init(ma_format_f32, baseNodeConfig.pInputChannels[0], pEngineNode->sampleRate, ma_engine_get_sample_rate(pEngineNode->pEngine));
+    resamplerConfig.lpfOrder = 0;    /* <-- Need to disable low-pass filtering for pitch shifting for now because there's cases where the biquads are becoming unstable. Need to figure out a better fix for this. */
+
+    result = ma_linear_resampler_init_preallocated(&resamplerConfig, ma_offset_ptr(pHeap, heapLayout.resamplerOffset), &pEngineNode->resampler);
+    if (result != MA_SUCCESS) {
+        goto error1;
+    }
+
+
+    /* After resampling will come the fader. */
+    faderConfig = ma_fader_config_init(ma_format_f32, baseNodeConfig.pInputChannels[0], ma_engine_get_sample_rate(pEngineNode->pEngine));
+
+    result = ma_fader_init(&faderConfig, &pEngineNode->fader);
+    if (result != MA_SUCCESS) {
+        goto error2;
+    }
+
+
+    /*
+    Spatialization comes next. We spatialize based ont he node's output channel count. It's up the caller to
+    ensure channels counts link up correctly in the node graph.
+    */
+    spatializerConfig = ma_engine_node_spatializer_config_init(&baseNodeConfig);
+    spatializerConfig.gainSmoothTimeInFrames = pEngineNode->pEngine->gainSmoothTimeInFrames;
+
+    if (spatializerConfig.channelsIn == 2) {
+        spatializerConfig.pChannelMapIn = defaultStereoChannelMap;
+    }
+
+    result = ma_spatializer_init_preallocated(&spatializerConfig, ma_offset_ptr(pHeap, heapLayout.spatializerOffset), &pEngineNode->spatializer);
+    if (result != MA_SUCCESS) {
+        goto error2;
+    }
+
+
+    /*
+    After spatialization comes panning. We need to do this after spatialization because otherwise we wouldn't
+    be able to pan mono sounds.
+    */
+    pannerConfig = ma_panner_config_init(ma_format_f32, baseNodeConfig.pOutputChannels[0]);
+
+    result = ma_panner_init(&pannerConfig, &pEngineNode->panner);
+    if (result != MA_SUCCESS) {
+        goto error3;
+    }
+
+
+    /* We'll need a gainer for smoothing out volume changes if we have a non-zero smooth time. We apply this before converting to the output channel count. */
+    if (pConfig->volumeSmoothTimeInPCMFrames > 0) {
+        gainerConfig = ma_gainer_config_init(channelsIn, pConfig->volumeSmoothTimeInPCMFrames);
+
+        result = ma_gainer_init_preallocated(&gainerConfig, ma_offset_ptr(pHeap, heapLayout.gainerOffset), &pEngineNode->volumeGainer);
+        if (result != MA_SUCCESS) {
+            goto error3;
+        }
+    }
+
+
+    return MA_SUCCESS;
+
+    /* No need for allocation callbacks here because we use a preallocated heap. */
+error3: ma_spatializer_uninit(&pEngineNode->spatializer, NULL);
+error2: ma_linear_resampler_uninit(&pEngineNode->resampler, NULL);
+error1: ma_node_uninit(&pEngineNode->baseNode, NULL);
+error0: return result;
+}
+
+MA_API ma_result ma_engine_node_init(const ma_engine_node_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_engine_node* pEngineNode)
+{
+    ma_result result;
+    size_t heapSizeInBytes;
+    void* pHeap;
+
+    result = ma_engine_node_get_heap_size(pConfig, &heapSizeInBytes);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (heapSizeInBytes > 0) {
+        pHeap = ma_malloc(heapSizeInBytes, pAllocationCallbacks);
+        if (pHeap == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+    } else {
+        pHeap = NULL;
+    }
+
+    result = ma_engine_node_init_preallocated(pConfig, pHeap, pEngineNode);
+    if (result != MA_SUCCESS) {
+        ma_free(pHeap, pAllocationCallbacks);
+        return result;
+    }
+
+    pEngineNode->_ownsHeap = MA_TRUE;
+    return MA_SUCCESS;
+}
+
+MA_API void ma_engine_node_uninit(ma_engine_node* pEngineNode, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    /*
+    The base node always needs to be uninitialized first to ensure it's detached from the graph completely before we
+    destroy anything that might be in the middle of being used by the processing function.
+    */
+    ma_node_uninit(&pEngineNode->baseNode, pAllocationCallbacks);
+
+    /* Now that the node has been uninitialized we can safely uninitialize the rest. */
+    if (pEngineNode->volumeSmoothTimeInPCMFrames > 0) {
+        ma_gainer_uninit(&pEngineNode->volumeGainer, pAllocationCallbacks);
+    }
+
+    ma_spatializer_uninit(&pEngineNode->spatializer, pAllocationCallbacks);
+    ma_linear_resampler_uninit(&pEngineNode->resampler, pAllocationCallbacks);
+
+    /* Free the heap last. */
+    if (pEngineNode->_ownsHeap) {
+        ma_free(pEngineNode->_pHeap, pAllocationCallbacks);
+    }
+}
+
+
+MA_API ma_sound_config ma_sound_config_init(void)
+{
+    return ma_sound_config_init_2(NULL);
+}
+
+MA_API ma_sound_config ma_sound_config_init_2(ma_engine* pEngine)
+{
+    ma_sound_config config;
+
+    MA_ZERO_OBJECT(&config);
+
+    if (pEngine != NULL) {
+        config.monoExpansionMode = pEngine->monoExpansionMode;
+    } else {
+        config.monoExpansionMode = ma_mono_expansion_mode_default;
+    }
+
+    config.rangeEndInPCMFrames     = ~((ma_uint64)0);
+    config.loopPointEndInPCMFrames = ~((ma_uint64)0);
+
+    return config;
+}
+
+MA_API ma_sound_group_config ma_sound_group_config_init(void)
+{
+    return ma_sound_group_config_init_2(NULL);
+}
+
+MA_API ma_sound_group_config ma_sound_group_config_init_2(ma_engine* pEngine)
+{
+    ma_sound_group_config config;
+
+    MA_ZERO_OBJECT(&config);
+
+    if (pEngine != NULL) {
+        config.monoExpansionMode = pEngine->monoExpansionMode;
+    } else {
+        config.monoExpansionMode = ma_mono_expansion_mode_default;
+    }
+
+    return config;
+}
+
+
+MA_API ma_engine_config ma_engine_config_init(void)
+{
+    ma_engine_config config;
+
+    MA_ZERO_OBJECT(&config);
+    config.listenerCount     = 1;   /* Always want at least one listener. */
+    config.monoExpansionMode = ma_mono_expansion_mode_default;
+
+    return config;
+}
+
+
+#if !defined(MA_NO_DEVICE_IO)
+static void ma_engine_data_callback_internal(ma_device* pDevice, void* pFramesOut, const void* pFramesIn, ma_uint32 frameCount)
+{
+    ma_engine* pEngine = (ma_engine*)pDevice->pUserData;
+
+    (void)pFramesIn;
+
+    /*
+    Experiment: Try processing a resource manager job if we're on the Emscripten build.
+
+    This serves two purposes:
+
+        1) It ensures jobs are actually processed at some point since we cannot guarantee that the
+           caller is doing the right thing and calling ma_resource_manager_process_next_job(); and
+
+        2) It's an attempt at working around an issue where processing jobs on the Emscripten main
+           loop doesn't work as well as it should. When trying to load sounds without the `DECODE`
+           flag or with the `ASYNC` flag, the sound data is just not able to be loaded in time
+           before the callback is processed. I think it's got something to do with the single-
+           threaded nature of Web, but I'm not entirely sure.
+    */
+    #if !defined(MA_NO_RESOURCE_MANAGER) && defined(MA_EMSCRIPTEN)
+    {
+        if (pEngine->pResourceManager != NULL) {
+            if ((pEngine->pResourceManager->config.flags & MA_RESOURCE_MANAGER_FLAG_NO_THREADING) != 0) {
+                ma_resource_manager_process_next_job(pEngine->pResourceManager);
+            }
+        }
+    }
+    #endif
+
+    ma_engine_read_pcm_frames(pEngine, pFramesOut, frameCount, NULL);
+}
+#endif
+
+MA_API ma_result ma_engine_init(const ma_engine_config* pConfig, ma_engine* pEngine)
+{
+    ma_result result;
+    ma_node_graph_config nodeGraphConfig;
+    ma_engine_config engineConfig;
+    ma_spatializer_listener_config listenerConfig;
+    ma_uint32 iListener;
+
+    if (pEngine == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pEngine);
+
+    /* The config is allowed to be NULL in which case we use defaults for everything. */
+    if (pConfig != NULL) {
+        engineConfig = *pConfig;
+    } else {
+        engineConfig = ma_engine_config_init();
+    }
+
+    pEngine->monoExpansionMode = engineConfig.monoExpansionMode;
+    pEngine->defaultVolumeSmoothTimeInPCMFrames = engineConfig.defaultVolumeSmoothTimeInPCMFrames;
+    pEngine->onProcess = engineConfig.onProcess;
+    pEngine->pProcessUserData = engineConfig.pProcessUserData;
+    ma_allocation_callbacks_init_copy(&pEngine->allocationCallbacks, &engineConfig.allocationCallbacks);
+
+    #if !defined(MA_NO_RESOURCE_MANAGER)
+    {
+        pEngine->pResourceManager = engineConfig.pResourceManager;
+    }
+    #endif
+
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        pEngine->pDevice = engineConfig.pDevice;
+
+        /* If we don't have a device, we need one. */
+        if (pEngine->pDevice == NULL && engineConfig.noDevice == MA_FALSE) {
+            ma_device_config deviceConfig;
+
+            pEngine->pDevice = (ma_device*)ma_malloc(sizeof(*pEngine->pDevice), &pEngine->allocationCallbacks);
+            if (pEngine->pDevice == NULL) {
+                return MA_OUT_OF_MEMORY;
+            }
+
+            deviceConfig = ma_device_config_init(ma_device_type_playback);
+            deviceConfig.playback.pDeviceID        = engineConfig.pPlaybackDeviceID;
+            deviceConfig.playback.format           = ma_format_f32;
+            deviceConfig.playback.channels         = engineConfig.channels;
+            deviceConfig.sampleRate                = engineConfig.sampleRate;
+            deviceConfig.dataCallback              = (engineConfig.dataCallback != NULL) ? engineConfig.dataCallback : ma_engine_data_callback_internal;
+            deviceConfig.pUserData                 = pEngine;
+            deviceConfig.notificationCallback      = engineConfig.notificationCallback;
+            deviceConfig.periodSizeInFrames        = engineConfig.periodSizeInFrames;
+            deviceConfig.periodSizeInMilliseconds  = engineConfig.periodSizeInMilliseconds;
+            deviceConfig.noPreSilencedOutputBuffer = MA_TRUE;    /* We'll always be outputting to every frame in the callback so there's no need for a pre-silenced buffer. */
+            deviceConfig.noClip                    = MA_TRUE;    /* The engine will do clipping itself. */
+
+            if (engineConfig.pContext == NULL) {
+                ma_context_config contextConfig = ma_context_config_init();
+                contextConfig.allocationCallbacks = pEngine->allocationCallbacks;
+                contextConfig.pLog = engineConfig.pLog;
+
+                /* If the engine config does not specify a log, use the resource manager's if we have one. */
+                #ifndef MA_NO_RESOURCE_MANAGER
+                {
+                    if (contextConfig.pLog == NULL && engineConfig.pResourceManager != NULL) {
+                        contextConfig.pLog = ma_resource_manager_get_log(engineConfig.pResourceManager);
+                    }
+                }
+                #endif
+
+                result = ma_device_init_ex(NULL, 0, &contextConfig, &deviceConfig, pEngine->pDevice);
+            } else {
+                result = ma_device_init(engineConfig.pContext, &deviceConfig, pEngine->pDevice);
+            }
+
+            if (result != MA_SUCCESS) {
+                ma_free(pEngine->pDevice, &pEngine->allocationCallbacks);
+                pEngine->pDevice = NULL;
+                return result;
+            }
+
+            pEngine->ownsDevice = MA_TRUE;
+        }
+
+        /* Update the channel count and sample rate of the engine config so we can reference it below. */
+        if (pEngine->pDevice != NULL) {
+            engineConfig.channels   = pEngine->pDevice->playback.channels;
+            engineConfig.sampleRate = pEngine->pDevice->sampleRate;
+        }
+    }
+    #endif
+
+    if (engineConfig.channels == 0 || engineConfig.sampleRate == 0) {
+        return MA_INVALID_ARGS;
+    }
+
+    pEngine->sampleRate = engineConfig.sampleRate;
+
+    /* The engine always uses either the log that was passed into the config, or the context's log is available. */
+    if (engineConfig.pLog != NULL) {
+        pEngine->pLog = engineConfig.pLog;
+    } else {
+        #if !defined(MA_NO_DEVICE_IO)
+        {
+            pEngine->pLog = ma_device_get_log(pEngine->pDevice);
+        }
+        #else
+        {
+            pEngine->pLog = NULL;
+        }
+        #endif
+    }
+
+
+    /* The engine is a node graph. This needs to be initialized after we have the device so we can can determine the channel count. */
+    nodeGraphConfig = ma_node_graph_config_init(engineConfig.channels);
+    nodeGraphConfig.nodeCacheCapInFrames = (engineConfig.periodSizeInFrames > 0xFFFF) ? 0xFFFF : (ma_uint16)engineConfig.periodSizeInFrames;
+
+    result = ma_node_graph_init(&nodeGraphConfig, &pEngine->allocationCallbacks, &pEngine->nodeGraph);
+    if (result != MA_SUCCESS) {
+        goto on_error_1;
+    }
+
+
+    /* We need at least one listener. */
+    if (engineConfig.listenerCount == 0) {
+        engineConfig.listenerCount = 1;
+    }
+
+    if (engineConfig.listenerCount > MA_ENGINE_MAX_LISTENERS) {
+        result = MA_INVALID_ARGS;   /* Too many listeners. */
+        goto on_error_1;
+    }
+
+    for (iListener = 0; iListener < engineConfig.listenerCount; iListener += 1) {
+        listenerConfig = ma_spatializer_listener_config_init(ma_node_graph_get_channels(&pEngine->nodeGraph));
+
+        /*
+        If we're using a device, use the device's channel map for the listener. Otherwise just use
+        miniaudio's default channel map.
+        */
+        #if !defined(MA_NO_DEVICE_IO)
+        {
+            if (pEngine->pDevice != NULL) {
+                /*
+                Temporarily disabled. There is a subtle bug here where front-left and front-right
+                will be used by the device's channel map, but this is not what we want to use for
+                spatialization. Instead we want to use side-left and side-right. I need to figure
+                out a better solution for this. For now, disabling the use of device channel maps.
+                */
+                /*listenerConfig.pChannelMapOut = pEngine->pDevice->playback.channelMap;*/
+            }
+        }
+        #endif
+
+        result = ma_spatializer_listener_init(&listenerConfig, &pEngine->allocationCallbacks, &pEngine->listeners[iListener]);  /* TODO: Change this to a pre-allocated heap. */
+        if (result != MA_SUCCESS) {
+            goto on_error_2;
+        }
+
+        pEngine->listenerCount += 1;
+    }
+
+
+    /* Gain smoothing for spatialized sounds. */
+    pEngine->gainSmoothTimeInFrames = engineConfig.gainSmoothTimeInFrames;
+    if (pEngine->gainSmoothTimeInFrames == 0) {
+        ma_uint32 gainSmoothTimeInMilliseconds = engineConfig.gainSmoothTimeInMilliseconds;
+        if (gainSmoothTimeInMilliseconds == 0) {
+            gainSmoothTimeInMilliseconds = 8;
+        }
+
+        pEngine->gainSmoothTimeInFrames = (gainSmoothTimeInMilliseconds * ma_engine_get_sample_rate(pEngine)) / 1000;  /* 8ms by default. */
+    }
+
+
+    /* We need a resource manager. */
+    #ifndef MA_NO_RESOURCE_MANAGER
+    {
+        if (pEngine->pResourceManager == NULL) {
+            ma_resource_manager_config resourceManagerConfig;
+
+            pEngine->pResourceManager = (ma_resource_manager*)ma_malloc(sizeof(*pEngine->pResourceManager), &pEngine->allocationCallbacks);
+            if (pEngine->pResourceManager == NULL) {
+                result = MA_OUT_OF_MEMORY;
+                goto on_error_2;
+            }
+
+            resourceManagerConfig = ma_resource_manager_config_init();
+            resourceManagerConfig.pLog              = pEngine->pLog;    /* Always use the engine's log for internally-managed resource managers. */
+            resourceManagerConfig.decodedFormat     = ma_format_f32;
+            resourceManagerConfig.decodedChannels   = 0;  /* Leave the decoded channel count as 0 so we can get good spatialization. */
+            resourceManagerConfig.decodedSampleRate = ma_engine_get_sample_rate(pEngine);
+            ma_allocation_callbacks_init_copy(&resourceManagerConfig.allocationCallbacks, &pEngine->allocationCallbacks);
+            resourceManagerConfig.pVFS              = engineConfig.pResourceManagerVFS;
+
+            /* The Emscripten build cannot use threads. */
+            #if defined(MA_EMSCRIPTEN)
+            {
+                resourceManagerConfig.jobThreadCount = 0;
+                resourceManagerConfig.flags |= MA_RESOURCE_MANAGER_FLAG_NO_THREADING;
+            }
+            #endif
+
+            result = ma_resource_manager_init(&resourceManagerConfig, pEngine->pResourceManager);
+            if (result != MA_SUCCESS) {
+                goto on_error_3;
+            }
+
+            pEngine->ownsResourceManager = MA_TRUE;
+        }
+    }
+    #endif
+
+    /* Setup some stuff for inlined sounds. That is sounds played with ma_engine_play_sound(). */
+    pEngine->inlinedSoundLock  = 0;
+    pEngine->pInlinedSoundHead = NULL;
+
+    /* Start the engine if required. This should always be the last step. */
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        if (engineConfig.noAutoStart == MA_FALSE && pEngine->pDevice != NULL) {
+            result = ma_engine_start(pEngine);
+            if (result != MA_SUCCESS) {
+                goto on_error_4;    /* Failed to start the engine. */
+            }
+        }
+    }
+    #endif
+
+    return MA_SUCCESS;
+
+#if !defined(MA_NO_DEVICE_IO)
+on_error_4:
+#endif
+#if !defined(MA_NO_RESOURCE_MANAGER)
+on_error_3:
+    if (pEngine->ownsResourceManager) {
+        ma_free(pEngine->pResourceManager, &pEngine->allocationCallbacks);
+    }
+#endif  /* MA_NO_RESOURCE_MANAGER */
+on_error_2:
+    for (iListener = 0; iListener < pEngine->listenerCount; iListener += 1) {
+        ma_spatializer_listener_uninit(&pEngine->listeners[iListener], &pEngine->allocationCallbacks);
+    }
+
+    ma_node_graph_uninit(&pEngine->nodeGraph, &pEngine->allocationCallbacks);
+on_error_1:
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        if (pEngine->ownsDevice) {
+            ma_device_uninit(pEngine->pDevice);
+            ma_free(pEngine->pDevice, &pEngine->allocationCallbacks);
+        }
+    }
+    #endif
+
+    return result;
+}
+
+MA_API void ma_engine_uninit(ma_engine* pEngine)
+{
+    ma_uint32 iListener;
+
+    if (pEngine == NULL) {
+        return;
+    }
+
+    /* The device must be uninitialized before the node graph to ensure the audio thread doesn't try accessing it. */
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        if (pEngine->ownsDevice) {
+            ma_device_uninit(pEngine->pDevice);
+            ma_free(pEngine->pDevice, &pEngine->allocationCallbacks);
+        } else {
+            if (pEngine->pDevice != NULL) {
+                ma_device_stop(pEngine->pDevice);
+            }
+        }
+    }
+    #endif
+
+    /*
+    All inlined sounds need to be deleted. I'm going to use a lock here just to future proof in case
+    I want to do some kind of garbage collection later on.
+    */
+    ma_spinlock_lock(&pEngine->inlinedSoundLock);
+    {
+        for (;;) {
+            ma_sound_inlined* pSoundToDelete = pEngine->pInlinedSoundHead;
+            if (pSoundToDelete == NULL) {
+                break;  /* Done. */
+            }
+
+            pEngine->pInlinedSoundHead = pSoundToDelete->pNext;
+
+            ma_sound_uninit(&pSoundToDelete->sound);
+            ma_free(pSoundToDelete, &pEngine->allocationCallbacks);
+        }
+    }
+    ma_spinlock_unlock(&pEngine->inlinedSoundLock);
+
+    for (iListener = 0; iListener < pEngine->listenerCount; iListener += 1) {
+        ma_spatializer_listener_uninit(&pEngine->listeners[iListener], &pEngine->allocationCallbacks);
+    }
+
+    /* Make sure the node graph is uninitialized after the audio thread has been shutdown to prevent accessing of the node graph after being uninitialized. */
+    ma_node_graph_uninit(&pEngine->nodeGraph, &pEngine->allocationCallbacks);
+
+    /* Uninitialize the resource manager last to ensure we don't have a thread still trying to access it. */
+#ifndef MA_NO_RESOURCE_MANAGER
+    if (pEngine->ownsResourceManager) {
+        ma_resource_manager_uninit(pEngine->pResourceManager);
+        ma_free(pEngine->pResourceManager, &pEngine->allocationCallbacks);
+    }
+#endif
+}
+
+MA_API ma_result ma_engine_read_pcm_frames(ma_engine* pEngine, void* pFramesOut, ma_uint64 frameCount, ma_uint64* pFramesRead)
+{
+    ma_result result;
+    ma_uint64 framesRead = 0;
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = 0;
+    }
+
+    result = ma_node_graph_read_pcm_frames(&pEngine->nodeGraph, pFramesOut, frameCount, &framesRead);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pFramesRead != NULL) {
+        *pFramesRead = framesRead;
+    }
+
+    if (pEngine->onProcess) {
+        pEngine->onProcess(pEngine->pProcessUserData, (float*)pFramesOut, framesRead);  /* Safe cast to float* because the engine always works on floating point samples. */
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_node_graph* ma_engine_get_node_graph(ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return NULL;
+    }
+
+    return &pEngine->nodeGraph;
+}
+
+#if !defined(MA_NO_RESOURCE_MANAGER)
+MA_API ma_resource_manager* ma_engine_get_resource_manager(ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return NULL;
+    }
+
+    #if !defined(MA_NO_RESOURCE_MANAGER)
+    {
+        return pEngine->pResourceManager;
+    }
+    #else
+    {
+        return NULL;
+    }
+    #endif
+}
+#endif
+
+MA_API ma_device* ma_engine_get_device(ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return NULL;
+    }
+
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        return pEngine->pDevice;
+    }
+    #else
+    {
+        return NULL;
+    }
+    #endif
+}
+
+MA_API ma_log* ma_engine_get_log(ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return NULL;
+    }
+
+    if (pEngine->pLog != NULL) {
+        return pEngine->pLog;
+    } else {
+        #if !defined(MA_NO_DEVICE_IO)
+        {
+            return ma_device_get_log(ma_engine_get_device(pEngine));
+        }
+        #else
+        {
+            return NULL;
+        }
+        #endif
+    }
+}
+
+MA_API ma_node* ma_engine_get_endpoint(ma_engine* pEngine)
+{
+    return ma_node_graph_get_endpoint(&pEngine->nodeGraph);
+}
+
+MA_API ma_uint64 ma_engine_get_time_in_pcm_frames(const ma_engine* pEngine)
+{
+    return ma_node_graph_get_time(&pEngine->nodeGraph);
+}
+
+MA_API ma_uint64 ma_engine_get_time_in_milliseconds(const ma_engine* pEngine)
+{
+    return ma_engine_get_time_in_pcm_frames(pEngine) * 1000 / ma_engine_get_sample_rate(pEngine);
+}
+
+MA_API ma_result ma_engine_set_time_in_pcm_frames(ma_engine* pEngine, ma_uint64 globalTime)
+{
+    return ma_node_graph_set_time(&pEngine->nodeGraph, globalTime);
+}
+
+MA_API ma_result ma_engine_set_time_in_milliseconds(ma_engine* pEngine, ma_uint64 globalTime)
+{
+    return ma_engine_set_time_in_pcm_frames(pEngine, globalTime * ma_engine_get_sample_rate(pEngine) / 1000);
+}
+
+MA_API ma_uint64 ma_engine_get_time(const ma_engine* pEngine)
+{
+    return ma_engine_get_time_in_pcm_frames(pEngine);
+}
+
+MA_API ma_result ma_engine_set_time(ma_engine* pEngine, ma_uint64 globalTime)
+{
+    return ma_engine_set_time_in_pcm_frames(pEngine, globalTime);
+}
+
+MA_API ma_uint32 ma_engine_get_channels(const ma_engine* pEngine)
+{
+    return ma_node_graph_get_channels(&pEngine->nodeGraph);
+}
+
+MA_API ma_uint32 ma_engine_get_sample_rate(const ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return 0;
+    }
+
+    return pEngine->sampleRate;
+}
+
+
+MA_API ma_result ma_engine_start(ma_engine* pEngine)
+{
+    ma_result result;
+
+    if (pEngine == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        if (pEngine->pDevice != NULL) {
+            result = ma_device_start(pEngine->pDevice);
+        } else {
+            result = MA_INVALID_OPERATION;  /* The engine is running without a device which means there's no real notion of "starting" the engine. */
+        }
+    }
+    #else
+    {
+        result = MA_INVALID_OPERATION;  /* Device IO is disabled, so there's no real notion of "starting" the engine. */
+    }
+    #endif
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_engine_stop(ma_engine* pEngine)
+{
+    ma_result result;
+
+    if (pEngine == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    #if !defined(MA_NO_DEVICE_IO)
+    {
+        if (pEngine->pDevice != NULL) {
+            result = ma_device_stop(pEngine->pDevice);
+        } else {
+            result = MA_INVALID_OPERATION;  /* The engine is running without a device which means there's no real notion of "stopping" the engine. */
+        }
+    }
+    #else
+    {
+        result = MA_INVALID_OPERATION;  /* Device IO is disabled, so there's no real notion of "stopping" the engine. */
+    }
+    #endif
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_engine_set_volume(ma_engine* pEngine, float volume)
+{
+    if (pEngine == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_node_set_output_bus_volume(ma_node_graph_get_endpoint(&pEngine->nodeGraph), 0, volume);
+}
+
+MA_API float ma_engine_get_volume(ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return 0;
+    }
+
+    return ma_node_get_output_bus_volume(ma_node_graph_get_endpoint(&pEngine->nodeGraph), 0);
+}
+
+MA_API ma_result ma_engine_set_gain_db(ma_engine* pEngine, float gainDB)
+{
+    return ma_engine_set_volume(pEngine, ma_volume_db_to_linear(gainDB));
+}
+
+MA_API float ma_engine_get_gain_db(ma_engine* pEngine)
+{
+    return ma_volume_linear_to_db(ma_engine_get_volume(pEngine));
+}
+
+
+MA_API ma_uint32 ma_engine_get_listener_count(const ma_engine* pEngine)
+{
+    if (pEngine == NULL) {
+        return 0;
+    }
+
+    return pEngine->listenerCount;
+}
+
+MA_API ma_uint32 ma_engine_find_closest_listener(const ma_engine* pEngine, float absolutePosX, float absolutePosY, float absolutePosZ)
+{
+    ma_uint32 iListener;
+    ma_uint32 iListenerClosest;
+    float closestLen2 = MA_FLT_MAX;
+
+    if (pEngine == NULL || pEngine->listenerCount == 1) {
+        return 0;
+    }
+
+    iListenerClosest = 0;
+    for (iListener = 0; iListener < pEngine->listenerCount; iListener += 1) {
+        if (ma_engine_listener_is_enabled(pEngine, iListener)) {
+            float len2 = ma_vec3f_len2(ma_vec3f_sub(ma_spatializer_listener_get_position(&pEngine->listeners[iListener]), ma_vec3f_init_3f(absolutePosX, absolutePosY, absolutePosZ)));
+            if (closestLen2 > len2) {
+                closestLen2 = len2;
+                iListenerClosest = iListener;
+            }
+        }
+    }
+
+    MA_ASSERT(iListenerClosest < 255);
+    return iListenerClosest;
+}
+
+MA_API void ma_engine_listener_set_position(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_position(&pEngine->listeners[listenerIndex], x, y, z);
+}
+
+MA_API ma_vec3f ma_engine_listener_get_position(const ma_engine* pEngine, ma_uint32 listenerIndex)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_spatializer_listener_get_position(&pEngine->listeners[listenerIndex]);
+}
+
+MA_API void ma_engine_listener_set_direction(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_direction(&pEngine->listeners[listenerIndex], x, y, z);
+}
+
+MA_API ma_vec3f ma_engine_listener_get_direction(const ma_engine* pEngine, ma_uint32 listenerIndex)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    }
+
+    return ma_spatializer_listener_get_direction(&pEngine->listeners[listenerIndex]);
+}
+
+MA_API void ma_engine_listener_set_velocity(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_velocity(&pEngine->listeners[listenerIndex], x, y, z);
+}
+
+MA_API ma_vec3f ma_engine_listener_get_velocity(const ma_engine* pEngine, ma_uint32 listenerIndex)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_spatializer_listener_get_velocity(&pEngine->listeners[listenerIndex]);
+}
+
+MA_API void ma_engine_listener_set_cone(ma_engine* pEngine, ma_uint32 listenerIndex, float innerAngleInRadians, float outerAngleInRadians, float outerGain)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_cone(&pEngine->listeners[listenerIndex], innerAngleInRadians, outerAngleInRadians, outerGain);
+}
+
+MA_API void ma_engine_listener_get_cone(const ma_engine* pEngine, ma_uint32 listenerIndex, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain)
+{
+    if (pInnerAngleInRadians != NULL) {
+        *pInnerAngleInRadians = 0;
+    }
+
+    if (pOuterAngleInRadians != NULL) {
+        *pOuterAngleInRadians = 0;
+    }
+
+    if (pOuterGain != NULL) {
+        *pOuterGain = 0;
+    }
+
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_get_cone(&pEngine->listeners[listenerIndex], pInnerAngleInRadians, pOuterAngleInRadians, pOuterGain);
+}
+
+MA_API void ma_engine_listener_set_world_up(ma_engine* pEngine, ma_uint32 listenerIndex, float x, float y, float z)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_world_up(&pEngine->listeners[listenerIndex], x, y, z);
+}
+
+MA_API ma_vec3f ma_engine_listener_get_world_up(const ma_engine* pEngine, ma_uint32 listenerIndex)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return ma_vec3f_init_3f(0, 1, 0);
+    }
+
+    return ma_spatializer_listener_get_world_up(&pEngine->listeners[listenerIndex]);
+}
+
+MA_API void ma_engine_listener_set_enabled(ma_engine* pEngine, ma_uint32 listenerIndex, ma_bool32 isEnabled)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return;
+    }
+
+    ma_spatializer_listener_set_enabled(&pEngine->listeners[listenerIndex], isEnabled);
+}
+
+MA_API ma_bool32 ma_engine_listener_is_enabled(const ma_engine* pEngine, ma_uint32 listenerIndex)
+{
+    if (pEngine == NULL || listenerIndex >= pEngine->listenerCount) {
+        return MA_FALSE;
+    }
+
+    return ma_spatializer_listener_is_enabled(&pEngine->listeners[listenerIndex]);
+}
+
+
+#ifndef MA_NO_RESOURCE_MANAGER
+MA_API ma_result ma_engine_play_sound_ex(ma_engine* pEngine, const char* pFilePath, ma_node* pNode, ma_uint32 nodeInputBusIndex)
+{
+    ma_result result = MA_SUCCESS;
+    ma_sound_inlined* pSound = NULL;
+    ma_sound_inlined* pNextSound = NULL;
+
+    if (pEngine == NULL || pFilePath == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Attach to the endpoint node if nothing is specicied. */
+    if (pNode == NULL) {
+        pNode = ma_node_graph_get_endpoint(&pEngine->nodeGraph);
+        nodeInputBusIndex = 0;
+    }
+
+    /*
+    We want to check if we can recycle an already-allocated inlined sound. Since this is just a
+    helper I'm not *too* concerned about performance here and I'm happy to use a lock to keep
+    the implementation simple. Maybe this can be optimized later if there's enough demand, but
+    if this function is being used it probably means the caller doesn't really care too much.
+
+    What we do is check the atEnd flag. When this is true, we can recycle the sound. Otherwise
+    we just keep iterating. If we reach the end without finding a sound to recycle we just
+    allocate a new one. This doesn't scale well for a massive number of sounds being played
+    simultaneously as we don't ever actually free the sound objects. Some kind of garbage
+    collection routine might be valuable for this which I'll think about.
+    */
+    ma_spinlock_lock(&pEngine->inlinedSoundLock);
+    {
+        ma_uint32 soundFlags = 0;
+
+        for (pNextSound = pEngine->pInlinedSoundHead; pNextSound != NULL; pNextSound = pNextSound->pNext) {
+            if (ma_sound_at_end(&pNextSound->sound)) {
+                /*
+                The sound is at the end which means it's available for recycling. All we need to do
+                is uninitialize it and reinitialize it. All we're doing is recycling memory.
+                */
+                pSound = pNextSound;
+                ma_atomic_fetch_sub_32(&pEngine->inlinedSoundCount, 1);
+                break;
+            }
+        }
+
+        if (pSound != NULL) {
+            /*
+            We actually want to detach the sound from the list here. The reason is because we want the sound
+            to be in a consistent state at the non-recycled case to simplify the logic below.
+            */
+            if (pEngine->pInlinedSoundHead == pSound) {
+                pEngine->pInlinedSoundHead =  pSound->pNext;
+            }
+
+            if (pSound->pPrev != NULL) {
+                pSound->pPrev->pNext = pSound->pNext;
+            }
+            if (pSound->pNext != NULL) {
+                pSound->pNext->pPrev = pSound->pPrev;
+            }
+
+            /* Now the previous sound needs to be uninitialized. */
+            ma_sound_uninit(&pNextSound->sound);
+        } else {
+            /* No sound available for recycling. Allocate one now. */
+            pSound = (ma_sound_inlined*)ma_malloc(sizeof(*pSound), &pEngine->allocationCallbacks);
+        }
+
+        if (pSound != NULL) {   /* Safety check for the allocation above. */
+            /*
+            At this point we should have memory allocated for the inlined sound. We just need
+            to initialize it like a normal sound now.
+            */
+            soundFlags |= MA_SOUND_FLAG_ASYNC;                 /* For inlined sounds we don't want to be sitting around waiting for stuff to load so force an async load. */
+            soundFlags |= MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT; /* We want specific control over where the sound is attached in the graph. We'll attach it manually just before playing the sound. */
+            soundFlags |= MA_SOUND_FLAG_NO_PITCH;              /* Pitching isn't usable with inlined sounds, so disable it to save on speed. */
+            soundFlags |= MA_SOUND_FLAG_NO_SPATIALIZATION;     /* Not currently doing spatialization with inlined sounds, but this might actually change later. For now disable spatialization. Will be removed if we ever add support for spatialization here. */
+
+            result = ma_sound_init_from_file(pEngine, pFilePath, soundFlags, NULL, NULL, &pSound->sound);
+            if (result == MA_SUCCESS) {
+                /* Now attach the sound to the graph. */
+                result = ma_node_attach_output_bus(pSound, 0, pNode, nodeInputBusIndex);
+                if (result == MA_SUCCESS) {
+                    /* At this point the sound should be loaded and we can go ahead and add it to the list. The new item becomes the new head. */
+                    pSound->pNext = pEngine->pInlinedSoundHead;
+                    pSound->pPrev = NULL;
+
+                    pEngine->pInlinedSoundHead = pSound;    /* <-- This is what attaches the sound to the list. */
+                    if (pSound->pNext != NULL) {
+                        pSound->pNext->pPrev = pSound;
+                    }
+                } else {
+                    ma_free(pSound, &pEngine->allocationCallbacks);
+                }
+            } else {
+                ma_free(pSound, &pEngine->allocationCallbacks);
+            }
+        } else {
+            result = MA_OUT_OF_MEMORY;
+        }
+    }
+    ma_spinlock_unlock(&pEngine->inlinedSoundLock);
+
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* Finally we can start playing the sound. */
+    result = ma_sound_start(&pSound->sound);
+    if (result != MA_SUCCESS) {
+        /* Failed to start the sound. We need to mark it for recycling and return an error. */
+        ma_atomic_exchange_32(&pSound->sound.atEnd, MA_TRUE);
+        return result;
+    }
+
+    ma_atomic_fetch_add_32(&pEngine->inlinedSoundCount, 1);
+    return result;
+}
+
+MA_API ma_result ma_engine_play_sound(ma_engine* pEngine, const char* pFilePath, ma_sound_group* pGroup)
+{
+    return ma_engine_play_sound_ex(pEngine, pFilePath, pGroup, 0);
+}
+#endif
+
+
+static ma_result ma_sound_preinit(ma_engine* pEngine, ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pSound);
+    pSound->seekTarget = MA_SEEK_TARGET_NONE;
+
+    if (pEngine == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return MA_SUCCESS;
+}
+
+static ma_result ma_sound_init_from_data_source_internal(ma_engine* pEngine, const ma_sound_config* pConfig, ma_sound* pSound)
+{
+    ma_result result;
+    ma_engine_node_config engineNodeConfig;
+    ma_engine_node_type type;   /* Will be set to ma_engine_node_type_group if no data source is specified. */
+
+    /* Do not clear pSound to zero here - that's done at a higher level with ma_sound_preinit(). */
+    MA_ASSERT(pEngine != NULL);
+    MA_ASSERT(pSound  != NULL);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pSound->pDataSource = pConfig->pDataSource;
+
+    if (pConfig->pDataSource != NULL) {
+        type = ma_engine_node_type_sound;
+    } else {
+        type = ma_engine_node_type_group;
+    }
+
+    /*
+    Sounds are engine nodes. Before we can initialize this we need to determine the channel count.
+    If we can't do this we need to abort. It's up to the caller to ensure they're using a data
+    source that provides this information upfront.
+    */
+    engineNodeConfig = ma_engine_node_config_init(pEngine, type, pConfig->flags);
+    engineNodeConfig.channelsIn                  = pConfig->channelsIn;
+    engineNodeConfig.channelsOut                 = pConfig->channelsOut;
+    engineNodeConfig.volumeSmoothTimeInPCMFrames = pConfig->volumeSmoothTimeInPCMFrames;
+    engineNodeConfig.monoExpansionMode           = pConfig->monoExpansionMode;
+
+    if (engineNodeConfig.volumeSmoothTimeInPCMFrames == 0) {
+        engineNodeConfig.volumeSmoothTimeInPCMFrames = pEngine->defaultVolumeSmoothTimeInPCMFrames;
+    }
+
+    /* If we're loading from a data source the input channel count needs to be the data source's native channel count. */
+    if (pConfig->pDataSource != NULL) {
+        result = ma_data_source_get_data_format(pConfig->pDataSource, NULL, &engineNodeConfig.channelsIn, &engineNodeConfig.sampleRate, NULL, 0);
+        if (result != MA_SUCCESS) {
+            return result;  /* Failed to retrieve the channel count. */
+        }
+
+        if (engineNodeConfig.channelsIn == 0) {
+            return MA_INVALID_OPERATION;    /* Invalid channel count. */
+        }
+
+        if (engineNodeConfig.channelsOut == MA_SOUND_SOURCE_CHANNEL_COUNT) {
+            engineNodeConfig.channelsOut = engineNodeConfig.channelsIn;
+        }
+    }
+
+
+    /* Getting here means we should have a valid channel count and we can initialize the engine node. */
+    result = ma_engine_node_init(&engineNodeConfig, &pEngine->allocationCallbacks, &pSound->engineNode);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* If no attachment is specified, attach the sound straight to the endpoint. */
+    if (pConfig->pInitialAttachment == NULL) {
+        /* No group. Attach straight to the endpoint by default, unless the caller has requested that it not. */
+        if ((pConfig->flags & MA_SOUND_FLAG_NO_DEFAULT_ATTACHMENT) == 0) {
+            result = ma_node_attach_output_bus(pSound, 0, ma_node_graph_get_endpoint(&pEngine->nodeGraph), 0);
+        }
+    } else {
+        /* An attachment is specified. Attach to it by default. The sound has only a single output bus, and the config will specify which input bus to attach to. */
+        result = ma_node_attach_output_bus(pSound, 0, pConfig->pInitialAttachment, pConfig->initialAttachmentInputBusIndex);
+    }
+
+    if (result != MA_SUCCESS) {
+        ma_engine_node_uninit(&pSound->engineNode, &pEngine->allocationCallbacks);
+        return result;
+    }
+
+
+    /* Apply initial range and looping state to the data source if applicable. */
+    if (pConfig->rangeBegInPCMFrames != 0 || pConfig->rangeEndInPCMFrames != ~((ma_uint64)0)) {
+        ma_data_source_set_range_in_pcm_frames(ma_sound_get_data_source(pSound), pConfig->rangeBegInPCMFrames, pConfig->rangeEndInPCMFrames);
+    }
+
+    if (pConfig->loopPointBegInPCMFrames != 0 || pConfig->loopPointEndInPCMFrames != ~((ma_uint64)0)) {
+        ma_data_source_set_range_in_pcm_frames(ma_sound_get_data_source(pSound), pConfig->loopPointBegInPCMFrames, pConfig->loopPointEndInPCMFrames);
+    }
+
+    ma_sound_set_looping(pSound, pConfig->isLooping);
+
+    return MA_SUCCESS;
+}
+
+#ifndef MA_NO_RESOURCE_MANAGER
+MA_API ma_result ma_sound_init_from_file_internal(ma_engine* pEngine, const ma_sound_config* pConfig, ma_sound* pSound)
+{
+    ma_result result = MA_SUCCESS;
+    ma_uint32 flags;
+    ma_sound_config config;
+    ma_resource_manager_pipeline_notifications notifications;
+
+    /*
+    The engine requires knowledge of the channel count of the underlying data source before it can
+    initialize the sound. Therefore, we need to make the resource manager wait until initialization
+    of the underlying data source to be initialized so we can get access to the channel count. To
+    do this, the MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT is forced.
+
+    Because we're initializing the data source before the sound, there's a chance the notification
+    will get triggered before this function returns. This is OK, so long as the caller is aware of
+    it and can avoid accessing the sound from within the notification.
+    */
+    flags = pConfig->flags | MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT;
+
+    pSound->pResourceManagerDataSource = (ma_resource_manager_data_source*)ma_malloc(sizeof(*pSound->pResourceManagerDataSource), &pEngine->allocationCallbacks);
+    if (pSound->pResourceManagerDataSource == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    /* Removed in 0.12. Set pDoneFence on the notifications. */
+    notifications = pConfig->initNotifications;
+    if (pConfig->pDoneFence != NULL && notifications.done.pFence == NULL) {
+        notifications.done.pFence = pConfig->pDoneFence;
+    }
+
+    /*
+    We must wrap everything around the fence if one was specified. This ensures ma_fence_wait() does
+    not return prematurely before the sound has finished initializing.
+    */
+    if (notifications.done.pFence) { ma_fence_acquire(notifications.done.pFence); }
+    {
+        ma_resource_manager_data_source_config resourceManagerDataSourceConfig = ma_resource_manager_data_source_config_init();
+        resourceManagerDataSourceConfig.pFilePath                   = pConfig->pFilePath;
+        resourceManagerDataSourceConfig.pFilePathW                  = pConfig->pFilePathW;
+        resourceManagerDataSourceConfig.flags                       = flags;
+        resourceManagerDataSourceConfig.pNotifications              = &notifications;
+        resourceManagerDataSourceConfig.initialSeekPointInPCMFrames = pConfig->initialSeekPointInPCMFrames;
+        resourceManagerDataSourceConfig.rangeBegInPCMFrames         = pConfig->rangeBegInPCMFrames;
+        resourceManagerDataSourceConfig.rangeEndInPCMFrames         = pConfig->rangeEndInPCMFrames;
+        resourceManagerDataSourceConfig.loopPointBegInPCMFrames     = pConfig->loopPointBegInPCMFrames;
+        resourceManagerDataSourceConfig.loopPointEndInPCMFrames     = pConfig->loopPointEndInPCMFrames;
+        resourceManagerDataSourceConfig.isLooping                   = pConfig->isLooping;
+
+        result = ma_resource_manager_data_source_init_ex(pEngine->pResourceManager, &resourceManagerDataSourceConfig, pSound->pResourceManagerDataSource);
+        if (result != MA_SUCCESS) {
+            goto done;
+        }
+
+        pSound->ownsDataSource = MA_TRUE;   /* <-- Important. Not setting this will result in the resource manager data source never getting uninitialized. */
+
+        /* We need to use a slightly customized version of the config so we'll need to make a copy. */
+        config = *pConfig;
+        config.pFilePath   = NULL;
+        config.pFilePathW  = NULL;
+        config.pDataSource = pSound->pResourceManagerDataSource;
+
+        result = ma_sound_init_from_data_source_internal(pEngine, &config, pSound);
+        if (result != MA_SUCCESS) {
+            ma_resource_manager_data_source_uninit(pSound->pResourceManagerDataSource);
+            ma_free(pSound->pResourceManagerDataSource, &pEngine->allocationCallbacks);
+            MA_ZERO_OBJECT(pSound);
+            goto done;
+        }
+    }
+done:
+    if (notifications.done.pFence) { ma_fence_release(notifications.done.pFence); }
+    return result;
+}
+
+MA_API ma_result ma_sound_init_from_file(ma_engine* pEngine, const char* pFilePath, ma_uint32 flags, ma_sound_group* pGroup, ma_fence* pDoneFence, ma_sound* pSound)
+{
+    ma_sound_config config;
+
+    if (pFilePath == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    config = ma_sound_config_init_2(pEngine);
+    config.pFilePath          = pFilePath;
+    config.flags              = flags;
+    config.pInitialAttachment = pGroup;
+    config.pDoneFence         = pDoneFence;
+
+    return ma_sound_init_ex(pEngine, &config, pSound);
+}
+
+MA_API ma_result ma_sound_init_from_file_w(ma_engine* pEngine, const wchar_t* pFilePath, ma_uint32 flags, ma_sound_group* pGroup, ma_fence* pDoneFence, ma_sound* pSound)
+{
+    ma_sound_config config;
+
+    if (pFilePath == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    config = ma_sound_config_init_2(pEngine);
+    config.pFilePathW         = pFilePath;
+    config.flags              = flags;
+    config.pInitialAttachment = pGroup;
+    config.pDoneFence         = pDoneFence;
+
+    return ma_sound_init_ex(pEngine, &config, pSound);
+}
+
+MA_API ma_result ma_sound_init_copy(ma_engine* pEngine, const ma_sound* pExistingSound, ma_uint32 flags, ma_sound_group* pGroup, ma_sound* pSound)
+{
+    ma_result result;
+    ma_sound_config config;
+
+    result = ma_sound_preinit(pEngine, pSound);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pExistingSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Cloning only works for data buffers (not streams) that are loaded from the resource manager. */
+    if (pExistingSound->pResourceManagerDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /*
+    We need to make a clone of the data source. If the data source is not a data buffer (i.e. a stream)
+    this will fail.
+    */
+    pSound->pResourceManagerDataSource = (ma_resource_manager_data_source*)ma_malloc(sizeof(*pSound->pResourceManagerDataSource), &pEngine->allocationCallbacks);
+    if (pSound->pResourceManagerDataSource == NULL) {
+        return MA_OUT_OF_MEMORY;
+    }
+
+    result = ma_resource_manager_data_source_init_copy(pEngine->pResourceManager, pExistingSound->pResourceManagerDataSource, pSound->pResourceManagerDataSource);
+    if (result != MA_SUCCESS) {
+        ma_free(pSound->pResourceManagerDataSource, &pEngine->allocationCallbacks);
+        return result;
+    }
+
+    config = ma_sound_config_init_2(pEngine);
+    config.pDataSource                 = pSound->pResourceManagerDataSource;
+    config.flags                       = flags;
+    config.pInitialAttachment          = pGroup;
+    config.monoExpansionMode           = pExistingSound->engineNode.monoExpansionMode;
+    config.volumeSmoothTimeInPCMFrames = pExistingSound->engineNode.volumeSmoothTimeInPCMFrames;
+
+    result = ma_sound_init_from_data_source_internal(pEngine, &config, pSound);
+    if (result != MA_SUCCESS) {
+        ma_resource_manager_data_source_uninit(pSound->pResourceManagerDataSource);
+        ma_free(pSound->pResourceManagerDataSource, &pEngine->allocationCallbacks);
+        MA_ZERO_OBJECT(pSound);
+        return result;
+    }
+
+    /* Make sure the sound is marked as the owner of the data source or else it will never get uninitialized. */
+    pSound->ownsDataSource = MA_TRUE;
+
+    return MA_SUCCESS;
+}
+#endif
+
+MA_API ma_result ma_sound_init_from_data_source(ma_engine* pEngine, ma_data_source* pDataSource, ma_uint32 flags, ma_sound_group* pGroup, ma_sound* pSound)
+{
+    ma_sound_config config = ma_sound_config_init_2(pEngine);
+    config.pDataSource        = pDataSource;
+    config.flags              = flags;
+    config.pInitialAttachment = pGroup;
+    return ma_sound_init_ex(pEngine, &config, pSound);
+}
+
+MA_API ma_result ma_sound_init_ex(ma_engine* pEngine, const ma_sound_config* pConfig, ma_sound* pSound)
+{
+    ma_result result;
+
+    result = ma_sound_preinit(pEngine, pSound);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    pSound->endCallback          = pConfig->endCallback;
+    pSound->pEndCallbackUserData = pConfig->pEndCallbackUserData;
+
+    /* We need to load the sound differently depending on whether or not we're loading from a file. */
+#ifndef MA_NO_RESOURCE_MANAGER
+    if (pConfig->pFilePath != NULL || pConfig->pFilePathW != NULL) {
+        return ma_sound_init_from_file_internal(pEngine, pConfig, pSound);
+    } else
+#endif
+    {
+        /*
+        Getting here means we're not loading from a file. We may be loading from an already-initialized
+        data source, or none at all. If we aren't specifying any data source, we'll be initializing the
+        the equivalent to a group. ma_data_source_init_from_data_source_internal() will deal with this
+        for us, so no special treatment required here.
+        */
+        return ma_sound_init_from_data_source_internal(pEngine, pConfig, pSound);
+    }
+}
+
+MA_API void ma_sound_uninit(ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    /*
+    Always uninitialize the node first. This ensures it's detached from the graph and does not return until it has done
+    so which makes thread safety beyond this point trivial.
+    */
+    ma_engine_node_uninit(&pSound->engineNode, &pSound->engineNode.pEngine->allocationCallbacks);
+
+    /* Once the sound is detached from the group we can guarantee that it won't be referenced by the mixer thread which means it's safe for us to destroy the data source. */
+#ifndef MA_NO_RESOURCE_MANAGER
+    if (pSound->ownsDataSource) {
+        ma_resource_manager_data_source_uninit(pSound->pResourceManagerDataSource);
+        ma_free(pSound->pResourceManagerDataSource, &pSound->engineNode.pEngine->allocationCallbacks);
+        pSound->pDataSource = NULL;
+    }
+#else
+    MA_ASSERT(pSound->ownsDataSource == MA_FALSE);
+#endif
+}
+
+MA_API ma_engine* ma_sound_get_engine(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return NULL;
+    }
+
+    return pSound->engineNode.pEngine;
+}
+
+MA_API ma_data_source* ma_sound_get_data_source(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return NULL;
+    }
+
+    return pSound->pDataSource;
+}
+
+MA_API ma_result ma_sound_start(ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* If the sound is already playing, do nothing. */
+    if (ma_sound_is_playing(pSound)) {
+        return MA_SUCCESS;
+    }
+
+    /* If the sound is at the end it means we want to start from the start again. */
+    if (ma_sound_at_end(pSound)) {
+        ma_result result = ma_data_source_seek_to_pcm_frame(pSound->pDataSource, 0);
+        if (result != MA_SUCCESS && result != MA_NOT_IMPLEMENTED) {
+            return result;  /* Failed to seek back to the start. */
+        }
+
+        /* Make sure we clear the end indicator. */
+        ma_atomic_exchange_32(&pSound->atEnd, MA_FALSE);
+    }
+
+    /* Make sure the sound is started. If there's a start delay, the sound won't actually start until the start time is reached. */
+    ma_node_set_state(pSound, ma_node_state_started);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_sound_stop(ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* This will stop the sound immediately. Use ma_sound_set_stop_time() to stop the sound at a specific time. */
+    ma_node_set_state(pSound, ma_node_state_stopped);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_sound_stop_with_fade_in_pcm_frames(ma_sound* pSound, ma_uint64 fadeLengthInFrames)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Stopping with a fade out requires us to schedule the stop into the future by the fade length. */
+    ma_sound_set_stop_time_with_fade_in_pcm_frames(pSound, ma_engine_get_time_in_pcm_frames(ma_sound_get_engine(pSound)) + fadeLengthInFrames, fadeLengthInFrames);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_sound_stop_with_fade_in_milliseconds(ma_sound* pSound, ma_uint64 fadeLengthInMilliseconds)
+{
+    ma_uint64 sampleRate;
+
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    sampleRate = ma_engine_get_sample_rate(ma_sound_get_engine(pSound));
+
+    return ma_sound_stop_with_fade_in_pcm_frames(pSound, (fadeLengthInMilliseconds * sampleRate) / 1000);
+}
+
+MA_API void ma_sound_set_volume(ma_sound* pSound, float volume)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_engine_node_set_volume(&pSound->engineNode, volume);
+}
+
+MA_API float ma_sound_get_volume(const ma_sound* pSound)
+{
+    float volume = 0;
+
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    ma_engine_node_get_volume(&pSound->engineNode, &volume);
+
+    return volume;
+}
+
+MA_API void ma_sound_set_pan(ma_sound* pSound, float pan)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_panner_set_pan(&pSound->engineNode.panner, pan);
+}
+
+MA_API float ma_sound_get_pan(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_panner_get_pan(&pSound->engineNode.panner);
+}
+
+MA_API void ma_sound_set_pan_mode(ma_sound* pSound, ma_pan_mode panMode)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_panner_set_mode(&pSound->engineNode.panner, panMode);
+}
+
+MA_API ma_pan_mode ma_sound_get_pan_mode(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_pan_mode_balance;
+    }
+
+    return ma_panner_get_mode(&pSound->engineNode.panner);
+}
+
+MA_API void ma_sound_set_pitch(ma_sound* pSound, float pitch)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    if (pitch <= 0) {
+        return;
+    }
+
+    ma_atomic_exchange_explicit_f32(&pSound->engineNode.pitch, pitch, ma_atomic_memory_order_release);
+}
+
+MA_API float ma_sound_get_pitch(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_atomic_load_f32(&pSound->engineNode.pitch);    /* Naughty const-cast for this. */
+}
+
+MA_API void ma_sound_set_spatialization_enabled(ma_sound* pSound, ma_bool32 enabled)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_atomic_exchange_explicit_32(&pSound->engineNode.isSpatializationDisabled, !enabled, ma_atomic_memory_order_release);
+}
+
+MA_API ma_bool32 ma_sound_is_spatialization_enabled(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_engine_node_is_spatialization_enabled(&pSound->engineNode);
+}
+
+MA_API void ma_sound_set_pinned_listener_index(ma_sound* pSound, ma_uint32 listenerIndex)
+{
+    if (pSound == NULL || listenerIndex >= ma_engine_get_listener_count(ma_sound_get_engine(pSound))) {
+        return;
+    }
+
+    ma_atomic_exchange_explicit_32(&pSound->engineNode.pinnedListenerIndex, listenerIndex, ma_atomic_memory_order_release);
+}
+
+MA_API ma_uint32 ma_sound_get_pinned_listener_index(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_LISTENER_INDEX_CLOSEST;
+    }
+
+    return ma_atomic_load_explicit_32(&pSound->engineNode.pinnedListenerIndex, ma_atomic_memory_order_acquire);
+}
+
+MA_API ma_uint32 ma_sound_get_listener_index(const ma_sound* pSound)
+{
+    ma_uint32 listenerIndex;
+
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    listenerIndex = ma_sound_get_pinned_listener_index(pSound);
+    if (listenerIndex == MA_LISTENER_INDEX_CLOSEST) {
+        ma_vec3f position = ma_sound_get_position(pSound);
+        return ma_engine_find_closest_listener(ma_sound_get_engine(pSound), position.x, position.y, position.z);
+    }
+
+    return listenerIndex;
+}
+
+MA_API ma_vec3f ma_sound_get_direction_to_listener(const ma_sound* pSound)
+{
+    ma_vec3f relativePos;
+    ma_engine* pEngine;
+
+    if (pSound == NULL) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    }
+
+    pEngine = ma_sound_get_engine(pSound);
+    if (pEngine == NULL) {
+        return ma_vec3f_init_3f(0, 0, -1);
+    }
+
+    ma_spatializer_get_relative_position_and_direction(&pSound->engineNode.spatializer, &pEngine->listeners[ma_sound_get_listener_index(pSound)], &relativePos, NULL);
+
+    return ma_vec3f_normalize(ma_vec3f_neg(relativePos));
+}
+
+MA_API void ma_sound_set_position(ma_sound* pSound, float x, float y, float z)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_position(&pSound->engineNode.spatializer, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_get_position(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_spatializer_get_position(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_direction(ma_sound* pSound, float x, float y, float z)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_direction(&pSound->engineNode.spatializer, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_get_direction(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_spatializer_get_direction(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_velocity(ma_sound* pSound, float x, float y, float z)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_velocity(&pSound->engineNode.spatializer, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_get_velocity(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_vec3f_init_3f(0, 0, 0);
+    }
+
+    return ma_spatializer_get_velocity(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_attenuation_model(ma_sound* pSound, ma_attenuation_model attenuationModel)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_attenuation_model(&pSound->engineNode.spatializer, attenuationModel);
+}
+
+MA_API ma_attenuation_model ma_sound_get_attenuation_model(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_attenuation_model_none;
+    }
+
+    return ma_spatializer_get_attenuation_model(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_positioning(ma_sound* pSound, ma_positioning positioning)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_positioning(&pSound->engineNode.spatializer, positioning);
+}
+
+MA_API ma_positioning ma_sound_get_positioning(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return ma_positioning_absolute;
+    }
+
+    return ma_spatializer_get_positioning(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_rolloff(ma_sound* pSound, float rolloff)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_rolloff(&pSound->engineNode.spatializer, rolloff);
+}
+
+MA_API float ma_sound_get_rolloff(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_rolloff(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_min_gain(ma_sound* pSound, float minGain)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_min_gain(&pSound->engineNode.spatializer, minGain);
+}
+
+MA_API float ma_sound_get_min_gain(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_min_gain(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_max_gain(ma_sound* pSound, float maxGain)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_max_gain(&pSound->engineNode.spatializer, maxGain);
+}
+
+MA_API float ma_sound_get_max_gain(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_max_gain(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_min_distance(ma_sound* pSound, float minDistance)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_min_distance(&pSound->engineNode.spatializer, minDistance);
+}
+
+MA_API float ma_sound_get_min_distance(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_min_distance(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_max_distance(ma_sound* pSound, float maxDistance)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_max_distance(&pSound->engineNode.spatializer, maxDistance);
+}
+
+MA_API float ma_sound_get_max_distance(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_max_distance(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_cone(ma_sound* pSound, float innerAngleInRadians, float outerAngleInRadians, float outerGain)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_cone(&pSound->engineNode.spatializer, innerAngleInRadians, outerAngleInRadians, outerGain);
+}
+
+MA_API void ma_sound_get_cone(const ma_sound* pSound, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain)
+{
+    if (pInnerAngleInRadians != NULL) {
+        *pInnerAngleInRadians = 0;
+    }
+
+    if (pOuterAngleInRadians != NULL) {
+        *pOuterAngleInRadians = 0;
+    }
+
+    if (pOuterGain != NULL) {
+        *pOuterGain = 0;
+    }
+
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_get_cone(&pSound->engineNode.spatializer, pInnerAngleInRadians, pOuterAngleInRadians, pOuterGain);
+}
+
+MA_API void ma_sound_set_doppler_factor(ma_sound* pSound, float dopplerFactor)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_doppler_factor(&pSound->engineNode.spatializer, dopplerFactor);
+}
+
+MA_API float ma_sound_get_doppler_factor(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_spatializer_get_doppler_factor(&pSound->engineNode.spatializer);
+}
+
+MA_API void ma_sound_set_directional_attenuation_factor(ma_sound* pSound, float directionalAttenuationFactor)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_spatializer_set_directional_attenuation_factor(&pSound->engineNode.spatializer, directionalAttenuationFactor);
+}
+
+MA_API float ma_sound_get_directional_attenuation_factor(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 1;
+    }
+
+    return ma_spatializer_get_directional_attenuation_factor(&pSound->engineNode.spatializer);
+}
+
+
+MA_API void ma_sound_set_fade_in_pcm_frames(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_sound_set_fade_start_in_pcm_frames(pSound, volumeBeg, volumeEnd, fadeLengthInFrames, (~(ma_uint64)0));
+}
+
+MA_API void ma_sound_set_fade_in_milliseconds(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_sound_set_fade_in_pcm_frames(pSound, volumeBeg, volumeEnd, (fadeLengthInMilliseconds * pSound->engineNode.fader.config.sampleRate) / 1000);
+}
+
+MA_API void ma_sound_set_fade_start_in_pcm_frames(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames, ma_uint64 absoluteGlobalTimeInFrames)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    /*
+    We don't want to update the fader at this point because we need to use the engine's current time
+    to derive the fader's start offset. The timer is being updated on the audio thread so in order to
+    do this as accurately as possible we'll need to defer this to the audio thread.
+    */
+    ma_atomic_float_set(&pSound->engineNode.fadeSettings.volumeBeg, volumeBeg);
+    ma_atomic_float_set(&pSound->engineNode.fadeSettings.volumeEnd, volumeEnd);
+    ma_atomic_uint64_set(&pSound->engineNode.fadeSettings.fadeLengthInFrames, fadeLengthInFrames);
+    ma_atomic_uint64_set(&pSound->engineNode.fadeSettings.absoluteGlobalTimeInFrames, absoluteGlobalTimeInFrames);
+}
+
+MA_API void ma_sound_set_fade_start_in_milliseconds(ma_sound* pSound, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds, ma_uint64 absoluteGlobalTimeInMilliseconds)
+{
+    ma_uint32 sampleRate;
+
+    if (pSound == NULL) {
+        return;
+    }
+
+    sampleRate = ma_engine_get_sample_rate(ma_sound_get_engine(pSound));
+
+    ma_sound_set_fade_start_in_pcm_frames(pSound, volumeBeg, volumeEnd, (fadeLengthInMilliseconds * sampleRate) / 1000, (absoluteGlobalTimeInMilliseconds * sampleRate) / 1000);
+}
+
+MA_API float ma_sound_get_current_fade_volume(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    return ma_fader_get_current_volume(&pSound->engineNode.fader);
+}
+
+MA_API void ma_sound_set_start_time_in_pcm_frames(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInFrames)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_node_set_state_time(pSound, ma_node_state_started, absoluteGlobalTimeInFrames);
+}
+
+MA_API void ma_sound_set_start_time_in_milliseconds(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInMilliseconds)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_sound_set_start_time_in_pcm_frames(pSound, absoluteGlobalTimeInMilliseconds * ma_engine_get_sample_rate(ma_sound_get_engine(pSound)) / 1000);
+}
+
+MA_API void ma_sound_set_stop_time_in_pcm_frames(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInFrames)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_sound_set_stop_time_with_fade_in_pcm_frames(pSound, absoluteGlobalTimeInFrames, 0);
+}
+
+MA_API void ma_sound_set_stop_time_in_milliseconds(ma_sound* pSound, ma_uint64 absoluteGlobalTimeInMilliseconds)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    ma_sound_set_stop_time_in_pcm_frames(pSound, absoluteGlobalTimeInMilliseconds * ma_engine_get_sample_rate(ma_sound_get_engine(pSound)) / 1000);
+}
+
+MA_API void ma_sound_set_stop_time_with_fade_in_pcm_frames(ma_sound* pSound, ma_uint64 stopAbsoluteGlobalTimeInFrames, ma_uint64 fadeLengthInFrames)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    if (fadeLengthInFrames > 0) {
+        if (fadeLengthInFrames > stopAbsoluteGlobalTimeInFrames) {
+            fadeLengthInFrames = stopAbsoluteGlobalTimeInFrames;
+        }
+
+        ma_sound_set_fade_start_in_pcm_frames(pSound, -1, 0, fadeLengthInFrames, stopAbsoluteGlobalTimeInFrames - fadeLengthInFrames);
+    }
+
+    ma_node_set_state_time(pSound, ma_node_state_stopped, stopAbsoluteGlobalTimeInFrames);
+}
+
+MA_API void ma_sound_set_stop_time_with_fade_in_milliseconds(ma_sound* pSound, ma_uint64 stopAbsoluteGlobalTimeInMilliseconds, ma_uint64 fadeLengthInMilliseconds)
+{
+    ma_uint32 sampleRate;
+
+    if (pSound == NULL) {
+        return;
+    }
+
+    sampleRate = ma_engine_get_sample_rate(ma_sound_get_engine(pSound));
+
+    ma_sound_set_stop_time_with_fade_in_pcm_frames(pSound, (stopAbsoluteGlobalTimeInMilliseconds * sampleRate) / 1000, (fadeLengthInMilliseconds * sampleRate) / 1000);
+}
+
+MA_API ma_bool32 ma_sound_is_playing(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_node_get_state_by_time(pSound, ma_engine_get_time_in_pcm_frames(ma_sound_get_engine(pSound))) == ma_node_state_started;
+}
+
+MA_API ma_uint64 ma_sound_get_time_in_pcm_frames(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return 0;
+    }
+
+    return ma_node_get_time(pSound);
+}
+
+MA_API ma_uint64 ma_sound_get_time_in_milliseconds(const ma_sound* pSound)
+{
+    return ma_sound_get_time_in_pcm_frames(pSound) * 1000 / ma_engine_get_sample_rate(ma_sound_get_engine(pSound));
+}
+
+MA_API void ma_sound_set_looping(ma_sound* pSound, ma_bool32 isLooping)
+{
+    if (pSound == NULL) {
+        return;
+    }
+
+    /* Looping is only a valid concept if the sound is backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return;
+    }
+
+    /* The looping state needs to be applied to the data source in order for any looping to actually happen. */
+    ma_data_source_set_looping(pSound->pDataSource, isLooping);
+}
+
+MA_API ma_bool32 ma_sound_is_looping(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_FALSE;
+    }
+
+    /* There is no notion of looping for sounds that are not backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_data_source_is_looping(pSound->pDataSource);
+}
+
+MA_API ma_bool32 ma_sound_at_end(const ma_sound* pSound)
+{
+    if (pSound == NULL) {
+        return MA_FALSE;
+    }
+
+    /* There is no notion of an end of a sound if it's not backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_FALSE;
+    }
+
+    return ma_sound_get_at_end(pSound);
+}
+
+MA_API ma_result ma_sound_seek_to_pcm_frame(ma_sound* pSound, ma_uint64 frameIndex)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* Seeking is only valid for sounds that are backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    /* We can't be seeking while reading at the same time. We just set the seek target and get the mixing thread to do the actual seek. */
+    ma_atomic_exchange_64(&pSound->seekTarget, frameIndex);
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_sound_get_data_format(ma_sound* pSound, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate, ma_channel* pChannelMap, size_t channelMapCap)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The data format is retrieved directly from the data source if the sound is backed by one. Otherwise we pull it from the node. */
+    if (pSound->pDataSource == NULL) {
+        ma_uint32 channels;
+
+        if (pFormat != NULL) {
+            *pFormat = ma_format_f32;
+        }
+
+        channels = ma_node_get_input_channels(&pSound->engineNode, 0);
+        if (pChannels != NULL) {
+            *pChannels = channels;
+        }
+
+        if (pSampleRate != NULL) {
+            *pSampleRate = pSound->engineNode.resampler.config.sampleRateIn;
+        }
+
+        if (pChannelMap != NULL) {
+            ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, channels);
+        }
+
+        return MA_SUCCESS;
+    } else {
+        return ma_data_source_get_data_format(pSound->pDataSource, pFormat, pChannels, pSampleRate, pChannelMap, channelMapCap);
+    }
+}
+
+MA_API ma_result ma_sound_get_cursor_in_pcm_frames(ma_sound* pSound, ma_uint64* pCursor)
+{
+    ma_uint64 seekTarget;
+
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The notion of a cursor is only valid for sounds that are backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    seekTarget = ma_atomic_load_64(&pSound->seekTarget);
+    if (seekTarget != MA_SEEK_TARGET_NONE) {
+        *pCursor = seekTarget;
+        return MA_SUCCESS;
+    } else {
+        return ma_data_source_get_cursor_in_pcm_frames(pSound->pDataSource, pCursor);
+    }
+}
+
+MA_API ma_result ma_sound_get_length_in_pcm_frames(ma_sound* pSound, ma_uint64* pLength)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The notion of a sound length is only valid for sounds that are backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    return ma_data_source_get_length_in_pcm_frames(pSound->pDataSource, pLength);
+}
+
+MA_API ma_result ma_sound_get_cursor_in_seconds(ma_sound* pSound, float* pCursor)
+{
+    ma_result result;
+    ma_uint64 cursorInPCMFrames;
+    ma_uint32 sampleRate;
+
+    if (pCursor != NULL) {
+        *pCursor = 0;
+    }
+
+    result = ma_sound_get_cursor_in_pcm_frames(pSound, &cursorInPCMFrames);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    result = ma_sound_get_data_format(pSound, NULL, NULL, &sampleRate, NULL, 0);
+    if (result != MA_SUCCESS) {
+        return result;
+    }
+
+    /* VC6 does not support division of unsigned 64-bit integers with floating point numbers. Need to use a signed number. This shouldn't effect anything in practice. */
+    *pCursor = (ma_int64)cursorInPCMFrames / (float)sampleRate;
+
+    return MA_SUCCESS;
+}
+
+MA_API ma_result ma_sound_get_length_in_seconds(ma_sound* pSound, float* pLength)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The notion of a sound length is only valid for sounds that are backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    return ma_data_source_get_length_in_seconds(pSound->pDataSource, pLength);
+}
+
+MA_API ma_result ma_sound_set_end_callback(ma_sound* pSound, ma_sound_end_proc callback, void* pUserData)
+{
+    if (pSound == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* The notion of an end is only valid for sounds that are backed by a data source. */
+    if (pSound->pDataSource == NULL) {
+        return MA_INVALID_OPERATION;
+    }
+
+    pSound->endCallback          = callback;
+    pSound->pEndCallbackUserData = pUserData;
+
+    return MA_SUCCESS;
+}
+
+
+MA_API ma_result ma_sound_group_init(ma_engine* pEngine, ma_uint32 flags, ma_sound_group* pParentGroup, ma_sound_group* pGroup)
+{
+    ma_sound_group_config config = ma_sound_group_config_init_2(pEngine);
+    config.flags              = flags;
+    config.pInitialAttachment = pParentGroup;
+    return ma_sound_group_init_ex(pEngine, &config, pGroup);
+}
+
+MA_API ma_result ma_sound_group_init_ex(ma_engine* pEngine, const ma_sound_group_config* pConfig, ma_sound_group* pGroup)
+{
+    ma_sound_config soundConfig;
+
+    if (pGroup == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    MA_ZERO_OBJECT(pGroup);
+
+    if (pConfig == NULL) {
+        return MA_INVALID_ARGS;
+    }
+
+    /* A sound group is just a sound without a data source. */
+    soundConfig = *pConfig;
+    soundConfig.pFilePath   = NULL;
+    soundConfig.pFilePathW  = NULL;
+    soundConfig.pDataSource = NULL;
+
+    /*
+    Groups need to have spatialization disabled by default because I think it'll be pretty rare
+    that programs will want to spatialize groups (but not unheard of). Certainly it feels like
+    disabling this by default feels like the right option. Spatialization can be enabled with a
+    call to ma_sound_group_set_spatialization_enabled().
+    */
+    soundConfig.flags |= MA_SOUND_FLAG_NO_SPATIALIZATION;
+
+    return ma_sound_init_ex(pEngine, &soundConfig, pGroup);
+}
+
+MA_API void ma_sound_group_uninit(ma_sound_group* pGroup)
+{
+    ma_sound_uninit(pGroup);
+}
+
+MA_API ma_engine* ma_sound_group_get_engine(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_engine(pGroup);
+}
+
+MA_API ma_result ma_sound_group_start(ma_sound_group* pGroup)
+{
+    return ma_sound_start(pGroup);
+}
+
+MA_API ma_result ma_sound_group_stop(ma_sound_group* pGroup)
+{
+    return ma_sound_stop(pGroup);
+}
+
+MA_API void ma_sound_group_set_volume(ma_sound_group* pGroup, float volume)
+{
+    ma_sound_set_volume(pGroup, volume);
+}
+
+MA_API float ma_sound_group_get_volume(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_volume(pGroup);
+}
+
+MA_API void ma_sound_group_set_pan(ma_sound_group* pGroup, float pan)
+{
+    ma_sound_set_pan(pGroup, pan);
+}
+
+MA_API float ma_sound_group_get_pan(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_pan(pGroup);
+}
+
+MA_API void ma_sound_group_set_pan_mode(ma_sound_group* pGroup, ma_pan_mode panMode)
+{
+    ma_sound_set_pan_mode(pGroup, panMode);
+}
+
+MA_API ma_pan_mode ma_sound_group_get_pan_mode(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_pan_mode(pGroup);
+}
+
+MA_API void ma_sound_group_set_pitch(ma_sound_group* pGroup, float pitch)
+{
+    ma_sound_set_pitch(pGroup, pitch);
+}
+
+MA_API float ma_sound_group_get_pitch(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_pitch(pGroup);
+}
+
+MA_API void ma_sound_group_set_spatialization_enabled(ma_sound_group* pGroup, ma_bool32 enabled)
+{
+    ma_sound_set_spatialization_enabled(pGroup, enabled);
+}
+
+MA_API ma_bool32 ma_sound_group_is_spatialization_enabled(const ma_sound_group* pGroup)
+{
+    return ma_sound_is_spatialization_enabled(pGroup);
+}
+
+MA_API void ma_sound_group_set_pinned_listener_index(ma_sound_group* pGroup, ma_uint32 listenerIndex)
+{
+    ma_sound_set_pinned_listener_index(pGroup, listenerIndex);
+}
+
+MA_API ma_uint32 ma_sound_group_get_pinned_listener_index(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_pinned_listener_index(pGroup);
+}
+
+MA_API ma_uint32 ma_sound_group_get_listener_index(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_listener_index(pGroup);
+}
+
+MA_API ma_vec3f ma_sound_group_get_direction_to_listener(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_direction_to_listener(pGroup);
+}
+
+MA_API void ma_sound_group_set_position(ma_sound_group* pGroup, float x, float y, float z)
+{
+    ma_sound_set_position(pGroup, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_group_get_position(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_position(pGroup);
+}
+
+MA_API void ma_sound_group_set_direction(ma_sound_group* pGroup, float x, float y, float z)
+{
+    ma_sound_set_direction(pGroup, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_group_get_direction(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_direction(pGroup);
+}
+
+MA_API void ma_sound_group_set_velocity(ma_sound_group* pGroup, float x, float y, float z)
+{
+    ma_sound_set_velocity(pGroup, x, y, z);
+}
+
+MA_API ma_vec3f ma_sound_group_get_velocity(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_velocity(pGroup);
+}
+
+MA_API void ma_sound_group_set_attenuation_model(ma_sound_group* pGroup, ma_attenuation_model attenuationModel)
+{
+    ma_sound_set_attenuation_model(pGroup, attenuationModel);
+}
+
+MA_API ma_attenuation_model ma_sound_group_get_attenuation_model(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_attenuation_model(pGroup);
+}
+
+MA_API void ma_sound_group_set_positioning(ma_sound_group* pGroup, ma_positioning positioning)
+{
+    ma_sound_set_positioning(pGroup, positioning);
+}
+
+MA_API ma_positioning ma_sound_group_get_positioning(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_positioning(pGroup);
+}
+
+MA_API void ma_sound_group_set_rolloff(ma_sound_group* pGroup, float rolloff)
+{
+    ma_sound_set_rolloff(pGroup, rolloff);
+}
+
+MA_API float ma_sound_group_get_rolloff(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_rolloff(pGroup);
+}
+
+MA_API void ma_sound_group_set_min_gain(ma_sound_group* pGroup, float minGain)
+{
+    ma_sound_set_min_gain(pGroup, minGain);
+}
+
+MA_API float ma_sound_group_get_min_gain(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_min_gain(pGroup);
+}
+
+MA_API void ma_sound_group_set_max_gain(ma_sound_group* pGroup, float maxGain)
+{
+    ma_sound_set_max_gain(pGroup, maxGain);
+}
+
+MA_API float ma_sound_group_get_max_gain(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_max_gain(pGroup);
+}
+
+MA_API void ma_sound_group_set_min_distance(ma_sound_group* pGroup, float minDistance)
+{
+    ma_sound_set_min_distance(pGroup, minDistance);
+}
+
+MA_API float ma_sound_group_get_min_distance(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_min_distance(pGroup);
+}
+
+MA_API void ma_sound_group_set_max_distance(ma_sound_group* pGroup, float maxDistance)
+{
+    ma_sound_set_max_distance(pGroup, maxDistance);
+}
+
+MA_API float ma_sound_group_get_max_distance(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_max_distance(pGroup);
+}
+
+MA_API void ma_sound_group_set_cone(ma_sound_group* pGroup, float innerAngleInRadians, float outerAngleInRadians, float outerGain)
+{
+    ma_sound_set_cone(pGroup, innerAngleInRadians, outerAngleInRadians, outerGain);
+}
+
+MA_API void ma_sound_group_get_cone(const ma_sound_group* pGroup, float* pInnerAngleInRadians, float* pOuterAngleInRadians, float* pOuterGain)
+{
+    ma_sound_get_cone(pGroup, pInnerAngleInRadians, pOuterAngleInRadians, pOuterGain);
+}
+
+MA_API void ma_sound_group_set_doppler_factor(ma_sound_group* pGroup, float dopplerFactor)
+{
+    ma_sound_set_doppler_factor(pGroup, dopplerFactor);
+}
+
+MA_API float ma_sound_group_get_doppler_factor(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_doppler_factor(pGroup);
+}
+
+MA_API void ma_sound_group_set_directional_attenuation_factor(ma_sound_group* pGroup, float directionalAttenuationFactor)
+{
+    ma_sound_set_directional_attenuation_factor(pGroup, directionalAttenuationFactor);
+}
+
+MA_API float ma_sound_group_get_directional_attenuation_factor(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_directional_attenuation_factor(pGroup);
+}
+
+MA_API void ma_sound_group_set_fade_in_pcm_frames(ma_sound_group* pGroup, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInFrames)
+{
+    ma_sound_set_fade_in_pcm_frames(pGroup, volumeBeg, volumeEnd, fadeLengthInFrames);
+}
+
+MA_API void ma_sound_group_set_fade_in_milliseconds(ma_sound_group* pGroup, float volumeBeg, float volumeEnd, ma_uint64 fadeLengthInMilliseconds)
+{
+    ma_sound_set_fade_in_milliseconds(pGroup, volumeBeg, volumeEnd, fadeLengthInMilliseconds);
+}
+
+MA_API float ma_sound_group_get_current_fade_volume(ma_sound_group* pGroup)
+{
+    return ma_sound_get_current_fade_volume(pGroup);
+}
+
+MA_API void ma_sound_group_set_start_time_in_pcm_frames(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInFrames)
+{
+    ma_sound_set_start_time_in_pcm_frames(pGroup, absoluteGlobalTimeInFrames);
+}
+
+MA_API void ma_sound_group_set_start_time_in_milliseconds(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInMilliseconds)
+{
+    ma_sound_set_start_time_in_milliseconds(pGroup, absoluteGlobalTimeInMilliseconds);
+}
+
+MA_API void ma_sound_group_set_stop_time_in_pcm_frames(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInFrames)
+{
+    ma_sound_set_stop_time_in_pcm_frames(pGroup, absoluteGlobalTimeInFrames);
+}
+
+MA_API void ma_sound_group_set_stop_time_in_milliseconds(ma_sound_group* pGroup, ma_uint64 absoluteGlobalTimeInMilliseconds)
+{
+    ma_sound_set_stop_time_in_milliseconds(pGroup, absoluteGlobalTimeInMilliseconds);
+}
+
+MA_API ma_bool32 ma_sound_group_is_playing(const ma_sound_group* pGroup)
+{
+    return ma_sound_is_playing(pGroup);
+}
+
+MA_API ma_uint64 ma_sound_group_get_time_in_pcm_frames(const ma_sound_group* pGroup)
+{
+    return ma_sound_get_time_in_pcm_frames(pGroup);
+}
+#endif  /* MA_NO_ENGINE */
+/* END SECTION: miniaudio_engine.c */
+
+
+
+/**************************************************************************************************************************************************************
+***************************************************************************************************************************************************************
+
+Auto Generated
+==============
+All code below is auto-generated from a tool. This mostly consists of decoding backend implementations such as ma_dr_wav, ma_dr_flac, etc. If you find a bug in the
+code below please report the bug to the respective repository for the relevant project (probably dr_libs).
+
+***************************************************************************************************************************************************************
+**************************************************************************************************************************************************************/
+#if !defined(MA_NO_WAV) && (!defined(MA_NO_DECODING) || !defined(MA_NO_ENCODING))
+#if !defined(MA_DR_WAV_IMPLEMENTATION) && !defined(MA_DR_WAV_IMPLEMENTATION) /* For backwards compatibility. Will be removed in version 0.11 for cleanliness. */
+/* dr_wav_c begin */
+#ifndef ma_dr_wav_c
+#define ma_dr_wav_c
+#ifdef __MRC__
+#pragma options opt off
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#ifndef MA_DR_WAV_NO_STDIO
+#include <stdio.h>
+#ifndef MA_DR_WAV_NO_WCHAR
+#include <wchar.h>
+#endif
+#endif
+#ifndef MA_DR_WAV_ASSERT
+#include <assert.h>
+#define MA_DR_WAV_ASSERT(expression)           assert(expression)
+#endif
+#ifndef MA_DR_WAV_MALLOC
+#define MA_DR_WAV_MALLOC(sz)                   malloc((sz))
+#endif
+#ifndef MA_DR_WAV_REALLOC
+#define MA_DR_WAV_REALLOC(p, sz)               realloc((p), (sz))
+#endif
+#ifndef MA_DR_WAV_FREE
+#define MA_DR_WAV_FREE(p)                      free((p))
+#endif
+#ifndef MA_DR_WAV_COPY_MEMORY
+#define MA_DR_WAV_COPY_MEMORY(dst, src, sz)    memcpy((dst), (src), (sz))
+#endif
+#ifndef MA_DR_WAV_ZERO_MEMORY
+#define MA_DR_WAV_ZERO_MEMORY(p, sz)           memset((p), 0, (sz))
+#endif
+#ifndef MA_DR_WAV_ZERO_OBJECT
+#define MA_DR_WAV_ZERO_OBJECT(p)               MA_DR_WAV_ZERO_MEMORY((p), sizeof(*p))
+#endif
+#define ma_dr_wav_countof(x)                   (sizeof(x) / sizeof(x[0]))
+#define ma_dr_wav_align(x, a)                  ((((x) + (a) - 1) / (a)) * (a))
+#define ma_dr_wav_min(a, b)                    (((a) < (b)) ? (a) : (b))
+#define ma_dr_wav_max(a, b)                    (((a) > (b)) ? (a) : (b))
+#define ma_dr_wav_clamp(x, lo, hi)             (ma_dr_wav_max((lo), ma_dr_wav_min((hi), (x))))
+#define ma_dr_wav_offset_ptr(p, offset)        (((ma_uint8*)(p)) + (offset))
+#define MA_DR_WAV_MAX_SIMD_VECTOR_SIZE         32
+#define MA_DR_WAV_INT64_MIN ((ma_int64) ((ma_uint64)0x80000000 << 32))
+#define MA_DR_WAV_INT64_MAX ((ma_int64)(((ma_uint64)0x7FFFFFFF << 32) | 0xFFFFFFFF))
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+    #define MA_DR_WAV_HAS_BYTESWAP16_INTRINSIC
+    #define MA_DR_WAV_HAS_BYTESWAP32_INTRINSIC
+    #define MA_DR_WAV_HAS_BYTESWAP64_INTRINSIC
+#elif defined(__clang__)
+    #if defined(__has_builtin)
+        #if __has_builtin(__builtin_bswap16)
+            #define MA_DR_WAV_HAS_BYTESWAP16_INTRINSIC
+        #endif
+        #if __has_builtin(__builtin_bswap32)
+            #define MA_DR_WAV_HAS_BYTESWAP32_INTRINSIC
+        #endif
+        #if __has_builtin(__builtin_bswap64)
+            #define MA_DR_WAV_HAS_BYTESWAP64_INTRINSIC
+        #endif
+    #endif
+#elif defined(__GNUC__)
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+        #define MA_DR_WAV_HAS_BYTESWAP32_INTRINSIC
+        #define MA_DR_WAV_HAS_BYTESWAP64_INTRINSIC
+    #endif
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+        #define MA_DR_WAV_HAS_BYTESWAP16_INTRINSIC
+    #endif
+#endif
+MA_API void ma_dr_wav_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision)
+{
+    if (pMajor) {
+        *pMajor = MA_DR_WAV_VERSION_MAJOR;
+    }
+    if (pMinor) {
+        *pMinor = MA_DR_WAV_VERSION_MINOR;
+    }
+    if (pRevision) {
+        *pRevision = MA_DR_WAV_VERSION_REVISION;
+    }
+}
+MA_API const char* ma_dr_wav_version_string(void)
+{
+    return MA_DR_WAV_VERSION_STRING;
+}
+#ifndef MA_DR_WAV_MAX_SAMPLE_RATE
+#define MA_DR_WAV_MAX_SAMPLE_RATE       384000
+#endif
+#ifndef MA_DR_WAV_MAX_CHANNELS
+#define MA_DR_WAV_MAX_CHANNELS          256
+#endif
+#ifndef MA_DR_WAV_MAX_BITS_PER_SAMPLE
+#define MA_DR_WAV_MAX_BITS_PER_SAMPLE   64
+#endif
+static const ma_uint8 ma_dr_wavGUID_W64_RIFF[16] = {0x72,0x69,0x66,0x66, 0x2E,0x91, 0xCF,0x11, 0xA5,0xD6, 0x28,0xDB,0x04,0xC1,0x00,0x00};
+static const ma_uint8 ma_dr_wavGUID_W64_WAVE[16] = {0x77,0x61,0x76,0x65, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
+static const ma_uint8 ma_dr_wavGUID_W64_FMT [16] = {0x66,0x6D,0x74,0x20, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
+static const ma_uint8 ma_dr_wavGUID_W64_FACT[16] = {0x66,0x61,0x63,0x74, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
+static const ma_uint8 ma_dr_wavGUID_W64_DATA[16] = {0x64,0x61,0x74,0x61, 0xF3,0xAC, 0xD3,0x11, 0x8C,0xD1, 0x00,0xC0,0x4F,0x8E,0xDB,0x8A};
+static MA_INLINE int ma_dr_wav__is_little_endian(void)
+{
+#if defined(MA_X86) || defined(MA_X64)
+    return MA_TRUE;
+#elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN
+    return MA_TRUE;
+#else
+    int n = 1;
+    return (*(char*)&n) == 1;
+#endif
+}
+static MA_INLINE void ma_dr_wav_bytes_to_guid(const ma_uint8* data, ma_uint8* guid)
+{
+    int i;
+    for (i = 0; i < 16; ++i) {
+        guid[i] = data[i];
+    }
+}
+static MA_INLINE ma_uint16 ma_dr_wav__bswap16(ma_uint16 n)
+{
+#ifdef MA_DR_WAV_HAS_BYTESWAP16_INTRINSIC
+    #if defined(_MSC_VER)
+        return _byteswap_ushort(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        return __builtin_bswap16(n);
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & 0xFF00) >> 8) |
+           ((n & 0x00FF) << 8);
+#endif
+}
+static MA_INLINE ma_uint32 ma_dr_wav__bswap32(ma_uint32 n)
+{
+#ifdef MA_DR_WAV_HAS_BYTESWAP32_INTRINSIC
+    #if defined(_MSC_VER)
+        return _byteswap_ulong(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        #if defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(MA_64BIT)
+            ma_uint32 r;
+            __asm__ __volatile__ (
+            #if defined(MA_64BIT)
+                "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n)
+            #else
+                "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n)
+            #endif
+            );
+            return r;
+        #else
+            return __builtin_bswap32(n);
+        #endif
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & 0xFF000000) >> 24) |
+           ((n & 0x00FF0000) >>  8) |
+           ((n & 0x0000FF00) <<  8) |
+           ((n & 0x000000FF) << 24);
+#endif
+}
+static MA_INLINE ma_uint64 ma_dr_wav__bswap64(ma_uint64 n)
+{
+#ifdef MA_DR_WAV_HAS_BYTESWAP64_INTRINSIC
+    #if defined(_MSC_VER)
+        return _byteswap_uint64(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        return __builtin_bswap64(n);
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & ((ma_uint64)0xFF000000 << 32)) >> 56) |
+           ((n & ((ma_uint64)0x00FF0000 << 32)) >> 40) |
+           ((n & ((ma_uint64)0x0000FF00 << 32)) >> 24) |
+           ((n & ((ma_uint64)0x000000FF << 32)) >>  8) |
+           ((n & ((ma_uint64)0xFF000000      )) <<  8) |
+           ((n & ((ma_uint64)0x00FF0000      )) << 24) |
+           ((n & ((ma_uint64)0x0000FF00      )) << 40) |
+           ((n & ((ma_uint64)0x000000FF      )) << 56);
+#endif
+}
+static MA_INLINE ma_int16 ma_dr_wav__bswap_s16(ma_int16 n)
+{
+    return (ma_int16)ma_dr_wav__bswap16((ma_uint16)n);
+}
+static MA_INLINE void ma_dr_wav__bswap_samples_s16(ma_int16* pSamples, ma_uint64 sampleCount)
+{
+    ma_uint64 iSample;
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamples[iSample] = ma_dr_wav__bswap_s16(pSamples[iSample]);
+    }
+}
+static MA_INLINE void ma_dr_wav__bswap_s24(ma_uint8* p)
+{
+    ma_uint8 t;
+    t = p[0];
+    p[0] = p[2];
+    p[2] = t;
+}
+static MA_INLINE void ma_dr_wav__bswap_samples_s24(ma_uint8* pSamples, ma_uint64 sampleCount)
+{
+    ma_uint64 iSample;
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        ma_uint8* pSample = pSamples + (iSample*3);
+        ma_dr_wav__bswap_s24(pSample);
+    }
+}
+static MA_INLINE ma_int32 ma_dr_wav__bswap_s32(ma_int32 n)
+{
+    return (ma_int32)ma_dr_wav__bswap32((ma_uint32)n);
+}
+static MA_INLINE void ma_dr_wav__bswap_samples_s32(ma_int32* pSamples, ma_uint64 sampleCount)
+{
+    ma_uint64 iSample;
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamples[iSample] = ma_dr_wav__bswap_s32(pSamples[iSample]);
+    }
+}
+static MA_INLINE ma_int64 ma_dr_wav__bswap_s64(ma_int64 n)
+{
+    return (ma_int64)ma_dr_wav__bswap64((ma_uint64)n);
+}
+static MA_INLINE void ma_dr_wav__bswap_samples_s64(ma_int64* pSamples, ma_uint64 sampleCount)
+{
+    ma_uint64 iSample;
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamples[iSample] = ma_dr_wav__bswap_s64(pSamples[iSample]);
+    }
+}
+static MA_INLINE float ma_dr_wav__bswap_f32(float n)
+{
+    union {
+        ma_uint32 i;
+        float f;
+    } x;
+    x.f = n;
+    x.i = ma_dr_wav__bswap32(x.i);
+    return x.f;
+}
+static MA_INLINE void ma_dr_wav__bswap_samples_f32(float* pSamples, ma_uint64 sampleCount)
+{
+    ma_uint64 iSample;
+    for (iSample = 0; iSample < sampleCount; iSample += 1) {
+        pSamples[iSample] = ma_dr_wav__bswap_f32(pSamples[iSample]);
+    }
+}
+static MA_INLINE void ma_dr_wav__bswap_samples(void* pSamples, ma_uint64 sampleCount, ma_uint32 bytesPerSample)
+{
+    switch (bytesPerSample)
+    {
+        case 1:
+        {
+        } break;
+        case 2:
+        {
+            ma_dr_wav__bswap_samples_s16((ma_int16*)pSamples, sampleCount);
+        } break;
+        case 3:
+        {
+            ma_dr_wav__bswap_samples_s24((ma_uint8*)pSamples, sampleCount);
+        } break;
+        case 4:
+        {
+            ma_dr_wav__bswap_samples_s32((ma_int32*)pSamples, sampleCount);
+        } break;
+        case 8:
+        {
+            ma_dr_wav__bswap_samples_s64((ma_int64*)pSamples, sampleCount);
+        } break;
+        default:
+        {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+        } break;
+    }
+}
+MA_PRIVATE MA_INLINE ma_bool32 ma_dr_wav_is_container_be(ma_dr_wav_container container)
+{
+    if (container == ma_dr_wav_container_rifx || container == ma_dr_wav_container_aiff) {
+        return MA_TRUE;
+    } else {
+        return MA_FALSE;
+    }
+}
+MA_PRIVATE MA_INLINE ma_uint16 ma_dr_wav_bytes_to_u16_le(const ma_uint8* data)
+{
+    return ((ma_uint16)data[0] << 0) | ((ma_uint16)data[1] << 8);
+}
+MA_PRIVATE MA_INLINE ma_uint16 ma_dr_wav_bytes_to_u16_be(const ma_uint8* data)
+{
+    return ((ma_uint16)data[1] << 0) | ((ma_uint16)data[0] << 8);
+}
+MA_PRIVATE MA_INLINE ma_uint16 ma_dr_wav_bytes_to_u16_ex(const ma_uint8* data, ma_dr_wav_container container)
+{
+    if (ma_dr_wav_is_container_be(container)) {
+        return ma_dr_wav_bytes_to_u16_be(data);
+    } else {
+        return ma_dr_wav_bytes_to_u16_le(data);
+    }
+}
+MA_PRIVATE MA_INLINE ma_uint32 ma_dr_wav_bytes_to_u32_le(const ma_uint8* data)
+{
+    return ((ma_uint32)data[0] << 0) | ((ma_uint32)data[1] << 8) | ((ma_uint32)data[2] << 16) | ((ma_uint32)data[3] << 24);
+}
+MA_PRIVATE MA_INLINE ma_uint32 ma_dr_wav_bytes_to_u32_be(const ma_uint8* data)
+{
+    return ((ma_uint32)data[3] << 0) | ((ma_uint32)data[2] << 8) | ((ma_uint32)data[1] << 16) | ((ma_uint32)data[0] << 24);
+}
+MA_PRIVATE MA_INLINE ma_uint32 ma_dr_wav_bytes_to_u32_ex(const ma_uint8* data, ma_dr_wav_container container)
+{
+    if (ma_dr_wav_is_container_be(container)) {
+        return ma_dr_wav_bytes_to_u32_be(data);
+    } else {
+        return ma_dr_wav_bytes_to_u32_le(data);
+    }
+}
+MA_PRIVATE ma_int64 ma_dr_wav_aiff_extented_to_s64(const ma_uint8* data)
+{
+    ma_uint32 exponent = ((ma_uint32)data[0] << 8) | data[1];
+    ma_uint64 hi = ((ma_uint64)data[2] << 24) | ((ma_uint64)data[3] << 16) | ((ma_uint64)data[4] <<  8) | ((ma_uint64)data[5] <<  0);
+    ma_uint64 lo = ((ma_uint64)data[6] << 24) | ((ma_uint64)data[7] << 16) | ((ma_uint64)data[8] <<  8) | ((ma_uint64)data[9] <<  0);
+    ma_uint64 significand = (hi << 32) | lo;
+    int sign = exponent >> 15;
+    exponent &= 0x7FFF;
+    if (exponent == 0 && significand == 0) {
+        return 0;
+    } else if (exponent == 0x7FFF) {
+        return sign ? MA_DR_WAV_INT64_MIN : MA_DR_WAV_INT64_MAX;
+    }
+    exponent -= 16383;
+    if (exponent > 63) {
+        return sign ? MA_DR_WAV_INT64_MIN : MA_DR_WAV_INT64_MAX;
+    } else if (exponent < 1) {
+        return 0;
+    }
+    significand >>= (63 - exponent);
+    if (sign) {
+        return -(ma_int64)significand;
+    } else {
+        return  (ma_int64)significand;
+    }
+}
+MA_PRIVATE void* ma_dr_wav__malloc_default(size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_WAV_MALLOC(sz);
+}
+MA_PRIVATE void* ma_dr_wav__realloc_default(void* p, size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_WAV_REALLOC(p, sz);
+}
+MA_PRIVATE void ma_dr_wav__free_default(void* p, void* pUserData)
+{
+    (void)pUserData;
+    MA_DR_WAV_FREE(p);
+}
+MA_PRIVATE void* ma_dr_wav__malloc_from_callbacks(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onMalloc != NULL) {
+        return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(NULL, sz, pAllocationCallbacks->pUserData);
+    }
+    return NULL;
+}
+MA_PRIVATE void* ma_dr_wav__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(p, szNew, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) {
+        void* p2;
+        p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData);
+        if (p2 == NULL) {
+            return NULL;
+        }
+        if (p != NULL) {
+            MA_DR_WAV_COPY_MEMORY(p2, p, szOld);
+            pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+        }
+        return p2;
+    }
+    return NULL;
+}
+MA_PRIVATE void ma_dr_wav__free_from_callbacks(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (p == NULL || pAllocationCallbacks == NULL) {
+        return;
+    }
+    if (pAllocationCallbacks->onFree != NULL) {
+        pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+    }
+}
+MA_PRIVATE ma_allocation_callbacks ma_dr_wav_copy_allocation_callbacks_or_defaults(const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        return *pAllocationCallbacks;
+    } else {
+        ma_allocation_callbacks allocationCallbacks;
+        allocationCallbacks.pUserData = NULL;
+        allocationCallbacks.onMalloc  = ma_dr_wav__malloc_default;
+        allocationCallbacks.onRealloc = ma_dr_wav__realloc_default;
+        allocationCallbacks.onFree    = ma_dr_wav__free_default;
+        return allocationCallbacks;
+    }
+}
+static MA_INLINE ma_bool32 ma_dr_wav__is_compressed_format_tag(ma_uint16 formatTag)
+{
+    return
+        formatTag == MA_DR_WAVE_FORMAT_ADPCM ||
+        formatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM;
+}
+MA_PRIVATE unsigned int ma_dr_wav__chunk_padding_size_riff(ma_uint64 chunkSize)
+{
+    return (unsigned int)(chunkSize % 2);
+}
+MA_PRIVATE unsigned int ma_dr_wav__chunk_padding_size_w64(ma_uint64 chunkSize)
+{
+    return (unsigned int)(chunkSize % 8);
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__msadpcm(ma_dr_wav* pWav, ma_uint64 samplesToRead, ma_int16* pBufferOut);
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__ima(ma_dr_wav* pWav, ma_uint64 samplesToRead, ma_int16* pBufferOut);
+MA_PRIVATE ma_bool32 ma_dr_wav_init_write__internal(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount);
+MA_PRIVATE ma_result ma_dr_wav__read_chunk_header(ma_dr_wav_read_proc onRead, void* pUserData, ma_dr_wav_container container, ma_uint64* pRunningBytesReadOut, ma_dr_wav_chunk_header* pHeaderOut)
+{
+    if (container == ma_dr_wav_container_riff || container == ma_dr_wav_container_rifx || container == ma_dr_wav_container_rf64 || container == ma_dr_wav_container_aiff) {
+        ma_uint8 sizeInBytes[4];
+        if (onRead(pUserData, pHeaderOut->id.fourcc, 4) != 4) {
+            return MA_AT_END;
+        }
+        if (onRead(pUserData, sizeInBytes, 4) != 4) {
+            return MA_INVALID_FILE;
+        }
+        pHeaderOut->sizeInBytes = ma_dr_wav_bytes_to_u32_ex(sizeInBytes, container);
+        pHeaderOut->paddingSize = ma_dr_wav__chunk_padding_size_riff(pHeaderOut->sizeInBytes);
+        *pRunningBytesReadOut += 8;
+    } else if (container == ma_dr_wav_container_w64) {
+        ma_uint8 sizeInBytes[8];
+        if (onRead(pUserData, pHeaderOut->id.guid, 16) != 16) {
+            return MA_AT_END;
+        }
+        if (onRead(pUserData, sizeInBytes, 8) != 8) {
+            return MA_INVALID_FILE;
+        }
+        pHeaderOut->sizeInBytes = ma_dr_wav_bytes_to_u64(sizeInBytes) - 24;
+        pHeaderOut->paddingSize = ma_dr_wav__chunk_padding_size_w64(pHeaderOut->sizeInBytes);
+        *pRunningBytesReadOut += 24;
+    } else {
+        return MA_INVALID_FILE;
+    }
+    return MA_SUCCESS;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__seek_forward(ma_dr_wav_seek_proc onSeek, ma_uint64 offset, void* pUserData)
+{
+    ma_uint64 bytesRemainingToSeek = offset;
+    while (bytesRemainingToSeek > 0) {
+        if (bytesRemainingToSeek > 0x7FFFFFFF) {
+            if (!onSeek(pUserData, 0x7FFFFFFF, ma_dr_wav_seek_origin_current)) {
+                return MA_FALSE;
+            }
+            bytesRemainingToSeek -= 0x7FFFFFFF;
+        } else {
+            if (!onSeek(pUserData, (int)bytesRemainingToSeek, ma_dr_wav_seek_origin_current)) {
+                return MA_FALSE;
+            }
+            bytesRemainingToSeek = 0;
+        }
+    }
+    return MA_TRUE;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__seek_from_start(ma_dr_wav_seek_proc onSeek, ma_uint64 offset, void* pUserData)
+{
+    if (offset <= 0x7FFFFFFF) {
+        return onSeek(pUserData, (int)offset, ma_dr_wav_seek_origin_start);
+    }
+    if (!onSeek(pUserData, 0x7FFFFFFF, ma_dr_wav_seek_origin_start)) {
+        return MA_FALSE;
+    }
+    offset -= 0x7FFFFFFF;
+    for (;;) {
+        if (offset <= 0x7FFFFFFF) {
+            return onSeek(pUserData, (int)offset, ma_dr_wav_seek_origin_current);
+        }
+        if (!onSeek(pUserData, 0x7FFFFFFF, ma_dr_wav_seek_origin_current)) {
+            return MA_FALSE;
+        }
+        offset -= 0x7FFFFFFF;
+    }
+}
+MA_PRIVATE size_t ma_dr_wav__on_read(ma_dr_wav_read_proc onRead, void* pUserData, void* pBufferOut, size_t bytesToRead, ma_uint64* pCursor)
+{
+    size_t bytesRead;
+    MA_DR_WAV_ASSERT(onRead != NULL);
+    MA_DR_WAV_ASSERT(pCursor != NULL);
+    bytesRead = onRead(pUserData, pBufferOut, bytesToRead);
+    *pCursor += bytesRead;
+    return bytesRead;
+}
+#if 0
+MA_PRIVATE ma_bool32 ma_dr_wav__on_seek(ma_dr_wav_seek_proc onSeek, void* pUserData, int offset, ma_dr_wav_seek_origin origin, ma_uint64* pCursor)
+{
+    MA_DR_WAV_ASSERT(onSeek != NULL);
+    MA_DR_WAV_ASSERT(pCursor != NULL);
+    if (!onSeek(pUserData, offset, origin)) {
+        return MA_FALSE;
+    }
+    if (origin == ma_dr_wav_seek_origin_start) {
+        *pCursor = offset;
+    } else {
+        *pCursor += offset;
+    }
+    return MA_TRUE;
+}
+#endif
+#define MA_DR_WAV_SMPL_BYTES                    36
+#define MA_DR_WAV_SMPL_LOOP_BYTES               24
+#define MA_DR_WAV_INST_BYTES                    7
+#define MA_DR_WAV_ACID_BYTES                    24
+#define MA_DR_WAV_CUE_BYTES                     4
+#define MA_DR_WAV_BEXT_BYTES                    602
+#define MA_DR_WAV_BEXT_DESCRIPTION_BYTES        256
+#define MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES    32
+#define MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES     32
+#define MA_DR_WAV_BEXT_RESERVED_BYTES           180
+#define MA_DR_WAV_BEXT_UMID_BYTES               64
+#define MA_DR_WAV_CUE_POINT_BYTES               24
+#define MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES      4
+#define MA_DR_WAV_LIST_LABELLED_TEXT_BYTES      20
+#define MA_DR_WAV_METADATA_ALIGNMENT            8
+typedef enum
+{
+    ma_dr_wav__metadata_parser_stage_count,
+    ma_dr_wav__metadata_parser_stage_read
+} ma_dr_wav__metadata_parser_stage;
+typedef struct
+{
+    ma_dr_wav_read_proc onRead;
+    ma_dr_wav_seek_proc onSeek;
+    void *pReadSeekUserData;
+    ma_dr_wav__metadata_parser_stage stage;
+    ma_dr_wav_metadata *pMetadata;
+    ma_uint32 metadataCount;
+    ma_uint8 *pData;
+    ma_uint8 *pDataCursor;
+    ma_uint64 metadataCursor;
+    ma_uint64 extraCapacity;
+} ma_dr_wav__metadata_parser;
+MA_PRIVATE size_t ma_dr_wav__metadata_memory_capacity(ma_dr_wav__metadata_parser* pParser)
+{
+    ma_uint64 cap = sizeof(ma_dr_wav_metadata) * (ma_uint64)pParser->metadataCount + pParser->extraCapacity;
+    if (cap > MA_SIZE_MAX) {
+        return 0;
+    }
+    return (size_t)cap;
+}
+MA_PRIVATE ma_uint8* ma_dr_wav__metadata_get_memory(ma_dr_wav__metadata_parser* pParser, size_t size, size_t align)
+{
+    ma_uint8* pResult;
+    if (align) {
+        ma_uintptr modulo = (ma_uintptr)pParser->pDataCursor % align;
+        if (modulo != 0) {
+            pParser->pDataCursor += align - modulo;
+        }
+    }
+    pResult = pParser->pDataCursor;
+    MA_DR_WAV_ASSERT((pResult + size) <= (pParser->pData + ma_dr_wav__metadata_memory_capacity(pParser)));
+    pParser->pDataCursor += size;
+    return pResult;
+}
+MA_PRIVATE void ma_dr_wav__metadata_request_extra_memory_for_stage_2(ma_dr_wav__metadata_parser* pParser, size_t bytes, size_t align)
+{
+    size_t extra = bytes + (align ? (align - 1) : 0);
+    pParser->extraCapacity += extra;
+}
+MA_PRIVATE ma_result ma_dr_wav__metadata_alloc(ma_dr_wav__metadata_parser* pParser, ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pParser->extraCapacity != 0 || pParser->metadataCount != 0) {
+        pAllocationCallbacks->onFree(pParser->pData, pAllocationCallbacks->pUserData);
+        pParser->pData = (ma_uint8*)pAllocationCallbacks->onMalloc(ma_dr_wav__metadata_memory_capacity(pParser), pAllocationCallbacks->pUserData);
+        pParser->pDataCursor = pParser->pData;
+        if (pParser->pData == NULL) {
+            return MA_OUT_OF_MEMORY;
+        }
+        pParser->pMetadata = (ma_dr_wav_metadata*)ma_dr_wav__metadata_get_memory(pParser, sizeof(ma_dr_wav_metadata) * pParser->metadataCount, 1);
+        pParser->metadataCursor = 0;
+    }
+    return MA_SUCCESS;
+}
+MA_PRIVATE size_t ma_dr_wav__metadata_parser_read(ma_dr_wav__metadata_parser* pParser, void* pBufferOut, size_t bytesToRead, ma_uint64* pCursor)
+{
+    if (pCursor != NULL) {
+        return ma_dr_wav__on_read(pParser->onRead, pParser->pReadSeekUserData, pBufferOut, bytesToRead, pCursor);
+    } else {
+        return pParser->onRead(pParser->pReadSeekUserData, pBufferOut, bytesToRead);
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_smpl_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, const ma_dr_wav_chunk_header* pChunkHeader, ma_dr_wav_metadata* pMetadata)
+{
+    ma_uint8 smplHeaderData[MA_DR_WAV_SMPL_BYTES];
+    ma_uint64 totalBytesRead = 0;
+    size_t bytesJustRead;
+    if (pMetadata == NULL) {
+        return 0;
+    }
+    bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, smplHeaderData, sizeof(smplHeaderData), &totalBytesRead);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    MA_DR_WAV_ASSERT(pChunkHeader != NULL);
+    if (pMetadata != NULL && bytesJustRead == sizeof(smplHeaderData)) {
+        ma_uint32 iSampleLoop;
+        pMetadata->type                                     = ma_dr_wav_metadata_type_smpl;
+        pMetadata->data.smpl.manufacturerId                 = ma_dr_wav_bytes_to_u32(smplHeaderData + 0);
+        pMetadata->data.smpl.productId                      = ma_dr_wav_bytes_to_u32(smplHeaderData + 4);
+        pMetadata->data.smpl.samplePeriodNanoseconds        = ma_dr_wav_bytes_to_u32(smplHeaderData + 8);
+        pMetadata->data.smpl.midiUnityNote                  = ma_dr_wav_bytes_to_u32(smplHeaderData + 12);
+        pMetadata->data.smpl.midiPitchFraction              = ma_dr_wav_bytes_to_u32(smplHeaderData + 16);
+        pMetadata->data.smpl.smpteFormat                    = ma_dr_wav_bytes_to_u32(smplHeaderData + 20);
+        pMetadata->data.smpl.smpteOffset                    = ma_dr_wav_bytes_to_u32(smplHeaderData + 24);
+        pMetadata->data.smpl.sampleLoopCount                = ma_dr_wav_bytes_to_u32(smplHeaderData + 28);
+        pMetadata->data.smpl.samplerSpecificDataSizeInBytes = ma_dr_wav_bytes_to_u32(smplHeaderData + 32);
+        if (pMetadata->data.smpl.sampleLoopCount == (pChunkHeader->sizeInBytes - MA_DR_WAV_SMPL_BYTES) / MA_DR_WAV_SMPL_LOOP_BYTES) {
+            pMetadata->data.smpl.pLoops = (ma_dr_wav_smpl_loop*)ma_dr_wav__metadata_get_memory(pParser, sizeof(ma_dr_wav_smpl_loop) * pMetadata->data.smpl.sampleLoopCount, MA_DR_WAV_METADATA_ALIGNMENT);
+            for (iSampleLoop = 0; iSampleLoop < pMetadata->data.smpl.sampleLoopCount; ++iSampleLoop) {
+                ma_uint8 smplLoopData[MA_DR_WAV_SMPL_LOOP_BYTES];
+                bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, smplLoopData, sizeof(smplLoopData), &totalBytesRead);
+                if (bytesJustRead == sizeof(smplLoopData)) {
+                    pMetadata->data.smpl.pLoops[iSampleLoop].cuePointId            = ma_dr_wav_bytes_to_u32(smplLoopData + 0);
+                    pMetadata->data.smpl.pLoops[iSampleLoop].type                  = ma_dr_wav_bytes_to_u32(smplLoopData + 4);
+                    pMetadata->data.smpl.pLoops[iSampleLoop].firstSampleByteOffset = ma_dr_wav_bytes_to_u32(smplLoopData + 8);
+                    pMetadata->data.smpl.pLoops[iSampleLoop].lastSampleByteOffset  = ma_dr_wav_bytes_to_u32(smplLoopData + 12);
+                    pMetadata->data.smpl.pLoops[iSampleLoop].sampleFraction        = ma_dr_wav_bytes_to_u32(smplLoopData + 16);
+                    pMetadata->data.smpl.pLoops[iSampleLoop].playCount             = ma_dr_wav_bytes_to_u32(smplLoopData + 20);
+                } else {
+                    break;
+                }
+            }
+            if (pMetadata->data.smpl.samplerSpecificDataSizeInBytes > 0) {
+                pMetadata->data.smpl.pSamplerSpecificData = ma_dr_wav__metadata_get_memory(pParser, pMetadata->data.smpl.samplerSpecificDataSizeInBytes, 1);
+                MA_DR_WAV_ASSERT(pMetadata->data.smpl.pSamplerSpecificData != NULL);
+                ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.smpl.pSamplerSpecificData, pMetadata->data.smpl.samplerSpecificDataSizeInBytes, &totalBytesRead);
+            }
+        }
+    }
+    return totalBytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_cue_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, const ma_dr_wav_chunk_header* pChunkHeader, ma_dr_wav_metadata* pMetadata)
+{
+    ma_uint8 cueHeaderSectionData[MA_DR_WAV_CUE_BYTES];
+    ma_uint64 totalBytesRead = 0;
+    size_t bytesJustRead;
+    if (pMetadata == NULL) {
+        return 0;
+    }
+    bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, cueHeaderSectionData, sizeof(cueHeaderSectionData), &totalBytesRead);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesJustRead == sizeof(cueHeaderSectionData)) {
+        pMetadata->type                   = ma_dr_wav_metadata_type_cue;
+        pMetadata->data.cue.cuePointCount = ma_dr_wav_bytes_to_u32(cueHeaderSectionData);
+        if (pMetadata->data.cue.cuePointCount == (pChunkHeader->sizeInBytes - MA_DR_WAV_CUE_BYTES) / MA_DR_WAV_CUE_POINT_BYTES) {
+            pMetadata->data.cue.pCuePoints    = (ma_dr_wav_cue_point*)ma_dr_wav__metadata_get_memory(pParser, sizeof(ma_dr_wav_cue_point) * pMetadata->data.cue.cuePointCount, MA_DR_WAV_METADATA_ALIGNMENT);
+            MA_DR_WAV_ASSERT(pMetadata->data.cue.pCuePoints != NULL);
+            if (pMetadata->data.cue.cuePointCount > 0) {
+                ma_uint32 iCuePoint;
+                for (iCuePoint = 0; iCuePoint < pMetadata->data.cue.cuePointCount; ++iCuePoint) {
+                    ma_uint8 cuePointData[MA_DR_WAV_CUE_POINT_BYTES];
+                    bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, cuePointData, sizeof(cuePointData), &totalBytesRead);
+                    if (bytesJustRead == sizeof(cuePointData)) {
+                        pMetadata->data.cue.pCuePoints[iCuePoint].id                = ma_dr_wav_bytes_to_u32(cuePointData + 0);
+                        pMetadata->data.cue.pCuePoints[iCuePoint].playOrderPosition = ma_dr_wav_bytes_to_u32(cuePointData + 4);
+                        pMetadata->data.cue.pCuePoints[iCuePoint].dataChunkId[0]    = cuePointData[8];
+                        pMetadata->data.cue.pCuePoints[iCuePoint].dataChunkId[1]    = cuePointData[9];
+                        pMetadata->data.cue.pCuePoints[iCuePoint].dataChunkId[2]    = cuePointData[10];
+                        pMetadata->data.cue.pCuePoints[iCuePoint].dataChunkId[3]    = cuePointData[11];
+                        pMetadata->data.cue.pCuePoints[iCuePoint].chunkStart        = ma_dr_wav_bytes_to_u32(cuePointData + 12);
+                        pMetadata->data.cue.pCuePoints[iCuePoint].blockStart        = ma_dr_wav_bytes_to_u32(cuePointData + 16);
+                        pMetadata->data.cue.pCuePoints[iCuePoint].sampleByteOffset  = ma_dr_wav_bytes_to_u32(cuePointData + 20);
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return totalBytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_inst_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, ma_dr_wav_metadata* pMetadata)
+{
+    ma_uint8 instData[MA_DR_WAV_INST_BYTES];
+    ma_uint64 bytesRead;
+    if (pMetadata == NULL) {
+        return 0;
+    }
+    bytesRead = ma_dr_wav__metadata_parser_read(pParser, instData, sizeof(instData), NULL);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesRead == sizeof(instData)) {
+        pMetadata->type                    = ma_dr_wav_metadata_type_inst;
+        pMetadata->data.inst.midiUnityNote = (ma_int8)instData[0];
+        pMetadata->data.inst.fineTuneCents = (ma_int8)instData[1];
+        pMetadata->data.inst.gainDecibels  = (ma_int8)instData[2];
+        pMetadata->data.inst.lowNote       = (ma_int8)instData[3];
+        pMetadata->data.inst.highNote      = (ma_int8)instData[4];
+        pMetadata->data.inst.lowVelocity   = (ma_int8)instData[5];
+        pMetadata->data.inst.highVelocity  = (ma_int8)instData[6];
+    }
+    return bytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_acid_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, ma_dr_wav_metadata* pMetadata)
+{
+    ma_uint8 acidData[MA_DR_WAV_ACID_BYTES];
+    ma_uint64 bytesRead;
+    if (pMetadata == NULL) {
+        return 0;
+    }
+    bytesRead = ma_dr_wav__metadata_parser_read(pParser, acidData, sizeof(acidData), NULL);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesRead == sizeof(acidData)) {
+        pMetadata->type                       = ma_dr_wav_metadata_type_acid;
+        pMetadata->data.acid.flags            = ma_dr_wav_bytes_to_u32(acidData + 0);
+        pMetadata->data.acid.midiUnityNote    = ma_dr_wav_bytes_to_u16(acidData + 4);
+        pMetadata->data.acid.reserved1        = ma_dr_wav_bytes_to_u16(acidData + 6);
+        pMetadata->data.acid.reserved2        = ma_dr_wav_bytes_to_f32(acidData + 8);
+        pMetadata->data.acid.numBeats         = ma_dr_wav_bytes_to_u32(acidData + 12);
+        pMetadata->data.acid.meterDenominator = ma_dr_wav_bytes_to_u16(acidData + 16);
+        pMetadata->data.acid.meterNumerator   = ma_dr_wav_bytes_to_u16(acidData + 18);
+        pMetadata->data.acid.tempo            = ma_dr_wav_bytes_to_f32(acidData + 20);
+    }
+    return bytesRead;
+}
+MA_PRIVATE size_t ma_dr_wav__strlen(const char* str)
+{
+    size_t result = 0;
+    while (*str++) {
+        result += 1;
+    }
+    return result;
+}
+MA_PRIVATE size_t ma_dr_wav__strlen_clamped(const char* str, size_t maxToRead)
+{
+    size_t result = 0;
+    while (*str++ && result < maxToRead) {
+        result += 1;
+    }
+    return result;
+}
+MA_PRIVATE char* ma_dr_wav__metadata_copy_string(ma_dr_wav__metadata_parser* pParser, const char* str, size_t maxToRead)
+{
+    size_t len = ma_dr_wav__strlen_clamped(str, maxToRead);
+    if (len) {
+        char* result = (char*)ma_dr_wav__metadata_get_memory(pParser, len + 1, 1);
+        MA_DR_WAV_ASSERT(result != NULL);
+        MA_DR_WAV_COPY_MEMORY(result, str, len);
+        result[len] = '\0';
+        return result;
+    } else {
+        return NULL;
+    }
+}
+typedef struct
+{
+    const void* pBuffer;
+    size_t sizeInBytes;
+    size_t cursor;
+} ma_dr_wav_buffer_reader;
+MA_PRIVATE ma_result ma_dr_wav_buffer_reader_init(const void* pBuffer, size_t sizeInBytes, ma_dr_wav_buffer_reader* pReader)
+{
+    MA_DR_WAV_ASSERT(pBuffer != NULL);
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    MA_DR_WAV_ZERO_OBJECT(pReader);
+    pReader->pBuffer     = pBuffer;
+    pReader->sizeInBytes = sizeInBytes;
+    pReader->cursor      = 0;
+    return MA_SUCCESS;
+}
+MA_PRIVATE const void* ma_dr_wav_buffer_reader_ptr(const ma_dr_wav_buffer_reader* pReader)
+{
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    return ma_dr_wav_offset_ptr(pReader->pBuffer, pReader->cursor);
+}
+MA_PRIVATE ma_result ma_dr_wav_buffer_reader_seek(ma_dr_wav_buffer_reader* pReader, size_t bytesToSeek)
+{
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    if (pReader->cursor + bytesToSeek > pReader->sizeInBytes) {
+        return MA_BAD_SEEK;
+    }
+    pReader->cursor += bytesToSeek;
+    return MA_SUCCESS;
+}
+MA_PRIVATE ma_result ma_dr_wav_buffer_reader_read(ma_dr_wav_buffer_reader* pReader, void* pDst, size_t bytesToRead, size_t* pBytesRead)
+{
+    ma_result result = MA_SUCCESS;
+    size_t bytesRemaining;
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    if (pBytesRead != NULL) {
+        *pBytesRead = 0;
+    }
+    bytesRemaining = (pReader->sizeInBytes - pReader->cursor);
+    if (bytesToRead > bytesRemaining) {
+        bytesToRead = bytesRemaining;
+    }
+    if (pDst == NULL) {
+        result = ma_dr_wav_buffer_reader_seek(pReader, bytesToRead);
+    } else {
+        MA_DR_WAV_COPY_MEMORY(pDst, ma_dr_wav_buffer_reader_ptr(pReader), bytesToRead);
+        pReader->cursor += bytesToRead;
+    }
+    MA_DR_WAV_ASSERT(pReader->cursor <= pReader->sizeInBytes);
+    if (result == MA_SUCCESS) {
+        if (pBytesRead != NULL) {
+            *pBytesRead = bytesToRead;
+        }
+    }
+    return MA_SUCCESS;
+}
+MA_PRIVATE ma_result ma_dr_wav_buffer_reader_read_u16(ma_dr_wav_buffer_reader* pReader, ma_uint16* pDst)
+{
+    ma_result result;
+    size_t bytesRead;
+    ma_uint8 data[2];
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    MA_DR_WAV_ASSERT(pDst != NULL);
+    *pDst = 0;
+    result = ma_dr_wav_buffer_reader_read(pReader, data, sizeof(*pDst), &bytesRead);
+    if (result != MA_SUCCESS || bytesRead != sizeof(*pDst)) {
+        return result;
+    }
+    *pDst = ma_dr_wav_bytes_to_u16(data);
+    return MA_SUCCESS;
+}
+MA_PRIVATE ma_result ma_dr_wav_buffer_reader_read_u32(ma_dr_wav_buffer_reader* pReader, ma_uint32* pDst)
+{
+    ma_result result;
+    size_t bytesRead;
+    ma_uint8 data[4];
+    MA_DR_WAV_ASSERT(pReader != NULL);
+    MA_DR_WAV_ASSERT(pDst != NULL);
+    *pDst = 0;
+    result = ma_dr_wav_buffer_reader_read(pReader, data, sizeof(*pDst), &bytesRead);
+    if (result != MA_SUCCESS || bytesRead != sizeof(*pDst)) {
+        return result;
+    }
+    *pDst = ma_dr_wav_bytes_to_u32(data);
+    return MA_SUCCESS;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_bext_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, ma_dr_wav_metadata* pMetadata, ma_uint64 chunkSize)
+{
+    ma_uint8 bextData[MA_DR_WAV_BEXT_BYTES];
+    size_t bytesRead = ma_dr_wav__metadata_parser_read(pParser, bextData, sizeof(bextData), NULL);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesRead == sizeof(bextData)) {
+        ma_dr_wav_buffer_reader reader;
+        ma_uint32 timeReferenceLow;
+        ma_uint32 timeReferenceHigh;
+        size_t extraBytes;
+        pMetadata->type = ma_dr_wav_metadata_type_bext;
+        if (ma_dr_wav_buffer_reader_init(bextData, bytesRead, &reader) == MA_SUCCESS) {
+            pMetadata->data.bext.pDescription = ma_dr_wav__metadata_copy_string(pParser, (const char*)ma_dr_wav_buffer_reader_ptr(&reader), MA_DR_WAV_BEXT_DESCRIPTION_BYTES);
+            ma_dr_wav_buffer_reader_seek(&reader, MA_DR_WAV_BEXT_DESCRIPTION_BYTES);
+            pMetadata->data.bext.pOriginatorName = ma_dr_wav__metadata_copy_string(pParser, (const char*)ma_dr_wav_buffer_reader_ptr(&reader), MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES);
+            ma_dr_wav_buffer_reader_seek(&reader, MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES);
+            pMetadata->data.bext.pOriginatorReference = ma_dr_wav__metadata_copy_string(pParser, (const char*)ma_dr_wav_buffer_reader_ptr(&reader), MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES);
+            ma_dr_wav_buffer_reader_seek(&reader, MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES);
+            ma_dr_wav_buffer_reader_read(&reader, pMetadata->data.bext.pOriginationDate, sizeof(pMetadata->data.bext.pOriginationDate), NULL);
+            ma_dr_wav_buffer_reader_read(&reader, pMetadata->data.bext.pOriginationTime, sizeof(pMetadata->data.bext.pOriginationTime), NULL);
+            ma_dr_wav_buffer_reader_read_u32(&reader, &timeReferenceLow);
+            ma_dr_wav_buffer_reader_read_u32(&reader, &timeReferenceHigh);
+            pMetadata->data.bext.timeReference = ((ma_uint64)timeReferenceHigh << 32) + timeReferenceLow;
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.version);
+            pMetadata->data.bext.pUMID = ma_dr_wav__metadata_get_memory(pParser, MA_DR_WAV_BEXT_UMID_BYTES, 1);
+            ma_dr_wav_buffer_reader_read(&reader, pMetadata->data.bext.pUMID, MA_DR_WAV_BEXT_UMID_BYTES, NULL);
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.loudnessValue);
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.loudnessRange);
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.maxTruePeakLevel);
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.maxMomentaryLoudness);
+            ma_dr_wav_buffer_reader_read_u16(&reader, &pMetadata->data.bext.maxShortTermLoudness);
+            MA_DR_WAV_ASSERT((ma_dr_wav_offset_ptr(ma_dr_wav_buffer_reader_ptr(&reader), MA_DR_WAV_BEXT_RESERVED_BYTES)) == (bextData + MA_DR_WAV_BEXT_BYTES));
+            extraBytes = (size_t)(chunkSize - MA_DR_WAV_BEXT_BYTES);
+            if (extraBytes > 0) {
+                pMetadata->data.bext.pCodingHistory = (char*)ma_dr_wav__metadata_get_memory(pParser, extraBytes + 1, 1);
+                MA_DR_WAV_ASSERT(pMetadata->data.bext.pCodingHistory != NULL);
+                bytesRead += ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.bext.pCodingHistory, extraBytes, NULL);
+                pMetadata->data.bext.codingHistorySize = (ma_uint32)ma_dr_wav__strlen(pMetadata->data.bext.pCodingHistory);
+            } else {
+                pMetadata->data.bext.pCodingHistory    = NULL;
+                pMetadata->data.bext.codingHistorySize = 0;
+            }
+        }
+    }
+    return bytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_list_label_or_note_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, ma_dr_wav_metadata* pMetadata, ma_uint64 chunkSize, ma_dr_wav_metadata_type type)
+{
+    ma_uint8 cueIDBuffer[MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES];
+    ma_uint64 totalBytesRead = 0;
+    size_t bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, cueIDBuffer, sizeof(cueIDBuffer), &totalBytesRead);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesJustRead == sizeof(cueIDBuffer)) {
+        ma_uint32 sizeIncludingNullTerminator;
+        pMetadata->type = type;
+        pMetadata->data.labelOrNote.cuePointId = ma_dr_wav_bytes_to_u32(cueIDBuffer);
+        sizeIncludingNullTerminator = (ma_uint32)chunkSize - MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES;
+        if (sizeIncludingNullTerminator > 0) {
+            pMetadata->data.labelOrNote.stringLength = sizeIncludingNullTerminator - 1;
+            pMetadata->data.labelOrNote.pString      = (char*)ma_dr_wav__metadata_get_memory(pParser, sizeIncludingNullTerminator, 1);
+            MA_DR_WAV_ASSERT(pMetadata->data.labelOrNote.pString != NULL);
+            ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.labelOrNote.pString, sizeIncludingNullTerminator, &totalBytesRead);
+        } else {
+            pMetadata->data.labelOrNote.stringLength = 0;
+            pMetadata->data.labelOrNote.pString      = NULL;
+        }
+    }
+    return totalBytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__read_list_labelled_cue_region_to_metadata_obj(ma_dr_wav__metadata_parser* pParser, ma_dr_wav_metadata* pMetadata, ma_uint64 chunkSize)
+{
+    ma_uint8 buffer[MA_DR_WAV_LIST_LABELLED_TEXT_BYTES];
+    ma_uint64 totalBytesRead = 0;
+    size_t bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, sizeof(buffer), &totalBytesRead);
+    MA_DR_WAV_ASSERT(pParser->stage == ma_dr_wav__metadata_parser_stage_read);
+    if (bytesJustRead == sizeof(buffer)) {
+        ma_uint32 sizeIncludingNullTerminator;
+        pMetadata->type                                = ma_dr_wav_metadata_type_list_labelled_cue_region;
+        pMetadata->data.labelledCueRegion.cuePointId   = ma_dr_wav_bytes_to_u32(buffer + 0);
+        pMetadata->data.labelledCueRegion.sampleLength = ma_dr_wav_bytes_to_u32(buffer + 4);
+        pMetadata->data.labelledCueRegion.purposeId[0] = buffer[8];
+        pMetadata->data.labelledCueRegion.purposeId[1] = buffer[9];
+        pMetadata->data.labelledCueRegion.purposeId[2] = buffer[10];
+        pMetadata->data.labelledCueRegion.purposeId[3] = buffer[11];
+        pMetadata->data.labelledCueRegion.country      = ma_dr_wav_bytes_to_u16(buffer + 12);
+        pMetadata->data.labelledCueRegion.language     = ma_dr_wav_bytes_to_u16(buffer + 14);
+        pMetadata->data.labelledCueRegion.dialect      = ma_dr_wav_bytes_to_u16(buffer + 16);
+        pMetadata->data.labelledCueRegion.codePage     = ma_dr_wav_bytes_to_u16(buffer + 18);
+        sizeIncludingNullTerminator = (ma_uint32)chunkSize - MA_DR_WAV_LIST_LABELLED_TEXT_BYTES;
+        if (sizeIncludingNullTerminator > 0) {
+            pMetadata->data.labelledCueRegion.stringLength = sizeIncludingNullTerminator - 1;
+            pMetadata->data.labelledCueRegion.pString      = (char*)ma_dr_wav__metadata_get_memory(pParser, sizeIncludingNullTerminator, 1);
+            MA_DR_WAV_ASSERT(pMetadata->data.labelledCueRegion.pString != NULL);
+            ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.labelledCueRegion.pString, sizeIncludingNullTerminator, &totalBytesRead);
+        } else {
+            pMetadata->data.labelledCueRegion.stringLength = 0;
+            pMetadata->data.labelledCueRegion.pString      = NULL;
+        }
+    }
+    return totalBytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__metadata_process_info_text_chunk(ma_dr_wav__metadata_parser* pParser, ma_uint64 chunkSize, ma_dr_wav_metadata_type type)
+{
+    ma_uint64 bytesRead = 0;
+    ma_uint32 stringSizeWithNullTerminator = (ma_uint32)chunkSize;
+    if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+        pParser->metadataCount += 1;
+        ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, stringSizeWithNullTerminator, 1);
+    } else {
+        ma_dr_wav_metadata* pMetadata = &pParser->pMetadata[pParser->metadataCursor];
+        pMetadata->type = type;
+        if (stringSizeWithNullTerminator > 0) {
+            pMetadata->data.infoText.stringLength = stringSizeWithNullTerminator - 1;
+            pMetadata->data.infoText.pString = (char*)ma_dr_wav__metadata_get_memory(pParser, stringSizeWithNullTerminator, 1);
+            MA_DR_WAV_ASSERT(pMetadata->data.infoText.pString != NULL);
+            bytesRead = ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.infoText.pString, (size_t)stringSizeWithNullTerminator, NULL);
+            if (bytesRead == chunkSize) {
+                pParser->metadataCursor += 1;
+            } else {
+            }
+        } else {
+            pMetadata->data.infoText.stringLength = 0;
+            pMetadata->data.infoText.pString      = NULL;
+            pParser->metadataCursor += 1;
+        }
+    }
+    return bytesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__metadata_process_unknown_chunk(ma_dr_wav__metadata_parser* pParser, const ma_uint8* pChunkId, ma_uint64 chunkSize, ma_dr_wav_metadata_location location)
+{
+    ma_uint64 bytesRead = 0;
+    if (location == ma_dr_wav_metadata_location_invalid) {
+        return 0;
+    }
+    if (ma_dr_wav_fourcc_equal(pChunkId, "data") || ma_dr_wav_fourcc_equal(pChunkId, "fmt ") || ma_dr_wav_fourcc_equal(pChunkId, "fact")) {
+        return 0;
+    }
+    if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+        pParser->metadataCount += 1;
+        ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, (size_t)chunkSize, 1);
+    } else {
+        ma_dr_wav_metadata* pMetadata = &pParser->pMetadata[pParser->metadataCursor];
+        pMetadata->type                         = ma_dr_wav_metadata_type_unknown;
+        pMetadata->data.unknown.chunkLocation   = location;
+        pMetadata->data.unknown.id[0]           = pChunkId[0];
+        pMetadata->data.unknown.id[1]           = pChunkId[1];
+        pMetadata->data.unknown.id[2]           = pChunkId[2];
+        pMetadata->data.unknown.id[3]           = pChunkId[3];
+        pMetadata->data.unknown.dataSizeInBytes = (ma_uint32)chunkSize;
+        pMetadata->data.unknown.pData           = (ma_uint8 *)ma_dr_wav__metadata_get_memory(pParser, (size_t)chunkSize, 1);
+        MA_DR_WAV_ASSERT(pMetadata->data.unknown.pData != NULL);
+        bytesRead = ma_dr_wav__metadata_parser_read(pParser, pMetadata->data.unknown.pData, pMetadata->data.unknown.dataSizeInBytes, NULL);
+        if (bytesRead == pMetadata->data.unknown.dataSizeInBytes) {
+            pParser->metadataCursor += 1;
+        } else {
+        }
+    }
+    return bytesRead;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__chunk_matches(ma_dr_wav_metadata_type allowedMetadataTypes, const ma_uint8* pChunkID, ma_dr_wav_metadata_type type, const char* pID)
+{
+    return (allowedMetadataTypes & type) && ma_dr_wav_fourcc_equal(pChunkID, pID);
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__metadata_process_chunk(ma_dr_wav__metadata_parser* pParser, const ma_dr_wav_chunk_header* pChunkHeader, ma_dr_wav_metadata_type allowedMetadataTypes)
+{
+    const ma_uint8 *pChunkID = pChunkHeader->id.fourcc;
+    ma_uint64 bytesRead = 0;
+    if (ma_dr_wav__chunk_matches(allowedMetadataTypes, pChunkID, ma_dr_wav_metadata_type_smpl, "smpl")) {
+        if (pChunkHeader->sizeInBytes >= MA_DR_WAV_SMPL_BYTES) {
+            if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                ma_uint8 buffer[4];
+                size_t bytesJustRead;
+                if (!pParser->onSeek(pParser->pReadSeekUserData, 28, ma_dr_wav_seek_origin_current)) {
+                    return bytesRead;
+                }
+                bytesRead += 28;
+                bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, sizeof(buffer), &bytesRead);
+                if (bytesJustRead == sizeof(buffer)) {
+                    ma_uint32 loopCount = ma_dr_wav_bytes_to_u32(buffer);
+                    ma_uint64 calculatedLoopCount;
+                    calculatedLoopCount = (pChunkHeader->sizeInBytes - MA_DR_WAV_SMPL_BYTES) / MA_DR_WAV_SMPL_LOOP_BYTES;
+                    if (calculatedLoopCount == loopCount) {
+                        bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, sizeof(buffer), &bytesRead);
+                        if (bytesJustRead == sizeof(buffer)) {
+                            ma_uint32 samplerSpecificDataSizeInBytes = ma_dr_wav_bytes_to_u32(buffer);
+                            pParser->metadataCount += 1;
+                            ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, sizeof(ma_dr_wav_smpl_loop) * loopCount, MA_DR_WAV_METADATA_ALIGNMENT);
+                            ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, samplerSpecificDataSizeInBytes, 1);
+                        }
+                    } else {
+                    }
+                }
+            } else {
+                bytesRead = ma_dr_wav__read_smpl_to_metadata_obj(pParser, pChunkHeader, &pParser->pMetadata[pParser->metadataCursor]);
+                if (bytesRead == pChunkHeader->sizeInBytes) {
+                    pParser->metadataCursor += 1;
+                } else {
+                }
+            }
+        } else {
+        }
+    } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, pChunkID, ma_dr_wav_metadata_type_inst, "inst")) {
+        if (pChunkHeader->sizeInBytes == MA_DR_WAV_INST_BYTES) {
+            if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                pParser->metadataCount += 1;
+            } else {
+                bytesRead = ma_dr_wav__read_inst_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor]);
+                if (bytesRead == pChunkHeader->sizeInBytes) {
+                    pParser->metadataCursor += 1;
+                } else {
+                }
+            }
+        } else {
+        }
+    } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, pChunkID, ma_dr_wav_metadata_type_acid, "acid")) {
+        if (pChunkHeader->sizeInBytes == MA_DR_WAV_ACID_BYTES) {
+            if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                pParser->metadataCount += 1;
+            } else {
+                bytesRead = ma_dr_wav__read_acid_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor]);
+                if (bytesRead == pChunkHeader->sizeInBytes) {
+                    pParser->metadataCursor += 1;
+                } else {
+                }
+            }
+        } else {
+        }
+    } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, pChunkID, ma_dr_wav_metadata_type_cue, "cue ")) {
+        if (pChunkHeader->sizeInBytes >= MA_DR_WAV_CUE_BYTES) {
+            if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                size_t cueCount;
+                pParser->metadataCount += 1;
+                cueCount = (size_t)(pChunkHeader->sizeInBytes - MA_DR_WAV_CUE_BYTES) / MA_DR_WAV_CUE_POINT_BYTES;
+                ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, sizeof(ma_dr_wav_cue_point) * cueCount, MA_DR_WAV_METADATA_ALIGNMENT);
+            } else {
+                bytesRead = ma_dr_wav__read_cue_to_metadata_obj(pParser, pChunkHeader, &pParser->pMetadata[pParser->metadataCursor]);
+                if (bytesRead == pChunkHeader->sizeInBytes) {
+                    pParser->metadataCursor += 1;
+                } else {
+                }
+            }
+        } else {
+        }
+    } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, pChunkID, ma_dr_wav_metadata_type_bext, "bext")) {
+        if (pChunkHeader->sizeInBytes >= MA_DR_WAV_BEXT_BYTES) {
+            if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                char buffer[MA_DR_WAV_BEXT_DESCRIPTION_BYTES + 1];
+                size_t allocSizeNeeded = MA_DR_WAV_BEXT_UMID_BYTES;
+                size_t bytesJustRead;
+                buffer[MA_DR_WAV_BEXT_DESCRIPTION_BYTES] = '\0';
+                bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, MA_DR_WAV_BEXT_DESCRIPTION_BYTES, &bytesRead);
+                if (bytesJustRead != MA_DR_WAV_BEXT_DESCRIPTION_BYTES) {
+                    return bytesRead;
+                }
+                allocSizeNeeded += ma_dr_wav__strlen(buffer) + 1;
+                buffer[MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES] = '\0';
+                bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES, &bytesRead);
+                if (bytesJustRead != MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES) {
+                    return bytesRead;
+                }
+                allocSizeNeeded += ma_dr_wav__strlen(buffer) + 1;
+                buffer[MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES] = '\0';
+                bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, buffer, MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES, &bytesRead);
+                if (bytesJustRead != MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES) {
+                    return bytesRead;
+                }
+                allocSizeNeeded += ma_dr_wav__strlen(buffer) + 1;
+                allocSizeNeeded += (size_t)pChunkHeader->sizeInBytes - MA_DR_WAV_BEXT_BYTES;
+                ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, allocSizeNeeded, 1);
+                pParser->metadataCount += 1;
+            } else {
+                bytesRead = ma_dr_wav__read_bext_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor], pChunkHeader->sizeInBytes);
+                if (bytesRead == pChunkHeader->sizeInBytes) {
+                    pParser->metadataCursor += 1;
+                } else {
+                }
+            }
+        } else {
+        }
+    } else if (ma_dr_wav_fourcc_equal(pChunkID, "LIST") || ma_dr_wav_fourcc_equal(pChunkID, "list")) {
+        ma_dr_wav_metadata_location listType = ma_dr_wav_metadata_location_invalid;
+        while (bytesRead < pChunkHeader->sizeInBytes) {
+            ma_uint8 subchunkId[4];
+            ma_uint8 subchunkSizeBuffer[4];
+            ma_uint64 subchunkDataSize;
+            ma_uint64 subchunkBytesRead = 0;
+            ma_uint64 bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, subchunkId, sizeof(subchunkId), &bytesRead);
+            if (bytesJustRead != sizeof(subchunkId)) {
+                break;
+            }
+            if (ma_dr_wav_fourcc_equal(subchunkId, "adtl")) {
+                listType = ma_dr_wav_metadata_location_inside_adtl_list;
+                continue;
+            } else if (ma_dr_wav_fourcc_equal(subchunkId, "INFO")) {
+                listType = ma_dr_wav_metadata_location_inside_info_list;
+                continue;
+            }
+            bytesJustRead = ma_dr_wav__metadata_parser_read(pParser, subchunkSizeBuffer, sizeof(subchunkSizeBuffer), &bytesRead);
+            if (bytesJustRead != sizeof(subchunkSizeBuffer)) {
+                break;
+            }
+            subchunkDataSize = ma_dr_wav_bytes_to_u32(subchunkSizeBuffer);
+            if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_label, "labl") || ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_note, "note")) {
+                if (subchunkDataSize >= MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES) {
+                    ma_uint64 stringSizeWithNullTerm = subchunkDataSize - MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES;
+                    if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                        pParser->metadataCount += 1;
+                        ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, (size_t)stringSizeWithNullTerm, 1);
+                    } else {
+                        subchunkBytesRead = ma_dr_wav__read_list_label_or_note_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor], subchunkDataSize, ma_dr_wav_fourcc_equal(subchunkId, "labl") ? ma_dr_wav_metadata_type_list_label : ma_dr_wav_metadata_type_list_note);
+                        if (subchunkBytesRead == subchunkDataSize) {
+                            pParser->metadataCursor += 1;
+                        } else {
+                        }
+                    }
+                } else {
+                }
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_labelled_cue_region, "ltxt")) {
+                if (subchunkDataSize >= MA_DR_WAV_LIST_LABELLED_TEXT_BYTES) {
+                    ma_uint64 stringSizeWithNullTerminator = subchunkDataSize - MA_DR_WAV_LIST_LABELLED_TEXT_BYTES;
+                    if (pParser->stage == ma_dr_wav__metadata_parser_stage_count) {
+                        pParser->metadataCount += 1;
+                        ma_dr_wav__metadata_request_extra_memory_for_stage_2(pParser, (size_t)stringSizeWithNullTerminator, 1);
+                    } else {
+                        subchunkBytesRead = ma_dr_wav__read_list_labelled_cue_region_to_metadata_obj(pParser, &pParser->pMetadata[pParser->metadataCursor], subchunkDataSize);
+                        if (subchunkBytesRead == subchunkDataSize) {
+                            pParser->metadataCursor += 1;
+                        } else {
+                        }
+                    }
+                } else {
+                }
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_software, "ISFT")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_software);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_copyright, "ICOP")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_copyright);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_title, "INAM")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_title);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_artist, "IART")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_artist);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_comment, "ICMT")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_comment);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_date, "ICRD")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_date);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_genre, "IGNR")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_genre);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_album, "IPRD")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_album);
+            } else if (ma_dr_wav__chunk_matches(allowedMetadataTypes, subchunkId, ma_dr_wav_metadata_type_list_info_tracknumber, "ITRK")) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_info_text_chunk(pParser, subchunkDataSize,  ma_dr_wav_metadata_type_list_info_tracknumber);
+            } else if ((allowedMetadataTypes & ma_dr_wav_metadata_type_unknown) != 0) {
+                subchunkBytesRead = ma_dr_wav__metadata_process_unknown_chunk(pParser, subchunkId, subchunkDataSize, listType);
+            }
+            bytesRead += subchunkBytesRead;
+            MA_DR_WAV_ASSERT(subchunkBytesRead <= subchunkDataSize);
+            if (subchunkBytesRead < subchunkDataSize) {
+                ma_uint64 bytesToSeek = subchunkDataSize - subchunkBytesRead;
+                if (!pParser->onSeek(pParser->pReadSeekUserData, (int)bytesToSeek, ma_dr_wav_seek_origin_current)) {
+                    break;
+                }
+                bytesRead += bytesToSeek;
+            }
+            if ((subchunkDataSize % 2) == 1) {
+                if (!pParser->onSeek(pParser->pReadSeekUserData, 1, ma_dr_wav_seek_origin_current)) {
+                    break;
+                }
+                bytesRead += 1;
+            }
+        }
+    } else if ((allowedMetadataTypes & ma_dr_wav_metadata_type_unknown) != 0) {
+        bytesRead = ma_dr_wav__metadata_process_unknown_chunk(pParser, pChunkID, pChunkHeader->sizeInBytes, ma_dr_wav_metadata_location_top_level);
+    }
+    return bytesRead;
+}
+MA_PRIVATE ma_uint32 ma_dr_wav_get_bytes_per_pcm_frame(ma_dr_wav* pWav)
+{
+    ma_uint32 bytesPerFrame;
+    if ((pWav->bitsPerSample & 0x7) == 0) {
+        bytesPerFrame = (pWav->bitsPerSample * pWav->fmt.channels) >> 3;
+    } else {
+        bytesPerFrame = pWav->fmt.blockAlign;
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ALAW || pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_MULAW) {
+        if (bytesPerFrame != pWav->fmt.channels) {
+            return 0;
+        }
+    }
+    return bytesPerFrame;
+}
+MA_API ma_uint16 ma_dr_wav_fmt_get_format(const ma_dr_wav_fmt* pFMT)
+{
+    if (pFMT == NULL) {
+        return 0;
+    }
+    if (pFMT->formatTag != MA_DR_WAVE_FORMAT_EXTENSIBLE) {
+        return pFMT->formatTag;
+    } else {
+        return ma_dr_wav_bytes_to_u16(pFMT->subFormat);
+    }
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_preinit(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pReadSeekUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pWav == NULL || onRead == NULL || onSeek == NULL) {
+        return MA_FALSE;
+    }
+    MA_DR_WAV_ZERO_MEMORY(pWav, sizeof(*pWav));
+    pWav->onRead    = onRead;
+    pWav->onSeek    = onSeek;
+    pWav->pUserData = pReadSeekUserData;
+    pWav->allocationCallbacks = ma_dr_wav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
+    if (pWav->allocationCallbacks.onFree == NULL || (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) {
+        return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_init__internal(ma_dr_wav* pWav, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags)
+{
+    ma_result result;
+    ma_uint64 cursor;
+    ma_bool32 sequential;
+    ma_uint8 riff[4];
+    ma_dr_wav_fmt fmt;
+    unsigned short translatedFormatTag;
+    ma_uint64 dataChunkSize = 0;
+    ma_uint64 sampleCountFromFactChunk = 0;
+    ma_uint64 metadataStartPos;
+    ma_dr_wav__metadata_parser metadataParser;
+    ma_bool8 isProcessingMetadata = MA_FALSE;
+    ma_bool8 foundChunk_fmt  = MA_FALSE;
+    ma_bool8 foundChunk_data = MA_FALSE;
+    ma_bool8 isAIFCFormType = MA_FALSE;
+    ma_uint64 aiffFrameCount = 0;
+    cursor = 0;
+    sequential = (flags & MA_DR_WAV_SEQUENTIAL) != 0;
+    MA_DR_WAV_ZERO_OBJECT(&fmt);
+    if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, riff, sizeof(riff), &cursor) != sizeof(riff)) {
+        return MA_FALSE;
+    }
+    if (ma_dr_wav_fourcc_equal(riff, "RIFF")) {
+        pWav->container = ma_dr_wav_container_riff;
+    } else if (ma_dr_wav_fourcc_equal(riff, "RIFX")) {
+        pWav->container = ma_dr_wav_container_rifx;
+    } else if (ma_dr_wav_fourcc_equal(riff, "riff")) {
+        int i;
+        ma_uint8 riff2[12];
+        pWav->container = ma_dr_wav_container_w64;
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, riff2, sizeof(riff2), &cursor) != sizeof(riff2)) {
+            return MA_FALSE;
+        }
+        for (i = 0; i < 12; ++i) {
+            if (riff2[i] != ma_dr_wavGUID_W64_RIFF[i+4]) {
+                return MA_FALSE;
+            }
+        }
+    } else if (ma_dr_wav_fourcc_equal(riff, "RF64")) {
+        pWav->container = ma_dr_wav_container_rf64;
+    } else if (ma_dr_wav_fourcc_equal(riff, "FORM")) {
+        pWav->container = ma_dr_wav_container_aiff;
+    } else {
+        return MA_FALSE;
+    }
+    if (pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx || pWav->container == ma_dr_wav_container_rf64) {
+        ma_uint8 chunkSizeBytes[4];
+        ma_uint8 wave[4];
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) {
+            return MA_FALSE;
+        }
+        if (pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx) {
+            if (ma_dr_wav_bytes_to_u32_ex(chunkSizeBytes, pWav->container) < 36) {
+                return MA_FALSE;
+            }
+        } else if (pWav->container == ma_dr_wav_container_rf64) {
+            if (ma_dr_wav_bytes_to_u32_le(chunkSizeBytes) != 0xFFFFFFFF) {
+                return MA_FALSE;
+            }
+        } else {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, wave, sizeof(wave), &cursor) != sizeof(wave)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_wav_fourcc_equal(wave, "WAVE")) {
+            return MA_FALSE;
+        }
+    } else if (pWav->container == ma_dr_wav_container_w64) {
+        ma_uint8 chunkSizeBytes[8];
+        ma_uint8 wave[16];
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav_bytes_to_u64(chunkSizeBytes) < 80) {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, wave, sizeof(wave), &cursor) != sizeof(wave)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_wav_guid_equal(wave, ma_dr_wavGUID_W64_WAVE)) {
+            return MA_FALSE;
+        }
+    } else if (pWav->container == ma_dr_wav_container_aiff) {
+        ma_uint8 chunkSizeBytes[4];
+        ma_uint8 aiff[4];
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, chunkSizeBytes, sizeof(chunkSizeBytes), &cursor) != sizeof(chunkSizeBytes)) {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav_bytes_to_u32_be(chunkSizeBytes) < 18) {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, aiff, sizeof(aiff), &cursor) != sizeof(aiff)) {
+            return MA_FALSE;
+        }
+        if (ma_dr_wav_fourcc_equal(aiff, "AIFF")) {
+            isAIFCFormType = MA_FALSE;
+        } else if (ma_dr_wav_fourcc_equal(aiff, "AIFC")) {
+            isAIFCFormType = MA_TRUE;
+        } else {
+            return MA_FALSE;
+        }
+    } else {
+        return MA_FALSE;
+    }
+    if (pWav->container == ma_dr_wav_container_rf64) {
+        ma_uint8 sizeBytes[8];
+        ma_uint64 bytesRemainingInChunk;
+        ma_dr_wav_chunk_header header;
+        result = ma_dr_wav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
+        if (result != MA_SUCCESS) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_wav_fourcc_equal(header.id.fourcc, "ds64")) {
+            return MA_FALSE;
+        }
+        bytesRemainingInChunk = header.sizeInBytes + header.paddingSize;
+        if (!ma_dr_wav__seek_forward(pWav->onSeek, 8, pWav->pUserData)) {
+            return MA_FALSE;
+        }
+        bytesRemainingInChunk -= 8;
+        cursor += 8;
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, sizeBytes, sizeof(sizeBytes), &cursor) != sizeof(sizeBytes)) {
+            return MA_FALSE;
+        }
+        bytesRemainingInChunk -= 8;
+        dataChunkSize = ma_dr_wav_bytes_to_u64(sizeBytes);
+        if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, sizeBytes, sizeof(sizeBytes), &cursor) != sizeof(sizeBytes)) {
+            return MA_FALSE;
+        }
+        bytesRemainingInChunk -= 8;
+        sampleCountFromFactChunk = ma_dr_wav_bytes_to_u64(sizeBytes);
+        if (!ma_dr_wav__seek_forward(pWav->onSeek, bytesRemainingInChunk, pWav->pUserData)) {
+            return MA_FALSE;
+        }
+        cursor += bytesRemainingInChunk;
+    }
+    metadataStartPos = cursor;
+    isProcessingMetadata = !sequential && ((flags & MA_DR_WAV_WITH_METADATA) != 0);
+    if (pWav->container != ma_dr_wav_container_riff && pWav->container != ma_dr_wav_container_rf64) {
+        isProcessingMetadata = MA_FALSE;
+    }
+    MA_DR_WAV_ZERO_MEMORY(&metadataParser, sizeof(metadataParser));
+    if (isProcessingMetadata) {
+        metadataParser.onRead = pWav->onRead;
+        metadataParser.onSeek = pWav->onSeek;
+        metadataParser.pReadSeekUserData = pWav->pUserData;
+        metadataParser.stage  = ma_dr_wav__metadata_parser_stage_count;
+    }
+    for (;;) {
+        ma_dr_wav_chunk_header header;
+        ma_uint64 chunkSize;
+        result = ma_dr_wav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
+        if (result != MA_SUCCESS) {
+            break;
+        }
+        chunkSize = header.sizeInBytes;
+        if (!sequential && onChunk != NULL) {
+            ma_uint64 callbackBytesRead = onChunk(pChunkUserData, pWav->onRead, pWav->onSeek, pWav->pUserData, &header, pWav->container, &fmt);
+            if (callbackBytesRead > 0) {
+                if (ma_dr_wav__seek_from_start(pWav->onSeek, cursor, pWav->pUserData) == MA_FALSE) {
+                    return MA_FALSE;
+                }
+            }
+        }
+        if (((pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx || pWav->container == ma_dr_wav_container_rf64) && ma_dr_wav_fourcc_equal(header.id.fourcc, "fmt ")) ||
+            ((pWav->container == ma_dr_wav_container_w64) && ma_dr_wav_guid_equal(header.id.guid, ma_dr_wavGUID_W64_FMT))) {
+            ma_uint8 fmtData[16];
+            foundChunk_fmt = MA_TRUE;
+            if (pWav->onRead(pWav->pUserData, fmtData, sizeof(fmtData)) != sizeof(fmtData)) {
+                return MA_FALSE;
+            }
+            cursor += sizeof(fmtData);
+            fmt.formatTag      = ma_dr_wav_bytes_to_u16_ex(fmtData + 0,  pWav->container);
+            fmt.channels       = ma_dr_wav_bytes_to_u16_ex(fmtData + 2,  pWav->container);
+            fmt.sampleRate     = ma_dr_wav_bytes_to_u32_ex(fmtData + 4,  pWav->container);
+            fmt.avgBytesPerSec = ma_dr_wav_bytes_to_u32_ex(fmtData + 8,  pWav->container);
+            fmt.blockAlign     = ma_dr_wav_bytes_to_u16_ex(fmtData + 12, pWav->container);
+            fmt.bitsPerSample  = ma_dr_wav_bytes_to_u16_ex(fmtData + 14, pWav->container);
+            fmt.extendedSize       = 0;
+            fmt.validBitsPerSample = 0;
+            fmt.channelMask        = 0;
+            MA_DR_WAV_ZERO_MEMORY(fmt.subFormat, sizeof(fmt.subFormat));
+            if (header.sizeInBytes > 16) {
+                ma_uint8 fmt_cbSize[2];
+                int bytesReadSoFar = 0;
+                if (pWav->onRead(pWav->pUserData, fmt_cbSize, sizeof(fmt_cbSize)) != sizeof(fmt_cbSize)) {
+                    return MA_FALSE;
+                }
+                cursor += sizeof(fmt_cbSize);
+                bytesReadSoFar = 18;
+                fmt.extendedSize = ma_dr_wav_bytes_to_u16_ex(fmt_cbSize, pWav->container);
+                if (fmt.extendedSize > 0) {
+                    if (fmt.formatTag == MA_DR_WAVE_FORMAT_EXTENSIBLE) {
+                        if (fmt.extendedSize != 22) {
+                            return MA_FALSE;
+                        }
+                    }
+                    if (fmt.formatTag == MA_DR_WAVE_FORMAT_EXTENSIBLE) {
+                        ma_uint8 fmtext[22];
+                        if (pWav->onRead(pWav->pUserData, fmtext, fmt.extendedSize) != fmt.extendedSize) {
+                            return MA_FALSE;
+                        }
+                        fmt.validBitsPerSample = ma_dr_wav_bytes_to_u16_ex(fmtext + 0, pWav->container);
+                        fmt.channelMask        = ma_dr_wav_bytes_to_u32_ex(fmtext + 2, pWav->container);
+                        ma_dr_wav_bytes_to_guid(fmtext + 6, fmt.subFormat);
+                    } else {
+                        if (pWav->onSeek(pWav->pUserData, fmt.extendedSize, ma_dr_wav_seek_origin_current) == MA_FALSE) {
+                            return MA_FALSE;
+                        }
+                    }
+                    cursor += fmt.extendedSize;
+                    bytesReadSoFar += fmt.extendedSize;
+                }
+                if (pWav->onSeek(pWav->pUserData, (int)(header.sizeInBytes - bytesReadSoFar), ma_dr_wav_seek_origin_current) == MA_FALSE) {
+                    return MA_FALSE;
+                }
+                cursor += (header.sizeInBytes - bytesReadSoFar);
+            }
+            if (header.paddingSize > 0) {
+                if (ma_dr_wav__seek_forward(pWav->onSeek, header.paddingSize, pWav->pUserData) == MA_FALSE) {
+                    break;
+                }
+                cursor += header.paddingSize;
+            }
+            continue;
+        }
+        if (((pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx || pWav->container == ma_dr_wav_container_rf64) && ma_dr_wav_fourcc_equal(header.id.fourcc, "data")) ||
+            ((pWav->container == ma_dr_wav_container_w64) && ma_dr_wav_guid_equal(header.id.guid, ma_dr_wavGUID_W64_DATA))) {
+            foundChunk_data = MA_TRUE;
+            pWav->dataChunkDataPos  = cursor;
+            if (pWav->container != ma_dr_wav_container_rf64) {
+                dataChunkSize = chunkSize;
+            }
+            if (sequential || !isProcessingMetadata) {
+                break;
+            } else {
+                chunkSize += header.paddingSize;
+                if (ma_dr_wav__seek_forward(pWav->onSeek, chunkSize, pWav->pUserData) == MA_FALSE) {
+                    break;
+                }
+                cursor += chunkSize;
+                continue;
+            }
+        }
+        if (((pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx || pWav->container == ma_dr_wav_container_rf64) && ma_dr_wav_fourcc_equal(header.id.fourcc, "fact")) ||
+            ((pWav->container == ma_dr_wav_container_w64) && ma_dr_wav_guid_equal(header.id.guid, ma_dr_wavGUID_W64_FACT))) {
+            if (pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx) {
+                ma_uint8 sampleCount[4];
+                if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, &sampleCount, 4, &cursor) != 4) {
+                    return MA_FALSE;
+                }
+                chunkSize -= 4;
+                if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+                    sampleCountFromFactChunk = ma_dr_wav_bytes_to_u32_ex(sampleCount, pWav->container);
+                } else {
+                    sampleCountFromFactChunk = 0;
+                }
+            } else if (pWav->container == ma_dr_wav_container_w64) {
+                if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, &sampleCountFromFactChunk, 8, &cursor) != 8) {
+                    return MA_FALSE;
+                }
+                chunkSize -= 8;
+            } else if (pWav->container == ma_dr_wav_container_rf64) {
+            }
+            chunkSize += header.paddingSize;
+            if (ma_dr_wav__seek_forward(pWav->onSeek, chunkSize, pWav->pUserData) == MA_FALSE) {
+                break;
+            }
+            cursor += chunkSize;
+            continue;
+        }
+        if (pWav->container == ma_dr_wav_container_aiff && ma_dr_wav_fourcc_equal(header.id.fourcc, "COMM")) {
+            ma_uint8 commData[24];
+            ma_uint32 commDataBytesToRead;
+            ma_uint16 channels;
+            ma_uint32 frameCount;
+            ma_uint16 sampleSizeInBits;
+            ma_int64  sampleRate;
+            ma_uint16 compressionFormat;
+            foundChunk_fmt = MA_TRUE;
+            if (isAIFCFormType) {
+                commDataBytesToRead = 24;
+                if (header.sizeInBytes < commDataBytesToRead) {
+                    return MA_FALSE;
+                }
+            } else {
+                commDataBytesToRead = 18;
+                if (header.sizeInBytes != commDataBytesToRead) {
+                    return MA_FALSE;
+                }
+            }
+            if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, commData, commDataBytesToRead, &cursor) != commDataBytesToRead) {
+                return MA_FALSE;
+            }
+            channels         = ma_dr_wav_bytes_to_u16_ex     (commData + 0, pWav->container);
+            frameCount       = ma_dr_wav_bytes_to_u32_ex     (commData + 2, pWav->container);
+            sampleSizeInBits = ma_dr_wav_bytes_to_u16_ex     (commData + 6, pWav->container);
+            sampleRate       = ma_dr_wav_aiff_extented_to_s64(commData + 8);
+            if (sampleRate < 0 || sampleRate > 0xFFFFFFFF) {
+                return MA_FALSE;
+            }
+            if (isAIFCFormType) {
+                const ma_uint8* type = commData + 18;
+                if (ma_dr_wav_fourcc_equal(type, "NONE")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_PCM;
+                } else if (ma_dr_wav_fourcc_equal(type, "raw ")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_PCM;
+                    if (sampleSizeInBits == 8) {
+                        pWav->aiff.isUnsigned = MA_TRUE;
+                    }
+                } else if (ma_dr_wav_fourcc_equal(type, "sowt")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_PCM;
+                    pWav->aiff.isLE = MA_TRUE;
+                } else if (ma_dr_wav_fourcc_equal(type, "fl32") || ma_dr_wav_fourcc_equal(type, "fl64") || ma_dr_wav_fourcc_equal(type, "FL32") || ma_dr_wav_fourcc_equal(type, "FL64")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_IEEE_FLOAT;
+                } else if (ma_dr_wav_fourcc_equal(type, "alaw") || ma_dr_wav_fourcc_equal(type, "ALAW")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_ALAW;
+                } else if (ma_dr_wav_fourcc_equal(type, "ulaw") || ma_dr_wav_fourcc_equal(type, "ULAW")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_MULAW;
+                } else if (ma_dr_wav_fourcc_equal(type, "ima4")) {
+                    compressionFormat = MA_DR_WAVE_FORMAT_DVI_ADPCM;
+                    sampleSizeInBits = 4;
+                    return MA_FALSE;
+                } else {
+                    return MA_FALSE;
+                }
+            } else {
+                compressionFormat = MA_DR_WAVE_FORMAT_PCM;
+            }
+            aiffFrameCount = frameCount;
+            fmt.formatTag      = compressionFormat;
+            fmt.channels       = channels;
+            fmt.sampleRate     = (ma_uint32)sampleRate;
+            fmt.bitsPerSample  = sampleSizeInBits;
+            fmt.blockAlign     = (ma_uint16)(fmt.channels * fmt.bitsPerSample / 8);
+            fmt.avgBytesPerSec = fmt.blockAlign * fmt.sampleRate;
+            if (fmt.blockAlign == 0 && compressionFormat == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+                fmt.blockAlign = 34 * fmt.channels;
+            }
+            if (compressionFormat == MA_DR_WAVE_FORMAT_ALAW || compressionFormat == MA_DR_WAVE_FORMAT_MULAW) {
+                if (fmt.bitsPerSample > 8) {
+                    fmt.bitsPerSample = 8;
+                    fmt.blockAlign = fmt.channels;
+                }
+            }
+            fmt.bitsPerSample += (fmt.bitsPerSample & 7);
+            if (isAIFCFormType) {
+                if (ma_dr_wav__seek_forward(pWav->onSeek, (chunkSize - commDataBytesToRead), pWav->pUserData) == MA_FALSE) {
+                    return MA_FALSE;
+                }
+                cursor += (chunkSize - commDataBytesToRead);
+            }
+            continue;
+        }
+        if (pWav->container == ma_dr_wav_container_aiff && ma_dr_wav_fourcc_equal(header.id.fourcc, "SSND")) {
+            ma_uint8 offsetAndBlockSizeData[8];
+            ma_uint32 offset;
+            foundChunk_data = MA_TRUE;
+            if (ma_dr_wav__on_read(pWav->onRead, pWav->pUserData, offsetAndBlockSizeData, sizeof(offsetAndBlockSizeData), &cursor) != sizeof(offsetAndBlockSizeData)) {
+                return MA_FALSE;
+            }
+            offset = ma_dr_wav_bytes_to_u32_ex(offsetAndBlockSizeData + 0, pWav->container);
+            if (ma_dr_wav__seek_forward(pWav->onSeek, offset, pWav->pUserData) == MA_FALSE) {
+                return MA_FALSE;
+            }
+            cursor += offset;
+            pWav->dataChunkDataPos = cursor;
+            dataChunkSize = chunkSize;
+            if (sequential || !isProcessingMetadata) {
+                break;
+            } else {
+                if (ma_dr_wav__seek_forward(pWav->onSeek, chunkSize, pWav->pUserData) == MA_FALSE) {
+                    break;
+                }
+                cursor += chunkSize;
+                continue;
+            }
+        }
+        if (isProcessingMetadata) {
+            ma_uint64 metadataBytesRead;
+            metadataBytesRead = ma_dr_wav__metadata_process_chunk(&metadataParser, &header, ma_dr_wav_metadata_type_all_including_unknown);
+            MA_DR_WAV_ASSERT(metadataBytesRead <= header.sizeInBytes);
+            if (ma_dr_wav__seek_from_start(pWav->onSeek, cursor, pWav->pUserData) == MA_FALSE) {
+                break;
+            }
+        }
+        chunkSize += header.paddingSize;
+        if (ma_dr_wav__seek_forward(pWav->onSeek, chunkSize, pWav->pUserData) == MA_FALSE) {
+            break;
+        }
+        cursor += chunkSize;
+    }
+    if (!foundChunk_fmt || !foundChunk_data) {
+        return MA_FALSE;
+    }
+    if ((fmt.sampleRate    == 0 || fmt.sampleRate    > MA_DR_WAV_MAX_SAMPLE_RATE    ) ||
+        (fmt.channels      == 0 || fmt.channels      > MA_DR_WAV_MAX_CHANNELS       ) ||
+        (fmt.bitsPerSample == 0 || fmt.bitsPerSample > MA_DR_WAV_MAX_BITS_PER_SAMPLE) ||
+        fmt.blockAlign == 0) {
+        return MA_FALSE;
+    }
+    translatedFormatTag = fmt.formatTag;
+    if (translatedFormatTag == MA_DR_WAVE_FORMAT_EXTENSIBLE) {
+        translatedFormatTag = ma_dr_wav_bytes_to_u16_ex(fmt.subFormat + 0, pWav->container);
+    }
+    if (!sequential) {
+        if (!ma_dr_wav__seek_from_start(pWav->onSeek, pWav->dataChunkDataPos, pWav->pUserData)) {
+            return MA_FALSE;
+        }
+        cursor = pWav->dataChunkDataPos;
+    }
+    if (isProcessingMetadata && metadataParser.metadataCount > 0) {
+        if (ma_dr_wav__seek_from_start(pWav->onSeek, metadataStartPos, pWav->pUserData) == MA_FALSE) {
+            return MA_FALSE;
+        }
+        result = ma_dr_wav__metadata_alloc(&metadataParser, &pWav->allocationCallbacks);
+        if (result != MA_SUCCESS) {
+            return MA_FALSE;
+        }
+        metadataParser.stage = ma_dr_wav__metadata_parser_stage_read;
+        for (;;) {
+            ma_dr_wav_chunk_header header;
+            ma_uint64 metadataBytesRead;
+            result = ma_dr_wav__read_chunk_header(pWav->onRead, pWav->pUserData, pWav->container, &cursor, &header);
+            if (result != MA_SUCCESS) {
+                break;
+            }
+            metadataBytesRead = ma_dr_wav__metadata_process_chunk(&metadataParser, &header, ma_dr_wav_metadata_type_all_including_unknown);
+            if (ma_dr_wav__seek_forward(pWav->onSeek, (header.sizeInBytes + header.paddingSize) - metadataBytesRead, pWav->pUserData) == MA_FALSE) {
+                ma_dr_wav_free(metadataParser.pMetadata, &pWav->allocationCallbacks);
+                return MA_FALSE;
+            }
+        }
+        pWav->pMetadata     = metadataParser.pMetadata;
+        pWav->metadataCount = metadataParser.metadataCount;
+    }
+    if (dataChunkSize == 0xFFFFFFFF && (pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rifx) && pWav->isSequentialWrite == MA_FALSE) {
+        dataChunkSize = 0;
+        for (;;) {
+            ma_uint8 temp[4096];
+            size_t bytesRead = pWav->onRead(pWav->pUserData, temp, sizeof(temp));
+            dataChunkSize += bytesRead;
+            if (bytesRead < sizeof(temp)) {
+                break;
+            }
+        }
+    }
+    if (ma_dr_wav__seek_from_start(pWav->onSeek, pWav->dataChunkDataPos, pWav->pUserData) == MA_FALSE) {
+        ma_dr_wav_free(pWav->pMetadata, &pWav->allocationCallbacks);
+        return MA_FALSE;
+    }
+    pWav->fmt                 = fmt;
+    pWav->sampleRate          = fmt.sampleRate;
+    pWav->channels            = fmt.channels;
+    pWav->bitsPerSample       = fmt.bitsPerSample;
+    pWav->bytesRemaining      = dataChunkSize;
+    pWav->translatedFormatTag = translatedFormatTag;
+    pWav->dataChunkDataSize   = dataChunkSize;
+    if (sampleCountFromFactChunk != 0) {
+        pWav->totalPCMFrameCount = sampleCountFromFactChunk;
+    } else if (aiffFrameCount != 0) {
+        pWav->totalPCMFrameCount = aiffFrameCount;
+    } else {
+        ma_uint32 bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+        if (bytesPerFrame == 0) {
+            ma_dr_wav_free(pWav->pMetadata, &pWav->allocationCallbacks);
+            return MA_FALSE;
+        }
+        pWav->totalPCMFrameCount = dataChunkSize / bytesPerFrame;
+        if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+            ma_uint64 totalBlockHeaderSizeInBytes;
+            ma_uint64 blockCount = dataChunkSize / fmt.blockAlign;
+            if ((blockCount * fmt.blockAlign) < dataChunkSize) {
+                blockCount += 1;
+            }
+            totalBlockHeaderSizeInBytes = blockCount * (6*fmt.channels);
+            pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
+        }
+        if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+            ma_uint64 totalBlockHeaderSizeInBytes;
+            ma_uint64 blockCount = dataChunkSize / fmt.blockAlign;
+            if ((blockCount * fmt.blockAlign) < dataChunkSize) {
+                blockCount += 1;
+            }
+            totalBlockHeaderSizeInBytes = blockCount * (4*fmt.channels);
+            pWav->totalPCMFrameCount = ((dataChunkSize - totalBlockHeaderSizeInBytes) * 2) / fmt.channels;
+            pWav->totalPCMFrameCount += blockCount;
+        }
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM || pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        if (pWav->channels > 2) {
+            ma_dr_wav_free(pWav->pMetadata, &pWav->allocationCallbacks);
+            return MA_FALSE;
+        }
+    }
+    if (ma_dr_wav_get_bytes_per_pcm_frame(pWav) == 0) {
+        ma_dr_wav_free(pWav->pMetadata, &pWav->allocationCallbacks);
+        return MA_FALSE;
+    }
+#ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+        ma_uint64 blockCount = dataChunkSize / fmt.blockAlign;
+        pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (6*pWav->channels))) * 2)) / fmt.channels;
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        ma_uint64 blockCount = dataChunkSize / fmt.blockAlign;
+        pWav->totalPCMFrameCount = (((blockCount * (fmt.blockAlign - (4*pWav->channels))) * 2) + (blockCount * pWav->channels)) / fmt.channels;
+    }
+#endif
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_init(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_ex(pWav, onRead, onSeek, NULL, pUserData, NULL, 0, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_ex(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, ma_dr_wav_chunk_proc onChunk, void* pReadSeekUserData, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (!ma_dr_wav_preinit(pWav, onRead, onSeek, pReadSeekUserData, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init__internal(pWav, onChunk, pChunkUserData, flags);
+}
+MA_API ma_bool32 ma_dr_wav_init_with_metadata(ma_dr_wav* pWav, ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (!ma_dr_wav_preinit(pWav, onRead, onSeek, pUserData, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init__internal(pWav, NULL, NULL, flags | MA_DR_WAV_WITH_METADATA);
+}
+MA_API ma_dr_wav_metadata* ma_dr_wav_take_ownership_of_metadata(ma_dr_wav* pWav)
+{
+    ma_dr_wav_metadata *result = pWav->pMetadata;
+    pWav->pMetadata     = NULL;
+    pWav->metadataCount = 0;
+    return result;
+}
+MA_PRIVATE size_t ma_dr_wav__write(ma_dr_wav* pWav, const void* pData, size_t dataSize)
+{
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    return pWav->onWrite(pWav->pUserData, pData, dataSize);
+}
+MA_PRIVATE size_t ma_dr_wav__write_byte(ma_dr_wav* pWav, ma_uint8 byte)
+{
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    return pWav->onWrite(pWav->pUserData, &byte, 1);
+}
+MA_PRIVATE size_t ma_dr_wav__write_u16ne_to_le(ma_dr_wav* pWav, ma_uint16 value)
+{
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    if (!ma_dr_wav__is_little_endian()) {
+        value = ma_dr_wav__bswap16(value);
+    }
+    return ma_dr_wav__write(pWav, &value, 2);
+}
+MA_PRIVATE size_t ma_dr_wav__write_u32ne_to_le(ma_dr_wav* pWav, ma_uint32 value)
+{
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    if (!ma_dr_wav__is_little_endian()) {
+        value = ma_dr_wav__bswap32(value);
+    }
+    return ma_dr_wav__write(pWav, &value, 4);
+}
+MA_PRIVATE size_t ma_dr_wav__write_u64ne_to_le(ma_dr_wav* pWav, ma_uint64 value)
+{
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    if (!ma_dr_wav__is_little_endian()) {
+        value = ma_dr_wav__bswap64(value);
+    }
+    return ma_dr_wav__write(pWav, &value, 8);
+}
+MA_PRIVATE size_t ma_dr_wav__write_f32ne_to_le(ma_dr_wav* pWav, float value)
+{
+    union {
+       ma_uint32 u32;
+       float f32;
+    } u;
+    MA_DR_WAV_ASSERT(pWav          != NULL);
+    MA_DR_WAV_ASSERT(pWav->onWrite != NULL);
+    u.f32 = value;
+    if (!ma_dr_wav__is_little_endian()) {
+        u.u32 = ma_dr_wav__bswap32(u.u32);
+    }
+    return ma_dr_wav__write(pWav, &u.u32, 4);
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count(ma_dr_wav* pWav, const void* pData, size_t dataSize)
+{
+    if (pWav == NULL) {
+        return dataSize;
+    }
+    return ma_dr_wav__write(pWav, pData, dataSize);
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count_byte(ma_dr_wav* pWav, ma_uint8 byte)
+{
+    if (pWav == NULL) {
+        return 1;
+    }
+    return ma_dr_wav__write_byte(pWav, byte);
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count_u16ne_to_le(ma_dr_wav* pWav, ma_uint16 value)
+{
+    if (pWav == NULL) {
+        return 2;
+    }
+    return ma_dr_wav__write_u16ne_to_le(pWav, value);
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count_u32ne_to_le(ma_dr_wav* pWav, ma_uint32 value)
+{
+    if (pWav == NULL) {
+        return 4;
+    }
+    return ma_dr_wav__write_u32ne_to_le(pWav, value);
+}
+#if 0
+MA_PRIVATE size_t ma_dr_wav__write_or_count_u64ne_to_le(ma_dr_wav* pWav, ma_uint64 value)
+{
+    if (pWav == NULL) {
+        return 8;
+    }
+    return ma_dr_wav__write_u64ne_to_le(pWav, value);
+}
+#endif
+MA_PRIVATE size_t ma_dr_wav__write_or_count_f32ne_to_le(ma_dr_wav* pWav, float value)
+{
+    if (pWav == NULL) {
+        return 4;
+    }
+    return ma_dr_wav__write_f32ne_to_le(pWav, value);
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count_string_to_fixed_size_buf(ma_dr_wav* pWav, char* str, size_t bufFixedSize)
+{
+    size_t len;
+    if (pWav == NULL) {
+        return bufFixedSize;
+    }
+    len = ma_dr_wav__strlen_clamped(str, bufFixedSize);
+    ma_dr_wav__write_or_count(pWav, str, len);
+    if (len < bufFixedSize) {
+        size_t i;
+        for (i = 0; i < bufFixedSize - len; ++i) {
+            ma_dr_wav__write_byte(pWav, 0);
+        }
+    }
+    return bufFixedSize;
+}
+MA_PRIVATE size_t ma_dr_wav__write_or_count_metadata(ma_dr_wav* pWav, ma_dr_wav_metadata* pMetadatas, ma_uint32 metadataCount)
+{
+    size_t bytesWritten = 0;
+    ma_bool32 hasListAdtl = MA_FALSE;
+    ma_bool32 hasListInfo = MA_FALSE;
+    ma_uint32 iMetadata;
+    if (pMetadatas == NULL || metadataCount == 0) {
+        return 0;
+    }
+    for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
+        ma_dr_wav_metadata* pMetadata = &pMetadatas[iMetadata];
+        ma_uint32 chunkSize = 0;
+        if ((pMetadata->type & ma_dr_wav_metadata_type_list_all_info_strings) || (pMetadata->type == ma_dr_wav_metadata_type_unknown && pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_info_list)) {
+            hasListInfo = MA_TRUE;
+        }
+        if ((pMetadata->type & ma_dr_wav_metadata_type_list_all_adtl) || (pMetadata->type == ma_dr_wav_metadata_type_unknown && pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_adtl_list)) {
+            hasListAdtl = MA_TRUE;
+        }
+        switch (pMetadata->type) {
+            case ma_dr_wav_metadata_type_smpl:
+            {
+                ma_uint32 iLoop;
+                chunkSize = MA_DR_WAV_SMPL_BYTES + MA_DR_WAV_SMPL_LOOP_BYTES * pMetadata->data.smpl.sampleLoopCount + pMetadata->data.smpl.samplerSpecificDataSizeInBytes;
+                bytesWritten += ma_dr_wav__write_or_count(pWav, "smpl", 4);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.manufacturerId);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.productId);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.samplePeriodNanoseconds);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.midiUnityNote);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.midiPitchFraction);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.smpteFormat);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.smpteOffset);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.sampleLoopCount);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.samplerSpecificDataSizeInBytes);
+                for (iLoop = 0; iLoop < pMetadata->data.smpl.sampleLoopCount; ++iLoop) {
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].cuePointId);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].type);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].firstSampleByteOffset);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].lastSampleByteOffset);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].sampleFraction);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.smpl.pLoops[iLoop].playCount);
+                }
+                if (pMetadata->data.smpl.samplerSpecificDataSizeInBytes > 0) {
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.smpl.pSamplerSpecificData, pMetadata->data.smpl.samplerSpecificDataSizeInBytes);
+                }
+            } break;
+            case ma_dr_wav_metadata_type_inst:
+            {
+                chunkSize = MA_DR_WAV_INST_BYTES;
+                bytesWritten += ma_dr_wav__write_or_count(pWav, "inst", 4);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.midiUnityNote, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.fineTuneCents, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.gainDecibels, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.lowNote, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.highNote, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.lowVelocity, 1);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, &pMetadata->data.inst.highVelocity, 1);
+            } break;
+            case ma_dr_wav_metadata_type_cue:
+            {
+                ma_uint32 iCuePoint;
+                chunkSize = MA_DR_WAV_CUE_BYTES + MA_DR_WAV_CUE_POINT_BYTES * pMetadata->data.cue.cuePointCount;
+                bytesWritten += ma_dr_wav__write_or_count(pWav, "cue ", 4);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.cuePointCount);
+                for (iCuePoint = 0; iCuePoint < pMetadata->data.cue.cuePointCount; ++iCuePoint) {
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].id);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].playOrderPosition);
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].dataChunkId, 4);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].chunkStart);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].blockStart);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.cue.pCuePoints[iCuePoint].sampleByteOffset);
+                }
+            } break;
+            case ma_dr_wav_metadata_type_acid:
+            {
+                chunkSize = MA_DR_WAV_ACID_BYTES;
+                bytesWritten += ma_dr_wav__write_or_count(pWav, "acid", 4);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.acid.flags);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.acid.midiUnityNote);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.acid.reserved1);
+                bytesWritten += ma_dr_wav__write_or_count_f32ne_to_le(pWav, pMetadata->data.acid.reserved2);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.acid.numBeats);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.acid.meterDenominator);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.acid.meterNumerator);
+                bytesWritten += ma_dr_wav__write_or_count_f32ne_to_le(pWav, pMetadata->data.acid.tempo);
+            } break;
+            case ma_dr_wav_metadata_type_bext:
+            {
+                char reservedBuf[MA_DR_WAV_BEXT_RESERVED_BYTES];
+                ma_uint32 timeReferenceLow;
+                ma_uint32 timeReferenceHigh;
+                chunkSize = MA_DR_WAV_BEXT_BYTES + pMetadata->data.bext.codingHistorySize;
+                bytesWritten += ma_dr_wav__write_or_count(pWav, "bext", 4);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                bytesWritten += ma_dr_wav__write_or_count_string_to_fixed_size_buf(pWav, pMetadata->data.bext.pDescription, MA_DR_WAV_BEXT_DESCRIPTION_BYTES);
+                bytesWritten += ma_dr_wav__write_or_count_string_to_fixed_size_buf(pWav, pMetadata->data.bext.pOriginatorName, MA_DR_WAV_BEXT_ORIGINATOR_NAME_BYTES);
+                bytesWritten += ma_dr_wav__write_or_count_string_to_fixed_size_buf(pWav, pMetadata->data.bext.pOriginatorReference, MA_DR_WAV_BEXT_ORIGINATOR_REF_BYTES);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.bext.pOriginationDate, sizeof(pMetadata->data.bext.pOriginationDate));
+                bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.bext.pOriginationTime, sizeof(pMetadata->data.bext.pOriginationTime));
+                timeReferenceLow  = (ma_uint32)(pMetadata->data.bext.timeReference & 0xFFFFFFFF);
+                timeReferenceHigh = (ma_uint32)(pMetadata->data.bext.timeReference >> 32);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, timeReferenceLow);
+                bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, timeReferenceHigh);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.version);
+                bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.bext.pUMID, MA_DR_WAV_BEXT_UMID_BYTES);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.loudnessValue);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.loudnessRange);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.maxTruePeakLevel);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.maxMomentaryLoudness);
+                bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.maxShortTermLoudness);
+                MA_DR_WAV_ZERO_MEMORY(reservedBuf, sizeof(reservedBuf));
+                bytesWritten += ma_dr_wav__write_or_count(pWav, reservedBuf, sizeof(reservedBuf));
+                if (pMetadata->data.bext.codingHistorySize > 0) {
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.bext.pCodingHistory, pMetadata->data.bext.codingHistorySize);
+                }
+            } break;
+            case ma_dr_wav_metadata_type_unknown:
+            {
+                if (pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_top_level) {
+                    chunkSize = pMetadata->data.unknown.dataSizeInBytes;
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.id, 4);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.pData, pMetadata->data.unknown.dataSizeInBytes);
+                }
+            } break;
+            default: break;
+        }
+        if ((chunkSize % 2) != 0) {
+            bytesWritten += ma_dr_wav__write_or_count_byte(pWav, 0);
+        }
+    }
+    if (hasListInfo) {
+        ma_uint32 chunkSize = 4;
+        for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
+            ma_dr_wav_metadata* pMetadata = &pMetadatas[iMetadata];
+            if ((pMetadata->type & ma_dr_wav_metadata_type_list_all_info_strings)) {
+                chunkSize += 8;
+                chunkSize += pMetadata->data.infoText.stringLength + 1;
+            } else if (pMetadata->type == ma_dr_wav_metadata_type_unknown && pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_info_list) {
+                chunkSize += 8;
+                chunkSize += pMetadata->data.unknown.dataSizeInBytes;
+            }
+            if ((chunkSize % 2) != 0) {
+                chunkSize += 1;
+            }
+        }
+        bytesWritten += ma_dr_wav__write_or_count(pWav, "LIST", 4);
+        bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+        bytesWritten += ma_dr_wav__write_or_count(pWav, "INFO", 4);
+        for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
+            ma_dr_wav_metadata* pMetadata = &pMetadatas[iMetadata];
+            ma_uint32 subchunkSize = 0;
+            if (pMetadata->type & ma_dr_wav_metadata_type_list_all_info_strings) {
+                const char* pID = NULL;
+                switch (pMetadata->type) {
+                    case ma_dr_wav_metadata_type_list_info_software:    pID = "ISFT"; break;
+                    case ma_dr_wav_metadata_type_list_info_copyright:   pID = "ICOP"; break;
+                    case ma_dr_wav_metadata_type_list_info_title:       pID = "INAM"; break;
+                    case ma_dr_wav_metadata_type_list_info_artist:      pID = "IART"; break;
+                    case ma_dr_wav_metadata_type_list_info_comment:     pID = "ICMT"; break;
+                    case ma_dr_wav_metadata_type_list_info_date:        pID = "ICRD"; break;
+                    case ma_dr_wav_metadata_type_list_info_genre:       pID = "IGNR"; break;
+                    case ma_dr_wav_metadata_type_list_info_album:       pID = "IPRD"; break;
+                    case ma_dr_wav_metadata_type_list_info_tracknumber: pID = "ITRK"; break;
+                    default: break;
+                }
+                MA_DR_WAV_ASSERT(pID != NULL);
+                if (pMetadata->data.infoText.stringLength) {
+                    subchunkSize = pMetadata->data.infoText.stringLength + 1;
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pID, 4);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, subchunkSize);
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.infoText.pString, pMetadata->data.infoText.stringLength);
+                    bytesWritten += ma_dr_wav__write_or_count_byte(pWav, '\0');
+                }
+            } else if (pMetadata->type == ma_dr_wav_metadata_type_unknown && pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_info_list) {
+                if (pMetadata->data.unknown.dataSizeInBytes) {
+                    subchunkSize = pMetadata->data.unknown.dataSizeInBytes;
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.id, 4);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.unknown.dataSizeInBytes);
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.pData, subchunkSize);
+                }
+            }
+            if ((subchunkSize % 2) != 0) {
+                bytesWritten += ma_dr_wav__write_or_count_byte(pWav, 0);
+            }
+        }
+    }
+    if (hasListAdtl) {
+        ma_uint32 chunkSize = 4;
+        for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
+            ma_dr_wav_metadata* pMetadata = &pMetadatas[iMetadata];
+            switch (pMetadata->type)
+            {
+                case ma_dr_wav_metadata_type_list_label:
+                case ma_dr_wav_metadata_type_list_note:
+                {
+                    chunkSize += 8;
+                    chunkSize += MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES;
+                    if (pMetadata->data.labelOrNote.stringLength > 0) {
+                        chunkSize += pMetadata->data.labelOrNote.stringLength + 1;
+                    }
+                } break;
+                case ma_dr_wav_metadata_type_list_labelled_cue_region:
+                {
+                    chunkSize += 8;
+                    chunkSize += MA_DR_WAV_LIST_LABELLED_TEXT_BYTES;
+                    if (pMetadata->data.labelledCueRegion.stringLength > 0) {
+                        chunkSize += pMetadata->data.labelledCueRegion.stringLength + 1;
+                    }
+                } break;
+                case ma_dr_wav_metadata_type_unknown:
+                {
+                    if (pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_adtl_list) {
+                        chunkSize += 8;
+                        chunkSize += pMetadata->data.unknown.dataSizeInBytes;
+                    }
+                } break;
+                default: break;
+            }
+            if ((chunkSize % 2) != 0) {
+                chunkSize += 1;
+            }
+        }
+        bytesWritten += ma_dr_wav__write_or_count(pWav, "LIST", 4);
+        bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, chunkSize);
+        bytesWritten += ma_dr_wav__write_or_count(pWav, "adtl", 4);
+        for (iMetadata = 0; iMetadata < metadataCount; ++iMetadata) {
+            ma_dr_wav_metadata* pMetadata = &pMetadatas[iMetadata];
+            ma_uint32 subchunkSize = 0;
+            switch (pMetadata->type)
+            {
+                case ma_dr_wav_metadata_type_list_label:
+                case ma_dr_wav_metadata_type_list_note:
+                {
+                    if (pMetadata->data.labelOrNote.stringLength > 0) {
+                        const char *pID = NULL;
+                        if (pMetadata->type == ma_dr_wav_metadata_type_list_label) {
+                            pID = "labl";
+                        }
+                        else if (pMetadata->type == ma_dr_wav_metadata_type_list_note) {
+                            pID = "note";
+                        }
+                        MA_DR_WAV_ASSERT(pID != NULL);
+                        MA_DR_WAV_ASSERT(pMetadata->data.labelOrNote.pString != NULL);
+                        subchunkSize = MA_DR_WAV_LIST_LABEL_OR_NOTE_BYTES;
+                        bytesWritten += ma_dr_wav__write_or_count(pWav, pID, 4);
+                        subchunkSize += pMetadata->data.labelOrNote.stringLength + 1;
+                        bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, subchunkSize);
+                        bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.labelOrNote.cuePointId);
+                        bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.labelOrNote.pString, pMetadata->data.labelOrNote.stringLength);
+                        bytesWritten += ma_dr_wav__write_or_count_byte(pWav, '\0');
+                    }
+                } break;
+                case ma_dr_wav_metadata_type_list_labelled_cue_region:
+                {
+                    subchunkSize = MA_DR_WAV_LIST_LABELLED_TEXT_BYTES;
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, "ltxt", 4);
+                    if (pMetadata->data.labelledCueRegion.stringLength > 0) {
+                        subchunkSize += pMetadata->data.labelledCueRegion.stringLength + 1;
+                    }
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, subchunkSize);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.labelledCueRegion.cuePointId);
+                    bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, pMetadata->data.labelledCueRegion.sampleLength);
+                    bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.labelledCueRegion.purposeId, 4);
+                    bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.labelledCueRegion.country);
+                    bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.labelledCueRegion.language);
+                    bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.labelledCueRegion.dialect);
+                    bytesWritten += ma_dr_wav__write_or_count_u16ne_to_le(pWav, pMetadata->data.labelledCueRegion.codePage);
+                    if (pMetadata->data.labelledCueRegion.stringLength > 0) {
+                        MA_DR_WAV_ASSERT(pMetadata->data.labelledCueRegion.pString != NULL);
+                        bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.labelledCueRegion.pString, pMetadata->data.labelledCueRegion.stringLength);
+                        bytesWritten += ma_dr_wav__write_or_count_byte(pWav, '\0');
+                    }
+                } break;
+                case ma_dr_wav_metadata_type_unknown:
+                {
+                    if (pMetadata->data.unknown.chunkLocation == ma_dr_wav_metadata_location_inside_adtl_list) {
+                        subchunkSize = pMetadata->data.unknown.dataSizeInBytes;
+                        MA_DR_WAV_ASSERT(pMetadata->data.unknown.pData != NULL);
+                        bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.id, 4);
+                        bytesWritten += ma_dr_wav__write_or_count_u32ne_to_le(pWav, subchunkSize);
+                        bytesWritten += ma_dr_wav__write_or_count(pWav, pMetadata->data.unknown.pData, subchunkSize);
+                    }
+                } break;
+                default: break;
+            }
+            if ((subchunkSize % 2) != 0) {
+                bytesWritten += ma_dr_wav__write_or_count_byte(pWav, 0);
+            }
+        }
+    }
+    MA_DR_WAV_ASSERT((bytesWritten % 2) == 0);
+    return bytesWritten;
+}
+MA_PRIVATE ma_uint32 ma_dr_wav__riff_chunk_size_riff(ma_uint64 dataChunkSize, ma_dr_wav_metadata* pMetadata, ma_uint32 metadataCount)
+{
+    ma_uint64 chunkSize = 4 + 24 + (ma_uint64)ma_dr_wav__write_or_count_metadata(NULL, pMetadata, metadataCount) + 8 + dataChunkSize + ma_dr_wav__chunk_padding_size_riff(dataChunkSize);
+    if (chunkSize > 0xFFFFFFFFUL) {
+        chunkSize = 0xFFFFFFFFUL;
+    }
+    return (ma_uint32)chunkSize;
+}
+MA_PRIVATE ma_uint32 ma_dr_wav__data_chunk_size_riff(ma_uint64 dataChunkSize)
+{
+    if (dataChunkSize <= 0xFFFFFFFFUL) {
+        return (ma_uint32)dataChunkSize;
+    } else {
+        return 0xFFFFFFFFUL;
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__riff_chunk_size_w64(ma_uint64 dataChunkSize)
+{
+    ma_uint64 dataSubchunkPaddingSize = ma_dr_wav__chunk_padding_size_w64(dataChunkSize);
+    return 80 + 24 + dataChunkSize + dataSubchunkPaddingSize;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__data_chunk_size_w64(ma_uint64 dataChunkSize)
+{
+    return 24 + dataChunkSize;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__riff_chunk_size_rf64(ma_uint64 dataChunkSize, ma_dr_wav_metadata *metadata, ma_uint32 numMetadata)
+{
+    ma_uint64 chunkSize = 4 + 36 + 24 + (ma_uint64)ma_dr_wav__write_or_count_metadata(NULL, metadata, numMetadata) + 8 + dataChunkSize + ma_dr_wav__chunk_padding_size_riff(dataChunkSize);
+    if (chunkSize > 0xFFFFFFFFUL) {
+        chunkSize = 0xFFFFFFFFUL;
+    }
+    return chunkSize;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav__data_chunk_size_rf64(ma_uint64 dataChunkSize)
+{
+    return dataChunkSize;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_preinit_write(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_bool32 isSequential, ma_dr_wav_write_proc onWrite, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pWav == NULL || onWrite == NULL) {
+        return MA_FALSE;
+    }
+    if (!isSequential && onSeek == NULL) {
+        return MA_FALSE;
+    }
+    if (pFormat->format == MA_DR_WAVE_FORMAT_EXTENSIBLE) {
+        return MA_FALSE;
+    }
+    if (pFormat->format == MA_DR_WAVE_FORMAT_ADPCM || pFormat->format == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        return MA_FALSE;
+    }
+    MA_DR_WAV_ZERO_MEMORY(pWav, sizeof(*pWav));
+    pWav->onWrite   = onWrite;
+    pWav->onSeek    = onSeek;
+    pWav->pUserData = pUserData;
+    pWav->allocationCallbacks = ma_dr_wav_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
+    if (pWav->allocationCallbacks.onFree == NULL || (pWav->allocationCallbacks.onMalloc == NULL && pWav->allocationCallbacks.onRealloc == NULL)) {
+        return MA_FALSE;
+    }
+    pWav->fmt.formatTag = (ma_uint16)pFormat->format;
+    pWav->fmt.channels = (ma_uint16)pFormat->channels;
+    pWav->fmt.sampleRate = pFormat->sampleRate;
+    pWav->fmt.avgBytesPerSec = (ma_uint32)((pFormat->bitsPerSample * pFormat->sampleRate * pFormat->channels) / 8);
+    pWav->fmt.blockAlign = (ma_uint16)((pFormat->channels * pFormat->bitsPerSample) / 8);
+    pWav->fmt.bitsPerSample = (ma_uint16)pFormat->bitsPerSample;
+    pWav->fmt.extendedSize = 0;
+    pWav->isSequentialWrite = isSequential;
+    return MA_TRUE;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_init_write__internal(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount)
+{
+    size_t runningPos = 0;
+    ma_uint64 initialDataChunkSize = 0;
+    ma_uint64 chunkSizeFMT;
+    if (pWav->isSequentialWrite) {
+        initialDataChunkSize = (totalSampleCount * pWav->fmt.bitsPerSample) / 8;
+        if (pFormat->container == ma_dr_wav_container_riff) {
+            if (initialDataChunkSize > (0xFFFFFFFFUL - 36)) {
+                return MA_FALSE;
+            }
+        }
+    }
+    pWav->dataChunkDataSizeTargetWrite = initialDataChunkSize;
+    if (pFormat->container == ma_dr_wav_container_riff) {
+        ma_uint32 chunkSizeRIFF = 28 + (ma_uint32)initialDataChunkSize;
+        runningPos += ma_dr_wav__write(pWav, "RIFF", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, chunkSizeRIFF);
+        runningPos += ma_dr_wav__write(pWav, "WAVE", 4);
+    } else if (pFormat->container == ma_dr_wav_container_w64) {
+        ma_uint64 chunkSizeRIFF = 80 + 24 + initialDataChunkSize;
+        runningPos += ma_dr_wav__write(pWav, ma_dr_wavGUID_W64_RIFF, 16);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, chunkSizeRIFF);
+        runningPos += ma_dr_wav__write(pWav, ma_dr_wavGUID_W64_WAVE, 16);
+    } else if (pFormat->container == ma_dr_wav_container_rf64) {
+        runningPos += ma_dr_wav__write(pWav, "RF64", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, 0xFFFFFFFF);
+        runningPos += ma_dr_wav__write(pWav, "WAVE", 4);
+    } else {
+        return MA_FALSE;
+    }
+    if (pFormat->container == ma_dr_wav_container_rf64) {
+        ma_uint32 initialds64ChunkSize = 28;
+        ma_uint64 initialRiffChunkSize = 8 + initialds64ChunkSize + initialDataChunkSize;
+        runningPos += ma_dr_wav__write(pWav, "ds64", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, initialds64ChunkSize);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, initialRiffChunkSize);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, initialDataChunkSize);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, totalSampleCount);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, 0);
+    }
+    if (pFormat->container == ma_dr_wav_container_riff || pFormat->container == ma_dr_wav_container_rf64) {
+        chunkSizeFMT = 16;
+        runningPos += ma_dr_wav__write(pWav, "fmt ", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, (ma_uint32)chunkSizeFMT);
+    } else if (pFormat->container == ma_dr_wav_container_w64) {
+        chunkSizeFMT = 40;
+        runningPos += ma_dr_wav__write(pWav, ma_dr_wavGUID_W64_FMT, 16);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, chunkSizeFMT);
+    }
+    runningPos += ma_dr_wav__write_u16ne_to_le(pWav, pWav->fmt.formatTag);
+    runningPos += ma_dr_wav__write_u16ne_to_le(pWav, pWav->fmt.channels);
+    runningPos += ma_dr_wav__write_u32ne_to_le(pWav, pWav->fmt.sampleRate);
+    runningPos += ma_dr_wav__write_u32ne_to_le(pWav, pWav->fmt.avgBytesPerSec);
+    runningPos += ma_dr_wav__write_u16ne_to_le(pWav, pWav->fmt.blockAlign);
+    runningPos += ma_dr_wav__write_u16ne_to_le(pWav, pWav->fmt.bitsPerSample);
+    if (!pWav->isSequentialWrite && pWav->pMetadata != NULL && pWav->metadataCount > 0 && (pFormat->container == ma_dr_wav_container_riff || pFormat->container == ma_dr_wav_container_rf64)) {
+        runningPos += ma_dr_wav__write_or_count_metadata(pWav, pWav->pMetadata, pWav->metadataCount);
+    }
+    pWav->dataChunkDataPos = runningPos;
+    if (pFormat->container == ma_dr_wav_container_riff) {
+        ma_uint32 chunkSizeDATA = (ma_uint32)initialDataChunkSize;
+        runningPos += ma_dr_wav__write(pWav, "data", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, chunkSizeDATA);
+    } else if (pFormat->container == ma_dr_wav_container_w64) {
+        ma_uint64 chunkSizeDATA = 24 + initialDataChunkSize;
+        runningPos += ma_dr_wav__write(pWav, ma_dr_wavGUID_W64_DATA, 16);
+        runningPos += ma_dr_wav__write_u64ne_to_le(pWav, chunkSizeDATA);
+    } else if (pFormat->container == ma_dr_wav_container_rf64) {
+        runningPos += ma_dr_wav__write(pWav, "data", 4);
+        runningPos += ma_dr_wav__write_u32ne_to_le(pWav, 0xFFFFFFFF);
+    }
+    pWav->container = pFormat->container;
+    pWav->channels = (ma_uint16)pFormat->channels;
+    pWav->sampleRate = pFormat->sampleRate;
+    pWav->bitsPerSample = (ma_uint16)pFormat->bitsPerSample;
+    pWav->translatedFormatTag = (ma_uint16)pFormat->format;
+    pWav->dataChunkDataPos = runningPos;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_init_write(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_dr_wav_write_proc onWrite, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (!ma_dr_wav_preinit_write(pWav, pFormat, MA_FALSE, onWrite, onSeek, pUserData, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_write__internal(pWav, pFormat, 0);
+}
+MA_API ma_bool32 ma_dr_wav_init_write_sequential(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_dr_wav_write_proc onWrite, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (!ma_dr_wav_preinit_write(pWav, pFormat, MA_TRUE, onWrite, NULL, pUserData, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_write__internal(pWav, pFormat, totalSampleCount);
+}
+MA_API ma_bool32 ma_dr_wav_init_write_sequential_pcm_frames(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, ma_dr_wav_write_proc onWrite, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFormat == NULL) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_write_sequential(pWav, pFormat, totalPCMFrameCount*pFormat->channels, onWrite, pUserData, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_write_with_metadata(ma_dr_wav* pWav, const ma_dr_wav_data_format* pFormat, ma_dr_wav_write_proc onWrite, ma_dr_wav_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks, ma_dr_wav_metadata* pMetadata, ma_uint32 metadataCount)
+{
+    if (!ma_dr_wav_preinit_write(pWav, pFormat, MA_FALSE, onWrite, onSeek, pUserData, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    pWav->pMetadata     = pMetadata;
+    pWav->metadataCount = metadataCount;
+    return ma_dr_wav_init_write__internal(pWav, pFormat, 0);
+}
+MA_API ma_uint64 ma_dr_wav_target_write_size_bytes(const ma_dr_wav_data_format* pFormat, ma_uint64 totalFrameCount, ma_dr_wav_metadata* pMetadata, ma_uint32 metadataCount)
+{
+    ma_uint64 targetDataSizeBytes = (ma_uint64)((ma_int64)totalFrameCount * pFormat->channels * pFormat->bitsPerSample/8.0);
+    ma_uint64 riffChunkSizeBytes;
+    ma_uint64 fileSizeBytes = 0;
+    if (pFormat->container == ma_dr_wav_container_riff) {
+        riffChunkSizeBytes = ma_dr_wav__riff_chunk_size_riff(targetDataSizeBytes, pMetadata, metadataCount);
+        fileSizeBytes = (8 + riffChunkSizeBytes);
+    } else if (pFormat->container == ma_dr_wav_container_w64) {
+        riffChunkSizeBytes = ma_dr_wav__riff_chunk_size_w64(targetDataSizeBytes);
+        fileSizeBytes = riffChunkSizeBytes;
+    } else if (pFormat->container == ma_dr_wav_container_rf64) {
+        riffChunkSizeBytes = ma_dr_wav__riff_chunk_size_rf64(targetDataSizeBytes, pMetadata, metadataCount);
+        fileSizeBytes = (8 + riffChunkSizeBytes);
+    }
+    return fileSizeBytes;
+}
+#ifndef MA_DR_WAV_NO_STDIO
+MA_PRIVATE size_t ma_dr_wav__on_read_stdio(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    return fread(pBufferOut, 1, bytesToRead, (FILE*)pUserData);
+}
+MA_PRIVATE size_t ma_dr_wav__on_write_stdio(void* pUserData, const void* pData, size_t bytesToWrite)
+{
+    return fwrite(pData, 1, bytesToWrite, (FILE*)pUserData);
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__on_seek_stdio(void* pUserData, int offset, ma_dr_wav_seek_origin origin)
+{
+    return fseek((FILE*)pUserData, offset, (origin == ma_dr_wav_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0;
+}
+MA_API ma_bool32 ma_dr_wav_init_file(ma_dr_wav* pWav, const char* filename, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_ex(pWav, filename, NULL, NULL, 0, pAllocationCallbacks);
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_init_file__internal_FILE(ma_dr_wav* pWav, FILE* pFile, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 result;
+    result = ma_dr_wav_preinit(pWav, ma_dr_wav__on_read_stdio, ma_dr_wav__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    result = ma_dr_wav_init__internal(pWav, onChunk, pChunkUserData, flags);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_init_file_ex(ma_dr_wav* pWav, const char* filename, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_fopen(&pFile, filename, "rb") != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks);
+}
+#ifndef MA_DR_WAV_NO_WCHAR
+MA_API ma_bool32 ma_dr_wav_init_file_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_ex_w(pWav, filename, NULL, NULL, 0, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_file_ex_w(ma_dr_wav* pWav, const wchar_t* filename, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_wfopen(&pFile, filename, L"rb", pAllocationCallbacks) != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file__internal_FILE(pWav, pFile, onChunk, pChunkUserData, flags, pAllocationCallbacks);
+}
+#endif
+MA_API ma_bool32 ma_dr_wav_init_file_with_metadata(ma_dr_wav* pWav, const char* filename, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_fopen(&pFile, filename, "rb") != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file__internal_FILE(pWav, pFile, NULL, NULL, flags | MA_DR_WAV_WITH_METADATA, pAllocationCallbacks);
+}
+#ifndef MA_DR_WAV_NO_WCHAR
+MA_API ma_bool32 ma_dr_wav_init_file_with_metadata_w(ma_dr_wav* pWav, const wchar_t* filename, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_wfopen(&pFile, filename, L"rb", pAllocationCallbacks) != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file__internal_FILE(pWav, pFile, NULL, NULL, flags | MA_DR_WAV_WITH_METADATA, pAllocationCallbacks);
+}
+#endif
+MA_PRIVATE ma_bool32 ma_dr_wav_init_file_write__internal_FILE(ma_dr_wav* pWav, FILE* pFile, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_bool32 isSequential, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 result;
+    result = ma_dr_wav_preinit_write(pWav, pFormat, isSequential, ma_dr_wav__on_write_stdio, ma_dr_wav__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    result = ma_dr_wav_init_write__internal(pWav, pFormat, totalSampleCount);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    return MA_TRUE;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_init_file_write__internal(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_bool32 isSequential, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_fopen(&pFile, filename, "wb") != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks);
+}
+#ifndef MA_DR_WAV_NO_WCHAR
+MA_PRIVATE ma_bool32 ma_dr_wav_init_file_write_w__internal(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_bool32 isSequential, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    FILE* pFile;
+    if (ma_wfopen(&pFile, filename, L"wb", pAllocationCallbacks) != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file_write__internal_FILE(pWav, pFile, pFormat, totalSampleCount, isSequential, pAllocationCallbacks);
+}
+#endif
+MA_API ma_bool32 ma_dr_wav_init_file_write(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_write__internal(pWav, filename, pFormat, 0, MA_FALSE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_write__internal(pWav, filename, pFormat, totalSampleCount, MA_TRUE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_pcm_frames(ma_dr_wav* pWav, const char* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFormat == NULL) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file_write_sequential(pWav, filename, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
+}
+#ifndef MA_DR_WAV_NO_WCHAR
+MA_API ma_bool32 ma_dr_wav_init_file_write_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_write_w__internal(pWav, filename, pFormat, 0, MA_FALSE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_file_write_w__internal(pWav, filename, pFormat, totalSampleCount, MA_TRUE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_file_write_sequential_pcm_frames_w(ma_dr_wav* pWav, const wchar_t* filename, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFormat == NULL) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_file_write_sequential_w(pWav, filename, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
+}
+#endif
+#endif
+MA_PRIVATE size_t ma_dr_wav__on_read_memory(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    ma_dr_wav* pWav = (ma_dr_wav*)pUserData;
+    size_t bytesRemaining;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    MA_DR_WAV_ASSERT(pWav->memoryStream.dataSize >= pWav->memoryStream.currentReadPos);
+    bytesRemaining = pWav->memoryStream.dataSize - pWav->memoryStream.currentReadPos;
+    if (bytesToRead > bytesRemaining) {
+        bytesToRead = bytesRemaining;
+    }
+    if (bytesToRead > 0) {
+        MA_DR_WAV_COPY_MEMORY(pBufferOut, pWav->memoryStream.data + pWav->memoryStream.currentReadPos, bytesToRead);
+        pWav->memoryStream.currentReadPos += bytesToRead;
+    }
+    return bytesToRead;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__on_seek_memory(void* pUserData, int offset, ma_dr_wav_seek_origin origin)
+{
+    ma_dr_wav* pWav = (ma_dr_wav*)pUserData;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    if (origin == ma_dr_wav_seek_origin_current) {
+        if (offset > 0) {
+            if (pWav->memoryStream.currentReadPos + offset > pWav->memoryStream.dataSize) {
+                return MA_FALSE;
+            }
+        } else {
+            if (pWav->memoryStream.currentReadPos < (size_t)-offset) {
+                return MA_FALSE;
+            }
+        }
+        pWav->memoryStream.currentReadPos += offset;
+    } else {
+        if ((ma_uint32)offset <= pWav->memoryStream.dataSize) {
+            pWav->memoryStream.currentReadPos = offset;
+        } else {
+            return MA_FALSE;
+        }
+    }
+    return MA_TRUE;
+}
+MA_PRIVATE size_t ma_dr_wav__on_write_memory(void* pUserData, const void* pDataIn, size_t bytesToWrite)
+{
+    ma_dr_wav* pWav = (ma_dr_wav*)pUserData;
+    size_t bytesRemaining;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    MA_DR_WAV_ASSERT(pWav->memoryStreamWrite.dataCapacity >= pWav->memoryStreamWrite.currentWritePos);
+    bytesRemaining = pWav->memoryStreamWrite.dataCapacity - pWav->memoryStreamWrite.currentWritePos;
+    if (bytesRemaining < bytesToWrite) {
+        void* pNewData;
+        size_t newDataCapacity = (pWav->memoryStreamWrite.dataCapacity == 0) ? 256 : pWav->memoryStreamWrite.dataCapacity * 2;
+        if ((newDataCapacity - pWav->memoryStreamWrite.currentWritePos) < bytesToWrite) {
+            newDataCapacity = pWav->memoryStreamWrite.currentWritePos + bytesToWrite;
+        }
+        pNewData = ma_dr_wav__realloc_from_callbacks(*pWav->memoryStreamWrite.ppData, newDataCapacity, pWav->memoryStreamWrite.dataCapacity, &pWav->allocationCallbacks);
+        if (pNewData == NULL) {
+            return 0;
+        }
+        *pWav->memoryStreamWrite.ppData = pNewData;
+        pWav->memoryStreamWrite.dataCapacity = newDataCapacity;
+    }
+    MA_DR_WAV_COPY_MEMORY(((ma_uint8*)(*pWav->memoryStreamWrite.ppData)) + pWav->memoryStreamWrite.currentWritePos, pDataIn, bytesToWrite);
+    pWav->memoryStreamWrite.currentWritePos += bytesToWrite;
+    if (pWav->memoryStreamWrite.dataSize < pWav->memoryStreamWrite.currentWritePos) {
+        pWav->memoryStreamWrite.dataSize = pWav->memoryStreamWrite.currentWritePos;
+    }
+    *pWav->memoryStreamWrite.pDataSize = pWav->memoryStreamWrite.dataSize;
+    return bytesToWrite;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav__on_seek_memory_write(void* pUserData, int offset, ma_dr_wav_seek_origin origin)
+{
+    ma_dr_wav* pWav = (ma_dr_wav*)pUserData;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    if (origin == ma_dr_wav_seek_origin_current) {
+        if (offset > 0) {
+            if (pWav->memoryStreamWrite.currentWritePos + offset > pWav->memoryStreamWrite.dataSize) {
+                offset = (int)(pWav->memoryStreamWrite.dataSize - pWav->memoryStreamWrite.currentWritePos);
+            }
+        } else {
+            if (pWav->memoryStreamWrite.currentWritePos < (size_t)-offset) {
+                offset = -(int)pWav->memoryStreamWrite.currentWritePos;
+            }
+        }
+        pWav->memoryStreamWrite.currentWritePos += offset;
+    } else {
+        if ((ma_uint32)offset <= pWav->memoryStreamWrite.dataSize) {
+            pWav->memoryStreamWrite.currentWritePos = offset;
+        } else {
+            pWav->memoryStreamWrite.currentWritePos = pWav->memoryStreamWrite.dataSize;
+        }
+    }
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_init_memory(ma_dr_wav* pWav, const void* data, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_memory_ex(pWav, data, dataSize, NULL, NULL, 0, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_memory_ex(ma_dr_wav* pWav, const void* data, size_t dataSize, ma_dr_wav_chunk_proc onChunk, void* pChunkUserData, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (data == NULL || dataSize == 0) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_wav_preinit(pWav, ma_dr_wav__on_read_memory, ma_dr_wav__on_seek_memory, pWav, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    pWav->memoryStream.data = (const ma_uint8*)data;
+    pWav->memoryStream.dataSize = dataSize;
+    pWav->memoryStream.currentReadPos = 0;
+    return ma_dr_wav_init__internal(pWav, onChunk, pChunkUserData, flags);
+}
+MA_API ma_bool32 ma_dr_wav_init_memory_with_metadata(ma_dr_wav* pWav, const void* data, size_t dataSize, ma_uint32 flags, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (data == NULL || dataSize == 0) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_wav_preinit(pWav, ma_dr_wav__on_read_memory, ma_dr_wav__on_seek_memory, pWav, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    pWav->memoryStream.data = (const ma_uint8*)data;
+    pWav->memoryStream.dataSize = dataSize;
+    pWav->memoryStream.currentReadPos = 0;
+    return ma_dr_wav_init__internal(pWav, NULL, NULL, flags | MA_DR_WAV_WITH_METADATA);
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_init_memory_write__internal(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, ma_bool32 isSequential, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (ppData == NULL || pDataSize == NULL) {
+        return MA_FALSE;
+    }
+    *ppData = NULL;
+    *pDataSize = 0;
+    if (!ma_dr_wav_preinit_write(pWav, pFormat, isSequential, ma_dr_wav__on_write_memory, ma_dr_wav__on_seek_memory_write, pWav, pAllocationCallbacks)) {
+        return MA_FALSE;
+    }
+    pWav->memoryStreamWrite.ppData = ppData;
+    pWav->memoryStreamWrite.pDataSize = pDataSize;
+    pWav->memoryStreamWrite.dataSize = 0;
+    pWav->memoryStreamWrite.dataCapacity = 0;
+    pWav->memoryStreamWrite.currentWritePos = 0;
+    return ma_dr_wav_init_write__internal(pWav, pFormat, totalSampleCount);
+}
+MA_API ma_bool32 ma_dr_wav_init_memory_write(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, 0, MA_FALSE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_memory_write_sequential(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, ma_uint64 totalSampleCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_wav_init_memory_write__internal(pWav, ppData, pDataSize, pFormat, totalSampleCount, MA_TRUE, pAllocationCallbacks);
+}
+MA_API ma_bool32 ma_dr_wav_init_memory_write_sequential_pcm_frames(ma_dr_wav* pWav, void** ppData, size_t* pDataSize, const ma_dr_wav_data_format* pFormat, ma_uint64 totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pFormat == NULL) {
+        return MA_FALSE;
+    }
+    return ma_dr_wav_init_memory_write_sequential(pWav, ppData, pDataSize, pFormat, totalPCMFrameCount*pFormat->channels, pAllocationCallbacks);
+}
+MA_API ma_result ma_dr_wav_uninit(ma_dr_wav* pWav)
+{
+    ma_result result = MA_SUCCESS;
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+    if (pWav->onWrite != NULL) {
+        ma_uint32 paddingSize = 0;
+        if (pWav->container == ma_dr_wav_container_riff || pWav->container == ma_dr_wav_container_rf64) {
+            paddingSize = ma_dr_wav__chunk_padding_size_riff(pWav->dataChunkDataSize);
+        } else {
+            paddingSize = ma_dr_wav__chunk_padding_size_w64(pWav->dataChunkDataSize);
+        }
+        if (paddingSize > 0) {
+            ma_uint64 paddingData = 0;
+            ma_dr_wav__write(pWav, &paddingData, paddingSize);
+        }
+        if (pWav->onSeek && !pWav->isSequentialWrite) {
+            if (pWav->container == ma_dr_wav_container_riff) {
+                if (pWav->onSeek(pWav->pUserData, 4, ma_dr_wav_seek_origin_start)) {
+                    ma_uint32 riffChunkSize = ma_dr_wav__riff_chunk_size_riff(pWav->dataChunkDataSize, pWav->pMetadata, pWav->metadataCount);
+                    ma_dr_wav__write_u32ne_to_le(pWav, riffChunkSize);
+                }
+                if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos - 4, ma_dr_wav_seek_origin_start)) {
+                    ma_uint32 dataChunkSize = ma_dr_wav__data_chunk_size_riff(pWav->dataChunkDataSize);
+                    ma_dr_wav__write_u32ne_to_le(pWav, dataChunkSize);
+                }
+            } else if (pWav->container == ma_dr_wav_container_w64) {
+                if (pWav->onSeek(pWav->pUserData, 16, ma_dr_wav_seek_origin_start)) {
+                    ma_uint64 riffChunkSize = ma_dr_wav__riff_chunk_size_w64(pWav->dataChunkDataSize);
+                    ma_dr_wav__write_u64ne_to_le(pWav, riffChunkSize);
+                }
+                if (pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos - 8, ma_dr_wav_seek_origin_start)) {
+                    ma_uint64 dataChunkSize = ma_dr_wav__data_chunk_size_w64(pWav->dataChunkDataSize);
+                    ma_dr_wav__write_u64ne_to_le(pWav, dataChunkSize);
+                }
+            } else if (pWav->container == ma_dr_wav_container_rf64) {
+                int ds64BodyPos = 12 + 8;
+                if (pWav->onSeek(pWav->pUserData, ds64BodyPos + 0, ma_dr_wav_seek_origin_start)) {
+                    ma_uint64 riffChunkSize = ma_dr_wav__riff_chunk_size_rf64(pWav->dataChunkDataSize, pWav->pMetadata, pWav->metadataCount);
+                    ma_dr_wav__write_u64ne_to_le(pWav, riffChunkSize);
+                }
+                if (pWav->onSeek(pWav->pUserData, ds64BodyPos + 8, ma_dr_wav_seek_origin_start)) {
+                    ma_uint64 dataChunkSize = ma_dr_wav__data_chunk_size_rf64(pWav->dataChunkDataSize);
+                    ma_dr_wav__write_u64ne_to_le(pWav, dataChunkSize);
+                }
+            }
+        }
+        if (pWav->isSequentialWrite) {
+            if (pWav->dataChunkDataSize != pWav->dataChunkDataSizeTargetWrite) {
+                result = MA_INVALID_FILE;
+            }
+        }
+    } else {
+        ma_dr_wav_free(pWav->pMetadata, &pWav->allocationCallbacks);
+    }
+#ifndef MA_DR_WAV_NO_STDIO
+    if (pWav->onRead == ma_dr_wav__on_read_stdio || pWav->onWrite == ma_dr_wav__on_write_stdio) {
+        fclose((FILE*)pWav->pUserData);
+    }
+#endif
+    return result;
+}
+MA_API size_t ma_dr_wav_read_raw(ma_dr_wav* pWav, size_t bytesToRead, void* pBufferOut)
+{
+    size_t bytesRead;
+    ma_uint32 bytesPerFrame;
+    if (pWav == NULL || bytesToRead == 0) {
+        return 0;
+    }
+    if (bytesToRead > pWav->bytesRemaining) {
+        bytesToRead = (size_t)pWav->bytesRemaining;
+    }
+    if (bytesToRead == 0) {
+        return 0;
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    if (pBufferOut != NULL) {
+        bytesRead = pWav->onRead(pWav->pUserData, pBufferOut, bytesToRead);
+    } else {
+        bytesRead = 0;
+        while (bytesRead < bytesToRead) {
+            size_t bytesToSeek = (bytesToRead - bytesRead);
+            if (bytesToSeek > 0x7FFFFFFF) {
+                bytesToSeek = 0x7FFFFFFF;
+            }
+            if (pWav->onSeek(pWav->pUserData, (int)bytesToSeek, ma_dr_wav_seek_origin_current) == MA_FALSE) {
+                break;
+            }
+            bytesRead += bytesToSeek;
+        }
+        while (bytesRead < bytesToRead) {
+            ma_uint8 buffer[4096];
+            size_t bytesSeeked;
+            size_t bytesToSeek = (bytesToRead - bytesRead);
+            if (bytesToSeek > sizeof(buffer)) {
+                bytesToSeek = sizeof(buffer);
+            }
+            bytesSeeked = pWav->onRead(pWav->pUserData, buffer, bytesToSeek);
+            bytesRead += bytesSeeked;
+            if (bytesSeeked < bytesToSeek) {
+                break;
+            }
+        }
+    }
+    pWav->readCursorInPCMFrames += bytesRead / bytesPerFrame;
+    pWav->bytesRemaining -= bytesRead;
+    return bytesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_le(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut)
+{
+    ma_uint32 bytesPerFrame;
+    ma_uint64 bytesToRead;
+    ma_uint64 framesRemainingInFile;
+    if (pWav == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (ma_dr_wav__is_compressed_format_tag(pWav->translatedFormatTag)) {
+        return 0;
+    }
+    framesRemainingInFile = pWav->totalPCMFrameCount - pWav->readCursorInPCMFrames;
+    if (framesToRead > framesRemainingInFile) {
+        framesToRead = framesRemainingInFile;
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesToRead = framesToRead * bytesPerFrame;
+    if (bytesToRead > MA_SIZE_MAX) {
+        bytesToRead = (MA_SIZE_MAX / bytesPerFrame) * bytesPerFrame;
+    }
+    if (bytesToRead == 0) {
+        return 0;
+    }
+    return ma_dr_wav_read_raw(pWav, (size_t)bytesToRead, pBufferOut) / bytesPerFrame;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_be(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_le(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL) {
+        ma_uint32 bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+        if (bytesPerFrame == 0) {
+            return 0;
+        }
+        ma_dr_wav__bswap_samples(pBufferOut, framesRead*pWav->channels, bytesPerFrame/pWav->channels);
+    }
+    return framesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames(ma_dr_wav* pWav, ma_uint64 framesToRead, void* pBufferOut)
+{
+    ma_uint64 framesRead = 0;
+    if (ma_dr_wav_is_container_be(pWav->container)) {
+        if (pWav->container != ma_dr_wav_container_aiff || pWav->aiff.isLE == MA_FALSE) {
+            if (ma_dr_wav__is_little_endian()) {
+                framesRead = ma_dr_wav_read_pcm_frames_be(pWav, framesToRead, pBufferOut);
+            } else {
+                framesRead = ma_dr_wav_read_pcm_frames_le(pWav, framesToRead, pBufferOut);
+            }
+            goto post_process;
+        }
+    }
+    if (ma_dr_wav__is_little_endian()) {
+        framesRead = ma_dr_wav_read_pcm_frames_le(pWav, framesToRead, pBufferOut);
+    } else {
+        framesRead = ma_dr_wav_read_pcm_frames_be(pWav, framesToRead, pBufferOut);
+    }
+    post_process:
+    {
+        if (pWav->container == ma_dr_wav_container_aiff && pWav->bitsPerSample == 8 && pWav->aiff.isUnsigned == MA_FALSE) {
+            if (pBufferOut != NULL) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < framesRead * pWav->channels; iSample += 1) {
+                    ((ma_uint8*)pBufferOut)[iSample] += 128;
+                }
+            }
+        }
+    }
+    return framesRead;
+}
+MA_PRIVATE ma_bool32 ma_dr_wav_seek_to_first_pcm_frame(ma_dr_wav* pWav)
+{
+    if (pWav->onWrite != NULL) {
+        return MA_FALSE;
+    }
+    if (!pWav->onSeek(pWav->pUserData, (int)pWav->dataChunkDataPos, ma_dr_wav_seek_origin_start)) {
+        return MA_FALSE;
+    }
+    if (ma_dr_wav__is_compressed_format_tag(pWav->translatedFormatTag)) {
+        if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+            MA_DR_WAV_ZERO_OBJECT(&pWav->msadpcm);
+        } else if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+            MA_DR_WAV_ZERO_OBJECT(&pWav->ima);
+        } else {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+        }
+    }
+    pWav->readCursorInPCMFrames = 0;
+    pWav->bytesRemaining = pWav->dataChunkDataSize;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_seek_to_pcm_frame(ma_dr_wav* pWav, ma_uint64 targetFrameIndex)
+{
+    if (pWav == NULL || pWav->onSeek == NULL) {
+        return MA_FALSE;
+    }
+    if (pWav->onWrite != NULL) {
+        return MA_FALSE;
+    }
+    if (pWav->totalPCMFrameCount == 0) {
+        return MA_TRUE;
+    }
+    if (targetFrameIndex > pWav->totalPCMFrameCount) {
+        targetFrameIndex = pWav->totalPCMFrameCount;
+    }
+    if (ma_dr_wav__is_compressed_format_tag(pWav->translatedFormatTag)) {
+        if (targetFrameIndex < pWav->readCursorInPCMFrames) {
+            if (!ma_dr_wav_seek_to_first_pcm_frame(pWav)) {
+                return MA_FALSE;
+            }
+        }
+        if (targetFrameIndex > pWav->readCursorInPCMFrames) {
+            ma_uint64 offsetInFrames = targetFrameIndex - pWav->readCursorInPCMFrames;
+            ma_int16 devnull[2048];
+            while (offsetInFrames > 0) {
+                ma_uint64 framesRead = 0;
+                ma_uint64 framesToRead = offsetInFrames;
+                if (framesToRead > ma_dr_wav_countof(devnull)/pWav->channels) {
+                    framesToRead = ma_dr_wav_countof(devnull)/pWav->channels;
+                }
+                if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+                    framesRead = ma_dr_wav_read_pcm_frames_s16__msadpcm(pWav, framesToRead, devnull);
+                } else if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+                    framesRead = ma_dr_wav_read_pcm_frames_s16__ima(pWav, framesToRead, devnull);
+                } else {
+                    MA_DR_WAV_ASSERT(MA_FALSE);
+                }
+                if (framesRead != framesToRead) {
+                    return MA_FALSE;
+                }
+                offsetInFrames -= framesRead;
+            }
+        }
+    } else {
+        ma_uint64 totalSizeInBytes;
+        ma_uint64 currentBytePos;
+        ma_uint64 targetBytePos;
+        ma_uint64 offset;
+        ma_uint32 bytesPerFrame;
+        bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+        if (bytesPerFrame == 0) {
+            return MA_FALSE;
+        }
+        totalSizeInBytes = pWav->totalPCMFrameCount * bytesPerFrame;
+        currentBytePos = totalSizeInBytes - pWav->bytesRemaining;
+        targetBytePos  = targetFrameIndex * bytesPerFrame;
+        if (currentBytePos < targetBytePos) {
+            offset = (targetBytePos - currentBytePos);
+        } else {
+            if (!ma_dr_wav_seek_to_first_pcm_frame(pWav)) {
+                return MA_FALSE;
+            }
+            offset = targetBytePos;
+        }
+        while (offset > 0) {
+            int offset32 = ((offset > INT_MAX) ? INT_MAX : (int)offset);
+            if (!pWav->onSeek(pWav->pUserData, offset32, ma_dr_wav_seek_origin_current)) {
+                return MA_FALSE;
+            }
+            pWav->readCursorInPCMFrames += offset32 / bytesPerFrame;
+            pWav->bytesRemaining        -= offset32;
+            offset                      -= offset32;
+        }
+    }
+    return MA_TRUE;
+}
+MA_API ma_result ma_dr_wav_get_cursor_in_pcm_frames(ma_dr_wav* pWav, ma_uint64* pCursor)
+{
+    if (pCursor == NULL) {
+        return MA_INVALID_ARGS;
+    }
+    *pCursor = 0;
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+    *pCursor = pWav->readCursorInPCMFrames;
+    return MA_SUCCESS;
+}
+MA_API ma_result ma_dr_wav_get_length_in_pcm_frames(ma_dr_wav* pWav, ma_uint64* pLength)
+{
+    if (pLength == NULL) {
+        return MA_INVALID_ARGS;
+    }
+    *pLength = 0;
+    if (pWav == NULL) {
+        return MA_INVALID_ARGS;
+    }
+    *pLength = pWav->totalPCMFrameCount;
+    return MA_SUCCESS;
+}
+MA_API size_t ma_dr_wav_write_raw(ma_dr_wav* pWav, size_t bytesToWrite, const void* pData)
+{
+    size_t bytesWritten;
+    if (pWav == NULL || bytesToWrite == 0 || pData == NULL) {
+        return 0;
+    }
+    bytesWritten = pWav->onWrite(pWav->pUserData, pData, bytesToWrite);
+    pWav->dataChunkDataSize += bytesWritten;
+    return bytesWritten;
+}
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames_le(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData)
+{
+    ma_uint64 bytesToWrite;
+    ma_uint64 bytesWritten;
+    const ma_uint8* pRunningData;
+    if (pWav == NULL || framesToWrite == 0 || pData == NULL) {
+        return 0;
+    }
+    bytesToWrite = ((framesToWrite * pWav->channels * pWav->bitsPerSample) / 8);
+    if (bytesToWrite > MA_SIZE_MAX) {
+        return 0;
+    }
+    bytesWritten = 0;
+    pRunningData = (const ma_uint8*)pData;
+    while (bytesToWrite > 0) {
+        size_t bytesJustWritten;
+        ma_uint64 bytesToWriteThisIteration;
+        bytesToWriteThisIteration = bytesToWrite;
+        MA_DR_WAV_ASSERT(bytesToWriteThisIteration <= MA_SIZE_MAX);
+        bytesJustWritten = ma_dr_wav_write_raw(pWav, (size_t)bytesToWriteThisIteration, pRunningData);
+        if (bytesJustWritten == 0) {
+            break;
+        }
+        bytesToWrite -= bytesJustWritten;
+        bytesWritten += bytesJustWritten;
+        pRunningData += bytesJustWritten;
+    }
+    return (bytesWritten * 8) / pWav->bitsPerSample / pWav->channels;
+}
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames_be(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData)
+{
+    ma_uint64 bytesToWrite;
+    ma_uint64 bytesWritten;
+    ma_uint32 bytesPerSample;
+    const ma_uint8* pRunningData;
+    if (pWav == NULL || framesToWrite == 0 || pData == NULL) {
+        return 0;
+    }
+    bytesToWrite = ((framesToWrite * pWav->channels * pWav->bitsPerSample) / 8);
+    if (bytesToWrite > MA_SIZE_MAX) {
+        return 0;
+    }
+    bytesWritten = 0;
+    pRunningData = (const ma_uint8*)pData;
+    bytesPerSample = ma_dr_wav_get_bytes_per_pcm_frame(pWav) / pWav->channels;
+    if (bytesPerSample == 0) {
+        return 0;
+    }
+    while (bytesToWrite > 0) {
+        ma_uint8 temp[4096];
+        ma_uint32 sampleCount;
+        size_t bytesJustWritten;
+        ma_uint64 bytesToWriteThisIteration;
+        bytesToWriteThisIteration = bytesToWrite;
+        MA_DR_WAV_ASSERT(bytesToWriteThisIteration <= MA_SIZE_MAX);
+        sampleCount = sizeof(temp)/bytesPerSample;
+        if (bytesToWriteThisIteration > ((ma_uint64)sampleCount)*bytesPerSample) {
+            bytesToWriteThisIteration = ((ma_uint64)sampleCount)*bytesPerSample;
+        }
+        MA_DR_WAV_COPY_MEMORY(temp, pRunningData, (size_t)bytesToWriteThisIteration);
+        ma_dr_wav__bswap_samples(temp, sampleCount, bytesPerSample);
+        bytesJustWritten = ma_dr_wav_write_raw(pWav, (size_t)bytesToWriteThisIteration, temp);
+        if (bytesJustWritten == 0) {
+            break;
+        }
+        bytesToWrite -= bytesJustWritten;
+        bytesWritten += bytesJustWritten;
+        pRunningData += bytesJustWritten;
+    }
+    return (bytesWritten * 8) / pWav->bitsPerSample / pWav->channels;
+}
+MA_API ma_uint64 ma_dr_wav_write_pcm_frames(ma_dr_wav* pWav, ma_uint64 framesToWrite, const void* pData)
+{
+    if (ma_dr_wav__is_little_endian()) {
+        return ma_dr_wav_write_pcm_frames_le(pWav, framesToWrite, pData);
+    } else {
+        return ma_dr_wav_write_pcm_frames_be(pWav, framesToWrite, pData);
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__msadpcm(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead = 0;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    MA_DR_WAV_ASSERT(framesToRead > 0);
+    while (pWav->readCursorInPCMFrames < pWav->totalPCMFrameCount) {
+        MA_DR_WAV_ASSERT(framesToRead > 0);
+        if (pWav->msadpcm.cachedFrameCount == 0 && pWav->msadpcm.bytesRemainingInBlock == 0) {
+            if (pWav->channels == 1) {
+                ma_uint8 header[7];
+                if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
+                    return totalFramesRead;
+                }
+                pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
+                pWav->msadpcm.predictor[0]     = header[0];
+                pWav->msadpcm.delta[0]         = ma_dr_wav_bytes_to_s16(header + 1);
+                pWav->msadpcm.prevFrames[0][1] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 3);
+                pWav->msadpcm.prevFrames[0][0] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 5);
+                pWav->msadpcm.cachedFrames[2]  = pWav->msadpcm.prevFrames[0][0];
+                pWav->msadpcm.cachedFrames[3]  = pWav->msadpcm.prevFrames[0][1];
+                pWav->msadpcm.cachedFrameCount = 2;
+            } else {
+                ma_uint8 header[14];
+                if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
+                    return totalFramesRead;
+                }
+                pWav->msadpcm.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
+                pWav->msadpcm.predictor[0] = header[0];
+                pWav->msadpcm.predictor[1] = header[1];
+                pWav->msadpcm.delta[0] = ma_dr_wav_bytes_to_s16(header + 2);
+                pWav->msadpcm.delta[1] = ma_dr_wav_bytes_to_s16(header + 4);
+                pWav->msadpcm.prevFrames[0][1] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 6);
+                pWav->msadpcm.prevFrames[1][1] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 8);
+                pWav->msadpcm.prevFrames[0][0] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 10);
+                pWav->msadpcm.prevFrames[1][0] = (ma_int32)ma_dr_wav_bytes_to_s16(header + 12);
+                pWav->msadpcm.cachedFrames[0] = pWav->msadpcm.prevFrames[0][0];
+                pWav->msadpcm.cachedFrames[1] = pWav->msadpcm.prevFrames[1][0];
+                pWav->msadpcm.cachedFrames[2] = pWav->msadpcm.prevFrames[0][1];
+                pWav->msadpcm.cachedFrames[3] = pWav->msadpcm.prevFrames[1][1];
+                pWav->msadpcm.cachedFrameCount = 2;
+            }
+        }
+        while (framesToRead > 0 && pWav->msadpcm.cachedFrameCount > 0 && pWav->readCursorInPCMFrames < pWav->totalPCMFrameCount) {
+            if (pBufferOut != NULL) {
+                ma_uint32 iSample = 0;
+                for (iSample = 0; iSample < pWav->channels; iSample += 1) {
+                    pBufferOut[iSample] = (ma_int16)pWav->msadpcm.cachedFrames[(ma_dr_wav_countof(pWav->msadpcm.cachedFrames) - (pWav->msadpcm.cachedFrameCount*pWav->channels)) + iSample];
+                }
+                pBufferOut += pWav->channels;
+            }
+            framesToRead    -= 1;
+            totalFramesRead += 1;
+            pWav->readCursorInPCMFrames += 1;
+            pWav->msadpcm.cachedFrameCount -= 1;
+        }
+        if (framesToRead == 0) {
+            break;
+        }
+        if (pWav->msadpcm.cachedFrameCount == 0) {
+            if (pWav->msadpcm.bytesRemainingInBlock == 0) {
+                continue;
+            } else {
+                static ma_int32 adaptationTable[] = {
+                    230, 230, 230, 230, 307, 409, 512, 614,
+                    768, 614, 512, 409, 307, 230, 230, 230
+                };
+                static ma_int32 coeff1Table[] = { 256, 512, 0, 192, 240, 460,  392 };
+                static ma_int32 coeff2Table[] = { 0,  -256, 0, 64,  0,  -208, -232 };
+                ma_uint8 nibbles;
+                ma_int32 nibble0;
+                ma_int32 nibble1;
+                if (pWav->onRead(pWav->pUserData, &nibbles, 1) != 1) {
+                    return totalFramesRead;
+                }
+                pWav->msadpcm.bytesRemainingInBlock -= 1;
+                nibble0 = ((nibbles & 0xF0) >> 4); if ((nibbles & 0x80)) { nibble0 |= 0xFFFFFFF0UL; }
+                nibble1 = ((nibbles & 0x0F) >> 0); if ((nibbles & 0x08)) { nibble1 |= 0xFFFFFFF0UL; }
+                if (pWav->channels == 1) {
+                    ma_int32 newSample0;
+                    ma_int32 newSample1;
+                    newSample0  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
+                    newSample0 += nibble0 * pWav->msadpcm.delta[0];
+                    newSample0  = ma_dr_wav_clamp(newSample0, -32768, 32767);
+                    pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8;
+                    if (pWav->msadpcm.delta[0] < 16) {
+                        pWav->msadpcm.delta[0] = 16;
+                    }
+                    pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
+                    pWav->msadpcm.prevFrames[0][1] = newSample0;
+                    newSample1  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
+                    newSample1 += nibble1 * pWav->msadpcm.delta[0];
+                    newSample1  = ma_dr_wav_clamp(newSample1, -32768, 32767);
+                    pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[0]) >> 8;
+                    if (pWav->msadpcm.delta[0] < 16) {
+                        pWav->msadpcm.delta[0] = 16;
+                    }
+                    pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
+                    pWav->msadpcm.prevFrames[0][1] = newSample1;
+                    pWav->msadpcm.cachedFrames[2] = newSample0;
+                    pWav->msadpcm.cachedFrames[3] = newSample1;
+                    pWav->msadpcm.cachedFrameCount = 2;
+                } else {
+                    ma_int32 newSample0;
+                    ma_int32 newSample1;
+                    newSample0  = ((pWav->msadpcm.prevFrames[0][1] * coeff1Table[pWav->msadpcm.predictor[0]]) + (pWav->msadpcm.prevFrames[0][0] * coeff2Table[pWav->msadpcm.predictor[0]])) >> 8;
+                    newSample0 += nibble0 * pWav->msadpcm.delta[0];
+                    newSample0  = ma_dr_wav_clamp(newSample0, -32768, 32767);
+                    pWav->msadpcm.delta[0] = (adaptationTable[((nibbles & 0xF0) >> 4)] * pWav->msadpcm.delta[0]) >> 8;
+                    if (pWav->msadpcm.delta[0] < 16) {
+                        pWav->msadpcm.delta[0] = 16;
+                    }
+                    pWav->msadpcm.prevFrames[0][0] = pWav->msadpcm.prevFrames[0][1];
+                    pWav->msadpcm.prevFrames[0][1] = newSample0;
+                    newSample1  = ((pWav->msadpcm.prevFrames[1][1] * coeff1Table[pWav->msadpcm.predictor[1]]) + (pWav->msadpcm.prevFrames[1][0] * coeff2Table[pWav->msadpcm.predictor[1]])) >> 8;
+                    newSample1 += nibble1 * pWav->msadpcm.delta[1];
+                    newSample1  = ma_dr_wav_clamp(newSample1, -32768, 32767);
+                    pWav->msadpcm.delta[1] = (adaptationTable[((nibbles & 0x0F) >> 0)] * pWav->msadpcm.delta[1]) >> 8;
+                    if (pWav->msadpcm.delta[1] < 16) {
+                        pWav->msadpcm.delta[1] = 16;
+                    }
+                    pWav->msadpcm.prevFrames[1][0] = pWav->msadpcm.prevFrames[1][1];
+                    pWav->msadpcm.prevFrames[1][1] = newSample1;
+                    pWav->msadpcm.cachedFrames[2] = newSample0;
+                    pWav->msadpcm.cachedFrames[3] = newSample1;
+                    pWav->msadpcm.cachedFrameCount = 1;
+                }
+            }
+        }
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__ima(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead = 0;
+    ma_uint32 iChannel;
+    static ma_int32 indexTable[16] = {
+        -1, -1, -1, -1, 2, 4, 6, 8,
+        -1, -1, -1, -1, 2, 4, 6, 8
+    };
+    static ma_int32 stepTable[89] = {
+        7,     8,     9,     10,    11,    12,    13,    14,    16,    17,
+        19,    21,    23,    25,    28,    31,    34,    37,    41,    45,
+        50,    55,    60,    66,    73,    80,    88,    97,    107,   118,
+        130,   143,   157,   173,   190,   209,   230,   253,   279,   307,
+        337,   371,   408,   449,   494,   544,   598,   658,   724,   796,
+        876,   963,   1060,  1166,  1282,  1411,  1552,  1707,  1878,  2066,
+        2272,  2499,  2749,  3024,  3327,  3660,  4026,  4428,  4871,  5358,
+        5894,  6484,  7132,  7845,  8630,  9493,  10442, 11487, 12635, 13899,
+        15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
+    };
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    MA_DR_WAV_ASSERT(framesToRead > 0);
+    while (pWav->readCursorInPCMFrames < pWav->totalPCMFrameCount) {
+        MA_DR_WAV_ASSERT(framesToRead > 0);
+        if (pWav->ima.cachedFrameCount == 0 && pWav->ima.bytesRemainingInBlock == 0) {
+            if (pWav->channels == 1) {
+                ma_uint8 header[4];
+                if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
+                    return totalFramesRead;
+                }
+                pWav->ima.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
+                if (header[2] >= ma_dr_wav_countof(stepTable)) {
+                    pWav->onSeek(pWav->pUserData, pWav->ima.bytesRemainingInBlock, ma_dr_wav_seek_origin_current);
+                    pWav->ima.bytesRemainingInBlock = 0;
+                    return totalFramesRead;
+                }
+                pWav->ima.predictor[0] = (ma_int16)ma_dr_wav_bytes_to_u16(header + 0);
+                pWav->ima.stepIndex[0] = ma_dr_wav_clamp(header[2], 0, (ma_int32)ma_dr_wav_countof(stepTable)-1);
+                pWav->ima.cachedFrames[ma_dr_wav_countof(pWav->ima.cachedFrames) - 1] = pWav->ima.predictor[0];
+                pWav->ima.cachedFrameCount = 1;
+            } else {
+                ma_uint8 header[8];
+                if (pWav->onRead(pWav->pUserData, header, sizeof(header)) != sizeof(header)) {
+                    return totalFramesRead;
+                }
+                pWav->ima.bytesRemainingInBlock = pWav->fmt.blockAlign - sizeof(header);
+                if (header[2] >= ma_dr_wav_countof(stepTable) || header[6] >= ma_dr_wav_countof(stepTable)) {
+                    pWav->onSeek(pWav->pUserData, pWav->ima.bytesRemainingInBlock, ma_dr_wav_seek_origin_current);
+                    pWav->ima.bytesRemainingInBlock = 0;
+                    return totalFramesRead;
+                }
+                pWav->ima.predictor[0] = ma_dr_wav_bytes_to_s16(header + 0);
+                pWav->ima.stepIndex[0] = ma_dr_wav_clamp(header[2], 0, (ma_int32)ma_dr_wav_countof(stepTable)-1);
+                pWav->ima.predictor[1] = ma_dr_wav_bytes_to_s16(header + 4);
+                pWav->ima.stepIndex[1] = ma_dr_wav_clamp(header[6], 0, (ma_int32)ma_dr_wav_countof(stepTable)-1);
+                pWav->ima.cachedFrames[ma_dr_wav_countof(pWav->ima.cachedFrames) - 2] = pWav->ima.predictor[0];
+                pWav->ima.cachedFrames[ma_dr_wav_countof(pWav->ima.cachedFrames) - 1] = pWav->ima.predictor[1];
+                pWav->ima.cachedFrameCount = 1;
+            }
+        }
+        while (framesToRead > 0 && pWav->ima.cachedFrameCount > 0 && pWav->readCursorInPCMFrames < pWav->totalPCMFrameCount) {
+            if (pBufferOut != NULL) {
+                ma_uint32 iSample;
+                for (iSample = 0; iSample < pWav->channels; iSample += 1) {
+                    pBufferOut[iSample] = (ma_int16)pWav->ima.cachedFrames[(ma_dr_wav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + iSample];
+                }
+                pBufferOut += pWav->channels;
+            }
+            framesToRead    -= 1;
+            totalFramesRead += 1;
+            pWav->readCursorInPCMFrames += 1;
+            pWav->ima.cachedFrameCount -= 1;
+        }
+        if (framesToRead == 0) {
+            break;
+        }
+        if (pWav->ima.cachedFrameCount == 0) {
+            if (pWav->ima.bytesRemainingInBlock == 0) {
+                continue;
+            } else {
+                pWav->ima.cachedFrameCount = 8;
+                for (iChannel = 0; iChannel < pWav->channels; ++iChannel) {
+                    ma_uint32 iByte;
+                    ma_uint8 nibbles[4];
+                    if (pWav->onRead(pWav->pUserData, &nibbles, 4) != 4) {
+                        pWav->ima.cachedFrameCount = 0;
+                        return totalFramesRead;
+                    }
+                    pWav->ima.bytesRemainingInBlock -= 4;
+                    for (iByte = 0; iByte < 4; ++iByte) {
+                        ma_uint8 nibble0 = ((nibbles[iByte] & 0x0F) >> 0);
+                        ma_uint8 nibble1 = ((nibbles[iByte] & 0xF0) >> 4);
+                        ma_int32 step      = stepTable[pWav->ima.stepIndex[iChannel]];
+                        ma_int32 predictor = pWav->ima.predictor[iChannel];
+                        ma_int32      diff  = step >> 3;
+                        if (nibble0 & 1) diff += step >> 2;
+                        if (nibble0 & 2) diff += step >> 1;
+                        if (nibble0 & 4) diff += step;
+                        if (nibble0 & 8) diff  = -diff;
+                        predictor = ma_dr_wav_clamp(predictor + diff, -32768, 32767);
+                        pWav->ima.predictor[iChannel] = predictor;
+                        pWav->ima.stepIndex[iChannel] = ma_dr_wav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble0], 0, (ma_int32)ma_dr_wav_countof(stepTable)-1);
+                        pWav->ima.cachedFrames[(ma_dr_wav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + (iByte*2+0)*pWav->channels + iChannel] = predictor;
+                        step      = stepTable[pWav->ima.stepIndex[iChannel]];
+                        predictor = pWav->ima.predictor[iChannel];
+                                         diff  = step >> 3;
+                        if (nibble1 & 1) diff += step >> 2;
+                        if (nibble1 & 2) diff += step >> 1;
+                        if (nibble1 & 4) diff += step;
+                        if (nibble1 & 8) diff  = -diff;
+                        predictor = ma_dr_wav_clamp(predictor + diff, -32768, 32767);
+                        pWav->ima.predictor[iChannel] = predictor;
+                        pWav->ima.stepIndex[iChannel] = ma_dr_wav_clamp(pWav->ima.stepIndex[iChannel] + indexTable[nibble1], 0, (ma_int32)ma_dr_wav_countof(stepTable)-1);
+                        pWav->ima.cachedFrames[(ma_dr_wav_countof(pWav->ima.cachedFrames) - (pWav->ima.cachedFrameCount*pWav->channels)) + (iByte*2+1)*pWav->channels + iChannel] = predictor;
+                    }
+                }
+            }
+        }
+    }
+    return totalFramesRead;
+}
+#ifndef MA_DR_WAV_NO_CONVERSION_API
+static unsigned short g_ma_dr_wavAlawTable[256] = {
+    0xEA80, 0xEB80, 0xE880, 0xE980, 0xEE80, 0xEF80, 0xEC80, 0xED80, 0xE280, 0xE380, 0xE080, 0xE180, 0xE680, 0xE780, 0xE480, 0xE580,
+    0xF540, 0xF5C0, 0xF440, 0xF4C0, 0xF740, 0xF7C0, 0xF640, 0xF6C0, 0xF140, 0xF1C0, 0xF040, 0xF0C0, 0xF340, 0xF3C0, 0xF240, 0xF2C0,
+    0xAA00, 0xAE00, 0xA200, 0xA600, 0xBA00, 0xBE00, 0xB200, 0xB600, 0x8A00, 0x8E00, 0x8200, 0x8600, 0x9A00, 0x9E00, 0x9200, 0x9600,
+    0xD500, 0xD700, 0xD100, 0xD300, 0xDD00, 0xDF00, 0xD900, 0xDB00, 0xC500, 0xC700, 0xC100, 0xC300, 0xCD00, 0xCF00, 0xC900, 0xCB00,
+    0xFEA8, 0xFEB8, 0xFE88, 0xFE98, 0xFEE8, 0xFEF8, 0xFEC8, 0xFED8, 0xFE28, 0xFE38, 0xFE08, 0xFE18, 0xFE68, 0xFE78, 0xFE48, 0xFE58,
+    0xFFA8, 0xFFB8, 0xFF88, 0xFF98, 0xFFE8, 0xFFF8, 0xFFC8, 0xFFD8, 0xFF28, 0xFF38, 0xFF08, 0xFF18, 0xFF68, 0xFF78, 0xFF48, 0xFF58,
+    0xFAA0, 0xFAE0, 0xFA20, 0xFA60, 0xFBA0, 0xFBE0, 0xFB20, 0xFB60, 0xF8A0, 0xF8E0, 0xF820, 0xF860, 0xF9A0, 0xF9E0, 0xF920, 0xF960,
+    0xFD50, 0xFD70, 0xFD10, 0xFD30, 0xFDD0, 0xFDF0, 0xFD90, 0xFDB0, 0xFC50, 0xFC70, 0xFC10, 0xFC30, 0xFCD0, 0xFCF0, 0xFC90, 0xFCB0,
+    0x1580, 0x1480, 0x1780, 0x1680, 0x1180, 0x1080, 0x1380, 0x1280, 0x1D80, 0x1C80, 0x1F80, 0x1E80, 0x1980, 0x1880, 0x1B80, 0x1A80,
+    0x0AC0, 0x0A40, 0x0BC0, 0x0B40, 0x08C0, 0x0840, 0x09C0, 0x0940, 0x0EC0, 0x0E40, 0x0FC0, 0x0F40, 0x0CC0, 0x0C40, 0x0DC0, 0x0D40,
+    0x5600, 0x5200, 0x5E00, 0x5A00, 0x4600, 0x4200, 0x4E00, 0x4A00, 0x7600, 0x7200, 0x7E00, 0x7A00, 0x6600, 0x6200, 0x6E00, 0x6A00,
+    0x2B00, 0x2900, 0x2F00, 0x2D00, 0x2300, 0x2100, 0x2700, 0x2500, 0x3B00, 0x3900, 0x3F00, 0x3D00, 0x3300, 0x3100, 0x3700, 0x3500,
+    0x0158, 0x0148, 0x0178, 0x0168, 0x0118, 0x0108, 0x0138, 0x0128, 0x01D8, 0x01C8, 0x01F8, 0x01E8, 0x0198, 0x0188, 0x01B8, 0x01A8,
+    0x0058, 0x0048, 0x0078, 0x0068, 0x0018, 0x0008, 0x0038, 0x0028, 0x00D8, 0x00C8, 0x00F8, 0x00E8, 0x0098, 0x0088, 0x00B8, 0x00A8,
+    0x0560, 0x0520, 0x05E0, 0x05A0, 0x0460, 0x0420, 0x04E0, 0x04A0, 0x0760, 0x0720, 0x07E0, 0x07A0, 0x0660, 0x0620, 0x06E0, 0x06A0,
+    0x02B0, 0x0290, 0x02F0, 0x02D0, 0x0230, 0x0210, 0x0270, 0x0250, 0x03B0, 0x0390, 0x03F0, 0x03D0, 0x0330, 0x0310, 0x0370, 0x0350
+};
+static unsigned short g_ma_dr_wavMulawTable[256] = {
+    0x8284, 0x8684, 0x8A84, 0x8E84, 0x9284, 0x9684, 0x9A84, 0x9E84, 0xA284, 0xA684, 0xAA84, 0xAE84, 0xB284, 0xB684, 0xBA84, 0xBE84,
+    0xC184, 0xC384, 0xC584, 0xC784, 0xC984, 0xCB84, 0xCD84, 0xCF84, 0xD184, 0xD384, 0xD584, 0xD784, 0xD984, 0xDB84, 0xDD84, 0xDF84,
+    0xE104, 0xE204, 0xE304, 0xE404, 0xE504, 0xE604, 0xE704, 0xE804, 0xE904, 0xEA04, 0xEB04, 0xEC04, 0xED04, 0xEE04, 0xEF04, 0xF004,
+    0xF0C4, 0xF144, 0xF1C4, 0xF244, 0xF2C4, 0xF344, 0xF3C4, 0xF444, 0xF4C4, 0xF544, 0xF5C4, 0xF644, 0xF6C4, 0xF744, 0xF7C4, 0xF844,
+    0xF8A4, 0xF8E4, 0xF924, 0xF964, 0xF9A4, 0xF9E4, 0xFA24, 0xFA64, 0xFAA4, 0xFAE4, 0xFB24, 0xFB64, 0xFBA4, 0xFBE4, 0xFC24, 0xFC64,
+    0xFC94, 0xFCB4, 0xFCD4, 0xFCF4, 0xFD14, 0xFD34, 0xFD54, 0xFD74, 0xFD94, 0xFDB4, 0xFDD4, 0xFDF4, 0xFE14, 0xFE34, 0xFE54, 0xFE74,
+    0xFE8C, 0xFE9C, 0xFEAC, 0xFEBC, 0xFECC, 0xFEDC, 0xFEEC, 0xFEFC, 0xFF0C, 0xFF1C, 0xFF2C, 0xFF3C, 0xFF4C, 0xFF5C, 0xFF6C, 0xFF7C,
+    0xFF88, 0xFF90, 0xFF98, 0xFFA0, 0xFFA8, 0xFFB0, 0xFFB8, 0xFFC0, 0xFFC8, 0xFFD0, 0xFFD8, 0xFFE0, 0xFFE8, 0xFFF0, 0xFFF8, 0x0000,
+    0x7D7C, 0x797C, 0x757C, 0x717C, 0x6D7C, 0x697C, 0x657C, 0x617C, 0x5D7C, 0x597C, 0x557C, 0x517C, 0x4D7C, 0x497C, 0x457C, 0x417C,
+    0x3E7C, 0x3C7C, 0x3A7C, 0x387C, 0x367C, 0x347C, 0x327C, 0x307C, 0x2E7C, 0x2C7C, 0x2A7C, 0x287C, 0x267C, 0x247C, 0x227C, 0x207C,
+    0x1EFC, 0x1DFC, 0x1CFC, 0x1BFC, 0x1AFC, 0x19FC, 0x18FC, 0x17FC, 0x16FC, 0x15FC, 0x14FC, 0x13FC, 0x12FC, 0x11FC, 0x10FC, 0x0FFC,
+    0x0F3C, 0x0EBC, 0x0E3C, 0x0DBC, 0x0D3C, 0x0CBC, 0x0C3C, 0x0BBC, 0x0B3C, 0x0ABC, 0x0A3C, 0x09BC, 0x093C, 0x08BC, 0x083C, 0x07BC,
+    0x075C, 0x071C, 0x06DC, 0x069C, 0x065C, 0x061C, 0x05DC, 0x059C, 0x055C, 0x051C, 0x04DC, 0x049C, 0x045C, 0x041C, 0x03DC, 0x039C,
+    0x036C, 0x034C, 0x032C, 0x030C, 0x02EC, 0x02CC, 0x02AC, 0x028C, 0x026C, 0x024C, 0x022C, 0x020C, 0x01EC, 0x01CC, 0x01AC, 0x018C,
+    0x0174, 0x0164, 0x0154, 0x0144, 0x0134, 0x0124, 0x0114, 0x0104, 0x00F4, 0x00E4, 0x00D4, 0x00C4, 0x00B4, 0x00A4, 0x0094, 0x0084,
+    0x0078, 0x0070, 0x0068, 0x0060, 0x0058, 0x0050, 0x0048, 0x0040, 0x0038, 0x0030, 0x0028, 0x0020, 0x0018, 0x0010, 0x0008, 0x0000
+};
+static MA_INLINE ma_int16 ma_dr_wav__alaw_to_s16(ma_uint8 sampleIn)
+{
+    return (short)g_ma_dr_wavAlawTable[sampleIn];
+}
+static MA_INLINE ma_int16 ma_dr_wav__mulaw_to_s16(ma_uint8 sampleIn)
+{
+    return (short)g_ma_dr_wavMulawTable[sampleIn];
+}
+MA_PRIVATE void ma_dr_wav__pcm_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
+{
+    size_t i;
+    if (bytesPerSample == 1) {
+        ma_dr_wav_u8_to_s16(pOut, pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample == 2) {
+        for (i = 0; i < totalSampleCount; ++i) {
+           *pOut++ = ((const ma_int16*)pIn)[i];
+        }
+        return;
+    }
+    if (bytesPerSample == 3) {
+        ma_dr_wav_s24_to_s16(pOut, pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample == 4) {
+        ma_dr_wav_s32_to_s16(pOut, (const ma_int32*)pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample > 8) {
+        MA_DR_WAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
+        return;
+    }
+    for (i = 0; i < totalSampleCount; ++i) {
+        ma_uint64 sample = 0;
+        unsigned int shift  = (8 - bytesPerSample) * 8;
+        unsigned int j;
+        for (j = 0; j < bytesPerSample; j += 1) {
+            MA_DR_WAV_ASSERT(j < 8);
+            sample |= (ma_uint64)(pIn[j]) << shift;
+            shift  += 8;
+        }
+        pIn += j;
+        *pOut++ = (ma_int16)((ma_int64)sample >> 48);
+    }
+}
+MA_PRIVATE void ma_dr_wav__ieee_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
+{
+    if (bytesPerSample == 4) {
+        ma_dr_wav_f32_to_s16(pOut, (const float*)pIn, totalSampleCount);
+        return;
+    } else if (bytesPerSample == 8) {
+        ma_dr_wav_f64_to_s16(pOut, (const double*)pIn, totalSampleCount);
+        return;
+    } else {
+        MA_DR_WAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
+        return;
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__pcm(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if ((pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_PCM && pWav->bitsPerSample == 16) || pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, pBufferOut);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__pcm_to_s16(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__ieee(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__ieee_to_s16(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__alaw(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_alaw_to_s16(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s16__mulaw(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_mulaw_to_s16(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    if (pWav == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    if (framesToRead * pWav->channels * sizeof(ma_int16) > MA_SIZE_MAX) {
+        framesToRead = MA_SIZE_MAX / sizeof(ma_int16) / pWav->channels;
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_PCM) {
+        return ma_dr_wav_read_pcm_frames_s16__pcm(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_IEEE_FLOAT) {
+        return ma_dr_wav_read_pcm_frames_s16__ieee(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ALAW) {
+        return ma_dr_wav_read_pcm_frames_s16__alaw(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_MULAW) {
+        return ma_dr_wav_read_pcm_frames_s16__mulaw(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM) {
+        return ma_dr_wav_read_pcm_frames_s16__msadpcm(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        return ma_dr_wav_read_pcm_frames_s16__ima(pWav, framesToRead, pBufferOut);
+    }
+    return 0;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16le(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s16(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_FALSE) {
+        ma_dr_wav__bswap_samples_s16(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s16be(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s16(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_TRUE) {
+        ma_dr_wav__bswap_samples_s16(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API void ma_dr_wav_u8_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    int r;
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        int x = pIn[i];
+        r = x << 8;
+        r = r - 32768;
+        pOut[i] = (short)r;
+    }
+}
+MA_API void ma_dr_wav_s24_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    int r;
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        int x = ((int)(((unsigned int)(((const ma_uint8*)pIn)[i*3+0]) << 8) | ((unsigned int)(((const ma_uint8*)pIn)[i*3+1]) << 16) | ((unsigned int)(((const ma_uint8*)pIn)[i*3+2])) << 24)) >> 8;
+        r = x >> 8;
+        pOut[i] = (short)r;
+    }
+}
+MA_API void ma_dr_wav_s32_to_s16(ma_int16* pOut, const ma_int32* pIn, size_t sampleCount)
+{
+    int r;
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        int x = pIn[i];
+        r = x >> 16;
+        pOut[i] = (short)r;
+    }
+}
+MA_API void ma_dr_wav_f32_to_s16(ma_int16* pOut, const float* pIn, size_t sampleCount)
+{
+    int r;
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        float x = pIn[i];
+        float c;
+        c = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
+        c = c + 1;
+        r = (int)(c * 32767.5f);
+        r = r - 32768;
+        pOut[i] = (short)r;
+    }
+}
+MA_API void ma_dr_wav_f64_to_s16(ma_int16* pOut, const double* pIn, size_t sampleCount)
+{
+    int r;
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        double x = pIn[i];
+        double c;
+        c = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
+        c = c + 1;
+        r = (int)(c * 32767.5);
+        r = r - 32768;
+        pOut[i] = (short)r;
+    }
+}
+MA_API void ma_dr_wav_alaw_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        pOut[i] = ma_dr_wav__alaw_to_s16(pIn[i]);
+    }
+}
+MA_API void ma_dr_wav_mulaw_to_s16(ma_int16* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    for (i = 0; i < sampleCount; ++i) {
+        pOut[i] = ma_dr_wav__mulaw_to_s16(pIn[i]);
+    }
+}
+MA_PRIVATE void ma_dr_wav__pcm_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount, unsigned int bytesPerSample)
+{
+    unsigned int i;
+    if (bytesPerSample == 1) {
+        ma_dr_wav_u8_to_f32(pOut, pIn, sampleCount);
+        return;
+    }
+    if (bytesPerSample == 2) {
+        ma_dr_wav_s16_to_f32(pOut, (const ma_int16*)pIn, sampleCount);
+        return;
+    }
+    if (bytesPerSample == 3) {
+        ma_dr_wav_s24_to_f32(pOut, pIn, sampleCount);
+        return;
+    }
+    if (bytesPerSample == 4) {
+        ma_dr_wav_s32_to_f32(pOut, (const ma_int32*)pIn, sampleCount);
+        return;
+    }
+    if (bytesPerSample > 8) {
+        MA_DR_WAV_ZERO_MEMORY(pOut, sampleCount * sizeof(*pOut));
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        ma_uint64 sample = 0;
+        unsigned int shift  = (8 - bytesPerSample) * 8;
+        unsigned int j;
+        for (j = 0; j < bytesPerSample; j += 1) {
+            MA_DR_WAV_ASSERT(j < 8);
+            sample |= (ma_uint64)(pIn[j]) << shift;
+            shift  += 8;
+        }
+        pIn += j;
+        *pOut++ = (float)((ma_int64)sample / 9223372036854775807.0);
+    }
+}
+MA_PRIVATE void ma_dr_wav__ieee_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount, unsigned int bytesPerSample)
+{
+    if (bytesPerSample == 4) {
+        unsigned int i;
+        for (i = 0; i < sampleCount; ++i) {
+            *pOut++ = ((const float*)pIn)[i];
+        }
+        return;
+    } else if (bytesPerSample == 8) {
+        ma_dr_wav_f64_to_f32(pOut, (const double*)pIn, sampleCount);
+        return;
+    } else {
+        MA_DR_WAV_ZERO_MEMORY(pOut, sampleCount * sizeof(*pOut));
+        return;
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_f32__pcm(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__pcm_to_f32(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_f32__msadpcm_ima(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_int16 samples16[2048];
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, ma_dr_wav_countof(samples16)/pWav->channels);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s16(pWav, framesToReadThisIteration, samples16);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        ma_dr_wav_s16_to_f32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels));
+        pBufferOut      += framesRead*pWav->channels;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_f32__ieee(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_IEEE_FLOAT && pWav->bitsPerSample == 32) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, pBufferOut);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__ieee_to_f32(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_f32__alaw(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_alaw_to_f32(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_f32__mulaw(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_mulaw_to_f32(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    if (pWav == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    if (framesToRead * pWav->channels * sizeof(float) > MA_SIZE_MAX) {
+        framesToRead = MA_SIZE_MAX / sizeof(float) / pWav->channels;
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_PCM) {
+        return ma_dr_wav_read_pcm_frames_f32__pcm(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM || pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        return ma_dr_wav_read_pcm_frames_f32__msadpcm_ima(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_IEEE_FLOAT) {
+        return ma_dr_wav_read_pcm_frames_f32__ieee(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ALAW) {
+        return ma_dr_wav_read_pcm_frames_f32__alaw(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_MULAW) {
+        return ma_dr_wav_read_pcm_frames_f32__mulaw(pWav, framesToRead, pBufferOut);
+    }
+    return 0;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32le(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_f32(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_FALSE) {
+        ma_dr_wav__bswap_samples_f32(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_f32be(ma_dr_wav* pWav, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_f32(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_TRUE) {
+        ma_dr_wav__bswap_samples_f32(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API void ma_dr_wav_u8_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+#ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = (pIn[i] / 256.0f) * 2 - 1;
+    }
+#else
+    for (i = 0; i < sampleCount; ++i) {
+        float x = pIn[i];
+        x = x * 0.00784313725490196078f;
+        x = x - 1;
+        *pOut++ = x;
+    }
+#endif
+}
+MA_API void ma_dr_wav_s16_to_f32(float* pOut, const ma_int16* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = pIn[i] * 0.000030517578125f;
+    }
+}
+MA_API void ma_dr_wav_s24_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        double x;
+        ma_uint32 a = ((ma_uint32)(pIn[i*3+0]) <<  8);
+        ma_uint32 b = ((ma_uint32)(pIn[i*3+1]) << 16);
+        ma_uint32 c = ((ma_uint32)(pIn[i*3+2]) << 24);
+        x = (double)((ma_int32)(a | b | c) >> 8);
+        *pOut++ = (float)(x * 0.00000011920928955078125);
+    }
+}
+MA_API void ma_dr_wav_s32_to_f32(float* pOut, const ma_int32* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = (float)(pIn[i] / 2147483648.0);
+    }
+}
+MA_API void ma_dr_wav_f64_to_f32(float* pOut, const double* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = (float)pIn[i];
+    }
+}
+MA_API void ma_dr_wav_alaw_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = ma_dr_wav__alaw_to_s16(pIn[i]) / 32768.0f;
+    }
+}
+MA_API void ma_dr_wav_mulaw_to_f32(float* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = ma_dr_wav__mulaw_to_s16(pIn[i]) / 32768.0f;
+    }
+}
+MA_PRIVATE void ma_dr_wav__pcm_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
+{
+    unsigned int i;
+    if (bytesPerSample == 1) {
+        ma_dr_wav_u8_to_s32(pOut, pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample == 2) {
+        ma_dr_wav_s16_to_s32(pOut, (const ma_int16*)pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample == 3) {
+        ma_dr_wav_s24_to_s32(pOut, pIn, totalSampleCount);
+        return;
+    }
+    if (bytesPerSample == 4) {
+        for (i = 0; i < totalSampleCount; ++i) {
+           *pOut++ = ((const ma_int32*)pIn)[i];
+        }
+        return;
+    }
+    if (bytesPerSample > 8) {
+        MA_DR_WAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
+        return;
+    }
+    for (i = 0; i < totalSampleCount; ++i) {
+        ma_uint64 sample = 0;
+        unsigned int shift  = (8 - bytesPerSample) * 8;
+        unsigned int j;
+        for (j = 0; j < bytesPerSample; j += 1) {
+            MA_DR_WAV_ASSERT(j < 8);
+            sample |= (ma_uint64)(pIn[j]) << shift;
+            shift  += 8;
+        }
+        pIn += j;
+        *pOut++ = (ma_int32)((ma_int64)sample >> 32);
+    }
+}
+MA_PRIVATE void ma_dr_wav__ieee_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t totalSampleCount, unsigned int bytesPerSample)
+{
+    if (bytesPerSample == 4) {
+        ma_dr_wav_f32_to_s32(pOut, (const float*)pIn, totalSampleCount);
+        return;
+    } else if (bytesPerSample == 8) {
+        ma_dr_wav_f64_to_s32(pOut, (const double*)pIn, totalSampleCount);
+        return;
+    } else {
+        MA_DR_WAV_ZERO_MEMORY(pOut, totalSampleCount * sizeof(*pOut));
+        return;
+    }
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s32__pcm(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_PCM && pWav->bitsPerSample == 32) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, pBufferOut);
+    }
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__pcm_to_s32(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s32__msadpcm_ima(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 totalFramesRead = 0;
+    ma_int16 samples16[2048];
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, ma_dr_wav_countof(samples16)/pWav->channels);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s16(pWav, framesToReadThisIteration, samples16);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        ma_dr_wav_s16_to_s32(pBufferOut, samples16, (size_t)(framesRead*pWav->channels));
+        pBufferOut      += framesRead*pWav->channels;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s32__ieee(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav__ieee_to_s32(pBufferOut, sampleData, (size_t)samplesRead, bytesPerSample);
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s32__alaw(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_alaw_to_s32(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_PRIVATE ma_uint64 ma_dr_wav_read_pcm_frames_s32__mulaw(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 totalFramesRead;
+    ma_uint8 sampleData[4096] = {0};
+    ma_uint32 bytesPerFrame;
+    ma_uint32 bytesPerSample;
+    ma_uint64 samplesRead;
+    bytesPerFrame = ma_dr_wav_get_bytes_per_pcm_frame(pWav);
+    if (bytesPerFrame == 0) {
+        return 0;
+    }
+    bytesPerSample = bytesPerFrame / pWav->channels;
+    if (bytesPerSample == 0 || (bytesPerFrame % pWav->channels) != 0) {
+        return 0;
+    }
+    totalFramesRead = 0;
+    while (framesToRead > 0) {
+        ma_uint64 framesToReadThisIteration = ma_dr_wav_min(framesToRead, sizeof(sampleData)/bytesPerFrame);
+        ma_uint64 framesRead = ma_dr_wav_read_pcm_frames(pWav, framesToReadThisIteration, sampleData);
+        if (framesRead == 0) {
+            break;
+        }
+        MA_DR_WAV_ASSERT(framesRead <= framesToReadThisIteration);
+        samplesRead = framesRead * pWav->channels;
+        if ((samplesRead * bytesPerSample) > sizeof(sampleData)) {
+            MA_DR_WAV_ASSERT(MA_FALSE);
+            break;
+        }
+        ma_dr_wav_mulaw_to_s32(pBufferOut, sampleData, (size_t)samplesRead);
+        #ifdef MA_DR_WAV_LIBSNDFILE_COMPAT
+        {
+            if (pWav->container == ma_dr_wav_container_aiff) {
+                ma_uint64 iSample;
+                for (iSample = 0; iSample < samplesRead; iSample += 1) {
+                    pBufferOut[iSample] = -pBufferOut[iSample];
+                }
+            }
+        }
+        #endif
+        pBufferOut      += samplesRead;
+        framesToRead    -= framesRead;
+        totalFramesRead += framesRead;
+    }
+    return totalFramesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    if (pWav == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_wav_read_pcm_frames(pWav, framesToRead, NULL);
+    }
+    if (framesToRead * pWav->channels * sizeof(ma_int32) > MA_SIZE_MAX) {
+        framesToRead = MA_SIZE_MAX / sizeof(ma_int32) / pWav->channels;
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_PCM) {
+        return ma_dr_wav_read_pcm_frames_s32__pcm(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ADPCM || pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_DVI_ADPCM) {
+        return ma_dr_wav_read_pcm_frames_s32__msadpcm_ima(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_IEEE_FLOAT) {
+        return ma_dr_wav_read_pcm_frames_s32__ieee(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_ALAW) {
+        return ma_dr_wav_read_pcm_frames_s32__alaw(pWav, framesToRead, pBufferOut);
+    }
+    if (pWav->translatedFormatTag == MA_DR_WAVE_FORMAT_MULAW) {
+        return ma_dr_wav_read_pcm_frames_s32__mulaw(pWav, framesToRead, pBufferOut);
+    }
+    return 0;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32le(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s32(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_FALSE) {
+        ma_dr_wav__bswap_samples_s32(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API ma_uint64 ma_dr_wav_read_pcm_frames_s32be(ma_dr_wav* pWav, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 framesRead = ma_dr_wav_read_pcm_frames_s32(pWav, framesToRead, pBufferOut);
+    if (pBufferOut != NULL && ma_dr_wav__is_little_endian() == MA_TRUE) {
+        ma_dr_wav__bswap_samples_s32(pBufferOut, framesRead*pWav->channels);
+    }
+    return framesRead;
+}
+MA_API void ma_dr_wav_u8_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = ((int)pIn[i] - 128) << 24;
+    }
+}
+MA_API void ma_dr_wav_s16_to_s32(ma_int32* pOut, const ma_int16* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = pIn[i] << 16;
+    }
+}
+MA_API void ma_dr_wav_s24_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        unsigned int s0 = pIn[i*3 + 0];
+        unsigned int s1 = pIn[i*3 + 1];
+        unsigned int s2 = pIn[i*3 + 2];
+        ma_int32 sample32 = (ma_int32)((s0 << 8) | (s1 << 16) | (s2 << 24));
+        *pOut++ = sample32;
+    }
+}
+MA_API void ma_dr_wav_f32_to_s32(ma_int32* pOut, const float* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = (ma_int32)(2147483648.0 * pIn[i]);
+    }
+}
+MA_API void ma_dr_wav_f64_to_s32(ma_int32* pOut, const double* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = (ma_int32)(2147483648.0 * pIn[i]);
+    }
+}
+MA_API void ma_dr_wav_alaw_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i = 0; i < sampleCount; ++i) {
+        *pOut++ = ((ma_int32)ma_dr_wav__alaw_to_s16(pIn[i])) << 16;
+    }
+}
+MA_API void ma_dr_wav_mulaw_to_s32(ma_int32* pOut, const ma_uint8* pIn, size_t sampleCount)
+{
+    size_t i;
+    if (pOut == NULL || pIn == NULL) {
+        return;
+    }
+    for (i= 0; i < sampleCount; ++i) {
+        *pOut++ = ((ma_int32)ma_dr_wav__mulaw_to_s16(pIn[i])) << 16;
+    }
+}
+MA_PRIVATE ma_int16* ma_dr_wav__read_pcm_frames_and_close_s16(ma_dr_wav* pWav, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalFrameCount)
+{
+    ma_uint64 sampleDataSize;
+    ma_int16* pSampleData;
+    ma_uint64 framesRead;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(ma_int16);
+    if (sampleDataSize > MA_SIZE_MAX) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    pSampleData = (ma_int16*)ma_dr_wav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks);
+    if (pSampleData == NULL) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    framesRead = ma_dr_wav_read_pcm_frames_s16(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
+    if (framesRead != pWav->totalPCMFrameCount) {
+        ma_dr_wav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    ma_dr_wav_uninit(pWav);
+    if (sampleRate) {
+        *sampleRate = pWav->sampleRate;
+    }
+    if (channels) {
+        *channels = pWav->channels;
+    }
+    if (totalFrameCount) {
+        *totalFrameCount = pWav->totalPCMFrameCount;
+    }
+    return pSampleData;
+}
+MA_PRIVATE float* ma_dr_wav__read_pcm_frames_and_close_f32(ma_dr_wav* pWav, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalFrameCount)
+{
+    ma_uint64 sampleDataSize;
+    float* pSampleData;
+    ma_uint64 framesRead;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(float);
+    if (sampleDataSize > MA_SIZE_MAX) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    pSampleData = (float*)ma_dr_wav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks);
+    if (pSampleData == NULL) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    framesRead = ma_dr_wav_read_pcm_frames_f32(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
+    if (framesRead != pWav->totalPCMFrameCount) {
+        ma_dr_wav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    ma_dr_wav_uninit(pWav);
+    if (sampleRate) {
+        *sampleRate = pWav->sampleRate;
+    }
+    if (channels) {
+        *channels = pWav->channels;
+    }
+    if (totalFrameCount) {
+        *totalFrameCount = pWav->totalPCMFrameCount;
+    }
+    return pSampleData;
+}
+MA_PRIVATE ma_int32* ma_dr_wav__read_pcm_frames_and_close_s32(ma_dr_wav* pWav, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalFrameCount)
+{
+    ma_uint64 sampleDataSize;
+    ma_int32* pSampleData;
+    ma_uint64 framesRead;
+    MA_DR_WAV_ASSERT(pWav != NULL);
+    sampleDataSize = pWav->totalPCMFrameCount * pWav->channels * sizeof(ma_int32);
+    if (sampleDataSize > MA_SIZE_MAX) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    pSampleData = (ma_int32*)ma_dr_wav__malloc_from_callbacks((size_t)sampleDataSize, &pWav->allocationCallbacks);
+    if (pSampleData == NULL) {
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    framesRead = ma_dr_wav_read_pcm_frames_s32(pWav, (size_t)pWav->totalPCMFrameCount, pSampleData);
+    if (framesRead != pWav->totalPCMFrameCount) {
+        ma_dr_wav__free_from_callbacks(pSampleData, &pWav->allocationCallbacks);
+        ma_dr_wav_uninit(pWav);
+        return NULL;
+    }
+    ma_dr_wav_uninit(pWav);
+    if (sampleRate) {
+        *sampleRate = pWav->sampleRate;
+    }
+    if (channels) {
+        *channels = pWav->channels;
+    }
+    if (totalFrameCount) {
+        *totalFrameCount = pWav->totalPCMFrameCount;
+    }
+    return pSampleData;
+}
+MA_API ma_int16* ma_dr_wav_open_and_read_pcm_frames_s16(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init(&wav, onRead, onSeek, pUserData, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API float* ma_dr_wav_open_and_read_pcm_frames_f32(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init(&wav, onRead, onSeek, pUserData, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API ma_int32* ma_dr_wav_open_and_read_pcm_frames_s32(ma_dr_wav_read_proc onRead, ma_dr_wav_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init(&wav, onRead, onSeek, pUserData, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+#ifndef MA_DR_WAV_NO_STDIO
+MA_API ma_int16* ma_dr_wav_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API float* ma_dr_wav_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API ma_int32* ma_dr_wav_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+#ifndef MA_DR_WAV_NO_WCHAR
+MA_API ma_int16* ma_dr_wav_open_file_and_read_pcm_frames_s16_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file_w(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API float* ma_dr_wav_open_file_and_read_pcm_frames_f32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file_w(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API ma_int32* ma_dr_wav_open_file_and_read_pcm_frames_s32_w(const wchar_t* filename, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_file_w(&wav, filename, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+#endif
+#endif
+MA_API ma_int16* ma_dr_wav_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s16(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API float* ma_dr_wav_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_f32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+MA_API ma_int32* ma_dr_wav_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_wav wav;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalFrameCountOut) {
+        *totalFrameCountOut = 0;
+    }
+    if (!ma_dr_wav_init_memory(&wav, data, dataSize, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_wav__read_pcm_frames_and_close_s32(&wav, channelsOut, sampleRateOut, totalFrameCountOut);
+}
+#endif
+MA_API void ma_dr_wav_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        ma_dr_wav__free_from_callbacks(p, pAllocationCallbacks);
+    } else {
+        ma_dr_wav__free_default(p, NULL);
+    }
+}
+MA_API ma_uint16 ma_dr_wav_bytes_to_u16(const ma_uint8* data)
+{
+    return ((ma_uint16)data[0] << 0) | ((ma_uint16)data[1] << 8);
+}
+MA_API ma_int16 ma_dr_wav_bytes_to_s16(const ma_uint8* data)
+{
+    return (ma_int16)ma_dr_wav_bytes_to_u16(data);
+}
+MA_API ma_uint32 ma_dr_wav_bytes_to_u32(const ma_uint8* data)
+{
+    return ma_dr_wav_bytes_to_u32_le(data);
+}
+MA_API float ma_dr_wav_bytes_to_f32(const ma_uint8* data)
+{
+    union {
+        ma_uint32 u32;
+        float f32;
+    } value;
+    value.u32 = ma_dr_wav_bytes_to_u32(data);
+    return value.f32;
+}
+MA_API ma_int32 ma_dr_wav_bytes_to_s32(const ma_uint8* data)
+{
+    return (ma_int32)ma_dr_wav_bytes_to_u32(data);
+}
+MA_API ma_uint64 ma_dr_wav_bytes_to_u64(const ma_uint8* data)
+{
+    return
+        ((ma_uint64)data[0] <<  0) | ((ma_uint64)data[1] <<  8) | ((ma_uint64)data[2] << 16) | ((ma_uint64)data[3] << 24) |
+        ((ma_uint64)data[4] << 32) | ((ma_uint64)data[5] << 40) | ((ma_uint64)data[6] << 48) | ((ma_uint64)data[7] << 56);
+}
+MA_API ma_int64 ma_dr_wav_bytes_to_s64(const ma_uint8* data)
+{
+    return (ma_int64)ma_dr_wav_bytes_to_u64(data);
+}
+MA_API ma_bool32 ma_dr_wav_guid_equal(const ma_uint8 a[16], const ma_uint8 b[16])
+{
+    int i;
+    for (i = 0; i < 16; i += 1) {
+        if (a[i] != b[i]) {
+            return MA_FALSE;
+        }
+    }
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_wav_fourcc_equal(const ma_uint8* a, const char* b)
+{
+    return
+        a[0] == b[0] &&
+        a[1] == b[1] &&
+        a[2] == b[2] &&
+        a[3] == b[3];
+}
+#ifdef __MRC__
+#pragma options opt reset
+#endif
+#endif
+/* dr_wav_c end */
+#endif  /* MA_DR_WAV_IMPLEMENTATION */
+#endif  /* MA_NO_WAV */
+
+#if !defined(MA_NO_FLAC) && !defined(MA_NO_DECODING)
+#if !defined(MA_DR_FLAC_IMPLEMENTATION) && !defined(MA_DR_FLAC_IMPLEMENTATION) /* For backwards compatibility. Will be removed in version 0.11 for cleanliness. */
+/* dr_flac_c begin */
+#ifndef ma_dr_flac_c
+#define ma_dr_flac_c
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic push
+    #if __GNUC__ >= 7
+    #pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+    #endif
+#endif
+#ifdef __linux__
+    #ifndef _BSD_SOURCE
+        #define _BSD_SOURCE
+    #endif
+    #ifndef _DEFAULT_SOURCE
+        #define _DEFAULT_SOURCE
+    #endif
+    #ifndef __USE_BSD
+        #define __USE_BSD
+    #endif
+    #include <endian.h>
+#endif
+#include <stdlib.h>
+#include <string.h>
+#if !defined(MA_DR_FLAC_NO_SIMD)
+    #if defined(MA_X64) || defined(MA_X86)
+        #if defined(_MSC_VER) && !defined(__clang__)
+            #if _MSC_VER >= 1400 && !defined(MA_DR_FLAC_NO_SSE2)
+                #define MA_DR_FLAC_SUPPORT_SSE2
+            #endif
+            #if _MSC_VER >= 1600 && !defined(MA_DR_FLAC_NO_SSE41)
+                #define MA_DR_FLAC_SUPPORT_SSE41
+            #endif
+        #elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)))
+            #if defined(__SSE2__) && !defined(MA_DR_FLAC_NO_SSE2)
+                #define MA_DR_FLAC_SUPPORT_SSE2
+            #endif
+            #if defined(__SSE4_1__) && !defined(MA_DR_FLAC_NO_SSE41)
+                #define MA_DR_FLAC_SUPPORT_SSE41
+            #endif
+        #endif
+        #if !defined(__GNUC__) && !defined(__clang__) && defined(__has_include)
+            #if !defined(MA_DR_FLAC_SUPPORT_SSE2) && !defined(MA_DR_FLAC_NO_SSE2) && __has_include(<emmintrin.h>)
+                #define MA_DR_FLAC_SUPPORT_SSE2
+            #endif
+            #if !defined(MA_DR_FLAC_SUPPORT_SSE41) && !defined(MA_DR_FLAC_NO_SSE41) && __has_include(<smmintrin.h>)
+                #define MA_DR_FLAC_SUPPORT_SSE41
+            #endif
+        #endif
+        #if defined(MA_DR_FLAC_SUPPORT_SSE41)
+            #include <smmintrin.h>
+        #elif defined(MA_DR_FLAC_SUPPORT_SSE2)
+            #include <emmintrin.h>
+        #endif
+    #endif
+    #if defined(MA_ARM)
+        #if !defined(MA_DR_FLAC_NO_NEON) && (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
+            #define MA_DR_FLAC_SUPPORT_NEON
+            #include <arm_neon.h>
+        #endif
+    #endif
+#endif
+#if !defined(MA_DR_FLAC_NO_SIMD) && (defined(MA_X86) || defined(MA_X64))
+    #if defined(_MSC_VER) && !defined(__clang__)
+        #if _MSC_VER >= 1400
+            #include <intrin.h>
+            static void ma_dr_flac__cpuid(int info[4], int fid)
+            {
+                __cpuid(info, fid);
+            }
+        #else
+            #define MA_DR_FLAC_NO_CPUID
+        #endif
+    #else
+        #if defined(__GNUC__) || defined(__clang__)
+            static void ma_dr_flac__cpuid(int info[4], int fid)
+            {
+                #if defined(MA_X86) && defined(__PIC__)
+                    __asm__ __volatile__ (
+                        "xchg{l} {%%}ebx, %k1;"
+                        "cpuid;"
+                        "xchg{l} {%%}ebx, %k1;"
+                        : "=a"(info[0]), "=&r"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0)
+                    );
+                #else
+                    __asm__ __volatile__ (
+                        "cpuid" : "=a"(info[0]), "=b"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(fid), "c"(0)
+                    );
+                #endif
+            }
+        #else
+            #define MA_DR_FLAC_NO_CPUID
+        #endif
+    #endif
+#else
+    #define MA_DR_FLAC_NO_CPUID
+#endif
+static MA_INLINE ma_bool32 ma_dr_flac_has_sse2(void)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    #if (defined(MA_X64) || defined(MA_X86)) && !defined(MA_DR_FLAC_NO_SSE2)
+        #if defined(MA_X64)
+            return MA_TRUE;
+        #elif (defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE2__)
+            return MA_TRUE;
+        #else
+            #if defined(MA_DR_FLAC_NO_CPUID)
+                return MA_FALSE;
+            #else
+                int info[4];
+                ma_dr_flac__cpuid(info, 1);
+                return (info[3] & (1 << 26)) != 0;
+            #endif
+        #endif
+    #else
+        return MA_FALSE;
+    #endif
+#else
+    return MA_FALSE;
+#endif
+}
+static MA_INLINE ma_bool32 ma_dr_flac_has_sse41(void)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE41)
+    #if (defined(MA_X64) || defined(MA_X86)) && !defined(MA_DR_FLAC_NO_SSE41)
+        #if defined(__SSE4_1__) || defined(__AVX__)
+            return MA_TRUE;
+        #else
+            #if defined(MA_DR_FLAC_NO_CPUID)
+                return MA_FALSE;
+            #else
+                int info[4];
+                ma_dr_flac__cpuid(info, 1);
+                return (info[2] & (1 << 19)) != 0;
+            #endif
+        #endif
+    #else
+        return MA_FALSE;
+    #endif
+#else
+    return MA_FALSE;
+#endif
+}
+#if defined(_MSC_VER) && _MSC_VER >= 1500 && (defined(MA_X86) || defined(MA_X64)) && !defined(__clang__)
+    #define MA_DR_FLAC_HAS_LZCNT_INTRINSIC
+#elif (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)))
+    #define MA_DR_FLAC_HAS_LZCNT_INTRINSIC
+#elif defined(__clang__)
+    #if defined(__has_builtin)
+        #if __has_builtin(__builtin_clzll) || __has_builtin(__builtin_clzl)
+            #define MA_DR_FLAC_HAS_LZCNT_INTRINSIC
+        #endif
+    #endif
+#endif
+#if defined(_MSC_VER) && _MSC_VER >= 1400 && !defined(__clang__)
+    #define MA_DR_FLAC_HAS_BYTESWAP16_INTRINSIC
+    #define MA_DR_FLAC_HAS_BYTESWAP32_INTRINSIC
+    #define MA_DR_FLAC_HAS_BYTESWAP64_INTRINSIC
+#elif defined(__clang__)
+    #if defined(__has_builtin)
+        #if __has_builtin(__builtin_bswap16)
+            #define MA_DR_FLAC_HAS_BYTESWAP16_INTRINSIC
+        #endif
+        #if __has_builtin(__builtin_bswap32)
+            #define MA_DR_FLAC_HAS_BYTESWAP32_INTRINSIC
+        #endif
+        #if __has_builtin(__builtin_bswap64)
+            #define MA_DR_FLAC_HAS_BYTESWAP64_INTRINSIC
+        #endif
+    #endif
+#elif defined(__GNUC__)
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+        #define MA_DR_FLAC_HAS_BYTESWAP32_INTRINSIC
+        #define MA_DR_FLAC_HAS_BYTESWAP64_INTRINSIC
+    #endif
+    #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
+        #define MA_DR_FLAC_HAS_BYTESWAP16_INTRINSIC
+    #endif
+#elif defined(__WATCOMC__) && defined(__386__)
+    #define MA_DR_FLAC_HAS_BYTESWAP16_INTRINSIC
+    #define MA_DR_FLAC_HAS_BYTESWAP32_INTRINSIC
+    #define MA_DR_FLAC_HAS_BYTESWAP64_INTRINSIC
+    extern __inline ma_uint16 _watcom_bswap16(ma_uint16);
+    extern __inline ma_uint32 _watcom_bswap32(ma_uint32);
+    extern __inline ma_uint64 _watcom_bswap64(ma_uint64);
+#pragma aux _watcom_bswap16 = \
+    "xchg al, ah" \
+    parm  [ax]    \
+    value [ax]    \
+    modify nomemory;
+#pragma aux _watcom_bswap32 = \
+    "bswap eax" \
+    parm  [eax] \
+    value [eax] \
+    modify nomemory;
+#pragma aux _watcom_bswap64 = \
+    "bswap eax"     \
+    "bswap edx"     \
+    "xchg eax,edx"  \
+    parm [eax edx]  \
+    value [eax edx] \
+    modify nomemory;
+#endif
+#ifndef MA_DR_FLAC_ASSERT
+#include <assert.h>
+#define MA_DR_FLAC_ASSERT(expression)           assert(expression)
+#endif
+#ifndef MA_DR_FLAC_MALLOC
+#define MA_DR_FLAC_MALLOC(sz)                   malloc((sz))
+#endif
+#ifndef MA_DR_FLAC_REALLOC
+#define MA_DR_FLAC_REALLOC(p, sz)               realloc((p), (sz))
+#endif
+#ifndef MA_DR_FLAC_FREE
+#define MA_DR_FLAC_FREE(p)                      free((p))
+#endif
+#ifndef MA_DR_FLAC_COPY_MEMORY
+#define MA_DR_FLAC_COPY_MEMORY(dst, src, sz)    memcpy((dst), (src), (sz))
+#endif
+#ifndef MA_DR_FLAC_ZERO_MEMORY
+#define MA_DR_FLAC_ZERO_MEMORY(p, sz)           memset((p), 0, (sz))
+#endif
+#ifndef MA_DR_FLAC_ZERO_OBJECT
+#define MA_DR_FLAC_ZERO_OBJECT(p)               MA_DR_FLAC_ZERO_MEMORY((p), sizeof(*(p)))
+#endif
+#define MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE                     64
+#define MA_DR_FLAC_SUBFRAME_CONSTANT                        0
+#define MA_DR_FLAC_SUBFRAME_VERBATIM                        1
+#define MA_DR_FLAC_SUBFRAME_FIXED                           8
+#define MA_DR_FLAC_SUBFRAME_LPC                             32
+#define MA_DR_FLAC_SUBFRAME_RESERVED                        255
+#define MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE  0
+#define MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2 1
+#define MA_DR_FLAC_CHANNEL_ASSIGNMENT_INDEPENDENT           0
+#define MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE             8
+#define MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE            9
+#define MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE              10
+#define MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES                  18
+#define MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES             36
+#define MA_DR_FLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES       12
+#define ma_dr_flac_align(x, a)                              ((((x) + (a) - 1) / (a)) * (a))
+MA_API void ma_dr_flac_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision)
+{
+    if (pMajor) {
+        *pMajor = MA_DR_FLAC_VERSION_MAJOR;
+    }
+    if (pMinor) {
+        *pMinor = MA_DR_FLAC_VERSION_MINOR;
+    }
+    if (pRevision) {
+        *pRevision = MA_DR_FLAC_VERSION_REVISION;
+    }
+}
+MA_API const char* ma_dr_flac_version_string(void)
+{
+    return MA_DR_FLAC_VERSION_STRING;
+}
+#if defined(__has_feature)
+    #if __has_feature(thread_sanitizer)
+        #define MA_DR_FLAC_NO_THREAD_SANITIZE __attribute__((no_sanitize("thread")))
+    #else
+        #define MA_DR_FLAC_NO_THREAD_SANITIZE
+    #endif
+#else
+    #define MA_DR_FLAC_NO_THREAD_SANITIZE
+#endif
+#if defined(MA_DR_FLAC_HAS_LZCNT_INTRINSIC)
+static ma_bool32 ma_dr_flac__gIsLZCNTSupported = MA_FALSE;
+#endif
+#ifndef MA_DR_FLAC_NO_CPUID
+static ma_bool32 ma_dr_flac__gIsSSE2Supported  = MA_FALSE;
+static ma_bool32 ma_dr_flac__gIsSSE41Supported = MA_FALSE;
+MA_DR_FLAC_NO_THREAD_SANITIZE static void ma_dr_flac__init_cpu_caps(void)
+{
+    static ma_bool32 isCPUCapsInitialized = MA_FALSE;
+    if (!isCPUCapsInitialized) {
+#if defined(MA_DR_FLAC_HAS_LZCNT_INTRINSIC)
+        int info[4] = {0};
+        ma_dr_flac__cpuid(info, 0x80000001);
+        ma_dr_flac__gIsLZCNTSupported = (info[2] & (1 << 5)) != 0;
+#endif
+        ma_dr_flac__gIsSSE2Supported = ma_dr_flac_has_sse2();
+        ma_dr_flac__gIsSSE41Supported = ma_dr_flac_has_sse41();
+        isCPUCapsInitialized = MA_TRUE;
+    }
+}
+#else
+static ma_bool32 ma_dr_flac__gIsNEONSupported  = MA_FALSE;
+static MA_INLINE ma_bool32 ma_dr_flac__has_neon(void)
+{
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+    #if defined(MA_ARM) && !defined(MA_DR_FLAC_NO_NEON)
+        #if (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
+            return MA_TRUE;
+        #else
+            return MA_FALSE;
+        #endif
+    #else
+        return MA_FALSE;
+    #endif
+#else
+    return MA_FALSE;
+#endif
+}
+MA_DR_FLAC_NO_THREAD_SANITIZE static void ma_dr_flac__init_cpu_caps(void)
+{
+    ma_dr_flac__gIsNEONSupported = ma_dr_flac__has_neon();
+#if defined(MA_DR_FLAC_HAS_LZCNT_INTRINSIC) && defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5)
+    ma_dr_flac__gIsLZCNTSupported = MA_TRUE;
+#endif
+}
+#endif
+static MA_INLINE ma_bool32 ma_dr_flac__is_little_endian(void)
+{
+#if defined(MA_X86) || defined(MA_X64)
+    return MA_TRUE;
+#elif defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && __BYTE_ORDER == __LITTLE_ENDIAN
+    return MA_TRUE;
+#else
+    int n = 1;
+    return (*(char*)&n) == 1;
+#endif
+}
+static MA_INLINE ma_uint16 ma_dr_flac__swap_endian_uint16(ma_uint16 n)
+{
+#ifdef MA_DR_FLAC_HAS_BYTESWAP16_INTRINSIC
+    #if defined(_MSC_VER) && !defined(__clang__)
+        return _byteswap_ushort(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        return __builtin_bswap16(n);
+    #elif defined(__WATCOMC__) && defined(__386__)
+        return _watcom_bswap16(n);
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & 0xFF00) >> 8) |
+           ((n & 0x00FF) << 8);
+#endif
+}
+static MA_INLINE ma_uint32 ma_dr_flac__swap_endian_uint32(ma_uint32 n)
+{
+#ifdef MA_DR_FLAC_HAS_BYTESWAP32_INTRINSIC
+    #if defined(_MSC_VER) && !defined(__clang__)
+        return _byteswap_ulong(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        #if defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 6) && !defined(__ARM_ARCH_6M__) && !defined(MA_64BIT)
+            ma_uint32 r;
+            __asm__ __volatile__ (
+            #if defined(MA_64BIT)
+                "rev %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(n)
+            #else
+                "rev %[out], %[in]" : [out]"=r"(r) : [in]"r"(n)
+            #endif
+            );
+            return r;
+        #else
+            return __builtin_bswap32(n);
+        #endif
+    #elif defined(__WATCOMC__) && defined(__386__)
+        return _watcom_bswap32(n);
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & 0xFF000000) >> 24) |
+           ((n & 0x00FF0000) >>  8) |
+           ((n & 0x0000FF00) <<  8) |
+           ((n & 0x000000FF) << 24);
+#endif
+}
+static MA_INLINE ma_uint64 ma_dr_flac__swap_endian_uint64(ma_uint64 n)
+{
+#ifdef MA_DR_FLAC_HAS_BYTESWAP64_INTRINSIC
+    #if defined(_MSC_VER) && !defined(__clang__)
+        return _byteswap_uint64(n);
+    #elif defined(__GNUC__) || defined(__clang__)
+        return __builtin_bswap64(n);
+    #elif defined(__WATCOMC__) && defined(__386__)
+        return _watcom_bswap64(n);
+    #else
+        #error "This compiler does not support the byte swap intrinsic."
+    #endif
+#else
+    return ((n & ((ma_uint64)0xFF000000 << 32)) >> 56) |
+           ((n & ((ma_uint64)0x00FF0000 << 32)) >> 40) |
+           ((n & ((ma_uint64)0x0000FF00 << 32)) >> 24) |
+           ((n & ((ma_uint64)0x000000FF << 32)) >>  8) |
+           ((n & ((ma_uint64)0xFF000000      )) <<  8) |
+           ((n & ((ma_uint64)0x00FF0000      )) << 24) |
+           ((n & ((ma_uint64)0x0000FF00      )) << 40) |
+           ((n & ((ma_uint64)0x000000FF      )) << 56);
+#endif
+}
+static MA_INLINE ma_uint16 ma_dr_flac__be2host_16(ma_uint16 n)
+{
+    if (ma_dr_flac__is_little_endian()) {
+        return ma_dr_flac__swap_endian_uint16(n);
+    }
+    return n;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__be2host_32(ma_uint32 n)
+{
+    if (ma_dr_flac__is_little_endian()) {
+        return ma_dr_flac__swap_endian_uint32(n);
+    }
+    return n;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__be2host_32_ptr_unaligned(const void* pData)
+{
+    const ma_uint8* pNum = (ma_uint8*)pData;
+    return *(pNum) << 24 | *(pNum+1) << 16 | *(pNum+2) << 8 | *(pNum+3);
+}
+static MA_INLINE ma_uint64 ma_dr_flac__be2host_64(ma_uint64 n)
+{
+    if (ma_dr_flac__is_little_endian()) {
+        return ma_dr_flac__swap_endian_uint64(n);
+    }
+    return n;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__le2host_32(ma_uint32 n)
+{
+    if (!ma_dr_flac__is_little_endian()) {
+        return ma_dr_flac__swap_endian_uint32(n);
+    }
+    return n;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__le2host_32_ptr_unaligned(const void* pData)
+{
+    const ma_uint8* pNum = (ma_uint8*)pData;
+    return *pNum | *(pNum+1) << 8 |  *(pNum+2) << 16 | *(pNum+3) << 24;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__unsynchsafe_32(ma_uint32 n)
+{
+    ma_uint32 result = 0;
+    result |= (n & 0x7F000000) >> 3;
+    result |= (n & 0x007F0000) >> 2;
+    result |= (n & 0x00007F00) >> 1;
+    result |= (n & 0x0000007F) >> 0;
+    return result;
+}
+static ma_uint8 ma_dr_flac__crc8_table[] = {
+    0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
+    0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65, 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
+    0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5, 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
+    0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85, 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
+    0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2, 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
+    0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2, 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
+    0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32, 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
+    0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42, 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
+    0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C, 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
+    0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC, 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
+    0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C, 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
+    0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C, 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
+    0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B, 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
+    0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B, 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
+    0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB, 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
+    0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB, 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
+};
+static ma_uint16 ma_dr_flac__crc16_table[] = {
+    0x0000, 0x8005, 0x800F, 0x000A, 0x801B, 0x001E, 0x0014, 0x8011,
+    0x8033, 0x0036, 0x003C, 0x8039, 0x0028, 0x802D, 0x8027, 0x0022,
+    0x8063, 0x0066, 0x006C, 0x8069, 0x0078, 0x807D, 0x8077, 0x0072,
+    0x0050, 0x8055, 0x805F, 0x005A, 0x804B, 0x004E, 0x0044, 0x8041,
+    0x80C3, 0x00C6, 0x00CC, 0x80C9, 0x00D8, 0x80DD, 0x80D7, 0x00D2,
+    0x00F0, 0x80F5, 0x80FF, 0x00FA, 0x80EB, 0x00EE, 0x00E4, 0x80E1,
+    0x00A0, 0x80A5, 0x80AF, 0x00AA, 0x80BB, 0x00BE, 0x00B4, 0x80B1,
+    0x8093, 0x0096, 0x009C, 0x8099, 0x0088, 0x808D, 0x8087, 0x0082,
+    0x8183, 0x0186, 0x018C, 0x8189, 0x0198, 0x819D, 0x8197, 0x0192,
+    0x01B0, 0x81B5, 0x81BF, 0x01BA, 0x81AB, 0x01AE, 0x01A4, 0x81A1,
+    0x01E0, 0x81E5, 0x81EF, 0x01EA, 0x81FB, 0x01FE, 0x01F4, 0x81F1,
+    0x81D3, 0x01D6, 0x01DC, 0x81D9, 0x01C8, 0x81CD, 0x81C7, 0x01C2,
+    0x0140, 0x8145, 0x814F, 0x014A, 0x815B, 0x015E, 0x0154, 0x8151,
+    0x8173, 0x0176, 0x017C, 0x8179, 0x0168, 0x816D, 0x8167, 0x0162,
+    0x8123, 0x0126, 0x012C, 0x8129, 0x0138, 0x813D, 0x8137, 0x0132,
+    0x0110, 0x8115, 0x811F, 0x011A, 0x810B, 0x010E, 0x0104, 0x8101,
+    0x8303, 0x0306, 0x030C, 0x8309, 0x0318, 0x831D, 0x8317, 0x0312,
+    0x0330, 0x8335, 0x833F, 0x033A, 0x832B, 0x032E, 0x0324, 0x8321,
+    0x0360, 0x8365, 0x836F, 0x036A, 0x837B, 0x037E, 0x0374, 0x8371,
+    0x8353, 0x0356, 0x035C, 0x8359, 0x0348, 0x834D, 0x8347, 0x0342,
+    0x03C0, 0x83C5, 0x83CF, 0x03CA, 0x83DB, 0x03DE, 0x03D4, 0x83D1,
+    0x83F3, 0x03F6, 0x03FC, 0x83F9, 0x03E8, 0x83ED, 0x83E7, 0x03E2,
+    0x83A3, 0x03A6, 0x03AC, 0x83A9, 0x03B8, 0x83BD, 0x83B7, 0x03B2,
+    0x0390, 0x8395, 0x839F, 0x039A, 0x838B, 0x038E, 0x0384, 0x8381,
+    0x0280, 0x8285, 0x828F, 0x028A, 0x829B, 0x029E, 0x0294, 0x8291,
+    0x82B3, 0x02B6, 0x02BC, 0x82B9, 0x02A8, 0x82AD, 0x82A7, 0x02A2,
+    0x82E3, 0x02E6, 0x02EC, 0x82E9, 0x02F8, 0x82FD, 0x82F7, 0x02F2,
+    0x02D0, 0x82D5, 0x82DF, 0x02DA, 0x82CB, 0x02CE, 0x02C4, 0x82C1,
+    0x8243, 0x0246, 0x024C, 0x8249, 0x0258, 0x825D, 0x8257, 0x0252,
+    0x0270, 0x8275, 0x827F, 0x027A, 0x826B, 0x026E, 0x0264, 0x8261,
+    0x0220, 0x8225, 0x822F, 0x022A, 0x823B, 0x023E, 0x0234, 0x8231,
+    0x8213, 0x0216, 0x021C, 0x8219, 0x0208, 0x820D, 0x8207, 0x0202
+};
+static MA_INLINE ma_uint8 ma_dr_flac_crc8_byte(ma_uint8 crc, ma_uint8 data)
+{
+    return ma_dr_flac__crc8_table[crc ^ data];
+}
+static MA_INLINE ma_uint8 ma_dr_flac_crc8(ma_uint8 crc, ma_uint32 data, ma_uint32 count)
+{
+#ifdef MA_DR_FLAC_NO_CRC
+    (void)crc;
+    (void)data;
+    (void)count;
+    return 0;
+#else
+#if 0
+    ma_uint8 p = 0x07;
+    for (int i = count-1; i >= 0; --i) {
+        ma_uint8 bit = (data & (1 << i)) >> i;
+        if (crc & 0x80) {
+            crc = ((crc << 1) | bit) ^ p;
+        } else {
+            crc = ((crc << 1) | bit);
+        }
+    }
+    return crc;
+#else
+    ma_uint32 wholeBytes;
+    ma_uint32 leftoverBits;
+    ma_uint64 leftoverDataMask;
+    static ma_uint64 leftoverDataMaskTable[8] = {
+        0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F
+    };
+    MA_DR_FLAC_ASSERT(count <= 32);
+    wholeBytes = count >> 3;
+    leftoverBits = count - (wholeBytes*8);
+    leftoverDataMask = leftoverDataMaskTable[leftoverBits];
+    switch (wholeBytes) {
+        case 4: crc = ma_dr_flac_crc8_byte(crc, (ma_uint8)((data & (0xFF000000UL << leftoverBits)) >> (24 + leftoverBits)));
+        case 3: crc = ma_dr_flac_crc8_byte(crc, (ma_uint8)((data & (0x00FF0000UL << leftoverBits)) >> (16 + leftoverBits)));
+        case 2: crc = ma_dr_flac_crc8_byte(crc, (ma_uint8)((data & (0x0000FF00UL << leftoverBits)) >> ( 8 + leftoverBits)));
+        case 1: crc = ma_dr_flac_crc8_byte(crc, (ma_uint8)((data & (0x000000FFUL << leftoverBits)) >> ( 0 + leftoverBits)));
+        case 0: if (leftoverBits > 0) crc = (ma_uint8)((crc << leftoverBits) ^ ma_dr_flac__crc8_table[(crc >> (8 - leftoverBits)) ^ (data & leftoverDataMask)]);
+    }
+    return crc;
+#endif
+#endif
+}
+static MA_INLINE ma_uint16 ma_dr_flac_crc16_byte(ma_uint16 crc, ma_uint8 data)
+{
+    return (crc << 8) ^ ma_dr_flac__crc16_table[(ma_uint8)(crc >> 8) ^ data];
+}
+static MA_INLINE ma_uint16 ma_dr_flac_crc16_cache(ma_uint16 crc, ma_dr_flac_cache_t data)
+{
+#ifdef MA_64BIT
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 56) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 48) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 40) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 32) & 0xFF));
+#endif
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 24) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 16) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >>  8) & 0xFF));
+    crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >>  0) & 0xFF));
+    return crc;
+}
+static MA_INLINE ma_uint16 ma_dr_flac_crc16_bytes(ma_uint16 crc, ma_dr_flac_cache_t data, ma_uint32 byteCount)
+{
+    switch (byteCount)
+    {
+#ifdef MA_64BIT
+    case 8: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 56) & 0xFF));
+    case 7: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 48) & 0xFF));
+    case 6: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 40) & 0xFF));
+    case 5: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 32) & 0xFF));
+#endif
+    case 4: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 24) & 0xFF));
+    case 3: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >> 16) & 0xFF));
+    case 2: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >>  8) & 0xFF));
+    case 1: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data >>  0) & 0xFF));
+    }
+    return crc;
+}
+#if 0
+static MA_INLINE ma_uint16 ma_dr_flac_crc16__32bit(ma_uint16 crc, ma_uint32 data, ma_uint32 count)
+{
+#ifdef MA_DR_FLAC_NO_CRC
+    (void)crc;
+    (void)data;
+    (void)count;
+    return 0;
+#else
+#if 0
+    ma_uint16 p = 0x8005;
+    for (int i = count-1; i >= 0; --i) {
+        ma_uint16 bit = (data & (1ULL << i)) >> i;
+        if (r & 0x8000) {
+            r = ((r << 1) | bit) ^ p;
+        } else {
+            r = ((r << 1) | bit);
+        }
+    }
+    return crc;
+#else
+    ma_uint32 wholeBytes;
+    ma_uint32 leftoverBits;
+    ma_uint64 leftoverDataMask;
+    static ma_uint64 leftoverDataMaskTable[8] = {
+        0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F
+    };
+    MA_DR_FLAC_ASSERT(count <= 64);
+    wholeBytes = count >> 3;
+    leftoverBits = count & 7;
+    leftoverDataMask = leftoverDataMaskTable[leftoverBits];
+    switch (wholeBytes) {
+        default:
+        case 4: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (0xFF000000UL << leftoverBits)) >> (24 + leftoverBits)));
+        case 3: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (0x00FF0000UL << leftoverBits)) >> (16 + leftoverBits)));
+        case 2: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (0x0000FF00UL << leftoverBits)) >> ( 8 + leftoverBits)));
+        case 1: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (0x000000FFUL << leftoverBits)) >> ( 0 + leftoverBits)));
+        case 0: if (leftoverBits > 0) crc = (crc << leftoverBits) ^ ma_dr_flac__crc16_table[(crc >> (16 - leftoverBits)) ^ (data & leftoverDataMask)];
+    }
+    return crc;
+#endif
+#endif
+}
+static MA_INLINE ma_uint16 ma_dr_flac_crc16__64bit(ma_uint16 crc, ma_uint64 data, ma_uint32 count)
+{
+#ifdef MA_DR_FLAC_NO_CRC
+    (void)crc;
+    (void)data;
+    (void)count;
+    return 0;
+#else
+    ma_uint32 wholeBytes;
+    ma_uint32 leftoverBits;
+    ma_uint64 leftoverDataMask;
+    static ma_uint64 leftoverDataMaskTable[8] = {
+        0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F
+    };
+    MA_DR_FLAC_ASSERT(count <= 64);
+    wholeBytes = count >> 3;
+    leftoverBits = count & 7;
+    leftoverDataMask = leftoverDataMaskTable[leftoverBits];
+    switch (wholeBytes) {
+        default:
+        case 8: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0xFF000000 << 32) << leftoverBits)) >> (56 + leftoverBits)));
+        case 7: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x00FF0000 << 32) << leftoverBits)) >> (48 + leftoverBits)));
+        case 6: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x0000FF00 << 32) << leftoverBits)) >> (40 + leftoverBits)));
+        case 5: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x000000FF << 32) << leftoverBits)) >> (32 + leftoverBits)));
+        case 4: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0xFF000000      ) << leftoverBits)) >> (24 + leftoverBits)));
+        case 3: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x00FF0000      ) << leftoverBits)) >> (16 + leftoverBits)));
+        case 2: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x0000FF00      ) << leftoverBits)) >> ( 8 + leftoverBits)));
+        case 1: crc = ma_dr_flac_crc16_byte(crc, (ma_uint8)((data & (((ma_uint64)0x000000FF      ) << leftoverBits)) >> ( 0 + leftoverBits)));
+        case 0: if (leftoverBits > 0) crc = (crc << leftoverBits) ^ ma_dr_flac__crc16_table[(crc >> (16 - leftoverBits)) ^ (data & leftoverDataMask)];
+    }
+    return crc;
+#endif
+}
+static MA_INLINE ma_uint16 ma_dr_flac_crc16(ma_uint16 crc, ma_dr_flac_cache_t data, ma_uint32 count)
+{
+#ifdef MA_64BIT
+    return ma_dr_flac_crc16__64bit(crc, data, count);
+#else
+    return ma_dr_flac_crc16__32bit(crc, data, count);
+#endif
+}
+#endif
+#ifdef MA_64BIT
+#define ma_dr_flac__be2host__cache_line ma_dr_flac__be2host_64
+#else
+#define ma_dr_flac__be2host__cache_line ma_dr_flac__be2host_32
+#endif
+#define MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs)                      (sizeof((bs)->cache))
+#define MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)                       (sizeof((bs)->cache)*8)
+#define MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)                  (MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs) - (bs)->consumedBits)
+#define MA_DR_FLAC_CACHE_L1_SELECTION_MASK(_bitCount)           (~((~(ma_dr_flac_cache_t)0) >> (_bitCount)))
+#define MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT(bs, _bitCount)      (MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs) - (_bitCount))
+#define MA_DR_FLAC_CACHE_L1_SELECT(bs, _bitCount)               (((bs)->cache) & MA_DR_FLAC_CACHE_L1_SELECTION_MASK(_bitCount))
+#define MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, _bitCount)     (MA_DR_FLAC_CACHE_L1_SELECT((bs), (_bitCount)) >>  MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT((bs), (_bitCount)))
+#define MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE(bs, _bitCount)(MA_DR_FLAC_CACHE_L1_SELECT((bs), (_bitCount)) >> (MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT((bs), (_bitCount)) & (MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)-1)))
+#define MA_DR_FLAC_CACHE_L2_SIZE_BYTES(bs)                      (sizeof((bs)->cacheL2))
+#define MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)                      (MA_DR_FLAC_CACHE_L2_SIZE_BYTES(bs) / sizeof((bs)->cacheL2[0]))
+#define MA_DR_FLAC_CACHE_L2_LINES_REMAINING(bs)                 (MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs) - (bs)->nextL2Line)
+#ifndef MA_DR_FLAC_NO_CRC
+static MA_INLINE void ma_dr_flac__reset_crc16(ma_dr_flac_bs* bs)
+{
+    bs->crc16 = 0;
+    bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3;
+}
+static MA_INLINE void ma_dr_flac__update_crc16(ma_dr_flac_bs* bs)
+{
+    if (bs->crc16CacheIgnoredBytes == 0) {
+        bs->crc16 = ma_dr_flac_crc16_cache(bs->crc16, bs->crc16Cache);
+    } else {
+        bs->crc16 = ma_dr_flac_crc16_bytes(bs->crc16, bs->crc16Cache, MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs) - bs->crc16CacheIgnoredBytes);
+        bs->crc16CacheIgnoredBytes = 0;
+    }
+}
+static MA_INLINE ma_uint16 ma_dr_flac__flush_crc16(ma_dr_flac_bs* bs)
+{
+    MA_DR_FLAC_ASSERT((MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs) & 7) == 0);
+    if (MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs) == 0) {
+        ma_dr_flac__update_crc16(bs);
+    } else {
+        bs->crc16 = ma_dr_flac_crc16_bytes(bs->crc16, bs->crc16Cache >> MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs), (bs->consumedBits >> 3) - bs->crc16CacheIgnoredBytes);
+        bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3;
+    }
+    return bs->crc16;
+}
+#endif
+static MA_INLINE ma_bool32 ma_dr_flac__reload_l1_cache_from_l2(ma_dr_flac_bs* bs)
+{
+    size_t bytesRead;
+    size_t alignedL1LineCount;
+    if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+        bs->cache = bs->cacheL2[bs->nextL2Line++];
+        return MA_TRUE;
+    }
+    if (bs->unalignedByteCount > 0) {
+        return MA_FALSE;
+    }
+    bytesRead = bs->onRead(bs->pUserData, bs->cacheL2, MA_DR_FLAC_CACHE_L2_SIZE_BYTES(bs));
+    bs->nextL2Line = 0;
+    if (bytesRead == MA_DR_FLAC_CACHE_L2_SIZE_BYTES(bs)) {
+        bs->cache = bs->cacheL2[bs->nextL2Line++];
+        return MA_TRUE;
+    }
+    alignedL1LineCount = bytesRead / MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs);
+    bs->unalignedByteCount = bytesRead - (alignedL1LineCount * MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs));
+    if (bs->unalignedByteCount > 0) {
+        bs->unalignedCache = bs->cacheL2[alignedL1LineCount];
+    }
+    if (alignedL1LineCount > 0) {
+        size_t offset = MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs) - alignedL1LineCount;
+        size_t i;
+        for (i = alignedL1LineCount; i > 0; --i) {
+            bs->cacheL2[i-1 + offset] = bs->cacheL2[i-1];
+        }
+        bs->nextL2Line = (ma_uint32)offset;
+        bs->cache = bs->cacheL2[bs->nextL2Line++];
+        return MA_TRUE;
+    } else {
+        bs->nextL2Line = MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs);
+        return MA_FALSE;
+    }
+}
+static ma_bool32 ma_dr_flac__reload_cache(ma_dr_flac_bs* bs)
+{
+    size_t bytesRead;
+#ifndef MA_DR_FLAC_NO_CRC
+    ma_dr_flac__update_crc16(bs);
+#endif
+    if (ma_dr_flac__reload_l1_cache_from_l2(bs)) {
+        bs->cache = ma_dr_flac__be2host__cache_line(bs->cache);
+        bs->consumedBits = 0;
+#ifndef MA_DR_FLAC_NO_CRC
+        bs->crc16Cache = bs->cache;
+#endif
+        return MA_TRUE;
+    }
+    bytesRead = bs->unalignedByteCount;
+    if (bytesRead == 0) {
+        bs->consumedBits = MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+        return MA_FALSE;
+    }
+    MA_DR_FLAC_ASSERT(bytesRead < MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs));
+    bs->consumedBits = (ma_uint32)(MA_DR_FLAC_CACHE_L1_SIZE_BYTES(bs) - bytesRead) * 8;
+    bs->cache = ma_dr_flac__be2host__cache_line(bs->unalignedCache);
+    bs->cache &= MA_DR_FLAC_CACHE_L1_SELECTION_MASK(MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs));
+    bs->unalignedByteCount = 0;
+#ifndef MA_DR_FLAC_NO_CRC
+    bs->crc16Cache = bs->cache >> bs->consumedBits;
+    bs->crc16CacheIgnoredBytes = bs->consumedBits >> 3;
+#endif
+    return MA_TRUE;
+}
+static void ma_dr_flac__reset_cache(ma_dr_flac_bs* bs)
+{
+    bs->nextL2Line   = MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs);
+    bs->consumedBits = MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+    bs->cache = 0;
+    bs->unalignedByteCount = 0;
+    bs->unalignedCache = 0;
+#ifndef MA_DR_FLAC_NO_CRC
+    bs->crc16Cache = 0;
+    bs->crc16CacheIgnoredBytes = 0;
+#endif
+}
+static MA_INLINE ma_bool32 ma_dr_flac__read_uint32(ma_dr_flac_bs* bs, unsigned int bitCount, ma_uint32* pResultOut)
+{
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResultOut != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 32);
+    if (bs->consumedBits == MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)) {
+        if (!ma_dr_flac__reload_cache(bs)) {
+            return MA_FALSE;
+        }
+    }
+    if (bitCount <= MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+#ifdef MA_64BIT
+        *pResultOut = (ma_uint32)MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCount);
+        bs->consumedBits += bitCount;
+        bs->cache <<= bitCount;
+#else
+        if (bitCount < MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)) {
+            *pResultOut = (ma_uint32)MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCount);
+            bs->consumedBits += bitCount;
+            bs->cache <<= bitCount;
+        } else {
+            *pResultOut = (ma_uint32)bs->cache;
+            bs->consumedBits = MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+            bs->cache = 0;
+        }
+#endif
+        return MA_TRUE;
+    } else {
+        ma_uint32 bitCountHi = MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs);
+        ma_uint32 bitCountLo = bitCount - bitCountHi;
+        ma_uint32 resultHi;
+        MA_DR_FLAC_ASSERT(bitCountHi > 0);
+        MA_DR_FLAC_ASSERT(bitCountHi < 32);
+        resultHi = (ma_uint32)MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCountHi);
+        if (!ma_dr_flac__reload_cache(bs)) {
+            return MA_FALSE;
+        }
+        if (bitCountLo > MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+            return MA_FALSE;
+        }
+        *pResultOut = (resultHi << bitCountLo) | (ma_uint32)MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCountLo);
+        bs->consumedBits += bitCountLo;
+        bs->cache <<= bitCountLo;
+        return MA_TRUE;
+    }
+}
+static ma_bool32 ma_dr_flac__read_int32(ma_dr_flac_bs* bs, unsigned int bitCount, ma_int32* pResult)
+{
+    ma_uint32 result;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResult != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 32);
+    if (!ma_dr_flac__read_uint32(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    if (bitCount < 32) {
+        ma_uint32 signbit;
+        signbit = ((result >> (bitCount-1)) & 0x01);
+        result |= (~signbit + 1) << bitCount;
+    }
+    *pResult = (ma_int32)result;
+    return MA_TRUE;
+}
+#ifdef MA_64BIT
+static ma_bool32 ma_dr_flac__read_uint64(ma_dr_flac_bs* bs, unsigned int bitCount, ma_uint64* pResultOut)
+{
+    ma_uint32 resultHi;
+    ma_uint32 resultLo;
+    MA_DR_FLAC_ASSERT(bitCount <= 64);
+    MA_DR_FLAC_ASSERT(bitCount >  32);
+    if (!ma_dr_flac__read_uint32(bs, bitCount - 32, &resultHi)) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_flac__read_uint32(bs, 32, &resultLo)) {
+        return MA_FALSE;
+    }
+    *pResultOut = (((ma_uint64)resultHi) << 32) | ((ma_uint64)resultLo);
+    return MA_TRUE;
+}
+#endif
+#if 0
+static ma_bool32 ma_dr_flac__read_int64(ma_dr_flac_bs* bs, unsigned int bitCount, ma_int64* pResultOut)
+{
+    ma_uint64 result;
+    ma_uint64 signbit;
+    MA_DR_FLAC_ASSERT(bitCount <= 64);
+    if (!ma_dr_flac__read_uint64(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    signbit = ((result >> (bitCount-1)) & 0x01);
+    result |= (~signbit + 1) << bitCount;
+    *pResultOut = (ma_int64)result;
+    return MA_TRUE;
+}
+#endif
+static ma_bool32 ma_dr_flac__read_uint16(ma_dr_flac_bs* bs, unsigned int bitCount, ma_uint16* pResult)
+{
+    ma_uint32 result;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResult != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 16);
+    if (!ma_dr_flac__read_uint32(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    *pResult = (ma_uint16)result;
+    return MA_TRUE;
+}
+#if 0
+static ma_bool32 ma_dr_flac__read_int16(ma_dr_flac_bs* bs, unsigned int bitCount, ma_int16* pResult)
+{
+    ma_int32 result;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResult != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 16);
+    if (!ma_dr_flac__read_int32(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    *pResult = (ma_int16)result;
+    return MA_TRUE;
+}
+#endif
+static ma_bool32 ma_dr_flac__read_uint8(ma_dr_flac_bs* bs, unsigned int bitCount, ma_uint8* pResult)
+{
+    ma_uint32 result;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResult != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 8);
+    if (!ma_dr_flac__read_uint32(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    *pResult = (ma_uint8)result;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__read_int8(ma_dr_flac_bs* bs, unsigned int bitCount, ma_int8* pResult)
+{
+    ma_int32 result;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pResult != NULL);
+    MA_DR_FLAC_ASSERT(bitCount > 0);
+    MA_DR_FLAC_ASSERT(bitCount <= 8);
+    if (!ma_dr_flac__read_int32(bs, bitCount, &result)) {
+        return MA_FALSE;
+    }
+    *pResult = (ma_int8)result;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__seek_bits(ma_dr_flac_bs* bs, size_t bitsToSeek)
+{
+    if (bitsToSeek <= MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+        bs->consumedBits += (ma_uint32)bitsToSeek;
+        bs->cache <<= bitsToSeek;
+        return MA_TRUE;
+    } else {
+        bitsToSeek       -= MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs);
+        bs->consumedBits += MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs);
+        bs->cache         = 0;
+#ifdef MA_64BIT
+        while (bitsToSeek >= MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)) {
+            ma_uint64 bin;
+            if (!ma_dr_flac__read_uint64(bs, MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs), &bin)) {
+                return MA_FALSE;
+            }
+            bitsToSeek -= MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+        }
+#else
+        while (bitsToSeek >= MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)) {
+            ma_uint32 bin;
+            if (!ma_dr_flac__read_uint32(bs, MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs), &bin)) {
+                return MA_FALSE;
+            }
+            bitsToSeek -= MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+        }
+#endif
+        while (bitsToSeek >= 8) {
+            ma_uint8 bin;
+            if (!ma_dr_flac__read_uint8(bs, 8, &bin)) {
+                return MA_FALSE;
+            }
+            bitsToSeek -= 8;
+        }
+        if (bitsToSeek > 0) {
+            ma_uint8 bin;
+            if (!ma_dr_flac__read_uint8(bs, (ma_uint32)bitsToSeek, &bin)) {
+                return MA_FALSE;
+            }
+            bitsToSeek = 0;
+        }
+        MA_DR_FLAC_ASSERT(bitsToSeek == 0);
+        return MA_TRUE;
+    }
+}
+static ma_bool32 ma_dr_flac__find_and_seek_to_next_sync_code(ma_dr_flac_bs* bs)
+{
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    if (!ma_dr_flac__seek_bits(bs, MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs) & 7)) {
+        return MA_FALSE;
+    }
+    for (;;) {
+        ma_uint8 hi;
+#ifndef MA_DR_FLAC_NO_CRC
+        ma_dr_flac__reset_crc16(bs);
+#endif
+        if (!ma_dr_flac__read_uint8(bs, 8, &hi)) {
+            return MA_FALSE;
+        }
+        if (hi == 0xFF) {
+            ma_uint8 lo;
+            if (!ma_dr_flac__read_uint8(bs, 6, &lo)) {
+                return MA_FALSE;
+            }
+            if (lo == 0x3E) {
+                return MA_TRUE;
+            } else {
+                if (!ma_dr_flac__seek_bits(bs, MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs) & 7)) {
+                    return MA_FALSE;
+                }
+            }
+        }
+    }
+}
+#if defined(MA_DR_FLAC_HAS_LZCNT_INTRINSIC)
+#define MA_DR_FLAC_IMPLEMENT_CLZ_LZCNT
+#endif
+#if  defined(_MSC_VER) && _MSC_VER >= 1400 && (defined(MA_X64) || defined(MA_X86)) && !defined(__clang__)
+#define MA_DR_FLAC_IMPLEMENT_CLZ_MSVC
+#endif
+#if  defined(__WATCOMC__) && defined(__386__)
+#define MA_DR_FLAC_IMPLEMENT_CLZ_WATCOM
+#endif
+#ifdef __MRC__
+#include <intrinsics.h>
+#define MA_DR_FLAC_IMPLEMENT_CLZ_MRC
+#endif
+static MA_INLINE ma_uint32 ma_dr_flac__clz_software(ma_dr_flac_cache_t x)
+{
+    ma_uint32 n;
+    static ma_uint32 clz_table_4[] = {
+        0,
+        4,
+        3, 3,
+        2, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 1, 1
+    };
+    if (x == 0) {
+        return sizeof(x)*8;
+    }
+    n = clz_table_4[x >> (sizeof(x)*8 - 4)];
+    if (n == 0) {
+#ifdef MA_64BIT
+        if ((x & ((ma_uint64)0xFFFFFFFF << 32)) == 0) { n  = 32; x <<= 32; }
+        if ((x & ((ma_uint64)0xFFFF0000 << 32)) == 0) { n += 16; x <<= 16; }
+        if ((x & ((ma_uint64)0xFF000000 << 32)) == 0) { n += 8;  x <<= 8;  }
+        if ((x & ((ma_uint64)0xF0000000 << 32)) == 0) { n += 4;  x <<= 4;  }
+#else
+        if ((x & 0xFFFF0000) == 0) { n  = 16; x <<= 16; }
+        if ((x & 0xFF000000) == 0) { n += 8;  x <<= 8;  }
+        if ((x & 0xF0000000) == 0) { n += 4;  x <<= 4;  }
+#endif
+        n += clz_table_4[x >> (sizeof(x)*8 - 4)];
+    }
+    return n - 1;
+}
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_LZCNT
+static MA_INLINE ma_bool32 ma_dr_flac__is_lzcnt_supported(void)
+{
+#if defined(MA_DR_FLAC_HAS_LZCNT_INTRINSIC) && defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5)
+    return MA_TRUE;
+#elif defined(__MRC__)
+    return MA_TRUE;
+#else
+    #ifdef MA_DR_FLAC_HAS_LZCNT_INTRINSIC
+        return ma_dr_flac__gIsLZCNTSupported;
+    #else
+        return MA_FALSE;
+    #endif
+#endif
+}
+static MA_INLINE ma_uint32 ma_dr_flac__clz_lzcnt(ma_dr_flac_cache_t x)
+{
+#if defined(_MSC_VER)
+    #ifdef MA_64BIT
+        return (ma_uint32)__lzcnt64(x);
+    #else
+        return (ma_uint32)__lzcnt(x);
+    #endif
+#else
+    #if defined(__GNUC__) || defined(__clang__)
+        #if defined(MA_X64)
+            {
+                ma_uint64 r;
+                __asm__ __volatile__ (
+                    "lzcnt{ %1, %0| %0, %1}" : "=r"(r) : "r"(x) : "cc"
+                );
+                return (ma_uint32)r;
+            }
+        #elif defined(MA_X86)
+            {
+                ma_uint32 r;
+                __asm__ __volatile__ (
+                    "lzcnt{l %1, %0| %0, %1}" : "=r"(r) : "r"(x) : "cc"
+                );
+                return r;
+            }
+        #elif defined(MA_ARM) && (defined(__ARM_ARCH) && __ARM_ARCH >= 5) && !defined(__ARM_ARCH_6M__) && !defined(MA_64BIT)
+            {
+                unsigned int r;
+                __asm__ __volatile__ (
+                #if defined(MA_64BIT)
+                    "clz %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(x)
+                #else
+                    "clz %[out], %[in]" : [out]"=r"(r) : [in]"r"(x)
+                #endif
+                );
+                return r;
+            }
+        #else
+            if (x == 0) {
+                return sizeof(x)*8;
+            }
+            #ifdef MA_64BIT
+                return (ma_uint32)__builtin_clzll((ma_uint64)x);
+            #else
+                return (ma_uint32)__builtin_clzl((ma_uint32)x);
+            #endif
+        #endif
+    #else
+        #error "This compiler does not support the lzcnt intrinsic."
+    #endif
+#endif
+}
+#endif
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_MSVC
+#include <intrin.h>
+static MA_INLINE ma_uint32 ma_dr_flac__clz_msvc(ma_dr_flac_cache_t x)
+{
+    ma_uint32 n;
+    if (x == 0) {
+        return sizeof(x)*8;
+    }
+#ifdef MA_64BIT
+    _BitScanReverse64((unsigned long*)&n, x);
+#else
+    _BitScanReverse((unsigned long*)&n, x);
+#endif
+    return sizeof(x)*8 - n - 1;
+}
+#endif
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_WATCOM
+static __inline ma_uint32 ma_dr_flac__clz_watcom (ma_uint32);
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_WATCOM_LZCNT
+#pragma aux ma_dr_flac__clz_watcom_lzcnt = \
+    "db 0F3h, 0Fh, 0BDh, 0C0h"  \
+    parm [eax] \
+    value [eax] \
+    modify nomemory;
+#else
+#pragma aux ma_dr_flac__clz_watcom = \
+    "bsr eax, eax" \
+    "xor eax, 31" \
+    parm [eax] nomemory \
+    value [eax] \
+    modify exact [eax] nomemory;
+#endif
+#endif
+static MA_INLINE ma_uint32 ma_dr_flac__clz(ma_dr_flac_cache_t x)
+{
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_LZCNT
+    if (ma_dr_flac__is_lzcnt_supported()) {
+        return ma_dr_flac__clz_lzcnt(x);
+    } else
+#endif
+    {
+#ifdef MA_DR_FLAC_IMPLEMENT_CLZ_MSVC
+        return ma_dr_flac__clz_msvc(x);
+#elif defined(MA_DR_FLAC_IMPLEMENT_CLZ_WATCOM_LZCNT)
+        return ma_dr_flac__clz_watcom_lzcnt(x);
+#elif defined(MA_DR_FLAC_IMPLEMENT_CLZ_WATCOM)
+        return (x == 0) ? sizeof(x)*8 : ma_dr_flac__clz_watcom(x);
+#elif defined(__MRC__)
+        return __cntlzw(x);
+#else
+        return ma_dr_flac__clz_software(x);
+#endif
+    }
+}
+static MA_INLINE ma_bool32 ma_dr_flac__seek_past_next_set_bit(ma_dr_flac_bs* bs, unsigned int* pOffsetOut)
+{
+    ma_uint32 zeroCounter = 0;
+    ma_uint32 setBitOffsetPlus1;
+    while (bs->cache == 0) {
+        zeroCounter += (ma_uint32)MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs);
+        if (!ma_dr_flac__reload_cache(bs)) {
+            return MA_FALSE;
+        }
+    }
+    if (bs->cache == 1) {
+        *pOffsetOut = zeroCounter + (ma_uint32)MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs) - 1;
+        if (!ma_dr_flac__reload_cache(bs)) {
+            return MA_FALSE;
+        }
+        return MA_TRUE;
+    }
+    setBitOffsetPlus1 = ma_dr_flac__clz(bs->cache);
+    setBitOffsetPlus1 += 1;
+    if (setBitOffsetPlus1 > MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+        return MA_FALSE;
+    }
+    bs->consumedBits += setBitOffsetPlus1;
+    bs->cache <<= setBitOffsetPlus1;
+    *pOffsetOut = zeroCounter + setBitOffsetPlus1 - 1;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__seek_to_byte(ma_dr_flac_bs* bs, ma_uint64 offsetFromStart)
+{
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(offsetFromStart > 0);
+    if (offsetFromStart > 0x7FFFFFFF) {
+        ma_uint64 bytesRemaining = offsetFromStart;
+        if (!bs->onSeek(bs->pUserData, 0x7FFFFFFF, ma_dr_flac_seek_origin_start)) {
+            return MA_FALSE;
+        }
+        bytesRemaining -= 0x7FFFFFFF;
+        while (bytesRemaining > 0x7FFFFFFF) {
+            if (!bs->onSeek(bs->pUserData, 0x7FFFFFFF, ma_dr_flac_seek_origin_current)) {
+                return MA_FALSE;
+            }
+            bytesRemaining -= 0x7FFFFFFF;
+        }
+        if (bytesRemaining > 0) {
+            if (!bs->onSeek(bs->pUserData, (int)bytesRemaining, ma_dr_flac_seek_origin_current)) {
+                return MA_FALSE;
+            }
+        }
+    } else {
+        if (!bs->onSeek(bs->pUserData, (int)offsetFromStart, ma_dr_flac_seek_origin_start)) {
+            return MA_FALSE;
+        }
+    }
+    ma_dr_flac__reset_cache(bs);
+    return MA_TRUE;
+}
+static ma_result ma_dr_flac__read_utf8_coded_number(ma_dr_flac_bs* bs, ma_uint64* pNumberOut, ma_uint8* pCRCOut)
+{
+    ma_uint8 crc;
+    ma_uint64 result;
+    ma_uint8 utf8[7] = {0};
+    int byteCount;
+    int i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pNumberOut != NULL);
+    MA_DR_FLAC_ASSERT(pCRCOut != NULL);
+    crc = *pCRCOut;
+    if (!ma_dr_flac__read_uint8(bs, 8, utf8)) {
+        *pNumberOut = 0;
+        return MA_AT_END;
+    }
+    crc = ma_dr_flac_crc8(crc, utf8[0], 8);
+    if ((utf8[0] & 0x80) == 0) {
+        *pNumberOut = utf8[0];
+        *pCRCOut = crc;
+        return MA_SUCCESS;
+    }
+    if ((utf8[0] & 0xE0) == 0xC0) {
+        byteCount = 2;
+    } else if ((utf8[0] & 0xF0) == 0xE0) {
+        byteCount = 3;
+    } else if ((utf8[0] & 0xF8) == 0xF0) {
+        byteCount = 4;
+    } else if ((utf8[0] & 0xFC) == 0xF8) {
+        byteCount = 5;
+    } else if ((utf8[0] & 0xFE) == 0xFC) {
+        byteCount = 6;
+    } else if ((utf8[0] & 0xFF) == 0xFE) {
+        byteCount = 7;
+    } else {
+        *pNumberOut = 0;
+        return MA_CRC_MISMATCH;
+    }
+    MA_DR_FLAC_ASSERT(byteCount > 1);
+    result = (ma_uint64)(utf8[0] & (0xFF >> (byteCount + 1)));
+    for (i = 1; i < byteCount; ++i) {
+        if (!ma_dr_flac__read_uint8(bs, 8, utf8 + i)) {
+            *pNumberOut = 0;
+            return MA_AT_END;
+        }
+        crc = ma_dr_flac_crc8(crc, utf8[i], 8);
+        result = (result << 6) | (utf8[i] & 0x3F);
+    }
+    *pNumberOut = result;
+    *pCRCOut = crc;
+    return MA_SUCCESS;
+}
+static MA_INLINE ma_uint32 ma_dr_flac__ilog2_u32(ma_uint32 x)
+{
+#if 1
+    ma_uint32 result = 0;
+    while (x > 0) {
+        result += 1;
+        x >>= 1;
+    }
+    return result;
+#endif
+}
+static MA_INLINE ma_bool32 ma_dr_flac__use_64_bit_prediction(ma_uint32 bitsPerSample, ma_uint32 order, ma_uint32 precision)
+{
+    return bitsPerSample + precision + ma_dr_flac__ilog2_u32(order) > 32;
+}
+#if defined(__clang__)
+__attribute__((no_sanitize("signed-integer-overflow")))
+#endif
+static MA_INLINE ma_int32 ma_dr_flac__calculate_prediction_32(ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pDecodedSamples)
+{
+    ma_int32 prediction = 0;
+    MA_DR_FLAC_ASSERT(order <= 32);
+    switch (order)
+    {
+    case 32: prediction += coefficients[31] * pDecodedSamples[-32];
+    case 31: prediction += coefficients[30] * pDecodedSamples[-31];
+    case 30: prediction += coefficients[29] * pDecodedSamples[-30];
+    case 29: prediction += coefficients[28] * pDecodedSamples[-29];
+    case 28: prediction += coefficients[27] * pDecodedSamples[-28];
+    case 27: prediction += coefficients[26] * pDecodedSamples[-27];
+    case 26: prediction += coefficients[25] * pDecodedSamples[-26];
+    case 25: prediction += coefficients[24] * pDecodedSamples[-25];
+    case 24: prediction += coefficients[23] * pDecodedSamples[-24];
+    case 23: prediction += coefficients[22] * pDecodedSamples[-23];
+    case 22: prediction += coefficients[21] * pDecodedSamples[-22];
+    case 21: prediction += coefficients[20] * pDecodedSamples[-21];
+    case 20: prediction += coefficients[19] * pDecodedSamples[-20];
+    case 19: prediction += coefficients[18] * pDecodedSamples[-19];
+    case 18: prediction += coefficients[17] * pDecodedSamples[-18];
+    case 17: prediction += coefficients[16] * pDecodedSamples[-17];
+    case 16: prediction += coefficients[15] * pDecodedSamples[-16];
+    case 15: prediction += coefficients[14] * pDecodedSamples[-15];
+    case 14: prediction += coefficients[13] * pDecodedSamples[-14];
+    case 13: prediction += coefficients[12] * pDecodedSamples[-13];
+    case 12: prediction += coefficients[11] * pDecodedSamples[-12];
+    case 11: prediction += coefficients[10] * pDecodedSamples[-11];
+    case 10: prediction += coefficients[ 9] * pDecodedSamples[-10];
+    case  9: prediction += coefficients[ 8] * pDecodedSamples[- 9];
+    case  8: prediction += coefficients[ 7] * pDecodedSamples[- 8];
+    case  7: prediction += coefficients[ 6] * pDecodedSamples[- 7];
+    case  6: prediction += coefficients[ 5] * pDecodedSamples[- 6];
+    case  5: prediction += coefficients[ 4] * pDecodedSamples[- 5];
+    case  4: prediction += coefficients[ 3] * pDecodedSamples[- 4];
+    case  3: prediction += coefficients[ 2] * pDecodedSamples[- 3];
+    case  2: prediction += coefficients[ 1] * pDecodedSamples[- 2];
+    case  1: prediction += coefficients[ 0] * pDecodedSamples[- 1];
+    }
+    return (ma_int32)(prediction >> shift);
+}
+static MA_INLINE ma_int32 ma_dr_flac__calculate_prediction_64(ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pDecodedSamples)
+{
+    ma_int64 prediction;
+    MA_DR_FLAC_ASSERT(order <= 32);
+#ifndef MA_64BIT
+    if (order == 8)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3] * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4] * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5] * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6] * (ma_int64)pDecodedSamples[-7];
+        prediction += coefficients[7] * (ma_int64)pDecodedSamples[-8];
+    }
+    else if (order == 7)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3] * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4] * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5] * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6] * (ma_int64)pDecodedSamples[-7];
+    }
+    else if (order == 3)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+    }
+    else if (order == 6)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3] * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4] * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5] * (ma_int64)pDecodedSamples[-6];
+    }
+    else if (order == 5)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3] * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4] * (ma_int64)pDecodedSamples[-5];
+    }
+    else if (order == 4)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2] * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3] * (ma_int64)pDecodedSamples[-4];
+    }
+    else if (order == 12)
+    {
+        prediction  = coefficients[0]  * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1]  * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2]  * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3]  * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4]  * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5]  * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6]  * (ma_int64)pDecodedSamples[-7];
+        prediction += coefficients[7]  * (ma_int64)pDecodedSamples[-8];
+        prediction += coefficients[8]  * (ma_int64)pDecodedSamples[-9];
+        prediction += coefficients[9]  * (ma_int64)pDecodedSamples[-10];
+        prediction += coefficients[10] * (ma_int64)pDecodedSamples[-11];
+        prediction += coefficients[11] * (ma_int64)pDecodedSamples[-12];
+    }
+    else if (order == 2)
+    {
+        prediction  = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1] * (ma_int64)pDecodedSamples[-2];
+    }
+    else if (order == 1)
+    {
+        prediction = coefficients[0] * (ma_int64)pDecodedSamples[-1];
+    }
+    else if (order == 10)
+    {
+        prediction  = coefficients[0]  * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1]  * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2]  * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3]  * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4]  * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5]  * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6]  * (ma_int64)pDecodedSamples[-7];
+        prediction += coefficients[7]  * (ma_int64)pDecodedSamples[-8];
+        prediction += coefficients[8]  * (ma_int64)pDecodedSamples[-9];
+        prediction += coefficients[9]  * (ma_int64)pDecodedSamples[-10];
+    }
+    else if (order == 9)
+    {
+        prediction  = coefficients[0]  * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1]  * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2]  * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3]  * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4]  * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5]  * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6]  * (ma_int64)pDecodedSamples[-7];
+        prediction += coefficients[7]  * (ma_int64)pDecodedSamples[-8];
+        prediction += coefficients[8]  * (ma_int64)pDecodedSamples[-9];
+    }
+    else if (order == 11)
+    {
+        prediction  = coefficients[0]  * (ma_int64)pDecodedSamples[-1];
+        prediction += coefficients[1]  * (ma_int64)pDecodedSamples[-2];
+        prediction += coefficients[2]  * (ma_int64)pDecodedSamples[-3];
+        prediction += coefficients[3]  * (ma_int64)pDecodedSamples[-4];
+        prediction += coefficients[4]  * (ma_int64)pDecodedSamples[-5];
+        prediction += coefficients[5]  * (ma_int64)pDecodedSamples[-6];
+        prediction += coefficients[6]  * (ma_int64)pDecodedSamples[-7];
+        prediction += coefficients[7]  * (ma_int64)pDecodedSamples[-8];
+        prediction += coefficients[8]  * (ma_int64)pDecodedSamples[-9];
+        prediction += coefficients[9]  * (ma_int64)pDecodedSamples[-10];
+        prediction += coefficients[10] * (ma_int64)pDecodedSamples[-11];
+    }
+    else
+    {
+        int j;
+        prediction = 0;
+        for (j = 0; j < (int)order; ++j) {
+            prediction += coefficients[j] * (ma_int64)pDecodedSamples[-j-1];
+        }
+    }
+#endif
+#ifdef MA_64BIT
+    prediction = 0;
+    switch (order)
+    {
+    case 32: prediction += coefficients[31] * (ma_int64)pDecodedSamples[-32];
+    case 31: prediction += coefficients[30] * (ma_int64)pDecodedSamples[-31];
+    case 30: prediction += coefficients[29] * (ma_int64)pDecodedSamples[-30];
+    case 29: prediction += coefficients[28] * (ma_int64)pDecodedSamples[-29];
+    case 28: prediction += coefficients[27] * (ma_int64)pDecodedSamples[-28];
+    case 27: prediction += coefficients[26] * (ma_int64)pDecodedSamples[-27];
+    case 26: prediction += coefficients[25] * (ma_int64)pDecodedSamples[-26];
+    case 25: prediction += coefficients[24] * (ma_int64)pDecodedSamples[-25];
+    case 24: prediction += coefficients[23] * (ma_int64)pDecodedSamples[-24];
+    case 23: prediction += coefficients[22] * (ma_int64)pDecodedSamples[-23];
+    case 22: prediction += coefficients[21] * (ma_int64)pDecodedSamples[-22];
+    case 21: prediction += coefficients[20] * (ma_int64)pDecodedSamples[-21];
+    case 20: prediction += coefficients[19] * (ma_int64)pDecodedSamples[-20];
+    case 19: prediction += coefficients[18] * (ma_int64)pDecodedSamples[-19];
+    case 18: prediction += coefficients[17] * (ma_int64)pDecodedSamples[-18];
+    case 17: prediction += coefficients[16] * (ma_int64)pDecodedSamples[-17];
+    case 16: prediction += coefficients[15] * (ma_int64)pDecodedSamples[-16];
+    case 15: prediction += coefficients[14] * (ma_int64)pDecodedSamples[-15];
+    case 14: prediction += coefficients[13] * (ma_int64)pDecodedSamples[-14];
+    case 13: prediction += coefficients[12] * (ma_int64)pDecodedSamples[-13];
+    case 12: prediction += coefficients[11] * (ma_int64)pDecodedSamples[-12];
+    case 11: prediction += coefficients[10] * (ma_int64)pDecodedSamples[-11];
+    case 10: prediction += coefficients[ 9] * (ma_int64)pDecodedSamples[-10];
+    case  9: prediction += coefficients[ 8] * (ma_int64)pDecodedSamples[- 9];
+    case  8: prediction += coefficients[ 7] * (ma_int64)pDecodedSamples[- 8];
+    case  7: prediction += coefficients[ 6] * (ma_int64)pDecodedSamples[- 7];
+    case  6: prediction += coefficients[ 5] * (ma_int64)pDecodedSamples[- 6];
+    case  5: prediction += coefficients[ 4] * (ma_int64)pDecodedSamples[- 5];
+    case  4: prediction += coefficients[ 3] * (ma_int64)pDecodedSamples[- 4];
+    case  3: prediction += coefficients[ 2] * (ma_int64)pDecodedSamples[- 3];
+    case  2: prediction += coefficients[ 1] * (ma_int64)pDecodedSamples[- 2];
+    case  1: prediction += coefficients[ 0] * (ma_int64)pDecodedSamples[- 1];
+    }
+#endif
+    return (ma_int32)(prediction >> shift);
+}
+#if 0
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__reference(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    for (i = 0; i < count; ++i) {
+        ma_uint32 zeroCounter = 0;
+        for (;;) {
+            ma_uint8 bit;
+            if (!ma_dr_flac__read_uint8(bs, 1, &bit)) {
+                return MA_FALSE;
+            }
+            if (bit == 0) {
+                zeroCounter += 1;
+            } else {
+                break;
+            }
+        }
+        ma_uint32 decodedRice;
+        if (riceParam > 0) {
+            if (!ma_dr_flac__read_uint32(bs, riceParam, &decodedRice)) {
+                return MA_FALSE;
+            }
+        } else {
+            decodedRice = 0;
+        }
+        decodedRice |= (zeroCounter << riceParam);
+        if ((decodedRice & 0x01)) {
+            decodedRice = ~(decodedRice >> 1);
+        } else {
+            decodedRice =  (decodedRice >> 1);
+        }
+        if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+            pSamplesOut[i] = decodedRice + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+        } else {
+            pSamplesOut[i] = decodedRice + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+        }
+    }
+    return MA_TRUE;
+}
+#endif
+#if 0
+static ma_bool32 ma_dr_flac__read_rice_parts__reference(ma_dr_flac_bs* bs, ma_uint8 riceParam, ma_uint32* pZeroCounterOut, ma_uint32* pRiceParamPartOut)
+{
+    ma_uint32 zeroCounter = 0;
+    ma_uint32 decodedRice;
+    for (;;) {
+        ma_uint8 bit;
+        if (!ma_dr_flac__read_uint8(bs, 1, &bit)) {
+            return MA_FALSE;
+        }
+        if (bit == 0) {
+            zeroCounter += 1;
+        } else {
+            break;
+        }
+    }
+    if (riceParam > 0) {
+        if (!ma_dr_flac__read_uint32(bs, riceParam, &decodedRice)) {
+            return MA_FALSE;
+        }
+    } else {
+        decodedRice = 0;
+    }
+    *pZeroCounterOut = zeroCounter;
+    *pRiceParamPartOut = decodedRice;
+    return MA_TRUE;
+}
+#endif
+#if 0
+static MA_INLINE ma_bool32 ma_dr_flac__read_rice_parts(ma_dr_flac_bs* bs, ma_uint8 riceParam, ma_uint32* pZeroCounterOut, ma_uint32* pRiceParamPartOut)
+{
+    ma_dr_flac_cache_t riceParamMask;
+    ma_uint32 zeroCounter;
+    ma_uint32 setBitOffsetPlus1;
+    ma_uint32 riceParamPart;
+    ma_uint32 riceLength;
+    MA_DR_FLAC_ASSERT(riceParam > 0);
+    riceParamMask = MA_DR_FLAC_CACHE_L1_SELECTION_MASK(riceParam);
+    zeroCounter = 0;
+    while (bs->cache == 0) {
+        zeroCounter += (ma_uint32)MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs);
+        if (!ma_dr_flac__reload_cache(bs)) {
+            return MA_FALSE;
+        }
+    }
+    setBitOffsetPlus1 = ma_dr_flac__clz(bs->cache);
+    zeroCounter += setBitOffsetPlus1;
+    setBitOffsetPlus1 += 1;
+    riceLength = setBitOffsetPlus1 + riceParam;
+    if (riceLength < MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+        riceParamPart = (ma_uint32)((bs->cache & (riceParamMask >> setBitOffsetPlus1)) >> MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT(bs, riceLength));
+        bs->consumedBits += riceLength;
+        bs->cache <<= riceLength;
+    } else {
+        ma_uint32 bitCountLo;
+        ma_dr_flac_cache_t resultHi;
+        bs->consumedBits += riceLength;
+        bs->cache <<= setBitOffsetPlus1 & (MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs)-1);
+        bitCountLo = bs->consumedBits - MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs);
+        resultHi = MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT(bs, riceParam);
+        if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+#ifndef MA_DR_FLAC_NO_CRC
+            ma_dr_flac__update_crc16(bs);
+#endif
+            bs->cache = ma_dr_flac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+            bs->consumedBits = 0;
+#ifndef MA_DR_FLAC_NO_CRC
+            bs->crc16Cache = bs->cache;
+#endif
+        } else {
+            if (!ma_dr_flac__reload_cache(bs)) {
+                return MA_FALSE;
+            }
+            if (bitCountLo > MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+                return MA_FALSE;
+            }
+        }
+        riceParamPart = (ma_uint32)(resultHi | MA_DR_FLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE(bs, bitCountLo));
+        bs->consumedBits += bitCountLo;
+        bs->cache <<= bitCountLo;
+    }
+    pZeroCounterOut[0] = zeroCounter;
+    pRiceParamPartOut[0] = riceParamPart;
+    return MA_TRUE;
+}
+#endif
+static MA_INLINE ma_bool32 ma_dr_flac__read_rice_parts_x1(ma_dr_flac_bs* bs, ma_uint8 riceParam, ma_uint32* pZeroCounterOut, ma_uint32* pRiceParamPartOut)
+{
+    ma_uint32  riceParamPlus1 = riceParam + 1;
+    ma_uint32  riceParamPlus1Shift = MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT(bs, riceParamPlus1);
+    ma_uint32  riceParamPlus1MaxConsumedBits = MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs) - riceParamPlus1;
+    ma_dr_flac_cache_t bs_cache = bs->cache;
+    ma_uint32  bs_consumedBits = bs->consumedBits;
+    ma_uint32  lzcount = ma_dr_flac__clz(bs_cache);
+    if (lzcount < sizeof(bs_cache)*8) {
+        pZeroCounterOut[0] = lzcount;
+    extract_rice_param_part:
+        bs_cache       <<= lzcount;
+        bs_consumedBits += lzcount;
+        if (bs_consumedBits <= riceParamPlus1MaxConsumedBits) {
+            pRiceParamPartOut[0] = (ma_uint32)(bs_cache >> riceParamPlus1Shift);
+            bs_cache       <<= riceParamPlus1;
+            bs_consumedBits += riceParamPlus1;
+        } else {
+            ma_uint32 riceParamPartHi;
+            ma_uint32 riceParamPartLo;
+            ma_uint32 riceParamPartLoBitCount;
+            riceParamPartHi = (ma_uint32)(bs_cache >> riceParamPlus1Shift);
+            riceParamPartLoBitCount = bs_consumedBits - riceParamPlus1MaxConsumedBits;
+            MA_DR_FLAC_ASSERT(riceParamPartLoBitCount > 0 && riceParamPartLoBitCount < 32);
+            if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+            #ifndef MA_DR_FLAC_NO_CRC
+                ma_dr_flac__update_crc16(bs);
+            #endif
+                bs_cache = ma_dr_flac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+                bs_consumedBits = riceParamPartLoBitCount;
+            #ifndef MA_DR_FLAC_NO_CRC
+                bs->crc16Cache = bs_cache;
+            #endif
+            } else {
+                if (!ma_dr_flac__reload_cache(bs)) {
+                    return MA_FALSE;
+                }
+                if (riceParamPartLoBitCount > MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+                    return MA_FALSE;
+                }
+                bs_cache = bs->cache;
+                bs_consumedBits = bs->consumedBits + riceParamPartLoBitCount;
+            }
+            riceParamPartLo = (ma_uint32)(bs_cache >> (MA_DR_FLAC_CACHE_L1_SELECTION_SHIFT(bs, riceParamPartLoBitCount)));
+            pRiceParamPartOut[0] = riceParamPartHi | riceParamPartLo;
+            bs_cache <<= riceParamPartLoBitCount;
+        }
+    } else {
+        ma_uint32 zeroCounter = (ma_uint32)(MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs) - bs_consumedBits);
+        for (;;) {
+            if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+            #ifndef MA_DR_FLAC_NO_CRC
+                ma_dr_flac__update_crc16(bs);
+            #endif
+                bs_cache = ma_dr_flac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+                bs_consumedBits = 0;
+            #ifndef MA_DR_FLAC_NO_CRC
+                bs->crc16Cache = bs_cache;
+            #endif
+            } else {
+                if (!ma_dr_flac__reload_cache(bs)) {
+                    return MA_FALSE;
+                }
+                bs_cache = bs->cache;
+                bs_consumedBits = bs->consumedBits;
+            }
+            lzcount = ma_dr_flac__clz(bs_cache);
+            zeroCounter += lzcount;
+            if (lzcount < sizeof(bs_cache)*8) {
+                break;
+            }
+        }
+        pZeroCounterOut[0] = zeroCounter;
+        goto extract_rice_param_part;
+    }
+    bs->cache = bs_cache;
+    bs->consumedBits = bs_consumedBits;
+    return MA_TRUE;
+}
+static MA_INLINE ma_bool32 ma_dr_flac__seek_rice_parts(ma_dr_flac_bs* bs, ma_uint8 riceParam)
+{
+    ma_uint32  riceParamPlus1 = riceParam + 1;
+    ma_uint32  riceParamPlus1MaxConsumedBits = MA_DR_FLAC_CACHE_L1_SIZE_BITS(bs) - riceParamPlus1;
+    ma_dr_flac_cache_t bs_cache = bs->cache;
+    ma_uint32  bs_consumedBits = bs->consumedBits;
+    ma_uint32  lzcount = ma_dr_flac__clz(bs_cache);
+    if (lzcount < sizeof(bs_cache)*8) {
+    extract_rice_param_part:
+        bs_cache       <<= lzcount;
+        bs_consumedBits += lzcount;
+        if (bs_consumedBits <= riceParamPlus1MaxConsumedBits) {
+            bs_cache       <<= riceParamPlus1;
+            bs_consumedBits += riceParamPlus1;
+        } else {
+            ma_uint32 riceParamPartLoBitCount = bs_consumedBits - riceParamPlus1MaxConsumedBits;
+            MA_DR_FLAC_ASSERT(riceParamPartLoBitCount > 0 && riceParamPartLoBitCount < 32);
+            if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+            #ifndef MA_DR_FLAC_NO_CRC
+                ma_dr_flac__update_crc16(bs);
+            #endif
+                bs_cache = ma_dr_flac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+                bs_consumedBits = riceParamPartLoBitCount;
+            #ifndef MA_DR_FLAC_NO_CRC
+                bs->crc16Cache = bs_cache;
+            #endif
+            } else {
+                if (!ma_dr_flac__reload_cache(bs)) {
+                    return MA_FALSE;
+                }
+                if (riceParamPartLoBitCount > MA_DR_FLAC_CACHE_L1_BITS_REMAINING(bs)) {
+                    return MA_FALSE;
+                }
+                bs_cache = bs->cache;
+                bs_consumedBits = bs->consumedBits + riceParamPartLoBitCount;
+            }
+            bs_cache <<= riceParamPartLoBitCount;
+        }
+    } else {
+        for (;;) {
+            if (bs->nextL2Line < MA_DR_FLAC_CACHE_L2_LINE_COUNT(bs)) {
+            #ifndef MA_DR_FLAC_NO_CRC
+                ma_dr_flac__update_crc16(bs);
+            #endif
+                bs_cache = ma_dr_flac__be2host__cache_line(bs->cacheL2[bs->nextL2Line++]);
+                bs_consumedBits = 0;
+            #ifndef MA_DR_FLAC_NO_CRC
+                bs->crc16Cache = bs_cache;
+            #endif
+            } else {
+                if (!ma_dr_flac__reload_cache(bs)) {
+                    return MA_FALSE;
+                }
+                bs_cache = bs->cache;
+                bs_consumedBits = bs->consumedBits;
+            }
+            lzcount = ma_dr_flac__clz(bs_cache);
+            if (lzcount < sizeof(bs_cache)*8) {
+                break;
+            }
+        }
+        goto extract_rice_param_part;
+    }
+    bs->cache = bs_cache;
+    bs->consumedBits = bs_consumedBits;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__scalar_zeroorder(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    ma_uint32 zeroCountPart0;
+    ma_uint32 riceParamPart0;
+    ma_uint32 riceParamMask;
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    (void)bitsPerSample;
+    (void)order;
+    (void)shift;
+    (void)coefficients;
+    riceParamMask  = (ma_uint32)~((~0UL) << riceParam);
+    i = 0;
+    while (i < count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0)) {
+            return MA_FALSE;
+        }
+        riceParamPart0 &= riceParamMask;
+        riceParamPart0 |= (zeroCountPart0 << riceParam);
+        riceParamPart0  = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+        pSamplesOut[i] = riceParamPart0;
+        i += 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__scalar(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    ma_uint32 zeroCountPart0 = 0;
+    ma_uint32 zeroCountPart1 = 0;
+    ma_uint32 zeroCountPart2 = 0;
+    ma_uint32 zeroCountPart3 = 0;
+    ma_uint32 riceParamPart0 = 0;
+    ma_uint32 riceParamPart1 = 0;
+    ma_uint32 riceParamPart2 = 0;
+    ma_uint32 riceParamPart3 = 0;
+    ma_uint32 riceParamMask;
+    const ma_int32* pSamplesOutEnd;
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    if (lpcOrder == 0) {
+        return ma_dr_flac__decode_samples_with_residual__rice__scalar_zeroorder(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+    }
+    riceParamMask  = (ma_uint32)~((~0UL) << riceParam);
+    pSamplesOutEnd = pSamplesOut + (count & ~3);
+    if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+        while (pSamplesOut < pSamplesOutEnd) {
+            if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart1, &riceParamPart1) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart2, &riceParamPart2) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart3, &riceParamPart3)) {
+                return MA_FALSE;
+            }
+            riceParamPart0 &= riceParamMask;
+            riceParamPart1 &= riceParamMask;
+            riceParamPart2 &= riceParamMask;
+            riceParamPart3 &= riceParamMask;
+            riceParamPart0 |= (zeroCountPart0 << riceParam);
+            riceParamPart1 |= (zeroCountPart1 << riceParam);
+            riceParamPart2 |= (zeroCountPart2 << riceParam);
+            riceParamPart3 |= (zeroCountPart3 << riceParam);
+            riceParamPart0  = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+            riceParamPart1  = (riceParamPart1 >> 1) ^ t[riceParamPart1 & 0x01];
+            riceParamPart2  = (riceParamPart2 >> 1) ^ t[riceParamPart2 & 0x01];
+            riceParamPart3  = (riceParamPart3 >> 1) ^ t[riceParamPart3 & 0x01];
+            pSamplesOut[0] = riceParamPart0 + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+            pSamplesOut[1] = riceParamPart1 + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 1);
+            pSamplesOut[2] = riceParamPart2 + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 2);
+            pSamplesOut[3] = riceParamPart3 + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 3);
+            pSamplesOut += 4;
+        }
+    } else {
+        while (pSamplesOut < pSamplesOutEnd) {
+            if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart1, &riceParamPart1) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart2, &riceParamPart2) ||
+                !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart3, &riceParamPart3)) {
+                return MA_FALSE;
+            }
+            riceParamPart0 &= riceParamMask;
+            riceParamPart1 &= riceParamMask;
+            riceParamPart2 &= riceParamMask;
+            riceParamPart3 &= riceParamMask;
+            riceParamPart0 |= (zeroCountPart0 << riceParam);
+            riceParamPart1 |= (zeroCountPart1 << riceParam);
+            riceParamPart2 |= (zeroCountPart2 << riceParam);
+            riceParamPart3 |= (zeroCountPart3 << riceParam);
+            riceParamPart0  = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+            riceParamPart1  = (riceParamPart1 >> 1) ^ t[riceParamPart1 & 0x01];
+            riceParamPart2  = (riceParamPart2 >> 1) ^ t[riceParamPart2 & 0x01];
+            riceParamPart3  = (riceParamPart3 >> 1) ^ t[riceParamPart3 & 0x01];
+            pSamplesOut[0] = riceParamPart0 + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+            pSamplesOut[1] = riceParamPart1 + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 1);
+            pSamplesOut[2] = riceParamPart2 + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 2);
+            pSamplesOut[3] = riceParamPart3 + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 3);
+            pSamplesOut += 4;
+        }
+    }
+    i = (count & ~3);
+    while (i < count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0)) {
+            return MA_FALSE;
+        }
+        riceParamPart0 &= riceParamMask;
+        riceParamPart0 |= (zeroCountPart0 << riceParam);
+        riceParamPart0  = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
+        if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+            pSamplesOut[0] = riceParamPart0 + ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+        } else {
+            pSamplesOut[0] = riceParamPart0 + ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+        }
+        i += 1;
+        pSamplesOut += 1;
+    }
+    return MA_TRUE;
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE __m128i ma_dr_flac__mm_packs_interleaved_epi32(__m128i a, __m128i b)
+{
+    __m128i r;
+    r = _mm_packs_epi32(a, b);
+    r = _mm_shuffle_epi32(r, _MM_SHUFFLE(3, 1, 2, 0));
+    r = _mm_shufflehi_epi16(r, _MM_SHUFFLE(3, 1, 2, 0));
+    r = _mm_shufflelo_epi16(r, _MM_SHUFFLE(3, 1, 2, 0));
+    return r;
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_SSE41)
+static MA_INLINE __m128i ma_dr_flac__mm_not_si128(__m128i a)
+{
+    return _mm_xor_si128(a, _mm_cmpeq_epi32(_mm_setzero_si128(), _mm_setzero_si128()));
+}
+static MA_INLINE __m128i ma_dr_flac__mm_hadd_epi32(__m128i x)
+{
+    __m128i x64 = _mm_add_epi32(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2)));
+    __m128i x32 = _mm_shufflelo_epi16(x64, _MM_SHUFFLE(1, 0, 3, 2));
+    return _mm_add_epi32(x64, x32);
+}
+static MA_INLINE __m128i ma_dr_flac__mm_hadd_epi64(__m128i x)
+{
+    return _mm_add_epi64(x, _mm_shuffle_epi32(x, _MM_SHUFFLE(1, 0, 3, 2)));
+}
+static MA_INLINE __m128i ma_dr_flac__mm_srai_epi64(__m128i x, int count)
+{
+    __m128i lo = _mm_srli_epi64(x, count);
+    __m128i hi = _mm_srai_epi32(x, count);
+    hi = _mm_and_si128(hi, _mm_set_epi32(0xFFFFFFFF, 0, 0xFFFFFFFF, 0));
+    return _mm_or_si128(lo, hi);
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__sse41_32(ma_dr_flac_bs* bs, ma_uint32 count, ma_uint8 riceParam, ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    int i;
+    ma_uint32 riceParamMask;
+    ma_int32* pDecodedSamples    = pSamplesOut;
+    ma_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+    ma_uint32 zeroCountParts0 = 0;
+    ma_uint32 zeroCountParts1 = 0;
+    ma_uint32 zeroCountParts2 = 0;
+    ma_uint32 zeroCountParts3 = 0;
+    ma_uint32 riceParamParts0 = 0;
+    ma_uint32 riceParamParts1 = 0;
+    ma_uint32 riceParamParts2 = 0;
+    ma_uint32 riceParamParts3 = 0;
+    __m128i coefficients128_0;
+    __m128i coefficients128_4;
+    __m128i coefficients128_8;
+    __m128i samples128_0;
+    __m128i samples128_4;
+    __m128i samples128_8;
+    __m128i riceParamMask128;
+    const ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    riceParamMask    = (ma_uint32)~((~0UL) << riceParam);
+    riceParamMask128 = _mm_set1_epi32(riceParamMask);
+    coefficients128_0 = _mm_setzero_si128();
+    coefficients128_4 = _mm_setzero_si128();
+    coefficients128_8 = _mm_setzero_si128();
+    samples128_0 = _mm_setzero_si128();
+    samples128_4 = _mm_setzero_si128();
+    samples128_8 = _mm_setzero_si128();
+#if 1
+    {
+        int runningOrder = order;
+        if (runningOrder >= 4) {
+            coefficients128_0 = _mm_loadu_si128((const __m128i*)(coefficients + 0));
+            samples128_0      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 4));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_0 = _mm_set_epi32(0, coefficients[2], coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], pSamplesOut[-3], 0); break;
+                case 2: coefficients128_0 = _mm_set_epi32(0, 0,               coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], 0,               0); break;
+                case 1: coefficients128_0 = _mm_set_epi32(0, 0,               0,               coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], 0,               0,               0); break;
+            }
+            runningOrder = 0;
+        }
+        if (runningOrder >= 4) {
+            coefficients128_4 = _mm_loadu_si128((const __m128i*)(coefficients + 4));
+            samples128_4      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 8));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_4 = _mm_set_epi32(0, coefficients[6], coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], pSamplesOut[-7], 0); break;
+                case 2: coefficients128_4 = _mm_set_epi32(0, 0,               coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], 0,               0); break;
+                case 1: coefficients128_4 = _mm_set_epi32(0, 0,               0,               coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], 0,               0,               0); break;
+            }
+            runningOrder = 0;
+        }
+        if (runningOrder == 4) {
+            coefficients128_8 = _mm_loadu_si128((const __m128i*)(coefficients + 8));
+            samples128_8      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 12));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_8 = _mm_set_epi32(0, coefficients[10], coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], pSamplesOut[-11], 0); break;
+                case 2: coefficients128_8 = _mm_set_epi32(0, 0,                coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], 0,                0); break;
+                case 1: coefficients128_8 = _mm_set_epi32(0, 0,                0,               coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], 0,                0,                0); break;
+            }
+            runningOrder = 0;
+        }
+        coefficients128_0 = _mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(0, 1, 2, 3));
+        coefficients128_4 = _mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(0, 1, 2, 3));
+        coefficients128_8 = _mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(0, 1, 2, 3));
+    }
+#else
+    switch (order)
+    {
+    case 12: ((ma_int32*)&coefficients128_8)[0] = coefficients[11]; ((ma_int32*)&samples128_8)[0] = pDecodedSamples[-12];
+    case 11: ((ma_int32*)&coefficients128_8)[1] = coefficients[10]; ((ma_int32*)&samples128_8)[1] = pDecodedSamples[-11];
+    case 10: ((ma_int32*)&coefficients128_8)[2] = coefficients[ 9]; ((ma_int32*)&samples128_8)[2] = pDecodedSamples[-10];
+    case 9:  ((ma_int32*)&coefficients128_8)[3] = coefficients[ 8]; ((ma_int32*)&samples128_8)[3] = pDecodedSamples[- 9];
+    case 8:  ((ma_int32*)&coefficients128_4)[0] = coefficients[ 7]; ((ma_int32*)&samples128_4)[0] = pDecodedSamples[- 8];
+    case 7:  ((ma_int32*)&coefficients128_4)[1] = coefficients[ 6]; ((ma_int32*)&samples128_4)[1] = pDecodedSamples[- 7];
+    case 6:  ((ma_int32*)&coefficients128_4)[2] = coefficients[ 5]; ((ma_int32*)&samples128_4)[2] = pDecodedSamples[- 6];
+    case 5:  ((ma_int32*)&coefficients128_4)[3] = coefficients[ 4]; ((ma_int32*)&samples128_4)[3] = pDecodedSamples[- 5];
+    case 4:  ((ma_int32*)&coefficients128_0)[0] = coefficients[ 3]; ((ma_int32*)&samples128_0)[0] = pDecodedSamples[- 4];
+    case 3:  ((ma_int32*)&coefficients128_0)[1] = coefficients[ 2]; ((ma_int32*)&samples128_0)[1] = pDecodedSamples[- 3];
+    case 2:  ((ma_int32*)&coefficients128_0)[2] = coefficients[ 1]; ((ma_int32*)&samples128_0)[2] = pDecodedSamples[- 2];
+    case 1:  ((ma_int32*)&coefficients128_0)[3] = coefficients[ 0]; ((ma_int32*)&samples128_0)[3] = pDecodedSamples[- 1];
+    }
+#endif
+    while (pDecodedSamples < pDecodedSamplesEnd) {
+        __m128i prediction128;
+        __m128i zeroCountPart128;
+        __m128i riceParamPart128;
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts1, &riceParamParts1) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts2, &riceParamParts2) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts3, &riceParamParts3)) {
+            return MA_FALSE;
+        }
+        zeroCountPart128 = _mm_set_epi32(zeroCountParts3, zeroCountParts2, zeroCountParts1, zeroCountParts0);
+        riceParamPart128 = _mm_set_epi32(riceParamParts3, riceParamParts2, riceParamParts1, riceParamParts0);
+        riceParamPart128 = _mm_and_si128(riceParamPart128, riceParamMask128);
+        riceParamPart128 = _mm_or_si128(riceParamPart128, _mm_slli_epi32(zeroCountPart128, riceParam));
+        riceParamPart128 = _mm_xor_si128(_mm_srli_epi32(riceParamPart128, 1), _mm_add_epi32(ma_dr_flac__mm_not_si128(_mm_and_si128(riceParamPart128, _mm_set1_epi32(0x01))), _mm_set1_epi32(0x01)));
+        if (order <= 4) {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 = _mm_mullo_epi32(coefficients128_0, samples128_0);
+                prediction128 = ma_dr_flac__mm_hadd_epi32(prediction128);
+                prediction128 = _mm_srai_epi32(prediction128, shift);
+                prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+                samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+                riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+            }
+        } else if (order <= 8) {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 =                              _mm_mullo_epi32(coefficients128_4, samples128_4);
+                prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_0, samples128_0));
+                prediction128 = ma_dr_flac__mm_hadd_epi32(prediction128);
+                prediction128 = _mm_srai_epi32(prediction128, shift);
+                prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+                samples128_4 = _mm_alignr_epi8(samples128_0,  samples128_4, 4);
+                samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+                riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+            }
+        } else {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 =                              _mm_mullo_epi32(coefficients128_8, samples128_8);
+                prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_4, samples128_4));
+                prediction128 = _mm_add_epi32(prediction128, _mm_mullo_epi32(coefficients128_0, samples128_0));
+                prediction128 = ma_dr_flac__mm_hadd_epi32(prediction128);
+                prediction128 = _mm_srai_epi32(prediction128, shift);
+                prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+                samples128_8 = _mm_alignr_epi8(samples128_4,  samples128_8, 4);
+                samples128_4 = _mm_alignr_epi8(samples128_0,  samples128_4, 4);
+                samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+                riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+            }
+        }
+        _mm_storeu_si128((__m128i*)pDecodedSamples, samples128_0);
+        pDecodedSamples += 4;
+    }
+    i = (count & ~3);
+    while (i < (int)count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0)) {
+            return MA_FALSE;
+        }
+        riceParamParts0 &= riceParamMask;
+        riceParamParts0 |= (zeroCountParts0 << riceParam);
+        riceParamParts0  = (riceParamParts0 >> 1) ^ t[riceParamParts0 & 0x01];
+        pDecodedSamples[0] = riceParamParts0 + ma_dr_flac__calculate_prediction_32(order, shift, coefficients, pDecodedSamples);
+        i += 1;
+        pDecodedSamples += 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__sse41_64(ma_dr_flac_bs* bs, ma_uint32 count, ma_uint8 riceParam, ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    int i;
+    ma_uint32 riceParamMask;
+    ma_int32* pDecodedSamples    = pSamplesOut;
+    ma_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+    ma_uint32 zeroCountParts0 = 0;
+    ma_uint32 zeroCountParts1 = 0;
+    ma_uint32 zeroCountParts2 = 0;
+    ma_uint32 zeroCountParts3 = 0;
+    ma_uint32 riceParamParts0 = 0;
+    ma_uint32 riceParamParts1 = 0;
+    ma_uint32 riceParamParts2 = 0;
+    ma_uint32 riceParamParts3 = 0;
+    __m128i coefficients128_0;
+    __m128i coefficients128_4;
+    __m128i coefficients128_8;
+    __m128i samples128_0;
+    __m128i samples128_4;
+    __m128i samples128_8;
+    __m128i prediction128;
+    __m128i riceParamMask128;
+    const ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    MA_DR_FLAC_ASSERT(order <= 12);
+    riceParamMask    = (ma_uint32)~((~0UL) << riceParam);
+    riceParamMask128 = _mm_set1_epi32(riceParamMask);
+    prediction128 = _mm_setzero_si128();
+    coefficients128_0  = _mm_setzero_si128();
+    coefficients128_4  = _mm_setzero_si128();
+    coefficients128_8  = _mm_setzero_si128();
+    samples128_0  = _mm_setzero_si128();
+    samples128_4  = _mm_setzero_si128();
+    samples128_8  = _mm_setzero_si128();
+#if 1
+    {
+        int runningOrder = order;
+        if (runningOrder >= 4) {
+            coefficients128_0 = _mm_loadu_si128((const __m128i*)(coefficients + 0));
+            samples128_0      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 4));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_0 = _mm_set_epi32(0, coefficients[2], coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], pSamplesOut[-3], 0); break;
+                case 2: coefficients128_0 = _mm_set_epi32(0, 0,               coefficients[1], coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], pSamplesOut[-2], 0,               0); break;
+                case 1: coefficients128_0 = _mm_set_epi32(0, 0,               0,               coefficients[0]); samples128_0 = _mm_set_epi32(pSamplesOut[-1], 0,               0,               0); break;
+            }
+            runningOrder = 0;
+        }
+        if (runningOrder >= 4) {
+            coefficients128_4 = _mm_loadu_si128((const __m128i*)(coefficients + 4));
+            samples128_4      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 8));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_4 = _mm_set_epi32(0, coefficients[6], coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], pSamplesOut[-7], 0); break;
+                case 2: coefficients128_4 = _mm_set_epi32(0, 0,               coefficients[5], coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], pSamplesOut[-6], 0,               0); break;
+                case 1: coefficients128_4 = _mm_set_epi32(0, 0,               0,               coefficients[4]); samples128_4 = _mm_set_epi32(pSamplesOut[-5], 0,               0,               0); break;
+            }
+            runningOrder = 0;
+        }
+        if (runningOrder == 4) {
+            coefficients128_8 = _mm_loadu_si128((const __m128i*)(coefficients + 8));
+            samples128_8      = _mm_loadu_si128((const __m128i*)(pSamplesOut  - 12));
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: coefficients128_8 = _mm_set_epi32(0, coefficients[10], coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], pSamplesOut[-11], 0); break;
+                case 2: coefficients128_8 = _mm_set_epi32(0, 0,                coefficients[9], coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], pSamplesOut[-10], 0,                0); break;
+                case 1: coefficients128_8 = _mm_set_epi32(0, 0,                0,               coefficients[8]); samples128_8 = _mm_set_epi32(pSamplesOut[-9], 0,                0,                0); break;
+            }
+            runningOrder = 0;
+        }
+        coefficients128_0 = _mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(0, 1, 2, 3));
+        coefficients128_4 = _mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(0, 1, 2, 3));
+        coefficients128_8 = _mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(0, 1, 2, 3));
+    }
+#else
+    switch (order)
+    {
+    case 12: ((ma_int32*)&coefficients128_8)[0] = coefficients[11]; ((ma_int32*)&samples128_8)[0] = pDecodedSamples[-12];
+    case 11: ((ma_int32*)&coefficients128_8)[1] = coefficients[10]; ((ma_int32*)&samples128_8)[1] = pDecodedSamples[-11];
+    case 10: ((ma_int32*)&coefficients128_8)[2] = coefficients[ 9]; ((ma_int32*)&samples128_8)[2] = pDecodedSamples[-10];
+    case 9:  ((ma_int32*)&coefficients128_8)[3] = coefficients[ 8]; ((ma_int32*)&samples128_8)[3] = pDecodedSamples[- 9];
+    case 8:  ((ma_int32*)&coefficients128_4)[0] = coefficients[ 7]; ((ma_int32*)&samples128_4)[0] = pDecodedSamples[- 8];
+    case 7:  ((ma_int32*)&coefficients128_4)[1] = coefficients[ 6]; ((ma_int32*)&samples128_4)[1] = pDecodedSamples[- 7];
+    case 6:  ((ma_int32*)&coefficients128_4)[2] = coefficients[ 5]; ((ma_int32*)&samples128_4)[2] = pDecodedSamples[- 6];
+    case 5:  ((ma_int32*)&coefficients128_4)[3] = coefficients[ 4]; ((ma_int32*)&samples128_4)[3] = pDecodedSamples[- 5];
+    case 4:  ((ma_int32*)&coefficients128_0)[0] = coefficients[ 3]; ((ma_int32*)&samples128_0)[0] = pDecodedSamples[- 4];
+    case 3:  ((ma_int32*)&coefficients128_0)[1] = coefficients[ 2]; ((ma_int32*)&samples128_0)[1] = pDecodedSamples[- 3];
+    case 2:  ((ma_int32*)&coefficients128_0)[2] = coefficients[ 1]; ((ma_int32*)&samples128_0)[2] = pDecodedSamples[- 2];
+    case 1:  ((ma_int32*)&coefficients128_0)[3] = coefficients[ 0]; ((ma_int32*)&samples128_0)[3] = pDecodedSamples[- 1];
+    }
+#endif
+    while (pDecodedSamples < pDecodedSamplesEnd) {
+        __m128i zeroCountPart128;
+        __m128i riceParamPart128;
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts1, &riceParamParts1) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts2, &riceParamParts2) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts3, &riceParamParts3)) {
+            return MA_FALSE;
+        }
+        zeroCountPart128 = _mm_set_epi32(zeroCountParts3, zeroCountParts2, zeroCountParts1, zeroCountParts0);
+        riceParamPart128 = _mm_set_epi32(riceParamParts3, riceParamParts2, riceParamParts1, riceParamParts0);
+        riceParamPart128 = _mm_and_si128(riceParamPart128, riceParamMask128);
+        riceParamPart128 = _mm_or_si128(riceParamPart128, _mm_slli_epi32(zeroCountPart128, riceParam));
+        riceParamPart128 = _mm_xor_si128(_mm_srli_epi32(riceParamPart128, 1), _mm_add_epi32(ma_dr_flac__mm_not_si128(_mm_and_si128(riceParamPart128, _mm_set1_epi32(1))), _mm_set1_epi32(1)));
+        for (i = 0; i < 4; i += 1) {
+            prediction128 = _mm_xor_si128(prediction128, prediction128);
+            switch (order)
+            {
+            case 12:
+            case 11: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_8, _MM_SHUFFLE(1, 1, 0, 0))));
+            case 10:
+            case  9: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_8, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_8, _MM_SHUFFLE(3, 3, 2, 2))));
+            case  8:
+            case  7: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_4, _MM_SHUFFLE(1, 1, 0, 0))));
+            case  6:
+            case  5: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_4, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_4, _MM_SHUFFLE(3, 3, 2, 2))));
+            case  4:
+            case  3: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(1, 1, 0, 0)), _mm_shuffle_epi32(samples128_0, _MM_SHUFFLE(1, 1, 0, 0))));
+            case  2:
+            case  1: prediction128 = _mm_add_epi64(prediction128, _mm_mul_epi32(_mm_shuffle_epi32(coefficients128_0, _MM_SHUFFLE(3, 3, 2, 2)), _mm_shuffle_epi32(samples128_0, _MM_SHUFFLE(3, 3, 2, 2))));
+            }
+            prediction128 = ma_dr_flac__mm_hadd_epi64(prediction128);
+            prediction128 = ma_dr_flac__mm_srai_epi64(prediction128, shift);
+            prediction128 = _mm_add_epi32(riceParamPart128, prediction128);
+            samples128_8 = _mm_alignr_epi8(samples128_4,  samples128_8, 4);
+            samples128_4 = _mm_alignr_epi8(samples128_0,  samples128_4, 4);
+            samples128_0 = _mm_alignr_epi8(prediction128, samples128_0, 4);
+            riceParamPart128 = _mm_alignr_epi8(_mm_setzero_si128(), riceParamPart128, 4);
+        }
+        _mm_storeu_si128((__m128i*)pDecodedSamples, samples128_0);
+        pDecodedSamples += 4;
+    }
+    i = (count & ~3);
+    while (i < (int)count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts0, &riceParamParts0)) {
+            return MA_FALSE;
+        }
+        riceParamParts0 &= riceParamMask;
+        riceParamParts0 |= (zeroCountParts0 << riceParam);
+        riceParamParts0  = (riceParamParts0 >> 1) ^ t[riceParamParts0 & 0x01];
+        pDecodedSamples[0] = riceParamParts0 + ma_dr_flac__calculate_prediction_64(order, shift, coefficients, pDecodedSamples);
+        i += 1;
+        pDecodedSamples += 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__sse41(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    if (lpcOrder > 0 && lpcOrder <= 12) {
+        if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+            return ma_dr_flac__decode_samples_with_residual__rice__sse41_64(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+        } else {
+            return ma_dr_flac__decode_samples_with_residual__rice__sse41_32(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+        }
+    } else {
+        return ma_dr_flac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac__vst2q_s32(ma_int32* p, int32x4x2_t x)
+{
+    vst1q_s32(p+0, x.val[0]);
+    vst1q_s32(p+4, x.val[1]);
+}
+static MA_INLINE void ma_dr_flac__vst2q_u32(ma_uint32* p, uint32x4x2_t x)
+{
+    vst1q_u32(p+0, x.val[0]);
+    vst1q_u32(p+4, x.val[1]);
+}
+static MA_INLINE void ma_dr_flac__vst2q_f32(float* p, float32x4x2_t x)
+{
+    vst1q_f32(p+0, x.val[0]);
+    vst1q_f32(p+4, x.val[1]);
+}
+static MA_INLINE void ma_dr_flac__vst2q_s16(ma_int16* p, int16x4x2_t x)
+{
+    vst1q_s16(p, vcombine_s16(x.val[0], x.val[1]));
+}
+static MA_INLINE void ma_dr_flac__vst2q_u16(ma_uint16* p, uint16x4x2_t x)
+{
+    vst1q_u16(p, vcombine_u16(x.val[0], x.val[1]));
+}
+static MA_INLINE int32x4_t ma_dr_flac__vdupq_n_s32x4(ma_int32 x3, ma_int32 x2, ma_int32 x1, ma_int32 x0)
+{
+    ma_int32 x[4];
+    x[3] = x3;
+    x[2] = x2;
+    x[1] = x1;
+    x[0] = x0;
+    return vld1q_s32(x);
+}
+static MA_INLINE int32x4_t ma_dr_flac__valignrq_s32_1(int32x4_t a, int32x4_t b)
+{
+    return vextq_s32(b, a, 1);
+}
+static MA_INLINE uint32x4_t ma_dr_flac__valignrq_u32_1(uint32x4_t a, uint32x4_t b)
+{
+    return vextq_u32(b, a, 1);
+}
+static MA_INLINE int32x2_t ma_dr_flac__vhaddq_s32(int32x4_t x)
+{
+    int32x2_t r = vadd_s32(vget_high_s32(x), vget_low_s32(x));
+    return vpadd_s32(r, r);
+}
+static MA_INLINE int64x1_t ma_dr_flac__vhaddq_s64(int64x2_t x)
+{
+    return vadd_s64(vget_high_s64(x), vget_low_s64(x));
+}
+static MA_INLINE int32x4_t ma_dr_flac__vrevq_s32(int32x4_t x)
+{
+    return vrev64q_s32(vcombine_s32(vget_high_s32(x), vget_low_s32(x)));
+}
+static MA_INLINE int32x4_t ma_dr_flac__vnotq_s32(int32x4_t x)
+{
+    return veorq_s32(x, vdupq_n_s32(0xFFFFFFFF));
+}
+static MA_INLINE uint32x4_t ma_dr_flac__vnotq_u32(uint32x4_t x)
+{
+    return veorq_u32(x, vdupq_n_u32(0xFFFFFFFF));
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__neon_32(ma_dr_flac_bs* bs, ma_uint32 count, ma_uint8 riceParam, ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    int i;
+    ma_uint32 riceParamMask;
+    ma_int32* pDecodedSamples    = pSamplesOut;
+    ma_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+    ma_uint32 zeroCountParts[4];
+    ma_uint32 riceParamParts[4];
+    int32x4_t coefficients128_0;
+    int32x4_t coefficients128_4;
+    int32x4_t coefficients128_8;
+    int32x4_t samples128_0;
+    int32x4_t samples128_4;
+    int32x4_t samples128_8;
+    uint32x4_t riceParamMask128;
+    int32x4_t riceParam128;
+    int32x2_t shift64;
+    uint32x4_t one128;
+    const ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    riceParamMask    = (ma_uint32)~((~0UL) << riceParam);
+    riceParamMask128 = vdupq_n_u32(riceParamMask);
+    riceParam128 = vdupq_n_s32(riceParam);
+    shift64 = vdup_n_s32(-shift);
+    one128 = vdupq_n_u32(1);
+    {
+        int runningOrder = order;
+        ma_int32 tempC[4] = {0, 0, 0, 0};
+        ma_int32 tempS[4] = {0, 0, 0, 0};
+        if (runningOrder >= 4) {
+            coefficients128_0 = vld1q_s32(coefficients + 0);
+            samples128_0      = vld1q_s32(pSamplesOut  - 4);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[2]; tempS[1] = pSamplesOut[-3];
+                case 2: tempC[1] = coefficients[1]; tempS[2] = pSamplesOut[-2];
+                case 1: tempC[0] = coefficients[0]; tempS[3] = pSamplesOut[-1];
+            }
+            coefficients128_0 = vld1q_s32(tempC);
+            samples128_0      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        if (runningOrder >= 4) {
+            coefficients128_4 = vld1q_s32(coefficients + 4);
+            samples128_4      = vld1q_s32(pSamplesOut  - 8);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[6]; tempS[1] = pSamplesOut[-7];
+                case 2: tempC[1] = coefficients[5]; tempS[2] = pSamplesOut[-6];
+                case 1: tempC[0] = coefficients[4]; tempS[3] = pSamplesOut[-5];
+            }
+            coefficients128_4 = vld1q_s32(tempC);
+            samples128_4      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        if (runningOrder == 4) {
+            coefficients128_8 = vld1q_s32(coefficients + 8);
+            samples128_8      = vld1q_s32(pSamplesOut  - 12);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[10]; tempS[1] = pSamplesOut[-11];
+                case 2: tempC[1] = coefficients[ 9]; tempS[2] = pSamplesOut[-10];
+                case 1: tempC[0] = coefficients[ 8]; tempS[3] = pSamplesOut[- 9];
+            }
+            coefficients128_8 = vld1q_s32(tempC);
+            samples128_8      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        coefficients128_0 = ma_dr_flac__vrevq_s32(coefficients128_0);
+        coefficients128_4 = ma_dr_flac__vrevq_s32(coefficients128_4);
+        coefficients128_8 = ma_dr_flac__vrevq_s32(coefficients128_8);
+    }
+    while (pDecodedSamples < pDecodedSamplesEnd) {
+        int32x4_t prediction128;
+        int32x2_t prediction64;
+        uint32x4_t zeroCountPart128;
+        uint32x4_t riceParamPart128;
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[1], &riceParamParts[1]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[2], &riceParamParts[2]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[3], &riceParamParts[3])) {
+            return MA_FALSE;
+        }
+        zeroCountPart128 = vld1q_u32(zeroCountParts);
+        riceParamPart128 = vld1q_u32(riceParamParts);
+        riceParamPart128 = vandq_u32(riceParamPart128, riceParamMask128);
+        riceParamPart128 = vorrq_u32(riceParamPart128, vshlq_u32(zeroCountPart128, riceParam128));
+        riceParamPart128 = veorq_u32(vshrq_n_u32(riceParamPart128, 1), vaddq_u32(ma_dr_flac__vnotq_u32(vandq_u32(riceParamPart128, one128)), one128));
+        if (order <= 4) {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 = vmulq_s32(coefficients128_0, samples128_0);
+                prediction64 = ma_dr_flac__vhaddq_s32(prediction128);
+                prediction64 = vshl_s32(prediction64, shift64);
+                prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128)));
+                samples128_0 = ma_dr_flac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0);
+                riceParamPart128 = ma_dr_flac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+            }
+        } else if (order <= 8) {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 =                vmulq_s32(coefficients128_4, samples128_4);
+                prediction128 = vmlaq_s32(prediction128, coefficients128_0, samples128_0);
+                prediction64 = ma_dr_flac__vhaddq_s32(prediction128);
+                prediction64 = vshl_s32(prediction64, shift64);
+                prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128)));
+                samples128_4 = ma_dr_flac__valignrq_s32_1(samples128_0, samples128_4);
+                samples128_0 = ma_dr_flac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0);
+                riceParamPart128 = ma_dr_flac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+            }
+        } else {
+            for (i = 0; i < 4; i += 1) {
+                prediction128 =                vmulq_s32(coefficients128_8, samples128_8);
+                prediction128 = vmlaq_s32(prediction128, coefficients128_4, samples128_4);
+                prediction128 = vmlaq_s32(prediction128, coefficients128_0, samples128_0);
+                prediction64 = ma_dr_flac__vhaddq_s32(prediction128);
+                prediction64 = vshl_s32(prediction64, shift64);
+                prediction64 = vadd_s32(prediction64, vget_low_s32(vreinterpretq_s32_u32(riceParamPart128)));
+                samples128_8 = ma_dr_flac__valignrq_s32_1(samples128_4, samples128_8);
+                samples128_4 = ma_dr_flac__valignrq_s32_1(samples128_0, samples128_4);
+                samples128_0 = ma_dr_flac__valignrq_s32_1(vcombine_s32(prediction64, vdup_n_s32(0)), samples128_0);
+                riceParamPart128 = ma_dr_flac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+            }
+        }
+        vst1q_s32(pDecodedSamples, samples128_0);
+        pDecodedSamples += 4;
+    }
+    i = (count & ~3);
+    while (i < (int)count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0])) {
+            return MA_FALSE;
+        }
+        riceParamParts[0] &= riceParamMask;
+        riceParamParts[0] |= (zeroCountParts[0] << riceParam);
+        riceParamParts[0]  = (riceParamParts[0] >> 1) ^ t[riceParamParts[0] & 0x01];
+        pDecodedSamples[0] = riceParamParts[0] + ma_dr_flac__calculate_prediction_32(order, shift, coefficients, pDecodedSamples);
+        i += 1;
+        pDecodedSamples += 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__neon_64(ma_dr_flac_bs* bs, ma_uint32 count, ma_uint8 riceParam, ma_uint32 order, ma_int32 shift, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    int i;
+    ma_uint32 riceParamMask;
+    ma_int32* pDecodedSamples    = pSamplesOut;
+    ma_int32* pDecodedSamplesEnd = pSamplesOut + (count & ~3);
+    ma_uint32 zeroCountParts[4];
+    ma_uint32 riceParamParts[4];
+    int32x4_t coefficients128_0;
+    int32x4_t coefficients128_4;
+    int32x4_t coefficients128_8;
+    int32x4_t samples128_0;
+    int32x4_t samples128_4;
+    int32x4_t samples128_8;
+    uint32x4_t riceParamMask128;
+    int32x4_t riceParam128;
+    int64x1_t shift64;
+    uint32x4_t one128;
+    int64x2_t prediction128 = { 0 };
+    uint32x4_t zeroCountPart128;
+    uint32x4_t riceParamPart128;
+    const ma_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
+    riceParamMask    = (ma_uint32)~((~0UL) << riceParam);
+    riceParamMask128 = vdupq_n_u32(riceParamMask);
+    riceParam128 = vdupq_n_s32(riceParam);
+    shift64 = vdup_n_s64(-shift);
+    one128 = vdupq_n_u32(1);
+    {
+        int runningOrder = order;
+        ma_int32 tempC[4] = {0, 0, 0, 0};
+        ma_int32 tempS[4] = {0, 0, 0, 0};
+        if (runningOrder >= 4) {
+            coefficients128_0 = vld1q_s32(coefficients + 0);
+            samples128_0      = vld1q_s32(pSamplesOut  - 4);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[2]; tempS[1] = pSamplesOut[-3];
+                case 2: tempC[1] = coefficients[1]; tempS[2] = pSamplesOut[-2];
+                case 1: tempC[0] = coefficients[0]; tempS[3] = pSamplesOut[-1];
+            }
+            coefficients128_0 = vld1q_s32(tempC);
+            samples128_0      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        if (runningOrder >= 4) {
+            coefficients128_4 = vld1q_s32(coefficients + 4);
+            samples128_4      = vld1q_s32(pSamplesOut  - 8);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[6]; tempS[1] = pSamplesOut[-7];
+                case 2: tempC[1] = coefficients[5]; tempS[2] = pSamplesOut[-6];
+                case 1: tempC[0] = coefficients[4]; tempS[3] = pSamplesOut[-5];
+            }
+            coefficients128_4 = vld1q_s32(tempC);
+            samples128_4      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        if (runningOrder == 4) {
+            coefficients128_8 = vld1q_s32(coefficients + 8);
+            samples128_8      = vld1q_s32(pSamplesOut  - 12);
+            runningOrder -= 4;
+        } else {
+            switch (runningOrder) {
+                case 3: tempC[2] = coefficients[10]; tempS[1] = pSamplesOut[-11];
+                case 2: tempC[1] = coefficients[ 9]; tempS[2] = pSamplesOut[-10];
+                case 1: tempC[0] = coefficients[ 8]; tempS[3] = pSamplesOut[- 9];
+            }
+            coefficients128_8 = vld1q_s32(tempC);
+            samples128_8      = vld1q_s32(tempS);
+            runningOrder = 0;
+        }
+        coefficients128_0 = ma_dr_flac__vrevq_s32(coefficients128_0);
+        coefficients128_4 = ma_dr_flac__vrevq_s32(coefficients128_4);
+        coefficients128_8 = ma_dr_flac__vrevq_s32(coefficients128_8);
+    }
+    while (pDecodedSamples < pDecodedSamplesEnd) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[1], &riceParamParts[1]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[2], &riceParamParts[2]) ||
+            !ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[3], &riceParamParts[3])) {
+            return MA_FALSE;
+        }
+        zeroCountPart128 = vld1q_u32(zeroCountParts);
+        riceParamPart128 = vld1q_u32(riceParamParts);
+        riceParamPart128 = vandq_u32(riceParamPart128, riceParamMask128);
+        riceParamPart128 = vorrq_u32(riceParamPart128, vshlq_u32(zeroCountPart128, riceParam128));
+        riceParamPart128 = veorq_u32(vshrq_n_u32(riceParamPart128, 1), vaddq_u32(ma_dr_flac__vnotq_u32(vandq_u32(riceParamPart128, one128)), one128));
+        for (i = 0; i < 4; i += 1) {
+            int64x1_t prediction64;
+            prediction128 = veorq_s64(prediction128, prediction128);
+            switch (order)
+            {
+            case 12:
+            case 11: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_8), vget_low_s32(samples128_8)));
+            case 10:
+            case  9: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_8), vget_high_s32(samples128_8)));
+            case  8:
+            case  7: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_4), vget_low_s32(samples128_4)));
+            case  6:
+            case  5: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_4), vget_high_s32(samples128_4)));
+            case  4:
+            case  3: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_low_s32(coefficients128_0), vget_low_s32(samples128_0)));
+            case  2:
+            case  1: prediction128 = vaddq_s64(prediction128, vmull_s32(vget_high_s32(coefficients128_0), vget_high_s32(samples128_0)));
+            }
+            prediction64 = ma_dr_flac__vhaddq_s64(prediction128);
+            prediction64 = vshl_s64(prediction64, shift64);
+            prediction64 = vadd_s64(prediction64, vdup_n_s64(vgetq_lane_u32(riceParamPart128, 0)));
+            samples128_8 = ma_dr_flac__valignrq_s32_1(samples128_4, samples128_8);
+            samples128_4 = ma_dr_flac__valignrq_s32_1(samples128_0, samples128_4);
+            samples128_0 = ma_dr_flac__valignrq_s32_1(vcombine_s32(vreinterpret_s32_s64(prediction64), vdup_n_s32(0)), samples128_0);
+            riceParamPart128 = ma_dr_flac__valignrq_u32_1(vdupq_n_u32(0), riceParamPart128);
+        }
+        vst1q_s32(pDecodedSamples, samples128_0);
+        pDecodedSamples += 4;
+    }
+    i = (count & ~3);
+    while (i < (int)count) {
+        if (!ma_dr_flac__read_rice_parts_x1(bs, riceParam, &zeroCountParts[0], &riceParamParts[0])) {
+            return MA_FALSE;
+        }
+        riceParamParts[0] &= riceParamMask;
+        riceParamParts[0] |= (zeroCountParts[0] << riceParam);
+        riceParamParts[0]  = (riceParamParts[0] >> 1) ^ t[riceParamParts[0] & 0x01];
+        pDecodedSamples[0] = riceParamParts[0] + ma_dr_flac__calculate_prediction_64(order, shift, coefficients, pDecodedSamples);
+        i += 1;
+        pDecodedSamples += 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice__neon(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    if (lpcOrder > 0 && lpcOrder <= 12) {
+        if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+            return ma_dr_flac__decode_samples_with_residual__rice__neon_64(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+        } else {
+            return ma_dr_flac__decode_samples_with_residual__rice__neon_32(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
+        }
+    } else {
+        return ma_dr_flac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    }
+}
+#endif
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__rice(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 riceParam, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE41)
+    if (ma_dr_flac__gIsSSE41Supported) {
+        return ma_dr_flac__decode_samples_with_residual__rice__sse41(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported) {
+        return ma_dr_flac__decode_samples_with_residual__rice__neon(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    } else
+#endif
+    {
+    #if 0
+        return ma_dr_flac__decode_samples_with_residual__rice__reference(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    #else
+        return ma_dr_flac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
+    #endif
+    }
+}
+static ma_bool32 ma_dr_flac__read_and_seek_residual__rice(ma_dr_flac_bs* bs, ma_uint32 count, ma_uint8 riceParam)
+{
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    for (i = 0; i < count; ++i) {
+        if (!ma_dr_flac__seek_rice_parts(bs, riceParam)) {
+            return MA_FALSE;
+        }
+    }
+    return MA_TRUE;
+}
+#if defined(__clang__)
+__attribute__((no_sanitize("signed-integer-overflow")))
+#endif
+static ma_bool32 ma_dr_flac__decode_samples_with_residual__unencoded(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 count, ma_uint8 unencodedBitsPerSample, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pSamplesOut)
+{
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(unencodedBitsPerSample <= 31);
+    MA_DR_FLAC_ASSERT(pSamplesOut != NULL);
+    for (i = 0; i < count; ++i) {
+        if (unencodedBitsPerSample > 0) {
+            if (!ma_dr_flac__read_int32(bs, unencodedBitsPerSample, pSamplesOut + i)) {
+                return MA_FALSE;
+            }
+        } else {
+            pSamplesOut[i] = 0;
+        }
+        if (ma_dr_flac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+            pSamplesOut[i] += ma_dr_flac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+        } else {
+            pSamplesOut[i] += ma_dr_flac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
+        }
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples_with_residual(ma_dr_flac_bs* bs, ma_uint32 bitsPerSample, ma_uint32 blockSize, ma_uint32 lpcOrder, ma_int32 lpcShift, ma_uint32 lpcPrecision, const ma_int32* coefficients, ma_int32* pDecodedSamples)
+{
+    ma_uint8 residualMethod;
+    ma_uint8 partitionOrder;
+    ma_uint32 samplesInPartition;
+    ma_uint32 partitionsRemaining;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(blockSize != 0);
+    MA_DR_FLAC_ASSERT(pDecodedSamples != NULL);
+    if (!ma_dr_flac__read_uint8(bs, 2, &residualMethod)) {
+        return MA_FALSE;
+    }
+    if (residualMethod != MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE && residualMethod != MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+        return MA_FALSE;
+    }
+    pDecodedSamples += lpcOrder;
+    if (!ma_dr_flac__read_uint8(bs, 4, &partitionOrder)) {
+        return MA_FALSE;
+    }
+    if (partitionOrder > 8) {
+        return MA_FALSE;
+    }
+    if ((blockSize / (1 << partitionOrder)) < lpcOrder) {
+        return MA_FALSE;
+    }
+    samplesInPartition = (blockSize / (1 << partitionOrder)) - lpcOrder;
+    partitionsRemaining = (1 << partitionOrder);
+    for (;;) {
+        ma_uint8 riceParam = 0;
+        if (residualMethod == MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE) {
+            if (!ma_dr_flac__read_uint8(bs, 4, &riceParam)) {
+                return MA_FALSE;
+            }
+            if (riceParam == 15) {
+                riceParam = 0xFF;
+            }
+        } else if (residualMethod == MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+            if (!ma_dr_flac__read_uint8(bs, 5, &riceParam)) {
+                return MA_FALSE;
+            }
+            if (riceParam == 31) {
+                riceParam = 0xFF;
+            }
+        }
+        if (riceParam != 0xFF) {
+            if (!ma_dr_flac__decode_samples_with_residual__rice(bs, bitsPerSample, samplesInPartition, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+                return MA_FALSE;
+            }
+        } else {
+            ma_uint8 unencodedBitsPerSample = 0;
+            if (!ma_dr_flac__read_uint8(bs, 5, &unencodedBitsPerSample)) {
+                return MA_FALSE;
+            }
+            if (!ma_dr_flac__decode_samples_with_residual__unencoded(bs, bitsPerSample, samplesInPartition, unencodedBitsPerSample, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+                return MA_FALSE;
+            }
+        }
+        pDecodedSamples += samplesInPartition;
+        if (partitionsRemaining == 1) {
+            break;
+        }
+        partitionsRemaining -= 1;
+        if (partitionOrder != 0) {
+            samplesInPartition = blockSize / (1 << partitionOrder);
+        }
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__read_and_seek_residual(ma_dr_flac_bs* bs, ma_uint32 blockSize, ma_uint32 order)
+{
+    ma_uint8 residualMethod;
+    ma_uint8 partitionOrder;
+    ma_uint32 samplesInPartition;
+    ma_uint32 partitionsRemaining;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(blockSize != 0);
+    if (!ma_dr_flac__read_uint8(bs, 2, &residualMethod)) {
+        return MA_FALSE;
+    }
+    if (residualMethod != MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE && residualMethod != MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_flac__read_uint8(bs, 4, &partitionOrder)) {
+        return MA_FALSE;
+    }
+    if (partitionOrder > 8) {
+        return MA_FALSE;
+    }
+    if ((blockSize / (1 << partitionOrder)) <= order) {
+        return MA_FALSE;
+    }
+    samplesInPartition = (blockSize / (1 << partitionOrder)) - order;
+    partitionsRemaining = (1 << partitionOrder);
+    for (;;)
+    {
+        ma_uint8 riceParam = 0;
+        if (residualMethod == MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE) {
+            if (!ma_dr_flac__read_uint8(bs, 4, &riceParam)) {
+                return MA_FALSE;
+            }
+            if (riceParam == 15) {
+                riceParam = 0xFF;
+            }
+        } else if (residualMethod == MA_DR_FLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
+            if (!ma_dr_flac__read_uint8(bs, 5, &riceParam)) {
+                return MA_FALSE;
+            }
+            if (riceParam == 31) {
+                riceParam = 0xFF;
+            }
+        }
+        if (riceParam != 0xFF) {
+            if (!ma_dr_flac__read_and_seek_residual__rice(bs, samplesInPartition, riceParam)) {
+                return MA_FALSE;
+            }
+        } else {
+            ma_uint8 unencodedBitsPerSample = 0;
+            if (!ma_dr_flac__read_uint8(bs, 5, &unencodedBitsPerSample)) {
+                return MA_FALSE;
+            }
+            if (!ma_dr_flac__seek_bits(bs, unencodedBitsPerSample * samplesInPartition)) {
+                return MA_FALSE;
+            }
+        }
+        if (partitionsRemaining == 1) {
+            break;
+        }
+        partitionsRemaining -= 1;
+        samplesInPartition = blockSize / (1 << partitionOrder);
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples__constant(ma_dr_flac_bs* bs, ma_uint32 blockSize, ma_uint32 subframeBitsPerSample, ma_int32* pDecodedSamples)
+{
+    ma_uint32 i;
+    ma_int32 sample;
+    if (!ma_dr_flac__read_int32(bs, subframeBitsPerSample, &sample)) {
+        return MA_FALSE;
+    }
+    for (i = 0; i < blockSize; ++i) {
+        pDecodedSamples[i] = sample;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples__verbatim(ma_dr_flac_bs* bs, ma_uint32 blockSize, ma_uint32 subframeBitsPerSample, ma_int32* pDecodedSamples)
+{
+    ma_uint32 i;
+    for (i = 0; i < blockSize; ++i) {
+        ma_int32 sample;
+        if (!ma_dr_flac__read_int32(bs, subframeBitsPerSample, &sample)) {
+            return MA_FALSE;
+        }
+        pDecodedSamples[i] = sample;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples__fixed(ma_dr_flac_bs* bs, ma_uint32 blockSize, ma_uint32 subframeBitsPerSample, ma_uint8 lpcOrder, ma_int32* pDecodedSamples)
+{
+    ma_uint32 i;
+    static ma_int32 lpcCoefficientsTable[5][4] = {
+        {0,  0, 0,  0},
+        {1,  0, 0,  0},
+        {2, -1, 0,  0},
+        {3, -3, 1,  0},
+        {4, -6, 4, -1}
+    };
+    for (i = 0; i < lpcOrder; ++i) {
+        ma_int32 sample;
+        if (!ma_dr_flac__read_int32(bs, subframeBitsPerSample, &sample)) {
+            return MA_FALSE;
+        }
+        pDecodedSamples[i] = sample;
+    }
+    if (!ma_dr_flac__decode_samples_with_residual(bs, subframeBitsPerSample, blockSize, lpcOrder, 0, 4, lpcCoefficientsTable[lpcOrder], pDecodedSamples)) {
+        return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_samples__lpc(ma_dr_flac_bs* bs, ma_uint32 blockSize, ma_uint32 bitsPerSample, ma_uint8 lpcOrder, ma_int32* pDecodedSamples)
+{
+    ma_uint8 i;
+    ma_uint8 lpcPrecision;
+    ma_int8 lpcShift;
+    ma_int32 coefficients[32];
+    for (i = 0; i < lpcOrder; ++i) {
+        ma_int32 sample;
+        if (!ma_dr_flac__read_int32(bs, bitsPerSample, &sample)) {
+            return MA_FALSE;
+        }
+        pDecodedSamples[i] = sample;
+    }
+    if (!ma_dr_flac__read_uint8(bs, 4, &lpcPrecision)) {
+        return MA_FALSE;
+    }
+    if (lpcPrecision == 15) {
+        return MA_FALSE;
+    }
+    lpcPrecision += 1;
+    if (!ma_dr_flac__read_int8(bs, 5, &lpcShift)) {
+        return MA_FALSE;
+    }
+    if (lpcShift < 0) {
+        return MA_FALSE;
+    }
+    MA_DR_FLAC_ZERO_MEMORY(coefficients, sizeof(coefficients));
+    for (i = 0; i < lpcOrder; ++i) {
+        if (!ma_dr_flac__read_int32(bs, lpcPrecision, coefficients + i)) {
+            return MA_FALSE;
+        }
+    }
+    if (!ma_dr_flac__decode_samples_with_residual(bs, bitsPerSample, blockSize, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+        return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__read_next_flac_frame_header(ma_dr_flac_bs* bs, ma_uint8 streaminfoBitsPerSample, ma_dr_flac_frame_header* header)
+{
+    const ma_uint32 sampleRateTable[12]  = {0, 88200, 176400, 192000, 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000};
+    const ma_uint8 bitsPerSampleTable[8] = {0, 8, 12, (ma_uint8)-1, 16, 20, 24, (ma_uint8)-1};
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(header != NULL);
+    for (;;) {
+        ma_uint8 crc8 = 0xCE;
+        ma_uint8 reserved = 0;
+        ma_uint8 blockingStrategy = 0;
+        ma_uint8 blockSize = 0;
+        ma_uint8 sampleRate = 0;
+        ma_uint8 channelAssignment = 0;
+        ma_uint8 bitsPerSample = 0;
+        ma_bool32 isVariableBlockSize;
+        if (!ma_dr_flac__find_and_seek_to_next_sync_code(bs)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_flac__read_uint8(bs, 1, &reserved)) {
+            return MA_FALSE;
+        }
+        if (reserved == 1) {
+            continue;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, reserved, 1);
+        if (!ma_dr_flac__read_uint8(bs, 1, &blockingStrategy)) {
+            return MA_FALSE;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, blockingStrategy, 1);
+        if (!ma_dr_flac__read_uint8(bs, 4, &blockSize)) {
+            return MA_FALSE;
+        }
+        if (blockSize == 0) {
+            continue;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, blockSize, 4);
+        if (!ma_dr_flac__read_uint8(bs, 4, &sampleRate)) {
+            return MA_FALSE;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, sampleRate, 4);
+        if (!ma_dr_flac__read_uint8(bs, 4, &channelAssignment)) {
+            return MA_FALSE;
+        }
+        if (channelAssignment > 10) {
+            continue;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, channelAssignment, 4);
+        if (!ma_dr_flac__read_uint8(bs, 3, &bitsPerSample)) {
+            return MA_FALSE;
+        }
+        if (bitsPerSample == 3 || bitsPerSample == 7) {
+            continue;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, bitsPerSample, 3);
+        if (!ma_dr_flac__read_uint8(bs, 1, &reserved)) {
+            return MA_FALSE;
+        }
+        if (reserved == 1) {
+            continue;
+        }
+        crc8 = ma_dr_flac_crc8(crc8, reserved, 1);
+        isVariableBlockSize = blockingStrategy == 1;
+        if (isVariableBlockSize) {
+            ma_uint64 pcmFrameNumber;
+            ma_result result = ma_dr_flac__read_utf8_coded_number(bs, &pcmFrameNumber, &crc8);
+            if (result != MA_SUCCESS) {
+                if (result == MA_AT_END) {
+                    return MA_FALSE;
+                } else {
+                    continue;
+                }
+            }
+            header->flacFrameNumber  = 0;
+            header->pcmFrameNumber = pcmFrameNumber;
+        } else {
+            ma_uint64 flacFrameNumber = 0;
+            ma_result result = ma_dr_flac__read_utf8_coded_number(bs, &flacFrameNumber, &crc8);
+            if (result != MA_SUCCESS) {
+                if (result == MA_AT_END) {
+                    return MA_FALSE;
+                } else {
+                    continue;
+                }
+            }
+            header->flacFrameNumber  = (ma_uint32)flacFrameNumber;
+            header->pcmFrameNumber = 0;
+        }
+        MA_DR_FLAC_ASSERT(blockSize > 0);
+        if (blockSize == 1) {
+            header->blockSizeInPCMFrames = 192;
+        } else if (blockSize <= 5) {
+            MA_DR_FLAC_ASSERT(blockSize >= 2);
+            header->blockSizeInPCMFrames = 576 * (1 << (blockSize - 2));
+        } else if (blockSize == 6) {
+            if (!ma_dr_flac__read_uint16(bs, 8, &header->blockSizeInPCMFrames)) {
+                return MA_FALSE;
+            }
+            crc8 = ma_dr_flac_crc8(crc8, header->blockSizeInPCMFrames, 8);
+            header->blockSizeInPCMFrames += 1;
+        } else if (blockSize == 7) {
+            if (!ma_dr_flac__read_uint16(bs, 16, &header->blockSizeInPCMFrames)) {
+                return MA_FALSE;
+            }
+            crc8 = ma_dr_flac_crc8(crc8, header->blockSizeInPCMFrames, 16);
+            if (header->blockSizeInPCMFrames == 0xFFFF) {
+                return MA_FALSE;
+            }
+            header->blockSizeInPCMFrames += 1;
+        } else {
+            MA_DR_FLAC_ASSERT(blockSize >= 8);
+            header->blockSizeInPCMFrames = 256 * (1 << (blockSize - 8));
+        }
+        if (sampleRate <= 11) {
+            header->sampleRate = sampleRateTable[sampleRate];
+        } else if (sampleRate == 12) {
+            if (!ma_dr_flac__read_uint32(bs, 8, &header->sampleRate)) {
+                return MA_FALSE;
+            }
+            crc8 = ma_dr_flac_crc8(crc8, header->sampleRate, 8);
+            header->sampleRate *= 1000;
+        } else if (sampleRate == 13) {
+            if (!ma_dr_flac__read_uint32(bs, 16, &header->sampleRate)) {
+                return MA_FALSE;
+            }
+            crc8 = ma_dr_flac_crc8(crc8, header->sampleRate, 16);
+        } else if (sampleRate == 14) {
+            if (!ma_dr_flac__read_uint32(bs, 16, &header->sampleRate)) {
+                return MA_FALSE;
+            }
+            crc8 = ma_dr_flac_crc8(crc8, header->sampleRate, 16);
+            header->sampleRate *= 10;
+        } else {
+            continue;
+        }
+        header->channelAssignment = channelAssignment;
+        header->bitsPerSample = bitsPerSampleTable[bitsPerSample];
+        if (header->bitsPerSample == 0) {
+            header->bitsPerSample = streaminfoBitsPerSample;
+        }
+        if (header->bitsPerSample != streaminfoBitsPerSample) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_flac__read_uint8(bs, 8, &header->crc8)) {
+            return MA_FALSE;
+        }
+#ifndef MA_DR_FLAC_NO_CRC
+        if (header->crc8 != crc8) {
+            continue;
+        }
+#endif
+        return MA_TRUE;
+    }
+}
+static ma_bool32 ma_dr_flac__read_subframe_header(ma_dr_flac_bs* bs, ma_dr_flac_subframe* pSubframe)
+{
+    ma_uint8 header;
+    int type;
+    if (!ma_dr_flac__read_uint8(bs, 8, &header)) {
+        return MA_FALSE;
+    }
+    if ((header & 0x80) != 0) {
+        return MA_FALSE;
+    }
+    type = (header & 0x7E) >> 1;
+    if (type == 0) {
+        pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_CONSTANT;
+    } else if (type == 1) {
+        pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_VERBATIM;
+    } else {
+        if ((type & 0x20) != 0) {
+            pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_LPC;
+            pSubframe->lpcOrder = (ma_uint8)(type & 0x1F) + 1;
+        } else if ((type & 0x08) != 0) {
+            pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_FIXED;
+            pSubframe->lpcOrder = (ma_uint8)(type & 0x07);
+            if (pSubframe->lpcOrder > 4) {
+                pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_RESERVED;
+                pSubframe->lpcOrder = 0;
+            }
+        } else {
+            pSubframe->subframeType = MA_DR_FLAC_SUBFRAME_RESERVED;
+        }
+    }
+    if (pSubframe->subframeType == MA_DR_FLAC_SUBFRAME_RESERVED) {
+        return MA_FALSE;
+    }
+    pSubframe->wastedBitsPerSample = 0;
+    if ((header & 0x01) == 1) {
+        unsigned int wastedBitsPerSample;
+        if (!ma_dr_flac__seek_past_next_set_bit(bs, &wastedBitsPerSample)) {
+            return MA_FALSE;
+        }
+        pSubframe->wastedBitsPerSample = (ma_uint8)wastedBitsPerSample + 1;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_subframe(ma_dr_flac_bs* bs, ma_dr_flac_frame* frame, int subframeIndex, ma_int32* pDecodedSamplesOut)
+{
+    ma_dr_flac_subframe* pSubframe;
+    ma_uint32 subframeBitsPerSample;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(frame != NULL);
+    pSubframe = frame->subframes + subframeIndex;
+    if (!ma_dr_flac__read_subframe_header(bs, pSubframe)) {
+        return MA_FALSE;
+    }
+    subframeBitsPerSample = frame->header.bitsPerSample;
+    if ((frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE || frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE) && subframeIndex == 1) {
+        subframeBitsPerSample += 1;
+    } else if (frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE && subframeIndex == 0) {
+        subframeBitsPerSample += 1;
+    }
+    if (subframeBitsPerSample > 32) {
+        return MA_FALSE;
+    }
+    if (pSubframe->wastedBitsPerSample >= subframeBitsPerSample) {
+        return MA_FALSE;
+    }
+    subframeBitsPerSample -= pSubframe->wastedBitsPerSample;
+    pSubframe->pSamplesS32 = pDecodedSamplesOut;
+    switch (pSubframe->subframeType)
+    {
+        case MA_DR_FLAC_SUBFRAME_CONSTANT:
+        {
+            ma_dr_flac__decode_samples__constant(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->pSamplesS32);
+        } break;
+        case MA_DR_FLAC_SUBFRAME_VERBATIM:
+        {
+            ma_dr_flac__decode_samples__verbatim(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->pSamplesS32);
+        } break;
+        case MA_DR_FLAC_SUBFRAME_FIXED:
+        {
+            ma_dr_flac__decode_samples__fixed(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->lpcOrder, pSubframe->pSamplesS32);
+        } break;
+        case MA_DR_FLAC_SUBFRAME_LPC:
+        {
+            ma_dr_flac__decode_samples__lpc(bs, frame->header.blockSizeInPCMFrames, subframeBitsPerSample, pSubframe->lpcOrder, pSubframe->pSamplesS32);
+        } break;
+        default: return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__seek_subframe(ma_dr_flac_bs* bs, ma_dr_flac_frame* frame, int subframeIndex)
+{
+    ma_dr_flac_subframe* pSubframe;
+    ma_uint32 subframeBitsPerSample;
+    MA_DR_FLAC_ASSERT(bs != NULL);
+    MA_DR_FLAC_ASSERT(frame != NULL);
+    pSubframe = frame->subframes + subframeIndex;
+    if (!ma_dr_flac__read_subframe_header(bs, pSubframe)) {
+        return MA_FALSE;
+    }
+    subframeBitsPerSample = frame->header.bitsPerSample;
+    if ((frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE || frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE) && subframeIndex == 1) {
+        subframeBitsPerSample += 1;
+    } else if (frame->header.channelAssignment == MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE && subframeIndex == 0) {
+        subframeBitsPerSample += 1;
+    }
+    if (pSubframe->wastedBitsPerSample >= subframeBitsPerSample) {
+        return MA_FALSE;
+    }
+    subframeBitsPerSample -= pSubframe->wastedBitsPerSample;
+    pSubframe->pSamplesS32 = NULL;
+    switch (pSubframe->subframeType)
+    {
+        case MA_DR_FLAC_SUBFRAME_CONSTANT:
+        {
+            if (!ma_dr_flac__seek_bits(bs, subframeBitsPerSample)) {
+                return MA_FALSE;
+            }
+        } break;
+        case MA_DR_FLAC_SUBFRAME_VERBATIM:
+        {
+            unsigned int bitsToSeek = frame->header.blockSizeInPCMFrames * subframeBitsPerSample;
+            if (!ma_dr_flac__seek_bits(bs, bitsToSeek)) {
+                return MA_FALSE;
+            }
+        } break;
+        case MA_DR_FLAC_SUBFRAME_FIXED:
+        {
+            unsigned int bitsToSeek = pSubframe->lpcOrder * subframeBitsPerSample;
+            if (!ma_dr_flac__seek_bits(bs, bitsToSeek)) {
+                return MA_FALSE;
+            }
+            if (!ma_dr_flac__read_and_seek_residual(bs, frame->header.blockSizeInPCMFrames, pSubframe->lpcOrder)) {
+                return MA_FALSE;
+            }
+        } break;
+        case MA_DR_FLAC_SUBFRAME_LPC:
+        {
+            ma_uint8 lpcPrecision;
+            unsigned int bitsToSeek = pSubframe->lpcOrder * subframeBitsPerSample;
+            if (!ma_dr_flac__seek_bits(bs, bitsToSeek)) {
+                return MA_FALSE;
+            }
+            if (!ma_dr_flac__read_uint8(bs, 4, &lpcPrecision)) {
+                return MA_FALSE;
+            }
+            if (lpcPrecision == 15) {
+                return MA_FALSE;
+            }
+            lpcPrecision += 1;
+            bitsToSeek = (pSubframe->lpcOrder * lpcPrecision) + 5;
+            if (!ma_dr_flac__seek_bits(bs, bitsToSeek)) {
+                return MA_FALSE;
+            }
+            if (!ma_dr_flac__read_and_seek_residual(bs, frame->header.blockSizeInPCMFrames, pSubframe->lpcOrder)) {
+                return MA_FALSE;
+            }
+        } break;
+        default: return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static MA_INLINE ma_uint8 ma_dr_flac__get_channel_count_from_channel_assignment(ma_int8 channelAssignment)
+{
+    ma_uint8 lookup[] = {1, 2, 3, 4, 5, 6, 7, 8, 2, 2, 2};
+    MA_DR_FLAC_ASSERT(channelAssignment <= 10);
+    return lookup[channelAssignment];
+}
+static ma_result ma_dr_flac__decode_flac_frame(ma_dr_flac* pFlac)
+{
+    int channelCount;
+    int i;
+    ma_uint8 paddingSizeInBits;
+    ma_uint16 desiredCRC16;
+#ifndef MA_DR_FLAC_NO_CRC
+    ma_uint16 actualCRC16;
+#endif
+    MA_DR_FLAC_ZERO_MEMORY(pFlac->currentFLACFrame.subframes, sizeof(pFlac->currentFLACFrame.subframes));
+    if (pFlac->currentFLACFrame.header.blockSizeInPCMFrames > pFlac->maxBlockSizeInPCMFrames) {
+        return MA_ERROR;
+    }
+    channelCount = ma_dr_flac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+    if (channelCount != (int)pFlac->channels) {
+        return MA_ERROR;
+    }
+    for (i = 0; i < channelCount; ++i) {
+        if (!ma_dr_flac__decode_subframe(&pFlac->bs, &pFlac->currentFLACFrame, i, pFlac->pDecodedSamples + (pFlac->currentFLACFrame.header.blockSizeInPCMFrames * i))) {
+            return MA_ERROR;
+        }
+    }
+    paddingSizeInBits = (ma_uint8)(MA_DR_FLAC_CACHE_L1_BITS_REMAINING(&pFlac->bs) & 7);
+    if (paddingSizeInBits > 0) {
+        ma_uint8 padding = 0;
+        if (!ma_dr_flac__read_uint8(&pFlac->bs, paddingSizeInBits, &padding)) {
+            return MA_AT_END;
+        }
+    }
+#ifndef MA_DR_FLAC_NO_CRC
+    actualCRC16 = ma_dr_flac__flush_crc16(&pFlac->bs);
+#endif
+    if (!ma_dr_flac__read_uint16(&pFlac->bs, 16, &desiredCRC16)) {
+        return MA_AT_END;
+    }
+#ifndef MA_DR_FLAC_NO_CRC
+    if (actualCRC16 != desiredCRC16) {
+        return MA_CRC_MISMATCH;
+    }
+#endif
+    pFlac->currentFLACFrame.pcmFramesRemaining = pFlac->currentFLACFrame.header.blockSizeInPCMFrames;
+    return MA_SUCCESS;
+}
+static ma_result ma_dr_flac__seek_flac_frame(ma_dr_flac* pFlac)
+{
+    int channelCount;
+    int i;
+    ma_uint16 desiredCRC16;
+#ifndef MA_DR_FLAC_NO_CRC
+    ma_uint16 actualCRC16;
+#endif
+    channelCount = ma_dr_flac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+    for (i = 0; i < channelCount; ++i) {
+        if (!ma_dr_flac__seek_subframe(&pFlac->bs, &pFlac->currentFLACFrame, i)) {
+            return MA_ERROR;
+        }
+    }
+    if (!ma_dr_flac__seek_bits(&pFlac->bs, MA_DR_FLAC_CACHE_L1_BITS_REMAINING(&pFlac->bs) & 7)) {
+        return MA_ERROR;
+    }
+#ifndef MA_DR_FLAC_NO_CRC
+    actualCRC16 = ma_dr_flac__flush_crc16(&pFlac->bs);
+#endif
+    if (!ma_dr_flac__read_uint16(&pFlac->bs, 16, &desiredCRC16)) {
+        return MA_AT_END;
+    }
+#ifndef MA_DR_FLAC_NO_CRC
+    if (actualCRC16 != desiredCRC16) {
+        return MA_CRC_MISMATCH;
+    }
+#endif
+    return MA_SUCCESS;
+}
+static ma_bool32 ma_dr_flac__read_and_decode_next_flac_frame(ma_dr_flac* pFlac)
+{
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    for (;;) {
+        ma_result result;
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+        result = ma_dr_flac__decode_flac_frame(pFlac);
+        if (result != MA_SUCCESS) {
+            if (result == MA_CRC_MISMATCH) {
+                continue;
+            } else {
+                return MA_FALSE;
+            }
+        }
+        return MA_TRUE;
+    }
+}
+static void ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(ma_dr_flac* pFlac, ma_uint64* pFirstPCMFrame, ma_uint64* pLastPCMFrame)
+{
+    ma_uint64 firstPCMFrame;
+    ma_uint64 lastPCMFrame;
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    firstPCMFrame = pFlac->currentFLACFrame.header.pcmFrameNumber;
+    if (firstPCMFrame == 0) {
+        firstPCMFrame = ((ma_uint64)pFlac->currentFLACFrame.header.flacFrameNumber) * pFlac->maxBlockSizeInPCMFrames;
+    }
+    lastPCMFrame = firstPCMFrame + pFlac->currentFLACFrame.header.blockSizeInPCMFrames;
+    if (lastPCMFrame > 0) {
+        lastPCMFrame -= 1;
+    }
+    if (pFirstPCMFrame) {
+        *pFirstPCMFrame = firstPCMFrame;
+    }
+    if (pLastPCMFrame) {
+        *pLastPCMFrame = lastPCMFrame;
+    }
+}
+static ma_bool32 ma_dr_flac__seek_to_first_frame(ma_dr_flac* pFlac)
+{
+    ma_bool32 result;
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    result = ma_dr_flac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes);
+    MA_DR_FLAC_ZERO_MEMORY(&pFlac->currentFLACFrame, sizeof(pFlac->currentFLACFrame));
+    pFlac->currentPCMFrame = 0;
+    return result;
+}
+static MA_INLINE ma_result ma_dr_flac__seek_to_next_flac_frame(ma_dr_flac* pFlac)
+{
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    return ma_dr_flac__seek_flac_frame(pFlac);
+}
+static ma_uint64 ma_dr_flac__seek_forward_by_pcm_frames(ma_dr_flac* pFlac, ma_uint64 pcmFramesToSeek)
+{
+    ma_uint64 pcmFramesRead = 0;
+    while (pcmFramesToSeek > 0) {
+        if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_and_decode_next_flac_frame(pFlac)) {
+                break;
+            }
+        } else {
+            if (pFlac->currentFLACFrame.pcmFramesRemaining > pcmFramesToSeek) {
+                pcmFramesRead   += pcmFramesToSeek;
+                pFlac->currentFLACFrame.pcmFramesRemaining -= (ma_uint32)pcmFramesToSeek;
+                pcmFramesToSeek  = 0;
+            } else {
+                pcmFramesRead   += pFlac->currentFLACFrame.pcmFramesRemaining;
+                pcmFramesToSeek -= pFlac->currentFLACFrame.pcmFramesRemaining;
+                pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+            }
+        }
+    }
+    pFlac->currentPCMFrame += pcmFramesRead;
+    return pcmFramesRead;
+}
+static ma_bool32 ma_dr_flac__seek_to_pcm_frame__brute_force(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex)
+{
+    ma_bool32 isMidFrame = MA_FALSE;
+    ma_uint64 runningPCMFrameCount;
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    if (pcmFrameIndex >= pFlac->currentPCMFrame) {
+        runningPCMFrameCount = pFlac->currentPCMFrame;
+        if (pFlac->currentPCMFrame == 0 && pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+                return MA_FALSE;
+            }
+        } else {
+            isMidFrame = MA_TRUE;
+        }
+    } else {
+        runningPCMFrameCount = 0;
+        if (!ma_dr_flac__seek_to_first_frame(pFlac)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+    }
+    for (;;) {
+        ma_uint64 pcmFrameCountInThisFLACFrame;
+        ma_uint64 firstPCMFrameInFLACFrame = 0;
+        ma_uint64 lastPCMFrameInFLACFrame = 0;
+        ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame);
+        pcmFrameCountInThisFLACFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1;
+        if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFLACFrame)) {
+            ma_uint64 pcmFramesToDecode = pcmFrameIndex - runningPCMFrameCount;
+            if (!isMidFrame) {
+                ma_result result = ma_dr_flac__decode_flac_frame(pFlac);
+                if (result == MA_SUCCESS) {
+                    return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+                } else {
+                    if (result == MA_CRC_MISMATCH) {
+                        goto next_iteration;
+                    } else {
+                        return MA_FALSE;
+                    }
+                }
+            } else {
+                return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+            }
+        } else {
+            if (!isMidFrame) {
+                ma_result result = ma_dr_flac__seek_to_next_flac_frame(pFlac);
+                if (result == MA_SUCCESS) {
+                    runningPCMFrameCount += pcmFrameCountInThisFLACFrame;
+                } else {
+                    if (result == MA_CRC_MISMATCH) {
+                        goto next_iteration;
+                    } else {
+                        return MA_FALSE;
+                    }
+                }
+            } else {
+                runningPCMFrameCount += pFlac->currentFLACFrame.pcmFramesRemaining;
+                pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+                isMidFrame = MA_FALSE;
+            }
+            if (pcmFrameIndex == pFlac->totalPCMFrameCount && runningPCMFrameCount == pFlac->totalPCMFrameCount) {
+                return MA_TRUE;
+            }
+        }
+    next_iteration:
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+    }
+}
+#if !defined(MA_DR_FLAC_NO_CRC)
+#define MA_DR_FLAC_BINARY_SEARCH_APPROX_COMPRESSION_RATIO 0.6f
+static ma_bool32 ma_dr_flac__seek_to_approximate_flac_frame_to_byte(ma_dr_flac* pFlac, ma_uint64 targetByte, ma_uint64 rangeLo, ma_uint64 rangeHi, ma_uint64* pLastSuccessfulSeekOffset)
+{
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    MA_DR_FLAC_ASSERT(pLastSuccessfulSeekOffset != NULL);
+    MA_DR_FLAC_ASSERT(targetByte >= rangeLo);
+    MA_DR_FLAC_ASSERT(targetByte <= rangeHi);
+    *pLastSuccessfulSeekOffset = pFlac->firstFLACFramePosInBytes;
+    for (;;) {
+        ma_uint64 lastTargetByte = targetByte;
+        if (!ma_dr_flac__seek_to_byte(&pFlac->bs, targetByte)) {
+            if (targetByte == 0) {
+                ma_dr_flac__seek_to_first_frame(pFlac);
+                return MA_FALSE;
+            }
+            targetByte = rangeLo + ((rangeHi - rangeLo)/2);
+            rangeHi = targetByte;
+        } else {
+            MA_DR_FLAC_ZERO_MEMORY(&pFlac->currentFLACFrame, sizeof(pFlac->currentFLACFrame));
+#if 1
+            if (!ma_dr_flac__read_and_decode_next_flac_frame(pFlac)) {
+                targetByte = rangeLo + ((rangeHi - rangeLo)/2);
+                rangeHi = targetByte;
+            } else {
+                break;
+            }
+#else
+            if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+                targetByte = rangeLo + ((rangeHi - rangeLo)/2);
+                rangeHi = targetByte;
+            } else {
+                break;
+            }
+#endif
+        }
+        if(targetByte == lastTargetByte) {
+            return MA_FALSE;
+        }
+    }
+    ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &pFlac->currentPCMFrame, NULL);
+    MA_DR_FLAC_ASSERT(targetByte <= rangeHi);
+    *pLastSuccessfulSeekOffset = targetByte;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__decode_flac_frame_and_seek_forward_by_pcm_frames(ma_dr_flac* pFlac, ma_uint64 offset)
+{
+#if 0
+    if (ma_dr_flac__decode_flac_frame(pFlac) != MA_SUCCESS) {
+        if (ma_dr_flac__read_and_decode_next_flac_frame(pFlac) == MA_FALSE) {
+            return MA_FALSE;
+        }
+    }
+#endif
+    return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, offset) == offset;
+}
+static ma_bool32 ma_dr_flac__seek_to_pcm_frame__binary_search_internal(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex, ma_uint64 byteRangeLo, ma_uint64 byteRangeHi)
+{
+    ma_uint64 targetByte;
+    ma_uint64 pcmRangeLo = pFlac->totalPCMFrameCount;
+    ma_uint64 pcmRangeHi = 0;
+    ma_uint64 lastSuccessfulSeekOffset = (ma_uint64)-1;
+    ma_uint64 closestSeekOffsetBeforeTargetPCMFrame = byteRangeLo;
+    ma_uint32 seekForwardThreshold = (pFlac->maxBlockSizeInPCMFrames != 0) ? pFlac->maxBlockSizeInPCMFrames*2 : 4096;
+    targetByte = byteRangeLo + (ma_uint64)(((ma_int64)((pcmFrameIndex - pFlac->currentPCMFrame) * pFlac->channels * pFlac->bitsPerSample)/8.0f) * MA_DR_FLAC_BINARY_SEARCH_APPROX_COMPRESSION_RATIO);
+    if (targetByte > byteRangeHi) {
+        targetByte = byteRangeHi;
+    }
+    for (;;) {
+        if (ma_dr_flac__seek_to_approximate_flac_frame_to_byte(pFlac, targetByte, byteRangeLo, byteRangeHi, &lastSuccessfulSeekOffset)) {
+            ma_uint64 newPCMRangeLo;
+            ma_uint64 newPCMRangeHi;
+            ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &newPCMRangeLo, &newPCMRangeHi);
+            if (pcmRangeLo == newPCMRangeLo) {
+                if (!ma_dr_flac__seek_to_approximate_flac_frame_to_byte(pFlac, closestSeekOffsetBeforeTargetPCMFrame, closestSeekOffsetBeforeTargetPCMFrame, byteRangeHi, &lastSuccessfulSeekOffset)) {
+                    break;
+                }
+                if (ma_dr_flac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame)) {
+                    return MA_TRUE;
+                } else {
+                    break;
+                }
+            }
+            pcmRangeLo = newPCMRangeLo;
+            pcmRangeHi = newPCMRangeHi;
+            if (pcmRangeLo <= pcmFrameIndex && pcmRangeHi >= pcmFrameIndex) {
+                if (ma_dr_flac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame) ) {
+                    return MA_TRUE;
+                } else {
+                    break;
+                }
+            } else {
+                const float approxCompressionRatio = (ma_int64)(lastSuccessfulSeekOffset - pFlac->firstFLACFramePosInBytes) / ((ma_int64)(pcmRangeLo * pFlac->channels * pFlac->bitsPerSample)/8.0f);
+                if (pcmRangeLo > pcmFrameIndex) {
+                    byteRangeHi = lastSuccessfulSeekOffset;
+                    if (byteRangeLo > byteRangeHi) {
+                        byteRangeLo = byteRangeHi;
+                    }
+                    targetByte = byteRangeLo + ((byteRangeHi - byteRangeLo) / 2);
+                    if (targetByte < byteRangeLo) {
+                        targetByte = byteRangeLo;
+                    }
+                } else  {
+                    if ((pcmFrameIndex - pcmRangeLo) < seekForwardThreshold) {
+                        if (ma_dr_flac__decode_flac_frame_and_seek_forward_by_pcm_frames(pFlac, pcmFrameIndex - pFlac->currentPCMFrame)) {
+                            return MA_TRUE;
+                        } else {
+                            break;
+                        }
+                    } else {
+                        byteRangeLo = lastSuccessfulSeekOffset;
+                        if (byteRangeHi < byteRangeLo) {
+                            byteRangeHi = byteRangeLo;
+                        }
+                        targetByte = lastSuccessfulSeekOffset + (ma_uint64)(((ma_int64)((pcmFrameIndex-pcmRangeLo) * pFlac->channels * pFlac->bitsPerSample)/8.0f) * approxCompressionRatio);
+                        if (targetByte > byteRangeHi) {
+                            targetByte = byteRangeHi;
+                        }
+                        if (closestSeekOffsetBeforeTargetPCMFrame < lastSuccessfulSeekOffset) {
+                            closestSeekOffsetBeforeTargetPCMFrame = lastSuccessfulSeekOffset;
+                        }
+                    }
+                }
+            }
+        } else {
+            break;
+        }
+    }
+    ma_dr_flac__seek_to_first_frame(pFlac);
+    return MA_FALSE;
+}
+static ma_bool32 ma_dr_flac__seek_to_pcm_frame__binary_search(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex)
+{
+    ma_uint64 byteRangeLo;
+    ma_uint64 byteRangeHi;
+    ma_uint32 seekForwardThreshold = (pFlac->maxBlockSizeInPCMFrames != 0) ? pFlac->maxBlockSizeInPCMFrames*2 : 4096;
+    if (ma_dr_flac__seek_to_first_frame(pFlac) == MA_FALSE) {
+        return MA_FALSE;
+    }
+    if (pcmFrameIndex < seekForwardThreshold) {
+        return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFrameIndex) == pcmFrameIndex;
+    }
+    byteRangeLo = pFlac->firstFLACFramePosInBytes;
+    byteRangeHi = pFlac->firstFLACFramePosInBytes + (ma_uint64)((ma_int64)(pFlac->totalPCMFrameCount * pFlac->channels * pFlac->bitsPerSample)/8.0f);
+    return ma_dr_flac__seek_to_pcm_frame__binary_search_internal(pFlac, pcmFrameIndex, byteRangeLo, byteRangeHi);
+}
+#endif
+static ma_bool32 ma_dr_flac__seek_to_pcm_frame__seek_table(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex)
+{
+    ma_uint32 iClosestSeekpoint = 0;
+    ma_bool32 isMidFrame = MA_FALSE;
+    ma_uint64 runningPCMFrameCount;
+    ma_uint32 iSeekpoint;
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    if (pFlac->pSeekpoints == NULL || pFlac->seekpointCount == 0) {
+        return MA_FALSE;
+    }
+    if (pFlac->pSeekpoints[0].firstPCMFrame > pcmFrameIndex) {
+        return MA_FALSE;
+    }
+    for (iSeekpoint = 0; iSeekpoint < pFlac->seekpointCount; ++iSeekpoint) {
+        if (pFlac->pSeekpoints[iSeekpoint].firstPCMFrame >= pcmFrameIndex) {
+            break;
+        }
+        iClosestSeekpoint = iSeekpoint;
+    }
+    if (pFlac->pSeekpoints[iClosestSeekpoint].pcmFrameCount == 0 || pFlac->pSeekpoints[iClosestSeekpoint].pcmFrameCount > pFlac->maxBlockSizeInPCMFrames) {
+        return MA_FALSE;
+    }
+    if (pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame > pFlac->totalPCMFrameCount && pFlac->totalPCMFrameCount > 0) {
+        return MA_FALSE;
+    }
+#if !defined(MA_DR_FLAC_NO_CRC)
+    if (pFlac->totalPCMFrameCount > 0) {
+        ma_uint64 byteRangeLo;
+        ma_uint64 byteRangeHi;
+        byteRangeHi = pFlac->firstFLACFramePosInBytes + (ma_uint64)((ma_int64)(pFlac->totalPCMFrameCount * pFlac->channels * pFlac->bitsPerSample)/8.0f);
+        byteRangeLo = pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset;
+        if (iClosestSeekpoint < pFlac->seekpointCount-1) {
+            ma_uint32 iNextSeekpoint = iClosestSeekpoint + 1;
+            if (pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset >= pFlac->pSeekpoints[iNextSeekpoint].flacFrameOffset || pFlac->pSeekpoints[iNextSeekpoint].pcmFrameCount == 0) {
+                return MA_FALSE;
+            }
+            if (pFlac->pSeekpoints[iNextSeekpoint].firstPCMFrame != (((ma_uint64)0xFFFFFFFF << 32) | 0xFFFFFFFF)) {
+                byteRangeHi = pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iNextSeekpoint].flacFrameOffset - 1;
+            }
+        }
+        if (ma_dr_flac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset)) {
+            if (ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+                ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &pFlac->currentPCMFrame, NULL);
+                if (ma_dr_flac__seek_to_pcm_frame__binary_search_internal(pFlac, pcmFrameIndex, byteRangeLo, byteRangeHi)) {
+                    return MA_TRUE;
+                }
+            }
+        }
+    }
+#endif
+    if (pcmFrameIndex >= pFlac->currentPCMFrame && pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame <= pFlac->currentPCMFrame) {
+        runningPCMFrameCount = pFlac->currentPCMFrame;
+        if (pFlac->currentPCMFrame == 0 && pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+                return MA_FALSE;
+            }
+        } else {
+            isMidFrame = MA_TRUE;
+        }
+    } else {
+        runningPCMFrameCount = pFlac->pSeekpoints[iClosestSeekpoint].firstPCMFrame;
+        if (!ma_dr_flac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes + pFlac->pSeekpoints[iClosestSeekpoint].flacFrameOffset)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+    }
+    for (;;) {
+        ma_uint64 pcmFrameCountInThisFLACFrame;
+        ma_uint64 firstPCMFrameInFLACFrame = 0;
+        ma_uint64 lastPCMFrameInFLACFrame = 0;
+        ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame);
+        pcmFrameCountInThisFLACFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1;
+        if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFLACFrame)) {
+            ma_uint64 pcmFramesToDecode = pcmFrameIndex - runningPCMFrameCount;
+            if (!isMidFrame) {
+                ma_result result = ma_dr_flac__decode_flac_frame(pFlac);
+                if (result == MA_SUCCESS) {
+                    return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+                } else {
+                    if (result == MA_CRC_MISMATCH) {
+                        goto next_iteration;
+                    } else {
+                        return MA_FALSE;
+                    }
+                }
+            } else {
+                return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+            }
+        } else {
+            if (!isMidFrame) {
+                ma_result result = ma_dr_flac__seek_to_next_flac_frame(pFlac);
+                if (result == MA_SUCCESS) {
+                    runningPCMFrameCount += pcmFrameCountInThisFLACFrame;
+                } else {
+                    if (result == MA_CRC_MISMATCH) {
+                        goto next_iteration;
+                    } else {
+                        return MA_FALSE;
+                    }
+                }
+            } else {
+                runningPCMFrameCount += pFlac->currentFLACFrame.pcmFramesRemaining;
+                pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+                isMidFrame = MA_FALSE;
+            }
+            if (pcmFrameIndex == pFlac->totalPCMFrameCount && runningPCMFrameCount == pFlac->totalPCMFrameCount) {
+                return MA_TRUE;
+            }
+        }
+    next_iteration:
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+    }
+}
+#ifndef MA_DR_FLAC_NO_OGG
+typedef struct
+{
+    ma_uint8 capturePattern[4];
+    ma_uint8 structureVersion;
+    ma_uint8 headerType;
+    ma_uint64 granulePosition;
+    ma_uint32 serialNumber;
+    ma_uint32 sequenceNumber;
+    ma_uint32 checksum;
+    ma_uint8 segmentCount;
+    ma_uint8 segmentTable[255];
+} ma_dr_flac_ogg_page_header;
+#endif
+typedef struct
+{
+    ma_dr_flac_read_proc onRead;
+    ma_dr_flac_seek_proc onSeek;
+    ma_dr_flac_meta_proc onMeta;
+    ma_dr_flac_container container;
+    void* pUserData;
+    void* pUserDataMD;
+    ma_uint32 sampleRate;
+    ma_uint8  channels;
+    ma_uint8  bitsPerSample;
+    ma_uint64 totalPCMFrameCount;
+    ma_uint16 maxBlockSizeInPCMFrames;
+    ma_uint64 runningFilePos;
+    ma_bool32 hasStreamInfoBlock;
+    ma_bool32 hasMetadataBlocks;
+    ma_dr_flac_bs bs;
+    ma_dr_flac_frame_header firstFrameHeader;
+#ifndef MA_DR_FLAC_NO_OGG
+    ma_uint32 oggSerial;
+    ma_uint64 oggFirstBytePos;
+    ma_dr_flac_ogg_page_header oggBosHeader;
+#endif
+} ma_dr_flac_init_info;
+static MA_INLINE void ma_dr_flac__decode_block_header(ma_uint32 blockHeader, ma_uint8* isLastBlock, ma_uint8* blockType, ma_uint32* blockSize)
+{
+    blockHeader = ma_dr_flac__be2host_32(blockHeader);
+    *isLastBlock = (ma_uint8)((blockHeader & 0x80000000UL) >> 31);
+    *blockType   = (ma_uint8)((blockHeader & 0x7F000000UL) >> 24);
+    *blockSize   =                (blockHeader & 0x00FFFFFFUL);
+}
+static MA_INLINE ma_bool32 ma_dr_flac__read_and_decode_block_header(ma_dr_flac_read_proc onRead, void* pUserData, ma_uint8* isLastBlock, ma_uint8* blockType, ma_uint32* blockSize)
+{
+    ma_uint32 blockHeader;
+    *blockSize = 0;
+    if (onRead(pUserData, &blockHeader, 4) != 4) {
+        return MA_FALSE;
+    }
+    ma_dr_flac__decode_block_header(blockHeader, isLastBlock, blockType, blockSize);
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__read_streaminfo(ma_dr_flac_read_proc onRead, void* pUserData, ma_dr_flac_streaminfo* pStreamInfo)
+{
+    ma_uint32 blockSizes;
+    ma_uint64 frameSizes = 0;
+    ma_uint64 importantProps;
+    ma_uint8 md5[16];
+    if (onRead(pUserData, &blockSizes, 4) != 4) {
+        return MA_FALSE;
+    }
+    if (onRead(pUserData, &frameSizes, 6) != 6) {
+        return MA_FALSE;
+    }
+    if (onRead(pUserData, &importantProps, 8) != 8) {
+        return MA_FALSE;
+    }
+    if (onRead(pUserData, md5, sizeof(md5)) != sizeof(md5)) {
+        return MA_FALSE;
+    }
+    blockSizes     = ma_dr_flac__be2host_32(blockSizes);
+    frameSizes     = ma_dr_flac__be2host_64(frameSizes);
+    importantProps = ma_dr_flac__be2host_64(importantProps);
+    pStreamInfo->minBlockSizeInPCMFrames = (ma_uint16)((blockSizes & 0xFFFF0000) >> 16);
+    pStreamInfo->maxBlockSizeInPCMFrames = (ma_uint16) (blockSizes & 0x0000FFFF);
+    pStreamInfo->minFrameSizeInPCMFrames = (ma_uint32)((frameSizes     &  (((ma_uint64)0x00FFFFFF << 16) << 24)) >> 40);
+    pStreamInfo->maxFrameSizeInPCMFrames = (ma_uint32)((frameSizes     &  (((ma_uint64)0x00FFFFFF << 16) <<  0)) >> 16);
+    pStreamInfo->sampleRate              = (ma_uint32)((importantProps &  (((ma_uint64)0x000FFFFF << 16) << 28)) >> 44);
+    pStreamInfo->channels                = (ma_uint8 )((importantProps &  (((ma_uint64)0x0000000E << 16) << 24)) >> 41) + 1;
+    pStreamInfo->bitsPerSample           = (ma_uint8 )((importantProps &  (((ma_uint64)0x0000001F << 16) << 20)) >> 36) + 1;
+    pStreamInfo->totalPCMFrameCount      =                ((importantProps & ((((ma_uint64)0x0000000F << 16) << 16) | 0xFFFFFFFF)));
+    MA_DR_FLAC_COPY_MEMORY(pStreamInfo->md5, md5, sizeof(md5));
+    return MA_TRUE;
+}
+static void* ma_dr_flac__malloc_default(size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_FLAC_MALLOC(sz);
+}
+static void* ma_dr_flac__realloc_default(void* p, size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_FLAC_REALLOC(p, sz);
+}
+static void ma_dr_flac__free_default(void* p, void* pUserData)
+{
+    (void)pUserData;
+    MA_DR_FLAC_FREE(p);
+}
+static void* ma_dr_flac__malloc_from_callbacks(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onMalloc != NULL) {
+        return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(NULL, sz, pAllocationCallbacks->pUserData);
+    }
+    return NULL;
+}
+static void* ma_dr_flac__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(p, szNew, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) {
+        void* p2;
+        p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData);
+        if (p2 == NULL) {
+            return NULL;
+        }
+        if (p != NULL) {
+            MA_DR_FLAC_COPY_MEMORY(p2, p, szOld);
+            pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+        }
+        return p2;
+    }
+    return NULL;
+}
+static void ma_dr_flac__free_from_callbacks(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (p == NULL || pAllocationCallbacks == NULL) {
+        return;
+    }
+    if (pAllocationCallbacks->onFree != NULL) {
+        pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+    }
+}
+static ma_bool32 ma_dr_flac__read_and_decode_metadata(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, void* pUserData, void* pUserDataMD, ma_uint64* pFirstFramePos, ma_uint64* pSeektablePos, ma_uint32* pSeekpointCount, ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_uint64 runningFilePos = 42;
+    ma_uint64 seektablePos   = 0;
+    ma_uint32 seektableSize  = 0;
+    for (;;) {
+        ma_dr_flac_metadata metadata;
+        ma_uint8 isLastBlock = 0;
+        ma_uint8 blockType = 0;
+        ma_uint32 blockSize;
+        if (ma_dr_flac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize) == MA_FALSE) {
+            return MA_FALSE;
+        }
+        runningFilePos += 4;
+        metadata.type = blockType;
+        metadata.pRawData = NULL;
+        metadata.rawDataSize = 0;
+        switch (blockType)
+        {
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_APPLICATION:
+            {
+                if (blockSize < 4) {
+                    return MA_FALSE;
+                }
+                if (onMeta) {
+                    void* pRawData = ma_dr_flac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    metadata.data.application.id       = ma_dr_flac__be2host_32(*(ma_uint32*)pRawData);
+                    metadata.data.application.pData    = (const void*)((ma_uint8*)pRawData + sizeof(ma_uint32));
+                    metadata.data.application.dataSize = blockSize - sizeof(ma_uint32);
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_SEEKTABLE:
+            {
+                seektablePos  = runningFilePos;
+                seektableSize = blockSize;
+                if (onMeta) {
+                    ma_uint32 seekpointCount;
+                    ma_uint32 iSeekpoint;
+                    void* pRawData;
+                    seekpointCount = blockSize/MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES;
+                    pRawData = ma_dr_flac__malloc_from_callbacks(seekpointCount * sizeof(ma_dr_flac_seekpoint), pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    for (iSeekpoint = 0; iSeekpoint < seekpointCount; ++iSeekpoint) {
+                        ma_dr_flac_seekpoint* pSeekpoint = (ma_dr_flac_seekpoint*)pRawData + iSeekpoint;
+                        if (onRead(pUserData, pSeekpoint, MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES) != MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES) {
+                            ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                            return MA_FALSE;
+                        }
+                        pSeekpoint->firstPCMFrame   = ma_dr_flac__be2host_64(pSeekpoint->firstPCMFrame);
+                        pSeekpoint->flacFrameOffset = ma_dr_flac__be2host_64(pSeekpoint->flacFrameOffset);
+                        pSeekpoint->pcmFrameCount   = ma_dr_flac__be2host_16(pSeekpoint->pcmFrameCount);
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    metadata.data.seektable.seekpointCount = seekpointCount;
+                    metadata.data.seektable.pSeekpoints = (const ma_dr_flac_seekpoint*)pRawData;
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_VORBIS_COMMENT:
+            {
+                if (blockSize < 8) {
+                    return MA_FALSE;
+                }
+                if (onMeta) {
+                    void* pRawData;
+                    const char* pRunningData;
+                    const char* pRunningDataEnd;
+                    ma_uint32 i;
+                    pRawData = ma_dr_flac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    pRunningData    = (const char*)pRawData;
+                    pRunningDataEnd = (const char*)pRawData + blockSize;
+                    metadata.data.vorbis_comment.vendorLength = ma_dr_flac__le2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    if ((pRunningDataEnd - pRunningData) - 4 < (ma_int64)metadata.data.vorbis_comment.vendorLength) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.data.vorbis_comment.vendor       = pRunningData;                                            pRunningData += metadata.data.vorbis_comment.vendorLength;
+                    metadata.data.vorbis_comment.commentCount = ma_dr_flac__le2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    if ((pRunningDataEnd - pRunningData) / sizeof(ma_uint32) < metadata.data.vorbis_comment.commentCount) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.data.vorbis_comment.pComments    = pRunningData;
+                    for (i = 0; i < metadata.data.vorbis_comment.commentCount; ++i) {
+                        ma_uint32 commentLength;
+                        if (pRunningDataEnd - pRunningData < 4) {
+                            ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                            return MA_FALSE;
+                        }
+                        commentLength = ma_dr_flac__le2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                        if (pRunningDataEnd - pRunningData < (ma_int64)commentLength) {
+                            ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                            return MA_FALSE;
+                        }
+                        pRunningData += commentLength;
+                    }
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_CUESHEET:
+            {
+                if (blockSize < 396) {
+                    return MA_FALSE;
+                }
+                if (onMeta) {
+                    void* pRawData;
+                    const char* pRunningData;
+                    const char* pRunningDataEnd;
+                    size_t bufferSize;
+                    ma_uint8 iTrack;
+                    ma_uint8 iIndex;
+                    void* pTrackData;
+                    pRawData = ma_dr_flac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    pRunningData    = (const char*)pRawData;
+                    pRunningDataEnd = (const char*)pRawData + blockSize;
+                    MA_DR_FLAC_COPY_MEMORY(metadata.data.cuesheet.catalog, pRunningData, 128);                              pRunningData += 128;
+                    metadata.data.cuesheet.leadInSampleCount = ma_dr_flac__be2host_64(*(const ma_uint64*)pRunningData); pRunningData += 8;
+                    metadata.data.cuesheet.isCD              = (pRunningData[0] & 0x80) != 0;                           pRunningData += 259;
+                    metadata.data.cuesheet.trackCount        = pRunningData[0];                                         pRunningData += 1;
+                    metadata.data.cuesheet.pTrackData        = NULL;
+                    {
+                        const char* pRunningDataSaved = pRunningData;
+                        bufferSize = metadata.data.cuesheet.trackCount * MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES;
+                        for (iTrack = 0; iTrack < metadata.data.cuesheet.trackCount; ++iTrack) {
+                            ma_uint8 indexCount;
+                            ma_uint32 indexPointSize;
+                            if (pRunningDataEnd - pRunningData < MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES) {
+                                ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                                return MA_FALSE;
+                            }
+                            pRunningData += 35;
+                            indexCount = pRunningData[0];
+                            pRunningData += 1;
+                            bufferSize += indexCount * sizeof(ma_dr_flac_cuesheet_track_index);
+                            indexPointSize = indexCount * MA_DR_FLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES;
+                            if (pRunningDataEnd - pRunningData < (ma_int64)indexPointSize) {
+                                ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                                return MA_FALSE;
+                            }
+                            pRunningData += indexPointSize;
+                        }
+                        pRunningData = pRunningDataSaved;
+                    }
+                    {
+                        char* pRunningTrackData;
+                        pTrackData = ma_dr_flac__malloc_from_callbacks(bufferSize, pAllocationCallbacks);
+                        if (pTrackData == NULL) {
+                            ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                            return MA_FALSE;
+                        }
+                        pRunningTrackData = (char*)pTrackData;
+                        for (iTrack = 0; iTrack < metadata.data.cuesheet.trackCount; ++iTrack) {
+                            ma_uint8 indexCount;
+                            MA_DR_FLAC_COPY_MEMORY(pRunningTrackData, pRunningData, MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES);
+                            pRunningData      += MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES-1;
+                            pRunningTrackData += MA_DR_FLAC_CUESHEET_TRACK_SIZE_IN_BYTES-1;
+                            indexCount = pRunningData[0];
+                            pRunningData      += 1;
+                            pRunningTrackData += 1;
+                            for (iIndex = 0; iIndex < indexCount; ++iIndex) {
+                                ma_dr_flac_cuesheet_track_index* pTrackIndex = (ma_dr_flac_cuesheet_track_index*)pRunningTrackData;
+                                MA_DR_FLAC_COPY_MEMORY(pRunningTrackData, pRunningData, MA_DR_FLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES);
+                                pRunningData      += MA_DR_FLAC_CUESHEET_TRACK_INDEX_SIZE_IN_BYTES;
+                                pRunningTrackData += sizeof(ma_dr_flac_cuesheet_track_index);
+                                pTrackIndex->offset = ma_dr_flac__be2host_64(pTrackIndex->offset);
+                            }
+                        }
+                        metadata.data.cuesheet.pTrackData = pTrackData;
+                    }
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                    pRawData = NULL;
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pTrackData, pAllocationCallbacks);
+                    pTrackData = NULL;
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_PICTURE:
+            {
+                if (blockSize < 32) {
+                    return MA_FALSE;
+                }
+                if (onMeta) {
+                    void* pRawData;
+                    const char* pRunningData;
+                    const char* pRunningDataEnd;
+                    pRawData = ma_dr_flac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    pRunningData    = (const char*)pRawData;
+                    pRunningDataEnd = (const char*)pRawData + blockSize;
+                    metadata.data.picture.type       = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.mimeLength = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    if ((pRunningDataEnd - pRunningData) - 24 < (ma_int64)metadata.data.picture.mimeLength) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.data.picture.mime              = pRunningData;                                   pRunningData += metadata.data.picture.mimeLength;
+                    metadata.data.picture.descriptionLength = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    if ((pRunningDataEnd - pRunningData) - 20 < (ma_int64)metadata.data.picture.descriptionLength) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.data.picture.description     = pRunningData;                                   pRunningData += metadata.data.picture.descriptionLength;
+                    metadata.data.picture.width           = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.height          = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.colorDepth      = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.indexColorCount = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.pictureDataSize = ma_dr_flac__be2host_32_ptr_unaligned(pRunningData); pRunningData += 4;
+                    metadata.data.picture.pPictureData    = (const ma_uint8*)pRunningData;
+                    if (pRunningDataEnd - pRunningData < (ma_int64)metadata.data.picture.pictureDataSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_PADDING:
+            {
+                if (onMeta) {
+                    metadata.data.padding.unused = 0;
+                    if (!onSeek(pUserData, blockSize, ma_dr_flac_seek_origin_current)) {
+                        isLastBlock = MA_TRUE;
+                    } else {
+                        onMeta(pUserDataMD, &metadata);
+                    }
+                }
+            } break;
+            case MA_DR_FLAC_METADATA_BLOCK_TYPE_INVALID:
+            {
+                if (onMeta) {
+                    if (!onSeek(pUserData, blockSize, ma_dr_flac_seek_origin_current)) {
+                        isLastBlock = MA_TRUE;
+                    }
+                }
+            } break;
+            default:
+            {
+                if (onMeta) {
+                    void* pRawData = ma_dr_flac__malloc_from_callbacks(blockSize, pAllocationCallbacks);
+                    if (pRawData == NULL) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, pRawData, blockSize) != blockSize) {
+                        ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                        return MA_FALSE;
+                    }
+                    metadata.pRawData = pRawData;
+                    metadata.rawDataSize = blockSize;
+                    onMeta(pUserDataMD, &metadata);
+                    ma_dr_flac__free_from_callbacks(pRawData, pAllocationCallbacks);
+                }
+            } break;
+        }
+        if (onMeta == NULL && blockSize > 0) {
+            if (!onSeek(pUserData, blockSize, ma_dr_flac_seek_origin_current)) {
+                isLastBlock = MA_TRUE;
+            }
+        }
+        runningFilePos += blockSize;
+        if (isLastBlock) {
+            break;
+        }
+    }
+    *pSeektablePos   = seektablePos;
+    *pSeekpointCount = seektableSize / MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES;
+    *pFirstFramePos  = runningFilePos;
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac__init_private__native(ma_dr_flac_init_info* pInit, ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, void* pUserData, void* pUserDataMD, ma_bool32 relaxed)
+{
+    ma_uint8 isLastBlock;
+    ma_uint8 blockType;
+    ma_uint32 blockSize;
+    (void)onSeek;
+    pInit->container = ma_dr_flac_container_native;
+    if (!ma_dr_flac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize)) {
+        return MA_FALSE;
+    }
+    if (blockType != MA_DR_FLAC_METADATA_BLOCK_TYPE_STREAMINFO || blockSize != 34) {
+        if (!relaxed) {
+            return MA_FALSE;
+        } else {
+            pInit->hasStreamInfoBlock = MA_FALSE;
+            pInit->hasMetadataBlocks  = MA_FALSE;
+            if (!ma_dr_flac__read_next_flac_frame_header(&pInit->bs, 0, &pInit->firstFrameHeader)) {
+                return MA_FALSE;
+            }
+            if (pInit->firstFrameHeader.bitsPerSample == 0) {
+                return MA_FALSE;
+            }
+            pInit->sampleRate              = pInit->firstFrameHeader.sampleRate;
+            pInit->channels                = ma_dr_flac__get_channel_count_from_channel_assignment(pInit->firstFrameHeader.channelAssignment);
+            pInit->bitsPerSample           = pInit->firstFrameHeader.bitsPerSample;
+            pInit->maxBlockSizeInPCMFrames = 65535;
+            return MA_TRUE;
+        }
+    } else {
+        ma_dr_flac_streaminfo streaminfo;
+        if (!ma_dr_flac__read_streaminfo(onRead, pUserData, &streaminfo)) {
+            return MA_FALSE;
+        }
+        pInit->hasStreamInfoBlock      = MA_TRUE;
+        pInit->sampleRate              = streaminfo.sampleRate;
+        pInit->channels                = streaminfo.channels;
+        pInit->bitsPerSample           = streaminfo.bitsPerSample;
+        pInit->totalPCMFrameCount      = streaminfo.totalPCMFrameCount;
+        pInit->maxBlockSizeInPCMFrames = streaminfo.maxBlockSizeInPCMFrames;
+        pInit->hasMetadataBlocks       = !isLastBlock;
+        if (onMeta) {
+            ma_dr_flac_metadata metadata;
+            metadata.type = MA_DR_FLAC_METADATA_BLOCK_TYPE_STREAMINFO;
+            metadata.pRawData = NULL;
+            metadata.rawDataSize = 0;
+            metadata.data.streaminfo = streaminfo;
+            onMeta(pUserDataMD, &metadata);
+        }
+        return MA_TRUE;
+    }
+}
+#ifndef MA_DR_FLAC_NO_OGG
+#define MA_DR_FLAC_OGG_MAX_PAGE_SIZE            65307
+#define MA_DR_FLAC_OGG_CAPTURE_PATTERN_CRC32    1605413199
+typedef enum
+{
+    ma_dr_flac_ogg_recover_on_crc_mismatch,
+    ma_dr_flac_ogg_fail_on_crc_mismatch
+} ma_dr_flac_ogg_crc_mismatch_recovery;
+#ifndef MA_DR_FLAC_NO_CRC
+static ma_uint32 ma_dr_flac__crc32_table[] = {
+    0x00000000L, 0x04C11DB7L, 0x09823B6EL, 0x0D4326D9L,
+    0x130476DCL, 0x17C56B6BL, 0x1A864DB2L, 0x1E475005L,
+    0x2608EDB8L, 0x22C9F00FL, 0x2F8AD6D6L, 0x2B4BCB61L,
+    0x350C9B64L, 0x31CD86D3L, 0x3C8EA00AL, 0x384FBDBDL,
+    0x4C11DB70L, 0x48D0C6C7L, 0x4593E01EL, 0x4152FDA9L,
+    0x5F15ADACL, 0x5BD4B01BL, 0x569796C2L, 0x52568B75L,
+    0x6A1936C8L, 0x6ED82B7FL, 0x639B0DA6L, 0x675A1011L,
+    0x791D4014L, 0x7DDC5DA3L, 0x709F7B7AL, 0x745E66CDL,
+    0x9823B6E0L, 0x9CE2AB57L, 0x91A18D8EL, 0x95609039L,
+    0x8B27C03CL, 0x8FE6DD8BL, 0x82A5FB52L, 0x8664E6E5L,
+    0xBE2B5B58L, 0xBAEA46EFL, 0xB7A96036L, 0xB3687D81L,
+    0xAD2F2D84L, 0xA9EE3033L, 0xA4AD16EAL, 0xA06C0B5DL,
+    0xD4326D90L, 0xD0F37027L, 0xDDB056FEL, 0xD9714B49L,
+    0xC7361B4CL, 0xC3F706FBL, 0xCEB42022L, 0xCA753D95L,
+    0xF23A8028L, 0xF6FB9D9FL, 0xFBB8BB46L, 0xFF79A6F1L,
+    0xE13EF6F4L, 0xE5FFEB43L, 0xE8BCCD9AL, 0xEC7DD02DL,
+    0x34867077L, 0x30476DC0L, 0x3D044B19L, 0x39C556AEL,
+    0x278206ABL, 0x23431B1CL, 0x2E003DC5L, 0x2AC12072L,
+    0x128E9DCFL, 0x164F8078L, 0x1B0CA6A1L, 0x1FCDBB16L,
+    0x018AEB13L, 0x054BF6A4L, 0x0808D07DL, 0x0CC9CDCAL,
+    0x7897AB07L, 0x7C56B6B0L, 0x71159069L, 0x75D48DDEL,
+    0x6B93DDDBL, 0x6F52C06CL, 0x6211E6B5L, 0x66D0FB02L,
+    0x5E9F46BFL, 0x5A5E5B08L, 0x571D7DD1L, 0x53DC6066L,
+    0x4D9B3063L, 0x495A2DD4L, 0x44190B0DL, 0x40D816BAL,
+    0xACA5C697L, 0xA864DB20L, 0xA527FDF9L, 0xA1E6E04EL,
+    0xBFA1B04BL, 0xBB60ADFCL, 0xB6238B25L, 0xB2E29692L,
+    0x8AAD2B2FL, 0x8E6C3698L, 0x832F1041L, 0x87EE0DF6L,
+    0x99A95DF3L, 0x9D684044L, 0x902B669DL, 0x94EA7B2AL,
+    0xE0B41DE7L, 0xE4750050L, 0xE9362689L, 0xEDF73B3EL,
+    0xF3B06B3BL, 0xF771768CL, 0xFA325055L, 0xFEF34DE2L,
+    0xC6BCF05FL, 0xC27DEDE8L, 0xCF3ECB31L, 0xCBFFD686L,
+    0xD5B88683L, 0xD1799B34L, 0xDC3ABDEDL, 0xD8FBA05AL,
+    0x690CE0EEL, 0x6DCDFD59L, 0x608EDB80L, 0x644FC637L,
+    0x7A089632L, 0x7EC98B85L, 0x738AAD5CL, 0x774BB0EBL,
+    0x4F040D56L, 0x4BC510E1L, 0x46863638L, 0x42472B8FL,
+    0x5C007B8AL, 0x58C1663DL, 0x558240E4L, 0x51435D53L,
+    0x251D3B9EL, 0x21DC2629L, 0x2C9F00F0L, 0x285E1D47L,
+    0x36194D42L, 0x32D850F5L, 0x3F9B762CL, 0x3B5A6B9BL,
+    0x0315D626L, 0x07D4CB91L, 0x0A97ED48L, 0x0E56F0FFL,
+    0x1011A0FAL, 0x14D0BD4DL, 0x19939B94L, 0x1D528623L,
+    0xF12F560EL, 0xF5EE4BB9L, 0xF8AD6D60L, 0xFC6C70D7L,
+    0xE22B20D2L, 0xE6EA3D65L, 0xEBA91BBCL, 0xEF68060BL,
+    0xD727BBB6L, 0xD3E6A601L, 0xDEA580D8L, 0xDA649D6FL,
+    0xC423CD6AL, 0xC0E2D0DDL, 0xCDA1F604L, 0xC960EBB3L,
+    0xBD3E8D7EL, 0xB9FF90C9L, 0xB4BCB610L, 0xB07DABA7L,
+    0xAE3AFBA2L, 0xAAFBE615L, 0xA7B8C0CCL, 0xA379DD7BL,
+    0x9B3660C6L, 0x9FF77D71L, 0x92B45BA8L, 0x9675461FL,
+    0x8832161AL, 0x8CF30BADL, 0x81B02D74L, 0x857130C3L,
+    0x5D8A9099L, 0x594B8D2EL, 0x5408ABF7L, 0x50C9B640L,
+    0x4E8EE645L, 0x4A4FFBF2L, 0x470CDD2BL, 0x43CDC09CL,
+    0x7B827D21L, 0x7F436096L, 0x7200464FL, 0x76C15BF8L,
+    0x68860BFDL, 0x6C47164AL, 0x61043093L, 0x65C52D24L,
+    0x119B4BE9L, 0x155A565EL, 0x18197087L, 0x1CD86D30L,
+    0x029F3D35L, 0x065E2082L, 0x0B1D065BL, 0x0FDC1BECL,
+    0x3793A651L, 0x3352BBE6L, 0x3E119D3FL, 0x3AD08088L,
+    0x2497D08DL, 0x2056CD3AL, 0x2D15EBE3L, 0x29D4F654L,
+    0xC5A92679L, 0xC1683BCEL, 0xCC2B1D17L, 0xC8EA00A0L,
+    0xD6AD50A5L, 0xD26C4D12L, 0xDF2F6BCBL, 0xDBEE767CL,
+    0xE3A1CBC1L, 0xE760D676L, 0xEA23F0AFL, 0xEEE2ED18L,
+    0xF0A5BD1DL, 0xF464A0AAL, 0xF9278673L, 0xFDE69BC4L,
+    0x89B8FD09L, 0x8D79E0BEL, 0x803AC667L, 0x84FBDBD0L,
+    0x9ABC8BD5L, 0x9E7D9662L, 0x933EB0BBL, 0x97FFAD0CL,
+    0xAFB010B1L, 0xAB710D06L, 0xA6322BDFL, 0xA2F33668L,
+    0xBCB4666DL, 0xB8757BDAL, 0xB5365D03L, 0xB1F740B4L
+};
+#endif
+static MA_INLINE ma_uint32 ma_dr_flac_crc32_byte(ma_uint32 crc32, ma_uint8 data)
+{
+#ifndef MA_DR_FLAC_NO_CRC
+    return (crc32 << 8) ^ ma_dr_flac__crc32_table[(ma_uint8)((crc32 >> 24) & 0xFF) ^ data];
+#else
+    (void)data;
+    return crc32;
+#endif
+}
+#if 0
+static MA_INLINE ma_uint32 ma_dr_flac_crc32_uint32(ma_uint32 crc32, ma_uint32 data)
+{
+    crc32 = ma_dr_flac_crc32_byte(crc32, (ma_uint8)((data >> 24) & 0xFF));
+    crc32 = ma_dr_flac_crc32_byte(crc32, (ma_uint8)((data >> 16) & 0xFF));
+    crc32 = ma_dr_flac_crc32_byte(crc32, (ma_uint8)((data >>  8) & 0xFF));
+    crc32 = ma_dr_flac_crc32_byte(crc32, (ma_uint8)((data >>  0) & 0xFF));
+    return crc32;
+}
+static MA_INLINE ma_uint32 ma_dr_flac_crc32_uint64(ma_uint32 crc32, ma_uint64 data)
+{
+    crc32 = ma_dr_flac_crc32_uint32(crc32, (ma_uint32)((data >> 32) & 0xFFFFFFFF));
+    crc32 = ma_dr_flac_crc32_uint32(crc32, (ma_uint32)((data >>  0) & 0xFFFFFFFF));
+    return crc32;
+}
+#endif
+static MA_INLINE ma_uint32 ma_dr_flac_crc32_buffer(ma_uint32 crc32, ma_uint8* pData, ma_uint32 dataSize)
+{
+    ma_uint32 i;
+    for (i = 0; i < dataSize; ++i) {
+        crc32 = ma_dr_flac_crc32_byte(crc32, pData[i]);
+    }
+    return crc32;
+}
+static MA_INLINE ma_bool32 ma_dr_flac_ogg__is_capture_pattern(ma_uint8 pattern[4])
+{
+    return pattern[0] == 'O' && pattern[1] == 'g' && pattern[2] == 'g' && pattern[3] == 'S';
+}
+static MA_INLINE ma_uint32 ma_dr_flac_ogg__get_page_header_size(ma_dr_flac_ogg_page_header* pHeader)
+{
+    return 27 + pHeader->segmentCount;
+}
+static MA_INLINE ma_uint32 ma_dr_flac_ogg__get_page_body_size(ma_dr_flac_ogg_page_header* pHeader)
+{
+    ma_uint32 pageBodySize = 0;
+    int i;
+    for (i = 0; i < pHeader->segmentCount; ++i) {
+        pageBodySize += pHeader->segmentTable[i];
+    }
+    return pageBodySize;
+}
+static ma_result ma_dr_flac_ogg__read_page_header_after_capture_pattern(ma_dr_flac_read_proc onRead, void* pUserData, ma_dr_flac_ogg_page_header* pHeader, ma_uint32* pBytesRead, ma_uint32* pCRC32)
+{
+    ma_uint8 data[23];
+    ma_uint32 i;
+    MA_DR_FLAC_ASSERT(*pCRC32 == MA_DR_FLAC_OGG_CAPTURE_PATTERN_CRC32);
+    if (onRead(pUserData, data, 23) != 23) {
+        return MA_AT_END;
+    }
+    *pBytesRead += 23;
+    pHeader->capturePattern[0] = 'O';
+    pHeader->capturePattern[1] = 'g';
+    pHeader->capturePattern[2] = 'g';
+    pHeader->capturePattern[3] = 'S';
+    pHeader->structureVersion = data[0];
+    pHeader->headerType       = data[1];
+    MA_DR_FLAC_COPY_MEMORY(&pHeader->granulePosition, &data[ 2], 8);
+    MA_DR_FLAC_COPY_MEMORY(&pHeader->serialNumber,    &data[10], 4);
+    MA_DR_FLAC_COPY_MEMORY(&pHeader->sequenceNumber,  &data[14], 4);
+    MA_DR_FLAC_COPY_MEMORY(&pHeader->checksum,        &data[18], 4);
+    pHeader->segmentCount     = data[22];
+    data[18] = 0;
+    data[19] = 0;
+    data[20] = 0;
+    data[21] = 0;
+    for (i = 0; i < 23; ++i) {
+        *pCRC32 = ma_dr_flac_crc32_byte(*pCRC32, data[i]);
+    }
+    if (onRead(pUserData, pHeader->segmentTable, pHeader->segmentCount) != pHeader->segmentCount) {
+        return MA_AT_END;
+    }
+    *pBytesRead += pHeader->segmentCount;
+    for (i = 0; i < pHeader->segmentCount; ++i) {
+        *pCRC32 = ma_dr_flac_crc32_byte(*pCRC32, pHeader->segmentTable[i]);
+    }
+    return MA_SUCCESS;
+}
+static ma_result ma_dr_flac_ogg__read_page_header(ma_dr_flac_read_proc onRead, void* pUserData, ma_dr_flac_ogg_page_header* pHeader, ma_uint32* pBytesRead, ma_uint32* pCRC32)
+{
+    ma_uint8 id[4];
+    *pBytesRead = 0;
+    if (onRead(pUserData, id, 4) != 4) {
+        return MA_AT_END;
+    }
+    *pBytesRead += 4;
+    for (;;) {
+        if (ma_dr_flac_ogg__is_capture_pattern(id)) {
+            ma_result result;
+            *pCRC32 = MA_DR_FLAC_OGG_CAPTURE_PATTERN_CRC32;
+            result = ma_dr_flac_ogg__read_page_header_after_capture_pattern(onRead, pUserData, pHeader, pBytesRead, pCRC32);
+            if (result == MA_SUCCESS) {
+                return MA_SUCCESS;
+            } else {
+                if (result == MA_CRC_MISMATCH) {
+                    continue;
+                } else {
+                    return result;
+                }
+            }
+        } else {
+            id[0] = id[1];
+            id[1] = id[2];
+            id[2] = id[3];
+            if (onRead(pUserData, &id[3], 1) != 1) {
+                return MA_AT_END;
+            }
+            *pBytesRead += 1;
+        }
+    }
+}
+typedef struct
+{
+    ma_dr_flac_read_proc onRead;
+    ma_dr_flac_seek_proc onSeek;
+    void* pUserData;
+    ma_uint64 currentBytePos;
+    ma_uint64 firstBytePos;
+    ma_uint32 serialNumber;
+    ma_dr_flac_ogg_page_header bosPageHeader;
+    ma_dr_flac_ogg_page_header currentPageHeader;
+    ma_uint32 bytesRemainingInPage;
+    ma_uint32 pageDataSize;
+    ma_uint8 pageData[MA_DR_FLAC_OGG_MAX_PAGE_SIZE];
+} ma_dr_flac_oggbs;
+static size_t ma_dr_flac_oggbs__read_physical(ma_dr_flac_oggbs* oggbs, void* bufferOut, size_t bytesToRead)
+{
+    size_t bytesActuallyRead = oggbs->onRead(oggbs->pUserData, bufferOut, bytesToRead);
+    oggbs->currentBytePos += bytesActuallyRead;
+    return bytesActuallyRead;
+}
+static ma_bool32 ma_dr_flac_oggbs__seek_physical(ma_dr_flac_oggbs* oggbs, ma_uint64 offset, ma_dr_flac_seek_origin origin)
+{
+    if (origin == ma_dr_flac_seek_origin_start) {
+        if (offset <= 0x7FFFFFFF) {
+            if (!oggbs->onSeek(oggbs->pUserData, (int)offset, ma_dr_flac_seek_origin_start)) {
+                return MA_FALSE;
+            }
+            oggbs->currentBytePos = offset;
+            return MA_TRUE;
+        } else {
+            if (!oggbs->onSeek(oggbs->pUserData, 0x7FFFFFFF, ma_dr_flac_seek_origin_start)) {
+                return MA_FALSE;
+            }
+            oggbs->currentBytePos = offset;
+            return ma_dr_flac_oggbs__seek_physical(oggbs, offset - 0x7FFFFFFF, ma_dr_flac_seek_origin_current);
+        }
+    } else {
+        while (offset > 0x7FFFFFFF) {
+            if (!oggbs->onSeek(oggbs->pUserData, 0x7FFFFFFF, ma_dr_flac_seek_origin_current)) {
+                return MA_FALSE;
+            }
+            oggbs->currentBytePos += 0x7FFFFFFF;
+            offset -= 0x7FFFFFFF;
+        }
+        if (!oggbs->onSeek(oggbs->pUserData, (int)offset, ma_dr_flac_seek_origin_current)) {
+            return MA_FALSE;
+        }
+        oggbs->currentBytePos += offset;
+        return MA_TRUE;
+    }
+}
+static ma_bool32 ma_dr_flac_oggbs__goto_next_page(ma_dr_flac_oggbs* oggbs, ma_dr_flac_ogg_crc_mismatch_recovery recoveryMethod)
+{
+    ma_dr_flac_ogg_page_header header;
+    for (;;) {
+        ma_uint32 crc32 = 0;
+        ma_uint32 bytesRead;
+        ma_uint32 pageBodySize;
+#ifndef MA_DR_FLAC_NO_CRC
+        ma_uint32 actualCRC32;
+#endif
+        if (ma_dr_flac_ogg__read_page_header(oggbs->onRead, oggbs->pUserData, &header, &bytesRead, &crc32) != MA_SUCCESS) {
+            return MA_FALSE;
+        }
+        oggbs->currentBytePos += bytesRead;
+        pageBodySize = ma_dr_flac_ogg__get_page_body_size(&header);
+        if (pageBodySize > MA_DR_FLAC_OGG_MAX_PAGE_SIZE) {
+            continue;
+        }
+        if (header.serialNumber != oggbs->serialNumber) {
+            if (pageBodySize > 0 && !ma_dr_flac_oggbs__seek_physical(oggbs, pageBodySize, ma_dr_flac_seek_origin_current)) {
+                return MA_FALSE;
+            }
+            continue;
+        }
+        if (ma_dr_flac_oggbs__read_physical(oggbs, oggbs->pageData, pageBodySize) != pageBodySize) {
+            return MA_FALSE;
+        }
+        oggbs->pageDataSize = pageBodySize;
+#ifndef MA_DR_FLAC_NO_CRC
+        actualCRC32 = ma_dr_flac_crc32_buffer(crc32, oggbs->pageData, oggbs->pageDataSize);
+        if (actualCRC32 != header.checksum) {
+            if (recoveryMethod == ma_dr_flac_ogg_recover_on_crc_mismatch) {
+                continue;
+            } else {
+                ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_recover_on_crc_mismatch);
+                return MA_FALSE;
+            }
+        }
+#else
+        (void)recoveryMethod;
+#endif
+        oggbs->currentPageHeader = header;
+        oggbs->bytesRemainingInPage = pageBodySize;
+        return MA_TRUE;
+    }
+}
+#if 0
+static ma_uint8 ma_dr_flac_oggbs__get_current_segment_index(ma_dr_flac_oggbs* oggbs, ma_uint8* pBytesRemainingInSeg)
+{
+    ma_uint32 bytesConsumedInPage = ma_dr_flac_ogg__get_page_body_size(&oggbs->currentPageHeader) - oggbs->bytesRemainingInPage;
+    ma_uint8 iSeg = 0;
+    ma_uint32 iByte = 0;
+    while (iByte < bytesConsumedInPage) {
+        ma_uint8 segmentSize = oggbs->currentPageHeader.segmentTable[iSeg];
+        if (iByte + segmentSize > bytesConsumedInPage) {
+            break;
+        } else {
+            iSeg += 1;
+            iByte += segmentSize;
+        }
+    }
+    *pBytesRemainingInSeg = oggbs->currentPageHeader.segmentTable[iSeg] - (ma_uint8)(bytesConsumedInPage - iByte);
+    return iSeg;
+}
+static ma_bool32 ma_dr_flac_oggbs__seek_to_next_packet(ma_dr_flac_oggbs* oggbs)
+{
+    for (;;) {
+        ma_bool32 atEndOfPage = MA_FALSE;
+        ma_uint8 bytesRemainingInSeg;
+        ma_uint8 iFirstSeg = ma_dr_flac_oggbs__get_current_segment_index(oggbs, &bytesRemainingInSeg);
+        ma_uint32 bytesToEndOfPacketOrPage = bytesRemainingInSeg;
+        for (ma_uint8 iSeg = iFirstSeg; iSeg < oggbs->currentPageHeader.segmentCount; ++iSeg) {
+            ma_uint8 segmentSize = oggbs->currentPageHeader.segmentTable[iSeg];
+            if (segmentSize < 255) {
+                if (iSeg == oggbs->currentPageHeader.segmentCount-1) {
+                    atEndOfPage = MA_TRUE;
+                }
+                break;
+            }
+            bytesToEndOfPacketOrPage += segmentSize;
+        }
+        ma_dr_flac_oggbs__seek_physical(oggbs, bytesToEndOfPacketOrPage, ma_dr_flac_seek_origin_current);
+        oggbs->bytesRemainingInPage -= bytesToEndOfPacketOrPage;
+        if (atEndOfPage) {
+            if (!ma_dr_flac_oggbs__goto_next_page(oggbs)) {
+                return MA_FALSE;
+            }
+            if ((oggbs->currentPageHeader.headerType & 0x01) == 0) {
+                return MA_TRUE;
+            }
+        } else {
+            return MA_TRUE;
+        }
+    }
+}
+static ma_bool32 ma_dr_flac_oggbs__seek_to_next_frame(ma_dr_flac_oggbs* oggbs)
+{
+    return ma_dr_flac_oggbs__seek_to_next_packet(oggbs);
+}
+#endif
+static size_t ma_dr_flac__on_read_ogg(void* pUserData, void* bufferOut, size_t bytesToRead)
+{
+    ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pUserData;
+    ma_uint8* pRunningBufferOut = (ma_uint8*)bufferOut;
+    size_t bytesRead = 0;
+    MA_DR_FLAC_ASSERT(oggbs != NULL);
+    MA_DR_FLAC_ASSERT(pRunningBufferOut != NULL);
+    while (bytesRead < bytesToRead) {
+        size_t bytesRemainingToRead = bytesToRead - bytesRead;
+        if (oggbs->bytesRemainingInPage >= bytesRemainingToRead) {
+            MA_DR_FLAC_COPY_MEMORY(pRunningBufferOut, oggbs->pageData + (oggbs->pageDataSize - oggbs->bytesRemainingInPage), bytesRemainingToRead);
+            bytesRead += bytesRemainingToRead;
+            oggbs->bytesRemainingInPage -= (ma_uint32)bytesRemainingToRead;
+            break;
+        }
+        if (oggbs->bytesRemainingInPage > 0) {
+            MA_DR_FLAC_COPY_MEMORY(pRunningBufferOut, oggbs->pageData + (oggbs->pageDataSize - oggbs->bytesRemainingInPage), oggbs->bytesRemainingInPage);
+            bytesRead += oggbs->bytesRemainingInPage;
+            pRunningBufferOut += oggbs->bytesRemainingInPage;
+            oggbs->bytesRemainingInPage = 0;
+        }
+        MA_DR_FLAC_ASSERT(bytesRemainingToRead > 0);
+        if (!ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_recover_on_crc_mismatch)) {
+            break;
+        }
+    }
+    return bytesRead;
+}
+static ma_bool32 ma_dr_flac__on_seek_ogg(void* pUserData, int offset, ma_dr_flac_seek_origin origin)
+{
+    ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pUserData;
+    int bytesSeeked = 0;
+    MA_DR_FLAC_ASSERT(oggbs != NULL);
+    MA_DR_FLAC_ASSERT(offset >= 0);
+    if (origin == ma_dr_flac_seek_origin_start) {
+        if (!ma_dr_flac_oggbs__seek_physical(oggbs, (int)oggbs->firstBytePos, ma_dr_flac_seek_origin_start)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_fail_on_crc_mismatch)) {
+            return MA_FALSE;
+        }
+        return ma_dr_flac__on_seek_ogg(pUserData, offset, ma_dr_flac_seek_origin_current);
+    }
+    MA_DR_FLAC_ASSERT(origin == ma_dr_flac_seek_origin_current);
+    while (bytesSeeked < offset) {
+        int bytesRemainingToSeek = offset - bytesSeeked;
+        MA_DR_FLAC_ASSERT(bytesRemainingToSeek >= 0);
+        if (oggbs->bytesRemainingInPage >= (size_t)bytesRemainingToSeek) {
+            bytesSeeked += bytesRemainingToSeek;
+            (void)bytesSeeked;
+            oggbs->bytesRemainingInPage -= bytesRemainingToSeek;
+            break;
+        }
+        if (oggbs->bytesRemainingInPage > 0) {
+            bytesSeeked += (int)oggbs->bytesRemainingInPage;
+            oggbs->bytesRemainingInPage = 0;
+        }
+        MA_DR_FLAC_ASSERT(bytesRemainingToSeek > 0);
+        if (!ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_fail_on_crc_mismatch)) {
+            return MA_FALSE;
+        }
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_flac_ogg__seek_to_pcm_frame(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex)
+{
+    ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pFlac->_oggbs;
+    ma_uint64 originalBytePos;
+    ma_uint64 runningGranulePosition;
+    ma_uint64 runningFrameBytePos;
+    ma_uint64 runningPCMFrameCount;
+    MA_DR_FLAC_ASSERT(oggbs != NULL);
+    originalBytePos = oggbs->currentBytePos;
+    if (!ma_dr_flac__seek_to_byte(&pFlac->bs, pFlac->firstFLACFramePosInBytes)) {
+        return MA_FALSE;
+    }
+    oggbs->bytesRemainingInPage = 0;
+    runningGranulePosition = 0;
+    for (;;) {
+        if (!ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_recover_on_crc_mismatch)) {
+            ma_dr_flac_oggbs__seek_physical(oggbs, originalBytePos, ma_dr_flac_seek_origin_start);
+            return MA_FALSE;
+        }
+        runningFrameBytePos = oggbs->currentBytePos - ma_dr_flac_ogg__get_page_header_size(&oggbs->currentPageHeader) - oggbs->pageDataSize;
+        if (oggbs->currentPageHeader.granulePosition >= pcmFrameIndex) {
+            break;
+        }
+        if ((oggbs->currentPageHeader.headerType & 0x01) == 0) {
+            if (oggbs->currentPageHeader.segmentTable[0] >= 2) {
+                ma_uint8 firstBytesInPage[2];
+                firstBytesInPage[0] = oggbs->pageData[0];
+                firstBytesInPage[1] = oggbs->pageData[1];
+                if ((firstBytesInPage[0] == 0xFF) && (firstBytesInPage[1] & 0xFC) == 0xF8) {
+                    runningGranulePosition = oggbs->currentPageHeader.granulePosition;
+                }
+                continue;
+            }
+        }
+    }
+    if (!ma_dr_flac_oggbs__seek_physical(oggbs, runningFrameBytePos, ma_dr_flac_seek_origin_start)) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_flac_oggbs__goto_next_page(oggbs, ma_dr_flac_ogg_recover_on_crc_mismatch)) {
+        return MA_FALSE;
+    }
+    runningPCMFrameCount = runningGranulePosition;
+    for (;;) {
+        ma_uint64 firstPCMFrameInFLACFrame = 0;
+        ma_uint64 lastPCMFrameInFLACFrame = 0;
+        ma_uint64 pcmFrameCountInThisFrame;
+        if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+            return MA_FALSE;
+        }
+        ma_dr_flac__get_pcm_frame_range_of_current_flac_frame(pFlac, &firstPCMFrameInFLACFrame, &lastPCMFrameInFLACFrame);
+        pcmFrameCountInThisFrame = (lastPCMFrameInFLACFrame - firstPCMFrameInFLACFrame) + 1;
+        if (pcmFrameIndex == pFlac->totalPCMFrameCount && (runningPCMFrameCount + pcmFrameCountInThisFrame) == pFlac->totalPCMFrameCount) {
+            ma_result result = ma_dr_flac__decode_flac_frame(pFlac);
+            if (result == MA_SUCCESS) {
+                pFlac->currentPCMFrame = pcmFrameIndex;
+                pFlac->currentFLACFrame.pcmFramesRemaining = 0;
+                return MA_TRUE;
+            } else {
+                return MA_FALSE;
+            }
+        }
+        if (pcmFrameIndex < (runningPCMFrameCount + pcmFrameCountInThisFrame)) {
+            ma_result result = ma_dr_flac__decode_flac_frame(pFlac);
+            if (result == MA_SUCCESS) {
+                ma_uint64 pcmFramesToDecode = (size_t)(pcmFrameIndex - runningPCMFrameCount);
+                if (pcmFramesToDecode == 0) {
+                    return MA_TRUE;
+                }
+                pFlac->currentPCMFrame = runningPCMFrameCount;
+                return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, pcmFramesToDecode) == pcmFramesToDecode;
+            } else {
+                if (result == MA_CRC_MISMATCH) {
+                    continue;
+                } else {
+                    return MA_FALSE;
+                }
+            }
+        } else {
+            ma_result result = ma_dr_flac__seek_to_next_flac_frame(pFlac);
+            if (result == MA_SUCCESS) {
+                runningPCMFrameCount += pcmFrameCountInThisFrame;
+            } else {
+                if (result == MA_CRC_MISMATCH) {
+                    continue;
+                } else {
+                    return MA_FALSE;
+                }
+            }
+        }
+    }
+}
+static ma_bool32 ma_dr_flac__init_private__ogg(ma_dr_flac_init_info* pInit, ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, void* pUserData, void* pUserDataMD, ma_bool32 relaxed)
+{
+    ma_dr_flac_ogg_page_header header;
+    ma_uint32 crc32 = MA_DR_FLAC_OGG_CAPTURE_PATTERN_CRC32;
+    ma_uint32 bytesRead = 0;
+    (void)relaxed;
+    pInit->container = ma_dr_flac_container_ogg;
+    pInit->oggFirstBytePos = 0;
+    if (ma_dr_flac_ogg__read_page_header_after_capture_pattern(onRead, pUserData, &header, &bytesRead, &crc32) != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    pInit->runningFilePos += bytesRead;
+    for (;;) {
+        int pageBodySize;
+        if ((header.headerType & 0x02) == 0) {
+            return MA_FALSE;
+        }
+        pageBodySize = ma_dr_flac_ogg__get_page_body_size(&header);
+        if (pageBodySize == 51) {
+            ma_uint32 bytesRemainingInPage = pageBodySize;
+            ma_uint8 packetType;
+            if (onRead(pUserData, &packetType, 1) != 1) {
+                return MA_FALSE;
+            }
+            bytesRemainingInPage -= 1;
+            if (packetType == 0x7F) {
+                ma_uint8 sig[4];
+                if (onRead(pUserData, sig, 4) != 4) {
+                    return MA_FALSE;
+                }
+                bytesRemainingInPage -= 4;
+                if (sig[0] == 'F' && sig[1] == 'L' && sig[2] == 'A' && sig[3] == 'C') {
+                    ma_uint8 mappingVersion[2];
+                    if (onRead(pUserData, mappingVersion, 2) != 2) {
+                        return MA_FALSE;
+                    }
+                    if (mappingVersion[0] != 1) {
+                        return MA_FALSE;
+                    }
+                    if (!onSeek(pUserData, 2, ma_dr_flac_seek_origin_current)) {
+                        return MA_FALSE;
+                    }
+                    if (onRead(pUserData, sig, 4) != 4) {
+                        return MA_FALSE;
+                    }
+                    if (sig[0] == 'f' && sig[1] == 'L' && sig[2] == 'a' && sig[3] == 'C') {
+                        ma_dr_flac_streaminfo streaminfo;
+                        ma_uint8 isLastBlock;
+                        ma_uint8 blockType;
+                        ma_uint32 blockSize;
+                        if (!ma_dr_flac__read_and_decode_block_header(onRead, pUserData, &isLastBlock, &blockType, &blockSize)) {
+                            return MA_FALSE;
+                        }
+                        if (blockType != MA_DR_FLAC_METADATA_BLOCK_TYPE_STREAMINFO || blockSize != 34) {
+                            return MA_FALSE;
+                        }
+                        if (ma_dr_flac__read_streaminfo(onRead, pUserData, &streaminfo)) {
+                            pInit->hasStreamInfoBlock      = MA_TRUE;
+                            pInit->sampleRate              = streaminfo.sampleRate;
+                            pInit->channels                = streaminfo.channels;
+                            pInit->bitsPerSample           = streaminfo.bitsPerSample;
+                            pInit->totalPCMFrameCount      = streaminfo.totalPCMFrameCount;
+                            pInit->maxBlockSizeInPCMFrames = streaminfo.maxBlockSizeInPCMFrames;
+                            pInit->hasMetadataBlocks       = !isLastBlock;
+                            if (onMeta) {
+                                ma_dr_flac_metadata metadata;
+                                metadata.type = MA_DR_FLAC_METADATA_BLOCK_TYPE_STREAMINFO;
+                                metadata.pRawData = NULL;
+                                metadata.rawDataSize = 0;
+                                metadata.data.streaminfo = streaminfo;
+                                onMeta(pUserDataMD, &metadata);
+                            }
+                            pInit->runningFilePos  += pageBodySize;
+                            pInit->oggFirstBytePos  = pInit->runningFilePos - 79;
+                            pInit->oggSerial        = header.serialNumber;
+                            pInit->oggBosHeader     = header;
+                            break;
+                        } else {
+                            return MA_FALSE;
+                        }
+                    } else {
+                        return MA_FALSE;
+                    }
+                } else {
+                    if (!onSeek(pUserData, bytesRemainingInPage, ma_dr_flac_seek_origin_current)) {
+                        return MA_FALSE;
+                    }
+                }
+            } else {
+                if (!onSeek(pUserData, bytesRemainingInPage, ma_dr_flac_seek_origin_current)) {
+                    return MA_FALSE;
+                }
+            }
+        } else {
+            if (!onSeek(pUserData, pageBodySize, ma_dr_flac_seek_origin_current)) {
+                return MA_FALSE;
+            }
+        }
+        pInit->runningFilePos += pageBodySize;
+        if (ma_dr_flac_ogg__read_page_header(onRead, pUserData, &header, &bytesRead, &crc32) != MA_SUCCESS) {
+            return MA_FALSE;
+        }
+        pInit->runningFilePos += bytesRead;
+    }
+    pInit->hasMetadataBlocks = MA_TRUE;
+    return MA_TRUE;
+}
+#endif
+static ma_bool32 ma_dr_flac__init_private(ma_dr_flac_init_info* pInit, ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, ma_dr_flac_container container, void* pUserData, void* pUserDataMD)
+{
+    ma_bool32 relaxed;
+    ma_uint8 id[4];
+    if (pInit == NULL || onRead == NULL || onSeek == NULL) {
+        return MA_FALSE;
+    }
+    MA_DR_FLAC_ZERO_MEMORY(pInit, sizeof(*pInit));
+    pInit->onRead       = onRead;
+    pInit->onSeek       = onSeek;
+    pInit->onMeta       = onMeta;
+    pInit->container    = container;
+    pInit->pUserData    = pUserData;
+    pInit->pUserDataMD  = pUserDataMD;
+    pInit->bs.onRead    = onRead;
+    pInit->bs.onSeek    = onSeek;
+    pInit->bs.pUserData = pUserData;
+    ma_dr_flac__reset_cache(&pInit->bs);
+    relaxed = container != ma_dr_flac_container_unknown;
+    for (;;) {
+        if (onRead(pUserData, id, 4) != 4) {
+            return MA_FALSE;
+        }
+        pInit->runningFilePos += 4;
+        if (id[0] == 'I' && id[1] == 'D' && id[2] == '3') {
+            ma_uint8 header[6];
+            ma_uint8 flags;
+            ma_uint32 headerSize;
+            if (onRead(pUserData, header, 6) != 6) {
+                return MA_FALSE;
+            }
+            pInit->runningFilePos += 6;
+            flags = header[1];
+            MA_DR_FLAC_COPY_MEMORY(&headerSize, header+2, 4);
+            headerSize = ma_dr_flac__unsynchsafe_32(ma_dr_flac__be2host_32(headerSize));
+            if (flags & 0x10) {
+                headerSize += 10;
+            }
+            if (!onSeek(pUserData, headerSize, ma_dr_flac_seek_origin_current)) {
+                return MA_FALSE;
+            }
+            pInit->runningFilePos += headerSize;
+        } else {
+            break;
+        }
+    }
+    if (id[0] == 'f' && id[1] == 'L' && id[2] == 'a' && id[3] == 'C') {
+        return ma_dr_flac__init_private__native(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+    }
+#ifndef MA_DR_FLAC_NO_OGG
+    if (id[0] == 'O' && id[1] == 'g' && id[2] == 'g' && id[3] == 'S') {
+        return ma_dr_flac__init_private__ogg(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+    }
+#endif
+    if (relaxed) {
+        if (container == ma_dr_flac_container_native) {
+            return ma_dr_flac__init_private__native(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+        }
+#ifndef MA_DR_FLAC_NO_OGG
+        if (container == ma_dr_flac_container_ogg) {
+            return ma_dr_flac__init_private__ogg(pInit, onRead, onSeek, onMeta, pUserData, pUserDataMD, relaxed);
+        }
+#endif
+    }
+    return MA_FALSE;
+}
+static void ma_dr_flac__init_from_info(ma_dr_flac* pFlac, const ma_dr_flac_init_info* pInit)
+{
+    MA_DR_FLAC_ASSERT(pFlac != NULL);
+    MA_DR_FLAC_ASSERT(pInit != NULL);
+    MA_DR_FLAC_ZERO_MEMORY(pFlac, sizeof(*pFlac));
+    pFlac->bs                      = pInit->bs;
+    pFlac->onMeta                  = pInit->onMeta;
+    pFlac->pUserDataMD             = pInit->pUserDataMD;
+    pFlac->maxBlockSizeInPCMFrames = pInit->maxBlockSizeInPCMFrames;
+    pFlac->sampleRate              = pInit->sampleRate;
+    pFlac->channels                = (ma_uint8)pInit->channels;
+    pFlac->bitsPerSample           = (ma_uint8)pInit->bitsPerSample;
+    pFlac->totalPCMFrameCount      = pInit->totalPCMFrameCount;
+    pFlac->container               = pInit->container;
+}
+static ma_dr_flac* ma_dr_flac_open_with_metadata_private(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, ma_dr_flac_container container, void* pUserData, void* pUserDataMD, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac_init_info init;
+    ma_uint32 allocationSize;
+    ma_uint32 wholeSIMDVectorCountPerChannel;
+    ma_uint32 decodedSamplesAllocationSize;
+#ifndef MA_DR_FLAC_NO_OGG
+    ma_dr_flac_oggbs* pOggbs = NULL;
+#endif
+    ma_uint64 firstFramePos;
+    ma_uint64 seektablePos;
+    ma_uint32 seekpointCount;
+    ma_allocation_callbacks allocationCallbacks;
+    ma_dr_flac* pFlac;
+    ma_dr_flac__init_cpu_caps();
+    if (!ma_dr_flac__init_private(&init, onRead, onSeek, onMeta, container, pUserData, pUserDataMD)) {
+        return NULL;
+    }
+    if (pAllocationCallbacks != NULL) {
+        allocationCallbacks = *pAllocationCallbacks;
+        if (allocationCallbacks.onFree == NULL || (allocationCallbacks.onMalloc == NULL && allocationCallbacks.onRealloc == NULL)) {
+            return NULL;
+        }
+    } else {
+        allocationCallbacks.pUserData = NULL;
+        allocationCallbacks.onMalloc  = ma_dr_flac__malloc_default;
+        allocationCallbacks.onRealloc = ma_dr_flac__realloc_default;
+        allocationCallbacks.onFree    = ma_dr_flac__free_default;
+    }
+    allocationSize = sizeof(ma_dr_flac);
+    if ((init.maxBlockSizeInPCMFrames % (MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE / sizeof(ma_int32))) == 0) {
+        wholeSIMDVectorCountPerChannel = (init.maxBlockSizeInPCMFrames / (MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE / sizeof(ma_int32)));
+    } else {
+        wholeSIMDVectorCountPerChannel = (init.maxBlockSizeInPCMFrames / (MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE / sizeof(ma_int32))) + 1;
+    }
+    decodedSamplesAllocationSize = wholeSIMDVectorCountPerChannel * MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE * init.channels;
+    allocationSize += decodedSamplesAllocationSize;
+    allocationSize += MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE;
+#ifndef MA_DR_FLAC_NO_OGG
+    if (init.container == ma_dr_flac_container_ogg) {
+        allocationSize += sizeof(ma_dr_flac_oggbs);
+        pOggbs = (ma_dr_flac_oggbs*)ma_dr_flac__malloc_from_callbacks(sizeof(*pOggbs), &allocationCallbacks);
+        if (pOggbs == NULL) {
+            return NULL;
+        }
+        MA_DR_FLAC_ZERO_MEMORY(pOggbs, sizeof(*pOggbs));
+        pOggbs->onRead = onRead;
+        pOggbs->onSeek = onSeek;
+        pOggbs->pUserData = pUserData;
+        pOggbs->currentBytePos = init.oggFirstBytePos;
+        pOggbs->firstBytePos = init.oggFirstBytePos;
+        pOggbs->serialNumber = init.oggSerial;
+        pOggbs->bosPageHeader = init.oggBosHeader;
+        pOggbs->bytesRemainingInPage = 0;
+    }
+#endif
+    firstFramePos  = 42;
+    seektablePos   = 0;
+    seekpointCount = 0;
+    if (init.hasMetadataBlocks) {
+        ma_dr_flac_read_proc onReadOverride = onRead;
+        ma_dr_flac_seek_proc onSeekOverride = onSeek;
+        void* pUserDataOverride = pUserData;
+#ifndef MA_DR_FLAC_NO_OGG
+        if (init.container == ma_dr_flac_container_ogg) {
+            onReadOverride = ma_dr_flac__on_read_ogg;
+            onSeekOverride = ma_dr_flac__on_seek_ogg;
+            pUserDataOverride = (void*)pOggbs;
+        }
+#endif
+        if (!ma_dr_flac__read_and_decode_metadata(onReadOverride, onSeekOverride, onMeta, pUserDataOverride, pUserDataMD, &firstFramePos, &seektablePos, &seekpointCount, &allocationCallbacks)) {
+        #ifndef MA_DR_FLAC_NO_OGG
+            ma_dr_flac__free_from_callbacks(pOggbs, &allocationCallbacks);
+        #endif
+            return NULL;
+        }
+        allocationSize += seekpointCount * sizeof(ma_dr_flac_seekpoint);
+    }
+    pFlac = (ma_dr_flac*)ma_dr_flac__malloc_from_callbacks(allocationSize, &allocationCallbacks);
+    if (pFlac == NULL) {
+    #ifndef MA_DR_FLAC_NO_OGG
+        ma_dr_flac__free_from_callbacks(pOggbs, &allocationCallbacks);
+    #endif
+        return NULL;
+    }
+    ma_dr_flac__init_from_info(pFlac, &init);
+    pFlac->allocationCallbacks = allocationCallbacks;
+    pFlac->pDecodedSamples = (ma_int32*)ma_dr_flac_align((size_t)pFlac->pExtraData, MA_DR_FLAC_MAX_SIMD_VECTOR_SIZE);
+#ifndef MA_DR_FLAC_NO_OGG
+    if (init.container == ma_dr_flac_container_ogg) {
+        ma_dr_flac_oggbs* pInternalOggbs = (ma_dr_flac_oggbs*)((ma_uint8*)pFlac->pDecodedSamples + decodedSamplesAllocationSize + (seekpointCount * sizeof(ma_dr_flac_seekpoint)));
+        MA_DR_FLAC_COPY_MEMORY(pInternalOggbs, pOggbs, sizeof(*pOggbs));
+        ma_dr_flac__free_from_callbacks(pOggbs, &allocationCallbacks);
+        pOggbs = NULL;
+        pFlac->bs.onRead = ma_dr_flac__on_read_ogg;
+        pFlac->bs.onSeek = ma_dr_flac__on_seek_ogg;
+        pFlac->bs.pUserData = (void*)pInternalOggbs;
+        pFlac->_oggbs = (void*)pInternalOggbs;
+    }
+#endif
+    pFlac->firstFLACFramePosInBytes = firstFramePos;
+#ifndef MA_DR_FLAC_NO_OGG
+    if (init.container == ma_dr_flac_container_ogg)
+    {
+        pFlac->pSeekpoints = NULL;
+        pFlac->seekpointCount = 0;
+    }
+    else
+#endif
+    {
+        if (seektablePos != 0) {
+            pFlac->seekpointCount = seekpointCount;
+            pFlac->pSeekpoints = (ma_dr_flac_seekpoint*)((ma_uint8*)pFlac->pDecodedSamples + decodedSamplesAllocationSize);
+            MA_DR_FLAC_ASSERT(pFlac->bs.onSeek != NULL);
+            MA_DR_FLAC_ASSERT(pFlac->bs.onRead != NULL);
+            if (pFlac->bs.onSeek(pFlac->bs.pUserData, (int)seektablePos, ma_dr_flac_seek_origin_start)) {
+                ma_uint32 iSeekpoint;
+                for (iSeekpoint = 0; iSeekpoint < seekpointCount; iSeekpoint += 1) {
+                    if (pFlac->bs.onRead(pFlac->bs.pUserData, pFlac->pSeekpoints + iSeekpoint, MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES) == MA_DR_FLAC_SEEKPOINT_SIZE_IN_BYTES) {
+                        pFlac->pSeekpoints[iSeekpoint].firstPCMFrame   = ma_dr_flac__be2host_64(pFlac->pSeekpoints[iSeekpoint].firstPCMFrame);
+                        pFlac->pSeekpoints[iSeekpoint].flacFrameOffset = ma_dr_flac__be2host_64(pFlac->pSeekpoints[iSeekpoint].flacFrameOffset);
+                        pFlac->pSeekpoints[iSeekpoint].pcmFrameCount   = ma_dr_flac__be2host_16(pFlac->pSeekpoints[iSeekpoint].pcmFrameCount);
+                    } else {
+                        pFlac->pSeekpoints = NULL;
+                        pFlac->seekpointCount = 0;
+                        break;
+                    }
+                }
+                if (!pFlac->bs.onSeek(pFlac->bs.pUserData, (int)pFlac->firstFLACFramePosInBytes, ma_dr_flac_seek_origin_start)) {
+                    ma_dr_flac__free_from_callbacks(pFlac, &allocationCallbacks);
+                    return NULL;
+                }
+            } else {
+                pFlac->pSeekpoints = NULL;
+                pFlac->seekpointCount = 0;
+            }
+        }
+    }
+    if (!init.hasStreamInfoBlock) {
+        pFlac->currentFLACFrame.header = init.firstFrameHeader;
+        for (;;) {
+            ma_result result = ma_dr_flac__decode_flac_frame(pFlac);
+            if (result == MA_SUCCESS) {
+                break;
+            } else {
+                if (result == MA_CRC_MISMATCH) {
+                    if (!ma_dr_flac__read_next_flac_frame_header(&pFlac->bs, pFlac->bitsPerSample, &pFlac->currentFLACFrame.header)) {
+                        ma_dr_flac__free_from_callbacks(pFlac, &allocationCallbacks);
+                        return NULL;
+                    }
+                    continue;
+                } else {
+                    ma_dr_flac__free_from_callbacks(pFlac, &allocationCallbacks);
+                    return NULL;
+                }
+            }
+        }
+    }
+    return pFlac;
+}
+#ifndef MA_DR_FLAC_NO_STDIO
+#include <stdio.h>
+#ifndef MA_DR_FLAC_NO_WCHAR
+#include <wchar.h>
+#endif
+static size_t ma_dr_flac__on_read_stdio(void* pUserData, void* bufferOut, size_t bytesToRead)
+{
+    return fread(bufferOut, 1, bytesToRead, (FILE*)pUserData);
+}
+static ma_bool32 ma_dr_flac__on_seek_stdio(void* pUserData, int offset, ma_dr_flac_seek_origin origin)
+{
+    MA_DR_FLAC_ASSERT(offset >= 0);
+    return fseek((FILE*)pUserData, offset, (origin == ma_dr_flac_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0;
+}
+MA_API ma_dr_flac* ma_dr_flac_open_file(const char* pFileName, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    FILE* pFile;
+    if (ma_fopen(&pFile, pFileName, "rb") != MA_SUCCESS) {
+        return NULL;
+    }
+    pFlac = ma_dr_flac_open(ma_dr_flac__on_read_stdio, ma_dr_flac__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        fclose(pFile);
+        return NULL;
+    }
+    return pFlac;
+}
+#ifndef MA_DR_FLAC_NO_WCHAR
+MA_API ma_dr_flac* ma_dr_flac_open_file_w(const wchar_t* pFileName, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    FILE* pFile;
+    if (ma_wfopen(&pFile, pFileName, L"rb", pAllocationCallbacks) != MA_SUCCESS) {
+        return NULL;
+    }
+    pFlac = ma_dr_flac_open(ma_dr_flac__on_read_stdio, ma_dr_flac__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        fclose(pFile);
+        return NULL;
+    }
+    return pFlac;
+}
+#endif
+MA_API ma_dr_flac* ma_dr_flac_open_file_with_metadata(const char* pFileName, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    FILE* pFile;
+    if (ma_fopen(&pFile, pFileName, "rb") != MA_SUCCESS) {
+        return NULL;
+    }
+    pFlac = ma_dr_flac_open_with_metadata_private(ma_dr_flac__on_read_stdio, ma_dr_flac__on_seek_stdio, onMeta, ma_dr_flac_container_unknown, (void*)pFile, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        fclose(pFile);
+        return pFlac;
+    }
+    return pFlac;
+}
+#ifndef MA_DR_FLAC_NO_WCHAR
+MA_API ma_dr_flac* ma_dr_flac_open_file_with_metadata_w(const wchar_t* pFileName, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    FILE* pFile;
+    if (ma_wfopen(&pFile, pFileName, L"rb", pAllocationCallbacks) != MA_SUCCESS) {
+        return NULL;
+    }
+    pFlac = ma_dr_flac_open_with_metadata_private(ma_dr_flac__on_read_stdio, ma_dr_flac__on_seek_stdio, onMeta, ma_dr_flac_container_unknown, (void*)pFile, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        fclose(pFile);
+        return pFlac;
+    }
+    return pFlac;
+}
+#endif
+#endif
+static size_t ma_dr_flac__on_read_memory(void* pUserData, void* bufferOut, size_t bytesToRead)
+{
+    ma_dr_flac__memory_stream* memoryStream = (ma_dr_flac__memory_stream*)pUserData;
+    size_t bytesRemaining;
+    MA_DR_FLAC_ASSERT(memoryStream != NULL);
+    MA_DR_FLAC_ASSERT(memoryStream->dataSize >= memoryStream->currentReadPos);
+    bytesRemaining = memoryStream->dataSize - memoryStream->currentReadPos;
+    if (bytesToRead > bytesRemaining) {
+        bytesToRead = bytesRemaining;
+    }
+    if (bytesToRead > 0) {
+        MA_DR_FLAC_COPY_MEMORY(bufferOut, memoryStream->data + memoryStream->currentReadPos, bytesToRead);
+        memoryStream->currentReadPos += bytesToRead;
+    }
+    return bytesToRead;
+}
+static ma_bool32 ma_dr_flac__on_seek_memory(void* pUserData, int offset, ma_dr_flac_seek_origin origin)
+{
+    ma_dr_flac__memory_stream* memoryStream = (ma_dr_flac__memory_stream*)pUserData;
+    MA_DR_FLAC_ASSERT(memoryStream != NULL);
+    MA_DR_FLAC_ASSERT(offset >= 0);
+    if (offset > (ma_int64)memoryStream->dataSize) {
+        return MA_FALSE;
+    }
+    if (origin == ma_dr_flac_seek_origin_current) {
+        if (memoryStream->currentReadPos + offset <= memoryStream->dataSize) {
+            memoryStream->currentReadPos += offset;
+        } else {
+            return MA_FALSE;
+        }
+    } else {
+        if ((ma_uint32)offset <= memoryStream->dataSize) {
+            memoryStream->currentReadPos = offset;
+        } else {
+            return MA_FALSE;
+        }
+    }
+    return MA_TRUE;
+}
+MA_API ma_dr_flac* ma_dr_flac_open_memory(const void* pData, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac__memory_stream memoryStream;
+    ma_dr_flac* pFlac;
+    memoryStream.data = (const ma_uint8*)pData;
+    memoryStream.dataSize = dataSize;
+    memoryStream.currentReadPos = 0;
+    pFlac = ma_dr_flac_open(ma_dr_flac__on_read_memory, ma_dr_flac__on_seek_memory, &memoryStream, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    pFlac->memoryStream = memoryStream;
+#ifndef MA_DR_FLAC_NO_OGG
+    if (pFlac->container == ma_dr_flac_container_ogg)
+    {
+        ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pFlac->_oggbs;
+        oggbs->pUserData = &pFlac->memoryStream;
+    }
+    else
+#endif
+    {
+        pFlac->bs.pUserData = &pFlac->memoryStream;
+    }
+    return pFlac;
+}
+MA_API ma_dr_flac* ma_dr_flac_open_memory_with_metadata(const void* pData, size_t dataSize, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac__memory_stream memoryStream;
+    ma_dr_flac* pFlac;
+    memoryStream.data = (const ma_uint8*)pData;
+    memoryStream.dataSize = dataSize;
+    memoryStream.currentReadPos = 0;
+    pFlac = ma_dr_flac_open_with_metadata_private(ma_dr_flac__on_read_memory, ma_dr_flac__on_seek_memory, onMeta, ma_dr_flac_container_unknown, &memoryStream, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    pFlac->memoryStream = memoryStream;
+#ifndef MA_DR_FLAC_NO_OGG
+    if (pFlac->container == ma_dr_flac_container_ogg)
+    {
+        ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pFlac->_oggbs;
+        oggbs->pUserData = &pFlac->memoryStream;
+    }
+    else
+#endif
+    {
+        pFlac->bs.pUserData = &pFlac->memoryStream;
+    }
+    return pFlac;
+}
+MA_API ma_dr_flac* ma_dr_flac_open(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_flac_open_with_metadata_private(onRead, onSeek, NULL, ma_dr_flac_container_unknown, pUserData, pUserData, pAllocationCallbacks);
+}
+MA_API ma_dr_flac* ma_dr_flac_open_relaxed(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_container container, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_flac_open_with_metadata_private(onRead, onSeek, NULL, container, pUserData, pUserData, pAllocationCallbacks);
+}
+MA_API ma_dr_flac* ma_dr_flac_open_with_metadata(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_flac_open_with_metadata_private(onRead, onSeek, onMeta, ma_dr_flac_container_unknown, pUserData, pUserData, pAllocationCallbacks);
+}
+MA_API ma_dr_flac* ma_dr_flac_open_with_metadata_relaxed(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, ma_dr_flac_meta_proc onMeta, ma_dr_flac_container container, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    return ma_dr_flac_open_with_metadata_private(onRead, onSeek, onMeta, container, pUserData, pUserData, pAllocationCallbacks);
+}
+MA_API void ma_dr_flac_close(ma_dr_flac* pFlac)
+{
+    if (pFlac == NULL) {
+        return;
+    }
+#ifndef MA_DR_FLAC_NO_STDIO
+    if (pFlac->bs.onRead == ma_dr_flac__on_read_stdio) {
+        fclose((FILE*)pFlac->bs.pUserData);
+    }
+#ifndef MA_DR_FLAC_NO_OGG
+    if (pFlac->container == ma_dr_flac_container_ogg) {
+        ma_dr_flac_oggbs* oggbs = (ma_dr_flac_oggbs*)pFlac->_oggbs;
+        MA_DR_FLAC_ASSERT(pFlac->bs.onRead == ma_dr_flac__on_read_ogg);
+        if (oggbs->onRead == ma_dr_flac__on_read_stdio) {
+            fclose((FILE*)oggbs->pUserData);
+        }
+    }
+#endif
+#endif
+    ma_dr_flac__free_from_callbacks(pFlac, &pFlac->allocationCallbacks);
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_left_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 left  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 side  = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_left_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 left0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 left1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 left2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 left3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 side0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 side1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 side2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 side3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 right0 = left0 - side0;
+        ma_uint32 right1 = left1 - side1;
+        ma_uint32 right2 = left2 - side2;
+        ma_uint32 right3 = left3 - side3;
+        pOutputSamples[i*8+0] = (ma_int32)left0;
+        pOutputSamples[i*8+1] = (ma_int32)right0;
+        pOutputSamples[i*8+2] = (ma_int32)left1;
+        pOutputSamples[i*8+3] = (ma_int32)right1;
+        pOutputSamples[i*8+4] = (ma_int32)left2;
+        pOutputSamples[i*8+5] = (ma_int32)right2;
+        pOutputSamples[i*8+6] = (ma_int32)left3;
+        pOutputSamples[i*8+7] = (ma_int32)right3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_left_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i left  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i right = _mm_sub_epi32(left, side);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_left_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t left;
+        uint32x4_t side;
+        uint32x4_t right;
+        left  = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        right = vsubq_u32(left, side);
+        ma_dr_flac__vst2q_u32((ma_uint32*)pOutputSamples + i*8, vzipq_u32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_left_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s32__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s32__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_right_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 side  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 right = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_right_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 side0  = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 side1  = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 side2  = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 side3  = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 right0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 right1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 right2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 right3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 left0 = right0 + side0;
+        ma_uint32 left1 = right1 + side1;
+        ma_uint32 left2 = right2 + side2;
+        ma_uint32 left3 = right3 + side3;
+        pOutputSamples[i*8+0] = (ma_int32)left0;
+        pOutputSamples[i*8+1] = (ma_int32)right0;
+        pOutputSamples[i*8+2] = (ma_int32)left1;
+        pOutputSamples[i*8+3] = (ma_int32)right1;
+        pOutputSamples[i*8+4] = (ma_int32)left2;
+        pOutputSamples[i*8+5] = (ma_int32)right2;
+        pOutputSamples[i*8+6] = (ma_int32)left3;
+        pOutputSamples[i*8+7] = (ma_int32)right3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_right_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i left  = _mm_add_epi32(right, side);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_right_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t side;
+        uint32x4_t right;
+        uint32x4_t left;
+        side  = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        right = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        left  = vaddq_u32(right, side);
+        ma_dr_flac__vst2q_u32((ma_uint32*)pOutputSamples + i*8, vzipq_u32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left;
+        pOutputSamples[i*2+1] = (ma_int32)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_right_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s32__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s32__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_mid_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (ma_int32)((ma_uint32)((ma_int32)(mid + side) >> 1) << unusedBitsPerSample);
+        pOutputSamples[i*2+1] = (ma_int32)((ma_uint32)((ma_int32)(mid - side) >> 1) << unusedBitsPerSample);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_mid_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_int32 shift = unusedBitsPerSample;
+    if (shift > 0) {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = (mid0 + side0) << shift;
+            temp1L = (mid1 + side1) << shift;
+            temp2L = (mid2 + side2) << shift;
+            temp3L = (mid3 + side3) << shift;
+            temp0R = (mid0 - side0) << shift;
+            temp1R = (mid1 - side1) << shift;
+            temp2R = (mid2 - side2) << shift;
+            temp3R = (mid3 - side3) << shift;
+            pOutputSamples[i*8+0] = (ma_int32)temp0L;
+            pOutputSamples[i*8+1] = (ma_int32)temp0R;
+            pOutputSamples[i*8+2] = (ma_int32)temp1L;
+            pOutputSamples[i*8+3] = (ma_int32)temp1R;
+            pOutputSamples[i*8+4] = (ma_int32)temp2L;
+            pOutputSamples[i*8+5] = (ma_int32)temp2R;
+            pOutputSamples[i*8+6] = (ma_int32)temp3L;
+            pOutputSamples[i*8+7] = (ma_int32)temp3R;
+        }
+    } else {
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = (ma_uint32)((ma_int32)(mid0 + side0) >> 1);
+            temp1L = (ma_uint32)((ma_int32)(mid1 + side1) >> 1);
+            temp2L = (ma_uint32)((ma_int32)(mid2 + side2) >> 1);
+            temp3L = (ma_uint32)((ma_int32)(mid3 + side3) >> 1);
+            temp0R = (ma_uint32)((ma_int32)(mid0 - side0) >> 1);
+            temp1R = (ma_uint32)((ma_int32)(mid1 - side1) >> 1);
+            temp2R = (ma_uint32)((ma_int32)(mid2 - side2) >> 1);
+            temp3R = (ma_uint32)((ma_int32)(mid3 - side3) >> 1);
+            pOutputSamples[i*8+0] = (ma_int32)temp0L;
+            pOutputSamples[i*8+1] = (ma_int32)temp0R;
+            pOutputSamples[i*8+2] = (ma_int32)temp1L;
+            pOutputSamples[i*8+3] = (ma_int32)temp1R;
+            pOutputSamples[i*8+4] = (ma_int32)temp2L;
+            pOutputSamples[i*8+5] = (ma_int32)temp2R;
+            pOutputSamples[i*8+6] = (ma_int32)temp3L;
+            pOutputSamples[i*8+7] = (ma_int32)temp3R;
+        }
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (ma_int32)((ma_uint32)((ma_int32)(mid + side) >> 1) << unusedBitsPerSample);
+        pOutputSamples[i*2+1] = (ma_int32)((ma_uint32)((ma_int32)(mid - side) >> 1) << unusedBitsPerSample);
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_mid_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_int32 shift = unusedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i left;
+            __m128i right;
+            mid   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid   = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            left  = _mm_srai_epi32(_mm_add_epi32(mid, side), 1);
+            right = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1);
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)(mid + side) >> 1;
+            pOutputSamples[i*2+1] = (ma_int32)(mid - side) >> 1;
+        }
+    } else {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i left;
+            __m128i right;
+            mid   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid   = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            left  = _mm_slli_epi32(_mm_add_epi32(mid, side), shift);
+            right = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift);
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)((mid + side) << shift);
+            pOutputSamples[i*2+1] = (ma_int32)((mid - side) << shift);
+        }
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_mid_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_int32 shift = unusedBitsPerSample;
+    int32x4_t  wbpsShift0_4;
+    int32x4_t  wbpsShift1_4;
+    uint32x4_t one4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    wbpsShift0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+    wbpsShift1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+    one4         = vdupq_n_u32(1);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            uint32x4_t mid;
+            uint32x4_t side;
+            int32x4_t left;
+            int32x4_t right;
+            mid   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+            side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+            mid   = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, one4));
+            left  = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1);
+            right = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1);
+            ma_dr_flac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)(mid + side) >> 1;
+            pOutputSamples[i*2+1] = (ma_int32)(mid - side) >> 1;
+        }
+    } else {
+        int32x4_t shift4;
+        shift -= 1;
+        shift4 = vdupq_n_s32(shift);
+        for (i = 0; i < frameCount4; ++i) {
+            uint32x4_t mid;
+            uint32x4_t side;
+            int32x4_t left;
+            int32x4_t right;
+            mid   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+            side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+            mid   = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, one4));
+            left  = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4));
+            right = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4));
+            ma_dr_flac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)((mid + side) << shift);
+            pOutputSamples[i*2+1] = (ma_int32)((mid - side) << shift);
+        }
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_mid_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s32__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s32__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)((ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample));
+        pOutputSamples[i*2+1] = (ma_int32)((ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample));
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1;
+        pOutputSamples[i*8+0] = (ma_int32)tempL0;
+        pOutputSamples[i*8+1] = (ma_int32)tempR0;
+        pOutputSamples[i*8+2] = (ma_int32)tempL1;
+        pOutputSamples[i*8+3] = (ma_int32)tempR1;
+        pOutputSamples[i*8+4] = (ma_int32)tempL2;
+        pOutputSamples[i*8+5] = (ma_int32)tempR2;
+        pOutputSamples[i*8+6] = (ma_int32)tempL3;
+        pOutputSamples[i*8+7] = (ma_int32)tempR3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0);
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1);
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i left  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 0), _mm_unpacklo_epi32(left, right));
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8 + 4), _mm_unpackhi_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0);
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1);
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift4_0 = vdupq_n_s32(shift0);
+    int32x4_t shift4_1 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        int32x4_t left;
+        int32x4_t right;
+        left  = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift4_0));
+        right = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift4_1));
+        ma_dr_flac__vst2q_s32(pOutputSamples + i*8, vzipq_s32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0);
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int32* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_s32(ma_dr_flac* pFlac, ma_uint64 framesToRead, ma_int32* pBufferOut)
+{
+    ma_uint64 framesRead;
+    ma_uint32 unusedBitsPerSample;
+    if (pFlac == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, framesToRead);
+    }
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 32);
+    unusedBitsPerSample = 32 - pFlac->bitsPerSample;
+    framesRead = 0;
+    while (framesToRead > 0) {
+        if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_and_decode_next_flac_frame(pFlac)) {
+                break;
+            }
+        } else {
+            unsigned int channelCount = ma_dr_flac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+            ma_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining;
+            ma_uint64 frameCountThisIteration = framesToRead;
+            if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) {
+                frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining;
+            }
+            if (channelCount == 2) {
+                const ma_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame;
+                const ma_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame;
+                switch (pFlac->currentFLACFrame.header.channelAssignment)
+                {
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s32__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s32__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s32__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_INDEPENDENT:
+                    default:
+                    {
+                        ma_dr_flac_read_pcm_frames_s32__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                }
+            } else {
+                ma_uint64 i;
+                for (i = 0; i < frameCountThisIteration; ++i) {
+                    unsigned int j;
+                    for (j = 0; j < channelCount; ++j) {
+                        pBufferOut[(i*channelCount)+j] = (ma_int32)((ma_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample));
+                    }
+                }
+            }
+            framesRead                += frameCountThisIteration;
+            pBufferOut                += frameCountThisIteration * channelCount;
+            framesToRead              -= frameCountThisIteration;
+            pFlac->currentPCMFrame    += frameCountThisIteration;
+            pFlac->currentFLACFrame.pcmFramesRemaining -= (ma_uint32)frameCountThisIteration;
+        }
+    }
+    return framesRead;
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_left_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 left  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 side  = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 right = left - side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_left_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 left0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 left1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 left2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 left3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 side0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 side1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 side2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 side3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 right0 = left0 - side0;
+        ma_uint32 right1 = left1 - side1;
+        ma_uint32 right2 = left2 - side2;
+        ma_uint32 right3 = left3 - side3;
+        left0  >>= 16;
+        left1  >>= 16;
+        left2  >>= 16;
+        left3  >>= 16;
+        right0 >>= 16;
+        right1 >>= 16;
+        right2 >>= 16;
+        right3 >>= 16;
+        pOutputSamples[i*8+0] = (ma_int16)left0;
+        pOutputSamples[i*8+1] = (ma_int16)right0;
+        pOutputSamples[i*8+2] = (ma_int16)left1;
+        pOutputSamples[i*8+3] = (ma_int16)right1;
+        pOutputSamples[i*8+4] = (ma_int16)left2;
+        pOutputSamples[i*8+5] = (ma_int16)right2;
+        pOutputSamples[i*8+6] = (ma_int16)left3;
+        pOutputSamples[i*8+7] = (ma_int16)right3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_left_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i left  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i right = _mm_sub_epi32(left, side);
+        left  = _mm_srai_epi32(left,  16);
+        right = _mm_srai_epi32(right, 16);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), ma_dr_flac__mm_packs_interleaved_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_left_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t left;
+        uint32x4_t side;
+        uint32x4_t right;
+        left  = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        right = vsubq_u32(left, side);
+        left  = vshrq_n_u32(left,  16);
+        right = vshrq_n_u32(right, 16);
+        ma_dr_flac__vst2q_u16((ma_uint16*)pOutputSamples + i*8, vzip_u16(vmovn_u32(left), vmovn_u32(right)));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_left_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s16__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s16__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_right_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 side  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 right = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 left  = right + side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_right_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 side0  = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 side1  = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 side2  = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 side3  = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 right0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 right1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 right2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 right3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 left0 = right0 + side0;
+        ma_uint32 left1 = right1 + side1;
+        ma_uint32 left2 = right2 + side2;
+        ma_uint32 left3 = right3 + side3;
+        left0  >>= 16;
+        left1  >>= 16;
+        left2  >>= 16;
+        left3  >>= 16;
+        right0 >>= 16;
+        right1 >>= 16;
+        right2 >>= 16;
+        right3 >>= 16;
+        pOutputSamples[i*8+0] = (ma_int16)left0;
+        pOutputSamples[i*8+1] = (ma_int16)right0;
+        pOutputSamples[i*8+2] = (ma_int16)left1;
+        pOutputSamples[i*8+3] = (ma_int16)right1;
+        pOutputSamples[i*8+4] = (ma_int16)left2;
+        pOutputSamples[i*8+5] = (ma_int16)right2;
+        pOutputSamples[i*8+6] = (ma_int16)left3;
+        pOutputSamples[i*8+7] = (ma_int16)right3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_right_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i left  = _mm_add_epi32(right, side);
+        left  = _mm_srai_epi32(left,  16);
+        right = _mm_srai_epi32(right, 16);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), ma_dr_flac__mm_packs_interleaved_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_right_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t side;
+        uint32x4_t right;
+        uint32x4_t left;
+        side  = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        right = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        left  = vaddq_u32(right, side);
+        left  = vshrq_n_u32(left,  16);
+        right = vshrq_n_u32(right, 16);
+        ma_dr_flac__vst2q_u16((ma_uint16*)pOutputSamples + i*8, vzip_u16(vmovn_u32(left), vmovn_u32(right)));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        left  >>= 16;
+        right >>= 16;
+        pOutputSamples[i*2+0] = (ma_int16)left;
+        pOutputSamples[i*2+1] = (ma_int16)right;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_right_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s16__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s16__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_mid_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        ma_uint32 mid  = (ma_uint32)pInputSamples0[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = (ma_uint32)pInputSamples1[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (ma_int16)(((ma_uint32)((ma_int32)(mid + side) >> 1) << unusedBitsPerSample) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)(((ma_uint32)((ma_int32)(mid - side) >> 1) << unusedBitsPerSample) >> 16);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_mid_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample;
+    if (shift > 0) {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = (mid0 + side0) << shift;
+            temp1L = (mid1 + side1) << shift;
+            temp2L = (mid2 + side2) << shift;
+            temp3L = (mid3 + side3) << shift;
+            temp0R = (mid0 - side0) << shift;
+            temp1R = (mid1 - side1) << shift;
+            temp2R = (mid2 - side2) << shift;
+            temp3R = (mid3 - side3) << shift;
+            temp0L >>= 16;
+            temp1L >>= 16;
+            temp2L >>= 16;
+            temp3L >>= 16;
+            temp0R >>= 16;
+            temp1R >>= 16;
+            temp2R >>= 16;
+            temp3R >>= 16;
+            pOutputSamples[i*8+0] = (ma_int16)temp0L;
+            pOutputSamples[i*8+1] = (ma_int16)temp0R;
+            pOutputSamples[i*8+2] = (ma_int16)temp1L;
+            pOutputSamples[i*8+3] = (ma_int16)temp1R;
+            pOutputSamples[i*8+4] = (ma_int16)temp2L;
+            pOutputSamples[i*8+5] = (ma_int16)temp2R;
+            pOutputSamples[i*8+6] = (ma_int16)temp3L;
+            pOutputSamples[i*8+7] = (ma_int16)temp3R;
+        }
+    } else {
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = ((ma_int32)(mid0 + side0) >> 1);
+            temp1L = ((ma_int32)(mid1 + side1) >> 1);
+            temp2L = ((ma_int32)(mid2 + side2) >> 1);
+            temp3L = ((ma_int32)(mid3 + side3) >> 1);
+            temp0R = ((ma_int32)(mid0 - side0) >> 1);
+            temp1R = ((ma_int32)(mid1 - side1) >> 1);
+            temp2R = ((ma_int32)(mid2 - side2) >> 1);
+            temp3R = ((ma_int32)(mid3 - side3) >> 1);
+            temp0L >>= 16;
+            temp1L >>= 16;
+            temp2L >>= 16;
+            temp3L >>= 16;
+            temp0R >>= 16;
+            temp1R >>= 16;
+            temp2R >>= 16;
+            temp3R >>= 16;
+            pOutputSamples[i*8+0] = (ma_int16)temp0L;
+            pOutputSamples[i*8+1] = (ma_int16)temp0R;
+            pOutputSamples[i*8+2] = (ma_int16)temp1L;
+            pOutputSamples[i*8+3] = (ma_int16)temp1R;
+            pOutputSamples[i*8+4] = (ma_int16)temp2L;
+            pOutputSamples[i*8+5] = (ma_int16)temp2R;
+            pOutputSamples[i*8+6] = (ma_int16)temp3L;
+            pOutputSamples[i*8+7] = (ma_int16)temp3R;
+        }
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (ma_int16)(((ma_uint32)((ma_int32)(mid + side) >> 1) << unusedBitsPerSample) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)(((ma_uint32)((ma_int32)(mid - side) >> 1) << unusedBitsPerSample) >> 16);
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_mid_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i left;
+            __m128i right;
+            mid   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid   = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            left  = _mm_srai_epi32(_mm_add_epi32(mid, side), 1);
+            right = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1);
+            left  = _mm_srai_epi32(left,  16);
+            right = _mm_srai_epi32(right, 16);
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), ma_dr_flac__mm_packs_interleaved_epi32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int16)(((ma_int32)(mid + side) >> 1) >> 16);
+            pOutputSamples[i*2+1] = (ma_int16)(((ma_int32)(mid - side) >> 1) >> 16);
+        }
+    } else {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i left;
+            __m128i right;
+            mid   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid   = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            left  = _mm_slli_epi32(_mm_add_epi32(mid, side), shift);
+            right = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift);
+            left  = _mm_srai_epi32(left,  16);
+            right = _mm_srai_epi32(right, 16);
+            _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), ma_dr_flac__mm_packs_interleaved_epi32(left, right));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int16)(((mid + side) << shift) >> 16);
+            pOutputSamples[i*2+1] = (ma_int16)(((mid - side) << shift) >> 16);
+        }
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_mid_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample;
+    int32x4_t wbpsShift0_4;
+    int32x4_t wbpsShift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    wbpsShift0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+    wbpsShift1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            uint32x4_t mid;
+            uint32x4_t side;
+            int32x4_t left;
+            int32x4_t right;
+            mid   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+            side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+            mid   = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+            left  = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1);
+            right = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1);
+            left  = vshrq_n_s32(left,  16);
+            right = vshrq_n_s32(right, 16);
+            ma_dr_flac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right)));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int16)(((ma_int32)(mid + side) >> 1) >> 16);
+            pOutputSamples[i*2+1] = (ma_int16)(((ma_int32)(mid - side) >> 1) >> 16);
+        }
+    } else {
+        int32x4_t shift4;
+        shift -= 1;
+        shift4 = vdupq_n_s32(shift);
+        for (i = 0; i < frameCount4; ++i) {
+            uint32x4_t mid;
+            uint32x4_t side;
+            int32x4_t left;
+            int32x4_t right;
+            mid   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbpsShift0_4);
+            side  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbpsShift1_4);
+            mid   = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+            left  = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4));
+            right = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4));
+            left  = vshrq_n_s32(left,  16);
+            right = vshrq_n_s32(right, 16);
+            ma_dr_flac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right)));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int16)(((mid + side) << shift) >> 16);
+            pOutputSamples[i*2+1] = (ma_int16)(((mid - side) << shift) >> 16);
+        }
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_mid_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s16__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s16__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int16)((ma_int32)((ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample)) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)((ma_int32)((ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample)) >> 16);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1;
+        tempL0 >>= 16;
+        tempL1 >>= 16;
+        tempL2 >>= 16;
+        tempL3 >>= 16;
+        tempR0 >>= 16;
+        tempR1 >>= 16;
+        tempR2 >>= 16;
+        tempR3 >>= 16;
+        pOutputSamples[i*8+0] = (ma_int16)tempL0;
+        pOutputSamples[i*8+1] = (ma_int16)tempR0;
+        pOutputSamples[i*8+2] = (ma_int16)tempL1;
+        pOutputSamples[i*8+3] = (ma_int16)tempR1;
+        pOutputSamples[i*8+4] = (ma_int16)tempL2;
+        pOutputSamples[i*8+5] = (ma_int16)tempR2;
+        pOutputSamples[i*8+6] = (ma_int16)tempL3;
+        pOutputSamples[i*8+7] = (ma_int16)tempR3;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int16)((pInputSamples0U32[i] << shift0) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)((pInputSamples1U32[i] << shift1) >> 16);
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i left  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        left  = _mm_srai_epi32(left,  16);
+        right = _mm_srai_epi32(right, 16);
+        _mm_storeu_si128((__m128i*)(pOutputSamples + i*8), ma_dr_flac__mm_packs_interleaved_epi32(left, right));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int16)((pInputSamples0U32[i] << shift0) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)((pInputSamples1U32[i] << shift1) >> 16);
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    int32x4_t shift0_4 = vdupq_n_s32(shift0);
+    int32x4_t shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        int32x4_t left;
+        int32x4_t right;
+        left  = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4));
+        right = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4));
+        left  = vshrq_n_s32(left,  16);
+        right = vshrq_n_s32(right, 16);
+        ma_dr_flac__vst2q_s16(pOutputSamples + i*8, vzip_s16(vmovn_s32(left), vmovn_s32(right)));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int16)((pInputSamples0U32[i] << shift0) >> 16);
+        pOutputSamples[i*2+1] = (ma_int16)((pInputSamples1U32[i] << shift1) >> 16);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, ma_int16* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_s16(ma_dr_flac* pFlac, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    ma_uint64 framesRead;
+    ma_uint32 unusedBitsPerSample;
+    if (pFlac == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, framesToRead);
+    }
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 32);
+    unusedBitsPerSample = 32 - pFlac->bitsPerSample;
+    framesRead = 0;
+    while (framesToRead > 0) {
+        if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_and_decode_next_flac_frame(pFlac)) {
+                break;
+            }
+        } else {
+            unsigned int channelCount = ma_dr_flac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+            ma_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining;
+            ma_uint64 frameCountThisIteration = framesToRead;
+            if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) {
+                frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining;
+            }
+            if (channelCount == 2) {
+                const ma_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame;
+                const ma_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame;
+                switch (pFlac->currentFLACFrame.header.channelAssignment)
+                {
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s16__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s16__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_s16__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_INDEPENDENT:
+                    default:
+                    {
+                        ma_dr_flac_read_pcm_frames_s16__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                }
+            } else {
+                ma_uint64 i;
+                for (i = 0; i < frameCountThisIteration; ++i) {
+                    unsigned int j;
+                    for (j = 0; j < channelCount; ++j) {
+                        ma_int32 sampleS32 = (ma_int32)((ma_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample));
+                        pBufferOut[(i*channelCount)+j] = (ma_int16)(sampleS32 >> 16);
+                    }
+                }
+            }
+            framesRead                += frameCountThisIteration;
+            pBufferOut                += frameCountThisIteration * channelCount;
+            framesToRead              -= frameCountThisIteration;
+            pFlac->currentPCMFrame    += frameCountThisIteration;
+            pFlac->currentFLACFrame.pcmFramesRemaining -= (ma_uint32)frameCountThisIteration;
+        }
+    }
+    return framesRead;
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_left_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 left  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 side  = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (float)((ma_int32)left  / 2147483648.0);
+        pOutputSamples[i*2+1] = (float)((ma_int32)right / 2147483648.0);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_left_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    float factor = 1 / 2147483648.0;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 left0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 left1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 left2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 left3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 side0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 side1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 side2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 side3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 right0 = left0 - side0;
+        ma_uint32 right1 = left1 - side1;
+        ma_uint32 right2 = left2 - side2;
+        ma_uint32 right3 = left3 - side3;
+        pOutputSamples[i*8+0] = (ma_int32)left0  * factor;
+        pOutputSamples[i*8+1] = (ma_int32)right0 * factor;
+        pOutputSamples[i*8+2] = (ma_int32)left1  * factor;
+        pOutputSamples[i*8+3] = (ma_int32)right1 * factor;
+        pOutputSamples[i*8+4] = (ma_int32)left2  * factor;
+        pOutputSamples[i*8+5] = (ma_int32)right2 * factor;
+        pOutputSamples[i*8+6] = (ma_int32)left3  * factor;
+        pOutputSamples[i*8+7] = (ma_int32)right3 * factor;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left  * factor;
+        pOutputSamples[i*2+1] = (ma_int32)right * factor;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_left_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    __m128 factor;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor = _mm_set1_ps(1.0f / 8388608.0f);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i left  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i right = _mm_sub_epi32(left, side);
+        __m128 leftf  = _mm_mul_ps(_mm_cvtepi32_ps(left),  factor);
+        __m128 rightf = _mm_mul_ps(_mm_cvtepi32_ps(right), factor);
+        _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+        _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left  / 8388608.0f;
+        pOutputSamples[i*2+1] = (ma_int32)right / 8388608.0f;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_left_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    float32x4_t factor4;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor4  = vdupq_n_f32(1.0f / 8388608.0f);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t left;
+        uint32x4_t side;
+        uint32x4_t right;
+        float32x4_t leftf;
+        float32x4_t rightf;
+        left   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        side   = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        right  = vsubq_u32(left, side);
+        leftf  = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(left)),  factor4);
+        rightf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(right)), factor4);
+        ma_dr_flac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 left  = pInputSamples0U32[i] << shift0;
+        ma_uint32 side  = pInputSamples1U32[i] << shift1;
+        ma_uint32 right = left - side;
+        pOutputSamples[i*2+0] = (ma_int32)left  / 8388608.0f;
+        pOutputSamples[i*2+1] = (ma_int32)right / 8388608.0f;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_left_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_left_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_left_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_f32__decode_left_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_f32__decode_left_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_right_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    for (i = 0; i < frameCount; ++i) {
+        ma_uint32 side  = (ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+        ma_uint32 right = (ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (float)((ma_int32)left  / 2147483648.0);
+        pOutputSamples[i*2+1] = (float)((ma_int32)right / 2147483648.0);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_right_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    float factor = 1 / 2147483648.0;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 side0  = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 side1  = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 side2  = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 side3  = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 right0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 right1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 right2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 right3 = pInputSamples1U32[i*4+3] << shift1;
+        ma_uint32 left0 = right0 + side0;
+        ma_uint32 left1 = right1 + side1;
+        ma_uint32 left2 = right2 + side2;
+        ma_uint32 left3 = right3 + side3;
+        pOutputSamples[i*8+0] = (ma_int32)left0  * factor;
+        pOutputSamples[i*8+1] = (ma_int32)right0 * factor;
+        pOutputSamples[i*8+2] = (ma_int32)left1  * factor;
+        pOutputSamples[i*8+3] = (ma_int32)right1 * factor;
+        pOutputSamples[i*8+4] = (ma_int32)left2  * factor;
+        pOutputSamples[i*8+5] = (ma_int32)right2 * factor;
+        pOutputSamples[i*8+6] = (ma_int32)left3  * factor;
+        pOutputSamples[i*8+7] = (ma_int32)right3 * factor;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left  * factor;
+        pOutputSamples[i*2+1] = (ma_int32)right * factor;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_right_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    __m128 factor;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor = _mm_set1_ps(1.0f / 8388608.0f);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i side  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        __m128i right = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        __m128i left  = _mm_add_epi32(right, side);
+        __m128 leftf  = _mm_mul_ps(_mm_cvtepi32_ps(left),  factor);
+        __m128 rightf = _mm_mul_ps(_mm_cvtepi32_ps(right), factor);
+        _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+        _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left  / 8388608.0f;
+        pOutputSamples[i*2+1] = (ma_int32)right / 8388608.0f;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_right_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    float32x4_t factor4;
+    int32x4_t shift0_4;
+    int32x4_t shift1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor4  = vdupq_n_f32(1.0f / 8388608.0f);
+    shift0_4 = vdupq_n_s32(shift0);
+    shift1_4 = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        uint32x4_t side;
+        uint32x4_t right;
+        uint32x4_t left;
+        float32x4_t leftf;
+        float32x4_t rightf;
+        side   = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4);
+        right  = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4);
+        left   = vaddq_u32(right, side);
+        leftf  = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(left)),  factor4);
+        rightf = vmulq_f32(vcvtq_f32_s32(vreinterpretq_s32_u32(right)), factor4);
+        ma_dr_flac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 side  = pInputSamples0U32[i] << shift0;
+        ma_uint32 right = pInputSamples1U32[i] << shift1;
+        ma_uint32 left  = right + side;
+        pOutputSamples[i*2+0] = (ma_int32)left  / 8388608.0f;
+        pOutputSamples[i*2+1] = (ma_int32)right / 8388608.0f;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_right_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_right_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_right_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_f32__decode_right_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_f32__decode_right_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_mid_side__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        ma_uint32 mid  = (ma_uint32)pInputSamples0[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = (ma_uint32)pInputSamples1[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (float)((((ma_int32)(mid + side) >> 1) << (unusedBitsPerSample)) / 2147483648.0);
+        pOutputSamples[i*2+1] = (float)((((ma_int32)(mid - side) >> 1) << (unusedBitsPerSample)) / 2147483648.0);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_mid_side__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample;
+    float factor = 1 / 2147483648.0;
+    if (shift > 0) {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = (mid0 + side0) << shift;
+            temp1L = (mid1 + side1) << shift;
+            temp2L = (mid2 + side2) << shift;
+            temp3L = (mid3 + side3) << shift;
+            temp0R = (mid0 - side0) << shift;
+            temp1R = (mid1 - side1) << shift;
+            temp2R = (mid2 - side2) << shift;
+            temp3R = (mid3 - side3) << shift;
+            pOutputSamples[i*8+0] = (ma_int32)temp0L * factor;
+            pOutputSamples[i*8+1] = (ma_int32)temp0R * factor;
+            pOutputSamples[i*8+2] = (ma_int32)temp1L * factor;
+            pOutputSamples[i*8+3] = (ma_int32)temp1R * factor;
+            pOutputSamples[i*8+4] = (ma_int32)temp2L * factor;
+            pOutputSamples[i*8+5] = (ma_int32)temp2R * factor;
+            pOutputSamples[i*8+6] = (ma_int32)temp3L * factor;
+            pOutputSamples[i*8+7] = (ma_int32)temp3R * factor;
+        }
+    } else {
+        for (i = 0; i < frameCount4; ++i) {
+            ma_uint32 temp0L;
+            ma_uint32 temp1L;
+            ma_uint32 temp2L;
+            ma_uint32 temp3L;
+            ma_uint32 temp0R;
+            ma_uint32 temp1R;
+            ma_uint32 temp2R;
+            ma_uint32 temp3R;
+            ma_uint32 mid0  = pInputSamples0U32[i*4+0] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid1  = pInputSamples0U32[i*4+1] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid2  = pInputSamples0U32[i*4+2] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 mid3  = pInputSamples0U32[i*4+3] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side0 = pInputSamples1U32[i*4+0] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side1 = pInputSamples1U32[i*4+1] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side2 = pInputSamples1U32[i*4+2] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            ma_uint32 side3 = pInputSamples1U32[i*4+3] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid0 = (mid0 << 1) | (side0 & 0x01);
+            mid1 = (mid1 << 1) | (side1 & 0x01);
+            mid2 = (mid2 << 1) | (side2 & 0x01);
+            mid3 = (mid3 << 1) | (side3 & 0x01);
+            temp0L = (ma_uint32)((ma_int32)(mid0 + side0) >> 1);
+            temp1L = (ma_uint32)((ma_int32)(mid1 + side1) >> 1);
+            temp2L = (ma_uint32)((ma_int32)(mid2 + side2) >> 1);
+            temp3L = (ma_uint32)((ma_int32)(mid3 + side3) >> 1);
+            temp0R = (ma_uint32)((ma_int32)(mid0 - side0) >> 1);
+            temp1R = (ma_uint32)((ma_int32)(mid1 - side1) >> 1);
+            temp2R = (ma_uint32)((ma_int32)(mid2 - side2) >> 1);
+            temp3R = (ma_uint32)((ma_int32)(mid3 - side3) >> 1);
+            pOutputSamples[i*8+0] = (ma_int32)temp0L * factor;
+            pOutputSamples[i*8+1] = (ma_int32)temp0R * factor;
+            pOutputSamples[i*8+2] = (ma_int32)temp1L * factor;
+            pOutputSamples[i*8+3] = (ma_int32)temp1R * factor;
+            pOutputSamples[i*8+4] = (ma_int32)temp2L * factor;
+            pOutputSamples[i*8+5] = (ma_int32)temp2R * factor;
+            pOutputSamples[i*8+6] = (ma_int32)temp3L * factor;
+            pOutputSamples[i*8+7] = (ma_int32)temp3R * factor;
+        }
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+        ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+        mid = (mid << 1) | (side & 0x01);
+        pOutputSamples[i*2+0] = (ma_int32)((ma_uint32)((ma_int32)(mid + side) >> 1) << unusedBitsPerSample) * factor;
+        pOutputSamples[i*2+1] = (ma_int32)((ma_uint32)((ma_int32)(mid - side) >> 1) << unusedBitsPerSample) * factor;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_mid_side__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample - 8;
+    float factor;
+    __m128 factor128;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor = 1.0f / 8388608.0f;
+    factor128 = _mm_set1_ps(factor);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i tempL;
+            __m128i tempR;
+            __m128  leftf;
+            __m128  rightf;
+            mid    = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid    = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            tempL  = _mm_srai_epi32(_mm_add_epi32(mid, side), 1);
+            tempR  = _mm_srai_epi32(_mm_sub_epi32(mid, side), 1);
+            leftf  = _mm_mul_ps(_mm_cvtepi32_ps(tempL), factor128);
+            rightf = _mm_mul_ps(_mm_cvtepi32_ps(tempR), factor128);
+            _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+            _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = ((ma_int32)(mid + side) >> 1) * factor;
+            pOutputSamples[i*2+1] = ((ma_int32)(mid - side) >> 1) * factor;
+        }
+    } else {
+        shift -= 1;
+        for (i = 0; i < frameCount4; ++i) {
+            __m128i mid;
+            __m128i side;
+            __m128i tempL;
+            __m128i tempR;
+            __m128 leftf;
+            __m128 rightf;
+            mid    = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+            side   = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+            mid    = _mm_or_si128(_mm_slli_epi32(mid, 1), _mm_and_si128(side, _mm_set1_epi32(0x01)));
+            tempL  = _mm_slli_epi32(_mm_add_epi32(mid, side), shift);
+            tempR  = _mm_slli_epi32(_mm_sub_epi32(mid, side), shift);
+            leftf  = _mm_mul_ps(_mm_cvtepi32_ps(tempL), factor128);
+            rightf = _mm_mul_ps(_mm_cvtepi32_ps(tempR), factor128);
+            _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+            _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)((mid + side) << shift) * factor;
+            pOutputSamples[i*2+1] = (ma_int32)((mid - side) << shift) * factor;
+        }
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_mid_side__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift = unusedBitsPerSample - 8;
+    float factor;
+    float32x4_t factor4;
+    int32x4_t shift4;
+    int32x4_t wbps0_4;
+    int32x4_t wbps1_4;
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 24);
+    factor  = 1.0f / 8388608.0f;
+    factor4 = vdupq_n_f32(factor);
+    wbps0_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample);
+    wbps1_4 = vdupq_n_s32(pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample);
+    if (shift == 0) {
+        for (i = 0; i < frameCount4; ++i) {
+            int32x4_t lefti;
+            int32x4_t righti;
+            float32x4_t leftf;
+            float32x4_t rightf;
+            uint32x4_t mid  = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbps0_4);
+            uint32x4_t side = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbps1_4);
+            mid    = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+            lefti  = vshrq_n_s32(vreinterpretq_s32_u32(vaddq_u32(mid, side)), 1);
+            righti = vshrq_n_s32(vreinterpretq_s32_u32(vsubq_u32(mid, side)), 1);
+            leftf  = vmulq_f32(vcvtq_f32_s32(lefti),  factor4);
+            rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4);
+            ma_dr_flac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = ((ma_int32)(mid + side) >> 1) * factor;
+            pOutputSamples[i*2+1] = ((ma_int32)(mid - side) >> 1) * factor;
+        }
+    } else {
+        shift -= 1;
+        shift4 = vdupq_n_s32(shift);
+        for (i = 0; i < frameCount4; ++i) {
+            uint32x4_t mid;
+            uint32x4_t side;
+            int32x4_t lefti;
+            int32x4_t righti;
+            float32x4_t leftf;
+            float32x4_t rightf;
+            mid    = vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), wbps0_4);
+            side   = vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), wbps1_4);
+            mid    = vorrq_u32(vshlq_n_u32(mid, 1), vandq_u32(side, vdupq_n_u32(1)));
+            lefti  = vreinterpretq_s32_u32(vshlq_u32(vaddq_u32(mid, side), shift4));
+            righti = vreinterpretq_s32_u32(vshlq_u32(vsubq_u32(mid, side), shift4));
+            leftf  = vmulq_f32(vcvtq_f32_s32(lefti),  factor4);
+            rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4);
+            ma_dr_flac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+        }
+        for (i = (frameCount4 << 2); i < frameCount; ++i) {
+            ma_uint32 mid  = pInputSamples0U32[i] << pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+            ma_uint32 side = pInputSamples1U32[i] << pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+            mid = (mid << 1) | (side & 0x01);
+            pOutputSamples[i*2+0] = (ma_int32)((mid + side) << shift) * factor;
+            pOutputSamples[i*2+1] = (ma_int32)((mid - side) << shift) * factor;
+        }
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_mid_side(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_mid_side__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_mid_side__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_f32__decode_mid_side__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_f32__decode_mid_side__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+#if 0
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__reference(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    for (ma_uint64 i = 0; i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (float)((ma_int32)((ma_uint32)pInputSamples0[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample)) / 2147483648.0);
+        pOutputSamples[i*2+1] = (float)((ma_int32)((ma_uint32)pInputSamples1[i] << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample)) / 2147483648.0);
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__scalar(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample;
+    ma_uint32 shift1 = unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample;
+    float factor = 1 / 2147483648.0;
+    for (i = 0; i < frameCount4; ++i) {
+        ma_uint32 tempL0 = pInputSamples0U32[i*4+0] << shift0;
+        ma_uint32 tempL1 = pInputSamples0U32[i*4+1] << shift0;
+        ma_uint32 tempL2 = pInputSamples0U32[i*4+2] << shift0;
+        ma_uint32 tempL3 = pInputSamples0U32[i*4+3] << shift0;
+        ma_uint32 tempR0 = pInputSamples1U32[i*4+0] << shift1;
+        ma_uint32 tempR1 = pInputSamples1U32[i*4+1] << shift1;
+        ma_uint32 tempR2 = pInputSamples1U32[i*4+2] << shift1;
+        ma_uint32 tempR3 = pInputSamples1U32[i*4+3] << shift1;
+        pOutputSamples[i*8+0] = (ma_int32)tempL0 * factor;
+        pOutputSamples[i*8+1] = (ma_int32)tempR0 * factor;
+        pOutputSamples[i*8+2] = (ma_int32)tempL1 * factor;
+        pOutputSamples[i*8+3] = (ma_int32)tempR1 * factor;
+        pOutputSamples[i*8+4] = (ma_int32)tempL2 * factor;
+        pOutputSamples[i*8+5] = (ma_int32)tempR2 * factor;
+        pOutputSamples[i*8+6] = (ma_int32)tempL3 * factor;
+        pOutputSamples[i*8+7] = (ma_int32)tempR3 * factor;
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0) * factor;
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1) * factor;
+    }
+}
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__sse2(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    float factor = 1.0f / 8388608.0f;
+    __m128 factor128 = _mm_set1_ps(factor);
+    for (i = 0; i < frameCount4; ++i) {
+        __m128i lefti;
+        __m128i righti;
+        __m128 leftf;
+        __m128 rightf;
+        lefti  = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples0 + i), shift0);
+        righti = _mm_slli_epi32(_mm_loadu_si128((const __m128i*)pInputSamples1 + i), shift1);
+        leftf  = _mm_mul_ps(_mm_cvtepi32_ps(lefti),  factor128);
+        rightf = _mm_mul_ps(_mm_cvtepi32_ps(righti), factor128);
+        _mm_storeu_ps(pOutputSamples + i*8 + 0, _mm_unpacklo_ps(leftf, rightf));
+        _mm_storeu_ps(pOutputSamples + i*8 + 4, _mm_unpackhi_ps(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0) * factor;
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1) * factor;
+    }
+}
+#endif
+#if defined(MA_DR_FLAC_SUPPORT_NEON)
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__neon(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+    ma_uint64 i;
+    ma_uint64 frameCount4 = frameCount >> 2;
+    const ma_uint32* pInputSamples0U32 = (const ma_uint32*)pInputSamples0;
+    const ma_uint32* pInputSamples1U32 = (const ma_uint32*)pInputSamples1;
+    ma_uint32 shift0 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[0].wastedBitsPerSample) - 8;
+    ma_uint32 shift1 = (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[1].wastedBitsPerSample) - 8;
+    float factor = 1.0f / 8388608.0f;
+    float32x4_t factor4 = vdupq_n_f32(factor);
+    int32x4_t shift0_4  = vdupq_n_s32(shift0);
+    int32x4_t shift1_4  = vdupq_n_s32(shift1);
+    for (i = 0; i < frameCount4; ++i) {
+        int32x4_t lefti;
+        int32x4_t righti;
+        float32x4_t leftf;
+        float32x4_t rightf;
+        lefti  = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples0U32 + i*4), shift0_4));
+        righti = vreinterpretq_s32_u32(vshlq_u32(vld1q_u32(pInputSamples1U32 + i*4), shift1_4));
+        leftf  = vmulq_f32(vcvtq_f32_s32(lefti),  factor4);
+        rightf = vmulq_f32(vcvtq_f32_s32(righti), factor4);
+        ma_dr_flac__vst2q_f32(pOutputSamples + i*8, vzipq_f32(leftf, rightf));
+    }
+    for (i = (frameCount4 << 2); i < frameCount; ++i) {
+        pOutputSamples[i*2+0] = (ma_int32)(pInputSamples0U32[i] << shift0) * factor;
+        pOutputSamples[i*2+1] = (ma_int32)(pInputSamples1U32[i] << shift1) * factor;
+    }
+}
+#endif
+static MA_INLINE void ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo(ma_dr_flac* pFlac, ma_uint64 frameCount, ma_uint32 unusedBitsPerSample, const ma_int32* pInputSamples0, const ma_int32* pInputSamples1, float* pOutputSamples)
+{
+#if defined(MA_DR_FLAC_SUPPORT_SSE2)
+    if (ma_dr_flac__gIsSSE2Supported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__sse2(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#elif defined(MA_DR_FLAC_SUPPORT_NEON)
+    if (ma_dr_flac__gIsNEONSupported && pFlac->bitsPerSample <= 24) {
+        ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__neon(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+    } else
+#endif
+    {
+#if 0
+        ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__reference(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#else
+        ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo__scalar(pFlac, frameCount, unusedBitsPerSample, pInputSamples0, pInputSamples1, pOutputSamples);
+#endif
+    }
+}
+MA_API ma_uint64 ma_dr_flac_read_pcm_frames_f32(ma_dr_flac* pFlac, ma_uint64 framesToRead, float* pBufferOut)
+{
+    ma_uint64 framesRead;
+    ma_uint32 unusedBitsPerSample;
+    if (pFlac == NULL || framesToRead == 0) {
+        return 0;
+    }
+    if (pBufferOut == NULL) {
+        return ma_dr_flac__seek_forward_by_pcm_frames(pFlac, framesToRead);
+    }
+    MA_DR_FLAC_ASSERT(pFlac->bitsPerSample <= 32);
+    unusedBitsPerSample = 32 - pFlac->bitsPerSample;
+    framesRead = 0;
+    while (framesToRead > 0) {
+        if (pFlac->currentFLACFrame.pcmFramesRemaining == 0) {
+            if (!ma_dr_flac__read_and_decode_next_flac_frame(pFlac)) {
+                break;
+            }
+        } else {
+            unsigned int channelCount = ma_dr_flac__get_channel_count_from_channel_assignment(pFlac->currentFLACFrame.header.channelAssignment);
+            ma_uint64 iFirstPCMFrame = pFlac->currentFLACFrame.header.blockSizeInPCMFrames - pFlac->currentFLACFrame.pcmFramesRemaining;
+            ma_uint64 frameCountThisIteration = framesToRead;
+            if (frameCountThisIteration > pFlac->currentFLACFrame.pcmFramesRemaining) {
+                frameCountThisIteration = pFlac->currentFLACFrame.pcmFramesRemaining;
+            }
+            if (channelCount == 2) {
+                const ma_int32* pDecodedSamples0 = pFlac->currentFLACFrame.subframes[0].pSamplesS32 + iFirstPCMFrame;
+                const ma_int32* pDecodedSamples1 = pFlac->currentFLACFrame.subframes[1].pSamplesS32 + iFirstPCMFrame;
+                switch (pFlac->currentFLACFrame.header.channelAssignment)
+                {
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_LEFT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_f32__decode_left_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_f32__decode_right_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_MID_SIDE:
+                    {
+                        ma_dr_flac_read_pcm_frames_f32__decode_mid_side(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                    case MA_DR_FLAC_CHANNEL_ASSIGNMENT_INDEPENDENT:
+                    default:
+                    {
+                        ma_dr_flac_read_pcm_frames_f32__decode_independent_stereo(pFlac, frameCountThisIteration, unusedBitsPerSample, pDecodedSamples0, pDecodedSamples1, pBufferOut);
+                    } break;
+                }
+            } else {
+                ma_uint64 i;
+                for (i = 0; i < frameCountThisIteration; ++i) {
+                    unsigned int j;
+                    for (j = 0; j < channelCount; ++j) {
+                        ma_int32 sampleS32 = (ma_int32)((ma_uint32)(pFlac->currentFLACFrame.subframes[j].pSamplesS32[iFirstPCMFrame + i]) << (unusedBitsPerSample + pFlac->currentFLACFrame.subframes[j].wastedBitsPerSample));
+                        pBufferOut[(i*channelCount)+j] = (float)(sampleS32 / 2147483648.0);
+                    }
+                }
+            }
+            framesRead                += frameCountThisIteration;
+            pBufferOut                += frameCountThisIteration * channelCount;
+            framesToRead              -= frameCountThisIteration;
+            pFlac->currentPCMFrame    += frameCountThisIteration;
+            pFlac->currentFLACFrame.pcmFramesRemaining -= (unsigned int)frameCountThisIteration;
+        }
+    }
+    return framesRead;
+}
+MA_API ma_bool32 ma_dr_flac_seek_to_pcm_frame(ma_dr_flac* pFlac, ma_uint64 pcmFrameIndex)
+{
+    if (pFlac == NULL) {
+        return MA_FALSE;
+    }
+    if (pFlac->currentPCMFrame == pcmFrameIndex) {
+        return MA_TRUE;
+    }
+    if (pFlac->firstFLACFramePosInBytes == 0) {
+        return MA_FALSE;
+    }
+    if (pcmFrameIndex == 0) {
+        pFlac->currentPCMFrame = 0;
+        return ma_dr_flac__seek_to_first_frame(pFlac);
+    } else {
+        ma_bool32 wasSuccessful = MA_FALSE;
+        ma_uint64 originalPCMFrame = pFlac->currentPCMFrame;
+        if (pcmFrameIndex > pFlac->totalPCMFrameCount) {
+            pcmFrameIndex = pFlac->totalPCMFrameCount;
+        }
+        if (pcmFrameIndex > pFlac->currentPCMFrame) {
+            ma_uint32 offset = (ma_uint32)(pcmFrameIndex - pFlac->currentPCMFrame);
+            if (pFlac->currentFLACFrame.pcmFramesRemaining >  offset) {
+                pFlac->currentFLACFrame.pcmFramesRemaining -= offset;
+                pFlac->currentPCMFrame = pcmFrameIndex;
+                return MA_TRUE;
+            }
+        } else {
+            ma_uint32 offsetAbs = (ma_uint32)(pFlac->currentPCMFrame - pcmFrameIndex);
+            ma_uint32 currentFLACFramePCMFrameCount = pFlac->currentFLACFrame.header.blockSizeInPCMFrames;
+            ma_uint32 currentFLACFramePCMFramesConsumed = currentFLACFramePCMFrameCount - pFlac->currentFLACFrame.pcmFramesRemaining;
+            if (currentFLACFramePCMFramesConsumed > offsetAbs) {
+                pFlac->currentFLACFrame.pcmFramesRemaining += offsetAbs;
+                pFlac->currentPCMFrame = pcmFrameIndex;
+                return MA_TRUE;
+            }
+        }
+#ifndef MA_DR_FLAC_NO_OGG
+        if (pFlac->container == ma_dr_flac_container_ogg)
+        {
+            wasSuccessful = ma_dr_flac_ogg__seek_to_pcm_frame(pFlac, pcmFrameIndex);
+        }
+        else
+#endif
+        {
+            if (!pFlac->_noSeekTableSeek) {
+                wasSuccessful = ma_dr_flac__seek_to_pcm_frame__seek_table(pFlac, pcmFrameIndex);
+            }
+#if !defined(MA_DR_FLAC_NO_CRC)
+            if (!wasSuccessful && !pFlac->_noBinarySearchSeek && pFlac->totalPCMFrameCount > 0) {
+                wasSuccessful = ma_dr_flac__seek_to_pcm_frame__binary_search(pFlac, pcmFrameIndex);
+            }
+#endif
+            if (!wasSuccessful && !pFlac->_noBruteForceSeek) {
+                wasSuccessful = ma_dr_flac__seek_to_pcm_frame__brute_force(pFlac, pcmFrameIndex);
+            }
+        }
+        if (wasSuccessful) {
+            pFlac->currentPCMFrame = pcmFrameIndex;
+        } else {
+            if (ma_dr_flac_seek_to_pcm_frame(pFlac, originalPCMFrame) == MA_FALSE) {
+                ma_dr_flac_seek_to_pcm_frame(pFlac, 0);
+            }
+        }
+        return wasSuccessful;
+    }
+}
+#define MA_DR_FLAC_DEFINE_FULL_READ_AND_CLOSE(extension, type) \
+static type* ma_dr_flac__full_read_and_close_ ## extension (ma_dr_flac* pFlac, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalPCMFrameCountOut)\
+{                                                                                                                                                                   \
+    type* pSampleData = NULL;                                                                                                                                       \
+    ma_uint64 totalPCMFrameCount;                                                                                                                               \
+                                                                                                                                                                    \
+    MA_DR_FLAC_ASSERT(pFlac != NULL);                                                                                                                                   \
+                                                                                                                                                                    \
+    totalPCMFrameCount = pFlac->totalPCMFrameCount;                                                                                                                 \
+                                                                                                                                                                    \
+    if (totalPCMFrameCount == 0) {                                                                                                                                  \
+        type buffer[4096];                                                                                                                                          \
+        ma_uint64 pcmFramesRead;                                                                                                                                \
+        size_t sampleDataBufferSize = sizeof(buffer);                                                                                                               \
+                                                                                                                                                                    \
+        pSampleData = (type*)ma_dr_flac__malloc_from_callbacks(sampleDataBufferSize, &pFlac->allocationCallbacks);                                                      \
+        if (pSampleData == NULL) {                                                                                                                                  \
+            goto on_error;                                                                                                                                          \
+        }                                                                                                                                                           \
+                                                                                                                                                                    \
+        while ((pcmFramesRead = (ma_uint64)ma_dr_flac_read_pcm_frames_##extension(pFlac, sizeof(buffer)/sizeof(buffer[0])/pFlac->channels, buffer)) > 0) {          \
+            if (((totalPCMFrameCount + pcmFramesRead) * pFlac->channels * sizeof(type)) > sampleDataBufferSize) {                                                   \
+                type* pNewSampleData;                                                                                                                               \
+                size_t newSampleDataBufferSize;                                                                                                                     \
+                                                                                                                                                                    \
+                newSampleDataBufferSize = sampleDataBufferSize * 2;                                                                                                 \
+                pNewSampleData = (type*)ma_dr_flac__realloc_from_callbacks(pSampleData, newSampleDataBufferSize, sampleDataBufferSize, &pFlac->allocationCallbacks);    \
+                if (pNewSampleData == NULL) {                                                                                                                       \
+                    ma_dr_flac__free_from_callbacks(pSampleData, &pFlac->allocationCallbacks);                                                                          \
+                    goto on_error;                                                                                                                                  \
+                }                                                                                                                                                   \
+                                                                                                                                                                    \
+                sampleDataBufferSize = newSampleDataBufferSize;                                                                                                     \
+                pSampleData = pNewSampleData;                                                                                                                       \
+            }                                                                                                                                                       \
+                                                                                                                                                                    \
+            MA_DR_FLAC_COPY_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), buffer, (size_t)(pcmFramesRead*pFlac->channels*sizeof(type)));                   \
+            totalPCMFrameCount += pcmFramesRead;                                                                                                                    \
+        }                                                                                                                                                           \
+                                                                                                                                                                    \
+                                                                                                                         \
+        MA_DR_FLAC_ZERO_MEMORY(pSampleData + (totalPCMFrameCount*pFlac->channels), (size_t)(sampleDataBufferSize - totalPCMFrameCount*pFlac->channels*sizeof(type)));   \
+    } else {                                                                                                                                                        \
+        ma_uint64 dataSize = totalPCMFrameCount*pFlac->channels*sizeof(type);                                                                                   \
+        if (dataSize > (ma_uint64)MA_SIZE_MAX) {                                                                                                            \
+            goto on_error;                                                                                                        \
+        }                                                                                                                                                           \
+                                                                                                                                                                    \
+        pSampleData = (type*)ma_dr_flac__malloc_from_callbacks((size_t)dataSize, &pFlac->allocationCallbacks);               \
+        if (pSampleData == NULL) {                                                                                                                                  \
+            goto on_error;                                                                                                                                          \
+        }                                                                                                                                                           \
+                                                                                                                                                                    \
+        totalPCMFrameCount = ma_dr_flac_read_pcm_frames_##extension(pFlac, pFlac->totalPCMFrameCount, pSampleData);                                                     \
+    }                                                                                                                                                               \
+                                                                                                                                                                    \
+    if (sampleRateOut) *sampleRateOut = pFlac->sampleRate;                                                                                                          \
+    if (channelsOut) *channelsOut = pFlac->channels;                                                                                                                \
+    if (totalPCMFrameCountOut) *totalPCMFrameCountOut = totalPCMFrameCount;                                                                                         \
+                                                                                                                                                                    \
+    ma_dr_flac_close(pFlac);                                                                                                                                            \
+    return pSampleData;                                                                                                                                             \
+                                                                                                                                                                    \
+on_error:                                                                                                                                                           \
+    ma_dr_flac_close(pFlac);                                                                                                                                            \
+    return NULL;                                                                                                                                                    \
+}
+MA_DR_FLAC_DEFINE_FULL_READ_AND_CLOSE(s32, ma_int32)
+MA_DR_FLAC_DEFINE_FULL_READ_AND_CLOSE(s16, ma_int16)
+MA_DR_FLAC_DEFINE_FULL_READ_AND_CLOSE(f32, float)
+MA_API ma_int32* ma_dr_flac_open_and_read_pcm_frames_s32(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalPCMFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalPCMFrameCountOut) {
+        *totalPCMFrameCountOut = 0;
+    }
+    pFlac = ma_dr_flac_open(onRead, onSeek, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s32(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut);
+}
+MA_API ma_int16* ma_dr_flac_open_and_read_pcm_frames_s16(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalPCMFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalPCMFrameCountOut) {
+        *totalPCMFrameCountOut = 0;
+    }
+    pFlac = ma_dr_flac_open(onRead, onSeek, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s16(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut);
+}
+MA_API float* ma_dr_flac_open_and_read_pcm_frames_f32(ma_dr_flac_read_proc onRead, ma_dr_flac_seek_proc onSeek, void* pUserData, unsigned int* channelsOut, unsigned int* sampleRateOut, ma_uint64* totalPCMFrameCountOut, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (channelsOut) {
+        *channelsOut = 0;
+    }
+    if (sampleRateOut) {
+        *sampleRateOut = 0;
+    }
+    if (totalPCMFrameCountOut) {
+        *totalPCMFrameCountOut = 0;
+    }
+    pFlac = ma_dr_flac_open(onRead, onSeek, pUserData, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_f32(pFlac, channelsOut, sampleRateOut, totalPCMFrameCountOut);
+}
+#ifndef MA_DR_FLAC_NO_STDIO
+MA_API ma_int32* ma_dr_flac_open_file_and_read_pcm_frames_s32(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_file(filename, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+MA_API ma_int16* ma_dr_flac_open_file_and_read_pcm_frames_s16(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_file(filename, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s16(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+MA_API float* ma_dr_flac_open_file_and_read_pcm_frames_f32(const char* filename, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_file(filename, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_f32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+#endif
+MA_API ma_int32* ma_dr_flac_open_memory_and_read_pcm_frames_s32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_memory(data, dataSize, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+MA_API ma_int16* ma_dr_flac_open_memory_and_read_pcm_frames_s16(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_memory(data, dataSize, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_s16(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+MA_API float* ma_dr_flac_open_memory_and_read_pcm_frames_f32(const void* data, size_t dataSize, unsigned int* channels, unsigned int* sampleRate, ma_uint64* totalPCMFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_flac* pFlac;
+    if (sampleRate) {
+        *sampleRate = 0;
+    }
+    if (channels) {
+        *channels = 0;
+    }
+    if (totalPCMFrameCount) {
+        *totalPCMFrameCount = 0;
+    }
+    pFlac = ma_dr_flac_open_memory(data, dataSize, pAllocationCallbacks);
+    if (pFlac == NULL) {
+        return NULL;
+    }
+    return ma_dr_flac__full_read_and_close_f32(pFlac, channels, sampleRate, totalPCMFrameCount);
+}
+MA_API void ma_dr_flac_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        ma_dr_flac__free_from_callbacks(p, pAllocationCallbacks);
+    } else {
+        ma_dr_flac__free_default(p, NULL);
+    }
+}
+MA_API void ma_dr_flac_init_vorbis_comment_iterator(ma_dr_flac_vorbis_comment_iterator* pIter, ma_uint32 commentCount, const void* pComments)
+{
+    if (pIter == NULL) {
+        return;
+    }
+    pIter->countRemaining = commentCount;
+    pIter->pRunningData   = (const char*)pComments;
+}
+MA_API const char* ma_dr_flac_next_vorbis_comment(ma_dr_flac_vorbis_comment_iterator* pIter, ma_uint32* pCommentLengthOut)
+{
+    ma_int32 length;
+    const char* pComment;
+    if (pCommentLengthOut) {
+        *pCommentLengthOut = 0;
+    }
+    if (pIter == NULL || pIter->countRemaining == 0 || pIter->pRunningData == NULL) {
+        return NULL;
+    }
+    length = ma_dr_flac__le2host_32_ptr_unaligned(pIter->pRunningData);
+    pIter->pRunningData += 4;
+    pComment = pIter->pRunningData;
+    pIter->pRunningData += length;
+    pIter->countRemaining -= 1;
+    if (pCommentLengthOut) {
+        *pCommentLengthOut = length;
+    }
+    return pComment;
+}
+MA_API void ma_dr_flac_init_cuesheet_track_iterator(ma_dr_flac_cuesheet_track_iterator* pIter, ma_uint32 trackCount, const void* pTrackData)
+{
+    if (pIter == NULL) {
+        return;
+    }
+    pIter->countRemaining = trackCount;
+    pIter->pRunningData   = (const char*)pTrackData;
+}
+MA_API ma_bool32 ma_dr_flac_next_cuesheet_track(ma_dr_flac_cuesheet_track_iterator* pIter, ma_dr_flac_cuesheet_track* pCuesheetTrack)
+{
+    ma_dr_flac_cuesheet_track cuesheetTrack;
+    const char* pRunningData;
+    ma_uint64 offsetHi;
+    ma_uint64 offsetLo;
+    if (pIter == NULL || pIter->countRemaining == 0 || pIter->pRunningData == NULL) {
+        return MA_FALSE;
+    }
+    pRunningData = pIter->pRunningData;
+    offsetHi                   = ma_dr_flac__be2host_32(*(const ma_uint32*)pRunningData); pRunningData += 4;
+    offsetLo                   = ma_dr_flac__be2host_32(*(const ma_uint32*)pRunningData); pRunningData += 4;
+    cuesheetTrack.offset       = offsetLo | (offsetHi << 32);
+    cuesheetTrack.trackNumber  = pRunningData[0];                                         pRunningData += 1;
+    MA_DR_FLAC_COPY_MEMORY(cuesheetTrack.ISRC, pRunningData, sizeof(cuesheetTrack.ISRC));     pRunningData += 12;
+    cuesheetTrack.isAudio      = (pRunningData[0] & 0x80) != 0;
+    cuesheetTrack.preEmphasis  = (pRunningData[0] & 0x40) != 0;                           pRunningData += 14;
+    cuesheetTrack.indexCount   = pRunningData[0];                                         pRunningData += 1;
+    cuesheetTrack.pIndexPoints = (const ma_dr_flac_cuesheet_track_index*)pRunningData;        pRunningData += cuesheetTrack.indexCount * sizeof(ma_dr_flac_cuesheet_track_index);
+    pIter->pRunningData = pRunningData;
+    pIter->countRemaining -= 1;
+    if (pCuesheetTrack) {
+        *pCuesheetTrack = cuesheetTrack;
+    }
+    return MA_TRUE;
+}
+#if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))
+    #pragma GCC diagnostic pop
+#endif
+#endif
+/* dr_flac_c end */
+#endif  /* MA_DR_FLAC_IMPLEMENTATION */
+#endif  /* MA_NO_FLAC */
+
+#if !defined(MA_NO_MP3) && !defined(MA_NO_DECODING)
+#if !defined(MA_DR_MP3_IMPLEMENTATION) && !defined(MA_DR_MP3_IMPLEMENTATION) /* For backwards compatibility. Will be removed in version 0.11 for cleanliness. */
+/* dr_mp3_c begin */
+#ifndef ma_dr_mp3_c
+#define ma_dr_mp3_c
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+MA_API void ma_dr_mp3_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision)
+{
+    if (pMajor) {
+        *pMajor = MA_DR_MP3_VERSION_MAJOR;
+    }
+    if (pMinor) {
+        *pMinor = MA_DR_MP3_VERSION_MINOR;
+    }
+    if (pRevision) {
+        *pRevision = MA_DR_MP3_VERSION_REVISION;
+    }
+}
+MA_API const char* ma_dr_mp3_version_string(void)
+{
+    return MA_DR_MP3_VERSION_STRING;
+}
+#if defined(__TINYC__)
+#define MA_DR_MP3_NO_SIMD
+#endif
+#define MA_DR_MP3_OFFSET_PTR(p, offset) ((void*)((ma_uint8*)(p) + (offset)))
+#define MA_DR_MP3_MAX_FREE_FORMAT_FRAME_SIZE  2304
+#ifndef MA_DR_MP3_MAX_FRAME_SYNC_MATCHES
+#define MA_DR_MP3_MAX_FRAME_SYNC_MATCHES      10
+#endif
+#define MA_DR_MP3_MAX_L3_FRAME_PAYLOAD_BYTES  MA_DR_MP3_MAX_FREE_FORMAT_FRAME_SIZE
+#define MA_DR_MP3_MAX_BITRESERVOIR_BYTES      511
+#define MA_DR_MP3_SHORT_BLOCK_TYPE            2
+#define MA_DR_MP3_STOP_BLOCK_TYPE             3
+#define MA_DR_MP3_MODE_MONO                   3
+#define MA_DR_MP3_MODE_JOINT_STEREO           1
+#define MA_DR_MP3_HDR_SIZE                    4
+#define MA_DR_MP3_HDR_IS_MONO(h)              (((h[3]) & 0xC0) == 0xC0)
+#define MA_DR_MP3_HDR_IS_MS_STEREO(h)         (((h[3]) & 0xE0) == 0x60)
+#define MA_DR_MP3_HDR_IS_FREE_FORMAT(h)       (((h[2]) & 0xF0) == 0)
+#define MA_DR_MP3_HDR_IS_CRC(h)               (!((h[1]) & 1))
+#define MA_DR_MP3_HDR_TEST_PADDING(h)         ((h[2]) & 0x2)
+#define MA_DR_MP3_HDR_TEST_MPEG1(h)           ((h[1]) & 0x8)
+#define MA_DR_MP3_HDR_TEST_NOT_MPEG25(h)      ((h[1]) & 0x10)
+#define MA_DR_MP3_HDR_TEST_I_STEREO(h)        ((h[3]) & 0x10)
+#define MA_DR_MP3_HDR_TEST_MS_STEREO(h)       ((h[3]) & 0x20)
+#define MA_DR_MP3_HDR_GET_STEREO_MODE(h)      (((h[3]) >> 6) & 3)
+#define MA_DR_MP3_HDR_GET_STEREO_MODE_EXT(h)  (((h[3]) >> 4) & 3)
+#define MA_DR_MP3_HDR_GET_LAYER(h)            (((h[1]) >> 1) & 3)
+#define MA_DR_MP3_HDR_GET_BITRATE(h)          ((h[2]) >> 4)
+#define MA_DR_MP3_HDR_GET_SAMPLE_RATE(h)      (((h[2]) >> 2) & 3)
+#define MA_DR_MP3_HDR_GET_MY_SAMPLE_RATE(h)   (MA_DR_MP3_HDR_GET_SAMPLE_RATE(h) + (((h[1] >> 3) & 1) + ((h[1] >> 4) & 1))*3)
+#define MA_DR_MP3_HDR_IS_FRAME_576(h)         ((h[1] & 14) == 2)
+#define MA_DR_MP3_HDR_IS_LAYER_1(h)           ((h[1] & 6) == 6)
+#define MA_DR_MP3_BITS_DEQUANTIZER_OUT        -1
+#define MA_DR_MP3_MAX_SCF                     (255 + MA_DR_MP3_BITS_DEQUANTIZER_OUT*4 - 210)
+#define MA_DR_MP3_MAX_SCFI                    ((MA_DR_MP3_MAX_SCF + 3) & ~3)
+#define MA_DR_MP3_MIN(a, b)           ((a) > (b) ? (b) : (a))
+#define MA_DR_MP3_MAX(a, b)           ((a) < (b) ? (b) : (a))
+#if !defined(MA_DR_MP3_NO_SIMD)
+#if !defined(MA_DR_MP3_ONLY_SIMD) && (defined(_M_X64) || defined(__x86_64__) || defined(__aarch64__) || defined(_M_ARM64))
+#define MA_DR_MP3_ONLY_SIMD
+#endif
+#if ((defined(_MSC_VER) && _MSC_VER >= 1400) && defined(_M_X64)) || ((defined(__i386) || defined(_M_IX86) || defined(__i386__) || defined(__x86_64__)) && ((defined(_M_IX86_FP) && _M_IX86_FP == 2) || defined(__SSE2__)))
+#if defined(_MSC_VER)
+#include <intrin.h>
+#endif
+#include <emmintrin.h>
+#define MA_DR_MP3_HAVE_SSE 1
+#define MA_DR_MP3_HAVE_SIMD 1
+#define MA_DR_MP3_VSTORE _mm_storeu_ps
+#define MA_DR_MP3_VLD _mm_loadu_ps
+#define MA_DR_MP3_VSET _mm_set1_ps
+#define MA_DR_MP3_VADD _mm_add_ps
+#define MA_DR_MP3_VSUB _mm_sub_ps
+#define MA_DR_MP3_VMUL _mm_mul_ps
+#define MA_DR_MP3_VMAC(a, x, y) _mm_add_ps(a, _mm_mul_ps(x, y))
+#define MA_DR_MP3_VMSB(a, x, y) _mm_sub_ps(a, _mm_mul_ps(x, y))
+#define MA_DR_MP3_VMUL_S(x, s)  _mm_mul_ps(x, _mm_set1_ps(s))
+#define MA_DR_MP3_VREV(x) _mm_shuffle_ps(x, x, _MM_SHUFFLE(0, 1, 2, 3))
+typedef __m128 ma_dr_mp3_f4;
+#if defined(_MSC_VER) || defined(MA_DR_MP3_ONLY_SIMD)
+#define ma_dr_mp3_cpuid __cpuid
+#else
+static __inline__ __attribute__((always_inline)) void ma_dr_mp3_cpuid(int CPUInfo[], const int InfoType)
+{
+#if defined(__PIC__)
+    __asm__ __volatile__(
+#if defined(__x86_64__)
+        "push %%rbx\n"
+        "cpuid\n"
+        "xchgl %%ebx, %1\n"
+        "pop  %%rbx\n"
+#else
+        "xchgl %%ebx, %1\n"
+        "cpuid\n"
+        "xchgl %%ebx, %1\n"
+#endif
+        : "=a" (CPUInfo[0]), "=r" (CPUInfo[1]), "=c" (CPUInfo[2]), "=d" (CPUInfo[3])
+        : "a" (InfoType));
+#else
+    __asm__ __volatile__(
+        "cpuid"
+        : "=a" (CPUInfo[0]), "=b" (CPUInfo[1]), "=c" (CPUInfo[2]), "=d" (CPUInfo[3])
+        : "a" (InfoType));
+#endif
+}
+#endif
+static int ma_dr_mp3_have_simd(void)
+{
+#ifdef MA_DR_MP3_ONLY_SIMD
+    return 1;
+#else
+    static int g_have_simd;
+    int CPUInfo[4];
+#ifdef MINIMP3_TEST
+    static int g_counter;
+    if (g_counter++ > 100)
+        return 0;
+#endif
+    if (g_have_simd)
+        goto end;
+    ma_dr_mp3_cpuid(CPUInfo, 0);
+    if (CPUInfo[0] > 0)
+    {
+        ma_dr_mp3_cpuid(CPUInfo, 1);
+        g_have_simd = (CPUInfo[3] & (1 << 26)) + 1;
+        return g_have_simd - 1;
+    }
+end:
+    return g_have_simd - 1;
+#endif
+}
+#elif defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64)
+#include <arm_neon.h>
+#define MA_DR_MP3_HAVE_SSE 0
+#define MA_DR_MP3_HAVE_SIMD 1
+#define MA_DR_MP3_VSTORE vst1q_f32
+#define MA_DR_MP3_VLD vld1q_f32
+#define MA_DR_MP3_VSET vmovq_n_f32
+#define MA_DR_MP3_VADD vaddq_f32
+#define MA_DR_MP3_VSUB vsubq_f32
+#define MA_DR_MP3_VMUL vmulq_f32
+#define MA_DR_MP3_VMAC(a, x, y) vmlaq_f32(a, x, y)
+#define MA_DR_MP3_VMSB(a, x, y) vmlsq_f32(a, x, y)
+#define MA_DR_MP3_VMUL_S(x, s)  vmulq_f32(x, vmovq_n_f32(s))
+#define MA_DR_MP3_VREV(x) vcombine_f32(vget_high_f32(vrev64q_f32(x)), vget_low_f32(vrev64q_f32(x)))
+typedef float32x4_t ma_dr_mp3_f4;
+static int ma_dr_mp3_have_simd(void)
+{
+    return 1;
+}
+#else
+#define MA_DR_MP3_HAVE_SSE 0
+#define MA_DR_MP3_HAVE_SIMD 0
+#ifdef MA_DR_MP3_ONLY_SIMD
+#error MA_DR_MP3_ONLY_SIMD used, but SSE/NEON not enabled
+#endif
+#endif
+#else
+#define MA_DR_MP3_HAVE_SIMD 0
+#endif
+#if defined(__ARM_ARCH) && (__ARM_ARCH >= 6) && !defined(__aarch64__) && !defined(_M_ARM64) && !defined(__ARM_ARCH_6M__)
+#define MA_DR_MP3_HAVE_ARMV6 1
+static __inline__ __attribute__((always_inline)) ma_int32 ma_dr_mp3_clip_int16_arm(ma_int32 a)
+{
+    ma_int32 x = 0;
+    __asm__ ("ssat %0, #16, %1" : "=r"(x) : "r"(a));
+    return x;
+}
+#else
+#define MA_DR_MP3_HAVE_ARMV6 0
+#endif
+#ifndef MA_DR_MP3_ASSERT
+#include <assert.h>
+#define MA_DR_MP3_ASSERT(expression) assert(expression)
+#endif
+#ifndef MA_DR_MP3_COPY_MEMORY
+#define MA_DR_MP3_COPY_MEMORY(dst, src, sz) memcpy((dst), (src), (sz))
+#endif
+#ifndef MA_DR_MP3_MOVE_MEMORY
+#define MA_DR_MP3_MOVE_MEMORY(dst, src, sz) memmove((dst), (src), (sz))
+#endif
+#ifndef MA_DR_MP3_ZERO_MEMORY
+#define MA_DR_MP3_ZERO_MEMORY(p, sz) memset((p), 0, (sz))
+#endif
+#define MA_DR_MP3_ZERO_OBJECT(p) MA_DR_MP3_ZERO_MEMORY((p), sizeof(*(p)))
+#ifndef MA_DR_MP3_MALLOC
+#define MA_DR_MP3_MALLOC(sz) malloc((sz))
+#endif
+#ifndef MA_DR_MP3_REALLOC
+#define MA_DR_MP3_REALLOC(p, sz) realloc((p), (sz))
+#endif
+#ifndef MA_DR_MP3_FREE
+#define MA_DR_MP3_FREE(p) free((p))
+#endif
+typedef struct
+{
+    const ma_uint8 *buf;
+    int pos, limit;
+} ma_dr_mp3_bs;
+typedef struct
+{
+    float scf[3*64];
+    ma_uint8 total_bands, stereo_bands, bitalloc[64], scfcod[64];
+} ma_dr_mp3_L12_scale_info;
+typedef struct
+{
+    ma_uint8 tab_offset, code_tab_width, band_count;
+} ma_dr_mp3_L12_subband_alloc;
+typedef struct
+{
+    const ma_uint8 *sfbtab;
+    ma_uint16 part_23_length, big_values, scalefac_compress;
+    ma_uint8 global_gain, block_type, mixed_block_flag, n_long_sfb, n_short_sfb;
+    ma_uint8 table_select[3], region_count[3], subblock_gain[3];
+    ma_uint8 preflag, scalefac_scale, count1_table, scfsi;
+} ma_dr_mp3_L3_gr_info;
+typedef struct
+{
+    ma_dr_mp3_bs bs;
+    ma_uint8 maindata[MA_DR_MP3_MAX_BITRESERVOIR_BYTES + MA_DR_MP3_MAX_L3_FRAME_PAYLOAD_BYTES];
+    ma_dr_mp3_L3_gr_info gr_info[4];
+    float grbuf[2][576], scf[40], syn[18 + 15][2*32];
+    ma_uint8 ist_pos[2][39];
+} ma_dr_mp3dec_scratch;
+static void ma_dr_mp3_bs_init(ma_dr_mp3_bs *bs, const ma_uint8 *data, int bytes)
+{
+    bs->buf   = data;
+    bs->pos   = 0;
+    bs->limit = bytes*8;
+}
+static ma_uint32 ma_dr_mp3_bs_get_bits(ma_dr_mp3_bs *bs, int n)
+{
+    ma_uint32 next, cache = 0, s = bs->pos & 7;
+    int shl = n + s;
+    const ma_uint8 *p = bs->buf + (bs->pos >> 3);
+    if ((bs->pos += n) > bs->limit)
+        return 0;
+    next = *p++ & (255 >> s);
+    while ((shl -= 8) > 0)
+    {
+        cache |= next << shl;
+        next = *p++;
+    }
+    return cache | (next >> -shl);
+}
+static int ma_dr_mp3_hdr_valid(const ma_uint8 *h)
+{
+    return h[0] == 0xff &&
+        ((h[1] & 0xF0) == 0xf0 || (h[1] & 0xFE) == 0xe2) &&
+        (MA_DR_MP3_HDR_GET_LAYER(h) != 0) &&
+        (MA_DR_MP3_HDR_GET_BITRATE(h) != 15) &&
+        (MA_DR_MP3_HDR_GET_SAMPLE_RATE(h) != 3);
+}
+static int ma_dr_mp3_hdr_compare(const ma_uint8 *h1, const ma_uint8 *h2)
+{
+    return ma_dr_mp3_hdr_valid(h2) &&
+        ((h1[1] ^ h2[1]) & 0xFE) == 0 &&
+        ((h1[2] ^ h2[2]) & 0x0C) == 0 &&
+        !(MA_DR_MP3_HDR_IS_FREE_FORMAT(h1) ^ MA_DR_MP3_HDR_IS_FREE_FORMAT(h2));
+}
+static unsigned ma_dr_mp3_hdr_bitrate_kbps(const ma_uint8 *h)
+{
+    static const ma_uint8 halfrate[2][3][15] = {
+        { { 0,4,8,12,16,20,24,28,32,40,48,56,64,72,80 }, { 0,4,8,12,16,20,24,28,32,40,48,56,64,72,80 }, { 0,16,24,28,32,40,48,56,64,72,80,88,96,112,128 } },
+        { { 0,16,20,24,28,32,40,48,56,64,80,96,112,128,160 }, { 0,16,24,28,32,40,48,56,64,80,96,112,128,160,192 }, { 0,16,32,48,64,80,96,112,128,144,160,176,192,208,224 } },
+    };
+    return 2*halfrate[!!MA_DR_MP3_HDR_TEST_MPEG1(h)][MA_DR_MP3_HDR_GET_LAYER(h) - 1][MA_DR_MP3_HDR_GET_BITRATE(h)];
+}
+static unsigned ma_dr_mp3_hdr_sample_rate_hz(const ma_uint8 *h)
+{
+    static const unsigned g_hz[3] = { 44100, 48000, 32000 };
+    return g_hz[MA_DR_MP3_HDR_GET_SAMPLE_RATE(h)] >> (int)!MA_DR_MP3_HDR_TEST_MPEG1(h) >> (int)!MA_DR_MP3_HDR_TEST_NOT_MPEG25(h);
+}
+static unsigned ma_dr_mp3_hdr_frame_samples(const ma_uint8 *h)
+{
+    return MA_DR_MP3_HDR_IS_LAYER_1(h) ? 384 : (1152 >> (int)MA_DR_MP3_HDR_IS_FRAME_576(h));
+}
+static int ma_dr_mp3_hdr_frame_bytes(const ma_uint8 *h, int free_format_size)
+{
+    int frame_bytes = ma_dr_mp3_hdr_frame_samples(h)*ma_dr_mp3_hdr_bitrate_kbps(h)*125/ma_dr_mp3_hdr_sample_rate_hz(h);
+    if (MA_DR_MP3_HDR_IS_LAYER_1(h))
+    {
+        frame_bytes &= ~3;
+    }
+    return frame_bytes ? frame_bytes : free_format_size;
+}
+static int ma_dr_mp3_hdr_padding(const ma_uint8 *h)
+{
+    return MA_DR_MP3_HDR_TEST_PADDING(h) ? (MA_DR_MP3_HDR_IS_LAYER_1(h) ? 4 : 1) : 0;
+}
+#ifndef MA_DR_MP3_ONLY_MP3
+static const ma_dr_mp3_L12_subband_alloc *ma_dr_mp3_L12_subband_alloc_table(const ma_uint8 *hdr, ma_dr_mp3_L12_scale_info *sci)
+{
+    const ma_dr_mp3_L12_subband_alloc *alloc;
+    int mode = MA_DR_MP3_HDR_GET_STEREO_MODE(hdr);
+    int nbands, stereo_bands = (mode == MA_DR_MP3_MODE_MONO) ? 0 : (mode == MA_DR_MP3_MODE_JOINT_STEREO) ? (MA_DR_MP3_HDR_GET_STEREO_MODE_EXT(hdr) << 2) + 4 : 32;
+    if (MA_DR_MP3_HDR_IS_LAYER_1(hdr))
+    {
+        static const ma_dr_mp3_L12_subband_alloc g_alloc_L1[] = { { 76, 4, 32 } };
+        alloc = g_alloc_L1;
+        nbands = 32;
+    } else if (!MA_DR_MP3_HDR_TEST_MPEG1(hdr))
+    {
+        static const ma_dr_mp3_L12_subband_alloc g_alloc_L2M2[] = { { 60, 4, 4 }, { 44, 3, 7 }, { 44, 2, 19 } };
+        alloc = g_alloc_L2M2;
+        nbands = 30;
+    } else
+    {
+        static const ma_dr_mp3_L12_subband_alloc g_alloc_L2M1[] = { { 0, 4, 3 }, { 16, 4, 8 }, { 32, 3, 12 }, { 40, 2, 7 } };
+        int sample_rate_idx = MA_DR_MP3_HDR_GET_SAMPLE_RATE(hdr);
+        unsigned kbps = ma_dr_mp3_hdr_bitrate_kbps(hdr) >> (int)(mode != MA_DR_MP3_MODE_MONO);
+        if (!kbps)
+        {
+            kbps = 192;
+        }
+        alloc = g_alloc_L2M1;
+        nbands = 27;
+        if (kbps < 56)
+        {
+            static const ma_dr_mp3_L12_subband_alloc g_alloc_L2M1_lowrate[] = { { 44, 4, 2 }, { 44, 3, 10 } };
+            alloc = g_alloc_L2M1_lowrate;
+            nbands = sample_rate_idx == 2 ? 12 : 8;
+        } else if (kbps >= 96 && sample_rate_idx != 1)
+        {
+            nbands = 30;
+        }
+    }
+    sci->total_bands = (ma_uint8)nbands;
+    sci->stereo_bands = (ma_uint8)MA_DR_MP3_MIN(stereo_bands, nbands);
+    return alloc;
+}
+static void ma_dr_mp3_L12_read_scalefactors(ma_dr_mp3_bs *bs, ma_uint8 *pba, ma_uint8 *scfcod, int bands, float *scf)
+{
+    static const float g_deq_L12[18*3] = {
+#define MA_DR_MP3_DQ(x) 9.53674316e-07f/x, 7.56931807e-07f/x, 6.00777173e-07f/x
+        MA_DR_MP3_DQ(3),MA_DR_MP3_DQ(7),MA_DR_MP3_DQ(15),MA_DR_MP3_DQ(31),MA_DR_MP3_DQ(63),MA_DR_MP3_DQ(127),MA_DR_MP3_DQ(255),MA_DR_MP3_DQ(511),MA_DR_MP3_DQ(1023),MA_DR_MP3_DQ(2047),MA_DR_MP3_DQ(4095),MA_DR_MP3_DQ(8191),MA_DR_MP3_DQ(16383),MA_DR_MP3_DQ(32767),MA_DR_MP3_DQ(65535),MA_DR_MP3_DQ(3),MA_DR_MP3_DQ(5),MA_DR_MP3_DQ(9)
+    };
+    int i, m;
+    for (i = 0; i < bands; i++)
+    {
+        float s = 0;
+        int ba = *pba++;
+        int mask = ba ? 4 + ((19 >> scfcod[i]) & 3) : 0;
+        for (m = 4; m; m >>= 1)
+        {
+            if (mask & m)
+            {
+                int b = ma_dr_mp3_bs_get_bits(bs, 6);
+                s = g_deq_L12[ba*3 - 6 + b % 3]*(int)(1 << 21 >> b/3);
+            }
+            *scf++ = s;
+        }
+    }
+}
+static void ma_dr_mp3_L12_read_scale_info(const ma_uint8 *hdr, ma_dr_mp3_bs *bs, ma_dr_mp3_L12_scale_info *sci)
+{
+    static const ma_uint8 g_bitalloc_code_tab[] = {
+        0,17, 3, 4, 5,6,7, 8,9,10,11,12,13,14,15,16,
+        0,17,18, 3,19,4,5, 6,7, 8, 9,10,11,12,13,16,
+        0,17,18, 3,19,4,5,16,
+        0,17,18,16,
+        0,17,18,19, 4,5,6, 7,8, 9,10,11,12,13,14,15,
+        0,17,18, 3,19,4,5, 6,7, 8, 9,10,11,12,13,14,
+        0, 2, 3, 4, 5,6,7, 8,9,10,11,12,13,14,15,16
+    };
+    const ma_dr_mp3_L12_subband_alloc *subband_alloc = ma_dr_mp3_L12_subband_alloc_table(hdr, sci);
+    int i, k = 0, ba_bits = 0;
+    const ma_uint8 *ba_code_tab = g_bitalloc_code_tab;
+    for (i = 0; i < sci->total_bands; i++)
+    {
+        ma_uint8 ba;
+        if (i == k)
+        {
+            k += subband_alloc->band_count;
+            ba_bits = subband_alloc->code_tab_width;
+            ba_code_tab = g_bitalloc_code_tab + subband_alloc->tab_offset;
+            subband_alloc++;
+        }
+        ba = ba_code_tab[ma_dr_mp3_bs_get_bits(bs, ba_bits)];
+        sci->bitalloc[2*i] = ba;
+        if (i < sci->stereo_bands)
+        {
+            ba = ba_code_tab[ma_dr_mp3_bs_get_bits(bs, ba_bits)];
+        }
+        sci->bitalloc[2*i + 1] = sci->stereo_bands ? ba : 0;
+    }
+    for (i = 0; i < 2*sci->total_bands; i++)
+    {
+        sci->scfcod[i] = (ma_uint8)(sci->bitalloc[i] ? MA_DR_MP3_HDR_IS_LAYER_1(hdr) ? 2 : ma_dr_mp3_bs_get_bits(bs, 2) : 6);
+    }
+    ma_dr_mp3_L12_read_scalefactors(bs, sci->bitalloc, sci->scfcod, sci->total_bands*2, sci->scf);
+    for (i = sci->stereo_bands; i < sci->total_bands; i++)
+    {
+        sci->bitalloc[2*i + 1] = 0;
+    }
+}
+static int ma_dr_mp3_L12_dequantize_granule(float *grbuf, ma_dr_mp3_bs *bs, ma_dr_mp3_L12_scale_info *sci, int group_size)
+{
+    int i, j, k, choff = 576;
+    for (j = 0; j < 4; j++)
+    {
+        float *dst = grbuf + group_size*j;
+        for (i = 0; i < 2*sci->total_bands; i++)
+        {
+            int ba = sci->bitalloc[i];
+            if (ba != 0)
+            {
+                if (ba < 17)
+                {
+                    int half = (1 << (ba - 1)) - 1;
+                    for (k = 0; k < group_size; k++)
+                    {
+                        dst[k] = (float)((int)ma_dr_mp3_bs_get_bits(bs, ba) - half);
+                    }
+                } else
+                {
+                    unsigned mod = (2 << (ba - 17)) + 1;
+                    unsigned code = ma_dr_mp3_bs_get_bits(bs, mod + 2 - (mod >> 3));
+                    for (k = 0; k < group_size; k++, code /= mod)
+                    {
+                        dst[k] = (float)((int)(code % mod - mod/2));
+                    }
+                }
+            }
+            dst += choff;
+            choff = 18 - choff;
+        }
+    }
+    return group_size*4;
+}
+static void ma_dr_mp3_L12_apply_scf_384(ma_dr_mp3_L12_scale_info *sci, const float *scf, float *dst)
+{
+    int i, k;
+    MA_DR_MP3_COPY_MEMORY(dst + 576 + sci->stereo_bands*18, dst + sci->stereo_bands*18, (sci->total_bands - sci->stereo_bands)*18*sizeof(float));
+    for (i = 0; i < sci->total_bands; i++, dst += 18, scf += 6)
+    {
+        for (k = 0; k < 12; k++)
+        {
+            dst[k + 0]   *= scf[0];
+            dst[k + 576] *= scf[3];
+        }
+    }
+}
+#endif
+static int ma_dr_mp3_L3_read_side_info(ma_dr_mp3_bs *bs, ma_dr_mp3_L3_gr_info *gr, const ma_uint8 *hdr)
+{
+    static const ma_uint8 g_scf_long[8][23] = {
+        { 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 },
+        { 12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2,0 },
+        { 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 },
+        { 6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,54,62,70,76,36,0 },
+        { 6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54,0 },
+        { 4,4,4,4,4,4,6,6,8,8,10,12,16,20,24,28,34,42,50,54,76,158,0 },
+        { 4,4,4,4,4,4,6,6,6,8,10,12,16,18,22,28,34,40,46,54,54,192,0 },
+        { 4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102,26,0 }
+    };
+    static const ma_uint8 g_scf_short[8][40] = {
+        { 4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 },
+        { 8,8,8,8,8,8,8,8,8,12,12,12,16,16,16,20,20,20,24,24,24,28,28,28,36,36,36,2,2,2,2,2,2,2,2,2,26,26,26,0 },
+        { 4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,8,8,8,10,10,10,14,14,14,18,18,18,26,26,26,32,32,32,42,42,42,18,18,18,0 },
+        { 4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,32,32,32,44,44,44,12,12,12,0 },
+        { 4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 },
+        { 4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,22,22,22,30,30,30,56,56,56,0 },
+        { 4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,6,6,6,10,10,10,12,12,12,14,14,14,16,16,16,20,20,20,26,26,26,66,66,66,0 },
+        { 4,4,4,4,4,4,4,4,4,4,4,4,6,6,6,8,8,8,12,12,12,16,16,16,20,20,20,26,26,26,34,34,34,42,42,42,12,12,12,0 }
+    };
+    static const ma_uint8 g_scf_mixed[8][40] = {
+        { 6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 },
+        { 12,12,12,4,4,4,8,8,8,12,12,12,16,16,16,20,20,20,24,24,24,28,28,28,36,36,36,2,2,2,2,2,2,2,2,2,26,26,26,0 },
+        { 6,6,6,6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,14,14,14,18,18,18,26,26,26,32,32,32,42,42,42,18,18,18,0 },
+        { 6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,32,32,32,44,44,44,12,12,12,0 },
+        { 6,6,6,6,6,6,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,24,24,24,30,30,30,40,40,40,18,18,18,0 },
+        { 4,4,4,4,4,4,6,6,4,4,4,6,6,6,8,8,8,10,10,10,12,12,12,14,14,14,18,18,18,22,22,22,30,30,30,56,56,56,0 },
+        { 4,4,4,4,4,4,6,6,4,4,4,6,6,6,6,6,6,10,10,10,12,12,12,14,14,14,16,16,16,20,20,20,26,26,26,66,66,66,0 },
+        { 4,4,4,4,4,4,6,6,4,4,4,6,6,6,8,8,8,12,12,12,16,16,16,20,20,20,26,26,26,34,34,34,42,42,42,12,12,12,0 }
+    };
+    unsigned tables, scfsi = 0;
+    int main_data_begin, part_23_sum = 0;
+    int gr_count = MA_DR_MP3_HDR_IS_MONO(hdr) ? 1 : 2;
+    int sr_idx = MA_DR_MP3_HDR_GET_MY_SAMPLE_RATE(hdr); sr_idx -= (sr_idx != 0);
+    if (MA_DR_MP3_HDR_TEST_MPEG1(hdr))
+    {
+        gr_count *= 2;
+        main_data_begin = ma_dr_mp3_bs_get_bits(bs, 9);
+        scfsi = ma_dr_mp3_bs_get_bits(bs, 7 + gr_count);
+    } else
+    {
+        main_data_begin = ma_dr_mp3_bs_get_bits(bs, 8 + gr_count) >> gr_count;
+    }
+    do
+    {
+        if (MA_DR_MP3_HDR_IS_MONO(hdr))
+        {
+            scfsi <<= 4;
+        }
+        gr->part_23_length = (ma_uint16)ma_dr_mp3_bs_get_bits(bs, 12);
+        part_23_sum += gr->part_23_length;
+        gr->big_values = (ma_uint16)ma_dr_mp3_bs_get_bits(bs,  9);
+        if (gr->big_values > 288)
+        {
+            return -1;
+        }
+        gr->global_gain = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 8);
+        gr->scalefac_compress = (ma_uint16)ma_dr_mp3_bs_get_bits(bs, MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? 4 : 9);
+        gr->sfbtab = g_scf_long[sr_idx];
+        gr->n_long_sfb  = 22;
+        gr->n_short_sfb = 0;
+        if (ma_dr_mp3_bs_get_bits(bs, 1))
+        {
+            gr->block_type = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 2);
+            if (!gr->block_type)
+            {
+                return -1;
+            }
+            gr->mixed_block_flag = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 1);
+            gr->region_count[0] = 7;
+            gr->region_count[1] = 255;
+            if (gr->block_type == MA_DR_MP3_SHORT_BLOCK_TYPE)
+            {
+                scfsi &= 0x0F0F;
+                if (!gr->mixed_block_flag)
+                {
+                    gr->region_count[0] = 8;
+                    gr->sfbtab = g_scf_short[sr_idx];
+                    gr->n_long_sfb = 0;
+                    gr->n_short_sfb = 39;
+                } else
+                {
+                    gr->sfbtab = g_scf_mixed[sr_idx];
+                    gr->n_long_sfb = MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? 8 : 6;
+                    gr->n_short_sfb = 30;
+                }
+            }
+            tables = ma_dr_mp3_bs_get_bits(bs, 10);
+            tables <<= 5;
+            gr->subblock_gain[0] = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 3);
+            gr->subblock_gain[1] = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 3);
+            gr->subblock_gain[2] = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 3);
+        } else
+        {
+            gr->block_type = 0;
+            gr->mixed_block_flag = 0;
+            tables = ma_dr_mp3_bs_get_bits(bs, 15);
+            gr->region_count[0] = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 4);
+            gr->region_count[1] = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 3);
+            gr->region_count[2] = 255;
+        }
+        gr->table_select[0] = (ma_uint8)(tables >> 10);
+        gr->table_select[1] = (ma_uint8)((tables >> 5) & 31);
+        gr->table_select[2] = (ma_uint8)((tables) & 31);
+        gr->preflag = (ma_uint8)(MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? ma_dr_mp3_bs_get_bits(bs, 1) : (gr->scalefac_compress >= 500));
+        gr->scalefac_scale = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 1);
+        gr->count1_table = (ma_uint8)ma_dr_mp3_bs_get_bits(bs, 1);
+        gr->scfsi = (ma_uint8)((scfsi >> 12) & 15);
+        scfsi <<= 4;
+        gr++;
+    } while(--gr_count);
+    if (part_23_sum + bs->pos > bs->limit + main_data_begin*8)
+    {
+        return -1;
+    }
+    return main_data_begin;
+}
+static void ma_dr_mp3_L3_read_scalefactors(ma_uint8 *scf, ma_uint8 *ist_pos, const ma_uint8 *scf_size, const ma_uint8 *scf_count, ma_dr_mp3_bs *bitbuf, int scfsi)
+{
+    int i, k;
+    for (i = 0; i < 4 && scf_count[i]; i++, scfsi *= 2)
+    {
+        int cnt = scf_count[i];
+        if (scfsi & 8)
+        {
+            MA_DR_MP3_COPY_MEMORY(scf, ist_pos, cnt);
+        } else
+        {
+            int bits = scf_size[i];
+            if (!bits)
+            {
+                MA_DR_MP3_ZERO_MEMORY(scf, cnt);
+                MA_DR_MP3_ZERO_MEMORY(ist_pos, cnt);
+            } else
+            {
+                int max_scf = (scfsi < 0) ? (1 << bits) - 1 : -1;
+                for (k = 0; k < cnt; k++)
+                {
+                    int s = ma_dr_mp3_bs_get_bits(bitbuf, bits);
+                    ist_pos[k] = (ma_uint8)(s == max_scf ? -1 : s);
+                    scf[k] = (ma_uint8)s;
+                }
+            }
+        }
+        ist_pos += cnt;
+        scf += cnt;
+    }
+    scf[0] = scf[1] = scf[2] = 0;
+}
+static float ma_dr_mp3_L3_ldexp_q2(float y, int exp_q2)
+{
+    static const float g_expfrac[4] = { 9.31322575e-10f,7.83145814e-10f,6.58544508e-10f,5.53767716e-10f };
+    int e;
+    do
+    {
+        e = MA_DR_MP3_MIN(30*4, exp_q2);
+        y *= g_expfrac[e & 3]*(1 << 30 >> (e >> 2));
+    } while ((exp_q2 -= e) > 0);
+    return y;
+}
+static void ma_dr_mp3_L3_decode_scalefactors(const ma_uint8 *hdr, ma_uint8 *ist_pos, ma_dr_mp3_bs *bs, const ma_dr_mp3_L3_gr_info *gr, float *scf, int ch)
+{
+    static const ma_uint8 g_scf_partitions[3][28] = {
+        { 6,5,5, 5,6,5,5,5,6,5, 7,3,11,10,0,0, 7, 7, 7,0, 6, 6,6,3, 8, 8,5,0 },
+        { 8,9,6,12,6,9,9,9,6,9,12,6,15,18,0,0, 6,15,12,0, 6,12,9,6, 6,18,9,0 },
+        { 9,9,6,12,9,9,9,9,9,9,12,6,18,18,0,0,12,12,12,0,12, 9,9,6,15,12,9,0 }
+    };
+    const ma_uint8 *scf_partition = g_scf_partitions[!!gr->n_short_sfb + !gr->n_long_sfb];
+    ma_uint8 scf_size[4], iscf[40];
+    int i, scf_shift = gr->scalefac_scale + 1, gain_exp, scfsi = gr->scfsi;
+    float gain;
+    if (MA_DR_MP3_HDR_TEST_MPEG1(hdr))
+    {
+        static const ma_uint8 g_scfc_decode[16] = { 0,1,2,3, 12,5,6,7, 9,10,11,13, 14,15,18,19 };
+        int part = g_scfc_decode[gr->scalefac_compress];
+        scf_size[1] = scf_size[0] = (ma_uint8)(part >> 2);
+        scf_size[3] = scf_size[2] = (ma_uint8)(part & 3);
+    } else
+    {
+        static const ma_uint8 g_mod[6*4] = { 5,5,4,4,5,5,4,1,4,3,1,1,5,6,6,1,4,4,4,1,4,3,1,1 };
+        int k, modprod, sfc, ist = MA_DR_MP3_HDR_TEST_I_STEREO(hdr) && ch;
+        sfc = gr->scalefac_compress >> ist;
+        for (k = ist*3*4; sfc >= 0; sfc -= modprod, k += 4)
+        {
+            for (modprod = 1, i = 3; i >= 0; i--)
+            {
+                scf_size[i] = (ma_uint8)(sfc / modprod % g_mod[k + i]);
+                modprod *= g_mod[k + i];
+            }
+        }
+        scf_partition += k;
+        scfsi = -16;
+    }
+    ma_dr_mp3_L3_read_scalefactors(iscf, ist_pos, scf_size, scf_partition, bs, scfsi);
+    if (gr->n_short_sfb)
+    {
+        int sh = 3 - scf_shift;
+        for (i = 0; i < gr->n_short_sfb; i += 3)
+        {
+            iscf[gr->n_long_sfb + i + 0] = (ma_uint8)(iscf[gr->n_long_sfb + i + 0] + (gr->subblock_gain[0] << sh));
+            iscf[gr->n_long_sfb + i + 1] = (ma_uint8)(iscf[gr->n_long_sfb + i + 1] + (gr->subblock_gain[1] << sh));
+            iscf[gr->n_long_sfb + i + 2] = (ma_uint8)(iscf[gr->n_long_sfb + i + 2] + (gr->subblock_gain[2] << sh));
+        }
+    } else if (gr->preflag)
+    {
+        static const ma_uint8 g_preamp[10] = { 1,1,1,1,2,2,3,3,3,2 };
+        for (i = 0; i < 10; i++)
+        {
+            iscf[11 + i] = (ma_uint8)(iscf[11 + i] + g_preamp[i]);
+        }
+    }
+    gain_exp = gr->global_gain + MA_DR_MP3_BITS_DEQUANTIZER_OUT*4 - 210 - (MA_DR_MP3_HDR_IS_MS_STEREO(hdr) ? 2 : 0);
+    gain = ma_dr_mp3_L3_ldexp_q2(1 << (MA_DR_MP3_MAX_SCFI/4),  MA_DR_MP3_MAX_SCFI - gain_exp);
+    for (i = 0; i < (int)(gr->n_long_sfb + gr->n_short_sfb); i++)
+    {
+        scf[i] = ma_dr_mp3_L3_ldexp_q2(gain, iscf[i] << scf_shift);
+    }
+}
+static const float g_ma_dr_mp3_pow43[129 + 16] = {
+    0,-1,-2.519842f,-4.326749f,-6.349604f,-8.549880f,-10.902724f,-13.390518f,-16.000000f,-18.720754f,-21.544347f,-24.463781f,-27.473142f,-30.567351f,-33.741992f,-36.993181f,
+    0,1,2.519842f,4.326749f,6.349604f,8.549880f,10.902724f,13.390518f,16.000000f,18.720754f,21.544347f,24.463781f,27.473142f,30.567351f,33.741992f,36.993181f,40.317474f,43.711787f,47.173345f,50.699631f,54.288352f,57.937408f,61.644865f,65.408941f,69.227979f,73.100443f,77.024898f,81.000000f,85.024491f,89.097188f,93.216975f,97.382800f,101.593667f,105.848633f,110.146801f,114.487321f,118.869381f,123.292209f,127.755065f,132.257246f,136.798076f,141.376907f,145.993119f,150.646117f,155.335327f,160.060199f,164.820202f,169.614826f,174.443577f,179.305980f,184.201575f,189.129918f,194.090580f,199.083145f,204.107210f,209.162385f,214.248292f,219.364564f,224.510845f,229.686789f,234.892058f,240.126328f,245.389280f,250.680604f,256.000000f,261.347174f,266.721841f,272.123723f,277.552547f,283.008049f,288.489971f,293.998060f,299.532071f,305.091761f,310.676898f,316.287249f,321.922592f,327.582707f,333.267377f,338.976394f,344.709550f,350.466646f,356.247482f,362.051866f,367.879608f,373.730522f,379.604427f,385.501143f,391.420496f,397.362314f,403.326427f,409.312672f,415.320884f,421.350905f,427.402579f,433.475750f,439.570269f,445.685987f,451.822757f,457.980436f,464.158883f,470.357960f,476.577530f,482.817459f,489.077615f,495.357868f,501.658090f,507.978156f,514.317941f,520.677324f,527.056184f,533.454404f,539.871867f,546.308458f,552.764065f,559.238575f,565.731879f,572.243870f,578.774440f,585.323483f,591.890898f,598.476581f,605.080431f,611.702349f,618.342238f,625.000000f,631.675540f,638.368763f,645.079578f
+};
+static float ma_dr_mp3_L3_pow_43(int x)
+{
+    float frac;
+    int sign, mult = 256;
+    if (x < 129)
+    {
+        return g_ma_dr_mp3_pow43[16 + x];
+    }
+    if (x < 1024)
+    {
+        mult = 16;
+        x <<= 3;
+    }
+    sign = 2*x & 64;
+    frac = (float)((x & 63) - sign) / ((x & ~63) + sign);
+    return g_ma_dr_mp3_pow43[16 + ((x + sign) >> 6)]*(1.f + frac*((4.f/3) + frac*(2.f/9)))*mult;
+}
+static void ma_dr_mp3_L3_huffman(float *dst, ma_dr_mp3_bs *bs, const ma_dr_mp3_L3_gr_info *gr_info, const float *scf, int layer3gr_limit)
+{
+    static const ma_int16 tabs[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        785,785,785,785,784,784,784,784,513,513,513,513,513,513,513,513,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,
+        -255,1313,1298,1282,785,785,785,785,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,290,288,
+        -255,1313,1298,1282,769,769,769,769,529,529,529,529,529,529,529,529,528,528,528,528,528,528,528,528,512,512,512,512,512,512,512,512,290,288,
+        -253,-318,-351,-367,785,785,785,785,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,819,818,547,547,275,275,275,275,561,560,515,546,289,274,288,258,
+        -254,-287,1329,1299,1314,1312,1057,1057,1042,1042,1026,1026,784,784,784,784,529,529,529,529,529,529,529,529,769,769,769,769,768,768,768,768,563,560,306,306,291,259,
+        -252,-413,-477,-542,1298,-575,1041,1041,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-383,-399,1107,1092,1106,1061,849,849,789,789,1104,1091,773,773,1076,1075,341,340,325,309,834,804,577,577,532,532,516,516,832,818,803,816,561,561,531,531,515,546,289,289,288,258,
+        -252,-429,-493,-559,1057,1057,1042,1042,529,529,529,529,529,529,529,529,784,784,784,784,769,769,769,769,512,512,512,512,512,512,512,512,-382,1077,-415,1106,1061,1104,849,849,789,789,1091,1076,1029,1075,834,834,597,581,340,340,339,324,804,833,532,532,832,772,818,803,817,787,816,771,290,290,290,290,288,258,
+        -253,-349,-414,-447,-463,1329,1299,-479,1314,1312,1057,1057,1042,1042,1026,1026,785,785,785,785,784,784,784,784,769,769,769,769,768,768,768,768,-319,851,821,-335,836,850,805,849,341,340,325,336,533,533,579,579,564,564,773,832,578,548,563,516,321,276,306,291,304,259,
+        -251,-572,-733,-830,-863,-879,1041,1041,784,784,784,784,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-511,-527,-543,1396,1351,1381,1366,1395,1335,1380,-559,1334,1138,1138,1063,1063,1350,1392,1031,1031,1062,1062,1364,1363,1120,1120,1333,1348,881,881,881,881,375,374,359,373,343,358,341,325,791,791,1123,1122,-703,1105,1045,-719,865,865,790,790,774,774,1104,1029,338,293,323,308,-799,-815,833,788,772,818,803,816,322,292,307,320,561,531,515,546,289,274,288,258,
+        -251,-525,-605,-685,-765,-831,-846,1298,1057,1057,1312,1282,785,785,785,785,784,784,784,784,769,769,769,769,512,512,512,512,512,512,512,512,1399,1398,1383,1367,1382,1396,1351,-511,1381,1366,1139,1139,1079,1079,1124,1124,1364,1349,1363,1333,882,882,882,882,807,807,807,807,1094,1094,1136,1136,373,341,535,535,881,775,867,822,774,-591,324,338,-671,849,550,550,866,864,609,609,293,336,534,534,789,835,773,-751,834,804,308,307,833,788,832,772,562,562,547,547,305,275,560,515,290,290,
+        -252,-397,-477,-557,-622,-653,-719,-735,-750,1329,1299,1314,1057,1057,1042,1042,1312,1282,1024,1024,785,785,785,785,784,784,784,784,769,769,769,769,-383,1127,1141,1111,1126,1140,1095,1110,869,869,883,883,1079,1109,882,882,375,374,807,868,838,881,791,-463,867,822,368,263,852,837,836,-543,610,610,550,550,352,336,534,534,865,774,851,821,850,805,593,533,579,564,773,832,578,578,548,548,577,577,307,276,306,291,516,560,259,259,
+        -250,-2107,-2507,-2764,-2909,-2974,-3007,-3023,1041,1041,1040,1040,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-767,-1052,-1213,-1277,-1358,-1405,-1469,-1535,-1550,-1582,-1614,-1647,-1662,-1694,-1726,-1759,-1774,-1807,-1822,-1854,-1886,1565,-1919,-1935,-1951,-1967,1731,1730,1580,1717,-1983,1729,1564,-1999,1548,-2015,-2031,1715,1595,-2047,1714,-2063,1610,-2079,1609,-2095,1323,1323,1457,1457,1307,1307,1712,1547,1641,1700,1699,1594,1685,1625,1442,1442,1322,1322,-780,-973,-910,1279,1278,1277,1262,1276,1261,1275,1215,1260,1229,-959,974,974,989,989,-943,735,478,478,495,463,506,414,-1039,1003,958,1017,927,942,987,957,431,476,1272,1167,1228,-1183,1256,-1199,895,895,941,941,1242,1227,1212,1135,1014,1014,490,489,503,487,910,1013,985,925,863,894,970,955,1012,847,-1343,831,755,755,984,909,428,366,754,559,-1391,752,486,457,924,997,698,698,983,893,740,740,908,877,739,739,667,667,953,938,497,287,271,271,683,606,590,712,726,574,302,302,738,736,481,286,526,725,605,711,636,724,696,651,589,681,666,710,364,467,573,695,466,466,301,465,379,379,709,604,665,679,316,316,634,633,436,436,464,269,424,394,452,332,438,363,347,408,393,448,331,422,362,407,392,421,346,406,391,376,375,359,1441,1306,-2367,1290,-2383,1337,-2399,-2415,1426,1321,-2431,1411,1336,-2447,-2463,-2479,1169,1169,1049,1049,1424,1289,1412,1352,1319,-2495,1154,1154,1064,1064,1153,1153,416,390,360,404,403,389,344,374,373,343,358,372,327,357,342,311,356,326,1395,1394,1137,1137,1047,1047,1365,1392,1287,1379,1334,1364,1349,1378,1318,1363,792,792,792,792,1152,1152,1032,1032,1121,1121,1046,1046,1120,1120,1030,1030,-2895,1106,1061,1104,849,849,789,789,1091,1076,1029,1090,1060,1075,833,833,309,324,532,532,832,772,818,803,561,561,531,560,515,546,289,274,288,258,
+        -250,-1179,-1579,-1836,-1996,-2124,-2253,-2333,-2413,-2477,-2542,-2574,-2607,-2622,-2655,1314,1313,1298,1312,1282,785,785,785,785,1040,1040,1025,1025,768,768,768,768,-766,-798,-830,-862,-895,-911,-927,-943,-959,-975,-991,-1007,-1023,-1039,-1055,-1070,1724,1647,-1103,-1119,1631,1767,1662,1738,1708,1723,-1135,1780,1615,1779,1599,1677,1646,1778,1583,-1151,1777,1567,1737,1692,1765,1722,1707,1630,1751,1661,1764,1614,1736,1676,1763,1750,1645,1598,1721,1691,1762,1706,1582,1761,1566,-1167,1749,1629,767,766,751,765,494,494,735,764,719,749,734,763,447,447,748,718,477,506,431,491,446,476,461,505,415,430,475,445,504,399,460,489,414,503,383,474,429,459,502,502,746,752,488,398,501,473,413,472,486,271,480,270,-1439,-1455,1357,-1471,-1487,-1503,1341,1325,-1519,1489,1463,1403,1309,-1535,1372,1448,1418,1476,1356,1462,1387,-1551,1475,1340,1447,1402,1386,-1567,1068,1068,1474,1461,455,380,468,440,395,425,410,454,364,467,466,464,453,269,409,448,268,432,1371,1473,1432,1417,1308,1460,1355,1446,1459,1431,1083,1083,1401,1416,1458,1445,1067,1067,1370,1457,1051,1051,1291,1430,1385,1444,1354,1415,1400,1443,1082,1082,1173,1113,1186,1066,1185,1050,-1967,1158,1128,1172,1097,1171,1081,-1983,1157,1112,416,266,375,400,1170,1142,1127,1065,793,793,1169,1033,1156,1096,1141,1111,1155,1080,1126,1140,898,898,808,808,897,897,792,792,1095,1152,1032,1125,1110,1139,1079,1124,882,807,838,881,853,791,-2319,867,368,263,822,852,837,866,806,865,-2399,851,352,262,534,534,821,836,594,594,549,549,593,593,533,533,848,773,579,579,564,578,548,563,276,276,577,576,306,291,516,560,305,305,275,259,
+        -251,-892,-2058,-2620,-2828,-2957,-3023,-3039,1041,1041,1040,1040,769,769,769,769,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,256,-511,-527,-543,-559,1530,-575,-591,1528,1527,1407,1526,1391,1023,1023,1023,1023,1525,1375,1268,1268,1103,1103,1087,1087,1039,1039,1523,-604,815,815,815,815,510,495,509,479,508,463,507,447,431,505,415,399,-734,-782,1262,-815,1259,1244,-831,1258,1228,-847,-863,1196,-879,1253,987,987,748,-767,493,493,462,477,414,414,686,669,478,446,461,445,474,429,487,458,412,471,1266,1264,1009,1009,799,799,-1019,-1276,-1452,-1581,-1677,-1757,-1821,-1886,-1933,-1997,1257,1257,1483,1468,1512,1422,1497,1406,1467,1496,1421,1510,1134,1134,1225,1225,1466,1451,1374,1405,1252,1252,1358,1480,1164,1164,1251,1251,1238,1238,1389,1465,-1407,1054,1101,-1423,1207,-1439,830,830,1248,1038,1237,1117,1223,1148,1236,1208,411,426,395,410,379,269,1193,1222,1132,1235,1221,1116,976,976,1192,1162,1177,1220,1131,1191,963,963,-1647,961,780,-1663,558,558,994,993,437,408,393,407,829,978,813,797,947,-1743,721,721,377,392,844,950,828,890,706,706,812,859,796,960,948,843,934,874,571,571,-1919,690,555,689,421,346,539,539,944,779,918,873,932,842,903,888,570,570,931,917,674,674,-2575,1562,-2591,1609,-2607,1654,1322,1322,1441,1441,1696,1546,1683,1593,1669,1624,1426,1426,1321,1321,1639,1680,1425,1425,1305,1305,1545,1668,1608,1623,1667,1592,1638,1666,1320,1320,1652,1607,1409,1409,1304,1304,1288,1288,1664,1637,1395,1395,1335,1335,1622,1636,1394,1394,1319,1319,1606,1621,1392,1392,1137,1137,1137,1137,345,390,360,375,404,373,1047,-2751,-2767,-2783,1062,1121,1046,-2799,1077,-2815,1106,1061,789,789,1105,1104,263,355,310,340,325,354,352,262,339,324,1091,1076,1029,1090,1060,1075,833,833,788,788,1088,1028,818,818,803,803,561,561,531,531,816,771,546,546,289,274,288,258,
+        -253,-317,-381,-446,-478,-509,1279,1279,-811,-1179,-1451,-1756,-1900,-2028,-2189,-2253,-2333,-2414,-2445,-2511,-2526,1313,1298,-2559,1041,1041,1040,1040,1025,1025,1024,1024,1022,1007,1021,991,1020,975,1019,959,687,687,1018,1017,671,671,655,655,1016,1015,639,639,758,758,623,623,757,607,756,591,755,575,754,559,543,543,1009,783,-575,-621,-685,-749,496,-590,750,749,734,748,974,989,1003,958,988,973,1002,942,987,957,972,1001,926,986,941,971,956,1000,910,985,925,999,894,970,-1071,-1087,-1102,1390,-1135,1436,1509,1451,1374,-1151,1405,1358,1480,1420,-1167,1507,1494,1389,1342,1465,1435,1450,1326,1505,1310,1493,1373,1479,1404,1492,1464,1419,428,443,472,397,736,526,464,464,486,457,442,471,484,482,1357,1449,1434,1478,1388,1491,1341,1490,1325,1489,1463,1403,1309,1477,1372,1448,1418,1433,1476,1356,1462,1387,-1439,1475,1340,1447,1402,1474,1324,1461,1371,1473,269,448,1432,1417,1308,1460,-1711,1459,-1727,1441,1099,1099,1446,1386,1431,1401,-1743,1289,1083,1083,1160,1160,1458,1445,1067,1067,1370,1457,1307,1430,1129,1129,1098,1098,268,432,267,416,266,400,-1887,1144,1187,1082,1173,1113,1186,1066,1050,1158,1128,1143,1172,1097,1171,1081,420,391,1157,1112,1170,1142,1127,1065,1169,1049,1156,1096,1141,1111,1155,1080,1126,1154,1064,1153,1140,1095,1048,-2159,1125,1110,1137,-2175,823,823,1139,1138,807,807,384,264,368,263,868,838,853,791,867,822,852,837,866,806,865,790,-2319,851,821,836,352,262,850,805,849,-2399,533,533,835,820,336,261,578,548,563,577,532,532,832,772,562,562,547,547,305,275,560,515,290,290,288,258 };
+    static const ma_uint8 tab32[] = { 130,162,193,209,44,28,76,140,9,9,9,9,9,9,9,9,190,254,222,238,126,94,157,157,109,61,173,205};
+    static const ma_uint8 tab33[] = { 252,236,220,204,188,172,156,140,124,108,92,76,60,44,28,12 };
+    static const ma_int16 tabindex[2*16] = { 0,32,64,98,0,132,180,218,292,364,426,538,648,746,0,1126,1460,1460,1460,1460,1460,1460,1460,1460,1842,1842,1842,1842,1842,1842,1842,1842 };
+    static const ma_uint8 g_linbits[] =  { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,6,8,10,13,4,5,6,7,8,9,11,13 };
+#define MA_DR_MP3_PEEK_BITS(n)    (bs_cache >> (32 - (n)))
+#define MA_DR_MP3_FLUSH_BITS(n)   { bs_cache <<= (n); bs_sh += (n); }
+#define MA_DR_MP3_CHECK_BITS      while (bs_sh >= 0) { bs_cache |= (ma_uint32)*bs_next_ptr++ << bs_sh; bs_sh -= 8; }
+#define MA_DR_MP3_BSPOS           ((bs_next_ptr - bs->buf)*8 - 24 + bs_sh)
+    float one = 0.0f;
+    int ireg = 0, big_val_cnt = gr_info->big_values;
+    const ma_uint8 *sfb = gr_info->sfbtab;
+    const ma_uint8 *bs_next_ptr = bs->buf + bs->pos/8;
+    ma_uint32 bs_cache = (((bs_next_ptr[0]*256u + bs_next_ptr[1])*256u + bs_next_ptr[2])*256u + bs_next_ptr[3]) << (bs->pos & 7);
+    int pairs_to_decode, np, bs_sh = (bs->pos & 7) - 8;
+    bs_next_ptr += 4;
+    while (big_val_cnt > 0)
+    {
+        int tab_num = gr_info->table_select[ireg];
+        int sfb_cnt = gr_info->region_count[ireg++];
+        const ma_int16 *codebook = tabs + tabindex[tab_num];
+        int linbits = g_linbits[tab_num];
+        if (linbits)
+        {
+            do
+            {
+                np = *sfb++ / 2;
+                pairs_to_decode = MA_DR_MP3_MIN(big_val_cnt, np);
+                one = *scf++;
+                do
+                {
+                    int j, w = 5;
+                    int leaf = codebook[MA_DR_MP3_PEEK_BITS(w)];
+                    while (leaf < 0)
+                    {
+                        MA_DR_MP3_FLUSH_BITS(w);
+                        w = leaf & 7;
+                        leaf = codebook[MA_DR_MP3_PEEK_BITS(w) - (leaf >> 3)];
+                    }
+                    MA_DR_MP3_FLUSH_BITS(leaf >> 8);
+                    for (j = 0; j < 2; j++, dst++, leaf >>= 4)
+                    {
+                        int lsb = leaf & 0x0F;
+                        if (lsb == 15)
+                        {
+                            lsb += MA_DR_MP3_PEEK_BITS(linbits);
+                            MA_DR_MP3_FLUSH_BITS(linbits);
+                            MA_DR_MP3_CHECK_BITS;
+                            *dst = one*ma_dr_mp3_L3_pow_43(lsb)*((ma_int32)bs_cache < 0 ? -1: 1);
+                        } else
+                        {
+                            *dst = g_ma_dr_mp3_pow43[16 + lsb - 16*(bs_cache >> 31)]*one;
+                        }
+                        MA_DR_MP3_FLUSH_BITS(lsb ? 1 : 0);
+                    }
+                    MA_DR_MP3_CHECK_BITS;
+                } while (--pairs_to_decode);
+            } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
+        } else
+        {
+            do
+            {
+                np = *sfb++ / 2;
+                pairs_to_decode = MA_DR_MP3_MIN(big_val_cnt, np);
+                one = *scf++;
+                do
+                {
+                    int j, w = 5;
+                    int leaf = codebook[MA_DR_MP3_PEEK_BITS(w)];
+                    while (leaf < 0)
+                    {
+                        MA_DR_MP3_FLUSH_BITS(w);
+                        w = leaf & 7;
+                        leaf = codebook[MA_DR_MP3_PEEK_BITS(w) - (leaf >> 3)];
+                    }
+                    MA_DR_MP3_FLUSH_BITS(leaf >> 8);
+                    for (j = 0; j < 2; j++, dst++, leaf >>= 4)
+                    {
+                        int lsb = leaf & 0x0F;
+                        *dst = g_ma_dr_mp3_pow43[16 + lsb - 16*(bs_cache >> 31)]*one;
+                        MA_DR_MP3_FLUSH_BITS(lsb ? 1 : 0);
+                    }
+                    MA_DR_MP3_CHECK_BITS;
+                } while (--pairs_to_decode);
+            } while ((big_val_cnt -= np) > 0 && --sfb_cnt >= 0);
+        }
+    }
+    for (np = 1 - big_val_cnt;; dst += 4)
+    {
+        const ma_uint8 *codebook_count1 = (gr_info->count1_table) ? tab33 : tab32;
+        int leaf = codebook_count1[MA_DR_MP3_PEEK_BITS(4)];
+        if (!(leaf & 8))
+        {
+            leaf = codebook_count1[(leaf >> 3) + (bs_cache << 4 >> (32 - (leaf & 3)))];
+        }
+        MA_DR_MP3_FLUSH_BITS(leaf & 7);
+        if (MA_DR_MP3_BSPOS > layer3gr_limit)
+        {
+            break;
+        }
+#define MA_DR_MP3_RELOAD_SCALEFACTOR  if (!--np) { np = *sfb++/2; if (!np) break; one = *scf++; }
+#define MA_DR_MP3_DEQ_COUNT1(s) if (leaf & (128 >> s)) { dst[s] = ((ma_int32)bs_cache < 0) ? -one : one; MA_DR_MP3_FLUSH_BITS(1) }
+        MA_DR_MP3_RELOAD_SCALEFACTOR;
+        MA_DR_MP3_DEQ_COUNT1(0);
+        MA_DR_MP3_DEQ_COUNT1(1);
+        MA_DR_MP3_RELOAD_SCALEFACTOR;
+        MA_DR_MP3_DEQ_COUNT1(2);
+        MA_DR_MP3_DEQ_COUNT1(3);
+        MA_DR_MP3_CHECK_BITS;
+    }
+    bs->pos = layer3gr_limit;
+}
+static void ma_dr_mp3_L3_midside_stereo(float *left, int n)
+{
+    int i = 0;
+    float *right = left + 576;
+#if MA_DR_MP3_HAVE_SIMD
+    if (ma_dr_mp3_have_simd())
+    {
+        for (; i < n - 3; i += 4)
+        {
+            ma_dr_mp3_f4 vl = MA_DR_MP3_VLD(left + i);
+            ma_dr_mp3_f4 vr = MA_DR_MP3_VLD(right + i);
+            MA_DR_MP3_VSTORE(left + i, MA_DR_MP3_VADD(vl, vr));
+            MA_DR_MP3_VSTORE(right + i, MA_DR_MP3_VSUB(vl, vr));
+        }
+#ifdef __GNUC__
+        if (__builtin_constant_p(n % 4 == 0) && n % 4 == 0)
+            return;
+#endif
+    }
+#endif
+    for (; i < n; i++)
+    {
+        float a = left[i];
+        float b = right[i];
+        left[i] = a + b;
+        right[i] = a - b;
+    }
+}
+static void ma_dr_mp3_L3_intensity_stereo_band(float *left, int n, float kl, float kr)
+{
+    int i;
+    for (i = 0; i < n; i++)
+    {
+        left[i + 576] = left[i]*kr;
+        left[i] = left[i]*kl;
+    }
+}
+static void ma_dr_mp3_L3_stereo_top_band(const float *right, const ma_uint8 *sfb, int nbands, int max_band[3])
+{
+    int i, k;
+    max_band[0] = max_band[1] = max_band[2] = -1;
+    for (i = 0; i < nbands; i++)
+    {
+        for (k = 0; k < sfb[i]; k += 2)
+        {
+            if (right[k] != 0 || right[k + 1] != 0)
+            {
+                max_band[i % 3] = i;
+                break;
+            }
+        }
+        right += sfb[i];
+    }
+}
+static void ma_dr_mp3_L3_stereo_process(float *left, const ma_uint8 *ist_pos, const ma_uint8 *sfb, const ma_uint8 *hdr, int max_band[3], int mpeg2_sh)
+{
+    static const float g_pan[7*2] = { 0,1,0.21132487f,0.78867513f,0.36602540f,0.63397460f,0.5f,0.5f,0.63397460f,0.36602540f,0.78867513f,0.21132487f,1,0 };
+    unsigned i, max_pos = MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? 7 : 64;
+    for (i = 0; sfb[i]; i++)
+    {
+        unsigned ipos = ist_pos[i];
+        if ((int)i > max_band[i % 3] && ipos < max_pos)
+        {
+            float kl, kr, s = MA_DR_MP3_HDR_TEST_MS_STEREO(hdr) ? 1.41421356f : 1;
+            if (MA_DR_MP3_HDR_TEST_MPEG1(hdr))
+            {
+                kl = g_pan[2*ipos];
+                kr = g_pan[2*ipos + 1];
+            } else
+            {
+                kl = 1;
+                kr = ma_dr_mp3_L3_ldexp_q2(1, (ipos + 1) >> 1 << mpeg2_sh);
+                if (ipos & 1)
+                {
+                    kl = kr;
+                    kr = 1;
+                }
+            }
+            ma_dr_mp3_L3_intensity_stereo_band(left, sfb[i], kl*s, kr*s);
+        } else if (MA_DR_MP3_HDR_TEST_MS_STEREO(hdr))
+        {
+            ma_dr_mp3_L3_midside_stereo(left, sfb[i]);
+        }
+        left += sfb[i];
+    }
+}
+static void ma_dr_mp3_L3_intensity_stereo(float *left, ma_uint8 *ist_pos, const ma_dr_mp3_L3_gr_info *gr, const ma_uint8 *hdr)
+{
+    int max_band[3], n_sfb = gr->n_long_sfb + gr->n_short_sfb;
+    int i, max_blocks = gr->n_short_sfb ? 3 : 1;
+    ma_dr_mp3_L3_stereo_top_band(left + 576, gr->sfbtab, n_sfb, max_band);
+    if (gr->n_long_sfb)
+    {
+        max_band[0] = max_band[1] = max_band[2] = MA_DR_MP3_MAX(MA_DR_MP3_MAX(max_band[0], max_band[1]), max_band[2]);
+    }
+    for (i = 0; i < max_blocks; i++)
+    {
+        int default_pos = MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? 3 : 0;
+        int itop = n_sfb - max_blocks + i;
+        int prev = itop - max_blocks;
+        ist_pos[itop] = (ma_uint8)(max_band[i] >= prev ? default_pos : ist_pos[prev]);
+    }
+    ma_dr_mp3_L3_stereo_process(left, ist_pos, gr->sfbtab, hdr, max_band, gr[1].scalefac_compress & 1);
+}
+static void ma_dr_mp3_L3_reorder(float *grbuf, float *scratch, const ma_uint8 *sfb)
+{
+    int i, len;
+    float *src = grbuf, *dst = scratch;
+    for (;0 != (len = *sfb); sfb += 3, src += 2*len)
+    {
+        for (i = 0; i < len; i++, src++)
+        {
+            *dst++ = src[0*len];
+            *dst++ = src[1*len];
+            *dst++ = src[2*len];
+        }
+    }
+    MA_DR_MP3_COPY_MEMORY(grbuf, scratch, (dst - scratch)*sizeof(float));
+}
+static void ma_dr_mp3_L3_antialias(float *grbuf, int nbands)
+{
+    static const float g_aa[2][8] = {
+        {0.85749293f,0.88174200f,0.94962865f,0.98331459f,0.99551782f,0.99916056f,0.99989920f,0.99999316f},
+        {0.51449576f,0.47173197f,0.31337745f,0.18191320f,0.09457419f,0.04096558f,0.01419856f,0.00369997f}
+    };
+    for (; nbands > 0; nbands--, grbuf += 18)
+    {
+        int i = 0;
+#if MA_DR_MP3_HAVE_SIMD
+        if (ma_dr_mp3_have_simd()) for (; i < 8; i += 4)
+        {
+            ma_dr_mp3_f4 vu = MA_DR_MP3_VLD(grbuf + 18 + i);
+            ma_dr_mp3_f4 vd = MA_DR_MP3_VLD(grbuf + 14 - i);
+            ma_dr_mp3_f4 vc0 = MA_DR_MP3_VLD(g_aa[0] + i);
+            ma_dr_mp3_f4 vc1 = MA_DR_MP3_VLD(g_aa[1] + i);
+            vd = MA_DR_MP3_VREV(vd);
+            MA_DR_MP3_VSTORE(grbuf + 18 + i, MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vu, vc0), MA_DR_MP3_VMUL(vd, vc1)));
+            vd = MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vu, vc1), MA_DR_MP3_VMUL(vd, vc0));
+            MA_DR_MP3_VSTORE(grbuf + 14 - i, MA_DR_MP3_VREV(vd));
+        }
+#endif
+#ifndef MA_DR_MP3_ONLY_SIMD
+        for(; i < 8; i++)
+        {
+            float u = grbuf[18 + i];
+            float d = grbuf[17 - i];
+            grbuf[18 + i] = u*g_aa[0][i] - d*g_aa[1][i];
+            grbuf[17 - i] = u*g_aa[1][i] + d*g_aa[0][i];
+        }
+#endif
+    }
+}
+static void ma_dr_mp3_L3_dct3_9(float *y)
+{
+    float s0, s1, s2, s3, s4, s5, s6, s7, s8, t0, t2, t4;
+    s0 = y[0]; s2 = y[2]; s4 = y[4]; s6 = y[6]; s8 = y[8];
+    t0 = s0 + s6*0.5f;
+    s0 -= s6;
+    t4 = (s4 + s2)*0.93969262f;
+    t2 = (s8 + s2)*0.76604444f;
+    s6 = (s4 - s8)*0.17364818f;
+    s4 += s8 - s2;
+    s2 = s0 - s4*0.5f;
+    y[4] = s4 + s0;
+    s8 = t0 - t2 + s6;
+    s0 = t0 - t4 + t2;
+    s4 = t0 + t4 - s6;
+    s1 = y[1]; s3 = y[3]; s5 = y[5]; s7 = y[7];
+    s3 *= 0.86602540f;
+    t0 = (s5 + s1)*0.98480775f;
+    t4 = (s5 - s7)*0.34202014f;
+    t2 = (s1 + s7)*0.64278761f;
+    s1 = (s1 - s5 - s7)*0.86602540f;
+    s5 = t0 - s3 - t2;
+    s7 = t4 - s3 - t0;
+    s3 = t4 + s3 - t2;
+    y[0] = s4 - s7;
+    y[1] = s2 + s1;
+    y[2] = s0 - s3;
+    y[3] = s8 + s5;
+    y[5] = s8 - s5;
+    y[6] = s0 + s3;
+    y[7] = s2 - s1;
+    y[8] = s4 + s7;
+}
+static void ma_dr_mp3_L3_imdct36(float *grbuf, float *overlap, const float *window, int nbands)
+{
+    int i, j;
+    static const float g_twid9[18] = {
+        0.73727734f,0.79335334f,0.84339145f,0.88701083f,0.92387953f,0.95371695f,0.97629601f,0.99144486f,0.99904822f,0.67559021f,0.60876143f,0.53729961f,0.46174861f,0.38268343f,0.30070580f,0.21643961f,0.13052619f,0.04361938f
+    };
+    for (j = 0; j < nbands; j++, grbuf += 18, overlap += 9)
+    {
+        float co[9], si[9];
+        co[0] = -grbuf[0];
+        si[0] = grbuf[17];
+        for (i = 0; i < 4; i++)
+        {
+            si[8 - 2*i] =   grbuf[4*i + 1] - grbuf[4*i + 2];
+            co[1 + 2*i] =   grbuf[4*i + 1] + grbuf[4*i + 2];
+            si[7 - 2*i] =   grbuf[4*i + 4] - grbuf[4*i + 3];
+            co[2 + 2*i] = -(grbuf[4*i + 3] + grbuf[4*i + 4]);
+        }
+        ma_dr_mp3_L3_dct3_9(co);
+        ma_dr_mp3_L3_dct3_9(si);
+        si[1] = -si[1];
+        si[3] = -si[3];
+        si[5] = -si[5];
+        si[7] = -si[7];
+        i = 0;
+#if MA_DR_MP3_HAVE_SIMD
+        if (ma_dr_mp3_have_simd()) for (; i < 8; i += 4)
+        {
+            ma_dr_mp3_f4 vovl = MA_DR_MP3_VLD(overlap + i);
+            ma_dr_mp3_f4 vc = MA_DR_MP3_VLD(co + i);
+            ma_dr_mp3_f4 vs = MA_DR_MP3_VLD(si + i);
+            ma_dr_mp3_f4 vr0 = MA_DR_MP3_VLD(g_twid9 + i);
+            ma_dr_mp3_f4 vr1 = MA_DR_MP3_VLD(g_twid9 + 9 + i);
+            ma_dr_mp3_f4 vw0 = MA_DR_MP3_VLD(window + i);
+            ma_dr_mp3_f4 vw1 = MA_DR_MP3_VLD(window + 9 + i);
+            ma_dr_mp3_f4 vsum = MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vc, vr1), MA_DR_MP3_VMUL(vs, vr0));
+            MA_DR_MP3_VSTORE(overlap + i, MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vc, vr0), MA_DR_MP3_VMUL(vs, vr1)));
+            MA_DR_MP3_VSTORE(grbuf + i, MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vovl, vw0), MA_DR_MP3_VMUL(vsum, vw1)));
+            vsum = MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vovl, vw1), MA_DR_MP3_VMUL(vsum, vw0));
+            MA_DR_MP3_VSTORE(grbuf + 14 - i, MA_DR_MP3_VREV(vsum));
+        }
+#endif
+        for (; i < 9; i++)
+        {
+            float ovl  = overlap[i];
+            float sum  = co[i]*g_twid9[9 + i] + si[i]*g_twid9[0 + i];
+            overlap[i] = co[i]*g_twid9[0 + i] - si[i]*g_twid9[9 + i];
+            grbuf[i]      = ovl*window[0 + i] - sum*window[9 + i];
+            grbuf[17 - i] = ovl*window[9 + i] + sum*window[0 + i];
+        }
+    }
+}
+static void ma_dr_mp3_L3_idct3(float x0, float x1, float x2, float *dst)
+{
+    float m1 = x1*0.86602540f;
+    float a1 = x0 - x2*0.5f;
+    dst[1] = x0 + x2;
+    dst[0] = a1 + m1;
+    dst[2] = a1 - m1;
+}
+static void ma_dr_mp3_L3_imdct12(float *x, float *dst, float *overlap)
+{
+    static const float g_twid3[6] = { 0.79335334f,0.92387953f,0.99144486f, 0.60876143f,0.38268343f,0.13052619f };
+    float co[3], si[3];
+    int i;
+    ma_dr_mp3_L3_idct3(-x[0], x[6] + x[3], x[12] + x[9], co);
+    ma_dr_mp3_L3_idct3(x[15], x[12] - x[9], x[6] - x[3], si);
+    si[1] = -si[1];
+    for (i = 0; i < 3; i++)
+    {
+        float ovl  = overlap[i];
+        float sum  = co[i]*g_twid3[3 + i] + si[i]*g_twid3[0 + i];
+        overlap[i] = co[i]*g_twid3[0 + i] - si[i]*g_twid3[3 + i];
+        dst[i]     = ovl*g_twid3[2 - i] - sum*g_twid3[5 - i];
+        dst[5 - i] = ovl*g_twid3[5 - i] + sum*g_twid3[2 - i];
+    }
+}
+static void ma_dr_mp3_L3_imdct_short(float *grbuf, float *overlap, int nbands)
+{
+    for (;nbands > 0; nbands--, overlap += 9, grbuf += 18)
+    {
+        float tmp[18];
+        MA_DR_MP3_COPY_MEMORY(tmp, grbuf, sizeof(tmp));
+        MA_DR_MP3_COPY_MEMORY(grbuf, overlap, 6*sizeof(float));
+        ma_dr_mp3_L3_imdct12(tmp, grbuf + 6, overlap + 6);
+        ma_dr_mp3_L3_imdct12(tmp + 1, grbuf + 12, overlap + 6);
+        ma_dr_mp3_L3_imdct12(tmp + 2, overlap, overlap + 6);
+    }
+}
+static void ma_dr_mp3_L3_change_sign(float *grbuf)
+{
+    int b, i;
+    for (b = 0, grbuf += 18; b < 32; b += 2, grbuf += 36)
+        for (i = 1; i < 18; i += 2)
+            grbuf[i] = -grbuf[i];
+}
+static void ma_dr_mp3_L3_imdct_gr(float *grbuf, float *overlap, unsigned block_type, unsigned n_long_bands)
+{
+    static const float g_mdct_window[2][18] = {
+        { 0.99904822f,0.99144486f,0.97629601f,0.95371695f,0.92387953f,0.88701083f,0.84339145f,0.79335334f,0.73727734f,0.04361938f,0.13052619f,0.21643961f,0.30070580f,0.38268343f,0.46174861f,0.53729961f,0.60876143f,0.67559021f },
+        { 1,1,1,1,1,1,0.99144486f,0.92387953f,0.79335334f,0,0,0,0,0,0,0.13052619f,0.38268343f,0.60876143f }
+    };
+    if (n_long_bands)
+    {
+        ma_dr_mp3_L3_imdct36(grbuf, overlap, g_mdct_window[0], n_long_bands);
+        grbuf += 18*n_long_bands;
+        overlap += 9*n_long_bands;
+    }
+    if (block_type == MA_DR_MP3_SHORT_BLOCK_TYPE)
+        ma_dr_mp3_L3_imdct_short(grbuf, overlap, 32 - n_long_bands);
+    else
+        ma_dr_mp3_L3_imdct36(grbuf, overlap, g_mdct_window[block_type == MA_DR_MP3_STOP_BLOCK_TYPE], 32 - n_long_bands);
+}
+static void ma_dr_mp3_L3_save_reservoir(ma_dr_mp3dec *h, ma_dr_mp3dec_scratch *s)
+{
+    int pos = (s->bs.pos + 7)/8u;
+    int remains = s->bs.limit/8u - pos;
+    if (remains > MA_DR_MP3_MAX_BITRESERVOIR_BYTES)
+    {
+        pos += remains - MA_DR_MP3_MAX_BITRESERVOIR_BYTES;
+        remains = MA_DR_MP3_MAX_BITRESERVOIR_BYTES;
+    }
+    if (remains > 0)
+    {
+        MA_DR_MP3_MOVE_MEMORY(h->reserv_buf, s->maindata + pos, remains);
+    }
+    h->reserv = remains;
+}
+static int ma_dr_mp3_L3_restore_reservoir(ma_dr_mp3dec *h, ma_dr_mp3_bs *bs, ma_dr_mp3dec_scratch *s, int main_data_begin)
+{
+    int frame_bytes = (bs->limit - bs->pos)/8;
+    int bytes_have = MA_DR_MP3_MIN(h->reserv, main_data_begin);
+    MA_DR_MP3_COPY_MEMORY(s->maindata, h->reserv_buf + MA_DR_MP3_MAX(0, h->reserv - main_data_begin), MA_DR_MP3_MIN(h->reserv, main_data_begin));
+    MA_DR_MP3_COPY_MEMORY(s->maindata + bytes_have, bs->buf + bs->pos/8, frame_bytes);
+    ma_dr_mp3_bs_init(&s->bs, s->maindata, bytes_have + frame_bytes);
+    return h->reserv >= main_data_begin;
+}
+static void ma_dr_mp3_L3_decode(ma_dr_mp3dec *h, ma_dr_mp3dec_scratch *s, ma_dr_mp3_L3_gr_info *gr_info, int nch)
+{
+    int ch;
+    for (ch = 0; ch < nch; ch++)
+    {
+        int layer3gr_limit = s->bs.pos + gr_info[ch].part_23_length;
+        ma_dr_mp3_L3_decode_scalefactors(h->header, s->ist_pos[ch], &s->bs, gr_info + ch, s->scf, ch);
+        ma_dr_mp3_L3_huffman(s->grbuf[ch], &s->bs, gr_info + ch, s->scf, layer3gr_limit);
+    }
+    if (MA_DR_MP3_HDR_TEST_I_STEREO(h->header))
+    {
+        ma_dr_mp3_L3_intensity_stereo(s->grbuf[0], s->ist_pos[1], gr_info, h->header);
+    } else if (MA_DR_MP3_HDR_IS_MS_STEREO(h->header))
+    {
+        ma_dr_mp3_L3_midside_stereo(s->grbuf[0], 576);
+    }
+    for (ch = 0; ch < nch; ch++, gr_info++)
+    {
+        int aa_bands = 31;
+        int n_long_bands = (gr_info->mixed_block_flag ? 2 : 0) << (int)(MA_DR_MP3_HDR_GET_MY_SAMPLE_RATE(h->header) == 2);
+        if (gr_info->n_short_sfb)
+        {
+            aa_bands = n_long_bands - 1;
+            ma_dr_mp3_L3_reorder(s->grbuf[ch] + n_long_bands*18, s->syn[0], gr_info->sfbtab + gr_info->n_long_sfb);
+        }
+        ma_dr_mp3_L3_antialias(s->grbuf[ch], aa_bands);
+        ma_dr_mp3_L3_imdct_gr(s->grbuf[ch], h->mdct_overlap[ch], gr_info->block_type, n_long_bands);
+        ma_dr_mp3_L3_change_sign(s->grbuf[ch]);
+    }
+}
+static void ma_dr_mp3d_DCT_II(float *grbuf, int n)
+{
+    static const float g_sec[24] = {
+        10.19000816f,0.50060302f,0.50241929f,3.40760851f,0.50547093f,0.52249861f,2.05778098f,0.51544732f,0.56694406f,1.48416460f,0.53104258f,0.64682180f,1.16943991f,0.55310392f,0.78815460f,0.97256821f,0.58293498f,1.06067765f,0.83934963f,0.62250412f,1.72244716f,0.74453628f,0.67480832f,5.10114861f
+    };
+    int i, k = 0;
+#if MA_DR_MP3_HAVE_SIMD
+    if (ma_dr_mp3_have_simd()) for (; k < n; k += 4)
+    {
+        ma_dr_mp3_f4 t[4][8], *x;
+        float *y = grbuf + k;
+        for (x = t[0], i = 0; i < 8; i++, x++)
+        {
+            ma_dr_mp3_f4 x0 = MA_DR_MP3_VLD(&y[i*18]);
+            ma_dr_mp3_f4 x1 = MA_DR_MP3_VLD(&y[(15 - i)*18]);
+            ma_dr_mp3_f4 x2 = MA_DR_MP3_VLD(&y[(16 + i)*18]);
+            ma_dr_mp3_f4 x3 = MA_DR_MP3_VLD(&y[(31 - i)*18]);
+            ma_dr_mp3_f4 t0 = MA_DR_MP3_VADD(x0, x3);
+            ma_dr_mp3_f4 t1 = MA_DR_MP3_VADD(x1, x2);
+            ma_dr_mp3_f4 t2 = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(x1, x2), g_sec[3*i + 0]);
+            ma_dr_mp3_f4 t3 = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(x0, x3), g_sec[3*i + 1]);
+            x[0] = MA_DR_MP3_VADD(t0, t1);
+            x[8] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(t0, t1), g_sec[3*i + 2]);
+            x[16] = MA_DR_MP3_VADD(t3, t2);
+            x[24] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(t3, t2), g_sec[3*i + 2]);
+        }
+        for (x = t[0], i = 0; i < 4; i++, x += 8)
+        {
+            ma_dr_mp3_f4 x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4], x5 = x[5], x6 = x[6], x7 = x[7], xt;
+            xt = MA_DR_MP3_VSUB(x0, x7); x0 = MA_DR_MP3_VADD(x0, x7);
+            x7 = MA_DR_MP3_VSUB(x1, x6); x1 = MA_DR_MP3_VADD(x1, x6);
+            x6 = MA_DR_MP3_VSUB(x2, x5); x2 = MA_DR_MP3_VADD(x2, x5);
+            x5 = MA_DR_MP3_VSUB(x3, x4); x3 = MA_DR_MP3_VADD(x3, x4);
+            x4 = MA_DR_MP3_VSUB(x0, x3); x0 = MA_DR_MP3_VADD(x0, x3);
+            x3 = MA_DR_MP3_VSUB(x1, x2); x1 = MA_DR_MP3_VADD(x1, x2);
+            x[0] = MA_DR_MP3_VADD(x0, x1);
+            x[4] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(x0, x1), 0.70710677f);
+            x5 = MA_DR_MP3_VADD(x5, x6);
+            x6 = MA_DR_MP3_VMUL_S(MA_DR_MP3_VADD(x6, x7), 0.70710677f);
+            x7 = MA_DR_MP3_VADD(x7, xt);
+            x3 = MA_DR_MP3_VMUL_S(MA_DR_MP3_VADD(x3, x4), 0.70710677f);
+            x5 = MA_DR_MP3_VSUB(x5, MA_DR_MP3_VMUL_S(x7, 0.198912367f));
+            x7 = MA_DR_MP3_VADD(x7, MA_DR_MP3_VMUL_S(x5, 0.382683432f));
+            x5 = MA_DR_MP3_VSUB(x5, MA_DR_MP3_VMUL_S(x7, 0.198912367f));
+            x0 = MA_DR_MP3_VSUB(xt, x6); xt = MA_DR_MP3_VADD(xt, x6);
+            x[1] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VADD(xt, x7), 0.50979561f);
+            x[2] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VADD(x4, x3), 0.54119611f);
+            x[3] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(x0, x5), 0.60134488f);
+            x[5] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VADD(x0, x5), 0.89997619f);
+            x[6] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(x4, x3), 1.30656302f);
+            x[7] = MA_DR_MP3_VMUL_S(MA_DR_MP3_VSUB(xt, x7), 2.56291556f);
+        }
+        if (k > n - 3)
+        {
+#if MA_DR_MP3_HAVE_SSE
+#define MA_DR_MP3_VSAVE2(i, v) _mm_storel_pi((__m64 *)(void*)&y[i*18], v)
+#else
+#define MA_DR_MP3_VSAVE2(i, v) vst1_f32((float32_t *)&y[(i)*18],  vget_low_f32(v))
+#endif
+            for (i = 0; i < 7; i++, y += 4*18)
+            {
+                ma_dr_mp3_f4 s = MA_DR_MP3_VADD(t[3][i], t[3][i + 1]);
+                MA_DR_MP3_VSAVE2(0, t[0][i]);
+                MA_DR_MP3_VSAVE2(1, MA_DR_MP3_VADD(t[2][i], s));
+                MA_DR_MP3_VSAVE2(2, MA_DR_MP3_VADD(t[1][i], t[1][i + 1]));
+                MA_DR_MP3_VSAVE2(3, MA_DR_MP3_VADD(t[2][1 + i], s));
+            }
+            MA_DR_MP3_VSAVE2(0, t[0][7]);
+            MA_DR_MP3_VSAVE2(1, MA_DR_MP3_VADD(t[2][7], t[3][7]));
+            MA_DR_MP3_VSAVE2(2, t[1][7]);
+            MA_DR_MP3_VSAVE2(3, t[3][7]);
+        } else
+        {
+#define MA_DR_MP3_VSAVE4(i, v) MA_DR_MP3_VSTORE(&y[(i)*18], v)
+            for (i = 0; i < 7; i++, y += 4*18)
+            {
+                ma_dr_mp3_f4 s = MA_DR_MP3_VADD(t[3][i], t[3][i + 1]);
+                MA_DR_MP3_VSAVE4(0, t[0][i]);
+                MA_DR_MP3_VSAVE4(1, MA_DR_MP3_VADD(t[2][i], s));
+                MA_DR_MP3_VSAVE4(2, MA_DR_MP3_VADD(t[1][i], t[1][i + 1]));
+                MA_DR_MP3_VSAVE4(3, MA_DR_MP3_VADD(t[2][1 + i], s));
+            }
+            MA_DR_MP3_VSAVE4(0, t[0][7]);
+            MA_DR_MP3_VSAVE4(1, MA_DR_MP3_VADD(t[2][7], t[3][7]));
+            MA_DR_MP3_VSAVE4(2, t[1][7]);
+            MA_DR_MP3_VSAVE4(3, t[3][7]);
+        }
+    } else
+#endif
+#ifdef MA_DR_MP3_ONLY_SIMD
+    {}
+#else
+    for (; k < n; k++)
+    {
+        float t[4][8], *x, *y = grbuf + k;
+        for (x = t[0], i = 0; i < 8; i++, x++)
+        {
+            float x0 = y[i*18];
+            float x1 = y[(15 - i)*18];
+            float x2 = y[(16 + i)*18];
+            float x3 = y[(31 - i)*18];
+            float t0 = x0 + x3;
+            float t1 = x1 + x2;
+            float t2 = (x1 - x2)*g_sec[3*i + 0];
+            float t3 = (x0 - x3)*g_sec[3*i + 1];
+            x[0] = t0 + t1;
+            x[8] = (t0 - t1)*g_sec[3*i + 2];
+            x[16] = t3 + t2;
+            x[24] = (t3 - t2)*g_sec[3*i + 2];
+        }
+        for (x = t[0], i = 0; i < 4; i++, x += 8)
+        {
+            float x0 = x[0], x1 = x[1], x2 = x[2], x3 = x[3], x4 = x[4], x5 = x[5], x6 = x[6], x7 = x[7], xt;
+            xt = x0 - x7; x0 += x7;
+            x7 = x1 - x6; x1 += x6;
+            x6 = x2 - x5; x2 += x5;
+            x5 = x3 - x4; x3 += x4;
+            x4 = x0 - x3; x0 += x3;
+            x3 = x1 - x2; x1 += x2;
+            x[0] = x0 + x1;
+            x[4] = (x0 - x1)*0.70710677f;
+            x5 =  x5 + x6;
+            x6 = (x6 + x7)*0.70710677f;
+            x7 =  x7 + xt;
+            x3 = (x3 + x4)*0.70710677f;
+            x5 -= x7*0.198912367f;
+            x7 += x5*0.382683432f;
+            x5 -= x7*0.198912367f;
+            x0 = xt - x6; xt += x6;
+            x[1] = (xt + x7)*0.50979561f;
+            x[2] = (x4 + x3)*0.54119611f;
+            x[3] = (x0 - x5)*0.60134488f;
+            x[5] = (x0 + x5)*0.89997619f;
+            x[6] = (x4 - x3)*1.30656302f;
+            x[7] = (xt - x7)*2.56291556f;
+        }
+        for (i = 0; i < 7; i++, y += 4*18)
+        {
+            y[0*18] = t[0][i];
+            y[1*18] = t[2][i] + t[3][i] + t[3][i + 1];
+            y[2*18] = t[1][i] + t[1][i + 1];
+            y[3*18] = t[2][i + 1] + t[3][i] + t[3][i + 1];
+        }
+        y[0*18] = t[0][7];
+        y[1*18] = t[2][7] + t[3][7];
+        y[2*18] = t[1][7];
+        y[3*18] = t[3][7];
+    }
+#endif
+}
+#ifndef MA_DR_MP3_FLOAT_OUTPUT
+typedef ma_int16 ma_dr_mp3d_sample_t;
+static ma_int16 ma_dr_mp3d_scale_pcm(float sample)
+{
+    ma_int16 s;
+#if MA_DR_MP3_HAVE_ARMV6
+    ma_int32 s32 = (ma_int32)(sample + .5f);
+    s32 -= (s32 < 0);
+    s = (ma_int16)ma_dr_mp3_clip_int16_arm(s32);
+#else
+    if (sample >=  32766.5) return (ma_int16) 32767;
+    if (sample <= -32767.5) return (ma_int16)-32768;
+    s = (ma_int16)(sample + .5f);
+    s -= (s < 0);
+#endif
+    return s;
+}
+#else
+typedef float ma_dr_mp3d_sample_t;
+static float ma_dr_mp3d_scale_pcm(float sample)
+{
+    return sample*(1.f/32768.f);
+}
+#endif
+static void ma_dr_mp3d_synth_pair(ma_dr_mp3d_sample_t *pcm, int nch, const float *z)
+{
+    float a;
+    a  = (z[14*64] - z[    0]) * 29;
+    a += (z[ 1*64] + z[13*64]) * 213;
+    a += (z[12*64] - z[ 2*64]) * 459;
+    a += (z[ 3*64] + z[11*64]) * 2037;
+    a += (z[10*64] - z[ 4*64]) * 5153;
+    a += (z[ 5*64] + z[ 9*64]) * 6574;
+    a += (z[ 8*64] - z[ 6*64]) * 37489;
+    a +=  z[ 7*64]             * 75038;
+    pcm[0] = ma_dr_mp3d_scale_pcm(a);
+    z += 2;
+    a  = z[14*64] * 104;
+    a += z[12*64] * 1567;
+    a += z[10*64] * 9727;
+    a += z[ 8*64] * 64019;
+    a += z[ 6*64] * -9975;
+    a += z[ 4*64] * -45;
+    a += z[ 2*64] * 146;
+    a += z[ 0*64] * -5;
+    pcm[16*nch] = ma_dr_mp3d_scale_pcm(a);
+}
+static void ma_dr_mp3d_synth(float *xl, ma_dr_mp3d_sample_t *dstl, int nch, float *lins)
+{
+    int i;
+    float *xr = xl + 576*(nch - 1);
+    ma_dr_mp3d_sample_t *dstr = dstl + (nch - 1);
+    static const float g_win[] = {
+        -1,26,-31,208,218,401,-519,2063,2000,4788,-5517,7134,5959,35640,-39336,74992,
+        -1,24,-35,202,222,347,-581,2080,1952,4425,-5879,7640,5288,33791,-41176,74856,
+        -1,21,-38,196,225,294,-645,2087,1893,4063,-6237,8092,4561,31947,-43006,74630,
+        -1,19,-41,190,227,244,-711,2085,1822,3705,-6589,8492,3776,30112,-44821,74313,
+        -1,17,-45,183,228,197,-779,2075,1739,3351,-6935,8840,2935,28289,-46617,73908,
+        -1,16,-49,176,228,153,-848,2057,1644,3004,-7271,9139,2037,26482,-48390,73415,
+        -2,14,-53,169,227,111,-919,2032,1535,2663,-7597,9389,1082,24694,-50137,72835,
+        -2,13,-58,161,224,72,-991,2001,1414,2330,-7910,9592,70,22929,-51853,72169,
+        -2,11,-63,154,221,36,-1064,1962,1280,2006,-8209,9750,-998,21189,-53534,71420,
+        -2,10,-68,147,215,2,-1137,1919,1131,1692,-8491,9863,-2122,19478,-55178,70590,
+        -3,9,-73,139,208,-29,-1210,1870,970,1388,-8755,9935,-3300,17799,-56778,69679,
+        -3,8,-79,132,200,-57,-1283,1817,794,1095,-8998,9966,-4533,16155,-58333,68692,
+        -4,7,-85,125,189,-83,-1356,1759,605,814,-9219,9959,-5818,14548,-59838,67629,
+        -4,7,-91,117,177,-106,-1428,1698,402,545,-9416,9916,-7154,12980,-61289,66494,
+        -5,6,-97,111,163,-127,-1498,1634,185,288,-9585,9838,-8540,11455,-62684,65290
+    };
+    float *zlin = lins + 15*64;
+    const float *w = g_win;
+    zlin[4*15]     = xl[18*16];
+    zlin[4*15 + 1] = xr[18*16];
+    zlin[4*15 + 2] = xl[0];
+    zlin[4*15 + 3] = xr[0];
+    zlin[4*31]     = xl[1 + 18*16];
+    zlin[4*31 + 1] = xr[1 + 18*16];
+    zlin[4*31 + 2] = xl[1];
+    zlin[4*31 + 3] = xr[1];
+    ma_dr_mp3d_synth_pair(dstr, nch, lins + 4*15 + 1);
+    ma_dr_mp3d_synth_pair(dstr + 32*nch, nch, lins + 4*15 + 64 + 1);
+    ma_dr_mp3d_synth_pair(dstl, nch, lins + 4*15);
+    ma_dr_mp3d_synth_pair(dstl + 32*nch, nch, lins + 4*15 + 64);
+#if MA_DR_MP3_HAVE_SIMD
+    if (ma_dr_mp3_have_simd()) for (i = 14; i >= 0; i--)
+    {
+#define MA_DR_MP3_VLOAD(k) ma_dr_mp3_f4 w0 = MA_DR_MP3_VSET(*w++); ma_dr_mp3_f4 w1 = MA_DR_MP3_VSET(*w++); ma_dr_mp3_f4 vz = MA_DR_MP3_VLD(&zlin[4*i - 64*k]); ma_dr_mp3_f4 vy = MA_DR_MP3_VLD(&zlin[4*i - 64*(15 - k)]);
+#define MA_DR_MP3_V0(k) { MA_DR_MP3_VLOAD(k) b =               MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vz, w1), MA_DR_MP3_VMUL(vy, w0)) ; a =               MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vz, w0), MA_DR_MP3_VMUL(vy, w1));  }
+#define MA_DR_MP3_V1(k) { MA_DR_MP3_VLOAD(k) b = MA_DR_MP3_VADD(b, MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vz, w1), MA_DR_MP3_VMUL(vy, w0))); a = MA_DR_MP3_VADD(a, MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vz, w0), MA_DR_MP3_VMUL(vy, w1))); }
+#define MA_DR_MP3_V2(k) { MA_DR_MP3_VLOAD(k) b = MA_DR_MP3_VADD(b, MA_DR_MP3_VADD(MA_DR_MP3_VMUL(vz, w1), MA_DR_MP3_VMUL(vy, w0))); a = MA_DR_MP3_VADD(a, MA_DR_MP3_VSUB(MA_DR_MP3_VMUL(vy, w1), MA_DR_MP3_VMUL(vz, w0))); }
+        ma_dr_mp3_f4 a, b;
+        zlin[4*i]     = xl[18*(31 - i)];
+        zlin[4*i + 1] = xr[18*(31 - i)];
+        zlin[4*i + 2] = xl[1 + 18*(31 - i)];
+        zlin[4*i + 3] = xr[1 + 18*(31 - i)];
+        zlin[4*i + 64] = xl[1 + 18*(1 + i)];
+        zlin[4*i + 64 + 1] = xr[1 + 18*(1 + i)];
+        zlin[4*i - 64 + 2] = xl[18*(1 + i)];
+        zlin[4*i - 64 + 3] = xr[18*(1 + i)];
+        MA_DR_MP3_V0(0) MA_DR_MP3_V2(1) MA_DR_MP3_V1(2) MA_DR_MP3_V2(3) MA_DR_MP3_V1(4) MA_DR_MP3_V2(5) MA_DR_MP3_V1(6) MA_DR_MP3_V2(7)
+        {
+#ifndef MA_DR_MP3_FLOAT_OUTPUT
+#if MA_DR_MP3_HAVE_SSE
+            static const ma_dr_mp3_f4 g_max = { 32767.0f, 32767.0f, 32767.0f, 32767.0f };
+            static const ma_dr_mp3_f4 g_min = { -32768.0f, -32768.0f, -32768.0f, -32768.0f };
+            __m128i pcm8 = _mm_packs_epi32(_mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(a, g_max), g_min)),
+                                           _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(b, g_max), g_min)));
+            dstr[(15 - i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 1);
+            dstr[(17 + i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 5);
+            dstl[(15 - i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 0);
+            dstl[(17 + i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 4);
+            dstr[(47 - i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 3);
+            dstr[(49 + i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 7);
+            dstl[(47 - i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 2);
+            dstl[(49 + i)*nch] = (ma_int16)_mm_extract_epi16(pcm8, 6);
+#else
+            int16x4_t pcma, pcmb;
+            a = MA_DR_MP3_VADD(a, MA_DR_MP3_VSET(0.5f));
+            b = MA_DR_MP3_VADD(b, MA_DR_MP3_VSET(0.5f));
+            pcma = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(a), vreinterpretq_s32_u32(vcltq_f32(a, MA_DR_MP3_VSET(0)))));
+            pcmb = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(b), vreinterpretq_s32_u32(vcltq_f32(b, MA_DR_MP3_VSET(0)))));
+            vst1_lane_s16(dstr + (15 - i)*nch, pcma, 1);
+            vst1_lane_s16(dstr + (17 + i)*nch, pcmb, 1);
+            vst1_lane_s16(dstl + (15 - i)*nch, pcma, 0);
+            vst1_lane_s16(dstl + (17 + i)*nch, pcmb, 0);
+            vst1_lane_s16(dstr + (47 - i)*nch, pcma, 3);
+            vst1_lane_s16(dstr + (49 + i)*nch, pcmb, 3);
+            vst1_lane_s16(dstl + (47 - i)*nch, pcma, 2);
+            vst1_lane_s16(dstl + (49 + i)*nch, pcmb, 2);
+#endif
+#else
+        #if MA_DR_MP3_HAVE_SSE
+            static const ma_dr_mp3_f4 g_scale = { 1.0f/32768.0f, 1.0f/32768.0f, 1.0f/32768.0f, 1.0f/32768.0f };
+        #else
+            const ma_dr_mp3_f4 g_scale = vdupq_n_f32(1.0f/32768.0f);
+        #endif
+            a = MA_DR_MP3_VMUL(a, g_scale);
+            b = MA_DR_MP3_VMUL(b, g_scale);
+#if MA_DR_MP3_HAVE_SSE
+            _mm_store_ss(dstr + (15 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(1, 1, 1, 1)));
+            _mm_store_ss(dstr + (17 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(1, 1, 1, 1)));
+            _mm_store_ss(dstl + (15 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(0, 0, 0, 0)));
+            _mm_store_ss(dstl + (17 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(0, 0, 0, 0)));
+            _mm_store_ss(dstr + (47 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(3, 3, 3, 3)));
+            _mm_store_ss(dstr + (49 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(3, 3, 3, 3)));
+            _mm_store_ss(dstl + (47 - i)*nch, _mm_shuffle_ps(a, a, _MM_SHUFFLE(2, 2, 2, 2)));
+            _mm_store_ss(dstl + (49 + i)*nch, _mm_shuffle_ps(b, b, _MM_SHUFFLE(2, 2, 2, 2)));
+#else
+            vst1q_lane_f32(dstr + (15 - i)*nch, a, 1);
+            vst1q_lane_f32(dstr + (17 + i)*nch, b, 1);
+            vst1q_lane_f32(dstl + (15 - i)*nch, a, 0);
+            vst1q_lane_f32(dstl + (17 + i)*nch, b, 0);
+            vst1q_lane_f32(dstr + (47 - i)*nch, a, 3);
+            vst1q_lane_f32(dstr + (49 + i)*nch, b, 3);
+            vst1q_lane_f32(dstl + (47 - i)*nch, a, 2);
+            vst1q_lane_f32(dstl + (49 + i)*nch, b, 2);
+#endif
+#endif
+        }
+    } else
+#endif
+#ifdef MA_DR_MP3_ONLY_SIMD
+    {}
+#else
+    for (i = 14; i >= 0; i--)
+    {
+#define MA_DR_MP3_LOAD(k) float w0 = *w++; float w1 = *w++; float *vz = &zlin[4*i - k*64]; float *vy = &zlin[4*i - (15 - k)*64];
+#define MA_DR_MP3_S0(k) { int j; MA_DR_MP3_LOAD(k); for (j = 0; j < 4; j++) b[j]  = vz[j]*w1 + vy[j]*w0, a[j]  = vz[j]*w0 - vy[j]*w1; }
+#define MA_DR_MP3_S1(k) { int j; MA_DR_MP3_LOAD(k); for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vz[j]*w0 - vy[j]*w1; }
+#define MA_DR_MP3_S2(k) { int j; MA_DR_MP3_LOAD(k); for (j = 0; j < 4; j++) b[j] += vz[j]*w1 + vy[j]*w0, a[j] += vy[j]*w1 - vz[j]*w0; }
+        float a[4], b[4];
+        zlin[4*i]     = xl[18*(31 - i)];
+        zlin[4*i + 1] = xr[18*(31 - i)];
+        zlin[4*i + 2] = xl[1 + 18*(31 - i)];
+        zlin[4*i + 3] = xr[1 + 18*(31 - i)];
+        zlin[4*(i + 16)]   = xl[1 + 18*(1 + i)];
+        zlin[4*(i + 16) + 1] = xr[1 + 18*(1 + i)];
+        zlin[4*(i - 16) + 2] = xl[18*(1 + i)];
+        zlin[4*(i - 16) + 3] = xr[18*(1 + i)];
+        MA_DR_MP3_S0(0) MA_DR_MP3_S2(1) MA_DR_MP3_S1(2) MA_DR_MP3_S2(3) MA_DR_MP3_S1(4) MA_DR_MP3_S2(5) MA_DR_MP3_S1(6) MA_DR_MP3_S2(7)
+        dstr[(15 - i)*nch] = ma_dr_mp3d_scale_pcm(a[1]);
+        dstr[(17 + i)*nch] = ma_dr_mp3d_scale_pcm(b[1]);
+        dstl[(15 - i)*nch] = ma_dr_mp3d_scale_pcm(a[0]);
+        dstl[(17 + i)*nch] = ma_dr_mp3d_scale_pcm(b[0]);
+        dstr[(47 - i)*nch] = ma_dr_mp3d_scale_pcm(a[3]);
+        dstr[(49 + i)*nch] = ma_dr_mp3d_scale_pcm(b[3]);
+        dstl[(47 - i)*nch] = ma_dr_mp3d_scale_pcm(a[2]);
+        dstl[(49 + i)*nch] = ma_dr_mp3d_scale_pcm(b[2]);
+    }
+#endif
+}
+static void ma_dr_mp3d_synth_granule(float *qmf_state, float *grbuf, int nbands, int nch, ma_dr_mp3d_sample_t *pcm, float *lins)
+{
+    int i;
+    for (i = 0; i < nch; i++)
+    {
+        ma_dr_mp3d_DCT_II(grbuf + 576*i, nbands);
+    }
+    MA_DR_MP3_COPY_MEMORY(lins, qmf_state, sizeof(float)*15*64);
+    for (i = 0; i < nbands; i += 2)
+    {
+        ma_dr_mp3d_synth(grbuf + i, pcm + 32*nch*i, nch, lins + i*64);
+    }
+#ifndef MA_DR_MP3_NONSTANDARD_BUT_LOGICAL
+    if (nch == 1)
+    {
+        for (i = 0; i < 15*64; i += 2)
+        {
+            qmf_state[i] = lins[nbands*64 + i];
+        }
+    } else
+#endif
+    {
+        MA_DR_MP3_COPY_MEMORY(qmf_state, lins + nbands*64, sizeof(float)*15*64);
+    }
+}
+static int ma_dr_mp3d_match_frame(const ma_uint8 *hdr, int mp3_bytes, int frame_bytes)
+{
+    int i, nmatch;
+    for (i = 0, nmatch = 0; nmatch < MA_DR_MP3_MAX_FRAME_SYNC_MATCHES; nmatch++)
+    {
+        i += ma_dr_mp3_hdr_frame_bytes(hdr + i, frame_bytes) + ma_dr_mp3_hdr_padding(hdr + i);
+        if (i + MA_DR_MP3_HDR_SIZE > mp3_bytes)
+            return nmatch > 0;
+        if (!ma_dr_mp3_hdr_compare(hdr, hdr + i))
+            return 0;
+    }
+    return 1;
+}
+static int ma_dr_mp3d_find_frame(const ma_uint8 *mp3, int mp3_bytes, int *free_format_bytes, int *ptr_frame_bytes)
+{
+    int i, k;
+    for (i = 0; i < mp3_bytes - MA_DR_MP3_HDR_SIZE; i++, mp3++)
+    {
+        if (ma_dr_mp3_hdr_valid(mp3))
+        {
+            int frame_bytes = ma_dr_mp3_hdr_frame_bytes(mp3, *free_format_bytes);
+            int frame_and_padding = frame_bytes + ma_dr_mp3_hdr_padding(mp3);
+            for (k = MA_DR_MP3_HDR_SIZE; !frame_bytes && k < MA_DR_MP3_MAX_FREE_FORMAT_FRAME_SIZE && i + 2*k < mp3_bytes - MA_DR_MP3_HDR_SIZE; k++)
+            {
+                if (ma_dr_mp3_hdr_compare(mp3, mp3 + k))
+                {
+                    int fb = k - ma_dr_mp3_hdr_padding(mp3);
+                    int nextfb = fb + ma_dr_mp3_hdr_padding(mp3 + k);
+                    if (i + k + nextfb + MA_DR_MP3_HDR_SIZE > mp3_bytes || !ma_dr_mp3_hdr_compare(mp3, mp3 + k + nextfb))
+                        continue;
+                    frame_and_padding = k;
+                    frame_bytes = fb;
+                    *free_format_bytes = fb;
+                }
+            }
+            if ((frame_bytes && i + frame_and_padding <= mp3_bytes &&
+                ma_dr_mp3d_match_frame(mp3, mp3_bytes - i, frame_bytes)) ||
+                (!i && frame_and_padding == mp3_bytes))
+            {
+                *ptr_frame_bytes = frame_and_padding;
+                return i;
+            }
+            *free_format_bytes = 0;
+        }
+    }
+    *ptr_frame_bytes = 0;
+    return mp3_bytes;
+}
+MA_API void ma_dr_mp3dec_init(ma_dr_mp3dec *dec)
+{
+    dec->header[0] = 0;
+}
+MA_API int ma_dr_mp3dec_decode_frame(ma_dr_mp3dec *dec, const ma_uint8 *mp3, int mp3_bytes, void *pcm, ma_dr_mp3dec_frame_info *info)
+{
+    int i = 0, igr, frame_size = 0, success = 1;
+    const ma_uint8 *hdr;
+    ma_dr_mp3_bs bs_frame[1];
+    ma_dr_mp3dec_scratch scratch;
+    if (mp3_bytes > 4 && dec->header[0] == 0xff && ma_dr_mp3_hdr_compare(dec->header, mp3))
+    {
+        frame_size = ma_dr_mp3_hdr_frame_bytes(mp3, dec->free_format_bytes) + ma_dr_mp3_hdr_padding(mp3);
+        if (frame_size != mp3_bytes && (frame_size + MA_DR_MP3_HDR_SIZE > mp3_bytes || !ma_dr_mp3_hdr_compare(mp3, mp3 + frame_size)))
+        {
+            frame_size = 0;
+        }
+    }
+    if (!frame_size)
+    {
+        MA_DR_MP3_ZERO_MEMORY(dec, sizeof(ma_dr_mp3dec));
+        i = ma_dr_mp3d_find_frame(mp3, mp3_bytes, &dec->free_format_bytes, &frame_size);
+        if (!frame_size || i + frame_size > mp3_bytes)
+        {
+            info->frame_bytes = i;
+            return 0;
+        }
+    }
+    hdr = mp3 + i;
+    MA_DR_MP3_COPY_MEMORY(dec->header, hdr, MA_DR_MP3_HDR_SIZE);
+    info->frame_bytes = i + frame_size;
+    info->channels = MA_DR_MP3_HDR_IS_MONO(hdr) ? 1 : 2;
+    info->hz = ma_dr_mp3_hdr_sample_rate_hz(hdr);
+    info->layer = 4 - MA_DR_MP3_HDR_GET_LAYER(hdr);
+    info->bitrate_kbps = ma_dr_mp3_hdr_bitrate_kbps(hdr);
+    ma_dr_mp3_bs_init(bs_frame, hdr + MA_DR_MP3_HDR_SIZE, frame_size - MA_DR_MP3_HDR_SIZE);
+    if (MA_DR_MP3_HDR_IS_CRC(hdr))
+    {
+        ma_dr_mp3_bs_get_bits(bs_frame, 16);
+    }
+    if (info->layer == 3)
+    {
+        int main_data_begin = ma_dr_mp3_L3_read_side_info(bs_frame, scratch.gr_info, hdr);
+        if (main_data_begin < 0 || bs_frame->pos > bs_frame->limit)
+        {
+            ma_dr_mp3dec_init(dec);
+            return 0;
+        }
+        success = ma_dr_mp3_L3_restore_reservoir(dec, bs_frame, &scratch, main_data_begin);
+        if (success && pcm != NULL)
+        {
+            for (igr = 0; igr < (MA_DR_MP3_HDR_TEST_MPEG1(hdr) ? 2 : 1); igr++, pcm = MA_DR_MP3_OFFSET_PTR(pcm, sizeof(ma_dr_mp3d_sample_t)*576*info->channels))
+            {
+                MA_DR_MP3_ZERO_MEMORY(scratch.grbuf[0], 576*2*sizeof(float));
+                ma_dr_mp3_L3_decode(dec, &scratch, scratch.gr_info + igr*info->channels, info->channels);
+                ma_dr_mp3d_synth_granule(dec->qmf_state, scratch.grbuf[0], 18, info->channels, (ma_dr_mp3d_sample_t*)pcm, scratch.syn[0]);
+            }
+        }
+        ma_dr_mp3_L3_save_reservoir(dec, &scratch);
+    } else
+    {
+#ifdef MA_DR_MP3_ONLY_MP3
+        return 0;
+#else
+        ma_dr_mp3_L12_scale_info sci[1];
+        if (pcm == NULL) {
+            return ma_dr_mp3_hdr_frame_samples(hdr);
+        }
+        ma_dr_mp3_L12_read_scale_info(hdr, bs_frame, sci);
+        MA_DR_MP3_ZERO_MEMORY(scratch.grbuf[0], 576*2*sizeof(float));
+        for (i = 0, igr = 0; igr < 3; igr++)
+        {
+            if (12 == (i += ma_dr_mp3_L12_dequantize_granule(scratch.grbuf[0] + i, bs_frame, sci, info->layer | 1)))
+            {
+                i = 0;
+                ma_dr_mp3_L12_apply_scf_384(sci, sci->scf + igr, scratch.grbuf[0]);
+                ma_dr_mp3d_synth_granule(dec->qmf_state, scratch.grbuf[0], 12, info->channels, (ma_dr_mp3d_sample_t*)pcm, scratch.syn[0]);
+                MA_DR_MP3_ZERO_MEMORY(scratch.grbuf[0], 576*2*sizeof(float));
+                pcm = MA_DR_MP3_OFFSET_PTR(pcm, sizeof(ma_dr_mp3d_sample_t)*384*info->channels);
+            }
+            if (bs_frame->pos > bs_frame->limit)
+            {
+                ma_dr_mp3dec_init(dec);
+                return 0;
+            }
+        }
+#endif
+    }
+    return success*ma_dr_mp3_hdr_frame_samples(dec->header);
+}
+MA_API void ma_dr_mp3dec_f32_to_s16(const float *in, ma_int16 *out, size_t num_samples)
+{
+    size_t i = 0;
+#if MA_DR_MP3_HAVE_SIMD
+    size_t aligned_count = num_samples & ~7;
+    for(; i < aligned_count; i+=8)
+    {
+        ma_dr_mp3_f4 scale = MA_DR_MP3_VSET(32768.0f);
+        ma_dr_mp3_f4 a = MA_DR_MP3_VMUL(MA_DR_MP3_VLD(&in[i  ]), scale);
+        ma_dr_mp3_f4 b = MA_DR_MP3_VMUL(MA_DR_MP3_VLD(&in[i+4]), scale);
+#if MA_DR_MP3_HAVE_SSE
+        ma_dr_mp3_f4 s16max = MA_DR_MP3_VSET( 32767.0f);
+        ma_dr_mp3_f4 s16min = MA_DR_MP3_VSET(-32768.0f);
+        __m128i pcm8 = _mm_packs_epi32(_mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(a, s16max), s16min)),
+                                        _mm_cvtps_epi32(_mm_max_ps(_mm_min_ps(b, s16max), s16min)));
+        out[i  ] = (ma_int16)_mm_extract_epi16(pcm8, 0);
+        out[i+1] = (ma_int16)_mm_extract_epi16(pcm8, 1);
+        out[i+2] = (ma_int16)_mm_extract_epi16(pcm8, 2);
+        out[i+3] = (ma_int16)_mm_extract_epi16(pcm8, 3);
+        out[i+4] = (ma_int16)_mm_extract_epi16(pcm8, 4);
+        out[i+5] = (ma_int16)_mm_extract_epi16(pcm8, 5);
+        out[i+6] = (ma_int16)_mm_extract_epi16(pcm8, 6);
+        out[i+7] = (ma_int16)_mm_extract_epi16(pcm8, 7);
+#else
+        int16x4_t pcma, pcmb;
+        a = MA_DR_MP3_VADD(a, MA_DR_MP3_VSET(0.5f));
+        b = MA_DR_MP3_VADD(b, MA_DR_MP3_VSET(0.5f));
+        pcma = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(a), vreinterpretq_s32_u32(vcltq_f32(a, MA_DR_MP3_VSET(0)))));
+        pcmb = vqmovn_s32(vqaddq_s32(vcvtq_s32_f32(b), vreinterpretq_s32_u32(vcltq_f32(b, MA_DR_MP3_VSET(0)))));
+        vst1_lane_s16(out+i  , pcma, 0);
+        vst1_lane_s16(out+i+1, pcma, 1);
+        vst1_lane_s16(out+i+2, pcma, 2);
+        vst1_lane_s16(out+i+3, pcma, 3);
+        vst1_lane_s16(out+i+4, pcmb, 0);
+        vst1_lane_s16(out+i+5, pcmb, 1);
+        vst1_lane_s16(out+i+6, pcmb, 2);
+        vst1_lane_s16(out+i+7, pcmb, 3);
+#endif
+    }
+#endif
+    for(; i < num_samples; i++)
+    {
+        float sample = in[i] * 32768.0f;
+        if (sample >=  32766.5)
+            out[i] = (ma_int16) 32767;
+        else if (sample <= -32767.5)
+            out[i] = (ma_int16)-32768;
+        else
+        {
+            short s = (ma_int16)(sample + .5f);
+            s -= (s < 0);
+            out[i] = s;
+        }
+    }
+}
+#ifndef MA_DR_MP3_SEEK_LEADING_MP3_FRAMES
+#define MA_DR_MP3_SEEK_LEADING_MP3_FRAMES   2
+#endif
+#define MA_DR_MP3_MIN_DATA_CHUNK_SIZE   16384
+#ifndef MA_DR_MP3_DATA_CHUNK_SIZE
+#define MA_DR_MP3_DATA_CHUNK_SIZE  (MA_DR_MP3_MIN_DATA_CHUNK_SIZE*4)
+#endif
+#define MA_DR_MP3_COUNTOF(x)        (sizeof(x) / sizeof(x[0]))
+#define MA_DR_MP3_CLAMP(x, lo, hi)  (MA_DR_MP3_MAX(lo, MA_DR_MP3_MIN(x, hi)))
+#ifndef MA_DR_MP3_PI_D
+#define MA_DR_MP3_PI_D    3.14159265358979323846264
+#endif
+#define MA_DR_MP3_DEFAULT_RESAMPLER_LPF_ORDER   2
+static MA_INLINE float ma_dr_mp3_mix_f32(float x, float y, float a)
+{
+    return x*(1-a) + y*a;
+}
+static MA_INLINE float ma_dr_mp3_mix_f32_fast(float x, float y, float a)
+{
+    float r0 = (y - x);
+    float r1 = r0*a;
+    return x + r1;
+}
+static MA_INLINE ma_uint32 ma_dr_mp3_gcf_u32(ma_uint32 a, ma_uint32 b)
+{
+    for (;;) {
+        if (b == 0) {
+            break;
+        } else {
+            ma_uint32 t = a;
+            a = b;
+            b = t % a;
+        }
+    }
+    return a;
+}
+static void* ma_dr_mp3__malloc_default(size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_MP3_MALLOC(sz);
+}
+static void* ma_dr_mp3__realloc_default(void* p, size_t sz, void* pUserData)
+{
+    (void)pUserData;
+    return MA_DR_MP3_REALLOC(p, sz);
+}
+static void ma_dr_mp3__free_default(void* p, void* pUserData)
+{
+    (void)pUserData;
+    MA_DR_MP3_FREE(p);
+}
+static void* ma_dr_mp3__malloc_from_callbacks(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onMalloc != NULL) {
+        return pAllocationCallbacks->onMalloc(sz, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(NULL, sz, pAllocationCallbacks->pUserData);
+    }
+    return NULL;
+}
+static void* ma_dr_mp3__realloc_from_callbacks(void* p, size_t szNew, size_t szOld, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks == NULL) {
+        return NULL;
+    }
+    if (pAllocationCallbacks->onRealloc != NULL) {
+        return pAllocationCallbacks->onRealloc(p, szNew, pAllocationCallbacks->pUserData);
+    }
+    if (pAllocationCallbacks->onMalloc != NULL && pAllocationCallbacks->onFree != NULL) {
+        void* p2;
+        p2 = pAllocationCallbacks->onMalloc(szNew, pAllocationCallbacks->pUserData);
+        if (p2 == NULL) {
+            return NULL;
+        }
+        if (p != NULL) {
+            MA_DR_MP3_COPY_MEMORY(p2, p, szOld);
+            pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+        }
+        return p2;
+    }
+    return NULL;
+}
+static void ma_dr_mp3__free_from_callbacks(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (p == NULL || pAllocationCallbacks == NULL) {
+        return;
+    }
+    if (pAllocationCallbacks->onFree != NULL) {
+        pAllocationCallbacks->onFree(p, pAllocationCallbacks->pUserData);
+    }
+}
+static ma_allocation_callbacks ma_dr_mp3_copy_allocation_callbacks_or_defaults(const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        return *pAllocationCallbacks;
+    } else {
+        ma_allocation_callbacks allocationCallbacks;
+        allocationCallbacks.pUserData = NULL;
+        allocationCallbacks.onMalloc  = ma_dr_mp3__malloc_default;
+        allocationCallbacks.onRealloc = ma_dr_mp3__realloc_default;
+        allocationCallbacks.onFree    = ma_dr_mp3__free_default;
+        return allocationCallbacks;
+    }
+}
+static size_t ma_dr_mp3__on_read(ma_dr_mp3* pMP3, void* pBufferOut, size_t bytesToRead)
+{
+    size_t bytesRead = pMP3->onRead(pMP3->pUserData, pBufferOut, bytesToRead);
+    pMP3->streamCursor += bytesRead;
+    return bytesRead;
+}
+static ma_bool32 ma_dr_mp3__on_seek(ma_dr_mp3* pMP3, int offset, ma_dr_mp3_seek_origin origin)
+{
+    MA_DR_MP3_ASSERT(offset >= 0);
+    if (!pMP3->onSeek(pMP3->pUserData, offset, origin)) {
+        return MA_FALSE;
+    }
+    if (origin == ma_dr_mp3_seek_origin_start) {
+        pMP3->streamCursor = (ma_uint64)offset;
+    } else {
+        pMP3->streamCursor += offset;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_mp3__on_seek_64(ma_dr_mp3* pMP3, ma_uint64 offset, ma_dr_mp3_seek_origin origin)
+{
+    if (offset <= 0x7FFFFFFF) {
+        return ma_dr_mp3__on_seek(pMP3, (int)offset, origin);
+    }
+    if (!ma_dr_mp3__on_seek(pMP3, 0x7FFFFFFF, ma_dr_mp3_seek_origin_start)) {
+        return MA_FALSE;
+    }
+    offset -= 0x7FFFFFFF;
+    while (offset > 0) {
+        if (offset <= 0x7FFFFFFF) {
+            if (!ma_dr_mp3__on_seek(pMP3, (int)offset, ma_dr_mp3_seek_origin_current)) {
+                return MA_FALSE;
+            }
+            offset = 0;
+        } else {
+            if (!ma_dr_mp3__on_seek(pMP3, 0x7FFFFFFF, ma_dr_mp3_seek_origin_current)) {
+                return MA_FALSE;
+            }
+            offset -= 0x7FFFFFFF;
+        }
+    }
+    return MA_TRUE;
+}
+static ma_uint32 ma_dr_mp3_decode_next_frame_ex__callbacks(ma_dr_mp3* pMP3, ma_dr_mp3d_sample_t* pPCMFrames)
+{
+    ma_uint32 pcmFramesRead = 0;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->onRead != NULL);
+    if (pMP3->atEnd) {
+        return 0;
+    }
+    for (;;) {
+        ma_dr_mp3dec_frame_info info;
+        if (pMP3->dataSize < MA_DR_MP3_MIN_DATA_CHUNK_SIZE) {
+            size_t bytesRead;
+            if (pMP3->pData != NULL) {
+                MA_DR_MP3_MOVE_MEMORY(pMP3->pData, pMP3->pData + pMP3->dataConsumed, pMP3->dataSize);
+            }
+            pMP3->dataConsumed = 0;
+            if (pMP3->dataCapacity < MA_DR_MP3_DATA_CHUNK_SIZE) {
+                ma_uint8* pNewData;
+                size_t newDataCap;
+                newDataCap = MA_DR_MP3_DATA_CHUNK_SIZE;
+                pNewData = (ma_uint8*)ma_dr_mp3__realloc_from_callbacks(pMP3->pData, newDataCap, pMP3->dataCapacity, &pMP3->allocationCallbacks);
+                if (pNewData == NULL) {
+                    return 0;
+                }
+                pMP3->pData = pNewData;
+                pMP3->dataCapacity = newDataCap;
+            }
+            bytesRead = ma_dr_mp3__on_read(pMP3, pMP3->pData + pMP3->dataSize, (pMP3->dataCapacity - pMP3->dataSize));
+            if (bytesRead == 0) {
+                if (pMP3->dataSize == 0) {
+                    pMP3->atEnd = MA_TRUE;
+                    return 0;
+                }
+            }
+            pMP3->dataSize += bytesRead;
+        }
+        if (pMP3->dataSize > INT_MAX) {
+            pMP3->atEnd = MA_TRUE;
+            return 0;
+        }
+        MA_DR_MP3_ASSERT(pMP3->pData != NULL);
+        MA_DR_MP3_ASSERT(pMP3->dataCapacity > 0);
+        if (pMP3->pData == NULL) {
+            return 0;
+        }
+        pcmFramesRead = ma_dr_mp3dec_decode_frame(&pMP3->decoder, pMP3->pData + pMP3->dataConsumed, (int)pMP3->dataSize, pPCMFrames, &info);
+        if (info.frame_bytes > 0) {
+            pMP3->dataConsumed += (size_t)info.frame_bytes;
+            pMP3->dataSize     -= (size_t)info.frame_bytes;
+        }
+        if (pcmFramesRead > 0) {
+            pcmFramesRead = ma_dr_mp3_hdr_frame_samples(pMP3->decoder.header);
+            pMP3->pcmFramesConsumedInMP3Frame = 0;
+            pMP3->pcmFramesRemainingInMP3Frame = pcmFramesRead;
+            pMP3->mp3FrameChannels = info.channels;
+            pMP3->mp3FrameSampleRate = info.hz;
+            break;
+        } else if (info.frame_bytes == 0) {
+            size_t bytesRead;
+            MA_DR_MP3_MOVE_MEMORY(pMP3->pData, pMP3->pData + pMP3->dataConsumed, pMP3->dataSize);
+            pMP3->dataConsumed = 0;
+            if (pMP3->dataCapacity == pMP3->dataSize) {
+                ma_uint8* pNewData;
+                size_t newDataCap;
+                newDataCap = pMP3->dataCapacity + MA_DR_MP3_DATA_CHUNK_SIZE;
+                pNewData = (ma_uint8*)ma_dr_mp3__realloc_from_callbacks(pMP3->pData, newDataCap, pMP3->dataCapacity, &pMP3->allocationCallbacks);
+                if (pNewData == NULL) {
+                    return 0;
+                }
+                pMP3->pData = pNewData;
+                pMP3->dataCapacity = newDataCap;
+            }
+            bytesRead = ma_dr_mp3__on_read(pMP3, pMP3->pData + pMP3->dataSize, (pMP3->dataCapacity - pMP3->dataSize));
+            if (bytesRead == 0) {
+                pMP3->atEnd = MA_TRUE;
+                return 0;
+            }
+            pMP3->dataSize += bytesRead;
+        }
+    };
+    return pcmFramesRead;
+}
+static ma_uint32 ma_dr_mp3_decode_next_frame_ex__memory(ma_dr_mp3* pMP3, ma_dr_mp3d_sample_t* pPCMFrames)
+{
+    ma_uint32 pcmFramesRead = 0;
+    ma_dr_mp3dec_frame_info info;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->memory.pData != NULL);
+    if (pMP3->atEnd) {
+        return 0;
+    }
+    for (;;) {
+        pcmFramesRead = ma_dr_mp3dec_decode_frame(&pMP3->decoder, pMP3->memory.pData + pMP3->memory.currentReadPos, (int)(pMP3->memory.dataSize - pMP3->memory.currentReadPos), pPCMFrames, &info);
+        if (pcmFramesRead > 0) {
+            pcmFramesRead = ma_dr_mp3_hdr_frame_samples(pMP3->decoder.header);
+            pMP3->pcmFramesConsumedInMP3Frame  = 0;
+            pMP3->pcmFramesRemainingInMP3Frame = pcmFramesRead;
+            pMP3->mp3FrameChannels             = info.channels;
+            pMP3->mp3FrameSampleRate           = info.hz;
+            break;
+        } else if (info.frame_bytes > 0) {
+            pMP3->memory.currentReadPos += (size_t)info.frame_bytes;
+        } else {
+            break;
+        }
+    }
+    pMP3->memory.currentReadPos += (size_t)info.frame_bytes;
+    return pcmFramesRead;
+}
+static ma_uint32 ma_dr_mp3_decode_next_frame_ex(ma_dr_mp3* pMP3, ma_dr_mp3d_sample_t* pPCMFrames)
+{
+    if (pMP3->memory.pData != NULL && pMP3->memory.dataSize > 0) {
+        return ma_dr_mp3_decode_next_frame_ex__memory(pMP3, pPCMFrames);
+    } else {
+        return ma_dr_mp3_decode_next_frame_ex__callbacks(pMP3, pPCMFrames);
+    }
+}
+static ma_uint32 ma_dr_mp3_decode_next_frame(ma_dr_mp3* pMP3)
+{
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    return ma_dr_mp3_decode_next_frame_ex(pMP3, (ma_dr_mp3d_sample_t*)pMP3->pcmFrames);
+}
+#if 0
+static ma_uint32 ma_dr_mp3_seek_next_frame(ma_dr_mp3* pMP3)
+{
+    ma_uint32 pcmFrameCount;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    pcmFrameCount = ma_dr_mp3_decode_next_frame_ex(pMP3, NULL);
+    if (pcmFrameCount == 0) {
+        return 0;
+    }
+    pMP3->currentPCMFrame             += pcmFrameCount;
+    pMP3->pcmFramesConsumedInMP3Frame  = pcmFrameCount;
+    pMP3->pcmFramesRemainingInMP3Frame = 0;
+    return pcmFrameCount;
+}
+#endif
+static ma_bool32 ma_dr_mp3_init_internal(ma_dr_mp3* pMP3, ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(onRead != NULL);
+    ma_dr_mp3dec_init(&pMP3->decoder);
+    pMP3->onRead = onRead;
+    pMP3->onSeek = onSeek;
+    pMP3->pUserData = pUserData;
+    pMP3->allocationCallbacks = ma_dr_mp3_copy_allocation_callbacks_or_defaults(pAllocationCallbacks);
+    if (pMP3->allocationCallbacks.onFree == NULL || (pMP3->allocationCallbacks.onMalloc == NULL && pMP3->allocationCallbacks.onRealloc == NULL)) {
+        return MA_FALSE;
+    }
+    if (ma_dr_mp3_decode_next_frame(pMP3) == 0) {
+        ma_dr_mp3__free_from_callbacks(pMP3->pData, &pMP3->allocationCallbacks);
+        return MA_FALSE;
+    }
+    pMP3->channels   = pMP3->mp3FrameChannels;
+    pMP3->sampleRate = pMP3->mp3FrameSampleRate;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_init(ma_dr_mp3* pMP3, ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, void* pUserData, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pMP3 == NULL || onRead == NULL) {
+        return MA_FALSE;
+    }
+    MA_DR_MP3_ZERO_OBJECT(pMP3);
+    return ma_dr_mp3_init_internal(pMP3, onRead, onSeek, pUserData, pAllocationCallbacks);
+}
+static size_t ma_dr_mp3__on_read_memory(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    ma_dr_mp3* pMP3 = (ma_dr_mp3*)pUserData;
+    size_t bytesRemaining;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->memory.dataSize >= pMP3->memory.currentReadPos);
+    bytesRemaining = pMP3->memory.dataSize - pMP3->memory.currentReadPos;
+    if (bytesToRead > bytesRemaining) {
+        bytesToRead = bytesRemaining;
+    }
+    if (bytesToRead > 0) {
+        MA_DR_MP3_COPY_MEMORY(pBufferOut, pMP3->memory.pData + pMP3->memory.currentReadPos, bytesToRead);
+        pMP3->memory.currentReadPos += bytesToRead;
+    }
+    return bytesToRead;
+}
+static ma_bool32 ma_dr_mp3__on_seek_memory(void* pUserData, int byteOffset, ma_dr_mp3_seek_origin origin)
+{
+    ma_dr_mp3* pMP3 = (ma_dr_mp3*)pUserData;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    if (origin == ma_dr_mp3_seek_origin_current) {
+        if (byteOffset > 0) {
+            if (pMP3->memory.currentReadPos + byteOffset > pMP3->memory.dataSize) {
+                byteOffset = (int)(pMP3->memory.dataSize - pMP3->memory.currentReadPos);
+            }
+        } else {
+            if (pMP3->memory.currentReadPos < (size_t)-byteOffset) {
+                byteOffset = -(int)pMP3->memory.currentReadPos;
+            }
+        }
+        pMP3->memory.currentReadPos += byteOffset;
+    } else {
+        if ((ma_uint32)byteOffset <= pMP3->memory.dataSize) {
+            pMP3->memory.currentReadPos = byteOffset;
+        } else {
+            pMP3->memory.currentReadPos = pMP3->memory.dataSize;
+        }
+    }
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_init_memory(ma_dr_mp3* pMP3, const void* pData, size_t dataSize, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pMP3 == NULL) {
+        return MA_FALSE;
+    }
+    MA_DR_MP3_ZERO_OBJECT(pMP3);
+    if (pData == NULL || dataSize == 0) {
+        return MA_FALSE;
+    }
+    pMP3->memory.pData = (const ma_uint8*)pData;
+    pMP3->memory.dataSize = dataSize;
+    pMP3->memory.currentReadPos = 0;
+    return ma_dr_mp3_init_internal(pMP3, ma_dr_mp3__on_read_memory, ma_dr_mp3__on_seek_memory, pMP3, pAllocationCallbacks);
+}
+#ifndef MA_DR_MP3_NO_STDIO
+#include <stdio.h>
+#include <wchar.h>
+static size_t ma_dr_mp3__on_read_stdio(void* pUserData, void* pBufferOut, size_t bytesToRead)
+{
+    return fread(pBufferOut, 1, bytesToRead, (FILE*)pUserData);
+}
+static ma_bool32 ma_dr_mp3__on_seek_stdio(void* pUserData, int offset, ma_dr_mp3_seek_origin origin)
+{
+    return fseek((FILE*)pUserData, offset, (origin == ma_dr_mp3_seek_origin_current) ? SEEK_CUR : SEEK_SET) == 0;
+}
+MA_API ma_bool32 ma_dr_mp3_init_file(ma_dr_mp3* pMP3, const char* pFilePath, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 result;
+    FILE* pFile;
+    if (ma_fopen(&pFile, pFilePath, "rb") != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    result = ma_dr_mp3_init(pMP3, ma_dr_mp3__on_read_stdio, ma_dr_mp3__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_init_file_w(ma_dr_mp3* pMP3, const wchar_t* pFilePath, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_bool32 result;
+    FILE* pFile;
+    if (ma_wfopen(&pFile, pFilePath, L"rb", pAllocationCallbacks) != MA_SUCCESS) {
+        return MA_FALSE;
+    }
+    result = ma_dr_mp3_init(pMP3, ma_dr_mp3__on_read_stdio, ma_dr_mp3__on_seek_stdio, (void*)pFile, pAllocationCallbacks);
+    if (result != MA_TRUE) {
+        fclose(pFile);
+        return result;
+    }
+    return MA_TRUE;
+}
+#endif
+MA_API void ma_dr_mp3_uninit(ma_dr_mp3* pMP3)
+{
+    if (pMP3 == NULL) {
+        return;
+    }
+#ifndef MA_DR_MP3_NO_STDIO
+    if (pMP3->onRead == ma_dr_mp3__on_read_stdio) {
+        FILE* pFile = (FILE*)pMP3->pUserData;
+        if (pFile != NULL) {
+            fclose(pFile);
+            pMP3->pUserData = NULL;
+        }
+    }
+#endif
+    ma_dr_mp3__free_from_callbacks(pMP3->pData, &pMP3->allocationCallbacks);
+}
+#if defined(MA_DR_MP3_FLOAT_OUTPUT)
+static void ma_dr_mp3_f32_to_s16(ma_int16* dst, const float* src, ma_uint64 sampleCount)
+{
+    ma_uint64 i;
+    ma_uint64 i4;
+    ma_uint64 sampleCount4;
+    i = 0;
+    sampleCount4 = sampleCount >> 2;
+    for (i4 = 0; i4 < sampleCount4; i4 += 1) {
+        float x0 = src[i+0];
+        float x1 = src[i+1];
+        float x2 = src[i+2];
+        float x3 = src[i+3];
+        x0 = ((x0 < -1) ? -1 : ((x0 > 1) ? 1 : x0));
+        x1 = ((x1 < -1) ? -1 : ((x1 > 1) ? 1 : x1));
+        x2 = ((x2 < -1) ? -1 : ((x2 > 1) ? 1 : x2));
+        x3 = ((x3 < -1) ? -1 : ((x3 > 1) ? 1 : x3));
+        x0 = x0 * 32767.0f;
+        x1 = x1 * 32767.0f;
+        x2 = x2 * 32767.0f;
+        x3 = x3 * 32767.0f;
+        dst[i+0] = (ma_int16)x0;
+        dst[i+1] = (ma_int16)x1;
+        dst[i+2] = (ma_int16)x2;
+        dst[i+3] = (ma_int16)x3;
+        i += 4;
+    }
+    for (; i < sampleCount; i += 1) {
+        float x = src[i];
+        x = ((x < -1) ? -1 : ((x > 1) ? 1 : x));
+        x = x * 32767.0f;
+        dst[i] = (ma_int16)x;
+    }
+}
+#endif
+#if !defined(MA_DR_MP3_FLOAT_OUTPUT)
+static void ma_dr_mp3_s16_to_f32(float* dst, const ma_int16* src, ma_uint64 sampleCount)
+{
+    ma_uint64 i;
+    for (i = 0; i < sampleCount; i += 1) {
+        float x = (float)src[i];
+        x = x * 0.000030517578125f;
+        dst[i] = x;
+    }
+}
+#endif
+static ma_uint64 ma_dr_mp3_read_pcm_frames_raw(ma_dr_mp3* pMP3, ma_uint64 framesToRead, void* pBufferOut)
+{
+    ma_uint64 totalFramesRead = 0;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->onRead != NULL);
+    while (framesToRead > 0) {
+        ma_uint32 framesToConsume = (ma_uint32)MA_DR_MP3_MIN(pMP3->pcmFramesRemainingInMP3Frame, framesToRead);
+        if (pBufferOut != NULL) {
+        #if defined(MA_DR_MP3_FLOAT_OUTPUT)
+            float* pFramesOutF32 = (float*)MA_DR_MP3_OFFSET_PTR(pBufferOut,          sizeof(float) * totalFramesRead                   * pMP3->channels);
+            float* pFramesInF32  = (float*)MA_DR_MP3_OFFSET_PTR(&pMP3->pcmFrames[0], sizeof(float) * pMP3->pcmFramesConsumedInMP3Frame * pMP3->mp3FrameChannels);
+            MA_DR_MP3_COPY_MEMORY(pFramesOutF32, pFramesInF32, sizeof(float) * framesToConsume * pMP3->channels);
+        #else
+            ma_int16* pFramesOutS16 = (ma_int16*)MA_DR_MP3_OFFSET_PTR(pBufferOut,          sizeof(ma_int16) * totalFramesRead                   * pMP3->channels);
+            ma_int16* pFramesInS16  = (ma_int16*)MA_DR_MP3_OFFSET_PTR(&pMP3->pcmFrames[0], sizeof(ma_int16) * pMP3->pcmFramesConsumedInMP3Frame * pMP3->mp3FrameChannels);
+            MA_DR_MP3_COPY_MEMORY(pFramesOutS16, pFramesInS16, sizeof(ma_int16) * framesToConsume * pMP3->channels);
+        #endif
+        }
+        pMP3->currentPCMFrame              += framesToConsume;
+        pMP3->pcmFramesConsumedInMP3Frame  += framesToConsume;
+        pMP3->pcmFramesRemainingInMP3Frame -= framesToConsume;
+        totalFramesRead                    += framesToConsume;
+        framesToRead                       -= framesToConsume;
+        if (framesToRead == 0) {
+            break;
+        }
+        MA_DR_MP3_ASSERT(pMP3->pcmFramesRemainingInMP3Frame == 0);
+        if (ma_dr_mp3_decode_next_frame(pMP3) == 0) {
+            break;
+        }
+    }
+    return totalFramesRead;
+}
+MA_API ma_uint64 ma_dr_mp3_read_pcm_frames_f32(ma_dr_mp3* pMP3, ma_uint64 framesToRead, float* pBufferOut)
+{
+    if (pMP3 == NULL || pMP3->onRead == NULL) {
+        return 0;
+    }
+#if defined(MA_DR_MP3_FLOAT_OUTPUT)
+    return ma_dr_mp3_read_pcm_frames_raw(pMP3, framesToRead, pBufferOut);
+#else
+    {
+        ma_int16 pTempS16[8192];
+        ma_uint64 totalPCMFramesRead = 0;
+        while (totalPCMFramesRead < framesToRead) {
+            ma_uint64 framesJustRead;
+            ma_uint64 framesRemaining = framesToRead - totalPCMFramesRead;
+            ma_uint64 framesToReadNow = MA_DR_MP3_COUNTOF(pTempS16) / pMP3->channels;
+            if (framesToReadNow > framesRemaining) {
+                framesToReadNow = framesRemaining;
+            }
+            framesJustRead = ma_dr_mp3_read_pcm_frames_raw(pMP3, framesToReadNow, pTempS16);
+            if (framesJustRead == 0) {
+                break;
+            }
+            ma_dr_mp3_s16_to_f32((float*)MA_DR_MP3_OFFSET_PTR(pBufferOut, sizeof(float) * totalPCMFramesRead * pMP3->channels), pTempS16, framesJustRead * pMP3->channels);
+            totalPCMFramesRead += framesJustRead;
+        }
+        return totalPCMFramesRead;
+    }
+#endif
+}
+MA_API ma_uint64 ma_dr_mp3_read_pcm_frames_s16(ma_dr_mp3* pMP3, ma_uint64 framesToRead, ma_int16* pBufferOut)
+{
+    if (pMP3 == NULL || pMP3->onRead == NULL) {
+        return 0;
+    }
+#if !defined(MA_DR_MP3_FLOAT_OUTPUT)
+    return ma_dr_mp3_read_pcm_frames_raw(pMP3, framesToRead, pBufferOut);
+#else
+    {
+        float pTempF32[4096];
+        ma_uint64 totalPCMFramesRead = 0;
+        while (totalPCMFramesRead < framesToRead) {
+            ma_uint64 framesJustRead;
+            ma_uint64 framesRemaining = framesToRead - totalPCMFramesRead;
+            ma_uint64 framesToReadNow = MA_DR_MP3_COUNTOF(pTempF32) / pMP3->channels;
+            if (framesToReadNow > framesRemaining) {
+                framesToReadNow = framesRemaining;
+            }
+            framesJustRead = ma_dr_mp3_read_pcm_frames_raw(pMP3, framesToReadNow, pTempF32);
+            if (framesJustRead == 0) {
+                break;
+            }
+            ma_dr_mp3_f32_to_s16((ma_int16*)MA_DR_MP3_OFFSET_PTR(pBufferOut, sizeof(ma_int16) * totalPCMFramesRead * pMP3->channels), pTempF32, framesJustRead * pMP3->channels);
+            totalPCMFramesRead += framesJustRead;
+        }
+        return totalPCMFramesRead;
+    }
+#endif
+}
+static void ma_dr_mp3_reset(ma_dr_mp3* pMP3)
+{
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    pMP3->pcmFramesConsumedInMP3Frame = 0;
+    pMP3->pcmFramesRemainingInMP3Frame = 0;
+    pMP3->currentPCMFrame = 0;
+    pMP3->dataSize = 0;
+    pMP3->atEnd = MA_FALSE;
+    ma_dr_mp3dec_init(&pMP3->decoder);
+}
+static ma_bool32 ma_dr_mp3_seek_to_start_of_stream(ma_dr_mp3* pMP3)
+{
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->onSeek != NULL);
+    if (!ma_dr_mp3__on_seek(pMP3, 0, ma_dr_mp3_seek_origin_start)) {
+        return MA_FALSE;
+    }
+    ma_dr_mp3_reset(pMP3);
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_mp3_seek_forward_by_pcm_frames__brute_force(ma_dr_mp3* pMP3, ma_uint64 frameOffset)
+{
+    ma_uint64 framesRead;
+#if defined(MA_DR_MP3_FLOAT_OUTPUT)
+    framesRead = ma_dr_mp3_read_pcm_frames_f32(pMP3, frameOffset, NULL);
+#else
+    framesRead = ma_dr_mp3_read_pcm_frames_s16(pMP3, frameOffset, NULL);
+#endif
+    if (framesRead != frameOffset) {
+        return MA_FALSE;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_mp3_seek_to_pcm_frame__brute_force(ma_dr_mp3* pMP3, ma_uint64 frameIndex)
+{
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    if (frameIndex == pMP3->currentPCMFrame) {
+        return MA_TRUE;
+    }
+    if (frameIndex < pMP3->currentPCMFrame) {
+        if (!ma_dr_mp3_seek_to_start_of_stream(pMP3)) {
+            return MA_FALSE;
+        }
+    }
+    MA_DR_MP3_ASSERT(frameIndex >= pMP3->currentPCMFrame);
+    return ma_dr_mp3_seek_forward_by_pcm_frames__brute_force(pMP3, (frameIndex - pMP3->currentPCMFrame));
+}
+static ma_bool32 ma_dr_mp3_find_closest_seek_point(ma_dr_mp3* pMP3, ma_uint64 frameIndex, ma_uint32* pSeekPointIndex)
+{
+    ma_uint32 iSeekPoint;
+    MA_DR_MP3_ASSERT(pSeekPointIndex != NULL);
+    *pSeekPointIndex = 0;
+    if (frameIndex < pMP3->pSeekPoints[0].pcmFrameIndex) {
+        return MA_FALSE;
+    }
+    for (iSeekPoint = 0; iSeekPoint < pMP3->seekPointCount; ++iSeekPoint) {
+        if (pMP3->pSeekPoints[iSeekPoint].pcmFrameIndex > frameIndex) {
+            break;
+        }
+        *pSeekPointIndex = iSeekPoint;
+    }
+    return MA_TRUE;
+}
+static ma_bool32 ma_dr_mp3_seek_to_pcm_frame__seek_table(ma_dr_mp3* pMP3, ma_uint64 frameIndex)
+{
+    ma_dr_mp3_seek_point seekPoint;
+    ma_uint32 priorSeekPointIndex;
+    ma_uint16 iMP3Frame;
+    ma_uint64 leftoverFrames;
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    MA_DR_MP3_ASSERT(pMP3->pSeekPoints != NULL);
+    MA_DR_MP3_ASSERT(pMP3->seekPointCount > 0);
+    if (ma_dr_mp3_find_closest_seek_point(pMP3, frameIndex, &priorSeekPointIndex)) {
+        seekPoint = pMP3->pSeekPoints[priorSeekPointIndex];
+    } else {
+        seekPoint.seekPosInBytes     = 0;
+        seekPoint.pcmFrameIndex      = 0;
+        seekPoint.mp3FramesToDiscard = 0;
+        seekPoint.pcmFramesToDiscard = 0;
+    }
+    if (!ma_dr_mp3__on_seek_64(pMP3, seekPoint.seekPosInBytes, ma_dr_mp3_seek_origin_start)) {
+        return MA_FALSE;
+    }
+    ma_dr_mp3_reset(pMP3);
+    for (iMP3Frame = 0; iMP3Frame < seekPoint.mp3FramesToDiscard; ++iMP3Frame) {
+        ma_uint32 pcmFramesRead;
+        ma_dr_mp3d_sample_t* pPCMFrames;
+        pPCMFrames = NULL;
+        if (iMP3Frame == seekPoint.mp3FramesToDiscard-1) {
+            pPCMFrames = (ma_dr_mp3d_sample_t*)pMP3->pcmFrames;
+        }
+        pcmFramesRead = ma_dr_mp3_decode_next_frame_ex(pMP3, pPCMFrames);
+        if (pcmFramesRead == 0) {
+            return MA_FALSE;
+        }
+    }
+    pMP3->currentPCMFrame = seekPoint.pcmFrameIndex - seekPoint.pcmFramesToDiscard;
+    leftoverFrames = frameIndex - pMP3->currentPCMFrame;
+    return ma_dr_mp3_seek_forward_by_pcm_frames__brute_force(pMP3, leftoverFrames);
+}
+MA_API ma_bool32 ma_dr_mp3_seek_to_pcm_frame(ma_dr_mp3* pMP3, ma_uint64 frameIndex)
+{
+    if (pMP3 == NULL || pMP3->onSeek == NULL) {
+        return MA_FALSE;
+    }
+    if (frameIndex == 0) {
+        return ma_dr_mp3_seek_to_start_of_stream(pMP3);
+    }
+    if (pMP3->pSeekPoints != NULL && pMP3->seekPointCount > 0) {
+        return ma_dr_mp3_seek_to_pcm_frame__seek_table(pMP3, frameIndex);
+    } else {
+        return ma_dr_mp3_seek_to_pcm_frame__brute_force(pMP3, frameIndex);
+    }
+}
+MA_API ma_bool32 ma_dr_mp3_get_mp3_and_pcm_frame_count(ma_dr_mp3* pMP3, ma_uint64* pMP3FrameCount, ma_uint64* pPCMFrameCount)
+{
+    ma_uint64 currentPCMFrame;
+    ma_uint64 totalPCMFrameCount;
+    ma_uint64 totalMP3FrameCount;
+    if (pMP3 == NULL) {
+        return MA_FALSE;
+    }
+    if (pMP3->onSeek == NULL) {
+        return MA_FALSE;
+    }
+    currentPCMFrame = pMP3->currentPCMFrame;
+    if (!ma_dr_mp3_seek_to_start_of_stream(pMP3)) {
+        return MA_FALSE;
+    }
+    totalPCMFrameCount = 0;
+    totalMP3FrameCount = 0;
+    for (;;) {
+        ma_uint32 pcmFramesInCurrentMP3Frame;
+        pcmFramesInCurrentMP3Frame = ma_dr_mp3_decode_next_frame_ex(pMP3, NULL);
+        if (pcmFramesInCurrentMP3Frame == 0) {
+            break;
+        }
+        totalPCMFrameCount += pcmFramesInCurrentMP3Frame;
+        totalMP3FrameCount += 1;
+    }
+    if (!ma_dr_mp3_seek_to_start_of_stream(pMP3)) {
+        return MA_FALSE;
+    }
+    if (!ma_dr_mp3_seek_to_pcm_frame(pMP3, currentPCMFrame)) {
+        return MA_FALSE;
+    }
+    if (pMP3FrameCount != NULL) {
+        *pMP3FrameCount = totalMP3FrameCount;
+    }
+    if (pPCMFrameCount != NULL) {
+        *pPCMFrameCount = totalPCMFrameCount;
+    }
+    return MA_TRUE;
+}
+MA_API ma_uint64 ma_dr_mp3_get_pcm_frame_count(ma_dr_mp3* pMP3)
+{
+    ma_uint64 totalPCMFrameCount;
+    if (!ma_dr_mp3_get_mp3_and_pcm_frame_count(pMP3, NULL, &totalPCMFrameCount)) {
+        return 0;
+    }
+    return totalPCMFrameCount;
+}
+MA_API ma_uint64 ma_dr_mp3_get_mp3_frame_count(ma_dr_mp3* pMP3)
+{
+    ma_uint64 totalMP3FrameCount;
+    if (!ma_dr_mp3_get_mp3_and_pcm_frame_count(pMP3, &totalMP3FrameCount, NULL)) {
+        return 0;
+    }
+    return totalMP3FrameCount;
+}
+static void ma_dr_mp3__accumulate_running_pcm_frame_count(ma_dr_mp3* pMP3, ma_uint32 pcmFrameCountIn, ma_uint64* pRunningPCMFrameCount, float* pRunningPCMFrameCountFractionalPart)
+{
+    float srcRatio;
+    float pcmFrameCountOutF;
+    ma_uint32 pcmFrameCountOut;
+    srcRatio = (float)pMP3->mp3FrameSampleRate / (float)pMP3->sampleRate;
+    MA_DR_MP3_ASSERT(srcRatio > 0);
+    pcmFrameCountOutF = *pRunningPCMFrameCountFractionalPart + (pcmFrameCountIn / srcRatio);
+    pcmFrameCountOut  = (ma_uint32)pcmFrameCountOutF;
+    *pRunningPCMFrameCountFractionalPart = pcmFrameCountOutF - pcmFrameCountOut;
+    *pRunningPCMFrameCount += pcmFrameCountOut;
+}
+typedef struct
+{
+    ma_uint64 bytePos;
+    ma_uint64 pcmFrameIndex;
+} ma_dr_mp3__seeking_mp3_frame_info;
+MA_API ma_bool32 ma_dr_mp3_calculate_seek_points(ma_dr_mp3* pMP3, ma_uint32* pSeekPointCount, ma_dr_mp3_seek_point* pSeekPoints)
+{
+    ma_uint32 seekPointCount;
+    ma_uint64 currentPCMFrame;
+    ma_uint64 totalMP3FrameCount;
+    ma_uint64 totalPCMFrameCount;
+    if (pMP3 == NULL || pSeekPointCount == NULL || pSeekPoints == NULL) {
+        return MA_FALSE;
+    }
+    seekPointCount = *pSeekPointCount;
+    if (seekPointCount == 0) {
+        return MA_FALSE;
+    }
+    currentPCMFrame = pMP3->currentPCMFrame;
+    if (!ma_dr_mp3_get_mp3_and_pcm_frame_count(pMP3, &totalMP3FrameCount, &totalPCMFrameCount)) {
+        return MA_FALSE;
+    }
+    if (totalMP3FrameCount < MA_DR_MP3_SEEK_LEADING_MP3_FRAMES+1) {
+        seekPointCount = 1;
+        pSeekPoints[0].seekPosInBytes     = 0;
+        pSeekPoints[0].pcmFrameIndex      = 0;
+        pSeekPoints[0].mp3FramesToDiscard = 0;
+        pSeekPoints[0].pcmFramesToDiscard = 0;
+    } else {
+        ma_uint64 pcmFramesBetweenSeekPoints;
+        ma_dr_mp3__seeking_mp3_frame_info mp3FrameInfo[MA_DR_MP3_SEEK_LEADING_MP3_FRAMES+1];
+        ma_uint64 runningPCMFrameCount = 0;
+        float runningPCMFrameCountFractionalPart = 0;
+        ma_uint64 nextTargetPCMFrame;
+        ma_uint32 iMP3Frame;
+        ma_uint32 iSeekPoint;
+        if (seekPointCount > totalMP3FrameCount-1) {
+            seekPointCount = (ma_uint32)totalMP3FrameCount-1;
+        }
+        pcmFramesBetweenSeekPoints = totalPCMFrameCount / (seekPointCount+1);
+        if (!ma_dr_mp3_seek_to_start_of_stream(pMP3)) {
+            return MA_FALSE;
+        }
+        for (iMP3Frame = 0; iMP3Frame < MA_DR_MP3_SEEK_LEADING_MP3_FRAMES+1; ++iMP3Frame) {
+            ma_uint32 pcmFramesInCurrentMP3FrameIn;
+            MA_DR_MP3_ASSERT(pMP3->streamCursor >= pMP3->dataSize);
+            mp3FrameInfo[iMP3Frame].bytePos       = pMP3->streamCursor - pMP3->dataSize;
+            mp3FrameInfo[iMP3Frame].pcmFrameIndex = runningPCMFrameCount;
+            pcmFramesInCurrentMP3FrameIn = ma_dr_mp3_decode_next_frame_ex(pMP3, NULL);
+            if (pcmFramesInCurrentMP3FrameIn == 0) {
+                return MA_FALSE;
+            }
+            ma_dr_mp3__accumulate_running_pcm_frame_count(pMP3, pcmFramesInCurrentMP3FrameIn, &runningPCMFrameCount, &runningPCMFrameCountFractionalPart);
+        }
+        nextTargetPCMFrame = 0;
+        for (iSeekPoint = 0; iSeekPoint < seekPointCount; ++iSeekPoint) {
+            nextTargetPCMFrame += pcmFramesBetweenSeekPoints;
+            for (;;) {
+                if (nextTargetPCMFrame < runningPCMFrameCount) {
+                    pSeekPoints[iSeekPoint].seekPosInBytes     = mp3FrameInfo[0].bytePos;
+                    pSeekPoints[iSeekPoint].pcmFrameIndex      = nextTargetPCMFrame;
+                    pSeekPoints[iSeekPoint].mp3FramesToDiscard = MA_DR_MP3_SEEK_LEADING_MP3_FRAMES;
+                    pSeekPoints[iSeekPoint].pcmFramesToDiscard = (ma_uint16)(nextTargetPCMFrame - mp3FrameInfo[MA_DR_MP3_SEEK_LEADING_MP3_FRAMES-1].pcmFrameIndex);
+                    break;
+                } else {
+                    size_t i;
+                    ma_uint32 pcmFramesInCurrentMP3FrameIn;
+                    for (i = 0; i < MA_DR_MP3_COUNTOF(mp3FrameInfo)-1; ++i) {
+                        mp3FrameInfo[i] = mp3FrameInfo[i+1];
+                    }
+                    mp3FrameInfo[MA_DR_MP3_COUNTOF(mp3FrameInfo)-1].bytePos       = pMP3->streamCursor - pMP3->dataSize;
+                    mp3FrameInfo[MA_DR_MP3_COUNTOF(mp3FrameInfo)-1].pcmFrameIndex = runningPCMFrameCount;
+                    pcmFramesInCurrentMP3FrameIn = ma_dr_mp3_decode_next_frame_ex(pMP3, NULL);
+                    if (pcmFramesInCurrentMP3FrameIn == 0) {
+                        pSeekPoints[iSeekPoint].seekPosInBytes     = mp3FrameInfo[0].bytePos;
+                        pSeekPoints[iSeekPoint].pcmFrameIndex      = nextTargetPCMFrame;
+                        pSeekPoints[iSeekPoint].mp3FramesToDiscard = MA_DR_MP3_SEEK_LEADING_MP3_FRAMES;
+                        pSeekPoints[iSeekPoint].pcmFramesToDiscard = (ma_uint16)(nextTargetPCMFrame - mp3FrameInfo[MA_DR_MP3_SEEK_LEADING_MP3_FRAMES-1].pcmFrameIndex);
+                        break;
+                    }
+                    ma_dr_mp3__accumulate_running_pcm_frame_count(pMP3, pcmFramesInCurrentMP3FrameIn, &runningPCMFrameCount, &runningPCMFrameCountFractionalPart);
+                }
+            }
+        }
+        if (!ma_dr_mp3_seek_to_start_of_stream(pMP3)) {
+            return MA_FALSE;
+        }
+        if (!ma_dr_mp3_seek_to_pcm_frame(pMP3, currentPCMFrame)) {
+            return MA_FALSE;
+        }
+    }
+    *pSeekPointCount = seekPointCount;
+    return MA_TRUE;
+}
+MA_API ma_bool32 ma_dr_mp3_bind_seek_table(ma_dr_mp3* pMP3, ma_uint32 seekPointCount, ma_dr_mp3_seek_point* pSeekPoints)
+{
+    if (pMP3 == NULL) {
+        return MA_FALSE;
+    }
+    if (seekPointCount == 0 || pSeekPoints == NULL) {
+        pMP3->seekPointCount = 0;
+        pMP3->pSeekPoints = NULL;
+    } else {
+        pMP3->seekPointCount = seekPointCount;
+        pMP3->pSeekPoints = pSeekPoints;
+    }
+    return MA_TRUE;
+}
+static float* ma_dr_mp3__full_read_and_close_f32(ma_dr_mp3* pMP3, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount)
+{
+    ma_uint64 totalFramesRead = 0;
+    ma_uint64 framesCapacity = 0;
+    float* pFrames = NULL;
+    float temp[4096];
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    for (;;) {
+        ma_uint64 framesToReadRightNow = MA_DR_MP3_COUNTOF(temp) / pMP3->channels;
+        ma_uint64 framesJustRead = ma_dr_mp3_read_pcm_frames_f32(pMP3, framesToReadRightNow, temp);
+        if (framesJustRead == 0) {
+            break;
+        }
+        if (framesCapacity < totalFramesRead + framesJustRead) {
+            ma_uint64 oldFramesBufferSize;
+            ma_uint64 newFramesBufferSize;
+            ma_uint64 newFramesCap;
+            float* pNewFrames;
+            newFramesCap = framesCapacity * 2;
+            if (newFramesCap < totalFramesRead + framesJustRead) {
+                newFramesCap = totalFramesRead + framesJustRead;
+            }
+            oldFramesBufferSize = framesCapacity * pMP3->channels * sizeof(float);
+            newFramesBufferSize = newFramesCap   * pMP3->channels * sizeof(float);
+            if (newFramesBufferSize > (ma_uint64)MA_SIZE_MAX) {
+                break;
+            }
+            pNewFrames = (float*)ma_dr_mp3__realloc_from_callbacks(pFrames, (size_t)newFramesBufferSize, (size_t)oldFramesBufferSize, &pMP3->allocationCallbacks);
+            if (pNewFrames == NULL) {
+                ma_dr_mp3__free_from_callbacks(pFrames, &pMP3->allocationCallbacks);
+                break;
+            }
+            pFrames = pNewFrames;
+            framesCapacity = newFramesCap;
+        }
+        MA_DR_MP3_COPY_MEMORY(pFrames + totalFramesRead*pMP3->channels, temp, (size_t)(framesJustRead*pMP3->channels*sizeof(float)));
+        totalFramesRead += framesJustRead;
+        if (framesJustRead != framesToReadRightNow) {
+            break;
+        }
+    }
+    if (pConfig != NULL) {
+        pConfig->channels   = pMP3->channels;
+        pConfig->sampleRate = pMP3->sampleRate;
+    }
+    ma_dr_mp3_uninit(pMP3);
+    if (pTotalFrameCount) {
+        *pTotalFrameCount = totalFramesRead;
+    }
+    return pFrames;
+}
+static ma_int16* ma_dr_mp3__full_read_and_close_s16(ma_dr_mp3* pMP3, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount)
+{
+    ma_uint64 totalFramesRead = 0;
+    ma_uint64 framesCapacity = 0;
+    ma_int16* pFrames = NULL;
+    ma_int16 temp[4096];
+    MA_DR_MP3_ASSERT(pMP3 != NULL);
+    for (;;) {
+        ma_uint64 framesToReadRightNow = MA_DR_MP3_COUNTOF(temp) / pMP3->channels;
+        ma_uint64 framesJustRead = ma_dr_mp3_read_pcm_frames_s16(pMP3, framesToReadRightNow, temp);
+        if (framesJustRead == 0) {
+            break;
+        }
+        if (framesCapacity < totalFramesRead + framesJustRead) {
+            ma_uint64 newFramesBufferSize;
+            ma_uint64 oldFramesBufferSize;
+            ma_uint64 newFramesCap;
+            ma_int16* pNewFrames;
+            newFramesCap = framesCapacity * 2;
+            if (newFramesCap < totalFramesRead + framesJustRead) {
+                newFramesCap = totalFramesRead + framesJustRead;
+            }
+            oldFramesBufferSize = framesCapacity * pMP3->channels * sizeof(ma_int16);
+            newFramesBufferSize = newFramesCap   * pMP3->channels * sizeof(ma_int16);
+            if (newFramesBufferSize > (ma_uint64)MA_SIZE_MAX) {
+                break;
+            }
+            pNewFrames = (ma_int16*)ma_dr_mp3__realloc_from_callbacks(pFrames, (size_t)newFramesBufferSize, (size_t)oldFramesBufferSize, &pMP3->allocationCallbacks);
+            if (pNewFrames == NULL) {
+                ma_dr_mp3__free_from_callbacks(pFrames, &pMP3->allocationCallbacks);
+                break;
+            }
+            pFrames = pNewFrames;
+            framesCapacity = newFramesCap;
+        }
+        MA_DR_MP3_COPY_MEMORY(pFrames + totalFramesRead*pMP3->channels, temp, (size_t)(framesJustRead*pMP3->channels*sizeof(ma_int16)));
+        totalFramesRead += framesJustRead;
+        if (framesJustRead != framesToReadRightNow) {
+            break;
+        }
+    }
+    if (pConfig != NULL) {
+        pConfig->channels   = pMP3->channels;
+        pConfig->sampleRate = pMP3->sampleRate;
+    }
+    ma_dr_mp3_uninit(pMP3);
+    if (pTotalFrameCount) {
+        *pTotalFrameCount = totalFramesRead;
+    }
+    return pFrames;
+}
+MA_API float* ma_dr_mp3_open_and_read_pcm_frames_f32(ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, void* pUserData, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init(&mp3, onRead, onSeek, pUserData, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_f32(&mp3, pConfig, pTotalFrameCount);
+}
+MA_API ma_int16* ma_dr_mp3_open_and_read_pcm_frames_s16(ma_dr_mp3_read_proc onRead, ma_dr_mp3_seek_proc onSeek, void* pUserData, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init(&mp3, onRead, onSeek, pUserData, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_s16(&mp3, pConfig, pTotalFrameCount);
+}
+MA_API float* ma_dr_mp3_open_memory_and_read_pcm_frames_f32(const void* pData, size_t dataSize, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init_memory(&mp3, pData, dataSize, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_f32(&mp3, pConfig, pTotalFrameCount);
+}
+MA_API ma_int16* ma_dr_mp3_open_memory_and_read_pcm_frames_s16(const void* pData, size_t dataSize, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init_memory(&mp3, pData, dataSize, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_s16(&mp3, pConfig, pTotalFrameCount);
+}
+#ifndef MA_DR_MP3_NO_STDIO
+MA_API float* ma_dr_mp3_open_file_and_read_pcm_frames_f32(const char* filePath, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init_file(&mp3, filePath, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_f32(&mp3, pConfig, pTotalFrameCount);
+}
+MA_API ma_int16* ma_dr_mp3_open_file_and_read_pcm_frames_s16(const char* filePath, ma_dr_mp3_config* pConfig, ma_uint64* pTotalFrameCount, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    ma_dr_mp3 mp3;
+    if (!ma_dr_mp3_init_file(&mp3, filePath, pAllocationCallbacks)) {
+        return NULL;
+    }
+    return ma_dr_mp3__full_read_and_close_s16(&mp3, pConfig, pTotalFrameCount);
+}
+#endif
+MA_API void* ma_dr_mp3_malloc(size_t sz, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        return ma_dr_mp3__malloc_from_callbacks(sz, pAllocationCallbacks);
+    } else {
+        return ma_dr_mp3__malloc_default(sz, NULL);
+    }
+}
+MA_API void ma_dr_mp3_free(void* p, const ma_allocation_callbacks* pAllocationCallbacks)
+{
+    if (pAllocationCallbacks != NULL) {
+        ma_dr_mp3__free_from_callbacks(p, pAllocationCallbacks);
+    } else {
+        ma_dr_mp3__free_default(p, NULL);
+    }
+}
+#endif
+/* dr_mp3_c end */
+#endif  /* MA_DR_MP3_IMPLEMENTATION */
+#endif  /* MA_NO_MP3 */
+
+
+/* End globally disabled warnings. */
+#if defined(_MSC_VER)
+    #pragma warning(pop)
+#endif
+
+#endif  /* miniaudio_c */
+#endif  /* MINIAUDIO_IMPLEMENTATION */
+
+
+/*
+This software is available as a choice of the following licenses. Choose
+whichever you prefer.
+
+===============================================================================
+ALTERNATIVE 1 - Public Domain (www.unlicense.org)
+===============================================================================
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>
+
+===============================================================================
+ALTERNATIVE 2 - MIT No Attribution
+===============================================================================
+Copyright 2023 David Reid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
diff --git a/dsp/audio/cosmoaudio/test.c b/dsp/audio/cosmoaudio/test.c
new file mode 100644
index 000000000..a6c7e2375
--- /dev/null
+++ b/dsp/audio/cosmoaudio/test.c
@@ -0,0 +1,76 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "cosmoaudio.h"
+
+#define SAMPLING_RATE 44100
+#define WAVE_INTERVAL 440
+#define CHANNELS      2
+
+#ifndef M_PIf
+#define M_PIf 3.14159265358979323846f
+#endif
+
+int main() {
+
+  struct CosmoAudioOpenOptions cao = {0};
+  cao.sizeofThis = sizeof(struct CosmoAudioOpenOptions);
+  cao.deviceType = kCosmoAudioDeviceTypePlayback;
+  cao.sampleRate = SAMPLING_RATE;
+  cao.channels = CHANNELS;
+
+  int status;
+  struct CosmoAudio *ca;
+  status = cosmoaudio_open(&ca, &cao);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to open audio: %d\n", status);
+    return 1;
+  }
+
+  float buf[256 * CHANNELS];
+  for (int g = 0; g < SAMPLING_RATE;) {
+    int frames = 1;
+    status = cosmoaudio_poll(ca, NULL, &frames);
+    if (status != COSMOAUDIO_SUCCESS) {
+      fprintf(stderr, "failed to poll output: %d\n", status);
+      return 2;
+    }
+    if (frames > 256)
+      frames = 256;
+    if (frames > SAMPLING_RATE - g)
+      frames = SAMPLING_RATE - g;
+    for (int f = 0; f < frames; ++f) {
+      float t = (float)g++ / SAMPLING_RATE;
+      float s = sinf(2 * M_PIf * WAVE_INTERVAL * t);
+      for (int c = 0; c < CHANNELS; c++)
+        buf[f * CHANNELS + c] = s * .3f;
+    }
+    status = cosmoaudio_write(ca, buf, frames);
+    if (status != frames) {
+      fprintf(stderr, "failed to write output: %d\n", status);
+      return 3;
+    }
+  }
+
+  status = cosmoaudio_flush(ca);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to flush output: %d\n", status);
+    return 4;
+  }
+
+  status = cosmoaudio_close(ca);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to close audio: %d\n", status);
+    return 5;
+  }
+}
diff --git a/dsp/audio/describe.c b/dsp/audio/describe.c
new file mode 100644
index 000000000..71d6eb91d
--- /dev/null
+++ b/dsp/audio/describe.c
@@ -0,0 +1,121 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "dsp/audio/describe.h"
+#include "dsp/audio/cosmoaudio/cosmoaudio.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/macros.h"
+
+#define append(...) o += ksnprintf(buf + o, n - o, __VA_ARGS__)
+
+const char *cosmoaudio_describe_status(char *buf, int n, int status) {
+  switch (status) {
+    case COSMOAUDIO_SUCCESS:
+      return "COSMOAUDIO_SUCCESS";
+    case COSMOAUDIO_ERROR:
+      return "COSMOAUDIO_ERROR";
+    case COSMOAUDIO_EINVAL:
+      return "COSMOAUDIO_EINVAL";
+    case COSMOAUDIO_ELINK:
+      return "COSMOAUDIO_ELINK";
+    case COSMOAUDIO_ENOBUF:
+      return "COSMOAUDIO_ENOBUF";
+    default:
+      ksnprintf(buf, n, "%d", status);
+      return buf;
+  }
+}
+
+const char *cosmoaudio_describe_open_options(
+    char *buf, int n, const struct CosmoAudioOpenOptions *options) {
+  int o = 0;
+  char b128[128];
+  bool gotsome = false;
+  if (!options)
+    return "NULL";
+  if (kisdangerous(options)) {
+    ksnprintf(buf, n, "%p", options);
+    return buf;
+  }
+  append("{");
+
+  if (options->sampleRate) {
+    if (gotsome)
+      append(", ");
+    append(".sampleRate=%d", options->sampleRate);
+    gotsome = true;
+  }
+
+  if (options->channels) {
+    if (gotsome)
+      append(", ");
+    append(".channels=%d", options->channels);
+    gotsome = true;
+  }
+
+  if (options->deviceType) {
+    if (gotsome)
+      append(", ");
+    static struct DescribeFlags kDeviceType[] = {
+        {kCosmoAudioDeviceTypeDuplex, "Duplex"},      //
+        {kCosmoAudioDeviceTypeCapture, "Capture"},    //
+        {kCosmoAudioDeviceTypePlayback, "Playback"},  //
+    };
+    append(".deviceType=%s",
+           _DescribeFlags(b128, 128, kDeviceType, ARRAYLEN(kDeviceType),
+                          "kCosmoAudioDeviceType", options->deviceType));
+    gotsome = true;
+  }
+
+  if (options->bufferFrames) {
+    if (gotsome)
+      append(", ");
+    append(".bufferFrames=%d", options->bufferFrames);
+    gotsome = true;
+  }
+
+  if (options->debugLog) {
+    if (gotsome)
+      append(", ");
+    append(".debugLog=%d", options->debugLog);
+    gotsome = true;
+  }
+
+  if (options->sizeofThis) {
+    if (gotsome)
+      append(", ");
+    append(".sizeofThis=%d", options->sizeofThis);
+    gotsome = true;
+  }
+
+  append("}");
+  return buf;
+}
+
+const char *cosmoaudio_describe_poll_frames(char *buf, int n,
+                                            int *in_out_frames) {
+  if (!in_out_frames)
+    return "NULL";
+  if (kisdangerous(in_out_frames)) {
+    ksnprintf(buf, n, "%p", in_out_frames);
+    return buf;
+  }
+  ksnprintf(buf, n, "[%d]", *in_out_frames);
+  return buf;
+}
diff --git a/dsp/audio/describe.h b/dsp/audio/describe.h
new file mode 100644
index 000000000..28f614574
--- /dev/null
+++ b/dsp/audio/describe.h
@@ -0,0 +1,12 @@
+#ifndef COSMOPOLITAN_DSP_AUDIO_DESCRIBE_H_
+#define COSMOPOLITAN_DSP_AUDIO_DESCRIBE_H_
+#include "dsp/audio/cosmoaudio/cosmoaudio.h"
+COSMOPOLITAN_C_START_
+
+const char *cosmoaudio_describe_status(char *, int, int);
+const char *cosmoaudio_describe_open_options(
+    char *, int, const struct CosmoAudioOpenOptions *);
+const char *cosmoaudio_describe_poll_frames(char *, int, int *);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_DSP_AUDIO_DESCRIBE_H_ */
diff --git a/dsp/core/c161.h b/dsp/core/c161.h
index 40753eefa..ddadcaa7f 100644
--- a/dsp/core/c161.h
+++ b/dsp/core/c161.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C161_H_
 #define COSMOPOLITAN_DSP_CORE_C161_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #define EXTRA_SHARP 2
 
diff --git a/dsp/core/c161s.h b/dsp/core/c161s.h
index 325278ee2..cd7018727 100644
--- a/dsp/core/c161s.h
+++ b/dsp/core/c161s.h
@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_DSP_CORE_C161S_H_
 #define COSMOPOLITAN_DSP_CORE_C161S_H_
 #include "dsp/core/c161.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 __funline signed char C161S(signed char al, signed char bl, signed char cl) {
   short ax, bx, cx;
diff --git a/dsp/core/core.h b/dsp/core/core.h
index d054201cb..2619d1af6 100644
--- a/dsp/core/core.h
+++ b/dsp/core/core.h
@@ -9,14 +9,13 @@ int mulaw(int);
 int unmulaw(int);
 void *double2byte(long, const void *, double, double) vallocesque;
 void *byte2double(long, const void *, double, double) vallocesque;
-void *dct(float[restrict hasatleast 8][8], unsigned, float, float, float, float,
-          float);
-void *dctjpeg(float[restrict hasatleast 8][8], unsigned);
+void *dct(float[hasatleast 8][8], unsigned, float, float, float, float, float);
+void *dctjpeg(float[hasatleast 8][8], unsigned);
 double det3(const double[3][3]) nosideeffect;
-void *inv3(double[restrict 3][3], const double[restrict 3][3], double);
-void *matmul3(double[restrict 3][3], const double[3][3], const double[3][3]);
-void *vmatmul3(double[restrict 3], const double[3], const double[3][3]);
-void *matvmul3(double[restrict 3], const double[3][3], const double[3]);
+void *inv3(double[3][3], const double[3][3], double);
+void *matmul3(double[3][3], const double[3][3], const double[3][3]);
+void *vmatmul3(double[3], const double[3], const double[3][3]);
+void *matvmul3(double[3], const double[3][3], const double[3]);
 double rgb2stdtv(double) pureconst;
 double rgb2lintv(double) pureconst;
 double rgb2stdpc(double, double) pureconst;
diff --git a/dsp/core/dct.c b/dsp/core/dct.c
index 68d5c3bdc..5647ffefb 100644
--- a/dsp/core/dct.c
+++ b/dsp/core/dct.c
@@ -65,8 +65,8 @@
  *
  * @cost ~100ns
  */
-void *dct(float M[restrict hasatleast 8][8], unsigned stride, float c0,
-          float c1, float c2, float c3, float c4) {
+void *dct(float M[hasatleast 8][8], unsigned stride, float c0, float c1,
+          float c2, float c3, float c4) {
   unsigned y, x;
   for (y = 0; y < stride * 8; y += stride) {
     DCT(M[y][0], M[y][1], M[y][2], M[y][3], M[y][4], M[y][5], M[y][6], M[y][7],
@@ -79,7 +79,7 @@ void *dct(float M[restrict hasatleast 8][8], unsigned stride, float c0,
   return M;
 }
 
-void *dctjpeg(float M[restrict hasatleast 8][8], unsigned stride) {
+void *dctjpeg(float M[hasatleast 8][8], unsigned stride) {
   return dct(M, stride, .707106781f, .382683433f, .541196100f, 1.306562965f,
              .707106781f);
 }
diff --git a/dsp/core/double2byte.c b/dsp/core/double2byte.c
index 1ac894e9b..95bcad14c 100644
--- a/dsp/core/double2byte.c
+++ b/dsp/core/double2byte.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/core.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 
diff --git a/dsp/core/float2short.c b/dsp/core/float2short.c
index 2c35fb17e..5efbcb4ee 100644
--- a/dsp/core/float2short.c
+++ b/dsp/core/float2short.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/str/str.h"
 
diff --git a/dsp/core/getintegercoefficients.c b/dsp/core/getintegercoefficients.c
index b8b377d3d..fc8cd77bb 100644
--- a/dsp/core/getintegercoefficients.c
+++ b/dsp/core/getintegercoefficients.c
@@ -20,7 +20,7 @@
 #include "libc/assert.h"
 #include "libc/dce.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/str/str.h"
 
diff --git a/dsp/core/getintegercoefficients8.c b/dsp/core/getintegercoefficients8.c
index 1ba9e5081..defafc058 100644
--- a/dsp/core/getintegercoefficients8.c
+++ b/dsp/core/getintegercoefficients8.c
@@ -19,7 +19,7 @@
 #include "dsp/core/core.h"
 #include "dsp/core/q.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/str/str.h"
 
diff --git a/dsp/core/half.h b/dsp/core/half.h
index 0955ddfba..0165ad76b 100644
--- a/dsp/core/half.h
+++ b/dsp/core/half.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_CORE_HALF_H_
 #define COSMOPOLITAN_DSP_CORE_HALF_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /**
  * Divides integer in half w/ rounding.
diff --git a/dsp/core/inv3.c b/dsp/core/inv3.c
index 548da5299..7e4828068 100644
--- a/dsp/core/inv3.c
+++ b/dsp/core/inv3.c
@@ -30,7 +30,7 @@
  * @define 𝐀⁻¹=𝐁 such that 𝐀×𝐁=𝐁×𝐀=𝐈ₙ
  * @see det3()
  */
-void *inv3(double B[restrict 3][3], const double A[restrict 3][3], double d) {
+void *inv3(double B[3][3], const double A[3][3], double d) {
   d = d ? 1 / d : NAN;
   B[0][0] = (A[1][1] * A[2][2] - A[2][1] * A[1][2]) * d;
   B[0][1] = (A[2][1] * A[0][2] - A[0][1] * A[2][2]) * d;
diff --git a/dsp/core/ks8.h b/dsp/core/ks8.h
index 100b3decc..4a0c81f72 100644
--- a/dsp/core/ks8.h
+++ b/dsp/core/ks8.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_DSP_CORE_KS8_H_
 #define COSMOPOLITAN_DSP_CORE_KS8_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /**
  * Performs 16-bit scaled rounded madd w/ eight coefficients or fewer.
diff --git a/dsp/core/kss8.h b/dsp/core/kss8.h
index 54bff129c..c86ae1a85 100644
--- a/dsp/core/kss8.h
+++ b/dsp/core/kss8.h
@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_DSP_CORE_KSS8_H_
 #define COSMOPOLITAN_DSP_CORE_KSS8_H_
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /**
  * Performs 16-bit scaled rounded saturated madd w/ eight coefficients or fewer.
diff --git a/dsp/core/matmul3.c b/dsp/core/matmul3.c
index 6b309f4ce..e6a06448f 100644
--- a/dsp/core/matmul3.c
+++ b/dsp/core/matmul3.c
@@ -22,8 +22,7 @@
 /**
  * Multiplies 3×3 matrices.
  */
-void *matmul3(double R[restrict 3][3], const double A[3][3],
-              const double B[3][3]) {
+void *matmul3(double R[3][3], const double A[3][3], const double B[3][3]) {
   int i, j, k;
   memset(R, 0, sizeof(double) * 3 * 3);
   for (i = 0; i < 3; ++i) {
diff --git a/dsp/core/matvmul3.c b/dsp/core/matvmul3.c
index 197d1ec3b..7bc99864a 100644
--- a/dsp/core/matvmul3.c
+++ b/dsp/core/matvmul3.c
@@ -23,7 +23,7 @@
  *
  * @see vmatmul3() for noncommutative corollary
  */
-void *matvmul3(double R[restrict 3], const double M[3][3], const double V[3]) {
+void *matvmul3(double R[3], const double M[3][3], const double V[3]) {
   R[0] = V[0] * M[0][0] + V[1] * M[0][1] + V[2] * M[0][2];
   R[1] = V[0] * M[1][0] + V[1] * M[1][1] + V[2] * M[1][2];
   R[2] = V[0] * M[2][0] + V[1] * M[2][1] + V[2] * M[2][2];
diff --git a/dsp/core/q.h b/dsp/core/q.h
index 3d122bf49..c23fa5f30 100644
--- a/dsp/core/q.h
+++ b/dsp/core/q.h
@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_DSP_CORE_Q_H_
 #define COSMOPOLITAN_DSP_CORE_Q_H_
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 
 /**
diff --git a/dsp/core/sad16x8n.c b/dsp/core/sad16x8n.c
index 802836164..c8e6f4fff 100644
--- a/dsp/core/sad16x8n.c
+++ b/dsp/core/sad16x8n.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/core.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "third_party/aarch64/arm_neon.internal.h"
 #include "third_party/intel/emmintrin.internal.h"
 
diff --git a/dsp/core/scalevolume.c b/dsp/core/scalevolume.c
index 4586aeb22..2ca6e479f 100644
--- a/dsp/core/scalevolume.c
+++ b/dsp/core/scalevolume.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/core.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 
 /**
diff --git a/dsp/core/vmatmul3.c b/dsp/core/vmatmul3.c
index fcf58bbaf..ed377b4d4 100644
--- a/dsp/core/vmatmul3.c
+++ b/dsp/core/vmatmul3.c
@@ -23,7 +23,7 @@
  *
  * @see matvmul3() for noncommutative corollary
  */
-void *vmatmul3(double R[restrict 3], const double V[3], const double M[3][3]) {
+void *vmatmul3(double R[3], const double V[3], const double M[3][3]) {
   R[0] = V[0] * M[0][0] + V[1] * M[1][0] + V[2] * M[2][0];
   R[1] = V[0] * M[0][1] + V[1] * M[1][1] + V[2] * M[2][1];
   R[2] = V[0] * M[0][2] + V[1] * M[1][2] + V[2] * M[2][2];
diff --git a/dsp/mpeg/.clang-format b/dsp/mpeg/.clang-format
new file mode 100644
index 000000000..47a38a93f
--- /dev/null
+++ b/dsp/mpeg/.clang-format
@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: Never
diff --git a/dsp/mpeg/BUILD.mk b/dsp/mpeg/BUILD.mk
index a16089eaa..be219ca23 100644
--- a/dsp/mpeg/BUILD.mk
+++ b/dsp/mpeg/BUILD.mk
@@ -25,18 +25,13 @@ DSP_MPEG_A_CHECKS =				\
 
 DSP_MPEG_A_DIRECTDEPS =				\
 	LIBC_CALLS				\
-	LIBC_FMT				\
 	LIBC_INTRIN				\
-	LIBC_LOG				\
-	LIBC_LOG				\
 	LIBC_MEM				\
 	LIBC_NEXGEN32E				\
-	LIBC_RUNTIME				\
 	LIBC_STDIO				\
 	LIBC_STR				\
-	LIBC_SYSV				\
 	LIBC_TINYMATH				\
-	THIRD_PARTY_COMPILER_RT
+	THIRD_PARTY_COMPILER_RT			\
 
 DSP_MPEG_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x))))
@@ -49,9 +44,10 @@ $(DSP_MPEG_A).pkg:				\
 		$(DSP_MPEG_A_OBJS)		\
 		$(foreach x,$(DSP_MPEG_A_DIRECTDEPS),$($(x)_A).pkg)
 
-o/$(MODE)/dsp/mpeg/clamp4int256-k8.o: private	\
+o/$(MODE)/dsp/mpeg/pl_mpeg.o: private		\
 		CFLAGS +=			\
-			-Os
+			-ffunction-sections	\
+			-fdata-sections
 
 DSP_MPEG_LIBS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)))
 DSP_MPEG_SRCS = $(foreach x,$(DSP_MPEG_ARTIFACTS),$($(x)_SRCS))
diff --git a/dsp/mpeg/README.cosmo b/dsp/mpeg/README.cosmo
new file mode 100644
index 000000000..1c1991af4
--- /dev/null
+++ b/dsp/mpeg/README.cosmo
@@ -0,0 +1,17 @@
+DESCRIPTION
+
+  pl_mpeg lets you decode .mpg files
+
+ORIGIN
+
+  https://github.com/phoboslab/pl_mpeg/
+  9e40dd6536269d788728e32c39bfacf2ab7a0866
+
+LICENSE
+
+  MIT
+
+LOCAL CHANGES
+
+  - Added API for extracting pixel aspect ratio
+    https://github.com/phoboslab/pl_mpeg/pull/42
diff --git a/dsp/mpeg/README.md b/dsp/mpeg/README.md
new file mode 100755
index 000000000..4892e7026
--- /dev/null
+++ b/dsp/mpeg/README.md
@@ -0,0 +1,68 @@
+# PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer
+
+Single-file MIT licensed library for C/C++
+
+See [pl_mpeg.h](https://github.com/phoboslab/pl_mpeg/blob/master/pl_mpeg.h) for
+the documentation.
+
+
+## Why?
+
+This is meant as a simple way to get video playback into your app or game. Other
+solutions, such as ffmpeg require huge libraries and a lot of glue code.
+
+MPEG1 is an old and inefficient codec, but it's still good enough for many use
+cases. All patents related to MPEG1 and MP2 have expired, so it's completely
+free now.
+
+This library does not make use of any SIMD instructions, but because of
+the relative simplicity of the codec it still manages to decode 4k60fps video
+on a single CPU core (on my i7-6700k at least).
+
+## Compilation on Linux
+
+Use a GCC invocation like the following to build the example `pl_mpeg_player`
+program:
+
+```shell
+gcc -o pl_mpeg_player pl_mpeg_player.c $(pkg-config --cflags --libs sdl2 glew)
+```
+
+## Example Usage
+
+- [pl_mpeg_extract_frames.c](https://github.com/phoboslab/pl_mpeg/blob/master/pl_mpeg_extract_frames.c)
+extracts all frames from a video and saves them as PNG.
+ - [pl_mpeg_player.c](https://github.com/phoboslab/pl_mpeg/blob/master/pl_mpeg_player.c)
+implements a video player using SDL2 and OpenGL for rendering.
+
+
+
+## Encoding for PL_MPEG
+
+Most [MPEG-PS](https://en.wikipedia.org/wiki/MPEG_program_stream) (`.mpg`) files
+containing MPEG1 Video ("mpeg1") and MPEG1 Audio Layer II ("mp2") streams should
+work with PL_MPEG. Note that `.mpg` files can also contain MPEG2 Video, which is
+not supported by this library.
+
+You can encode video in a suitable format using ffmpeg:
+
+```
+ffmpeg -i input.mp4 -c:v mpeg1video -q:v 0 -c:a mp2 -format mpeg output.mpg
+```
+
+`-q:v` sets a fixed video quality with a variable bitrate, where `0` is the
+highest. You may use `-b:v` to set a fixed bitrate instead; e.g.
+`-b:v 2000k` for 2000 kbit/s. Please refer to the
+[ffmpeg documentation](http://ffmpeg.org/ffmpeg.html#Options) for more details.
+
+If you just want to quickly test the library, try this file:
+
+https://phoboslab.org/files/bjork-all-is-full-of-love.mpg
+
+
+## Limitations
+
+- no error reporting. PL_MPEG will silently ignore any invalid data.
+- the pts (presentation time stamp) for packets in the MPEG-PS container is
+ignored. This may cause sync issues with some files.
+- bugs, probably.
diff --git a/dsp/mpeg/README.txt b/dsp/mpeg/README.txt
deleted file mode 100644
index b8263c03c..000000000
--- a/dsp/mpeg/README.txt
+++ /dev/null
@@ -1,92 +0,0 @@
-PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer
-Dominic Szablewski - https://phoboslab.org
-
--- Synopsis
-
-// This function gets called for each decoded video frame
-void my_video_callback(plm_t *plm, plm_frame_t *frame, void *user) {
-	// Do something with frame->y.data, frame->cr.data, frame->cb.data
-}
-
-// This function gets called for each decoded audio frame
-void my_audio_callback(plm_t *plm, plm_samples_t *frame, void *user) {
-	// Do something with samples->interleaved
-}
-
-// Load a .mpg (MPEG Program Stream) file
-plm_t *plm = plm_create_with_filename("some-file.mpg");
-
-// Install the video & audio decode callbacks
-plm_set_video_decode_callback(plm, my_video_callback, my_data);
-plm_set_audio_decode_callback(plm, my_audio_callback, my_data);
-
-
-// Decode
-do {
-	plm_decode(plm, time_since_last_call);
-} while (!plm_has_ended(plm));
-
-// All done
-plm_destroy(plm);
-
-
-
--- Documentation
-
-This library provides several interfaces to load, demux and decode MPEG video
-and audio data. A high-level API combines the demuxer, video & audio decoders
-in an easy to use wrapper.
-
-Lower-level APIs for accessing the demuxer, video decoder and audio decoder,
-as well as providing different data sources are also available.
-
-Interfaces are written in an object orientet style, meaning you create object
-instances via various different constructor functions (plm_*create()),
-do some work on them and later dispose them via plm_*destroy().
-
-plm_*		-- the high-level interface, combining demuxer and decoders
-plm_buffer_* -- the data source used by all interfaces
-plm_demux_*  -- the MPEG-PS demuxer
-plm_video_*  -- the MPEG1 Video ("mpeg1") decoder
-plm_audio_*  -- the MPEG1 Audio Layer II ("mp2") decoder
-
-
-This library uses malloc(), realloc() and free() to manage memory. Typically
-all allocation happens up-front when creating the interface. However, the
-default buffer size may be too small for certain inputs. In these cases plmpeg
-will realloc() the buffer with a larger size whenever needed. You can configure
-the default buffer size by defining PLM_BUFFER_DEFAULT_SIZE *before*
-including this library.
-
-With the high-level interface you have two options to decode video & audio:
-
-1) Use plm_decode() and just hand over the delta time since the last call.
-It will decode everything needed and call your callbacks (specified through
-plm_set_{video|audio}_decode_callback()) any number of times.
-
-2) Use plm_decode_video() and plm_decode_audio() to decode exactly one
-frame of video or audio data at a time. How you handle the synchronization of
-both streams is up to you.
-
-If you only want to decode video *or* audio through these functions, you should
-disable the other stream (plm_set_{video|audio}_enabled(false))
-
-
-Video data is decoded into a struct with all 3 planes (Y, Cr, Cb) stored in
-separate buffers. You can either convert this to RGB on the CPU (slow) via the
-plm_frame_to_rgb() function or do it on the GPU with the following matrix:
-
-mat4 rec601 = mat4(
-	1.16438,  0.00000,  1.59603, -0.87079,
-	1.16438, -0.39176, -0.81297,  0.52959,
-	1.16438,  2.01723,  0.00000, -1.08139,
-	0, 0, 0, 1
-);
-gl_FragColor = vec4(y, cb, cr, 1.0) * rec601;
-
-Audio data is decoded into a struct with either one single float array with the
-samples for the left and right channel interleaved, or if the
-PLM_AUDIO_SEPARATE_CHANNELS is defined *before* including this library, into
-two separate float arrays - one for each channel.
-
-See below for detailed the API documentation.
diff --git a/dsp/mpeg/blockset.h b/dsp/mpeg/blockset.h
deleted file mode 100644
index 14d0f36b2..000000000
--- a/dsp/mpeg/blockset.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_
-#define COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_
-
-#define PLM_BLOCK_SET(DEST, DEST_INDEX, DEST_WIDTH, SOURCE_INDEX, \
-                      SOURCE_WIDTH, BLOCK_SIZE, OP)               \
-  do {                                                            \
-    int dest_scan = DEST_WIDTH - BLOCK_SIZE;                      \
-    int source_scan = SOURCE_WIDTH - BLOCK_SIZE;                  \
-    for (int y = 0; y < BLOCK_SIZE; y++) {                        \
-      for (int x = 0; x < BLOCK_SIZE; x++) {                      \
-        DEST[DEST_INDEX] = OP;                                    \
-        SOURCE_INDEX++;                                           \
-        DEST_INDEX++;                                             \
-      }                                                           \
-      SOURCE_INDEX += source_scan;                                \
-      DEST_INDEX += dest_scan;                                    \
-    }                                                             \
-  } while (false)
-
-#endif /* COSMOPOLITAN_DSP_MPEG_BLOCKSET_H_ */
diff --git a/dsp/mpeg/buffer.c b/dsp/mpeg/buffer.c
deleted file mode 100644
index f0cb0de38..000000000
--- a/dsp/mpeg/buffer.c
+++ /dev/null
@@ -1,153 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=4 sw=4 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND                       │
-│  NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/buffer.h"
-#include "dsp/mpeg/mpeg.h"
-#include "libc/calls/calls.h"
-#include "libc/log/check.h"
-#include "libc/mem/mem.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/madv.h"
-__static_yoink("pl_mpeg_notice");
-
-/* clang-format off */
-// -----------------------------------------------------------------------------
-// plm_buffer implementation
-
-plm_buffer_t *plm_buffer_create_with_filename(const char *filename) {
-	FILE *fh = fopen(filename, "rb");
-	if (!fh) {
-		return NULL;
-	}
-	fadvise(fileno(fh), 0, 0, MADV_SEQUENTIAL);
-	return plm_buffer_create_with_file(fh, true);
-}
-
-plm_buffer_t *plm_buffer_create_with_file(FILE *fh, int close_when_done) {
-	plm_buffer_t *b;
-	b = plm_buffer_create_with_capacity(PLM_BUFFER_DEFAULT_SIZE);
-	b->fh = fh;
-	b->close_when_done = close_when_done;
-	b->mode = PLM_BUFFER_MODE_FILE;
-	plm_buffer_set_load_callback(b, plm_buffer_load_file_callback, NULL);
-	return b;
-}
-
-plm_buffer_t *plm_buffer_create_with_memory(unsigned char *bytes, size_t length, int free_when_done) {
-	plm_buffer_t *b;
-	b = memalign(_Alignof(plm_buffer_t), sizeof(plm_buffer_t));
-	memset(b, 0, sizeof(plm_buffer_t));
-	b->capacity = length;
-	b->length = length;
-	b->free_when_done = free_when_done;
-	b->bytes = bytes;
-	b->mode = PLM_BUFFER_MODE_FIXED_MEM;
-	return b;
-}
-
-plm_buffer_t * plm_buffer_create_with_capacity(size_t capacity) {
-	plm_buffer_t *b;
-	b = memalign(_Alignof(plm_buffer_t), sizeof(plm_buffer_t));
-	memset(b, 0, sizeof(plm_buffer_t));
-	b->capacity = capacity;
-	b->free_when_done = true;
-	b->bytes = (unsigned char *)malloc(capacity);
-	b->mode = PLM_BUFFER_MODE_DYNAMIC_MEM;
-	return b;
-}
-
-void plm_buffer_destroy(plm_buffer_t *self) {
-	if (self->fh && self->close_when_done) {
-		fclose(self->fh);
-	}
-	if (self->free_when_done) {
-		free(self->bytes);
-	}
-	free(self);
-}
-
-size_t plm_buffer_write(plm_buffer_t *self, unsigned char *bytes, size_t length) {
-	if (self->mode == PLM_BUFFER_MODE_FIXED_MEM) {
-		return 0;
-	}
-	// This should be a ring buffer, but instead it just shifts all unread data
-	// to the beginning of the buffer and appends new data at the end. Seems
-	// to be good enough.
-	plm_buffer_discard_read_bytes(self);
-	// Do we have to resize to fit the new data?
-	size_t bytes_available = self->capacity - self->length;
-	if (bytes_available < length) {
-		size_t new_size = self->capacity;
-		do {
-			new_size *= 2;
-		} while (new_size - self->length < length);
-		self->bytes = (unsigned char *)realloc(self->bytes, new_size);
-		self->capacity = new_size;
-	}
-	memcpy(self->bytes + self->length, bytes, length);
-	self->length += length;
-	return length;
-}
-
-void plm_buffer_set_load_callback(plm_buffer_t *self, plm_buffer_load_callback fp, void *user) {
-	self->load_callback = fp;
-	self->load_callback_user_data = user;
-}
-
-void plm_buffer_rewind(plm_buffer_t *self) {
-	if (self->fh) {
-		fseek(self->fh, 0, SEEK_SET);
-		self->length = 0;
-	}
-	if (self->mode != PLM_BUFFER_MODE_FIXED_MEM) {
-		self->length = 0;
-	}
-	self->bit_index = 0;
-}
-
-void plm_buffer_discard_read_bytes(plm_buffer_t *self) {
-	size_t byte_pos = self->bit_index >> 3;
-	if (byte_pos == self->length) {
-		self->bit_index = 0;
-		self->length = 0;
-	}
-	else if (byte_pos > 0) {
-		memmove(self->bytes, self->bytes + byte_pos, self->length - byte_pos);
-		self->bit_index -= byte_pos << 3;
-		self->length -= byte_pos;
-	}
-}
-
-void plm_buffer_load_file_callback(plm_buffer_t *self, void *user) {
-	plm_buffer_discard_read_bytes(self);
-	unsigned bytes_available = self->capacity - self->length;
-	unsigned bytes_read = fread(self->bytes + self->length, 1, bytes_available, self->fh);
-	self->length += bytes_read;
-}
diff --git a/dsp/mpeg/buffer.h b/dsp/mpeg/buffer.h
deleted file mode 100644
index e841535fb..000000000
--- a/dsp/mpeg/buffer.h
+++ /dev/null
@@ -1,160 +0,0 @@
-#ifndef COSMOPOLITAN_DSP_MPEG_BUFFER_H_
-#define COSMOPOLITAN_DSP_MPEG_BUFFER_H_
-#include "dsp/mpeg/mpeg.h"
-COSMOPOLITAN_C_START_
-
-enum plm_buffer_mode {
-  PLM_BUFFER_MODE_FILE,
-  PLM_BUFFER_MODE_FIXED_MEM,
-  PLM_BUFFER_MODE_DYNAMIC_MEM
-};
-
-typedef struct plm_buffer_t {
-  unsigned bit_index;
-  unsigned capacity;
-  unsigned length;
-  int free_when_done;
-  int close_when_done;
-  FILE *fh;
-  plm_buffer_load_callback load_callback;
-  void *load_callback_user_data;
-  unsigned char *bytes;
-  enum plm_buffer_mode mode;
-} plm_buffer_t;
-
-typedef struct {
-  int16_t index;
-  int16_t value;
-} plm_vlc_t;
-
-typedef struct {
-  int16_t index;
-  uint16_t value;
-} plm_vlc_uint_t;
-
-/* bool plm_buffer_has(plm_buffer_t *, size_t); */
-/* int plm_buffer_read(plm_buffer_t *, int); */
-/* void plm_buffer_align(plm_buffer_t *); */
-/* void plm_buffer_skip(plm_buffer_t *, size_t); */
-/* int plm_buffer_skip_bytes(plm_buffer_t *, unsigned char); */
-/* int plm_buffer_next_start_code(plm_buffer_t *); */
-/* int plm_buffer_find_start_code(plm_buffer_t *, int); */
-/* int plm_buffer_no_start_code(plm_buffer_t *); */
-/* int16_t plm_buffer_read_vlc(plm_buffer_t *, const plm_vlc_t *); */
-/* uint16_t plm_buffer_read_vlc_uint(plm_buffer_t *, const plm_vlc_uint_t *); */
-
-void plm_buffer_discard_read_bytes(plm_buffer_t *);
-relegated void plm_buffer_load_file_callback(plm_buffer_t *, void *);
-
-forceinline bool plm_buffer_has(plm_buffer_t *b, size_t bits) {
-  unsigned have;
-  have = b->length;
-  have <<= 3;
-  have -= b->bit_index;
-  if (bits <= have) {
-    return true;
-  } else {
-    if (b->load_callback) {
-      b->load_callback(b, b->load_callback_user_data);
-      return ((b->length << 3) - b->bit_index) >= bits;
-    } else {
-      return false;
-    }
-  }
-}
-
-forceinline int plm_buffer_read(plm_buffer_t *self, int count) {
-  if (!plm_buffer_has(self, count))
-    return 0;
-  int value = 0;
-  while (count) {
-    int current_byte = self->bytes[self->bit_index >> 3];
-    int remaining = 8 - (self->bit_index & 7);         // Remaining bits in byte
-    int read = remaining < count ? remaining : count;  // Bits in self run
-    int shift = remaining - read;
-    int mask = (0xff >> (8 - read));
-    value = (value << read) | ((current_byte & (mask << shift)) >> shift);
-    self->bit_index += read;
-    count -= read;
-  }
-  return value;
-}
-
-forceinline void plm_buffer_align(plm_buffer_t *self) {
-  self->bit_index = ((self->bit_index + 7) >> 3) << 3;
-}
-
-forceinline void plm_buffer_skip(plm_buffer_t *self, size_t count) {
-  if (plm_buffer_has(self, count)) {
-    self->bit_index += count;
-  }
-}
-
-forceinline int plm_buffer_skip_bytes(plm_buffer_t *self, unsigned char v) {
-  unsigned skipped;
-  plm_buffer_align(self);
-  skipped = 0;
-  while (plm_buffer_has(self, 8)) {
-    if (v == self->bytes[self->bit_index >> 3]) {
-      self->bit_index += 8;
-      ++skipped;
-    } else {
-      break;
-    }
-  }
-  return skipped;
-}
-
-forceinline int plm_buffer_next_start_code(plm_buffer_t *self) {
-  plm_buffer_align(self);
-  while (plm_buffer_has(self, (5 << 3))) {
-    size_t byte_index = (self->bit_index) >> 3;
-    if (self->bytes[byte_index] == 0x00 &&
-        self->bytes[byte_index + 1] == 0x00 &&
-        self->bytes[byte_index + 2] == 0x01) {
-      self->bit_index = (byte_index + 4) << 3;
-      return self->bytes[byte_index + 3];
-    }
-    self->bit_index += 8;
-  }
-  self->bit_index = (self->length << 3);
-  return -1;
-}
-
-forceinline int plm_buffer_find_start_code(plm_buffer_t *self, int code) {
-  int current = 0;
-  while (true) {
-    current = plm_buffer_next_start_code(self);
-    if (current == code || current == -1) {
-      return current;
-    }
-  }
-  return -1;
-}
-
-forceinline int plm_buffer_no_start_code(plm_buffer_t *self) {
-  if (!plm_buffer_has(self, (5 << 3))) {
-    return false;
-  }
-  size_t byte_index = ((self->bit_index + 7) >> 3);
-  return !(self->bytes[byte_index] == 0x00 &&
-           self->bytes[byte_index + 1] == 0x00 &&
-           self->bytes[byte_index + 2] == 0x01);
-}
-
-forceinline int16_t plm_buffer_read_vlc(plm_buffer_t *self,
-                                        const plm_vlc_t *table) {
-  plm_vlc_t state = {0, 0};
-  do {
-    state = table[state.index + plm_buffer_read(self, 1)];
-  } while (state.index > 0);
-  return state.value;
-}
-
-forceinline uint16_t plm_buffer_read_vlc_uint(plm_buffer_t *self,
-                                              const plm_vlc_uint_t *table) {
-  return (uint16_t)plm_buffer_read_vlc(self, (plm_vlc_t *)table);
-}
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_DSP_MPEG_BUFFER_H_ */
diff --git a/dsp/mpeg/clamp4int256-core.S b/dsp/mpeg/clamp4int256-core.S
deleted file mode 100644
index 3cd6797b1..000000000
--- a/dsp/mpeg/clamp4int256-core.S
+++ /dev/null
@@ -1,30 +0,0 @@
-/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
-
-clamp4int256$core:
-	.leafprologue
-	pxor	%xmm1,%xmm1
-	pmaxsd	%xmm1,%xmm0
-	pminsd	0f(%rip),%xmm0
-	.leafepilogue
-	.endfn	clamp4int256$core,globl
-
-	.rodata.cst16
-0:	.long	255,255,255,255
diff --git a/dsp/mpeg/demux.c b/dsp/mpeg/demux.c
deleted file mode 100644
index 66eff844a..000000000
--- a/dsp/mpeg/demux.c
+++ /dev/null
@@ -1,203 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=4 sw=4 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND                       │
-│  NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/demux.h"
-#include "dsp/mpeg/buffer.h"
-#include "dsp/mpeg/mpeg.h"
-#include "libc/mem/mem.h"
-#include "libc/str/str.h"
-__static_yoink("pl_mpeg_notice");
-
-/* clang-format off */
-// ----------------------------------------------------------------------------
-// plm_demux implementation
-
-plm_demux_t *plm_demux_create(plm_buffer_t *buffer, int destroy_when_done) {
-	plm_demux_t *self = (plm_demux_t *)malloc(sizeof(plm_demux_t));
-	memset(self, 0, sizeof(plm_demux_t));
-
-	self->buffer = buffer;
-	self->destroy_buffer_when_done = destroy_when_done;
-
-	if (plm_buffer_find_start_code(self->buffer, START_PACK) != -1) {
-		plm_demux_decode_pack_header(self);
-	}
-	if (plm_buffer_find_start_code(self->buffer, START_SYSTEM) != -1) {
-		plm_demux_decode_system_header(self);
-	}
-	return self;
-}
-
-void plm_demux_destroy(plm_demux_t *self) {
-	if (self->destroy_buffer_when_done) {
-		plm_buffer_destroy(self->buffer);
-	}
-	free(self);
-}
-
-int plm_demux_get_num_video_streams(plm_demux_t *self) {
-	return self->num_video_streams;
-}
-
-int plm_demux_get_num_audio_streams(plm_demux_t *self) {
-	return self->num_audio_streams;
-}
-
-void plm_demux_rewind(plm_demux_t *self) {
-	plm_buffer_rewind(self->buffer);
-}
-
-plm_packet_t *plm_demux_decode(plm_demux_t *self) {
-	if (self->current_packet.length) {
-		size_t bits_till_next_packet = self->current_packet.length << 3;
-		if (!plm_buffer_has(self->buffer, bits_till_next_packet)) {
-			return NULL;
-		}
-		plm_buffer_skip(self->buffer, bits_till_next_packet);
-		self->current_packet.length = 0;
-	}
-
-	if (!self->has_pack_header) {
-		if (plm_buffer_find_start_code(self->buffer, START_PACK) != -1) {
-			plm_demux_decode_pack_header(self);
-		}
-		else {
-			return NULL;
-		}
-	}
-
-	if (!self->has_system_header) {
-		if (plm_buffer_find_start_code(self->buffer, START_SYSTEM) != -1) {
-			plm_demux_decode_system_header(self);
-		}
-		else {
-			return NULL;
-		}
-	}
-
-	// pending packet just waiting for data?
-	if (self->next_packet.length) {
-		return plm_demux_get_packet(self);
-	}
-
-	int code;
-	do {
-		code = plm_buffer_next_start_code(self->buffer);
-		if (
-			code == PLM_DEMUX_PACKET_VIDEO_1 ||
-			code == PLM_DEMUX_PACKET_PRIVATE ||
-			(code >= PLM_DEMUX_PACKET_AUDIO_1 && code <= PLM_DEMUX_PACKET_AUDIO_4)
-		) {
-			return plm_demux_decode_packet(self, code);
-		}
-	} while (code != -1);
-
-	return NULL;
-}
-
-double plm_demux_read_time(plm_demux_t *self) {
-	int64_t clock = plm_buffer_read(self->buffer, 3) << 30;
-	plm_buffer_skip(self->buffer, 1);
-	clock |= plm_buffer_read(self->buffer, 15) << 15;
-	plm_buffer_skip(self->buffer, 1);
-	clock |= plm_buffer_read(self->buffer, 15);
-	plm_buffer_skip(self->buffer, 1);
-	return (double)clock / 90000.0;
-}
-
-void plm_demux_decode_pack_header(plm_demux_t *self) {
-	if (plm_buffer_read(self->buffer, 4) != 0x02) {
-		return; // invalid
-	}
-	self->system_clock_ref = plm_demux_read_time(self);
-	plm_buffer_skip(self->buffer, 1);
-	plm_buffer_skip(self->buffer, 22); // mux_rate * 50
-	plm_buffer_skip(self->buffer, 1);
-
-	self->has_pack_header = true;
-}
-
-void plm_demux_decode_system_header(plm_demux_t *self) {
-	plm_buffer_skip(self->buffer, 16); // header_length
-	plm_buffer_skip(self->buffer, 24); // rate bound
-	self->num_audio_streams = plm_buffer_read(self->buffer, 6);
-	plm_buffer_skip(self->buffer, 5); // misc flags
-	self->num_video_streams = plm_buffer_read(self->buffer, 5);
-
-	self->has_system_header = true;
-}
-
-plm_packet_t *plm_demux_decode_packet(plm_demux_t *self, int start_code) {
-	if (!plm_buffer_has(self->buffer, 8 << 3)) {
-		return NULL;
-	}
-
-	self->next_packet.type = start_code;
-	self->next_packet.length = plm_buffer_read(self->buffer, 16);
-	self->next_packet.length -= plm_buffer_skip_bytes(self->buffer, 0xff); // stuffing
-
-	// skip P-STD
-	if (plm_buffer_read(self->buffer, 2) == 0x01) {
-		plm_buffer_skip(self->buffer, 16);
-		self->next_packet.length -= 2;
-	}
-
-	int pts_dts_marker = plm_buffer_read(self->buffer, 2);
-	if (pts_dts_marker == 0x03) {
-		self->next_packet.pts = plm_demux_read_time(self);
-		plm_buffer_skip(self->buffer, 40); // skip dts
-		self->next_packet.length -= 10;
-	}
-	else if (pts_dts_marker == 0x02) {
-		self->next_packet.pts = plm_demux_read_time(self);
-		self->next_packet.length -= 5;
-	}
-	else if (pts_dts_marker == 0x00) {
-		self->next_packet.pts = 0;
-		plm_buffer_skip(self->buffer, 4);
-		self->next_packet.length -= 1;
-	}
-	else {
-		return NULL; // invalid
-	}
-
-	return plm_demux_get_packet(self);
-}
-
-plm_packet_t *plm_demux_get_packet(plm_demux_t *self) {
-	if (!plm_buffer_has(self->buffer, self->next_packet.length << 3)) {
-		return NULL;
-	}
-	self->current_packet.data = self->buffer->bytes + (self->buffer->bit_index >> 3);
-	self->current_packet.length = self->next_packet.length;
-	self->current_packet.type = self->next_packet.type;
-	self->current_packet.pts = self->next_packet.pts;
-	self->next_packet.length = 0;
-	return &self->current_packet;
-}
diff --git a/dsp/mpeg/demux.h b/dsp/mpeg/demux.h
deleted file mode 100644
index f36de4d3a..000000000
--- a/dsp/mpeg/demux.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef COSMOPOLITAN_DSP_MPEG_DEMUX_H_
-#define COSMOPOLITAN_DSP_MPEG_DEMUX_H_
-#include "dsp/mpeg/mpeg.h"
-COSMOPOLITAN_C_START_
-
-#define START_PACK   0xBA
-#define START_END    0xB9
-#define START_SYSTEM 0xBB
-
-typedef struct plm_demux_t {
-  plm_buffer_t *buffer;
-  int destroy_buffer_when_done;
-  double system_clock_ref;
-  int has_pack_header;
-  int has_system_header;
-  int num_audio_streams;
-  int num_video_streams;
-  plm_packet_t current_packet;
-  plm_packet_t next_packet;
-} plm_demux_t;
-
-double plm_demux_read_time(plm_demux_t *self);
-void plm_demux_decode_pack_header(plm_demux_t *self);
-void plm_demux_decode_system_header(plm_demux_t *self);
-plm_packet_t *plm_demux_decode_packet(plm_demux_t *self, int start_code);
-plm_packet_t *plm_demux_get_packet(plm_demux_t *self);
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_DSP_MPEG_DEMUX_H_ */
diff --git a/dsp/mpeg/idct.c b/dsp/mpeg/idct.c
deleted file mode 100644
index 11312607e..000000000
--- a/dsp/mpeg/idct.c
+++ /dev/null
@@ -1,101 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set et ft=c ts=4 sw=4 fenc=utf-8                                     :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND                       │
-│  NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/core/half.h"
-__static_yoink("pl_mpeg_notice");
-
-/**
- * Computes Fixed-Point 8x8 Inverse Discrete Cosine Transform.
- *
- * @note discovered by Nasir Ahmed
- */
-void plm_video_idct(int block[8][8]) {
-  int i, t1, t2, m0;
-  int b1, b3, b4, b6, b7;
-  int y3, y4, y5, y6, y7;
-  int x0, x1, x2, x3, x4;
-
-  for (i = 0; i < 8; ++i) {
-    b1 = block[4][i];
-    b3 = block[2][i] + block[6][i];
-    b4 = block[5][i] - block[3][i];
-    t1 = block[1][i] + block[7][i];
-    t2 = block[3][i] + block[5][i];
-    b6 = block[1][i] - block[7][i];
-    b7 = t1 + t2;
-    m0 = block[0][i];
-    x4 = ((b6 * 473 - b4 * 196 + 128) >> 8) - b7;
-    x0 = x4 - (((t1 - t2) * 362 + 128) >> 8);
-    x1 = m0 - b1;
-    x2 = (((block[2][i] - block[6][i]) * 362 + 128) >> 8) - b3;
-    x3 = m0 + b1;
-    y3 = x1 + x2;
-    y4 = x3 + b3;
-    y5 = x1 - x2;
-    y6 = x3 - b3;
-    y7 = -x0 - ((b4 * 473 + b6 * 196 + 128) >> 8);
-    block[0][i] = b7 + y4;
-    block[1][i] = x4 + y3;
-    block[2][i] = y5 - x0;
-    block[3][i] = y6 - y7;
-    block[4][i] = y6 + y7;
-    block[5][i] = x0 + y5;
-    block[6][i] = y3 - x4;
-    block[7][i] = y4 - b7;
-  }
-
-  for (i = 0; i < 8; ++i) {
-    b1 = block[i][4];
-    b3 = block[i][2] + block[i][6];
-    b4 = block[i][5] - block[i][3];
-    t1 = block[i][1] + block[i][7];
-    t2 = block[i][3] + block[i][5];
-    b6 = block[i][1] - block[i][7];
-    b7 = t1 + t2;
-    m0 = block[i][0];
-    x4 = ((b6 * 473 - b4 * 196 + 128) >> 8) - b7;
-    x0 = x4 - (((t1 - t2) * 362 + 128) >> 8);
-    x1 = m0 - b1;
-    x2 = (((block[i][2] - block[i][6]) * 362 + 128) >> 8) - b3;
-    x3 = m0 + b1;
-    y3 = x1 + x2;
-    y4 = x3 + b3;
-    y5 = x1 - x2;
-    y6 = x3 - b3;
-    y7 = -x0 - ((b4 * 473 + b6 * 196 + 128) >> 8);
-    block[i][0] = (b7 + y4 + 128) >> 8;
-    block[i][1] = (x4 + y3 + 128) >> 8;
-    block[i][2] = (y5 - x0 + 128) >> 8;
-    block[i][3] = (y6 - y7 + 128) >> 8;
-    block[i][4] = (y6 + y7 + 128) >> 8;
-    block[i][5] = (x0 + y5 + 128) >> 8;
-    block[i][6] = (y3 - x4 + 128) >> 8;
-    block[i][7] = (y4 - b7 + 128) >> 8;
-  }
-}
diff --git a/dsp/mpeg/idct.h b/dsp/mpeg/idct.h
deleted file mode 100644
index 1d16f8e38..000000000
--- a/dsp/mpeg/idct.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef COSMOPOLITAN_DSP_MPEG_IDCT_H_
-#define COSMOPOLITAN_DSP_MPEG_IDCT_H_
-COSMOPOLITAN_C_START_
-
-void plm_video_idct(int *);
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_DSP_MPEG_IDCT_H_ */
diff --git a/dsp/mpeg/macroblock.c b/dsp/mpeg/macroblock.c
deleted file mode 100644
index 3639011c3..000000000
--- a/dsp/mpeg/macroblock.c
+++ /dev/null
@@ -1,172 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set et ft=c ts=4 sw=4 fenc=utf-8                                     :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND                       │
-│  NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/mpeg.h"
-#include "dsp/mpeg/video.h"
-#include "libc/log/check.h"
-
-forceinline void plm_video_process_macroblock(plm_video_t *self,
-                                              uint8_t *restrict d,
-                                              uint8_t *restrict s, int motion_h,
-                                              int motion_v, bool interpolate,
-                                              unsigned BW) {
-  unsigned si, di, max_address;
-  int y, x, dest_scan, source_scan, dw, hp, vp, odd_h, odd_v;
-  dw = self->mb_width * BW;
-  hp = motion_h >> 1;
-  vp = motion_v >> 1;
-  odd_h = (motion_h & 1) == 1;
-  odd_v = (motion_v & 1) == 1;
-  si = ((self->mb_row * BW) + vp) * dw + (self->mb_col * BW) + hp;
-  di = (self->mb_row * dw + self->mb_col) * BW;
-  max_address = (dw * (self->mb_height * BW - BW + 1) - BW);
-  if (si > max_address || di > max_address)
-    return;
-  d += di;
-  s += si;
-  switch (((interpolate << 2) | (odd_h << 1) | (odd_v)) & 7) {
-    case 0:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          *d++ = *s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 1:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          *d++ = (s[0] + s[dw] + 1) >> 1;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 2:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          *d++ = (s[0] + s[1] + 1) >> 1;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 3:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          *d++ = (s[0] + s[1] + s[dw] + s[dw + 1] + 2) >> 2;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 4:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          d[0] = (d[0] + (s[0]) + 1) >> 1;
-          d++;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 5:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          d[0] = (d[0] + ((s[0] + s[dw] + 1) >> 1) + 1) >> 1;
-          d++;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 6:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          d[0] = (d[0] + ((s[0] + s[1] + 1) >> 1) + 1) >> 1;
-          d++;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    case 7:
-      dest_scan = dw - BW;
-      source_scan = dw - BW;
-      for (y = 0; y < BW; y++) {
-        for (x = 0; x < BW; x++) {
-          d[0] = (d[0] + ((s[0] + s[1] + s[dw] + s[dw + 1] + 2) >> 2) + 1) >> 1;
-          d++;
-          s++;
-        }
-        s += source_scan;
-        d += dest_scan;
-      }
-      break;
-    default:
-      break;
-  }
-}
-
-void plm_video_process_macroblock_8(plm_video_t *self, uint8_t *restrict d,
-                                    uint8_t *restrict s, int motion_h,
-                                    int motion_v, bool interpolate) {
-  DCHECK_ALIGNED(8, d);
-  DCHECK_ALIGNED(8, s);
-  plm_video_process_macroblock(self, d, s, motion_h, motion_v, interpolate, 8);
-}
-
-void plm_video_process_macroblock_16(plm_video_t *self, uint8_t *restrict d,
-                                     uint8_t *restrict s, int motion_h,
-                                     int motion_v, bool interpolate) {
-  DCHECK_ALIGNED(16, d);
-  DCHECK_ALIGNED(16, s);
-  plm_video_process_macroblock(self, d, s, motion_h, motion_v, interpolate, 16);
-}
diff --git a/dsp/mpeg/mp2.c b/dsp/mpeg/mp2.c
deleted file mode 100644
index 53fc91a23..000000000
--- a/dsp/mpeg/mp2.c
+++ /dev/null
@@ -1,769 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=4 sw=4 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND                       │
-│  NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/buffer.h"
-#include "dsp/mpeg/mpeg.h"
-#include "libc/log/log.h"
-#include "libc/mem/mem.h"
-#include "libc/str/str.h"
-
-/* clang-format off */
-// -----------------------------------------------------------------------------
-// plm_audio implementation
-
-// Based on kjmp2 by Martin J. Fiedler
-// http://keyj.emphy.de/kjmp2/
-
-#define PLM_AUDIO_FRAME_SYNC 0x7ff
-
-#define PLM_AUDIO_MPEG_2_5 0x0
-#define PLM_AUDIO_MPEG_2 0x2
-#define PLM_AUDIO_MPEG_1 0x3
-
-#define PLM_AUDIO_LAYER_III 0x1
-#define PLM_AUDIO_LAYER_II 0x2
-#define PLM_AUDIO_LAYER_I 0x3
-
-#define PLM_AUDIO_MODE_STEREO 0x0
-#define PLM_AUDIO_MODE_JOINT_STEREO 0x1
-#define PLM_AUDIO_MODE_DUAL_CHANNEL 0x2
-#define PLM_AUDIO_MODE_MONO 0x3
-
-static const unsigned short PLM_AUDIO_SAMPLE_RATE[] = {
-	44100, 48000, 32000, 0, // MPEG-1
-	22050, 24000, 16000, 0  // MPEG-2
-};
-
-static const short PLM_AUDIO_BIT_RATE[] = {
-	32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, // MPEG-1
-	 8, 16, 24, 32, 40, 48,  56,  64,  80,  96, 112, 128, 144, 160  // MPEG-2
-};
-
-static const int PLM_AUDIO_SCALEFACTOR_BASE[] = {
-	0x02000000, 0x01965FEA, 0x01428A30
-};
-
-static const float PLM_AUDIO_SYNTHESIS_WINDOW[] = {
-	     0.0,     -0.5,     -0.5,     -0.5,     -0.5,     -0.5,
-	    -0.5,     -1.0,     -1.0,     -1.0,     -1.0,     -1.5,
-	    -1.5,     -2.0,     -2.0,     -2.5,     -2.5,     -3.0,
-	    -3.5,     -3.5,     -4.0,     -4.5,     -5.0,     -5.5,
-	    -6.5,     -7.0,     -8.0,     -8.5,     -9.5,    -10.5,
-	   -12.0,    -13.0,    -14.5,    -15.5,    -17.5,    -19.0,
-	   -20.5,    -22.5,    -24.5,    -26.5,    -29.0,    -31.5,
-	   -34.0,    -36.5,    -39.5,    -42.5,    -45.5,    -48.5,
-	   -52.0,    -55.5,    -58.5,    -62.5,    -66.0,    -69.5,
-	   -73.5,    -77.0,    -80.5,    -84.5,    -88.0,    -91.5,
-	   -95.0,    -98.0,   -101.0,   -104.0,    106.5,    109.0,
-	   111.0,    112.5,    113.5,    114.0,    114.0,    113.5,
-	   112.0,    110.5,    107.5,    104.0,    100.0,     94.5,
-	    88.5,     81.5,     73.0,     63.5,     53.0,     41.5,
-	    28.5,     14.5,     -1.0,    -18.0,    -36.0,    -55.5,
-	   -76.5,    -98.5,   -122.0,   -147.0,   -173.5,   -200.5,
-	  -229.5,   -259.5,   -290.5,   -322.5,   -355.5,   -389.5,
-	  -424.0,   -459.5,   -495.5,   -532.0,   -568.5,   -605.0,
-	  -641.5,   -678.0,   -714.0,   -749.0,   -783.5,   -817.0,
-	  -849.0,   -879.5,   -908.5,   -935.0,   -959.5,   -981.0,
-	 -1000.5,  -1016.0,  -1028.5,  -1037.5,  -1042.5,  -1043.5,
-	 -1040.0,  -1031.5,   1018.5,   1000.0,    976.0,    946.5,
-	   911.0,    869.5,    822.0,    767.5,    707.0,    640.0,
-	   565.5,    485.0,    397.0,    302.5,    201.0,     92.5,
-	   -22.5,   -144.0,   -272.5,   -407.0,   -547.5,   -694.0,
-	  -846.0,  -1003.0,  -1165.0,  -1331.5,  -1502.0,  -1675.5,
-	 -1852.5,  -2031.5,  -2212.5,  -2394.0,  -2576.5,  -2758.5,
-	 -2939.5,  -3118.5,  -3294.5,  -3467.5,  -3635.5,  -3798.5,
-	 -3955.0,  -4104.5,  -4245.5,  -4377.5,  -4499.0,  -4609.5,
-	 -4708.0,  -4792.5,  -4863.5,  -4919.0,  -4958.0,  -4979.5,
-	 -4983.0,  -4967.5,  -4931.5,  -4875.0,  -4796.0,  -4694.5,
-	 -4569.5,  -4420.0,  -4246.0,  -4046.0,  -3820.0,  -3567.0,
-	  3287.0,   2979.5,   2644.0,   2280.5,   1888.0,   1467.5,
-	  1018.5,    541.0,     35.0,   -499.0,  -1061.0,  -1650.0,
-	 -2266.5,  -2909.0,  -3577.0,  -4270.0,  -4987.5,  -5727.5,
-	 -6490.0,  -7274.0,  -8077.5,  -8899.5,  -9739.0, -10594.5,
-	-11464.5, -12347.0, -13241.0, -14144.5, -15056.0, -15973.5,
-	-16895.5, -17820.0, -18744.5, -19668.0, -20588.0, -21503.0,
-	-22410.5, -23308.5, -24195.0, -25068.5, -25926.5, -26767.0,
-	-27589.0, -28389.0, -29166.5, -29919.0, -30644.5, -31342.0,
-	-32009.5, -32645.0, -33247.0, -33814.5, -34346.0, -34839.5,
-	-35295.0, -35710.0, -36084.5, -36417.5, -36707.5, -36954.0,
-	-37156.5, -37315.0, -37428.0, -37496.0,  37519.0,  37496.0,
-	 37428.0,  37315.0,  37156.5,  36954.0,  36707.5,  36417.5,
-	 36084.5,  35710.0,  35295.0,  34839.5,  34346.0,  33814.5,
-	 33247.0,  32645.0,  32009.5,  31342.0,  30644.5,  29919.0,
-	 29166.5,  28389.0,  27589.0,  26767.0,  25926.5,  25068.5,
-	 24195.0,  23308.5,  22410.5,  21503.0,  20588.0,  19668.0,
-	 18744.5,  17820.0,  16895.5,  15973.5,  15056.0,  14144.5,
-	 13241.0,  12347.0,  11464.5,  10594.5,   9739.0,   8899.5,
-	  8077.5,   7274.0,   6490.0,   5727.5,   4987.5,   4270.0,
-	  3577.0,   2909.0,   2266.5,   1650.0,   1061.0,    499.0,
-	   -35.0,   -541.0,  -1018.5,  -1467.5,  -1888.0,  -2280.5,
-	 -2644.0,  -2979.5,   3287.0,   3567.0,   3820.0,   4046.0,
-	  4246.0,   4420.0,   4569.5,   4694.5,   4796.0,   4875.0,
-	  4931.5,   4967.5,   4983.0,   4979.5,   4958.0,   4919.0,
-	  4863.5,   4792.5,   4708.0,   4609.5,   4499.0,   4377.5,
-	  4245.5,   4104.5,   3955.0,   3798.5,   3635.5,   3467.5,
-	  3294.5,   3118.5,   2939.5,   2758.5,   2576.5,   2394.0,
-	  2212.5,   2031.5,   1852.5,   1675.5,   1502.0,   1331.5,
-	  1165.0,   1003.0,    846.0,    694.0,    547.5,    407.0,
-	   272.5,    144.0,     22.5,    -92.5,   -201.0,   -302.5,
-	  -397.0,   -485.0,   -565.5,   -640.0,   -707.0,   -767.5,
-	  -822.0,   -869.5,   -911.0,   -946.5,   -976.0,  -1000.0,
-	  1018.5,   1031.5,   1040.0,   1043.5,   1042.5,   1037.5,
-	  1028.5,   1016.0,   1000.5,    981.0,    959.5,    935.0,
-	   908.5,    879.5,    849.0,    817.0,    783.5,    749.0,
-	   714.0,    678.0,    641.5,    605.0,    568.5,    532.0,
-	   495.5,    459.5,    424.0,    389.5,    355.5,    322.5,
-	   290.5,    259.5,    229.5,    200.5,    173.5,    147.0,
-	   122.0,     98.5,     76.5,     55.5,     36.0,     18.0,
-		1.0,    -14.5,    -28.5,    -41.5,    -53.0,    -63.5,
-	   -73.0,    -81.5,    -88.5,    -94.5,   -100.0,   -104.0,
-	  -107.5,   -110.5,   -112.0,   -113.5,   -114.0,   -114.0,
-	  -113.5,   -112.5,   -111.0,   -109.0,    106.5,    104.0,
-	   101.0,     98.0,     95.0,     91.5,     88.0,     84.5,
-	    80.5,     77.0,     73.5,     69.5,     66.0,     62.5,
-	    58.5,     55.5,     52.0,     48.5,     45.5,     42.5,
-	    39.5,     36.5,     34.0,     31.5,     29.0,     26.5,
-	    24.5,     22.5,     20.5,     19.0,     17.5,     15.5,
-	    14.5,     13.0,     12.0,     10.5,      9.5,      8.5,
-	     8.0,      7.0,      6.5,      5.5,      5.0,      4.5,
-	     4.0,      3.5,      3.5,      3.0,      2.5,      2.5,
-	     2.0,      2.0,      1.5,      1.5,      1.0,      1.0,
-	     1.0,      1.0,      0.5,      0.5,      0.5,      0.5,
-	     0.5,      0.5
-};
-
-// Quantizer lookup, step 1: bitrate classes
-static const uint8_t PLM_AUDIO_QUANT_LUT_STEP_1[2][16] = {
-	// 32, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,384 <- bitrate
-	{ 0,  0,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2 }, // mono
-	// 16, 24, 28, 32, 40, 48, 56, 64, 80, 96,112,128,160,192 <- bitrate / chan
-	{ 0,  0,  0,  0,  0,  0,  1,  1,  1,  2,  2,  2,  2,  2 } // stereo
-};
-
-// Quantizer lookup, step 2: bitrate class, sample rate -> B2 table idx, sblimit
-static const uint8_t PLM_AUDIO_QUANT_TAB_A = (27 | 64);   // Table 3-B.2a: high-rate, sblimit = 27
-static const uint8_t PLM_AUDIO_QUANT_TAB_B = (30 | 64);   // Table 3-B.2b: high-rate, sblimit = 30
-static const uint8_t PLM_AUDIO_QUANT_TAB_C = 8;           // Table 3-B.2c:  low-rate, sblimit =  8
-static const uint8_t PLM_AUDIO_QUANT_TAB_D = 12;          // Table 3-B.2d:  low-rate, sblimit = 12
-
-static const uint8_t QUANT_LUT_STEP_2[3][3] = {
-	//             44.1 kHz,               48 kHz,                 32 kHz
-	{ PLM_AUDIO_QUANT_TAB_C, PLM_AUDIO_QUANT_TAB_C, PLM_AUDIO_QUANT_TAB_D }, // 32 - 48 kbit/sec/ch
-	{ PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_A }, // 56 - 80 kbit/sec/ch
-	{ PLM_AUDIO_QUANT_TAB_B, PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_B }  // 96+	 kbit/sec/ch
-};
-
-// Quantizer lookup, step 3: B2 table, subband -> nbal, row index
-// (upper 4 bits: nbal, lower 4 bits: row index)
-static const uint8_t PLM_AUDIO_QUANT_LUT_STEP_3[3][32] = {
-	// Low-rate table (3-B.2c and 3-B.2d)
-	{
-		0x44,0x44,
-		0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34
-	},
-	// High-rate table (3-B.2a and 3-B.2b)
-	{
-		0x43,0x43,0x43,
-		0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,
-		0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,
-		0x20,0x20,0x20,0x20,0x20,0x20,0x20
-	},
-	// MPEG-2 LSR table (B.2 in ISO 13818-3)
-	{
-		0x45,0x45,0x45,0x45,
-		0x34,0x34,0x34,0x34,0x34,0x34,0x34,
-		0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,
-		0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24
-	}
-};
-
-// Quantizer lookup, step 4: table row, allocation[] value -> quant table index
-static const uint8_t PLM_AUDIO_QUANT_LUT_STEP4[6][16] = {
-	{ 0, 1, 2, 17 },
-	{ 0, 1, 2,  3, 4, 5, 6, 17 },
-	{ 0, 1, 2,  3, 4, 5, 6,  7,  8,  9, 10, 11, 12, 13, 14, 17 },
-	{ 0, 1, 3,  5, 6, 7, 8,  9, 10, 11, 12, 13, 14, 15, 16, 17 },
-	{ 0, 1, 2,  4, 5, 6, 7,  8,  9, 10, 11, 12, 13, 14, 15, 17 },
-	{ 0, 1, 2,  3, 4, 5, 6,  7,  8,  9, 10, 11, 12, 13, 14, 15 }
-};
-
-typedef struct plm_quantizer_spec_t {
-	unsigned short levels;
-	unsigned char group;
-	unsigned char bits;
-} plm_quantizer_spec_t;
-
-static const plm_quantizer_spec_t PLM_AUDIO_QUANT_TAB[] = {
-	{     3, 1,  5 },  //  1
-	{     5, 1,  7 },  //  2
-	{     7, 0,  3 },  //  3
-	{     9, 1, 10 },  //  4
-	{    15, 0,  4 },  //  5
-	{    31, 0,  5 },  //  6
-	{    63, 0,  6 },  //  7
-	{   127, 0,  7 },  //  8
-	{   255, 0,  8 },  //  9
-	{   511, 0,  9 },  // 10
-	{  1023, 0, 10 },  // 11
-	{  2047, 0, 11 },  // 12
-	{  4095, 0, 12 },  // 13
-	{  8191, 0, 13 },  // 14
-	{ 16383, 0, 14 },  // 15
-	{ 32767, 0, 15 },  // 16
-	{ 65535, 0, 16 }   // 17
-};
-
-struct plm_audio_t {
-	double time;
-	int samples_decoded;
-	int samplerate_index;
-	int bitrate_index;
-	int version;
-	int layer;
-	int mode;
-	int bound;
-	int v_pos;
-	int next_frame_data_size;
-	plm_buffer_t *buffer;
-	int destroy_buffer_when_done;
-	const plm_quantizer_spec_t *allocation[2][32];
-	uint8_t scale_factor_info[2][32];
-	int scale_factor[2][32][3];
-	int sample[2][32][3];
-	plm_samples_t samples;
-	float D[1024];
-	float V[1024];
-	float U[32];
-} forcealign(64);
-
-typedef plm_audio_t plm_audio_t;
-
-int plm_audio_decode_header(plm_audio_t *self);
-void plm_audio_decode_frame(plm_audio_t *self);
-const plm_quantizer_spec_t *plm_audio_read_allocation(plm_audio_t *self, int sb, int tab3);
-void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part);
-void plm_audio_matrix_transform(int s[32][3], int ss, float *d, int dp);
-
-plm_audio_t *plm_audio_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {
-	plm_audio_t *self = (plm_audio_t *)memalign(_Alignof(plm_audio_t), sizeof(plm_audio_t));
-	memset(self, 0, sizeof(plm_audio_t));
-
-	self->samples.count = PLM_AUDIO_SAMPLES_PER_FRAME;
-	self->buffer = buffer;
-	self->destroy_buffer_when_done = destroy_when_done;
-	self->samplerate_index = 3; // indicates 0 samplerate
-
-	memcpy(self->D, PLM_AUDIO_SYNTHESIS_WINDOW, 512 * sizeof(float));
-	memcpy(self->D + 512, PLM_AUDIO_SYNTHESIS_WINDOW, 512 * sizeof(float));
-
-	// Decode first header
-	if (plm_buffer_has(self->buffer, 48)) {
-		self->next_frame_data_size = plm_audio_decode_header(self);
-	}
-
-	return self;
-}
-
-void plm_audio_destroy(plm_audio_t *self) {
-	if (self->destroy_buffer_when_done) {
-		plm_buffer_destroy(self->buffer);
-	}
-	free(self);
-}
-
-int plm_audio_get_samplerate(plm_audio_t *self) {
-	return PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
-}
-
-double plm_audio_get_time(plm_audio_t *self) {
-	return self->time;
-}
-
-void plm_audio_rewind(plm_audio_t *self) {
-	plm_buffer_rewind(self->buffer);
-	self->time = 0;
-	self->samples_decoded = 0;
-	self->next_frame_data_size = 0;
-
-	// TODO: needed?
-	memset(self->V, 0, sizeof(self->V));
-	memset(self->U, 0, sizeof(self->U));
-}
-
-plm_samples_t *plm_audio_decode(plm_audio_t *self) {
-	DEBUGF("%s", "plm_audio_decode");
-	// Do we have at least enough information to decode the frame header?
-	if (!self->next_frame_data_size) {
-		if (!plm_buffer_has(self->buffer, 48)) {
-			return NULL;
-		}
-		self->next_frame_data_size = plm_audio_decode_header(self);
-	}
-
-	if (
-		self->next_frame_data_size == 0 ||
-		!plm_buffer_has(self->buffer, self->next_frame_data_size << 3)
-	) {
-		return NULL;
-	}
-
-	plm_audio_decode_frame(self);
-	self->next_frame_data_size = 0;
-
-	self->samples.time = self->time;
-
-	self->samples_decoded += PLM_AUDIO_SAMPLES_PER_FRAME;
-	self->time = (double)self->samples_decoded /
-		(double)PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
-
-	return &self->samples;
-}
-
-int plm_audio_decode_header(plm_audio_t *self) {
-	// Check for valid header: syncword OK, MPEG-Audio Layer 2
-	plm_buffer_skip_bytes(self->buffer, 0x00);
-
-	int sync = plm_buffer_read(self->buffer, 11);
-	self->version = plm_buffer_read(self->buffer, 2);
-	self->layer = plm_buffer_read(self->buffer, 2);
-	int hasCRC = !plm_buffer_read(self->buffer, 1);
-
-	if (
-		sync != PLM_AUDIO_FRAME_SYNC ||
-		self->version != PLM_AUDIO_MPEG_1 ||
-		self->layer != PLM_AUDIO_LAYER_II
-	) {
-		return false; // Invalid header or unsupported version
-	}
-
-	self->bitrate_index = plm_buffer_read(self->buffer, 4) - 1;
-	if (self->bitrate_index > 13) {
-		return false;  // Invalid bit rate or 'free format'
-	}
-
-	self->samplerate_index = plm_buffer_read(self->buffer, 2);
-	if (self->samplerate_index == 3) {
-		return false; // Invalid sample rate
-	}
-
-	if (self->version == PLM_AUDIO_MPEG_2) {
-		self->samplerate_index += 4;
-		self->bitrate_index += 14;
-	}
-	int padding = plm_buffer_read(self->buffer, 1);
-	plm_buffer_skip(self->buffer, 1); // f_private
-	self->mode = plm_buffer_read(self->buffer, 2);
-
-	// Parse the mode_extension, set up the stereo bound
-	self->bound = 0;
-	if (self->mode == PLM_AUDIO_MODE_JOINT_STEREO) {
-		self->bound = (plm_buffer_read(self->buffer, 2) + 1) << 2;
-	}
-	else {
-		plm_buffer_skip(self->buffer, 2);
-		self->bound = (self->mode == PLM_AUDIO_MODE_MONO) ? 0 : 32;
-	}
-
-	// Discard the last 4 bits of the header and the CRC value, if present
-	plm_buffer_skip(self->buffer, 4);
-	if (hasCRC) {
-		plm_buffer_skip(self->buffer, 16);
-	}
-
-	// Compute frame size, check if we have enough data to decode the whole
-	// frame.
-	int bitrate = PLM_AUDIO_BIT_RATE[self->bitrate_index];
-	int samplerate = PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
-	int frame_size = (144000 * bitrate / samplerate) + padding;
-	return frame_size - (hasCRC ? 6 : 4);
-}
-
-void plm_audio_decode_frame(plm_audio_t *self) {
-	// Prepare the quantizer table lookups
-	int tab3 = 0;
-	int sblimit = 0;
-	if (self->version == PLM_AUDIO_MPEG_2) {
-		// MPEG-2 (LSR)
-		tab3 = 2;
-		sblimit = 30;
-	}
-	else {
-		// MPEG-1
-		int tab1 = (self->mode == PLM_AUDIO_MODE_MONO) ? 0 : 1;
-		int tab2 = PLM_AUDIO_QUANT_LUT_STEP_1[tab1][self->bitrate_index];
-		tab3 = QUANT_LUT_STEP_2[tab2][self->samplerate_index];
-		sblimit = tab3 & 63;
-		tab3 >>= 6;
-	}
-
-	if (self->bound > sblimit) {
-		self->bound = sblimit;
-	}
-
-	// Read the allocation information
-	for (int sb = 0; sb < self->bound; sb++) {
-		self->allocation[0][sb] = plm_audio_read_allocation(self, sb, tab3);
-		self->allocation[1][sb] = plm_audio_read_allocation(self, sb, tab3);
-	}
-
-	for (int sb = self->bound; sb < sblimit; sb++) {
-		self->allocation[0][sb] =
-			self->allocation[1][sb] =
-			plm_audio_read_allocation(self, sb, tab3);
-	}
-
-	// Read scale factor selector information
-	int channels = (self->mode == PLM_AUDIO_MODE_MONO) ? 1 : 2;
-	for (int sb = 0; sb < sblimit; sb++) {
-		for (int ch = 0; ch < channels; ch++) {
-			if (self->allocation[ch][sb]) {
-				self->scale_factor_info[ch][sb] = plm_buffer_read(self->buffer, 2);
-			}
-		}
-		if (self->mode == PLM_AUDIO_MODE_MONO) {
-			self->scale_factor_info[1][sb] = self->scale_factor_info[0][sb];
-		}
-	}
-
-	// Read scale factors
-	for (int sb = 0; sb < sblimit; sb++) {
-		for (int ch = 0; ch < channels; ch++) {
-			if (self->allocation[ch][sb]) {
-				int *sf = self->scale_factor[ch][sb];
-				switch (self->scale_factor_info[ch][sb]) {
-				case 0:
-					sf[0] = plm_buffer_read(self->buffer, 6);
-					sf[1] = plm_buffer_read(self->buffer, 6);
-					sf[2] = plm_buffer_read(self->buffer, 6);
-					break;
-				case 1:
-					sf[0] =
-						sf[1] = plm_buffer_read(self->buffer, 6);
-					sf[2] = plm_buffer_read(self->buffer, 6);
-					break;
-				case 2:
-					sf[0] =
-						sf[1] =
-						sf[2] = plm_buffer_read(self->buffer, 6);
-					break;
-				case 3:
-					sf[0] = plm_buffer_read(self->buffer, 6);
-					sf[1] =
-						sf[2] = plm_buffer_read(self->buffer, 6);
-					break;
-				}
-			}
-		}
-		if (self->mode == PLM_AUDIO_MODE_MONO) {
-			self->scale_factor[1][sb][0] = self->scale_factor[0][sb][0];
-			self->scale_factor[1][sb][1] = self->scale_factor[0][sb][1];
-			self->scale_factor[1][sb][2] = self->scale_factor[0][sb][2];
-		}
-	}
-
-	// Coefficient input and reconstruction
-	int out_pos = 0;
-	for (int part = 0; part < 3; part++) {
-		for (int granule = 0; granule < 4; granule++) {
-
-			// Read the samples
-			for (int sb = 0; sb < self->bound; sb++) {
-				plm_audio_read_samples(self, 0, sb, part);
-				plm_audio_read_samples(self, 1, sb, part);
-			}
-			for (int sb = self->bound; sb < sblimit; sb++) {
-				plm_audio_read_samples(self, 0, sb, part);
-				self->sample[1][sb][0] = self->sample[0][sb][0];
-				self->sample[1][sb][1] = self->sample[0][sb][1];
-				self->sample[1][sb][2] = self->sample[0][sb][2];
-			}
-			for (int sb = sblimit; sb < 32; sb++) {
-				self->sample[0][sb][0] = 0;
-				self->sample[0][sb][1] = 0;
-				self->sample[0][sb][2] = 0;
-				self->sample[1][sb][0] = 0;
-				self->sample[1][sb][1] = 0;
-				self->sample[1][sb][2] = 0;
-			}
-
-			// Synthesis loop
-			for (int p = 0; p < 3; p++) {
-				// Shifting step
-				self->v_pos = (self->v_pos - 64) & 1023;
-
-				for (int ch = 0; ch < 2; ch++) {
-					plm_audio_matrix_transform(self->sample[ch], p, self->V, self->v_pos);
-
-					// Build U, windowing, calculate output
-					memset(self->U, 0, sizeof(self->U));
-
-					int d_index = 512 - (self->v_pos >> 1);
-					int v_index = (self->v_pos % 128) >> 1;
-					while (v_index < 1024) {
-						for (int i = 0; i < 32; ++i) {
-							self->U[i] += self->D[d_index++] * self->V[v_index++];
-						}
-
-						v_index += 128 - 32;
-						d_index += 64 - 32;
-					}
-
-					d_index -= (512 - 32);
-					v_index = (128 - 32 + 1024) - v_index;
-					while (v_index < 1024) {
-						for (int i = 0; i < 32; ++i) {
-							self->U[i] += self->D[d_index++] * self->V[v_index++];
-						}
-
-						v_index += 128 - 32;
-						d_index += 64 - 32;
-					}
-
-					// Output samples
-					#ifdef PLM_AUDIO_SEPARATE_CHANNELS
-						float *out_channel = ch == 0
-							? self->samples.left
-							: self->samples.right;
-						for (int j = 0; j < 32; j++) {
-							out_channel[out_pos + j] = self->U[j] / 2147418112.0f;
-						}
-					#else
-						for (int j = 0; j < 32; j++) {
-							self->samples.interleaved[((out_pos + j) << 1) + ch] =
-								self->U[j] / 2147418112.0f;
-						}
-					#endif
-				} // End of synthesis channel loop
-				out_pos += 32;
-			} // End of synthesis sub-block loop
-
-		} // Decoding of the granule finished
-	}
-
-	plm_buffer_align(self->buffer);
-}
-
-const plm_quantizer_spec_t *plm_audio_read_allocation(plm_audio_t *self, int sb, int tab3) {
-	int tab4 = PLM_AUDIO_QUANT_LUT_STEP_3[tab3][sb];
-	int qtab = PLM_AUDIO_QUANT_LUT_STEP4[tab4 & 15][plm_buffer_read(self->buffer, tab4 >> 4)];
-	return qtab ? (&PLM_AUDIO_QUANT_TAB[qtab - 1]) : 0;
-}
-
-void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part) {
-	const plm_quantizer_spec_t *q = self->allocation[ch][sb];
-	int sf = self->scale_factor[ch][sb][part];
-	int *sample = self->sample[ch][sb];
-	int val = 0;
-
-	if (!q) {
-		// No bits allocated for this subband
-		sample[0] = sample[1] = sample[2] = 0;
-		return;
-	}
-
-	// Resolve scalefactor
-	if (sf == 63) {
-		sf = 0;
-	}
-	else {
-		int shift = (sf / 3) | 0;
-		sf = (PLM_AUDIO_SCALEFACTOR_BASE[sf % 3] + ((1u << shift) >> 1)) >> shift;
-	}
-
-	// Decode samples
-	int adj = q->levels;
-	if (q->group) {
-		// Decode grouped samples
-		val = plm_buffer_read(self->buffer, q->bits);
-		sample[0] = val % adj;
-		val /= adj;
-		sample[1] = val % adj;
-		sample[2] = val / adj;
-	}
-	else {
-		// Decode direct samples
-		sample[0] = plm_buffer_read(self->buffer, q->bits);
-		sample[1] = plm_buffer_read(self->buffer, q->bits);
-		sample[2] = plm_buffer_read(self->buffer, q->bits);
-	}
-
-	// Postmultiply samples
-	int scale = 65536 / (adj + 1);
-	adj = ((adj + 1) >> 1) - 1;
-
-	val = (adj - sample[0]) * scale;
-	sample[0] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
-
-	val = (adj - sample[1]) * scale;
-	sample[1] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
-
-	val = (adj - sample[2]) * scale;
-	sample[2] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
-}
-
-void plm_audio_matrix_transform(int s[32][3], int ss, float *d, int dp) {
-	float t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12,
-		t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24,
-		t25, t26, t27, t28, t29, t30, t31, t32, t33;
-
-	t01 = (float)(s[0][ss] + s[31][ss]); t02 = (float)(s[0][ss] - s[31][ss]) * 0.500602998235f;
-	t03 = (float)(s[1][ss] + s[30][ss]); t04 = (float)(s[1][ss] - s[30][ss]) * 0.505470959898f;
-	t05 = (float)(s[2][ss] + s[29][ss]); t06 = (float)(s[2][ss] - s[29][ss]) * 0.515447309923f;
-	t07 = (float)(s[3][ss] + s[28][ss]); t08 = (float)(s[3][ss] - s[28][ss]) * 0.53104259109f;
-	t09 = (float)(s[4][ss] + s[27][ss]); t10 = (float)(s[4][ss] - s[27][ss]) * 0.553103896034f;
-	t11 = (float)(s[5][ss] + s[26][ss]); t12 = (float)(s[5][ss] - s[26][ss]) * 0.582934968206f;
-	t13 = (float)(s[6][ss] + s[25][ss]); t14 = (float)(s[6][ss] - s[25][ss]) * 0.622504123036f;
-	t15 = (float)(s[7][ss] + s[24][ss]); t16 = (float)(s[7][ss] - s[24][ss]) * 0.674808341455f;
-	t17 = (float)(s[8][ss] + s[23][ss]); t18 = (float)(s[8][ss] - s[23][ss]) * 0.744536271002f;
-	t19 = (float)(s[9][ss] + s[22][ss]); t20 = (float)(s[9][ss] - s[22][ss]) * 0.839349645416f;
-	t21 = (float)(s[10][ss] + s[21][ss]); t22 = (float)(s[10][ss] - s[21][ss]) * 0.972568237862f;
-	t23 = (float)(s[11][ss] + s[20][ss]); t24 = (float)(s[11][ss] - s[20][ss]) * 1.16943993343f;
-	t25 = (float)(s[12][ss] + s[19][ss]); t26 = (float)(s[12][ss] - s[19][ss]) * 1.48416461631f;
-	t27 = (float)(s[13][ss] + s[18][ss]); t28 = (float)(s[13][ss] - s[18][ss]) * 2.05778100995f;
-	t29 = (float)(s[14][ss] + s[17][ss]); t30 = (float)(s[14][ss] - s[17][ss]) * 3.40760841847f;
-	t31 = (float)(s[15][ss] + s[16][ss]); t32 = (float)(s[15][ss] - s[16][ss]) * 10.1900081235f;
-
-	t33 = t01 + t31; t31 = (t01 - t31) * 0.502419286188f;
-	t01 = t03 + t29; t29 = (t03 - t29) * 0.52249861494f;
-	t03 = t05 + t27; t27 = (t05 - t27) * 0.566944034816f;
-	t05 = t07 + t25; t25 = (t07 - t25) * 0.64682178336f;
-	t07 = t09 + t23; t23 = (t09 - t23) * 0.788154623451f;
-	t09 = t11 + t21; t21 = (t11 - t21) * 1.06067768599f;
-	t11 = t13 + t19; t19 = (t13 - t19) * 1.72244709824f;
-	t13 = t15 + t17; t17 = (t15 - t17) * 5.10114861869f;
-	t15 = t33 + t13; t13 = (t33 - t13) * 0.509795579104f;
-	t33 = t01 + t11; t01 = (t01 - t11) * 0.601344886935f;
-	t11 = t03 + t09; t09 = (t03 - t09) * 0.899976223136f;
-	t03 = t05 + t07; t07 = (t05 - t07) * 2.56291544774f;
-	t05 = t15 + t03; t15 = (t15 - t03) * 0.541196100146f;
-	t03 = t33 + t11; t11 = (t33 - t11) * 1.30656296488f;
-	t33 = t05 + t03; t05 = (t05 - t03) * 0.707106781187f;
-	t03 = t15 + t11; t15 = (t15 - t11) * 0.707106781187f;
-	t03 += t15;
-	t11 = t13 + t07; t13 = (t13 - t07) * 0.541196100146f;
-	t07 = t01 + t09; t09 = (t01 - t09) * 1.30656296488f;
-	t01 = t11 + t07; t07 = (t11 - t07) * 0.707106781187f;
-	t11 = t13 + t09; t13 = (t13 - t09) * 0.707106781187f;
-	t11 += t13; t01 += t11;
-	t11 += t07; t07 += t13;
-	t09 = t31 + t17; t31 = (t31 - t17) * 0.509795579104f;
-	t17 = t29 + t19; t29 = (t29 - t19) * 0.601344886935f;
-	t19 = t27 + t21; t21 = (t27 - t21) * 0.899976223136f;
-	t27 = t25 + t23; t23 = (t25 - t23) * 2.56291544774f;
-	t25 = t09 + t27; t09 = (t09 - t27) * 0.541196100146f;
-	t27 = t17 + t19; t19 = (t17 - t19) * 1.30656296488f;
-	t17 = t25 + t27; t27 = (t25 - t27) * 0.707106781187f;
-	t25 = t09 + t19; t19 = (t09 - t19) * 0.707106781187f;
-	t25 += t19;
-	t09 = t31 + t23; t31 = (t31 - t23) * 0.541196100146f;
-	t23 = t29 + t21; t21 = (t29 - t21) * 1.30656296488f;
-	t29 = t09 + t23; t23 = (t09 - t23) * 0.707106781187f;
-	t09 = t31 + t21; t31 = (t31 - t21) * 0.707106781187f;
-	t09 += t31;	t29 += t09;	t09 += t23;	t23 += t31;
-	t17 += t29;	t29 += t25;	t25 += t09;	t09 += t27;
-	t27 += t23;	t23 += t19; t19 += t31;
-	t21 = t02 + t32; t02 = (t02 - t32) * 0.502419286188f;
-	t32 = t04 + t30; t04 = (t04 - t30) * 0.52249861494f;
-	t30 = t06 + t28; t28 = (t06 - t28) * 0.566944034816f;
-	t06 = t08 + t26; t08 = (t08 - t26) * 0.64682178336f;
-	t26 = t10 + t24; t10 = (t10 - t24) * 0.788154623451f;
-	t24 = t12 + t22; t22 = (t12 - t22) * 1.06067768599f;
-	t12 = t14 + t20; t20 = (t14 - t20) * 1.72244709824f;
-	t14 = t16 + t18; t16 = (t16 - t18) * 5.10114861869f;
-	t18 = t21 + t14; t14 = (t21 - t14) * 0.509795579104f;
-	t21 = t32 + t12; t32 = (t32 - t12) * 0.601344886935f;
-	t12 = t30 + t24; t24 = (t30 - t24) * 0.899976223136f;
-	t30 = t06 + t26; t26 = (t06 - t26) * 2.56291544774f;
-	t06 = t18 + t30; t18 = (t18 - t30) * 0.541196100146f;
-	t30 = t21 + t12; t12 = (t21 - t12) * 1.30656296488f;
-	t21 = t06 + t30; t30 = (t06 - t30) * 0.707106781187f;
-	t06 = t18 + t12; t12 = (t18 - t12) * 0.707106781187f;
-	t06 += t12;
-	t18 = t14 + t26; t26 = (t14 - t26) * 0.541196100146f;
-	t14 = t32 + t24; t24 = (t32 - t24) * 1.30656296488f;
-	t32 = t18 + t14; t14 = (t18 - t14) * 0.707106781187f;
-	t18 = t26 + t24; t24 = (t26 - t24) * 0.707106781187f;
-	t18 += t24; t32 += t18;
-	t18 += t14; t26 = t14 + t24;
-	t14 = t02 + t16; t02 = (t02 - t16) * 0.509795579104f;
-	t16 = t04 + t20; t04 = (t04 - t20) * 0.601344886935f;
-	t20 = t28 + t22; t22 = (t28 - t22) * 0.899976223136f;
-	t28 = t08 + t10; t10 = (t08 - t10) * 2.56291544774f;
-	t08 = t14 + t28; t14 = (t14 - t28) * 0.541196100146f;
-	t28 = t16 + t20; t20 = (t16 - t20) * 1.30656296488f;
-	t16 = t08 + t28; t28 = (t08 - t28) * 0.707106781187f;
-	t08 = t14 + t20; t20 = (t14 - t20) * 0.707106781187f;
-	t08 += t20;
-	t14 = t02 + t10; t02 = (t02 - t10) * 0.541196100146f;
-	t10 = t04 + t22; t22 = (t04 - t22) * 1.30656296488f;
-	t04 = t14 + t10; t10 = (t14 - t10) * 0.707106781187f;
-	t14 = t02 + t22; t02 = (t02 - t22) * 0.707106781187f;
-	t14 += t02;	t04 += t14;	t14 += t10;	t10 += t02;
-	t16 += t04;	t04 += t08;	t08 += t14;	t14 += t28;
-	t28 += t10;	t10 += t20;	t20 += t02;	t21 += t16;
-	t16 += t32;	t32 += t04;	t04 += t06;	t06 += t08;
-	t08 += t18;	t18 += t14;	t14 += t30;	t30 += t28;
-	t28 += t26;	t26 += t10;	t10 += t12;	t12 += t20;
-	t20 += t24;	t24 += t02;
-
-	d[dp + 48] = -t33;
-	d[dp + 49] = d[dp + 47] = -t21;
-	d[dp + 50] = d[dp + 46] = -t17;
-	d[dp + 51] = d[dp + 45] = -t16;
-	d[dp + 52] = d[dp + 44] = -t01;
-	d[dp + 53] = d[dp + 43] = -t32;
-	d[dp + 54] = d[dp + 42] = -t29;
-	d[dp + 55] = d[dp + 41] = -t04;
-	d[dp + 56] = d[dp + 40] = -t03;
-	d[dp + 57] = d[dp + 39] = -t06;
-	d[dp + 58] = d[dp + 38] = -t25;
-	d[dp + 59] = d[dp + 37] = -t08;
-	d[dp + 60] = d[dp + 36] = -t11;
-	d[dp + 61] = d[dp + 35] = -t18;
-	d[dp + 62] = d[dp + 34] = -t09;
-	d[dp + 63] = d[dp + 33] = -t14;
-	d[dp + 32] = -t05;
-	d[dp + 0] = t05; d[dp + 31] = -t30;
-	d[dp + 1] = t30; d[dp + 30] = -t27;
-	d[dp + 2] = t27; d[dp + 29] = -t28;
-	d[dp + 3] = t28; d[dp + 28] = -t07;
-	d[dp + 4] = t07; d[dp + 27] = -t26;
-	d[dp + 5] = t26; d[dp + 26] = -t23;
-	d[dp + 6] = t23; d[dp + 25] = -t10;
-	d[dp + 7] = t10; d[dp + 24] = -t15;
-	d[dp + 8] = t15; d[dp + 23] = -t12;
-	d[dp + 9] = t12; d[dp + 22] = -t19;
-	d[dp + 10] = t19; d[dp + 21] = -t20;
-	d[dp + 11] = t20; d[dp + 20] = -t13;
-	d[dp + 12] = t13; d[dp + 19] = -t24;
-	d[dp + 13] = t24; d[dp + 18] = -t31;
-	d[dp + 14] = t31; d[dp + 17] = -t02;
-	d[dp + 15] = t02; d[dp + 16] = 0.0;
-};
-
diff --git a/dsp/mpeg/mpeg.h b/dsp/mpeg/mpeg.h
deleted file mode 100644
index f49ed953b..000000000
--- a/dsp/mpeg/mpeg.h
+++ /dev/null
@@ -1,447 +0,0 @@
-#ifndef COSMOPOLITAN_DSP_MPEG_MPEG_H_
-#define COSMOPOLITAN_DSP_MPEG_MPEG_H_
-#include "libc/stdio/stdio.h"
-COSMOPOLITAN_C_START_
-
-typedef struct plm_t plm_t;
-typedef struct plm_buffer_t plm_buffer_t;
-typedef struct plm_demux_t plm_demux_t;
-typedef struct plm_video_t plm_video_t;
-typedef struct plm_audio_t plm_audio_t;
-
-/**
- * Demuxed MPEG PS packet
- *
- * The type maps directly to the various MPEG-PES start codes. pts is
- * the presentation time stamp of the packet in seconds. Not all packets
- * have a pts value.
- */
-typedef struct plm_packet_t {
-  int type;
-  double pts;
-  size_t length;
-  uint8_t *data;
-} plm_packet_t;
-
-/**
- * Decoded Video Plane
- *
- * The byte length of the data is width * height. Note that different
- * planes have different sizes: the Luma plane (Y) is double the size of
- * each of the two Chroma planes (Cr, Cb) - i.e. 4 times the byte
- * length. Also note that the size of the plane does *not* denote the
- * size of the displayed frame. The sizes of planes are always rounded
- * up to the nearest macroblock (16px).
- */
-typedef struct plm_plane_t {
-  unsigned int width;
-  unsigned int height;
-  uint8_t *data;
-} plm_plane_t;
-
-/**
- * Decoded Video Frame
- *
- * Width and height denote the desired display size of the frame. This
- * may be different from the internal size of the 3 planes.
- */
-typedef struct plm_frame_t {
-  double time;
-  unsigned int width;
-  unsigned int height;
-  plm_plane_t y;
-  plm_plane_t cr;
-  plm_plane_t cb;
-} plm_frame_t;
-
-/**
- * Callback function type for decoded video frames used by the high-level
- * plm_* interface
- */
-typedef void (*plm_video_decode_callback)(plm_t *self, plm_frame_t *frame,
-                                          void *user);
-
-/**
- * Decoded Audio Samples
- *
- * Samples are stored as normalized (-1, 1) float either interleaved, or if
- * PLM_AUDIO_SEPARATE_CHANNELS is defined, in two separate arrays.
- * The `count` is always PLM_AUDIO_SAMPLES_PER_FRAME and just there for
- * convenience.
- */
-#define PLM_AUDIO_SAMPLES_PER_FRAME 1152
-
-struct plm_samples_t {
-  double time;
-  unsigned int count;
-#ifdef PLM_AUDIO_SEPARATE_CHANNELS
-  float left[PLM_AUDIO_SAMPLES_PER_FRAME] forcealign(32);
-  float right[PLM_AUDIO_SAMPLES_PER_FRAME] forcealign(32);
-#else
-  float interleaved[PLM_AUDIO_SAMPLES_PER_FRAME * 2] forcealign(32);
-#endif
-} forcealign(32);
-
-typedef struct plm_samples_t plm_samples_t;
-
-/**
- * Callback function type for decoded audio samples used by the high-level
- * plm_* interface
- */
-typedef void (*plm_audio_decode_callback)(plm_t *self, plm_samples_t *samples,
-                                          void *user);
-
-/**
- * Callback function for plm_buffer when it needs more data
- */
-typedef void (*plm_buffer_load_callback)(plm_buffer_t *self, void *user);
-
-/**
- * -----------------------------------------------------------------------------
- * plm_* public API
- * High-Level API for loading/demuxing/decoding MPEG-PS data
- *
- * Create a plmpeg instance with a filename. Returns NULL if the file could not
- * be opened.
- */
-plm_t *plm_create_with_filename(const char *filename);
-
-/**
- * Create a plmpeg instance with file handle. Pass true to close_when_done
- * to let plmpeg call fclose() on the handle when plm_destroy() is
- * called.
- */
-plm_t *plm_create_with_file(FILE *fh, int close_when_done);
-
-/**
- * Create a plmpeg instance with pointer to memory as source. This assumes the
- * whole file is in memory. Pass true to free_when_done to let plmpeg call
- * free() on the pointer when plm_destroy() is called.
- */
-plm_t *plm_create_with_memory(uint8_t *bytes, size_t length,
-                              int free_when_done);
-
-/**
- * Create a plmpeg instance with a plm_buffer as source. This is also
- * called internally by all the above constructor functions.
- */
-plm_t *plm_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done);
-
-/**
- * Destroy a plmpeg instance and free all data
- */
-void plm_destroy(plm_t *self);
-
-/**
- * Get or set whether video decoding is enabled.
- */
-int plm_get_video_enabled(plm_t *self);
-void plm_set_video_enabled(plm_t *self, int enabled);
-
-/**
- * Get or set whether audio decoding is enabled. When enabling, you can set the
- * desired audio stream (0-3) to decode.
- */
-int plm_get_audio_enabled(plm_t *self);
-void plm_set_audio_enabled(plm_t *self, int enabled, int stream_index);
-
-/**
- * Get the display width/height of the video stream
- */
-int plm_get_width(plm_t *self);
-int plm_get_height(plm_t *self);
-
-double plm_get_pixel_aspect_ratio(plm_t *);
-
-/**
- * Get the framerate of the video stream in frames per second
- */
-double plm_get_framerate(plm_t *self);
-
-/**
- * Get the number of available audio streams in the file
- */
-int plm_get_num_audio_streams(plm_t *self);
-
-/**
- * Get the samplerate of the audio stream in samples per second
- */
-int plm_get_samplerate(plm_t *self);
-
-/**
- * Get or set the audio lead time in seconds - the time in which audio samples
- * are decoded in advance (or behind) the video decode time. Default 0.
- */
-double plm_get_audio_lead_time(plm_t *self);
-void plm_set_audio_lead_time(plm_t *self, double lead_time);
-
-/**
- * Get the current internal time in seconds
- */
-double plm_get_time(plm_t *self);
-
-/**
- * Rewind all buffers back to the beginning.
- */
-void plm_rewind(plm_t *self);
-
-/**
- * Get or set looping. Default false.
- */
-int plm_get_loop(plm_t *self);
-void plm_set_loop(plm_t *self, int loop);
-
-/**
- * Get whether the file has ended. If looping is enabled, this will always
- * return false.
- */
-int plm_has_ended(plm_t *self);
-
-/**
- * Set the callback for decoded video frames used with plm_decode(). If no
- * callback is set, video data will be ignored and not be decoded.
- */
-void plm_set_video_decode_callback(plm_t *self, plm_video_decode_callback fp,
-                                   void *user);
-
-/**
- * Set the callback for decoded audio samples used with plm_decode(). If no
- * callback is set, audio data will be ignored and not be decoded.
- */
-void plm_set_audio_decode_callback(plm_t *self, plm_audio_decode_callback fp,
-                                   void *user);
-
-/**
- * Advance the internal timer by seconds and decode video/audio up to
- * this time. Returns true/false whether anything was decoded.
- */
-int plm_decode(plm_t *self, double seconds);
-
-/**
- * Decode and return one video frame. Returns NULL if no frame could be decoded
- * (either because the source ended or data is corrupt). If you only want to
- * decode video, you should disable audio via plm_set_audio_enabled().
- * The returned plm_frame_t is valid until the next call to
- * plm_decode_video call or until the plm_destroy is called.
- */
-plm_frame_t *plm_decode_video(plm_t *self);
-
-/**
- * Decode and return one audio frame. Returns NULL if no frame could be decoded
- * (either because the source ended or data is corrupt). If you only want to
- * decode audio, you should disable video via plm_set_video_enabled().
- * The returned plm_samples_t is valid until the next call to
- * plm_decode_video or until the plm_destroy is called.
- */
-plm_samples_t *plm_decode_audio(plm_t *self);
-
-/* -----------------------------------------------------------------------------
- * plm_buffer public API
- * Provides the data source for all other plm_* interfaces
- *
- * The default size for buffers created from files or by the high-level API
- */
-#ifndef PLM_BUFFER_DEFAULT_SIZE
-#define PLM_BUFFER_DEFAULT_SIZE (128 * 1024)
-#endif
-
-/**
- * Create a buffer instance with a filename. Returns NULL if the file could not
- * be opened.
- */
-plm_buffer_t *plm_buffer_create_with_filename(const char *filename);
-
-/**
- * Create a buffer instance with file handle. Pass true to close_when_done
- * to let plmpeg call fclose() on the handle when plm_destroy() is
- * called.
- */
-plm_buffer_t *plm_buffer_create_with_file(FILE *fh, int close_when_done);
-
-/**
- * Create a buffer instance with a pointer to memory as source. This assumes
- * the whole file is in memory. Pass 1 to free_when_done to let plmpeg call
- * free() on the pointer when plm_destroy() is called.
- */
-plm_buffer_t *plm_buffer_create_with_memory(uint8_t *bytes, size_t length,
-                                            int free_when_done);
-
-/**
- * Create an empty buffer with an initial capacity. The buffer will grow
- * as needed.
- */
-plm_buffer_t *plm_buffer_create_with_capacity(size_t capacity);
-
-/**
- * Destroy a buffer instance and free all data
- */
-void plm_buffer_destroy(plm_buffer_t *self);
-
-/**
- * Copy data into the buffer. If the data to be written is larger than the
- * available space, the buffer will realloc() with a larger capacity.
- * Returns the number of bytes written. This will always be the same as the
- * passed in length, except when the buffer was created _with_memory() for
- * which _write() is forbidden.
- */
-size_t plm_buffer_write(plm_buffer_t *self, uint8_t *bytes, size_t length);
-
-/**
- * Set a callback that is called whenever the buffer needs more data
- */
-void plm_buffer_set_load_callback(plm_buffer_t *self,
-                                  plm_buffer_load_callback fp, void *user);
-
-/**
- * Rewind the buffer back to the beginning. When loading from a file handle,
- * this also seeks to the beginning of the file.
- */
-void plm_buffer_rewind(plm_buffer_t *self);
-
-/**
- * -----------------------------------------------------------------------------
- * plm_demux public API
- * Demux an MPEG Program Stream (PS) data into separate packages
- *
- * Various Packet Types
- */
-#define PLM_DEMUX_PACKET_PRIVATE 0xBD
-#define PLM_DEMUX_PACKET_AUDIO_1 0xC0
-#define PLM_DEMUX_PACKET_AUDIO_2 0xC1
-#define PLM_DEMUX_PACKET_AUDIO_3 0xC2
-#define PLM_DEMUX_PACKET_AUDIO_4 0xC2
-#define PLM_DEMUX_PACKET_VIDEO_1 0xE0
-
-/**
- * Create a demuxer with a plm_buffer as source
- */
-plm_demux_t *plm_demux_create(plm_buffer_t *buffer, int destroy_when_done);
-
-/**
- * Destroy a demuxer and free all data
- */
-void plm_demux_destroy(plm_demux_t *self);
-
-/**
- * Returns the number of video streams found in the system header.
- */
-int plm_demux_get_num_video_streams(plm_demux_t *self);
-
-/**
- * Returns the number of audio streams found in the system header.
- */
-int plm_demux_get_num_audio_streams(plm_demux_t *self);
-
-/**
- * Rewinds the internal buffer. See plm_buffer_rewind().
- */
-void plm_demux_rewind(plm_demux_t *self);
-
-/**
- * Decode and return the next packet. The returned packet_t is valid until
- * the next call to plm_demux_decode() or until the demuxer is destroyed.
- */
-plm_packet_t *plm_demux_decode(plm_demux_t *self);
-
-/* -----------------------------------------------------------------------------
- * plm_video public API
- * Decode MPEG1 Video ("mpeg1") data into raw YCrCb frames
- */
-
-/**
- * Create a video decoder with a plm_buffer as source
- */
-plm_video_t *plm_video_create_with_buffer(plm_buffer_t *buffer,
-                                          int destroy_when_done);
-
-/**
- * Destroy a video decoder and free all data
- */
-void plm_video_destroy(plm_video_t *self);
-
-/**
- * Get the framerate in frames per second
- */
-double plm_video_get_framerate(plm_video_t *);
-
-double plm_video_get_pixel_aspect_ratio(plm_video_t *);
-
-/**
- * Get the display width/height
- */
-int plm_video_get_width(plm_video_t *);
-int plm_video_get_height(plm_video_t *);
-
-/**
- * Set "no delay" mode. When enabled, the decoder assumes that the video does
- * *not* contain any B-Frames. This is useful for reducing lag when streaming.
- */
-void plm_video_set_no_delay(plm_video_t *self, int no_delay);
-
-/**
- * Get the current internal time in seconds
- */
-double plm_video_get_time(plm_video_t *self);
-
-/**
- * Rewinds the internal buffer. See plm_buffer_rewind().
- */
-void plm_video_rewind(plm_video_t *self);
-
-/**
- * Decode and return one frame of video and advance the internal time by
- * 1/framerate seconds. The returned frame_t is valid until the next call of
- * plm_video_decode() or until the video decoder is destroyed.
- */
-plm_frame_t *plm_video_decode(plm_video_t *self);
-
-/**
- * Convert the YCrCb data of a frame into an interleaved RGB buffer. The buffer
- * pointed to by *rgb must have a size of (frame->width * frame->height * 3)
- * bytes.
- */
-void plm_frame_to_rgb(plm_frame_t *frame, uint8_t *rgb);
-
-/* -----------------------------------------------------------------------------
- * plm_audio public API
- * Decode MPEG-1 Audio Layer II ("mp2") data into raw samples
- */
-
-/**
- * Create an audio decoder with a plm_buffer as source.
- */
-plm_audio_t *plm_audio_create_with_buffer(plm_buffer_t *buffer,
-                                          int destroy_when_done);
-
-/**
- * Destroy an audio decoder and free all data
- */
-void plm_audio_destroy(plm_audio_t *self);
-
-/**
- * Get the samplerate in samples per second
- */
-int plm_audio_get_samplerate(plm_audio_t *self);
-
-/**
- * Get the current internal time in seconds
- */
-double plm_audio_get_time(plm_audio_t *self);
-
-/**
- * Rewinds the internal buffer. See plm_buffer_rewind().
- */
-void plm_audio_rewind(plm_audio_t *self);
-
-/**
- * Decode and return one "frame" of audio and advance the internal time by
- * (PLM_AUDIO_SAMPLES_PER_FRAME/samplerate) seconds. The returned samples_t
- * is valid until the next call of plm_audio_decode() or until the audio
- * decoder is destroyed.
- */
-plm_samples_t *plm_audio_decode(plm_audio_t *self);
-
-extern long plmpegdecode_latency_;
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_DSP_MPEG_MPEG_H_ */
diff --git a/dsp/mpeg/mpeg1.c b/dsp/mpeg/mpeg1.c
deleted file mode 100644
index 5b9eb0b82..000000000
--- a/dsp/mpeg/mpeg1.c
+++ /dev/null
@@ -1,1110 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set et ft=c ts=4 sw=4 fenc=utf-8                                     :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND                       │
-│  NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/blockset.h"
-#include "dsp/mpeg/buffer.h"
-#include "dsp/mpeg/idct.h"
-#include "dsp/mpeg/mpeg.h"
-#include "dsp/mpeg/video.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/fmt/conv.h"
-#include "libc/log/log.h"
-#include "libc/macros.internal.h"
-#include "libc/math.h"
-#include "libc/mem/mem.h"
-#include "libc/str/str.h"
-#include "libc/time.h"
-#include "libc/x/x.h"
-__static_yoink("pl_mpeg_notice");
-
-// -----------------------------------------------------------------------------
-// plm_video implementation
-
-// Inspired by Java MPEG-1 Video Decoder and Player by Zoltan Korandi
-// https://sourceforge.net/projects/javampeg1video/
-
-#define GETCONST(ARRAY, DEFAULT)
-
-static const int PLM_VIDEO_PICTURE_TYPE_INTRA = 1;
-static const int PLM_VIDEO_PICTURE_TYPE_PREDICTIVE = 2;
-static const int PLM_VIDEO_PICTURE_TYPE_B = 3;
-
-static const int PLM_START_SEQUENCE = 0xB3;
-static const int PLM_START_SLICE_FIRST = 0x01;
-static const int PLM_START_SLICE_LAST = 0xAF;
-static const int PLM_START_PICTURE = 0x00;
-static const int PLM_START_EXTENSION = 0xB5;
-static const int PLM_START_USER_DATA = 0xB2;
-
-static const float PLM_VIDEO_PIXEL_ASPECT_RATIO[] = {
-    1.0000, /* square pixels */
-    0.6735, /* 3:4? */
-    0.7031, /* MPEG-1 / MPEG-2 video encoding divergence? */
-    0.7615, 0.8055, 0.8437, 0.8935, 0.9157, 0.9815,
-    1.0255, 1.0695, 1.0950, 1.1575, 1.2051,
-};
-
-static const float PLM_VIDEO_PICTURE_RATE[] = {
-    23.976, /* NTSC-Film */
-    24.000, /* NTSC-Film (enriched for foreign nations) */
-    25.000, /* PAL (Britain, Africa, China, etc.) */
-    29.970, /* NTSC */
-    30.000, /* NTSC (enriched for foreign nations) */
-    50.000, /* PAL? */
-    59.940, /* NTSC-Wow */
-    60.000  /* NTSC-Wow (enriched for foreign nations) */
-};
-
-static const uint8_t PLM_VIDEO_ZIG_ZAG[] = /* clang-format off */ {
-     0,  1,  8, 16,  9,  2,  3, 10,
-	17, 24, 32, 25, 18, 11,  4,  5,
-    12, 19, 26, 33, 40, 48, 41, 34,
-	27, 20, 13,  6,  7, 14, 21, 28,
-    35, 42, 49, 56, 57, 50, 43, 36,
-	29, 22, 15, 23, 30, 37, 44, 51,
-    58, 59, 52, 45, 38, 31, 39, 46,
-	53, 60, 61, 54, 47, 55, 62, 63,
-} /* clang-format on */;
-
-static const uint8_t PLM_VIDEO_INTRAQUANT_MATRIX[] = /* clang-format off */ {
-     8, 16, 19, 22, 26, 27, 29, 34,
-	16, 16, 22, 24, 27, 29, 34, 37,
-    19, 22, 26, 27, 29, 34, 34, 38,
-	22, 22, 26, 27, 29, 34, 37, 40,
-    22, 26, 27, 29, 32, 35, 40, 48,
-	26, 27, 29, 32, 35, 40, 48, 58,
-    26, 27, 29, 34, 38, 46, 56, 69,
-	27, 29, 35, 38, 46, 56, 69, 83,
-} /* clang-format on */;
-
-static const uint8_t PLM_VIDEO_NONINTRAQUANT_MATRIX[] = /* clang-format off */ {
-    16, 16, 16, 16, 16, 16, 16, 16,
-	16, 16, 16, 16, 16, 16, 16, 16,
-    16, 16, 16, 16, 16, 16, 16, 16,
-	16, 16, 16, 16, 16, 16, 16, 16,
-    16, 16, 16, 16, 16, 16, 16, 16,
-	16, 16, 16, 16, 16, 16, 16, 16,
-    16, 16, 16, 16, 16, 16, 16, 16,
-	16, 16, 16, 16, 16, 16, 16, 16,
-} /* clang-format on */;
-
-static const uint8_t PLM_VIDEO_PREMULTIPLIER_MATRIX[] = /* clang-format off */ {
-    32, 44, 42, 38, 32, 25, 17,  9,
-	44, 62, 58, 52, 44, 35, 24, 12,
-    42, 58, 55, 49, 42, 33, 23, 12,
-	38, 52, 49, 44, 38, 30, 20, 10,
-    32, 44, 42, 38, 32, 25, 17,  9,
-	25, 35, 33, 30, 25, 20, 14,  7,
-    17, 24, 23, 20, 17, 14,  9,  5,
-	 9, 12, 12, 10,  9,  7,  5,  2,
-} /* clang-format on */;
-
-static const plm_vlc_t PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT[] = {
-    {1 << 1, 0},  {0, 1},        //   0: x
-    {2 << 1, 0},  {3 << 1, 0},   //   1: 0x
-    {4 << 1, 0},  {5 << 1, 0},   //   2: 00x
-    {0, 3},       {0, 2},        //   3: 01x
-    {6 << 1, 0},  {7 << 1, 0},   //   4: 000x
-    {0, 5},       {0, 4},        //   5: 001x
-    {8 << 1, 0},  {9 << 1, 0},   //   6: 0000x
-    {0, 7},       {0, 6},        //   7: 0001x
-    {10 << 1, 0}, {11 << 1, 0},  //   8: 0000 0x
-    {12 << 1, 0}, {13 << 1, 0},  //   9: 0000 1x
-    {14 << 1, 0}, {15 << 1, 0},  //  10: 0000 00x
-    {16 << 1, 0}, {17 << 1, 0},  //  11: 0000 01x
-    {18 << 1, 0}, {19 << 1, 0},  //  12: 0000 10x
-    {0, 9},       {0, 8},        //  13: 0000 11x
-    {-1, 0},      {20 << 1, 0},  //  14: 0000 000x
-    {-1, 0},      {21 << 1, 0},  //  15: 0000 001x
-    {22 << 1, 0}, {23 << 1, 0},  //  16: 0000 010x
-    {0, 15},      {0, 14},       //  17: 0000 011x
-    {0, 13},      {0, 12},       //  18: 0000 100x
-    {0, 11},      {0, 10},       //  19: 0000 101x
-    {24 << 1, 0}, {25 << 1, 0},  //  20: 0000 0001x
-    {26 << 1, 0}, {27 << 1, 0},  //  21: 0000 0011x
-    {28 << 1, 0}, {29 << 1, 0},  //  22: 0000 0100x
-    {30 << 1, 0}, {31 << 1, 0},  //  23: 0000 0101x
-    {32 << 1, 0}, {-1, 0},       //  24: 0000 0001 0x
-    {-1, 0},      {33 << 1, 0},  //  25: 0000 0001 1x
-    {34 << 1, 0}, {35 << 1, 0},  //  26: 0000 0011 0x
-    {36 << 1, 0}, {37 << 1, 0},  //  27: 0000 0011 1x
-    {38 << 1, 0}, {39 << 1, 0},  //  28: 0000 0100 0x
-    {0, 21},      {0, 20},       //  29: 0000 0100 1x
-    {0, 19},      {0, 18},       //  30: 0000 0101 0x
-    {0, 17},      {0, 16},       //  31: 0000 0101 1x
-    {0, 35},      {-1, 0},       //  32: 0000 0001 00x
-    {-1, 0},      {0, 34},       //  33: 0000 0001 11x
-    {0, 33},      {0, 32},       //  34: 0000 0011 00x
-    {0, 31},      {0, 30},       //  35: 0000 0011 01x
-    {0, 29},      {0, 28},       //  36: 0000 0011 10x
-    {0, 27},      {0, 26},       //  37: 0000 0011 11x
-    {0, 25},      {0, 24},       //  38: 0000 0100 00x
-    {0, 23},      {0, 22},       //  39: 0000 0100 01x
-};
-
-static const plm_vlc_t PLM_VIDEO_MACROBLOCK_TYPE_INTRA[] = {
-    {1 << 1, 0},
-    {0, 0x01},  //   0: x
-    {-1, 0},
-    {0, 0x11},  //   1: 0x
-};
-
-static const plm_vlc_t PLM_VIDEO_MACROBLOCK_TYPE_PREDICTIVE[] = {
-    {1 << 1, 0}, {0, 0x0a},    //   0: x
-    {2 << 1, 0}, {0, 0x02},    //   1: 0x
-    {3 << 1, 0}, {0, 0x08},    //   2: 00x
-    {4 << 1, 0}, {5 << 1, 0},  //   3: 000x
-    {6 << 1, 0}, {0, 0x12},    //   4: 0000x
-    {0, 0x1a},   {0, 0x01},    //   5: 0001x
-    {-1, 0},     {0, 0x11},    //   6: 0000 0x
-};
-
-static const plm_vlc_t PLM_VIDEO_MACROBLOCK_TYPE_B[] = {
-    {1 << 1, 0}, {2 << 1, 0},   //   0: x
-    {3 << 1, 0}, {4 << 1, 0},   //   1: 0x
-    {0, 0x0c},   {0, 0x0e},     //   2: 1x
-    {5 << 1, 0}, {6 << 1, 0},   //   3: 00x
-    {0, 0x04},   {0, 0x06},     //   4: 01x
-    {7 << 1, 0}, {8 << 1, 0},   //   5: 000x
-    {0, 0x08},   {0, 0x0a},     //   6: 001x
-    {9 << 1, 0}, {10 << 1, 0},  //   7: 0000x
-    {0, 0x1e},   {0, 0x01},     //   8: 0001x
-    {-1, 0},     {0, 0x11},     //   9: 0000 0x
-    {0, 0x16},   {0, 0x1a},     //  10: 0000 1x
-};
-
-static const plm_vlc_t PLM_VIDEO_CODE_BLOCK_PATTERN[] = {
-    {1 << 1, 0},  {2 << 1, 0},   //   0: x
-    {3 << 1, 0},  {4 << 1, 0},   //   1: 0x
-    {5 << 1, 0},  {6 << 1, 0},   //   2: 1x
-    {7 << 1, 0},  {8 << 1, 0},   //   3: 00x
-    {9 << 1, 0},  {10 << 1, 0},  //   4: 01x
-    {11 << 1, 0}, {12 << 1, 0},  //   5: 10x
-    {13 << 1, 0}, {0, 60},       //   6: 11x
-    {14 << 1, 0}, {15 << 1, 0},  //   7: 000x
-    {16 << 1, 0}, {17 << 1, 0},  //   8: 001x
-    {18 << 1, 0}, {19 << 1, 0},  //   9: 010x
-    {20 << 1, 0}, {21 << 1, 0},  //  10: 011x
-    {22 << 1, 0}, {23 << 1, 0},  //  11: 100x
-    {0, 32},      {0, 16},       //  12: 101x
-    {0, 8},       {0, 4},        //  13: 110x
-    {24 << 1, 0}, {25 << 1, 0},  //  14: 0000x
-    {26 << 1, 0}, {27 << 1, 0},  //  15: 0001x
-    {28 << 1, 0}, {29 << 1, 0},  //  16: 0010x
-    {30 << 1, 0}, {31 << 1, 0},  //  17: 0011x
-    {0, 62},      {0, 2},        //  18: 0100x
-    {0, 61},      {0, 1},        //  19: 0101x
-    {0, 56},      {0, 52},       //  20: 0110x
-    {0, 44},      {0, 28},       //  21: 0111x
-    {0, 40},      {0, 20},       //  22: 1000x
-    {0, 48},      {0, 12},       //  23: 1001x
-    {32 << 1, 0}, {33 << 1, 0},  //  24: 0000 0x
-    {34 << 1, 0}, {35 << 1, 0},  //  25: 0000 1x
-    {36 << 1, 0}, {37 << 1, 0},  //  26: 0001 0x
-    {38 << 1, 0}, {39 << 1, 0},  //  27: 0001 1x
-    {40 << 1, 0}, {41 << 1, 0},  //  28: 0010 0x
-    {42 << 1, 0}, {43 << 1, 0},  //  29: 0010 1x
-    {0, 63},      {0, 3},        //  30: 0011 0x
-    {0, 36},      {0, 24},       //  31: 0011 1x
-    {44 << 1, 0}, {45 << 1, 0},  //  32: 0000 00x
-    {46 << 1, 0}, {47 << 1, 0},  //  33: 0000 01x
-    {48 << 1, 0}, {49 << 1, 0},  //  34: 0000 10x
-    {50 << 1, 0}, {51 << 1, 0},  //  35: 0000 11x
-    {52 << 1, 0}, {53 << 1, 0},  //  36: 0001 00x
-    {54 << 1, 0}, {55 << 1, 0},  //  37: 0001 01x
-    {56 << 1, 0}, {57 << 1, 0},  //  38: 0001 10x
-    {58 << 1, 0}, {59 << 1, 0},  //  39: 0001 11x
-    {0, 34},      {0, 18},       //  40: 0010 00x
-    {0, 10},      {0, 6},        //  41: 0010 01x
-    {0, 33},      {0, 17},       //  42: 0010 10x
-    {0, 9},       {0, 5},        //  43: 0010 11x
-    {-1, 0},      {60 << 1, 0},  //  44: 0000 000x
-    {61 << 1, 0}, {62 << 1, 0},  //  45: 0000 001x
-    {0, 58},      {0, 54},       //  46: 0000 010x
-    {0, 46},      {0, 30},       //  47: 0000 011x
-    {0, 57},      {0, 53},       //  48: 0000 100x
-    {0, 45},      {0, 29},       //  49: 0000 101x
-    {0, 38},      {0, 26},       //  50: 0000 110x
-    {0, 37},      {0, 25},       //  51: 0000 111x
-    {0, 43},      {0, 23},       //  52: 0001 000x
-    {0, 51},      {0, 15},       //  53: 0001 001x
-    {0, 42},      {0, 22},       //  54: 0001 010x
-    {0, 50},      {0, 14},       //  55: 0001 011x
-    {0, 41},      {0, 21},       //  56: 0001 100x
-    {0, 49},      {0, 13},       //  57: 0001 101x
-    {0, 35},      {0, 19},       //  58: 0001 110x
-    {0, 11},      {0, 7},        //  59: 0001 111x
-    {0, 39},      {0, 27},       //  60: 0000 0001x
-    {0, 59},      {0, 55},       //  61: 0000 0010x
-    {0, 47},      {0, 31},       //  62: 0000 0011x
-};
-
-static const plm_vlc_t PLM_VIDEO_MOTION[] = {
-    {1 << 1, 0},  {0, 0},        //   0: x
-    {2 << 1, 0},  {3 << 1, 0},   //   1: 0x
-    {4 << 1, 0},  {5 << 1, 0},   //   2: 00x
-    {0, 1},       {0, -1},       //   3: 01x
-    {6 << 1, 0},  {7 << 1, 0},   //   4: 000x
-    {0, 2},       {0, -2},       //   5: 001x
-    {8 << 1, 0},  {9 << 1, 0},   //   6: 0000x
-    {0, 3},       {0, -3},       //   7: 0001x
-    {10 << 1, 0}, {11 << 1, 0},  //   8: 0000 0x
-    {12 << 1, 0}, {13 << 1, 0},  //   9: 0000 1x
-    {-1, 0},      {14 << 1, 0},  //  10: 0000 00x
-    {15 << 1, 0}, {16 << 1, 0},  //  11: 0000 01x
-    {17 << 1, 0}, {18 << 1, 0},  //  12: 0000 10x
-    {0, 4},       {0, -4},       //  13: 0000 11x
-    {-1, 0},      {19 << 1, 0},  //  14: 0000 001x
-    {20 << 1, 0}, {21 << 1, 0},  //  15: 0000 010x
-    {0, 7},       {0, -7},       //  16: 0000 011x
-    {0, 6},       {0, -6},       //  17: 0000 100x
-    {0, 5},       {0, -5},       //  18: 0000 101x
-    {22 << 1, 0}, {23 << 1, 0},  //  19: 0000 0011x
-    {24 << 1, 0}, {25 << 1, 0},  //  20: 0000 0100x
-    {26 << 1, 0}, {27 << 1, 0},  //  21: 0000 0101x
-    {28 << 1, 0}, {29 << 1, 0},  //  22: 0000 0011 0x
-    {30 << 1, 0}, {31 << 1, 0},  //  23: 0000 0011 1x
-    {32 << 1, 0}, {33 << 1, 0},  //  24: 0000 0100 0x
-    {0, 10},      {0, -10},      //  25: 0000 0100 1x
-    {0, 9},       {0, -9},       //  26: 0000 0101 0x
-    {0, 8},       {0, -8},       //  27: 0000 0101 1x
-    {0, 16},      {0, -16},      //  28: 0000 0011 00x
-    {0, 15},      {0, -15},      //  29: 0000 0011 01x
-    {0, 14},      {0, -14},      //  30: 0000 0011 10x
-    {0, 13},      {0, -13},      //  31: 0000 0011 11x
-    {0, 12},      {0, -12},      //  32: 0000 0100 00x
-    {0, 11},      {0, -11},      //  33: 0000 0100 01x
-};
-
-static const plm_vlc_t PLM_VIDEO_DCT_SIZE_LUMINANCE[] = {
-    {1 << 1, 0}, {2 << 1, 0},  //   0: x
-    {0, 1},      {0, 2},       //   1: 0x
-    {3 << 1, 0}, {4 << 1, 0},  //   2: 1x
-    {0, 0},      {0, 3},       //   3: 10x
-    {0, 4},      {5 << 1, 0},  //   4: 11x
-    {0, 5},      {6 << 1, 0},  //   5: 111x
-    {0, 6},      {7 << 1, 0},  //   6: 1111x
-    {0, 7},      {8 << 1, 0},  //   7: 1111 1x
-    {0, 8},      {-1, 0},      //   8: 1111 11x
-};
-
-static const plm_vlc_t PLM_VIDEO_DCT_SIZE_CHROMINANCE[] = {
-    {1 << 1, 0}, {2 << 1, 0},  //   0: x
-    {0, 0},      {0, 1},       //   1: 0x
-    {0, 2},      {3 << 1, 0},  //   2: 1x
-    {0, 3},      {4 << 1, 0},  //   3: 11x
-    {0, 4},      {5 << 1, 0},  //   4: 111x
-    {0, 5},      {6 << 1, 0},  //   5: 1111x
-    {0, 6},      {7 << 1, 0},  //   6: 1111 1x
-    {0, 7},      {8 << 1, 0},  //   7: 1111 11x
-    {0, 8},      {-1, 0},      //   8: 1111 111x
-};
-
-//  dct_coeff bitmap:
-//    0xff00  run
-//    0x00ff  level
-
-//  Decoded values are unsigned. Sign bit follows in the stream.
-
-static const plm_vlc_uint_t PLM_VIDEO_DCT_COEFF[] = {
-    {1 << 1, 0},   {0, 0x0001},    //   0: x
-    {2 << 1, 0},   {3 << 1, 0},    //   1: 0x
-    {4 << 1, 0},   {5 << 1, 0},    //   2: 00x
-    {6 << 1, 0},   {0, 0x0101},    //   3: 01x
-    {7 << 1, 0},   {8 << 1, 0},    //   4: 000x
-    {9 << 1, 0},   {10 << 1, 0},   //   5: 001x
-    {0, 0x0002},   {0, 0x0201},    //   6: 010x
-    {11 << 1, 0},  {12 << 1, 0},   //   7: 0000x
-    {13 << 1, 0},  {14 << 1, 0},   //   8: 0001x
-    {15 << 1, 0},  {0, 0x0003},    //   9: 0010x
-    {0, 0x0401},   {0, 0x0301},    //  10: 0011x
-    {16 << 1, 0},  {0, 0xffff},    //  11: 0000 0x
-    {17 << 1, 0},  {18 << 1, 0},   //  12: 0000 1x
-    {0, 0x0701},   {0, 0x0601},    //  13: 0001 0x
-    {0, 0x0102},   {0, 0x0501},    //  14: 0001 1x
-    {19 << 1, 0},  {20 << 1, 0},   //  15: 0010 0x
-    {21 << 1, 0},  {22 << 1, 0},   //  16: 0000 00x
-    {0, 0x0202},   {0, 0x0901},    //  17: 0000 10x
-    {0, 0x0004},   {0, 0x0801},    //  18: 0000 11x
-    {23 << 1, 0},  {24 << 1, 0},   //  19: 0010 00x
-    {25 << 1, 0},  {26 << 1, 0},   //  20: 0010 01x
-    {27 << 1, 0},  {28 << 1, 0},   //  21: 0000 000x
-    {29 << 1, 0},  {30 << 1, 0},   //  22: 0000 001x
-    {0, 0x0d01},   {0, 0x0006},    //  23: 0010 000x
-    {0, 0x0c01},   {0, 0x0b01},    //  24: 0010 001x
-    {0, 0x0302},   {0, 0x0103},    //  25: 0010 010x
-    {0, 0x0005},   {0, 0x0a01},    //  26: 0010 011x
-    {31 << 1, 0},  {32 << 1, 0},   //  27: 0000 0000x
-    {33 << 1, 0},  {34 << 1, 0},   //  28: 0000 0001x
-    {35 << 1, 0},  {36 << 1, 0},   //  29: 0000 0010x
-    {37 << 1, 0},  {38 << 1, 0},   //  30: 0000 0011x
-    {39 << 1, 0},  {40 << 1, 0},   //  31: 0000 0000 0x
-    {41 << 1, 0},  {42 << 1, 0},   //  32: 0000 0000 1x
-    {43 << 1, 0},  {44 << 1, 0},   //  33: 0000 0001 0x
-    {45 << 1, 0},  {46 << 1, 0},   //  34: 0000 0001 1x
-    {0, 0x1001},   {0, 0x0502},    //  35: 0000 0010 0x
-    {0, 0x0007},   {0, 0x0203},    //  36: 0000 0010 1x
-    {0, 0x0104},   {0, 0x0f01},    //  37: 0000 0011 0x
-    {0, 0x0e01},   {0, 0x0402},    //  38: 0000 0011 1x
-    {47 << 1, 0},  {48 << 1, 0},   //  39: 0000 0000 00x
-    {49 << 1, 0},  {50 << 1, 0},   //  40: 0000 0000 01x
-    {51 << 1, 0},  {52 << 1, 0},   //  41: 0000 0000 10x
-    {53 << 1, 0},  {54 << 1, 0},   //  42: 0000 0000 11x
-    {55 << 1, 0},  {56 << 1, 0},   //  43: 0000 0001 00x
-    {57 << 1, 0},  {58 << 1, 0},   //  44: 0000 0001 01x
-    {59 << 1, 0},  {60 << 1, 0},   //  45: 0000 0001 10x
-    {61 << 1, 0},  {62 << 1, 0},   //  46: 0000 0001 11x
-    {-1, 0},       {63 << 1, 0},   //  47: 0000 0000 000x
-    {64 << 1, 0},  {65 << 1, 0},   //  48: 0000 0000 001x
-    {66 << 1, 0},  {67 << 1, 0},   //  49: 0000 0000 010x
-    {68 << 1, 0},  {69 << 1, 0},   //  50: 0000 0000 011x
-    {70 << 1, 0},  {71 << 1, 0},   //  51: 0000 0000 100x
-    {72 << 1, 0},  {73 << 1, 0},   //  52: 0000 0000 101x
-    {74 << 1, 0},  {75 << 1, 0},   //  53: 0000 0000 110x
-    {76 << 1, 0},  {77 << 1, 0},   //  54: 0000 0000 111x
-    {0, 0x000b},   {0, 0x0802},    //  55: 0000 0001 000x
-    {0, 0x0403},   {0, 0x000a},    //  56: 0000 0001 001x
-    {0, 0x0204},   {0, 0x0702},    //  57: 0000 0001 010x
-    {0, 0x1501},   {0, 0x1401},    //  58: 0000 0001 011x
-    {0, 0x0009},   {0, 0x1301},    //  59: 0000 0001 100x
-    {0, 0x1201},   {0, 0x0105},    //  60: 0000 0001 101x
-    {0, 0x0303},   {0, 0x0008},    //  61: 0000 0001 110x
-    {0, 0x0602},   {0, 0x1101},    //  62: 0000 0001 111x
-    {78 << 1, 0},  {79 << 1, 0},   //  63: 0000 0000 0001x
-    {80 << 1, 0},  {81 << 1, 0},   //  64: 0000 0000 0010x
-    {82 << 1, 0},  {83 << 1, 0},   //  65: 0000 0000 0011x
-    {84 << 1, 0},  {85 << 1, 0},   //  66: 0000 0000 0100x
-    {86 << 1, 0},  {87 << 1, 0},   //  67: 0000 0000 0101x
-    {88 << 1, 0},  {89 << 1, 0},   //  68: 0000 0000 0110x
-    {90 << 1, 0},  {91 << 1, 0},   //  69: 0000 0000 0111x
-    {0, 0x0a02},   {0, 0x0902},    //  70: 0000 0000 1000x
-    {0, 0x0503},   {0, 0x0304},    //  71: 0000 0000 1001x
-    {0, 0x0205},   {0, 0x0107},    //  72: 0000 0000 1010x
-    {0, 0x0106},   {0, 0x000f},    //  73: 0000 0000 1011x
-    {0, 0x000e},   {0, 0x000d},    //  74: 0000 0000 1100x
-    {0, 0x000c},   {0, 0x1a01},    //  75: 0000 0000 1101x
-    {0, 0x1901},   {0, 0x1801},    //  76: 0000 0000 1110x
-    {0, 0x1701},   {0, 0x1601},    //  77: 0000 0000 1111x
-    {92 << 1, 0},  {93 << 1, 0},   //  78: 0000 0000 0001 0x
-    {94 << 1, 0},  {95 << 1, 0},   //  79: 0000 0000 0001 1x
-    {96 << 1, 0},  {97 << 1, 0},   //  80: 0000 0000 0010 0x
-    {98 << 1, 0},  {99 << 1, 0},   //  81: 0000 0000 0010 1x
-    {100 << 1, 0}, {101 << 1, 0},  //  82: 0000 0000 0011 0x
-    {102 << 1, 0}, {103 << 1, 0},  //  83: 0000 0000 0011 1x
-    {0, 0x001f},   {0, 0x001e},    //  84: 0000 0000 0100 0x
-    {0, 0x001d},   {0, 0x001c},    //  85: 0000 0000 0100 1x
-    {0, 0x001b},   {0, 0x001a},    //  86: 0000 0000 0101 0x
-    {0, 0x0019},   {0, 0x0018},    //  87: 0000 0000 0101 1x
-    {0, 0x0017},   {0, 0x0016},    //  88: 0000 0000 0110 0x
-    {0, 0x0015},   {0, 0x0014},    //  89: 0000 0000 0110 1x
-    {0, 0x0013},   {0, 0x0012},    //  90: 0000 0000 0111 0x
-    {0, 0x0011},   {0, 0x0010},    //  91: 0000 0000 0111 1x
-    {104 << 1, 0}, {105 << 1, 0},  //  92: 0000 0000 0001 00x
-    {106 << 1, 0}, {107 << 1, 0},  //  93: 0000 0000 0001 01x
-    {108 << 1, 0}, {109 << 1, 0},  //  94: 0000 0000 0001 10x
-    {110 << 1, 0}, {111 << 1, 0},  //  95: 0000 0000 0001 11x
-    {0, 0x0028},   {0, 0x0027},    //  96: 0000 0000 0010 00x
-    {0, 0x0026},   {0, 0x0025},    //  97: 0000 0000 0010 01x
-    {0, 0x0024},   {0, 0x0023},    //  98: 0000 0000 0010 10x
-    {0, 0x0022},   {0, 0x0021},    //  99: 0000 0000 0010 11x
-    {0, 0x0020},   {0, 0x010e},    // 100: 0000 0000 0011 00x
-    {0, 0x010d},   {0, 0x010c},    // 101: 0000 0000 0011 01x
-    {0, 0x010b},   {0, 0x010a},    // 102: 0000 0000 0011 10x
-    {0, 0x0109},   {0, 0x0108},    // 103: 0000 0000 0011 11x
-    {0, 0x0112},   {0, 0x0111},    // 104: 0000 0000 0001 000x
-    {0, 0x0110},   {0, 0x010f},    // 105: 0000 0000 0001 001x
-    {0, 0x0603},   {0, 0x1002},    // 106: 0000 0000 0001 010x
-    {0, 0x0f02},   {0, 0x0e02},    // 107: 0000 0000 0001 011x
-    {0, 0x0d02},   {0, 0x0c02},    // 108: 0000 0000 0001 100x
-    {0, 0x0b02},   {0, 0x1f01},    // 109: 0000 0000 0001 101x
-    {0, 0x1e01},   {0, 0x1d01},    // 110: 0000 0000 0001 110x
-    {0, 0x1c01},   {0, 0x1b01},    // 111: 0000 0000 0001 111x
-};
-
-long plmpegdecode_latency_;
-
-static plm_vlc_t *PLM_VIDEO_MACROBLOCK_TYPE[4];
-static plm_vlc_t *PLM_VIDEO_DCT_SIZE[3];
-
-#define plm_clamp(n) MIN(255, MAX(0, n))
-
-void plm_video_destroy(plm_video_t *self) {
-  if (self->destroy_buffer_when_done) {
-    plm_buffer_destroy(self->buffer);
-  }
-  if (self->has_sequence_header) {
-    free(self->frames_data);
-  }
-  free(self);
-}
-
-double plm_video_get_pixel_aspect_ratio(plm_video_t *self) {
-  return self->pixel_aspect_ratio;
-}
-
-double plm_video_get_framerate(plm_video_t *self) {
-  return self->framerate;
-}
-
-int plm_video_get_width(plm_video_t *self) {
-  return self->width;
-}
-
-int plm_video_get_height(plm_video_t *self) {
-  return self->height;
-}
-
-void plm_video_set_no_delay(plm_video_t *self, int no_delay) {
-  self->assume_no_b_frames = no_delay;
-}
-
-double plm_video_get_time(plm_video_t *self) {
-  return self->time;
-}
-
-void plm_video_rewind(plm_video_t *self) {
-  plm_buffer_rewind(self->buffer);
-  self->time = 0;
-  self->frames_decoded = 0;
-  self->has_reference_frame = false;
-}
-
-void plm_video_init_frame(plm_video_t *self, plm_frame_t *frame,
-                          uint8_t *base) {
-  size_t plane_size = self->luma_width * self->luma_height;
-  frame->width = self->width;
-  frame->height = self->height;
-  frame->y.width = self->luma_width;
-  frame->y.height = self->luma_height;
-  frame->y.data = base;
-  frame->cr.width = self->chroma_width;
-  frame->cr.height = self->chroma_height;
-  frame->cr.data = base + plane_size;
-  frame->cb.width = self->chroma_width;
-  frame->cb.height = self->chroma_height;
-  frame->cb.data = base + plane_size * 2;
-}
-
-void plm_video_decode_sequence_header(plm_video_t *self) {
-  int previous_width = self->width;
-  int previous_height = self->height;
-
-  self->width = plm_buffer_read(self->buffer, 12);
-  self->height = plm_buffer_read(self->buffer, 12);
-
-  int pixel_aspect_ratio_code;
-  pixel_aspect_ratio_code = plm_buffer_read(self->buffer, 4);
-  pixel_aspect_ratio_code -= 1;
-  pixel_aspect_ratio_code = MAX(pixel_aspect_ratio_code, 0);
-  pixel_aspect_ratio_code =
-      MIN(pixel_aspect_ratio_code, ARRAYLEN(PLM_VIDEO_PIXEL_ASPECT_RATIO) - 1);
-  self->pixel_aspect_ratio =
-      PLM_VIDEO_PIXEL_ASPECT_RATIO[pixel_aspect_ratio_code];
-
-  int framerate_code;
-  framerate_code = plm_buffer_read(self->buffer, 4);
-  framerate_code -= 1;
-  framerate_code = MAX(framerate_code, 0);
-  framerate_code = MIN(framerate_code, ARRAYLEN(PLM_VIDEO_PICTURE_RATE) - 1);
-  self->framerate = PLM_VIDEO_PICTURE_RATE[framerate_code];
-
-  // skip bitRate, marker, bufferSize and constrained bit
-  plm_buffer_skip(self->buffer, 18 + 1 + 10 + 1);
-
-  if (plm_buffer_read(self->buffer, 1)) {  // load custom intra quant matrix?
-    for (int i = 0; i < 64; i++) {
-      int idx = PLM_VIDEO_ZIG_ZAG[i];
-      self->intra_quant_matrix[idx] = plm_buffer_read(self->buffer, 8);
-    }
-  } else {
-    memcpy(self->intra_quant_matrix, PLM_VIDEO_INTRAQUANT_MATRIX, 64);
-  }
-
-  if (plm_buffer_read(self->buffer,
-                      1)) {  // load custom non intra quant matrix?
-    for (int i = 0; i < 64; i++) {
-      int idx = PLM_VIDEO_ZIG_ZAG[i];
-      self->non_intra_quant_matrix[idx] = plm_buffer_read(self->buffer, 8);
-    }
-  } else {
-    memcpy(self->non_intra_quant_matrix, PLM_VIDEO_NONINTRAQUANT_MATRIX, 64);
-  }
-
-  if (self->has_sequence_header) {
-    if (self->width == previous_width && self->height == previous_height) {
-      // We already had a sequence header with the same width/height;
-      // nothing else to do here.
-      return;
-    }
-
-    // We had a sequence header but with different dimensions;
-    // delete the previous planes and allocate new.
-    free(self->frames_data);
-  }
-
-  self->mb_width = (self->width + 15) >> 4;
-  self->mb_height = (self->height + 15) >> 4;
-  self->mb_size = self->mb_width * self->mb_height;
-  self->luma_width = self->mb_width << 4;
-  self->luma_height = self->mb_height << 4;
-  self->chroma_width = self->mb_width << 3;
-  self->chroma_height = self->mb_height << 3;
-
-  size_t plane_size = self->luma_width * self->luma_height;
-  self->frames_data = memalign(64, plane_size * 9);
-  plm_video_init_frame(self, &self->frame_current,
-                       self->frames_data + plane_size * 0);
-  plm_video_init_frame(self, &self->frame_forward,
-                       self->frames_data + plane_size * 3);
-  plm_video_init_frame(self, &self->frame_backward,
-                       self->frames_data + plane_size * 6);
-
-  self->has_sequence_header = true;
-
-  INFOF("%s:\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15f;\n"
-        "\t%-20s = %15f;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;\n"
-        "\t%-20s = %15d;",
-        "New MPEG Sequence", "width", self->width, "height", self->height,
-        "framerate", self->framerate, "pixel_aspect_ratio",
-        self->pixel_aspect_ratio, "mb_size", self->mb_size, "mb_width",
-        self->mb_width, "mb_height", self->mb_height, "luma_width",
-        self->luma_width, "luma_height", self->luma_height, "chroma_width",
-        self->chroma_width, "chroma_height", self->chroma_height);
-}
-
-static void plm_video_copy_macroblock(plm_video_t *self, int motion_h,
-                                      int motion_v, plm_frame_t *d) {
-  plm_frame_t *s = &self->frame_current;
-  plm_video_process_macroblock_16(self, s->y.data, d->y.data, motion_h,
-                                  motion_v, false);
-  plm_video_process_macroblock_8(self, s->cr.data, d->cr.data, motion_h / 2,
-                                 motion_v / 2, false);
-  plm_video_process_macroblock_8(self, s->cb.data, d->cb.data, motion_h / 2,
-                                 motion_v / 2, false);
-}
-
-static void plm_video_interpolate_macroblock(plm_video_t *self, int motion_h,
-                                             int motion_v, plm_frame_t *d) {
-  plm_frame_t *s = &self->frame_current;
-  plm_video_process_macroblock_16(self, s->y.data, d->y.data, motion_h,
-                                  motion_v, true);
-  plm_video_process_macroblock_8(self, s->cr.data, d->cr.data, motion_h / 2,
-                                 motion_v / 2, true);
-  plm_video_process_macroblock_8(self, s->cb.data, d->cb.data, motion_h / 2,
-                                 motion_v / 2, true);
-}
-
-static int plm_video_decode_motion_vector(plm_video_t *self, int r_size,
-                                          int motion) {
-  int fscale = 1u << r_size;
-  int m_code = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MOTION);
-  int r = 0;
-  int d;
-  if ((m_code != 0) && (fscale != 1)) {
-    r = plm_buffer_read(self->buffer, r_size);
-    d = ((abs(m_code) - 1) << r_size) + r + 1;
-    if (m_code < 0) {
-      d = -d;
-    }
-  } else {
-    d = m_code;
-  }
-  motion += d;
-  if (motion > (fscale << 4) - 1) {
-    motion -= fscale << 5;
-  } else if (motion < (int)(((unsigned)-fscale) << 4)) {
-    motion += fscale << 5;
-  }
-  return motion;
-}
-
-static void plm_video_decode_motion_vectors(plm_video_t *self) {
-  // Forward
-  if (self->motion_forward.is_set) {
-    int r_size = self->motion_forward.r_size;
-    self->motion_forward.h =
-        plm_video_decode_motion_vector(self, r_size, self->motion_forward.h);
-    self->motion_forward.v =
-        plm_video_decode_motion_vector(self, r_size, self->motion_forward.v);
-  } else if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) {
-    // No motion information in P-picture, reset vectors
-    self->motion_forward.h = 0;
-    self->motion_forward.v = 0;
-  }
-  if (self->motion_backward.is_set) {
-    int r_size = self->motion_backward.r_size;
-    self->motion_backward.h =
-        plm_video_decode_motion_vector(self, r_size, self->motion_backward.h);
-    self->motion_backward.v =
-        plm_video_decode_motion_vector(self, r_size, self->motion_backward.v);
-  }
-}
-
-static void plm_video_predict_macroblock(plm_video_t *self) {
-  int fw_h = self->motion_forward.h;
-  int fw_v = self->motion_forward.v;
-  if (self->motion_forward.full_px) {
-    fw_h <<= 1;
-    fw_v <<= 1;
-  }
-  if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) {
-    int bw_h = self->motion_backward.h;
-    int bw_v = self->motion_backward.v;
-    if (self->motion_backward.full_px) {
-      bw_h <<= 1;
-      bw_v <<= 1;
-    }
-    if (self->motion_forward.is_set) {
-      plm_video_copy_macroblock(self, fw_h, fw_v, &self->frame_forward);
-      if (self->motion_backward.is_set) {
-        plm_video_interpolate_macroblock(self, bw_h, bw_v,
-                                         &self->frame_backward);
-      }
-    } else {
-      plm_video_copy_macroblock(self, bw_h, bw_v, &self->frame_backward);
-    }
-  } else {
-    plm_video_copy_macroblock(self, fw_h, fw_v, &self->frame_forward);
-  }
-}
-
-static void plm_video_decode_block(plm_video_t *self, int block) {
-  int n = 0;
-  uint8_t *quant_matrix;
-
-  // Decode DC coefficient of intra-coded blocks
-  if (self->macroblock_intra) {
-    int predictor;
-    int dct_size;
-
-    // DC prediction
-    int plane_index = block > 3 ? block - 3 : 0;
-    predictor = self->dc_predictor[plane_index];
-    dct_size =
-        plm_buffer_read_vlc(self->buffer, PLM_VIDEO_DCT_SIZE[plane_index]);
-
-    // Read DC coeff
-    if (dct_size > 0) {
-      int differential = plm_buffer_read(self->buffer, dct_size);
-      if ((differential & (1 << (dct_size - 1))) != 0) {
-        self->block_data[0] = predictor + differential;
-      } else {
-        self->block_data[0] =
-            predictor + ((-1u << dct_size) | (differential + 1));
-      }
-    } else {
-      self->block_data[0] = predictor;
-    }
-
-    // Save predictor value
-    self->dc_predictor[plane_index] = self->block_data[0];
-
-    // Dequantize + premultiply
-    self->block_data[0] <<= (3 + 5);
-
-    quant_matrix = self->intra_quant_matrix;
-    n = 1;
-  } else {
-    quant_matrix = self->non_intra_quant_matrix;
-  }
-
-  // Decode AC coefficients (+DC for non-intra)
-  int level = 0;
-  while (true) {
-    int run = 0;
-    uint16_t coeff =
-        plm_buffer_read_vlc_uint(self->buffer, PLM_VIDEO_DCT_COEFF);
-
-    if ((coeff == 0x0001) && (n > 0) &&
-        (plm_buffer_read(self->buffer, 1) == 0)) {
-      // end_of_block
-      break;
-    }
-    if (coeff == 0xffff) {
-      // escape
-      run = plm_buffer_read(self->buffer, 6);
-      level = plm_buffer_read(self->buffer, 8);
-      if (level == 0) {
-        level = plm_buffer_read(self->buffer, 8);
-      } else if (level == 128) {
-        level = plm_buffer_read(self->buffer, 8) - 256;
-      } else if (level > 128) {
-        level = level - 256;
-      }
-    } else {
-      run = coeff >> 8;
-      level = coeff & 0xff;
-      if (plm_buffer_read(self->buffer, 1)) {
-        level = -level;
-      }
-    }
-
-    n += run;
-    if (n < 0 || n >= 64) {
-      return;  // invalid
-    }
-
-    int de_zig_zagged = PLM_VIDEO_ZIG_ZAG[n];
-    n++;
-
-    // Dequantize, oddify, clip
-    level = (unsigned)level << 1;
-    if (!self->macroblock_intra) {
-      level += (level < 0 ? -1 : 1);
-    }
-    level = (level * self->quantizer_scale * quant_matrix[de_zig_zagged]) >> 4;
-    if ((level & 1) == 0) {
-      level -= level > 0 ? 1 : -1;
-    }
-    if (level > 2047) {
-      level = 2047;
-    } else if (level < -2048) {
-      level = -2048;
-    }
-
-    // Save premultiplied coefficient
-    self->block_data[de_zig_zagged] =
-        level * PLM_VIDEO_PREMULTIPLIER_MATRIX[de_zig_zagged];
-  }
-
-  // Move block to its place
-  uint8_t *d;
-  int dw;
-  int di;
-
-  if (block < 4) {
-    d = self->frame_current.y.data;
-    dw = self->luma_width;
-    di = (self->mb_row * self->luma_width + self->mb_col) << 4;
-    if ((block & 1) != 0) {
-      di += 8;
-    }
-    if ((block & 2) != 0) {
-      di += self->luma_width << 3;
-    }
-  } else {
-    d = (block == 4) ? self->frame_current.cb.data
-                     : self->frame_current.cr.data;
-    dw = self->chroma_width;
-    di = ((self->mb_row * self->luma_width) << 2) + (self->mb_col << 3);
-  }
-
-  int *s = self->block_data;
-  int si = 0;
-  if (self->macroblock_intra) {
-    // Overwrite (no prediction)
-    if (n == 1) {
-      int clamped = plm_clamp((s[0] + 128) >> 8);
-      PLM_BLOCK_SET(d, di, dw, si, 8, 8, clamped);
-      s[0] = 0;
-    } else {
-      plm_video_idct(s);
-      PLM_BLOCK_SET(d, di, dw, si, 8, 8, plm_clamp(s[si]));
-      memset(self->block_data, 0, sizeof(self->block_data));
-    }
-  } else {
-    // Add data to the predicted macroblock
-    if (n == 1) {
-      int value = (s[0] + 128) >> 8;
-      PLM_BLOCK_SET(d, di, dw, si, 8, 8, plm_clamp(d[di] + value));
-      s[0] = 0;
-    } else {
-      plm_video_idct(s);
-      PLM_BLOCK_SET(d, di, dw, si, 8, 8, plm_clamp(d[di] + s[si]));
-      memset(self->block_data, 0, sizeof(self->block_data));
-    }
-  }
-}
-
-static void plm_video_decode_macroblock(plm_video_t *self) {
-  // Decode self->macroblock_address_increment
-  int increment = 0;
-  int t =
-      plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT);
-
-  while (t == 34) {
-    // macroblock_stuffing
-    t = plm_buffer_read_vlc(self->buffer,
-                            PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT);
-  }
-  while (t == 35) {
-    // macroblock_escape
-    increment += 33;
-    t = plm_buffer_read_vlc(self->buffer,
-                            PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT);
-  }
-  increment += t;
-
-  // Process any skipped macroblocks
-  if (self->slice_begin) {
-    // The first self->macroblock_address_increment of each slice is relative
-    // to beginning of the preverious row, not the preverious macroblock
-    self->slice_begin = false;
-    self->macroblock_address += increment;
-  } else {
-    if (self->macroblock_address + increment >= self->mb_size) {
-      return;  // invalid
-    }
-    if (increment > 1) {
-      // Skipped macroblocks reset DC predictors
-      self->dc_predictor[0] = 128;
-      self->dc_predictor[1] = 128;
-      self->dc_predictor[2] = 128;
-
-      // Skipped macroblocks in P-pictures reset motion vectors
-      if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) {
-        self->motion_forward.h = 0;
-        self->motion_forward.v = 0;
-      }
-    }
-
-    // Predict skipped macroblocks
-    while (increment > 1) {
-      self->macroblock_address++;
-      self->mb_row = self->macroblock_address / self->mb_width;
-      self->mb_col = self->macroblock_address % self->mb_width;
-
-      plm_video_predict_macroblock(self);
-      increment--;
-    }
-    self->macroblock_address++;
-  }
-
-  self->mb_row = self->macroblock_address / self->mb_width;
-  self->mb_col = self->macroblock_address % self->mb_width;
-
-  if (self->mb_col >= self->mb_width || self->mb_row >= self->mb_height) {
-    return;  // corrupt stream;
-  }
-
-  // Process the current macroblock
-  // static const s16 *mbTable = MACROBLOCK_TYPE[self->picture_type];
-  // macroblock_type = read_huffman(self->bits, mbTable);
-
-  const plm_vlc_t *table = PLM_VIDEO_MACROBLOCK_TYPE[self->picture_type];
-  self->macroblock_type = plm_buffer_read_vlc(self->buffer, table);
-
-  self->macroblock_intra = (self->macroblock_type & 0x01);
-  self->motion_forward.is_set = (self->macroblock_type & 0x08);
-  self->motion_backward.is_set = (self->macroblock_type & 0x04);
-
-  // Quantizer scale
-  if ((self->macroblock_type & 0x10) != 0) {
-    self->quantizer_scale = plm_buffer_read(self->buffer, 5);
-  }
-
-  if (self->macroblock_intra) {
-    // Intra-coded macroblocks reset motion vectors
-    self->motion_backward.h = self->motion_forward.h = 0;
-    self->motion_backward.v = self->motion_forward.v = 0;
-  } else {
-    // Non-intra macroblocks reset DC predictors
-    self->dc_predictor[0] = 128;
-    self->dc_predictor[1] = 128;
-    self->dc_predictor[2] = 128;
-
-    plm_video_decode_motion_vectors(self);
-    plm_video_predict_macroblock(self);
-  }
-
-  // Decode blocks
-  int cbp =
-      ((self->macroblock_type & 0x02) != 0)
-          ? plm_buffer_read_vlc(self->buffer, PLM_VIDEO_CODE_BLOCK_PATTERN)
-          : (self->macroblock_intra ? 0x3f : 0);
-
-  for (int block = 0, mask = 0x20; block < 6; block++) {
-    if ((cbp & mask) != 0) {
-      plm_video_decode_block(self, block);
-    }
-    mask >>= 1;
-  }
-}
-
-static void plm_video_decode_slice(plm_video_t *self, int slice) {
-  self->slice_begin = true;
-  self->macroblock_address = (slice - 1) * self->mb_width - 1;
-  // Reset motion vectors and DC predictors
-  self->motion_backward.h = self->motion_forward.h = 0;
-  self->motion_backward.v = self->motion_forward.v = 0;
-  self->dc_predictor[0] = 128;
-  self->dc_predictor[1] = 128;
-  self->dc_predictor[2] = 128;
-  self->quantizer_scale = plm_buffer_read(self->buffer, 5);
-  // Skip extra
-  while (plm_buffer_read(self->buffer, 1)) {
-    plm_buffer_skip(self->buffer, 8);
-  }
-  do {
-    plm_video_decode_macroblock(self);
-  } while (self->macroblock_address < self->mb_size - 1 &&
-           plm_buffer_no_start_code(self->buffer));
-}
-
-static void plm_video_decode_picture(plm_video_t *self) {
-  plm_buffer_skip(self->buffer, 10);  // skip temporalReference
-  self->picture_type = plm_buffer_read(self->buffer, 3);
-  plm_buffer_skip(self->buffer, 16);  // skip vbv_delay
-
-  // D frames or unknown coding type
-  if (self->picture_type <= 0 ||
-      self->picture_type > PLM_VIDEO_PICTURE_TYPE_B) {
-    return;
-  }
-
-  // forward full_px, f_code
-  if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE ||
-      self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) {
-    self->motion_forward.full_px = plm_buffer_read(self->buffer, 1);
-    int f_code = plm_buffer_read(self->buffer, 3);
-    if (f_code == 0) {
-      // Ignore picture with zero f_code
-      return;
-    }
-    self->motion_forward.r_size = f_code - 1;
-  }
-
-  // backward full_px, f_code
-  if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) {
-    self->motion_backward.full_px = plm_buffer_read(self->buffer, 1);
-    int f_code = plm_buffer_read(self->buffer, 3);
-    if (f_code == 0) {
-      // Ignore picture with zero f_code
-      return;
-    }
-    self->motion_backward.r_size = f_code - 1;
-  }
-
-  plm_frame_t frame_temp = self->frame_forward;
-
-  if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_INTRA ||
-      self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) {
-    self->frame_forward = self->frame_backward;
-  }
-
-  // Skip extensions, user data
-  do {
-    self->start_code = plm_buffer_next_start_code(self->buffer);
-  } while (self->start_code == PLM_START_EXTENSION ||
-           self->start_code == PLM_START_USER_DATA);
-
-  while (self->start_code >= PLM_START_SLICE_FIRST &&
-         self->start_code <= PLM_START_SLICE_LAST) {
-    plm_video_decode_slice(self, self->start_code & 0x000000FF);
-    if (self->macroblock_address == self->mb_size - 1) {
-      break;
-    }
-    self->start_code = plm_buffer_next_start_code(self->buffer);
-  }
-
-  // If this is a reference picutre rotate the prediction pointers
-  if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_INTRA ||
-      self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) {
-    self->frame_backward = self->frame_current;
-    self->frame_current = frame_temp;
-  }
-}
-
-static plm_frame_t *plm_video_decode_impl(plm_video_t *self) {
-  plm_frame_t *frame = NULL;
-  if (!self->has_sequence_header) {
-    self->start_code =
-        plm_buffer_find_start_code(self->buffer, PLM_START_SEQUENCE);
-    if (self->start_code == -1) {
-      return NULL;
-    }
-    plm_video_decode_sequence_header(self);
-  }
-  do {
-    if (self->start_code != PLM_START_PICTURE) {
-      self->start_code =
-          plm_buffer_find_start_code(self->buffer, PLM_START_PICTURE);
-    }
-    if (self->start_code == -1) {
-      return NULL;
-    }
-    plm_video_decode_picture(self);
-    if (self->assume_no_b_frames) {
-      frame = &self->frame_backward;
-    } else if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) {
-      frame = &self->frame_current;
-    } else if (self->has_reference_frame) {
-      frame = &self->frame_forward;
-    } else {
-      self->has_reference_frame = true;
-    }
-  } while (!frame);
-  frame->time = self->time;
-  self->frames_decoded++;
-  self->time = (double)self->frames_decoded / self->framerate;
-  return frame;
-}
-
-plm_frame_t *plm_video_decode(plm_video_t *self) {
-  plm_frame_t *res;
-  struct timespec tsc;
-  INFOF("plm_video_decode");
-  tsc = timespec_real();
-  res = plm_video_decode_impl(self);
-  plmpegdecode_latency_ = timespec_tomicros(timespec_sub(timespec_real(), tsc));
-  return res;
-}
-
-plm_video_t *plm_video_create_with_buffer(plm_buffer_t *buffer,
-                                          int destroy_when_done) {
-  plm_video_t *self = (plm_video_t *)memalign(64, sizeof(plm_video_t));
-  memset(self, 0, sizeof(plm_video_t));
-  self->buffer = buffer;
-  self->destroy_buffer_when_done = destroy_when_done;
-  self->start_code =
-      plm_buffer_find_start_code(self->buffer, PLM_START_SEQUENCE);
-  if (self->start_code != -1) {
-    plm_video_decode_sequence_header(self);
-  }
-  return self;
-}
-
-__attribute__((__constructor__)) static textstartup void plm_video_init(void) {
-  PLM_VIDEO_MACROBLOCK_TYPE[0] = NULL;
-  PLM_VIDEO_MACROBLOCK_TYPE[1] = (void *)PLM_VIDEO_MACROBLOCK_TYPE_INTRA;
-  PLM_VIDEO_MACROBLOCK_TYPE[2] = (void *)PLM_VIDEO_MACROBLOCK_TYPE_PREDICTIVE;
-  PLM_VIDEO_MACROBLOCK_TYPE[3] = (void *)PLM_VIDEO_MACROBLOCK_TYPE_B;
-  PLM_VIDEO_DCT_SIZE[0] = (void *)PLM_VIDEO_DCT_SIZE_LUMINANCE;
-  PLM_VIDEO_DCT_SIZE[1] = (void *)PLM_VIDEO_DCT_SIZE_CHROMINANCE;
-  PLM_VIDEO_DCT_SIZE[2] = (void *)PLM_VIDEO_DCT_SIZE_CHROMINANCE;
-}
diff --git a/dsp/mpeg/notice.c b/dsp/mpeg/notice.c
deleted file mode 100644
index 264a7549b..000000000
--- a/dsp/mpeg/notice.c
+++ /dev/null
@@ -1,4 +0,0 @@
-__notice(pl_mpeg_notice, "\
-PL_MPEG (MIT License)\n\
-Copyright(c) 2019 Dominic Szablewski\n\
-https://phoboslab.org");
diff --git a/dsp/mpeg/pl_mpeg.c b/dsp/mpeg/pl_mpeg.c
new file mode 100644
index 000000000..e2f4a75d9
--- /dev/null
+++ b/dsp/mpeg/pl_mpeg.c
@@ -0,0 +1,9 @@
+__notice(pl_mpeg_notice, "\
+PL_MPEG (MIT License)\n\
+Copyright(c) 2019 Dominic Szablewski\n\
+https://phoboslab.org");
+
+long plmpegdecode_latency_;
+
+#define PL_MPEG_IMPLEMENTATION
+#include "pl_mpeg.h"
diff --git a/dsp/mpeg/pl_mpeg.h b/dsp/mpeg/pl_mpeg.h
new file mode 100755
index 000000000..f81a8463a
--- /dev/null
+++ b/dsp/mpeg/pl_mpeg.h
@@ -0,0 +1,4379 @@
+/*
+PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer
+
+Dominic Szablewski - https://phoboslab.org
+
+
+-- LICENSE: The MIT License(MIT)
+
+Copyright(c) 2019 Dominic Szablewski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files(the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and / or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions :
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+
+
+-- Synopsis
+
+// Define `PL_MPEG_IMPLEMENTATION` in *one* C/C++ file before including this
+// library to create the implementation.
+
+#define PL_MPEG_IMPLEMENTATION
+#𝑖𝑛𝑐𝑙𝑢𝑑𝑒 "plmpeg.h"
+
+// This function gets called for each decoded video frame
+void my_video_callback(plm_t *plm, plm_frame_t *frame, void *user) {
+	// Do something with frame->y.data, frame->cr.data, frame->cb.data
+}
+
+// This function gets called for each decoded audio frame
+void my_audio_callback(plm_t *plm, plm_samples_t *frame, void *user) {
+	// Do something with samples->interleaved
+}
+
+// Load a .mpg (MPEG Program Stream) file
+plm_t *plm = plm_create_with_filename("some-file.mpg");
+
+// Install the video & audio decode callbacks
+plm_set_video_decode_callback(plm, my_video_callback, my_data);
+plm_set_audio_decode_callback(plm, my_audio_callback, my_data);
+
+
+// Decode
+do {
+	plm_decode(plm, time_since_last_call);
+} while (!plm_has_ended(plm));
+
+// All done
+plm_destroy(plm);
+
+
+
+-- Documentation
+
+This library provides several interfaces to load, demux and decode MPEG video
+and audio data. A high-level API combines the demuxer, video & audio decoders
+in an easy to use wrapper.
+
+Lower-level APIs for accessing the demuxer, video decoder and audio decoder, 
+as well as providing different data sources are also available.
+
+Interfaces are written in an object oriented style, meaning you create object 
+instances via various different constructor functions (plm_*create()),
+do some work on them and later dispose them via plm_*destroy().
+
+plm_* ......... the high-level interface, combining demuxer and decoders
+plm_buffer_* .. the data source used by all interfaces
+plm_demux_* ... the MPEG-PS demuxer
+plm_video_* ... the MPEG1 Video ("mpeg1") decoder
+plm_audio_* ... the MPEG1 Audio Layer II ("mp2") decoder
+
+
+With the high-level interface you have two options to decode video & audio:
+
+ 1. Use plm_decode() and just hand over the delta time since the last call.
+    It will decode everything needed and call your callbacks (specified through
+    plm_set_{video|audio}_decode_callback()) any number of times.
+
+ 2. Use plm_decode_video() and plm_decode_audio() to decode exactly one
+    frame of video or audio data at a time. How you handle the synchronization 
+    of both streams is up to you.
+
+If you only want to decode video *or* audio through these functions, you should
+disable the other stream (plm_set_{video|audio}_enabled(FALSE))
+
+Video data is decoded into a struct with all 3 planes (Y, Cr, Cb) stored in
+separate buffers. You can either convert this to RGB on the CPU (slow) via the
+plm_frame_to_rgb() function or do it on the GPU with the following matrix:
+
+mat4 bt601 = mat4(
+	1.16438,  0.00000,  1.59603, -0.87079,
+	1.16438, -0.39176, -0.81297,  0.52959,
+	1.16438,  2.01723,  0.00000, -1.08139,
+	0, 0, 0, 1
+);
+gl_FragColor = vec4(y, cb, cr, 1.0) * bt601;
+
+Audio data is decoded into a struct with either one single float array with the
+samples for the left and right channel interleaved, or if the 
+PLM_AUDIO_SEPARATE_CHANNELS is defined *before* including this library, into
+two separate float arrays - one for each channel.
+
+
+Data can be supplied to the high level interface, the demuxer and the decoders
+in three different ways:
+
+ 1. Using plm_create_from_filename() or with a file handle with 
+    plm_create_from_file().
+
+ 2. Using plm_create_with_memory() and supplying a pointer to memory that
+    contains the whole file.
+
+ 3. Using plm_create_with_buffer(), supplying your own plm_buffer_t instance and
+    periodically writing to this buffer.
+
+When using your own plm_buffer_t instance, you can fill this buffer using 
+plm_buffer_write(). You can either monitor plm_buffer_get_remaining() and push 
+data when appropriate, or install a callback on the buffer with 
+plm_buffer_set_load_callback() that gets called whenever the buffer needs more 
+data.
+
+A buffer created with plm_buffer_create_with_capacity() is treated as a ring
+buffer, meaning that data that has already been read, will be discarded. In
+contrast, a buffer created with plm_buffer_create_for_appending() will keep all
+data written to it in memory. This enables seeking in the already loaded data.
+
+
+There should be no need to use the lower level plm_demux_*, plm_video_* and 
+plm_audio_* functions, if all you want to do is read/decode an MPEG-PS file.
+However, if you get raw mpeg1video data or raw mp2 audio data from a different
+source, these functions can be used to decode the raw data directly. Similarly, 
+if you only want to analyze an MPEG-PS file or extract raw video or audio
+packets from it, you can use the plm_demux_* functions.
+
+
+This library uses malloc(), realloc() and free() to manage memory. Typically 
+all allocation happens up-front when creating the interface. However, the
+default buffer size may be too small for certain inputs. In these cases plmpeg
+will realloc() the buffer with a larger size whenever needed. You can configure
+the default buffer size by defining PLM_BUFFER_DEFAULT_SIZE *before* 
+including this library.
+
+You can also define PLM_MALLOC, PLM_REALLOC and PLM_FREE to provide your own
+memory management functions.
+
+
+See below for detailed the API documentation.
+
+*/
+
+
+#ifndef PL_MPEG_H
+#define PL_MPEG_H
+
+#include <stdint.h>
+#include <stdio.h>
+#include <time.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern long plmpegdecode_latency_; // [jart]
+
+// -----------------------------------------------------------------------------
+// Public Data Types
+
+
+// Object types for the various interfaces
+
+typedef struct plm_t plm_t;
+typedef struct plm_buffer_t plm_buffer_t;
+typedef struct plm_demux_t plm_demux_t;
+typedef struct plm_video_t plm_video_t;
+typedef struct plm_audio_t plm_audio_t;
+
+
+// Demuxed MPEG PS packet
+// The type maps directly to the various MPEG-PES start codes. PTS is the
+// presentation time stamp of the packet in seconds. Note that not all packets
+// have a PTS value, indicated by PLM_PACKET_INVALID_TS.
+
+#define PLM_PACKET_INVALID_TS -1
+
+typedef struct {
+	int type;
+	double pts;
+	size_t length;
+	uint8_t *data;
+} plm_packet_t;
+
+
+// Decoded Video Plane 
+// The byte length of the data is width * height. Note that different planes
+// have different sizes: the Luma plane (Y) is double the size of each of 
+// the two Chroma planes (Cr, Cb) - i.e. 4 times the byte length.
+// Also note that the size of the plane does *not* denote the size of the 
+// displayed frame. The sizes of planes are always rounded up to the nearest
+// macroblock (16px).
+
+typedef struct {
+	unsigned int width;
+	unsigned int height;
+	uint8_t *data;
+} plm_plane_t;
+
+
+// Decoded Video Frame
+// width and height denote the desired display size of the frame. This may be
+// different from the internal size of the 3 planes.
+
+typedef struct {
+	double time;
+	unsigned int width;
+	unsigned int height;
+	plm_plane_t y;
+	plm_plane_t cr;
+	plm_plane_t cb;
+} plm_frame_t;
+
+
+// Callback function type for decoded video frames used by the high-level
+// plm_* interface
+
+typedef void(*plm_video_decode_callback)
+	(plm_t *self, plm_frame_t *frame, void *user);
+
+
+// Decoded Audio Samples
+// Samples are stored as normalized (-1, 1) float either interleaved, or if
+// PLM_AUDIO_SEPARATE_CHANNELS is defined, in two separate arrays.
+// The `count` is always PLM_AUDIO_SAMPLES_PER_FRAME and just there for
+// convenience.
+
+#define PLM_AUDIO_SAMPLES_PER_FRAME 1152
+
+typedef struct {
+	double time;
+	unsigned int count;
+	#ifdef PLM_AUDIO_SEPARATE_CHANNELS
+		float left[PLM_AUDIO_SAMPLES_PER_FRAME];
+		float right[PLM_AUDIO_SAMPLES_PER_FRAME];
+	#else
+		float interleaved[PLM_AUDIO_SAMPLES_PER_FRAME * 2];
+	#endif
+} plm_samples_t;
+
+
+// Callback function type for decoded audio samples used by the high-level
+// plm_* interface
+
+typedef void(*plm_audio_decode_callback)
+	(plm_t *self, plm_samples_t *samples, void *user);
+
+
+// Callback function for plm_buffer when it needs more data
+
+typedef void(*plm_buffer_load_callback)(plm_buffer_t *self, void *user);
+
+
+
+// -----------------------------------------------------------------------------
+// plm_* public API
+// High-Level API for loading/demuxing/decoding MPEG-PS data
+
+
+// Create a plmpeg instance with a filename. Returns NULL if the file could not
+// be opened.
+
+plm_t *plm_create_with_filename(const char *filename);
+
+
+// Create a plmpeg instance with a file handle. Pass TRUE to close_when_done to
+// let plmpeg call fclose() on the handle when plm_destroy() is called.
+
+plm_t *plm_create_with_file(FILE *fh, int close_when_done);
+
+
+// Create a plmpeg instance with a pointer to memory as source. This assumes the
+// whole file is in memory. The memory is not copied. Pass TRUE to 
+// free_when_done to let plmpeg call free() on the pointer when plm_destroy() 
+// is called.
+
+plm_t *plm_create_with_memory(uint8_t *bytes, size_t length, int free_when_done);
+
+
+// Create a plmpeg instance with a plm_buffer as source. Pass TRUE to
+// destroy_when_done to let plmpeg call plm_buffer_destroy() on the buffer when
+// plm_destroy() is called.
+
+plm_t *plm_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done);
+
+
+// Destroy a plmpeg instance and free all data.
+
+void plm_destroy(plm_t *self);
+
+
+// Get whether we have headers on all available streams and we can report the 
+// number of video/audio streams, video dimensions, framerate and audio 
+// samplerate.
+// This returns FALSE if the file is not an MPEG-PS file or - when not using a
+// file as source - when not enough data is available yet.
+
+int plm_has_headers(plm_t *self);
+
+
+// Probe the MPEG-PS data to find the actual number of video and audio streams
+// within the buffer. For certain files (e.g. VideoCD) this can be more accurate
+// than just reading the number of streams from the headers.
+// This should only be used when the underlying plm_buffer is seekable, i.e. for 
+// files, fixed memory buffers or _for_appending buffers. If used with dynamic
+// memory buffers it will skip decoding the probesize!
+// The necessary probesize is dependent on the files you expect to read. Usually
+// a few hundred KB should be enough to find all streams.
+// Use plm_get_num_{audio|video}_streams() afterwards to get the number of 
+// streams in the file.
+// Returns TRUE if any streams were found within the probesize.
+
+int plm_probe(plm_t *self, size_t probesize);
+
+
+// Get or set whether video decoding is enabled. Default TRUE.
+
+int plm_get_video_enabled(plm_t *self);
+void plm_set_video_enabled(plm_t *self, int enabled);
+
+
+// Get the number of video streams (0--1) reported in the system header.
+
+int plm_get_num_video_streams(plm_t *self);
+
+
+// Get the display width/height of the video stream.
+
+int plm_get_width(plm_t *self);
+int plm_get_height(plm_t *self);
+double plm_get_pixel_aspect_ratio(plm_t *self); // [jart]
+
+
+// Get the framerate of the video stream in frames per second.
+
+double plm_get_framerate(plm_t *self);
+
+
+// Get or set whether audio decoding is enabled. Default TRUE.
+
+int plm_get_audio_enabled(plm_t *self);
+void plm_set_audio_enabled(plm_t *self, int enabled);
+
+
+// Get the number of audio streams (0--4) reported in the system header.
+
+int plm_get_num_audio_streams(plm_t *self);
+
+
+// Set the desired audio stream (0--3). Default 0.
+
+void plm_set_audio_stream(plm_t *self, int stream_index);
+
+
+// Get the samplerate of the audio stream in samples per second.
+
+int plm_get_samplerate(plm_t *self);
+
+
+// Get or set the audio lead time in seconds - the time in which audio samples
+// are decoded in advance (or behind) the video decode time. Typically this
+// should be set to the duration of the buffer of the audio API that you use
+// for output. E.g. for SDL2: (SDL_AudioSpec.samples / samplerate)
+
+double plm_get_audio_lead_time(plm_t *self);
+void plm_set_audio_lead_time(plm_t *self, double lead_time);
+
+
+// Get the current internal time in seconds.
+
+double plm_get_time(plm_t *self);
+
+
+// Get the video duration of the underlying source in seconds.
+
+double plm_get_duration(plm_t *self);
+
+
+// Rewind all buffers back to the beginning.
+
+void plm_rewind(plm_t *self);
+
+
+// Get or set looping. Default FALSE.
+
+int plm_get_loop(plm_t *self);
+void plm_set_loop(plm_t *self, int loop);
+
+
+// Get whether the file has ended. If looping is enabled, this will always
+// return FALSE.
+
+int plm_has_ended(plm_t *self);
+
+
+// Set the callback for decoded video frames used with plm_decode(). If no 
+// callback is set, video data will be ignored and not be decoded. The *user
+// Parameter will be passed to your callback.
+
+void plm_set_video_decode_callback(plm_t *self, plm_video_decode_callback fp, void *user);
+
+
+// Set the callback for decoded audio samples used with plm_decode(). If no 
+// callback is set, audio data will be ignored and not be decoded. The *user
+// Parameter will be passed to your callback.
+
+void plm_set_audio_decode_callback(plm_t *self, plm_audio_decode_callback fp, void *user);
+
+
+// Advance the internal timer by seconds and decode video/audio up to this time.
+// This will call the video_decode_callback and audio_decode_callback any number
+// of times. A frame-skip is not implemented, i.e. everything up to current time
+// will be decoded.
+
+void plm_decode(plm_t *self, double seconds);
+
+
+// Decode and return one video frame. Returns NULL if no frame could be decoded
+// (either because the source ended or data is corrupt). If you only want to 
+// decode video, you should disable audio via plm_set_audio_enabled().
+// The returned plm_frame_t is valid until the next call to plm_decode_video() 
+// or until plm_destroy() is called.
+
+plm_frame_t *plm_decode_video(plm_t *self);
+
+
+// Decode and return one audio frame. Returns NULL if no frame could be decoded
+// (either because the source ended or data is corrupt). If you only want to 
+// decode audio, you should disable video via plm_set_video_enabled().
+// The returned plm_samples_t is valid until the next call to plm_decode_audio()
+// or until plm_destroy() is called.
+
+plm_samples_t *plm_decode_audio(plm_t *self);
+
+
+// Seek to the specified time, clamped between 0 -- duration. This can only be 
+// used when the underlying plm_buffer is seekable, i.e. for files, fixed 
+// memory buffers or _for_appending buffers. 
+// If seek_exact is TRUE this will seek to the exact time, otherwise it will 
+// seek to the last intra frame just before the desired time. Exact seeking can 
+// be slow, because all frames up to the seeked one have to be decoded on top of
+// the previous intra frame.
+// If seeking succeeds, this function will call the video_decode_callback 
+// exactly once with the target frame. If audio is enabled, it will also call
+// the audio_decode_callback any number of times, until the audio_lead_time is
+// satisfied.
+// Returns TRUE if seeking succeeded or FALSE if no frame could be found.
+
+int plm_seek(plm_t *self, double time, int seek_exact);
+
+
+// Similar to plm_seek(), but will not call the video_decode_callback,
+// audio_decode_callback or make any attempts to sync audio.
+// Returns the found frame or NULL if no frame could be found.
+
+plm_frame_t *plm_seek_frame(plm_t *self, double time, int seek_exact);
+
+
+
+// -----------------------------------------------------------------------------
+// plm_buffer public API
+// Provides the data source for all other plm_* interfaces
+
+
+// The default size for buffers created from files or by the high-level API
+
+#ifndef PLM_BUFFER_DEFAULT_SIZE
+#define PLM_BUFFER_DEFAULT_SIZE (128 * 1024)
+#endif
+
+
+// Create a buffer instance with a filename. Returns NULL if the file could not
+// be opened.
+
+plm_buffer_t *plm_buffer_create_with_filename(const char *filename);
+
+
+// Create a buffer instance with a file handle. Pass TRUE to close_when_done
+// to let plmpeg call fclose() on the handle when plm_destroy() is called.
+
+plm_buffer_t *plm_buffer_create_with_file(FILE *fh, int close_when_done);
+
+
+// Create a buffer instance with a pointer to memory as source. This assumes
+// the whole file is in memory. The bytes are not copied. Pass 1 to 
+// free_when_done to let plmpeg call free() on the pointer when plm_destroy() 
+// is called.
+
+plm_buffer_t *plm_buffer_create_with_memory(uint8_t *bytes, size_t length, int free_when_done);
+
+
+// Create an empty buffer with an initial capacity. The buffer will grow
+// as needed. Data that has already been read, will be discarded.
+
+plm_buffer_t *plm_buffer_create_with_capacity(size_t capacity);
+
+
+// Create an empty buffer with an initial capacity. The buffer will grow
+// as needed. Decoded data will *not* be discarded. This can be used when
+// loading a file over the network, without needing to throttle the download. 
+// It also allows for seeking in the already loaded data.
+
+plm_buffer_t *plm_buffer_create_for_appending(size_t initial_capacity);
+
+
+// Destroy a buffer instance and free all data
+
+void plm_buffer_destroy(plm_buffer_t *self);
+
+
+// Copy data into the buffer. If the data to be written is larger than the 
+// available space, the buffer will realloc() with a larger capacity. 
+// Returns the number of bytes written. This will always be the same as the
+// passed in length, except when the buffer was created _with_memory() for
+// which _write() is forbidden.
+
+size_t plm_buffer_write(plm_buffer_t *self, uint8_t *bytes, size_t length);
+
+
+// Mark the current byte length as the end of this buffer and signal that no 
+// more data is expected to be written to it. This function should be called
+// just after the last plm_buffer_write().
+// For _with_capacity buffers, this is cleared on a plm_buffer_rewind().
+
+void plm_buffer_signal_end(plm_buffer_t *self);
+
+
+// Set a callback that is called whenever the buffer needs more data
+
+void plm_buffer_set_load_callback(plm_buffer_t *self, plm_buffer_load_callback fp, void *user);
+
+
+// Rewind the buffer back to the beginning. When loading from a file handle,
+// this also seeks to the beginning of the file.
+
+void plm_buffer_rewind(plm_buffer_t *self);
+
+
+// Get the total size. For files, this returns the file size. For all other 
+// types it returns the number of bytes currently in the buffer.
+
+size_t plm_buffer_get_size(plm_buffer_t *self);
+
+
+// Get the number of remaining (yet unread) bytes in the buffer. This can be
+// useful to throttle writing.
+
+size_t plm_buffer_get_remaining(plm_buffer_t *self);
+
+
+// Get whether the read position of the buffer is at the end and no more data 
+// is expected.
+
+int plm_buffer_has_ended(plm_buffer_t *self);
+
+
+
+// -----------------------------------------------------------------------------
+// plm_demux public API
+// Demux an MPEG Program Stream (PS) data into separate packages
+
+
+// Various Packet Types
+
+static const int PLM_DEMUX_PACKET_PRIVATE = 0xBD;
+static const int PLM_DEMUX_PACKET_AUDIO_1 = 0xC0;
+static const int PLM_DEMUX_PACKET_AUDIO_2 = 0xC1;
+static const int PLM_DEMUX_PACKET_AUDIO_3 = 0xC2;
+static const int PLM_DEMUX_PACKET_AUDIO_4 = 0xC3;
+static const int PLM_DEMUX_PACKET_VIDEO_1 = 0xE0;
+
+
+// Create a demuxer with a plm_buffer as source. This will also attempt to read
+// the pack and system headers from the buffer.
+
+plm_demux_t *plm_demux_create(plm_buffer_t *buffer, int destroy_when_done);
+
+
+// Destroy a demuxer and free all data.
+
+void plm_demux_destroy(plm_demux_t *self);
+
+
+// Returns TRUE/FALSE whether pack and system headers have been found. This will
+// attempt to read the headers if non are present yet.
+
+int plm_demux_has_headers(plm_demux_t *self);
+
+
+// Probe the file for the actual number of video/audio streams. See
+// plm_probe() for the details.
+
+int plm_demux_probe(plm_demux_t *self, size_t probesize);
+
+
+// Returns the number of video streams found in the system header. This will
+// attempt to read the system header if non is present yet.
+
+int plm_demux_get_num_video_streams(plm_demux_t *self);
+
+
+// Returns the number of audio streams found in the system header. This will
+// attempt to read the system header if non is present yet.
+
+int plm_demux_get_num_audio_streams(plm_demux_t *self);
+
+
+// Rewind the internal buffer. See plm_buffer_rewind().
+
+void plm_demux_rewind(plm_demux_t *self);
+
+
+// Get whether the file has ended. This will be cleared on seeking or rewind.
+
+int plm_demux_has_ended(plm_demux_t *self);
+
+
+// Seek to a packet of the specified type with a PTS just before specified time.
+// If force_intra is TRUE, only packets containing an intra frame will be 
+// considered - this only makes sense when the type is PLM_DEMUX_PACKET_VIDEO_1.
+// Note that the specified time is considered 0-based, regardless of the first 
+// PTS in the data source.
+
+plm_packet_t *plm_demux_seek(plm_demux_t *self, double time, int type, int force_intra);
+
+
+// Get the PTS of the first packet of this type. Returns PLM_PACKET_INVALID_TS
+// if not packet of this packet type can be found.
+
+double plm_demux_get_start_time(plm_demux_t *self, int type);
+
+
+// Get the duration for the specified packet type - i.e. the span between the
+// the first PTS and the last PTS in the data source. This only makes sense when
+// the underlying data source is a file or fixed memory.
+
+double plm_demux_get_duration(plm_demux_t *self, int type);
+
+
+// Decode and return the next packet. The returned packet_t is valid until
+// the next call to plm_demux_decode() or until the demuxer is destroyed.
+
+plm_packet_t *plm_demux_decode(plm_demux_t *self);
+
+
+
+// -----------------------------------------------------------------------------
+// plm_video public API
+// Decode MPEG1 Video ("mpeg1") data into raw YCrCb frames
+
+
+// Create a video decoder with a plm_buffer as source.
+
+plm_video_t *plm_video_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done);
+
+
+// Destroy a video decoder and free all data.
+
+void plm_video_destroy(plm_video_t *self);
+
+
+// Get whether a sequence header was found and we can accurately report on
+// dimensions and framerate.
+
+int plm_video_has_header(plm_video_t *self);
+
+
+// Get the framerate in frames per second.
+
+double plm_video_get_framerate(plm_video_t *self);
+double plm_video_get_pixel_aspect_ratio(plm_video_t *self); // [jart]
+
+
+// Get the display width/height.
+
+int plm_video_get_width(plm_video_t *self);
+int plm_video_get_height(plm_video_t *self);
+
+
+// Set "no delay" mode. When enabled, the decoder assumes that the video does
+// *not* contain any B-Frames. This is useful for reducing lag when streaming.
+// The default is FALSE.
+
+void plm_video_set_no_delay(plm_video_t *self, int no_delay);
+
+
+// Get the current internal time in seconds.
+
+double plm_video_get_time(plm_video_t *self);
+
+
+// Set the current internal time in seconds. This is only useful when you
+// manipulate the underlying video buffer and want to enforce a correct
+// timestamps.
+
+void plm_video_set_time(plm_video_t *self, double time);
+
+
+// Rewind the internal buffer. See plm_buffer_rewind().
+
+void plm_video_rewind(plm_video_t *self);
+
+
+// Get whether the file has ended. This will be cleared on rewind.
+
+int plm_video_has_ended(plm_video_t *self);
+
+
+// Decode and return one frame of video and advance the internal time by 
+// 1/framerate seconds. The returned frame_t is valid until the next call of
+// plm_video_decode() or until the video decoder is destroyed.
+
+plm_frame_t *plm_video_decode(plm_video_t *self);
+
+
+// Convert the YCrCb data of a frame into interleaved R G B data. The stride
+// specifies the width in bytes of the destination buffer. I.e. the number of
+// bytes from one line to the next. The stride must be at least 
+// (frame->width * bytes_per_pixel). The buffer pointed to by *dest must have a
+// size of at least (stride * frame->height).
+// Note that the alpha component of the dest buffer is always left untouched.
+
+void plm_frame_to_rgb(plm_frame_t *frame, uint8_t *dest, int stride);
+void plm_frame_to_bgr(plm_frame_t *frame, uint8_t *dest, int stride);
+void plm_frame_to_rgba(plm_frame_t *frame, uint8_t *dest, int stride);
+void plm_frame_to_bgra(plm_frame_t *frame, uint8_t *dest, int stride);
+void plm_frame_to_argb(plm_frame_t *frame, uint8_t *dest, int stride);
+void plm_frame_to_abgr(plm_frame_t *frame, uint8_t *dest, int stride);
+
+
+// -----------------------------------------------------------------------------
+// plm_audio public API
+// Decode MPEG-1 Audio Layer II ("mp2") data into raw samples
+
+
+// Create an audio decoder with a plm_buffer as source.
+
+plm_audio_t *plm_audio_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done);
+
+
+// Destroy an audio decoder and free all data.
+
+void plm_audio_destroy(plm_audio_t *self);
+
+
+// Get whether a frame header was found and we can accurately report on
+// samplerate.
+
+int plm_audio_has_header(plm_audio_t *self);
+
+
+// Get the samplerate in samples per second.
+
+int plm_audio_get_samplerate(plm_audio_t *self);
+
+
+// Get the current internal time in seconds.
+
+double plm_audio_get_time(plm_audio_t *self);
+
+
+// Set the current internal time in seconds. This is only useful when you
+// manipulate the underlying video buffer and want to enforce a correct
+// timestamps.
+
+void plm_audio_set_time(plm_audio_t *self, double time);
+
+
+// Rewind the internal buffer. See plm_buffer_rewind().
+
+void plm_audio_rewind(plm_audio_t *self);
+
+
+// Get whether the file has ended. This will be cleared on rewind.
+
+int plm_audio_has_ended(plm_audio_t *self);
+
+
+// Decode and return one "frame" of audio and advance the internal time by 
+// (PLM_AUDIO_SAMPLES_PER_FRAME/samplerate) seconds. The returned samples_t 
+// is valid until the next call of plm_audio_decode() or until the audio
+// decoder is destroyed.
+
+plm_samples_t *plm_audio_decode(plm_audio_t *self);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // PL_MPEG_H
+
+
+
+
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+// IMPLEMENTATION
+
+#ifdef PL_MPEG_IMPLEMENTATION
+
+#include <string.h>
+#include <stdlib.h>
+
+#ifndef TRUE
+#define TRUE 1
+#define FALSE 0
+#endif
+
+#ifndef PLM_MALLOC
+	#define PLM_MALLOC(sz) malloc(sz)
+	#define PLM_FREE(p) free(p)
+	#define PLM_REALLOC(p, sz) realloc(p, sz)
+#endif
+
+#define PLM_UNUSED(expr) (void)(expr)
+
+
+// -----------------------------------------------------------------------------
+// plm (high-level interface) implementation
+
+struct plm_t {
+	plm_demux_t *demux;
+	double time;
+	int has_ended;
+	int loop;
+	int has_decoders;
+
+	int video_enabled;
+	int video_packet_type;
+	plm_buffer_t *video_buffer;
+	plm_video_t *video_decoder;
+
+	int audio_enabled;
+	int audio_stream_index;
+	int audio_packet_type;
+	double audio_lead_time;
+	plm_buffer_t *audio_buffer;
+	plm_audio_t *audio_decoder;
+
+	plm_video_decode_callback video_decode_callback;
+	void *video_decode_callback_user_data;
+
+	plm_audio_decode_callback audio_decode_callback;
+	void *audio_decode_callback_user_data;
+};
+
+int plm_init_decoders(plm_t *self);
+void plm_handle_end(plm_t *self);
+void plm_read_video_packet(plm_buffer_t *buffer, void *user);
+void plm_read_audio_packet(plm_buffer_t *buffer, void *user);
+void plm_read_packets(plm_t *self, int requested_type);
+
+plm_t *plm_create_with_filename(const char *filename) {
+	plm_buffer_t *buffer = plm_buffer_create_with_filename(filename);
+	if (!buffer) {
+		return NULL;
+	}
+	return plm_create_with_buffer(buffer, TRUE);
+}
+
+plm_t *plm_create_with_file(FILE *fh, int close_when_done) {
+	plm_buffer_t *buffer = plm_buffer_create_with_file(fh, close_when_done);
+	return plm_create_with_buffer(buffer, TRUE);
+}
+
+plm_t *plm_create_with_memory(uint8_t *bytes, size_t length, int free_when_done) {
+	plm_buffer_t *buffer = plm_buffer_create_with_memory(bytes, length, free_when_done);
+	return plm_create_with_buffer(buffer, TRUE);
+}
+
+plm_t *plm_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {
+	plm_t *self = (plm_t *)PLM_MALLOC(sizeof(plm_t));
+	memset(self, 0, sizeof(plm_t));
+
+	self->demux = plm_demux_create(buffer, destroy_when_done);
+	self->video_enabled = TRUE;
+	self->audio_enabled = TRUE;
+	plm_init_decoders(self);
+
+	return self;
+}
+
+int plm_init_decoders(plm_t *self) {
+	if (self->has_decoders) {
+		return TRUE;
+	}
+
+	if (!plm_demux_has_headers(self->demux)) {
+		return FALSE;
+	}
+
+	if (plm_demux_get_num_video_streams(self->demux) > 0) {
+		if (self->video_enabled) {
+			self->video_packet_type = PLM_DEMUX_PACKET_VIDEO_1;
+		}
+		if (!self->video_decoder) {
+			self->video_buffer = plm_buffer_create_with_capacity(PLM_BUFFER_DEFAULT_SIZE);
+			plm_buffer_set_load_callback(self->video_buffer, plm_read_video_packet, self);
+			self->video_decoder = plm_video_create_with_buffer(self->video_buffer, TRUE);
+		}
+	}
+
+	if (plm_demux_get_num_audio_streams(self->demux) > 0) {
+		if (self->audio_enabled) {
+			self->audio_packet_type = PLM_DEMUX_PACKET_AUDIO_1 + self->audio_stream_index;
+		}
+		if (!self->audio_decoder) {
+			self->audio_buffer = plm_buffer_create_with_capacity(PLM_BUFFER_DEFAULT_SIZE);
+			plm_buffer_set_load_callback(self->audio_buffer, plm_read_audio_packet, self);
+			self->audio_decoder = plm_audio_create_with_buffer(self->audio_buffer, TRUE);
+		}
+	}
+
+	self->has_decoders = TRUE;
+	return TRUE;
+}
+
+void plm_destroy(plm_t *self) {
+	if (self->video_decoder) {
+		plm_video_destroy(self->video_decoder);
+	}
+	if (self->audio_decoder) {
+		plm_audio_destroy(self->audio_decoder);
+	}
+
+	plm_demux_destroy(self->demux);
+	PLM_FREE(self);
+}
+
+int plm_get_audio_enabled(plm_t *self) {
+	return self->audio_enabled;
+}
+
+int plm_has_headers(plm_t *self) {
+	if (!plm_demux_has_headers(self->demux)) {
+		return FALSE;
+	}
+	
+	if (!plm_init_decoders(self)) {
+		return FALSE;
+	}
+
+	if (
+		(self->video_decoder && !plm_video_has_header(self->video_decoder)) ||
+		(self->audio_decoder && !plm_audio_has_header(self->audio_decoder))
+	) {
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+int plm_probe(plm_t *self, size_t probesize) {
+	int found_streams = plm_demux_probe(self->demux, probesize);
+	if (!found_streams) {
+		return FALSE;
+	}
+
+	// Re-init decoders
+	self->has_decoders = FALSE;
+	self->video_packet_type = 0;
+	self->audio_packet_type = 0;
+	return plm_init_decoders(self);
+}
+
+void plm_set_audio_enabled(plm_t *self, int enabled) {
+	self->audio_enabled = enabled;
+
+	if (!enabled) {
+		self->audio_packet_type = 0;
+		return;
+	}
+
+	self->audio_packet_type = (plm_init_decoders(self) && self->audio_decoder)
+		? PLM_DEMUX_PACKET_AUDIO_1 + self->audio_stream_index
+		: 0;
+}
+
+void plm_set_audio_stream(plm_t *self, int stream_index) {
+	if (stream_index < 0 || stream_index > 3) {
+		return;
+	}
+	self->audio_stream_index = stream_index;
+
+	// Set the correct audio_packet_type
+	plm_set_audio_enabled(self, self->audio_enabled);
+}
+
+int plm_get_video_enabled(plm_t *self) {
+	return self->video_enabled;
+}
+
+void plm_set_video_enabled(plm_t *self, int enabled) {
+	self->video_enabled = enabled;
+
+	if (!enabled) {
+		self->video_packet_type = 0;
+		return;
+	}
+
+	self->video_packet_type = (plm_init_decoders(self) && self->video_decoder)
+		? PLM_DEMUX_PACKET_VIDEO_1
+		: 0;
+}
+
+int plm_get_num_video_streams(plm_t *self) {
+	return plm_demux_get_num_video_streams(self->demux);
+}
+
+int plm_get_width(plm_t *self) {
+	return (plm_init_decoders(self) && self->video_decoder)
+		? plm_video_get_width(self->video_decoder)
+		: 0;
+}
+
+int plm_get_height(plm_t *self) {
+	return (plm_init_decoders(self) && self->video_decoder)
+		? plm_video_get_height(self->video_decoder)
+		: 0;
+}
+
+double plm_get_framerate(plm_t *self) {
+	return (plm_init_decoders(self) && self->video_decoder)
+		? plm_video_get_framerate(self->video_decoder)
+		: 0;
+}
+
+double plm_get_pixel_aspect_ratio(plm_t *self) { // [jart]
+	return (plm_init_decoders(self) && self->video_decoder)
+		? plm_video_get_pixel_aspect_ratio(self->video_decoder)
+		: 0;
+}
+
+int plm_get_num_audio_streams(plm_t *self) {
+	return plm_demux_get_num_audio_streams(self->demux);
+}
+
+int plm_get_samplerate(plm_t *self) {
+	return (plm_init_decoders(self) && self->audio_decoder)
+		? plm_audio_get_samplerate(self->audio_decoder)
+		: 0;
+}
+
+double plm_get_audio_lead_time(plm_t *self) {
+	return self->audio_lead_time;
+}
+
+void plm_set_audio_lead_time(plm_t *self, double lead_time) {
+	self->audio_lead_time = lead_time;
+}
+
+double plm_get_time(plm_t *self) {
+	return self->time;
+}
+
+double plm_get_duration(plm_t *self) {
+	return plm_demux_get_duration(self->demux, PLM_DEMUX_PACKET_VIDEO_1);
+}
+
+void plm_rewind(plm_t *self) {
+	if (self->video_decoder) {
+		plm_video_rewind(self->video_decoder);
+	}
+
+	if (self->audio_decoder) {
+		plm_audio_rewind(self->audio_decoder);
+	}
+
+	plm_demux_rewind(self->demux);
+	self->time = 0;
+}
+
+int plm_get_loop(plm_t *self) {
+	return self->loop;
+}
+
+void plm_set_loop(plm_t *self, int loop) {
+	self->loop = loop;
+}
+
+int plm_has_ended(plm_t *self) {
+	return self->has_ended;
+}
+
+void plm_set_video_decode_callback(plm_t *self, plm_video_decode_callback fp, void *user) {
+	self->video_decode_callback = fp;
+	self->video_decode_callback_user_data = user;
+}
+
+void plm_set_audio_decode_callback(plm_t *self, plm_audio_decode_callback fp, void *user) {
+	self->audio_decode_callback = fp;
+	self->audio_decode_callback_user_data = user;
+}
+
+void plm_decode(plm_t *self, double tick) {
+	if (!plm_init_decoders(self)) {
+		return;
+	}
+
+	int decode_video = (self->video_decode_callback && self->video_packet_type);
+	int decode_audio = (self->audio_decode_callback && self->audio_packet_type);
+
+	if (!decode_video && !decode_audio) {
+		// Nothing to do here
+		return;
+	}
+
+	int did_decode = FALSE;
+	int decode_video_failed = FALSE;
+	int decode_audio_failed = FALSE;
+
+	double video_target_time = self->time + tick;
+	double audio_target_time = self->time + tick + self->audio_lead_time;
+
+	do {
+		did_decode = FALSE;
+		
+		if (decode_video && plm_video_get_time(self->video_decoder) < video_target_time) {
+			plm_frame_t *frame = plm_video_decode(self->video_decoder);
+			if (frame) {
+				self->video_decode_callback(self, frame, self->video_decode_callback_user_data);
+				did_decode = TRUE;
+			}
+			else {
+				decode_video_failed = TRUE;
+			}
+		}
+
+		if (decode_audio && plm_audio_get_time(self->audio_decoder) < audio_target_time) {
+			plm_samples_t *samples = plm_audio_decode(self->audio_decoder);
+			if (samples) {
+				self->audio_decode_callback(self, samples, self->audio_decode_callback_user_data);
+				did_decode = TRUE;
+			}
+			else {
+				decode_audio_failed = TRUE;
+			}
+		}
+	} while (did_decode);
+	
+	// Did all sources we wanted to decode fail and the demuxer is at the end?
+	if (
+		(!decode_video || decode_video_failed) && 
+		(!decode_audio || decode_audio_failed) &&
+		plm_demux_has_ended(self->demux)
+	) {
+		plm_handle_end(self);
+		return;
+	}
+
+	self->time += tick;
+}
+
+plm_frame_t *plm_decode_video(plm_t *self) {
+	if (!plm_init_decoders(self)) {
+		return NULL;
+	}
+
+	if (!self->video_packet_type) {
+		return NULL;
+	}
+
+	plm_frame_t *frame = plm_video_decode(self->video_decoder);
+	if (frame) {
+		self->time = frame->time;
+	}
+	else if (plm_demux_has_ended(self->demux)) {
+		plm_handle_end(self);
+	}
+	return frame;
+}
+
+plm_samples_t *plm_decode_audio(plm_t *self) {
+	if (!plm_init_decoders(self)) {
+		return NULL;
+	}
+
+	if (!self->audio_packet_type) {
+		return NULL;
+	}
+
+	plm_samples_t *samples = plm_audio_decode(self->audio_decoder);
+	if (samples) {
+		self->time = samples->time;
+	}
+	else if (plm_demux_has_ended(self->demux)) {
+		plm_handle_end(self);
+	}
+	return samples;
+}
+
+void plm_handle_end(plm_t *self) {
+	if (self->loop) {
+		plm_rewind(self);
+	}
+	else {
+		self->has_ended = TRUE;
+	}
+}
+
+void plm_read_video_packet(plm_buffer_t *buffer, void *user) {
+	PLM_UNUSED(buffer);
+	plm_t *self = (plm_t *)user;
+	plm_read_packets(self, self->video_packet_type);
+}
+
+void plm_read_audio_packet(plm_buffer_t *buffer, void *user) {
+	PLM_UNUSED(buffer);
+	plm_t *self = (plm_t *)user;
+	plm_read_packets(self, self->audio_packet_type);
+}
+
+void plm_read_packets(plm_t *self, int requested_type) {
+	plm_packet_t *packet;
+	while ((packet = plm_demux_decode(self->demux))) {
+		if (packet->type == self->video_packet_type) {
+			plm_buffer_write(self->video_buffer, packet->data, packet->length);
+		}
+		else if (packet->type == self->audio_packet_type) {
+			plm_buffer_write(self->audio_buffer, packet->data, packet->length);
+		}
+
+		if (packet->type == requested_type) {
+			return;
+		}
+	}
+
+	if (plm_demux_has_ended(self->demux)) {
+		if (self->video_buffer) {
+			plm_buffer_signal_end(self->video_buffer);
+		}
+		if (self->audio_buffer) {
+			plm_buffer_signal_end(self->audio_buffer);
+		}
+	}
+}
+
+plm_frame_t *plm_seek_frame(plm_t *self, double time, int seek_exact) {
+	if (!plm_init_decoders(self)) {
+		return NULL;
+	}
+
+	if (!self->video_packet_type) {
+		return NULL;
+	}
+
+	int type = self->video_packet_type;
+
+	double start_time = plm_demux_get_start_time(self->demux, type);
+	double duration = plm_demux_get_duration(self->demux, type);
+
+	if (time < 0) {
+		time = 0;
+	}
+	else if (time > duration) {
+		time = duration;
+	}
+	
+	plm_packet_t *packet = plm_demux_seek(self->demux, time, type, TRUE);
+	if (!packet) {
+		return NULL;
+	}
+
+	// Disable writing to the audio buffer while decoding video
+	int previous_audio_packet_type = self->audio_packet_type;
+	self->audio_packet_type = 0;
+
+	// Clear video buffer and decode the found packet
+	plm_video_rewind(self->video_decoder);
+	plm_video_set_time(self->video_decoder, packet->pts - start_time);
+	plm_buffer_write(self->video_buffer, packet->data, packet->length);
+	plm_frame_t *frame = plm_video_decode(self->video_decoder);	
+
+	// If we want to seek to an exact frame, we have to decode all frames
+	// on top of the intra frame we just jumped to.
+	if (seek_exact) {
+		while (frame && frame->time < time) {
+			frame = plm_video_decode(self->video_decoder);
+		}
+	}
+
+	// Enable writing to the audio buffer again?
+	self->audio_packet_type = previous_audio_packet_type;
+
+	if (frame) {
+		self->time = frame->time;
+	}
+
+	self->has_ended = FALSE;
+	return frame;
+}
+
+int plm_seek(plm_t *self, double time, int seek_exact) {
+	plm_frame_t *frame = plm_seek_frame(self, time, seek_exact);
+	
+	if (!frame) {
+		return FALSE;
+	}
+
+	if (self->video_decode_callback) {
+		self->video_decode_callback(self, frame, self->video_decode_callback_user_data);	
+	}
+
+	// If audio is not enabled we are done here.
+	if (!self->audio_packet_type) {
+		return TRUE;
+	}
+
+	// Sync up Audio. This demuxes more packets until the first audio packet
+	// with a PTS greater than the current time is found. plm_decode() is then
+	// called to decode enough audio data to satisfy the audio_lead_time.
+
+	double start_time = plm_demux_get_start_time(self->demux, self->video_packet_type);
+	plm_audio_rewind(self->audio_decoder);
+
+	plm_packet_t *packet = NULL;
+	while ((packet = plm_demux_decode(self->demux))) {
+		if (packet->type == self->video_packet_type) {
+			plm_buffer_write(self->video_buffer, packet->data, packet->length);
+		}
+		else if (
+			packet->type == self->audio_packet_type &&
+			packet->pts - start_time > self->time
+		) {
+			plm_audio_set_time(self->audio_decoder, packet->pts - start_time);
+			plm_buffer_write(self->audio_buffer, packet->data, packet->length);
+			plm_decode(self, 0);
+			break;
+		}
+	}	
+	
+	return TRUE;
+}
+
+
+
+// -----------------------------------------------------------------------------
+// plm_buffer implementation
+
+enum plm_buffer_mode {
+	PLM_BUFFER_MODE_FILE,
+	PLM_BUFFER_MODE_FIXED_MEM,
+	PLM_BUFFER_MODE_RING,
+	PLM_BUFFER_MODE_APPEND
+};
+
+struct plm_buffer_t {
+	size_t bit_index;
+	size_t capacity;
+	size_t length;
+	size_t total_size;
+	int discard_read_bytes;
+	int has_ended;
+	int free_when_done;
+	int close_when_done;
+	FILE *fh;
+	plm_buffer_load_callback load_callback;
+	void *load_callback_user_data;
+	uint8_t *bytes;
+	enum plm_buffer_mode mode;
+};
+
+typedef struct {
+	int16_t index;
+	int16_t value;
+} plm_vlc_t;
+
+typedef struct {
+	int16_t index;
+	uint16_t value;
+} plm_vlc_uint_t;
+
+
+void plm_buffer_seek(plm_buffer_t *self, size_t pos);
+size_t plm_buffer_tell(plm_buffer_t *self);
+void plm_buffer_discard_read_bytes(plm_buffer_t *self);
+void plm_buffer_load_file_callback(plm_buffer_t *self, void *user);
+
+int plm_buffer_has(plm_buffer_t *self, size_t count);
+int plm_buffer_read(plm_buffer_t *self, int count);
+void plm_buffer_align(plm_buffer_t *self);
+void plm_buffer_skip(plm_buffer_t *self, size_t count);
+int plm_buffer_skip_bytes(plm_buffer_t *self, uint8_t v);
+int plm_buffer_next_start_code(plm_buffer_t *self);
+int plm_buffer_find_start_code(plm_buffer_t *self, int code);
+int plm_buffer_no_start_code(plm_buffer_t *self);
+int16_t plm_buffer_read_vlc(plm_buffer_t *self, const plm_vlc_t *table);
+uint16_t plm_buffer_read_vlc_uint(plm_buffer_t *self, const plm_vlc_uint_t *table);
+
+plm_buffer_t *plm_buffer_create_with_filename(const char *filename) {
+	FILE *fh = fopen(filename, "rb");
+	if (!fh) {
+		return NULL;
+	}
+	return plm_buffer_create_with_file(fh, TRUE);
+}
+
+plm_buffer_t *plm_buffer_create_with_file(FILE *fh, int close_when_done) {
+	plm_buffer_t *self = plm_buffer_create_with_capacity(PLM_BUFFER_DEFAULT_SIZE);
+	self->fh = fh;
+	self->close_when_done = close_when_done;
+	self->mode = PLM_BUFFER_MODE_FILE;
+	self->discard_read_bytes = TRUE;
+	
+	fseek(self->fh, 0, SEEK_END);
+	self->total_size = ftell(self->fh);
+	fseek(self->fh, 0, SEEK_SET);
+
+	plm_buffer_set_load_callback(self, plm_buffer_load_file_callback, NULL);
+	return self;
+}
+
+plm_buffer_t *plm_buffer_create_with_memory(uint8_t *bytes, size_t length, int free_when_done) {
+	plm_buffer_t *self = (plm_buffer_t *)PLM_MALLOC(sizeof(plm_buffer_t));
+	memset(self, 0, sizeof(plm_buffer_t));
+	self->capacity = length;
+	self->length = length;
+	self->total_size = length;
+	self->free_when_done = free_when_done;
+	self->bytes = bytes;
+	self->mode = PLM_BUFFER_MODE_FIXED_MEM;
+	self->discard_read_bytes = FALSE;
+	return self;
+}
+
+plm_buffer_t *plm_buffer_create_with_capacity(size_t capacity) {
+	plm_buffer_t *self = (plm_buffer_t *)PLM_MALLOC(sizeof(plm_buffer_t));
+	memset(self, 0, sizeof(plm_buffer_t));
+	self->capacity = capacity;
+	self->free_when_done = TRUE;
+	self->bytes = (uint8_t *)PLM_MALLOC(capacity);
+	self->mode = PLM_BUFFER_MODE_RING;
+	self->discard_read_bytes = TRUE;
+	return self;
+}
+
+plm_buffer_t *plm_buffer_create_for_appending(size_t initial_capacity) {
+	plm_buffer_t *self = plm_buffer_create_with_capacity(initial_capacity);
+	self->mode = PLM_BUFFER_MODE_APPEND;
+	self->discard_read_bytes = FALSE;
+	return self;
+}
+
+void plm_buffer_destroy(plm_buffer_t *self) {
+	if (self->fh && self->close_when_done) {
+		fclose(self->fh);
+	}
+	if (self->free_when_done) {
+		PLM_FREE(self->bytes);
+	}
+	PLM_FREE(self);
+}
+
+size_t plm_buffer_get_size(plm_buffer_t *self) {
+	return (self->mode == PLM_BUFFER_MODE_FILE)
+		? self->total_size
+		: self->length;
+}
+
+size_t plm_buffer_get_remaining(plm_buffer_t *self) {
+	return self->length - (self->bit_index >> 3);
+}
+
+size_t plm_buffer_write(plm_buffer_t *self, uint8_t *bytes, size_t length) {
+	if (self->mode == PLM_BUFFER_MODE_FIXED_MEM) {
+		return 0;
+	}
+
+	if (self->discard_read_bytes) {
+		// This should be a ring buffer, but instead it just shifts all unread 
+		// data to the beginning of the buffer and appends new data at the end. 
+		// Seems to be good enough.
+
+		plm_buffer_discard_read_bytes(self);
+		if (self->mode == PLM_BUFFER_MODE_RING) {
+			self->total_size = 0;
+		}
+	}
+
+	// Do we have to resize to fit the new data?
+	size_t bytes_available = self->capacity - self->length;
+	if (bytes_available < length) {
+		size_t new_size = self->capacity;
+		do {
+			new_size *= 2;
+		} while (new_size - self->length < length);
+		self->bytes = (uint8_t *)PLM_REALLOC(self->bytes, new_size);
+		self->capacity = new_size;
+	}
+
+	memcpy(self->bytes + self->length, bytes, length);
+	self->length += length;
+	self->has_ended = FALSE;
+	return length;
+}
+
+void plm_buffer_signal_end(plm_buffer_t *self) {
+	self->total_size = self->length;
+}
+
+void plm_buffer_set_load_callback(plm_buffer_t *self, plm_buffer_load_callback fp, void *user) {
+	self->load_callback = fp;
+	self->load_callback_user_data = user;
+}
+
+void plm_buffer_rewind(plm_buffer_t *self) {
+	plm_buffer_seek(self, 0);
+}
+
+void plm_buffer_seek(plm_buffer_t *self, size_t pos) {
+	self->has_ended = FALSE;
+
+	if (self->mode == PLM_BUFFER_MODE_FILE) {
+		fseek(self->fh, pos, SEEK_SET);
+		self->bit_index = 0;
+		self->length = 0;
+	}
+	else if (self->mode == PLM_BUFFER_MODE_RING) {
+		if (pos != 0) {
+			// Seeking to non-0 is forbidden for dynamic-mem buffers
+			return; 
+		}
+		self->bit_index = 0;
+		self->length = 0;
+		self->total_size = 0;
+	}
+	else if (pos < self->length) {
+		self->bit_index = pos << 3;
+	}
+}
+
+size_t plm_buffer_tell(plm_buffer_t *self) {
+	return self->mode == PLM_BUFFER_MODE_FILE
+		? ftell(self->fh) + (self->bit_index >> 3) - self->length
+		: self->bit_index >> 3;
+}
+
+void plm_buffer_discard_read_bytes(plm_buffer_t *self) {
+	size_t byte_pos = self->bit_index >> 3;
+	if (byte_pos == self->length) {
+		self->bit_index = 0;
+		self->length = 0;
+	}
+	else if (byte_pos > 0) {
+		memmove(self->bytes, self->bytes + byte_pos, self->length - byte_pos);
+		self->bit_index -= byte_pos << 3;
+		self->length -= byte_pos;
+	}
+}
+
+void plm_buffer_load_file_callback(plm_buffer_t *self, void *user) {
+	PLM_UNUSED(user);
+	
+	if (self->discard_read_bytes) {
+		plm_buffer_discard_read_bytes(self);
+	}
+
+	size_t bytes_available = self->capacity - self->length;
+	size_t bytes_read = fread(self->bytes + self->length, 1, bytes_available, self->fh);
+	self->length += bytes_read;
+
+	if (bytes_read == 0) {
+		self->has_ended = TRUE;
+	}
+}
+
+int plm_buffer_has_ended(plm_buffer_t *self) {
+	return self->has_ended;
+}
+
+int plm_buffer_has(plm_buffer_t *self, size_t count) {
+	if (((self->length << 3) - self->bit_index) >= count) {
+		return TRUE;
+	}
+
+	if (self->load_callback) {
+		self->load_callback(self, self->load_callback_user_data);
+		
+		if (((self->length << 3) - self->bit_index) >= count) {
+			return TRUE;
+		}
+	}	
+	
+	if (self->total_size != 0 && self->length == self->total_size) {
+		self->has_ended = TRUE;
+	}
+	return FALSE;
+}
+
+int plm_buffer_read(plm_buffer_t *self, int count) {
+	if (!plm_buffer_has(self, count)) {
+		return 0;
+	}
+
+	int value = 0;
+	while (count) {
+		int current_byte = self->bytes[self->bit_index >> 3];
+
+		int remaining = 8 - (self->bit_index & 7); // Remaining bits in byte
+		int read = remaining < count ? remaining : count; // Bits in self run
+		int shift = remaining - read;
+		int mask = (0xff >> (8 - read));
+
+		value = (value << read) | ((current_byte & (mask << shift)) >> shift);
+
+		self->bit_index += read;
+		count -= read;
+	}
+
+	return value;
+}
+
+void plm_buffer_align(plm_buffer_t *self) {
+	self->bit_index = ((self->bit_index + 7) >> 3) << 3; // Align to next byte
+}
+
+void plm_buffer_skip(plm_buffer_t *self, size_t count) {
+	if (plm_buffer_has(self, count)) {
+		self->bit_index += count;
+	}
+}
+
+int plm_buffer_skip_bytes(plm_buffer_t *self, uint8_t v) {
+	plm_buffer_align(self);
+	int skipped = 0;
+	while (plm_buffer_has(self, 8) && self->bytes[self->bit_index >> 3] == v) {
+		self->bit_index += 8;
+		skipped++;
+	}
+	return skipped;
+}
+
+int plm_buffer_next_start_code(plm_buffer_t *self) {
+	plm_buffer_align(self);
+
+	while (plm_buffer_has(self, (5 << 3))) {
+		size_t byte_index = (self->bit_index) >> 3;
+		if (
+			self->bytes[byte_index] == 0x00 &&
+			self->bytes[byte_index + 1] == 0x00 &&
+			self->bytes[byte_index + 2] == 0x01
+		) {
+			self->bit_index = (byte_index + 4) << 3;
+			return self->bytes[byte_index + 3];
+		}
+		self->bit_index += 8;
+	}
+	return -1;
+}
+
+int plm_buffer_find_start_code(plm_buffer_t *self, int code) {
+	int current = 0;
+	while (TRUE) {
+		current = plm_buffer_next_start_code(self);
+		if (current == code || current == -1) {
+			return current;
+		}
+	}
+	return -1;
+}
+
+int plm_buffer_has_start_code(plm_buffer_t *self, int code) {
+	size_t previous_bit_index = self->bit_index;
+	int previous_discard_read_bytes = self->discard_read_bytes;
+	
+	self->discard_read_bytes = FALSE;
+	int current = plm_buffer_find_start_code(self, code);
+
+	self->bit_index = previous_bit_index;
+	self->discard_read_bytes = previous_discard_read_bytes;
+	return current;
+}
+
+int plm_buffer_peek_non_zero(plm_buffer_t *self, int bit_count) {
+	if (!plm_buffer_has(self, bit_count)) {
+		return FALSE;
+	}
+
+	int val = plm_buffer_read(self, bit_count);
+	self->bit_index -= bit_count;
+	return val != 0;
+}
+
+int16_t plm_buffer_read_vlc(plm_buffer_t *self, const plm_vlc_t *table) {
+	plm_vlc_t state = {0, 0};
+	do {
+		state = table[state.index + plm_buffer_read(self, 1)];
+	} while (state.index > 0);
+	return state.value;
+}
+
+uint16_t plm_buffer_read_vlc_uint(plm_buffer_t *self, const plm_vlc_uint_t *table) {
+	return (uint16_t)plm_buffer_read_vlc(self, (const plm_vlc_t *)table);
+}
+
+
+
+// ----------------------------------------------------------------------------
+// plm_demux implementation
+
+static const int PLM_START_PACK = 0xBA;
+static const int PLM_START_END = 0xB9;
+static const int PLM_START_SYSTEM = 0xBB;
+
+struct plm_demux_t {
+	plm_buffer_t *buffer;
+	int destroy_buffer_when_done;
+	double system_clock_ref;
+
+	size_t last_file_size;
+	double last_decoded_pts;
+	double start_time;
+	double duration;
+
+	int start_code;
+	int has_pack_header;
+	int has_system_header;
+	int has_headers;
+
+	int num_audio_streams;
+	int num_video_streams;
+	plm_packet_t current_packet;
+	plm_packet_t next_packet;
+};
+
+
+void plm_demux_buffer_seek(plm_demux_t *self, size_t pos);
+double plm_demux_decode_time(plm_demux_t *self);
+plm_packet_t *plm_demux_decode_packet(plm_demux_t *self, int type);
+plm_packet_t *plm_demux_get_packet(plm_demux_t *self);
+
+plm_demux_t *plm_demux_create(plm_buffer_t *buffer, int destroy_when_done) {
+	plm_demux_t *self = (plm_demux_t *)PLM_MALLOC(sizeof(plm_demux_t));
+	memset(self, 0, sizeof(plm_demux_t));
+
+	self->buffer = buffer;
+	self->destroy_buffer_when_done = destroy_when_done;
+
+	self->start_time = PLM_PACKET_INVALID_TS;
+	self->duration = PLM_PACKET_INVALID_TS;
+	self->start_code = -1;
+
+	plm_demux_has_headers(self);
+	return self;
+}
+
+void plm_demux_destroy(plm_demux_t *self) {
+	if (self->destroy_buffer_when_done) {
+		plm_buffer_destroy(self->buffer);
+	}
+	PLM_FREE(self);
+}
+
+int plm_demux_has_headers(plm_demux_t *self) {
+	if (self->has_headers) {
+		return TRUE;
+	}
+
+	// Decode pack header
+	if (!self->has_pack_header) {
+		if (
+			self->start_code != PLM_START_PACK &&
+			plm_buffer_find_start_code(self->buffer, PLM_START_PACK) == -1
+		) {
+			return FALSE;
+		}
+
+		self->start_code = PLM_START_PACK;
+		if (!plm_buffer_has(self->buffer, 64)) {
+			return FALSE;
+		}
+		self->start_code = -1;
+
+		if (plm_buffer_read(self->buffer, 4) != 0x02) {
+			return FALSE;
+		}
+
+		self->system_clock_ref = plm_demux_decode_time(self);
+		plm_buffer_skip(self->buffer, 1);
+		plm_buffer_skip(self->buffer, 22); // mux_rate * 50
+		plm_buffer_skip(self->buffer, 1);
+
+		self->has_pack_header = TRUE;
+	}
+
+	// Decode system header
+	if (!self->has_system_header) {
+		if (
+			self->start_code != PLM_START_SYSTEM &&
+			plm_buffer_find_start_code(self->buffer, PLM_START_SYSTEM) == -1
+		) {
+			return FALSE;
+		}
+
+		self->start_code = PLM_START_SYSTEM;
+		if (!plm_buffer_has(self->buffer, 56)) {
+			return FALSE;
+		}
+		self->start_code = -1;
+
+		plm_buffer_skip(self->buffer, 16); // header_length
+		plm_buffer_skip(self->buffer, 24); // rate bound
+		self->num_audio_streams = plm_buffer_read(self->buffer, 6);
+		plm_buffer_skip(self->buffer, 5); // misc flags
+		self->num_video_streams = plm_buffer_read(self->buffer, 5);
+
+		self->has_system_header = TRUE;
+	}
+
+	self->has_headers = TRUE;
+	return TRUE;
+}
+
+int plm_demux_probe(plm_demux_t *self, size_t probesize) {
+	int previous_pos = plm_buffer_tell(self->buffer);
+
+	int video_stream = FALSE;
+	int audio_streams[4] = {FALSE, FALSE, FALSE, FALSE};
+	do {
+		self->start_code = plm_buffer_next_start_code(self->buffer);
+		if (self->start_code == PLM_DEMUX_PACKET_VIDEO_1) {
+			video_stream = TRUE;
+		}
+		else if (
+			self->start_code >= PLM_DEMUX_PACKET_AUDIO_1 && 
+			self->start_code <= PLM_DEMUX_PACKET_AUDIO_4
+		) {
+			audio_streams[self->start_code - PLM_DEMUX_PACKET_AUDIO_1] = TRUE;
+		}
+	} while (
+		self->start_code != -1 && 
+		plm_buffer_tell(self->buffer) - previous_pos < probesize
+	);
+
+	self->num_video_streams = video_stream ? 1 : 0;
+	self->num_audio_streams = 0;
+	for (int i = 0; i < 4; i++) {
+		if (audio_streams[i]) {
+			self->num_audio_streams++;
+		}
+	}
+
+	plm_demux_buffer_seek(self, previous_pos);
+	return (self->num_video_streams || self->num_audio_streams);
+}
+
+int plm_demux_get_num_video_streams(plm_demux_t *self) {
+	return plm_demux_has_headers(self)
+		? self->num_video_streams
+		: 0;
+}
+
+int plm_demux_get_num_audio_streams(plm_demux_t *self) {
+	return plm_demux_has_headers(self)
+		? self->num_audio_streams
+		: 0;
+}
+
+void plm_demux_rewind(plm_demux_t *self) {
+	plm_buffer_rewind(self->buffer);
+	self->current_packet.length = 0;
+	self->next_packet.length = 0;
+	self->start_code = -1;
+}
+
+int plm_demux_has_ended(plm_demux_t *self) {
+	return plm_buffer_has_ended(self->buffer);
+}
+
+void plm_demux_buffer_seek(plm_demux_t *self, size_t pos) {
+	plm_buffer_seek(self->buffer, pos);
+	self->current_packet.length = 0;
+	self->next_packet.length = 0;
+	self->start_code = -1;
+}
+
+double plm_demux_get_start_time(plm_demux_t *self, int type) {
+	if (self->start_time != PLM_PACKET_INVALID_TS) {
+		return self->start_time;
+	}
+
+	int previous_pos = plm_buffer_tell(self->buffer);
+	int previous_start_code = self->start_code;
+	
+	// Find first video PTS
+	plm_demux_rewind(self);
+	do {
+		plm_packet_t *packet = plm_demux_decode(self);
+		if (!packet) {
+			break;
+		}
+		if (packet->type == type) {
+			self->start_time = packet->pts;
+		}
+	} while (self->start_time == PLM_PACKET_INVALID_TS);
+
+	plm_demux_buffer_seek(self, previous_pos);
+	self->start_code = previous_start_code;
+	return self->start_time;
+}
+
+double plm_demux_get_duration(plm_demux_t *self, int type) {
+	size_t file_size = plm_buffer_get_size(self->buffer);
+
+	if (
+		self->duration != PLM_PACKET_INVALID_TS &&
+		self->last_file_size == file_size
+	) {
+		return self->duration;
+	}
+
+	size_t previous_pos = plm_buffer_tell(self->buffer);
+	int previous_start_code = self->start_code;
+	
+	// Find last video PTS. Start searching 64kb from the end and go further 
+	// back if needed.
+	long start_range = 64 * 1024;
+	long max_range = 4096 * 1024;
+	for (long range = start_range; range <= max_range; range *= 2) {
+		long seek_pos = file_size - range;
+		if (seek_pos < 0) {
+			seek_pos = 0;
+			range = max_range; // Make sure to bail after this round
+		}
+		plm_demux_buffer_seek(self, seek_pos);
+		self->current_packet.length = 0;
+
+		double last_pts = PLM_PACKET_INVALID_TS;
+		plm_packet_t *packet = NULL;
+		while ((packet = plm_demux_decode(self))) {
+			if (packet->pts != PLM_PACKET_INVALID_TS && packet->type == type) {
+				last_pts = packet->pts;
+			}
+		}
+		if (last_pts != PLM_PACKET_INVALID_TS) {
+			self->duration = last_pts - plm_demux_get_start_time(self, type);
+			break;
+		}
+	}
+
+	plm_demux_buffer_seek(self, previous_pos);
+	self->start_code = previous_start_code;
+	self->last_file_size = file_size;
+	return self->duration;
+}
+
+plm_packet_t *plm_demux_seek(plm_demux_t *self, double seek_time, int type, int force_intra) {
+	if (!plm_demux_has_headers(self)) {
+		return NULL;
+	}
+
+	// Using the current time, current byte position and the average bytes per
+	// second for this file, try to jump to a byte position that hopefully has
+	// packets containing timestamps within one second before to the desired 
+	// seek_time.
+
+	// If we hit close to the seek_time scan through all packets to find the
+	// last one (just before the seek_time) containing an intra frame.
+	// Otherwise we should at least be closer than before. Calculate the bytes
+	// per second for the jumped range and jump again.
+
+	// The number of retries here is hard-limited to a generous amount. Usually
+	// the correct range is found after 1--5 jumps, even for files with very 
+	// variable bitrates. If significantly more jumps are needed, there's
+	// probably something wrong with the file and we just avoid getting into an
+	// infinite loop. 32 retries should be enough for anybody.
+
+	double duration = plm_demux_get_duration(self, type);
+	long file_size = plm_buffer_get_size(self->buffer);
+	long byterate = file_size / duration;
+
+	double cur_time = self->last_decoded_pts;
+	double scan_span = 1;
+
+	if (seek_time > duration) {
+		seek_time = duration;
+	}
+	else if (seek_time < 0) {
+		seek_time = 0;
+	}
+	seek_time += self->start_time;
+
+	for (int retry = 0; retry < 32; retry++) {
+		int found_packet_with_pts = FALSE;
+		int found_packet_in_range = FALSE;
+		long last_valid_packet_start = -1;
+		double first_packet_time = PLM_PACKET_INVALID_TS;
+
+		long cur_pos = plm_buffer_tell(self->buffer);
+
+		// Estimate byte offset and jump to it.
+		long offset = (seek_time - cur_time - scan_span) * byterate;
+		long seek_pos = cur_pos + offset;
+		if (seek_pos < 0) {
+			seek_pos = 0;
+		}
+		else if (seek_pos > file_size - 256) {
+			seek_pos = file_size - 256;
+		}
+
+		plm_demux_buffer_seek(self, seek_pos);
+
+		// Scan through all packets up to the seek_time to find the last packet
+		// containing an intra frame.
+		while (plm_buffer_find_start_code(self->buffer, type) != -1) {
+			long packet_start = plm_buffer_tell(self->buffer);
+			plm_packet_t *packet = plm_demux_decode_packet(self, type);
+
+			// Skip packet if it has no PTS
+			if (!packet || packet->pts == PLM_PACKET_INVALID_TS) {
+				continue;
+			}
+
+			// Bail scanning through packets if we hit one that is outside
+			// seek_time - scan_span.
+			// We also adjust the cur_time and byterate values here so the next 
+			// iteration can be a bit more precise.
+			if (packet->pts > seek_time || packet->pts < seek_time - scan_span) {
+				found_packet_with_pts = TRUE;
+				byterate = (seek_pos - cur_pos) / (packet->pts - cur_time);
+				cur_time = packet->pts;
+				break;
+			}
+
+			// If we are still here, it means this packet is in close range to
+			// the seek_time. If this is the first packet for this jump position
+			// record the PTS. If we later have to back off, when there was no
+			// intra frame in this range, we can lower the seek_time to not scan
+			// this range again.
+			if (!found_packet_in_range) {
+				found_packet_in_range = TRUE;
+				first_packet_time = packet->pts;
+			}
+
+			// Check if this is an intra frame packet. If so, record the buffer
+			// position of the start of this packet. We want to jump back to it 
+			// later, when we know it's the last intra frame before desired
+			// seek time.
+			if (force_intra) {
+				for (size_t i = 0; i < packet->length - 6; i++) {
+					// Find the START_PICTURE code
+					if (
+						packet->data[i] == 0x00 &&
+						packet->data[i + 1] == 0x00 &&
+						packet->data[i + 2] == 0x01 &&
+						packet->data[i + 3] == 0x00
+					) {
+						// Bits 11--13 in the picture header contain the frame 
+						// type, where 1=Intra
+						if ((packet->data[i + 5] & 0x38) == 8) {
+							last_valid_packet_start = packet_start;
+						}
+						break;
+					}
+				}
+			}
+
+			// If we don't want intra frames, just use the last PTS found.
+			else {
+				last_valid_packet_start = packet_start;
+			}
+		}
+
+		// If there was at least one intra frame in the range scanned above,
+		// our search is over. Jump back to the packet and decode it again.
+		if (last_valid_packet_start != -1) {
+			plm_demux_buffer_seek(self, last_valid_packet_start);
+			return plm_demux_decode_packet(self, type);
+		}
+
+		// If we hit the right range, but still found no intra frame, we have
+		// to increases the scan_span. This is done exponentially to also handle
+		// video files with very few intra frames.
+		else if (found_packet_in_range) {
+			scan_span *= 2;
+			seek_time = first_packet_time;
+		}
+
+		// If we didn't find any packet with a PTS, it probably means we reached
+		// the end of the file. Estimate byterate and cur_time accordingly.
+		else if (!found_packet_with_pts) {
+			byterate = (seek_pos - cur_pos) / (duration - cur_time);
+			cur_time = duration;
+		}
+	}
+
+	return NULL;
+}
+
+plm_packet_t *plm_demux_decode(plm_demux_t *self) {
+	if (!plm_demux_has_headers(self)) {
+		return NULL;
+	}
+
+	if (self->current_packet.length) {
+		size_t bits_till_next_packet = self->current_packet.length << 3;
+		if (!plm_buffer_has(self->buffer, bits_till_next_packet)) {
+			return NULL;
+		}
+		plm_buffer_skip(self->buffer, bits_till_next_packet);
+		self->current_packet.length = 0;
+	}
+
+	// Pending packet waiting for data?
+	if (self->next_packet.length) {
+		return plm_demux_get_packet(self);
+	}
+
+	// Pending packet waiting for header?
+	if (self->start_code != -1) {
+		return plm_demux_decode_packet(self, self->start_code);
+	}
+
+	do {
+		self->start_code = plm_buffer_next_start_code(self->buffer);
+		if (
+			self->start_code == PLM_DEMUX_PACKET_VIDEO_1 || 
+			self->start_code == PLM_DEMUX_PACKET_PRIVATE || (
+				self->start_code >= PLM_DEMUX_PACKET_AUDIO_1 && 
+				self->start_code <= PLM_DEMUX_PACKET_AUDIO_4
+			)
+		) {
+			return plm_demux_decode_packet(self, self->start_code);
+		}
+	} while (self->start_code != -1);
+
+	return NULL;
+}
+
+double plm_demux_decode_time(plm_demux_t *self) {
+	int64_t clock = plm_buffer_read(self->buffer, 3) << 30;
+	plm_buffer_skip(self->buffer, 1);
+	clock |= plm_buffer_read(self->buffer, 15) << 15;
+	plm_buffer_skip(self->buffer, 1);
+	clock |= plm_buffer_read(self->buffer, 15);
+	plm_buffer_skip(self->buffer, 1);
+	return (double)clock / 90000.0;
+}
+
+plm_packet_t *plm_demux_decode_packet(plm_demux_t *self, int type) {
+	if (!plm_buffer_has(self->buffer, 16 << 3)) {
+		return NULL;
+	}
+
+	self->start_code = -1;
+
+	self->next_packet.type = type;
+	self->next_packet.length = plm_buffer_read(self->buffer, 16);
+	self->next_packet.length -= plm_buffer_skip_bytes(self->buffer, 0xff); // stuffing
+
+	// skip P-STD
+	if (plm_buffer_read(self->buffer, 2) == 0x01) {
+		plm_buffer_skip(self->buffer, 16);
+		self->next_packet.length -= 2;
+	}
+
+	int pts_dts_marker = plm_buffer_read(self->buffer, 2);
+	if (pts_dts_marker == 0x03) {
+		self->next_packet.pts = plm_demux_decode_time(self);
+		self->last_decoded_pts = self->next_packet.pts;
+		plm_buffer_skip(self->buffer, 40); // skip dts
+		self->next_packet.length -= 10;
+	}
+	else if (pts_dts_marker == 0x02) {
+		self->next_packet.pts = plm_demux_decode_time(self);
+		self->last_decoded_pts = self->next_packet.pts;
+		self->next_packet.length -= 5;
+	}
+	else if (pts_dts_marker == 0x00) {
+		self->next_packet.pts = PLM_PACKET_INVALID_TS;
+		plm_buffer_skip(self->buffer, 4);
+		self->next_packet.length -= 1;
+	}
+	else {
+		return NULL; // invalid
+	}
+	
+	return plm_demux_get_packet(self);
+}
+
+plm_packet_t *plm_demux_get_packet(plm_demux_t *self) {
+	if (!plm_buffer_has(self->buffer, self->next_packet.length << 3)) {
+		return NULL;
+	}
+
+	self->current_packet.data = self->buffer->bytes + (self->buffer->bit_index >> 3);
+	self->current_packet.length = self->next_packet.length;
+	self->current_packet.type = self->next_packet.type;
+	self->current_packet.pts = self->next_packet.pts;
+
+	self->next_packet.length = 0;
+	return &self->current_packet;
+}
+
+
+
+// -----------------------------------------------------------------------------
+// plm_video implementation
+
+// Inspired by Java MPEG-1 Video Decoder and Player by Zoltan Korandi 
+// https://sourceforge.net/projects/javampeg1video/
+
+static const int PLM_VIDEO_PICTURE_TYPE_INTRA = 1;
+static const int PLM_VIDEO_PICTURE_TYPE_PREDICTIVE = 2;
+static const int PLM_VIDEO_PICTURE_TYPE_B = 3;
+
+static const int PLM_START_SEQUENCE = 0xB3;
+static const int PLM_START_SLICE_FIRST = 0x01;
+static const int PLM_START_SLICE_LAST = 0xAF;
+static const int PLM_START_PICTURE = 0x00;
+static const int PLM_START_EXTENSION = 0xB5;
+static const int PLM_START_USER_DATA = 0xB2;
+
+#define PLM_START_IS_SLICE(c) \
+	(c >= PLM_START_SLICE_FIRST && c <= PLM_START_SLICE_LAST)
+
+static const float PLM_VIDEO_PIXEL_ASPECT_RATIO[] = { // [jart]
+	1.0000, /* square pixels */
+	0.6735, /* 3:4? */
+	0.7031, /* MPEG-1 / MPEG-2 video encoding divergence? */
+	0.7615, 0.8055, 0.8437, 0.8935, 0.9157, 0.9815,
+	1.0255, 1.0695, 1.0950, 1.1575, 1.2051,
+};
+
+static const double PLM_VIDEO_PICTURE_RATE[] = {
+	0.000, 23.976, 24.000, 25.000, 29.970, 30.000, 50.000, 59.940,
+	60.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000
+};
+
+static const uint8_t PLM_VIDEO_ZIG_ZAG[] = {
+	 0,  1,  8, 16,  9,  2,  3, 10,
+	17, 24, 32, 25, 18, 11,  4,  5,
+	12, 19, 26, 33, 40, 48, 41, 34,
+	27, 20, 13,  6,  7, 14, 21, 28,
+	35, 42, 49, 56, 57, 50, 43, 36,
+	29, 22, 15, 23, 30, 37, 44, 51,
+	58, 59, 52, 45, 38, 31, 39, 46,
+	53, 60, 61, 54, 47, 55, 62, 63
+};
+
+static const uint8_t PLM_VIDEO_INTRA_QUANT_MATRIX[] = {
+	 8, 16, 19, 22, 26, 27, 29, 34,
+	16, 16, 22, 24, 27, 29, 34, 37,
+	19, 22, 26, 27, 29, 34, 34, 38,
+	22, 22, 26, 27, 29, 34, 37, 40,
+	22, 26, 27, 29, 32, 35, 40, 48,
+	26, 27, 29, 32, 35, 40, 48, 58,
+	26, 27, 29, 34, 38, 46, 56, 69,
+	27, 29, 35, 38, 46, 56, 69, 83
+};
+
+static const uint8_t PLM_VIDEO_NON_INTRA_QUANT_MATRIX[] = {
+	16, 16, 16, 16, 16, 16, 16, 16,
+	16, 16, 16, 16, 16, 16, 16, 16,
+	16, 16, 16, 16, 16, 16, 16, 16,
+	16, 16, 16, 16, 16, 16, 16, 16,
+	16, 16, 16, 16, 16, 16, 16, 16,
+	16, 16, 16, 16, 16, 16, 16, 16,
+	16, 16, 16, 16, 16, 16, 16, 16,
+	16, 16, 16, 16, 16, 16, 16, 16
+};
+
+static const uint8_t PLM_VIDEO_PREMULTIPLIER_MATRIX[] = {
+	32, 44, 42, 38, 32, 25, 17,  9,
+	44, 62, 58, 52, 44, 35, 24, 12,
+	42, 58, 55, 49, 42, 33, 23, 12,
+	38, 52, 49, 44, 38, 30, 20, 10,
+	32, 44, 42, 38, 32, 25, 17,  9,
+	25, 35, 33, 30, 25, 20, 14,  7,
+	17, 24, 23, 20, 17, 14,  9,  5,
+	 9, 12, 12, 10,  9,  7,  5,  2
+};
+
+static const plm_vlc_t PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT[] = {
+	{  1 << 1,    0}, {       0,    1},  //   0: x
+	{  2 << 1,    0}, {  3 << 1,    0},  //   1: 0x
+	{  4 << 1,    0}, {  5 << 1,    0},  //   2: 00x
+	{       0,    3}, {       0,    2},  //   3: 01x
+	{  6 << 1,    0}, {  7 << 1,    0},  //   4: 000x
+	{       0,    5}, {       0,    4},  //   5: 001x
+	{  8 << 1,    0}, {  9 << 1,    0},  //   6: 0000x
+	{       0,    7}, {       0,    6},  //   7: 0001x
+	{ 10 << 1,    0}, { 11 << 1,    0},  //   8: 0000 0x
+	{ 12 << 1,    0}, { 13 << 1,    0},  //   9: 0000 1x
+	{ 14 << 1,    0}, { 15 << 1,    0},  //  10: 0000 00x
+	{ 16 << 1,    0}, { 17 << 1,    0},  //  11: 0000 01x
+	{ 18 << 1,    0}, { 19 << 1,    0},  //  12: 0000 10x
+	{       0,    9}, {       0,    8},  //  13: 0000 11x
+	{      -1,    0}, { 20 << 1,    0},  //  14: 0000 000x
+	{      -1,    0}, { 21 << 1,    0},  //  15: 0000 001x
+	{ 22 << 1,    0}, { 23 << 1,    0},  //  16: 0000 010x
+	{       0,   15}, {       0,   14},  //  17: 0000 011x
+	{       0,   13}, {       0,   12},  //  18: 0000 100x
+	{       0,   11}, {       0,   10},  //  19: 0000 101x
+	{ 24 << 1,    0}, { 25 << 1,    0},  //  20: 0000 0001x
+	{ 26 << 1,    0}, { 27 << 1,    0},  //  21: 0000 0011x
+	{ 28 << 1,    0}, { 29 << 1,    0},  //  22: 0000 0100x
+	{ 30 << 1,    0}, { 31 << 1,    0},  //  23: 0000 0101x
+	{ 32 << 1,    0}, {      -1,    0},  //  24: 0000 0001 0x
+	{      -1,    0}, { 33 << 1,    0},  //  25: 0000 0001 1x
+	{ 34 << 1,    0}, { 35 << 1,    0},  //  26: 0000 0011 0x
+	{ 36 << 1,    0}, { 37 << 1,    0},  //  27: 0000 0011 1x
+	{ 38 << 1,    0}, { 39 << 1,    0},  //  28: 0000 0100 0x
+	{       0,   21}, {       0,   20},  //  29: 0000 0100 1x
+	{       0,   19}, {       0,   18},  //  30: 0000 0101 0x
+	{       0,   17}, {       0,   16},  //  31: 0000 0101 1x
+	{       0,   35}, {      -1,    0},  //  32: 0000 0001 00x
+	{      -1,    0}, {       0,   34},  //  33: 0000 0001 11x
+	{       0,   33}, {       0,   32},  //  34: 0000 0011 00x
+	{       0,   31}, {       0,   30},  //  35: 0000 0011 01x
+	{       0,   29}, {       0,   28},  //  36: 0000 0011 10x
+	{       0,   27}, {       0,   26},  //  37: 0000 0011 11x
+	{       0,   25}, {       0,   24},  //  38: 0000 0100 00x
+	{       0,   23}, {       0,   22},  //  39: 0000 0100 01x
+};
+
+static const plm_vlc_t PLM_VIDEO_MACROBLOCK_TYPE_INTRA[] = {
+	{  1 << 1,    0}, {       0,  0x01},  //   0: x
+	{      -1,    0}, {       0,  0x11},  //   1: 0x
+};
+
+static const plm_vlc_t PLM_VIDEO_MACROBLOCK_TYPE_PREDICTIVE[] = {
+	{  1 << 1,    0}, {       0, 0x0a},  //   0: x
+	{  2 << 1,    0}, {       0, 0x02},  //   1: 0x
+	{  3 << 1,    0}, {       0, 0x08},  //   2: 00x
+	{  4 << 1,    0}, {  5 << 1,    0},  //   3: 000x
+	{  6 << 1,    0}, {       0, 0x12},  //   4: 0000x
+	{       0, 0x1a}, {       0, 0x01},  //   5: 0001x
+	{      -1,    0}, {       0, 0x11},  //   6: 0000 0x
+};
+
+static const plm_vlc_t PLM_VIDEO_MACROBLOCK_TYPE_B[] = {
+	{  1 << 1,    0}, {  2 << 1,    0},  //   0: x
+	{  3 << 1,    0}, {  4 << 1,    0},  //   1: 0x
+	{       0, 0x0c}, {       0, 0x0e},  //   2: 1x
+	{  5 << 1,    0}, {  6 << 1,    0},  //   3: 00x
+	{       0, 0x04}, {       0, 0x06},  //   4: 01x
+	{  7 << 1,    0}, {  8 << 1,    0},  //   5: 000x
+	{       0, 0x08}, {       0, 0x0a},  //   6: 001x
+	{  9 << 1,    0}, { 10 << 1,    0},  //   7: 0000x
+	{       0, 0x1e}, {       0, 0x01},  //   8: 0001x
+	{      -1,    0}, {       0, 0x11},  //   9: 0000 0x
+	{       0, 0x16}, {       0, 0x1a},  //  10: 0000 1x
+};
+
+static const plm_vlc_t *PLM_VIDEO_MACROBLOCK_TYPE[] = {
+	NULL,
+	PLM_VIDEO_MACROBLOCK_TYPE_INTRA,
+	PLM_VIDEO_MACROBLOCK_TYPE_PREDICTIVE,
+	PLM_VIDEO_MACROBLOCK_TYPE_B
+};
+
+static const plm_vlc_t PLM_VIDEO_CODE_BLOCK_PATTERN[] = {
+	{  1 << 1,    0}, {  2 << 1,    0},  //   0: x
+	{  3 << 1,    0}, {  4 << 1,    0},  //   1: 0x
+	{  5 << 1,    0}, {  6 << 1,    0},  //   2: 1x
+	{  7 << 1,    0}, {  8 << 1,    0},  //   3: 00x
+	{  9 << 1,    0}, { 10 << 1,    0},  //   4: 01x
+	{ 11 << 1,    0}, { 12 << 1,    0},  //   5: 10x
+	{ 13 << 1,    0}, {       0,   60},  //   6: 11x
+	{ 14 << 1,    0}, { 15 << 1,    0},  //   7: 000x
+	{ 16 << 1,    0}, { 17 << 1,    0},  //   8: 001x
+	{ 18 << 1,    0}, { 19 << 1,    0},  //   9: 010x
+	{ 20 << 1,    0}, { 21 << 1,    0},  //  10: 011x
+	{ 22 << 1,    0}, { 23 << 1,    0},  //  11: 100x
+	{       0,   32}, {       0,   16},  //  12: 101x
+	{       0,    8}, {       0,    4},  //  13: 110x
+	{ 24 << 1,    0}, { 25 << 1,    0},  //  14: 0000x
+	{ 26 << 1,    0}, { 27 << 1,    0},  //  15: 0001x
+	{ 28 << 1,    0}, { 29 << 1,    0},  //  16: 0010x
+	{ 30 << 1,    0}, { 31 << 1,    0},  //  17: 0011x
+	{       0,   62}, {       0,    2},  //  18: 0100x
+	{       0,   61}, {       0,    1},  //  19: 0101x
+	{       0,   56}, {       0,   52},  //  20: 0110x
+	{       0,   44}, {       0,   28},  //  21: 0111x
+	{       0,   40}, {       0,   20},  //  22: 1000x
+	{       0,   48}, {       0,   12},  //  23: 1001x
+	{ 32 << 1,    0}, { 33 << 1,    0},  //  24: 0000 0x
+	{ 34 << 1,    0}, { 35 << 1,    0},  //  25: 0000 1x
+	{ 36 << 1,    0}, { 37 << 1,    0},  //  26: 0001 0x
+	{ 38 << 1,    0}, { 39 << 1,    0},  //  27: 0001 1x
+	{ 40 << 1,    0}, { 41 << 1,    0},  //  28: 0010 0x
+	{ 42 << 1,    0}, { 43 << 1,    0},  //  29: 0010 1x
+	{       0,   63}, {       0,    3},  //  30: 0011 0x
+	{       0,   36}, {       0,   24},  //  31: 0011 1x
+	{ 44 << 1,    0}, { 45 << 1,    0},  //  32: 0000 00x
+	{ 46 << 1,    0}, { 47 << 1,    0},  //  33: 0000 01x
+	{ 48 << 1,    0}, { 49 << 1,    0},  //  34: 0000 10x
+	{ 50 << 1,    0}, { 51 << 1,    0},  //  35: 0000 11x
+	{ 52 << 1,    0}, { 53 << 1,    0},  //  36: 0001 00x
+	{ 54 << 1,    0}, { 55 << 1,    0},  //  37: 0001 01x
+	{ 56 << 1,    0}, { 57 << 1,    0},  //  38: 0001 10x
+	{ 58 << 1,    0}, { 59 << 1,    0},  //  39: 0001 11x
+	{       0,   34}, {       0,   18},  //  40: 0010 00x
+	{       0,   10}, {       0,    6},  //  41: 0010 01x
+	{       0,   33}, {       0,   17},  //  42: 0010 10x
+	{       0,    9}, {       0,    5},  //  43: 0010 11x
+	{      -1,    0}, { 60 << 1,    0},  //  44: 0000 000x
+	{ 61 << 1,    0}, { 62 << 1,    0},  //  45: 0000 001x
+	{       0,   58}, {       0,   54},  //  46: 0000 010x
+	{       0,   46}, {       0,   30},  //  47: 0000 011x
+	{       0,   57}, {       0,   53},  //  48: 0000 100x
+	{       0,   45}, {       0,   29},  //  49: 0000 101x
+	{       0,   38}, {       0,   26},  //  50: 0000 110x
+	{       0,   37}, {       0,   25},  //  51: 0000 111x
+	{       0,   43}, {       0,   23},  //  52: 0001 000x
+	{       0,   51}, {       0,   15},  //  53: 0001 001x
+	{       0,   42}, {       0,   22},  //  54: 0001 010x
+	{       0,   50}, {       0,   14},  //  55: 0001 011x
+	{       0,   41}, {       0,   21},  //  56: 0001 100x
+	{       0,   49}, {       0,   13},  //  57: 0001 101x
+	{       0,   35}, {       0,   19},  //  58: 0001 110x
+	{       0,   11}, {       0,    7},  //  59: 0001 111x
+	{       0,   39}, {       0,   27},  //  60: 0000 0001x
+	{       0,   59}, {       0,   55},  //  61: 0000 0010x
+	{       0,   47}, {       0,   31},  //  62: 0000 0011x
+};
+
+static const plm_vlc_t PLM_VIDEO_MOTION[] = {
+	{  1 << 1,    0}, {       0,    0},  //   0: x
+	{  2 << 1,    0}, {  3 << 1,    0},  //   1: 0x
+	{  4 << 1,    0}, {  5 << 1,    0},  //   2: 00x
+	{       0,    1}, {       0,   -1},  //   3: 01x
+	{  6 << 1,    0}, {  7 << 1,    0},  //   4: 000x
+	{       0,    2}, {       0,   -2},  //   5: 001x
+	{  8 << 1,    0}, {  9 << 1,    0},  //   6: 0000x
+	{       0,    3}, {       0,   -3},  //   7: 0001x
+	{ 10 << 1,    0}, { 11 << 1,    0},  //   8: 0000 0x
+	{ 12 << 1,    0}, { 13 << 1,    0},  //   9: 0000 1x
+	{      -1,    0}, { 14 << 1,    0},  //  10: 0000 00x
+	{ 15 << 1,    0}, { 16 << 1,    0},  //  11: 0000 01x
+	{ 17 << 1,    0}, { 18 << 1,    0},  //  12: 0000 10x
+	{       0,    4}, {       0,   -4},  //  13: 0000 11x
+	{      -1,    0}, { 19 << 1,    0},  //  14: 0000 001x
+	{ 20 << 1,    0}, { 21 << 1,    0},  //  15: 0000 010x
+	{       0,    7}, {       0,   -7},  //  16: 0000 011x
+	{       0,    6}, {       0,   -6},  //  17: 0000 100x
+	{       0,    5}, {       0,   -5},  //  18: 0000 101x
+	{ 22 << 1,    0}, { 23 << 1,    0},  //  19: 0000 0011x
+	{ 24 << 1,    0}, { 25 << 1,    0},  //  20: 0000 0100x
+	{ 26 << 1,    0}, { 27 << 1,    0},  //  21: 0000 0101x
+	{ 28 << 1,    0}, { 29 << 1,    0},  //  22: 0000 0011 0x
+	{ 30 << 1,    0}, { 31 << 1,    0},  //  23: 0000 0011 1x
+	{ 32 << 1,    0}, { 33 << 1,    0},  //  24: 0000 0100 0x
+	{       0,   10}, {       0,  -10},  //  25: 0000 0100 1x
+	{       0,    9}, {       0,   -9},  //  26: 0000 0101 0x
+	{       0,    8}, {       0,   -8},  //  27: 0000 0101 1x
+	{       0,   16}, {       0,  -16},  //  28: 0000 0011 00x
+	{       0,   15}, {       0,  -15},  //  29: 0000 0011 01x
+	{       0,   14}, {       0,  -14},  //  30: 0000 0011 10x
+	{       0,   13}, {       0,  -13},  //  31: 0000 0011 11x
+	{       0,   12}, {       0,  -12},  //  32: 0000 0100 00x
+	{       0,   11}, {       0,  -11},  //  33: 0000 0100 01x
+};
+
+static const plm_vlc_t PLM_VIDEO_DCT_SIZE_LUMINANCE[] = {
+	{  1 << 1,    0}, {  2 << 1,    0},  //   0: x
+	{       0,    1}, {       0,    2},  //   1: 0x
+	{  3 << 1,    0}, {  4 << 1,    0},  //   2: 1x
+	{       0,    0}, {       0,    3},  //   3: 10x
+	{       0,    4}, {  5 << 1,    0},  //   4: 11x
+	{       0,    5}, {  6 << 1,    0},  //   5: 111x
+	{       0,    6}, {  7 << 1,    0},  //   6: 1111x
+	{       0,    7}, {  8 << 1,    0},  //   7: 1111 1x
+	{       0,    8}, {      -1,    0},  //   8: 1111 11x
+};
+
+static const plm_vlc_t PLM_VIDEO_DCT_SIZE_CHROMINANCE[] = {
+	{  1 << 1,    0}, {  2 << 1,    0},  //   0: x
+	{       0,    0}, {       0,    1},  //   1: 0x
+	{       0,    2}, {  3 << 1,    0},  //   2: 1x
+	{       0,    3}, {  4 << 1,    0},  //   3: 11x
+	{       0,    4}, {  5 << 1,    0},  //   4: 111x
+	{       0,    5}, {  6 << 1,    0},  //   5: 1111x
+	{       0,    6}, {  7 << 1,    0},  //   6: 1111 1x
+	{       0,    7}, {  8 << 1,    0},  //   7: 1111 11x
+	{       0,    8}, {      -1,    0},  //   8: 1111 111x
+};
+
+static const plm_vlc_t *PLM_VIDEO_DCT_SIZE[] = {
+	PLM_VIDEO_DCT_SIZE_LUMINANCE,
+	PLM_VIDEO_DCT_SIZE_CHROMINANCE,
+	PLM_VIDEO_DCT_SIZE_CHROMINANCE
+};
+
+
+//  dct_coeff bitmap:
+//    0xff00  run
+//    0x00ff  level
+
+//  Decoded values are unsigned. Sign bit follows in the stream.
+
+static const plm_vlc_uint_t PLM_VIDEO_DCT_COEFF[] = {
+	{  1 << 1,        0}, {       0,   0x0001},  //   0: x
+	{  2 << 1,        0}, {  3 << 1,        0},  //   1: 0x
+	{  4 << 1,        0}, {  5 << 1,        0},  //   2: 00x
+	{  6 << 1,        0}, {       0,   0x0101},  //   3: 01x
+	{  7 << 1,        0}, {  8 << 1,        0},  //   4: 000x
+	{  9 << 1,        0}, { 10 << 1,        0},  //   5: 001x
+	{       0,   0x0002}, {       0,   0x0201},  //   6: 010x
+	{ 11 << 1,        0}, { 12 << 1,        0},  //   7: 0000x
+	{ 13 << 1,        0}, { 14 << 1,        0},  //   8: 0001x
+	{ 15 << 1,        0}, {       0,   0x0003},  //   9: 0010x
+	{       0,   0x0401}, {       0,   0x0301},  //  10: 0011x
+	{ 16 << 1,        0}, {       0,   0xffff},  //  11: 0000 0x
+	{ 17 << 1,        0}, { 18 << 1,        0},  //  12: 0000 1x
+	{       0,   0x0701}, {       0,   0x0601},  //  13: 0001 0x
+	{       0,   0x0102}, {       0,   0x0501},  //  14: 0001 1x
+	{ 19 << 1,        0}, { 20 << 1,        0},  //  15: 0010 0x
+	{ 21 << 1,        0}, { 22 << 1,        0},  //  16: 0000 00x
+	{       0,   0x0202}, {       0,   0x0901},  //  17: 0000 10x
+	{       0,   0x0004}, {       0,   0x0801},  //  18: 0000 11x
+	{ 23 << 1,        0}, { 24 << 1,        0},  //  19: 0010 00x
+	{ 25 << 1,        0}, { 26 << 1,        0},  //  20: 0010 01x
+	{ 27 << 1,        0}, { 28 << 1,        0},  //  21: 0000 000x
+	{ 29 << 1,        0}, { 30 << 1,        0},  //  22: 0000 001x
+	{       0,   0x0d01}, {       0,   0x0006},  //  23: 0010 000x
+	{       0,   0x0c01}, {       0,   0x0b01},  //  24: 0010 001x
+	{       0,   0x0302}, {       0,   0x0103},  //  25: 0010 010x
+	{       0,   0x0005}, {       0,   0x0a01},  //  26: 0010 011x
+	{ 31 << 1,        0}, { 32 << 1,        0},  //  27: 0000 0000x
+	{ 33 << 1,        0}, { 34 << 1,        0},  //  28: 0000 0001x
+	{ 35 << 1,        0}, { 36 << 1,        0},  //  29: 0000 0010x
+	{ 37 << 1,        0}, { 38 << 1,        0},  //  30: 0000 0011x
+	{ 39 << 1,        0}, { 40 << 1,        0},  //  31: 0000 0000 0x
+	{ 41 << 1,        0}, { 42 << 1,        0},  //  32: 0000 0000 1x
+	{ 43 << 1,        0}, { 44 << 1,        0},  //  33: 0000 0001 0x
+	{ 45 << 1,        0}, { 46 << 1,        0},  //  34: 0000 0001 1x
+	{       0,   0x1001}, {       0,   0x0502},  //  35: 0000 0010 0x
+	{       0,   0x0007}, {       0,   0x0203},  //  36: 0000 0010 1x
+	{       0,   0x0104}, {       0,   0x0f01},  //  37: 0000 0011 0x
+	{       0,   0x0e01}, {       0,   0x0402},  //  38: 0000 0011 1x
+	{ 47 << 1,        0}, { 48 << 1,        0},  //  39: 0000 0000 00x
+	{ 49 << 1,        0}, { 50 << 1,        0},  //  40: 0000 0000 01x
+	{ 51 << 1,        0}, { 52 << 1,        0},  //  41: 0000 0000 10x
+	{ 53 << 1,        0}, { 54 << 1,        0},  //  42: 0000 0000 11x
+	{ 55 << 1,        0}, { 56 << 1,        0},  //  43: 0000 0001 00x
+	{ 57 << 1,        0}, { 58 << 1,        0},  //  44: 0000 0001 01x
+	{ 59 << 1,        0}, { 60 << 1,        0},  //  45: 0000 0001 10x
+	{ 61 << 1,        0}, { 62 << 1,        0},  //  46: 0000 0001 11x
+	{      -1,        0}, { 63 << 1,        0},  //  47: 0000 0000 000x
+	{ 64 << 1,        0}, { 65 << 1,        0},  //  48: 0000 0000 001x
+	{ 66 << 1,        0}, { 67 << 1,        0},  //  49: 0000 0000 010x
+	{ 68 << 1,        0}, { 69 << 1,        0},  //  50: 0000 0000 011x
+	{ 70 << 1,        0}, { 71 << 1,        0},  //  51: 0000 0000 100x
+	{ 72 << 1,        0}, { 73 << 1,        0},  //  52: 0000 0000 101x
+	{ 74 << 1,        0}, { 75 << 1,        0},  //  53: 0000 0000 110x
+	{ 76 << 1,        0}, { 77 << 1,        0},  //  54: 0000 0000 111x
+	{       0,   0x000b}, {       0,   0x0802},  //  55: 0000 0001 000x
+	{       0,   0x0403}, {       0,   0x000a},  //  56: 0000 0001 001x
+	{       0,   0x0204}, {       0,   0x0702},  //  57: 0000 0001 010x
+	{       0,   0x1501}, {       0,   0x1401},  //  58: 0000 0001 011x
+	{       0,   0x0009}, {       0,   0x1301},  //  59: 0000 0001 100x
+	{       0,   0x1201}, {       0,   0x0105},  //  60: 0000 0001 101x
+	{       0,   0x0303}, {       0,   0x0008},  //  61: 0000 0001 110x
+	{       0,   0x0602}, {       0,   0x1101},  //  62: 0000 0001 111x
+	{ 78 << 1,        0}, { 79 << 1,        0},  //  63: 0000 0000 0001x
+	{ 80 << 1,        0}, { 81 << 1,        0},  //  64: 0000 0000 0010x
+	{ 82 << 1,        0}, { 83 << 1,        0},  //  65: 0000 0000 0011x
+	{ 84 << 1,        0}, { 85 << 1,        0},  //  66: 0000 0000 0100x
+	{ 86 << 1,        0}, { 87 << 1,        0},  //  67: 0000 0000 0101x
+	{ 88 << 1,        0}, { 89 << 1,        0},  //  68: 0000 0000 0110x
+	{ 90 << 1,        0}, { 91 << 1,        0},  //  69: 0000 0000 0111x
+	{       0,   0x0a02}, {       0,   0x0902},  //  70: 0000 0000 1000x
+	{       0,   0x0503}, {       0,   0x0304},  //  71: 0000 0000 1001x
+	{       0,   0x0205}, {       0,   0x0107},  //  72: 0000 0000 1010x
+	{       0,   0x0106}, {       0,   0x000f},  //  73: 0000 0000 1011x
+	{       0,   0x000e}, {       0,   0x000d},  //  74: 0000 0000 1100x
+	{       0,   0x000c}, {       0,   0x1a01},  //  75: 0000 0000 1101x
+	{       0,   0x1901}, {       0,   0x1801},  //  76: 0000 0000 1110x
+	{       0,   0x1701}, {       0,   0x1601},  //  77: 0000 0000 1111x
+	{ 92 << 1,        0}, { 93 << 1,        0},  //  78: 0000 0000 0001 0x
+	{ 94 << 1,        0}, { 95 << 1,        0},  //  79: 0000 0000 0001 1x
+	{ 96 << 1,        0}, { 97 << 1,        0},  //  80: 0000 0000 0010 0x
+	{ 98 << 1,        0}, { 99 << 1,        0},  //  81: 0000 0000 0010 1x
+	{100 << 1,        0}, {101 << 1,        0},  //  82: 0000 0000 0011 0x
+	{102 << 1,        0}, {103 << 1,        0},  //  83: 0000 0000 0011 1x
+	{       0,   0x001f}, {       0,   0x001e},  //  84: 0000 0000 0100 0x
+	{       0,   0x001d}, {       0,   0x001c},  //  85: 0000 0000 0100 1x
+	{       0,   0x001b}, {       0,   0x001a},  //  86: 0000 0000 0101 0x
+	{       0,   0x0019}, {       0,   0x0018},  //  87: 0000 0000 0101 1x
+	{       0,   0x0017}, {       0,   0x0016},  //  88: 0000 0000 0110 0x
+	{       0,   0x0015}, {       0,   0x0014},  //  89: 0000 0000 0110 1x
+	{       0,   0x0013}, {       0,   0x0012},  //  90: 0000 0000 0111 0x
+	{       0,   0x0011}, {       0,   0x0010},  //  91: 0000 0000 0111 1x
+	{104 << 1,        0}, {105 << 1,        0},  //  92: 0000 0000 0001 00x
+	{106 << 1,        0}, {107 << 1,        0},  //  93: 0000 0000 0001 01x
+	{108 << 1,        0}, {109 << 1,        0},  //  94: 0000 0000 0001 10x
+	{110 << 1,        0}, {111 << 1,        0},  //  95: 0000 0000 0001 11x
+	{       0,   0x0028}, {       0,   0x0027},  //  96: 0000 0000 0010 00x
+	{       0,   0x0026}, {       0,   0x0025},  //  97: 0000 0000 0010 01x
+	{       0,   0x0024}, {       0,   0x0023},  //  98: 0000 0000 0010 10x
+	{       0,   0x0022}, {       0,   0x0021},  //  99: 0000 0000 0010 11x
+	{       0,   0x0020}, {       0,   0x010e},  // 100: 0000 0000 0011 00x
+	{       0,   0x010d}, {       0,   0x010c},  // 101: 0000 0000 0011 01x
+	{       0,   0x010b}, {       0,   0x010a},  // 102: 0000 0000 0011 10x
+	{       0,   0x0109}, {       0,   0x0108},  // 103: 0000 0000 0011 11x
+	{       0,   0x0112}, {       0,   0x0111},  // 104: 0000 0000 0001 000x
+	{       0,   0x0110}, {       0,   0x010f},  // 105: 0000 0000 0001 001x
+	{       0,   0x0603}, {       0,   0x1002},  // 106: 0000 0000 0001 010x
+	{       0,   0x0f02}, {       0,   0x0e02},  // 107: 0000 0000 0001 011x
+	{       0,   0x0d02}, {       0,   0x0c02},  // 108: 0000 0000 0001 100x
+	{       0,   0x0b02}, {       0,   0x1f01},  // 109: 0000 0000 0001 101x
+	{       0,   0x1e01}, {       0,   0x1d01},  // 110: 0000 0000 0001 110x
+	{       0,   0x1c01}, {       0,   0x1b01},  // 111: 0000 0000 0001 111x
+};
+
+typedef struct {
+	int full_px;
+	int is_set;
+	int r_size;
+	int h;
+	int v;
+} plm_video_motion_t;
+
+struct plm_video_t {
+	double framerate;
+	double pixel_aspect_ratio; // [jart]
+	double time;
+	int frames_decoded;
+	int width;
+	int height;
+	int mb_width;
+	int mb_height;
+	int mb_size;
+
+	int luma_width;
+	int luma_height;
+
+	int chroma_width;
+	int chroma_height;
+
+	int start_code;
+	int picture_type;
+
+	plm_video_motion_t motion_forward;
+	plm_video_motion_t motion_backward;
+
+	int has_sequence_header;
+
+	int quantizer_scale;
+	int slice_begin;
+	int macroblock_address;
+
+	int mb_row;
+	int mb_col;
+
+	int macroblock_type;
+	int macroblock_intra;
+
+	int dc_predictor[3];
+
+	plm_buffer_t *buffer;
+	int destroy_buffer_when_done;
+
+	plm_frame_t frame_current;
+	plm_frame_t frame_forward;
+	plm_frame_t frame_backward;
+
+	uint8_t *frames_data;
+
+	int block_data[64];
+	uint8_t intra_quant_matrix[64];
+	uint8_t non_intra_quant_matrix[64];
+
+	int has_reference_frame;
+	int assume_no_b_frames;
+};
+
+static inline uint8_t plm_clamp(int n) {
+	if (n > 255) {
+		n = 255;
+	}
+	else if (n < 0) {
+		n = 0;
+	}
+	return n;
+}
+
+int plm_video_decode_sequence_header(plm_video_t *self);
+void plm_video_init_frame(plm_video_t *self, plm_frame_t *frame, uint8_t *base);
+void plm_video_decode_picture(plm_video_t *self);
+void plm_video_decode_slice(plm_video_t *self, int slice);
+void plm_video_decode_macroblock(plm_video_t *self);
+void plm_video_decode_motion_vectors(plm_video_t *self);
+int plm_video_decode_motion_vector(plm_video_t *self, int r_size, int motion);
+void plm_video_predict_macroblock(plm_video_t *self);
+void plm_video_copy_macroblock(plm_video_t *self, plm_frame_t *s, int motion_h, int motion_v);
+void plm_video_interpolate_macroblock(plm_video_t *self, plm_frame_t *s, int motion_h, int motion_v);
+void plm_video_process_macroblock(plm_video_t *self, uint8_t *s, uint8_t *d, int mh, int mb, int bs, int interp);
+void plm_video_decode_block(plm_video_t *self, int block);
+void plm_video_idct(int *block);
+
+plm_video_t * plm_video_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {
+	plm_video_t *self = (plm_video_t *)PLM_MALLOC(sizeof(plm_video_t));
+	memset(self, 0, sizeof(plm_video_t));
+	
+	self->buffer = buffer;
+	self->destroy_buffer_when_done = destroy_when_done;
+
+	// Attempt to decode the sequence header
+	self->start_code = plm_buffer_find_start_code(self->buffer, PLM_START_SEQUENCE);
+	if (self->start_code != -1) {
+		plm_video_decode_sequence_header(self);
+	}
+	return self;
+}
+
+void plm_video_destroy(plm_video_t *self) {
+	if (self->destroy_buffer_when_done) {
+		plm_buffer_destroy(self->buffer);
+	}
+
+	if (self->has_sequence_header) {
+		PLM_FREE(self->frames_data);
+	}
+
+	PLM_FREE(self);
+}
+
+double plm_video_get_framerate(plm_video_t *self) {
+	return plm_video_has_header(self)
+		? self->framerate
+		: 0;
+}
+
+double plm_video_get_pixel_aspect_ratio(plm_video_t *self) { // [jart]
+	return plm_video_has_header(self)
+		? self->pixel_aspect_ratio
+		: 0;
+}
+
+int plm_video_get_width(plm_video_t *self) {
+	return plm_video_has_header(self)
+		? self->width
+		: 0;
+}
+
+int plm_video_get_height(plm_video_t *self) {
+	return plm_video_has_header(self)
+		? self->height
+		: 0;
+}
+
+void plm_video_set_no_delay(plm_video_t *self, int no_delay) {
+	self->assume_no_b_frames = no_delay;
+}
+
+double plm_video_get_time(plm_video_t *self) {
+	return self->time;
+}
+
+void plm_video_set_time(plm_video_t *self, double time) {
+	self->frames_decoded = self->framerate * time;
+	self->time = time;
+}
+
+void plm_video_rewind(plm_video_t *self) {
+	plm_buffer_rewind(self->buffer);
+	self->time = 0;
+	self->frames_decoded = 0;
+	self->has_reference_frame = FALSE;
+	self->start_code = -1;
+}
+
+int plm_video_has_ended(plm_video_t *self) {
+	return plm_buffer_has_ended(self->buffer);
+}
+
+plm_frame_t *plm_video_decode(plm_video_t *self) {
+	if (!plm_video_has_header(self)) {
+		return NULL;
+	}
+	
+	struct timespec tsc; // [jart]
+	tsc = timespec_real(); // [jart]
+
+	plm_frame_t *frame = NULL;
+	do {
+		if (self->start_code != PLM_START_PICTURE) {
+			self->start_code = plm_buffer_find_start_code(self->buffer, PLM_START_PICTURE);
+			
+			if (self->start_code == -1) {
+				// If we reached the end of the file and the previously decoded
+				// frame was a reference frame, we still have to return it.
+				if (
+					self->has_reference_frame &&
+					!self->assume_no_b_frames &&
+					plm_buffer_has_ended(self->buffer) && (
+						self->picture_type == PLM_VIDEO_PICTURE_TYPE_INTRA ||
+						self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE
+					)
+				) {
+					self->has_reference_frame = FALSE;
+					frame = &self->frame_backward;
+					break;
+				}
+
+				return NULL;
+			}
+		}
+
+		// Make sure we have a full picture in the buffer before attempting to
+		// decode it. Sadly, this can only be done by seeking for the start code
+		// of the next picture. Also, if we didn't find the start code for the
+		// next picture, but the source has ended, we assume that this last
+		// picture is in the buffer.
+		if (
+			plm_buffer_has_start_code(self->buffer, PLM_START_PICTURE) == -1 &&
+			!plm_buffer_has_ended(self->buffer)
+		) {
+			return NULL;
+		}
+		plm_buffer_discard_read_bytes(self->buffer);
+		
+		plm_video_decode_picture(self);
+
+		if (self->assume_no_b_frames) {
+			frame = &self->frame_backward;
+		}
+		else if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) {
+			frame = &self->frame_current;
+		}
+		else if (self->has_reference_frame) {
+			frame = &self->frame_forward;
+		}
+		else {
+			self->has_reference_frame = TRUE;
+		}
+	} while (!frame);
+	
+	frame->time = self->time;
+	self->frames_decoded++;
+	self->time = (double)self->frames_decoded / self->framerate;
+	
+	plmpegdecode_latency_ = timespec_tomicros(timespec_sub(timespec_real(), tsc));
+	return frame;
+}
+
+int plm_video_has_header(plm_video_t *self) {
+	if (self->has_sequence_header) {
+		return TRUE;
+	}
+
+	if (self->start_code != PLM_START_SEQUENCE) {
+		self->start_code = plm_buffer_find_start_code(self->buffer, PLM_START_SEQUENCE);
+	}
+	if (self->start_code == -1) {
+		return FALSE;
+	}
+	
+	if (!plm_video_decode_sequence_header(self)) {
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+int plm_video_decode_sequence_header(plm_video_t *self) {
+	int max_header_size = 64 + 2 * 64 * 8; // 64 bit header + 2x 64 byte matrix
+	if (!plm_buffer_has(self->buffer, max_header_size)) {
+		return FALSE;
+	}
+
+	self->width = plm_buffer_read(self->buffer, 12);
+	self->height = plm_buffer_read(self->buffer, 12);
+
+	if (self->width <= 0 || self->height <= 0) {
+		return FALSE;
+	}
+
+	// [jart] get pixel aspect ratio
+	int pixel_aspect_ratio_code;
+	pixel_aspect_ratio_code = plm_buffer_read(self->buffer, 4);
+	pixel_aspect_ratio_code -= 1;
+	if (pixel_aspect_ratio_code < 0)
+		pixel_aspect_ratio_code = 0;
+	int par_last = (sizeof(PLM_VIDEO_PIXEL_ASPECT_RATIO) /
+			sizeof(PLM_VIDEO_PIXEL_ASPECT_RATIO[0]) - 1);
+	if (pixel_aspect_ratio_code > par_last)
+		pixel_aspect_ratio_code = par_last;
+	self->pixel_aspect_ratio =
+		PLM_VIDEO_PIXEL_ASPECT_RATIO[pixel_aspect_ratio_code];
+
+	self->framerate = PLM_VIDEO_PICTURE_RATE[plm_buffer_read(self->buffer, 4)];
+
+	// Skip bit_rate, marker, buffer_size and constrained bit
+	plm_buffer_skip(self->buffer, 18 + 1 + 10 + 1);
+
+	// Load custom intra quant matrix?
+	if (plm_buffer_read(self->buffer, 1)) { 
+		for (int i = 0; i < 64; i++) {
+			int idx = PLM_VIDEO_ZIG_ZAG[i];
+			self->intra_quant_matrix[idx] = plm_buffer_read(self->buffer, 8);
+		}
+	}
+	else {
+		memcpy(self->intra_quant_matrix, PLM_VIDEO_INTRA_QUANT_MATRIX, 64);
+	}
+
+	// Load custom non intra quant matrix?
+	if (plm_buffer_read(self->buffer, 1)) { 
+		for (int i = 0; i < 64; i++) {
+			int idx = PLM_VIDEO_ZIG_ZAG[i];
+			self->non_intra_quant_matrix[idx] = plm_buffer_read(self->buffer, 8);
+		}
+	}
+	else {
+		memcpy(self->non_intra_quant_matrix, PLM_VIDEO_NON_INTRA_QUANT_MATRIX, 64);
+	}
+
+	self->mb_width = (self->width + 15) >> 4;
+	self->mb_height = (self->height + 15) >> 4;
+	self->mb_size = self->mb_width * self->mb_height;
+
+	self->luma_width = self->mb_width << 4;
+	self->luma_height = self->mb_height << 4;
+
+	self->chroma_width = self->mb_width << 3;
+	self->chroma_height = self->mb_height << 3;
+
+
+	// Allocate one big chunk of data for all 3 frames = 9 planes
+	size_t luma_plane_size = self->luma_width * self->luma_height;
+	size_t chroma_plane_size = self->chroma_width * self->chroma_height;
+	size_t frame_data_size = (luma_plane_size + 2 * chroma_plane_size);
+
+	self->frames_data = (uint8_t*)PLM_MALLOC(frame_data_size * 3);
+	plm_video_init_frame(self, &self->frame_current, self->frames_data + frame_data_size * 0);
+	plm_video_init_frame(self, &self->frame_forward, self->frames_data + frame_data_size * 1);
+	plm_video_init_frame(self, &self->frame_backward, self->frames_data + frame_data_size * 2);
+
+	self->has_sequence_header = TRUE;
+	return TRUE;
+}
+
+void plm_video_init_frame(plm_video_t *self, plm_frame_t *frame, uint8_t *base) {
+	size_t luma_plane_size = self->luma_width * self->luma_height;
+	size_t chroma_plane_size = self->chroma_width * self->chroma_height;
+
+	frame->width = self->width;
+	frame->height = self->height;
+	frame->y.width = self->luma_width;
+	frame->y.height = self->luma_height;
+	frame->y.data = base;
+
+	frame->cr.width = self->chroma_width;
+	frame->cr.height = self->chroma_height;
+	frame->cr.data = base + luma_plane_size;
+
+	frame->cb.width = self->chroma_width;
+	frame->cb.height = self->chroma_height;
+	frame->cb.data = base + luma_plane_size + chroma_plane_size;
+}
+
+void plm_video_decode_picture(plm_video_t *self) {
+	plm_buffer_skip(self->buffer, 10); // skip temporalReference
+	self->picture_type = plm_buffer_read(self->buffer, 3);
+	plm_buffer_skip(self->buffer, 16); // skip vbv_delay
+
+	// D frames or unknown coding type
+	if (self->picture_type <= 0 || self->picture_type > PLM_VIDEO_PICTURE_TYPE_B) {
+		return;
+	}
+
+	// Forward full_px, f_code
+	if (
+		self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE ||
+		self->picture_type == PLM_VIDEO_PICTURE_TYPE_B
+	) {
+		self->motion_forward.full_px = plm_buffer_read(self->buffer, 1);
+		int f_code = plm_buffer_read(self->buffer, 3);
+		if (f_code == 0) {
+			// Ignore picture with zero f_code
+			return;
+		}
+		self->motion_forward.r_size = f_code - 1;
+	}
+
+	// Backward full_px, f_code
+	if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) {
+		self->motion_backward.full_px = plm_buffer_read(self->buffer, 1);
+		int f_code = plm_buffer_read(self->buffer, 3);
+		if (f_code == 0) {
+			// Ignore picture with zero f_code
+			return;
+		}
+		self->motion_backward.r_size = f_code - 1;
+	}
+
+	plm_frame_t frame_temp = self->frame_forward;
+	if (
+		self->picture_type == PLM_VIDEO_PICTURE_TYPE_INTRA ||
+		self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE
+	) {
+		self->frame_forward = self->frame_backward;
+	}
+
+
+	// Find first slice start code; skip extension and user data
+	do {
+		self->start_code = plm_buffer_next_start_code(self->buffer);
+	} while (
+		self->start_code == PLM_START_EXTENSION || 
+		self->start_code == PLM_START_USER_DATA
+	);
+
+	// Decode all slices
+	while (PLM_START_IS_SLICE(self->start_code)) {
+		plm_video_decode_slice(self, self->start_code & 0x000000FF);
+		if (self->macroblock_address >= self->mb_size - 2) {
+			break;
+		}
+		self->start_code = plm_buffer_next_start_code(self->buffer);
+	}
+
+	// If this is a reference picture rotate the prediction pointers
+	if (
+		self->picture_type == PLM_VIDEO_PICTURE_TYPE_INTRA ||
+		self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE
+	) {
+		self->frame_backward = self->frame_current;
+		self->frame_current = frame_temp;
+	}
+}
+
+void plm_video_decode_slice(plm_video_t *self, int slice) {
+	self->slice_begin = TRUE;
+	self->macroblock_address = (slice - 1) * self->mb_width - 1;
+
+	// Reset motion vectors and DC predictors
+	self->motion_backward.h = self->motion_forward.h = 0;
+	self->motion_backward.v = self->motion_forward.v = 0;
+	self->dc_predictor[0] = 128;
+	self->dc_predictor[1] = 128;
+	self->dc_predictor[2] = 128;
+
+	self->quantizer_scale = plm_buffer_read(self->buffer, 5);
+
+	// Skip extra
+	while (plm_buffer_read(self->buffer, 1)) {
+		plm_buffer_skip(self->buffer, 8);
+	}
+
+	do {
+		plm_video_decode_macroblock(self);
+	} while (
+		self->macroblock_address < self->mb_size - 1 &&
+		plm_buffer_peek_non_zero(self->buffer, 23)
+	);
+}
+
+void plm_video_decode_macroblock(plm_video_t *self) {
+	// Decode increment
+	int increment = 0;
+	int t = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT);
+
+	while (t == 34) {
+		// macroblock_stuffing
+		t = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT);
+	}
+	while (t == 35) {
+		// macroblock_escape
+		increment += 33;
+		t = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MACROBLOCK_ADDRESS_INCREMENT);
+	}
+	increment += t;
+
+	// Process any skipped macroblocks
+	if (self->slice_begin) {
+		// The first increment of each slice is relative to beginning of the
+		// previous row, not the previous macroblock
+		self->slice_begin = FALSE;
+		self->macroblock_address += increment;
+	}
+	else {
+		if (self->macroblock_address + increment >= self->mb_size) {
+			return; // invalid
+		}
+		if (increment > 1) {
+			// Skipped macroblocks reset DC predictors
+			self->dc_predictor[0] = 128;
+			self->dc_predictor[1] = 128;
+			self->dc_predictor[2] = 128;
+
+			// Skipped macroblocks in P-pictures reset motion vectors
+			if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) {
+				self->motion_forward.h = 0;
+				self->motion_forward.v = 0;
+			}
+		}
+
+		// Predict skipped macroblocks
+		while (increment > 1) {
+			self->macroblock_address++;
+			self->mb_row = self->macroblock_address / self->mb_width;
+			self->mb_col = self->macroblock_address % self->mb_width;
+
+			plm_video_predict_macroblock(self);
+			increment--;
+		}
+		self->macroblock_address++;
+	}
+
+	self->mb_row = self->macroblock_address / self->mb_width;
+	self->mb_col = self->macroblock_address % self->mb_width;
+
+	if (self->mb_col >= self->mb_width || self->mb_row >= self->mb_height) {
+		return; // corrupt stream;
+	}
+
+	// Process the current macroblock
+	const plm_vlc_t *table = PLM_VIDEO_MACROBLOCK_TYPE[self->picture_type];
+	self->macroblock_type = plm_buffer_read_vlc(self->buffer, table);
+
+	self->macroblock_intra = (self->macroblock_type & 0x01);
+	self->motion_forward.is_set = (self->macroblock_type & 0x08);
+	self->motion_backward.is_set = (self->macroblock_type & 0x04);
+
+	// Quantizer scale
+	if ((self->macroblock_type & 0x10) != 0) {
+		self->quantizer_scale = plm_buffer_read(self->buffer, 5);
+	}
+
+	if (self->macroblock_intra) {
+		// Intra-coded macroblocks reset motion vectors
+		self->motion_backward.h = self->motion_forward.h = 0;
+		self->motion_backward.v = self->motion_forward.v = 0;
+	}
+	else {
+		// Non-intra macroblocks reset DC predictors
+		self->dc_predictor[0] = 128;
+		self->dc_predictor[1] = 128;
+		self->dc_predictor[2] = 128;
+
+		plm_video_decode_motion_vectors(self);
+		plm_video_predict_macroblock(self);
+	}
+
+	// Decode blocks
+	int cbp = ((self->macroblock_type & 0x02) != 0)
+		? plm_buffer_read_vlc(self->buffer, PLM_VIDEO_CODE_BLOCK_PATTERN)
+		: (self->macroblock_intra ? 0x3f : 0);
+
+	for (int block = 0, mask = 0x20; block < 6; block++) {
+		if ((cbp & mask) != 0) {
+			plm_video_decode_block(self, block);
+		}
+		mask >>= 1;
+	}
+}
+
+void plm_video_decode_motion_vectors(plm_video_t *self) {
+
+	// Forward
+	if (self->motion_forward.is_set) {
+		int r_size = self->motion_forward.r_size;
+		self->motion_forward.h = plm_video_decode_motion_vector(self, r_size, self->motion_forward.h);
+		self->motion_forward.v = plm_video_decode_motion_vector(self, r_size, self->motion_forward.v);
+	}
+	else if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_PREDICTIVE) {
+		// No motion information in P-picture, reset vectors
+		self->motion_forward.h = 0;
+		self->motion_forward.v = 0;
+	}
+
+	if (self->motion_backward.is_set) {
+		int r_size = self->motion_backward.r_size;
+		self->motion_backward.h = plm_video_decode_motion_vector(self, r_size, self->motion_backward.h);
+		self->motion_backward.v = plm_video_decode_motion_vector(self, r_size, self->motion_backward.v);
+	}
+}
+
+int plm_video_decode_motion_vector(plm_video_t *self, int r_size, int motion) {
+	int fscale = 1 << r_size;
+	int m_code = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_MOTION);
+	int r = 0;
+	int d;
+
+	if ((m_code != 0) && (fscale != 1)) {
+		r = plm_buffer_read(self->buffer, r_size);
+		d = ((abs(m_code) - 1) << r_size) + r + 1;
+		if (m_code < 0) {
+			d = -d;
+		}
+	}
+	else {
+		d = m_code;
+	}
+
+	motion += d;
+	if (motion > (fscale << 4) - 1) {
+		motion -= fscale << 5;
+	}
+	else if (motion < (int)((unsigned)(-fscale) << 4)) {  // [jart]
+		motion += fscale << 5;
+	}
+
+	return motion;
+}
+
+void plm_video_predict_macroblock(plm_video_t *self) {
+	int fw_h = self->motion_forward.h;
+	int fw_v = self->motion_forward.v;
+
+	if (self->motion_forward.full_px) {
+		fw_h <<= 1;
+		fw_v <<= 1;
+	}
+
+	if (self->picture_type == PLM_VIDEO_PICTURE_TYPE_B) {
+		int bw_h = self->motion_backward.h;
+		int bw_v = self->motion_backward.v;
+
+		if (self->motion_backward.full_px) {
+			bw_h <<= 1;
+			bw_v <<= 1;
+		}
+
+		if (self->motion_forward.is_set) {
+			plm_video_copy_macroblock(self, &self->frame_forward, fw_h, fw_v);
+			if (self->motion_backward.is_set) {
+				plm_video_interpolate_macroblock(self, &self->frame_backward, bw_h, bw_v);
+			}
+		}
+		else {
+			plm_video_copy_macroblock(self, &self->frame_backward, bw_h, bw_v);
+		}
+	}
+	else {
+		plm_video_copy_macroblock(self, &self->frame_forward, fw_h, fw_v);
+	}
+}
+
+void plm_video_copy_macroblock(plm_video_t *self, plm_frame_t *s, int motion_h, int motion_v) {
+	plm_frame_t *d = &self->frame_current;
+	plm_video_process_macroblock(self, s->y.data, d->y.data, motion_h, motion_v, 16, FALSE);
+	plm_video_process_macroblock(self, s->cr.data, d->cr.data, motion_h / 2, motion_v / 2, 8, FALSE);
+	plm_video_process_macroblock(self, s->cb.data, d->cb.data, motion_h / 2, motion_v / 2, 8, FALSE);
+}
+
+void plm_video_interpolate_macroblock(plm_video_t *self, plm_frame_t *s, int motion_h, int motion_v) {
+	plm_frame_t *d = &self->frame_current;
+	plm_video_process_macroblock(self, s->y.data, d->y.data, motion_h, motion_v, 16, TRUE);
+	plm_video_process_macroblock(self, s->cr.data, d->cr.data, motion_h / 2, motion_v / 2, 8, TRUE);
+	plm_video_process_macroblock(self, s->cb.data, d->cb.data, motion_h / 2, motion_v / 2, 8, TRUE);
+}
+
+#define PLM_BLOCK_SET(DEST, DEST_INDEX, DEST_WIDTH, SOURCE_INDEX, SOURCE_WIDTH, BLOCK_SIZE, OP) do { \
+	int dest_scan = DEST_WIDTH - BLOCK_SIZE; \
+	int source_scan = SOURCE_WIDTH - BLOCK_SIZE; \
+	for (int y = 0; y < BLOCK_SIZE; y++) { \
+		for (int x = 0; x < BLOCK_SIZE; x++) { \
+			DEST[DEST_INDEX] = OP; \
+			SOURCE_INDEX++; DEST_INDEX++; \
+		} \
+		SOURCE_INDEX += source_scan; \
+		DEST_INDEX += dest_scan; \
+	}} while(FALSE)
+
+void plm_video_process_macroblock(
+	plm_video_t *self, uint8_t *s, uint8_t *d,
+	int motion_h, int motion_v, int block_size, int interpolate
+) {
+	int dw = self->mb_width * block_size;
+
+	int hp = motion_h >> 1;
+	int vp = motion_v >> 1;
+	int odd_h = (motion_h & 1) == 1;
+	int odd_v = (motion_v & 1) == 1;
+
+	unsigned int si = ((self->mb_row * block_size) + vp) * dw + (self->mb_col * block_size) + hp;
+	unsigned int di = (self->mb_row * dw + self->mb_col) * block_size;
+	
+	unsigned int max_address = (dw * (self->mb_height * block_size - block_size + 1) - block_size);
+	if (si > max_address || di > max_address) {
+		return; // corrupt video
+	}
+
+	#define PLM_MB_CASE(INTERPOLATE, ODD_H, ODD_V, OP) \
+		case ((INTERPOLATE << 2) | (ODD_H << 1) | (ODD_V)): \
+			PLM_BLOCK_SET(d, di, dw, si, dw, block_size, OP); \
+			break
+
+	switch ((interpolate << 2) | (odd_h << 1) | (odd_v)) {
+		PLM_MB_CASE(0, 0, 0, (s[si]));
+		PLM_MB_CASE(0, 0, 1, (s[si] + s[si + dw] + 1) >> 1);
+		PLM_MB_CASE(0, 1, 0, (s[si] + s[si + 1] + 1) >> 1);
+		PLM_MB_CASE(0, 1, 1, (s[si] + s[si + 1] + s[si + dw] + s[si + dw + 1] + 2) >> 2);
+
+		PLM_MB_CASE(1, 0, 0, (d[di] + (s[si]) + 1) >> 1);
+		PLM_MB_CASE(1, 0, 1, (d[di] + ((s[si] + s[si + dw] + 1) >> 1) + 1) >> 1);
+		PLM_MB_CASE(1, 1, 0, (d[di] + ((s[si] + s[si + 1] + 1) >> 1) + 1) >> 1);
+		PLM_MB_CASE(1, 1, 1, (d[di] + ((s[si] + s[si + 1] + s[si + dw] + s[si + dw + 1] + 2) >> 2) + 1) >> 1);
+	}
+
+	#undef PLM_MB_CASE
+}
+
+void plm_video_decode_block(plm_video_t *self, int block) {
+
+	int n = 0;
+	uint8_t *quant_matrix;
+
+	// Decode DC coefficient of intra-coded blocks
+	if (self->macroblock_intra) {
+		int predictor;
+		int dct_size;
+
+		// DC prediction
+		int plane_index = block > 3 ? block - 3 : 0;
+		predictor = self->dc_predictor[plane_index];
+		dct_size = plm_buffer_read_vlc(self->buffer, PLM_VIDEO_DCT_SIZE[plane_index]);
+
+		// Read DC coeff
+		if (dct_size > 0) {
+			int differential = plm_buffer_read(self->buffer, dct_size);
+			if ((differential & (1 << (dct_size - 1))) != 0) {
+				self->block_data[0] = predictor + differential;
+			}
+			else {
+				self->block_data[0] = predictor + (-(1 << dct_size) | (differential + 1));
+			}
+		}
+		else {
+			self->block_data[0] = predictor;
+		}
+
+		// Save predictor value
+		self->dc_predictor[plane_index] = self->block_data[0];
+
+		// Dequantize + premultiply
+		self->block_data[0] <<= (3 + 5);
+
+		quant_matrix = self->intra_quant_matrix;
+		n = 1;
+	}
+	else {
+		quant_matrix = self->non_intra_quant_matrix;
+	}
+
+	// Decode AC coefficients (+DC for non-intra)
+	int level = 0;
+	while (TRUE) {
+		int run = 0;
+		uint16_t coeff = plm_buffer_read_vlc_uint(self->buffer, PLM_VIDEO_DCT_COEFF);
+
+		if ((coeff == 0x0001) && (n > 0) && (plm_buffer_read(self->buffer, 1) == 0)) {
+			// end_of_block
+			break;
+		}
+		if (coeff == 0xffff) {
+			// escape
+			run = plm_buffer_read(self->buffer, 6);
+			level = plm_buffer_read(self->buffer, 8);
+			if (level == 0) {
+				level = plm_buffer_read(self->buffer, 8);
+			}
+			else if (level == 128) {
+				level = plm_buffer_read(self->buffer, 8) - 256;
+			}
+			else if (level > 128) {
+				level = level - 256;
+			}
+		}
+		else {
+			run = coeff >> 8;
+			level = coeff & 0xff;
+			if (plm_buffer_read(self->buffer, 1)) {
+				level = -level;
+			}
+		}
+
+		n += run;
+		if (n < 0 || n >= 64) {
+			return; // invalid
+		}
+
+		int de_zig_zagged = PLM_VIDEO_ZIG_ZAG[n];
+		n++;
+
+		// Dequantize, oddify, clip
+		level = (unsigned)level << 1;  // [jart]
+		if (!self->macroblock_intra) {
+			level += (level < 0 ? -1 : 1);
+		}
+		level = (level * self->quantizer_scale * quant_matrix[de_zig_zagged]) >> 4;
+		if ((level & 1) == 0) {
+			level -= level > 0 ? 1 : -1;
+		}
+		if (level > 2047) {
+			level = 2047;
+		}
+		else if (level < -2048) {
+			level = -2048;
+		}
+
+		// Save premultiplied coefficient
+		self->block_data[de_zig_zagged] = level * PLM_VIDEO_PREMULTIPLIER_MATRIX[de_zig_zagged];
+	}
+
+	// Move block to its place
+	uint8_t *d;
+	int dw;
+	int di;
+
+	if (block < 4) {
+		d = self->frame_current.y.data;
+		dw = self->luma_width;
+		di = (self->mb_row * self->luma_width + self->mb_col) << 4;
+		if ((block & 1) != 0) {
+			di += 8;
+		}
+		if ((block & 2) != 0) {
+			di += self->luma_width << 3;
+		}
+	}
+	else {
+		d = (block == 4) ? self->frame_current.cb.data : self->frame_current.cr.data;
+		dw = self->chroma_width;
+		di = ((self->mb_row * self->luma_width) << 2) + (self->mb_col << 3);
+	}
+
+	int *s = self->block_data;
+	int si = 0;
+	if (self->macroblock_intra) {
+		// Overwrite (no prediction)
+		if (n == 1) {
+			int clamped = plm_clamp((s[0] + 128) >> 8);
+			PLM_BLOCK_SET(d, di, dw, si, 8, 8, clamped);
+			s[0] = 0;
+		}
+		else {
+			plm_video_idct(s);
+			PLM_BLOCK_SET(d, di, dw, si, 8, 8, plm_clamp(s[si]));
+			memset(self->block_data, 0, sizeof(self->block_data));
+		}
+	}
+	else {
+		// Add data to the predicted macroblock
+		if (n == 1) {
+			int value = (s[0] + 128) >> 8;
+			PLM_BLOCK_SET(d, di, dw, si, 8, 8, plm_clamp(d[di] + value));
+			s[0] = 0;
+		}
+		else {
+			plm_video_idct(s);
+			PLM_BLOCK_SET(d, di, dw, si, 8, 8, plm_clamp(d[di] + s[si]));
+			memset(self->block_data, 0, sizeof(self->block_data));
+		}
+	}
+}
+
+void plm_video_idct(int *block) {
+	int
+		b1, b3, b4, b6, b7, tmp1, tmp2, m0,
+		x0, x1, x2, x3, x4, y3, y4, y5, y6, y7;
+
+	// Transform columns
+	for (int i = 0; i < 8; ++i) {
+		b1 = block[4 * 8 + i];
+		b3 = block[2 * 8 + i] + block[6 * 8 + i];
+		b4 = block[5 * 8 + i] - block[3 * 8 + i];
+		tmp1 = block[1 * 8 + i] + block[7 * 8 + i];
+		tmp2 = block[3 * 8 + i] + block[5 * 8 + i];
+		b6 = block[1 * 8 + i] - block[7 * 8 + i];
+		b7 = tmp1 + tmp2;
+		m0 = block[0 * 8 + i];
+		x4 = ((b6 * 473 - b4 * 196 + 128) >> 8) - b7;
+		x0 = x4 - (((tmp1 - tmp2) * 362 + 128) >> 8);
+		x1 = m0 - b1;
+		x2 = (((block[2 * 8 + i] - block[6 * 8 + i]) * 362 + 128) >> 8) - b3;
+		x3 = m0 + b1;
+		y3 = x1 + x2;
+		y4 = x3 + b3;
+		y5 = x1 - x2;
+		y6 = x3 - b3;
+		y7 = -x0 - ((b4 * 473 + b6 * 196 + 128) >> 8);
+		block[0 * 8 + i] = b7 + y4;
+		block[1 * 8 + i] = x4 + y3;
+		block[2 * 8 + i] = y5 - x0;
+		block[3 * 8 + i] = y6 - y7;
+		block[4 * 8 + i] = y6 + y7;
+		block[5 * 8 + i] = x0 + y5;
+		block[6 * 8 + i] = y3 - x4;
+		block[7 * 8 + i] = y4 - b7;
+	}
+
+	// Transform rows
+	for (int i = 0; i < 64; i += 8) {
+		b1 = block[4 + i];
+		b3 = block[2 + i] + block[6 + i];
+		b4 = block[5 + i] - block[3 + i];
+		tmp1 = block[1 + i] + block[7 + i];
+		tmp2 = block[3 + i] + block[5 + i];
+		b6 = block[1 + i] - block[7 + i];
+		b7 = tmp1 + tmp2;
+		m0 = block[0 + i];
+		x4 = ((b6 * 473 - b4 * 196 + 128) >> 8) - b7;
+		x0 = x4 - (((tmp1 - tmp2) * 362 + 128) >> 8);
+		x1 = m0 - b1;
+		x2 = (((block[2 + i] - block[6 + i]) * 362 + 128) >> 8) - b3;
+		x3 = m0 + b1;
+		y3 = x1 + x2;
+		y4 = x3 + b3;
+		y5 = x1 - x2;
+		y6 = x3 - b3;
+		y7 = -x0 - ((b4 * 473 + b6 * 196 + 128) >> 8);
+		block[0 + i] = (b7 + y4 + 128) >> 8;
+		block[1 + i] = (x4 + y3 + 128) >> 8;
+		block[2 + i] = (y5 - x0 + 128) >> 8;
+		block[3 + i] = (y6 - y7 + 128) >> 8;
+		block[4 + i] = (y6 + y7 + 128) >> 8;
+		block[5 + i] = (x0 + y5 + 128) >> 8;
+		block[6 + i] = (y3 - x4 + 128) >> 8;
+		block[7 + i] = (y4 - b7 + 128) >> 8;
+	}
+}
+
+// YCbCr conversion following the BT.601 standard:
+// https://infogalactic.com/info/YCbCr#ITU-R_BT.601_conversion
+
+#define PLM_PUT_PIXEL(RI, GI, BI, Y_OFFSET, DEST_OFFSET) \
+	y = ((frame->y.data[y_index + Y_OFFSET]-16) * 76309) >> 16; \
+	dest[d_index + DEST_OFFSET + RI] = plm_clamp(y + r); \
+	dest[d_index + DEST_OFFSET + GI] = plm_clamp(y - g); \
+	dest[d_index + DEST_OFFSET + BI] = plm_clamp(y + b);
+
+#define PLM_DEFINE_FRAME_CONVERT_FUNCTION(NAME, BYTES_PER_PIXEL, RI, GI, BI) \
+	void NAME(plm_frame_t *frame, uint8_t *dest, int stride) { \
+		int cols = frame->width >> 1; \
+		int rows = frame->height >> 1; \
+		int yw = frame->y.width; \
+		int cw = frame->cb.width; \
+		for (int row = 0; row < rows; row++) { \
+			int c_index = row * cw; \
+			int y_index = row * 2 * yw; \
+			int d_index = row * 2 * stride; \
+			for (int col = 0; col < cols; col++) { \
+				int y; \
+				int cr = frame->cr.data[c_index] - 128; \
+				int cb = frame->cb.data[c_index] - 128; \
+				int r = (cr * 104597) >> 16; \
+				int g = (cb * 25674 + cr * 53278) >> 16; \
+				int b = (cb * 132201) >> 16; \
+				PLM_PUT_PIXEL(RI, GI, BI, 0,      0); \
+				PLM_PUT_PIXEL(RI, GI, BI, 1,      BYTES_PER_PIXEL); \
+				PLM_PUT_PIXEL(RI, GI, BI, yw,     stride); \
+				PLM_PUT_PIXEL(RI, GI, BI, yw + 1, stride + BYTES_PER_PIXEL); \
+				c_index += 1; \
+				y_index += 2; \
+				d_index += 2 * BYTES_PER_PIXEL; \
+			} \
+		} \
+	}
+
+PLM_DEFINE_FRAME_CONVERT_FUNCTION(plm_frame_to_rgb,  3, 0, 1, 2)
+PLM_DEFINE_FRAME_CONVERT_FUNCTION(plm_frame_to_bgr,  3, 2, 1, 0)
+PLM_DEFINE_FRAME_CONVERT_FUNCTION(plm_frame_to_rgba, 4, 0, 1, 2)
+PLM_DEFINE_FRAME_CONVERT_FUNCTION(plm_frame_to_bgra, 4, 2, 1, 0)
+PLM_DEFINE_FRAME_CONVERT_FUNCTION(plm_frame_to_argb, 4, 1, 2, 3)
+PLM_DEFINE_FRAME_CONVERT_FUNCTION(plm_frame_to_abgr, 4, 3, 2, 1)
+
+
+#undef PLM_PUT_PIXEL
+#undef PLM_DEFINE_FRAME_CONVERT_FUNCTION
+
+
+
+// -----------------------------------------------------------------------------
+// plm_audio implementation
+
+// Based on kjmp2 by Martin J. Fiedler
+// http://keyj.emphy.de/kjmp2/
+
+static const int PLM_AUDIO_FRAME_SYNC = 0x7ff;
+
+static const int PLM_AUDIO_MPEG_2_5 = 0x0;
+static const int PLM_AUDIO_MPEG_2 = 0x2;
+static const int PLM_AUDIO_MPEG_1 = 0x3;
+
+static const int PLM_AUDIO_LAYER_III = 0x1;
+static const int PLM_AUDIO_LAYER_II = 0x2;
+static const int PLM_AUDIO_LAYER_I = 0x3;
+
+static const int PLM_AUDIO_MODE_STEREO = 0x0;
+static const int PLM_AUDIO_MODE_JOINT_STEREO = 0x1;
+static const int PLM_AUDIO_MODE_DUAL_CHANNEL = 0x2;
+static const int PLM_AUDIO_MODE_MONO = 0x3;
+
+static const unsigned short PLM_AUDIO_SAMPLE_RATE[] = {
+	44100, 48000, 32000, 0, // MPEG-1
+	22050, 24000, 16000, 0  // MPEG-2
+};
+
+static const short PLM_AUDIO_BIT_RATE[] = {
+	32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, // MPEG-1
+	 8, 16, 24, 32, 40, 48,  56,  64,  80,  96, 112, 128, 144, 160  // MPEG-2
+};
+
+static const int PLM_AUDIO_SCALEFACTOR_BASE[] = {
+	0x02000000, 0x01965FEA, 0x01428A30
+};
+
+static const float PLM_AUDIO_SYNTHESIS_WINDOW[] = {
+	     0.0,     -0.5,     -0.5,     -0.5,     -0.5,     -0.5,
+	    -0.5,     -1.0,     -1.0,     -1.0,     -1.0,     -1.5,
+	    -1.5,     -2.0,     -2.0,     -2.5,     -2.5,     -3.0,
+	    -3.5,     -3.5,     -4.0,     -4.5,     -5.0,     -5.5,
+	    -6.5,     -7.0,     -8.0,     -8.5,     -9.5,    -10.5,
+	   -12.0,    -13.0,    -14.5,    -15.5,    -17.5,    -19.0,
+	   -20.5,    -22.5,    -24.5,    -26.5,    -29.0,    -31.5,
+	   -34.0,    -36.5,    -39.5,    -42.5,    -45.5,    -48.5,
+	   -52.0,    -55.5,    -58.5,    -62.5,    -66.0,    -69.5,
+	   -73.5,    -77.0,    -80.5,    -84.5,    -88.0,    -91.5,
+	   -95.0,    -98.0,   -101.0,   -104.0,    106.5,    109.0,
+	   111.0,    112.5,    113.5,    114.0,    114.0,    113.5,
+	   112.0,    110.5,    107.5,    104.0,    100.0,     94.5,
+	    88.5,     81.5,     73.0,     63.5,     53.0,     41.5,
+	    28.5,     14.5,     -1.0,    -18.0,    -36.0,    -55.5,
+	   -76.5,    -98.5,   -122.0,   -147.0,   -173.5,   -200.5,
+	  -229.5,   -259.5,   -290.5,   -322.5,   -355.5,   -389.5,
+	  -424.0,   -459.5,   -495.5,   -532.0,   -568.5,   -605.0,
+	  -641.5,   -678.0,   -714.0,   -749.0,   -783.5,   -817.0,
+	  -849.0,   -879.5,   -908.5,   -935.0,   -959.5,   -981.0,
+	 -1000.5,  -1016.0,  -1028.5,  -1037.5,  -1042.5,  -1043.5,
+	 -1040.0,  -1031.5,   1018.5,   1000.0,    976.0,    946.5,
+	   911.0,    869.5,    822.0,    767.5,    707.0,    640.0,
+	   565.5,    485.0,    397.0,    302.5,    201.0,     92.5,
+	   -22.5,   -144.0,   -272.5,   -407.0,   -547.5,   -694.0,
+	  -846.0,  -1003.0,  -1165.0,  -1331.5,  -1502.0,  -1675.5,
+	 -1852.5,  -2031.5,  -2212.5,  -2394.0,  -2576.5,  -2758.5,
+	 -2939.5,  -3118.5,  -3294.5,  -3467.5,  -3635.5,  -3798.5,
+	 -3955.0,  -4104.5,  -4245.5,  -4377.5,  -4499.0,  -4609.5,
+	 -4708.0,  -4792.5,  -4863.5,  -4919.0,  -4958.0,  -4979.5,
+	 -4983.0,  -4967.5,  -4931.5,  -4875.0,  -4796.0,  -4694.5,
+	 -4569.5,  -4420.0,  -4246.0,  -4046.0,  -3820.0,  -3567.0,
+	  3287.0,   2979.5,   2644.0,   2280.5,   1888.0,   1467.5,
+	  1018.5,    541.0,     35.0,   -499.0,  -1061.0,  -1650.0,
+	 -2266.5,  -2909.0,  -3577.0,  -4270.0,  -4987.5,  -5727.5,
+	 -6490.0,  -7274.0,  -8077.5,  -8899.5,  -9739.0, -10594.5,
+	-11464.5, -12347.0, -13241.0, -14144.5, -15056.0, -15973.5,
+	-16895.5, -17820.0, -18744.5, -19668.0, -20588.0, -21503.0,
+	-22410.5, -23308.5, -24195.0, -25068.5, -25926.5, -26767.0,
+	-27589.0, -28389.0, -29166.5, -29919.0, -30644.5, -31342.0,
+	-32009.5, -32645.0, -33247.0, -33814.5, -34346.0, -34839.5,
+	-35295.0, -35710.0, -36084.5, -36417.5, -36707.5, -36954.0,
+	-37156.5, -37315.0, -37428.0, -37496.0,  37519.0,  37496.0,
+	 37428.0,  37315.0,  37156.5,  36954.0,  36707.5,  36417.5,
+	 36084.5,  35710.0,  35295.0,  34839.5,  34346.0,  33814.5,
+	 33247.0,  32645.0,  32009.5,  31342.0,  30644.5,  29919.0,
+	 29166.5,  28389.0,  27589.0,  26767.0,  25926.5,  25068.5,
+	 24195.0,  23308.5,  22410.5,  21503.0,  20588.0,  19668.0,
+	 18744.5,  17820.0,  16895.5,  15973.5,  15056.0,  14144.5,
+	 13241.0,  12347.0,  11464.5,  10594.5,   9739.0,   8899.5,
+	  8077.5,   7274.0,   6490.0,   5727.5,   4987.5,   4270.0,
+	  3577.0,   2909.0,   2266.5,   1650.0,   1061.0,    499.0,
+	   -35.0,   -541.0,  -1018.5,  -1467.5,  -1888.0,  -2280.5,
+	 -2644.0,  -2979.5,   3287.0,   3567.0,   3820.0,   4046.0,
+	  4246.0,   4420.0,   4569.5,   4694.5,   4796.0,   4875.0,
+	  4931.5,   4967.5,   4983.0,   4979.5,   4958.0,   4919.0,
+	  4863.5,   4792.5,   4708.0,   4609.5,   4499.0,   4377.5,
+	  4245.5,   4104.5,   3955.0,   3798.5,   3635.5,   3467.5,
+	  3294.5,   3118.5,   2939.5,   2758.5,   2576.5,   2394.0,
+	  2212.5,   2031.5,   1852.5,   1675.5,   1502.0,   1331.5,
+	  1165.0,   1003.0,    846.0,    694.0,    547.5,    407.0,
+	   272.5,    144.0,     22.5,    -92.5,   -201.0,   -302.5,
+	  -397.0,   -485.0,   -565.5,   -640.0,   -707.0,   -767.5,
+	  -822.0,   -869.5,   -911.0,   -946.5,   -976.0,  -1000.0,
+	  1018.5,   1031.5,   1040.0,   1043.5,   1042.5,   1037.5,
+	  1028.5,   1016.0,   1000.5,    981.0,    959.5,    935.0,
+	   908.5,    879.5,    849.0,    817.0,    783.5,    749.0,
+	   714.0,    678.0,    641.5,    605.0,    568.5,    532.0,
+	   495.5,    459.5,    424.0,    389.5,    355.5,    322.5,
+	   290.5,    259.5,    229.5,    200.5,    173.5,    147.0,
+	   122.0,     98.5,     76.5,     55.5,     36.0,     18.0,
+	     1.0,    -14.5,    -28.5,    -41.5,    -53.0,    -63.5,
+	   -73.0,    -81.5,    -88.5,    -94.5,   -100.0,   -104.0,
+	  -107.5,   -110.5,   -112.0,   -113.5,   -114.0,   -114.0,
+	  -113.5,   -112.5,   -111.0,   -109.0,    106.5,    104.0,
+	   101.0,     98.0,     95.0,     91.5,     88.0,     84.5,
+	    80.5,     77.0,     73.5,     69.5,     66.0,     62.5,
+	    58.5,     55.5,     52.0,     48.5,     45.5,     42.5,
+	    39.5,     36.5,     34.0,     31.5,     29.0,     26.5,
+	    24.5,     22.5,     20.5,     19.0,     17.5,     15.5,
+	    14.5,     13.0,     12.0,     10.5,      9.5,      8.5,
+	     8.0,      7.0,      6.5,      5.5,      5.0,      4.5,
+	     4.0,      3.5,      3.5,      3.0,      2.5,      2.5,
+	     2.0,      2.0,      1.5,      1.5,      1.0,      1.0,
+	     1.0,      1.0,      0.5,      0.5,      0.5,      0.5,
+	     0.5,      0.5
+};
+
+// Quantizer lookup, step 1: bitrate classes
+static const uint8_t PLM_AUDIO_QUANT_LUT_STEP_1[2][16] = {
+	// 32, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,384 <- bitrate
+	{ 0,  0,  1,  1,  1,  2,  2,  2,  2,  2,  2,  2,  2,  2 }, // mono
+	// 16, 24, 28, 32, 40, 48, 56, 64, 80, 96,112,128,160,192 <- bitrate / chan
+	{ 0,  0,  0,  0,  0,  0,  1,  1,  1,  2,  2,  2,  2,  2 } // stereo
+};
+
+// Quantizer lookup, step 2: bitrate class, sample rate -> B2 table idx, sblimit
+#define PLM_AUDIO_QUANT_TAB_A (27 | 64)   // Table 3-B.2a: high-rate, sblimit = 27
+#define PLM_AUDIO_QUANT_TAB_B (30 | 64)   // Table 3-B.2b: high-rate, sblimit = 30
+#define PLM_AUDIO_QUANT_TAB_C 8           // Table 3-B.2c:  low-rate, sblimit =  8
+#define PLM_AUDIO_QUANT_TAB_D 12          // Table 3-B.2d:  low-rate, sblimit = 12
+
+static const uint8_t QUANT_LUT_STEP_2[3][3] = {
+	//44.1 kHz,              48 kHz,                32 kHz
+	{ PLM_AUDIO_QUANT_TAB_C, PLM_AUDIO_QUANT_TAB_C, PLM_AUDIO_QUANT_TAB_D }, // 32 - 48 kbit/sec/ch
+	{ PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_A }, // 56 - 80 kbit/sec/ch
+	{ PLM_AUDIO_QUANT_TAB_B, PLM_AUDIO_QUANT_TAB_A, PLM_AUDIO_QUANT_TAB_B }  // 96+	 kbit/sec/ch
+};
+
+// Quantizer lookup, step 3: B2 table, subband -> nbal, row index
+// (upper 4 bits: nbal, lower 4 bits: row index)
+static const uint8_t PLM_AUDIO_QUANT_LUT_STEP_3[3][32] = {
+	// Low-rate table (3-B.2c and 3-B.2d)
+	{
+		0x44,0x44,
+		0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34,0x34
+	},
+	// High-rate table (3-B.2a and 3-B.2b)
+	{
+		0x43,0x43,0x43,
+		0x42,0x42,0x42,0x42,0x42,0x42,0x42,0x42,
+		0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,
+		0x20,0x20,0x20,0x20,0x20,0x20,0x20
+	},
+	// MPEG-2 LSR table (B.2 in ISO 13818-3)
+	{
+		0x45,0x45,0x45,0x45,
+		0x34,0x34,0x34,0x34,0x34,0x34,0x34,
+		0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,
+		0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24
+	}
+};
+
+// Quantizer lookup, step 4: table row, allocation[] value -> quant table index
+static const uint8_t PLM_AUDIO_QUANT_LUT_STEP_4[6][16] = {
+	{ 0, 1, 2, 17 },
+	{ 0, 1, 2,  3, 4, 5, 6, 17 },
+	{ 0, 1, 2,  3, 4, 5, 6,  7,  8,  9, 10, 11, 12, 13, 14, 17 },
+	{ 0, 1, 3,  5, 6, 7, 8,  9, 10, 11, 12, 13, 14, 15, 16, 17 },
+	{ 0, 1, 2,  4, 5, 6, 7,  8,  9, 10, 11, 12, 13, 14, 15, 17 },
+	{ 0, 1, 2,  3, 4, 5, 6,  7,  8,  9, 10, 11, 12, 13, 14, 15 }
+};
+
+typedef struct plm_quantizer_spec_t {
+	unsigned short levels;
+	unsigned char group;
+	unsigned char bits;
+} plm_quantizer_spec_t;
+
+static const plm_quantizer_spec_t PLM_AUDIO_QUANT_TAB[] = {
+	{     3, 1,  5 },  //  1
+	{     5, 1,  7 },  //  2
+	{     7, 0,  3 },  //  3
+	{     9, 1, 10 },  //  4
+	{    15, 0,  4 },  //  5
+	{    31, 0,  5 },  //  6
+	{    63, 0,  6 },  //  7
+	{   127, 0,  7 },  //  8
+	{   255, 0,  8 },  //  9
+	{   511, 0,  9 },  // 10
+	{  1023, 0, 10 },  // 11
+	{  2047, 0, 11 },  // 12
+	{  4095, 0, 12 },  // 13
+	{  8191, 0, 13 },  // 14
+	{ 16383, 0, 14 },  // 15
+	{ 32767, 0, 15 },  // 16
+	{ 65535, 0, 16 }   // 17
+};
+
+struct plm_audio_t {
+	double time;
+	int samples_decoded;
+	int samplerate_index;
+	int bitrate_index;
+	int version;
+	int layer;
+	int mode;
+	int bound;
+	int v_pos;
+	int next_frame_data_size;
+	int has_header;
+	
+	plm_buffer_t *buffer;
+	int destroy_buffer_when_done;
+
+	const plm_quantizer_spec_t *allocation[2][32];
+	uint8_t scale_factor_info[2][32];
+	int scale_factor[2][32][3];
+	int sample[2][32][3];
+
+	plm_samples_t samples;
+	float D[1024];
+	float V[2][1024];
+	float U[32];
+};
+
+int plm_audio_find_frame_sync(plm_audio_t *self);
+int plm_audio_decode_header(plm_audio_t *self);
+void plm_audio_decode_frame(plm_audio_t *self);
+const plm_quantizer_spec_t *plm_audio_read_allocation(plm_audio_t *self, int sb, int tab3);
+void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part); 
+void plm_audio_idct36(int s[32][3], int ss, float *d, int dp);
+
+plm_audio_t *plm_audio_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {
+	plm_audio_t *self = (plm_audio_t *)PLM_MALLOC(sizeof(plm_audio_t));
+	memset(self, 0, sizeof(plm_audio_t));
+
+	self->samples.count = PLM_AUDIO_SAMPLES_PER_FRAME;
+	self->buffer = buffer;
+	self->destroy_buffer_when_done = destroy_when_done;
+	self->samplerate_index = 3; // Indicates 0
+
+	memcpy(self->D, PLM_AUDIO_SYNTHESIS_WINDOW, 512 * sizeof(float));
+	memcpy(self->D + 512, PLM_AUDIO_SYNTHESIS_WINDOW, 512 * sizeof(float));
+
+	// Attempt to decode first header
+	self->next_frame_data_size = plm_audio_decode_header(self);
+
+	return self;
+}
+
+void plm_audio_destroy(plm_audio_t *self) {
+	if (self->destroy_buffer_when_done) {
+		plm_buffer_destroy(self->buffer);
+	}
+	PLM_FREE(self);
+}
+
+int plm_audio_has_header(plm_audio_t *self) {
+	if (self->has_header) {
+		return TRUE;
+	}
+	
+	self->next_frame_data_size = plm_audio_decode_header(self);
+	return self->has_header;
+}
+
+int plm_audio_get_samplerate(plm_audio_t *self) {
+	return plm_audio_has_header(self)
+		? PLM_AUDIO_SAMPLE_RATE[self->samplerate_index]
+		: 0;
+}
+
+double plm_audio_get_time(plm_audio_t *self) {
+	return self->time;
+}
+
+void plm_audio_set_time(plm_audio_t *self, double time) {
+	self->samples_decoded = time * 
+		(double)PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
+	self->time = time;
+}
+
+void plm_audio_rewind(plm_audio_t *self) {
+	plm_buffer_rewind(self->buffer);
+	self->time = 0;
+	self->samples_decoded = 0;
+	self->next_frame_data_size = 0;
+}
+
+int plm_audio_has_ended(plm_audio_t *self) {
+	return plm_buffer_has_ended(self->buffer);
+}
+
+plm_samples_t *plm_audio_decode(plm_audio_t *self) {
+	// Do we have at least enough information to decode the frame header?
+	if (!self->next_frame_data_size) {
+		if (!plm_buffer_has(self->buffer, 48)) {
+			return NULL;
+		}
+		self->next_frame_data_size = plm_audio_decode_header(self);
+	}
+
+	if (
+		self->next_frame_data_size == 0 ||
+		!plm_buffer_has(self->buffer, self->next_frame_data_size << 3)
+	) {
+		return NULL;
+	}
+
+	plm_audio_decode_frame(self);
+	self->next_frame_data_size = 0;
+	
+	self->samples.time = self->time;
+
+	self->samples_decoded += PLM_AUDIO_SAMPLES_PER_FRAME;
+	self->time = (double)self->samples_decoded / 
+		(double)PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
+	
+	return &self->samples;
+}
+
+int plm_audio_find_frame_sync(plm_audio_t *self) {
+	size_t i;
+	for (i = self->buffer->bit_index >> 3; i < self->buffer->length-1; i++) {
+		if (
+			self->buffer->bytes[i] == 0xFF &&
+			(self->buffer->bytes[i+1] & 0xFE) == 0xFC
+		) {
+			self->buffer->bit_index = ((i+1) << 3) + 3;
+			return TRUE;
+		}
+	}
+	self->buffer->bit_index = (i + 1) << 3;
+	return FALSE;
+}
+
+int plm_audio_decode_header(plm_audio_t *self) {
+	if (!plm_buffer_has(self->buffer, 48)) {
+		return 0;
+	}
+
+	plm_buffer_skip_bytes(self->buffer, 0x00);
+	int sync = plm_buffer_read(self->buffer, 11);
+
+
+	// Attempt to resync if no syncword was found. This sucks balls. The MP2 
+	// stream contains a syncword just before every frame (11 bits set to 1).
+	// However, this syncword is not guaranteed to not occur elsewhere in the
+	// stream. So, if we have to resync, we also have to check if the header 
+	// (samplerate, bitrate) differs from the one we had before. This all
+	// may still lead to garbage data being decoded :/
+
+	if (sync != PLM_AUDIO_FRAME_SYNC && !plm_audio_find_frame_sync(self)) {
+		return 0;
+	}
+
+	self->version = plm_buffer_read(self->buffer, 2);
+	self->layer = plm_buffer_read(self->buffer, 2);
+	int hasCRC = !plm_buffer_read(self->buffer, 1);
+
+	if (
+		self->version != PLM_AUDIO_MPEG_1 ||
+		self->layer != PLM_AUDIO_LAYER_II
+	) {
+		return 0;
+	}
+
+	int bitrate_index = plm_buffer_read(self->buffer, 4) - 1;
+	if (bitrate_index > 13) {
+		return 0;
+	}
+
+	int samplerate_index = plm_buffer_read(self->buffer, 2);
+	if (samplerate_index == 3) {
+		return 0;
+	}
+
+	int padding = plm_buffer_read(self->buffer, 1);
+	plm_buffer_skip(self->buffer, 1); // f_private
+	int mode = plm_buffer_read(self->buffer, 2);
+
+	// If we already have a header, make sure the samplerate, bitrate and mode
+	// are still the same, otherwise we might have missed sync.
+	if (
+		self->has_header && (
+			self->bitrate_index != bitrate_index ||
+			self->samplerate_index != samplerate_index ||
+			self->mode != mode
+		)
+	) {
+		return 0;
+	}
+
+	self->bitrate_index = bitrate_index;
+	self->samplerate_index = samplerate_index;
+	self->mode = mode;
+	self->has_header = TRUE;
+
+	// Parse the mode_extension, set up the stereo bound
+	if (mode == PLM_AUDIO_MODE_JOINT_STEREO) {
+		self->bound = (plm_buffer_read(self->buffer, 2) + 1) << 2;
+	}
+	else {
+		plm_buffer_skip(self->buffer, 2);
+		self->bound = (mode == PLM_AUDIO_MODE_MONO) ? 0 : 32;
+	}
+
+	// Discard the last 4 bits of the header and the CRC value, if present
+	plm_buffer_skip(self->buffer, 4); // copyright(1), original(1), emphasis(2)
+	if (hasCRC) {
+		plm_buffer_skip(self->buffer, 16);
+	}
+
+	// Compute frame size, check if we have enough data to decode the whole
+	// frame.
+	int bitrate = PLM_AUDIO_BIT_RATE[self->bitrate_index];
+	int samplerate = PLM_AUDIO_SAMPLE_RATE[self->samplerate_index];
+	int frame_size = (144000 * bitrate / samplerate) + padding;
+	return frame_size - (hasCRC ? 6 : 4);
+}
+
+void plm_audio_decode_frame(plm_audio_t *self) {
+	// Prepare the quantizer table lookups
+	int tab3 = 0;
+	int sblimit = 0;
+	
+	int tab1 = (self->mode == PLM_AUDIO_MODE_MONO) ? 0 : 1;
+	int tab2 = PLM_AUDIO_QUANT_LUT_STEP_1[tab1][self->bitrate_index];
+	tab3 = QUANT_LUT_STEP_2[tab2][self->samplerate_index];
+	sblimit = tab3 & 63;
+	tab3 >>= 6;
+
+	if (self->bound > sblimit) {
+		self->bound = sblimit;
+	}
+
+	// Read the allocation information
+	for (int sb = 0; sb < self->bound; sb++) {
+		self->allocation[0][sb] = plm_audio_read_allocation(self, sb, tab3);
+		self->allocation[1][sb] = plm_audio_read_allocation(self, sb, tab3);
+	}
+
+	for (int sb = self->bound; sb < sblimit; sb++) {
+		self->allocation[0][sb] =
+			self->allocation[1][sb] =
+			plm_audio_read_allocation(self, sb, tab3);
+	}
+
+	// Read scale factor selector information
+	int channels = (self->mode == PLM_AUDIO_MODE_MONO) ? 1 : 2;
+	for (int sb = 0; sb < sblimit; sb++) {
+		for (int ch = 0; ch < channels; ch++) {
+			if (self->allocation[ch][sb]) {
+				self->scale_factor_info[ch][sb] = plm_buffer_read(self->buffer, 2);
+			}
+		}
+		if (self->mode == PLM_AUDIO_MODE_MONO) {
+			self->scale_factor_info[1][sb] = self->scale_factor_info[0][sb];
+		}
+	}
+
+	// Read scale factors
+	for (int sb = 0; sb < sblimit; sb++) {
+		for (int ch = 0; ch < channels; ch++) {
+			if (self->allocation[ch][sb]) {
+				int *sf = self->scale_factor[ch][sb];
+				switch (self->scale_factor_info[ch][sb]) {
+					case 0:
+						sf[0] = plm_buffer_read(self->buffer, 6);
+						sf[1] = plm_buffer_read(self->buffer, 6);
+						sf[2] = plm_buffer_read(self->buffer, 6);
+						break;
+					case 1:
+						sf[0] = 
+						sf[1] = plm_buffer_read(self->buffer, 6);
+						sf[2] = plm_buffer_read(self->buffer, 6);
+						break;
+					case 2:
+						sf[0] = 
+						sf[1] = 
+						sf[2] = plm_buffer_read(self->buffer, 6);
+						break;
+					case 3:
+						sf[0] = plm_buffer_read(self->buffer, 6);
+						sf[1] = 
+						sf[2] = plm_buffer_read(self->buffer, 6);
+						break;
+				}
+			}
+		}
+		if (self->mode == PLM_AUDIO_MODE_MONO) {
+			self->scale_factor[1][sb][0] = self->scale_factor[0][sb][0];
+			self->scale_factor[1][sb][1] = self->scale_factor[0][sb][1];
+			self->scale_factor[1][sb][2] = self->scale_factor[0][sb][2];
+		}
+	}
+
+	// Coefficient input and reconstruction
+	int out_pos = 0;
+	for (int part = 0; part < 3; part++) {
+		for (int granule = 0; granule < 4; granule++) {
+
+			// Read the samples
+			for (int sb = 0; sb < self->bound; sb++) {
+				plm_audio_read_samples(self, 0, sb, part);
+				plm_audio_read_samples(self, 1, sb, part);
+			}
+			for (int sb = self->bound; sb < sblimit; sb++) {
+				plm_audio_read_samples(self, 0, sb, part);
+				self->sample[1][sb][0] = self->sample[0][sb][0];
+				self->sample[1][sb][1] = self->sample[0][sb][1];
+				self->sample[1][sb][2] = self->sample[0][sb][2];
+			}
+			for (int sb = sblimit; sb < 32; sb++) {
+				self->sample[0][sb][0] = 0;
+				self->sample[0][sb][1] = 0;
+				self->sample[0][sb][2] = 0;
+				self->sample[1][sb][0] = 0;
+				self->sample[1][sb][1] = 0;
+				self->sample[1][sb][2] = 0;
+			}
+
+			// Synthesis loop
+			for (int p = 0; p < 3; p++) {
+				// Shifting step
+				self->v_pos = (self->v_pos - 64) & 1023;
+
+				for (int ch = 0; ch < 2; ch++) {
+					plm_audio_idct36(self->sample[ch], p, self->V[ch], self->v_pos);
+
+					// Build U, windowing, calculate output
+					memset(self->U, 0, sizeof(self->U));
+
+					int d_index = 512 - (self->v_pos >> 1);
+					int v_index = (self->v_pos % 128) >> 1;
+					while (v_index < 1024) {
+						for (int i = 0; i < 32; ++i) {
+							self->U[i] += self->D[d_index++] * self->V[ch][v_index++];
+						}
+
+						v_index += 128 - 32;
+						d_index += 64 - 32;
+					}
+
+					d_index -= (512 - 32);
+					v_index = (128 - 32 + 1024) - v_index;
+					while (v_index < 1024) {
+						for (int i = 0; i < 32; ++i) {
+							self->U[i] += self->D[d_index++] * self->V[ch][v_index++];
+						}
+
+						v_index += 128 - 32;
+						d_index += 64 - 32;
+					}
+
+					// Output samples
+					#ifdef PLM_AUDIO_SEPARATE_CHANNELS
+						float *out_channel = ch == 0
+							? self->samples.left
+							: self->samples.right;
+						for (int j = 0; j < 32; j++) {
+							out_channel[out_pos + j] = self->U[j] / 2147418112.0f;
+						}
+					#else
+						for (int j = 0; j < 32; j++) {
+							self->samples.interleaved[((out_pos + j) << 1) + ch] = 
+								self->U[j] / 2147418112.0f;
+						}
+					#endif
+				} // End of synthesis channel loop
+				out_pos += 32;
+			} // End of synthesis sub-block loop
+
+		} // Decoding of the granule finished
+	}
+
+	plm_buffer_align(self->buffer);
+}
+
+const plm_quantizer_spec_t *plm_audio_read_allocation(plm_audio_t *self, int sb, int tab3) {
+	int tab4 = PLM_AUDIO_QUANT_LUT_STEP_3[tab3][sb];
+	int qtab = PLM_AUDIO_QUANT_LUT_STEP_4[tab4 & 15][plm_buffer_read(self->buffer, tab4 >> 4)];
+	return qtab ? (&PLM_AUDIO_QUANT_TAB[qtab - 1]) : 0;
+}
+
+void plm_audio_read_samples(plm_audio_t *self, int ch, int sb, int part) {
+	const plm_quantizer_spec_t *q = self->allocation[ch][sb];
+	int sf = self->scale_factor[ch][sb][part];
+	int *sample = self->sample[ch][sb];
+	int val = 0;
+
+	if (!q) {
+		// No bits allocated for this subband
+		sample[0] = sample[1] = sample[2] = 0;
+		return;
+	}
+
+	// Resolve scalefactor
+	if (sf == 63) {
+		sf = 0;
+	}
+	else {
+		int shift = (sf / 3) | 0;
+		sf = (PLM_AUDIO_SCALEFACTOR_BASE[sf % 3] + ((1 << shift) >> 1)) >> shift;
+	}
+
+	// Decode samples
+	int adj = q->levels;
+	if (q->group) {
+		// Decode grouped samples
+		val = plm_buffer_read(self->buffer, q->bits);
+		sample[0] = val % adj;
+		val /= adj;
+		sample[1] = val % adj;
+		sample[2] = val / adj;
+	}
+	else {
+		// Decode direct samples
+		sample[0] = plm_buffer_read(self->buffer, q->bits);
+		sample[1] = plm_buffer_read(self->buffer, q->bits);
+		sample[2] = plm_buffer_read(self->buffer, q->bits);
+	}
+
+	// Postmultiply samples
+	int scale = 65536 / (adj + 1);
+	adj = ((adj + 1) >> 1) - 1;
+
+	val = (adj - sample[0]) * scale;
+	sample[0] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
+
+	val = (adj - sample[1]) * scale;
+	sample[1] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
+
+	val = (adj - sample[2]) * scale;
+	sample[2] = (val * (sf >> 12) + ((val * (sf & 4095) + 2048) >> 12)) >> 12;
+}
+
+void plm_audio_idct36(int s[32][3], int ss, float *d, int dp) {
+	float t01, t02, t03, t04, t05, t06, t07, t08, t09, t10, t11, t12,
+		t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24,
+		t25, t26, t27, t28, t29, t30, t31, t32, t33;
+
+	t01 = (float)(s[0][ss] + s[31][ss]); t02 = (float)(s[0][ss] - s[31][ss]) * 0.500602998235f;
+	t03 = (float)(s[1][ss] + s[30][ss]); t04 = (float)(s[1][ss] - s[30][ss]) * 0.505470959898f;
+	t05 = (float)(s[2][ss] + s[29][ss]); t06 = (float)(s[2][ss] - s[29][ss]) * 0.515447309923f;
+	t07 = (float)(s[3][ss] + s[28][ss]); t08 = (float)(s[3][ss] - s[28][ss]) * 0.53104259109f;
+	t09 = (float)(s[4][ss] + s[27][ss]); t10 = (float)(s[4][ss] - s[27][ss]) * 0.553103896034f;
+	t11 = (float)(s[5][ss] + s[26][ss]); t12 = (float)(s[5][ss] - s[26][ss]) * 0.582934968206f;
+	t13 = (float)(s[6][ss] + s[25][ss]); t14 = (float)(s[6][ss] - s[25][ss]) * 0.622504123036f;
+	t15 = (float)(s[7][ss] + s[24][ss]); t16 = (float)(s[7][ss] - s[24][ss]) * 0.674808341455f;
+	t17 = (float)(s[8][ss] + s[23][ss]); t18 = (float)(s[8][ss] - s[23][ss]) * 0.744536271002f;
+	t19 = (float)(s[9][ss] + s[22][ss]); t20 = (float)(s[9][ss] - s[22][ss]) * 0.839349645416f;
+	t21 = (float)(s[10][ss] + s[21][ss]); t22 = (float)(s[10][ss] - s[21][ss]) * 0.972568237862f;
+	t23 = (float)(s[11][ss] + s[20][ss]); t24 = (float)(s[11][ss] - s[20][ss]) * 1.16943993343f;
+	t25 = (float)(s[12][ss] + s[19][ss]); t26 = (float)(s[12][ss] - s[19][ss]) * 1.48416461631f;
+	t27 = (float)(s[13][ss] + s[18][ss]); t28 = (float)(s[13][ss] - s[18][ss]) * 2.05778100995f;
+	t29 = (float)(s[14][ss] + s[17][ss]); t30 = (float)(s[14][ss] - s[17][ss]) * 3.40760841847f;
+	t31 = (float)(s[15][ss] + s[16][ss]); t32 = (float)(s[15][ss] - s[16][ss]) * 10.1900081235f;
+
+	t33 = t01 + t31; t31 = (t01 - t31) * 0.502419286188f;
+	t01 = t03 + t29; t29 = (t03 - t29) * 0.52249861494f;
+	t03 = t05 + t27; t27 = (t05 - t27) * 0.566944034816f;
+	t05 = t07 + t25; t25 = (t07 - t25) * 0.64682178336f;
+	t07 = t09 + t23; t23 = (t09 - t23) * 0.788154623451f;
+	t09 = t11 + t21; t21 = (t11 - t21) * 1.06067768599f;
+	t11 = t13 + t19; t19 = (t13 - t19) * 1.72244709824f;
+	t13 = t15 + t17; t17 = (t15 - t17) * 5.10114861869f;
+	t15 = t33 + t13; t13 = (t33 - t13) * 0.509795579104f;
+	t33 = t01 + t11; t01 = (t01 - t11) * 0.601344886935f;
+	t11 = t03 + t09; t09 = (t03 - t09) * 0.899976223136f;
+	t03 = t05 + t07; t07 = (t05 - t07) * 2.56291544774f;
+	t05 = t15 + t03; t15 = (t15 - t03) * 0.541196100146f;
+	t03 = t33 + t11; t11 = (t33 - t11) * 1.30656296488f;
+	t33 = t05 + t03; t05 = (t05 - t03) * 0.707106781187f;
+	t03 = t15 + t11; t15 = (t15 - t11) * 0.707106781187f;
+	t03 += t15;
+	t11 = t13 + t07; t13 = (t13 - t07) * 0.541196100146f;
+	t07 = t01 + t09; t09 = (t01 - t09) * 1.30656296488f;
+	t01 = t11 + t07; t07 = (t11 - t07) * 0.707106781187f;
+	t11 = t13 + t09; t13 = (t13 - t09) * 0.707106781187f;
+	t11 += t13; t01 += t11;
+	t11 += t07; t07 += t13;
+	t09 = t31 + t17; t31 = (t31 - t17) * 0.509795579104f;
+	t17 = t29 + t19; t29 = (t29 - t19) * 0.601344886935f;
+	t19 = t27 + t21; t21 = (t27 - t21) * 0.899976223136f;
+	t27 = t25 + t23; t23 = (t25 - t23) * 2.56291544774f;
+	t25 = t09 + t27; t09 = (t09 - t27) * 0.541196100146f;
+	t27 = t17 + t19; t19 = (t17 - t19) * 1.30656296488f;
+	t17 = t25 + t27; t27 = (t25 - t27) * 0.707106781187f;
+	t25 = t09 + t19; t19 = (t09 - t19) * 0.707106781187f;
+	t25 += t19;
+	t09 = t31 + t23; t31 = (t31 - t23) * 0.541196100146f;
+	t23 = t29 + t21; t21 = (t29 - t21) * 1.30656296488f;
+	t29 = t09 + t23; t23 = (t09 - t23) * 0.707106781187f;
+	t09 = t31 + t21; t31 = (t31 - t21) * 0.707106781187f;
+	t09 += t31;	t29 += t09;	t09 += t23;	t23 += t31;
+	t17 += t29;	t29 += t25;	t25 += t09;	t09 += t27;
+	t27 += t23;	t23 += t19; t19 += t31;
+	t21 = t02 + t32; t02 = (t02 - t32) * 0.502419286188f;
+	t32 = t04 + t30; t04 = (t04 - t30) * 0.52249861494f;
+	t30 = t06 + t28; t28 = (t06 - t28) * 0.566944034816f;
+	t06 = t08 + t26; t08 = (t08 - t26) * 0.64682178336f;
+	t26 = t10 + t24; t10 = (t10 - t24) * 0.788154623451f;
+	t24 = t12 + t22; t22 = (t12 - t22) * 1.06067768599f;
+	t12 = t14 + t20; t20 = (t14 - t20) * 1.72244709824f;
+	t14 = t16 + t18; t16 = (t16 - t18) * 5.10114861869f;
+	t18 = t21 + t14; t14 = (t21 - t14) * 0.509795579104f;
+	t21 = t32 + t12; t32 = (t32 - t12) * 0.601344886935f;
+	t12 = t30 + t24; t24 = (t30 - t24) * 0.899976223136f;
+	t30 = t06 + t26; t26 = (t06 - t26) * 2.56291544774f;
+	t06 = t18 + t30; t18 = (t18 - t30) * 0.541196100146f;
+	t30 = t21 + t12; t12 = (t21 - t12) * 1.30656296488f;
+	t21 = t06 + t30; t30 = (t06 - t30) * 0.707106781187f;
+	t06 = t18 + t12; t12 = (t18 - t12) * 0.707106781187f;
+	t06 += t12;
+	t18 = t14 + t26; t26 = (t14 - t26) * 0.541196100146f;
+	t14 = t32 + t24; t24 = (t32 - t24) * 1.30656296488f;
+	t32 = t18 + t14; t14 = (t18 - t14) * 0.707106781187f;
+	t18 = t26 + t24; t24 = (t26 - t24) * 0.707106781187f;
+	t18 += t24; t32 += t18;
+	t18 += t14; t26 = t14 + t24;
+	t14 = t02 + t16; t02 = (t02 - t16) * 0.509795579104f;
+	t16 = t04 + t20; t04 = (t04 - t20) * 0.601344886935f;
+	t20 = t28 + t22; t22 = (t28 - t22) * 0.899976223136f;
+	t28 = t08 + t10; t10 = (t08 - t10) * 2.56291544774f;
+	t08 = t14 + t28; t14 = (t14 - t28) * 0.541196100146f;
+	t28 = t16 + t20; t20 = (t16 - t20) * 1.30656296488f;
+	t16 = t08 + t28; t28 = (t08 - t28) * 0.707106781187f;
+	t08 = t14 + t20; t20 = (t14 - t20) * 0.707106781187f;
+	t08 += t20;
+	t14 = t02 + t10; t02 = (t02 - t10) * 0.541196100146f;
+	t10 = t04 + t22; t22 = (t04 - t22) * 1.30656296488f;
+	t04 = t14 + t10; t10 = (t14 - t10) * 0.707106781187f;
+	t14 = t02 + t22; t02 = (t02 - t22) * 0.707106781187f;
+	t14 += t02;	t04 += t14;	t14 += t10;	t10 += t02;
+	t16 += t04;	t04 += t08;	t08 += t14;	t14 += t28;
+	t28 += t10;	t10 += t20;	t20 += t02;	t21 += t16;
+	t16 += t32;	t32 += t04;	t04 += t06;	t06 += t08;
+	t08 += t18;	t18 += t14;	t14 += t30;	t30 += t28;
+	t28 += t26;	t26 += t10;	t10 += t12;	t12 += t20;
+	t20 += t24;	t24 += t02;
+
+	d[dp + 48] = -t33;
+	d[dp + 49] = d[dp + 47] = -t21;
+	d[dp + 50] = d[dp + 46] = -t17;
+	d[dp + 51] = d[dp + 45] = -t16;
+	d[dp + 52] = d[dp + 44] = -t01;
+	d[dp + 53] = d[dp + 43] = -t32;
+	d[dp + 54] = d[dp + 42] = -t29;
+	d[dp + 55] = d[dp + 41] = -t04;
+	d[dp + 56] = d[dp + 40] = -t03;
+	d[dp + 57] = d[dp + 39] = -t06;
+	d[dp + 58] = d[dp + 38] = -t25;
+	d[dp + 59] = d[dp + 37] = -t08;
+	d[dp + 60] = d[dp + 36] = -t11;
+	d[dp + 61] = d[dp + 35] = -t18;
+	d[dp + 62] = d[dp + 34] = -t09;
+	d[dp + 63] = d[dp + 33] = -t14;
+	d[dp + 32] = -t05;
+	d[dp + 0] = t05; d[dp + 31] = -t30;
+	d[dp + 1] = t30; d[dp + 30] = -t27;
+	d[dp + 2] = t27; d[dp + 29] = -t28;
+	d[dp + 3] = t28; d[dp + 28] = -t07;
+	d[dp + 4] = t07; d[dp + 27] = -t26;
+	d[dp + 5] = t26; d[dp + 26] = -t23;
+	d[dp + 6] = t23; d[dp + 25] = -t10;
+	d[dp + 7] = t10; d[dp + 24] = -t15;
+	d[dp + 8] = t15; d[dp + 23] = -t12;
+	d[dp + 9] = t12; d[dp + 22] = -t19;
+	d[dp + 10] = t19; d[dp + 21] = -t20;
+	d[dp + 11] = t20; d[dp + 20] = -t13;
+	d[dp + 12] = t13; d[dp + 19] = -t24;
+	d[dp + 13] = t24; d[dp + 18] = -t31;
+	d[dp + 14] = t31; d[dp + 17] = -t02;
+	d[dp + 15] = t02; d[dp + 16] = 0.0;
+}
+
+
+#endif // PL_MPEG_IMPLEMENTATION
diff --git a/dsp/mpeg/plm.c b/dsp/mpeg/plm.c
deleted file mode 100644
index 7704643ff..000000000
--- a/dsp/mpeg/plm.c
+++ /dev/null
@@ -1,332 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=4 sw=4 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND                       │
-│  NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/mpeg.h"
-#include "libc/log/log.h"
-#include "libc/mem/mem.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-__static_yoink("pl_mpeg_notice");
-
-/* clang-format off */
-// -----------------------------------------------------------------------------
-// plm (high-level interface) implementation
-
-typedef struct plm_t {
-	plm_demux_t *demux;
-	double time;
-	int has_ended;
-	int loop;
-
-	int video_packet_type;
-	plm_buffer_t *video_buffer;
-	plm_video_t *video_decoder;
-
-	int audio_packet_type;
-	double audio_lead_time;
-	plm_buffer_t *audio_buffer;
-	plm_audio_t *audio_decoder;
-
-	plm_video_decode_callback video_decode_callback;
-	void *video_decode_callback_user_data;
-
-	plm_audio_decode_callback audio_decode_callback;
-	void *audio_decode_callback_user_data;
-} plm_t;
-
-void plm_handle_end(plm_t *self);
-void plm_read_video_packet(plm_buffer_t *buffer, void *user);
-void plm_read_audio_packet(plm_buffer_t *buffer, void *user);
-void plm_read_packets(plm_t *self, int requested_type);
-
-plm_t *plm_create_with_filename(const char *filename) {
-	plm_buffer_t *buffer = plm_buffer_create_with_filename(filename);
-	if (!buffer) {
-		return NULL;
-	}
-	return plm_create_with_buffer(buffer, true);
-}
-
-plm_t *plm_create_with_file(FILE *fh, int close_when_done) {
-	plm_buffer_t *buffer = plm_buffer_create_with_file(fh, close_when_done);
-	return plm_create_with_buffer(buffer, true);
-}
-
-plm_t *plm_create_with_memory(uint8_t *bytes, size_t length, int free_when_done) {
-	plm_buffer_t *buffer = plm_buffer_create_with_memory(bytes, length, free_when_done);
-	return plm_create_with_buffer(buffer, true);
-}
-
-plm_t *plm_create_with_buffer(plm_buffer_t *buffer, int destroy_when_done) {
-	plm_t *self = (plm_t *)malloc(sizeof(plm_t));
-	memset(self, 0, sizeof(plm_t));
-
-	self->demux = plm_demux_create(buffer, destroy_when_done);
-
-	// In theory we should check plm_demux_get_num_video_streams() and
-	// plm_demux_get_num_audio_streams() here, but older files typically
-	// do not specify these correctly. So we just assume we have a video and
-	// audio stream and create the decoders.
-
-	self->video_packet_type = PLM_DEMUX_PACKET_VIDEO_1;
-	self->video_buffer = plm_buffer_create_with_capacity(PLM_BUFFER_DEFAULT_SIZE);
-	plm_buffer_set_load_callback(self->video_buffer, plm_read_video_packet, self);
-
-	self->audio_packet_type = PLM_DEMUX_PACKET_AUDIO_1;
-	self->audio_buffer = plm_buffer_create_with_capacity(PLM_BUFFER_DEFAULT_SIZE);
-	plm_buffer_set_load_callback(self->audio_buffer, plm_read_audio_packet, self);
-
-	self->video_decoder = plm_video_create_with_buffer(self->video_buffer, true);
-	self->audio_decoder = plm_audio_create_with_buffer(self->audio_buffer, true);
-
-	return self;
-}
-
-void plm_destroy(plm_t *self) {
-	plm_video_destroy(self->video_decoder);
-	plm_audio_destroy(self->audio_decoder);
-	plm_demux_destroy(self->demux);
-	free(self);
-}
-
-int plm_get_audio_enabled(plm_t *self) {
-	return (self->audio_packet_type != 0);
-}
-
-void plm_set_audio_enabled(plm_t *self, int enabled, int stream_index) {
-	/* int num_streams = plm_demux_get_num_audio_streams(self->demux); */
-	self->audio_packet_type = (enabled && stream_index >= 0 && stream_index < 4)
-		? PLM_DEMUX_PACKET_AUDIO_1 + stream_index
-		: 0;
-}
-
-int plm_get_video_enabled(plm_t *self) {
-	return (self->video_packet_type != 0);
-}
-
-void plm_set_video_enabled(plm_t *self, int enabled) {
-	self->video_packet_type = (enabled)
-		? PLM_DEMUX_PACKET_VIDEO_1
-		: 0;
-}
-
-int plm_get_width(plm_t *self) {
-	return plm_video_get_width(self->video_decoder);
-}
-
-double plm_get_pixel_aspect_ratio(plm_t *self) {
-	return plm_video_get_pixel_aspect_ratio(self->video_decoder);
-}
-
-int plm_get_height(plm_t *self) {
-	return plm_video_get_height(self->video_decoder);
-}
-
-double plm_get_framerate(plm_t *self) {
-	return plm_video_get_framerate(self->video_decoder);
-}
-
-int plm_get_num_audio_streams(plm_t *self) {
-	// Some files do not specify the number of audio streams in the system header.
-	// If the reported number of streams is 0, we check if we have a samplerate,
-	// indicating at least one audio stream.
-	int num_streams = plm_demux_get_num_audio_streams(self->demux);
-	return num_streams == 0 && plm_get_samplerate(self) ? 1 : num_streams;
-}
-
-int plm_get_samplerate(plm_t *self) {
-	return plm_audio_get_samplerate(self->audio_decoder);
-}
-
-double plm_get_audio_lead_time(plm_t *self) {
-	return self->audio_lead_time;
-}
-
-void plm_set_audio_lead_time(plm_t *self, double lead_time) {
-	self->audio_lead_time = lead_time;
-}
-
-double plm_get_time(plm_t *self) {
-	return self->time;
-}
-
-void plm_rewind(plm_t *self) {
-	plm_video_rewind(self->video_decoder);
-	plm_audio_rewind(self->audio_decoder);
-	plm_demux_rewind(self->demux);
-	self->time = 0;
-}
-
-int plm_get_loop(plm_t *self) {
-	return self->loop;
-}
-
-void plm_set_loop(plm_t *self, int loop) {
-	self->loop = loop;
-}
-
-int plm_has_ended(plm_t *self) {
-	return self->has_ended;
-}
-
-void plm_set_video_decode_callback(plm_t *self, plm_video_decode_callback fp, void *user) {
-	self->video_decode_callback = fp;
-	self->video_decode_callback_user_data = user;
-}
-
-void plm_set_audio_decode_callback(plm_t *self, plm_audio_decode_callback fp, void *user) {
-	self->audio_decode_callback = fp;
-	self->audio_decode_callback_user_data = user;
-}
-
-int plm_decode(plm_t *self, double tick) {
-	DEBUGF("%s", "plm_decode");
-
-	int decode_video = (self->video_decode_callback && self->video_packet_type);
-	int decode_audio = (self->audio_decode_callback && self->audio_packet_type);
-
-	if (!decode_video && !decode_audio) {
-		// Nothing to do here
-		return false;
-	}
-
-	int did_decode = false;
-	int video_ended = false;
-	int audio_ended = false;
-
-	double video_target_time = self->time + tick;
-	double audio_target_time = self->time + tick;
-
-	if (self->audio_lead_time > 0 && decode_audio) {
-		video_target_time -= self->audio_lead_time;
-	}
-	else {
-		audio_target_time -= self->audio_lead_time;
-	}
-
-	do {
-		did_decode = false;
-
-		if (decode_video &&	plm_video_get_time(self->video_decoder) < video_target_time) {
-			plm_frame_t *frame = plm_video_decode(self->video_decoder);
-			if (frame) {
-				self->video_decode_callback(self, frame, self->video_decode_callback_user_data);
-				did_decode = true;
-			}
-			else {
-				video_ended = true;
-			}
-		}
-
-		if (decode_audio && plm_audio_get_time(self->audio_decoder) < audio_target_time) {
-			plm_samples_t *samples = plm_audio_decode(self->audio_decoder);
-			if (samples) {
-				self->audio_decode_callback(self, samples, self->audio_decode_callback_user_data);
-				did_decode = true;
-			}
-			else {
-				audio_ended = true;
-			}
-		}
-	} while (did_decode);
-
-	// We wanted to decode something but failed -> the source must have ended
-	if ((!decode_video || video_ended) && (!decode_audio || audio_ended)) {
-		plm_handle_end(self);
-	}
-	else {
-		self->time += tick;
-	}
-
-	return did_decode ? true : false;
-}
-
-plm_frame_t *plm_decode_video(plm_t *self) {
-	if (!self->video_packet_type) {
-		return NULL;
-	}
-
-	plm_frame_t *frame = plm_video_decode(self->video_decoder);
-	if (frame) {
-		self->time = frame->time;
-	}
-	else {
-		plm_handle_end(self);
-	}
-	return frame;
-}
-
-plm_samples_t *plm_decode_audio(plm_t *self) {
-	if (!self->audio_packet_type) {
-		return NULL;
-	}
-
-	plm_samples_t *samples = plm_audio_decode(self->audio_decoder);
-	if (samples) {
-		self->time = samples->time;
-	}
-	else {
-		plm_handle_end(self);
-	}
-	return samples;
-}
-
-void plm_handle_end(plm_t *self) {
-	if (self->loop) {
-		plm_rewind(self);
-	}
-	else {
-		self->has_ended = true;
-	}
-}
-
-void plm_read_video_packet(plm_buffer_t *buffer, void *user) {
-	plm_t *self = (plm_t *)user;
-	plm_read_packets(self, self->video_packet_type);
-}
-
-void plm_read_audio_packet(plm_buffer_t *buffer, void *user) {
-	plm_t *self = (plm_t *)user;
-	plm_read_packets(self, self->audio_packet_type);
-}
-
-void plm_read_packets(plm_t *self, int requested_type) {
-	plm_packet_t *packet;
-	while ((packet = plm_demux_decode(self->demux))) {
-		if (packet->type == self->video_packet_type) {
-			plm_buffer_write(self->video_buffer, packet->data, packet->length);
-		}
-		else if (packet->type == self->audio_packet_type) {
-			plm_buffer_write(self->audio_buffer, packet->data, packet->length);
-		}
-		if (packet->type == requested_type) {
-			return;
-		}
-	}
-}
diff --git a/dsp/mpeg/slowrgb.c b/dsp/mpeg/slowrgb.c
deleted file mode 100644
index 7472d82f3..000000000
--- a/dsp/mpeg/slowrgb.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:4;tab-width:4;coding:utf-8   -*-│
-│ vi: set et ft=c ts=4 sw=4 fenc=utf-8                                     :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│  PL_MPEG - MPEG1 Video decoder, MP2 Audio decoder, MPEG-PS demuxer           │
-│  Dominic Szablewski - https://phoboslab.org                                  │
-│                                                                              │
-│  The MIT License(MIT)                                                        │
-│  Copyright(c) 2019 Dominic Szablewski                                        │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files(the              │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and / or sell copies of the Software, and to        │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│    The above copyright notice and this permission notice shall be            │
-│    included in all copies or substantial portions of the Software.           │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND                       │
-│  NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE       │
-│  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN             │
-│  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN           │
-│  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE            │
-│  SOFTWARE.                                                                   │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/mpeg.h"
-#include "libc/macros.internal.h"
-__static_yoink("pl_mpeg_notice");
-
-/**
- * @see YCbCr2RGB() in tool/viz/lib/ycbcr2rgb.c
- */
-void plm_frame_to_rgb(plm_frame_t *frame, uint8_t *rgb) {
-  // Chroma values are the same for each block of 4 pixels, so we process
-  // 2 lines at a time, 2 neighboring pixels each.
-  int w = frame->y.width, w2 = w >> 1;
-  int y_index1 = 0, y_index2 = w, y_next_2_lines = w + (w - frame->width);
-  int c_index = 0, c_next_line = w2 - (frame->width >> 1);
-  int rgb_index1 = 0, rgb_index2 = frame->width * 3,
-      rgb_next_2_lines = frame->width * 3;
-  int cols = frame->width >> 1, rows = frame->height >> 1;
-  int ccb, ccr, r, g, b;
-  uint8_t *y = frame->y.data, *cb = frame->cb.data, *cr = frame->cr.data;
-  for (int row = 0; row < rows; row++) {
-    for (int col = 0; col < cols; col++) {
-      ccb = cb[c_index];
-      ccr = cr[c_index];
-      c_index++;
-      r = (ccr + ((ccr * 103) >> 8)) - 179;
-      g = ((ccb * 88) >> 8) - 44 + ((ccr * 183) >> 8) - 91;
-      b = (ccb + ((ccb * 198) >> 8)) - 227;
-      // Line 1
-      int y1 = y[y_index1++];
-      int y2 = y[y_index1++];
-      rgb[rgb_index1 + 0] = MAX(0, MIN(255, y1 + r));
-      rgb[rgb_index1 + 1] = MAX(0, MIN(255, y1 - g));
-      rgb[rgb_index1 + 2] = MAX(0, MIN(255, y1 + b));
-      rgb[rgb_index1 + 3] = MAX(0, MIN(255, y2 + r));
-      rgb[rgb_index1 + 4] = MAX(0, MIN(255, y2 - g));
-      rgb[rgb_index1 + 5] = MAX(0, MIN(255, y2 + b));
-      rgb_index1 += 6;
-      // Line 2
-      int y3 = y[y_index2++];
-      int y4 = y[y_index2++];
-      rgb[rgb_index2 + 0] = MAX(0, MIN(255, y3 + r));
-      rgb[rgb_index2 + 1] = MAX(0, MIN(255, y3 - g));
-      rgb[rgb_index2 + 2] = MAX(0, MIN(255, y3 + b));
-      rgb[rgb_index2 + 3] = MAX(0, MIN(255, y4 + r));
-      rgb[rgb_index2 + 4] = MAX(0, MIN(255, y4 - g));
-      rgb[rgb_index2 + 5] = MAX(0, MIN(255, y4 + b));
-      rgb_index2 += 6;
-    }
-    y_index1 += y_next_2_lines;
-    y_index2 += y_next_2_lines;
-    rgb_index1 += rgb_next_2_lines;
-    rgb_index2 += rgb_next_2_lines;
-    c_index += c_next_line;
-  }
-}
diff --git a/dsp/mpeg/video.h b/dsp/mpeg/video.h
deleted file mode 100644
index 570ee94ea..000000000
--- a/dsp/mpeg/video.h
+++ /dev/null
@@ -1,60 +0,0 @@
-#ifndef COSMOPOLITAN_DSP_MPEG_VIDEO_H_
-#define COSMOPOLITAN_DSP_MPEG_VIDEO_H_
-#include "dsp/mpeg/mpeg.h"
-COSMOPOLITAN_C_START_
-
-typedef struct {
-  int full_px;
-  int is_set;
-  int r_size;
-  int h;
-  int v;
-} plm_video_motion_t;
-
-typedef struct plm_video_t {
-  double framerate;
-  double time;
-  double pixel_aspect_ratio;
-  int frames_decoded;
-  int width;
-  int height;
-  int mb_width;
-  int mb_height;
-  int mb_size;
-  int luma_width;
-  int luma_height;
-  int chroma_width;
-  int chroma_height;
-  int start_code;
-  int picture_type;
-  plm_video_motion_t motion_forward;
-  plm_video_motion_t motion_backward;
-  int has_sequence_header;
-  int quantizer_scale;
-  int slice_begin;
-  int macroblock_address;
-  int mb_row;
-  int mb_col;
-  int macroblock_type;
-  int macroblock_intra;
-  int dc_predictor[3];
-  plm_buffer_t *buffer;
-  int destroy_buffer_when_done;
-  plm_frame_t frame_current;
-  plm_frame_t frame_forward;
-  plm_frame_t frame_backward;
-  uint8_t *frames_data;
-  int block_data[64];
-  uint8_t intra_quant_matrix[64];
-  uint8_t non_intra_quant_matrix[64];
-  int has_reference_frame;
-  int assume_no_b_frames;
-} plm_video_t;
-
-void plm_video_process_macroblock_8(plm_video_t *, uint8_t *restrict,
-                                    uint8_t *restrict, int, int, bool);
-void plm_video_process_macroblock_16(plm_video_t *, uint8_t *restrict,
-                                     uint8_t *restrict, int, int, bool);
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_DSP_MPEG_VIDEO_H_ */
diff --git a/dsp/prog/BUILD.mk b/dsp/prog/BUILD.mk
new file mode 100644
index 000000000..adc0668ee
--- /dev/null
+++ b/dsp/prog/BUILD.mk
@@ -0,0 +1,43 @@
+#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
+#── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
+
+PKGS += DSP_PROG
+
+DSP_PROG_FILES := $(wildcard dsp/prog/*)
+DSP_PROG_HDRS = $(filter %.h,$(DSP_PROG_FILES))
+DSP_PROG_SRCS = $(filter %.c,$(DSP_PROG_FILES))
+DSP_PROG_OBJS = $(DSP_PROG_SRCS:%.c=o/$(MODE)/%.o)
+DSP_PROG_COMS = $(DSP_PROG_SRCS:%.c=o/$(MODE)/%)
+DSP_PROG_BINS = $(DSP_PROG_COMS) $(DSP_PROG_COMS:%=%.dbg)
+
+DSP_PROG_DIRECTDEPS =				\
+	DSP_AUDIO				\
+	LIBC_CALLS				\
+	LIBC_INTRIN				\
+	LIBC_NEXGEN32E				\
+	LIBC_RUNTIME				\
+	LIBC_SOCK				\
+	LIBC_STDIO				\
+	LIBC_SYSV				\
+	LIBC_TINYMATH				\
+	THIRD_PARTY_MUSL			\
+
+DSP_PROG_DEPS :=				\
+	$(call uniq,$(foreach x,$(DSP_PROG_DIRECTDEPS),$($(x))))
+
+o/$(MODE)/dsp/prog/prog.pkg:			\
+		$(DSP_PROG_OBJS)		\
+		$(foreach x,$(DSP_PROG_DIRECTDEPS),$($(x)_A).pkg)
+
+o/$(MODE)/dsp/prog/%.dbg:			\
+		$(DSP_PROG_DEPS)		\
+		o/$(MODE)/dsp/prog/prog.pkg	\
+		o/$(MODE)/dsp/prog/%.o		\
+		$(CRT)				\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
+$(DSP_PROG_OBJS): dsp/prog/BUILD.mk
+
+.PHONY: o/$(MODE)/dsp/prog
+o/$(MODE)/dsp/prog: $(DSP_PROG_BINS)
diff --git a/dsp/prog/loudness.h b/dsp/prog/loudness.h
new file mode 100644
index 000000000..75a1e9518
--- /dev/null
+++ b/dsp/prog/loudness.h
@@ -0,0 +1,41 @@
+#ifndef COSMOPOLITAN_DSP_PROG_LOUDNESS_H_
+#define COSMOPOLITAN_DSP_PROG_LOUDNESS_H_
+#include <math.h>
+#include <stdio.h>
+
+#define MIN_DECIBEL -60
+#define MAX_DECIBEL 0
+
+// computes root of mean squares
+static double rms(float *p, int n) {
+  double s = 0;
+  for (int i = 0; i < n; ++i)
+    s += p[i] * p[i];
+  return sqrt(s / n);
+}
+
+// converts rms to decibel
+static double rms_to_db(double rms) {
+  double db = 20 * log10(rms);
+  db = fmin(db, MAX_DECIBEL);
+  db = fmax(db, MIN_DECIBEL);
+  return db;
+}
+
+// char meter[21];
+// format_decibel_meter(meter, 20, rms_to_db(rms(samps, count)))
+static char *format_decibel_meter(char *meter, int width, double db) {
+  double range = MAX_DECIBEL - MIN_DECIBEL;
+  int filled = (db - MIN_DECIBEL) / range * width;
+  for (int i = 0; i < width; ++i) {
+    if (i < filled) {
+      meter[i] = '=';
+    } else {
+      meter[i] = ' ';
+    }
+  }
+  meter[width] = 0;
+  return meter;
+}
+
+#endif /* COSMOPOLITAN_DSP_PROG_LOUDNESS_H_ */
diff --git a/dsp/prog/recvaudio.c b/dsp/prog/recvaudio.c
new file mode 100644
index 000000000..85ef98ed8
--- /dev/null
+++ b/dsp/prog/recvaudio.c
@@ -0,0 +1,127 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include <arpa/inet.h>
+#include <assert.h>
+#include <cosmoaudio.h>
+#include <errno.h>
+#include <math.h>
+#include <netinet/in.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <time.h>
+#include "loudness.h"
+
+/**
+ * @fileoverview plays audio from remote computer on speaker
+ * @see dsp/prog/sendaudio.c
+ */
+
+#define SAMPLING_RATE     44100
+#define FRAMES_PER_SECOND 60
+#define DEBUG_LOG         0
+#define PORT              9834
+
+#define CHUNK_FRAMES (SAMPLING_RATE / FRAMES_PER_SECOND)
+
+static_assert(CHUNK_FRAMES * sizeof(short) < 1472,
+              "audio chunks won't fit in udp ethernet packet");
+
+sig_atomic_t g_done;
+
+void onsig(int sig) {
+  g_done = 1;
+}
+
+short toshort(float x) {
+  return fmaxf(-1, fminf(1, x)) * 32767;
+}
+
+float tofloat(short x) {
+  return x / 32768.f;
+}
+
+int main(int argc, char* argv[]) {
+
+  // listen on udp port for audio
+  int server;
+  if ((server = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
+    perror("socket");
+    return 3;
+  }
+  struct sockaddr_in addr = {.sin_family = AF_INET, .sin_port = htons(PORT)};
+  if (bind(server, (struct sockaddr*)&addr, sizeof(addr))) {
+    perror("bind");
+    return 4;
+  }
+
+  // setup signals
+  struct sigaction sa;
+  sa.sa_flags = 0;
+  sa.sa_handler = onsig;
+  sigemptyset(&sa.sa_mask);
+  sigaction(SIGINT, &sa, 0);
+
+  // configure cosmo audio
+  struct CosmoAudioOpenOptions cao = {0};
+  cao.sizeofThis = sizeof(struct CosmoAudioOpenOptions);
+  cao.deviceType = kCosmoAudioDeviceTypePlayback;
+  cao.sampleRate = SAMPLING_RATE;
+  cao.bufferFrames = CHUNK_FRAMES * 2;
+  cao.debugLog = DEBUG_LOG;
+  cao.channels = 1;
+
+  // connect to microphone and speaker
+  int status;
+  struct CosmoAudio* ca;
+  status = cosmoaudio_open(&ca, &cao);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to open audio: %d\n", status);
+    return 5;
+  }
+
+  while (!g_done) {
+    // read from network
+    ssize_t got;
+    short buf16[CHUNK_FRAMES];
+    if ((got = read(server, buf16, CHUNK_FRAMES * sizeof(short))) == -1) {
+      if (errno == EINTR)
+        continue;
+      perror("read");
+      return 7;
+    }
+    if (got != CHUNK_FRAMES * sizeof(short)) {
+      fprintf(stderr, "warning: got partial audio frame\n");
+      continue;
+    }
+
+    // write to speaker
+    float buf32[CHUNK_FRAMES];
+    for (int i = 0; i < CHUNK_FRAMES; ++i)
+      buf32[i] = tofloat(buf16[i]);
+    cosmoaudio_poll(ca, 0, (int[]){CHUNK_FRAMES});
+    cosmoaudio_write(ca, buf32, CHUNK_FRAMES);
+
+    // print loudness in ascii
+    char meter[21];
+    double db = rms_to_db(rms(buf32, CHUNK_FRAMES));
+    format_decibel_meter(meter, 20, db);
+    printf("\r%s| %+6.2f dB", meter, db);
+    fflush(stdout);
+  }
+
+  // clean up resources
+  cosmoaudio_flush(ca);
+  cosmoaudio_close(ca);
+  close(server);
+}
diff --git a/dsp/prog/sendaudio.c b/dsp/prog/sendaudio.c
new file mode 100644
index 000000000..436bbfcdb
--- /dev/null
+++ b/dsp/prog/sendaudio.c
@@ -0,0 +1,149 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include <arpa/inet.h>
+#include <assert.h>
+#include <cosmoaudio.h>
+#include <errno.h>
+#include <math.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <time.h>
+#include "loudness.h"
+
+/**
+ * @fileoverview sends audio from microphone to remote computer
+ * @see dsp/prog/recvaudio.c
+ */
+
+#define SAMPLING_RATE     44100
+#define FRAMES_PER_SECOND 60
+#define DEBUG_LOG         0
+#define PORT              9834
+
+#define CHUNK_FRAMES (SAMPLING_RATE / FRAMES_PER_SECOND)
+
+static_assert(CHUNK_FRAMES * sizeof(short) < 1472,
+              "audio chunks won't fit in udp ethernet packet");
+
+sig_atomic_t g_done;
+
+void onsig(int sig) {
+  g_done = 1;
+}
+
+short toshort(float x) {
+  return fmaxf(-1, fminf(1, x)) * 32767;
+}
+
+float tofloat(short x) {
+  return x / 32768.f;
+}
+
+uint32_t host2ip(const char* host) {
+  uint32_t ip;
+  if ((ip = inet_addr(host)) != -1u)
+    return ip;
+  int rc;
+  struct addrinfo* ai = NULL;
+  struct addrinfo hint = {AI_NUMERICSERV, AF_INET, SOCK_STREAM, IPPROTO_TCP};
+  if ((rc = getaddrinfo(host, "0", &hint, &ai))) {
+    fprintf(stderr, "%s: %s\n", host, gai_strerror(rc));
+    exit(50 + rc);
+  }
+  ip = ntohl(((struct sockaddr_in*)ai->ai_addr)->sin_addr.s_addr);
+  freeaddrinfo(ai);
+  return ip;
+}
+
+int main(int argc, char* argv[]) {
+
+  if (argc != 2) {
+    fprintf(stderr, "%s: missing host argument\n", argv[0]);
+    return 1;
+  }
+
+  // get host argument
+  const char* remote_host = argv[1];
+  uint32_t ip = host2ip(remote_host);
+
+  // connect to server
+  int client;
+  if ((client = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
+    perror(remote_host);
+    return 3;
+  }
+  struct sockaddr_in addr = {.sin_family = AF_INET,
+                             .sin_port = htons(PORT),
+                             .sin_addr.s_addr = htonl(ip)};
+  if (connect(client, (struct sockaddr*)&addr, sizeof(addr))) {
+    perror(remote_host);
+    return 4;
+  }
+
+  // setup signals
+  struct sigaction sa;
+  sa.sa_flags = 0;
+  sa.sa_handler = onsig;
+  sigemptyset(&sa.sa_mask);
+  sigaction(SIGINT, &sa, 0);
+
+  // configure cosmo audio
+  struct CosmoAudioOpenOptions cao = {0};
+  cao.sizeofThis = sizeof(struct CosmoAudioOpenOptions);
+  cao.deviceType = kCosmoAudioDeviceTypeCapture;
+  cao.sampleRate = SAMPLING_RATE;
+  cao.bufferFrames = CHUNK_FRAMES * 2;
+  cao.debugLog = DEBUG_LOG;
+  cao.channels = 1;
+
+  // connect to microphone and speaker
+  int status;
+  struct CosmoAudio* ca;
+  status = cosmoaudio_open(&ca, &cao);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to open audio: %d\n", status);
+    return 5;
+  }
+
+  while (!g_done) {
+    // read from microphone
+    float buf32[CHUNK_FRAMES];
+    cosmoaudio_poll(ca, (int[]){CHUNK_FRAMES}, 0);
+    cosmoaudio_read(ca, buf32, CHUNK_FRAMES);
+    short buf16[CHUNK_FRAMES];
+    for (int i = 0; i < CHUNK_FRAMES; ++i)
+      buf16[i] = toshort(buf32[i]);
+
+    // send to server
+    if (write(client, buf16, CHUNK_FRAMES * sizeof(short)) == -1) {
+      if (errno == EINTR && g_done)
+        break;
+      perror(remote_host);
+      return 7;
+    }
+
+    // print loudness in ascii
+    char meter[21];
+    double db = rms_to_db(rms(buf32, CHUNK_FRAMES));
+    format_decibel_meter(meter, 20, db);
+    printf("\r%s| %+6.2f dB", meter, db);
+    fflush(stdout);
+  }
+
+  // clean up resources
+  cosmoaudio_close(ca);
+  close(client);
+}
diff --git a/dsp/scale/BUILD.mk b/dsp/scale/BUILD.mk
index bd4f6df7e..80397cd97 100644
--- a/dsp/scale/BUILD.mk
+++ b/dsp/scale/BUILD.mk
@@ -45,6 +45,12 @@ $(DSP_SCALE_A).pkg:				\
 		$(DSP_SCALE_A_OBJS)		\
 		$(foreach x,$(DSP_SCALE_A_DIRECTDEPS),$($(x)_A).pkg)
 
+ifeq ($(ARCH),x86_64)
+o/$(MODE)/dsp/scale/cdecimate2xuint8x8.o: private \
+		CFLAGS +=			\
+			-mssse3
+endif
+
 o/$(MODE)/dsp/scale/cdecimate2xuint8x8.o	\
 o/$(MODE)/dsp/scale/gyarados.o			\
 o/$(MODE)/dsp/scale/magikarp.o			\
diff --git a/dsp/scale/cdecimate2xuint8x8.c b/dsp/scale/cdecimate2xuint8x8.c
index 4a7e8a084..2a96284d9 100644
--- a/dsp/scale/cdecimate2xuint8x8.c
+++ b/dsp/scale/cdecimate2xuint8x8.c
@@ -16,17 +16,20 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/intrin/packuswb.h"
-#include "libc/intrin/paddw.h"
-#include "libc/intrin/palignr.h"
-#include "libc/intrin/pmaddubsw.h"
-#include "libc/intrin/psraw.h"
-#include "libc/log/check.h"
-#include "libc/log/log.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/str/str.h"
+#include "third_party/intel/immintrin.internal.h"
 
+/**
+ * Performs 2D Motion Picture Convolution Acceleration by Leveraging SSSE3.
+ *
+ * @note H/T John Costella, Jean-Baptiste Joseph Fourier
+ * @note RIP Huixiang Chen
+ */
+void *cDecimate2xUint8x8(unsigned long n, unsigned char A[n],
+                         const signed char K[8]) {
+#ifdef __x86_64__
 #define TAPS       8
 #define RATIO      2
 #define OFFSET     3
@@ -37,62 +40,107 @@
 #define LOOKAHEAD  (SPREAD - LOOKBEHIND)
 #define SCALE      5
 #define ROUND      (1 << (SCALE - 1))
-
-/**
- * Performs 2D Motion Picture Convolution Acceleration by Leveraging SSSE3.
- *
- * @note H/T John Costella, Jean-Baptiste Joseph Fourier
- * @note RIP Huixiang Chen
- */
-void *cDecimate2xUint8x8(unsigned long n, unsigned char A[n],
-                         const signed char K[8]) {
-  short kRound[8] = {ROUND, ROUND, ROUND, ROUND, ROUND, ROUND, ROUND, ROUND};
-  signed char kMadd1[16] = {K[0], K[1], K[0], K[1], K[0], K[1], K[0], K[1],
-                            K[0], K[1], K[0], K[1], K[0], K[1], K[0], K[1]};
-  signed char kMadd2[16] = {K[2], K[3], K[2], K[3], K[2], K[3], K[2], K[3],
-                            K[2], K[3], K[2], K[3], K[2], K[3], K[2], K[3]};
-  signed char kMadd3[16] = {K[4], K[5], K[4], K[5], K[4], K[5], K[4], K[5],
-                            K[4], K[5], K[4], K[5], K[4], K[5], K[4], K[5]};
-  signed char kMadd4[16] = {K[6], K[7], K[6], K[7], K[6], K[7], K[6], K[7],
-                            K[6], K[7], K[6], K[7], K[6], K[7], K[6], K[7]};
-  unsigned char bv0[16], bv1[16], bv2[16], bv3[16];
-  unsigned char in1[16], in2[16], in3[16];
-  short wv0[8], wv1[8], wv2[8], wv3[8];
+  __m128i kRound = _mm_set1_epi16(ROUND);
+  __m128i kMadd1 = _mm_set_epi8(K[1], K[0], K[1], K[0], K[1], K[0], K[1], K[0],
+                                K[1], K[0], K[1], K[0], K[1], K[0], K[1], K[0]);
+  __m128i kMadd2 = _mm_set_epi8(K[3], K[2], K[3], K[2], K[3], K[2], K[3], K[2],
+                                K[3], K[2], K[3], K[2], K[3], K[2], K[3], K[2]);
+  __m128i kMadd3 = _mm_set_epi8(K[5], K[4], K[5], K[4], K[5], K[4], K[5], K[4],
+                                K[5], K[4], K[5], K[4], K[5], K[4], K[5], K[4]);
+  __m128i kMadd4 = _mm_set_epi8(K[7], K[6], K[7], K[6], K[7], K[6], K[7], K[6],
+                                K[7], K[6], K[7], K[6], K[7], K[6], K[7], K[6]);
+  __m128i bv0, bv1, bv2, bv3;
+  __m128i in1, in2, in3;
+  __m128i wv0, wv1, wv2, wv3;
   unsigned long i, j, w;
   if (n >= STRIDE) {
     i = 0;
     w = (n + RATIO / 2) / RATIO;
-    memset(in1, A[0], sizeof(in1));
-    memset(in2, A[n - 1], 16);
-    memcpy(in2, A, MIN(16, n));
+    in1 = _mm_set1_epi8(A[0]);
+    in2 = _mm_set1_epi8(A[n - 1]);
+    _mm_storeu_si128((__m128i *)&in2, _mm_loadu_si128((__m128i *)A));
     for (; i < w; i += STRIDE) {
       j = i * RATIO + 16;
       if (j + 16 <= n) {
-        memcpy(in3, &A[j], 16);
+        in3 = _mm_loadu_si128((__m128i *)&A[j]);
       } else {
-        memset(in3, A[n - 1], 16);
+        in3 = _mm_set1_epi8(A[n - 1]);
         if (j < n) {
-          memcpy(in3, &A[j], n - j);
+          // SSSE3-compatible way to handle partial loads
+          __m128i mask = _mm_loadu_si128((__m128i *)&A[j]);
+          __m128i shuffle_mask = _mm_set_epi8(15, 14, 13, 12, 11, 10, 9, 8, 7,
+                                              6, 5, 4, 3, 2, 1, 0);
+          __m128i index = _mm_set1_epi8(n - j);
+          __m128i cmp = _mm_cmplt_epi8(shuffle_mask, index);
+          in3 = _mm_or_si128(_mm_and_si128(cmp, mask),
+                             _mm_andnot_si128(cmp, in3));
         }
       }
-      palignr(bv0, in2, in1, 13);
-      palignr(bv1, in2, in1, 15);
-      palignr(bv2, in3, in2, 1);
-      palignr(bv3, in3, in2, 3);
-      pmaddubsw(wv0, bv0, kMadd1);
-      pmaddubsw(wv1, bv1, kMadd2);
-      pmaddubsw(wv2, bv2, kMadd3);
-      pmaddubsw(wv3, bv3, kMadd4);
-      paddw(wv0, wv0, kRound);
-      paddw(wv0, wv0, wv1);
-      paddw(wv0, wv0, wv2);
-      paddw(wv0, wv0, wv3);
-      psraw(wv0, wv0, SCALE);
-      packuswb(bv2, wv0, wv0);
-      memcpy(&A[i], bv2, STRIDE);
-      memcpy(in1, in2, 16);
-      memcpy(in2, in3, 16);
+      bv0 = _mm_alignr_epi8(in2, in1, 13);
+      bv1 = _mm_alignr_epi8(in2, in1, 15);
+      bv2 = _mm_alignr_epi8(in3, in2, 1);
+      bv3 = _mm_alignr_epi8(in3, in2, 3);
+      wv0 = _mm_maddubs_epi16(bv0, kMadd1);
+      wv1 = _mm_maddubs_epi16(bv1, kMadd2);
+      wv2 = _mm_maddubs_epi16(bv2, kMadd3);
+      wv3 = _mm_maddubs_epi16(bv3, kMadd4);
+      wv0 = _mm_add_epi16(wv0, kRound);
+      wv0 = _mm_add_epi16(wv0, wv1);
+      wv0 = _mm_add_epi16(wv0, wv2);
+      wv0 = _mm_add_epi16(wv0, wv3);
+      wv0 = _mm_srai_epi16(wv0, SCALE);
+      bv2 = _mm_packus_epi16(wv0, wv0);
+      _mm_storel_epi64((__m128i *)&A[i], bv2);
+      in1 = in2;
+      in2 = in3;
     }
   }
   return A;
+#else
+  long h, i;
+  if (n < 2)
+    return A;
+  unsigned char M[3 + n + 4];
+  unsigned char *q = M;
+  q[0] = A[0];
+  q[1] = A[0];
+  q[2] = A[0];
+  memcpy(q + 3, A, n);
+  q[3 + n + 0] = A[n - 1];
+  q[3 + n + 1] = A[n - 1];
+  q[3 + n + 2] = A[n - 1];
+  q[3 + n + 3] = A[n - 1];
+  q += 3;
+  h = (n + 1) >> 1;
+  for (i = 0; i < h; ++i) {
+    short x0, x1, x2, x3, x4, x5, x6, x7;
+    x0 = q[i * 2 - 3];
+    x1 = q[i * 2 - 2];
+    x2 = q[i * 2 - 1];
+    x3 = q[i * 2 + 0];
+    x4 = q[i * 2 + 1];
+    x5 = q[i * 2 + 2];
+    x6 = q[i * 2 + 3];
+    x7 = q[i * 2 + 4];
+    x0 *= K[0];
+    x1 *= K[1];
+    x2 *= K[2];
+    x3 *= K[3];
+    x4 *= K[4];
+    x5 *= K[5];
+    x6 *= K[6];
+    x7 *= K[7];
+    x0 += x1;
+    x2 += x3;
+    x4 += x5;
+    x6 += x7;
+    x0 += x2;
+    x4 += x6;
+    x0 += x4;
+    x0 += 1 << 4;
+    x0 >>= 5;
+    A[i] = MIN(255, MAX(0, x0));
+  }
+  return A;
+#endif
 }
diff --git a/dsp/scale/gyarados.c b/dsp/scale/gyarados.c
index 4487b3d79..0785bbb0e 100644
--- a/dsp/scale/gyarados.c
+++ b/dsp/scale/gyarados.c
@@ -25,7 +25,7 @@
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
@@ -149,12 +149,11 @@ static int Sharpen(int ax, int bx, int cx) {
 
 static void GyaradosImpl(long dyw, long dxw, int dst[dyw][dxw], long syw,
                          long sxw, const int src[syw][sxw], long dyn, long dxn,
-                         long syn, long sxn, int tmp0[restrict dyn][sxn],
-                         int tmp1[restrict dyn][sxn],
-                         int tmp2[restrict dyn][dxn], long yfn, long xfn,
-                         const short fyi[dyn][yfn], const short fyw[dyn][yfn],
-                         const short fxi[dxn][xfn], const short fxw[dxn][xfn],
-                         bool sharpen) {
+                         long syn, long sxn, int tmp0[dyn][sxn],
+                         int tmp1[dyn][sxn], int tmp2[dyn][dxn], long yfn,
+                         long xfn, const short fyi[dyn][yfn],
+                         const short fyw[dyn][yfn], const short fxi[dxn][xfn],
+                         const short fxw[dxn][xfn], bool sharpen) {
   long i;
   int eax, dy, dx, sx;
   for (sx = 0; sx < sxn; ++sx) {
@@ -165,12 +164,19 @@ static void GyaradosImpl(long dyw, long dxw, int dst[dyw][dxw], long syw,
       tmp0[dy][sx] = QRS(M, eax);
     }
   }
-  for (dy = 0; dy < dyn; ++dy) {
-    for (sx = 0; sx < sxn; ++sx) {
-      tmp1[dy][sx] = sharpen ? Sharpen(tmp0[MIN(dyn - 1, MAX(0, dy - 1))][sx],
-                                       tmp0[dy][sx],
-                                       tmp0[MIN(dyn - 1, MAX(0, dy + 1))][sx])
-                             : tmp0[dy][sx];
+  if (sharpen) {
+    for (dy = 0; dy < dyn; ++dy) {
+      for (sx = 0; sx < sxn; ++sx) {
+        tmp1[dy][sx] =
+            Sharpen(tmp0[MIN(dyn - 1, MAX(0, dy - 1))][sx], tmp0[dy][sx],
+                    tmp0[MIN(dyn - 1, MAX(0, dy + 1))][sx]);
+      }
+    }
+  } else {
+    for (dy = 0; dy < dyn; ++dy) {
+      for (sx = 0; sx < sxn; ++sx) {
+        tmp1[dy][sx] = tmp0[dy][sx];
+      }
     }
   }
   for (dx = 0; dx < dxn; ++dx) {
@@ -181,12 +187,19 @@ static void GyaradosImpl(long dyw, long dxw, int dst[dyw][dxw], long syw,
       tmp2[dy][dx] = QRS(M, eax);
     }
   }
-  for (dx = 0; dx < dxn; ++dx) {
-    for (dy = 0; dy < dyn; ++dy) {
-      dst[dy][dx] = sharpen ? Sharpen(tmp2[dy][MIN(dxn - 1, MAX(0, dx - 1))],
-                                      tmp2[dy][dx],
-                                      tmp2[dy][MIN(dxn - 1, MAX(0, dx + 1))])
-                            : tmp2[dy][dx];
+  if (sharpen) {
+    for (dx = 0; dx < dxn; ++dx) {
+      for (dy = 0; dy < dyn; ++dy) {
+        dst[dy][dx] =
+            Sharpen(tmp2[dy][MIN(dxn - 1, MAX(0, dx - 1))], tmp2[dy][dx],
+                    tmp2[dy][MIN(dxn - 1, MAX(0, dx + 1))]);
+      }
+    }
+  } else {
+    for (dx = 0; dx < dxn; ++dx) {
+      for (dy = 0; dy < dyn; ++dy) {
+        dst[dy][dx] = tmp2[dy][dx];
+      }
     }
   }
 }
diff --git a/dsp/scale/magikarp.c b/dsp/scale/magikarp.c
index ea5aa7d55..f1f84b2ed 100644
--- a/dsp/scale/magikarp.c
+++ b/dsp/scale/magikarp.c
@@ -20,7 +20,7 @@
 #include "dsp/core/ks8.h"
 #include "dsp/core/kss8.h"
 #include "dsp/scale/cdecimate2xuint8x8.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/str/str.h"
 #include "libc/x/x.h"
@@ -106,9 +106,9 @@ void *Magkern2xY(long ys, long xs, unsigned char p[ys][xs], long yn, long xn) {
   return p;
 }
 
-void *MagikarpY(long dys, long dxs, unsigned char d[restrict dys][dxs],
-                long sys, long sxs, const unsigned char s[sys][sxs], long yn,
-                long xn, const signed char K[8]) {
+void *MagikarpY(long dys, long dxs, unsigned char d[dys][dxs], long sys,
+                long sxs, const unsigned char s[sys][sxs], long yn, long xn,
+                const signed char K[8]) {
   long y, x;
   for (y = 0; y < yn; ++y) {
     for (x = 0; x < xn; ++x) {
diff --git a/dsp/tty/ident.c b/dsp/tty/ident.c
index 9e28c817d..da830cab7 100644
--- a/dsp/tty/ident.c
+++ b/dsp/tty/ident.c
@@ -21,7 +21,7 @@
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/intrin/weaken.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/dsp/tty/mpsadbw.S b/dsp/tty/mpsadbw.S
index 833824ea4..165e17edd 100644
--- a/dsp/tty/mpsadbw.S
+++ b/dsp/tty/mpsadbw.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	TODO(jart): write me
 
diff --git a/dsp/tty/rgb2ansi.c b/dsp/tty/rgb2ansi.c
index baece9e8a..4ae5c54fa 100644
--- a/dsp/tty/rgb2ansi.c
+++ b/dsp/tty/rgb2ansi.c
@@ -21,7 +21,7 @@
 #include "libc/assert.h"
 #include "libc/limits.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/str/str.h"
 
diff --git a/dsp/tty/rgb2ttyi2f.c b/dsp/tty/rgb2ttyi2f.c
index e323c57f2..55472a40a 100644
--- a/dsp/tty/rgb2ttyi2f.c
+++ b/dsp/tty/rgb2ttyi2f.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/quant.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 struct TtyRgb rgb2ttyi2f_(int r, int g, int b) {
   return rgb2ttyf((ttyrgb_m128){r, g, b} / 255);
diff --git a/dsp/tty/rgb2xterm24.c b/dsp/tty/rgb2xterm24.c
index afbb6e9f5..166412a32 100644
--- a/dsp/tty/rgb2xterm24.c
+++ b/dsp/tty/rgb2xterm24.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/quant.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 struct TtyRgb rgb2xterm24_(int r, int g, int b) {
   return (struct TtyRgb){MAX(MIN(r, 255), 0), MAX(MIN(g, 255), 0),
diff --git a/dsp/tty/rgb2xterm24f.c b/dsp/tty/rgb2xterm24f.c
index 5a3b59594..6cad0f3cc 100644
--- a/dsp/tty/rgb2xterm24f.c
+++ b/dsp/tty/rgb2xterm24f.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/quant.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "third_party/intel/xmmintrin.internal.h"
 
diff --git a/dsp/tty/ttymove.c b/dsp/tty/ttymove.c
index 48d6696e4..838259f7e 100644
--- a/dsp/tty/ttymove.c
+++ b/dsp/tty/ttymove.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/itoa8.h"
 #include "dsp/tty/tty.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 
diff --git a/dsp/tty/ttyraster.c b/dsp/tty/ttyraster.c
index 1ced9e374..3bdb5ae97 100644
--- a/dsp/tty/ttyraster.c
+++ b/dsp/tty/ttyraster.c
@@ -22,11 +22,11 @@
 #include "dsp/tty/ttyrgb.h"
 #include "dsp/tty/windex.h"
 #include "libc/assert.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/runtime/runtime.h"
diff --git a/dsp/tty/ttyraw.c b/dsp/tty/ttyraw.c
index 333c641f0..bfb03f84f 100644
--- a/dsp/tty/ttyraw.c
+++ b/dsp/tty/ttyraw.c
@@ -24,7 +24,7 @@
 #include "libc/calls/termios.h"
 #include "libc/calls/ucontext.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
diff --git a/dsp/tty/windex-avx2.S b/dsp/tty/windex-avx2.S
index 4ebf2931e..f106fab29 100644
--- a/dsp/tty/windex-avx2.S
+++ b/dsp/tty/windex-avx2.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Returns index of minimum uint16 in array.
 //
diff --git a/dsp/tty/windex-sse4.S b/dsp/tty/windex-sse4.S
index 0347cb763..40ef0d856 100644
--- a/dsp/tty/windex-sse4.S
+++ b/dsp/tty/windex-sse4.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Returns index of minimum positive int16 in array.
 //
diff --git a/examples/BUILD.mk b/examples/BUILD.mk
index 5ebceb991..3d50b5429 100644
--- a/examples/BUILD.mk
+++ b/examples/BUILD.mk
@@ -39,6 +39,8 @@ EXAMPLES_BINS =							\
 	$(EXAMPLES_COMS:%=%.dbg)
 
 EXAMPLES_DIRECTDEPS =						\
+	CTL							\
+	DSP_AUDIO						\
 	DSP_CORE						\
 	DSP_SCALE						\
 	DSP_TTY							\
@@ -53,6 +55,7 @@ EXAMPLES_DIRECTDEPS =						\
 	LIBC_NT_ADVAPI32					\
 	LIBC_NT_IPHLPAPI					\
 	LIBC_NT_KERNEL32					\
+	LIBC_NT_MEMORY						\
 	LIBC_NT_NTDLL						\
 	LIBC_NT_USER32						\
 	LIBC_NT_WS2_32						\
@@ -61,6 +64,7 @@ EXAMPLES_DIRECTDEPS =						\
 	LIBC_SOCK						\
 	LIBC_STDIO						\
 	LIBC_STR						\
+	LIBC_SYSTEM						\
 	LIBC_SYSV						\
 	LIBC_SYSV_CALLS						\
 	LIBC_TESTLIB						\
@@ -78,6 +82,8 @@ EXAMPLES_DIRECTDEPS =						\
 	THIRD_PARTY_GETOPT					\
 	THIRD_PARTY_HIREDIS					\
 	THIRD_PARTY_LIBCXX					\
+	THIRD_PARTY_LIBCXXABI					\
+	THIRD_PARTY_LIBUNWIND					\
 	THIRD_PARTY_LINENOISE					\
 	THIRD_PARTY_LUA						\
 	THIRD_PARTY_MBEDTLS					\
@@ -91,11 +97,10 @@ EXAMPLES_DIRECTDEPS =						\
 	THIRD_PARTY_TZ						\
 	THIRD_PARTY_VQSORT					\
 	THIRD_PARTY_XED						\
-	THIRD_PARTY_LIBCXXABI					\
 	THIRD_PARTY_ZLIB					\
 	TOOL_ARGS						\
 	TOOL_BUILD_LIB						\
-	TOOL_VIZ_LIB
+	TOOL_VIZ_LIB						\
 
 EXAMPLES_DEPS :=						\
 	$(call uniq,$(foreach x,$(EXAMPLES_DIRECTDEPS),$($(x))))
@@ -146,6 +151,10 @@ o/$(MODE)/examples/picol.o: private				\
 		CPPFLAGS +=					\
 			-DSTACK_FRAME_UNLIMITED
 
+o/$(MODE)/examples/nesemu1.o: private				\
+		CPPFLAGS +=					\
+			-O3
+
 o/$(MODE)/examples/picol.dbg:					\
 		$(EXAMPLES_DEPS)				\
 		o/$(MODE)/examples/picol.o			\
diff --git a/examples/a440.c b/examples/a440.c
new file mode 100644
index 000000000..3b927da7d
--- /dev/null
+++ b/examples/a440.c
@@ -0,0 +1,80 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include <cosmoaudio.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+/**
+ * @fileoverview plays pure A.440 tone on speakers for 1 second
+ * @see https://en.wikipedia.org/wiki/A440_%28pitch_standard%29
+ */
+
+#define SAMPLING_RATE 44100
+#define WAVE_INTERVAL 440
+#define CHANNELS      2
+#define LOUDNESS      .3
+#define DEBUG_LOG     1
+
+int main() {
+
+  struct CosmoAudioOpenOptions cao = {0};
+  cao.sizeofThis = sizeof(struct CosmoAudioOpenOptions);
+  cao.deviceType = kCosmoAudioDeviceTypePlayback;
+  cao.sampleRate = SAMPLING_RATE;
+  cao.debugLog = DEBUG_LOG;
+  cao.channels = CHANNELS;
+
+  int status;
+  struct CosmoAudio *ca;
+  status = cosmoaudio_open(&ca, &cao);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to open audio: %d\n", status);
+    return 1;
+  }
+
+  float buf[256 * CHANNELS];
+  for (int g = 0; g < SAMPLING_RATE;) {
+    int frames = 1;
+    status = cosmoaudio_poll(ca, NULL, &frames);
+    if (status != COSMOAUDIO_SUCCESS) {
+      fprintf(stderr, "failed to poll output: %d\n", status);
+      return 2;
+    }
+    if (frames > 256)
+      frames = 256;
+    if (frames > SAMPLING_RATE - g)
+      frames = SAMPLING_RATE - g;
+    for (int f = 0; f < frames; ++f) {
+      float t = (float)g++ / SAMPLING_RATE;
+      float s = sinf(2 * M_PIf * WAVE_INTERVAL * t);
+      for (int c = 0; c < CHANNELS; c++)
+        buf[f * CHANNELS + c] = s * LOUDNESS;
+    }
+    status = cosmoaudio_write(ca, buf, frames);
+    if (status != frames) {
+      fprintf(stderr, "failed to write output: %d\n", status);
+      return 3;
+    }
+  }
+
+  status = cosmoaudio_flush(ca);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to flush output: %d\n", status);
+    return 4;
+  }
+
+  status = cosmoaudio_close(ca);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to close audio: %d\n", status);
+    return 5;
+  }
+}
diff --git a/examples/aba.c b/examples/aba.c
new file mode 100644
index 000000000..b38b26028
--- /dev/null
+++ b/examples/aba.c
@@ -0,0 +1,125 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include <assert.h>
+#include <cosmo.h>
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// lockless push / pop tutorial
+//
+// this file demonstrates how to create a singly linked list that can be
+// pushed and popped across multiple threads, using only atomics. atomic
+// operations (rather than using a mutex) make push/pop go faster and it
+// ensures asynchronous signal safety too. therefore it will be safe for
+// use in a variety of contexts, such as signal handlers.
+
+#define THREADS    128
+#define ITERATIONS 10000
+
+// adjust mask based on alignment of list struct
+//
+// - 0x00fffffffffffff0 may be used if List* is always 16-byte aligned.
+//   We know that's the case here, because we call malloc() to create
+//   every List* object, and malloc() results are always max aligned.
+//
+// - 0x00fffffffffffff8 may be used if List* is always 8-byte aligned.
+//   This might be the case if you're pushing and popping stuff that was
+//   allocated from an array, to avoid malloc() calls. This has one
+//   fewer byte of safeguards against the ABA problem though.
+//
+// - 0x00fffffffffff000 may be used if List* is always page aligned.
+//   This is a good choice if you use mmap() to allocate each List*
+//   element, since it offers maximum protection against ABA.
+//
+// - only the highest byte of a 64-bit pointer is safe to use on our
+//   supported platforms. on most x86 and arm systems, it's possible to
+//   use the top sixteen bits. however that's not the case on more
+//   recent high end x86-64 systems that have pml5t.
+//
+#define MASQUE 0x00fffffffffffff0
+
+#define PTR(x)    ((uintptr_t)(x) & MASQUE)
+#define TAG(x)    ROL((uintptr_t)(x) & ~MASQUE, 8)
+#define ABA(p, t) ((uintptr_t)(p) | (ROR((uintptr_t)(t), 8) & ~MASQUE))
+#define ROL(x, n) (((x) << (n)) | ((x) >> (64 - (n))))
+#define ROR(x, n) (((x) >> (n)) | ((x) << (64 - (n))))
+
+struct List {
+  struct List* next;
+  int count;
+};
+
+atomic_uintptr_t list;
+
+void push(struct List* elem) {
+  uintptr_t tip;
+  assert(!TAG(elem));
+  for (tip = atomic_load_explicit(&list, memory_order_relaxed);;) {
+    elem->next = (struct List*)PTR(tip);
+    if (atomic_compare_exchange_weak_explicit(
+            &list, &tip, ABA(elem, TAG(tip) + 1), memory_order_release,
+            memory_order_relaxed))
+      break;
+    pthread_pause_np();
+  }
+}
+
+struct List* pop(void) {
+  uintptr_t tip;
+  struct List* elem;
+  tip = atomic_load_explicit(&list, memory_order_relaxed);
+  while ((elem = (struct List*)PTR(tip))) {
+    if (atomic_compare_exchange_weak_explicit(
+            &list, &tip, ABA(elem->next, TAG(tip) + 1), memory_order_acquire,
+            memory_order_relaxed))
+      break;
+    pthread_pause_np();
+  }
+  return elem;
+}
+
+void* tester(void* arg) {
+  struct List* elem;
+  for (int i = 0; i < ITERATIONS; ++i) {
+    while (!(elem = pop())) {
+      elem = malloc(sizeof(*elem));
+      elem->count = 0;
+      push(elem);
+    }
+    elem->count++;
+    push(elem);
+  }
+  return 0;
+}
+
+int main() {
+  printf("testing aba problem...");
+  fflush(stdout);
+  pthread_t th[THREADS];
+  for (int i = 0; i < THREADS; ++i)
+    pthread_create(&th[i], 0, tester, 0);
+  for (int i = 0; i < THREADS; ++i)
+    pthread_join(th[i], 0);
+  int sum = 0;
+  struct List* elem;
+  while ((elem = pop())) {
+    printf(" %d", elem->count);
+    sum += elem->count;
+    free(elem);
+  }
+  printf("\n");
+  assert(sum == ITERATIONS * THREADS);
+  printf("you are the dancing queen\n");
+  CheckForMemoryLeaks();
+}
diff --git a/examples/art.c b/examples/art.c
new file mode 100644
index 000000000..3802afa9b
--- /dev/null
+++ b/examples/art.c
@@ -0,0 +1,353 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include <errno.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <iconv.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <termios.h>
+#include <time.h>
+#include <unistd.h>
+
+/**
+ * @fileoverview program for viewing bbs art files
+ * @see https://github.com/blocktronics/artpacks
+ * @see http://www.textfiles.com/art/
+ */
+
+#define HELP \
+  "Usage:\n\
+    art [-b %d] [-f %s] [-t %s] FILE...\n\
+\n\
+Flags:\n\
+    -b NUMBER   specifies simulated modem baud rate, which defaults to\n\
+                2400 since that was the most common modem speed in the\n\
+                later half of the 1980s during the BBS golden age; you\n\
+                could also say 300 for the slowest experience possible\n\
+                or you could say 14.4k to get more of a 90's feel, and\n\
+                there's also the infamous 56k to bring you back to y2k\n\
+    -f CHARSET  specifies charset of input bytes, where the default is\n\
+                cp347 which means IBM Code Page 347 a.k.a. DOS\n\
+    -t CHARSET  specifies output charset used by your terminal, and it\n\
+                defaults to utf8 a.k.a. thompson-pike encoding\n\
+\n\
+Supported charsets:\n\
+    utf8, ascii, wchar_t, ucs2be, ucs2le, utf16be, utf16le, ucs4be,\n\
+    ucs4le, utf16, ucs4, ucs2, eucjp, shiftjis, iso2022jp, gb18030, gbk,\n\
+    gb2312, big5, euckr, iso88591, latin1, iso88592, iso88593, iso88594,\n\
+    iso88595, iso88596, iso88597, iso88598, iso88599, iso885910,\n\
+    iso885911, iso885913, iso885914, iso885915, iso885916, cp1250,\n\
+    windows1250, cp1251, windows1251, cp1252, windows1252, cp1253,\n\
+    windows1253, cp1254, windows1254, cp1255, windows1255, cp1256,\n\
+    windows1256, cp1257, windows1257, cp1258, windows1258, koi8r, koi8u,\n\
+    cp437, cp850, cp866, ibm1047, cp1047.\n\
+\n\
+See also:\n\
+    http://www.textfiles.com/art/\n\
+    https://github.com/blocktronics/artpacks\n\
+\n"
+
+#define INBUFSZ 256
+#define OUBUFSZ (INBUFSZ * 6)
+#define SLIT(s) ((unsigned)s[3] << 24 | s[2] << 16 | s[1] << 8 | s[0])
+
+// "When new technology comes out, people don't all buy it right away.
+//  If what they have works, some will wait until it doesn't. A few
+//  people do get the latest though. In 1984 2400 baud modems became
+//  available, so some people had them, but many didn't. A BBS list
+//  from 1986 shows operators were mostly 300 and 1200, but some were
+//  using 2400. The next 5 years were the hayday of the 2400."
+//
+// https://forum.vcfed.org/index.php?threads/the-2400-baud-modem.44241/
+
+int baud_rate = 2400;                // -b 2400
+const char* from_charset = "CP437";  // -f CP437
+const char* to_charset = "UTF-8";    // -t UTF-8
+
+volatile sig_atomic_t done;
+
+void on_signal(int sig) {
+  done = 1;
+  (void)sig;
+}
+
+void print(const char* s) {
+  (void)!write(STDOUT_FILENO, s, strlen(s));
+}
+
+int encode_character(char output[8], const char* codec, wchar_t character) {
+  size_t inbytesleft = sizeof(wchar_t);
+  size_t outbytesleft = 7;
+  char* inbuf = (char*)&character;
+  char* outbuf = output;
+  iconv_t cd = iconv_open(codec, "wchar_t");
+  if (cd == (iconv_t)-1)
+    return -1;
+  size_t result = iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+  iconv_close(cd);
+  if (result == (size_t)-1)
+    return -1;
+  *outbuf = '\0';
+  return 7 - outbytesleft;
+}
+
+void append_replacement_character(char** b) {
+  int n = encode_character(*b, to_charset, 0xFFFD);
+  if (n == -1)
+    n = encode_character(*b, to_charset, '?');
+  if (n != -1)
+    *b += n;
+}
+
+int compare_time(struct timespec a, struct timespec b) {
+  int cmp;
+  if (!(cmp = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec)))
+    cmp = (a.tv_nsec > b.tv_nsec) - (a.tv_nsec < b.tv_nsec);
+  return cmp;
+}
+
+struct timespec add_time(struct timespec x, struct timespec y) {
+  x.tv_sec += y.tv_sec;
+  x.tv_nsec += y.tv_nsec;
+  if (x.tv_nsec >= 1000000000) {
+    x.tv_nsec -= 1000000000;
+    x.tv_sec += 1;
+  }
+  return x;
+}
+
+struct timespec subtract_time(struct timespec a, struct timespec b) {
+  a.tv_sec -= b.tv_sec;
+  if (a.tv_nsec < b.tv_nsec) {
+    a.tv_nsec += 1000000000;
+    a.tv_sec--;
+  }
+  a.tv_nsec -= b.tv_nsec;
+  return a;
+}
+
+struct timespec fromnanos(long long x) {
+  struct timespec ts;
+  ts.tv_sec = x / 1000000000;
+  ts.tv_nsec = x % 1000000000;
+  return ts;
+}
+
+void process_file(const char* path, int fd, iconv_t cd) {
+  size_t carry = 0;
+  struct timespec next;
+  char input_buffer[INBUFSZ];
+
+  clock_gettime(CLOCK_MONOTONIC, &next);
+
+  for (;;) {
+
+    // read from file
+    ssize_t bytes_read = read(fd, input_buffer + carry, INBUFSZ - carry);
+    if (!bytes_read)
+      return;
+    if (bytes_read == -1) {
+      perror(path);
+      done = 1;
+      return;
+    }
+
+    // modernize character set
+    char* input_ptr = input_buffer;
+    size_t input_left = carry + bytes_read;
+    char output_buffer[OUBUFSZ];
+    char* output_ptr = output_buffer;
+    size_t output_left = OUBUFSZ;
+    size_t ir = iconv(cd, &input_ptr, &input_left, &output_ptr, &output_left);
+    carry = 0;
+    if (ir == (size_t)-1) {
+      if (errno == EINVAL) {
+        // incomplete multibyte sequence encountered
+        memmove(input_buffer, input_ptr, input_left);
+        carry = input_left;
+      } else if (errno == EILSEQ && input_left) {
+        // EILSEQ means either
+        // 1. illegal input sequence encountered
+        // 2. code not encodable in output codec
+        //
+        // so we skip one byte of input, and insert � or ? in the output
+        // this isn't the most desirable behavior, but it is the best we
+        // can do, since we don't know specifics about the codecs in use
+        //
+        // unlike glibc cosmo's iconv implementation may handle case (2)
+        // automatically by inserting an asterisk in place of a sequence
+        ++input_ptr;
+        --input_left;
+        memmove(input_buffer, input_ptr, input_left);
+        carry = input_left;
+        if (output_left >= 8)
+          append_replacement_character(&output_ptr);
+      } else {
+        perror(path);
+        done = 1;
+        return;
+      }
+    }
+
+    // write to terminal
+    for (char* p = output_buffer; p < output_ptr; p++) {
+      if (done)
+        return;
+
+      (void)!write(STDOUT_FILENO, p, 1);
+
+      // allow arrow keys to change baud rate
+      int have;
+      if (ioctl(STDIN_FILENO, FIONREAD, &have)) {
+        perror("ioctl");
+        done = 1;
+        return;
+      }
+      if (have > 0) {
+        char key[4] = {0};
+        if (read(STDIN_FILENO, key, sizeof(key)) > 0) {
+          if (SLIT(key) == SLIT("\33[A") ||  // up
+              SLIT(key) == SLIT("\33[C")) {  // right
+            baud_rate *= 1.4;
+          } else if (SLIT(key) == SLIT("\33[B") ||  // down
+                     SLIT(key) == SLIT("\33[D")) {  // left
+            baud_rate *= 0.6;
+          }
+          if (baud_rate < 3)
+            baud_rate = 3;
+          if (baud_rate > 1000000000)
+            baud_rate = 1000000000;
+        }
+      }
+
+      // insert artificial delay for one byte. we divide by 10 to convert
+      // bits to bytes, because that is how many bits 8-N-1 encoding used
+      struct timespec now;
+      clock_gettime(CLOCK_MONOTONIC, &now);
+      next = add_time(next, fromnanos(1e9 / (baud_rate / 10.)));
+      if (compare_time(next, now) > 0) {
+        struct timespec sleep = subtract_time(next, now);
+        nanosleep(&sleep, 0);
+      }
+    }
+  }
+}
+
+int main(int argc, char* argv[]) {
+  int opt;
+  while ((opt = getopt(argc, argv, "hb:f:t:")) != -1) {
+    switch (opt) {
+      case 'b': {
+        char* endptr;
+        double rate = strtod(optarg, &endptr);
+        if (*endptr == 'k') {
+          rate *= 1e3;
+          ++endptr;
+        } else if (*endptr == 'm') {
+          rate *= 1e6;
+          ++endptr;
+        }
+        if (*endptr || baud_rate <= 0) {
+          fprintf(stderr, "%s: invalid baud rate: %s\n", argv[0], optarg);
+          exit(1);
+        }
+        baud_rate = rate;
+        break;
+      }
+      case 'f':
+        from_charset = optarg;
+        break;
+      case 't':
+        to_charset = optarg;
+        break;
+      case 'h':
+        fprintf(stderr, HELP, baud_rate, from_charset, to_charset);
+        exit(0);
+      default:
+        fprintf(stderr, "protip: pass the -h flag for help\n");
+        exit(1);
+    }
+  }
+  if (optind == argc) {
+    fprintf(stderr, "%s: missing operand\n", argv[0]);
+    exit(1);
+  }
+
+  // create character transcoder
+  iconv_t cd = iconv_open(to_charset, from_charset);
+  if (cd == (iconv_t)-1) {
+    fprintf(stderr, "error: conversion from %s to %s not supported\n",
+            from_charset, to_charset);
+    exit(1);
+  }
+
+  // catch ctrl-c
+  signal(SIGINT, on_signal);
+
+  // don't wait until newline to read() keystrokes
+  struct termios t;
+  if (!tcgetattr(STDIN_FILENO, &t)) {
+    struct termios t2 = t;
+    t2.c_lflag &= ~(ICANON | ECHO);
+    tcsetattr(STDIN_FILENO, TCSANOW, &t2);
+  }
+
+  // Process each file specified on the command line
+  for (int i = optind; i < argc && !done; i++) {
+
+    // open file
+    int fd = open(argv[i], O_RDONLY);
+    if (fd == -1) {
+      perror(argv[i]);
+      break;
+    }
+
+    // wait between files
+    if (i > optind)
+      sleep(1);
+
+    print("\33[?25l");   // hide cursor
+    print("\33[H");      // move cursor to top-left
+    print("\33[J");      // erase display forward
+    print("\33[1;24r");  // set scrolling region to first 24 lines
+    print("\33[?7h");    // enable auto-wrap mode
+    print("\33[?3l");    // 80 column mode (deccolm) vt100
+    print("\33[H");      // move cursor to top-left, again
+
+    // get busy
+    process_file(argv[i], fd, cd);
+    close(fd);
+  }
+
+  // cleanup
+  iconv_close(cd);
+
+  print("\33[s");        // save cursor position
+  print("\33[?25h");     // show cursor
+  print("\33[0m");       // reset text attributes (color, bold, etc.)
+  print("\33[?1049l");   // exit alternate screen mode
+  print("\33(B");        // exit line drawing and other alt charset modes
+  print("\33[r");        // reset scrolling region
+  print("\33[?2004l");   // turn off bracketed paste mode
+  print("\33[4l");       // exit insert mode
+  print("\33[?1l\33>");  // exit application keypad mode
+  print("\33[?7h");      // reset text wrapping mode
+  print("\33[?12l");     // reset cursor blinking mode
+  print("\33[?6l");      // reset origin mode
+  print("\33[20l");      // reset auto newline mode
+  print("\33[u");        // restore cursor position
+
+  // restore terminal
+  tcsetattr(STDIN_FILENO, TCSANOW, &t);
+}
diff --git a/examples/asteroids.c b/examples/asteroids.c
new file mode 100644
index 000000000..d9537936c
--- /dev/null
+++ b/examples/asteroids.c
@@ -0,0 +1,353 @@
+// -*- mode:c; indent-tabs-mode:nil; c-basic-offset:4 -*-
+// vi: set et ft=c ts=4 sts=4 sw=4 fenc=utf-8
+
+// asteroids by tsotchke
+// https://github.com/tsotchke/asteroids
+
+// clang-format off
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <unistd.h>
+#include <signal.h>
+#include <termios.h>
+#include <sys/select.h>
+
+#define SCREEN_WIDTH 80
+#define SCREEN_HEIGHT 24
+#define MAX_ASTEROIDS 5
+#define MAX_BULLETS 5
+
+typedef struct {
+    float x, y;
+} Vector2;
+
+typedef struct {
+    Vector2 position;
+    Vector2 velocity;
+    float angle;
+    float radius;
+} GameObject;
+
+GameObject spaceship;
+GameObject asteroids[MAX_ASTEROIDS];
+GameObject bullets[MAX_BULLETS];
+
+int score = 0;
+time_t startTime;
+int isGameOver = 0;
+int shouldExit = 0;
+int finalTime = 0; // To store final time at game over
+char display[SCREEN_HEIGHT][SCREEN_WIDTH];
+
+// Function to clear the screen buffer
+void clearDisplay() {
+    memset(display, ' ', sizeof(display));
+}
+
+// Function to draw a pixel on the screen
+void drawPixel(int x, int y) {
+    if (x >= 0 && x < SCREEN_WIDTH && y >= 0 && y < SCREEN_HEIGHT) {
+        display[y][x] = '*';
+    }
+}
+
+// Function to draw a line using Bresenham's algorithm
+void drawLine(int x1, int y1, int x2, int y2) {
+    int dx = abs(x2 - x1), sx = (x1 < x2) ? 1 : -1;
+    int dy = -abs(y2 - y1), sy = (y1 < y2) ? 1 : -1;
+    int error = dx + dy, e2;
+
+    while (1) {
+        drawPixel(x1, y1);
+        if (x1 == x2 && y1 == y2) break;
+        e2 = 2 * error;
+        if (e2 >= dy) { error += dy; x1 += sx; }
+        if (e2 <= dx) { error += dx; y1 += sy; }
+    }
+}
+
+// Function to draw a circle
+void drawCircle(int centerX, int centerY, int radius) {
+    int x = radius - 1, y = 0, dx = 1, dy = 1, err = dx - (radius << 1);
+    while (x >= y) {
+        drawPixel(centerX + x, centerY + y);
+        drawPixel(centerX + y, centerY + x);
+        drawPixel(centerX - y, centerY + x);
+        drawPixel(centerX - x, centerY + y);
+        drawPixel(centerX - x, centerY - y);
+        drawPixel(centerX - y, centerY - x);
+        drawPixel(centerX + y, centerY - x);
+        drawPixel(centerX + x, centerY - y);
+
+        if (err <= 0) {
+            y++;
+            err += dy;
+            dy += 2;
+        }
+        if (err > 0) {
+            x--;
+            dx += 2;
+            err += dx - (radius << 1);
+        }
+    }
+}
+
+// Initialize a game object
+void initializeGameObject(GameObject *obj, float x, float y, float angle, float radius) {
+    obj->position = (Vector2){x, y};
+    obj->velocity = (Vector2){0, 0};
+    obj->angle = angle;
+    obj->radius = radius;
+}
+
+// Wrap position of the spaceship and asteroids within screen bounds
+void wrapPosition(Vector2 *pos) {
+    if (pos->x < 0) pos->x = SCREEN_WIDTH - 1;
+    if (pos->x >= SCREEN_WIDTH) pos->x = 0;
+    if (pos->y < 0) pos->y = SCREEN_HEIGHT - 1;
+    if (pos->y >= SCREEN_HEIGHT) pos->y = 0;
+}
+
+// Check if two game objects are colliding
+int checkCollision(GameObject *a, GameObject *b) {
+    float deltaX = a->position.x - b->position.x;
+    float deltaY = a->position.y - b->position.y;
+    return sqrt(deltaX * deltaX + deltaY * deltaY) < (a->radius + b->radius);
+}
+
+// Initialize game state
+void initGame() {
+    score = 0; // Reset the score
+    initializeGameObject(&spaceship, SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0, 2);
+
+    for (int i = 0; i < MAX_ASTEROIDS; i++) {
+        initializeGameObject(&asteroids[i],
+            rand() % SCREEN_WIDTH,
+            rand() % SCREEN_HEIGHT,
+            0,
+            2 + rand() % 3);
+        asteroids[i].velocity.x = ((float)rand() / RAND_MAX) * 2 - 1;
+        asteroids[i].velocity.y = ((float)rand() / RAND_MAX) * 2 - 1;
+    }
+
+    for (int i = 0; i < MAX_BULLETS; i++) {
+        bullets[i].position.x = -1; // Mark bullet as inactive
+        bullets[i].position.y = -1;
+    }
+
+    startTime = time(NULL);
+    isGameOver = 0;
+    finalTime = 0; // Reset final time
+}
+
+// Draw the spaceship on the screen
+void drawSpaceship() {
+    int x = (int)spaceship.position.x;
+    int y = (int)spaceship.position.y;
+    int size = 3;
+
+    float cosAngle = cos(spaceship.angle);
+    float sinAngle = sin(spaceship.angle);
+
+    int x1 = x + size * cosAngle;
+    int y1 = y + size * sinAngle;
+    int x2 = x + size * cos(spaceship.angle + 2.5);
+    int y2 = y + size * sin(spaceship.angle + 2.5);
+    int x3 = x + size * cos(spaceship.angle - 2.5);
+    int y3 = y + size * sin(spaceship.angle - 2.5);
+
+    drawLine(x1, y1, x2, y2);
+    drawLine(x2, y2, x3, y3);
+    drawLine(x3, y3, x1, y1);
+}
+
+// Draw all entities on the screen
+void drawEntities(GameObject *entities, int count, void (*drawFunc)(GameObject *)) {
+    for (int i = 0; i < count; i++) {
+        drawFunc(&entities[i]);
+    }
+}
+
+// Draw a bullet on the screen
+void drawBullet(GameObject *bullet) { // Changed to non-const
+    if (bullet->position.x >= 0) {
+        drawPixel((int)bullet->position.x, (int)bullet->position.y);
+    }
+}
+
+// Draw an asteroid on the screen
+void drawAsteroid(GameObject *asteroid) { // Changed to non-const
+    drawCircle((int)asteroid->position.x, (int)asteroid->position.y, (int)asteroid->radius);
+}
+
+// Refresh the display
+void updateDisplay() {
+    clearDisplay();
+    if (!isGameOver) {
+        drawSpaceship();
+        drawEntities(asteroids, MAX_ASTEROIDS, drawAsteroid);
+        drawEntities(bullets, MAX_BULLETS, drawBullet);
+    }
+
+    // Print the screen buffer
+    printf("\033[H");
+    for (int y = 0; y < SCREEN_HEIGHT; y++) {
+        for (int x = 0; x < SCREEN_WIDTH; x++) {
+            putchar(display[y][x]);
+        }
+        putchar('\n');
+    }
+    
+    // Display score and elapsed time
+    time_t currentTime = time(NULL);
+    int elapsedTime = isGameOver ? finalTime : (currentTime - startTime);
+    printf("Score: %d | Time: %02d:%02d | %s\n", score, elapsedTime / 60, elapsedTime % 60, isGameOver ? "Game Over!" : "           ");
+}
+
+// Update the position of game objects
+void updateGameObject(GameObject *obj, int isBullet) {
+    obj->position.x += obj->velocity.x;
+    obj->position.y += obj->velocity.y;
+
+    // If it's a bullet, check if it's out of bounds
+    if (isBullet) {
+        if (obj->position.x < 0 || obj->position.x >= SCREEN_WIDTH || obj->position.y < 0 || obj->position.y >= SCREEN_HEIGHT) {
+            obj->position.x = -1; // Deactivate bullet
+            obj->position.y = -1;
+        }
+    } else {
+        wrapPosition(&obj->position);
+    }
+}
+
+// Update the game state
+void updateGame() {
+    if (isGameOver) return; 
+
+    // Update spaceship and apply friction
+    updateGameObject(&spaceship, 0); // 0 indicates it's not a bullet
+    spaceship.velocity.x *= 0.98;
+    spaceship.velocity.y *= 0.98;
+
+    // Move asteroids and check for collisions
+    for (int i = 0; i < MAX_ASTEROIDS; i++) {
+        updateGameObject(&asteroids[i], 0);
+        if (checkCollision(&spaceship, &asteroids[i])) {
+            isGameOver = 1;
+            finalTime = time(NULL) - startTime;
+            return;
+        }
+    }
+
+    // Update bullet positions
+    for (int i = 0; i < MAX_BULLETS; i++) {
+        if (bullets[i].position.x >= 0) {
+            updateGameObject(&bullets[i], 1); // 1 indicates it's a bullet
+        }
+    }
+
+    // Check for bullet collisions with asteroids
+    for (int i = 0; i < MAX_BULLETS; i++) {
+        if (bullets[i].position.x >= 0) {
+            for (int j = 0; j < MAX_ASTEROIDS; j++) {
+                if (checkCollision(&bullets[i], &asteroids[j])) {
+                    bullets[i].position.x = -1; // Deactivate bullet
+                    bullets[i].position.y = -1;
+                    asteroids[j].position.x = rand() % SCREEN_WIDTH;
+                    asteroids[j].position.y = rand() % SCREEN_HEIGHT;
+                    score += 100;
+                }
+            }
+        }
+    }
+}
+
+// Fire a bullet
+void shootBullet() {
+    for (int i = 0; i < MAX_BULLETS; i++) {
+        if (bullets[i].position.x < 0) {
+            bullets[i].position = spaceship.position;
+            bullets[i].velocity.x = cos(spaceship.angle) * 2;
+            bullets[i].velocity.y = sin(spaceship.angle) * 2;
+            break;
+        }
+    }
+}
+
+// Check if a key was hit
+int isKeyHit() {
+    struct timeval tv = { 0L, 0L };
+    fd_set fds;
+    FD_ZERO(&fds);
+    FD_SET(0, &fds);
+    return select(1, &fds, NULL, NULL, &tv);
+}
+
+// Configure terminal settings
+void configureTerminal(struct termios *old_tio, struct termios *new_tio) {
+    tcgetattr(STDIN_FILENO, old_tio);
+    *new_tio = *old_tio;
+    new_tio->c_lflag &= (~ICANON & ~ECHO);
+    tcsetattr(STDIN_FILENO, TCSANOW, new_tio);
+}
+
+// Restore terminal settings
+void restoreTerminal(struct termios *old_tio) {
+    tcsetattr(STDIN_FILENO, TCSANOW, old_tio);
+}
+
+void onSignal(int sig) {
+    shouldExit = 1;
+}
+
+// Main game loop
+int main() {
+    signal(SIGINT, onSignal); // Capture ^C
+    srand(time(NULL)); // Seed the random number generator
+    initGame(); // Initialize the game state
+
+    struct termios old_tio, new_tio;
+    configureTerminal(&old_tio, &new_tio);
+
+    printf("\033[?25l");  // Hide the cursor
+
+    while (!shouldExit) {
+        if (isKeyHit()) {
+            char input = getchar();
+            if (input == 27) {  // ESC key
+                if (getchar() == '[') {  // Handle arrow keys
+                    switch (getchar()) {
+                        case 'A':  // Up arrow
+                            spaceship.velocity.x += cos(spaceship.angle) * 0.2;
+                            spaceship.velocity.y += sin(spaceship.angle) * 0.2;
+                            break;
+                        case 'B':  // Down arrow
+                            spaceship.velocity.x -= cos(spaceship.angle) * 0.2;
+                            spaceship.velocity.y -= sin(spaceship.angle) * 0.2;
+                            break;
+                        case 'D': spaceship.angle -= 0.2; break;  // Left arrow
+                        case 'C': spaceship.angle += 0.2; break;  // Right arrow
+                    }
+                }
+            } else if (input == ' ') {
+                shootBullet(); // Fire a bullet
+            } else if (input == 'q') {
+                break; // Quit the game
+            } else if (input == 'r' && isGameOver) {
+                initGame(); // Restart the game
+            }
+        }
+
+        updateGame(); // Update game state
+        updateDisplay(); // Refresh the display
+        usleep(50000);  // Wait for 50ms (20 FPS)
+    }
+
+    printf("\033[?25h");  // Show the cursor
+    restoreTerminal(&old_tio); // Restore terminal settings
+    return 0;
+}
diff --git a/examples/blas.cc b/examples/blas.cc
index 5bcc4b2ba..1dbdec7cc 100644
--- a/examples/blas.cc
+++ b/examples/blas.cc
@@ -14,16 +14,16 @@
 // PERFORMANCE OF THIS SOFTWARE.
 
 #include <unistd.h>
+#include <cassert>
 #include <cinttypes>
 #include <cmath>
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
-#include "libc/assert.h"
 
 // high performance high accuracy matrix multiplication in ansi c
 
-#define MATH __target_clones("avx512f,fma")
+#define MATH __target_clones("avx512f,fma,avx")
 
 namespace {
 namespace ansiBLAS {
@@ -135,7 +135,7 @@ void sgemm(int m, int n, int k,      //
            const float *B, int ldb,  //
            float *C, int ldc) {
   int nth = sysconf(_SC_NPROCESSORS_ONLN);
-#pragma omp parallel for
+#pragma omp parallel for schedule(static)
   for (int ith = 0; ith < nth; ++ith) {
     ansiBLAS tb{k, A, lda, B, ldb, C, ldc, ith, nth};
     tb.matmul(m, n);
diff --git a/examples/clear.c b/examples/clear.c
index f008c5845..c03453e0e 100644
--- a/examples/clear.c
+++ b/examples/clear.c
@@ -7,7 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
+#include <unistd.h>
 
 // clears teletypewriter display
 //
diff --git a/examples/crashreport.c b/examples/crashreport.c
index 4e41ebf7f..b8219d83c 100644
--- a/examples/crashreport.c
+++ b/examples/crashreport.c
@@ -7,12 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/math.h"
-#include "libc/runtime/runtime.h"
-#include "libc/runtime/symbols.internal.h"
-#include "libc/stdio/stdio.h"
+#include <cosmo.h>
 
 /**
  * @fileoverview How to print backtraces and cpu state on crash.
diff --git a/examples/crashreport2.cc b/examples/crashreport2.cc
index d57f3bdea..094a9e21b 100644
--- a/examples/crashreport2.cc
+++ b/examples/crashreport2.cc
@@ -7,9 +7,8 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/math.h"
-#include "libc/runtime/runtime.h"
+#include <cosmo.h>
+#include <math.h>
 
 void crash(long x0, long x1, long x2,  //
            double v0, double v1, double v2) {
diff --git a/examples/ctrlc.c b/examples/ctrlc.c
index ee1ca37fa..f291add80 100644
--- a/examples/ctrlc.c
+++ b/examples/ctrlc.c
@@ -7,20 +7,43 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/assert.h"
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/sigaction.h"
-#include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sock/struct/pollfd.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/f.h"
-#include "libc/sysv/consts/limits.h"
-#include "libc/sysv/consts/o.h"
-#include "libc/sysv/consts/poll.h"
-#include "libc/sysv/consts/sig.h"
+#include <ctype.h>
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <termios.h>
+#include <unistd.h>
+
+// this program is used by jart for manually testing teletype interrupts
+// and canonical mode line editing. this file documents the hidden depth
+// of 1960's era computer usage, that's entrenched in primitive i/o apis
+//
+// manual testing checklist:
+//
+// - "hello" enter echos "got: hello^J"
+//
+// - "hello" ctrl-d echos "got: hello"
+//
+// - "hello" ctrl-r echos "^R\nhello"
+//
+// - "hello" ctrl-u enter echos "got: ^J"
+//
+// - ctrl-d during i/o task prints "got eof" and exits
+//
+// - ctrl-d during cpu task gets delayed until read() is called
+//
+// - ctrl-c during cpu task echos ^C, then calls SignalHandler()
+//   asynchronously, and program exits
+//
+// - ctrl-c during i/o task echos ^C, then calls SignalHandler()
+//   asynchronously, read() raises EINTR, and program exits
+//
+// - ctrl-v ctrl-c should echo "^\b" then echo "^C" and insert "\3"
+//
+// - ctrl-v ctrl-d should echo "^\b" then echo "^D" and insert "\4"
+//
 
 volatile bool gotsig;
 
@@ -34,23 +57,41 @@ void SignalHandler(int sig) {
   gotsig = true;
 }
 
+// this is the easiest way to write a string literal to standard output,
+// without formatting. printf() has an enormous binary footprint so it's
+// nice to avoid linking that when it is not needed.
+#define WRITE(sliteral) write(1, sliteral, sizeof(sliteral) - 1)
+
 int main(int argc, char *argv[]) {
 
-  printf("echoing stdin until ctrl+c is pressed\n");
+  WRITE("echoing stdin until ctrl+c is pressed\n");
 
-  // you need to set your signal handler using sigaction() rather than
-  // signal(), since the latter uses .sa_flags=SA_RESTART, which means
-  // read will restart itself after signals, rather than raising EINTR
+  // when you type ctrl-c, by default it'll kill the process, unless you
+  // define a SIGINT handler. there's multiple ways to do it. the common
+  // way is to say signal(SIGINT, func) which is normally defined to put
+  // the signal handler in Berkeley-style SA_RESTART mode. that means if
+  // a signal handler is called while inside a function like read() then
+  // the read operation will keep going afterwards like nothing happened
+  // which can make it difficult to break your event loop. to avoid this
+  // we can use sigaction() without specifying SA_RESTART in sa_flag and
+  // that'll put the signal in system v mode. this means that whenever a
+  // signal handler function in your program is called during an i/o op,
+  // that i/o op will return an EINTR error, so you can churn your loop.
+  // don't take that error too seriously though since SIGINT can also be
+  // delivered asynchronously, during the times you're crunching numbers
+  // rather than performing i/o which means you get no EINTR to warn you
   sigaction(SIGINT, &(struct sigaction){.sa_handler = SignalHandler}, 0);
 
   for (;;) {
 
-    // some programs are blocked on cpu rather than i/o
-    // such programs shall rely on asynchronous signals
-    printf("doing cpu task...\n");
-    for (volatile int i = 0; i < INT_MAX / 5; ++i) {
+    // asynchronous signals are needed to interrupt math, which we shall
+    // simulate here. signals can happen any time any place. that's only
+    // not the case when you use sigprocmask() to block signals which is
+    // useful for kicking the can down the road.
+    WRITE("doing cpu task...\n");
+    for (volatile int i = 0; i < INT_MAX / 3; ++i) {
       if (gotsig) {
-        printf("\rgot ctrl+c asynchronously\n");
+        WRITE("\rgot ctrl+c asynchronously\n");
         exit(0);
       }
     }
@@ -71,14 +112,18 @@ int main(int argc, char *argv[]) {
 
     // read data from standard input
     //
-    // since this is a blocking operation and we're not performing a
-    // cpu-bound operation it is almost with absolute certainty that
-    // when the ctrl-c signal gets delivered, it'll happen in read()
-    //
-    // it's possible to be more precise if we were building library
-    // code. for example, you can block signals using sigprocmask()
-    // and then use pselect() to do the waiting.
-    printf("doing read i/o task...\n");
+    // assuming you started this program in your terminal standard input
+    // will be plugged into your termios driver, which cosmpolitan codes
+    // in libc/calls/read-nt.c on windows. your read() function includes
+    // a primitive version of readline/linenoise called "canonical mode"
+    // which lets you edit the data that'll be returned by read() before
+    // it's actually returned. for example, if you type hello and enter,
+    // then "hello\n" will be returned. if you type hello and then ^D or
+    // ctrl-d, then "hello" will be returned. the ctrl-d keystroke is in
+    // fact an ascii control code whose special behavior can be bypassed
+    // if you type ctrl-v ctrl-d and then enter, in which case "\3\n" is
+    // returned, also known as ^D^J.
+    WRITE("doing read i/o task...\n");
     int got = read(0, buf, sizeof(buf));
 
     // check if the read operation failed
@@ -94,10 +139,10 @@ int main(int argc, char *argv[]) {
         // the \r character is needed so when the line is printed
         // it'll overwrite the ^C that got echo'd with the ctrl-c
         if (gotsig) {
-          printf("\rgot ctrl+c via i/o eintr\n");
+          WRITE("\rgot ctrl+c via i/o eintr\n");
           exit(0);
         } else {
-          printf("\rgot spurious eintr\n");
+          WRITE("\rgot spurious eintr\n");
           continue;
         }
       } else {
@@ -109,16 +154,34 @@ int main(int argc, char *argv[]) {
 
     // check if the user typed ctrl-d which closes the input handle
     if (!got) {
-      printf("got eof\n");
+      WRITE("got eof\n");
       exit(0);
     }
 
-    // relay read data to standard output
+    // visualize line data returned by canonical mode to standard output
     //
-    // it's usually safe to ignore the return code of write. the
-    // operating system will send SIGPIPE if there's any problem
-    // which kills the process by default
+    // it's usually safe to ignore the return code of write; your system
+    // will send SIGPIPE if there's any problem, which kills by default.
+    //
+    // it's possible to use keyboard shortcuts to embed control codes in
+    // the line. so we visualize them using the classic tty notation. it
+    // is also possible to type the ascii representation, so we use bold
+    // to visually distinguish ascii codes. see also o//examples/ttyinfo
     write(1, "got: ", 5);
-    write(1, buf, got);
+    for (int i = 0; i < got; ++i) {
+      if (isascii(buf[i])) {
+        if (iscntrl(buf[i])) {
+          char ctl[2];
+          ctl[0] = '^';
+          ctl[1] = buf[i] ^ 0100;
+          WRITE("\033[1m");
+          write(1, ctl, 2);
+          WRITE("\033[0m");
+        } else {
+          write(1, &buf[i], 1);
+        }
+      }
+    }
+    WRITE("\n");
   }
 }
diff --git a/examples/date.c b/examples/date.c
index fbee50f5d..a0d3c6656 100644
--- a/examples/date.c
+++ b/examples/date.c
@@ -7,18 +7,11 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
-#include "libc/nt/enum/timezoneid.h"
-#include "libc/nt/struct/timezoneinformation.h"
-#include "libc/nt/time.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/thread/threads.h"
-#include "libc/time.h"
+#include <stdlib.h>
+#include <string.h>
+#include <threads.h>
+#include <time.h>
+#include <unistd.h>
 
 /**
  * @fileoverview High performance ISO-8601 timestamp formatter.
@@ -27,6 +20,8 @@
  * Consider using something like this instead for your loggers.
  */
 
+#define ABS(X) ((X) >= 0 ? (X) : -(X))
+
 char *GetTimestamp(void) {
   int x;
   struct timespec ts;
diff --git a/examples/dlopen.c b/examples/dlopen.c
index 545513918..3198e5361 100644
--- a/examples/dlopen.c
+++ b/examples/dlopen.c
@@ -7,11 +7,9 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/dlopen/dlfcn.h"
-#include "libc/fmt/itoa.h"
-#include "libc/nt/thunk/msabi.h"
-#include "libc/runtime/runtime.h"
+#include <cosmo.h>
+#include <dlfcn.h>
+#include <stdlib.h>
 
 /**
  * @fileoverview cosmopolitan dynamic runtime linking demo
diff --git a/examples/env.c b/examples/env.c
index 5e607ddad..83973ddee 100644
--- a/examples/env.c
+++ b/examples/env.c
@@ -1,10 +1,21 @@
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+
+/**
+ * @fileoverview prints environment variables
+ */
 
 int main(int argc, char* argv[]) {
-  fprintf(stderr, "%s (%s)\n", argv[0], GetProgramExecutableName());
-  for (char** p = environ; *p; ++p) {
-    printf("%s\n", *p);
-  }
+  for (char** p = environ; *p; ++p)
+    puts(*p);
   return 0;
 }
diff --git a/examples/greenbean.c b/examples/greenbean.c
index 969051e82..eca939a7b 100644
--- a/examples/greenbean.c
+++ b/examples/greenbean.c
@@ -23,7 +23,6 @@
 #include <sys/auxv.h>
 #include <sys/socket.h>
 #include <time.h>
-#include "libc/mem/leaks.h"
 
 /**
  * @fileoverview greenbean lightweight threaded web server
@@ -288,10 +287,11 @@ int main(int argc, char *argv[]) {
   // print all the ips that 0.0.0.0 would bind
   // Cosmo's GetHostIps() API is much easier than ioctl(SIOCGIFCONF)
   uint32_t *hostips;
-  for (hostips = gc(GetHostIps()), i = 0; hostips[i]; ++i) {
+  for (hostips = GetHostIps(), i = 0; hostips[i]; ++i) {
     kprintf("listening on http://%hhu.%hhu.%hhu.%hhu:%hu\n", hostips[i] >> 24,
             hostips[i] >> 16, hostips[i] >> 8, hostips[i], PORT);
   }
+  free(hostips);
 
   // secure the server
   //
@@ -336,13 +336,12 @@ int main(int argc, char *argv[]) {
   sigaddset(&block, SIGHUP);
   sigaddset(&block, SIGQUIT);
   pthread_attr_t attr;
-  int pagesz = getauxval(AT_PAGESZ);
   unassert(!pthread_attr_init(&attr));
-  unassert(!pthread_attr_setstacksize(&attr, 65536));
-  unassert(!pthread_attr_setguardsize(&attr, pagesz));
+  unassert(!pthread_attr_setstacksize(&attr, 65536 - getpagesize()));
+  unassert(!pthread_attr_setguardsize(&attr, getpagesize()));
   unassert(!pthread_attr_setsigmask_np(&attr, &block));
   unassert(!pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0));
-  pthread_t *th = gc(calloc(threads, sizeof(pthread_t)));
+  pthread_t *th = calloc(threads, sizeof(pthread_t));
   for (i = 0; i < threads; ++i) {
     int rc;
     ++a_workers;
@@ -399,6 +398,7 @@ int main(int argc, char *argv[]) {
   for (i = 0; i < threads; ++i) {
     unassert(!pthread_join(th[i], 0));
   }
+  free(th);
 
   // close the server socket
   if (!IsWindows())
diff --git a/examples/hangman.c b/examples/hangman.c
index 4aa736490..a739af289 100644
--- a/examples/hangman.c
+++ b/examples/hangman.c
@@ -36,14 +36,10 @@
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/stat.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/rand.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/time.h"
-#include "third_party/zlib/zlib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <time.h>
 // clang-format off
 
 #define DICT "usr/share/dict/hangman"
diff --git a/examples/hello.c b/examples/hello.c
index f56cbae1e..f3cc59316 100644
--- a/examples/hello.c
+++ b/examples/hello.c
@@ -7,9 +7,8 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/stdio/stdio.h"
+#include <stdio.h>
 
 int main() {
   printf("hello world\n");
-  return 0;
 }
diff --git a/examples/hello2.c b/examples/hello2.c
index ecf749dee..25cbd9a07 100644
--- a/examples/hello2.c
+++ b/examples/hello2.c
@@ -7,7 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
+#include <unistd.h>
 
 int main() {
   write(1, "hello world\n", 12);
diff --git a/examples/helloplus.cc b/examples/helloplus.cc
new file mode 100644
index 000000000..0cae09b15
--- /dev/null
+++ b/examples/helloplus.cc
@@ -0,0 +1,6 @@
+#include "ctl/ostream.h"
+
+int main(int argc, char* argv[]) {
+  ctl::cout << "hello world\n";
+  return 0;
+}
diff --git a/examples/kilo.c b/examples/kilo.c
index 055b29853..513b3277e 100644
--- a/examples/kilo.c
+++ b/examples/kilo.c
@@ -60,6 +60,7 @@ Contact: antirez@gmail.com");
 #include "libc/calls/calls.h"
 #include "libc/calls/termios.h"
 #include "libc/calls/weirdtypes.h"
+#include "libc/ctype.h"
 #include "libc/errno.h"
 #include "libc/log/log.h"
 #include "libc/mem/alg.h"
diff --git a/examples/localtime.c b/examples/localtime.c
deleted file mode 100644
index 70d67c1c2..000000000
--- a/examples/localtime.c
+++ /dev/null
@@ -1,15 +0,0 @@
-#if 0
-/*─────────────────────────────────────────────────────────────────╗
-│ To the extent possible under law, Justine Tunney has waived      │
-│ all copyright and related or neighboring rights to this file,    │
-│ as it is written in the following disclaimers:                   │
-│   • http://unlicense.org/                                        │
-│   • http://creativecommons.org/publicdomain/zero/1.0/            │
-╚─────────────────────────────────────────────────────────────────*/
-#endif
-#include "libc/time.h"
-
-int main(int argc, char *argv[]) {
-  int64_t t = 0;
-  localtime(&t);
-}
diff --git a/examples/loudness.c b/examples/loudness.c
new file mode 100644
index 000000000..194600f08
--- /dev/null
+++ b/examples/loudness.c
@@ -0,0 +1,133 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include <cosmoaudio.h>
+#include <math.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+/**
+ * @fileoverview prints ascii meter of microphone loudness
+ *
+ * 0. -60 dB is nearly silent, barely audible, even in a quiet room
+ * 1. -50 dB is very quiet background sounds
+ * 2. -40 dB is quiet ambient noise
+ * 3. -30 dB is clear but soft sounds
+ * 4. -20 dB is moderate volume, comfortable for extended listening
+ * 5. -10 dB is fairly loud, but not uncomfortable
+ * 6.  -6 dB is loud, but not at full volume
+ * 7.  -3 dB is very loud, approaching system limits
+ * 8.  -1 dB is extremely loud, just below maximum
+ * 9.  -0 dB is maximum volume without distortion
+ */
+
+#define SAMPLING_RATE     44100
+#define ASCII_METER_WIDTH 20
+#define FRAMES_PER_SECOND 30
+#define MIN_DECIBEL       -60
+#define MAX_DECIBEL       0
+#define DEBUG_LOG         1
+
+sig_atomic_t g_done;
+
+void on_signal(int sig) {
+  g_done = 1;
+}
+
+// computes root of mean squares
+double rms(float* p, int n) {
+  double s = 0;
+  for (int i = 0; i < n; ++i)
+    s += p[i] * p[i];
+  return sqrt(s / n);
+}
+
+// converts rms to decibel
+double rms_to_db(double rms) {
+  double db = 20 * log10(rms);
+  db = fmin(db, MAX_DECIBEL);
+  db = fmax(db, MIN_DECIBEL);
+  return db;
+}
+
+int main() {
+  signal(SIGINT, on_signal);
+
+  // how many samples should we process at once
+  int chunkFrames = SAMPLING_RATE / FRAMES_PER_SECOND;
+
+  // configure cosmo audio
+  struct CosmoAudioOpenOptions cao = {0};
+  cao.sizeofThis = sizeof(struct CosmoAudioOpenOptions);
+  cao.deviceType = kCosmoAudioDeviceTypeCapture;
+  cao.sampleRate = SAMPLING_RATE;
+  cao.bufferFrames = chunkFrames * 2;
+  cao.debugLog = DEBUG_LOG;
+  cao.channels = 1;
+
+  // connect to microphone
+  int status;
+  struct CosmoAudio* ca;
+  status = cosmoaudio_open(&ca, &cao);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to open microphone: %d\n", status);
+    return 1;
+  }
+
+  // allocate memory for audio work area
+  float* chunk = malloc(chunkFrames * sizeof(float));
+  if (!chunk) {
+    fprintf(stderr, "out of memory\n");
+    return 1;
+  }
+
+  while (!g_done) {
+
+    // wait for full chunk of audio to become available
+    int need_in_frames = chunkFrames;
+    status = cosmoaudio_poll(ca, &need_in_frames, NULL);
+    if (status != COSMOAUDIO_SUCCESS) {
+      fprintf(stderr, "failed to poll microphone: %d\n", status);
+      return 2;
+    }
+
+    // read audio frames from microphone ring buffer
+    status = cosmoaudio_read(ca, chunk, chunkFrames);
+    if (status != chunkFrames) {
+      fprintf(stderr, "failed to read microphone: %d\n", status);
+      return 3;
+    }
+
+    // convert audio chunk to to ascii meter
+    char s[ASCII_METER_WIDTH + 1] = {0};
+    double db = rms_to_db(rms(chunk, chunkFrames));
+    double db_range = MAX_DECIBEL - MIN_DECIBEL;
+    int filled_length = (db - MIN_DECIBEL) / db_range * ASCII_METER_WIDTH;
+    for (int i = 0; i < ASCII_METER_WIDTH; ++i) {
+      if (i < filled_length) {
+        s[i] = '=';
+      } else {
+        s[i] = ' ';
+      }
+    }
+    printf("\r%s| %+6.2f dB", s, db);
+    fflush(stdout);
+  }
+  printf("\n");
+
+  // clean up resources
+  status = cosmoaudio_close(ca);
+  if (status != COSMOAUDIO_SUCCESS) {
+    fprintf(stderr, "failed to close microphone: %d\n", status);
+    return 5;
+  }
+  free(chunk);
+}
diff --git a/examples/ls.c b/examples/ls.c
deleted file mode 100644
index 7d8e509f1..000000000
--- a/examples/ls.c
+++ /dev/null
@@ -1,83 +0,0 @@
-#if 0
-/*─────────────────────────────────────────────────────────────────╗
-│ To the extent possible under law, Justine Tunney has waived      │
-│ all copyright and related or neighboring rights to this file,    │
-│ as it is written in the following disclaimers:                   │
-│   • http://unlicense.org/                                        │
-│   • http://creativecommons.org/publicdomain/zero/1.0/            │
-╚─────────────────────────────────────────────────────────────────*/
-#endif
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/dirent.h"
-#include "libc/calls/struct/stat.h"
-#include "libc/log/check.h"
-#include "libc/mem/gc.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/dt.h"
-#include "libc/sysv/consts/s.h"
-#include "libc/x/xasprintf.h"
-
-struct stat st;
-
-const char *TypeToString(uint8_t type) {
-  switch (type) {
-    case DT_UNKNOWN:
-      return "DT_UNKNOWN";
-    case DT_FIFO:
-      return "DT_FIFO";
-    case DT_CHR:
-      return "DT_CHR";
-    case DT_DIR:
-      return "DT_DIR";
-    case DT_BLK:
-      return "DT_BLK";
-    case DT_REG:
-      return "DT_REG";
-    case DT_LNK:
-      return "DT_LNK";
-    case DT_SOCK:
-      return "DT_SOCK";
-    default:
-      return "UNKNOWN";
-  }
-}
-
-void List(const char *path) {
-  DIR *d;
-  struct dirent *e;
-  const char *vpath;
-  if (strcmp(path, ".") == 0) {
-    vpath = "";
-  } else if (!endswith(path, "/")) {
-    vpath = gc(xasprintf("%s/", path));
-  } else {
-    vpath = path;
-  }
-  if (stat(path, &st) != -1) {
-    if (S_ISDIR(st.st_mode)) {
-      CHECK((d = opendir(path)));
-      while ((e = readdir(d))) {
-        printf("0x%016x 0x%016x %-10s %s%s\n", e->d_ino, e->d_off,
-               TypeToString(e->d_type), vpath, e->d_name);
-      }
-      closedir(d);
-    } else {
-      printf("%s\n", path);
-    }
-  } else {
-    fprintf(stderr, "not found: %s\n", path);
-  }
-}
-
-int main(int argc, char *argv[]) {
-  int i;
-  if (argc == 1) {
-    List(".");
-  } else {
-    for (i = 1; i < argc; ++i) {
-      List(argv[i]);
-    }
-  }
-  return 0;
-}
diff --git a/examples/nc.c b/examples/nc.c
index 3e29a51d2..1e4f9945b 100644
--- a/examples/nc.c
+++ b/examples/nc.c
@@ -7,25 +7,16 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/fmt/conv.h"
-#include "libc/log/log.h"
-#include "libc/macros.internal.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sock/sock.h"
-#include "libc/sock/struct/linger.h"
-#include "libc/sock/struct/pollfd.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/af.h"
-#include "libc/sysv/consts/ipproto.h"
-#include "libc/sysv/consts/poll.h"
-#include "libc/sysv/consts/shut.h"
-#include "libc/sysv/consts/so.h"
-#include "libc/sysv/consts/sock.h"
-#include "libc/sysv/consts/sol.h"
-#include "third_party/getopt/getopt.internal.h"
-#include "third_party/musl/netdb.h"
+#include <cosmo.h>
+#include <getopt.h>
+#include <netdb.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+// clang-format off
 
 /**
  * @fileoverview netcat clone
@@ -36,12 +27,14 @@
  * Here's an example usage:
  *
  *     make -j8 o//examples/nc.com
- *     printf 'GET /\r\nHost: justine.lol\r\n\r\n' | o//examples/nc.com
- * justine.lol 80
+ *     printf 'GET /\r\nHost: justine.lol\r\n\r\n' | o//examples/nc.com justine.lol 80
  *
- * Once upon time we called this command "telnet"
+ * Once upon time we called this command basically "telnet"
  */
 
+#define ARRAYLEN(A) \
+  ((sizeof(A) / sizeof(*(A))) / ((unsigned)!(sizeof(A) % sizeof(*(A)))))
+
 int main(int argc, char *argv[]) {
   ssize_t rc;
   size_t i, got;
diff --git a/examples/nesemu1.cc b/examples/nesemu1.cc
index 0104fd100..a7597c265 100644
--- a/examples/nesemu1.cc
+++ b/examples/nesemu1.cc
@@ -3,6 +3,7 @@
 /* PORTED TO TELETYPEWRITERS IN YEAR 2020 BY JUSTINE ALEXANDRA ROBERTS TUNNEY */
 /* TRADEMARKS ARE OWNED BY THEIR RESPECTIVE OWNERS LAWYERCATS LUV TAUTOLOGIES */
 /* https://bisqwit.iki.fi/jutut/kuvat/programming_examples/nesemu1/nesemu1.cc */
+#include "dsp/audio/cosmoaudio/cosmoaudio.h"
 #include "dsp/core/core.h"
 #include "dsp/core/half.h"
 #include "dsp/core/illumination.h"
@@ -12,18 +13,17 @@
 #include "dsp/tty/tty.h"
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
-#include "libc/calls/struct/itimerval.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/winsize.h"
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/inttypes.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/arraylist2.internal.h"
 #include "libc/mem/mem.h"
@@ -35,20 +35,17 @@
 #include "libc/str/str.h"
 #include "libc/sysv/consts/ex.h"
 #include "libc/sysv/consts/exit.h"
-#include "libc/sysv/consts/f.h"
 #include "libc/sysv/consts/fileno.h"
-#include "libc/sysv/consts/itimer.h"
-#include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/poll.h"
 #include "libc/sysv/consts/prio.h"
 #include "libc/sysv/consts/sig.h"
-#include "libc/sysv/consts/w.h"
 #include "libc/thread/thread.h"
 #include "libc/time.h"
 #include "libc/x/xasprintf.h"
 #include "libc/x/xsigaction.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "third_party/getopt/getopt.internal.h"
+#include "third_party/libcxx/__atomic/atomic.h"
 #include "third_party/libcxx/vector"
 #include "tool/viz/lib/knobs.h"
 
@@ -111,7 +108,9 @@ AUTHORS\n\
 #define DYN     240
 #define DXN     256
 #define FPS     60.0988
-#define HZ      1789773
+#define CPUHZ   1789773
+#define SRATE   44100
+#define ABUFZ   ((int)(SRATE / FPS) + 1)
 #define GAMMA   2.2
 #define CTRL(C) ((C) ^ 0100)
 #define ALT(C)  ((033 << 010) | (C))
@@ -121,25 +120,11 @@ typedef uint8_t u8;
 typedef uint16_t u16;
 typedef uint32_t u32;
 
-static const struct itimerval kNesFps = {
-    {0, 1. / FPS * 1e6},
-    {0, 1. / FPS * 1e6},
-};
-
-struct Frame {
-  char *p, *w, *mem;
-};
-
 struct Action {
   int code;
   int wait;
 };
 
-struct Audio {
-  size_t i;
-  int16_t p[65536];
-};
-
 struct Status {
   int wait;
   char text[80];
@@ -150,32 +135,33 @@ struct ZipGames {
   char** p;
 };
 
-static int frame_;
-static int playfd_;
-static int playpid_;
-static size_t vtsize_;
+static const struct timespec kNesFps = {0, 1. / FPS * 1e9};
+
 static bool artifacts_;
 static long tyn_, txn_;
-static struct Frame vf_[2];
-static struct Audio audio_;
 static const char* inputfn_;
 static struct Status status_;
 static volatile bool exited_;
-static volatile bool timeout_;
 static volatile bool resized_;
+static struct CosmoAudio* ca_;
 static struct TtyRgb* ttyrgb_;
 static unsigned char *R, *G, *B;
 static struct ZipGames zipgames_;
 static struct Action arrow_, button_;
 static struct SamplingSolution* ssy_;
 static struct SamplingSolution* ssx_;
-static unsigned char pixels_[3][DYN][DXN];
+static unsigned char (*pixels_)[3][DYN][DXN];
 static unsigned char palette_[3][64][512][3];
 static int joy_current_[2], joy_next_[2], joypos_[2];
 
 static int keyframes_ = 10;
 static enum TtyBlocksSelection blocks_ = kTtyBlocksUnicode;
-static enum TtyQuantizationAlgorithm quant_ = kTtyQuantTrue;
+static enum TtyQuantizationAlgorithm quant_ = kTtyQuantXterm256;
+
+static struct timespec deadline_;
+static std::atomic<void*> pixels_ready_;
+static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
 static int Clamp(int v) {
   return MAX(0, MIN(255, v));
@@ -229,73 +215,39 @@ void InitPalette(void) {
           rgbc[u] = FixGamma(y / 1980. + i * A[u] / 9e6 + q * B[u] / 9e6);
         }
         matvmul3(rgbd65, lightbulb, rgbc);
-        for (u = 0; u < 3; ++u) {
+        for (u = 0; u < 3; ++u)
           palette_[o][p1][p0][u] = Clamp(rgbd65[u] * 255);
-        }
       }
     }
   }
 }
 
-static ssize_t Write(int fd, const void* p, size_t n) {
-  int rc;
-  sigset_t ss, oldss;
-  sigfillset(&ss);
-  sigprocmask(SIG_SETMASK, &ss, &oldss);
-  rc = write(fd, p, n);
-  sigprocmask(SIG_SETMASK, &oldss, 0);
-  return rc;
-}
-
 static void WriteString(const char* s) {
-  Write(STDOUT_FILENO, s, strlen(s));
+  write(STDOUT_FILENO, s, strlen(s));
 }
 
 void Exit(int rc) {
   WriteString("\r\n\e[0m\e[J");
-  if (rc && errno) {
+  if (rc && errno)
     fprintf(stderr, "%s%s\r\n", "error: ", strerror(errno));
-  }
   exit(rc);
 }
 
 void Cleanup(void) {
   ttyraw((enum TtyRawFlags)(-1u));
   ttyshowcursor(STDOUT_FILENO);
-  if (playpid_) {
-    kill(playpid_, SIGKILL);
-    close(playfd_);
-    playfd_ = -1;
-  }
+  cosmoaudio_close(ca_);
+  ca_ = 0;
 }
 
 void OnCtrlC(void) {
   exited_ = true;
 }
 
-void OnTimer(void) {
-  timeout_ = true;
-}
-
 void OnResize(void) {
   resized_ = true;
 }
 
-void OnPiped(void) {
-  exited_ = true;
-}
-
-void OnSigChld(void) {
-  waitpid(-1, 0, WNOHANG);
-  close(playfd_);
-  playpid_ = 0;
-  playfd_ = -1;
-}
-
-void InitFrame(struct Frame* f) {
-  f->p = f->w = f->mem = (char*)realloc(f->mem, vtsize_);
-}
-
 long ChopAxis(long dn, long sn) {
   while (HALF(sn) > dn) {
     sn = HALF(sn);
@@ -318,11 +270,6 @@ void GetTermSize(void) {
   G = (unsigned char*)realloc(G, tyn_ * txn_);
   B = (unsigned char*)realloc(B, tyn_ * txn_);
   ttyrgb_ = (struct TtyRgb*)realloc(ttyrgb_, tyn_ * txn_ * 4);
-  vtsize_ = ((tyn_ * txn_ * strlen("\e[48;2;255;48;2;255m▄")) +
-             (tyn_ * strlen("\e[0m\r\n")) + 128);
-  frame_ = 0;
-  InitFrame(&vf_[0]);
-  InitFrame(&vf_[1]);
   WriteString("\e[0m\e[H\e[J");
   resized_ = false;
 }
@@ -330,11 +277,7 @@ void GetTermSize(void) {
 void IoInit(void) {
   GetTermSize();
   xsigaction(SIGINT, (void*)OnCtrlC, 0, 0, NULL);
-  xsigaction(SIGPIPE, (void*)OnPiped, 0, 0, NULL);
   xsigaction(SIGWINCH, (void*)OnResize, 0, 0, NULL);
-  xsigaction(SIGALRM, (void*)OnTimer, 0, 0, NULL);
-  xsigaction(SIGCHLD, (void*)OnSigChld, 0, 0, NULL);
-  setitimer(ITIMER_REAL, &kNesFps, NULL);
   ttyhidecursor(STDOUT_FILENO);
   ttyraw(kTtySigs);
   ttyquantsetup(quant_, kTtyQuantRgb, blocks_);
@@ -471,81 +414,29 @@ ssize_t ReadKeyboard(void) {
   return rc;
 }
 
-bool HasVideo(struct Frame* f) {
-  return f->w < f->p;
-}
-
-bool HasPendingVideo(void) {
-  return HasVideo(&vf_[0]) || HasVideo(&vf_[1]);
-}
-
-bool HasPendingAudio(void) {
-  return playpid_ && audio_.i;
-}
-
-struct Frame* FlipFrameBuffer(void) {
-  frame_ = !frame_;
-  return &vf_[frame_];
-}
-
-void TransmitVideo(void) {
-  ssize_t rc;
-  struct Frame* f;
-  f = &vf_[frame_];
-  if (!HasVideo(f))
-    f = FlipFrameBuffer();
-  if ((rc = Write(STDOUT_FILENO, f->w, f->p - f->w)) != -1) {
-    f->w += rc;
-  } else if (errno == EAGAIN) {
-    // slow teletypewriter
-  } else if (errno == EPIPE) {
-    Exit(0);
-  }
-}
-
-void TransmitAudio(void) {
-  ssize_t rc;
-  if (!playpid_)
-    return;
-  if (!audio_.i)
-    return;
-  if (playfd_ == -1)
-    return;
-  if ((rc = Write(playfd_, audio_.p, audio_.i * sizeof(short))) != -1) {
-    rc /= sizeof(short);
-    memmove(audio_.p, audio_.p + rc, (audio_.i - rc) * sizeof(short));
-    audio_.i -= rc;
-  } else if (errno == EPIPE) {
-    kill(playpid_, SIGKILL);
-    close(playfd_);
-    playfd_ = -1;
-    Exit(0);
-  }
-}
-
-void ScaleVideoFrameToTeletypewriter(void) {
+void ScaleVideoFrameToTeletypewriter(unsigned char (*pixels)[3][DYN][DXN]) {
   long y, x, yn, xn;
   yn = DYN, xn = DXN;
   while (HALF(yn) > tyn_ || HALF(xn) > txn_) {
     if (HALF(xn) > txn_) {
-      Magikarp2xX(DYN, DXN, pixels_[0], yn, xn);
-      Magikarp2xX(DYN, DXN, pixels_[1], yn, xn);
-      Magikarp2xX(DYN, DXN, pixels_[2], yn, xn);
+      Magikarp2xX(DYN, DXN, (*pixels)[0], yn, xn);
+      Magikarp2xX(DYN, DXN, (*pixels)[1], yn, xn);
+      Magikarp2xX(DYN, DXN, (*pixels)[2], yn, xn);
       xn = HALF(xn);
     }
     if (HALF(yn) > tyn_) {
-      Magikarp2xY(DYN, DXN, pixels_[0], yn, xn);
-      Magikarp2xY(DYN, DXN, pixels_[1], yn, xn);
-      Magikarp2xY(DYN, DXN, pixels_[2], yn, xn);
+      Magikarp2xY(DYN, DXN, (*pixels)[0], yn, xn);
+      Magikarp2xY(DYN, DXN, (*pixels)[1], yn, xn);
+      Magikarp2xY(DYN, DXN, (*pixels)[2], yn, xn);
       yn = HALF(yn);
     }
   }
-  GyaradosUint8(tyn_, txn_, R, DYN, DXN, pixels_[0], tyn_, txn_, yn, xn, 0, 255,
-                ssy_, ssx_, true);
-  GyaradosUint8(tyn_, txn_, G, DYN, DXN, pixels_[1], tyn_, txn_, yn, xn, 0, 255,
-                ssy_, ssx_, true);
-  GyaradosUint8(tyn_, txn_, B, DYN, DXN, pixels_[2], tyn_, txn_, yn, xn, 0, 255,
-                ssy_, ssx_, true);
+  GyaradosUint8(tyn_, txn_, R, DYN, DXN, (*pixels)[0], tyn_, txn_, yn, xn, 0,
+                255, ssy_, ssx_, true);
+  GyaradosUint8(tyn_, txn_, G, DYN, DXN, (*pixels)[1], tyn_, txn_, yn, xn, 0,
+                255, ssy_, ssx_, true);
+  GyaradosUint8(tyn_, txn_, B, DYN, DXN, (*pixels)[2], tyn_, txn_, yn, xn, 0,
+                255, ssy_, ssx_, true);
   for (y = 0; y < tyn_; ++y) {
     for (x = 0; x < txn_; ++x) {
       ttyrgb_[y * txn_ + x] =
@@ -562,57 +453,104 @@ void KeyCountdown(struct Action* a) {
   }
 }
 
-void PollAndSynchronize(void) {
-  do {
-    if (ReadKeyboard() == -1) {
-      if (errno != EINTR)
-        Exit(1);
-      if (exited_)
-        Exit(0);
-      if (resized_)
-        GetTermSize();
-    }
-  } while (!timeout_);
-  TransmitVideo();
-  TransmitAudio();
-  timeout_ = false;
-  KeyCountdown(&arrow_);
-  KeyCountdown(&button_);
-  joy_next_[0] = arrow_.code | button_.code;
-  joy_next_[1] = arrow_.code | button_.code;
-}
-
-void Raster(void) {
-  struct Frame* f;
+void Raster(unsigned char (*pixels)[3][DYN][DXN]) {
   struct TtyRgb bg = {0x12, 0x34, 0x56, 0};
   struct TtyRgb fg = {0x12, 0x34, 0x56, 0};
-  ScaleVideoFrameToTeletypewriter();
-  f = &vf_[!frame_];
-  f->p = f->w = f->mem;
-  f->p = stpcpy(f->p, "\e[0m\e[H");
-  f->p = ttyraster(f->p, ttyrgb_, tyn_, txn_, bg, fg);
+  ScaleVideoFrameToTeletypewriter(pixels);
+  char* ansi = (char*)malloc((tyn_ * txn_ * strlen("\e[48;2;255;48;2;255m▄")) +
+                             (tyn_ * strlen("\e[0m\r\n")) + 128);
+  char* p = ansi;
+  p = stpcpy(p, "\e[0m\e[H");
+  p = ttyraster(p, ttyrgb_, tyn_, txn_, bg, fg);
+  free(pixels);
   if (status_.wait) {
     status_.wait--;
-    f->p = stpcpy(f->p, "\e[0m\e[H");
-    f->p = stpcpy(f->p, status_.text);
+    p = stpcpy(p, "\e[0m\e[H");
+    p = stpcpy(p, status_.text);
+  }
+  size_t n = p - ansi;
+  ssize_t wrote;
+  for (size_t i = 0; i < n; i += wrote) {
+    if ((wrote = write(STDOUT_FILENO, ansi + i, n - i)) == -1) {
+      exited_ = true;
+      break;
+    }
+  }
+  free(ansi);
+}
+
+void* RasterThread(void* arg) {
+  sigset_t ss;
+  sigemptyset(&ss);
+  sigaddset(&ss, SIGINT);
+  sigaddset(&ss, SIGHUP);
+  sigaddset(&ss, SIGQUIT);
+  sigaddset(&ss, SIGTERM);
+  sigaddset(&ss, SIGPIPE);
+  sigprocmask(SIG_SETMASK, &ss, 0);
+  for (;;) {
+    unsigned char(*pixels)[3][DYN][DXN];
+    pthread_mutex_lock(&lock);
+    while (!(pixels = (unsigned char(*)[3][DYN][DXN])pixels_ready_.load()))
+      pthread_cond_wait(&cond, &lock);
+    pixels_ready_.store(0);
+    pthread_mutex_unlock(&lock);
+    if (resized_)
+      GetTermSize();
+    Raster(pixels);
   }
-  PollAndSynchronize();
 }
 
 void FlushScanline(unsigned py) {
-  if (py == DYN - 1) {
-    if (!timeout_) {
-      Raster();
-    }
-    timeout_ = false;
+  if (py != DYN - 1)
+    return;
+  pthread_mutex_lock(&lock);
+  if (!pixels_ready_) {
+    pixels_ready_.store(pixels_);
+    pixels_ = 0;
+    pthread_cond_signal(&cond);
   }
+  pthread_mutex_unlock(&lock);
+  if (!pixels_)
+    pixels_ = (unsigned char(*)[3][DYN][DXN])malloc(3 * DYN * DXN);
+  if (exited_)
+    Exit(0);
+  do {
+    struct timespec now = timespec_mono();
+    struct timespec remain = timespec_subz(deadline_, now);
+    int remain_ms = timespec_tomillis(remain);
+    struct pollfd fds[] = {{STDIN_FILENO, POLLIN}};
+    int got = poll(fds, 1, remain_ms);
+    if (got == -1) {
+      if (errno == EINTR)
+        continue;
+      Exit(1);
+    }
+    if (got == 1) {
+      do {
+        if (ReadKeyboard() == -1) {
+          if (errno == EINTR)
+            continue;
+          Exit(1);
+        }
+      } while (0);
+    }
+    KeyCountdown(&arrow_);
+    KeyCountdown(&button_);
+    joy_next_[0] = arrow_.code | button_.code;
+    joy_next_[1] = arrow_.code | button_.code;
+    now = timespec_mono();
+    do
+      deadline_ = timespec_add(deadline_, kNesFps);
+    while (timespec_cmp(deadline_, now) <= 0);
+  } while (0);
 }
 
 static void PutPixel(unsigned px, unsigned py, unsigned pixel, int offset) {
   static unsigned prev;
-  pixels_[0][py][px] = palette_[offset][prev % 64][pixel][2];
-  pixels_[1][py][px] = palette_[offset][prev % 64][pixel][1];
-  pixels_[2][py][px] = palette_[offset][prev % 64][pixel][0];
+  (*pixels_)[0][py][px] = palette_[offset][prev % 64][pixel][2];
+  (*pixels_)[1][py][px] = palette_[offset][prev % 64][pixel][1];
+  (*pixels_)[2][py][px] = palette_[offset][prev % 64][pixel][0];
   prev = pixel;
 }
 
@@ -1494,8 +1432,7 @@ void Tick() {  // Invoked at CPU's rate.
 // Mix the audio: Get the momentary sample from each channel and mix them.
 #define s(c) channels[c].Tick<c == 1 ? 0 : c>()
   auto v = [](float m, float n, float d) { return n != 0.f ? m / n : d; };
-  short sample =
-      30000 *
+  float sample =
       (v(95.88f, (100.f + v(8128.f, s(0) + s(1), -100.f)), 0.f) +
        v(159.79f,
          (100.f +
@@ -1504,7 +1441,19 @@ void Tick() {  // Invoked at CPU's rate.
        0.5f);
 #undef s
 
-  audio_.p[audio_.i = (audio_.i + 1) & (ARRAYLEN(audio_.p) - 1)] = sample;
+  // Relay audio to speaker.
+  static int buffer_position = 0;
+  static float audio_buffer[ABUFZ];
+  static double sample_counter = 0.0;
+  sample_counter += (double)SRATE / CPUHZ;
+  while (sample_counter >= 1.0) {
+    audio_buffer[buffer_position++] = sample;
+    sample_counter -= 1.0;
+    if (buffer_position == ABUFZ) {
+      cosmoaudio_write(ca_, audio_buffer, buffer_position);
+      buffer_position = 0;
+    }
+  }
 }
 
 }  // namespace APU
@@ -1716,8 +1665,8 @@ void Op() {
   if (!nmi_now)
     nmi_edge_detected = false;
 
-    // Define function pointers for each opcode (00..FF) and each interrupt
-    // (100,101,102)
+  // Define function pointers for each opcode (00..FF) and each interrupt
+  // (100,101,102)
 #define c(n) Ins<0x##n>, Ins<0x##n + 1>,
 #define o(n) c(n) c(n + 2) c(n + 4) c(n + 6)
   static void (*const i[0x108])() = {
@@ -1745,9 +1694,6 @@ char* GetLine(void) {
 
 int PlayGame(const char* romfile, const char* opt_tasfile) {
   FILE* fp;
-  int devnull;
-  int pipefds[2];
-  const char* ffplay;
   inputfn_ = opt_tasfile;
 
   if (!(fp = fopen(romfile, "rb"))) {
@@ -1760,47 +1706,29 @@ int PlayGame(const char* romfile, const char* opt_tasfile) {
     return 3;
   }
 
+  // initialize screen
+  pixels_ = (unsigned char(*)[3][DYN][DXN])malloc(3 * DYN * DXN);
   InitPalette();
 
-  // open speaker
-  // todo: this needs plenty of work
-  if (!IsWindows()) {
-    if ((ffplay = commandvenv("FFPLAY", "ffplay"))) {
-      devnull = open("/dev/null", O_WRONLY | O_CLOEXEC);
-      pipe2(pipefds, O_CLOEXEC);
-      if (!(playpid_ = fork())) {
-        const char* const args[] = {
-            ffplay,                  //
-            "-nodisp",               //
-            "-loglevel", "quiet",    //
-            "-ac",       "1",        //
-            "-ar",       "1789773",  //
-            "-f",        "s16le",    //
-            "pipe:",                 //
-            NULL,
-        };
-        dup2(pipefds[0], 0);
-        dup2(devnull, 1);
-        dup2(devnull, 2);
-        execv(ffplay, (char* const*)args);
-        abort();
-      }
-      close(pipefds[0]);
-      playfd_ = pipefds[1];
-    } else {
-      fputs("\nWARNING\n\
-\n\
-  Need `ffplay` command to play audio\n\
-  Try `sudo apt install ffmpeg` on Linux\n\
-  You can specify it on `PATH` or in `FFPLAY`\n\
-\n\
-Press enter to continue without sound: ",
-            stdout);
-      fflush(stdout);
-      GetLine();
-    }
+  // start raster thread
+  errno_t err;
+  pthread_t th;
+  if ((err = pthread_create(&th, 0, RasterThread, 0))) {
+    fprintf(stderr, "pthread_create: %s\n", strerror(err));
+    exit(1);
   }
 
+  // open speaker
+  struct CosmoAudioOpenOptions cao = {};
+  cao.sizeofThis = sizeof(struct CosmoAudioOpenOptions);
+  cao.deviceType = kCosmoAudioDeviceTypePlayback;
+  cao.sampleRate = SRATE;
+  cao.channels = 1;
+  cosmoaudio_open(&ca_, &cao);
+
+  // initialize time
+  deadline_ = timespec_add(timespec_mono(), kNesFps);
+
   // Read the ROM file header
   u8 rom16count = fgetc(fp);
   u8 vrom8count = fgetc(fp);
@@ -1907,9 +1835,8 @@ int SelectGameFromZip(void) {
   int i, rc;
   char *line, *uri;
   fputs("\nCOSMOPOLITAN NESEMU1\n\n", stdout);
-  for (i = 0; i < (int)zipgames_.i; ++i) {
+  for (i = 0; i < (int)zipgames_.i; ++i)
     printf("  [%d] %s\n", i, zipgames_.p[i]);
-  }
   fputs("\nPlease choose a game (or CTRL-C to quit) [default 0]: ", stdout);
   fflush(stdout);
   rc = 0;
@@ -1932,9 +1859,8 @@ int main(int argc, char** argv) {
   } else if (optind < argc) {
     rc = PlayGame(argv[optind], NULL);
   } else {
-    if (!FindZipGames()) {
+    if (!FindZipGames())
       PrintUsage(0, stderr);
-    }
     rc = SelectGameFromZip();
   }
   return rc;
diff --git a/examples/nproc.c b/examples/nproc.c
new file mode 100644
index 000000000..73ad91934
--- /dev/null
+++ b/examples/nproc.c
@@ -0,0 +1,15 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+#include <cosmo.h>
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  printf("%d\n", __get_cpu_count());
+}
diff --git a/examples/package/lib/myasm.S b/examples/package/lib/myasm.S
index acb21b98e..f0e0cad66 100644
--- a/examples/package/lib/myasm.S
+++ b/examples/package/lib/myasm.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Example assembly function.
 //
diff --git a/examples/parsefloat.c b/examples/parsefloat.c
index c9f049aef..eb8e21aaa 100644
--- a/examples/parsefloat.c
+++ b/examples/parsefloat.c
@@ -1,3 +1,12 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
 #include <stdio.h>
 
 #define PARSE_AND_PRINT(type, scan_fmt, print_fmt, str)      \
diff --git a/examples/pause.c b/examples/pause.c
index be13f5f45..a36ccdec1 100644
--- a/examples/pause.c
+++ b/examples/pause.c
@@ -7,10 +7,10 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/sigaction.h"
-#include "libc/fmt/itoa.h"
-#include "libc/str/str.h"
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
 
 volatile int g_sig;
 
@@ -21,16 +21,13 @@ void OnSig(int sig) {
 int main(int argc, char *argv[]) {
 
   // listen for all signals
-  for (int sig = 1; sig <= NSIG; ++sig) {
+  for (int sig = 1; sig <= NSIG; ++sig)
     signal(sig, OnSig);
-  }
 
   // wait for a signal
-  char ibuf[12];
-  FormatInt32(ibuf, getpid());
-  tinyprint(2, "waiting for signal to be sent to ", ibuf, "\n", NULL);
+  printf("waiting for signal to be sent to my pid %d\n", getpid());
   pause();
 
   // report the signal
-  tinyprint(1, "got ", strsignal(g_sig), "\n", NULL);
+  printf("got %s\n", strsignal(g_sig));
 }
diff --git a/examples/picol.c b/examples/picol.c
index fd54cca53..449e98ed4 100644
--- a/examples/picol.c
+++ b/examples/picol.c
@@ -32,12 +32,9 @@
  * . Formatted as per Cosmopolitan's standards.
  */
 
-#include "libc/fmt/conv.h"
-#include "libc/log/log.h"
-#include "libc/mem/mem.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 
 enum { PICOL_OK, PICOL_ERR, PICOL_RETURN, PICOL_BREAK, PICOL_CONTINUE };
 enum { PT_ESC, PT_STR, PT_CMD, PT_VAR, PT_SEP, PT_EOL, PT_EOF };
diff --git a/examples/printargs.c b/examples/printargs.c
index 60ce148ed..d65954fcb 100644
--- a/examples/printargs.c
+++ b/examples/printargs.c
@@ -7,7 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/runtime/runtime.h"
+#include <cosmo.h>
 
 int main() {
   __printargs("");
diff --git a/examples/romanize.c b/examples/romanize.c
new file mode 100644
index 000000000..2b7df6561
--- /dev/null
+++ b/examples/romanize.c
@@ -0,0 +1,1022 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+#include <wchar.h>
+#include <wctype.h>
+
+/**
+ * @fileoverview Roman Transliteration, e.g.
+ *
+ *     $ echo 'gaius julius cæsar' | o//examples/romanize
+ *     CAIVS IVLIVS CAESAR
+ *     $ echo 'гаиус юлиус цаесар' | o//examples/romanize
+ *     CAIVS IVLIVS TSAESAR
+ *     $ echo 'عودة أبو تايه' | o//examples/romanize
+ *     EVVDTA AEBVV TAIH
+ *
+ */
+
+#define PASSPORT 0
+
+enum Mode {
+  kArchaic,
+  kOld,
+  kClassical,
+  kMedieval,
+  kModern,
+} mode = kModern;
+
+bool IsHindiConsonant(wint_t c) {
+  switch (c) {
+    case 0x915:  // क
+    case 0x916:  // ख
+    case 0x917:  // ग
+    case 0x918:  // घ
+    case 0x91a:  // च
+    case 0x91b:  // छ
+    case L'ज':
+    case L'झ':
+    case L'ट':
+    case L'ठ':
+    case L'ड':
+    case L'ढ':
+    case L'ण':
+    case 0x924:  // त
+    case L'थ':
+    case L'द':
+    case L'ध':
+    case L'न':
+    case L'प':
+    case L'फ':
+    case L'ब':
+    case 0x92d:  // भ
+    case L'म':
+    case L'य':
+    case 0x930:  // र
+    case L'ल':
+    case L'व':
+    case L'श':
+    case L'ष':
+    case L'स':
+    case L'ह':
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool IsHindiMagicConsonant(wint_t c) {
+  switch (c) {
+    case 0x902:  // ं
+      return true;
+    default:
+      return false;
+  }
+}
+
+int main(int argc, char* argv[]) {
+  wint_t c1, c2;
+  while ((c1 = towupper(fgetwc(stdin))) != -1) {
+    if (!iswcntrl(c1)) {
+      c2 = fgetwc(stdin);
+      if (mode < kMedieval || !isascii(c2))
+        c2 = towupper(c2);
+    } else {
+      c2 = 0;
+    }
+    switch (c1) {
+      case '.':
+        if (c2 == ' ') {
+          fputwc(L'·', stdout);
+          continue;
+        }
+        break;
+      case '"':
+      case '\'':
+      case ',':
+      case ';':
+      case 0xFEFF:  // ZERO WIDTH NO-BREAK SPACE (UTF-8 BOM)
+      case 0x200E:  // LEFT-TO-RIGHT MARK
+      case 0x200F:  // RIGHT-TO-LEFT MARK
+        fputwc(c1, stdout);
+        break;
+      case L'Ĵ':
+      case L'Ј':
+      case 'J':
+      J:
+        if (mode >= kModern) {
+          fputc('J', stdout);
+        } else {
+          fputc('I', stdout);
+        }
+        break;
+      case L'Ũ':
+      case L'Ū':
+      case L'Ŭ':
+      case L'Ů':
+      case L'Ű':
+      case L'Ų':
+      case L'Ù':
+      case L'Ú':
+      case L'Û':
+      case L'ў':
+      case L'У':
+      case 0x046A:
+      case 'U':
+      U:
+        if (mode >= kMedieval) {
+          fputc('U', stdout);
+        } else {
+          fputc('V', stdout);
+        }
+        break;
+      case L'Ŵ':
+      case L'Ƿ':
+      case 'W':
+      W:
+        if (mode >= kMedieval) {
+          fputc('W', stdout);
+        } else {
+          fputc('V', stdout);
+          fputc('V', stdout);
+        }
+        break;
+      case 'Y':
+      case L'Ý':
+      case L'Ŷ':
+      case L'Ÿ':
+      case L'Ы':
+      Y:
+        if (mode == kClassical) {
+          fputc('Y', stdout);
+        } else {
+          fputc('I', stdout);
+        }
+        break;
+      case L'Ẍ':
+      case L'ẍ':
+      case L'Ẋ':
+      case L'ẋ':
+      case 'X':
+        fputc('X', stdout);
+        break;
+      case L'Ź':
+      case L'Ż':
+      case L'Ž':
+      case L'З':
+      case 'Z':
+      Z:
+        if (mode == kOld) {
+          fputc('G', stdout);
+        } else {
+          fputc('Z', stdout);
+        }
+        break;
+      case L'Ĝ':
+      case L'Ğ':
+      case L'Ġ':
+      case L'Ģ':
+      case L'Ґ':
+      case L'Г':
+      case 0x0492:
+      case 'G':
+        if (mode >= kOld) {
+          fputc('G', stdout);
+        } else if (c2 == 'U' || c2 == 'O') {
+          fputc('Q', stdout);
+        } else {
+          fputc('C', stdout);
+        }
+        break;
+      case L'Ķ':
+      case L'К':
+      case 'K':
+        if (mode >= kMedieval) {
+          fputc('K', stdout);
+          break;
+        }
+        if (c2 == 'O') {
+          fputc('Q', stdout);
+          break;
+        }
+        if (c2 == 'N') {
+          break;
+        }
+        /* fallthrough */
+      case 'C':
+      case 0x04BA:
+        switch (c2) {
+          case 'A':
+            if (mode >= kOld) {
+              fputc('C', stdout);
+            } else {
+              fputc('K', stdout);
+            }
+            break;
+          /* case 'O': */
+          case 'U':
+          case 'V':
+            fputc('Q', stdout);
+            break;
+          default:
+            fputc('C', stdout);
+            break;
+        }
+        break;
+      case L'Æ':
+      case L'Ä':
+        fputc('A', stdout);
+        fputc('E', stdout);
+        break;
+      case L'IJ':
+        fputc('I', stdout);
+        goto J;
+      case L'Þ':
+        fputc('T', stdout);
+        fputc('H', stdout);
+        break;
+      case L'Œ':
+      case L'Ö':
+      case L'Ø':
+        fputc('O', stdout);
+        fputc('E', stdout);
+        break;
+      case L'Ü':
+        if (mode >= kMedieval) {
+          fputc('U', stdout);
+        } else {
+          fputc('V', stdout);
+        }
+        fputc('E', stdout);
+        break;
+      case L'ẞ':
+        fputc('S', stdout);
+        fputc('S', stdout);
+        break;
+      case L'À':
+      case L'Á':
+      case L'Â':
+      case L'Ã':
+      case L'Ā':
+      case L'Ă':
+      case L'Ą':
+      case L'А':
+        fputc('A', stdout);
+        break;
+      case L'Ç':
+      case L'Ć':
+      case L'Ĉ':
+      case L'Ċ':
+      case L'Č':
+        fputc('C', stdout);
+        break;
+      case L'È':
+      case L'É':
+      case L'Ê':
+      case L'Ë':
+      case L'Ē':
+      case L'Ĕ':
+      case L'Ė':
+      case L'Ę':
+      case L'Ě':
+        fputc('E', stdout);
+        break;
+      case L'Ì':
+      case L'Í':
+      case L'Î':
+      case L'Ï':
+        fputc('I', stdout);
+        break;
+      case L'Ð':
+      case L'Ď':
+        fputc('D', stdout);
+        break;
+      case L'Ñ':
+      case L'Ń':
+      case L'Ņ':
+      case L'Ň':
+      case L'Ŋ':
+        fputc('N', stdout);
+        break;
+      case L'Ò':
+      case L'Ó':
+      case L'Ô':
+      case L'Õ':
+      case L'Ō':
+      case L'Ŏ':
+      case L'Ő':
+        fputc('O', stdout);
+        break;
+      default:
+        fputwc(c1, stdout);
+        break;
+      case L'Ĥ':
+      case L'Ħ':
+        fputc('H', stdout);
+        break;
+      case L'Ĩ':
+      case L'Ī':
+      case L'Ĭ':
+      case L'Į':
+      case L'İ':
+      case L'I':
+      case L'И':
+      case L'Й':
+        fputc('I', stdout);
+        break;
+      case L'Ĺ':
+      case L'Ļ':
+      case L'Ľ':
+      case L'Ŀ':
+      case L'Ł':
+        fputc('L', stdout);
+        break;
+      case L'Ŕ':
+      case L'Ŗ':
+      case L'Ř':
+        fputc('R', stdout);
+        break;
+      case L'Ś':
+      case L'Ŝ':
+      case L'Ş':
+      case L'Š':
+        fputc('S', stdout);
+        break;
+      case L'Ţ':
+      case L'Ť':
+      case L'Ŧ':
+        fputc('T', stdout);
+        break;
+      case L'Ё':
+        fputc('E', stdout);
+        break;
+      case L'Ћ':
+        fputc('D', stdout);
+        break;
+      case L'Є':
+        fputc('I', stdout);
+        fputc('E', stdout);
+        break;
+      case L'Ѕ':
+        fputc('D', stdout);
+        fputc('Z', stdout);
+        break;
+      case L'І':
+        fputc('I', stdout);
+        break;
+      case L'Ї':
+        fputc('I', stdout);
+        break;
+      case L'Љ':
+        fputc('L', stdout);
+        if (mode >= kMedieval) {
+          fputc('J', stdout);
+        } else {
+          fputc('I', stdout);
+        }
+        break;
+      case L'Њ':
+        fputc('N', stdout);
+        goto J;
+      case L'Ќ':
+        fputc('K', stdout);
+        break;
+      case L'Џ':
+        fputc('D', stdout);
+        goto Z;
+      case L'Б':
+        fputc('B', stdout);
+        break;
+      case L'В':
+        fputc('V', stdout);
+        break;
+      case L'Д':
+        fputc('D', stdout);
+        break;
+      case L'Е':
+        fputc('E', stdout);
+        break;
+      case L'Ж':
+        if (mode == kOld) {
+          fputc('G', stdout);
+        } else {
+          fputc('Z', stdout);
+        }
+        fputc('H', stdout);
+        break;
+      case L'Л':
+        fputc('L', stdout);
+        break;
+      case L'М':
+        fputc('M', stdout);
+        break;
+      case L'Н':
+        fputc('N', stdout);
+        break;
+      case L'О':
+        fputc('O', stdout);
+        break;
+      case L'П':
+        fputc('P', stdout);
+        break;
+      case L'Р':
+        fputc('R', stdout);
+        break;
+      case L'С':
+        fputc('S', stdout);
+        break;
+      case L'Т':
+        fputc('T', stdout);
+        break;
+      case L'Ф':
+        fputc('F', stdout);
+        break;
+      case L'Х':
+        /* fputc('K', stdout); */
+        fputc('H', stdout);
+        break;
+      case L'Ц':
+        fputc('T', stdout);
+        fputc('S', stdout);
+        break;
+      case L'Ч':
+        fputc('C', stdout);
+        fputc('H', stdout);
+        break;
+      case L'Ш':
+        fputc('S', stdout);
+        fputc('H', stdout);
+        break;
+      case L'Щ':
+        fputc('S', stdout);
+        fputc('H', stdout);
+        fputc('C', stdout);
+        fputc('H', stdout);
+        break;
+      case L'Ъ':
+        fputc('I', stdout);
+        fputc('E', stdout);
+        break;
+      case L'Э':
+        fputc('E', stdout);
+        break;
+      case L'Ю':
+        fputc('I', stdout);
+        goto U;
+      case L'Я':
+        fputc('I', stdout);
+        fputc('A', stdout);
+        break;
+      case L'Ȝ':
+        if (mode >= kOld) {
+          fputc('G', stdout);
+        } else if (mode == kArchaic) {
+          fputc('C', stdout);
+        }
+        fputc('H', stdout);
+        break;
+      case L'ſ':
+        fputc('S', stdout);
+        break;
+      case 0x0621:  // hamza
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('E', stdout);
+        break;
+      case 0x0622:  // alef with madda above
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('A', stdout);
+        fputc('A', stdout);
+        break;
+      case 0x0623:  // alef with hamza above
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('A', stdout);
+        fputc('E', stdout);
+        break;
+      case 0x0624:  // waw with hamza above
+        goto U;
+      case 0x0625:  // alef with hamza below
+        fputc('I', stdout);
+        break;
+      case 0x0626:  // yeh with hamza above
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('I', stdout);
+        break;
+      case 0x0627:  // alef
+        fputc('A', stdout);
+        break;
+      case 0x0628:  // beh
+        fputc('B', stdout);
+        break;
+      case 0x0629:  // teh marbuta
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('T', stdout);
+        fputc('A', stdout);
+        break;
+      case 0x062A:  // teh
+        fputc('T', stdout);
+        break;
+      case 0x062B:  // theh
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('T', stdout);
+        fputc('H', stdout);
+        break;
+      case 0x062C:  // jeem
+        goto J;
+      case 0x062D:  // hah
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('H', stdout);
+        break;
+      case 0x062E:  // khah
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('K', stdout);
+        fputc('H', stdout);
+        break;
+      case 0x062F:  // dal
+        fputc('D', stdout);
+        break;
+      case 0x0630:  // thal
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('D', stdout);
+        fputc('H', stdout);
+        break;
+      case 0x0631:  // reh
+        fputc('R', stdout);
+        break;
+      case 0x0632:  // zain
+        fputc('Z', stdout);
+        break;
+      case 0x0633:  // seen
+        fputc('S', stdout);
+        break;
+      case 0x0634:  // sheen
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('S', stdout);
+        fputc('H', stdout);
+        break;
+      case 0x0635:  // sad
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('S', stdout);
+        fputc('S', stdout);
+        break;
+      case 0x0636:  // dad
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('D', stdout);
+        fputc('Z', stdout);
+        break;
+      case 0x0637:  // tah
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('T', stdout);
+        fputc('T', stdout);
+        break;
+      case 0x0638:  // zah
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('Z', stdout);
+        fputc('Z', stdout);
+        break;
+      case 0x0639:  // ain
+        fputc('E', stdout);
+        break;
+      case 0x063A:  // ghain
+        fputc('G', stdout);
+        break;
+      case 0x0641:  // feh
+        fputc('F', stdout);
+        break;
+      case 0x0642:  // qaf
+        fputc('Q', stdout);
+        break;
+      case 0x0643:  // kaf
+        fputc('K', stdout);
+        break;
+      case 0x0644:  // lam
+        fputc('L', stdout);
+        break;
+      case 0x0645:  // meem
+        fputc('M', stdout);
+        break;
+      case 0x0646:  // noon
+        fputc('N', stdout);
+        break;
+      case 0x0647:  // heh
+        fputc('H', stdout);
+        break;
+      case 0x0648:  // waw
+        goto W;
+      case 0x0649:  // alef maksura
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('A', stdout);
+        goto Y;
+      case 0x064A:  // yeh
+        goto Y;
+      case 0x0671:  // alef wasla
+        if (PASSPORT)
+          fputc('X', stdout);
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('A', stdout);
+        break;
+      case 0x0679:  // tteh
+        if (PASSPORT)
+          fputc('X', stdout);
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('T', stdout);
+        break;
+      case 0x067C:  // teh with ring
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('R', stdout);
+        fputc('T', stdout);
+        break;
+      case 0x067E:  // peh
+        fputc('P', stdout);
+        break;
+      case 0x0681:  // hah with hamza above
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('K', stdout);
+        fputc('E', stdout);
+        break;
+      case 0x0685:  // hah with 3 dots above
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('X', stdout);
+        fputc('H', stdout);
+        break;
+      case 0x0686:  // tcheh
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('C', stdout);
+        break;
+      case 0x0688:  // ddal
+        if (PASSPORT)
+          fputc('X', stdout);
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('D', stdout);
+        break;
+      case 0x0689:  // dal with ring
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('D', stdout);
+        fputc('R', stdout);
+        break;
+      case 0x0691:  // rreh
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('X', stdout);
+        fputc('R', stdout);
+        break;
+      case 0x0693:  // reh with ring
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('R', stdout);
+        fputc('R', stdout);
+        break;
+      case 0x0696:  // reh with dot below and dot above
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('R', stdout);
+        fputc('X', stdout);
+        break;
+      case 0x0698:  // jeh
+        if (PASSPORT)
+          fputc('X', stdout);
+        goto J;
+      case 0x069A:  // seen with dot below and dot above
+        if (PASSPORT)
+          fputc('X', stdout);
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('S', stdout);
+        break;
+      case 0x06A9:  // keheh
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('K', stdout);
+        fputc('K', stdout);
+        break;
+      case 0x06AB:  // kaf with ring
+        if (PASSPORT)
+          fputc('X', stdout);
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('K', stdout);
+        break;
+      case 0x06AD:  // ng
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('N', stdout);
+        fputc('G', stdout);
+        break;
+      case 0x06AF:  // gaf
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('G', stdout);
+        fputc('G', stdout);
+        break;
+      case 0x06BA:  // noon ghunna
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('N', stdout);
+        fputc('N', stdout);
+        break;
+      case 0x06BC:  // noon with ring
+        if (PASSPORT)
+          fputc('X', stdout);
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('N', stdout);
+        break;
+      case 0x06BE:  // heh doachashmee
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('D', stdout);
+        fputc('O', stdout);
+        break;
+      case 0x06C0:  // heh with yeh above
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('Y', stdout);
+        fputc('H', stdout);
+        break;
+      case 0x06C1:  // heh goal
+        if (PASSPORT)
+          fputc('X', stdout);
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('G', stdout);
+        break;
+      case 0x06C2:  // heh goal with hamza above
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('G', stdout);
+        fputc('E', stdout);
+        break;
+      case 0x06C3:  // teh marbuta goal
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('T', stdout);
+        fputc('G', stdout);
+        break;
+      case 0x06CC:  // farsi yeh
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('Y', stdout);
+        fputc('A', stdout);
+        break;
+      case 0x06CD:  // yeh with tail
+        if (PASSPORT)
+          fputc('X', stdout);
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('Y', stdout);
+        break;
+      case 0x06D0:  // yeh
+        goto Y;
+      case 0x06D2:  // yeh barree
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('Y', stdout);
+        fputc('B', stdout);
+        break;
+      case 0x06D3:  // yeh barree with hamza above
+        if (PASSPORT)
+          fputc('X', stdout);
+        fputc('B', stdout);
+        fputc('E', stdout);
+        break;
+      case 0x069C:  // seen with 3 dots below and 3 dots above
+      case 0x06A2:  // feh with dot moved below
+      case 0x06A7:  // qaf with dot above
+      case 0x06A8:  // qaf with 3 dots above
+      case 0x0651:  // shadda
+      case 0x0652:  // sukun
+      case 0x0670:  // superscript alef
+      case 0x064B:  // fathatan
+      case 0x064C:  // dammatan
+      case 0x064D:  // kasratan
+      case 0x064E:  // fatha
+      case 0x064F:  // damma
+      case 0x0650:  // kasra
+      case 0x0640:  // tatwheel
+        break;
+
+      //
+      // HINDI
+      //
+      // The following C code for the romanization of Hindi was designed
+      // and written by vasant and jart on 2024-08-20.
+      //
+      // भारत देश का नाम है,
+      // तिरंगा झंडा इसकी शान है।
+      // अलग-अलग हैं बोली-भाषा,
+      // कहीं पहाड़, तो कहीं मैदान हैं।
+      // बहुत बड़ा है देश हमारा,
+      // परम्पराओं पर हमको अभिमान है।
+      // अनेकता में एकता,
+      // यही हमारा संविधान है।
+      //
+      // BHARAT DESH KA NAM HAI,
+      // TIRANGA JHANDA ISAKII SHAN HAI.
+      // ALAG-ALAG HAIN BOLII-BHASSA,
+      // KAHIIN PAHAD, TO KAHIIN MAIDAN HAIN.
+      // BAHUT BADA HAI DESH HAMARA,
+      // PARAMPARAON PAR HAMAKO ABHIMAN HAI.
+      // ANEKATA MEN EKATA,
+      // YAHII HAMARA SANVIDHAN HAI.
+      //
+
+      // Hindi Consonants
+      case 0x915:  // क
+        fputs("K", stdout);
+        break;
+      case 0x916:  // ख
+        fputs("KH", stdout);
+        break;
+      case 0x917:  // ग
+        fputs("G", stdout);
+        break;
+      case 0x918:  // घ
+        fputs("GH", stdout);
+        break;
+      case 0x91a:  // च
+        fputs("CH", stdout);
+        break;
+      case 0x91b:  // छ
+        fputs("CHH", stdout);
+        break;
+      case L'ज':
+        fputs("J", stdout);
+        break;
+      case L'झ':
+        fputs("JH", stdout);
+        break;
+      case L'ट':
+        fputs("T", stdout);
+        break;
+      case L'ठ':
+        fputs("TH", stdout);
+        break;
+      case L'ड':
+        fputs("D", stdout);
+        break;
+      case L'ढ':
+        fputs("DH", stdout);
+        break;
+      case L'ण':
+        fputs("N", stdout);
+        break;
+      case 0x924:  // त
+        fputs("T", stdout);
+        break;
+      case L'थ':
+        fputs("TH", stdout);
+        break;
+      case L'द':
+        fputs("D", stdout);
+        break;
+      case L'ध':
+        fputs("DH", stdout);
+        break;
+      case L'न':
+        fputs("N", stdout);
+        break;
+      case L'प':
+        fputs("P", stdout);
+        break;
+      case L'फ':
+        fputs("PH", stdout);
+        break;
+      case L'ब':
+        fputs("B", stdout);
+        break;
+      case 0x92d:  // भ
+        fputs("BH", stdout);
+        break;
+      case L'म':
+        fputs("M", stdout);
+        break;
+      case L'य':
+        fputs("Y", stdout);
+        break;
+      case 0x930:  // र
+        fputs("R", stdout);
+        break;
+      case L'ल':
+        fputs("L", stdout);
+        break;
+      case L'व':
+        fputs("V", stdout);
+        break;
+      case L'श':
+        fputs("SH", stdout);
+        break;
+      case L'ष':
+        fputs("SS", stdout);
+        break;
+      case L'स':
+        fputs("S", stdout);
+        break;
+      case L'ह':
+        fputs("H", stdout);
+        break;
+
+      // Hindi Vowels
+      case 0x905:  // अ
+      case 0x93e:  // ा
+        fputs("A", stdout);
+        break;
+      case 0x906:  // आ
+        fputs("AA", stdout);
+        break;
+      case 0x907:  // इ
+      case 0x93f:  // ि
+        fputs("I", stdout);
+        break;
+      case 0x940:  // ी
+      case 0x908:  // ई
+        fputs("II", stdout);
+        break;
+      case 0x942:  // ू
+      case 0x90A:  // ऊ
+        fputs("UU", stdout);
+        break;
+      case 0x947:  // े
+      case 0x90F:  // ए
+        fputs("E", stdout);
+        break;
+      case 0x948:  // ै
+      case 0x910:  // ऐ
+        fputs("AI", stdout);
+        break;
+      case 0x94b:  // ो
+      case 0x913:  // ओ
+        fputs("O", stdout);
+        break;
+      case 0x941:  // ु
+      case 0x909:  // उ
+        fputs("U", stdout);
+        break;
+      case 0x94c:  // ौ
+      case 0x914:  // औ
+        fputs("AU", stdout);
+        break;
+
+      // Hindi Magic Consonants
+      case 0x902:  // ं
+        fputs("N", stdout);
+        break;
+
+      // Hindi Miscellaneous
+      case 0x93c:  // ़ Devanagari Sign Nukta
+        break;
+      case 0x94d:  // ् Devanagari Sign Virama
+        break;
+
+      // Hindi Punctuation
+      case L'।':
+        fputc('.', stdout);
+        break;
+    }
+
+    if ((IsHindiConsonant(c1) && IsHindiConsonant(c2)) ||
+        (IsHindiConsonant(c1) && IsHindiMagicConsonant(c2)))
+      fputs("A", stdout);
+
+    if (c2) {
+      ungetwc(c2, stdin);
+    }
+  }
+  return 0;
+}
diff --git a/examples/rote.c b/examples/rote.c
new file mode 100644
index 000000000..3819ce331
--- /dev/null
+++ b/examples/rote.c
@@ -0,0 +1,322 @@
+#/*────────────────────────────────────────────────────────────────╗
+┌┘ To the extent possible under law, Justine Tunney has waived     │
+│  all copyright and related or neighboring rights to this file,   │
+│  as it is written in the following disclaimers:                  │
+│    • http://unlicense.org/                                       │
+│    • http://creativecommons.org/publicdomain/zero/1.0/           │
+╚─────────────────────────────────────────────────────────────────*/
+#include <ctype.h>
+#include <signal.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <termios.h>
+
+/**
+ * @fileoverview cosmopolitan flash cards viewer
+ */
+
+struct Card {
+  char* qa[2];
+};
+
+atomic_int g_done;
+
+void onsig(int sig) {
+  g_done = 1;
+}
+
+void* xmalloc(int n) {
+  void* p;
+  if ((p = malloc(n)))
+    return p;
+  perror("malloc");
+  exit(1);
+}
+
+void* xrealloc(void* p, int n) {
+  if ((p = realloc(p, n)))
+    return p;
+  perror("realloc");
+  exit(1);
+}
+
+char* xstrcat(const char* a, const char* b) {
+  char* p;
+  size_t n, m;
+  n = strlen(a);
+  m = strlen(b);
+  p = xmalloc(n + m + 1);
+  memcpy(p, a, n);
+  memcpy(p + n, b, m + 1);
+  return p;
+}
+
+void shuffle(struct Card* a, int n) {
+  while (n > 1) {
+    int i = rand() % n--;
+    struct Card t = a[i];
+    a[i] = a[n];
+    a[n] = t;
+  }
+}
+
+char* trim(char* s) {
+  int i;
+  if (s) {
+    while (isspace(*s))
+      ++s;
+    for (i = strlen(s); i--;) {
+      if (isspace(s[i])) {
+        s[i] = 0;
+      } else {
+        break;
+      }
+    }
+  }
+  return s;
+}
+
+char* readline(FILE* f) {
+  for (;;) {
+    char* line = trim(fgetln(f, 0));
+    if (!line)
+      return 0;
+    if (*line != '#')
+      if (*line)
+        return line;
+  }
+}
+
+char* fill(const char* text, int max_line_width, int* out_line_count) {
+  int text_len = strlen(text);
+  char* result = xmalloc(text_len * 2 + 1);
+  int result_pos = 0;
+  int line_start = 0;
+  int line_count = 1;
+  int i = 0;
+  while (i < text_len && isspace(text[i]))
+    i++;
+  while (i < text_len) {
+    int word_end = i;
+    while (word_end < text_len && !isspace(text[word_end]))
+      word_end++;
+    int word_length = word_end - i;
+    if ((result_pos - line_start) + (result_pos > line_start ? 1 : 0) +
+            word_length >
+        max_line_width) {
+      if (result_pos > line_start) {
+        ++line_count;
+        result[result_pos++] = '\n';
+        line_start = result_pos;
+      }
+    } else if (result_pos > line_start) {
+      result[result_pos++] = ' ';
+    }
+    memcpy(result + result_pos, text + i, word_length);
+    result_pos += word_length;
+    i = word_end;
+    while (i < text_len && isspace(text[i]))
+      i++;
+  }
+  result[result_pos] = '\0';
+  result = xrealloc(result, result_pos + 1);
+  if (out_line_count)
+    *out_line_count = line_count;
+  return result;
+}
+
+void show(const char* text, int i, int n) {
+
+  // get pseudoteletypewriter dimensions
+  struct winsize ws = {80, 25};
+  tcgetwinsize(1, &ws);
+  int width = ws.ws_col;
+  if (width > (int)(ws.ws_col * .9))
+    width = ws.ws_col * .9;
+  if (width > 80)
+    width = 80;
+  width &= -2;
+
+  // clear display
+  printf("\033[H\033[J");
+
+  // display flash card text in middle of display
+  char buf[32];
+  int line_count;
+  char* lines = fill(text, width, &line_count);
+  sprintf(buf, "%d/%d\r\n\r\n", i + 1, n);
+  line_count += 2;
+  char* extra = xstrcat(buf, lines);
+  free(lines);
+  char* tokens = extra;
+  for (int j = 0;; ++j) {
+    char* line = strtok(tokens, "\n");
+    tokens = 0;
+    if (!line)
+      break;
+    printf("\033[%d;%dH%s", ws.ws_row / 2 - line_count / 2 + j + 1,
+           ws.ws_col / 2 - strlen(line) / 2 + 1, line);
+  }
+  free(extra);
+  fflush(stdout);
+}
+
+void usage(FILE* f, const char* prog) {
+  fprintf(f,
+          "usage: %s FILE\n"
+          "\n"
+          "here's an example of what your file should look like:\n"
+          "\n"
+          "  # cosmopolitan flash cards\n"
+          "  # california dmv drivers test\n"
+          "  \n"
+          "  which of the following point totals could result in "
+          "your license being suspended by the dmv?\n"
+          "  4 points in 12 months (middle)\n"
+          "  \n"
+          "  at 55 mph under good conditions a passenger vehicle can stop "
+          "within\n"
+          "  300 feet (not 200, not 400, middle)\n"
+          "  \n"
+          "  two sets of solid double yellow lines spaced two or more feet "
+          "apart indicate\n"
+          "  a BARRIER (do not cross unless there's an opening)\n"
+          "\n"
+          "more specifically, empty lines are ignored, lines starting with\n"
+          "a hash are ignored, then an even number of lines must remain,\n"
+          "where each two lines is a card, holding question and answer.\n",
+          prog);
+}
+
+int main(int argc, char* argv[]) {
+
+  // show help
+  if (argc != 2) {
+    usage(stderr, argv[0]);
+    return 1;
+  }
+  if (!strcmp(argv[1], "-?") ||  //
+      !strcmp(argv[1], "-h") ||  //
+      !strcmp(argv[1], "--help")) {
+    usage(stdout, argv[0]);
+    return 0;
+  }
+
+  // teletypewriter is required
+  if (!isatty(0) || !isatty(1)) {
+    perror("isatty");
+    return 2;
+  }
+
+  // load cards
+  FILE* f = fopen(argv[1], "r");
+  if (!f) {
+    perror(argv[1]);
+    return 3;
+  }
+  int count = 0;
+  struct Card* cards = 0;
+  for (;;) {
+    struct Card card;
+    if (!(card.qa[0] = readline(f)))
+      break;
+    card.qa[0] = strdup(card.qa[0]);
+    if (!(card.qa[1] = readline(f))) {
+      fprintf(stderr, "%s: flash card file has odd number of lines\n", argv[1]);
+      exit(1);
+    }
+    card.qa[1] = strdup(card.qa[1]);
+    cards = xrealloc(cards, (count + 1) * sizeof(struct Card));
+    cards[count++] = card;
+  }
+  fclose(f);
+
+  // randomize
+  srand(time(0));
+  shuffle(cards, count);
+
+  // catch ctrl-c
+  struct sigaction sa;
+  sa.sa_flags = 0;
+  sa.sa_handler = onsig;
+  sigemptyset(&sa.sa_mask);
+  sigaction(SIGINT, &sa, 0);
+
+  // enter raw mode
+  struct termios ot;
+  tcgetattr(1, &ot);
+  struct termios nt = ot;
+  cfmakeraw(&nt);
+  nt.c_lflag |= ISIG;
+  tcsetattr(1, TCSANOW, &nt);
+  printf("\033[?25l");
+
+  // show flash cards
+  int i = 0;
+  while (!g_done) {
+    show(cards[i / 2].qa[i % 2], i / 2, count);
+
+    // press any key
+    char b[8] = {0};
+    read(0, b, sizeof(b));
+
+    // q quits
+    if (b[0] == 'q')
+      break;
+
+    // b or ctrl-b goes backward
+    if (b[0] == 'b' ||  //
+        b[0] == ('B' ^ 0100)) {
+      if (--i < 0)
+        i = count * 2 - 1;
+      i &= -2;
+      continue;
+    }
+
+    // p or ctrl-p goes backward
+    if (b[0] == 'p' ||  //
+        b[0] == ('P' ^ 0100)) {
+      if (--i < 0)
+        i = count * 2 - 1;
+      i &= -2;
+      continue;
+    }
+
+    // up arrow goes backward
+    if (b[0] == 033 &&  //
+        b[1] == '[' &&  //
+        b[2] == 'A') {
+      if (--i < 0)
+        i = count * 2 - 1;
+      i &= -2;
+      continue;
+    }
+
+    // left arrow goes backward
+    if (b[0] == 033 &&  //
+        b[1] == '[' &&  //
+        b[2] == 'D') {
+      if (--i < 0)
+        i = count * 2 - 1;
+      i &= -2;
+      continue;
+    }
+
+    // only advance
+    if (++i == count * 2)
+      i = 0;
+  }
+
+  // free memory
+  for (int i = 0; i < count; ++i)
+    for (int j = 0; j < 2; ++j)
+      free(cards[i].qa[j]);
+  free(cards);
+
+  // cleanup terminal and show cursor
+  tcsetattr(1, TCSANOW, &ot);
+  printf("\033[?25h");
+  printf("\n");
+}
diff --git a/examples/script.c b/examples/script.c
index e6559e626..414f07e8c 100644
--- a/examples/script.c
+++ b/examples/script.c
@@ -29,39 +29,30 @@
 │ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF       │
 │ SUCH DAMAGE.                                                                 │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/iovec.h"
-#include "libc/calls/struct/stat.h"
-#include "libc/calls/struct/termios.h"
-#include "libc/calls/struct/timeval.h"
-#include "libc/calls/struct/winsize.h"
-#include "libc/calls/termios.h"
-#include "libc/calls/weirdtypes.h"
-#include "libc/errno.h"
-#include "libc/fmt/conv.h"
-#include "libc/intrin/bswap.h"
-#include "libc/log/bsd.h"
-#include "libc/macros.internal.h"
-#include "libc/mem/mem.h"
-#include "libc/paths.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sock/select.h"
-#include "libc/stdio/stdio.h"
-#include "libc/sysv/consts/fileno.h"
-#include "libc/sysv/consts/s.h"
-#include "libc/sysv/consts/termios.h"
-#include "libc/time.h"
-#include "third_party/getopt/getopt.internal.h"
+#include <err.h>
+#include <errno.h>
+#include <paths.h>
+#include <pty.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/uio.h>
+#include <termios.h>
+#include <time.h>
+#include <unistd.h>
 // clang-format off
 
 /**
  * @fileoverview Terminal Screencast Recorder / Player, e.g.
  *
  *     make o//examples/script.com
- *     o//examples/script.com -r
+ *     o//examples/script.com -w80 -h24 -r recording.tty
  *     # type stuff..
  *     # CTRL-D
- *     o//examples/script.com -p typescript
+ *     o//examples/script.com -p recording.tty
  *
  * @note works on Linux, OpenBSD, NetBSD, FreeBSD, MacOS
  * @see https://asciinema.org/
@@ -112,9 +103,9 @@ main(int argc, char *argv[])
 	fd_set rfd;
 	int fm_fd;
 	int aflg, Fflg, kflg, pflg, ch, k, n;
-	int flushtime, readstdin;
+	int flushtime, readstdin, width, height;
 
-	aflg = Fflg = kflg = pflg = 0;
+	aflg = Fflg = kflg = pflg = height = width = 0;
 	usesleep = 1;
 	rawout = 0;
 	flushtime = 30;
@@ -124,7 +115,7 @@ main(int argc, char *argv[])
 
 	(void)fm_fd;
 
-	while ((ch = getopt(argc, argv, "adeFfkpqrt:")) != -1)
+	while ((ch = getopt(argc, argv, "adeFfkpqrt:w:h:")) != -1)
 		switch(ch) {
 		case 'a':
 			aflg = 1;
@@ -154,6 +145,12 @@ main(int argc, char *argv[])
 			if (flushtime < 0)
 				err(1, "invalid flush time %d", flushtime);
 			break;
+		case 'w':
+			width = atoi(optarg);
+			break;
+		case 'h':
+			height = atoi(optarg);
+			break;
 		case '?':
 		default:
 			usage();
@@ -181,6 +178,10 @@ main(int argc, char *argv[])
 		if (openpty(&master, &slave, NULL, NULL, NULL) == -1)
 			err(1, "openpty");
 	} else {
+		if (width)
+			win.ws_col = width;
+		if (height)
+			win.ws_row = height;
 		if (openpty(&master, &slave, NULL, &tt, &win) == -1)
 			err(1, "openpty");
 		ttyflg = 1;
diff --git a/examples/seq.c b/examples/seq.c
index 4d401133b..f8403f60f 100644
--- a/examples/seq.c
+++ b/examples/seq.c
@@ -7,9 +7,8 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/fmt/conv.h"
-#include "libc/fmt/itoa.h"
+#include <cosmo.h>
+#include <stdlib.h>
 
 /**
  * @fileoverview Prints sequence of numbers.
diff --git a/examples/setcontext.c b/examples/setcontext.c
index 07afabe30..ff20aee7e 100644
--- a/examples/setcontext.c
+++ b/examples/setcontext.c
@@ -7,12 +7,9 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/calls/ucontext.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/exit.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <ucontext.h>
 
 /**
  * @fileoverview swapcontext() and makecontext() example
@@ -33,18 +30,16 @@ static ucontext_t uctx_func2;
 static void func1(void) {
   say("func1: started\n");
   say("func1: swapcontext(&uctx_func1, &uctx_func2)\n");
-  if (swapcontext(&uctx_func1, &uctx_func2) == -1) {
+  if (swapcontext(&uctx_func1, &uctx_func2) == -1)
     handle_error("swapcontext");
-  }
   say("func1: returning\n");
 }
 
 static void func2(void) {
   say("func2: started\n");
   say("func2: swapcontext(&uctx_func2, &uctx_func1)\n");
-  if (swapcontext(&uctx_func2, &uctx_func1) == -1) {
+  if (swapcontext(&uctx_func2, &uctx_func1) == -1)
     handle_error("swapcontext");
-  }
   say("func2: returning\n");
 }
 
@@ -52,17 +47,15 @@ int main(int argc, char *argv[]) {
   char func1_stack[8192];
   char func2_stack[8192];
 
-  if (getcontext(&uctx_func1) == -1) {
+  if (getcontext(&uctx_func1) == -1)
     handle_error("getcontext");
-  }
   uctx_func1.uc_stack.ss_sp = func1_stack;
   uctx_func1.uc_stack.ss_size = sizeof(func1_stack);
   uctx_func1.uc_link = &uctx_main;
   makecontext(&uctx_func1, func1, 0);
 
-  if (getcontext(&uctx_func2) == -1) {
+  if (getcontext(&uctx_func2) == -1)
     handle_error("getcontext");
-  }
   uctx_func2.uc_stack.ss_sp = func2_stack;
   uctx_func2.uc_stack.ss_size = sizeof(func2_stack);
   /* Successor context is f1(), unless argc > 1 */
@@ -70,9 +63,8 @@ int main(int argc, char *argv[]) {
   makecontext(&uctx_func2, func2, 0);
 
   say("main: swapcontext(&uctx_main, &uctx_func2)\n");
-  if (swapcontext(&uctx_main, &uctx_func2) == -1) {
+  if (swapcontext(&uctx_main, &uctx_func2) == -1)
     handle_error("swapcontext");
-  }
 
   say("main: exiting\n");
   exit(EXIT_SUCCESS);
diff --git a/examples/setitimer.c b/examples/setitimer.c
index 89b291941..6d926bca8 100644
--- a/examples/setitimer.c
+++ b/examples/setitimer.c
@@ -7,17 +7,15 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/assert.h"
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/itimerval.h"
-#include "libc/calls/struct/sigaction.h"
-#include "libc/calls/struct/siginfo.h"
-#include "libc/calls/ucontext.h"
-#include "libc/stdio/stdio.h"
-#include "libc/sysv/consts/itimer.h"
-#include "libc/sysv/consts/sa.h"
-#include "libc/sysv/consts/sig.h"
-#include "libc/time.h"
+#include <assert.h>
+#include <signal.h>
+#include <stdio.h>
+#include <sys/time.h>
+#include <unistd.h>
+
+/**
+ * @fileoverview interval timer tutorial
+ */
 
 volatile bool gotalrm;
 
diff --git a/examples/spawn.c b/examples/spawn.c
new file mode 100644
index 000000000..c118fc7a1
--- /dev/null
+++ b/examples/spawn.c
@@ -0,0 +1,366 @@
+#if 0
+/*─────────────────────────────────────────────────────────────────╗
+│ To the extent possible under law, Justine Tunney has waived      │
+│ all copyright and related or neighboring rights to this file,    │
+│ as it is written in the following disclaimers:                   │
+│   • http://unlicense.org/                                        │
+│   • http://creativecommons.org/publicdomain/zero/1.0/            │
+╚─────────────────────────────────────────────────────────────────*/
+#endif
+
+// posix_spawn() example
+//
+// This program demonstrates the use of posix_spawn() to run the command
+// `ls --dired` and capture its output. It teaches several key features:
+//
+// - Changing the working directory for the child process
+// - Redirecting stdout and stderr to pipes
+// - Handling the output from the child process
+//
+// The primary advantage of using posix_spawn() instead of the
+// traditional fork()/execve() combination for launching processes is
+// safety, efficiency, and cross-platform compatibility.
+//
+// 1. On Linux, FreeBSD, and NetBSD:
+//
+//    Cosmopolitan Libc's posix_spawn() uses vfork() under the hood on
+//    these platforms automatically, since it's faster than fork(). It's
+//    because vfork() creates a child process without needing to copy
+//    the parent's page tables, making it more efficient, especially for
+//    large processes. Furthermore, vfork() avoids the need to acquire
+//    every single mutex (see pthread_atfork() for more details) which
+//    makes it scalable in multi-threaded apps, since the other threads
+//    in your app can keep going while the spawning thread waits for the
+//    subprocess to call execve(). Normally vfork() is error-prone since
+//    there exists few functions that are @vforksafe. the posix_spawn()
+//    API is designed to offer maximum assurance that you can't shoot
+//    yourself in the foot. If you do, then file a bug with Cosmo.
+//
+// 2. On Windows:
+//
+//    posix_spawn() avoids fork() entirely. Windows doesn't natively
+//    support fork(), and emulating it can be slow and memory-intensive.
+//    By using posix_spawn(), we get a much faster process creation on
+//    Windows systems, because it only needs to call CreateProcess().
+//    Your file actions are replayed beforehand in a simulated way. Only
+//    Cosmopolitan Libc offers this level of quality. With Cygwin you'd
+//    have to use its proprietary APIs to achieve the same performance.
+//
+// 3. Simplified error handling:
+//
+//    posix_spawn() combines process creation and program execution in a
+//    single call, reducing the points of failure and simplifying error
+//    handling. One important thing that happens with Cosmopolitan's
+//    posix_spawn() implementation is that the error code of execve()
+//    inside your subprocess, should it fail, will be propagated to your
+//    parent process. This will happen efficiently via vfork() shared
+//    memory in the event your Linux environment supports this. If it
+//    doesn't, then Cosmopolitan will fall back to a throwaway pipe().
+//    The pipe is needed on platforms like XNU and OpenBSD which do not
+//    support vfork(). It's also needed under QEMU User.
+//
+// 4. Signal safety:
+//
+//    posix_spawn() guarantees your signal handler callback functions
+//    won't be executed in the child process. By default, it'll remove
+//    sigaction() callbacks atomically. This ensures that if something
+//    like a SIGTERM or SIGHUP is sent to the child process before it's
+//    had a chance to call execve(), then the child process will simply
+//    be terminated (like the spawned process would) instead of running
+//    whatever signal handlers the spawning process has installed. If
+//    you've set some signals to SIG_IGN, then that'll be preserved for
+//    the child process by posix_spawn(), unless you explicitly call
+//    posix_spawnattr_setsigdefault() to reset them.
+//
+// 5. Portability:
+//
+//    posix_spawn() is part of the POSIX standard, making it more
+//    portable across different UNIX-like systems and Windows (with
+//    appropriate libraries). Even the non-POSIX APIs we use here are
+//    portable; e.g. posix_spawn_file_actions_addchdir_np() is supported
+//    by glibc, musl, freebsd, and apple too.
+//
+// These benefits make posix_spawn() a preferred choice for efficient
+// and portable process creation in many scenarios, especially when
+// launching many processes or on systems where process creation
+// performance is critical.
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <spawn.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/select.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#define max(X, Y) ((Y) < (X) ? (X) : (Y))
+
+#define USE_SELECT 0  // want poll() or select()? they both work great
+
+#define PIPE_READ  0
+#define PIPE_WRITE 1
+
+int main() {
+  errno_t err;
+
+  // Create spawn attributes object.
+  posix_spawnattr_t attr;
+  err = posix_spawnattr_init(&attr);
+  if (err != 0) {
+    fprintf(stderr, "posix_spawnattr_init failed: %s\n", strerror(err));
+    exit(1);
+  }
+
+  // Explicitly request vfork() from posix_spawn() implementation.
+  //
+  // This is currently the default for Cosmopolitan Libc, however you
+  // may want to set this anyway, for portability with other platforms.
+  // Please note that vfork() isn't officially specified by POSIX, so
+  // portable code may want to omit this and just use the default.
+  err = posix_spawnattr_setflags(&attr, POSIX_SPAWN_USEVFORK);
+  if (err != 0) {
+    fprintf(stderr, "posix_spawnattr_setflags: %s\n", strerror(err));
+    exit(2);
+  }
+
+  // Create file actions object.
+  posix_spawn_file_actions_t actions;
+  err = posix_spawn_file_actions_init(&actions);
+  if (err != 0) {
+    fprintf(stderr, "posix_spawn_file_actions_init: %s\n", strerror(err));
+    exit(3);
+  }
+
+  // Change directory to root directory in child process.
+  err = posix_spawn_file_actions_addchdir_np(&actions, "/");
+  if (err != 0) {
+    fprintf(stderr, "posix_spawn_file_actions_addchdir_np: %s\n",
+            strerror(err));
+    exit(4);
+  }
+
+  // Disable stdin in child process.
+  //
+  // By default, if you launch this example in your terminal, then child
+  // processes can read from your teletypewriter's keyboard too. You can
+  // avoid this by assigning /dev/null to standard input so if the child
+  // tries to read input, read() will return zero, indicating eof.
+  if ((err = posix_spawn_file_actions_addopen(&actions, STDIN_FILENO,
+                                              "/dev/null", O_RDONLY, 0644))) {
+    fprintf(stderr, "posix_spawn_file_actions_addopen: %s\n", strerror(err));
+    exit(5);
+  }
+
+  // Create pipes for stdout and stderr.
+  //
+  // Using O_DIRECT puts the pipe in message mode. This way we have some
+  // visibility into how the child process is using write(). It can also
+  // help ensure that logged lines won't be chopped up here, which could
+  // happen more frequently on platforms like Windows, which is somewhat
+  // less sophisticated than Linux with how it performs buffering.
+  //
+  // You can also specify O_CLOEXEC, which is a nice touch that lets you
+  // avoid needing to call posix_spawn_file_actions_addclose() later on.
+  // That's because all file descriptors are inherited by child programs
+  // by default. This is even the case with Cosmopolitan Libc on Windows
+  //
+  // XXX: We assume that stdin/stdout/stderr exist in this process. It's
+  //      possible for a rogue parent process to launch this example, in
+  //      a way where the following spawn logic will break.
+  int pipe_stdout[2];
+  int pipe_stderr[2];
+  if (pipe2(pipe_stdout, O_DIRECT) == -1 ||
+      pipe2(pipe_stderr, O_DIRECT) == -1) {
+    perror("pipe");
+    exit(6);
+  }
+
+  // Redirect child's stdout/stderr to pipes
+  if ((err = posix_spawn_file_actions_adddup2(&actions, pipe_stdout[PIPE_WRITE],
+                                              STDOUT_FILENO)) ||
+      (err = posix_spawn_file_actions_adddup2(&actions, pipe_stderr[PIPE_WRITE],
+                                              STDERR_FILENO))) {
+    fprintf(stderr, "posix_spawn_file_actions_adddup2: %s\n", strerror(err));
+    exit(7);
+  }
+
+  // Close unwanted write ends of pipes in the child process
+  if ((err = posix_spawn_file_actions_addclose(&actions,
+                                               pipe_stdout[PIPE_READ])) ||
+      (err = posix_spawn_file_actions_addclose(&actions,
+                                               pipe_stderr[PIPE_READ]))) {
+    fprintf(stderr, "posix_spawn_file_actions_addclose: %s\n", strerror(err));
+    exit(8);
+  };
+
+  // Asynchronously launch the child process.
+  pid_t pid;
+  char *const argv[] = {"ls", "--dired", NULL};
+  printf("** Launching `ls --dired` in root directory\n");
+  err = posix_spawnp(&pid, argv[0], &actions, NULL, argv, NULL);
+  if (err) {
+    fprintf(stderr, "posix_spawn: %s\n", strerror(err));
+    exit(9);
+  }
+
+  // Close unused write ends of pipes in the parent process
+  close(pipe_stdout[PIPE_WRITE]);
+  close(pipe_stderr[PIPE_WRITE]);
+
+  // we need poll() or select() because we're multiplexing output
+  // both poll() and select() work across all supported platforms
+#if USE_SELECT
+  // Relay output from child process using select()
+  char buffer[512];
+  ssize_t got_stdout = 1;
+  ssize_t got_stderr = 1;
+  while (got_stdout > 0 || got_stderr > 0) {
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    if (got_stdout > 0)
+      FD_SET(pipe_stdout[PIPE_READ], &rfds);
+    if (got_stderr > 0)
+      FD_SET(pipe_stderr[PIPE_READ], &rfds);
+    int nfds = max(pipe_stdout[PIPE_READ], pipe_stderr[PIPE_READ]) + 1;
+    if (select(nfds, &rfds, 0, 0, 0) == -1) {
+      perror("select");
+      exit(10);
+    }
+    if (FD_ISSET(pipe_stdout[PIPE_READ], &rfds)) {
+      got_stdout = read(pipe_stdout[PIPE_READ], buffer, sizeof(buffer));
+      printf("\n");
+      if (got_stdout > 0) {
+        printf("** Got stdout from child process:\n");
+        fflush(stdout);
+        write(STDOUT_FILENO, buffer, got_stdout);
+      } else if (!got_stdout) {
+        printf("** Got stdout EOF from child process\n");
+      } else {
+        printf("** Got stdout read() error from child process: %s\n",
+               strerror(errno));
+      }
+    }
+    if (FD_ISSET(pipe_stderr[PIPE_READ], &rfds)) {
+      got_stderr = read(pipe_stderr[PIPE_READ], buffer, sizeof(buffer));
+      printf("\n");
+      if (got_stderr > 0) {
+        printf("** Got stderr from child process:\n");
+        fflush(stdout);
+        write(STDOUT_FILENO, buffer, got_stderr);
+      } else if (!got_stderr) {
+        printf("** Got stderr EOF from child process\n");
+      } else {
+        printf("** Got stderr read() error from child process: %s\n",
+               strerror(errno));
+      }
+    }
+  }
+
+#else
+  // Relay output from child process using poll()
+  char buffer[512];
+  ssize_t got_stdout = 1;
+  ssize_t got_stderr = 1;
+  while (got_stdout > 0 || got_stderr > 0) {
+    struct pollfd fds[2];
+    fds[0].fd = got_stdout > 0 ? pipe_stdout[PIPE_READ] : -1;
+    fds[0].events = POLLIN;  // POLLHUP, POLLNVAL, and POLLERR are implied
+    fds[1].fd = got_stderr > 0 ? pipe_stderr[PIPE_READ] : -1;
+    fds[1].events = POLLIN;  // POLLHUP, POLLNVAL, and POLLERR are implied
+    if (poll(fds, 2, -1) == -1) {
+      perror("select");
+      exit(10);
+    }
+    if (fds[0].revents) {
+      printf("\n");
+      if (fds[0].revents & POLLIN)
+        printf("** Got POLLIN on stdout from child process\n");
+      if (fds[0].revents & POLLHUP)
+        printf("** Got POLLHUP on stdout from child process\n");
+      if (fds[0].revents & POLLERR)
+        printf("** Got POLLERR on stdout from child process\n");
+      if (fds[0].revents & POLLNVAL)
+        printf("** Got POLLNVAL on stdout from child process\n");
+      got_stdout = read(pipe_stdout[PIPE_READ], buffer, sizeof(buffer));
+      if (got_stdout > 0) {
+        printf("** Got stdout from child process:\n");
+        fflush(stdout);
+        write(STDOUT_FILENO, buffer, got_stdout);
+      } else if (!got_stdout) {
+        printf("** Got stdout EOF from child process\n");
+      } else {
+        printf("** Got stdout read() error from child process: %s\n",
+               strerror(errno));
+      }
+    }
+    if (fds[1].revents) {
+      printf("\n");
+      if (fds[1].revents & POLLIN)
+        printf("** Got POLLIN on stderr from child process\n");
+      if (fds[1].revents & POLLHUP)
+        printf("** Got POLLHUP on stderr from child process\n");
+      if (fds[1].revents & POLLERR)
+        printf("** Got POLLERR on stderr from child process\n");
+      if (fds[1].revents & POLLNVAL)
+        printf("** Got POLLNVAL on stderr from child process\n");
+      got_stderr = read(pipe_stderr[PIPE_READ], buffer, sizeof(buffer));
+      if (got_stderr > 0) {
+        printf("** Got stderr from child process:\n");
+        fflush(stdout);
+        write(STDOUT_FILENO, buffer, got_stderr);
+      } else if (!got_stderr) {
+        printf("** Got stderr EOF from child process\n");
+      } else {
+        printf("** Got stderr read() error from child process: %s\n",
+               strerror(errno));
+      }
+    }
+  }
+#endif
+
+  // Wait for child process to die.
+  int wait_status;
+  if (waitpid(pid, &wait_status, 0) == -1) {
+    perror("waitpid");
+    exit(11);
+  }
+
+  // Clean up resources.
+  posix_spawn_file_actions_destroy(&actions);
+  posix_spawnattr_destroy(&attr);
+  close(pipe_stdout[PIPE_READ]);
+  close(pipe_stderr[PIPE_READ]);
+
+  // Report wait status.
+  //
+  // When a process dies, it's almost always due to calling _Exit() or
+  // being killed due to an unhandled signal. On both UNIX and Windows
+  // this information will be propagated to the parent. That status is
+  // able to be propagated to the parent of this process too.
+  printf("\n");
+  if (WIFEXITED(wait_status)) {
+    printf("** Child process exited with exit code %d\n",
+           WEXITSTATUS(wait_status));
+    exit(WEXITSTATUS(wait_status));
+  } else if (WIFSIGNALED(wait_status)) {
+    printf("** Child process terminated with signal %s\n",
+           strsignal(WTERMSIG(wait_status)));
+    fflush(stdout);
+    sigset_t sm;
+    sigemptyset(&sm);
+    sigaddset(&sm, WTERMSIG(wait_status));
+    sigprocmask(SIG_UNBLOCK, &sm, 0);
+    signal(SIGABRT, SIG_DFL);
+    raise(WTERMSIG(wait_status));
+    exit(128 + WTERMSIG(wait_status));
+  } else {
+    printf("** Child process exited weirdly with wait status 0x%08x\n",
+           wait_status);
+    exit(12);
+  }
+}
diff --git a/examples/spawn_bench.c b/examples/spawn_bench.c
index 38423389d..66ccdbc6a 100644
--- a/examples/spawn_bench.c
+++ b/examples/spawn_bench.c
@@ -7,24 +7,20 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/atomic.h"
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/calls/weirdtypes.h"
-#include "libc/mem/mem.h"
-#include "libc/proc/posix_spawn.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/clock.h"
-#include "libc/sysv/consts/map.h"
-#include "libc/sysv/consts/prot.h"
+#include <spawn.h>
+#include <stdalign.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <time.h>
 
 #define ITERATIONS 10
 
-_Alignas(128) int a;
-_Alignas(128) int b;
-_Alignas(128) atomic_int lock;
+alignas(128) int a;
+alignas(128) int b;
+alignas(128) atomic_int lock;
 
 static struct timespec SubtractTime(struct timespec a, struct timespec b) {
   a.tv_sec -= b.tv_sec;
@@ -117,6 +113,11 @@ int main(int argc, char *argv[]) {
   void *p;
   const char *prog;
 
+  // if you need the tiny64 program for windows:
+  //
+  //     make -j o//tool/hello/life-pe.ape
+  //     scp o//tool/hello/life-pe.ape windows:tiny64
+  //
   if (argc <= 1) {
     prog = "tiny64";
   } else {
diff --git a/examples/stackexplorer.c b/examples/stackexplorer.c
index 5b5d9add9..96c34114c 100644
--- a/examples/stackexplorer.c
+++ b/examples/stackexplorer.c
@@ -7,9 +7,13 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
+#include "libc/dce.h"
+#include "libc/intrin/maps.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
+#include "libc/runtime/stack.h"
+#include "libc/runtime/winargs.internal.h"
 #include "libc/stdio/stdio.h"
 #include "libc/x/xasprintf.h"
 
@@ -67,8 +71,18 @@ int main(int argc, char *argv[]) {
     Append((uintptr_t)&__auxv[i + 1],
            xasprintf("&auxv[%d] = %#lx", i + 1, __auxv[i + 1]));
   }
-  qsort(things.p, things.n, sizeof(*things.p), Compare);
-  for (int i = 0; i < things.n; ++i) {
-    printf("%012lx %s\n", things.p[i].i, things.p[i].s);
+  if (!IsWindows()) {
+    struct AddrSize stak = __get_main_stack();
+    Append((intptr_t)stak.addr + stak.size, "top of stack");
+    Append((intptr_t)stak.addr, "bottom of stack");
+  } else {
+#ifdef __x86_64__
+    Append(GetStaticStackAddr(0) + GetStaticStackSize(), "top of stack");
+    Append(GetStaticStackAddr(0) + GetGuardSize(), "bottom of stack");
+    Append(GetStaticStackAddr(0), "bottom of guard region");
+#endif
   }
+  qsort(things.p, things.n, sizeof(*things.p), Compare);
+  for (int i = 0; i < things.n; ++i)
+    printf("%012lx %s\n", things.p[i].i, things.p[i].s);
 }
diff --git a/examples/stat.c b/examples/stat.c
index dce122cbb..45e17e354 100644
--- a/examples/stat.c
+++ b/examples/stat.c
@@ -7,19 +7,12 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/struct/stat.h"
-#include "libc/assert.h"
-#include "libc/calls/calls.h"
-#include "libc/errno.h"
-#include "libc/fmt/conv.h"
-#include "libc/log/check.h"
-#include "libc/log/log.h"
-#include "libc/mem/gc.h"
-#include "libc/mem/mem.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/s.h"
-#include "libc/time.h"
+#include <assert.h>
+#include <cosmo.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <time.h>
 
 /**
  * @fileoverview File metadata viewer.
@@ -72,9 +65,15 @@ void PrintFileMetadata(const char *pathname, struct stat *st) {
   printf("\n%s:", pathname);
   if (numeric) {
     fd = atoi(pathname);
-    CHECK_NE(-1, fstat(fd, st), "fd=%d", fd);
+    if (fstat(fd, st)) {
+      perror(pathname);
+      exit(1);
+    }
   } else {
-    CHECK_NE(-1, stat(pathname, st), "pathname=%s", pathname);
+    if (stat(pathname, st)) {
+      perror(pathname);
+      exit(1);
+    }
   }
   printf("\n"
          "%-32s%,ld\n"
diff --git a/examples/statfs.c b/examples/statfs.c
index ce6367794..817017d25 100644
--- a/examples/statfs.c
+++ b/examples/statfs.c
@@ -7,18 +7,19 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/struct/statfs.h"
-#include "libc/dce.h"
-#include "libc/fmt/conv.h"
-#include "libc/log/check.h"
 #include "libc/nt/enum/statfs.h"
-#include "libc/stdio/stdio.h"
-#include "libc/sysv/consts/st.h"
+#include <cosmo.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/vfs.h>
 
-dontinline void ShowIt(const char *path) {
+void ShowIt(const char *path) {
   char ibuf[21];
   struct statfs sf = {0};
-  CHECK_NE(-1, statfs(path, &sf));
+  if (statfs(path, &sf)) {
+    perror(path);
+    exit(1);
+  }
 
   printf("filesystem %s\n", path);
   printf("f_type    = %#x (%s)\n", sf.f_type, sf.f_fstypename);
diff --git a/examples/stringbuffer.c b/examples/stringbuffer.c
deleted file mode 100644
index 4f965be2f..000000000
--- a/examples/stringbuffer.c
+++ /dev/null
@@ -1,36 +0,0 @@
-#if 0
-/*─────────────────────────────────────────────────────────────────╗
-│ To the extent possible under law, Justine Tunney has waived      │
-│ all copyright and related or neighboring rights to this file,    │
-│ as it is written in the following disclaimers:                   │
-│   • http://unlicense.org/                                        │
-│   • http://creativecommons.org/publicdomain/zero/1.0/            │
-╚─────────────────────────────────────────────────────────────────*/
-#endif
-#include "libc/calls/calls.h"
-#include "libc/log/check.h"
-#include "libc/mem/mem.h"
-#include "libc/stdio/append.h"
-#include "libc/str/str.h"
-
-/**
- * @fileoverview Fast Growable Strings Tutorial
- */
-
-int main(int argc, char *argv[]) {
-  char *b = 0;
-  appendf(&b, "hello ");  // guarantees nul terminator
-  CHECK_EQ(6, strlen(b));
-  CHECK_EQ(6, appendz(b).i);
-  appendf(&b, " world\n");
-  CHECK_EQ(13, strlen(b));
-  CHECK_EQ(13, appendz(b).i);
-  appendd(&b, "\0", 1);  // supports binary
-  CHECK_EQ(13, strlen(b));
-  CHECK_EQ(14, appendz(b).i);
-  appendf(&b, "%d arg%s\n", argc, argc == 1 ? "" : "s");
-  appendf(&b, "%s\n", "have a nice day");
-  write(1, b, appendz(b).i);
-  free(b);
-  return 0;
-}
diff --git a/examples/sysconf.c b/examples/sysconf.c
index 19a91e6b6..553b3a245 100644
--- a/examples/sysconf.c
+++ b/examples/sysconf.c
@@ -7,8 +7,8 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/runtime/sysconf.h"
-#include "libc/stdio/stdio.h"
+#include <stdio.h>
+#include <unistd.h>
 
 #define SYSCONF(NAME) printf("%-24s %,ld\n", #NAME, sysconf(NAME))
 
diff --git a/examples/sysinfo.c b/examples/sysinfo.c
index 4892a8183..afd2c5bca 100644
--- a/examples/sysinfo.c
+++ b/examples/sysinfo.c
@@ -7,19 +7,19 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/struct/sysinfo.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/fmt/conv.h"
-#include "libc/fmt/itoa.h"
-#include "libc/log/check.h"
-#include "libc/stdio/stdio.h"
-#include "libc/sysv/consts/clock.h"
+#include <cosmo.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/sysinfo.h>
 
 int main(int argc, char *argv[]) {
   int64_t x;
   char ibuf[21];
   struct sysinfo si;
-  CHECK_NE(-1, sysinfo(&si));
+  if (sysinfo(&si)) {
+    perror("sysinfo");
+    exit(1);
+  }
 
   printf("%-16s", "uptime");
   x = si.uptime / (24 * 60 * 60);
diff --git a/examples/system.c b/examples/system.c
index 070665191..dcb2be248 100644
--- a/examples/system.c
+++ b/examples/system.c
@@ -7,9 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/calls/calls.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
+#include <stdlib.h>
 
 /**
  * @fileoverview Cosmopolitan Command Interpreter Demo
diff --git a/examples/thread.c b/examples/thread.c
new file mode 100644
index 000000000..283c2f8b0
--- /dev/null
+++ b/examples/thread.c
@@ -0,0 +1,17 @@
+#include <pthread.h>
+#include <stdio.h>
+
+// how to spawn a thread
+
+void *my_thread(void *arg) {
+  printf("my_thread(%p) is running\n", arg);
+  return (void *)0x456L;
+}
+
+int main(int argc, char *argv[]) {
+  void *res;
+  pthread_t th;
+  pthread_create(&th, 0, my_thread, (void *)0x123L);
+  pthread_join(th, &res);
+  printf("my_thread() returned %p\n", res);
+}
diff --git a/examples/ttyinfo.c b/examples/ttyinfo.c
index 6f111acbe..82a009fcd 100644
--- a/examples/ttyinfo.c
+++ b/examples/ttyinfo.c
@@ -14,6 +14,7 @@
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/termios.h"
+#include "libc/ctype.h"
 #include "libc/errno.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
@@ -160,6 +161,10 @@ void OnSignalThatWillEintrRead(int sig) {
 }
 
 int main(int argc, char *argv[]) {
+
+  // // emacs sends this to enable decckm mode
+  // WRITE(1, "\e[?1049h\e[22;0;0t\e[?12;25h\e[?1h\e=");
+
   int e, c, y, x, n, yn, xn;
   infd = 0;
   outfd = 1;
diff --git a/examples/unbourne.c b/examples/unbourne.c
deleted file mode 100644
index c8fe70c0f..000000000
--- a/examples/unbourne.c
+++ /dev/null
@@ -1,11594 +0,0 @@
-/*bin/echo ' #-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;coding:utf-8 -*-┤
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-├──────────────────────────────────────────────────────────────────────────────┤
-│███▒ ▓░░░▒ █▓█▓ ▒▒███████▓█████ ██▓▓▓███▒██▒▓█▓████████ ▓██▓█████▓██ ░ ░▒  ░  │
-│█░ ░ █░▒▒▒ █▓▓▓ ▒▓████▓░███▓█▓▓▓▓█▓▒▓▓███▓▒▒██▓▓█▓█████ ▒██▓█████▓██ ░ ▒░░░  ░│
-│███▓     ▒ ▓██▓ █████▓░█▓▓█▓██░░█░████▓█▓██▒██▒▓▓▓█▓▓█▓█▒██▓█████▓██░▒ ▓░     │
-│████ █▓     ▒███▓██████████████████████████████▓▓█▓█████▓████████▓██ ▒▓▓▓▒░▒ ░│
-│███▓ ▓▓▓▓        ▒███████████▓████████████▓▓██▓▓▓█▓████▓███▓█████▓██ ▒░▓▒░░  ░│
-│███▓ █▒▓▒▒░▓        ▒██▓████████████████████████████▓██▓▓████████▓██ ░░▒▒▓▓▒ ░│
-│███▓ ▓▒▓▓▓ █▓▓          ▒███████████████████████████▓██▓▓░███████▓██ ░ ▒▒░░▓▓░│
-│█▓█▓ █▒░░░ █▓██▓             ██████████████████████████▓█████████▓▓░░░ ▒░ ░░ ▒│
-│█▓█▓░█▓▒▓▒ ██▓█▓ ▓               ▓██████████████████▒██▓████████ ▒░▒▒▒▒▒▒▒   ░│
-│█▓▓▒░▓▓▒▓▓ █▓▓██ ██  ░ ░ ░░░░  ░░░ ░ ███████████████▓██▓██████ ░▒▓▓▒▓▓░▒▓░▒░  │
-│██▓▓░▓▒▒▓▒░▓▓▓▓▓ █▓▓░   ░  ░░ ░ ░     ▓█████████████▒██▓████▒▒▒░░▓▓▒▓▒░▒░░▒░ ░│
-│█▓▓▓░█▒▒▒▒ █▓▓▓▓ ██▓▓    ░      ░     ▒▒  ██████████▒██▓███░░░▒▒▓▓▓▓▒░░   ░   │
-│██▓▓░█░▒▒▒░█▓▓▓▓ █▓▓█        ░ ░  ░░░░▓░    ████████▒██ ░░░▓▒▒▓▓▓▓ ▓▒░▒▒▒▒░░  │
-│▒██▓▒▓░▒▓░░▓▓▓▓▓ ▓▓▓▓     ░░       ▒░░▒░░   ▓███████▒██░   ▒ ▒░░▒▓▒▒░▒▒▓▒ ░   │
-│▒▓▓▓▒█▒▒▒▒░█▒▒▓▓ ▓▓█▓▓▓▓▓  ░▒ ░  ▒ ░▓▓▓░░░   █▒  ▓   ██▓███▒▓░▓▓▒░▓░░░░▒▒░░░ ░│
-│▒█▒▓░▓▓░▓▓░▓▒▓▒▒ █▓████▓███  ░ ░▒░ ▓▓▒▒▒▒░░▓  ░ ░█ ▓ ▒█████░░  ▓▓▒▒░░▒▒▓▒░  ░░│
-│░▓█▓▒▓▓▒▓▒░█▓▒▓▓ █▓████▓███▓▓ ░▒▒▒▓▓▒▒▓▓▒░▒▓░ ▒ ░██  ░ ███▒░▓░ ▓▒▓▒▒░ ░       │
-│░█▓▓▓▓▓▓▒▒▓█▓▒▓▓ █▓▓███▓█████▓ ░▒▒▒▒▒▓▒▒░░▒░▓ ░░▓▒ ▒░▒░ ░▒ ▓░▓▓░░ ▓▓░ ░░░░ ░░ │
-│ ██░  ░   ▒█▓▓▓▓ ██████▓██████▓░▒▒▒▓▓▓▓▓▓▒▒░▓▒░▓▒▒▒▒▓▓▓░▓▒▒░▒▒▓▓▒▒░▒  ░   ░ ░░│
-│   ░░░▒     ▓▓▓▓ █▓▓█▓█▓███████▓░▒▓▒▓▓█▒░▒▓▓▓▒▒▓▓▒▓▓▒█░▒▓▒▒ ░▓▒▓ ▒▒░▒░ ▒ ░░░  │
-│  ▒░░ ░ ▓  ░▓▓▓▓ ████▓█▓████████▒▓▒█░░▓▒▓ ▒▓▓░▒▒▓▒▒▓▒▓▒▒▓▒▓▓█▓▓ ▓░▒  ░░░░░ ░  │
-│  ░▓ ▒░░░░ ▓█▓▓▓ █▓▒███▓█████████▓░░▒▒▓▒▓▒▒▓▓▒▓▓ ▓▒▓▓▒▓▒▓▒▓▓▒▓▓ ▓▒▒░▒ ▓▒ ░    │
-│  ▒░ ░  ░░ ▓▒░░░ █▓▓██▓▓████▓▓▓█▓░░▒▓▓▓▒▒▓░▓▓▓▒▓▒▒▒▓▒▓▓▓▓▒▒▒▒▒░▒▒▒░██         │
-│▒ ▒▒ ▒░░░  ▓▓▓▓▒ ▓▓▓███▒███▓███▓▓▒▒░░▒▒▒▒░▒▒▒▒▒▓▓▒▒░▓▓▓▒▓░▓▓▓▒▒▒▓░▓▓▓    ░ ░  │
-│▒  ░    ▓  ▓▓▓▓▒ ▓▒▓▓▓█▒███▓▓▓█▒▒▓▓███████▓▒▓░▒▓░▓▒▓▒▓▓▒▒▒▓░▒▒░ ░▒▓▒░         │
-│▓  ░░ ░ █  ▓▓▓▓▓ ▓▓▓█▓▓▓███▓█▓█▓████████████░▓▓▓▓▒▓▓▓▓▒▒▓▒▒▒ ▓▓ ▓░ ░▓     ░   │
-│▓  ░  ░   ▒▓▓▓▒▒ ▓▓▓█▓█▒██▓▓▓█▓█▓█▓██████████░▓▒▒▓▓▓▒▓▓▓▒ ▒▓ ▒    ░▒▓▓▓█  ░   │
-│▓▒░░▒▒░▒ ░░▓▓▓▓▓ ▓▓▓███▓██████████████████████░░▓▒░▓▒▒▒▒▒▒▓▓░       ░▒▒░░     │
-│▓   ░▓▒▒   ░░▒▓▒ ░▓▓█▓█▓█████████████████████▒░░ ░ ░ ░▒░   ░ ░   ░▓▒          │
-└──────────────────────────────────────────────────────────────────────────────┘
- unbourne is a gnu/systemd init process                          »cosmopolitan»
-
-
-╔────────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell                                        ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│─╝
-
-  The UNBOURNE SHELL is BASED off the Almquist Shell──colloquially
-  known as the Debian Almquist Shell, a.k.a. dash──which perfected
-  the work of the late Stephen Bourne whose shell set the standard
-  for decades thanks to a spark of brilliance from Ken Thompson.
-
-    git://git.kernel.org/pub/scm/utils/dash/dash.git
-    057cd650a4edd5856213d431a974ff35c6594489
-    Fri Sep 03 15:00:58 2021 +0800
-
-  The UNBOURNE SHELL pays HOMAGE to the Stewards of House California:
-
-    Almquist Shell
-    Derived from software contributed to Berkeley by Kenneth Almquist.
-
-    Copyright 1991,1993 The Regents of the University of California
-    Copyright 1997-2021 Herbert Xu
-    Copyright 1997 Christos Zoulas
-
-    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 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.
-
-
-╔──────────────────────────────────────────────────────────────────────┬───┬───╗
-│ cosmopolitan § the unbourne shell » build                             /   /  │
-╚────────────────────────────────────────────────────────────────────'>/dev/null
-
-  cc -Os -o unbourne unbourne.c
-  exit
-
-╔────────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell » macros                               ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│*/
-
-#include "libc/assert.h"
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/dirent.h"
-#include "libc/calls/struct/rlimit.h"
-#include "libc/calls/struct/rusage.h"
-#include "libc/calls/struct/sigaction.h"
-#include "libc/calls/struct/stat.h"
-#include "libc/calls/struct/tms.h"
-#include "libc/calls/termios.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/fmt/conv.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/limits.h"
-#include "libc/log/log.h"
-#include "libc/macros.internal.h"
-#include "libc/mem/alg.h"
-#include "libc/mem/alloca.h"
-#include "libc/mem/gc.h"
-#include "libc/mem/mem.h"
-#include "libc/paths.h"
-#include "libc/runtime/runtime.h"
-#include "libc/runtime/sysconf.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/at.h"
-#include "libc/sysv/consts/dt.h"
-#include "libc/sysv/consts/f.h"
-#include "libc/sysv/consts/fd.h"
-#include "libc/sysv/consts/fileno.h"
-#include "libc/sysv/consts/o.h"
-#include "libc/sysv/consts/ok.h"
-#include "libc/sysv/consts/rlim.h"
-#include "libc/sysv/consts/s.h"
-#include "libc/sysv/consts/sig.h"
-#include "libc/sysv/consts/w.h"
-#include "third_party/gdtoa/gdtoa.h"
-#include "third_party/linenoise/linenoise.h"
-#include "third_party/musl/passwd.h"
-
-#define likely(expr)   __builtin_expect(!!(expr), 1)
-#define unlikely(expr) __builtin_expect(!!(expr), 0)
-
-#undef CEOF
-#undef rflag
-
-/*
- * The follow should be set to reflect the type of system you have:
- *  JOBS -> 1 if you have Berkeley job control, 0 otherwise.
- *  SHORTNAMES -> 1 if your linker cannot handle long names.
- *  define BSD if you are running 4.2 BSD or later.
- *  define SYSV if you are running under System V.
- *  define DEBUG=1 to compile in debugging ('set -o debug' to turn on)
- *  define DEBUG=2 to compile in and turn on debugging.
- *  define DO_SHAREDVFORK to indicate that vfork(2) shares its address
- *         with its parent.
- *
- * When debugging is on, debugging info will be written to ./trace and
- * a quit signal will generate a core dump.
- */
-
-#define ALIASDEAD      2
-#define ALIASINUSE     1
-#define ARITH_MAX_PREC 8
-#define ATABSIZE       39
-#define CMDTABLESIZE   31
-#define JOBS           1
-#define NOPTS          17
-#define OUTPUT_ERR     01
-#define VTABSIZE       39
-
-/* exceptions */
-#define EXINT   0
-#define EXERROR 1
-#define EXEND   3
-#define EXEXIT  4
-
-/*
- * The input line number.  Input.c just defines this variable, and saves
- * and restores it when files are pushed and popped.  The user of this
- * package must set its value.
- */
-#define plinno (parsefile->linno)
-
-/* Syntax classes */
-#define CWORD     0
-#define CNL       1
-#define CBACK     2
-#define CSQUOTE   3
-#define CDQUOTE   4
-#define CENDQUOTE 5
-#define CBQUOTE   6
-#define CVAR      7
-#define CENDVAR   8
-#define CLP       9
-#define CRP       10
-#define CEOF      11
-#define CCTL      12
-#define CSPCL     13
-
-/* Syntax classes for is_ functions */
-#define ISDIGIT 01
-#define ISUPPER 02
-#define ISLOWER 04
-#define ISUNDER 010
-#define ISSPECL 020
-
-#define SYNBASE 129
-#define PEOF    -129
-
-#define EOF_NLEFT -99
-
-#define BASESYNTAX (basesyntax + SYNBASE)
-#define DQSYNTAX   (dqsyntax + SYNBASE)
-#define SQSYNTAX   (sqsyntax + SYNBASE)
-#define ARISYNTAX  (arisyntax + SYNBASE)
-
-#define ARITH_ASS       1
-#define ARITH_OR        2
-#define ARITH_AND       3
-#define ARITH_BAD       4
-#define ARITH_NUM       5
-#define ARITH_VAR       6
-#define ARITH_NOT       7
-#define ARITH_BINOP_MIN 8
-#define ARITH_LE        8
-#define ARITH_GE        9
-#define ARITH_LT        10
-#define ARITH_GT        11
-#define ARITH_EQ        12
-#define ARITH_REM       13
-#define ARITH_BAND      14
-#define ARITH_LSHIFT    15
-#define ARITH_RSHIFT    16
-#define ARITH_MUL       17
-#define ARITH_ADD       18
-#define ARITH_BOR       19
-#define ARITH_SUB       20
-#define ARITH_BXOR      21
-#define ARITH_DIV       22
-#define ARITH_NE        23
-#define ARITH_BINOP_MAX 24
-#define ARITH_ASS_MIN   24
-#define ARITH_REMASS    24
-#define ARITH_BANDASS   25
-#define ARITH_LSHIFTASS 26
-#define ARITH_RSHIFTASS 27
-#define ARITH_MULASS    28
-#define ARITH_ADDASS    29
-#define ARITH_BORASS    30
-#define ARITH_SUBASS    31
-#define ARITH_BXORASS   32
-#define ARITH_DIVASS    33
-#define ARITH_ASS_MAX   34
-#define ARITH_LPAREN    34
-#define ARITH_RPAREN    35
-#define ARITH_BNOT      36
-#define ARITH_QMARK     37
-#define ARITH_COLON     38
-
-/* expandarg() flags */
-#define EXP_FULL      0x1
-#define EXP_TILDE     0x2
-#define EXP_VARTILDE  0x4
-#define EXP_REDIR     0x8
-#define EXP_CASE      0x10
-#define EXP_VARTILDE2 0x40
-#define EXP_WORD      0x80
-#define EXP_QUOTED    0x100
-#define EXP_KEEPNUL   0x200
-#define EXP_DISCARD   0x400
-
-/* reasons for skipping commands (see comment on breakcmd routine) */
-#define SKIPBREAK   (1 << 0)
-#define SKIPCONT    (1 << 1)
-#define SKIPFUNC    (1 << 2)
-#define SKIPFUNCDEF (1 << 3)
-
-#define TEOF       0
-#define TNL        1
-#define TSEMI      2
-#define TBACKGND   3
-#define TAND       4
-#define TOR        5
-#define TPIPE      6
-#define TLP        7
-#define TRP        8
-#define TENDCASE   9
-#define TENDBQUOTE 10
-#define TREDIR     11
-#define TWORD      12
-#define TNOT       13
-#define TCASE      14
-#define TDO        15
-#define TDONE      16
-#define TELIF      17
-#define TELSE      18
-#define TESAC      19
-#define TFI        20
-#define TFOR       21
-#define TIF        22
-#define TIN        23
-#define TTHEN      24
-#define TUNTIL     25
-#define TWHILE     26
-#define TBEGIN     27
-#define TEND       28
-
-/* control characters in argument strings */
-#define CTL_FIRST    -127
-#define CTLESC       -127
-#define CTLVAR       -126
-#define CTLENDVAR    -125
-#define CTLBACKQ     -124
-#define CTLARI       -122
-#define CTLENDARI    -121
-#define CTLQUOTEMARK -120
-#define CTL_LAST     -120
-
-/* variable substitution byte (follows CTLVAR) */
-#define VSTYPE 0x0f
-#define VSNUL  0x10
-
-/* values of VSTYPE field */
-#define VSNORMAL       0x1
-#define VSMINUS        0x2
-#define VSPLUS         0x3
-#define VSQUESTION     0x4
-#define VSASSIGN       0x5
-#define VSTRIMRIGHT    0x6
-#define VSTRIMRIGHTMAX 0x7
-#define VSTRIMLEFT     0x8
-#define VSTRIMLEFTMAX  0x9
-#define VSLENGTH       0xa
-/* VSLENGTH must come last. */
-
-/* values of checkkwd variable */
-#define CHKALIAS   0x1
-#define CHKKWD     0x2
-#define CHKNL      0x4
-#define CHKEOFMARK 0x8
-
-/* flags in argument to evaltree */
-#define EV_EXIT   01
-#define EV_TESTED 02
-
-#define INT_CHARS (sizeof(int) * CHAR_BIT / 3)
-
-/*
- * These macros allow the user to suspend the handling of interrupt
- * signals over a period of time. This is similar to SIGHOLD to or
- * sigblock, but much more efficient and portable. (But hacking the
- * kernel is so much more fun than worrying about efficiency and
- * portability. :-))
- */
-#define barrier() ({ asm volatile("" : : : "memory"); })
-#define INTOFF     \
-  ({               \
-    suppressint++; \
-    barrier();     \
-    0;             \
-  })
-#define INTON                             \
-  ({                                      \
-    barrier();                            \
-    if (--suppressint == 0 && intpending) \
-      onint();                            \
-    0;                                    \
-  })
-#define FORCEINTON   \
-  ({                 \
-    barrier();       \
-    suppressint = 0; \
-    if (intpending)  \
-      onint();       \
-    0;               \
-  })
-#define SAVEINT(v) ((v) = suppressint)
-#define RESTOREINT(v)                           \
-  ({                                            \
-    barrier();                                  \
-    if ((suppressint = (v)) == 0 && intpending) \
-      onint();                                  \
-    0;                                          \
-  })
-#define CLEAR_PENDING_INT intpending = 0
-#define int_pending()     intpending
-
-/*
- * Most machines require the value returned from malloc to be aligned
- * in some way.  The following macro will get this right on many machines.
- */
-#define SHELL_SIZE \
-  (sizeof(union {  \
-     int i;        \
-     char *cp;     \
-     double d;     \
-   }) -            \
-   1)
-
-/*
- * It appears that grabstackstr() will barf with such alignments
- * because stalloc() will return a string allocated in a new stackblock.
- */
-#define SHELL_ALIGN(nbytes) (((nbytes) + SHELL_SIZE) & ~SHELL_SIZE)
-
-/*
- * Minimum size of a block
- *
- * Parse trees for commands are allocated in lifo order, so we use a stack
- * to make this more efficient, and also to avoid all sorts of exception
- * handling code to handle interrupts in the middle of a parse.
- *
- * The size 504 was chosen because the Ultrix malloc handles that size
- * well.
- */
-#define MINSIZE SHELL_ALIGN(504)
-
-/* flags */
-#define VEXPORT    0x001
-#define VREADONLY  0x002
-#define VSTRFIXED  0x004
-#define VTEXTFIXED 0x008
-#define VSTACK     0x010
-#define VUNSET     0x020
-#define VNOFUNC    0x040
-#define VNOSET     0x080
-#define VNOSAVE    0x100
-
-/*
- * Evaluate a command.
- */
-#define ALIASCMD   (kBuiltinCmds + 3)
-#define BGCMD      (kBuiltinCmds + 4)
-#define BREAKCMD   (kBuiltinCmds + 5)
-#define CDCMD      (kBuiltinCmds + 6)
-#define COMMANDCMD (kBuiltinCmds + 8)
-#define DOTCMD     (kBuiltinCmds + 0)
-#define ECHOCMD    (kBuiltinCmds + 10)
-#define EVALCMD    (kBuiltinCmds + 11)
-#define EXECCMD    (kBuiltinCmds + 12)
-#define EXITCMD    (kBuiltinCmds + 13)
-#define EXPORTCMD  (kBuiltinCmds + 14)
-#define FALSECMD   (kBuiltinCmds + 15)
-#define FGCMD      (kBuiltinCmds + 16)
-#define GETOPTSCMD (kBuiltinCmds + 17)
-#define HASHCMD    (kBuiltinCmds + 18)
-#define JOBSCMD    (kBuiltinCmds + 19)
-#define KILLCMD    (kBuiltinCmds + 20)
-#define LOCALCMD   (kBuiltinCmds + 21)
-#define PRINTFCMD  (kBuiltinCmds + 22)
-#define PWDCMD     (kBuiltinCmds + 23)
-#define READCMD    (kBuiltinCmds + 24)
-#define RETURNCMD  (kBuiltinCmds + 26)
-#define SETCMD     (kBuiltinCmds + 27)
-#define SHIFTCMD   (kBuiltinCmds + 28)
-#define TESTCMD    (kBuiltinCmds + 2)
-#define TIMESCMD   (kBuiltinCmds + 30)
-#define TRAPCMD    (kBuiltinCmds + 31)
-#define TRUECMD    (kBuiltinCmds + 1)
-#define TYPECMD    (kBuiltinCmds + 33)
-#define ULIMITCMD  (kBuiltinCmds + 34)
-#define UMASKCMD   (kBuiltinCmds + 35)
-#define UNALIASCMD (kBuiltinCmds + 36)
-#define UNSETCMD   (kBuiltinCmds + 37)
-#define WAITCMD    (kBuiltinCmds + 38)
-
-#define BUILTIN_SPECIAL 0x1
-#define BUILTIN_REGULAR 0x2
-#define BUILTIN_ASSIGN  0x4
-
-/* mode flags for set_curjob */
-#define CUR_DELETE  2
-#define CUR_RUNNING 1
-#define CUR_STOPPED 0
-
-/* mode flags for dowait */
-#define DOWAIT_NONBLOCK    0
-#define DOWAIT_BLOCK       1
-#define DOWAIT_WAITCMD     2
-#define DOWAIT_WAITCMD_ALL 4
-
-/* _rmescape() flags */
-#define RMESCAPE_ALLOC 0x01
-#define RMESCAPE_GLOB  0x02
-#define RMESCAPE_GROW  0x08
-#define RMESCAPE_HEAP  0x10
-
-/* Add CTLESC when necessary. */
-#define QUOTES_ESC (EXP_FULL | EXP_CASE)
-
-#define IBUFSIZ   (BUFSIZ + 1)
-#define OUTBUFSIZ BUFSIZ
-#define MEM_OUT   -3
-
-/*
- * Sigmode records the current value of the signal handlers for the
- * various modes. A value of zero means that the current handler is not
- * known. S_HARD_IGN indicates that the signal was ignored on entry to
- * the shell,
- */
-#define S_DFL      1
-#define S_CATCH    2
-#define S_IGN      3
-#define S_HARD_IGN 4
-#define S_RESET    5
-
-#define NCMD      0
-#define NPIPE     1
-#define NREDIR    2
-#define NBACKGND  3
-#define NSUBSHELL 4
-#define NAND      5
-#define NOR       6
-#define NSEMI     7
-#define NIF       8
-#define NWHILE    9
-#define NUNTIL    10
-#define NFOR      11
-#define NCASE     12
-#define NCLIST    13
-#define NDEFUN    14
-#define NARG      15
-#define NTO       16
-#define NCLOBBER  17
-#define NFROM     18
-#define NFROMTO   19
-#define NAPPEND   20
-#define NTOFD     21
-#define NFROMFD   22
-#define NHERE     23
-#define NXHERE    24
-#define NNOT      25
-
-/* Mode argument to forkshell.  Don't change FORK_FG or FORK_BG. */
-#define FORK_FG    0
-#define FORK_BG    1
-#define FORK_NOJOB 2
-
-/* mode flags for showjob(s) */
-#define SHOW_PGID    0x01
-#define SHOW_PID     0x04
-#define SHOW_CHANGED 0x08
-
-/* values of cmdtype */
-#define CMDUNKNOWN  -1
-#define CMDNORMAL   0
-#define CMDFUNCTION 1
-#define CMDBUILTIN  2
-
-/* action to find_command() */
-#define DO_ERR      0x01
-#define DO_ABS      0x02
-#define DO_NOFUNC   0x04
-#define DO_ALTPATH  0x08
-#define DO_REGBLTIN 0x10
-
-/* flags passed to redirect */
-#define REDIR_PUSH    01
-#define REDIR_SAVEFD2 03
-
-#define CD_PHYSICAL 1
-#define CD_PRINT    2
-
-#define EMPTY    -2
-#define CLOSED   -1
-#define PIPESIZE 4096
-
-#define rootshell (!shlvl)
-
-#define eflag optlist[0]
-#define fflag optlist[1]
-#define Iflag optlist[2]
-#define iflag optlist[3]
-#define mflag optlist[4]
-#define nflag optlist[5]
-#define sflag optlist[6]
-#define xflag optlist[7]
-#define vflag optlist[8]
-#define Vflag optlist[9]
-#define Eflag optlist[10]
-#define Cflag optlist[11]
-#define aflag optlist[12]
-#define bflag optlist[13]
-#define uflag optlist[14]
-#define nolog optlist[15]
-#define debug optlist[16]
-
-/* Used by expandstr to get here-doc like behaviour. */
-#define FAKEEOFMARK (char *)1
-
-/*
- * This file is included by programs which are optionally built into the
- * shell.  If SHELL is defined, we try to map the standard UNIX library
- * routines to ash routines using defines.
- */
-#define Printf out1fmt
-#define INITARGS(argv)
-#define setprogname(s)
-#define getprogname() commandname
-
-#define setlocate(l, s) 0
-#define equal(s1, s2)   (!strcmp(s1, s2))
-#define isodigit(c)     ((c) >= '0' && (c) <= '7')
-#define octtobin(c)     ((c) - '0')
-#define scopy(s1, s2)   ((void)strcpy(s2, s1))
-
-#define TRACE(param)
-/* #define TRACE(param)   \ */
-/*   do {                 \ */
-/*     printf("TRACE: "); \ */
-/*     printf param;      \ */
-/*   } while (0) */
-
-#define TRACEV(param)
-#define digit_val(c)  ((c) - '0')
-#define is_alpha(c)   isalpha((unsigned char)(c))
-#define is_digit(c)   ((unsigned)((c) - '0') <= 9)
-#define is_in_name(c) ((c) == '_' || isalnum((unsigned char)(c)))
-#define is_name(c)    ((c) == '_' || isalpha((unsigned char)(c)))
-#define is_special(c) \
-  ((is_type + SYNBASE)[(signed char)(c)] & (ISSPECL | ISDIGIT))
-
-#define uninitialized_var(x)                       \
-  x = x /* suppress uninitialized warning w/o code \
-         */
-
-/*
- * Shell variables.
- */
-#define vifs    varinit[0]
-#define vpath   (&vifs)[1]
-#define vps1    (&vpath)[1]
-#define vps2    (&vps1)[1]
-#define vps4    (&vps2)[1]
-#define voptind (&vps4)[1]
-#define vlineno (&voptind)[1]
-#define defifs  (defifsvar + 4)
-#define defpath (defpathvar + 36)
-
-/*
- * The following macros access the values of the above variables. They
- * have to skip over the name. They return the null string for unset
- * variables.
- */
-#define ifsval()      (vifs.text + 4)
-#define ifsset()      ((vifs.flags & VUNSET) == 0)
-#define mailval()     (vmail.text + 5)
-#define mpathval()    (vmpath.text + 9)
-#define pathval()     (vpath.text + 5)
-#define ps1val()      (vps1.text + 4)
-#define ps2val()      (vps2.text + 4)
-#define ps4val()      (vps4.text + 4)
-#define optindval()   (voptind.text + 7)
-#define linenoval()   (vlineno.text + 7)
-#define mpathset()    ((vmpath.flags & VUNSET) == 0)
-#define environment() listvars(VEXPORT, VUNSET, 0)
-
-/*───────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell » data structures                      ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│*/
-
-typedef void *pointer;
-
-struct redirtab {
-  struct redirtab *next;
-  int renamed[10];
-};
-
-/*
- * We enclose jmp_buf in a structure so that we can declare pointers to
- * jump locations. The global variable handler contains the location to
- * jump to when an exception occurs, and the global variable exception
- * contains a code identifying the exception. To implement nested
- * exception handlers, the user should save the value of handler on
- * entry to an inner scope, set handler to point to a jmploc structure
- * for the inner scope, and restore handler on exit from the scope.
- */
-struct jmploc {
-  jmp_buf loc;
-};
-
-/* PEOF (the end of file marker) is defined in syntax.h */
-enum {
-  INPUT_PUSH_FILE = 1,
-  INPUT_NOFILE_OK = 2,
-};
-
-struct alias {
-  struct alias *next;
-  char *name;
-  char *val;
-  int flag;
-};
-
-struct shparam {
-  int nparam;           /* # of positional parameters (without $0) */
-  unsigned char malloc; /* if parameter list dynamically allocated */
-  char **p;             /* parameter list */
-  int optind;           /* next parameter to be processed by getopts */
-  int optoff;           /* used by getopts */
-};
-
-struct strpush {
-  struct strpush *prev; /* preceding string on stack */
-  char *prevstring;
-  int prevnleft;
-  struct alias *ap;       /* if push was associated with an alias */
-  char *string;           /* remember the string since it may change */
-  struct strpush *spfree; /* Delay freeing so we can stop nested aliases. */
-  int lastc[2];           /* Remember last two characters for pungetc. */
-  int unget;              /* Number of outstanding calls to pungetc. */
-};
-
-/*
- * The parsefile structure pointed to by the global variable parsefile
- * contains information about the current file being read.
- */
-struct parsefile {
-  struct parsefile *prev;     /* preceding file on stack */
-  int linno;                  /* current line */
-  int fd;                     /* file descriptor (or -1 if string) */
-  int nleft;                  /* number of chars left in this line */
-  int lleft;                  /* number of chars left in this buffer */
-  char *nextc;                /* next char in buffer */
-  char *buf;                  /* input buffer */
-  struct strpush *strpush;    /* for pushing strings at this level */
-  struct strpush basestrpush; /* so pushing one is fast */
-  struct strpush *spfree;     /* Delay freeing so we can stop nested aliases. */
-  int lastc[2];               /* Remember last two characters for pungetc. */
-  int unget;                  /* Number of outstanding calls to pungetc. */
-};
-
-struct output {
-  char *nextc;
-  char *end;
-  char *buf;
-  unsigned bufsize;
-  int fd;
-  int flags;
-};
-
-struct heredoc {
-  struct heredoc *next; /* next here document in list */
-  union node *here;     /* redirection node */
-  char *eofmark;        /* string indicating end of input */
-  int striptabs;        /* if set, strip leading tabs */
-};
-
-struct synstack {
-  const char *syntax;
-  struct synstack *prev;
-  struct synstack *next;
-  int innerdq;
-  int varpushed;
-  int dblquote;
-  int varnest;    /* levels of variables expansion */
-  int parenlevel; /* levels of parens in arithmetic */
-  int dqvarnest;  /* levels of variables expansion within double quotes */
-};
-
-struct procstat {
-  int pid;    /* process id */
-  int status; /* last process status from wait() */
-  char *cmd;  /* text of command being run */
-};
-
-/*
- * A job structure contains information about a job.  A job is either a
- * single process or a set of processes contained in a pipeline.  In the
- * latter case, pidlist will be non-NULL, and will point to a -1 terminated
- * array of pids.
- */
-struct job {
-  struct procstat ps0;  /* status of process */
-  struct procstat *ps;  /* status or processes when more than one */
-  int stopstatus;       /* status of a stopped job */
-  unsigned nprocs : 16, /* number of processes */
-      state : 8,
-#define JOBRUNNING 0
-#define JOBSTOPPED 1
-#define JOBDONE    2
-      sigint : 1,       /* job was killed by SIGINT */
-      jobctl : 1,       /* job running under job control */
-      waited : 1,       /* true if this entry has been waited for */
-      used : 1,         /* true if this entry is in used */
-      changed : 1;      /* true if status has changed */
-  struct job *prev_job; /* previous job */
-};
-
-struct ncmd {
-  int type;
-  int linno;
-  union node *assign;
-  union node *args;
-  union node *redirect;
-};
-
-struct npipe {
-  int type;
-  int backgnd;
-  struct nodelist *cmdlist;
-};
-
-struct nredir {
-  int type;
-  int linno;
-  union node *n;
-  union node *redirect;
-};
-
-struct nbinary {
-  int type;
-  union node *ch1;
-  union node *ch2;
-};
-
-struct nif {
-  int type;
-  union node *test;
-  union node *ifpart;
-  union node *elsepart;
-};
-
-struct nfor {
-  int type;
-  int linno;
-  union node *args;
-  union node *body;
-  char *var_;
-};
-
-struct ncase {
-  int type;
-  int linno;
-  union node *expr;
-  union node *cases;
-};
-
-struct nclist {
-  int type;
-  union node *next;
-  union node *pattern;
-  union node *body;
-};
-
-struct ndefun {
-  int type;
-  int linno;
-  char *text;
-  union node *body;
-};
-
-struct narg {
-  int type;
-  union node *next;
-  char *text;
-  struct nodelist *backquote;
-};
-
-struct nfile {
-  int type;
-  union node *next;
-  int fd;
-  union node *fname;
-  char *expfname;
-};
-
-struct ndup {
-  int type;
-  union node *next;
-  int fd;
-  int dupfd;
-  union node *vname;
-};
-
-struct nhere {
-  int type;
-  union node *next;
-  int fd;
-  union node *doc;
-};
-
-struct nnot {
-  int type;
-  union node *com;
-};
-
-union node {
-  int type;
-  struct ncmd ncmd;
-  struct npipe npipe;
-  struct nredir nredir;
-  struct nbinary nbinary;
-  struct nif nif;
-  struct nfor nfor;
-  struct ncase ncase;
-  struct nclist nclist;
-  struct ndefun ndefun;
-  struct narg narg;
-  struct nfile nfile;
-  struct ndup ndup;
-  struct nhere nhere;
-  struct nnot nnot;
-};
-
-struct nodelist {
-  struct nodelist *next;
-  union node *n;
-};
-
-struct funcnode {
-  int count;
-  union node n;
-};
-
-struct localvar_list {
-  struct localvar_list *next;
-  struct localvar *lv;
-};
-
-struct Var {
-  struct Var *next; /* next entry in hash list */
-  int flags;        /* flags are defined above */
-  const char *text; /* name=value */
-  void (*func)(const char *);
-  /* function to be called when  */
-  /* the variable gets set/unset */
-};
-
-struct localvar {
-  struct localvar *next; /* next local variable in list */
-  struct Var *vp;        /* the variable that was made local */
-  int flags;             /* saved flags */
-  const char *text;      /* saved text */
-};
-
-union yystype {
-  int64_t val;
-  char *name;
-};
-
-struct strlist {
-  struct strlist *next;
-  char *text;
-};
-
-struct arglist {
-  struct strlist *list;
-  struct strlist **lastp;
-};
-
-/*
- * Structure specifying which parts of the string should be searched
- * for IFS characters.
- */
-struct ifsregion {
-  struct ifsregion *next; /* next region in list */
-  int begoff;             /* offset of start of region */
-  int endoff;             /* offset of end of region */
-  int nulonly;            /* search for nul bytes only */
-};
-
-struct builtincmd {
-  const char *name;
-  int (*builtin)(int, char **);
-  unsigned flags;
-};
-
-struct cmdentry {
-  int cmdtype;
-  union param {
-    int index;
-    const struct builtincmd *cmd;
-    struct funcnode *func;
-  } u;
-};
-
-struct tblentry {
-  struct tblentry *next; /* next entry in hash chain */
-  union param param;     /* definition of builtin function */
-  short cmdtype;         /* index identifying command */
-  char rehash;           /* if set, cd done since entry created */
-  char cmdname[];        /* name of command */
-};
-
-struct backcmd {  /* result of evalbackcmd */
-  int fd;         /* file descriptor to read from */
-  char *buf;      /* buffer */
-  int nleft;      /* number of chars in buffer */
-  struct job *jp; /* job structure for command */
-};
-
-struct stack_block {
-  struct stack_block *prev;
-  char space[MINSIZE];
-};
-
-struct stackmark {
-  struct stack_block *stackp;
-  char *stacknxt;
-  unsigned stacknleft;
-};
-
-struct limits {
-  const char *name;
-  int cmd;
-  int factor; /* multiply by to get rlim_{cur,max} values */
-  char option;
-};
-
-struct t_op {
-  const char *op_text;
-  short op_num, op_type;
-};
-
-/*───────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell » bss                                  ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│*/
-
-static char **argptr; /* argument list for builtin commands */
-static char **gargv;
-static char **t_wp;
-static char *arg0; /* value of $0 */
-static char *cmdnextc;
-static char *commandname;
-static char *expdest; /* output of current string */
-static char *expdir;
-static char *funcstring;      /* block to allocate strings from */
-static char *minusc;          /* argument to -c option */
-static char *optionarg;       /* set by nextopt (like getopt) */
-static char *optptr;          /* used by nextopt */
-static char *trap[NSIG];      /* trap handler commands */
-static char *wordtext;        /* text of last word returned by readtoken */
-static char basebuf[IBUFSIZ]; /* buffer for top level input file */
-static char gotsig[NSIG - 1]; /* indicates specified signal received */
-static char nullstr[1];       /* zero length string */
-static char optlist[NOPTS];
-static char sigmode[NSIG - 1]; /* current value of signal */
-static const char *arith_buf;
-static const char *arith_startbuf;
-static const char *pathopt;
-static int back_exitstatus; /* exit status of backquoted command */
-static int checkkwd;
-static int doprompt; /* if set, prompt the user */
-static int errlinno;
-static int evalskip; /* set if we are skipping commands */
-static int exception;
-static int exitstatus;     /* exit status of last command */
-static int funcblocksize;  /* size of structures in function */
-static int funcline;       /* start line of function, or 0 if not in one */
-static int funcstringsize; /* size of strings in node */
-static int initialpgrp;    /* pgrp of shell on invocation */
-static int inps4;          /* Prevent PS4 nesting. */
-static int job_warning;
-static int jobctl;
-static int last_token;
-static int lasttoken; /* last token read */
-static int lineno;
-static int loopnest;   /* current loop nesting level */
-static int needprompt; /* true if interactive and at start of line */
-static int quoteflag;  /* set if (part of) last token was quoted */
-static int rootpid;
-static int rval;
-static int shlvl;
-static int skipcount; /* number of levels to skip */
-static int suppressint;
-static int tokpushback;       /* last token pushed back */
-static int trapcnt;           /* number of non-null traps */
-static int ttyfd = -1;        /* control terminal */
-static int vforked;           /* Set if we are in the vforked child */
-static int whichprompt;       /* 1 == PS1, 2 == PS2 */
-static int backgndpid;        /* pid of last background process */
-static pointer funcblock;     /* block to allocate function from */
-static struct arglist exparg; /* holds expanded arg list */
-static struct heredoc *heredoc;
-static struct heredoc *heredoclist; /* list of here documents to read */
-static struct ifsregion *ifslastp;  /* last struct in list */
-static struct ifsregion ifsfirst;   /* first struct in list of ifs regions */
-static struct jmploc *handler;
-static struct jmploc main_handler;
-static struct job *curjob; /* current job */
-static struct job *jobtab; /* array of jobs */
-static struct localvar_list *localvar_stack;
-static struct nodelist *argbackq; /* list of back quote expressions */
-static struct nodelist *backquotelist;
-static struct output preverrout;
-static struct parsefile basepf; /* top level input file */
-static struct redirtab *redirlist;
-static struct shparam shellparam; /* current positional parameters */
-static struct stack_block stackbase;
-static struct t_op const *t_wp_op;
-static struct tblentry **lastcmdentry;
-static struct tblentry *cmdtable[CMDTABLESIZE];
-static struct Var *vartab[VTABSIZE];
-static union node *redirnode;
-static union yystype yylval;
-static unsigned
-    closed_redirs; /* Bit map of currently closed file descriptors. */
-static unsigned expdir_max;
-static unsigned njobs;                   /* size of array */
-static volatile sig_atomic_t gotsigchld; /* received SIGCHLD */
-static volatile sig_atomic_t intpending;
-static volatile sig_atomic_t pending_sig; /* last pending signal */
-static struct alias *atab[ATABSIZE];
-
-/*───────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell » data                                 ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│*/
-
-static char *curdir = nullstr;  /* current working directory */
-static char *physdir = nullstr; /* physical working directory */
-static char *sstrend = stackbase.space + MINSIZE;
-static char *stacknxt = stackbase.space;
-static char defifsvar[] = "IFS= \t\n";
-static char defoptindvar[] = "OPTIND=1";
-static char linenovar[sizeof("LINENO=") + INT_CHARS + 1] = "LINENO=";
-static int builtinloc = -1; /* index in path of %builtin, or -1 */
-static int savestatus = -1; /* exit status of last command outside traps */
-static struct output errout = {0, 0, 0, 0, 2, 0};
-static struct output output = {0, 0, 0, OUTBUFSIZ, 1, 0};
-static struct parsefile *parsefile = &basepf; /* current input file */
-static struct stack_block *stackp = &stackbase;
-static unsigned stacknleft = MINSIZE;
-
-static struct output *out1 = &output;
-static struct output *out2 = &errout;
-
-/*───────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell » rodata                               ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│*/
-
-/* Array indicating which tokens mark the end of a list */
-static const char tokendlist[] = {
-    1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0,
-    1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1,
-};
-
-static const char *const tokname[] = {
-    "end of file", "newline",     "\";\"",    "\"&\"",    "\"&&\"",
-    "\"||\"",      "\"|\"",       "\"(\"",    "\")\"",    "\";;\"",
-    "\"`\"",       "redirection", "word",     "\"!\"",    "\"case\"",
-    "\"do\"",      "\"done\"",    "\"elif\"", "\"else\"", "\"esac\"",
-    "\"fi\"",      "\"for\"",     "\"if\"",   "\"in\"",   "\"then\"",
-    "\"until\"",   "\"while\"",   "\"{\"",    "\"}\"",
-};
-
-static const char *const parsekwd[] = {
-    "!",   "case", "do", "done", "elif",  "else",  "esac", "fi",
-    "for", "if",   "in", "then", "until", "while", "{",    "}"};
-
-static const char defpathvar[] =
-    "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
-
-static const char *const optnames[NOPTS] = {
-    "errexit",   "noglob", "ignoreeof", "interactive", "monitor", "noexec",
-    "stdin",     "xtrace", "verbose",   "vi",          "emacs",   "noclobber",
-    "allexport", "notify", "nounset",   "nolog",       "debug",
-};
-
-static const char optletters[NOPTS] = {
-    'e', 'f', 'I', 'i', 'm', 'n', 's', 'x', 'v',
-    'V', 'E', 'C', 'a', 'b', 'u', 0,   0,
-};
-
-static const char spcstr[] = " ";
-static const char snlfmt[] = "%s\n";
-static const char qchars[] = {CTLESC, CTLQUOTEMARK, 0};
-static const char illnum[] = "Illegal number: %s";
-static const char homestr[] = "HOME";
-static const char dolatstr[] = {CTLQUOTEMARK, CTLVAR,       VSNORMAL, '@',
-                                '=',          CTLQUOTEMARK, '\0'};
-
-/* TODO(jart): What's wrong with varinit? */
-#if defined(__GNUC__) || defined(__llvm__)
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-
-/* Some macros depend on the order, add new variables to the end. */
-static void changepath(const char *);
-static void getoptsreset(const char *);
-
-static struct Var varinit[] = {
-    {0, VSTRFIXED | VTEXTFIXED, defifsvar, 0},
-    {0, VSTRFIXED | VTEXTFIXED, defpathvar, changepath},
-    {0, VSTRFIXED | VTEXTFIXED, "PS1=$ ", 0},
-    {0, VSTRFIXED | VTEXTFIXED, "PS2=> ", 0},
-    {0, VSTRFIXED | VTEXTFIXED, "PS4=+ ", 0},
-    {0, VSTRFIXED | VTEXTFIXED, defoptindvar, getoptsreset},
-    {0, VSTRFIXED | VTEXTFIXED, linenovar, 0},
-};
-
-static const char kPrec[ARITH_BINOP_MAX - ARITH_BINOP_MIN] = {
-#define ARITH_PRECEDENCE(OP, PREC) [OP - ARITH_BINOP_MIN] = PREC
-    ARITH_PRECEDENCE(ARITH_MUL, 0),    ARITH_PRECEDENCE(ARITH_DIV, 0),
-    ARITH_PRECEDENCE(ARITH_REM, 0),    ARITH_PRECEDENCE(ARITH_ADD, 1),
-    ARITH_PRECEDENCE(ARITH_SUB, 1),    ARITH_PRECEDENCE(ARITH_LSHIFT, 2),
-    ARITH_PRECEDENCE(ARITH_RSHIFT, 2), ARITH_PRECEDENCE(ARITH_LT, 3),
-    ARITH_PRECEDENCE(ARITH_LE, 3),     ARITH_PRECEDENCE(ARITH_GT, 3),
-    ARITH_PRECEDENCE(ARITH_GE, 3),     ARITH_PRECEDENCE(ARITH_EQ, 4),
-    ARITH_PRECEDENCE(ARITH_NE, 4),     ARITH_PRECEDENCE(ARITH_BAND, 5),
-    ARITH_PRECEDENCE(ARITH_BXOR, 6),   ARITH_PRECEDENCE(ARITH_BOR, 7),
-#undef ARITH_PRECEDENCE
-};
-
-static const short nodesize[26] /* clang-format off */ = {
-    SHELL_ALIGN(sizeof(struct ncmd)),    SHELL_ALIGN(sizeof(struct npipe)),
-    SHELL_ALIGN(sizeof(struct nredir)),  SHELL_ALIGN(sizeof(struct nredir)),
-    SHELL_ALIGN(sizeof(struct nredir)),  SHELL_ALIGN(sizeof(struct nbinary)),
-    SHELL_ALIGN(sizeof(struct nbinary)), SHELL_ALIGN(sizeof(struct nbinary)),
-    SHELL_ALIGN(sizeof(struct nif)),     SHELL_ALIGN(sizeof(struct nbinary)),
-    SHELL_ALIGN(sizeof(struct nbinary)), SHELL_ALIGN(sizeof(struct nfor)),
-    SHELL_ALIGN(sizeof(struct ncase)),   SHELL_ALIGN(sizeof(struct nclist)),
-    SHELL_ALIGN(sizeof(struct ndefun)),  SHELL_ALIGN(sizeof(struct narg)),
-    SHELL_ALIGN(sizeof(struct nfile)),   SHELL_ALIGN(sizeof(struct nfile)),
-    SHELL_ALIGN(sizeof(struct nfile)),   SHELL_ALIGN(sizeof(struct nfile)),
-    SHELL_ALIGN(sizeof(struct nfile)),   SHELL_ALIGN(sizeof(struct ndup)),
-    SHELL_ALIGN(sizeof(struct ndup)),    SHELL_ALIGN(sizeof(struct nhere)),
-    SHELL_ALIGN(sizeof(struct nhere)),   SHELL_ALIGN(sizeof(struct nnot)),
-} /* clang-format on */;
-
-/* syntax table used when not in quotes */
-static const char basesyntax[] /* clang-format off */ = {
-    CEOF,    CWORD,   CCTL,    CCTL,  CCTL,  CCTL,  CCTL,    CCTL,  CCTL,
-    CCTL,    CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CSPCL, CNL,   CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CSPCL,
-    CWORD,   CDQUOTE, CWORD,   CVAR,  CWORD, CSPCL, CSQUOTE, CSPCL, CSPCL,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CSPCL,
-    CSPCL,   CWORD,   CSPCL,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CBACK, CWORD,   CWORD, CWORD,
-    CBQUOTE, CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CWORD,   CWORD,   CWORD, CWORD, CWORD, CWORD,   CWORD, CWORD,
-    CWORD,   CSPCL,   CENDVAR, CWORD, CWORD
-} /* clang-format on */;
-
-/* syntax table used when in double quotes */
-static const char dqsyntax[] /* clang-format off */ = {
-    CEOF,    CWORD,     CCTL,    CCTL,  CCTL,  CCTL,  CCTL,  CCTL,  CCTL,
-    CCTL,    CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CNL,   CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CCTL,    CENDQUOTE, CWORD,   CVAR,  CWORD, CWORD, CWORD, CWORD, CWORD,
-    CCTL,    CWORD,     CWORD,   CCTL,  CWORD, CCTL,  CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CCTL,  CWORD,
-    CWORD,   CCTL,      CWORD,   CCTL,  CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CCTL,  CBACK, CCTL,  CWORD, CWORD,
-    CBQUOTE, CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD,     CENDVAR, CCTL,  CWORD
-} /* clang-format on */;
-
-/* syntax table used when in single quotes */
-static const char sqsyntax[] /* clang-format off */ = {
-    CEOF,  CWORD, CCTL,  CCTL,  CCTL,  CCTL,  CCTL,      CCTL,  CCTL,
-    CCTL,  CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CNL,   CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CCTL,  CWORD, CWORD, CWORD, CWORD, CWORD, CENDQUOTE, CWORD, CWORD,
-    CCTL,  CWORD, CWORD, CCTL,  CWORD, CCTL,  CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CCTL,  CWORD,
-    CWORD, CCTL,  CWORD, CCTL,  CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CCTL,  CCTL,  CCTL,      CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,     CWORD, CWORD,
-    CWORD, CWORD, CWORD, CCTL,  CWORD
-} /* clang-format on */;
-
-/* syntax table used when in arithmetic */
-static const char arisyntax[] /* clang-format off */ = {
-    CEOF,    CWORD, CCTL,    CCTL,  CCTL,  CCTL,  CCTL,  CCTL,  CCTL,
-    CCTL,    CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CNL,   CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CVAR,  CWORD, CWORD, CWORD, CLP,   CRP,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CBACK, CWORD, CWORD, CWORD,
-    CBQUOTE, CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CWORD,   CWORD, CWORD, CWORD, CWORD, CWORD, CWORD,
-    CWORD,   CWORD, CENDVAR, CWORD, CWORD
-} /* clang-format on */;
-
-/* character classification table */
-static const char is_type[] /* clang-format off */ = {
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       0,       0,       0,       0,       0,       0,
-    0,       0,       ISSPECL, 0,       ISSPECL, ISSPECL, 0,       0,
-    0,       0,       0,       ISSPECL, 0,       0,       ISSPECL, 0,
-    0,       ISDIGIT, ISDIGIT, ISDIGIT, ISDIGIT, ISDIGIT, ISDIGIT, ISDIGIT,
-    ISDIGIT, ISDIGIT, ISDIGIT, 0,       0,       0,       0,       0,
-    ISSPECL, ISSPECL, ISUPPER, ISUPPER, ISUPPER, ISUPPER, ISUPPER, ISUPPER,
-    ISUPPER, ISUPPER, ISUPPER, ISUPPER, ISUPPER, ISUPPER, ISUPPER, ISUPPER,
-    ISUPPER, ISUPPER, ISUPPER, ISUPPER, ISUPPER, ISUPPER, ISUPPER, ISUPPER,
-    ISUPPER, ISUPPER, ISUPPER, ISUPPER, 0,       0,       0,       0,
-    ISUNDER, 0,       ISLOWER, ISLOWER, ISLOWER, ISLOWER, ISLOWER, ISLOWER,
-    ISLOWER, ISLOWER, ISLOWER, ISLOWER, ISLOWER, ISLOWER, ISLOWER, ISLOWER,
-    ISLOWER, ISLOWER, ISLOWER, ISLOWER, ISLOWER, ISLOWER, ISLOWER, ISLOWER,
-    ISLOWER, ISLOWER, ISLOWER, ISLOWER, 0,       0,       0,       0,
-    0
-} /* clang-format on */;
-
-static int aliascmd();
-static int bgcmd();
-static int breakcmd();
-static int cdcmd();
-static int commandcmd();
-static int dotcmd();
-static int echocmd();
-static int evalcmd();
-static int execcmd();
-static int exitcmd();
-static int exportcmd();
-static int falsecmd();
-static int fgcmd();
-static int getoptscmd();
-static int hashcmd();
-static int jobscmd();
-static int killcmd();
-static int localcmd();
-static int printfcmd();
-static int pwdcmd();
-static int readcmd();
-static int returncmd();
-static int setcmd();
-static int shiftcmd();
-static int testcmd();
-static int timescmd();
-static int trapcmd();
-static int truecmd();
-static int typecmd();
-static int ulimitcmd();
-static int umaskcmd();
-static int unaliascmd();
-static int unsetcmd();
-static int waitcmd();
-
-static const struct builtincmd kBuiltinCmds[] = {
-    {".", dotcmd, 3},            //
-    {":", truecmd, 3},           //
-    {"[", testcmd, 0},           //
-    {"alias", aliascmd, 6},      //
-    {"bg", bgcmd, 2},            //
-    {"break", breakcmd, 3},      //
-    {"cd", cdcmd, 2},            //
-    {"chdir", cdcmd, 0},         //
-    {"command", commandcmd, 2},  //
-    {"continue", breakcmd, 3},   //
-    {"echo", echocmd, 0},        //
-    {"eval", NULL, 3},           //
-    {"exec", execcmd, 3},        //
-    {"exit", exitcmd, 3},        //
-    {"export", exportcmd, 7},    //
-    {"false", falsecmd, 2},      //
-    {"fg", fgcmd, 2},            //
-    {"getopts", getoptscmd, 2},  //
-    {"hash", hashcmd, 2},        //
-    {"jobs", jobscmd, 2},        //
-    {"kill", killcmd, 2},        //
-    {"local", localcmd, 7},      //
-    {"printf", printfcmd, 0},    //
-    {"pwd", pwdcmd, 2},          //
-    {"read", readcmd, 2},        //
-    {"readonly", exportcmd, 7},  //
-    {"return", returncmd, 3},    //
-    {"set", setcmd, 3},          //
-    {"shift", shiftcmd, 3},      //
-    {"test", testcmd, 0},        //
-    {"times", timescmd, 3},      //
-    {"trap", trapcmd, 3},        //
-    {"true", truecmd, 2},        //
-    {"type", typecmd, 2},        //
-    {"ulimit", ulimitcmd, 2},    //
-    {"umask", umaskcmd, 2},      //
-    {"unalias", unaliascmd, 2},  //
-    {"unset", unsetcmd, 3},      //
-    {"wait", waitcmd, 2},        //
-};
-
-enum token {
-  EOI,
-  FILRD,
-  FILWR,
-  FILEX,
-  FILEXIST,
-  FILREG,
-  FILDIR,
-  FILCDEV,
-  FILBDEV,
-  FILFIFO,
-  FILSOCK,
-  FILSYM,
-  FILGZ,
-  FILTT,
-  FILSUID,
-  FILSGID,
-  FILSTCK,
-  FILNT,
-  FILOT,
-  FILEQ,
-  FILUID,
-  FILGID,
-  STREZ,
-  STRNZ,
-  STREQ,
-  STRNE,
-  STRLT,
-  STRGT,
-  INTEQ,
-  INTNE,
-  INTGE,
-  INTGT,
-  INTLE,
-  INTLT,
-  UNOT,
-  BAND,
-  BOR,
-  LPAREN,
-  RPAREN,
-  OPERAND
-};
-
-enum token_types { UNOP, BINOP, BUNOP, BBINOP, PAREN };
-
-static struct t_op const ops[] = {
-    {"-r", FILRD, UNOP},
-    {"-w", FILWR, UNOP},
-    {"-x", FILEX, UNOP},
-    {"-e", FILEXIST, UNOP},
-    {"-f", FILREG, UNOP},
-    {"-d", FILDIR, UNOP},
-    {"-c", FILCDEV, UNOP},
-    {"-b", FILBDEV, UNOP},
-    {"-p", FILFIFO, UNOP},
-    {"-u", FILSUID, UNOP},
-    {"-g", FILSGID, UNOP},
-    {"-k", FILSTCK, UNOP},
-    {"-s", FILGZ, UNOP},
-    {"-t", FILTT, UNOP},
-    {"-z", STREZ, UNOP},
-    {"-n", STRNZ, UNOP},
-    {"-h", FILSYM, UNOP}, /* for backwards compat */
-    {"-O", FILUID, UNOP},
-    {"-G", FILGID, UNOP},
-    {"-L", FILSYM, UNOP},
-    {"-S", FILSOCK, UNOP},
-    {"=", STREQ, BINOP},
-    {"!=", STRNE, BINOP},
-    {"<", STRLT, BINOP},
-    {">", STRGT, BINOP},
-    {"-eq", INTEQ, BINOP},
-    {"-ne", INTNE, BINOP},
-    {"-ge", INTGE, BINOP},
-    {"-gt", INTGT, BINOP},
-    {"-le", INTLE, BINOP},
-    {"-lt", INTLT, BINOP},
-    {"-nt", FILNT, BINOP},
-    {"-ot", FILOT, BINOP},
-    {"-ef", FILEQ, BINOP},
-    {"!", UNOT, BUNOP},
-    {"-a", BAND, BBINOP},
-    {"-o", BOR, BBINOP},
-    {"(", LPAREN, PAREN},
-    {")", RPAREN, PAREN},
-    {0, 0, 0},
-};
-
-/*───────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell » text                                 ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│*/
-
-/*
- * Hack to calculate maximum length.
- * (length * 8 - 1) * log10(2) + 1 + 1 + 12
- * The second 1 is for the minus sign and the 12 is a safety margin.
- */
-static inline int max_int_length(int bytes) {
-  return (bytes * 8 - 1) * 0.30102999566398119521 + 14;
-}
-
-/* prefix -- see if pfx is a prefix of string. */
-static char *prefix(const char *string, const char *pfx) {
-  while (*pfx) {
-    if (*pfx++ != *string++)
-      return 0;
-  }
-  return (char *)string;
-}
-
-/*
- * Wrapper around strcmp for qsort/bsearch/...
- */
-static int pstrcmp(const void *a, const void *b) {
-  return strcmp(*(const char *const *)a, *(const char *const *)b);
-}
-
-/*
- * Find a string is in a sorted array.
- */
-static const char *const *findstring(const char *s, const char *const *array,
-                                     unsigned nmemb) {
-  return bsearch(&s, array, nmemb, sizeof(const char *), pstrcmp);
-}
-
-/* Types of operations (passed to the errmsg routine). */
-enum ShErrorAction { E_OPEN, E_CREAT, E_EXEC };
-
-/*
- * Return a string describing an error.  The returned string may be a
- * pointer to a static buffer that will be overwritten on the next call.
- * Action describes the operation that got the error.
- */
-static const char *errmsg(int e, enum ShErrorAction action) {
-  if (e != ENOENT && e != ENOTDIR)
-    return strerror(e);
-  switch (action) {
-    case E_OPEN:
-      return "No such file";
-    case E_CREAT:
-      return "Directory nonexistent";
-    default:
-      return "not found";
-  }
-}
-
-static inline void sigclearmask(void) {
-  sigset_t set;
-  sigemptyset(&set);
-  sigprocmask(SIG_SETMASK, &set, 0);
-}
-
-/*
- * Called to raise an exception.  Since C doesn't include exceptions, we
- * just do a longjmp to the exception handler.  The type of exception is
- * stored in the global variable "exception".
- */
-wontreturn static void exraise(int e) {
-  if (vforked)
-    _exit(exitstatus);
-  INTOFF;
-  exception = e;
-  longjmp(handler->loc, 1);
-}
-
-/*
- * Called from trap.c when a SIGINT is received.  (If the user specifies
- * that SIGINT is to be trapped or ignored using the trap builtin, then
- * this routine is not called.)  Suppressint is nonzero when interrupts
- * are held using the INTOFF macro.  (The test for iflag is just
- * defensive programming.)
- */
-wontreturn static void onint(void) {
-  intpending = 0;
-  sigclearmask();
-  if (!(rootshell && iflag)) {
-    signal(SIGINT, SIG_DFL);
-    raise(SIGINT);
-  }
-  exitstatus = SIGINT + 128;
-  exraise(EXINT);
-}
-
-static pointer ckmalloc(unsigned nbytes) {
-  pointer p;
-  if (!(p = malloc(nbytes)))
-    abort();
-  return p;
-}
-
-static pointer ckrealloc(pointer p, unsigned nbytes) {
-  if (!(p = realloc(p, nbytes)))
-    abort();
-  return p;
-}
-
-#define stackblock()     ((void *)stacknxt)
-#define stackblocksize() stacknleft
-#define STARTSTACKSTR(p) ((p) = stackblock())
-#define STPUTC(c, p)     ((p) = _STPUTC((c), (p)))
-#define CHECKSTRSPACE(n, p)     \
-  ({                            \
-    char *q = (p);              \
-    unsigned l = (n);           \
-    unsigned m = sstrend - q;   \
-    if (l > m)                  \
-      (p) = makestrspace(l, q); \
-    0;                          \
-  })
-#define USTPUTC(c, p) (*p++ = (c))
-#define STACKSTRNUL(p) \
-  ((p) == sstrend ? (p = growstackstr(), *p = '\0') : (*p = '\0'))
-#define STUNPUTC(p)          (--p)
-#define STTOPC(p)            p[-1]
-#define STADJUST(amount, p)  (p += (amount))
-#define grabstackstr(p)      stalloc((char *)(p) - (char *)stackblock())
-#define ungrabstackstr(s, p) stunalloc((s))
-#define stackstrend()        ((void *)sstrend)
-#define ckfree(p)            free((pointer)(p))
-
-static pointer stalloc(unsigned nbytes) {
-  char *p;
-  unsigned aligned;
-  aligned = SHELL_ALIGN(nbytes);
-  if (aligned > stacknleft) {
-    unsigned len;
-    unsigned blocksize;
-    struct stack_block *sp;
-    blocksize = aligned;
-    if (blocksize < MINSIZE)
-      blocksize = MINSIZE;
-    len = sizeof(struct stack_block) - MINSIZE + blocksize;
-    if (len < blocksize)
-      abort();
-    INTOFF;
-    sp = ckmalloc(len);
-    sp->prev = stackp;
-    stacknxt = sp->space;
-    stacknleft = blocksize;
-    sstrend = stacknxt + blocksize;
-    stackp = sp;
-    INTON;
-  }
-  p = stacknxt;
-  stacknxt += aligned;
-  stacknleft -= aligned;
-  return p;
-}
-
-static inline void grabstackblock(unsigned len) {
-  stalloc(len);
-}
-
-static void pushstackmark(struct stackmark *mark, unsigned len) {
-  mark->stackp = stackp;
-  mark->stacknxt = stacknxt;
-  mark->stacknleft = stacknleft;
-  grabstackblock(len);
-}
-
-static void popstackmark(struct stackmark *mark) {
-  struct stack_block *sp;
-  INTOFF;
-  while (stackp != mark->stackp) {
-    sp = stackp;
-    stackp = sp->prev;
-    ckfree(sp);
-  }
-  stacknxt = mark->stacknxt;
-  stacknleft = mark->stacknleft;
-  sstrend = mark->stacknxt + mark->stacknleft;
-  INTON;
-}
-
-static void setstackmark(struct stackmark *mark) {
-  pushstackmark(mark, stacknxt == stackp->space && stackp != &stackbase);
-}
-
-static void stunalloc(pointer p) {
-  stacknleft += stacknxt - (char *)p;
-  stacknxt = p;
-}
-
-/* Like strdup but works with the ash stack. */
-static char *sstrdup(const char *p) {
-  unsigned len = strlen(p) + 1;
-  return memcpy(stalloc(len), p, len);
-}
-
-int __xwrite(int, const void *, uint64_t);
-
-static void flushout(struct output *dest) {
-  unsigned len;
-  len = dest->nextc - dest->buf;
-  if (!len || dest->fd < 0)
-    return;
-  dest->nextc = dest->buf;
-  if ((__xwrite(dest->fd, dest->buf, len)))
-    dest->flags |= OUTPUT_ERR;
-}
-
-static void flushall(void) {
-  flushout(&output);
-}
-
-/*───────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell » output routines                      ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│─╝
-        When a builtin command is interrupted we have to discard
-                any pending output.
-        When a builtin command appears in back quotes, we want to
-                save the output of the command in a region obtained
-                via malloc, rather than doing a fork and reading the
-                output of the command via a pipe. */
-
-static int xvsnprintf(char *outbuf, unsigned length, const char *fmt,
-                      va_list ap) {
-  int ret;
-  INTOFF;
-  ret = vsnprintf(outbuf, length, fmt, ap);
-  INTON;
-  return ret;
-}
-
-static int Xvasprintf(char **sp, unsigned size, const char *f, va_list ap) {
-  char *s;
-  int len;
-  va_list ap2;
-  va_copy(ap2, ap);
-  len = xvsnprintf(*sp, size, f, ap2);
-  va_end(ap2);
-  if (len < 0)
-    abort();
-  if (len < size)
-    return len;
-  s = stalloc((len >= stackblocksize() ? len : stackblocksize()) + 1);
-  *sp = s;
-  len = xvsnprintf(s, len + 1, f, ap);
-  return len;
-}
-
-static void outmem(const char *p, unsigned len, struct output *dest) {
-  unsigned bufsize;
-  unsigned offset;
-  unsigned nleft;
-  nleft = dest->end - dest->nextc;
-  if (likely(nleft >= len)) {
-  buffered:
-    dest->nextc = mempcpy(dest->nextc, p, len);
-    return;
-  }
-  bufsize = dest->bufsize;
-  if (!bufsize) {
-    (void)0;
-  } else if (dest->buf == NULL) {
-    offset = 0;
-    INTOFF;
-    dest->buf = ckrealloc(dest->buf, bufsize);
-    dest->bufsize = bufsize;
-    dest->end = dest->buf + bufsize;
-    dest->nextc = dest->buf + offset;
-    INTON;
-  } else {
-    flushout(dest);
-  }
-  nleft = dest->end - dest->nextc;
-  if (nleft > len)
-    goto buffered;
-  if ((__xwrite(dest->fd, p, len))) {
-    dest->flags |= OUTPUT_ERR;
-  }
-}
-
-static void outstr(const char *p, struct output *file) {
-  unsigned len;
-  len = strlen(p);
-  outmem(p, len, file);
-}
-
-static void outcslow(int c, struct output *dest) {
-  char buf = c;
-  outmem(&buf, 1, dest);
-}
-
-printfesque(3) static int fmtstr(char *outbuf, unsigned length, const char *fmt,
-                                 ...) {
-  va_list ap;
-  int ret;
-  va_start(ap, fmt);
-  ret = xvsnprintf(outbuf, length, fmt, ap);
-  va_end(ap);
-  return ret > (int)length ? length : ret;
-}
-
-printfesque(2) static int Xasprintf(char **sp, const char *fmt, ...) {
-  va_list ap;
-  int ret;
-  va_start(ap, fmt);
-  ret = Xvasprintf(sp, 0, fmt, ap);
-  va_end(ap);
-  return ret;
-}
-
-static void doformat(struct output *dest, const char *f, va_list ap) {
-  struct stackmark smark;
-  char *s;
-  int len;
-  int olen;
-  setstackmark(&smark);
-  s = dest->nextc;
-  olen = dest->end - dest->nextc;
-  len = Xvasprintf(&s, olen, f, ap);
-  if (likely(olen > len)) {
-    dest->nextc += len;
-    goto out;
-  }
-  outmem(s, len, dest);
-out:
-  popstackmark(&smark);
-}
-
-printfesque(1) static void out1fmt(const char *fmt, ...) {
-  va_list ap;
-  va_start(ap, fmt);
-  doformat(out1, fmt, ap);
-  va_end(ap);
-}
-
-printfesque(2) static void outfmt(struct output *file, const char *fmt, ...) {
-  va_list ap;
-  va_start(ap, fmt);
-  doformat(file, fmt, ap);
-  va_end(ap);
-}
-
-static void exvwarning(const char *msg, va_list ap) {
-  struct output *errs;
-  const char *name;
-  const char *fmt;
-  errs = out2;
-  name = arg0 ? arg0 : "sh";
-  if (!commandname) {
-    fmt = "%s: %d: ";
-  } else {
-    fmt = "%s: %d: %s: ";
-  }
-  outfmt(errs, fmt, name, errlinno, commandname);
-  doformat(errs, msg, ap);
-  outcslow('\n', errs);
-}
-
-/* error/warning routines for external builtins */
-printfesque(1) static void sh_warnx(const char *fmt, ...) {
-  va_list ap;
-  va_start(ap, fmt);
-  exvwarning(fmt, ap);
-  va_end(ap);
-}
-
-/*
- * Exverror is called to raise the error exception.  If the second argument
- * is not NULL then error prints an error message using printf style
- * formatting.  It then raises the error exception.
- */
-wontreturn static void exverror(int cond, const char *msg, va_list ap) {
-  exvwarning(msg, ap);
-  flushall();
-  exraise(cond);
-}
-
-wontreturn static void exerror(int cond, const char *msg, ...) {
-  va_list ap;
-  va_start(ap, msg);
-  exverror(cond, msg, ap);
-  va_end(ap);
-}
-
-wontreturn static void sh_error(const char *msg, ...) {
-  va_list ap;
-  exitstatus = 2;
-  va_start(ap, msg);
-  exverror(EXERROR, msg, ap);
-  va_end(ap);
-}
-
-wontreturn static void badnum(const char *s) {
-  sh_error(illnum, s);
-}
-
-wontreturn static void synerror(const char *msg) {
-  errlinno = plinno;
-  sh_error("Syntax error: %s", msg);
-}
-
-wontreturn static void yyerror(const char *s) {
-  sh_error("arithmetic expression: %s: \"%s\"", s, arith_startbuf);
-}
-
-/*
- * Called when an unexpected token is read during the parse. The
- * argument is the token that is expected, or -1 if more than one type
- * of token can occur at this point.
- */
-wontreturn static void synexpect(int token) {
-  char msg[64];
-  if (token >= 0) {
-    fmtstr(msg, 64, "%s unexpected (expecting %s)", tokname[lasttoken],
-           tokname[token]);
-  } else {
-    fmtstr(msg, 64, "%s unexpected", tokname[lasttoken]);
-  }
-  synerror(msg);
-}
-
-wontreturn static void varunset(const char *end, const char *var_,
-                                const char *umsg, int varflags) {
-  const char *msg;
-  const char *tail;
-  tail = nullstr;
-  msg = "parameter not set";
-  if (umsg) {
-    if (*end == (char)CTLENDVAR) {
-      if (varflags & VSNUL)
-        tail = " or null";
-    } else
-      msg = umsg;
-  }
-  sh_error("%.*s: %s%s", end - var_ - 1, var_, msg, tail);
-}
-
-/*
- * Convert a string into an integer of type int64.  Allow trailing spaces.
- */
-static int64_t atomax(const char *s, int base) {
-  char *p;
-  int64_t r;
-  errno = 0;
-  r = strtoimax(s, &p, base);
-  if (errno == ERANGE)
-    badnum(s);
-  /*
-   * Disallow completely blank strings in non-arithmetic (base != 0)
-   * contexts.
-   */
-  if (p == s && base)
-    badnum(s);
-  while (isspace((unsigned char)*p))
-    p++;
-  if (*p)
-    badnum(s);
-  return r;
-}
-
-static int64_t atomax10(const char *s) {
-  return atomax(s, 10);
-}
-
-/*
- * Convert a string of digits to an integer, printing an error message
- * on failure.
- */
-static int number(const char *s) {
-  int64_t n = atomax10(s);
-  if (n < 0 || n > INT_MAX)
-    badnum(s);
-  return n;
-}
-
-static inline int64_t getn(const char *s) {
-  return atomax10(s);
-}
-
-/*
- * When the parser reads in a string, it wants to stick the string on
- * the stack and only adjust the stack pointer when it knows how big the
- * string is. Stackblock (defined in stack.h) returns a pointer to a
- * block of space on top of the stack and stackblocklen returns the
- * length of this block. Growstackblock will grow this space by at least
- * one byte, possibly moving it (like realloc). Grabstackblock actually
- * allocates the part of the block that has been used.
- */
-static void growstackblock(unsigned min) {
-  unsigned newlen;
-  newlen = stacknleft * 2;
-  if (newlen < stacknleft)
-    sh_error("Out of space");
-  min = SHELL_ALIGN(min | 128);
-  if (newlen < min)
-    newlen += min;
-  if (stacknxt == stackp->space && stackp != &stackbase) {
-    struct stack_block *sp;
-    struct stack_block *prevstackp;
-    unsigned grosslen;
-    INTOFF;
-    sp = stackp;
-    prevstackp = sp->prev;
-    grosslen = newlen + sizeof(struct stack_block) - MINSIZE;
-    sp = ckrealloc((pointer)sp, grosslen);
-    sp->prev = prevstackp;
-    stackp = sp;
-    stacknxt = sp->space;
-    stacknleft = newlen;
-    sstrend = sp->space + newlen;
-    INTON;
-  } else {
-    char *oldspace = stacknxt;
-    int oldlen = stacknleft;
-    char *p = stalloc(newlen);
-    /* free the space we just allocated */
-    stacknxt = memcpy(p, oldspace, oldlen);
-    stacknleft += newlen;
-  }
-}
-
-/*
- * The following routines are somewhat easier to use than the above. The
- * user declares a variable of type STACKSTR, which may be declared to
- * be a register. The macro STARTSTACKSTR initializes things. Then the
- * user uses the macro STPUTC to add characters to the string. In
- * effect, STPUTC(c, p) is the same as *p++ = c except that the stack is
- * grown as necessary. When the user is done, she can just leave the
- * string there and refer to it using stackblock(). Or she can allocate
- * the space for it using grabstackstr(). If it is necessary to allow
- * someone else to use the stack temporarily and then continue to grow
- * the string, the user should use grabstack to allocate the space, and
- * then call ungrabstr(p) to return to the previous mode of operation.
- *
- * USTPUTC is like STPUTC except that it doesn't check for overflow.
- * CHECKSTACKSPACE can be called before USTPUTC to ensure that there
- * is space for at least one character.
- */
-static void *growstackstr(void) {
-  unsigned len = stackblocksize();
-  growstackblock(0);
-  return (char *)stackblock() + len;
-}
-
-static char *growstackto(unsigned len) {
-  if (stackblocksize() < len)
-    growstackblock(len);
-  return stackblock();
-}
-
-/*
- * Make a copy of a string in safe storage.
- */
-static char *savestr(const char *s) {
-  char *p = strdup(s);
-  if (!p)
-    sh_error("Out of space");
-  return p;
-}
-
-/* Called from CHECKSTRSPACE. */
-static char *makestrspace(unsigned newlen, char *p) {
-  unsigned len = p - stacknxt;
-  return growstackto(len + newlen) + len;
-}
-
-static char *stnputs(const char *s, unsigned n, char *p) {
-  p = makestrspace(n, p);
-  p = mempcpy(p, s, n);
-  return p;
-}
-
-static char *stputs(const char *s, char *p) {
-  return stnputs(s, strlen(s), p);
-}
-
-static char *nodesavestr(s)
-char *s;
-{
-  char *rtn = funcstring;
-  funcstring = stpcpy(funcstring, s) + 1;
-  return rtn;
-}
-
-wontreturn static void shellexec(char **, const char *, int);
-static char **listvars(int, int, char ***);
-static char *argstr(char *p, int flag);
-static char *conv_escape(char *, int *);
-static char *evalvar(char *, int);
-static char *expari(char *start, int flag);
-static char *exptilde(char *startp, int flag);
-static int shlex(void);
-static char *lookupvar(const char *);
-static char *mklong(const char *, const char *);
-static char *rmescapes(char *, int);
-static char *scanleft(char *, char *, char *, char *, int, int);
-static char *scanright(char *, char *, char *, char *, int, int);
-static char *single_quote(const char *);
-static const char *const *findkwd(const char *);
-static const char *expandstr(const char *);
-static const char *getprompt(void *);
-static double getdouble(void);
-static enum token t_lex(char **);
-static int aexpr(enum token);
-static int binop0(void);
-static int bltincmd(int, char **);
-static int conv_escape_str(char *, char **);
-static int decode_signal(const char *, int);
-static int decode_signum(const char *);
-static int describe_command(struct output *, char *, const char *, int);
-static int eprintlist(struct output *, struct strlist *, int);
-static int equalf(const char *, const char *);
-static int evalbltin(const struct builtincmd *, int, char **, int);
-static int evalcase(union node *, int);
-static int evalcommand(union node *, int);
-static int evalfor(union node *, int);
-static int evalfun(struct funcnode *, int, char **, int);
-static int evalloop(union node *, int);
-static int evalpipe(union node *, int);
-static int evalsubshell(union node *, int);
-static int filstat(char *, enum token);
-static int forkshell(struct job *, union node *, int);
-static int getopts(char *, char *, char **);
-static int isassignment(const char *p);
-static int isoperand(char **);
-static int newerf(const char *, const char *);
-static int nexpr(enum token);
-static int nextopt(const char *);
-static int oexpr(enum token);
-static int olderf(const char *, const char *);
-static int64_t openhere(union node *);
-static int openredirect(union node *);
-static int options(int);
-static int padvance_magic(const char **, const char *, int);
-static int patmatch(char *, const char *);
-static int pgetc(void);
-static int pgetc_eatbnl();
-static int pmatch(const char *, const char *);
-static int preadbuffer(void);
-static ssize_t preadfd(void);
-static int primary1(enum token);
-static int procargs(int, char **);
-static int readtoken(void);
-static int readtoken1(int, char const *, char *, int);
-static int redirectsafe(union node *, int);
-static int savefd(int, int);
-static int setinputfile(const char *, int);
-static int sh_open(const char *pathname, int flags, int mayfail);
-static int showvars(const char *, int, int);
-static int stoppedjobs(void);
-static int test_file_access(const char *, int);
-static int unalias(const char *);
-static int waitforjob(struct job *);
-static int xxreadtoken(void);
-static int64_t arith(const char *);
-static int64_t assignment(int var_, int noeval);
-static int64_t lookupvarint(const char *);
-static long varvalue(char *, int, int, int);
-static int64_t setvarint(const char *name, int64_t val, int flags);
-static struct Var *setvar(const char *name, const char *val, int flags);
-static struct Var *setvareq(char *s, int flags);
-static struct alias **__lookupalias(const char *);
-static struct alias *freealias(struct alias *);
-static struct alias *lookupalias(const char *, int);
-static struct funcnode *copyfunc(union node *);
-static struct job *makejob(union node *, int);
-static struct job *vforkexec(union node *n, char **argv, const char *path,
-                             int idx);
-static struct localvar_list *pushlocalvars(int push);
-static struct nodelist *copynodelist(struct nodelist *);
-static struct redirtab *pushredir(union node *redir);
-static struct strlist *expsort(struct strlist *);
-static struct strlist *msort(struct strlist *, int);
-static struct tblentry *cmdlookup(const char *, int);
-static uint64_t getuintmax(int);
-static union node *andor(void);
-static union node *command(void);
-static union node *copynode(union node *);
-static union node *list(int);
-static union node *makename(void);
-static union node *parsecmd(int);
-static union node *pipeline(void);
-static union node *simplecmd(void);
-static unsigned esclen(const char *, const char *);
-static unsigned memtodest(const char *p, unsigned len, int flags);
-static unsigned strtodest(const char *p, int flags);
-static void addcmdentry(char *, struct cmdentry *);
-static void addfname(char *);
-static void check_conversion(const char *, const char *);
-static void clearcmdentry(void);
-static void defun(union node *);
-static void delete_cmd_entry(void);
-static void dotrap(void);
-static void dupredirect(union node *, int);
-static void exitreset(void);
-static void expandarg(union node *arg, struct arglist *arglist, int flag);
-static void expandmeta(struct strlist *);
-static void expbackq(union node *, int);
-static void expmeta(char *, unsigned, unsigned);
-static void expredir(union node *);
-static void find_command(char *, struct cmdentry *, int, const char *);
-static void fixredir(union node *, const char *, int);
-static void forkreset(void);
-static void freeparam(volatile struct shparam *);
-static void hashcd(void);
-static void ignoresig(int);
-static void init(void);
-static void minus_o(char *, int);
-static void mklocal(char *name, int flags);
-static void onsig(int);
-static void optschanged(void);
-static void parsefname(void);
-static void parseheredoc(void);
-static void popallfiles(void);
-static void popfile(void);
-static void poplocalvars(void);
-static void popredir(int);
-static void popstring(void);
-static void prehash(union node *);
-static void printalias(const struct alias *);
-static void printentry(struct tblentry *);
-static void pungetc(void);
-static void pushfile(void);
-static void pushstring(char *, void *);
-static void read_profile(const char *);
-static void redirect(union node *, int);
-static void reset(void);
-static void rmaliases(void);
-static void setalias(const char *, const char *);
-static void setinputfd(int fd, int push);
-static void setinputstring(char *);
-static void setinteractive(int);
-static void setjobctl(int);
-static void setparam(char **);
-static void setprompt(int);
-static void setsignal(int);
-static void showjobs(struct output *, int);
-static void sigblockall(sigset_t *oldmask);
-static void sizenodelist(struct nodelist *);
-static void syntax(const char *, const char *);
-static void tryexec(char *, char **, char **);
-static void unsetfunc(const char *);
-static void unsetvar(const char *);
-static void unwindfiles(struct parsefile *);
-static void unwindlocalvars(struct localvar_list *stop);
-static void unwindredir(struct redirtab *stop);
-static unsigned cvtnum(int64_t num, int flags);
-
-static int getchr(void) {
-  int val = 0;
-  if (*gargv)
-    val = **gargv++;
-  return val;
-}
-
-static char *getstr(void) {
-  char *val = nullstr;
-  if (*gargv)
-    val = *gargv++;
-  return val;
-}
-
-/*
- * Check for a valid number.  This should be elsewhere.
- */
-static int is_number(const char *p) {
-  do {
-    if (!is_digit(*p))
-      return 0;
-  } while (*++p != '\0');
-  return 1;
-}
-
-static inline void freestdout() {
-  output.nextc = output.buf;
-  output.flags = 0;
-}
-
-static inline void outc(int ch, struct output *file) {
-  if (file->nextc == file->end)
-    outcslow(ch, file);
-  else {
-    *file->nextc = ch;
-    file->nextc++;
-  }
-}
-
-static inline char *_STPUTC(int c, char *p) {
-  if (p == sstrend)
-    p = growstackstr();
-  *p++ = c;
-  return p;
-}
-
-static void ifsfree(void) {
-  struct ifsregion *p = ifsfirst.next;
-  if (!p)
-    goto out;
-  INTOFF;
-  do {
-    struct ifsregion *ifsp;
-    ifsp = p->next;
-    ckfree(p);
-    p = ifsp;
-  } while (p);
-  ifsfirst.next = NULL;
-  INTON;
-out:
-  ifslastp = NULL;
-}
-
-static void setalias(const char *name, const char *val) {
-  struct alias *ap, **app;
-  app = __lookupalias(name);
-  ap = *app;
-  INTOFF;
-  if (ap) {
-    if (!(ap->flag & ALIASINUSE)) {
-      ckfree(ap->val);
-    }
-    ap->val = savestr(val);
-    ap->flag &= ~ALIASDEAD;
-  } else {
-    /* not found */
-    ap = ckmalloc(sizeof(struct alias));
-    ap->name = savestr(name);
-    ap->val = savestr(val);
-    ap->flag = 0;
-    ap->next = 0;
-    *app = ap;
-  }
-  INTON;
-}
-
-static int unalias(const char *name) {
-  struct alias **app;
-  app = __lookupalias(name);
-  if (*app) {
-    INTOFF;
-    *app = freealias(*app);
-    INTON;
-    return (0);
-  }
-  return (1);
-}
-
-static void rmaliases(void) {
-  struct alias *ap, **app;
-  int i;
-  INTOFF;
-  for (i = 0; i < ATABSIZE; i++) {
-    app = &atab[i];
-    for (ap = *app; ap; ap = *app) {
-      *app = freealias(*app);
-      if (ap == *app) {
-        app = &ap->next;
-      }
-    }
-  }
-  INTON;
-}
-
-struct alias *lookupalias(const char *name, int check) {
-  struct alias *ap = *__lookupalias(name);
-  if (check && ap && (ap->flag & ALIASINUSE))
-    return (NULL);
-  return (ap);
-}
-
-static int aliascmd(int argc, char **argv) {
-  /* TODO - sort output */
-  char *n, *v;
-  int ret = 0;
-  struct alias *ap;
-  if (argc == 1) {
-    int i;
-    for (i = 0; i < ATABSIZE; i++)
-      for (ap = atab[i]; ap; ap = ap->next) {
-        printalias(ap);
-      }
-    return (0);
-  }
-  while ((n = *++argv) != NULL) {
-    if ((v = strchr(n + 1, '=')) == NULL) { /* n+1: funny ksh stuff */
-      if ((ap = *__lookupalias(n)) == NULL) {
-        outfmt(out2, "%s: %s not found\n", "alias", n);
-        ret = 1;
-      } else
-        printalias(ap);
-    } else {
-      *v++ = '\0';
-      setalias(n, v);
-    }
-  }
-  return (ret);
-}
-
-static int unaliascmd(int argc, char **argv) {
-  int i;
-  while ((i = nextopt("a")) != '\0') {
-    if (i == 'a') {
-      rmaliases();
-      return (0);
-    }
-  }
-  for (i = 0; *argptr; argptr++) {
-    if (unalias(*argptr)) {
-      outfmt(out2, "%s: %s not found\n", "unalias", *argptr);
-      i = 1;
-    }
-  }
-  return i;
-}
-
-static struct alias *freealias(struct alias *ap) {
-  struct alias *next;
-  if (ap->flag & ALIASINUSE) {
-    ap->flag |= ALIASDEAD;
-    return ap;
-  }
-  next = ap->next;
-  ckfree(ap->name);
-  ckfree(ap->val);
-  ckfree(ap);
-  return next;
-}
-
-static void printalias(const struct alias *ap) {
-  out1fmt("%s=%s\n", ap->name, single_quote(ap->val));
-}
-
-static struct alias **__lookupalias(const char *name) {
-  unsigned int hashval;
-  struct alias **app;
-  const char *p;
-  unsigned int ch;
-  p = name;
-  ch = (unsigned char)*p;
-  hashval = ch << 4;
-  while (ch) {
-    hashval += ch;
-    ch = (unsigned char)*++p;
-  }
-  app = &atab[hashval % ATABSIZE];
-  for (; *app; app = &(*app)->next) {
-    if (equal(name, (*app)->name)) {
-      break;
-    }
-  }
-  return app;
-}
-
-static int shlex() {
-  int value;
-  const char *buf = arith_buf;
-  const char *p;
-  for (;;) {
-    value = *buf;
-    switch (value) {
-      case ' ':
-      case '\t':
-      case '\n':
-        buf++;
-        continue;
-      default:
-        return ARITH_BAD;
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9':
-        yylval.val = strtoimax(buf, (char **)&arith_buf, 0);
-        return ARITH_NUM;
-      case 'A':
-      case 'B':
-      case 'C':
-      case 'D':
-      case 'E':
-      case 'F':
-      case 'G':
-      case 'H':
-      case 'I':
-      case 'J':
-      case 'K':
-      case 'L':
-      case 'M':
-      case 'N':
-      case 'O':
-      case 'P':
-      case 'Q':
-      case 'R':
-      case 'S':
-      case 'T':
-      case 'U':
-      case 'V':
-      case 'W':
-      case 'X':
-      case 'Y':
-      case 'Z':
-      case '_':
-      case 'a':
-      case 'b':
-      case 'c':
-      case 'd':
-      case 'e':
-      case 'f':
-      case 'g':
-      case 'h':
-      case 'i':
-      case 'j':
-      case 'k':
-      case 'l':
-      case 'm':
-      case 'n':
-      case 'o':
-      case 'p':
-      case 'q':
-      case 'r':
-      case 's':
-      case 't':
-      case 'u':
-      case 'v':
-      case 'w':
-      case 'x':
-      case 'y':
-      case 'z':
-        p = buf;
-        while (buf++, is_in_name(*buf))
-          ;
-        yylval.name = stalloc(buf - p + 1);
-        *(char *)mempcpy(yylval.name, p, buf - p) = 0;
-        value = ARITH_VAR;
-        goto out;
-      case '=':
-        value += ARITH_ASS - '=';
-      checkeq:
-        buf++;
-      checkeqcur:
-        if (*buf != '=')
-          goto out;
-        value += 11;
-        break;
-      case '>':
-        switch (*++buf) {
-          case '=':
-            value += ARITH_GE - '>';
-            break;
-          case '>':
-            value += ARITH_RSHIFT - '>';
-            goto checkeq;
-          default:
-            value += ARITH_GT - '>';
-            goto out;
-        }
-        break;
-      case '<':
-        switch (*++buf) {
-          case '=':
-            value += ARITH_LE - '<';
-            break;
-          case '<':
-            value += ARITH_LSHIFT - '<';
-            goto checkeq;
-          default:
-            value += ARITH_LT - '<';
-            goto out;
-        }
-        break;
-      case '|':
-        if (*++buf != '|') {
-          value += ARITH_BOR - '|';
-          goto checkeqcur;
-        }
-        value += ARITH_OR - '|';
-        break;
-      case '&':
-        if (*++buf != '&') {
-          value += ARITH_BAND - '&';
-          goto checkeqcur;
-        }
-        value += ARITH_AND - '&';
-        break;
-      case '!':
-        if (*++buf != '=') {
-          value += ARITH_NOT - '!';
-          goto out;
-        }
-        value += ARITH_NE - '!';
-        break;
-      case 0:
-        goto out;
-      case '(':
-        value += ARITH_LPAREN - '(';
-        break;
-      case ')':
-        value += ARITH_RPAREN - ')';
-        break;
-      case '*':
-        value += ARITH_MUL - '*';
-        goto checkeq;
-      case '/':
-        value += ARITH_DIV - '/';
-        goto checkeq;
-      case '%':
-        value += ARITH_REM - '%';
-        goto checkeq;
-      case '+':
-        value += ARITH_ADD - '+';
-        goto checkeq;
-      case '-':
-        value += ARITH_SUB - '-';
-        goto checkeq;
-      case '~':
-        value += ARITH_BNOT - '~';
-        break;
-      case '^':
-        value += ARITH_BXOR - '^';
-        goto checkeq;
-      case '?':
-        value += ARITH_QMARK - '?';
-        break;
-      case ':':
-        value += ARITH_COLON - ':';
-        break;
-    }
-    break;
-  }
-  buf++;
-out:
-  arith_buf = buf;
-  return value;
-}
-
-/*
- * Compares two strings up to the first = or '\0'. The first string must
- * be terminated by '='; the second may be terminated by either '=' or
- * '\0'.
- */
-static int varcmp(const char *p, const char *q) {
-  int c, d;
-  while ((c = *p) == (d = *q)) {
-    if (!c || c == '=')
-      goto out;
-    p++;
-    q++;
-  }
-  if (c == '=')
-    c = 0;
-  if (d == '=')
-    d = 0;
-out:
-  return c - d;
-}
-
-static inline int varequal(const char *a, const char *b) {
-  return !varcmp(a, b);
-}
-
-/*
- * Search the environment of a builtin command.
- */
-static inline char *bltinlookup(const char *name) {
-  return lookupvar(name);
-}
-
-static inline int arith_prec(int op) {
-  return kPrec[op - ARITH_BINOP_MIN];
-}
-
-static inline int higher_prec(int op1, int op2) {
-  return arith_prec(op1) < arith_prec(op2);
-}
-
-static int64_t do_binop(int op, int64_t a, int64_t b) {
-  switch (op) {
-    default:
-    case ARITH_REM:
-    case ARITH_DIV:
-      if (!b)
-        yyerror("division by zero");
-      return op == ARITH_REM ? a % b : a / b;
-    case ARITH_MUL:
-      return a * b;
-    case ARITH_ADD:
-      return a + b;
-    case ARITH_SUB:
-      return a - b;
-    case ARITH_LSHIFT:
-      return a << b;
-    case ARITH_RSHIFT:
-      return a >> b;
-    case ARITH_LT:
-      return a < b;
-    case ARITH_LE:
-      return a <= b;
-    case ARITH_GT:
-      return a > b;
-    case ARITH_GE:
-      return a >= b;
-    case ARITH_EQ:
-      return a == b;
-    case ARITH_NE:
-      return a != b;
-    case ARITH_BAND:
-      return a & b;
-    case ARITH_BXOR:
-      return a ^ b;
-    case ARITH_BOR:
-      return a | b;
-  }
-}
-
-static int64_t primary(int token, union yystype *val, int op, int noeval) {
-  int64_t result;
-again:
-  switch (token) {
-    case ARITH_LPAREN:
-      result = assignment(op, noeval);
-      if (last_token != ARITH_RPAREN)
-        yyerror("expecting ')'");
-      last_token = shlex();
-      return result;
-    case ARITH_NUM:
-      last_token = op;
-      return val->val;
-    case ARITH_VAR:
-      last_token = op;
-      return noeval ? val->val : lookupvarint(val->name);
-    case ARITH_ADD:
-      token = op;
-      *val = yylval;
-      op = shlex();
-      goto again;
-    case ARITH_SUB:
-      *val = yylval;
-      return -primary(op, val, shlex(), noeval);
-    case ARITH_NOT:
-      *val = yylval;
-      return !primary(op, val, shlex(), noeval);
-    case ARITH_BNOT:
-      *val = yylval;
-      return ~primary(op, val, shlex(), noeval);
-    default:
-      yyerror("expecting primary");
-  }
-}
-
-static int64_t binop2(int64_t a, int op, int prec, int noeval) {
-  for (;;) {
-    union yystype val;
-    int64_t b;
-    int op2;
-    int token;
-    token = shlex();
-    val = yylval;
-    b = primary(token, &val, shlex(), noeval);
-    op2 = last_token;
-    if (op2 >= ARITH_BINOP_MIN && op2 < ARITH_BINOP_MAX &&
-        higher_prec(op2, op)) {
-      b = binop2(b, op2, arith_prec(op), noeval);
-      op2 = last_token;
-    }
-    a = noeval ? b : do_binop(op, a, b);
-    if (op2 < ARITH_BINOP_MIN || op2 >= ARITH_BINOP_MAX ||
-        arith_prec(op2) >= prec) {
-      return a;
-    }
-    op = op2;
-  }
-}
-
-static int64_t binop(int token, union yystype *val, int op, int noeval) {
-  int64_t a = primary(token, val, op, noeval);
-  op = last_token;
-  if (op < ARITH_BINOP_MIN || op >= ARITH_BINOP_MAX)
-    return a;
-  return binop2(a, op, ARITH_MAX_PREC, noeval);
-}
-
-static int64_t and (int token, union yystype *val, int op, int noeval) {
-  int64_t a = binop(token, val, op, noeval);
-  int64_t b;
-  op = last_token;
-  if (op != ARITH_AND)
-    return a;
-  token = shlex();
-  *val = yylval;
-  b = and(token, val, shlex(), noeval | !a);
-  return a && b;
-}
-
-static int64_t or (int token, union yystype *val, int op, int noeval) {
-  int64_t a = and(token, val, op, noeval);
-  int64_t b;
-  op = last_token;
-  if (op != ARITH_OR)
-    return a;
-  token = shlex();
-  *val = yylval;
-  b = or (token, val, shlex(), noeval | !!a);
-  return a || b;
-}
-
-static int64_t cond(int token, union yystype *val, int op, int noeval) {
-  int64_t a = or (token, val, op, noeval);
-  int64_t b;
-  int64_t c;
-  if (last_token != ARITH_QMARK)
-    return a;
-  b = assignment(shlex(), noeval | !a);
-  if (last_token != ARITH_COLON)
-    yyerror("expecting ':'");
-  token = shlex();
-  *val = yylval;
-  c = cond(token, val, shlex(), noeval | !!a);
-  return a ? b : c;
-}
-
-static int64_t assignment(int var_, int noeval) {
-  union yystype val = yylval;
-  int op = shlex();
-  int64_t result;
-  if (var_ != ARITH_VAR)
-    return cond(var_, &val, op, noeval);
-  if (op != ARITH_ASS && (op < ARITH_ASS_MIN || op >= ARITH_ASS_MAX)) {
-    return cond(var_, &val, op, noeval);
-  }
-  result = assignment(shlex(), noeval);
-  if (noeval)
-    return result;
-  return setvarint(
-      val.name,
-      (op == ARITH_ASS ? result
-                       : do_binop(op - 11, lookupvarint(val.name), result)),
-      0);
-}
-
-static int64_t arith(const char *s) {
-  int64_t result;
-  arith_buf = arith_startbuf = s;
-  result = assignment(shlex(), 0);
-  if (last_token)
-    yyerror("expecting EOF");
-  return result;
-}
-
-/*
- * The cd and pwd commands.
- */
-static inline int padvance(const char **path, const char *name) {
-  return padvance_magic(path, name, 1);
-}
-
-static char *getpwd(void);
-static const char *updatepwd(const char *);
-static int cdopt(void);
-static int docd(const char *, int);
-static void setpwd(const char *, int);
-
-static int cdopt() {
-  int flags = 0;
-  int i, j;
-  j = 'L';
-  while ((i = nextopt("LP"))) {
-    if (i != j) {
-      flags ^= CD_PHYSICAL;
-      j = i;
-    }
-  }
-  return flags;
-}
-
-static int cdcmd(int argc, char **argv) {
-  const char *dest;
-  const char *path;
-  const char *p;
-  char c;
-  struct stat statb;
-  int flags;
-  int len;
-  flags = cdopt();
-  dest = *argptr;
-  if (!dest)
-    dest = bltinlookup(homestr);
-  else if (dest[0] == '-' && dest[1] == '\0') {
-    dest = bltinlookup("OLDPWD");
-    flags |= CD_PRINT;
-  }
-  if (!dest)
-    dest = nullstr;
-  if (*dest == '/')
-    goto step6;
-  if (*dest == '.') {
-    c = dest[1];
-  dotdot:
-    switch (c) {
-      case '\0':
-      case '/':
-        goto step6;
-      case '.':
-        c = dest[2];
-        if (c != '.')
-          goto dotdot;
-    }
-  }
-  if (!*dest)
-    dest = ".";
-  path = bltinlookup("CDPATH");
-  while (p = path, (len = padvance_magic(&path, dest, 0)) >= 0) {
-    c = *p;
-    p = stalloc(len);
-    if (stat(p, &statb) >= 0 && S_ISDIR(statb.st_mode)) {
-      if (c && c != ':')
-        flags |= CD_PRINT;
-    docd:
-      if (!docd(p, flags))
-        goto out;
-      goto err;
-    }
-  }
-step6:
-  p = dest;
-  goto docd;
-err:
-  sh_error("can't cd to %s", dest);
-  __builtin_unreachable();
-out:
-  if (flags & CD_PRINT)
-    out1fmt(snlfmt, curdir);
-  return 0;
-}
-
-/*
- * Actually do the chdir.  We also call hashcd to let the routines in exec.c
- * know that the current directory has changed.
- */
-static int docd(const char *dest, int flags) {
-  const char *dir = 0;
-  int err;
-  TRACE(("docd(\"%s\", %d) called\n", dest, flags));
-  INTOFF;
-  if (!(flags & CD_PHYSICAL)) {
-    dir = updatepwd(dest);
-    if (dir)
-      dest = dir;
-  }
-  err = chdir(dest);
-  if (err)
-    goto out;
-  setpwd(dir, 1);
-  hashcd();
-out:
-  INTON;
-  return err;
-}
-
-/*
- * Update curdir (the name of the current directory) in response to a
- * cd command.
- */
-static const char *updatepwd(const char *dir) {
-  char *new;
-  char *p;
-  char *cdcomppath;
-  const char *lim;
-  cdcomppath = sstrdup(dir);
-  STARTSTACKSTR(new);
-  if (*dir != '/') {
-    if (curdir == nullstr)
-      return 0;
-    new = stputs(curdir, new);
-  }
-  new = makestrspace(strlen(dir) + 2, new);
-  lim = (char *)stackblock() + 1;
-  if (*dir != '/') {
-    if (new[-1] != '/')
-      USTPUTC('/', new);
-    if (new > lim && *lim == '/')
-      lim++;
-  } else {
-    USTPUTC('/', new);
-    cdcomppath++;
-    if (dir[1] == '/' && dir[2] != '/') {
-      USTPUTC('/', new);
-      cdcomppath++;
-      lim++;
-    }
-  }
-  p = strtok(cdcomppath, "/");
-  while (p) {
-    switch (*p) {
-      case '.':
-        if (p[1] == '.' && p[2] == '\0') {
-          while (new > lim) {
-            STUNPUTC(new);
-            if (new[-1] == '/')
-              break;
-          }
-          break;
-        } else if (p[1] == '\0')
-          break;
-        /* fall through */
-      default:
-        new = stputs(p, new);
-        USTPUTC('/', new);
-    }
-    p = strtok(0, "/");
-  }
-  if (new > lim)
-    STUNPUTC(new);
-  *new = 0;
-  return stackblock();
-}
-
-/*
- * Find out what the current directory is. If we already know the
- * current directory, this routine returns immediately.
- */
-static inline char *getpwd() {
-  char buf[PATH_MAX];
-  if (getcwd(buf, sizeof(buf)))
-    return savestr(buf);
-  sh_warnx("getcwd() failed: %s", strerror(errno));
-  return nullstr;
-}
-
-static int pwdcmd(int argc, char **argv) {
-  int flags;
-  const char *dir = curdir;
-  flags = cdopt();
-  if (flags) {
-    if (physdir == nullstr)
-      setpwd(dir, 0);
-    dir = physdir;
-  }
-  out1fmt(snlfmt, dir);
-  return 0;
-}
-
-static void setpwd(const char *val, int setold) {
-  char *oldcur, *dir;
-  oldcur = dir = curdir;
-  if (setold) {
-    setvar("OLDPWD", oldcur, VEXPORT);
-  }
-  INTOFF;
-  if (physdir != nullstr) {
-    if (physdir != oldcur)
-      free(physdir);
-    physdir = nullstr;
-  }
-  if (oldcur == val || !val) {
-    char *s = getpwd();
-    physdir = s;
-    if (!val)
-      dir = s;
-  } else
-    dir = savestr(val);
-  if (oldcur != dir && oldcur != nullstr) {
-    free(oldcur);
-  }
-  curdir = dir;
-  INTON;
-  setvar("PWD", dir, VEXPORT);
-}
-
-/*
- * Errors and exceptions.
- */
-
-/*
- * NEOF is returned by parsecmd when it encounters an end of file.  It
- * must be distinct from NULL, so we use the address of a variable that
- * happens to be handy.
- */
-#define NEOF ((union node *)&tokpushback)
-
-/*
- * Return of a legal variable name (a letter or underscore followed by zero or
- * more letters, underscores, and digits).
- */
-static char *endofname(const char *name) {
-  char *p;
-  p = (char *)name;
-  if (!is_name(*p))
-    return p;
-  while (*++p) {
-    if (!is_in_name(*p))
-      break;
-  }
-  return p;
-}
-
-static inline int goodname(const char *p) {
-  return !*endofname(p);
-}
-static inline int parser_eof(void) {
-  return tokpushback && lasttoken == TEOF;
-}
-static inline int have_traps(void) {
-  return trapcnt;
-}
-
-static const struct builtincmd kBltin = {
-    .name = nullstr,
-    .builtin = bltincmd,
-    .flags = BUILTIN_REGULAR,
-};
-
-/*
- * Evaluate a parse tree.  The value is left in the global variable
- * exitstatus.
- */
-static int evaltree(union node *n, int flags) {
-  int checkexit = 0;
-  int (*evalfn)(union node *, int);
-  struct stackmark smark;
-  unsigned isor;
-  int status = 0;
-  setstackmark(&smark);
-  if (nflag)
-    goto out;
-  if (n == NULL) {
-    TRACE(("evaltree(NULL) called\n"));
-    goto out;
-  }
-  dotrap();
-  TRACE(("pid %d, evaltree(%p: %d, %d) called\n", getpid(), n, n->type, flags));
-  switch (n->type) {
-    default:
-    case NNOT:
-      status = !evaltree(n->nnot.com, EV_TESTED);
-      goto setstatus;
-    case NREDIR:
-      errlinno = lineno = n->nredir.linno;
-      if (funcline)
-        lineno -= funcline - 1;
-      expredir(n->nredir.redirect);
-      pushredir(n->nredir.redirect);
-      status = (redirectsafe(n->nredir.redirect, REDIR_PUSH)
-                    ?: evaltree(n->nredir.n, flags & EV_TESTED));
-      if (n->nredir.redirect)
-        popredir(0);
-      goto setstatus;
-    case NCMD:
-      evalfn = evalcommand;
-    checkexit:
-      checkexit = ~flags & EV_TESTED;
-      goto calleval;
-    case NFOR:
-      evalfn = evalfor;
-      goto calleval;
-    case NWHILE:
-    case NUNTIL:
-      evalfn = evalloop;
-      goto calleval;
-    case NSUBSHELL:
-    case NBACKGND:
-      evalfn = evalsubshell;
-      goto checkexit;
-    case NPIPE:
-      evalfn = evalpipe;
-      goto checkexit;
-    case NCASE:
-      evalfn = evalcase;
-      goto calleval;
-    case NAND:
-    case NOR:
-    case NSEMI:
-      isor = n->type - NAND;
-      status =
-          evaltree(n->nbinary.ch1, (flags | ((isor >> 1) - 1)) & EV_TESTED);
-      if ((!status) == isor || evalskip)
-        break;
-      n = n->nbinary.ch2;
-    evaln:
-      evalfn = evaltree;
-    calleval:
-      status = evalfn(n, flags);
-      goto setstatus;
-    case NIF:
-      status = evaltree(n->nif.test, EV_TESTED);
-      if (evalskip)
-        break;
-      if (!status) {
-        n = n->nif.ifpart;
-        goto evaln;
-      } else if (n->nif.elsepart) {
-        n = n->nif.elsepart;
-        goto evaln;
-      }
-      status = 0;
-      goto setstatus;
-    case NDEFUN:
-      defun(n);
-    setstatus:
-      exitstatus = status;
-      break;
-  }
-out:
-  dotrap();
-  if (eflag && checkexit & status)
-    goto exexit;
-  if (flags & EV_EXIT) {
-  exexit:
-    exraise(EXEND);
-  }
-  popstackmark(&smark);
-  return exitstatus;
-}
-
-wontreturn static void evaltreenr(union node *n, int flags) {
-  evaltree(n, flags);
-  abort();
-}
-
-/*
- * Execute a command or commands contained in a string.
- */
-static int evalstring(char *s, int flags) {
-  union node *n;
-  struct stackmark smark;
-  int status;
-  s = sstrdup(s);
-  setinputstring(s);
-  setstackmark(&smark);
-  status = 0;
-  for (; (n = parsecmd(0)) != NEOF; popstackmark(&smark)) {
-    int i;
-    i = evaltree(n, flags & ~(parser_eof() ? 0 : EV_EXIT));
-    if (n)
-      status = i;
-    if (evalskip)
-      break;
-  }
-  popstackmark(&smark);
-  popfile();
-  stunalloc(s);
-  return status;
-}
-
-static int evalcmd(int argc, char **argv, int flags) {
-  char *p;
-  char *concat;
-  char **ap;
-  if (argc > 1) {
-    p = argv[1];
-    if (argc > 2) {
-      STARTSTACKSTR(concat);
-      ap = argv + 2;
-      for (;;) {
-        concat = stputs(p, concat);
-        if ((p = *ap++) == NULL)
-          break;
-        STPUTC(' ', concat);
-      }
-      STPUTC('\0', concat);
-      p = grabstackstr(concat);
-    }
-    return evalstring(p, flags & EV_TESTED);
-  }
-  return 0;
-}
-
-static int skiploop(void) {
-  int skip = evalskip;
-  switch (skip) {
-    case 0:
-      break;
-    case SKIPBREAK:
-    case SKIPCONT:
-      if (likely(--skipcount <= 0)) {
-        evalskip = 0;
-        break;
-      }
-      skip = SKIPBREAK;
-      break;
-  }
-  return skip;
-}
-
-static int evalloop(union node *n, int flags) {
-  int skip;
-  int status;
-  loopnest++;
-  status = 0;
-  flags &= EV_TESTED;
-  do {
-    int i;
-    i = evaltree(n->nbinary.ch1, EV_TESTED);
-    skip = skiploop();
-    if (skip == SKIPFUNC)
-      status = i;
-    if (skip)
-      continue;
-    if (n->type != NWHILE)
-      i = !i;
-    if (i != 0)
-      break;
-    status = evaltree(n->nbinary.ch2, flags);
-    skip = skiploop();
-  } while (!(skip & ~SKIPCONT));
-  loopnest--;
-  return status;
-}
-
-static int evalfor(union node *n, int flags) {
-  struct arglist arglist;
-  union node *argp;
-  struct strlist *sp;
-  int status;
-  errlinno = lineno = n->nfor.linno;
-  if (funcline)
-    lineno -= funcline - 1;
-  arglist.lastp = &arglist.list;
-  for (argp = n->nfor.args; argp; argp = argp->narg.next) {
-    expandarg(argp, &arglist, EXP_FULL | EXP_TILDE);
-  }
-  *arglist.lastp = NULL;
-  status = 0;
-  loopnest++;
-  flags &= EV_TESTED;
-  for (sp = arglist.list; sp; sp = sp->next) {
-    setvar(n->nfor.var_, sp->text, 0);
-    status = evaltree(n->nfor.body, flags);
-    if (skiploop() & ~SKIPCONT)
-      break;
-  }
-  loopnest--;
-  return status;
-}
-
-/*
- * See if a pattern matches in a case statement.
- */
-static int casematch(union node *pattern, char *val) {
-  struct stackmark smark;
-  int result;
-  setstackmark(&smark);
-  argbackq = pattern->narg.backquote;
-  STARTSTACKSTR(expdest);
-  argstr(pattern->narg.text, EXP_TILDE | EXP_CASE);
-  ifsfree();
-  result = patmatch(stackblock(), val);
-  popstackmark(&smark);
-  return result;
-}
-
-static int evalcase(union node *n, int flags) {
-  union node *cp;
-  union node *patp;
-  struct arglist arglist;
-  int status = 0;
-  errlinno = lineno = n->ncase.linno;
-  if (funcline)
-    lineno -= funcline - 1;
-  arglist.lastp = &arglist.list;
-  expandarg(n->ncase.expr, &arglist, EXP_TILDE);
-  for (cp = n->ncase.cases; cp && evalskip == 0; cp = cp->nclist.next) {
-    for (patp = cp->nclist.pattern; patp; patp = patp->narg.next) {
-      if (casematch(patp, arglist.list->text)) {
-        /* Ensure body is non-empty as otherwise
-         * EV_EXIT may prevent us from setting the
-         * exit status.
-         */
-        if (evalskip == 0 && cp->nclist.body) {
-          status = evaltree(cp->nclist.body, flags);
-        }
-        goto out;
-      }
-    }
-  }
-out:
-  return status;
-}
-
-/*
- * Kick off a subshell to evaluate a tree.
- */
-static int evalsubshell(union node *n, int flags) {
-  struct job *jp;
-  int backgnd = (n->type == NBACKGND);
-  int status;
-  errlinno = lineno = n->nredir.linno;
-  if (funcline)
-    lineno -= funcline - 1;
-  expredir(n->nredir.redirect);
-  INTOFF;
-  if (!backgnd && flags & EV_EXIT && !have_traps()) {
-    forkreset();
-    goto nofork;
-  }
-  jp = makejob(n, 1);
-  if (forkshell(jp, n, backgnd) == 0) {
-    flags |= EV_EXIT;
-    if (backgnd)
-      flags &= ~EV_TESTED;
-  nofork:
-    INTON;
-    redirect(n->nredir.redirect, 0);
-    evaltreenr(n->nredir.n, flags);
-    /* never returns */
-  }
-  status = 0;
-  if (!backgnd)
-    status = waitforjob(jp);
-  INTON;
-  return status;
-}
-
-/*
- * Compute the names of the files in a redirection list.
- */
-static void expredir(union node *n) {
-  union node *redir;
-  for (redir = n; redir; redir = redir->nfile.next) {
-    struct arglist fn;
-    fn.lastp = &fn.list;
-    switch (redir->type) {
-      case NFROMTO:
-      case NFROM:
-      case NTO:
-      case NCLOBBER:
-      case NAPPEND:
-        expandarg(redir->nfile.fname, &fn, EXP_TILDE | EXP_REDIR);
-        redir->nfile.expfname = fn.list->text;
-        break;
-      case NFROMFD:
-      case NTOFD:
-        if (redir->ndup.vname) {
-          expandarg(redir->ndup.vname, &fn, EXP_TILDE | EXP_REDIR);
-          fixredir(redir, fn.list->text, 1);
-        }
-        break;
-    }
-  }
-}
-
-/*
- * Evaluate a pipeline.  All the processes in the pipeline are children
- * of the process creating the pipeline.  (This differs from some versions
- * of the shell, which make the last process in a pipeline the parent
- * of all the rest.)
- */
-static int evalpipe(union node *n, int flags) {
-  struct job *jp;
-  struct nodelist *lp;
-  int pipelen;
-  int prevfd;
-  int pip[2];
-  int status = 0;
-  TRACE(("evalpipe(0x%lx) called\n", (long)n));
-  pipelen = 0;
-  for (lp = n->npipe.cmdlist; lp; lp = lp->next)
-    pipelen++;
-  flags |= EV_EXIT;
-  INTOFF;
-  jp = makejob(n, pipelen);
-  prevfd = -1;
-  for (lp = n->npipe.cmdlist; lp; lp = lp->next) {
-    prehash(lp->n);
-    pip[1] = -1;
-    if (lp->next) {
-      if (pipe(pip) < 0) {
-        close(prevfd);
-        sh_error("Pipe call failed");
-      }
-    }
-    if (forkshell(jp, lp->n, n->npipe.backgnd) == 0) {
-      INTON;
-      if (pip[1] >= 0) {
-        close(pip[0]);
-      }
-      if (prevfd > 0) {
-        dup2(prevfd, 0);
-        close(prevfd);
-      }
-      if (pip[1] > 1) {
-        dup2(pip[1], 1);
-        close(pip[1]);
-      }
-      evaltreenr(lp->n, flags);
-      /* never returns */
-    }
-    if (prevfd >= 0)
-      close(prevfd);
-    prevfd = pip[0];
-    close(pip[1]);
-  }
-  if (n->npipe.backgnd == 0) {
-    status = waitforjob(jp);
-    TRACE(("evalpipe:  job done exit status %d\n", status));
-  }
-  INTON;
-  return status;
-}
-
-/*
- * Execute a command inside back quotes.  If it's a builtin command, we
- * want to save its output in a block obtained from malloc.  Otherwise
- * we fork off a subprocess and get the output of the command via a pipe.
- * Should be called with interrupts off.
- */
-static void evalbackcmd(union node *n, struct backcmd *result) {
-  int pip[2];
-  struct job *jp;
-  result->fd = -1;
-  result->buf = NULL;
-  result->nleft = 0;
-  result->jp = NULL;
-  if (n == NULL) {
-    goto out;
-  }
-  if (pipe(pip) < 0)
-    sh_error("Pipe call failed");
-  jp = makejob(n, 1);
-  if (forkshell(jp, n, FORK_NOJOB) == 0) {
-    FORCEINTON;
-    close(pip[0]);
-    if (pip[1] != 1) {
-      dup2(pip[1], 1);
-      close(pip[1]);
-    }
-    ifsfree();
-    evaltreenr(n, EV_EXIT);
-    __builtin_unreachable();
-  }
-  close(pip[1]);
-  result->fd = pip[0];
-  result->jp = jp;
-out:
-  TRACE(("evalbackcmd done: fd=%d buf=0x%x nleft=%d jp=0x%x\n", result->fd,
-         result->buf, result->nleft, result->jp));
-}
-
-static struct strlist *fill_arglist(struct arglist *arglist,
-                                    union node **argpp) {
-  struct strlist **lastp = arglist->lastp;
-  union node *argp;
-  while ((argp = *argpp)) {
-    expandarg(argp, arglist, EXP_FULL | EXP_TILDE);
-    *argpp = argp->narg.next;
-    if (*lastp)
-      break;
-  }
-  return *lastp;
-}
-
-static int parse_command_args(struct arglist *arglist, union node **argpp,
-                              const char **path) {
-  struct strlist *sp = arglist->list;
-  char *cp, c;
-  for (;;) {
-    sp = unlikely(sp->next != NULL) ? sp->next : fill_arglist(arglist, argpp);
-    if (!sp)
-      return 0;
-    cp = sp->text;
-    if (*cp++ != '-')
-      break;
-    if (!(c = *cp++))
-      break;
-    if (c == '-' && !*cp) {
-      if (likely(!sp->next) && !fill_arglist(arglist, argpp))
-        return 0;
-      sp = sp->next;
-      break;
-    }
-    do {
-      switch (c) {
-        case 'p':
-          *path = defpath;
-          break;
-        default:
-          /* run 'typecmd' for other options */
-          return 0;
-      }
-    } while ((c = *cp++));
-  }
-  arglist->list = sp;
-  return DO_NOFUNC;
-}
-
-/*
- * Execute a simple command.
- */
-static int evalcommand(union node *cmd, int flags) {
-  struct localvar_list *localvar_stop;
-  struct parsefile *file_stop;
-  struct redirtab *redir_stop;
-  union node *argp;
-  struct arglist arglist;
-  struct arglist varlist;
-  char **argv;
-  int argc;
-  struct strlist *osp;
-  struct strlist *sp;
-  struct cmdentry cmdentry;
-  struct job *jp;
-  char *lastarg;
-  const char *path;
-  int spclbltin;
-  int cmd_flag;
-  int execcmd;
-  int status;
-  char **nargv;
-  int vflags;
-  int vlocal;
-  errlinno = lineno = cmd->ncmd.linno;
-  if (funcline)
-    lineno -= funcline - 1;
-  /* First expand the arguments. */
-  TRACE(("evalcommand(0x%lx, %d) called\n", (long)cmd, flags));
-  file_stop = parsefile;
-  back_exitstatus = 0;
-  cmdentry.cmdtype = CMDBUILTIN;
-  cmdentry.u.cmd = &kBltin;
-  varlist.lastp = &varlist.list;
-  *varlist.lastp = NULL;
-  arglist.lastp = &arglist.list;
-  *arglist.lastp = NULL;
-  cmd_flag = 0;
-  execcmd = 0;
-  spclbltin = -1;
-  vflags = 0;
-  vlocal = 0;
-  path = NULL;
-  argc = 0;
-  argp = cmd->ncmd.args;
-  if ((osp = fill_arglist(&arglist, &argp))) {
-    int pseudovarflag = 0;
-    for (;;) {
-      find_command(arglist.list->text, &cmdentry, cmd_flag | DO_REGBLTIN,
-                   pathval());
-      vlocal++;
-      /* implement bltin and command here */
-      if (cmdentry.cmdtype != CMDBUILTIN)
-        break;
-      pseudovarflag = cmdentry.u.cmd->flags & BUILTIN_ASSIGN;
-      if (likely(spclbltin < 0)) {
-        spclbltin = cmdentry.u.cmd->flags & BUILTIN_SPECIAL;
-        vlocal = spclbltin ^ BUILTIN_SPECIAL;
-      }
-      execcmd = cmdentry.u.cmd == EXECCMD;
-      if (likely(cmdentry.u.cmd != COMMANDCMD))
-        break;
-      cmd_flag = parse_command_args(&arglist, &argp, &path);
-      if (!cmd_flag)
-        break;
-    }
-    for (; argp; argp = argp->narg.next) {
-      expandarg(argp, &arglist,
-                (pseudovarflag && isassignment(argp->narg.text))
-                    ? EXP_VARTILDE
-                    : EXP_FULL | EXP_TILDE);
-    }
-    for (sp = arglist.list; sp; sp = sp->next)
-      argc++;
-    if (execcmd && argc > 1)
-      vflags = VEXPORT;
-  }
-  localvar_stop = pushlocalvars(vlocal);
-  /* Reserve one extra spot at the front for shellexec. */
-  nargv = stalloc(sizeof(char *) * (argc + 2));
-  argv = ++nargv;
-  for (sp = arglist.list; sp; sp = sp->next) {
-    TRACE(("evalcommand arg: %s\n", sp->text));
-    *nargv++ = sp->text;
-  }
-  *nargv = NULL;
-  lastarg = NULL;
-  if (iflag && funcline == 0 && argc > 0)
-    lastarg = nargv[-1];
-  preverrout.fd = 2;
-  expredir(cmd->ncmd.redirect);
-  redir_stop = pushredir(cmd->ncmd.redirect);
-  status = redirectsafe(cmd->ncmd.redirect, REDIR_PUSH | REDIR_SAVEFD2);
-  if (unlikely(status)) {
-  bail:
-    exitstatus = status;
-    /* We have a redirection error. */
-    if (spclbltin > 0)
-      exraise(EXERROR);
-    goto out;
-  }
-  for (argp = cmd->ncmd.assign; argp; argp = argp->narg.next) {
-    struct strlist **spp;
-    spp = varlist.lastp;
-    expandarg(argp, &varlist, EXP_VARTILDE);
-    if (vlocal)
-      mklocal((*spp)->text, VEXPORT);
-    else
-      setvareq((*spp)->text, vflags);
-  }
-  /* Print the command if xflag is set. */
-  if (xflag && !inps4) {
-    struct output *out;
-    int sep;
-    out = &preverrout;
-    inps4 = 1;
-    outstr(expandstr(ps4val()), out);
-    inps4 = 0;
-    sep = 0;
-    sep = eprintlist(out, varlist.list, sep);
-    eprintlist(out, osp, sep);
-    outcslow('\n', out);
-  }
-  /* Now locate the command. */
-  if (cmdentry.cmdtype != CMDBUILTIN ||
-      !(cmdentry.u.cmd->flags & BUILTIN_REGULAR)) {
-    path = unlikely(path != NULL) ? path : pathval(); /* wut */
-    find_command(argv[0], &cmdentry, cmd_flag | DO_ERR, path);
-  }
-  jp = NULL;
-  /* Execute the command. */
-  switch (cmdentry.cmdtype) {
-    case CMDUNKNOWN:
-      status = 127;
-      goto bail;
-    default:
-      /* Fork off a child process if necessary. */
-      if (!(flags & EV_EXIT) || have_traps()) {
-        INTOFF;
-        jp = vforkexec(cmd, argv, path, cmdentry.u.index);
-        break;
-      }
-      shellexec(argv, path, cmdentry.u.index);
-      __builtin_unreachable();
-    case CMDBUILTIN:
-      if (evalbltin(cmdentry.u.cmd, argc, argv, flags) &&
-          !(exception == EXERROR && spclbltin <= 0)) {
-      raise:
-        longjmp(handler->loc, 1);
-      }
-      break;
-    case CMDFUNCTION:
-      if (evalfun(cmdentry.u.func, argc, argv, flags))
-        goto raise;
-      break;
-  }
-  status = waitforjob(jp);
-  FORCEINTON;
-out:
-  if (cmd->ncmd.redirect)
-    popredir(execcmd);
-  unwindredir(redir_stop);
-  unwindfiles(file_stop);
-  unwindlocalvars(localvar_stop);
-  if (lastarg) {
-    /* dsl: I think this is intended to be used to support
-     * '_' in 'vi' command mode during line editing...
-     * However I implemented that within libedit itself.
-     */
-    setvar("_", lastarg, 0);
-  }
-  return status;
-}
-
-static int evalbltin(const struct builtincmd *cmd, int argc, char **argv,
-                     int flags) {
-  char *volatile savecmdname;
-  struct jmploc *volatile savehandler;
-  struct jmploc jmploc;
-  int status;
-  int i;
-
-  savecmdname = commandname;
-  savehandler = handler;
-  if ((i = setjmp(jmploc.loc)))
-    goto cmddone;
-  handler = &jmploc;
-  commandname = argv[0];
-  argptr = argv + 1;
-  optptr = NULL; /* initialize nextopt */
-  if (cmd == EVALCMD)
-    status = evalcmd(argc, argv, flags);
-  else
-    status = (*cmd->builtin)(argc, argv);
-  flushall();
-  if (out1->flags)
-    sh_warnx("%s: I/O error", commandname);
-  status |= out1->flags;
-  exitstatus = status;
-cmddone:
-  freestdout();
-  commandname = savecmdname;
-  handler = savehandler;
-
-  return i;
-}
-
-/*
- * Free a parse tree.
- */
-static void freefunc(struct funcnode *f) {
-  if (f && --f->count < 0)
-    ckfree(f);
-}
-
-static int evalfun(struct funcnode *func, int argc, char **argv, int flags) {
-  volatile struct shparam saveparam;
-  struct jmploc *volatile savehandler;
-  struct jmploc jmploc;
-  int e;
-  int savefuncline;
-  int saveloopnest;
-  saveparam = shellparam;
-  savefuncline = funcline;
-  saveloopnest = loopnest;
-  savehandler = handler;
-  if ((e = setjmp(jmploc.loc))) {
-    goto funcdone;
-  }
-  INTOFF;
-  handler = &jmploc;
-  shellparam.malloc = 0;
-  func->count++;
-  funcline = func->n.ndefun.linno;
-  loopnest = 0;
-  INTON;
-  shellparam.nparam = argc - 1;
-  shellparam.p = argv + 1;
-  shellparam.optind = 1;
-  shellparam.optoff = -1;
-  evaltree(func->n.ndefun.body, flags & EV_TESTED);
-funcdone:
-  INTOFF;
-  loopnest = saveloopnest;
-  funcline = savefuncline;
-  freefunc(func);
-  freeparam(&shellparam);
-  shellparam = saveparam;
-  handler = savehandler;
-  INTON;
-  evalskip &= ~(SKIPFUNC | SKIPFUNCDEF);
-  return e;
-}
-
-/*
- * Search for a command.  This is called before we fork so that the
- * location of the command will be available in the parent as well as
- * the child.  The check for "goodname" is an overly conservative
- * check that the name will not be subject to expansion.
- */
-static void prehash(union node *n) {
-  struct cmdentry entry;
-  if (n->type == NCMD && n->ncmd.args) {
-    if (goodname(n->ncmd.args->narg.text)) {
-      find_command(n->ncmd.args->narg.text, &entry, 0, pathval());
-    }
-  }
-}
-
-/*───────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell » builtins                             ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│─╝
-  Builtin commands whose functions are closely tied to evaluation are
-  implemented here. */
-
-static int falsecmd(int argc, char **argv) {
-  return 1;
-}
-
-static int truecmd(int argc, char **argv) {
-  return 0;
-}
-
-/* No command given. */
-static int bltincmd(int argc, char **argv) {
-  /*
-   * Preserve exitstatus of a previous possible redirection
-   * as POSIX mandates
-   */
-  return back_exitstatus;
-}
-
-/*
- * Handle break and continue commands.  Break, continue, and return are
- * all handled by setting the evalskip flag.  The evaluation routines
- * above all check this flag, and if it is set they start skipping
- * commands rather than executing them.  The variable skipcount is
- * the number of loops to break/continue, or the number of function
- * levels to return.  (The latter is always 1.)  It should probably
- * be an error to break out of more loops than exist, but it isn't
- * in the standard shell so we don't make it one here.
- */
-static int breakcmd(int argc, char **argv) {
-  int n = argc > 1 ? number(argv[1]) : 1;
-  if (n <= 0)
-    badnum(argv[1]);
-  if (n > loopnest)
-    n = loopnest;
-  if (n > 0) {
-    evalskip = (**argv == 'c') ? SKIPCONT : SKIPBREAK;
-    skipcount = n;
-  }
-  return 0;
-}
-
-/* The return command. */
-static int returncmd(int argc, char **argv) {
-  int skip;
-  int status;
-  /*
-   * If called outside a function, do what ksh does;
-   * skip the rest of the file.
-   */
-  if (argv[1]) {
-    skip = SKIPFUNC;
-    status = number(argv[1]);
-  } else {
-    skip = SKIPFUNCDEF;
-    status = exitstatus;
-  }
-  evalskip = skip;
-  return status;
-}
-
-static int execcmd(int argc, char **argv) {
-  if (argc > 1) {
-    iflag = 0; /* exit on error */
-    mflag = 0;
-    optschanged();
-    shellexec(argv + 1, pathval(), 0);
-  }
-  return 0;
-}
-
-static int eprintlist(struct output *out, struct strlist *sp, int sep) {
-  while (sp) {
-    const char *p;
-    p = &" %s"[!sep]; /* XXX: -Wstring-plus-int: p = " %s" + (1 - sep); */
-    sep |= 1;
-    outfmt(out, p, sp->text);
-    sp = sp->next;
-  }
-  return sep;
-}
-
-/*
- * When commands are first encountered, they are entered in a hash table.
- * This ensures that a full path search will not have to be done for them
- * on each invocation.
- *
- * We should investigate converting to a linear search, even though that
- * would make the command name "hash" a misnomer.
- */
-
-/*
- * Exec a program.  Never returns.  If you change this routine, you may
- * have to change the find_command routine as well.
- */
-wontreturn static void shellexec(char **argv, const char *path, int idx) {
-  char *cmdname;
-  int e;
-  char **envp;
-  int exerrno;
-  envp = environment();
-  if (strchr(argv[0], '/') != NULL) {
-    tryexec(argv[0], argv, envp);
-    e = errno;
-  } else {
-    e = ENOENT;
-    while (padvance(&path, argv[0]) >= 0) {
-      cmdname = stackblock();
-      if (--idx < 0 && pathopt == NULL) {
-        tryexec(cmdname, argv, envp);
-        if (errno != ENOENT && errno != ENOTDIR)
-          e = errno;
-      }
-    }
-  }
-  /* Map to POSIX errors */
-  exerrno = (e == ELOOP || e == ENAMETOOLONG || e == ENOENT || e == ENOTDIR)
-                ? 127
-                : 126;
-  exitstatus = exerrno;
-  TRACE(("shellexec failed for %s, errno %d, suppressint %d\n", argv[0], e,
-         suppressint));
-  exerror(EXEND, "%s: %s", argv[0], errmsg(e, E_EXEC));
-}
-
-static void tryexec(char *cmd, char **argv, char **envp) {
-  char *const path_bshell = _PATH_BSHELL;
-repeat:
-  execve(cmd, argv, envp);
-  if (cmd != path_bshell && errno == ENOEXEC) {
-    *argv-- = cmd;
-    *argv = cmd = path_bshell;
-    goto repeat;
-  }
-}
-
-static const char *legal_pathopt(const char *opt, const char *term, int magic) {
-  switch (magic) {
-    case 0:
-      opt = NULL;
-      break;
-    case 1:
-      opt = prefix(opt, "builtin") ?: prefix(opt, "func");
-      break;
-    default:
-      opt += strcspn(opt, term);
-      break;
-  }
-  if (opt && *opt == '%')
-    opt++;
-  return opt;
-}
-
-/*
- * Do a path search.  The variable path (passed by reference) should be
- * set to the start of the path before the first call; padvance will update
- * this value as it proceeds.  Successive calls to padvance will return
- * the possible path expansions in sequence.  If an option (indicated by
- * a percent sign) appears in the path entry then the global variable
- * pathopt will be set to point to it; otherwise pathopt will be set to
- * NULL.
- *
- * If magic is 0 then pathopt recognition will be disabled.  If magic is
- * 1 we shall recognise %builtin/%func.  Otherwise we shall accept any
- * pathopt.
- */
-static int padvance_magic(const char **path, const char *name, int magic) {
-  const char *term = "%:";
-  const char *lpathopt;
-  const char *p;
-  char *q;
-  const char *start;
-  unsigned qlen;
-  unsigned len;
-  if (*path == NULL)
-    return -1;
-  lpathopt = NULL;
-  start = *path;
-  if (*start == '%' && (p = legal_pathopt(start + 1, term, magic))) {
-    lpathopt = start + 1;
-    start = p;
-    term = ":";
-  }
-  len = strcspn(start, term);
-  p = start + len;
-  if (*p == '%') {
-    unsigned extra = strchrnul(p, ':') - p;
-    if (legal_pathopt(p + 1, term, magic))
-      lpathopt = p + 1;
-    else
-      len += extra;
-    p += extra;
-  }
-  pathopt = lpathopt;
-  *path = *p == ':' ? p + 1 : NULL;
-  /* "2" is for '/' and '\0' */
-  qlen = len + strlen(name) + 2;
-  q = growstackto(qlen);
-  if (likely(len)) {
-    q = mempcpy(q, start, len);
-    *q++ = '/';
-  }
-  strcpy(q, name);
-  return qlen;
-}
-
-/*** Command hashing code ***/
-static int hashcmd(int argc, char **argv) {
-  struct tblentry **pp;
-  struct tblentry *cmdp;
-  int c;
-  struct cmdentry entry;
-  char *name;
-  while ((c = nextopt("r")) != '\0') {
-    clearcmdentry();
-    return 0;
-  }
-  if (*argptr == NULL) {
-    for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
-      for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
-        if (cmdp->cmdtype == CMDNORMAL) {
-          printentry(cmdp);
-        }
-      }
-    }
-    return 0;
-  }
-  c = 0;
-  while ((name = *argptr) != NULL) {
-    if ((cmdp = cmdlookup(name, 0)) &&
-        (cmdp->cmdtype == CMDNORMAL ||
-         (cmdp->cmdtype == CMDBUILTIN &&
-          !(cmdp->param.cmd->flags & BUILTIN_REGULAR) && builtinloc > 0))) {
-      delete_cmd_entry();
-    }
-    find_command(name, &entry, DO_ERR, pathval());
-    if (entry.cmdtype == CMDUNKNOWN)
-      c = 1;
-    argptr++;
-  }
-  return c;
-}
-
-static void printentry(struct tblentry *cmdp) {
-  int idx;
-  const char *path;
-  char *name;
-  idx = cmdp->param.index;
-  path = pathval();
-  do {
-    padvance(&path, cmdp->cmdname);
-  } while (--idx >= 0);
-  name = stackblock();
-  outstr(name, out1);
-  out1fmt(snlfmt, cmdp->rehash ? "*" : nullstr);
-}
-
-static int cmdloop(int top);
-
-/*
- * Read a file containing shell functions.
- */
-static void readcmdfile(char *name) {
-  setinputfile(name, INPUT_PUSH_FILE);
-  cmdloop(0);
-  popfile();
-}
-
-/*
- * Search the table of builtin commands.
- */
-static struct builtincmd *find_builtin(const char *name) {
-  return bsearch(&name, kBuiltinCmds,
-                 sizeof(kBuiltinCmds) / sizeof(kBuiltinCmds[0]),
-                 sizeof(kBuiltinCmds[0]), pstrcmp);
-}
-
-/*
- * Resolve a command name.  If you change this routine, you may have to
- * change the shellexec routine as well.
- */
-static void find_command(char *name, struct cmdentry *entry, int act,
-                         const char *path) {
-  char *fullname;
-  struct stat statb;
-  struct tblentry *cmdp;
-  struct builtincmd *bcmd;
-  int e, bit, idx, prev, updatetbl, len;
-  /* If name contains a slash, don't use PATH or hash table */
-  if (strchr(name, '/') != NULL) {
-    entry->u.index = -1;
-    if (act & DO_ABS) {
-      while (stat(name, &statb) < 0) {
-        entry->cmdtype = CMDUNKNOWN;
-        return;
-      }
-    }
-    entry->cmdtype = CMDNORMAL;
-    return;
-  }
-  updatetbl = (path == pathval());
-  if (!updatetbl)
-    act |= DO_ALTPATH;
-  /* If name is in the table, check answer will be ok */
-  if ((cmdp = cmdlookup(name, 0)) != NULL) {
-    switch (cmdp->cmdtype) {
-      default:
-      case CMDNORMAL:
-        bit = DO_ALTPATH | DO_REGBLTIN;
-        break;
-      case CMDFUNCTION:
-        bit = DO_NOFUNC;
-        break;
-      case CMDBUILTIN:
-        bit = cmdp->param.cmd->flags & BUILTIN_REGULAR ? 0 : DO_REGBLTIN;
-        break;
-    }
-    if (act & bit) {
-      if (act & bit & DO_REGBLTIN)
-        goto fail;
-      updatetbl = 0;
-      cmdp = NULL;
-    } else if (cmdp->rehash == 0) {
-      /* if not invalidated by cd, we're done */
-      goto success;
-    }
-  }
-  /* If %builtin not in path, check for builtin next */
-  bcmd = find_builtin(name);
-  if (bcmd && ((bcmd->flags & BUILTIN_REGULAR) | (act & DO_ALTPATH) |
-               (builtinloc <= 0))) {
-    goto builtin_success;
-  }
-  if (act & DO_REGBLTIN)
-    goto fail;
-  /* We have to search path. */
-  prev = -1;                  /* where to start */
-  if (cmdp && cmdp->rehash) { /* doing a rehash */
-    if (cmdp->cmdtype == CMDBUILTIN)
-      prev = builtinloc;
-    else
-      prev = cmdp->param.index;
-  }
-  e = ENOENT;
-  idx = -1;
-loop:
-  while ((len = padvance(&path, name)) >= 0) {
-    const char *lpathopt = pathopt;
-    fullname = stackblock();
-    idx++;
-    if (lpathopt) {
-      if (*lpathopt == 'b') {
-        if (bcmd)
-          goto builtin_success;
-        continue;
-      } else if (!(act & DO_NOFUNC)) {
-        /* handled below */
-      } else {
-        /* ignore unimplemented options */
-        continue;
-      }
-    }
-    /* if rehash, don't redo absolute path names */
-    if (fullname[0] == '/' && idx <= prev) {
-      if (idx < prev)
-        continue;
-      TRACE(("searchexec \"%s\": no change\n", name));
-      goto success;
-    }
-    while (stat(fullname, &statb) < 0) {
-      if (errno != ENOENT && errno != ENOTDIR)
-        e = errno;
-      goto loop;
-    }
-    e = EACCES; /* if we fail, this will be the error */
-    if (!S_ISREG(statb.st_mode))
-      continue;
-    if (lpathopt) { /* this is a %func directory */
-      stalloc(len);
-      readcmdfile(fullname);
-      if ((cmdp = cmdlookup(name, 0)) == NULL || cmdp->cmdtype != CMDFUNCTION) {
-        sh_error("%s not defined in %s", name, fullname);
-      }
-      stunalloc(fullname);
-      goto success;
-    }
-    TRACE(("searchexec \"%s\" returns \"%s\"\n", name, fullname));
-    if (!updatetbl) {
-      entry->cmdtype = CMDNORMAL;
-      entry->u.index = idx;
-      return;
-    }
-    INTOFF;
-    cmdp = cmdlookup(name, 1);
-    cmdp->cmdtype = CMDNORMAL;
-    cmdp->param.index = idx;
-    INTON;
-    goto success;
-  }
-  /* We failed.  If there was an entry for this command, delete it */
-  if (cmdp && updatetbl)
-    delete_cmd_entry();
-  if (act & DO_ERR)
-    sh_warnx("%s: %s", name, errmsg(e, E_EXEC));
-fail:
-  entry->cmdtype = CMDUNKNOWN;
-  return;
-builtin_success:
-  if (!updatetbl) {
-    entry->cmdtype = CMDBUILTIN;
-    entry->u.cmd = bcmd;
-    return;
-  }
-  INTOFF;
-  cmdp = cmdlookup(name, 1);
-  cmdp->cmdtype = CMDBUILTIN;
-  cmdp->param.cmd = bcmd;
-  INTON;
-success:
-  cmdp->rehash = 0;
-  entry->cmdtype = cmdp->cmdtype;
-  entry->u = cmdp->param;
-}
-
-/*
- * Called when a cd is done.  Marks all commands so the next time they
- * are executed they will be rehashed.
- */
-static void hashcd(void) {
-  struct tblentry **pp;
-  struct tblentry *cmdp;
-  for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
-    for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
-      if (cmdp->cmdtype == CMDNORMAL ||
-          (cmdp->cmdtype == CMDBUILTIN &&
-           !(cmdp->param.cmd->flags & BUILTIN_REGULAR) && builtinloc > 0)) {
-        cmdp->rehash = 1;
-      }
-    }
-  }
-}
-
-/*
- * Fix command hash table when PATH changed.
- * Called before PATH is changed.  The argument is the new value of PATH;
- * pathval() still returns the old value at this point.
- * Called with interrupts off.
- */
-static void changepath(const char *newval) {
-  int idx;
-  int bltin;
-  const char *neu;
-  neu = newval;
-  idx = 0;
-  bltin = -1;
-  for (;;) {
-    if (*neu == '%' && prefix(neu + 1, "builtin")) {
-      bltin = idx;
-      break;
-    }
-    neu = strchr(neu, ':');
-    if (!neu)
-      break;
-    idx++;
-    neu++;
-  }
-  builtinloc = bltin;
-  clearcmdentry();
-}
-
-/*
- * Clear out command entries.  The argument specifies the first entry in
- * PATH which has changed.
- */
-static void clearcmdentry(void) {
-  struct tblentry **tblp;
-  struct tblentry **pp;
-  struct tblentry *cmdp;
-  INTOFF;
-  for (tblp = cmdtable; tblp < &cmdtable[CMDTABLESIZE]; tblp++) {
-    pp = tblp;
-    while ((cmdp = *pp) != NULL) {
-      if (cmdp->cmdtype == CMDNORMAL ||
-          (cmdp->cmdtype == CMDBUILTIN &&
-           !(cmdp->param.cmd->flags & BUILTIN_REGULAR) && builtinloc > 0)) {
-        *pp = cmdp->next;
-        ckfree(cmdp);
-      } else {
-        pp = &cmdp->next;
-      }
-    }
-  }
-  INTON;
-}
-
-/*
- * Locate a command in the command hash table.  If "add" is nonzero,
- * add the command to the table if it is not already present.  The
- * variable "lastcmdentry" is set to point to the address of the link
- * pointing to the entry, so that delete_cmd_entry can delete the
- * entry.
- *
- * Interrupts must be off if called with add != 0.
- */
-static struct tblentry *cmdlookup(const char *name, int add) {
-  unsigned int hashval;
-  const char *p;
-  struct tblentry *cmdp;
-  struct tblentry **pp;
-  p = name;
-  hashval = (unsigned char)*p << 4;
-  while (*p)
-    hashval += (unsigned char)*p++;
-  hashval &= 0x7FFF;
-  pp = &cmdtable[hashval % CMDTABLESIZE];
-  for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
-    if (equal(cmdp->cmdname, name))
-      break;
-    pp = &cmdp->next;
-  }
-  if (add && cmdp == NULL) {
-    cmdp = *pp = ckmalloc(sizeof(struct tblentry) + strlen(name) + 1);
-    cmdp->next = NULL;
-    cmdp->cmdtype = CMDUNKNOWN;
-    strcpy(cmdp->cmdname, name);
-  }
-  lastcmdentry = pp;
-  return cmdp;
-}
-
-/*
- * Delete the command entry returned on the last lookup.
- */
-static void delete_cmd_entry(void) {
-  struct tblentry *cmdp;
-  INTOFF;
-  cmdp = *lastcmdentry;
-  *lastcmdentry = cmdp->next;
-  if (cmdp->cmdtype == CMDFUNCTION)
-    freefunc(cmdp->param.func);
-  ckfree(cmdp);
-  INTON;
-}
-
-/*
- * Add a new command entry, replacing any existing command entry for
- * the same name - except special builtins.
- */
-static void addcmdentry(char *name, struct cmdentry *entry) {
-  struct tblentry *cmdp;
-  cmdp = cmdlookup(name, 1);
-  if (cmdp->cmdtype == CMDFUNCTION) {
-    freefunc(cmdp->param.func);
-  }
-  cmdp->cmdtype = entry->cmdtype;
-  cmdp->param = entry->u;
-  cmdp->rehash = 0;
-}
-
-/* Define a shell function. */
-static void defun(union node *func) {
-  struct cmdentry entry;
-  INTOFF;
-  entry.cmdtype = CMDFUNCTION;
-  entry.u.func = copyfunc(func);
-  addcmdentry(func->ndefun.text, &entry);
-  INTON;
-}
-
-/* Delete a function if it exists. */
-static void unsetfunc(const char *name) {
-  struct tblentry *cmdp;
-  if ((cmdp = cmdlookup(name, 0)) != NULL && cmdp->cmdtype == CMDFUNCTION) {
-    delete_cmd_entry();
-  }
-}
-
-/* Locate and print what a word is... */
-static int typecmd(int argc, char **argv) {
-  int i;
-  int err = 0;
-  for (i = 1; i < argc; i++) {
-    err |= describe_command(out1, argv[i], NULL, 1);
-  }
-  return err;
-}
-
-static int describe_command(struct output *out, char *command, const char *path,
-                            int verbose) {
-  struct cmdentry entry;
-  struct tblentry *cmdp;
-  const struct alias *ap;
-  if (verbose) {
-    outstr(command, out);
-  }
-  /* First look at the keywords */
-  if (findkwd(command)) {
-    outstr(verbose ? " is a shell keyword" : command, out);
-    goto out;
-  }
-  /* Then look at the aliases */
-  if ((ap = lookupalias(command, 0)) != NULL) {
-    if (verbose) {
-      outfmt(out, " is an alias for %s", ap->val);
-    } else {
-      outstr("alias ", out);
-      printalias(ap);
-      return 0;
-    }
-    goto out;
-  }
-  /* Then if the standard search path is used, check if it is
-   * a tracked alias.
-   */
-  if (path == NULL) {
-    path = pathval();
-    cmdp = cmdlookup(command, 0);
-  } else {
-    cmdp = NULL;
-  }
-  if (cmdp != NULL) {
-    entry.cmdtype = cmdp->cmdtype;
-    entry.u = cmdp->param;
-  } else {
-    /* Finally use brute force */
-    find_command(command, &entry, DO_ABS, path);
-  }
-  switch (entry.cmdtype) {
-    case CMDNORMAL: {
-      int j = entry.u.index;
-      char *p;
-      if (j == -1) {
-        p = command;
-      } else {
-        do {
-          padvance(&path, command);
-        } while (--j >= 0);
-        p = stackblock();
-      }
-      if (verbose) {
-        outfmt(out, " is%s %s", cmdp ? " a tracked alias for" : nullstr, p);
-      } else {
-        outstr(p, out);
-      }
-      break;
-    }
-    case CMDFUNCTION:
-      if (verbose) {
-        outstr(" is a shell function", out);
-      } else {
-        outstr(command, out);
-      }
-      break;
-    case CMDBUILTIN:
-      if (verbose) {
-        outfmt(out, " is a %sshell builtin",
-               entry.u.cmd->flags & BUILTIN_SPECIAL ? "special " : nullstr);
-      } else {
-        outstr(command, out);
-      }
-      break;
-    default:
-      if (verbose) {
-        outstr(": not found\n", out);
-      }
-      return 127;
-  }
-out:
-  outc('\n', out);
-  return 0;
-}
-
-static int commandcmd(argc, argv)
-int argc;
-char **argv;
-{
-  char *cmd;
-  int c;
-  enum {
-    VERIFY_BRIEF = 1,
-    VERIFY_VERBOSE = 2,
-  } verify = 0;
-  const char *path = NULL;
-  while ((c = nextopt("pvV")) != '\0')
-    if (c == 'V')
-      verify |= VERIFY_VERBOSE;
-    else if (c == 'v')
-      verify |= VERIFY_BRIEF;
-    else
-      path = defpath;
-  cmd = *argptr;
-  if (verify && cmd) {
-    return describe_command(out1, cmd, path, verify - VERIFY_BRIEF);
-  }
-  return 0;
-}
-
-/*
- * Prepare a pattern for a glob(3) call.
- *
- * Returns an stalloced string.
- */
-static inline char *preglob(const char *pattern, int flag) {
-  flag |= RMESCAPE_GLOB;
-  return rmescapes((char *)pattern, flag);
-}
-
-static unsigned esclen(const char *start, const char *p) {
-  unsigned esc = 0;
-  while (p > start && *--p == (char)CTLESC) {
-    esc++;
-  }
-  return esc;
-}
-
-static inline const char *getpwhome(const char *name) {
-  struct passwd *pw = getpwnam(name);
-  return pw ? pw->pw_dir : 0;
-}
-
-static void ifsbreakup(char *string, int maxargs, struct arglist *arglist);
-static void recordregion(int start, int end, int nulonly);
-
-/*
- * Perform variable substitution and command substitution on an
- * argument, placing the resulting list of arguments in arglist. If
- * EXP_FULL is true, perform splitting and file name expansion. When
- * arglist is NULL, perform here document expansion.
- */
-static void expandarg(union node *arg, struct arglist *arglist, int flag) {
-  struct strlist *sp;
-  char *p;
-  argbackq = arg->narg.backquote;
-  STARTSTACKSTR(expdest);
-  argstr(arg->narg.text, flag);
-  if (arglist == NULL) {
-    /* here document expanded */
-    goto out;
-  }
-  p = grabstackstr(expdest);
-  exparg.lastp = &exparg.list;
-  /*
-   * TODO - EXP_REDIR
-   */
-  if (flag & EXP_FULL) {
-    ifsbreakup(p, -1, &exparg);
-    *exparg.lastp = NULL;
-    exparg.lastp = &exparg.list;
-    expandmeta(exparg.list);
-  } else {
-    sp = (struct strlist *)stalloc(sizeof(struct strlist));
-    sp->text = p;
-    *exparg.lastp = sp;
-    exparg.lastp = &sp->next;
-  }
-  *exparg.lastp = NULL;
-  if (exparg.list) {
-    *arglist->lastp = exparg.list;
-    arglist->lastp = exparg.lastp;
-  }
-out:
-  ifsfree();
-}
-
-/*
- * Perform variable and command substitution. If EXP_FULL is set, output
- * CTLESC characters to allow for further processing. Otherwise treat $@
- * like $* since no splitting will be performed.
- */
-static char *argstr(char *p, int flag) {
-  static const int DOLATSTRLEN = 6;
-  static const char spclchars[] = {'=',       ':',    CTLQUOTEMARK, CTLENDVAR,
-                                   CTLESC,    CTLVAR, CTLBACKQ,     CTLARI,
-                                   CTLENDARI, 0};
-  const char *reject = spclchars;
-  int c;
-  int breakall = (flag & (EXP_WORD | EXP_QUOTED)) == EXP_WORD;
-  int inquotes;
-  unsigned length;
-  int startloc;
-  reject += !!(flag & EXP_VARTILDE2);
-  reject += flag & EXP_VARTILDE ? 0 : 2;
-  inquotes = 0;
-  length = 0;
-  if (flag & EXP_TILDE) {
-    flag &= ~EXP_TILDE;
-  tilde:
-    if (*p == '~')
-      p = exptilde(p, flag);
-  }
-start:
-  startloc = expdest - (char *)stackblock();
-  for (;;) {
-    int end;
-    length += strcspn(p + length, reject);
-    end = 0;
-    c = (signed char)p[length];
-    if (!(c & 0x80) || c == CTLENDARI || c == CTLENDVAR) {
-      /*
-       * c == '=' || c == ':' || c == '\0' ||
-       * c == CTLENDARI || c == CTLENDVAR
-       */
-      length++;
-      /* c == '\0' || c == CTLENDARI || c == CTLENDVAR */
-      end = !!((c - 1) & 0x80);
-    }
-    if (length > 0 && !(flag & EXP_DISCARD)) {
-      int newloc;
-      char *q;
-      q = stnputs(p, length, expdest);
-      q[-1] &= end - 1;
-      expdest = q - (flag & EXP_WORD ? end : 0);
-      newloc = q - (char *)stackblock() - end;
-      if (breakall && !inquotes && newloc > startloc) {
-        recordregion(startloc, newloc, 0);
-      }
-      startloc = newloc;
-    }
-    p += length + 1;
-    length = 0;
-    if (end)
-      break;
-    switch (c) {
-      case '=':
-        flag |= EXP_VARTILDE2;
-        reject++;
-        /* fall through */
-      case ':':
-        /*
-         * sort of a hack - expand tildes in variable
-         * assignments (after the first '=' and after ':'s).
-         */
-        if (*--p == '~') {
-          goto tilde;
-        }
-        continue;
-      case CTLQUOTEMARK:
-        /* "$@" syntax adherence hack */
-        if (!inquotes && !memcmp(p, dolatstr + 1, DOLATSTRLEN - 1)) {
-          p = evalvar(p + 1, flag | EXP_QUOTED) + 1;
-          goto start;
-        }
-        inquotes ^= EXP_QUOTED;
-      addquote:
-        if (flag & QUOTES_ESC) {
-          p--;
-          length++;
-          startloc++;
-        }
-        break;
-      case CTLESC:
-        startloc++;
-        length++;
-        goto addquote;
-      case CTLVAR:
-        p = evalvar(p, flag | inquotes);
-        goto start;
-      case CTLBACKQ:
-        expbackq(argbackq->n, flag | inquotes);
-        goto start;
-      case CTLARI:
-        p = expari(p, flag | inquotes);
-        goto start;
-    }
-  }
-  return p - 1;
-}
-
-static char *exptilde(char *startp, int flag) {
-  signed char c;
-  char *name;
-  const char *home;
-  char *p;
-  p = startp;
-  name = p + 1;
-  while ((c = *++p) != '\0') {
-    switch (c) {
-      case CTLESC:
-        return (startp);
-      case CTLQUOTEMARK:
-        return (startp);
-      case ':':
-        if (flag & EXP_VARTILDE)
-          goto done;
-        break;
-      case '/':
-      case CTLENDVAR:
-        goto done;
-    }
-  }
-done:
-  if (flag & EXP_DISCARD)
-    goto out;
-  *p = '\0';
-  if (*name == '\0') {
-    home = lookupvar(homestr);
-  } else {
-    home = getpwhome(name);
-  }
-  *p = c;
-  if (!home)
-    goto lose;
-  strtodest(home, flag | EXP_QUOTED);
-out:
-  return (p);
-lose:
-  return (startp);
-}
-
-static void removerecordregions(int endoff) {
-  if (ifslastp == NULL)
-    return;
-  if (ifsfirst.endoff > endoff) {
-    while (ifsfirst.next != NULL) {
-      struct ifsregion *ifsp;
-      INTOFF;
-      ifsp = ifsfirst.next->next;
-      ckfree(ifsfirst.next);
-      ifsfirst.next = ifsp;
-      INTON;
-    }
-    if (ifsfirst.begoff > endoff)
-      ifslastp = NULL;
-    else {
-      ifslastp = &ifsfirst;
-      ifsfirst.endoff = endoff;
-    }
-    return;
-  }
-  ifslastp = &ifsfirst;
-  while (ifslastp->next && ifslastp->next->begoff < endoff) {
-    ifslastp = ifslastp->next;
-  }
-  while (ifslastp->next != NULL) {
-    struct ifsregion *ifsp;
-    INTOFF;
-    ifsp = ifslastp->next->next;
-    ckfree(ifslastp->next);
-    ifslastp->next = ifsp;
-    INTON;
-  }
-  if (ifslastp->endoff > endoff)
-    ifslastp->endoff = endoff;
-}
-
-/*
- * Expand arithmetic expression. Backup to start of expression,
- * evaluate, place result in (backed up) result, adjust string position.
- */
-static char *expari(char *start, int flag) {
-  struct stackmark sm;
-  int begoff;
-  int endoff;
-  int len;
-  int64_t result;
-  char *p;
-  p = stackblock();
-  begoff = expdest - p;
-  p = argstr(start, flag & EXP_DISCARD);
-  if (flag & EXP_DISCARD)
-    goto out;
-  start = stackblock();
-  endoff = expdest - start;
-  start += begoff;
-  STADJUST(start - expdest, expdest);
-  removerecordregions(begoff);
-  if (likely(flag & QUOTES_ESC))
-    rmescapes(start, 0);
-  pushstackmark(&sm, endoff);
-  result = arith(start);
-  popstackmark(&sm);
-  len = cvtnum(result, flag);
-  if (likely(!(flag & EXP_QUOTED)))
-    recordregion(begoff, begoff + len, 0);
-out:
-  return p;
-}
-
-/*
- * Expand stuff in backwards quotes.
- */
-static void expbackq(union node *cmd, int flag) {
-  struct backcmd in;
-  int i;
-  char buf[128];
-  char *p;
-  char *dest;
-  int startloc;
-  struct stackmark smark;
-  if (flag & EXP_DISCARD)
-    goto out;
-  INTOFF;
-  startloc = expdest - (char *)stackblock();
-  pushstackmark(&smark, startloc);
-  evalbackcmd(cmd, (struct backcmd *)&in);
-  popstackmark(&smark);
-  p = in.buf;
-  i = in.nleft;
-  if (i == 0)
-    goto read;
-  for (;;) {
-    memtodest(p, i, flag);
-  read:
-    if (in.fd < 0)
-      break;
-    do {
-      i = read(in.fd, buf, sizeof buf);
-    } while (i < 0 && errno == EINTR);
-    TRACE(("expbackq: read returns %d\n", i));
-    if (i <= 0)
-      break;
-    p = buf;
-  }
-  if (in.buf)
-    ckfree(in.buf);
-  if (in.fd >= 0) {
-    close(in.fd);
-    back_exitstatus = waitforjob(in.jp);
-  }
-  INTON;
-  /* Eat all trailing newlines */
-  dest = expdest;
-  for (; dest > ((char *)stackblock() + startloc) && dest[-1] == '\n';) {
-    STUNPUTC(dest);
-  }
-  expdest = dest;
-  if (!(flag & EXP_QUOTED)) {
-    recordregion(startloc, dest - (char *)stackblock(), 0);
-  }
-  TRACE(("evalbackq: size=%d: \"%.*s\"\n",
-         (dest - (char *)stackblock()) - startloc,
-         (dest - (char *)stackblock()) - startloc,
-         (char *)stackblock() + startloc));
-out:
-  argbackq = argbackq->next;
-}
-
-static char *scanleft(char *startp, char *rmesc, char *rmescend, char *str,
-                      int quotes, int zero) {
-  char *loc;
-  char *loc2;
-  char c;
-  loc = startp;
-  loc2 = rmesc;
-  do {
-    int match;
-    const char *s = loc2;
-    c = *loc2;
-    if (zero) {
-      *loc2 = '\0';
-      s = rmesc;
-    }
-    match = pmatch(str, s);
-    *loc2 = c;
-    if (match)
-      return loc;
-    if (quotes && *loc == (char)CTLESC)
-      loc++;
-    loc++;
-    loc2++;
-  } while (c);
-  return 0;
-}
-
-static char *scanright(char *startp, char *rmesc, char *rmescend, char *str,
-                       int quotes, int zero) {
-  int esc = 0;
-  char *loc;
-  char *loc2;
-  for (loc = str - 1, loc2 = rmescend; loc >= startp; loc2--) {
-    int match;
-    char c = *loc2;
-    const char *s = loc2;
-    if (zero) {
-      *loc2 = '\0';
-      s = rmesc;
-    }
-    match = pmatch(str, s);
-    *loc2 = c;
-    if (match)
-      return loc;
-    loc--;
-    if (quotes) {
-      if (--esc < 0) {
-        esc = esclen(startp, loc);
-      }
-      if (esc % 2) {
-        esc--;
-        loc--;
-      }
-    }
-  }
-  return 0;
-}
-
-static char *subevalvar(char *start, char *str, int strloc, int startloc,
-                        int varflags, int flag) {
-  int subtype = varflags & VSTYPE;
-  int quotes = flag & QUOTES_ESC;
-  char *startp;
-  char *loc;
-  long amount;
-  char *rmesc, *rmescend;
-  int zero;
-  char *(*scan)(char *, char *, char *, char *, int, int);
-  char *p;
-  p = argstr(start, (flag & EXP_DISCARD) | EXP_TILDE | (str ? 0 : EXP_CASE));
-  if (flag & EXP_DISCARD)
-    return p;
-  startp = (char *)stackblock() + startloc;
-  switch (subtype) {
-    case VSASSIGN:
-      setvar(str, startp, 0);
-      loc = startp;
-      goto out;
-    case VSQUESTION:
-      varunset(start, str, startp, varflags);
-      __builtin_unreachable();
-  }
-  subtype -= VSTRIMRIGHT;
-  rmesc = startp;
-  rmescend = (char *)stackblock() + strloc;
-  if (quotes) {
-    rmesc = rmescapes(startp, RMESCAPE_ALLOC | RMESCAPE_GROW);
-    if (rmesc != startp) {
-      rmescend = expdest;
-      startp = (char *)stackblock() + startloc;
-    }
-  }
-  rmescend--;
-  str = (char *)stackblock() + strloc;
-  preglob(str, 0);
-  /* zero = subtype == VSTRIMLEFT || subtype == VSTRIMLEFTMAX */
-  zero = subtype >> 1;
-  /* VSTRIMLEFT/VSTRIMRIGHTMAX -> scanleft */
-  scan = (subtype & 1) ^ zero ? scanleft : scanright;
-  loc = scan(startp, rmesc, rmescend, str, quotes, zero);
-  if (loc) {
-    if (zero) {
-      memmove(startp, loc, str - loc);
-      loc = startp + (str - loc) - 1;
-    }
-    *loc = '\0';
-  } else
-    loc = str - 1;
-out:
-  amount = loc - expdest;
-  STADJUST(amount, expdest);
-  /* Remove any recorded regions beyond start of variable */
-  removerecordregions(startloc);
-  return p;
-}
-
-/*
- * Expand a variable, and return a pointer to the next character in the
- * input string.
- */
-static char *evalvar(char *p, int flag) {
-  int subtype;
-  int varflags;
-  char *var_;
-  int patloc;
-  int startloc;
-  long varlen;
-  int discard;
-  int quoted;
-  varflags = *p++;
-  subtype = varflags & VSTYPE;
-  quoted = flag & EXP_QUOTED;
-  var_ = p;
-  startloc = expdest - (char *)stackblock();
-  p = strchr(p, '=') + 1;
-again:
-  varlen = varvalue(var_, varflags, flag, quoted);
-  if (varflags & VSNUL)
-    varlen--;
-  discard = varlen < 0 ? EXP_DISCARD : 0;
-  switch (subtype) {
-    case VSPLUS:
-      discard ^= EXP_DISCARD;
-      /* fall through */
-    case 0:
-    case VSMINUS:
-      p = argstr(p, flag | EXP_TILDE | EXP_WORD | (discard ^ EXP_DISCARD));
-      goto record;
-    case VSASSIGN:
-    case VSQUESTION:
-      p = subevalvar(p, var_, 0, startloc, varflags,
-                     (flag & ~QUOTES_ESC) | (discard ^ EXP_DISCARD));
-      if ((flag | ~discard) & EXP_DISCARD)
-        goto record;
-      varflags &= ~VSNUL;
-      subtype = VSNORMAL;
-      goto again;
-  }
-  if ((discard & ~flag) && uflag)
-    varunset(p, var_, 0, 0);
-  if (subtype == VSLENGTH) {
-    p++;
-    if (flag & EXP_DISCARD)
-      return p;
-    cvtnum(varlen > 0 ? varlen : 0, flag);
-    goto really_record;
-  }
-  if (subtype == VSNORMAL)
-    goto record;
-  flag |= discard;
-  if (!(flag & EXP_DISCARD)) {
-    /*
-     * Terminate the string and start recording the pattern
-     * right after it
-     */
-    STPUTC('\0', expdest);
-  }
-  patloc = expdest - (char *)stackblock();
-  p = subevalvar(p, NULL, patloc, startloc, varflags, flag);
-record:
-  if ((flag | discard) & EXP_DISCARD)
-    return p;
-really_record:
-  if (quoted) {
-    quoted = *var_ == '@' && shellparam.nparam;
-    if (!quoted)
-      return p;
-  }
-  recordregion(startloc, expdest - (char *)stackblock(), quoted);
-  return p;
-}
-
-/*
- * Put a string on the stack.
- */
-static unsigned memtodest(const char *p, unsigned len, int flags) {
-  const char *syntax = flags & EXP_QUOTED ? DQSYNTAX : BASESYNTAX;
-  char *q;
-  char *s;
-  if (unlikely(!len))
-    return 0;
-  q = makestrspace(len * 2, expdest);
-  s = q;
-  do {
-    int c = (signed char)*p++;
-    if (c) {
-      if ((flags & QUOTES_ESC) &&
-          ((syntax[c] == CCTL) || (flags & EXP_QUOTED && syntax[c] == CBACK))) {
-        USTPUTC(CTLESC, q);
-      }
-    } else if (!(flags & EXP_KEEPNUL))
-      continue;
-    USTPUTC(c, q);
-  } while (--len);
-  expdest = q;
-  return q - s;
-}
-
-static unsigned strtodest(const char *p, int flags) {
-  unsigned len = strlen(p);
-  memtodest(p, len, flags);
-  return len;
-}
-
-/*
- * Add the value of a specialized variable to the stack string.
- */
-static long varvalue(char *name, int varflags, int flags, int quoted) {
-  int num;
-  char *p;
-  int i;
-  int sep;
-  char sepc;
-  char **ap;
-  int subtype = varflags & VSTYPE;
-  int discard =
-      (subtype == VSPLUS || subtype == VSLENGTH) | (flags & EXP_DISCARD);
-  long len = 0;
-  char c;
-  if (!subtype) {
-    if (discard)
-      return -1;
-    sh_error("Bad substitution");
-  }
-  flags |= EXP_KEEPNUL;
-  flags &= discard ? ~QUOTES_ESC : ~0;
-  sep = (flags & EXP_FULL) << CHAR_BIT;
-  switch (*name) {
-    case '$':
-      num = rootpid;
-      goto numvar;
-    case '?':
-      num = exitstatus;
-      goto numvar;
-    case '#':
-      num = shellparam.nparam;
-      goto numvar;
-    case '!':
-      num = backgndpid;
-      if (num == 0)
-        return -1;
-    numvar:
-      len = cvtnum(num, flags);
-      break;
-    case '-':
-      p = makestrspace(NOPTS, expdest);
-      for (i = NOPTS - 1; i >= 0; i--) {
-        if (optlist[i] && optletters[i]) {
-          USTPUTC(optletters[i], p);
-          len++;
-        }
-      }
-      expdest = p;
-      break;
-    case '@':
-      if (quoted && sep)
-        goto param;
-      /* fall through */
-    case '*':
-      /* We will set c to 0 or ~0 depending on whether
-       * we're doing field splitting.  We won't do field
-       * splitting if either we're quoted or sep is zero.
-       *
-       * Instead of testing (quoted || !sep) the following
-       * trick optimises away any branches by using the
-       * fact that EXP_QUOTED (which is the only bit that
-       * can be set in quoted) is the same as EXP_FULL <<
-       * CHAR_BIT (which is the only bit that can be set
-       * in sep).
-       */
-      /* #if EXP_QUOTED >> CHAR_BIT != EXP_FULL */
-      /* #error The following two lines expect EXP_QUOTED == EXP_FULL <<
-       * CHAR_BIT */
-      /* #endif */
-      c = !((quoted | ~sep) & EXP_QUOTED) - 1;
-      sep &= ~quoted;
-      sep |= ifsset() ? (unsigned char)(c & ifsval()[0]) : ' ';
-    param:
-      sepc = sep;
-      if (!(ap = shellparam.p))
-        return -1;
-      while ((p = *ap++)) {
-        len += strtodest(p, flags);
-        if (*ap && sep) {
-          len++;
-          memtodest(&sepc, 1, flags);
-        }
-      }
-      break;
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-      num = atoi(name);
-      if (num < 0 || num > shellparam.nparam)
-        return -1;
-      p = num ? shellparam.p[num - 1] : arg0;
-      goto value;
-    default:
-      p = lookupvar(name);
-    value:
-      if (!p)
-        return -1;
-      len = strtodest(p, flags);
-      break;
-  }
-  if (discard)
-    STADJUST(-len, expdest);
-  return len;
-}
-
-/*
- * Record the fact that we have to scan this region of the
- * string for IFS characters.
- */
-static void recordregion(int start, int end, int nulonly) {
-  struct ifsregion *ifsp;
-  if (ifslastp == NULL) {
-    ifsp = &ifsfirst;
-  } else {
-    INTOFF;
-    ifsp = (struct ifsregion *)ckmalloc(sizeof(struct ifsregion));
-    ifsp->next = NULL;
-    ifslastp->next = ifsp;
-    INTON;
-  }
-  ifslastp = ifsp;
-  ifslastp->begoff = start;
-  ifslastp->endoff = end;
-  ifslastp->nulonly = nulonly;
-}
-
-/*
- * Break the argument string into pieces based upon IFS and add the
- * strings to the argument list.  The regions of the string to be
- * searched for IFS characters have been stored by recordregion.
- * If maxargs is non-negative, at most maxargs arguments will be created, by
- * joining together the last arguments.
- */
-static void ifsbreakup(char *string, int maxargs, struct arglist *arglist) {
-  struct ifsregion *ifsp;
-  struct strlist *sp;
-  char *start;
-  char *p;
-  char *q;
-  char *r = NULL;
-  const char *ifs, *realifs;
-  int ifsspc;
-  int nulonly;
-  start = string;
-  if (ifslastp != NULL) {
-    ifsspc = 0;
-    nulonly = 0;
-    realifs = ifsset() ? ifsval() : defifs;
-    ifsp = &ifsfirst;
-    do {
-      int afternul;
-      p = string + ifsp->begoff;
-      afternul = nulonly;
-      nulonly = ifsp->nulonly;
-      ifs = nulonly ? nullstr : realifs;
-      ifsspc = 0;
-      while (p < string + ifsp->endoff) {
-        int c;
-        bool isifs;
-        bool isdefifs;
-        q = p;
-        c = *p++;
-        if (c == (char)CTLESC)
-          c = *p++;
-        isifs = !!strchr(ifs, c);
-        isdefifs = false;
-        if (isifs)
-          isdefifs = !!strchr(defifs, c);
-        /* If only reading one more argument:
-         * If we have exactly one field,
-         * read that field without its terminator.
-         * If we have more than one field,
-         * read all fields including their terminators,
-         * except for trailing IFS whitespace.
-         *
-         * This means that if we have only IFS
-         * characters left, and at most one
-         * of them is non-whitespace, we stop
-         * reading here.
-         * Otherwise, we read all the remaining
-         * characters except for trailing
-         * IFS whitespace.
-         *
-         * In any case, r indicates the start
-         * of the characters to remove, or NULL
-         * if no characters should be removed.
-         */
-        if (!maxargs) {
-          if (isdefifs) {
-            if (!r)
-              r = q;
-            continue;
-          }
-          if (!(isifs && ifsspc))
-            r = NULL;
-          ifsspc = 0;
-          continue;
-        }
-        if (ifsspc) {
-          if (isifs)
-            q = p;
-          start = q;
-          if (isdefifs)
-            continue;
-          isifs = false;
-        }
-        if (isifs) {
-          if (!(afternul || nulonly))
-            ifsspc = isdefifs;
-          /* Ignore IFS whitespace at start */
-          if (q == start && ifsspc) {
-            start = p;
-            ifsspc = 0;
-            continue;
-          }
-          if (maxargs > 0 && !--maxargs) {
-            r = q;
-            continue;
-          }
-          *q = '\0';
-          sp = (struct strlist *)stalloc(sizeof *sp);
-          sp->text = start;
-          *arglist->lastp = sp;
-          arglist->lastp = &sp->next;
-          start = p;
-          continue;
-        }
-        ifsspc = 0;
-      }
-    } while ((ifsp = ifsp->next) != NULL);
-    if (nulonly)
-      goto add;
-  }
-  if (r)
-    *r = '\0';
-  if (!*start)
-    return;
-add:
-  sp = (struct strlist *)stalloc(sizeof *sp);
-  sp->text = start;
-  *arglist->lastp = sp;
-  arglist->lastp = &sp->next;
-}
-
-/*
- * Expand shell metacharacters.  At this point, the only control characters
- * should be escapes.  The results are stored in the list exparg.
- */
-static void expandmeta(struct strlist *str) {
-  static const char metachars[] = {'*', '?', '[', 0};
-  /* TODO - EXP_REDIR */
-  while (str) {
-    struct strlist **savelastp;
-    struct strlist *sp;
-    char *p;
-    unsigned len;
-    if (fflag)
-      goto nometa;
-    if (!strpbrk(str->text, metachars))
-      goto nometa;
-    savelastp = exparg.lastp;
-    INTOFF;
-    p = preglob(str->text, RMESCAPE_ALLOC | RMESCAPE_HEAP);
-    len = strlen(p);
-    expdir_max = len + PATH_MAX;
-    expdir = ckmalloc(expdir_max);
-    expmeta(p, len, 0);
-    ckfree(expdir);
-    if (p != str->text)
-      ckfree(p);
-    INTON;
-    if (exparg.lastp == savelastp) {
-      /*
-       * no matches
-       */
-    nometa:
-      *exparg.lastp = str;
-      rmescapes(str->text, 0);
-      exparg.lastp = &str->next;
-    } else {
-      *exparg.lastp = NULL;
-      *savelastp = sp = expsort(*savelastp);
-      while (sp->next != NULL)
-        sp = sp->next;
-      exparg.lastp = &sp->next;
-    }
-    str = str->next;
-  }
-}
-
-/*
- * Do metacharacter (i.e. *, ?, [...]) expansion.
- */
-static void expmeta(char *name, unsigned name_len, unsigned expdir_len) {
-  char *enddir = expdir + expdir_len;
-  char *p;
-  const char *cp;
-  char *start;
-  char *endname;
-  int metaflag;
-  struct stat statb;
-  DIR *dirp;
-  struct dirent *dp;
-  int atend;
-  int matchdot;
-  int esc;
-  metaflag = 0;
-  start = name;
-  for (p = name; esc = 0, *p; p += esc + 1) {
-    if (*p == '*' || *p == '?')
-      metaflag = 1;
-    else if (*p == '[') {
-      char *q = p + 1;
-      if (*q == '!')
-        q++;
-      for (;;) {
-        if (*q == '\\')
-          q++;
-        if (*q == '/' || *q == '\0')
-          break;
-        if (*++q == ']') {
-          metaflag = 1;
-          break;
-        }
-      }
-    } else {
-      if (*p == '\\' && p[1])
-        esc++;
-      if (p[esc] == '/') {
-        if (metaflag)
-          break;
-        start = p + esc + 1;
-      }
-    }
-  }
-  if (metaflag == 0) { /* we've reached the end of the file name */
-    if (!expdir_len)
-      return;
-    p = name;
-    do {
-      if (*p == '\\' && p[1])
-        p++;
-      *enddir++ = *p;
-    } while (*p++);
-    if (lstat(expdir, &statb) >= 0)
-      addfname(expdir);
-    return;
-  }
-  endname = p;
-  if (name < start) {
-    p = name;
-    do {
-      if (*p == '\\' && p[1])
-        p++;
-      *enddir++ = *p++;
-    } while (p < start);
-  }
-  *enddir = 0;
-  cp = expdir;
-  expdir_len = enddir - cp;
-  if (!expdir_len)
-    cp = ".";
-  if ((dirp = opendir(cp)) == NULL)
-    return;
-  if (*endname == 0) {
-    atend = 1;
-  } else {
-    atend = 0;
-    *endname = '\0';
-    endname += esc + 1;
-  }
-  name_len -= endname - name;
-  matchdot = 0;
-  p = start;
-  if (*p == '\\')
-    p++;
-  if (*p == '.')
-    matchdot++;
-  while (!int_pending() && (dp = readdir(dirp)) != NULL) {
-    if (dp->d_name[0] == '.' && !matchdot)
-      continue;
-    if (pmatch(start, dp->d_name)) {
-      if (atend) {
-        scopy(dp->d_name, enddir);
-        addfname(expdir);
-      } else {
-        unsigned offset;
-        unsigned len;
-        p = stpcpy(enddir, dp->d_name);
-        *p = '/';
-        offset = p - expdir + 1;
-        len = offset + name_len + NAME_MAX;
-        if (len > expdir_max) {
-          len += PATH_MAX;
-          expdir = ckrealloc(expdir, len);
-          expdir_max = len;
-        }
-        expmeta(endname, name_len, offset);
-        enddir = expdir + expdir_len;
-      }
-    }
-  }
-  closedir(dirp);
-  if (!atend)
-    endname[-esc - 1] = esc ? '\\' : '/';
-}
-
-/*
- * Add a file name to the list.
- */
-static void addfname(char *name) {
-  struct strlist *sp;
-  sp = (struct strlist *)stalloc(sizeof *sp);
-  sp->text = sstrdup(name);
-  *exparg.lastp = sp;
-  exparg.lastp = &sp->next;
-}
-
-/*
- * Sort the results of file name expansion.  It calculates the number of
- * strings to sort and then calls msort (short for merge sort) to do the
- * work.
- */
-static struct strlist *expsort(struct strlist *str) {
-  int len;
-  struct strlist *sp;
-  len = 0;
-  for (sp = str; sp; sp = sp->next)
-    len++;
-  return msort(str, len);
-}
-
-static struct strlist *msort(struct strlist *list, int len) {
-  struct strlist *p, *q = NULL;
-  struct strlist **lpp;
-  int half;
-  int n;
-  if (len <= 1)
-    return list;
-  half = len >> 1;
-  p = list;
-  for (n = half; --n >= 0;) {
-    q = p;
-    p = p->next;
-  }
-  q->next = NULL;           /* terminate first half of list */
-  q = msort(list, half);    /* sort first half of list */
-  p = msort(p, len - half); /* sort second half */
-  lpp = &list;
-  for (;;) {
-    if (strcmp(p->text, q->text) < 0) {
-      *lpp = p;
-      lpp = &p->next;
-      if ((p = *lpp) == NULL) {
-        *lpp = q;
-        break;
-      }
-    } else {
-      *lpp = q;
-      lpp = &q->next;
-      if ((q = *lpp) == NULL) {
-        *lpp = p;
-        break;
-      }
-    }
-  }
-  return list;
-}
-
-/*
- * Returns true if the pattern matches the string.
- */
-static inline int patmatch(char *pattern, const char *string) {
-  return pmatch(preglob(pattern, 0), string);
-}
-
-static int ccmatch(const char *p, int chr, const char **r) {
-  static const struct class {
-    char name[10];
-    int (*fn)(int);
-  } classes[] = {{.name = ":alnum:]", .fn = isalnum},
-                 {.name = ":cntrl:]", .fn = iscntrl},
-                 {.name = ":lower:]", .fn = islower},
-                 {.name = ":space:]", .fn = isspace},
-                 {.name = ":alpha:]", .fn = isalpha},
-                 {.name = ":digit:]", .fn = isdigit},
-                 {.name = ":print:]", .fn = isprint},
-                 {.name = ":upper:]", .fn = isupper},
-                 {.name = ":blank:]", .fn = isblank},
-                 {.name = ":graph:]", .fn = isgraph},
-                 {.name = ":punct:]", .fn = ispunct},
-                 {.name = ":xdigit:]", .fn = isxdigit}};
-  const struct class *class, *end;
-  end = classes + sizeof(classes) / sizeof(classes[0]);
-  for (class = classes; class < end; class ++) {
-    const char *q;
-    q = prefix(p, class->name);
-    if (!q)
-      continue;
-    *r = q;
-    return class->fn(chr);
-  }
-  *r = 0;
-  return 0;
-}
-
-static int pmatch(const char *pattern, const char *string) {
-  const char *p, *q;
-  char c;
-  p = pattern;
-  q = string;
-  for (;;) {
-    switch (c = *p++) {
-      case '\0':
-        goto breakloop;
-      case '\\':
-        if (*p) {
-          c = *p++;
-        }
-        goto dft;
-      case '?':
-        if (*q++ == '\0')
-          return 0;
-        break;
-      case '*':
-        c = *p;
-        while (c == '*')
-          c = *++p;
-        if (c != '\\' && c != '?' && c != '*' && c != '[') {
-          while (*q != c) {
-            if (*q == '\0')
-              return 0;
-            q++;
-          }
-        }
-        do {
-          if (pmatch(p, q))
-            return 1;
-        } while (*q++ != '\0');
-        return 0;
-      case '[': {
-        const char *startp;
-        int invert, found;
-        char chr;
-        startp = p;
-        invert = 0;
-        if (*p == '!') {
-          invert++;
-          p++;
-        }
-        found = 0;
-        chr = *q;
-        if (chr == '\0')
-          return 0;
-        c = *p++;
-        do {
-          if (!c) {
-            p = startp;
-            c = '[';
-            goto dft;
-          }
-          if (c == '[') {
-            const char *r;
-            found |= !!ccmatch(p, chr, &r);
-            if (r) {
-              p = r;
-              continue;
-            }
-          } else if (c == '\\')
-            c = *p++;
-          if (*p == '-' && p[1] != ']') {
-            p++;
-            if (*p == '\\')
-              p++;
-            if (chr >= c && chr <= *p)
-              found = 1;
-            p++;
-          } else {
-            if (chr == c)
-              found = 1;
-          }
-        } while ((c = *p++) != ']');
-        if (found == invert)
-          return 0;
-        q++;
-        break;
-      }
-      dft:
-      default:
-        if (*q++ != c)
-          return 0;
-        break;
-    }
-  }
-breakloop:
-  if (*q != '\0')
-    return 0;
-  return 1;
-}
-
-/*
- * Remove any CTLESC characters from a string.
- */
-static char *rmescapes(char *str, int flag) {
-  char *p, *q, *r;
-  int notescaped;
-  int globbing;
-  p = strpbrk(str, qchars);
-  if (!p) {
-    return str;
-  }
-  q = p;
-  r = str;
-  if (flag & RMESCAPE_ALLOC) {
-    unsigned len = p - str;
-    unsigned fulllen = len + strlen(p) + 1;
-    if (flag & RMESCAPE_GROW) {
-      int strloc = str - (char *)stackblock();
-      r = makestrspace(fulllen, expdest);
-      str = (char *)stackblock() + strloc;
-      p = str + len;
-    } else if (flag & RMESCAPE_HEAP) {
-      r = ckmalloc(fulllen);
-    } else {
-      r = stalloc(fulllen);
-    }
-    q = r;
-    if (len > 0) {
-      q = mempcpy(q, str, len);
-    }
-  }
-  globbing = flag & RMESCAPE_GLOB;
-  notescaped = globbing;
-  while (*p) {
-    if (*p == (char)CTLQUOTEMARK) {
-      p++;
-      notescaped = globbing;
-      continue;
-    }
-    if (*p == '\\') {
-      /* naked back slash */
-      notescaped = 0;
-      goto copy;
-    }
-    if (*p == (char)CTLESC) {
-      p++;
-      if (notescaped)
-        *q++ = '\\';
-    }
-    notescaped = globbing;
-  copy:
-    *q++ = *p++;
-  }
-  *q = '\0';
-  if (flag & RMESCAPE_GROW) {
-    expdest = r;
-    STADJUST(q - r + 1, expdest);
-  }
-  return r;
-}
-
-/*
- * Our own itoa().
- */
-static unsigned cvtnum(int64_t num, int flags) {
-  int len = max_int_length(sizeof(num));
-  char buf[len];
-  len = fmtstr(buf, len, "%ld", num);
-  return memtodest(buf, len, flags);
-}
-
-static void freestrings(struct strpush *sp) {
-  INTOFF;
-  do {
-    struct strpush *psp;
-    if (sp->ap) {
-      sp->ap->flag &= ~ALIASINUSE;
-      if (sp->ap->flag & ALIASDEAD)
-        unalias(sp->ap->name);
-    }
-    psp = sp;
-    sp = sp->spfree;
-    if (psp != &(parsefile->basestrpush))
-      ckfree(psp);
-  } while (sp);
-  parsefile->spfree = NULL;
-  INTON;
-}
-
-static int pgetc_nofree(void) {
-  int c;
-  if (parsefile->unget)
-    return parsefile->lastc[--parsefile->unget];
-  if (--parsefile->nleft >= 0)
-    c = (signed char)*parsefile->nextc++;
-  else
-    c = preadbuffer();
-  parsefile->lastc[1] = parsefile->lastc[0];
-  parsefile->lastc[0] = c;
-  return c;
-}
-
-/*
- * Read a character from the script, returning PEOF on end of file.
- * Nul characters in the input are silently discarded.
- */
-int pgetc(void) {
-  struct strpush *sp = parsefile->spfree;
-  if (unlikely(sp))
-    freestrings(sp);
-  return pgetc_nofree();
-}
-
-static void AddUniqueCompletion(linenoiseCompletions *c, char *s) {
-  size_t i;
-  if (!s)
-    return;
-  for (i = 0; i < c->len; ++i) {
-    if (!strcmp(s, c->cvec[i])) {
-      return;
-    }
-  }
-  c->cvec = realloc(c->cvec, ++c->len * sizeof(*c->cvec));
-  c->cvec[c->len - 1] = s;
-}
-
-static void CompleteCommand(const char *p, const char *q, const char *b,
-                            linenoiseCompletions *c) {
-  DIR *d;
-  size_t i;
-  struct dirent *e;
-  const char *x, *y, *path;
-  struct tblentry **pp, *cmdp;
-  for (pp = cmdtable; pp < &cmdtable[CMDTABLESIZE]; pp++) {
-    for (cmdp = *pp; cmdp; cmdp = cmdp->next) {
-      if (cmdp->cmdtype >= 0 && !strncmp(cmdp->cmdname, p, q - p)) {
-        AddUniqueCompletion(c, strdup(cmdp->cmdname));
-      }
-    }
-  }
-  for (i = 0; i < ARRAYLEN(kBuiltinCmds); ++i) {
-    if (!strncmp(kBuiltinCmds[i].name, p, q - p)) {
-      AddUniqueCompletion(c, strdup(kBuiltinCmds[i].name));
-    }
-  }
-  for (y = x = lookupvar("PATH"); *y; x = y + 1) {
-    if ((path = strndup(x, (y = strchrnul(x, ':')) - x))) {
-      if ((d = opendir(path))) {
-        while ((e = readdir(d))) {
-          if (e->d_type == DT_REG && !strncmp(e->d_name, p, q - p)) {
-            AddUniqueCompletion(c, strdup(e->d_name));
-          }
-        }
-        closedir(d);
-      }
-      free((void *)path);
-    }
-  }
-}
-
-static void CompleteFilename(const char *p, const char *q, const char *b,
-                             linenoiseCompletions *c) {
-  DIR *d;
-  char *buf;
-  const char *g;
-  struct dirent *e;
-  if ((buf = malloc(512))) {
-    if ((g = memrchr(p, '/', q - p))) {
-      *(char *)mempcpy(buf, p, MIN(g - p, 511)) = 0;
-      p = ++g;
-    } else {
-      strcpy(buf, ".");
-    }
-    if ((d = opendir(buf))) {
-      while ((e = readdir(d))) {
-        if (!strcmp(e->d_name, "."))
-          continue;
-        if (!strcmp(e->d_name, ".."))
-          continue;
-        if (!strncmp(e->d_name, p, q - p)) {
-          snprintf(buf, 512, "%.*s%s%s", p - b, b, e->d_name,
-                   e->d_type == DT_DIR ? "/" : "");
-          AddUniqueCompletion(c, strdup(buf));
-        }
-      }
-      closedir(d);
-    }
-    free(buf);
-  }
-}
-
-static void ShellCompletion(const char *p, linenoiseCompletions *c) {
-  bool slashed;
-  const char *q, *b;
-  for (slashed = false, b = p, q = (p += strlen(p)); p > b; --p) {
-    if (p[-1] == '/' && p[-1] == '\\')
-      slashed = true;
-    if (!isalnum(p[-1]) &&
-        (p[-1] != '.' && p[-1] != '_' && p[-1] != '-' && p[-1] != '+' &&
-         p[-1] != '[' && p[-1] != '/' && p[-1] != '\\')) {
-      break;
-    }
-  }
-  if (b == p && !slashed) {
-    CompleteCommand(p, q, b, c);
-  } else {
-    CompleteFilename(p, q, b, c);
-  }
-}
-
-static char *ShellHint(const char *p, const char **ansi1, const char **ansi2) {
-  char *h = 0;
-  linenoiseCompletions c = {0};
-  ShellCompletion(p, &c);
-  if (c.len == 1) {
-    h = strdup(c.cvec[0] + strlen(p));
-  }
-  linenoiseFreeCompletions(&c);
-  return h;
-}
-
-static ssize_t preadfd(void) {
-  ssize_t nr;
-  char *p, *buf = parsefile->buf;
-  parsefile->nextc = buf;
-retry:
-  if (!parsefile->fd && isatty(0)) {
-    linenoiseSetFreeHintsCallback(free);
-    if (!IsWindows()) {
-      // TODO(jart): Cache $PATH search.
-      linenoiseSetHintsCallback(ShellHint);
-      linenoiseSetCompletionCallback(ShellCompletion);
-    }
-    char ps1[256];
-    snprintf(ps1, sizeof(ps1), "%d >: ", exitstatus);
-    if ((p = linenoiseWithHistory(ps1, "unbourne"))) {
-      nr = min(strlen(p), IBUFSIZ - 2);
-      memcpy(buf, p, nr);
-      buf[nr++] = '\n';
-      free(p);
-    } else {
-      write(1, "\n", 1);
-      nr = 0;
-    }
-  } else {
-    nr = read(parsefile->fd, buf, IBUFSIZ - 1);
-  }
-  if (nr < 0) {
-    if (errno == EINTR)
-      goto retry;
-    if (parsefile->fd == 0 && errno == EAGAIN) {
-      int flags = fcntl(0, F_GETFL, 0);
-      if (flags >= 0 && flags & O_NONBLOCK) {
-        flags &= ~O_NONBLOCK;
-        if (fcntl(0, F_SETFL, flags) >= 0) {
-          outstr("sh: turning off NDELAY mode\n", out2);
-          goto retry;
-        }
-      }
-    }
-  }
-  return nr;
-}
-
-/*
- * Refill the input buffer and return the next input character:
- *
- * 1) If a string was pushed back on the input, pop it;
- * 2) If an EOF was pushed back (parsenleft == EOF_NLEFT) or we are reading
- *    from a string so we can't refill the buffer, return EOF.
- * 3) If the is more stuff in this buffer, use it else call read to fill it.
- * 4) Process input up to the next newline, deleting nul characters.
- */
-static int preadbuffer(void) {
-  char *q;
-  int more;
-  char savec;
-  if (unlikely(parsefile->strpush)) {
-    popstring();
-    return pgetc_nofree();
-  }
-  if (unlikely(parsefile->nleft == EOF_NLEFT || parsefile->buf == NULL))
-    return PEOF;
-  flushall();
-  more = parsefile->lleft;
-  if (more <= 0) {
-  again:
-    if ((more = preadfd()) <= 0) {
-      parsefile->lleft = parsefile->nleft = EOF_NLEFT;
-      return PEOF;
-    }
-  }
-  q = parsefile->nextc;
-  /* delete nul characters */
-  for (;;) {
-    int c;
-    more--;
-    c = *q;
-    if (!c)
-      memmove(q, q + 1, more);
-    else {
-      q++;
-      if (c == '\n') {
-        parsefile->nleft = q - parsefile->nextc - 1;
-        break;
-      }
-    }
-    if (more <= 0) {
-      parsefile->nleft = q - parsefile->nextc - 1;
-      if (parsefile->nleft < 0)
-        goto again;
-      break;
-    }
-  }
-  parsefile->lleft = more;
-  savec = *q;
-  *q = '\0';
-  if (vflag) {
-    outstr(parsefile->nextc, out2);
-  }
-  *q = savec;
-  return (signed char)*parsefile->nextc++;
-}
-
-/*
- * Undo a call to pgetc.  Only two characters may be pushed back.
- * PEOF may be pushed back.
- */
-static void pungetc(void) {
-  parsefile->unget++;
-}
-
-/*
- * Push a string back onto the input at this current parsefile level.
- * We handle aliases this way.
- */
-static void pushstring(char *s, void *ap) {
-  struct strpush *sp;
-  unsigned len;
-  len = strlen(s);
-  INTOFF;
-  /*dprintf("*** calling pushstring: %s, %d\n", s, len);*/
-  if ((unsigned long)parsefile->strpush | (unsigned long)parsefile->spfree) {
-    sp = ckmalloc(sizeof(struct strpush));
-    sp->prev = parsefile->strpush;
-    parsefile->strpush = sp;
-  } else
-    sp = parsefile->strpush = &(parsefile->basestrpush);
-  sp->prevstring = parsefile->nextc;
-  sp->prevnleft = parsefile->nleft;
-  sp->unget = parsefile->unget;
-  sp->spfree = parsefile->spfree;
-  memcpy(sp->lastc, parsefile->lastc, sizeof(sp->lastc));
-  sp->ap = (struct alias *)ap;
-  if (ap) {
-    ((struct alias *)ap)->flag |= ALIASINUSE;
-    sp->string = s;
-  }
-  parsefile->nextc = s;
-  parsefile->nleft = len;
-  parsefile->unget = 0;
-  parsefile->spfree = NULL;
-  INTON;
-}
-
-static void popstring(void) {
-  struct strpush *sp = parsefile->strpush;
-  INTOFF;
-  if (sp->ap) {
-    if (parsefile->nextc[-1] == ' ' || parsefile->nextc[-1] == '\t') {
-      checkkwd |= CHKALIAS;
-    }
-    if (sp->string != sp->ap->val) {
-      ckfree(sp->string);
-    }
-  }
-  parsefile->nextc = sp->prevstring;
-  parsefile->nleft = sp->prevnleft;
-  parsefile->unget = sp->unget;
-  memcpy(parsefile->lastc, sp->lastc, sizeof(sp->lastc));
-  /*dprintf("*** calling popstring: restoring to '%s'\n", parsenextc);*/
-  parsefile->strpush = sp->prev;
-  parsefile->spfree = sp;
-  INTON;
-}
-
-/*
- * Set the input to take input from a file.  If push is set, push the
- * old input onto the stack first.
- */
-static int setinputfile(const char *fname, int flags) {
-  int fd;
-  INTOFF;
-  fd = sh_open(fname, O_RDONLY, flags & INPUT_NOFILE_OK);
-  if (fd < 0)
-    goto out;
-  if (fd < 10)
-    fd = savefd(fd, fd);
-  setinputfd(fd, flags & INPUT_PUSH_FILE);
-out:
-  INTON;
-  return fd;
-}
-
-/*
- * Like setinputfile, but takes an open file descriptor.  Call this with
- * interrupts off.
- */
-static void setinputfd(int fd, int push) {
-  if (push) {
-    pushfile();
-    parsefile->buf = 0;
-  }
-  parsefile->fd = fd;
-  if (parsefile->buf == NULL)
-    parsefile->buf = ckmalloc(IBUFSIZ);
-  parsefile->lleft = parsefile->nleft = 0;
-  plinno = 1;
-}
-
-/*
- * Like setinputfile, but takes input from a string.
- */
-static void setinputstring(char *string) {
-  INTOFF;
-  pushfile();
-  parsefile->nextc = string;
-  parsefile->nleft = strlen(string);
-  parsefile->buf = NULL;
-  plinno = 1;
-  INTON;
-}
-
-/*
- * To handle the "." command, a stack of input files is used.  Pushfile
- * adds a new entry to the stack and popfile restores the previous level.
- */
-static void pushfile(void) {
-  struct parsefile *pf;
-  pf = (struct parsefile *)ckmalloc(sizeof(struct parsefile));
-  pf->prev = parsefile;
-  pf->fd = -1;
-  pf->strpush = NULL;
-  pf->spfree = NULL;
-  pf->basestrpush.prev = NULL;
-  pf->unget = 0;
-  parsefile = pf;
-}
-
-static void popfile(void) {
-  struct parsefile *pf = parsefile;
-  INTOFF;
-  if (pf->fd >= 0)
-    close(pf->fd);
-  if (pf->buf)
-    ckfree(pf->buf);
-  if (parsefile->spfree)
-    freestrings(parsefile->spfree);
-  while (pf->strpush) {
-    popstring();
-    freestrings(parsefile->spfree);
-  }
-  parsefile = pf->prev;
-  ckfree(pf);
-  INTON;
-}
-
-static void unwindfiles(struct parsefile *stop) {
-  while (parsefile != stop)
-    popfile();
-}
-
-/*
- * Return to top level.
- */
-static void popallfiles(void) {
-  unwindfiles(&basepf);
-}
-
-static char *commandtext(union node *);
-static int dowait(int, struct job *);
-static int getstatus(struct job *);
-static int jobno(const struct job *);
-static int restartjob(struct job *, int);
-static int sprint_status(char *, int, int);
-static int waitproc(int, int *);
-static struct job *getjob(const char *, int);
-static struct job *growjobtab(void);
-static void cmdlist(union node *, int);
-static void cmdputs(const char *);
-static void cmdtxt(union node *);
-static void forkchild(struct job *, union node *, int);
-static void forkparent(struct job *, union node *, int, int);
-static void freejob(struct job *);
-static void set_curjob(struct job *, unsigned);
-static void showpipe(struct job *, struct output *);
-static void xtcsetpgrp(int, int);
-
-static void set_curjob(struct job *jp, unsigned mode) {
-  struct job *jp1;
-  struct job **jpp, **curp;
-  /* first remove from list */
-  jpp = curp = &curjob;
-  do {
-    jp1 = *jpp;
-    if (jp1 == jp)
-      break;
-    jpp = &jp1->prev_job;
-  } while (1);
-  *jpp = jp1->prev_job;
-  /* Then re-insert in correct position */
-  jpp = curp;
-  switch (mode) {
-    default:
-    case CUR_DELETE:
-      /* job being deleted */
-      break;
-    case CUR_RUNNING:
-      /* newly created job or backgrounded job,
-         put after all stopped jobs. */
-      do {
-        jp1 = *jpp;
-        if (!JOBS || !jp1 || jp1->state != JOBSTOPPED)
-          break;
-        jpp = &jp1->prev_job;
-      } while (1);
-      /* FALLTHROUGH */
-    case CUR_STOPPED:
-      /* newly stopped job - becomes curjob */
-      jp->prev_job = *jpp;
-      *jpp = jp;
-      break;
-  }
-}
-
-/*
- * Turn job control on and off.
- *
- * Note:  This code assumes that the third arg to ioctl is a character
- * pointer, which is true on Berkeley systems but not System V.  Since
- * System V doesn't have job control yet, this isn't a problem now.
- *
- * Called with interrupts off.
- */
-static void setjobctl(int on) {
-  int fd;
-  int pgrp;
-  if (IsWindows())
-    return; /* TODO(jart) */
-  if (on == jobctl || rootshell == 0)
-    return;
-  if (on) {
-    int ofd;
-    ofd = fd = sh_open(_PATH_TTY, O_RDWR, 1);
-    if (fd < 0) {
-      fd += 3;
-      while (!isatty(fd))
-        if (--fd < 0)
-          goto out;
-    }
-    fd = savefd(fd, ofd);
-    do { /* while we are in the background */
-      if ((pgrp = tcgetpgrp(fd)) < 0) {
-      out:
-        sh_warnx("can't access tty; job control turned off");
-        mflag = on = 0;
-        goto close;
-      }
-      if (pgrp == getpgrp())
-        break;
-      killpg(0, SIGTTIN);
-    } while (1);
-    initialpgrp = pgrp;
-    setsignal(SIGTSTP);
-    setsignal(SIGTTOU);
-    setsignal(SIGTTIN);
-    pgrp = rootpid;
-    setpgid(0, pgrp);
-    xtcsetpgrp(fd, pgrp);
-  } else {
-    /* turning job control off */
-    fd = ttyfd;
-    pgrp = initialpgrp;
-    xtcsetpgrp(fd, pgrp);
-    setpgid(0, pgrp);
-    setsignal(SIGTSTP);
-    setsignal(SIGTTOU);
-    setsignal(SIGTTIN);
-  close:
-    close(fd);
-    fd = -1;
-  }
-  ttyfd = fd;
-  jobctl = on;
-}
-
-static int decode_signum(const char *string) {
-  int signo = -1;
-  if (is_number(string)) {
-    signo = atoi(string);
-    if (signo >= NSIG)
-      signo = -1;
-  }
-  return signo;
-}
-
-static int killcmd(argc, argv)
-int argc;
-char **argv;
-{
-  int signo = -1;
-  int list = 0;
-  int i;
-  int pid;
-  struct job *jp;
-  if (argc <= 1) {
-  usage:
-    sh_error("Usage: kill [-s sigspec | -signum | -sigspec] [pid | job]... or\n"
-             "kill -l [exitstatus]");
-  }
-  if (**++argv == '-') {
-    signo = decode_signal(*argv + 1, 1);
-    if (signo < 0) {
-      int c;
-      while ((c = nextopt("ls:")) != '\0')
-        switch (c) {
-          default:
-          case 'l':
-            list = 1;
-            break;
-          case 's':
-            signo = decode_signal(optionarg, 1);
-            if (signo < 0) {
-              sh_error("invalid signal number or name: %s", optionarg);
-            }
-            break;
-        }
-      argv = argptr;
-    } else
-      argv++;
-  }
-  if (!list && signo < 0)
-    signo = SIGTERM;
-  if ((signo < 0 || !*argv) ^ list) {
-    goto usage;
-  }
-  if (list) {
-    struct output *out;
-    out = out1;
-    if (!*argv) {
-      outstr("0\n", out);
-      for (i = 1; i < NSIG; i++) {
-        outfmt(out, snlfmt, strsignal(i));
-      }
-      return 0;
-    }
-    signo = number(*argv);
-    if (signo > 128)
-      signo -= 128;
-    if (0 < signo && signo < NSIG)
-      outfmt(out, snlfmt, strsignal(signo));
-    else
-      sh_error("invalid signal number or exit status: %s", *argv);
-    return 0;
-  }
-  i = 0;
-  do {
-    if (**argv == '%') {
-      jp = getjob(*argv, 0);
-      pid = -jp->ps[0].pid;
-    } else
-      pid = **argv == '-' ? -number(*argv + 1) : number(*argv);
-    if (kill(pid, signo) != 0) {
-      sh_warnx("%s\n", strerror(errno));
-      i = 1;
-    }
-  } while (*++argv);
-  return i;
-}
-
-static int jobno(const struct job *jp) {
-  return jp - jobtab + 1;
-}
-
-static int fgcmd(int argc, char **argv) {
-  struct job *jp;
-  struct output *out;
-  int mode;
-  int retval;
-  mode = (**argv == 'f') ? FORK_FG : FORK_BG;
-  nextopt(nullstr);
-  argv = argptr;
-  out = out1;
-  do {
-    jp = getjob(*argv, 1);
-    if (mode == FORK_BG) {
-      set_curjob(jp, CUR_RUNNING);
-      outfmt(out, "[%d] ", jobno(jp));
-    }
-    outstr(jp->ps->cmd, out);
-    showpipe(jp, out);
-    retval = restartjob(jp, mode);
-  } while (*argv && *++argv);
-  return retval;
-}
-
-static int bgcmd(int argc, char **argv) __attribute__((__alias__("fgcmd")));
-
-static int restartjob(struct job *jp, int mode) {
-  struct procstat *ps;
-  int i;
-  int status;
-  int pgid;
-  INTOFF;
-  if (jp->state == JOBDONE)
-    goto out;
-  jp->state = JOBRUNNING;
-  pgid = jp->ps->pid;
-  if (mode == FORK_FG)
-    xtcsetpgrp(ttyfd, pgid);
-  killpg(pgid, SIGCONT);
-  ps = jp->ps;
-  i = jp->nprocs;
-  do {
-    if (WIFSTOPPED(ps->status)) {
-      ps->status = -1;
-    }
-  } while (ps++, --i);
-out:
-  status = (mode == FORK_FG) ? waitforjob(jp) : 0;
-  INTON;
-  return status;
-}
-
-static int sprint_status(char *os, int status, int sigonly) {
-  char *s = os;
-  int st;
-  st = WEXITSTATUS(status);
-  if (!WIFEXITED(status)) {
-    st = WSTOPSIG(status);
-    if (!WIFSTOPPED(status))
-      st = WTERMSIG(status);
-    if (sigonly) {
-      if (st == SIGINT || st == SIGPIPE)
-        goto out;
-      if (WIFSTOPPED(status))
-        goto out;
-    }
-    s = stpncpy(s, strsignal(st), 32);
-  } else if (!sigonly) {
-    if (st)
-      s += fmtstr(s, 16, "Done(%d)", st);
-    else
-      s = stpcpy(s, "Done");
-  }
-out:
-  return s - os;
-}
-
-static void showjob(struct output *out, struct job *jp, int mode) {
-  struct procstat *ps;
-  struct procstat *psend;
-  int col;
-  int indent;
-  char s[80];
-  ps = jp->ps;
-  if (mode & SHOW_PGID) {
-    /* just output process (group) id of pipeline */
-    outfmt(out, "%d\n", ps->pid);
-    return;
-  }
-  col = fmtstr(s, 16, "[%d]   ", jobno(jp));
-  indent = col;
-  if (jp == curjob)
-    s[col - 2] = '+';
-  else if (curjob && jp == curjob->prev_job)
-    s[col - 2] = '-';
-  if (mode & SHOW_PID)
-    col += fmtstr(s + col, 16, "%d ", ps->pid);
-  psend = ps + jp->nprocs;
-  if (jp->state == JOBRUNNING) {
-    scopy("Running", s + col);
-    col += strlen("Running");
-  } else {
-    int status = psend[-1].status;
-    if (jp->state == JOBSTOPPED)
-      status = jp->stopstatus;
-    col += sprint_status(s + col, status, 0);
-  }
-  goto start;
-  do {
-    /* for each process */
-    col = fmtstr(s, 48, " |\n%*c%d ", indent, ' ', ps->pid) - 3;
-  start:
-    outfmt(out, "%s%*c%s", s, 33 - col >= 0 ? 33 - col : 0, ' ', ps->cmd);
-    if (!(mode & SHOW_PID)) {
-      showpipe(jp, out);
-      break;
-    }
-    if (++ps == psend) {
-      outcslow('\n', out);
-      break;
-    }
-  } while (1);
-  jp->changed = 0;
-  if (jp->state == JOBDONE) {
-    TRACE(("showjob: freeing job %d\n", jobno(jp)));
-    freejob(jp);
-  }
-}
-
-static int jobscmd(int argc, char **argv) {
-  int mode, m;
-  struct output *out;
-  mode = 0;
-  while ((m = nextopt("lp")))
-    if (m == 'l')
-      mode = SHOW_PID;
-    else
-      mode = SHOW_PGID;
-  out = out1;
-  argv = argptr;
-  if (*argv)
-    do
-      showjob(out, getjob(*argv, 0), mode);
-    while (*++argv);
-  else
-    showjobs(out, mode);
-  return 0;
-}
-
-/*
- * Print a list of jobs.  If "change" is nonzero, only print jobs whose
- * statuses have changed since the last call to showjobs.
- */
-static void showjobs(struct output *out, int mode) {
-  struct job *jp;
-  TRACE(("showjobs(%x) called\n", mode));
-  /* If not even one job changed, there is nothing to do */
-  dowait(DOWAIT_NONBLOCK, NULL);
-  for (jp = curjob; jp; jp = jp->prev_job) {
-    if (!(mode & SHOW_CHANGED) || jp->changed)
-      showjob(out, jp, mode);
-  }
-}
-
-/*
- * Mark a job structure as unused.
- */
-static void freejob(struct job *jp) {
-  struct procstat *ps;
-  int i;
-  INTOFF;
-  for (i = jp->nprocs, ps = jp->ps; --i >= 0; ps++) {
-    if (ps->cmd != nullstr)
-      ckfree(ps->cmd);
-  }
-  if (jp->ps != &jp->ps0)
-    ckfree(jp->ps);
-  jp->used = 0;
-  set_curjob(jp, CUR_DELETE);
-  INTON;
-}
-
-static int waitcmd(int argc, char **argv) {
-  struct job *job;
-  int retval;
-  struct job *jp;
-  nextopt(nullstr);
-  retval = 0;
-  argv = argptr;
-  if (!*argv) {
-    /* wait for all jobs */
-    for (;;) {
-      jp = curjob;
-      while (1) {
-        if (!jp) {
-          /* no running procs */
-          goto out;
-        }
-        if (jp->state == JOBRUNNING)
-          break;
-        jp->waited = 1;
-        jp = jp->prev_job;
-      }
-      if (!dowait(DOWAIT_WAITCMD_ALL, 0))
-        goto sigout;
-    }
-  }
-  retval = 127;
-  do {
-    if (**argv != '%') {
-      int pid = number(*argv);
-      job = curjob;
-      goto start;
-      do {
-        if (job->ps[job->nprocs - 1].pid == pid)
-          break;
-        job = job->prev_job;
-      start:
-        if (!job)
-          goto repeat;
-      } while (1);
-    } else
-      job = getjob(*argv, 0);
-    /* loop until process terminated or stopped */
-    if (!dowait(DOWAIT_WAITCMD, job))
-      goto sigout;
-    job->waited = 1;
-    retval = getstatus(job);
-  repeat:;
-  } while (*++argv);
-out:
-  return retval;
-sigout:
-  retval = 128 + pending_sig;
-  goto out;
-}
-
-/*
- * Convert a job name to a job structure.
- */
-static struct job *getjob(const char *name, int getctl) {
-  struct job *jp;
-  struct job *found;
-  const char *err_msg = "No such job: %s";
-  unsigned num;
-  int c;
-  const char *p;
-  char *(*match)(const char *, const char *);
-  jp = curjob;
-  p = name;
-  if (!p)
-    goto currentjob;
-  if (*p != '%')
-    goto err;
-  c = *++p;
-  if (!c)
-    goto currentjob;
-  if (!p[1]) {
-    if (c == '+' || c == '%') {
-    currentjob:
-      err_msg = "No current job";
-      goto check;
-    } else if (c == '-') {
-      if (jp)
-        jp = jp->prev_job;
-      err_msg = "No previous job";
-    check:
-      if (!jp)
-        goto err;
-      goto gotit;
-    }
-  }
-  if (is_number(p)) {
-    num = atoi(p);
-    if (num > 0 && num <= njobs) {
-      jp = jobtab + num - 1;
-      if (jp->used)
-        goto gotit;
-      goto err;
-    }
-  }
-  match = prefix;
-  if (*p == '?') {
-    match = strstr;
-    p++;
-  }
-  found = 0;
-  while (jp) {
-    if (match(jp->ps[0].cmd, p)) {
-      if (found)
-        goto err;
-      found = jp;
-      err_msg = "%s: ambiguous";
-    }
-    jp = jp->prev_job;
-  }
-  if (!found)
-    goto err;
-  jp = found;
-gotit:
-  err_msg = "job %s not created under job control";
-  if (getctl && jp->jobctl == 0)
-    goto err;
-  return jp;
-err:
-  sh_error(err_msg, name);
-}
-
-/*
- * Return a new job structure.
- * Called with interrupts off.
- */
-struct job *makejob(union node *node, int nprocs) {
-  int i;
-  struct job *jp;
-  for (i = njobs, jp = jobtab;; jp++) {
-    if (--i < 0) {
-      jp = growjobtab();
-      break;
-    }
-    if (jp->used == 0)
-      break;
-    if (jp->state != JOBDONE || !jp->waited)
-      continue;
-    if (jobctl)
-      continue;
-    freejob(jp);
-    break;
-  }
-  memset(jp, 0, sizeof(*jp));
-  if (jobctl)
-    jp->jobctl = 1;
-  jp->prev_job = curjob;
-  curjob = jp;
-  jp->used = 1;
-  jp->ps = &jp->ps0;
-  if (nprocs > 1) {
-    jp->ps = ckmalloc(nprocs * sizeof(struct procstat));
-  }
-  TRACE(("makejob(0x%lx, %d) returns %%%d\n", (long)node, nprocs, jobno(jp)));
-  return jp;
-}
-
-#if defined(__GNUC__) && __GNUC__ >= 12
-#pragma GCC diagnostic ignored "-Wuse-after-free"
-#endif
-
-static struct job *growjobtab(void) {
-  unsigned len;
-  long offset;
-  struct job *jp, *jq;
-  len = njobs * sizeof(*jp);
-  jq = jobtab;
-  jp = ckrealloc(jq, len + 4 * sizeof(*jp));
-  offset = (char *)jp - (char *)jq;
-  if (offset) {
-    /* Relocate pointers */
-    unsigned l = len;
-    jq = (struct job *)((char *)jq + l);
-    while (l) {
-      l -= sizeof(*jp);
-      jq--;
-#define joff(p)  ((struct job *)((char *)(p) + l))
-#define jmove(p) (p) = (void *)((char *)(p) + offset)
-      if (likely(joff(jp)->ps == &jq->ps0))
-        jmove(joff(jp)->ps);
-      if (joff(jp)->prev_job)
-        jmove(joff(jp)->prev_job);
-    }
-    if (curjob)
-      jmove(curjob);
-#undef joff
-#undef jmove
-  }
-  njobs += 4;
-  jobtab = jp;
-  jp = (struct job *)((char *)jp + len);
-  jq = jp + 3;
-  do {
-    jq->used = 0;
-  } while (--jq >= jp);
-  return jp;
-}
-
-/*
- * Fork off a subshell.  If we are doing job control, give the subshell its
- * own process group.  Jp is a job structure that the job is to be added to.
- * N is the command that will be evaluated by the child.  Both jp and n may
- * be NULL.  The mode parameter can be one of the following:
- *  FORK_FG - Fork off a foreground process.
- *  FORK_BG - Fork off a background process.
- *  FORK_NOJOB - Like FORK_FG, but don't give the process its own
- *               process group even if job control is on.
- *
- * When job control is turned off, background processes have their standard
- * input redirected to /dev/null (except for the second and later processes
- * in a pipeline).
- *
- * Called with interrupts off.
- */
-static void forkchild(struct job *jp, union node *n, int mode) {
-  int lvforked;
-  int oldlvl;
-  TRACE(("Child shell %d\n", getpid()));
-  oldlvl = shlvl;
-  lvforked = vforked;
-  if (!lvforked) {
-    shlvl++;
-    forkreset();
-    /* do job control only in root shell */
-    jobctl = 0;
-  }
-  if (mode != FORK_NOJOB && jp->jobctl && !oldlvl) {
-    int pgrp;
-    if (jp->nprocs == 0)
-      pgrp = getpid();
-    else
-      pgrp = jp->ps[0].pid;
-    /* This can fail because we are doing it in the parent also */
-    (void)setpgid(0, pgrp);
-    if (mode == FORK_FG)
-      xtcsetpgrp(ttyfd, pgrp);
-    setsignal(SIGTSTP);
-    setsignal(SIGTTOU);
-  } else if (mode == FORK_BG) {
-    ignoresig(SIGINT);
-    ignoresig(SIGQUIT);
-    if (jp->nprocs == 0) {
-      close(0);
-      sh_open(_PATH_DEVNULL, O_RDONLY, 0);
-    }
-  }
-  if (!oldlvl && iflag) {
-    setsignal(SIGINT);
-    setsignal(SIGQUIT);
-    setsignal(SIGTERM);
-  }
-  if (lvforked)
-    return;
-  for (jp = curjob; jp; jp = jp->prev_job)
-    freejob(jp);
-}
-
-static void forkparent(struct job *jp, union node *n, int mode, int pid) {
-  if (pid < 0) {
-    TRACE(("Fork failed, errno=%d", errno));
-    if (jp)
-      freejob(jp);
-    sh_error("Cannot fork");
-    __builtin_unreachable();
-  }
-  TRACE(("In parent shell:  child = %d\n", pid));
-  if (!jp)
-    return;
-  if (mode != FORK_NOJOB && jp->jobctl) {
-    int pgrp;
-    if (jp->nprocs == 0)
-      pgrp = pid;
-    else
-      pgrp = jp->ps[0].pid;
-    /* This can fail because we are doing it in the child also */
-    (void)setpgid(pid, pgrp);
-  }
-  if (mode == FORK_BG) {
-    backgndpid = pid; /* set $! */
-    set_curjob(jp, CUR_RUNNING);
-  }
-  if (jp) {
-    struct procstat *ps = &jp->ps[jp->nprocs++];
-    ps->pid = pid;
-    ps->status = -1;
-    ps->cmd = nullstr;
-    if (jobctl && n)
-      ps->cmd = commandtext(n);
-  }
-}
-
-static int forkshell(struct job *jp, union node *n, int mode) {
-  int pid;
-  TRACE(("forkshell(%%%d, %p, %d) called\n", jobno(jp), n, mode));
-  pid = fork();
-  if (pid == 0) {
-    forkchild(jp, n, mode);
-  } else {
-    forkparent(jp, n, mode, pid);
-  }
-  return pid;
-}
-
-static struct job *vforkexec(union node *n, char **argv, const char *path,
-                             int idx) {
-  struct job *jp;
-  int pid;
-  jp = makejob(n, 1);
-  sigblockall(NULL);
-  vforked++;
-  pid = vfork();
-  if (!pid) {
-    forkchild(jp, n, FORK_FG);
-    sigclearmask();
-    shellexec(argv, path, idx);
-    __builtin_unreachable();
-  }
-  vforked = 0;
-  sigclearmask();
-  forkparent(jp, n, FORK_FG, pid);
-  return jp;
-}
-
-/*
- * Wait for job to finish.
- *
- * Under job control we have the problem that while a child process is
- * running interrupts generated by the user are sent to the child but not
- * to the shell.  This means that an infinite loop started by an inter-
- * active user may be hard to kill.  With job control turned off, an
- * interactive user may place an interactive program inside a loop.  If
- * the interactive program catches interrupts, the user doesn't want
- * these interrupts to also abort the loop.  The approach we take here
- * is to have the shell ignore interrupt signals while waiting for a
- * foreground process to terminate, and then send itself an interrupt
- * signal if the child process was terminated by an interrupt signal.
- * Unfortunately, some programs want to do a bit of cleanup and then
- * exit on interrupt; unless these processes terminate themselves by
- * sending a signal to themselves (instead of calling exit) they will
- * confuse this approach.
- *
- * Called with interrupts off.
- */
-static int waitforjob(struct job *jp) {
-  int st;
-  TRACE(("waitforjob(%%%d) called\n", jp ? jobno(jp) : 0));
-  dowait(jp ? DOWAIT_BLOCK : DOWAIT_NONBLOCK, jp);
-  if (!jp)
-    return exitstatus;
-  st = getstatus(jp);
-  if (jp->jobctl) {
-    xtcsetpgrp(ttyfd, rootpid);
-    /*
-     * This is truly gross.
-     * If we're doing job control, then we did a TIOCSPGRP which
-     * caused us (the shell) to no longer be in the controlling
-     * session -- so we wouldn't have seen any ^C/SIGINT.  So, we
-     * intuit from the subprocess exit status whether a SIGINT
-     * occurred, and if so interrupt ourselves.  Yuck.  - mycroft
-     */
-    if (jp->sigint)
-      raise(SIGINT);
-  }
-  if (!JOBS || jp->state == JOBDONE)
-    freejob(jp);
-  return st;
-}
-
-/*
- * Wait for a process to terminate.
- */
-static int waitone(int block, struct job *job) {
-  int pid;
-  int status;
-  struct job *jp;
-  struct job *thisjob = NULL;
-  int state;
-  INTOFF;
-  TRACE(("dowait(%d) called\n", block));
-  pid = waitproc(block, &status);
-  TRACE(("wait returns pid %d, status=%d\n", pid, status));
-  if (pid <= 0)
-    goto out;
-  for (jp = curjob; jp; jp = jp->prev_job) {
-    struct procstat *sp;
-    struct procstat *spend;
-    if (jp->state == JOBDONE)
-      continue;
-    state = JOBDONE;
-    spend = jp->ps + jp->nprocs;
-    sp = jp->ps;
-    do {
-      if (sp->pid == pid) {
-        TRACE(("Job %d: changing status of proc %d from 0x%x to 0x%x\n",
-               jobno(jp), pid, sp->status, status));
-        sp->status = status;
-        thisjob = jp;
-      }
-      if (sp->status == -1)
-        state = JOBRUNNING;
-      if (state == JOBRUNNING)
-        continue;
-      if (WIFSTOPPED(sp->status)) {
-        jp->stopstatus = sp->status;
-        state = JOBSTOPPED;
-      }
-    } while (++sp < spend);
-    if (thisjob)
-      goto gotjob;
-  }
-  goto out;
-gotjob:
-  if (state != JOBRUNNING) {
-    thisjob->changed = 1;
-    if (thisjob->state != state) {
-      TRACE(("Job %d: changing state from %d to %d\n", jobno(thisjob),
-             thisjob->state, state));
-      thisjob->state = state;
-      if (state == JOBSTOPPED) {
-        set_curjob(thisjob, CUR_STOPPED);
-      }
-    }
-  }
-out:
-  INTON;
-  if (thisjob && thisjob == job) {
-    char s[48 + 1];
-    int len;
-    len = sprint_status(s, status, 1);
-    if (len) {
-      s[len] = '\n';
-      s[len + 1] = 0;
-      outstr(s, out2);
-    }
-  }
-  return pid;
-}
-
-static int dowait(int block, struct job *jp) {
-  int gotchld = *(volatile int *)&gotsigchld;
-  int rpid;
-  int pid;
-  if (jp && jp->state != JOBRUNNING)
-    block = DOWAIT_NONBLOCK;
-  if (block == DOWAIT_NONBLOCK && !gotchld)
-    return 1;
-  rpid = 1;
-  do {
-    pid = waitone(block, jp);
-    rpid &= !!pid;
-    block &= ~DOWAIT_WAITCMD_ALL;
-    if (!pid || (jp && jp->state != JOBRUNNING))
-      block = DOWAIT_NONBLOCK;
-  } while (pid >= 0);
-  return rpid;
-}
-
-/*
- * Do a wait system call.  If block is zero, we return -1 rather than
- * blocking.  If block is DOWAIT_WAITCMD, we return 0 when a signal
- * other than SIGCHLD interrupted the wait.
- *
- * We use sigsuspend in conjunction with a non-blocking wait3 in
- * order to ensure that waitcmd exits promptly upon the reception
- * of a signal.
- *
- * For code paths other than waitcmd we either use a blocking wait3
- * or a non-blocking wait3.  For the latter case the caller of dowait
- * must ensure that it is called over and over again until all dead
- * children have been reaped.  Otherwise zombies may linger.
- */
-static int waitproc(int block, int *status) {
-  sigset_t oldmask;
-  int flags = block == DOWAIT_BLOCK ? 0 : WNOHANG;
-  int err;
-  if (jobctl)
-    flags |= WUNTRACED;
-  do {
-    gotsigchld = 0;
-    do
-      err = wait3(status, flags, NULL);
-    while (err < 0 && errno == EINTR);
-    if (err || (err = -!block))
-      break;
-    sigblockall(&oldmask);
-    while (!gotsigchld && !pending_sig)
-      sigsuspend(&oldmask);
-    sigclearmask();
-  } while (gotsigchld);
-  return err;
-}
-
-/*
- * return 1 if there are stopped jobs, otherwise 0
- */
-static int stoppedjobs(void) {
-  struct job *jp;
-  int retval;
-  retval = 0;
-  if (job_warning)
-    goto out;
-  jp = curjob;
-  if (jp && jp->state == JOBSTOPPED) {
-    outstr("You have stopped jobs.\n", out2);
-    job_warning = 2;
-    retval++;
-  }
-out:
-  return retval;
-}
-
-/*
- * Return a string identifying a command (to be printed by the
- * jobs command).
- */
-static char *commandtext(union node *n) {
-  char *name;
-  STARTSTACKSTR(cmdnextc);
-  cmdtxt(n);
-  name = stackblock();
-  TRACE(("commandtext: name %p, end %p\n", name, cmdnextc));
-  return savestr(name);
-}
-
-static void cmdtxt(union node *n) {
-  union node *np;
-  struct nodelist *lp;
-  const char *p;
-  char s[2];
-  if (!n)
-    return;
-  switch (n->type) {
-    default:
-    case NPIPE:
-      lp = n->npipe.cmdlist;
-      for (;;) {
-        cmdtxt(lp->n);
-        lp = lp->next;
-        if (!lp)
-          break;
-        cmdputs(" | ");
-      }
-      break;
-    case NSEMI:
-      p = "; ";
-      goto binop;
-    case NAND:
-      p = " && ";
-      goto binop;
-    case NOR:
-      p = " || ";
-    binop:
-      cmdtxt(n->nbinary.ch1);
-      cmdputs(p);
-      n = n->nbinary.ch2;
-      goto donode;
-    case NREDIR:
-    case NBACKGND:
-      n = n->nredir.n;
-      goto donode;
-    case NNOT:
-      cmdputs("!");
-      n = n->nnot.com;
-    donode:
-      cmdtxt(n);
-      break;
-    case NIF:
-      cmdputs("if ");
-      cmdtxt(n->nif.test);
-      cmdputs("; then ");
-      if (n->nif.elsepart) {
-        cmdtxt(n->nif.ifpart);
-        cmdputs("; else ");
-        n = n->nif.elsepart;
-      } else {
-        n = n->nif.ifpart;
-      }
-      p = "; fi";
-      goto dotail;
-    case NSUBSHELL:
-      cmdputs("(");
-      n = n->nredir.n;
-      p = ")";
-      goto dotail;
-    case NWHILE:
-      p = "while ";
-      goto until;
-    case NUNTIL:
-      p = "until ";
-    until:
-      cmdputs(p);
-      cmdtxt(n->nbinary.ch1);
-      n = n->nbinary.ch2;
-      p = "; done";
-    dodo:
-      cmdputs("; do ");
-    dotail:
-      cmdtxt(n);
-      goto dotail2;
-    case NFOR:
-      cmdputs("for ");
-      cmdputs(n->nfor.var_);
-      cmdputs(" in ");
-      cmdlist(n->nfor.args, 1);
-      n = n->nfor.body;
-      p = "; done";
-      goto dodo;
-    case NDEFUN:
-      cmdputs(n->ndefun.text);
-      p = "() { ... }";
-      goto dotail2;
-    case NCMD:
-      cmdlist(n->ncmd.args, 1);
-      cmdlist(n->ncmd.redirect, 0);
-      break;
-    case NARG:
-      p = n->narg.text;
-    dotail2:
-      cmdputs(p);
-      break;
-    case NHERE:
-    case NXHERE:
-      p = "<<...";
-      goto dotail2;
-    case NCASE:
-      cmdputs("case ");
-      cmdputs(n->ncase.expr->narg.text);
-      cmdputs(" in ");
-      for (np = n->ncase.cases; np; np = np->nclist.next) {
-        cmdtxt(np->nclist.pattern);
-        cmdputs(") ");
-        cmdtxt(np->nclist.body);
-        cmdputs(";; ");
-      }
-      p = "esac";
-      goto dotail2;
-    case NTO:
-      p = ">";
-      goto redir;
-    case NCLOBBER:
-      p = ">|";
-      goto redir;
-    case NAPPEND:
-      p = ">>";
-      goto redir;
-    case NTOFD:
-      p = ">&";
-      goto redir;
-    case NFROM:
-      p = "<";
-      goto redir;
-    case NFROMFD:
-      p = "<&";
-      goto redir;
-    case NFROMTO:
-      p = "<>";
-    redir:
-      s[0] = n->nfile.fd + '0';
-      s[1] = '\0';
-      cmdputs(s);
-      cmdputs(p);
-      if (n->type == NTOFD || n->type == NFROMFD) {
-        s[0] = n->ndup.dupfd + '0';
-        p = s;
-        goto dotail2;
-      } else {
-        n = n->nfile.fname;
-        goto donode;
-      }
-  }
-}
-
-static void cmdlist(union node *np, int sep) {
-  for (; np; np = np->narg.next) {
-    if (!sep)
-      cmdputs(spcstr);
-    cmdtxt(np);
-    if (sep && np->narg.next)
-      cmdputs(spcstr);
-  }
-}
-
-static void cmdputs(const char *s) {
-  const char *p, *str;
-  char cc[2] = " ";
-  char *nextc;
-  signed char c;
-  int subtype = 0;
-  int quoted = 0;
-  static const char vstype[VSTYPE + 1][4] = {
-      "", "}", "-", "+", "?", "=", "%", "%%", "#", "##",
-  };
-  nextc = makestrspace((strlen(s) + 1) * 8, cmdnextc);
-  p = s;
-  while ((c = *p++) != 0) {
-    str = 0;
-    switch (c) {
-      case CTLESC:
-        c = *p++;
-        break;
-      case CTLVAR:
-        subtype = *p++;
-        if ((subtype & VSTYPE) == VSLENGTH)
-          str = "${#";
-        else
-          str = "${";
-        goto dostr;
-      case CTLENDVAR:
-        str = &"\"}"[!quoted];
-        quoted >>= 1;
-        subtype = 0;
-        goto dostr;
-      case CTLBACKQ:
-        str = "$(...)";
-        goto dostr;
-      case CTLARI:
-        str = "$((";
-        goto dostr;
-      case CTLENDARI:
-        str = "))";
-        goto dostr;
-      case CTLQUOTEMARK:
-        quoted ^= 1;
-        c = '"';
-        break;
-      case '=':
-        if (subtype == 0)
-          break;
-        if ((subtype & VSTYPE) != VSNORMAL)
-          quoted <<= 1;
-        str = vstype[subtype & VSTYPE];
-        if (subtype & VSNUL)
-          c = ':';
-        else
-          goto checkstr;
-        break;
-      case '\'':
-      case '\\':
-      case '"':
-      case '$':
-        /* These can only happen inside quotes */
-        cc[0] = c;
-        str = cc;
-        c = '\\';
-        break;
-      default:
-        break;
-    }
-    USTPUTC(c, nextc);
-  checkstr:
-    if (!str)
-      continue;
-  dostr:
-    while ((c = *str++)) {
-      USTPUTC(c, nextc);
-    }
-  }
-  if (quoted & 1) {
-    USTPUTC('"', nextc);
-  }
-  *nextc = 0;
-  cmdnextc = nextc;
-}
-
-static void showpipe(struct job *jp, struct output *out) {
-  struct procstat *sp;
-  struct procstat *spend;
-  spend = jp->ps + jp->nprocs;
-  for (sp = jp->ps + 1; sp < spend; sp++)
-    outfmt(out, " | %s", sp->cmd);
-  outcslow('\n', out);
-  flushall();
-}
-
-static void xtcsetpgrp(int fd, int pgrp) {
-  int err;
-  sigblockall(NULL);
-  err = tcsetpgrp(fd, pgrp);
-  sigclearmask();
-  if (err)
-    sh_error("Cannot set tty process group (%s)", strerror(errno));
-}
-
-static int getstatus(struct job *job) {
-  int status;
-  int retval;
-  status = job->ps[job->nprocs - 1].status;
-  retval = WEXITSTATUS(status);
-  if (!WIFEXITED(status)) {
-    retval = WSTOPSIG(status);
-    if (!WIFSTOPPED(status)) {
-      /* XXX: limits number of signals */
-      retval = WTERMSIG(status);
-      if (retval == SIGINT)
-        job->sigint = 1;
-    }
-    retval += 128;
-  }
-  TRACE(("getstatus: job %d, nproc %d, status %x, retval %x\n", jobno(job),
-         job->nprocs, status, retval));
-  return retval;
-}
-
-/** handle one line of the read command.
- *  more fields than variables -> remainder shall be part of last variable.
- *  less fields than variables -> remaining variables unset.
- *
- *  @param line complete line of input
- *  @param ac argument count
- *  @param ap argument (variable) list
- *  @param len length of line including trailing '\0'
- */
-static void readcmd_handle_line(char *s, int ac, char **ap) {
-  struct arglist arglist;
-  struct strlist *sl;
-  s = grabstackstr(s);
-  arglist.lastp = &arglist.list;
-  ifsbreakup(s, ac, &arglist);
-  *arglist.lastp = NULL;
-  ifsfree();
-  sl = arglist.list;
-  do {
-    if (!sl) {
-      /* nullify remaining arguments */
-      do {
-        setvar(*ap, nullstr, 0);
-      } while (*++ap);
-      return;
-    }
-    /* set variable to field */
-    rmescapes(sl->text, 0);
-    setvar(*ap, sl->text, 0);
-    sl = sl->next;
-  } while (*++ap);
-}
-
-/*
- * The read builtin.  The -e option causes backslashes to escape the
- * following character. The -p option followed by an argument prompts
- * with the argument.
- *
- * This uses unbuffered input, which may be avoidable in some cases.
- */
-static int readcmd(int argc, char **argv) {
-  char **ap;
-  char c;
-  int rflag;
-  char *prompt;
-  char *p;
-  int startloc;
-  int newloc;
-  int status;
-  int i;
-  rflag = 0;
-  prompt = NULL;
-  while ((i = nextopt("p:r")) != '\0') {
-    if (i == 'p')
-      prompt = optionarg;
-    else
-      rflag = 1;
-  }
-  if (prompt && isatty(0)) {
-    outstr(prompt, out2);
-  }
-  if (!*(ap = argptr))
-    sh_error("arg count");
-  status = 0;
-  STARTSTACKSTR(p);
-  goto start;
-  for (;;) {
-    switch (read(0, &c, 1)) {
-      case 1:
-        break;
-      default:
-        if (errno == EINTR && !pending_sig)
-          continue;
-        /* fall through */
-      case 0:
-        status = 1;
-        goto out;
-    }
-    if (!c)
-      continue;
-    if (newloc >= startloc) {
-      if (c == '\n')
-        goto resetbs;
-      goto put;
-    }
-    if (!rflag && c == '\\') {
-      newloc = p - (char *)stackblock();
-      continue;
-    }
-    if (c == '\n')
-      break;
-  put:
-    CHECKSTRSPACE(2, p);
-    if (strchr(qchars, c))
-      USTPUTC(CTLESC, p);
-    USTPUTC(c, p);
-    if (newloc >= startloc) {
-    resetbs:
-      recordregion(startloc, newloc, 0);
-    start:
-      startloc = p - (char *)stackblock();
-      newloc = startloc - 1;
-    }
-  }
-out:
-  recordregion(startloc, p - (char *)stackblock(), 0);
-  STACKSTRNUL(p);
-  readcmd_handle_line(p + 1, argc - (ap - argv), ap);
-  return status;
-}
-
-/*───────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell » builtins » umask                     ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│─╝
-  This code was ripped from pdksh 5.2.14 and hacked for use with
-  dash by Herbert Xu. Public Domain. */
-
-static int umaskcmd(int argc, char **argv) {
-  char *ap;
-  int mask;
-  int i;
-  int symbolic_mode = 0;
-  while ((i = nextopt("S")) != '\0') {
-    symbolic_mode = 1;
-  }
-  INTOFF;
-  mask = umask(0);
-  umask(mask);
-  INTON;
-  if ((ap = *argptr) == NULL) {
-    if (symbolic_mode) {
-      char buf[18];
-      int j;
-      mask = ~mask;
-      ap = buf;
-      for (i = 0; i < 3; i++) {
-        *ap++ = "ugo"[i];
-        *ap++ = '=';
-        for (j = 0; j < 3; j++)
-          if (mask & (1u << (8 - (3 * i + j))))
-            *ap++ = "rwx"[j];
-        *ap++ = ',';
-      }
-      ap[-1] = '\0';
-      out1fmt("%s\n", buf);
-    } else {
-      out1fmt("%.4o\n", mask);
-    }
-  } else {
-    int new_mask;
-    if (isdigit((unsigned char)*ap)) {
-      new_mask = 0;
-      do {
-        if (*ap >= '8' || *ap < '0')
-          sh_error(illnum, *argptr);
-        new_mask = (new_mask << 3) + (*ap - '0');
-      } while (*++ap != '\0');
-    } else {
-      int positions, new_val;
-      char op;
-      mask = ~mask;
-      new_mask = mask;
-      positions = 0;
-      while (*ap) {
-        while (*ap && strchr("augo", *ap))
-          switch (*ap++) {
-            case 'a':
-              positions |= 0111;
-              break;
-            case 'u':
-              positions |= 0100;
-              break;
-            case 'g':
-              positions |= 0010;
-              break;
-            case 'o':
-              positions |= 0001;
-              break;
-          }
-        if (!positions)
-          positions = 0111; /* default is a */
-        if (!strchr("=+-", op = *ap))
-          break;
-        ap++;
-        new_val = 0;
-        while (*ap && strchr("rwxugoXs", *ap))
-          switch (*ap++) {
-            case 'r':
-              new_val |= 04;
-              break;
-            case 'w':
-              new_val |= 02;
-              break;
-            case 'x':
-              new_val |= 01;
-              break;
-            case 'u':
-              new_val |= mask >> 6;
-              break;
-            case 'g':
-              new_val |= mask >> 3;
-              break;
-            case 'o':
-              new_val |= mask >> 0;
-              break;
-            case 'X':
-              if (mask & 0111)
-                new_val |= 01;
-              break;
-            case 's': /* ignored */
-              break;
-          }
-        new_val = (new_val & 07) * positions;
-        switch (op) {
-          case '-':
-            new_mask &= ~new_val;
-            break;
-          case '=':
-            new_mask = new_val | (new_mask & ~(positions * 07));
-            break;
-          case '+':
-            new_mask |= new_val;
-        }
-        if (*ap == ',') {
-          positions = 0;
-          ap++;
-        } else if (!strchr("=+-", *ap))
-          break;
-      }
-      if (*ap) {
-        sh_error("Illegal mode: %s", *argptr);
-        return 1;
-      }
-      new_mask = ~new_mask;
-    }
-    umask(new_mask);
-  }
-  return 0;
-}
-
-/*───────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § the unbourne shell » builtins » ulimit                    ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│─╝
-  This code, originally by Doug Gwyn, Doug Kingston, Eric Gisin, and
-  Michael Rendell was ripped from pdksh 5.0.8 and hacked for use with
-  ash by J.T. Conklin. Public Domain. */
-
-enum limtype { SOFT = 0x1, HARD = 0x2 };
-
-static void printlim(enum limtype how, const struct rlimit *limit,
-                     const struct limits *l) {
-  uint64_t val;
-  val = limit->rlim_max;
-  if (how & SOFT)
-    val = limit->rlim_cur;
-  if (val == RLIM_INFINITY)
-    out1fmt("unlimited\n");
-  else {
-    val /= l->factor;
-    out1fmt("%ld\n", (int64_t)val);
-  }
-}
-
-static int ulimitcmd(int argc, char **argv) {
-  static const struct limits limits[] = {{(char *)0, 0, 0, '\0'}};
-  int c;
-  uint64_t val = 0;
-  enum limtype how = SOFT | HARD;
-  const struct limits *l;
-  int set, all = 0;
-  int optc, what;
-  struct rlimit limit;
-  what = 'f';
-  while ((optc = nextopt("HSa")) != '\0') {
-    switch (optc) {
-      case 'H':
-        how = HARD;
-        break;
-      case 'S':
-        how = SOFT;
-        break;
-      case 'a':
-        all = 1;
-        break;
-      default:
-        what = optc;
-    }
-  }
-  for (l = limits; l->option != what; l++)
-    ;
-  set = *argptr ? 1 : 0;
-  if (set) {
-    char *p = *argptr;
-    if (all || argptr[1])
-      sh_error("too many arguments");
-    if (strcmp(p, "unlimited") == 0)
-      val = RLIM_INFINITY;
-    else {
-      val = (uint64_t)0;
-      while ((c = *p++) >= '0' && c <= '9') {
-        val = (val * 10) + (long)(c - '0');
-        if (val < (uint64_t)0)
-          break;
-      }
-      if (c)
-        sh_error("bad number");
-      val *= l->factor;
-    }
-  }
-  if (all) {
-    for (l = limits; l->name; l++) {
-      getrlimit(l->cmd, &limit);
-      out1fmt("%-20s ", l->name);
-      printlim(how, &limit, l);
-    }
-    return 0;
-  }
-  getrlimit(l->cmd, &limit);
-  if (set) {
-    if (how & HARD)
-      limit.rlim_max = val;
-    if (how & SOFT)
-      limit.rlim_cur = val;
-    if (setrlimit(l->cmd, &limit) < 0)
-      sh_error("error setting limit (%s)", strerror(errno));
-  } else {
-    printlim(how, &limit, l);
-  }
-  return 0;
-}
-
-/*
- * Produce a possibly single quoted string suitable as input to the shell.
- * The return string is allocated on the stack.
- */
-static char *single_quote(const char *s) {
-  char *p;
-  STARTSTACKSTR(p);
-  do {
-    char *q;
-    unsigned len;
-    len = strchrnul(s, '\'') - s;
-    q = p = makestrspace(len + 3, p);
-    *q++ = '\'';
-    q = mempcpy(q, s, len);
-    *q++ = '\'';
-    s += len;
-    STADJUST(q - p, p);
-    len = strspn(s, "'");
-    if (!len)
-      break;
-    q = p = makestrspace(len + 3, p);
-    *q++ = '"';
-    q = mempcpy(q, s, len);
-    *q++ = '"';
-    s += len;
-    STADJUST(q - p, p);
-  } while (*s);
-  USTPUTC(0, p);
-  return stackblock();
-}
-
-/*
- * Process the shell command line arguments.
- */
-static int procargs(int argc, char **argv) {
-  int i;
-  const char *xminusc;
-  char **xargv;
-  int login;
-  xargv = argv;
-  login = xargv[0] && xargv[0][0] == '-';
-  arg0 = xargv[0];
-  if (argc > 0)
-    xargv++;
-  for (i = 0; i < NOPTS; i++)
-    optlist[i] = 2;
-  argptr = xargv;
-  login |= options(1);
-  xargv = argptr;
-  xminusc = minusc;
-  if (*xargv == NULL) {
-    if (xminusc)
-      sh_error("-c requires an argument");
-    sflag = 1;
-  }
-  /* JART: fuck tty check this is documented behavior w/ no args */
-  if (iflag == 2 && sflag == 1 /* && isatty(0) && isatty(1) */)
-    iflag = 1;
-  if (mflag == 2)
-    mflag = iflag;
-  for (i = 0; i < NOPTS; i++)
-    if (optlist[i] == 2)
-      optlist[i] = 0;
-  /* POSIX 1003.2: first arg after -c cmd is $0, remainder $1... */
-  if (xminusc) {
-    minusc = *xargv++;
-    if (*xargv)
-      goto setarg0;
-  } else if (!sflag) {
-    setinputfile(*xargv, 0);
-  setarg0:
-    arg0 = *xargv++;
-  }
-  shellparam.p = xargv;
-  shellparam.optind = 1;
-  shellparam.optoff = -1;
-  /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */
-  while (*xargv) {
-    shellparam.nparam++;
-    xargv++;
-  }
-  optschanged();
-  return login;
-}
-
-static void optschanged(void) {
-  setinteractive(iflag);
-  setjobctl(mflag);
-}
-
-static void setoption(int flag, int val) {
-  int i;
-  for (i = 0; i < NOPTS; i++)
-    if (optletters[i] == flag) {
-      optlist[i] = val;
-      if (val) {
-        /* #%$ hack for ksh semantics */
-        if (flag == 'V')
-          Eflag = 0;
-        else if (flag == 'E')
-          Vflag = 0;
-      }
-      return;
-    }
-  sh_error("Illegal option -%c", flag);
-  __builtin_unreachable();
-}
-
-/*
- * Process shell options.  The global variable argptr contains a pointer
- * to the argument list; we advance it past the options.
- */
-static int options(int cmdline) {
-  char *p;
-  int val;
-  int c;
-  int login = 0;
-  if (cmdline)
-    minusc = NULL;
-  while ((p = *argptr) != NULL) {
-    argptr++;
-    if ((c = *p++) == '-') {
-      val = 1;
-      if (p[0] == '\0' || (p[0] == '-' && p[1] == '\0')) {
-        if (!cmdline) {
-          /* "-" means turn off -x and -v */
-          if (p[0] == '\0')
-            xflag = vflag = 0;
-          /* "--" means reset params */
-          else if (*argptr == NULL)
-            setparam(argptr);
-        }
-        break; /* "-" or  "--" terminates options */
-      }
-    } else if (c == '+') {
-      val = 0;
-    } else {
-      argptr--;
-      break;
-    }
-    while ((c = *p++) != '\0') {
-      if (c == 'c' && cmdline) {
-        minusc = p; /* command is after shell args*/
-      } else if (c == 'l' && cmdline) {
-        login = 1;
-      } else if (c == 'o') {
-        minus_o(*argptr, val);
-        if (*argptr)
-          argptr++;
-      } else {
-        setoption(c, val);
-      }
-    }
-  }
-  return login;
-}
-
-static void minus_o(char *name, int val) {
-  int i;
-  if (name == NULL) {
-    if (val) {
-      outstr("Current option settings\n", out1);
-      for (i = 0; i < NOPTS; i++) {
-        out1fmt("%-16s%s\n", optnames[i], optlist[i] ? "on" : "off");
-      }
-    } else {
-      for (i = 0; i < NOPTS; i++) {
-        out1fmt("set %s %s\n", optlist[i] ? "-o" : "+o", optnames[i]);
-      }
-    }
-  } else {
-    for (i = 0; i < NOPTS; i++)
-      if (equal(name, optnames[i])) {
-        optlist[i] = val;
-        return;
-      }
-    sh_error("Illegal option -o %s", name);
-  }
-}
-
-/*
- * Set the shell parameters.
- */
-static void setparam(char **argv) {
-  char **newparam;
-  char **ap;
-  int nparam;
-  for (nparam = 0; argv[nparam]; nparam++)
-    ;
-  ap = newparam = ckmalloc((nparam + 1) * sizeof *ap);
-  while (*argv) {
-    *ap++ = savestr(*argv++);
-  }
-  *ap = NULL;
-  freeparam(&shellparam);
-  shellparam.malloc = 1;
-  shellparam.nparam = nparam;
-  shellparam.p = newparam;
-  shellparam.optind = 1;
-  shellparam.optoff = -1;
-}
-
-/*
- * Free the list of positional parameters.
- */
-static void freeparam(volatile struct shparam *param) {
-  char **ap;
-  if (param->malloc) {
-    for (ap = param->p; *ap; ap++)
-      ckfree(*ap);
-    ckfree(param->p);
-  }
-}
-
-/*
- * The shift builtin command.
- */
-static int shiftcmd(int argc, char **argv) {
-  int n;
-  char **ap1, **ap2;
-  n = 1;
-  if (argc > 1)
-    n = number(argv[1]);
-  if (n > shellparam.nparam)
-    sh_error("can't shift that many");
-  INTOFF;
-  shellparam.nparam -= n;
-  for (ap1 = shellparam.p; --n >= 0; ap1++) {
-    if (shellparam.malloc)
-      ckfree(*ap1);
-  }
-  ap2 = shellparam.p;
-  while ((*ap2++ = *ap1++) != NULL)
-    ;
-  shellparam.optind = 1;
-  shellparam.optoff = -1;
-  INTON;
-  return 0;
-}
-
-/*
- * The set command builtin.
- */
-static int setcmd(int argc, char **argv) {
-  if (argc == 1)
-    return showvars(nullstr, 0, VUNSET);
-  INTOFF;
-  options(0);
-  optschanged();
-  if (*argptr != NULL) {
-    setparam(argptr);
-  }
-  INTON;
-  return 0;
-}
-
-static void getoptsreset(value) const char *value;
-{
-  shellparam.optind = number(value) ?: 1;
-  shellparam.optoff = -1;
-}
-
-/*
- * The getopts builtin.  Shellparam.optnext points to the next argument
- * to be processed.  Shellparam.optptr points to the next character to
- * be processed in the current argument.  If shellparam.optnext is NULL,
- * then it's the first time getopts has been called.
- */
-static int getoptscmd(int argc, char **argv) {
-  char **optbase;
-  if (argc < 3)
-    sh_error("Usage: getopts optstring var [arg]");
-  else if (argc == 3) {
-    optbase = shellparam.p;
-    if ((unsigned)shellparam.optind > shellparam.nparam + 1) {
-      shellparam.optind = 1;
-      shellparam.optoff = -1;
-    }
-  } else {
-    optbase = &argv[3];
-    if ((unsigned)shellparam.optind > argc - 2) {
-      shellparam.optind = 1;
-      shellparam.optoff = -1;
-    }
-  }
-  return getopts(argv[1], argv[2], optbase);
-}
-
-static int getopts(char *optstr, char *optvar, char **optfirst) {
-  char *p, *q;
-  char c = '?';
-  int done = 0;
-  char s[2];
-  char **optnext;
-  int ind = shellparam.optind;
-  int off = shellparam.optoff;
-  shellparam.optind = -1;
-  optnext = optfirst + ind - 1;
-  if (ind <= 1 || off < 0 || strlen(optnext[-1]) < off)
-    p = NULL;
-  else
-    p = optnext[-1] + off;
-  if (p == NULL || *p == '\0') {
-    /* Current word is done, advance */
-    p = *optnext;
-    if (p == NULL || *p != '-' || *++p == '\0') {
-    atend:
-      p = NULL;
-      done = 1;
-      goto out;
-    }
-    optnext++;
-    if (p[0] == '-' && p[1] == '\0') /* check for "--" */
-      goto atend;
-  }
-  c = *p++;
-  for (q = optstr; *q != c;) {
-    if (*q == '\0') {
-      if (optstr[0] == ':') {
-        s[0] = c;
-        s[1] = '\0';
-        setvar("OPTARG", s, 0);
-      } else {
-        outfmt(&errout, "Illegal option -%c\n", c);
-        (void)unsetvar("OPTARG");
-      }
-      c = '?';
-      goto out;
-    }
-    if (*++q == ':')
-      q++;
-  }
-  if (*++q == ':') {
-    if (*p == '\0' && (p = *optnext) == NULL) {
-      if (optstr[0] == ':') {
-        s[0] = c;
-        s[1] = '\0';
-        setvar("OPTARG", s, 0);
-        c = ':';
-      } else {
-        outfmt(&errout, "No arg for -%c option\n", c);
-        (void)unsetvar("OPTARG");
-        c = '?';
-      }
-      goto out;
-    }
-    if (p == *optnext)
-      optnext++;
-    setvar("OPTARG", p, 0);
-    p = NULL;
-  } else
-    setvar("OPTARG", nullstr, 0);
-out:
-  ind = optnext - optfirst + 1;
-  setvarint("OPTIND", ind, VNOFUNC);
-  s[0] = c;
-  s[1] = '\0';
-  setvar(optvar, s, 0);
-  shellparam.optoff = p ? p - *(optnext - 1) : -1;
-  shellparam.optind = ind;
-  return done;
-}
-
-/*
- * XXX - should get rid of.  have all builtins use getopt(3).  the
- * library getopt must have the BSD extension function variable "optreset"
- * otherwise it can't be used within the shell safely.
- *
- * Standard option processing (a la getopt) for builtin routines.  The
- * only argument that is passed to nextopt is the option string; the
- * other arguments are unnecessary.  It return the character, or '\0' on
- * end of input.
- */
-static int nextopt(const char *optstring) {
-  char *p;
-  const char *q;
-  char c;
-  if ((p = optptr) == NULL || *p == '\0') {
-    p = *argptr;
-    if (p == NULL || *p != '-' || *++p == '\0')
-      return '\0';
-    argptr++;
-    if (p[0] == '-' && p[1] == '\0') /* check for "--" */
-      return '\0';
-  }
-  c = *p++;
-  for (q = optstring; *q != c;) {
-    if (*q == '\0')
-      sh_error("Illegal option -%c", c);
-    if (*++q == ':')
-      q++;
-  }
-  if (*++q == ':') {
-    if (*p == '\0' && (p = *argptr++) == NULL) {
-      sh_error("No arg for -%c option", c);
-    }
-    optionarg = p;
-    p = NULL;
-  }
-  optptr = p;
-  return c;
-}
-
-/* values returned by readtoken */
-static int isassignment(const char *p) {
-  const char *q = endofname(p);
-  if (p == q)
-    return 0;
-  return *q == '=';
-}
-
-static inline int realeofmark(const char *eofmark) {
-  return eofmark && eofmark != FAKEEOFMARK;
-}
-
-/*
- * Read and parse a command.  Returns NEOF on end of file.  (NULL is a
- * valid parse tree indicating a blank line.)
- */
-static union node *parsecmd(int interact) {
-  tokpushback = 0;
-  checkkwd = 0;
-  heredoclist = 0;
-  doprompt = interact;
-  if (doprompt)
-    setprompt(doprompt);
-  needprompt = 0;
-  return list(1);
-}
-
-static union node *list(int nlflag) {
-  int chknl = nlflag & 1 ? 0 : CHKNL;
-  union node *n1, *n2, *n3;
-  int tok;
-  n1 = NULL;
-  for (;;) {
-    checkkwd = chknl | CHKKWD | CHKALIAS;
-    tok = readtoken();
-    switch (tok) {
-      case TNL:
-        parseheredoc();
-        return n1;
-      case TEOF:
-        if (!n1 && !chknl)
-          n1 = NEOF;
-      out_eof:
-        parseheredoc();
-        tokpushback++;
-        lasttoken = TEOF;
-        return n1;
-    }
-    tokpushback++;
-    if (nlflag == 2 && tokendlist[tok])
-      return n1;
-    nlflag |= 2;
-    n2 = andor();
-    tok = readtoken();
-    if (tok == TBACKGND) {
-      if (n2->type == NPIPE) {
-        n2->npipe.backgnd = 1;
-      } else {
-        if (n2->type != NREDIR) {
-          n3 = stalloc(sizeof(struct nredir));
-          n3->nredir.n = n2;
-          n3->nredir.redirect = NULL;
-          n2 = n3;
-        }
-        n2->type = NBACKGND;
-      }
-    }
-    if (n1 == NULL) {
-      n1 = n2;
-    } else {
-      n3 = (union node *)stalloc(sizeof(struct nbinary));
-      n3->type = NSEMI;
-      n3->nbinary.ch1 = n1;
-      n3->nbinary.ch2 = n2;
-      n1 = n3;
-    }
-    switch (tok) {
-      case TEOF:
-        goto out_eof;
-      case TNL:
-        tokpushback++;
-        /* fall through */
-      case TBACKGND:
-      case TSEMI:
-        break;
-      default:
-        if (!chknl)
-          synexpect(-1);
-        tokpushback++;
-        return n1;
-    }
-  }
-}
-
-static union node *andor(void) {
-  union node *n1, *n2, *n3;
-  int t;
-  n1 = pipeline();
-  for (;;) {
-    if ((t = readtoken()) == TAND) {
-      t = NAND;
-    } else if (t == TOR) {
-      t = NOR;
-    } else {
-      tokpushback++;
-      return n1;
-    }
-    checkkwd = CHKNL | CHKKWD | CHKALIAS;
-    n2 = pipeline();
-    n3 = (union node *)stalloc(sizeof(struct nbinary));
-    n3->type = t;
-    n3->nbinary.ch1 = n1;
-    n3->nbinary.ch2 = n2;
-    n1 = n3;
-  }
-}
-
-static union node *pipeline(void) {
-  union node *n1, *n2, *pipenode;
-  struct nodelist *lp, *prev;
-  int negate;
-  negate = 0;
-  TRACE(("pipeline: entered\n"));
-  if (readtoken() == TNOT) {
-    negate = !negate;
-    checkkwd = CHKKWD | CHKALIAS;
-  } else
-    tokpushback++;
-  n1 = command();
-  if (readtoken() == TPIPE) {
-    pipenode = (union node *)stalloc(sizeof(struct npipe));
-    pipenode->type = NPIPE;
-    pipenode->npipe.backgnd = 0;
-    lp = (struct nodelist *)stalloc(sizeof(struct nodelist));
-    pipenode->npipe.cmdlist = lp;
-    lp->n = n1;
-    do {
-      prev = lp;
-      lp = (struct nodelist *)stalloc(sizeof(struct nodelist));
-      checkkwd = CHKNL | CHKKWD | CHKALIAS;
-      lp->n = command();
-      prev->next = lp;
-    } while (readtoken() == TPIPE);
-    lp->next = NULL;
-    n1 = pipenode;
-  }
-  tokpushback++;
-  if (negate) {
-    n2 = (union node *)stalloc(sizeof(struct nnot));
-    n2->type = NNOT;
-    n2->nnot.com = n1;
-    return n2;
-  } else
-    return n1;
-}
-
-static union node *command(void) {
-  union node *n1, *n2;
-  union node *ap, **app;
-  union node *cp, **cpp;
-  union node *redir, **rpp;
-  union node **rpp2;
-  int t;
-  int savelinno;
-  redir = NULL;
-  rpp2 = &redir;
-  savelinno = plinno;
-  switch (readtoken()) {
-    default:
-      synexpect(-1);
-      __builtin_unreachable();
-    case TIF:
-      n1 = (union node *)stalloc(sizeof(struct nif));
-      n1->type = NIF;
-      n1->nif.test = list(0);
-      if (readtoken() != TTHEN)
-        synexpect(TTHEN);
-      n1->nif.ifpart = list(0);
-      n2 = n1;
-      while (readtoken() == TELIF) {
-        n2->nif.elsepart = (union node *)stalloc(sizeof(struct nif));
-        n2 = n2->nif.elsepart;
-        n2->type = NIF;
-        n2->nif.test = list(0);
-        if (readtoken() != TTHEN)
-          synexpect(TTHEN);
-        n2->nif.ifpart = list(0);
-      }
-      if (lasttoken == TELSE)
-        n2->nif.elsepart = list(0);
-      else {
-        n2->nif.elsepart = NULL;
-        tokpushback++;
-      }
-      t = TFI;
-      break;
-    case TWHILE:
-    case TUNTIL: {
-      int got;
-      n1 = (union node *)stalloc(sizeof(struct nbinary));
-      n1->type = (lasttoken == TWHILE) ? NWHILE : NUNTIL;
-      n1->nbinary.ch1 = list(0);
-      if ((got = readtoken()) != TDO) {
-        TRACE(("expecting DO got %s %s\n", tokname[got],
-               got == TWORD ? wordtext : ""));
-        synexpect(TDO);
-      }
-      n1->nbinary.ch2 = list(0);
-      t = TDONE;
-      break;
-    }
-    case TFOR:
-      if (readtoken() != TWORD || quoteflag || !goodname(wordtext))
-        synerror("Bad for loop variable");
-      n1 = (union node *)stalloc(sizeof(struct nfor));
-      n1->type = NFOR;
-      n1->nfor.linno = savelinno;
-      n1->nfor.var_ = wordtext;
-      checkkwd = CHKNL | CHKKWD | CHKALIAS;
-      if (readtoken() == TIN) {
-        app = &ap;
-        while (readtoken() == TWORD) {
-          n2 = (union node *)stalloc(sizeof(struct narg));
-          n2->type = NARG;
-          n2->narg.text = wordtext;
-          n2->narg.backquote = backquotelist;
-          *app = n2;
-          app = &n2->narg.next;
-        }
-        *app = NULL;
-        n1->nfor.args = ap;
-        if (lasttoken != TNL && lasttoken != TSEMI)
-          synexpect(-1);
-      } else {
-        n2 = (union node *)stalloc(sizeof(struct narg));
-        n2->type = NARG;
-        n2->narg.text = (char *)dolatstr;
-        n2->narg.backquote = NULL;
-        n2->narg.next = NULL;
-        n1->nfor.args = n2;
-        /*
-         * Newline or semicolon here is optional (but note
-         * that the original Bourne shell only allowed NL).
-         */
-        if (lasttoken != TSEMI)
-          tokpushback++;
-      }
-      checkkwd = CHKNL | CHKKWD | CHKALIAS;
-      if (readtoken() != TDO)
-        synexpect(TDO);
-      n1->nfor.body = list(0);
-      t = TDONE;
-      break;
-    case TCASE:
-      n1 = (union node *)stalloc(sizeof(struct ncase));
-      n1->type = NCASE;
-      n1->ncase.linno = savelinno;
-      if (readtoken() != TWORD)
-        synexpect(TWORD);
-      n1->ncase.expr = n2 = (union node *)stalloc(sizeof(struct narg));
-      n2->type = NARG;
-      n2->narg.text = wordtext;
-      n2->narg.backquote = backquotelist;
-      n2->narg.next = NULL;
-      checkkwd = CHKNL | CHKKWD | CHKALIAS;
-      if (readtoken() != TIN)
-        synexpect(TIN);
-      cpp = &n1->ncase.cases;
-    next_case:
-      checkkwd = CHKNL | CHKKWD;
-      t = readtoken();
-      while (t != TESAC) {
-        if (lasttoken == TLP)
-          readtoken();
-        *cpp = cp = (union node *)stalloc(sizeof(struct nclist));
-        cp->type = NCLIST;
-        app = &cp->nclist.pattern;
-        for (;;) {
-          *app = ap = (union node *)stalloc(sizeof(struct narg));
-          ap->type = NARG;
-          ap->narg.text = wordtext;
-          ap->narg.backquote = backquotelist;
-          if (readtoken() != TPIPE)
-            break;
-          app = &ap->narg.next;
-          readtoken();
-        }
-        ap->narg.next = NULL;
-        if (lasttoken != TRP)
-          synexpect(TRP);
-        cp->nclist.body = list(2);
-        cpp = &cp->nclist.next;
-        checkkwd = CHKNL | CHKKWD;
-        if ((t = readtoken()) != TESAC) {
-          if (t != TENDCASE)
-            synexpect(TENDCASE);
-          else
-            goto next_case;
-        }
-      }
-      *cpp = NULL;
-      goto redir;
-    case TLP:
-      n1 = (union node *)stalloc(sizeof(struct nredir));
-      n1->type = NSUBSHELL;
-      n1->nredir.linno = savelinno;
-      n1->nredir.n = list(0);
-      n1->nredir.redirect = NULL;
-      t = TRP;
-      break;
-    case TBEGIN:
-      n1 = list(0);
-      t = TEND;
-      break;
-    case TWORD:
-    case TREDIR:
-      tokpushback++;
-      return simplecmd();
-  }
-  if (readtoken() != t)
-    synexpect(t);
-redir:
-  /* Now check for redirection which may follow command */
-  checkkwd = CHKKWD | CHKALIAS;
-  rpp = rpp2;
-  while (readtoken() == TREDIR) {
-    *rpp = n2 = redirnode;
-    rpp = &n2->nfile.next;
-    parsefname();
-  }
-  tokpushback++;
-  *rpp = NULL;
-  if (redir) {
-    if (n1->type != NSUBSHELL) {
-      n2 = (union node *)stalloc(sizeof(struct nredir));
-      n2->type = NREDIR;
-      n2->nredir.linno = savelinno;
-      n2->nredir.n = n1;
-      n1 = n2;
-    }
-    n1->nredir.redirect = redir;
-  }
-  return n1;
-}
-
-static union node *simplecmd(void) {
-  union node *args, **app;
-  union node *n = NULL;
-  union node *vars, **vpp;
-  union node **rpp, *redir;
-  int savecheckkwd;
-  int savelinno;
-  args = NULL;
-  app = &args;
-  vars = NULL;
-  vpp = &vars;
-  redir = NULL;
-  rpp = &redir;
-  savecheckkwd = CHKALIAS;
-  savelinno = plinno;
-  for (;;) {
-    checkkwd = savecheckkwd;
-    switch (readtoken()) {
-      case TWORD:
-        n = (union node *)stalloc(sizeof(struct narg));
-        n->type = NARG;
-        n->narg.text = wordtext;
-        n->narg.backquote = backquotelist;
-        if (savecheckkwd && isassignment(wordtext)) {
-          *vpp = n;
-          vpp = &n->narg.next;
-        } else {
-          *app = n;
-          app = &n->narg.next;
-          savecheckkwd = 0;
-        }
-        break;
-      case TREDIR:
-        *rpp = n = redirnode;
-        rpp = &n->nfile.next;
-        parsefname(); /* read name of redirection file */
-        break;
-      case TLP:
-        if (args && app == &args->narg.next && !vars && !redir) {
-          struct builtincmd *bcmd;
-          const char *name;
-          /* We have a function */
-          if (readtoken() != TRP)
-            synexpect(TRP);
-          name = n->narg.text;
-          if (!goodname(name) ||
-              ((bcmd = find_builtin(name)) && bcmd->flags & BUILTIN_SPECIAL))
-            synerror("Bad function name");
-          n->type = NDEFUN;
-          checkkwd = CHKNL | CHKKWD | CHKALIAS;
-          n->ndefun.text = n->narg.text;
-          n->ndefun.linno = plinno;
-          n->ndefun.body = command();
-          return n;
-        }
-        /* fall through */
-      default:
-        tokpushback++;
-        goto out;
-    }
-  }
-out:
-  *app = NULL;
-  *vpp = NULL;
-  *rpp = NULL;
-  n = (union node *)stalloc(sizeof(struct ncmd));
-  n->type = NCMD;
-  n->ncmd.linno = savelinno;
-  n->ncmd.args = args;
-  n->ncmd.assign = vars;
-  n->ncmd.redirect = redir;
-  return n;
-}
-
-static union node *makename(void) {
-  union node *n;
-  n = (union node *)stalloc(sizeof(struct narg));
-  n->type = NARG;
-  n->narg.next = NULL;
-  n->narg.text = wordtext;
-  n->narg.backquote = backquotelist;
-  return n;
-}
-
-static void fixredir(union node *n, const char *text, int err) {
-  TRACE(("Fix redir %s %d\n", text, err));
-  if (!err)
-    n->ndup.vname = NULL;
-  if (is_digit(text[0]) && text[1] == '\0')
-    n->ndup.dupfd = digit_val(text[0]);
-  else if (text[0] == '-' && text[1] == '\0')
-    n->ndup.dupfd = -1;
-  else {
-    if (err)
-      synerror("Bad fd number");
-    else
-      n->ndup.vname = makename();
-  }
-}
-
-static void parsefname(void) {
-  union node *n = redirnode;
-  if (n->type == NHERE)
-    checkkwd = CHKEOFMARK;
-  if (readtoken() != TWORD)
-    synexpect(-1);
-  if (n->type == NHERE) {
-    struct heredoc *here = heredoc;
-    struct heredoc *p;
-    if (quoteflag == 0)
-      n->type = NXHERE;
-    TRACE(("Here document %d\n", n->type));
-    rmescapes(wordtext, 0);
-    here->eofmark = wordtext;
-    here->next = NULL;
-    if (heredoclist == NULL)
-      heredoclist = here;
-    else {
-      for (p = heredoclist; p->next; p = p->next)
-        ;
-      p->next = here;
-    }
-  } else if (n->type == NTOFD || n->type == NFROMFD) {
-    fixredir(n, wordtext, 0);
-  } else {
-    n->nfile.fname = makename();
-  }
-}
-
-/*
- * Input any here documents.
- */
-static void parseheredoc(void) {
-  struct heredoc *here;
-  union node *n;
-  here = heredoclist;
-  heredoclist = 0;
-  while (here) {
-    if (needprompt) {
-      setprompt(2);
-    }
-    if (here->here->type == NHERE)
-      readtoken1(pgetc(), SQSYNTAX, here->eofmark, here->striptabs);
-    else
-      readtoken1(pgetc_eatbnl(), DQSYNTAX, here->eofmark, here->striptabs);
-    n = (union node *)stalloc(sizeof(struct narg));
-    n->narg.type = NARG;
-    n->narg.next = NULL;
-    n->narg.text = wordtext;
-    n->narg.backquote = backquotelist;
-    here->here->nhere.doc = n;
-    here = here->next;
-  }
-}
-
-static int readtoken(void) {
-  int t;
-  int kwd = checkkwd;
-top:
-  t = xxreadtoken();
-  /*
-   * eat newlines
-   */
-  if (kwd & CHKNL) {
-    while (t == TNL) {
-      parseheredoc();
-      checkkwd = 0;
-      t = xxreadtoken();
-    }
-  }
-  kwd |= checkkwd;
-  checkkwd = 0;
-  if (t != TWORD || quoteflag) {
-    goto out;
-  }
-  /*
-   * check for keywords
-   */
-  if (kwd & CHKKWD) {
-    const char *const *pp;
-    const int KWDOFFSET = 13;
-    if ((pp = findkwd(wordtext))) {
-      lasttoken = t = pp - parsekwd + KWDOFFSET;
-      TRACE(("keyword %s recognized\n", tokname[t]));
-      goto out;
-    }
-  }
-  if (kwd & CHKALIAS) {
-    struct alias *ap;
-    if ((ap = lookupalias(wordtext, 1)) != NULL) {
-      if (*ap->val) {
-        pushstring(ap->val, ap);
-      }
-      goto top;
-    }
-  }
-out:
-  return (t);
-}
-
-static void nlprompt(void) {
-  plinno++;
-  if (doprompt)
-    setprompt(2);
-}
-
-static void nlnoprompt(void) {
-  plinno++;
-  needprompt = doprompt;
-}
-
-/*
- * Read the next input token.
- * If the token is a word, we set backquotelist to the list of cmds in
- *  backquotes.  We set quoteflag to true if any part of the word was
- *  quoted.
- * If the token is TREDIR, then we set redirnode to a structure containing
- *  the redirection.
- *
- * [Change comment:  here documents and internal procedures]
- * [Readtoken shouldn't have any arguments.  Perhaps we should make the
- *  word parsing code into a separate routine.  In this case, readtoken
- *  doesn't need to have any internal procedures, but parseword does.
- *  We could also make parseoperator in essence the main routine, and
- *  have parseword (readtoken1?) handle both words and redirection.]
- */
-static int xxreadtoken(void) {
-#define RETURN(token) return lasttoken = token
-  int c;
-  if (tokpushback) {
-    tokpushback = 0;
-    return lasttoken;
-  }
-  if (needprompt) {
-    setprompt(2);
-  }
-  for (;;) { /* until token or start of word found */
-    c = pgetc_eatbnl();
-    switch (c) {
-      case ' ':
-      case '\t':
-        continue;
-      case '#':
-        while ((c = pgetc()) != '\n' && c != PEOF)
-          ;
-        pungetc();
-        continue;
-      case '\n':
-        nlnoprompt();
-        RETURN(TNL);
-      case PEOF:
-        RETURN(TEOF);
-      case '&':
-        if (pgetc_eatbnl() == '&')
-          RETURN(TAND);
-        pungetc();
-        RETURN(TBACKGND);
-      case '|':
-        if (pgetc_eatbnl() == '|')
-          RETURN(TOR);
-        pungetc();
-        RETURN(TPIPE);
-      case ';':
-        if (pgetc_eatbnl() == ';')
-          RETURN(TENDCASE);
-        pungetc();
-        RETURN(TSEMI);
-      case '(':
-        RETURN(TLP);
-      case ')':
-        RETURN(TRP);
-    }
-    break;
-  }
-  return readtoken1(c, BASESYNTAX, (char *)NULL, 0);
-#undef RETURN
-}
-
-static int pgetc_eatbnl(void) {
-  int c;
-  while ((c = pgetc()) == '\\') {
-    if (pgetc() != '\n') {
-      pungetc();
-      break;
-    }
-    nlprompt();
-  }
-  return c;
-}
-
-static int pgetc_top(struct synstack *stack) {
-  return stack->syntax == SQSYNTAX ? pgetc() : pgetc_eatbnl();
-}
-
-static void synstack_push(struct synstack **stack, struct synstack *next,
-                          const char *syntax) {
-  memset(next, 0, sizeof(*next));
-  next->syntax = syntax;
-  next->next = *stack;
-  (*stack)->prev = next;
-  *stack = next;
-}
-
-static void synstack_pop(struct synstack **stack) {
-  *stack = (*stack)->next;
-}
-
-/*
- * If eofmark is NULL, read a word or a redirection symbol.  If eofmark
- * is not NULL, read a here document.  In the latter case, eofmark is the
- * word which marks the end of the document and striptabs is true if
- * leading tabs should be stripped from the document.  The argument firstc
- * is the first character of the input token or document.
- *
- * Because C does not have internal subroutines, I have simulated them
- * using goto's to implement the subroutine linkage.  The following macros
- * will run code that appears at the end of readtoken1.
- */
-
-#define CHECKEND()  \
-  {                 \
-    goto checkend;  \
-  checkend_return:; \
-  }
-#define PARSEREDIR()  \
-  {                   \
-    goto parseredir;  \
-  parseredir_return:; \
-  }
-#define PARSESUB()  \
-  {                 \
-    goto parsesub;  \
-  parsesub_return:; \
-  }
-#define PARSEBACKQOLD()  \
-  {                      \
-    oldstyle = 1;        \
-    goto parsebackq;     \
-  parsebackq_oldreturn:; \
-  }
-#define PARSEBACKQNEW()  \
-  {                      \
-    oldstyle = 0;        \
-    goto parsebackq;     \
-  parsebackq_newreturn:; \
-  }
-#define PARSEARITH()  \
-  {                   \
-    goto parsearith;  \
-  parsearith_return:; \
-  }
-
-static int readtoken1(int firstc, char const *syntax, char *eofmark,
-                      int striptabs) {
-  int c = firstc;
-  char *out;
-  unsigned len;
-  struct nodelist *bqlist;
-  int quotef;
-  int oldstyle;
-  /* syntax stack */
-  struct synstack synbase = {.syntax = syntax};
-  struct synstack *synstack = &synbase;
-  if (syntax == DQSYNTAX)
-    synstack->dblquote = 1;
-  quotef = 0;
-  bqlist = NULL;
-  STARTSTACKSTR(out);
-loop: {                    /* for each line, until end of word */
-  CHECKEND();              /* set c to PEOF if at end of here document */
-  for (;;) {               /* until end of line or end of word */
-    CHECKSTRSPACE(4, out); /* permit 4 calls to USTPUTC */
-    switch (synstack->syntax[c]) {
-      case CNL: /* '\n' */
-        if (synstack->syntax == BASESYNTAX && !synstack->varnest)
-          goto endword; /* exit outer loop */
-        USTPUTC(c, out);
-        nlprompt();
-        c = pgetc_top(synstack);
-        goto loop; /* continue outer loop */
-      case CWORD:
-        USTPUTC(c, out);
-        break;
-      case CCTL:
-        if ((!eofmark) | synstack->dblquote | synstack->varnest)
-          USTPUTC(CTLESC, out);
-        USTPUTC(c, out);
-        break;
-      /* backslash */
-      case CBACK:
-        c = pgetc();
-        if (c == PEOF) {
-          USTPUTC(CTLESC, out);
-          USTPUTC('\\', out);
-          pungetc();
-        } else {
-          if (synstack->dblquote && c != '\\' && c != '`' && c != '$' &&
-              (c != '"' || (eofmark != NULL && !synstack->varnest)) &&
-              (c != '}' || !synstack->varnest)) {
-            USTPUTC(CTLESC, out);
-            USTPUTC('\\', out);
-          }
-          USTPUTC(CTLESC, out);
-          USTPUTC(c, out);
-          quotef++;
-        }
-        break;
-      case CSQUOTE:
-        synstack->syntax = SQSYNTAX;
-      quotemark:
-        if (eofmark == NULL) {
-          USTPUTC(CTLQUOTEMARK, out);
-        }
-        break;
-      case CDQUOTE:
-        synstack->syntax = DQSYNTAX;
-        synstack->dblquote = 1;
-      toggledq:
-        if (synstack->varnest)
-          synstack->innerdq ^= 1;
-        goto quotemark;
-      case CENDQUOTE:
-        if (eofmark && !synstack->varnest) {
-          USTPUTC(c, out);
-          break;
-        }
-        if (synstack->dqvarnest == 0) {
-          synstack->syntax = BASESYNTAX;
-          synstack->dblquote = 0;
-        }
-        quotef++;
-        if (c == '"')
-          goto toggledq;
-        goto quotemark;
-      case CVAR:    /* '$' */
-        PARSESUB(); /* parse substitution */
-        break;
-      case CENDVAR: /* '}' */
-        if (!synstack->innerdq && synstack->varnest > 0) {
-          if (!--synstack->varnest && synstack->varpushed)
-            synstack_pop(&synstack);
-          else if (synstack->dqvarnest > 0)
-            synstack->dqvarnest--;
-          USTPUTC(CTLENDVAR, out);
-        } else {
-          USTPUTC(c, out);
-        }
-        break;
-      case CLP: /* '(' in arithmetic */
-        synstack->parenlevel++;
-        USTPUTC(c, out);
-        break;
-      case CRP: /* ')' in arithmetic */
-        if (synstack->parenlevel > 0) {
-          USTPUTC(c, out);
-          --synstack->parenlevel;
-        } else {
-          if (pgetc_eatbnl() == ')') {
-            USTPUTC(CTLENDARI, out);
-            synstack_pop(&synstack);
-          } else {
-            /*
-             * unbalanced parens
-             *  (don't 2nd guess - no error)
-             */
-            pungetc();
-            USTPUTC(')', out);
-          }
-        }
-        break;
-      case CBQUOTE: /* '`' */
-        if (checkkwd & CHKEOFMARK) {
-          USTPUTC('`', out);
-          break;
-        }
-        PARSEBACKQOLD();
-        break;
-      case CEOF:
-        goto endword; /* exit outer loop */
-      default:
-        if (synstack->varnest == 0)
-          goto endword; /* exit outer loop */
-        USTPUTC(c, out);
-    }
-    c = pgetc_top(synstack);
-  }
-}
-endword:
-  if (synstack->syntax == ARISYNTAX)
-    synerror("Missing '))'");
-  if (synstack->syntax != BASESYNTAX && eofmark == NULL)
-    synerror("Unterminated quoted string");
-  if (synstack->varnest != 0) {
-    /* { */
-    synerror("Missing '}'");
-  }
-  USTPUTC('\0', out);
-  len = out - (char *)stackblock();
-  out = stackblock();
-  if (eofmark == NULL) {
-    if ((c == '>' || c == '<') && quotef == 0 && len <= 2 &&
-        (*out == '\0' || is_digit(*out))) {
-      PARSEREDIR();
-      return lasttoken = TREDIR;
-    } else {
-      pungetc();
-    }
-  }
-  quoteflag = quotef;
-  backquotelist = bqlist;
-  grabstackblock(len);
-  wordtext = out;
-  return lasttoken = TWORD;
-  /* end of readtoken routine */
-
-  /*
-   * Check to see whether we are at the end of the here document.  When this
-   * is called, c is set to the first character of the next input line.  If
-   * we are at the end of the here document, this routine sets the c to PEOF.
-   */
-checkend: {
-  if (realeofmark(eofmark)) {
-    int markloc;
-    char *p;
-    if (striptabs) {
-      while (c == '\t')
-        c = pgetc();
-    }
-    markloc = out - (char *)stackblock();
-    for (p = eofmark; STPUTC(c, out), *p; p++) {
-      if (c != *p)
-        goto more_heredoc;
-      c = pgetc();
-    }
-    if (c == '\n' || c == PEOF) {
-      c = PEOF;
-      nlnoprompt();
-    } else {
-      int len2;
-    more_heredoc:
-      p = (char *)stackblock() + markloc + 1;
-      len2 = out - p;
-      if (len2) {
-        len2 -= c < 0;
-        c = p[-1];
-        if (len2) {
-          char *str;
-          str = alloca(len2 + 1);
-          *(char *)mempcpy(str, p, len2) = 0;
-          pushstring(str, NULL);
-        }
-      }
-    }
-    STADJUST((char *)stackblock() + markloc - out, out);
-  }
-  goto checkend_return;
-}
-
-  /*
-   * Parse a redirection operator.  The variable "out" points to a string
-   * specifying the fd to be redirected.  The variable "c" contains the
-   * first character of the redirection operator.
-   */
-parseredir: {
-  char fd = *out;
-  union node *np;
-  np = (union node *)stalloc(sizeof(struct nfile));
-  if (c == '>') {
-    np->nfile.fd = 1;
-    c = pgetc_eatbnl();
-    if (c == '>')
-      np->type = NAPPEND;
-    else if (c == '|')
-      np->type = NCLOBBER;
-    else if (c == '&')
-      np->type = NTOFD;
-    else {
-      np->type = NTO;
-      pungetc();
-    }
-  } else { /* c == '<' */
-    np->nfile.fd = 0;
-    switch (c = pgetc_eatbnl()) {
-      case '<':
-        if (sizeof(struct nfile) != sizeof(struct nhere)) {
-          np = (union node *)stalloc(sizeof(struct nhere));
-          np->nfile.fd = 0;
-        }
-        np->type = NHERE;
-        heredoc = (struct heredoc *)stalloc(sizeof(struct heredoc));
-        heredoc->here = np;
-        if ((c = pgetc_eatbnl()) == '-') {
-          heredoc->striptabs = 1;
-        } else {
-          heredoc->striptabs = 0;
-          pungetc();
-        }
-        break;
-      case '&':
-        np->type = NFROMFD;
-        break;
-      case '>':
-        np->type = NFROMTO;
-        break;
-      default:
-        np->type = NFROM;
-        pungetc();
-        break;
-    }
-  }
-  if (fd != '\0')
-    np->nfile.fd = digit_val(fd);
-  redirnode = np;
-  goto parseredir_return;
-}
-
-  /*
-   * Parse a substitution.  At this point, we have read the dollar sign
-   * and nothing else.
-   */
-parsesub: {
-  int subtype;
-  int typeloc;
-  char *p;
-  static const char types[] = "}-+?=";
-  c = pgetc_eatbnl();
-  if ((checkkwd & CHKEOFMARK) ||
-      (c != '(' && c != '{' && !is_name(c) && !is_special(c))) {
-    USTPUTC('$', out);
-    pungetc();
-  } else if (c == '(') { /* $(command) or $((arith)) */
-    if (pgetc_eatbnl() == '(') {
-      PARSEARITH();
-    } else {
-      pungetc();
-      PARSEBACKQNEW();
-    }
-  } else {
-    const char *newsyn = synstack->syntax;
-    USTPUTC(CTLVAR, out);
-    typeloc = out - (char *)stackblock();
-    STADJUST(1, out);
-    subtype = VSNORMAL;
-    if (likely(c == '{')) {
-      c = pgetc_eatbnl();
-      subtype = 0;
-    }
-  varname:
-    if (is_name(c)) {
-      do {
-        STPUTC(c, out);
-        c = pgetc_eatbnl();
-      } while (is_in_name(c));
-    } else if (is_digit(c)) {
-      do {
-        STPUTC(c, out);
-        c = pgetc_eatbnl();
-      } while ((subtype <= 0 || subtype >= VSLENGTH) && is_digit(c));
-    } else if (c != '}') {
-      int cc = c;
-      c = pgetc_eatbnl();
-      if (!subtype && cc == '#') {
-        subtype = VSLENGTH;
-        if (c == '_' || isalnum(c))
-          goto varname;
-        cc = c;
-        c = pgetc_eatbnl();
-        if (cc == '}' || c != '}') {
-          pungetc();
-          subtype = 0;
-          c = cc;
-          cc = '#';
-        }
-      }
-      if (!is_special(cc)) {
-        if (subtype == VSLENGTH)
-          subtype = 0;
-        goto badsub;
-      }
-      USTPUTC(cc, out);
-    } else
-      goto badsub;
-    if (subtype == 0) {
-      int cc = c;
-      switch (c) {
-        case ':':
-          subtype = VSNUL;
-          c = pgetc_eatbnl();
-          /*FALLTHROUGH*/
-        default:
-          p = strchr(types, c);
-          if (p == NULL)
-            break;
-          subtype |= p - types + VSNORMAL;
-          break;
-        case '%':
-        case '#':
-          subtype = c == '#' ? VSTRIMLEFT : VSTRIMRIGHT;
-          c = pgetc_eatbnl();
-          if (c == cc)
-            subtype++;
-          else
-            pungetc();
-          newsyn = BASESYNTAX;
-          break;
-      }
-    } else {
-      if (subtype == VSLENGTH && c != '}')
-        subtype = 0;
-    badsub:
-      pungetc();
-    }
-    if (newsyn == ARISYNTAX)
-      newsyn = DQSYNTAX;
-    if ((newsyn != synstack->syntax || synstack->innerdq) &&
-        subtype != VSNORMAL) {
-      synstack_push(&synstack, synstack->prev ?: alloca(sizeof(*synstack)),
-                    newsyn);
-      synstack->varpushed++;
-      synstack->dblquote = newsyn != BASESYNTAX;
-    }
-    *((char *)stackblock() + typeloc) = subtype;
-    if (subtype != VSNORMAL) {
-      synstack->varnest++;
-      if (synstack->dblquote)
-        synstack->dqvarnest++;
-    }
-    STPUTC('=', out);
-  }
-  goto parsesub_return;
-}
-
-  /*
-   * Called to parse command substitutions.  Newstyle is set if the command
-   * is enclosed inside $(...); nlpp is a pointer to the head of the linked
-   * list of commands (passed by reference), and savelen is the number of
-   * characters on the top of the stack which must be preserved.
-   */
-parsebackq: {
-  struct nodelist **nlpp;
-  union node *n;
-  char *str;
-  unsigned savelen;
-  struct heredoc *saveheredoclist;
-  int uninitialized_var(saveprompt);
-  str = NULL;
-  savelen = out - (char *)stackblock();
-  if (savelen > 0) {
-    str = alloca(savelen);
-    memcpy(str, stackblock(), savelen);
-  }
-  if (oldstyle) {
-    /* We must read until the closing backquote, giving special
-       treatment to some slashes, and then push the string and
-       reread it as input, interpreting it normally.  */
-    char *pout;
-    int pc;
-    unsigned psavelen;
-    char *pstr;
-    STARTSTACKSTR(pout);
-    for (;;) {
-      if (needprompt) {
-        setprompt(2);
-      }
-      switch (pc = pgetc_eatbnl()) {
-        case '`':
-          goto done;
-        case '\\':
-          pc = pgetc();
-          if (pc != '\\' && pc != '`' && pc != '$' &&
-              (!synstack->dblquote || pc != '"'))
-            STPUTC('\\', pout);
-          break;
-        case PEOF:
-          synerror("EOF in backquote substitution");
-        case '\n':
-          nlnoprompt();
-          break;
-        default:
-          break;
-      }
-      STPUTC(pc, pout);
-    }
-  done:
-    STPUTC('\0', pout);
-    psavelen = pout - (char *)stackblock();
-    if (psavelen > 0) {
-      pstr = grabstackstr(pout);
-      setinputstring(pstr);
-    }
-  }
-  nlpp = &bqlist;
-  while (*nlpp)
-    nlpp = &(*nlpp)->next;
-  *nlpp = (struct nodelist *)stalloc(sizeof(struct nodelist));
-  (*nlpp)->next = NULL;
-  saveheredoclist = heredoclist;
-  heredoclist = NULL;
-  if (oldstyle) {
-    saveprompt = doprompt;
-    doprompt = 0;
-  }
-  n = list(2);
-  if (oldstyle)
-    doprompt = saveprompt;
-  else {
-    if (readtoken() != TRP)
-      synexpect(TRP);
-    setinputstring(nullstr);
-  }
-  parseheredoc();
-  heredoclist = saveheredoclist;
-  (*nlpp)->n = n;
-  /* Start reading from old file again. */
-  popfile();
-  /* Ignore any pushed back tokens left from the backquote parsing. */
-  if (oldstyle)
-    tokpushback = 0;
-  out = growstackto(savelen + 1);
-  if (str) {
-    memcpy(out, str, savelen);
-    STADJUST(savelen, out);
-  }
-  USTPUTC(CTLBACKQ, out);
-  if (oldstyle)
-    goto parsebackq_oldreturn;
-  else
-    goto parsebackq_newreturn;
-}
-
-/*
- * Parse an arithmetic expansion (indicate start of one and set state)
- */
-parsearith: {
-  synstack_push(&synstack, synstack->prev ?: alloca(sizeof(*synstack)),
-                ARISYNTAX);
-  synstack->dblquote = 1;
-  USTPUTC(CTLARI, out);
-  goto parsearith_return;
-}
-
-} /* end of readtoken */
-
-static void setprompt(int which) {
-  struct stackmark smark;
-  int show;
-  needprompt = 0;
-  whichprompt = which;
-  show = 0;
-  if (show) {
-    pushstackmark(&smark, stackblocksize());
-    outstr(getprompt(NULL), out2);
-    popstackmark(&smark);
-  }
-}
-
-static const char *expandstr(const char *ps) {
-  struct parsefile *file_stop;
-  struct jmploc *volatile savehandler;
-  struct heredoc *saveheredoclist;
-  const char *result;
-  int saveprompt;
-  struct jmploc jmploc;
-  union node n;
-  int err;
-  file_stop = parsefile;
-  setinputstring((char *)ps); /* XXX Fix (char *) cast. */
-  saveheredoclist = heredoclist;
-  heredoclist = NULL;
-  saveprompt = doprompt;
-  doprompt = 0;
-  result = ps;
-  savehandler = handler;
-  if (unlikely(err = setjmp(jmploc.loc)))
-    goto out;
-  handler = &jmploc;
-  readtoken1(pgetc_eatbnl(), DQSYNTAX, FAKEEOFMARK, 0);
-  n.narg.type = NARG;
-  n.narg.next = NULL;
-  n.narg.text = wordtext;
-  n.narg.backquote = backquotelist;
-  expandarg(&n, NULL, EXP_QUOTED);
-  result = stackblock();
-out:
-  handler = savehandler;
-  if (err && exception != EXERROR)
-    longjmp(handler->loc, 1);
-  doprompt = saveprompt;
-  unwindfiles(file_stop);
-  heredoclist = saveheredoclist;
-  return result;
-}
-
-/*
- * called by editline -- any expansions to the prompt
- *    should be added here.
- */
-static const char *getprompt(void *unused) {
-  const char *prompt;
-  switch (whichprompt) {
-    default:
-    case 0:
-      return nullstr;
-    case 1:
-      prompt = ps1val();
-      break;
-    case 2:
-      prompt = ps2val();
-      break;
-  }
-  return expandstr(prompt);
-}
-
-const char *const *findkwd(const char *s) {
-  return findstring(s, parsekwd, sizeof(parsekwd) / sizeof(const char *));
-}
-
-static unsigned update_closed_redirs(int fd, int nfd) {
-  unsigned val = closed_redirs;
-  unsigned bit = 1 << fd;
-  if (nfd >= 0)
-    closed_redirs &= ~bit;
-  else
-    closed_redirs |= bit;
-  return val & bit;
-}
-
-/*
- * Process a list of redirection commands.  If the REDIR_PUSH flag is set,
- * old file descriptors are stashed away so that the redirection can be
- * undone by calling popredir.  If the REDIR_BACKQ flag is set, then the
- * standard output, and the standard error if it becomes a duplicate of
- * stdout, is saved in memory.
- */
-static void redirect(union node *redir, int flags) {
-  union node *n;
-  struct redirtab *sv;
-  int i;
-  int fd;
-  int newfd;
-  int *p;
-  if (!redir)
-    return;
-  sv = NULL;
-  INTOFF;
-  if (likely(flags & REDIR_PUSH))
-    sv = redirlist;
-  n = redir;
-  do {
-    newfd = openredirect(n);
-    if (newfd < -1)
-      continue;
-    fd = n->nfile.fd;
-    if (sv) {
-      int closed;
-      p = &sv->renamed[fd];
-      i = *p;
-      closed = update_closed_redirs(fd, newfd);
-      if (likely(i == EMPTY)) {
-        i = CLOSED;
-        if (fd != newfd && !closed) {
-          i = savefd(fd, fd);
-          fd = -1;
-        }
-      }
-      *p = i;
-    }
-    if (fd == newfd)
-      continue;
-    dupredirect(n, newfd);
-  } while ((n = n->nfile.next));
-  INTON;
-  if (flags & REDIR_SAVEFD2 && sv->renamed[2] >= 0)
-    preverrout.fd = sv->renamed[2];
-}
-
-wontreturn static int sh_open_fail(const char *pathname, int flags, int e) {
-  const char *word;
-  int action;
-  word = "open";
-  action = E_OPEN;
-  if (flags & O_CREAT) {
-    word = "create";
-    action = E_CREAT;
-  }
-  sh_error("cannot %s %s: %s", word, pathname, errmsg(e, action));
-}
-
-static int sh_open(const char *pathname, int flags, int mayfail) {
-  int fd;
-  int e;
-  do {
-    fd = open(pathname, flags, 0666);
-    e = errno;
-  } while (fd < 0 && e == EINTR && !pending_sig);
-  if (mayfail || fd >= 0)
-    return fd;
-  sh_open_fail(pathname, flags, e);
-}
-
-static int openredirect(union node *redir) {
-  struct stat sb;
-  char *fname;
-  int flags;
-  int f;
-  switch (redir->nfile.type) {
-    case NFROM:
-      flags = O_RDONLY;
-    do_open:
-      f = sh_open(redir->nfile.expfname, flags, 0);
-      break;
-    case NFROMTO:
-      flags = O_RDWR | O_CREAT;
-      goto do_open;
-    case NTO:
-      /* Take care of noclobber mode. */
-      if (Cflag) {
-        fname = redir->nfile.expfname;
-        if (stat(fname, &sb) < 0) {
-          flags = O_WRONLY | O_CREAT | O_EXCL;
-          goto do_open;
-        }
-        if (S_ISREG(sb.st_mode))
-          goto ecreate;
-        f = sh_open(fname, O_WRONLY, 0);
-        if (!fstat(f, &sb) && S_ISREG(sb.st_mode)) {
-          close(f);
-          goto ecreate;
-        }
-        break;
-      }
-      /* FALLTHROUGH */
-    case NCLOBBER:
-      flags = O_WRONLY | O_CREAT | O_TRUNC;
-      goto do_open;
-    case NAPPEND:
-      flags = O_WRONLY | O_CREAT | O_APPEND;
-      goto do_open;
-    case NTOFD:
-    case NFROMFD:
-      f = redir->ndup.dupfd;
-      if (f == redir->nfile.fd)
-        f = -2;
-      break;
-    default:
-      /* Fall through to eliminate warning. */
-    case NHERE:
-    case NXHERE:
-      f = openhere(redir);
-      break;
-  }
-  return f;
-ecreate:
-  sh_open_fail(fname, O_CREAT, EEXIST);
-}
-
-static void dupredirect(union node *redir, int f) {
-  int fd = redir->nfile.fd;
-  int err = 0;
-  if (redir->nfile.type == NTOFD || redir->nfile.type == NFROMFD) {
-    /* if not ">&-" */
-    if (f >= 0) {
-      if (dup2(f, fd) < 0) {
-        err = errno;
-        goto err;
-      }
-      return;
-    }
-    f = fd;
-  } else if (dup2(f, fd) < 0) {
-    err = errno;
-  }
-  close(f);
-  if (err < 0)
-    goto err;
-  return;
-err:
-  sh_error("%ld: %s", f, strerror(err));
-}
-
-/*
- * Handle here documents.  Normally we fork off a process to write the
- * data to a pipe.  If the document is short, we can stuff the data in
- * the pipe without forking.
- */
-static int64_t openhere(union node *redir) {
-  char *p;
-  int pip[2];
-  unsigned len = 0;
-  if (pipe(pip) < 0)
-    sh_error("Pipe call failed");
-  p = redir->nhere.doc->narg.text;
-  if (redir->type == NXHERE) {
-    expandarg(redir->nhere.doc, NULL, EXP_QUOTED);
-    p = stackblock();
-  }
-  len = strlen(p);
-  if (len <= PIPESIZE) {
-    __xwrite(pip[1], p, len);
-    goto out;
-  }
-  if (forkshell((struct job *)NULL, (union node *)NULL, FORK_NOJOB) == 0) {
-    close(pip[0]);
-    signal(SIGINT, SIG_IGN);
-    signal(SIGQUIT, SIG_IGN);
-    signal(SIGHUP, SIG_IGN);
-    signal(SIGPIPE, SIG_DFL);
-    __xwrite(pip[1], p, len);
-    _exit(0);
-  }
-out:
-  close(pip[1]);
-  return pip[0];
-}
-
-/*
- * Undo the effects of the last redirection.
- */
-static void popredir(int drop) {
-  struct redirtab *rp;
-  int i;
-  INTOFF;
-  rp = redirlist;
-  for (i = 0; i < 10; i++) {
-    int closed;
-    if (rp->renamed[i] == EMPTY)
-      continue;
-    closed = drop ? 1 : update_closed_redirs(i, rp->renamed[i]);
-    switch (rp->renamed[i]) {
-      case CLOSED:
-        if (!closed)
-          close(i);
-        break;
-      default:
-        if (!drop)
-          dup2(rp->renamed[i], i);
-        close(rp->renamed[i]);
-        break;
-    }
-  }
-  redirlist = rp->next;
-  ckfree(rp);
-  INTON;
-}
-
-/*
- * Move a file descriptor to > 10.  Invokes sh_error on error unless
- * the original file dscriptor is not open.
- */
-static int savefd(int from, int ofd) {
-  int newfd;
-  int err;
-  newfd = fcntl(from, F_DUPFD, 10);
-  err = newfd < 0 ? errno : 0;
-  if (err != EBADF) {
-    close(ofd);
-    if (err) {
-      sh_error("%d: %s", from, strerror(err));
-    } else {
-      fcntl(newfd, F_SETFD, FD_CLOEXEC);
-    }
-  }
-  return newfd;
-}
-
-static int redirectsafe(union node *redir, int flags) {
-  int err;
-  volatile int saveint;
-  struct jmploc *volatile savehandler = handler;
-  struct jmploc jmploc;
-  SAVEINT(saveint);
-  if (!(err = setjmp(jmploc.loc) * 2)) {
-    handler = &jmploc;
-    redirect(redir, flags);
-  }
-  handler = savehandler;
-  if (err && exception != EXERROR)
-    longjmp(handler->loc, 1);
-  RESTOREINT(saveint);
-  return err;
-}
-
-static void unwindredir(struct redirtab *stop) {
-  while (redirlist != stop)
-    popredir(0);
-}
-
-static struct redirtab *pushredir(union node *redir) {
-  struct redirtab *sv;
-  struct redirtab *q;
-  int i;
-  q = redirlist;
-  if (!redir)
-    goto out;
-  sv = ckmalloc(sizeof(struct redirtab));
-  sv->next = q;
-  redirlist = sv;
-  for (i = 0; i < 10; i++)
-    sv->renamed[i] = EMPTY;
-out:
-  return q;
-}
-
-/*
- * The trap builtin.
- */
-static int trapcmd(int argc, char **argv) {
-  char *action;
-  char **ap;
-  int signo;
-  nextopt(nullstr);
-  ap = argptr;
-  if (!*ap) {
-    for (signo = 0; signo < NSIG; signo++) {
-      if (trap[signo] != NULL) {
-        out1fmt("trap -- %s %s\n", single_quote(trap[signo]), strsignal(signo));
-      }
-    }
-    return 0;
-  }
-  if (!ap[1] || decode_signum(*ap) >= 0)
-    action = NULL;
-  else
-    action = *ap++;
-  while (*ap) {
-    if ((signo = decode_signal(*ap, 0)) < 0) {
-      outfmt(out2, "trap: %s: bad trap\n", *ap);
-      return 1;
-    }
-    INTOFF;
-    if (action) {
-      if (action[0] == '-' && action[1] == '\0')
-        action = NULL;
-      else {
-        if (*action)
-          trapcnt++;
-        action = savestr(action);
-      }
-    }
-    if (trap[signo]) {
-      if (*trap[signo])
-        trapcnt--;
-      ckfree(trap[signo]);
-    }
-    trap[signo] = action;
-    if (signo != 0)
-      setsignal(signo);
-    INTON;
-    ap++;
-  }
-  return 0;
-}
-
-/*
- * Set the signal handler for the specified signal.  The routine figures
- * out what it should be set to.
- */
-static void setsignal(int signo) {
-  int action;
-  int lvforked;
-  char *t, tsig;
-  struct sigaction act;
-  lvforked = vforked;
-  if ((t = trap[signo]) == NULL)
-    action = S_DFL;
-  else if (*t != '\0')
-    action = S_CATCH;
-  else
-    action = S_IGN;
-  if (rootshell && action == S_DFL && !lvforked) {
-    if (signo == SIGINT) {
-      if (iflag || minusc || sflag == 0)
-        action = S_CATCH;
-    } else if (signo == SIGQUIT || signo == SIGTERM) {
-      if (iflag)
-        action = S_IGN;
-    } else if (signo == SIGTSTP || signo == SIGTTOU) {
-      if (mflag)
-        action = S_IGN;
-    }
-  }
-  if (signo == SIGCHLD)
-    action = S_CATCH;
-  t = &sigmode[signo - 1];
-  tsig = *t;
-  if (tsig == 0) {
-    /*
-     * current setting unknown
-     */
-    if (sigaction(signo, 0, &act) == -1) {
-      /*
-       * Pretend it worked; maybe we should give a warning
-       * here, but other shells don't. We don't alter
-       * sigmode, so that we retry every time.
-       */
-      return;
-    }
-    if (act.sa_handler == SIG_IGN) {
-      if (mflag && (signo == SIGTSTP || signo == SIGTTIN || signo == SIGTTOU)) {
-        tsig = S_IGN; /* don't hard ignore these */
-      } else
-        tsig = S_HARD_IGN;
-    } else {
-      tsig = S_RESET; /* force to be set */
-    }
-  }
-  if (tsig == S_HARD_IGN || tsig == action)
-    return;
-  switch (action) {
-    case S_CATCH:
-      act.sa_handler = onsig;
-      break;
-    case S_IGN:
-      act.sa_handler = SIG_IGN;
-      break;
-    default:
-      act.sa_handler = SIG_DFL;
-  }
-  if (!lvforked)
-    *t = action;
-  act.sa_flags = 0;
-  sigfillset(&act.sa_mask);
-  sigaction(signo, &act, 0);
-}
-
-/*
- * Ignore a signal.
- */
-static void ignoresig(int signo) {
-  if (sigmode[signo - 1] != S_IGN && sigmode[signo - 1] != S_HARD_IGN) {
-    signal(signo, SIG_IGN);
-  }
-  if (!vforked)
-    sigmode[signo - 1] = S_HARD_IGN;
-}
-
-/*
- * Signal handler.
- */
-static void onsig(int signo) {
-  if (vforked)
-    return;
-  if (signo == SIGCHLD) {
-    gotsigchld = 1;
-    if (!trap[SIGCHLD])
-      return;
-  }
-  gotsig[signo - 1] = 1;
-  pending_sig = signo;
-  if (signo == SIGINT && !trap[SIGINT]) {
-    if (!suppressint)
-      onint();
-    intpending = 1;
-  }
-}
-
-/*
- * Called to execute a trap.  Perhaps we should avoid entering new trap
- * handlers while we are executing a trap handler.
- */
-static void dotrap(void) {
-  char *p;
-  char *q;
-  int i;
-  int status, last_status;
-  if (!pending_sig)
-    return;
-  status = savestatus;
-  last_status = status;
-  if (likely(status < 0)) {
-    status = exitstatus;
-    savestatus = status;
-  }
-  pending_sig = 0;
-  barrier();
-  for (i = 0, q = gotsig; i < NSIG - 1; i++, q++) {
-    if (!*q)
-      continue;
-    if (evalskip) {
-      pending_sig = i + 1;
-      break;
-    }
-    *q = 0;
-    p = trap[i + 1];
-    if (!p)
-      continue;
-    evalstring(p, 0);
-    if (evalskip != SKIPFUNC)
-      exitstatus = status;
-  }
-  savestatus = last_status;
-}
-
-/*
- * Controls whether the shell is interactive or not.
- */
-static void setinteractive(int on) {
-  static int is_interactive;
-  if (++on == is_interactive)
-    return;
-  is_interactive = on;
-  setsignal(SIGINT);
-  setsignal(SIGQUIT);
-  setsignal(SIGTERM);
-}
-
-/*
- * Called to exit the shell.
- */
-wontreturn static void exitshell(void) {
-  struct jmploc loc;
-  char *p;
-  savestatus = exitstatus;
-  TRACE(("pid %d, exitshell(%d)\n", getpid(), savestatus));
-  if (setjmp(loc.loc))
-    goto out;
-  handler = &loc;
-  if ((p = trap[0])) {
-    trap[0] = NULL;
-    evalskip = 0;
-    evalstring(p, 0);
-    evalskip = SKIPFUNCDEF;
-  }
-out:
-  exitreset();
-  /*
-   * Disable job control so that whoever had the foreground before we
-   * started can get it back.
-   */
-  if (likely(!setjmp(loc.loc)))
-    setjobctl(0);
-  flushall();
-  _exit(exitstatus);
-}
-
-static int decode_signal(const char *string, int minsig) {
-  int signo;
-  signo = decode_signum(string);
-  if (signo >= 0)
-    return signo;
-  for (signo = minsig; signo < NSIG; signo++) {
-    if (!strcasecmp(string, strsignal(signo))) {
-      return signo;
-    }
-  }
-  return -1;
-}
-
-static void sigblockall(sigset_t *oldmask) {
-  sigset_t mask;
-  sigfillset(&mask);
-  sigprocmask(SIG_SETMASK, &mask, oldmask);
-}
-
-#define PF(f, func)                                \
-  {                                                \
-    switch ((char *)param - (char *)array) {       \
-      default:                                     \
-        (void)Printf(f, array[0], array[1], func); \
-        break;                                     \
-      case sizeof(*param):                         \
-        (void)Printf(f, array[0], func);           \
-        break;                                     \
-      case 0:                                      \
-        (void)Printf(f, func);                     \
-        break;                                     \
-    }                                              \
-  }
-
-#define ASPF(sp, f, func)                                 \
-  ({                                                      \
-    int ret;                                              \
-    switch ((char *)param - (char *)array) {              \
-      default:                                            \
-        ret = Xasprintf(sp, f, array[0], array[1], func); \
-        break;                                            \
-      case sizeof(*param):                                \
-        ret = Xasprintf(sp, f, array[0], func);           \
-        break;                                            \
-      case 0:                                             \
-        ret = Xasprintf(sp, f, func);                     \
-        break;                                            \
-    }                                                     \
-    ret;                                                  \
-  })
-
-static int print_escape_str(const char *f, int *param, int *array, char *s) {
-  struct stackmark smark;
-  char *p, *q;
-  int done;
-  int len;
-  int total;
-  setstackmark(&smark);
-  done = conv_escape_str(s, &q);
-  p = stackblock();
-  len = q - p;
-  total = len - 1;
-  q[-1] = (!!((f[1] - 's') | done) - 1) & f[2];
-  total += !!q[-1];
-  if (f[1] == 's')
-    goto easy;
-  p = makestrspace(len, q);
-  memset(p, 'X', total);
-  p[total] = 0;
-  q = stackblock();
-  total = ASPF(&p, f, p);
-  len = strchrnul(p, 'X') - p;
-  memcpy(p + len, q, strspn(p + len, "X"));
-easy:
-  outmem(p, total, out1);
-  popstackmark(&smark);
-  return done;
-}
-
-static int printfcmd(int argc, char *argv[]) {
-  static const char kSkip1[] = "#-+ 0";
-  static const char kSkip2[] = "*0123456789";
-  char *fmt;
-  char *format;
-  int ch;
-  rval = 0;
-  nextopt(nullstr);
-  argv = argptr;
-  format = *argv;
-  if (!format)
-    sh_error("usage: printf format [arg ...]");
-  gargv = ++argv;
-  do {
-    /*
-     * Basic algorithm is to scan the format string for conversion
-     * specifications -- once one is found, find out if the field
-     * width or precision is a '*'; if it is, gather up value.
-     * Note, format strings are reused as necessary to use up the
-     * provided arguments, arguments of zero/null string are
-     * provided to use up the format string.
-     */
-    /* find next format specification */
-    for (fmt = format; (ch = *fmt++);) {
-      char *start;
-      char nextch;
-      int array[2];
-      int *param;
-      if (ch == '\\') {
-        int c_ch;
-        fmt = conv_escape(fmt, &c_ch);
-        ch = c_ch;
-        goto pc;
-      }
-      if (ch != '%' || (*fmt == '%' && (++fmt || 1))) {
-      pc:
-        outc(ch, out1);
-        continue;
-      }
-      /* Ok - we've found a format specification,
-         Save its address for a later printf(). */
-      start = fmt - 1;
-      param = array;
-      /* skip to field width */
-      fmt += strspn(fmt, kSkip1);
-      if (*fmt == '*') {
-        ++fmt;
-        *param++ = getuintmax(1);
-      } else {
-        /* skip to possible '.',
-         * get following precision
-         */
-        fmt += strspn(fmt, kSkip2);
-      }
-      if (*fmt == '.') {
-        ++fmt;
-        if (*fmt == '*') {
-          ++fmt;
-          *param++ = getuintmax(1);
-        } else
-          fmt += strspn(fmt, kSkip2);
-      }
-      ch = *fmt;
-      if (!ch)
-        sh_error("missing format character");
-      /* null terminate format string to we can use it
-         as an argument to printf. */
-      nextch = fmt[1];
-      fmt[1] = 0;
-      switch (ch) {
-        case 'b':
-          *fmt = 's';
-          /* escape if a \c was encountered */
-          if (print_escape_str(start, param, array, getstr()))
-            goto out;
-          *fmt = 'b';
-          break;
-        case 'c': {
-          int p = getchr();
-          PF(start, p);
-          break;
-        }
-        case 's': {
-          char *p = getstr();
-          PF(start, p);
-          break;
-        }
-        case 'd':
-        case 'i': {
-          uint64_t p = getuintmax(1);
-          start = mklong(start, fmt);
-          PF(start, p);
-          break;
-        }
-        case 'o':
-        case 'u':
-        case 'x':
-        case 'X': {
-          uint64_t p = getuintmax(0);
-          start = mklong(start, fmt);
-          PF(start, p);
-          break;
-        }
-        case 'a':
-        case 'A':
-        case 'e':
-        case 'E':
-        case 'f':
-        case 'F':
-        case 'g':
-        case 'G': {
-          double p = getdouble();
-          PF(start, p);
-          break;
-        }
-        default:
-          sh_error("%s: invalid directive", start);
-      }
-      *++fmt = nextch;
-    }
-  } while (gargv != argv && *gargv);
-out:
-  return rval;
-}
-
-/*
- * Print SysV echo(1) style escape string
- *  Halts processing string if a \c escape is encountered.
- */
-static int conv_escape_str(char *str, char **sp) {
-  int c;
-  int ch;
-  char *cp;
-  /* convert string into a temporary buffer... */
-  STARTSTACKSTR(cp);
-  do {
-    c = ch = *str++;
-    if (ch != '\\')
-      continue;
-    c = *str++;
-    if (c == 'c') {
-      /* \c as in SYSV echo - abort all processing.... */
-      c = ch = 0x100;
-      continue;
-    }
-    /*
-     * %b string octal constants are not like those in C.
-     * They start with a \0, and are followed by 0, 1, 2,
-     * or 3 octal digits.
-     */
-    if (c == '0' && isodigit(*str))
-      str++;
-    /* Finally test for sequences valid in the format string */
-    str = conv_escape(str - 1, &c);
-  } while (STPUTC(c, cp), (char)ch);
-  *sp = cp;
-  return ch;
-}
-
-/*
- * Print "standard" escape characters
- */
-static char *conv_escape(char *str, int *conv_ch) {
-  int value;
-  int ch;
-  ch = *str;
-  switch (ch) {
-    default:
-      if (!isodigit(*str)) {
-        value = '\\';
-        goto out;
-      }
-      ch = 3;
-      value = 0;
-      do {
-        value <<= 3;
-        value += octtobin(*str++);
-      } while (isodigit(*str) && --ch);
-      goto out;
-    case '\\':
-      value = '\\';
-      break; /* backslash */
-    case 'a':
-      value = '\a';
-      break; /* alert */
-    case 'b':
-      value = '\b';
-      break; /* backspace */
-    case 'f':
-      value = '\f';
-      break; /* form-feed */
-    case 'e':
-      value = '\e';
-      break; /* escape */
-    case 'n':
-      value = '\n';
-      break; /* newline */
-    case 'r':
-      value = '\r';
-      break; /* carriage-return */
-    case 't':
-      value = '\t';
-      break; /* tab */
-    case 'v':
-      value = '\v';
-      break; /* vertical-tab */
-  }
-  str++;
-out:
-  *conv_ch = value;
-  return str;
-}
-
-#define PRIdMAX "ld"
-
-static char *mklong(const char *str, const char *ch) {
-  /*
-   * Replace a string like "%92.3u" with "%92.3"PRIuMAX.
-   *
-   * Although C99 does not guarantee it, we assume PRIiMAX,
-   * PRIoMAX, PRIuMAX, PRIxMAX, and PRIXMAX are all the same
-   * as PRIdMAX with the final 'd' replaced by the corresponding
-   * character.
-   */
-  char *copy;
-  unsigned len;
-  len = ch - str + sizeof(PRIdMAX);
-  STARTSTACKSTR(copy);
-  copy = makestrspace(len, copy);
-  memcpy(copy, str, len - sizeof(PRIdMAX));
-  memcpy(copy + len - sizeof(PRIdMAX), PRIdMAX, sizeof(PRIdMAX));
-  copy[len - 2] = *ch;
-  return (copy);
-}
-
-static uint64_t getuintmax(int sign) {
-  uint64_t val = 0;
-  char *cp, *ep;
-  cp = *gargv;
-  if (cp == NULL)
-    goto out;
-  gargv++;
-  val = (unsigned char)cp[1];
-  if (*cp == '\"' || *cp == '\'')
-    goto out;
-  errno = 0;
-  val = sign ? strtoimax(cp, &ep, 0) : strtoumax(cp, &ep, 0);
-  check_conversion(cp, ep);
-out:
-  return val;
-}
-
-static double getdouble(void) {
-  double val;
-  char *cp, *ep;
-  cp = *gargv;
-  if (cp == NULL)
-    return 0;
-  gargv++;
-  if (*cp == '\"' || *cp == '\'')
-    return (unsigned char)cp[1];
-  errno = 0;
-  val = strtod(cp, &ep);
-  check_conversion(cp, ep);
-  return val;
-}
-
-static void check_conversion(const char *s, const char *ep) {
-  if (*ep) {
-    if (ep == s)
-      sh_warnx("%s: expected numeric value", s);
-    else
-      sh_warnx("%s: not completely converted", s);
-    rval = 1;
-  } else if (errno == ERANGE) {
-    sh_warnx("%s: %s", s, strerror(ERANGE));
-    rval = 1;
-  }
-}
-
-static int echocmd(int argc, char **argv) {
-  const char *lastfmt = snlfmt;
-  int nonl;
-  if (*++argv && equal(*argv, "-n")) {
-    argv++;
-    lastfmt = "%s";
-  }
-  do {
-    const char *fmt = "%s ";
-    char *s = *argv;
-    if (!s || !*++argv)
-      fmt = lastfmt;
-    nonl = print_escape_str(fmt, NULL, NULL, s ?: nullstr);
-  } while (!nonl && *argv);
-  return 0;
-}
-
-/*
- * test(1); version 7-like  --  author Erik Baalbergen
- * modified by Eric Gisin to be used as built-in.
- * modified by Arnold Robbins to add SVR3 compatibility
- * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
- * modified by J.T. Conklin for NetBSD.
- *
- * This program is in the Public Domain.
- */
-
-/* test(1) accepts the following grammar:
-        oexpr ::= aexpr | aexpr "-o" oexpr ;
-        aexpr ::= nexpr | nexpr "-a" aexpr ;
-        nexpr ::= primary | "!" primary
-        primary ::= unary-operator operand
-                | operand binary-operator operand
-                | operand
-                | "(" oexpr ")"
-                ;
-        unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"|
-                "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S";
-        binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
-                        "-nt"|"-ot"|"-ef";
-        operand ::= <any legal UNIX file name>
-*/
-
-static inline int faccessat_confused_about_superuser(void) {
-  return 0;
-}
-
-static const struct t_op *getop(const char *s) {
-  const struct t_op *op;
-  for (op = ops; op->op_text; op++) {
-    if (strcmp(s, op->op_text) == 0)
-      return op;
-  }
-  return NULL;
-}
-
-static int testcmd(int argc, char **argv) {
-  const struct t_op *op;
-  enum token n;
-  int res = 1;
-  if (*argv[0] == '[') {
-    if (*argv[--argc] != ']')
-      sh_error("missing ]");
-    argv[argc] = NULL;
-  }
-  t_wp_op = NULL;
-recheck:
-  argv++;
-  argc--;
-  if (argc < 1)
-    return res;
-  /*
-   * POSIX prescriptions: he who wrote this deserves the Nobel
-   * peace prize.
-   */
-  switch (argc) {
-    case 3:
-      op = getop(argv[1]);
-      if (op && op->op_type == BINOP) {
-        n = OPERAND;
-        goto eval;
-      }
-      /* fall through */
-    case 4:
-      if (!strcmp(argv[0], "(") && !strcmp(argv[argc - 1], ")")) {
-        argv[--argc] = NULL;
-        argv++;
-        argc--;
-      } else if (!strcmp(argv[0], "!")) {
-        res = 0;
-        goto recheck;
-      }
-  }
-  n = t_lex(argv);
-eval:
-  t_wp = argv;
-  res ^= oexpr(n);
-  argv = t_wp;
-  if (argv[0] != NULL && argv[1] != NULL)
-    syntax(argv[0], "unexpected operator");
-  return res;
-}
-
-static void syntax(const char *op, const char *msg) {
-  if (op && *op) {
-    sh_error("%s: %s", op, msg);
-  } else {
-    sh_error("%s", msg);
-  }
-}
-
-static int oexpr(enum token n) {
-  int res = 0;
-  for (;;) {
-    res |= aexpr(n);
-    n = t_lex(t_wp + 1);
-    if (n != BOR)
-      break;
-    n = t_lex(t_wp += 2);
-  }
-  return res;
-}
-
-static int aexpr(enum token n) {
-  int res = 1;
-  for (;;) {
-    if (!nexpr(n))
-      res = 0;
-    n = t_lex(t_wp + 1);
-    if (n != BAND)
-      break;
-    n = t_lex(t_wp += 2);
-  }
-  return res;
-}
-
-static int nexpr(enum token n) {
-  if (n != UNOT)
-    return primary1(n);
-  n = t_lex(t_wp + 1);
-  if (n != EOI)
-    t_wp++;
-  return !nexpr(n);
-}
-
-static int primary1(enum token n) {
-  enum token nn;
-  int res;
-  if (n == EOI)
-    return 0; /* missing expression */
-  if (n == LPAREN) {
-    if ((nn = t_lex(++t_wp)) == RPAREN)
-      return 0; /* missing expression */
-    res = oexpr(nn);
-    if (t_lex(++t_wp) != RPAREN)
-      syntax(NULL, "closing paren expected");
-    return res;
-  }
-  if (t_wp_op && t_wp_op->op_type == UNOP) {
-    /* unary expression */
-    if (*++t_wp == NULL)
-      syntax(t_wp_op->op_text, "argument expected");
-    switch (n) {
-      case STREZ:
-        return strlen(*t_wp) == 0;
-      case STRNZ:
-        return strlen(*t_wp) != 0;
-      case FILTT:
-        return isatty(getn(*t_wp));
-      case FILRD:
-        return test_file_access(*t_wp, R_OK);
-      case FILWR:
-        return test_file_access(*t_wp, W_OK);
-      case FILEX:
-        return test_file_access(*t_wp, X_OK);
-      default:
-        return filstat(*t_wp, n);
-    }
-  }
-  if (t_lex(t_wp + 1), t_wp_op && t_wp_op->op_type == BINOP) {
-    return binop0();
-  }
-  return strlen(*t_wp) > 0;
-}
-
-static int binop0(void) {
-  const char *opnd1, *opnd2;
-  struct t_op const *op;
-  opnd1 = *t_wp;
-  (void)t_lex(++t_wp);
-  op = t_wp_op;
-  if ((opnd2 = *++t_wp) == (char *)0)
-    syntax(op->op_text, "argument expected");
-  switch (op->op_num) {
-    default:
-    case STREQ:
-      return strcmp(opnd1, opnd2) == 0;
-    case STRNE:
-      return strcmp(opnd1, opnd2) != 0;
-    case STRLT:
-      return strcmp(opnd1, opnd2) < 0;
-    case STRGT:
-      return strcmp(opnd1, opnd2) > 0;
-    case INTEQ:
-      return getn(opnd1) == getn(opnd2);
-    case INTNE:
-      return getn(opnd1) != getn(opnd2);
-    case INTGE:
-      return getn(opnd1) >= getn(opnd2);
-    case INTGT:
-      return getn(opnd1) > getn(opnd2);
-    case INTLE:
-      return getn(opnd1) <= getn(opnd2);
-    case INTLT:
-      return getn(opnd1) < getn(opnd2);
-    case FILNT:
-      return newerf(opnd1, opnd2);
-    case FILOT:
-      return olderf(opnd1, opnd2);
-    case FILEQ:
-      return equalf(opnd1, opnd2);
-  }
-}
-
-static int filstat(char *nm, enum token mode) {
-  struct stat s;
-  if (mode == FILSYM ? lstat(nm, &s) : stat(nm, &s))
-    return 0;
-  switch (mode) {
-    case FILEXIST:
-      return 1;
-    case FILREG:
-      return S_ISREG(s.st_mode);
-    case FILDIR:
-      return S_ISDIR(s.st_mode);
-    case FILCDEV:
-      return S_ISCHR(s.st_mode);
-    case FILBDEV:
-      return S_ISBLK(s.st_mode);
-    case FILFIFO:
-      return S_ISFIFO(s.st_mode);
-    case FILSOCK:
-      return S_ISSOCK(s.st_mode);
-    case FILSYM:
-      return S_ISLNK(s.st_mode);
-    case FILSUID:
-      return (s.st_mode & S_ISUID) != 0;
-    case FILSGID:
-      return (s.st_mode & S_ISGID) != 0;
-    case FILSTCK:
-      return (s.st_mode & S_ISVTX) != 0;
-    case FILGZ:
-      return !!s.st_size;
-    case FILUID:
-      return s.st_uid == geteuid();
-    case FILGID:
-      return s.st_gid == getegid();
-    default:
-      return 1;
-  }
-}
-
-static enum token t_lex(char **tp) {
-  struct t_op const *op;
-  char *s = *tp;
-  if (s == 0) {
-    t_wp_op = (struct t_op *)0;
-    return EOI;
-  }
-  op = getop(s);
-  if (op && !(op->op_type == UNOP && isoperand(tp)) &&
-      !(op->op_num == LPAREN && !tp[1])) {
-    t_wp_op = op;
-    return op->op_num;
-  }
-  t_wp_op = (struct t_op *)0;
-  return OPERAND;
-}
-
-static int isoperand(char **tp) {
-  struct t_op const *op;
-  char *s;
-  if (!(s = tp[1]))
-    return 1;
-  if (!tp[2])
-    return 0;
-  op = getop(s);
-  return op && op->op_type == BINOP;
-}
-
-static int newerf(const char *f1, const char *f2) {
-  struct stat b1, b2;
-  return (stat(f1, &b1) == 0 && stat(f2, &b2) == 0 &&
-          (b1.st_mtim.tv_sec > b2.st_mtim.tv_sec ||
-           (b1.st_mtim.tv_sec == b2.st_mtim.tv_sec &&
-            (b1.st_mtim.tv_nsec > b2.st_mtim.tv_nsec))));
-}
-
-static int olderf(const char *f1, const char *f2) {
-  struct stat b1, b2;
-  return (stat(f1, &b1) == 0 && stat(f2, &b2) == 0 &&
-          (b1.st_mtim.tv_sec < b2.st_mtim.tv_sec ||
-           (b1.st_mtim.tv_sec == b2.st_mtim.tv_sec &&
-            (b1.st_mtim.tv_nsec < b2.st_mtim.tv_nsec))));
-}
-
-static int equalf(const char *f1, const char *f2) {
-  struct stat b1, b2;
-  return (stat(f1, &b1) == 0 && stat(f2, &b2) == 0 && b1.st_dev == b2.st_dev &&
-          b1.st_ino == b2.st_ino);
-}
-
-static int has_exec_bit_set(const char *path) {
-  struct stat st;
-  if (stat(path, &st))
-    return 0;
-  return st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH);
-}
-
-static int test_file_access(const char *path, int mode) {
-  if (faccessat_confused_about_superuser() && mode == X_OK && geteuid() == 0 &&
-      !has_exec_bit_set(path)) {
-    return 0;
-  }
-  return !faccessat(AT_FDCWD, path, mode, AT_EACCESS);
-}
-
-static int timescmd() {
-  struct tms buf;
-  long int clk_tck = sysconf(_SC_CLK_TCK);
-  int mutime, mstime, mcutime, mcstime;
-  double utime, stime, cutime, cstime;
-  times(&buf);
-  utime = (double)buf.tms_utime / clk_tck;
-  mutime = utime / 60;
-  utime -= mutime * 60.0;
-  stime = (double)buf.tms_stime / clk_tck;
-  mstime = stime / 60;
-  stime -= mstime * 60.0;
-  cutime = (double)buf.tms_cutime / clk_tck;
-  mcutime = cutime / 60;
-  cutime -= mcutime * 60.0;
-  cstime = (double)buf.tms_cstime / clk_tck;
-  mcstime = cstime / 60;
-  cstime -= mcstime * 60.0;
-  Printf("%dm%fs %dm%fs\n%dm%fs %dm%fs\n", mutime, utime, mstime, stime,
-         mcutime, cutime, mcstime, cstime);
-  return 0;
-}
-
-/*
- * Find the appropriate entry in the hash table from the name.
- */
-static struct Var **hashvar(const char *p) {
-  unsigned int hashval;
-  hashval = ((unsigned char)*p) << 4;
-  while (*p && *p != '=')
-    hashval += (unsigned char)*p++;
-  return &vartab[hashval % VTABSIZE];
-}
-
-/*
- * This routine initializes the builtin variables.  It is called when the
- * shell is initialized.
- */
-static void initvar(void) {
-  struct Var *vp;
-  struct Var *end;
-  struct Var **vpp;
-  vp = varinit;
-  end = vp + sizeof(varinit) / sizeof(varinit[0]);
-  do {
-    vpp = hashvar(vp->text);
-    vp->next = *vpp;
-    *vpp = vp;
-  } while (++vp < end);
-  /* PS1 depends on uid */
-  if (!geteuid()) {
-    vps1.text = "PS1=# ";
-  }
-}
-
-/*
- * Set the value of a variable.  The flags argument is ored with the
- * flags of the variable.  If val is NULL, the variable is unset.
- */
-static struct Var *setvar(const char *name, const char *val, int flags) {
-  char *p, *q;
-  unsigned namelen;
-  char *nameeq;
-  unsigned vallen;
-  struct Var *vp;
-  q = endofname(name);
-  p = strchrnul(q, '=');
-  namelen = p - name;
-  if (!namelen || p != q)
-    sh_error("%.*s: bad variable name", namelen, name);
-  vallen = 0;
-  if (val == NULL) {
-    flags |= VUNSET;
-  } else {
-    vallen = strlen(val);
-  }
-  INTOFF;
-  p = mempcpy(nameeq = ckmalloc(namelen + vallen + 2), name, namelen);
-  if (val) {
-    *p++ = '=';
-    p = mempcpy(p, val, vallen);
-  }
-  *p = '\0';
-  vp = setvareq(nameeq, flags | VNOSAVE);
-  INTON;
-  return vp;
-}
-
-/*
- * Set the given integer as the value of a variable.  The flags argument is
- * ored with the flags of the variable.
- */
-static int64_t setvarint(const char *name, int64_t val, int flags) {
-  int len = max_int_length(sizeof(val));
-  char buf[len];
-  fmtstr(buf, len, "%ld", val);
-  setvar(name, buf, flags);
-  return val;
-}
-
-static struct Var **findvar(struct Var **vpp, const char *name) {
-  for (; *vpp; vpp = &(*vpp)->next) {
-    if (varequal((*vpp)->text, name)) {
-      break;
-    }
-  }
-  return vpp;
-}
-
-/*
- * Same as setvar except that the variable and value are passed in
- * the first argument as name=value.  Since the first argument will
- * be actually stored in the table, it should not be a string that
- * will go away.
- * Called with interrupts off.
- */
-static struct Var *setvareq(char *s, int flags) {
-  struct Var *vp, **vpp;
-  vpp = hashvar(s);
-  flags |= (VEXPORT & (((unsigned)(1 - aflag)) - 1));
-  vpp = findvar(vpp, s);
-  vp = *vpp;
-  if (vp) {
-    if (vp->flags & VREADONLY) {
-      const char *n;
-      if (flags & VNOSAVE)
-        free(s);
-      n = vp->text;
-      sh_error("%.*s: is read only", strchrnul(n, '=') - n, n);
-    }
-    if (flags & VNOSET)
-      goto out;
-    if (vp->func && (flags & VNOFUNC) == 0)
-      (*vp->func)(strchrnul(s, '=') + 1);
-    if ((vp->flags & (VTEXTFIXED | VSTACK)) == 0)
-      ckfree(vp->text);
-    if (((flags & (VEXPORT | VREADONLY | VSTRFIXED | VUNSET)) |
-         (vp->flags & VSTRFIXED)) == VUNSET) {
-      *vpp = vp->next;
-      ckfree(vp);
-    out_free:
-      if ((flags & (VTEXTFIXED | VSTACK | VNOSAVE)) == VNOSAVE)
-        ckfree(s);
-      goto out;
-    }
-    flags |= vp->flags & ~(VTEXTFIXED | VSTACK | VNOSAVE | VUNSET);
-  } else {
-    if (flags & VNOSET)
-      goto out;
-    if ((flags & (VEXPORT | VREADONLY | VSTRFIXED | VUNSET)) == VUNSET)
-      goto out_free;
-    /* not found */
-    vp = ckmalloc(sizeof(*vp));
-    vp->next = *vpp;
-    vp->func = NULL;
-    *vpp = vp;
-  }
-  if (!(flags & (VTEXTFIXED | VSTACK | VNOSAVE)))
-    s = savestr(s);
-  vp->text = s;
-  vp->flags = flags;
-out:
-  return vp;
-}
-
-/*
- * Find the value of a variable.  Returns NULL if not set.
- */
-static char *lookupvar(const char *name) {
-  struct Var *v;
-  if ((v = *findvar(hashvar(name), name)) && !(v->flags & VUNSET)) {
-    if (v == &vlineno && v->text == linenovar) {
-      fmtstr(linenovar + 7, sizeof(linenovar) - 7, "%d", lineno);
-    }
-    return strchrnul(v->text, '=') + 1;
-  }
-  return NULL;
-}
-
-static int64_t lookupvarint(const char *name) {
-  return atomax(lookupvar(name) ?: nullstr, 0);
-}
-
-/*
- * Generate a list of variables satisfying the given conditions.
- */
-static char **listvars(int on, int off, char ***end) {
-  struct Var **vpp;
-  struct Var *vp;
-  char **ep;
-  int mask;
-  STARTSTACKSTR(ep);
-  vpp = vartab;
-  mask = on | off;
-  do {
-    for (vp = *vpp; vp; vp = vp->next)
-      if ((vp->flags & mask) == on) {
-        if (ep == stackstrend())
-          ep = growstackstr();
-        *ep++ = (char *)vp->text;
-      }
-  } while (++vpp < vartab + VTABSIZE);
-  if (ep == stackstrend())
-    ep = growstackstr();
-  if (end)
-    *end = ep;
-  *ep++ = NULL;
-  return grabstackstr(ep);
-}
-
-static int vpcmp(const void *a, const void *b) {
-  return varcmp(*(const char **)a, *(const char **)b);
-}
-
-/*
- * POSIX requires that 'set' (but not export or readonly) output the
- * variables in lexicographic order - by the locale's collating order (sigh).
- * Maybe we could keep them in an ordered balanced binary tree
- * instead of hashed lists.
- * For now just roll 'em through qsort for printing...
- */
-static int showvars(const char *prefix, int on, int off) {
-  const char *sep;
-  char **ep, **epend;
-  ep = listvars(on, off, &epend);
-  qsort(ep, epend - ep, sizeof(char *), vpcmp);
-  sep = *prefix ? spcstr : prefix;
-  for (; ep < epend; ep++) {
-    const char *p;
-    const char *q;
-    p = strchrnul(*ep, '=');
-    q = nullstr;
-    if (*p)
-      q = single_quote(++p);
-    out1fmt("%s%s%.*s%s\n", prefix, sep, (int)(p - *ep), *ep, q);
-  }
-  return 0;
-}
-
-/*
- * The export and readonly commands.
- */
-static int exportcmd(int argc, char **argv) {
-  struct Var *vp;
-  char *name;
-  const char *p;
-  char **aptr;
-  int flag = argv[0][0] == 'r' ? VREADONLY : VEXPORT;
-  int notp;
-  notp = nextopt("p") - 'p';
-  if (notp && ((name = *(aptr = argptr)))) {
-    do {
-      if ((p = strchr(name, '=')) != NULL) {
-        p++;
-      } else {
-        if ((vp = *findvar(hashvar(name), name))) {
-          vp->flags |= flag;
-          continue;
-        }
-      }
-      setvar(name, p, flag);
-    } while ((name = *++aptr) != NULL);
-  } else {
-    showvars(argv[0], flag, 0);
-  }
-  return 0;
-}
-
-/*
- * The "local" command.
- */
-static int localcmd(int argc, char **argv) {
-  char *name;
-  if (!localvar_stack)
-    sh_error("not in a function");
-  argv = argptr;
-  while ((name = *argv++) != NULL) {
-    mklocal(name, 0);
-  }
-  return 0;
-}
-
-/*
- * Make a variable a local variable.  When a variable is made local, it's
- * value and flags are saved in a localvar structure.  The saved values
- * will be restored when the shell function returns.  We handle the name
- * "-" as a special case.
- */
-static void mklocal(char *name, int flags) {
-  struct localvar *lvp;
-  struct Var **vpp;
-  struct Var *vp;
-  INTOFF;
-  lvp = ckmalloc(sizeof(struct localvar));
-  if (name[0] == '-' && name[1] == '\0') {
-    char *p;
-    p = ckmalloc(sizeof(optlist));
-    lvp->text = memcpy(p, optlist, sizeof(optlist));
-    vp = NULL;
-  } else {
-    char *eq;
-    vpp = hashvar(name);
-    vp = *findvar(vpp, name);
-    eq = strchr(name, '=');
-    if (vp == NULL) {
-      if (eq)
-        vp = setvareq(name, VSTRFIXED | flags);
-      else
-        vp = setvar(name, NULL, VSTRFIXED | flags);
-      lvp->flags = VUNSET;
-    } else {
-      lvp->text = vp->text;
-      lvp->flags = vp->flags;
-      vp->flags |= VSTRFIXED | VTEXTFIXED;
-      if (eq)
-        setvareq(name, flags);
-    }
-  }
-  lvp->vp = vp;
-  lvp->next = localvar_stack->lv;
-  localvar_stack->lv = lvp;
-  INTON;
-}
-
-/*
- * Called after a function returns.
- * Interrupts must be off.
- */
-static void poplocalvars(void) {
-  struct localvar_list *ll;
-  struct localvar *lvp, *next;
-  struct Var *vp;
-  INTOFF;
-  ll = localvar_stack;
-  localvar_stack = ll->next;
-  next = ll->lv;
-  ckfree(ll);
-  while ((lvp = next) != NULL) {
-    next = lvp->next;
-    vp = lvp->vp;
-    TRACE(("poplocalvar %s\n", vp ? vp->text : "-"));
-    if (vp == NULL) { /* $- saved */
-      memcpy(optlist, lvp->text, sizeof(optlist));
-      ckfree(lvp->text);
-      optschanged();
-    } else if (lvp->flags == VUNSET) {
-      vp->flags &= ~(VSTRFIXED | VREADONLY);
-      unsetvar(vp->text);
-    } else {
-      if (vp->func)
-        (*vp->func)(strchrnul(lvp->text, '=') + 1);
-      if ((vp->flags & (VTEXTFIXED | VSTACK)) == 0)
-        ckfree(vp->text);
-      vp->flags = lvp->flags;
-      vp->text = lvp->text;
-    }
-    ckfree(lvp);
-  }
-  INTON;
-}
-
-/*
- * Create a new localvar environment.
- */
-static struct localvar_list *pushlocalvars(int push) {
-  struct localvar_list *ll;
-  struct localvar_list *top;
-  top = localvar_stack;
-  if (!push)
-    goto out;
-  INTOFF;
-  ll = ckmalloc(sizeof(*ll));
-  ll->lv = NULL;
-  ll->next = top;
-  localvar_stack = ll;
-  INTON;
-out:
-  return top;
-}
-
-static void unwindlocalvars(struct localvar_list *stop) {
-  while (localvar_stack != stop)
-    poplocalvars();
-}
-
-/*
- * The unset builtin command.  We unset the function before we unset the
- * variable to allow a function to be unset when there is a readonly variable
- * with the same name.
- */
-static int unsetcmd(int argc, char **argv) {
-  char **ap;
-  int i;
-  int flag = 0;
-  while ((i = nextopt("vf")) != '\0') {
-    flag = i;
-  }
-  for (ap = argptr; *ap; ap++) {
-    if (flag != 'f') {
-      unsetvar(*ap);
-      continue;
-    }
-    if (flag != 'v')
-      unsetfunc(*ap);
-  }
-  return 0;
-}
-
-static void unsetvar(const char *s) {
-  setvar(s, 0, 0);
-}
-
-/*
- * Initialization code.
- */
-static void init() {
-  /* from input.c: */
-  {
-    basepf.nextc = basepf.buf = basebuf;
-    basepf.linno = 1;
-  }
-  /* from trap.c: */
-  {
-    sigmode[SIGCHLD - 1] = S_DFL;
-    setsignal(SIGCHLD);
-  }
-  /* from var.c: */
-  {
-    char **envp;
-    static char ppid[32] = "PPID=";
-    const char *p;
-    struct stat st1, st2;
-    initvar();
-    for (envp = environ; *envp; envp++) {
-      p = endofname(*envp);
-      if (p != *envp && *p == '=') {
-        setvareq(*envp, VEXPORT | VTEXTFIXED);
-      }
-    }
-    setvareq(defifsvar, VTEXTFIXED);
-    setvareq(defoptindvar, VTEXTFIXED);
-    fmtstr(ppid + 5, sizeof(ppid) - 5, "%ld", (long)getppid());
-    setvareq(ppid, VTEXTFIXED);
-    p = lookupvar("PWD");
-    if (p) {
-      if (*p != '/' || stat(p, &st1) || stat(".", &st2) ||
-          st1.st_dev != st2.st_dev || st1.st_ino != st2.st_ino) {
-        p = 0;
-      }
-    }
-    setpwd(p, 0);
-  }
-}
-
-/*
- * This routine is called when an error or an interrupt occurs in an
- * interactive shell and control is returned to the main command loop
- * but prior to exitshell.
- */
-static void exitreset() {
-  /* from eval.c: */
-  {
-    if (savestatus >= 0) {
-      if (exception == EXEXIT || evalskip == SKIPFUNCDEF)
-        exitstatus = savestatus;
-      savestatus = -1;
-    }
-    evalskip = 0;
-    loopnest = 0;
-    inps4 = 0;
-  }
-  /* from expand.c: */
-  { ifsfree(); }
-  /* from redir.c: */
-  {
-    /*
-     * Discard all saved file descriptors.
-     */
-    unwindredir(0);
-  }
-}
-
-/*
- * This routine is called when we enter a subshell.
- */
-static void forkreset() {
-  /* from input.c: */
-  {
-    popallfiles();
-    if (parsefile->fd > 0) {
-      close(parsefile->fd);
-      parsefile->fd = 0;
-    }
-  }
-  /* from main.c: */
-  { handler = &main_handler; }
-  /* from redir.c: */
-  { redirlist = NULL; }
-  /* from trap.c: */
-  {
-    char **tp;
-    INTOFF;
-    for (tp = trap; tp < &trap[NSIG]; tp++) {
-      if (*tp && **tp) { /* trap not NULL or SIG_IGN */
-        ckfree(*tp);
-        *tp = NULL;
-        if (tp != &trap[0])
-          setsignal(tp - trap);
-      }
-    }
-    trapcnt = 0;
-    INTON;
-  }
-}
-
-/*
- * This routine is called when an error or an interrupt occurs in an
- * interactive shell and control is returned to the main command loop.
- */
-static void reset() {
-  /* from input.c: */
-  {
-    /* clear input buffer */
-    basepf.lleft = basepf.nleft = 0;
-    basepf.unget = 0;
-    popallfiles();
-  }
-  /* from var.c: */
-  { unwindlocalvars(0); }
-}
-
-static void calcsize(union node *n) {
-  if (n == NULL)
-    return;
-  funcblocksize += nodesize[n->type];
-  switch (n->type) {
-    case NCMD:
-      calcsize(n->ncmd.redirect);
-      calcsize(n->ncmd.args);
-      calcsize(n->ncmd.assign);
-      break;
-    case NPIPE:
-      sizenodelist(n->npipe.cmdlist);
-      break;
-    case NREDIR:
-    case NBACKGND:
-    case NSUBSHELL:
-      calcsize(n->nredir.redirect);
-      calcsize(n->nredir.n);
-      break;
-    case NAND:
-    case NOR:
-    case NSEMI:
-    case NWHILE:
-    case NUNTIL:
-      calcsize(n->nbinary.ch2);
-      calcsize(n->nbinary.ch1);
-      break;
-    case NIF:
-      calcsize(n->nif.elsepart);
-      calcsize(n->nif.ifpart);
-      calcsize(n->nif.test);
-      break;
-    case NFOR:
-      funcstringsize += strlen(n->nfor.var_) + 1;
-      calcsize(n->nfor.body);
-      calcsize(n->nfor.args);
-      break;
-    case NCASE:
-      calcsize(n->ncase.cases);
-      calcsize(n->ncase.expr);
-      break;
-    case NCLIST:
-      calcsize(n->nclist.body);
-      calcsize(n->nclist.pattern);
-      calcsize(n->nclist.next);
-      break;
-    case NDEFUN:
-      calcsize(n->ndefun.body);
-      funcstringsize += strlen(n->ndefun.text) + 1;
-      break;
-    case NARG:
-      sizenodelist(n->narg.backquote);
-      funcstringsize += strlen(n->narg.text) + 1;
-      calcsize(n->narg.next);
-      break;
-    case NTO:
-    case NCLOBBER:
-    case NFROM:
-    case NFROMTO:
-    case NAPPEND:
-      calcsize(n->nfile.fname);
-      calcsize(n->nfile.next);
-      break;
-    case NTOFD:
-    case NFROMFD:
-      calcsize(n->ndup.vname);
-      calcsize(n->ndup.next);
-      break;
-    case NHERE:
-    case NXHERE:
-      calcsize(n->nhere.doc);
-      calcsize(n->nhere.next);
-      break;
-    case NNOT:
-      calcsize(n->nnot.com);
-      break;
-  };
-}
-
-/*
- * Make a copy of a parse tree.
- */
-static struct funcnode *copyfunc(union node *n) {
-  struct funcnode *f;
-  unsigned blocksize;
-  funcblocksize = offsetof(struct funcnode, n);
-  funcstringsize = 0;
-  calcsize(n);
-  blocksize = funcblocksize;
-  f = ckmalloc(blocksize + funcstringsize);
-  funcblock = (char *)f + offsetof(struct funcnode, n);
-  funcstring = (char *)f + blocksize;
-  copynode(n);
-  f->count = 0;
-  return f;
-}
-
-static void sizenodelist(struct nodelist *lp) {
-  while (lp) {
-    funcblocksize += SHELL_ALIGN(sizeof(struct nodelist));
-    calcsize(lp->n);
-    lp = lp->next;
-  }
-}
-
-static union node *copynode(union node *n) {
-  union node *new;
-  if (n == NULL)
-    return NULL;
-  new = funcblock;
-  funcblock = (char *)funcblock + nodesize[n->type];
-  switch (n->type) {
-    case NCMD:
-      new->ncmd.redirect = copynode(n->ncmd.redirect);
-      new->ncmd.args = copynode(n->ncmd.args);
-      new->ncmd.assign = copynode(n->ncmd.assign);
-      new->ncmd.linno = n->ncmd.linno;
-      break;
-    case NPIPE:
-      new->npipe.cmdlist = copynodelist(n->npipe.cmdlist);
-      new->npipe.backgnd = n->npipe.backgnd;
-      break;
-    case NREDIR:
-    case NBACKGND:
-    case NSUBSHELL:
-      new->nredir.redirect = copynode(n->nredir.redirect);
-      new->nredir.n = copynode(n->nredir.n);
-      new->nredir.linno = n->nredir.linno;
-      break;
-    case NAND:
-    case NOR:
-    case NSEMI:
-    case NWHILE:
-    case NUNTIL:
-      new->nbinary.ch2 = copynode(n->nbinary.ch2);
-      new->nbinary.ch1 = copynode(n->nbinary.ch1);
-      break;
-    case NIF:
-      new->nif.elsepart = copynode(n->nif.elsepart);
-      new->nif.ifpart = copynode(n->nif.ifpart);
-      new->nif.test = copynode(n->nif.test);
-      break;
-    case NFOR:
-      new->nfor.var_ = nodesavestr(n->nfor.var_);
-      new->nfor.body = copynode(n->nfor.body);
-      new->nfor.args = copynode(n->nfor.args);
-      new->nfor.linno = n->nfor.linno;
-      break;
-    case NCASE:
-      new->ncase.cases = copynode(n->ncase.cases);
-      new->ncase.expr = copynode(n->ncase.expr);
-      new->ncase.linno = n->ncase.linno;
-      break;
-    case NCLIST:
-      new->nclist.body = copynode(n->nclist.body);
-      new->nclist.pattern = copynode(n->nclist.pattern);
-      new->nclist.next = copynode(n->nclist.next);
-      break;
-    case NDEFUN:
-      new->ndefun.body = copynode(n->ndefun.body);
-      new->ndefun.text = nodesavestr(n->ndefun.text);
-      new->ndefun.linno = n->ndefun.linno;
-      break;
-    case NARG:
-      new->narg.backquote = copynodelist(n->narg.backquote);
-      new->narg.text = nodesavestr(n->narg.text);
-      new->narg.next = copynode(n->narg.next);
-      break;
-    case NTO:
-    case NCLOBBER:
-    case NFROM:
-    case NFROMTO:
-    case NAPPEND:
-      new->nfile.fname = copynode(n->nfile.fname);
-      new->nfile.fd = n->nfile.fd;
-      new->nfile.next = copynode(n->nfile.next);
-      break;
-    case NTOFD:
-    case NFROMFD:
-      new->ndup.vname = copynode(n->ndup.vname);
-      new->ndup.dupfd = n->ndup.dupfd;
-      new->ndup.fd = n->ndup.fd;
-      new->ndup.next = copynode(n->ndup.next);
-      break;
-    case NHERE:
-    case NXHERE:
-      new->nhere.doc = copynode(n->nhere.doc);
-      new->nhere.fd = n->nhere.fd;
-      new->nhere.next = copynode(n->nhere.next);
-      break;
-    case NNOT:
-      new->nnot.com = copynode(n->nnot.com);
-      break;
-  };
-  new->type = n->type;
-  return new;
-}
-
-static struct nodelist *copynodelist(struct nodelist *lp) {
-  struct nodelist *start;
-  struct nodelist **lpp;
-  lpp = &start;
-  while (lp) {
-    *lpp = funcblock;
-    funcblock = (char *)funcblock + SHELL_ALIGN(sizeof(struct nodelist));
-    (*lpp)->n = copynode(lp->n);
-    lp = lp->next;
-    lpp = &(*lpp)->next;
-  }
-  *lpp = NULL;
-  return start;
-}
-
-/*
- * Read and execute commands.  "Top" is nonzero for the top level command
- * loop; it turns on prompting if the shell is interactive.
- */
-static int cmdloop(int top) {
-  union node *n;
-  struct stackmark smark;
-  int inter;
-  int status = 0;
-  int numeof = 0;
-  TRACE(("cmdloop(%d) called\n", top));
-  for (;;) {
-    int skip;
-    setstackmark(&smark);
-    if (jobctl)
-      showjobs(out2, SHOW_CHANGED);
-    inter = 0;
-    if (iflag && top) {
-      inter++;
-      /* chkmail(); */
-    }
-    n = parsecmd(inter);
-    /* showtree(n); DEBUG */
-    if (n == NEOF) {
-      if (!top || numeof >= 50)
-        break;
-      if (!stoppedjobs()) {
-        if (!Iflag) {
-          if (iflag)
-            outcslow('\n', out2);
-          break;
-        }
-        outstr("\nUse \"exit\" to leave shell.\n", out2);
-      }
-      numeof++;
-    } else {
-      int i;
-      job_warning = (job_warning == 2) ? 1 : 0;
-      numeof = 0;
-      i = evaltree(n, 0);
-      if (n)
-        status = i;
-    }
-    popstackmark(&smark);
-    skip = evalskip;
-    if (skip) {
-      evalskip &= ~(SKIPFUNC | SKIPFUNCDEF);
-      break;
-    }
-  }
-  return status;
-}
-
-/*
- * Read /etc/profile or .profile.  Return on error.
- */
-static void read_profile(const char *name) {
-  name = expandstr(name);
-  if (setinputfile(name, INPUT_PUSH_FILE | INPUT_NOFILE_OK) < 0)
-    return;
-  cmdloop(0);
-  popfile();
-}
-
-/*
- * Take commands from a file.  To be compatible we should do a path
- * search for the file, which is necessary to find sub-commands.
- */
-static char *find_dot_file(char *basename) {
-  char *fullname;
-  const char *path = pathval();
-  struct stat statb;
-  int len;
-  /* don't try this for absolute or relative paths */
-  if (strchr(basename, '/'))
-    return basename;
-  while ((len = padvance(&path, basename)) >= 0) {
-    fullname = stackblock();
-    if ((!pathopt || *pathopt == 'f') && !stat(fullname, &statb) &&
-        S_ISREG(statb.st_mode)) {
-      /* This will be freed by the caller. */
-      return stalloc(len);
-    }
-  }
-  /* not found in the PATH */
-  sh_error("%s: not found", basename);
-}
-
-static int dotcmd(int argc, char **argv) {
-  int status = 0;
-  nextopt(nullstr);
-  argv = argptr;
-  if (*argv) {
-    char *fullname;
-    fullname = find_dot_file(*argv);
-    setinputfile(fullname, INPUT_PUSH_FILE);
-    commandname = fullname;
-    status = cmdloop(0);
-    popfile();
-  }
-  return status;
-}
-
-static int exitcmd(int argc, char **argv) {
-  if (stoppedjobs())
-    return 0;
-  if (argc > 1)
-    savestatus = number(argv[1]);
-  exraise(EXEXIT);
-}
-
-/**
- * Main routine.  We initialize things, parse the arguments, execute
- * profiles if we're a login shell, and then call cmdloop to execute
- * commands.  The setjmp call sets up the location to jump to when an
- * exception occurs.  When an exception occurs the variable "state"
- * is used to figure out how far we had gotten.
- */
-int main(int argc, char **argv) {
-  char *shinit;
-  volatile int state;
-  struct stackmark smark;
-  int login;
-  state = 0;
-  if (unlikely(setjmp(main_handler.loc))) {
-    int e;
-    int s;
-    exitreset();
-    e = exception;
-    s = state;
-    if (e == EXEND || e == EXEXIT || s == 0 || iflag == 0 || shlvl)
-      exitshell();
-    reset();
-    if (e == EXINT) {
-      outcslow('\n', out2);
-    }
-    popstackmark(&smark);
-    FORCEINTON; /* enable interrupts */
-    if (s == 1) {
-      goto state1;
-    } else if (s == 2) {
-      goto state2;
-    } else if (s == 3) {
-      goto state3;
-    } else {
-      goto state4;
-    }
-  }
-  handler = &main_handler;
-  rootpid = getpid();
-  init();
-  setstackmark(&smark);
-  login = procargs(argc, argv);
-  if (login) {
-    state = 1;
-    read_profile("/etc/profile");
-  state1:
-    state = 2;
-    read_profile("$HOME/.profile");
-  }
-state2:
-  state = 3;
-  if (iflag) {
-    if ((shinit = lookupvar("ENV")) != NULL && *shinit != '\0') {
-      read_profile(shinit);
-    }
-  }
-  popstackmark(&smark);
-state3:
-  state = 4;
-  if (minusc)
-    evalstring(minusc, sflag ? 0 : EV_EXIT);
-  if (sflag || minusc == NULL) {
-  state4: /* XXX ??? - why isn't this before the "if" statement */
-    cmdloop(1);
-  }
-  exitshell();
-}
diff --git a/examples/whois.c b/examples/whois.c
index 95154787f..81b3e0214 100644
--- a/examples/whois.c
+++ b/examples/whois.c
@@ -30,6 +30,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/weirdtypes.h"
+#include "libc/ctype.h"
 #include "libc/errno.h"
 #include "libc/log/bsd.h"
 #include "libc/mem/mem.h"
diff --git a/libc/BUILD.mk b/libc/BUILD.mk
index acc7f7739..8e13bbc7c 100644
--- a/libc/BUILD.mk
+++ b/libc/BUILD.mk
@@ -18,6 +18,7 @@ libc/isystem/byteswap.h \
 libc/isystem/clzerointrin.h \
 libc/isystem/complex.h \
 libc/isystem/cosmo.h \
+libc/isystem/cosmoaudio.h \
 libc/isystem/cpio.h \
 libc/isystem/cpuid.h \
 libc/isystem/crypt.h \
diff --git a/libc/calls/BUILD.mk b/libc/calls/BUILD.mk
index 442dab18e..75ac5a00a 100644
--- a/libc/calls/BUILD.mk
+++ b/libc/calls/BUILD.mk
@@ -48,12 +48,13 @@ LIBC_CALLS_A_DIRECTDEPS =				\
 	LIBC_NT_PDH					\
 	LIBC_NT_POWRPROF				\
 	LIBC_NT_PSAPI					\
+	LIBC_NT_REALTIME				\
 	LIBC_NT_SYNCHRONIZATION				\
 	LIBC_NT_WS2_32					\
 	LIBC_STR					\
 	LIBC_SYSV					\
 	LIBC_SYSV_CALLS					\
-	THIRD_PARTY_COMPILER_RT
+	THIRD_PARTY_COMPILER_RT				\
 
 LIBC_CALLS_A_DEPS :=					\
 	$(call uniq,$(foreach x,$(LIBC_CALLS_A_DIRECTDEPS),$($(x))))
@@ -154,13 +155,67 @@ o/$(MODE)/libc/calls/sigcrashsig.o: private		\
 		CFLAGS +=				\
 			-Os
 
+# avoid legacy sse decoding penalty on avx systems
+o//libc/calls/cfmakeraw.o				\
+o//libc/calls/clock_gettime-xnu.o			\
+o//libc/calls/CPU_AND.o					\
+o//libc/calls/CPU_OR.o					\
+o//libc/calls/CPU_XOR.o					\
+o//libc/calls/dl_iterate_phdr.o				\
+o//libc/calls/dup-nt.o					\
+o//libc/calls/fcntl-nt.o				\
+o//libc/calls/flock-nt.o				\
+o//libc/calls/fstatfs-nt.o				\
+o//libc/calls/fstat-nt.o				\
+o//libc/calls/futimesat.o				\
+o//libc/calls/futimes.o					\
+o//libc/calls/getrlimit.o				\
+o//libc/calls/gettimeofday.o				\
+o//libc/calls/ioctl.o					\
+o//libc/calls/lutimes.o					\
+o//libc/calls/metaflock.o				\
+o//libc/calls/ntaccesscheck.o				\
+o//libc/calls/ntspawn.o					\
+o//libc/calls/open-nt.o					\
+o//libc/calls/pledge-linux.o				\
+o//libc/calls/ppoll.o					\
+o//libc/calls/preadv.o					\
+o//libc/calls/pselect.o					\
+o//libc/calls/pwritev.o					\
+o//libc/calls/read-nt.o					\
+o//libc/calls/readv.o					\
+o//libc/calls/readwrite-nt.o				\
+o//libc/calls/releasefd.o				\
+o//libc/calls/select.o					\
+o//libc/calls/sigaction.o				\
+o//libc/calls/sigenter-freebsd.o			\
+o//libc/calls/sigenter-netbsd.o				\
+o//libc/calls/sigenter-openbsd.o			\
+o//libc/calls/sigenter-xnu.o				\
+o//libc/calls/sigignore.o				\
+o//libc/calls/siginfo2cosmo.o				\
+o//libc/calls/signal.o					\
+o//libc/calls/sig.o					\
+o//libc/calls/sigtimedwait.o				\
+o//libc/calls/stat2cosmo.o				\
+o//libc/calls/statfs2cosmo.o				\
+o//libc/calls/statfs2statvfs.o				\
+o//libc/calls/tcgetattr-nt.o				\
+o//libc/calls/tcgetattr.o				\
+o//libc/calls/tcgetwinsize-nt.o				\
+o//libc/calls/tcsetattr-nt.o				\
+o//libc/calls/tcsetwinsize-nt.o				\
+o//libc/calls/termios2host.o				\
+o//libc/calls/timespec_sleep.o				\
+o//libc/calls/uname.o					\
+o//libc/calls/utimensat-old.o				\
+o//libc/calls/utimes.o					\
+o//libc/calls/winexec.o					\
+o//libc/calls/writev.o: private				\
+		COPTS +=				\
+			-mgeneral-regs-only
+
 # these assembly files are safe to build on aarch64
-o/$(MODE)/libc/calls/getcontext.o: libc/calls/getcontext.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/libc/calls/swapcontext.o: libc/calls/swapcontext.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/libc/calls/tailcontext.o: libc/calls/tailcontext.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/calls/stackjump.o: libc/calls/stackjump.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 
diff --git a/libc/calls/CPU_AND.c b/libc/calls/CPU_AND.c
index b90a0d1e4..bfe7ef2cc 100644
--- a/libc/calls/CPU_AND.c
+++ b/libc/calls/CPU_AND.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/cpuset.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 void CPU_AND(cpu_set_t *d, cpu_set_t *x, cpu_set_t *y) {
   int i;
diff --git a/libc/calls/CPU_COUNT.c b/libc/calls/CPU_COUNT.c
index 0e2348cb7..792cbfc7d 100644
--- a/libc/calls/CPU_COUNT.c
+++ b/libc/calls/CPU_COUNT.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/cpuset.h"
 #include "libc/intrin/popcnt.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 int CPU_COUNT(cpu_set_t *set) {
   int i, c;
diff --git a/libc/calls/CPU_OR.c b/libc/calls/CPU_OR.c
index 8218b9158..11fcaf20e 100644
--- a/libc/calls/CPU_OR.c
+++ b/libc/calls/CPU_OR.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/cpuset.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 void CPU_OR(cpu_set_t *d, cpu_set_t *x, cpu_set_t *y) {
   int i;
diff --git a/libc/calls/CPU_XOR.c b/libc/calls/CPU_XOR.c
index db5ced87a..08277e43f 100644
--- a/libc/calls/CPU_XOR.c
+++ b/libc/calls/CPU_XOR.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/cpuset.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 void CPU_XOR(cpu_set_t *d, cpu_set_t *x, cpu_set_t *y) {
   int i;
diff --git a/libc/calls/assertfail.c b/libc/calls/assertfail.c
index 9a15d2e8c..dc69fca5c 100644
--- a/libc/calls/assertfail.c
+++ b/libc/calls/assertfail.c
@@ -21,7 +21,7 @@
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describebacktrace.internal.h"
+#include "libc/intrin/describebacktrace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
 
diff --git a/libc/calls/cachestat.c b/libc/calls/cachestat.c
index 0163aeed7..6ab48a757 100644
--- a/libc/calls/cachestat.c
+++ b/libc/calls/cachestat.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 
 #include "libc/calls/cachestat.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 int sys_cachestat(int, struct cachestat_range *, struct cachestat *, uint32_t);
 
diff --git a/libc/calls/calls.h b/libc/calls/calls.h
index f2b8985ca..cd90cce73 100644
--- a/libc/calls/calls.h
+++ b/libc/calls/calls.h
@@ -69,48 +69,49 @@ COSMOPOLITAN_C_START_
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § system calls                                              ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
+/* clang-format off */
 
 typedef int sig_atomic_t;
 
 bool32 isatty(int) libcesque;
-char *getcwd(char *, size_t) dontthrow;
-char *realpath(const char *, char *) libcesque __wur;
+char *getcwd(char *, size_t) dontthrow __write_only(1, 2);
+char *realpath(const char *, char *) libcesque __wur __read_only(1) __write_only(2);
 char *ttyname(int) libcesque;
-int access(const char *, int) libcesque;
-int chdir(const char *) libcesque;
-int chmod(const char *, unsigned) libcesque;
-int chown(const char *, unsigned, unsigned) libcesque;
-int chroot(const char *) libcesque;
+int access(const char *, int) libcesque __read_only(1);
+int chdir(const char *) libcesque __read_only(1);
+int chmod(const char *, unsigned) libcesque __read_only(1);
+int chown(const char *, unsigned, unsigned) libcesque __read_only(1);
+int chroot(const char *) libcesque __read_only(1);
 int close(int) libcesque;
 int close_range(unsigned, unsigned, unsigned) libcesque;
 int closefrom(int) libcesque;
-int creat(const char *, unsigned) libcesque;
+int creat(const char *, unsigned) libcesque __read_only(1);
 int dup(int) libcesque;
 int dup2(int, int) libcesque;
 int dup3(int, int, int) libcesque;
-int execl(const char *, const char *, ...) nullterminated() libcesque;
-int execle(const char *, const char *, ...) nullterminated((1)) libcesque;
-int execlp(const char *, const char *, ...) nullterminated() libcesque;
-int execv(const char *, char *const[]) libcesque;
-int execve(const char *, char *const[], char *const[]) libcesque;
-int execvp(const char *, char *const[]) libcesque;
-int faccessat(int, const char *, int, int) libcesque;
+int execl(const char *, const char *, ...) nullterminated() libcesque __read_only(1) __read_only(2);
+int execle(const char *, const char *, ...) nullterminated((1)) libcesque __read_only(1) __read_only(2);
+int execlp(const char *, const char *, ...) nullterminated() libcesque __read_only(1) __read_only(2);
+int execv(const char *, char *const[]) libcesque __read_only(1) __read_only(2);
+int execve(const char *, char *const[], char *const[]) libcesque __read_only(1) __read_only(2) __read_only(3);
+int execvp(const char *, char *const[]) libcesque __read_only(1) __read_only(2);
+int faccessat(int, const char *, int, int) libcesque __read_only(2);
 int fchdir(int) libcesque;
 int fchmod(int, unsigned) libcesque;
-int fchmodat(int, const char *, unsigned, int) libcesque;
+int fchmodat(int, const char *, unsigned, int) libcesque __read_only(2);
 int fchown(int, unsigned, unsigned) libcesque;
-int fchownat(int, const char *, unsigned, unsigned, int) libcesque;
+int fchownat(int, const char *, unsigned, unsigned, int) libcesque __read_only(2);
 int fcntl(int, int, ...) libcesque;
 int fdatasync(int) libcesque;
-int fexecve(int, char *const[], char *const[]) libcesque;
+int fexecve(int, char *const[], char *const[]) libcesque __read_only(2) __read_only(3);
 int flock(int, int) libcesque;
 int fork(void) libcesque;
 int fsync(int) libcesque;
 int ftruncate(int, int64_t) libcesque;
-int getdomainname(char *, size_t) libcesque;
-int getgroups(int, unsigned[]) libcesque;
-int gethostname(char *, size_t) libcesque;
-int getloadavg(double *, int) libcesque;
+int getdomainname(char *, size_t) libcesque __write_only(1, 2);
+int getgroups(int, unsigned[]) libcesque __write_only(2, 1);
+int gethostname(char *, size_t) libcesque __write_only(1, 2);
+int getloadavg(double *, int) libcesque __write_only(1, 2);
 int getpgid(int) libcesque;
 int getpgrp(void) libcesque nosideeffect;
 int getpid(void) libcesque nosideeffect;
@@ -121,35 +122,35 @@ int ioctl(int, unsigned long, ...) libcesque;
 int issetugid(void) libcesque;
 int kill(int, int) libcesque;
 int killpg(int, int) libcesque;
-int lchmod(const char *, unsigned) libcesque;
-int lchown(const char *, unsigned, unsigned) libcesque;
-int link(const char *, const char *) libcesque;
-int linkat(int, const char *, int, const char *, int) libcesque;
-int mincore(void *, size_t, unsigned char *) libcesque;
-int mkdir(const char *, unsigned) libcesque;
-int mkdirat(int, const char *, unsigned) libcesque;
-int mknod(const char *, unsigned, uint64_t) libcesque;
+int lchmod(const char *, unsigned) libcesque __read_only(1);
+int lchown(const char *, unsigned, unsigned) libcesque __read_only(1);
+int link(const char *, const char *) libcesque __read_only(1) __read_only(2);
+int linkat(int, const char *, int, const char *, int) libcesque __read_only(2) __read_only(4);
+int mincore(void *, size_t, unsigned char *) libcesque __read_only(1) __write_only(3);
+int mkdir(const char *, unsigned) libcesque __read_only(1);
+int mkdirat(int, const char *, unsigned) libcesque __read_only(2);
+int mknod(const char *, unsigned, uint64_t) libcesque __read_only(1);
 int nice(int) libcesque;
-int open(const char *, int, ...) libcesque;
-int openat(int, const char *, int, ...) libcesque;
+int open(const char *, int, ...) libcesque __read_only(1);
+int openat(int, const char *, int, ...) libcesque __read_only(2);
 int pause(void) libcesque;
-int pipe(int[hasatleast 2]) libcesque;
-int pipe2(int[hasatleast 2], int) libcesque;
+int pipe(int[2]) libcesque __write_only(1);
+int pipe2(int[2], int) libcesque __write_only(1);
 int posix_fadvise(int, int64_t, int64_t, int) libcesque;
-int posix_madvise(void *, uint64_t, int) libcesque;
+int posix_madvise(void *, uint64_t, int) libcesque __read_write(1);
 int raise(int) libcesque;
 int reboot(int) libcesque;
-int remove(const char *) libcesque;
-int rename(const char *, const char *) libcesque;
-int renameat(int, const char *, int, const char *) libcesque;
-int rmdir(const char *) libcesque;
+int remove(const char *) libcesque __read_only(1);
+int rename(const char *, const char *) libcesque __read_only(1) __read_only(2);
+int renameat(int, const char *, int, const char *) libcesque __read_only(2) __read_only(4);
+int rmdir(const char *) libcesque __read_only(1);
 int sched_yield(void) libcesque;
 int setegid(unsigned) libcesque;
 int seteuid(unsigned) libcesque;
 int setfsgid(unsigned) libcesque;
 int setfsuid(unsigned) libcesque;
 int setgid(unsigned) libcesque;
-int setgroups(size_t, const unsigned[]) libcesque;
+int setgroups(size_t, const unsigned[]) libcesque __read_only(2);
 int setpgid(int, int) libcesque;
 int setpgrp(void) libcesque;
 int setpriority(int, unsigned, int) libcesque;
@@ -157,32 +158,32 @@ int setregid(unsigned, unsigned) libcesque;
 int setreuid(unsigned, unsigned) libcesque;
 int setsid(void) libcesque;
 int setuid(unsigned) libcesque;
-int shm_open(const char *, int, unsigned) libcesque;
-int shm_unlink(const char *) libcesque;
+int shm_open(const char *, int, unsigned) libcesque __read_only(1);
+int shm_unlink(const char *) libcesque __read_only(1);
 int sigignore(int) libcesque;
 int siginterrupt(int, int) libcesque;
-int symlink(const char *, const char *) libcesque;
-int symlinkat(const char *, int, const char *) libcesque;
+int symlink(const char *, const char *) libcesque __read_only(1) __read_only(2);
+int symlinkat(const char *, int, const char *) libcesque __read_only(1) __read_only(3);
 int tcgetpgrp(int) libcesque;
 int tcsetpgrp(int, int) libcesque;
-int truncate(const char *, int64_t) libcesque;
-int ttyname_r(int, char *, size_t) libcesque;
-int unlink(const char *) libcesque;
-int unlinkat(int, const char *, int) libcesque;
+int truncate(const char *, int64_t) libcesque __read_only(1);
+int ttyname_r(int, char *, size_t) libcesque __write_only(2, 3);
+int unlink(const char *) libcesque __read_only(1);
+int unlinkat(int, const char *, int) libcesque __read_only(2);
 int usleep(uint64_t) libcesque;
 int vfork(void) libcesque returnstwice;
-int wait(int *) libcesque;
-int waitpid(int, int *, int) libcesque;
+int wait(int *) libcesque __write_only(1);
+int waitpid(int, int *, int) libcesque __write_only(2);
 int64_t clock(void) libcesque;
-int64_t time(int64_t *) libcesque;
-ssize_t copy_file_range(int, long *, int, long *, size_t, unsigned) libcesque;
+int64_t time(int64_t *) libcesque __write_only(1);
+ssize_t copy_file_range(int, long *, int, long *, size_t, unsigned) libcesque __read_write(2) __read_write(4);
 ssize_t lseek(int, int64_t, int) libcesque;
-ssize_t pread(int, void *, size_t, int64_t) libcesque;
-ssize_t pwrite(int, const void *, size_t, int64_t) libcesque;
-ssize_t read(int, void *, size_t) libcesque;
-ssize_t readlink(const char *, char *, size_t) libcesque;
-ssize_t readlinkat(int, const char *, char *, size_t) libcesque;
-ssize_t write(int, const void *, size_t) libcesque;
+ssize_t pread(int, void *, size_t, int64_t) libcesque __write_only(2, 3);
+ssize_t pwrite(int, const void *, size_t, int64_t) libcesque __read_only(2);
+ssize_t read(int, void *, size_t) libcesque __write_only(2, 3);
+ssize_t readlink(const char *, char *, size_t) libcesque __read_only(1) __write_only(2, 3);
+ssize_t readlinkat(int, const char *, char *, size_t) libcesque __read_only(2) __write_only(3, 4);
+ssize_t write(int, const void *, size_t) libcesque __read_only(2);
 unsigned alarm(unsigned) libcesque;
 unsigned getegid(void) libcesque nosideeffect;
 unsigned geteuid(void) libcesque nosideeffect;
@@ -199,50 +200,50 @@ int prctl(int, ...) libcesque;
 int gettid(void) libcesque;
 int setresgid(unsigned, unsigned, unsigned) libcesque;
 int setresuid(unsigned, unsigned, unsigned) libcesque;
-int getresgid(unsigned *, unsigned *, unsigned *) libcesque;
-int getresuid(unsigned *, unsigned *, unsigned *) libcesque;
+int getresgid(unsigned *, unsigned *, unsigned *) libcesque __write_only(1) __write_only(2) __write_only(3);
+int getresuid(unsigned *, unsigned *, unsigned *) libcesque __write_only(1) __write_only(2) __write_only(3);
 char *get_current_dir_name(void) libcesque __wur;
-ssize_t splice(int, int64_t *, int, int64_t *, size_t, unsigned) libcesque;
-int memfd_create(const char *, unsigned int) libcesque;
-int execvpe(const char *, char *const[], char *const[]) libcesque;
-int euidaccess(const char *, int) libcesque;
-int eaccess(const char *, int) libcesque;
-int madvise(void *, uint64_t, int) libcesque;
-int getcpu(unsigned *, unsigned *) libcesque;
+ssize_t splice(int, int64_t *, int, int64_t *, size_t, unsigned) libcesque __read_write(2) __read_write(4);
+int memfd_create(const char *, unsigned int) libcesque __read_only(1);
+int execvpe(const char *, char *const[], char *const[]) libcesque __read_only(1) __read_only(2) __read_only(3);
+int euidaccess(const char *, int) libcesque __read_only(1);
+int eaccess(const char *, int) libcesque __read_only(1);
+int madvise(void *, uint64_t, int) libcesque __read_write(1);
+int getcpu(unsigned *, unsigned *) libcesque __write_only(1) __write_only(2);
 #endif
 
 #ifdef _COSMO_SOURCE
 bool32 fdexists(int) libcesque;
-bool32 fileexists(const char *) libcesque;
+bool32 fileexists(const char *) libcesque __read_only(1);
 bool32 ischardev(int) libcesque;
-bool32 isdirectory(const char *) libcesque;
-bool32 isexecutable(const char *) libcesque;
-bool32 isregularfile(const char *) libcesque;
-bool32 issymlink(const char *) libcesque;
-char *commandv(const char *, char *, size_t) libcesque;
-int __getcwd(char *, size_t) libcesque;
+bool32 isdirectory(const char *) libcesque __read_only(1);
+bool32 isexecutable(const char *) libcesque __read_only(1);
+bool32 isregularfile(const char *) libcesque __read_only(1);
+bool32 issymlink(const char *) libcesque __read_only(1);
+char *commandv(const char *, char *, size_t) libcesque __read_only(1) __write_only(2, 3);
+int __getcwd(char *, size_t) libcesque __write_only(1, 2);
 int clone(void *, void *, size_t, int, void *, void *, void *, void *);
 int fadvise(int, uint64_t, uint64_t, int) libcesque;
-int makedirs(const char *, unsigned) libcesque;
-int pivot_root(const char *, const char *) libcesque;
-int pledge(const char *, const char *) libcesque;
-int seccomp(unsigned, unsigned, void *) libcesque;
+int makedirs(const char *, unsigned) libcesque __read_only(1);
+int pivot_root(const char *, const char *) libcesque __read_only(1) __read_only(2);
+int pledge(const char *, const char *) libcesque __read_only(1) __read_only(2);
+int seccomp(unsigned, unsigned, void *) libcesque __read_only(3);
 int sys_iopl(int) libcesque;
 int sys_ioprio_get(int, int) libcesque;
 int sys_ioprio_set(int, int, int) libcesque;
-int sys_mlock(const void *, size_t) libcesque;
-int sys_mlock2(const void *, size_t, int) libcesque;
+int sys_mlock(const void *, size_t) libcesque __read_only(1);
+int sys_mlock2(const void *, size_t, int) libcesque __read_only(1);
 int sys_mlockall(int) libcesque;
-int sys_munlock(const void *, size_t) libcesque;
+int sys_munlock(const void *, size_t) libcesque __read_only(1);
 int sys_munlockall(void) libcesque;
 int sys_personality(uint64_t) libcesque;
 int sys_ptrace(int, ...) libcesque;
-int sysctl(int *, unsigned, void *, size_t *, void *, size_t) libcesque;
-int sysctlbyname(const char *, void *, size_t *, void *, size_t) libcesque;
-int sysctlnametomib(const char *, int *, size_t *) libcesque;
+int sysctl(int *, unsigned, void *, size_t *, void *, size_t) libcesque __read_write(1) __read_write(4) __read_write(5);
+int sysctlbyname(const char *, void *, size_t *, void *, size_t) libcesque __read_only(1) __write_only(2) __read_write(3) __read_only(4);
+int sysctlnametomib(const char *, int *, size_t *) libcesque __read_only(1) __write_only(2) __read_write(3);
 int tmpfd(void) libcesque;
-int touch(const char *, unsigned) libcesque;
-int unveil(const char *, const char *) libcesque;
+int touch(const char *, unsigned) libcesque __read_only(1);
+int unveil(const char *, const char *) libcesque __read_only(1);
 long ptrace(int, ...) libcesque;
 ssize_t copyfd(int, int, size_t) libcesque;
 ssize_t readansi(int, char *, size_t) libcesque;
diff --git a/libc/calls/chdir-nt.c b/libc/calls/chdir-nt.c
index ebc052c5a..86e104bc8 100644
--- a/libc/calls/chdir-nt.c
+++ b/libc/calls/chdir-nt.c
@@ -16,70 +16,48 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/errno.h"
-#include "libc/macros.internal.h"
-#include "libc/nt/errors.h"
+#include "libc/limits.h"
 #include "libc/nt/files.h"
 #include "libc/nt/process.h"
-#include "libc/nt/runtime.h"
-#include "libc/nt/synchronization.h"
 #include "libc/sysv/errfuns.h"
 
 textwindows int sys_chdir_nt_impl(char16_t path[hasatleast PATH_MAX],
                                   uint32_t len) {
   uint32_t n;
-  int e, ms, err;
   char16_t var[4];
-
   if (len && path[len - 1] != u'\\') {
     if (len + 2 > PATH_MAX)
       return enametoolong();
     path[len + 0] = u'\\';
     path[len + 1] = u'\0';
   }
-
-  /*
-   * chdir() seems flaky on windows 7
-   * in a similar way to rmdir() sigh
-   */
-  for (err = errno, ms = 1;; ms *= 2) {
-    if (SetCurrentDirectory(path)) {
-      /*
-       * Now we need to set a magic environment variable.
-       */
-      if ((n = GetCurrentDirectory(PATH_MAX, path))) {
-        if (n < PATH_MAX) {
-          if (!((path[0] == '/' && path[1] == '/') ||
-                (path[0] == '\\' && path[1] == '\\'))) {
-            var[0] = '=';
-            var[1] = path[0];
-            var[2] = ':';
-            var[3] = 0;
-            if (!SetEnvironmentVariable(var, path)) {
-              return __winerr();
-            }
-          }
-          return 0;
-        } else {
-          return enametoolong();
+  if (SetCurrentDirectory(path)) {
+    /*
+     * Now we need to set a magic environment variable.
+     */
+    if ((n = GetCurrentDirectory(PATH_MAX, path))) {
+      if (n < PATH_MAX) {
+        if (!((path[0] == '/' && path[1] == '/') ||
+              (path[0] == '\\' && path[1] == '\\'))) {
+          var[0] = '=';
+          var[1] = path[0];
+          var[2] = ':';
+          var[3] = 0;
+          if (!SetEnvironmentVariable(var, path))
+            return __winerr();
         }
+        return 0;
       } else {
-        return __winerr();
+        return enametoolong();
       }
     } else {
-      e = GetLastError();
-      if (ms <= 512 &&
-          (e == kNtErrorFileNotFound || e == kNtErrorAccessDenied)) {
-        Sleep(ms);
-        errno = err;
-        continue;
-      } else {
-        break;
-      }
+      return __winerr();
     }
+  } else {
+    return __fix_enotdir(__winerr(), path);
   }
-  return __fix_enotdir(-1, path);
 }
 
 textwindows int sys_chdir_nt(const char *path) {
diff --git a/libc/calls/chdir.c b/libc/calls/chdir.c
index b37eaf655..876dedb60 100644
--- a/libc/calls/chdir.c
+++ b/libc/calls/chdir.c
@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/log.h"
 #include "libc/runtime/runtime.h"
diff --git a/libc/calls/chroot.c b/libc/calls/chroot.c
index c5256fd1a..e18ed88c0 100644
--- a/libc/calls/chroot.c
+++ b/libc/calls/chroot.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/clktck.c b/libc/calls/clktck.c
index b59a73711..3e39b4e3f 100644
--- a/libc/calls/clktck.c
+++ b/libc/calls/clktck.c
@@ -20,7 +20,7 @@
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
 #include "libc/fmt/wintime.internal.h"
-#include "libc/intrin/getauxval.internal.h"
+#include "libc/intrin/getauxval.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/auxv.h"
 
diff --git a/libc/calls/clock_getres.c b/libc/calls/clock_getres.c
index e400e0569..39ba39fc0 100644
--- a/libc/calls/clock_getres.c
+++ b/libc/calls/clock_getres.c
@@ -18,26 +18,39 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/runtime/clktck.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/time.h"
 
-static int sys_clock_getres_poly(int clock, struct timespec *ts, int64_t real,
-                                 int64_t real_coarse, int64_t boot) {
-  ts->tv_sec = 0;
-  if (clock == CLOCK_REALTIME) {
-    ts->tv_nsec = real;
+static uint64_t hz_to_nanos(uint64_t frequency) {
+  if (!frequency)
     return 0;
-  } else if (clock == CLOCK_REALTIME_COARSE) {
-    ts->tv_nsec = real_coarse;
+  uint64_t quotient = 1000000000 / frequency;
+  uint64_t remainder = 1000000000 % frequency;
+  if (remainder > 0)
+    quotient += 1;
+  return quotient;
+}
+
+static int sys_clock_getres_poly(int clock, struct timespec *ts, int64_t prec) {
+  if (ts)
+    ts->tv_sec = 0;
+  if (clock == CLOCK_REALTIME ||   //
+      clock == CLOCK_BOOTTIME ||   //
+      clock == CLOCK_MONOTONIC ||  //
+      clock == CLOCK_MONOTONIC_RAW) {
+    if (ts)
+      ts->tv_nsec = prec;
     return 0;
-  } else if (clock == CLOCK_MONOTONIC) {
-    ts->tv_nsec = 10;
-    return 0;
-  } else if (clock == CLOCK_BOOTTIME) {
-    ts->tv_nsec = boot;
+  } else if (clock == CLOCK_REALTIME_COARSE ||
+             clock == CLOCK_MONOTONIC_COARSE ||
+             clock == CLOCK_THREAD_CPUTIME_ID ||
+             clock == CLOCK_PROCESS_CPUTIME_ID) {
+    if (ts)
+      *ts = timespec_fromnanos(hz_to_nanos(CLK_TCK));
     return 0;
   } else {
     return einval();
@@ -45,11 +58,11 @@ static int sys_clock_getres_poly(int clock, struct timespec *ts, int64_t real,
 }
 
 static int sys_clock_getres_nt(int clock, struct timespec *ts) {
-  return sys_clock_getres_poly(clock, ts, 100, 1000000, 1000000);
+  return sys_clock_getres_poly(clock, ts, 100);
 }
 
 static int sys_clock_getres_xnu(int clock, struct timespec *ts) {
-  return sys_clock_getres_poly(clock, ts, 1000, 1000, 1000);
+  return sys_clock_getres_poly(clock, ts, 1000);
 }
 
 /**
diff --git a/libc/calls/clock_gettime-mono.c b/libc/calls/clock_gettime-mono.c
deleted file mode 100644
index 3bc38f37f..000000000
--- a/libc/calls/clock_gettime-mono.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/atomic.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/cosmo.h"
-#include "libc/errno.h"
-#include "libc/nexgen32e/rdtsc.h"
-#include "libc/nexgen32e/x86feature.h"
-
-/**
- * @fileoverview Fast Monotonic Clock Polyfill for XNU/NT.
- */
-
-static struct {
-  atomic_uint once;
-  struct timespec base_wall;
-  uint64_t base_tick;
-} g_mono;
-
-static void sys_clock_gettime_mono_init(void) {
-  g_mono.base_wall = timespec_real();
-  g_mono.base_tick = rdtsc();
-}
-
-int sys_clock_gettime_mono(struct timespec *time) {
-  uint64_t nanos;
-  uint64_t cycles;
-#ifdef __x86_64__
-  // intel architecture guarantees that a mapping exists between rdtsc &
-  // nanoseconds only if the cpu advertises invariant timestamps support
-  if (!X86_HAVE(INVTSC))
-    return -EINVAL;
-#endif
-  cosmo_once(&g_mono.once, sys_clock_gettime_mono_init);
-  cycles = rdtsc() - g_mono.base_tick;
-  // this is a crude approximation, that's worked reasonably well so far
-  // only the kernel knows the actual mapping between rdtsc and nanosecs
-  // which we could attempt to measure ourselves using clock_gettime but
-  // we'd need to impose 100 ms of startup latency for a guess this good
-  nanos = cycles / 3;
-  *time = timespec_add(g_mono.base_wall, timespec_fromnanos(nanos));
-  return 0;
-}
diff --git a/libc/calls/clock_gettime-nt.c b/libc/calls/clock_gettime-nt.c
deleted file mode 100644
index 5a6464e42..000000000
--- a/libc/calls/clock_gettime-nt.c
+++ /dev/null
@@ -1,95 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/timespec.h"
-#include "libc/calls/struct/timespec.internal.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/fmt/wintime.internal.h"
-#include "libc/nt/accounting.h"
-#include "libc/nt/runtime.h"
-#include "libc/nt/synchronization.h"
-#include "libc/nt/thread.h"
-
-#define _CLOCK_REALTIME           0
-#define _CLOCK_MONOTONIC          1
-#define _CLOCK_REALTIME_COARSE    2
-#define _CLOCK_BOOTTIME           3
-#define _CLOCK_PROCESS_CPUTIME_ID 4
-#define _CLOCK_THREAD_CPUTIME_ID  5
-
-static struct {
-  uint64_t base;
-  uint64_t freq;
-} g_winclock;
-
-textwindows int sys_clock_gettime_nt(int clock, struct timespec *ts) {
-  uint64_t t;
-  struct NtFileTime ft, ftExit, ftUser, ftKernel, ftCreation;
-  switch (clock) {
-    case _CLOCK_REALTIME:
-      if (ts) {
-        GetSystemTimePreciseAsFileTime(&ft);
-        *ts = FileTimeToTimeSpec(ft);
-      }
-      return 0;
-    case _CLOCK_REALTIME_COARSE:
-      if (ts) {
-        GetSystemTimeAsFileTime(&ft);
-        *ts = FileTimeToTimeSpec(ft);
-      }
-      return 0;
-    case _CLOCK_MONOTONIC:
-      if (ts) {
-        QueryPerformanceCounter(&t);
-        t = ((t - g_winclock.base) * 1000000000) / g_winclock.freq;
-        *ts = timespec_fromnanos(t);
-      }
-      return 0;
-    case _CLOCK_BOOTTIME:
-      if (ts) {
-        *ts = timespec_frommillis(GetTickCount64());
-      }
-      return 0;
-    case _CLOCK_PROCESS_CPUTIME_ID:
-      if (ts) {
-        GetProcessTimes(GetCurrentProcess(), &ftCreation, &ftExit, &ftKernel,
-                        &ftUser);
-        *ts = WindowsDurationToTimeSpec(ReadFileTime(ftUser) +
-                                        ReadFileTime(ftKernel));
-      }
-      return 0;
-    case _CLOCK_THREAD_CPUTIME_ID:
-      if (ts) {
-        GetThreadTimes(GetCurrentThread(), &ftCreation, &ftExit, &ftKernel,
-                       &ftUser);
-        *ts = WindowsDurationToTimeSpec(ReadFileTime(ftUser) +
-                                        ReadFileTime(ftKernel));
-      }
-      return 0;
-    default:
-      return -EINVAL;
-  }
-}
-
-__attribute__((__constructor__(40))) static textstartup void winclock_init() {
-  if (IsWindows()) {
-    QueryPerformanceCounter(&g_winclock.base);
-    QueryPerformanceFrequency(&g_winclock.freq);
-  }
-}
diff --git a/libc/calls/clock_gettime.c b/libc/calls/clock_gettime.c
deleted file mode 100644
index c5f72fdd9..000000000
--- a/libc/calls/clock_gettime.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=8 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/timespec.h"
-#include "libc/calls/struct/timespec.internal.h"
-#include "libc/calls/syscall_support-sysv.internal.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/runtime/syslib.internal.h"
-
-#ifdef __aarch64__
-#define CGT_VDSO __vdsosym("LINUX_2.6.39", "__kernel_clock_gettime")
-#else
-#define CGT_VDSO __vdsosym("LINUX_2.6", "__vdso_clock_gettime")
-#endif
-
-typedef int clock_gettime_f(int, struct timespec *);
-
-static clock_gettime_f *__clock_gettime_get(void) {
-  clock_gettime_f *cgt;
-  if (IsLinux() && (cgt = CGT_VDSO)) {
-    return cgt;
-  } else if (__syslib) {
-    return (void *)__syslib->__clock_gettime;
-  } else if (IsWindows()) {
-    return sys_clock_gettime_nt;
-#ifdef __x86_64__
-  } else if (IsXnu()) {
-    return sys_clock_gettime_xnu;
-#endif
-  } else {
-    return sys_clock_gettime;
-  }
-}
-
-static int __clock_gettime_init(int, struct timespec *);
-static clock_gettime_f *__clock_gettime = __clock_gettime_init;
-static int __clock_gettime_init(int clockid, struct timespec *ts) {
-  clock_gettime_f *cgt;
-  __clock_gettime = cgt = __clock_gettime_get();
-  return cgt(clockid, ts);
-}
-
-/**
- * Returns nanosecond time.
- *
- * @param clock supports the following values across OSes:
- *    - `CLOCK_REALTIME`
- *    - `CLOCK_MONOTONIC`
- *    - `CLOCK_REALTIME_COARSE`
- *    - `CLOCK_MONOTONIC_COARSE`
- *    - `CLOCK_THREAD_CPUTIME_ID`
- *    - `CLOCK_PROCESS_CPUTIME_ID`
- * @param ts is where the result is stored (or null to do clock check)
- * @return 0 on success, or -1 w/ errno
- * @raise EFAULT if `ts` points to invalid memory
- * @error EINVAL if `clock` isn't supported on this system
- * @error EPERM if pledge() is in play without stdio promise
- * @error ESRCH on NetBSD if PID/TID OR'd into `clock` wasn't found
- * @see strftime(), gettimeofday()
- * @asyncsignalsafe
- * @vforksafe
- */
-int clock_gettime(int clock, struct timespec *ts) {
-  // threads on win32 stacks call this so we can't asan check *ts
-  int rc = __clock_gettime(clock, ts);
-  if (rc) {
-    errno = -rc;
-    rc = -1;
-  }
-  TIMETRACE("clock_gettime(%s, [%s]) → %d% m", DescribeClockName(clock),
-            DescribeTimespec(rc, ts), rc);
-  return rc;
-}
diff --git a/libc/calls/clock_nanosleep-cosmo.c b/libc/calls/clock_nanosleep-cosmo.c
deleted file mode 100644
index f49c4c50f..000000000
--- a/libc/calls/clock_nanosleep-cosmo.c
+++ /dev/null
@@ -1,85 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/internal.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/errno.h"
-#include "libc/runtime/clktck.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sysv/consts/clock.h"
-#include "libc/sysv/consts/timer.h"
-
-/**
- * Sleeps with higher accuracy at the cost of cpu.
- */
-int cosmo_clock_nanosleep(int clock, int flags, const struct timespec *req,
-                          struct timespec *rem) {
-
-  // pick clocks
-  int time_clock;
-  int sleep_clock;
-  if (clock == CLOCK_REALTIME ||  //
-      clock == CLOCK_REALTIME_PRECISE) {
-    time_clock = clock;
-    sleep_clock = CLOCK_REALTIME;
-  } else if (clock == CLOCK_MONOTONIC ||  //
-             clock == CLOCK_MONOTONIC_PRECISE) {
-    time_clock = clock;
-    sleep_clock = CLOCK_MONOTONIC;
-  } else if (clock == CLOCK_REALTIME_COARSE ||  //
-             clock == CLOCK_REALTIME_FAST) {
-    return sys_clock_nanosleep(CLOCK_REALTIME, flags, req, rem);
-  } else if (clock == CLOCK_MONOTONIC_COARSE ||  //
-             clock == CLOCK_MONOTONIC_FAST) {
-    return sys_clock_nanosleep(CLOCK_MONOTONIC, flags, req, rem);
-  } else {
-    return sys_clock_nanosleep(clock, flags, req, rem);
-  }
-
-  // sleep bulk of time in kernel
-  struct timespec start, deadline, remain, waitfor, now;
-  struct timespec quantum = timespec_fromnanos(1000000000 / CLK_TCK);
-  clock_gettime(time_clock, &start);
-  deadline = flags & TIMER_ABSTIME ? *req : timespec_add(start, *req);
-  if (timespec_cmp(start, deadline) >= 0)
-    return 0;
-  remain = timespec_sub(deadline, start);
-  if (timespec_cmp(remain, quantum) > 0) {
-    waitfor = timespec_sub(remain, quantum);
-    if (sys_clock_nanosleep(sleep_clock, 0, &waitfor, rem) == -1) {
-      if (!flags && rem && errno == EINTR) {
-        *rem = timespec_add(*rem, quantum);
-      }
-      return -1;
-    }
-  }
-
-  // spin through final scheduling quantum
-  int rc = 0;
-  ftrace_enabled(-1);
-  do {
-    if (_check_cancel()) {
-      rc = -1;
-      break;
-    }
-    clock_gettime(time_clock, &now);
-  } while (timespec_cmp(now, deadline) < 0);
-  ftrace_enabled(+1);
-  return rc;
-}
diff --git a/libc/calls/clock_nanosleep-nt.c b/libc/calls/clock_nanosleep-nt.c
index 6d7adc5be..1e1a09cbd 100644
--- a/libc/calls/clock_nanosleep-nt.c
+++ b/libc/calls/clock_nanosleep-nt.c
@@ -16,30 +16,45 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
+#include "libc/calls/syscall-sysv.internal.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
+#include "libc/nt/enum/status.h"
+#include "libc/nt/ntdll.h"
+#include "libc/stdio/sysparam.h"
+#include "libc/sysv/consts/clock.h"
 #include "libc/sysv/consts/timer.h"
 #include "libc/thread/tls.h"
 #ifdef __x86_64__
 
+static atomic_int usingRes;
+static atomic_bool changedRes;
+
 static textwindows int sys_clock_nanosleep_nt_impl(int clock,
                                                    struct timespec abs,
                                                    sigset_t waitmask) {
-  uint32_t msdelay;
-  struct timespec now;
-  for (;;) {
-    if (sys_clock_gettime_nt(clock, &now))
-      return -1;
-    if (timespec_cmp(now, abs) >= 0)
-      return 0;
-    msdelay = timespec_tomillis(timespec_sub(abs, now));
-    if (_park_norestart(msdelay, waitmask))
-      return -1;
-  }
+  struct timespec now, wall;
+  uint32_t minRes, maxRes, oldRes;
+  sys_clock_gettime_nt(0, &wall);
+  if (sys_clock_gettime_nt(clock, &now))
+    return -1;
+  bool wantRes = clock == CLOCK_REALTIME ||   //
+                 clock == CLOCK_MONOTONIC ||  //
+                 clock == CLOCK_BOOTTIME;
+  if (wantRes && !atomic_fetch_add(&usingRes, 1))
+    changedRes = NtSuccess(NtQueryTimerResolution(&minRes, &maxRes, &oldRes)) &&
+                 NtSuccess(NtSetTimerResolution(maxRes, true, &oldRes));
+  if (timespec_cmp(abs, now) > 0)
+    wall = timespec_add(wall, timespec_sub(abs, now));
+  int rc = _park_norestart(wall, waitmask);
+  if (wantRes && atomic_fetch_sub(&usingRes, 1) == 1 && changedRes)
+    NtSetTimerResolution(0, false, &minRes);
+  return rc;
 }
 
 textwindows int sys_clock_nanosleep_nt(int clock, int flags,
@@ -48,15 +63,17 @@ textwindows int sys_clock_nanosleep_nt(int clock, int flags,
   int rc;
   struct timespec abs, now;
   sigset_t m = __sig_block();
-  if (flags & TIMER_ABSTIME) {
+  if (flags) {
     abs = *req;
   } else {
-    if ((rc = sys_clock_gettime_nt(clock, &now)))
+    if ((rc = sys_clock_gettime_nt(clock, &now))) {
+      rc = _sysret(rc);
       goto BailOut;
+    }
     abs = timespec_add(now, *req);
   }
   rc = sys_clock_nanosleep_nt_impl(clock, abs, m);
-  if (rc == -1 && rem && errno == EINTR) {
+  if (rc == -1 && !flags && rem && errno == EINTR) {
     sys_clock_gettime_nt(clock, &now);
     *rem = timespec_subz(abs, now);
   }
diff --git a/libc/calls/clock_nanosleep-openbsd.c b/libc/calls/clock_nanosleep-openbsd.c
index e1d67bcef..dec285314 100644
--- a/libc/calls/clock_nanosleep-openbsd.c
+++ b/libc/calls/clock_nanosleep-openbsd.c
@@ -18,28 +18,27 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/errno.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
 
-int sys_clock_nanosleep_openbsd(int clock, int flags,
-                                const struct timespec *req,
-                                struct timespec *rem) {
+relegated int sys_clock_nanosleep_openbsd(int clock, int flags,
+                                          const struct timespec *req,
+                                          struct timespec *rem) {
   int res;
-  struct timespec now, rel;
-  if (clock == CLOCK_REALTIME) {
-    if (!flags) {
-      res = sys_nanosleep(req, rem);
-    } else {
-      sys_clock_gettime(clock, &now);
-      if (timespec_cmp(*req, now) > 0) {
-        rel = timespec_sub(*req, now);
-        res = sys_nanosleep(&rel, 0);
-      } else {
-        res = 0;
-      }
-    }
+  struct timespec start, relative, remainder;
+  if (!flags) {
+    relative = *req;
   } else {
-    res = enotsup();
+    if ((res = sys_clock_gettime(clock, &start)))
+      return _sysret(res);
+    if (timespec_cmp(start, *req) >= 0)
+      return 0;
+    relative = timespec_sub(*req, start);
   }
+  res = sys_nanosleep(&relative, &remainder);
+  if (res == -1 && errno == EINTR && rem && !flags)
+    *rem = remainder;
   return res;
 }
diff --git a/libc/calls/clock_nanosleep-sys.c b/libc/calls/clock_nanosleep-sys.c
index 3d0e5cef8..d33d9454c 100644
--- a/libc/calls/clock_nanosleep-sys.c
+++ b/libc/calls/clock_nanosleep-sys.c
@@ -22,8 +22,8 @@
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/thread.h"
diff --git a/libc/calls/clock_nanosleep-xnu.c b/libc/calls/clock_nanosleep-xnu.c
index 23d0f2125..83a358f8e 100644
--- a/libc/calls/clock_nanosleep-xnu.c
+++ b/libc/calls/clock_nanosleep-xnu.c
@@ -35,8 +35,10 @@ int sys_clock_nanosleep_xnu(int clock, int flags, const struct timespec *req,
                             struct timespec *rem) {
 #ifdef __x86_64__
   if (flags & TIMER_ABSTIME) {
+    int nerr;
     struct timespec now;
-    sys_clock_gettime_xnu(clock, &now);
+    if ((nerr = sys_clock_gettime_xnu(clock, &now)))
+      return _sysret(nerr);
     if (timespec_cmp(*req, now) > 0) {
       struct timeval rel = timespec_totimeval(timespec_sub(*req, now));
       return sys_select(0, 0, 0, 0, &rel);
@@ -47,12 +49,13 @@ int sys_clock_nanosleep_xnu(int clock, int flags, const struct timespec *req,
     int rc;
     struct timespec beg;
     if (rem)
-      sys_clock_gettime_xnu(CLOCK_REALTIME, &beg);
+      if ((rc = sys_clock_gettime_xnu(clock, &beg)))
+        return _sysret(rc);
     struct timeval rel = timespec_totimeval(*req);  // rounds up
     rc = sys_select(0, 0, 0, 0, &rel);
     if (rc == -1 && rem && errno == EINTR) {
       struct timespec end;
-      sys_clock_gettime_xnu(CLOCK_REALTIME, &end);
+      sys_clock_gettime_xnu(clock, &end);
       *rem = timespec_subz(*req, timespec_sub(end, beg));
     }
     return rc;
@@ -61,9 +64,8 @@ int sys_clock_nanosleep_xnu(int clock, int flags, const struct timespec *req,
   long res;
   struct timespec abs, now, rel;
   if (_weaken(pthread_testcancel_np) &&  //
-      _weaken(pthread_testcancel_np)()) {
+      _weaken(pthread_testcancel_np)())
     return ecanceled();
-  }
   if (flags & TIMER_ABSTIME) {
     abs = *req;
     if (!(res = __syslib->__clock_gettime(clock, &now))) {
@@ -73,7 +75,10 @@ int sys_clock_nanosleep_xnu(int clock, int flags, const struct timespec *req,
       }
     }
   } else {
-    res = __syslib->__nanosleep(req, rem);
+    struct timespec remainder;
+    res = __syslib->__nanosleep(req, &remainder);
+    if (res == -EINTR && rem)
+      *rem = remainder;
   }
   if (res == -EINTR &&                    //
       (_weaken(pthread_testcancel_np) &&  //
diff --git a/libc/calls/clock_nanosleep.c b/libc/calls/clock_nanosleep.c
index 20a6b03ee..459e50328 100644
--- a/libc/calls/clock_nanosleep.c
+++ b/libc/calls/clock_nanosleep.c
@@ -19,6 +19,7 @@
 #include "libc/calls/struct/timespec.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
+#include "libc/sysv/consts/clock.h"
 #include "libc/sysv/consts/timer.h"
 
 /**
@@ -56,7 +57,10 @@
  *
  * @param clock may be
  *     - `CLOCK_REALTIME`
+ *     - `CLOCK_BOOTTIME`
  *     - `CLOCK_MONOTONIC`
+ *     - `CLOCK_REALTIME_COARSE` but is likely to sleep negative time
+ *     - `CLOCK_MONTONIC_COARSE` but is likely to sleep negative time
  * @param flags can be 0 for relative and `TIMER_ABSTIME` for absolute
  * @param req can be a relative or absolute time, depending on `flags`
  * @param rem shall be updated with the remainder of unslept time when
@@ -79,18 +83,21 @@
 errno_t clock_nanosleep(int clock, int flags,        //
                         const struct timespec *req,  //
                         struct timespec *rem) {
-  if (IsMetal()) {
+  if (IsMetal())
     return ENOSYS;
-  }
+  if (IsLinux() && clock == CLOCK_REALTIME_COARSE)
+    clock = CLOCK_REALTIME;
+  if (IsLinux() && clock == CLOCK_MONOTONIC_COARSE)
+    clock = CLOCK_MONOTONIC;
   if (clock == 127 ||              //
       (flags & ~TIMER_ABSTIME) ||  //
       req->tv_sec < 0 ||           //
-      !(0 <= req->tv_nsec && req->tv_nsec <= 999999999)) {
+      !(0 <= req->tv_nsec && req->tv_nsec <= 999999999))
     return EINVAL;
-  }
-  errno_t old = errno;
-  int rc = sys_clock_nanosleep(clock, flags, req, rem);
-  errno_t err = !rc ? 0 : errno;
+  int rc;
+  errno_t err, old = errno;
+  rc = sys_clock_nanosleep(clock, flags, req, rem);
+  err = !rc ? 0 : errno;
   errno = old;
   return err;
 }
diff --git a/libc/calls/clock_settime.c b/libc/calls/clock_settime.c
index e738d35df..b618cbdec 100644
--- a/libc/calls/clock_settime.c
+++ b/libc/calls/clock_settime.c
@@ -21,8 +21,8 @@
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/struct/timeval.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/close-nt.c b/libc/calls/close-nt.c
index 5d5b49645..16557582f 100644
--- a/libc/calls/close-nt.c
+++ b/libc/calls/close-nt.c
@@ -17,13 +17,14 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/enum/filetype.h"
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
+#include "libc/runtime/runtime.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sock/syscall_fd.internal.h"
 #include "libc/sysv/consts/o.h"
@@ -51,11 +52,6 @@ textwindows int sys_close_nt(int fd, int fildes) {
         FlushFileBuffers(f->handle);
       }
       break;
-    case kFdEpoll:
-      if (_weaken(sys_close_epoll_nt)) {
-        return _weaken(sys_close_epoll_nt)(fd);
-      }
-      break;
     case kFdSocket:
       if (_weaken(sys_closesocket_nt)) {
         return _weaken(sys_closesocket_nt)(g_fds.p + fd);
@@ -64,5 +60,7 @@ textwindows int sys_close_nt(int fd, int fildes) {
     default:
       break;
   }
+  if (f->cursor)
+    __cursor_unref(f->cursor);
   return CloseHandle(f->handle) ? 0 : __winerr();
 }
diff --git a/libc/calls/close.c b/libc/calls/close.c
index d054f8199..2de6a55ef 100644
--- a/libc/calls/close.c
+++ b/libc/calls/close.c
@@ -20,14 +20,14 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
+#include "libc/intrin/fds.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sock/syscall_fd.internal.h"
@@ -74,7 +74,6 @@ static int close_impl(int fd) {
  * - openat()
  * - socket()
  * - accept()
- * - epoll_create()
  * - landlock_create_ruleset()
  *
  * This function should never be reattempted if an error is returned;
diff --git a/libc/calls/close_range.c b/libc/calls/close_range.c
index adf2049e5..3ee22d119 100644
--- a/libc/calls/close_range.c
+++ b/libc/calls/close_range.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/closefrom.c b/libc/calls/closefrom.c
index f102259cf..fe30a4672 100644
--- a/libc/calls/closefrom.c
+++ b/libc/calls/closefrom.c
@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/commandv.c b/libc/calls/commandv.c
index a603e4373..925ffbe1c 100644
--- a/libc/calls/commandv.c
+++ b/libc/calls/commandv.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/paths.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
diff --git a/libc/calls/copy.c b/libc/calls/copy.c
index 8be9d5c36..9140d40e9 100644
--- a/libc/calls/copy.c
+++ b/libc/calls/copy.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 
 /**
diff --git a/libc/calls/copy_file_range.c b/libc/calls/copy_file_range.c
index d35fcbc9a..1a340710e 100644
--- a/libc/calls/copy_file_range.c
+++ b/libc/calls/copy_file_range.c
@@ -27,8 +27,8 @@
 #include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
 
@@ -83,9 +83,11 @@ static void copy_file_range_init(void) {
  * @return number of bytes transferred, or -1 w/ errno
  * @raise EXDEV if source and destination are on different filesystems
  * @raise EBADF if `infd` or `outfd` aren't open files or append-only
+ * @raise EOPNOTSUPP if filesystem doesn't support this operation
  * @raise EPERM if `fdout` refers to an immutable file on Linux
  * @raise ECANCELED if thread was cancelled in masked mode
  * @raise EINVAL if ranges overlap or `flags` is non-zero
+ * @raise EINVAL on eCryptFs filesystems that have a bug
  * @raise EFBIG if `setrlimit(RLIMIT_FSIZE)` is exceeded
  * @raise EFAULT if one of the pointers memory is bad
  * @raise ERANGE if overflow happens computing ranges
diff --git a/libc/calls/createpipename.c b/libc/calls/createpipename.c
index a5d518522..f8eed1531 100644
--- a/libc/calls/createpipename.c
+++ b/libc/calls/createpipename.c
@@ -17,26 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/atomic.h"
+#include "libc/fmt/internal.h"
 #include "libc/intrin/atomic.h"
 #include "libc/runtime/internal.h"
 
-static textwindows char16_t *itoa16(char16_t p[21], uint64_t x) {
-  char t;
-  size_t a, b, i = 0;
-  do {
-    p[i++] = x % 10 + '0';
-    x = x / 10;
-  } while (x > 0);
-  if (i) {
-    for (a = 0, b = i - 1; a < b; ++a, --b) {
-      t = p[a];
-      p[a] = p[b];
-      p[b] = t;
-    }
-  }
-  return p + i;
-}
-
 // This function is called very early by WinMain().
 textwindows char16_t *__create_pipe_name(char16_t *a) {
   char16_t *p = a;
@@ -44,9 +28,9 @@ textwindows char16_t *__create_pipe_name(char16_t *a) {
   static atomic_uint x;
   while (*q)
     *p++ = *q++;
-  p = itoa16(p, __pid);
+  p = __itoa16(p, __pid);
   *p++ = '-';
-  p = itoa16(p, atomic_fetch_add(&x, 1));
+  p = __itoa16(p, atomic_fetch_add(&x, 1));
   *p = 0;
   return a;
 }
diff --git a/libc/calls/dup-nt.c b/libc/calls/dup-nt.c
index 35a07a223..4bf3f68fc 100644
--- a/libc/calls/dup-nt.c
+++ b/libc/calls/dup-nt.c
@@ -24,6 +24,7 @@
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/errno.h"
+#include "libc/intrin/fds.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/files.h"
@@ -82,6 +83,7 @@ static textwindows int sys_dup_nt_impl(int oldfd, int newfd, int flags,
 
   g_fds.p[newfd] = g_fds.p[oldfd];
   g_fds.p[newfd].handle = handle;
+  __cursor_ref(g_fds.p[newfd].cursor);
   if (flags & _O_CLOEXEC) {
     g_fds.p[newfd].flags |= _O_CLOEXEC;
   } else {
diff --git a/libc/calls/dup.c b/libc/calls/dup.c
index caab149ee..e502622fb 100644
--- a/libc/calls/dup.c
+++ b/libc/calls/dup.c
@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/dup2.c b/libc/calls/dup2.c
index 34d42dd12..3d5178259 100644
--- a/libc/calls/dup2.c
+++ b/libc/calls/dup2.c
@@ -23,7 +23,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/str/str.h"
diff --git a/libc/calls/dup3-sysv.c b/libc/calls/dup3-sysv.c
index 5f7889091..93cf8a732 100644
--- a/libc/calls/dup3-sysv.c
+++ b/libc/calls/dup3-sysv.c
@@ -22,7 +22,7 @@
 #include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/dup3.c b/libc/calls/dup3.c
index 368942c61..4d2f327cc 100644
--- a/libc/calls/dup3.c
+++ b/libc/calls/dup3.c
@@ -23,7 +23,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/str/str.h"
diff --git a/libc/calls/faccessat.c b/libc/calls/faccessat.c
index 7493e5e90..f9df7a9c0 100644
--- a/libc/calls/faccessat.c
+++ b/libc/calls/faccessat.c
@@ -22,8 +22,8 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/consts/at.h"
diff --git a/libc/calls/fadvise.c b/libc/calls/fadvise.c
index fb191ff34..36078bbcd 100644
--- a/libc/calls/fadvise.c
+++ b/libc/calls/fadvise.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/fchdir.c b/libc/calls/fchdir.c
index cfa17b725..509d078f3 100644
--- a/libc/calls/fchdir.c
+++ b/libc/calls/fchdir.c
@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/fchmod-nt.c b/libc/calls/fchmod-nt.c
index 5b31226c0..bd3249070 100644
--- a/libc/calls/fchmod-nt.c
+++ b/libc/calls/fchmod-nt.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/nt/enum/fileflagandattributes.h"
diff --git a/libc/calls/fchmod.c b/libc/calls/fchmod.c
index a4070cb02..88a0221d9 100644
--- a/libc/calls/fchmod.c
+++ b/libc/calls/fchmod.c
@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/fchmodat.c b/libc/calls/fchmodat.c
index e5bbc9bdf..744ad5bdb 100644
--- a/libc/calls/fchmodat.c
+++ b/libc/calls/fchmodat.c
@@ -22,8 +22,8 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/fchown.c b/libc/calls/fchown.c
index e105e7bb6..2418873b8 100644
--- a/libc/calls/fchown.c
+++ b/libc/calls/fchown.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/at.h"
 
 /**
diff --git a/libc/calls/fchownat.c b/libc/calls/fchownat.c
index 132cacac5..235f403ff 100644
--- a/libc/calls/fchownat.c
+++ b/libc/calls/fchownat.c
@@ -19,8 +19,8 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/fcntl-nt.c b/libc/calls/fcntl-nt.c
index 73584e48d..77b8331a1 100644
--- a/libc/calls/fcntl-nt.c
+++ b/libc/calls/fcntl-nt.c
@@ -20,18 +20,18 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/createfileflags.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/flock.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/calls/wincrash.internal.h"
 #include "libc/errno.h"
+#include "libc/intrin/fds.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
 #include "libc/log/backtrace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/leaks.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/createfile.h"
@@ -51,6 +51,7 @@
 #include "libc/sysv/consts/fio.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 
 struct FileLock {
@@ -67,7 +68,9 @@ struct FileLocks {
   struct FileLock *free;
 };
 
-static struct FileLocks g_locks;
+static struct FileLocks g_locks = {
+    .mu = PTHREAD_MUTEX_INITIALIZER,
+};
 
 static textwindows struct FileLock *NewFileLock(void) {
   struct FileLock *fl;
@@ -110,7 +113,7 @@ static textwindows bool EqualsFileLock(struct FileLock *fl, int64_t off,
 
 textwindows void sys_fcntl_nt_lock_cleanup(int fd) {
   struct FileLock *fl, *ft, **flp;
-  pthread_mutex_lock(&g_locks.mu);
+  _pthread_mutex_lock(&g_locks.mu);
   for (flp = &g_locks.list, fl = *flp; fl;) {
     if (fl->fd == fd) {
       *flp = fl->next;
@@ -122,7 +125,7 @@ textwindows void sys_fcntl_nt_lock_cleanup(int fd) {
       fl = *flp;
     }
   }
-  pthread_mutex_unlock(&g_locks.mu);
+  _pthread_mutex_unlock(&g_locks.mu);
 }
 
 static textwindows int64_t GetfileSize(int64_t handle) {
@@ -151,7 +154,7 @@ static textwindows int sys_fcntl_nt_lock(struct Fd *f, int fd, int cmd,
     case SEEK_SET:
       break;
     case SEEK_CUR:
-      off = f->pointer + off;
+      off = f->cursor->shared->pointer + off;
       break;
     case SEEK_END: {
       int64_t size;
@@ -351,9 +354,14 @@ textwindows int sys_fcntl_nt(int fd, int cmd, uintptr_t arg) {
       }
       rc = 0;
     } else if (cmd == F_SETLK || cmd == F_SETLKW || cmd == F_GETLK) {
-      pthread_mutex_lock(&g_locks.mu);
-      rc = sys_fcntl_nt_lock(g_fds.p + fd, fd, cmd, arg);
-      pthread_mutex_unlock(&g_locks.mu);
+      struct Fd *f = g_fds.p + fd;
+      if (f->cursor) {
+        _pthread_mutex_lock(&g_locks.mu);
+        rc = sys_fcntl_nt_lock(f, fd, cmd, arg);
+        _pthread_mutex_unlock(&g_locks.mu);
+      } else {
+        rc = ebadf();
+      }
     } else if (cmd == F_DUPFD || cmd == F_DUPFD_CLOEXEC) {
       rc = sys_fcntl_nt_dupfd(fd, cmd, arg);
     } else {
diff --git a/libc/calls/fcntl.c b/libc/calls/fcntl.c
index 497ff2ccb..5193c291e 100644
--- a/libc/calls/fcntl.c
+++ b/libc/calls/fcntl.c
@@ -24,8 +24,8 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/str/str.h"
diff --git a/libc/calls/fdatasync.c b/libc/calls/fdatasync.c
index a452e6bdf..0bf8c3453 100644
--- a/libc/calls/fdatasync.c
+++ b/libc/calls/fdatasync.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/fdexists.c b/libc/calls/fdexists.c
index fd5b9b71b..0965ec528 100644
--- a/libc/calls/fdexists.c
+++ b/libc/calls/fdexists.c
@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/f.h"
 
 /**
diff --git a/libc/calls/fileexists.c b/libc/calls/fileexists.c
index 03d3a9b80..56d58474d 100644
--- a/libc/calls/fileexists.c
+++ b/libc/calls/fileexists.c
@@ -23,7 +23,7 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/files.h"
 #include "libc/runtime/zipos.internal.h"
diff --git a/libc/calls/finddebugbinary.c b/libc/calls/finddebugbinary.c
index b4bae854e..8b0efed7d 100644
--- a/libc/calls/finddebugbinary.c
+++ b/libc/calls/finddebugbinary.c
@@ -26,7 +26,8 @@
 #include "libc/elf/def.h"
 #include "libc/elf/tinyelf.internal.h"
 #include "libc/errno.h"
-#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/directmap.h"
+#include "libc/intrin/promises.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/runtime.h"
 #include "libc/runtime/runtime.h"
@@ -69,42 +70,35 @@ static int GetElfMachine(void) {
 }
 
 static bool IsMyDebugBinary(const char *path) {
+  void *addr;
   int64_t size;
   uintptr_t value;
   bool res = false;
   int fd, e = errno;
-  struct DirectMap dm;
-  BLOCK_CANCELATION;
   if ((fd = open(path, O_RDONLY | O_CLOEXEC, 0)) != -1) {
     // sanity test that this .com.dbg file (1) is an elf image, and (2)
     // contains the same number of bytes of code as our .com executable
     // which is currently running in memory.
     if ((size = lseek(fd, 0, SEEK_END)) != -1 &&
-        (dm = sys_mmap((void *)0x12345000000, size, PROT_READ, MAP_SHARED, fd,
-                       0))
-                .addr != MAP_FAILED) {
-      if (READ32LE((char *)dm.addr) == READ32LE("\177ELF") &&
-          ((Elf64_Ehdr *)dm.addr)->e_machine == GetElfMachine() &&
-          GetElfSymbolValue(dm.addr, "_etext", &value)) {
+        (addr = mmap(0, size, PROT_READ, MAP_SHARED, fd, 0)) != MAP_FAILED) {
+      if (READ32LE((char *)addr) == READ32LE("\177ELF") &&
+          ((Elf64_Ehdr *)addr)->e_machine == GetElfMachine() &&
+          GetElfSymbolValue(addr, "_etext", &value)) {
         res = !_etext || value == (uintptr_t)_etext;
       }
-      if (!IsWindows()) {
-        sys_munmap(dm.addr, size);
-      } else {
-        CloseHandle(dm.maphandle);
-        UnmapViewOfFile(dm.addr);
-      }
+      munmap(addr, size);
     }
     close(fd);
   }
-  ALLOW_CANCELATION;
   errno = e;
   return res;
 }
 
 static void FindDebugBinaryInit(void) {
   const char *comdbg;
-  if ((comdbg = getenv("COMDBG")) && IsMyDebugBinary(comdbg)) {
+  if (issetugid())
+    return;
+  if ((comdbg = getenv("COMDBG"))) {
     g_comdbg.res = comdbg;
     return;
   }
@@ -123,9 +117,19 @@ static void FindDebugBinaryInit(void) {
 /**
  * Returns path of binary with the debug information, or null.
  *
- * @return path to debug binary, or NULL
+ * You can specify the COMDBG environment variable, with the path of the
+ * debug binary, in case the automatic heuristics fail. What we look for
+ * is GetProgramExecutableName() with ".dbg", ".com.dbg", etc. appended.
+ *
+ * @return path to debug binary, or NULL if we couldn't find it
+ * @asyncsignalsafe
  */
 const char *FindDebugBinary(void) {
   cosmo_once(&g_comdbg.once, FindDebugBinaryInit);
   return g_comdbg.res;
 }
+
+// pay startup cost to make this signal safe from the user's perspective
+__attribute__((__constructor__(10))) static void FindDebugBinaryCtor(void) {
+  cosmo_once(&g_comdbg.once, FindDebugBinaryInit);
+}
diff --git a/libc/calls/fixenotdir.c b/libc/calls/fixenotdir.c
index 8787578a6..1537ea69c 100644
--- a/libc/calls/fixenotdir.c
+++ b/libc/calls/fixenotdir.c
@@ -23,10 +23,20 @@
 #include "libc/nt/files.h"
 #include "libc/str/str.h"
 
+static int IsAlpha(int c) {
+  return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z');
+}
+
 static textwindows bool SubpathExistsThatsNotDirectory(char16_t *path) {
   char16_t *p;
   uint32_t attrs;
   while ((p = strrchr16(path, '\\'))) {
+    if (p == path)
+      // don't bother checking GetFileAttributes(u"\\")
+      break;
+    if (p == path + 2 && IsAlpha(path[0]) && path[1] == ':')
+      // don't bother checking GetFileAttributes(u"C:\\")
+      break;
     *p = u'\0';
     if ((attrs = GetFileAttributes(path)) != -1u &&
         !(attrs & kNtFileAttributeDirectory)) {
diff --git a/libc/calls/flock-nt.c b/libc/calls/flock-nt.c
index 734362ffa..1f23a0e69 100644
--- a/libc/calls/flock-nt.c
+++ b/libc/calls/flock-nt.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/nt/enum/filelockflags.h"
diff --git a/libc/calls/flock.c b/libc/calls/flock.c
index 080e2f1f7..2935e1e65 100644
--- a/libc/calls/flock.c
+++ b/libc/calls/flock.c
@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Acquires lock on file.
diff --git a/libc/calls/fstat-nt.c b/libc/calls/fstat-nt.c
index 97a941b1c..b3edea321 100644
--- a/libc/calls/fstat-nt.c
+++ b/libc/calls/fstat-nt.c
@@ -19,15 +19,15 @@
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/calls/struct/stat.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/fmt/wintime.internal.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/bsr.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/mem/alloca.h"
 #include "libc/nt/enum/fileflagandattributes.h"
 #include "libc/nt/enum/fileinfobyhandleclass.h"
@@ -119,81 +119,82 @@ textwindows int sys_fstat_nt_handle(int64_t handle, const char16_t *path,
 
   // Always set st_blksize to avoid divide by zero issues.
   // The Linux kernel sets this for /dev/tty and similar too.
-  // TODO(jart): GetVolumeInformationByHandle?
   st.st_blksize = 4096;
   st.st_gid = st.st_uid = sys_getuid_nt();
 
-  // We'll use the "umask" to fake out the mode bits.
-  uint32_t umask = atomic_load_explicit(&__umask, memory_order_acquire);
-
   switch (GetFileType(handle)) {
     case kNtFileTypeUnknown:
       break;
     case kNtFileTypeChar:
-      st.st_mode = S_IFCHR | (0666 & ~umask);
+      st.st_mode = S_IFCHR | 0664;
       st.st_dev = 0x66666666;
       st.st_ino = handle;
       break;
     case kNtFileTypePipe:
-      st.st_mode = S_IFIFO | (0666 & ~umask);
+      st.st_mode = S_IFIFO | 0664;
       st.st_dev = 0x55555555;
       st.st_ino = handle;
       break;
     case kNtFileTypeDisk: {
       struct NtByHandleFileInformation wst;
-      if (!GetFileInformationByHandle(handle, &wst)) {
-        return __winerr();
-      }
-      st.st_mode = 0444 & ~umask;
-      if ((wst.dwFileAttributes & kNtFileAttributeDirectory) ||
-          IsWindowsExecutable(handle, path)) {
-        st.st_mode |= 0111 & ~umask;
-      }
-      st.st_flags = wst.dwFileAttributes;
-      if (!(wst.dwFileAttributes & kNtFileAttributeReadonly)) {
-        st.st_mode |= 0222 & ~umask;
-      }
-      if (wst.dwFileAttributes & kNtFileAttributeReparsePoint) {
-        st.st_mode |= S_IFLNK;
-      } else if (wst.dwFileAttributes & kNtFileAttributeDirectory) {
-        st.st_mode |= S_IFDIR;
-      } else {
-        st.st_mode |= S_IFREG;
-      }
-      st.st_atim = FileTimeToTimeSpec(wst.ftLastAccessFileTime);
-      st.st_mtim = FileTimeToTimeSpec(wst.ftLastWriteFileTime);
-      st.st_birthtim = FileTimeToTimeSpec(wst.ftCreationFileTime);
-      // compute time of last status change
-      if (timespec_cmp(st.st_atim, st.st_mtim) > 0) {
-        st.st_ctim = st.st_atim;
-      } else {
-        st.st_ctim = st.st_mtim;
-      }
-      st.st_size = (wst.nFileSizeHigh + 0ull) << 32 | wst.nFileSizeLow;
-      st.st_dev = wst.dwVolumeSerialNumber;
-      st.st_ino = (wst.nFileIndexHigh + 0ull) << 32 | wst.nFileIndexLow;
-      st.st_nlink = wst.nNumberOfLinks;
-      if (S_ISLNK(st.st_mode)) {
-        if (!st.st_size) {
-          long size = GetSizeOfReparsePoint(handle);
-          if (size == -1)
-            return -1;
-          st.st_size = size;
-        }
-      } else {
-        // st_size       = uncompressed size
-        // st_blocks*512 = physical size
-        uint64_t physicalsize;
-        struct NtFileCompressionInfo fci;
-        if (!(wst.dwFileAttributes &
-              (kNtFileAttributeDirectory | kNtFileAttributeReparsePoint)) &&
-            GetFileInformationByHandleEx(handle, kNtFileCompressionInfo, &fci,
-                                         sizeof(fci))) {
-          physicalsize = fci.CompressedFileSize;
+      if (GetFileInformationByHandle(handle, &wst)) {
+        st.st_mode = 0444;
+        if ((wst.dwFileAttributes & kNtFileAttributeDirectory) ||
+            IsWindowsExecutable(handle, path))
+          st.st_mode |= 0111;
+        st.st_flags = wst.dwFileAttributes;
+        if (!(wst.dwFileAttributes & kNtFileAttributeReadonly))
+          st.st_mode |= 0220;
+        if (wst.dwFileAttributes & kNtFileAttributeReparsePoint) {
+          st.st_mode |= S_IFLNK;
+        } else if (wst.dwFileAttributes & kNtFileAttributeDirectory) {
+          st.st_mode |= S_IFDIR;
         } else {
-          physicalsize = st.st_size;
+          st.st_mode |= S_IFREG;
         }
-        st.st_blocks = ROUNDUP(physicalsize, st.st_blksize) / 512;
+        st.st_atim = FileTimeToTimeSpec(wst.ftLastAccessFileTime);
+        st.st_mtim = FileTimeToTimeSpec(wst.ftLastWriteFileTime);
+        st.st_birthtim = FileTimeToTimeSpec(wst.ftCreationFileTime);
+        // compute time of last status change
+        if (timespec_cmp(st.st_atim, st.st_mtim) > 0) {
+          st.st_ctim = st.st_atim;
+        } else {
+          st.st_ctim = st.st_mtim;
+        }
+        st.st_size = (wst.nFileSizeHigh + 0ull) << 32 | wst.nFileSizeLow;
+        st.st_dev = wst.dwVolumeSerialNumber;
+        st.st_ino = (wst.nFileIndexHigh + 0ull) << 32 | wst.nFileIndexLow;
+        st.st_nlink = wst.nNumberOfLinks;
+        if (S_ISLNK(st.st_mode)) {
+          if (!st.st_size) {
+            long size = GetSizeOfReparsePoint(handle);
+            if (size == -1)
+              return -1;
+            st.st_size = size;
+          }
+        } else {
+          // st_size       = uncompressed size
+          // st_blocks*512 = physical size
+          uint64_t physicalsize;
+          struct NtFileCompressionInfo fci;
+          if (!(wst.dwFileAttributes &
+                (kNtFileAttributeDirectory | kNtFileAttributeReparsePoint)) &&
+              GetFileInformationByHandleEx(handle, kNtFileCompressionInfo, &fci,
+                                           sizeof(fci))) {
+            physicalsize = fci.CompressedFileSize;
+          } else {
+            physicalsize = st.st_size;
+          }
+          st.st_blocks = ROUNDUP(physicalsize, st.st_blksize) / 512;
+        }
+      } else if (GetVolumeInformationByHandle(
+                     handle, 0, 0, &wst.dwVolumeSerialNumber, 0, 0, 0, 0)) {
+        st.st_dev = wst.dwVolumeSerialNumber;
+        st.st_mode = S_IFDIR | 0555;
+      } else {
+        // both GetFileInformationByHandle and
+        // GetVolumeInformationByHandle failed
+        return __winerr();
       }
       break;
     }
diff --git a/libc/calls/fstat.c b/libc/calls/fstat.c
index bec74978d..094ae5347 100644
--- a/libc/calls/fstat.c
+++ b/libc/calls/fstat.c
@@ -20,8 +20,8 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/stat.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/fstatat-nt.c b/libc/calls/fstatat-nt.c
index b8b75e8f8..cfca355cc 100644
--- a/libc/calls/fstatat-nt.c
+++ b/libc/calls/fstatat-nt.c
@@ -16,11 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/struct/stat.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/errno.h"
+#include "libc/intrin/fds.h"
 #include "libc/nt/createfile.h"
 #include "libc/nt/enum/accessmask.h"
 #include "libc/nt/enum/creationdisposition.h"
@@ -97,14 +97,27 @@ TryAgain:
            0)) != -1) {
     rc = st ? sys_fstat_nt_handle(fh, path16, st) : 0;
     CloseHandle(fh);
-  } else if (dwDesiredAccess == kNtFileGenericRead &&
-             (GetLastError() == kNtErrorAccessDenied ||
-              GetLastError() == kNtErrorSharingViolation)) {
-    dwDesiredAccess = kNtFileReadAttributes;
-    errno = e;
-    goto TryAgain;
   } else {
-    rc = __winerr();
+    uint32_t dwErrorCode = GetLastError();
+    if (dwDesiredAccess == kNtFileGenericRead &&
+        (dwErrorCode == kNtErrorAccessDenied ||
+         dwErrorCode == kNtErrorSharingViolation)) {
+      dwDesiredAccess = kNtFileReadAttributes;
+      errno = e;
+      goto TryAgain;
+    } else if (!(flags & AT_SYMLINK_NOFOLLOW) &&
+               dwErrorCode == kNtErrorCantAccessFile) {
+      // ERROR_CANT_ACCESS_FILE (1920) usually means that the I/O system
+      // a WSL symlink is accessed from WIN32 API. Falling back with the
+      // failed to traverse a filesystem reparse point. For example when
+      // details of the link itself is better than providing nothing. It
+      // should never be like this on UNIX but Windows gets a bit screwy
+      flags |= AT_SYMLINK_NOFOLLOW;
+      errno = e;
+      goto TryAgain;
+    } else {
+      rc = __winerr();
+    }
   }
   ALLOW_SIGNALS;
 
diff --git a/libc/calls/fstatat.c b/libc/calls/fstatat.c
index 9e4247067..0d4946f95 100644
--- a/libc/calls/fstatat.c
+++ b/libc/calls/fstatat.c
@@ -23,8 +23,8 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/log.h"
 #include "libc/mem/alloca.h"
diff --git a/libc/calls/fstatfs-nt.c b/libc/calls/fstatfs-nt.c
index 06c0ce515..f7d0229bc 100644
--- a/libc/calls/fstatfs-nt.c
+++ b/libc/calls/fstatfs-nt.c
@@ -23,7 +23,7 @@
 #include "libc/calls/struct/statfs.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/fsinformationclass.h"
 #include "libc/nt/enum/status.h"
 #include "libc/nt/files.h"
diff --git a/libc/calls/fstatfs.c b/libc/calls/fstatfs.c
index 607acb621..fee2e5039 100644
--- a/libc/calls/fstatfs.c
+++ b/libc/calls/fstatfs.c
@@ -19,11 +19,11 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/statfs-meta.internal.h"
 #include "libc/calls/struct/statfs.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/stack.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/fsync.c b/libc/calls/fsync.c
index 95a28e45e..72c2bd823 100644
--- a/libc/calls/fsync.c
+++ b/libc/calls/fsync.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/ftruncate.c b/libc/calls/ftruncate.c
index e441d4617..0b76efa4c 100644
--- a/libc/calls/ftruncate.c
+++ b/libc/calls/ftruncate.c
@@ -23,7 +23,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/futimens.c b/libc/calls/futimens.c
index 5a45ef505..e2c2332db 100644
--- a/libc/calls/futimens.c
+++ b/libc/calls/futimens.c
@@ -19,7 +19,7 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/futimes.c b/libc/calls/futimes.c
index 50f814c14..0bb6572cf 100644
--- a/libc/calls/futimes.c
+++ b/libc/calls/futimes.c
@@ -21,7 +21,7 @@
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/struct/timeval.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/getcpu.c b/libc/calls/getcpu.c
index bdc97089e..b689f43fc 100644
--- a/libc/calls/getcpu.c
+++ b/libc/calls/getcpu.c
@@ -30,39 +30,63 @@
 
 int sys_getcpu(unsigned *opt_cpu, unsigned *opt_node, void *tcache);
 
+/**
+ * Determines ID of CPU on which thread is currently scheduled.
+ *
+ * This is the same as sched_getcpu(), except it also supports returning
+ * the ID of the current NUMA node. On some platforms this functionality
+ * isn't available, in which case `out_opt_node` is always be set to 0.
+ */
 int getcpu(unsigned *out_opt_cpu, unsigned *out_opt_node) {
-  unsigned cpu;
-  unsigned node;
-  if (X86_HAVE(RDTSCP)) {
+
+  if (IsWindows()) {
+    struct NtProcessorNumber pn;
+    if (out_opt_cpu) {
+      GetCurrentProcessorNumberEx(&pn);
+      *out_opt_cpu = 64 * pn.Group + pn.Number;
+    }
+    if (out_opt_node) {
+      unsigned short node16;
+      if (GetNumaProcessorNodeEx(&pn, &node16)) {
+        *out_opt_node = node16;
+      } else {
+        return __winerr();
+      }
+    }
+    return 0;
+  }
+
+#ifdef __x86_64__
+  if (X86_HAVE(RDTSCP) && (IsLinux() || IsFreebsd())) {
     unsigned tsc_aux;
     rdtscp(&tsc_aux);
-    cpu = TSC_AUX_CORE(tsc_aux);
-    node = TSC_AUX_NODE(tsc_aux);
-  } else if (IsWindows()) {
-    struct NtProcessorNumber pn;
-    GetCurrentProcessorNumberEx(&pn);
-    cpu = 64 * pn.Group + pn.Number;
-    unsigned short node16;
-    if (GetNumaProcessorNodeEx(&pn, &node16)) {
-      node = node16;
-    } else {
-      return __winerr();
+    if (out_opt_cpu)
+      *out_opt_cpu = TSC_AUX_CORE(tsc_aux);
+    if (out_opt_node)
+      *out_opt_node = TSC_AUX_NODE(tsc_aux);
+    return 0;
+  }
+#endif
+
+  if (IsXnu() || IsOpenbsd() || IsNetbsd() || IsFreebsd()) {
+    if (out_opt_cpu) {
+      int rc = sched_getcpu();
+      if (rc == -1)
+        return -1;
+      *out_opt_cpu = rc;
     }
-  } else if (IsAarch64()) {
-    long tpidr_el0;
-    asm("mrs\t%0,tpidr_el0" : "=r"(tpidr_el0));
-    cpu = tpidr_el0 & 255;
-    node = 0;
-  } else {
-    int rc = sys_getcpu(&cpu, &node, 0);
-    if (rc == -1)
-      return -1;
+    if (out_opt_node)
+      *out_opt_node = 0;
+    return 0;
   }
-  if (out_opt_cpu) {
+
+  unsigned cpu, node;
+  int rc = sys_getcpu(&cpu, &node, 0);
+  if (rc == -1)
+    return -1;
+  if (out_opt_cpu)
     *out_opt_cpu = cpu;
-  }
-  if (out_opt_node) {
+  if (out_opt_node)
     *out_opt_node = node;
-  }
   return 0;
 }
diff --git a/libc/calls/getcwd.greg.c b/libc/calls/getcwd.greg.c
index edabb8af1..81dde1559 100644
--- a/libc/calls/getcwd.greg.c
+++ b/libc/calls/getcwd.greg.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/nt/files.h"
 #include "libc/stdio/sysparam.h"
diff --git a/libc/calls/getdomainname.c b/libc/calls/getdomainname.c
index b188ff066..988cbdd2e 100644
--- a/libc/calls/getdomainname.c
+++ b/libc/calls/getdomainname.c
@@ -19,8 +19,8 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/computernameformat.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/getdtablesize.c b/libc/calls/getdtablesize.c
index fdfd06ac5..cc5a7460e 100644
--- a/libc/calls/getdtablesize.c
+++ b/libc/calls/getdtablesize.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/rlimit.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/rlimit.h"
 
diff --git a/libc/calls/getegid.c b/libc/calls/getegid.c
index 09d8cec0d..c48ab96cc 100644
--- a/libc/calls/getegid.c
+++ b/libc/calls/getegid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 
 /**
diff --git a/libc/calls/geteuid.c b/libc/calls/geteuid.c
index aa618ddcc..eedafcd9c 100644
--- a/libc/calls/geteuid.c
+++ b/libc/calls/geteuid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Returns effective user ID of calling process.
diff --git a/libc/calls/getgroups.c b/libc/calls/getgroups.c
index 72d49a49a..25251453b 100644
--- a/libc/calls/getgroups.c
+++ b/libc/calls/getgroups.c
@@ -19,9 +19,8 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/groups.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/stdckdint.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/gethostname-nt.c b/libc/calls/gethostname-nt.c
index e1c9e1f0b..a39b0d013 100644
--- a/libc/calls/gethostname-nt.c
+++ b/libc/calls/gethostname-nt.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/computernameformat.h"
 #include "libc/nt/systeminfo.h"
 #include "libc/str/str.h"
diff --git a/libc/calls/gethostname.c b/libc/calls/gethostname.c
index 6419fbae2..10a3cb12c 100644
--- a/libc/calls/gethostname.c
+++ b/libc/calls/gethostname.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/computernameformat.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/getloadavg-nt.c b/libc/calls/getloadavg-nt.c
index 4e8d6d847..77e0a83ed 100644
--- a/libc/calls/getloadavg-nt.c
+++ b/libc/calls/getloadavg-nt.c
@@ -21,24 +21,23 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/fmt/conv.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/cxaatexit.h"
+#include "libc/macros.h"
 #include "libc/nt/accounting.h"
 #include "libc/runtime/runtime.h"
-#include "libc/thread/thread.h"
 
+#define CTOR  __attribute__((__constructor__(99)))
 #define FT(x) (x.dwLowDateTime | (uint64_t)x.dwHighDateTime << 32)
 
 static int cpus;
 static double load;
-static pthread_spinlock_t lock;
 static struct NtFileTime idle1, kern1, user1;
 
 textwindows int sys_getloadavg_nt(double *a, int n) {
   int i, rc;
   uint64_t elapsed, used;
   struct NtFileTime idle, kern, user;
-  BLOCK_SIGNALS;
-  pthread_spin_lock(&lock);
+  __cxa_lock();
   if (GetSystemTimes(&idle, &kern, &user)) {
     elapsed = (FT(kern) - FT(kern1)) + (FT(user) - FT(user1));
     if (elapsed) {
@@ -54,12 +53,11 @@ textwindows int sys_getloadavg_nt(double *a, int n) {
   } else {
     rc = __winerr();
   }
-  pthread_spin_unlock(&lock);
-  ALLOW_SIGNALS;
+  __cxa_unlock();
   return rc;
 }
 
-__attribute__((__constructor__(40))) static textstartup void ntinitload(void) {
+CTOR static textstartup void sys_getloadavg_nt_init(void) {
   if (IsWindows()) {
     load = 1;
     cpus = __get_cpu_count() / 2;
diff --git a/libc/calls/getloadavg.c b/libc/calls/getloadavg.c
index eb28d34c4..ad13a8610 100644
--- a/libc/calls/getloadavg.c
+++ b/libc/calls/getloadavg.c
@@ -21,7 +21,7 @@
 #include "libc/calls/struct/sysinfo.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 #define CTL_VM     2
diff --git a/libc/calls/getntsyspath.S b/libc/calls/getntsyspath.S
index 62bd818f0..bd8178bd3 100644
--- a/libc/calls/getntsyspath.S
+++ b/libc/calls/getntsyspath.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Obtains WIN32 magic path, e.g. GetTempPathA.
 //
@@ -28,8 +28,8 @@
 //	@return	rdi is rdi+edx
 	.text.startup
 __getntsyspath:
-	push	%rbp
-	mov	%rsp,%rbp
+	beg
+	pro
 	push	%rdx
 	movpp	%rdi,%rcx		# call f=%rax(p1=%rcx,p2=%rdx)
 	sub	$40,%rsp
@@ -55,6 +55,7 @@ __getntsyspath:
 	jne	2f
 	movb	$'/',-1(%rdi)
 2:	.loop	1b
-	leave
+	epi
 	ret
+	end
 	.endfn	__getntsyspath,globl,hidden
diff --git a/libc/calls/getpgid.c b/libc/calls/getpgid.c
index 3b6760ddd..ba353cd7d 100644
--- a/libc/calls/getpgid.c
+++ b/libc/calls/getpgid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Returns process group id.
diff --git a/libc/calls/getpgrp.c b/libc/calls/getpgrp.c
index 6ba24c23c..718b7b8a5 100644
--- a/libc/calls/getpgrp.c
+++ b/libc/calls/getpgrp.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Returns process group id of calling process.
diff --git a/libc/calls/getppid-nt.c b/libc/calls/getppid-nt.c
deleted file mode 100644
index 438cafc61..000000000
--- a/libc/calls/getppid-nt.c
+++ /dev/null
@@ -1,37 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/syscall-nt.internal.h"
-#include "libc/nt/enum/status.h"
-#include "libc/nt/nt/process.h"
-#include "libc/nt/process.h"
-#include "libc/nt/runtime.h"
-#include "libc/nt/struct/processbasicinformation.h"
-
-textwindows int sys_getppid_nt(void) {
-  struct NtProcessBasicInformation ProcessInformation;
-  uint32_t gotsize = 0;
-  if (!NtError(
-          NtQueryInformationProcess(GetCurrentProcess(), 0, &ProcessInformation,
-                                    sizeof(ProcessInformation), &gotsize)) &&
-      gotsize >= sizeof(ProcessInformation) &&
-      ProcessInformation.InheritedFromUniqueProcessId) {
-    return ProcessInformation.InheritedFromUniqueProcessId;
-  }
-  return GetCurrentProcessId();
-}
diff --git a/libc/calls/getprogramexecutablename.greg.c b/libc/calls/getprogramexecutablename.greg.c
index 067e7a0a3..8589bb099 100644
--- a/libc/calls/getprogramexecutablename.greg.c
+++ b/libc/calls/getprogramexecutablename.greg.c
@@ -24,10 +24,10 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/libgen.h"
-#include "libc/intrin/getenv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/getenv.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/runtime.h"
 #include "libc/runtime/runtime.h"
 #include "libc/serialize.h"
@@ -96,9 +96,8 @@ static int OldApeLoader(char *s) {
 static int CopyWithCwd(const char *q, char *p, char *e) {
   char c;
   if (*q != '/') {
-    if (q[0] == '.' && q[1] == '/') {
+    if (q[0] == '.' && q[1] == '/')
       q += 2;
-    }
     int got = __getcwd(p, e - p - 1 /* '/' */);
     if (got != -1) {
       p += got - 1;
@@ -118,9 +117,10 @@ static int CopyWithCwd(const char *q, char *p, char *e) {
 
 // if q exists then turn it into an absolute path.
 static int TryPath(const char *q) {
-  if (!CopyWithCwd(q, g_prog.u.buf, g_prog.u.buf + sizeof(g_prog.u.buf))) {
+  if (!q)
+    return 0;
+  if (!CopyWithCwd(q, g_prog.u.buf, g_prog.u.buf + sizeof(g_prog.u.buf)))
     return 0;
-  }
   return !sys_faccessat(AT_FDCWD, g_prog.u.buf, F_OK, 0);
 }
 
@@ -129,9 +129,8 @@ static int TryPath(const char *q) {
 void __init_program_executable_name(void) {
   if (__program_executable_name && *__program_executable_name != '/' &&
       CopyWithCwd(__program_executable_name, g_prog.u.buf,
-                  g_prog.u.buf + sizeof(g_prog.u.buf))) {
+                  g_prog.u.buf + sizeof(g_prog.u.buf)))
     __program_executable_name = g_prog.u.buf;
-  }
 }
 
 static inline void InitProgramExecutableNameImpl(void) {
@@ -212,14 +211,12 @@ static inline void InitProgramExecutableNameImpl(void) {
   }
 
   // don't trust argv or envp if set-id.
-  if (issetugid()) {
+  if (issetugid())
     goto UseEmpty;
-  }
 
   // try argv[0], then then $_.
-  if (TryPath(__argv[0]) || TryPath(__getenv(__envp, "_").s)) {
+  if (TryPath(__argv[0]) || TryPath(__getenv(__envp, "_").s))
     goto UseBuf;
-  }
 
   // give up and just copy argv[0] into it
   if ((q = __argv[0])) {
diff --git a/libc/calls/getrandom.c b/libc/calls/getrandom.c
index b15abf069..a0c53383b 100644
--- a/libc/calls/getrandom.c
+++ b/libc/calls/getrandom.c
@@ -30,9 +30,9 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/asmflag.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/kcpuids.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/nexgen32e/vendor.internal.h"
@@ -86,26 +86,36 @@ static ssize_t GetRandomBsd(char *p, size_t n, void impl(char *, size_t)) {
   }
 }
 
-static ssize_t GetDevUrandom(char *p, size_t n) {
+static ssize_t GetDevUrandom(char *p, size_t n, unsigned f) {
   int fd;
+  int oflags;
   ssize_t rc;
-  BLOCK_SIGNALS;
-  BLOCK_CANCELATION;
-  fd = sys_openat(AT_FDCWD, "/dev/urandom", O_RDONLY | O_CLOEXEC, 0);
+  const char *dev;
+  BEGIN_CANCELATION_POINT;
+  if (f & GRND_RANDOM) {
+    dev = "/dev/random";
+  } else {
+    dev = "/dev/urandom";
+  }
+  oflags = O_RDONLY | O_CLOEXEC;
+  if (f & GRND_NONBLOCK)
+    oflags |= O_NONBLOCK;
+  fd = sys_openat(AT_FDCWD, dev, oflags, 0);
   if (fd != -1) {
     rc = sys_read(fd, p, n);
+    sys_close(fd);
   } else {
     rc = -1;
   }
-  ALLOW_CANCELATION;
-  ALLOW_SIGNALS;
+  END_CANCELATION_POINT;
   return rc;
 }
 
 ssize_t __getrandom(void *p, size_t n, unsigned f) {
   ssize_t rc;
   if (IsWindows()) {
-    rc = ProcessPrng(p, n) ? n : __winerr();
+    ProcessPrng(p, n);  // never fails
+    rc = n;
   } else if (have_getrandom) {
     if (IsXnu() || IsOpenbsd()) {
       rc = GetRandomBsd(p, n, GetRandomEntropy);
@@ -122,7 +132,7 @@ ssize_t __getrandom(void *p, size_t n, unsigned f) {
 #endif
   } else {
     BEGIN_CANCELATION_POINT;
-    rc = GetDevUrandom(p, n);
+    rc = GetDevUrandom(p, n, f);
     END_CANCELATION_POINT;
   }
   return rc;
@@ -175,9 +185,7 @@ ssize_t __getrandom(void *p, size_t n, unsigned f) {
  * @raise EFAULT if the `n` bytes at `p` aren't valid memory
  * @raise EINTR if we needed to block and a signal was delivered instead
  * @cancelationpoint
- * @asyncsignalsafe
  * @restartable
- * @vforksafe
  */
 ssize_t getrandom(void *p, size_t n, unsigned f) {
   ssize_t rc;
diff --git a/libc/calls/getresgid.c b/libc/calls/getresgid.c
index 53edea9f1..584d9f1c0 100644
--- a/libc/calls/getresgid.c
+++ b/libc/calls/getresgid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Gets real, effective, and "saved" group ids.
diff --git a/libc/calls/getresuid.c b/libc/calls/getresuid.c
index 7234882e1..c7e1257b8 100644
--- a/libc/calls/getresuid.c
+++ b/libc/calls/getresuid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Gets real, effective, and "saved" user ids.
diff --git a/libc/calls/getrlimit.c b/libc/calls/getrlimit.c
index f02ac5226..d2a826eda 100644
--- a/libc/calls/getrlimit.c
+++ b/libc/calls/getrlimit.c
@@ -20,8 +20,9 @@
 #include "libc/calls/struct/rlimit.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/rlimit.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
 #include "libc/runtime/syslib.internal.h"
@@ -47,8 +48,7 @@ int getrlimit(int resource, struct rlimit *rlim) {
   } else if (!IsWindows()) {
     rc = sys_getrlimit(resource, rlim);
   } else if (resource == RLIMIT_STACK) {
-    rlim->rlim_cur = GetStaticStackSize();
-    rlim->rlim_max = GetStaticStackSize();
+    *rlim = __rlimit_stack_get();
     rc = 0;
   } else if (resource == RLIMIT_AS) {
     rlim->rlim_cur = __virtualmax;
diff --git a/libc/calls/getsid.c b/libc/calls/getsid.c
index 7c76e9b76..6c71174d0 100644
--- a/libc/calls/getsid.c
+++ b/libc/calls/getsid.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Creates session and sets the process group id.
diff --git a/libc/calls/getuid-nt.c b/libc/calls/getuid-nt.c
index 7f191db4e..c6acd2a91 100644
--- a/libc/calls/getuid-nt.c
+++ b/libc/calls/getuid-nt.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/intrin/atomic.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/accounting.h"
 #include "libc/str/str.h"
 
diff --git a/libc/calls/getuid.c b/libc/calls/getuid.c
index bebd5cee8..3be6e8245 100644
--- a/libc/calls/getuid.c
+++ b/libc/calls/getuid.c
@@ -23,9 +23,9 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 
diff --git a/libc/calls/grantpt.c b/libc/calls/grantpt.c
index ee8c14ed5..476b82f86 100644
--- a/libc/calls/grantpt.c
+++ b/libc/calls/grantpt.c
@@ -17,12 +17,12 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 #define TIOCPTYGRANT 0x20007454
diff --git a/libc/calls/groups.internal.h b/libc/calls/groups.internal.h
index d7d0c80b7..2fca2ca10 100644
--- a/libc/calls/groups.internal.h
+++ b/libc/calls/groups.internal.h
@@ -5,9 +5,9 @@ COSMOPOLITAN_C_START_
 int sys_getgroups(int size, uint32_t list[]);
 int sys_setgroups(size_t size, const uint32_t list[]);
 
-const char *DescribeGidList(char[128], int, int, const uint32_t list[]);
+const char *_DescribeGidList(char[128], int, int, const uint32_t list[]);
 #define DescribeGidList(rc, length, gidlist) \
-  DescribeGidList(alloca(128), rc, length, gidlist)
+  _DescribeGidList(alloca(128), rc, length, gidlist)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_GROUPS_INTERNAL_H_ */
diff --git a/libc/calls/internal.h b/libc/calls/internal.h
index 5640aa719..80ffd0c58 100644
--- a/libc/calls/internal.h
+++ b/libc/calls/internal.h
@@ -1,10 +1,12 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_INTERNAL_H_
 #include "libc/atomic.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigval.h"
+#include "libc/calls/struct/timespec.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/macros.h"
 #include "libc/stdbool.h"
 
 #define kSigactionMinRva 8 /* >SIG_{ERR,DFL,IGN,...} */
@@ -24,12 +26,15 @@ int __ensurefds(int);
 uint32_t sys_getuid_nt(void);
 int __ensurefds_unlocked(int);
 void __printfds(struct Fd *, size_t);
+int __sigcheck(sigset_t, bool);
 int CountConsoleInputBytes(void);
 int FlushConsoleInputBytes(void);
 int64_t GetConsoleInputHandle(void);
 int64_t GetConsoleOutputHandle(void);
+void EchoConsoleNt(const char *, size_t, bool);
 int IsWindowsExecutable(int64_t, const char16_t *);
 void InterceptTerminalCommands(const char *, size_t);
+void sys_read_nt_wipe_keystrokes(void);
 
 forceinline bool __isfdopen(int fd) {
   return 0 <= fd && fd < g_fds.n && g_fds.p[fd].kind != kFdEmpty;
@@ -41,9 +46,10 @@ forceinline bool __isfdkind(int fd, int kind) {
 
 int _check_signal(bool);
 int _check_cancel(void);
+bool _is_canceled(void);
 int sys_close_nt(int, int);
-int _park_norestart(uint32_t, uint64_t);
-int _park_restartable(uint32_t, uint64_t);
+int _park_norestart(struct timespec, uint64_t);
+int _park_restartable(struct timespec, uint64_t);
 int sys_openat_metal(int, const char *, int, unsigned);
 
 #ifdef __x86_64__
diff --git a/libc/calls/ioctl.c b/libc/calls/ioctl.c
index 87ea17031..5151c8524 100644
--- a/libc/calls/ioctl.c
+++ b/libc/calls/ioctl.c
@@ -18,16 +18,16 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/cmpxchg.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alloca.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/console.h"
@@ -38,6 +38,7 @@
 #include "libc/nt/iphlpapi.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/ipadapteraddresses.h"
+#include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
@@ -59,6 +60,8 @@
 #define MAX_UNICAST_ADDR 32
 #define MAX_NAME_CLASH   ((int)('z' - 'a')) /* Allow a..z */
 
+__msabi extern typeof(__sys_ioctlsocket_nt) *const __imp_ioctlsocket;
+
 static struct HostAdapterInfoNode {
   struct HostAdapterInfoNode *next;
   char name[IFNAMSIZ]; /* Obtained from FriendlyName */
@@ -76,7 +79,7 @@ static int ioctl_default(int fd, unsigned long request, void *arg) {
   } else if (__isfdopen(fd)) {
     if (g_fds.p[fd].kind == kFdSocket) {
       handle = g_fds.p[fd].handle;
-      if ((rc = _weaken(__sys_ioctlsocket_nt)(handle, request, arg)) != -1) {
+      if ((rc = __imp_ioctlsocket(handle, request, arg)) != -1) {
         return rc;
       } else {
         return _weaken(__winsockerr)();
@@ -97,7 +100,7 @@ static int ioctl_fionread(int fd, uint32_t *arg) {
   } else if (__isfdopen(fd)) {
     handle = g_fds.p[fd].handle;
     if (g_fds.p[fd].kind == kFdSocket) {
-      if ((rc = _weaken(__sys_ioctlsocket_nt)(handle, FIONREAD, arg)) != -1) {
+      if ((rc = __imp_ioctlsocket(handle, FIONREAD, arg)) != -1) {
         return rc;
       } else {
         return _weaken(__winsockerr)();
@@ -258,7 +261,10 @@ static textwindows struct HostAdapterInfoNode *appendHostInfo(
     node->flags = flags;
   } else {
     /* Copy from previous node */
-    node->flags = parentInfoNode->flags;
+    if (parentInfoNode)
+      node->flags = parentInfoNode->flags;
+    else
+      node->flags = 0;
   }
 
   ip = ntohl(
@@ -508,6 +514,7 @@ static int ioctl_siocgifconf_sysv(int fd, struct ifconf *ifc) {
   }
 #pragma GCC push_options
 #pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
   bufMax = 15000; /* conservative guesstimate */
   b = alloca(bufMax);
   CheckLargeStackAllocation(b, bufMax);
diff --git a/libc/calls/isapemagic.c b/libc/calls/isapemagic.c
index a1ca56460..e387880cc 100644
--- a/libc/calls/isapemagic.c
+++ b/libc/calls/isapemagic.c
@@ -25,6 +25,5 @@
 bool IsApeLoadable(char buf[8]) {
   return READ32LE(buf) == READ32LE("\177ELF") ||
          READ64LE(buf) == READ64LE("MZqFpD='") ||
-         READ64LE(buf) == READ64LE("jartsr='") ||
-         READ64LE(buf) == READ64LE("APEDBG='");
+         READ64LE(buf) == READ64LE("jartsr='");
 }
diff --git a/libc/calls/isatty-nt.c b/libc/calls/isatty-nt.c
index 7098291a5..72342c683 100644
--- a/libc/calls/isatty-nt.c
+++ b/libc/calls/isatty-nt.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/isatty.c b/libc/calls/isatty.c
index f5bd51491..9462d31a9 100644
--- a/libc/calls/isatty.c
+++ b/libc/calls/isatty.c
@@ -23,7 +23,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/isdirectory.c b/libc/calls/isdirectory.c
index c5847f7b9..9299fbf23 100644
--- a/libc/calls/isdirectory.c
+++ b/libc/calls/isdirectory.c
@@ -23,7 +23,7 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/files.h"
 #include "libc/runtime/zipos.internal.h"
diff --git a/libc/calls/islinuxmodern.c b/libc/calls/islinuxmodern.c
new file mode 100644
index 000000000..565bd8fab
--- /dev/null
+++ b/libc/calls/islinuxmodern.c
@@ -0,0 +1,27 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/calls/syscall_support-sysv.internal.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+
+bool32 IsLinuxModern(void) {
+  return IsLinux() && sys_close_range(-1, -2, 0) == -1 && errno == EINVAL;
+}
diff --git a/libc/calls/isregularfile.c b/libc/calls/isregularfile.c
index 5dd12bd97..8baa68b21 100644
--- a/libc/calls/isregularfile.c
+++ b/libc/calls/isregularfile.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/consts/at.h"
diff --git a/libc/calls/issetugid.c b/libc/calls/issetugid.c
index 7dd7aa5b4..8a8a700f5 100644
--- a/libc/calls/issetugid.c
+++ b/libc/calls/issetugid.c
@@ -19,8 +19,8 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/getauxval.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/getauxval.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/auxv.h"
 
 /**
diff --git a/libc/calls/issymlink.c b/libc/calls/issymlink.c
index f030b20b6..8a6fe4c25 100644
--- a/libc/calls/issymlink.c
+++ b/libc/calls/issymlink.c
@@ -23,7 +23,7 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/files.h"
 #include "libc/runtime/zipos.internal.h"
diff --git a/libc/calls/kemptyfd.c b/libc/calls/kemptyfd.c
index 138980eba..17f646919 100644
--- a/libc/calls/kemptyfd.c
+++ b/libc/calls/kemptyfd.c
@@ -17,6 +17,6 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 
 const struct Fd kEmptyFd;
diff --git a/libc/calls/kntsystemdirectory.S b/libc/calls/kntsystemdirectory.S
index 85338d555..e50cc3485 100644
--- a/libc/calls/kntsystemdirectory.S
+++ b/libc/calls/kntsystemdirectory.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #define BYTES 64
 
diff --git a/libc/calls/kntwindowsdirectory.S b/libc/calls/kntwindowsdirectory.S
index de7418a62..0a20e3183 100644
--- a/libc/calls/kntwindowsdirectory.S
+++ b/libc/calls/kntwindowsdirectory.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #define BYTES 64
 
diff --git a/libc/calls/landlock_add_rule.c b/libc/calls/landlock_add_rule.c
index 34cb1d1bb..b87c22081 100644
--- a/libc/calls/landlock_add_rule.c
+++ b/libc/calls/landlock_add_rule.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/landlock.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 int sys_landlock_add_rule(int, enum landlock_rule_type, const void *, uint32_t);
 
diff --git a/libc/calls/landlock_create_ruleset.c b/libc/calls/landlock_create_ruleset.c
index baee3b920..a8dec3f99 100644
--- a/libc/calls/landlock_create_ruleset.c
+++ b/libc/calls/landlock_create_ruleset.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/landlock.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 int sys_landlock_create_ruleset(const struct landlock_ruleset_attr *, size_t,
                                 uint32_t);
diff --git a/libc/calls/landlock_restrict_self.c b/libc/calls/landlock_restrict_self.c
index 2bf173c1e..96a36e8fd 100644
--- a/libc/calls/landlock_restrict_self.c
+++ b/libc/calls/landlock_restrict_self.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/landlock.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 int sys_landlock_restrict_self(int, uint32_t);
 
diff --git a/libc/calls/linkat-nt.c b/libc/calls/linkat-nt.c
index 9364b62be..4f55b6707 100644
--- a/libc/calls/linkat-nt.c
+++ b/libc/calls/linkat-nt.c
@@ -18,14 +18,15 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
 #include "libc/runtime/stack.h"
 #include "libc/str/str.h"
 
-textwindows int sys_linkat_nt(int olddirfd, const char *oldpath, int newdirfd,
-                              const char *newpath) {
+textwindows int sys_linkat_nt(int olddirfd, const char *oldpath,  //
+                              int newdirfd, const char *newpath) {
 #pragma GCC push_options
 #pragma GCC diagnostic ignored "-Wframe-larger-than="
   struct {
@@ -36,7 +37,10 @@ textwindows int sys_linkat_nt(int olddirfd, const char *oldpath, int newdirfd,
 #pragma GCC pop_options
   if (__mkntpathat(olddirfd, oldpath, 0, M.oldpath16) != -1 &&
       __mkntpathat(newdirfd, newpath, 0, M.newpath16) != -1) {
-    if (CreateHardLink(M.newpath16, M.oldpath16, NULL)) {
+    bool32 ok = CreateHardLink(M.newpath16, M.oldpath16, NULL);
+    NTTRACE("CreateHardLink(%#hs, %#hs, NULL) → {%hhhd, %d}", M.newpath16,
+            M.oldpath16, ok, GetLastError());
+    if (ok) {
       return 0;
     } else {
       return __fix_enotdir3(__winerr(), M.newpath16, M.oldpath16);
diff --git a/libc/calls/linkat.c b/libc/calls/linkat.c
index 2b3d466d3..84237baf3 100644
--- a/libc/calls/linkat.c
+++ b/libc/calls/linkat.c
@@ -20,8 +20,8 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/errfuns.h"
@@ -34,6 +34,7 @@
  *
  * @param flags can have AT_EMPTY_PATH or AT_SYMLINK_NOFOLLOW
  * @return 0 on success, or -1 w/ errno
+ * @raise EROFS if either path is under /zip/...
  * @asyncsignalsafe
  */
 int linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath,
@@ -42,7 +43,7 @@ int linkat(int olddirfd, const char *oldpath, int newdirfd, const char *newpath,
   if (_weaken(__zipos_notat) &&
       ((rc = __zipos_notat(olddirfd, oldpath)) == -1 ||
        (rc = __zipos_notat(newdirfd, newpath)) == -1)) {
-    STRACE("zipos fchownat not supported yet");
+    rc = erofs();
   } else if (!IsWindows()) {
     rc = sys_linkat(olddirfd, oldpath, newdirfd, newpath, flags);
   } else {
diff --git a/libc/calls/lseek-nt.c b/libc/calls/lseek-nt.c
index 11ef3471f..9e073b8c4 100644
--- a/libc/calls/lseek-nt.c
+++ b/libc/calls/lseek-nt.c
@@ -19,6 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/nt/enum/filetype.h"
 #include "libc/nt/files.h"
 #include "libc/nt/struct/byhandlefileinformation.h"
@@ -31,7 +32,7 @@ static textwindows int64_t GetPosition(struct Fd *f, int whence) {
     case SEEK_SET:
       return 0;
     case SEEK_CUR:
-      return f->pointer;
+      return f->cursor->shared->pointer;
     case SEEK_END: {
       struct NtByHandleFileInformation wst;
       if (!GetFileInformationByHandle(f->handle, &wst)) {
@@ -67,11 +68,14 @@ textwindows int64_t sys_lseek_nt(int fd, int64_t offset, int whence) {
   } else if (__isfdkind(fd, kFdFile)) {
     struct Fd *f = g_fds.p + fd;
     int filetype = GetFileType(f->handle);
-    if (filetype != kNtFileTypePipe && filetype != kNtFileTypeChar) {
+    if (filetype != kNtFileTypePipe &&  //
+        filetype != kNtFileTypeChar &&  //
+        f->cursor->shared) {
       int64_t res;
-      if ((res = Seek(f, offset, whence)) != -1) {
-        f->pointer = res;
-      }
+      __cursor_lock(f->cursor);
+      if ((res = Seek(f, offset, whence)) != -1)
+        f->cursor->shared->pointer = res;
+      __cursor_unlock(f->cursor);
       return res;
     } else {
       return espipe();
diff --git a/libc/calls/lseek.c b/libc/calls/lseek.c
index 696889f2b..2cf78a674 100644
--- a/libc/calls/lseek.c
+++ b/libc/calls/lseek.c
@@ -21,8 +21,8 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/backtrace.internal.h"
 #include "libc/runtime/zipos.internal.h"
diff --git a/libc/calls/madvise-nt.c b/libc/calls/madvise-nt.c
index 77ad7351c..16bb589dc 100644
--- a/libc/calls/madvise-nt.c
+++ b/libc/calls/madvise-nt.c
@@ -16,61 +16,31 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/nt/enum/offerpriority.h"
+#include "libc/nt/memory.h"
 #include "libc/nt/runtime.h"
-#include "libc/nt/struct/memoryrangeentry.h"
 #include "libc/sysv/consts/madv.h"
 #include "libc/sysv/errfuns.h"
 
-typedef bool32 (*__msabi PrefetchVirtualMemoryPtr)(
-    int64_t hProcess, uintptr_t NumberOfEntries,
-    struct NtMemoryRangeEntry *VirtualAddresses, uint32_t reserved_Flags);
-
-textwindows static PrefetchVirtualMemoryPtr GetPrefetchVirtualMemory(void) {
-  static PrefetchVirtualMemoryPtr PrefetchVirtualMemory_;
-  if (!PrefetchVirtualMemory_) {
-    PrefetchVirtualMemory_ = /* win8.1+ */
-        GetProcAddressModule("Kernel32.dll", "PrefetchVirtualMemory");
-  }
-  return PrefetchVirtualMemory_;
-}
-
-typedef bool32 (*__msabi OfferVirtualMemoryPtr)(void *inout_VirtualAddress,
-                                                size_t Size, int Priority);
-
-textwindows static OfferVirtualMemoryPtr GetOfferVirtualMemory(void) {
-  static OfferVirtualMemoryPtr OfferVirtualMemory_;
-  if (!OfferVirtualMemory_) {
-    OfferVirtualMemory_ = /* win8.1+ */
-        GetProcAddressModule("Kernel32.dll", "OfferVirtualMemory");
-  }
-  return OfferVirtualMemory_;
-}
-
 textwindows int sys_madvise_nt(void *addr, size_t length, int advice) {
   if (advice == MADV_WILLNEED || advice == MADV_SEQUENTIAL) {
-    PrefetchVirtualMemoryPtr fn = GetPrefetchVirtualMemory();
-    if (fn) {
-      if (fn(GetCurrentProcess(), 1, &(struct NtMemoryRangeEntry){addr, length},
-             0)) {
-        return 0;
-      } else {
-        return __winerr();
-      }
+    if (!length)
+      return 0;
+    if (PrefetchVirtualMemory(GetCurrentProcess(), 1,
+                              &(struct NtMemoryRangeEntry){addr, length}, 0)) {
+      return 0;
     } else {
-      return enosys();
+      return __winerr();
     }
   } else if (advice == MADV_FREE) {
-    OfferVirtualMemoryPtr fn = GetOfferVirtualMemory();
-    if (fn) {
-      if (fn(addr, length, kNtVmOfferPriorityNormal)) {
-        return 0;
-      } else {
-        return __winerr();
-      }
+    if (!length)
+      return 0;
+    if (OfferVirtualMemory(addr, length, kNtVmOfferPriorityNormal)) {
+      return 0;
     } else {
-      return enosys();
+      return __winerr();
     }
   } else {
     return einval();
diff --git a/libc/calls/madvise.c b/libc/calls/madvise.c
index 27ea1c7cf..8bf52c515 100644
--- a/libc/calls/madvise.c
+++ b/libc/calls/madvise.c
@@ -20,28 +20,50 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/runtime/runtime.h"
 #include "libc/sysv/errfuns.h"
 
+static int __madvise(void *addr, size_t length, int advice) {
+
+  // simulate linux behavior of validating alignment
+  if ((uintptr_t)addr & (__pagesize - 1))
+    return einval();
+
+  // simulate linux behavior of checking for negative length
+  if ((ssize_t)length < 0)
+    return einval();
+
+  // madvise(0, 0, advice) may be used to validate advice
+  if (!length && (IsFreebsd() || IsNetbsd()))
+    addr = (void *)65536l;
+
+  if (!IsWindows())
+    return sys_madvise(addr, length, advice);
+  return sys_madvise_nt(addr, length, advice);
+}
+
 /**
- * Drops hints to O/S about intended access patterns of mmap()'d memory.
+ * Declares intent to OS on how memory region will be used.
+ *
+ * `madvise(0, 0, advice)` is recommended for validating `advise` and it
+ * will always be the case that a `length` of zero is a no-op otherwise.
+ *
+ * Having the interval overlap unmapped pages has undefined behavior. On
+ * Linux, this can be counted upon to raise ENOMEM. Other OSes vary much
+ * in behavior here; they'll might ignore unmapped regions or they might
+ * raise EINVAL, EFAULT, or ENOMEM.
  *
  * @param advice can be MADV_WILLNEED, MADV_SEQUENTIAL, MADV_FREE, etc.
  * @return 0 on success, or -1 w/ errno
  * @raise EINVAL if `advice` isn't valid or supported by system
- * @raise EINVAL on Linux if addr/length isn't page size aligned with
- *     respect to `getauxval(AT_PAGESZ)`
- * @raise ENOMEM on Linux if addr/length overlaps unmapped regions
+ * @raise EINVAL if `addr` isn't getpagesize() aligned
+ * @raise EINVAL if `length` is negative
  * @see libc/sysv/consts.sh
  * @see fadvise()
  */
 int madvise(void *addr, size_t length, int advice) {
-  int rc;
-  if (!IsWindows()) {
-    rc = sys_madvise(addr, length, advice);
-  } else {
-    rc = sys_madvise_nt(addr, length, advice);
-  }
+  int rc = __madvise(addr, length, advice);
   STRACE("madvise(%p, %'zu, %d) → %d% m", addr, length, advice, rc);
   return rc;
 }
diff --git a/libc/calls/makedev.h b/libc/calls/makedev.h
index dcd221026..21479c795 100644
--- a/libc/calls/makedev.h
+++ b/libc/calls/makedev.h
@@ -1,5 +1,6 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_MAKEDEV_H_
 #define COSMOPOLITAN_LIBC_CALLS_MAKEDEV_H_
+COSMOPOLITAN_C_START_
 
 uint64_t makedev(uint32_t, uint32_t) libcesque;
 uint32_t major(uint64_t) libcesque;
@@ -9,4 +10,5 @@ uint32_t minor(uint64_t) libcesque;
 #define minor(x)      minor(x)
 #define makedev(x, y) makedev(x, y)
 
+COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_MAKEDEV_H_ */
diff --git a/libc/calls/memfd_create.c b/libc/calls/memfd_create.c
index fa0950ab1..9215b7736 100644
--- a/libc/calls/memfd_create.c
+++ b/libc/calls/memfd_create.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Creates anonymous file.
diff --git a/libc/calls/metalfile.c b/libc/calls/metalfile.c
index 0832d52f5..5d2c57540 100644
--- a/libc/calls/metalfile.c
+++ b/libc/calls/metalfile.c
@@ -29,10 +29,10 @@
 #include "libc/assert.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/metalfile.internal.h"
-#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/directmap.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/pc.internal.h"
 #include "libc/runtime/runtime.h"
@@ -67,10 +67,9 @@ textstartup void InitializeMetalFile(void) {
     size_t size = ROUNDUP(_ezip - __executable_start, 4096);
     // TODO(jart): Restore support for ZIPOS on metal.
     void *copied_base;
-    struct DirectMap dm;
-    dm = sys_mmap_metal(NULL, size, PROT_READ | PROT_WRITE,
-                        MAP_SHARED_linux | MAP_ANONYMOUS_linux, -1, 0);
-    copied_base = dm.addr;
+    void *addr = sys_mmap_metal(NULL, size, PROT_READ | PROT_WRITE,
+                                MAP_SHARED_linux | MAP_ANONYMOUS_linux, -1, 0);
+    copied_base = addr;
     npassert(copied_base != (void *)-1);
     memcpy(copied_base, (void *)(BANE + IMAGE_BASE_PHYSICAL), size);
     __ape_com_base = copied_base;
diff --git a/libc/calls/metalfile_init.S b/libc/calls/metalfile_init.S
index 72e7f8972..0f5466fc5 100644
--- a/libc/calls/metalfile_init.S
+++ b/libc/calls/metalfile_init.S
@@ -24,7 +24,7 @@
 │ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR        │
 │ OTHER DEALINGS IN THE SOFTWARE.                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/calls/metalfile.internal.h"
 
 	.init.start 102,_init_metalfile
diff --git a/libc/calls/mincore.c b/libc/calls/mincore.c
index 40187d2c0..62c6a0eee 100644
--- a/libc/calls/mincore.c
+++ b/libc/calls/mincore.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Tells you which pages are resident in memory.
diff --git a/libc/calls/mkdirat.c b/libc/calls/mkdirat.c
index 3dd07d8b3..b4a2cb1b4 100644
--- a/libc/calls/mkdirat.c
+++ b/libc/calls/mkdirat.c
@@ -20,8 +20,8 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/consts/at.h"
@@ -53,7 +53,7 @@
 int mkdirat(int dirfd, const char *path, unsigned mode) {
   int rc;
   if (_weaken(__zipos_notat) && (rc = __zipos_notat(dirfd, path)) == -1) {
-    STRACE("zipos mkdirat not supported yet");
+    rc = erofs();
   } else if (!IsWindows()) {
     rc = sys_mkdirat(dirfd, path, mode);
   } else {
diff --git a/libc/calls/mknod.c b/libc/calls/mknod.c
index 33ee93d32..2c1fa90b9 100644
--- a/libc/calls/mknod.c
+++ b/libc/calls/mknod.c
@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/at.h"
 #include "libc/sysv/consts/s.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/mkntenvblock.c b/libc/calls/mkntenvblock.c
index 9ea54b03e..a6738fa7a 100644
--- a/libc/calls/mkntenvblock.c
+++ b/libc/calls/mkntenvblock.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
-#include "libc/intrin/getenv.internal.h"
+#include "libc/intrin/getenv.h"
 #include "libc/mem/alloca.h"
 #include "libc/proc/ntspawn.h"
 #include "libc/runtime/runtime.h"
@@ -144,6 +144,7 @@ textwindows int mkntenvblock(char16_t envblock[32767], char *const envp[],
   n = (CountStrings(envp) + CountStrings(extravars) + 1) * sizeof(char *);
 #pragma GCC push_options
 #pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
   env.var = alloca(n);
   CheckLargeStackAllocation(env.var, n);
 #pragma GCC pop_options
diff --git a/libc/calls/mkntpath.c b/libc/calls/mkntpath.c
index 32477d412..7c535de1a 100644
--- a/libc/calls/mkntpath.c
+++ b/libc/calls/mkntpath.c
@@ -19,8 +19,8 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/nt/systeminfo.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/o.h"
@@ -55,6 +55,19 @@ textwindows size_t __normntpath(char16_t *p, size_t n) {
       // matched "/../" or "/..$"
       while (j && p[j - 1] == '\\')
         --j;
+      if (j && p[j - 1] == '.') {
+        // matched "." before
+        if (j >= 2 && p[j - 2] == '.' &&  //
+            (j == 2 || p[j - 3] == '\\')) {
+          // matched "^.." or "/.." before
+          p[++j] = '.';
+          ++j;
+          continue;
+        } else if (j == 1 || p[j - 2] == '\\') {
+          // matched "^." or "/." before
+          continue;
+        }
+      }
       while (j && p[j - 1] != '\\')
         --j;
     } else {
diff --git a/libc/calls/mkntpathat.c b/libc/calls/mkntpathat.c
index 8eec12b4c..a263cd838 100644
--- a/libc/calls/mkntpathat.c
+++ b/libc/calls/mkntpathat.c
@@ -18,8 +18,9 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/fileflagandattributes.h"
 #include "libc/nt/files.h"
 #include "libc/nt/thunk/msabi.h"
@@ -27,6 +28,18 @@
 #include "libc/sysv/consts/at.h"
 #include "libc/sysv/errfuns.h"
 
+static int IsAlpha(int c) {
+  return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z');
+}
+
+static bool IsAbsolutePathWin32(char16_t *path) {
+  if (path[0] == '\\')
+    return true;
+  if (IsAlpha(path[0]) && path[1] == ':')
+    return true;
+  return false;
+}
+
 static textwindows int __mkntpathath_impl(int64_t dirhand, const char *path,
                                           int flags,
                                           char16_t file[hasatleast PATH_MAX]) {
@@ -39,7 +52,7 @@ static textwindows int __mkntpathath_impl(int64_t dirhand, const char *path,
     return -1;
   if (!filelen)
     return enoent();
-  if (file[0] != u'\\' && dirhand != AT_FDCWD) {  // ProTip: \\?\C:\foo
+  if (dirhand != AT_FDCWD && !IsAbsolutePathWin32(file)) {
     dirlen = GetFinalPathNameByHandle(dirhand, dir, ARRAYLEN(dir),
                                       kNtFileNameNormalized | kNtVolumeNameDos);
     if (!dirlen)
@@ -49,8 +62,20 @@ static textwindows int __mkntpathath_impl(int64_t dirhand, const char *path,
     dir[dirlen] = u'\\';
     memcpy(dir + dirlen + 1, file, (filelen + 1) * sizeof(char16_t));
     memcpy(file, dir, ((n = dirlen + 1 + filelen) + 1) * sizeof(char16_t));
-    return __normntpath(file, n);
+    n = __normntpath(file, n);
+
+    // UNC paths break some things when they are not needed.
+    if (n > 4 && n < 260 &&  //
+        file[0] == '\\' &&   //
+        file[1] == '\\' &&   //
+        file[2] == '?' &&    //
+        file[3] == '\\') {
+      memmove(file, file + 4, (n - 4 + 1) * sizeof(char16_t));
+    }
+
+    return n;
   } else {
+    filelen = __normntpath(file, filelen);
     return filelen;
   }
 }
@@ -60,23 +85,20 @@ textwindows int __mkntpathath(int64_t dirhand, const char *path, int flags,
 
   // convert the path.
   int len;
-  if ((len = __mkntpathath_impl(dirhand, path, flags, file)) == -1) {
+  if ((len = __mkntpathath_impl(dirhand, path, flags, file)) == -1)
     return -1;
-  }
 
   // if path ends with a slash, then we need to manually do what linux
   // does and check to make sure it's a directory, and return ENOTDIR,
   // since WIN32 will reject the path with EINVAL if we don't do this.
   if (len && file[len - 1] == '\\') {
     uint32_t fattr;
-    if (len > 1 && !(len == 3 && file[1] == ':')) {
+    if (len > 1 && !(len == 3 && file[1] == ':'))
       file[--len] = 0;
-    }
     if ((fattr = GetFileAttributes(file)) != -1u &&
         !(fattr & kNtFileAttributeReparsePoint) &&
-        !(fattr & kNtFileAttributeDirectory)) {
+        !(fattr & kNtFileAttributeDirectory))
       return enotdir();
-    }
   }
 
   return len;
diff --git a/libc/calls/mremap-sysv.greg.c b/libc/calls/mremap-sysv.greg.c
deleted file mode 100644
index e65d9af0a..000000000
--- a/libc/calls/mremap-sysv.greg.c
+++ /dev/null
@@ -1,77 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/syscall-sysv.internal.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/intrin/asmflag.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/sysv/consts/map.h"
-#include "libc/sysv/consts/mremap.h"
-#include "libc/sysv/errfuns.h"
-
-/**
- * Relocates memory.
- *
- * This function lets you move to to different addresses witohut copying
- * it. This system call is currently supported on Linux and NetBSD. Your
- * C library runtime won't have any awareness of this memory, so certain
- * features like ASAN memory safety and kprintf() won't work as well.
- */
-void *sys_mremap(void *p, size_t n, size_t m, int f, void *q) {
-#ifdef __x86_64__
-  bool cf;
-  uintptr_t res, rdx;
-  register uintptr_t r8 asm("r8");
-  register uintptr_t r10 asm("r10");
-  if (IsLinux()) {
-    r10 = f;
-    r8 = (uintptr_t)q;
-    asm("syscall"
-        : "=a"(res)
-        : "0"(0x019), "D"(p), "S"(n), "d"(m), "r"(r10), "r"(r8)
-        : "rcx", "r11", "memory", "cc");
-    if (res > -4096ul)
-      errno = -res, res = -1;
-  } else if (IsNetbsd()) {
-    if (f & MREMAP_MAYMOVE) {
-      res = 0x19B;
-      r10 = m;
-      r8 = (f & MREMAP_FIXED) ? MAP_FIXED : 0;
-      asm(CFLAG_ASM("syscall")
-          : CFLAG_CONSTRAINT(cf), "+a"(res), "=d"(rdx)
-          : "D"(p), "S"(n), "2"(q), "r"(r10), "r"(r8)
-          : "rcx", "r9", "r11", "memory", "cc");
-      if (cf)
-        errno = res, res = -1;
-    } else {
-      res = einval();
-    }
-  } else {
-    res = enosys();
-  }
-#elif defined(__aarch64__)
-  void *res;
-  res = __sys_mremap(p, n, m, f, q);
-#else
-#error "arch unsupported"
-#endif
-  KERNTRACE("sys_mremap(%p, %'zu, %'zu, %#b, %p) → %p% m", p, n, m, f, q, res);
-  return (void *)res;
-}
diff --git a/libc/calls/netbsdtramp.S b/libc/calls/netbsdtramp.S
index 01fdca769..dddd3536b 100644
--- a/libc/calls/netbsdtramp.S
+++ b/libc/calls/netbsdtramp.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .privileged
 
 __restore_rt_netbsd:
diff --git a/libc/calls/ntaccesscheck.c b/libc/calls/ntaccesscheck.c
index 708238736..695d5480b 100644
--- a/libc/calls/ntaccesscheck.c
+++ b/libc/calls/ntaccesscheck.c
@@ -24,7 +24,7 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/createfile.h"
diff --git a/libc/calls/ntspawn.c b/libc/calls/ntspawn.c
index 3cd4c8ae0..cd7531148 100644
--- a/libc/calls/ntspawn.c
+++ b/libc/calls/ntspawn.c
@@ -17,9 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/proc/ntspawn.h"
+#include "libc/calls/state.internal.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/createfile.h"
 #include "libc/nt/enum/accessmask.h"
 #include "libc/nt/enum/creationdisposition.h"
@@ -38,12 +39,15 @@
 #include "libc/nt/struct/procthreadattributelist.h"
 #include "libc/nt/struct/startupinfo.h"
 #include "libc/nt/struct/startupinfoex.h"
+#include "libc/nt/thunk/msabi.h"
 #include "libc/proc/ntspawn.h"
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 #ifdef __x86_64__
 
+__msabi extern typeof(CloseHandle) *const __imp_CloseHandle;
+
 struct SpawnBlock {
   char16_t path[PATH_MAX];
   char16_t cmdline[32767];
@@ -63,10 +67,12 @@ static textwindows ssize_t ntspawn_read(intptr_t fh, char *buf, size_t len) {
   bool ok;
   uint32_t got;
   struct NtOverlapped overlap = {.hEvent = CreateEvent(0, 0, 0, 0)};
-  ok = (ReadFile(fh, buf, len, 0, &overlap) ||
+  ok = overlap.hEvent &&
+       (ReadFile(fh, buf, len, 0, &overlap) ||
         GetLastError() == kNtErrorIoPending) &&
        GetOverlappedResult(fh, &overlap, &got, true);
-  CloseHandle(overlap.hEvent);
+  if (overlap.hEvent)
+    __imp_CloseHandle(overlap.hEvent);
   return ok ? got : -1;
 }
 
@@ -86,7 +92,7 @@ static textwindows int ntspawn2(struct NtSpawnArgs *a, struct SpawnBlock *sb) {
   if (fh == -1)
     return -1;
   ssize_t got = ntspawn_read(fh, p, pe - p);
-  CloseHandle(fh);
+  __imp_CloseHandle(fh);
   if (got < 3)
     return enoexec();
   pe = p + got;
@@ -153,7 +159,7 @@ static textwindows int ntspawn2(struct NtSpawnArgs *a, struct SpawnBlock *sb) {
   alignas(16) char memory[128];
   size_t size = sizeof(memory);
   struct NtProcThreadAttributeList *alist = (void *)memory;
-  uint32_t items = !!a->opt_hParentProcess + !!a->opt_lpExplicitHandleList;
+  uint32_t items = !!a->opt_hParentProcess + !!a->dwExplicitHandleCount;
   ok = InitializeProcThreadAttributeList(alist, items, 0, &size);
   if (!ok && GetLastError() == kNtErrorInsufficientBuffer) {
     ok = !!(alist = freeme = ntspawn_malloc(size));
@@ -166,7 +172,7 @@ static textwindows int ntspawn2(struct NtSpawnArgs *a, struct SpawnBlock *sb) {
         alist, 0, kNtProcThreadAttributeParentProcess, &a->opt_hParentProcess,
         sizeof(a->opt_hParentProcess), 0, 0);
   }
-  if (ok && a->opt_lpExplicitHandleList) {
+  if (ok && a->dwExplicitHandleCount) {
     ok = UpdateProcThreadAttribute(
         alist, 0, kNtProcThreadAttributeHandleList, a->opt_lpExplicitHandleList,
         a->dwExplicitHandleCount * sizeof(*a->opt_lpExplicitHandleList), 0, 0);
@@ -238,6 +244,7 @@ textwindows int ntspawn(struct NtSpawnArgs *args) {
   BLOCK_SIGNALS;
   if ((sb = ntspawn_malloc(sizeof(*sb)))) {
     rc = ntspawn2(args, sb);
+    ntspawn_free(sb);
   } else {
     rc = -1;
   }
diff --git a/libc/calls/open-nt.c b/libc/calls/open-nt.c
index c7339171b..09061eb8a 100644
--- a/libc/calls/open-nt.c
+++ b/libc/calls/open-nt.c
@@ -24,7 +24,8 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/macros.h"
 #include "libc/nt/console.h"
 #include "libc/nt/createfile.h"
 #include "libc/nt/enum/accessmask.h"
@@ -138,6 +139,7 @@ static textwindows int sys_open_nt_file(int dirfd, const char *file,
   int64_t handle;
   if ((handle = sys_open_nt_impl(dirfd, file, flags, mode,
                                  kNtFileFlagOverlapped)) != -1) {
+    g_fds.p[fd].cursor = __cursor_new();
     g_fds.p[fd].handle = handle;
     g_fds.p[fd].kind = kFdFile;
     g_fds.p[fd].flags = flags;
@@ -170,15 +172,15 @@ static textwindows int sys_open_nt_no_handle(int fd, int flags, int mode,
 
 static textwindows int sys_open_nt_dup(int fd, int flags, int mode, int oldfd) {
   int64_t handle;
-  if (!__isfdopen(oldfd)) {
+  if (!__isfdopen(oldfd))
     return enoent();
-  }
   if (DuplicateHandle(GetCurrentProcess(), g_fds.p[oldfd].handle,
                       GetCurrentProcess(), &handle, 0, true,
                       kNtDuplicateSameAccess)) {
     g_fds.p[fd] = g_fds.p[oldfd];
     g_fds.p[fd].handle = handle;
     g_fds.p[fd].mode = mode;
+    __cursor_ref(g_fds.p[fd].cursor);
     if (!sys_fcntl_nt_setfl(fd, flags)) {
       return fd;
     } else {
diff --git a/libc/calls/openat-metal.c b/libc/calls/openat-metal.c
index 34d4d799d..647af1360 100644
--- a/libc/calls/openat-metal.c
+++ b/libc/calls/openat-metal.c
@@ -21,9 +21,9 @@
 #include "libc/assert.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/metalfile.internal.h"
-#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/directmap.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/pc.internal.h"
 #include "libc/runtime/runtime.h"
@@ -49,11 +49,9 @@ int sys_openat_metal(int dirfd, const char *file, int flags, unsigned mode) {
   if ((fd = __reservefd(-1)) == -1)
     return -1;
   if (!_weaken(calloc) || !_weaken(free)) {
-    struct DirectMap dm;
-    dm = sys_mmap_metal(NULL, ROUNDUP(sizeof(struct MetalFile), 4096),
-                        PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1,
-                        0);
-    state = dm.addr;
+    state = sys_mmap_metal(NULL, ROUNDUP(sizeof(struct MetalFile), 4096),
+                           PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS,
+                           -1, 0);
     if (state == (void *)-1)
       return -1;
   } else {
diff --git a/libc/calls/openat.c b/libc/calls/openat.c
index 94e4452bc..327867ba3 100644
--- a/libc/calls/openat.c
+++ b/libc/calls/openat.c
@@ -26,8 +26,8 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/log.h"
 #include "libc/runtime/zipos.internal.h"
diff --git a/libc/calls/park.c b/libc/calls/park.c
index 286c77555..103a6cbdf 100644
--- a/libc/calls/park.c
+++ b/libc/calls/park.c
@@ -18,50 +18,97 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
+#include "libc/calls/struct/sigset.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/fmt/wintime.internal.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/weaken.h"
+#include "libc/nt/events.h"
+#include "libc/nt/runtime.h"
 #include "libc/nt/synchronization.h"
+#include "libc/str/str.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/posixthread.internal.h"
+
 #ifdef __x86_64__
 
-// returns 0 on timeout or spurious wakeup
+// returns 0 if deadline is reached
 // raises EINTR if a signal delivery interrupted wait operation
 // raises ECANCELED if this POSIX thread was canceled in masked mode
-static textwindows int _park_thread(uint32_t msdelay, sigset_t waitmask,
+textwindows static int _park_thread(struct timespec deadline, sigset_t waitmask,
                                     bool restartable) {
-  int sig, handler_was_called;
-  if (_check_cancel() == -1)
-    return -1;
-  if (_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))) {
-    goto HandleSignal;
-  }
-  int expect = 0;
-  atomic_int futex = 0;
-  struct PosixThread *pt = _pthread_self();
-  pt->pt_blkmask = waitmask;
-  atomic_store_explicit(&pt->pt_blocker, &futex, memory_order_release);
-  bool32 ok = WaitOnAddress(&futex, &expect, sizeof(int), msdelay);
-  atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
-  if (ok && _weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))) {
-  HandleSignal:
-    handler_was_called = _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
-    if (_check_cancel() == -1)
-      return -1;
-    if (!restartable || (handler_was_called & SIG_HANDLED_NO_RESTART)) {
-      return eintr();
+  for (;;) {
+    uint32_t handl = 0;
+    intptr_t hands[2];
+
+    // create event object
+    intptr_t sigev;
+    if (!(sigev = CreateEvent(0, 0, 0, 0)))
+      return __winerr();
+    hands[handl++] = sigev;
+
+    // create high precision timer if needed
+    if (memcmp(&deadline, &timespec_max, sizeof(struct timespec))) {
+      intptr_t hTimer;
+      if ((hTimer = CreateWaitableTimer(NULL, true, NULL))) {
+        int64_t due = TimeSpecToWindowsTime(deadline);
+        if (SetWaitableTimer(hTimer, &due, 0, NULL, NULL, false)) {
+          hands[handl++] = hTimer;
+        } else {
+          CloseHandle(hTimer);
+        }
+      }
     }
+
+    // perform wait operation
+    struct PosixThread *pt = _pthread_self();
+    pt->pt_event = sigev;
+    pt->pt_blkmask = waitmask;
+    atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_EVENT,
+                          memory_order_release);
+    //!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!//
+    int sig = 0;
+    uint32_t wi = 0;
+    if (!_is_canceled() &&
+        !(_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))))
+      wi = WaitForMultipleObjects(handl, hands, false, -1u);
+    //!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!//
+    atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
+    for (int i = 0; i < handl; ++i)
+      CloseHandle(hands[i]);
+
+    // recursion is now safe
+    if (wi == 1)
+      return 0;
+    if (wi == -1u)
+      return __winerr();
+    int handler_was_called = 0;
+    if (!sig) {
+      if (_check_cancel())
+        return -1;
+      if (_weaken(__sig_get))
+        sig = _weaken(__sig_get)(waitmask);
+    }
+    if (sig)
+      handler_was_called = _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
+    if (_check_cancel())
+      return -1;
+    if (handler_was_called & SIG_HANDLED_NO_RESTART)
+      return eintr();
+    if (handler_was_called & SIG_HANDLED_SA_RESTART)
+      if (!restartable)
+        return eintr();
   }
-  return 0;
 }
 
-textwindows int _park_norestart(uint32_t msdelay, sigset_t waitmask) {
-  return _park_thread(msdelay, waitmask, false);
+textwindows int _park_norestart(struct timespec deadline, sigset_t waitmask) {
+  return _park_thread(deadline, waitmask, false);
 }
 
-textwindows int _park_restartable(uint32_t msdelay, sigset_t waitmask) {
-  return _park_thread(msdelay, waitmask, true);
+textwindows int _park_restartable(struct timespec deadline, sigset_t waitmask) {
+  return _park_thread(deadline, waitmask, true);
 }
 
 #endif /* __x86_64__ */
diff --git a/libc/calls/parsepromises.c b/libc/calls/parsepromises.c
index af4770e06..c12b2ee33 100644
--- a/libc/calls/parsepromises.c
+++ b/libc/calls/parsepromises.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/pledge.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 
 static int FindPromise(const char *name) {
diff --git a/libc/calls/pause-nt.c b/libc/calls/pause-nt.c
index 0a43e5089..28e5e4184 100644
--- a/libc/calls/pause-nt.c
+++ b/libc/calls/pause-nt.c
@@ -17,14 +17,21 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
+#include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/timespec.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #ifdef __x86_64__
 
 textwindows int sys_pause_nt(void) {
-  int rc;
-  while (!(rc = _park_norestart(-1u, 0)))
-    donothing;
-  return rc;
+  // we don't strictly need to block signals, but it reduces signal
+  // delivery latency, by preventing other threads from delivering a
+  // signal asynchronously. it takes about ~5us to deliver a signal
+  // using SetEvent() whereas it takes ~30us to use SuspendThread(),
+  // GetThreadContext(), SetThreadContext(), and ResumeThread().
+  BLOCK_SIGNALS;
+  _park_norestart(timespec_max, 0);
+  ALLOW_SIGNALS;
+  return -1;
 }
 
 #endif /* __x86_64__ */
diff --git a/libc/calls/pause.c b/libc/calls/pause.c
index 7d24dd2d9..d73537081 100644
--- a/libc/calls/pause.c
+++ b/libc/calls/pause.c
@@ -20,7 +20,7 @@
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sock/internal.h"
 
 /**
diff --git a/libc/calls/pipe-nt.c b/libc/calls/pipe-nt.c
index d2ed971e0..40a16c375 100644
--- a/libc/calls/pipe-nt.c
+++ b/libc/calls/pipe-nt.c
@@ -56,7 +56,6 @@ static textwindows int sys_pipe_nt_impl(int pipefd[2], unsigned flags) {
   __fds_unlock();
   hin = CreateNamedPipe(pipename, kNtPipeAccessInbound | kNtFileFlagOverlapped,
                         mode, 1, PIPE_BUF, PIPE_BUF, 0, &kNtIsInheritable);
-  __fds_lock();
   if (hin != -1) {
     if ((hout = CreateFile(
              pipename, kNtGenericWrite,
@@ -73,7 +72,6 @@ static textwindows int sys_pipe_nt_impl(int pipefd[2], unsigned flags) {
       g_fds.p[writer].handle = hout;
       pipefd[0] = reader;
       pipefd[1] = writer;
-      __fds_unlock();
       return 0;
     } else {
       CloseHandle(hin);
@@ -81,7 +79,6 @@ static textwindows int sys_pipe_nt_impl(int pipefd[2], unsigned flags) {
   }
   __releasefd(writer);
   __releasefd(reader);
-  __fds_unlock();
   return -1;
 }
 
diff --git a/libc/calls/pipe.c b/libc/calls/pipe.c
index 2f668c31d..9f897996a 100644
--- a/libc/calls/pipe.c
+++ b/libc/calls/pipe.c
@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
@@ -33,7 +33,7 @@
  * @asyncsignalsafe
  * @see pipe2()
  */
-int pipe(int pipefd[hasatleast 2]) {
+int pipe(int pipefd[2]) {
   int rc;
   if (!pipefd) {
     // needed for windows which is polyfilled
diff --git a/libc/calls/pipe2.c b/libc/calls/pipe2.c
index 36593d76c..7286fd8db 100644
--- a/libc/calls/pipe2.c
+++ b/libc/calls/pipe2.c
@@ -19,7 +19,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
 
@@ -39,7 +39,7 @@
  * @param flags can have O_CLOEXEC or O_DIRECT or O_NONBLOCK
  * @return 0 on success, or -1 w/ errno and pipefd isn't modified
  */
-int pipe2(int pipefd[hasatleast 2], int flags) {
+int pipe2(int pipefd[2], int flags) {
   int rc;
   if (flags & ~(O_CLOEXEC | O_NONBLOCK | (O_DIRECT != -1u ? O_DIRECT : 0))) {
     return einval();
diff --git a/libc/calls/pivot_root.c b/libc/calls/pivot_root.c
index aec7fe4bf..53c6af00c 100644
--- a/libc/calls/pivot_root.c
+++ b/libc/calls/pivot_root.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Changes root mount.
diff --git a/libc/calls/pledge-linux.c b/libc/calls/pledge-linux.c
index d36684bfd..3ea63946c 100644
--- a/libc/calls/pledge-linux.c
+++ b/libc/calls/pledge-linux.c
@@ -28,8 +28,8 @@
 #include "libc/calls/ucontext.h"
 #include "libc/intrin/bsr.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/promises.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/promises.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
 #include "libc/sysv/consts/audit.h"
@@ -694,6 +694,7 @@ static const uint16_t kPledgeStdio[] = {
     __NR_linux_sched_getaffinity,  //
     __NR_linux_sched_setaffinity,  //
     __NR_linux_sigtimedwait,       //
+    __NR_linux_getcpu,             //
 };
 
 static const uint16_t kPledgeFlock[] = {
@@ -712,6 +713,7 @@ static const uint16_t kPledgeRpath[] = {
 #endif                             //
     __NR_linux_fstat,              //
     __NR_linux_fstatat,            //
+    __NR_linux_statx,              //
 #ifdef __NR_linux_access           //
     __NR_linux_access,             //
 #endif                             //
@@ -739,6 +741,7 @@ static const uint16_t kPledgeWpath[] = {
     __NR_linux_lstat,               //
 #endif                              //
     __NR_linux_fstatat,             //
+    __NR_linux_statx,               //
 #ifdef __NR_linux_access            //
     __NR_linux_access,              //
 #endif                              //
@@ -1005,16 +1008,15 @@ static const struct sock_filter kPledgeStart[] = {
     BPF_STMT(BPF_LD | BPF_W | BPF_ABS, OFF(nr)),
 #ifdef __NR_linux_memfd_secret
     // forbid some system calls with ENOSYS (rather than EPERM)
-    BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, __NR_linux_memfd_secret, 5, 0),
+    BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, __NR_linux_memfd_secret, 4, 0),
 #else
     BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, __NR_linux_landlock_restrict_self + 1,
-             5, 0),
+             4, 0),
 #endif
-    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_linux_rseq, 4, 0),
-    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_linux_memfd_create, 3, 0),
-    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_linux_openat2, 2, 0),
-    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_linux_clone3, 1, 0),
-    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_linux_statx, 0, 1),
+    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_linux_rseq, 3, 0),
+    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_linux_memfd_create, 2, 0),
+    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_linux_openat2, 1, 0),
+    BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, __NR_linux_clone3, 0, 1),
     BPF_STMT(BPF_RET | BPF_K, SECCOMP_RET_ERRNO | (Enosys & SECCOMP_RET_DATA)),
 };
 
diff --git a/libc/calls/pledge.c b/libc/calls/pledge.c
index f56af95fa..812844502 100644
--- a/libc/calls/pledge.c
+++ b/libc/calls/pledge.c
@@ -24,8 +24,8 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/promises.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/promises.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nexgen32e/vendor.internal.h"
 #include "libc/runtime/runtime.h"
@@ -169,8 +169,7 @@
  *   turn APE binaries into static native binaries.
  *
  * - "prot_exec" allows mmap(PROT_EXEC) and mprotect(PROT_EXEC). This is
- *   needed to (1) code morph mutexes in __enable_threads(), and it's
- *   needed to (2) launch non-static or non-native executables, e.g.
+ *   needed to launch non-static or non-native executables, e.g.
  *   non-assimilated APE binaries, or dynamic-linked executables.
  *
  * - "unveil" allows unveil() to be called, as well as the underlying
@@ -233,6 +232,21 @@
  *   option might not be a good idea if you're pledging `exec` because
  *   subprocesses can't inherit the `SIGSYS` handler this installs.
  *
+ * If you experience crashes during startup when execve'ing a cosmo
+ * binary that's had permissions like rpath pledged away, then try doing
+ * this before calling execve. This prevents special startup checks.
+ *
+ *     putenv("COMDBG=program.dbg");
+ *
+ * If having pledge() security is mission critical, then add this code
+ * to the start of your main() function to ensure your program fails
+ * with an error if it isn't available.
+ *
+ *     if (pledge(0, 0)) {
+ *       fprintf(stderr, "error: OS doesn't support pledge() security\n");
+ *       exit(1);
+ *     }
+ *
  * @return 0 on success, or -1 w/ errno
  * @raise ENOSYS if `pledge(0, 0)` was used and security is not possible
  * @raise EINVAL if `execpromises` on Linux isn't a subset of `promises`
diff --git a/libc/calls/pledge.internal.h b/libc/calls/pledge.internal.h
index a133cc904..773d38b55 100644
--- a/libc/calls/pledge.internal.h
+++ b/libc/calls/pledge.internal.h
@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_PLEDGE_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_PLEDGE_INTERNAL_H_
 #include "libc/calls/pledge.h"
-#include "libc/intrin/promises.internal.h"
+#include "libc/intrin/promises.h"
 COSMOPOLITAN_C_START_
 
 struct Pledges {
diff --git a/libc/calls/poll-metal.c b/libc/calls/poll-metal.c
index 613d4d415..d81af2658 100644
--- a/libc/calls/poll-metal.c
+++ b/libc/calls/poll-metal.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/nexgen32e/uart.internal.h"
 #include "libc/runtime/pc.internal.h"
diff --git a/libc/calls/poll-nt.c b/libc/calls/poll-nt.c
index f2b16e91d..cc015f045 100644
--- a/libc/calls/poll-nt.c
+++ b/libc/calls/poll-nt.c
@@ -16,219 +16,358 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigaction.h"
+#include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/struct/timespec.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
+#include "libc/calls/struct/timespec.internal.h"
+#include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
-#include "libc/mem/mem.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/weaken.h"
+#include "libc/macros.h"
 #include "libc/nt/console.h"
 #include "libc/nt/enum/filetype.h"
+#include "libc/nt/enum/wait.h"
 #include "libc/nt/errors.h"
+#include "libc/nt/events.h"
 #include "libc/nt/files.h"
 #include "libc/nt/ipc.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/pollfd.h"
 #include "libc/nt/synchronization.h"
-#include "libc/nt/thread.h"
-#include "libc/nt/thunk/msabi.h"
+#include "libc/nt/time.h"
 #include "libc/nt/winsock.h"
-#include "libc/runtime/runtime.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/struct/pollfd.h"
-#include "libc/sock/struct/pollfd.internal.h"
-#include "libc/stdio/sysparam.h"
 #include "libc/sysv/consts/o.h"
-#include "libc/sysv/consts/poll.h"
-#include "libc/sysv/consts/sig.h"
+#include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/posixthread.internal.h"
-#include "libc/thread/tls.h"
 #ifdef __x86_64__
 
-#define POLL_INTERVAL_MS 10
+// <sync libc/sysv/consts.sh>
+#define POLLERR_    0x0001  // implied in events
+#define POLLHUP_    0x0002  // implied in events
+#define POLLNVAL_   0x0004  // implied in events
+#define POLLIN_     0x0300
+#define POLLRDNORM_ 0x0100
+#define POLLRDBAND_ 0x0200
+#define POLLOUT_    0x0010
+#define POLLWRNORM_ 0x0010
+#define POLLWRBAND_ 0x0020  // MSDN undocumented
+#define POLLPRI_    0x0400  // MSDN unsupported
+// </sync libc/sysv/consts.sh>
+
+textwindows static uint32_t sys_poll_nt_waitms(struct timespec deadline) {
+  struct timespec now = sys_clock_gettime_monotonic_nt();
+  if (timespec_cmp(now, deadline) < 0) {
+    struct timespec remain = timespec_sub(deadline, now);
+    int64_t millis = timespec_tomillis(remain);
+    uint32_t waitfor = MIN(millis, 0xffffffffu);
+    return MIN(waitfor, POLL_INTERVAL_MS);
+  } else {
+    return 0;  // we timed out
+  }
+}
 
 // Polls on the New Technology.
 //
 // This function is used to implement poll() and select(). You may poll
 // on sockets, files and the console at the same time. We also poll for
 // both signals and posix thread cancelation, while the poll is polling
-static textwindows int sys_poll_nt_impl(struct pollfd *fds, uint64_t nfds,
-                                        uint32_t *ms, sigset_t sigmask) {
-  bool ok;
-  uint64_t millis;
-  uint32_t cm, avail, waitfor;
-  struct sys_pollfd_nt pipefds[8];
+textwindows static int sys_poll_nt_actual(struct pollfd *fds, uint64_t nfds,
+                                          struct timespec deadline,
+                                          sigset_t waitmask) {
+  int fileindices[64];
+  int sockindices[64];
+  int64_t filehands[64];
+  struct PosixThread *pt;
+  int i, rc, ev, kind, gotsocks;
   struct sys_pollfd_nt sockfds[64];
-  int pipeindices[ARRAYLEN(pipefds)];
-  int sockindices[ARRAYLEN(sockfds)];
-  struct timespec started, deadline, remain, now;
-  int i, rc, sn, pn, gotinvals, gotpipes, gotsocks;
+  uint32_t cm, fi, sn, pn, avail, waitfor, already_slept;
 
-  started = timespec_real();
-  deadline = timespec_add(started, timespec_frommillis(ms ? *ms : -1u));
+  // ensure revents is cleared
+  for (i = 0; i < nfds; ++i)
+    fds[i].revents = 0;
 
-  // do the planning
-  // we need to read static variables
-  // we might need to spawn threads and open pipes
+  // divide files from sockets
+  // check for invalid file descriptors
   __fds_lock();
-  for (gotinvals = rc = sn = pn = i = 0; i < nfds; ++i) {
+  for (rc = sn = pn = i = 0; i < nfds; ++i) {
     if (fds[i].fd < 0)
       continue;
     if (__isfdopen(fds[i].fd)) {
-      if (__isfdkind(fds[i].fd, kFdSocket)) {
+      kind = g_fds.p[fds[i].fd].kind;
+      if (kind == kFdSocket) {
+        // we can use WSAPoll() for these fds
         if (sn < ARRAYLEN(sockfds)) {
-          // the magnums for POLLIN/OUT/PRI on NT include the other ones too
-          // we need to clear ones like POLLNVAL or else WSAPoll shall whine
+          // WSAPoll whines if we pass POLLNVAL, POLLHUP, or POLLERR.
           sockindices[sn] = i;
           sockfds[sn].handle = g_fds.p[fds[i].fd].handle;
-          sockfds[sn].events = fds[i].events & (POLLPRI | POLLIN | POLLOUT);
+          sockfds[sn].events =
+              fds[i].events & (POLLRDNORM_ | POLLRDBAND_ | POLLWRNORM_);
           sockfds[sn].revents = 0;
           ++sn;
         } else {
-          // too many socket fds
-          rc = enomem();
+          // too many sockets
+          rc = einval();
           break;
         }
-      } else if (pn < ARRAYLEN(pipefds)) {
-        pipeindices[pn] = i;
-        pipefds[pn].handle = g_fds.p[fds[i].fd].handle;
-        pipefds[pn].events = 0;
-        pipefds[pn].revents = 0;
-        switch (g_fds.p[fds[i].fd].flags & O_ACCMODE) {
-          case O_RDONLY:
-            pipefds[pn].events = fds[i].events & POLLIN;
-            break;
-          case O_WRONLY:
-            pipefds[pn].events = fds[i].events & POLLOUT;
-            break;
-          case O_RDWR:
-            pipefds[pn].events = fds[i].events & (POLLIN | POLLOUT);
-            break;
-          default:
-            break;
+      } else if (kind == kFdFile || kind == kFdConsole) {
+        // we can use WaitForMultipleObjects() for these fds
+        if (pn < ARRAYLEN(fileindices) - 1) {  // last slot for signal event
+          fileindices[pn] = i;
+          filehands[pn] = g_fds.p[fds[i].fd].handle;
+          ++pn;
+        } else {
+          // too many files
+          rc = einval();
+          break;
+        }
+      } else if (kind == kFdDevNull || kind == kFdDevRandom || kind == kFdZip) {
+        // we can't wait on these kinds via win32
+        if (fds[i].events & (POLLRDNORM_ | POLLWRNORM_)) {
+          // the linux kernel does this irrespective of oflags
+          fds[i].revents = fds[i].events & (POLLRDNORM_ | POLLWRNORM_);
         }
-        ++pn;
       } else {
-        // too many non-socket fds
-        rc = enomem();
-        break;
+        // unsupported file type
+        fds[i].revents = POLLNVAL_;
       }
     } else {
-      ++gotinvals;
+      // file not open
+      fds[i].revents = POLLNVAL_;
     }
+    rc += !!fds[i].revents;
   }
   __fds_unlock();
-  if (rc) {
-    // failed to create a polling solution
+  if (rc == -1)
     return rc;
-  }
 
-  // perform the i/o and sleeping and looping
+  // perform poll operation
   for (;;) {
-    // see if input is available on non-sockets
-    for (gotpipes = i = 0; i < pn; ++i) {
-      if (pipefds[i].events & POLLOUT) {
-        // we have no way of polling if a non-socket is writeable yet
-        // therefore we assume that if it can happen, it shall happen
-        pipefds[i].revents |= POLLOUT;
+
+    // check input status of pipes / consoles without blocking
+    // this ensures any socket fds won't starve them of events
+    // we can't poll file handles, so we just mark those ready
+    for (i = 0; i < pn; ++i) {
+      fi = fileindices[i];
+      ev = fds[fi].events;
+      ev &= POLLRDNORM_ | POLLWRNORM_;
+      if ((g_fds.p[fds[fi].fd].flags & O_ACCMODE) == O_RDONLY)
+        ev &= ~POLLWRNORM_;
+      if ((g_fds.p[fds[fi].fd].flags & O_ACCMODE) == O_WRONLY)
+        ev &= ~POLLRDNORM_;
+      if ((ev & POLLWRNORM_) && !(ev & POLLRDNORM_)) {
+        fds[fi].revents = fds[fi].events & (POLLRDNORM_ | POLLWRNORM_);
+      } else if (GetFileType(filehands[i]) == kNtFileTypePipe) {
+        if (PeekNamedPipe(filehands[i], 0, 0, 0, &avail, 0)) {
+          if (avail)
+            fds[fi].revents = POLLRDNORM_;
+        } else if (GetLastError() == kNtErrorHandleEof ||
+                   GetLastError() == kNtErrorBrokenPipe) {
+          fds[fi].revents = POLLHUP_;
+        } else {
+          fds[fi].revents = POLLERR_;
+        }
+      } else if (GetConsoleMode(filehands[i], &cm)) {
+        switch (CountConsoleInputBytes()) {
+          case 0:
+            fds[fi].revents = fds[fi].events & POLLWRNORM_;
+            break;
+          case -1:
+            fds[fi].revents = POLLHUP_;
+            break;
+          default:
+            fds[fi].revents = fds[fi].events & (POLLRDNORM_ | POLLWRNORM_);
+            break;
+        }
+      } else {
+        fds[fi].revents = fds[fi].events & (POLLRDNORM_ | POLLWRNORM_);
       }
-      if (pipefds[i].events & POLLIN) {
-        if (GetFileType(pipefds[i].handle) == kNtFileTypePipe) {
-          ok = PeekNamedPipe(pipefds[i].handle, 0, 0, 0, &avail, 0);
-          POLLTRACE("PeekNamedPipe(%ld, 0, 0, 0, [%'u], 0) → %hhhd% m",
-                    pipefds[i].handle, avail, ok);
-          if (ok) {
-            if (avail) {
-              pipefds[i].revents |= POLLIN;
+      rc += !!fds[fi].revents;
+    }
+
+    // determine how long to wait
+    waitfor = sys_poll_nt_waitms(deadline);
+
+    // check for events and/or readiness on sockets
+    // we always do this due to issues with POLLOUT
+    if (sn) {
+      // if we need to wait, then we prefer to wait inside WSAPoll()
+      // this ensures network events are received in ~10µs not ~10ms
+      if (!rc && waitfor) {
+        if (__sigcheck(waitmask, false))
+          return -1;
+        already_slept = waitfor;
+      } else {
+        already_slept = 0;
+      }
+      if ((gotsocks = WSAPoll(sockfds, sn, already_slept)) == -1)
+        return __winsockerr();
+      if (gotsocks) {
+        for (i = 0; i < sn; ++i)
+          if (sockfds[i].revents) {
+            fds[sockindices[i]].revents = sockfds[i].revents;
+            ++rc;
+          }
+      } else if (already_slept) {
+        if (__sigcheck(waitmask, false))
+          return -1;
+      }
+    } else {
+      already_slept = 0;
+    }
+
+    // return if we observed events
+    if (rc || !waitfor)
+      break;
+
+    // if nothing has happened and we haven't already waited in poll()
+    // then we can wait on consoles, pipes, and signals simultaneously
+    // this ensures low latency for apps like emacs which with no sock
+    // here we shall actually report that something can be written too
+    if (!already_slept) {
+      intptr_t sigev;
+      if (!(sigev = CreateEvent(0, 0, 0, 0)))
+        return __winerr();
+      filehands[pn] = sigev;
+      pt = _pthread_self();
+      pt->pt_event = sigev;
+      pt->pt_blkmask = waitmask;
+      atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_EVENT,
+                            memory_order_release);
+      //!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!//
+      int sig = 0;
+      uint32_t wi = pn;
+      if (!_is_canceled() &&
+          !(_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))))
+        wi = WaitForMultipleObjects(pn + 1, filehands, 0, waitfor);
+      //!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!/!//
+      atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
+      CloseHandle(sigev);
+      if (wi == -1u)
+        // win32 wait failure
+        return __winerr();
+      if (wi == pn) {
+        // our signal event was signalled
+        int handler_was_called = 0;
+        if (sig)
+          handler_was_called = _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
+        if (_check_cancel() == -1)
+          return -1;
+        if (handler_was_called)
+          return eintr();
+      } else if ((wi ^ kNtWaitAbandoned) < pn) {
+        // this is possibly because a process or thread was killed
+        fds[fileindices[wi ^ kNtWaitAbandoned]].revents = POLLERR_;
+        ++rc;
+      } else if (wi < pn) {
+        fi = fileindices[wi];
+        // one of the handles we polled is ready for fi/o
+        if (GetConsoleMode(filehands[wi], &cm)) {
+          switch (CountConsoleInputBytes()) {
+            case 0:
+              // it's possible there was input and it was handled by the
+              // ICANON reader, and therefore should not be reported yet
+              if (fds[fi].events & POLLWRNORM_)
+                fds[fi].revents = POLLWRNORM_;
+              break;
+            case -1:
+              fds[fi].revents = POLLHUP_;
+              break;
+            default:
+              fds[fi].revents = fds[fi].events & (POLLRDNORM_ | POLLWRNORM_);
+              break;
+          }
+        } else if (GetFileType(filehands[wi]) == kNtFileTypePipe) {
+          if ((fds[fi].events & POLLRDNORM_) &&
+              (g_fds.p[fds[fi].fd].flags & O_ACCMODE) != O_WRONLY) {
+            if (PeekNamedPipe(filehands[wi], 0, 0, 0, &avail, 0)) {
+              fds[fi].revents = fds[fi].events & (POLLRDNORM_ | POLLWRNORM_);
+            } else if (GetLastError() == kNtErrorHandleEof ||
+                       GetLastError() == kNtErrorBrokenPipe) {
+              fds[fi].revents = POLLHUP_;
+            } else {
+              fds[fi].revents = POLLERR_;
             }
           } else {
-            pipefds[i].revents |= POLLERR;
-          }
-        } else if (GetConsoleMode(pipefds[i].handle, &cm)) {
-          if (CountConsoleInputBytes()) {
-            pipefds[i].revents |= POLLIN;  // both >0 and -1 (eof) are pollin
+            fds[fi].revents = fds[fi].events & (POLLRDNORM_ | POLLWRNORM_);
           }
         } else {
-          // we have no way of polling if a non-socket is readable yet
-          // therefore we assume that if it can happen it shall happen
-          pipefds[i].revents |= POLLIN;
-        }
-      }
-      if (pipefds[i].revents) {
-        ++gotpipes;
-      }
-    }
-    // if we haven't found any good results yet then here we
-    // compute a small time slice we don't mind sleeping for
-    if (sn) {
-      if ((gotsocks = WSAPoll(sockfds, sn, 0)) == -1) {
-        return __winsockerr();
-      }
-    } else {
-      gotsocks = 0;
-    }
-
-    // add some artificial delay, which we use as an opportunity to also
-    // check for pending signals, thread cancelation, etc.
-    waitfor = 0;
-    if (!gotinvals && !gotsocks && !gotpipes) {
-      now = timespec_real();
-      if (timespec_cmp(now, deadline) < 0) {
-        remain = timespec_sub(deadline, now);
-        millis = timespec_tomillis(remain);
-        waitfor = MIN(millis, 0xffffffffu);
-        waitfor = MIN(waitfor, POLL_INTERVAL_MS);
-        if (waitfor) {
-          POLLTRACE("poll() sleeping for %'d out of %'lu ms", waitfor,
-                    timespec_tomillis(remain));
-          if ((rc = _park_norestart(waitfor, sigmask)) == -1) {
-            return -1;  // eintr, ecanceled, etc.
-          }
+          fds[fi].revents = fds[fi].events & (POLLRDNORM_ | POLLWRNORM_);
         }
+        rc += !!fds[fi].revents;
+      } else {
+        // should only be possible on kNtWaitTimeout or semaphore abandoned
+        // keep looping for events and we'll catch timeout when appropriate
       }
     }
 
-    // we gave all the sockets and all the named pipes a shot
-    // if we found anything at all then it's time to end work
-    if (gotinvals || gotpipes || gotsocks || !waitfor) {
+    // once again, return if we observed events
+    if (rc)
       break;
-    }
   }
 
-  // the system call is going to succeed
-  // it's now ok to start setting the output memory
-  for (i = 0; i < nfds; ++i) {
-    if (fds[i].fd < 0 || __isfdopen(fds[i].fd)) {
-      fds[i].revents = 0;
-    } else {
-      fds[i].revents = POLLNVAL;
-    }
-  }
-  for (i = 0; i < pn; ++i) {
-    fds[pipeindices[i]].revents = pipefds[i].revents;
-  }
-  for (i = 0; i < sn; ++i) {
-    fds[sockindices[i]].revents = sockfds[i].revents;
-  }
-
-  // and finally return
-  return gotinvals + gotpipes + gotsocks;
+  return rc;
 }
 
-textwindows int sys_poll_nt(struct pollfd *fds, uint64_t nfds, uint32_t *ms,
+textwindows static int sys_poll_nt_impl(struct pollfd *fds, uint64_t nfds,
+                                        struct timespec deadline,
+                                        const sigset_t waitmask) {
+  int i, n, rc, got = 0;
+  struct timespec now, next, target;
+
+  // we normally don't check for signals until we decide to wait, since
+  // it's nice to have functions like write() be unlikely to EINTR, but
+  // ppoll is a function where users are surely thinking about signals,
+  // since ppoll actually allows them to block signals everywhere else.
+  if (__sigcheck(waitmask, false))
+    return -1;
+
+  // fast path
+  if (nfds <= 63)
+    return sys_poll_nt_actual(fds, nfds, deadline, waitmask);
+
+  // clumsy path
+  for (;;) {
+    for (i = 0; i < nfds; i += 64) {
+      n = nfds - i;
+      n = n > 64 ? 64 : n;
+      rc = sys_poll_nt_actual(fds + i, n, timespec_zero, waitmask);
+      if (rc == -1)
+        return -1;
+      got += rc;
+    }
+    if (got)
+      return got;
+    now = sys_clock_gettime_monotonic_nt();
+    if (timespec_cmp(now, deadline) >= 0)
+      return 0;
+    next = timespec_add(now, timespec_frommillis(POLL_INTERVAL_MS));
+    if (timespec_cmp(next, deadline) >= 0) {
+      target = deadline;
+    } else {
+      target = next;
+    }
+    if (_park_norestart(target, waitmask) == -1)
+      return -1;
+  }
+}
+
+textwindows int sys_poll_nt(struct pollfd *fds, uint64_t nfds,
+                            const struct timespec *relative,
                             const sigset_t *sigmask) {
   int rc;
+  struct timespec now, timeout, deadline;
   BLOCK_SIGNALS;
-  rc = sys_poll_nt_impl(fds, nfds, ms, sigmask ? *sigmask : 0);
+  now = relative ? sys_clock_gettime_monotonic_nt() : timespec_zero;
+  timeout = relative ? *relative : timespec_max;
+  deadline = timespec_add(now, timeout);
+  rc = sys_poll_nt_impl(fds, nfds, deadline, sigmask ? *sigmask : _SigMask);
   ALLOW_SIGNALS;
   return rc;
 }
diff --git a/libc/calls/poll.c b/libc/calls/poll.c
index 0108475bb..e547a41cf 100644
--- a/libc/calls/poll.c
+++ b/libc/calls/poll.c
@@ -16,69 +16,65 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/cp.internal.h"
-#include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/calls/struct/timespec.h"
 #include "libc/sock/struct/pollfd.h"
-#include "libc/sock/struct/pollfd.internal.h"
-#include "libc/stdckdint.h"
-#include "libc/sysv/errfuns.h"
 
 /**
- * Waits for something to happen on multiple file descriptors at once.
+ * Checks status on multiple file descriptors at once.
  *
- * Warning: XNU has an inconsistency with other platforms. If you have
- * pollfds with fd≥0 and none of the meaningful events flags are added
- * e.g. POLLIN then XNU won't check for POLLNVAL. This matters because
- * one of the use-cases for poll() is quickly checking for open files.
+ * Servers that need to handle an unbounded number of client connections
+ * should just create a separate thread for each client. poll() isn't a
+ * scalable i/o solution on any platform.
  *
- * Note: Polling works best on Windows for sockets. We're able to poll
- * input on named pipes. But for anything that isn't a socket, or pipe
- * with POLLIN, (e.g. regular file) then POLLIN/POLLOUT are always set
- * into revents if they're requested, provided they were opened with a
- * mode that permits reading and/or writing.
+ * One of the use cases for poll() is to quickly check if a number of
+ * file descriptors are valid. The canonical way to do this is to set
+ * events to 0 which prevents blocking and causes only the invalid,
+ * hangup, and error statuses to be checked.
  *
- * Note: Windows has a limit of 64 file descriptors and ENOMEM with -1
- * is returned if that limit is exceeded. In practice the limit is not
- * this low. For example, pollfds with fd<0 don't count. So the caller
- * could flip the sign bit with a short timeout, to poll a larger set.
+ * On XNU, the POLLHUP and POLLERR statuses aren't checked unless either
+ * POLLIN, POLLOUT, or POLLPRI are specified in the events field. Cosmo
+ * will however polyfill the checking of POLLNVAL on XNU with the events
+ * doesn't specify any of the above i/o events.
+ *
+ * When XNU and BSD OSes report POLLHUP, they will always set POLLIN too
+ * when POLLIN is requested, even in cases when there isn't unread data.
+ *
+ * Your poll() function will check the status of all file descriptors
+ * before returning. This function won't block unless none of the fds
+ * had had any reportable status.
+ *
+ * The impact shutdown() will have on poll() is a dice roll across OSes.
  *
  * @param fds[𝑖].fd should be a socket, input pipe, or conosle input
- *     and if it's a negative number then the entry is ignored
+ *     and if it's a negative number then the entry is ignored, plus
+ *     revents will be set to zero
  * @param fds[𝑖].events flags can have POLLIN, POLLOUT, POLLPRI,
  *     POLLRDNORM, POLLWRNORM, POLLRDBAND, POLLWRBAND as well as
  *     POLLERR, POLLHUP, and POLLNVAL although the latter are
  *     always implied (assuming fd≥0) so they're ignored here
- * @param timeout_ms if 0 means don't wait and -1 means wait forever
- * @return number of items fds whose revents field has been set to
- *     nonzero to describe its events, or 0 if the timeout elapsed,
- *     or -1 w/ errno
+ * @param timeout_ms if 0 means don't wait and negative waits forever
+ * @return number of `fds` whose revents field has been set to a nonzero
+ *     number, 0 if the timeout elapsed without events, or -1 w/ errno
  * @return fds[𝑖].revents is always zero initializaed and then will
  *     be populated with POLL{IN,OUT,PRI,HUP,ERR,NVAL} if something
  *     was determined about the file descriptor
  * @raise ECANCELED if thread was cancelled in masked mode
+ * @raise EINVAL if `nfds` exceeded `RLIMIT_NOFILE`
+ * @raise ENOMEM on failure to allocate memory
  * @raise EINTR if signal was delivered
  * @cancelationpoint
  * @asyncsignalsafe
  * @norestart
  */
 int poll(struct pollfd *fds, size_t nfds, int timeout_ms) {
-  int rc;
-  BEGIN_CANCELATION_POINT;
-
-  if (!IsWindows()) {
-    if (!IsMetal()) {
-      rc = sys_poll(fds, nfds, timeout_ms);
-    } else {
-      rc = sys_poll_metal(fds, nfds, timeout_ms);
-    }
+  struct timespec ts;
+  struct timespec *tsp;
+  if (timeout_ms >= 0) {
+    ts.tv_sec = timeout_ms / 1000;
+    ts.tv_nsec = timeout_ms % 1000 * 1000000;
+    tsp = &ts;
   } else {
-    uint32_t ms = timeout_ms >= 0 ? timeout_ms : -1u;
-    rc = sys_poll_nt(fds, nfds, &ms, 0);
+    tsp = 0;
   }
-
-  END_CANCELATION_POINT;
-  STRACE("poll(%s, %'zu, %'d) → %d% lm", DescribePollFds(rc, fds, nfds), nfds,
-         timeout_ms, rc);
-  return rc;
+  return ppoll(fds, nfds, tsp, 0);
 }
diff --git a/libc/calls/posix_fadvise.c b/libc/calls/posix_fadvise.c
index 2aea15d7b..f7ba74c91 100644
--- a/libc/calls/posix_fadvise.c
+++ b/libc/calls/posix_fadvise.c
@@ -19,13 +19,13 @@
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/posix_madvise.c b/libc/calls/posix_madvise.c
index 9503cd7a4..b6d816372 100644
--- a/libc/calls/posix_madvise.c
+++ b/libc/calls/posix_madvise.c
@@ -25,7 +25,7 @@
  * @return 0 on success, or errno on error
  * @raise EINVAL if `advice` isn't valid or supported by system
  * @raise EINVAL on Linux if addr/length isn't page size aligned with
- *     respect to `getauxval(AT_PAGESZ)`
+ *     respect to `getpagesize()`
  * @raise ENOMEM on Linux if addr/length overlaps unmapped regions
  * @returnserrno
  */
diff --git a/libc/calls/posix_openpt.c b/libc/calls/posix_openpt.c
index ae36362fb..2868bba77 100644
--- a/libc/calls/posix_openpt.c
+++ b/libc/calls/posix_openpt.c
@@ -20,8 +20,8 @@
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/at.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/ppoll.c b/libc/calls/ppoll.c
index 8c2d6d38f..d961a27f4 100644
--- a/libc/calls/ppoll.c
+++ b/libc/calls/ppoll.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
@@ -23,46 +24,48 @@
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/limits.h"
+#include "libc/runtime/stack.h"
 #include "libc/sock/struct/pollfd.h"
 #include "libc/sock/struct/pollfd.internal.h"
 #include "libc/stdckdint.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/f.h"
+#include "libc/sysv/consts/poll.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
 
-/**
- * Waits for something to happen on multiple file descriptors at once.
- *
- * This function is the same as saying:
- *
- *     sigset_t old;
- *     sigprocmask(SIG_SETMASK, sigmask, &old);
- *     poll(fds, nfds, timeout);
- *     sigprocmask(SIG_SETMASK, old, 0);
- *
- * Except it happens atomically when the kernel supports doing that. On
- * kernel such as XNU and NetBSD which don't, this wrapper will fall
- * back to using the example above. Consider using pselect() which is
- * atomic on all supported platforms.
- *
- * The Linux Kernel modifies the timeout parameter. This wrapper gives
- * it a local variable due to POSIX requiring that `timeout` be const.
- * If you need that information from the Linux Kernel use sys_ppoll().
- *
- * @param timeout if null will block indefinitely
- * @param sigmask may be null in which case no mask change happens
- * @raise ECANCELED if thread was cancelled in masked mode
- * @raise EINTR if signal was delivered
- * @cancelationpoint
- * @asyncsignalsafe
- * @norestart
- */
-int ppoll(struct pollfd *fds, size_t nfds, const struct timespec *timeout,
-          const sigset_t *sigmask) {
-  int e, rc;
+static int ppoll_impl(struct pollfd *fds, size_t nfds,
+                      const struct timespec *timeout, const sigset_t *sigmask) {
+  int e, fdcount;
   sigset_t oldmask;
   struct timespec ts, *tsp;
-  BEGIN_CANCELATION_POINT;
+
+  // validate timeout
+  if (timeout && timeout->tv_nsec >= 1000000000ull)
+    return einval();
+
+  // The OpenBSD poll() man pages claims it'll ignore POLLERR, POLLHUP,
+  // and POLLNVAL in pollfd::events except it doesn't actually do this.
+  size_t bytes = 0;
+  struct pollfd *fds2 = 0;
+  if (IsOpenbsd()) {
+    if (ckd_mul(&bytes, nfds, sizeof(struct pollfd)))
+      return einval();
+#pragma GCC push_options
+#pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
+    fds2 = alloca(bytes);
+#pragma GCC pop_options
+    CheckLargeStackAllocation(fds2, bytes);
+    memcpy(fds2, fds, bytes);
+    for (size_t i = 0; i < nfds; ++i)
+      fds2[i].events &= ~(POLLERR | POLLHUP | POLLNVAL);
+    struct pollfd *swap = fds;
+    fds = fds2;
+    fds2 = swap;
+  }
 
   if (!IsWindows()) {
     e = errno;
@@ -72,31 +75,128 @@ int ppoll(struct pollfd *fds, size_t nfds, const struct timespec *timeout,
     } else {
       tsp = 0;
     }
-    rc = sys_ppoll(fds, nfds, tsp, sigmask, 8);
-    if (rc == -1 && errno == ENOSYS) {
-      int ms;
+    fdcount = sys_ppoll(fds, nfds, tsp, sigmask, 8);
+    if (fdcount == -1 && errno == ENOSYS) {
+      int64_t ms;
       errno = e;
-      if (!timeout || ckd_add(&ms, timeout->tv_sec,
-                              (timeout->tv_nsec + 999999) / 1000000)) {
+      if (timeout) {
+        ms = timespec_tomillis(*timeout);
+        if (ms > INT_MAX)
+          ms = -1;
+      } else {
         ms = -1;
       }
       if (sigmask)
         sys_sigprocmask(SIG_SETMASK, sigmask, &oldmask);
-      rc = poll(fds, nfds, ms);
+      fdcount = sys_poll(fds, nfds, ms);
       if (sigmask)
         sys_sigprocmask(SIG_SETMASK, &oldmask, 0);
     }
   } else {
-    uint32_t ms;
-    if (!timeout ||
-        ckd_add(&ms, timeout->tv_sec, (timeout->tv_nsec + 999999) / 1000000)) {
-      ms = -1u;
-    }
-    rc = sys_poll_nt(fds, nfds, &ms, sigmask);
+    fdcount = sys_poll_nt(fds, nfds, timeout, sigmask);
   }
 
-  END_CANCELATION_POINT;
-  STRACE("ppoll(%s, %'zu, %s, %s) → %d% lm", DescribePollFds(rc, fds, nfds),
-         nfds, DescribeTimespec(0, timeout), DescribeSigset(0, sigmask), rc);
-  return rc;
+  if (IsOpenbsd() && fdcount != -1) {
+    struct pollfd *swap = fds;
+    fds = fds2;
+    fds2 = swap;
+    memcpy(fds, fds2, bytes);
+  }
+
+  // One of the use cases for poll() is checking if a large number of
+  // file descriptors exist. However on XNU if none of the meaningful
+  // event flags are specified (e.g. POLLIN, POLLOUT) then it doesn't
+  // perform the POLLNVAL check that's implied on all other platforms
+  if (IsXnu() && fdcount != -1) {
+    for (size_t i = 0; i < nfds; ++i) {
+      if (fds[i].fd >= 0 &&   //
+          !fds[i].revents &&  //
+          !(fds[i].events & (POLLIN | POLLOUT | POLLPRI))) {
+        int err = errno;
+        if (fcntl(fds[i].fd, F_GETFL) == -1) {
+          errno = err;
+          fds[i].revents = POLLNVAL;
+          ++fdcount;
+        }
+      }
+    }
+  }
+
+  return fdcount;
+}
+
+/**
+ * Checks status on multiple file descriptors at once.
+ *
+ * This function is the same as saying:
+ *
+ *     sigset_t old;
+ *     sigprocmask(SIG_SETMASK, sigmask, &old);
+ *     poll(fds, nfds, timeout);
+ *     sigprocmask(SIG_SETMASK, old, 0);
+ *
+ * Except it happens atomically when the kernel supports doing that. On
+ * kernels such as XNU and NetBSD which don't, this wrapper will fall
+ * back to using the example above. If you need ironclad assurances of
+ * signal mask atomicity, then consider using pselect() which Cosmo Libc
+ * guarantees to be atomic on all supported platforms.
+ *
+ * Servers that need to handle an unbounded number of client connections
+ * should just create a separate thread for each client. poll(), ppoll()
+ * and select() aren't scalable i/o solutions on any platform.
+ *
+ * On Windows it's only possible to poll 64 file descriptors at a time;
+ * it's a limitation imposed by WSAPoll(). Cosmopolitan Libc's ppoll()
+ * polyfill can go higher in some cases; for example, It's possible to
+ * poll 64 sockets and 64 pipes/terminals at the same time. Furthermore,
+ * elements whose fd field is set to a negative number are ignored and
+ * will not count against this limit.
+ *
+ * One of the use cases for poll() is to quickly check if a number of
+ * file descriptors are valid. The canonical way to do this is to set
+ * events to 0 which prevents blocking and causes only the invalid,
+ * hangup, and error statuses to be checked.
+ *
+ * On XNU, the POLLHUP and POLLERR statuses aren't checked unless either
+ * POLLIN, POLLOUT, or POLLPRI are specified in the events field. Cosmo
+ * will however polyfill the checking of POLLNVAL on XNU with the events
+ * doesn't specify any of the above i/o events.
+ *
+ * When XNU and BSD OSes report POLLHUP, they will always set POLLIN too
+ * when POLLIN is requested, even in cases when there isn't unread data.
+ *
+ * @param fds[𝑖].fd should be a socket, input pipe, or conosle input
+ *     and if it's a negative number then the entry is ignored, plus
+ *     revents will be set to zero
+ * @param fds[𝑖].events flags can have POLLIN, POLLOUT, POLLPRI,
+ *     POLLRDNORM, POLLWRNORM, POLLRDBAND, POLLWRBAND as well as
+ *     POLLERR, POLLHUP, and POLLNVAL although the latter are
+ *     always implied (assuming fd≥0) so they're ignored here
+ * @param timeout_ms if 0 means don't wait and negative waits forever
+ * @return number of `fds` whose revents field has been set to a nonzero
+ *     number, 0 if the timeout elapsed without events, or -1 w/ errno
+ * @return fds[𝑖].revents is always zero initializaed and then will
+ *     be populated with POLL{IN,OUT,PRI,HUP,ERR,NVAL} if something
+ *     was determined about the file descriptor
+ * @param timeout if null will block indefinitely
+ * @param sigmask may be null in which case no mask change happens
+ * @raise ECANCELED if thread was cancelled in masked mode
+ * @raise EINVAL if `nfds` exceeded `RLIMIT_NOFILE`
+ * @raise ENOMEM on failure to allocate memory
+ * @raise EINVAL if `*timeout` is invalid
+ * @raise EINTR if signal was delivered
+ * @cancelationpoint
+ * @asyncsignalsafe
+ * @norestart
+ */
+int ppoll(struct pollfd *fds, size_t nfds, const struct timespec *timeout,
+          const sigset_t *sigmask) {
+  int fdcount;
+  BEGIN_CANCELATION_POINT;
+  fdcount = ppoll_impl(fds, nfds, timeout, sigmask);
+  END_CANCELATION_POINT;
+  STRACE("ppoll(%s, %'zu, %s, %s) → %d% lm",
+         DescribePollFds(fdcount, fds, nfds), nfds,
+         DescribeTimespec(0, timeout), DescribeSigset(0, sigmask), fdcount);
+  return fdcount;
 }
diff --git a/libc/calls/prctl.c b/libc/calls/prctl.c
index bd31a8c75..4d5119cf8 100644
--- a/libc/calls/prctl.c
+++ b/libc/calls/prctl.c
@@ -21,8 +21,8 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/pr.h"
 #include "libc/sysv/errfuns.h"
 
@@ -53,15 +53,5 @@ int prctl(int operation, ...) {
     rc = enosys();
   }
 
-#if SYSDEBUG
-  if (operation == PR_CAPBSET_READ || operation == PR_CAPBSET_DROP) {
-    STRACE("prctl(%s, %s) → %d% m", DescribePrctlOperation(operation),
-           DescribeCapability(a), rc);
-  } else {
-    STRACE("prctl(%s, %p, %p, %p, %p) → %d% m",
-           DescribePrctlOperation(operation), a, b, c, d, rc);
-  }
-#endif
-
   return rc;
 }
diff --git a/libc/calls/pread.c b/libc/calls/pread.c
index 4aa7b0c53..ee42b55bd 100644
--- a/libc/calls/pread.c
+++ b/libc/calls/pread.c
@@ -24,9 +24,9 @@
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/stdio/sysparam.h"
diff --git a/libc/calls/preadv.c b/libc/calls/preadv.c
index 586141b80..21ac113e0 100644
--- a/libc/calls/preadv.c
+++ b/libc/calls/preadv.c
@@ -25,7 +25,7 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
 #include "libc/mem/alloca.h"
@@ -60,6 +60,7 @@ static ssize_t Preadv(int fd, struct iovec *iov, int iovlen, int64_t off) {
       struct iovec *iov2;
 #pragma GCC push_options
 #pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
       iov2 = alloca(iovlen * sizeof(struct iovec));
       CheckLargeStackAllocation(iov2, iovlen * sizeof(struct iovec));
 #pragma GCC pop_options
diff --git a/libc/calls/printfds.c b/libc/calls/printfds.c
index 9e3ad0e55..4786357ef 100644
--- a/libc/calls/printfds.c
+++ b/libc/calls/printfds.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/fd.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/fds.h"
 #include "libc/intrin/kprintf.h"
 
 static const char *__fdkind2str(int x) {
@@ -55,7 +55,7 @@ void __printfds(struct Fd *fds, size_t fdslen) {
       continue;
     kprintf("%3d %s", i, __fdkind2str(fds[i].kind));
     if (fds[i].flags) {
-      kprintf(" flags=%s", (DescribeOpenFlags)(buf, fds[i].flags));
+      kprintf(" flags=%s", _DescribeOpenFlags(buf, fds[i].flags));
     }
     if (fds[i].mode)
       kprintf(" mode=%#o", fds[i].mode);
diff --git a/libc/calls/program_executable_name_init.S b/libc/calls/program_executable_name_init.S
index 99ed4db3e..262018e25 100644
--- a/libc/calls/program_executable_name_init.S
+++ b/libc/calls/program_executable_name_init.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.init.start 305,_init_program_executable_name
 	push	%rdi
diff --git a/libc/calls/pselect.c b/libc/calls/pselect.c
index 391d94f53..93c7f495f 100644
--- a/libc/calls/pselect.c
+++ b/libc/calls/pselect.c
@@ -23,8 +23,8 @@
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/calls/struct/timeval.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/select.h"
 #include "libc/sock/select.internal.h"
@@ -32,7 +32,7 @@
 #include "libc/sysv/errfuns.h"
 
 /**
- * Does what poll() does except with bitset API.
+ * Checks status on multiple file descriptors at once.
  *
  * This function is the same as saying:
  *
@@ -41,15 +41,23 @@
  *     select(nfds, readfds, writefds, exceptfds, timeout);
  *     sigprocmask(SIG_SETMASK, old, 0);
  *
- * Except it happens atomically.
- *
- * The Linux Kernel modifies the timeout parameter. This wrapper gives
- * it a local variable due to POSIX requiring that `timeout` be const.
- * If you need that information from the Linux Kernel use sys_pselect.
- *
- * This system call is supported on all platforms. It's like select()
- * except that it atomically changes the sigprocmask() during the op.
+ * Except it happens atomically. Unlike ppoll() Cosmo guarantees this is
+ * atomic on all supported platforms.
  *
+ * @param nfds is the number of the highest file descriptor set in these
+ *     bitsets by the caller, plus one; this value can't be greater than
+ *     `FD_SETSIZE` which Cosmopolitan currently defines as 1024 because
+ *     `fd_set` has a static size
+ * @param readfds may be used to be notified when you can call read() on
+ *     a file descriptor without it blocking; this includes when data is
+ *     is available to be read as well as eof and error conditions
+ * @param writefds may be used to be notified when write() may be called
+ *     on a file descriptor without it blocking
+ * @param exceptfds may be used to be notified of exceptional conditions
+ *     such as out-of-band data on a socket; it is equivalent to POLLPRI
+ *     in the revents of poll()
+ * @param timeout if null will block indefinitely
+ * @param sigmask may be null in which case no mask change happens
  * @raise ECANCELED if thread was cancelled in masked mode
  * @raise EINTR if signal was delivered
  * @cancelationpoint
@@ -59,7 +67,6 @@
 int pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
             const struct timespec *timeout, const sigset_t *sigmask) {
   int rc;
-  struct timeval tv, *tvp;
   struct timespec ts, *tsp;
   struct {
     const sigset_t *s;
@@ -74,7 +81,7 @@ int pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
   fd_set *old_exceptfds_ptr = 0;
 
   BEGIN_CANCELATION_POINT;
-  if (nfds < 0) {
+  if (nfds < 0 || nfds > FD_SETSIZE) {
     rc = einval();
   } else {
     if (readfds) {
@@ -103,24 +110,17 @@ int pselect(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
       rc = sys_pselect(nfds, readfds, writefds, exceptfds,
                        (struct timespec *)timeout, sigmask);
     } else {
-      if (timeout) {
-        tv.tv_sec = timeout->tv_sec;
-        tv.tv_usec = timeout->tv_nsec / 1000;
-        tvp = &tv;
-      } else {
-        tvp = 0;
-      }
-      rc = sys_select_nt(nfds, readfds, writefds, exceptfds, tvp, sigmask);
+      rc = sys_select_nt(nfds, readfds, writefds, exceptfds, timeout, sigmask);
     }
   }
   END_CANCELATION_POINT;
 
   STRACE("pselect(%d, %s → [%s], %s → [%s], %s → [%s], %s, %s) → %d% m", nfds,
-         DescribeFdSet(rc, nfds, old_readfds_ptr),
+         DescribeFdSet(0, nfds, old_readfds_ptr),
          DescribeFdSet(rc, nfds, readfds),
-         DescribeFdSet(rc, nfds, old_writefds_ptr),
+         DescribeFdSet(0, nfds, old_writefds_ptr),
          DescribeFdSet(rc, nfds, writefds),
-         DescribeFdSet(rc, nfds, old_exceptfds_ptr),
+         DescribeFdSet(0, nfds, old_exceptfds_ptr),
          DescribeFdSet(rc, nfds, exceptfds),  //
          DescribeTimespec(0, timeout),        //
          DescribeSigset(0, sigmask), rc);
diff --git a/libc/calls/ptrace.c b/libc/calls/ptrace.c
index 8acb3c8de..a48d0cc0a 100644
--- a/libc/calls/ptrace.c
+++ b/libc/calls/ptrace.c
@@ -19,8 +19,8 @@
 #include "libc/sysv/consts/ptrace.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/ptsname.c b/libc/calls/ptsname.c
index 67fc87abc..abf6b9f90 100644
--- a/libc/calls/ptsname.c
+++ b/libc/calls/ptsname.c
@@ -17,11 +17,11 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/calls/termios.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 static char g_ptsname[16];
diff --git a/libc/calls/pwrite.c b/libc/calls/pwrite.c
index f22f52f52..c76c1d01a 100644
--- a/libc/calls/pwrite.c
+++ b/libc/calls/pwrite.c
@@ -20,13 +20,13 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/stdio/sysparam.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/pwritev.c b/libc/calls/pwritev.c
index 651b320aa..3373a8f16 100644
--- a/libc/calls/pwritev.c
+++ b/libc/calls/pwritev.c
@@ -25,7 +25,7 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
 #include "libc/mem/alloca.h"
@@ -62,6 +62,7 @@ static ssize_t Pwritev(int fd, const struct iovec *iov, int iovlen,
       struct iovec *iov2;
 #pragma GCC push_options
 #pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
       iov2 = alloca(iovlen * sizeof(struct iovec));
       CheckLargeStackAllocation(iov2, iovlen * sizeof(struct iovec));
 #pragma GCC pop_options
diff --git a/libc/calls/raise.c b/libc/calls/raise.c
index 8ba3e67ff..096f9bea0 100644
--- a/libc/calls/raise.c
+++ b/libc/calls/raise.c
@@ -20,7 +20,7 @@
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/syslib.internal.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/read-nt.c b/libc/calls/read-nt.c
index 931e9b1f9..b50f428e2 100644
--- a/libc/calls/read-nt.c
+++ b/libc/calls/read-nt.c
@@ -16,23 +16,28 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/createfileflags.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/calls/struct/timespec.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/cosmo.h"
+#include "libc/ctype.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/nomultics.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/nomultics.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/console.h"
 #include "libc/nt/createfile.h"
 #include "libc/nt/enum/accessmask.h"
@@ -42,6 +47,8 @@
 #include "libc/nt/enum/vk.h"
 #include "libc/nt/enum/wait.h"
 #include "libc/nt/errors.h"
+#include "libc/nt/events.h"
+#include "libc/nt/memory.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/inputrecord.h"
 #include "libc/nt/synchronization.h"
@@ -81,15 +88,15 @@ struct VirtualKey {
 #define S(s) W(s "\0\0")
 #define W(s) (s[3] << 24 | s[2] << 16 | s[1] << 8 | s[0])
 
-static const struct VirtualKey kVirtualKey[] = {
-    {kNtVkUp, S("A"), S("1;2A"), S("1;5A"), S("1;6A")},
-    {kNtVkDown, S("B"), S("1;2B"), S("1;5B"), S("1;6B")},
-    {kNtVkRight, S("C"), S("1;2C"), S("1;5C"), S("1;6C")},
-    {kNtVkLeft, S("D"), S("1;2D"), S("1;5D"), S("1;6D")},
+static struct VirtualKey kVirtualKey[] = {
+    {kNtVkUp, S("A"), S("1;2A"), S("1;5A"), S("1;6A")},     // order matters
+    {kNtVkDown, S("B"), S("1;2B"), S("1;5B"), S("1;6B")},   // order matters
+    {kNtVkRight, S("C"), S("1;2C"), S("1;5C"), S("1;6C")},  // order matters
+    {kNtVkLeft, S("D"), S("1;2D"), S("1;5D"), S("1;6D")},   // order matters
+    {kNtVkEnd, S("F"), S("1;2F"), S("1;5F"), S("1;6F")},    // order matters
+    {kNtVkHome, S("H"), S("1;2H"), S("1;5H"), S("1;6H")},   // order matters
     {kNtVkInsert, S("2~"), S("2;2~"), S("2;5~"), S("2;6~")},
     {kNtVkDelete, S("3~"), S("3;2~"), S("3;5~"), S("3;6~")},
-    {kNtVkHome, S("H"), S("1;2H"), S("1;5H"), S("1;6H")},
-    {kNtVkEnd, S("F"), S("1;2F"), S("1;5F"), S("1;6F")},
     {kNtVkPrior, S("5~"), S("5;2~"), S("5;5~"), S("5;6~")},
     {kNtVkNext, S("6~"), S("6;2~"), S("6;5~"), S("6;6~")},
     {kNtVkF1, -S("OP"), S("1;2P"), S("11^"), S("1;6P")},
@@ -107,17 +114,6 @@ static const struct VirtualKey kVirtualKey[] = {
     {0},
 };
 
-// TODO: How can we configure `less` to not need this bloat?
-static const struct VirtualKey kDecckm[] = {
-    {kNtVkUp, -S("OA"), -S("OA"), S("A"), S("A")},
-    {kNtVkDown, -S("OB"), -S("OB"), S("B"), S("B")},
-    {kNtVkRight, -S("OC"), -S("OC"), S("C"), S("C")},
-    {kNtVkLeft, -S("OD"), -S("OD"), S("D"), S("D")},
-    {kNtVkPrior, S("5~"), S("5;2~"), S("5;5~"), S("5;6~")},
-    {kNtVkNext, S("6~"), S("6;2~"), S("6;5~"), S("6;6~")},
-    {0},
-};
-
 #define KEYSTROKE_CONTAINER(e) DLL_CONTAINER(struct Keystroke, elem, e)
 
 struct Keystroke {
@@ -130,79 +126,97 @@ struct Keystrokes {
   atomic_uint once;
   bool end_of_file;
   bool ohno_decckm;
+  bool bypass_mode;
   uint16_t utf16hs;
-  int16_t freekeys;
+  size_t free_keys;
   int64_t cin, cot;
   struct Dll *list;
   struct Dll *line;
   struct Dll *free;
-  pthread_mutex_t lock;
-  const struct VirtualKey *vkt;
-  struct Keystroke pool[512];
 };
 
 static struct Keystrokes __keystroke;
+static pthread_mutex_t __keystroke_lock = PTHREAD_MUTEX_INITIALIZER;
 
-textwindows void WipeKeystrokes(void) {
+textwindows void sys_read_nt_wipe_keystrokes(void) {
   bzero(&__keystroke, sizeof(__keystroke));
+  _pthread_mutex_wipe_np(&__keystroke_lock);
 }
 
-static textwindows void FreeKeystrokeImpl(struct Dll *key) {
+textwindows static void FreeKeystrokeImpl(struct Dll *key) {
   dll_make_first(&__keystroke.free, key);
-  ++__keystroke.freekeys;
+  ++__keystroke.free_keys;
 }
 
-static textwindows struct Keystroke *NewKeystroke(void) {
-  struct Dll *e = dll_first(__keystroke.free);
-  struct Keystroke *k = KEYSTROKE_CONTAINER(e);
-  dll_remove(&__keystroke.free, &k->elem);
-  --__keystroke.freekeys;
-  // TODO(jart): What's wrong with GCC 12.3?
-  asm("" : "+r"(k));
+textwindows static struct Keystroke *AllocKeystroke(void) {
+  struct Keystroke *k;
+  if (!(k = HeapAlloc(GetProcessHeap(), 0, sizeof(struct Keystroke))))
+    return 0;
+  dll_init(&k->elem);
+  return k;
+}
+
+textwindows static struct Keystroke *NewKeystroke(void) {
+  struct Dll *e;
+  struct Keystroke *k;
+  if ((e = dll_first(__keystroke.free))) {
+    dll_remove(&__keystroke.free, e);
+    k = KEYSTROKE_CONTAINER(e);
+    --__keystroke.free_keys;
+  } else {
+    // PopulateKeystrokes() should make this branch impossible
+    if (!(k = AllocKeystroke()))
+      return 0;
+  }
   k->buflen = 0;
   return k;
 }
 
-static textwindows void FreeKeystroke(struct Dll **list, struct Dll *key) {
+textwindows static void FreeKeystroke(struct Dll **list, struct Dll *key) {
   dll_remove(list, key);
   FreeKeystrokeImpl(key);
 }
 
-static textwindows void FreeKeystrokes(struct Dll **list) {
+textwindows static void FreeKeystrokes(struct Dll **list) {
   struct Dll *key;
-  while ((key = dll_first(*list))) {
+  while ((key = dll_first(*list)))
     FreeKeystroke(list, key);
+}
+
+textwindows static void PopulateKeystrokes(size_t want) {
+  struct Keystroke *k;
+  while (__keystroke.free_keys < want) {
+    if ((k = AllocKeystroke())) {
+      FreeKeystrokeImpl(&k->elem);
+    } else {
+      break;
+    }
   }
 }
 
-static textwindows void OpenConsole(void) {
-  __keystroke.vkt = kVirtualKey;
+textwindows static void OpenConsole(void) {
   __keystroke.cin = CreateFile(u"CONIN$", kNtGenericRead | kNtGenericWrite,
                                kNtFileShareRead, 0, kNtOpenExisting, 0, 0);
   __keystroke.cot = CreateFile(u"CONOUT$", kNtGenericRead | kNtGenericWrite,
                                kNtFileShareWrite, 0, kNtOpenExisting, 0, 0);
-  for (int i = 0; i < ARRAYLEN(__keystroke.pool); ++i) {
-    dll_init(&__keystroke.pool[i].elem);
-    FreeKeystrokeImpl(&__keystroke.pool[i].elem);
-  }
 }
 
-static textwindows int AddSignal(int sig) {
+textwindows static int AddSignal(int sig) {
   atomic_fetch_or_explicit(&__get_tls()->tib_sigpending, 1ull << (sig - 1),
                            memory_order_relaxed);
   return 0;
 }
 
-static textwindows void InitConsole(void) {
+textwindows static void InitConsole(void) {
   cosmo_once(&__keystroke.once, OpenConsole);
 }
 
-static textwindows void LockKeystrokes(void) {
-  pthread_mutex_lock(&__keystroke.lock);
+textwindows static void LockKeystrokes(void) {
+  _pthread_mutex_lock(&__keystroke_lock);
 }
 
-static textwindows void UnlockKeystrokes(void) {
-  pthread_mutex_unlock(&__keystroke.lock);
+textwindows static void UnlockKeystrokes(void) {
+  _pthread_mutex_unlock(&__keystroke_lock);
 }
 
 textwindows int64_t GetConsoleInputHandle(void) {
@@ -215,40 +229,39 @@ textwindows int64_t GetConsoleOutputHandle(void) {
   return __keystroke.cot;
 }
 
-static textwindows bool IsMouseModeCommand(int x) {
+textwindows static bool IsMouseModeCommand(int x) {
   return x == 1000 ||  // SET_VT200_MOUSE
          x == 1002 ||  // SET_BTN_EVENT_MOUSE
          x == 1006 ||  // SET_SGR_EXT_MODE_MOUSE
          x == 1015;    // SET_URXVT_EXT_MODE_MOUSE
 }
 
-static textwindows int GetVirtualKey(uint16_t vk, bool shift, bool ctrl) {
-  for (int i = 0; __keystroke.vkt[i].vk; ++i) {
-    if (__keystroke.vkt[i].vk == vk) {
+textwindows static int GetVirtualKey(uint16_t vk, bool shift, bool ctrl) {
+  for (int i = 0; kVirtualKey[i].vk; ++i) {
+    if (kVirtualKey[i].vk == vk) {
       if (shift && ctrl) {
-        return __keystroke.vkt[i].shift_ctrl_str;
+        return kVirtualKey[i].shift_ctrl_str;
       } else if (shift) {
-        return __keystroke.vkt[i].shift_str;
+        return kVirtualKey[i].shift_str;
       } else if (ctrl) {
-        return __keystroke.vkt[i].ctrl_str;
+        return kVirtualKey[i].ctrl_str;
       } else {
-        return __keystroke.vkt[i].normal_str;
+        return kVirtualKey[i].normal_str;
       }
     }
   }
   return 0;
 }
 
-static textwindows int ProcessKeyEvent(const struct NtInputRecord *r, char *p) {
+textwindows static int ProcessKeyEvent(const struct NtInputRecord *r, char *p) {
 
   uint32_t c = r->Event.KeyEvent.uChar.UnicodeChar;
   uint16_t vk = r->Event.KeyEvent.wVirtualKeyCode;
   uint16_t cks = r->Event.KeyEvent.dwControlKeyState;
 
   // ignore keyup events
-  if (!r->Event.KeyEvent.bKeyDown && (!c || vk != kNtVkMenu)) {
+  if (!r->Event.KeyEvent.bKeyDown && (!c || vk != kNtVkMenu))
     return 0;
-  }
 
 #if 0
   // this code is useful for troubleshooting why keys don't work
@@ -308,40 +321,41 @@ static textwindows int ProcessKeyEvent(const struct NtInputRecord *r, char *p) {
     __keystroke.utf16hs = c;
     return 0;
   }
-  if (IsLowSurrogate(c)) {
+  if (IsLowSurrogate(c))
     c = MergeUtf16(__keystroke.utf16hs, c);
-  }
 
   // enter sends \r with raw terminals
   // make it a multics newline instead
-  if (c == '\r' && !(__ttyconf.magic & kTtyNoCr2Nl)) {
+  if (c == '\r' && !(__ttyconf.magic & kTtyNoCr2Nl))
     c = '\n';
-  }
 
   // ctrl-space (^@) is literally zero
-  if (c == ' ' && (cks & (kNtLeftCtrlPressed | kNtRightCtrlPressed))) {
+  if (c == ' ' && (cks & (kNtLeftCtrlPressed | kNtRightCtrlPressed)))
     c = '\0';
-  }
 
   // make backspace (^?) distinguishable from ctrl-h (^H)
-  if (c == kNtVkBack && !(cks & (kNtLeftCtrlPressed | kNtRightCtrlPressed))) {
+  if (c == kNtVkBack && !(cks & (kNtLeftCtrlPressed | kNtRightCtrlPressed)))
     c = 0177;
-  }
 
   // handle ctrl-\ and ctrl-c
   // note we define _POSIX_VDISABLE as zero
   // tcsetattr() lets anyone reconfigure these keybindings
-  if (c && !(__ttyconf.magic & kTtyNoIsigs)) {
+  if (c && !(__ttyconf.magic & kTtyNoIsigs) && !__keystroke.bypass_mode) {
+    char b[] = {c};
     if (c == __ttyconf.vintr) {
+      EchoConsoleNt(b, 1, false);
       return AddSignal(SIGINT);
     } else if (c == __ttyconf.vquit) {
+      EchoConsoleNt(b, 1, false);
       return AddSignal(SIGQUIT);
     }
   }
 
   // handle ctrl-d which generates end-of-file, unless pending line data
   // is present, in which case we flush that without the newline instead
-  if (c && c == __ttyconf.veof && !(__ttyconf.magic & kTtyUncanon)) {
+  if (c && c == __ttyconf.veof &&  //
+      !__keystroke.bypass_mode &&  //
+      !(__ttyconf.magic & kTtyUncanon)) {
     if (dll_is_empty(__keystroke.line)) {
       __keystroke.end_of_file = true;
     } else {
@@ -371,7 +385,7 @@ static textwindows int ProcessKeyEvent(const struct NtInputRecord *r, char *p) {
 //   - write(1, "\e[?1000;1002;1015;1006h") to enable
 //   - write(1, "\e[?1000;1002;1015;1006l") to disable
 // See o//examples/ttyinfo and o//tool/viz/life
-static textwindows int ProcessMouseEvent(const struct NtInputRecord *r,
+textwindows static int ProcessMouseEvent(const struct NtInputRecord *r,
                                          char *b) {
   char *p = b;
   unsigned char e = 0;
@@ -396,21 +410,21 @@ static textwindows int ProcessMouseEvent(const struct NtInputRecord *r,
                   kNtLeftAltPressed | kNtRightAltPressed))) {
       // we disable mouse highlighting when the tty is put in raw mode
       // to mouse wheel events with widely understood vt100 arrow keys
-      *p++ = 033;
-      *p++ = !__keystroke.ohno_decckm ? '[' : 'O';
-      if (isup) {
-        *p++ = 'A';
-      } else {
-        *p++ = 'B';
+      for (int i = 0; i < 3; ++i) {
+        *p++ = 033;
+        *p++ = !__keystroke.ohno_decckm ? '[' : 'O';
+        if (isup) {
+          *p++ = 'A';
+        } else {
+          *p++ = 'B';
+        }
       }
     }
   } else if ((bs || currentbs) && (__ttyconf.magic & kTtyXtMouse)) {
-    if (bs && (ev & kNtMouseMoved) && currentbs) {
+    if (bs && (ev & kNtMouseMoved) && currentbs)
       e |= 32;  // dragging
-    }
-    if ((bs | currentbs) & kNtRightmostButtonPressed) {
+    if ((bs | currentbs) & kNtRightmostButtonPressed)
       e |= 2;  // right
-    }
   OutputXtermMouseEvent:
     *p++ = 033;
     *p++ = '[';
@@ -430,7 +444,7 @@ static textwindows int ProcessMouseEvent(const struct NtInputRecord *r,
   return p - b;
 }
 
-static textwindows int ConvertConsoleInputToAnsi(const struct NtInputRecord *r,
+textwindows static int ConvertConsoleInputToAnsi(const struct NtInputRecord *r,
                                                  char p[hasatleast 23]) {
   switch (r->EventType) {
     case kNtKeyEvent:
@@ -444,18 +458,19 @@ static textwindows int ConvertConsoleInputToAnsi(const struct NtInputRecord *r,
   }
 }
 
-static textwindows void WriteTty(const char *p, size_t n) {
+textwindows static void WriteTty(const char *p, size_t n) {
   WriteFile(__keystroke.cot, p, n, 0, 0);
 }
 
-static textwindows bool IsCtl(int c) {
-  return isascii(c) && iscntrl(c) && c != '\n' && c != '\t';
+textwindows static bool IsCtl(int c, bool escape_harder) {
+  return isascii(c) && iscntrl(c) &&
+         (escape_harder || (c != '\n' && c != '\t'));
 }
 
-static textwindows void WriteCtl(const char *p, size_t n) {
+textwindows static void WriteCtl(const char *p, size_t n, bool escape_harder) {
   size_t i;
   for (i = 0; i < n; ++i) {
-    if (IsCtl(p[i])) {
+    if (IsCtl(p[i], escape_harder)) {
       char ctl[2];
       ctl[0] = '^';
       ctl[1] = p[i] ^ 0100;
@@ -466,19 +481,23 @@ static textwindows void WriteCtl(const char *p, size_t n) {
   }
 }
 
-static textwindows void EchoTty(const char *p, size_t n) {
-  if (__ttyconf.magic & kTtyEchoRaw) {
-    WriteTty(p, n);
-  } else {
-    WriteCtl(p, n);
+textwindows void EchoConsoleNt(const char *p, size_t n, bool escape_harder) {
+  InitConsole();
+  if (!(__ttyconf.magic & kTtySilence)) {
+    if (__ttyconf.magic & kTtyEchoRaw) {
+      WriteTty(p, n);
+    } else {
+      WriteCtl(p, n, escape_harder);
+    }
   }
 }
 
-static textwindows void EraseCharacter(void) {
-  WriteTty("\b \b", 3);
+textwindows static void EraseCharacter(bool should_echo) {
+  if (should_echo)
+    WriteTty("\b \b", 3);
 }
 
-static textwindows bool EraseKeystroke(void) {
+textwindows static bool EraseKeystroke(bool should_echo) {
   struct Dll *e;
   if ((e = dll_last(__keystroke.line))) {
     struct Keystroke *k = KEYSTROKE_CONTAINER(e);
@@ -486,10 +505,9 @@ static textwindows bool EraseKeystroke(void) {
     for (int i = k->buflen; i--;) {
       if ((k->buf[i] & 0300) == 0200)
         continue;  // utf-8 cont
-      EraseCharacter();
-      if (!(__ttyconf.magic & kTtyEchoRaw) && IsCtl(k->buf[i])) {
-        EraseCharacter();
-      }
+      EraseCharacter(should_echo);
+      if (!(__ttyconf.magic & kTtyEchoRaw) && IsCtl(k->buf[i], true))
+        EraseCharacter(should_echo);
     }
     return true;
   } else {
@@ -497,42 +515,133 @@ static textwindows bool EraseKeystroke(void) {
   }
 }
 
-static textwindows void IngestConsoleInputRecord(struct NtInputRecord *r) {
+textwindows static int IsLookingAtSpace(void) {
+  struct Dll *e;
+  if ((e = dll_last(__keystroke.line))) {
+    struct Keystroke *k = KEYSTROKE_CONTAINER(e);
+    return k->buflen == 1 && isascii(k->buf[0]) && isspace(k->buf[0]);
+  } else {
+    return -1;
+  }
+}
+
+textwindows static void IngestConsoleInputRecord(struct NtInputRecord *r) {
 
   // convert win32 console event into ansi
   int len;
   char buf[23];
-  if (!(len = ConvertConsoleInputToAnsi(r, buf))) {
+  if (!(len = ConvertConsoleInputToAnsi(r, buf)))
     return;
+
+  // handle ctrl-v in canonical mode
+  // the next keystroke will bypass input processing
+  if (!(__ttyconf.magic & kTtyUncanon) &&   // ICANON
+      !(__ttyconf.magic & kTtyNoIexten)) {  // IEXTEN
+    if (__keystroke.bypass_mode) {
+      struct Keystroke *k = NewKeystroke();
+      if (!k)
+        return;
+      memcpy(k->buf, buf, sizeof(k->buf));
+      k->buflen = len;
+      dll_make_last(&__keystroke.line, &k->elem);
+      EchoConsoleNt(buf, len, true);
+      __keystroke.bypass_mode = false;
+      return;
+    } else if (len == 1 && buf[0] &&  //
+               (buf[0] & 255) == __ttyconf.vlnext) {
+      __keystroke.bypass_mode = true;
+      if (!(__ttyconf.magic & kTtySilence) &&  // ECHO
+          !(__ttyconf.magic & kTtyEchoRaw))    // ECHOCTL
+        WriteTty("^\b", 2);
+      return;
+    }
   }
 
   // handle backspace in canonical mode
   if (len == 1 && buf[0] &&                  //
       (buf[0] & 255) == __ttyconf.verase &&  //
-      !(__ttyconf.magic & kTtyUncanon)) {
-    EraseKeystroke();
+      !(__ttyconf.magic & kTtyUncanon) &&    //
+      !(__ttyconf.magic & kTtyNoIexten)) {
+    bool should_visually_erase =             //
+        !(__ttyconf.magic & kTtySilence) &&  // ECHO
+        !(__ttyconf.magic & kTtyNoEchoe);    // ECHOE
+    EraseKeystroke(should_visually_erase);
+    if (!(__ttyconf.magic & kTtySilence) &&  // ECHO
+        (__ttyconf.magic & kTtyNoEchoe) &&   // !ECHOE
+        !(__ttyconf.magic & kTtyEchoRaw))    // ECHOCTL
+      WriteCtl(buf, len, true);
+    return;
+  }
+
+  // handle ctrl-w in canonical mode
+  // this lets you erase the last word
+  if (len == 1 && buf[0] &&                   //
+      (buf[0] & 255) == __ttyconf.vwerase &&  //
+      !(__ttyconf.magic & kTtyUncanon) &&     //
+      !(__ttyconf.magic & kTtyNoIexten)) {
+    bool should_visually_erase =             //
+        !(__ttyconf.magic & kTtySilence) &&  // ECHO
+        !(__ttyconf.magic & kTtyNoEchoe);    // ECHOE
+    while (IsLookingAtSpace() == 1)
+      EraseKeystroke(should_visually_erase);
+    while (IsLookingAtSpace() == 0)
+      EraseKeystroke(should_visually_erase);
+    if (!(__ttyconf.magic & kTtySilence) &&  // ECHO
+        (__ttyconf.magic & kTtyNoEchoe) &&   // !ECHOE
+        !(__ttyconf.magic & kTtyEchoRaw))    // ECHOCTL
+      WriteCtl(buf, len, true);
     return;
   }
 
   // handle kill in canonical mode
+  // this clears the line you're editing
   if (len == 1 && buf[0] &&                 //
       (buf[0] & 255) == __ttyconf.vkill &&  //
-      !(__ttyconf.magic & kTtyUncanon)) {
-    while (EraseKeystroke()) {
+      !(__ttyconf.magic & kTtyUncanon) &&   //
+      !(__ttyconf.magic & kTtyNoIexten)) {
+    bool should_visually_kill =              //
+        !(__ttyconf.magic & kTtySilence) &&  // ECHO
+        !(__ttyconf.magic & kTtyNoEchok) &&  // ECHOK
+        !(__ttyconf.magic & kTtyNoEchoke);   // ECHOKE
+    while (EraseKeystroke(should_visually_kill)) {
+    }
+    if (!(__ttyconf.magic & kTtySilence) &&  // ECHO
+        !(__ttyconf.magic & kTtyNoEchok) &&  // ECHOK
+        (__ttyconf.magic & kTtyNoEchoke) &&  // !ECHOKE
+        !(__ttyconf.magic & kTtyEchoRaw))    // ECHOCTL
+      WriteCtl(buf, len, true);
+    return;
+  }
+
+  // handle ctrl-r in canonical mode
+  // this reprints the line you're editing
+  if (len == 1 && buf[0] &&                    //
+      (buf[0] & 255) == __ttyconf.vreprint &&  //
+      !(__ttyconf.magic & kTtyUncanon) &&      // ICANON
+      !(__ttyconf.magic & kTtyNoIexten) &&     // IEXTEN
+      !(__ttyconf.magic & kTtySilence)) {      // ECHO
+    struct Dll *e;
+    if (!(__ttyconf.magic & kTtyEchoRaw))
+      WriteCtl(buf, len, true);
+    WriteTty("\r\n", 2);
+    for (e = dll_first(__keystroke.line); e;
+         e = dll_next(__keystroke.line, e)) {
+      struct Keystroke *k = KEYSTROKE_CONTAINER(e);
+      WriteCtl(k->buf, k->buflen, true);
     }
     return;
   }
 
   // allocate object to hold keystroke
   struct Keystroke *k = NewKeystroke();
+  if (!k)
+    return;
   memcpy(k->buf, buf, sizeof(k->buf));
   k->buflen = len;
 
   // echo input if it was successfully recorded
   // assuming the win32 console isn't doing it already
-  if (!(__ttyconf.magic & kTtySilence)) {
-    EchoTty(buf, len);
-  }
+  EchoConsoleNt(buf, len, false);
 
   // save keystroke to appropriate list
   if (__ttyconf.magic & kTtyUncanon) {
@@ -540,37 +649,37 @@ static textwindows void IngestConsoleInputRecord(struct NtInputRecord *r) {
   } else {
     dll_make_last(&__keystroke.line, &k->elem);
 
-    // flush canonical mode line if oom or enter
-    if (!__keystroke.freekeys || (len == 1 && buf[0] &&
-                                  ((buf[0] & 255) == '\n' ||            //
-                                   (buf[0] & 255) == __ttyconf.veol ||  //
-                                   (buf[0] & 255) == __ttyconf.veol2))) {
+    // flush canonical mode line on enter
+    if (len == 1 && buf[0] &&
+        ((buf[0] & 255) == '\n' ||            //
+         (buf[0] & 255) == __ttyconf.veol ||  //
+         ((buf[0] & 255) == __ttyconf.veol2 &&
+          !(__ttyconf.magic & kTtyNoIexten)))) {
       dll_make_last(&__keystroke.list, __keystroke.line);
       __keystroke.line = 0;
     }
   }
 }
 
-static textwindows void IngestConsoleInput(void) {
+textwindows static void IngestConsoleInput(void) {
   uint32_t i, n;
   struct NtInputRecord records[16];
   for (;;) {
-    if (!__keystroke.freekeys)
-      return;
     if (__keystroke.end_of_file)
       return;
-    if (!GetNumberOfConsoleInputEvents(__keystroke.cin, &n)) {
+    if (!GetNumberOfConsoleInputEvents(__keystroke.cin, &n))
       goto UnexpectedEof;
-    }
+    if (n > ARRAYLEN(records))
+      n = ARRAYLEN(records);
+    PopulateKeystrokes(n + 1);
+    if (n > __keystroke.free_keys)
+      n = __keystroke.free_keys;
     if (!n)
       return;
-    n = MIN(__keystroke.freekeys, MIN(ARRAYLEN(records), n));
-    if (!ReadConsoleInput(__keystroke.cin, records, n, &n)) {
+    if (!ReadConsoleInput(__keystroke.cin, records, n, &n))
       goto UnexpectedEof;
-    }
-    for (i = 0; i < n && !__keystroke.end_of_file; ++i) {
+    for (i = 0; i < n && !__keystroke.end_of_file; ++i)
       IngestConsoleInputRecord(records + i);
-    }
   }
 UnexpectedEof:
   STRACE("console read error %d", GetLastError());
@@ -598,12 +707,10 @@ textwindows int CountConsoleInputBytes(void) {
   InitConsole();
   LockKeystrokes();
   IngestConsoleInput();
-  for (e = dll_first(__keystroke.list); e; e = dll_next(__keystroke.list, e)) {
+  for (e = dll_first(__keystroke.list); e; e = dll_next(__keystroke.list, e))
     count += KEYSTROKE_CONTAINER(e)->buflen;
-  }
-  if (!count && __keystroke.end_of_file) {
+  if (!count && __keystroke.end_of_file)
     count = -1;
-  }
   UnlockKeystrokes();
   ALLOW_SIGNALS;
   return count;
@@ -648,8 +755,14 @@ textwindows void InterceptTerminalCommands(const char *data, size_t size) {
           x = 0;
         } else if (data[i] == 'h') {
           if (x == 1) {
-            __keystroke.vkt = kDecckm;  // \e[?1h decckm on
+            // \e[?1h decckm on
             __keystroke.ohno_decckm = true;
+            kVirtualKey[0].normal_str = -S("OA");  // kNtVkUp
+            kVirtualKey[1].normal_str = -S("OB");  // kNtVkDown
+            kVirtualKey[2].normal_str = -S("OC");  // kNtVkRight
+            kVirtualKey[3].normal_str = -S("OD");  // kNtVkLeft
+            kVirtualKey[4].normal_str = -S("OF");  // kNtVkEnd
+            kVirtualKey[5].normal_str = -S("OH");  // kNtVkHome
           } else if ((ismouse |= IsMouseModeCommand(x))) {
             __ttyconf.magic |= kTtyXtMouse;
             cm2 |= kNtEnableMouseInput;
@@ -658,8 +771,14 @@ textwindows void InterceptTerminalCommands(const char *data, size_t size) {
           t = ASC;
         } else if (data[i] == 'l') {
           if (x == 1) {
-            __keystroke.vkt = kVirtualKey;  // \e[?1l decckm off
+            // \e[?1l decckm off
             __keystroke.ohno_decckm = false;
+            kVirtualKey[0].normal_str = S("A");  // kNtVkUp
+            kVirtualKey[1].normal_str = S("B");  // kNtVkDown
+            kVirtualKey[2].normal_str = S("C");  // kNtVkRight
+            kVirtualKey[3].normal_str = S("D");  // kNtVkLeft
+            kVirtualKey[4].normal_str = S("F");  // kNtVkEnd
+            kVirtualKey[5].normal_str = S("H");  // kNtVkHome
           } else if ((ismouse |= IsMouseModeCommand(x))) {
             __ttyconf.magic &= ~kTtyXtMouse;
             cm2 |= kNtEnableQuickEditMode;  // release mouse
@@ -671,12 +790,11 @@ textwindows void InterceptTerminalCommands(const char *data, size_t size) {
         __builtin_unreachable();
     }
   }
-  if (cm2 != cm) {
+  if (cm2 != cm)
     SetConsoleMode(GetConsoleInputHandle(), cm2);
-  }
 }
 
-static textwindows bool DigestConsoleInput(char *data, size_t size, int *rc) {
+textwindows static bool DigestConsoleInput(char *data, size_t size, int *rc) {
 
   // handle eof once available input is consumed
   if (dll_is_empty(__keystroke.list) && __keystroke.end_of_file) {
@@ -703,9 +821,8 @@ static textwindows bool DigestConsoleInput(char *data, size_t size, int *rc) {
     } else {
       FreeKeystroke(&__keystroke.list, e);
     }
-    if ((__ttyconf.magic & kTtyUncanon) && toto >= __ttyconf.vmin) {
+    if ((__ttyconf.magic & kTtyUncanon) && toto >= __ttyconf.vmin)
       break;
-    }
   }
 
   // return result
@@ -717,10 +834,124 @@ static textwindows bool DigestConsoleInput(char *data, size_t size, int *rc) {
   }
 }
 
-static textwindows int WaitForConsole(struct Fd *f, sigset_t waitmask) {
-  int sig;
-  int64_t sem;
-  uint32_t wi, ms = -1;
+textwindows static uint32_t DisableProcessedInput(void) {
+  // the time has come to ensure that ctrl-v ctrl-c works in icanon mode
+  // we're perfectly capable of generating a SIGINT or SIGQUIT ourselves
+  // while the cosmo termios driver is in control; so we disable windows
+  // console input processing for now; we'll turn it back on when we are
+  // done, since it's useful for ensuring asynchronous signal deliveries
+  uint32_t inmode = 0;
+  if (GetConsoleMode(__keystroke.cin, &inmode))
+    if (inmode & kNtEnableProcessedInput)
+      SetConsoleMode(__keystroke.cin, inmode & ~kNtEnableProcessedInput);
+  return inmode;
+}
+
+textwindows static void RestoreProcessedInput(uint32_t inmode) {
+  // re-enable win32 console input processing, if it was enabled when we
+  // started, and no signal handler callbacks changed things in-between.
+  if (inmode & kNtEnableProcessedInput) {
+    uint32_t inmode2;
+    if (GetConsoleMode(__keystroke.cin, &inmode2))
+      if (inmode2 == (inmode & ~kNtEnableProcessedInput))
+        SetConsoleMode(__keystroke.cin, inmode);
+  }
+}
+
+textwindows static int CountConsoleInputBytesBlockingImpl(uint32_t ms,
+                                                          sigset_t waitmask,
+                                                          bool restartable) {
+  InitConsole();
+  struct timespec deadline =
+      timespec_add(sys_clock_gettime_monotonic_nt(), timespec_frommillis(ms));
+  for (;;) {
+    int sig = 0;
+    intptr_t sev;
+    if (!(sev = CreateEvent(0, 0, 0, 0)))
+      return __winerr();
+    struct PosixThread *pt = _pthread_self();
+    pt->pt_event = sev;
+    pt->pt_blkmask = waitmask;
+    atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_EVENT,
+                          memory_order_release);
+    if (_check_cancel() == -1) {
+      atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
+      CloseHandle(sev);
+      return -1;
+    }
+    if (_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))) {
+      atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
+      CloseHandle(sev);
+      goto DeliverSignal;
+    }
+    struct timespec now = sys_clock_gettime_monotonic_nt();
+    struct timespec remain = timespec_subz(deadline, now);
+    int64_t millis = timespec_tomillis(remain);
+    uint32_t waitms = MIN(millis, 0xffffffffu);
+    intptr_t hands[] = {__keystroke.cin, sev};
+    uint32_t wi = WaitForMultipleObjects(2, hands, 0, waitms);
+    atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
+    CloseHandle(sev);
+    if (wi == -1u)
+      return __winerr();
+
+    // check for wait timeout
+    if (wi == kNtWaitTimeout)
+      return etimedout();
+
+    // handle event on console handle. this means we can now read from the
+    // conosle without blocking. so the first thing we do is slurp up your
+    // keystroke data. some of those keystrokes might cause a signal to be
+    // raised. so we need to check for pending signals again and handle it
+    if (wi == 0) {
+      int got = CountConsoleInputBytes();
+      // we might have read a keystroke that generated a signal
+      if (_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask)))
+        goto DeliverSignal;
+      if (got == -1)
+        // this is a bona fide eof and console errors are logged to strace
+        return 0;
+      if (got == 0)
+        // this can happen for multiple reasons. first our driver controls
+        // user interactions in canonical mode. secondly we could lose the
+        // race with another thread that's reading input.
+        continue;
+      return got;
+    }
+
+    if (wi == 1 && _weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))) {
+      // handle event on throwaway semaphore, it is poked by signal delivery
+    DeliverSignal:;
+      int handler_was_called = 0;
+      do {
+        handler_was_called |= _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
+      } while ((sig = _weaken(__sig_get)(waitmask)));
+      if (_check_cancel() == -1)
+        return -1;
+      if (handler_was_called & SIG_HANDLED_NO_RESTART)
+        return eintr();
+      if (handler_was_called & SIG_HANDLED_SA_RESTART)
+        if (!restartable)
+          return eintr();
+    }
+  }
+}
+
+textwindows static int CountConsoleInputBytesBlocking(uint32_t ms,
+                                                      sigset_t waitmask) {
+  int got = CountConsoleInputBytes();
+  if (got == -1)
+    return 0;
+  if (got > 0)
+    return got;
+  uint32_t inmode = DisableProcessedInput();
+  int rc = CountConsoleInputBytesBlockingImpl(ms, waitmask, true);
+  RestoreProcessedInput(inmode);
+  return rc;
+}
+
+textwindows static int WaitToReadFromConsole(struct Fd *f, sigset_t waitmask) {
+  uint32_t ms = -1;
   if (!__ttyconf.vmin) {
     if (!__ttyconf.vtime) {
       return 0;  // non-blocking w/o raising eagain
@@ -728,51 +959,32 @@ static textwindows int WaitForConsole(struct Fd *f, sigset_t waitmask) {
       ms = __ttyconf.vtime * 100;
     }
   }
-  if (_check_cancel() == -1)
-    return -1;
   if (f->flags & _O_NONBLOCK)
     return eagain();
-  if (_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))) {
-    goto DeliverSignal;
+  int olderr = errno;
+  int rc = CountConsoleInputBytesBlockingImpl(ms, waitmask, true);
+  if (rc == -1 && errno == ETIMEDOUT) {
+    // read() never raises ETIMEDOUT so if vtime elapses we raise an EOF
+    errno = olderr;
+    rc = 0;
   }
-  struct PosixThread *pt = _pthread_self();
-  pt->pt_blkmask = waitmask;
-  pt->pt_semaphore = sem = CreateSemaphore(0, 0, 1, 0);
-  atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_SEM, memory_order_release);
-  wi = WaitForMultipleObjects(2, (int64_t[2]){__keystroke.cin, sem}, 0, ms);
-  atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
-  CloseHandle(sem);
-  if (wi == kNtWaitTimeout)
-    return 0;  // vtime elapsed
-  if (wi == 0)
-    return -2;  // console data
-  if (wi != 1)
-    return __winerr();  // wait failed
-  if (_weaken(__sig_get)) {
-    if (!(sig = _weaken(__sig_get)(waitmask)))
-      return eintr();
-  DeliverSignal:
-    int handler_was_called = _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
-    if (_check_cancel() == -1)
-      return -1;
-    if (!(handler_was_called & SIG_HANDLED_NO_RESTART))
-      return -2;
-  }
-  return eintr();
+  return rc;
 }
 
-static textwindows ssize_t ReadFromConsole(struct Fd *f, void *data,
+textwindows static ssize_t ReadFromConsole(struct Fd *f, void *data,
                                            size_t size, sigset_t waitmask) {
   int rc;
   InitConsole();
+  uint32_t inmode = DisableProcessedInput();
   do {
     LockKeystrokes();
     IngestConsoleInput();
     bool done = DigestConsoleInput(data, size, &rc);
     UnlockKeystrokes();
     if (done)
-      return rc;
-  } while ((rc = WaitForConsole(f, waitmask)) == -2);
+      break;
+  } while ((rc = WaitToReadFromConsole(f, waitmask)) > 0);
+  RestoreProcessedInput(inmode);
   return rc;
 }
 
@@ -782,17 +994,16 @@ textwindows ssize_t ReadBuffer(int fd, void *data, size_t size, int64_t offset,
   // switch to terminal polyfill if reading from win32 console
   struct Fd *f = g_fds.p + fd;
 
-  if (f->kind == kFdDevNull) {
+  if (f->kind == kFdDevNull)
     return 0;
-  }
 
   if (f->kind == kFdDevRandom) {
-    return ProcessPrng(data, size) ? size : __winerr();
+    ProcessPrng(data, size);
+    return size;
   }
 
-  if (f->kind == kFdConsole) {
+  if (f->kind == kFdConsole)
     return ReadFromConsole(f, data, size, waitmask);
-  }
 
   // perform heavy lifting
   ssize_t rc;
@@ -813,7 +1024,7 @@ textwindows ssize_t ReadBuffer(int fd, void *data, size_t size, int64_t offset,
   }
 }
 
-static textwindows ssize_t ReadIovecs(int fd, const struct iovec *iov,
+textwindows static ssize_t ReadIovecs(int fd, const struct iovec *iov,
                                       size_t iovlen, int64_t opt_offset,
                                       sigset_t waitmask) {
   ssize_t rc;
diff --git a/libc/calls/read.c b/libc/calls/read.c
index af9461971..69b593652 100644
--- a/libc/calls/read.c
+++ b/libc/calls/read.c
@@ -23,7 +23,7 @@
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sock/internal.h"
diff --git a/libc/calls/readlinkat-nt.c b/libc/calls/readlinkat-nt.c
index ff9a6eca2..d70cf5583 100644
--- a/libc/calls/readlinkat-nt.c
+++ b/libc/calls/readlinkat-nt.c
@@ -18,7 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/ctype.h"
+#include "libc/intrin/strace.h"
 #include "libc/mem/alloca.h"
 #include "libc/nt/createfile.h"
 #include "libc/nt/enum/accessmask.h"
@@ -51,6 +52,7 @@ static textwindows ssize_t sys_readlinkat_nt_impl(int dirfd, const char *path,
   ssize_t rc;
 #pragma GCC push_options
 #pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
   uint32_t mem = 6000;
   volatile char *memory = alloca(mem);
   CheckLargeStackAllocation((char *)memory, mem);
@@ -118,7 +120,17 @@ static textwindows ssize_t sys_readlinkat_nt_impl(int dirfd, const char *path,
         }
         rc = j;
       } else {
-        NTTRACE("sys_readlinkat_nt() should have kNtIoReparseTagSymlink");
+        // e.g. 0xA000001D means IO_REPARSE_TAG_LX_SYMLINK
+        //
+        //     "WSL symlinks can't be opened from Windows, only from
+        //      within WSL, so if we identify them as fs.ModeSymlink,
+        //      then functions like filepath.Walk would fail when trying
+        //      to follow the link."
+        //
+        //            —Quoth Quim Muntal (dev on Go team at Microsoft)
+        //
+        // See also MSDN Learn § 2.1.2.1 Reparse Tags
+        NTTRACE("reparse tag %#x != kNtIoReparseTagSymlink", rdb->ReparseTag);
         rc = einval();
       }
     } else {
diff --git a/libc/calls/readlinkat.c b/libc/calls/readlinkat.c
index 0312fae73..a9b539cfb 100644
--- a/libc/calls/readlinkat.c
+++ b/libc/calls/readlinkat.c
@@ -19,8 +19,8 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/zipos.internal.h"
@@ -57,6 +57,7 @@ ssize_t readlinkat(int dirfd, const char *path, char *buf, size_t bufsiz) {
   } else if (_weaken(__zipos_notat) &&
              (bytes = __zipos_notat(dirfd, path)) == -1) {
     STRACE("TODO: zipos support for readlinkat");
+    bytes = einval();
   } else if (!IsWindows()) {
     bytes = sys_readlinkat(dirfd, path, buf, bufsiz);
   } else {
diff --git a/libc/calls/readv-metal.c b/libc/calls/readv-metal.c
index 6e43f431a..926d6fbc8 100644
--- a/libc/calls/readv-metal.c
+++ b/libc/calls/readv-metal.c
@@ -18,11 +18,11 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/metalfile.internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/vga/vga.internal.h"
diff --git a/libc/calls/readv-serial.c b/libc/calls/readv-serial.c
index 677e3481b..5b7976dc2 100644
--- a/libc/calls/readv-serial.c
+++ b/libc/calls/readv-serial.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/nexgen32e/uart.internal.h"
 #include "libc/runtime/pc.internal.h"
diff --git a/libc/calls/readv.c b/libc/calls/readv.c
index e885ca6de..26d05690f 100644
--- a/libc/calls/readv.c
+++ b/libc/calls/readv.c
@@ -23,9 +23,9 @@
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
 #include "libc/mem/alloca.h"
@@ -57,6 +57,7 @@ static ssize_t readv_impl(int fd, const struct iovec *iov, int iovlen) {
       struct iovec *iov2;
 #pragma GCC push_options
 #pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
       iov2 = alloca(iovlen * sizeof(struct iovec));
       CheckLargeStackAllocation(iov2, iovlen * sizeof(struct iovec));
 #pragma GCC pop_options
diff --git a/libc/calls/readwrite-nt.c b/libc/calls/readwrite-nt.c
index 530880f4b..1c983ca80 100644
--- a/libc/calls/readwrite-nt.c
+++ b/libc/calls/readwrite-nt.c
@@ -19,18 +19,21 @@
 #include "libc/calls/createfileflags.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/errno.h"
+#include "libc/intrin/fds.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/enum/filetype.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/events.h"
 #include "libc/nt/files.h"
+#include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/overlapped.h"
 #include "libc/nt/synchronization.h"
 #include "libc/nt/thread.h"
+#include "libc/sock/internal.h"
 #include "libc/stdio/sysparam.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/errfuns.h"
@@ -47,108 +50,161 @@ sys_readwrite_nt(int fd, void *data, size_t size, ssize_t offset,
                  int64_t handle, sigset_t waitmask,
                  bool32 ReadOrWriteFile(int64_t, void *, uint32_t, uint32_t *,
                                         struct NtOverlapped *)) {
-  int sig;
-  uint32_t exchanged;
   struct Fd *f = g_fds.p + fd;
 
-  // win32 i/o apis generally take 32-bit values thus we implicitly
-  // truncate outrageously large sizes. linux actually does it too!
-  size = MIN(size, 0x7ffff000);
-
   // pread() and pwrite() perform an implicit lseek() operation, so
   // similar to the lseek() system call, they too raise ESPIPE when
   // operating on a non-seekable file.
   bool pwriting = offset != -1;
-  bool seekable =
-      (f->kind == kFdFile && GetFileType(handle) == kNtFileTypeDisk) ||
-      f->kind == kFdDevNull || f->kind == kFdDevRandom;
-  if (pwriting && !seekable) {
+  bool isdisk = f->kind == kFdFile && GetFileType(handle) == kNtFileTypeDisk;
+  bool seekable = isdisk || f->kind == kFdDevNull || f->kind == kFdDevRandom;
+  if (pwriting && !seekable)
     return espipe();
-  }
 
-  // when a file is opened in overlapped mode win32 requires that we
-  // take over full responsibility for managing our own file pointer
-  // which is fine, because the one win32 has was never very good in
-  // the sense that it behaves so differently from linux, that using
-  // win32 i/o required more compatibilty toil than doing it by hand
-  if (!pwriting) {
-    if (seekable) {
-      offset = f->pointer;
-    } else {
-      offset = 0;
-    }
-  }
+  // determine if we need to lock file descriptor
+  bool locked = isdisk && !pwriting && f->cursor;
 
-RestartOperation:
-  bool eagained = false;
-  // check for signals and cancelation
-  if (_check_cancel() == -1)
-    return -1;  // ECANCELED
-  if (_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))) {
-    goto HandleInterrupt;
-  }
+  for (;;) {
+    int got_sig = 0;
+    bool got_eagain = false;
+    uint32_t other_error = 0;
 
-  // signals have already been fully blocked by caller
-  // perform i/o operation with atomic signal/cancel checking
-  struct NtOverlapped overlap = {.hEvent = CreateEvent(0, 1, 0, 0),
-                                 .Pointer = offset};
-  bool32 ok = ReadOrWriteFile(handle, data, size, 0, &overlap);
-  if (!ok && GetLastError() == kNtErrorIoPending) {
-    // win32 says this i/o operation needs to block
-    if (f->flags & _O_NONBLOCK) {
-      // abort the i/o operation if file descriptor is in non-blocking mode
-      CancelIoEx(handle, &overlap);
-      eagained = true;
-    } else {
-      // wait until i/o either completes or is canceled by another thread
-      // we avoid a race condition by having a second mask for unblocking
-      struct PosixThread *pt;
-      pt = _pthread_self();
-      pt->pt_blkmask = waitmask;
-      pt->pt_iohandle = handle;
-      pt->pt_ioverlap = &overlap;
-      atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_IO,
-                            memory_order_release);
-      WaitForSingleObject(overlap.hEvent, -1u);
-      atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
-    }
-    ok = true;
-  }
-  if (ok) {
-    ok = GetOverlappedResult(handle, &overlap, &exchanged, true);
-  }
-  CloseHandle(overlap.hEvent);
+    // create event handle for overlapped i/o
+    intptr_t event;
+    if (!(event = CreateEvent(0, 1, 0, 0)))
+      return __winerr();
 
-  // if i/o succeeded then return its result
-  if (ok) {
-    if (!pwriting && seekable) {
-      f->pointer = offset + exchanged;
-    }
-    return exchanged;
-  }
+    // ensure iops are ordered across threads and processes if seeking
+    if (locked)
+      __cursor_lock(f->cursor);
 
-  // only raise EINTR or EAGAIN if I/O got canceled
-  if (GetLastError() == kNtErrorOperationAborted) {
-    // raise EAGAIN if it's due to O_NONBLOCK mmode
-    if (eagained) {
-      return eagain();
-    }
-    // otherwise it must be due to a kill() via __sig_cancel()
-    if (_weaken(__sig_relay) && (sig = _weaken(__sig_get)(waitmask))) {
-    HandleInterrupt:
-      int handler_was_called = _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
-      if (_check_cancel() == -1)
-        return -1;  // possible if we SIGTHR'd
-      // read() is @restartable unless non-SA_RESTART hands were called
-      if (!(handler_was_called & SIG_HANDLED_NO_RESTART)) {
-        goto RestartOperation;
+    // when a file is opened in overlapped mode win32 requires that we
+    // take over full responsibility for managing our own file pointer
+    // which is fine, because the one win32 has was never very good in
+    // the sense that it behaves so differently from linux, that using
+    // win32 i/o required more compatibilty toil than doing it by hand
+    if (!pwriting) {
+      if (seekable && f->cursor) {
+        offset = f->cursor->shared->pointer;
+      } else {
+        offset = 0;
       }
     }
-    return eintr();
-  }
 
-  // read() and write() have generally different error-handling paths
-  return -2;
+    // initiate asynchronous i/o operation with win32
+    struct NtOverlapped overlap = {.hEvent = event, .Pointer = offset};
+    bool32 ok = ReadOrWriteFile(handle, data, size, 0, &overlap);
+    if (!ok && GetLastError() == kNtErrorIoPending) {
+      if (f->flags & _O_NONBLOCK) {
+        // immediately back out of blocking i/o if non-blocking
+        CancelIoEx(handle, &overlap);
+        got_eagain = true;
+      } else {
+        // atomic block on i/o completion, signal, or cancel
+        // it's not safe to acknowledge cancelation from here
+        // it's not safe to call any signal handlers from here
+        intptr_t sigev;
+        if ((sigev = CreateEvent(0, 0, 0, 0))) {
+          // installing semaphore before sig get makes wait atomic
+          struct PosixThread *pt = _pthread_self();
+          pt->pt_event = sigev;
+          pt->pt_blkmask = waitmask;
+          atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_EVENT,
+                                memory_order_release);
+          if (_is_canceled()) {
+            CancelIoEx(handle, &overlap);
+          } else if (_weaken(__sig_get) &&
+                     (got_sig = _weaken(__sig_get)(waitmask))) {
+            CancelIoEx(handle, &overlap);
+          } else {
+            intptr_t hands[] = {event, sigev};
+            uint32_t wi = WaitForMultipleObjects(2, hands, 0, -1u);
+            if (wi == 1) {  // event was signaled by signal enqueue
+              CancelIoEx(handle, &overlap);
+              if (_weaken(__sig_get))
+                got_sig = _weaken(__sig_get)(waitmask);
+            } else if (wi == -1u) {
+              other_error = GetLastError();
+              CancelIoEx(handle, &overlap);
+            }
+          }
+          atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
+          CloseHandle(sigev);
+        } else {
+          other_error = GetLastError();
+          CancelIoEx(handle, &overlap);
+        }
+      }
+      ok = true;
+    }
+    uint32_t exchanged = 0;
+    if (ok)
+      ok = GetOverlappedResult(handle, &overlap, &exchanged, true);
+    uint32_t io_error = GetLastError();
+    CloseHandle(event);
+
+    // check if i/o completed
+    // this could forseeably happen even if CancelIoEx was called
+    if (ok) {
+      if (!pwriting && seekable && f->cursor)
+        f->cursor->shared->pointer = offset + exchanged;
+      if (locked)
+        __cursor_unlock(f->cursor);
+      if (got_sig)  // swallow dequeued signal
+        _weaken(__sig_relay)(got_sig, SI_KERNEL, waitmask);
+      return exchanged;
+    }
+
+    // it's now safe to unlock cursor
+    if (locked)
+      __cursor_unlock(f->cursor);
+
+    // check if i/o failed
+    if (io_error != kNtErrorOperationAborted) {
+      if (got_sig)  // swallow dequeued signal
+        _weaken(__sig_relay)(got_sig, SI_KERNEL, waitmask);
+      // read() and write() have different error paths
+      SetLastError(io_error);
+      return -2;
+    }
+
+    // the i/o operation was successfully canceled
+    if (got_eagain)
+      return eagain();
+
+    // it's now reasonable to report semaphore creation error
+    if (other_error) {
+      errno = __dos2errno(other_error);
+      return -1;
+    }
+
+    // check for thread cancelation and acknowledge
+    if (_check_cancel() == -1)
+      return -1;
+
+    // if signal module has been linked, then
+    if (_weaken(__sig_get)) {
+
+      // gobble up all unmasked pending signals
+      // it's now safe to recurse into signal handlers
+      int handler_was_called = 0;
+      do {
+        if (got_sig)
+          handler_was_called |=
+              _weaken(__sig_relay)(got_sig, SI_KERNEL, waitmask);
+      } while ((got_sig = _weaken(__sig_get)(waitmask)));
+
+      // check if SIGTHR handler was called
+      if (_check_cancel() == -1)
+        return -1;
+
+      // check if signal handler without SA_RESTART was called
+      if (handler_was_called & SIG_HANDLED_NO_RESTART)
+        return eintr();
+    }
+
+    // otherwise try the i/o operation again
+  }
 }
 
 #endif /* __x86_64__ */
diff --git a/libc/calls/releasefd.c b/libc/calls/releasefd.c
index f6947d22d..ccf2664bd 100644
--- a/libc/calls/releasefd.c
+++ b/libc/calls/releasefd.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/intrin/atomic.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 
 // really want to avoid locking here so close() needn't block signals
diff --git a/libc/calls/renameat.c b/libc/calls/renameat.c
index 4c329abe6..821cdba4b 100644
--- a/libc/calls/renameat.c
+++ b/libc/calls/renameat.c
@@ -20,8 +20,8 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/consts/at.h"
@@ -41,6 +41,7 @@
  * @param newdirfd is normally AT_FDCWD but if it's an open directory
  *     and newpath is relative, then newpath become relative to dirfd
  * @return 0 on success, or -1 w/ errno
+ * @raise EROFS if either path is under /zip/...
  */
 int renameat(int olddirfd, const char *oldpath, int newdirfd,
              const char *newpath) {
@@ -48,7 +49,7 @@ int renameat(int olddirfd, const char *oldpath, int newdirfd,
   if (_weaken(__zipos_notat) &&
       ((rc = __zipos_notat(olddirfd, oldpath)) == -1 ||
        (rc = __zipos_notat(newdirfd, newpath)) == -1)) {
-    STRACE("zipos renameat not supported yet");
+    rc = erofs();
   } else if (!IsWindows()) {
     rc = sys_renameat(olddirfd, oldpath, newdirfd, newpath);
   } else {
diff --git a/libc/calls/rusage_add.c b/libc/calls/rusage_add.c
index 38a831aac..254b04169 100644
--- a/libc/calls/rusage_add.c
+++ b/libc/calls/rusage_add.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/rusage.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /**
  * Accumulates resource statistics in `y` to `x`.
diff --git a/libc/calls/sched_get_priority_max.c b/libc/calls/sched_get_priority_max.c
index 247fea944..89fff487f 100644
--- a/libc/calls/sched_get_priority_max.c
+++ b/libc/calls/sched_get_priority_max.c
@@ -19,8 +19,8 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/sched-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/sched.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/sched_get_priority_min.c b/libc/calls/sched_get_priority_min.c
index 80059e8d1..7d9552ec1 100644
--- a/libc/calls/sched_get_priority_min.c
+++ b/libc/calls/sched_get_priority_min.c
@@ -19,8 +19,8 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/sched-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/sched.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/sched_getcpu.c b/libc/calls/sched_getcpu.c
index 12a0a832b..e671e80ca 100644
--- a/libc/calls/sched_getcpu.c
+++ b/libc/calls/sched_getcpu.c
@@ -23,32 +23,82 @@
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/nt/struct/processornumber.h"
 #include "libc/nt/synchronization.h"
+#include "libc/runtime/syslib.internal.h"
 #include "libc/sysv/errfuns.h"
 
 int sys_getcpu(unsigned *opt_cpu, unsigned *opt_node, void *tcache);
 
 /**
  * Returns ID of CPU on which thread is currently scheduled.
+ *
+ * This function is supported on the following platforms:
+ *
+ * - x86-64
+ *
+ *   - Linux: rdtsc
+ *   - FreeBSD: rdtsc
+ *   - Windows: win32
+ *   - OpenBSD: unsupported
+ *   - NetBSD: unsupported
+ *   - MacOS: unsupported
+ *
+ * - aarch64
+ *
+ *   - Linux: syscall
+ *   - FreeBSD: syscall
+ *   - MacOS: supported
+ *
  * @return cpu number on success, or -1 w/ errno
  */
 int sched_getcpu(void) {
-  if (X86_HAVE(RDTSCP)) {
-    unsigned tsc_aux;
-    rdtscp(&tsc_aux);
-    return TSC_AUX_CORE(tsc_aux);
-  } else if (IsAarch64()) {
-    long tpidr_el0;
-    asm("mrs\t%0,tpidr_el0" : "=r"(tpidr_el0));
-    return tpidr_el0 & 255;
-  } else if (IsWindows()) {
+
+  if (IsWindows()) {
     struct NtProcessorNumber pn;
     GetCurrentProcessorNumberEx(&pn);
     return 64 * pn.Group + pn.Number;
-  } else {
-    unsigned cpu = 0;
-    int rc = sys_getcpu(&cpu, 0, 0);
-    if (rc == -1)
-      return -1;
-    return cpu;
   }
+
+#ifdef __x86_64__
+  if (X86_HAVE(RDTSCP) && (IsLinux() || IsFreebsd())) {
+    // Only the Linux, FreeBSD, and Windows kernels can be counted upon
+    // to populate the TSC_AUX register with the current thread number.
+    unsigned tsc_aux;
+    rdtscp(&tsc_aux);
+    return TSC_AUX_CORE(tsc_aux);
+  }
+#endif
+
+#ifdef __aarch64__
+  if (IsXnu()) {
+    // pthread_cpu_number_np() is defined by MacOS 11.0+ (Big Sur) in
+    // the SDK pthread.h header file, even though there's no man page
+    if (__syslib && __syslib->__version >= 9) {
+      errno_t err;
+      size_t out = 0;
+      if ((err = __syslib->__pthread_cpu_number_np(&out))) {
+        errno = err;
+        return -1;
+      }
+      return out;
+    } else {
+      errno = ENOSYS;  // upgrade your ape loader
+      return -1;       // cc -o /usr/local/bin/ape ape/ape-m1.c
+    }
+  }
+#endif
+
+#ifdef __aarch64__
+  if (IsFreebsd()) {
+    register int x0 asm("x0");
+    register int x8 asm("x8") = 581;  // sched_getcpu
+    asm volatile("svc\t0" : "=r"(x0) : "r"(x8) : "memory");
+    return x0;
+  }
+#endif
+
+  unsigned cpu = 0;
+  int rc = sys_getcpu(&cpu, 0, 0);
+  if (rc == -1)
+    return -1;
+  return cpu;
 }
diff --git a/libc/calls/sched_getparam.c b/libc/calls/sched_getparam.c
index 0b5a9705f..98699211d 100644
--- a/libc/calls/sched_getparam.c
+++ b/libc/calls/sched_getparam.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/sched_param.h"
 #include "libc/calls/struct/sched_param.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/sched_getscheduler.c b/libc/calls/sched_getscheduler.c
index fe6e39f25..fafe9fdd3 100644
--- a/libc/calls/sched_getscheduler.c
+++ b/libc/calls/sched_getscheduler.c
@@ -19,8 +19,8 @@
 #include "libc/calls/sched-sysv.internal.h"
 #include "libc/calls/struct/sched_param.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Gets scheduler policy for `pid`.
@@ -31,7 +31,6 @@
  *     special; the kernel treats this as a thread id (noting that
  *     `getpid() == gettid()` is always the case on Linux for the main
  *     thread) and will only take effect for the specified tid.
- *     Therefore this function is POSIX-compliant iif `!__threaded`.
  * @return scheduler policy, or -1 w/ errno
  * @error ESRCH if `pid` not found
  * @error EPERM if not permitted
diff --git a/libc/calls/sched_rr_get_interval.c b/libc/calls/sched_rr_get_interval.c
index 6e1c43001..15881ceab 100644
--- a/libc/calls/sched_rr_get_interval.c
+++ b/libc/calls/sched_rr_get_interval.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/timespec.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 
 int sys_sched_rr_get_interval(int, struct timespec *);
 
diff --git a/libc/calls/sched_setparam.c b/libc/calls/sched_setparam.c
index 4fae3cbbd..10b64bd66 100644
--- a/libc/calls/sched_setparam.c
+++ b/libc/calls/sched_setparam.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/sched_param.h"
 #include "libc/calls/struct/sched_param.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/sched_setscheduler.c b/libc/calls/sched_setscheduler.c
index 80a48e95a..5f4839846 100644
--- a/libc/calls/sched_setscheduler.c
+++ b/libc/calls/sched_setscheduler.c
@@ -20,8 +20,8 @@
 #include "libc/calls/struct/sched_param.h"
 #include "libc/calls/struct/sched_param.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/tls.h"
@@ -41,7 +41,6 @@
  *     special; the kernel treats this as a thread id (noting that
  *     `getpid() == gettid()` is always the case on Linux for the main
  *     thread) and will only take effect for the specified tid.
- *     Therefore this function is POSIX-compliant iif `!__threaded`.
  *
  * @param policy specifies the kernel's timesharing strategy.
  *
diff --git a/libc/calls/seccomp.c b/libc/calls/seccomp.c
index eaa1e4708..1d004fe2d 100644
--- a/libc/calls/seccomp.c
+++ b/libc/calls/seccomp.c
@@ -21,8 +21,8 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/pr.h"
 #include "libc/sysv/errfuns.h"
 
@@ -82,7 +82,7 @@ int seccomp(unsigned operation, unsigned flags, void *args) {
   } else {
     rc = enosys();
   }
-  STRACE("seccomp(%s, %#x, %p) → %d% m", DescribeSeccompOperation(operation),
+  STRACE("seccomp(%s, %#x, %p) → %d% m", _DescribeSeccompOperation(operation),
          flags, args, rc);
   return rc;
 }
diff --git a/libc/calls/sedebug.c b/libc/calls/sedebug.c
index 64c4ac52d..eed940e25 100644
--- a/libc/calls/sedebug.c
+++ b/libc/calls/sedebug.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/accessmask.h"
 #include "libc/nt/enum/securityimpersonationlevel.h"
 #include "libc/nt/errors.h"
diff --git a/libc/calls/select-nt.c b/libc/calls/select-nt.c
index 8245f9f32..0d9e2f2e0 100644
--- a/libc/calls/select-nt.c
+++ b/libc/calls/select-nt.c
@@ -16,65 +16,60 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
 #include "libc/calls/struct/timeval.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sock/select.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/pollfd.h"
 #include "libc/sock/struct/pollfd.internal.h"
-#include "libc/stdckdint.h"
 #include "libc/sysv/consts/poll.h"
 #include "libc/sysv/errfuns.h"
 #ifdef __x86_64__
 
+// <sync libc/sysv/consts.sh>
+#define POLLERR_    0x0001  // implied in events
+#define POLLHUP_    0x0002  // implied in events
+#define POLLNVAL_   0x0004  // implied in events
+#define POLLIN_     0x0300
+#define POLLRDNORM_ 0x0100
+#define POLLRDBAND_ 0x0200
+#define POLLOUT_    0x0010
+#define POLLWRNORM_ 0x0010
+#define POLLWRBAND_ 0x0020  // MSDN undocumented
+#define POLLPRI_    0x0400  // MSDN unsupported
+// </sync libc/sysv/consts.sh>
+
 int sys_select_nt(int nfds, fd_set *readfds, fd_set *writefds,
-                  fd_set *exceptfds, struct timeval *timeout,
+                  fd_set *exceptfds, const struct timespec *timeout,
                   const sigset_t *sigmask) {
-  int i, pfds, events, fdcount;
+  int pfds = 0;
 
   // convert bitsets to pollfd
-  struct pollfd fds[64];
-  for (pfds = i = 0; i < nfds; ++i) {
-    events = 0;
-    if (readfds && FD_ISSET(i, readfds))
-      events |= POLLIN;
-    if (writefds && FD_ISSET(i, writefds))
-      events |= POLLOUT;
-    if (exceptfds && FD_ISSET(i, exceptfds))
-      events |= POLLERR;
+  struct pollfd fds[128];
+  for (int fd = 0; fd < nfds; ++fd) {
+    int events = 0;
+    if (readfds && FD_ISSET(fd, readfds))
+      events |= POLLIN_;
+    if (writefds && FD_ISSET(fd, writefds))
+      events |= POLLOUT_;
+    if (exceptfds && FD_ISSET(fd, exceptfds))
+      events |= POLLPRI_;
     if (events) {
-      if (pfds < ARRAYLEN(fds)) {
-        fds[pfds].fd = i;
-        fds[pfds].events = events;
-        fds[pfds].revents = 0;
-        pfds += 1;
-      } else {
-        return enomem();
-      }
-    }
-  }
-
-  // convert the wait time to a word
-  uint32_t millis;
-  if (!timeout) {
-    millis = -1;
-  } else {
-    int64_t ms = timeval_tomillis(*timeout);
-    if (ms < 0 || ms > UINT32_MAX) {
-      millis = -1u;
-    } else {
-      millis = ms;
+      if (pfds == ARRAYLEN(fds))
+        return e2big();
+      fds[pfds].fd = fd;
+      fds[pfds].events = events;
+      fds[pfds].revents = 0;
+      ++pfds;
     }
   }
 
   // call our nt poll implementation
-  fdcount = sys_poll_nt(fds, pfds, &millis, sigmask);
-  unassert(fdcount < 64);
-  if (fdcount < 0)
+  int fdcount = sys_poll_nt(fds, pfds, timeout, sigmask);
+  if (fdcount == -1)
     return -1;
 
   // convert pollfd back to bitsets
@@ -85,20 +80,20 @@ int sys_select_nt(int nfds, fd_set *readfds, fd_set *writefds,
   if (exceptfds)
     FD_ZERO(exceptfds);
   int bits = 0;
-  for (i = 0; i < pfds; ++i) {
-    if (fds[i].revents & POLLIN) {
+  for (int i = 0; i < pfds; ++i) {
+    if (fds[i].revents & (POLLIN_ | POLLHUP_ | POLLERR_ | POLLNVAL_)) {
       if (readfds) {
         FD_SET(fds[i].fd, readfds);
         ++bits;
       }
     }
-    if (fds[i].revents & POLLOUT) {
+    if (fds[i].revents & POLLOUT_) {
       if (writefds) {
         FD_SET(fds[i].fd, writefds);
         ++bits;
       }
     }
-    if (fds[i].revents & (POLLERR | POLLNVAL)) {
+    if (fds[i].revents & POLLPRI_) {
       if (exceptfds) {
         FD_SET(fds[i].fd, exceptfds);
         ++bits;
@@ -106,11 +101,6 @@ int sys_select_nt(int nfds, fd_set *readfds, fd_set *writefds,
     }
   }
 
-  // store remaining time back in caller's timeval
-  if (timeout) {
-    *timeout = timeval_frommillis(millis);
-  }
-
   return bits;
 }
 
diff --git a/libc/calls/select.c b/libc/calls/select.c
index d517eb4ea..93704b269 100644
--- a/libc/calls/select.c
+++ b/libc/calls/select.c
@@ -17,26 +17,22 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/sock/select.h"
-#include "libc/calls/cp.internal.h"
-#include "libc/calls/struct/itimerval.internal.h"
-#include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timeval.h"
-#include "libc/calls/struct/timeval.internal.h"
-#include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/sock/internal.h"
-#include "libc/sock/select.h"
-#include "libc/sock/select.internal.h"
-#include "libc/sysv/errfuns.h"
 
 /**
- * Does what poll() does except with bitset API.
- *
- * This system call is supported on all platforms. However, on Windows,
- * this is polyfilled to translate into poll(). So it's recommended that
- * poll() be used instead.
+ * Checks status on multiple file descriptors at once.
  *
+ * @param readfds may be used to be notified when you can call read() on
+ *     a file descriptor without it blocking; this includes when data is
+ *     is available to be read as well as eof and error conditions
+ * @param writefds may be used to be notified when write() may be called
+ *     on a file descriptor without it blocking
+ * @param exceptfds may be used to be notified of exceptional conditions
+ *     such as out-of-band data on a socket; it is equivalent to POLLPRI
+ *     in the revents of poll()
+ * @param timeout may be null which means to block indefinitely; cosmo's
+ *     implementation of select() never modifies this parameter
+ * @raise E2BIG if we exceeded the 64 socket limit on Windows
  * @raise ECANCELED if thread was cancelled in masked mode
  * @raise EINTR if signal was delivered
  * @cancelationpoint
@@ -45,70 +41,13 @@
  */
 int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
            struct timeval *timeout) {
-
-  int rc;
-  fd_set old_readfds;
-  fd_set *old_readfds_ptr = 0;
-  fd_set old_writefds;
-  fd_set *old_writefds_ptr = 0;
-  fd_set old_exceptfds;
-  fd_set *old_exceptfds_ptr = 0;
-  struct timeval old_timeout;
-  struct timeval *old_timeout_ptr = 0;
-
-  POLLTRACE("select(%d, %p, %p, %p, %s) → ...", nfds, readfds, writefds,
-            exceptfds, DescribeTimeval(0, timeout));
-
-  BEGIN_CANCELATION_POINT;
-  if (nfds < 0) {
-    rc = einval();
+  struct timespec ts;
+  struct timespec *tsp;
+  if (timeout) {
+    ts = timeval_totimespec(*timeout);
+    tsp = &ts;
   } else {
-    if (readfds) {
-      old_readfds = *readfds;
-      old_readfds_ptr = &old_readfds;
-    }
-    if (writefds) {
-      old_writefds = *writefds;
-      old_writefds_ptr = &old_writefds;
-    }
-    if (exceptfds) {
-      old_exceptfds = *exceptfds;
-      old_exceptfds_ptr = &old_exceptfds;
-    }
-    if (timeout) {
-      old_timeout = *timeout;
-      old_timeout_ptr = &old_timeout;
-    }
-    if (!IsWindows()) {
-#ifdef __aarch64__
-      struct timespec ts, *tsp;
-      if (timeout) {
-        ts = timeval_totimespec(*timeout);
-        tsp = &ts;
-      } else {
-        tsp = 0;
-      }
-      rc = sys_pselect(nfds, readfds, writefds, exceptfds, tsp, 0);
-      if (timeout) {
-        *timeout = timespec_totimeval(ts);
-      }
-#else
-      rc = sys_select(nfds, readfds, writefds, exceptfds, timeout);
-#endif
-    } else {
-      rc = sys_select_nt(nfds, readfds, writefds, exceptfds, timeout, 0);
-    }
+    tsp = 0;
   }
-  END_CANCELATION_POINT;
-
-  STRACE("select(%d, %s → [%s], %s → [%s], %s → [%s], %s → [%s]) → %d% m", nfds,
-         DescribeFdSet(rc, nfds, old_readfds_ptr),
-         DescribeFdSet(rc, nfds, readfds),
-         DescribeFdSet(rc, nfds, old_writefds_ptr),
-         DescribeFdSet(rc, nfds, writefds),
-         DescribeFdSet(rc, nfds, old_exceptfds_ptr),
-         DescribeFdSet(rc, nfds, exceptfds),    //
-         DescribeTimeval(rc, old_timeout_ptr),  //
-         DescribeTimeval(rc, timeout), rc);
-  return rc;
+  return pselect(nfds, readfds, writefds, exceptfds, tsp, 0);
 }
diff --git a/libc/calls/setegid.c b/libc/calls/setegid.c
index 3d6edd902..fd6dba78e 100644
--- a/libc/calls/setegid.c
+++ b/libc/calls/setegid.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets effective group ID.
diff --git a/libc/calls/seteuid.c b/libc/calls/seteuid.c
index 995c7cccb..7bbb79ffb 100644
--- a/libc/calls/seteuid.c
+++ b/libc/calls/seteuid.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets effective user ID.
diff --git a/libc/calls/setfl.c b/libc/calls/setfl.c
index 553179598..e96137862 100644
--- a/libc/calls/setfl.c
+++ b/libc/calls/setfl.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/createfileflags.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/nt/createfile.h"
 #include "libc/nt/enum/fileflagandattributes.h"
diff --git a/libc/calls/setfsgid.c b/libc/calls/setfsgid.c
index 5deee2daa..f69a32187 100644
--- a/libc/calls/setfsgid.c
+++ b/libc/calls/setfsgid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets user id of current process for file system ops.
diff --git a/libc/calls/setfsuid.c b/libc/calls/setfsuid.c
index 62b7c6c79..d992e53e2 100644
--- a/libc/calls/setfsuid.c
+++ b/libc/calls/setfsuid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets user id of current process for file system ops.
diff --git a/libc/calls/setgid.c b/libc/calls/setgid.c
index 44a55c5ad..5a1208a83 100644
--- a/libc/calls/setgid.c
+++ b/libc/calls/setgid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets group id of current process.
diff --git a/libc/calls/setgroups.c b/libc/calls/setgroups.c
index 0c12a106b..534f5962a 100644
--- a/libc/calls/setgroups.c
+++ b/libc/calls/setgroups.c
@@ -19,9 +19,8 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/groups.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/stdckdint.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/setpgid.c b/libc/calls/setpgid.c
index c883c2e6a..26980b4f9 100644
--- a/libc/calls/setpgid.c
+++ b/libc/calls/setpgid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Changes process group for process.
diff --git a/libc/calls/setregid.c b/libc/calls/setregid.c
index 03367acb1..859db8bea 100644
--- a/libc/calls/setregid.c
+++ b/libc/calls/setregid.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets real and/or effective group ids.
diff --git a/libc/calls/setresgid.c b/libc/calls/setresgid.c
index e8310cc1a..bf27e7f9b 100644
--- a/libc/calls/setresgid.c
+++ b/libc/calls/setresgid.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets real, effective, and "saved" group ids.
diff --git a/libc/calls/setresuid.c b/libc/calls/setresuid.c
index eaa95f1a9..c6ae50caa 100644
--- a/libc/calls/setresuid.c
+++ b/libc/calls/setresuid.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets real, effective, and "saved" user ids.
diff --git a/libc/calls/setreuid.c b/libc/calls/setreuid.c
index f01680988..0b7149ba7 100644
--- a/libc/calls/setreuid.c
+++ b/libc/calls/setreuid.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets real and/or effective user ids.
diff --git a/libc/calls/setrlimit.c b/libc/calls/setrlimit.c
index 96112a096..0a2b12ffa 100644
--- a/libc/calls/setrlimit.c
+++ b/libc/calls/setrlimit.c
@@ -21,9 +21,11 @@
 #include "libc/calls/struct/rlimit.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/errno.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/rlimit.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/syslib.internal.h"
 #include "libc/sysv/consts/rlimit.h"
@@ -77,26 +79,27 @@
  */
 int setrlimit(int resource, const struct rlimit *rlim) {
   int rc;
+  int olde = errno;
   if (resource == 127) {
     rc = einval();
   } else if (!rlim) {
     rc = efault();
   } else if (IsXnuSilicon()) {
     rc = _sysret(__syslib->__setrlimit(resource, rlim));
-  } else if (!IsWindows()) {
+  } else if (!IsWindows() && !(IsNetbsd() && resource == RLIMIT_AS)) {
     rc = sys_setrlimit(resource, rlim);
-    if (IsXnu() && !rc && resource == RLIMIT_AS) {
-      // TODO(jart): What's up with XNU and NetBSD?
-      __virtualmax = rlim->rlim_cur;
-    }
   } else if (resource == RLIMIT_STACK) {
-    rc = enotsup();
-  } else if (resource == RLIMIT_AS) {
-    __virtualmax = rlim->rlim_cur;
     rc = 0;
   } else {
     rc = einval();
   }
+  if (!rc && resource == RLIMIT_STACK)
+    __rlimit_stack_set(*rlim);  // so __rlimit_stack_get() works on all OSes
+  if (resource == RLIMIT_AS) {
+    __virtualmax = rlim->rlim_cur;
+    errno = olde;
+    rc = 0;
+  }
   STRACE("setrlimit(%s, %s) → %d% m", DescribeRlimitName(resource),
          DescribeRlimit(0, rlim), rc);
   return rc;
diff --git a/libc/calls/setsid.c b/libc/calls/setsid.c
index 026f97b3c..efd10aef7 100644
--- a/libc/calls/setsid.c
+++ b/libc/calls/setsid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Creates session and sets the process group id.
diff --git a/libc/calls/settimeofday.c b/libc/calls/settimeofday.c
index f0774746d..e35ba6e01 100644
--- a/libc/calls/settimeofday.c
+++ b/libc/calls/settimeofday.c
@@ -19,7 +19,7 @@
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/struct/timeval.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/time.h"
 
diff --git a/libc/calls/setuid.c b/libc/calls/setuid.c
index f9e922906..5d22f24ef 100644
--- a/libc/calls/setuid.c
+++ b/libc/calls/setuid.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets user id of current process.
diff --git a/libc/calls/shm_path_np.c b/libc/calls/shm_path_np.c
index 42df957c4..dc5813b8a 100644
--- a/libc/calls/shm_path_np.c
+++ b/libc/calls/shm_path_np.c
@@ -35,9 +35,8 @@ void shm_path_np(const char *name, char buf[hasatleast 78]) {
   const char *a;
   uint8_t digest[BLAKE2B256_DIGEST_LENGTH];
   a = "/tmp/", n = 5;
-  if (IsLinux() && isdirectory("/dev/shm")) {
+  if (IsLinux() && isdirectory("/dev/shm"))
     a = "/dev/shm/", n = 9;
-  }
   BLAKE2B256(name, strlen(name), digest);
   p = mempcpy(buf, a, n);
   p = hexpcpy(p, digest, BLAKE2B256_DIGEST_LENGTH);
diff --git a/libc/calls/sig.c b/libc/calls/sig.c
deleted file mode 100644
index c1ce797fb..000000000
--- a/libc/calls/sig.c
+++ /dev/null
@@ -1,633 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/sysv/consts/sig.h"
-#include "ape/sections.internal.h"
-#include "libc/calls/calls.h"
-#include "libc/calls/sig.internal.h"
-#include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigaction.h"
-#include "libc/calls/struct/siginfo.h"
-#include "libc/calls/struct/sigset.internal.h"
-#include "libc/calls/struct/ucontext.internal.h"
-#include "libc/calls/ucontext.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/intrin/atomic.h"
-#include "libc/intrin/bsf.h"
-#include "libc/intrin/describebacktrace.internal.h"
-#include "libc/intrin/dll.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/intrin/weaken.h"
-#include "libc/nt/console.h"
-#include "libc/nt/enum/context.h"
-#include "libc/nt/enum/exceptionhandleractions.h"
-#include "libc/nt/enum/signal.h"
-#include "libc/nt/enum/status.h"
-#include "libc/nt/runtime.h"
-#include "libc/nt/signals.h"
-#include "libc/nt/struct/ntexceptionpointers.h"
-#include "libc/nt/synchronization.h"
-#include "libc/nt/thread.h"
-#include "libc/runtime/symbols.internal.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/sa.h"
-#include "libc/sysv/consts/sicode.h"
-#include "libc/sysv/consts/ss.h"
-#include "libc/thread/posixthread.internal.h"
-#ifdef __x86_64__
-
-/**
- * @fileoverview Cosmopolitan Signals for Windows.
- */
-
-struct SignalFrame {
-  unsigned rva;
-  unsigned flags;
-  siginfo_t si;
-  ucontext_t ctx;
-};
-
-static textwindows bool __sig_ignored_by_default(int sig) {
-  return sig == SIGURG ||   //
-         sig == SIGCONT ||  //
-         sig == SIGCHLD ||  //
-         sig == SIGWINCH;
-}
-
-textwindows bool __sig_ignored(int sig) {
-  return __sighandrvas[sig] == (intptr_t)SIG_IGN ||
-         (__sighandrvas[sig] == (intptr_t)SIG_DFL &&
-          __sig_ignored_by_default(sig));
-}
-
-textwindows void __sig_delete(int sig) {
-  struct Dll *e;
-  atomic_fetch_and_explicit(&__sig.pending, ~(1ull << (sig - 1)),
-                            memory_order_relaxed);
-  BLOCK_SIGNALS;
-  _pthread_lock();
-  for (e = dll_last(_pthread_list); e; e = dll_prev(_pthread_list, e)) {
-    atomic_fetch_and_explicit(&POSIXTHREAD_CONTAINER(e)->tib->tib_sigpending,
-                              ~(1ull << (sig - 1)), memory_order_relaxed);
-  }
-  _pthread_unlock();
-  ALLOW_SIGNALS;
-}
-
-static textwindows int __sig_getter(atomic_ulong *sigs, sigset_t masked) {
-  int sig;
-  sigset_t bit, pending, deliverable;
-  for (;;) {
-    pending = atomic_load_explicit(sigs, memory_order_acquire);
-    if ((deliverable = pending & ~masked)) {
-      sig = bsfl(deliverable) + 1;
-      bit = 1ull << (sig - 1);
-      if (atomic_fetch_and_explicit(sigs, ~bit, memory_order_acq_rel) & bit) {
-        return sig;
-      }
-    } else {
-      return 0;
-    }
-  }
-}
-
-textwindows int __sig_get(sigset_t masked) {
-  int sig;
-  if (!(sig = __sig_getter(&__get_tls()->tib_sigpending, masked))) {
-    sig = __sig_getter(&__sig.pending, masked);
-  }
-  return sig;
-}
-
-static textwindows bool __sig_should_use_altstack(unsigned flags,
-                                                  struct CosmoTib *tib) {
-  if (!(flags & SA_ONSTACK)) {
-    return false;  // signal handler didn't enable it
-  }
-  if (!tib->tib_sigstack_size) {
-    return false;  // sigaltstack() wasn't installed on this thread
-  }
-  if (tib->tib_sigstack_flags & SS_DISABLE) {
-    return false;  // sigaltstack() on this thread was disabled by user
-  }
-  char *bp = __builtin_frame_address(0);
-  if (tib->tib_sigstack_addr <= bp &&
-      bp <= tib->tib_sigstack_addr + tib->tib_sigstack_size) {
-    return false;  // we're already on the alternate stack
-  }
-  return true;
-}
-
-static textwindows wontreturn void __sig_terminate(int sig) {
-  TerminateThisProcess(sig);
-}
-
-static textwindows bool __sig_start(struct PosixThread *pt, int sig,
-                                    unsigned *rva, unsigned *flags) {
-  *rva = __sighandrvas[sig];
-  *flags = __sighandflags[sig];
-  if (*rva == (intptr_t)SIG_IGN ||
-      (*rva == (intptr_t)SIG_DFL && __sig_ignored_by_default(sig))) {
-    STRACE("ignoring %G", sig);
-    return false;
-  }
-  if (atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
-      (1ull << (sig - 1))) {
-    STRACE("enqueing %G on %d", sig, _pthread_tid(pt));
-    atomic_fetch_or_explicit(&pt->tib->tib_sigpending, 1ull << (sig - 1),
-                             memory_order_relaxed);
-    return false;
-  }
-  if (*rva == (intptr_t)SIG_DFL) {
-    STRACE("terminating on %G due to no handler", sig);
-    __sig_terminate(sig);
-  }
-  return true;
-}
-
-static textwindows sigaction_f __sig_handler(unsigned rva) {
-  atomic_fetch_add_explicit(&__sig.count, 1, memory_order_relaxed);
-  return (sigaction_f)(__executable_start + rva);
-}
-
-textwindows int __sig_raise(volatile int sig, int sic) {
-
-  // bitset of kinds of handlers called
-  volatile int handler_was_called = 0;
-
-  // loop over pending signals
-  ucontext_t ctx;
-  getcontext(&ctx);
-  if (!sig) {
-    if ((sig = __sig_get(ctx.uc_sigmask))) {
-      sic = SI_KERNEL;
-    } else {
-      return handler_was_called;
-    }
-  }
-
-  // process signal(s)
-  unsigned rva, flags;
-  struct PosixThread *pt = _pthread_self();
-  if (__sig_start(pt, sig, &rva, &flags)) {
-    if (flags & SA_RESETHAND) {
-      STRACE("resetting %G handler", sig);
-      __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
-    }
-
-    // update the signal mask in preparation for signal handller
-    sigset_t blocksigs = __sighandmask[sig];
-    if (!(flags & SA_NODEFER))
-      blocksigs |= 1ull << (sig - 1);
-    ctx.uc_sigmask = atomic_fetch_or_explicit(&pt->tib->tib_sigmask, blocksigs,
-                                              memory_order_acquire);
-
-    // call the user's signal handler
-    char ssbuf[128];
-    siginfo_t si = {.si_signo = sig, .si_code = sic};
-    STRACE("__sig_raise(%G, %t) mask %s", sig, __sig_handler(rva),
-           (DescribeSigset)(ssbuf, 0, (sigset_t *)&pt->tib->tib_sigmask));
-    __sig_handler(rva)(sig, &si, &ctx);
-
-    // record this handler
-    if (flags & SA_RESTART) {
-      handler_was_called |= SIG_HANDLED_SA_RESTART;
-    } else {
-      handler_was_called |= SIG_HANDLED_NO_RESTART;
-    }
-  }
-
-  // restore sigmask
-  // loop back to top
-  // jump where handler says
-  sig = 0;
-  return setcontext(&ctx);
-}
-
-textwindows int __sig_relay(int sig, int sic, sigset_t waitmask) {
-  sigset_t m;
-  int handler_was_called;
-  m = atomic_exchange_explicit(&__get_tls()->tib_sigmask, waitmask,
-                               memory_order_acquire);
-  handler_was_called = __sig_raise(sig, SI_KERNEL);
-  atomic_store_explicit(&__get_tls()->tib_sigmask, m, memory_order_release);
-  return handler_was_called;
-}
-
-// cancels blocking operations being performed by signaled thread
-textwindows void __sig_cancel(struct PosixThread *pt, int sig, unsigned flags) {
-  atomic_int *blocker;
-  blocker = atomic_load_explicit(&pt->pt_blocker, memory_order_acquire);
-  if (!blocker) {
-    STRACE("%G sent to %d asynchronously", sig, _pthread_tid(pt));
-    return;
-  }
-  // we can cancel another thread's overlapped i/o op after the freeze
-  if (blocker == PT_BLOCKER_IO) {
-    STRACE("%G canceling %d's i/o", sig, _pthread_tid(pt));
-    CancelIoEx(pt->pt_iohandle, pt->pt_ioverlap);
-    return;
-  }
-  // threads can create semaphores on an as-needed basis
-  if (blocker == PT_BLOCKER_SEM) {
-    STRACE("%G releasing %d's semaphore", sig, _pthread_tid(pt));
-    ReleaseSemaphore(pt->pt_semaphore, 1, 0);
-    return;
-  }
-  // all other blocking ops that aren't overlap should use futexes
-  // we force restartable futexes to churn by waking w/o releasing
-  STRACE("%G waking %d's futex", sig, _pthread_tid(pt));
-  WakeByAddressSingle(blocker);
-}
-
-// the user's signal handler callback is wrapped with this trampoline
-static textwindows wontreturn void __sig_tramp(struct SignalFrame *sf) {
-  int sig = sf->si.si_signo;
-  struct CosmoTib *tib = __get_tls();
-  struct PosixThread *pt = (struct PosixThread *)tib->tib_pthread;
-  for (;;) {
-
-    // update the signal mask in preparation for signal handller
-    sigset_t blocksigs = __sighandmask[sig];
-    if (!(sf->flags & SA_NODEFER))
-      blocksigs |= 1ull << (sig - 1);
-    sf->ctx.uc_sigmask = atomic_fetch_or_explicit(&tib->tib_sigmask, blocksigs,
-                                                  memory_order_acquire);
-
-    // call the user's signal handler
-    char ssbuf[2][128];
-    STRACE("__sig_tramp(%G, %t) mask %s → %s", sig, __sig_handler(sf->rva),
-           (DescribeSigset)(ssbuf[0], 0, &sf->ctx.uc_sigmask),
-           (DescribeSigset)(ssbuf[1], 0, (sigset_t *)&tib->tib_sigmask));
-    __sig_handler(sf->rva)(sig, &sf->si, &sf->ctx);
-
-    // restore the signal mask that was used by the interrupted code
-    // this may have been modified by the signal handler in the callback
-    atomic_store_explicit(&tib->tib_sigmask, sf->ctx.uc_sigmask,
-                          memory_order_release);
-
-    // jump back into original code if there aren't any pending signals
-    do {
-      if (!(sig = __sig_get(sf->ctx.uc_sigmask))) {
-        __sig_restore(&sf->ctx);
-      }
-    } while (!__sig_start(pt, sig, &sf->rva, &sf->flags));
-
-    // tail recurse into another signal handler
-    sf->si.si_signo = sig;
-    sf->si.si_code = SI_KERNEL;
-    if (sf->flags & SA_RESETHAND) {
-      STRACE("resetting %G handler", sig);
-      __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
-    }
-  }
-}
-
-// sends signal to another specific thread which is ref'd
-static textwindows int __sig_killer(struct PosixThread *pt, int sig, int sic) {
-  unsigned rva = __sighandrvas[sig];
-  unsigned flags = __sighandflags[sig];
-
-  // do nothing if signal is ignored
-  if (rva == (intptr_t)SIG_IGN ||
-      (rva == (intptr_t)SIG_DFL && __sig_ignored_by_default(sig))) {
-    STRACE("ignoring %G", sig);
-    return 0;
-  }
-
-  // if there's no handler then killing a thread kills the process
-  if (rva == (intptr_t)SIG_DFL) {
-    STRACE("terminating on %G due to no handler", sig);
-    __sig_terminate(sig);
-  }
-
-  // ignore signals already pending
-  uintptr_t th = _pthread_syshand(pt);
-  if (atomic_load_explicit(&pt->tib->tib_sigpending, memory_order_acquire) &
-      (1ull << (sig - 1))) {
-    return 0;
-  }
-
-  // take control of thread
-  // suspending the thread happens asynchronously
-  // however getting the context blocks until it's frozen
-  static pthread_spinlock_t killer_lock;
-  pthread_spin_lock(&killer_lock);
-  if (SuspendThread(th) == -1u) {
-    STRACE("SuspendThread failed w/ %d", GetLastError());
-    pthread_spin_unlock(&killer_lock);
-    return ESRCH;
-  }
-  struct NtContext nc;
-  nc.ContextFlags = kNtContextFull;
-  if (!GetThreadContext(th, &nc)) {
-    STRACE("GetThreadContext failed w/ %d", GetLastError());
-    ResumeThread(th);
-    pthread_spin_unlock(&killer_lock);
-    return ESRCH;
-  }
-  pthread_spin_unlock(&killer_lock);
-
-  // we can't preempt threads that masked sig or are blocked
-  // we can't preempt threads that are running in win32 code
-  // so we shall unblock the thread and let it signal itself
-  if ((atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
-       (1ull << (sig - 1))) ||
-      !((uintptr_t)__executable_start <= nc.Rip &&
-        nc.Rip < (uintptr_t)__privileged_start)) {
-    atomic_fetch_or_explicit(&pt->tib->tib_sigpending, 1ull << (sig - 1),
-                             memory_order_relaxed);
-    ResumeThread(th);
-    __sig_cancel(pt, sig, flags);
-    return 0;
-  }
-
-  // preferring to live dangerously
-  // the thread will be signaled asynchronously
-  if (flags & SA_RESETHAND) {
-    STRACE("resetting %G handler", sig);
-    __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
-  }
-
-  // inject call to trampoline function into thread
-  uintptr_t sp;
-  if (__sig_should_use_altstack(flags, pt->tib)) {
-    sp = (uintptr_t)pt->tib->tib_sigstack_addr + pt->tib->tib_sigstack_size;
-  } else {
-    sp = nc.Rsp;
-  }
-  sp -= sizeof(struct SignalFrame);
-  sp &= -16;
-  struct SignalFrame *sf = (struct SignalFrame *)sp;
-  _ntcontext2linux(&sf->ctx, &nc);
-  bzero(&sf->si, sizeof(sf->si));
-  sf->rva = rva;
-  sf->flags = flags;
-  sf->si.si_code = sic;
-  sf->si.si_signo = sig;
-  *(uintptr_t *)(sp -= sizeof(uintptr_t)) = nc.Rip;
-  nc.Rip = (intptr_t)__sig_tramp;
-  nc.Rdi = (intptr_t)sf;
-  nc.Rsp = sp;
-  if (!SetThreadContext(th, &nc)) {
-    STRACE("SetThreadContext failed w/ %d", GetLastError());
-    return ESRCH;
-  }
-  ResumeThread(th);
-  __sig_cancel(pt, sig, flags);
-  return 0;
-}
-
-// sends signal to another specific thread
-textwindows int __sig_kill(struct PosixThread *pt, int sig, int sic) {
-  int rc;
-  BLOCK_SIGNALS;
-  _pthread_ref(pt);
-  rc = __sig_killer(pt, sig, sic);
-  _pthread_unref(pt);
-  ALLOW_SIGNALS;
-  return rc;
-}
-
-// sends signal to any other thread
-textwindows void __sig_generate(int sig, int sic) {
-  struct Dll *e;
-  struct PosixThread *pt, *mark = 0;
-  if (__sig_ignored(sig)) {
-    STRACE("ignoring %G", sig);
-    return;
-  }
-  if (__sighandrvas[sig] == (intptr_t)SIG_DFL) {
-    STRACE("terminating on %G due to no handler", sig);
-    __sig_terminate(sig);
-  }
-  if (atomic_load_explicit(&__sig.pending, memory_order_acquire) &
-      (1ull << (sig - 1))) {
-    return;
-  }
-  BLOCK_SIGNALS;
-  _pthread_lock();
-  for (e = dll_first(_pthread_list); e; e = dll_next(_pthread_list, e)) {
-    pt = POSIXTHREAD_CONTAINER(e);
-    // we don't want to signal ourself
-    if (pt == _pthread_self())
-      continue;
-    // we don't want to signal a thread that isn't running
-    if (atomic_load_explicit(&pt->pt_status, memory_order_acquire) >=
-        kPosixThreadTerminated) {
-      continue;
-    }
-    // choose this thread if it isn't masking sig
-    if (!(atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
-          (1ull << (sig - 1)))) {
-      _pthread_ref(pt);
-      mark = pt;
-      break;
-    }
-    // if a thread is blocking then we check to see if it's planning
-    // to unblock our sig once the wait operation is completed; when
-    // that's the case we can cancel the thread's i/o to deliver sig
-    if (atomic_load_explicit(&pt->pt_blocker, memory_order_acquire) &&
-        !(pt->pt_blkmask & (1ull << (sig - 1)))) {
-      _pthread_ref(pt);
-      mark = pt;
-      break;
-    }
-  }
-  _pthread_unlock();
-  if (mark) {
-    __sig_killer(mark, sig, sic);
-    _pthread_unref(mark);
-  } else {
-    atomic_fetch_or_explicit(&__sig.pending, 1ull << (sig - 1),
-                             memory_order_relaxed);
-  }
-  ALLOW_SIGNALS;
-}
-
-static textwindows char *__sig_stpcpy(char *d, const char *s) {
-  size_t i;
-  for (i = 0;; ++i) {
-    if (!(d[i] = s[i])) {
-      return d + i;
-    }
-  }
-}
-
-static textwindows wontreturn void __sig_death(int sig, const char *thing) {
-#ifndef TINY
-  intptr_t hStderr;
-  char sigbuf[21], s[128], *p;
-  hStderr = GetStdHandle(kNtStdErrorHandle);
-  p = __sig_stpcpy(s, "Terminating on ");
-  p = __sig_stpcpy(p, thing);
-  p = __sig_stpcpy(p, strsignal_r(sig, sigbuf));
-  p = __sig_stpcpy(p,
-                   ". Pass --strace and/or ShowCrashReports() for details.\n");
-  WriteFile(hStderr, s, p - s, 0, 0);
-#endif
-  __sig_terminate(sig);
-}
-
-static textwindows void __sig_unmaskable(struct NtExceptionPointers *ep,
-                                         int code, int sig,
-                                         struct CosmoTib *tib) {
-
-  // log vital crash information reliably for --strace before doing much
-  // we don't print this without the flag since raw numbers scare people
-  // this needs at least one page of stack memory in order to get logged
-  // otherwise it'll print a warning message about the lack of stack mem
-  STRACE("win32 vectored exception 0x%08Xu raising %G "
-         "cosmoaddr2line %s %lx %s",
-         ep->ExceptionRecord->ExceptionCode, sig,
-         _weaken(FindDebugBinary) ? _weaken(FindDebugBinary)()
-                                  : program_invocation_name,
-         ep->ContextRecord->Rip,
-         DescribeBacktrace((struct StackFrame *)ep->ContextRecord->Rbp));
-
-  // if the user didn't install a signal handler for this unmaskable
-  // exception, then print a friendly helpful hint message to stderr
-  unsigned rva = __sighandrvas[sig];
-  if (rva == (intptr_t)SIG_DFL || rva == (intptr_t)SIG_IGN) {
-    __sig_death(sig, "uncaught ");
-  }
-
-  // if this signal handler is configured to auto-reset to the default
-  // then that reset needs to happen before the user handler is called
-  unsigned flags = __sighandflags[sig];
-  if (flags & SA_RESETHAND) {
-    STRACE("resetting %G handler", sig);
-    __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
-  }
-
-  // determine the true memory address at which fault occurred
-  // if this is a stack overflow then reapply guard protection
-  void *si_addr;
-  if (ep->ExceptionRecord->ExceptionCode == kNtSignalGuardPage) {
-    si_addr = (void *)ep->ExceptionRecord->ExceptionInformation[1];
-  } else {
-    si_addr = ep->ExceptionRecord->ExceptionAddress;
-  }
-
-  // call the user signal handler
-  // and a modifiable view of the faulting code's cpu state
-  // temporarily replace signal mask while calling crash handler
-  // abort process if sig is already blocked to avoid crash loop
-  // note ucontext_t is a hefty data structures on top of NtContext
-  ucontext_t ctx = {0};
-  siginfo_t si = {.si_signo = sig, .si_code = code, .si_addr = si_addr};
-  _ntcontext2linux(&ctx, ep->ContextRecord);
-  sigset_t blocksigs = __sighandmask[sig];
-  if (!(flags & SA_NODEFER))
-    blocksigs |= 1ull << (sig - 1);
-  ctx.uc_sigmask = atomic_fetch_or_explicit(&tib->tib_sigmask, blocksigs,
-                                            memory_order_acquire);
-  if (ctx.uc_sigmask & (1ull << (sig - 1))) {
-    __sig_death(sig, "masked ");
-    __sig_terminate(sig);
-  }
-  __sig_handler(rva)(sig, &si, &ctx);
-  atomic_store_explicit(&tib->tib_sigmask, ctx.uc_sigmask,
-                        memory_order_release);
-  _ntlinux2context(ep->ContextRecord, &ctx);
-}
-
-void __stack_call(struct NtExceptionPointers *, int, int, struct CosmoTib *,
-                  void (*)(struct NtExceptionPointers *, int, int,
-                           struct CosmoTib *),
-                  void *);
-
-//                         abashed the devil stood
-//                      and felt how awful goodness is
-__msabi dontinstrument unsigned __sig_crash(struct NtExceptionPointers *ep) {
-
-  // translate win32 to unix si_signo and si_code
-  int code, sig = __sig_crash_sig(ep, &code);
-
-  // advance the instruction pointer to skip over debugger breakpoints
-  // this behavior is consistent with how unix kernels are implemented
-  if (sig == SIGTRAP) {
-    ep->ContextRecord->Rip++;
-    if (__sig_ignored(sig)) {
-      return kNtExceptionContinueExecution;
-    }
-  }
-
-  // win32 stack overflow detection executes INSIDE the guard page
-  // thus switch to the alternate signal stack as soon as possible
-  struct CosmoTib *tib = __get_tls();
-  unsigned flags = __sighandflags[sig];
-  if (__sig_should_use_altstack(flags, tib)) {
-    __stack_call(ep, code, sig, tib, __sig_unmaskable,
-                 tib->tib_sigstack_addr + tib->tib_sigstack_size);
-  } else {
-    __sig_unmaskable(ep, code, sig, tib);
-  }
-
-  // resume running user program
-  // hopefully the user fixed the cpu state
-  // otherwise the crash will keep happening
-  return kNtExceptionContinueExecution;
-}
-
-static textwindows int __sig_console_sig(uint32_t dwCtrlType) {
-  switch (dwCtrlType) {
-    case kNtCtrlCEvent:
-      return SIGINT;
-    case kNtCtrlBreakEvent:
-      return SIGQUIT;
-    case kNtCtrlCloseEvent:
-    case kNtCtrlLogoffEvent:    // only received by services
-    case kNtCtrlShutdownEvent:  // only received by services
-      return SIGHUP;
-    default:
-      return SIGSTKFLT;
-  }
-}
-
-__msabi textwindows dontinstrument bool32 __sig_console(uint32_t dwCtrlType) {
-  struct CosmoTib tls;
-  __bootstrap_tls(&tls, __builtin_frame_address(0));
-  __sig_generate(__sig_console_sig(dwCtrlType), SI_KERNEL);
-  return true;
-}
-
-// returns 0 if no signal handlers were called, otherwise a bitmask
-// consisting of `1` which means a signal handler was invoked which
-// didn't have the SA_RESTART flag, and `2`, which means SA_RESTART
-// handlers were called (or `3` if both were the case).
-textwindows int __sig_check(void) {
-  int sig;
-  if ((sig = __sig_get(atomic_load_explicit(&__get_tls()->tib_sigmask,
-                                            memory_order_acquire)))) {
-    return __sig_raise(sig, SI_KERNEL);
-  } else {
-    return 0;
-  }
-}
-
-__attribute__((__constructor__(10))) textstartup void __sig_init(void) {
-  if (!IsWindows())
-    return;
-  AddVectoredExceptionHandler(true, (void *)__sig_crash);
-  SetConsoleCtrlHandler((void *)__sig_console, true);
-}
-
-#endif /* __x86_64__ */
diff --git a/libc/calls/sig.internal.h b/libc/calls/sig.internal.h
index 4175194f0..34b2f1d7c 100644
--- a/libc/calls/sig.internal.h
+++ b/libc/calls/sig.internal.h
@@ -1,7 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_SIGNALS_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_SIGNALS_INTERNAL_H_
+#include "libc/atomic.h"
 #include "libc/calls/struct/sigset.h"
-#include "libc/nt/struct/ntexceptionpointers.h"
+#include "libc/nt/thunk/msabi.h"
 #include "libc/thread/posixthread.internal.h"
 
 #define SIG_HANDLED_NO_RESTART 1
@@ -10,15 +11,15 @@
 COSMOPOLITAN_C_START_
 
 struct Signals {
-  _Atomic(uint64_t) pending;
-  _Atomic(uint64_t) count;
+  atomic_ulong *process;
+  atomic_ulong count;
 };
 
 extern struct Signals __sig;
 
 bool __sig_ignored(int);
 int __sig_check(void);
-int __sig_crash_sig(struct NtExceptionPointers *, int *);
+int __sig_crash_sig(unsigned, int *);
 int __sig_get(sigset_t);
 int __sig_kill(struct PosixThread *, int, int);
 int __sig_mask(int, const sigset_t *, sigset_t *);
@@ -28,5 +29,8 @@ void __sig_delete(int);
 void __sig_generate(int, int);
 void __sig_init(void);
 
+__msabi char16_t *__sig_process_path(char16_t *, uint32_t, int);
+__msabi atomic_ulong *__sig_map_process(int, int);
+
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_SIGNALS_INTERNAL_H_ */
diff --git a/libc/calls/sigaction.c b/libc/calls/sigaction.c
index 8def7b1dd..7c28b6851 100644
--- a/libc/calls/sigaction.c
+++ b/libc/calls/sigaction.c
@@ -30,13 +30,13 @@
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/calls/ucontext.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/log/backtrace.internal.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/syslib.internal.h"
@@ -423,7 +423,7 @@ static int __sigaction(int sig, const struct sigaction *act,
  *     }
  *
  *     void ContinueOnCrash(void) {
- *       struct sigaction sa = {.sa_handler = OnSigSegv,
+ *       struct sigaction sa = {.sa_sigaction = OnCrash,
  *                              .sa_flags = SA_SIGINFO | SA_RESETHAND};
  *       sigaction(SIGSEGV, &sa, 0);
  *       sigaction(SIGFPE, &sa, 0);
diff --git a/libc/calls/sigaltstack.c b/libc/calls/sigaltstack.c
index 7cfb961e4..a580a0fec 100644
--- a/libc/calls/sigaltstack.c
+++ b/libc/calls/sigaltstack.c
@@ -21,9 +21,9 @@
 #include "libc/calls/struct/sigaltstack.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/syslib.internal.h"
 #include "libc/sysv/consts/ss.h"
@@ -113,7 +113,7 @@ static int sigaltstack_bsd(const struct sigaltstack *neu,
  *     struct sigaction sa;
  *     struct sigaltstack ss;
  *     ss.ss_flags = 0;
- *     ss.ss_size = sysconf(_SC_MINSIGSTKSZ) + 8192;
+ *     ss.ss_size = sysconf(_SC_SIGSTKSZ);
  *     ss.ss_sp = malloc(ss.ss_size);
  *     sigaltstack(&ss, 0);
  *     sigemptyset(&sa.ss_mask);
@@ -121,18 +121,24 @@ static int sigaltstack_bsd(const struct sigaltstack *neu,
  *     sa.sa_handler = OnStackOverflow;
  *     sigaction(SIGSEGV, &sa, 0);
  *
+ * Your stack size should be `sysconf(_SC_SIGSTKSZ)` which should be
+ * somewhere in the ballpark of 32kb to 64kb. You should go no lower
+ * than `sysconf(_SC_MINSIGSTKSZ) + 2048` which could be 4kb - 34kb.
+ * Cosmo also defines `SIGSTKSZ` as 32kb, which should also be safe.
+ *
  * @param neu if non-null will install new signal alt stack
  * @param old if non-null will receive current signal alt stack
  * @return 0 on success, or -1 w/ errno
  * @raise EFAULT if bad memory was supplied
- * @raise ENOMEM if `neu->ss_size` is less than `MINSIGSTKSZ`
+ * @raise ENOMEM if `neu->ss_size` is beneath `sysconf(_SC_MINSIGSTKSZ)`
  */
 int sigaltstack(const struct sigaltstack *neu, struct sigaltstack *old) {
   int rc;
   if (neu && ((neu->ss_size >> 32) ||  //
               (neu->ss_flags & ~(SS_ONSTACK | SS_DISABLE)))) {
     rc = einval();
-  } else if (neu && neu->ss_size < __get_minsigstksz()) {
+  } else if (neu && !(neu->ss_flags & SS_DISABLE) &&
+             neu->ss_size < __get_minsigstksz()) {
     rc = enomem();
   } else if (IsLinux()) {
     rc = sys_sigaltstack(neu, old);
@@ -145,7 +151,7 @@ int sigaltstack(const struct sigaltstack *neu, struct sigaltstack *old) {
   } else {
     rc = sigaltstack_cosmo(neu, old);
   }
-  STRACE("sigaltstack(%s, [%s]) → %d% m", DescribeSigaltstk(0, neu),
-         DescribeSigaltstk(0, old), rc);
+  STRACE("sigaltstack(%s, [%s]) → %d% m", DescribeSigaltstack(0, neu),
+         DescribeSigaltstack(0, old), rc);
   return rc;
 }
diff --git a/libc/calls/sigcheck.c b/libc/calls/sigcheck.c
new file mode 100644
index 000000000..e8cad756d
--- /dev/null
+++ b/libc/calls/sigcheck.c
@@ -0,0 +1,40 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/internal.h"
+#include "libc/calls/sig.internal.h"
+#include "libc/intrin/weaken.h"
+#include "libc/sysv/consts/sicode.h"
+#include "libc/sysv/errfuns.h"
+
+textwindows int __sigcheck(sigset_t waitmask, bool restartable) {
+  int sig, handler_was_called = 0;
+  if (_check_cancel() == -1)
+    return -1;
+  while (_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))) {
+    handler_was_called |= _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
+    if (_check_cancel() == -1)
+      return -1;
+  }
+  if (handler_was_called & SIG_HANDLED_NO_RESTART)
+    return eintr();
+  if (handler_was_called & SIG_HANDLED_SA_RESTART)
+    if (!restartable)
+      return eintr();
+  return 0;
+}
diff --git a/libc/calls/sigcrashsig.c b/libc/calls/sigcrashsig.c
deleted file mode 100644
index 27d710a5d..000000000
--- a/libc/calls/sigcrashsig.c
+++ /dev/null
@@ -1,107 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/sig.internal.h"
-#include "libc/intrin/pushpop.internal.h"
-#include "libc/nt/enum/signal.h"
-#include "libc/nt/enum/status.h"
-#include "libc/nt/struct/ntexceptionpointers.h"
-
-// this is all a mandatory dependency of winmain
-// so, we trade away maintanibility for tininess
-// see libc/sysv/consts.sh for canonical magnums
-
-#define SIGILL_  pushpop(4)
-#define SIGTRAP_ pushpop(5)
-#define SIGABRT_ pushpop(6)
-#define SIGFPE_  pushpop(8)
-#define SIGSEGV_ pushpop(11)
-#define SIGSYS_  pushpop(31)
-
-#define TRAP_BRKPT_  pushpop(1)
-#define ILL_ILLOPC_  pushpop(1)
-#define ILL_PRVOPC_  pushpop(5)
-#define SEGV_MAPERR_ pushpop(1)
-#define SEGV_ACCERR_ pushpop(2)
-#define SI_USER_     pushpop(0)
-#define FPE_FLTDIV_  pushpop(3)
-#define FPE_FLTOVF_  pushpop(4)
-#define FPE_INTOVF_  pushpop(2)
-#define FPE_FLTUND_  pushpop(5)
-#define FPE_FLTRES_  pushpop(6)
-#define FPE_FLTINV_  pushpop(7)
-#define SI_KERNEL_   0x80
-
-textwindows int __sig_crash_sig(struct NtExceptionPointers *ep, int *code) {
-  switch (ep->ExceptionRecord->ExceptionCode) {
-    case kNtSignalBreakpoint:
-      *code = TRAP_BRKPT_;
-      return SIGTRAP_;
-    case kNtSignalIllegalInstruction:
-      *code = ILL_ILLOPC_;
-      return SIGILL_;
-    case kNtSignalPrivInstruction:
-      *code = ILL_PRVOPC_;
-      return SIGILL_;
-    case kNtSignalInPageError:
-    case kNtStatusStackOverflow:
-      *code = SEGV_MAPERR_;
-      return SIGSEGV_;
-    case kNtSignalGuardPage:
-    case kNtSignalAccessViolation:
-      *code = SEGV_ACCERR_;
-      return SIGSEGV_;
-    case kNtSignalInvalidHandle:
-    case kNtSignalInvalidParameter:
-    case kNtSignalAssertionFailure:
-      *code = SI_USER_;
-      return SIGABRT_;
-    case kNtStatusIntegerOverflow:
-      *code = FPE_INTOVF_;
-      return SIGFPE_;
-    case kNtSignalFltDivideByZero:
-      *code = FPE_FLTDIV_;
-      return SIGFPE_;
-    case kNtSignalFltOverflow:
-      *code = FPE_FLTOVF_;
-      return SIGFPE_;
-    case kNtSignalFltUnderflow:
-      *code = FPE_FLTUND_;
-      return SIGFPE_;
-    case kNtSignalFltInexactResult:
-      *code = FPE_FLTRES_;
-      return SIGFPE_;
-    case kNtSignalFltDenormalOperand:
-    case kNtSignalFltInvalidOperation:
-    case kNtSignalFltStackCheck:
-    case kNtSignalIntegerDivideByZero:
-    case kNtSignalFloatMultipleFaults:
-    case kNtSignalFloatMultipleTraps:
-      *code = FPE_FLTINV_;
-      return SIGFPE_;
-    case kNtSignalDllNotFound:
-    case kNtSignalOrdinalNotFound:
-    case kNtSignalEntrypointNotFound:
-    case kNtSignalDllInitFailed:
-      *code = SI_KERNEL_;
-      return SIGSYS_;
-    default:
-      *code = ep->ExceptionRecord->ExceptionCode;
-      return SIGSEGV_;
-  }
-}
diff --git a/libc/calls/sigenter-freebsd.c b/libc/calls/sigenter-freebsd.c
index 0f29ad547..d895f630c 100644
--- a/libc/calls/sigenter-freebsd.c
+++ b/libc/calls/sigenter-freebsd.c
@@ -28,7 +28,7 @@
 #include "libc/calls/struct/ucontext-freebsd.internal.h"
 #include "libc/calls/ucontext.h"
 #include "libc/log/libfatal.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
 #include "libc/str/str.h"
diff --git a/libc/calls/sigenter-netbsd.c b/libc/calls/sigenter-netbsd.c
index 9e20817df..09f8ff90c 100644
--- a/libc/calls/sigenter-netbsd.c
+++ b/libc/calls/sigenter-netbsd.c
@@ -27,7 +27,7 @@
 #include "libc/calls/struct/ucontext-netbsd.internal.h"
 #include "libc/calls/ucontext.h"
 #include "libc/log/libfatal.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
 #include "libc/str/str.h"
diff --git a/libc/calls/sigenter-openbsd.c b/libc/calls/sigenter-openbsd.c
index 5be46f32a..ac3819740 100644
--- a/libc/calls/sigenter-openbsd.c
+++ b/libc/calls/sigenter-openbsd.c
@@ -27,7 +27,7 @@
 #include "libc/calls/struct/ucontext-openbsd.internal.h"
 #include "libc/calls/ucontext.h"
 #include "libc/log/libfatal.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
 #include "libc/str/str.h"
diff --git a/libc/calls/sigenter-xnu.c b/libc/calls/sigenter-xnu.c
index c68a9c7c5..9d546ff28 100644
--- a/libc/calls/sigenter-xnu.c
+++ b/libc/calls/sigenter-xnu.c
@@ -33,6 +33,7 @@
 #include "libc/runtime/syslib.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sa.h"
+#include "libc/sysv/consts/sig.h"
 
 /**
  * @fileoverview XNU kernel callback normalization.
@@ -513,6 +514,7 @@ privileged void __sigenter_xnu(int sig, struct siginfo_xnu *xnuinfo,
     flags = __sighandflags[sig];
 
 #ifdef __aarch64__
+
     // xnu silicon claims to support sa_resethand but it does nothing
     // this can be tested, since it clears the bit from flags as well
     if (flags & SA_RESETHAND) {
@@ -521,6 +523,13 @@ privileged void __sigenter_xnu(int sig, struct siginfo_xnu *xnuinfo,
       __sighandflags[sig] = 0;
       __sighandrvas[sig] = 0;
     }
+
+    // unlike amd64, the instruction pointer on arm64 isn't advanced
+    // past the debugger breakpoint instruction automatically. we need
+    // this so execution can resume after __builtin_trap().
+    if (xnuctx && sig == SIGTRAP)
+      xnuctx->uc_mcontext->__ss.__pc += 4;
+
 #endif
 
     if (~flags & SA_SIGINFO) {
diff --git a/libc/calls/sigpending.c b/libc/calls/sigpending.c
index 648a6d223..0fceafa98 100644
--- a/libc/calls/sigpending.c
+++ b/libc/calls/sigpending.c
@@ -21,8 +21,8 @@
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/tls.h"
 
@@ -53,7 +53,7 @@ int sigpending(sigset_t *pending) {
     }
     rc = 0;
   } else if (IsWindows()) {
-    *pending = atomic_load_explicit(&__sig.pending, memory_order_acquire) |
+    *pending = atomic_load_explicit(__sig.process, memory_order_acquire) |
                atomic_load_explicit(&__get_tls()->tib_sigpending,
                                     memory_order_acquire);
     rc = 0;
diff --git a/libc/calls/sigsuspend.c b/libc/calls/sigsuspend.c
index 8c4c5d69e..fc7187f57 100644
--- a/libc/calls/sigsuspend.c
+++ b/libc/calls/sigsuspend.c
@@ -21,10 +21,11 @@
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/timespec.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/synchronization.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
@@ -53,8 +54,14 @@ int sigsuspend(const sigset_t *ignore) {
   } else {
     sigset_t waitmask = ignore ? *ignore : 0;
     if (IsWindows() || IsMetal()) {
-      while (!(rc = _park_norestart(-1u, waitmask)))
-        donothing;
+      // we don't strictly need to block signals, but it reduces signal
+      // delivery latency, by preventing other threads from delivering a
+      // signal asynchronously. it takes about ~5us to deliver a signal
+      // using SetEvent() whereas it takes ~30us to use SuspendThread(),
+      // GetThreadContext(), SetThreadContext(), and ResumeThread().
+      BLOCK_SIGNALS;
+      rc = _park_norestart(timespec_max, waitmask);
+      ALLOW_SIGNALS;
     } else {
       rc = sys_sigsuspend((uint64_t[2]){waitmask}, 8);
     }
diff --git a/libc/calls/sigtimedwait-nt.c b/libc/calls/sigtimedwait-nt.c
new file mode 100644
index 000000000..9deaa9d33
--- /dev/null
+++ b/libc/calls/sigtimedwait-nt.c
@@ -0,0 +1,117 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/calls/internal.h"
+#include "libc/calls/sig.internal.h"
+#include "libc/calls/struct/siginfo.h"
+#include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/timespec.internal.h"
+#include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/intrin/atomic.h"
+#include "libc/macros.h"
+#include "libc/nt/events.h"
+#include "libc/nt/runtime.h"
+#include "libc/nt/synchronization.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/sicode.h"
+#include "libc/sysv/consts/sig.h"
+#include "libc/sysv/errfuns.h"
+#include "libc/thread/posixthread.internal.h"
+#ifdef __x86_64__
+
+textwindows static int sys_sigtimedwait_nt_check(sigset_t syncsigs,
+                                                 siginfo_t *opt_info,
+                                                 sigset_t waitmask) {
+  int sig;
+  if (_check_cancel() == -1)
+    return -1;
+  if ((sig = __sig_get(waitmask))) {
+    if ((1ull << (sig - 1)) & syncsigs) {
+      if (opt_info) {
+        memset(opt_info, 0, sizeof(*opt_info));
+        opt_info->si_signo = sig;
+        opt_info->si_code = SI_TKILL;
+        opt_info->si_uid = sys_getuid_nt();
+      }
+      return sig;
+    }
+    int handler_was_called = __sig_relay(sig, SI_TKILL, waitmask);
+    if (_check_cancel() == -1)
+      return -1;
+    if (handler_was_called)
+      return eintr();
+  }
+  return 0;
+}
+
+textwindows static int sys_sigtimedwait_nt_impl(sigset_t syncsigs,
+                                                siginfo_t *opt_info,
+                                                struct timespec deadline,
+                                                sigset_t waitmask,
+                                                intptr_t semaphore) {
+  for (;;) {
+    int sig;
+    if ((sig = sys_sigtimedwait_nt_check(syncsigs, opt_info, waitmask)))
+      return sig;
+    struct timespec now = sys_clock_gettime_monotonic_nt();
+    if (timespec_cmp(now, deadline) >= 0)
+      return eagain();
+    struct timespec remain = timespec_sub(deadline, now);
+    int64_t millis = timespec_tomillis(remain);
+    uint32_t waitms = MIN(millis, 0xffffffffu);
+    uint32_t wi = WaitForSingleObject(semaphore, waitms);
+    if (wi == -1u)
+      return __winerr();
+    if (wi)
+      return eagain();
+  }
+}
+
+textwindows int sys_sigtimedwait_nt(const sigset_t *set, siginfo_t *opt_info,
+                                    const struct timespec *opt_timeout) {
+  int rc;
+  intptr_t sev;
+  struct PosixThread *pt;
+  struct timespec deadline;
+  sigset_t syncsigs, waitmask;
+  BLOCK_SIGNALS;
+  if (opt_timeout) {
+    deadline = timespec_add(sys_clock_gettime_monotonic_nt(), *opt_timeout);
+  } else {
+    deadline = timespec_max;
+  }
+  if ((sev = CreateEvent(0, 0, 0, 0))) {
+    syncsigs = *set & ~(1ull << (SIGTHR - 1));  // internal to pthreads
+    waitmask = ~syncsigs & _SigMask;
+    pt = _pthread_self();
+    pt->pt_event = sev;
+    pt->pt_blkmask = waitmask;
+    atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_EVENT,
+                          memory_order_release);
+    rc = sys_sigtimedwait_nt_impl(syncsigs, opt_info, deadline, waitmask, sev);
+    atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
+    CloseHandle(sev);
+  } else {
+    rc = __winerr();
+  }
+  ALLOW_SIGNALS;
+  return rc;
+}
+
+#endif /* __x86_64__ */
diff --git a/libc/calls/sigtimedwait.c b/libc/calls/sigtimedwait.c
index d68958113..65528d1e1 100644
--- a/libc/calls/sigtimedwait.c
+++ b/libc/calls/sigtimedwait.c
@@ -23,52 +23,66 @@
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
+int sys_sigtimedwait_nt(const sigset_t *, siginfo_t *, const struct timespec *);
+
 /**
  * Waits for signal synchronously, w/ timeout.
  *
+ * This function does not change the thread signal mask. Signals that
+ * aren't masked, which aren't in `set`, will be handled normally, in
+ * which case this function will raise `EINTR`.
+ *
+ * This function silently ignores attempts to synchronously wait for
+ * SIGTHR which is used internally by the POSIX threads implementation.
+ *
  * @param set is signals for which we'll be waiting
- * @param info if not null shall receive info about signal
- * @param timeout is relative deadline and null means wait forever
+ * @param opt_info if not null shall receive info about signal
+ * @param opt_timeout is relative deadline and null means wait forever
  * @return signal number on success, or -1 w/ errno
  * @raise EINTR if an asynchronous signal was delivered instead
  * @raise ECANCELED if thread was cancelled in masked mode
  * @raise EINVAL if nanoseconds parameter was out of range
- * @raise EAGAIN if deadline expired
- * @raise ENOSYS on Windows, XNU, OpenBSD, Metal
+ * @raise EAGAIN if timeout elapsed
+ * @raise ENOSYS on XNU, OpenBSD, and Metal
  * @raise EFAULT if invalid memory was supplied
  * @cancelationpoint
+ * @norestart
  */
-int sigtimedwait(const sigset_t *set, siginfo_t *info,
-                 const struct timespec *timeout) {
+int sigtimedwait(const sigset_t *set, siginfo_t *opt_info,
+                 const struct timespec *opt_timeout) {
   int rc;
   char strsig[21];
   struct timespec ts;
   union siginfo_meta si = {0};
   BEGIN_CANCELATION_POINT;
 
-  if (IsLinux() || IsFreebsd() || IsNetbsd()) {
-    if (timeout) {
+  // validate timeout
+  if (opt_timeout && opt_timeout->tv_nsec >= 1000000000ull) {
+    rc = einval();
+  } else if (IsLinux() || IsFreebsd() || IsNetbsd()) {
+    if (opt_timeout) {
       // 1. Linux needs its size parameter
       // 2. NetBSD modifies timeout argument
-      ts = *timeout;
+      ts = *opt_timeout;
       rc = sys_sigtimedwait(set, &si, &ts, 8);
     } else {
       rc = sys_sigtimedwait(set, &si, 0, 8);
     }
-    if (rc != -1 && info) {
-      __siginfo2cosmo(info, &si);
-    }
+    if (rc != -1 && opt_info)
+      __siginfo2cosmo(opt_info, &si);
+  } else if (IsWindows()) {
+    rc = sys_sigtimedwait_nt(set, opt_info, opt_timeout);
   } else {
     rc = enosys();
   }
 
   END_CANCELATION_POINT;
   STRACE("sigtimedwait(%s, [%s], %s) → %s% m", DescribeSigset(0, set),
-         DescribeSiginfo(rc, info), DescribeTimespec(0, timeout),
+         DescribeSiginfo(rc, opt_info), DescribeTimespec(0, opt_timeout),
          strsignal_r(rc, strsig));
   return rc;
 }
diff --git a/libc/calls/sigwait.c b/libc/calls/sigwait.c
index 77dc014fa..a76b0dfd0 100644
--- a/libc/calls/sigwait.c
+++ b/libc/calls/sigwait.c
@@ -18,10 +18,26 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/sigtimedwait.h"
 
-int sigwait(const sigset_t *mask, int *sig) {
-  siginfo_t si;
-  if (sigtimedwait(mask, &si, 0) < 0)
+/**
+ * Waits for signal synchronously.
+ *
+ * See sigtimedwait() for further details.
+ *
+ * @param set is signals for which we'll be waiting
+ * @param out_sig shall receive signal number
+ * @return 0 on success, or -1 w/ errno
+ * @raise EINTR if an asynchronous signal was delivered instead
+ * @raise ECANCELED if thread was cancelled in masked mode
+ * @raise ENOSYS on OpenBSD, XNU, and Metal
+ * @see sigtimedwait()
+ * @cancelationpoint
+ * @norestart
+ */
+int sigwait(const sigset_t *mask, int *out_sig) {
+  int sig;
+  if ((sig = sigtimedwait(mask, 0, 0)) == -1)
     return -1;
-  *sig = si.si_signo;
+  if (out_sig)
+    *out_sig = sig;
   return 0;
 }
diff --git a/libc/calls/sigwaitinfo.c b/libc/calls/sigwaitinfo.c
index 368ae1777..ef5876698 100644
--- a/libc/calls/sigwaitinfo.c
+++ b/libc/calls/sigwaitinfo.c
@@ -21,14 +21,17 @@
 /**
  * Waits for signal synchronously.
  *
+ * See sigtimedwait() for further details.
+ *
  * @param set is signals for which we'll be waiting
  * @param info if not null shall receive info about signal
  * @return signal number on success, or -1 w/ errno
  * @raise EINTR if an asynchronous signal was delivered instead
  * @raise ECANCELED if thread was cancelled in masked mode
- * @raise ENOSYS on OpenBSD, XNU, and Windows
+ * @raise ENOSYS on OpenBSD, XNU, and Metal
  * @see sigtimedwait()
  * @cancelationpoint
+ * @norestart
  */
 int sigwaitinfo(const sigset_t *mask, siginfo_t *si) {
   return sigtimedwait(mask, si, 0);
diff --git a/libc/calls/splice.c b/libc/calls/splice.c
index ce936f6ff..6460d0c79 100644
--- a/libc/calls/splice.c
+++ b/libc/calls/splice.c
@@ -23,8 +23,8 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/mem/alloca.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/state.internal.h b/libc/calls/state.internal.h
index 003265867..3d4d2a2d9 100644
--- a/libc/calls/state.internal.h
+++ b/libc/calls/state.internal.h
@@ -13,7 +13,6 @@ extern unsigned __sighandflags[NSIG + 1];
 extern uint64_t __sighandmask[NSIG + 1];
 extern const struct NtSecurityAttributes kNtIsInheritable;
 
-void __fds_wipe(void);
 void __fds_lock(void);
 void __fds_unlock(void);
 
diff --git a/libc/calls/statfs.c b/libc/calls/statfs.c
index c8d573a06..ef71c8bc4 100644
--- a/libc/calls/statfs.c
+++ b/libc/calls/statfs.c
@@ -24,7 +24,7 @@
 #include "libc/calls/struct/statfs.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/stack.h"
 #include "libc/runtime/zipos.internal.h"
@@ -34,6 +34,63 @@
 /**
  * Returns information about filesystem.
  *
+ * The `struct statfs` returned has the following fields:
+ *
+ * - `f_fstypename` holds a NUL-terminated string identifying the file
+ *   system type. On Linux, this will usually be "nfs". On FreeBSD, it
+ *   will usually be "zfs". On OpenBSD and NetBSD, it's usually "ffs".
+ *   On MacOS it's usually "apfs", and on Windows it's usually "NTFS".
+ *
+ * - `f_bsize` is the optimal transfer block size. This may be used to
+ *   appropriately chunk your i/o operations. On local file systems it
+ *   will usually be somewhere between 4096 and 131072 bytes. With NFS
+ *   it may be as high as 512kb.
+ *
+ * - `f_frsize` is the fragment size of the file system. This could be
+ *   anywhere between 512 and 4096 bytes for local filesystems usually
+ *   although it could go higher. It should less than, or equal to the
+ *   `f_bsize`. This fragment size is what you want to use to multiply
+ *   other fields that count blocks into a byte count.
+ *
+ * - `f_bfree` is the number of free blocks in the filesystem. You can
+ *   multiply this number by `f_frsize` to obtain the free byte count.
+ *
+ * - `f_bavail` is the number of free blocks in the filesystem you can
+ *   access from userspace. It's less than or equal to `f_bfree` which
+ *   generally has some blocks reserved for root in a pinch. You could
+ *   multiply this by `f_frsize` to convert this number to bytes.
+ *
+ * - `f_files` is the total number of file nodes. Not every OS has it.
+ *   On Windows for instance it's currently always `INT64_MAX`. It has
+ *   an unspecified meaning. It should be seen as informative.
+ *
+ * - `f_fsid` is an opaque data structure that uniquely identifies the
+ *   filesystem. We're not yet certain how reliable this is across the
+ *   various OSes and filesystem types.
+ *
+ * - `f_namelen` is basically the same as `NAME_MAX` which seems to be
+ *   255 on all the OSes we've evaluated. It's the maximum length when
+ *   it comes to individual components in a filesystem path.
+ *
+ * - `f_type` is an OS-specific file system type ID. This is just some
+ *   magic number. No defines are provided by Cosmopolitan Libc for it
+ *
+ * - `f_flags` specifies the options used when a filesystem is mounted
+ *   and the numbers vary across OSes. Cosmopolitan Libc polyfills the
+ *   magic numbers somewhat consistently. If `IsWindows()` is set then
+ *   the constants defined by Microsoft (e.g. `FILE_READ_ONLY_VOLUME`)
+ *   should be used. Otherwise on any other UNIX system, the following
+ *   constants are provided. You should check each constant at runtime
+ *   before using them, to determine if they're non-zero, for support.
+ *
+ *   - `ST_RDONLY` if mounted in read-only mode (works UNIX + Windows)
+ *   - `ST_NOSUID` if setuid binaries are forbidden (all UNIX support)
+ *   - `ST_NODEV` when device file access forbidden (all UNIX support)
+ *   - `ST_NOEXEC` when a file executions forbidden (all UNIX support)
+ *   - `ST_SYNCHRONOUS`, if `O_SYNC` always happens (all UNIX support)
+ *   - `ST_NOATIME` if access timestamps aren't set (all UNIX support)
+ *   - `ST_RELATIME` if relative acces time is used (all UNIX support)
+ *
  * @return 0 on success, or -1 w/ errno
  * @raise ECANCELED if thread was cancelled in masked mode
  * @raise EINTR if signal was delivered
diff --git a/libc/calls/struct/fd.internal.h b/libc/calls/struct/fd.internal.h
deleted file mode 100644
index e3ff36fc5..000000000
--- a/libc/calls/struct/fd.internal.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_FD_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_CALLS_STRUCT_FD_INTERNAL_H_
-COSMOPOLITAN_C_START_
-
-#define kFdEmpty     0
-#define kFdFile      1
-#define kFdSocket    2
-#define kFdConsole   4
-#define kFdSerial    5
-#define kFdZip       6
-#define kFdEpoll     7
-#define kFdReserved  8
-#define kFdDevNull   9
-#define kFdDevRandom 10
-
-struct Fd {
-  char kind;
-  bool isbound;
-  unsigned flags;
-  unsigned mode;
-  long handle;
-  long pointer;
-  int family;
-  int type;
-  int protocol;
-  unsigned rcvtimeo; /* millis; 0 means wait forever */
-  unsigned sndtimeo; /* millis; 0 means wait forever */
-  void *connect_op;
-};
-
-struct Fds {
-  _Atomic(int) f; /* lowest free slot */
-  size_t n;
-  struct Fd *p, *e;
-};
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_FD_INTERNAL_H_ */
diff --git a/libc/calls/struct/flock.internal.h b/libc/calls/struct/flock.internal.h
index aea17b09e..52b14ad66 100644
--- a/libc/calls/struct/flock.internal.h
+++ b/libc/calls/struct/flock.internal.h
@@ -4,8 +4,8 @@
 #include "libc/mem/alloca.h"
 COSMOPOLITAN_C_START_
 
-const char *DescribeFlock(char[300], int, const struct flock *);
-#define DescribeFlock(c, l) DescribeFlock(alloca(300), c, l)
+const char *_DescribeFlock(char[300], int, const struct flock *);
+#define DescribeFlock(c, l) _DescribeFlock(alloca(300), c, l)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_FLOCK_INTERNAL_H_ */
diff --git a/libc/calls/struct/iovec.internal.h b/libc/calls/struct/iovec.internal.h
index 34fd4e07d..6c6a3661a 100644
--- a/libc/calls/struct/iovec.internal.h
+++ b/libc/calls/struct/iovec.internal.h
@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_IOVEC_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_STRUCT_IOVEC_INTERNAL_H_
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/iovec.h"
+#include "libc/intrin/fds.h"
 #include "libc/mem/alloca.h"
 COSMOPOLITAN_C_START_
 
@@ -22,8 +22,8 @@ ssize_t sys_send_nt(int, const struct iovec *, size_t, uint32_t);
 ssize_t sys_sendto_nt(int, const struct iovec *, size_t, uint32_t, const void *,
                       uint32_t);
 
-const char *DescribeIovec(char[300], ssize_t, const struct iovec *, int);
-#define DescribeIovec(x, y, z) DescribeIovec(alloca(300), x, y, z)
+const char *_DescribeIovec(char[300], ssize_t, const struct iovec *, int);
+#define DescribeIovec(x, y, z) _DescribeIovec(alloca(300), x, y, z)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_IOVEC_INTERNAL_H_ */
diff --git a/libc/calls/struct/itimerval.internal.h b/libc/calls/struct/itimerval.internal.h
index ababa1bee..9bad9b7a0 100644
--- a/libc/calls/struct/itimerval.internal.h
+++ b/libc/calls/struct/itimerval.internal.h
@@ -8,8 +8,8 @@ int sys_getitimer(int, struct itimerval *);
 int sys_setitimer(int, const struct itimerval *, struct itimerval *);
 int sys_setitimer_nt(int, const struct itimerval *, struct itimerval *);
 
-const char *DescribeItimerval(char[90], int, const struct itimerval *);
-#define DescribeItimerval(rc, ts) DescribeItimerval(alloca(90), rc, ts)
+const char *_DescribeItimerval(char[90], int, const struct itimerval *);
+#define DescribeItimerval(rc, ts) _DescribeItimerval(alloca(90), rc, ts)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_ITIMERVAL_INTERNAL_H_ */
diff --git a/libc/calls/struct/rlimit.internal.h b/libc/calls/struct/rlimit.internal.h
index fa8ce9200..5818c6d5a 100644
--- a/libc/calls/struct/rlimit.internal.h
+++ b/libc/calls/struct/rlimit.internal.h
@@ -8,8 +8,8 @@ int sys_getrlimit(int, struct rlimit *);
 int sys_setrlimit(int, const struct rlimit *);
 int sys_setrlimit_nt(int, const struct rlimit *);
 
-const char *DescribeRlimit(char[64], int, const struct rlimit *);
-#define DescribeRlimit(rc, rl) DescribeRlimit(alloca(64), rc, rl)
+const char *_DescribeRlimit(char[64], int, const struct rlimit *);
+#define DescribeRlimit(rc, rl) _DescribeRlimit(alloca(64), rc, rl)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_RLIMIT_INTERNAL_H_ */
diff --git a/libc/calls/struct/sched_param.internal.h b/libc/calls/struct/sched_param.internal.h
index 9df42312e..565d661b3 100644
--- a/libc/calls/struct/sched_param.internal.h
+++ b/libc/calls/struct/sched_param.internal.h
@@ -4,8 +4,8 @@
 #include "libc/mem/alloca.h"
 COSMOPOLITAN_C_START_
 
-const char *DescribeSchedParam(char[32], const struct sched_param *);
-#define DescribeSchedParam(x) DescribeSchedParam(alloca(32), x)
+const char *_DescribeSchedParam(char[32], const struct sched_param *);
+#define DescribeSchedParam(x) _DescribeSchedParam(alloca(32), x)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SCHED_PARAM_INTERNAL_H_ */
diff --git a/libc/calls/struct/sigaction.internal.h b/libc/calls/struct/sigaction.internal.h
index bf69a81db..19b1177a5 100644
--- a/libc/calls/struct/sigaction.internal.h
+++ b/libc/calls/struct/sigaction.internal.h
@@ -66,8 +66,8 @@ void __sigenter_netbsd(int, siginfo_t *, void *);
 void __sigenter_freebsd(int, siginfo_t *, void *);
 void __sigenter_openbsd(int, siginfo_t *, void *);
 
-const char *DescribeSigaction(char[256], int, const struct sigaction *);
-#define DescribeSigaction(rc, sa) DescribeSigaction(alloca(256), rc, sa)
+const char *_DescribeSigaction(char[256], int, const struct sigaction *);
+#define DescribeSigaction(rc, sa) _DescribeSigaction(alloca(256), rc, sa)
 
 void _init_onntconsoleevent(void);
 
diff --git a/libc/calls/struct/sigaltstack.internal.h b/libc/calls/struct/sigaltstack.internal.h
index 43c21abb9..b2416b560 100644
--- a/libc/calls/struct/sigaltstack.internal.h
+++ b/libc/calls/struct/sigaltstack.internal.h
@@ -4,8 +4,8 @@
 #include "libc/mem/alloca.h"
 COSMOPOLITAN_C_START_
 
-const char *DescribeSigaltstk(char[128], int, const struct sigaltstack *);
-#define DescribeSigaltstk(rc, ss) DescribeSigaltstk(alloca(128), rc, ss)
+const char *_DescribeSigaltstack(char[128], int, const struct sigaltstack *);
+#define DescribeSigaltstack(rc, ss) _DescribeSigaltstack(alloca(128), rc, ss)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGALTSTACK_INTERNAL_H_ */
diff --git a/libc/calls/struct/siginfo.internal.h b/libc/calls/struct/siginfo.internal.h
index 99b2e4eda..d5479c464 100644
--- a/libc/calls/struct/siginfo.internal.h
+++ b/libc/calls/struct/siginfo.internal.h
@@ -6,8 +6,8 @@ COSMOPOLITAN_C_START_
 
 int sys_sigqueueinfo(int, const siginfo_t *);
 
-const char *DescribeSiginfo(char[300], int, const siginfo_t *);
-#define DescribeSiginfo(x, y) DescribeSiginfo(alloca(300), x, y)
+const char *_DescribeSiginfo(char[300], int, const siginfo_t *);
+#define DescribeSiginfo(x, y) _DescribeSiginfo(alloca(300), x, y)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGINFO_INTERNAL_H_ */
diff --git a/libc/calls/struct/sigset.h b/libc/calls/struct/sigset.h
index 3d783c47a..09faa3118 100644
--- a/libc/calls/struct/sigset.h
+++ b/libc/calls/struct/sigset.h
@@ -4,19 +4,21 @@ COSMOPOLITAN_C_START_
 
 typedef uint64_t sigset_t;
 
-int sigaddset(sigset_t *, int) paramsnonnull();
-int sigdelset(sigset_t *, int) paramsnonnull();
-int sigemptyset(sigset_t *) paramsnonnull();
-int sigfillset(sigset_t *) paramsnonnull();
-int sigandset(sigset_t *, const sigset_t *, const sigset_t *) paramsnonnull();
-int sigorset(sigset_t *, const sigset_t *, const sigset_t *) paramsnonnull();
-int sigisemptyset(const sigset_t *) paramsnonnull() nosideeffect;
-int sigismember(const sigset_t *, int) paramsnonnull() nosideeffect;
-int sigcountset(const sigset_t *) paramsnonnull() nosideeffect;
-int sigprocmask(int, const sigset_t *, sigset_t *);
-int sigsuspend(const sigset_t *);
-int sigpending(sigset_t *);
-int pthread_sigmask(int, const sigset_t *, sigset_t *);
+/* clang-format off */
+int sigaddset(sigset_t *, int) libcesque paramsnonnull();
+int sigdelset(sigset_t *, int) libcesque paramsnonnull();
+int sigemptyset(sigset_t *) libcesque paramsnonnull();
+int sigfillset(sigset_t *) libcesque paramsnonnull();
+int sigandset(sigset_t *, const sigset_t *, const sigset_t *) libcesque paramsnonnull();
+int sigorset(sigset_t *, const sigset_t *, const sigset_t *) libcesque paramsnonnull();
+int sigisemptyset(const sigset_t *) libcesque paramsnonnull() nosideeffect;
+int sigismember(const sigset_t *, int) libcesque paramsnonnull() nosideeffect;
+int sigcountset(const sigset_t *) libcesque paramsnonnull() nosideeffect;
+int sigprocmask(int, const sigset_t *, sigset_t *) dontthrow;
+int sigsuspend(const sigset_t *) dontthrow;
+int sigpending(sigset_t *) libcesque;
+int pthread_sigmask(int, const sigset_t *, sigset_t *) dontthrow;
+/* clang-format on */
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGSET_H_ */
diff --git a/libc/calls/struct/sigset.internal.h b/libc/calls/struct/sigset.internal.h
index 567ea1728..77af35704 100644
--- a/libc/calls/struct/sigset.internal.h
+++ b/libc/calls/struct/sigset.internal.h
@@ -2,6 +2,7 @@
 #define COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGSET_INTERNAL_H_
 #include "libc/calls/struct/sigset.h"
 #include "libc/mem/alloca.h"
+#include "libc/sysv/consts/sig.h"
 COSMOPOLITAN_C_START_
 
 #define BLOCK_SIGNALS  \
@@ -21,8 +22,8 @@ int sys_sigprocmask(int, const sigset_t *, sigset_t *);
 int sys_sigsuspend(const uint64_t *, uint64_t);
 int sys_sigpending(uint64_t *, size_t);
 
-const char *DescribeSigset(char[128], int, const sigset_t *);
-#define DescribeSigset(rc, ss) DescribeSigset(alloca(128), rc, ss)
+const char *_DescribeSigset(char[128], int, const sigset_t *);
+#define DescribeSigset(rc, ss) _DescribeSigset(alloca(128), rc, ss)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_SIGSET_INTERNAL_H_ */
diff --git a/libc/calls/struct/stat.internal.h b/libc/calls/struct/stat.internal.h
index 5d1c9fed6..eb9aa1ca6 100644
--- a/libc/calls/struct/stat.internal.h
+++ b/libc/calls/struct/stat.internal.h
@@ -13,8 +13,8 @@ int sys_fstatat_nt(int, const char *, struct stat *, int);
 int sys_lstat_nt(const char *, struct stat *);
 int sys_fstat_metal(int, struct stat *);
 
-const char *DescribeStat(char[300], int, const struct stat *);
-#define DescribeStat(rc, st) DescribeStat(alloca(300), rc, st)
+const char *_DescribeStat(char[300], int, const struct stat *);
+#define DescribeStat(rc, st) _DescribeStat(alloca(300), rc, st)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_STAT_INTERNAL_H_ */
diff --git a/libc/calls/struct/statfs.internal.h b/libc/calls/struct/statfs.internal.h
index ab3919628..b98073dc4 100644
--- a/libc/calls/struct/statfs.internal.h
+++ b/libc/calls/struct/statfs.internal.h
@@ -12,8 +12,8 @@ int sys_fstatfs_nt(int64_t, struct statfs *);
 int sys_statfs_nt(const char *, struct statfs *);
 void statfs2statvfs(struct statvfs *, const struct statfs *);
 
-const char *DescribeStatfs(char[300], int, const struct statfs *);
-#define DescribeStatfs(rc, sf) DescribeStatfs(alloca(300), rc, sf)
+const char *_DescribeStatfs(char[300], int, const struct statfs *);
+#define DescribeStatfs(rc, sf) _DescribeStatfs(alloca(300), rc, sf)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_STATFS_INTERNAL_H_ */
diff --git a/libc/calls/struct/termios.internal.h b/libc/calls/struct/termios.internal.h
index c116d4d04..ac85545dc 100644
--- a/libc/calls/struct/termios.internal.h
+++ b/libc/calls/struct/termios.internal.h
@@ -4,9 +4,9 @@
 #include "libc/mem/alloca.h"
 COSMOPOLITAN_C_START_
 
-const char *DescribeTermios(char[1024], ssize_t, const struct termios *);
+const char *_DescribeTermios(char[1024], ssize_t, const struct termios *);
 
-#define DescribeTermios(rc, tio) DescribeTermios(alloca(1024), rc, tio)
+#define DescribeTermios(rc, tio) _DescribeTermios(alloca(1024), rc, tio)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_TERMIOS_INTERNAL_H_ */
diff --git a/libc/calls/struct/timespec.h b/libc/calls/struct/timespec.h
index 7dbcb5b28..9a8c3e8db 100644
--- a/libc/calls/struct/timespec.h
+++ b/libc/calls/struct/timespec.h
@@ -20,7 +20,6 @@ int timespec_get(struct timespec *, int) libcesque;
 
 #ifdef _COSMO_SOURCE
 int sys_clock_nanosleep(int, int, const struct timespec *, struct timespec *);
-int cosmo_clock_nanosleep(int, int, const struct timespec *, struct timespec *);
 #define timespec_zero ((struct timespec){0})
 #define timespec_max  ((struct timespec){0x7fffffffffffffff, 999999999})
 libcesque int timespec_cmp(struct timespec, struct timespec) pureconst;
@@ -34,8 +33,8 @@ libcesque struct timespec timespec_frommicros(int64_t) pureconst;
 libcesque struct timespec timespec_frommillis(int64_t) pureconst;
 libcesque struct timespec timespec_real(void) libcesque;
 libcesque struct timespec timespec_mono(void) libcesque;
-libcesque struct timespec timespec_sleep(struct timespec) libcesque;
-libcesque int timespec_sleep_until(struct timespec) libcesque;
+libcesque struct timespec timespec_sleep(int, struct timespec) libcesque;
+libcesque int timespec_sleep_until(int, struct timespec) libcesque;
 libcesque struct timespec timespec_sub(struct timespec,
                                        struct timespec) pureconst;
 libcesque struct timespec timespec_subz(struct timespec,
diff --git a/libc/calls/struct/timespec.internal.h b/libc/calls/struct/timespec.internal.h
index fc15a2061..4eaa08004 100644
--- a/libc/calls/struct/timespec.internal.h
+++ b/libc/calls/struct/timespec.internal.h
@@ -25,9 +25,10 @@ int sys_sem_timedwait(int64_t, const struct timespec *);
 int sys_utimensat(int, const char *, const struct timespec[2], int);
 int sys_utimensat_nt(int, const char *, const struct timespec[2], int);
 int sys_utimensat_old(int, const char *, const struct timespec[2], int);
+struct timespec sys_clock_gettime_monotonic_nt(void);
 
-const char *DescribeTimespec(char[45], int, const struct timespec *);
-#define DescribeTimespec(rc, ts) DescribeTimespec(alloca(45), rc, ts)
+const char *_DescribeTimespec(char[45], int, const struct timespec *);
+#define DescribeTimespec(rc, ts) _DescribeTimespec(alloca(45), rc, ts)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_TIMESPEC_INTERNAL_H_ */
diff --git a/libc/calls/struct/timeval.internal.h b/libc/calls/struct/timeval.internal.h
index ceaf8f73e..a3cf06847 100644
--- a/libc/calls/struct/timeval.internal.h
+++ b/libc/calls/struct/timeval.internal.h
@@ -11,8 +11,8 @@ int sys_lutimes(const char *, const struct timeval *);
 int sys_utimes(const char *, const struct timeval *);
 int sys_utimes_nt(const char *, const struct timeval[2]);
 
-const char *DescribeTimeval(char[45], int, const struct timeval *);
-#define DescribeTimeval(rc, ts) DescribeTimeval(alloca(45), rc, ts)
+const char *_DescribeTimeval(char[45], int, const struct timeval *);
+#define DescribeTimeval(rc, ts) _DescribeTimeval(alloca(45), rc, ts)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_TIMEVAL_INTERNAL_H_ */
diff --git a/libc/calls/struct/ucontext.internal.h b/libc/calls/struct/ucontext.internal.h
index 9122af24a..18a271f10 100644
--- a/libc/calls/struct/ucontext.internal.h
+++ b/libc/calls/struct/ucontext.internal.h
@@ -1,13 +1,14 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_UCONTEXT_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_STRUCT_UCONTEXT_INTERNAL_H_
 #include "libc/calls/ucontext.h"
-#include "libc/nt/struct/context.h"
 COSMOPOLITAN_C_START_
 
 #ifdef __x86_64__
 #define PC   rip
 #define SP   rsp
 #define BP   rbp
+#define RES0 rax
+#define RES1 rdx
 #define ARG0 rdi
 #define ARG1 rsi
 #define ARG2 rdx
@@ -18,6 +19,8 @@ COSMOPOLITAN_C_START_
 #define PC   pc
 #define SP   sp
 #define BP   regs[29]
+#define RES0 regs[0]
+#define RES1 regs[1]
 #define ARG0 regs[0]
 #define ARG1 regs[1]
 #define ARG2 regs[2]
@@ -28,8 +31,5 @@ COSMOPOLITAN_C_START_
 #error "unsupported architecture"
 #endif
 
-void _ntcontext2linux(struct ucontext *, const struct NtContext *);
-void _ntlinux2context(struct NtContext *, const ucontext_t *);
-
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_UCONTEXT_INTERNAL_H_ */
diff --git a/libc/calls/struct/user_regs_struct.h b/libc/calls/struct/user_regs_struct.h
deleted file mode 100644
index 5cbe63f5c..000000000
--- a/libc/calls/struct/user_regs_struct.h
+++ /dev/null
@@ -1,71 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_USER_REGS_STRUCT_H_
-#define COSMOPOLITAN_LIBC_CALLS_STRUCT_USER_REGS_STRUCT_H_
-COSMOPOLITAN_C_START_
-
-/**
- * Linux Kernel user registers.
- *
- * @note superset of struct pt_regs
- * @see ptrace() w/ PTRACE_SYSCALL
- */
-struct user_regs_struct {
-  uint64_t r15;
-  uint64_t r14;
-  uint64_t r13;
-  uint64_t r12;
-  uint64_t rbp;
-  uint64_t rbx;
-  uint64_t r11;
-  uint64_t r10;
-  uint64_t r9;
-  uint64_t r8;
-  uint64_t rax;
-  uint64_t rcx;
-  uint64_t rdx;
-  uint64_t rsi;
-  uint64_t rdi;
-  uint64_t orig_rax;
-  uint64_t rip;
-  uint64_t cs;
-  uint64_t eflags;
-  uint64_t rsp;
-  uint64_t ss;
-  uint64_t fs_base;
-  uint64_t gs_base;
-  uint64_t ds;
-  uint64_t es;
-  uint64_t fs;
-  uint64_t gs;
-};
-
-struct useregs_struct_freebsd {
-  int64_t r15;
-  int64_t r14;
-  int64_t r13;
-  int64_t r12;
-  int64_t r11;
-  int64_t r10;
-  int64_t r9;
-  int64_t r8;
-  int64_t rdi;
-  int64_t rsi;
-  int64_t rbp;
-  int64_t rbx;
-  int64_t rdx;
-  int64_t rcx;
-  int64_t rax;
-  uint32_t trapno;
-  uint16_t fs;
-  uint16_t gs;
-  uint32_t err;
-  uint16_t es;
-  uint16_t ds;
-  int64_t rip;
-  int64_t cs;
-  int64_t rflags;
-  int64_t rsp;
-  int64_t ss;
-};
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_USER_REGS_STRUCT_H_ */
diff --git a/libc/calls/struct/winsize.internal.h b/libc/calls/struct/winsize.internal.h
index 8e1d5dbec..8c5e07fad 100644
--- a/libc/calls/struct/winsize.internal.h
+++ b/libc/calls/struct/winsize.internal.h
@@ -1,13 +1,13 @@
 #ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_WINSIZE_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_CALLS_STRUCT_WINSIZE_INTERNAL_H_
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/winsize.h"
+#include "libc/intrin/fds.h"
 #include "libc/mem/alloca.h"
 COSMOPOLITAN_C_START_
 
 int tcgetwinsize_nt(int, struct winsize *);
-const char *DescribeWinsize(char[64], int, const struct winsize *);
-#define DescribeWinsize(rc, ws) DescribeWinsize(alloca(64), rc, ws)
+const char *_DescribeWinsize(char[64], int, const struct winsize *);
+#define DescribeWinsize(rc, ws) _DescribeWinsize(alloca(64), rc, ws)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_WINSIZE_INTERNAL_H_ */
diff --git a/libc/calls/symlinkat.c b/libc/calls/symlinkat.c
index 3af90f91d..c4aa3e726 100644
--- a/libc/calls/symlinkat.c
+++ b/libc/calls/symlinkat.c
@@ -20,8 +20,8 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/at.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/sync.c b/libc/calls/sync.c
index bdf2c7592..ca6cd1b84 100644
--- a/libc/calls/sync.c
+++ b/libc/calls/sync.c
@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 
 /**
diff --git a/libc/calls/sys_ptrace.c b/libc/calls/sys_ptrace.c
index 21cfda437..3121e0bc3 100644
--- a/libc/calls/sys_ptrace.c
+++ b/libc/calls/sys_ptrace.c
@@ -19,9 +19,9 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 
 #define IsPeek(request) (IsLinux() && (request) - 1u < 3)
diff --git a/libc/calls/syscall-nt.internal.h b/libc/calls/syscall-nt.internal.h
index 70fa3b41d..dafbf18ea 100644
--- a/libc/calls/syscall-nt.internal.h
+++ b/libc/calls/syscall-nt.internal.h
@@ -2,9 +2,11 @@
 #define COSMOPOLITAN_LIBC_CALLS_SYSCALL_NT_INTERNAL_H_
 COSMOPOLITAN_C_START_
 
+extern int sys_getppid_nt_cosmo;
+extern int sys_getppid_nt_win32;
+
 bool32 sys_isatty(int);
 int sys_chdir_nt(const char *);
-int sys_close_epoll_nt(int);
 int sys_dup_nt(int, int, int, int);
 int sys_execve_nt(const char *, char *const[], char *const[]);
 int sys_faccessat_nt(int, const char *, int, uint32_t);
@@ -38,6 +40,7 @@ int sys_unlinkat_nt(int, const char *, int);
 int64_t sys_lseek_nt(int, int64_t, int);
 ssize_t sys_read_nt_impl(int, void *, size_t, int64_t);
 ssize_t sys_readlinkat_nt(int, const char *, char *, size_t);
+void sys_getppid_nt_wipe(int, int);
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_CALLS_SYSCALL_NT_INTERNAL_H_ */
diff --git a/libc/calls/syscall-sysv.internal.h b/libc/calls/syscall-sysv.internal.h
index e976e42ed..551f3e4a5 100644
--- a/libc/calls/syscall-sysv.internal.h
+++ b/libc/calls/syscall-sysv.internal.h
@@ -136,8 +136,7 @@ u32 sys_getuid(void);
 u32 sys_umask(u32);
 unsigned long _sysret(unsigned long);
 void *__sys_mmap(void *, u64, u32, u32, i64, i64, i64);
-void *__sys_mremap(void *, u64, u64, i32, void *);
-void *sys_mremap(void *, u64, u64, i32, void *);
+void *sys_mremap(void *, u64, u64, u64, u64);
 void sys_exit(i32);
 
 #undef i32
diff --git a/libc/calls/syscall_support-nt.internal.h b/libc/calls/syscall_support-nt.internal.h
index a002ef9e3..7b0ced2d3 100644
--- a/libc/calls/syscall_support-nt.internal.h
+++ b/libc/calls/syscall_support-nt.internal.h
@@ -4,6 +4,8 @@
 #include "libc/nt/struct/overlapped.h"
 COSMOPOLITAN_C_START_
 
+#define POLL_INTERVAL_MS 10
+
 bool isdirectory_nt(const char *);
 bool isregularfile_nt(const char *);
 bool issymlink_nt(const char *);
diff --git a/libc/calls/sysinfo.c b/libc/calls/sysinfo.c
index 5f5fc832f..e67de5921 100644
--- a/libc/calls/sysinfo.c
+++ b/libc/calls/sysinfo.c
@@ -22,8 +22,8 @@
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timeval.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/tcdrain.c b/libc/calls/tcdrain.c
index c172d4027..1e4dc4522 100644
--- a/libc/calls/tcdrain.c
+++ b/libc/calls/tcdrain.c
@@ -18,13 +18,13 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/tcflow.c b/libc/calls/tcflow.c
index 6543319c3..512de21bd 100644
--- a/libc/calls/tcflow.c
+++ b/libc/calls/tcflow.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/metatermios.internal.h"
 #include "libc/calls/struct/termios.h"
 #include "libc/calls/syscall-sysv.internal.h"
@@ -25,7 +25,7 @@
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/mem/alloca.h"
 #include "libc/nt/comms.h"
 #include "libc/sysv/consts/termios.h"
diff --git a/libc/calls/tcflush.c b/libc/calls/tcflush.c
index cfa4bd9a1..e9a171b20 100644
--- a/libc/calls/tcflush.c
+++ b/libc/calls/tcflush.c
@@ -17,7 +17,6 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
@@ -25,7 +24,8 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/strace.h"
 #include "libc/mem/alloca.h"
 #include "libc/nt/comms.h"
 #include "libc/nt/console.h"
@@ -52,6 +52,7 @@ static const char *DescribeFlush(char buf[12], int action) {
 }
 
 static dontinline textwindows int sys_tcflush_nt(int fd, int queue) {
+#ifdef __x86_64__
   if (!sys_isatty(fd)) {
     return -1;  // ebadf, enotty
   }
@@ -59,6 +60,9 @@ static dontinline textwindows int sys_tcflush_nt(int fd, int queue) {
     return 0;  // windows console output is never buffered
   }
   return FlushConsoleInputBytes();
+#else
+  return enosys();
+#endif
 }
 
 /**
diff --git a/libc/calls/tcgetattr-nt.c b/libc/calls/tcgetattr-nt.c
index bf4262ebf..8e4c72945 100644
--- a/libc/calls/tcgetattr-nt.c
+++ b/libc/calls/tcgetattr-nt.c
@@ -18,10 +18,10 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/termios.h"
 #include "libc/calls/syscall-nt.internal.h"
-#include "libc/intrin/nomultics.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/nomultics.h"
 #include "libc/nt/console.h"
 #include "libc/nt/enum/consolemodeflags.h"
 #include "libc/str/str.h"
@@ -58,32 +58,34 @@ textwindows int tcgetattr_nt(int fd, struct termios *tio) {
   // kNtEnableLineInput and kNtEnableEchoInput only apply to programs
   // that call ReadFile() or ReadConsole(). since we do not use them,
   // the flags could serve the purpose of inter-process communication
-  if ((inmode & kNtEnableLineInput) || !(__ttyconf.magic & kTtyUncanon)) {
+  if ((inmode & kNtEnableLineInput) || !(__ttyconf.magic & kTtyUncanon))
     tio->c_lflag |= ICANON;
-  }
+
   // kNtEnableEchoInput only works with kNtEnableLineInput enabled.
-  if ((inmode & kNtEnableEchoInput) || !(__ttyconf.magic & kTtySilence)) {
+  if ((inmode & kNtEnableEchoInput) || !(__ttyconf.magic & kTtySilence))
     tio->c_lflag |= ECHO;
-  }
+
   // The Windows console itself always echos control codes as ASCII.
-  if ((inmode & kNtEnableEchoInput) || !(__ttyconf.magic & kTtyEchoRaw)) {
+  if (!(__ttyconf.magic & kTtyEchoRaw))
     tio->c_lflag |= ECHOCTL;
-  }
-  if (!(__ttyconf.magic & kTtyNoCr2Nl)) {
+
+  if (!(__ttyconf.magic & kTtyNoEchoe))
+    tio->c_lflag |= ECHOE;
+  if (!(__ttyconf.magic & kTtyNoEchok))
+    tio->c_lflag |= ECHOK;
+  if (!(__ttyconf.magic & kTtyNoEchoke))
+    tio->c_lflag |= ECHOKE;
+
+  if (!(__ttyconf.magic & kTtyNoCr2Nl))
     tio->c_iflag |= ICRNL;
-  }
-  if (!(__ttyconf.magic & kTtyNoIsigs)) {
+  if (!(__ttyconf.magic & kTtyNoIsigs))
     tio->c_lflag |= ISIG;
-  }
-  if (inmode & kNtEnableProcessedInput) {
+  if (!(__ttyconf.magic & kTtyNoIexten))
     tio->c_lflag |= IEXTEN;
-  }
-  if (outmode & kNtEnableProcessedOutput) {
+  if (outmode & kNtEnableProcessedOutput)
     tio->c_oflag |= OPOST;
-  }
-  if (!(outmode & kNtDisableNewlineAutoReturn)) {
+  if (!(outmode & kNtDisableNewlineAutoReturn))
     tio->c_oflag |= OPOST | ONLCR;
-  }
 
   return 0;
 }
diff --git a/libc/calls/tcgetattr.c b/libc/calls/tcgetattr.c
index e22e0c780..4c2f116eb 100644
--- a/libc/calls/tcgetattr.c
+++ b/libc/calls/tcgetattr.c
@@ -24,7 +24,7 @@
 #include "libc/calls/termios.internal.h"
 #include "libc/calls/ttydefaults.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/tcgetpgrp.c b/libc/calls/tcgetpgrp.c
index f6a6ade21..2f996c9d6 100644
--- a/libc/calls/tcgetpgrp.c
+++ b/libc/calls/tcgetpgrp.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/console.h"
 #include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/tcgetsid.c b/libc/calls/tcgetsid.c
index 147cfacde..77c9617f5 100644
--- a/libc/calls/tcgetsid.c
+++ b/libc/calls/tcgetsid.c
@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 #define TIOCGSID (IsLinux() ? 0x5429 : 0x40047463)
diff --git a/libc/calls/tcgetwinsize.c b/libc/calls/tcgetwinsize.c
index 6ed585a47..ad1bd76e6 100644
--- a/libc/calls/tcgetwinsize.c
+++ b/libc/calls/tcgetwinsize.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/tcsendbreak.c b/libc/calls/tcsendbreak.c
index 9e6e3b55b..f00ef83db 100644
--- a/libc/calls/tcsendbreak.c
+++ b/libc/calls/tcsendbreak.c
@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/comms.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/tcsetattr-nt.c b/libc/calls/tcsetattr-nt.c
index b0f49e803..984ff48ec 100644
--- a/libc/calls/tcsetattr-nt.c
+++ b/libc/calls/tcsetattr-nt.c
@@ -18,11 +18,11 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/termios.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/ttydefaults.h"
-#include "libc/intrin/nomultics.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/nomultics.h"
 #include "libc/nt/console.h"
 #include "libc/nt/enum/consolemodeflags.h"
 #include "libc/str/str.h"
@@ -61,40 +61,50 @@ textwindows int tcsetattr_nt(int fd, int opt, const struct termios *tio) {
     inmode &= ~kNtEnableQuickEditMode;
     __ttyconf.magic |= kTtyUncanon;
   }
-  if (!(tio->c_iflag & ICRNL)) {
+  if (!(tio->c_iflag & ICRNL))
     __ttyconf.magic |= kTtyNoCr2Nl;
-  }
-  if (!(tio->c_lflag & ECHOCTL)) {
+
+  if (!(tio->c_lflag & ECHOE))
+    __ttyconf.magic |= kTtyNoEchoe;
+  if (!(tio->c_lflag & ECHOK))
+    __ttyconf.magic |= kTtyNoEchok;
+  if (!(tio->c_lflag & ECHOKE))
+    __ttyconf.magic |= kTtyNoEchoke;
+  if (!(tio->c_lflag & ECHOCTL))
     __ttyconf.magic |= kTtyEchoRaw;
-  }
+
   if (tio->c_lflag & ECHO) {
     // "kNtEnableEchoInput can be used only if the
     //  kNtEnableLineInput mode is also enabled." -MSDN
-    if (tio->c_lflag & ICANON) {
+    if (tio->c_lflag & ICANON)
       inmode |= kNtEnableEchoInput;
-    }
   } else {
     __ttyconf.magic |= kTtySilence;
   }
-  if (!(tio->c_lflag & ISIG)) {
+
+  if (!(tio->c_lflag & ISIG))
     __ttyconf.magic |= kTtyNoIsigs;
-  }
+
+  // IEXTEN enables implementation-defined input processing. This flag,
+  // as well as ICANON must be enabled for the special characters EOL2,
+  // LNEXT, REPRINT, WERASE to be interpreted.
+  if (!(tio->c_lflag & IEXTEN))
+    __ttyconf.magic |= kTtyNoIexten;
+
   memcpy(__ttyconf.c_cc, tio->c_cc, NCCS);
-  if ((tio->c_lflag & ISIG) &&     //
-      !(tio->c_lflag & ICANON) &&  //
-      __ttyconf.vintr == CTRL('C')) {
+
+  if ((tio->c_lflag & ISIG) && __ttyconf.vintr == CTRL('C'))
     // allows ctrl-c to be delivered asynchronously via win32
     // we normally don't want win32 doing this 24/7 in the bg
     // because we don't have job control, tcsetpgrp, etc. yet
     // it's normally much better to let read-nt.c raise a sig
-    // because read-nt only manages your tty whilst it's used
+    // because read-nt only manages your tty while it is used
     inmode |= kNtEnableProcessedInput;
-  }
+
   outmode &= ~kNtDisableNewlineAutoReturn;
   outmode |= kNtEnableProcessedOutput;
-  if (!(tio->c_oflag & ONLCR)) {
+  if (!(tio->c_oflag & ONLCR))
     outmode |= kNtDisableNewlineAutoReturn;
-  }
   outmode |= kNtEnableVirtualTerminalProcessing;
 
   // tune the win32 configuration
diff --git a/libc/calls/tcsetattr.c b/libc/calls/tcsetattr.c
index db59486db..030e42790 100644
--- a/libc/calls/tcsetattr.c
+++ b/libc/calls/tcsetattr.c
@@ -24,7 +24,7 @@
 #include "libc/calls/termios.internal.h"
 #include "libc/dce.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/mem/alloca.h"
 #include "libc/sysv/consts/termios.h"
diff --git a/libc/calls/tcsetpgrp.c b/libc/calls/tcsetpgrp.c
index eafe3ab2b..ba88f1422 100644
--- a/libc/calls/tcsetpgrp.c
+++ b/libc/calls/tcsetpgrp.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/console.h"
 #include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/tcsetsid.c b/libc/calls/tcsetsid.c
index de7e241ef..59f6052a5 100644
--- a/libc/calls/tcsetsid.c
+++ b/libc/calls/tcsetsid.c
@@ -20,7 +20,7 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/tcsetwinsize.c b/libc/calls/tcsetwinsize.c
index a8503ca68..7c0e6bd2c 100644
--- a/libc/calls/tcsetwinsize.c
+++ b/libc/calls/tcsetwinsize.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/time.c b/libc/calls/time.c
index d592bc256..f0455d2b5 100644
--- a/libc/calls/time.c
+++ b/libc/calls/time.c
@@ -16,10 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/time.h"
-#include "libc/calls/struct/timeval.h"
-#include "libc/dce.h"
-#include "libc/sysv/errfuns.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/sysv/consts/clock.h"
 
 /**
  * Returns time as seconds from UNIX epoch.
@@ -29,15 +28,11 @@
  * @asyncsignalsafe
  */
 int64_t time(int64_t *opt_out_ret) {
-  int64_t secs;
-  struct timeval tv;
-  if (gettimeofday(&tv, 0) != -1) {
-    secs = tv.tv_sec;
-    if (opt_out_ret) {
-      *opt_out_ret = secs;
-    }
-  } else {
-    secs = -1;
-  }
+  int64_t secs = -1;
+  struct timespec ts;
+  if (!clock_gettime(CLOCK_REALTIME, &ts))
+    secs = ts.tv_sec;
+  if (opt_out_ret)
+    *opt_out_ret = secs;
   return secs;
 }
diff --git a/libc/calls/timespec_mono.c b/libc/calls/timespec_mono.c
index 044a3edfd..4ca4fd2e7 100644
--- a/libc/calls/timespec_mono.c
+++ b/libc/calls/timespec_mono.c
@@ -29,6 +29,6 @@
  */
 struct timespec timespec_mono(void) {
   struct timespec ts;
-  npassert(!clock_gettime(CLOCK_MONOTONIC, &ts));
+  unassert(!clock_gettime(CLOCK_MONOTONIC, &ts));
   return ts;
 }
diff --git a/libc/calls/timespec_real.c b/libc/calls/timespec_real.c
index 59a5c8a80..81f6ed84b 100644
--- a/libc/calls/timespec_real.c
+++ b/libc/calls/timespec_real.c
@@ -16,7 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/sysv/consts/clock.h"
 
@@ -31,6 +30,6 @@
  */
 struct timespec timespec_real(void) {
   struct timespec ts;
-  unassert(!clock_gettime(CLOCK_REALTIME, &ts));
+  clock_gettime(CLOCK_REALTIME, &ts);
   return ts;
 }
diff --git a/libc/calls/timespec_sleep.c b/libc/calls/timespec_sleep.c
index 30cb9c52f..41d56a3fb 100644
--- a/libc/calls/timespec_sleep.c
+++ b/libc/calls/timespec_sleep.c
@@ -34,19 +34,16 @@
  * @return unslept time which may be non-zero if the call was interrupted
  * @cancelationpoint
  */
-struct timespec timespec_sleep(struct timespec delay) {
+struct timespec timespec_sleep(int clock, struct timespec delay) {
   int cs = -1;
   errno_t err;
   struct timespec remain;
   remain = timespec_zero;
-  if (_pthread_self()->pt_flags & PT_MASKED) {
+  if (_pthread_self()->pt_flags & PT_MASKED)
     cs = _pthread_block_cancelation();
-  }
-  if ((err = clock_nanosleep(CLOCK_REALTIME, 0, &delay, &remain))) {
+  if ((err = clock_nanosleep(clock, 0, &delay, &remain)))
     unassert(err == EINTR);
-  }
-  if (cs != -1) {
+  if (cs != -1)
     _pthread_allow_cancelation(cs);
-  }
   return remain;
 }
diff --git a/libc/calls/timespec_sleep_until.c b/libc/calls/timespec_sleep_until.c
index 867268b96..5749d39f8 100644
--- a/libc/calls/timespec_sleep_until.c
+++ b/libc/calls/timespec_sleep_until.c
@@ -30,9 +30,9 @@
  * @raise EINTR if signal was delivered
  * @cancelationpoint
  */
-errno_t timespec_sleep_until(struct timespec abs_deadline) {
+errno_t timespec_sleep_until(int clock, struct timespec abs_deadline) {
   errno_t rc;
-  rc = clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &abs_deadline, 0);
+  rc = clock_nanosleep(clock, TIMER_ABSTIME, &abs_deadline, 0);
   unassert(!rc || rc == EINTR || rc == ECANCELED);
   return rc;
 }
diff --git a/libc/calls/tinyprint.c b/libc/calls/tinyprint.c
index 55aec26ef..2411d9b20 100644
--- a/libc/calls/tinyprint.c
+++ b/libc/calls/tinyprint.c
@@ -62,6 +62,7 @@ ssize_t tinyprint(int fd, const char *s, ...) {
       buf[n++] = c;
       if (n == sizeof(buf)) {
         if (tinyflush(fd, buf, n, &toto)) {
+          va_end(va);
           return toto;
         }
         n = 0;
diff --git a/libc/calls/tmpdir.c b/libc/calls/tmpdir.c
index 552467167..946bf2bbf 100644
--- a/libc/calls/tmpdir.c
+++ b/libc/calls/tmpdir.c
@@ -21,7 +21,7 @@
 #include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/systeminfo.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
diff --git a/libc/calls/truncate.c b/libc/calls/truncate.c
index 956fd81fc..756353a13 100644
--- a/libc/calls/truncate.c
+++ b/libc/calls/truncate.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/calls/ttyname_r.c b/libc/calls/ttyname_r.c
index c87d4a99a..4d700a51d 100644
--- a/libc/calls/ttyname_r.c
+++ b/libc/calls/ttyname_r.c
@@ -19,14 +19,14 @@
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/log/log.h"
 #include "libc/nt/console.h"
 #include "libc/nt/enum/consolemodeflags.h"
diff --git a/libc/calls/ucontext.h b/libc/calls/ucontext.h
index b820686bc..b17527c93 100644
--- a/libc/calls/ucontext.h
+++ b/libc/calls/ucontext.h
@@ -168,8 +168,8 @@ struct ucontext {
 
 typedef struct ucontext ucontext_t;
 
-int getcontext(ucontext_t *) dontthrow;
-int setcontext(const ucontext_t *) dontthrow;
+int getcontext(ucontext_t *) dontthrow __read_write(1);
+int setcontext(const ucontext_t *) dontthrow __read_only(1);
 int swapcontext(ucontext_t *, const ucontext_t *) dontthrow returnstwice;
 void makecontext(ucontext_t *, void *, int, ...) dontthrow dontcallback;
 void __sig_restore(const ucontext_t *) wontreturn;
diff --git a/libc/calls/umask.c b/libc/calls/umask.c
index 79f0ea314..29b10e8e3 100644
--- a/libc/calls/umask.c
+++ b/libc/calls/umask.c
@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/nr.h"
 
 /**
diff --git a/libc/calls/uname.c b/libc/calls/uname.c
index e61181f20..0f3f0e2d4 100644
--- a/libc/calls/uname.c
+++ b/libc/calls/uname.c
@@ -25,9 +25,9 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/computernameformat.h"
 #include "libc/nt/systeminfo.h"
 #include "libc/runtime/runtime.h"
diff --git a/libc/calls/unassert.c b/libc/calls/unassert.c
index d7a8ce42d..b44f8a1d8 100644
--- a/libc/calls/unassert.c
+++ b/libc/calls/unassert.c
@@ -21,7 +21,7 @@
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describebacktrace.internal.h"
+#include "libc/intrin/describebacktrace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
 
diff --git a/libc/calls/unlinkat-nt.c b/libc/calls/unlinkat-nt.c
index 536694bd3..a0209ed1c 100644
--- a/libc/calls/unlinkat-nt.c
+++ b/libc/calls/unlinkat-nt.c
@@ -57,15 +57,14 @@ static textwindows bool IsDirectorySymlink(const char16_t *path) {
 static textwindows int sys_rmdir_nt(const char16_t *path) {
   int ms;
   for (ms = 1;; ms *= 2) {
-    if (RemoveDirectory(path)) {
+    if (RemoveDirectory(path))
       return 0;
-    }
     // Files can linger, for absolutely no reason.
     // Possibly some Windows Defender bug on Win7.
     // Sleep for up to one second w/ expo backoff.
     // Alternative is use Microsoft internal APIs.
     // Never could have imagined it'd be this bad.
-    if (GetLastError() == kNtErrorDirNotEmpty && ms <= 2048) {
+    if (GetLastError() == kNtErrorDirNotEmpty && ms <= 1024) {
       Sleep(ms);
       continue;
     } else {
diff --git a/libc/calls/unlinkat.c b/libc/calls/unlinkat.c
index 75ecfdcb9..b23830b59 100644
--- a/libc/calls/unlinkat.c
+++ b/libc/calls/unlinkat.c
@@ -22,8 +22,8 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/consts/s.h"
@@ -39,12 +39,13 @@
  * @param path is the thing to delete
  * @param flags can have AT_REMOVEDIR
  * @return 0 on success, or -1 w/ errno
+ * @raise EROFS if either path is under /zip/...
  */
 int unlinkat(int dirfd, const char *path, int flags) {
   int rc;
 
   if (_weaken(__zipos_notat) && (rc = __zipos_notat(dirfd, path)) == -1) {
-    STRACE("zipos unlinkat not supported yet");
+    rc = erofs();
   } else if (!IsWindows()) {
     rc = sys_unlinkat(dirfd, path, flags);
   } else {
@@ -53,12 +54,13 @@ int unlinkat(int dirfd, const char *path, int flags) {
 
   // POSIX.1 says unlink(directory) raises EPERM but on Linux
   // it always raises EISDIR, which is so much less ambiguous
-  if (!IsLinux() && rc == -1 && !flags && errno == EPERM) {
+  int e = errno;
+  if (!IsLinux() && rc == -1 && !flags && (e == EPERM || e == EACCES)) {
     struct stat st;
     if (!fstatat(dirfd, path, &st, 0) && S_ISDIR(st.st_mode)) {
       errno = EISDIR;
     } else {
-      errno = EPERM;
+      errno = e;
     }
   }
 
diff --git a/libc/calls/unlockpt.c b/libc/calls/unlockpt.c
index 181115065..438a4b955 100644
--- a/libc/calls/unlockpt.c
+++ b/libc/calls/unlockpt.c
@@ -18,12 +18,12 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/calls/termios.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/pty.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/unmount.c b/libc/calls/unmount.c
index db84e4670..e78172bef 100644
--- a/libc/calls/unmount.c
+++ b/libc/calls/unmount.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/mount.h"
 #include "libc/calls/syscall-sysv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Unmounts file system.
diff --git a/libc/calls/unveil.c b/libc/calls/unveil.c
index 57f4cfc28..971c7b2b0 100644
--- a/libc/calls/unveil.c
+++ b/libc/calls/unveil.c
@@ -31,9 +31,9 @@
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/libgen.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/vendor.internal.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
@@ -405,6 +405,15 @@ int sys_unveil_linux(const char *path, const char *permissions) {
  *     - `c` allows `path` to be created and removed, corresponding to
  *       the pledge promise "cpath".
  *
+ * If having unveil() security is mission critical, then add this code
+ * to the start of your main() function to ensure your program fails
+ * with an error if it isn't available.
+ *
+ *     if (unveil("", 0) >= 0) {
+ *       fprintf(stderr, "error: OS doesn't support unveil() security\n");
+ *       exit(1);
+ *     }
+ *
  * @return 0 on success, or -1 w/ errno; note: if `unveil("",0)` is used
  *     to perform a feature check, then on Linux a value greater than 0
  *     shall be returned which is the supported Landlock ABI version
diff --git a/libc/calls/usleep.c b/libc/calls/usleep.c
index 82dd7b55f..b137bfdd1 100644
--- a/libc/calls/usleep.c
+++ b/libc/calls/usleep.c
@@ -34,10 +34,14 @@
  * @norestart
  */
 int usleep(uint64_t micros) {
-  errno_t err;
-  struct timespec ts = timespec_frommicros(micros);
-  err = clock_nanosleep(CLOCK_REALTIME, 0, &ts, 0);
-  if (err)
-    return errno = err, -1;
+  // All OSes except OpenBSD return instantly on usleep(0). So we might
+  // as well avoid system call overhead and helping OpenBSD work better
+  if (micros) {
+    errno_t err;
+    struct timespec ts = timespec_frommicros(micros);
+    err = clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, 0);
+    if (err)
+      return errno = err, -1;
+  }
   return 0;
 }
diff --git a/libc/calls/utimens.c b/libc/calls/utimens.c
index 333b49432..c768d5235 100644
--- a/libc/calls/utimens.c
+++ b/libc/calls/utimens.c
@@ -23,8 +23,8 @@
 #include "libc/calls/struct/timeval.internal.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sysv/consts/at.h"
diff --git a/libc/calls/utimensat.c b/libc/calls/utimensat.c
index adac0714e..a8065a1a1 100644
--- a/libc/calls/utimensat.c
+++ b/libc/calls/utimensat.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/calls/utimes.c b/libc/calls/utimes.c
index 7f863fd3e..a5dd2f66c 100644
--- a/libc/calls/utimes.c
+++ b/libc/calls/utimes.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/struct/timeval.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/at.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/calls/vdsofunc.greg.c b/libc/calls/vdsofunc.greg.c
deleted file mode 100644
index 69b2f774d..000000000
--- a/libc/calls/vdsofunc.greg.c
+++ /dev/null
@@ -1,153 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/dce.h"
-#include "libc/elf/def.h"
-#include "libc/elf/scalar.h"
-#include "libc/elf/struct/ehdr.h"
-#include "libc/elf/struct/phdr.h"
-#include "libc/elf/struct/shdr.h"
-#include "libc/elf/struct/sym.h"
-#include "libc/elf/struct/verdaux.h"
-#include "libc/elf/struct/verdef.h"
-#include "libc/intrin/getauxval.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/runtime/runtime.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/auxv.h"
-
-// needed to avoid asan restrictions on strcmp
-static int StrCmp(const char *l, const char *r) {
-  size_t i = 0;
-  while (l[i] == r[i] && r[i])
-    ++i;
-  return (l[i] & 255) - (r[i] & 255);
-}
-
-static inline int CheckDsoSymbolVersion(Elf64_Verdef *vd, int sym,
-                                        const char *name, char *strtab) {
-  Elf64_Verdaux *aux;
-  for (;; vd = (Elf64_Verdef *)((char *)vd + vd->vd_next)) {
-    if (!(vd->vd_flags & VER_FLG_BASE) &&
-        (vd->vd_ndx & 0x7fff) == (sym & 0x7fff)) {
-      aux = (Elf64_Verdaux *)((char *)vd + vd->vd_aux);
-      return !StrCmp(name, strtab + aux->vda_name);
-    }
-    if (!vd->vd_next) {
-      return 0;
-    }
-  }
-}
-
-/**
- * Returns address of "Virtual Dynamic Shared Object" function on Linux.
- */
-void *__vdsosym(const char *version, const char *name) {
-  void *p;
-  size_t i;
-  Elf64_Ehdr *ehdr;
-  Elf64_Phdr *phdr;
-  char *strtab = 0;
-  size_t *dyn, base;
-  Elf64_Sym *symtab = 0;
-  uint16_t *versym = 0;
-  Elf_Symndx *hashtab = 0;
-  Elf64_Verdef *verdef = 0;
-  struct AuxiliaryValue av;
-
-  av = __getauxval(AT_SYSINFO_EHDR);
-  if (!av.isfound) {
-    KERNTRACE("__vdsosym() → missing AT_SYSINFO_EHDR");
-    return 0;
-  }
-
-  ehdr = (void *)av.value;
-  phdr = (void *)((char *)ehdr + ehdr->e_phoff);
-  for (base = -1, dyn = 0, i = 0; i < ehdr->e_phnum;
-       i++, phdr = (void *)((char *)phdr + ehdr->e_phentsize)) {
-    switch (phdr->p_type) {
-      case PT_LOAD:
-        // modern linux uses the base address zero, but elders
-        // e.g. rhel7 uses the base address 0xffffffffff700000
-        base = (size_t)ehdr + phdr->p_offset - phdr->p_vaddr;
-        break;
-      case PT_DYNAMIC:
-        dyn = (void *)((char *)ehdr + phdr->p_offset);
-        break;
-      default:
-        break;
-    }
-  }
-  if (!dyn || base == -1) {
-    KERNTRACE("__vdsosym() → missing program headers");
-    return 0;
-  }
-
-  for (i = 0; dyn[i]; i += 2) {
-    p = (void *)(base + dyn[i + 1]);
-    switch (dyn[i]) {
-      case DT_STRTAB:
-        strtab = p;
-        break;
-      case DT_SYMTAB:
-        symtab = p;
-        break;
-      case DT_HASH:
-        hashtab = p;
-        break;
-      case DT_VERSYM:
-        versym = p;
-        break;
-      case DT_VERDEF:
-        verdef = p;
-        break;
-    }
-  }
-  if (!strtab || !symtab || !hashtab) {
-    KERNTRACE("__vdsosym() → tables not found");
-    return 0;
-  }
-  if (!verdef) {
-    versym = 0;
-  }
-
-  for (i = 0; i < hashtab[1]; i++) {
-    if (ELF64_ST_TYPE(symtab[i].st_info) != STT_FUNC &&
-        ELF64_ST_TYPE(symtab[i].st_info) != STT_OBJECT &&
-        ELF64_ST_TYPE(symtab[i].st_info) != STT_NOTYPE) {
-      continue;
-    }
-    if (ELF64_ST_BIND(symtab[i].st_info) != STB_GLOBAL) {
-      continue;
-    }
-    if (!symtab[i].st_shndx) {
-      continue;
-    }
-    if (StrCmp(name, strtab + symtab[i].st_name)) {
-      continue;
-    }
-    if (versym && !CheckDsoSymbolVersion(verdef, versym[i], version, strtab)) {
-      continue;
-    }
-    return (void *)(base + symtab[i].st_value);
-  }
-
-  KERNTRACE("__vdsosym() → symbol not found");
-  return 0;
-}
diff --git a/libc/calls/winexec.c b/libc/calls/winexec.c
index cdb41dd72..429589c10 100644
--- a/libc/calls/winexec.c
+++ b/libc/calls/winexec.c
@@ -24,7 +24,7 @@
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/overlapped.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "third_party/linenoise/linenoise.h"
 
 #define Read32(s) (s[3] << 24 | s[2] << 16 | s[1] << 8 | s[0])
@@ -80,7 +80,8 @@ textwindows int IsWindowsExecutable(int64_t handle, const char16_t *path) {
   uint32_t got;
   BLOCK_SIGNALS;
   struct NtOverlapped overlap = {.hEvent = CreateEvent(0, 0, 0, 0)};
-  ok = (ReadFile(handle, buf, 2, 0, &overlap) ||
+  ok = overlap.hEvent &&
+       (ReadFile(handle, buf, 2, 0, &overlap) ||
         GetLastError() == kNtErrorIoPending) &&
        GetOverlappedResult(handle, &overlap, &got, true);
   CloseHandle(overlap.hEvent);
diff --git a/libc/calls/write-nt.c b/libc/calls/write-nt.c
index edea79f9f..cbd721483 100644
--- a/libc/calls/write-nt.c
+++ b/libc/calls/write-nt.c
@@ -18,7 +18,6 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
@@ -26,7 +25,8 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/nomultics.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/nomultics.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/console.h"
 #include "libc/nt/enum/consolemodeflags.h"
@@ -53,20 +53,17 @@ static textwindows ssize_t sys_write_nt_impl(int fd, void *data, size_t size,
   bool isconsole = f->kind == kFdConsole;
 
   // not implemented, XNU returns eperm();
-  if (f->kind == kFdDevRandom) {
+  if (f->kind == kFdDevRandom)
     return eperm();
-  }
 
   // determine win32 handle for writing
   int64_t handle = f->handle;
-  if (isconsole && _weaken(GetConsoleOutputHandle)) {
+  if (isconsole && _weaken(GetConsoleOutputHandle))
     handle = _weaken(GetConsoleOutputHandle)();
-  }
 
   // intercept ansi tty configuration sequences
-  if (isconsole && _weaken(GetConsoleOutputHandle)) {
+  if (isconsole && _weaken(GetConsoleOutputHandle))
     _weaken(InterceptTerminalCommands)(data, size);
-  }
 
   // perform heavy lifting
   ssize_t rc;
diff --git a/libc/calls/write.c b/libc/calls/write.c
index 258386df3..bf1d4fa19 100644
--- a/libc/calls/write.c
+++ b/libc/calls/write.c
@@ -22,7 +22,7 @@
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/sock/sock.h"
diff --git a/libc/calls/writev-metal.c b/libc/calls/writev-metal.c
index a3e87c6cd..d028e5f83 100644
--- a/libc/calls/writev-metal.c
+++ b/libc/calls/writev-metal.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/intrin/weaken.h"
diff --git a/libc/calls/writev-serial.c b/libc/calls/writev-serial.c
index c896fec31..9c5822d7b 100644
--- a/libc/calls/writev-serial.c
+++ b/libc/calls/writev-serial.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/nexgen32e/uart.internal.h"
diff --git a/libc/calls/writev.c b/libc/calls/writev.c
index 42d141461..5e8899e14 100644
--- a/libc/calls/writev.c
+++ b/libc/calls/writev.c
@@ -22,9 +22,9 @@
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
 #include "libc/runtime/stack.h"
@@ -57,6 +57,7 @@ static ssize_t writev_impl(int fd, const struct iovec *iov, int iovlen) {
       struct iovec *iov2;
 #pragma GCC push_options
 #pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
       iov2 = alloca(iovlen * sizeof(struct iovec));
       CheckLargeStackAllocation(iov2, iovlen * sizeof(struct iovec));
 #pragma GCC pop_options
diff --git a/libc/cosmo.h b/libc/cosmo.h
index 9788bb3ca..e91621e48 100644
--- a/libc/cosmo.h
+++ b/libc/cosmo.h
@@ -1,13 +1,41 @@
 #ifndef COSMOPOLITAN_LIBC_COSMO_H_
 #define COSMOPOLITAN_LIBC_COSMO_H_
+#include "libc/calls/struct/timespec.h"
 COSMOPOLITAN_C_START_
 
-errno_t cosmo_once(_Atomic(unsigned) *, void (*)(void)) libcesque;
+#ifndef __cplusplus
+#define _COSMO_ATOMIC(x) _Atomic(x)
+#else
+#define _COSMO_ATOMIC(x) x
+#endif
+
+errno_t cosmo_once(_COSMO_ATOMIC(unsigned) *, void (*)(void));
 int systemvpe(const char *, char *const[], char *const[]) libcesque;
 char *GetProgramExecutableName(void) libcesque;
 void unleaf(void) libcesque;
+bool32 IsLinuxModern(void) libcesque;
+
 int __demangle(char *, const char *, size_t) libcesque;
 int __is_mangled(const char *) libcesque;
 
+int cosmo_args(const char *, char ***) libcesque;
+int LoadZipArgs(int *, char ***) libcesque;
+
+int cosmo_futex_wake(_COSMO_ATOMIC(int) *, int, char);
+int cosmo_futex_wait(_COSMO_ATOMIC(int) *, int, char, int,
+                     const struct timespec *);
+
+errno_t cosmo_stack_alloc(size_t *, size_t *, void **) libcesque;
+errno_t cosmo_stack_free(void *, size_t, size_t) libcesque;
+void cosmo_stack_clear(void) libcesque;
+void cosmo_stack_setmaxstacks(int) libcesque;
+int cosmo_stack_getmaxstacks(void) libcesque;
+
+int __deadlock_check(void *, int) libcesque;
+int __deadlock_tracked(void *) libcesque;
+void __deadlock_record(void *, int) libcesque;
+void __deadlock_track(void *, int) libcesque;
+void __deadlock_untrack(void *) libcesque;
+
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_COSMO_H_ */
diff --git a/libc/crt/crt.S b/libc/crt/crt.S
index b5ba61a59..74226c641 100644
--- a/libc/crt/crt.S
+++ b/libc/crt/crt.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .section .start,"ax",@progbits
 
 #if SupportsXnu() && defined(__x86_64__)
@@ -47,7 +47,14 @@ __oops_win32:
 //	@note	ape.S and ape-loader both set RCX to XNU on Darwin
 //	@noreturn
 _start:
-#ifdef __x86_64__
+	.cfi_startproc
+#if defined(__x86_64__)
+	.cfi_undefined rip
+#elif defined(__aarch64__)
+	.cfi_undefined x30
+#endif /* __x86_64__ */
+
+#if defined(__x86_64__)
 
 #if SupportsFreebsd()
 //	detect free besiyata dishmaya
@@ -159,4 +166,5 @@ _start:
 #else
 #error "architecture unsupported"
 #endif /* __x86_64__ */
+	.cfi_endproc
 	.endfn	_start,weak,hidden
diff --git a/libc/ctype.h b/libc/ctype.h
new file mode 100644
index 000000000..b7fabc097
--- /dev/null
+++ b/libc/ctype.h
@@ -0,0 +1,26 @@
+#ifndef COSMOPOLITAN_CTYPE_H_
+#define COSMOPOLITAN_CTYPE_H_
+COSMOPOLITAN_C_START_
+
+#define _tolower(u) (0040 | (u))
+#define _toupper(u) (0137 & (u))
+
+int isascii(int) libcesque;
+int isspace(int) libcesque;
+int isalpha(int) libcesque;
+int isdigit(int) libcesque;
+int isalnum(int) libcesque;
+int isxdigit(int) libcesque;
+int isprint(int) libcesque;
+int islower(int) libcesque;
+int isupper(int) libcesque;
+int isblank(int) libcesque;
+int iscntrl(int) libcesque;
+int isgraph(int) libcesque;
+int tolower(int) libcesque;
+int ispunct(int) libcesque;
+int toupper(int) libcesque;
+int toascii(int) libcesque;
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_CTYPE_H_ */
diff --git a/libc/dlopen/dlopen.c b/libc/dlopen/dlopen.c
index c5cb457ba..2a47aa99e 100644
--- a/libc/dlopen/dlopen.c
+++ b/libc/dlopen/dlopen.c
@@ -38,7 +38,7 @@
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/nt/dll.h"
 #include "libc/nt/enum/filemapflags.h"
@@ -57,6 +57,7 @@
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/temp.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 
@@ -131,24 +132,23 @@ struct {
 
 long __sysv2nt14();
 long foreign_tramp();
+void __dlopen_lock(void);
+void __dlopen_unlock(void);
 
 static _Thread_local char dlerror_buf[128];
 
 static const char *get_tmp_dir(void) {
   const char *tmpdir;
-  if (!(tmpdir = getenv("TMPDIR")) || !*tmpdir) {
-    if (!(tmpdir = getenv("HOME")) || !*tmpdir) {
+  if (!(tmpdir = getenv("TMPDIR")) || !*tmpdir)
+    if (!(tmpdir = getenv("HOME")) || !*tmpdir)
       tmpdir = ".";
-    }
-  }
   return tmpdir;
 }
 
 static int is_file_newer_than(const char *path, const char *other) {
   struct stat st1, st2;
-  if (stat(path, &st1)) {
+  if (stat(path, &st1))
     return -1;
-  }
   if (stat(other, &st2)) {
     if (errno == ENOENT) {
       return 2;
@@ -191,29 +191,24 @@ static char *elf_map(int fd, Elf64_Ehdr *ehdr, Elf64_Phdr *phdr, long pagesz,
   Elf64_Addr maxva = 0;
   Elf64_Addr minva = -1;
   for (Elf64_Phdr *p = phdr; p < phdr + ehdr->e_phnum; p++) {
-    if (p->p_type != PT_LOAD) {
+    if (p->p_type != PT_LOAD)
       continue;
-    }
-    if (p->p_vaddr < minva) {
+    if (p->p_vaddr < minva)
       minva = p->p_vaddr & -pagesz;
-    }
-    if (p->p_vaddr + p->p_memsz > maxva) {
+    if (p->p_vaddr + p->p_memsz > maxva)
       maxva = p->p_vaddr + p->p_memsz;
-    }
   }
   uint8_t *base =
       __sys_mmap(0, maxva - minva, PROT_NONE,
                  MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0, 0);
-  if (base == MAP_FAILED) {
+  if (base == MAP_FAILED)
     return MAP_FAILED;
-  }
   for (Elf64_Phdr *p = phdr; p < phdr + ehdr->e_phnum; p++) {
     if (p->p_type != PT_LOAD) {
       if (p->p_type == PT_INTERP && interp_size &&
           (p->p_filesz >= interp_size - 1 ||
-           pread(fd, interp_path, p->p_filesz, p->p_offset) != p->p_filesz)) {
+           pread(fd, interp_path, p->p_filesz, p->p_offset) != p->p_filesz))
         return MAP_FAILED;
-      }
       continue;
     }
     Elf64_Addr skew = p->p_vaddr & (pagesz - 1);
@@ -228,29 +223,24 @@ static char *elf_map(int fd, Elf64_Ehdr *ehdr, Elf64_Phdr *phdr, long pagesz,
       prot1 &= ~PROT_EXEC;
     }
     if (__sys_mmap(base + p->p_vaddr - skew, skew + p->p_filesz, prot1,
-                   MAP_FIXED | MAP_PRIVATE, fd, off, off) == MAP_FAILED) {
+                   MAP_FIXED | MAP_PRIVATE, fd, off, off) == MAP_FAILED)
       return MAP_FAILED;
-    }
-    if (b > a) {
+    if (b > a)
       bzero(base + a, b - a);
-    }
     if (c > b && __sys_mmap(base + b, c - b, prot2,
                             MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0,
-                            0) == MAP_FAILED) {
+                            0) == MAP_FAILED)
       return MAP_FAILED;
-    }
     if (prot1 != prot2 &&
-        sys_mprotect(base + p->p_vaddr - skew, skew + p->p_filesz, prot2)) {
+        sys_mprotect(base + p->p_vaddr - skew, skew + p->p_filesz, prot2))
       return MAP_FAILED;
-    }
   }
   return (void *)base;
 }
 
 static bool elf_slurp(struct Loaded *l, int fd, const char *file) {
-  if (pread(fd, &l->eh, 64, 0) != 64) {
+  if (pread(fd, &l->eh, 64, 0) != 64)
     return false;
-  }
   if (!IsElf64Binary(&l->eh, 64) ||                      //
       l->eh.e_phnum > sizeof(l->ph) / sizeof(*l->ph) ||  //
       l->eh.e_machine != get_host_elf_machine()) {
@@ -258,19 +248,17 @@ static bool elf_slurp(struct Loaded *l, int fd, const char *file) {
     return false;
   }
   int bytes = l->eh.e_phnum * sizeof(l->ph[0]);
-  if (pread(fd, l->ph, bytes, l->eh.e_phoff) != bytes) {
+  if (pread(fd, l->ph, bytes, l->eh.e_phoff) != bytes)
     return false;
-  }
   l->entry = (char *)l->eh.e_entry;
   return true;
 }
 
-static dontinline bool elf_load(struct Loaded *l, const char *file, long pagesz,
+dontinline static bool elf_load(struct Loaded *l, const char *file, long pagesz,
                                 char *interp_path, size_t interp_size) {
   int fd;
-  if ((fd = open(file, O_RDONLY | O_CLOEXEC)) == -1) {
+  if ((fd = open(file, O_RDONLY | O_CLOEXEC)) == -1)
     return false;
-  }
   if (!elf_slurp(l, fd, file)) {
     close(fd);
     return false;
@@ -292,7 +280,7 @@ static long *push_strs(long *sp, char **list, int count) {
   return sp;
 }
 
-static wontreturn dontinstrument void foreign_helper(void **p) {
+wontreturn dontinstrument static void foreign_helper(void **p) {
   __foreign.dlopen = p[0];
   __foreign.dlsym = p[1];
   __foreign.dlclose = p[2];
@@ -300,23 +288,21 @@ static wontreturn dontinstrument void foreign_helper(void **p) {
   _longjmp(__foreign.jb, 1);
 }
 
-static dontinline void elf_exec(const char *file, char **envp) {
+dontinline static void elf_exec(const char *file, char **envp) {
 
   // get microprocessor page size
-  long pagesz = getauxval(AT_PAGESZ);
+  long pagesz = __pagesize;
 
   // load helper executable into address space
   struct Loaded prog;
   char interp_path[256] = {0};
-  if (!elf_load(&prog, file, pagesz, interp_path, sizeof(interp_path))) {
+  if (!elf_load(&prog, file, pagesz, interp_path, sizeof(interp_path)))
     return;
-  }
 
   // load platform c library into address space
   struct Loaded interp;
-  if (!elf_load(&interp, interp_path, pagesz, 0, 0)) {
+  if (!elf_load(&interp, interp_path, pagesz, 0, 0))
     return;
-  }
 
   // count environment variables
   int envc = 0;
@@ -426,15 +412,14 @@ static char *dlerror_set(const char *str) {
   return dlerror_buf;
 }
 
-static dontinline char *foreign_alloc_block(void) {
+dontinline static char *foreign_alloc_block(void) {
   char *p = 0;
   size_t sz = 65536;
   if (!IsWindows()) {
     p = __sys_mmap(0, sz, PROT_READ | PROT_WRITE | PROT_EXEC,
                    MAP_PRIVATE | MAP_ANONYMOUS | MAP_JIT, -1, 0, 0);
-    if (p == MAP_FAILED) {
+    if (p == MAP_FAILED)
       p = 0;
-    }
   } else {
     uintptr_t h;
     if ((h = CreateFileMapping(-1, 0, kNtPageExecuteReadwrite, 0, sz, 0))) {
@@ -450,19 +435,16 @@ static dontinline char *foreign_alloc_block(void) {
   return p;
 }
 
-static dontinline void *foreign_alloc(size_t n) {
+dontinline static void *foreign_alloc(size_t n) {
   void *res;
   static char *block;
-  static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
-  pthread_mutex_lock(&lock);
-  if (!block || READ32LE(block) + n > 65536) {
-    if (!(block = foreign_alloc_block())) {
+  __dlopen_lock();
+  if (!block || READ32LE(block) + n > 65536)
+    if (!(block = foreign_alloc_block()))
       return 0;
-    }
-  }
   res = block + READ32LE(block);
   WRITE32LE(block, READ32LE(block) + n);
-  pthread_mutex_unlock(&lock);
+  __dlopen_unlock();
   return res;
 }
 
@@ -470,9 +452,8 @@ static uint8_t *movimm(uint8_t p[static 16], int reg, uint64_t val) {
 #ifdef __x86_64__
   int rex;
   rex = AMD_REXW;
-  if (reg & 8) {
+  if (reg & 8)
     rex |= AMD_REXB;
-  }
   *p++ = rex;
   *p++ = AMD_MOV_IMM | (reg & 7);
   p = WRITE64LE(p, val);
@@ -557,7 +538,9 @@ static void *foreign_thunk_nt(void *func) {
   // movabs $tramp,%r10
   code[14] = 0x49;
   code[15] = 0xba;
+#ifdef __x86_64__
   WRITE64LE(code + 16, (uintptr_t)__sysv2nt14);
+#endif
   // jmp *%r10
   code[24] = 0x41;
   code[25] = 0xff;
@@ -565,14 +548,13 @@ static void *foreign_thunk_nt(void *func) {
   return code;
 }
 
-static dontinline bool foreign_compile(char exe[hasatleast PATH_MAX]) {
+dontinline static bool foreign_compile(char exe[hasatleast PATH_MAX]) {
 
   // construct path
   strlcpy(exe, get_tmp_dir(), PATH_MAX);
   strlcat(exe, "/.cosmo/", PATH_MAX);
-  if (mkdir(exe, 0755) && errno != EEXIST) {
+  if (mkdir(exe, 0755) && errno != EEXIST)
     return false;
-  }
   strlcat(exe, "dlopen-helper", PATH_MAX);
 
   // skip build if helper exists and this program is older
@@ -603,9 +585,8 @@ static dontinline bool foreign_compile(char exe[hasatleast PATH_MAX]) {
       ssize_t got = pread(fd, sauce, sizeof(HELPER), 0);
       close(fd);
       if (got == sizeof(HELPER) - 1 &&
-          !memcmp(sauce, HELPER, sizeof(HELPER) - 1)) {
+          !memcmp(sauce, HELPER, sizeof(HELPER) - 1))
         return true;
-      }
     }
   }
 
@@ -613,9 +594,8 @@ static dontinline bool foreign_compile(char exe[hasatleast PATH_MAX]) {
   char tmp[PATH_MAX];
   strlcpy(tmp, src, PATH_MAX);
   strlcat(tmp, ".XXXXXX", PATH_MAX);
-  if ((fd = mkostemp(tmp, O_CLOEXEC)) == -1) {
+  if ((fd = mkostemp(tmp, O_CLOEXEC)) == -1)
     return false;
-  }
   if (write(fd, HELPER, sizeof(HELPER) - 1) != sizeof(HELPER) - 1) {
     close(fd);
     unlink(tmp);
@@ -633,9 +613,8 @@ static dontinline bool foreign_compile(char exe[hasatleast PATH_MAX]) {
   // create executable
   strlcpy(tmp, exe, PATH_MAX);
   strlcat(tmp, ".XXXXXX", PATH_MAX);
-  if ((fd = mkostemp(tmp, O_CLOEXEC)) == -1) {
+  if ((fd = mkostemp(tmp, O_CLOEXEC)) == -1)
     return false;
-  }
   int pid, ws;
   char *args[] = {
       "cc",
@@ -654,11 +633,11 @@ static dontinline bool foreign_compile(char exe[hasatleast PATH_MAX]) {
     errno = err;
     return false;
   }
-  while (waitpid(pid, &ws, 0) == -1) {
-    if (errno != EINTR) {
-      unlink(tmp);
-      return false;
-    }
+  if (waitpid(pid, &ws, 0) == -1) {
+    // signals and cancelation are blocked
+    // therefore this must be a real error
+    unlink(tmp);
+    return false;
   }
   if (ws) {
     unlink(tmp);
@@ -704,9 +683,8 @@ static void foreign_once(void) {
 static bool foreign_init(void) {
   bool res;
   cosmo_once(&__foreign.once, foreign_once);
-  if (!(res = __foreign.is_supported)) {
+  if (!(res = __foreign.is_supported))
     dlerror_set("dlopen() isn't supported on this platform");
-  }
   return res;
 }
 
@@ -742,9 +720,8 @@ static void *dlopen_nt(const char *path, int mode) {
     path16[n + 0] = 'l';
     path16[n + 1] = 0;
   }
-  if (!(handle = LoadLibrary(path16))) {
+  if (!(handle = LoadLibrary(path16)))
     dlerror_set("library not found");
-  }
   return (void *)handle;
 }
 
@@ -763,18 +740,14 @@ static void *dlopen_silicon(const char *path, int mode) {
   int n;
   int xnu_mode = 0;
   char path2[PATH_MAX + 5];
-  if (mode & ~(RTLD_LOCAL | RTLD_LAZY | RTLD_NOW | RTLD_GLOBAL)) {
+  if (mode & ~(RTLD_LOCAL | RTLD_LAZY | RTLD_NOW | RTLD_GLOBAL))
     xnu_mode = -1;  // punt error to system dlerror() impl
-  }
-  if (!(mode & RTLD_GLOBAL)) {
+  if (!(mode & RTLD_GLOBAL))
     xnu_mode |= XNU_RTLD_LOCAL;  // unlike Linux, XNU defaults to RTLD_GLOBAL
-  }
-  if (mode & RTLD_NOW) {
+  if (mode & RTLD_NOW)
     xnu_mode |= XNU_RTLD_NOW;
-  }
-  if (mode & RTLD_LAZY) {
+  if (mode & RTLD_LAZY)
     xnu_mode |= XNU_RTLD_LAZY;
-  }
   if ((n = strlen(path)) < PATH_MAX && n > 3 &&  //
       path[n - 3] == '.' &&                      //
       path[n - 2] == 's' &&                      //
@@ -837,7 +810,7 @@ void *cosmo_dlopen(const char *path, int mode) {
   }
   ALLOW_CANCELATION;
   ALLOW_SIGNALS;
-  STRACE("dlopen(%#s, %d) → %p% m", path, mode, res);
+  STRACE("cosmo_dlopen(%#s, %d) → %p% m", path, mode, res);
   return res;
 }
 
@@ -882,7 +855,7 @@ void *cosmo_dlsym(void *handle, const char *name) {
   } else {
     func = 0;
   }
-  STRACE("dlsym(%p, %#s) → %p", handle, name, func);
+  STRACE("cosmo_dlsym(%p, %#s) → %p", handle, name, func);
   return func;
 }
 
@@ -917,7 +890,7 @@ int cosmo_dlclose(void *handle) {
   } else {
     res = -1;
   }
-  STRACE("dlclose(%p) → %d", handle, res);
+  STRACE("cosmo_dlclose(%p) → %d", handle, res);
   return res;
 }
 
@@ -936,6 +909,6 @@ char *cosmo_dlerror(void) {
   } else {
     res = dlerror_buf;
   }
-  STRACE("dlerror() → %#s", res);
+  STRACE("cosmo_dlerror() → %#s", res);
   return res;
 }
diff --git a/libc/dlopen/foreign_tramp.S b/libc/dlopen/foreign_tramp.S
index dbd036306..38dc914f1 100644
--- a/libc/dlopen/foreign_tramp.S
+++ b/libc/dlopen/foreign_tramp.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #define SIZE 0x0200
 #define SKEW 0x10
diff --git a/libc/dlopen/stubs.c b/libc/dlopen/stubs.c
index 9a94e891b..357f864f3 100644
--- a/libc/dlopen/stubs.c
+++ b/libc/dlopen/stubs.c
@@ -17,6 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dlopen/dlfcn.h"
+#include "libc/intrin/strace.h"
+
+#define DLOPEN_ERROR \
+  "dlopen() isn't supported; consider using cosmo_dlopen() and read its docs"
 
 /**
  * Opens dynamic shared object using host platform libc.
@@ -27,12 +31,13 @@
  *
  * @return null always
  */
-void *dlopen(const char *, int) {
+void *dlopen(const char *path, int mode) {
+  STRACE("dlopen(%#s, %d) → 0 [%s]", path, mode, DLOPEN_ERROR);
   return 0;
 }
 
 char *dlerror(void) {
-  return "dlopen() isn't supported by cosmo; try using cosmo_dlopen()";
+  return DLOPEN_ERROR;
 }
 
 void *dlsym(void *, const char *) {
@@ -42,7 +47,3 @@ void *dlsym(void *, const char *) {
 int dlclose(void *) {
   return -1;
 }
-
-int dl_iterate_phdr(int (*)(void *, size_t, void *), void *) {
-  return -1;
-}
diff --git a/libc/dos.internal.h b/libc/dos.h
similarity index 100%
rename from libc/dos.internal.h
rename to libc/dos.h
diff --git a/libc/elf/def.h b/libc/elf/def.h
index 913e9c930..04d69985e 100644
--- a/libc/elf/def.h
+++ b/libc/elf/def.h
@@ -68,6 +68,7 @@
 #define EM_NONE      0
 #define EM_M32       1
 #define EM_386       3
+#define EM_MIPS      8
 #define EM_PPC64     21
 #define EM_S390      22
 #define EM_ARM       40
diff --git a/libc/errno.h b/libc/errno.h
index 8a3a04f30..f8963ed98 100644
--- a/libc/errno.h
+++ b/libc/errno.h
@@ -26,11 +26,11 @@ COSMOPOLITAN_C_START_
 /* this header is included by 700+ files; therefore we */
 /* hand-roll &__get_tls()->tib_errno to avoid #include */
 /* cosmopolitan uses x28 as the tls register b/c apple */
-#define errno                                      \
-  (*__extension__({                                \
-    errno_t *__ep;                                 \
-    __asm__("sub\t%0,x28,#512-0x3c" : "=r"(__ep)); \
-    __ep;                                          \
+#define errno                                       \
+  (*__extension__({                                 \
+    errno_t *__ep;                                  \
+    __asm__("sub\t%0,x28,#1024-0x3c" : "=r"(__ep)); \
+    __ep;                                           \
   }))
 #else
 #define errno (*__errno_location())
diff --git a/libc/fmt/BUILD.mk b/libc/fmt/BUILD.mk
index 4114c6ba7..8fdbfeb14 100644
--- a/libc/fmt/BUILD.mk
+++ b/libc/fmt/BUILD.mk
@@ -40,7 +40,7 @@ LIBC_FMT_A_DIRECTDEPS =				\
 	LIBC_STR				\
 	LIBC_SYSV				\
 	LIBC_TINYMATH				\
-	THIRD_PARTY_COMPILER_RT
+	THIRD_PARTY_COMPILER_RT			\
 
 LIBC_FMT_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(LIBC_FMT_A_DIRECTDEPS),$($(x))))
diff --git a/libc/fmt/atoi.c b/libc/fmt/atoi.c
index bca5be980..ac2450add 100644
--- a/libc/fmt/atoi.c
+++ b/libc/fmt/atoi.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/fmt/conv.h"
 #include "libc/str/str.h"
 
diff --git a/libc/fmt/atol.c b/libc/fmt/atol.c
index 5bce5bcac..c922b82d2 100644
--- a/libc/fmt/atol.c
+++ b/libc/fmt/atol.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/fmt/conv.h"
 #include "libc/str/str.h"
 
diff --git a/libc/fmt/bing.c b/libc/fmt/bing.c
index 3ccfb87c6..8280685cb 100644
--- a/libc/fmt/bing.c
+++ b/libc/fmt/bing.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/fmt/bing.internal.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * Turns binary octet into unicode glyph representation.
diff --git a/libc/fmt/internal.h b/libc/fmt/internal.h
index b05b1085b..b82c4b382 100644
--- a/libc/fmt/internal.h
+++ b/libc/fmt/internal.h
@@ -1,6 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_FMT_STRTOL_H_
 #define COSMOPOLITAN_LIBC_FMT_STRTOL_H_
+#include "libc/ctype.h"
 #include "libc/errno.h"
+#include "libc/nt/thunk/msabi.h"
 #include "libc/str/str.h"
 
 #define CONSUME_SPACES(t, s, c) \
@@ -46,6 +48,7 @@
 
 int __vcscanf(int (*)(void *), int (*)(int, void *), void *, const char *,
               va_list);
-int __fmt(void *, void *, const char *, va_list);
+int __fmt(void *, void *, const char *, va_list, int *);
+char16_t *__itoa16(char16_t[21], uint64_t) __msabi;
 
 #endif /* COSMOPOLITAN_LIBC_FMT_STRTOL_H_ */
diff --git a/libc/fmt/itoa64radix16.greg.c b/libc/fmt/itoa64radix16.greg.c
index 25c5e55a9..28555685d 100644
--- a/libc/fmt/itoa64radix16.greg.c
+++ b/libc/fmt/itoa64radix16.greg.c
@@ -19,7 +19,7 @@
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/bsr.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 size_t uint64toarray_radix16(uint64_t x, char b[hasatleast 17]) {
   return uint64toarray_fixed16(x, b, ROUNDUP(x ? bsrl(x) + 1 : 1, 4));
diff --git a/libc/fmt/magnumstrs.internal.h b/libc/fmt/magnumstrs.internal.h
index 77833499c..af1daba81 100644
--- a/libc/fmt/magnumstrs.internal.h
+++ b/libc/fmt/magnumstrs.internal.h
@@ -21,6 +21,7 @@ extern const struct MagnumStr kErrnoDocs[];
 extern const struct MagnumStr kErrnoNames[];
 extern const struct MagnumStr kFcntlCmds[];
 extern const struct MagnumStr kIpOptnames[];
+extern const struct MagnumStr kIpv6Optnames[];
 extern const struct MagnumStr kOpenFlags[];
 extern const struct MagnumStr kRlimitNames[];
 extern const struct MagnumStr kSignalNames[];
@@ -28,7 +29,8 @@ extern const struct MagnumStr kSockOptnames[];
 extern const struct MagnumStr kTcpOptnames[];
 extern const struct MagnumStr kPollNames[];
 
-const char *DescribeMagnum(char *, const struct MagnumStr *, const char *, int);
+const char *_DescribeMagnum(char *, const struct MagnumStr *, const char *,
+                            int);
 
 __funline const char *GetMagnumStr(const struct MagnumStr *ms, int x) {
   int i;
diff --git a/libc/fmt/sizetol.c b/libc/fmt/sizetol.c
index e1828fc9d..e1d8b3107 100644
--- a/libc/fmt/sizetol.c
+++ b/libc/fmt/sizetol.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/fmt/conv.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
diff --git a/libc/fmt/unbing.c b/libc/fmt/unbing.c
index ddee8e828..66ae63d7f 100644
--- a/libc/fmt/unbing.c
+++ b/libc/fmt/unbing.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/bing.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 static const int kCp437i[] = {
     0x000a << 8 | 10,   // \n NEWLINE
diff --git a/libc/fmt/unzleb64.c b/libc/fmt/unzleb64.c
index edc7c71c7..4627da678 100644
--- a/libc/fmt/unzleb64.c
+++ b/libc/fmt/unzleb64.c
@@ -28,7 +28,7 @@
        ░███▓▀                                                    ▀▓▓██▀▀░
         ░▀░                                                         */
 #include "libc/fmt/leb128.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /**
  * Decodes array to signed integer w/ zig-zag encoding.
diff --git a/libc/fmt/wcstol.c b/libc/fmt/wcstol.c
index f95000e1c..ac3037325 100644
--- a/libc/fmt/wcstol.c
+++ b/libc/fmt/wcstol.c
@@ -22,7 +22,7 @@
 #include "libc/limits.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * Decodes signed long integer from wide string.
diff --git a/libc/fmt/wcstoul.c b/libc/fmt/wcstoul.c
index 9085a8000..b953c1366 100644
--- a/libc/fmt/wcstoul.c
+++ b/libc/fmt/wcstoul.c
@@ -22,7 +22,7 @@
 #include "libc/limits.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * Decodes unsigned integer from wide string.
diff --git a/libc/imag.internal.h b/libc/imag.h
similarity index 100%
rename from libc/imag.internal.h
rename to libc/imag.h
diff --git a/libc/integral/c.inc b/libc/integral/c.inc
index 491aff579..7a00cd8da 100644
--- a/libc/integral/c.inc
+++ b/libc/integral/c.inc
@@ -1,7 +1,3 @@
-#if __GNUC__ + 0 < 2
-#define __attribute__(x)
-#endif
-
 #ifndef __cplusplus
 #define COSMOPOLITAN_C_START_
 #define COSMOPOLITAN_C_END_
@@ -10,73 +6,16 @@
 #define COSMOPOLITAN_CXX_USING_
 #endif
 
-#ifndef __ia16__
-#define __far
-#endif
-
 #if !defined(__GNUC__) && __cplusplus + 0 >= 201103L
 #define typeof(x) decltype(x)
 #elif !defined(__GNUC__) && __STDC_VERSION__ + 0 < 201112
 #define typeof(x) __typeof(x)
 #endif
 
-#ifdef __cplusplus
-#if __cplusplus >= 201103L
-#define _Alignof(x) alignof(x)
-#endif /* C++11 */
-#else  /* __cplusplus */
-#if __STDC_VERSION__ + 0 < 201112
-#if __GNUC__ + _MSC_VER + 0
-#define _Alignof(x) __alignof(x)
-#else
-#define _Alignof(x) /* basically all it ever did lool */ sizeof(x)
-#endif /* GNU/MSVC/!ANSI */
-#endif /* C11 */
-#endif /* __cplusplus */
-
-#if !defined(__cplusplus) && !defined(inline) && __STDC_VERSION__ + 0 < 199901
-#if defined(__GNUC__) || defined(_MSC_VER)
-#define inline __inline
-#else
-#define inline
-#define __inline
-#endif
-#endif
-
 #ifdef __chibicc__
 #define __extension__
 #endif
 
-#if __STDC_VERSION__ + 0 < 201112
-#ifdef __GNUC__
-#define _Alignas(x) __attribute__((__aligned__(x)))
-#elif defined(_MSC_VER)
-#define _Alignas(x) __declspec(align(x))
-#endif
-#endif
-
-#ifdef _MSC_VER
-#define __builtin_unreachable() __assume(false)
-#elif !((__GNUC__ + 0) * 100 + (__GNUC_MINOR__ + 0) >= 405 || \
-        defined(__clang__) || defined(__INTEL_COMPILER) ||    \
-        __has_builtin(__builtin_unreachable))
-#define __builtin_unreachable() \
-  for (;;) {                    \
-  }
-#endif
-
-#if (!defined(__llvm__) && !__has_builtin(__builtin_assume))
-#define __builtin_assume(x)    \
-  do {                         \
-    if (!(x))                  \
-      __builtin_unreachable(); \
-  } while (0)
-#endif
-
-#if __STDC_VERSION__ + 0 < 201112
-#define _Atomic(t) volatile t
-#endif
-
 #ifdef __llvm__
 #define __gnu_printf__ __printf__
 #define __gnu_scanf__  __scanf__
@@ -126,6 +65,26 @@ typedef __UINT64_TYPE__ uint64_t;
 typedef __INTMAX_TYPE__ intmax_t;
 typedef __UINTMAX_TYPE__ uintmax_t;
 
+/* TODO(jart): re-import compiler-rt once they have it */
+#if defined(__x86_64__) && defined(__FLT128_MAX_10_EXP__)
+#undef __FLT128_MAX_10_EXP__
+#undef __FLT128_DENORM_MIN__
+#undef __FLT128_MIN_EXP__
+#undef __FLT128_MIN_10_EXP__
+#undef __FLT128_MANT_DIG__
+#undef __FLT128_HAS_INFINITY__
+#undef __FLT128_EPSILON__
+#undef __FLT128_MAX_EXP__
+#undef __FLT128_HAS_DENORM__
+#undef __FLT128_DIG__
+#undef __FLT128_MIN__
+#undef __FLT128_MAX__
+#undef __FLT128_NORM_MAX__
+#undef __FLT128_HAS_QUIET_NAN__
+#undef __FLT128_IS_IEC_60559__
+#undef __FLT128_DECIMAL_DIG__
+#endif
+
 #define __DEFINED_max_align_t
 typedef long double max_align_t;
 
@@ -176,7 +135,7 @@ typedef struct {
 #define strftimeesque(n) __attribute__((__format__(__strftime__, n, 0)))
 
 #ifndef privileged
-#define privileged _Section(".privileged") dontinline dontinstrument dontubsan
+#define privileged _Section(".privileged") dontinstrument dontubsan
 #endif
 
 #ifndef wontreturn
@@ -325,16 +284,6 @@ typedef struct {
 #define hasatleast
 #endif
 
-#if __STDC_VERSION__ + 0 < 199901L && !defined(restrict)
-#if !defined(__cplusplus) && \
-    ((__GNUC__ + 0) * 100 + (__GNUC_MINOR__ + 0) >= 301 || defined(_MSC_VER))
-#define restrict __restrict__
-#else
-#define restrict
-#define __restrict
-#endif
-#endif
-
 #ifndef dontcallback
 #if (__has_attribute(__leaf__) || \
      (!defined(__llvm__) &&       \
@@ -438,6 +387,24 @@ typedef struct {
 
 #define offsetof(type, member) __builtin_offsetof(type, member)
 
+#if defined(__GNUC__) && __GNUC__ >= 10
+#define __read_only(...) __attribute__((__access__(__read_only__, __VA_ARGS__)))
+#define __write_only(...) \
+  __attribute__((__access__(__write_only__, __VA_ARGS__)))
+#define __read_write(...) \
+  __attribute__((__access__(__read_write__, __VA_ARGS__)))
+#else
+#define __read_only(...)
+#define __write_only(...)
+#define __read_write(...)
+#endif
+
+#if defined(__GNUC__) && __GNUC__ >= 13
+#define __fd_arg(N) __attribute__((__fd_arg__(N)))
+#else
+#define __fd_arg(N)
+#endif
+
 #ifdef _COSMO_SOURCE
 
 #ifndef dontinstrument
@@ -594,11 +561,8 @@ typedef struct {
 
 #ifdef __aarch64__
 /* raise sigill (not sigtrap) like x86 does */
-#define __builtin_trap()     \
-  do {                       \
-    __asm__("udf\t#0x666");  \
-    __builtin_unreachable(); \
-  } while (0)
+#define __builtin_trap() \
+  (({ __asm__("udf\t#0x666"); }), __builtin_unreachable())
 #endif
 
 #endif /* _COSMO_SOURCE */
diff --git a/libc/integral/normalize.inc b/libc/integral/normalize.inc
index 04aecb03a..97bd665cb 100644
--- a/libc/integral/normalize.inc
+++ b/libc/integral/normalize.inc
@@ -2,9 +2,9 @@
 #undef __COSMOPOLITAN__
 #endif
 
-#define __COSMOPOLITAN_MAJOR__ 3
-#define __COSMOPOLITAN_MINOR__ 5
-#define __COSMOPOLITAN_PATCH__ 1
+#define __COSMOPOLITAN_MAJOR__ 4
+#define __COSMOPOLITAN_MINOR__ 0
+#define __COSMOPOLITAN_PATCH__ 2
 #define __COSMOPOLITAN__                                                   \
   (100000000 * __COSMOPOLITAN_MAJOR__ + 1000000 * __COSMOPOLITAN_MINOR__ + \
    __COSMOPOLITAN_PATCH__)
@@ -79,12 +79,12 @@
 #undef __linux__
 #endif
 
-#ifndef __BIGGEST_ALIGNMENT__
-#define __BIGGEST_ALIGNMENT__ 16
+#ifdef __gnu_linux__
+#undef __gnu_linux__
 #endif
 
-#ifdef _COSMO_SOURCE
-#define _PAGESIZE 4096
+#ifndef __BIGGEST_ALIGNMENT__
+#define __BIGGEST_ALIGNMENT__ 16
 #endif
 
 #if defined(__LP64__) && !defined(__INT64_TYPE__)
@@ -93,6 +93,30 @@
 #include "libc/integral/llp64.inc"
 #endif
 
+#undef __INT_FAST16_MAX__
+#undef __INT_FAST16_TYPE__
+#undef __UINT_FAST16_MAX__
+#undef __INT_FAST16_WIDTH__
+#undef __UINT_FAST16_TYPE__
+
+#define __INT_FAST16_MAX__   2147483647
+#define __INT_FAST16_TYPE__  int
+#define __UINT_FAST16_MAX__  4294967295U
+#define __INT_FAST16_WIDTH__ 32
+#define __UINT_FAST16_TYPE__ unsigned int
+
+#undef __INT_FAST32_MAX__
+#undef __INT_FAST32_TYPE__
+#undef __UINT_FAST32_MAX__
+#undef __INT_FAST32_WIDTH__
+#undef __UINT_FAST32_TYPE__
+
+#define __INT_FAST32_MAX__   2147483647
+#define __INT_FAST32_TYPE__  int
+#define __UINT_FAST32_MAX__  4294967295U
+#define __INT_FAST32_WIDTH__ 32
+#define __UINT_FAST32_TYPE__ unsigned int
+
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 #ifdef __STDC__
 #include "libc/integral/c.inc"
diff --git a/libc/intrin/BUILD.mk b/libc/intrin/BUILD.mk
index 3cc80c6b6..c84aeebaf 100644
--- a/libc/intrin/BUILD.mk
+++ b/libc/intrin/BUILD.mk
@@ -16,7 +16,7 @@ LIBC_INTRIN_A_CHECKS = $(LIBC_INTRIN_A).pkg
 
 ifeq ($(ARCH), aarch64)
 LIBC_INTRIN_A_SRCS_S += $(wildcard libc/intrin/aarch64/*.S)
-LIBC_INTRIN_A_HDRS += libc/intrin/aarch64/asmdefs.internal.h
+LIBC_INTRIN_A_HDRS += libc/intrin/aarch64/asmdefs.h
 endif
 
 LIBC_INTRIN_A_OBJS =					\
@@ -30,9 +30,11 @@ LIBC_INTRIN_A_CHECKS =					\
 LIBC_INTRIN_A_DIRECTDEPS =				\
 	LIBC_NEXGEN32E					\
 	LIBC_NT_KERNEL32				\
+	LIBC_NT_REALTIME				\
+	LIBC_NT_SYNCHRONIZATION				\
 	LIBC_NT_WS2_32					\
 	LIBC_SYSV					\
-	LIBC_SYSV_CALLS
+	LIBC_SYSV_CALLS					\
 
 LIBC_INTRIN_A_DEPS :=					\
 	$(call uniq,$(foreach x,$(LIBC_INTRIN_A_DIRECTDEPS),$($(x))))
@@ -62,6 +64,12 @@ o/$(MODE)/libc/intrin/kprintf.o: private		\
 			-Wframe-larger-than=128		\
 			-Walloca-larger-than=128
 
+o/$(MODE)/libc/intrin/cursor.o				\
+o/$(MODE)/libc/intrin/mmap.o				\
+o/$(MODE)/libc/intrin/tree.o: private			\
+		CFLAGS +=				\
+			-ffunction-sections
+
 o//libc/intrin/memmove.o: private			\
 		CFLAGS +=				\
 			-fno-toplevel-reorder
@@ -92,14 +100,38 @@ o/$(MODE)/libc/intrin/x86.o: private			\
 			-fpatchable-function-entry=0	\
 			-Os
 
+# avoid the legacy sse decoding penalty on avx systems
+o//libc/intrin/dll.o					\
+o//libc/intrin/fds.o					\
+o//libc/intrin/mmap.o					\
+o//libc/intrin/demangle.o: private			\
+		CFLAGS +=				\
+			-mgeneral-regs-only
+
+# ensure that division is optimized
+o/$(MODE)/libc/intrin/windowsdurationtotimeval.o	\
+o/$(MODE)/libc/intrin/windowsdurationtotimespec.o	\
+o/$(MODE)/libc/intrin/timevaltowindowstime.o		\
+o/$(MODE)/libc/intrin/timespectowindowstime.o		\
+o/$(MODE)/libc/intrin/windowstimetotimeval.o		\
+o/$(MODE)/libc/intrin/windowstimetotimespec.o: private	\
+		CFLAGS +=				\
+			-O2
+
 # these assembly files are safe to build on aarch64
+o/$(MODE)/libc/intrin/getcontext.o: libc/intrin/getcontext.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+o/$(MODE)/libc/intrin/swapcontext.o: libc/intrin/swapcontext.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+o/$(MODE)/libc/intrin/tailcontext.o: libc/intrin/tailcontext.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/aarch64/%.o: libc/intrin/aarch64/%.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/fenv.o: libc/intrin/fenv.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/gcov.o: libc/intrin/gcov.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/libc/intrin/futex.o: libc/intrin/futex.S
+o/$(MODE)/libc/intrin/cosmo_futex_thunk.o: libc/intrin/cosmo_futex_thunk.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/typeinfo.o: libc/intrin/typeinfo.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
@@ -111,6 +143,8 @@ o/$(MODE)/libc/intrin/kerrnodocs.o: libc/intrin/kerrnodocs.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/kipoptnames.o: libc/intrin/kipoptnames.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+o/$(MODE)/libc/intrin/kipv6optnames.o: libc/intrin/kipv6optnames.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/kerrnonames.o: libc/intrin/kerrnonames.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/kfcntlcmds.o: libc/intrin/kfcntlcmds.S
@@ -137,6 +171,10 @@ o/$(MODE)/libc/intrin/kweekdaynameshort.o: libc/intrin/kweekdaynameshort.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/intrin/sched_yield.o: libc/intrin/sched_yield.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+o/$(MODE)/libc/intrin/dsohandle.o: libc/intrin/dsohandle.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+o/$(MODE)/libc/intrin/getpagesize_freebsd.o: libc/intrin/getpagesize_freebsd.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 
 LIBC_INTRIN_LIBS = $(foreach x,$(LIBC_INTRIN_ARTIFACTS),$($(x)))
 LIBC_INTRIN_HDRS = $(foreach x,$(LIBC_INTRIN_ARTIFACTS),$($(x)_HDRS))
diff --git a/libc/intrin/__getauxval.c b/libc/intrin/__getauxval.c
index 58447b7ee..db75a12ff 100644
--- a/libc/intrin/__getauxval.c
+++ b/libc/intrin/__getauxval.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/getauxval.internal.h"
+#include "libc/intrin/getauxval.h"
 #include "libc/runtime/runtime.h"
 
 /**
@@ -30,10 +30,8 @@
  */
 struct AuxiliaryValue __getauxval(unsigned long at) {
   unsigned long *ap;
-  for (ap = __auxv; ap[0]; ap += 2) {
-    if (at == ap[0]) {
+  for (ap = __auxv; ap && ap[0]; ap += 2)
+    if (at == ap[0])
       return (struct AuxiliaryValue){ap[1], true};
-    }
-  }
   return (struct AuxiliaryValue){0, false};
 }
diff --git a/libc/intrin/__getenv.c b/libc/intrin/__getenv.c
index b94d09798..6d40aa91d 100644
--- a/libc/intrin/__getenv.c
+++ b/libc/intrin/__getenv.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/intrin/getenv.internal.h"
+#include "libc/intrin/getenv.h"
 #include "libc/intrin/kprintf.h"
 
-privileged struct Env __getenv(char **p, const char *k) {
+privileged optimizesize struct Env __getenv(char **p, const char *k) {
   char *t;
   int i, j;
   for (i = 0; (t = p[i]); ++i) {
diff --git a/libc/intrin/aarch64/asmdefs.h b/libc/intrin/aarch64/asmdefs.h
new file mode 100644
index 000000000..e8d677849
--- /dev/null
+++ b/libc/intrin/aarch64/asmdefs.h
@@ -0,0 +1,91 @@
+#ifndef COSMOPOLITAN_LIBC_INTRIN_AARCH64_ASMDEFS_H_
+#define COSMOPOLITAN_LIBC_INTRIN_AARCH64_ASMDEFS_H_
+#include "libc/macros.h"
+#ifdef __ASSEMBLER__
+// clang-format off
+
+/* Branch Target Identitication support.  */
+#define BTI_C		hint	34
+#define BTI_J		hint	36
+/* Return address signing support (pac-ret).  */
+#define PACIASP		hint	25; .cfi_window_save
+#define AUTIASP		hint	29; .cfi_window_save
+
+/* GNU_PROPERTY_AARCH64_* macros from elf.h.  */
+#define FEATURE_1_AND 0xc0000000
+#define FEATURE_1_BTI 1
+#define FEATURE_1_PAC 2
+
+/* Add a NT_GNU_PROPERTY_TYPE_0 note.  */
+#define GNU_PROPERTY(type, value)	\
+  .section .note.gnu.property, "a";	\
+  .p2align 3;				\
+  .word 4;				\
+  .word 16;				\
+  .word 5;				\
+  .asciz "GNU";				\
+  .word type;				\
+  .word 4;				\
+  .word value;				\
+  .word 0;				\
+  .text
+
+/* If set then the GNU Property Note section will be added to
+   mark objects to support BTI and PAC-RET.  */
+#ifndef WANT_GNU_PROPERTY
+#define WANT_GNU_PROPERTY 1
+#endif
+
+#if WANT_GNU_PROPERTY
+/* Add property note with supported features to all asm files.  */
+GNU_PROPERTY (FEATURE_1_AND, FEATURE_1_BTI|FEATURE_1_PAC)
+#endif
+
+#define ENTRY_ALIGN(name, alignment)	\
+  .global name;		\
+  .type name,%function;	\
+  .align alignment;		\
+  .ftrace1;                     \
+  name:			\
+  .ftrace2;		\
+  .cfi_startproc;	\
+  BTI_C;
+
+#define ENTRY(name)	ENTRY_ALIGN(name, 6)
+
+/* [jart] alias the proper way */
+#define ENTRY_ALIAS(sym, alias) \
+  .global alias;		\
+  .equ alias,sym
+
+#define END(name)	\
+  .cfi_endproc;		\
+  .size name, .-name;
+
+#define L(l) .L ## l
+
+#ifdef __ILP32__
+  /* Sanitize padding bits of pointer arguments as per aapcs64 */
+#define PTR_ARG(n)  mov w##n, w##n
+#else
+#define PTR_ARG(n)
+#endif
+
+#ifdef __ILP32__
+  /* Sanitize padding bits of size arguments as per aapcs64 */
+#define SIZE_ARG(n)  mov w##n, w##n
+#else
+#define SIZE_ARG(n)
+#endif
+
+/* Compiler supports SVE instructions  */
+#ifndef HAVE_SVE
+# if __aarch64__ && (__GNUC__ >= 8 || __clang_major__ >= 5)
+#   define HAVE_SVE 1
+# else
+#   define HAVE_SVE 0
+# endif
+#endif
+
+#endif /* __ASSEMBLER__ */
+#endif /* COSMOPOLITAN_LIBC_INTRIN_AARCH64_ASMDEFS_H_ */
diff --git a/libc/intrin/aarch64/asmdefs.internal.h b/libc/intrin/aarch64/asmdefs.internal.h
deleted file mode 100644
index f18eb2bc1..000000000
--- a/libc/intrin/aarch64/asmdefs.internal.h
+++ /dev/null
@@ -1,91 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_AARCH64_ASMDEFS_H_
-#define COSMOPOLITAN_LIBC_INTRIN_AARCH64_ASMDEFS_H_
-#include "libc/macros.internal.h"
-#ifdef __ASSEMBLER__
-// clang-format off
-
-/* Branch Target Identitication support.  */
-#define BTI_C		hint	34
-#define BTI_J		hint	36
-/* Return address signing support (pac-ret).  */
-#define PACIASP		hint	25; .cfi_window_save
-#define AUTIASP		hint	29; .cfi_window_save
-
-/* GNU_PROPERTY_AARCH64_* macros from elf.h.  */
-#define FEATURE_1_AND 0xc0000000
-#define FEATURE_1_BTI 1
-#define FEATURE_1_PAC 2
-
-/* Add a NT_GNU_PROPERTY_TYPE_0 note.  */
-#define GNU_PROPERTY(type, value)	\
-  .section .note.gnu.property, "a";	\
-  .p2align 3;				\
-  .word 4;				\
-  .word 16;				\
-  .word 5;				\
-  .asciz "GNU";				\
-  .word type;				\
-  .word 4;				\
-  .word value;				\
-  .word 0;				\
-  .text
-
-/* If set then the GNU Property Note section will be added to
-   mark objects to support BTI and PAC-RET.  */
-#ifndef WANT_GNU_PROPERTY
-#define WANT_GNU_PROPERTY 1
-#endif
-
-#if WANT_GNU_PROPERTY
-/* Add property note with supported features to all asm files.  */
-GNU_PROPERTY (FEATURE_1_AND, FEATURE_1_BTI|FEATURE_1_PAC)
-#endif
-
-#define ENTRY_ALIGN(name, alignment)	\
-  .global name;		\
-  .type name,%function;	\
-  .align alignment;		\
-  .ftrace1;                     \
-  name:			\
-  .ftrace2;		\
-  .cfi_startproc;	\
-  BTI_C;
-
-#define ENTRY(name)	ENTRY_ALIGN(name, 6)
-
-/* [jart] alias the proper way */
-#define ENTRY_ALIAS(sym, alias) \
-  .global alias;		\
-  .equ alias,sym
-
-#define END(name)	\
-  .cfi_endproc;		\
-  .size name, .-name;
-
-#define L(l) .L ## l
-
-#ifdef __ILP32__
-  /* Sanitize padding bits of pointer arguments as per aapcs64 */
-#define PTR_ARG(n)  mov w##n, w##n
-#else
-#define PTR_ARG(n)
-#endif
-
-#ifdef __ILP32__
-  /* Sanitize padding bits of size arguments as per aapcs64 */
-#define SIZE_ARG(n)  mov w##n, w##n
-#else
-#define SIZE_ARG(n)
-#endif
-
-/* Compiler supports SVE instructions  */
-#ifndef HAVE_SVE
-# if __aarch64__ && (__GNUC__ >= 8 || __clang_major__ >= 5)
-#   define HAVE_SVE 1
-# else
-#   define HAVE_SVE 0
-# endif
-#endif
-
-#endif /* __ASSEMBLER__ */
-#endif /* COSMOPOLITAN_LIBC_INTRIN_AARCH64_ASMDEFS_H_ */
diff --git a/libc/intrin/aarch64/atomics.S b/libc/intrin/aarch64/atomics.S
new file mode 100644
index 000000000..17bc04fc3
--- /dev/null
+++ b/libc/intrin/aarch64/atomics.S
@@ -0,0 +1,1919 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "libc/macros.h"
+
+// aarch64 atomics compiler runtime
+//
+// armv8.1 introduced atomic instructions that go considerably faster.
+// you can pass the -mno-outline-atomics flag to the compiler to avoid
+// this runtime, however that'll go slower.
+
+.arch armv8-a+lse
+
+.macro .prvfn name
+	.privileged
+	.balign	16
+\name:
+.endm
+
+.macro .begfn name
+	.section .text.\name,"ax",%progbits
+	.balign	16
+	.ftrace1
+\name:
+	.ftrace2
+.endm
+
+.macro	jnatom	label
+	adrp	x16,__aarch64_have_lse_atomics
+	ldrb	w16,[x16,:lo12:__aarch64_have_lse_atomics]
+	cbz	w16,\label
+.endm
+
+
+.begfn __aarch64_swp1_relax
+	jnatom	1f
+	swpb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	stxrb	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp1_relax,globl
+
+.begfn __aarch64_swp1_acq
+	jnatom	1f
+	swpab	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrb	w0,[x1]
+	stxrb	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp1_acq,globl
+
+.begfn __aarch64_swp1_rel
+	jnatom	1f
+	swplb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	stlxrb	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp1_rel,globl
+
+.begfn __aarch64_swp1_acq_rel
+	jnatom	1f
+	swpalb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrb	w0,[x1]
+	stlxrb	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp1_acq_rel,globl
+
+.begfn __aarch64_swp1_sync
+	jnatom	1f
+	swpab	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	stxrb	w17,w16,[x1]
+	cbnz	w17,0b
+	dmb	ish
+	ret
+.endfn __aarch64_swp1_sync,globl
+
+
+.begfn __aarch64_cas1_relax
+	jnatom	1f
+	casb	w0,w1,[x2]
+	ret
+1:	uxtb	w16,w0
+0:	ldxrb	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stxrb	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas1_relax,globl
+
+.begfn __aarch64_cas1_acq
+	jnatom	1f
+	casab	w0,w1,[x2]
+	ret
+1:	uxtb	w16,w0
+0:	ldaxrb	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stxrb	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas1_acq,globl
+
+.begfn __aarch64_cas1_rel
+	jnatom	1f
+	caslb	w0,w1,[x2]
+	ret
+1:	uxtb	w16,w0
+0:	ldxrb	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stlxrb	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas1_rel,globl
+
+.begfn __aarch64_cas1_acq_rel
+	jnatom	1f
+	casalb	w0,w1,[x2]
+	ret
+1:	uxtb	w16,w0
+0:	ldaxrb	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stlxrb	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas1_acq_rel,globl
+
+.begfn __aarch64_cas1_sync
+	jnatom	1f
+	casalb	w0,w1,[x2]
+	ret
+1:	uxtb	w16,w0
+0:	ldxrb	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stlxrb	w17,w1,[x2]
+	cbnz	w17,0b
+1:	dmb	ish
+	ret
+.endfn __aarch64_cas1_sync,globl
+
+
+.begfn __aarch64_ldadd1_relax
+	jnatom	1f
+	ldaddb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	add	w17,w0,w16
+	stxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd1_relax,globl
+
+.begfn __aarch64_ldadd1_acq
+	jnatom	1f
+	ldaddab	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrb	w0,[x1]
+	add	w17,w0,w16
+	stxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd1_acq,globl
+
+.begfn __aarch64_ldadd1_rel
+	jnatom	1f
+	ldaddlb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	add	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd1_rel,globl
+
+.begfn __aarch64_ldadd1_acq_rel
+	jnatom	1f
+	ldaddalb w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrb	w0,[x1]
+	add	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd1_acq_rel,globl
+
+.begfn __aarch64_ldadd1_sync
+	jnatom	1f
+	ldaddalb w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	add	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldadd1_sync,globl
+
+
+.begfn __aarch64_ldset1_relax
+	jnatom	1f
+	ldsetb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	orr	w17,w0,w16
+	stxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset1_relax,globl
+
+.begfn __aarch64_ldset1_acq
+	jnatom	1f
+	ldsetab	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrb	w0,[x1]
+	orr	w17,w0,w16
+	stxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset1_acq,globl
+
+.begfn __aarch64_ldset1_rel
+	jnatom	1f
+	ldsetlb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	orr	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset1_rel,globl
+
+.begfn __aarch64_ldset1_acq_rel
+	jnatom	1f
+	ldsetalb w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrb	w0,[x1]
+	orr	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset1_acq_rel,globl
+
+.begfn __aarch64_ldset1_sync
+	jnatom	1f
+	ldsetalb w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	orr	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldset1_sync,globl
+
+
+.begfn __aarch64_ldclr1_relax
+	jnatom	1f
+	ldclrb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	bic	w17,w0,w16
+	stxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr1_relax,globl
+
+.begfn __aarch64_ldclr1_acq
+	jnatom	1f
+	ldclrab	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrb	w0,[x1]
+	bic	w17,w0,w16
+	stxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr1_acq,globl
+
+.begfn __aarch64_ldclr1_rel
+	jnatom	1f
+	ldclrlb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	bic	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr1_rel,globl
+
+.begfn __aarch64_ldclr1_acq_rel
+	jnatom	1f
+	ldclralb w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrb	w0,[x1]
+	bic	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr1_acq_rel,globl
+
+.begfn __aarch64_ldclr1_sync
+	jnatom	1f
+	ldclralb w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	bic	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldclr1_sync,globl
+
+
+.begfn __aarch64_ldeor1_relax
+	jnatom	1f
+	ldeorb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	eor	w17,w0,w16
+	stxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor1_relax,globl
+
+.begfn __aarch64_ldeor1_acq
+	jnatom	1f
+	ldeorab	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrb	w0,[x1]
+	eor	w17,w0,w16
+	stxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor1_acq,globl
+
+.begfn __aarch64_ldeor1_rel
+	jnatom	1f
+	ldeorlb	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	eor	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor1_rel,globl
+
+.begfn __aarch64_ldeor1_acq_rel
+	jnatom	1f
+	ldeoralb w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrb	w0,[x1]
+	eor	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor1_acq_rel,globl
+
+.begfn __aarch64_ldeor1_sync
+	jnatom	1f
+	ldeoralb w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrb	w0,[x1]
+	eor	w17,w0,w16
+	stlxrb	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldeor1_sync,globl
+
+
+.begfn __aarch64_swp2_relax
+	jnatom	1f
+	swph	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	stxrh	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp2_relax,globl
+
+.begfn __aarch64_swp2_acq
+	jnatom	1f
+	swpah	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrh	w0,[x1]
+	stxrh	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp2_acq,globl
+
+.begfn __aarch64_swp2_rel
+	jnatom	1f
+	swplh	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	stlxrh	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp2_rel,globl
+
+.begfn __aarch64_swp2_acq_rel
+	jnatom	1f
+	swpalh	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrh	w0,[x1]
+	stlxrh	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp2_acq_rel,globl
+
+.begfn __aarch64_swp2_sync
+	jnatom	1f
+	swpah	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	stxrh	w17,w16,[x1]
+	cbnz	w17,0b
+	dmb	ish
+	ret
+.endfn __aarch64_swp2_sync,globl
+
+
+.begfn __aarch64_cas2_relax
+	jnatom	1f
+	cash	w0,w1,[x2]
+	ret
+1:	uxth	w16,w0
+0:	ldxrh	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stxrh	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas2_relax,globl
+
+.begfn __aarch64_cas2_acq
+	jnatom	1f
+	casah	w0,w1,[x2]
+	ret
+1:	uxth	w16,w0
+0:	ldaxrh	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stxrh	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas2_acq,globl
+
+.begfn __aarch64_cas2_rel
+	jnatom	1f
+	caslh	w0,w1,[x2]
+	ret
+1:	uxth	w16,w0
+0:	ldxrh	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stlxrh	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas2_rel,globl
+
+.begfn __aarch64_cas2_acq_rel
+	jnatom	1f
+	casalh	w0,w1,[x2]
+	ret
+1:	uxth	w16,w0
+0:	ldaxrh	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stlxrh	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas2_acq_rel,globl
+
+.begfn __aarch64_cas2_sync
+	jnatom	1f
+	casalh	w0,w1,[x2]
+	ret
+1:	uxth	w16,w0
+0:	ldxrh	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stlxrh	w17,w1,[x2]
+	cbnz	w17,0b
+1:	dmb	ish
+	ret
+.endfn __aarch64_cas2_sync,globl
+
+
+.begfn __aarch64_ldadd2_relax
+	jnatom	1f
+	ldaddh	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	add	w17,w0,w16
+	stxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd2_relax,globl
+
+.begfn __aarch64_ldadd2_acq
+	jnatom	1f
+	ldaddah	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrh	w0,[x1]
+	add	w17,w0,w16
+	stxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd2_acq,globl
+
+.begfn __aarch64_ldadd2_rel
+	jnatom	1f
+	ldaddlh	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	add	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd2_rel,globl
+
+.begfn __aarch64_ldadd2_acq_rel
+	jnatom	1f
+	ldaddalh w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrh	w0,[x1]
+	add	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd2_acq_rel,globl
+
+.begfn __aarch64_ldadd2_sync
+	jnatom	1f
+	ldaddalh w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	add	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldadd2_sync,globl
+
+
+.begfn __aarch64_ldset2_relax
+	jnatom	1f
+	ldseth	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	orr	w17,w0,w16
+	stxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset2_relax,globl
+
+.begfn __aarch64_ldset2_acq
+	jnatom	1f
+	ldsetah	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrh	w0,[x1]
+	orr	w17,w0,w16
+	stxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset2_acq,globl
+
+.begfn __aarch64_ldset2_rel
+	jnatom	1f
+	ldsetlh	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	orr	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset2_rel,globl
+
+.begfn __aarch64_ldset2_acq_rel
+	jnatom	1f
+	ldsetalh w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrh	w0,[x1]
+	orr	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset2_acq_rel,globl
+
+.begfn __aarch64_ldset2_sync
+	jnatom	1f
+	ldsetalh w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	orr	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldset2_sync,globl
+
+
+.begfn __aarch64_ldclr2_relax
+	jnatom	1f
+	ldclrh	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	bic	w17,w0,w16
+	stxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr2_relax,globl
+
+.begfn __aarch64_ldclr2_acq
+	jnatom	1f
+	ldclrah	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrh	w0,[x1]
+	bic	w17,w0,w16
+	stxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr2_acq,globl
+
+.begfn __aarch64_ldclr2_rel
+	jnatom	1f
+	ldclrlh	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	bic	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr2_rel,globl
+
+.begfn __aarch64_ldclr2_acq_rel
+	jnatom	1f
+	ldclralh w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrh	w0,[x1]
+	bic	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr2_acq_rel,globl
+
+.begfn __aarch64_ldclr2_sync
+	jnatom	1f
+	ldclralh w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	bic	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldclr2_sync,globl
+
+
+.begfn __aarch64_ldeor2_relax
+	jnatom	1f
+	ldeorh	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	eor	w17,w0,w16
+	stxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor2_relax,globl
+
+.begfn __aarch64_ldeor2_acq
+	jnatom	1f
+	ldeorah	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrh	w0,[x1]
+	eor	w17,w0,w16
+	stxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor2_acq,globl
+
+.begfn __aarch64_ldeor2_rel
+	jnatom	1f
+	ldeorlh	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	eor	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor2_rel,globl
+
+.begfn __aarch64_ldeor2_acq_rel
+	jnatom	1f
+	ldeoralh w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxrh	w0,[x1]
+	eor	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor2_acq_rel,globl
+
+.begfn __aarch64_ldeor2_sync
+	jnatom	1f
+	ldeoralh w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxrh	w0,[x1]
+	eor	w17,w0,w16
+	stlxrh	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldeor2_sync,globl
+
+
+.begfn __aarch64_swp4_relax
+	jnatom	1f
+	swp	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	stxr	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp4_relax,globl
+
+.begfn __aarch64_swp4_acq
+	jnatom	1f
+	swpa	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x1]
+	stxr	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp4_acq,globl
+
+.begfn __aarch64_swp4_rel
+	jnatom	1f
+	swpl	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	stlxr	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp4_rel,globl
+
+.begfn __aarch64_swp4_acq_rel
+	jnatom	1f
+	swpal	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x1]
+	stlxr	w17,w16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp4_acq_rel,globl
+
+.begfn __aarch64_swp4_sync
+	jnatom	1f
+	swpa	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	stxr	w17,w16,[x1]
+	cbnz	w17,0b
+	dmb	ish
+	ret
+.endfn __aarch64_swp4_sync,globl
+
+
+.begfn __aarch64_cas4_relax
+	jnatom	1f
+	cas	w0,w1,[x2]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stxr	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas4_relax,globl
+
+.begfn __aarch64_cas4_acq
+	jnatom	1f
+	casa	w0,w1,[x2]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stxr	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas4_acq,globl
+
+.begfn __aarch64_cas4_rel
+	jnatom	1f
+	casl	w0,w1,[x2]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stlxr	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas4_rel,globl
+
+.begfn __aarch64_cas4_acq_rel
+	jnatom	1f
+	casal	w0,w1,[x2]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stlxr	w17,w1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas4_acq_rel,globl
+
+.begfn __aarch64_cas4_sync
+	jnatom	1f
+	casal	w0,w1,[x2]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x2]
+	cmp	w0,w16
+	bne	1f
+	stlxr	w17,w1,[x2]
+	cbnz	w17,0b
+1:	dmb	ish
+	ret
+.endfn __aarch64_cas4_sync,globl
+
+
+.begfn __aarch64_ldadd4_relax
+	jnatom	1f
+	ldadd	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	add	w17,w0,w16
+	stxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd4_relax,globl
+
+.begfn __aarch64_ldadd4_acq
+	jnatom	1f
+	ldadda	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x1]
+	add	w17,w0,w16
+	stxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd4_acq,globl
+
+.begfn __aarch64_ldadd4_rel
+	jnatom	1f
+	ldaddl	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	add	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd4_rel,globl
+
+.begfn __aarch64_ldadd4_acq_rel
+	jnatom	1f
+	ldaddal	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x1]
+	add	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd4_acq_rel,globl
+
+.begfn __aarch64_ldadd4_sync
+	jnatom	1f
+	ldaddal	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	add	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldadd4_sync,globl
+
+
+.begfn __aarch64_ldset4_relax
+	jnatom	1f
+	ldset	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	orr	w17,w0,w16
+	stxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset4_relax,globl
+
+.begfn __aarch64_ldset4_acq
+	jnatom	1f
+	ldseta	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x1]
+	orr	w17,w0,w16
+	stxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset4_acq,globl
+
+.begfn __aarch64_ldset4_rel
+	jnatom	1f
+	ldsetl	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	orr	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset4_rel,globl
+
+.begfn __aarch64_ldset4_acq_rel
+	jnatom	1f
+	ldsetal	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x1]
+	orr	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset4_acq_rel,globl
+
+.begfn __aarch64_ldset4_sync
+	jnatom	1f
+	ldsetal	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	orr	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldset4_sync,globl
+
+
+.begfn __aarch64_ldclr4_relax
+	jnatom	1f
+	ldclr	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	bic	w17,w0,w16
+	stxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr4_relax,globl
+
+.begfn __aarch64_ldclr4_acq
+	jnatom	1f
+	ldclra	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x1]
+	bic	w17,w0,w16
+	stxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr4_acq,globl
+
+.begfn __aarch64_ldclr4_rel
+	jnatom	1f
+	ldclrl	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	bic	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr4_rel,globl
+
+.begfn __aarch64_ldclr4_acq_rel
+	jnatom	1f
+	ldclral	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x1]
+	bic	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr4_acq_rel,globl
+
+.begfn __aarch64_ldclr4_sync
+	jnatom	1f
+	ldclral	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	bic	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldclr4_sync,globl
+
+
+.begfn __aarch64_ldeor4_relax
+	jnatom	1f
+	ldeor	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	eor	w17,w0,w16
+	stxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor4_relax,globl
+
+.begfn __aarch64_ldeor4_acq
+	jnatom	1f
+	ldeora	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x1]
+	eor	w17,w0,w16
+	stxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor4_acq,globl
+
+.begfn __aarch64_ldeor4_rel
+	jnatom	1f
+	ldeorl	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	eor	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor4_rel,globl
+
+.begfn __aarch64_ldeor4_acq_rel
+	jnatom	1f
+	ldeoral	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldaxr	w0,[x1]
+	eor	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor4_acq_rel,globl
+
+.begfn __aarch64_ldeor4_sync
+	jnatom	1f
+	ldeoral	w0,w0,[x1]
+	ret
+1:	mov	w16,w0
+0:	ldxr	w0,[x1]
+	eor	w17,w0,w16
+	stlxr	w15,w17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldeor4_sync,globl
+
+
+.begfn __aarch64_swp8_relax
+	jnatom	1f
+	swp	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	stxr	w17,x16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp8_relax,globl
+
+.begfn __aarch64_swp8_acq
+	jnatom	1f
+	swpa	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	stxr	w17,x16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp8_acq,globl
+
+.begfn __aarch64_swp8_rel
+	jnatom	1f
+	swpl	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	stlxr	w17,x16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp8_rel,globl
+
+.begfn __aarch64_swp8_acq_rel
+	jnatom	1f
+	swpal	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	stlxr	w17,x16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp8_acq_rel,globl
+
+.begfn __aarch64_swp8_sync
+	jnatom	1f
+	swpa	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	stxr	w17,x16,[x1]
+	cbnz	w17,0b
+	dmb	ish
+	ret
+.endfn __aarch64_swp8_sync,globl
+
+
+.prvfn __aarch64_cas8_relax
+	jnatom	1f
+	cas	x0,x1,[x2]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x2]
+	cmp	x0,x16
+	bne	1f
+	stxr	w17,x1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas8_relax,globl
+
+.prvfn __aarch64_cas8_acq
+	jnatom	1f
+	casa	x0,x1,[x2]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x2]
+	cmp	x0,x16
+	bne	1f
+	stxr	w17,x1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas8_acq,globl
+
+.prvfn __aarch64_cas8_rel
+	jnatom	1f
+	casl	x0,x1,[x2]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x2]
+	cmp	x0,x16
+	bne	1f
+	stlxr	w17,x1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas8_rel,globl
+
+.begfn __aarch64_cas8_acq_rel
+	jnatom	1f
+	casal	x0,x1,[x2]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x2]
+	cmp	x0,x16
+	bne	1f
+	stlxr	w17,x1,[x2]
+	cbnz	w17,0b
+1:	ret
+.endfn __aarch64_cas8_acq_rel,globl
+
+.begfn __aarch64_cas8_sync
+	jnatom	1f
+	casal	x0,x1,[x2]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x2]
+	cmp	x0,x16
+	bne	1f
+	stlxr	w17,x1,[x2]
+	cbnz	w17,0b
+1:	dmb	ish
+	ret
+.endfn __aarch64_cas8_sync,globl
+
+
+.begfn __aarch64_ldadd8_relax
+	jnatom	1f
+	ldadd	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	add	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd8_relax,globl
+
+.begfn __aarch64_ldadd8_acq
+	jnatom	1f
+	ldadda	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	add	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd8_acq,globl
+
+.begfn __aarch64_ldadd8_rel
+	jnatom	1f
+	ldaddl	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	add	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd8_rel,globl
+
+.begfn __aarch64_ldadd8_acq_rel
+	jnatom	1f
+	ldaddal	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	add	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd8_acq_rel,globl
+
+.begfn __aarch64_ldadd8_sync
+	jnatom	1f
+	ldaddal	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	add	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldadd8_sync,globl
+
+
+.begfn __aarch64_ldset8_relax
+	jnatom	1f
+	ldset	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	orr	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset8_relax,globl
+
+.begfn __aarch64_ldset8_acq
+	jnatom	1f
+	ldseta	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	orr	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset8_acq,globl
+
+.begfn __aarch64_ldset8_rel
+	jnatom	1f
+	ldsetl	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	orr	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset8_rel,globl
+
+.begfn __aarch64_ldset8_acq_rel
+	jnatom	1f
+	ldsetal	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	orr	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset8_acq_rel,globl
+
+.begfn __aarch64_ldset8_sync
+	jnatom	1f
+	ldsetal	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	orr	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldset8_sync,globl
+
+
+.begfn __aarch64_ldclr8_relax
+	jnatom	1f
+	ldclr	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	bic	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr8_relax,globl
+
+.begfn __aarch64_ldclr8_acq
+	jnatom	1f
+	ldclra	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	bic	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr8_acq,globl
+
+.begfn __aarch64_ldclr8_rel
+	jnatom	1f
+	ldclrl	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	bic	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr8_rel,globl
+
+.begfn __aarch64_ldclr8_acq_rel
+	jnatom	1f
+	ldclral	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	bic	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr8_acq_rel,globl
+
+.begfn __aarch64_ldclr8_sync
+	jnatom	1f
+	ldclral	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	bic	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldclr8_sync,globl
+
+
+.begfn __aarch64_ldeor8_relax
+	jnatom	1f
+	ldeor	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	eor	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor8_relax,globl
+
+.begfn __aarch64_ldeor8_acq
+	jnatom	1f
+	ldeora	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	eor	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor8_acq,globl
+
+.begfn __aarch64_ldeor8_rel
+	jnatom	1f
+	ldeorl	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	eor	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor8_rel,globl
+
+.begfn __aarch64_ldeor8_acq_rel
+	jnatom	1f
+	ldeoral	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	eor	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor8_acq_rel,globl
+
+.begfn __aarch64_ldeor8_sync
+	jnatom	1f
+	ldeoral	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	eor	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldeor8_sync,globl
+
+
+.begfn __aarch64_swp16_relax
+	jnatom	1f
+	swp	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	stxr	w17,x16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp16_relax,globl
+
+.begfn __aarch64_swp16_acq
+	jnatom	1f
+	swpa	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	stxr	w17,x16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp16_acq,globl
+
+.begfn __aarch64_swp16_rel
+	jnatom	1f
+	swpl	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	stlxr	w17,x16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp16_rel,globl
+
+.begfn __aarch64_swp16_acq_rel
+	jnatom	1f
+	swpal	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	stlxr	w17,x16,[x1]
+	cbnz	w17,0b
+	ret
+.endfn __aarch64_swp16_acq_rel,globl
+
+.begfn __aarch64_swp16_sync
+	jnatom	1f
+	swpa	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	stxr	w17,x16,[x1]
+	cbnz	w17,0b
+	dmb	ish
+	ret
+.endfn __aarch64_swp16_sync,globl
+
+
+.begfn __aarch64_cas16_relax
+	jnatom	1f
+	casp	x0,x1,x2,x3,[x4]
+	ret
+1:	mov	x16,x0
+	mov	x17,x1
+0:	ldxp	x0,x1,[x4]
+	cmp	x0,x16
+	ccmp	x1,x17,#0,eq
+	csel	x15,x2,x0,eq
+	csel	x14,x3,x1,eq
+	stxp	w13,x15,x14,[x4]
+	cbnz	w13,0b
+	ret
+.endfn __aarch64_cas16_relax,globl
+
+.begfn __aarch64_cas16_acq
+	jnatom	1f
+	caspa	x0,x1,x2,x3,[x4]
+	ret
+1:	mov	x16,x0
+	mov	x17,x1
+0:	ldaxp	x0,x1,[x4]
+	cmp	x0,x16
+	ccmp	x1,x17,#0,eq
+	csel	x15,x2,x0,eq
+	csel	x14,x3,x1,eq
+	stxp	w13,x15,x14,[x4]
+	cbnz	w13,0b
+	ret
+.endfn __aarch64_cas16_acq,globl
+
+.begfn __aarch64_cas16_rel
+	jnatom	1f
+	caspl	x0,x1,x2,x3,[x4]
+	ret
+1:	mov	x16,x0
+	mov	x17,x1
+0:	ldxp	x0,x1,[x4]
+	cmp	x0,x16
+	ccmp	x1,x17,#0,eq
+	csel	x15,x2,x0,eq
+	csel	x14,x3,x1,eq
+	stlxp	w13,x15,x14,[x4]
+	cbnz	w13,0b
+	ret
+.endfn __aarch64_cas16_rel,globl
+
+.begfn __aarch64_cas16_acq_rel
+	jnatom	1f
+	caspal	x0,x1,x2,x3,[x4]
+	ret
+1:	mov	x16,x0
+	mov	x17,x1
+0:	ldaxp	x0,x1,[x4]
+	cmp	x0,x16
+	ccmp	x1,x17,#0,eq
+	csel	x15,x2,x0,eq
+	csel	x14,x3,x1,eq
+	stlxp	w13,x15,x14,[x4]
+	cbnz	w13,0b
+	ret
+.endfn __aarch64_cas16_acq_rel,globl
+
+.begfn __aarch64_cas16_sync
+	jnatom	1f
+	caspal	x0,x1,x2,x3,[x4]
+	ret
+1:	mov	x16,x0
+	mov	x17,x1
+0:	ldxp	x0,x1,[x4]
+	cmp	x0,x16
+	ccmp	x1,x17,#0,eq
+	csel	x15,x2,x0,eq
+	csel	x14,x3,x1,eq
+	stlxp	w13,x15,x14,[x4]
+	cbnz	w13,0b
+	dmb	ish
+	ret
+.endfn __aarch64_cas16_sync,globl
+
+
+.begfn __aarch64_ldadd16_relax
+	jnatom	1f
+	ldadd	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	add	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd16_relax,globl
+
+.begfn __aarch64_ldadd16_acq
+	jnatom	1f
+	ldadda	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	add	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd16_acq,globl
+
+.begfn __aarch64_ldadd16_rel
+	jnatom	1f
+	ldaddl	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	add	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd16_rel,globl
+
+.begfn __aarch64_ldadd16_acq_rel
+	jnatom	1f
+	ldaddal	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	add	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldadd16_acq_rel,globl
+
+.begfn __aarch64_ldadd16_sync
+	jnatom	1f
+	ldaddal	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	add	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldadd16_sync,globl
+
+
+.begfn __aarch64_ldset16_relax
+	jnatom	1f
+	ldset	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	orr	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset16_relax,globl
+
+.begfn __aarch64_ldset16_acq
+	jnatom	1f
+	ldseta	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	orr	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset16_acq,globl
+
+.begfn __aarch64_ldset16_rel
+	jnatom	1f
+	ldsetl	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	orr	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset16_rel,globl
+
+.begfn __aarch64_ldset16_acq_rel
+	jnatom	1f
+	ldsetal	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	orr	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldset16_acq_rel,globl
+
+.begfn __aarch64_ldset16_sync
+	jnatom	1f
+	ldsetal	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	orr	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldset16_sync,globl
+
+
+.begfn __aarch64_ldclr16_relax
+	jnatom	1f
+	ldclr	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	bic	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr16_relax,globl
+
+.begfn __aarch64_ldclr16_acq
+	jnatom	1f
+	ldclra	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	bic	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr16_acq,globl
+
+.begfn __aarch64_ldclr16_rel
+	jnatom	1f
+	ldclrl	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	bic	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr16_rel,globl
+
+.begfn __aarch64_ldclr16_acq_rel
+	jnatom	1f
+	ldclral	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	bic	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldclr16_acq_rel,globl
+
+.begfn __aarch64_ldclr16_sync
+	jnatom	1f
+	ldclral	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	bic	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldclr16_sync,globl
+
+
+.begfn __aarch64_ldeor16_relax
+	jnatom	1f
+	ldeor	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	eor	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor16_relax,globl
+
+.begfn __aarch64_ldeor16_acq
+	jnatom	1f
+	ldeora	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	eor	x17,x0,x16
+	stxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor16_acq,globl
+
+.begfn __aarch64_ldeor16_rel
+	jnatom	1f
+	ldeorl	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	eor	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor16_rel,globl
+
+.begfn __aarch64_ldeor16_acq_rel
+	jnatom	1f
+	ldeoral	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldaxr	x0,[x1]
+	eor	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	ret
+.endfn __aarch64_ldeor16_acq_rel,globl
+
+.begfn __aarch64_ldeor16_sync
+	jnatom	1f
+	ldeoral	x0,x0,[x1]
+	ret
+1:	mov	x16,x0
+0:	ldxr	x0,[x1]
+	eor	x17,x0,x16
+	stlxr	w15,x17,[x1]
+	cbnz	w15,0b
+	dmb	ish
+	ret
+.endfn __aarch64_ldeor16_sync,globl
diff --git a/libc/intrin/aarch64/memchr.S b/libc/intrin/aarch64/memchr.S
index 7242bfc86..22361b26d 100644
--- a/libc/intrin/aarch64/memchr.S
+++ b/libc/intrin/aarch64/memchr.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __memchr_aarch64 memchr
diff --git a/libc/intrin/aarch64/memcpy.S b/libc/intrin/aarch64/memcpy.S
index 65b58d75a..d9294db9d 100644
--- a/libc/intrin/aarch64/memcpy.S
+++ b/libc/intrin/aarch64/memcpy.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __memcpy_aarch64_simd memcpy
diff --git a/libc/intrin/aarch64/memrchr.S b/libc/intrin/aarch64/memrchr.S
index 3041eeab7..57e6c4354 100644
--- a/libc/intrin/aarch64/memrchr.S
+++ b/libc/intrin/aarch64/memrchr.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __memrchr_aarch64 memrchr
diff --git a/libc/intrin/aarch64/memset.S b/libc/intrin/aarch64/memset.S
index cef8edd9c..c9e2d3dd7 100644
--- a/libc/intrin/aarch64/memset.S
+++ b/libc/intrin/aarch64/memset.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __memset_aarch64 memset
diff --git a/libc/intrin/aarch64/stpcpy.S b/libc/intrin/aarch64/stpcpy.S
index a34f1aa8f..3bf49d8cb 100644
--- a/libc/intrin/aarch64/stpcpy.S
+++ b/libc/intrin/aarch64/stpcpy.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __stpcpy_aarch64 stpcpy
diff --git a/libc/intrin/aarch64/strchr.S b/libc/intrin/aarch64/strchr.S
index 462d94806..20a7e8dab 100644
--- a/libc/intrin/aarch64/strchr.S
+++ b/libc/intrin/aarch64/strchr.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __strchr_aarch64 strchr
diff --git a/libc/intrin/aarch64/strchrnul.S b/libc/intrin/aarch64/strchrnul.S
index 184305b22..a86383f62 100644
--- a/libc/intrin/aarch64/strchrnul.S
+++ b/libc/intrin/aarch64/strchrnul.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __strchrnul_aarch64 strchrnul
diff --git a/libc/intrin/aarch64/strcmp.S b/libc/intrin/aarch64/strcmp.S
index 98f26d486..190fd77e3 100644
--- a/libc/intrin/aarch64/strcmp.S
+++ b/libc/intrin/aarch64/strcmp.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __strcmp_aarch64 strcmp
diff --git a/libc/intrin/aarch64/strcpy.S b/libc/intrin/aarch64/strcpy.S
index 93cb85fec..dc53c8f50 100644
--- a/libc/intrin/aarch64/strcpy.S
+++ b/libc/intrin/aarch64/strcpy.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __strcpy_aarch64 strcpy
diff --git a/libc/intrin/aarch64/strlen.S b/libc/intrin/aarch64/strlen.S
index 7464eafc9..600640cf3 100644
--- a/libc/intrin/aarch64/strlen.S
+++ b/libc/intrin/aarch64/strlen.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __strlen_aarch64 strlen
diff --git a/libc/intrin/aarch64/strncmp.S b/libc/intrin/aarch64/strncmp.S
index 8a0b75397..4734185bc 100644
--- a/libc/intrin/aarch64/strncmp.S
+++ b/libc/intrin/aarch64/strncmp.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __strncmp_aarch64 strncmp
diff --git a/libc/intrin/aarch64/strnlen.S b/libc/intrin/aarch64/strnlen.S
index 988c15f63..750b1de48 100644
--- a/libc/intrin/aarch64/strnlen.S
+++ b/libc/intrin/aarch64/strnlen.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __strnlen_aarch64 strnlen
diff --git a/libc/intrin/aarch64/strrchr.S b/libc/intrin/aarch64/strrchr.S
index 5199254ff..0ad8f7b3b 100644
--- a/libc/intrin/aarch64/strrchr.S
+++ b/libc/intrin/aarch64/strrchr.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/aarch64/asmdefs.internal.h"
+#include "libc/intrin/aarch64/asmdefs.h"
 .yoink arm_optimized_routines_notice
 
 #define __strrchr_aarch64 strrchr
diff --git a/libc/intrin/armlse.c b/libc/intrin/armlse.c
new file mode 100644
index 000000000..b05bf0709
--- /dev/null
+++ b/libc/intrin/armlse.c
@@ -0,0 +1,32 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/getauxval.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sysv/consts/auxv.h"
+#include "libc/sysv/consts/hwcap.h"
+#ifdef __aarch64__
+
+bool __aarch64_have_lse_atomics;
+
+static __attribute__((__constructor__(1))) void __aarch64_atomics_init(void) {
+  struct AuxiliaryValue x = __getauxval(AT_HWCAP);
+  __aarch64_have_lse_atomics = !!(x.value & HWCAP_ATOMICS);
+}
+
+#endif /* __aarch64__ */
diff --git a/libc/intrin/atomic.h b/libc/intrin/atomic.h
index 3d503d37f..a2d93df8a 100644
--- a/libc/intrin/atomic.h
+++ b/libc/intrin/atomic.h
@@ -13,48 +13,26 @@
  */
 
 typedef enum {
-  memory_order_relaxed,
-  memory_order_consume,
-  memory_order_acquire,
-  memory_order_release,
-  memory_order_acq_rel,
-  memory_order_seq_cst,
+  memory_order_relaxed = __ATOMIC_RELAXED,
+  memory_order_consume = __ATOMIC_CONSUME,
+  memory_order_acquire = __ATOMIC_ACQUIRE,
+  memory_order_release = __ATOMIC_RELEASE,
+  memory_order_acq_rel = __ATOMIC_ACQ_REL,
+  memory_order_seq_cst = __ATOMIC_SEQ_CST
 } memory_order;
 
-#define ATOMIC_VAR_INIT(...)     __VA_ARGS__
+#if !(defined __STDC_VERSION__ && __STDC_VERSION__ > 201710L)
+#define ATOMIC_VAR_INIT(...) __VA_ARGS__
+#endif
+
 #define atomic_is_lock_free(obj) ((void)(obj), sizeof(obj) <= sizeof(void *))
 
 #define atomic_flag      atomic_bool
-#define ATOMIC_FLAG_INIT ATOMIC_VAR_INIT(0)
+#define ATOMIC_FLAG_INIT false
 #define atomic_flag_test_and_set_explicit(x, order) \
   atomic_exchange_explicit(x, 1, order)
 #define atomic_flag_clear_explicit(x, order) atomic_store_explicit(x, 0, order)
 
-#define atomic_compare_exchange_strong(pObject, pExpected, desired) \
-  atomic_compare_exchange_strong_explicit(                          \
-      pObject, pExpected, desired, memory_order_seq_cst, memory_order_seq_cst)
-#define atomic_compare_exchange_weak(pObject, pExpected, desired) \
-  atomic_compare_exchange_weak_explicit(                          \
-      pObject, pExpected, desired, memory_order_seq_cst, memory_order_seq_cst)
-#define atomic_exchange(pObject, desired) \
-  atomic_exchange_explicit(pObject, desired, memory_order_seq_cst)
-#define atomic_fetch_add(pObject, operand) \
-  atomic_fetch_add_explicit(pObject, operand, memory_order_seq_cst)
-#define atomic_fetch_and(pObject, operand) \
-  atomic_fetch_and_explicit(pObject, operand, memory_order_seq_cst)
-#define atomic_fetch_or(pObject, operand) \
-  atomic_fetch_or_explicit(pObject, operand, memory_order_seq_cst)
-#define atomic_fetch_sub(pObject, operand) \
-  atomic_fetch_sub_explicit(pObject, operand, memory_order_seq_cst)
-#define atomic_fetch_xor(pObject, operand) \
-  atomic_fetch_xor_explicit(pObject, operand, memory_order_seq_cst)
-#define atomic_load(pObject) atomic_load_explicit(pObject, memory_order_seq_cst)
-#define atomic_store(pObject, desired) \
-  atomic_store_explicit(pObject, desired, memory_order_seq_cst)
-#define atomic_flag_test_and_set(x) \
-  atomic_flag_test_and_set_explicit(x, memory_order_seq_cst)
-#define atomic_flag_clear(x) atomic_flag_clear_explicit(x, memory_order_seq_cst)
-
 #if defined(__CLANG_ATOMIC_BOOL_LOCK_FREE)
 
 #define atomic_init(obj, value)    __c11_atomic_init(obj, value)
@@ -84,9 +62,35 @@ typedef enum {
 #define atomic_store_explicit(object, desired, order) \
   __c11_atomic_store(object, desired, order)
 
+#define atomic_compare_exchange_strong(pObject, pExpected, desired) \
+  atomic_compare_exchange_strong_explicit(                          \
+      pObject, pExpected, desired, memory_order_seq_cst, memory_order_seq_cst)
+#define atomic_compare_exchange_weak(pObject, pExpected, desired) \
+  atomic_compare_exchange_weak_explicit(                          \
+      pObject, pExpected, desired, memory_order_seq_cst, memory_order_seq_cst)
+#define atomic_exchange(pObject, desired) \
+  atomic_exchange_explicit(pObject, desired, memory_order_seq_cst)
+#define atomic_fetch_add(pObject, operand) \
+  atomic_fetch_add_explicit(pObject, operand, memory_order_seq_cst)
+#define atomic_fetch_and(pObject, operand) \
+  atomic_fetch_and_explicit(pObject, operand, memory_order_seq_cst)
+#define atomic_fetch_or(pObject, operand) \
+  atomic_fetch_or_explicit(pObject, operand, memory_order_seq_cst)
+#define atomic_fetch_sub(pObject, operand) \
+  atomic_fetch_sub_explicit(pObject, operand, memory_order_seq_cst)
+#define atomic_fetch_xor(pObject, operand) \
+  atomic_fetch_xor_explicit(pObject, operand, memory_order_seq_cst)
+#define atomic_load(pObject) atomic_load_explicit(pObject, memory_order_seq_cst)
+#define atomic_store(pObject, desired) \
+  atomic_store_explicit(pObject, desired, memory_order_seq_cst)
+#define atomic_flag_test_and_set(x) \
+  atomic_flag_test_and_set_explicit(x, memory_order_seq_cst)
+#define atomic_flag_clear(x) atomic_flag_clear_explicit(x, memory_order_seq_cst)
+
 #elif (__GNUC__ + 0) * 100 + (__GNUC_MINOR__ + 0) >= 407
 
-#define atomic_init(obj, value)    ((void)(*(obj) = (value)))
+#define atomic_init(obj, value) \
+  atomic_store_explicit(obj, value, __ATOMIC_RELAXED)
 #define atomic_thread_fence(order) __atomic_thread_fence(order)
 #define atomic_signal_fence(order) __atomic_signal_fence(order)
 #define atomic_compare_exchange_strong_explicit(pObject, pExpected, desired, \
@@ -111,6 +115,31 @@ typedef enum {
 #define atomic_store_explicit(pObject, desired, order) \
   __atomic_store_n(pObject, desired, order)
 
+#define atomic_compare_exchange_strong(pObject, pExpected, desired)    \
+  atomic_compare_exchange_strong_explicit(pObject, pExpected, desired, \
+                                          __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
+#define atomic_compare_exchange_weak(pObject, pExpected, desired)    \
+  atomic_compare_exchange_weak_explicit(pObject, pExpected, desired, \
+                                        __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
+#define atomic_exchange(pObject, desired) \
+  atomic_exchange_explicit(pObject, desired, __ATOMIC_SEQ_CST)
+#define atomic_fetch_add(pObject, operand) \
+  atomic_fetch_add_explicit(pObject, operand, __ATOMIC_SEQ_CST)
+#define atomic_fetch_and(pObject, operand) \
+  atomic_fetch_and_explicit(pObject, operand, __ATOMIC_SEQ_CST)
+#define atomic_fetch_or(pObject, operand) \
+  atomic_fetch_or_explicit(pObject, operand, __ATOMIC_SEQ_CST)
+#define atomic_fetch_sub(pObject, operand) \
+  atomic_fetch_sub_explicit(pObject, operand, __ATOMIC_SEQ_CST)
+#define atomic_fetch_xor(pObject, operand) \
+  atomic_fetch_xor_explicit(pObject, operand, __ATOMIC_SEQ_CST)
+#define atomic_load(pObject) atomic_load_explicit(pObject, __ATOMIC_SEQ_CST)
+#define atomic_store(pObject, desired) \
+  atomic_store_explicit(pObject, desired, __ATOMIC_SEQ_CST)
+#define atomic_flag_test_and_set(x) \
+  atomic_flag_test_and_set_explicit(x, __ATOMIC_SEQ_CST)
+#define atomic_flag_clear(x) atomic_flag_clear_explicit(x, __ATOMIC_SEQ_CST)
+
 #elif (__GNUC__ + 0) * 100 + (__GNUC_MINOR__ + 0) >= 401
 
 #define atomic_init(obj, value)    ((void)(*(obj) = (value)))
@@ -210,6 +239,31 @@ typedef enum {
 #define atomic_store_explicit(object, desired, order) \
   ((void)atomic_exchange_explicit(object, desired, order))
 
+#define atomic_compare_exchange_strong(pObject, pExpected, desired) \
+  atomic_compare_exchange_strong_explicit(                          \
+      pObject, pExpected, desired, memory_order_seq_cst, memory_order_seq_cst)
+#define atomic_compare_exchange_weak(pObject, pExpected, desired) \
+  atomic_compare_exchange_weak_explicit(                          \
+      pObject, pExpected, desired, memory_order_seq_cst, memory_order_seq_cst)
+#define atomic_exchange(pObject, desired) \
+  atomic_exchange_explicit(pObject, desired, memory_order_seq_cst)
+#define atomic_fetch_add(pObject, operand) \
+  atomic_fetch_add_explicit(pObject, operand, memory_order_seq_cst)
+#define atomic_fetch_and(pObject, operand) \
+  atomic_fetch_and_explicit(pObject, operand, memory_order_seq_cst)
+#define atomic_fetch_or(pObject, operand) \
+  atomic_fetch_or_explicit(pObject, operand, memory_order_seq_cst)
+#define atomic_fetch_sub(pObject, operand) \
+  atomic_fetch_sub_explicit(pObject, operand, memory_order_seq_cst)
+#define atomic_fetch_xor(pObject, operand) \
+  atomic_fetch_xor_explicit(pObject, operand, memory_order_seq_cst)
+#define atomic_load(pObject) atomic_load_explicit(pObject, memory_order_seq_cst)
+#define atomic_store(pObject, desired) \
+  atomic_store_explicit(pObject, desired, memory_order_seq_cst)
+#define atomic_flag_test_and_set(x) \
+  atomic_flag_test_and_set_explicit(x, memory_order_seq_cst)
+#define atomic_flag_clear(x) atomic_flag_clear_explicit(x, memory_order_seq_cst)
+
 #else /* non-gcc or old gcc w/o x86 */
 #error "atomic operations not supported with this compiler and/or architecture"
 #endif
diff --git a/libc/intrin/brain16.c b/libc/intrin/brain16.c
new file mode 100644
index 000000000..95b0050b8
--- /dev/null
+++ b/libc/intrin/brain16.c
@@ -0,0 +1,97 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+
+/**
+ * @fileoverview bf16 compiler runtime
+ */
+
+_Float32 __extendbfsf2(__bf16 f) {
+  union {
+    __bf16 f;
+    uint16_t i;
+  } ub = {f};
+
+  // convert brain16 to binary32
+  uint32_t x = (uint32_t)ub.i << 16;
+
+  // force nan to quiet
+  if ((x & 0x7fffffff) > 0x7f800000)
+    x |= 0x00400000;
+
+  // pun to _Float32
+  union {
+    uint32_t i;
+    _Float32 f;
+  } uf = {x};
+  return uf.f;
+}
+
+_Float64 __extendbfdf2(__bf16 f) {
+  return __extendbfsf2(f);
+}
+
+#ifdef __x86_64__
+__float80 __extendbfxf2(__bf16 f) {
+  return __extendbfsf2(f);
+}
+#endif
+
+#ifdef __aarch64__
+_Float128 __extendbftf2(__bf16 f) {
+  return __extendbfsf2(f);
+}
+#endif
+
+__bf16 __truncsfbf2(_Float32 f) {
+  union {
+    _Float32 f;
+    uint32_t i;
+  } uf = {f};
+  uint32_t x = uf.i;
+
+  if ((x & 0x7fffffff) > 0x7f800000)
+    // force nan to quiet
+    x = (x | 0x00400000) >> 16;
+  else
+    // convert binary32 to brain16 with nearest rounding
+    x = (x + (0x7fff + ((x >> 16) & 1))) >> 16;
+
+  // pun to bf16
+  union {
+    uint16_t i;
+    __bf16 f;
+  } ub = {x};
+  return ub.f;
+}
+
+__bf16 __truncdfbf2(_Float64 f) {
+  return __truncsfbf2(f);
+}
+
+#ifdef __x86_64__
+__bf16 __truncxfbf2(__float80 f) {
+  return __truncsfbf2(f);
+}
+#endif
+
+#ifdef __aarch64__
+__bf16 __trunctfbf2(_Float128 f) {
+  return __truncsfbf2(f);
+}
+#endif
diff --git a/libc/intrin/bzero.c b/libc/intrin/bzero.c
index 8f5087109..2d51a9314 100644
--- a/libc/intrin/bzero.c
+++ b/libc/intrin/bzero.c
@@ -16,155 +16,18 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/dce.h"
-#include "libc/nexgen32e/nexgen32e.h"
-#include "libc/nexgen32e/x86feature.h"
 #include "libc/str/str.h"
 
-typedef char xmm_t __attribute__((__vector_size__(16), __aligned__(1)));
-typedef long long xmm_a __attribute__((__vector_size__(16), __aligned__(16)));
-
-static void bzero128(char *p, size_t n) {
-  xmm_t v = {0};
-  if (n <= 32) {
-    *(xmm_t *)(p + n - 16) = v;
-    *(xmm_t *)p = v;
-  } else {
-    do {
-      n -= 32;
-      *(xmm_t *)(p + n) = v;
-      *(xmm_t *)(p + n + 16) = v;
-    } while (n > 32);
-    *(xmm_t *)(p + 16) = v;
-    *(xmm_t *)p = v;
-  }
-}
-
-#if defined(__x86_64__) && !defined(__chibicc__)
-_Microarchitecture("avx") static void bzero_avx(char *p, size_t n) {
-  xmm_t v = {0};
-  if (n <= 32) {
-    *(xmm_t *)(p + n - 16) = v;
-    *(xmm_t *)p = v;
-  } else if (n >= 1024 && X86_HAVE(ERMS)) {
-    asm("rep stosb" : "+D"(p), "+c"(n), "=m"(*(char(*)[n])p) : "a"(0));
-  } else {
-    if (n < kHalfCache3 || !kHalfCache3) {
-      do {
-        n -= 32;
-        *(xmm_t *)(p + n) = v;
-        *(xmm_t *)(p + n + 16) = v;
-      } while (n > 32);
-    } else {
-      while ((uintptr_t)(p + n) & 15) {
-        p[--n] = 0;
-      }
-      do {
-        n -= 32;
-        __builtin_ia32_movntdq((xmm_a *)(p + n), (xmm_a)v);
-        __builtin_ia32_movntdq((xmm_a *)(p + n + 16), (xmm_a)v);
-      } while (n > 32);
-      asm("sfence");
-    }
-    *(xmm_t *)(p + 16) = v;
-    *(xmm_t *)p = v;
-  }
-}
-#endif
-
 /**
  * Sets memory to zero.
  *
- *     bzero n=0                          661 picoseconds
- *     bzero n=1                          661 ps/byte          1,476 mb/s
- *     bzero n=2                          330 ps/byte          2,952 mb/s
- *     bzero n=3                          220 ps/byte          4,428 mb/s
- *     bzero n=4                          165 ps/byte          5,904 mb/s
- *     bzero n=7                           94 ps/byte         10,333 mb/s
- *     bzero n=8                           41 ps/byte         23,618 mb/s
- *     bzero n=15                          44 ps/byte         22,142 mb/s
- *     bzero n=16                          20 ps/byte         47,236 mb/s
- *     bzero n=31                          21 ps/byte         45,760 mb/s
- *     bzero n=32                          20 ps/byte         47,236 mb/s
- *     bzero n=63                          10 ps/byte         92,997 mb/s
- *     bzero n=64                          15 ps/byte         62,982 mb/s
- *     bzero n=127                         15 ps/byte         62,490 mb/s
- *     bzero n=128                         10 ps/byte         94,473 mb/s
- *     bzero n=255                         14 ps/byte         68,439 mb/s
- *     bzero n=256                          9 ps/byte            105 gb/s
- *     bzero n=511                         15 ps/byte         62,859 mb/s
- *     bzero n=512                         11 ps/byte         83,976 mb/s
- *     bzero n=1023                        15 ps/byte         61,636 mb/s
- *     bzero n=1024                        10 ps/byte         88,916 mb/s
- *     bzero n=2047                         9 ps/byte            105 gb/s
- *     bzero n=2048                         8 ps/byte            109 gb/s
- *     bzero n=4095                         8 ps/byte            115 gb/s
- *     bzero n=4096                         8 ps/byte            118 gb/s
- *     bzero n=8191                         7 ps/byte            129 gb/s
- *     bzero n=8192                         7 ps/byte            130 gb/s
- *     bzero n=16383                        6 ps/byte            136 gb/s
- *     bzero n=16384                        6 ps/byte            137 gb/s
- *     bzero n=32767                        6 ps/byte            140 gb/s
- *     bzero n=32768                        6 ps/byte            141 gb/s
- *     bzero n=65535                       15 ps/byte         64,257 mb/s
- *     bzero n=65536                       15 ps/byte         64,279 mb/s
- *     bzero n=131071                      15 ps/byte         63,166 mb/s
- *     bzero n=131072                      15 ps/byte         63,115 mb/s
- *     bzero n=262143                      15 ps/byte         62,052 mb/s
- *     bzero n=262144                      15 ps/byte         62,097 mb/s
- *     bzero n=524287                      15 ps/byte         61,699 mb/s
- *     bzero n=524288                      15 ps/byte         61,674 mb/s
- *     bzero n=1048575                     16 ps/byte         60,179 mb/s
- *     bzero n=1048576                     15 ps/byte         61,330 mb/s
- *     bzero n=2097151                     15 ps/byte         61,071 mb/s
- *     bzero n=2097152                     15 ps/byte         61,065 mb/s
- *     bzero n=4194303                     16 ps/byte         60,942 mb/s
- *     bzero n=4194304                     16 ps/byte         60,947 mb/s
- *     bzero n=8388607                     16 ps/byte         60,872 mb/s
- *     bzero n=8388608                     16 ps/byte         60,879 mb/s
- *
  * @param p is memory address
  * @param n is byte length
  * @return p
  * @asyncsignalsafe
  */
 void bzero(void *p, size_t n) {
-  char *b;
-  uint64_t x;
-  b = p;
-#ifdef __x86_64__
-  asm("xorl\t%k0,%k0" : "=r"(x));
-#else
-  if (1) {
-    memset(p, 0, n);
-    return;
-  }
-  x = 0;
-#endif
-  if (n <= 16) {
-    if (n >= 8) {
-      __builtin_memcpy(b, &x, 8);
-      __builtin_memcpy(b + n - 8, &x, 8);
-    } else if (n >= 4) {
-      __builtin_memcpy(b, &x, 4);
-      __builtin_memcpy(b + n - 4, &x, 4);
-    } else if (n) {
-      do {
-        asm volatile("" ::: "memory");
-        b[--n] = x;
-      } while (n);
-    }
-#if defined(__x86_64__) && !defined(__chibicc__)
-  } else if (IsTiny()) {
-    asm("rep stosb" : "+D"(b), "+c"(n), "=m"(*(char(*)[n])b) : "a"(0));
-    return;
-  } else if (X86_HAVE(AVX)) {
-    bzero_avx(b, n);
-#endif
-  } else {
-    bzero128(b, n);
-  }
+  memset(p, 0, n);
 }
 
 __weak_reference(bzero, explicit_bzero);
diff --git a/libc/calls/checkcancel.c b/libc/intrin/checkcancel.c
similarity index 84%
rename from libc/calls/checkcancel.c
rename to libc/intrin/checkcancel.c
index 8b95bf3cd..51e1bfee7 100644
--- a/libc/calls/checkcancel.c
+++ b/libc/intrin/checkcancel.c
@@ -21,12 +21,16 @@
 #include "libc/intrin/weaken.h"
 #include "libc/thread/posixthread.internal.h"
 
-int _check_cancel(void) {
-  if (_weaken(_pthread_cancel_ack) &&  //
-      _pthread_self() && !(_pthread_self()->pt_flags & PT_NOCANCEL) &&
-      atomic_load_explicit(&_pthread_self()->pt_canceled,
-                           memory_order_acquire)) {
+textwindows bool _is_canceled(void) {
+  struct PosixThread *pt;
+  return _weaken(_pthread_cancel_ack) && (pt = _pthread_self()) &&
+         atomic_load_explicit(&pt->pt_canceled, memory_order_acquire) &&
+         !(pt->pt_flags & PT_NOCANCEL);
+}
+
+textwindows int _check_cancel(void) {
+  if (_is_canceled())
+    // once acknowledged _is_canceled() will return false
     return _weaken(_pthread_cancel_ack)();
-  }
   return 0;
 }
diff --git a/libc/intrin/clearenv.c b/libc/intrin/clearenv.c
index 35dcda617..14ed915f8 100644
--- a/libc/intrin/clearenv.c
+++ b/libc/intrin/clearenv.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 
 /**
diff --git a/libc/intrin/clock_gettime-mono.c b/libc/intrin/clock_gettime-mono.c
new file mode 100644
index 000000000..937967f57
--- /dev/null
+++ b/libc/intrin/clock_gettime-mono.c
@@ -0,0 +1,80 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/calls/struct/timespec.internal.h"
+#include "libc/calls/struct/timeval.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/nexgen32e/rdtsc.h"
+
+/**
+ * @fileoverview Monotonic clock polyfill.
+ *
+ * This isn't quite `CLOCK_MONOTONIC` and isn't quite `CLOCK_BOOTTIME`
+ * either; however it is fast and almost always goes in one direction.
+ *
+ * Intel architecture guarantees that a mapping exists between rdtsc &
+ * nanoseconds only if the cpu advertises invariant timestamps support
+ * however this shouldn't matter for a monotonic clock since we really
+ * don't want to have it tick while suspended. Sadly that shall happen
+ * since nearly all x86 microprocessors support invariant tsc which is
+ * why we try to avoid this fallback when possible.
+ */
+
+int sys_sysctl(int *, unsigned, void *, size_t *, void *, size_t) libcesque;
+
+static struct {
+  atomic_uint once;
+  unsigned long base;
+  struct timespec boot;
+} g_mono;
+
+static struct timespec get_boot_time_xnu(void) {
+  struct timeval t;
+  size_t n = sizeof(t);
+  int mib[] = {1 /* CTL_KERN */, 21 /* KERN_BOOTTIME */};
+  if (sys_sysctl(mib, 2, &t, &n, 0, 0) == -1)
+    __builtin_trap();
+  return timeval_totimespec(t);
+}
+
+static void sys_clock_gettime_mono_init(void) {
+  g_mono.base = rdtsc();
+  if (IsXnu()) {
+    g_mono.boot = get_boot_time_xnu();
+  } else {
+    __builtin_trap();
+  }
+}
+
+int sys_clock_gettime_mono(struct timespec *time) {
+  uint64_t nanos;
+  uint64_t cycles;
+  cosmo_once(&g_mono.once, sys_clock_gettime_mono_init);
+  // ensure we get the full 64 bits of counting, which avoids wraparound
+  cycles = rdtsc() - g_mono.base;
+  // this is a crude approximation, that's worked reasonably well so far
+  // only the kernel knows the actual mapping between rdtsc and nanosecs
+  // which we could attempt to measure ourselves using clock_gettime but
+  // we'd need to impose 100 ms of startup latency for a guess this good
+  nanos = cycles / 3;
+  *time = timespec_add(g_mono.boot, timespec_fromnanos(nanos));
+  return 0;
+}
diff --git a/libc/intrin/clock_gettime-nt.c b/libc/intrin/clock_gettime-nt.c
new file mode 100644
index 000000000..9020e9cfd
--- /dev/null
+++ b/libc/intrin/clock_gettime-nt.c
@@ -0,0 +1,117 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+#include "libc/calls/struct/timespec.internal.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/fmt/wintime.internal.h"
+#include "libc/nt/accounting.h"
+#include "libc/nt/runtime.h"
+#include "libc/nt/synchronization.h"
+#include "libc/nt/thread.h"
+#include "libc/nt/time.h"
+#ifdef __x86_64__
+
+#define _CLOCK_REALTIME           0
+#define _CLOCK_MONOTONIC          1
+#define _CLOCK_REALTIME_COARSE    2
+#define _CLOCK_BOOTTIME           3
+#define _CLOCK_PROCESS_CPUTIME_ID 4
+#define _CLOCK_THREAD_CPUTIME_ID  5
+#define _CLOCK_MONOTONIC_COARSE   6
+
+textwindows int sys_clock_gettime_nt(int clock, struct timespec *ts) {
+  uint64_t hectons;
+  struct NtFileTime ft, ftExit, ftUser, ftKernel, ftCreation;
+  switch (clock) {
+    case _CLOCK_REALTIME:
+      GetSystemTimePreciseAsFileTime(&ft);
+      *ts = FileTimeToTimeSpec(ft);
+      return 0;
+    case _CLOCK_REALTIME_COARSE:
+      GetSystemTimeAsFileTime(&ft);
+      *ts = FileTimeToTimeSpec(ft);
+      return 0;
+    case _CLOCK_MONOTONIC:
+      //
+      // "If you need a higher resolution timer, use the
+      //  QueryUnbiasedInterruptTime function, a multimedia timer, or a
+      //  high-resolution timer. The elapsed time retrieved by the
+      //  QueryUnbiasedInterruptTime function includes only time that
+      //  the system spends in the working state."
+      //
+      //                     —Quoth MSDN § Windows Time
+      //
+      QueryUnbiasedInterruptTimePrecise(&hectons);
+      *ts = WindowsDurationToTimeSpec(hectons);
+      return 0;
+    case _CLOCK_MONOTONIC_COARSE:
+      //
+      // "QueryUnbiasedInterruptTimePrecise is similar to the
+      //  QueryUnbiasedInterruptTime routine, but is more precise. The
+      //  interrupt time reported by QueryUnbiasedInterruptTime is based
+      //  on the latest tick of the system clock timer. The system clock
+      //  timer is the hardware timer that periodically generates
+      //  interrupts for the system clock. The uniform period between
+      //  system clock timer interrupts is referred to as a system clock
+      //  tick, and is typically in the range of 0.5 milliseconds to
+      //  15.625 milliseconds, depending on the hardware platform. The
+      //  interrupt time value retrieved by QueryUnbiasedInterruptTime
+      //  is accurate within a system clock tick. ¶To provide a system
+      //  time value that is more precise than that of
+      //  QueryUnbiasedInterruptTime, QueryUnbiasedInterruptTimePrecise
+      //  reads the timer hardware directly, therefore a
+      //  QueryUnbiasedInterruptTimePrecise call can be slower than a
+      //  QueryUnbiasedInterruptTime call."
+      //
+      //                     —Quoth MSDN § QueryUnbiasedInterruptTimePrecise
+      //
+      QueryUnbiasedInterruptTime(&hectons);
+      *ts = WindowsDurationToTimeSpec(hectons);
+      return 0;
+    case _CLOCK_BOOTTIME:
+      //
+      // "Unbiased interrupt-time means that only time that the system
+      //  is in the working state is counted; therefore, the interrupt
+      //  time count is not "biased" by time the system spends in sleep
+      //  or hibernation."
+      //
+      //                     —Quoth MSDN § Interrupt Time
+      //
+      QueryInterruptTimePrecise(&hectons);
+      *ts = WindowsDurationToTimeSpec(hectons);
+      return 0;
+    case _CLOCK_PROCESS_CPUTIME_ID:
+      GetProcessTimes(GetCurrentProcess(), &ftCreation, &ftExit, &ftKernel,
+                      &ftUser);
+      *ts = WindowsDurationToTimeSpec(ReadFileTime(ftUser) +
+                                      ReadFileTime(ftKernel));
+      return 0;
+    case _CLOCK_THREAD_CPUTIME_ID:
+      GetThreadTimes(GetCurrentThread(), &ftCreation, &ftExit, &ftKernel,
+                     &ftUser);
+      *ts = WindowsDurationToTimeSpec(ReadFileTime(ftUser) +
+                                      ReadFileTime(ftKernel));
+      return 0;
+    default:
+      return -EINVAL;
+  }
+}
+
+#endif  // __x86_64__
diff --git a/libc/calls/clock_gettime-sysv.c b/libc/intrin/clock_gettime-sysv.c
similarity index 100%
rename from libc/calls/clock_gettime-sysv.c
rename to libc/intrin/clock_gettime-sysv.c
diff --git a/libc/calls/clock_gettime-xnu.c b/libc/intrin/clock_gettime-xnu.c
similarity index 78%
rename from libc/calls/clock_gettime-xnu.c
rename to libc/intrin/clock_gettime-xnu.c
index e9548884e..a0eb5b9e2 100644
--- a/libc/calls/clock_gettime-xnu.c
+++ b/libc/intrin/clock_gettime-xnu.c
@@ -21,13 +21,10 @@
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/struct/timeval.internal.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sysv/consts/clock.h"
 #ifdef __x86_64__
 
-#define CTL_KERN      1
-#define KERN_BOOTTIME 21
-
 int sys_clock_gettime_xnu(int clock, struct timespec *ts) {
   long ax, dx;
   if (clock == CLOCK_REALTIME) {
@@ -47,31 +44,20 @@ int sys_clock_gettime_xnu(int clock, struct timespec *ts) {
     //   2. old xnu returns *ts in rax:rdx regs
     //
     // we assume this system call always succeeds
-    if (ts) {
-      asm volatile("syscall"
-                   : "=a"(ax), "=d"(dx)
-                   : "0"(0x2000000 | 116), "D"(ts), "S"(0), "1"(0)
-                   : "rcx", "r8", "r9", "r10", "r11", "memory");
-      if (ax) {
-        ts->tv_sec = ax;
-        ts->tv_nsec = dx;
-      }
-      ts->tv_nsec *= 1000;
+    asm volatile("syscall"
+                 : "=a"(ax), "=d"(dx)
+                 : "0"(0x2000000 | 116), "D"(ts), "S"(0), "1"(0)
+                 : "rcx", "r8", "r9", "r10", "r11", "memory");
+    if (ax) {
+      ts->tv_sec = ax;
+      ts->tv_nsec = dx;
     }
+    ts->tv_nsec *= 1000;
     return 0;
-  } else if (clock == CLOCK_MONOTONIC) {
-    if (!ts)
-      return 0;
+  } else if (clock == CLOCK_BOOTTIME ||   //
+             clock == CLOCK_MONOTONIC ||  //
+             clock == CLOCK_MONOTONIC_COARSE) {
     return sys_clock_gettime_mono(ts);
-  } else if (clock == CLOCK_BOOTTIME) {
-    struct timeval x;
-    size_t n = sizeof(x);
-    int mib[] = {CTL_KERN, KERN_BOOTTIME};
-    if (sysctl(mib, ARRAYLEN(mib), &x, &n, 0, 0) == -1)
-      return -1;
-    if (ts)
-      *ts = timeval_totimespec(timeval_sub(timeval_real(), x));
-    return 0;
   } else {
     return -EINVAL;
   }
diff --git a/libc/intrin/clock_gettime.c b/libc/intrin/clock_gettime.c
new file mode 100644
index 000000000..c087d8145
--- /dev/null
+++ b/libc/intrin/clock_gettime.c
@@ -0,0 +1,165 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=8 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+#include "libc/calls/struct/timespec.internal.h"
+#include "libc/calls/syscall_support-sysv.internal.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/runtime/syslib.internal.h"
+#include "libc/sysv/consts/clock.h"
+
+#ifdef __aarch64__
+#define CGT_VDSO __vdsosym("LINUX_2.6.39", "__kernel_clock_gettime")
+#else
+#define CGT_VDSO __vdsosym("LINUX_2.6", "__vdso_clock_gettime")
+#endif
+
+typedef int clock_gettime_f(int, struct timespec *);
+
+static clock_gettime_f *__clock_gettime_get(void) {
+  clock_gettime_f *cgt;
+  if (IsLinux() && (cgt = CGT_VDSO)) {
+    return cgt;
+  } else if (__syslib) {
+    return (void *)__syslib->__clock_gettime;
+#ifdef __x86_64__
+  } else if (IsWindows()) {
+    return sys_clock_gettime_nt;
+  } else if (IsXnu()) {
+    return sys_clock_gettime_xnu;
+#endif
+  } else {
+    return sys_clock_gettime;
+  }
+}
+
+static int __clock_gettime_init(int, struct timespec *);
+static clock_gettime_f *__clock_gettime = __clock_gettime_init;
+static int __clock_gettime_init(int clockid, struct timespec *ts) {
+  clock_gettime_f *cgt;
+  __clock_gettime = cgt = __clock_gettime_get();
+  return cgt(clockid, ts);
+}
+
+static int clock_gettime_impl(int clock, struct timespec *ts) {
+  // BSDs and sometimes Linux too will crash when `ts` is NULL
+  // it's also nice to not have to check for null in polyfills
+  struct timespec memory;
+  if (!ts)
+    ts = &memory;
+  return __clock_gettime(clock, ts);
+}
+
+/**
+ * Returns nanosecond time.
+ *
+ * The `clock` parameter may bo set to:
+ *
+ * - `CLOCK_REALTIME` returns a wall clock timestamp represented in
+ *   nanoseconds since the UNIX epoch (~1970). It'll count time in the
+ *   suspend state. This clock is subject to being smeared by various
+ *   adjustments made by NTP. These timestamps can have unpredictable
+ *   discontinuous jumps when clock_settime() is used. Therefore this
+ *   clock is the default clock for everything, even pthread condition
+ *   variables. Cosmopoiltan guarantees this clock will never raise
+ *   `EINVAL` and also guarantees `CLOCK_REALTIME == 0` will always be
+ *   the case. On Windows this maps to GetSystemTimePreciseAsFileTime().
+ *   On platforms with vDSOs like Linux, Windows, and MacOS ARM64 this
+ *   should take about 20 nanoseconds.
+ *
+ * - `CLOCK_MONOTONIC` returns a timestamp with an unspecified epoch,
+ *   that should be when the system was powered on. These timestamps
+ *   shouldn't go backwards. Timestamps shouldn't count time spent in
+ *   the sleep, suspend, and hibernation states. These timestamps won't
+ *   be impacted by clock_settime(). These timestamps may be impacted by
+ *   frequency adjustments made by NTP. Cosmopoiltan guarantees this
+ *   clock will never raise `EINVAL`. MacOS and BSDs use the word
+ *   "uptime" to describe this clock. On Windows this maps to
+ *   QueryUnbiasedInterruptTimePrecise().
+ *
+ * - `CLOCK_BOOTTIME` is a monotonic clock returning a timestamp with an
+ *   unspecified epoch, that should be relative to when the host system
+ *   was powered on. These timestamps shouldn't go backwards. Timestamps
+ *   should also include time spent in a sleep, suspend, or hibernation
+ *   state. These timestamps aren't impacted by clock_settime(), but
+ *   they may be impacted by frequency adjustments made by NTP. This
+ *   clock will raise an `EINVAL` error on extremely old Linux distros
+ *   like RHEL5. MacOS and BSDs use the word "monotonic" to describe
+ *   this clock. On Windows this maps to QueryInterruptTimePrecise().
+ *
+ * - `CLOCK_MONOTONIC_RAW` returns a timestamp from an unspecified
+ *   epoch. These timestamps don't count time spent in the sleep,
+ *   suspend, and hibernation states. This clock is not impacted by
+ *   clock_settime(). Unlike `CLOCK_MONOTONIC` this clock is guaranteed
+ *   to not be impacted by frequency adjustments. Providing this level
+ *   of assurances may make this clock 10x slower than the monotonic
+ *   clock. Furthermore this clock may cause `EINVAL` to be raised if
+ *   running on a host system that doesn't provide those guarantees,
+ *   e.g. OpenBSD and MacOS on AMD64.
+ *
+ * - `CLOCK_REALTIME_COARSE` is the same as `CLOCK_REALTIME` except
+ *   it'll go faster if the host OS provides a cheaper way to read the
+ *   wall time. Please be warned that coarse can be really coarse.
+ *   Rather than nano precision, you're looking at `CLK_TCK` precision,
+ *   which can lag as far as 30 milliseconds behind or possibly more.
+ *   Cosmopolitan may fallback to `CLOCK_REALTIME` if a faster less
+ *   accurate clock isn't provided by the system. This clock will raise
+ *   an `EINVAL` error on extremely old Linux distros like RHEL5. On
+ *   platforms with vDSOs like Linux, Windows, and MacOS ARM64 this
+ *   should take about 5 nanoseconds.
+ *
+ * - `CLOCK_MONOTONIC_COARSE` is the same as `CLOCK_MONOTONIC` except
+ *   it'll go faster if the host OS provides a cheaper way to read the
+ *   unbiased time. Please be warned that coarse can be really coarse.
+ *   Rather than nano precision, you're looking at `CLK_TCK` precision,
+ *   which can lag as far as 30 milliseconds behind or possibly more.
+ *   Cosmopolitan may fallback to `CLOCK_REALTIME` if a faster less
+ *   accurate clock isn't provided by the system. This clock will raise
+ *   an `EINVAL` error on extremely old Linux distros like RHEL5. On
+ *   platforms with vDSOs like Linux, Windows, and MacOS ARM64 this
+ *   should take about 5 nanoseconds.
+ *
+ * - `CLOCK_PROCESS_CPUTIME_ID` returns the amount of time this process
+ *   was actively scheduled. This is similar to getrusage() and clock().
+ *
+ * - `CLOCK_THREAD_CPUTIME_ID` returns the amount of time this thread
+ *   was actively scheduled. This is similar to getrusage() and clock().
+ *
+ * @param ts is where the result is stored (or null to do clock check)
+ * @return 0 on success, or -1 w/ errno
+ * @raise EFAULT if `ts` points to invalid memory
+ * @error EINVAL if `clock` isn't supported on this system
+ * @error EPERM if pledge() is in play without stdio promise
+ * @error ESRCH on NetBSD if PID/TID OR'd into `clock` wasn't found
+ * @see strftime(), gettimeofday()
+ * @asyncsignalsafe
+ * @vforksafe
+ */
+int clock_gettime(int clock, struct timespec *ts) {
+  int rc = clock_gettime_impl(clock, ts);
+  if (rc) {
+    errno = -rc;
+    rc = -1;
+  }
+  TIMETRACE("clock_gettime(%s, [%s]) → %d% m", DescribeClockName(clock),
+            DescribeTimespec(rc, ts), rc);
+  return rc;
+}
diff --git a/libc/intrin/clock_gettime_monotonic_nt.c b/libc/intrin/clock_gettime_monotonic_nt.c
new file mode 100644
index 000000000..f1371d27d
--- /dev/null
+++ b/libc/intrin/clock_gettime_monotonic_nt.c
@@ -0,0 +1,26 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.internal.h"
+#include "libc/nt/time.h"
+
+textwindows struct timespec sys_clock_gettime_monotonic_nt(void) {
+  uint64_t hectons;
+  QueryUnbiasedInterruptTimePrecise(&hectons);
+  return timespec_fromnanos(hectons * 100);
+}
diff --git a/libc/intrin/cosmo_futex.c b/libc/intrin/cosmo_futex.c
new file mode 100644
index 000000000..0c0531894
--- /dev/null
+++ b/libc/intrin/cosmo_futex.c
@@ -0,0 +1,427 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/atomic.h"
+#include "libc/calls/cp.internal.h"
+#include "libc/calls/internal.h"
+#include "libc/calls/sig.internal.h"
+#include "libc/calls/struct/sigset.h"
+#include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/calls/struct/timespec.internal.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/intrin/ulock.h"
+#include "libc/intrin/weaken.h"
+#include "libc/limits.h"
+#include "libc/nt/runtime.h"
+#include "libc/nt/synchronization.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/sysv/consts/futex.h"
+#include "libc/sysv/consts/sicode.h"
+#include "libc/sysv/errfuns.h"
+#include "libc/thread/freebsd.internal.h"
+#include "libc/thread/posixthread.internal.h"
+#include "libc/thread/thread.h"
+// clang-format off
+
+#define FUTEX_WAIT_BITS_ FUTEX_BITSET_MATCH_ANY
+
+errno_t cosmo_futex_thunk (atomic_int *, int, int, const struct timespec *, int *, int);
+errno_t _futex_wake (atomic_int *, int, int) asm ("cosmo_futex_thunk");
+int sys_futex_cp (atomic_int *, int, int, const struct timespec *, int *, int);
+
+static struct CosmoFutex {
+	atomic_uint once;
+	int FUTEX_WAIT_;
+	int FUTEX_PRIVATE_FLAG_;
+	int FUTEX_CLOCK_REALTIME_;
+	bool is_supported;
+	bool timeout_is_relative;
+} g_cosmo_futex;
+
+static void cosmo_futex_init (void) {
+	int e;
+	atomic_int x;
+
+	g_cosmo_futex.FUTEX_WAIT_ = FUTEX_WAIT;
+
+	if (IsWindows ()) {
+		g_cosmo_futex.is_supported = true;
+		return;
+	}
+
+	if (IsXnu ()) {
+		g_cosmo_futex.is_supported = true;
+		g_cosmo_futex.timeout_is_relative = true;
+		return;
+	}
+
+	if (IsFreebsd ()) {
+		g_cosmo_futex.is_supported = true;
+		g_cosmo_futex.FUTEX_PRIVATE_FLAG_ = FUTEX_PRIVATE_FLAG;
+		return;
+	}
+
+	if (!(g_cosmo_futex.is_supported = IsLinux () || IsOpenbsd ()))
+		return;
+
+	// In our testing, we found that the monotonic clock on various
+	// popular systems (such as Linux, and some BSD variants) was no
+	// better behaved than the realtime clock, and routinely took
+	// large steps backwards, especially on multiprocessors. Given
+	// that "monotonic" doesn't seem to mean what it says,
+	// implementers of cosmo_time might consider retaining the
+	// simplicity of a single epoch within an address space, by
+	// configuring any time synchronization mechanism (like ntp) to
+	// adjust for leap seconds by adjusting the rate, rather than
+	// with a backwards step.
+	e = errno;
+	atomic_store_explicit (&x, 0, memory_order_relaxed);
+	if (IsLinux () &&
+	    cosmo_futex_thunk (&x, FUTEX_WAIT_BITSET | FUTEX_CLOCK_REALTIME,
+			       1, 0, 0, FUTEX_BITSET_MATCH_ANY) == -EAGAIN) {
+		g_cosmo_futex.FUTEX_WAIT_ = FUTEX_WAIT_BITSET;
+		g_cosmo_futex.FUTEX_PRIVATE_FLAG_ = FUTEX_PRIVATE_FLAG;
+		g_cosmo_futex.FUTEX_CLOCK_REALTIME_ = FUTEX_CLOCK_REALTIME;
+	} else if (IsOpenbsd () ||
+		   (IsLinux () &&
+		    !_futex_wake (&x, FUTEX_WAKE_PRIVATE, 1))) {
+		g_cosmo_futex.FUTEX_WAIT_ = FUTEX_WAIT;
+		g_cosmo_futex.FUTEX_PRIVATE_FLAG_ = FUTEX_PRIVATE_FLAG;
+		g_cosmo_futex.timeout_is_relative = true;
+	} else {
+		g_cosmo_futex.FUTEX_WAIT_ = FUTEX_WAIT;
+		g_cosmo_futex.timeout_is_relative = true;
+	}
+	errno = e;
+}
+
+static uint32_t cosmo_time_64to32u (uint64_t duration) {
+	if (duration <= -1u)
+		return duration;
+	return -1u;
+}
+
+static int cosmo_futex_polyfill (atomic_int *w, int expect, int clock,
+				 struct timespec *abstime) {
+	for (;;) {
+		if (atomic_load_explicit (w, memory_order_acquire) != expect)
+			return 0;
+		if (_weaken (pthread_testcancel_np) &&
+		    _weaken (pthread_testcancel_np) ())
+			return -ECANCELED;
+		struct timespec now;
+		if (clock_gettime (clock, &now))
+			return -EINVAL;
+		if (abstime && timespec_cmp (now, *abstime) >= 0)
+			return -ETIMEDOUT;
+		pthread_yield_np ();
+	}
+}
+
+static int cosmo_futex_wait_win32 (atomic_int *w, int expect, char pshare,
+				   int clock, const struct timespec *timeout,
+				   struct PosixThread *pt,
+				   sigset_t waitmask) {
+#ifdef __x86_64__
+	int sig;
+	bool32 ok;
+	struct timespec deadline, wait, now;
+
+	if (timeout) {
+		deadline = *timeout;
+	} else {
+		deadline = timespec_max;
+	}
+
+	for (;;) {
+		if (clock_gettime (clock, &now))
+			return einval ();
+		if (timespec_cmp (now, deadline) >= 0)
+			return etimedout ();
+		wait = timespec_sub (deadline, now);
+		if (atomic_load_explicit (w, memory_order_acquire) != expect)
+			return 0;
+		if (pt) {
+			if (_check_cancel () == -1)
+				return -1; /* ECANCELED */
+			if ((sig = __sig_get (waitmask))) {
+				__sig_relay (sig, SI_KERNEL, waitmask);
+				if (_check_cancel () == -1)
+					return -1; /* ECANCELED */
+				return eintr ();
+			}
+			pt->pt_blkmask = waitmask;
+			atomic_store_explicit (&pt->pt_blocker, w, memory_order_release);
+		}
+		ok = WaitOnAddress (w, &expect, sizeof(int), cosmo_time_64to32u (timespec_tomillis (wait)));
+		if (pt) {
+			/* __sig_wake wakes our futex without changing `w` after enqueing signals */
+			atomic_store_explicit (&pt->pt_blocker, 0, memory_order_release);
+			if (ok && atomic_load_explicit (w, memory_order_acquire) == expect && (sig = __sig_get (waitmask))) {
+				__sig_relay (sig, SI_KERNEL, waitmask);
+				if (_check_cancel () == -1)
+					return -1; /* ECANCELED */
+				return eintr ();
+			}
+		}
+		if (ok) {
+			return 0;
+		} else {
+			unassert (GetLastError () == ETIMEDOUT);
+		}
+	}
+#else
+	return 0;
+#endif /* __x86_64__ */
+}
+
+static int cosmo_futex_fix_timeout (struct timespec *memory, int clock,
+				    const struct timespec *abstime,
+				    struct timespec **result) {
+	struct timespec now;
+	if (!abstime) {
+		*result = 0;
+		return 0;
+	} else if (!g_cosmo_futex.timeout_is_relative) {
+		*memory = *abstime;
+		*result = memory;
+		return 0;
+	} else {
+		if (clock_gettime (clock, &now))
+			return -EINVAL;
+		*memory = timespec_subz (*abstime, now);
+		*result = memory;
+		return 0;
+	}
+}
+
+/**
+ * Waits on futex.
+ *
+ * This function may be used to ask the OS to park the calling thread
+ * until cosmo_futex_wake() is called on the memory address `w`.
+ *
+ * @param w is your futex
+ * @param expect is the value `*w` is expected to have on entry
+ * @param pshare is `PTHREAD_PROCESS_PRIVATE` / `PTHREAD_PROCESS_SHARED`
+ * @param clock is `CLOCK_MONOTONIC`, `CLOCK_REALTIME`, etc.
+ * @param abstime is null to wait forever or absolute timestamp to stop
+ * @return 0 on success, or -errno on error
+ * @raise EINVAL on bad parameter
+ * @raise EAGAIN if `*w` wasn't `expect`
+ * @raise EINTR if a signal handler was called while waiting
+ * @raise ECANCELED if calling thread was canceled while waiting
+ * @cancelationpoint
+ */
+int cosmo_futex_wait (atomic_int *w, int expect, char pshare,
+		      int clock, const struct timespec *abstime) {
+	int e, rc, op;
+	struct CosmoTib *tib;
+	struct PosixThread *pt;
+	struct timespec tsmem;
+	struct timespec *timeout = 0;
+	BEGIN_CANCELATION_POINT;
+
+	cosmo_once (&g_cosmo_futex.once, cosmo_futex_init);
+
+	op = g_cosmo_futex.FUTEX_WAIT_;
+	if (pshare == PTHREAD_PROCESS_PRIVATE)
+		op |= g_cosmo_futex.FUTEX_PRIVATE_FLAG_;
+	if (clock == CLOCK_REALTIME ||
+	    clock == CLOCK_REALTIME_COARSE)
+		op |= g_cosmo_futex.FUTEX_CLOCK_REALTIME_;
+
+	if (abstime && timespec_cmp (*abstime, timespec_zero) <= 0) {
+		rc = -ETIMEDOUT;
+		goto Finished;
+	}
+
+	if (atomic_load_explicit (w, memory_order_acquire) != expect) {
+		rc = -EAGAIN;
+		goto Finished;
+	}
+
+	if ((rc = cosmo_futex_fix_timeout (&tsmem, clock, abstime, &timeout)))
+		goto Finished;
+
+	LOCKTRACE ("futex(%t [%d], %s, %#x, %s) → ...",
+		   w, atomic_load_explicit (w, memory_order_relaxed),
+		   DescribeFutexOp (op), expect,
+		   DescribeTimespec (0, timeout));
+
+	tib = __get_tls();
+	pt = (struct PosixThread *)tib->tib_pthread;
+
+	if (g_cosmo_futex.is_supported) {
+		e = errno;
+		if (IsWindows ()) {
+			// Windows 8 futexes don't support multiple processes :(
+			if (pshare) goto Polyfill;
+			sigset_t m = __sig_block ();
+			rc = cosmo_futex_wait_win32 (w, expect, pshare, clock, timeout, pt, m);
+			__sig_unblock (m);
+		} else if (IsXnu ()) {
+
+			/* XNU ulock (used by cosmo futexes) is an internal API, however:
+
+			     1. Unlike GCD it's cancelable i.e. can be EINTR'd by signals
+			     2. We have no choice but to use ulock for joining threads
+			     3. Grand Central Dispatch requires a busy loop workaround
+			     4. ulock makes our mutexes use 20% more system time (meh)
+			     5. ulock makes our mutexes use 40% less wall time (good)
+			     6. ulock makes our mutexes use 64% less user time (woop)
+			     7. GCD uses Mach timestamps D: ulock just uses rel. time
+
+			   ulock is an outstanding system call that must be used.
+			   gcd is not an acceptable alternative to ulock. */
+
+			uint32_t op, us;
+			if (pshare) {
+				op = UL_COMPARE_AND_WAIT_SHARED;
+			} else {
+				op = UL_COMPARE_AND_WAIT;
+			}
+			if (timeout) {
+				us = cosmo_time_64to32u (timespec_tomicros (*timeout));
+			} else {
+				us = -1u;
+			}
+			rc = ulock_wait (op, w, expect, us);
+			if (rc > 0) rc = 0; // don't care about #waiters
+		} else if (IsFreebsd ()) {
+			rc = sys_umtx_timedwait_uint (w, expect, pshare, clock, timeout);
+		} else {
+			if (IsOpenbsd()) {
+				// OpenBSD 6.8 futex() returns errors as
+				// positive numbers, without setting CF.
+				// This irregularity is fixed in 7.2 but
+				// unfortunately OpenBSD futex() defines
+				// its own ECANCELED condition, and that
+				// overlaps with our system call wrapper
+				if (pt) pt->pt_flags &= ~PT_OPENBSD_KLUDGE;
+			}
+			rc = sys_futex_cp (w, op, expect, timeout, 0, FUTEX_WAIT_BITS_);
+			if (IsOpenbsd()) {
+				// Handle the OpenBSD 6.x irregularity.
+				if (rc > 0) {
+					errno = rc;
+					rc = -1;
+				}
+				// Check if ECANCELED came from the kernel
+				// because a SA_RESTART signal handler was
+				// invoked, such as our SIGTHR callback.
+				if (rc == -1 && errno == ECANCELED &&
+				    pt && (~pt->pt_flags & PT_OPENBSD_KLUDGE)) {
+					errno = EINTR;
+				}
+			}
+		}
+		if (rc == -1) {
+			rc = -errno;
+			errno = e;
+		}
+	} else {
+	Polyfill:
+		rc = cosmo_futex_polyfill (w, expect, clock, timeout);
+	}
+
+Finished:
+	STRACE ("futex(%t [%d], %s, %#x, %s) → %s",
+		w, atomic_load_explicit (w, memory_order_relaxed),
+		DescribeFutexOp (op), expect,
+		DescribeTimespec (0, abstime),
+		DescribeErrno (rc));
+
+	END_CANCELATION_POINT;
+	return rc;
+}
+
+/**
+ * Wakes futex.
+ *
+ * @param w is your futex
+ * @param count is number of threads to wake (usually 1 or `INT_MAX`)
+ * @param pshare is `PTHREAD_PROCESS_PRIVATE` / `PTHREAD_PROCESS_SHARED`
+ * @return number of threads woken on success, or -errno on error
+ */
+int cosmo_futex_wake (atomic_int *w, int count, char pshare) {
+	int rc, op, fop;
+
+	cosmo_once (&g_cosmo_futex.once, cosmo_futex_init);
+
+	op = FUTEX_WAKE;
+	if (pshare == PTHREAD_PROCESS_PRIVATE)
+		op |= g_cosmo_futex.FUTEX_PRIVATE_FLAG_;
+
+	if (g_cosmo_futex.is_supported) {
+		if (IsWindows ()) {
+			if (pshare) {
+				goto Polyfill;
+			}
+			if (count == 1) {
+				WakeByAddressSingle (w);
+			} else {
+				WakeByAddressAll (w);
+			}
+			rc = 0;
+		} else if (IsXnu ()) {
+			uint32_t op;
+			if (pshare) {
+				op = UL_COMPARE_AND_WAIT_SHARED;
+			} else {
+				op = UL_COMPARE_AND_WAIT;
+			}
+			if (count > 1) {
+				op |= ULF_WAKE_ALL;
+			}
+			rc = ulock_wake (op, w, 0);
+			unassert (!rc || rc == -ENOENT);
+			if (!rc) {
+				rc = 1;
+			} else if (rc == -ENOENT) {
+				rc = 0;
+			}
+		} else if (IsFreebsd ()) {
+			if (pshare) {
+				fop = UMTX_OP_WAKE;
+			} else {
+				fop = UMTX_OP_WAKE_PRIVATE;
+			}
+			rc = _futex_wake (w, fop, count);
+		} else {
+			rc = _futex_wake (w, op, count);
+		}
+	} else {
+	Polyfill:
+		pthread_yield_np ();
+		rc = 0;
+	}
+
+	STRACE ("futex(%t [%d], %s, %d) → %d woken",
+		w, atomic_load_explicit (w, memory_order_relaxed),
+		DescribeFutexOp (op), count, rc);
+
+	return rc;
+}
diff --git a/libc/intrin/cosmo_futex_thunk.S b/libc/intrin/cosmo_futex_thunk.S
new file mode 100644
index 000000000..ad65cc106
--- /dev/null
+++ b/libc/intrin/cosmo_futex_thunk.S
@@ -0,0 +1,51 @@
+/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/sysv/consts/nr.h"
+#include "libc/macros.h"
+.privileged
+
+cosmo_futex_thunk:
+	beg
+	pro
+#ifdef __x86_64__
+	mov	%rcx,%r10
+	mov	__NR_futex,%eax
+	clc
+	syscall
+	jnc	1f
+	neg	%eax
+#elif defined(__aarch64__)
+	ldr	x7,=__hostos
+	ldr	w7,[x7]
+	tst	x7,1			// IsLinux()
+	mov	x7,98			// futex (Linux)
+	mov	x8,454			// _umtx_op (FreeBSD)
+	csel	x8,x7,x8,ne		// choose syscall magnum
+	mov	x7,0			// clear carry (for Linux)
+	adds	x7,x7,0			// clear carry
+	svc	#0			// call kernel
+	bcc	1f			// jump if not carry
+	neg	x0,x0			// linux style errno
+#else
+#error "unsupported architecture"
+#endif /* __x86_64__ */
+1:	epi
+	ret
+	end
+	.endfn	cosmo_futex_thunk,globl,hidden
diff --git a/libc/intrin/count.c b/libc/intrin/count.c
new file mode 100644
index 000000000..d4f4365bb
--- /dev/null
+++ b/libc/intrin/count.c
@@ -0,0 +1,26 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
+#include "libc/stdalign.h"
+#include "libc/thread/thread.h"
+
+// this counter is important because pthread_exit() needs to know if
+// it's an orphan thread, without needing to acquire _pthread_lock()
+// which causes contention and a file descriptor explosion on netbsd
+alignas(64) atomic_uint _pthread_count = 1;
diff --git a/libc/intrin/cp.c b/libc/intrin/cp.c
index 411226157..d98c36e66 100644
--- a/libc/intrin/cp.c
+++ b/libc/intrin/cp.c
@@ -18,6 +18,9 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/blockcancel.internal.h"
 #include "libc/calls/cp.internal.h"
+#include "libc/intrin/describebacktrace.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/nexgen32e/stackframe.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/thread/posixthread.internal.h"
@@ -26,11 +29,9 @@
 
 int begin_cancelation_point(void) {
   int state = 0;
-  struct CosmoTib *tib;
-  struct PosixThread *pt;
   if (__tls_enabled) {
-    tib = __get_tls();
-    if ((pt = (struct PosixThread *)tib->tib_pthread)) {
+    struct PosixThread *pt;
+    if ((pt = _pthread_self())) {
       state = pt->pt_flags & PT_INCANCEL;
       pt->pt_flags |= PT_INCANCEL;
     }
@@ -39,18 +40,20 @@ int begin_cancelation_point(void) {
 }
 
 void end_cancelation_point(int state) {
-  struct CosmoTib *tib;
-  struct PosixThread *pt;
   if (__tls_enabled) {
-    tib = __get_tls();
-    if ((pt = (struct PosixThread *)tib->tib_pthread)) {
+    struct PosixThread *pt;
+    if ((pt = _pthread_self())) {
       pt->pt_flags &= ~PT_INCANCEL;
       pt->pt_flags |= state;
     }
   }
 }
 
-void report_cancelation_point(void) {
+void report_cancelation_point(int sysv_ordinal, int xnu_ordinal) {
+  char bt[160];
+  struct StackFrame *bp = __builtin_frame_address(0);
+  kprintf("error: report_cancelation_point(%#x, %#x) %s\n", sysv_ordinal,
+          xnu_ordinal, _DescribeBacktrace(bt, bp));
   __builtin_trap();
 }
 
diff --git a/libc/intrin/createdirectory.c b/libc/intrin/createdirectory.c
index e0e787859..af41e4ba5 100644
--- a/libc/intrin/createdirectory.c
+++ b/libc/intrin/createdirectory.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/nt/thunk/msabi.h"
 
diff --git a/libc/intrin/createfile.c b/libc/intrin/createfile.c
index 594329c64..3063379b1 100644
--- a/libc/intrin/createfile.c
+++ b/libc/intrin/createfile.c
@@ -19,8 +19,8 @@
 #include "libc/nt/createfile.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/accessmask.h"
 #include "libc/nt/enum/creationdisposition.h"
 #include "libc/nt/errors.h"
@@ -56,12 +56,12 @@ TryAgain:
   hHandle = __imp_CreateFileW(lpFileName, dwDesiredAccess, dwShareMode,
                               opt_lpSecurity, dwCreationDisposition,
                               dwFlagsAndAttributes, opt_hTemplateFile);
-  NTTRACE("CreateFile(%#hs, %s, %s, %s, %s, %s, %ld) → {%ld, %d}", lpFileName,
-          (DescribeNtFileAccessFlags)(buf_accessflags, dwDesiredAccess),
-          (DescribeNtFileShareFlags)(buf_shareflags, dwShareMode),
-          (DescribeNtSecurityAttributes)(buf_secattr, opt_lpSecurity),
-          DescribeNtCreationDisposition(dwCreationDisposition),
-          (DescribeNtFileFlagAttr)(buf_flagattr, dwFlagsAndAttributes),
+  NTTRACE("CreateFile(%#!hs, %s, %s, %s, %s, %s, %ld) → {%ld, %d}", lpFileName,
+          _DescribeNtFileAccessFlags(buf_accessflags, dwDesiredAccess),
+          _DescribeNtFileShareFlags(buf_shareflags, dwShareMode),
+          _DescribeNtSecurityAttributes(buf_secattr, opt_lpSecurity),
+          _DescribeNtCreationDisposition(dwCreationDisposition),
+          _DescribeNtFileFlagAttr(buf_flagattr, dwFlagsAndAttributes),
           opt_hTemplateFile, hHandle, __imp_GetLastError());
   if (hHandle == -1) {
     switch (__imp_GetLastError()) {
diff --git a/libc/intrin/createfilemapping.c b/libc/intrin/createfilemapping.c
index 147793ec7..7d6912967 100644
--- a/libc/intrin/createfilemapping.c
+++ b/libc/intrin/createfilemapping.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/struct/securityattributes.h"
 #include "libc/nt/thunk/msabi.h"
diff --git a/libc/intrin/createfilemappingnuma.c b/libc/intrin/createfilemappingnuma.c
index a99653617..50ee5f7c4 100644
--- a/libc/intrin/createfilemappingnuma.c
+++ b/libc/intrin/createfilemappingnuma.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/struct/securityattributes.h"
 
diff --git a/libc/intrin/createnamedpipe.c b/libc/intrin/createnamedpipe.c
index 2bb67417a..b62a4e482 100644
--- a/libc/intrin/createnamedpipe.c
+++ b/libc/intrin/createnamedpipe.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/ipc.h"
 #include "libc/nt/runtime.h"
diff --git a/libc/intrin/createpipe.c b/libc/intrin/createpipe.c
index 7d6e9df1e..bde3623e1 100644
--- a/libc/intrin/createpipe.c
+++ b/libc/intrin/createpipe.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/ipc.h"
 #include "libc/nt/struct/securityattributes.h"
 #include "libc/nt/thunk/msabi.h"
diff --git a/libc/intrin/createprocess.c b/libc/intrin/createprocess.c
index 4205b5bcd..232c2d17b 100644
--- a/libc/intrin/createprocess.c
+++ b/libc/intrin/createprocess.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/thunk/msabi.h"
diff --git a/libc/intrin/createsymboliclink.c b/libc/intrin/createsymboliclink.c
index 663753b13..cd6be90c7 100644
--- a/libc/intrin/createsymboliclink.c
+++ b/libc/intrin/createsymboliclink.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 
 __msabi extern typeof(CreateSymbolicLink) *const __imp_CreateSymbolicLinkW;
diff --git a/libc/intrin/createthread.c b/libc/intrin/createthread.c
index 8a4bc7a64..a910e629f 100644
--- a/libc/intrin/createthread.c
+++ b/libc/intrin/createthread.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/securityattributes.h"
 #include "libc/nt/thread.h"
diff --git a/libc/intrin/cursor.c b/libc/intrin/cursor.c
new file mode 100644
index 000000000..b89b1be27
--- /dev/null
+++ b/libc/intrin/cursor.c
@@ -0,0 +1,61 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/fds.h"
+#include "libc/runtime/runtime.h"
+#include "libc/thread/posixthread.internal.h"
+
+struct Cursor *__cursor_new(void) {
+  struct Cursor *c;
+  if ((c = _mapanon(sizeof(struct Cursor)))) {
+    if ((c->shared = _mapshared(sizeof(struct CursorShared)))) {
+      c->shared->lock = (pthread_mutex_t)PTHREAD_SHARED_MUTEX_INITIALIZER_NP;
+    } else {
+      munmap(c, sizeof(struct Cursor));
+      c = 0;
+    }
+  }
+  return c;
+}
+
+void __cursor_ref(struct Cursor *c) {
+  if (!c)
+    return;
+  unassert(atomic_fetch_add_explicit(&c->refs, 1, memory_order_relaxed) >= 0);
+}
+
+int __cursor_unref(struct Cursor *c) {
+  if (!c)
+    return 0;
+  if (atomic_fetch_sub_explicit(&c->refs, 1, memory_order_release))
+    return 0;
+  atomic_thread_fence(memory_order_acquire);
+  int rc = munmap(c->shared, sizeof(struct CursorShared));
+  rc |= munmap(c, sizeof(struct Cursor));
+  return rc;
+}
+
+void __cursor_lock(struct Cursor *c) {
+  _pthread_mutex_lock(&c->shared->lock);
+}
+
+void __cursor_unlock(struct Cursor *c) {
+  _pthread_mutex_unlock(&c->shared->lock);
+}
diff --git a/libc/intrin/cxaatexit.c b/libc/intrin/cxaatexit.c
index a5b001162..eca0952ce 100644
--- a/libc/intrin/cxaatexit.c
+++ b/libc/intrin/cxaatexit.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bsr.h"
-#include "libc/intrin/cxaatexit.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/cxaatexit.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/intrin/cxaatexit.h b/libc/intrin/cxaatexit.h
new file mode 100644
index 000000000..ac89d7614
--- /dev/null
+++ b/libc/intrin/cxaatexit.h
@@ -0,0 +1,28 @@
+#ifndef COSMOPOLITAN_LIBC_RUNTIME_CXAATEXIT_H_
+#define COSMOPOLITAN_LIBC_RUNTIME_CXAATEXIT_H_
+#include "libc/stdio/stdio.h"
+#include "libc/thread/tls.h"
+COSMOPOLITAN_C_START_
+
+struct CxaAtexitBlocks {
+  struct CxaAtexitBlock {
+    unsigned mask;
+    struct CxaAtexitBlock *next;
+    struct CxaAtexit {
+      void *fp;
+      void *arg;
+      void *pred;
+    } p[32];
+  } *p, root;
+};
+
+extern struct CxaAtexitBlocks __cxa_blocks;
+
+void __cxa_lock(void) dontthrow;
+void __cxa_unlock(void) dontthrow;
+void __cxa_thread_finalize(void) dontthrow;
+void __cxa_printexits(FILE *, void *) libcesque;
+int __cxa_thread_atexit_impl(void *, void *, void *);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_RUNTIME_CXAATEXIT_H_ */
diff --git a/libc/intrin/cxaatexit.internal.h b/libc/intrin/cxaatexit.internal.h
deleted file mode 100644
index 45b566b70..000000000
--- a/libc/intrin/cxaatexit.internal.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_RUNTIME_CXAATEXIT_H_
-#define COSMOPOLITAN_LIBC_RUNTIME_CXAATEXIT_H_
-#include "libc/stdio/stdio.h"
-#include "libc/thread/tls.h"
-COSMOPOLITAN_C_START_
-
-struct CxaAtexitBlocks {
-  struct CxaAtexitBlock {
-    unsigned mask;
-    struct CxaAtexitBlock *next;
-    struct CxaAtexit {
-      void *fp;
-      void *arg;
-      void *pred;
-    } p[32];
-  } *p, root;
-};
-
-extern struct CxaAtexitBlocks __cxa_blocks;
-
-void __cxa_lock(void) libcesque;
-void __cxa_unlock(void) libcesque;
-void __cxa_thread_finalize(void) libcesque;
-void __cxa_printexits(FILE *, void *) libcesque;
-int __cxa_thread_atexit_impl(void *, void *, void *);
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_RUNTIME_CXAATEXIT_H_ */
diff --git a/libc/intrin/cxablocks.c b/libc/intrin/cxablocks.c
index 86b4965da..af74fdf9a 100644
--- a/libc/intrin/cxablocks.c
+++ b/libc/intrin/cxablocks.c
@@ -16,6 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/cxaatexit.internal.h"
+#include "libc/intrin/cxaatexit.h"
 
 struct CxaAtexitBlocks __cxa_blocks;
diff --git a/libc/intrin/cxafinalize.c b/libc/intrin/cxafinalize.c
index 119bebdd4..da9b30441 100644
--- a/libc/intrin/cxafinalize.c
+++ b/libc/intrin/cxafinalize.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bsf.h"
-#include "libc/intrin/cxaatexit.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/cxaatexit.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/libc/intrin/cxalock.c b/libc/intrin/cxalock.c
index 4e6de59d0..cb5256757 100644
--- a/libc/intrin/cxalock.c
+++ b/libc/intrin/cxalock.c
@@ -16,23 +16,16 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/cxaatexit.internal.h"
+#include "libc/intrin/cxaatexit.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 
-static pthread_mutex_t __cxa_lock_obj;
-
-void __cxa_wipe(void) {
-  pthread_mutex_init(&__cxa_lock_obj, 0);
-}
+pthread_mutex_t __cxa_lock_obj = PTHREAD_MUTEX_INITIALIZER;
 
 void __cxa_lock(void) {
-  pthread_mutex_lock(&__cxa_lock_obj);
+  _pthread_mutex_lock(&__cxa_lock_obj);
 }
 
 void __cxa_unlock(void) {
-  pthread_mutex_unlock(&__cxa_lock_obj);
-}
-
-__attribute__((__constructor__(60))) static textstartup void __cxa_init() {
-  pthread_atfork(__cxa_lock, __cxa_unlock, __cxa_wipe);
+  _pthread_mutex_unlock(&__cxa_lock_obj);
 }
diff --git a/libc/intrin/deadlock.c b/libc/intrin/deadlock.c
new file mode 100644
index 000000000..57da577a4
--- /dev/null
+++ b/libc/intrin/deadlock.c
@@ -0,0 +1,277 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "ape/sections.internal.h"
+#include "libc/assert.h"
+#include "libc/atomic.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/maps.h"
+#include "libc/macros.h"
+#include "libc/str/str.h"
+#include "libc/thread/lock.h"
+#include "libc/thread/thread.h"
+#include "libc/thread/tls.h"
+
+/**
+ * @fileoverview deadlock detector for statically allocated locks
+ *
+ * This module helps you spot multi-threading bugs in your program.
+ * High-level abstractions like mutexes are much easier to use than
+ * atomics, but they still carry their own non-obvious dangers. For
+ * example, nesting locks need to be nested in a consistent way and
+ * normal mutexes can't be required recursively. Normally this will
+ * cause your program to deadlock, i.e. hang indefinitely, but this
+ * module can detect such conditions and return errors instead, and
+ * better yet print helpful information when using `cosmocc -mdbg`.
+ */
+
+#define ABI privileged optimizesize
+
+// building our visitor function using this optimizesize keyword shrinks
+// the stack memory requirement from 7168 to 2048 bytes. totally amazing
+// although please note this maximum isn't a hard limit. for normal mode
+// builds your posix mandated mutex error checking will be less accurate
+// but still helpful and reliable, although your cosmocc -mdbg will trap
+// and report that you've run into the limit, so you can talk to justine
+#define MAX_LOCKS 64
+
+// cosmo's tib reserves space for 64 nested locks before things degrade.
+// the cosmopolitan c runtime defines 16 locks, which are all registered
+// with pthread_atfork(). it means you get to have 48 mutexes right now,
+// and if you register all of them, then calling fork() will cause there
+// to be 2080 edges in your lock graph. talk to justine if you need more
+// because we're obviously going to need to find a way to make this grow
+#define LOCK_EDGES_MAX 2080
+
+// supported lock objects must define `void *_edges`
+#define LOCK_EDGES_OFFSET 0
+static_assert(offsetof(struct MapLock, edges) == LOCK_EDGES_OFFSET);
+static_assert(offsetof(pthread_mutex_t, _edges) == LOCK_EDGES_OFFSET);
+
+struct LockEdge {
+  struct LockEdge *next;
+  void *dest;
+};
+
+struct VisitedLock {
+  struct VisitedLock *next;
+  void *lock;
+};
+
+typedef _Atomic(struct LockEdge *) LockEdges;
+
+static struct DeadlockDetector {
+  atomic_size_t edges_allocated;
+  struct LockEdge edges_memory[LOCK_EDGES_MAX];
+} __deadlock;
+
+forceinline struct CosmoTib *__deadlock_tls(void) {
+  return __get_tls_privileged();
+}
+
+forceinline LockEdges *get_lock_edges(void *lock) {
+  return (LockEdges *)((char *)lock + LOCK_EDGES_OFFSET);
+}
+
+forceinline struct LockEdge *load_lock_edges(LockEdges *edges) {
+  return atomic_load_explicit(edges, memory_order_relaxed);
+}
+
+ABI static int is_static_memory(void *lock) {
+  return _etext <= (unsigned char *)lock && (unsigned char *)lock < _end;
+}
+
+ABI static struct LockEdge *__deadlock_alloc(void) {
+  size_t edges_allocated =
+      atomic_load_explicit(&__deadlock.edges_allocated, memory_order_relaxed);
+  for (;;) {
+    if (edges_allocated == LOCK_EDGES_MAX) {
+      if (IsModeDbg()) {
+        kprintf("error: cosmo LOCK_EDGES_MAX needs to be increased\n");
+        DebugBreak();
+      }
+      return 0;
+    }
+    if (atomic_compare_exchange_weak_explicit(
+            &__deadlock.edges_allocated, &edges_allocated, edges_allocated + 1,
+            memory_order_relaxed, memory_order_relaxed))
+      return &__deadlock.edges_memory[edges_allocated];
+  }
+}
+
+ABI static void __deadlock_add_edge(void *from, void *dest) {
+  LockEdges *edges = get_lock_edges(from);
+  for (struct LockEdge *e = load_lock_edges(edges); e; e = e->next)
+    if (e->dest == dest)
+      return;
+  struct LockEdge *edge;
+  if ((edge = __deadlock_alloc())) {
+    edge->next = load_lock_edges(edges);
+    edge->dest = dest;
+    // we tolerate duplicate elements in the interest of performance.
+    // once an element is inserted, it's never removed. that's why we
+    // don't need need to worry about the aba problem. the cas itself
+    // is very important since it ensures inserted edges aren't lost.
+    for (;;)
+      if (atomic_compare_exchange_weak_explicit(edges, &edge->next, edge,
+                                                memory_order_relaxed,
+                                                memory_order_relaxed))
+        break;
+  }
+}
+
+ABI static bool __deadlock_visit(void *lock, struct VisitedLock *visited,
+                                 int notrap, int depth) {
+  if (++depth == MAX_LOCKS) {
+    if (IsModeDbg()) {
+      kprintf("error: too much recursion in deadlock detector\n");
+      DebugBreak();
+    }
+    return false;
+  }
+  for (struct VisitedLock *v = visited; v; v = v->next) {
+    if (v->lock == lock) {
+      if (IsModeDbg() && !notrap) {
+        // lock hierarchy violated!
+        //
+        // when you lock mutexes in a nested way, your locks must be
+        // nested in the same order globally. otherwise deadlocks might
+        // occur. for example, if you say in your first thread
+        //
+        //     pthread_mutex_lock(&x);
+        //     pthread_mutex_lock(&y);
+        //     pthread_mutex_unlock(&y);
+        //     pthread_mutex_unlock(&x);
+        //
+        // then in your second thread you say
+        //
+        //     pthread_mutex_lock(&y);
+        //     pthread_mutex_lock(&x);
+        //     pthread_mutex_unlock(&x);
+        //     pthread_mutex_unlock(&y);
+        //
+        // then a deadlock might happen, because {x→y, y→x} is cyclic!
+        // they don't happen often, but this is the kind of thing that
+        // matters if you want to build carrier grade production stuff
+        kprintf("error: cycle detected in directed graph of nested locks\n");
+        for (struct VisitedLock *v = visited; v; v = v->next)
+          kprintf("\t- %t\n", v->lock);  // strongly connected component
+        DebugBreak();
+      }
+      return true;
+    }
+  }
+  LockEdges *edges = get_lock_edges(lock);
+  struct VisitedLock visit = {visited, lock};
+  for (struct LockEdge *e = load_lock_edges(edges); e; e = e->next)
+    if (__deadlock_visit(e->dest, &visit, notrap, depth))
+      return true;
+  return false;
+}
+
+/**
+ * Returns true if lock is already locked by calling thread.
+ *
+ * This function may return false negatives if we run out of TLS memory.
+ * That suboptimal condition will be reported in debug mode.
+ *
+ * @return 1 if lock is certainly owned by calling thread, 0 if lock is
+ *     certainly not owned by calling thread, and -1 if we're uncertain
+ */
+ABI int __deadlock_tracked(void *lock) {
+  int full = 1;
+  int owned = 0;
+  struct CosmoTib *tib = __deadlock_tls();
+  for (int i = 0; i < ARRAYLEN(tib->tib_locks); ++i) {
+    full &= tib->tib_locks[i] != NULL;
+    owned |= tib->tib_locks[i] == lock;
+  }
+  if (full)
+    return -1;
+  if (!owned && !is_static_memory(lock))
+    return -1;
+  return owned;
+}
+
+/**
+ * Records that lock is held by thread.
+ * @param notrap can prevent error printing and debug breaking
+ * @asyncsignalsafe
+ */
+ABI void __deadlock_track(void *lock, int notrap) {
+  if (!notrap && !is_static_memory(lock))
+    return;
+  struct CosmoTib *tib = __deadlock_tls();
+  for (int i = 0; i < ARRAYLEN(tib->tib_locks); ++i) {
+    if (!tib->tib_locks[i]) {
+      tib->tib_locks[i] = lock;
+      return;
+    }
+  }
+  if (IsModeDbg()) {
+    kprintf("error: cosmo tls max lock depth needs to be increased!\n");
+    DebugBreak();
+  }
+}
+
+/**
+ * Records relationship for all held locks to `lock`.
+ * @param notrap can prevent error printing and debug breaking
+ * @asyncsignalsafe
+ */
+ABI void __deadlock_record(void *lock, int notrap) {
+  if (!notrap && !is_static_memory(lock))
+    return;
+  struct CosmoTib *tib = __deadlock_tls();
+  for (int i = 0; i < ARRAYLEN(tib->tib_locks); ++i)
+    if (tib->tib_locks[i] && tib->tib_locks[i] != lock)
+      __deadlock_add_edge(tib->tib_locks[i], lock);
+}
+
+/**
+ * Returns EDEADLK if locking `lock` could cause a deadlock.
+ * @param notrap can prevent error printing and debug breaking
+ * @asyncsignalsafe
+ */
+ABI int __deadlock_check(void *lock, int notrap) {
+  struct CosmoTib *tib = __deadlock_tls();
+  for (int i = 0; i < ARRAYLEN(tib->tib_locks); ++i) {
+    if (tib->tib_locks[i] == lock)
+      return 0;
+    if (tib->tib_locks[i]) {
+      struct VisitedLock visit = {0, tib->tib_locks[i]};
+      if (__deadlock_visit(lock, &visit, notrap, 0))
+        return EDEADLK;
+    }
+  }
+  return 0;
+}
+
+/**
+ * Records that lock isn't held by thread.
+ * @asyncsignalsafe
+ */
+ABI void __deadlock_untrack(void *lock) {
+  struct CosmoTib *tib = __deadlock_tls();
+  for (int i = 0; i < ARRAYLEN(tib->tib_locks); ++i)
+    tib->tib_locks[i] = tib->tib_locks[i] != lock ? tib->tib_locks[i] : 0;
+}
diff --git a/libc/intrin/deletefile.c b/libc/intrin/deletefile.c
index 1fd3b54ed..6161b816b 100644
--- a/libc/intrin/deletefile.c
+++ b/libc/intrin/deletefile.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/nt/thunk/msabi.h"
 
diff --git a/libc/intrin/demangle.c b/libc/intrin/demangle.c
index ad21c1eb1..c44803f12 100644
--- a/libc/intrin/demangle.c
+++ b/libc/intrin/demangle.c
@@ -91,6 +91,8 @@ Copyright (c) 2024 Justine Tunney <jtunney@gmail.com>");
  *
  */
 
+#define ABI privileged optimizesize
+
 #define DEMANGLE_NO_FLOATING_POINT
 
 #define ASSERT(x)	    (void)0
@@ -103,6 +105,7 @@ Copyright (c) 2024 Justine Tunney <jtunney@gmail.com>");
 #define ELFTC_SUCCESS	    1
 
 #define VECTOR_DEF_CAPACITY 1
+#define MAX_DEPTH           20
 
 typedef unsigned short index_t;
 
@@ -188,6 +191,7 @@ struct demangle_data {
 	enum type_qualifier ref_qualifier_type; /* ref qualifier type */
 	enum push_qualifier push_qualifier;	/* which qualifiers to push */
 	int func_type;
+	int depth;
 	const char *cur;	/* current mangled name ptr */
 	const char *last_sname; /* last source name */
 	intptr_t jmpbuf[5];
@@ -220,16 +224,18 @@ static int demangle_read_sname(struct demangle_data *);
 static int demangle_read_subst(struct demangle_data *);
 static int demangle_read_type(struct demangle_data *, struct type_delimit *);
 
-static privileged size_t
+ABI static size_t
 demangle_strlen(const char *s)
 {
 	size_t n = 0;
-	while (*s++)
+	while (*s++) {
+		asm volatile("" ::: "memory");
 		++n;
+	}
 	return n;
 }
 
-static privileged char *
+ABI static char *
 demangle_stpcpy(char *d, const char *s)
 {
 	size_t i = 0;
@@ -240,7 +246,7 @@ demangle_stpcpy(char *d, const char *s)
 	}
 }
 
-static privileged void *
+ABI static void *
 demangle_mempcpy(void *a, const void *b, size_t n)
 {
 	char *d = a;
@@ -250,14 +256,14 @@ demangle_mempcpy(void *a, const void *b, size_t n)
 	return d;
 }
 
-static privileged void *
+ABI static void *
 demangle_memcpy(void *a, const void *b, size_t n)
 {
 	demangle_mempcpy(a, b, n);
 	return a;
 }
 
-static privileged int
+ABI static int
 demangle_strncmp(const char *a, const char *b, size_t n)
 {
 	size_t i = 0;
@@ -268,7 +274,7 @@ demangle_strncmp(const char *a, const char *b, size_t n)
 	return (a[i] & 0xff) - (b[i] & 0xff);
 }
 
-static privileged int
+ABI static int
 demangle_memcmp(const void *a, const void *b, size_t n)
 {
 	int c;
@@ -283,7 +289,7 @@ demangle_memcmp(const void *a, const void *b, size_t n)
 	return 0;
 }
 
-static privileged void
+ABI static void
 demangle_strlcpy(char *dst, const char *src, size_t dsize)
 {
 	size_t remain;
@@ -295,7 +301,7 @@ demangle_strlcpy(char *dst, const char *src, size_t dsize)
 		*dst = 0;
 }
 
-static privileged long
+ABI static long
 demangle_strtol(const char *s, int base)
 {
 	static const uint8_t demangle_base36[80] = { 1, 2, 3, 4, 5, 6, 7, 8, 9,
@@ -312,7 +318,7 @@ demangle_strtol(const char *s, int base)
 	return x;
 }
 
-static privileged char *
+ABI static char *
 demangle_strstr(const char *haystack, const char *needle)
 {
 	size_t i;
@@ -333,7 +339,7 @@ demangle_strstr(const char *haystack, const char *needle)
 	return 0;
 }
 
-static privileged char *
+ABI static char *
 demangle_utoa(char *p, unsigned long long x)
 {
 	char t;
@@ -354,7 +360,7 @@ demangle_utoa(char *p, unsigned long long x)
 	return p + i;
 }
 
-static privileged char *
+ABI static char *
 demangle_itoa(char *p, long long x)
 {
 	if (x < 0)
@@ -362,7 +368,7 @@ demangle_itoa(char *p, long long x)
 	return demangle_utoa(p, x);
 }
 
-static privileged void
+ABI static void
 demangle_free(struct demangle_data *h, void *ptr)
 {
 	index_t base;
@@ -379,14 +385,17 @@ demangle_free(struct demangle_data *h, void *ptr)
 	}
 }
 
-static privileged returnspointerwithnoaliases returnsnonnull void *
-demangle_malloc(struct demangle_data *h, int a, int n)
+ABI static returnspointerwithnoaliases returnsnonnull void *
+demangle_malloc(struct demangle_data *h, long a, long n)
 {
-	int rem;
+	long rem;
 	uintptr_t ptr;
 	index_t next, next2;
 	index_t *link, *link2;
-	int b = sizeof(index_t);
+	long b = sizeof(index_t);
+
+	if (n < 0 || n >= 32768)
+		__builtin_longjmp(h->jmpbuf, 1);
 
 	/* Roundup size. */
 	n += a - 1;
@@ -433,7 +442,7 @@ demangle_malloc(struct demangle_data *h, int a, int n)
 	}
 }
 
-static privileged returnspointerwithnoaliases char *
+ABI static returnspointerwithnoaliases char *
 demangle_strdup(struct demangle_data *h, const char *s)
 {
 	char *d = 0;
@@ -445,7 +454,7 @@ demangle_strdup(struct demangle_data *h, const char *s)
 	return d;
 }
 
-static privileged void
+ABI static void
 demangle_vector_str_dest(struct demangle_data *h, struct vector_str *v)
 {
 	int i;
@@ -454,7 +463,7 @@ demangle_vector_str_dest(struct demangle_data *h, struct vector_str *v)
 	demangle_free(h, v->container);
 }
 
-static privileged void
+ABI static void
 demangle_vector_type_qualifier_dest(struct demangle_data *d,
     struct vector_type_qualifier *v)
 {
@@ -462,7 +471,7 @@ demangle_vector_type_qualifier_dest(struct demangle_data *d,
 	demangle_vector_str_dest(d, &v->ext_name);
 }
 
-static privileged void
+ABI static void
 demangle_stack_str_init(struct stack_str *ss)
 {
 	ss->str = ss->buf;
@@ -471,7 +480,7 @@ demangle_stack_str_init(struct stack_str *ss)
 	ss->cap = sizeof(ss->buf);
 }
 
-static privileged void
+ABI static void
 demangle_stack_str_append(struct demangle_data *h, struct stack_str *ss,
     const char *str, size_t len)
 {
@@ -494,7 +503,7 @@ demangle_stack_str_append(struct demangle_data *h, struct stack_str *ss,
 #define demangle_stack_str_append_str(h, ss, s) \
 	demangle_stack_str_append(h, ss, s, demangle_strlen(s))
 
-static privileged size_t
+ABI static size_t
 demangle_get_strlen_sum(struct demangle_data *h, const struct vector_str *v)
 {
 	size_t i, len = 0;
@@ -504,7 +513,7 @@ demangle_get_strlen_sum(struct demangle_data *h, const struct vector_str *v)
 	return len;
 }
 
-static privileged int
+ABI static int
 demangle_demangle_strncmp(const char *a, const char *b, size_t n)
 {
 	size_t i = 0;
@@ -522,7 +531,7 @@ demangle_demangle_strncmp(const char *a, const char *b, size_t n)
  * @param l Length of the string.
  * @return -1 at failed, 0 at not found, 1 at found.
  */
-static privileged int
+ABI static int
 demangle_vector_str_find(struct demangle_data *h, const struct vector_str *v,
     const char *o, size_t l)
 {
@@ -546,7 +555,7 @@ demangle_vector_str_find(struct demangle_data *h, const struct vector_str *v,
  * @param l Length of the string.
  * @return NULL at failed or NUL terminated new allocated string.
  */
-static privileged char *
+ABI static char *
 demangle_vector_str_get_flat(struct demangle_data *ddata,
     const struct vector_str *v, size_t *l)
 {
@@ -572,7 +581,7 @@ demangle_vector_str_get_flat(struct demangle_data *ddata,
 	return rtn;
 }
 
-static privileged void
+ABI static void
 demangle_vector_str_grow(struct demangle_data *ddata, struct vector_str *v)
 {
 	size_t i, tmp_cap;
@@ -600,7 +609,7 @@ demangle_vector_str_grow(struct demangle_data *ddata, struct vector_str *v)
  * @brief Initialize vector_str.
  * @return false at failed, true at success.
  */
-static privileged void
+ABI static void
 demangle_vector_str_init(struct demangle_data *ddata, struct vector_str *v)
 {
 	v->size = 0;
@@ -616,7 +625,7 @@ demangle_vector_str_init(struct demangle_data *ddata, struct vector_str *v)
  * @brief Remove last element in vector_str.
  * @return false at failed, true at success.
  */
-static privileged bool
+ABI static bool
 demangle_vector_str_pop(struct vector_str *v)
 {
 	if (!v)
@@ -636,7 +645,7 @@ demangle_vector_str_pop(struct vector_str *v)
  * @brief Push back string to vector.
  * @return false at failed, true at success.
  */
-static privileged bool
+ABI static bool
 demangle_vector_str_push(struct demangle_data *ddata, struct vector_str *v,
     const char *str, size_t len)
 {
@@ -660,7 +669,7 @@ demangle_vector_str_push(struct demangle_data *ddata, struct vector_str *v,
  * @brief Push front org vector to det vector.
  * @return false at failed, true at success.
  */
-static privileged bool
+ABI static bool
 demangle_vector_str_push_vector_head(struct demangle_data *ddata,
     struct vector_str *dst, struct vector_str *org)
 {
@@ -693,7 +702,7 @@ demangle_vector_str_push_vector_head(struct demangle_data *ddata,
  * @brief Push org vector to the tail of det vector.
  * @return false at failed, true at success.
  */
-static privileged bool
+ABI static bool
 demangle_vector_str_push_vector(struct demangle_data *ddata,
     struct vector_str *dst, struct vector_str *org)
 {
@@ -731,7 +740,7 @@ demangle_vector_str_push_vector(struct demangle_data *ddata,
  * If r_len is not NULL, string length will be returned.
  * @return NULL at failed or NUL terminated new allocated string.
  */
-static privileged returnspointerwithnoaliases char *
+ABI static returnspointerwithnoaliases char *
 demangle_vector_str_substr(struct demangle_data *ddata,
     const struct vector_str *v, size_t begin, size_t end, size_t *r_len)
 {
@@ -757,7 +766,7 @@ demangle_vector_str_substr(struct demangle_data *ddata,
 	return rtn;
 }
 
-static privileged int
+ABI static int
 demangle_vector_read_cmd_pop(struct vector_read_cmd *v)
 {
 	if (!v->size)
@@ -770,7 +779,7 @@ demangle_vector_read_cmd_pop(struct vector_read_cmd *v)
 	return 1;
 }
 
-static privileged void
+ABI static void
 demangle_vector_read_cmd_init(struct demangle_data *ddata,
     struct vector_read_cmd *v)
 {
@@ -781,7 +790,7 @@ demangle_vector_read_cmd_init(struct demangle_data *ddata,
 	    alignof(*v->r_container), sizeof(*v->r_container) * v->capacity);
 }
 
-static privileged void
+ABI static void
 demangle_data_init(struct demangle_data *d, const char *cur)
 {
 	demangle_vector_str_init(d, &d->output);
@@ -811,7 +820,7 @@ demangle_data_init(struct demangle_data *d, const char *cur)
 	d->last_sname = NULL;
 }
 
-static privileged int
+ABI static int
 demangle_push_str(struct demangle_data *ddata, const char *str, size_t len)
 {
 	if (!str || !len)
@@ -828,7 +837,7 @@ demangle_push_str(struct demangle_data *ddata, const char *str, size_t len)
 }
 
 #ifndef DEMANGLE_NO_FLOATING_POINT
-static privileged int
+ABI static int
 demangle_push_fp(struct demangle_data *ddata,
     char *decoder(struct demangle_data *, const char *, size_t))
 {
@@ -857,13 +866,13 @@ demangle_push_fp(struct demangle_data *ddata,
 }
 #endif // DEMANGLE_NO_FLOATING_POINT
 
-static privileged int
+ABI static int
 demangle_pop_str(struct demangle_data *ddata)
 {
 	return demangle_vector_str_pop(ddata->cur_output);
 }
 
-static privileged int
+ABI static int
 demangle_push_subst(struct demangle_data *ddata, const char *str, size_t len)
 {
 	if (!str || !len)
@@ -875,7 +884,7 @@ demangle_push_subst(struct demangle_data *ddata, const char *str, size_t len)
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_push_subst_v(struct demangle_data *ddata, struct vector_str *v)
 {
 	int rtn;
@@ -895,7 +904,7 @@ demangle_push_subst_v(struct demangle_data *ddata, struct vector_str *v)
 	return rtn;
 }
 
-static privileged int
+ABI static int
 demangle_push_type_qualifier(struct demangle_data *ddata,
     struct vector_type_qualifier *v, const char *type_str)
 {
@@ -1128,7 +1137,7 @@ demangle_push_type_qualifier(struct demangle_data *ddata,
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_get_subst(struct demangle_data *ddata, size_t idx)
 {
 	size_t len;
@@ -1146,7 +1155,7 @@ demangle_get_subst(struct demangle_data *ddata, size_t idx)
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_get_tmpl_param(struct demangle_data *ddata, size_t idx)
 {
 	size_t len;
@@ -1163,7 +1172,7 @@ demangle_get_tmpl_param(struct demangle_data *ddata, size_t idx)
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_read_array(struct demangle_data *ddata)
 {
 	size_t i, num_len, exp_len, p_idx, idx;
@@ -1235,7 +1244,7 @@ demangle_read_array(struct demangle_data *ddata)
 #ifndef DEMANGLE_NO_FLOATING_POINT
 
 /* Simple hex to integer function used by decode_to_* function. */
-static privileged int
+ABI static int
 hex_to_dec(char c)
 {
 	switch (c) {
@@ -1283,7 +1292,7 @@ hex_to_dec(char c)
  * Todo
  * Replace these functions to macro.
  */
-static privileged returnspointerwithnoaliases char *
+ABI static returnspointerwithnoaliases char *
 decode_fp_to_double(struct demangle_data *ddata, const char *p, size_t len)
 {
 	double f;
@@ -1327,7 +1336,7 @@ again:
 	return rtn;
 }
 
-static privileged returnspointerwithnoaliases char *
+ABI static returnspointerwithnoaliases char *
 decode_fp_to_float(struct demangle_data *ddata, const char *p, size_t len)
 {
 	size_t i, rtn_len, limit;
@@ -1369,7 +1378,7 @@ again:
 	return rtn;
 }
 
-static privileged returnspointerwithnoaliases char *
+ABI static returnspointerwithnoaliases char *
 decode_fp_to_long_double(struct demangle_data *ddata, const char *p, size_t len)
 {
 	long double f;
@@ -1413,7 +1422,7 @@ again:
 	return rtn;
 }
 
-static privileged returnspointerwithnoaliases char *
+ABI static returnspointerwithnoaliases char *
 decode_fp_to_float128(struct demangle_data *ddata, const char *p, size_t len)
 {
 	long double f;
@@ -1470,7 +1479,7 @@ decode_fp_to_float128(struct demangle_data *ddata, const char *p, size_t len)
 	}
 }
 
-static privileged returnspointerwithnoaliases char *
+ABI static returnspointerwithnoaliases char *
 decode_fp_to_float80(struct demangle_data *ddata, const char *p, size_t len)
 {
 	long double f;
@@ -1533,7 +1542,7 @@ decode_fp_to_float80(struct demangle_data *ddata, const char *p, size_t len)
 
 #endif // DEMANGLE_NO_FLOATING_POINT
 
-static privileged int
+ABI static int
 demangle_read_expr_primary(struct demangle_data *ddata)
 {
 	const char *num;
@@ -1625,7 +1634,7 @@ demangle_read_expr_primary(struct demangle_data *ddata)
  *   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
  *   http://gcc.gnu.org/viewcvs?view=rev&revision=124467
  */
-static privileged int
+ABI static int
 demangle_local_source_name(struct demangle_data *ddata)
 {
 	/* L */
@@ -1651,7 +1660,7 @@ demangle_local_source_name(struct demangle_data *ddata)
  * read unqualified-name, unqualified name are operator-name, ctor-dtor-name,
  * source-name
  */
-static privileged int
+ABI static int
 demangle_read_uqname(struct demangle_data *ddata)
 {
 	size_t len;
@@ -2080,7 +2089,7 @@ demangle_read_uqname(struct demangle_data *ddata)
  * Read template parameter that forms in 'T[number]_'.
  * This function much like to read_subst but only for types.
  */
-static privileged int
+ABI static int
 demangle_read_tmpl_param(struct demangle_data *ddata)
 {
 	long nth;
@@ -2098,10 +2107,11 @@ demangle_read_tmpl_param(struct demangle_data *ddata)
 		/* T_ is first */
 		++nth;
 
-		while (*ddata->cur != '_')
+		while (*ddata->cur && *ddata->cur != '_')
 			++ddata->cur;
 
-		ASSERT(nth > 0);
+		if (nth <= 0)
+			return 0;
 
 		return demangle_get_tmpl_param(ddata, nth);
 	}
@@ -2110,7 +2120,7 @@ demangle_read_tmpl_param(struct demangle_data *ddata)
 	return 0;
 }
 
-static privileged int
+ABI static int
 demangle_vector_read_cmd_push(struct demangle_data *ddata,
     struct vector_read_cmd *v, enum read_cmd cmd, void *data)
 {
@@ -2139,7 +2149,7 @@ demangle_vector_read_cmd_push(struct demangle_data *ddata,
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_read_tmpl_arg(struct demangle_data *ddata)
 {
 	if (*ddata->cur == '\0')
@@ -2158,7 +2168,7 @@ demangle_read_tmpl_arg(struct demangle_data *ddata)
 	return demangle_read_type(ddata, NULL);
 }
 
-static privileged int
+ABI static int
 demangle_read_tmpl_args(struct demangle_data *ddata)
 {
 	struct vector_str *v;
@@ -2211,7 +2221,7 @@ demangle_read_tmpl_args(struct demangle_data *ddata)
 	return demangle_vector_read_cmd_pop(&ddata->cmd);
 }
 
-static privileged int
+ABI static int
 demangle_read_expression_trinary(struct demangle_data *ddata, const char *name1,
     size_t len1, const char *name2, size_t len2)
 {
@@ -2230,7 +2240,7 @@ demangle_read_expression_trinary(struct demangle_data *ddata, const char *name1,
 	return demangle_read_expression(ddata);
 }
 
-static privileged int
+ABI static int
 demangle_read_expression_unary(struct demangle_data *ddata, const char *name,
     size_t len)
 {
@@ -2242,7 +2252,7 @@ demangle_read_expression_unary(struct demangle_data *ddata, const char *name,
 	return demangle_push_str(ddata, name, len);
 }
 
-static privileged int
+ABI static int
 demangle_read_expression_binary(struct demangle_data *ddata, const char *name,
     size_t len)
 {
@@ -2256,8 +2266,8 @@ demangle_read_expression_binary(struct demangle_data *ddata, const char *name,
 	return demangle_read_expression(ddata);
 }
 
-static privileged int
-demangle_read_expression(struct demangle_data *ddata)
+ABI static int
+demangle_read_expression_impl(struct demangle_data *ddata)
 {
 	if (*ddata->cur == '\0')
 		return 0;
@@ -2538,7 +2548,18 @@ demangle_read_expression(struct demangle_data *ddata)
 	return 0;
 }
 
-static privileged int
+ABI static int
+demangle_read_expression(struct demangle_data *ddata)
+{
+	if (ddata->depth == MAX_DEPTH)
+		__builtin_longjmp(ddata->jmpbuf, 1);
+	++ddata->depth;
+	int res = demangle_read_expression_impl(ddata);
+	--ddata->depth;
+	return res;
+}
+
+ABI static int
 demangle_read_expression_flat(struct demangle_data *ddata, char **str)
 {
 	struct vector_str *output;
@@ -2567,7 +2588,7 @@ demangle_read_expression_flat(struct demangle_data *ddata, char **str)
 }
 
 /* size, capacity, ext_name */
-static privileged void
+ABI static void
 demangle_vector_type_qualifier_init(struct demangle_data *ddata,
     struct vector_type_qualifier *v)
 {
@@ -2583,7 +2604,7 @@ demangle_vector_type_qualifier_init(struct demangle_data *ddata,
 	demangle_vector_str_init(ddata, &v->ext_name);
 }
 
-static privileged struct read_cmd_item *
+ABI static struct read_cmd_item *
 demangle_vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
 {
 	int i;
@@ -2598,7 +2619,7 @@ demangle_vector_read_cmd_find(struct vector_read_cmd *v, enum read_cmd dst)
 	return 0;
 }
 
-static privileged int
+ABI static int
 demangle_read_function(struct demangle_data *ddata, int *ext_c,
     struct vector_type_qualifier *v)
 {
@@ -2734,7 +2755,7 @@ demangle_read_function(struct demangle_data *ddata, int *ext_c,
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_read_offset_number(struct demangle_data *ddata)
 {
 	bool negative;
@@ -2752,7 +2773,7 @@ demangle_read_offset_number(struct demangle_data *ddata)
 		start = ddata->cur;
 	}
 
-	while (*ddata->cur != '_')
+	while (*ddata->cur && *ddata->cur != '_')
 		++ddata->cur;
 
 	if (negative && !DEM_PUSH_STR(ddata, "-"))
@@ -2770,7 +2791,7 @@ demangle_read_offset_number(struct demangle_data *ddata)
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_read_nv_offset(struct demangle_data *ddata)
 {
 	if (!DEM_PUSH_STR(ddata, "offset : "))
@@ -2779,7 +2800,7 @@ demangle_read_nv_offset(struct demangle_data *ddata)
 	return demangle_read_offset_number(ddata);
 }
 
-static privileged int
+ABI static int
 demangle_read_v_offset(struct demangle_data *ddata)
 {
 	if (!DEM_PUSH_STR(ddata, "offset : "))
@@ -2795,7 +2816,7 @@ demangle_read_v_offset(struct demangle_data *ddata)
 }
 
 /* read offset, offset are nv-offset, v-offset */
-static privileged int
+ABI static int
 demangle_read_offset(struct demangle_data *ddata)
 {
 	if (*ddata->cur == 'h') {
@@ -2809,7 +2830,7 @@ demangle_read_offset(struct demangle_data *ddata)
 	return 0;
 }
 
-static privileged int
+ABI static int
 demangle_read_type_flat(struct demangle_data *ddata, char **str)
 {
 	struct vector_str *output;
@@ -2841,7 +2862,7 @@ demangle_read_type_flat(struct demangle_data *ddata, char **str)
  * read number
  * number ::= [n] <decimal>
  */
-static privileged int
+ABI static int
 demangle_read_number(struct demangle_data *ddata, long *rtn)
 {
 	long len, negative_factor;
@@ -2859,19 +2880,18 @@ demangle_read_number(struct demangle_data *ddata, long *rtn)
 		return 0;
 
 	len = demangle_strtol(ddata->cur, 10);
+	if (len < 0)
+		__builtin_longjmp(ddata->jmpbuf, 1);
 
 	while (ELFTC_ISDIGIT(*ddata->cur))
 		++ddata->cur;
 
-	ASSERT(len >= 0);
-	ASSERT(negative_factor == 1 || negative_factor == -1);
-
 	*rtn = len * negative_factor;
 
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_read_number_as_string(struct demangle_data *ddata, char **str)
 {
 	long n;
@@ -2888,9 +2908,8 @@ demangle_read_number_as_string(struct demangle_data *ddata, char **str)
 	return 1;
 }
 
-/* read encoding, encoding are function name, data name, special-name */
-static privileged int
-demangle_read_encoding(struct demangle_data *ddata)
+ABI static int
+demangle_read_encoding_impl(struct demangle_data *ddata)
 {
 	char *name, *type, *num_str;
 	long offset;
@@ -3097,7 +3116,19 @@ demangle_read_encoding(struct demangle_data *ddata)
 	return demangle_read_name(ddata);
 }
 
-static privileged int
+/* read encoding, encoding are function name, data name, special-name */
+ABI static int
+demangle_read_encoding(struct demangle_data *ddata)
+{
+	if (ddata->depth == MAX_DEPTH)
+		__builtin_longjmp(ddata->jmpbuf, 1);
+	++ddata->depth;
+	int res = demangle_read_encoding_impl(ddata);
+	--ddata->depth;
+	return res;
+}
+
+ABI static int
 demangle_read_local_name(struct demangle_data *ddata)
 {
 	struct vector_str local_name;
@@ -3178,7 +3209,7 @@ demangle_read_local_name(struct demangle_data *ddata)
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_read_nested_name(struct demangle_data *ddata)
 {
 	struct stack_str v;
@@ -3266,8 +3297,8 @@ next:
 	return 1;
 }
 
-static privileged int
-demangle_read_name(struct demangle_data *ddata)
+ABI static int
+demangle_read_name_impl(struct demangle_data *ddata)
 {
 	struct stack_str v;
 	struct vector_str *output;
@@ -3328,7 +3359,18 @@ clean:
 	return rtn;
 }
 
-static privileged int
+ABI static int
+demangle_read_name(struct demangle_data *ddata)
+{
+	if (ddata->depth == MAX_DEPTH)
+		__builtin_longjmp(ddata->jmpbuf, 1);
+	++ddata->depth;
+	int res = demangle_read_name_impl(ddata);
+	--ddata->depth;
+	return res;
+}
+
+ABI static int
 demangle_read_name_flat(struct demangle_data *ddata, char **str)
 {
 	struct vector_str *output;
@@ -3356,7 +3398,7 @@ demangle_read_name_flat(struct demangle_data *ddata, char **str)
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_read_pointer_to_member(struct demangle_data *ddata,
     struct vector_type_qualifier *v)
 {
@@ -3416,9 +3458,10 @@ clean1:
 }
 
 /* read source-name, source-name is <len> <ID> */
-static privileged int
+ABI static int
 demangle_read_sname(struct demangle_data *ddata)
 {
+	size_t lim;
 	long len;
 	int err;
 
@@ -3438,12 +3481,15 @@ demangle_read_sname(struct demangle_data *ddata)
 		ddata->last_sname = VEC_STR(ddata, ddata->cur_output,
 		    ddata->cur_output->size - 1);
 
+	lim = demangle_strlen(ddata->cur);
+	if (len > lim)
+		len = lim;
 	ddata->cur += len;
 
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_read_subst_stdtmpl(struct demangle_data *ddata, const char *str)
 {
 	struct vector_str *output;
@@ -3481,7 +3527,7 @@ demangle_read_subst_stdtmpl(struct demangle_data *ddata, const char *str)
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_read_subst_std(struct demangle_data *ddata)
 {
 	struct vector_str *output, v;
@@ -3532,7 +3578,7 @@ demangle_read_subst_std(struct demangle_data *ddata)
 	return 1;
 }
 
-static privileged int
+ABI static int
 demangle_read_subst(struct demangle_data *ddata)
 {
 	long nth;
@@ -3647,10 +3693,11 @@ demangle_read_subst(struct demangle_data *ddata)
 		/* first was '_', so increase one */
 		++nth;
 
-		while (*ddata->cur != '_')
+		while (*ddata->cur && *ddata->cur != '_')
 			++ddata->cur;
 
-		ASSERT(nth > 0);
+		if (nth <= 0)
+			return 0;
 
 		return demangle_get_subst(ddata, nth);
 	}
@@ -3659,7 +3706,7 @@ demangle_read_subst(struct demangle_data *ddata)
 	return 0;
 }
 
-static privileged int
+ABI static int
 demangle_vector_type_qualifier_push(struct demangle_data *ddata,
     struct vector_type_qualifier *v, enum type_qualifier t)
 {
@@ -3688,8 +3735,8 @@ demangle_vector_type_qualifier_push(struct demangle_data *ddata,
 	return 1;
 }
 
-static privileged int
-demangle_read_type(struct demangle_data *ddata, struct type_delimit *td)
+ABI static int
+demangle_read_type_impl(struct demangle_data *ddata, struct type_delimit *td)
 {
 	struct vector_type_qualifier v;
 	struct vector_str *output, sv;
@@ -3881,7 +3928,7 @@ again:
 
 	case 'E':
 		/* unexpected end (except some things) */
-		if (ddata->is_guard_variable)
+		if (td && ddata->is_guard_variable)
 			td->paren = false;
 		if (ddata->is_guard_variable ||
 		    (ddata->ref_qualifier && ddata->is_functype)) {
@@ -4102,6 +4149,8 @@ again:
 		if (!demangle_vector_str_push(ddata, &v.ext_name, ddata->cur,
 			len))
 			return 0;
+		if (len > demangle_strlen(ddata->cur))
+			len = demangle_strlen(ddata->cur);
 		ddata->cur += len;
 		if (!demangle_vector_type_qualifier_push(ddata, &v, TYPE_EXT))
 			return 0;
@@ -4209,7 +4258,18 @@ clean:
 	return 0;
 }
 
-static privileged int
+ABI static int
+demangle_read_type(struct demangle_data *ddata, struct type_delimit *td)
+{
+	if (ddata->depth == MAX_DEPTH)
+		__builtin_longjmp(ddata->jmpbuf, 1);
+	++ddata->depth;
+	int res = demangle_read_type_impl(ddata, td);
+	--ddata->depth;
+	return res;
+}
+
+ABI static int
 demangle_copy_output(struct demangle_data *ddata, char *buf,
     const struct vector_str *v, size_t buflen)
 {
@@ -4232,14 +4292,14 @@ demangle_copy_output(struct demangle_data *ddata, char *buf,
 		return -1;
 }
 
-static privileged int
+ABI static int
 demangle_failure(char *buf, const char *org, size_t buflen)
 {
 	demangle_strlcpy(buf, org, buflen);
 	return -1;
 }
 
-static privileged int
+ABI static int
 demangle(struct demangle_data *ddata, char *buf, const char *org, size_t buflen)
 {
 	struct vector_str ret_type;
@@ -4391,7 +4451,7 @@ demangle(struct demangle_data *ddata, char *buf, const char *org, size_t buflen)
  * @return bytes of output name or -1 upon error or truncation
  * @asyncsignalsafe
  */
-privileged int
+ABI int
 __demangle(char *buf, const char *org, size_t buflen)
 {
 	struct demangle_data ddata[1];
@@ -4405,7 +4465,7 @@ __demangle(char *buf, const char *org, size_t buflen)
  *
  * This means it starts with either "_Z" or "_GLOBAL__I_".
  */
-privileged int
+ABI int
 __is_mangled(const char *org)
 {
 	if (!org)
diff --git a/libc/intrin/describeallocationtype.c b/libc/intrin/describeallocationtype.c
new file mode 100644
index 000000000..4dd69e733
--- /dev/null
+++ b/libc/intrin/describeallocationtype.c
@@ -0,0 +1,32 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
+#include "libc/nt/enum/memflags.h"
+
+static const struct DescribeFlags kNtAllocationTypeFlags[] = {
+    {kNtMemCommit, "Commit"},    //
+    {kNtMemReserve, "Reserve"},  //
+    {kNtMemReset, "Reset"},      //
+};
+
+const char *_DescribeNtAllocationType(char buf[48], uint32_t x) {
+  return _DescribeFlags(buf, 48, kNtAllocationTypeFlags,
+                        ARRAYLEN(kNtAllocationTypeFlags), "kNtMem", x);
+}
diff --git a/libc/intrin/describearchprctlcode.c b/libc/intrin/describearchprctlcode.c
index 57ad37830..b260b73ba 100644
--- a/libc/intrin/describearchprctlcode.c
+++ b/libc/intrin/describearchprctlcode.c
@@ -18,10 +18,10 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/arch.h"
 
-const char *(DescribeArchPrctlCode)(char buf[12], int x) {
+const char *_DescribeArchPrctlCode(char buf[12], int x) {
   if (x == ARCH_SET_FS)
     return "ARCH_SET_FS";
   if (x == ARCH_GET_FS)
diff --git a/libc/intrin/describebacktrace.c b/libc/intrin/describebacktrace.c
index d6bd8f8e0..7d61f5bc9 100644
--- a/libc/intrin/describebacktrace.c
+++ b/libc/intrin/describebacktrace.c
@@ -16,21 +16,23 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describebacktrace.internal.h"
-#include "libc/intrin/iscall.internal.h"
+#include "libc/intrin/describebacktrace.h"
+#include "libc/intrin/iscall.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nexgen32e/stackframe.h"
 
 #define N 160
 
-static bool IsDangerous(const void *ptr) {
+#define ABI privileged optimizesize
+
+ABI static bool IsDangerous(const void *ptr) {
   if (_weaken(kisdangerous))
     return _weaken(kisdangerous)(ptr);
   return false;
 }
 
-static char *FormatHex(char *p, unsigned long x) {
+ABI static char *FormatHex(char *p, unsigned long x) {
   int k = x ? (__builtin_clzl(x) ^ 63) + 1 : 1;
   k = (k + 3) & -4;
   while (k > 0)
@@ -39,8 +41,7 @@ static char *FormatHex(char *p, unsigned long x) {
   return p;
 }
 
-dontinstrument const char *(DescribeBacktrace)(char buf[N],
-                                               const struct StackFrame *fr) {
+ABI const char *_DescribeBacktrace(char buf[N], const struct StackFrame *fr) {
   char *p = buf;
   char *pe = p + N;
   bool gotsome = false;
diff --git a/libc/intrin/describebacktrace.h b/libc/intrin/describebacktrace.h
new file mode 100644
index 000000000..ee8614317
--- /dev/null
+++ b/libc/intrin/describebacktrace.h
@@ -0,0 +1,11 @@
+#ifndef COSMOPOLITAN_LIBC_INTRIN_DESCRIBEBACKTRACE_H_
+#define COSMOPOLITAN_LIBC_INTRIN_DESCRIBEBACKTRACE_H_
+#include "libc/mem/alloca.h"
+#include "libc/nexgen32e/stackframe.h"
+COSMOPOLITAN_C_START_
+
+const char *_DescribeBacktrace(char[160], const struct StackFrame *) libcesque;
+#define DescribeBacktrace(x) _DescribeBacktrace(alloca(160), x)
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_INTRIN_DESCRIBEBACKTRACE_H_ */
diff --git a/libc/intrin/describebacktrace.internal.h b/libc/intrin/describebacktrace.internal.h
deleted file mode 100644
index 9c116cd25..000000000
--- a/libc/intrin/describebacktrace.internal.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_DESCRIBEBACKTRACE_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_INTRIN_DESCRIBEBACKTRACE_INTERNAL_H_
-#include "libc/mem/alloca.h"
-#include "libc/nexgen32e/stackframe.h"
-COSMOPOLITAN_C_START_
-
-const char *DescribeBacktrace(char[160], const struct StackFrame *) libcesque;
-#define DescribeBacktrace(x) DescribeBacktrace(alloca(160), x)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_DESCRIBEBACKTRACE_INTERNAL_H_ */
diff --git a/libc/intrin/describecancelstate.c b/libc/intrin/describecancelstate.c
index b6ef58702..ccaa1d139 100644
--- a/libc/intrin/describecancelstate.c
+++ b/libc/intrin/describecancelstate.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/thread/thread.h"
 
-const char *(DescribeCancelState)(char buf[12], int err, int *state) {
+const char *_DescribeCancelState(char buf[12], int err, int *state) {
   if (err)
     return "n/a";
   if (!state)
diff --git a/libc/intrin/describecapability.c b/libc/intrin/describecapability.c
index f38ed5b8b..67ddcf829 100644
--- a/libc/intrin/describecapability.c
+++ b/libc/intrin/describecapability.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/cap.h"
 
@@ -69,7 +69,7 @@ static const struct thatispacked {
     {CAP_CHECKPOINT_RESTORE, "CHECKPOINT_RESTORE"},  //
 };
 
-const char *(DescribeCapability)(char buf[32], int x) {
+const char *_DescribeCapability(char buf[32], int x) {
   int i;
   for (i = 0; i < ARRAYLEN(kCapabilityName); ++i) {
     if (kCapabilityName[i].x == x) {
diff --git a/libc/intrin/describeclockname.c b/libc/intrin/describeclockname.c
index b5640c620..58d73b86f 100644
--- a/libc/intrin/describeclockname.c
+++ b/libc/intrin/describeclockname.c
@@ -17,11 +17,11 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 
 /**
  * Describes clock_gettime() clock argument.
  */
-const char *(DescribeClockName)(char buf[32], int x) {
-  return DescribeMagnum(buf, kClockNames, "CLOCK_", x);
+const char *_DescribeClockName(char buf[32], int x) {
+  return _DescribeMagnum(buf, kClockNames, "CLOCK_", x);
 }
diff --git a/libc/intrin/describecontrolkeystate.c b/libc/intrin/describecontrolkeystate.c
index 93f685cad..f2e75e300 100644
--- a/libc/intrin/describecontrolkeystate.c
+++ b/libc/intrin/describecontrolkeystate.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/struct/inputrecord.h"
 
 static const struct DescribeFlags kControlKeyState[] = {
@@ -32,7 +32,7 @@ static const struct DescribeFlags kControlKeyState[] = {
     {kNtEnhancedKey, "EnhancedKey"},            //
 };
 
-const char *(DescribeControlKeyState)(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kControlKeyState, ARRAYLEN(kControlKeyState),
-                       "kNt", x);
+const char *_DescribeControlKeyState(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kControlKeyState, ARRAYLEN(kControlKeyState),
+                        "kNt", x);
 }
diff --git a/libc/intrin/describedirfd.c b/libc/intrin/describedirfd.c
index a769f1225..36f729296 100644
--- a/libc/intrin/describedirfd.c
+++ b/libc/intrin/describedirfd.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/at.h"
 
-const char *(DescribeDirfd)(char buf[12], int dirfd) {
+const char *_DescribeDirfd(char buf[12], int dirfd) {
   if (dirfd == AT_FDCWD)
     return "AT_FDCWD";
   FormatInt32(buf, dirfd);
diff --git a/libc/intrin/describednotify.c b/libc/intrin/describednotify.c
index c6693dbb9..2a56e1557 100644
--- a/libc/intrin/describednotify.c
+++ b/libc/intrin/describednotify.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/processaccess.h"
 #include "libc/sysv/consts/dn.h"
 
@@ -31,7 +31,7 @@ static const struct DescribeFlags kDnotifyFlags[] = {
     {DN_MULTISHOT, "MULTISHOT"},  //
 };
 
-const char *(DescribeDnotifyFlags)(char buf[80], int x) {
-  return DescribeFlags(buf, 80, kDnotifyFlags, ARRAYLEN(kDnotifyFlags), "DN_",
-                       x);
+const char *_DescribeDnotifyFlags(char buf[80], int x) {
+  return _DescribeFlags(buf, 80, kDnotifyFlags, ARRAYLEN(kDnotifyFlags), "DN_",
+                        x);
 }
diff --git a/libc/intrin/describeerrnoresult.c b/libc/intrin/describeerrnoresult.c
index 672665edb..9f3817e02 100644
--- a/libc/intrin/describeerrnoresult.c
+++ b/libc/intrin/describeerrnoresult.c
@@ -18,11 +18,11 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/log/libfatal.internal.h"
 #include "libc/str/str.h"
 
-const char *(DescribeErrno)(char buf[30], int ax) {
+const char *_DescribeErrno(char buf[30], int ax) {
   char *p = buf;
   const char *s;
   if (ax < 0) {
diff --git a/libc/intrin/describefcntlcmd.c b/libc/intrin/describefcntlcmd.c
index 338b476a6..dbdef8513 100644
--- a/libc/intrin/describefcntlcmd.c
+++ b/libc/intrin/describefcntlcmd.c
@@ -18,10 +18,10 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/str/str.h"
 
-const char *(DescribeFcntlCmd)(char buf[20], int x) {
+const char *_DescribeFcntlCmd(char buf[20], int x) {
   const char *s;
   if (x >= 0 && (s = GetMagnumStr(kFcntlCmds, x))) {
     buf[0] = 'F';
diff --git a/libc/intrin/describefdset.c b/libc/intrin/describefdset.c
index 1ef26444d..7241b00db 100644
--- a/libc/intrin/describefdset.c
+++ b/libc/intrin/describefdset.c
@@ -26,11 +26,13 @@
 
 #define append(...) o += ksnprintf(buf + o, N - o, __VA_ARGS__)
 
-const char *(DescribeFdSet)(char buf[N], ssize_t rc, int nfds, fd_set *fds) {
+const char *_DescribeFdSet(char buf[N], ssize_t rc, int nfds, fd_set *fds) {
   int o = 0;
 
   if (!fds)
     return "NULL";
+  if (rc == -1)
+    return "n/a";
   if (kisdangerous(fds)) {
     ksnprintf(buf, N, "%p", fds);
     return buf;
diff --git a/libc/intrin/describeflags.c b/libc/intrin/describeflags.c
index cb316b244..b4ea4ed98 100644
--- a/libc/intrin/describeflags.c
+++ b/libc/intrin/describeflags.c
@@ -16,10 +16,10 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 
-const char *DescribeFlags(char *p, size_t n, const struct DescribeFlags *d,
-                          size_t m, const char *prefix, unsigned x) {
+const char *_DescribeFlags(char *p, size_t n, const struct DescribeFlags *d,
+                           size_t m, const char *prefix, unsigned x) {
   bool t;
   char b[21];
   size_t i, j, k;
diff --git a/libc/intrin/describeflags.h b/libc/intrin/describeflags.h
new file mode 100644
index 000000000..e63059f0e
--- /dev/null
+++ b/libc/intrin/describeflags.h
@@ -0,0 +1,132 @@
+#ifndef COSMOPOLITAN_LIBC_INTRIN_DESCRIBEFLAGS_INTERNAL_H_
+#define COSMOPOLITAN_LIBC_INTRIN_DESCRIBEFLAGS_INTERNAL_H_
+#include "libc/mem/alloca.h"
+COSMOPOLITAN_C_START_
+
+struct thatispacked DescribeFlags {
+  unsigned flag;
+  const char *name;
+};
+
+const char *_DescribeFlags(char *, size_t, const struct DescribeFlags *, size_t,
+                           const char *, unsigned) libcesque;
+
+const char *_DescribeArchPrctlCode(char[12], int) libcesque;
+const char *_DescribeCancelState(char[12], int, int *) libcesque;
+const char *_DescribeClockName(char[32], int) libcesque;
+const char *_DescribeControlKeyState(char[64], uint32_t) libcesque;
+const char *_DescribeDirfd(char[12], int) libcesque;
+const char *_DescribeDnotifyFlags(char[80], int) libcesque;
+const char *_DescribeErrno(char[30], int) libcesque;
+const char *_DescribeFcntlCmd(char[20], int) libcesque;
+const char *_DescribeFlockType(char[12], int) libcesque;
+const char *_DescribeFutexOp(char[64], int) libcesque;
+const char *_DescribeHow(char[12], int) libcesque;
+const char *_DescribeInOutInt64(char[23], ssize_t, int64_t *) libcesque;
+const char *_DescribeItimer(char[12], int) libcesque;
+const char *_DescribeMapFlags(char[64], int) libcesque;
+const char *_DescribeMapping(char[8], int, int) libcesque;
+const char *_DescribeMremapFlags(char[30], int) libcesque;
+const char *_DescribeMsg(char[16], int) libcesque;
+const char *_DescribeMsyncFlags(char[48], int) libcesque;
+const char *_DescribeNtAllocationType(char[48], uint32_t);
+const char *_DescribeNtConsoleInFlags(char[256], uint32_t) libcesque;
+const char *_DescribeNtConsoleOutFlags(char[128], uint32_t) libcesque;
+const char *_DescribeNtCreationDisposition(uint32_t) libcesque;
+const char *_DescribeNtFileAccessFlags(char[512], uint32_t) libcesque;
+const char *_DescribeNtFileFlagAttr(char[256], uint32_t) libcesque;
+const char *_DescribeNtFileMapFlags(char[64], uint32_t) libcesque;
+const char *_DescribeNtFileShareFlags(char[64], uint32_t) libcesque;
+const char *_DescribeNtFiletypeFlags(char[64], uint32_t) libcesque;
+const char *_DescribeNtLockFileFlags(char[64], uint32_t) libcesque;
+const char *_DescribeNtMovFileInpFlags(char[256], uint32_t) libcesque;
+const char *_DescribeNtPageFlags(char[64], uint32_t) libcesque;
+const char *_DescribeNtPipeModeFlags(char[64], uint32_t) libcesque;
+const char *_DescribeNtPipeOpenFlags(char[64], uint32_t) libcesque;
+const char *_DescribeNtProcAccessFlags(char[256], uint32_t) libcesque;
+const char *_DescribeNtStartFlags(char[128], uint32_t) libcesque;
+const char *_DescribeNtSymlinkFlags(char[64], uint32_t) libcesque;
+const char *_DescribeOpenFlags(char[128], int) libcesque;
+const char *_DescribeOpenMode(char[15], int, int) libcesque;
+const char *_DescribePersonalityFlags(char[128], int) libcesque;
+const char *_DescribePollFlags(char[64], int) libcesque;
+const char *_DescribeProtFlags(char[48], int) libcesque;
+const char *_DescribePtrace(char[12], int) libcesque;
+const char *_DescribePtraceEvent(char[32], int) libcesque;
+const char *_DescribeRlimitName(char[20], int) libcesque;
+const char *_DescribeSchedPolicy(char[48], int) libcesque;
+const char *_DescribeSeccompOperation(int) libcesque;
+const char *_DescribeSiCode(char[20], int, int) libcesque;
+const char *_DescribeSigaltstackFlags(char[22], int) libcesque;
+const char *_DescribeSleepFlags(char[16], int) libcesque;
+const char *_DescribeSockLevel(char[12], int) libcesque;
+const char *_DescribeSockOptname(char[32], int, int) libcesque;
+const char *_DescribeSocketFamily(char[12], int) libcesque;
+const char *_DescribeSocketProtocol(char[12], int) libcesque;
+const char *_DescribeSocketType(char[64], int) libcesque;
+const char *_DescribeStdioState(char[12], int) libcesque;
+const char *_DescribeStringList(char[300], char *const[]) libcesque;
+const char *_DescribeThreadCreateFlags(char[64], uint32_t) libcesque;
+const char *_DescribeVirtualKeyCode(char[32], uint32_t) libcesque;
+const char *_DescribeWhence(char[12], int) libcesque;
+const char *_DescribeWhichPrio(char[12], int) libcesque;
+
+#define DescribeCancelState(x, y)    _DescribeCancelState(alloca(12), x, y)
+#define DescribeClockName(x)         _DescribeClockName(alloca(32), x)
+#define DescribeControlKeyState(x)   _DescribeControlKeyState(alloca(64), x)
+#define DescribeDirfd(x)             _DescribeDirfd(alloca(12), x)
+#define DescribeDnotifyFlags(x)      _DescribeDnotifyFlags(alloca(80), x)
+#define DescribeErrno(x)             _DescribeErrno(alloca(30), x)
+#define DescribeFcntlCmd(x)          _DescribeFcntlCmd(alloca(20), x)
+#define DescribeFlockType(x)         _DescribeFlockType(alloca(12), x)
+#define DescribeFutexOp(x)           _DescribeFutexOp(alloca(64), x)
+#define DescribeHow(x)               _DescribeHow(alloca(12), x)
+#define DescribeInOutInt64(rc, x)    _DescribeInOutInt64(alloca(23), rc, x)
+#define DescribeItimer(x)            _DescribeItimer(alloca(12), x)
+#define DescribeMapFlags(x)          _DescribeMapFlags(alloca(64), x)
+#define DescribeMapping(x, y)        _DescribeMapping(alloca(8), x, y)
+#define DescribeMremapFlags(x)       _DescribeMremapFlags(alloca(30), x)
+#define DescribeMsg(x)               _DescribeMsg(alloca(16), x)
+#define DescribeMsyncFlags(x)        _DescribeMsyncFlags(alloca(48), x)
+#define DescribeNtAllocationType(x)  _DescribeNtAllocationType(alloca(48), x)
+#define DescribeNtConsoleInFlags(x)  _DescribeNtConsoleInFlags(alloca(256), x)
+#define DescribeNtConsoleOutFlags(x) _DescribeNtConsoleOutFlags(alloca(128), x)
+#define DescribeNtFileAccessFlags(x) _DescribeNtFileAccessFlags(alloca(512), x)
+#define DescribeNtFileFlagAttr(x)    _DescribeNtFileFlagAttr(alloca(256), x)
+#define DescribeNtFileMapFlags(x)    _DescribeNtFileMapFlags(alloca(64), x)
+#define DescribeNtFileShareFlags(x)  _DescribeNtFileShareFlags(alloca(64), x)
+#define DescribeNtFiletypeFlags(x)   _DescribeNtFiletypeFlags(alloca(64), x)
+#define DescribeNtLockFileFlags(x)   _DescribeNtLockFileFlags(alloca(64), x)
+#define DescribeNtMovFileInpFlags(x) _DescribeNtMovFileInpFlags(alloca(256), x)
+#define DescribeNtPageFlags(x)       _DescribeNtPageFlags(alloca(64), x)
+#define DescribeNtPipeModeFlags(x)   _DescribeNtPipeModeFlags(alloca(64), x)
+#define DescribeNtPipeOpenFlags(x)   _DescribeNtPipeOpenFlags(alloca(64), x)
+#define DescribeNtProcAccessFlags(x) _DescribeNtProcAccessFlags(alloca(256), x)
+#define DescribeNtStartFlags(x)      _DescribeNtStartFlags(alloca(128), x)
+#define DescribeNtSymlinkFlags(x)    _DescribeNtSymlinkFlags(alloca(64), x)
+#define DescribeOpenFlags(x)         _DescribeOpenFlags(alloca(128), x)
+#define DescribeOpenMode(x, y)       _DescribeOpenMode(alloca(15), x, y)
+#define DescribePersonalityFlags(p)  _DescribePersonalityFlags(alloca(128), p)
+#define DescribePollFlags(p)         _DescribePollFlags(alloca(64), p)
+#define DescribeProtFlags(x)         _DescribeProtFlags(alloca(48), x)
+#define DescribePtrace(i)            _DescribePtrace(alloca(12), i)
+#define DescribePtraceEvent(x)       _DescribePtraceEvent(alloca(32), x)
+#define DescribeRlimitName(rl)       _DescribeRlimitName(alloca(20), rl)
+#define DescribeSchedPolicy(x)       _DescribeSchedPolicy(alloca(48), x)
+#define DescribeSiCode(x, y)         _DescribeSiCode(alloca(20), x, y)
+#define DescribeSigaltstackFlags(x)  _DescribeSigaltstackFlags(alloca(22), x)
+#define DescribeSleepFlags(x)        _DescribeSleepFlags(alloca(16), x)
+#define DescribeSockLevel(x)         _DescribeSockLevel(alloca(12), x)
+#define DescribeSockOptname(x, y)    _DescribeSockOptname(alloca(32), x, y)
+#define DescribeSocketFamily(x)      _DescribeSocketFamily(alloca(12), x)
+#define DescribeSocketProtocol(x)    _DescribeSocketProtocol(alloca(12), x)
+#define DescribeSocketType(x)        _DescribeSocketType(alloca(64), x)
+#define DescribeStdioState(x)        _DescribeStdioState(alloca(12), x)
+#define DescribeStringList(x)        _DescribeStringList(alloca(300), x)
+#define DescribeThreadCreateFlags(x) _DescribeThreadCreateFlags(alloca(64), x)
+#define DescribeVirtualKeyCode(x)    _DescribeVirtualKeyCode(alloca(32), x)
+#define DescribeWhence(x)            _DescribeWhence(alloca(12), x)
+#define DescribeWhichPrio(x)         _DescribeWhichPrio(alloca(12), x)
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_INTRIN_DESCRIBEFLAGS_INTERNAL_H_ */
diff --git a/libc/intrin/describeflags.internal.h b/libc/intrin/describeflags.internal.h
deleted file mode 100644
index 28d0a635a..000000000
--- a/libc/intrin/describeflags.internal.h
+++ /dev/null
@@ -1,128 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_DESCRIBEFLAGS_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_INTRIN_DESCRIBEFLAGS_INTERNAL_H_
-#include "libc/mem/alloca.h"
-COSMOPOLITAN_C_START_
-
-struct thatispacked DescribeFlags {
-  unsigned flag;
-  const char *name;
-};
-
-const char *DescribeFlags(char *, size_t, const struct DescribeFlags *, size_t,
-                          const char *, unsigned) libcesque;
-
-const char *DescribeArchPrctlCode(char[12], int) libcesque;
-const char *DescribeCancelState(char[12], int, int *) libcesque;
-const char *DescribeCapability(char[32], int) libcesque;
-const char *DescribeClockName(char[32], int) libcesque;
-const char *DescribeControlKeyState(char[64], uint32_t) libcesque;
-const char *DescribeDirfd(char[12], int) libcesque;
-const char *DescribeDnotifyFlags(char[80], int) libcesque;
-const char *DescribeErrno(char[30], int) libcesque;
-const char *DescribeFcntlCmd(char[20], int) libcesque;
-const char *DescribeFlockType(char[12], int) libcesque;
-const char *DescribeFutexOp(char[64], int) libcesque;
-const char *DescribeHow(char[12], int) libcesque;
-const char *DescribeInOutInt64(char[23], ssize_t, int64_t *) libcesque;
-const char *DescribeItimer(char[12], int) libcesque;
-const char *DescribeMapFlags(char[64], int) libcesque;
-const char *DescribeMapping(char[8], int, int) libcesque;
-const char *DescribeNtConsoleInFlags(char[256], uint32_t) libcesque;
-const char *DescribeNtConsoleOutFlags(char[128], uint32_t) libcesque;
-const char *DescribeNtCreationDisposition(uint32_t) libcesque;
-const char *DescribeNtFileAccessFlags(char[512], uint32_t) libcesque;
-const char *DescribeNtFileFlagAttr(char[256], uint32_t) libcesque;
-const char *DescribeNtFileMapFlags(char[64], uint32_t) libcesque;
-const char *DescribeNtFileShareFlags(char[64], uint32_t) libcesque;
-const char *DescribeNtFiletypeFlags(char[64], uint32_t) libcesque;
-const char *DescribeNtLockFileFlags(char[64], uint32_t) libcesque;
-const char *DescribeNtMovFileInpFlags(char[256], uint32_t) libcesque;
-const char *DescribeNtPageFlags(char[64], uint32_t) libcesque;
-const char *DescribeNtPipeModeFlags(char[64], uint32_t) libcesque;
-const char *DescribeNtPipeOpenFlags(char[64], uint32_t) libcesque;
-const char *DescribeNtProcAccessFlags(char[256], uint32_t) libcesque;
-const char *DescribeNtStartFlags(char[128], uint32_t) libcesque;
-const char *DescribeNtSymlinkFlags(char[64], uint32_t) libcesque;
-const char *DescribeOpenFlags(char[128], int) libcesque;
-const char *DescribeOpenMode(char[15], int, int) libcesque;
-const char *DescribePersonalityFlags(char[128], int) libcesque;
-const char *DescribePollFlags(char[64], int) libcesque;
-const char *DescribePrctlOperation(int) libcesque;
-const char *DescribeProtFlags(char[48], int) libcesque;
-const char *DescribePtrace(char[12], int) libcesque;
-const char *DescribePtraceEvent(char[32], int) libcesque;
-const char *DescribeRemapFlags(char[48], int) libcesque;
-const char *DescribeRlimitName(char[20], int) libcesque;
-const char *DescribeSchedPolicy(char[48], int) libcesque;
-const char *DescribeSeccompOperation(int) libcesque;
-const char *DescribeSiCode(char[20], int, int) libcesque;
-const char *DescribeSleepFlags(char[16], int) libcesque;
-const char *DescribeSockLevel(char[12], int) libcesque;
-const char *DescribeSockOptname(char[32], int, int) libcesque;
-const char *DescribeSocketFamily(char[12], int) libcesque;
-const char *DescribeSocketProtocol(char[12], int) libcesque;
-const char *DescribeSocketType(char[64], int) libcesque;
-const char *DescribeStdioState(char[12], int) libcesque;
-const char *DescribeStringList(char[300], char *const[]) libcesque;
-const char *DescribeThreadCreateFlags(char[64], uint32_t) libcesque;
-const char *DescribeVirtualKeyCode(char[32], uint32_t) libcesque;
-const char *DescribeWhence(char[12], int) libcesque;
-const char *DescribeWhichPrio(char[12], int) libcesque;
-
-#define DescribeArchPrctlCode(x)     DescribeArchPrctlCode(alloca(12), x)
-#define DescribeCancelState(x, y)    DescribeCancelState(alloca(12), x, y)
-#define DescribeCapability(x)        DescribeCapability(alloca(32), x)
-#define DescribeClockName(x)         DescribeClockName(alloca(32), x)
-#define DescribeControlKeyState(x)   DescribeControlKeyState(alloca(64), x)
-#define DescribeDirfd(x)             DescribeDirfd(alloca(12), x)
-#define DescribeDnotifyFlags(x)      DescribeDnotifyFlags(alloca(80), x)
-#define DescribeErrno(x)             DescribeErrno(alloca(30), x)
-#define DescribeFcntlCmd(x)          DescribeFcntlCmd(alloca(20), x)
-#define DescribeFlockType(x)         DescribeFlockType(alloca(12), x)
-#define DescribeFutexOp(x)           DescribeFutexOp(alloca(64), x)
-#define DescribeHow(x)               DescribeHow(alloca(12), x)
-#define DescribeInOutInt64(rc, x)    DescribeInOutInt64(alloca(23), rc, x)
-#define DescribeItimer(x)            DescribeItimer(alloca(12), x)
-#define DescribeMapFlags(x)          DescribeMapFlags(alloca(64), x)
-#define DescribeMapping(x, y)        DescribeMapping(alloca(8), x, y)
-#define DescribeNtConsoleInFlags(x)  DescribeNtConsoleInFlags(alloca(256), x)
-#define DescribeNtConsoleOutFlags(x) DescribeNtConsoleOutFlags(alloca(128), x)
-#define DescribeNtFileAccessFlags(x) DescribeNtFileAccessFlags(alloca(512), x)
-#define DescribeNtFileFlagAttr(x)    DescribeNtFileFlagAttr(alloca(256), x)
-#define DescribeNtFileMapFlags(x)    DescribeNtFileMapFlags(alloca(64), x)
-#define DescribeNtFileShareFlags(x)  DescribeNtFileShareFlags(alloca(64), x)
-#define DescribeNtFiletypeFlags(x)   DescribeNtFiletypeFlags(alloca(64), x)
-#define DescribeNtLockFileFlags(x)   DescribeNtLockFileFlags(alloca(64), x)
-#define DescribeNtMovFileInpFlags(x) DescribeNtMovFileInpFlags(alloca(256), x)
-#define DescribeNtPageFlags(x)       DescribeNtPageFlags(alloca(64), x)
-#define DescribeNtPipeModeFlags(x)   DescribeNtPipeModeFlags(alloca(64), x)
-#define DescribeNtPipeOpenFlags(x)   DescribeNtPipeOpenFlags(alloca(64), x)
-#define DescribeNtProcAccessFlags(x) DescribeNtProcAccessFlags(alloca(256), x)
-#define DescribeNtStartFlags(x)      DescribeNtStartFlags(alloca(128), x)
-#define DescribeNtSymlinkFlags(x)    DescribeNtSymlinkFlags(alloca(64), x)
-#define DescribeOpenFlags(x)         DescribeOpenFlags(alloca(128), x)
-#define DescribeOpenMode(x, y)       DescribeOpenMode(alloca(15), x, y)
-#define DescribePersonalityFlags(p)  DescribePersonalityFlags(alloca(128), p)
-#define DescribePollFlags(p)         DescribePollFlags(alloca(64), p)
-#define DescribeProtFlags(x)         DescribeProtFlags(alloca(48), x)
-#define DescribePtrace(i)            DescribePtrace(alloca(12), i)
-#define DescribePtraceEvent(x)       DescribePtraceEvent(alloca(32), x)
-#define DescribeRemapFlags(x)        DescribeRemapFlags(alloca(48), x)
-#define DescribeRlimitName(rl)       DescribeRlimitName(alloca(20), rl)
-#define DescribeSchedPolicy(x)       DescribeSchedPolicy(alloca(48), x)
-#define DescribeSiCode(x, y)         DescribeSiCode(alloca(20), x, y)
-#define DescribeSleepFlags(x)        DescribeSleepFlags(alloca(16), x)
-#define DescribeSockLevel(x)         DescribeSockLevel(alloca(12), x)
-#define DescribeSockOptname(x, y)    DescribeSockOptname(alloca(32), x, y)
-#define DescribeSocketFamily(x)      DescribeSocketFamily(alloca(12), x)
-#define DescribeSocketProtocol(x)    DescribeSocketProtocol(alloca(12), x)
-#define DescribeSocketType(x)        DescribeSocketType(alloca(64), x)
-#define DescribeStdioState(x)        DescribeStdioState(alloca(12), x)
-#define DescribeStringList(x)        DescribeStringList(alloca(300), x)
-#define DescribeThreadCreateFlags(x) DescribeThreadCreateFlags(alloca(64), x)
-#define DescribeVirtualKeyCode(x)    DescribeVirtualKeyCode(alloca(32), x)
-#define DescribeWhence(x)            DescribeWhence(alloca(12), x)
-#define DescribeWhichPrio(x)         DescribeWhichPrio(alloca(12), x)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_DESCRIBEFLAGS_INTERNAL_H_ */
diff --git a/libc/intrin/describeflock.c b/libc/intrin/describeflock.c
index c2399e583..7f95445c4 100644
--- a/libc/intrin/describeflock.c
+++ b/libc/intrin/describeflock.c
@@ -19,7 +19,7 @@
 #include "libc/calls/struct/flock.h"
 #include "libc/calls/struct/flock.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/sysv/consts/f.h"
 
@@ -27,7 +27,7 @@
 
 #define append(...) o += ksnprintf(buf + o, N - o, __VA_ARGS__)
 
-const char *(DescribeFlock)(char buf[N], int cmd, const struct flock *l) {
+const char *_DescribeFlock(char buf[N], int cmd, const struct flock *l) {
   int o = 0;
 
   if (!l)
diff --git a/libc/intrin/describeflocktype.c b/libc/intrin/describeflocktype.c
index 67c13a024..ffb13879f 100644
--- a/libc/intrin/describeflocktype.c
+++ b/libc/intrin/describeflocktype.c
@@ -19,7 +19,7 @@
 #include "libc/fmt/itoa.h"
 #include "libc/sysv/consts/f.h"
 
-const char *(DescribeFlockType)(char buf[12], int x) {
+const char *_DescribeFlockType(char buf[12], int x) {
   if (x == F_RDLCK)
     return "F_RDLCK";
   if (x == F_WRLCK)
diff --git a/libc/intrin/describefutexop.c b/libc/intrin/describefutexop.c
index 9dead5932..7777a4755 100644
--- a/libc/intrin/describefutexop.c
+++ b/libc/intrin/describefutexop.c
@@ -17,11 +17,11 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/futex.h"
 
-const char *(DescribeFutexOp)(char buf[64], int x) {
+const char *_DescribeFutexOp(char buf[64], int x) {
 
   bool priv = false;
   if (x & FUTEX_PRIVATE_FLAG) {
diff --git a/libc/intrin/describegidlist.c b/libc/intrin/describegidlist.c
index d35e9db87..f915da80b 100644
--- a/libc/intrin/describegidlist.c
+++ b/libc/intrin/describegidlist.c
@@ -20,13 +20,13 @@
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/popcnt.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 
 #define N 128
 
-const char *(DescribeGidList)(char buf[N], int rc, int size,
-                              const uint32_t list[]) {
+const char *_DescribeGidList(char buf[N], int rc, int size,
+                             const uint32_t list[]) {
   if ((rc == -1) || (size < 0))
     return "n/a";
   if (!size)
diff --git a/libc/intrin/describehow.c b/libc/intrin/describehow.c
index a4c447025..9a92abd7a 100644
--- a/libc/intrin/describehow.c
+++ b/libc/intrin/describehow.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/sig.h"
 
-const char *(DescribeHow)(char buf[12], int how) {
+const char *_DescribeHow(char buf[12], int how) {
   if (how == SIG_BLOCK)
     return "SIG_BLOCK";
   if (how == SIG_UNBLOCK)
diff --git a/libc/intrin/describeinoutint64.c b/libc/intrin/describeinoutint64.c
index 977c32a15..19a8f31ad 100644
--- a/libc/intrin/describeinoutint64.c
+++ b/libc/intrin/describeinoutint64.c
@@ -18,9 +18,9 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 
-const char *(DescribeInOutInt64)(char buf[23], ssize_t rc, int64_t *x) {
+const char *_DescribeInOutInt64(char buf[23], ssize_t rc, int64_t *x) {
   if (!x)
     return "NULL";
   char *p = buf;
diff --git a/libc/intrin/describeiovec.c b/libc/intrin/describeiovec.c
index 2f1e97350..30a2f3afb 100644
--- a/libc/intrin/describeiovec.c
+++ b/libc/intrin/describeiovec.c
@@ -21,14 +21,14 @@
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #define N 300
 
 #define append(...) o += ksnprintf(buf + o, N - o, __VA_ARGS__)
 
-const char *(DescribeIovec)(char buf[N], ssize_t rc, const struct iovec *iov,
-                            int iovlen) {
+const char *_DescribeIovec(char buf[N], ssize_t rc, const struct iovec *iov,
+                           int iovlen) {
   const char *d;
   int i, j, o = 0;
 
diff --git a/libc/intrin/describeiovnt.c b/libc/intrin/describeiovnt.c
index 1f94bc5d2..e33b493fb 100644
--- a/libc/intrin/describeiovnt.c
+++ b/libc/intrin/describeiovnt.c
@@ -17,12 +17,12 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/winsock.h"
 
-void DescribeIovNt(const struct NtIovec *iov, uint32_t iovlen, ssize_t rem) {
+void _DescribeIovNt(const struct NtIovec *iov, uint32_t iovlen, ssize_t rem) {
   int i;
   if (kisdangerous(iov)) {
     kprintf("%p", iov);
diff --git a/libc/intrin/describeitimer.c b/libc/intrin/describeitimer.c
index d1e83a28d..aa1f96c75 100644
--- a/libc/intrin/describeitimer.c
+++ b/libc/intrin/describeitimer.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/itimer.h"
 
-const char *(DescribeItimer)(char buf[12], int which) {
+const char *_DescribeItimer(char buf[12], int which) {
   if (which == ITIMER_REAL)
     return "ITIMER_REAL";
   if (which == ITIMER_VIRTUAL)
diff --git a/libc/intrin/describeitimerval.c b/libc/intrin/describeitimerval.c
index 9ea8ff455..94af2a008 100644
--- a/libc/intrin/describeitimerval.c
+++ b/libc/intrin/describeitimerval.c
@@ -20,13 +20,13 @@
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/struct/timeval.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 
 #define N 90
 
-const char *(DescribeItimerval)(char buf[N], int rc,
-                                const struct itimerval *it) {
+const char *_DescribeItimerval(char buf[N], int rc,
+                               const struct itimerval *it) {
   if (!it)
     return "NULL";
   if (rc == -1)
diff --git a/libc/intrin/describemagnums.c b/libc/intrin/describemagnums.c
index fe76de780..c5540cfc1 100644
--- a/libc/intrin/describemagnums.c
+++ b/libc/intrin/describemagnums.c
@@ -20,8 +20,8 @@
 #include "libc/fmt/magnumstrs.internal.h"
 #include "libc/str/str.h"
 
-const char *DescribeMagnum(char *b, const struct MagnumStr *m, const char *p,
-                           int x) {
+const char *_DescribeMagnum(char *b, const struct MagnumStr *m, const char *p,
+                            int x) {
   const char *s;
   if (x == 127)
     return "CLOCK_INVALID";
diff --git a/libc/intrin/describemapflags.c b/libc/intrin/describemapflags.c
index fa1514435..7d6461b19 100644
--- a/libc/intrin/describemapflags.c
+++ b/libc/intrin/describemapflags.c
@@ -16,25 +16,29 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/dce.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/consolemodeflags.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
 
-const char *(DescribeMapFlags)(char buf[64], int x) {
+#define MAP_GROWSDOWN_LINUX 0x00000100
+
+const char *_DescribeMapFlags(char buf[64], int x) {
   const struct DescribeFlags kMapFlags[] = {
-      {MAP_PRIVATE, "PRIVATE"},                  //
-      {MAP_ANONYMOUS, "ANONYMOUS"},              //
-      {MAP_SHARED, "SHARED"},                    //
-      {MAP_FIXED, "FIXED"},                      //
-      {MAP_FIXED_NOREPLACE, "FIXED_NOREPLACE"},  //
-      {MAP_HUGETLB, "HUGETLB"},                  //
-      {MAP_CONCEAL, "CONCEAL"},                  //
-      {MAP_LOCKED, "LOCKED"},                    //
-      {MAP_NORESERVE, "NORESERVE"},              //
-      {MAP_NONBLOCK, "NONBLOCK"},                //
-      {MAP_POPULATE, "POPULATE"},                //
+      {MAP_PRIVATE, "PRIVATE"},                            //
+      {MAP_ANONYMOUS, "ANONYMOUS"},                        //
+      {MAP_SHARED, "SHARED"},                              //
+      {MAP_FIXED, "FIXED"},                                //
+      {MAP_FIXED_NOREPLACE, "FIXED_NOREPLACE"},            //
+      {MAP_HUGETLB, "HUGETLB"},                            //
+      {MAP_CONCEAL, "CONCEAL"},                            //
+      {MAP_LOCKED, "LOCKED"},                              //
+      {MAP_NORESERVE, "NORESERVE"},                        //
+      {MAP_NONBLOCK, "NONBLOCK"},                          //
+      {MAP_POPULATE, "POPULATE"},                          //
+      {IsLinux() ? MAP_GROWSDOWN_LINUX : 0, "GROWSDOWN"},  //
   };
-  return DescribeFlags(buf, 64, kMapFlags, ARRAYLEN(kMapFlags), "MAP_", x);
+  return _DescribeFlags(buf, 64, kMapFlags, ARRAYLEN(kMapFlags), "MAP_", x);
 }
diff --git a/libc/intrin/describemapping.c b/libc/intrin/describemapping.c
index 258e9a4ab..9371028b8 100644
--- a/libc/intrin/describemapping.c
+++ b/libc/intrin/describemapping.c
@@ -16,7 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/maps.h"
 #include "libc/runtime/memtrack.internal.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
@@ -24,8 +25,12 @@
 static char DescribeMapType(int flags) {
   switch (flags & MAP_TYPE) {
     case MAP_FILE:
-      return 'f';
+      if (flags & MAP_NOFORK)
+        return 'i';  // executable image
+      return '-';
     case MAP_PRIVATE:
+      if (flags & MAP_NOFORK)
+        return 'w';  // windows memory
       return 'p';
     case MAP_SHARED:
       return 's';
@@ -42,12 +47,11 @@ char *DescribeProt(char p[4], int prot) {
   return p;
 }
 
-const char *(DescribeMapping)(char p[8], int prot, int flags) {
+const char *_DescribeMapping(char p[8], int prot, int flags) {
   /* asan runtime depends on this function */
   DescribeProt(p, prot);
   p[3] = DescribeMapType(flags);
   p[4] = (flags & MAP_ANONYMOUS) ? 'a' : '-';
-  p[5] = (flags & MAP_FIXED) ? 'F' : '-';
-  p[6] = 0;
+  p[5] = 0;
   return p;
 }
diff --git a/libc/intrin/describemremapflags.c b/libc/intrin/describemremapflags.c
new file mode 100644
index 000000000..152f8a4ce
--- /dev/null
+++ b/libc/intrin/describemremapflags.c
@@ -0,0 +1,31 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
+#include "libc/sysv/consts/mremap.h"
+
+static const struct DescribeFlags kMremapFlags[] = {
+    {MREMAP_MAYMOVE, "MAYMOVE"},  //
+    {MREMAP_FIXED, "FIXED"},      //
+};
+
+const char *_DescribeMremapFlags(char buf[30], int x) {
+  return _DescribeFlags(buf, 30, kMremapFlags, ARRAYLEN(kMremapFlags),
+                        "MREMAP_", x);
+}
diff --git a/libc/intrin/describemsg.c b/libc/intrin/describemsg.c
new file mode 100644
index 000000000..9cfc5372e
--- /dev/null
+++ b/libc/intrin/describemsg.c
@@ -0,0 +1,36 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
+#include "libc/sysv/consts/msg.h"
+
+const char *_DescribeMsg(char buf[16], int x) {
+  const struct DescribeFlags kMsgFlags[] = {
+      {MSG_FASTOPEN, "FASTOPEN"},    // order matters
+      {MSG_OOB, "OOB"},              //
+      {MSG_PEEK, "PEEK"},            //
+      {MSG_DONTROUTE, "DONTROUTE"},  //
+      {MSG_DONTWAIT, "DONTWAIT"},    //
+      {MSG_WAITALL, "WAITALL"},      //
+      {MSG_NOSIGNAL, "NOSIGNAL"},    //
+      {MSG_TRUNC, "TRUNC"},          //
+      {MSG_CTRUNC, "CTRUNC"},        //
+  };
+  return _DescribeFlags(buf, 16, kMsgFlags, ARRAYLEN(kMsgFlags), "MSG_", x);
+}
diff --git a/libc/intrin/describemsyncflags.c b/libc/intrin/describemsyncflags.c
new file mode 100644
index 000000000..56a838e97
--- /dev/null
+++ b/libc/intrin/describemsyncflags.c
@@ -0,0 +1,30 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
+#include "libc/sysv/consts/msync.h"
+
+const char *_DescribeMsyncFlags(char buf[48], int x) {
+  const struct DescribeFlags kMsyncFlags[] = {
+      {MS_SYNC, "SYNC"},              //
+      {MS_ASYNC, "ASYNC"},            //
+      {MS_INVALIDATE, "INVALIDATE"},  //
+  };
+  return _DescribeFlags(buf, 48, kMsyncFlags, ARRAYLEN(kMsyncFlags), "MS_", x);
+}
diff --git a/libc/intrin/describentconsolemodeinputflags.c b/libc/intrin/describentconsolemodeinputflags.c
index 8083e49a3..a53575481 100644
--- a/libc/intrin/describentconsolemodeinputflags.c
+++ b/libc/intrin/describentconsolemodeinputflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/consolemodeflags.h"
 
 static const struct DescribeFlags kConsoleModeInputFlags[] = {
@@ -33,7 +33,7 @@ static const struct DescribeFlags kConsoleModeInputFlags[] = {
     {kNtEnableVirtualTerminalInput, "VirtualTerminalInput"},  //
 };
 
-const char *(DescribeNtConsoleInFlags)(char buf[256], uint32_t x) {
-  return DescribeFlags(buf, 256, kConsoleModeInputFlags,
-                       ARRAYLEN(kConsoleModeInputFlags), "kNtEnable", x);
+const char *_DescribeNtConsoleInFlags(char buf[256], uint32_t x) {
+  return _DescribeFlags(buf, 256, kConsoleModeInputFlags,
+                        ARRAYLEN(kConsoleModeInputFlags), "kNtEnable", x);
 }
diff --git a/libc/intrin/describentconsolemodeoutputflags.c b/libc/intrin/describentconsolemodeoutputflags.c
index 93b9adf78..2686e765a 100644
--- a/libc/intrin/describentconsolemodeoutputflags.c
+++ b/libc/intrin/describentconsolemodeoutputflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/consolemodeflags.h"
 
 static const struct DescribeFlags kConsoleModeOutputFlags[] = {
@@ -28,7 +28,7 @@ static const struct DescribeFlags kConsoleModeOutputFlags[] = {
     {kNtEnableLvbGridWorldwide, "EnableLvbGridWorldwide"},                    //
 };
 
-const char *(DescribeNtConsoleOutFlags)(char buf[128], uint32_t x) {
-  return DescribeFlags(buf, 128, kConsoleModeOutputFlags,
-                       ARRAYLEN(kConsoleModeOutputFlags), "kNt", x);
+const char *_DescribeNtConsoleOutFlags(char buf[128], uint32_t x) {
+  return _DescribeFlags(buf, 128, kConsoleModeOutputFlags,
+                        ARRAYLEN(kConsoleModeOutputFlags), "kNt", x);
 }
diff --git a/libc/intrin/describentcreationdisposition.c b/libc/intrin/describentcreationdisposition.c
index 33ee9015f..00636b1f7 100644
--- a/libc/intrin/describentcreationdisposition.c
+++ b/libc/intrin/describentcreationdisposition.c
@@ -16,10 +16,10 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/nt/enum/creationdisposition.h"
 
-const char *DescribeNtCreationDisposition(uint32_t x) {
+const char *_DescribeNtCreationDisposition(uint32_t x) {
   switch (x) {
     case kNtCreateNew:
       return "kNtCreateNew";
diff --git a/libc/intrin/describentfileaccessflags.c b/libc/intrin/describentfileaccessflags.c
index 6bcfe0ed2..582f519e4 100644
--- a/libc/intrin/describentfileaccessflags.c
+++ b/libc/intrin/describentfileaccessflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/accessmask.h"
 #include "libc/nt/enum/filesharemode.h"
 // clang-format off
@@ -72,7 +72,7 @@ static const struct DescribeFlags kFileAccessflags[] = {
     {kNtTokenAdjustSessionid, "kNtTokenAdjustSessionid"},
 };
 
-const char *(DescribeNtFileAccessFlags)(char buf[512], uint32_t x) {
-  return DescribeFlags(buf, 512, kFileAccessflags, ARRAYLEN(kFileAccessflags),
+const char *_DescribeNtFileAccessFlags(char buf[512], uint32_t x) {
+  return _DescribeFlags(buf, 512, kFileAccessflags, ARRAYLEN(kFileAccessflags),
                        "", x);
 }
diff --git a/libc/intrin/describentfileflagattr.c b/libc/intrin/describentfileflagattr.c
index 36762db5a..4dc9528df 100644
--- a/libc/intrin/describentfileflagattr.c
+++ b/libc/intrin/describentfileflagattr.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/fileflagandattributes.h"
 #include "libc/runtime/runtime.h"
 
@@ -50,9 +50,9 @@ static const struct DescribeFlags kFileFlags[] = {
     {kNtFileFlagFirstPipeInstance, "FlagFirstPipeInstance"},            //
 };
 
-const char *(DescribeNtFileFlagAttr)(char buf[256], uint32_t x) {
+const char *_DescribeNtFileFlagAttr(char buf[256], uint32_t x) {
   if (x == -1u)
     return "-1u";
-  return DescribeFlags(buf, 256, kFileFlags, ARRAYLEN(kFileFlags), "kNtFile",
-                       x);
+  return _DescribeFlags(buf, 256, kFileFlags, ARRAYLEN(kFileFlags), "kNtFile",
+                        x);
 }
diff --git a/libc/intrin/describentfilemapflags.c b/libc/intrin/describentfilemapflags.c
index 6d1848b3f..08ba98242 100644
--- a/libc/intrin/describentfilemapflags.c
+++ b/libc/intrin/describentfilemapflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/filemapflags.h"
 
 static const struct DescribeFlags kFileMapFlags[] = {
@@ -30,7 +30,7 @@ static const struct DescribeFlags kFileMapFlags[] = {
     {kNtFileMapLargePages, "LargePages"},          //
 };
 
-const char *(DescribeNtFileMapFlags)(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kFileMapFlags, ARRAYLEN(kFileMapFlags),
-                       "kNtFileMap", x);
+const char *_DescribeNtFileMapFlags(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kFileMapFlags, ARRAYLEN(kFileMapFlags),
+                        "kNtFileMap", x);
 }
diff --git a/libc/intrin/describentfileshareflags.c b/libc/intrin/describentfileshareflags.c
index 5878b1140..52f3aeee4 100644
--- a/libc/intrin/describentfileshareflags.c
+++ b/libc/intrin/describentfileshareflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/filesharemode.h"
 
 static const struct DescribeFlags kFileShareflags[] = {
@@ -26,7 +26,7 @@ static const struct DescribeFlags kFileShareflags[] = {
     {kNtFileShareDelete, "Delete"},  //
 };
 
-const char *(DescribeNtFileShareFlags)(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kFileShareflags, ARRAYLEN(kFileShareflags),
-                       "kNtFileShare", x);
+const char *_DescribeNtFileShareFlags(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kFileShareflags, ARRAYLEN(kFileShareflags),
+                        "kNtFileShare", x);
 }
diff --git a/libc/intrin/describentfiletypeflags.c b/libc/intrin/describentfiletypeflags.c
index 4ba2ffe00..7cecebc04 100644
--- a/libc/intrin/describentfiletypeflags.c
+++ b/libc/intrin/describentfiletypeflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/filetype.h"
 #include "libc/sysv/consts/mremap.h"
 
@@ -28,7 +28,7 @@ static const struct DescribeFlags kFiletypeFlags[] = {
     {kNtFileTypeChar, "Char"},      //
 };
 
-const char *(DescribeNtFiletypeFlags)(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kFiletypeFlags, ARRAYLEN(kFiletypeFlags),
-                       "kNtFileType", x);
+const char *_DescribeNtFiletypeFlags(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kFiletypeFlags, ARRAYLEN(kFiletypeFlags),
+                        "kNtFileType", x);
 }
diff --git a/libc/intrin/describentlockfileflags.c b/libc/intrin/describentlockfileflags.c
index af02f1d9f..007b5c74d 100644
--- a/libc/intrin/describentlockfileflags.c
+++ b/libc/intrin/describentlockfileflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/filelockflags.h"
 
 static const struct DescribeFlags kNtLockFileFlags[] = {
@@ -25,7 +25,7 @@ static const struct DescribeFlags kNtLockFileFlags[] = {
     {kNtLockfileExclusiveLock, "ExclusiveLock"},      //
 };
 
-const char *(DescribeNtLockFileFlags)(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kNtLockFileFlags, ARRAYLEN(kNtLockFileFlags),
-                       "kNtLockfile", x);
+const char *_DescribeNtLockFileFlags(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kNtLockFileFlags, ARRAYLEN(kNtLockFileFlags),
+                        "kNtLockfile", x);
 }
diff --git a/libc/intrin/describentmovfileinpflags.c b/libc/intrin/describentmovfileinpflags.c
index 7cb601066..311a3992b 100644
--- a/libc/intrin/describentmovfileinpflags.c
+++ b/libc/intrin/describentmovfileinpflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/movefileexflags.h"
 
 static const struct DescribeFlags kMoveFileInputFlags[] = {
@@ -29,7 +29,7 @@ static const struct DescribeFlags kMoveFileInputFlags[] = {
     {kNtMovefileFailIfNotTrackable, "FailIfNotTrackable"},  //
 };
 
-const char *(DescribeNtMovFileInpFlags)(char buf[256], uint32_t x) {
-  return DescribeFlags(buf, 256, kMoveFileInputFlags,
-                       ARRAYLEN(kMoveFileInputFlags), "kNtMovefile", x);
+const char *_DescribeNtMovFileInpFlags(char buf[256], uint32_t x) {
+  return _DescribeFlags(buf, 256, kMoveFileInputFlags,
+                        ARRAYLEN(kMoveFileInputFlags), "kNtMovefile", x);
 }
diff --git a/libc/intrin/describentoverlapped.c b/libc/intrin/describentoverlapped.c
index a4f3e1e07..c21e231e5 100644
--- a/libc/intrin/describentoverlapped.c
+++ b/libc/intrin/describentoverlapped.c
@@ -16,11 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describentoverlapped.internal.h"
+#include "libc/intrin/describentoverlapped.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
-const char *(DescribeNtOverlapped)(char b[128], const struct NtOverlapped *o) {
+const char *_DescribeNtOverlapped(char b[128], const struct NtOverlapped *o) {
   int i = 0, n = 128;
   bool gotsome = false;
   if (!o)
diff --git a/libc/intrin/describentoverlapped.h b/libc/intrin/describentoverlapped.h
new file mode 100644
index 000000000..b7d97f6d3
--- /dev/null
+++ b/libc/intrin/describentoverlapped.h
@@ -0,0 +1,11 @@
+#ifndef COSMOPOLITAN_LIBC_INTRIN_DESCRIBENTOVERLAPPED_INTERNAL_H_
+#define COSMOPOLITAN_LIBC_INTRIN_DESCRIBENTOVERLAPPED_INTERNAL_H_
+#include "libc/mem/alloca.h"
+#include "libc/nt/struct/overlapped.h"
+COSMOPOLITAN_C_START_
+
+const char *_DescribeNtOverlapped(char[128], const struct NtOverlapped *);
+#define DescribeNtOverlapped(x) _DescribeNtOverlapped(alloca(128), x)
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_INTRIN_DESCRIBENTOVERLAPPED_INTERNAL_H_ */
diff --git a/libc/intrin/describentoverlapped.internal.h b/libc/intrin/describentoverlapped.internal.h
deleted file mode 100644
index 009dad0c1..000000000
--- a/libc/intrin/describentoverlapped.internal.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_DESCRIBENTOVERLAPPED_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_INTRIN_DESCRIBENTOVERLAPPED_INTERNAL_H_
-#include "libc/mem/alloca.h"
-#include "libc/nt/struct/overlapped.h"
-COSMOPOLITAN_C_START_
-
-const char *DescribeNtOverlapped(char[128], const struct NtOverlapped *);
-#define DescribeNtOverlapped(x) DescribeNtOverlapped(alloca(128), x)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_DESCRIBENTOVERLAPPED_INTERNAL_H_ */
diff --git a/libc/intrin/describentpageflags.c b/libc/intrin/describentpageflags.c
index 543f630f2..aac644adb 100644
--- a/libc/intrin/describentpageflags.c
+++ b/libc/intrin/describentpageflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/pageflags.h"
 
 static const struct DescribeFlags kPageFlags[] = {
@@ -41,6 +41,6 @@ static const struct DescribeFlags kPageFlags[] = {
     {kNtSecWritecombine, "SecWritecombine"},            //
 };
 
-const char *(DescribeNtPageFlags)(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kPageFlags, ARRAYLEN(kPageFlags), "kNt", x);
+const char *_DescribeNtPageFlags(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kPageFlags, ARRAYLEN(kPageFlags), "kNt", x);
 }
diff --git a/libc/intrin/describentpipemodeflags.c b/libc/intrin/describentpipemodeflags.c
index 490bdb037..0c8f58bfc 100644
--- a/libc/intrin/describentpipemodeflags.c
+++ b/libc/intrin/describentpipemodeflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/filemapflags.h"
 #include "libc/nt/ipc.h"
 
@@ -32,7 +32,7 @@ static const struct DescribeFlags kPipeModeFlags[] = {
     //{kNtPipeTypeByte, "TypeByte"},                        // 0x00000000
 };
 
-const char *(DescribeNtPipeModeFlags)(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kPipeModeFlags, ARRAYLEN(kPipeModeFlags),
-                       "kNtPipe", x);
+const char *_DescribeNtPipeModeFlags(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kPipeModeFlags, ARRAYLEN(kPipeModeFlags),
+                        "kNtPipe", x);
 }
diff --git a/libc/intrin/describentpipeopenflags.c b/libc/intrin/describentpipeopenflags.c
index ec3a0c5c6..623075468 100644
--- a/libc/intrin/describentpipeopenflags.c
+++ b/libc/intrin/describentpipeopenflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/accessmask.h"
 #include "libc/nt/enum/fileflagandattributes.h"
 #include "libc/nt/enum/filemapflags.h"
@@ -35,7 +35,7 @@ static const struct DescribeFlags kPipeOpenFlags[] = {
     {kNtAccessSystemSecurity, "kNtAccessSystemSecurity"},
 };
 
-const char *(DescribeNtPipeOpenFlags)(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kPipeOpenFlags, ARRAYLEN(kPipeOpenFlags), "",
-                       x);
+const char *_DescribeNtPipeOpenFlags(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kPipeOpenFlags, ARRAYLEN(kPipeOpenFlags), "",
+                        x);
 }
diff --git a/libc/intrin/describentprocaccessflags.c b/libc/intrin/describentprocaccessflags.c
index b8d18202e..63b94754b 100644
--- a/libc/intrin/describentprocaccessflags.c
+++ b/libc/intrin/describentprocaccessflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/processaccess.h"
 
 static const struct DescribeFlags kProcessAccessflags[] = {
@@ -37,7 +37,7 @@ static const struct DescribeFlags kProcessAccessflags[] = {
     {kNtProcessSynchronize, "Synchronize"},                          //
 };
 
-const char *(DescribeNtProcAccessFlags)(char buf[256], uint32_t x) {
-  return DescribeFlags(buf, 256, kProcessAccessflags,
-                       ARRAYLEN(kProcessAccessflags), "kNtProcess", x);
+const char *_DescribeNtProcAccessFlags(char buf[256], uint32_t x) {
+  return _DescribeFlags(buf, 256, kProcessAccessflags,
+                        ARRAYLEN(kProcessAccessflags), "kNtProcess", x);
 }
diff --git a/libc/intrin/describentsecurityattributes.c b/libc/intrin/describentsecurityattributes.c
index 3031b3c3a..674fe2f28 100644
--- a/libc/intrin/describentsecurityattributes.c
+++ b/libc/intrin/describentsecurityattributes.c
@@ -18,12 +18,11 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/state.internal.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/nt/struct/securityattributes.h"
 
-const char *(
-    DescribeNtSecurityAttributes)(char buf[32],
-                                  const struct NtSecurityAttributes *p) {
+const char *_DescribeNtSecurityAttributes(
+    char buf[32], const struct NtSecurityAttributes *p) {
   FormatInt64(buf, (uintptr_t)p);
   return buf;
 }
diff --git a/libc/intrin/describentstartflags.c b/libc/intrin/describentstartflags.c
index 02aaec9ee..6af9c8744 100644
--- a/libc/intrin/describentstartflags.c
+++ b/libc/intrin/describentstartflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/startf.h"
 #include "libc/sysv/consts/prot.h"
 
@@ -38,7 +38,7 @@ static const struct DescribeFlags kNtStartFlags[] = {
     {kNtStartfUntrustedsource, "Untrustedsource"},    //
 };
 
-const char *(DescribeNtStartFlags)(char buf[128], uint32_t x) {
-  return DescribeFlags(buf, 128, kNtStartFlags, ARRAYLEN(kNtStartFlags),
-                       "kNtStartf", x);
+const char *_DescribeNtStartFlags(char buf[128], uint32_t x) {
+  return _DescribeFlags(buf, 128, kNtStartFlags, ARRAYLEN(kNtStartFlags),
+                        "kNtStartf", x);
 }
diff --git a/libc/intrin/describentsymlinkflags.c b/libc/intrin/describentsymlinkflags.c
index 4cc66d262..c9924fba5 100644
--- a/libc/intrin/describentsymlinkflags.c
+++ b/libc/intrin/describentsymlinkflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/symboliclink.h"
 
 static const struct DescribeFlags kSymbolicLinkflags[] = {
@@ -25,7 +25,7 @@ static const struct DescribeFlags kSymbolicLinkflags[] = {
     {kNtSymbolicLinkFlagAllowUnprivilegedCreate, "AllowUnprivilegedCreate"},  //
 };
 
-const char *(DescribeNtSymlinkFlags)(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kSymbolicLinkflags,
-                       ARRAYLEN(kSymbolicLinkflags), "kNtSymbolicLinkFlag", x);
+const char *_DescribeNtSymlinkFlags(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kSymbolicLinkflags,
+                        ARRAYLEN(kSymbolicLinkflags), "kNtSymbolicLinkFlag", x);
 }
diff --git a/libc/intrin/describeopenflags.c b/libc/intrin/describeopenflags.c
index b57fc9219..0f640288f 100644
--- a/libc/intrin/describeopenflags.c
+++ b/libc/intrin/describeopenflags.c
@@ -19,8 +19,8 @@
 #include "libc/assert.h"
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/sol.h"
@@ -30,7 +30,7 @@
 /**
  * Describes clock_gettime() clock argument.
  */
-const char *(DescribeOpenFlags)(char buf[128], int x) {
+const char *_DescribeOpenFlags(char buf[128], int x) {
   char *p;
   int i, n;
   const char *pipe;
@@ -68,7 +68,7 @@ const char *(DescribeOpenFlags)(char buf[128], int x) {
       d[i].flag = MAGNUM_NUMBER(kOpenFlags, i);
       d[i].name = MAGNUM_STRING(kOpenFlags, i);
     }
-    DescribeFlags(p, 128 - (p - buf), d, n, "O_", x);
+    _DescribeFlags(p, 128 - (p - buf), d, n, "O_", x);
   }
   return buf;
 }
diff --git a/libc/intrin/describeopenmode.c b/libc/intrin/describeopenmode.c
index 692427508..bfcc3397e 100644
--- a/libc/intrin/describeopenmode.c
+++ b/libc/intrin/describeopenmode.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/o.h"
 
 #define O_TMPFILE_LINUX 0x00410000
@@ -28,7 +28,7 @@ static bool IsCreatingFile(int flags) {
          (IsLinux() && (flags & O_TMPFILE_LINUX) == O_TMPFILE_LINUX);
 }
 
-const char *(DescribeOpenMode)(char buf[15], int flags, int mode) {
+const char *_DescribeOpenMode(char buf[15], int flags, int mode) {
   if (!IsCreatingFile(flags)) {
     return "";
   }
diff --git a/libc/intrin/describepersonalityflags.c b/libc/intrin/describepersonalityflags.c
index d92bc2c0d..88fab3203 100644
--- a/libc/intrin/describepersonalityflags.c
+++ b/libc/intrin/describepersonalityflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/accessmask.h"
 #include "libc/nt/enum/filesharemode.h"
 #include "libc/sysv/consts/personality.h"
@@ -36,7 +36,7 @@ static const struct DescribeFlags kPersonalityFlags[] = {
     {UNAME26, "UNAME26"},                        //
 };
 
-const char *(DescribePersonalityFlags)(char buf[128], int x) {
-  return DescribeFlags(buf, 128, kPersonalityFlags, ARRAYLEN(kPersonalityFlags),
-                       "", x);
+const char *_DescribePersonalityFlags(char buf[128], int x) {
+  return _DescribeFlags(buf, 128, kPersonalityFlags,
+                        ARRAYLEN(kPersonalityFlags), "", x);
 }
diff --git a/libc/intrin/describepollfds.c b/libc/intrin/describepollfds.c
index 941fa09e2..94ebd2da5 100644
--- a/libc/intrin/describepollfds.c
+++ b/libc/intrin/describepollfds.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sock/struct/pollfd.h"
 #include "libc/sock/struct/pollfd.internal.h"
 
@@ -28,8 +28,8 @@
 
 #define append(...) o += ksnprintf(buf + o, N - o, __VA_ARGS__)
 
-const char *(DescribePollFds)(char buf[N], ssize_t rc, struct pollfd *fds,
-                              size_t nfds) {
+const char *_DescribePollFds(char buf[N], ssize_t rc, struct pollfd *fds,
+                             size_t nfds) {
   char b64[64];
   int i, o = 0;
 
@@ -45,9 +45,9 @@ const char *(DescribePollFds)(char buf[N], ssize_t rc, struct pollfd *fds,
   for (i = 0; i < nfds; ++i) {
     if (i)
       append(", ");
-    append("{%d, %s", fds[i].fd, (DescribePollFlags)(b64, fds[i].events));
+    append("{%d, %s", fds[i].fd, _DescribePollFlags(b64, fds[i].events));
     if (rc >= 0) {
-      append(", [%s]", (DescribePollFlags)(b64, fds[i].revents));
+      append(", [%s]", _DescribePollFlags(b64, fds[i].revents));
     }
     append("}");
   }
diff --git a/libc/intrin/describepollflags.c b/libc/intrin/describepollflags.c
index 6556e4f16..6445b4e54 100644
--- a/libc/intrin/describepollflags.c
+++ b/libc/intrin/describepollflags.c
@@ -16,12 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/filemapflags.h"
 #include "libc/sysv/consts/poll.h"
 
-const char *(DescribePollFlags)(char buf[64], int x) {
+const char *_DescribePollFlags(char buf[64], int x) {
   const struct DescribeFlags kPollFlags[] = {
       {POLLIN, "IN"},          // order matters
       {POLLOUT, "OUT"},        // order matters
@@ -35,5 +35,5 @@ const char *(DescribePollFlags)(char buf[64], int x) {
       {POLLWRBAND, "WRBAND"},  //
       {POLLWRNORM, "WRNORM"},  //
   };
-  return DescribeFlags(buf, 64, kPollFlags, ARRAYLEN(kPollFlags), "POLL", x);
+  return _DescribeFlags(buf, 64, kPollFlags, ARRAYLEN(kPollFlags), "POLL", x);
 }
diff --git a/libc/intrin/describeprctloperation.c b/libc/intrin/describeprctloperation.c
deleted file mode 100644
index fc0d3c085..000000000
--- a/libc/intrin/describeprctloperation.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/sysv/consts/pr.h"
-
-const char *DescribePrctlOperation(int x) {
-  switch (x) {
-    case PR_GET_NAME:
-      return "PR_GET_NAME";
-    case PR_SET_NO_NEW_PRIVS:
-      return "PR_SET_NO_NEW_PRIVS";
-    case PR_SET_SECCOMP:
-      return "PR_SET_SECCOMP";
-    case PR_GET_SECCOMP:
-      return "PR_GET_SECCOMP";
-    case PR_CAPBSET_READ:
-      return "PR_CAPBSET_READ";
-    case PR_CAPBSET_DROP:
-      return "PR_CAPBSET_DROP";
-    default:
-      return "PRCTL_???";
-  }
-}
diff --git a/libc/intrin/describeprotflags.c b/libc/intrin/describeprotflags.c
index f281dffc2..9fad2bd32 100644
--- a/libc/intrin/describeprotflags.c
+++ b/libc/intrin/describeprotflags.c
@@ -16,16 +16,18 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/sysv/consts/prot.h"
 
-static const struct DescribeFlags kProtFlags[] = {
-    {PROT_READ, "READ"},    //
-    {PROT_WRITE, "WRITE"},  //
-    {PROT_EXEC, "EXEC"},    //
-};
-
-const char *(DescribeProtFlags)(char buf[48], int x) {
-  return DescribeFlags(buf, 48, kProtFlags, ARRAYLEN(kProtFlags), "PROT_", x);
+const char *_DescribeProtFlags(char buf[48], int x) {
+  if (!x)
+    return "PROT_NONE";
+  const struct DescribeFlags kProtFlags[] = {
+      {PROT_READ, "READ"},    //
+      {PROT_WRITE, "WRITE"},  //
+      {PROT_EXEC, "EXEC"},    //
+      {PROT_GUARD, "GUARD"},  //
+  };
+  return _DescribeFlags(buf, 48, kProtFlags, ARRAYLEN(kProtFlags), "PROT_", x);
 }
diff --git a/libc/intrin/describeptrace.c b/libc/intrin/describeptrace.c
index 7b9969fce..84baa0e5d 100644
--- a/libc/intrin/describeptrace.c
+++ b/libc/intrin/describeptrace.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/ptrace.h"
 
-const char *(DescribePtrace)(char buf[12], int x) {
+const char *_DescribePtrace(char buf[12], int x) {
   if (x == -1)
     return "-1";
   if (x == PTRACE_TRACEME)
diff --git a/libc/intrin/describeptraceevent.c b/libc/intrin/describeptraceevent.c
index f8e8e49ed..11c0c4699 100644
--- a/libc/intrin/describeptraceevent.c
+++ b/libc/intrin/describeptraceevent.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/ptrace.h"
 
-const char *(DescribePtraceEvent)(char buf[32], int x) {
+const char *_DescribePtraceEvent(char buf[32], int x) {
   if (x == PTRACE_EVENT_FORK)
     return "PTRACE_EVENT_FORK";
   if (x == PTRACE_EVENT_VFORK)
diff --git a/libc/intrin/describeremapflags.c b/libc/intrin/describeremapflags.c
deleted file mode 100644
index 01f7bdb35..000000000
--- a/libc/intrin/describeremapflags.c
+++ /dev/null
@@ -1,31 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
-#include "libc/sysv/consts/mremap.h"
-
-static const struct DescribeFlags kRemapFlags[] = {
-    {MREMAP_MAYMOVE, "MAYMOVE"},  //
-    {MREMAP_FIXED, "FIXED"},      //
-};
-
-const char *(DescribeRemapFlags)(char buf[48], int x) {
-  return DescribeFlags(buf, 48, kRemapFlags, ARRAYLEN(kRemapFlags), "MREMAP_",
-                       x);
-}
diff --git a/libc/intrin/describerlimit.c b/libc/intrin/describerlimit.c
index 79d9a7d46..7c58a965b 100644
--- a/libc/intrin/describerlimit.c
+++ b/libc/intrin/describerlimit.c
@@ -18,10 +18,13 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/rlimit.h"
 #include "libc/dce.h"
+#include "libc/fmt/itoa.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/rlim.h"
 
-const char *DescribeRlimit(char buf[64], int rc, const struct rlimit *rlim) {
+const char *_DescribeRlimit(char buf[64], int rc, const struct rlimit *rlim) {
   if (rc == -1)
     return "n/a";
   if (!rlim)
@@ -29,7 +32,18 @@ const char *DescribeRlimit(char buf[64], int rc, const struct rlimit *rlim) {
   if (kisdangerous(rlim)) {
     ksnprintf(buf, 64, "%p", rlim);
   } else {
-    ksnprintf(buf, 64, "{%'ld, %'ld}", rlim->rlim_cur, rlim->rlim_max);
+    char str[2][21];
+    if (rlim->rlim_cur == RLIM_INFINITY) {
+      strcpy(str[0], "RLIM_INFINITY");
+    } else {
+      FormatInt64(str[0], rlim->rlim_cur);
+    }
+    if (rlim->rlim_max == RLIM_INFINITY) {
+      strcpy(str[1], "RLIM_INFINITY");
+    } else {
+      FormatInt64(str[1], rlim->rlim_max);
+    }
+    ksnprintf(buf, 64, "{%s, %s}", str[0], str[1]);
   }
   return buf;
 }
diff --git a/libc/intrin/describerlimitname.c b/libc/intrin/describerlimitname.c
index d7b578853..1872e7792 100644
--- a/libc/intrin/describerlimitname.c
+++ b/libc/intrin/describerlimitname.c
@@ -17,13 +17,13 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 
 /**
  * Describes setrlimit() / getrlimit() argument.
  */
-const char *(DescribeRlimitName)(char buf[20], int x) {
+const char *_DescribeRlimitName(char buf[20], int x) {
   if (x == 127)
     return "n/a";
-  return DescribeMagnum(buf, kRlimitNames, "RLIMIT_", x);
+  return _DescribeMagnum(buf, kRlimitNames, "RLIMIT_", x);
 }
diff --git a/libc/intrin/describeschedparam.c b/libc/intrin/describeschedparam.c
index 059d66088..f559ffad5 100644
--- a/libc/intrin/describeschedparam.c
+++ b/libc/intrin/describeschedparam.c
@@ -18,13 +18,13 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/sched_param.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/str/str.h"
 
 /**
  * Describes clock_gettime() clock argument.
  */
-const char *(DescribeSchedParam)(char buf[32], const struct sched_param *x) {
+const char *_DescribeSchedParam(char buf[32], const struct sched_param *x) {
   char *p;
   if (!x)
     return "0";
diff --git a/libc/intrin/describeschedpolicy.c b/libc/intrin/describeschedpolicy.c
index 626a8efe0..24c7eb67c 100644
--- a/libc/intrin/describeschedpolicy.c
+++ b/libc/intrin/describeschedpolicy.c
@@ -18,15 +18,15 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sched.h"
 
 /**
  * Describes clock_gettime() clock argument.
  */
-const char *(DescribeSchedPolicy)(char buf[48], int x) {
+const char *_DescribeSchedPolicy(char buf[48], int x) {
   char *p = buf;
   if (x == -1) {
     goto DoNumber;
diff --git a/libc/intrin/describeseccompoperation.c b/libc/intrin/describeseccompoperation.c
index 74a379f9e..824f10841 100644
--- a/libc/intrin/describeseccompoperation.c
+++ b/libc/intrin/describeseccompoperation.c
@@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/seccomp.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 
-const char *DescribeSeccompOperation(int x) {
+const char *_DescribeSeccompOperation(int x) {
   switch (x) {
     case SECCOMP_SET_MODE_STRICT:
       return "SECCOMP_SET_MODE_STRICT";
diff --git a/libc/intrin/describesicode.c b/libc/intrin/describesicode.c
index 56dcf898d..a9e33ca4a 100644
--- a/libc/intrin/describesicode.c
+++ b/libc/intrin/describesicode.c
@@ -38,7 +38,7 @@ static void NameIt(char p[20], const char *s, int si_code) {
 /**
  * Returns symbolic name for siginfo::si_code value.
  */
-const char *(DescribeSiCode)(char b[20], int sig, int si_code) {
+const char *_DescribeSiCode(char b[20], int sig, int si_code) {
   NameIt(b, "SI_", si_code);
   if (si_code == SI_QUEUE) {
     strcpy(b + 3, "QUEUE"); /* sent by sigqueue(2) */
diff --git a/libc/intrin/describesigaction.c b/libc/intrin/describesigaction.c
index 968ce057c..5a7a417a6 100644
--- a/libc/intrin/describesigaction.c
+++ b/libc/intrin/describesigaction.c
@@ -21,9 +21,9 @@
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alloca.h"
 #include "libc/sysv/consts/sa.h"
 
@@ -51,15 +51,15 @@ static const char *DescribeSigFlags(char buf[64], int x) {
       {SA_ONESHOT, "ONESHOT"},      //
       {0x04000000, "RESTORER"},     //
   };
-  return DescribeFlags(buf, 64, kSigFlags, ARRAYLEN(kSigFlags), "SA_", x);
+  return _DescribeFlags(buf, 64, kSigFlags, ARRAYLEN(kSigFlags), "SA_", x);
 }
 
 #define N 256
 
 #define append(...) o += ksnprintf(buf + o, N - o, __VA_ARGS__)
 
-const char *(DescribeSigaction)(char buf[N], int rc,
-                                const struct sigaction *sa) {
+const char *_DescribeSigaction(char buf[N], int rc,
+                               const struct sigaction *sa) {
   int o = 0;
   char b64[64];
 
diff --git a/libc/intrin/describesigaltstack.c b/libc/intrin/describesigaltstack.c
index 5121a93e5..71ed50335 100644
--- a/libc/intrin/describesigaltstack.c
+++ b/libc/intrin/describesigaltstack.c
@@ -18,11 +18,11 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/sigaltstack.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 
-const char *(DescribeSigaltstk)(char buf[128], int rc,
-                                const struct sigaltstack *ss) {
+const char *_DescribeSigaltstack(char buf[128], int rc,
+                                 const struct sigaltstack *ss) {
   if (rc == -1)
     return "n/a";
   if (!ss)
@@ -30,8 +30,8 @@ const char *(DescribeSigaltstk)(char buf[128], int rc,
   if (kisdangerous(ss)) {
     ksnprintf(buf, 128, "%p", ss);
   } else {
-    ksnprintf(buf, 128, "{.ss_sp=%p, .ss_flags=%#lx, .ss_size=%'zu}", ss->ss_sp,
-              ss->ss_flags, ss->ss_size);
+    ksnprintf(buf, 128, "{.ss_sp=%p, .ss_flags=%s, .ss_size=%'zu}", ss->ss_sp,
+              DescribeSigaltstackFlags(ss->ss_flags), ss->ss_size);
   }
   return buf;
 }
diff --git a/libc/intrin/describesigaltstackflags.c b/libc/intrin/describesigaltstackflags.c
new file mode 100644
index 000000000..33354d07e
--- /dev/null
+++ b/libc/intrin/describesigaltstackflags.c
@@ -0,0 +1,30 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
+#include "libc/sysv/consts/ss.h"
+
+const char *_DescribeSigaltstackFlags(char buf[22], int x) {
+  const struct DescribeFlags kSigaltstackFlags[] = {
+      {SS_ONSTACK, "ONSTACK"},  //
+      {SS_DISABLE, "DISABLE"},  //
+  };
+  return _DescribeFlags(buf, 48, kSigaltstackFlags, ARRAYLEN(kSigaltstackFlags),
+                        "SS_", x);
+}
diff --git a/libc/intrin/describesiginfo.c b/libc/intrin/describesiginfo.c
index d1bc5508d..074e09442 100644
--- a/libc/intrin/describesiginfo.c
+++ b/libc/intrin/describesiginfo.c
@@ -19,7 +19,7 @@
 #include "libc/calls/struct/siginfo.h"
 #include "libc/calls/struct/siginfo.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/weaken.h"
 #include "libc/str/str.h"
@@ -29,7 +29,7 @@
 
 #define append(...) i += ksnprintf(buf + i, N - i, __VA_ARGS__)
 
-const char *(DescribeSiginfo)(char buf[N], int rc, const siginfo_t *si) {
+const char *_DescribeSiginfo(char buf[N], int rc, const siginfo_t *si) {
   int i = 0;
 
   if (rc == -1)
diff --git a/libc/intrin/describesigset.c b/libc/intrin/describesigset.c
index e05758d49..ee1529155 100644
--- a/libc/intrin/describesigset.c
+++ b/libc/intrin/describesigset.c
@@ -31,7 +31,7 @@
 
 #define append(...) o += ksnprintf(buf + o, N - o, __VA_ARGS__)
 
-const char *(DescribeSigset)(char buf[N], int rc, const sigset_t *ss) {
+const char *_DescribeSigset(char buf[N], int rc, const sigset_t *ss) {
   int olderr;
   bool gotsome;
   const char *s;
diff --git a/libc/intrin/describesleepflags.c b/libc/intrin/describesleepflags.c
index 8b37755fd..2bcfaf4d7 100644
--- a/libc/intrin/describesleepflags.c
+++ b/libc/intrin/describesleepflags.c
@@ -18,13 +18,13 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/timer.h"
 
 /**
  * Describes clock_nanosleep() flags argument.
  */
-const char *(DescribeSleepFlags)(char buf[16], int x) {
+const char *_DescribeSleepFlags(char buf[16], int x) {
   switch (x) {
     case 0:
       return "0";
diff --git a/libc/intrin/describesocketfamily.c b/libc/intrin/describesocketfamily.c
index 7f1b32ade..1144ec8da 100644
--- a/libc/intrin/describesocketfamily.c
+++ b/libc/intrin/describesocketfamily.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/af.h"
 
-const char *(DescribeSocketFamily)(char buf[12], int family) {
+const char *_DescribeSocketFamily(char buf[12], int family) {
   if (family == AF_UNIX)
     return "AF_UNIX";
   if (family == AF_INET)
diff --git a/libc/intrin/describesocketprotocol.c b/libc/intrin/describesocketprotocol.c
index 933ce7b41..16059fa1f 100644
--- a/libc/intrin/describesocketprotocol.c
+++ b/libc/intrin/describesocketprotocol.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/ipproto.h"
 
-const char *(DescribeSocketProtocol)(char buf[12], int family) {
+const char *_DescribeSocketProtocol(char buf[12], int family) {
   if (family == IPPROTO_IP)
     return "IPPROTO_IP";
   if (family == IPPROTO_ICMP)
diff --git a/libc/intrin/describesockettype.c b/libc/intrin/describesockettype.c
index 69cf9d76e..c8084b573 100644
--- a/libc/intrin/describesockettype.c
+++ b/libc/intrin/describesockettype.c
@@ -17,11 +17,11 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sock.h"
 
-const char *(DescribeSocketType)(char buf[64], int type) {
+const char *_DescribeSocketType(char buf[64], int type) {
   int x;
   char *p;
   p = buf;
diff --git a/libc/intrin/describesocklevel.c b/libc/intrin/describesocklevel.c
index dc1959ee1..d2b981a36 100644
--- a/libc/intrin/describesocklevel.c
+++ b/libc/intrin/describesocklevel.c
@@ -17,13 +17,13 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/sol.h"
 
 /**
  * Describes setsockopt() level arguments.
  */
-const char *(DescribeSockLevel)(char buf[12], int x) {
+const char *_DescribeSockLevel(char buf[12], int x) {
   if (x == SOL_SOCKET)
     return "SOL_SOCKET";
   if (x == SOL_IP)
diff --git a/libc/intrin/describesockoptname.c b/libc/intrin/describesockoptname.c
index 1341008eb..acfe5b25d 100644
--- a/libc/intrin/describesockoptname.c
+++ b/libc/intrin/describesockoptname.c
@@ -18,14 +18,14 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sol.h"
 
 /**
  * Describes setsockopt() optname arguments.
  */
-const char *(DescribeSockOptname)(char buf[32], int l, int x) {
+const char *_DescribeSockOptname(char buf[32], int l, int x) {
   char *p;
   const char *s;
   const struct MagnumStr *ms;
@@ -49,6 +49,14 @@ const char *(DescribeSockOptname)(char buf[32], int l, int x) {
       *p++ = '_';
       *p = 0;
       ms = kIpOptnames;
+    } else if (l == SOL_IPV6) {
+      *p++ = 'I';
+      *p++ = 'P';
+      *p++ = 'V';
+      *p++ = '6';
+      *p++ = '_';
+      *p = 0;
+      ms = kIpv6Optnames;
     } else {
       ms = 0;
     }
diff --git a/libc/intrin/describestat.c b/libc/intrin/describestat.c
index 102e58ef7..530708568 100644
--- a/libc/intrin/describestat.c
+++ b/libc/intrin/describestat.c
@@ -25,7 +25,7 @@
 
 #define append(...) o += ksnprintf(buf + o, N - o, __VA_ARGS__)
 
-const char *(DescribeStat)(char buf[N], int rc, const struct stat *st) {
+const char *_DescribeStat(char buf[N], int rc, const struct stat *st) {
   int o = 0;
 
   if (rc == -1)
diff --git a/libc/intrin/describestatfs.c b/libc/intrin/describestatfs.c
index 787062edc..439fb925f 100644
--- a/libc/intrin/describestatfs.c
+++ b/libc/intrin/describestatfs.c
@@ -27,7 +27,7 @@
 
 #define append(...) i += ksnprintf(buf + i, N - i, __VA_ARGS__)
 
-const char *(DescribeStatfs)(char buf[N], int rc, const struct statfs *f) {
+const char *_DescribeStatfs(char buf[N], int rc, const struct statfs *f) {
   int i = 0;
   char ibuf[21];
   int64_t flags;
diff --git a/libc/intrin/describestdiostate.c b/libc/intrin/describestdiostate.c
index 74a934cdc..ec7fdba3e 100644
--- a/libc/intrin/describestdiostate.c
+++ b/libc/intrin/describestdiostate.c
@@ -18,10 +18,10 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/str/str.h"
 
-const char *(DescribeStdioState)(char buf[12], int x) {
+const char *_DescribeStdioState(char buf[12], int x) {
   if (!x)
     return "";
   if (x == -1)
diff --git a/libc/intrin/describestringlist.c b/libc/intrin/describestringlist.c
index b998b1cea..67baea91e 100644
--- a/libc/intrin/describestringlist.c
+++ b/libc/intrin/describestringlist.c
@@ -17,14 +17,14 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 
 #define N 300
 
 #define append(...) o += ksnprintf(buf + o, N - o, __VA_ARGS__)
 
-const char *(DescribeStringList)(char buf[N], char *const list[]) {
+const char *_DescribeStringList(char buf[N], char *const list[]) {
   int i, o = 0;
 
   if (!list)
diff --git a/libc/intrin/describetermios.c b/libc/intrin/describetermios.c
index 825d3f0c6..1cbb40694 100644
--- a/libc/intrin/describetermios.c
+++ b/libc/intrin/describetermios.c
@@ -20,17 +20,17 @@
 #include "libc/calls/struct/termios.internal.h"
 #include "libc/calls/ttydefaults.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sysv/consts/termios.h"
 
 #define N 1024
 
 #define append(...) o += ksnprintf(buf + o, N - o, __VA_ARGS__)
 
-const char *(DescribeTermios)(char buf[N], ssize_t rc,
-                              const struct termios *tio) {
+const char *_DescribeTermios(char buf[N], ssize_t rc,
+                             const struct termios *tio) {
   int o = 0;
   char b128[128];
 
@@ -61,7 +61,7 @@ const char *(DescribeTermios)(char buf[N], ssize_t rc,
       {IUTF8, "IUTF8"},      //
   };
   append(".c_iflag=%s",
-         DescribeFlags(b128, 128, kInput, ARRAYLEN(kInput), "", tio->c_iflag));
+         _DescribeFlags(b128, 128, kInput, ARRAYLEN(kInput), "", tio->c_iflag));
 
   struct DescribeFlags kOutput[] = {
       {OPOST, "OPOST"},    //
@@ -83,8 +83,8 @@ const char *(DescribeTermios)(char buf[N], ssize_t rc,
       {VT1, "VT1"},        //
       {FF1, "FF1"},        //
   };
-  append(", .c_oflag=%s", DescribeFlags(b128, 128, kOutput, ARRAYLEN(kOutput),
-                                        "", tio->c_oflag));
+  append(", .c_oflag=%s", _DescribeFlags(b128, 128, kOutput, ARRAYLEN(kOutput),
+                                         "", tio->c_oflag));
 
   struct DescribeFlags kControl[] = {
       {CS8, "CS8"},          //
@@ -98,8 +98,8 @@ const char *(DescribeTermios)(char buf[N], ssize_t rc,
       {CLOCAL, "CLOCAL"},    //
       {CRTSCTS, "CRTSCTS"},  //
   };
-  append(", .c_cflag=%s", DescribeFlags(b128, 128, kControl, ARRAYLEN(kControl),
-                                        "", tio->c_cflag));
+  append(", .c_cflag=%s", _DescribeFlags(b128, 128, kControl,
+                                         ARRAYLEN(kControl), "", tio->c_cflag));
 
   struct DescribeFlags kLocal[] = {
       {ISIG, "ISIG"},        //
@@ -125,7 +125,7 @@ const char *(DescribeTermios)(char buf[N], ssize_t rc,
          ".c_cc[VTIME]=%d, "
          ".c_cc[VINTR]=CTRL(%#c), "
          ".c_cc[VQUIT]=CTRL(%#c)",
-         DescribeFlags(b128, 128, kLocal, ARRAYLEN(kLocal), "", tio->c_lflag),
+         _DescribeFlags(b128, 128, kLocal, ARRAYLEN(kLocal), "", tio->c_lflag),
          tio->c_cc[VMIN], tio->c_cc[VTIME], CTRL(tio->c_cc[VINTR]),
          CTRL(tio->c_cc[VQUIT]));
 
diff --git a/libc/intrin/describethreadcreationflags.c b/libc/intrin/describethreadcreationflags.c
index 54f5ec657..d77faee10 100644
--- a/libc/intrin/describethreadcreationflags.c
+++ b/libc/intrin/describethreadcreationflags.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/processcreationflags.h"
 
 static const struct DescribeFlags kThreadCreationFlags[] = {
@@ -25,7 +25,7 @@ static const struct DescribeFlags kThreadCreationFlags[] = {
     {kNtStackSizeParamIsAReservation, "kNtStackSizeParamIsAReservation"},  //
 };
 
-const char *(DescribeThreadCreateFlags)(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kThreadCreationFlags,
-                       ARRAYLEN(kThreadCreationFlags), "", x);
+const char *_DescribeThreadCreateFlags(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kThreadCreationFlags,
+                        ARRAYLEN(kThreadCreationFlags), "", x);
 }
diff --git a/libc/intrin/describetimespec.c b/libc/intrin/describetimespec.c
index 7b5c56d9c..121c7f479 100644
--- a/libc/intrin/describetimespec.c
+++ b/libc/intrin/describetimespec.c
@@ -18,12 +18,11 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timespec.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/str/str.h"
 
-const char *(DescribeTimespec)(char buf[45], int rc,
-                               const struct timespec *ts) {
+const char *_DescribeTimespec(char buf[45], int rc, const struct timespec *ts) {
   if (rc == -1)
     return "n/a";
   if (!ts)
diff --git a/libc/intrin/describetimeval.c b/libc/intrin/describetimeval.c
index 328d95d90..10d0abb3d 100644
--- a/libc/intrin/describetimeval.c
+++ b/libc/intrin/describetimeval.c
@@ -18,10 +18,10 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timeval.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 
-const char *(DescribeTimeval)(char buf[45], int rc, const struct timeval *tv) {
+const char *_DescribeTimeval(char buf[45], int rc, const struct timeval *tv) {
   if (!tv)
     return "NULL";
   if (rc == -1)
diff --git a/libc/intrin/describevirtualkeycode.c b/libc/intrin/describevirtualkeycode.c
index 2e4bc1b05..8655ca081 100644
--- a/libc/intrin/describevirtualkeycode.c
+++ b/libc/intrin/describevirtualkeycode.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/vk.h"
 
 // clang-format off
@@ -205,7 +205,7 @@ static const struct VirtualKeyCodeName {
 };
 // clang-format on
 
-const char *(DescribeVirtualKeyCode)(char buf[32], uint32_t x) {
+const char *_DescribeVirtualKeyCode(char buf[32], uint32_t x) {
   for (int i = 0; i < ARRAYLEN(kVirtualKeyCodeNames); ++i) {
     if (x == kVirtualKeyCodeNames[i].code) {
       return kVirtualKeyCodeNames[i].name;
diff --git a/libc/intrin/describewhence.c b/libc/intrin/describewhence.c
index 3de47df18..3c0820b7c 100644
--- a/libc/intrin/describewhence.c
+++ b/libc/intrin/describewhence.c
@@ -18,9 +18,9 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 
-const char *(DescribeWhence)(char buf[12], int whence) {
+const char *_DescribeWhence(char buf[12], int whence) {
   if (whence == SEEK_SET)
     return "SEEK_SET";
   if (whence == SEEK_CUR)
diff --git a/libc/intrin/describewhichprio.c b/libc/intrin/describewhichprio.c
index 3459dc17e..121e026f9 100644
--- a/libc/intrin/describewhichprio.c
+++ b/libc/intrin/describewhichprio.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/prio.h"
 
-const char *(DescribeWhichPrio)(char buf[12], int x) {
+const char *_DescribeWhichPrio(char buf[12], int x) {
   if (x == PRIO_PROCESS)
     return "PRIO_PROCESS";
   if (x == PRIO_PGRP)
diff --git a/libc/intrin/describewinsize.c b/libc/intrin/describewinsize.c
index abc91c867..a84c15907 100644
--- a/libc/intrin/describewinsize.c
+++ b/libc/intrin/describewinsize.c
@@ -19,16 +19,16 @@
 #include "libc/calls/struct/winsize.h"
 #include "libc/calls/struct/winsize.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #define N 64
 
 #define append(...) o += ksnprintf(buf + o, N - o, __VA_ARGS__)
 
-const char *(DescribeWinsize)(char buf[N], int rc, const struct winsize *ws) {
+const char *_DescribeWinsize(char buf[N], int rc, const struct winsize *ws) {
   int o = 0;
   if (!ws)
     return "NULL";
diff --git a/libc/intrin/deviceiocontrol.c b/libc/intrin/deviceiocontrol.c
index bd164fe29..983870285 100644
--- a/libc/intrin/deviceiocontrol.c
+++ b/libc/intrin/deviceiocontrol.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describentoverlapped.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describentoverlapped.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/nt/struct/overlapped.h"
 #include "libc/nt/thunk/msabi.h"
diff --git a/libc/intrin/directmap-metal.c b/libc/intrin/directmap-metal.c
index af0e1889c..30e377da9 100644
--- a/libc/intrin/directmap-metal.c
+++ b/libc/intrin/directmap-metal.c
@@ -19,8 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/metalfile.internal.h"
-#include "libc/intrin/directmap.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/pc.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/prot.h"
@@ -32,19 +31,11 @@
 
 static uint64_t sys_mmap_metal_break;
 
-static struct DirectMap bad_mmap(void) {
-  struct DirectMap res;
-  res.addr = (void *)-1;
-  res.maphandle = -1;
-  return res;
-}
-
-struct DirectMap sys_mmap_metal(void *vaddr, size_t size, int prot, int flags,
-                                int fd, int64_t off) {
+void *sys_mmap_metal(void *vaddr, size_t size, int prot, int flags, int fd,
+                     int64_t off) {
   /* asan runtime depends on this function */
   size_t i;
   struct mman *mm;
-  struct DirectMap res;
   uint64_t addr, faddr = 0, page, e, *pte, *fdpte, *pml4t;
   mm = __get_mm();
   pml4t = __get_pml4t();
@@ -54,18 +45,18 @@ struct DirectMap sys_mmap_metal(void *vaddr, size_t size, int prot, int flags,
     struct Fd *sfd;
     struct MetalFile *file;
     if (off < 0 || fd < 0 || fd >= g_fds.n)
-      return bad_mmap();
+      return MAP_FAILED;
     sfd = &g_fds.p[fd];
     if (sfd->kind != kFdFile)
-      return bad_mmap();
+      return MAP_FAILED;
     file = (struct MetalFile *)sfd->handle;
     /* TODO: allow mapping partial page at end of file, if file size not
      * multiple of page size */
     if (off > file->size || size > file->size - off)
-      return bad_mmap();
+      return MAP_FAILED;
     faddr = (uint64_t)file->base + off;
     if (faddr % 4096 != 0)
-      return bad_mmap();
+      return MAP_FAILED;
   }
   if (!(flags & MAP_FIXED_linux)) {
     if (!addr) {
@@ -88,7 +79,7 @@ struct DirectMap sys_mmap_metal(void *vaddr, size_t size, int prot, int flags,
       if ((flags & MAP_ANONYMOUS_linux)) {
         page = __new_page(mm);
         if (!page)
-          return bad_mmap();
+          return MAP_FAILED;
         __clear_page(BANE + page);
         e = page | PAGE_RSRV | PAGE_U;
         if ((prot & PROT_WRITE))
@@ -114,9 +105,7 @@ struct DirectMap sys_mmap_metal(void *vaddr, size_t size, int prot, int flags,
       break;
     }
   }
-  res.addr = (void *)addr;
-  res.maphandle = -1;
-  return res;
+  return (void *)addr;
 }
 
 #endif /* __x86_64__ */
diff --git a/libc/intrin/directmap-nt.c b/libc/intrin/directmap-nt.c
deleted file mode 100644
index a6fd1d2f1..000000000
--- a/libc/intrin/directmap-nt.c
+++ /dev/null
@@ -1,123 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/calls/internal.h"
-#include "libc/calls/state.internal.h"
-#include "libc/errno.h"
-#include "libc/intrin/directmap.internal.h"
-#include "libc/nt/enum/filemapflags.h"
-#include "libc/nt/enum/pageflags.h"
-#include "libc/nt/errors.h"
-#include "libc/nt/memory.h"
-#include "libc/nt/runtime.h"
-#include "libc/nt/struct/processmemorycounters.h"
-#include "libc/nt/struct/securityattributes.h"
-#include "libc/sysv/consts/map.h"
-#include "libc/sysv/consts/o.h"
-#include "libc/sysv/consts/prot.h"
-
-textwindows struct DirectMap sys_mmap_nt(void *addr, size_t size, int prot,
-                                         int flags, int fd, int64_t off) {
-
-  int64_t handle;
-  if (flags & MAP_ANONYMOUS) {
-    handle = kNtInvalidHandleValue;
-  } else {
-    handle = g_fds.p[fd].handle;
-  }
-
-  // mark map handle as inheritable if fork might need it
-  const struct NtSecurityAttributes *mapsec;
-  if ((flags & MAP_TYPE) == MAP_SHARED) {
-    mapsec = &kNtIsInheritable;
-  } else {
-    mapsec = 0;
-  }
-
-  // nt will whine under many circumstances if we change the execute bit
-  // later using mprotect(). the workaround is to always request execute
-  // and then virtualprotect() it away until we actually need it. please
-  // note that open-nt.c always requests an kNtGenericExecute accessmask
-  int iscow = false;
-  struct ProtectNt fl;
-  if (handle != -1) {
-    if ((flags & MAP_TYPE) != MAP_SHARED) {
-      // windows has cow pages but they can't propagate across fork()
-      // that means we only get copy-on-write for the root process :(
-      fl = (struct ProtectNt){kNtPageExecuteWritecopy,
-                              kNtFileMapCopy | kNtFileMapExecute};
-      iscow = true;
-    } else {
-      if ((g_fds.p[fd].flags & O_ACCMODE) == O_RDONLY) {
-        fl = (struct ProtectNt){kNtPageExecuteRead,
-                                kNtFileMapRead | kNtFileMapExecute};
-      } else {
-        fl = (struct ProtectNt){kNtPageExecuteReadwrite,
-                                kNtFileMapWrite | kNtFileMapExecute};
-      }
-    }
-  } else {
-    unassert(flags & MAP_ANONYMOUS);
-    fl = (struct ProtectNt){kNtPageExecuteReadwrite,
-                            kNtFileMapWrite | kNtFileMapExecute};
-  }
-
-  int e = errno;
-  struct DirectMap dm;
-TryAgain:
-  if ((dm.maphandle = CreateFileMapping(handle, mapsec, fl.flags1,
-                                        (size + off) >> 32, (size + off), 0))) {
-    if ((dm.addr = MapViewOfFileEx(dm.maphandle, fl.flags2, off >> 32, off,
-                                   size, addr))) {
-      uint32_t oldprot;
-      if (VirtualProtect(dm.addr, size, __prot2nt(prot, iscow), &oldprot)) {
-        return dm;
-      }
-      UnmapViewOfFile(dm.addr);
-    }
-    CloseHandle(dm.maphandle);
-  } else if (!(prot & PROT_EXEC) &&              //
-             (fl.flags2 & kNtFileMapExecute) &&  //
-             GetLastError() == kNtErrorAccessDenied) {
-    // your file needs to have been O_CREAT'd with exec `mode` bits in
-    // order to be mapped with executable permission. we always try to
-    // get execute permission if the kernel will give it to us because
-    // win32 would otherwise forbid mprotect() from elevating later on
-    fl.flags2 &= ~kNtFileMapExecute;
-    switch (fl.flags1) {
-      case kNtPageExecuteWritecopy:
-        fl.flags1 = kNtPageWritecopy;
-        break;
-      case kNtPageExecuteReadwrite:
-        fl.flags1 = kNtPageReadwrite;
-        break;
-      case kNtPageExecuteRead:
-        fl.flags1 = kNtPageReadonly;
-        break;
-      default:
-        __builtin_unreachable();
-    }
-    errno = e;
-    goto TryAgain;
-  }
-
-  dm.maphandle = kNtInvalidHandleValue;
-  dm.addr = (void *)(intptr_t)-1;
-  return dm;
-}
diff --git a/libc/intrin/directmap.c b/libc/intrin/directmap.c
deleted file mode 100644
index edac9eb8d..000000000
--- a/libc/intrin/directmap.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/syscall-sysv.internal.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/directmap.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/nt/runtime.h"
-#include "libc/runtime/memtrack.internal.h"
-#include "libc/runtime/runtime.h"
-#include "libc/runtime/syslib.internal.h"
-#include "libc/sysv/errfuns.h"
-
-/**
- * Obtains memory mapping directly from system.
- *
- * The mmap() function needs to track memory mappings in order to
- * support Windows NT and Address Sanitizer. That memory tracking can be
- * bypassed by calling this function. However the caller is responsible
- * for passing the magic memory handle on Windows NT to CloseHandle().
- *
- * @asyncsignalsafe
- */
-struct DirectMap sys_mmap(void *addr, size_t size, int prot, int flags, int fd,
-                          int64_t off) {
-  struct DirectMap d;
-  if ((__virtualsize += size) >= __virtualmax) {
-    d.maphandle = kNtInvalidHandleValue;
-    d.addr = (void *)enomem();
-  } else if (IsXnuSilicon()) {
-    long p = _sysret(__syslib->__mmap(addr, size, prot, flags, fd, off));
-    d.maphandle = kNtInvalidHandleValue;
-    d.addr = (void *)p;
-  } else if (!IsWindows() && !IsMetal()) {
-    d.addr = __sys_mmap(addr, size, prot, flags, fd, off, off);
-    d.maphandle = kNtInvalidHandleValue;
-  } else if (IsMetal()) {
-    d = sys_mmap_metal(addr, size, prot, flags, fd, off);
-  } else {
-    d = sys_mmap_nt(addr, size, prot, flags, fd, off);
-  }
-  if (d.addr == MAP_FAILED)
-    __virtualsize -= size;
-  KERNTRACE("sys_mmap(%.12p, %'zu, %s, %s, %d, %'ld) → {%.12p, %p}% m", addr,
-            size, DescribeProtFlags(prot), DescribeMapFlags(flags), fd, off,
-            d.addr, d.maphandle);
-  return d;
-}
diff --git a/libc/intrin/directmap.h b/libc/intrin/directmap.h
new file mode 100644
index 000000000..389336a91
--- /dev/null
+++ b/libc/intrin/directmap.h
@@ -0,0 +1,10 @@
+#ifndef COSMOPOLITAN_LIBC_INTRIN_DIRECTMAP_H_
+#define COSMOPOLITAN_LIBC_INTRIN_DIRECTMAP_H_
+COSMOPOLITAN_C_START_
+
+void *sys_mmap_metal(void *, size_t, int, int, int, int64_t) libcesque;
+int sys_munmap_metal(void *, size_t) libcesque;
+int __prot2nt(int, int) libcesque;
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_INTRIN_DIRECTMAP_H_ */
diff --git a/libc/intrin/directmap.internal.h b/libc/intrin/directmap.internal.h
deleted file mode 100644
index a3eefc30a..000000000
--- a/libc/intrin/directmap.internal.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_DIRECTMAP_H_
-#define COSMOPOLITAN_LIBC_INTRIN_DIRECTMAP_H_
-COSMOPOLITAN_C_START_
-
-struct ProtectNt {
-  uint32_t flags1;
-  uint32_t flags2;
-};
-
-struct DirectMap {
-  void *addr;
-  int64_t maphandle;
-};
-
-struct DirectMap sys_mmap(void *, size_t, int, int, int, int64_t);
-struct DirectMap sys_mmap_nt(void *, size_t, int, int, int, int64_t);
-struct DirectMap sys_mmap_metal(void *, size_t, int, int, int, int64_t);
-int sys_munmap_metal(void *, size_t) libcesque;
-int __prot2nt(int, int) libcesque;
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_DIRECTMAP_H_ */
diff --git a/libc/intrin/dll.c b/libc/intrin/dll.c
index b94cfd7b2..b6337273d 100644
--- a/libc/intrin/dll.c
+++ b/libc/intrin/dll.c
@@ -28,7 +28,7 @@
  *
  * It's required that `elem` and `succ` aren't part of the same list.
  */
-privileged void dll_splice_after(struct Dll *elem, struct Dll *succ) {
+void dll_splice_after(struct Dll *elem, struct Dll *succ) {
   struct Dll *tmp1, *tmp2;
   tmp1 = elem->next;
   tmp2 = succ->prev;
@@ -43,7 +43,7 @@ privileged void dll_splice_after(struct Dll *elem, struct Dll *succ) {
  *
  * @param list is a doubly-linked list, where `!*list` means empty
  */
-privileged void dll_remove(struct Dll **list, struct Dll *elem) {
+void dll_remove(struct Dll **list, struct Dll *elem) {
   if (*list == elem) {
     if ((*list)->prev == *list) {
       *list = 0;
@@ -66,7 +66,7 @@ privileged void dll_remove(struct Dll **list, struct Dll *elem) {
  * @param list is a doubly-linked list, where `!*list` means empty
  * @param elem must not be a member of `list`, or null for no-op
  */
-privileged void dll_make_first(struct Dll **list, struct Dll *elem) {
+void dll_make_first(struct Dll **list, struct Dll *elem) {
   if (elem) {
     if (!*list) {
       *list = elem->prev;
@@ -85,7 +85,7 @@ privileged void dll_make_first(struct Dll **list, struct Dll *elem) {
  * @param list is a doubly-linked list, where `!*list` means empty
  * @param elem must not be a member of `list`, or null for no-op
  */
-privileged void dll_make_last(struct Dll **list, struct Dll *elem) {
+void dll_make_last(struct Dll **list, struct Dll *elem) {
   if (elem) {
     dll_make_first(list, elem->next);
     *list = elem;
diff --git a/libc/intrin/dlopen.c b/libc/intrin/dlopen.c
new file mode 100644
index 000000000..3e93f8be3
--- /dev/null
+++ b/libc/intrin/dlopen.c
@@ -0,0 +1,34 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/posixthread.internal.h"
+#include "libc/thread/thread.h"
+
+static pthread_mutex_t __dlopen_lock_obj = PTHREAD_MUTEX_INITIALIZER;
+
+void __dlopen_lock(void) {
+  _pthread_mutex_lock(&__dlopen_lock_obj);
+}
+
+void __dlopen_unlock(void) {
+  _pthread_mutex_unlock(&__dlopen_lock_obj);
+}
+
+void __dlopen_wipe(void) {
+  _pthread_mutex_wipe_np(&__dlopen_lock_obj);
+}
diff --git a/libc/intrin/dos2errno.c b/libc/intrin/dos2errno.c
index 4e88bd67b..2cbca8f1e 100644
--- a/libc/intrin/dos2errno.c
+++ b/libc/intrin/dos2errno.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
-#include "libc/intrin/dos2errno.internal.h"
+#include "libc/intrin/dos2errno.h"
 #include "libc/nt/errors.h"
 #include "libc/sock/sock.h"
 
diff --git a/libc/intrin/dos2errno.internal.h b/libc/intrin/dos2errno.h
similarity index 100%
rename from libc/intrin/dos2errno.internal.h
rename to libc/intrin/dos2errno.h
diff --git a/libc/runtime/dsohandle.S b/libc/intrin/dsohandle.S
similarity index 98%
rename from libc/runtime/dsohandle.S
rename to libc/intrin/dsohandle.S
index 39cc3e989..37108e8a3 100644
--- a/libc/runtime/dsohandle.S
+++ b/libc/intrin/dsohandle.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.underrun
 //	Uniquely identifies each artifact linked in an address space.
diff --git a/libc/intrin/enable_threads.c b/libc/intrin/enable_threads.c
deleted file mode 100644
index 18c27364f..000000000
--- a/libc/intrin/enable_threads.c
+++ /dev/null
@@ -1,24 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/runtime/runtime.h"
-#include "libc/thread/tls.h"
-
-void __enable_threads(void) {
-  __threaded = 1;
-}
diff --git a/libc/intrin/exit.c b/libc/intrin/exit.c
index 8d1a92f6c..1338e1846 100644
--- a/libc/intrin/exit.c
+++ b/libc/intrin/exit.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/intrin/promises.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/promises.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nexgen32e/vendor.internal.h"
 #include "libc/nt/enum/status.h"
diff --git a/libc/intrin/extend.c b/libc/intrin/extend.c
index 20a557fef..f4bf9383b 100644
--- a/libc/intrin/extend.c
+++ b/libc/intrin/extend.c
@@ -22,7 +22,7 @@
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
 
-#define G __granularity()
+#define G __gransize
 
 /**
  * Extends static allocation.
diff --git a/libc/intrin/extend.internal.h b/libc/intrin/extend.h
similarity index 100%
rename from libc/intrin/extend.internal.h
rename to libc/intrin/extend.h
diff --git a/third_party/compiler_rt/extendsftf2.c b/libc/intrin/extendsftf2.c
similarity index 89%
rename from third_party/compiler_rt/extendsftf2.c
rename to libc/intrin/extendsftf2.c
index 1509b45e4..444140e1a 100644
--- a/third_party/compiler_rt/extendsftf2.c
+++ b/libc/intrin/extendsftf2.c
@@ -8,8 +8,6 @@
 //===----------------------------------------------------------------------===//
 //
 
-__static_yoink("huge_compiler_rt_license");
-
 #define QUAD_PRECISION
 #include "third_party/compiler_rt/fp_lib.inc"
 
@@ -19,7 +17,7 @@ __static_yoink("huge_compiler_rt_license");
 #include "third_party/compiler_rt/fp_extend_impl.inc"
 
 COMPILER_RT_ABI long double __extendsftf2(float a) {
-    return __extendXfYf2__(a);
+  return __extendXfYf2__(a);
 }
 
 #endif
diff --git a/libc/intrin/fds.c b/libc/intrin/fds.c
new file mode 100644
index 000000000..7fcfe983d
--- /dev/null
+++ b/libc/intrin/fds.c
@@ -0,0 +1,198 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/fds.h"
+#include "libc/calls/internal.h"
+#include "libc/calls/state.internal.h"
+#include "libc/calls/ttydefaults.h"
+#include "libc/dce.h"
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/extend.h"
+#include "libc/intrin/maps.h"
+#include "libc/intrin/nomultics.h"
+#include "libc/intrin/pushpop.h"
+#include "libc/intrin/weaken.h"
+#include "libc/nt/console.h"
+#include "libc/nt/createfile.h"
+#include "libc/nt/enum/accessmask.h"
+#include "libc/nt/enum/creationdisposition.h"
+#include "libc/nt/enum/fileflagandattributes.h"
+#include "libc/nt/enum/filemapflags.h"
+#include "libc/nt/enum/filesharemode.h"
+#include "libc/nt/memory.h"
+#include "libc/nt/runtime.h"
+#include "libc/runtime/internal.h"
+#include "libc/runtime/memtrack.internal.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sock/sock.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/prot.h"
+#include "libc/thread/thread.h"
+#include "libc/thread/tls.h"
+
+#ifdef __x86_64__
+__static_yoink("_init_fds");
+#endif
+
+struct Fds g_fds;
+
+static bool TokAtoi(const char **str, long *res) {
+  int c, d;
+  unsigned long x = 0;
+  d = 1;
+  if (**str == '-') {
+    (*str)++;
+    d = -1;
+  }
+  while ((c = *(*str)++)) {
+    if (('0' <= c && c <= '9')) {
+      x *= 10;
+      x += (c - '0') * d;
+    } else {
+      *res = x;
+      return true;
+    }
+  }
+  return false;
+}
+
+static textwindows void SetupWinStd(struct Fds *fds, int i, uint32_t x) {
+  int64_t h;
+  uint32_t cm;
+  h = GetStdHandle(x);
+  if (!h || h == -1)
+    return;
+  fds->p[i].kind = GetConsoleMode(h, &cm) ? kFdConsole : kFdFile;
+  fds->p[i].handle = h;
+  atomic_store_explicit(&fds->f, i + 1, memory_order_relaxed);
+}
+
+textstartup void __init_fds(int argc, char **argv, char **envp) {
+
+  struct Fds *fds;
+  fds = &g_fds;
+  fds->n = 4;
+  atomic_store_explicit(&fds->f, 3, memory_order_relaxed);
+  fds->p = fds->e = (void *)kMemtrackFdsStart;
+  fds->e = _extend(fds->p, fds->n * sizeof(*fds->p), fds->e, MAP_PRIVATE,
+                   kMemtrackFdsStart + kMemtrackFdsSize);
+
+  // inherit standard i/o file descriptors
+  if (IsMetal()) {
+    extern const char vga_console[];
+    fds->f = 3;
+    if (_weaken(vga_console)) {
+      fds->p[0].kind = pushpop(kFdConsole);
+      fds->p[1].kind = pushpop(kFdConsole);
+      fds->p[2].kind = pushpop(kFdConsole);
+    } else {
+      fds->p[0].kind = pushpop(kFdSerial);
+      fds->p[1].kind = pushpop(kFdSerial);
+      fds->p[2].kind = pushpop(kFdSerial);
+    }
+    fds->p[0].handle = __veil("r", 0x3F8ull);
+    fds->p[1].handle = __veil("r", 0x3F8ull);
+    fds->p[2].handle = __veil("r", 0x3F8ull);
+  } else if (IsWindows()) {
+    for (long i = 0; i < 3; ++i) {
+      SetupWinStd(fds, i, kNtStdio[i]);
+    }
+  }
+  fds->p[0].flags = O_RDONLY;
+  fds->p[1].flags = O_WRONLY | O_APPEND;
+  fds->p[2].flags = O_WRONLY | O_APPEND;
+
+  // inherit file descriptors from cosmo parent process
+  if (IsWindows()) {
+    const char *fdspec;
+    if ((fdspec = getenv("_COSMO_FDS_V2"))) {
+      char *smaddr = 0;
+      unsetenv("_COSMO_FDS");
+      unsetenv("_COSMO_FDS_V2");
+      for (;;) {
+        long fd, kind, flags, mode, handle, shand, type, family, protocol;
+        if (!TokAtoi(&fdspec, &fd))
+          break;
+        if (!TokAtoi(&fdspec, &handle))
+          break;
+        if (!TokAtoi(&fdspec, &kind))
+          break;
+        if (!TokAtoi(&fdspec, &flags))
+          break;
+        if (!TokAtoi(&fdspec, &mode))
+          break;
+        if (!TokAtoi(&fdspec, &shand))
+          break;
+        if (!TokAtoi(&fdspec, &type))
+          break;
+        if (!TokAtoi(&fdspec, &family))
+          break;
+        if (!TokAtoi(&fdspec, &protocol))
+          break;
+        __ensurefds_unlocked(fd);
+        struct Fd *f = fds->p + fd;
+        if (f->handle && f->handle != -1 && f->handle != handle) {
+          CloseHandle(f->handle);
+          if (fd < 3)
+            SetStdHandle(kNtStdio[fd], handle);
+        }
+        f->handle = handle;
+        f->kind = kind;
+        f->flags = flags;
+        f->mode = mode;
+        f->type = type;
+        f->family = family;
+        f->protocol = protocol;
+        atomic_store_explicit(&fds->f, fd + 1, memory_order_relaxed);
+
+        if (shand) {
+          struct Map *map;
+          struct CursorShared *shared;
+          if (!smaddr) {
+            smaddr = __maps_randaddr();
+          } else {
+            smaddr += 65536;
+          }
+          if ((shared = MapViewOfFileEx(shand, kNtFileMapWrite, 0, 0,
+                                        sizeof(struct CursorShared), smaddr))) {
+            if ((f->cursor = _mapanon(sizeof(struct Cursor)))) {
+              f->cursor->shared = shared;
+              if ((map = __maps_alloc())) {
+                map->addr = (char *)shared;
+                map->size = sizeof(struct CursorShared);
+                map->off = 0;
+                map->prot = PROT_READ | PROT_WRITE;
+                map->flags = MAP_SHARED | MAP_ANONYMOUS;
+                map->hand = shand;
+                __maps_lock();
+                __maps_insert(map);
+                __maps_unlock();
+              }
+            }
+          }
+        }
+      }
+    }
+    for (int i = 0; i < 3; ++i) {
+      struct Fd *f = fds->p + i;
+      if (f->kind == kFdFile && !f->cursor)
+        f->cursor = __cursor_new();
+    }
+  }
+}
diff --git a/libc/intrin/fds.h b/libc/intrin/fds.h
new file mode 100644
index 000000000..2cfccc771
--- /dev/null
+++ b/libc/intrin/fds.h
@@ -0,0 +1,57 @@
+#ifndef COSMOPOLITAN_LIBC_CALLS_STRUCT_FD_INTERNAL_H_
+#define COSMOPOLITAN_LIBC_CALLS_STRUCT_FD_INTERNAL_H_
+#include "libc/sock/struct/sockaddr.h"
+#include "libc/thread/thread.h"
+COSMOPOLITAN_C_START_
+
+#define kFdEmpty     0
+#define kFdFile      1
+#define kFdSocket    2
+#define kFdConsole   4
+#define kFdSerial    5
+#define kFdZip       6
+#define kFdEpoll     7 /* epoll() deleted on 2024-09-01 */
+#define kFdReserved  8
+#define kFdDevNull   9
+#define kFdDevRandom 10
+
+struct CursorShared {
+  pthread_mutex_t lock;
+  long pointer;
+};
+
+struct Cursor {
+  struct CursorShared *shared;
+  _Atomic(int) refs;
+};
+
+struct Fd {
+  char kind;
+  bool isbound;
+  char connecting;
+  unsigned flags;
+  unsigned mode;
+  long handle;
+  int family;
+  int type;
+  int protocol;
+  unsigned rcvtimeo; /* millis; 0 means wait forever */
+  unsigned sndtimeo; /* millis; 0 means wait forever */
+  void *connect_op;
+  struct Cursor *cursor;
+};
+
+struct Fds {
+  _Atomic(int) f; /* lowest free slot */
+  size_t n;
+  struct Fd *p, *e;
+};
+
+struct Cursor *__cursor_new(void);
+void __cursor_ref(struct Cursor *);
+int __cursor_unref(struct Cursor *);
+void __cursor_lock(struct Cursor *);
+void __cursor_unlock(struct Cursor *);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_CALLS_STRUCT_FD_INTERNAL_H_ */
diff --git a/libc/intrin/fds_init.S b/libc/intrin/fds_init.S
new file mode 100644
index 000000000..f86569b6f
--- /dev/null
+++ b/libc/intrin/fds_init.S
@@ -0,0 +1,30 @@
+/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/macros.h"
+
+	.init.start 305,_init_fds
+	push	%rdi
+	push	%rsi
+	mov	%r12d,%edi			// argc
+	mov	%r13,%rsi			// argv
+	mov	%r14,%rdx			// environ
+	call	__init_fds
+	pop	%rsi
+	pop	%rdi
+	.init.end 305,_init_fds
diff --git a/libc/intrin/fds_lock.c b/libc/intrin/fds_lock.c
index c32367d85..1e1ddcc32 100644
--- a/libc/intrin/fds_lock.c
+++ b/libc/intrin/fds_lock.c
@@ -17,12 +17,13 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/state.internal.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 
 void __fds_lock(void) {
-  pthread_mutex_lock(&__fds_lock_obj);
+  _pthread_mutex_lock(&__fds_lock_obj);
 }
 
 void __fds_unlock(void) {
-  pthread_mutex_unlock(&__fds_lock_obj);
+  _pthread_mutex_unlock(&__fds_lock_obj);
 }
diff --git a/libc/intrin/fds_lock_obj.c b/libc/intrin/fds_lock_obj.c
index 954531a0f..89733cab9 100644
--- a/libc/intrin/fds_lock_obj.c
+++ b/libc/intrin/fds_lock_obj.c
@@ -19,4 +19,4 @@
 #include "libc/calls/state.internal.h"
 #include "libc/thread/thread.h"
 
-pthread_mutex_t __fds_lock_obj = {._type = PTHREAD_MUTEX_RECURSIVE};
+pthread_mutex_t __fds_lock_obj = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
diff --git a/libc/intrin/fenv.S b/libc/intrin/fenv.S
index ae00d8684..697d19999 100644
--- a/libc/intrin/fenv.S
+++ b/libc/intrin/fenv.S
@@ -25,7 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Clears floating point exception status, e.g.
 //
diff --git a/libc/intrin/findclose.c b/libc/intrin/findclose.c
index eccb3dff0..7f208ac21 100644
--- a/libc/intrin/findclose.c
+++ b/libc/intrin/findclose.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/nt/thunk/msabi.h"
 
diff --git a/libc/intrin/findfirstfile.c b/libc/intrin/findfirstfile.c
index 661de9c3d..f43759706 100644
--- a/libc/intrin/findfirstfile.c
+++ b/libc/intrin/findfirstfile.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/struct/win32finddata.h"
diff --git a/libc/intrin/findnextfile.c b/libc/intrin/findnextfile.c
index 5bb42cc87..e1cb288e6 100644
--- a/libc/intrin/findnextfile.c
+++ b/libc/intrin/findnextfile.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/files.h"
 #include "libc/nt/memory.h"
diff --git a/libc/intrin/float16.c b/libc/intrin/float16.c
index 476a2f6c9..434f0cafd 100644
--- a/libc/intrin/float16.c
+++ b/libc/intrin/float16.c
@@ -21,22 +21,135 @@
  * @fileoverview fp16 compiler runtime
  */
 
-#define asint(x) ((union pun){x}).i
-#define isnan(x) (((x) & 0x7fff) > 0x7c00)
+#define isnan16(x) (((x) & 0x7fff) > 0x7c00)
 
-union pun {
-  _Float16 f;
-  unsigned short i;
-};
+static inline _Float16 tofloat16(int x) {
+  union {
+    uint16_t i;
+    _Float16 f;
+  } u = {x};
+  return u.f;
+}
+
+static inline int fromfloat16(_Float16 x) {
+  union {
+    _Float16 f;
+    uint16_t i;
+  } u = {x};
+  return u.i;
+}
+
+static inline _Float32 tofloat32(uint32_t w) {
+  union {
+    uint32_t as_bits;
+    _Float32 as_value;
+  } fp32;
+  fp32.as_bits = w;
+  return fp32.as_value;
+}
+
+static inline uint32_t fromfloat32(_Float32 f) {
+  union {
+    _Float32 as_value;
+    uint32_t as_bits;
+  } fp32;
+  fp32.as_value = f;
+  return fp32.as_bits;
+}
+
+static inline _Float32 fabs32(_Float32 x) {
+  return tofloat32(fromfloat32(x) & 0x7fffffffu);
+}
 
 int __eqhf2(_Float16 fx, _Float16 fy) {
-  int x = asint(fx);
-  int y = asint(fy);
-  return (x == y) & !isnan(x) & !isnan(y);
+  int x = fromfloat16(fx);
+  int y = fromfloat16(fy);
+  return (x == y) & !isnan16(x) & !isnan16(y);
 }
 
 int __nehf2(_Float16 fx, _Float16 fy) {
-  int x = asint(fx);
-  int y = asint(fy);
-  return (x != y) & !isnan(x) & !isnan(y);
+  int x = fromfloat16(fx);
+  int y = fromfloat16(fy);
+  return (x != y) & !isnan16(x) & !isnan16(y);
 }
+
+_Float32 __extendhfsf2(_Float16 f) {
+  uint16_t h = fromfloat16(f);
+  const uint32_t w = (uint32_t)h << 16;
+  const uint32_t sign = w & 0x80000000u;
+  const uint32_t two_w = w + w;
+  const uint32_t exp_offset = 0xE0u << 23;
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) || \
+    defined(__GNUC__) && !defined(__STRICT_ANSI__)
+  const _Float32 exp_scale = 0x1.0p-112f;
+#else
+  const _Float32 exp_scale = tofloat32(0x7800000u);
+#endif
+  const _Float32 normalized_value =
+      tofloat32((two_w >> 4) + exp_offset) * exp_scale;
+  const uint32_t magic_mask = 126u << 23;
+  const _Float32 magic_bias = 0.5f;
+  const _Float32 denormalized_value =
+      tofloat32((two_w >> 17) | magic_mask) - magic_bias;
+  const uint32_t denormalized_cutoff = 1u << 27;
+  const uint32_t result =
+      sign | (two_w < denormalized_cutoff ? fromfloat32(denormalized_value)
+                                          : fromfloat32(normalized_value));
+  return tofloat32(result);
+}
+
+_Float64 __extendhfdf2(_Float16 f) {
+  return __extendhfsf2(f);
+}
+
+#ifdef __x86_64__
+__float80 __extendhfxf2(_Float16 f) {
+  return __extendhfsf2(f);
+}
+#endif
+
+#ifdef __aarch64__
+_Float128 __extendhftf2(_Float16 f) {
+  return __extendhfsf2(f);
+}
+#endif
+
+_Float16 __truncsfhf2(_Float32 f) {
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) || \
+    defined(__GNUC__) && !defined(__STRICT_ANSI__)
+  const _Float32 scale_to_inf = 0x1.0p+112f;
+  const _Float32 scale_to_zero = 0x1.0p-110f;
+#else
+  const _Float32 scale_to_inf = tofloat32(0x77800000u);
+  const _Float32 scale_to_zero = tofloat32(0x08800000u);
+#endif
+  _Float32 base = (fabs32(f) * scale_to_inf) * scale_to_zero;
+  const uint32_t w = fromfloat32(f);
+  const uint32_t shl1_w = w + w;
+  const uint32_t sign = w & 0x80000000u;
+  uint32_t bias = shl1_w & 0xFF000000u;
+  if (bias < 0x71000000u)
+    bias = 0x71000000u;
+  base = tofloat32((bias >> 1) + 0x07800000u) + base;
+  const uint32_t bits = fromfloat32(base);
+  const uint32_t exp_bits = (bits >> 13) & 0x00007C00u;
+  const uint32_t mantissa_bits = bits & 0x00000FFFu;
+  const uint32_t nonsign = exp_bits + mantissa_bits;
+  return tofloat16((sign >> 16) | (shl1_w > 0xFF000000u ? 0x7E00u : nonsign));
+}
+
+_Float16 __truncdfhf2(_Float64 f) {
+  return __truncsfhf2(f);
+}
+
+#ifdef __x86_64__
+_Float16 __truncxfhf2(__float80 f) {
+  return __truncsfhf2(f);
+}
+#endif
+
+#ifdef __aarch64__
+_Float16 __trunctfhf2(_Float128 f) {
+  return __truncsfhf2(f);
+}
+#endif
diff --git a/libc/intrin/flushers.c b/libc/intrin/flushers.c
deleted file mode 100644
index 9ef0e0576..000000000
--- a/libc/intrin/flushers.c
+++ /dev/null
@@ -1,22 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdio/fflush.internal.h"
-
-pthread_mutex_t __fflush_lock_obj;
-struct StdioFlush __fflush;
diff --git a/libc/intrin/flushfilebuffers.c b/libc/intrin/flushfilebuffers.c
index 1105d8dd1..4c03a89ae 100644
--- a/libc/intrin/flushfilebuffers.c
+++ b/libc/intrin/flushfilebuffers.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
 
diff --git a/libc/intrin/flushviewoffile.c b/libc/intrin/flushviewoffile.c
index 049a9c0e1..1f977481c 100644
--- a/libc/intrin/flushviewoffile.c
+++ b/libc/intrin/flushviewoffile.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/memory.h"
 
 __msabi extern typeof(FlushViewOfFile) *const __imp_FlushViewOfFile;
diff --git a/libc/intrin/formathex64.c b/libc/intrin/formathex64.c
index 33ba78f8e..e54a1b2c7 100644
--- a/libc/intrin/formathex64.c
+++ b/libc/intrin/formathex64.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/bsr.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 static inline int PickGoodWidth(unsigned x, char z) {
   if (z) {
diff --git a/libc/intrin/futex.S b/libc/intrin/futex.S
deleted file mode 100644
index 73971e959..000000000
--- a/libc/intrin/futex.S
+++ /dev/null
@@ -1,50 +0,0 @@
-/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/sysv/consts/nr.h"
-#include "libc/macros.internal.h"
-.privileged
-
-_futex:
-#ifdef __x86_64__
-	push	%rbp
-	mov	%rsp,%rbp
-	mov	%rcx,%r10
-	mov	__NR_futex,%eax
-	clc
-	syscall
-	jnc	1f
-	neg	%eax
-1:	pop	%rbp
-#elif defined(__aarch64__)
-	ldr	x7,=__hostos
-	ldr	w7,[x7]
-	tst	x7,1			// IsLinux()
-	mov	x7,98			// futex (Linux)
-	mov	x8,454			// _umtx_op (FreeBSD)
-	csel	x8,x7,x8,ne		// choose syscall magnum
-	mov	x7,0			// clear carry (for Linux)
-	adds	x7,x7,0			// clear carry
-	svc	#0			// call kernel
-	bcc	1f			// jump if not carry
-	neg	x0,x0			// linux style errno
-#else
-#error "unsupported architecture"
-#endif /* __x86_64__ */
-1:	ret
-	.endfn	_futex,globl,hidden
diff --git a/libc/intrin/g_fds.c b/libc/intrin/g_fds.c
deleted file mode 100644
index b9f54a491..000000000
--- a/libc/intrin/g_fds.c
+++ /dev/null
@@ -1,166 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/internal.h"
-#include "libc/calls/state.internal.h"
-#include "libc/calls/struct/fd.internal.h"
-#include "libc/calls/ttydefaults.h"
-#include "libc/dce.h"
-#include "libc/intrin/atomic.h"
-#include "libc/intrin/extend.internal.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/intrin/nomultics.internal.h"
-#include "libc/intrin/pushpop.internal.h"
-#include "libc/intrin/weaken.h"
-#include "libc/nt/console.h"
-#include "libc/nt/createfile.h"
-#include "libc/nt/enum/accessmask.h"
-#include "libc/nt/enum/creationdisposition.h"
-#include "libc/nt/enum/fileflagandattributes.h"
-#include "libc/nt/enum/filesharemode.h"
-#include "libc/nt/runtime.h"
-#include "libc/runtime/internal.h"
-#include "libc/runtime/memtrack.internal.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sock/sock.h"
-#include "libc/sysv/consts/map.h"
-#include "libc/sysv/consts/o.h"
-#include "libc/thread/thread.h"
-
-#define OPEN_MAX 16
-
-#ifdef __x86_64__
-__static_yoink("_init_g_fds");
-#endif
-
-struct Fds g_fds;
-static struct Fd g_fds_static[OPEN_MAX];
-
-static bool TokAtoi(const char **str, long *res) {
-  int c, d;
-  unsigned long x = 0;
-  d = **str == '-' ? -1 : 1;
-  while ((c = *(*str)++)) {
-    if (('0' <= c && c <= '9')) {
-      x *= 10;
-      x += (c - '0') * d;
-    } else {
-      *res = x;
-      return true;
-    }
-  }
-  return false;
-}
-
-static textwindows void SetupWinStd(struct Fds *fds, int i, uint32_t x) {
-  int64_t h;
-  uint32_t cm;
-  h = GetStdHandle(x);
-  if (!h || h == -1)
-    return;
-  fds->p[i].kind = GetConsoleMode(h, &cm) ? kFdConsole : kFdFile;
-  fds->p[i].handle = h;
-  atomic_store_explicit(&fds->f, i + 1, memory_order_relaxed);
-}
-
-textstartup void __init_fds(int argc, char **argv, char **envp) {
-  struct Fds *fds;
-  fds = &g_fds;
-  fds->n = 4;
-  atomic_store_explicit(&fds->f, 3, memory_order_relaxed);
-  if (_weaken(_extend)) {
-    fds->p = fds->e = (void *)kMemtrackFdsStart;
-    fds->e =
-        _weaken(_extend)(fds->p, fds->n * sizeof(*fds->p), fds->e, MAP_PRIVATE,
-                         kMemtrackFdsStart + kMemtrackFdsSize);
-  } else {
-    fds->p = g_fds_static;
-    fds->e = g_fds_static + OPEN_MAX;
-  }
-
-  // inherit standard i/o file descriptors
-  if (IsMetal()) {
-    extern const char vga_console[];
-    fds->f = 3;
-    if (_weaken(vga_console)) {
-      fds->p[0].kind = pushpop(kFdConsole);
-      fds->p[1].kind = pushpop(kFdConsole);
-      fds->p[2].kind = pushpop(kFdConsole);
-    } else {
-      fds->p[0].kind = pushpop(kFdSerial);
-      fds->p[1].kind = pushpop(kFdSerial);
-      fds->p[2].kind = pushpop(kFdSerial);
-    }
-    fds->p[0].handle = __veil("r", 0x3F8ull);
-    fds->p[1].handle = __veil("r", 0x3F8ull);
-    fds->p[2].handle = __veil("r", 0x3F8ull);
-  } else if (IsWindows()) {
-    for (long i = 0; i < 3; ++i) {
-      SetupWinStd(fds, i, kNtStdio[i]);
-    }
-  }
-  fds->p[0].flags = O_RDONLY;
-  fds->p[1].flags = O_WRONLY | O_APPEND;
-  fds->p[2].flags = O_WRONLY | O_APPEND;
-
-  // inherit file descriptors from cosmo parent process
-  if (IsWindows()) {
-    const char *fdspec;
-    if ((fdspec = getenv("_COSMO_FDS"))) {
-      unsetenv("_COSMO_FDS");
-      for (;;) {
-        long fd, kind, flags, mode, handle, pointer, type, family, protocol;
-        if (!TokAtoi(&fdspec, &fd))
-          break;
-        if (!TokAtoi(&fdspec, &handle))
-          break;
-        if (!TokAtoi(&fdspec, &kind))
-          break;
-        if (!TokAtoi(&fdspec, &flags))
-          break;
-        if (!TokAtoi(&fdspec, &mode))
-          break;
-        if (!TokAtoi(&fdspec, &pointer))
-          break;
-        if (!TokAtoi(&fdspec, &type))
-          break;
-        if (!TokAtoi(&fdspec, &family))
-          break;
-        if (!TokAtoi(&fdspec, &protocol))
-          break;
-        __ensurefds_unlocked(fd);
-        struct Fd *f = fds->p + fd;
-        if (f->handle && f->handle != -1 && f->handle != handle) {
-          CloseHandle(f->handle);
-          if (fd < 3) {
-            SetStdHandle(kNtStdio[fd], handle);
-          }
-        }
-        f->handle = handle;
-        f->kind = kind;
-        f->flags = flags;
-        f->mode = mode;
-        f->pointer = pointer;
-        f->type = type;
-        f->family = family;
-        f->protocol = protocol;
-        atomic_store_explicit(&fds->f, fd + 1, memory_order_relaxed);
-      }
-    }
-  }
-}
diff --git a/libc/intrin/g_fds_init.S b/libc/intrin/g_fds_init.S
deleted file mode 100644
index c39f63767..000000000
--- a/libc/intrin/g_fds_init.S
+++ /dev/null
@@ -1,30 +0,0 @@
-/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
-
-	.init.start 305,_init_g_fds
-	push	%rdi
-	push	%rsi
-	mov	%r12d,%edi			// argc
-	mov	%r13,%rsi			// argv
-	mov	%r14,%rdx			// environ
-	call	__init_fds
-	pop	%rsi
-	pop	%rdi
-	.init.end 305,_init_g_fds
diff --git a/libc/intrin/gcov.S b/libc/intrin/gcov.S
index c32da3b85..410e30da2 100644
--- a/libc/intrin/gcov.S
+++ b/libc/intrin/gcov.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Magic words to unbreak build if GCOV flags are passed.
 
diff --git a/libc/intrin/generateconsolectrlevent.c b/libc/intrin/generateconsolectrlevent.c
index a9b24dd0e..8a2c673cd 100644
--- a/libc/intrin/generateconsolectrlevent.c
+++ b/libc/intrin/generateconsolectrlevent.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/console.h"
 #include "libc/nt/thunk/msabi.h"
 
diff --git a/libc/intrin/getauxval.c b/libc/intrin/getauxval.c
index 93391e98a..503be8f26 100644
--- a/libc/intrin/getauxval.c
+++ b/libc/intrin/getauxval.c
@@ -17,9 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
-#include "libc/intrin/getauxval.internal.h"
+#include "libc/intrin/getauxval.h"
 #include "libc/runtime/runtime.h"
-#include "libc/sysv/consts/auxv.h"
 
 /**
  * Returns auxiliary value.
@@ -33,16 +32,6 @@
 unsigned long getauxval(unsigned long key) {
   struct AuxiliaryValue x;
   x = __getauxval(key);
-  if (key == AT_PAGESZ) {
-    if (!x.isfound) {
-#ifdef __aarch64__
-      x.value = 16384;
-#else
-      x.value = 4096;
-#endif
-    }
-    x.isfound = true;
-  }
   if (x.isfound) {
     return x.value;
   } else {
diff --git a/libc/intrin/getauxval.internal.h b/libc/intrin/getauxval.h
similarity index 100%
rename from libc/intrin/getauxval.internal.h
rename to libc/intrin/getauxval.h
diff --git a/libc/calls/getcontext.S b/libc/intrin/getcontext.S
similarity index 96%
rename from libc/calls/getcontext.S
rename to libc/intrin/getcontext.S
index bf3400f43..bdfaded97 100644
--- a/libc/calls/getcontext.S
+++ b/libc/intrin/getcontext.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Gets machine state.
 //
@@ -26,7 +26,9 @@
 //	@see	setcontext()
 	.ftrace1
 getcontext:
+	beg
 	.ftrace2
-#include "libc/calls/getcontext.inc"
+#include "libc/intrin/getcontext.inc"
 	jmp	__getcontextsig
+	end
 	.endfn	getcontext,globl
diff --git a/libc/calls/getcontext.inc b/libc/intrin/getcontext.inc
similarity index 99%
rename from libc/calls/getcontext.inc
rename to libc/intrin/getcontext.inc
index ea0a8b4a8..bbc452658 100644
--- a/libc/calls/getcontext.inc
+++ b/libc/intrin/getcontext.inc
@@ -34,6 +34,7 @@
 	mov	%rbp,120(%rdi)
 	mov	%rbx,128(%rdi)
 	mov	%rdx,136(%rdi)
+	mov	%rax,144(%rdi)
 	mov	%rcx,152(%rdi)
 	lea	8(%rsp),%rax
 	mov	%rax,160(%rdi)		// rsp = caller's rsp
diff --git a/libc/intrin/getcpuidbrand.S b/libc/intrin/getcpuidbrand.S
index 0f4c397f4..255d34a48 100644
--- a/libc/intrin/getcpuidbrand.S
+++ b/libc/intrin/getcpuidbrand.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 GetCpuidBrand:
 	mov	%esi,%eax
diff --git a/libc/intrin/getenv.c b/libc/intrin/getenv.c
index e272d3ed1..29a003d71 100644
--- a/libc/intrin/getenv.c
+++ b/libc/intrin/getenv.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/getenv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/getenv.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 
 /**
diff --git a/libc/intrin/getenv.internal.h b/libc/intrin/getenv.h
similarity index 100%
rename from libc/intrin/getenv.internal.h
rename to libc/intrin/getenv.h
diff --git a/libc/intrin/getexitcodeprocess.c b/libc/intrin/getexitcodeprocess.c
index 8f359803a..630cb4d77 100644
--- a/libc/intrin/getexitcodeprocess.c
+++ b/libc/intrin/getexitcodeprocess.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/accounting.h"
 #include "libc/nt/thunk/msabi.h"
 
diff --git a/libc/intrin/getfileattributes.c b/libc/intrin/getfileattributes.c
index 17f520589..67cb6808e 100644
--- a/libc/intrin/getfileattributes.c
+++ b/libc/intrin/getfileattributes.c
@@ -16,9 +16,10 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
+#include "libc/nt/runtime.h"
 #include "libc/nt/thunk/msabi.h"
 
 __msabi extern typeof(GetFileAttributes) *const __imp_GetFileAttributesW;
@@ -30,7 +31,7 @@ __msabi extern typeof(GetFileAttributes) *const __imp_GetFileAttributesW;
 textwindows uint32_t GetFileAttributes(const char16_t *lpPathName) {
   uint32_t flags;
   flags = __imp_GetFileAttributesW(lpPathName);
-  NTTRACE("GetFileAttributes(%#hs) → %s", lpPathName,
-          DescribeNtFileFlagAttr(flags));
+  NTTRACE("GetFileAttributes(%#hs) → {%s, %d}", lpPathName,
+          DescribeNtFileFlagAttr(flags), GetLastError());
   return flags;
 }
diff --git a/libc/intrin/getgransize.c b/libc/intrin/getgransize.c
new file mode 100644
index 000000000..0b8e30418
--- /dev/null
+++ b/libc/intrin/getgransize.c
@@ -0,0 +1,26 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/runtime/runtime.h"
+
+/**
+ * Returns granularity of mmap() allocations.
+ */
+int getgransize(void) {
+  return __gransize;
+}
diff --git a/libc/intrin/getmainstack.c b/libc/intrin/getmainstack.c
index dc9dbc3fa..afcf18e5a 100644
--- a/libc/intrin/getmainstack.c
+++ b/libc/intrin/getmainstack.c
@@ -17,16 +17,13 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/rlimit.h"
-#include "libc/calls/struct/rlimit.internal.h"
-#include "libc/dce.h"
-#include "libc/intrin/getauxval.internal.h"
-#include "libc/intrin/kprintf.h"
+#include "libc/intrin/getauxval.h"
 #include "libc/intrin/maps.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/rlimit.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
+#include "libc/stdio/sysparam.h"
 #include "libc/sysv/consts/auxv.h"
-#include "libc/sysv/consts/rlim.h"
-#include "libc/sysv/consts/rlimit.h"
 
 // Hack for guessing boundaries of _start()'s stack
 //
@@ -91,12 +88,9 @@ static uintptr_t __get_main_top(int pagesz) {
 }
 
 static size_t __get_stack_size(int pagesz, uintptr_t start, uintptr_t top) {
-  size_t size, max = 8 * 1024 * 1024;
-  struct rlimit rlim = {RLIM_INFINITY};
-  sys_getrlimit(RLIMIT_STACK, &rlim);
-  if ((size = rlim.rlim_cur) > max)
-    size = max;
-  return MAX(ROUNDUP(size, pagesz), ROUNDUP(top - start, pagesz));
+  size_t stacksz = __rlimit_stack_get().rlim_cur;
+  stacksz = MIN(stacksz, 1024ul * 1024 * 1024 * 1024);
+  return MAX(ROUNDDOWN(stacksz, pagesz), ROUNDUP(top - start, pagesz));
 }
 
 /**
@@ -105,7 +99,7 @@ static size_t __get_stack_size(int pagesz, uintptr_t start, uintptr_t top) {
  * This function works on every OS except Windows.
  */
 struct AddrSize __get_main_stack(void) {
-  int pagesz = getauxval(AT_PAGESZ);
+  int pagesz = __pagesize;
   uintptr_t start = (uintptr_t)__argv;
   uintptr_t top = __get_main_top(pagesz);
   uintptr_t bot = top - __get_stack_size(pagesz, start, top);
diff --git a/libc/intrin/getminsigstksz.c b/libc/intrin/getminsigstksz.c
index 95306f23b..9b746e279 100644
--- a/libc/intrin/getminsigstksz.c
+++ b/libc/intrin/getminsigstksz.c
@@ -16,18 +16,47 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/getauxval.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/calls/struct/siginfo.h"
+#include "libc/calls/ucontext.h"
+#include "libc/dce.h"
+#include "libc/intrin/getauxval.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/auxv.h"
 #include "libc/sysv/consts/ss.h"
 
 long __get_minsigstksz(void) {
-  struct AuxiliaryValue x;
-  x = __getauxval(AT_MINSIGSTKSZ);
-  if (x.isfound) {
-    return MAX(_MINSIGSTKSZ, x.value);
+  struct AuxiliaryValue av;
+  av = __getauxval(AT_MINSIGSTKSZ);
+  if (av.isfound) {
+    long res = av.value;
+    if (!IsLinux())
+      res += sizeof(struct ucontext) + sizeof(struct siginfo) + 128;
+    if (res < _MINSIGSTKSZ)
+      res = _MINSIGSTKSZ;
+    return res;
   } else {
+    // _MINSIGSTKSZ takes these things into consideration:
+    //
+    // 1. The platform definition of MINSIGSTKSZ. This will probably be
+    //    enforced by the kernel when calling sys_sigaltstack(). On ARM
+    //    platforms this might be several kilobytes larger than x86. On
+    //    Linux they really want you to use AT_MINSIGSTKSZ instead. The
+    //    kernel should ideally set this to be the number of bytes that
+    //    get subtracted from the stack pointer when delivering signals
+    //    meaning that if you use this for a stack size your handler is
+    //    called successfully but if it uses the stack then it'll crash
+    //
+    // 2. Cosmo sigenter overhead. On non-Linux OSes the kernel calls a
+    //    trampoline in the libc runtime, which translates the platform
+    //    specific signal frame to the Linux memory layout. It means we
+    //    need to push ~1024 extra bytes on the stack to call a handler
+    //
+    // 3. Sanity testing. Assume we use sysconf(_SC_MINSIGSTKSZ) + 2048
+    //    as our stack size (see stackoverflow1_test.c). Then we should
+    //    have enough room to use kprintf() from our signal handler. If
+    //    that isn't the case, then this should be increased a bit more
+    //    noting that if 1024 is used then kprintf should print refusal
+    //
     return _MINSIGSTKSZ;
   }
 }
diff --git a/libc/runtime/getpagesize.c b/libc/intrin/getpagesize.c
similarity index 93%
rename from libc/runtime/getpagesize.c
rename to libc/intrin/getpagesize.c
index 81375c246..acfe9f298 100644
--- a/libc/runtime/getpagesize.c
+++ b/libc/intrin/getpagesize.c
@@ -1,7 +1,7 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
 │ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@@ -19,9 +19,9 @@
 #include "libc/runtime/runtime.h"
 
 /**
- * Returns granularity of memory manager.
+ * Returns system page size.
  * @see sysconf(_SC_PAGE_SIZE) which is portable
  */
 int getpagesize(void) {
-  return __granularity();
+  return __pagesize;
 }
diff --git a/libc/intrin/getsafesize.greg.c b/libc/intrin/getsafesize.greg.c
index 83a772e8a..5a6d9123b 100644
--- a/libc/intrin/getsafesize.greg.c
+++ b/libc/intrin/getsafesize.greg.c
@@ -17,12 +17,11 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "ape/sections.internal.h"
-#include "libc/intrin/kprintf.h"
 #include "libc/runtime/memtrack.internal.h"
+#include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/tls.h"
-#include "libc/thread/tls2.internal.h"
 
 /**
  * Computes safer buffer size for alloca().
@@ -32,18 +31,19 @@
  * @return number of bytes to use for your buffer, or negative if the
  *     allocation would likely cause a stack overflow
  */
-privileged long __get_safe_size(long want, long extraspace) {
+privileged optimizesize long __get_safe_size(long want, long extraspace) {
   if (!__tls_enabled)
     return want;
   struct PosixThread *pt;
   struct CosmoTib *tib = __get_tls_privileged();
   long bottom, sp = GetStackPointer();
-  if ((char *)sp >= tib->tib_sigstack_addr &&
-      (char *)sp <= tib->tib_sigstack_addr + tib->tib_sigstack_size) {
+  if (sp >= (long)tib->tib_sigstack_addr &&
+      sp < (long)tib->tib_sigstack_addr + tib->tib_sigstack_size) {
     bottom = (long)tib->tib_sigstack_addr;
   } else if ((pt = (struct PosixThread *)tib->tib_pthread) &&
-             pt->pt_attr.__stacksize) {
-    bottom = (long)pt->pt_attr.__stackaddr + pt->pt_attr.__guardsize;
+             sp >= (long)pt->pt_attr.__stackaddr &&
+             sp < (long)pt->pt_attr.__stackaddr + pt->pt_attr.__stacksize) {
+    bottom = (long)pt->pt_attr.__stackaddr;
   } else {
     return want;
   }
diff --git a/libc/intrin/gettid.c b/libc/intrin/gettid.c
index 91b37737f..48c7c9e42 100644
--- a/libc/intrin/gettid.c
+++ b/libc/intrin/gettid.c
@@ -39,10 +39,9 @@
 int gettid(void) {
   int tid;
   if (VERY_LIKELY(__tls_enabled && !__vforked)) {
-    tid = atomic_load_explicit(&__get_tls()->tib_tid, memory_order_acquire);
-    if (VERY_LIKELY(tid > 0)) {
+    tid = atomic_load_explicit(&__get_tls()->tib_ptid, memory_order_relaxed);
+    if (VERY_LIKELY(tid > 0))
       return tid;
-    }
   }
   if (IsXnuSilicon()) {
     return enosys();  // can only happen if we can't access thread local storage
diff --git a/libc/intrin/granularity.c b/libc/intrin/granularity.c
deleted file mode 100644
index 279b8d628..000000000
--- a/libc/intrin/granularity.c
+++ /dev/null
@@ -1,30 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/dce.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sysv/consts/auxv.h"
-
-int __granularity(void) {
-  if (IsWindows())
-    return 65536;
-  static int res;
-  if (!res)
-    res = getauxval(AT_PAGESZ);
-  return res;
-}
diff --git a/libc/intrin/interrupts.S b/libc/intrin/interrupts.S
index 837973a18..f1b4298c5 100644
--- a/libc/intrin/interrupts.S
+++ b/libc/intrin/interrupts.S
@@ -26,7 +26,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/runtime/pc.internal.h"
 
diff --git a/libc/intrin/iscall.c b/libc/intrin/iscall.c
index 7907d8525..2cdd23de0 100644
--- a/libc/intrin/iscall.c
+++ b/libc/intrin/iscall.c
@@ -16,11 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/iscall.internal.h"
+#include "libc/intrin/iscall.h"
 
 // returns true if `p` is preceded by x86 call instruction
 // this is actually impossible to do but we'll do our best
-dontinstrument int __is_call(const unsigned char *p) {
+privileged dontinstrument int __is_call(const unsigned char *p) {
   if (p[-5] == 0xe8)
     return 5;  // call Jvds
   if (p[-2] == 0xff && (p[-1] & 070) == 020)
diff --git a/libc/intrin/iscall.internal.h b/libc/intrin/iscall.h
similarity index 100%
rename from libc/intrin/iscall.internal.h
rename to libc/intrin/iscall.h
diff --git a/libc/intrin/isdebuggerpresent.c b/libc/intrin/isdebuggerpresent.c
index 0e12034f3..37474326e 100644
--- a/libc/intrin/isdebuggerpresent.c
+++ b/libc/intrin/isdebuggerpresent.c
@@ -20,8 +20,8 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/getenv.internal.h"
-#include "libc/intrin/promises.internal.h"
+#include "libc/intrin/getenv.h"
+#include "libc/intrin/promises.h"
 #include "libc/log/libfatal.internal.h"
 #include "libc/log/log.h"
 #include "libc/runtime/runtime.h"
diff --git a/libc/calls/isqemu.c b/libc/intrin/isqemu.c
similarity index 100%
rename from libc/calls/isqemu.c
rename to libc/intrin/isqemu.c
diff --git a/libc/intrin/itimer.c b/libc/intrin/itimer.c
new file mode 100644
index 000000000..4d1825396
--- /dev/null
+++ b/libc/intrin/itimer.c
@@ -0,0 +1,43 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/itimer.h"
+#include "libc/str/str.h"
+#include "libc/thread/posixthread.internal.h"
+
+struct IntervalTimer __itimer = {
+    .lock = PTHREAD_MUTEX_INITIALIZER,
+    .cond = PTHREAD_COND_INITIALIZER,
+};
+
+textwindows void __itimer_lock(void) {
+  _pthread_mutex_lock(&__itimer.lock);
+}
+
+textwindows void __itimer_unlock(void) {
+  _pthread_mutex_unlock(&__itimer.lock);
+}
+
+textwindows void __itimer_wipe_and_reset(void) {
+  // timers aren't inherited by forked subprocesses
+  bzero(&__itimer.it, sizeof(__itimer.it));
+  _pthread_mutex_wipe_np(&__itimer.lock);
+  bzero(&__itimer.cond, sizeof(__itimer.cond));
+  __itimer.thread = 0;
+  __itimer.once = 0;
+}
diff --git a/libc/intrin/itoa16.c b/libc/intrin/itoa16.c
new file mode 100644
index 000000000..003aba59c
--- /dev/null
+++ b/libc/intrin/itoa16.c
@@ -0,0 +1,37 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/fmt/internal.h"
+
+__msabi textwindows dontinstrument char16_t *__itoa16(char16_t p[21],
+                                                      uint64_t x) {
+  char t;
+  size_t a, b, i = 0;
+  do {
+    p[i++] = x % 10 + '0';
+    x = x / 10;
+  } while (x > 0);
+  if (i) {
+    for (a = 0, b = i - 1; a < b; ++a, --b) {
+      t = p[a];
+      p[a] = p[b];
+      p[b] = t;
+    }
+  }
+  return p + i;
+}
diff --git a/libc/intrin/kclocknames.S b/libc/intrin/kclocknames.S
index 9a4ba9d6a..fec200aca 100644
--- a/libc/intrin/kclocknames.S
+++ b/libc/intrin/kclocknames.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e s
 	.long	\e - kClockNames
@@ -32,25 +32,13 @@
 	.underrun
 kClockNames:
 	.e	CLOCK_REALTIME,"REALTIME"
-	.e	CLOCK_REALTIME_FAST,"REALTIME_FAST"		// order matters
-	.e	CLOCK_REALTIME_PRECISE,"REALTIME_PRECISE"	// order matters
 	.e	CLOCK_REALTIME_COARSE,"REALTIME_COARSE"		// order matters
 	.e	CLOCK_MONOTONIC,"MONOTONIC"
-	.e	CLOCK_MONOTONIC_FAST,"MONOTONIC_FAST"		// order matters
 	.e	CLOCK_MONOTONIC_RAW,"MONOTONIC_RAW"		// order matters
-	.e	CLOCK_MONOTONIC_PRECISE,"MONOTONIC_PRECISE"	// order matters
 	.e	CLOCK_MONOTONIC_COARSE,"MONOTONIC_COARSE"	// order matters
 	.e	CLOCK_PROCESS_CPUTIME_ID,"PROCESS_CPUTIME_ID"
 	.e	CLOCK_THREAD_CPUTIME_ID,"THREAD_CPUTIME_ID"
-	.e	CLOCK_TAI,"TAI"
-	.e	CLOCK_PROF,"PROF"
 	.e	CLOCK_BOOTTIME,"BOOTTIME"
-	.e	CLOCK_REALTIME_ALARM,"REALTIME_ALARM"
-	.e	CLOCK_BOOTTIME_ALARM,"BOOTTIME_ALARM"
-	.e	CLOCK_UPTIME,"UPTIME"
-	.e	CLOCK_UPTIME_FAST,"UPTIME_FAST"
-	.e	CLOCK_UPTIME_PRECISE,"UPTIME_PRECISE"
-	.e	CLOCK_SECOND,"SECOND"
 	.long	MAGNUM_TERMINATOR
 	.endobj	kClockNames,globl,hidden
 	.overrun
diff --git a/libc/intrin/kdos2errno.S b/libc/intrin/kdos2errno.S
index 8d3e824a7..e753485c4 100644
--- a/libc/intrin/kdos2errno.S
+++ b/libc/intrin/kdos2errno.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	@fileoverview data structure for __dos2errno()
 //	@see	libc/sysv/dos2errno.sh for the numbers
diff --git a/libc/intrin/kerrnodocs.S b/libc/intrin/kerrnodocs.S
index 5bae4dd56..e2947b79a 100644
--- a/libc/intrin/kerrnodocs.S
+++ b/libc/intrin/kerrnodocs.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e s
 	.long	\e - kErrnoDocs
diff --git a/libc/intrin/kerrnonames.S b/libc/intrin/kerrnonames.S
index a79a52a13..078a60306 100644
--- a/libc/intrin/kerrnonames.S
+++ b/libc/intrin/kerrnonames.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e
 	.long	\e - kErrnoNames
diff --git a/libc/intrin/kfcntlcmds.S b/libc/intrin/kfcntlcmds.S
index 6eb1db6e1..6de1f427e 100644
--- a/libc/intrin/kfcntlcmds.S
+++ b/libc/intrin/kfcntlcmds.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e s
 	.long	\e - kFcntlCmds
diff --git a/libc/intrin/kipoptnames.S b/libc/intrin/kipoptnames.S
index f2a2ede1f..1980cfac3 100644
--- a/libc/intrin/kipoptnames.S
+++ b/libc/intrin/kipoptnames.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e s
 	.long	\e - kIpOptnames
@@ -32,9 +32,18 @@
 	.underrun
 kIpOptnames:
 	.e	IP_TOS,"TOS"			// int
-	.e	IP_MTU,"MTU"			// int
 	.e	IP_TTL,"TTL"			// int
+	.e	IP_MTU,"MTU"			// int
 	.e	IP_HDRINCL,"HDRINCL"		// bool32
+	.e	IP_OPTIONS,"OPTIONS"
+	.e	IP_RECVTTL,"RECVTTL"
+	.e	IP_ADD_MEMBERSHIP,"ADD_MEMBERSHIP"
+	.e	IP_DROP_MEMBERSHIP,"DROP_MEMBERSHIP"
+	.e	IP_MULTICAST_IF,"MULTICAST_IF"
+	.e	IP_MULTICAST_LOOP,"MULTICAST_LOOP"
+	.e	IP_MULTICAST_TTL,"MULTICAST_TTL"
+	.e	IP_PKTINFO,"PKTINFO"
+	.e	IP_RECVTOS,"RECVTOS"
 	.long	MAGNUM_TERMINATOR
 	.endobj	kIpOptnames,globl,hidden
 	.overrun
diff --git a/libc/intrin/kipv6optnames.S b/libc/intrin/kipv6optnames.S
new file mode 100644
index 000000000..a3bb86a37
--- /dev/null
+++ b/libc/intrin/kipv6optnames.S
@@ -0,0 +1,52 @@
+/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/fmt/magnumstrs.internal.h"
+#include "libc/macros.h"
+
+	.macro	.e e s
+	.long	\e - kIpv6Optnames
+	.long	.L\@ - kIpv6Optnames
+	.rodata.str1.1
+.L\@:	.string	"\s"
+	.previous
+	.endm
+
+	.section .rodata
+	.balign	4
+	.underrun
+kIpv6Optnames:
+	.e	IPV6_V6ONLY,"V6ONLY"
+	.e	IPV6_CHECKSUM,"CHECKSUM"
+	.e	IPV6_JOIN_GROUP,"JOIN_GROUP"
+	.e	IPV6_LEAVE_GROUP,"LEAVE_GROUP"
+	.e	IPV6_MULTICAST_HOPS,"MULTICAST_HOPS"
+	.e	IPV6_MULTICAST_IF,"MULTICAST_IF"
+	.e	IPV6_MULTICAST_LOOP,"MULTICAST_LOOP"
+	.e	IPV6_UNICAST_HOPS,"UNICAST_HOPS"
+	.e	IPV6_RECVTCLASS,"RECVTCLASS"
+	.e	IPV6_TCLASS,"TCLASS"
+	.e	IPV6_DONTFRAG,"DONTFRAG"
+	.e	IPV6_HOPLIMIT,"HOPLIMIT"
+	.e	IPV6_HOPOPTS,"HOPOPTS"
+	.e	IPV6_PKTINFO,"PKTINFO"
+	.e	IPV6_RECVRTHDR,"RECVRTHDR"
+	.e	IPV6_RTHDR,"RTHDR"
+	.long	MAGNUM_TERMINATOR
+	.endobj	kIpv6Optnames,globl,hidden
+	.overrun
diff --git a/libc/intrin/kisdangerous.c b/libc/intrin/kisdangerous.c
new file mode 100644
index 000000000..2672eae0d
--- /dev/null
+++ b/libc/intrin/kisdangerous.c
@@ -0,0 +1,38 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/maps.h"
+#include "libc/runtime/runtime.h"
+
+privileged optimizesize bool32 kisdangerous(const void *addr) {
+  bool32 res = true;
+  __maps_lock();
+  if (__maps.maps) {
+    struct Map *map;
+    if ((map = __maps_floor(addr)))
+      if ((const char *)addr >= map->addr &&
+          (const char *)addr <
+              map->addr + ((map->size + __pagesize - 1) & -__pagesize))
+        res = false;
+  } else {
+    res = false;
+  }
+  __maps_unlock();
+  return res;
+}
diff --git a/libc/intrin/kmonthname.S b/libc/intrin/kmonthname.S
index e9a4984d0..bf47c7622 100644
--- a/libc/intrin/kmonthname.S
+++ b/libc/intrin/kmonthname.S
@@ -7,7 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	extern const char kMonthName[12][10];
 	.section .rodata,"a",@progbits
diff --git a/libc/intrin/kmonthnameshort.S b/libc/intrin/kmonthnameshort.S
index 4f1874086..573f1bc6a 100644
--- a/libc/intrin/kmonthnameshort.S
+++ b/libc/intrin/kmonthnameshort.S
@@ -7,7 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Type #1:
 //	  - Indexable C-String Array
diff --git a/libc/intrin/kopenflags.S b/libc/intrin/kopenflags.S
index bc6691990..7927fbacd 100644
--- a/libc/intrin/kopenflags.S
+++ b/libc/intrin/kopenflags.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e s
 	.long	\e - kOpenFlags
diff --git a/libc/intrin/kpollnames.S b/libc/intrin/kpollnames.S
index 21e0d4038..76fbc4b00 100644
--- a/libc/intrin/kpollnames.S
+++ b/libc/intrin/kpollnames.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e s
 	.long	\e - kPollNames
diff --git a/libc/intrin/kprintf.greg.c b/libc/intrin/kprintf.greg.c
index 8c4907cc4..a303723c5 100644
--- a/libc/intrin/kprintf.greg.c
+++ b/libc/intrin/kprintf.greg.c
@@ -25,12 +25,11 @@
 #include "libc/fmt/magnumstrs.internal.h"
 #include "libc/intrin/asmflag.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/dll.h"
-#include "libc/intrin/getenv.internal.h"
+#include "libc/intrin/getenv.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/likely.h"
 #include "libc/intrin/maps.h"
-#include "libc/intrin/nomultics.internal.h"
+#include "libc/intrin/nomultics.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/internal.h"
 #include "libc/nexgen32e/rdtsc.h"
@@ -41,9 +40,11 @@
 #include "libc/nt/enum/fileflagandattributes.h"
 #include "libc/nt/enum/filesharemode.h"
 #include "libc/nt/errors.h"
+#include "libc/nt/events.h"
 #include "libc/nt/files.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
+#include "libc/nt/struct/overlapped.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/memtrack.internal.h"
@@ -54,7 +55,7 @@
 #include "libc/stdckdint.h"
 #include "libc/stdio/sysparam.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/str/utf16.h"
 #include "libc/sysv/consts/at.h"
 #include "libc/sysv/consts/f.h"
@@ -64,8 +65,10 @@
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/thread/tls.h"
-#include "libc/thread/tls2.internal.h"
 #include "libc/vga/vga.internal.h"
+#include "libc/wctype.h"
+
+#define ABI privileged optimizesize
 
 #define STACK_ERROR "kprintf error: stack is about to overflow\n"
 
@@ -113,10 +116,13 @@
   }
 
 // clang-format off
+__msabi extern typeof(CloseHandle) *const __imp_CloseHandle;
+__msabi extern typeof(CreateEvent) *const __imp_CreateEventW;
 __msabi extern typeof(CreateFile) *const __imp_CreateFileW;
 __msabi extern typeof(DuplicateHandle) *const __imp_DuplicateHandle;
 __msabi extern typeof(GetEnvironmentVariable) *const __imp_GetEnvironmentVariableW;
 __msabi extern typeof(GetLastError) *const __imp_GetLastError;
+__msabi extern typeof(GetOverlappedResult) *const __imp_GetOverlappedResult;
 __msabi extern typeof(GetStdHandle) *const __imp_GetStdHandle;
 __msabi extern typeof(SetLastError) *const __imp_SetLastError;
 __msabi extern typeof(WriteFile) *const __imp_WriteFile;
@@ -154,29 +160,7 @@ __funline bool kischarmisaligned(const char *p, signed char t) {
   return false;
 }
 
-privileged static bool32 kisdangerous_unlocked(const char *addr) {
-  struct Dll *e, *e2;
-  for (e = dll_first(__maps.used); e; e = e2) {
-    e2 = dll_next(__maps.used, e);
-    struct Map *map = MAP_CONTAINER(e);
-    if (map->addr <= addr && addr < map->addr + map->size) {
-      dll_remove(&__maps.used, e);
-      dll_make_first(&__maps.used, e);
-      return !(map->prot & PROT_READ);
-    }
-  }
-  return true;
-}
-
-privileged bool32 kisdangerous(const void *addr) {
-  bool32 res;
-  __maps_lock();
-  res = kisdangerous_unlocked(addr);
-  __maps_unlock();
-  return res;
-}
-
-privileged static void klogclose(long fd) {
+ABI static void klogclose(long fd) {
 #ifdef __x86_64__
   long ax = __NR_close;
   asm volatile("syscall"
@@ -193,7 +177,7 @@ privileged static void klogclose(long fd) {
 #endif
 }
 
-privileged static long klogfcntl(long fd, long cmd, long arg) {
+ABI static long klogfcntl(long fd, long cmd, long arg) {
 #ifdef __x86_64__
   char cf;
   long ax = __NR_fcntl;
@@ -225,7 +209,7 @@ privileged static long klogfcntl(long fd, long cmd, long arg) {
 #endif
 }
 
-privileged static long klogopen(const char *path) {
+ABI static long klogopen(const char *path) {
   long dirfd = AT_FDCWD;
   long flags = O_WRONLY | O_CREAT | O_APPEND;
   long mode = 0600;
@@ -264,7 +248,7 @@ privileged static long klogopen(const char *path) {
 }
 
 // returns log handle or -1 if logging shouldn't happen
-privileged long kloghandle(void) {
+ABI long kloghandle(void) {
   // kprintf() needs to own a file descriptor in case apps closes stderr
   // our close() and dup() implementations will trigger this initializer
   // to minimize a chance that the user accidentally closes their logger
@@ -289,7 +273,7 @@ privileged long kloghandle(void) {
         hand = __imp_CreateFileW(
             path, kNtFileAppendData,
             kNtFileShareRead | kNtFileShareWrite | kNtFileShareDelete, 0,
-            kNtOpenAlways, kNtFileAttributeNormal, 0);
+            kNtOpenAlways, kNtFileAttributeNormal | kNtFileFlagOverlapped, 0);
       } else {
         hand = -1;  // KPRINTF_LOG was empty string or too long
       }
@@ -343,7 +327,7 @@ privileged long kloghandle(void) {
 }
 
 #ifdef __x86_64__
-privileged void _klog_serial(const char *b, size_t n) {
+ABI void _klog_serial(const char *b, size_t n) {
   size_t i;
   uint16_t dx;
   unsigned char al;
@@ -363,21 +347,28 @@ privileged void _klog_serial(const char *b, size_t n) {
 }
 #endif /* __x86_64__ */
 
-privileged void klog(const char *b, size_t n) {
+ABI void klog(const char *b, size_t n) {
 #ifdef __x86_64__
-  int e;
   long h;
   uint32_t wrote;
   long rax, rdi, rsi, rdx;
-  if ((h = kloghandle()) == -1) {
+  if ((h = kloghandle()) == -1)
     return;
-  }
   if (IsWindows()) {
-    e = __imp_GetLastError();
-    if (!__imp_WriteFile(h, b, n, &wrote, 0)) {
-      __imp_SetLastError(e);
-      __klog_handle = 0;
+    bool32 ok;
+    intptr_t ev;
+    int e = __imp_GetLastError();
+    if ((ev = __imp_CreateEventW(0, 0, 0, 0))) {
+      struct NtOverlapped overlap = {.hEvent = ev};
+      ok = !!__imp_WriteFile(h, b, n, 0, &overlap);
+      if (!ok && __imp_GetLastError() == kNtErrorIoPending)
+        ok = true;
+      ok &= !!__imp_GetOverlappedResult(h, &overlap, &wrote, true);
+      if (!ok)
+        __klog_handle = 0;
+      __imp_CloseHandle(ev);
     }
+    __imp_SetLastError(e);
   } else if (IsMetal()) {
     if (_weaken(_klog_vga)) {
       _weaken(_klog_vga)(b, n);
@@ -413,14 +404,14 @@ privileged void klog(const char *b, size_t n) {
 #endif
 }
 
-privileged static size_t kformat(char *b, size_t n, const char *fmt,
-                                 va_list va) {
+ABI static size_t kformat(char *b, size_t n, const char *fmt, va_list va) {
   int si;
   wint_t t, u;
+  char *cxxbuf;
   const char *abet;
   signed char type;
   const char *s, *f;
-  char cxxbuf[3000];
+  int cxxbufsize = 0;
   struct CosmoTib *tib;
   unsigned long long x;
   unsigned i, j, m, rem, sign, hash, cols, prec;
@@ -570,7 +561,7 @@ privileged static size_t kformat(char *b, size_t n, const char *fmt,
           tib = __tls_enabled ? __get_tls_privileged() : 0;
           if (!(tib && (tib->tib_flags & TIB_FLAG_VFORKED))) {
             if (tib) {
-              x = atomic_load_explicit(&tib->tib_tid, memory_order_relaxed);
+              x = atomic_load_explicit(&tib->tib_ptid, memory_order_relaxed);
             } else {
               x = __pid;
             }
@@ -764,13 +755,25 @@ privileged static size_t kformat(char *b, size_t n, const char *fmt,
           x = va_arg(va, intptr_t);
           if (_weaken(__symtab) && *_weaken(__symtab) &&
               (idx = _weaken(__get_symbol)(0, x)) != -1) {
-            /* if (p + 1 <= e) */
-            /*   *p++ = '&'; */
             s = (*_weaken(__symtab))->name_base +
                 (*_weaken(__symtab))->names[idx];
-            if (_weaken(__is_mangled) && _weaken(__is_mangled)(s) &&
-                _weaken(__demangle)(cxxbuf, s, sizeof(cxxbuf)) != -1)
-              s = cxxbuf;
+#pragma GCC push_options
+#pragma GCC diagnostic ignored "-Walloca-larger-than="
+            // decipher c++ symbols if there's enough stack memory
+            // stack size requirement assumes max_depth's still 20
+            if (_weaken(__demangle) &&    //
+                _weaken(__is_mangled) &&  //
+                _weaken(__is_mangled)(s)) {
+              if (!cxxbufsize)
+                if ((cxxbufsize = __get_safe_size(8192, 8192)) >= 512) {
+                  cxxbuf = alloca(cxxbufsize);
+                  CheckLargeStackAllocation(cxxbuf, sizeof(cxxbufsize));
+                }
+              if (cxxbufsize >= 512)
+                if (_weaken(__demangle)(cxxbuf, s, cxxbufsize) != -1)
+                  s = cxxbuf;
+            }
+#pragma GCC pop_options
             goto FormatString;
           }
           base = 4;
@@ -1026,7 +1029,7 @@ privileged static size_t kformat(char *b, size_t n, const char *fmt,
  * @asyncsignalsafe
  * @vforksafe
  */
-privileged size_t ksnprintf(char *b, size_t n, const char *fmt, ...) {
+ABI size_t ksnprintf(char *b, size_t n, const char *fmt, ...) {
   size_t m;
   va_list v;
   va_start(v, fmt);
@@ -1045,7 +1048,7 @@ privileged size_t ksnprintf(char *b, size_t n, const char *fmt, ...) {
  * @asyncsignalsafe
  * @vforksafe
  */
-privileged size_t kvsnprintf(char *b, size_t n, const char *fmt, va_list v) {
+ABI size_t kvsnprintf(char *b, size_t n, const char *fmt, va_list v) {
   return kformat(b, n, fmt, v);
 }
 
@@ -1056,10 +1059,10 @@ privileged size_t kvsnprintf(char *b, size_t n, const char *fmt, va_list v) {
  * @asyncsignalsafe
  * @vforksafe
  */
-privileged void kvprintf(const char *fmt, va_list v) {
+ABI void kvprintf(const char *fmt, va_list v) {
 #pragma GCC push_options
 #pragma GCC diagnostic ignored "-Walloca-larger-than="
-  long size = __get_safe_size(8000, 8000);
+  long size = __get_safe_size(8192, 2048);
   if (size < 80) {
     klog(STACK_ERROR, sizeof(STACK_ERROR) - 1);
     return;
@@ -1142,7 +1145,7 @@ privileged void kvprintf(const char *fmt, va_list v) {
  * @asyncsignalsafe
  * @vforksafe
  */
-privileged void kprintf(const char *fmt, ...) {
+ABI void kprintf(const char *fmt, ...) {
   // system call support runtime depends on this function
   // function tracing runtime depends on this function
   // asan runtime depends on this function
diff --git a/libc/intrin/krlimitnames.S b/libc/intrin/krlimitnames.S
index 46c6f5dd1..e7f0e788b 100644
--- a/libc/intrin/krlimitnames.S
+++ b/libc/intrin/krlimitnames.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e s
 	.long	\e - kRlimitNames
diff --git a/libc/intrin/ksignalnames.S b/libc/intrin/ksignalnames.S
index 19ad59e9c..6dbc09c01 100644
--- a/libc/intrin/ksignalnames.S
+++ b/libc/intrin/ksignalnames.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e s
 	.long	\e - kSignalNames
diff --git a/libc/intrin/ksockoptnames.S b/libc/intrin/ksockoptnames.S
index 90d592788..28c62f276 100644
--- a/libc/intrin/ksockoptnames.S
+++ b/libc/intrin/ksockoptnames.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e s
 	.long	\e - kSockOptnames
@@ -47,6 +47,7 @@ kSockOptnames:
 	.e	SO_RCVLOWAT,"RCVLOWAT"			// int
 	.e	SO_SNDLOWAT,"SNDLOWAT"			// int
 	.e	SO_ERROR,"ERROR"			// int
+	.e	SO_OOBINLINE,"OOBINLINE"		// int
 	.long	MAGNUM_TERMINATOR
 	.endobj	kSockOptnames,globl,hidden
 	.overrun
diff --git a/libc/intrin/ktcpoptnames.S b/libc/intrin/ktcpoptnames.S
index d4ab2fdbe..314c6b16b 100644
--- a/libc/intrin/ktcpoptnames.S
+++ b/libc/intrin/ktcpoptnames.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.macro	.e e s
 	.long	\e - kTcpOptnames
diff --git a/libc/intrin/kweekdayname.S b/libc/intrin/kweekdayname.S
index 0fa2d967c..835b8bfe9 100644
--- a/libc/intrin/kweekdayname.S
+++ b/libc/intrin/kweekdayname.S
@@ -7,7 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	extern const char kWeekdayName[7][10];
 	.section .rodata,"a",@progbits
diff --git a/libc/intrin/kweekdaynameshort.S b/libc/intrin/kweekdaynameshort.S
index 14a37b1bd..05886838f 100644
--- a/libc/intrin/kweekdaynameshort.S
+++ b/libc/intrin/kweekdaynameshort.S
@@ -7,7 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Type #1:
 //	  - Indexable C-String Array
diff --git a/libc/intrin/leaky.S b/libc/intrin/leaky.S
index b9ba43ed2..45b034ffd 100644
--- a/libc/intrin/leaky.S
+++ b/libc/intrin/leaky.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Decentralized section for leaky functions.
 	.section .piro.relo.sort.leaky.1,"aw",@progbits
diff --git a/libc/intrin/localtime_lock.c b/libc/intrin/localtime_lock.c
new file mode 100644
index 000000000..bbc0a04d1
--- /dev/null
+++ b/libc/intrin/localtime_lock.c
@@ -0,0 +1,34 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/posixthread.internal.h"
+#include "third_party/tz/lock.h"
+
+static pthread_mutex_t __localtime_lock_obj = PTHREAD_MUTEX_INITIALIZER;
+
+void __localtime_lock(void) {
+  _pthread_mutex_lock(&__localtime_lock_obj);
+}
+
+void __localtime_unlock(void) {
+  _pthread_mutex_unlock(&__localtime_lock_obj);
+}
+
+void __localtime_wipe(void) {
+  _pthread_mutex_wipe_np(&__localtime_lock_obj);
+}
diff --git a/libc/intrin/lockfileex.c b/libc/intrin/lockfileex.c
index e156ebe54..88f3cb9e0 100644
--- a/libc/intrin/lockfileex.c
+++ b/libc/intrin/lockfileex.c
@@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/describentoverlapped.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/describentoverlapped.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/filelockflags.h"
 #include "libc/nt/files.h"
 
diff --git a/libc/intrin/lockless.h b/libc/intrin/lockless.h
new file mode 100644
index 000000000..7855f16c2
--- /dev/null
+++ b/libc/intrin/lockless.h
@@ -0,0 +1,50 @@
+#ifndef COSMOPOLITAN_LIBC_INTRIN_LOCKLESS_H_
+#define COSMOPOLITAN_LIBC_INTRIN_LOCKLESS_H_
+#include "libc/atomic.h"
+#include "libc/intrin/atomic.h"
+COSMOPOLITAN_C_START_
+
+// lockless memory transactions
+//
+// - one writer
+// - many readers
+// - generation is monotonic
+// - even numbers mean memory is ready
+// - odd numbers mean memory is actively being changed
+// - always use acquire semantics inside your read transaction
+//
+// let's say you want to be able to atomically read and write to 128-bit
+// values, but you've only got a 64-bit system. if you expect that it'll
+// frequently written, then you should use a mutex. but if you expect it
+// to be frequently read and rarely written, then it's possible to do it
+// without a mutex; in fact you don't even need the x86 lock instruction
+// prefix; all that is required is a series of carefully ordered mov ops
+// which are designed to exploit the strong ordering of the architecture
+
+static inline unsigned lockless_write_begin(atomic_uint* genptr) {
+  unsigned gen = atomic_load_explicit(genptr, memory_order_acquire);
+  atomic_store_explicit(genptr, gen + 1, memory_order_release);
+  return gen;
+}
+
+static inline void lockless_write_end(atomic_uint* genptr, unsigned gen) {
+  atomic_store_explicit(genptr, gen + 2, memory_order_release);
+}
+
+static inline unsigned lockless_read_begin(atomic_uint* genptr) {
+  return atomic_load_explicit(genptr, memory_order_acquire);
+}
+
+static inline bool lockless_read_end(atomic_uint* genptr, unsigned* want) {
+  unsigned gen1 = *want;
+  unsigned gen2 = atomic_load_explicit(genptr, memory_order_acquire);
+  unsigned is_being_actively_changed = gen1 & 1;
+  unsigned we_lost_race_with_writers = gen1 ^ gen2;
+  if (!(is_being_actively_changed | we_lost_race_with_writers))
+    return true;
+  *want = gen2;
+  return false;
+}
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_INTRIN_LOCKLESS_H_ */
diff --git a/libc/intrin/macros.h b/libc/intrin/macros.h
deleted file mode 100644
index 38d6324bd..000000000
--- a/libc/intrin/macros.h
+++ /dev/null
@@ -1,82 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_MACROS_H_
-#define COSMOPOLITAN_LIBC_INTRIN_MACROS_H_
-#include "libc/dce.h"
-#include "libc/nexgen32e/x86feature.h"
-
-#define INTRIN_COMMUTATIVE "%"
-#define INTRIN_NONCOMMUTATIVE
-
-#if defined(__x86_64__) && !defined(__STRICT_ANSI__)
-
-typedef char __intrin_xmm_t
-    __attribute__((__vector_size__(16), __aligned__(16), __may_alias__));
-
-#define INTRIN_SSEVEX_X_X_X_(PURE, ISA, OP, FLAGS, A, B, C)                    \
-  do {                                                                         \
-    if (X86_HAVE(ISA)) {                                                       \
-      __intrin_xmm_t *Xmm0 = (void *)(A);                                      \
-      const __intrin_xmm_t *Xmm1 = (const __intrin_xmm_t *)(B);                \
-      const __intrin_xmm_t *Xmm2 = (const __intrin_xmm_t *)(C);                \
-      if (!X86_NEED(AVX)) {                                                    \
-        asm(OP "\t%1,%0" : "=x"(*Xmm0) : FLAGS "x"(*Xmm2), "0"(*Xmm1));        \
-      } else {                                                                 \
-        asm("v" OP "\t%2,%1,%0" : "=x"(*Xmm0) : FLAGS "x"(*Xmm1), "x"(*Xmm2)); \
-      }                                                                        \
-    } else {                                                                   \
-      PURE(A, B, C);                                                           \
-    }                                                                          \
-  } while (0)
-
-#define INTRIN_SSEVEX_X_X_I_(PURE, ISA, OP, A, B, I)                 \
-  do {                                                               \
-    if (X86_HAVE(ISA)) {                                             \
-      __intrin_xmm_t *Xmm0 = (void *)(A);                            \
-      const __intrin_xmm_t *Xmm1 = (const __intrin_xmm_t *)(B);      \
-      if (!X86_NEED(AVX)) {                                          \
-        asm(OP "\t%2,%1,%0" : "=x"(*Xmm0) : "x"(*Xmm1), "i"(I));     \
-      } else {                                                       \
-        asm("v" OP "\t%2,%1,%0" : "=x"(*Xmm0) : "x"(*Xmm1), "i"(I)); \
-      }                                                              \
-    } else {                                                         \
-      PURE(A, B, I);                                                 \
-    }                                                                \
-  } while (0)
-
-#define INTRIN_SSEVEX_X_X_(PURE, ISA, OP, A, B)                 \
-  do {                                                          \
-    if (X86_HAVE(ISA)) {                                        \
-      __intrin_xmm_t *Xmm0 = (void *)(A);                       \
-      const __intrin_xmm_t *Xmm1 = (const __intrin_xmm_t *)(B); \
-      if (!X86_NEED(AVX)) {                                     \
-        asm(OP "\t%1,%0" : "=x"(*Xmm0) : "0"(*Xmm1));           \
-      } else {                                                  \
-        asm("v" OP "\t%1,%0" : "=x"(*Xmm0) : "x"(*Xmm1));       \
-      }                                                         \
-    } else {                                                    \
-      PURE(A, B);                                               \
-    }                                                           \
-  } while (0)
-
-#define INTRIN_SSEVEX_X_I_(PURE, ISA, OP, A, B, I)                   \
-  do {                                                               \
-    if (!IsModeDbg() && X86_HAVE(ISA)) {                             \
-      __intrin_xmm_t *Xmm0 = (void *)(A);                            \
-      const __intrin_xmm_t *Xmm1 = (const __intrin_xmm_t *)(B);      \
-      if (!X86_NEED(AVX)) {                                          \
-        asm(OP "\t%1,%0" : "=x"(*Xmm0) : "i"(I), "0"(*Xmm1));        \
-      } else {                                                       \
-        asm("v" OP "\t%2,%1,%0" : "=x"(*Xmm0) : "x"(*Xmm1), "i"(I)); \
-      }                                                              \
-    } else {                                                         \
-      PURE(A, B, I);                                                 \
-    }                                                                \
-  } while (0)
-
-#else
-#define INTRIN_SSEVEX_X_X_X_(PURE, ISA, OP, FLAGS, A, B, C) PURE(A, B, C)
-#define INTRIN_SSEVEX_X_X_I_(PURE, ISA, OP, A, B, I)        PURE(A, B, I)
-#define INTRIN_SSEVEX_X_I_(PURE, ISA, OP, A, B, I)          PURE(A, B, I)
-#define INTRIN_SSEVEX_X_X_(PURE, ISA, OP, A, B)             PURE(A, B)
-#endif /* X86 && !ANSI */
-
-#endif /* COSMOPOLITAN_LIBC_INTRIN_MACROS_H_ */
diff --git a/libc/runtime/mapanon.c b/libc/intrin/mapanon.c
similarity index 100%
rename from libc/runtime/mapanon.c
rename to libc/intrin/mapanon.c
diff --git a/libc/intrin/maps.c b/libc/intrin/maps.c
index dd55f2526..7f74960e1 100644
--- a/libc/intrin/maps.c
+++ b/libc/intrin/maps.c
@@ -18,78 +18,175 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/maps.h"
 #include "ape/sections.internal.h"
+#include "libc/calls/state.internal.h"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/cosmo.h"
 #include "libc/dce.h"
+#include "libc/intrin/describebacktrace.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/maps.h"
+#include "libc/macros.h"
+#include "libc/nexgen32e/rdtsc.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
-#include "libc/sysv/consts/auxv.h"
+#include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
-#include "libc/thread/thread.h"
+#include "libc/thread/lock.h"
 #include "libc/thread/tls.h"
 
 #ifdef __x86_64__
 __static_yoink("_init_maps");
 #endif
 
+#define ABI privileged optimizespeed
+
 struct Maps __maps;
 
+void __maps_add(struct Map *map) {
+  tree_insert(&__maps.maps, &map->tree, __maps_compare);
+  ++__maps.count;
+}
+
+static void __maps_adder(struct Map *map, int pagesz) {
+  __maps.pages += ((map->size + pagesz - 1) & -pagesz) / pagesz;
+  __maps_add(map);
+}
+
+void __maps_stack(char *stackaddr, int pagesz, int guardsize, size_t stacksize,
+                  int stackprot, intptr_t stackhand) {
+  __maps.stack.addr = stackaddr + guardsize;
+  __maps.stack.size = stacksize - guardsize;
+  __maps.stack.prot = stackprot;
+  __maps.stack.hand = MAPS_SUBREGION;
+  __maps.stack.flags = MAP_PRIVATE | MAP_ANONYMOUS;
+  __maps_adder(&__maps.stack, pagesz);
+  if (guardsize) {
+    __maps.guard.addr = stackaddr;
+    __maps.guard.size = guardsize;
+    __maps.guard.prot = PROT_NONE | PROT_GUARD;
+    __maps.guard.hand = stackhand;
+    __maps.guard.flags = MAP_PRIVATE | MAP_ANONYMOUS;
+    __maps_adder(&__maps.guard, pagesz);
+  } else {
+    __maps.stack.hand = stackhand;
+  }
+}
+
 void __maps_init(void) {
+  int pagesz = __pagesize;
+
+  // initialize lemur64
+  __maps.rand = 2131259787901769494;
+  __maps.rand ^= kStartTsc;
+
+  // these static map objects avoid mandatory mmap() in __maps_alloc()
+  // they aren't actually needed for bootstrapping this memory manager
+  for (int i = 0; i < ARRAYLEN(__maps.spool); ++i)
+    __maps_free(&__maps.spool[i]);
 
   // record _start() stack mapping
   if (!IsWindows()) {
-    struct AddrSize stack;
-    stack = __get_main_stack();
-    dll_init(&__maps.stack.elem);
-    __maps.stack.addr = stack.addr;
-    __maps.stack.size = stack.size;
-    __maps.stack.prot = (uintptr_t)ape_stack_prot;
-    __maps_insert(&__maps.stack);
+
+    // linux v4.12+ reserves 1mb of guard space beneath rlimit_stack
+    // https://lwn.net/Articles/725832/. if we guess too small, then
+    // slackmap will create a bunch of zombie stacks in __print_maps
+    // to coverup the undisclosed memory but no cost if we guess big
+    size_t guardsize = 1024 * 1024;
+    guardsize += __pagesize - 1;
+    guardsize &= -__pagesize;
+
+    // track the main stack region that the os gave to start earlier
+    struct AddrSize stack = __get_main_stack();
+    __maps_stack(stack.addr - guardsize, pagesz, guardsize,
+                 guardsize + stack.size, (uintptr_t)ape_stack_prot, 0);
   }
 
   // record .text and .data mappings
-  static struct Map text, data;
-  dll_init(&text.elem);
-  text.addr = (char *)__executable_start;
-  text.size = _etext - __executable_start;
-  text.prot = PROT_READ | PROT_EXEC;
-  int pagesz = getauxval(AT_PAGESZ);
+  __maps_track((char *)__executable_start, _etext - __executable_start,
+               PROT_READ | PROT_EXEC, MAP_NOFORK);
   uintptr_t ds = ((uintptr_t)_etext + pagesz - 1) & -pagesz;
-  if (ds < (uintptr_t)_end) {
-    dll_init(&data.elem);
-    data.addr = (char *)ds;
-    data.size = (uintptr_t)_end - ds;
-    data.prot = PROT_READ | PROT_WRITE;
-    __maps_insert(&data);
-  }
-  __maps_insert(&text);
+  if (ds < (uintptr_t)_end)
+    __maps_track((char *)ds, (uintptr_t)_end - ds, PROT_READ | PROT_WRITE,
+                 MAP_NOFORK);
 }
 
-privileged void __maps_lock(void) {
+bool __maps_held(void) {
+  return !__tls_enabled || (__get_tls()->tib_flags & TIB_FLAG_VFORKED) ||
+         MUTEX_OWNER(
+             atomic_load_explicit(&__maps.lock.word, memory_order_relaxed)) ==
+             atomic_load_explicit(&__get_tls()->tib_ptid, memory_order_relaxed);
+}
+
+bool __maps_reentrant(void) {
+  return __tls_enabled && !(__get_tls()->tib_flags & TIB_FLAG_VFORKED) &&
+         MUTEX_OWNER(
+             atomic_load_explicit(&__maps.lock.word, memory_order_relaxed)) ==
+             atomic_load_explicit(&__get_tls()->tib_ptid, memory_order_relaxed);
+}
+
+ABI void __maps_lock(void) {
+  int me;
+  uint64_t word, lock;
   struct CosmoTib *tib;
-  if (!__threaded)
-    return;
   if (!__tls_enabled)
     return;
-  tib = __get_tls_privileged();
-  if (tib->tib_flags & TIB_FLAG_MAPLOCK)
+  if (!(tib = __get_tls_privileged()))
     return;
-  while (atomic_exchange_explicit(&__maps.lock, 1, memory_order_acquire)) {
-#if defined(__GNUC__) && defined(__aarch64__)
-    __asm__ volatile("yield");
-#elif defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
-    __asm__ volatile("pause");
-#endif
+  if (tib->tib_flags & TIB_FLAG_VFORKED)
+    return;
+  me = atomic_load_explicit(&tib->tib_ptid, memory_order_relaxed);
+  word = 0;
+  lock = MUTEX_LOCK(word);
+  lock = MUTEX_SET_OWNER(lock, me);
+  if (atomic_compare_exchange_strong_explicit(&__maps.lock.word, &word, lock,
+                                              memory_order_acquire,
+                                              memory_order_relaxed))
+    return;
+  word = atomic_load_explicit(&__maps.lock.word, memory_order_relaxed);
+  for (;;) {
+    if (MUTEX_OWNER(word) == me) {
+      if (atomic_compare_exchange_weak_explicit(
+              &__maps.lock.word, &word, MUTEX_INC_DEPTH(word),
+              memory_order_relaxed, memory_order_relaxed))
+        return;
+      continue;
+    }
+    word = 0;
+    lock = MUTEX_LOCK(word);
+    lock = MUTEX_SET_OWNER(lock, me);
+    if (atomic_compare_exchange_weak_explicit(&__maps.lock.word, &word, lock,
+                                              memory_order_acquire,
+                                              memory_order_relaxed))
+      return;
+    for (;;) {
+      word = atomic_load_explicit(&__maps.lock.word, memory_order_relaxed);
+      if (MUTEX_OWNER(word) == me)
+        break;
+      if (!word)
+        break;
+    }
   }
-  tib->tib_flags |= TIB_FLAG_MAPLOCK;
 }
 
-privileged void __maps_unlock(void) {
+ABI void __maps_unlock(void) {
+  uint64_t word;
   struct CosmoTib *tib;
-  atomic_store_explicit(&__maps.lock, 0, memory_order_release);
-  if (__tls_enabled) {
-    tib = __get_tls_privileged();
-    tib->tib_flags &= ~TIB_FLAG_MAPLOCK;
+  if (!__tls_enabled)
+    return;
+  if (!(tib = __get_tls_privileged()))
+    return;
+  if (tib->tib_flags & TIB_FLAG_VFORKED)
+    return;
+  word = atomic_load_explicit(&__maps.lock.word, memory_order_relaxed);
+  for (;;) {
+    if (MUTEX_DEPTH(word))
+      if (atomic_compare_exchange_weak_explicit(
+              &__maps.lock.word, &word, MUTEX_DEC_DEPTH(word),
+              memory_order_relaxed, memory_order_relaxed))
+        break;
+    if (atomic_compare_exchange_weak_explicit(&__maps.lock.word, &word, 0,
+                                              memory_order_release,
+                                              memory_order_relaxed))
+      break;
   }
 }
diff --git a/libc/intrin/maps.h b/libc/intrin/maps.h
index bd03e2266..86b1f2f55 100644
--- a/libc/intrin/maps.h
+++ b/libc/intrin/maps.h
@@ -1,33 +1,75 @@
-#ifndef COSMOPOLITAN_LIBC_RUNTIME_MAPS_H_
-#define COSMOPOLITAN_LIBC_RUNTIME_MAPS_H_
+#ifndef COSMOPOLITAN_MAPS_H_
+#define COSMOPOLITAN_MAPS_H_
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/dll.h"
-#include "libc/thread/tls2.internal.h"
+#include "libc/intrin/tree.h"
+#include "libc/runtime/runtime.h"
 COSMOPOLITAN_C_START_
 
-#define MAP_CONTAINER(e) DLL_CONTAINER(struct Map, elem, e)
+/* size of dynamic memory that is used internally by your memory manager */
+#define MAPS_SIZE 65536
+
+/* when map->hand is MAPS_RESERVATION it means mmap() is transactionally
+   reserving address space it is in the process of requesting from win32 */
+#define MAPS_RESERVATION -2
+
+/* when map->hand is MAPS_SUBREGION it means that an allocation has been
+   broken into multiple fragments by mprotect(). the first fragment must
+   be set to MAPS_VIRTUAL or your CreateFileMapping() handle. your frags
+   must be perfectly contiguous in memory and should have the same flags */
+#define MAPS_SUBREGION -3
+
+/* indicates an allocation was created by VirtualAlloc() and so munmap()
+   must call VirtualFree() when destroying it. use it on the hand field. */
+#define MAPS_VIRTUAL -4
+
+/* if this is used on MAP_PRIVATE memory, then it's assumed to be memory
+   that win32 allocated, e.g. a CreateThread() stack. if this is used on
+   MAP_FILE memory, then it's assumed to be part of the executable image */
+#define MAP_NOFORK 0x10000000
+
+#define MAP_TREE_CONTAINER(e) TREE_CONTAINER(struct Map, tree, e)
 
 struct Map {
-  _Atomic(struct Map *) next; /* for __maps.maps */
-  char *addr;                 /* granule aligned */
-  size_t size;                /* must be nonzero */
-  struct Dll elem;            /* for __maps.free */
-  int64_t off;                /* -1 if anonymous */
-  int prot;                   /* memory protects */
-  int flags;                  /* memory map flag */
-  bool iscow;                 /* windows nt only */
-  bool readonlyfile;          /* windows nt only */
-  intptr_t h;                 /* windows nt only */
+  char *addr;        /* granule aligned */
+  size_t size;       /* must be nonzero */
+  int64_t off;       /* ignore for anon */
+  int flags;         /* memory map flag */
+  short prot;        /* memory protects */
+  bool iscow;        /* windows nt only */
+  bool readonlyfile; /* windows nt only */
+  unsigned visited;  /* checks and fork */
+  intptr_t hand;     /* windows nt only */
+  union {
+    struct Tree tree;
+    struct Map *freed;
+  };
+};
+
+struct MapLock {
+  void *edges;
+  _Atomic(uint64_t) word;
+};
+
+struct MapSlab {
+  struct MapSlab *next;
+  struct Map maps[(MAPS_SIZE - sizeof(struct MapSlab *)) / sizeof(struct Map)];
 };
 
 struct Maps {
-  atomic_int lock;
-  _Atomic(struct Map *) maps;
-  struct Dll *free;
-  struct Map stack;
-  struct Dll *used;
+  uint128_t rand;
+  struct Tree *maps;
+  struct MapLock lock;
+  _Atomic(uintptr_t) freed;
+  _Atomic(struct MapSlab *) slabs;
   size_t count;
   size_t pages;
+  struct Map stack;
+  struct Map guard;
+#ifdef MODE_DBG
+  struct Map spool[1];
+#else
+  struct Map spool[20];
+#endif
 };
 
 struct AddrSize {
@@ -37,15 +79,62 @@ struct AddrSize {
 
 extern struct Maps __maps;
 
+bool __maps_held(void);
 void __maps_init(void);
 void __maps_lock(void);
 void __maps_check(void);
 void __maps_unlock(void);
-struct Map *__maps_alloc(void);
+bool __maps_reentrant(void);
+void *__maps_randaddr(void);
+void __maps_add(struct Map *);
 void __maps_free(struct Map *);
 void __maps_insert(struct Map *);
-void *__mmap(char *, size_t, int, int, int, int64_t);
+int __maps_untrack(char *, size_t);
+bool __maps_track(char *, size_t, int, int);
+struct Map *__maps_alloc(void);
+struct Map *__maps_floor(const char *);
+void __maps_stack(char *, int, int, size_t, int, intptr_t);
+int __maps_compare(const struct Tree *, const struct Tree *);
 struct AddrSize __get_main_stack(void);
 
+forceinline optimizespeed int __maps_search(const void *key,
+                                            const struct Tree *node) {
+  const char *addr = (const char *)key;
+  const struct Map *map = (const struct Map *)MAP_TREE_CONTAINER(node);
+  return (addr > map->addr) - (addr < map->addr);
+}
+
+static inline struct Map *__maps_next(struct Map *map) {
+  struct Tree *node;
+  if ((node = tree_next(&map->tree)))
+    return MAP_TREE_CONTAINER(node);
+  return 0;
+}
+
+static inline struct Map *__maps_prev(struct Map *map) {
+  struct Tree *node;
+  if ((node = tree_prev(&map->tree)))
+    return MAP_TREE_CONTAINER(node);
+  return 0;
+}
+
+static inline struct Map *__maps_first(void) {
+  struct Tree *node;
+  if ((node = tree_first(__maps.maps)))
+    return MAP_TREE_CONTAINER(node);
+  return 0;
+}
+
+static inline struct Map *__maps_last(void) {
+  struct Tree *node;
+  if ((node = tree_last(__maps.maps)))
+    return MAP_TREE_CONTAINER(node);
+  return 0;
+}
+
+static inline bool __maps_isalloc(struct Map *map) {
+  return map->hand != MAPS_SUBREGION;
+}
+
 COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_RUNTIME_MAPS_H_ */
+#endif /* COSMOPOLITAN_MAPS_H_ */
diff --git a/libc/intrin/maps_init.S b/libc/intrin/maps_init.S
index 56f2c7f63..134ed77f7 100644
--- a/libc/intrin/maps_init.S
+++ b/libc/intrin/maps_init.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.init.start 301,_init_maps
 	push	%rdi
diff --git a/libc/runtime/mapshared.c b/libc/intrin/mapshared.c
similarity index 100%
rename from libc/runtime/mapshared.c
rename to libc/intrin/mapshared.c
diff --git a/libc/intrin/mapviewoffileex.c b/libc/intrin/mapviewoffileex.c
index 3841269bf..992a1897d 100644
--- a/libc/intrin/mapviewoffileex.c
+++ b/libc/intrin/mapviewoffileex.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/filemapflags.h"
 #include "libc/nt/memory.h"
 
diff --git a/libc/intrin/mapviewoffileexnuma.c b/libc/intrin/mapviewoffileexnuma.c
index 2ee4e40de..879ba345c 100644
--- a/libc/intrin/mapviewoffileexnuma.c
+++ b/libc/intrin/mapviewoffileexnuma.c
@@ -19,8 +19,8 @@
 #include "libc/assert.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/filemapflags.h"
 #include "libc/nt/memory.h"
 
diff --git a/libc/intrin/memchr.c b/libc/intrin/memchr.c
index 6680c5292..fbe1ad409 100644
--- a/libc/intrin/memchr.c
+++ b/libc/intrin/memchr.c
@@ -19,10 +19,10 @@
 #include "libc/dce.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/str/str.h"
+#include "third_party/aarch64/arm_neon.internal.h"
+#include "third_party/intel/immintrin.internal.h"
 #ifndef __aarch64__
 
-typedef char xmm_t __attribute__((__vector_size__(16), __aligned__(1)));
-
 static inline const unsigned char *memchr_pure(const unsigned char *s,
                                                unsigned char c, size_t n) {
   size_t i;
@@ -35,22 +35,27 @@ static inline const unsigned char *memchr_pure(const unsigned char *s,
 }
 
 #if defined(__x86_64__) && !defined(__chibicc__)
-static __vex const unsigned char *memchr_sse(const unsigned char *s,
-                                             unsigned char c, size_t n) {
-  size_t i;
-  unsigned m;
-  xmm_t v, t = {c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c};
-  for (; n >= 16; n -= 16, s += 16) {
-    v = *(const xmm_t *)s;
-    m = __builtin_ia32_pmovmskb128(v == t);
-    if (m) {
-      m = __builtin_ctzll(m);
-      return s + m;
-    }
+static const char *memchr_sse(const char *s, char c, size_t n) {
+  const char *e = s + n;
+  __m128i t = _mm_set1_epi8(c);
+  unsigned m, k = (uintptr_t)s & 15;
+  m = _mm_movemask_epi8(
+      _mm_cmpeq_epi8(_mm_load_si128((const __m128i *)((uintptr_t)s & -16)), t));
+  m >>= k;
+  if (m) {
+    s += __builtin_ctz(m);
+    if (s < e)
+      return s;
+    return 0;
   }
-  for (i = 0; i < n; ++i) {
-    if (s[i] == c) {
-      return s + i;
+  for (s += 16 - k; s < e; s += 16) {
+    m = _mm_movemask_epi8(
+        _mm_cmpeq_epi8(_mm_load_si128((const __m128i *)s), t));
+    if (m) {
+      s += __builtin_ctz(m);
+      if (s < e)
+        return s;
+      return 0;
     }
   }
   return 0;
diff --git a/libc/intrin/mman.greg.c b/libc/intrin/mman.greg.c
index cb9274a1b..07059f919 100644
--- a/libc/intrin/mman.greg.c
+++ b/libc/intrin/mman.greg.c
@@ -36,7 +36,7 @@
 #include "libc/assert.h"
 #include "libc/elf/def.h"
 #include "libc/elf/struct/phdr.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/uart.internal.h"
 #include "libc/runtime/e820.internal.h"
 #include "libc/runtime/metalprintf.internal.h"
@@ -45,7 +45,7 @@
 #ifdef __x86_64__
 
 #define INVERT(x) (BANE + PHYSICAL((uintptr_t)(x)))
-#define NOPAGE    ((uint64_t) - 1)
+#define NOPAGE    ((uint64_t)-1)
 
 #define APE_STACK_VADDR                   \
   ({                                      \
@@ -69,9 +69,9 @@ texthead uint64_t __new_page(struct mman *mm) {
   if (p != NOPAGE) {
     uint64_t q;
     struct ReclaimedPage *rp = (struct ReclaimedPage *)(BANE + p);
-    unassert(p == (p & PAGE_TA));
+    /* unassert(p == (p & PAGE_TA)); */
     q = rp->next;
-    unassert(q == (q & PAGE_TA) || q == NOPAGE);
+    /* unassert(q == (q & PAGE_TA) || q == NOPAGE); */
     mm->frp = q;
     return p;
   }
@@ -200,7 +200,7 @@ void __ref_pages(struct mman *mm, uint64_t *pml4t, uint64_t ps, uint64_t size) {
  */
 static void __reclaim_page(struct mman *mm, uint64_t p) {
   struct ReclaimedPage *rp = (struct ReclaimedPage *)(BANE + p);
-  unassert(p == (p & PAGE_TA));
+  /* unassert(p == (p & PAGE_TA)); */
   rp->next = mm->frp;
   mm->frp = p;
 }
diff --git a/libc/intrin/mmap.c b/libc/intrin/mmap.c
index 8011618a0..de3b5571a 100644
--- a/libc/intrin/mmap.c
+++ b/libc/intrin/mmap.c
@@ -16,45 +16,60 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "ape/sections.internal.h"
-#include "libc/atomic.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/state.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
+#include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describebacktrace.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/directmap.internal.h"
-#include "libc/intrin/dll.h"
+#include "libc/intrin/describebacktrace.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/directmap.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/maps.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/intrin/tree.h"
 #include "libc/intrin/weaken.h"
+#include "libc/limits.h"
+#include "libc/macros.h"
+#include "libc/nt/enum/filemapflags.h"
+#include "libc/nt/enum/memflags.h"
+#include "libc/nt/enum/pageflags.h"
+#include "libc/nt/errors.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/runtime.h"
 #include "libc/runtime/runtime.h"
-#include "libc/runtime/stack.h"
+#include "libc/runtime/syslib.internal.h"
 #include "libc/runtime/zipos.internal.h"
+#include "libc/stdckdint.h"
 #include "libc/stdio/sysparam.h"
-#include "libc/sysv/consts/auxv.h"
 #include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/mremap.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/lock.h"
 #include "libc/thread/thread.h"
+#include "libc/thread/tls.h"
 
-#define MMDEBUG 0               // this code is too slow for openbsd/windows
-#define WINBASE 0x100080040000  // TODO: Can we support Windows Vista again?
-#define WINMAXX 0x200080000000
+#define MMDEBUG  0
+#define MAX_SIZE 0x0ff800000000ul
 
 #define MAP_FIXED_NOREPLACE_linux 0x100000
 
-#define PGUP(x) (((x) + granularity - 1) & -granularity)
+#define PGUP(x) (((x) + __pagesize - 1) & -__pagesize)
+#define GRUP(x) (((x) + __gransize - 1) & -__gransize)
 
-#if MMDEBUG
+#define MASQUE    0x00fffffffffffff8
+#define PTR(x)    ((uintptr_t)(x) & MASQUE)
+#define TAG(x)    ROL((uintptr_t)(x) & ~MASQUE, 8)
+#define ABA(p, t) ((uintptr_t)(p) | (ROR((uintptr_t)(t), 8) & ~MASQUE))
+#define ROL(x, n) (((x) << (n)) | ((x) >> (64 - (n))))
+#define ROR(x, n) (((x) >> (n)) | ((x) << (64 - (n))))
+
+#if !MMDEBUG
 #define ASSERT(x) (void)0
 #else
 #define ASSERT(x)                                                         \
@@ -63,347 +78,619 @@
       char bt[160];                                                       \
       struct StackFrame *bp = __builtin_frame_address(0);                 \
       kprintf("%!s:%d: assertion failed: %!s\n", __FILE__, __LINE__, #x); \
-      kprintf("bt %!s\n", (DescribeBacktrace)(bt, bp));                   \
-      __print_maps();                                                     \
-      _Exit(99);                                                          \
+      kprintf("bt %!s\n", _DescribeBacktrace(bt, bp));                    \
+      __print_maps(0);                                                    \
+      __builtin_trap();                                                   \
     }                                                                     \
   } while (0)
 #endif
 
-static atomic_ulong rollo;
+struct DirectMap {
+  void *addr;
+  int64_t hand;
+};
 
-static bool overlaps_existing_map(const char *addr, size_t size) {
-  int granularity = __granularity();
-  for (struct Map *map = __maps.maps; map; map = map->next)
+int __maps_compare(const struct Tree *ra, const struct Tree *rb) {
+  const struct Map *a = (const struct Map *)MAP_TREE_CONTAINER(ra);
+  const struct Map *b = (const struct Map *)MAP_TREE_CONTAINER(rb);
+  return (a->addr > b->addr) - (a->addr < b->addr);
+}
+
+privileged optimizespeed struct Map *__maps_floor(const char *addr) {
+  struct Tree *node;
+  if ((node = tree_floor(__maps.maps, addr, __maps_search)))
+    return MAP_TREE_CONTAINER(node);
+  return 0;
+}
+
+static bool __maps_overlaps(const char *addr, size_t size) {
+  struct Map *map;
+  ASSERT(__maps_held());
+  if (!(map = __maps_floor(addr)))
+    map = __maps_first();
+  for (; map && map->addr <= addr + size; map = __maps_next(map))
     if (MAX(addr, map->addr) <
         MIN(addr + PGUP(size), map->addr + PGUP(map->size)))
       return true;
   return false;
 }
 
+// returns true if all fragments of all allocations which overlap
+// [addr,addr+size) are completely contained by [addr,addr+size).
+textwindows static bool __maps_envelops(const char *addr, size_t size) {
+  struct Map *map;
+  size = PGUP(size);
+  ASSERT(__maps_held());
+  if (!(map = __maps_floor(addr)))
+    map = __maps_first();
+  while (map && map->addr <= addr + size) {
+    if (MAX(addr, map->addr) < MIN(addr + size, map->addr + map->size)) {
+      if (!__maps_isalloc(map))
+        return false;  // didn't include first fragment of alloc
+      if (addr > map->addr)
+        return false;    // excluded leading pages of first fragment
+      struct Map *next;  // set map to last fragment in allocation
+      for (; (next = __maps_next(map)) && !__maps_isalloc(next); map = next)
+        ASSERT(map->addr + map->size == next->addr);  // contiguous
+      if (addr + size < map->addr + PGUP(map->size))
+        return false;  // excluded trailing pages of allocation
+      map = next;
+    } else {
+      map = __maps_next(map);
+    }
+  }
+  return true;
+}
+
 void __maps_check(void) {
 #if MMDEBUG
+  ASSERT(__maps_held());
   size_t maps = 0;
   size_t pages = 0;
-  int granularity = getauxval(AT_PAGESZ);
-  for (struct Map *map = __maps.maps; map; map = map->next) {
+  static unsigned mono;
+  unsigned id = ++mono;
+  for (struct Map *map = __maps_first(); map; map = __maps_next(map)) {
     ASSERT(map->addr != MAP_FAILED);
+    ASSERT(map->visited != id);
     ASSERT(map->size);
-    pages += PGUP(map->size) / granularity;
+    map->visited = id;
+    pages += (map->size + __pagesize - 1) / __pagesize;
     maps += 1;
+    struct Map *next;
+    if ((next = __maps_next(map))) {
+      ASSERT(map->addr < next->addr);
+      ASSERT(MAX(map->addr, next->addr) >=
+             MIN(map->addr + PGUP(map->size), next->addr + PGUP(next->size)));
+    }
   }
   ASSERT(maps = __maps.count);
   ASSERT(pages == __maps.pages);
-  for (struct Map *m1 = __maps.maps; m1; m1 = m1->next)
-    for (struct Map *m2 = m1->next; m2; m2 = m2->next)
-      ASSERT(MAX(m1->addr, m2->addr) >=
-             MIN(m1->addr + PGUP(m1->size), m2->addr + PGUP(m2->size)));
 #endif
 }
 
+#if MMDEBUG
+static void __maps_ok(void) {
+  ASSERT(!__maps_reentrant());
+  __maps_lock();
+  __maps_check();
+  __maps_unlock();
+}
+__attribute__((__constructor__)) static void __maps_ctor(void) {
+  atexit(__maps_ok);
+  __maps_ok();
+}
+__attribute__((__destructor__)) static void __maps_dtor(void) {
+  __maps_ok();
+}
+#endif
+
+static int __muntrack(char *addr, size_t size, struct Map **deleted,
+                      struct Map **untracked, struct Map temp[2]) {
+  int rc = 0;
+  size_t ti = 0;
+  struct Map *map;
+  struct Map *next;
+  size = PGUP(size);
+  ASSERT(__maps_held());
+  if (!(map = __maps_floor(addr)))
+    map = __maps_first();
+  for (; map && map->addr <= addr + size; map = next) {
+    next = __maps_next(map);
+    char *map_addr = map->addr;
+    size_t map_size = map->size;
+    if (MAX(addr, map_addr) >= MIN(addr + size, map_addr + PGUP(map_size)))
+      continue;
+    if (addr <= map_addr && addr + size >= map_addr + PGUP(map_size)) {
+      if (map->hand == MAPS_RESERVATION)
+        continue;
+      // remove mapping completely
+      tree_remove(&__maps.maps, &map->tree);
+      map->freed = *deleted;
+      *deleted = map;
+      __maps.pages -= (map_size + __pagesize - 1) / __pagesize;
+      __maps.count -= 1;
+      __maps_check();
+    } else if (addr <= map_addr) {
+      // shave off lefthand side of mapping
+      ASSERT(addr + size < map_addr + PGUP(map_size));
+      size_t left = addr + size - map_addr;
+      size_t right = map_size - left;
+      ASSERT(right > 0);
+      ASSERT(left > 0);
+      map->addr += left;
+      map->size = right;
+      if (!(map->flags & MAP_ANONYMOUS))
+        map->off += left;
+      __maps.pages -= (left + __pagesize - 1) / __pagesize;
+      if (untracked) {
+        ASSERT(ti < 2);
+        temp[ti].addr = map_addr;
+        temp[ti].size = left;
+        temp[ti].freed = *untracked;
+        *untracked = temp;
+        ++ti;
+      }
+      __maps_check();
+    } else if (addr + size >= map_addr + PGUP(map_size)) {
+      // shave off righthand side of mapping
+      size_t left = addr - map_addr;
+      size_t right = map_addr + map_size - addr;
+      map->size = left;
+      __maps.pages -= (right + __pagesize - 1) / __pagesize;
+      if (untracked) {
+        ASSERT(ti < 2);
+        temp[ti].addr = addr;
+        temp[ti].size = right;
+        temp[ti].freed = *untracked;
+        *untracked = temp;
+        ++ti;
+      }
+      __maps_check();
+    } else {
+      // punch hole in mapping
+      size_t left = addr - map_addr;
+      size_t middle = size;
+      size_t right = map_size - middle - left;
+      struct Map *leftmap;
+      if ((leftmap = __maps_alloc())) {
+        leftmap->addr = map_addr;
+        leftmap->size = left;
+        leftmap->off = map->off;
+        leftmap->prot = map->prot;
+        leftmap->flags = map->flags;
+        map->addr += left + middle;
+        map->size = right;
+        if (!(map->flags & MAP_ANONYMOUS))
+          map->off += left + middle;
+        tree_insert(&__maps.maps, &leftmap->tree, __maps_compare);
+        __maps.pages -= (middle + __pagesize - 1) / __pagesize;
+        __maps.count += 1;
+        if (untracked) {
+          ASSERT(ti < 2);
+          temp[ti].addr = addr;
+          temp[ti].size = size;
+          temp[ti].freed = *untracked;
+          *untracked = temp;
+          ++ti;
+        }
+        __maps_check();
+      } else {
+        rc = -1;
+      }
+    }
+  }
+  return rc;
+}
+
 void __maps_free(struct Map *map) {
-  map->next = 0;
+  uintptr_t tip;
+  ASSERT(!TAG(map));
   map->size = 0;
   map->addr = MAP_FAILED;
-  ASSERT(dll_is_alone(&map->elem));
-  dll_make_last(&__maps.free, &map->elem);
+  map->hand = kNtInvalidHandleValue;
+  for (tip = atomic_load_explicit(&__maps.freed, memory_order_relaxed);;) {
+    map->freed = (struct Map *)PTR(tip);
+    if (atomic_compare_exchange_weak_explicit(
+            &__maps.freed, &tip, ABA(map, TAG(tip) + 1), memory_order_release,
+            memory_order_relaxed))
+      break;
+  }
+}
+
+static void __maps_free_all(struct Map *list) {
+  struct Map *next;
+  for (struct Map *map = list; map; map = next) {
+    next = map->freed;
+    __maps_free(map);
+  }
+}
+
+static void __maps_insert_all(struct Map *list) {
+  struct Map *next;
+  for (struct Map *map = list; map; map = next) {
+    next = map->freed;
+    __maps_insert(map);
+  }
+}
+
+static int __maps_destroy_all(struct Map *list) {
+  int rc = 0;
+  for (struct Map *map = list; map; map = map->freed) {
+    if (!IsWindows()) {
+      if (sys_munmap(map->addr, map->size))
+        rc = -1;
+    } else {
+      switch (map->hand) {
+        case MAPS_SUBREGION:
+        case MAPS_RESERVATION:
+          break;
+        case MAPS_VIRTUAL:
+          if (!VirtualFree(map->addr, 0, kNtMemRelease))
+            rc = __winerr();
+          break;
+        default:
+          ASSERT(map->hand > 0);
+          if (!UnmapViewOfFile(map->addr))
+            rc = -1;
+          if (!CloseHandle(map->hand))
+            rc = -1;
+          break;
+      }
+    }
+  }
+  return rc;
+}
+
+static int __maps_funge_flags(int flags) {
+  flags &= ~MAP_FIXED;
+  flags &= ~MAP_FIXED_NOREPLACE;
+  if ((flags & MAP_TYPE) == MAP_SHARED_VALIDATE) {
+    flags &= ~MAP_TYPE;
+    flags |= MAP_SHARED;
+  }
+  return flags;
+}
+
+static bool __maps_fungible(const struct Map *map) {
+  // anonymous memory is fungible on unix, so we may coalesce such
+  // mappings in the rbtree to have fewer objects. on windows even
+  // anonymous memory has unique win32 handles we need to preserve
+  return !IsWindows() && (map->flags & MAP_ANONYMOUS);
+}
+
+static bool __maps_adjacent(const struct Map *x, const struct Map *y) {
+  char *a = x->addr + PGUP(x->size);
+  char *b = y->addr;
+  ASSERT(a <= b);
+  return a == b;
+}
+
+static bool __maps_mergeable(const struct Map *x, const struct Map *y) {
+  if (!__maps_adjacent(x, y))
+    return false;
+  if (!__maps_fungible(x))
+    return false;
+  if (!__maps_fungible(y))
+    return false;
+  if (x->prot != y->prot)
+    return false;
+  if (__maps_funge_flags(x->flags) != __maps_funge_flags(y->flags))
+    return false;
+  return true;
 }
 
 void __maps_insert(struct Map *map) {
-  struct Map *last = __maps.maps;
-  int granularity = getauxval(AT_PAGESZ);
-  __maps.pages += PGUP(map->size) / granularity;
-  if (last && !IsWindows() &&                  //
-      map->addr == last->addr + last->size &&  //
-      (map->flags & MAP_ANONYMOUS) &&          //
-      map->flags == last->flags &&             //
-      map->prot == last->prot) {
-    last->size += map->size;
-    dll_remove(&__maps.used, &last->elem);
-    dll_make_first(&__maps.used, &last->elem);
-    __maps_free(map);
-  } else if (last && !IsWindows() &&                 //
-             map->addr + map->size == last->addr &&  //
-             (map->flags & MAP_ANONYMOUS) &&         //
-             map->flags == last->flags &&            //
-             map->prot == last->prot) {
-    last->addr -= map->size;
-    last->size += map->size;
-    dll_remove(&__maps.used, &last->elem);
-    dll_make_first(&__maps.used, &last->elem);
-    __maps_free(map);
+  struct Map *left, *right;
+  ASSERT(map->size);
+  ASSERT(__maps_held());
+  ASSERT(!__maps_overlaps(map->addr, map->size));
+  __maps.pages += (map->size + __pagesize - 1) / __pagesize;
+
+  // find adjacent mappings
+  if ((left = __maps_floor(map->addr))) {
+    right = __maps_next(left);
   } else {
-    dll_make_first(&__maps.used, &map->elem);
-    map->next = __maps.maps;
-    __maps.maps = map;
-    ++__maps.count;
+    right = __maps_first();
   }
+
+  // avoid insert by making mapping on left bigger
+  if (left)
+    if (__maps_mergeable(left, map)) {
+      left->size = PGUP(left->size);
+      left->size += map->size;
+      __maps_free(map);
+      map = 0;
+    }
+
+  // avoid insert by making mapping on right bigger
+  if (map && right)
+    if (__maps_mergeable(map, right)) {
+      map->size = PGUP(map->size);
+      right->addr -= map->size;
+      right->size += map->size;
+      __maps_free(map);
+      map = 0;
+    }
+
+  // check if we filled a hole
+  if (!map && left && right)
+    if (__maps_mergeable(left, right)) {
+      left->size = PGUP(left->size);
+      left->size += right->size;
+      tree_remove(&__maps.maps, &right->tree);
+      __maps_free(right);
+      __maps.count -= 1;
+    }
+
+  // otherwise just insert
+  if (map)
+    __maps_add(map);
+
+  // sanity check
   __maps_check();
 }
 
-struct Map *__maps_alloc(void) {
-  struct Dll *e;
+// adds interval to rbtree
+bool __maps_track(char *addr, size_t size, int prot, int flags) {
   struct Map *map;
-  if ((e = dll_first(__maps.free))) {
-    dll_remove(&__maps.free, e);
-    map = MAP_CONTAINER(e);
-    map->next = 0;
-    return map;
+  if (!(map = __maps_alloc()))
+    return false;
+  map->addr = addr;
+  map->size = size;
+  map->prot = prot;
+  map->flags = flags;
+  map->hand = MAPS_VIRTUAL;
+  __maps_lock();
+  __maps_insert(map);
+  __maps_unlock();
+  return true;
+}
+
+// removes interval from rbtree (no sys_munmap)
+int __maps_untrack(char *addr, size_t size) {
+  struct Map *deleted = 0;
+  __maps_lock();
+  int rc = __muntrack(addr, size, &deleted, 0, 0);
+  __maps_unlock();
+  __maps_free_all(deleted);
+  return rc;
+}
+
+textwindows dontinline static struct DirectMap sys_mmap_nt(
+    void *addr, size_t size, int prot, int flags, int fd, int64_t off) {
+  struct DirectMap dm;
+
+  // it's 5x faster
+  if ((flags & MAP_ANONYMOUS) && (flags & MAP_TYPE) != MAP_SHARED) {
+    if (!(dm.addr = VirtualAlloc(addr, size, kNtMemReserve | kNtMemCommit,
+                                 __prot2nt(prot, false)))) {
+      dm.addr = MAP_FAILED;
+    }
+    dm.hand = MAPS_VIRTUAL;
+    return dm;
   }
-  int granularity = __granularity();
-  struct DirectMap sys = sys_mmap(0, granularity, PROT_READ | PROT_WRITE,
-                                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+
+  int64_t file_handle;
+  if (flags & MAP_ANONYMOUS) {
+    file_handle = kNtInvalidHandleValue;
+  } else {
+    file_handle = g_fds.p[fd].handle;
+  }
+
+  // mark map handle as inheritable if fork might need it
+  const struct NtSecurityAttributes *mapsec;
+  if ((flags & MAP_TYPE) == MAP_SHARED) {
+    mapsec = &kNtIsInheritable;
+  } else {
+    mapsec = 0;
+  }
+
+  // nt will whine under many circumstances if we change the execute bit
+  // later using mprotect(). the workaround is to always request execute
+  // and then virtualprotect() it away until we actually need it. please
+  // note that open-nt.c always requests an kNtGenericExecute accessmask
+  int iscow = 0;
+  int page_flags;
+  int file_flags;
+  if (file_handle != -1) {
+    if ((flags & MAP_TYPE) != MAP_SHARED) {
+      // windows has cow pages but they can't propagate across fork()
+      // that means we only get copy-on-write for the root process :(
+      page_flags = kNtPageExecuteWritecopy;
+      file_flags = kNtFileMapCopy | kNtFileMapExecute;
+      iscow = 1;
+    } else {
+      if ((g_fds.p[fd].flags & O_ACCMODE) == O_RDONLY) {
+        page_flags = kNtPageExecuteRead;
+        file_flags = kNtFileMapRead | kNtFileMapExecute;
+      } else {
+        page_flags = kNtPageExecuteReadwrite;
+        file_flags = kNtFileMapWrite | kNtFileMapExecute;
+      }
+    }
+  } else {
+    page_flags = kNtPageExecuteReadwrite;
+    file_flags = kNtFileMapWrite | kNtFileMapExecute;
+  }
+
+  int e = errno;
+TryAgain:
+  if ((dm.hand = CreateFileMapping(file_handle, mapsec, page_flags,
+                                   (size + off) >> 32, (size + off), 0))) {
+    if ((dm.addr = MapViewOfFileEx(dm.hand, file_flags, off >> 32, off, size,
+                                   addr))) {
+      uint32_t oldprot;
+      if (VirtualProtect(dm.addr, size, __prot2nt(prot, iscow), &oldprot))
+        return dm;
+      UnmapViewOfFile(dm.addr);
+    }
+    CloseHandle(dm.hand);
+  } else if (!(prot & PROT_EXEC) &&               //
+             (file_flags & kNtFileMapExecute) &&  //
+             GetLastError() == kNtErrorAccessDenied) {
+    // your file needs to have been O_CREAT'd with exec `mode` bits in
+    // order to be mapped with executable permission. we always try to
+    // get execute permission if the kernel will give it to us because
+    // win32 would otherwise forbid mprotect() from elevating later on
+    file_flags &= ~kNtFileMapExecute;
+    switch (page_flags) {
+      case kNtPageExecuteWritecopy:
+        page_flags = kNtPageWritecopy;
+        break;
+      case kNtPageExecuteReadwrite:
+        page_flags = kNtPageReadwrite;
+        break;
+      case kNtPageExecuteRead:
+        page_flags = kNtPageReadonly;
+        break;
+      default:
+        __builtin_unreachable();
+    }
+    errno = e;
+    goto TryAgain;
+  }
+
+  dm.hand = kNtInvalidHandleValue;
+  dm.addr = (void *)(intptr_t)-1;
+  return dm;
+}
+
+static struct DirectMap sys_mmap(void *addr, size_t size, int prot, int flags,
+                                 int fd, int64_t off) {
+  struct DirectMap d;
+  if (IsXnuSilicon()) {
+    long p = _sysret(__syslib->__mmap(addr, size, prot, flags, fd, off));
+    d.hand = kNtInvalidHandleValue;
+    d.addr = (void *)p;
+  } else if (IsWindows()) {
+    d = sys_mmap_nt(addr, size, prot, flags, fd, off);
+  } else if (IsMetal()) {
+    d.addr = sys_mmap_metal(addr, size, prot, flags, fd, off);
+    d.hand = kNtInvalidHandleValue;
+  } else {
+    d.addr = __sys_mmap(addr, size, prot, flags, fd, off, off);
+    d.hand = kNtInvalidHandleValue;
+  }
+  return d;
+}
+
+struct Map *__maps_alloc(void) {
+  struct Map *map;
+  uintptr_t tip = atomic_load_explicit(&__maps.freed, memory_order_relaxed);
+  while ((map = (struct Map *)PTR(tip)))
+    if (atomic_compare_exchange_weak_explicit(
+            &__maps.freed, &tip, ABA(map->freed, TAG(tip) + 1),
+            memory_order_acquire, memory_order_relaxed))
+      return map;
+  // we're creating sudden surprise memory. the user might be in the
+  // middle of carefully planning a fixed memory structure. we don't
+  // want the system allocator to put our surprise memory inside it,
+  // and we also want to avoid the chances of accidentally unmapping
+  struct DirectMap sys =
+      sys_mmap(__maps_randaddr(), MAPS_SIZE, PROT_READ | PROT_WRITE,
+               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   if (sys.addr == MAP_FAILED)
     return 0;
-  if (IsWindows())
-    CloseHandle(sys.maphandle);
-  map = sys.addr;
-  map->addr = MAP_FAILED;
-  dll_init(&map->elem);
-  for (int i = 1; i < granularity / sizeof(struct Map); ++i) {
-    dll_init(&map[i].elem);
-    __maps_free(map + i);
+  struct MapSlab *slab = sys.addr;
+  while (!atomic_compare_exchange_weak(&__maps.slabs, &slab->next, slab)) {
   }
-  map->next = 0;
-  return map;
+  for (size_t i = 1; i < ARRAYLEN(slab->maps); ++i)
+    __maps_free(&slab->maps[i]);
+  return &slab->maps[0];
 }
 
-static int __munmap_chunk(void *addr, size_t size) {
-  return sys_munmap(addr, size);
-}
-
-static int __munmap(char *addr, size_t size, bool untrack_only) {
+static int __munmap(char *addr, size_t size) {
 
   // validate arguments
-  int pagesz = getauxval(AT_PAGESZ);
-  int granularity = __granularity();
-  if (((uintptr_t)addr & (granularity - 1)) ||  //
+  if (((uintptr_t)addr & (__gransize - 1)) ||  //
       !size || (uintptr_t)addr + size < size)
     return einval();
 
-  // untrack and delete mapping
-  int rc = 0;
+  // test for signal handler tragedy
+  if (__maps_reentrant())
+    return edeadlk();
+
+  // lock the memory manager
   __maps_lock();
-StartOver:;
-  struct Map *map = __maps.maps;
-  _Atomic(struct Map *) *prev = &__maps.maps;
-  while (map) {
-    char *map_addr = map->addr;
-    size_t map_size = map->size;
-    struct Map *next = map->next;
-    if (MAX(addr, map_addr) <
-        MIN(addr + PGUP(size), map_addr + PGUP(map_size))) {
-      if (addr <= map_addr && addr + PGUP(size) >= map_addr + PGUP(map_size)) {
-        // remove mapping completely
-        dll_remove(&__maps.used, &map->elem);
-        *prev = next;
-        __maps.pages -= (map_size + pagesz - 1) / pagesz;
-        __maps.count -= 1;
-        if (untrack_only) {
-          __maps_free(map);
-          __maps_check();
-        } else {
-          __maps_unlock();
-          if (!IsWindows()) {
-            ASSERT(addr <= map_addr);
-            ASSERT(map_addr + PGUP(map_size) <= addr + PGUP(size));
-            if (__munmap_chunk(map_addr, map_size))
-              rc = -1;
-          } else {
-            if (!UnmapViewOfFile(map_addr))
-              rc = -1;
-            if (!CloseHandle(map->h))
-              rc = -1;
-          }
-          __maps_lock();
-          __maps_free(map);
-          __maps_check();
-          goto StartOver;
-        }
-        map = next;
-        continue;
-      } else if (IsWindows()) {
-        // you can't carve up memory maps on windows. our mmap() makes
-        // this not a problem (for non-enormous memory maps) by making
-        // independent mappings for each 64 kb granule, under the hood
-        rc = einval();
-      } else if (addr <= map_addr) {
-        // shave off lefthand side of mapping
-        ASSERT(addr + size < map_addr + PGUP(map_size));
-        size_t left = PGUP(addr + size - map_addr);
-        size_t right = map_size - left;
-        ASSERT(right > 0);
-        ASSERT(left > 0);
-        map->addr += left;
-        map->size = right;
-        if (map->off != -1)
-          map->off += left;
-        __maps.pages -= (left + pagesz - 1) / pagesz;
-        __maps_check();
-        if (!untrack_only) {
-          __maps_unlock();
-          ASSERT(addr <= map_addr);
-          ASSERT(map_addr + PGUP(left) <= addr + PGUP(size));
-          if (__munmap_chunk(map_addr, left) == -1)
-            rc = -1;
-          __maps_lock();
-          goto StartOver;
-        }
-      } else if (addr + PGUP(size) >= map_addr + PGUP(map_size)) {
-        // shave off righthand side of mapping
-        size_t left = addr - map_addr;
-        size_t right = map_addr + map_size - addr;
-        map->size = left;
-        __maps.pages -= (right + pagesz - 1) / pagesz;
-        __maps_check();
-        if (!untrack_only) {
-          __maps_unlock();
-          ASSERT(PGUP(right) <= PGUP(size));
-          if (__munmap_chunk(addr, right) == -1)
-            rc = -1;
-          __maps_lock();
-          goto StartOver;
-        }
-      } else {
-        // punch hole in mapping
-        size_t left = addr - map_addr;
-        size_t middle = PGUP(size);
-        size_t right = map_size - middle - left;
-        struct Map *leftmap;
-        if ((leftmap = __maps_alloc())) {
-          leftmap->next = map;
-          leftmap->addr = map_addr;
-          leftmap->size = left;
-          leftmap->off = map->off;
-          leftmap->prot = map->prot;
-          leftmap->flags = map->flags;
-          map->addr += left + middle;
-          map->size = right;
-          if (map->off != -1)
-            map->off += left + middle;
-          dll_make_first(&__maps.used, &leftmap->elem);
-          *prev = leftmap;
-          __maps.pages -= (middle + pagesz - 1) / pagesz;
-          __maps.count += 1;
-          __maps_check();
-          if (!untrack_only) {
-            __maps_unlock();
-            if (__munmap_chunk(addr, size) == -1)
-              rc = -1;
-            __maps_lock();
-            goto StartOver;
-          }
-        } else {
-          rc = -1;
-        }
-      }
+  __maps_check();
+
+  // on windows we can only unmap whole allocations
+  if (IsWindows())
+    if (!__maps_envelops(addr, size)) {
+      __maps_unlock();
+      return enotsup();
     }
-    prev = &map->next;
-    map = next;
-  }
+
+  // untrack mappings
+  int rc;
+  struct Map temp[2];
+  struct Map *deleted = 0;
+  struct Map *untracked = 0;
+  rc = __muntrack(addr, size, &deleted, &untracked, temp);
   __maps_unlock();
 
+  // ask operating system to remove mappings
+  rc |= __maps_destroy_all(untracked);
+  rc |= __maps_destroy_all(deleted);
+  __maps_free_all(deleted);
+
   return rc;
 }
 
-static void *__mmap_chunk(void *addr, size_t size, int prot, int flags, int fd,
-                          int64_t off, int granularity) {
-
-  // polyfill nuances of fixed mappings
-  int sysflags = flags;
-  bool noreplace = false;
-  bool should_untrack = false;
-  if (flags & MAP_FIXED_NOREPLACE) {
-    if (flags & MAP_FIXED)
-      return (void *)einval();
-    sysflags &= ~MAP_FIXED_NOREPLACE;
-    if (IsLinux()) {
-      noreplace = true;
-      sysflags |= MAP_FIXED_NOREPLACE_linux;
-    } else if (IsFreebsd() || IsNetbsd()) {
-      sysflags |= MAP_FIXED;
-      if (overlaps_existing_map(addr, size))
-        return (void *)eexist();
-    } else {
-      noreplace = true;
-    }
-  } else if (flags & MAP_FIXED) {
-    should_untrack = true;
-  }
-
-  // allocate Map object
-  struct Map *map;
+void *__maps_randaddr(void) {
+  uintptr_t addr;
   __maps_lock();
-  map = __maps_alloc();
+  addr = (__maps.rand *= 15750249268501108917ull) >> 64;
   __maps_unlock();
-  if (!map)
-    return MAP_FAILED;
+  addr &= 0x3fffffffffff;
+  addr |= 0x004000000000;
+  addr &= -__gransize;
+  return (void *)addr;
+}
 
-  // obtain mapping from operating system
-  int olderr = errno;
-  struct DirectMap res;
-TryAgain:
-  res = sys_mmap(addr, size, prot, sysflags, fd, off);
-  if (res.addr == MAP_FAILED) {
-    if (IsWindows() && errno == EADDRNOTAVAIL) {
-      if (noreplace) {
-        errno = EEXIST;
-      } else if (should_untrack) {
-        sys_munmap(res.addr, size);
-        errno = olderr;
-        goto TryAgain;
-      } else {
-        addr += granularity;
-        errno = olderr;
-        goto TryAgain;
+static void *__maps_pickaddr(size_t size) {
+  ASSERT(__maps_held());
+  char *addr = 0;
+  struct Map *map, *prev;
+  size = GRUP(size);
+  if ((map = __maps_last())) {
+    // choose address beneath higher mapping
+    for (; map; map = prev) {
+      char *min = (char *)(intptr_t)__gransize;
+      if ((prev = __maps_prev(map)))
+        min = prev->addr + GRUP(prev->size);
+      if (map->addr > min &&  //
+          map->addr - min >= size) {
+        addr = map->addr - size;
+        break;
       }
     }
-    __maps_lock();
-    __maps_free(map);
-    __maps_unlock();
-    return MAP_FAILED;
+    // append if existing maps are too dense
+    if (!addr) {
+      map = __maps_last();
+      addr = map->addr + GRUP(map->size);
+      intptr_t end = (intptr_t)addr;
+      if (ckd_add(&end, end, size))
+        return 0;
+    }
+  } else {
+    // roll the dice if rbtree is empty
+    addr = __maps_randaddr();
   }
-
-  // polyfill map fixed noreplace
-  // we assume non-linux gives us addr if it's free
-  // that's what linux (e.g. rhel7) did before noreplace
-  if (noreplace && res.addr != addr) {
-    sys_munmap(res.addr, size);
-    __maps_lock();
-    __maps_free(map);
-    __maps_unlock();
-    return (void *)eexist();
-  }
-
-  // untrack mapping we blew away
-  if (should_untrack)
-    __munmap(res.addr, size, true);
-
-  // track Map object
-  map->addr = res.addr;
-  map->size = size;
-  map->off = off;
-  map->prot = prot;
-  map->flags = flags;
-  map->h = res.maphandle;
-  if (IsWindows()) {
-    map->iscow = (flags & MAP_TYPE) != MAP_SHARED && fd != -1;
-    map->readonlyfile = (flags & MAP_TYPE) == MAP_SHARED && fd != -1 &&
-                        (g_fds.p[fd].flags & O_ACCMODE) == O_RDONLY;
-  }
-  __maps_lock();
-  __maps_insert(map);
-  __maps_unlock();
-
-  return res.addr;
+  return addr;
 }
 
 static void *__mmap_impl(char *addr, size_t size, int prot, int flags, int fd,
-                         int64_t off, int granularity) {
+                         int64_t off) {
 
   // validate file map args
-  if (fd != -1) {
-    if (off & (granularity - 1))
+  if (flags & MAP_ANONYMOUS) {
+    // some operating systems will complain unless we do this
+    fd = -1;
+    off = 0;
+  } else {
+    // validate arguments for file mapping
+    if (off & (__gransize - 1))
       return (void *)einval();
     if (IsWindows()) {
       if (!__isfdkind(fd, kFdFile))
@@ -413,68 +700,195 @@ static void *__mmap_impl(char *addr, size_t size, int prot, int flags, int fd,
     }
   }
 
-  // mmap works fine on unix
-  if (!IsWindows())
-    return __mmap_chunk(addr, size, prot, flags, fd, off, granularity);
+  // allocate Map object
+  struct Map *map;
+  if (!(map = __maps_alloc()))
+    return MAP_FAILED;
 
-  // if the concept of granularity wasn't exciting enough
-  if (!addr && !(flags & (MAP_FIXED | MAP_FIXED_NOREPLACE)))
-    addr = (char *)(WINBASE + atomic_fetch_add(&rollo, PGUP(size)) % WINMAXX);
-
-  // windows forbids unmapping a subset of a map once it's made
-  if (size <= granularity || size > 100 * 1024 * 1024)
-    return __mmap_chunk(addr, size, prot, flags, fd, off, granularity);
-
-  // so we create an separate map for each granule in the mapping
-  if (!(flags & MAP_FIXED)) {
-    while (overlaps_existing_map(addr, size)) {
-      if (flags & MAP_FIXED_NOREPLACE)
+  // polyfill nuances of fixed mappings
+  int sysflags = flags;
+  bool noreplace = false;
+  bool fixedmode = false;
+  if (flags & MAP_FIXED_NOREPLACE) {
+    if (flags & MAP_FIXED) {
+      __maps_free(map);
+      return (void *)einval();
+    }
+    sysflags &= ~MAP_FIXED_NOREPLACE;
+    if (IsLinux()) {
+      noreplace = true;
+      sysflags |= MAP_FIXED_NOREPLACE_linux;
+    } else if (IsFreebsd() || IsNetbsd()) {
+      // todo: insert a reservation like windows
+      sysflags |= MAP_FIXED;
+      __maps_lock();
+      if (__maps_overlaps(addr, size)) {
+        __maps_unlock();
+        __maps_free(map);
         return (void *)eexist();
-      addr += granularity;
+      }
+      __maps_unlock();
+    } else {
+      noreplace = true;
     }
+  } else if (flags & MAP_FIXED) {
+    fixedmode = true;
   }
-  char *res = addr;
-  while (size) {
-    char *got;
-    size_t amt = MIN(size, granularity);
-    got = __mmap_chunk(addr, amt, prot, flags, fd, off, granularity);
-    if (got != addr) {
-      if (got != MAP_FAILED)
-        __munmap(got, amt, false);
-      if (addr > res)
-        __munmap(res, addr - res, false);
-      errno = EAGAIN;
-      return MAP_FAILED;
+
+  // loop for memory
+  int olderr = errno;
+  struct DirectMap res;
+  for (;;) {
+
+    // transactionally find the mark on windows
+    if (IsWindows()) {
+      __maps_lock();
+      if (!fixedmode) {
+        // give user desired address if possible
+        if (addr && __maps_overlaps(addr, size)) {
+          if (noreplace) {
+            __maps_unlock();
+            __maps_free(map);
+            return (void *)eexist();
+          }
+          addr = 0;
+        }
+        // choose suitable address then claim it in our rbtree
+        if (!addr && !(addr = __maps_pickaddr(size))) {
+          __maps_unlock();
+          __maps_free(map);
+          return (void *)enomem();
+        }
+      } else {
+        // remove existing mappings and their tracking objects
+        if (!__maps_envelops(addr, size)) {
+          __maps_unlock();
+          __maps_free(map);
+          return (void *)enotsup();
+        }
+        struct Map *deleted = 0;
+        if (__muntrack(addr, size, &deleted, 0, 0)) {
+          __maps_insert_all(deleted);
+          __maps_unlock();
+          __maps_free(map);
+          return MAP_FAILED;
+        }
+        int rc = __maps_destroy_all(deleted);
+        __maps_free_all(deleted);
+        if (rc) {
+          __maps_unlock();
+          __maps_free(map);
+          return (void *)eperm();
+        }
+      }
+      // claims intended interval while still holding the lock
+      map->addr = addr;
+      map->size = size;
+      map->prot = 0;
+      map->flags = 0;
+      map->hand = MAPS_RESERVATION;
+      __maps_insert(map);
+      __maps_unlock();
     }
-    size -= amt;
-    addr += amt;
-    off += amt;
+
+    // ask operating system for our memory
+    // notice how we're not holding the lock
+    res = sys_mmap(addr, size, prot, sysflags, fd, off);
+    if (res.addr != MAP_FAILED)
+      break;
+
+    // handle failure
+    if (IsWindows()) {
+      // untrack reservation
+      __maps_lock();
+      tree_remove(&__maps.maps, &map->tree);
+      __maps.pages -= (map->size + __pagesize - 1) / __pagesize;
+      __maps_unlock();
+      if (errno == EADDRNOTAVAIL) {
+        // we've encountered mystery memory
+        if (fixedmode) {
+          // TODO(jart): Use VirtualQuery() to destroy mystery memory.
+          errno = ENOMEM;
+        } else if (noreplace) {
+          // we can't try again with a different address in this case
+          errno = EEXIST;
+        } else {
+          // we shall leak the tracking object since it should at least
+          // partially cover the mystery mapping. so if we loop forever
+          // the system should eventually recover and find fresh spaces
+          errno = olderr;
+          addr = 0;
+          continue;
+        }
+      }
+    }
+    __maps_free(map);
+    return MAP_FAILED;
   }
-  return res;
+
+  // polyfill map fixed noreplace
+  if (noreplace && res.addr != addr) {
+    ASSERT(!IsWindows());
+    sys_munmap(res.addr, size);
+    __maps_free(map);
+    return (void *)eexist();
+  }
+
+  // setup map object
+  map->addr = res.addr;
+  map->size = size;
+  map->off = off;
+  map->prot = prot;
+  map->flags = flags;
+  map->hand = res.hand;
+  if (IsWindows()) {
+    map->iscow = (flags & MAP_TYPE) != MAP_SHARED && fd != -1;
+    map->readonlyfile = (flags & MAP_TYPE) == MAP_SHARED && fd != -1 &&
+                        (g_fds.p[fd].flags & O_ACCMODE) == O_RDONLY;
+  }
+
+  // track map object
+  if (!IsWindows()) {
+    struct Map *deleted = 0;
+    __maps_lock();
+    if (fixedmode)
+      if (__muntrack(res.addr, size, &deleted, 0, 0))
+        STRACE("memtrack compromised by hole punch oom");
+    __maps_insert(map);
+    __maps_unlock();
+    __maps_free_all(deleted);
+  } else {
+    atomic_thread_fence(memory_order_release);
+  }
+
+  return res.addr;
 }
 
-void *__mmap(char *addr, size_t size, int prot, int flags, int fd,
-             int64_t off) {
+static void *__mmap(char *addr, size_t size, int prot, int flags, int fd,
+                    int64_t off) {
   char *res;
-  int granularity = __granularity();
 
   // validate arguments
-  if (((uintptr_t)addr & (granularity - 1)) ||  //
-      !size || (uintptr_t)addr + size < size)
+  if ((uintptr_t)addr & (__gransize - 1))
+    addr = NULL;
+  if (!addr && (flags & (MAP_FIXED | MAP_FIXED_NOREPLACE)))
+    return (void *)eperm();
+  if ((intptr_t)addr < 0)
+    return (void *)enomem();
+  if (!size || (uintptr_t)addr + size < size)
     return (void *)einval();
-  if (size > 0x100000000000)
+  if (size > MAX_SIZE)
+    return (void *)enomem();
+  if (__maps.count * __pagesize + size > __virtualmax)
     return (void *)enomem();
 
-  // normalize arguments
-  if (flags & MAP_ANONYMOUS) {
-    fd = -1;
-    off = 0;
-    size = PGUP(size);
-  }
+  // test for signal handler reentry
+  if (__maps_reentrant())
+    return (void *)edeadlk();
 
   // create memory mappping
   if (!__isfdkind(fd, kFdZip)) {
-    res = __mmap_impl(addr, size, prot, flags, fd, off, granularity);
+    res = __mmap_impl(addr, size, prot, flags, fd, off);
   } else {
     res = _weaken(__zipos_mmap)(
         addr, size, prot, flags,
@@ -484,18 +898,293 @@ void *__mmap(char *addr, size_t size, int prot, int flags, int fd,
   return res;
 }
 
-void *mmap(void *addr, size_t size, int prot, int flags, int fd, int64_t off) {
-  void *res;
-  res = __mmap(addr, size, prot, flags, fd, off);
-  STRACE("mmap(%p, %'zu, %s, %s, %d, %'ld) → %p% m", addr, size,
-         DescribeProtFlags(prot), DescribeMapFlags(flags), fd, off, res);
+static void *__mremap_impl(char *old_addr, size_t old_size, size_t new_size,
+                           int flags, char *new_addr) {
+
+  // allocate object for tracking new mapping
+  struct Map *map;
+  if (!(map = __maps_alloc()))
+    return (void *)enomem();
+
+  // check old interval is fully contained within one mapping
+  struct Map *old_map;
+  if (!(old_map = __maps_floor(old_addr)) ||
+      old_addr + PGUP(old_size) > old_map->addr + PGUP(old_map->size) ||
+      old_addr < old_map->addr) {
+    __maps_free(map);
+    return (void *)efault();
+  }
+
+  // save old properties
+  int old_off = old_map->off;
+  int old_prot = old_map->prot;
+  int old_flags = old_map->flags;
+
+  // netbsd mremap fixed returns enoent rather than unmapping old pages
+  if (IsNetbsd() && (flags & MREMAP_FIXED))
+    if (__munmap(new_addr, new_size)) {
+      __maps_free(map);
+      return MAP_FAILED;
+    }
+
+  // release lock before system call if possible
+  if (!flags)
+    __maps_unlock();
+
+  // the time has come
+  char *res;
+  if (IsNetbsd()) {
+    int sysfl = (flags & MREMAP_FIXED) ? MAP_FIXED : 0;
+    res = sys_mremap(old_addr, old_size, (uintptr_t)new_addr, new_size, sysfl);
+  } else {
+    res = sys_mremap(old_addr, old_size, new_size, flags, (uintptr_t)new_addr);
+  }
+  if (res == MAP_FAILED)
+    __maps_free(map);
+
+  // re-acquire lock if needed
+  if (!flags)
+    __maps_lock();
+
+  if (res == MAP_FAILED)
+    return MAP_FAILED;
+
+  if (!(flags & MREMAP_MAYMOVE))
+    ASSERT(res == old_addr);
+
+  // untrack old mapping
+  struct Map *deleted = 0;
+  __muntrack(old_addr, old_size, &deleted, 0, 0);
+  __maps_free_all(deleted);
+
+  // track map object
+  map->addr = res;
+  map->size = new_size;
+  map->off = old_off;
+  map->prot = old_prot;
+  map->flags = old_flags;
+  map->hand = kNtInvalidHandleValue;
+  __maps_insert(map);
+
   return res;
 }
 
+static void *__mremap(char *old_addr, size_t old_size, size_t new_size,
+                      int flags, char *new_addr) {
+
+  // kernel support
+  if (!IsLinux() && !IsNetbsd())
+    return (void *)enosys();
+
+  // it is not needed
+  if (new_size <= old_size)
+    if (!(flags & MREMAP_FIXED))
+      if (flags & MREMAP_MAYMOVE)
+        flags &= ~MREMAP_MAYMOVE;
+
+  // we support these flags
+  if (flags & ~(MREMAP_MAYMOVE | MREMAP_FIXED))
+    return (void *)einval();
+  if (IsNetbsd() && !(flags & MREMAP_MAYMOVE) && PGUP(new_size) > old_size)
+    return (void *)enotsup();
+  if ((flags & MREMAP_FIXED) && !(flags & MREMAP_MAYMOVE))
+    return (void *)einval();
+
+  // addresses must be granularity aligned
+  if ((uintptr_t)old_addr & (__gransize - 1))
+    return (void *)einval();
+  if (flags & MREMAP_FIXED)
+    if ((uintptr_t)new_addr & (__gransize - 1))
+      return (void *)einval();
+
+  // sizes must not be zero
+  if (!old_size)
+    return (void *)einval();
+  if (!new_size)
+    return (void *)einval();
+
+  // check for big size
+  if (old_size > MAX_SIZE)
+    return (void *)enomem();
+  if (new_size > MAX_SIZE)
+    return (void *)enomem();
+
+  // check for overflow
+  if ((uintptr_t)old_addr + old_size < old_size)
+    return (void *)enomem();
+  if (flags & MREMAP_FIXED)
+    if ((uintptr_t)new_addr + new_size < new_size)
+      return (void *)enomem();
+
+  // old and new intervals must not overlap
+  if (flags & MREMAP_FIXED)
+    if (MAX(old_addr, new_addr) <
+        MIN(old_addr + old_size, new_addr + PGUP(new_size)))
+      return (void *)einval();
+
+  // memory increase must not exceed RLIMIT_AS
+  if (PGUP(new_size) > old_size)
+    if (__maps.count * __pagesize - old_size + PGUP(new_size) > __virtualmax)
+      return (void *)enomem();
+
+  // test for signal handler reentry
+  if (__maps_reentrant())
+    return (void *)edeadlk();
+
+  // lock the memory manager
+  __maps_lock();
+  __maps_check();
+
+  // perform operation
+  char *res = __mremap_impl(old_addr, old_size, new_size, flags, new_addr);
+
+  // return result
+  __maps_unlock();
+  return res;
+}
+
+/**
+ * Creates memory mapping.
+ *
+ * The mmap() function is used by Cosmopolitan's malloc() implementation
+ * to obtain new memory from the operating system. This function is also
+ * useful for establishing a mapping between a file on disk and a memory
+ * address, which avoids most need to call read() and write(). It is how
+ * executables are loaded into memory, for instance, in which case pages
+ * are loaded lazily from disk by the operating system.
+ *
+ * The `addr` parameter may be zero. This lets the implementation choose
+ * an available address in memory. OSes normally pick something randomly
+ * assigned, for security. Most OSes try to make sure subsequent mapping
+ * requests will be adjacent to one another. More paranoid OSes may have
+ * different mappings be sparse, with unmapped content between them. You
+ * may not use the `MAP_FIXED` parameter to create a memory map at NULL.
+ *
+ * The `addr` parameter may be non-zero, in which case Cosmopolitan will
+ * give you a mapping at that specific address if it's available. When a
+ * mapping already exists at the requested address then another one will
+ * be chosen automatically. On most OSes the newly selected address will
+ * be as close-by as possible, but that's not guaranteed. If `MAP_FIXED`
+ * is also supplied in `flags` then this hint is taken as mandatory, and
+ * existing mappings at the requested interval shall be auto-unmapped.
+ *
+ * The `size` parameter is implicitly rounded up to the system page size
+ * reported by getpagesize() and sysconf(_SC_PAGESIZE). Your extra bytes
+ * will be zero-initialized.
+ *
+ * The returned address will always be aligned, on the system allocation
+ * granularity. This value may be obtained from getgransize() or calling
+ * sysconf(_SC_GRANSIZE). Granularity is always greater than or equal to
+ * the page size. On some platforms, i.e. Windows, it may be larger than
+ * the page size.
+ *
+ * The `prot` value specifies the memory protection of the mapping. This
+ * may be `PROT_NONE` to disallow all access otherwise it's a bitwise or
+ * of the following constants:
+ *
+ * - `PROT_READ` allows read access
+ * - `PROT_WRITE` allows write access
+ * - `PROT_EXEC` allows execute access
+ *
+ * Some OSes (i.e. OpenBSD) will raise an error if both `PROT_WRITE` and
+ * `PROT_EXEC` are requested. You may still modify executable memory but
+ * you must use mprotect() to transition between the two states. On some
+ * OSes like MacOS ARM64, you need to pass the `MAP_JIT` flag to get RWX
+ * memory, which is considered zero on other OSes.
+ *
+ * The lower bits of the `flags` parameter specify the `MAP_TYPE`, which
+ * may be:
+ *
+ * - `MAP_PRIVATE` for non-shared and copy-on-write mappings
+ * - `MAP_SHARED` for memory that may be shared between processes
+ *
+ * Your `fd` argument specifies the file descriptor of the open file you
+ * want to map. This parameter is ignored when `MAP_ANONYMOUS` is passed
+ * via `flags`.
+ *
+ * Your `off` argument specifies the offset into a, file at which mapped
+ * memory shall begin. It must be aligned to the allocation granularity,
+ * which may be obtained from getgransize() or sysconf(_SC_GRANSIZE).
+ *
+ * The `MAP_FIXED_NOREPLACE` flag may be passed in `flags` which has the
+ * same behavior as `MAP_FIXED` except it raises `EEXIST` when a mapping
+ * already exists on the requested interval.
+ *
+ * The `MAP_CONCEAL` flag may be passed to prevent a memory mapping from
+ * appearing in core dumps. This is currently supported on BSD OSes, and
+ * is ignored on everything else.
+ *
+ * POSIX does not require mmap() to be asynchronous signal safe. But you
+ * should be able to call this from a signal handler safely, if you know
+ * that your signal will never interrupt the cosmopolitan memory manager
+ * and the only way you can ensure that, is by blocking signals whenever
+ * you call mmap(), munmap(), mprotect(), etc.
+ *
+ * @raise ENOMEM if `RUSAGE_AS` or similar limits are exceeded
+ * @raise EEXIST if `flags` has `MAP_FIXED_NOREPLACE` and `addr` is used
+ * @raise ENOTSUP if interval overlapped without enveloping win32 alloc
+ * @raise EPERM if `addr` is null and `flags` has `MAP_FIXED`
+ * @raise EINVAL if `addr` isn't granularity aligned with `MAP_FIXED`
+ * @raise EINVAL if `size` is zero
+ * @raise EINVAL if `flags` or `prot` hold invalid values
+ * @raise EACCESS if `fd` isn't a regular file
+ * @raise EACCESS if `fd` was opened in write-only mode
+ * @raise EACCESS if `off` isn't getgransize() aligned
+ * @raise EDEADLK if called from signal handler interrupting mmap()
+ */
+void *mmap(void *addr, size_t size, int prot, int flags, int fd, int64_t off) {
+  void *res = __mmap(addr, size, prot, flags, fd, off);
+  STRACE("mmap(%p, %'zu, %s, %s, %d, %'ld) → %p% m (%'zu bytes total)", addr,
+         size, DescribeProtFlags(prot), DescribeMapFlags(flags), fd, off, res,
+         __maps.pages * __pagesize);
+  return res;
+}
+
+/**
+ * Changes memory mapping.
+ *
+ * This system call lets you move memory without copying it. It can also
+ * be used to shrink memory mappings.
+ *
+ * This system call is supported on Linux and NetBSD. It's used by Cosmo
+ * Libc's realloc() implementation under the hood.
+ *
+ * The `flags` parameter may have:
+ *
+ * - `MREMAP_MAYMOVE` to allow relocation
+ * - `MREMAP_FIXED` in which case an additional parameter is taken
+ *
+ */
+void *mremap(void *old_addr, size_t old_size, size_t new_size, int flags, ...) {
+  va_list ap;
+  void *new_addr = 0;
+  if (flags & MREMAP_FIXED) {
+    va_start(ap, flags);
+    new_addr = va_arg(ap, void *);
+    va_end(ap);
+  }
+  void *res = __mremap(old_addr, old_size, new_size, flags, new_addr);
+  STRACE("mremap(%p, %'zu, %'zu, %s, %p) → %p% m (%'zu bytes total)", old_addr,
+         old_size, new_size, DescribeMremapFlags(flags), new_addr, res,
+         __maps.pages * __pagesize);
+  return res;
+}
+
+/**
+ * Removes memory mapping.
+ *
+ * The `size` parameter is implicitly rounded up to the page size.
+ *
+ * @return 0 on success, or -1 w/ errno.
+ * @raise ENOMEM if OOM happened when punching hole in existing mapping
+ * @raise ENOTSUP if interval overlapped without enveloping win32 alloc
+ * @raise EDEADLK if called from signal handler interrupting mmap()
+ * @raise EINVAL if `addr` isn't granularity aligned
+ */
 int munmap(void *addr, size_t size) {
-  int rc;
-  rc = __munmap(addr, size, false);
-  STRACE("munmap(%p, %'zu) → %d% m", addr, size, rc);
+  int rc = __munmap(addr, size);
+  STRACE("munmap(%p, %'zu) → %d% m (%'zu bytes total)", addr, size, rc,
+         __maps.pages * __pagesize);
   return rc;
 }
 
diff --git a/libc/intrin/movefileex.c b/libc/intrin/movefileex.c
index 66e32fe02..bd7496db2 100644
--- a/libc/intrin/movefileex.c
+++ b/libc/intrin/movefileex.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/thunk/msabi.h"
diff --git a/libc/intrin/mprotect.c b/libc/intrin/mprotect.c
index b1af88552..393bc641c 100644
--- a/libc/intrin/mprotect.c
+++ b/libc/intrin/mprotect.c
@@ -19,17 +19,18 @@
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/directmap.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/kprintf.h"
 #include "libc/intrin/maps.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/intrin/tree.h"
 #include "libc/nt/memory.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/sysparam.h"
 #include "libc/sysv/consts/auxv.h"
+#include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/errfuns.h"
 
@@ -50,7 +51,7 @@ static int __mprotect_chunk(char *addr, size_t size, int prot, bool iscow) {
 int __mprotect(char *addr, size_t size, int prot) {
 
   // unix checks prot before checking size
-  if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
+  if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC | PROT_GUARD))
     return einval();
 
   // make new technology consistent with unix
@@ -58,141 +59,146 @@ int __mprotect(char *addr, size_t size, int prot) {
     return 0;
 
   // unix checks prot before checking size
-  int pagesz = getauxval(AT_PAGESZ);
-  if ((intptr_t)addr & (pagesz - 1))
+  int pagesz = __pagesize;
+  if (((intptr_t)addr & (pagesz - 1)) || (uintptr_t)addr + size < size)
     return einval();
 
+  // normalize size
+  size = (size + pagesz - 1) & -pagesz;
+
+  // test for signal handler reentry
+  if (__maps_reentrant())
+    return edeadlk();
+
   // change mappings
   int rc = 0;
-  __maps_lock();
   bool found = false;
-  struct Map *map = __maps.maps;
-  _Atomic(struct Map *) *prev = &__maps.maps;
-  while (map) {
+  __maps_lock();
+  struct Map *map;
+  if (!(map = __maps_floor(addr)))
+    map = __maps_first();
+  for (; map && map->addr <= addr + size; map = __maps_next(map)) {
     char *map_addr = map->addr;
     size_t map_size = map->size;
-    struct Map *next = map->next;
     char *beg = MAX(addr, map_addr);
-    char *end = MIN(addr + PGUP(size), map_addr + PGUP(map_size));
-    if (beg < end) {
-      found = true;
-      if (addr <= map_addr && addr + PGUP(size) >= map_addr + PGUP(map_size)) {
-        // change protection of entire mapping
-        if (!__mprotect_chunk(map_addr, map_size, prot, map->iscow)) {
+    char *end = MIN(addr + size, map_addr + PGUP(map_size));
+    if (beg >= end)
+      continue;
+    found = true;
+    if (addr <= map_addr && addr + size >= map_addr + PGUP(map_size)) {
+      // change protection status of pages
+      if (!__mprotect_chunk(map_addr, map_size, prot, map->iscow)) {
+        map->prot = prot;
+      } else {
+        rc = -1;
+      }
+    } else if (addr <= map_addr) {
+      // change lefthand side of mapping
+      size_t left = addr + size - map_addr;
+      size_t right = map_size - left;
+      struct Map *leftmap;
+      if ((leftmap = __maps_alloc())) {
+        if (!__mprotect_chunk(map_addr, left, prot, false)) {
+          leftmap->addr = map_addr;
+          leftmap->size = left;
+          leftmap->prot = prot;
+          leftmap->off = map->off;
+          leftmap->flags = map->flags;
+          leftmap->iscow = map->iscow;
+          leftmap->readonlyfile = map->readonlyfile;
+          leftmap->hand = map->hand;
+          map->addr += left;
+          map->size = right;
+          map->hand = MAPS_SUBREGION;
+          if (!(map->flags & MAP_ANONYMOUS))
+            map->off += left;
+          tree_insert(&__maps.maps, &leftmap->tree, __maps_compare);
+          __maps.count += 1;
+          __maps_check();
+        } else {
+          __maps_free(leftmap);
+          rc = -1;
+        }
+      } else {
+        rc = -1;
+      }
+    } else if (addr + size >= map_addr + PGUP(map_size)) {
+      // change righthand side of mapping
+      size_t left = addr - map_addr;
+      size_t right = map_addr + map_size - addr;
+      struct Map *leftmap;
+      if ((leftmap = __maps_alloc())) {
+        if (!__mprotect_chunk(map_addr + left, right, prot, false)) {
+          leftmap->addr = map_addr;
+          leftmap->size = left;
+          leftmap->off = map->off;
+          leftmap->prot = map->prot;
+          leftmap->flags = map->flags;
+          leftmap->iscow = map->iscow;
+          leftmap->readonlyfile = map->readonlyfile;
+          leftmap->hand = map->hand;
+          map->addr += left;
+          map->size = right;
           map->prot = prot;
+          map->hand = MAPS_SUBREGION;
+          if (!(map->flags & MAP_ANONYMOUS))
+            map->off += left;
+          tree_insert(&__maps.maps, &leftmap->tree, __maps_compare);
+          __maps.count += 1;
+          __maps_check();
         } else {
+          __maps_free(leftmap);
           rc = -1;
         }
-      } else if (IsWindows()) {
-        // windows does allow changing protection at 4096 byte chunks
-        // however we currently don't have data structures that track
-        // this within the 64 kb map granules that can't be broken up
-        if (__mprotect_chunk(beg, end - beg, prot, map->iscow) == -1)
-          rc = -1;
-      } else if (addr <= map_addr) {
-        // cleave lefthand side of mapping
-        size_t left = PGUP(addr + size - map_addr);
-        size_t right = map_size - left;
-        struct Map *leftmap;
-        if ((leftmap = __maps_alloc())) {
-          if (!__mprotect_chunk(map_addr, left, prot, false)) {
-            leftmap->next = map;
-            leftmap->addr = map_addr;
-            leftmap->size = left;
-            leftmap->prot = prot;
-            leftmap->off = map->off;
-            leftmap->flags = map->flags;
-            map->addr += left;
-            map->size = right;
-            if (map->off != -1)
-              map->off += left;
-            dll_make_first(&__maps.used, &leftmap->elem);
-            *prev = leftmap;
-            __maps.count += 1;
-            __maps_check();
-          } else {
-            __maps_free(leftmap);
-            rc = -1;
-          }
-        } else {
-          rc = -1;
-        }
-      } else if (addr + PGUP(size) >= map_addr + PGUP(map_size)) {
-        // cleave righthand side of mapping
-        size_t left = addr - map_addr;
-        size_t right = map_addr + map_size - addr;
-        struct Map *leftmap;
-        if ((leftmap = __maps_alloc())) {
-          if (!__mprotect_chunk(map_addr + left, right, prot, false)) {
-            leftmap->next = map;
+      } else {
+        rc = -1;
+      }
+    } else {
+      // change middle of mapping
+      size_t left = addr - map_addr;
+      size_t middle = size;
+      size_t right = map_size - middle - left;
+      struct Map *leftmap;
+      if ((leftmap = __maps_alloc())) {
+        struct Map *midlmap;
+        if ((midlmap = __maps_alloc())) {
+          if (!__mprotect_chunk(map_addr + left, middle, prot, false)) {
             leftmap->addr = map_addr;
             leftmap->size = left;
             leftmap->off = map->off;
             leftmap->prot = map->prot;
             leftmap->flags = map->flags;
-            map->addr += left;
+            leftmap->iscow = map->iscow;
+            leftmap->readonlyfile = map->readonlyfile;
+            leftmap->hand = map->hand;
+            midlmap->addr = map_addr + left;
+            midlmap->size = middle;
+            midlmap->off = (map->flags & MAP_ANONYMOUS) ? 0 : map->off + left;
+            midlmap->prot = prot;
+            midlmap->flags = map->flags;
+            midlmap->hand = MAPS_SUBREGION;
+            map->addr += left + middle;
             map->size = right;
-            map->prot = prot;
-            if (map->off != -1)
-              map->off += left;
-            dll_make_first(&__maps.used, &leftmap->elem);
-            *prev = leftmap;
-            __maps.count += 1;
+            map->hand = MAPS_SUBREGION;
+            if (!(map->flags & MAP_ANONYMOUS))
+              map->off += left + middle;
+            tree_insert(&__maps.maps, &leftmap->tree, __maps_compare);
+            tree_insert(&__maps.maps, &midlmap->tree, __maps_compare);
+            __maps.count += 2;
             __maps_check();
           } else {
+            __maps_free(midlmap);
             __maps_free(leftmap);
             rc = -1;
           }
         } else {
+          __maps_free(leftmap);
           rc = -1;
         }
       } else {
-        // punch hole in mapping
-        size_t left = addr - map_addr;
-        size_t middle = PGUP(size);
-        size_t right = map_size - middle - left;
-        struct Map *leftmap;
-        if ((leftmap = __maps_alloc())) {
-          struct Map *midlmap;
-          if ((midlmap = __maps_alloc())) {
-            if (!__mprotect_chunk(map_addr + left, middle, prot, false)) {
-              leftmap->next = midlmap;
-              leftmap->addr = map_addr;
-              leftmap->size = left;
-              leftmap->off = map->off;
-              leftmap->prot = map->prot;
-              leftmap->flags = map->flags;
-              midlmap->next = map;
-              midlmap->addr = map_addr + left;
-              midlmap->size = middle;
-              midlmap->off = map->off == -1 ? -1 : map->off + left;
-              midlmap->prot = prot;
-              midlmap->flags = map->flags;
-              map->addr += left + middle;
-              map->size = right;
-              if (map->off != -1)
-                map->off += left + middle;
-              dll_make_first(&__maps.used, &leftmap->elem);
-              dll_make_first(&__maps.used, &midlmap->elem);
-              *prev = leftmap;
-              __maps.count += 2;
-              __maps_check();
-            } else {
-              __maps_free(midlmap);
-              __maps_free(leftmap);
-              rc = -1;
-            }
-          } else {
-            __maps_free(leftmap);
-            rc = -1;
-          }
-        } else {
-          rc = -1;
-        }
+        rc = -1;
       }
     }
-    prev = &map->next;
-    map = next;
   }
 
   // allow user to change mappings unknown to cosmo runtime
@@ -206,11 +212,20 @@ int __mprotect(char *addr, size_t size, int prot) {
 /**
  * Modifies restrictions on virtual memory address range.
  *
- * @param addr needs to be 4kb aligned
- * @param prot can have PROT_{NONE,READ,WRITE,EXEC}
+ * POSIX doesn't require mprotect() to be async signal safe. However you
+ * should be able to call this from a signal handler safely, if you know
+ * that your signal will never interrupt the cosmopolitan memory manager
+ * and the only way you can ensure that, is by blocking signals whenever
+ * you call mmap(), munmap(), mprotect(), etc.
+ *
+ * @param addr needs to be page size aligned
+ * @param size is rounded up to the page size
+ * @param prot can be PROT_NONE or a combination of PROT_READ,
+ *     PROT_WRITE, and PROT_EXEC
  * @return 0 on success, or -1 w/ errno
+ * @raise EINVAL if `size` is zero
  * @raise ENOMEM on tracking memory oom
- * @see mmap()
+ * @raise EDEADLK if called from signal handler interrupting mmap()
  */
 int mprotect(void *addr, size_t size, int prot) {
   int rc;
diff --git a/libc/intrin/msync-nt.c b/libc/intrin/msync-nt.c
index 78cbd5444..4e737678b 100644
--- a/libc/intrin/msync-nt.c
+++ b/libc/intrin/msync-nt.c
@@ -19,28 +19,33 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/intrin/maps.h"
 #include "libc/nt/memory.h"
-#include "libc/nt/runtime.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/sysparam.h"
-#include "libc/sysv/consts/auxv.h"
+#include "libc/sysv/consts/map.h"
 #include "libc/sysv/errfuns.h"
 
 textwindows int sys_msync_nt(char *addr, size_t size, int flags) {
+  size = (size + __pagesize - 1) & -__pagesize;
 
-  int pagesz = getauxval(AT_PAGESZ);
-  size = (size + pagesz - 1) & -pagesz;
-
-  if ((uintptr_t)addr & (pagesz - 1))
+  if ((uintptr_t)addr & (__pagesize - 1))
     return einval();
+  if (__maps_reentrant())
+    return edeadlk();
 
   int rc = 0;
   __maps_lock();
-  for (struct Map *map = __maps.maps; map; map = map->next) {
+  struct Map *map;
+  if (!(map = __maps_floor(addr)))
+    map = __maps_first();
+  for (; map && map->addr <= addr + size; map = __maps_next(map)) {
+    if (map->flags & MAP_ANONYMOUS)
+      continue;  // msync() is about coherency between file and memory
     char *beg = MAX(addr, map->addr);
     char *end = MIN(addr + size, map->addr + map->size);
-    if (beg < end)
-      if (!FlushViewOfFile(beg, end - beg))
-        rc = -1;
+    if (beg >= end)
+      continue;  // didn't overlap mapping
+    if (!FlushViewOfFile(beg, end - beg))
+      rc = -1;
     // TODO(jart): FlushFileBuffers too on g_fds handle if MS_SYNC?
   }
   __maps_unlock();
diff --git a/libc/intrin/msync.c b/libc/intrin/msync.c
index a9b03ea8c..e9be44863 100644
--- a/libc/intrin/msync.c
+++ b/libc/intrin/msync.c
@@ -23,8 +23,9 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/sysv/errfuns.h"
 
 /**
@@ -37,6 +38,7 @@
  * @param flags needs MS_ASYNC or MS_SYNC and can have MS_INVALIDATE
  * @return 0 on success or -1 w/ errno
  * @raise ECANCELED if thread was cancelled in masked mode
+ * @raise EDEADLK if called from signal handler interrupting mmap()
  * @raise EINTR if we needed to block and a signal was delivered instead
  * @raise EINVAL if `MS_SYNC` and `MS_ASYNC` were both specified
  * @raise EINVAL if unknown `flags` were passed
@@ -66,23 +68,19 @@ int msync(void *addr, size_t size, int flags) {
   } else {
     sysflags = MS_ASYNC;
   }
-  if (flags & MS_INVALIDATE) {
+  if (flags & MS_INVALIDATE)
     sysflags |= MS_INVALIDATE;
-  }
 
   // FreeBSD's manual says "The flags argument was both MS_ASYNC and
   // MS_INVALIDATE. Only one of these flags is allowed." which makes
   // following the POSIX recommendation somewhat difficult.
-  if (IsFreebsd()) {
-    if (sysflags == (MS_ASYNC | MS_INVALIDATE)) {
+  if (IsFreebsd())
+    if (sysflags == (MS_ASYNC | MS_INVALIDATE))
       sysflags = MS_INVALIDATE;
-    }
-  }
 
   // FreeBSD specifies MS_SYNC as 0 so we shift the Cosmo constants
-  if (IsFreebsd()) {
+  if (IsFreebsd())
     sysflags >>= 1;
-  }
 
   BEGIN_CANCELATION_POINT;
   if (!IsWindows()) {
@@ -93,6 +91,7 @@ int msync(void *addr, size_t size, int flags) {
   END_CANCELATION_POINT;
 
 Finished:
-  STRACE("msync(%p, %'zu, %#x) → %d% m", addr, size, flags, rc);
+  STRACE("msync(%p, %'zu, %s) → %d% m", addr, size, DescribeMsyncFlags(flags),
+         rc);
   return rc;
 }
diff --git a/libc/intrin/munmap-metal.c b/libc/intrin/munmap-metal.c
index b022ddfc4..83f889bb6 100644
--- a/libc/intrin/munmap-metal.c
+++ b/libc/intrin/munmap-metal.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/directmap.h"
 #include "libc/runtime/pc.internal.h"
 #ifdef __x86_64__
 
diff --git a/libc/intrin/munmap-sysv.c b/libc/intrin/munmap-sysv.c
index 258782d60..3d4b0c6ae 100644
--- a/libc/intrin/munmap-sysv.c
+++ b/libc/intrin/munmap-sysv.c
@@ -18,9 +18,9 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/directmap.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/directmap.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/syslib.internal.h"
 
@@ -41,8 +41,6 @@ int sys_munmap(void *p, size_t n) {
   } else {
     rc = __sys_munmap(p, n);
   }
-  if (!rc)
-    __virtualsize -= n;
   KERNTRACE("sys_munmap(%p, %'zu) → %d", p, n, rc);
   return rc;
 }
diff --git a/libc/intrin/nomultics.c b/libc/intrin/nomultics.c
index 065eb42fc..fa38350f1 100644
--- a/libc/intrin/nomultics.c
+++ b/libc/intrin/nomultics.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/ttydefaults.h"
-#include "libc/intrin/nomultics.internal.h"
+#include "libc/intrin/nomultics.h"
 
 struct TtyConf __ttyconf = {
     .vmin = 1,
diff --git a/libc/intrin/nomultics.h b/libc/intrin/nomultics.h
new file mode 100644
index 000000000..b2aca3ecf
--- /dev/null
+++ b/libc/intrin/nomultics.h
@@ -0,0 +1,50 @@
+#ifndef COSMOPOLITAN_NOMULTICS_H_
+#define COSMOPOLITAN_NOMULTICS_H_
+
+#define kTtySilence  1  /* do not relay read() into write() */
+#define kTtyEchoRaw  2  /* don't ^X visualize control codes */
+#define kTtyUncanon  4  /* enables non-canonical (raw) mode */
+#define kTtyNoCr2Nl  8  /* don't map \r → \n (a.k.a !ICRNL) */
+#define kTtyNoIsigs  16 /* don't auto-raise signals on keys */
+#define kTtyXtMouse  32 /* enables eXtreme Xterm mouse mode */
+#define kTtyNoIexten 64 /* disable various canon keystrokes */
+#define kTtyNoEchoe  128
+#define kTtyNoEchok  256
+#define kTtyNoEchoke 512
+
+COSMOPOLITAN_C_START_
+
+struct TtyConf {
+  unsigned magic;
+  unsigned char mousebs;
+  unsigned char replmode;
+  unsigned char replstderr;
+  union {
+    unsigned char c_cc[20];
+    struct {
+      unsigned char vline;
+      unsigned char vintr;  /* SIGINT keystroke (isigs) */
+      unsigned char vquit;  /* SIGQUIT keystroke (isigs) */
+      unsigned char verase; /* backspace keystroke (canon) */
+      unsigned char vkill;  /* kill line back keystroke (canon) */
+      unsigned char veof;   /* EOF keystroke (canon) */
+      unsigned char vtime;  /* vtime*100ms can control read delay */
+      unsigned char vmin;   /* use 0 for special non-blocking mode */
+      unsigned char vswtc;
+      unsigned char vstart;
+      unsigned char vstop;
+      unsigned char vsusp; /* keystroke for SIGTSTP (isigs) */
+      unsigned char veol;
+      unsigned char vreprint; /* keystroke to print unread line (canon) */
+      unsigned char vdiscard;
+      unsigned char vwerase; /* keystroke for kill word back (canon) */
+      unsigned char vlnext;  /* print next keystroke as ascii (canon) */
+      unsigned char veol2;
+    };
+  };
+};
+
+extern struct TtyConf __ttyconf;
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_NOMULTICS_H_ */
diff --git a/libc/intrin/nomultics.internal.h b/libc/intrin/nomultics.internal.h
deleted file mode 100644
index 833bc7e28..000000000
--- a/libc/intrin/nomultics.internal.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef COSMOPOLITAN_NOMULTICS_H_
-#define COSMOPOLITAN_NOMULTICS_H_
-
-#define kTtySilence 1  /* do not relay read() into write() */
-#define kTtyEchoRaw 2  /* don't ^X visualize control codes */
-#define kTtyUncanon 4  /* enables non-canonical (raw) mode */
-#define kTtyNoCr2Nl 8  /* don't map \r → \n (a.k.a !ICRNL) */
-#define kTtyNoIsigs 16 /* don't auto-raise signals on keys */
-#define kTtyXtMouse 32 /* enables eXtreme Xterm mouse mode */
-
-COSMOPOLITAN_C_START_
-
-struct TtyConf {
-  unsigned char magic;
-  unsigned char mousebs;
-  unsigned char replmode;
-  unsigned char replstderr;
-  union {
-    unsigned char c_cc[20];
-    struct {
-      unsigned char vline;
-      unsigned char vintr;  /* SIGINT keystroke (isigs) */
-      unsigned char vquit;  /* SIGQUIT keystroke (isigs) */
-      unsigned char verase; /* backspace keystroke (canon) */
-      unsigned char vkill;  /* kill line back keystroke (canon) */
-      unsigned char veof;   /* EOF keystroke (canon) */
-      unsigned char vtime;  /* vtime*100ms can control read delay */
-      unsigned char vmin;   /* use 0 for special non-blocking mode */
-      unsigned char vswtc;
-      unsigned char vstart;
-      unsigned char vstop;
-      unsigned char vsusp; /* keystroke for SIGTSTP (isigs) */
-      unsigned char veol;
-      unsigned char vreprint; /* keystroke to print unread line (canon) */
-      unsigned char vdiscard;
-      unsigned char vwerase; /* keystroke for kill word back (canon) */
-      unsigned char vlnext;  /* print next keystroke as ascii (canon) */
-      unsigned char veol2;
-    };
-  };
-};
-
-extern struct TtyConf __ttyconf;
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_NOMULTICS_H_ */
diff --git a/libc/intrin/ntcontext2linux.c b/libc/intrin/ntcontext2linux.c
deleted file mode 100644
index bf9d3df15..000000000
--- a/libc/intrin/ntcontext2linux.c
+++ /dev/null
@@ -1,82 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/ucontext.h"
-#include "libc/log/libfatal.internal.h"
-#include "libc/nt/struct/context.h"
-#include "libc/str/str.h"
-#ifdef __x86_64__
-
-textwindows void _ntcontext2linux(ucontext_t *ctx, const struct NtContext *cr) {
-  if (!cr)
-    return;
-  ctx->uc_mcontext.eflags = cr->EFlags;
-  ctx->uc_mcontext.rax = cr->Rax;
-  ctx->uc_mcontext.rbx = cr->Rbx;
-  ctx->uc_mcontext.rcx = cr->Rcx;
-  ctx->uc_mcontext.rdx = cr->Rdx;
-  ctx->uc_mcontext.rdi = cr->Rdi;
-  ctx->uc_mcontext.rsi = cr->Rsi;
-  ctx->uc_mcontext.rbp = cr->Rbp;
-  ctx->uc_mcontext.rsp = cr->Rsp;
-  ctx->uc_mcontext.rip = cr->Rip;
-  ctx->uc_mcontext.r8 = cr->R8;
-  ctx->uc_mcontext.r9 = cr->R9;
-  ctx->uc_mcontext.r10 = cr->R10;
-  ctx->uc_mcontext.r11 = cr->R11;
-  ctx->uc_mcontext.r12 = cr->R12;
-  ctx->uc_mcontext.r13 = cr->R13;
-  ctx->uc_mcontext.r14 = cr->R14;
-  ctx->uc_mcontext.r15 = cr->R15;
-  ctx->uc_mcontext.cs = cr->SegCs;
-  ctx->uc_mcontext.gs = cr->SegGs;
-  ctx->uc_mcontext.fs = cr->SegFs;
-  ctx->uc_mcontext.fpregs = &ctx->__fpustate;
-  __repmovsb(&ctx->__fpustate, &cr->FltSave, sizeof(ctx->__fpustate));
-  ctx->__fpustate.mxcsr = cr->MxCsr;
-}
-
-textwindows void _ntlinux2context(struct NtContext *cr, const ucontext_t *ctx) {
-  if (!cr)
-    return;
-  cr->EFlags = ctx->uc_mcontext.eflags;
-  cr->Rax = ctx->uc_mcontext.rax;
-  cr->Rbx = ctx->uc_mcontext.rbx;
-  cr->Rcx = ctx->uc_mcontext.rcx;
-  cr->Rdx = ctx->uc_mcontext.rdx;
-  cr->Rdi = ctx->uc_mcontext.rdi;
-  cr->Rsi = ctx->uc_mcontext.rsi;
-  cr->Rbp = ctx->uc_mcontext.rbp;
-  cr->Rsp = ctx->uc_mcontext.rsp;
-  cr->Rip = ctx->uc_mcontext.rip;
-  cr->R8 = ctx->uc_mcontext.r8;
-  cr->R9 = ctx->uc_mcontext.r9;
-  cr->R10 = ctx->uc_mcontext.r10;
-  cr->R11 = ctx->uc_mcontext.r11;
-  cr->R12 = ctx->uc_mcontext.r12;
-  cr->R13 = ctx->uc_mcontext.r13;
-  cr->R14 = ctx->uc_mcontext.r14;
-  cr->R15 = ctx->uc_mcontext.r15;
-  cr->SegCs = ctx->uc_mcontext.cs;
-  cr->SegGs = ctx->uc_mcontext.gs;
-  cr->SegFs = ctx->uc_mcontext.fs;
-  cr->MxCsr = ctx->__fpustate.mxcsr;
-  __repmovsb(&cr->FltSave, &ctx->__fpustate, sizeof(ctx->__fpustate));
-}
-
-#endif /* __x86_64__ */
diff --git a/libc/intrin/openprocess.c b/libc/intrin/openprocess.c
index 338da91bf..3f9fed97c 100644
--- a/libc/intrin/openprocess.c
+++ b/libc/intrin/openprocess.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/process.h"
 #include "libc/nt/struct/securityattributes.h"
diff --git a/libc/intrin/packsswb.c b/libc/intrin/packsswb.c
deleted file mode 100644
index da3fa67b9..000000000
--- a/libc/intrin/packsswb.c
+++ /dev/null
@@ -1,40 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/packsswb.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "libc/str/str.h"
-
-/**
- * Casts shorts to signed chars w/ saturation.
- *
- *   𝑎 ← {CLAMP[𝑏ᵢ]|𝑖∈[0,4)} ║ {CLAMP[𝑐ᵢ]|𝑖∈[4,8)}
- *
- * @see packuswb()
- * @mayalias
- */
-void(packsswb)(int8_t a[16], const int16_t b[8], const int16_t c[8]) {
-  unsigned i;
-  int8_t r[16];
-  for (i = 0; i < 8; ++i)
-    r[i + 0] = MIN(INT8_MAX, MAX(INT8_MIN, b[i]));
-  for (i = 0; i < 8; ++i)
-    r[i + 8] = MIN(INT8_MAX, MAX(INT8_MIN, c[i]));
-  __builtin_memcpy(a, r, 16);
-}
diff --git a/libc/intrin/packsswb.h b/libc/intrin/packsswb.h
deleted file mode 100644
index fae659b0b..000000000
--- a/libc/intrin/packsswb.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PACKSSWB_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PACKSSWB_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void packsswb(int8_t[16], const int16_t[8], const int16_t[8]);
-
-#define packsswb(A, B, C)                                                    \
-  INTRIN_SSEVEX_X_X_X_(packsswb, SSE2, "packsswb", INTRIN_NONCOMMUTATIVE, A, \
-                       B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PACKSSWB_H_ */
diff --git a/libc/intrin/packuswb.c b/libc/intrin/packuswb.c
deleted file mode 100644
index 66d9c766f..000000000
--- a/libc/intrin/packuswb.c
+++ /dev/null
@@ -1,40 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/packuswb.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "libc/str/str.h"
-
-/**
- * Casts shorts to unsigned chars w/ saturation.
- *
- *   𝑎 ← {CLAMP[𝑏ᵢ]|𝑖∈[0,4)} ║ {CLAMP[𝑐ᵢ]|𝑖∈[4,8)}
- *
- * @see packsswb()
- * @mayalias
- */
-void(packuswb)(uint8_t a[16], const int16_t b[8], const int16_t c[8]) {
-  unsigned i;
-  uint8_t r[16];
-  for (i = 0; i < 8; ++i)
-    r[i + 0] = MIN(UINT8_MAX, MAX(UINT8_MIN, b[i]));
-  for (i = 0; i < 8; ++i)
-    r[i + 8] = MIN(UINT8_MAX, MAX(UINT8_MIN, c[i]));
-  __builtin_memcpy(a, r, 16);
-}
diff --git a/libc/intrin/packuswb.h b/libc/intrin/packuswb.h
deleted file mode 100644
index 3c8ddf7da..000000000
--- a/libc/intrin/packuswb.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PACKUSWB_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PACKUSWB_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void packuswb(uint8_t[16], const int16_t[8], const int16_t[8]);
-
-#define packuswb(A, B, C)                                                    \
-  INTRIN_SSEVEX_X_X_X_(packuswb, SSE2, "packuswb", INTRIN_NONCOMMUTATIVE, A, \
-                       B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PACKUSWB_H_ */
diff --git a/libc/intrin/paddw.c b/libc/intrin/paddw.c
deleted file mode 100644
index ea3351e4f..000000000
--- a/libc/intrin/paddw.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/paddw.h"
-#include "libc/str/str.h"
-
-/**
- * Adds 16-bit integers.
- *
- * @param 𝑎 [w/o] receives result
- * @param 𝑏 [r/o] supplies first input vector
- * @param 𝑐 [r/o] supplies second input vector
- * @note shorts can't overflow so ubsan won't report it when it happens
- * @see paddsw()
- * @mayalias
- */
-void(paddw)(int16_t a[8], const int16_t b[8], const int16_t c[8]) {
-  unsigned i;
-  int16_t r[8];
-  for (i = 0; i < 8; ++i) {
-    r[i] = b[i] + c[i];
-  }
-  __builtin_memcpy(a, r, 16);
-}
diff --git a/libc/intrin/paddw.h b/libc/intrin/paddw.h
deleted file mode 100644
index bdad518d9..000000000
--- a/libc/intrin/paddw.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PADDW_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PADDW_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void paddw(int16_t[8], const int16_t[8], const int16_t[8]);
-
-#define paddw(A, B, C) \
-  INTRIN_SSEVEX_X_X_X_(paddw, SSE2, "paddw", INTRIN_COMMUTATIVE, A, B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PADDW_H_ */
diff --git a/libc/intrin/pagesize.c b/libc/intrin/pagesize.c
new file mode 100644
index 000000000..a15149123
--- /dev/null
+++ b/libc/intrin/pagesize.c
@@ -0,0 +1,47 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/dce.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/nt/struct/systeminfo.h"
+#include "libc/nt/systeminfo.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sysv/consts/auxv.h"
+
+#ifdef __x86_64__
+__static_yoink("_init_pagesize");
+#endif
+
+int __pagesize;
+int __gransize;
+
+textstartup static int __pagesize_get(unsigned long *auxv) {
+  for (; auxv && auxv[0]; auxv += 2)
+    if (auxv[0] == AT_PAGESZ)
+      return auxv[1];
+#ifdef __aarch64__
+  return 16384;
+#else
+  return 4096;
+#endif
+}
+
+textstartup dontinstrument void __pagesize_init(unsigned long *auxv) {
+  if (!__pagesize)
+    __gransize = __pagesize = __pagesize_get(auxv);
+}
diff --git a/libc/intrin/pagesize_init.S b/libc/intrin/pagesize_init.S
new file mode 100644
index 000000000..bb9a8188e
--- /dev/null
+++ b/libc/intrin/pagesize_init.S
@@ -0,0 +1,28 @@
+/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
+│ vi: set et ft=asm ts=8 tw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/macros.h"
+
+	.init.start 251,_init_pagesize
+	push	%rdi
+	push	%rsi
+	mov	%r15,%rdi
+	call	__pagesize_init
+	pop	%rsi
+	pop	%rdi
+	.init.end 251,_init_pagesize
diff --git a/libc/intrin/palignr.c b/libc/intrin/palignr.c
deleted file mode 100644
index 2f4474076..000000000
--- a/libc/intrin/palignr.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/palignr.h"
-#include "libc/assert.h"
-#include "libc/macros.internal.h"
-
-/**
- * Overlaps vectors.
- *
- *     𝑖= 0 means 𝑐←𝑎
- *   0<𝑖<16 means 𝑐←𝑎║𝑏
- *     𝑖=16 means 𝑐←𝑏
- *  16<𝑖<32 means 𝑐←𝑏║0
- *     𝑖≥32 means 𝑐←0
- *
- * @param 𝑖 goes faster as constexpr
- * @note not compatible with mmx
- * @see pvalignr()
- * @mayalias
- */
-void(palignr)(void *c, const void *b, const void *a, unsigned long i) {
-  char t[48];
-  __builtin_memcpy(t, a, 16);
-  __builtin_memcpy(t + 16, b, 16);
-  __builtin_memset(t + 32, 0, 16);
-  __builtin_memcpy(c, t + MIN(i, 32), 16);
-}
diff --git a/libc/intrin/palignr.h b/libc/intrin/palignr.h
deleted file mode 100644
index 3995bd4a2..000000000
--- a/libc/intrin/palignr.h
+++ /dev/null
@@ -1,45 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PALIGNR_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PALIGNR_H_
-#include "libc/intrin/macros.h"
-#include "libc/str/str.h"
-COSMOPOLITAN_C_START_
-
-void palignr(void *, const void *, const void *, unsigned long);
-
-#if !defined(__STRICT_ANSI__) && !defined(__chibicc__) && defined(__x86_64__)
-__intrin_xmm_t __palignrs(__intrin_xmm_t, __intrin_xmm_t);
-#define palignr(C, B, A, I)                                                 \
-  do {                                                                      \
-    if (__builtin_expect(!IsModeDbg() && X86_NEED(SSE) && X86_HAVE(SSSE3),  \
-                         1)) {                                              \
-      __intrin_xmm_t *Xmm0 = (void *)(C);                                   \
-      const __intrin_xmm_t *Xmm1 = (const __intrin_xmm_t *)(B);             \
-      const __intrin_xmm_t *Xmm2 = (const __intrin_xmm_t *)(A);             \
-      if (__builtin_constant_p(I)) {                                        \
-        if (!X86_NEED(AVX)) {                                               \
-          asm("palignr\t%2,%1,%0"                                           \
-              : "=x"(*Xmm0)                                                 \
-              : "x"(*Xmm2), "i"(I), "0"(*Xmm1));                            \
-        } else {                                                            \
-          asm("vpalignr\t%3,%2,%1,%0"                                       \
-              : "=x"(*Xmm0)                                                 \
-              : "x"(*Xmm1), "x"(*Xmm2), "i"(I));                            \
-        }                                                                   \
-      } else {                                                              \
-        unsigned long Vimm = (I);                                           \
-        typeof(__palignrs) *Fn;                                             \
-        if (__builtin_expect(Vimm < 32, 1)) {                               \
-          Fn = (typeof(__palignrs) *)((uintptr_t) & __palignrs + Vimm * 8); \
-          *Xmm0 = Fn(*Xmm1, *Xmm2);                                         \
-        } else {                                                            \
-          memset(Xmm0, 0, 16);                                              \
-        }                                                                   \
-      }                                                                     \
-    } else {                                                                \
-      palignr(C, B, A, I);                                                  \
-    }                                                                       \
-  } while (0)
-#endif
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PALIGNR_H_ */
diff --git a/libc/intrin/palignrs.S b/libc/intrin/palignrs.S
deleted file mode 100644
index 9eeee072f..000000000
--- a/libc/intrin/palignrs.S
+++ /dev/null
@@ -1,125 +0,0 @@
-/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
-
-//	Jump table for palignr() with non-constexpr immediate parameter.
-//
-//	@note	needs ssse3 cf. prescott c. 2004 cf. bulldozer c. 2011
-//	@see	palignr()
-	.balign	8
-__palignrs:
-  	palignr	$0,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$1,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$2,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$3,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$4,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$5,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$6,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$7,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$8,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$9,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$10,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$11,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$12,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$13,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$14,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$15,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$16,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$17,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$18,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$19,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$20,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$21,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$22,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$23,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$24,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$25,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$26,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$27,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$28,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$29,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$30,%xmm1,%xmm0
-	ret
-	nop
-  	palignr	$31,%xmm1,%xmm0
-	ret
-	.if	. - __palignrs != 8 * 32 - 1
-	.error	"bad assemblage"
-	.endif
-	.endfn	__palignrs,globl
diff --git a/libc/intrin/pandn.c b/libc/intrin/pandn.c
deleted file mode 100644
index 10d91c52b..000000000
--- a/libc/intrin/pandn.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pandn.h"
-
-/**
- * Nands 128-bit integers.
- *
- * @param 𝑎 [w/o] receives result
- * @param 𝑏 [r/o] supplies first input vector
- * @param 𝑐 [r/o] supplies second input vector
- * @mayalias
- */
-void(pandn)(uint64_t a[2], const uint64_t b[2], const uint64_t c[2]) {
-  unsigned i;
-  for (i = 0; i < 2; ++i) {
-    a[i] = ~b[i] & c[i];
-  }
-}
diff --git a/libc/intrin/pandn.h b/libc/intrin/pandn.h
deleted file mode 100644
index bb4687614..000000000
--- a/libc/intrin/pandn.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PANDN_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PANDN_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void pandn(uint64_t[2], const uint64_t[2], const uint64_t[2]);
-
-#define pandn(A, B, C) \
-  INTRIN_SSEVEX_X_X_X_(pandn, SSE2, "pandn", INTRIN_NONCOMMUTATIVE, A, B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PANDN_H_ */
diff --git a/libc/intrin/pcmpgtb.c b/libc/intrin/pcmpgtb.c
deleted file mode 100644
index f1c895d72..000000000
--- a/libc/intrin/pcmpgtb.c
+++ /dev/null
@@ -1,38 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pcmpgtb.h"
-#include "libc/str/str.h"
-
-/**
- * Compares signed 8-bit integers w/ greater than predicate.
- *
- * Note that operands can be xor'd with 0x80 for unsigned compares.
- *
- * @param 𝑎 [w/o] receives result
- * @param 𝑏 [r/o] supplies first input vector
- * @param 𝑐 [r/o] supplies second input vector
- * @mayalias
- */
-void(pcmpgtb)(int8_t a[16], const int8_t b[16], const int8_t c[16]) {
-  unsigned i;
-  int8_t r[16];
-  for (i = 0; i < 16; ++i)
-    r[i] = -(b[i] > c[i]);
-  __builtin_memcpy(a, r, 16);
-}
diff --git a/libc/intrin/pcmpgtb.h b/libc/intrin/pcmpgtb.h
deleted file mode 100644
index 043cedf4f..000000000
--- a/libc/intrin/pcmpgtb.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PCMPGTB_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PCMPGTB_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void pcmpgtb(int8_t[16], const int8_t[16], const int8_t[16]);
-
-#define pcmpgtb(A, B, C) \
-  INTRIN_SSEVEX_X_X_X_(pcmpgtb, SSE2, "pcmpgtb", INTRIN_NONCOMMUTATIVE, A, B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PCMPGTB_H_ */
diff --git a/libc/intrin/pcmpgtw.c b/libc/intrin/pcmpgtw.c
deleted file mode 100644
index 7bf94ef49..000000000
--- a/libc/intrin/pcmpgtw.c
+++ /dev/null
@@ -1,36 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pcmpgtw.h"
-#include "libc/str/str.h"
-
-/**
- * Compares signed 16-bit integers w/ greater than predicate.
- *
- * @param 𝑎 [w/o] receives result
- * @param 𝑏 [r/o] supplies first input vector
- * @param 𝑐 [r/o] supplies second input vector
- * @mayalias
- */
-void(pcmpgtw)(int16_t a[8], const int16_t b[8], const int16_t c[8]) {
-  unsigned i;
-  int16_t r[8];
-  for (i = 0; i < 8; ++i)
-    r[i] = -(b[i] > c[i]);
-  __builtin_memcpy(a, r, 16);
-}
diff --git a/libc/intrin/pcmpgtw.h b/libc/intrin/pcmpgtw.h
deleted file mode 100644
index bb9707d19..000000000
--- a/libc/intrin/pcmpgtw.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PCMPGTW_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PCMPGTW_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void pcmpgtw(int16_t[8], const int16_t[8], const int16_t[8]);
-
-#define pcmpgtw(A, B, C) \
-  INTRIN_SSEVEX_X_X_X_(pcmpgtw, SSE2, "pcmpgtw", INTRIN_NONCOMMUTATIVE, A, B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PCMPGTW_H_ */
diff --git a/libc/intrin/personality.c b/libc/intrin/personality.c
new file mode 100644
index 000000000..de4dce7a5
--- /dev/null
+++ b/libc/intrin/personality.c
@@ -0,0 +1,22 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+
+__attribute__((__weak__)) void __gxx_personality_v0() {
+  __builtin_trap();
+}
diff --git a/libc/intrin/pmaddubsw.c b/libc/intrin/pmaddubsw.c
deleted file mode 100644
index f2bdc9b58..000000000
--- a/libc/intrin/pmaddubsw.c
+++ /dev/null
@@ -1,42 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pmaddubsw.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "libc/str/str.h"
-
-/**
- * Multiplies bytes and adds adjacent results w/ short saturation.
- *
- *     𝑤ᵢ ← CLAMP[ 𝑏₂ᵢ𝑐₂ᵢ + 𝑏₍₂ᵢ₊₁₎𝑐₍₂ᵢ₊₁₎ ]
- *
- * @param 𝑤 [w/o] receives shorts
- * @param 𝑏 [r/o] is your byte data
- * @param 𝑐 [r/o] are your int8 coefficients
- * @note SSSE3 w/ Prescott c. 2004, Bulldozer c. 2011
- * @note greatest simd op, like, ever
- * @mayalias
- */
-void(pmaddubsw)(int16_t w[8], const uint8_t b[16], const int8_t c[16]) {
-  unsigned i;
-  for (i = 0; i < 8; ++i) {
-    w[i] = MIN(SHRT_MAX, MAX(SHRT_MIN, (c[i * 2 + 0] * b[i * 2 + 0] +
-                                        c[i * 2 + 1] * b[i * 2 + 1])));
-  }
-}
diff --git a/libc/intrin/pmaddubsw.h b/libc/intrin/pmaddubsw.h
deleted file mode 100644
index 5e503c56c..000000000
--- a/libc/intrin/pmaddubsw.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PMADDUBSW_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PMADDUBSW_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void pmaddubsw(int16_t[8], const uint8_t[16], const int8_t[16]);
-
-#define pmaddubsw(W, B, C)                                                   \
-  INTRIN_SSEVEX_X_X_X_(pmaddubsw, SSSE3, "pmaddubsw", INTRIN_NONCOMMUTATIVE, \
-                       W, B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PMADDUBSW_H_ */
diff --git a/libc/intrin/pmovmskb.c b/libc/intrin/pmovmskb.c
deleted file mode 100644
index 0ff024d1d..000000000
--- a/libc/intrin/pmovmskb.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pmovmskb.h"
-
-/**
- * Turns result of byte comparison into bitmask.
- *
- * @param 𝑝 is byte vector to crunch
- * @see pcmpeqb(), bsf(), etc.
- */
-uint32_t(pmovmskb)(const uint8_t p[16]) {
-  uint32_t i, m;
-  for (m = i = 0; i < 16; ++i) {
-    if (p[i] & 0x80)
-      m |= 1 << i;
-  }
-  return m;
-}
diff --git a/libc/intrin/pmovmskb.h b/libc/intrin/pmovmskb.h
deleted file mode 100644
index e17e1fb16..000000000
--- a/libc/intrin/pmovmskb.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PMOVMSKB_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PMOVMSKB_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-uint32_t pmovmskb(const uint8_t[16]);
-
-#if defined(__x86_64__) && defined(__GNUC__)
-#define pmovmskb(A)                                            \
-  ({                                                           \
-    uint32_t Mask;                                             \
-    if (!IsModeDbg() && X86_HAVE(SSE2)) {                      \
-      const __intrin_xmm_t *Xmm = (const __intrin_xmm_t *)(A); \
-      if (!X86_NEED(AVX)) {                                    \
-        asm("pmovmskb\t%1,%0" : "=r"(Mask) : "x"(*Xmm));       \
-      } else {                                                 \
-        asm("vpmovmskb\t%1,%0" : "=r"(Mask) : "x"(*Xmm));      \
-      }                                                        \
-    } else {                                                   \
-      Mask = pmovmskb(A);                                      \
-    }                                                          \
-    Mask;                                                      \
-  })
-#endif
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PMOVMSKB_H_ */
diff --git a/libc/intrin/pmulhrsw.c b/libc/intrin/pmulhrsw.c
deleted file mode 100644
index 4326542e0..000000000
--- a/libc/intrin/pmulhrsw.c
+++ /dev/null
@@ -1,36 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pmulhrsw.h"
-#include "libc/str/str.h"
-
-/**
- * Multiplies Q15 numbers.
- *
- * @note goes fast w/ ssse3 (intel c. 2004, amd c. 2011)
- * @note a.k.a. packed multiply high w/ round & scale
- * @see Q2F(15,𝑥), F2Q(15,𝑥)
- * @mayalias
- */
-void(pmulhrsw)(int16_t a[8], const int16_t b[8], const int16_t c[8]) {
-  unsigned i;
-  int16_t r[8];
-  for (i = 0; i < 8; ++i)
-    r[i] = (((b[i] * c[i]) >> 14) + 1) >> 1;
-  __builtin_memcpy(a, r, 16);
-}
diff --git a/libc/intrin/pmulhrsw.h b/libc/intrin/pmulhrsw.h
deleted file mode 100644
index 2182c3404..000000000
--- a/libc/intrin/pmulhrsw.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PMULHRSW_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PMULHRSW_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void pmulhrsw(int16_t a[8], const int16_t b[8], const int16_t c[8]);
-
-#define pmulhrsw(A, B, C) \
-  INTRIN_SSEVEX_X_X_X_(pmulhrsw, SSSE3, "pmulhrsw", INTRIN_COMMUTATIVE, A, B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PMULHRSW_H_ */
diff --git a/libc/intrin/printmaps.c b/libc/intrin/printmaps.c
index 468c0f928..7503876ed 100644
--- a/libc/intrin/printmaps.c
+++ b/libc/intrin/printmaps.c
@@ -16,44 +16,92 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/dce.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/bsr.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/maps.h"
-#include "libc/macros.internal.h"
 #include "libc/runtime/memtrack.internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/auxv.h"
 
+// this will usually return 12 since x86 pml4t uses a 47 bit address
+// space in userspace, and decent arm machines uses a 48 bit address
+// space. however it could go lower on embedded devices. it can also
+// rise higher on expensive x86 machines with pml5t, if user uses it
+static int get_address_digits(int pagesz) {
+  int max_bits = 0;
+  for (struct Tree *e = tree_first(__maps.maps); e; e = tree_next(e)) {
+    struct Map *map = MAP_TREE_CONTAINER(e);
+    char *end = map->addr + ((map->size + pagesz - 1) & -pagesz);
+    int bits = bsrll((uintptr_t)end) + 1;
+    if (bits > max_bits)
+      max_bits = bits;
+  }
+  return ((max_bits + 3) & -4) / 4;
+}
+
 /**
- * Prints memory mappings.
+ * Prints memory mappings known to cosmo.
  */
-void __print_maps(void) {
-  int limit = 13;
-  long maptally = 0;
-  char mappingbuf[8], sb[16];
+void __print_maps(size_t limit) {
   __maps_lock();
-  struct Dll *e, *e2;
-  for (e = dll_first(__maps.used); e; e = e2) {
-    e2 = dll_next(__maps.used, e);
-    struct Map *map = MAP_CONTAINER(e);
-    maptally += map->size;
-    kprintf("%012lx-%012lx %!s", map->addr, map->addr + map->size,
-            (DescribeMapping)(mappingbuf, map->prot, map->flags));
+  char sb[16];
+  char mappingbuf[8];
+  struct Map *last = 0;
+  int pagesz = __pagesize;
+  int gransz = __gransize;
+  int digs = get_address_digits(pagesz);
+  for (struct Tree *e = tree_first(__maps.maps); e; e = tree_next(e)) {
+    struct Map *map = MAP_TREE_CONTAINER(e);
+
+    // show gaps between maps
+    if (last) {
+      char *beg = last->addr + ((last->size + gransz - 1) & -gransz);
+      char *end = map->addr;
+      if (end > beg) {
+        size_t gap = end - beg;
+        sizefmt(sb, gap, 1024);
+        kprintf("%0*lx-%0*lx       %sb\n", digs, beg, digs, end, sb);
+      }
+    }
+    last = map;
+
+    // show mapping
+    kprintf("%0*lx-%0*lx %!s", digs, map->addr, digs, map->addr + map->size,
+            _DescribeMapping(mappingbuf, map->prot, map->flags));
     sizefmt(sb, map->size, 1024);
     kprintf(" %!sb", sb);
-    if (map->h && map->h != -1)
-      kprintf(" h=%ld", map->h);
+    if (IsWindows()) {
+      switch (map->hand) {
+        case MAPS_RESERVATION:
+          kprintf(" reservation");
+          break;
+        case MAPS_SUBREGION:
+          break;
+        case MAPS_VIRTUAL:
+          kprintf(" virtual");
+          break;
+        default:
+          kprintf(" hand=%ld", map->hand);
+          break;
+      }
+    }
     if (map->iscow)
       kprintf(" cow");
     if (map->readonlyfile)
       kprintf(" readonlyfile");
     kprintf("\n");
+
+    // stay beneath our limit
     if (!--limit)
       break;
   }
-  kprintf("# %'zu bytes in %'zu mappings\n",
-          __maps.pages * getauxval(AT_PAGESZ), __maps.count);
+
+  // print summary
+  kprintf("# %'zu bytes in %'zu mappings\n", __maps.pages * pagesz,
+          __maps.count);
   __maps_unlock();
 }
diff --git a/libc/intrin/printmapswin32.c b/libc/intrin/printmapswin32.c
new file mode 100644
index 000000000..8f03b7db0
--- /dev/null
+++ b/libc/intrin/printmapswin32.c
@@ -0,0 +1,71 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/fmt/conv.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/macros.h"
+#include "libc/nt/enum/memflags.h"
+#include "libc/nt/memory.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/sysparam.h"
+#include "libc/str/str.h"
+
+static const struct DescribeFlags kNtMemState[] = {
+    {kNtMemCommit, "Commit"},    //
+    {kNtMemFree, "Free"},        //
+    {kNtMemReserve, "Reserve"},  //
+};
+
+const char *DescribeNtMemState(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kNtMemState, ARRAYLEN(kNtMemState), "kNtMem",
+                        x);
+}
+
+static const struct DescribeFlags kNtMemType[] = {
+    {kNtMemImage, "Image"},      //
+    {kNtMemMapped, "Mapped"},    //
+    {kNtMemPrivate, "Private"},  //
+};
+
+const char *DescribeNtMemType(char buf[64], uint32_t x) {
+  return _DescribeFlags(buf, 64, kNtMemType, ARRAYLEN(kNtMemType), "kNtMem", x);
+}
+
+void __print_maps_win32(int64_t hProcess, const char *addr, size_t size) {
+  char *p, b[5][64];
+  struct NtMemoryBasicInformation mi;
+  kprintf("%-12s %-12s %10s %16s %16s %32s %32s\n", "Allocation", "BaseAddress",
+          "RegionSize", "State", "Type", "AllocationProtect", "Protect");
+  for (p = 0;; p = (char *)mi.BaseAddress + mi.RegionSize) {
+    bzero(&mi, sizeof(mi));
+    if (!VirtualQueryEx(hProcess, p, &mi, sizeof(mi)))
+      break;
+    sizefmt(b[0], mi.RegionSize, 1024);
+    kprintf("%.12lx %.12lx %10s %16s %16s %32s %32s%s\n", mi.AllocationBase,
+            mi.BaseAddress, b[0], DescribeNtMemState(b[1], mi.State),
+            DescribeNtMemType(b[2], mi.Type),
+            _DescribeNtPageFlags(b[3], mi.AllocationProtect),
+            _DescribeNtPageFlags(b[4], mi.Protect),
+            (mi.State != kNtMemFree &&
+             MAX(addr, (const char *)mi.BaseAddress) <
+                 MIN(addr + size, (const char *)mi.BaseAddress + mi.RegionSize))
+                ? " [OVERLAPS]"
+                : "");
+  }
+}
diff --git a/libc/intrin/promises.c b/libc/intrin/promises.c
index a04f9cd8a..99778d9b5 100644
--- a/libc/intrin/promises.c
+++ b/libc/intrin/promises.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/pledge.h"
-#include "libc/intrin/promises.internal.h"
+#include "libc/intrin/promises.h"
 
 // XXX: should be inherited thread local
 //      see also sys_pledge_linux() which is 100% pure
diff --git a/libc/intrin/promises.internal.h b/libc/intrin/promises.h
similarity index 100%
rename from libc/intrin/promises.internal.h
rename to libc/intrin/promises.h
diff --git a/libc/intrin/prot2nt.greg.c b/libc/intrin/prot2nt.greg.c
index 67a59430b..569786b9b 100644
--- a/libc/intrin/prot2nt.greg.c
+++ b/libc/intrin/prot2nt.greg.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/directmap.h"
 #include "libc/nt/enum/pageflags.h"
 #include "libc/sysv/consts/prot.h"
 
@@ -42,6 +42,8 @@ privileged int __prot2nt(int prot, int iscow) {
         return kNtPageExecuteReadwrite;
       }
     default:
+      if (prot & PROT_GUARD)
+        return kNtPageReadwrite | kNtPageGuard;
       return kNtPageNoaccess;
   }
 }
diff --git a/libc/intrin/psraw.c b/libc/intrin/psraw.c
deleted file mode 100644
index 0ea62c129..000000000
--- a/libc/intrin/psraw.c
+++ /dev/null
@@ -1,35 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/psraw.h"
-
-/**
- * Divides shorts by two power.
- *
- * @note c needs to be a literal, asmconstexpr, or linkconstsym
- * @note arithmetic shift right will sign extend negatives
- * @mayalias
- */
-void(psraw)(int16_t a[8], const int16_t b[8], unsigned char k) {
-  unsigned i;
-  if (k > 15)
-    k = 15;
-  for (i = 0; i < 8; ++i) {
-    a[i] = b[i] >> k;
-  }
-}
diff --git a/libc/intrin/psraw.h b/libc/intrin/psraw.h
deleted file mode 100644
index 4814b073c..000000000
--- a/libc/intrin/psraw.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PSRAW_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PSRAW_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void psraw(int16_t[8], const int16_t[8], unsigned char) libcesque;
-void psrawv(int16_t[8], const int16_t[8], const uint64_t[2]) libcesque;
-
-#define psraw(A, B, I) INTRIN_SSEVEX_X_I_(psraw, SSE2, "psraw", A, B, I)
-#define psrawv(A, B, C) \
-  INTRIN_SSEVEX_X_X_X_(psrawv, SSE2, "psraw", INTRIN_NONCOMMUTATIVE, A, B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PSRAW_H_ */
diff --git a/libc/intrin/psrawv.c b/libc/intrin/psrawv.c
deleted file mode 100644
index 5409db233..000000000
--- a/libc/intrin/psrawv.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/psraw.h"
-
-/**
- * Divides shorts by two power.
- *
- * @note arithmetic shift right will sign extend negatives
- * @mayalias
- */
-void(psrawv)(int16_t a[8], const int16_t b[8], const uint64_t c[2]) {
-  unsigned i;
-  unsigned char k;
-  k = c[0] > 15 ? 15 : c[0];
-  for (i = 0; i < 8; ++i) {
-    a[i] = b[i] >> k;
-  }
-}
diff --git a/libc/intrin/pthread_atfork.c b/libc/intrin/pthread_atfork.c
deleted file mode 100644
index 5093ed594..000000000
--- a/libc/intrin/pthread_atfork.c
+++ /dev/null
@@ -1,77 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/weaken.h"
-#include "libc/thread/posixthread.internal.h"
-#include "libc/thread/thread.h"
-
-/**
- * Registers fork() handlers.
- *
- * Parent and child functions are called in the same order they're
- * registered. Prepare functions are called in reverse order.
- *
- * Here's an example of how pthread_atfork() can be used:
- *
- *     static struct {
- *       pthread_once_t once;
- *       pthread_mutex_t lock;
- *       // data structures...
- *     } g_lib;
- *
- *     static void lib_wipe(void) {
- *       pthread_mutex_init(&g_lib.lock, 0);
- *     }
- *
- *     static void lib_lock(void) {
- *       pthread_mutex_lock(&g_lib.lock);
- *     }
- *
- *     static void lib_unlock(void) {
- *       pthread_mutex_unlock(&g_lib.lock);
- *     }
- *
- *     static void lib_setup(void) {
- *       lib_wipe();
- *       pthread_atfork(lib_lock, lib_unlock, lib_wipe);
- *     }
- *
- *     static void lib_init(void) {
- *       pthread_once(&g_lib.once, lib_setup);
- *     }
- *
- *     void lib(void) {
- *       lib_init();
- *       lib_lock();
- *       // do stuff...
- *       lib_unlock();
- *     }
- *
- * @param prepare is run by fork() before forking happens
- * @param parent is run by fork() after forking happens in parent process
- * @param child is run by fork() after forking happens in childe process
- * @return 0 on success, or errno on error
- * @raise ENOMEM if we require more vespene gas
- */
-int pthread_atfork(atfork_f prepare, atfork_f parent, atfork_f child) {
-  if (_weaken(_pthread_atfork)) {
-    return _weaken(_pthread_atfork)(prepare, parent, child);
-  } else {
-    return 0;
-  }
-}
diff --git a/libc/intrin/pthread_delay_np.c b/libc/intrin/pthread_delay_np.c
new file mode 100644
index 000000000..03d51f08d
--- /dev/null
+++ b/libc/intrin/pthread_delay_np.c
@@ -0,0 +1,40 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/strace.h"
+#include "libc/thread/thread.h"
+
+/**
+ * Delays execution for brief moment.
+ *
+ * @param symbol may be used to strace names of static locks
+ * @param backoff should start at zero and be feed back in
+ * @return new value for backoff
+ */
+int pthread_delay_np(const void *symbol, int backoff) {
+  if (backoff < 7) {
+    volatile int i;
+    for (i = 0; i != 1 << backoff; i++) {
+    }
+    backoff++;
+  } else {
+    STRACE("pthread_delay_np(%t)", symbol);
+    pthread_yield_np();
+  }
+  return backoff;
+}
diff --git a/libc/intrin/pthread_mutex_lock.c b/libc/intrin/pthread_mutex_lock.c
index c3cea69bd..8ee1daa12 100644
--- a/libc/intrin/pthread_mutex_lock.c
+++ b/libc/intrin/pthread_mutex_lock.c
@@ -16,41 +16,220 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
+#include "libc/calls/blockcancel.internal.h"
 #include "libc/calls/state.internal.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
+#include "libc/macros.h"
 #include "libc/runtime/internal.h"
+#include "libc/thread/lock.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 #include "third_party/nsync/mu.h"
 
+static errno_t pthread_mutex_lock_normal_success(pthread_mutex_t *mutex,
+                                                 uint64_t word) {
+  if (IsModeDbg() || MUTEX_TYPE(word) == PTHREAD_MUTEX_ERRORCHECK) {
+    __deadlock_track(mutex, MUTEX_TYPE(word) == PTHREAD_MUTEX_ERRORCHECK);
+    __deadlock_record(mutex, MUTEX_TYPE(word) == PTHREAD_MUTEX_ERRORCHECK);
+  }
+  return 0;
+}
+
+// see "take 3" algorithm in "futexes are tricky" by ulrich drepper
+// slightly improved to attempt acquiring multiple times b4 syscall
+static int pthread_mutex_lock_drepper(pthread_mutex_t *mutex, uint64_t word,
+                                      bool is_trylock) {
+  int val = 0;
+  if (atomic_compare_exchange_strong_explicit(
+          &mutex->_futex, &val, 1, memory_order_acquire, memory_order_acquire))
+    return pthread_mutex_lock_normal_success(mutex, word);
+  if (is_trylock)
+    return EBUSY;
+  LOCKTRACE("acquiring pthread_mutex_lock_drepper(%t)...", mutex);
+  if (val == 1)
+    val = atomic_exchange_explicit(&mutex->_futex, 2, memory_order_acquire);
+  BLOCK_CANCELATION;
+  while (val > 0) {
+    cosmo_futex_wait(&mutex->_futex, 2, MUTEX_PSHARED(word), 0, 0);
+    val = atomic_exchange_explicit(&mutex->_futex, 2, memory_order_acquire);
+  }
+  ALLOW_CANCELATION;
+  return pthread_mutex_lock_normal_success(mutex, word);
+}
+
+static errno_t pthread_mutex_lock_recursive(pthread_mutex_t *mutex,
+                                            uint64_t word, bool is_trylock) {
+  uint64_t lock;
+  int backoff = 0;
+  int me = atomic_load_explicit(&__get_tls()->tib_ptid, memory_order_relaxed);
+  bool once = false;
+  for (;;) {
+    if (MUTEX_OWNER(word) == me) {
+      if (MUTEX_DEPTH(word) < MUTEX_DEPTH_MAX) {
+        if (atomic_compare_exchange_weak_explicit(
+                &mutex->_word, &word, MUTEX_INC_DEPTH(word),
+                memory_order_relaxed, memory_order_relaxed))
+          return 0;
+        continue;
+      } else {
+        return EAGAIN;
+      }
+    }
+    if (IsModeDbg())
+      __deadlock_check(mutex, 0);
+    word = MUTEX_UNLOCK(word);
+    lock = MUTEX_LOCK(word);
+    lock = MUTEX_SET_OWNER(lock, me);
+    if (atomic_compare_exchange_weak_explicit(&mutex->_word, &word, lock,
+                                              memory_order_acquire,
+                                              memory_order_relaxed)) {
+      if (IsModeDbg()) {
+        __deadlock_track(mutex, 0);
+        __deadlock_record(mutex, 0);
+      }
+      mutex->_pid = __pid;
+      return 0;
+    }
+    if (is_trylock)
+      return EBUSY;
+    if (!once) {
+      LOCKTRACE("acquiring pthread_mutex_lock_recursive(%t)...", mutex);
+      once = true;
+    }
+    for (;;) {
+      word = atomic_load_explicit(&mutex->_word, memory_order_relaxed);
+      if (MUTEX_OWNER(word) == me)
+        break;
+      if (word == MUTEX_UNLOCK(word))
+        break;
+      backoff = pthread_delay_np(mutex, backoff);
+    }
+  }
+}
+
+#if PTHREAD_USE_NSYNC
+static errno_t pthread_mutex_lock_recursive_nsync(pthread_mutex_t *mutex,
+                                                  uint64_t word,
+                                                  bool is_trylock) {
+  int me = atomic_load_explicit(&__get_tls()->tib_ptid, memory_order_relaxed);
+  for (;;) {
+    if (MUTEX_OWNER(word) == me) {
+      if (MUTEX_DEPTH(word) < MUTEX_DEPTH_MAX) {
+        if (atomic_compare_exchange_weak_explicit(
+                &mutex->_word, &word, MUTEX_INC_DEPTH(word),
+                memory_order_relaxed, memory_order_relaxed))
+          return 0;
+        continue;
+      } else {
+        return EAGAIN;
+      }
+    }
+    if (IsModeDbg())
+      __deadlock_check(mutex, 0);
+    if (!is_trylock) {
+      _weaken(nsync_mu_lock)((nsync_mu *)mutex->_nsync);
+    } else {
+      if (!_weaken(nsync_mu_trylock)((nsync_mu *)mutex->_nsync))
+        return EBUSY;
+    }
+    if (IsModeDbg()) {
+      __deadlock_track(mutex, 0);
+      __deadlock_record(mutex, 0);
+    }
+    word = MUTEX_UNLOCK(word);
+    word = MUTEX_LOCK(word);
+    word = MUTEX_SET_OWNER(word, me);
+    mutex->_word = word;
+    mutex->_pid = __pid;
+    return 0;
+  }
+}
+#endif
+
+static errno_t pthread_mutex_lock_impl(pthread_mutex_t *mutex,
+                                       bool is_trylock) {
+  uint64_t word = atomic_load_explicit(&mutex->_word, memory_order_relaxed);
+
+  // handle recursive mutexes
+  if (MUTEX_TYPE(word) == PTHREAD_MUTEX_RECURSIVE) {
+#if PTHREAD_USE_NSYNC
+    if (_weaken(nsync_mu_lock) &&
+        MUTEX_PSHARED(word) == PTHREAD_PROCESS_PRIVATE) {
+      return pthread_mutex_lock_recursive_nsync(mutex, word, is_trylock);
+    } else {
+      return pthread_mutex_lock_recursive(mutex, word, is_trylock);
+    }
+#else
+    return pthread_mutex_lock_recursive(mutex, word, is_trylock);
+#endif
+  }
+
+  // check if normal mutex is already owned by calling thread
+  if (!is_trylock &&
+      (MUTEX_TYPE(word) == PTHREAD_MUTEX_ERRORCHECK ||
+       (IsModeDbg() && MUTEX_TYPE(word) == PTHREAD_MUTEX_DEFAULT))) {
+    if (__deadlock_tracked(mutex) == 1) {
+      if (IsModeDbg() && MUTEX_TYPE(word) != PTHREAD_MUTEX_ERRORCHECK) {
+        kprintf("error: attempted to lock non-recursive mutex that's already "
+                "held by the calling thread: %t\n",
+                mutex);
+        DebugBreak();
+      }
+      return EDEADLK;
+    }
+  }
+
+  // check if locking will create cycle in lock graph
+  if (IsModeDbg() || MUTEX_TYPE(word) == PTHREAD_MUTEX_ERRORCHECK)
+    if (__deadlock_check(mutex, MUTEX_TYPE(word) == PTHREAD_MUTEX_ERRORCHECK))
+      return EDEADLK;
+
+#if PTHREAD_USE_NSYNC
+  // use superior mutexes if possible
+  if (MUTEX_PSHARED(word) == PTHREAD_PROCESS_PRIVATE &&
+      _weaken(nsync_mu_lock)) {
+    // on apple silicon we should just put our faith in ulock
+    // otherwise *nsync gets struck down by the eye of sauron
+    if (!IsXnuSilicon()) {
+      if (!is_trylock) {
+        _weaken(nsync_mu_lock)((nsync_mu *)mutex->_nsync);
+        return pthread_mutex_lock_normal_success(mutex, word);
+      } else {
+        if (_weaken(nsync_mu_trylock)((nsync_mu *)mutex->_nsync))
+          return pthread_mutex_lock_normal_success(mutex, word);
+        return EBUSY;
+      }
+    }
+  }
+#endif
+
+  // isc licensed non-recursive mutex implementation
+  return pthread_mutex_lock_drepper(mutex, word, is_trylock);
+}
+
 /**
- * Locks mutex.
- *
- * Here's an example of using a normal mutex:
+ * Locks mutex, e.g.
  *
  *     pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
  *     pthread_mutex_lock(&lock);
  *     // do work...
  *     pthread_mutex_unlock(&lock);
- *     pthread_mutex_destroy(&lock);
  *
- * Cosmopolitan permits succinct notation for normal mutexes:
- *
- *     pthread_mutex_t lock = {0};
- *     pthread_mutex_lock(&lock);
- *     // do work...
- *     pthread_mutex_unlock(&lock);
- *
- * Here's an example of the proper way to do recursive mutexes:
+ * The long way to do that is:
  *
  *     pthread_mutex_t lock;
  *     pthread_mutexattr_t attr;
  *     pthread_mutexattr_init(&attr);
- *     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+ *     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
+ *     pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_PRIVATE);
  *     pthread_mutex_init(&lock, &attr);
  *     pthread_mutexattr_destroy(&attr);
  *     pthread_mutex_lock(&lock);
@@ -58,56 +237,101 @@
  *     pthread_mutex_unlock(&lock);
  *     pthread_mutex_destroy(&lock);
  *
- * This function does nothing in vfork() children.
+ * The following non-POSIX initializers are also provided by cosmo libc:
+ *
+ * - `PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP`
+ * - `PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP`
+ * - `PTHREAD_NORMAL_MUTEX_INITIALIZER_NP`
+ *
+ * Locking a mutex that's already locked by the calling thread will make
+ * the thread hang indefinitely, i.e. it's a deadlock condition. You can
+ * use `PTHREAD_MUTEX_RECURSIVE` to allow recursive locking, which could
+ * result in somewhat less performance. An alternative solution is using
+ * the `PTHREAD_MUTEX_ERRORCHECK` mode, which raises `EDEADLK` for that.
+ *
+ * If a thread locks a mutex while other mutexes are already locked then
+ * you need to observe a consistent global ordering, otherwise deadlocks
+ * might occur. The Cosmopolitan runtime can detect these cycles quickly
+ * so you can fix your code before it becomes an issue. With error check
+ * mode, an EPERM will be returned. If your app is using `cosmocc -mdbg`
+ * then an error message will be printed including the demangled symbols
+ * of the mutexes in the strongly connected component that was detected.
+ * Please note that, even for debug builds mutexes set to explicitly use
+ * the `PTHREAD_MUTEX_ERRORCHECK` mode will return an error code instead
+ * which means the cosmo debug mode only influences undefined behaviors.
+ *
+ * Cosmopolitan only supports error checking on mutexes stored in static
+ * memory, i.e. your `mutex` pointer must point inside the .data or .bss
+ * sections of your executable. When compiling your programs using -mdbg
+ * all your locks will gain error checking automatically. When deadlocks
+ * are detected an error message will be printed and a SIGTRAP signal is
+ * raised, which may be ignored to force EDEADLK and EPERM to be raised.
+ *
+ * Using `cosmocc -mdbg` also enhances `--strace` with information about
+ * mutexes. First, locks and unlocks will be logged. Since the lock line
+ * only appears after the lock is acquired, that might mean you'll never
+ * get an indication about a lock that takes a very long time to acquire
+ * so, whenever a lock can't immediately be acquired, a second line gets
+ * printed *before* the lock is acquired to let you know that the thread
+ * is waiting for a particular lock. If your mutex object resides within
+ * static memory, then its demangled symbol name will be printed. If you
+ * call ShowCrashReports() at the beginning of your main() function then
+ * you'll also see a backtrace when a locking violation occurs. When the
+ * symbols in the violation error messages show up as numbers, and it is
+ * desirable to see demangled symbols without enabling full crash report
+ * functionality the GetSymbolTable() function may be called for effect.
+ *
+ * If you use `PTHREAD_MUTEX_NORMAL`, instead of `PTHREAD_MUTEX_DEFAULT`
+ * then deadlocking is actually defined behavior according to POSIX.1 so
+ * the helpfulness of `cosmocc -mdbg` will be somewhat weakened.
+ *
+ * If your `mutex` object resides in `MAP_SHARED` memory, then undefined
+ * behavior will happen unless you use `PTHREAD_PROCESS_SHARED` mode, if
+ * the lock is used by multiple processes.
+ *
+ * This function does nothing when the process is in vfork() mode.
  *
  * @return 0 on success, or error number on failure
+ * @raise EDEADLK if mutex is recursive and locked by another thread
+ * @raise EDEADLK if mutex is non-recursive and locked by current thread
+ * @raise EDEADLK if cycle is detected in global nested lock graph
+ * @raise EAGAIN if maximum recursive locks is exceeded
  * @see pthread_spin_lock()
  * @vforksafe
  */
-errno_t pthread_mutex_lock(pthread_mutex_t *mutex) {
-  int t;
-
-  LOCKTRACE("pthread_mutex_lock(%t)", mutex);
-
-  if (__vforked) {
+errno_t _pthread_mutex_lock(pthread_mutex_t *mutex) {
+  if (__tls_enabled && !__vforked) {
+    errno_t err = pthread_mutex_lock_impl(mutex, false);
+    LOCKTRACE("pthread_mutex_lock(%t) → %s", mutex, DescribeErrno(err));
+    return err;
+  } else {
+    LOCKTRACE("skipping pthread_mutex_lock(%t) due to runtime state", mutex);
     return 0;
   }
-
-  if (mutex->_type == PTHREAD_MUTEX_NORMAL &&        //
-      mutex->_pshared == PTHREAD_PROCESS_PRIVATE &&  //
-      _weaken(nsync_mu_lock)) {
-    _weaken(nsync_mu_lock)((nsync_mu *)mutex);
-    return 0;
-  }
-
-  if (mutex->_type == PTHREAD_MUTEX_NORMAL) {
-    while (atomic_exchange_explicit(&mutex->_lock, 1, memory_order_acquire)) {
-      pthread_pause_np();
-    }
-    return 0;
-  }
-
-  t = gettid();
-  if (mutex->_owner == t) {
-    if (mutex->_type != PTHREAD_MUTEX_ERRORCHECK) {
-      if (mutex->_depth < 63) {
-        ++mutex->_depth;
-        return 0;
-      } else {
-        return EAGAIN;
-      }
-    } else {
-      return EDEADLK;
-    }
-  }
-
-  while (atomic_exchange_explicit(&mutex->_lock, 1, memory_order_acquire)) {
-    pthread_pause_np();
-  }
-
-  mutex->_depth = 0;
-  mutex->_owner = t;
-  mutex->_pid = __pid;
-
-  return 0;
 }
+
+/**
+ * Attempts acquiring lock.
+ *
+ * Unlike pthread_mutex_lock() this function won't block and instead
+ * returns an error immediately if the lock couldn't be acquired.
+ *
+ * @return 0 if lock was acquired, otherwise an errno
+ * @raise EBUSY if lock is currently held by another thread
+ * @raise EAGAIN if maximum number of recursive locks is held
+ * @raise EDEADLK if `mutex` is `PTHREAD_MUTEX_ERRORCHECK` and the
+ *     current thread already holds this mutex
+ */
+errno_t _pthread_mutex_trylock(pthread_mutex_t *mutex) {
+  if (__tls_enabled && !__vforked) {
+    errno_t err = pthread_mutex_lock_impl(mutex, true);
+    LOCKTRACE("pthread_mutex_trylock(%t) → %s", mutex, DescribeErrno(err));
+    return err;
+  } else {
+    LOCKTRACE("skipping pthread_mutex_trylock(%t) due to runtime state", mutex);
+    return 0;
+  }
+}
+
+__weak_reference(_pthread_mutex_lock, pthread_mutex_lock);
+__weak_reference(_pthread_mutex_trylock, pthread_mutex_trylock);
diff --git a/libc/intrin/pthread_mutex_trylock.c b/libc/intrin/pthread_mutex_trylock.c
deleted file mode 100644
index ff0734a54..000000000
--- a/libc/intrin/pthread_mutex_trylock.c
+++ /dev/null
@@ -1,87 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/errno.h"
-#include "libc/intrin/atomic.h"
-#include "libc/intrin/weaken.h"
-#include "libc/runtime/internal.h"
-#include "libc/thread/thread.h"
-#include "third_party/nsync/mu.h"
-
-/**
- * Attempts acquiring lock.
- *
- * Unlike pthread_mutex_lock() this function won't block and instead
- * returns an error immediately if the lock couldn't be acquired.
- *
- * @return 0 if lock was acquired, otherwise an errno
- * @raise EAGAIN if maximum number of recursive locks is held
- * @raise EBUSY if lock is currently held in read or write mode
- * @raise EINVAL if `mutex` doesn't refer to an initialized lock
- * @raise EDEADLK if `mutex` is `PTHREAD_MUTEX_ERRORCHECK` and the
- *     current thread already holds this mutex
- */
-errno_t pthread_mutex_trylock(pthread_mutex_t *mutex) {
-  int t;
-
-  // delegate to *NSYNC if possible
-  if (mutex->_type == PTHREAD_MUTEX_NORMAL &&
-      mutex->_pshared == PTHREAD_PROCESS_PRIVATE &&  //
-      _weaken(nsync_mu_trylock)) {
-    if (_weaken(nsync_mu_trylock)((nsync_mu *)mutex)) {
-      return 0;
-    } else {
-      return EBUSY;
-    }
-  }
-
-  // handle normal mutexes
-  if (mutex->_type == PTHREAD_MUTEX_NORMAL) {
-    if (!atomic_exchange_explicit(&mutex->_lock, 1, memory_order_acquire)) {
-      return 0;
-    } else {
-      return EBUSY;
-    }
-  }
-
-  // handle recursive and error check mutexes
-  t = gettid();
-  if (mutex->_owner == t) {
-    if (mutex->_type != PTHREAD_MUTEX_ERRORCHECK) {
-      if (mutex->_depth < 63) {
-        ++mutex->_depth;
-        return 0;
-      } else {
-        return EAGAIN;
-      }
-    } else {
-      return EDEADLK;
-    }
-  }
-
-  if (atomic_exchange_explicit(&mutex->_lock, 1, memory_order_acquire)) {
-    return EBUSY;
-  }
-
-  mutex->_depth = 0;
-  mutex->_owner = t;
-  mutex->_pid = __pid;
-
-  return 0;
-}
diff --git a/libc/intrin/pthread_mutex_unlock.c b/libc/intrin/pthread_mutex_unlock.c
index 9ca401ec4..25525dccb 100644
--- a/libc/intrin/pthread_mutex_unlock.c
+++ b/libc/intrin/pthread_mutex_unlock.c
@@ -17,56 +17,166 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/state.internal.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/internal.h"
+#include "libc/thread/lock.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
+#include "libc/thread/tls.h"
 #include "third_party/nsync/mu.h"
 
+// see "take 3" algorithm in "futexes are tricky" by ulrich drepper
+static void pthread_mutex_unlock_drepper(atomic_int *futex, char pshare) {
+  int word = atomic_fetch_sub_explicit(futex, 1, memory_order_release);
+  if (word == 2) {
+    atomic_store_explicit(futex, 0, memory_order_release);
+    cosmo_futex_wake(futex, 1, pshare);
+  }
+}
+
+static errno_t pthread_mutex_unlock_recursive(pthread_mutex_t *mutex,
+                                              uint64_t word) {
+  int me = atomic_load_explicit(&__get_tls()->tib_ptid, memory_order_relaxed);
+  for (;;) {
+
+    // we allow unlocking an initialized lock that wasn't locked, but we
+    // don't allow unlocking a lock held by another thread, or unlocking
+    // recursive locks from a forked child, since it should be re-init'd
+    if (MUTEX_OWNER(word) && (MUTEX_OWNER(word) != me || mutex->_pid != __pid))
+      return EPERM;
+
+    // check if this is a nested lock with signal safety
+    if (MUTEX_DEPTH(word)) {
+      if (atomic_compare_exchange_weak_explicit(
+              &mutex->_word, &word, MUTEX_DEC_DEPTH(word), memory_order_relaxed,
+              memory_order_relaxed))
+        return 0;
+      continue;
+    }
+
+    // actually unlock the mutex
+    if (atomic_compare_exchange_weak_explicit(
+            &mutex->_word, &word, MUTEX_UNLOCK(word), memory_order_release,
+            memory_order_relaxed)) {
+      if (IsModeDbg())
+        __deadlock_untrack(mutex);
+      return 0;
+    }
+  }
+}
+
+#if PTHREAD_USE_NSYNC
+static errno_t pthread_mutex_unlock_recursive_nsync(pthread_mutex_t *mutex,
+                                                    uint64_t word) {
+  int me = atomic_load_explicit(&__get_tls()->tib_ptid, memory_order_relaxed);
+  for (;;) {
+
+    // we allow unlocking an initialized lock that wasn't locked, but we
+    // don't allow unlocking a lock held by another thread, or unlocking
+    // recursive locks from a forked child, since it should be re-init'd
+    if (MUTEX_OWNER(word) && (MUTEX_OWNER(word) != me || mutex->_pid != __pid))
+      return EPERM;
+
+    // check if this is a nested lock with signal safety
+    if (MUTEX_DEPTH(word)) {
+      if (atomic_compare_exchange_strong_explicit(
+              &mutex->_word, &word, MUTEX_DEC_DEPTH(word), memory_order_relaxed,
+              memory_order_relaxed))
+        return 0;
+      continue;
+    }
+
+    // actually unlock the mutex
+    mutex->_word = MUTEX_UNLOCK(word);
+    _weaken(nsync_mu_unlock)((nsync_mu *)mutex->_nsync);
+    if (IsModeDbg())
+      __deadlock_untrack(mutex);
+    return 0;
+  }
+}
+#endif
+
+static errno_t pthread_mutex_unlock_impl(pthread_mutex_t *mutex) {
+  uint64_t word = atomic_load_explicit(&mutex->_word, memory_order_relaxed);
+
+  // check if mutex isn't held by calling thread
+  if (MUTEX_TYPE(word) == PTHREAD_MUTEX_ERRORCHECK || IsModeDbg()) {
+    if (__deadlock_tracked(mutex) == 0) {
+      if (IsModeDbg() && MUTEX_TYPE(word) != PTHREAD_MUTEX_ERRORCHECK) {
+        kprintf("error: unlock mutex not owned by calling thread: %t\n", mutex);
+        DebugBreak();
+      }
+      return EPERM;
+    }
+  }
+
+  // handle recursive mutexes
+  if (MUTEX_TYPE(word) == PTHREAD_MUTEX_RECURSIVE) {
+#if PTHREAD_USE_NSYNC
+    if (_weaken(nsync_mu_unlock) &&
+        MUTEX_PSHARED(word) == PTHREAD_PROCESS_PRIVATE) {
+      return pthread_mutex_unlock_recursive_nsync(mutex, word);
+    } else {
+      return pthread_mutex_unlock_recursive(mutex, word);
+    }
+#else
+    return pthread_mutex_unlock_recursive(mutex, word);
+#endif
+  }
+
+#if PTHREAD_USE_NSYNC
+  // use superior mutexes if possible
+  if (MUTEX_PSHARED(word) == PTHREAD_PROCESS_PRIVATE &&  //
+      _weaken(nsync_mu_unlock)) {
+    // on apple silicon we should just put our faith in ulock
+    // otherwise *nsync gets struck down by the eye of sauron
+    if (!IsXnuSilicon()) {
+      _weaken(nsync_mu_unlock)((nsync_mu *)mutex->_nsync);
+      if (MUTEX_TYPE(word) == PTHREAD_MUTEX_ERRORCHECK || IsModeDbg())
+        __deadlock_untrack(mutex);
+      return 0;
+    }
+  }
+#endif
+
+  // implement barebones normal mutexes
+  pthread_mutex_unlock_drepper(&mutex->_futex, MUTEX_PSHARED(word));
+  if (MUTEX_TYPE(word) == PTHREAD_MUTEX_ERRORCHECK || IsModeDbg())
+    __deadlock_untrack(mutex);
+  return 0;
+}
+
 /**
  * Releases mutex.
  *
+ * POSIX.1 says it's undefined behavior to unlock a mutex that wasn't
+ * locked by the calling thread. Therefore, if `mutex` isn't locked, or
+ * it is locked and the thing that locked it was a different thread or
+ * process, then you should expect your program to deadlock or crash.
+ *
  * This function does nothing in vfork() children.
  *
  * @return 0 on success or error number on failure
- * @raises EPERM if in error check mode and not owned by caller
+ * @raises EPERM if mutex ownership isn't acceptable
  * @vforksafe
  */
-errno_t pthread_mutex_unlock(pthread_mutex_t *mutex) {
-  int t;
-
-  LOCKTRACE("pthread_mutex_unlock(%t)", mutex);
-
-  if (mutex->_type == PTHREAD_MUTEX_NORMAL &&        //
-      mutex->_pshared == PTHREAD_PROCESS_PRIVATE &&  //
-      _weaken(nsync_mu_unlock)) {
-    _weaken(nsync_mu_unlock)((nsync_mu *)mutex);
+errno_t _pthread_mutex_unlock(pthread_mutex_t *mutex) {
+  if (__tls_enabled && !__vforked) {
+    errno_t err = pthread_mutex_unlock_impl(mutex);
+    LOCKTRACE("pthread_mutex_unlock(%t) → %s", mutex, DescribeErrno(err));
+    return err;
+  } else {
+    LOCKTRACE("skipping pthread_mutex_lock(%t) due to runtime state", mutex);
     return 0;
   }
-
-  if (mutex->_type == PTHREAD_MUTEX_NORMAL) {
-    atomic_store_explicit(&mutex->_lock, 0, memory_order_release);
-    return 0;
-  }
-
-  t = gettid();
-
-  // we allow unlocking an initialized lock that wasn't locked, but we
-  // don't allow unlocking a lock held by another thread, or unlocking
-  // recursive locks from a forked child, since it should be re-init'd
-  if (mutex->_owner && (mutex->_owner != t || mutex->_pid != __pid)) {
-    return EPERM;
-  }
-
-  if (mutex->_depth) {
-    --mutex->_depth;
-    return 0;
-  }
-
-  mutex->_owner = 0;
-  atomic_store_explicit(&mutex->_lock, 0, memory_order_release);
-
-  return 0;
 }
+
+__weak_reference(_pthread_mutex_unlock, pthread_mutex_unlock);
diff --git a/libc/intrin/pthread_mutex_wipe_np.c b/libc/intrin/pthread_mutex_wipe_np.c
new file mode 100644
index 000000000..9c19f6d0a
--- /dev/null
+++ b/libc/intrin/pthread_mutex_wipe_np.c
@@ -0,0 +1,39 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/atomic.h"
+#include "libc/str/str.h"
+#include "libc/thread/lock.h"
+#include "libc/thread/posixthread.internal.h"
+#include "libc/thread/thread.h"
+
+/**
+ * Unlocks mutex from child process after fork.
+ */
+int _pthread_mutex_wipe_np(pthread_mutex_t *mutex) {
+  atomic_init(&mutex->_word, MUTEX_UNLOCK(atomic_load_explicit(
+                                 &mutex->_word, memory_order_relaxed)));
+  atomic_init(&mutex->_futex, 0);
+  mutex->_pid = 0;
+  mutex->_nsync[0] = 0;
+  atomic_signal_fence(memory_order_relaxed);  // avoid xmm
+  mutex->_nsync[1] = 0;
+  return 0;
+}
+
+__weak_reference(_pthread_mutex_wipe_np, pthread_mutex_wipe_np);
diff --git a/libc/intrin/pthread_orphan_np.c b/libc/intrin/pthread_orphan_np.c
index 68e2a9f5f..1575502f1 100644
--- a/libc/intrin/pthread_orphan_np.c
+++ b/libc/intrin/pthread_orphan_np.c
@@ -16,6 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/intrin/atomic.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 
@@ -28,5 +30,6 @@ int pthread_orphan_np(void) {
   res = _pthread_list == _pthread_list->prev &&
         _pthread_list == _pthread_list->next;
   _pthread_unlock();
+  unassert(!res || atomic_load(&_pthread_count) <= 1);
   return res;
 }
diff --git a/libc/intrin/pthread_pause_np.c b/libc/intrin/pthread_pause_np.c
index ceb85d242..8f5c399c1 100644
--- a/libc/intrin/pthread_pause_np.c
+++ b/libc/intrin/pthread_pause_np.c
@@ -16,15 +16,23 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/thread/thread.h"
+#ifdef _MSC_VER
+#include <intrin.h>
+#else
+#include <xmmintrin.h>
+#endif
 
 /**
  * Yields hyperthread.
  */
 void pthread_pause_np(void) {
 #if defined(__GNUC__) && defined(__aarch64__)
-  __asm__ volatile("yield");
-#elif defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
-  __asm__ volatile("pause");
+  __asm__("yield");
+#elif defined(__x86_64__) || defined(__i386__)
+  _mm_pause();
+#elif defined(__GNUC__) && (defined(__PPC__) || defined(__PPC64__))
+  __asm__("or 27,27,27");
+#else
+  // do nothing
 #endif
 }
diff --git a/libc/intrin/pthread_setcancelstate.c b/libc/intrin/pthread_setcancelstate.c
index ae8f9a129..6e2a35f35 100644
--- a/libc/intrin/pthread_setcancelstate.c
+++ b/libc/intrin/pthread_setcancelstate.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
@@ -47,28 +47,30 @@
  * @asyncsignalsafe
  */
 errno_t pthread_setcancelstate(int state, int *oldstate) {
+  int old;
   errno_t err;
   struct PosixThread *pt;
   if (__tls_enabled && (pt = _pthread_self())) {
+    if (pt->pt_flags & PT_NOCANCEL) {
+      old = PTHREAD_CANCEL_DISABLE;
+    } else if (pt->pt_flags & PT_MASKED) {
+      old = PTHREAD_CANCEL_MASKED;
+    } else {
+      old = PTHREAD_CANCEL_ENABLE;
+    }
     switch (state) {
       case PTHREAD_CANCEL_ENABLE:
-      case PTHREAD_CANCEL_DISABLE:
-      case PTHREAD_CANCEL_MASKED:
-        if (oldstate) {
-          if (pt->pt_flags & PT_NOCANCEL) {
-            *oldstate = PTHREAD_CANCEL_DISABLE;
-          } else if (pt->pt_flags & PT_MASKED) {
-            *oldstate = PTHREAD_CANCEL_MASKED;
-          } else {
-            *oldstate = PTHREAD_CANCEL_ENABLE;
-          }
-        }
         pt->pt_flags &= ~(PT_NOCANCEL | PT_MASKED);
-        if (state == PTHREAD_CANCEL_MASKED) {
-          pt->pt_flags |= PT_MASKED;
-        } else if (state == PTHREAD_CANCEL_DISABLE) {
-          pt->pt_flags |= PT_NOCANCEL;
-        }
+        err = 0;
+        break;
+      case PTHREAD_CANCEL_DISABLE:
+        pt->pt_flags &= ~(PT_NOCANCEL | PT_MASKED);
+        pt->pt_flags |= PT_NOCANCEL;
+        err = 0;
+        break;
+      case PTHREAD_CANCEL_MASKED:
+        pt->pt_flags &= ~(PT_NOCANCEL | PT_MASKED);
+        pt->pt_flags |= PT_MASKED;
         err = 0;
         break;
       default:
@@ -76,12 +78,13 @@ errno_t pthread_setcancelstate(int state, int *oldstate) {
         break;
     }
   } else {
-    if (oldstate) {
-      *oldstate = 0;
-    }
+    old = 0;
     err = 0;
   }
-#if IsModeDbg()
+  if (!err)
+    if (oldstate)
+      *oldstate = old;
+#if IsModeDbg() && 0
   STRACE("pthread_setcancelstate(%s, [%s]) → %s",
          DescribeCancelState(0, &state), DescribeCancelState(err, oldstate),
          DescribeErrno(err));
diff --git a/libc/intrin/pthread_spin_lock.c b/libc/intrin/pthread_spin_lock.c
deleted file mode 100644
index 4ce73139a..000000000
--- a/libc/intrin/pthread_spin_lock.c
+++ /dev/null
@@ -1,45 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/atomic.h"
-#include "libc/thread/thread.h"
-
-/**
- * Acquires spin lock, e.g.
- *
- *     pthread_spinlock_t lock;
- *     pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE);
- *     pthread_spin_lock(&lock);
- *     // do work...
- *     pthread_spin_unlock(&lock);
- *     pthread_spin_destroy(&lock);
- *
- * This function has undefined behavior when `spin` wasn't intialized,
- * was destroyed, or if the lock's already held by the calling thread.
- *
- * @return 0 on success, or errno on error
- * @see pthread_spin_trylock
- * @see pthread_spin_unlock
- * @see pthread_spin_init
- */
-errno_t pthread_spin_lock(pthread_spinlock_t *spin) {
-  while (atomic_exchange_explicit(&spin->_lock, 1, memory_order_acquire)) {
-    pthread_pause_np();
-  }
-  return 0;
-}
diff --git a/libc/intrin/pthread_syshand.c b/libc/intrin/pthread_syshand.c
index 856ce3323..b15460580 100644
--- a/libc/intrin/pthread_syshand.c
+++ b/libc/intrin/pthread_syshand.c
@@ -29,6 +29,6 @@ intptr_t _pthread_syshand(struct PosixThread *pt) {
     syshand = atomic_load_explicit(&pt->tib->tib_syshand, memory_order_acquire);
     if (syshand)
       return syshand;
-    pthread_pause_np();
+    pthread_yield_np();
   }
 }
diff --git a/libc/intrin/pthread_tid.c b/libc/intrin/pthread_tid.c
index 27e3ee5a1..fb9d22f44 100644
--- a/libc/intrin/pthread_tid.c
+++ b/libc/intrin/pthread_tid.c
@@ -21,9 +21,25 @@
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 
+//
+// - tib_ptid: always guaranteed to be non-zero in thread itself. on
+//             some platforms (e.g. xnu) the parent thread and other
+//             threads may need to wait for this value to be set. this
+//             is generally the value you want to read to get the tid.
+//
+// - tib_ctid: starts off as -1. once thread starts, it's set to the
+//             thread's tid before calling the thread callback. when
+//             thread is done executing, this is set to zero, and then
+//             this address is futex woken, in case the parent thread or
+//             any other thread is waiting on its completion. when a
+//             thread wants to read its own tid, it shouldn't use this,
+//             because the thread might need to do things after clearing
+//             its own tib_ctid (see pthread_exit() for static thread).
+//
 int _pthread_tid(struct PosixThread *pt) {
   int tid = 0;
-  while (pt && !(tid = atomic_load_explicit(&pt->ptid, memory_order_acquire)))
-    pthread_pause_np();
+  while (pt && !(tid = atomic_load_explicit(&pt->tib->tib_ptid,
+                                            memory_order_acquire)))
+    pthread_yield_np();
   return tid;
 }
diff --git a/libc/intrin/pthread_unref.c b/libc/intrin/pthread_unref.c
deleted file mode 100644
index 6ff6a7a5c..000000000
--- a/libc/intrin/pthread_unref.c
+++ /dev/null
@@ -1,35 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/intrin/atomic.h"
-#include "libc/intrin/weaken.h"
-#include "libc/thread/posixthread.internal.h"
-
-static bool _pthread_deref(struct PosixThread *pt) {
-  int refs = atomic_load_explicit(&pt->pt_refs, memory_order_acquire);
-  return !refs || !atomic_fetch_sub(&pt->pt_refs, 1);
-}
-
-void _pthread_unref(struct PosixThread *pt) {
-  if (_pthread_deref(pt)) {
-    unassert(_weaken(_pthread_free));
-    _weaken(_pthread_free)(pt, false);
-    _weaken(_pthread_decimate)();
-  }
-}
diff --git a/libc/calls/pthread_yield_np.c b/libc/intrin/pthread_yield_np.c
similarity index 91%
rename from libc/calls/pthread_yield_np.c
rename to libc/intrin/pthread_yield_np.c
index dd209e6be..4fa0c988c 100644
--- a/libc/calls/pthread_yield_np.c
+++ b/libc/intrin/pthread_yield_np.c
@@ -22,6 +22,8 @@
 #include "libc/runtime/syslib.internal.h"
 #include "libc/thread/thread.h"
 
+void sys_sched_yield(void);
+
 /**
  * Yields current thread's remaining timeslice to operating system.
  *
@@ -31,12 +33,15 @@ int pthread_yield_np(void) {
   if (IsXnuSilicon()) {
     __syslib->__pthread_yield_np();
   } else if (IsOpenbsd()) {
-    pthread_pause_np();  // sched_yield() is punishingly slow on OpenBSD
+    // sched_yield() is punishingly slow on OpenBSD
+    // it's ruinously slow it'll destroy everything
+    pthread_pause_np();
   } else {
-    sched_yield();
+    sys_sched_yield();
   }
   return 0;
 }
 
 __weak_reference(pthread_yield_np, thrd_yield);
+__weak_reference(pthread_yield_np, sched_yield);
 __weak_reference(pthread_yield_np, pthread_yield);
diff --git a/libc/intrin/pthreadlock.c b/libc/intrin/pthreadlock.c
index 3fd1d564a..085f5bba0 100644
--- a/libc/intrin/pthreadlock.c
+++ b/libc/intrin/pthreadlock.c
@@ -16,18 +16,15 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/stdalign.h"
 #include "libc/thread/posixthread.internal.h"
 
-pthread_spinlock_t _pthread_lock_obj;
-
-void _pthread_init(void) {
-  (void)pthread_spin_init(&_pthread_lock_obj, 0);
-}
+alignas(64) pthread_mutex_t __pthread_lock_obj = PTHREAD_MUTEX_INITIALIZER;
 
 void _pthread_lock(void) {
-  pthread_spin_lock(&_pthread_lock_obj);
+  _pthread_mutex_lock(&__pthread_lock_obj);
 }
 
 void _pthread_unlock(void) {
-  pthread_spin_unlock(&_pthread_lock_obj);
+  _pthread_mutex_unlock(&__pthread_lock_obj);
 }
diff --git a/libc/intrin/punpckhbw.c b/libc/intrin/punpckhbw.c
deleted file mode 100644
index 151530c77..000000000
--- a/libc/intrin/punpckhbw.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/punpckhbw.h"
-
-/**
- * Interleaves high bytes.
- *
- * @param 𝑎 [w/o] receives reduced 𝑏 and 𝑐 interleaved
- * @param 𝑏 [r/o] supplies eight words
- * @param 𝑐 [r/o] supplies eight words
- * @mayalias
- */
-void(punpckhbw)(uint8_t a[16], const uint8_t b[16], const uint8_t c[16]) {
-  a[0x0] = b[0x8];
-  a[0x1] = c[0x8];
-  a[0x2] = b[0x9];
-  a[0x3] = c[0x9];
-  a[0x4] = b[0xa];
-  a[0x5] = c[0xa];
-  a[0x6] = b[0xb];
-  a[0x7] = c[0xb];
-  a[0x8] = b[0xc];
-  a[0x9] = c[0xc];
-  a[0xa] = b[0xd];
-  a[0xb] = c[0xd];
-  a[0xc] = b[0xe];
-  a[0xd] = c[0xe];
-  a[0xe] = b[0xf];
-  a[0xf] = c[0xf];
-}
diff --git a/libc/intrin/punpckhbw.h b/libc/intrin/punpckhbw.h
deleted file mode 100644
index 306cb1597..000000000
--- a/libc/intrin/punpckhbw.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PUNPCKHBW_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PUNPCKHBW_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void punpckhbw(uint8_t[16], const uint8_t[16], const uint8_t[16]);
-
-#define punpckhbw(A, B, C)                                                     \
-  INTRIN_SSEVEX_X_X_X_(punpckhbw, SSE2, "punpckhbw", INTRIN_NONCOMMUTATIVE, A, \
-                       B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PUNPCKHBW_H_ */
diff --git a/libc/intrin/punpckhwd.c b/libc/intrin/punpckhwd.c
deleted file mode 100644
index 5aad8b10b..000000000
--- a/libc/intrin/punpckhwd.c
+++ /dev/null
@@ -1,49 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/punpckhwd.h"
-#include "libc/str/str.h"
-
-/**
- * Interleaves high words.
- *
- *          0  1  2  3  4  5  6  7
- *       B  aa bb cc dd EE FF GG HH
- *       C  ii jj kk ll MM NN OO PP
- *                      └┤ └┤ └┤ └┤
- *              ┌────────┘  │  │  │
- *              │     ┌─────┘  │  │
- *              │     │     ┌──┘  │
- *          ┌───┤ ┌───┤ ┌───┤ ┌───┤
- *     → A  EE MM FF NN GG OO HH PP
- *
- * @param 𝑎 [w/o] receives reduced 𝑏 and 𝑐 interleaved
- * @param 𝑏 [r/o] supplies eight words
- * @param 𝑐 [r/o] supplies eight words
- * @mayalias
- */
-void(punpckhwd)(uint16_t a[8], const uint16_t b[8], const uint16_t c[8]) {
-  a[0] = b[4];
-  a[1] = c[4];
-  a[2] = b[5];
-  a[3] = c[5];
-  a[4] = b[6];
-  a[5] = c[6];
-  a[6] = b[7];
-  a[7] = c[7];
-}
diff --git a/libc/intrin/punpckhwd.h b/libc/intrin/punpckhwd.h
deleted file mode 100644
index 548e6ee92..000000000
--- a/libc/intrin/punpckhwd.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PUNPCKHWD_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PUNPCKHWD_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void punpckhwd(uint16_t[8], const uint16_t[8], const uint16_t[8]);
-
-#define punpckhwd(A, B, C)                                                     \
-  INTRIN_SSEVEX_X_X_X_(punpckhwd, SSE2, "punpckhwd", INTRIN_NONCOMMUTATIVE, A, \
-                       B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PUNPCKHWD_H_ */
diff --git a/libc/intrin/punpcklbw.c b/libc/intrin/punpcklbw.c
deleted file mode 100644
index 559d8a553..000000000
--- a/libc/intrin/punpcklbw.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/punpcklbw.h"
-
-/**
- * Interleaves low bytes.
- *
- *          0 1 2 3 4 5 6 7 8 9 A B C D E F
- *       B  A B C D E F G H i j k l m n o p
- *       C  Q R S T U V W X y z α σ π μ τ ε
- *          │ │ │ │ │ │ │ │
- *          │ │ │ └─────┐
- *          │ │ └───┐   │  etc...
- *          │ └─┐   │   │
- *          ├─┐ ├─┐ ├─┐ ├─┐
- *     → A  A Q B R C S D T E U F V G W H X
- *
- * @param 𝑎 [w/o] receives reduced 𝑏 and 𝑐 interleaved
- * @param 𝑏 [r/o] supplies eight words
- * @param 𝑐 [r/o] supplies eight words
- * @mayalias
- */
-void(punpcklbw)(uint8_t a[16], const uint8_t b[16], const uint8_t c[16]) {
-  a[0xf] = c[7];
-  a[0xe] = b[7];
-  a[0xd] = c[6];
-  a[0xc] = b[6];
-  a[0xb] = c[5];
-  a[0xa] = b[5];
-  a[0x9] = c[4];
-  a[0x8] = b[4];
-  a[0x7] = c[3];
-  a[0x6] = b[3];
-  a[0x5] = c[2];
-  a[0x4] = b[2];
-  a[0x3] = c[1];
-  a[0x2] = b[1];
-  a[0x1] = c[0];
-  a[0x0] = b[0];
-}
diff --git a/libc/intrin/punpcklbw.h b/libc/intrin/punpcklbw.h
deleted file mode 100644
index 40c9cef89..000000000
--- a/libc/intrin/punpcklbw.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PUNPCKLBW_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PUNPCKLBW_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void punpcklbw(uint8_t[16], const uint8_t[16], const uint8_t[16]);
-
-#define punpcklbw(A, B, C)                                                     \
-  INTRIN_SSEVEX_X_X_X_(punpcklbw, SSE2, "punpcklbw", INTRIN_NONCOMMUTATIVE, A, \
-                       B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PUNPCKLBW_H_ */
diff --git a/libc/intrin/punpcklwd.c b/libc/intrin/punpcklwd.c
deleted file mode 100644
index 11936c456..000000000
--- a/libc/intrin/punpcklwd.c
+++ /dev/null
@@ -1,48 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/punpcklwd.h"
-
-/**
- * Interleaves low words.
- *
- *          0  1  2  3  4  5  6  7
- *       B  AA BB CC DD ee ff gg hh
- *       C  II JJ KK LL mm nn oo pp
- *          ├┘ ├┘ ├┘ ├┘
- *          │  │  │  └────────┐
- *          │  │  └─────┐     │
- *          │  └──┐     │     │
- *          ├───┐ ├───┐ ├───┐ ├───┐
- *     → A  AA II BB JJ CC KK DD LL
- *
- * @param 𝑎 [w/o] receives reduced 𝑏 and 𝑐 interleaved
- * @param 𝑏 [r/o] supplies eight words
- * @param 𝑐 [r/o] supplies eight words
- * @mayalias
- */
-void(punpcklwd)(uint16_t a[8], const uint16_t b[8], const uint16_t c[8]) {
-  a[7] = c[3];
-  a[6] = b[3];
-  a[5] = c[2];
-  a[4] = b[2];
-  a[3] = c[1];
-  a[2] = b[1];
-  a[1] = c[0];
-  a[0] = b[0];
-}
diff --git a/libc/intrin/punpcklwd.h b/libc/intrin/punpcklwd.h
deleted file mode 100644
index e286ba9c2..000000000
--- a/libc/intrin/punpcklwd.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_INTRIN_PUNPCKLWD_H_
-#define COSMOPOLITAN_LIBC_INTRIN_PUNPCKLWD_H_
-#include "libc/intrin/macros.h"
-COSMOPOLITAN_C_START_
-
-void punpcklwd(uint16_t[8], const uint16_t[8], const uint16_t[8]);
-
-#define punpcklwd(A, B, C)                                                     \
-  INTRIN_SSEVEX_X_X_X_(punpcklwd, SSE2, "punpcklwd", INTRIN_NONCOMMUTATIVE, A, \
-                       B, C)
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_INTRIN_PUNPCKLWD_H_ */
diff --git a/libc/intrin/pushpop.h b/libc/intrin/pushpop.h
new file mode 100644
index 000000000..17f551ac4
--- /dev/null
+++ b/libc/intrin/pushpop.h
@@ -0,0 +1,57 @@
+#ifndef COSMOPOLITAN_LIBC_BITS_PUSHPOP_H_
+#define COSMOPOLITAN_LIBC_BITS_PUSHPOP_H_
+#ifdef _COSMO_SOURCE
+#include "libc/macros.h"
+
+#if !defined(__GNUC__) || defined(__STRICT_ANSI__) || !defined(__x86_64__) || \
+    !defined(__MNO_RED_ZONE__)
+#define pushpop(x) (x)
+#else
+/**
+ * PushPop
+ * An elegant weapon for a more civilized age.
+ */
+#define pushpop(x)                                          \
+  ({                                                        \
+    typeof(x) Popped;                                       \
+    if (__builtin_constant_p(x) &&                          \
+        (TYPE_SIGNED(typeof(x)) ? (intptr_t)(x) + 128 < 256 \
+                                : (intptr_t)(x) < 128)) {   \
+      if (x) {                                              \
+        asm("push\t%1\n\t"                                  \
+            "pop\t%q0"                                      \
+            : "=r"(Popped)                                  \
+            : "ir"(x));                                     \
+      } else {                                              \
+        asm("xor\t%k0,%k0" : "=r"(Popped));                 \
+      }                                                     \
+    } else {                                                \
+      asm("" : "=r"(Popped) : "0"(x));                      \
+    }                                                       \
+    Popped;                                                 \
+  })
+#endif
+
+#if !defined(__GNUC__) || defined(__STRICT_ANSI__) || !defined(__x86_64__) || \
+    !defined(__MNO_RED_ZONE__)
+#define pushmov(d, x) (*(d) = (x))
+#else
+#define pushmov(d, x)                                       \
+  ({                                                        \
+    typeof(*(d)) Popped = (x);                              \
+    if (__builtin_constant_p(x) &&                          \
+        (TYPE_SIGNED(typeof(x)) ? (intptr_t)(x) + 128 < 256 \
+                                : (intptr_t)(x) < 128)) {   \
+      asm("pushq\t%1\n\t"                                   \
+          "popq\t%0"                                        \
+          : "=m"(*(d))                                      \
+          : "ir"(Popped));                                  \
+    } else {                                                \
+      *(d) = Popped;                                        \
+    }                                                       \
+    Popped;                                                 \
+  })
+#endif
+
+#endif /* _COSMO_SOURCE */
+#endif /* COSMOPOLITAN_LIBC_BITS_PUSHPOP_H_ */
diff --git a/libc/intrin/pushpop.internal.h b/libc/intrin/pushpop.internal.h
deleted file mode 100644
index 2f693e542..000000000
--- a/libc/intrin/pushpop.internal.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_BITS_PUSHPOP_H_
-#define COSMOPOLITAN_LIBC_BITS_PUSHPOP_H_
-#ifdef _COSMO_SOURCE
-#include "libc/macros.internal.h"
-
-#if !defined(__GNUC__) || defined(__STRICT_ANSI__) || !defined(__x86_64__) || \
-    !defined(__MNO_RED_ZONE__)
-#define pushpop(x) (x)
-#else
-/**
- * PushPop
- * An elegant weapon for a more civilized age.
- */
-#define pushpop(x)                                          \
-  ({                                                        \
-    typeof(x) Popped;                                       \
-    if (__builtin_constant_p(x) &&                          \
-        (TYPE_SIGNED(typeof(x)) ? (intptr_t)(x) + 128 < 256 \
-                                : (intptr_t)(x) < 128)) {   \
-      if (x) {                                              \
-        asm("push\t%1\n\t"                                  \
-            "pop\t%q0"                                      \
-            : "=r"(Popped)                                  \
-            : "ir"(x));                                     \
-      } else {                                              \
-        asm("xor\t%k0,%k0" : "=r"(Popped));                 \
-      }                                                     \
-    } else {                                                \
-      asm("" : "=r"(Popped) : "0"(x));                      \
-    }                                                       \
-    Popped;                                                 \
-  })
-#endif
-
-#if !defined(__GNUC__) || defined(__STRICT_ANSI__) || !defined(__x86_64__) || \
-    !defined(__MNO_RED_ZONE__)
-#define pushmov(d, x) (*(d) = (x))
-#else
-#define pushmov(d, x)                                       \
-  ({                                                        \
-    typeof(*(d)) Popped = (x);                              \
-    if (__builtin_constant_p(x) &&                          \
-        (TYPE_SIGNED(typeof(x)) ? (intptr_t)(x) + 128 < 256 \
-                                : (intptr_t)(x) < 128)) {   \
-      asm("pushq\t%1\n\t"                                   \
-          "popq\t%0"                                        \
-          : "=m"(*(d))                                      \
-          : "ir"(Popped));                                  \
-    } else {                                                \
-      *(d) = Popped;                                        \
-    }                                                       \
-    Popped;                                                 \
-  })
-#endif
-
-#endif /* _COSMO_SOURCE */
-#endif /* COSMOPOLITAN_LIBC_BITS_PUSHPOP_H_ */
diff --git a/libc/intrin/rand64.c b/libc/intrin/rand64.c
index f631d109f..53252327e 100644
--- a/libc/intrin/rand64.c
+++ b/libc/intrin/rand64.c
@@ -16,20 +16,31 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/getauxval.internal.h"
+#include "libc/intrin/getauxval.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/auxv.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 
-static struct {
-  int thepid;
-  uint128_t thepool;
-  pthread_spinlock_t lock;
-} g_rand64;
+static int _rand64_pid;
+static unsigned __int128 _rand64_pool;
+static pthread_mutex_t __rand64_lock_obj = PTHREAD_MUTEX_INITIALIZER;
+
+void __rand64_lock(void) {
+  _pthread_mutex_lock(&__rand64_lock_obj);
+}
+
+void __rand64_unlock(void) {
+  _pthread_mutex_unlock(&__rand64_lock_obj);
+}
+
+void __rand64_wipe(void) {
+  _pthread_mutex_wipe_np(&__rand64_lock_obj);
+}
 
 /**
  * Returns nondeterministic random data.
@@ -39,19 +50,16 @@ static struct {
  * the case even across forks and threads, whose sequences will differ.
  *
  * @see rdseed(), rdrand(), rand(), random(), rngset()
- * @note this function takes 5 cycles (30 if `__threaded`)
- * @note this function is not intended for cryptography
  * @note this function passes bigcrush and practrand
  */
 uint64_t _rand64(void) {
   void *p;
   uint128_t s;
-  if (__threaded)
-    pthread_spin_lock(&g_rand64.lock);
-  if (__pid == g_rand64.thepid) {
-    s = g_rand64.thepool;  // normal path
+  __rand64_lock();
+  if (__pid == _rand64_pid) {
+    s = _rand64_pool;  // normal path
   } else {
-    if (!g_rand64.thepid) {
+    if (!_rand64_pid) {
       if (AT_RANDOM && (p = (void *)__getauxval(AT_RANDOM).value)) {
         // linux / freebsd kernel supplied entropy
         memcpy(&s, p, 16);
@@ -61,13 +69,13 @@ uint64_t _rand64(void) {
       }
     } else {
       // blend another timestamp on fork contention
-      s = g_rand64.thepool ^ rdtsc();
+      s = _rand64_pool ^ rdtsc();
     }
     // blend the pid on startup and fork contention
     s ^= __pid;
-    g_rand64.thepid = __pid;
+    _rand64_pid = __pid;
   }
-  g_rand64.thepool = (s *= 15750249268501108917ull);  // lemur64
-  pthread_spin_unlock(&g_rand64.lock);
+  _rand64_pool = (s *= 15750249268501108917ull);  // lemur64
+  __rand64_unlock();
   return s >> 64;
 }
diff --git a/libc/intrin/removedirectory.c b/libc/intrin/removedirectory.c
index 38f03d205..0e7864bf7 100644
--- a/libc/intrin/removedirectory.c
+++ b/libc/intrin/removedirectory.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/nt/thunk/msabi.h"
 
diff --git a/libc/intrin/reopenfile.c b/libc/intrin/reopenfile.c
index 0c769d8be..d49b008ef 100644
--- a/libc/intrin/reopenfile.c
+++ b/libc/intrin/reopenfile.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/thunk/msabi.h"
diff --git a/libc/intrin/reservefd.c b/libc/intrin/reservefd.c
index 1be7e4b4f..272590122 100644
--- a/libc/intrin/reservefd.c
+++ b/libc/intrin/reservefd.c
@@ -18,11 +18,11 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/cmpxchg.h"
-#include "libc/intrin/extend.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/extend.h"
+#include "libc/intrin/fds.h"
+#include "libc/macros.h"
 #include "libc/runtime/memtrack.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/map.h"
@@ -47,7 +47,7 @@ int __ensurefds_unlocked(int fd) {
 
 /**
  * Grows file descriptor array memory if needed.
- * @asyncsignalsafe
+ * @asyncsignalsafe if signals are blocked
  */
 int __ensurefds(int fd) {
   __fds_lock();
@@ -64,17 +64,15 @@ int __reservefd_unlocked(int start) {
   int fd, f1, f2;
   for (;;) {
     f1 = atomic_load_explicit(&g_fds.f, memory_order_acquire);
-    for (fd = MAX(start, f1); fd < g_fds.n; ++fd) {
-      if (!g_fds.p[fd].kind) {
+    for (fd = MAX(start, f1); fd < g_fds.n; ++fd)
+      if (!g_fds.p[fd].kind)
         break;
-      }
-    }
     fd = __ensurefds_unlocked(fd);
     bzero(g_fds.p + fd, sizeof(*g_fds.p));
     if (_cmpxchg(&g_fds.p[fd].kind, kFdEmpty, kFdReserved)) {
       // g_fds.f isn't guarded by our mutex
       do {
-        f2 = MAX(fd + 1, f1);
+        f2 = MIN(fd + 1, f1);
       } while (!atomic_compare_exchange_weak_explicit(
           &g_fds.f, &f1, f2, memory_order_release, memory_order_relaxed));
       return fd;
@@ -84,7 +82,7 @@ int __reservefd_unlocked(int start) {
 
 /**
  * Finds open file descriptor slot.
- * @asyncsignalsafe
+ * @asyncsignalsafe if signals are blocked
  */
 int __reservefd(int start) {
   int fd;
diff --git a/libc/calls/restore.S b/libc/intrin/restore.S
similarity index 98%
rename from libc/calls/restore.S
rename to libc/intrin/restore.S
index 6ce347160..596b01f7c 100644
--- a/libc/calls/restore.S
+++ b/libc/intrin/restore.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.windows
 
 //	Restores thread to state before signal.
diff --git a/libc/intrin/rlimit.h b/libc/intrin/rlimit.h
new file mode 100644
index 000000000..05d0fb96e
--- /dev/null
+++ b/libc/intrin/rlimit.h
@@ -0,0 +1,10 @@
+#ifndef COSMOPOLITAN_LIBC_INTRIN_RLIMIT_H_
+#define COSMOPOLITAN_LIBC_INTRIN_RLIMIT_H_
+#include "libc/calls/struct/rlimit.h"
+COSMOPOLITAN_C_START_
+
+void __rlimit_stack_set(struct rlimit);
+struct rlimit __rlimit_stack_get(void);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_INTRIN_RLIMIT_H_ */
diff --git a/libc/intrin/rlimitstack.c b/libc/intrin/rlimitstack.c
new file mode 100644
index 000000000..66f47c64a
--- /dev/null
+++ b/libc/intrin/rlimitstack.c
@@ -0,0 +1,76 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
+#include "libc/calls/struct/rlimit.h"
+#include "libc/calls/struct/rlimit.internal.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/intrin/cxaatexit.h"
+#include "libc/intrin/lockless.h"
+#include "libc/intrin/rlimit.h"
+#include "libc/runtime/stack.h"
+#include "libc/sysv/consts/rlim.h"
+#include "libc/sysv/consts/rlimit.h"
+
+struct atomic_rlimit {
+  atomic_ulong cur;
+  atomic_ulong max;
+  atomic_uint once;
+  atomic_uint gen;
+};
+
+static struct atomic_rlimit __rlimit_stack;
+
+static void __rlimit_stack_init(void) {
+  struct rlimit rlim;
+  if (IsWindows()) {
+    rlim.rlim_cur = GetStaticStackSize();
+    rlim.rlim_max = -1;  // RLIM_INFINITY in consts.sh
+  } else {
+    sys_getrlimit(RLIMIT_STACK, &rlim);
+  }
+  atomic_init(&__rlimit_stack.cur, rlim.rlim_cur);
+  atomic_init(&__rlimit_stack.max, rlim.rlim_max);
+}
+
+struct rlimit __rlimit_stack_get(void) {
+  unsigned gen;
+  unsigned long cur, max;
+  cosmo_once(&__rlimit_stack.once, __rlimit_stack_init);
+  gen = lockless_read_begin(&__rlimit_stack.gen);
+  do {
+    cur = atomic_load_explicit(&__rlimit_stack.cur, memory_order_acquire);
+    max = atomic_load_explicit(&__rlimit_stack.max, memory_order_acquire);
+  } while (!lockless_read_end(&__rlimit_stack.gen, &gen));
+  return (struct rlimit){cur, max};
+}
+
+void __rlimit_stack_set(struct rlimit rlim) {
+  unsigned gen;
+  unsigned long cur, max;
+  cosmo_once(&__rlimit_stack.once, __rlimit_stack_init);
+  __cxa_lock();
+  cur = rlim.rlim_cur;
+  max = rlim.rlim_max;
+  gen = lockless_write_begin(&__rlimit_stack.gen);
+  atomic_store_explicit(&__rlimit_stack.cur, cur, memory_order_release);
+  atomic_store_explicit(&__rlimit_stack.max, max, memory_order_release);
+  lockless_write_end(&__rlimit_stack.gen, gen);
+  __cxa_unlock();
+}
diff --git a/libc/intrin/safemacros.h b/libc/intrin/safemacros.h
new file mode 100644
index 000000000..8fe6613f4
--- /dev/null
+++ b/libc/intrin/safemacros.h
@@ -0,0 +1,70 @@
+#ifndef COSMOPOLITAN_LIBC_BITS_SAFEMACROS_H_
+#define COSMOPOLITAN_LIBC_BITS_SAFEMACROS_H_
+#include "libc/macros.h"
+#include "libc/runtime/runtime.h"
+COSMOPOLITAN_C_START_
+
+#define min(x, y)              \
+  ({                           \
+    autotype(x) MinX = (x);    \
+    autotype(y) MinY = (y);    \
+    MinX < MinY ? MinX : MinY; \
+  })
+
+#define max(x, y)              \
+  ({                           \
+    autotype(x) MaxX = (x);    \
+    autotype(y) MaxY = (y);    \
+    MaxX > MaxY ? MaxX : MaxY; \
+  })
+
+#define roundup(x, k)            \
+  ({                             \
+    autotype(x) RoundupX = (x);  \
+    autotype(k) RoundupK = (k);  \
+    ROUNDUP(RoundupX, RoundupK); \
+  })
+
+#define rounddown(x, k)                \
+  ({                                   \
+    autotype(x) RounddownX = (x);      \
+    autotype(k) RounddownK = (k);      \
+    ROUNDDOWN(RounddownX, RounddownK); \
+  })
+
+#define isempty(s)              \
+  ({                            \
+    autotype(s) IsEmptyS = (s); \
+    !IsEmptyS || !(*IsEmptyS);  \
+  })
+
+#define nulltoempty(s)                \
+  ({                                  \
+    autotype(s) NullToEmptyS = (s);   \
+    NullToEmptyS ? NullToEmptyS : ""; \
+  })
+
+#define firstnonnull(a, b)                         \
+  ({                                               \
+    autotype(a) FirstNonNullA = (a);               \
+    autotype(a) FirstNonNullB = (b);               \
+    if (!FirstNonNullA && !FirstNonNullB)          \
+      abort();                                     \
+    FirstNonNullA ? FirstNonNullA : FirstNonNullB; \
+  })
+
+#define emptytonull(s)                                      \
+  ({                                                        \
+    autotype(s) EmptyToNullS = (s);                         \
+    EmptyToNullS && !(*EmptyToNullS) ? NULL : EmptyToNullS; \
+  })
+
+#define unsignedsubtract(a, b)                                 \
+  ({                                                           \
+    uint64_t UnsubA = (a);                                     \
+    uint64_t UnsubB = (b);                                     \
+    UnsubA >= UnsubB ? UnsubA - UnsubB : ~UnsubB + UnsubA + 1; \
+  })
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_BITS_SAFEMACROS_H_ */
diff --git a/libc/intrin/safemacros.internal.h b/libc/intrin/safemacros.internal.h
deleted file mode 100644
index 443843f37..000000000
--- a/libc/intrin/safemacros.internal.h
+++ /dev/null
@@ -1,70 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_BITS_SAFEMACROS_H_
-#define COSMOPOLITAN_LIBC_BITS_SAFEMACROS_H_
-#include "libc/macros.internal.h"
-#include "libc/runtime/runtime.h"
-COSMOPOLITAN_C_START_
-
-#define min(x, y)              \
-  ({                           \
-    autotype(x) MinX = (x);    \
-    autotype(y) MinY = (y);    \
-    MinX < MinY ? MinX : MinY; \
-  })
-
-#define max(x, y)              \
-  ({                           \
-    autotype(x) MaxX = (x);    \
-    autotype(y) MaxY = (y);    \
-    MaxX > MaxY ? MaxX : MaxY; \
-  })
-
-#define roundup(x, k)            \
-  ({                             \
-    autotype(x) RoundupX = (x);  \
-    autotype(k) RoundupK = (k);  \
-    ROUNDUP(RoundupX, RoundupK); \
-  })
-
-#define rounddown(x, k)                \
-  ({                                   \
-    autotype(x) RounddownX = (x);      \
-    autotype(k) RounddownK = (k);      \
-    ROUNDDOWN(RounddownX, RounddownK); \
-  })
-
-#define isempty(s)              \
-  ({                            \
-    autotype(s) IsEmptyS = (s); \
-    !IsEmptyS || !(*IsEmptyS);  \
-  })
-
-#define nulltoempty(s)                \
-  ({                                  \
-    autotype(s) NullToEmptyS = (s);   \
-    NullToEmptyS ? NullToEmptyS : ""; \
-  })
-
-#define firstnonnull(a, b)                         \
-  ({                                               \
-    autotype(a) FirstNonNullA = (a);               \
-    autotype(a) FirstNonNullB = (b);               \
-    if (!FirstNonNullA && !FirstNonNullB)          \
-      abort();                                     \
-    FirstNonNullA ? FirstNonNullA : FirstNonNullB; \
-  })
-
-#define emptytonull(s)                                      \
-  ({                                                        \
-    autotype(s) EmptyToNullS = (s);                         \
-    EmptyToNullS && !(*EmptyToNullS) ? NULL : EmptyToNullS; \
-  })
-
-#define unsignedsubtract(a, b)                                 \
-  ({                                                           \
-    uint64_t UnsubA = (a);                                     \
-    uint64_t UnsubB = (b);                                     \
-    UnsubA >= UnsubB ? UnsubA - UnsubB : ~UnsubB + UnsubA + 1; \
-  })
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_BITS_SAFEMACROS_H_ */
diff --git a/libc/intrin/sched_yield.S b/libc/intrin/sched_yield.S
deleted file mode 100644
index 42433fa6d..000000000
--- a/libc/intrin/sched_yield.S
+++ /dev/null
@@ -1,111 +0,0 @@
-/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/dce.h"
-#include "libc/sysv/consts/nr.h"
-#include "libc/macros.internal.h"
-.privileged
-
-//	Relinquishes scheduled quantum.
-//
-//	@return	0 on success, or -1 w/ errno
-sched_yield:
-#ifdef __x86_64__
-	push	%rbp
-	mov	%rsp,%rbp
-	xor	%eax,%eax
-	mov	__hostos(%rip),%dl
-
-#if SupportsMetal()
-	testb	$_HOSTMETAL,%dl
-	jnz	9f
-#endif
-
-#if SupportsWindows()
-//	Windows Support
-//
-//	A value of zero, together with the bAlertable parameter set to
-//	FALSE, causes the thread to relinquish the remainder of its time
-//	slice to any other thread that is ready to run, if there are no
-//	pending user APCs on the calling thread. If there are no other
-//	threads ready to run and no user APCs are queued, the function
-//	returns immediately, and the thread continues execution.
-//	                                  ──Quoth MSDN
-	testb	$_HOSTWINDOWS,%dl
-	jz	1f
-	xor	%ecx,%ecx
-	xor	%edx,%edx
-	ntcall	__imp_SleepEx
-	xor	%eax,%eax
-	jmp	9f
-1:
-#endif
-
-#if SupportsSystemv()
-//	On XNU we polyfill sched_yield() using sleep() which'll
-//	be polyfilled using select() with a zero timeout, which
-//	means to wait zero microseconds and then returns a zero
-//	and this hopefully will give other threads a chance too
-//	XNU has a special version we use called select_nocancel
-//
-//	"If the readfds, writefds, and errorfds arguments are
-//	 all null pointers and the timeout argument is not a
-//	 null pointer, the pselect() or select() function shall
-//	 block for the time specified, or until interrupted by
-//	 a signal." ──Quoth IEEE 1003.1-2017 §functions/select
-//
-//	On other platforms, sched_yield() takes no arguments.
-	push	$0				// timeout.tv_usec
-	push	$0				// timeout.tv_sec
-	xor	%edi,%edi			// nfds
-	xor	%esi,%esi			// readfds
-	xor	%edx,%edx			// writefds
-	xor	%r10d,%r10d			// exceptfds
-	mov	%rsp,%r8			// timeout
-	mov	__NR_sched_yield,%eax		// ordinal
-	clc					// linux
-	syscall
-//	It should not be possible for this to fail so we don't
-//	bother going through the errno ritual. If this somehow
-//	fails a positive or negative errno might get returned.
-#endif
-
-9:	leave
-	ret
-
-#elif defined(__aarch64__)
-
-	stp	x29,x30,[sp,-32]!
-	mov	x29,sp
-	mov	x3,0
-	mov	x2,0
-	add	x4,sp,16
-	mov	x1,0
-	mov	w0,0
-	stp	xzr,xzr,[sp,16]
-	mov	x8,#0x7c			// sched_yield() for gnu/systemd
-	mov	x16,#0x5d			// select(0,0,0,0,&blah) for xnu
-	svc	0
-	ldp	x29,x30,[sp],32
-	ret
-
-#else
-#error "arch unsupported"
-#endif
-	.endfn	sched_yield,globl
-	.previous
diff --git a/libc/intrin/setcurrentdirectory.c b/libc/intrin/setcurrentdirectory.c
index ae8b70c43..3e2398bf5 100644
--- a/libc/intrin/setcurrentdirectory.c
+++ b/libc/intrin/setcurrentdirectory.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/thunk/msabi.h"
diff --git a/libc/intrin/setjmp.internal.h b/libc/intrin/setjmp.h
similarity index 100%
rename from libc/intrin/setjmp.internal.h
rename to libc/intrin/setjmp.h
diff --git a/libc/intrin/sig.c b/libc/intrin/sig.c
index 2bffeeb7b..0cf56902d 100644
--- a/libc/intrin/sig.c
+++ b/libc/intrin/sig.c
@@ -1,7 +1,7 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
 │ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@@ -17,33 +17,812 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/sysv/consts/sig.h"
+#include "ape/sections.internal.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
+#include "libc/calls/state.internal.h"
+#include "libc/calls/struct/sigaction.h"
+#include "libc/calls/struct/siginfo.h"
 #include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/ucontext.internal.h"
+#include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/calls/ucontext.h"
 #include "libc/dce.h"
+#include "libc/errno.h"
 #include "libc/intrin/atomic.h"
+#include "libc/intrin/bsf.h"
+#include "libc/intrin/describebacktrace.h"
+#include "libc/intrin/dll.h"
+#include "libc/intrin/maps.h"
+#include "libc/intrin/nomultics.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
-#include "libc/thread/tls.h"
+#include "libc/log/libfatal.internal.h"
+#include "libc/mem/alloca.h"
+#include "libc/nt/console.h"
+#include "libc/nt/enum/context.h"
+#include "libc/nt/enum/exceptionhandleractions.h"
+#include "libc/nt/enum/pageflags.h"
+#include "libc/nt/enum/processcreationflags.h"
+#include "libc/nt/enum/signal.h"
+#include "libc/nt/enum/status.h"
+#include "libc/nt/events.h"
+#include "libc/nt/memory.h"
+#include "libc/nt/runtime.h"
+#include "libc/nt/signals.h"
+#include "libc/nt/struct/memorybasicinformation.h"
+#include "libc/nt/struct/ntexceptionpointers.h"
+#include "libc/nt/synchronization.h"
+#include "libc/nt/thread.h"
+#include "libc/runtime/internal.h"
+#include "libc/runtime/runtime.h"
+#include "libc/runtime/symbols.internal.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
+#include "libc/sysv/consts/sa.h"
+#include "libc/sysv/consts/sicode.h"
+#include "libc/sysv/consts/ss.h"
+#include "libc/sysv/consts/termios.h"
+#include "libc/thread/posixthread.internal.h"
+#ifdef __x86_64__
 
-struct Signals __sig;
+/**
+ * @fileoverview Cosmopolitan Signals for Windows.
+ */
 
-sigset_t __sig_block(void) {
-  if (IsWindows()) {
-    return atomic_exchange_explicit(&__get_tls()->tib_sigmask, -1,
-                                    memory_order_acquire);
-  } else {
-    sigset_t res, neu = -1;
-    sys_sigprocmask(SIG_SETMASK, &neu, &res);
-    return res;
-  }
+#define STKSZ 65536
+#define HAIRY textwindows dontinstrument dontinline
+
+struct SignalFrame {
+  unsigned rva;
+  unsigned flags;
+  siginfo_t si;
+  ucontext_t ctx;
+};
+
+__msabi extern typeof(GetStdHandle) *const __imp_GetStdHandle;
+__msabi extern typeof(VirtualProtectEx) *const __imp_VirtualProtectEx;
+__msabi extern typeof(VirtualQuery) *const __imp_VirtualQuery;
+__msabi extern typeof(WriteFile) *const __imp_WriteFile;
+
+atomic_int __sig_worker_state;
+
+textwindows static bool __sig_ignored_by_default(int sig) {
+  return sig == SIGURG ||   //
+         sig == SIGCONT ||  //
+         sig == SIGCHLD ||  //
+         sig == SIGWINCH;
 }
 
-void __sig_unblock(sigset_t m) {
-  if (IsWindows()) {
-    atomic_store_explicit(&__get_tls()->tib_sigmask, m, memory_order_release);
-    if (_weaken(__sig_check)) {
-      _weaken(__sig_check)();
+textwindows bool __sig_ignored(int sig) {
+  return __sighandrvas[sig] == (intptr_t)SIG_IGN ||
+         (__sighandrvas[sig] == (intptr_t)SIG_DFL &&
+          __sig_ignored_by_default(sig));
+}
+
+textwindows void __sig_delete(int sig) {
+  struct Dll *e;
+  atomic_fetch_and_explicit(__sig.process, ~(1ull << (sig - 1)),
+                            memory_order_relaxed);
+  _pthread_lock();
+  for (e = dll_last(_pthread_list); e; e = dll_prev(_pthread_list, e))
+    atomic_fetch_and_explicit(&POSIXTHREAD_CONTAINER(e)->tib->tib_sigpending,
+                              ~(1ull << (sig - 1)), memory_order_relaxed);
+  _pthread_unlock();
+}
+
+textwindows static int __sig_getter(atomic_ulong *sigs, sigset_t masked) {
+  int sig;
+  sigset_t bit, pending, deliverable;
+  for (;;) {
+    pending = atomic_load_explicit(sigs, memory_order_acquire);
+    if ((deliverable = pending & ~masked)) {
+      sig = bsfl(deliverable) + 1;
+      bit = 1ull << (sig - 1);
+      if (atomic_fetch_and_explicit(sigs, ~bit, memory_order_acq_rel) & bit)
+        return sig;
+    } else {
+      return 0;
     }
-  } else {
-    sys_sigprocmask(SIG_SETMASK, &m, 0);
   }
 }
+
+textwindows int __sig_get(sigset_t masked) {
+  int sig;
+  if (!(sig = __sig_getter(&__get_tls()->tib_sigpending, masked)))
+    sig = __sig_getter(__sig.process, masked);
+  return sig;
+}
+
+HAIRY static bool __sig_should_use_altstack(unsigned flags,
+                                            struct CosmoTib *tib) {
+  if (!(flags & SA_ONSTACK))
+    return false;  // signal handler didn't enable it
+  if (!tib->tib_sigstack_size)
+    return false;  // sigaltstack() wasn't installed on this thread
+  if (tib->tib_sigstack_flags & SS_DISABLE)
+    return false;  // sigaltstack() on this thread was disabled by user
+  char *bp = __builtin_frame_address(0);
+  if (tib->tib_sigstack_addr <= bp &&
+      bp <= tib->tib_sigstack_addr + tib->tib_sigstack_size)
+    return false;  // we're already on the alternate stack
+  return true;
+}
+
+forceinline wontreturn void __sig_terminate(int sig) {
+  TerminateThisProcess(sig);
+}
+
+textwindows static bool __sig_wake(struct PosixThread *pt, int sig) {
+  atomic_int *blocker;
+  blocker = atomic_load_explicit(&pt->pt_blocker, memory_order_acquire);
+  if (!blocker)
+    return false;
+  // threads can create semaphores on an as-needed basis
+  if (blocker == PT_BLOCKER_EVENT) {
+    STRACE("%G set %d's event object", sig, _pthread_tid(pt));
+    SetEvent(pt->pt_event);
+    return !!atomic_load_explicit(&pt->pt_blocker, memory_order_acquire);
+  }
+  // all other blocking ops that aren't overlap should use futexes
+  // we force restartable futexes to churn by waking w/o releasing
+  STRACE("%G waking %d's futex", sig, _pthread_tid(pt));
+  WakeByAddressSingle(blocker);
+  return !!atomic_load_explicit(&pt->pt_blocker, memory_order_acquire);
+}
+
+textwindows static bool __sig_start(struct PosixThread *pt, int sig,
+                                    unsigned *rva, unsigned *flags) {
+  *rva = __sighandrvas[sig];
+  *flags = __sighandflags[sig];
+  if (*rva == (intptr_t)SIG_IGN ||
+      (*rva == (intptr_t)SIG_DFL && __sig_ignored_by_default(sig))) {
+    STRACE("ignoring %G", sig);
+    return false;
+  }
+  if (atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
+      (1ull << (sig - 1))) {
+    STRACE("enqueing %G on %d", sig, _pthread_tid(pt));
+    atomic_fetch_or_explicit(&pt->tib->tib_sigpending, 1ull << (sig - 1),
+                             memory_order_relaxed);
+    __sig_wake(pt, sig);
+    return false;
+  }
+  if (*rva == (intptr_t)SIG_DFL) {
+    STRACE("terminating on %G due to no handler", sig);
+    __sig_terminate(sig);
+  }
+  return true;
+}
+
+textwindows static sigaction_f __sig_handler(unsigned rva) {
+  atomic_fetch_add_explicit(&__sig.count, 1, memory_order_relaxed);
+  return (sigaction_f)(__executable_start + rva);
+}
+
+textwindows int __sig_raise(volatile int sig, int sic) {
+
+  // bitset of kinds of handlers called
+  volatile int handler_was_called = 0;
+
+  // loop over pending signals
+  ucontext_t ctx;
+  getcontext(&ctx);
+  if (!sig) {
+    if ((sig = __sig_get(ctx.uc_sigmask))) {
+      sic = SI_KERNEL;
+    } else {
+      return handler_was_called;
+    }
+  }
+
+  // process signal(s)
+  unsigned rva, flags;
+  struct PosixThread *pt = _pthread_self();
+  if (__sig_start(pt, sig, &rva, &flags)) {
+
+    if (flags & SA_RESETHAND) {
+      STRACE("resetting %G handler", sig);
+      __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
+    }
+
+    // update the signal mask in preparation for signal handller
+    sigset_t blocksigs = __sighandmask[sig];
+    if (!(flags & SA_NODEFER))
+      blocksigs |= 1ull << (sig - 1);
+    ctx.uc_sigmask = atomic_fetch_or_explicit(&pt->tib->tib_sigmask, blocksigs,
+                                              memory_order_acquire);
+
+    // call the user's signal handler
+    char ssbuf[128];
+    siginfo_t si = {.si_signo = sig, .si_code = sic};
+    STRACE("__sig_raise(%G, %t) mask %s", sig, __sig_handler(rva),
+           _DescribeSigset(ssbuf, 0, (sigset_t *)&pt->tib->tib_sigmask));
+    __sig_handler(rva)(sig, &si, &ctx);
+
+    // record this handler
+    if (flags & SA_RESTART) {
+      handler_was_called |= SIG_HANDLED_SA_RESTART;
+    } else {
+      handler_was_called |= SIG_HANDLED_NO_RESTART;
+    }
+  }
+
+  // restore sigmask
+  // loop back to top
+  // jump where handler says
+  sig = 0;
+  setcontext(&ctx);
+  __builtin_unreachable();
+}
+
+textwindows int __sig_relay(int sig, int sic, sigset_t waitmask) {
+  sigset_t m;
+  int handler_was_called;
+  m = atomic_exchange_explicit(&__get_tls()->tib_sigmask, waitmask,
+                               memory_order_acquire);
+  handler_was_called = __sig_raise(sig, SI_KERNEL);
+  atomic_store_explicit(&__get_tls()->tib_sigmask, m, memory_order_release);
+  return handler_was_called;
+}
+
+// the user's signal handler callback is wrapped with this trampoline
+textwindows wontreturn static void __sig_tramp(struct SignalFrame *sf) {
+  int sig = sf->si.si_signo;
+  struct CosmoTib *tib = __get_tls();
+  struct PosixThread *pt = (struct PosixThread *)tib->tib_pthread;
+  atomic_store_explicit(&pt->pt_intoff, 0, memory_order_release);
+  for (;;) {
+
+    // update the signal mask in preparation for signal handler
+    sigset_t blocksigs = __sighandmask[sig];
+    if (!(sf->flags & SA_NODEFER))
+      blocksigs |= 1ull << (sig - 1);
+    sf->ctx.uc_sigmask = atomic_fetch_or_explicit(&tib->tib_sigmask, blocksigs,
+                                                  memory_order_acquire);
+
+    // call the user's signal handler
+    char ssbuf[2][128];
+    STRACE("__sig_tramp(%G, %t) mask %s → %s", sig, __sig_handler(sf->rva),
+           _DescribeSigset(ssbuf[0], 0, &sf->ctx.uc_sigmask),
+           _DescribeSigset(ssbuf[1], 0, (sigset_t *)&tib->tib_sigmask));
+    __sig_handler(sf->rva)(sig, &sf->si, &sf->ctx);
+
+    // restore the signal mask that was used by the interrupted code
+    // this may have been modified by the signal handler in the callback
+    atomic_store_explicit(&tib->tib_sigmask, sf->ctx.uc_sigmask,
+                          memory_order_release);
+
+    // jump back into original code if there aren't any pending signals
+    do {
+      if (!(sig = __sig_get(sf->ctx.uc_sigmask)))
+        __sig_restore(&sf->ctx);
+    } while (!__sig_start(pt, sig, &sf->rva, &sf->flags));
+
+    // tail recurse into another signal handler
+    sf->si.si_signo = sig;
+    sf->si.si_code = SI_KERNEL;
+    if (sf->flags & SA_RESETHAND) {
+      STRACE("resetting %G handler", sig);
+      __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
+    }
+  }
+}
+
+HAIRY optimizespeed void __sig_translate(ucontext_t *ctx,
+                                         const struct NtContext *cr) {
+  ctx->uc_mcontext.eflags = cr->EFlags;
+  ctx->uc_mcontext.rax = cr->Rax;
+  ctx->uc_mcontext.rbx = cr->Rbx;
+  ctx->uc_mcontext.rcx = cr->Rcx;
+  ctx->uc_mcontext.rdx = cr->Rdx;
+  ctx->uc_mcontext.rdi = cr->Rdi;
+  ctx->uc_mcontext.rsi = cr->Rsi;
+  ctx->uc_mcontext.rbp = cr->Rbp;
+  ctx->uc_mcontext.rsp = cr->Rsp;
+  ctx->uc_mcontext.rip = cr->Rip;
+  ctx->uc_mcontext.r8 = cr->R8;
+  ctx->uc_mcontext.r9 = cr->R9;
+  ctx->uc_mcontext.r10 = cr->R10;
+  ctx->uc_mcontext.r11 = cr->R11;
+  ctx->uc_mcontext.r12 = cr->R12;
+  ctx->uc_mcontext.r13 = cr->R13;
+  ctx->uc_mcontext.r14 = cr->R14;
+  ctx->uc_mcontext.r15 = cr->R15;
+  ctx->uc_mcontext.cs = cr->SegCs;
+  ctx->uc_mcontext.gs = cr->SegGs;
+  ctx->uc_mcontext.fs = cr->SegFs;
+  ctx->uc_mcontext.fpregs = &ctx->__fpustate;
+  __repmovsb(&ctx->__fpustate, &cr->FltSave, sizeof(ctx->__fpustate));
+  ctx->__fpustate.mxcsr = cr->MxCsr;
+}
+
+// sends signal to another specific thread which is ref'd
+textwindows static int __sig_killer(struct PosixThread *pt, int sig, int sic) {
+  unsigned rva = __sighandrvas[sig];
+  unsigned flags = __sighandflags[sig];
+
+  // do nothing if signal is ignored
+  if (rva == (intptr_t)SIG_IGN ||
+      (rva == (intptr_t)SIG_DFL && __sig_ignored_by_default(sig))) {
+    STRACE("ignoring %G", sig);
+    return 0;
+  }
+
+  // we can't preempt threads that masked sigs or are blocked on i/o
+  while ((atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
+          (1ull << (sig - 1)))) {
+    if (atomic_fetch_or_explicit(&pt->tib->tib_sigpending, 1ull << (sig - 1),
+                                 memory_order_acq_rel) &
+        (1ull << (sig - 1)))
+      // we believe signal was already enqueued
+      return 0;
+    if (__sig_wake(pt, sig))
+      // we believe i/o routine will handle signal
+      return 0;
+    if (atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
+        (1ull << (sig - 1)))
+      // we believe ALLOW_SIGNALS will handle signal
+      return 0;
+    if (!(atomic_fetch_and_explicit(&pt->tib->tib_sigpending,
+                                    ~(1ull << (sig - 1)),
+                                    memory_order_acq_rel) &
+          (1ull << (sig - 1))))
+      // we believe another thread sniped our signal
+      return 0;
+    break;
+  }
+
+  // avoid race conditions and deadlocks with thread suspend process
+  if (atomic_exchange_explicit(&pt->pt_intoff, 1, memory_order_acquire)) {
+    // we believe another thread is asynchronously waking the mark
+    if (atomic_fetch_or_explicit(&pt->tib->tib_sigpending, 1ull << (sig - 1),
+                                 memory_order_acq_rel) &
+        (1ull << (sig - 1)))
+      // we believe our signal is already being delivered
+      return 0;
+    if (atomic_load_explicit(&pt->pt_intoff, memory_order_acquire) ||
+        atomic_exchange_explicit(&pt->pt_intoff, 1, memory_order_acquire))
+      // we believe __sig_tramp will deliver our signal
+      return 0;
+    if (!(atomic_fetch_and_explicit(&pt->tib->tib_sigpending,
+                                    ~(1ull << (sig - 1)),
+                                    memory_order_acq_rel) &
+          (1ull << (sig - 1))))
+      // we believe another thread sniped our signal
+      return 0;
+  }
+
+  // if there's no handler then killing a thread kills the process
+  if (rva == (intptr_t)SIG_DFL) {
+    STRACE("terminating on %G due to no handler", sig);
+    __sig_terminate(sig);
+  }
+
+  // take control of thread
+  // suspending the thread happens asynchronously
+  // however getting the context blocks until it's frozen
+  uintptr_t th = _pthread_syshand(pt);
+  if (SuspendThread(th) == -1u) {
+    STRACE("SuspendThread failed w/ %d", GetLastError());
+    atomic_store_explicit(&pt->pt_intoff, 0, memory_order_release);
+    return ESRCH;
+  }
+  struct NtContext nc;
+  nc.ContextFlags = kNtContextFull;
+  if (!GetThreadContext(th, &nc)) {
+    STRACE("GetThreadContext failed w/ %d", GetLastError());
+    ResumeThread(th);
+    atomic_store_explicit(&pt->pt_intoff, 0, memory_order_release);
+    return ESRCH;
+  }
+
+  // we can't preempt threads that masked sig or are blocked
+  // we can't preempt threads that are running in win32 code
+  // so we shall unblock the thread and let it signal itself
+  if (!((uintptr_t)__executable_start <= nc.Rip &&
+        nc.Rip < (uintptr_t)__privileged_start)) {
+    atomic_fetch_or_explicit(&pt->tib->tib_sigpending, 1ull << (sig - 1),
+                             memory_order_relaxed);
+    ResumeThread(th);
+    atomic_store_explicit(&pt->pt_intoff, 0, memory_order_release);
+    __sig_wake(pt, sig);
+    return 0;
+  }
+
+  // preferring to live dangerously
+  // the thread will be signaled asynchronously
+  if (flags & SA_RESETHAND) {
+    STRACE("resetting %G handler", sig);
+    __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
+  }
+
+  // inject call to trampoline function into thread
+  uintptr_t sp;
+  if (__sig_should_use_altstack(flags, pt->tib)) {
+    sp = (uintptr_t)pt->tib->tib_sigstack_addr + pt->tib->tib_sigstack_size;
+  } else {
+    sp = nc.Rsp;
+  }
+  sp -= sizeof(struct SignalFrame);
+  sp &= -16;
+  struct SignalFrame *sf = (struct SignalFrame *)sp;
+  __repstosb(sf, 0, sizeof(*sf));
+  __sig_translate(&sf->ctx, &nc);
+  sf->rva = rva;
+  sf->flags = flags;
+  sf->si.si_code = sic;
+  sf->si.si_signo = sig;
+  *(uintptr_t *)(sp -= sizeof(uintptr_t)) = nc.Rip;
+  nc.Rip = (intptr_t)__sig_tramp;
+  nc.Rdi = (intptr_t)sf;
+  nc.Rsp = sp;
+  if (!SetThreadContext(th, &nc)) {
+    STRACE("SetThreadContext failed w/ %d", GetLastError());
+    atomic_store_explicit(&pt->pt_intoff, 0, memory_order_release);
+    return ESRCH;
+  }
+  ResumeThread(th);
+  __sig_wake(pt, sig);
+  return 0;
+}
+
+// sends signal to another specific thread
+textwindows int __sig_kill(struct PosixThread *pt, int sig, int sic) {
+  int rc;
+  BLOCK_SIGNALS;
+  rc = __sig_killer(pt, sig, sic);
+  ALLOW_SIGNALS;
+  return rc;
+}
+
+// sends signal to any other thread
+// this should only be called by non-posix threads
+textwindows void __sig_generate(int sig, int sic) {
+  struct Dll *e;
+  struct PosixThread *pt, *mark = 0;
+  if (__sig_ignored(sig)) {
+    STRACE("ignoring %G", sig);
+    return;
+  }
+  if (__sighandrvas[sig] == (intptr_t)SIG_DFL) {
+    STRACE("terminating on %G due to no handler", sig);
+    __sig_terminate(sig);
+  }
+  if (atomic_load_explicit(__sig.process, memory_order_acquire) &
+      (1ull << (sig - 1)))
+    return;
+  _pthread_lock();
+  for (e = dll_first(_pthread_list); e; e = dll_next(_pthread_list, e)) {
+    pt = POSIXTHREAD_CONTAINER(e);
+    // we don't want to signal ourself
+    if (pt == _pthread_self())
+      continue;
+    // we don't want to signal a thread that isn't running
+    if (atomic_load_explicit(&pt->pt_status, memory_order_acquire) >=
+        kPosixThreadTerminated)
+      continue;
+    // choose this thread if it isn't masking sig
+    if (!(atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire) &
+          (1ull << (sig - 1)))) {
+      _pthread_ref(pt);
+      mark = pt;
+      break;
+    }
+    // if a thread is blocking then we check to see if it's planning
+    // to unblock our sig once the wait operation is completed; when
+    // that's the case we can cancel the thread's i/o to deliver sig
+    if (atomic_load_explicit(&pt->pt_blocker, memory_order_acquire) &&
+        !(pt->pt_blkmask & (1ull << (sig - 1)))) {
+      _pthread_ref(pt);
+      mark = pt;
+      break;
+    }
+  }
+  _pthread_unlock();
+  if (mark) {
+    // no lock needed since current thread is nameless and formless
+    __sig_killer(mark, sig, sic);
+    _pthread_unref(mark);
+  } else {
+    atomic_fetch_or_explicit(__sig.process, 1ull << (sig - 1),
+                             memory_order_relaxed);
+  }
+}
+
+textwindows static char *__sig_stpcpy(char *d, const char *s) {
+  size_t i;
+  for (i = 0;; ++i)
+    if (!(d[i] = s[i]))
+      return d + i;
+}
+
+textwindows wontreturn static void __sig_death(int sig, const char *thing) {
+#ifndef TINY
+  intptr_t hStderr;
+  char sigbuf[21], s[128], *p;
+  hStderr = __imp_GetStdHandle(kNtStdErrorHandle);
+  p = __sig_stpcpy(s, "Terminating on ");
+  p = __sig_stpcpy(p, thing);
+  p = __sig_stpcpy(p, strsignal_r(sig, sigbuf));
+  p = __sig_stpcpy(p,
+                   ". Pass --strace and/or ShowCrashReports() for details.\n");
+  __imp_WriteFile(hStderr, s, p - s, 0, 0);
+#endif
+  __sig_terminate(sig);
+}
+
+//
+//   "If a program attempts to access an address within a guard page,
+//    the system raises a kNtStatusGuardPageViolation (0x80000001)
+//    exception. The system also clears the kNtPageGuard modifier,
+//    removing the memory page's guard page status. The system will not
+//    stop the next attempt to access the memory page with a
+//    kNtStatusGuardPageViolation exception."
+//
+//                              —Quoth MSDN § Creating Guard Pages
+//
+forceinline void __sig_reguard(void *page) {
+  uint32_t old_protect;
+  __imp_VirtualProtectEx(GetCurrentProcess(),
+                         (void *)((uintptr_t)page & -__pagesize), __pagesize,
+                         kNtPageReadwrite | kNtPageGuard, &old_protect);
+}
+
+// trampoline for calling signal handler when system reports crash
+textwindows static void __sig_unmaskable(struct SignalFrame *sf) {
+
+  // log vital crash information reliably for --strace before doing much
+  // we don't print this without the flag since raw numbers scare people
+  // this needs at least one page of stack memory in order to get logged
+  // otherwise it'll print a warning message about the lack of stack mem
+  STRACE("win32 vectored exception 0x%08Xu raising %G "
+         "cosmoaddr2line %s %lx %s",
+         sf->si.si_errno, sf->si.si_signo,
+         _weaken(FindDebugBinary) ? _weaken(FindDebugBinary)()
+                                  : program_invocation_name,
+         sf->ctx.uc_mcontext.gregs[REG_RIP],
+         DescribeBacktrace(
+             (struct StackFrame *)sf->ctx.uc_mcontext.gregs[REG_RBP]));
+
+  // kills process if the user did not specify a handler for this signal
+  // we also don't allow unmaskable signals to be ignored by the program
+  if (sf->rva == (intptr_t)SIG_DFL ||  //
+      sf->rva == (intptr_t)SIG_IGN)
+    __sig_death(sf->si.si_signo, "uncaught ");
+
+  // we kill the process if this thread's signal mask blocks this signal
+  // then we block some extra signals while executing the signal handler
+  struct CosmoTib *tib = __get_tls();
+  sigset_t blocksigs = __sighandmask[sf->si.si_signo];
+  if (!(sf->flags & SA_NODEFER))
+    blocksigs |= 1ull << (sf->si.si_signo - 1);
+  sf->ctx.uc_sigmask = atomic_fetch_or(&tib->tib_sigmask, blocksigs);
+  if (sf->ctx.uc_sigmask & (1ull << (sf->si.si_signo - 1)))
+    __sig_death(sf->si.si_signo, "masked ");
+
+  // this will restore the guard page if the user is using a sigaltstack
+  if (sf->si.si_errno == kNtStatusGuardPageViolation)
+    __sig_reguard(sf->si.si_addr);
+
+  // call the user signal handler
+  // and a modifiable view of the faulting code's cpu state
+  // then finally restore signal mask and return control to program
+  __sig_handler(sf->rva)(sf->si.si_signo, &sf->si, &sf->ctx);
+  atomic_store_explicit(&__get_tls()->tib_sigmask, sf->ctx.uc_sigmask,
+                        memory_order_release);
+  setcontext(&sf->ctx);
+  __builtin_unreachable();
+}
+
+//                         abashed the devil stood
+//                      and felt how awful goodness is
+__msabi HAIRY static unsigned __sig_crash(struct NtExceptionPointers *ep) {
+
+  // translate the win32 exception code into unix's si_signo and si_code
+  int sic, sig = __sig_crash_sig(ep->ExceptionRecord->ExceptionCode, &sic);
+
+  // advances the instruction pointer, to skip over debugger breakpoints
+  // this makes windows consistent with how unix kernels are implemented
+  if (sig == SIGTRAP)
+    ep->ContextRecord->Rip++;
+
+  // clears signal handler if user asked sigaction for one-shot behavior
+  unsigned rva = __sighandrvas[sig];
+  unsigned flags = __sighandflags[sig];
+  if (flags & SA_RESETHAND)
+    __sighandrvas[sig] = (int32_t)(intptr_t)SIG_DFL;
+
+  // we don't know if it is safe for signal handlers to longjmp() out of
+  // win32 vectored exception handlers so let's copy the machine context
+  // and tell win32 to restore control to __sig_unmaskable() which shall
+  // call the user signal handler safely. please note that if this crash
+  // was caused by stack overflow, then we're literally executing inside
+  // the guard page so this code can't use more than 4096 bytes of stack
+  uintptr_t sp;
+  struct CosmoTib *tib = __get_tls();
+  if (__sig_should_use_altstack(flags, tib)) {
+    sp = (uintptr_t)tib->tib_sigstack_addr + tib->tib_sigstack_size;
+  } else {
+    size_t n = sizeof(struct SignalFrame) + 32;
+    sp = (uintptr_t)alloca(n) + n;
+  }
+  sp -= sizeof(struct SignalFrame);
+  sp &= -16;
+  struct SignalFrame *sf = (struct SignalFrame *)sp;
+  __repstosb(sf, 0, sizeof(*sf));
+  __sig_translate(&sf->ctx, ep->ContextRecord);
+  sf->rva = rva;
+  sf->flags = flags;
+  sf->si.si_code = sic;
+  sf->si.si_signo = sig;
+  sf->si.si_errno = ep->ExceptionRecord->ExceptionCode;
+  if (sf->si.si_errno == kNtStatusGuardPageViolation) {
+    sf->si.si_addr = (void *)ep->ExceptionRecord->ExceptionInformation[1];
+  } else {
+    sf->si.si_addr = ep->ExceptionRecord->ExceptionAddress;
+  }
+  *(uintptr_t *)(sp -= sizeof(uintptr_t)) = ep->ContextRecord->Rip;
+  ep->ContextRecord->Rip = (intptr_t)__sig_unmaskable;
+  ep->ContextRecord->Rdi = (intptr_t)sf;
+  ep->ContextRecord->Rsp = sp;
+  return kNtExceptionContinueExecution;
+}
+
+textwindows static int __sig_console_sig(uint32_t dwCtrlType) {
+  switch (dwCtrlType) {
+    case kNtCtrlCEvent:
+      return SIGINT;
+    case kNtCtrlBreakEvent:
+      return SIGQUIT;
+    case kNtCtrlCloseEvent:
+    case kNtCtrlLogoffEvent:    // only received by services
+    case kNtCtrlShutdownEvent:  // only received by services
+      return SIGHUP;
+    default:
+      return SIGSTKFLT;
+  }
+}
+
+textwindows static int __sig_console_char(uint32_t dwCtrlType) {
+  switch (dwCtrlType) {
+    case kNtCtrlCEvent:
+      return __ttyconf.vintr;
+    case kNtCtrlBreakEvent:
+      return __ttyconf.vquit;
+    default:
+      return _POSIX_VDISABLE;
+  }
+}
+
+__msabi HAIRY bool32 __sig_console(uint32_t dwCtrlType) {
+  // win32 launches a thread to deliver ctrl-c and ctrl-break when typed
+  // it only happens when kNtEnableProcessedInput is in play on console.
+  // otherwise we need to wait until read-nt.c discovers that keystroke.
+  struct CosmoTib tls;
+  __bootstrap_tls(&tls, __builtin_frame_address(0));
+
+  // ensure that ^C or ^\ gets printed to console appropriately
+  if (_weaken(EchoConsoleNt)) {
+    char c;
+    if ((c = __sig_console_char(dwCtrlType)) != _POSIX_VDISABLE)
+      _weaken(EchoConsoleNt)(&c, sizeof(c), false);
+  }
+
+  // take control of random thread and inject call to signal handler
+  __sig_generate(__sig_console_sig(dwCtrlType), SI_KERNEL);
+  return true;
+}
+
+// returns 0 if no signal handlers were called, otherwise a bitmask
+// consisting of `1` which means a signal handler was invoked which
+// didn't have the SA_RESTART flag, and `2`, which means SA_RESTART
+// handlers were called (or `3` if both were the case).
+textwindows int __sig_check(void) {
+  int sig, res = 0;
+  while ((sig = __sig_get(atomic_load_explicit(&__get_tls()->tib_sigmask,
+                                               memory_order_acquire))))
+    res |= __sig_raise(sig, SI_KERNEL);
+  return res;
+}
+
+// background thread for delivering inter-process signals asynchronously
+// this checks for undelivered process-wide signals, once per scheduling
+// quantum, which on windows should be every ~15ms or so, unless somehow
+// the process was tuned to have more fine-grained event timing. we want
+// signals to happen faster when possible; that happens when cancelation
+// points, e.g. read need to wait on i/o; they too check for new signals
+HAIRY static uint32_t __sig_worker(void *arg) {
+  struct CosmoTib tls;
+  __bootstrap_tls(&tls, __builtin_frame_address(0));
+  char *sp = __builtin_frame_address(0);
+  __maps_track((char *)(((uintptr_t)sp + __pagesize - 1) & -__pagesize) - STKSZ,
+               STKSZ, PROT_READ | PROT_WRITE,
+               MAP_PRIVATE | MAP_ANONYMOUS | MAP_NOFORK);
+  for (;;) {
+    // ok sys_execve_nt() might disable this worker
+    if (~__sig_worker_state & 2) {
+
+      // dequeue all pending signals and fire them off. if there's no
+      // thread that can handle them then __sig_generate will requeue
+      // those signals back to __sig.process; hence the need for xchg
+      unsigned long sigs =
+          atomic_exchange_explicit(__sig.process, 0, memory_order_acq_rel);
+      while (sigs) {
+        int sig = bsfl(sigs) + 1;
+        sigs &= ~(1ull << (sig - 1));
+        __sig_generate(sig, SI_KERNEL);
+      }
+
+      // unblock stalled i/o signals in threads
+      _pthread_lock();
+      for (struct Dll *e = dll_first(_pthread_list); e;
+           e = dll_next(_pthread_list, e)) {
+        struct PosixThread *pt = POSIXTHREAD_CONTAINER(e);
+        if (atomic_load_explicit(&pt->pt_status, memory_order_acquire) >=
+            kPosixThreadTerminated)
+          break;
+        if (atomic_load_explicit(&pt->pt_blocker, memory_order_acquire) &&
+            (atomic_load_explicit(&pt->tib->tib_sigpending,
+                                  memory_order_acquire) &
+             ~atomic_load_explicit(&pt->pt_blkmask, memory_order_acquire)))
+          __sig_wake(pt, 0);
+      }
+      _pthread_unlock();
+
+      // unblock stalled asynchronous signals in threads
+      for (;;) {
+        sigset_t pending, mask;
+        struct PosixThread *mark = 0;
+        _pthread_lock();
+        for (struct Dll *e = dll_first(_pthread_list); e;
+             e = dll_next(_pthread_list, e)) {
+          struct PosixThread *pt = POSIXTHREAD_CONTAINER(e);
+          if (atomic_load_explicit(&pt->pt_status, memory_order_acquire) >=
+              kPosixThreadTerminated)
+            break;
+          pending = atomic_load_explicit(&pt->tib->tib_sigpending,
+                                         memory_order_acquire);
+          mask =
+              atomic_load_explicit(&pt->tib->tib_sigmask, memory_order_acquire);
+          if (pending & ~mask) {
+            _pthread_ref(pt);
+            mark = pt;
+            break;
+          }
+        }
+        _pthread_unlock();
+        if (!mark)
+          break;
+        while (!atomic_compare_exchange_weak_explicit(
+            &mark->tib->tib_sigpending, &pending, pending & ~mask,
+            memory_order_acq_rel, memory_order_relaxed)) {
+        }
+        while ((pending = pending & ~mask)) {
+          int sig = bsfl(pending) + 1;
+          pending &= ~(1ull << (sig - 1));
+          __sig_killer(mark, sig, SI_KERNEL);
+        }
+        _pthread_unref(mark);
+      }
+    }
+
+    // wait until next scheduler quantum
+    __sig_worker_state |= 1;
+    Sleep(POLL_INTERVAL_MS);
+    __sig_worker_state &= ~1;
+  }
+  __builtin_unreachable();
+}
+
+__attribute__((__constructor__(10))) textstartup void __sig_init(void) {
+  if (!IsWindows())
+    return;
+  AddVectoredExceptionHandler(true, (void *)__sig_crash);
+  SetConsoleCtrlHandler((void *)__sig_console, true);
+  CreateThread(0, STKSZ, __sig_worker, 0, kNtStackSizeParamIsAReservation, 0);
+}
+
+#endif /* __x86_64__ */
diff --git a/libc/intrin/sigblock.c b/libc/intrin/sigblock.c
new file mode 100644
index 000000000..919dced56
--- /dev/null
+++ b/libc/intrin/sigblock.c
@@ -0,0 +1,57 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/sig.internal.h"
+#include "libc/calls/struct/sigset.internal.h"
+#include "libc/dce.h"
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/weaken.h"
+#include "libc/sysv/consts/sig.h"
+#include "libc/thread/tls.h"
+
+// since there's so many c library interfaces and system call wrappers
+// that always need to block signals we avoid the distraction of their
+// ftrace and strace output being muddied with sigprocmask lines. it's
+// usually better that sigprocmask only strace the user is calling it.
+// plus, since we have a very specific use case, this code goes faster
+
+sigset_t __sig_block(void) {
+  if (IsWindows() || IsMetal()) {
+    if (__tls_enabled)
+      return atomic_exchange_explicit(&__get_tls()->tib_sigmask, -1,
+                                      memory_order_acquire);
+    else
+      return 0;
+  } else {
+    sigset_t res, neu = -1;
+    sys_sigprocmask(SIG_SETMASK, &neu, &res);
+    return res;
+  }
+}
+
+void __sig_unblock(sigset_t m) {
+  if (IsWindows() || IsMetal()) {
+    if (__tls_enabled) {
+      atomic_store_explicit(&__get_tls()->tib_sigmask, m, memory_order_release);
+      if (_weaken(__sig_check))
+        _weaken(__sig_check)();
+    }
+  } else {
+    sys_sigprocmask(SIG_SETMASK, &m, 0);
+  }
+}
diff --git a/libc/intrin/sigcrashsig.c b/libc/intrin/sigcrashsig.c
new file mode 100644
index 000000000..060c2b310
--- /dev/null
+++ b/libc/intrin/sigcrashsig.c
@@ -0,0 +1,116 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/sig.internal.h"
+#include "libc/intrin/pushpop.h"
+#include "libc/macros.h"
+#include "libc/nt/enum/signal.h"
+#include "libc/nt/enum/status.h"
+#include "libc/nt/struct/ntexceptionpointers.h"
+
+// this is all a mandatory dependency of winmain
+// so, we trade away maintanibility for tininess
+// see libc/sysv/consts.sh for canonical magnums
+
+#define SIGILL_  4
+#define SIGTRAP_ 5
+#define SIGABRT_ 6
+#define SIGFPE_  8
+#define SIGSEGV_ 11
+#define SIGSYS_  31
+
+#define TRAP_BRKPT_  1
+#define ILL_ILLOPC_  1
+#define ILL_PRVOPC_  5
+#define SEGV_MAPERR_ 1
+#define SEGV_ACCERR_ 2
+#define SI_USER_     0
+#define FPE_FLTDIV_  3
+#define FPE_FLTOVF_  4
+#define FPE_INTOVF_  2
+#define FPE_FLTUND_  5
+#define FPE_FLTRES_  6
+#define FPE_FLTINV_  7
+#define SI_KERNEL_   128
+
+#define LO(x) (x & 255)
+#define HI(x) ((x >> 24) / !(x & 0x00ffff00u))
+#define ROW(x, sic, sig)                                                   \
+  {                                                                        \
+    {                                                                      \
+      {                                                                    \
+        LO(x), HI(x), sic / !(sic & 0xffffff00), sig / !(sig & 0xffffff00) \
+      }                                                                    \
+    }                                                                      \
+  }
+
+struct CrashSig {
+  union {
+    struct {
+      unsigned char lo;
+      unsigned char hi;
+      unsigned char sic;
+      unsigned char sig;
+    };
+    unsigned word;
+  };
+};
+
+static const struct CrashSig kNtCrashSigs[] = {
+    ROW(kNtSignalBreakpoint, TRAP_BRKPT_, SIGTRAP_),          //
+    ROW(kNtSignalIllegalInstruction, ILL_ILLOPC_, SIGILL_),   //
+    ROW(kNtSignalPrivInstruction, ILL_PRVOPC_, SIGILL_),      //
+    ROW(kNtSignalInPageError, SEGV_MAPERR_, SIGSEGV_),        //
+    ROW(kNtStatusStackOverflow, SEGV_MAPERR_, SIGSEGV_),      //
+    ROW(kNtSignalGuardPage, SEGV_ACCERR_, SIGSEGV_),          //
+    ROW(kNtSignalAccessViolation, SEGV_ACCERR_, SIGSEGV_),    //
+    ROW(kNtSignalInvalidHandle, SI_USER_, SIGABRT_),          //
+    ROW(kNtSignalInvalidParameter, SI_USER_, SIGABRT_),       //
+    ROW(kNtStatusIntegerOverflow, FPE_INTOVF_, SIGFPE_),      //
+    ROW(kNtSignalFltDivideByZero, FPE_FLTDIV_, SIGFPE_),      //
+    ROW(kNtSignalFltOverflow, FPE_FLTOVF_, SIGFPE_),          //
+    ROW(kNtSignalFltUnderflow, FPE_FLTUND_, SIGFPE_),         //
+    ROW(kNtSignalFltInexactResult, FPE_FLTRES_, SIGFPE_),     //
+    ROW(kNtSignalFltDenormalOperand, FPE_FLTINV_, SIGFPE_),   //
+    ROW(kNtSignalFltInvalidOperation, FPE_FLTINV_, SIGFPE_),  //
+    ROW(kNtSignalFltStackCheck, FPE_FLTINV_, SIGFPE_),        //
+    ROW(kNtSignalIntegerDivideByZero, FPE_FLTINV_, SIGFPE_),  //
+    // ROW(kNtSignalAssertionFailure, SI_USER_, SIGABRT_),
+    // ROW(kNtSignalFloatMultipleTraps, FPE_FLTINV_, SIGFPE_),
+    // ROW(kNtSignalFloatMultipleFaults, FPE_FLTINV_, SIGFPE_),
+    // ROW(kNtSignalDllNotFound, SI_KERNEL_, SIGSYS_),
+    // ROW(kNtSignalOrdinalNotFound, SI_KERNEL_, SIGSYS_),
+    // ROW(kNtSignalEntrypointNotFound, SI_KERNEL_, SIGSYS_),
+    // ROW(kNtSignalDllInitFailed, SI_KERNEL_, SIGSYS_),
+};
+
+textwindows dontinstrument int __sig_crash_sig(unsigned exception, int *code) {
+  for (int i = 0; i < ARRAYLEN(kNtCrashSigs); ++i) {
+    struct CrashSig cs;
+    cs.word = kNtCrashSigs[i].word;
+    unsigned lo = cs.lo;
+    unsigned hi = cs.hi;
+    unsigned ec = lo | hi << 24;
+    if (ec == exception) {
+      *code = cs.sic;
+      return cs.sig;
+    }
+  }
+  *code = exception;
+  return SIGSEGV_;
+}
diff --git a/libc/intrin/sigproc.c b/libc/intrin/sigproc.c
new file mode 100644
index 000000000..e3f6d0673
--- /dev/null
+++ b/libc/intrin/sigproc.c
@@ -0,0 +1,126 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
+#include "libc/calls/sig.internal.h"
+#include "libc/fmt/internal.h"
+#include "libc/nt/createfile.h"
+#include "libc/nt/enum/accessmask.h"
+#include "libc/nt/enum/creationdisposition.h"
+#include "libc/nt/enum/fileflagandattributes.h"
+#include "libc/nt/enum/filemapflags.h"
+#include "libc/nt/enum/filemovemethod.h"
+#include "libc/nt/enum/filesharemode.h"
+#include "libc/nt/enum/pageflags.h"
+#include "libc/nt/files.h"
+#include "libc/nt/memory.h"
+#include "libc/nt/process.h"
+#include "libc/nt/runtime.h"
+#include "libc/nt/thunk/msabi.h"
+#ifdef __x86_64__
+
+#define ABI __msabi textwindows dontinstrument
+
+// cut back on code size and avoid setting errno
+// this code is a mandatory dependency of winmain
+__msabi extern typeof(CloseHandle) *const __imp_CloseHandle;
+__msabi extern typeof(CreateDirectory) *const __imp_CreateDirectoryW;
+__msabi extern typeof(CreateFile) *const __imp_CreateFileW;
+__msabi extern typeof(CreateFileMapping) *const __imp_CreateFileMappingW;
+__msabi extern typeof(MapViewOfFileEx) *const __imp_MapViewOfFileEx;
+__msabi extern typeof(SetEndOfFile) *const __imp_SetEndOfFile;
+__msabi extern typeof(SetFilePointer) *const __imp_SetFilePointer;
+__msabi extern typeof(GetEnvironmentVariable)
+    *const __imp_GetEnvironmentVariableW;
+
+// Generates C:\ProgramData\cosmo\sig\x\y.pid like path
+ABI char16_t *__sig_process_path(char16_t *path, uint32_t pid,
+                                 int create_directories) {
+  char16_t buf[3];
+  char16_t *p = path;
+  uint32_t vlen = __imp_GetEnvironmentVariableW(u"SYSTEMDRIVE", buf, 3);
+  *p++ = vlen == 2 ? buf[0] : 'C';
+  *p++ = ':';
+  *p++ = '\\';
+  *p++ = 'P';
+  *p++ = 'r';
+  *p++ = 'o';
+  *p++ = 'g';
+  *p++ = 'r';
+  *p++ = 'a';
+  *p++ = 'm';
+  *p++ = 'D';
+  *p++ = 'a';
+  *p++ = 't';
+  *p++ = 'a';
+  *p = 0;
+  if (create_directories)
+    __imp_CreateDirectoryW(path, 0);
+  *p++ = '\\';
+  *p++ = 'c';
+  *p++ = 'o';
+  *p++ = 's';
+  *p++ = 'm';
+  *p++ = 'o';
+  *p = 0;
+  if (create_directories)
+    __imp_CreateDirectoryW(path, 0);
+  *p++ = '\\';
+  *p++ = 's';
+  *p++ = 'i';
+  *p++ = 'g';
+  *p = 0;
+  if (create_directories)
+    __imp_CreateDirectoryW(path, 0);
+  *p++ = '\\';
+  p = __itoa16(p, (pid & 0x000ff800) >> 11);
+  *p = 0;
+  if (create_directories)
+    __imp_CreateDirectoryW(path, 0);
+  *p++ = '\\';
+  p = __itoa16(p, pid);
+  *p++ = '.';
+  *p++ = 'p';
+  *p++ = 'i';
+  *p++ = 'd';
+  *p = 0;
+  return path;
+}
+
+ABI atomic_ulong *__sig_map_process(int pid, int disposition) {
+  char16_t path[128];
+  __sig_process_path(path, pid, disposition == kNtOpenAlways);
+  intptr_t hand = __imp_CreateFileW(path, kNtGenericRead | kNtGenericWrite,
+                                    kNtFileShareRead | kNtFileShareWrite, 0,
+                                    disposition, kNtFileAttributeNormal, 0);
+  if (hand == -1)
+    return 0;
+  __imp_SetFilePointer(hand, 8, 0, kNtFileBegin);
+  __imp_SetEndOfFile(hand);
+  intptr_t map = __imp_CreateFileMappingW(hand, 0, kNtPageReadwrite, 0, 8, 0);
+  if (!map) {
+    __imp_CloseHandle(hand);
+    return 0;
+  }
+  atomic_ulong *sigs = __imp_MapViewOfFileEx(map, kNtFileMapWrite, 0, 0, 8, 0);
+  __imp_CloseHandle(map);
+  __imp_CloseHandle(hand);
+  return sigs;
+}
+
+#endif /* __x86_64__ */
diff --git a/libc/intrin/sigprocmask-nt.c b/libc/intrin/sigprocmask-nt.c
index 0d31b61af..38246b430 100644
--- a/libc/intrin/sigprocmask-nt.c
+++ b/libc/intrin/sigprocmask-nt.c
@@ -16,7 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/intrin/atomic.h"
@@ -27,38 +26,25 @@
 #ifdef __x86_64__
 
 textwindows int __sig_mask(int how, const sigset_t *neu, sigset_t *old) {
-
-  // validate api usage
-  if (how != SIG_BLOCK && how != SIG_UNBLOCK && how != SIG_SETMASK) {
+  if (how != SIG_BLOCK && how != SIG_UNBLOCK && how != SIG_SETMASK)
     return einval();
-  }
-
-  // get address of sigset to modify
-  _Atomic(uint64_t) *mask = &__get_tls()->tib_sigmask;
-
-  // handle read-only case
   sigset_t oldmask;
+  atomic_ulong *mask = &__get_tls()->tib_sigmask;
   if (neu) {
     if (how == SIG_BLOCK) {
-      oldmask = atomic_fetch_or_explicit(mask, *neu, memory_order_acq_rel);
+      oldmask = atomic_fetch_or(mask, *neu);
     } else if (how == SIG_UNBLOCK) {
-      oldmask = atomic_fetch_and_explicit(mask, ~*neu, memory_order_acq_rel);
-    } else {  // SIG_SETMASK
-      oldmask = atomic_exchange_explicit(mask, *neu, memory_order_acq_rel);
+      oldmask = atomic_fetch_and(mask, ~*neu);
+    } else {
+      oldmask = atomic_exchange(mask, *neu);
     }
+    if (_weaken(__sig_check))
+      _weaken(__sig_check)();
   } else {
-    oldmask = atomic_load_explicit(mask, memory_order_acquire);
+    oldmask = atomic_load(mask);
   }
-
-  // return old signal mask to caller
-  if (old) {
+  if (old)
     *old = oldmask;
-  }
-
-  if (_weaken(__sig_check)) {
-    _weaken(__sig_check)();
-  }
-
   return 0;
 }
 
diff --git a/libc/intrin/sigprocmask-sysv.c b/libc/intrin/sigprocmask-sysv.c
index 685f36c15..c7a43aaeb 100644
--- a/libc/intrin/sigprocmask-sysv.c
+++ b/libc/intrin/sigprocmask-sysv.c
@@ -32,8 +32,7 @@ int sys_sigprocmask(int how, const sigset_t *opt_set,
         how, opt_set ? (sigset_t *)(intptr_t)(uint32_t)*opt_set : 0, 0, 0);
     rc = 0;
   }
-  if (rc != -1 && opt_out_oldset) {
+  if (rc != -1 && opt_out_oldset)
     *opt_out_oldset = old[0];
-  }
   return rc;
 }
diff --git a/libc/intrin/sigprocmask.c b/libc/intrin/sigprocmask.c
index aa77cac8c..bb1406624 100644
--- a/libc/intrin/sigprocmask.c
+++ b/libc/intrin/sigprocmask.c
@@ -16,18 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/dce.h"
-#include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/sig.h"
-#include "libc/sysv/errfuns.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Changes signal blocking state of calling thread, e.g.:
@@ -55,9 +49,8 @@ int sigprocmask(int how, const sigset_t *opt_set, sigset_t *opt_out_oldset) {
   } else {
     rc = sys_sigprocmask(how, opt_set, opt_out_oldset ? &old : 0);
   }
-  if (rc != -1 && opt_out_oldset) {
+  if (rc != -1 && opt_out_oldset)
     *opt_out_oldset = old;
-  }
   STRACE("sigprocmask(%s, %s, [%s]) → %d% m", DescribeHow(how),
          DescribeSigset(0, opt_set), DescribeSigset(rc, opt_out_oldset), rc);
   return rc;
diff --git a/libc/intrin/sigvar.c b/libc/intrin/sigvar.c
new file mode 100644
index 000000000..21c1d2945
--- /dev/null
+++ b/libc/intrin/sigvar.c
@@ -0,0 +1,21 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/sig.internal.h"
+
+struct Signals __sig;
diff --git a/libc/intrin/sizefmt.c b/libc/intrin/sizefmt.c
index a3cb8ea6b..14e52c9f9 100644
--- a/libc/intrin/sizefmt.c
+++ b/libc/intrin/sizefmt.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /**
  * Represents size as readable string.
diff --git a/libc/intrin/stack.c b/libc/intrin/stack.c
new file mode 100644
index 000000000..27a20a06c
--- /dev/null
+++ b/libc/intrin/stack.c
@@ -0,0 +1,513 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/stack.h"
+#include "libc/assert.h"
+#include "libc/atomic.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/dlopen/dlfcn.h"
+#include "libc/errno.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/dll.h"
+#include "libc/intrin/maps.h"
+#include "libc/intrin/rlimit.h"
+#include "libc/intrin/strace.h"
+#include "libc/intrin/weaken.h"
+#include "libc/limits.h"
+#include "libc/macros.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sock/internal.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
+#include "libc/thread/posixthread.internal.h"
+#include "libc/thread/thread.h"
+
+/**
+ * @fileoverview cosmo stack memory manager
+ */
+
+#define MAP_GROWSDOWN_LINUX 0x00000100
+#define MAP_ANONYMOUS_LINUX 0x00000020
+#define MAP_NOREPLACE_LINUX 0x08000000
+#define MAP_NORESERVE_LINUX 0x00004000
+
+#define MAP_ANON_OPENBSD  0x1000
+#define MAP_STACK_OPENBSD 0x4000
+
+#define THREADSTACK_CONTAINER(e) DLL_CONTAINER(struct CosmoStack, elem, e)
+
+struct CosmoStack {
+  struct Dll elem;
+  void *stackaddr;
+  size_t stacksize;
+  size_t guardsize;
+};
+
+struct CosmoStacks {
+  atomic_uint once;
+  pthread_mutex_t lock;
+  struct Dll *stacks;
+  struct Dll *objects;
+  unsigned count;
+};
+
+struct CosmoStacksConfig {
+  unsigned maxstacks;
+};
+
+static struct CosmoStacks cosmo_stacks = {
+    .lock = PTHREAD_MUTEX_INITIALIZER,
+};
+
+static struct CosmoStacksConfig cosmo_stacks_config = {
+    .maxstacks = 3,
+};
+
+void cosmo_stack_lock(void) {
+  _pthread_mutex_lock(&cosmo_stacks.lock);
+}
+
+void cosmo_stack_unlock(void) {
+  _pthread_mutex_unlock(&cosmo_stacks.lock);
+}
+
+void cosmo_stack_wipe(void) {
+  _pthread_mutex_wipe_np(&cosmo_stacks.lock);
+}
+
+// map_growsdown will not grow more than rlimit_stack
+static size_t cosmo_stack_maxgrow(void) {
+  return __rlimit_stack_get().rlim_cur & -__pagesize;
+}
+
+// allocates private anonymous fixed noreplace memory on linux
+static void *flixmap(void *addr, size_t size, int prot, int flags) {
+  flags |= MAP_PRIVATE | MAP_ANONYMOUS_LINUX | MAP_NOREPLACE_LINUX;
+  void *res = __sys_mmap(addr, size, prot, flags, -1, 0, 0);
+  if (res != MAP_FAILED) {
+    if (res != addr) {
+      sys_munmap(addr, size);
+      errno = EEXIST;  // polyfill linux 4.17+ behavior
+      res = 0;
+    }
+  } else {
+    res = 0;
+  }
+  STRACE("mmap(%p, %'zu, %s, %s) → %p% m", addr, size, DescribeProtFlags(prot),
+         DescribeMapFlags(flags), res);
+  return res;
+}
+
+// maps stack on linux
+static void *slackmap(size_t stacksize, size_t guardsize) {
+  int olde = errno;
+  struct Map *prev, *map;
+  char *max = (char *)PTRDIFF_MAX;
+  size_t need = guardsize + stacksize;
+  __maps_lock();
+  for (;;) {
+
+    // look for empty space beneath higher mappings
+    char *region = 0;
+    for (map = __maps_floor(max); map; map = prev) {
+      char *min = (char *)(intptr_t)__gransize;
+      if ((prev = __maps_prev(map)))
+        min = prev->addr + ROUNDUP(prev->size, __gransize);
+      if (map->addr - min >= need) {
+        region = map->addr - need;
+        max = region - 1;
+        break;
+      }
+    }
+    if (!region)
+      break;
+
+    // track intended memory in rbtree
+    if (!__maps_track(region, guardsize, PROT_NONE,
+                      MAP_PRIVATE | MAP_ANONYMOUS_LINUX))
+      break;
+    if (!__maps_track(region + guardsize, stacksize, PROT_READ | PROT_WRITE,
+                      MAP_PRIVATE | MAP_ANONYMOUS_LINUX)) {
+      __maps_untrack(region, need);
+      break;
+    }
+    __maps_unlock();
+
+    // ask kernel to create guard region
+    // taking special care to not clobber untracked mappings
+    //
+    // it's important that this call happen first, since it limits how
+    // much memory map_growsdown will secretly consume. if there's
+    // nothing beneath a map_growsdown mapping, then the kernel reserves
+    // (and this isn't listed /proc/PID/maps so don't bother looking)
+    // `rlimit_stack.rlim_cur & -__pagesize` bytes of memory including
+    // this top-most page, and another 1mb of guard pages beneath that.
+    // but by mapping our guard pages manually, we ensure the guard
+    // region and the stack itself will be exactly as big as we want.
+    //
+    // you'd think we could mmap(0, pagesz, growsdown) to let the kernel
+    // pick an address and then we could just upscale the user's stack
+    // size request to whatever rlimit_stack is if it's bigger. but the
+    // linux kernel will actually choose addresses between existing maps
+    // where the hole is smaller than rlimit_stack.
+    //
+    // to use map_growsdown, we must use map_fixed. normally when we use
+    // map_fixed, we reserve an entire kernel-assigned region beforehand
+    // to ensure there isn't any overlap with existing mappings. however
+    // since growsdown stops growing when it encounters another mapping,
+    // you can't map it on top of a reservation mapping. so we must take
+    // a leap of faith there aren't any mystery mappings twixt the guard
+    // region and growsdown page below.
+    char *guard_region =
+        flixmap(region, guardsize, PROT_NONE, MAP_NORESERVE_LINUX);
+    if (!guard_region) {
+    RecoverFromMmapFailure:
+      if (errno != EEXIST) {
+        // mmap() probably raised enomem due to rlimit_as etc.
+        __maps_untrack(region, need);
+        return 0;
+      } else {
+        // we've encountered a mystery mapping. it's hard to imagine
+        // this happening, since we don't use map_growsdown when
+        // cosmo_dlopen() is linked in the binary. in that case, the
+        // tracker we created covers at least some of the rogue map,
+        // therefore this issue should fix itself if we keep going
+        errno = olde;
+        __maps_lock();
+        ++max;
+        continue;
+      }
+    }
+
+    // ask kernel to create stack pages
+    // taking special care to not clobber untracked mappings
+    char *top_page = flixmap(region + need - __pagesize, __pagesize,
+                             PROT_READ | PROT_WRITE, MAP_GROWSDOWN_LINUX);
+    if (!top_page) {
+      sys_munmap(region, guardsize);
+      goto RecoverFromMmapFailure;
+    }
+
+    // return address to bottom of stack
+    return region + guardsize;
+  }
+  __maps_unlock();
+  errno = ENOMEM;
+  return 0;
+}
+
+static errno_t cosmo_stack_munmap(char *stackaddr, size_t stacksize,
+                                  size_t guardsize) {
+  errno_t r = 0;
+  errno_t e = errno;
+  if (!munmap(stackaddr - guardsize,  //
+              guardsize + stacksize)) {
+    r = errno;
+    errno = e;
+  }
+  return r;
+}
+
+static void cosmo_stack_populate(void) {
+  errno_t e = errno;
+  void *map = mmap(0, __pagesize, PROT_READ | PROT_WRITE,
+                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  errno = e;
+  if (map != MAP_FAILED) {
+    struct CosmoStack *ts = map;
+    int n = __pagesize / sizeof(struct CosmoStack);
+    for (int i = 0; i < n; ++i) {
+      dll_init(&ts[i].elem);
+      dll_make_first(&cosmo_stacks.objects, &ts[i].elem);
+    }
+  }
+}
+
+static struct Dll *cosmo_stack_decimate(unsigned maxstacks) {
+  struct Dll *surplus = 0;
+  while (cosmo_stacks.count > maxstacks) {
+    struct Dll *e = dll_last(cosmo_stacks.stacks);
+    dll_remove(&cosmo_stacks.stacks, e);
+    dll_make_first(&surplus, e);
+    --cosmo_stacks.count;
+  }
+  return surplus;
+}
+
+static void cosmo_stack_rehabilitate(struct Dll *stacks) {
+  struct Dll *e;
+  for (e = dll_first(stacks); e; e = dll_next(stacks, e))
+    cosmo_stack_munmap(THREADSTACK_CONTAINER(e)->stackaddr,
+                       THREADSTACK_CONTAINER(e)->stacksize,
+                       THREADSTACK_CONTAINER(e)->guardsize);
+  cosmo_stack_lock();
+  dll_make_first(&cosmo_stacks.objects, stacks);
+  cosmo_stack_unlock();
+}
+
+/**
+ * Empties unused stack cache.
+ *
+ * To make POSIX threads as cheap as possible to spawn, we recycle their
+ * stacks without zeroing their memory. On Linux for an 80kb stack size,
+ * that makes launching a thread take 40µs rather than 80µs. However the
+ * stack cache needs to be cleared in certain cases. This is called upon
+ * exit() automatically but anyone can clear this at any other time too.
+ *
+ * @see pthread_decimate_np()
+ */
+void cosmo_stack_clear(void) {
+  cosmo_stack_lock();
+  struct Dll *stacks = cosmo_stacks.stacks;
+  cosmo_stacks.stacks = 0;
+  cosmo_stacks.count = 0;
+  cosmo_stack_unlock();
+  cosmo_stack_rehabilitate(stacks);
+}
+
+/**
+ * Gets maximum number of unused stacks cosmo should cache.
+ * @see cosmo_stack_setmaxstacks()
+ */
+int cosmo_stack_getmaxstacks(void) {
+  return cosmo_stacks_config.maxstacks;
+}
+
+/**
+ * Sets maximum number of unused stacks cosmo should cache.
+ *
+ * This lets you place some limitations on how much stack memory the
+ * cosmo runtime will cache. This number is a count of stacks rather
+ * than the number of bytes they contain. Old stacks are freed in a
+ * least recently used fashion once the cache exceeds this limit.
+ *
+ * If this is set to zero, then the cosmo stack allocator enters a
+ * highly secure hardening mode where cosmo_stack_alloc() zeroes all
+ * stack memory that's returned.
+ *
+ * Setting this to a negative number makes the cache size unlimited.
+ *
+ * Please note this limit only applies to stacks that aren't in use.
+ *
+ * Your default is three stacks may be cached at any given moment.
+ *
+ * If `maxstacks` is less than the current cache size, then surplus
+ * entries will be evicted and freed before this function returns.
+ */
+void cosmo_stack_setmaxstacks(int maxstacks) {
+  cosmo_stack_lock();
+  cosmo_stacks_config.maxstacks = maxstacks;
+  struct Dll *stacks = cosmo_stack_decimate(maxstacks);
+  cosmo_stack_unlock();
+  cosmo_stack_rehabilitate(stacks);
+}
+
+/**
+ * Allocates stack memory.
+ *
+ * This is a caching stack allocator that's used by the POSIX threads
+ * runtime but you may also find it useful for setcontext() coroutines
+ * or sigaltstack(). Normally you can get away with using malloc() for
+ * creating stacks. However some OSes (e.g. OpenBSD) forbid you from
+ * doing that for anything except sigaltstack(). This API serves to
+ * abstract all the gory details of gaining authorized memory, and
+ * additionally implements caching for lightning fast performance.
+ *
+ * The stack size must be nonzero. It specifies the minimum amount of
+ * stack space that will be available for use. The provided value is
+ * rounded up to the system page size. It may be increased further for
+ * various reasons. Your stack size parameter will be updated with the
+ * chosen value upon success.
+ *
+ * The guard size specifies the minimum amount of memory that should be
+ * protected beneath your stack. This helps ensure stack overflows cause
+ * a segfault rather than corrupting memory silently. This may be set to
+ * zero in which case no guard pages will be made. This value is rounded
+ * up to the system page size. The corrected value will be returned upon
+ * success. Your guard size needs to be small enough to leave room for
+ * at least one memory page in your stack size i.e. `guardsize +
+ * pagesize <= stacksize` must be the case. Otherwise this function will
+ * return an `EINVAL` error.
+ *
+ * When you're done using your stack, pass it to cosmo_stack_free() so
+ * it can be recycled. Stacks are only recycled when the `stacksize` and
+ * `guardsize` parameters match the constraints described above. Stacks
+ * that don't end up getting reused will be freed eventually, in a least
+ * recently used way based upon your cosmo_stack_setmaxstacks() setting.
+ *
+ * This function returns 0 on success, or an errno on error. See the
+ * documentation of mmap() for a list possible errors that may occur.
+ */
+errno_t cosmo_stack_alloc(size_t *inout_stacksize,  //
+                          size_t *inout_guardsize,  //
+                          void **out_stackaddr) {
+
+  // validate arguments
+  size_t stacksize = *inout_stacksize;
+  size_t guardsize = *inout_guardsize;
+  stacksize = (stacksize + __pagesize - 1) & -__pagesize;
+  guardsize = (guardsize + __pagesize - 1) & -__pagesize;
+  if (!stacksize)
+    return EINVAL;
+
+  // recycle stack
+  void *stackaddr = 0;
+  cosmo_stack_lock();
+  for (struct Dll *e = dll_first(cosmo_stacks.stacks); e;
+       e = dll_next(cosmo_stacks.stacks, e)) {
+    struct CosmoStack *ts = THREADSTACK_CONTAINER(e);
+    if (ts->stacksize == stacksize &&  //
+        ts->guardsize == guardsize) {
+      stackaddr = ts->stackaddr;
+      stacksize = ts->stacksize;
+      guardsize = ts->guardsize;
+      dll_remove(&cosmo_stacks.stacks, e);
+      dll_make_first(&cosmo_stacks.objects, e);
+      --cosmo_stacks.count;
+      break;
+    }
+  }
+  cosmo_stack_unlock();
+
+  // create stack
+  if (!stackaddr) {
+    errno_t olde = errno;
+    if (!IsTiny() && IsLinux() && guardsize && !_weaken(cosmo_dlopen) &&
+        stacksize <= cosmo_stack_maxgrow() && !IsQemuUser()) {
+      // this special linux-only stack allocator significantly reduces
+      // the consumption of virtual memory.
+      if (!(stackaddr = slackmap(stacksize, guardsize))) {
+        errno_t err = errno;
+        errno = olde;
+        return err;
+      }
+    } else {
+      char *map = mmap(0, guardsize + stacksize, PROT_READ | PROT_WRITE,
+                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+      if (map == MAP_FAILED) {
+        errno_t err = errno;
+        errno = olde;
+        return err;
+      }
+      stackaddr = map + guardsize;
+      if (IsOpenbsd())
+        if (!TellOpenbsdThisIsStackMemory(stackaddr, stacksize))
+          notpossible;
+      if (guardsize) {
+        if (mprotect(map, guardsize, PROT_NONE | PROT_GUARD)) {
+          errno_t err = errno;
+          munmap(map, guardsize + stacksize);
+          errno = olde;
+          return err;
+        }
+      }
+    }
+  }
+
+  // return stack
+  *inout_stacksize = stacksize;
+  *inout_guardsize = guardsize;
+  *out_stackaddr = stackaddr;
+  return 0;
+}
+
+static void cosmo_stack_setup(void) {
+  atexit(cosmo_stack_clear);
+}
+
+/**
+ * Frees stack memory.
+ *
+ * While not strictly required, it's assumed the three parameters are
+ * those returned by an earlier call to cosmo_stack_alloc(). If they
+ * aren't page aligned and rounded, this function will return EINVAL.
+ *
+ * This function returns 0 on success, or an errno on error. The `errno`
+ * variable is never clobbered. You can only dependably count on this to
+ * return an error on failure when you say `cosmo_stack_setmaxstacks(0)`
+ */
+errno_t cosmo_stack_free(void *stackaddr, size_t stacksize, size_t guardsize) {
+  if (!stacksize)
+    return EINVAL;
+  if (stacksize & (__pagesize - 1))
+    return EINVAL;
+  if (guardsize & (__pagesize - 1))
+    return EINVAL;
+  if ((uintptr_t)stackaddr & (__pagesize - 1))
+    return EINVAL;
+  cosmo_stack_lock();
+  struct Dll *surplus = 0;
+  if (cosmo_stacks_config.maxstacks) {
+    cosmo_once(&cosmo_stacks.once, cosmo_stack_setup);
+    surplus = cosmo_stack_decimate(cosmo_stacks_config.maxstacks - 1);
+    struct CosmoStack *ts = 0;
+    if (dll_is_empty(cosmo_stacks.objects))
+      cosmo_stack_populate();
+    struct Dll *e;
+    if ((e = dll_first(cosmo_stacks.objects))) {
+      dll_remove(&cosmo_stacks.objects, e);
+      ts = THREADSTACK_CONTAINER(e);
+    }
+    if (ts) {
+      ts->stackaddr = stackaddr;
+      ts->stacksize = stacksize;
+      ts->guardsize = guardsize;
+      dll_make_first(&cosmo_stacks.stacks, &ts->elem);
+      ++cosmo_stacks.count;
+      stackaddr = 0;
+    }
+  }
+  cosmo_stack_unlock();
+  cosmo_stack_rehabilitate(surplus);
+  errno_t err = 0;
+  if (stackaddr)
+    err = cosmo_stack_munmap(stackaddr, stacksize, guardsize);
+  return err;
+}
+
+relegated bool TellOpenbsdThisIsStackMemory(void *addr, size_t size) {
+  return __sys_mmap(
+             addr, size, PROT_READ | PROT_WRITE,
+             MAP_PRIVATE | MAP_FIXED | MAP_ANON_OPENBSD | MAP_STACK_OPENBSD, -1,
+             0, 0) == addr;
+}
+
+// OpenBSD only permits RSP to occupy memory that's been explicitly
+// defined as stack memory, i.e. `lo <= %rsp < hi` must be the case
+relegated bool FixupCustomStackOnOpenbsd(pthread_attr_t *attr) {
+
+  // get interval
+  uintptr_t lo = (uintptr_t)attr->__stackaddr;
+  uintptr_t hi = lo + attr->__stacksize;
+
+  // squeeze interval
+  lo = (lo + __pagesize - 1) & -__pagesize;
+  hi = hi & -__pagesize;
+
+  // tell os it's stack memory
+  if (!TellOpenbsdThisIsStackMemory((void *)lo, hi - lo))
+    return false;
+
+  // update attributes with usable stack address
+  attr->__stackaddr = (void *)lo;
+  attr->__stacksize = hi - lo;
+  return true;
+}
diff --git a/libc/intrin/stack.h b/libc/intrin/stack.h
new file mode 100644
index 000000000..282244547
--- /dev/null
+++ b/libc/intrin/stack.h
@@ -0,0 +1,14 @@
+#ifndef COSMOPOLITAN_LIBC_STACK_H_
+#define COSMOPOLITAN_LIBC_STACK_H_
+#include "libc/thread/thread.h"
+COSMOPOLITAN_C_START_
+
+void cosmo_stack_lock(void);
+void cosmo_stack_unlock(void);
+void cosmo_stack_wipe(void);
+
+bool TellOpenbsdThisIsStackMemory(void *, size_t);
+bool FixupCustomStackOnOpenbsd(pthread_attr_t *);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_STACK_H_ */
diff --git a/libc/intrin/stackcall.S b/libc/intrin/stackcall.S
index 6ad9bc8ec..6e3658a47 100644
--- a/libc/intrin/stackcall.S
+++ b/libc/intrin/stackcall.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Calls function on different stack.
 //
diff --git a/libc/intrin/stackchkguard.S b/libc/intrin/stackchkguard.S
index b78117a5d..f35484a8e 100644
--- a/libc/intrin/stackchkguard.S
+++ b/libc/intrin/stackchkguard.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Canary for -fstack-protector.
 //
diff --git a/libc/intrin/stdio.c b/libc/intrin/stdio.c
new file mode 100644
index 000000000..f487b0867
--- /dev/null
+++ b/libc/intrin/stdio.c
@@ -0,0 +1,96 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/weaken.h"
+#include "libc/mem/mem.h"
+#include "libc/stdio/internal.h"
+#include "libc/thread/posixthread.internal.h"
+
+#define STDIO_FILE_USE_AFTER_FREE 1
+#define CORRUPT_STDIO_FILE_OBJECT 1
+
+struct Stdio __stdio = {
+    .lock = PTHREAD_MUTEX_INITIALIZER,
+};
+
+void __stdio_lock(void) {
+  _pthread_mutex_lock(&__stdio.lock);
+}
+
+void __stdio_unlock(void) {
+  _pthread_mutex_unlock(&__stdio.lock);
+}
+
+static int refchk(int refs) {
+  unassert(refs != STDIO_FILE_USE_AFTER_FREE);
+  unassert(refs < CORRUPT_STDIO_FILE_OBJECT);
+  return refs;
+}
+
+void __stdio_ref(FILE *f) {
+  refchk(atomic_fetch_sub_explicit(&f->refs, 1, memory_order_relaxed));
+}
+
+static void __stdio_unref_impl(FILE *f, bool should_lock) {
+  int refs = atomic_load_explicit(&f->refs, memory_order_relaxed);
+  for (;;) {
+    refchk(refs);
+    if (refs) {
+      if (atomic_compare_exchange_strong_explicit(&f->refs, &refs, refs + 1,
+                                                  memory_order_acq_rel,
+                                                  memory_order_relaxed))
+        return;
+      continue;
+    }
+    if (should_lock) {
+      __stdio_lock();
+      if ((refs = atomic_load_explicit(&f->refs, memory_order_relaxed))) {
+        __stdio_unlock();
+        continue;
+      }
+    }
+    if (!atomic_compare_exchange_strong_explicit(
+            &f->refs, &refs, 1, memory_order_acq_rel, memory_order_relaxed)) {
+      if (should_lock)
+        __stdio_unlock();
+      continue;
+    }
+    dll_remove(&__stdio.files, &f->elem);
+    if (should_lock)
+      __stdio_unlock();
+    break;
+  }
+  if (_weaken(free)) {
+    _weaken(free)(f->getln);
+    if (f->freebuf)
+      _weaken(free)(f->buf);
+    if (f->freethis)
+      _weaken(free)(f);
+  }
+}
+
+void __stdio_unref(FILE *f) {
+  __stdio_unref_impl(f, true);
+}
+
+void __stdio_unref_unlocked(FILE *f) {
+  __stdio_unref_impl(f, false);
+}
diff --git a/libc/intrin/strace.h b/libc/intrin/strace.h
new file mode 100644
index 000000000..b39a50709
--- /dev/null
+++ b/libc/intrin/strace.h
@@ -0,0 +1,66 @@
+#ifndef COSMOPOLITAN_LIBC_CALLS_STRACE_INTERNAL_H_
+#define COSMOPOLITAN_LIBC_CALLS_STRACE_INTERNAL_H_
+
+#ifndef SYSDEBUG
+#define SYSDEBUG 0
+#endif
+
+#ifdef MODE_DBG
+#define _STRACE_VERBOSE 1
+#else
+#define _STRACE_VERBOSE 0
+#endif
+
+#define _NTTRACE    _STRACE_VERBOSE /* not configurable w/ flag yet */
+#define _KERNTRACE  _STRACE_VERBOSE /* not configurable w/ flag yet */
+#define _POLLTRACE  _STRACE_VERBOSE /* not configurable w/ flag yet */
+#define _LOCKTRACE  _STRACE_VERBOSE /* not configurable w/ flag yet */
+#define _DATATRACE  1               /* not configurable w/ flag yet */
+#define _STDIOTRACE 0               /* not configurable w/ flag yet */
+#define _TIMETRACE  0               /* not configurable w/ flag yet */
+
+#define STRACE_PROLOGUE "%rSYS %6P %6H %'18T "
+
+#if !(__ASSEMBLER__ + __LINKER__ + 0)
+COSMOPOLITAN_C_START_
+
+#define STRACE(FMT, ...)                       \
+  ((void)(SYSDEBUG && strace_enabled(0) > 0 && \
+          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
+
+#define DATATRACE(FMT, ...)                                  \
+  ((void)(SYSDEBUG && _DATATRACE && strace_enabled(0) > 0 && \
+          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
+
+#define POLLTRACE(FMT, ...)                                  \
+  ((void)(SYSDEBUG && _POLLTRACE && strace_enabled(0) > 0 && \
+          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
+
+#define KERNTRACE(FMT, ...)                                                 \
+  ((void)(SYSDEBUG && _KERNTRACE && strace_enabled(0) > 0 &&                \
+          (__stracef(STRACE_PROLOGUE "\e[2m" FMT "\e[0m\n", ##__VA_ARGS__), \
+           0)))
+
+#define STDIOTRACE(FMT, ...)                                  \
+  ((void)(SYSDEBUG && _STDIOTRACE && strace_enabled(0) > 0 && \
+          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
+
+#define NTTRACE(FMT, ...)                                                   \
+  ((void)(SYSDEBUG && _NTTRACE && strace_enabled(0) > 0 &&                  \
+          (__stracef(STRACE_PROLOGUE "\e[2m" FMT "\e[0m\n", ##__VA_ARGS__), \
+           0)))
+
+#define LOCKTRACE(FMT, ...)                                  \
+  ((void)(SYSDEBUG && _LOCKTRACE && strace_enabled(0) > 0 && \
+          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
+
+#define TIMETRACE(FMT, ...)                                  \
+  ((void)(SYSDEBUG && _TIMETRACE && strace_enabled(0) > 0 && \
+          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
+
+int strace_enabled(int);
+void __stracef(const char *, ...);
+
+COSMOPOLITAN_C_END_
+#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+#endif /* COSMOPOLITAN_LIBC_CALLS_STRACE_INTERNAL_H_ */
diff --git a/libc/intrin/strace.internal.h b/libc/intrin/strace.internal.h
deleted file mode 100644
index 3c521857f..000000000
--- a/libc/intrin/strace.internal.h
+++ /dev/null
@@ -1,59 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_CALLS_STRACE_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_CALLS_STRACE_INTERNAL_H_
-
-#ifndef SYSDEBUG
-#define SYSDEBUG 0
-#endif
-
-#define _NTTRACE    0 /* not configurable w/ flag yet */
-#define _POLLTRACE  0 /* not configurable w/ flag yet */
-#define _DATATRACE  1 /* not configurable w/ flag yet */
-#define _LOCKTRACE  0 /* not configurable w/ flag yet */
-#define _STDIOTRACE 0 /* not configurable w/ flag yet */
-#define _KERNTRACE  0 /* not configurable w/ flag yet */
-#define _TIMETRACE  0 /* not configurable w/ flag yet */
-
-#define STRACE_PROLOGUE "%rSYS %6P %6H %'18T "
-
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-COSMOPOLITAN_C_START_
-
-#define STRACE(FMT, ...)                       \
-  ((void)(SYSDEBUG && strace_enabled(0) > 0 && \
-          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
-
-#define DATATRACE(FMT, ...)                                  \
-  ((void)(SYSDEBUG && _DATATRACE && strace_enabled(0) > 0 && \
-          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
-
-#define POLLTRACE(FMT, ...)                                  \
-  ((void)(SYSDEBUG && _POLLTRACE && strace_enabled(0) > 0 && \
-          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
-
-#define KERNTRACE(FMT, ...)                                  \
-  ((void)(SYSDEBUG && _KERNTRACE && strace_enabled(0) > 0 && \
-          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
-
-#define STDIOTRACE(FMT, ...)                                  \
-  ((void)(SYSDEBUG && _STDIOTRACE && strace_enabled(0) > 0 && \
-          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
-
-#define NTTRACE(FMT, ...)                                                   \
-  ((void)(SYSDEBUG && _NTTRACE && strace_enabled(0) > 0 &&                  \
-          (__stracef(STRACE_PROLOGUE "\e[2m" FMT "\e[0m\n", ##__VA_ARGS__), \
-           0)))
-
-#define LOCKTRACE(FMT, ...)                                  \
-  ((void)(SYSDEBUG && _LOCKTRACE && strace_enabled(0) > 0 && \
-          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
-
-#define TIMETRACE(FMT, ...)                                  \
-  ((void)(SYSDEBUG && _TIMETRACE && strace_enabled(0) > 0 && \
-          (__stracef(STRACE_PROLOGUE FMT "\n", ##__VA_ARGS__), 0)))
-
-int strace_enabled(int);
-void __stracef(const char *, ...);
-
-COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_CALLS_STRACE_INTERNAL_H_ */
diff --git a/libc/intrin/stracef.greg.c b/libc/intrin/stracef.greg.c
index 3bbfe1166..04cc8a80a 100644
--- a/libc/intrin/stracef.greg.c
+++ b/libc/intrin/stracef.greg.c
@@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/intrin/describebacktrace.internal.h"
+#include "libc/intrin/describebacktrace.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 
 dontinstrument void __stracef(const char *fmt, ...) {
diff --git a/libc/intrin/strerror.c b/libc/intrin/strerror.c
index a465c5c7d..89110783e 100644
--- a/libc/intrin/strerror.c
+++ b/libc/intrin/strerror.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #include "libc/str/str.h"
 
 alignas(1) static char strerror_buf[128];
diff --git a/libc/intrin/strsignal_r.c b/libc/intrin/strsignal_r.c
index 325838bf8..24417b36a 100644
--- a/libc/intrin/strsignal_r.c
+++ b/libc/intrin/strsignal_r.c
@@ -36,12 +36,10 @@
 privileged const char *strsignal_r(int sig, char buf[21]) {
   char *p;
   const char *s;
-  if (!sig) {
+  if (!sig)
     return "0";
-  }
-  if ((s = GetMagnumStr(kSignalNames, sig))) {
+  if ((s = GetMagnumStr(kSignalNames, sig)))
     return s;
-  }
   if (SIGRTMIN <= sig && sig <= SIGRTMAX) {
     sig -= SIGRTMIN;
     buf[0] = 'S';
diff --git a/libc/calls/swapcontext.S b/libc/intrin/swapcontext.S
similarity index 94%
rename from libc/calls/swapcontext.S
rename to libc/intrin/swapcontext.S
index 6dd78947f..b40b86777 100644
--- a/libc/calls/swapcontext.S
+++ b/libc/intrin/swapcontext.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Saves machine to 𝑥 and activates 𝑦, i.e.
 //
@@ -31,17 +31,17 @@
 //	@returnstwice
 	.ftrace1
 swapcontext:
+	beg
 	.ftrace2
-#include "libc/calls/getcontext.inc"
+#include "libc/intrin/getcontext.inc"
 #ifdef __x86_64__
-	push	%rbp
-	mov	%rsp,%rbp
-	push	%rsi
-	push	%rsi
+	pro
+	cpush	%rsi
+	cpush	%rsi
 	call	__swapcontextsig
-	pop	%rdi
-	pop	%rdi
-	pop	%rbp
+	cpop	%rdi
+	cpop	%rdi
+	epi
 	test	%eax,%eax
 	jnz	1f
 #elif defined(__aarch64__)
@@ -56,4 +56,5 @@ swapcontext:
 #endif
 	jmp	__tailcontext
 1:	ret
+	end
 	.endfn	swapcontext,globl
diff --git a/libc/intrin/sys_gettid.greg.c b/libc/intrin/sys_gettid.greg.c
index 408025bc0..fbc4dadd0 100644
--- a/libc/intrin/sys_gettid.greg.c
+++ b/libc/intrin/sys_gettid.greg.c
@@ -25,7 +25,10 @@
 
 __msabi extern typeof(GetCurrentThreadId) *const __imp_GetCurrentThreadId;
 
-int sys_gettid(void) {
+// it's important that this be noinstrument because the child process
+// created by fork() needs to update this value quickly, since ftrace
+// will deadlock __maps_lock() if the wrong tid is accidentally used.
+dontinstrument int sys_gettid(void) {
   int64_t wut;
 #ifdef __x86_64__
   int tid;
diff --git a/libc/intrin/sys_sched_yield.S b/libc/intrin/sys_sched_yield.S
new file mode 100644
index 000000000..f78f48712
--- /dev/null
+++ b/libc/intrin/sys_sched_yield.S
@@ -0,0 +1,117 @@
+/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
+│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/dce.h"
+#include "libc/sysv/consts/nr.h"
+#include "libc/macros.h"
+
+//	Relinquishes scheduled quantum.
+//
+//	@return	0 on success, or -1 w/ errno
+sys_sched_yield:
+	beg
+#ifdef __x86_64__
+	pro
+	xor	%eax,%eax
+	mov	__hostos(%rip),%dl
+
+#if SupportsMetal()
+	testb	$_HOSTMETAL,%dl
+	jnz	9f
+#endif
+
+#if SupportsWindows()
+//	Windows Support
+//
+//	A value of zero, together with the bAlertable parameter set to
+//	FALSE, causes the thread to relinquish the remainder of its time
+//	slice to any other thread that is ready to run, if there are no
+//	pending user APCs on the calling thread. If there are no other
+//	threads ready to run and no user APCs are queued, the function
+//	returns immediately, and the thread continues execution.
+//	                                  ──Quoth MSDN
+	testb	$_HOSTWINDOWS,%dl
+	jz	1f
+	xor	%ecx,%ecx
+	xor	%edx,%edx
+	ntcall	__imp_SleepEx
+	xor	%eax,%eax
+	jmp	9f
+1:
+#endif
+
+#if SupportsSystemv()
+//	On XNU we polyfill sched_yield() using sleep() which'll
+//	be polyfilled using select() with a zero timeout, which
+//	means to wait zero microseconds and then returns a zero
+//	and this hopefully will give other threads a chance too
+//	XNU has a special version we use called select_nocancel
+//
+//	"If the readfds, writefds, and errorfds arguments are
+//	 all null pointers and the timeout argument is not a
+//	 null pointer, the pselect() or select() function shall
+//	 block for the time specified, or until interrupted by
+//	 a signal." ──Quoth IEEE 1003.1-2017 §functions/select
+//
+//	On other platforms, sched_yield() takes no arguments.
+	push	$0				// timeout.tv_usec
+	push	$0				// timeout.tv_sec
+	xor	%edi,%edi			// nfds
+	xor	%esi,%esi			// readfds
+	xor	%edx,%edx			// writefds
+	xor	%r10d,%r10d			// exceptfds
+	mov	%rsp,%r8			// timeout
+	mov	__NR_sched_yield,%eax		// ordinal
+	clc					// linux
+	syscall
+//	It should not be possible for this to fail so we don't
+//	bother going through the errno ritual. If this somehow
+//	fails a positive or negative errno might get returned.
+#endif
+
+9:	epi
+	ret
+
+#elif defined(__aarch64__)
+
+	stp	x29,x30,[sp,-32]!
+	mov	x29,sp
+	.cfi_adjust_cfa_offset 32
+	.cfi_rel_offset x29,16
+	.cfi_rel_offset x30,24
+	mov	x3,0
+	mov	x2,0
+	add	x4,sp,16
+	mov	x1,0
+	mov	w0,0
+	stp	xzr,xzr,[sp,16]
+	mov	x8,#0x7c			// sched_yield() for gnu/systemd
+	mov	x16,#0x5d			// select(0,0,0,0,&blah) for xnu
+	svc	0
+	ldp	x29,x30,[sp],32
+	.cfi_adjust_cfa_offset -32
+	.cfi_restore x30
+	.cfi_restore x29
+	ret
+
+#else
+#error "arch unsupported"
+#endif
+	end
+	.endfn	sys_sched_yield,globl
+	.previous
diff --git a/libc/intrin/sys_set_tls.S b/libc/intrin/sys_set_tls.S
index e013014b5..4f8130521 100644
--- a/libc/intrin/sys_set_tls.S
+++ b/libc/intrin/sys_set_tls.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	we can't allow ftrace here since ftrace needs tls
 sys_set_tls:
diff --git a/libc/intrin/sys_umtx_timedwait_uint.c b/libc/intrin/sys_umtx_timedwait_uint.c
index 9bcc7c595..f82c2898c 100644
--- a/libc/intrin/sys_umtx_timedwait_uint.c
+++ b/libc/intrin/sys_umtx_timedwait_uint.c
@@ -23,7 +23,7 @@
 int sys_umtx_timedwait_uint_cp(atomic_int *, int, int, size_t,
                                struct _umtx_time *) asm("sys_futex_cp");
 
-int sys_umtx_timedwait_uint(atomic_int *p, int expect, bool pshare,
+int sys_umtx_timedwait_uint(atomic_int *p, int expect, bool pshare, int clock,
                             const struct timespec *abstime) {
   int op;
   size_t size;
@@ -32,7 +32,7 @@ int sys_umtx_timedwait_uint(atomic_int *p, int expect, bool pshare,
     tm_p = 0;
     size = 0;
   } else {
-    timo._clockid = CLOCK_REALTIME;
+    timo._clockid = clock;
     timo._flags = UMTX_ABSTIME;
     timo._timeout = *abstime;
     tm_p = &timo;
diff --git a/libc/calls/tailcontext.S b/libc/intrin/tailcontext.S
similarity index 98%
rename from libc/calls/tailcontext.S
rename to libc/intrin/tailcontext.S
index a55163dce..8ed1b17c9 100644
--- a/libc/calls/tailcontext.S
+++ b/libc/intrin/tailcontext.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	tailed called by setcontext() implementation
 __tailcontext:
@@ -57,8 +57,7 @@ __tailcontext:
 	mov	80(%rax),%rsp
 	push	88(%rax)
 	mov	24(%rax),%rdi
-
-	xor	%eax,%eax
+	mov	64(%rax),%rax
 	ret
 
 #elif defined(__aarch64__)
diff --git a/libc/intrin/terminateprocess.c b/libc/intrin/terminateprocess.c
index b69e68351..b03966dd6 100644
--- a/libc/intrin/terminateprocess.c
+++ b/libc/intrin/terminateprocess.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/console.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/thunk/msabi.h"
diff --git a/libc/intrin/terminatethisprocess.c b/libc/intrin/terminatethisprocess.c
index cff6d6e79..2f61cdb27 100644
--- a/libc/intrin/terminatethisprocess.c
+++ b/libc/intrin/terminatethisprocess.c
@@ -16,17 +16,38 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
+#include "libc/calls/sig.internal.h"
+#include "libc/limits.h"
+#include "libc/nt/files.h"
+#include "libc/nt/memory.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/thunk/msabi.h"
+#include "libc/runtime/internal.h"
+#ifdef __x86_64__
 
+__msabi extern typeof(DeleteFile) *const __imp_DeleteFileW;
 __msabi extern typeof(TerminateProcess) *const __imp_TerminateProcess;
+__msabi extern typeof(UnmapViewOfFile) *const __imp_UnmapViewOfFile;
 
 /**
  * Terminates the calling process and all of its threads.
  */
 textwindows dontinstrument void TerminateThisProcess(uint32_t dwWaitStatus) {
+
+  // delete sig file
+  char16_t path[128];
+  atomic_ulong *real;
+  atomic_ulong fake = 0;
+  real = __sig.process;
+  __sig.process = &fake;
+  __imp_UnmapViewOfFile(real);
+  __imp_DeleteFileW(__sig_process_path(path, __pid, false));
+
   // "When a process terminates itself, TerminateProcess stops execution
   // of the calling thread and does not return." -Quoth MSDN
   __imp_TerminateProcess(-1, dwWaitStatus);
   __builtin_unreachable();
 }
+
+#endif /* __x86_64__ */
diff --git a/libc/calls/timespec_add.c b/libc/intrin/timespec_add.c
similarity index 100%
rename from libc/calls/timespec_add.c
rename to libc/intrin/timespec_add.c
diff --git a/libc/calls/timespec_cmp.c b/libc/intrin/timespec_cmp.c
similarity index 100%
rename from libc/calls/timespec_cmp.c
rename to libc/intrin/timespec_cmp.c
diff --git a/libc/calls/timespec_frommicros.c b/libc/intrin/timespec_frommicros.c
similarity index 100%
rename from libc/calls/timespec_frommicros.c
rename to libc/intrin/timespec_frommicros.c
diff --git a/libc/calls/timespec_frommillis.c b/libc/intrin/timespec_frommillis.c
similarity index 100%
rename from libc/calls/timespec_frommillis.c
rename to libc/intrin/timespec_frommillis.c
diff --git a/libc/calls/timespec_fromnanos.c b/libc/intrin/timespec_fromnanos.c
similarity index 100%
rename from libc/calls/timespec_fromnanos.c
rename to libc/intrin/timespec_fromnanos.c
diff --git a/libc/calls/timespec_sub.c b/libc/intrin/timespec_sub.c
similarity index 100%
rename from libc/calls/timespec_sub.c
rename to libc/intrin/timespec_sub.c
diff --git a/libc/calls/timespec_subz.c b/libc/intrin/timespec_subz.c
similarity index 100%
rename from libc/calls/timespec_subz.c
rename to libc/intrin/timespec_subz.c
diff --git a/libc/calls/timespec_tomicros.c b/libc/intrin/timespec_tomicros.c
similarity index 100%
rename from libc/calls/timespec_tomicros.c
rename to libc/intrin/timespec_tomicros.c
diff --git a/libc/calls/timespec_tomillis.c b/libc/intrin/timespec_tomillis.c
similarity index 100%
rename from libc/calls/timespec_tomillis.c
rename to libc/intrin/timespec_tomillis.c
diff --git a/libc/calls/timespec_tonanos.c b/libc/intrin/timespec_tonanos.c
similarity index 100%
rename from libc/calls/timespec_tonanos.c
rename to libc/intrin/timespec_tonanos.c
diff --git a/libc/calls/timespec_totimeval.c b/libc/intrin/timespec_totimeval.c
similarity index 100%
rename from libc/calls/timespec_totimeval.c
rename to libc/intrin/timespec_totimeval.c
diff --git a/libc/str/timespectowindowstime.c b/libc/intrin/timespectowindowstime.c
similarity index 86%
rename from libc/str/timespectowindowstime.c
rename to libc/intrin/timespectowindowstime.c
index af7cb9507..03e8c631c 100644
--- a/libc/str/timespectowindowstime.c
+++ b/libc/intrin/timespectowindowstime.c
@@ -17,7 +17,14 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/wintime.internal.h"
+#include "libc/limits.h"
+#include "libc/stdckdint.h"
 
-int64_t TimeSpecToWindowsTime(struct timespec t) {
-  return t.tv_nsec / 100 + (t.tv_sec + MODERNITYSECONDS) * HECTONANOSECONDS;
+int64_t TimeSpecToWindowsTime(struct timespec time) {
+  int64_t wt;
+  if (ckd_add(&wt, time.tv_sec, MODERNITYSECONDS) ||
+      ckd_mul(&wt, wt, HECTONANOSECONDS) ||
+      ckd_add(&wt, wt, time.tv_nsec / 100))
+    wt = INT64_MAX;
+  return wt;
 }
diff --git a/libc/calls/timeval_add.c b/libc/intrin/timeval_add.c
similarity index 100%
rename from libc/calls/timeval_add.c
rename to libc/intrin/timeval_add.c
diff --git a/libc/calls/timeval_cmp.c b/libc/intrin/timeval_cmp.c
similarity index 100%
rename from libc/calls/timeval_cmp.c
rename to libc/intrin/timeval_cmp.c
diff --git a/libc/calls/timeval_frommicros.c b/libc/intrin/timeval_frommicros.c
similarity index 100%
rename from libc/calls/timeval_frommicros.c
rename to libc/intrin/timeval_frommicros.c
diff --git a/libc/calls/timeval_frommillis.c b/libc/intrin/timeval_frommillis.c
similarity index 100%
rename from libc/calls/timeval_frommillis.c
rename to libc/intrin/timeval_frommillis.c
diff --git a/libc/calls/timeval_sub.c b/libc/intrin/timeval_sub.c
similarity index 100%
rename from libc/calls/timeval_sub.c
rename to libc/intrin/timeval_sub.c
diff --git a/libc/calls/timeval_subz.c b/libc/intrin/timeval_subz.c
similarity index 100%
rename from libc/calls/timeval_subz.c
rename to libc/intrin/timeval_subz.c
diff --git a/libc/calls/timeval_tomicros.c b/libc/intrin/timeval_tomicros.c
similarity index 100%
rename from libc/calls/timeval_tomicros.c
rename to libc/intrin/timeval_tomicros.c
diff --git a/libc/calls/timeval_tomillis.c b/libc/intrin/timeval_tomillis.c
similarity index 100%
rename from libc/calls/timeval_tomillis.c
rename to libc/intrin/timeval_tomillis.c
diff --git a/libc/calls/timeval_toseconds.c b/libc/intrin/timeval_toseconds.c
similarity index 100%
rename from libc/calls/timeval_toseconds.c
rename to libc/intrin/timeval_toseconds.c
diff --git a/libc/str/timevaltowindowstime.c b/libc/intrin/timevaltowindowstime.c
similarity index 100%
rename from libc/str/timevaltowindowstime.c
rename to libc/intrin/timevaltowindowstime.c
diff --git a/libc/intrin/tls.c b/libc/intrin/tls.c
new file mode 100644
index 000000000..3a6d82db2
--- /dev/null
+++ b/libc/intrin/tls.c
@@ -0,0 +1,54 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/tls.h"
+#include "libc/dce.h"
+
+/**
+ * Returns location of thread information block.
+ *
+ * This should be favored over __get_tls() for .privileged code that
+ * can't be self-modified by __enable_tls().
+ */
+privileged optimizespeed struct CosmoTib *__get_tls_privileged(void) {
+#if defined(__x86_64__)
+  char *tib, *lin = (char *)0x30;
+  if (IsNetbsd() || IsOpenbsd()) {
+    asm("mov\t%%fs:(%1),%0" : "=a"(tib) : "r"(lin) : "memory");
+  } else {
+    asm("mov\t%%gs:(%1),%0" : "=a"(tib) : "r"(lin) : "memory");
+    if (IsWindows())
+      tib = *(char **)(tib + 0x1480 + __tls_index * 8);
+  }
+  return (struct CosmoTib *)tib;
+#elif defined(__aarch64__)
+  return __get_tls();
+#endif
+}
+
+#if defined(__x86_64__)
+privileged optimizespeed struct CosmoTib *__get_tls_win32(void) {
+  char *tib, *lin = (char *)0x30;
+  asm("mov\t%%gs:(%1),%0" : "=a"(tib) : "r"(lin) : "memory");
+  tib = *(char **)(tib + 0x1480 + __tls_index * 8);
+  return (struct CosmoTib *)tib;
+}
+privileged void __set_tls_win32(void *tls) {
+  asm("mov\t%1,%%gs:%0" : "=m"(*((long *)0x1480 + __tls_index)) : "r"(tls));
+}
+#endif
diff --git a/libc/intrin/tree.c b/libc/intrin/tree.c
new file mode 100644
index 000000000..2c3e3fecc
--- /dev/null
+++ b/libc/intrin/tree.c
@@ -0,0 +1,275 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "tree.h"
+
+struct Tree *tree_last(struct Tree *node) {
+  while (node && node->right)
+    node = node->right;
+  return node;
+}
+
+struct Tree *tree_first(struct Tree *node) {
+  while (node && tree_get_left(node))
+    node = tree_get_left(node);
+  return node;
+}
+
+struct Tree *tree_next(struct Tree *node) {
+  if (!node)
+    return 0;
+  if (node->right)
+    return tree_first(node->right);
+  struct Tree *parent = node->parent;
+  while (parent && node == parent->right) {
+    node = parent;
+    parent = parent->parent;
+  }
+  return parent;
+}
+
+struct Tree *tree_prev(struct Tree *node) {
+  struct Tree *parent;
+  if (!node)
+    return 0;
+  if (tree_get_left(node))
+    return tree_last(tree_get_left(node));
+  parent = node->parent;
+  while (parent && node == tree_get_left(parent)) {
+    node = parent;
+    parent = parent->parent;
+  }
+  return parent;
+}
+
+dontinstrument static void tree_rotate_left(struct Tree **root,
+                                            struct Tree *x) {
+  struct Tree *y = x->right;
+  x->right = tree_get_left(y);
+  if (tree_get_left(y))
+    tree_get_left(y)->parent = x;
+  y->parent = x->parent;
+  if (!x->parent) {
+    *root = y;
+  } else if (x == tree_get_left(x->parent)) {
+    tree_set_left(x->parent, y);
+  } else {
+    x->parent->right = y;
+  }
+  tree_set_left(y, x);
+  x->parent = y;
+}
+
+dontinstrument static void tree_rotate_right(struct Tree **root,
+                                             struct Tree *y) {
+  struct Tree *x = tree_get_left(y);
+  tree_set_left(y, x->right);
+  if (x->right)
+    x->right->parent = y;
+  x->parent = y->parent;
+  if (!y->parent) {
+    *root = x;
+  } else if (y == y->parent->right) {
+    y->parent->right = x;
+  } else {
+    tree_set_left(y->parent, x);
+  }
+  y->parent = x;
+  x->right = y;
+}
+
+dontinstrument static void tree_rebalance_insert(struct Tree **root,
+                                                 struct Tree *node) {
+  struct Tree *uncle;
+  tree_set_red(node, 1);
+  while (node != *root && tree_get_red(node->parent)) {
+    if (node->parent == tree_get_left(node->parent->parent)) {
+      uncle = node->parent->parent->right;
+      if (uncle && tree_get_red(uncle)) {
+        tree_set_red(node->parent, 0);
+        tree_set_red(uncle, 0);
+        tree_set_red(node->parent->parent, 1);
+        node = node->parent->parent;
+      } else {
+        if (node == node->parent->right) {
+          node = node->parent;
+          tree_rotate_left(root, node);
+        }
+        tree_set_red(node->parent, 0);
+        tree_set_red(node->parent->parent, 1);
+        tree_rotate_right(root, node->parent->parent);
+      }
+    } else {
+      uncle = tree_get_left(node->parent->parent);
+      if (uncle && tree_get_red(uncle)) {
+        tree_set_red(node->parent, 0);
+        tree_set_red(uncle, 0);
+        tree_set_red(node->parent->parent, 1);
+        node = node->parent->parent;
+      } else {
+        if (node == tree_get_left(node->parent)) {
+          node = node->parent;
+          tree_rotate_right(root, node);
+        }
+        tree_set_red(node->parent, 0);
+        tree_set_red(node->parent->parent, 1);
+        tree_rotate_left(root, node->parent->parent);
+      }
+    }
+  }
+  tree_set_red(*root, 0);
+}
+
+void tree_insert(struct Tree **root, struct Tree *node, tree_cmp_f *cmp) {
+  struct Tree *search, *parent;
+  node->word = 0;
+  node->right = 0;
+  node->parent = 0;
+  if (!*root) {
+    *root = node;
+  } else {
+    search = *root;
+    parent = 0;
+    do {
+      parent = search;
+      if (cmp(node, search) < 0) {
+        search = tree_get_left(search);
+      } else {
+        search = search->right;
+      }
+    } while (search);
+    if (cmp(node, parent) < 0) {
+      tree_set_left(parent, node);
+    } else {
+      parent->right = node;
+    }
+    node->parent = parent;
+    tree_rebalance_insert(root, node);
+  }
+}
+
+dontinstrument static void tree_transplant(struct Tree **root, struct Tree *u,
+                                           struct Tree *v) {
+  if (!u->parent) {
+    *root = v;
+  } else if (u == tree_get_left(u->parent)) {
+    tree_set_left(u->parent, v);
+  } else {
+    u->parent->right = v;
+  }
+  if (v)
+    v->parent = u->parent;
+}
+
+dontinstrument static void tree_rebalance_remove(struct Tree **root,
+                                                 struct Tree *node,
+                                                 struct Tree *parent) {
+  struct Tree *sibling;
+  while (node != *root && (!node || !tree_get_red(node))) {
+    if (node == tree_get_left(parent)) {
+      sibling = parent->right;
+      if (tree_get_red(sibling)) {
+        tree_set_red(sibling, 0);
+        tree_set_red(parent, 1);
+        tree_rotate_left(root, parent);
+        sibling = parent->right;
+      }
+      if ((!tree_get_left(sibling) || !tree_get_red(tree_get_left(sibling))) &&
+          (!sibling->right || !tree_get_red(sibling->right))) {
+        tree_set_red(sibling, 1);
+        node = parent;
+        parent = node->parent;
+      } else {
+        if (!sibling->right || !tree_get_red(sibling->right)) {
+          tree_set_red(tree_get_left(sibling), 0);
+          tree_set_red(sibling, 1);
+          tree_rotate_right(root, sibling);
+          sibling = parent->right;
+        }
+        tree_set_red(sibling, tree_get_red(parent));
+        tree_set_red(parent, 0);
+        tree_set_red(sibling->right, 0);
+        tree_rotate_left(root, parent);
+        node = *root;
+        break;
+      }
+    } else {
+      sibling = tree_get_left(parent);
+      if (tree_get_red(sibling)) {
+        tree_set_red(sibling, 0);
+        tree_set_red(parent, 1);
+        tree_rotate_right(root, parent);
+        sibling = tree_get_left(parent);
+      }
+      if ((!sibling->right || !tree_get_red(sibling->right)) &&
+          (!tree_get_left(sibling) || !tree_get_red(tree_get_left(sibling)))) {
+        tree_set_red(sibling, 1);
+        node = parent;
+        parent = node->parent;
+      } else {
+        if (!tree_get_left(sibling) || !tree_get_red(tree_get_left(sibling))) {
+          tree_set_red(sibling->right, 0);
+          tree_set_red(sibling, 1);
+          tree_rotate_left(root, sibling);
+          sibling = tree_get_left(parent);
+        }
+        tree_set_red(sibling, tree_get_red(parent));
+        tree_set_red(parent, 0);
+        tree_set_red(tree_get_left(sibling), 0);
+        tree_rotate_right(root, parent);
+        node = *root;
+        break;
+      }
+    }
+  }
+  if (node)
+    tree_set_red(node, 0);
+}
+
+void tree_remove(struct Tree **root, struct Tree *node) {
+  struct Tree *x = 0;
+  struct Tree *y = node;
+  struct Tree *x_parent = 0;
+  int y_original_color = tree_get_red(y);
+  if (!tree_get_left(node)) {
+    x = node->right;
+    tree_transplant(root, node, node->right);
+    x_parent = node->parent;
+  } else if (!node->right) {
+    x = tree_get_left(node);
+    tree_transplant(root, node, tree_get_left(node));
+    x_parent = node->parent;
+  } else {
+    y = tree_first(node->right);
+    y_original_color = tree_get_red(y);
+    x = y->right;
+    if (y->parent == node) {
+      if (x)
+        x->parent = y;
+      x_parent = y;
+    } else {
+      tree_transplant(root, y, y->right);
+      y->right = node->right;
+      y->right->parent = y;
+      x_parent = y->parent;
+    }
+    tree_transplant(root, node, y);
+    tree_set_left(y, tree_get_left(node));
+    tree_get_left(y)->parent = y;
+    tree_set_red(y, tree_get_red(node));
+  }
+  if (!y_original_color)
+    tree_rebalance_remove(root, x, x_parent);
+}
diff --git a/libc/intrin/tree.h b/libc/intrin/tree.h
new file mode 100644
index 000000000..601eaa927
--- /dev/null
+++ b/libc/intrin/tree.h
@@ -0,0 +1,134 @@
+#ifndef COSMOPOLITAN_TREE_H_
+#define COSMOPOLITAN_TREE_H_
+#define tree_first  __tree_first
+#define tree_insert __tree_insert
+#define tree_last   __tree_last
+#define tree_next   __tree_next
+#define tree_prev   __tree_prev
+#define tree_remove __tree_remove
+COSMOPOLITAN_C_START_
+
+#define TREE_CONTAINER(t, f, p) ((t *)(((char *)(p)) - offsetof(t, f)))
+
+struct Tree {
+  uintptr_t word;
+  struct Tree *right;
+  struct Tree *parent;
+};
+
+typedef int tree_search_f(const void *, const struct Tree *);
+typedef int tree_cmp_f(const struct Tree *, const struct Tree *);
+
+forceinline struct Tree *tree_get_left(const struct Tree *node) {
+  return (struct Tree *)(node->word & -2);
+}
+
+static inline void tree_set_left(struct Tree *node, struct Tree *left) {
+  node->word = (uintptr_t)left | (node->word & 1);
+}
+
+static inline int tree_get_red(const struct Tree *node) {
+  return node->word & 1;
+}
+
+static inline void tree_set_red(struct Tree *node, int red) {
+  node->word &= -2;
+  node->word |= red;
+}
+
+// Returns node equal to given key.
+//
+//    [1 3 5 7]   [1 3 5 7]   [1 3 5 7]
+//       NULL        ↑               NULL
+//        4          3                8
+//
+static inline struct Tree *tree_get(const struct Tree *node, const void *key,
+                                    tree_search_f *cmp) {
+  while (node) {
+    int c = cmp(key, node);
+    if (c < 0) {
+      node = tree_get_left(node);
+    } else if (c > 0) {
+      node = node->right;
+    } else {
+      return (struct Tree *)node;
+    }
+  }
+  return 0;
+}
+
+// Returns last node less than or equal to given key.
+//
+//    [1 3 5 7]   [1 3 5 7]   [1 3 5 7]
+//       ↑           ↑               ↑
+//       4           3               8
+//
+forceinline optimizespeed struct Tree *tree_floor(const struct Tree *node,
+                                                  const void *key,
+                                                  tree_search_f *cmp) {
+  struct Tree *left = 0;
+  while (node) {
+    int c = cmp(key, node);
+    if (c < 0) {
+      node = tree_get_left(node);
+    } else if (c > 0) {
+      left = (struct Tree *)node;
+      node = node->right;
+    } else {
+      return (struct Tree *)node;
+    }
+  }
+  return left;
+}
+
+// Returns first node not less than given key.
+//
+//    [1 3 5 7]   [1 3 5 7]   [1 3 5 7]
+//         ↑         ↑               NULL
+//         4         3                8
+//
+static inline struct Tree *tree_lower(const struct Tree *node, const void *key,
+                                      tree_search_f *cmp) {
+  struct Tree *left = 0;
+  while (node) {
+    int c = cmp(key, node);
+    if (c <= 0) {
+      left = (struct Tree *)node;
+      node = tree_get_left(node);
+    } else {
+      node = node->right;
+    }
+  }
+  return left;
+}
+
+// Returns first node greater than than given key.
+//
+//    [1 3 5 7]   [1 3 5 7]   [1 3 5 7]
+//         ↑           ↑             NULL
+//         4           3              8
+//
+static inline struct Tree *tree_ceil(const struct Tree *node, const void *key,
+                                     tree_search_f *cmp) {
+  struct Tree *left = 0;
+  while (node) {
+    int c = cmp(key, node);
+    if (c < 0) {
+      left = (struct Tree *)node;
+      node = tree_get_left(node);
+    } else {
+      node = node->right;
+    }
+  }
+  return left;
+}
+
+struct Tree *tree_next(struct Tree *) libcesque;
+struct Tree *tree_prev(struct Tree *) libcesque;
+struct Tree *tree_first(struct Tree *) libcesque;
+struct Tree *tree_last(struct Tree *) libcesque;
+void tree_remove(struct Tree **, struct Tree *) libcesque;
+void tree_insert(struct Tree **, struct Tree *, tree_cmp_f *) libcesque;
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_TREE_H_ */
diff --git a/third_party/compiler_rt/trunctfsf2.c b/libc/intrin/trunctfsf2.c
similarity index 89%
rename from third_party/compiler_rt/trunctfsf2.c
rename to libc/intrin/trunctfsf2.c
index 3ebda8151..bbb961dfe 100644
--- a/third_party/compiler_rt/trunctfsf2.c
+++ b/libc/intrin/trunctfsf2.c
@@ -7,8 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-__static_yoink("huge_compiler_rt_license");
-
 #define QUAD_PRECISION
 #include "third_party/compiler_rt/fp_lib.inc"
 
@@ -18,7 +16,7 @@ __static_yoink("huge_compiler_rt_license");
 #include "third_party/compiler_rt/fp_trunc_impl.inc"
 
 COMPILER_RT_ABI float __trunctfsf2(long double a) {
-    return __truncXfYf2__(a);
+  return __truncXfYf2__(a);
 }
 
 #endif
diff --git a/libc/intrin/typeinfo.S b/libc/intrin/typeinfo.S
deleted file mode 100644
index e195c73c3..000000000
--- a/libc/intrin/typeinfo.S
+++ /dev/null
@@ -1,26 +0,0 @@
-/*-*- mode:unix-assembly; indent-tabs-mode:t; tab-width:8; coding:utf-8     -*-│
-│ vi: set noet ft=asm ts=8 sw=8 fenc=utf-8                                 :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
-
-//	__cxxabiv1::__function_type_info (?)
-//	Because Clang in MODE=dbg doesn't respect -fno-rtti
-	.balign	8
-_ZTVN10__cxxabiv120__function_type_infoE:
-	.quad	0
-	.endobj	_ZTVN10__cxxabiv120__function_type_infoE,globl
diff --git a/libc/intrin/ubsan.c b/libc/intrin/ubsan.c
index 98c22d85d..bef84f828 100644
--- a/libc/intrin/ubsan.c
+++ b/libc/intrin/ubsan.c
@@ -18,9 +18,10 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/ubsan.h"
 #include "libc/calls/calls.h"
+#include "libc/intrin/describebacktrace.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/pushpop.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/pushpop.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
 #include "libc/log/color.internal.h"
@@ -31,6 +32,7 @@
 #include "libc/nt/runtime.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
+#include "libc/runtime/symbols.internal.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/fileno.h"
@@ -240,16 +242,20 @@ __wur static __ubsan_die_f *__ubsan_die(void) {
 
 static void __ubsan_warning(const struct UbsanSourceLocation *loc,
                             const char *description) {
-  kprintf("%s:%d: %subsan warning: %s is undefined behavior%s\n", loc->file,
-          loc->line, SUBTLE, description, RESET);
+  kprintf("%s:%d: %subsan warning: %s is undefined behavior%s\n"
+          "cosmoaddr2line %s %s\n",
+          loc->file, loc->line, SUBTLE, description, RESET, __argv[0],
+          DescribeBacktrace(__builtin_frame_address(0)));
   if (__ubsan_strict)
     __ubsan_die()();
 }
 
 __wur __ubsan_die_f *__ubsan_abort(const struct UbsanSourceLocation *loc,
                                    const char *description) {
-  kprintf("\n%s:%d: %subsan error%s: %s (tid %d)\n", loc->file, loc->line, RED2,
-          RESET, description, gettid());
+  kprintf("\n%s:%d: %subsan error%s: %s (tid %d)\n"
+          "cosmoaddr2line %s %s\n",
+          loc->file, loc->line, RED2, RESET, description, gettid(), __argv[0],
+          DescribeBacktrace(__builtin_frame_address(0)));
   return __ubsan_die();
 }
 
diff --git a/libc/calls/ucontext.c b/libc/intrin/ucontext.c
similarity index 94%
rename from libc/calls/ucontext.c
rename to libc/intrin/ucontext.c
index a6227663b..f7472c127 100644
--- a/libc/calls/ucontext.c
+++ b/libc/intrin/ucontext.c
@@ -23,7 +23,7 @@
 #include "libc/sysv/consts/sig.h"
 #include "libc/thread/tls.h"
 
-int __tailcontext(const ucontext_t *);
+int __tailcontext(const ucontext_t *) wontreturn;
 
 /**
  * Sets machine context.
@@ -34,17 +34,17 @@ int __tailcontext(const ucontext_t *);
  * @see getcontext()
  */
 int setcontext(const ucontext_t *uc) {
-  if (IsWindows()) {
+  if (IsWindows() || IsMetal()) {
     atomic_store_explicit(&__get_tls()->tib_sigmask, uc->uc_sigmask,
                           memory_order_release);
   } else {
     sys_sigprocmask(SIG_SETMASK, &uc->uc_sigmask, 0);
   }
-  return __tailcontext(uc);
+  __tailcontext(uc);
 }
 
 int __getcontextsig(ucontext_t *uc) {
-  if (IsWindows()) {
+  if (IsWindows() || IsMetal()) {
     uc->uc_sigmask =
         atomic_load_explicit(&__get_tls()->tib_sigmask, memory_order_acquire);
     return 0;
@@ -54,7 +54,7 @@ int __getcontextsig(ucontext_t *uc) {
 }
 
 int __swapcontextsig(ucontext_t *x, const ucontext_t *y) {
-  if (IsWindows()) {
+  if (IsWindows() || IsMetal()) {
     x->uc_sigmask = atomic_exchange_explicit(
         &__get_tls()->tib_sigmask, y->uc_sigmask, memory_order_acquire);
     return 0;
diff --git a/libc/intrin/ulock.c b/libc/intrin/ulock.c
index 190d18133..f4da16d18 100644
--- a/libc/intrin/ulock.c
+++ b/libc/intrin/ulock.c
@@ -17,12 +17,12 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/ulock.h"
-#include "libc/assert.h"
-#include "libc/calls/calls.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
-#include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/errno.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/strace.h"
+#include "libc/intrin/ulock.h"
 
 // XNU futexes
 // https://opensource.apple.com/source/xnu/xnu-7195.50.7.100.1/bsd/sys/ulock.h.auto.html
@@ -32,6 +32,26 @@ int sys_ulock_wait(uint32_t operation, void *addr, uint64_t value,
                    uint32_t timeout_micros) asm("sys_futex_cp");
 
 // returns number of other waiters, or -1 w/ errno
+//
+// - EINTR means a signal handler was called. This is how we support
+//   things like POSIX thread cancelation.
+//
+// - EFAULT if XNU couldn't read `addr`. This is normally considered a
+//   programming error, but with ulock it can actually be a transient
+//   error due to low memory conditions. Apple recommends retrying.
+//
+// - ENOMEM means XNU wasn't able to allocate memory for kernel internal
+//   data structures. Apple doesn't provide any advice on what to do. We
+//   simply turn this into EAGAIN.
+//
+// - EAGAIN if XNU told us EFAULT but cosmo believes the address exists.
+//   This value is also used as a substitute for ENOMEM.
+//
+// - EINVAL could mean operation is invalid, addr is null or misaligned;
+//   it could also mean another thread calling ulock on this address was
+//   configured (via operation) in an inconsistent way.
+//
+// see also os_sync_wait_on_address.h from xcode sdk
 int ulock_wait(uint32_t operation, void *addr, uint64_t value,
                uint32_t timeout_micros) {
   int rc;
@@ -39,13 +59,31 @@ int ulock_wait(uint32_t operation, void *addr, uint64_t value,
   LOCKTRACE("ulock_wait(%#x, %p, %lx, %u) → ...", operation, addr, value,
             timeout_micros);
   rc = sys_ulock_wait(operation, addr, value, timeout_micros);
+  if (rc == -1) {
+    if (errno == ENOMEM)
+      errno = EAGAIN;
+    if (errno == EFAULT)
+      if (!kisdangerous(addr))
+        errno = EAGAIN;
+  }
   LOCKTRACE("ulock_wait(%#x, %p, %lx, %u) → %d% m", operation, addr, value,
             timeout_micros, rc);
   return rc;
 }
 
 // returns -errno
-int ulock_wake(uint32_t operation, void *addr, uint64_t wake_value) {
+//
+// - ENOENT means there wasn't anyone to wake
+//
+// - EINVAL could mean operation is invalid, addr is null or misaligned;
+//   it could also mean another thread calling ulock on this address was
+//   configured (via operation) in an inconsistent way.
+//
+// should be dontinstrument because SiliconThreadMain() calls this from
+// a stack managed by apple libc.
+//
+dontinstrument int ulock_wake(uint32_t operation, void *addr,
+                              uint64_t wake_value) {
   int rc;
   rc = __syscall3i(operation, (long)addr, wake_value, 0x2000000 | 516);
   LOCKTRACE("ulock_wake(%#x, %p, %lx) → %s", operation, addr, wake_value,
diff --git a/libc/intrin/umask.c b/libc/intrin/umask.c
index c3af0d52c..2bec074a8 100644
--- a/libc/intrin/umask.c
+++ b/libc/intrin/umask.c
@@ -19,4 +19,4 @@
 #include "libc/atomic.h"
 #include "libc/calls/internal.h"
 
-atomic_int __umask;
+atomic_int __umask = 0777;
diff --git a/libc/intrin/unlockfileex.c b/libc/intrin/unlockfileex.c
index 46cc29248..295b7ae77 100644
--- a/libc/intrin/unlockfileex.c
+++ b/libc/intrin/unlockfileex.c
@@ -18,9 +18,9 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/describentoverlapped.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/describentoverlapped.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/files.h"
 #include "libc/str/str.h"
 
diff --git a/libc/intrin/unmapviewoffile.c b/libc/intrin/unmapviewoffile.c
index 853893895..7c5972082 100644
--- a/libc/intrin/unmapviewoffile.c
+++ b/libc/intrin/unmapviewoffile.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/memory.h"
 
 __msabi extern typeof(UnmapViewOfFile) *const __imp_UnmapViewOfFile;
diff --git a/libc/intrin/unsetenv.c b/libc/intrin/unsetenv.c
index d96e1e4f4..e882448ff 100644
--- a/libc/intrin/unsetenv.c
+++ b/libc/intrin/unsetenv.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/intrin/getenv.internal.h"
+#include "libc/intrin/getenv.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
diff --git a/libc/intrin/vdsofunc.c b/libc/intrin/vdsofunc.c
new file mode 100644
index 000000000..a063c41a1
--- /dev/null
+++ b/libc/intrin/vdsofunc.c
@@ -0,0 +1,153 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/dce.h"
+#include "libc/elf/def.h"
+#include "libc/elf/scalar.h"
+#include "libc/elf/struct/ehdr.h"
+#include "libc/elf/struct/phdr.h"
+#include "libc/elf/struct/shdr.h"
+#include "libc/elf/struct/sym.h"
+#include "libc/elf/struct/verdaux.h"
+#include "libc/elf/struct/verdef.h"
+#include "libc/intrin/getauxval.h"
+#include "libc/intrin/strace.h"
+#include "libc/runtime/runtime.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/auxv.h"
+
+// needed to avoid asan restrictions on strcmp
+static int StrCmp(const char *l, const char *r) {
+  size_t i = 0;
+  while (l[i] == r[i] && r[i])
+    ++i;
+  return (l[i] & 255) - (r[i] & 255);
+}
+
+static inline int CheckDsoSymbolVersion(Elf64_Verdef *vd, int sym,
+                                        const char *name, char *strtab) {
+  Elf64_Verdaux *aux;
+  for (;; vd = (Elf64_Verdef *)((char *)vd + vd->vd_next)) {
+    if (!(vd->vd_flags & VER_FLG_BASE) &&
+        (vd->vd_ndx & 0x7fff) == (sym & 0x7fff)) {
+      aux = (Elf64_Verdaux *)((char *)vd + vd->vd_aux);
+      return !StrCmp(name, strtab + aux->vda_name);
+    }
+    if (!vd->vd_next) {
+      return 0;
+    }
+  }
+}
+
+/**
+ * Returns address of "Virtual Dynamic Shared Object" function on Linux.
+ */
+void *__vdsosym(const char *version, const char *name) {
+  void *p;
+  size_t i;
+  Elf64_Ehdr *ehdr;
+  Elf64_Phdr *phdr;
+  char *strtab = 0;
+  size_t *dyn, base;
+  Elf64_Sym *symtab = 0;
+  uint16_t *versym = 0;
+  Elf_Symndx *hashtab = 0;
+  Elf64_Verdef *verdef = 0;
+  struct AuxiliaryValue av;
+
+  av = __getauxval(AT_SYSINFO_EHDR);
+  if (!av.isfound) {
+    KERNTRACE("__vdsosym() → missing AT_SYSINFO_EHDR");
+    return 0;
+  }
+
+  ehdr = (void *)av.value;
+  phdr = (void *)((char *)ehdr + ehdr->e_phoff);
+  for (base = -1, dyn = 0, i = 0; i < ehdr->e_phnum;
+       i++, phdr = (void *)((char *)phdr + ehdr->e_phentsize)) {
+    switch (phdr->p_type) {
+      case PT_LOAD:
+        // modern linux uses the base address zero, but elders
+        // e.g. rhel7 uses the base address 0xffffffffff700000
+        base = (size_t)ehdr + phdr->p_offset - phdr->p_vaddr;
+        break;
+      case PT_DYNAMIC:
+        dyn = (void *)((char *)ehdr + phdr->p_offset);
+        break;
+      default:
+        break;
+    }
+  }
+  if (!dyn || base == -1) {
+    KERNTRACE("__vdsosym() → missing program headers");
+    return 0;
+  }
+
+  for (i = 0; dyn[i]; i += 2) {
+    p = (void *)(base + dyn[i + 1]);
+    switch (dyn[i]) {
+      case DT_STRTAB:
+        strtab = p;
+        break;
+      case DT_SYMTAB:
+        symtab = p;
+        break;
+      case DT_HASH:
+        hashtab = p;
+        break;
+      case DT_VERSYM:
+        versym = p;
+        break;
+      case DT_VERDEF:
+        verdef = p;
+        break;
+    }
+  }
+  if (!strtab || !symtab || !hashtab) {
+    KERNTRACE("__vdsosym() → tables not found");
+    return 0;
+  }
+  if (!verdef) {
+    versym = 0;
+  }
+
+  for (i = 0; i < hashtab[1]; i++) {
+    if (ELF64_ST_TYPE(symtab[i].st_info) != STT_FUNC &&
+        ELF64_ST_TYPE(symtab[i].st_info) != STT_OBJECT &&
+        ELF64_ST_TYPE(symtab[i].st_info) != STT_NOTYPE) {
+      continue;
+    }
+    if (ELF64_ST_BIND(symtab[i].st_info) != STB_GLOBAL) {
+      continue;
+    }
+    if (!symtab[i].st_shndx) {
+      continue;
+    }
+    if (StrCmp(name, strtab + symtab[i].st_name)) {
+      continue;
+    }
+    if (versym && !CheckDsoSymbolVersion(verdef, versym[i], version, strtab)) {
+      continue;
+    }
+    return (void *)(base + symtab[i].st_value);
+  }
+
+  KERNTRACE("__vdsosym() → symbol not found");
+  return 0;
+}
diff --git a/libc/intrin/virtualalloc.c b/libc/intrin/virtualalloc.c
new file mode 100644
index 000000000..6993d8154
--- /dev/null
+++ b/libc/intrin/virtualalloc.c
@@ -0,0 +1,29 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/nt/memory.h"
+#include "libc/nt/runtime.h"
+
+/**
+ * Allocates memory on The New Technology.
+ */
+textwindows void *VirtualAlloc(void *lpAddress, uint64_t dwSize,
+                               uint32_t flAllocationType, uint32_t flProtect) {
+  return VirtualAllocEx(GetCurrentProcess(), lpAddress, dwSize,
+                        flAllocationType, flProtect);
+}
diff --git a/libc/intrin/virtualallocex.c b/libc/intrin/virtualallocex.c
new file mode 100644
index 000000000..77e938819
--- /dev/null
+++ b/libc/intrin/virtualallocex.c
@@ -0,0 +1,41 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/nt/memory.h"
+#include "libc/nt/thunk/msabi.h"
+
+__msabi extern typeof(VirtualAllocEx) *const __imp_VirtualAllocEx;
+
+/**
+ * Allocates memory on The New Technology.
+ */
+textwindows void *VirtualAllocEx(int64_t hProcess, void *lpAddress,
+                                 uint64_t dwSize, uint32_t flAllocationType,
+                                 uint32_t flProtect) {
+  void *res = __imp_VirtualAllocEx(hProcess, lpAddress, dwSize,
+                                   flAllocationType, flProtect);
+  if (!res)
+    __winerr();
+  NTTRACE("VirtualAllocEx(%ld, %p, %'lu, %s, %s) → %p% m", hProcess, lpAddress,
+          dwSize, DescribeNtAllocationType(flAllocationType),
+          DescribeNtPageFlags(flProtect), res);
+  return res;
+}
diff --git a/libc/intrin/virtualmax.c b/libc/intrin/virtualmax.c
index 4f24070e2..e6b5b1888 100644
--- a/libc/intrin/virtualmax.c
+++ b/libc/intrin/virtualmax.c
@@ -19,4 +19,3 @@
 #include "libc/runtime/runtime.h"
 
 size_t __virtualmax = -1;
-size_t __virtualsize = 0;
diff --git a/libc/intrin/virtualprotect.c b/libc/intrin/virtualprotect.c
index 55c97470c..5f653afff 100644
--- a/libc/intrin/virtualprotect.c
+++ b/libc/intrin/virtualprotect.c
@@ -16,13 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/log/libfatal.internal.h"
 #include "libc/nt/memory.h"
-
-__msabi extern typeof(VirtualProtect) *const __imp_VirtualProtect;
+#include "libc/nt/runtime.h"
 
 /**
  * Protects memory on the New Technology.
@@ -31,12 +26,6 @@ __msabi extern typeof(VirtualProtect) *const __imp_VirtualProtect;
 textwindows bool32 VirtualProtect(void *lpAddress, uint64_t dwSize,
                                   uint32_t flNewProtect,
                                   uint32_t *lpflOldProtect) {
-  bool32 bOk;
-  bOk = __imp_VirtualProtect(lpAddress, dwSize, flNewProtect, lpflOldProtect);
-  if (!bOk)
-    __winerr();
-  NTTRACE("VirtualProtect(%p, %'zu, %s, [%s]) → %hhhd% m", lpAddress, dwSize,
-          DescribeNtPageFlags(flNewProtect),
-          DescribeNtPageFlags(*lpflOldProtect), bOk);
-  return bOk;
+  return VirtualProtectEx(GetCurrentProcess(), lpAddress, dwSize, flNewProtect,
+                          lpflOldProtect);
 }
diff --git a/libc/intrin/virtualprotectex.c b/libc/intrin/virtualprotectex.c
new file mode 100644
index 000000000..44615c730
--- /dev/null
+++ b/libc/intrin/virtualprotectex.c
@@ -0,0 +1,43 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/log/libfatal.internal.h"
+#include "libc/nt/memory.h"
+
+__msabi extern typeof(VirtualProtectEx) *const __imp_VirtualProtectEx;
+
+/**
+ * Protects memory on the New Technology.
+ * @note this wrapper takes care of ABI, STRACE(), and __winerr()
+ */
+textwindows bool32 VirtualProtectEx(int64_t hProcess, void *lpAddress,
+                                    uint64_t dwSize, uint32_t flNewProtect,
+                                    uint32_t *lpflOldProtect) {
+  bool32 bOk;
+  bOk = __imp_VirtualProtectEx(hProcess, lpAddress, dwSize, flNewProtect,
+                               lpflOldProtect);
+  if (!bOk)
+    __winerr();
+  NTTRACE("VirtualProtectEx(%ld, %p, %'zu, %s, [%s]) → %hhhd% m", hProcess,
+          lpAddress, dwSize, DescribeNtPageFlags(flNewProtect),
+          DescribeNtPageFlags(*lpflOldProtect), bOk);
+  return bOk;
+}
diff --git a/libc/intrin/waitformultipleobjects.c b/libc/intrin/waitformultipleobjects.c
index 3ea1abba3..661f8946b 100644
--- a/libc/intrin/waitformultipleobjects.c
+++ b/libc/intrin/waitformultipleobjects.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/synchronization.h"
 #include "libc/nt/thunk/msabi.h"
diff --git a/libc/intrin/waitforsingleobject.c b/libc/intrin/waitforsingleobject.c
index 038ff2683..c42d3b5d2 100644
--- a/libc/intrin/waitforsingleobject.c
+++ b/libc/intrin/waitforsingleobject.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/synchronization.h"
 #include "libc/nt/thunk/msabi.h"
diff --git a/libc/str/windowsdurationtotimespec.c b/libc/intrin/windowsdurationtotimespec.c
similarity index 100%
rename from libc/str/windowsdurationtotimespec.c
rename to libc/intrin/windowsdurationtotimespec.c
diff --git a/libc/str/windowsdurationtotimeval.c b/libc/intrin/windowsdurationtotimeval.c
similarity index 100%
rename from libc/str/windowsdurationtotimeval.c
rename to libc/intrin/windowsdurationtotimeval.c
diff --git a/libc/str/windowstimetotimespec.c b/libc/intrin/windowstimetotimespec.c
similarity index 100%
rename from libc/str/windowstimetotimespec.c
rename to libc/intrin/windowstimetotimespec.c
diff --git a/libc/str/windowstimetotimeval.c b/libc/intrin/windowstimetotimeval.c
similarity index 100%
rename from libc/str/windowstimetotimeval.c
rename to libc/intrin/windowstimetotimeval.c
diff --git a/libc/intrin/winerr.greg.c b/libc/intrin/winerr.greg.c
index b960296a1..68abab78e 100644
--- a/libc/intrin/winerr.greg.c
+++ b/libc/intrin/winerr.greg.c
@@ -24,7 +24,7 @@
 #include "libc/nt/runtime.h"
 #include "libc/sock/internal.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/thread/tls2.internal.h"
+#include "libc/thread/tls.h"
 
 /**
  * Return path for failed Win32 API calls.
@@ -32,7 +32,7 @@
  * @return -1 w/ few exceptions
  * @note this is a code-size saving device
  */
-privileged int64_t __winerr(void) {
+privileged optimizesize int64_t __winerr(void) {
   errno_t e;
   if (IsWindows()) {
     e = __dos2errno(__imp_GetLastError());
diff --git a/libc/intrin/wintlsinit.c b/libc/intrin/wintlsinit.c
index 599bffb13..eb19331ff 100644
--- a/libc/intrin/wintlsinit.c
+++ b/libc/intrin/wintlsinit.c
@@ -16,12 +16,13 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/atomic.h"
 #include "libc/log/libfatal.internal.h"
 #include "libc/nt/thread.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/runtime/runtime.h"
 #include "libc/thread/tls.h"
-#include "libc/thread/tls2.internal.h"
+#ifdef __x86_64__
 
 __msabi extern typeof(GetCurrentThreadId) *const __imp_GetCurrentThreadId;
 
@@ -34,10 +35,14 @@ textwindows dontinstrument void __bootstrap_tls(struct CosmoTib *tib,
   tib->tib_self = tib;
   tib->tib_self2 = tib;
   tib->tib_sigmask = -1;
-  tib->tib_strace = __strace;
-  tib->tib_ftrace = __ftrace;
+  tib->tib_strace = -100;
+  tib->tib_ftrace = -100;
   tib->tib_sigstack_size = 57344;
   tib->tib_sigstack_addr = bp - 57344;
-  tib->tib_tid = __imp_GetCurrentThreadId();
+  int tid = __imp_GetCurrentThreadId();
+  atomic_init(&tib->tib_ptid, tid);
+  atomic_init(&tib->tib_ctid, tid);
   __set_tls_win32(tib);
 }
+
+#endif /* __x86_64__ */
diff --git a/libc/intrin/writeprocessmemory.c b/libc/intrin/writeprocessmemory.c
new file mode 100644
index 000000000..ec99b583b
--- /dev/null
+++ b/libc/intrin/writeprocessmemory.c
@@ -0,0 +1,36 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/nt/memory.h"
+#include "libc/nt/thunk/msabi.h"
+
+__msabi extern typeof(WriteProcessMemory) *const __imp_WriteProcessMemory;
+
+bool32 WriteProcessMemory(int64_t hProcess, void *lpBaseAddress,
+                          const void *lpBuffer, uint64_t nSize,
+                          uint64_t *opt_out_lpNumberOfBytesWritten) {
+  bool32 ok = __imp_WriteProcessMemory(hProcess, lpBaseAddress, lpBuffer, nSize,
+                                       opt_out_lpNumberOfBytesWritten);
+  if (!ok)
+    __winerr();
+  NTTRACE("WriteProcessMemory(%ld, %p, %p, %'lu, %p) → %hhhd% m", hProcess,
+          lpBaseAddress, lpBuffer, nSize, opt_out_lpNumberOfBytesWritten, ok);
+  return ok;
+}
diff --git a/libc/intrin/wsagetoverlappedresult.c b/libc/intrin/wsagetoverlappedresult.c
index a9096ec8a..f1315bcef 100644
--- a/libc/intrin/wsagetoverlappedresult.c
+++ b/libc/intrin/wsagetoverlappedresult.c
@@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
-#include "libc/intrin/describentoverlapped.internal.h"
+#include "libc/intrin/describentoverlapped.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/mem/alloca.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
diff --git a/libc/intrin/wsarecv.c b/libc/intrin/wsarecv.c
index 89cad8a1c..62c489e0f 100644
--- a/libc/intrin/wsarecv.c
+++ b/libc/intrin/wsarecv.c
@@ -18,11 +18,11 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/describentoverlapped.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/describentoverlapped.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
 #include "libc/runtime/runtime.h"
@@ -59,8 +59,8 @@ textwindows int WSARecv(
   }
   if (UNLIKELY(__strace > 0) && strace_enabled(0) > 0) {
     kprintf(STRACE_PROLOGUE "WSARecv(%lu, [", s);
-    DescribeIovNt(inout_lpBuffers, dwBufferCount,
-                  rc != -1 ? NumberOfBytesRecvd : 0);
+    _DescribeIovNt(inout_lpBuffers, dwBufferCount,
+                   rc != -1 ? NumberOfBytesRecvd : 0);
     kprintf("], %u, [%'u], %p, %s, %p) → %d% lm\n", dwBufferCount,
             NumberOfBytesRecvd, inout_lpFlags,
             DescribeNtOverlapped(opt_inout_lpOverlapped),
diff --git a/libc/intrin/wsarecvfrom.c b/libc/intrin/wsarecvfrom.c
index 9965974d3..0885c0eec 100644
--- a/libc/intrin/wsarecvfrom.c
+++ b/libc/intrin/wsarecvfrom.c
@@ -17,12 +17,13 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/describentoverlapped.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/describentoverlapped.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/runtime.h"
+#include "libc/nt/struct/iovec.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
 #include "libc/runtime/runtime.h"
@@ -54,8 +55,8 @@ textwindows int WSARecvFrom(
   }
   if (UNLIKELY(__strace > 0) && strace_enabled(0) > 0) {
     kprintf(STRACE_PROLOGUE "WSARecvFrom(%lu, [", s);
-    DescribeIovNt(inout_lpBuffers, dwBufferCount,
-                  rc != -1 ? NumberOfBytesRecvd : 0);
+    _DescribeIovNt(inout_lpBuffers, dwBufferCount,
+                   rc != -1 ? NumberOfBytesRecvd : 0);
     kprintf("], %u, [%'u], %p, %p, %p, %s, %p) → %d %d\n", dwBufferCount,
             NumberOfBytesRecvd, opt_out_fromsockaddr, opt_inout_fromsockaddrlen,
             inout_lpFlags, DescribeNtOverlapped(opt_inout_lpOverlapped),
diff --git a/libc/intrin/wsawaitformultipleevents.c b/libc/intrin/wsawaitformultipleevents.c
index 33f8d65c7..115d9615e 100644
--- a/libc/intrin/wsawaitformultipleevents.c
+++ b/libc/intrin/wsawaitformultipleevents.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
 
diff --git a/libc/intrin/x86.c b/libc/intrin/x86.c
index 0ee34f136..a86531533 100644
--- a/libc/intrin/x86.c
+++ b/libc/intrin/x86.c
@@ -381,6 +381,13 @@ static const char *getAMDProcessorTypeAndSubtype(unsigned Family,
   const char *CPU = 0;
 
   switch (Family) {
+    case 15:
+      if (testFeature(FEATURE_SSE3)) {
+        CPU = "k8-sse3";
+        break;
+      }
+      CPU = "k8";
+      break;
     case 16:
       CPU = "amdfam10";
       *Type = AMDFAM10H;
@@ -535,13 +542,15 @@ static void getAvailableFeatures(unsigned ECX, unsigned EDX, unsigned MaxLeaf,
     setFeature(FEATURE_AES);
   if ((ECX >> 29) & 1)
     setFeature(FEATURE_F16C);
+  if ((ECX >> 30) & 1)
+    setFeature(FEATURE_RDRND);
 
   // If CPUID indicates support for XSAVE, XRESTORE and AVX, and XGETBV
   // indicates that the AVX registers will be saved and restored on context
   // switch, then we have full AVX support.
   const unsigned AVXBits = (1 << 27) | (1 << 28);
-  bool HasAVX = ((ECX & AVXBits) == AVXBits) && !getX86XCR0(&EAX, &EDX) &&
-                ((EAX & 0x6) == 0x6);
+  bool HasAVXSave = ((ECX & AVXBits) == AVXBits) && !getX86XCR0(&EAX, &EDX) &&
+                    ((EAX & 0x6) == 0x6);
 #if defined(__APPLE__)
   // Darwin lazily saves the AVX512 context on first use: trust that the OS will
   // save the AVX512 context if we use AVX512 instructions, even the bit is not
@@ -549,71 +558,174 @@ static void getAvailableFeatures(unsigned ECX, unsigned EDX, unsigned MaxLeaf,
   bool HasAVX512Save = true;
 #else
   // AVX512 requires additional context to be saved by the OS.
-  bool HasAVX512Save = HasAVX && ((EAX & 0xe0) == 0xe0);
+  bool HasAVX512Save = HasAVXSave && ((EAX & 0xe0) == 0xe0);
 #endif
+  // AMX requires additional context to be saved by the OS.
+  const unsigned AMXBits = (1 << 17) | (1 << 18);
+  bool HasXSave = ((ECX >> 27) & 1) && !getX86XCR0(&EAX, &EDX);
+  bool HasAMXSave = HasXSave && ((EAX & AMXBits) == AMXBits);
 
-  if (HasAVX)
+  if (HasAVXSave)
     setFeature(FEATURE_AVX);
 
   bool HasLeaf7 =
       MaxLeaf >= 0x7 && !getX86CpuIDAndInfoEx(0x7, 0x0, &EAX, &EBX, &ECX, &EDX);
 
-  if (HasLeaf7) {
-    if ((EBX >> 3) & 1)
-      setFeature(FEATURE_BMI);
-    if (((EBX >> 5) & 1) && HasAVX)
-      setFeature(FEATURE_AVX2);
-    if ((EBX >> 8) & 1)
-      setFeature(FEATURE_BMI2);
-    if (HasAVX512Save) {
-      if ((EBX >> 16) & 1)
-        setFeature(FEATURE_AVX512F);
-      if ((EBX >> 17) & 1)
-        setFeature(FEATURE_AVX512DQ);
-      if ((EBX >> 21) & 1)
-        setFeature(FEATURE_AVX512IFMA);
-      if ((EBX >> 26) & 1)
-        setFeature(FEATURE_AVX512PF);
-      if ((EBX >> 27) & 1)
-        setFeature(FEATURE_AVX512ER);
-      if ((EBX >> 28) & 1)
-        setFeature(FEATURE_AVX512CD);
-      if ((EBX >> 30) & 1)
-        setFeature(FEATURE_AVX512BW);
-      if ((EBX >> 31) & 1)
-        setFeature(FEATURE_AVX512VL);
-      if ((ECX >> 1) & 1)
-        setFeature(FEATURE_AVX512VBMI);
-      if ((ECX >> 6) & 1)
-        setFeature(FEATURE_AVX512VBMI2);
-      if ((ECX >> 11) & 1)
-        setFeature(FEATURE_AVX512VNNI);
-      if ((ECX >> 12) & 1)
-        setFeature(FEATURE_AVX512BITALG);
-      if ((ECX >> 14) & 1)
-        setFeature(FEATURE_AVX512VPOPCNTDQ);
-      if ((EDX >> 2) & 1)
-        setFeature(FEATURE_AVX5124VNNIW);
-      if ((EDX >> 3) & 1)
-        setFeature(FEATURE_AVX5124FMAPS);
-      if ((EDX >> 8) & 1)
-        setFeature(FEATURE_AVX512VP2INTERSECT);
-      if ((EDX >> 23) & 1)
-        setFeature(FEATURE_AVX512FP16);
-    }
-    if ((ECX >> 8) & 1)
-      setFeature(FEATURE_GFNI);
-    if (((ECX >> 10) & 1) && HasAVX)
-      setFeature(FEATURE_VPCLMULQDQ);
-  }
+  if (HasLeaf7 && ((EBX >> 0) & 1))
+    setFeature(FEATURE_FSGSBASE);
+  if (HasLeaf7 && ((EBX >> 2) & 1))
+    setFeature(FEATURE_SGX);
+  if (HasLeaf7 && ((EBX >> 3) & 1))
+    setFeature(FEATURE_BMI);
+  if (HasLeaf7 && ((EBX >> 5) & 1) && HasAVXSave)
+    setFeature(FEATURE_AVX2);
+  if (HasLeaf7 && ((EBX >> 8) & 1))
+    setFeature(FEATURE_BMI2);
+  if (HasLeaf7 && ((EBX >> 11) & 1))
+    setFeature(FEATURE_RTM);
+  if (HasLeaf7 && ((EBX >> 16) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512F);
+  if (HasLeaf7 && ((EBX >> 17) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512DQ);
+  if (HasLeaf7 && ((EBX >> 18) & 1))
+    setFeature(FEATURE_RDSEED);
+  if (HasLeaf7 && ((EBX >> 19) & 1))
+    setFeature(FEATURE_ADX);
+  if (HasLeaf7 && ((EBX >> 21) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512IFMA);
+  if (HasLeaf7 && ((EBX >> 24) & 1))
+    setFeature(FEATURE_CLWB);
+  if (HasLeaf7 && ((EBX >> 26) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512PF);
+  if (HasLeaf7 && ((EBX >> 27) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512ER);
+  if (HasLeaf7 && ((EBX >> 28) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512CD);
+  if (HasLeaf7 && ((EBX >> 29) & 1))
+    setFeature(FEATURE_SHA);
+  if (HasLeaf7 && ((EBX >> 30) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512BW);
+  if (HasLeaf7 && ((EBX >> 31) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512VL);
+
+  if (HasLeaf7 && ((ECX >> 0) & 1))
+    setFeature(FEATURE_PREFETCHWT1);
+  if (HasLeaf7 && ((ECX >> 1) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512VBMI);
+  if (HasLeaf7 && ((ECX >> 4) & 1))
+    setFeature(FEATURE_PKU);
+  if (HasLeaf7 && ((ECX >> 5) & 1))
+    setFeature(FEATURE_WAITPKG);
+  if (HasLeaf7 && ((ECX >> 6) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512VBMI2);
+  if (HasLeaf7 && ((ECX >> 7) & 1))
+    setFeature(FEATURE_SHSTK);
+  if (HasLeaf7 && ((ECX >> 8) & 1))
+    setFeature(FEATURE_GFNI);
+  if (HasLeaf7 && ((ECX >> 9) & 1) && HasAVXSave)
+    setFeature(FEATURE_VAES);
+  if (HasLeaf7 && ((ECX >> 10) & 1) && HasAVXSave)
+    setFeature(FEATURE_VPCLMULQDQ);
+  if (HasLeaf7 && ((ECX >> 11) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512VNNI);
+  if (HasLeaf7 && ((ECX >> 12) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512BITALG);
+  if (HasLeaf7 && ((ECX >> 14) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512VPOPCNTDQ);
+  if (HasLeaf7 && ((ECX >> 22) & 1))
+    setFeature(FEATURE_RDPID);
+  if (HasLeaf7 && ((ECX >> 23) & 1))
+    setFeature(FEATURE_KL);
+  if (HasLeaf7 && ((ECX >> 25) & 1))
+    setFeature(FEATURE_CLDEMOTE);
+  if (HasLeaf7 && ((ECX >> 27) & 1))
+    setFeature(FEATURE_MOVDIRI);
+  if (HasLeaf7 && ((ECX >> 28) & 1))
+    setFeature(FEATURE_MOVDIR64B);
+  if (HasLeaf7 && ((ECX >> 29) & 1))
+    setFeature(FEATURE_ENQCMD);
+
+  if (HasLeaf7 && ((EDX >> 2) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX5124VNNIW);
+  if (HasLeaf7 && ((EDX >> 3) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX5124FMAPS);
+  if (HasLeaf7 && ((EDX >> 5) & 1))
+    setFeature(FEATURE_UINTR);
+  if (HasLeaf7 && ((EDX >> 8) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512VP2INTERSECT);
+  if (HasLeaf7 && ((EDX >> 14) & 1))
+    setFeature(FEATURE_SERIALIZE);
+  if (HasLeaf7 && ((EDX >> 16) & 1))
+    setFeature(FEATURE_TSXLDTRK);
+  if (HasLeaf7 && ((EDX >> 18) & 1))
+    setFeature(FEATURE_PCONFIG);
+  if (HasLeaf7 && ((EDX >> 22) & 1) && HasAMXSave)
+    setFeature(FEATURE_AMX_BF16);
+  if (HasLeaf7 && ((EDX >> 23) & 1) && HasAVX512Save)
+    setFeature(FEATURE_AVX512FP16);
+  if (HasLeaf7 && ((EDX >> 24) & 1) && HasAMXSave)
+    setFeature(FEATURE_AMX_TILE);
+  if (HasLeaf7 && ((EDX >> 25) & 1) && HasAMXSave)
+    setFeature(FEATURE_AMX_INT8);
 
   // EAX from subleaf 0 is the maximum subleaf supported. Some CPUs don't
   // return all 0s for invalid subleaves so check the limit.
   bool HasLeaf7Subleaf1 =
       HasLeaf7 && EAX >= 1 &&
       !getX86CpuIDAndInfoEx(0x7, 0x1, &EAX, &EBX, &ECX, &EDX);
+  if (HasLeaf7Subleaf1 && ((EAX >> 0) & 1))
+    setFeature(FEATURE_SHA512);
+  if (HasLeaf7Subleaf1 && ((EAX >> 1) & 1))
+    setFeature(FEATURE_SM3);
+  if (HasLeaf7Subleaf1 && ((EAX >> 2) & 1))
+    setFeature(FEATURE_SM4);
+  if (HasLeaf7Subleaf1 && ((EAX >> 3) & 1))
+    setFeature(FEATURE_RAOINT);
+  if (HasLeaf7Subleaf1 && ((EAX >> 4) & 1) && HasAVXSave)
+    setFeature(FEATURE_AVXVNNI);
   if (HasLeaf7Subleaf1 && ((EAX >> 5) & 1) && HasAVX512Save)
     setFeature(FEATURE_AVX512BF16);
+  if (HasLeaf7Subleaf1 && ((EAX >> 7) & 1))
+    setFeature(FEATURE_CMPCCXADD);
+  if (HasLeaf7Subleaf1 && ((EAX >> 21) & 1) && HasAMXSave)
+    setFeature(FEATURE_AMX_FP16);
+  if (HasLeaf7Subleaf1 && ((EAX >> 22) & 1))
+    setFeature(FEATURE_HRESET);
+  if (HasLeaf7Subleaf1 && ((EAX >> 23) & 1) && HasAVXSave)
+    setFeature(FEATURE_AVXIFMA);
+
+  if (HasLeaf7Subleaf1 && ((EDX >> 4) & 1) && HasAVXSave)
+    setFeature(FEATURE_AVXVNNIINT8);
+  if (HasLeaf7Subleaf1 && ((EDX >> 5) & 1) && HasAVXSave)
+    setFeature(FEATURE_AVXNECONVERT);
+  if (HasLeaf7Subleaf1 && ((EDX >> 8) & 1) && HasAMXSave)
+    setFeature(FEATURE_AMX_COMPLEX);
+  if (HasLeaf7Subleaf1 && ((EDX >> 10) & 1) && HasAVXSave)
+    setFeature(FEATURE_AVXVNNIINT16);
+  if (HasLeaf7Subleaf1 && ((EDX >> 14) & 1))
+    setFeature(FEATURE_PREFETCHI);
+  if (HasLeaf7Subleaf1 && ((EDX >> 15) & 1))
+    setFeature(FEATURE_USERMSR);
+  if (HasLeaf7Subleaf1 && ((EDX >> 19) & 1))
+    setFeature(FEATURE_AVX10_1_256);
+  if (HasLeaf7Subleaf1 && ((EDX >> 21) & 1))
+    setFeature(FEATURE_APXF);
+
+  unsigned MaxLevel;
+  getX86CpuIDAndInfo(0, &MaxLevel, &EBX, &ECX, &EDX);
+  bool HasLeafD = MaxLevel >= 0xd &&
+                  !getX86CpuIDAndInfoEx(0xd, 0x1, &EAX, &EBX, &ECX, &EDX);
+  if (HasLeafD && ((EAX >> 0) & 1) && HasAVXSave)
+    setFeature(FEATURE_XSAVEOPT);
+  if (HasLeafD && ((EAX >> 1) & 1) && HasAVXSave)
+    setFeature(FEATURE_XSAVEC);
+  if (HasLeafD && ((EAX >> 3) & 1) && HasAVXSave)
+    setFeature(FEATURE_XSAVES);
+
+  bool HasLeaf24 =
+      MaxLevel >= 0x24 && !getX86CpuIDAndInfo(0x24, &EAX, &EBX, &ECX, &EDX);
+  if (HasLeaf7Subleaf1 && ((EDX >> 19) & 1) && HasLeaf24 && ((EBX >> 18) & 1))
+    setFeature(FEATURE_AVX10_1_512);
 
   unsigned MaxExtLevel;
   getX86CpuIDAndInfo(0x80000000, &MaxExtLevel, &EBX, &ECX, &EDX);
@@ -627,14 +739,40 @@ static void getAvailableFeatures(unsigned ECX, unsigned EDX, unsigned MaxLeaf,
       setFeature(FEATURE_LZCNT);
     if (((ECX >> 6) & 1))
       setFeature(FEATURE_SSE4_A);
+    if (((ECX >> 8) & 1))
+      setFeature(FEATURE_PRFCHW);
     if (((ECX >> 11) & 1))
       setFeature(FEATURE_XOP);
+    if (((ECX >> 15) & 1))
+      setFeature(FEATURE_LWP);
     if (((ECX >> 16) & 1))
       setFeature(FEATURE_FMA4);
+    if (((ECX >> 21) & 1))
+      setFeature(FEATURE_TBM);
+    if (((ECX >> 29) & 1))
+      setFeature(FEATURE_MWAITX);
+
     if (((EDX >> 29) & 1))
       setFeature(FEATURE_LM);
   }
 
+  bool HasExtLeaf8 = MaxExtLevel >= 0x80000008 &&
+                     !getX86CpuIDAndInfo(0x80000008, &EAX, &EBX, &ECX, &EDX);
+  if (HasExtLeaf8 && ((EBX >> 0) & 1))
+    setFeature(FEATURE_CLZERO);
+  if (HasExtLeaf8 && ((EBX >> 9) & 1))
+    setFeature(FEATURE_WBNOINVD);
+
+  bool HasLeaf14 = MaxLevel >= 0x14 &&
+                   !getX86CpuIDAndInfoEx(0x14, 0x0, &EAX, &EBX, &ECX, &EDX);
+  if (HasLeaf14 && ((EBX >> 4) & 1))
+    setFeature(FEATURE_PTWRITE);
+
+  bool HasLeaf19 =
+      MaxLevel >= 0x19 && !getX86CpuIDAndInfo(0x19, &EAX, &EBX, &ECX, &EDX);
+  if (HasLeaf7 && HasLeaf19 && ((EBX >> 2) & 1))
+    setFeature(FEATURE_WIDEKL);
+
   if (hasFeature(FEATURE_LM) && hasFeature(FEATURE_SSE2)) {
     setFeature(FEATURE_X86_64_BASELINE);
     if (hasFeature(FEATURE_CMPXCHG16B) && hasFeature(FEATURE_POPCNT) &&
diff --git a/libc/intrin/x86.h b/libc/intrin/x86.h
index 8608454f2..9624fb496 100644
--- a/libc/intrin/x86.h
+++ b/libc/intrin/x86.h
@@ -114,20 +114,88 @@ enum ProcessorFeatures {
   FEATURE_AVX512BITALG,
   FEATURE_AVX512BF16,
   FEATURE_AVX512VP2INTERSECT,
-
-  FEATURE_CMPXCHG16B = 46,
-  FEATURE_F16C = 49,
+  // FIXME: Below Features has some missings comparing to gcc, it's because gcc
+  // has some not one-to-one mapped in llvm.
+  // FEATURE_3DNOW,
+  // FEATURE_3DNOWP,
+  FEATURE_ADX = 40,
+  // FEATURE_ABM,
+  FEATURE_CLDEMOTE = 42,
+  FEATURE_CLFLUSHOPT,
+  FEATURE_CLWB,
+  FEATURE_CLZERO,
+  FEATURE_CMPXCHG16B,
+  // FIXME: Not adding FEATURE_CMPXCHG8B is a workaround to make 'generic' as
+  // a cpu string with no X86_FEATURE_COMPAT features, which is required in
+  // current implementantion of cpu_specific/cpu_dispatch FMV feature.
+  // FEATURE_CMPXCHG8B,
+  FEATURE_ENQCMD = 48,
+  FEATURE_F16C,
+  FEATURE_FSGSBASE,
+  // FEATURE_FXSAVE,
+  // FEATURE_HLE,
+  // FEATURE_IBT,
   FEATURE_LAHF_LM = 54,
   FEATURE_LM,
-  FEATURE_WP,
+  FEATURE_LWP,
   FEATURE_LZCNT,
   FEATURE_MOVBE,
-
-  FEATURE_AVX512FP16 = 94,
+  FEATURE_MOVDIR64B,
+  FEATURE_MOVDIRI,
+  FEATURE_MWAITX,
+  // FEATURE_OSXSAVE,
+  FEATURE_PCONFIG = 63,
+  FEATURE_PKU,
+  FEATURE_PREFETCHWT1,
+  FEATURE_PRFCHW,
+  FEATURE_PTWRITE,
+  FEATURE_RDPID,
+  FEATURE_RDRND,
+  FEATURE_RDSEED,
+  FEATURE_RTM,
+  FEATURE_SERIALIZE,
+  FEATURE_SGX,
+  FEATURE_SHA,
+  FEATURE_SHSTK,
+  FEATURE_TBM,
+  FEATURE_TSXLDTRK,
+  FEATURE_VAES,
+  FEATURE_WAITPKG,
+  FEATURE_WBNOINVD,
+  FEATURE_XSAVE,
+  FEATURE_XSAVEC,
+  FEATURE_XSAVEOPT,
+  FEATURE_XSAVES,
+  FEATURE_AMX_TILE,
+  FEATURE_AMX_INT8,
+  FEATURE_AMX_BF16,
+  FEATURE_UINTR,
+  FEATURE_HRESET,
+  FEATURE_KL,
+  // FEATURE_AESKLE,
+  FEATURE_WIDEKL = 92,
+  FEATURE_AVXVNNI,
+  FEATURE_AVX512FP16,
   FEATURE_X86_64_BASELINE,
   FEATURE_X86_64_V2,
   FEATURE_X86_64_V3,
   FEATURE_X86_64_V4,
+  FEATURE_AVXIFMA,
+  FEATURE_AVXVNNIINT8,
+  FEATURE_AVXNECONVERT,
+  FEATURE_CMPCCXADD,
+  FEATURE_AMX_FP16,
+  FEATURE_PREFETCHI,
+  FEATURE_RAOINT,
+  FEATURE_AMX_COMPLEX,
+  FEATURE_AVXVNNIINT16,
+  FEATURE_SM3,
+  FEATURE_SHA512,
+  FEATURE_SM4,
+  FEATURE_APXF,
+  FEATURE_USERMSR,
+  FEATURE_AVX10_1_256,
+  FEATURE_AVX10_1_512,
   CPU_FEATURE_MAX
 };
 
diff --git a/libc/intrin/xchg.internal.h b/libc/intrin/xchg.h
similarity index 100%
rename from libc/intrin/xchg.internal.h
rename to libc/intrin/xchg.h
diff --git a/libc/irq/acpi-fadt-init.S b/libc/irq/acpi-fadt-init.S
index e58410cc3..de1038be3 100644
--- a/libc/irq/acpi-fadt-init.S
+++ b/libc/irq/acpi-fadt-init.S
@@ -26,7 +26,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/irq/acpi.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/pc.internal.h"
 
 	.init.start 312,_init_acpi_fadt
diff --git a/libc/irq/acpi-madt-init.S b/libc/irq/acpi-madt-init.S
index 3a3b473d1..6bfbddbf5 100644
--- a/libc/irq/acpi-madt-init.S
+++ b/libc/irq/acpi-madt-init.S
@@ -26,7 +26,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/irq/acpi.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/pc.internal.h"
 
 	.init.start 311,_init_acpi_madt
diff --git a/libc/irq/acpi-xsdt-init.S b/libc/irq/acpi-xsdt-init.S
index 2275dc8d3..98f7db6a3 100644
--- a/libc/irq/acpi-xsdt-init.S
+++ b/libc/irq/acpi-xsdt-init.S
@@ -26,7 +26,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/irq/acpi.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/pc.internal.h"
 
 	.init.start 310,_init_acpi_xsdt
diff --git a/libc/irq/acpi-xsdt.c b/libc/irq/acpi-xsdt.c
index e37f92a3d..83b71ffd1 100644
--- a/libc/irq/acpi-xsdt.c
+++ b/libc/irq/acpi-xsdt.c
@@ -26,11 +26,11 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/directmap.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/irq/acpi.internal.h"
 #include "libc/log/color.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/efi.h"
 #include "libc/runtime/pc.internal.h"
 #include "libc/serialize.h"
@@ -58,9 +58,8 @@ textstartup void *_AcpiOsMapUncachedMemory(uintptr_t phy, size_t n) {
 }
 
 textstartup static void *_AcpiOsAllocatePages(size_t n) {
-  struct DirectMap dm = sys_mmap_metal(NULL, n, PROT_READ | PROT_WRITE,
-                                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-  void *addr = dm.addr;
+  void *addr = sys_mmap_metal(NULL, n, PROT_READ | PROT_WRITE,
+                              MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   if (addr == (void *)-1)
     addr = NULL;
   return addr;
diff --git a/libc/iso646.internal.h b/libc/iso646.h
similarity index 100%
rename from libc/iso646.internal.h
rename to libc/iso646.h
diff --git a/libc/isystem/__algorithm/adjacent_find.h b/libc/isystem/__algorithm/adjacent_find.h
deleted file mode 100644
index 5e1d2ad07..000000000
--- a/libc/isystem/__algorithm/adjacent_find.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/adjacent_find.h"
diff --git a/libc/isystem/__algorithm/all_of.h b/libc/isystem/__algorithm/all_of.h
deleted file mode 100644
index 4652ac854..000000000
--- a/libc/isystem/__algorithm/all_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/all_of.h"
diff --git a/libc/isystem/__algorithm/any_of.h b/libc/isystem/__algorithm/any_of.h
deleted file mode 100644
index 6f273d1d9..000000000
--- a/libc/isystem/__algorithm/any_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/any_of.h"
diff --git a/libc/isystem/__algorithm/binary_search.h b/libc/isystem/__algorithm/binary_search.h
deleted file mode 100644
index 980063c6d..000000000
--- a/libc/isystem/__algorithm/binary_search.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/binary_search.h"
diff --git a/libc/isystem/__algorithm/clamp.h b/libc/isystem/__algorithm/clamp.h
deleted file mode 100644
index 7b2774011..000000000
--- a/libc/isystem/__algorithm/clamp.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/clamp.h"
diff --git a/libc/isystem/__algorithm/comp.h b/libc/isystem/__algorithm/comp.h
deleted file mode 100644
index eefb8bf55..000000000
--- a/libc/isystem/__algorithm/comp.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/comp.h"
diff --git a/libc/isystem/__algorithm/comp_ref_type.h b/libc/isystem/__algorithm/comp_ref_type.h
deleted file mode 100644
index a99ce32cf..000000000
--- a/libc/isystem/__algorithm/comp_ref_type.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/comp_ref_type.h"
diff --git a/libc/isystem/__algorithm/copy.h b/libc/isystem/__algorithm/copy.h
deleted file mode 100644
index f0b135cda..000000000
--- a/libc/isystem/__algorithm/copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/copy.h"
diff --git a/libc/isystem/__algorithm/copy_backward.h b/libc/isystem/__algorithm/copy_backward.h
deleted file mode 100644
index f1f982802..000000000
--- a/libc/isystem/__algorithm/copy_backward.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/copy_backward.h"
diff --git a/libc/isystem/__algorithm/copy_if.h b/libc/isystem/__algorithm/copy_if.h
deleted file mode 100644
index 78b1e991d..000000000
--- a/libc/isystem/__algorithm/copy_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/copy_if.h"
diff --git a/libc/isystem/__algorithm/copy_move_common.h b/libc/isystem/__algorithm/copy_move_common.h
deleted file mode 100644
index dbd46eca0..000000000
--- a/libc/isystem/__algorithm/copy_move_common.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/copy_move_common.h"
diff --git a/libc/isystem/__algorithm/copy_n.h b/libc/isystem/__algorithm/copy_n.h
deleted file mode 100644
index e1678d6b0..000000000
--- a/libc/isystem/__algorithm/copy_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/copy_n.h"
diff --git a/libc/isystem/__algorithm/count.h b/libc/isystem/__algorithm/count.h
deleted file mode 100644
index 29503d08c..000000000
--- a/libc/isystem/__algorithm/count.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/count.h"
diff --git a/libc/isystem/__algorithm/count_if.h b/libc/isystem/__algorithm/count_if.h
deleted file mode 100644
index 1e92f0c16..000000000
--- a/libc/isystem/__algorithm/count_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/count_if.h"
diff --git a/libc/isystem/__algorithm/equal.h b/libc/isystem/__algorithm/equal.h
deleted file mode 100644
index c59e36840..000000000
--- a/libc/isystem/__algorithm/equal.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/equal.h"
diff --git a/libc/isystem/__algorithm/equal_range.h b/libc/isystem/__algorithm/equal_range.h
deleted file mode 100644
index 69b5941b3..000000000
--- a/libc/isystem/__algorithm/equal_range.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/equal_range.h"
diff --git a/libc/isystem/__algorithm/fill.h b/libc/isystem/__algorithm/fill.h
deleted file mode 100644
index b0e93bc45..000000000
--- a/libc/isystem/__algorithm/fill.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/fill.h"
diff --git a/libc/isystem/__algorithm/fill_n.h b/libc/isystem/__algorithm/fill_n.h
deleted file mode 100644
index d23b90a51..000000000
--- a/libc/isystem/__algorithm/fill_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/fill_n.h"
diff --git a/libc/isystem/__algorithm/find.h b/libc/isystem/__algorithm/find.h
deleted file mode 100644
index 3a409b265..000000000
--- a/libc/isystem/__algorithm/find.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/find.h"
diff --git a/libc/isystem/__algorithm/find_end.h b/libc/isystem/__algorithm/find_end.h
deleted file mode 100644
index 01b432a3d..000000000
--- a/libc/isystem/__algorithm/find_end.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/find_end.h"
diff --git a/libc/isystem/__algorithm/find_first_of.h b/libc/isystem/__algorithm/find_first_of.h
deleted file mode 100644
index 389dfab08..000000000
--- a/libc/isystem/__algorithm/find_first_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/find_first_of.h"
diff --git a/libc/isystem/__algorithm/find_if.h b/libc/isystem/__algorithm/find_if.h
deleted file mode 100644
index 617f7b0b6..000000000
--- a/libc/isystem/__algorithm/find_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/find_if.h"
diff --git a/libc/isystem/__algorithm/find_if_not.h b/libc/isystem/__algorithm/find_if_not.h
deleted file mode 100644
index 62423636e..000000000
--- a/libc/isystem/__algorithm/find_if_not.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/find_if_not.h"
diff --git a/libc/isystem/__algorithm/for_each.h b/libc/isystem/__algorithm/for_each.h
deleted file mode 100644
index 3dbb80023..000000000
--- a/libc/isystem/__algorithm/for_each.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/for_each.h"
diff --git a/libc/isystem/__algorithm/for_each_n.h b/libc/isystem/__algorithm/for_each_n.h
deleted file mode 100644
index f1d6bb9ca..000000000
--- a/libc/isystem/__algorithm/for_each_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/for_each_n.h"
diff --git a/libc/isystem/__algorithm/for_each_segment.h b/libc/isystem/__algorithm/for_each_segment.h
deleted file mode 100644
index a48155365..000000000
--- a/libc/isystem/__algorithm/for_each_segment.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/for_each_segment.h"
diff --git a/libc/isystem/__algorithm/generate.h b/libc/isystem/__algorithm/generate.h
deleted file mode 100644
index cdeb4f740..000000000
--- a/libc/isystem/__algorithm/generate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/generate.h"
diff --git a/libc/isystem/__algorithm/generate_n.h b/libc/isystem/__algorithm/generate_n.h
deleted file mode 100644
index bc63ac495..000000000
--- a/libc/isystem/__algorithm/generate_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/generate_n.h"
diff --git a/libc/isystem/__algorithm/half_positive.h b/libc/isystem/__algorithm/half_positive.h
deleted file mode 100644
index 07dbde6d8..000000000
--- a/libc/isystem/__algorithm/half_positive.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/half_positive.h"
diff --git a/libc/isystem/__algorithm/in_found_result.h b/libc/isystem/__algorithm/in_found_result.h
deleted file mode 100644
index b1ba3443b..000000000
--- a/libc/isystem/__algorithm/in_found_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/in_found_result.h"
diff --git a/libc/isystem/__algorithm/in_fun_result.h b/libc/isystem/__algorithm/in_fun_result.h
deleted file mode 100644
index 8ddaa0703..000000000
--- a/libc/isystem/__algorithm/in_fun_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/in_fun_result.h"
diff --git a/libc/isystem/__algorithm/in_in_out_result.h b/libc/isystem/__algorithm/in_in_out_result.h
deleted file mode 100644
index f60a94127..000000000
--- a/libc/isystem/__algorithm/in_in_out_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/in_in_out_result.h"
diff --git a/libc/isystem/__algorithm/in_in_result.h b/libc/isystem/__algorithm/in_in_result.h
deleted file mode 100644
index 935c3d9f2..000000000
--- a/libc/isystem/__algorithm/in_in_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/in_in_result.h"
diff --git a/libc/isystem/__algorithm/in_out_out_result.h b/libc/isystem/__algorithm/in_out_out_result.h
deleted file mode 100644
index 6aca65796..000000000
--- a/libc/isystem/__algorithm/in_out_out_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/in_out_out_result.h"
diff --git a/libc/isystem/__algorithm/in_out_result.h b/libc/isystem/__algorithm/in_out_result.h
deleted file mode 100644
index fae41433a..000000000
--- a/libc/isystem/__algorithm/in_out_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/in_out_result.h"
diff --git a/libc/isystem/__algorithm/includes.h b/libc/isystem/__algorithm/includes.h
deleted file mode 100644
index fe1dbcefc..000000000
--- a/libc/isystem/__algorithm/includes.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/includes.h"
diff --git a/libc/isystem/__algorithm/inplace_merge.h b/libc/isystem/__algorithm/inplace_merge.h
deleted file mode 100644
index 3a52f879d..000000000
--- a/libc/isystem/__algorithm/inplace_merge.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/inplace_merge.h"
diff --git a/libc/isystem/__algorithm/is_heap.h b/libc/isystem/__algorithm/is_heap.h
deleted file mode 100644
index c8fb92ecb..000000000
--- a/libc/isystem/__algorithm/is_heap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/is_heap.h"
diff --git a/libc/isystem/__algorithm/is_heap_until.h b/libc/isystem/__algorithm/is_heap_until.h
deleted file mode 100644
index b10a5340a..000000000
--- a/libc/isystem/__algorithm/is_heap_until.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/is_heap_until.h"
diff --git a/libc/isystem/__algorithm/is_partitioned.h b/libc/isystem/__algorithm/is_partitioned.h
deleted file mode 100644
index c749a1ad6..000000000
--- a/libc/isystem/__algorithm/is_partitioned.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/is_partitioned.h"
diff --git a/libc/isystem/__algorithm/is_permutation.h b/libc/isystem/__algorithm/is_permutation.h
deleted file mode 100644
index 04023edcf..000000000
--- a/libc/isystem/__algorithm/is_permutation.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/is_permutation.h"
diff --git a/libc/isystem/__algorithm/is_sorted.h b/libc/isystem/__algorithm/is_sorted.h
deleted file mode 100644
index 327f6f2f6..000000000
--- a/libc/isystem/__algorithm/is_sorted.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/is_sorted.h"
diff --git a/libc/isystem/__algorithm/is_sorted_until.h b/libc/isystem/__algorithm/is_sorted_until.h
deleted file mode 100644
index 3aaa25a47..000000000
--- a/libc/isystem/__algorithm/is_sorted_until.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/is_sorted_until.h"
diff --git a/libc/isystem/__algorithm/iter_swap.h b/libc/isystem/__algorithm/iter_swap.h
deleted file mode 100644
index 453fe0d58..000000000
--- a/libc/isystem/__algorithm/iter_swap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/iter_swap.h"
diff --git a/libc/isystem/__algorithm/iterator_operations.h b/libc/isystem/__algorithm/iterator_operations.h
deleted file mode 100644
index 40fb82c6f..000000000
--- a/libc/isystem/__algorithm/iterator_operations.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/iterator_operations.h"
diff --git a/libc/isystem/__algorithm/lexicographical_compare.h b/libc/isystem/__algorithm/lexicographical_compare.h
deleted file mode 100644
index dfb6994dd..000000000
--- a/libc/isystem/__algorithm/lexicographical_compare.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/lexicographical_compare.h"
diff --git a/libc/isystem/__algorithm/lexicographical_compare_three_way.h b/libc/isystem/__algorithm/lexicographical_compare_three_way.h
deleted file mode 100644
index 0ad819b94..000000000
--- a/libc/isystem/__algorithm/lexicographical_compare_three_way.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/lexicographical_compare_three_way.h"
diff --git a/libc/isystem/__algorithm/lower_bound.h b/libc/isystem/__algorithm/lower_bound.h
deleted file mode 100644
index 94b2db647..000000000
--- a/libc/isystem/__algorithm/lower_bound.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/lower_bound.h"
diff --git a/libc/isystem/__algorithm/make_heap.h b/libc/isystem/__algorithm/make_heap.h
deleted file mode 100644
index bcf103889..000000000
--- a/libc/isystem/__algorithm/make_heap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/make_heap.h"
diff --git a/libc/isystem/__algorithm/make_projected.h b/libc/isystem/__algorithm/make_projected.h
deleted file mode 100644
index 6d729c4b5..000000000
--- a/libc/isystem/__algorithm/make_projected.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/make_projected.h"
diff --git a/libc/isystem/__algorithm/max.h b/libc/isystem/__algorithm/max.h
deleted file mode 100644
index 484addcad..000000000
--- a/libc/isystem/__algorithm/max.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/max.h"
diff --git a/libc/isystem/__algorithm/max_element.h b/libc/isystem/__algorithm/max_element.h
deleted file mode 100644
index cfb1f66c6..000000000
--- a/libc/isystem/__algorithm/max_element.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/max_element.h"
diff --git a/libc/isystem/__algorithm/merge.h b/libc/isystem/__algorithm/merge.h
deleted file mode 100644
index 25dd21f3d..000000000
--- a/libc/isystem/__algorithm/merge.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/merge.h"
diff --git a/libc/isystem/__algorithm/min.h b/libc/isystem/__algorithm/min.h
deleted file mode 100644
index 93a1be51a..000000000
--- a/libc/isystem/__algorithm/min.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/min.h"
diff --git a/libc/isystem/__algorithm/min_element.h b/libc/isystem/__algorithm/min_element.h
deleted file mode 100644
index e6745293d..000000000
--- a/libc/isystem/__algorithm/min_element.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/min_element.h"
diff --git a/libc/isystem/__algorithm/min_max_result.h b/libc/isystem/__algorithm/min_max_result.h
deleted file mode 100644
index f944c2265..000000000
--- a/libc/isystem/__algorithm/min_max_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/min_max_result.h"
diff --git a/libc/isystem/__algorithm/minmax.h b/libc/isystem/__algorithm/minmax.h
deleted file mode 100644
index 17ef2ddf9..000000000
--- a/libc/isystem/__algorithm/minmax.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/minmax.h"
diff --git a/libc/isystem/__algorithm/minmax_element.h b/libc/isystem/__algorithm/minmax_element.h
deleted file mode 100644
index 405b168a9..000000000
--- a/libc/isystem/__algorithm/minmax_element.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/minmax_element.h"
diff --git a/libc/isystem/__algorithm/mismatch.h b/libc/isystem/__algorithm/mismatch.h
deleted file mode 100644
index 54b9c8896..000000000
--- a/libc/isystem/__algorithm/mismatch.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/mismatch.h"
diff --git a/libc/isystem/__algorithm/move.h b/libc/isystem/__algorithm/move.h
deleted file mode 100644
index 1f7b306ba..000000000
--- a/libc/isystem/__algorithm/move.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/move.h"
diff --git a/libc/isystem/__algorithm/move_backward.h b/libc/isystem/__algorithm/move_backward.h
deleted file mode 100644
index 430f91c33..000000000
--- a/libc/isystem/__algorithm/move_backward.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/move_backward.h"
diff --git a/libc/isystem/__algorithm/next_permutation.h b/libc/isystem/__algorithm/next_permutation.h
deleted file mode 100644
index fbbee7f89..000000000
--- a/libc/isystem/__algorithm/next_permutation.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/next_permutation.h"
diff --git a/libc/isystem/__algorithm/none_of.h b/libc/isystem/__algorithm/none_of.h
deleted file mode 100644
index c708d865e..000000000
--- a/libc/isystem/__algorithm/none_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/none_of.h"
diff --git a/libc/isystem/__algorithm/nth_element.h b/libc/isystem/__algorithm/nth_element.h
deleted file mode 100644
index 361b51b08..000000000
--- a/libc/isystem/__algorithm/nth_element.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/nth_element.h"
diff --git a/libc/isystem/__algorithm/partial_sort.h b/libc/isystem/__algorithm/partial_sort.h
deleted file mode 100644
index 826252843..000000000
--- a/libc/isystem/__algorithm/partial_sort.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/partial_sort.h"
diff --git a/libc/isystem/__algorithm/partial_sort_copy.h b/libc/isystem/__algorithm/partial_sort_copy.h
deleted file mode 100644
index c3304c0c0..000000000
--- a/libc/isystem/__algorithm/partial_sort_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/partial_sort_copy.h"
diff --git a/libc/isystem/__algorithm/partition.h b/libc/isystem/__algorithm/partition.h
deleted file mode 100644
index d746009c2..000000000
--- a/libc/isystem/__algorithm/partition.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/partition.h"
diff --git a/libc/isystem/__algorithm/partition_copy.h b/libc/isystem/__algorithm/partition_copy.h
deleted file mode 100644
index c53139f01..000000000
--- a/libc/isystem/__algorithm/partition_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/partition_copy.h"
diff --git a/libc/isystem/__algorithm/partition_point.h b/libc/isystem/__algorithm/partition_point.h
deleted file mode 100644
index af904ffe3..000000000
--- a/libc/isystem/__algorithm/partition_point.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/partition_point.h"
diff --git a/libc/isystem/__algorithm/pop_heap.h b/libc/isystem/__algorithm/pop_heap.h
deleted file mode 100644
index 29efc6977..000000000
--- a/libc/isystem/__algorithm/pop_heap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pop_heap.h"
diff --git a/libc/isystem/__algorithm/prev_permutation.h b/libc/isystem/__algorithm/prev_permutation.h
deleted file mode 100644
index d2b0e6729..000000000
--- a/libc/isystem/__algorithm/prev_permutation.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/prev_permutation.h"
diff --git a/libc/isystem/__algorithm/pstl_any_all_none_of.h b/libc/isystem/__algorithm/pstl_any_all_none_of.h
deleted file mode 100644
index 1383d20ea..000000000
--- a/libc/isystem/__algorithm/pstl_any_all_none_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_any_all_none_of.h"
diff --git a/libc/isystem/__algorithm/pstl_backend.h b/libc/isystem/__algorithm/pstl_backend.h
deleted file mode 100644
index f46ff3449..000000000
--- a/libc/isystem/__algorithm/pstl_backend.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backend.h"
diff --git a/libc/isystem/__algorithm/pstl_backends/cpu_backend.h b/libc/isystem/__algorithm/pstl_backends/cpu_backend.h
deleted file mode 100644
index b85042f11..000000000
--- a/libc/isystem/__algorithm/pstl_backends/cpu_backend.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backends/cpu_backend.h"
diff --git a/libc/isystem/__algorithm/pstl_backends/cpu_backends/any_of.h b/libc/isystem/__algorithm/pstl_backends/cpu_backends/any_of.h
deleted file mode 100644
index ee3e81079..000000000
--- a/libc/isystem/__algorithm/pstl_backends/cpu_backends/any_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backends/cpu_backends/any_of.h"
diff --git a/libc/isystem/__algorithm/pstl_backends/cpu_backends/backend.h b/libc/isystem/__algorithm/pstl_backends/cpu_backends/backend.h
deleted file mode 100644
index 84df5fe9f..000000000
--- a/libc/isystem/__algorithm/pstl_backends/cpu_backends/backend.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backends/cpu_backends/backend.h"
diff --git a/libc/isystem/__algorithm/pstl_backends/cpu_backends/fill.h b/libc/isystem/__algorithm/pstl_backends/cpu_backends/fill.h
deleted file mode 100644
index 0f5b7b478..000000000
--- a/libc/isystem/__algorithm/pstl_backends/cpu_backends/fill.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backends/cpu_backends/fill.h"
diff --git a/libc/isystem/__algorithm/pstl_backends/cpu_backends/find_if.h b/libc/isystem/__algorithm/pstl_backends/cpu_backends/find_if.h
deleted file mode 100644
index 7adf76049..000000000
--- a/libc/isystem/__algorithm/pstl_backends/cpu_backends/find_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backends/cpu_backends/find_if.h"
diff --git a/libc/isystem/__algorithm/pstl_backends/cpu_backends/for_each.h b/libc/isystem/__algorithm/pstl_backends/cpu_backends/for_each.h
deleted file mode 100644
index aaa45c6c8..000000000
--- a/libc/isystem/__algorithm/pstl_backends/cpu_backends/for_each.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backends/cpu_backends/for_each.h"
diff --git a/libc/isystem/__algorithm/pstl_backends/cpu_backends/merge.h b/libc/isystem/__algorithm/pstl_backends/cpu_backends/merge.h
deleted file mode 100644
index 7676a5da3..000000000
--- a/libc/isystem/__algorithm/pstl_backends/cpu_backends/merge.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backends/cpu_backends/merge.h"
diff --git a/libc/isystem/__algorithm/pstl_backends/cpu_backends/serial.h b/libc/isystem/__algorithm/pstl_backends/cpu_backends/serial.h
deleted file mode 100644
index 4b25ed3b5..000000000
--- a/libc/isystem/__algorithm/pstl_backends/cpu_backends/serial.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backends/cpu_backends/serial.h"
diff --git a/libc/isystem/__algorithm/pstl_backends/cpu_backends/thread.h b/libc/isystem/__algorithm/pstl_backends/cpu_backends/thread.h
deleted file mode 100644
index 6487ec38c..000000000
--- a/libc/isystem/__algorithm/pstl_backends/cpu_backends/thread.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backends/cpu_backends/thread.h"
diff --git a/libc/isystem/__algorithm/pstl_backends/cpu_backends/transform.h b/libc/isystem/__algorithm/pstl_backends/cpu_backends/transform.h
deleted file mode 100644
index 1217711a0..000000000
--- a/libc/isystem/__algorithm/pstl_backends/cpu_backends/transform.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_backends/cpu_backends/transform.h"
diff --git a/libc/isystem/__algorithm/pstl_copy.h b/libc/isystem/__algorithm/pstl_copy.h
deleted file mode 100644
index be0f6c2d3..000000000
--- a/libc/isystem/__algorithm/pstl_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_copy.h"
diff --git a/libc/isystem/__algorithm/pstl_fill.h b/libc/isystem/__algorithm/pstl_fill.h
deleted file mode 100644
index 0740e0139..000000000
--- a/libc/isystem/__algorithm/pstl_fill.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_fill.h"
diff --git a/libc/isystem/__algorithm/pstl_find.h b/libc/isystem/__algorithm/pstl_find.h
deleted file mode 100644
index cbc557e5d..000000000
--- a/libc/isystem/__algorithm/pstl_find.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_find.h"
diff --git a/libc/isystem/__algorithm/pstl_for_each.h b/libc/isystem/__algorithm/pstl_for_each.h
deleted file mode 100644
index 438931f61..000000000
--- a/libc/isystem/__algorithm/pstl_for_each.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_for_each.h"
diff --git a/libc/isystem/__algorithm/pstl_frontend_dispatch.h b/libc/isystem/__algorithm/pstl_frontend_dispatch.h
deleted file mode 100644
index a36a3e4af..000000000
--- a/libc/isystem/__algorithm/pstl_frontend_dispatch.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_frontend_dispatch.h"
diff --git a/libc/isystem/__algorithm/pstl_merge.h b/libc/isystem/__algorithm/pstl_merge.h
deleted file mode 100644
index 0121cf6b7..000000000
--- a/libc/isystem/__algorithm/pstl_merge.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_merge.h"
diff --git a/libc/isystem/__algorithm/pstl_transform.h b/libc/isystem/__algorithm/pstl_transform.h
deleted file mode 100644
index d4b998947..000000000
--- a/libc/isystem/__algorithm/pstl_transform.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/pstl_transform.h"
diff --git a/libc/isystem/__algorithm/push_heap.h b/libc/isystem/__algorithm/push_heap.h
deleted file mode 100644
index c02a0d194..000000000
--- a/libc/isystem/__algorithm/push_heap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/push_heap.h"
diff --git a/libc/isystem/__algorithm/ranges_adjacent_find.h b/libc/isystem/__algorithm/ranges_adjacent_find.h
deleted file mode 100644
index 1f2376204..000000000
--- a/libc/isystem/__algorithm/ranges_adjacent_find.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_adjacent_find.h"
diff --git a/libc/isystem/__algorithm/ranges_all_of.h b/libc/isystem/__algorithm/ranges_all_of.h
deleted file mode 100644
index 2363a515f..000000000
--- a/libc/isystem/__algorithm/ranges_all_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_all_of.h"
diff --git a/libc/isystem/__algorithm/ranges_any_of.h b/libc/isystem/__algorithm/ranges_any_of.h
deleted file mode 100644
index b87580f0b..000000000
--- a/libc/isystem/__algorithm/ranges_any_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_any_of.h"
diff --git a/libc/isystem/__algorithm/ranges_binary_search.h b/libc/isystem/__algorithm/ranges_binary_search.h
deleted file mode 100644
index c6a2f3b12..000000000
--- a/libc/isystem/__algorithm/ranges_binary_search.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_binary_search.h"
diff --git a/libc/isystem/__algorithm/ranges_clamp.h b/libc/isystem/__algorithm/ranges_clamp.h
deleted file mode 100644
index 00a415218..000000000
--- a/libc/isystem/__algorithm/ranges_clamp.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_clamp.h"
diff --git a/libc/isystem/__algorithm/ranges_copy.h b/libc/isystem/__algorithm/ranges_copy.h
deleted file mode 100644
index 614e85eaf..000000000
--- a/libc/isystem/__algorithm/ranges_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_copy.h"
diff --git a/libc/isystem/__algorithm/ranges_copy_backward.h b/libc/isystem/__algorithm/ranges_copy_backward.h
deleted file mode 100644
index 3918baef3..000000000
--- a/libc/isystem/__algorithm/ranges_copy_backward.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_copy_backward.h"
diff --git a/libc/isystem/__algorithm/ranges_copy_if.h b/libc/isystem/__algorithm/ranges_copy_if.h
deleted file mode 100644
index d38f65586..000000000
--- a/libc/isystem/__algorithm/ranges_copy_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_copy_if.h"
diff --git a/libc/isystem/__algorithm/ranges_copy_n.h b/libc/isystem/__algorithm/ranges_copy_n.h
deleted file mode 100644
index e420c638c..000000000
--- a/libc/isystem/__algorithm/ranges_copy_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_copy_n.h"
diff --git a/libc/isystem/__algorithm/ranges_count.h b/libc/isystem/__algorithm/ranges_count.h
deleted file mode 100644
index 2367c1f69..000000000
--- a/libc/isystem/__algorithm/ranges_count.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_count.h"
diff --git a/libc/isystem/__algorithm/ranges_count_if.h b/libc/isystem/__algorithm/ranges_count_if.h
deleted file mode 100644
index 23f801f37..000000000
--- a/libc/isystem/__algorithm/ranges_count_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_count_if.h"
diff --git a/libc/isystem/__algorithm/ranges_equal.h b/libc/isystem/__algorithm/ranges_equal.h
deleted file mode 100644
index 6d754d9dc..000000000
--- a/libc/isystem/__algorithm/ranges_equal.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_equal.h"
diff --git a/libc/isystem/__algorithm/ranges_equal_range.h b/libc/isystem/__algorithm/ranges_equal_range.h
deleted file mode 100644
index 0bba88876..000000000
--- a/libc/isystem/__algorithm/ranges_equal_range.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_equal_range.h"
diff --git a/libc/isystem/__algorithm/ranges_fill.h b/libc/isystem/__algorithm/ranges_fill.h
deleted file mode 100644
index 8a37d08a6..000000000
--- a/libc/isystem/__algorithm/ranges_fill.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_fill.h"
diff --git a/libc/isystem/__algorithm/ranges_fill_n.h b/libc/isystem/__algorithm/ranges_fill_n.h
deleted file mode 100644
index 549344c61..000000000
--- a/libc/isystem/__algorithm/ranges_fill_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_fill_n.h"
diff --git a/libc/isystem/__algorithm/ranges_find.h b/libc/isystem/__algorithm/ranges_find.h
deleted file mode 100644
index bb84856c7..000000000
--- a/libc/isystem/__algorithm/ranges_find.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_find.h"
diff --git a/libc/isystem/__algorithm/ranges_find_end.h b/libc/isystem/__algorithm/ranges_find_end.h
deleted file mode 100644
index 4ad4cecf6..000000000
--- a/libc/isystem/__algorithm/ranges_find_end.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_find_end.h"
diff --git a/libc/isystem/__algorithm/ranges_find_first_of.h b/libc/isystem/__algorithm/ranges_find_first_of.h
deleted file mode 100644
index aca73405f..000000000
--- a/libc/isystem/__algorithm/ranges_find_first_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_find_first_of.h"
diff --git a/libc/isystem/__algorithm/ranges_find_if.h b/libc/isystem/__algorithm/ranges_find_if.h
deleted file mode 100644
index 2f36e6891..000000000
--- a/libc/isystem/__algorithm/ranges_find_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_find_if.h"
diff --git a/libc/isystem/__algorithm/ranges_find_if_not.h b/libc/isystem/__algorithm/ranges_find_if_not.h
deleted file mode 100644
index 56af48b0c..000000000
--- a/libc/isystem/__algorithm/ranges_find_if_not.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_find_if_not.h"
diff --git a/libc/isystem/__algorithm/ranges_for_each.h b/libc/isystem/__algorithm/ranges_for_each.h
deleted file mode 100644
index df9984033..000000000
--- a/libc/isystem/__algorithm/ranges_for_each.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_for_each.h"
diff --git a/libc/isystem/__algorithm/ranges_for_each_n.h b/libc/isystem/__algorithm/ranges_for_each_n.h
deleted file mode 100644
index d14180101..000000000
--- a/libc/isystem/__algorithm/ranges_for_each_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_for_each_n.h"
diff --git a/libc/isystem/__algorithm/ranges_generate.h b/libc/isystem/__algorithm/ranges_generate.h
deleted file mode 100644
index 835940bce..000000000
--- a/libc/isystem/__algorithm/ranges_generate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_generate.h"
diff --git a/libc/isystem/__algorithm/ranges_generate_n.h b/libc/isystem/__algorithm/ranges_generate_n.h
deleted file mode 100644
index 87628794d..000000000
--- a/libc/isystem/__algorithm/ranges_generate_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_generate_n.h"
diff --git a/libc/isystem/__algorithm/ranges_includes.h b/libc/isystem/__algorithm/ranges_includes.h
deleted file mode 100644
index ae5763c6a..000000000
--- a/libc/isystem/__algorithm/ranges_includes.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_includes.h"
diff --git a/libc/isystem/__algorithm/ranges_inplace_merge.h b/libc/isystem/__algorithm/ranges_inplace_merge.h
deleted file mode 100644
index d93fc2f6a..000000000
--- a/libc/isystem/__algorithm/ranges_inplace_merge.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_inplace_merge.h"
diff --git a/libc/isystem/__algorithm/ranges_is_heap.h b/libc/isystem/__algorithm/ranges_is_heap.h
deleted file mode 100644
index 2098e2926..000000000
--- a/libc/isystem/__algorithm/ranges_is_heap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_is_heap.h"
diff --git a/libc/isystem/__algorithm/ranges_is_heap_until.h b/libc/isystem/__algorithm/ranges_is_heap_until.h
deleted file mode 100644
index 9211fed6a..000000000
--- a/libc/isystem/__algorithm/ranges_is_heap_until.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_is_heap_until.h"
diff --git a/libc/isystem/__algorithm/ranges_is_partitioned.h b/libc/isystem/__algorithm/ranges_is_partitioned.h
deleted file mode 100644
index d85d14103..000000000
--- a/libc/isystem/__algorithm/ranges_is_partitioned.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_is_partitioned.h"
diff --git a/libc/isystem/__algorithm/ranges_is_permutation.h b/libc/isystem/__algorithm/ranges_is_permutation.h
deleted file mode 100644
index 16ca02f32..000000000
--- a/libc/isystem/__algorithm/ranges_is_permutation.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_is_permutation.h"
diff --git a/libc/isystem/__algorithm/ranges_is_sorted.h b/libc/isystem/__algorithm/ranges_is_sorted.h
deleted file mode 100644
index 5c284c3c9..000000000
--- a/libc/isystem/__algorithm/ranges_is_sorted.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_is_sorted.h"
diff --git a/libc/isystem/__algorithm/ranges_is_sorted_until.h b/libc/isystem/__algorithm/ranges_is_sorted_until.h
deleted file mode 100644
index 0518f5cdf..000000000
--- a/libc/isystem/__algorithm/ranges_is_sorted_until.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_is_sorted_until.h"
diff --git a/libc/isystem/__algorithm/ranges_iterator_concept.h b/libc/isystem/__algorithm/ranges_iterator_concept.h
deleted file mode 100644
index 45e6c1170..000000000
--- a/libc/isystem/__algorithm/ranges_iterator_concept.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_iterator_concept.h"
diff --git a/libc/isystem/__algorithm/ranges_lexicographical_compare.h b/libc/isystem/__algorithm/ranges_lexicographical_compare.h
deleted file mode 100644
index 07f8d9f3b..000000000
--- a/libc/isystem/__algorithm/ranges_lexicographical_compare.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_lexicographical_compare.h"
diff --git a/libc/isystem/__algorithm/ranges_lower_bound.h b/libc/isystem/__algorithm/ranges_lower_bound.h
deleted file mode 100644
index 2267d4ae4..000000000
--- a/libc/isystem/__algorithm/ranges_lower_bound.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_lower_bound.h"
diff --git a/libc/isystem/__algorithm/ranges_make_heap.h b/libc/isystem/__algorithm/ranges_make_heap.h
deleted file mode 100644
index b365948f4..000000000
--- a/libc/isystem/__algorithm/ranges_make_heap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_make_heap.h"
diff --git a/libc/isystem/__algorithm/ranges_max.h b/libc/isystem/__algorithm/ranges_max.h
deleted file mode 100644
index 841f0c942..000000000
--- a/libc/isystem/__algorithm/ranges_max.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_max.h"
diff --git a/libc/isystem/__algorithm/ranges_max_element.h b/libc/isystem/__algorithm/ranges_max_element.h
deleted file mode 100644
index df3ac4b63..000000000
--- a/libc/isystem/__algorithm/ranges_max_element.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_max_element.h"
diff --git a/libc/isystem/__algorithm/ranges_merge.h b/libc/isystem/__algorithm/ranges_merge.h
deleted file mode 100644
index 79595cd16..000000000
--- a/libc/isystem/__algorithm/ranges_merge.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_merge.h"
diff --git a/libc/isystem/__algorithm/ranges_min.h b/libc/isystem/__algorithm/ranges_min.h
deleted file mode 100644
index cdee59d2a..000000000
--- a/libc/isystem/__algorithm/ranges_min.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_min.h"
diff --git a/libc/isystem/__algorithm/ranges_min_element.h b/libc/isystem/__algorithm/ranges_min_element.h
deleted file mode 100644
index 9d910deac..000000000
--- a/libc/isystem/__algorithm/ranges_min_element.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_min_element.h"
diff --git a/libc/isystem/__algorithm/ranges_minmax.h b/libc/isystem/__algorithm/ranges_minmax.h
deleted file mode 100644
index dde2e06a2..000000000
--- a/libc/isystem/__algorithm/ranges_minmax.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_minmax.h"
diff --git a/libc/isystem/__algorithm/ranges_minmax_element.h b/libc/isystem/__algorithm/ranges_minmax_element.h
deleted file mode 100644
index 6e4492f16..000000000
--- a/libc/isystem/__algorithm/ranges_minmax_element.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_minmax_element.h"
diff --git a/libc/isystem/__algorithm/ranges_mismatch.h b/libc/isystem/__algorithm/ranges_mismatch.h
deleted file mode 100644
index 792d15396..000000000
--- a/libc/isystem/__algorithm/ranges_mismatch.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_mismatch.h"
diff --git a/libc/isystem/__algorithm/ranges_move.h b/libc/isystem/__algorithm/ranges_move.h
deleted file mode 100644
index 31679c803..000000000
--- a/libc/isystem/__algorithm/ranges_move.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_move.h"
diff --git a/libc/isystem/__algorithm/ranges_move_backward.h b/libc/isystem/__algorithm/ranges_move_backward.h
deleted file mode 100644
index bc818a177..000000000
--- a/libc/isystem/__algorithm/ranges_move_backward.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_move_backward.h"
diff --git a/libc/isystem/__algorithm/ranges_next_permutation.h b/libc/isystem/__algorithm/ranges_next_permutation.h
deleted file mode 100644
index 6ad640a97..000000000
--- a/libc/isystem/__algorithm/ranges_next_permutation.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_next_permutation.h"
diff --git a/libc/isystem/__algorithm/ranges_none_of.h b/libc/isystem/__algorithm/ranges_none_of.h
deleted file mode 100644
index 1c646d68d..000000000
--- a/libc/isystem/__algorithm/ranges_none_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_none_of.h"
diff --git a/libc/isystem/__algorithm/ranges_nth_element.h b/libc/isystem/__algorithm/ranges_nth_element.h
deleted file mode 100644
index e1bf4c096..000000000
--- a/libc/isystem/__algorithm/ranges_nth_element.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_nth_element.h"
diff --git a/libc/isystem/__algorithm/ranges_partial_sort.h b/libc/isystem/__algorithm/ranges_partial_sort.h
deleted file mode 100644
index 31ef088ce..000000000
--- a/libc/isystem/__algorithm/ranges_partial_sort.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_partial_sort.h"
diff --git a/libc/isystem/__algorithm/ranges_partial_sort_copy.h b/libc/isystem/__algorithm/ranges_partial_sort_copy.h
deleted file mode 100644
index a77684b58..000000000
--- a/libc/isystem/__algorithm/ranges_partial_sort_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_partial_sort_copy.h"
diff --git a/libc/isystem/__algorithm/ranges_partition.h b/libc/isystem/__algorithm/ranges_partition.h
deleted file mode 100644
index 5066131c7..000000000
--- a/libc/isystem/__algorithm/ranges_partition.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_partition.h"
diff --git a/libc/isystem/__algorithm/ranges_partition_copy.h b/libc/isystem/__algorithm/ranges_partition_copy.h
deleted file mode 100644
index f11101304..000000000
--- a/libc/isystem/__algorithm/ranges_partition_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_partition_copy.h"
diff --git a/libc/isystem/__algorithm/ranges_partition_point.h b/libc/isystem/__algorithm/ranges_partition_point.h
deleted file mode 100644
index 44c05b726..000000000
--- a/libc/isystem/__algorithm/ranges_partition_point.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_partition_point.h"
diff --git a/libc/isystem/__algorithm/ranges_pop_heap.h b/libc/isystem/__algorithm/ranges_pop_heap.h
deleted file mode 100644
index a39869c2b..000000000
--- a/libc/isystem/__algorithm/ranges_pop_heap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_pop_heap.h"
diff --git a/libc/isystem/__algorithm/ranges_prev_permutation.h b/libc/isystem/__algorithm/ranges_prev_permutation.h
deleted file mode 100644
index fe51f73d9..000000000
--- a/libc/isystem/__algorithm/ranges_prev_permutation.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_prev_permutation.h"
diff --git a/libc/isystem/__algorithm/ranges_push_heap.h b/libc/isystem/__algorithm/ranges_push_heap.h
deleted file mode 100644
index 4b42e1a96..000000000
--- a/libc/isystem/__algorithm/ranges_push_heap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_push_heap.h"
diff --git a/libc/isystem/__algorithm/ranges_remove.h b/libc/isystem/__algorithm/ranges_remove.h
deleted file mode 100644
index 2daa6b198..000000000
--- a/libc/isystem/__algorithm/ranges_remove.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_remove.h"
diff --git a/libc/isystem/__algorithm/ranges_remove_copy.h b/libc/isystem/__algorithm/ranges_remove_copy.h
deleted file mode 100644
index 56dfa76c8..000000000
--- a/libc/isystem/__algorithm/ranges_remove_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_remove_copy.h"
diff --git a/libc/isystem/__algorithm/ranges_remove_copy_if.h b/libc/isystem/__algorithm/ranges_remove_copy_if.h
deleted file mode 100644
index 50b979301..000000000
--- a/libc/isystem/__algorithm/ranges_remove_copy_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_remove_copy_if.h"
diff --git a/libc/isystem/__algorithm/ranges_remove_if.h b/libc/isystem/__algorithm/ranges_remove_if.h
deleted file mode 100644
index aa6d62fdb..000000000
--- a/libc/isystem/__algorithm/ranges_remove_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_remove_if.h"
diff --git a/libc/isystem/__algorithm/ranges_replace.h b/libc/isystem/__algorithm/ranges_replace.h
deleted file mode 100644
index c768b9880..000000000
--- a/libc/isystem/__algorithm/ranges_replace.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_replace.h"
diff --git a/libc/isystem/__algorithm/ranges_replace_copy.h b/libc/isystem/__algorithm/ranges_replace_copy.h
deleted file mode 100644
index d74d03164..000000000
--- a/libc/isystem/__algorithm/ranges_replace_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_replace_copy.h"
diff --git a/libc/isystem/__algorithm/ranges_replace_copy_if.h b/libc/isystem/__algorithm/ranges_replace_copy_if.h
deleted file mode 100644
index 52b6e66a5..000000000
--- a/libc/isystem/__algorithm/ranges_replace_copy_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_replace_copy_if.h"
diff --git a/libc/isystem/__algorithm/ranges_replace_if.h b/libc/isystem/__algorithm/ranges_replace_if.h
deleted file mode 100644
index 7ba904e37..000000000
--- a/libc/isystem/__algorithm/ranges_replace_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_replace_if.h"
diff --git a/libc/isystem/__algorithm/ranges_reverse.h b/libc/isystem/__algorithm/ranges_reverse.h
deleted file mode 100644
index 1d6511164..000000000
--- a/libc/isystem/__algorithm/ranges_reverse.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_reverse.h"
diff --git a/libc/isystem/__algorithm/ranges_reverse_copy.h b/libc/isystem/__algorithm/ranges_reverse_copy.h
deleted file mode 100644
index 33326159a..000000000
--- a/libc/isystem/__algorithm/ranges_reverse_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_reverse_copy.h"
diff --git a/libc/isystem/__algorithm/ranges_rotate.h b/libc/isystem/__algorithm/ranges_rotate.h
deleted file mode 100644
index 1940bbc41..000000000
--- a/libc/isystem/__algorithm/ranges_rotate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_rotate.h"
diff --git a/libc/isystem/__algorithm/ranges_rotate_copy.h b/libc/isystem/__algorithm/ranges_rotate_copy.h
deleted file mode 100644
index 43d13c4a9..000000000
--- a/libc/isystem/__algorithm/ranges_rotate_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_rotate_copy.h"
diff --git a/libc/isystem/__algorithm/ranges_sample.h b/libc/isystem/__algorithm/ranges_sample.h
deleted file mode 100644
index 52f55a29d..000000000
--- a/libc/isystem/__algorithm/ranges_sample.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_sample.h"
diff --git a/libc/isystem/__algorithm/ranges_search.h b/libc/isystem/__algorithm/ranges_search.h
deleted file mode 100644
index acfc90c94..000000000
--- a/libc/isystem/__algorithm/ranges_search.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_search.h"
diff --git a/libc/isystem/__algorithm/ranges_search_n.h b/libc/isystem/__algorithm/ranges_search_n.h
deleted file mode 100644
index 12056e956..000000000
--- a/libc/isystem/__algorithm/ranges_search_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_search_n.h"
diff --git a/libc/isystem/__algorithm/ranges_set_difference.h b/libc/isystem/__algorithm/ranges_set_difference.h
deleted file mode 100644
index b4705f503..000000000
--- a/libc/isystem/__algorithm/ranges_set_difference.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_set_difference.h"
diff --git a/libc/isystem/__algorithm/ranges_set_intersection.h b/libc/isystem/__algorithm/ranges_set_intersection.h
deleted file mode 100644
index 592bf86a2..000000000
--- a/libc/isystem/__algorithm/ranges_set_intersection.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_set_intersection.h"
diff --git a/libc/isystem/__algorithm/ranges_set_symmetric_difference.h b/libc/isystem/__algorithm/ranges_set_symmetric_difference.h
deleted file mode 100644
index d0a8d3e4d..000000000
--- a/libc/isystem/__algorithm/ranges_set_symmetric_difference.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_set_symmetric_difference.h"
diff --git a/libc/isystem/__algorithm/ranges_set_union.h b/libc/isystem/__algorithm/ranges_set_union.h
deleted file mode 100644
index be428aa5c..000000000
--- a/libc/isystem/__algorithm/ranges_set_union.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_set_union.h"
diff --git a/libc/isystem/__algorithm/ranges_shuffle.h b/libc/isystem/__algorithm/ranges_shuffle.h
deleted file mode 100644
index 39554ef60..000000000
--- a/libc/isystem/__algorithm/ranges_shuffle.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_shuffle.h"
diff --git a/libc/isystem/__algorithm/ranges_sort.h b/libc/isystem/__algorithm/ranges_sort.h
deleted file mode 100644
index 049c5288f..000000000
--- a/libc/isystem/__algorithm/ranges_sort.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_sort.h"
diff --git a/libc/isystem/__algorithm/ranges_sort_heap.h b/libc/isystem/__algorithm/ranges_sort_heap.h
deleted file mode 100644
index 88c46cbe5..000000000
--- a/libc/isystem/__algorithm/ranges_sort_heap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_sort_heap.h"
diff --git a/libc/isystem/__algorithm/ranges_stable_partition.h b/libc/isystem/__algorithm/ranges_stable_partition.h
deleted file mode 100644
index d82565db0..000000000
--- a/libc/isystem/__algorithm/ranges_stable_partition.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_stable_partition.h"
diff --git a/libc/isystem/__algorithm/ranges_stable_sort.h b/libc/isystem/__algorithm/ranges_stable_sort.h
deleted file mode 100644
index 53b3bfd7e..000000000
--- a/libc/isystem/__algorithm/ranges_stable_sort.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_stable_sort.h"
diff --git a/libc/isystem/__algorithm/ranges_starts_with.h b/libc/isystem/__algorithm/ranges_starts_with.h
deleted file mode 100644
index 9a2a22b8f..000000000
--- a/libc/isystem/__algorithm/ranges_starts_with.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_starts_with.h"
diff --git a/libc/isystem/__algorithm/ranges_swap_ranges.h b/libc/isystem/__algorithm/ranges_swap_ranges.h
deleted file mode 100644
index 7ee898342..000000000
--- a/libc/isystem/__algorithm/ranges_swap_ranges.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_swap_ranges.h"
diff --git a/libc/isystem/__algorithm/ranges_transform.h b/libc/isystem/__algorithm/ranges_transform.h
deleted file mode 100644
index 8dc2bd3a7..000000000
--- a/libc/isystem/__algorithm/ranges_transform.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_transform.h"
diff --git a/libc/isystem/__algorithm/ranges_unique.h b/libc/isystem/__algorithm/ranges_unique.h
deleted file mode 100644
index 741c22c41..000000000
--- a/libc/isystem/__algorithm/ranges_unique.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_unique.h"
diff --git a/libc/isystem/__algorithm/ranges_unique_copy.h b/libc/isystem/__algorithm/ranges_unique_copy.h
deleted file mode 100644
index fa3ead46b..000000000
--- a/libc/isystem/__algorithm/ranges_unique_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_unique_copy.h"
diff --git a/libc/isystem/__algorithm/ranges_upper_bound.h b/libc/isystem/__algorithm/ranges_upper_bound.h
deleted file mode 100644
index 658bb096b..000000000
--- a/libc/isystem/__algorithm/ranges_upper_bound.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/ranges_upper_bound.h"
diff --git a/libc/isystem/__algorithm/remove.h b/libc/isystem/__algorithm/remove.h
deleted file mode 100644
index 1c6d33eb9..000000000
--- a/libc/isystem/__algorithm/remove.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/remove.h"
diff --git a/libc/isystem/__algorithm/remove_copy.h b/libc/isystem/__algorithm/remove_copy.h
deleted file mode 100644
index cc8f5347d..000000000
--- a/libc/isystem/__algorithm/remove_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/remove_copy.h"
diff --git a/libc/isystem/__algorithm/remove_copy_if.h b/libc/isystem/__algorithm/remove_copy_if.h
deleted file mode 100644
index fdf763b14..000000000
--- a/libc/isystem/__algorithm/remove_copy_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/remove_copy_if.h"
diff --git a/libc/isystem/__algorithm/remove_if.h b/libc/isystem/__algorithm/remove_if.h
deleted file mode 100644
index e9dc12444..000000000
--- a/libc/isystem/__algorithm/remove_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/remove_if.h"
diff --git a/libc/isystem/__algorithm/replace.h b/libc/isystem/__algorithm/replace.h
deleted file mode 100644
index 29b8205d4..000000000
--- a/libc/isystem/__algorithm/replace.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/replace.h"
diff --git a/libc/isystem/__algorithm/replace_copy.h b/libc/isystem/__algorithm/replace_copy.h
deleted file mode 100644
index 6b05b8502..000000000
--- a/libc/isystem/__algorithm/replace_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/replace_copy.h"
diff --git a/libc/isystem/__algorithm/replace_copy_if.h b/libc/isystem/__algorithm/replace_copy_if.h
deleted file mode 100644
index 13ee607b1..000000000
--- a/libc/isystem/__algorithm/replace_copy_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/replace_copy_if.h"
diff --git a/libc/isystem/__algorithm/replace_if.h b/libc/isystem/__algorithm/replace_if.h
deleted file mode 100644
index 42ac7b810..000000000
--- a/libc/isystem/__algorithm/replace_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/replace_if.h"
diff --git a/libc/isystem/__algorithm/reverse.h b/libc/isystem/__algorithm/reverse.h
deleted file mode 100644
index 76a9096f7..000000000
--- a/libc/isystem/__algorithm/reverse.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/reverse.h"
diff --git a/libc/isystem/__algorithm/reverse_copy.h b/libc/isystem/__algorithm/reverse_copy.h
deleted file mode 100644
index a0b6debef..000000000
--- a/libc/isystem/__algorithm/reverse_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/reverse_copy.h"
diff --git a/libc/isystem/__algorithm/rotate.h b/libc/isystem/__algorithm/rotate.h
deleted file mode 100644
index 84afe3294..000000000
--- a/libc/isystem/__algorithm/rotate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/rotate.h"
diff --git a/libc/isystem/__algorithm/rotate_copy.h b/libc/isystem/__algorithm/rotate_copy.h
deleted file mode 100644
index d0ad68ce0..000000000
--- a/libc/isystem/__algorithm/rotate_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/rotate_copy.h"
diff --git a/libc/isystem/__algorithm/sample.h b/libc/isystem/__algorithm/sample.h
deleted file mode 100644
index 540d05e44..000000000
--- a/libc/isystem/__algorithm/sample.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/sample.h"
diff --git a/libc/isystem/__algorithm/search.h b/libc/isystem/__algorithm/search.h
deleted file mode 100644
index ba33010f4..000000000
--- a/libc/isystem/__algorithm/search.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/search.h"
diff --git a/libc/isystem/__algorithm/search_n.h b/libc/isystem/__algorithm/search_n.h
deleted file mode 100644
index 7e4c2e984..000000000
--- a/libc/isystem/__algorithm/search_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/search_n.h"
diff --git a/libc/isystem/__algorithm/set_difference.h b/libc/isystem/__algorithm/set_difference.h
deleted file mode 100644
index 1c171eabb..000000000
--- a/libc/isystem/__algorithm/set_difference.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/set_difference.h"
diff --git a/libc/isystem/__algorithm/set_intersection.h b/libc/isystem/__algorithm/set_intersection.h
deleted file mode 100644
index f04fd24a8..000000000
--- a/libc/isystem/__algorithm/set_intersection.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/set_intersection.h"
diff --git a/libc/isystem/__algorithm/set_symmetric_difference.h b/libc/isystem/__algorithm/set_symmetric_difference.h
deleted file mode 100644
index 8b00ca162..000000000
--- a/libc/isystem/__algorithm/set_symmetric_difference.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/set_symmetric_difference.h"
diff --git a/libc/isystem/__algorithm/set_union.h b/libc/isystem/__algorithm/set_union.h
deleted file mode 100644
index 0d6a276bc..000000000
--- a/libc/isystem/__algorithm/set_union.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/set_union.h"
diff --git a/libc/isystem/__algorithm/shift_left.h b/libc/isystem/__algorithm/shift_left.h
deleted file mode 100644
index 775fa8a60..000000000
--- a/libc/isystem/__algorithm/shift_left.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/shift_left.h"
diff --git a/libc/isystem/__algorithm/shift_right.h b/libc/isystem/__algorithm/shift_right.h
deleted file mode 100644
index ab37a39b8..000000000
--- a/libc/isystem/__algorithm/shift_right.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/shift_right.h"
diff --git a/libc/isystem/__algorithm/shuffle.h b/libc/isystem/__algorithm/shuffle.h
deleted file mode 100644
index 68818703b..000000000
--- a/libc/isystem/__algorithm/shuffle.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/shuffle.h"
diff --git a/libc/isystem/__algorithm/sift_down.h b/libc/isystem/__algorithm/sift_down.h
deleted file mode 100644
index 385e7ddf9..000000000
--- a/libc/isystem/__algorithm/sift_down.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/sift_down.h"
diff --git a/libc/isystem/__algorithm/sort.h b/libc/isystem/__algorithm/sort.h
deleted file mode 100644
index 9317e69a3..000000000
--- a/libc/isystem/__algorithm/sort.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/sort.h"
diff --git a/libc/isystem/__algorithm/sort_heap.h b/libc/isystem/__algorithm/sort_heap.h
deleted file mode 100644
index 9114e3b1d..000000000
--- a/libc/isystem/__algorithm/sort_heap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/sort_heap.h"
diff --git a/libc/isystem/__algorithm/stable_partition.h b/libc/isystem/__algorithm/stable_partition.h
deleted file mode 100644
index 68df678f4..000000000
--- a/libc/isystem/__algorithm/stable_partition.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/stable_partition.h"
diff --git a/libc/isystem/__algorithm/stable_sort.h b/libc/isystem/__algorithm/stable_sort.h
deleted file mode 100644
index 0a4f0ab4f..000000000
--- a/libc/isystem/__algorithm/stable_sort.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/stable_sort.h"
diff --git a/libc/isystem/__algorithm/swap_ranges.h b/libc/isystem/__algorithm/swap_ranges.h
deleted file mode 100644
index 2d10b25fa..000000000
--- a/libc/isystem/__algorithm/swap_ranges.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/swap_ranges.h"
diff --git a/libc/isystem/__algorithm/three_way_comp_ref_type.h b/libc/isystem/__algorithm/three_way_comp_ref_type.h
deleted file mode 100644
index e504e19c6..000000000
--- a/libc/isystem/__algorithm/three_way_comp_ref_type.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/three_way_comp_ref_type.h"
diff --git a/libc/isystem/__algorithm/transform.h b/libc/isystem/__algorithm/transform.h
deleted file mode 100644
index 60614cb88..000000000
--- a/libc/isystem/__algorithm/transform.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/transform.h"
diff --git a/libc/isystem/__algorithm/uniform_random_bit_generator_adaptor.h b/libc/isystem/__algorithm/uniform_random_bit_generator_adaptor.h
deleted file mode 100644
index f3ca28284..000000000
--- a/libc/isystem/__algorithm/uniform_random_bit_generator_adaptor.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/uniform_random_bit_generator_adaptor.h"
diff --git a/libc/isystem/__algorithm/unique.h b/libc/isystem/__algorithm/unique.h
deleted file mode 100644
index a1ef228cf..000000000
--- a/libc/isystem/__algorithm/unique.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/unique.h"
diff --git a/libc/isystem/__algorithm/unique_copy.h b/libc/isystem/__algorithm/unique_copy.h
deleted file mode 100644
index 3f8ddeb61..000000000
--- a/libc/isystem/__algorithm/unique_copy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/unique_copy.h"
diff --git a/libc/isystem/__algorithm/unwrap_iter.h b/libc/isystem/__algorithm/unwrap_iter.h
deleted file mode 100644
index 277288f9a..000000000
--- a/libc/isystem/__algorithm/unwrap_iter.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/unwrap_iter.h"
diff --git a/libc/isystem/__algorithm/unwrap_range.h b/libc/isystem/__algorithm/unwrap_range.h
deleted file mode 100644
index 9cb43bd44..000000000
--- a/libc/isystem/__algorithm/unwrap_range.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/unwrap_range.h"
diff --git a/libc/isystem/__algorithm/upper_bound.h b/libc/isystem/__algorithm/upper_bound.h
deleted file mode 100644
index c694ac61d..000000000
--- a/libc/isystem/__algorithm/upper_bound.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__algorithm/upper_bound.h"
diff --git a/libc/isystem/__assert b/libc/isystem/__assert
deleted file mode 100644
index 29532acc8..000000000
--- a/libc/isystem/__assert
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__assert"
diff --git a/libc/isystem/__atomic/aliases.h b/libc/isystem/__atomic/aliases.h
deleted file mode 100644
index 6849bcd1b..000000000
--- a/libc/isystem/__atomic/aliases.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/aliases.h"
diff --git a/libc/isystem/__atomic/atomic.h b/libc/isystem/__atomic/atomic.h
deleted file mode 100644
index b2324671e..000000000
--- a/libc/isystem/__atomic/atomic.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/atomic.h"
diff --git a/libc/isystem/__atomic/atomic_base.h b/libc/isystem/__atomic/atomic_base.h
deleted file mode 100644
index ec1733d30..000000000
--- a/libc/isystem/__atomic/atomic_base.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/atomic_base.h"
diff --git a/libc/isystem/__atomic/atomic_flag.h b/libc/isystem/__atomic/atomic_flag.h
deleted file mode 100644
index 70e1268a5..000000000
--- a/libc/isystem/__atomic/atomic_flag.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/atomic_flag.h"
diff --git a/libc/isystem/__atomic/atomic_init.h b/libc/isystem/__atomic/atomic_init.h
deleted file mode 100644
index c04e99f38..000000000
--- a/libc/isystem/__atomic/atomic_init.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/atomic_init.h"
diff --git a/libc/isystem/__atomic/atomic_lock_free.h b/libc/isystem/__atomic/atomic_lock_free.h
deleted file mode 100644
index 3a086be7f..000000000
--- a/libc/isystem/__atomic/atomic_lock_free.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/atomic_lock_free.h"
diff --git a/libc/isystem/__atomic/atomic_sync.h b/libc/isystem/__atomic/atomic_sync.h
deleted file mode 100644
index 8fb086325..000000000
--- a/libc/isystem/__atomic/atomic_sync.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/atomic_sync.h"
diff --git a/libc/isystem/__atomic/check_memory_order.h b/libc/isystem/__atomic/check_memory_order.h
deleted file mode 100644
index 71de721f7..000000000
--- a/libc/isystem/__atomic/check_memory_order.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/check_memory_order.h"
diff --git a/libc/isystem/__atomic/contention_t.h b/libc/isystem/__atomic/contention_t.h
deleted file mode 100644
index 64c180391..000000000
--- a/libc/isystem/__atomic/contention_t.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/contention_t.h"
diff --git a/libc/isystem/__atomic/cxx_atomic_impl.h b/libc/isystem/__atomic/cxx_atomic_impl.h
deleted file mode 100644
index 78aabe632..000000000
--- a/libc/isystem/__atomic/cxx_atomic_impl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/cxx_atomic_impl.h"
diff --git a/libc/isystem/__atomic/fence.h b/libc/isystem/__atomic/fence.h
deleted file mode 100644
index 183ace12e..000000000
--- a/libc/isystem/__atomic/fence.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/fence.h"
diff --git a/libc/isystem/__atomic/is_always_lock_free.h b/libc/isystem/__atomic/is_always_lock_free.h
deleted file mode 100644
index 9b6374f35..000000000
--- a/libc/isystem/__atomic/is_always_lock_free.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/is_always_lock_free.h"
diff --git a/libc/isystem/__atomic/kill_dependency.h b/libc/isystem/__atomic/kill_dependency.h
deleted file mode 100644
index 8b89ed54e..000000000
--- a/libc/isystem/__atomic/kill_dependency.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/kill_dependency.h"
diff --git a/libc/isystem/__atomic/memory_order.h b/libc/isystem/__atomic/memory_order.h
deleted file mode 100644
index d29e57fa5..000000000
--- a/libc/isystem/__atomic/memory_order.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__atomic/memory_order.h"
diff --git a/libc/isystem/__availability b/libc/isystem/__availability
deleted file mode 100644
index 479d7b7ac..000000000
--- a/libc/isystem/__availability
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__availability"
diff --git a/libc/isystem/__bit/bit_cast.h b/libc/isystem/__bit/bit_cast.h
deleted file mode 100644
index 44318231a..000000000
--- a/libc/isystem/__bit/bit_cast.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/bit_cast.h"
diff --git a/libc/isystem/__bit/bit_ceil.h b/libc/isystem/__bit/bit_ceil.h
deleted file mode 100644
index 2626419a0..000000000
--- a/libc/isystem/__bit/bit_ceil.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/bit_ceil.h"
diff --git a/libc/isystem/__bit/bit_floor.h b/libc/isystem/__bit/bit_floor.h
deleted file mode 100644
index bff96affd..000000000
--- a/libc/isystem/__bit/bit_floor.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/bit_floor.h"
diff --git a/libc/isystem/__bit/bit_log2.h b/libc/isystem/__bit/bit_log2.h
deleted file mode 100644
index 6cd2cf734..000000000
--- a/libc/isystem/__bit/bit_log2.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/bit_log2.h"
diff --git a/libc/isystem/__bit/bit_width.h b/libc/isystem/__bit/bit_width.h
deleted file mode 100644
index ca0ffe6e7..000000000
--- a/libc/isystem/__bit/bit_width.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/bit_width.h"
diff --git a/libc/isystem/__bit/blsr.h b/libc/isystem/__bit/blsr.h
deleted file mode 100644
index 785569624..000000000
--- a/libc/isystem/__bit/blsr.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/blsr.h"
diff --git a/libc/isystem/__bit/byteswap.h b/libc/isystem/__bit/byteswap.h
deleted file mode 100644
index 698990aca..000000000
--- a/libc/isystem/__bit/byteswap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/byteswap.h"
diff --git a/libc/isystem/__bit/countl.h b/libc/isystem/__bit/countl.h
deleted file mode 100644
index a1bb62153..000000000
--- a/libc/isystem/__bit/countl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/countl.h"
diff --git a/libc/isystem/__bit/countr.h b/libc/isystem/__bit/countr.h
deleted file mode 100644
index ff1b0056b..000000000
--- a/libc/isystem/__bit/countr.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/countr.h"
diff --git a/libc/isystem/__bit/endian.h b/libc/isystem/__bit/endian.h
deleted file mode 100644
index ab076f21a..000000000
--- a/libc/isystem/__bit/endian.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/endian.h"
diff --git a/libc/isystem/__bit/has_single_bit.h b/libc/isystem/__bit/has_single_bit.h
deleted file mode 100644
index 9a3f4bc10..000000000
--- a/libc/isystem/__bit/has_single_bit.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/has_single_bit.h"
diff --git a/libc/isystem/__bit/popcount.h b/libc/isystem/__bit/popcount.h
deleted file mode 100644
index b12a77a70..000000000
--- a/libc/isystem/__bit/popcount.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/popcount.h"
diff --git a/libc/isystem/__bit/rotate.h b/libc/isystem/__bit/rotate.h
deleted file mode 100644
index 20f0ec244..000000000
--- a/libc/isystem/__bit/rotate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit/rotate.h"
diff --git a/libc/isystem/__bit_reference b/libc/isystem/__bit_reference
deleted file mode 100644
index 89438011c..000000000
--- a/libc/isystem/__bit_reference
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__bit_reference"
diff --git a/libc/isystem/__charconv/chars_format.h b/libc/isystem/__charconv/chars_format.h
deleted file mode 100644
index 7e15b94c4..000000000
--- a/libc/isystem/__charconv/chars_format.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__charconv/chars_format.h"
diff --git a/libc/isystem/__charconv/from_chars_integral.h b/libc/isystem/__charconv/from_chars_integral.h
deleted file mode 100644
index 13af75de0..000000000
--- a/libc/isystem/__charconv/from_chars_integral.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__charconv/from_chars_integral.h"
diff --git a/libc/isystem/__charconv/from_chars_result.h b/libc/isystem/__charconv/from_chars_result.h
deleted file mode 100644
index c3b6d41ce..000000000
--- a/libc/isystem/__charconv/from_chars_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__charconv/from_chars_result.h"
diff --git a/libc/isystem/__charconv/tables.h b/libc/isystem/__charconv/tables.h
deleted file mode 100644
index 4abd3d125..000000000
--- a/libc/isystem/__charconv/tables.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__charconv/tables.h"
diff --git a/libc/isystem/__charconv/to_chars.h b/libc/isystem/__charconv/to_chars.h
deleted file mode 100644
index ee2ee1db2..000000000
--- a/libc/isystem/__charconv/to_chars.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__charconv/to_chars.h"
diff --git a/libc/isystem/__charconv/to_chars_base_10.h b/libc/isystem/__charconv/to_chars_base_10.h
deleted file mode 100644
index 850ffbf1f..000000000
--- a/libc/isystem/__charconv/to_chars_base_10.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__charconv/to_chars_base_10.h"
diff --git a/libc/isystem/__charconv/to_chars_floating_point.h b/libc/isystem/__charconv/to_chars_floating_point.h
deleted file mode 100644
index b88f5777b..000000000
--- a/libc/isystem/__charconv/to_chars_floating_point.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__charconv/to_chars_floating_point.h"
diff --git a/libc/isystem/__charconv/to_chars_integral.h b/libc/isystem/__charconv/to_chars_integral.h
deleted file mode 100644
index 0180d2f2f..000000000
--- a/libc/isystem/__charconv/to_chars_integral.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__charconv/to_chars_integral.h"
diff --git a/libc/isystem/__charconv/to_chars_result.h b/libc/isystem/__charconv/to_chars_result.h
deleted file mode 100644
index c6256c3d3..000000000
--- a/libc/isystem/__charconv/to_chars_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__charconv/to_chars_result.h"
diff --git a/libc/isystem/__charconv/traits.h b/libc/isystem/__charconv/traits.h
deleted file mode 100644
index e2c5ac488..000000000
--- a/libc/isystem/__charconv/traits.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__charconv/traits.h"
diff --git a/libc/isystem/__chrono/calendar.h b/libc/isystem/__chrono/calendar.h
deleted file mode 100644
index 4f83cab7b..000000000
--- a/libc/isystem/__chrono/calendar.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/calendar.h"
diff --git a/libc/isystem/__chrono/concepts.h b/libc/isystem/__chrono/concepts.h
deleted file mode 100644
index e3a11cdde..000000000
--- a/libc/isystem/__chrono/concepts.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/concepts.h"
diff --git a/libc/isystem/__chrono/convert_to_timespec.h b/libc/isystem/__chrono/convert_to_timespec.h
deleted file mode 100644
index 628d0b0a8..000000000
--- a/libc/isystem/__chrono/convert_to_timespec.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/convert_to_timespec.h"
diff --git a/libc/isystem/__chrono/convert_to_tm.h b/libc/isystem/__chrono/convert_to_tm.h
deleted file mode 100644
index f007e86fe..000000000
--- a/libc/isystem/__chrono/convert_to_tm.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/convert_to_tm.h"
diff --git a/libc/isystem/__chrono/day.h b/libc/isystem/__chrono/day.h
deleted file mode 100644
index 120234303..000000000
--- a/libc/isystem/__chrono/day.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/day.h"
diff --git a/libc/isystem/__chrono/duration.h b/libc/isystem/__chrono/duration.h
deleted file mode 100644
index c3ed6729d..000000000
--- a/libc/isystem/__chrono/duration.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/duration.h"
diff --git a/libc/isystem/__chrono/file_clock.h b/libc/isystem/__chrono/file_clock.h
deleted file mode 100644
index 95c3844f7..000000000
--- a/libc/isystem/__chrono/file_clock.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/file_clock.h"
diff --git a/libc/isystem/__chrono/formatter.h b/libc/isystem/__chrono/formatter.h
deleted file mode 100644
index fa3aadbb9..000000000
--- a/libc/isystem/__chrono/formatter.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/formatter.h"
diff --git a/libc/isystem/__chrono/hh_mm_ss.h b/libc/isystem/__chrono/hh_mm_ss.h
deleted file mode 100644
index 9ad5eb53c..000000000
--- a/libc/isystem/__chrono/hh_mm_ss.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/hh_mm_ss.h"
diff --git a/libc/isystem/__chrono/high_resolution_clock.h b/libc/isystem/__chrono/high_resolution_clock.h
deleted file mode 100644
index 154105dfa..000000000
--- a/libc/isystem/__chrono/high_resolution_clock.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/high_resolution_clock.h"
diff --git a/libc/isystem/__chrono/literals.h b/libc/isystem/__chrono/literals.h
deleted file mode 100644
index a78197f4c..000000000
--- a/libc/isystem/__chrono/literals.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/literals.h"
diff --git a/libc/isystem/__chrono/month.h b/libc/isystem/__chrono/month.h
deleted file mode 100644
index 1efb44743..000000000
--- a/libc/isystem/__chrono/month.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/month.h"
diff --git a/libc/isystem/__chrono/month_weekday.h b/libc/isystem/__chrono/month_weekday.h
deleted file mode 100644
index 4933df3c4..000000000
--- a/libc/isystem/__chrono/month_weekday.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/month_weekday.h"
diff --git a/libc/isystem/__chrono/monthday.h b/libc/isystem/__chrono/monthday.h
deleted file mode 100644
index 116a0667c..000000000
--- a/libc/isystem/__chrono/monthday.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/monthday.h"
diff --git a/libc/isystem/__chrono/ostream.h b/libc/isystem/__chrono/ostream.h
deleted file mode 100644
index 03c1d617a..000000000
--- a/libc/isystem/__chrono/ostream.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/ostream.h"
diff --git a/libc/isystem/__chrono/parser_std_format_spec.h b/libc/isystem/__chrono/parser_std_format_spec.h
deleted file mode 100644
index a1f0a7a66..000000000
--- a/libc/isystem/__chrono/parser_std_format_spec.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/parser_std_format_spec.h"
diff --git a/libc/isystem/__chrono/statically_widen.h b/libc/isystem/__chrono/statically_widen.h
deleted file mode 100644
index dc6792601..000000000
--- a/libc/isystem/__chrono/statically_widen.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/statically_widen.h"
diff --git a/libc/isystem/__chrono/steady_clock.h b/libc/isystem/__chrono/steady_clock.h
deleted file mode 100644
index 662b4ff44..000000000
--- a/libc/isystem/__chrono/steady_clock.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/steady_clock.h"
diff --git a/libc/isystem/__chrono/system_clock.h b/libc/isystem/__chrono/system_clock.h
deleted file mode 100644
index 074c1a445..000000000
--- a/libc/isystem/__chrono/system_clock.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/system_clock.h"
diff --git a/libc/isystem/__chrono/time_point.h b/libc/isystem/__chrono/time_point.h
deleted file mode 100644
index 12e91e5d0..000000000
--- a/libc/isystem/__chrono/time_point.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/time_point.h"
diff --git a/libc/isystem/__chrono/weekday.h b/libc/isystem/__chrono/weekday.h
deleted file mode 100644
index a0495b5f1..000000000
--- a/libc/isystem/__chrono/weekday.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/weekday.h"
diff --git a/libc/isystem/__chrono/year.h b/libc/isystem/__chrono/year.h
deleted file mode 100644
index 0cc26795f..000000000
--- a/libc/isystem/__chrono/year.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/year.h"
diff --git a/libc/isystem/__chrono/year_month.h b/libc/isystem/__chrono/year_month.h
deleted file mode 100644
index 017ce52d5..000000000
--- a/libc/isystem/__chrono/year_month.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/year_month.h"
diff --git a/libc/isystem/__chrono/year_month_day.h b/libc/isystem/__chrono/year_month_day.h
deleted file mode 100644
index 3dabb5381..000000000
--- a/libc/isystem/__chrono/year_month_day.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/year_month_day.h"
diff --git a/libc/isystem/__chrono/year_month_weekday.h b/libc/isystem/__chrono/year_month_weekday.h
deleted file mode 100644
index fea61c011..000000000
--- a/libc/isystem/__chrono/year_month_weekday.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__chrono/year_month_weekday.h"
diff --git a/libc/isystem/__compare/common_comparison_category.h b/libc/isystem/__compare/common_comparison_category.h
deleted file mode 100644
index de98b2a88..000000000
--- a/libc/isystem/__compare/common_comparison_category.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/common_comparison_category.h"
diff --git a/libc/isystem/__compare/compare_partial_order_fallback.h b/libc/isystem/__compare/compare_partial_order_fallback.h
deleted file mode 100644
index f3f249923..000000000
--- a/libc/isystem/__compare/compare_partial_order_fallback.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/compare_partial_order_fallback.h"
diff --git a/libc/isystem/__compare/compare_strong_order_fallback.h b/libc/isystem/__compare/compare_strong_order_fallback.h
deleted file mode 100644
index 688861e61..000000000
--- a/libc/isystem/__compare/compare_strong_order_fallback.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/compare_strong_order_fallback.h"
diff --git a/libc/isystem/__compare/compare_three_way.h b/libc/isystem/__compare/compare_three_way.h
deleted file mode 100644
index 87a359eaa..000000000
--- a/libc/isystem/__compare/compare_three_way.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/compare_three_way.h"
diff --git a/libc/isystem/__compare/compare_three_way_result.h b/libc/isystem/__compare/compare_three_way_result.h
deleted file mode 100644
index b917b6682..000000000
--- a/libc/isystem/__compare/compare_three_way_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/compare_three_way_result.h"
diff --git a/libc/isystem/__compare/compare_weak_order_fallback.h b/libc/isystem/__compare/compare_weak_order_fallback.h
deleted file mode 100644
index 9fad4a764..000000000
--- a/libc/isystem/__compare/compare_weak_order_fallback.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/compare_weak_order_fallback.h"
diff --git a/libc/isystem/__compare/is_eq.h b/libc/isystem/__compare/is_eq.h
deleted file mode 100644
index 8cc06f947..000000000
--- a/libc/isystem/__compare/is_eq.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/is_eq.h"
diff --git a/libc/isystem/__compare/ordering.h b/libc/isystem/__compare/ordering.h
deleted file mode 100644
index f3c216b03..000000000
--- a/libc/isystem/__compare/ordering.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/ordering.h"
diff --git a/libc/isystem/__compare/partial_order.h b/libc/isystem/__compare/partial_order.h
deleted file mode 100644
index a6d273736..000000000
--- a/libc/isystem/__compare/partial_order.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/partial_order.h"
diff --git a/libc/isystem/__compare/strong_order.h b/libc/isystem/__compare/strong_order.h
deleted file mode 100644
index d95c48d0d..000000000
--- a/libc/isystem/__compare/strong_order.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/strong_order.h"
diff --git a/libc/isystem/__compare/synth_three_way.h b/libc/isystem/__compare/synth_three_way.h
deleted file mode 100644
index d3ce27c29..000000000
--- a/libc/isystem/__compare/synth_three_way.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/synth_three_way.h"
diff --git a/libc/isystem/__compare/three_way_comparable.h b/libc/isystem/__compare/three_way_comparable.h
deleted file mode 100644
index 2af969ffd..000000000
--- a/libc/isystem/__compare/three_way_comparable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/three_way_comparable.h"
diff --git a/libc/isystem/__compare/weak_order.h b/libc/isystem/__compare/weak_order.h
deleted file mode 100644
index 4005b2733..000000000
--- a/libc/isystem/__compare/weak_order.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__compare/weak_order.h"
diff --git a/libc/isystem/__concepts/arithmetic.h b/libc/isystem/__concepts/arithmetic.h
deleted file mode 100644
index b7b3a862b..000000000
--- a/libc/isystem/__concepts/arithmetic.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/arithmetic.h"
diff --git a/libc/isystem/__concepts/assignable.h b/libc/isystem/__concepts/assignable.h
deleted file mode 100644
index a5ba0abc6..000000000
--- a/libc/isystem/__concepts/assignable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/assignable.h"
diff --git a/libc/isystem/__concepts/boolean_testable.h b/libc/isystem/__concepts/boolean_testable.h
deleted file mode 100644
index d2090da3e..000000000
--- a/libc/isystem/__concepts/boolean_testable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/boolean_testable.h"
diff --git a/libc/isystem/__concepts/class_or_enum.h b/libc/isystem/__concepts/class_or_enum.h
deleted file mode 100644
index 06f8b868b..000000000
--- a/libc/isystem/__concepts/class_or_enum.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/class_or_enum.h"
diff --git a/libc/isystem/__concepts/common_reference_with.h b/libc/isystem/__concepts/common_reference_with.h
deleted file mode 100644
index 3fb55b0bf..000000000
--- a/libc/isystem/__concepts/common_reference_with.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/common_reference_with.h"
diff --git a/libc/isystem/__concepts/common_with.h b/libc/isystem/__concepts/common_with.h
deleted file mode 100644
index 8312c9793..000000000
--- a/libc/isystem/__concepts/common_with.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/common_with.h"
diff --git a/libc/isystem/__concepts/constructible.h b/libc/isystem/__concepts/constructible.h
deleted file mode 100644
index bcc66912e..000000000
--- a/libc/isystem/__concepts/constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/constructible.h"
diff --git a/libc/isystem/__concepts/convertible_to.h b/libc/isystem/__concepts/convertible_to.h
deleted file mode 100644
index 28d89bcea..000000000
--- a/libc/isystem/__concepts/convertible_to.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/convertible_to.h"
diff --git a/libc/isystem/__concepts/copyable.h b/libc/isystem/__concepts/copyable.h
deleted file mode 100644
index ee9df4ce8..000000000
--- a/libc/isystem/__concepts/copyable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/copyable.h"
diff --git a/libc/isystem/__concepts/derived_from.h b/libc/isystem/__concepts/derived_from.h
deleted file mode 100644
index 4598169a0..000000000
--- a/libc/isystem/__concepts/derived_from.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/derived_from.h"
diff --git a/libc/isystem/__concepts/destructible.h b/libc/isystem/__concepts/destructible.h
deleted file mode 100644
index 7b6bd65bb..000000000
--- a/libc/isystem/__concepts/destructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/destructible.h"
diff --git a/libc/isystem/__concepts/different_from.h b/libc/isystem/__concepts/different_from.h
deleted file mode 100644
index 81c2114f3..000000000
--- a/libc/isystem/__concepts/different_from.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/different_from.h"
diff --git a/libc/isystem/__concepts/equality_comparable.h b/libc/isystem/__concepts/equality_comparable.h
deleted file mode 100644
index 6c1abeafa..000000000
--- a/libc/isystem/__concepts/equality_comparable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/equality_comparable.h"
diff --git a/libc/isystem/__concepts/invocable.h b/libc/isystem/__concepts/invocable.h
deleted file mode 100644
index e5639ff74..000000000
--- a/libc/isystem/__concepts/invocable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/invocable.h"
diff --git a/libc/isystem/__concepts/movable.h b/libc/isystem/__concepts/movable.h
deleted file mode 100644
index d3939c357..000000000
--- a/libc/isystem/__concepts/movable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/movable.h"
diff --git a/libc/isystem/__concepts/predicate.h b/libc/isystem/__concepts/predicate.h
deleted file mode 100644
index bb5145da0..000000000
--- a/libc/isystem/__concepts/predicate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/predicate.h"
diff --git a/libc/isystem/__concepts/regular.h b/libc/isystem/__concepts/regular.h
deleted file mode 100644
index 39772486a..000000000
--- a/libc/isystem/__concepts/regular.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/regular.h"
diff --git a/libc/isystem/__concepts/relation.h b/libc/isystem/__concepts/relation.h
deleted file mode 100644
index ca0f9603f..000000000
--- a/libc/isystem/__concepts/relation.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/relation.h"
diff --git a/libc/isystem/__concepts/same_as.h b/libc/isystem/__concepts/same_as.h
deleted file mode 100644
index 5aed22981..000000000
--- a/libc/isystem/__concepts/same_as.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/same_as.h"
diff --git a/libc/isystem/__concepts/semiregular.h b/libc/isystem/__concepts/semiregular.h
deleted file mode 100644
index 419b73bed..000000000
--- a/libc/isystem/__concepts/semiregular.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/semiregular.h"
diff --git a/libc/isystem/__concepts/swappable.h b/libc/isystem/__concepts/swappable.h
deleted file mode 100644
index 30f479c29..000000000
--- a/libc/isystem/__concepts/swappable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/swappable.h"
diff --git a/libc/isystem/__concepts/totally_ordered.h b/libc/isystem/__concepts/totally_ordered.h
deleted file mode 100644
index b7b4cd760..000000000
--- a/libc/isystem/__concepts/totally_ordered.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__concepts/totally_ordered.h"
diff --git a/libc/isystem/__condition_variable/condition_variable.h b/libc/isystem/__condition_variable/condition_variable.h
deleted file mode 100644
index 27d82ac00..000000000
--- a/libc/isystem/__condition_variable/condition_variable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__condition_variable/condition_variable.h"
diff --git a/libc/isystem/__config b/libc/isystem/__config
deleted file mode 100644
index e0803675d..000000000
--- a/libc/isystem/__config
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__config"
diff --git a/libc/isystem/__config_site b/libc/isystem/__config_site
deleted file mode 100644
index 281eff4b8..000000000
--- a/libc/isystem/__config_site
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__config_site"
diff --git a/libc/isystem/__coroutine/coroutine_handle.h b/libc/isystem/__coroutine/coroutine_handle.h
deleted file mode 100644
index edc585dcc..000000000
--- a/libc/isystem/__coroutine/coroutine_handle.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__coroutine/coroutine_handle.h"
diff --git a/libc/isystem/__coroutine/coroutine_traits.h b/libc/isystem/__coroutine/coroutine_traits.h
deleted file mode 100644
index bbff1ebdd..000000000
--- a/libc/isystem/__coroutine/coroutine_traits.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__coroutine/coroutine_traits.h"
diff --git a/libc/isystem/__coroutine/noop_coroutine_handle.h b/libc/isystem/__coroutine/noop_coroutine_handle.h
deleted file mode 100644
index 2f171894e..000000000
--- a/libc/isystem/__coroutine/noop_coroutine_handle.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__coroutine/noop_coroutine_handle.h"
diff --git a/libc/isystem/__coroutine/trivial_awaitables.h b/libc/isystem/__coroutine/trivial_awaitables.h
deleted file mode 100644
index 3bdd68e0e..000000000
--- a/libc/isystem/__coroutine/trivial_awaitables.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__coroutine/trivial_awaitables.h"
diff --git a/libc/isystem/__debug b/libc/isystem/__debug
deleted file mode 100644
index 04395b9bc..000000000
--- a/libc/isystem/__debug
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__debug"
diff --git a/libc/isystem/__debug_utils/randomize_range.h b/libc/isystem/__debug_utils/randomize_range.h
deleted file mode 100644
index a33bc6b98..000000000
--- a/libc/isystem/__debug_utils/randomize_range.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__debug_utils/randomize_range.h"
diff --git a/libc/isystem/__exception/exception.h b/libc/isystem/__exception/exception.h
deleted file mode 100644
index fc7c3312e..000000000
--- a/libc/isystem/__exception/exception.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__exception/exception.h"
diff --git a/libc/isystem/__exception/exception_ptr.h b/libc/isystem/__exception/exception_ptr.h
deleted file mode 100644
index 10b134614..000000000
--- a/libc/isystem/__exception/exception_ptr.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__exception/exception_ptr.h"
diff --git a/libc/isystem/__exception/nested_exception.h b/libc/isystem/__exception/nested_exception.h
deleted file mode 100644
index e5900e7b3..000000000
--- a/libc/isystem/__exception/nested_exception.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__exception/nested_exception.h"
diff --git a/libc/isystem/__exception/operations.h b/libc/isystem/__exception/operations.h
deleted file mode 100644
index 330230368..000000000
--- a/libc/isystem/__exception/operations.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__exception/operations.h"
diff --git a/libc/isystem/__exception/terminate.h b/libc/isystem/__exception/terminate.h
deleted file mode 100644
index bd9211ab7..000000000
--- a/libc/isystem/__exception/terminate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__exception/terminate.h"
diff --git a/libc/isystem/__expected/bad_expected_access.h b/libc/isystem/__expected/bad_expected_access.h
deleted file mode 100644
index 42f6c73e4..000000000
--- a/libc/isystem/__expected/bad_expected_access.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__expected/bad_expected_access.h"
diff --git a/libc/isystem/__expected/expected.h b/libc/isystem/__expected/expected.h
deleted file mode 100644
index ba78e807d..000000000
--- a/libc/isystem/__expected/expected.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__expected/expected.h"
diff --git a/libc/isystem/__expected/unexpect.h b/libc/isystem/__expected/unexpect.h
deleted file mode 100644
index 16d23ea4e..000000000
--- a/libc/isystem/__expected/unexpect.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__expected/unexpect.h"
diff --git a/libc/isystem/__expected/unexpected.h b/libc/isystem/__expected/unexpected.h
deleted file mode 100644
index 51a2d1b6a..000000000
--- a/libc/isystem/__expected/unexpected.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__expected/unexpected.h"
diff --git a/libc/isystem/__filesystem/copy_options.h b/libc/isystem/__filesystem/copy_options.h
deleted file mode 100644
index 6bb46afbf..000000000
--- a/libc/isystem/__filesystem/copy_options.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/copy_options.h"
diff --git a/libc/isystem/__filesystem/directory_entry.h b/libc/isystem/__filesystem/directory_entry.h
deleted file mode 100644
index 888c4219c..000000000
--- a/libc/isystem/__filesystem/directory_entry.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/directory_entry.h"
diff --git a/libc/isystem/__filesystem/directory_iterator.h b/libc/isystem/__filesystem/directory_iterator.h
deleted file mode 100644
index c8a3ab02e..000000000
--- a/libc/isystem/__filesystem/directory_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/directory_iterator.h"
diff --git a/libc/isystem/__filesystem/directory_options.h b/libc/isystem/__filesystem/directory_options.h
deleted file mode 100644
index c6fd6d089..000000000
--- a/libc/isystem/__filesystem/directory_options.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/directory_options.h"
diff --git a/libc/isystem/__filesystem/file_status.h b/libc/isystem/__filesystem/file_status.h
deleted file mode 100644
index 45626c212..000000000
--- a/libc/isystem/__filesystem/file_status.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/file_status.h"
diff --git a/libc/isystem/__filesystem/file_time_type.h b/libc/isystem/__filesystem/file_time_type.h
deleted file mode 100644
index 69568dbcf..000000000
--- a/libc/isystem/__filesystem/file_time_type.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/file_time_type.h"
diff --git a/libc/isystem/__filesystem/file_type.h b/libc/isystem/__filesystem/file_type.h
deleted file mode 100644
index 335a11c9e..000000000
--- a/libc/isystem/__filesystem/file_type.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/file_type.h"
diff --git a/libc/isystem/__filesystem/filesystem_error.h b/libc/isystem/__filesystem/filesystem_error.h
deleted file mode 100644
index b95126848..000000000
--- a/libc/isystem/__filesystem/filesystem_error.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/filesystem_error.h"
diff --git a/libc/isystem/__filesystem/operations.h b/libc/isystem/__filesystem/operations.h
deleted file mode 100644
index d0d79480d..000000000
--- a/libc/isystem/__filesystem/operations.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/operations.h"
diff --git a/libc/isystem/__filesystem/path.h b/libc/isystem/__filesystem/path.h
deleted file mode 100644
index c5a25621f..000000000
--- a/libc/isystem/__filesystem/path.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/path.h"
diff --git a/libc/isystem/__filesystem/path_iterator.h b/libc/isystem/__filesystem/path_iterator.h
deleted file mode 100644
index c730fd4b3..000000000
--- a/libc/isystem/__filesystem/path_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/path_iterator.h"
diff --git a/libc/isystem/__filesystem/perm_options.h b/libc/isystem/__filesystem/perm_options.h
deleted file mode 100644
index dbd32cbc7..000000000
--- a/libc/isystem/__filesystem/perm_options.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/perm_options.h"
diff --git a/libc/isystem/__filesystem/perms.h b/libc/isystem/__filesystem/perms.h
deleted file mode 100644
index b83178fc0..000000000
--- a/libc/isystem/__filesystem/perms.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/perms.h"
diff --git a/libc/isystem/__filesystem/recursive_directory_iterator.h b/libc/isystem/__filesystem/recursive_directory_iterator.h
deleted file mode 100644
index 08bf7946c..000000000
--- a/libc/isystem/__filesystem/recursive_directory_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/recursive_directory_iterator.h"
diff --git a/libc/isystem/__filesystem/space_info.h b/libc/isystem/__filesystem/space_info.h
deleted file mode 100644
index 81b17e6e7..000000000
--- a/libc/isystem/__filesystem/space_info.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/space_info.h"
diff --git a/libc/isystem/__filesystem/u8path.h b/libc/isystem/__filesystem/u8path.h
deleted file mode 100644
index fffbb8ce0..000000000
--- a/libc/isystem/__filesystem/u8path.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__filesystem/u8path.h"
diff --git a/libc/isystem/__format/buffer.h b/libc/isystem/__format/buffer.h
deleted file mode 100644
index 818c3b38e..000000000
--- a/libc/isystem/__format/buffer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/buffer.h"
diff --git a/libc/isystem/__format/concepts.h b/libc/isystem/__format/concepts.h
deleted file mode 100644
index ecb0e8480..000000000
--- a/libc/isystem/__format/concepts.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/concepts.h"
diff --git a/libc/isystem/__format/container_adaptor.h b/libc/isystem/__format/container_adaptor.h
deleted file mode 100644
index 4cd42bf05..000000000
--- a/libc/isystem/__format/container_adaptor.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/container_adaptor.h"
diff --git a/libc/isystem/__format/enable_insertable.h b/libc/isystem/__format/enable_insertable.h
deleted file mode 100644
index b10f358d7..000000000
--- a/libc/isystem/__format/enable_insertable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/enable_insertable.h"
diff --git a/libc/isystem/__format/escaped_output_table.h b/libc/isystem/__format/escaped_output_table.h
deleted file mode 100644
index 0388bfd25..000000000
--- a/libc/isystem/__format/escaped_output_table.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/escaped_output_table.h"
diff --git a/libc/isystem/__format/extended_grapheme_cluster_table.h b/libc/isystem/__format/extended_grapheme_cluster_table.h
deleted file mode 100644
index 9dcfd92a8..000000000
--- a/libc/isystem/__format/extended_grapheme_cluster_table.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/extended_grapheme_cluster_table.h"
diff --git a/libc/isystem/__format/format_arg.h b/libc/isystem/__format/format_arg.h
deleted file mode 100644
index 8e13b8af3..000000000
--- a/libc/isystem/__format/format_arg.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/format_arg.h"
diff --git a/libc/isystem/__format/format_arg_store.h b/libc/isystem/__format/format_arg_store.h
deleted file mode 100644
index 3f917bb4e..000000000
--- a/libc/isystem/__format/format_arg_store.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/format_arg_store.h"
diff --git a/libc/isystem/__format/format_args.h b/libc/isystem/__format/format_args.h
deleted file mode 100644
index 55d301edf..000000000
--- a/libc/isystem/__format/format_args.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/format_args.h"
diff --git a/libc/isystem/__format/format_context.h b/libc/isystem/__format/format_context.h
deleted file mode 100644
index b29184b2d..000000000
--- a/libc/isystem/__format/format_context.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/format_context.h"
diff --git a/libc/isystem/__format/format_error.h b/libc/isystem/__format/format_error.h
deleted file mode 100644
index 5f3f358b5..000000000
--- a/libc/isystem/__format/format_error.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/format_error.h"
diff --git a/libc/isystem/__format/format_functions.h b/libc/isystem/__format/format_functions.h
deleted file mode 100644
index 14f8df3b1..000000000
--- a/libc/isystem/__format/format_functions.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/format_functions.h"
diff --git a/libc/isystem/__format/format_fwd.h b/libc/isystem/__format/format_fwd.h
deleted file mode 100644
index 590990237..000000000
--- a/libc/isystem/__format/format_fwd.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/format_fwd.h"
diff --git a/libc/isystem/__format/format_parse_context.h b/libc/isystem/__format/format_parse_context.h
deleted file mode 100644
index c1cf595f1..000000000
--- a/libc/isystem/__format/format_parse_context.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/format_parse_context.h"
diff --git a/libc/isystem/__format/format_string.h b/libc/isystem/__format/format_string.h
deleted file mode 100644
index 427a501bd..000000000
--- a/libc/isystem/__format/format_string.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/format_string.h"
diff --git a/libc/isystem/__format/format_to_n_result.h b/libc/isystem/__format/format_to_n_result.h
deleted file mode 100644
index 099dee51a..000000000
--- a/libc/isystem/__format/format_to_n_result.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/format_to_n_result.h"
diff --git a/libc/isystem/__format/formatter.h b/libc/isystem/__format/formatter.h
deleted file mode 100644
index 740c4cc54..000000000
--- a/libc/isystem/__format/formatter.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/formatter.h"
diff --git a/libc/isystem/__format/formatter_bool.h b/libc/isystem/__format/formatter_bool.h
deleted file mode 100644
index bf532de5d..000000000
--- a/libc/isystem/__format/formatter_bool.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/formatter_bool.h"
diff --git a/libc/isystem/__format/formatter_char.h b/libc/isystem/__format/formatter_char.h
deleted file mode 100644
index 6674430b2..000000000
--- a/libc/isystem/__format/formatter_char.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/formatter_char.h"
diff --git a/libc/isystem/__format/formatter_floating_point.h b/libc/isystem/__format/formatter_floating_point.h
deleted file mode 100644
index ec3237b4d..000000000
--- a/libc/isystem/__format/formatter_floating_point.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/formatter_floating_point.h"
diff --git a/libc/isystem/__format/formatter_integer.h b/libc/isystem/__format/formatter_integer.h
deleted file mode 100644
index 5999edecd..000000000
--- a/libc/isystem/__format/formatter_integer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/formatter_integer.h"
diff --git a/libc/isystem/__format/formatter_integral.h b/libc/isystem/__format/formatter_integral.h
deleted file mode 100644
index 4564f4087..000000000
--- a/libc/isystem/__format/formatter_integral.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/formatter_integral.h"
diff --git a/libc/isystem/__format/formatter_output.h b/libc/isystem/__format/formatter_output.h
deleted file mode 100644
index 858d25ee8..000000000
--- a/libc/isystem/__format/formatter_output.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/formatter_output.h"
diff --git a/libc/isystem/__format/formatter_pointer.h b/libc/isystem/__format/formatter_pointer.h
deleted file mode 100644
index 1299e68bf..000000000
--- a/libc/isystem/__format/formatter_pointer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/formatter_pointer.h"
diff --git a/libc/isystem/__format/formatter_string.h b/libc/isystem/__format/formatter_string.h
deleted file mode 100644
index 3223ce63b..000000000
--- a/libc/isystem/__format/formatter_string.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/formatter_string.h"
diff --git a/libc/isystem/__format/formatter_tuple.h b/libc/isystem/__format/formatter_tuple.h
deleted file mode 100644
index 1cc3c466a..000000000
--- a/libc/isystem/__format/formatter_tuple.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/formatter_tuple.h"
diff --git a/libc/isystem/__format/parser_std_format_spec.h b/libc/isystem/__format/parser_std_format_spec.h
deleted file mode 100644
index e308602a4..000000000
--- a/libc/isystem/__format/parser_std_format_spec.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/parser_std_format_spec.h"
diff --git a/libc/isystem/__format/range_default_formatter.h b/libc/isystem/__format/range_default_formatter.h
deleted file mode 100644
index fd460f6f3..000000000
--- a/libc/isystem/__format/range_default_formatter.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/range_default_formatter.h"
diff --git a/libc/isystem/__format/range_formatter.h b/libc/isystem/__format/range_formatter.h
deleted file mode 100644
index c99e4af1b..000000000
--- a/libc/isystem/__format/range_formatter.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/range_formatter.h"
diff --git a/libc/isystem/__format/unicode.h b/libc/isystem/__format/unicode.h
deleted file mode 100644
index 75cfb9873..000000000
--- a/libc/isystem/__format/unicode.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/unicode.h"
diff --git a/libc/isystem/__format/width_estimation_table.h b/libc/isystem/__format/width_estimation_table.h
deleted file mode 100644
index 61e359e53..000000000
--- a/libc/isystem/__format/width_estimation_table.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__format/width_estimation_table.h"
diff --git a/libc/isystem/__functional/binary_function.h b/libc/isystem/__functional/binary_function.h
deleted file mode 100644
index dfa940f7c..000000000
--- a/libc/isystem/__functional/binary_function.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/binary_function.h"
diff --git a/libc/isystem/__functional/binary_negate.h b/libc/isystem/__functional/binary_negate.h
deleted file mode 100644
index 74b7fb637..000000000
--- a/libc/isystem/__functional/binary_negate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/binary_negate.h"
diff --git a/libc/isystem/__functional/bind.h b/libc/isystem/__functional/bind.h
deleted file mode 100644
index 495bb1111..000000000
--- a/libc/isystem/__functional/bind.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/bind.h"
diff --git a/libc/isystem/__functional/bind_back.h b/libc/isystem/__functional/bind_back.h
deleted file mode 100644
index d8b1b5704..000000000
--- a/libc/isystem/__functional/bind_back.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/bind_back.h"
diff --git a/libc/isystem/__functional/bind_front.h b/libc/isystem/__functional/bind_front.h
deleted file mode 100644
index 8581fe048..000000000
--- a/libc/isystem/__functional/bind_front.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/bind_front.h"
diff --git a/libc/isystem/__functional/binder1st.h b/libc/isystem/__functional/binder1st.h
deleted file mode 100644
index 548aa5cc6..000000000
--- a/libc/isystem/__functional/binder1st.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/binder1st.h"
diff --git a/libc/isystem/__functional/binder2nd.h b/libc/isystem/__functional/binder2nd.h
deleted file mode 100644
index f194a998d..000000000
--- a/libc/isystem/__functional/binder2nd.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/binder2nd.h"
diff --git a/libc/isystem/__functional/boyer_moore_searcher.h b/libc/isystem/__functional/boyer_moore_searcher.h
deleted file mode 100644
index 028e35e6d..000000000
--- a/libc/isystem/__functional/boyer_moore_searcher.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/boyer_moore_searcher.h"
diff --git a/libc/isystem/__functional/compose.h b/libc/isystem/__functional/compose.h
deleted file mode 100644
index e190a0a2e..000000000
--- a/libc/isystem/__functional/compose.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/compose.h"
diff --git a/libc/isystem/__functional/default_searcher.h b/libc/isystem/__functional/default_searcher.h
deleted file mode 100644
index 64ab66f8e..000000000
--- a/libc/isystem/__functional/default_searcher.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/default_searcher.h"
diff --git a/libc/isystem/__functional/function.h b/libc/isystem/__functional/function.h
deleted file mode 100644
index e70e5e883..000000000
--- a/libc/isystem/__functional/function.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/function.h"
diff --git a/libc/isystem/__functional/hash.h b/libc/isystem/__functional/hash.h
deleted file mode 100644
index 269bca2e1..000000000
--- a/libc/isystem/__functional/hash.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/hash.h"
diff --git a/libc/isystem/__functional/identity.h b/libc/isystem/__functional/identity.h
deleted file mode 100644
index 1174eb660..000000000
--- a/libc/isystem/__functional/identity.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/identity.h"
diff --git a/libc/isystem/__functional/invoke.h b/libc/isystem/__functional/invoke.h
deleted file mode 100644
index 541cfff6e..000000000
--- a/libc/isystem/__functional/invoke.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/invoke.h"
diff --git a/libc/isystem/__functional/is_transparent.h b/libc/isystem/__functional/is_transparent.h
deleted file mode 100644
index cbfdcd080..000000000
--- a/libc/isystem/__functional/is_transparent.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/is_transparent.h"
diff --git a/libc/isystem/__functional/mem_fn.h b/libc/isystem/__functional/mem_fn.h
deleted file mode 100644
index a7d6c0309..000000000
--- a/libc/isystem/__functional/mem_fn.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/mem_fn.h"
diff --git a/libc/isystem/__functional/mem_fun_ref.h b/libc/isystem/__functional/mem_fun_ref.h
deleted file mode 100644
index 49430c517..000000000
--- a/libc/isystem/__functional/mem_fun_ref.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/mem_fun_ref.h"
diff --git a/libc/isystem/__functional/not_fn.h b/libc/isystem/__functional/not_fn.h
deleted file mode 100644
index f1f98ada8..000000000
--- a/libc/isystem/__functional/not_fn.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/not_fn.h"
diff --git a/libc/isystem/__functional/operations.h b/libc/isystem/__functional/operations.h
deleted file mode 100644
index bd14a162a..000000000
--- a/libc/isystem/__functional/operations.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/operations.h"
diff --git a/libc/isystem/__functional/perfect_forward.h b/libc/isystem/__functional/perfect_forward.h
deleted file mode 100644
index 8506b8297..000000000
--- a/libc/isystem/__functional/perfect_forward.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/perfect_forward.h"
diff --git a/libc/isystem/__functional/pointer_to_binary_function.h b/libc/isystem/__functional/pointer_to_binary_function.h
deleted file mode 100644
index 648eb8c42..000000000
--- a/libc/isystem/__functional/pointer_to_binary_function.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/pointer_to_binary_function.h"
diff --git a/libc/isystem/__functional/pointer_to_unary_function.h b/libc/isystem/__functional/pointer_to_unary_function.h
deleted file mode 100644
index ef966d038..000000000
--- a/libc/isystem/__functional/pointer_to_unary_function.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/pointer_to_unary_function.h"
diff --git a/libc/isystem/__functional/ranges_operations.h b/libc/isystem/__functional/ranges_operations.h
deleted file mode 100644
index 42d5ebb19..000000000
--- a/libc/isystem/__functional/ranges_operations.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/ranges_operations.h"
diff --git a/libc/isystem/__functional/reference_wrapper.h b/libc/isystem/__functional/reference_wrapper.h
deleted file mode 100644
index 0dcebaf1d..000000000
--- a/libc/isystem/__functional/reference_wrapper.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/reference_wrapper.h"
diff --git a/libc/isystem/__functional/unary_function.h b/libc/isystem/__functional/unary_function.h
deleted file mode 100644
index 31762250a..000000000
--- a/libc/isystem/__functional/unary_function.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/unary_function.h"
diff --git a/libc/isystem/__functional/unary_negate.h b/libc/isystem/__functional/unary_negate.h
deleted file mode 100644
index b411f1d1e..000000000
--- a/libc/isystem/__functional/unary_negate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/unary_negate.h"
diff --git a/libc/isystem/__functional/weak_result_type.h b/libc/isystem/__functional/weak_result_type.h
deleted file mode 100644
index 931b520c8..000000000
--- a/libc/isystem/__functional/weak_result_type.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__functional/weak_result_type.h"
diff --git a/libc/isystem/__fwd/array.h b/libc/isystem/__fwd/array.h
deleted file mode 100644
index f35d9fa29..000000000
--- a/libc/isystem/__fwd/array.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/array.h"
diff --git a/libc/isystem/__fwd/fstream.h b/libc/isystem/__fwd/fstream.h
deleted file mode 100644
index 320157622..000000000
--- a/libc/isystem/__fwd/fstream.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/fstream.h"
diff --git a/libc/isystem/__fwd/get.h b/libc/isystem/__fwd/get.h
deleted file mode 100644
index 62f51e163..000000000
--- a/libc/isystem/__fwd/get.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/get.h"
diff --git a/libc/isystem/__fwd/hash.h b/libc/isystem/__fwd/hash.h
deleted file mode 100644
index efb447e83..000000000
--- a/libc/isystem/__fwd/hash.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/hash.h"
diff --git a/libc/isystem/__fwd/ios.h b/libc/isystem/__fwd/ios.h
deleted file mode 100644
index a121bea35..000000000
--- a/libc/isystem/__fwd/ios.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/ios.h"
diff --git a/libc/isystem/__fwd/istream.h b/libc/isystem/__fwd/istream.h
deleted file mode 100644
index f2f3a07ed..000000000
--- a/libc/isystem/__fwd/istream.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/istream.h"
diff --git a/libc/isystem/__fwd/memory_resource.h b/libc/isystem/__fwd/memory_resource.h
deleted file mode 100644
index 9c3a22885..000000000
--- a/libc/isystem/__fwd/memory_resource.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/memory_resource.h"
diff --git a/libc/isystem/__fwd/ostream.h b/libc/isystem/__fwd/ostream.h
deleted file mode 100644
index a3ed81564..000000000
--- a/libc/isystem/__fwd/ostream.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/ostream.h"
diff --git a/libc/isystem/__fwd/pair.h b/libc/isystem/__fwd/pair.h
deleted file mode 100644
index 8ae0ca4be..000000000
--- a/libc/isystem/__fwd/pair.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/pair.h"
diff --git a/libc/isystem/__fwd/span.h b/libc/isystem/__fwd/span.h
deleted file mode 100644
index bc2ac552e..000000000
--- a/libc/isystem/__fwd/span.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/span.h"
diff --git a/libc/isystem/__fwd/sstream.h b/libc/isystem/__fwd/sstream.h
deleted file mode 100644
index fccf7caa6..000000000
--- a/libc/isystem/__fwd/sstream.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/sstream.h"
diff --git a/libc/isystem/__fwd/streambuf.h b/libc/isystem/__fwd/streambuf.h
deleted file mode 100644
index cd3c6bc22..000000000
--- a/libc/isystem/__fwd/streambuf.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/streambuf.h"
diff --git a/libc/isystem/__fwd/string.h b/libc/isystem/__fwd/string.h
deleted file mode 100644
index 403ba5d2e..000000000
--- a/libc/isystem/__fwd/string.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/string.h"
diff --git a/libc/isystem/__fwd/string_view.h b/libc/isystem/__fwd/string_view.h
deleted file mode 100644
index d094372be..000000000
--- a/libc/isystem/__fwd/string_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/string_view.h"
diff --git a/libc/isystem/__fwd/subrange.h b/libc/isystem/__fwd/subrange.h
deleted file mode 100644
index baecfb3b7..000000000
--- a/libc/isystem/__fwd/subrange.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/subrange.h"
diff --git a/libc/isystem/__fwd/tuple.h b/libc/isystem/__fwd/tuple.h
deleted file mode 100644
index ba1a2d888..000000000
--- a/libc/isystem/__fwd/tuple.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__fwd/tuple.h"
diff --git a/libc/isystem/__hash_table b/libc/isystem/__hash_table
deleted file mode 100644
index 06dd032db..000000000
--- a/libc/isystem/__hash_table
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__hash_table"
diff --git a/libc/isystem/__ios/fpos.h b/libc/isystem/__ios/fpos.h
deleted file mode 100644
index 8752622fd..000000000
--- a/libc/isystem/__ios/fpos.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ios/fpos.h"
diff --git a/libc/isystem/__iterator/access.h b/libc/isystem/__iterator/access.h
deleted file mode 100644
index 42e8993ad..000000000
--- a/libc/isystem/__iterator/access.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/access.h"
diff --git a/libc/isystem/__iterator/advance.h b/libc/isystem/__iterator/advance.h
deleted file mode 100644
index b9d6ecb59..000000000
--- a/libc/isystem/__iterator/advance.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/advance.h"
diff --git a/libc/isystem/__iterator/back_insert_iterator.h b/libc/isystem/__iterator/back_insert_iterator.h
deleted file mode 100644
index 8b6ea8655..000000000
--- a/libc/isystem/__iterator/back_insert_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/back_insert_iterator.h"
diff --git a/libc/isystem/__iterator/bounded_iter.h b/libc/isystem/__iterator/bounded_iter.h
deleted file mode 100644
index 3acf996fc..000000000
--- a/libc/isystem/__iterator/bounded_iter.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/bounded_iter.h"
diff --git a/libc/isystem/__iterator/common_iterator.h b/libc/isystem/__iterator/common_iterator.h
deleted file mode 100644
index 74b1bfeda..000000000
--- a/libc/isystem/__iterator/common_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/common_iterator.h"
diff --git a/libc/isystem/__iterator/concepts.h b/libc/isystem/__iterator/concepts.h
deleted file mode 100644
index b930c317d..000000000
--- a/libc/isystem/__iterator/concepts.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/concepts.h"
diff --git a/libc/isystem/__iterator/counted_iterator.h b/libc/isystem/__iterator/counted_iterator.h
deleted file mode 100644
index e8fea8179..000000000
--- a/libc/isystem/__iterator/counted_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/counted_iterator.h"
diff --git a/libc/isystem/__iterator/data.h b/libc/isystem/__iterator/data.h
deleted file mode 100644
index 074df0122..000000000
--- a/libc/isystem/__iterator/data.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/data.h"
diff --git a/libc/isystem/__iterator/default_sentinel.h b/libc/isystem/__iterator/default_sentinel.h
deleted file mode 100644
index 35f516299..000000000
--- a/libc/isystem/__iterator/default_sentinel.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/default_sentinel.h"
diff --git a/libc/isystem/__iterator/distance.h b/libc/isystem/__iterator/distance.h
deleted file mode 100644
index 03427f348..000000000
--- a/libc/isystem/__iterator/distance.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/distance.h"
diff --git a/libc/isystem/__iterator/empty.h b/libc/isystem/__iterator/empty.h
deleted file mode 100644
index 7dff787a6..000000000
--- a/libc/isystem/__iterator/empty.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/empty.h"
diff --git a/libc/isystem/__iterator/erase_if_container.h b/libc/isystem/__iterator/erase_if_container.h
deleted file mode 100644
index 891c35d32..000000000
--- a/libc/isystem/__iterator/erase_if_container.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/erase_if_container.h"
diff --git a/libc/isystem/__iterator/front_insert_iterator.h b/libc/isystem/__iterator/front_insert_iterator.h
deleted file mode 100644
index 803fa7c19..000000000
--- a/libc/isystem/__iterator/front_insert_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/front_insert_iterator.h"
diff --git a/libc/isystem/__iterator/incrementable_traits.h b/libc/isystem/__iterator/incrementable_traits.h
deleted file mode 100644
index 016a7429d..000000000
--- a/libc/isystem/__iterator/incrementable_traits.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/incrementable_traits.h"
diff --git a/libc/isystem/__iterator/indirectly_comparable.h b/libc/isystem/__iterator/indirectly_comparable.h
deleted file mode 100644
index e8dd61611..000000000
--- a/libc/isystem/__iterator/indirectly_comparable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/indirectly_comparable.h"
diff --git a/libc/isystem/__iterator/insert_iterator.h b/libc/isystem/__iterator/insert_iterator.h
deleted file mode 100644
index d7d51d5a2..000000000
--- a/libc/isystem/__iterator/insert_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/insert_iterator.h"
diff --git a/libc/isystem/__iterator/istream_iterator.h b/libc/isystem/__iterator/istream_iterator.h
deleted file mode 100644
index c4dca4cf7..000000000
--- a/libc/isystem/__iterator/istream_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/istream_iterator.h"
diff --git a/libc/isystem/__iterator/istreambuf_iterator.h b/libc/isystem/__iterator/istreambuf_iterator.h
deleted file mode 100644
index e1c6f5c0c..000000000
--- a/libc/isystem/__iterator/istreambuf_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/istreambuf_iterator.h"
diff --git a/libc/isystem/__iterator/iter_move.h b/libc/isystem/__iterator/iter_move.h
deleted file mode 100644
index d6ec40c76..000000000
--- a/libc/isystem/__iterator/iter_move.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/iter_move.h"
diff --git a/libc/isystem/__iterator/iter_swap.h b/libc/isystem/__iterator/iter_swap.h
deleted file mode 100644
index d417d7b99..000000000
--- a/libc/isystem/__iterator/iter_swap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/iter_swap.h"
diff --git a/libc/isystem/__iterator/iterator.h b/libc/isystem/__iterator/iterator.h
deleted file mode 100644
index e25632aaa..000000000
--- a/libc/isystem/__iterator/iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/iterator.h"
diff --git a/libc/isystem/__iterator/iterator_traits.h b/libc/isystem/__iterator/iterator_traits.h
deleted file mode 100644
index 74329d233..000000000
--- a/libc/isystem/__iterator/iterator_traits.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/iterator_traits.h"
diff --git a/libc/isystem/__iterator/iterator_with_data.h b/libc/isystem/__iterator/iterator_with_data.h
deleted file mode 100644
index a13a042d6..000000000
--- a/libc/isystem/__iterator/iterator_with_data.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/iterator_with_data.h"
diff --git a/libc/isystem/__iterator/mergeable.h b/libc/isystem/__iterator/mergeable.h
deleted file mode 100644
index 9c05a7ec7..000000000
--- a/libc/isystem/__iterator/mergeable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/mergeable.h"
diff --git a/libc/isystem/__iterator/move_iterator.h b/libc/isystem/__iterator/move_iterator.h
deleted file mode 100644
index 93556c2c4..000000000
--- a/libc/isystem/__iterator/move_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/move_iterator.h"
diff --git a/libc/isystem/__iterator/move_sentinel.h b/libc/isystem/__iterator/move_sentinel.h
deleted file mode 100644
index d92a398a2..000000000
--- a/libc/isystem/__iterator/move_sentinel.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/move_sentinel.h"
diff --git a/libc/isystem/__iterator/next.h b/libc/isystem/__iterator/next.h
deleted file mode 100644
index b7083bb64..000000000
--- a/libc/isystem/__iterator/next.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/next.h"
diff --git a/libc/isystem/__iterator/ostream_iterator.h b/libc/isystem/__iterator/ostream_iterator.h
deleted file mode 100644
index 11cf36d9a..000000000
--- a/libc/isystem/__iterator/ostream_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/ostream_iterator.h"
diff --git a/libc/isystem/__iterator/ostreambuf_iterator.h b/libc/isystem/__iterator/ostreambuf_iterator.h
deleted file mode 100644
index d8e15b6b8..000000000
--- a/libc/isystem/__iterator/ostreambuf_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/ostreambuf_iterator.h"
diff --git a/libc/isystem/__iterator/permutable.h b/libc/isystem/__iterator/permutable.h
deleted file mode 100644
index e09e8078b..000000000
--- a/libc/isystem/__iterator/permutable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/permutable.h"
diff --git a/libc/isystem/__iterator/prev.h b/libc/isystem/__iterator/prev.h
deleted file mode 100644
index 5b540a33a..000000000
--- a/libc/isystem/__iterator/prev.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/prev.h"
diff --git a/libc/isystem/__iterator/projected.h b/libc/isystem/__iterator/projected.h
deleted file mode 100644
index 8014a4a53..000000000
--- a/libc/isystem/__iterator/projected.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/projected.h"
diff --git a/libc/isystem/__iterator/readable_traits.h b/libc/isystem/__iterator/readable_traits.h
deleted file mode 100644
index 01e249bd7..000000000
--- a/libc/isystem/__iterator/readable_traits.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/readable_traits.h"
diff --git a/libc/isystem/__iterator/reverse_access.h b/libc/isystem/__iterator/reverse_access.h
deleted file mode 100644
index 6b46073f1..000000000
--- a/libc/isystem/__iterator/reverse_access.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/reverse_access.h"
diff --git a/libc/isystem/__iterator/reverse_iterator.h b/libc/isystem/__iterator/reverse_iterator.h
deleted file mode 100644
index 261ca8fe4..000000000
--- a/libc/isystem/__iterator/reverse_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/reverse_iterator.h"
diff --git a/libc/isystem/__iterator/segmented_iterator.h b/libc/isystem/__iterator/segmented_iterator.h
deleted file mode 100644
index 083dc0e6c..000000000
--- a/libc/isystem/__iterator/segmented_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/segmented_iterator.h"
diff --git a/libc/isystem/__iterator/size.h b/libc/isystem/__iterator/size.h
deleted file mode 100644
index fd8f8ea22..000000000
--- a/libc/isystem/__iterator/size.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/size.h"
diff --git a/libc/isystem/__iterator/sortable.h b/libc/isystem/__iterator/sortable.h
deleted file mode 100644
index aa714d95a..000000000
--- a/libc/isystem/__iterator/sortable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/sortable.h"
diff --git a/libc/isystem/__iterator/unreachable_sentinel.h b/libc/isystem/__iterator/unreachable_sentinel.h
deleted file mode 100644
index 100669d16..000000000
--- a/libc/isystem/__iterator/unreachable_sentinel.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/unreachable_sentinel.h"
diff --git a/libc/isystem/__iterator/wrap_iter.h b/libc/isystem/__iterator/wrap_iter.h
deleted file mode 100644
index f9f9e17a8..000000000
--- a/libc/isystem/__iterator/wrap_iter.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__iterator/wrap_iter.h"
diff --git a/libc/isystem/__locale b/libc/isystem/__locale
deleted file mode 100644
index 430f7d277..000000000
--- a/libc/isystem/__locale
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__locale"
diff --git a/libc/isystem/__locale_dir/locale_base_api/bsd_locale_defaults.h b/libc/isystem/__locale_dir/locale_base_api/bsd_locale_defaults.h
deleted file mode 100644
index 9616b1307..000000000
--- a/libc/isystem/__locale_dir/locale_base_api/bsd_locale_defaults.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_defaults.h"
diff --git a/libc/isystem/__locale_dir/locale_base_api/bsd_locale_fallbacks.h b/libc/isystem/__locale_dir/locale_base_api/bsd_locale_fallbacks.h
deleted file mode 100644
index aefdb8f3c..000000000
--- a/libc/isystem/__locale_dir/locale_base_api/bsd_locale_fallbacks.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_fallbacks.h"
diff --git a/libc/isystem/__locale_dir/locale_base_api/locale_guard.h b/libc/isystem/__locale_dir/locale_base_api/locale_guard.h
deleted file mode 100644
index 9c1a10090..000000000
--- a/libc/isystem/__locale_dir/locale_base_api/locale_guard.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__locale_dir/locale_base_api/locale_guard.h"
diff --git a/libc/isystem/__mbstate_t.h b/libc/isystem/__mbstate_t.h
deleted file mode 100644
index ce032b9ae..000000000
--- a/libc/isystem/__mbstate_t.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__mbstate_t.h"
diff --git a/libc/isystem/__mdspan/extents.h b/libc/isystem/__mdspan/extents.h
deleted file mode 100644
index d4060eeb0..000000000
--- a/libc/isystem/__mdspan/extents.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__mdspan/extents.h"
diff --git a/libc/isystem/__memory/addressof.h b/libc/isystem/__memory/addressof.h
deleted file mode 100644
index 74479acbc..000000000
--- a/libc/isystem/__memory/addressof.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/addressof.h"
diff --git a/libc/isystem/__memory/align.h b/libc/isystem/__memory/align.h
deleted file mode 100644
index dac036328..000000000
--- a/libc/isystem/__memory/align.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/align.h"
diff --git a/libc/isystem/__memory/aligned_alloc.h b/libc/isystem/__memory/aligned_alloc.h
deleted file mode 100644
index 8f5c4a6ca..000000000
--- a/libc/isystem/__memory/aligned_alloc.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/aligned_alloc.h"
diff --git a/libc/isystem/__memory/allocate_at_least.h b/libc/isystem/__memory/allocate_at_least.h
deleted file mode 100644
index b8806999b..000000000
--- a/libc/isystem/__memory/allocate_at_least.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/allocate_at_least.h"
diff --git a/libc/isystem/__memory/allocation_guard.h b/libc/isystem/__memory/allocation_guard.h
deleted file mode 100644
index a7f3f3020..000000000
--- a/libc/isystem/__memory/allocation_guard.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/allocation_guard.h"
diff --git a/libc/isystem/__memory/allocator.h b/libc/isystem/__memory/allocator.h
deleted file mode 100644
index 4460c2cfe..000000000
--- a/libc/isystem/__memory/allocator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/allocator.h"
diff --git a/libc/isystem/__memory/allocator_arg_t.h b/libc/isystem/__memory/allocator_arg_t.h
deleted file mode 100644
index 8606655c2..000000000
--- a/libc/isystem/__memory/allocator_arg_t.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/allocator_arg_t.h"
diff --git a/libc/isystem/__memory/allocator_destructor.h b/libc/isystem/__memory/allocator_destructor.h
deleted file mode 100644
index 9922a6ad2..000000000
--- a/libc/isystem/__memory/allocator_destructor.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/allocator_destructor.h"
diff --git a/libc/isystem/__memory/allocator_traits.h b/libc/isystem/__memory/allocator_traits.h
deleted file mode 100644
index 7c0ef7fe0..000000000
--- a/libc/isystem/__memory/allocator_traits.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/allocator_traits.h"
diff --git a/libc/isystem/__memory/assume_aligned.h b/libc/isystem/__memory/assume_aligned.h
deleted file mode 100644
index 816f2a513..000000000
--- a/libc/isystem/__memory/assume_aligned.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/assume_aligned.h"
diff --git a/libc/isystem/__memory/auto_ptr.h b/libc/isystem/__memory/auto_ptr.h
deleted file mode 100644
index 31694389a..000000000
--- a/libc/isystem/__memory/auto_ptr.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/auto_ptr.h"
diff --git a/libc/isystem/__memory/builtin_new_allocator.h b/libc/isystem/__memory/builtin_new_allocator.h
deleted file mode 100644
index f23c8a06e..000000000
--- a/libc/isystem/__memory/builtin_new_allocator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/builtin_new_allocator.h"
diff --git a/libc/isystem/__memory/compressed_pair.h b/libc/isystem/__memory/compressed_pair.h
deleted file mode 100644
index 2ce22d3af..000000000
--- a/libc/isystem/__memory/compressed_pair.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/compressed_pair.h"
diff --git a/libc/isystem/__memory/concepts.h b/libc/isystem/__memory/concepts.h
deleted file mode 100644
index 3e8e04d19..000000000
--- a/libc/isystem/__memory/concepts.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/concepts.h"
diff --git a/libc/isystem/__memory/construct_at.h b/libc/isystem/__memory/construct_at.h
deleted file mode 100644
index 612ad40b0..000000000
--- a/libc/isystem/__memory/construct_at.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/construct_at.h"
diff --git a/libc/isystem/__memory/destruct_n.h b/libc/isystem/__memory/destruct_n.h
deleted file mode 100644
index ce33b80cf..000000000
--- a/libc/isystem/__memory/destruct_n.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/destruct_n.h"
diff --git a/libc/isystem/__memory/pointer_traits.h b/libc/isystem/__memory/pointer_traits.h
deleted file mode 100644
index 9f3e55118..000000000
--- a/libc/isystem/__memory/pointer_traits.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/pointer_traits.h"
diff --git a/libc/isystem/__memory/ranges_construct_at.h b/libc/isystem/__memory/ranges_construct_at.h
deleted file mode 100644
index 5facc37fe..000000000
--- a/libc/isystem/__memory/ranges_construct_at.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/ranges_construct_at.h"
diff --git a/libc/isystem/__memory/ranges_uninitialized_algorithms.h b/libc/isystem/__memory/ranges_uninitialized_algorithms.h
deleted file mode 100644
index 0cebbbb26..000000000
--- a/libc/isystem/__memory/ranges_uninitialized_algorithms.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/ranges_uninitialized_algorithms.h"
diff --git a/libc/isystem/__memory/raw_storage_iterator.h b/libc/isystem/__memory/raw_storage_iterator.h
deleted file mode 100644
index c08589f0a..000000000
--- a/libc/isystem/__memory/raw_storage_iterator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/raw_storage_iterator.h"
diff --git a/libc/isystem/__memory/shared_ptr.h b/libc/isystem/__memory/shared_ptr.h
deleted file mode 100644
index 0ef2be9a7..000000000
--- a/libc/isystem/__memory/shared_ptr.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/shared_ptr.h"
diff --git a/libc/isystem/__memory/swap_allocator.h b/libc/isystem/__memory/swap_allocator.h
deleted file mode 100644
index 926309208..000000000
--- a/libc/isystem/__memory/swap_allocator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/swap_allocator.h"
diff --git a/libc/isystem/__memory/temp_value.h b/libc/isystem/__memory/temp_value.h
deleted file mode 100644
index 3443ff2ce..000000000
--- a/libc/isystem/__memory/temp_value.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/temp_value.h"
diff --git a/libc/isystem/__memory/temporary_buffer.h b/libc/isystem/__memory/temporary_buffer.h
deleted file mode 100644
index 8e3d01430..000000000
--- a/libc/isystem/__memory/temporary_buffer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/temporary_buffer.h"
diff --git a/libc/isystem/__memory/uninitialized_algorithms.h b/libc/isystem/__memory/uninitialized_algorithms.h
deleted file mode 100644
index ace3ba3b4..000000000
--- a/libc/isystem/__memory/uninitialized_algorithms.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/uninitialized_algorithms.h"
diff --git a/libc/isystem/__memory/unique_ptr.h b/libc/isystem/__memory/unique_ptr.h
deleted file mode 100644
index a2c62bf6e..000000000
--- a/libc/isystem/__memory/unique_ptr.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/unique_ptr.h"
diff --git a/libc/isystem/__memory/uses_allocator.h b/libc/isystem/__memory/uses_allocator.h
deleted file mode 100644
index fe24b8572..000000000
--- a/libc/isystem/__memory/uses_allocator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/uses_allocator.h"
diff --git a/libc/isystem/__memory/uses_allocator_construction.h b/libc/isystem/__memory/uses_allocator_construction.h
deleted file mode 100644
index 52e3a3be8..000000000
--- a/libc/isystem/__memory/uses_allocator_construction.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/uses_allocator_construction.h"
diff --git a/libc/isystem/__memory/voidify.h b/libc/isystem/__memory/voidify.h
deleted file mode 100644
index 5c7ebde6a..000000000
--- a/libc/isystem/__memory/voidify.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory/voidify.h"
diff --git a/libc/isystem/__memory_resource/memory_resource.h b/libc/isystem/__memory_resource/memory_resource.h
deleted file mode 100644
index b99854ba2..000000000
--- a/libc/isystem/__memory_resource/memory_resource.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory_resource/memory_resource.h"
diff --git a/libc/isystem/__memory_resource/monotonic_buffer_resource.h b/libc/isystem/__memory_resource/monotonic_buffer_resource.h
deleted file mode 100644
index 86a7afce1..000000000
--- a/libc/isystem/__memory_resource/monotonic_buffer_resource.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory_resource/monotonic_buffer_resource.h"
diff --git a/libc/isystem/__memory_resource/polymorphic_allocator.h b/libc/isystem/__memory_resource/polymorphic_allocator.h
deleted file mode 100644
index 75cb9ffc0..000000000
--- a/libc/isystem/__memory_resource/polymorphic_allocator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory_resource/polymorphic_allocator.h"
diff --git a/libc/isystem/__memory_resource/pool_options.h b/libc/isystem/__memory_resource/pool_options.h
deleted file mode 100644
index 932881687..000000000
--- a/libc/isystem/__memory_resource/pool_options.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory_resource/pool_options.h"
diff --git a/libc/isystem/__memory_resource/synchronized_pool_resource.h b/libc/isystem/__memory_resource/synchronized_pool_resource.h
deleted file mode 100644
index d65c0ee3d..000000000
--- a/libc/isystem/__memory_resource/synchronized_pool_resource.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory_resource/synchronized_pool_resource.h"
diff --git a/libc/isystem/__memory_resource/unsynchronized_pool_resource.h b/libc/isystem/__memory_resource/unsynchronized_pool_resource.h
deleted file mode 100644
index 70a08c647..000000000
--- a/libc/isystem/__memory_resource/unsynchronized_pool_resource.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__memory_resource/unsynchronized_pool_resource.h"
diff --git a/libc/isystem/__mutex/lock_guard.h b/libc/isystem/__mutex/lock_guard.h
deleted file mode 100644
index 2f16fdf99..000000000
--- a/libc/isystem/__mutex/lock_guard.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__mutex/lock_guard.h"
diff --git a/libc/isystem/__mutex/mutex.h b/libc/isystem/__mutex/mutex.h
deleted file mode 100644
index 2cfbd07d0..000000000
--- a/libc/isystem/__mutex/mutex.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__mutex/mutex.h"
diff --git a/libc/isystem/__mutex/tag_types.h b/libc/isystem/__mutex/tag_types.h
deleted file mode 100644
index ab92992ab..000000000
--- a/libc/isystem/__mutex/tag_types.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__mutex/tag_types.h"
diff --git a/libc/isystem/__mutex/unique_lock.h b/libc/isystem/__mutex/unique_lock.h
deleted file mode 100644
index beddbbc34..000000000
--- a/libc/isystem/__mutex/unique_lock.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__mutex/unique_lock.h"
diff --git a/libc/isystem/__node_handle b/libc/isystem/__node_handle
deleted file mode 100644
index 46fb2a977..000000000
--- a/libc/isystem/__node_handle
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__node_handle"
diff --git a/libc/isystem/__numeric/accumulate.h b/libc/isystem/__numeric/accumulate.h
deleted file mode 100644
index c6b2b5d7b..000000000
--- a/libc/isystem/__numeric/accumulate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/accumulate.h"
diff --git a/libc/isystem/__numeric/adjacent_difference.h b/libc/isystem/__numeric/adjacent_difference.h
deleted file mode 100644
index 15f6adefa..000000000
--- a/libc/isystem/__numeric/adjacent_difference.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/adjacent_difference.h"
diff --git a/libc/isystem/__numeric/exclusive_scan.h b/libc/isystem/__numeric/exclusive_scan.h
deleted file mode 100644
index 3c9ac4039..000000000
--- a/libc/isystem/__numeric/exclusive_scan.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/exclusive_scan.h"
diff --git a/libc/isystem/__numeric/gcd_lcm.h b/libc/isystem/__numeric/gcd_lcm.h
deleted file mode 100644
index da21251ac..000000000
--- a/libc/isystem/__numeric/gcd_lcm.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/gcd_lcm.h"
diff --git a/libc/isystem/__numeric/inclusive_scan.h b/libc/isystem/__numeric/inclusive_scan.h
deleted file mode 100644
index 760af62db..000000000
--- a/libc/isystem/__numeric/inclusive_scan.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/inclusive_scan.h"
diff --git a/libc/isystem/__numeric/inner_product.h b/libc/isystem/__numeric/inner_product.h
deleted file mode 100644
index 50ff22838..000000000
--- a/libc/isystem/__numeric/inner_product.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/inner_product.h"
diff --git a/libc/isystem/__numeric/iota.h b/libc/isystem/__numeric/iota.h
deleted file mode 100644
index 7e790b8c3..000000000
--- a/libc/isystem/__numeric/iota.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/iota.h"
diff --git a/libc/isystem/__numeric/midpoint.h b/libc/isystem/__numeric/midpoint.h
deleted file mode 100644
index 82b5eba42..000000000
--- a/libc/isystem/__numeric/midpoint.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/midpoint.h"
diff --git a/libc/isystem/__numeric/partial_sum.h b/libc/isystem/__numeric/partial_sum.h
deleted file mode 100644
index cab9525da..000000000
--- a/libc/isystem/__numeric/partial_sum.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/partial_sum.h"
diff --git a/libc/isystem/__numeric/reduce.h b/libc/isystem/__numeric/reduce.h
deleted file mode 100644
index 15f0d16d8..000000000
--- a/libc/isystem/__numeric/reduce.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/reduce.h"
diff --git a/libc/isystem/__numeric/transform_exclusive_scan.h b/libc/isystem/__numeric/transform_exclusive_scan.h
deleted file mode 100644
index e21a234b5..000000000
--- a/libc/isystem/__numeric/transform_exclusive_scan.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/transform_exclusive_scan.h"
diff --git a/libc/isystem/__numeric/transform_inclusive_scan.h b/libc/isystem/__numeric/transform_inclusive_scan.h
deleted file mode 100644
index df792c263..000000000
--- a/libc/isystem/__numeric/transform_inclusive_scan.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/transform_inclusive_scan.h"
diff --git a/libc/isystem/__numeric/transform_reduce.h b/libc/isystem/__numeric/transform_reduce.h
deleted file mode 100644
index 60857126d..000000000
--- a/libc/isystem/__numeric/transform_reduce.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__numeric/transform_reduce.h"
diff --git a/libc/isystem/__pstl/internal/algorithm_fwd.h b/libc/isystem/__pstl/internal/algorithm_fwd.h
deleted file mode 100644
index 0ec6c87f2..000000000
--- a/libc/isystem/__pstl/internal/algorithm_fwd.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/algorithm_fwd.h"
diff --git a/libc/isystem/__pstl/internal/algorithm_impl.h b/libc/isystem/__pstl/internal/algorithm_impl.h
deleted file mode 100644
index 8b95f0d63..000000000
--- a/libc/isystem/__pstl/internal/algorithm_impl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/algorithm_impl.h"
diff --git a/libc/isystem/__pstl/internal/execution_defs.h b/libc/isystem/__pstl/internal/execution_defs.h
deleted file mode 100644
index 25e27ab00..000000000
--- a/libc/isystem/__pstl/internal/execution_defs.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/execution_defs.h"
diff --git a/libc/isystem/__pstl/internal/execution_impl.h b/libc/isystem/__pstl/internal/execution_impl.h
deleted file mode 100644
index 3517735c2..000000000
--- a/libc/isystem/__pstl/internal/execution_impl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/execution_impl.h"
diff --git a/libc/isystem/__pstl/internal/glue_algorithm_defs.h b/libc/isystem/__pstl/internal/glue_algorithm_defs.h
deleted file mode 100644
index 404b11ea9..000000000
--- a/libc/isystem/__pstl/internal/glue_algorithm_defs.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/glue_algorithm_defs.h"
diff --git a/libc/isystem/__pstl/internal/glue_algorithm_impl.h b/libc/isystem/__pstl/internal/glue_algorithm_impl.h
deleted file mode 100644
index 6ba6ab16d..000000000
--- a/libc/isystem/__pstl/internal/glue_algorithm_impl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/glue_algorithm_impl.h"
diff --git a/libc/isystem/__pstl/internal/glue_memory_defs.h b/libc/isystem/__pstl/internal/glue_memory_defs.h
deleted file mode 100644
index 3dd439cf8..000000000
--- a/libc/isystem/__pstl/internal/glue_memory_defs.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/glue_memory_defs.h"
diff --git a/libc/isystem/__pstl/internal/glue_memory_impl.h b/libc/isystem/__pstl/internal/glue_memory_impl.h
deleted file mode 100644
index 6542bd695..000000000
--- a/libc/isystem/__pstl/internal/glue_memory_impl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/glue_memory_impl.h"
diff --git a/libc/isystem/__pstl/internal/glue_numeric_defs.h b/libc/isystem/__pstl/internal/glue_numeric_defs.h
deleted file mode 100644
index f7b8b77e6..000000000
--- a/libc/isystem/__pstl/internal/glue_numeric_defs.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/glue_numeric_defs.h"
diff --git a/libc/isystem/__pstl/internal/glue_numeric_impl.h b/libc/isystem/__pstl/internal/glue_numeric_impl.h
deleted file mode 100644
index f04d6c080..000000000
--- a/libc/isystem/__pstl/internal/glue_numeric_impl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/glue_numeric_impl.h"
diff --git a/libc/isystem/__pstl/internal/memory_impl.h b/libc/isystem/__pstl/internal/memory_impl.h
deleted file mode 100644
index d98f079b2..000000000
--- a/libc/isystem/__pstl/internal/memory_impl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/memory_impl.h"
diff --git a/libc/isystem/__pstl/internal/numeric_fwd.h b/libc/isystem/__pstl/internal/numeric_fwd.h
deleted file mode 100644
index 2a973e3a6..000000000
--- a/libc/isystem/__pstl/internal/numeric_fwd.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/numeric_fwd.h"
diff --git a/libc/isystem/__pstl/internal/numeric_impl.h b/libc/isystem/__pstl/internal/numeric_impl.h
deleted file mode 100644
index a88a76d2e..000000000
--- a/libc/isystem/__pstl/internal/numeric_impl.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/numeric_impl.h"
diff --git a/libc/isystem/__pstl/internal/omp/parallel_for.h b/libc/isystem/__pstl/internal/omp/parallel_for.h
deleted file mode 100644
index bbce2cda6..000000000
--- a/libc/isystem/__pstl/internal/omp/parallel_for.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/parallel_for.h"
diff --git a/libc/isystem/__pstl/internal/omp/parallel_for_each.h b/libc/isystem/__pstl/internal/omp/parallel_for_each.h
deleted file mode 100644
index 4d09b34a7..000000000
--- a/libc/isystem/__pstl/internal/omp/parallel_for_each.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/parallel_for_each.h"
diff --git a/libc/isystem/__pstl/internal/omp/parallel_invoke.h b/libc/isystem/__pstl/internal/omp/parallel_invoke.h
deleted file mode 100644
index 11448e477..000000000
--- a/libc/isystem/__pstl/internal/omp/parallel_invoke.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/parallel_invoke.h"
diff --git a/libc/isystem/__pstl/internal/omp/parallel_merge.h b/libc/isystem/__pstl/internal/omp/parallel_merge.h
deleted file mode 100644
index 1d33dc8b7..000000000
--- a/libc/isystem/__pstl/internal/omp/parallel_merge.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/parallel_merge.h"
diff --git a/libc/isystem/__pstl/internal/omp/parallel_reduce.h b/libc/isystem/__pstl/internal/omp/parallel_reduce.h
deleted file mode 100644
index 06a5ca107..000000000
--- a/libc/isystem/__pstl/internal/omp/parallel_reduce.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/parallel_reduce.h"
diff --git a/libc/isystem/__pstl/internal/omp/parallel_scan.h b/libc/isystem/__pstl/internal/omp/parallel_scan.h
deleted file mode 100644
index e7a1ee8d0..000000000
--- a/libc/isystem/__pstl/internal/omp/parallel_scan.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/parallel_scan.h"
diff --git a/libc/isystem/__pstl/internal/omp/parallel_stable_partial_sort.h b/libc/isystem/__pstl/internal/omp/parallel_stable_partial_sort.h
deleted file mode 100644
index 57386b22e..000000000
--- a/libc/isystem/__pstl/internal/omp/parallel_stable_partial_sort.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/parallel_stable_partial_sort.h"
diff --git a/libc/isystem/__pstl/internal/omp/parallel_stable_sort.h b/libc/isystem/__pstl/internal/omp/parallel_stable_sort.h
deleted file mode 100644
index c8d84edbe..000000000
--- a/libc/isystem/__pstl/internal/omp/parallel_stable_sort.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/parallel_stable_sort.h"
diff --git a/libc/isystem/__pstl/internal/omp/parallel_transform_reduce.h b/libc/isystem/__pstl/internal/omp/parallel_transform_reduce.h
deleted file mode 100644
index 089e909b5..000000000
--- a/libc/isystem/__pstl/internal/omp/parallel_transform_reduce.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/parallel_transform_reduce.h"
diff --git a/libc/isystem/__pstl/internal/omp/parallel_transform_scan.h b/libc/isystem/__pstl/internal/omp/parallel_transform_scan.h
deleted file mode 100644
index 627c15f1a..000000000
--- a/libc/isystem/__pstl/internal/omp/parallel_transform_scan.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/parallel_transform_scan.h"
diff --git a/libc/isystem/__pstl/internal/omp/util.h b/libc/isystem/__pstl/internal/omp/util.h
deleted file mode 100644
index bd8355cf4..000000000
--- a/libc/isystem/__pstl/internal/omp/util.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/omp/util.h"
diff --git a/libc/isystem/__pstl/internal/parallel_backend.h b/libc/isystem/__pstl/internal/parallel_backend.h
deleted file mode 100644
index 3231344c5..000000000
--- a/libc/isystem/__pstl/internal/parallel_backend.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/parallel_backend.h"
diff --git a/libc/isystem/__pstl/internal/parallel_backend_omp.h b/libc/isystem/__pstl/internal/parallel_backend_omp.h
deleted file mode 100644
index b5abe31ae..000000000
--- a/libc/isystem/__pstl/internal/parallel_backend_omp.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/parallel_backend_omp.h"
diff --git a/libc/isystem/__pstl/internal/parallel_backend_serial.h b/libc/isystem/__pstl/internal/parallel_backend_serial.h
deleted file mode 100644
index 044d2de57..000000000
--- a/libc/isystem/__pstl/internal/parallel_backend_serial.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/parallel_backend_serial.h"
diff --git a/libc/isystem/__pstl/internal/parallel_backend_tbb.h b/libc/isystem/__pstl/internal/parallel_backend_tbb.h
deleted file mode 100644
index c9310efc5..000000000
--- a/libc/isystem/__pstl/internal/parallel_backend_tbb.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/parallel_backend_tbb.h"
diff --git a/libc/isystem/__pstl/internal/parallel_backend_utils.h b/libc/isystem/__pstl/internal/parallel_backend_utils.h
deleted file mode 100644
index 89f833757..000000000
--- a/libc/isystem/__pstl/internal/parallel_backend_utils.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/parallel_backend_utils.h"
diff --git a/libc/isystem/__pstl/internal/unseq_backend_simd.h b/libc/isystem/__pstl/internal/unseq_backend_simd.h
deleted file mode 100644
index ae6d5645c..000000000
--- a/libc/isystem/__pstl/internal/unseq_backend_simd.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/unseq_backend_simd.h"
diff --git a/libc/isystem/__pstl/internal/utils.h b/libc/isystem/__pstl/internal/utils.h
deleted file mode 100644
index 36bf3054d..000000000
--- a/libc/isystem/__pstl/internal/utils.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl/internal/utils.h"
diff --git a/libc/isystem/__pstl_algorithm b/libc/isystem/__pstl_algorithm
deleted file mode 100644
index 8a0d459be..000000000
--- a/libc/isystem/__pstl_algorithm
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl_algorithm"
diff --git a/libc/isystem/__pstl_config_site b/libc/isystem/__pstl_config_site
deleted file mode 100644
index 492945c9d..000000000
--- a/libc/isystem/__pstl_config_site
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl_config_site"
diff --git a/libc/isystem/__pstl_memory b/libc/isystem/__pstl_memory
deleted file mode 100644
index 8412f9cf5..000000000
--- a/libc/isystem/__pstl_memory
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl_memory"
diff --git a/libc/isystem/__pstl_numeric b/libc/isystem/__pstl_numeric
deleted file mode 100644
index bf03f0a0a..000000000
--- a/libc/isystem/__pstl_numeric
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__pstl_numeric"
diff --git a/libc/isystem/__random/bernoulli_distribution.h b/libc/isystem/__random/bernoulli_distribution.h
deleted file mode 100644
index e240f5277..000000000
--- a/libc/isystem/__random/bernoulli_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/bernoulli_distribution.h"
diff --git a/libc/isystem/__random/binomial_distribution.h b/libc/isystem/__random/binomial_distribution.h
deleted file mode 100644
index ddacda8dc..000000000
--- a/libc/isystem/__random/binomial_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/binomial_distribution.h"
diff --git a/libc/isystem/__random/cauchy_distribution.h b/libc/isystem/__random/cauchy_distribution.h
deleted file mode 100644
index 178ff7480..000000000
--- a/libc/isystem/__random/cauchy_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/cauchy_distribution.h"
diff --git a/libc/isystem/__random/chi_squared_distribution.h b/libc/isystem/__random/chi_squared_distribution.h
deleted file mode 100644
index f87e342bf..000000000
--- a/libc/isystem/__random/chi_squared_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/chi_squared_distribution.h"
diff --git a/libc/isystem/__random/clamp_to_integral.h b/libc/isystem/__random/clamp_to_integral.h
deleted file mode 100644
index cfe92b74b..000000000
--- a/libc/isystem/__random/clamp_to_integral.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/clamp_to_integral.h"
diff --git a/libc/isystem/__random/default_random_engine.h b/libc/isystem/__random/default_random_engine.h
deleted file mode 100644
index 2134e8dbf..000000000
--- a/libc/isystem/__random/default_random_engine.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/default_random_engine.h"
diff --git a/libc/isystem/__random/discard_block_engine.h b/libc/isystem/__random/discard_block_engine.h
deleted file mode 100644
index 9cf79e60b..000000000
--- a/libc/isystem/__random/discard_block_engine.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/discard_block_engine.h"
diff --git a/libc/isystem/__random/discrete_distribution.h b/libc/isystem/__random/discrete_distribution.h
deleted file mode 100644
index 5478b7da2..000000000
--- a/libc/isystem/__random/discrete_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/discrete_distribution.h"
diff --git a/libc/isystem/__random/exponential_distribution.h b/libc/isystem/__random/exponential_distribution.h
deleted file mode 100644
index 547b9198f..000000000
--- a/libc/isystem/__random/exponential_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/exponential_distribution.h"
diff --git a/libc/isystem/__random/extreme_value_distribution.h b/libc/isystem/__random/extreme_value_distribution.h
deleted file mode 100644
index df7e193de..000000000
--- a/libc/isystem/__random/extreme_value_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/extreme_value_distribution.h"
diff --git a/libc/isystem/__random/fisher_f_distribution.h b/libc/isystem/__random/fisher_f_distribution.h
deleted file mode 100644
index b1ac457f8..000000000
--- a/libc/isystem/__random/fisher_f_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/fisher_f_distribution.h"
diff --git a/libc/isystem/__random/gamma_distribution.h b/libc/isystem/__random/gamma_distribution.h
deleted file mode 100644
index 0cdde5138..000000000
--- a/libc/isystem/__random/gamma_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/gamma_distribution.h"
diff --git a/libc/isystem/__random/generate_canonical.h b/libc/isystem/__random/generate_canonical.h
deleted file mode 100644
index e4737fb26..000000000
--- a/libc/isystem/__random/generate_canonical.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/generate_canonical.h"
diff --git a/libc/isystem/__random/geometric_distribution.h b/libc/isystem/__random/geometric_distribution.h
deleted file mode 100644
index 86cce45e4..000000000
--- a/libc/isystem/__random/geometric_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/geometric_distribution.h"
diff --git a/libc/isystem/__random/independent_bits_engine.h b/libc/isystem/__random/independent_bits_engine.h
deleted file mode 100644
index 76eb66d97..000000000
--- a/libc/isystem/__random/independent_bits_engine.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/independent_bits_engine.h"
diff --git a/libc/isystem/__random/is_seed_sequence.h b/libc/isystem/__random/is_seed_sequence.h
deleted file mode 100644
index 037f36a94..000000000
--- a/libc/isystem/__random/is_seed_sequence.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/is_seed_sequence.h"
diff --git a/libc/isystem/__random/is_valid.h b/libc/isystem/__random/is_valid.h
deleted file mode 100644
index c1f871a6f..000000000
--- a/libc/isystem/__random/is_valid.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/is_valid.h"
diff --git a/libc/isystem/__random/knuth_b.h b/libc/isystem/__random/knuth_b.h
deleted file mode 100644
index 425206b18..000000000
--- a/libc/isystem/__random/knuth_b.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/knuth_b.h"
diff --git a/libc/isystem/__random/linear_congruential_engine.h b/libc/isystem/__random/linear_congruential_engine.h
deleted file mode 100644
index 37826ff22..000000000
--- a/libc/isystem/__random/linear_congruential_engine.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/linear_congruential_engine.h"
diff --git a/libc/isystem/__random/log2.h b/libc/isystem/__random/log2.h
deleted file mode 100644
index a6f96d734..000000000
--- a/libc/isystem/__random/log2.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/log2.h"
diff --git a/libc/isystem/__random/lognormal_distribution.h b/libc/isystem/__random/lognormal_distribution.h
deleted file mode 100644
index 1bc2e2f11..000000000
--- a/libc/isystem/__random/lognormal_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/lognormal_distribution.h"
diff --git a/libc/isystem/__random/mersenne_twister_engine.h b/libc/isystem/__random/mersenne_twister_engine.h
deleted file mode 100644
index c1d04a247..000000000
--- a/libc/isystem/__random/mersenne_twister_engine.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/mersenne_twister_engine.h"
diff --git a/libc/isystem/__random/negative_binomial_distribution.h b/libc/isystem/__random/negative_binomial_distribution.h
deleted file mode 100644
index d0ee1d480..000000000
--- a/libc/isystem/__random/negative_binomial_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/negative_binomial_distribution.h"
diff --git a/libc/isystem/__random/normal_distribution.h b/libc/isystem/__random/normal_distribution.h
deleted file mode 100644
index 6514d7e80..000000000
--- a/libc/isystem/__random/normal_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/normal_distribution.h"
diff --git a/libc/isystem/__random/piecewise_constant_distribution.h b/libc/isystem/__random/piecewise_constant_distribution.h
deleted file mode 100644
index 100ba45a0..000000000
--- a/libc/isystem/__random/piecewise_constant_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/piecewise_constant_distribution.h"
diff --git a/libc/isystem/__random/piecewise_linear_distribution.h b/libc/isystem/__random/piecewise_linear_distribution.h
deleted file mode 100644
index 666bee165..000000000
--- a/libc/isystem/__random/piecewise_linear_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/piecewise_linear_distribution.h"
diff --git a/libc/isystem/__random/poisson_distribution.h b/libc/isystem/__random/poisson_distribution.h
deleted file mode 100644
index 0b8562668..000000000
--- a/libc/isystem/__random/poisson_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/poisson_distribution.h"
diff --git a/libc/isystem/__random/random_device.h b/libc/isystem/__random/random_device.h
deleted file mode 100644
index 7c636db53..000000000
--- a/libc/isystem/__random/random_device.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/random_device.h"
diff --git a/libc/isystem/__random/ranlux.h b/libc/isystem/__random/ranlux.h
deleted file mode 100644
index 09c20cfcb..000000000
--- a/libc/isystem/__random/ranlux.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/ranlux.h"
diff --git a/libc/isystem/__random/seed_seq.h b/libc/isystem/__random/seed_seq.h
deleted file mode 100644
index 0aa3307f6..000000000
--- a/libc/isystem/__random/seed_seq.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/seed_seq.h"
diff --git a/libc/isystem/__random/shuffle_order_engine.h b/libc/isystem/__random/shuffle_order_engine.h
deleted file mode 100644
index 61961bba3..000000000
--- a/libc/isystem/__random/shuffle_order_engine.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/shuffle_order_engine.h"
diff --git a/libc/isystem/__random/student_t_distribution.h b/libc/isystem/__random/student_t_distribution.h
deleted file mode 100644
index faa747d85..000000000
--- a/libc/isystem/__random/student_t_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/student_t_distribution.h"
diff --git a/libc/isystem/__random/subtract_with_carry_engine.h b/libc/isystem/__random/subtract_with_carry_engine.h
deleted file mode 100644
index df0e52cc8..000000000
--- a/libc/isystem/__random/subtract_with_carry_engine.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/subtract_with_carry_engine.h"
diff --git a/libc/isystem/__random/uniform_int_distribution.h b/libc/isystem/__random/uniform_int_distribution.h
deleted file mode 100644
index 3d14ec164..000000000
--- a/libc/isystem/__random/uniform_int_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/uniform_int_distribution.h"
diff --git a/libc/isystem/__random/uniform_random_bit_generator.h b/libc/isystem/__random/uniform_random_bit_generator.h
deleted file mode 100644
index af2fd5f5c..000000000
--- a/libc/isystem/__random/uniform_random_bit_generator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/uniform_random_bit_generator.h"
diff --git a/libc/isystem/__random/uniform_real_distribution.h b/libc/isystem/__random/uniform_real_distribution.h
deleted file mode 100644
index d0ee5da8b..000000000
--- a/libc/isystem/__random/uniform_real_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/uniform_real_distribution.h"
diff --git a/libc/isystem/__random/weibull_distribution.h b/libc/isystem/__random/weibull_distribution.h
deleted file mode 100644
index 81334a3b7..000000000
--- a/libc/isystem/__random/weibull_distribution.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__random/weibull_distribution.h"
diff --git a/libc/isystem/__ranges/access.h b/libc/isystem/__ranges/access.h
deleted file mode 100644
index 6f811bdb6..000000000
--- a/libc/isystem/__ranges/access.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/access.h"
diff --git a/libc/isystem/__ranges/all.h b/libc/isystem/__ranges/all.h
deleted file mode 100644
index bbd3f32b0..000000000
--- a/libc/isystem/__ranges/all.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/all.h"
diff --git a/libc/isystem/__ranges/as_rvalue_view.h b/libc/isystem/__ranges/as_rvalue_view.h
deleted file mode 100644
index efda2bc13..000000000
--- a/libc/isystem/__ranges/as_rvalue_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/as_rvalue_view.h"
diff --git a/libc/isystem/__ranges/common_view.h b/libc/isystem/__ranges/common_view.h
deleted file mode 100644
index ecec8365e..000000000
--- a/libc/isystem/__ranges/common_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/common_view.h"
diff --git a/libc/isystem/__ranges/concepts.h b/libc/isystem/__ranges/concepts.h
deleted file mode 100644
index 5e3917d5b..000000000
--- a/libc/isystem/__ranges/concepts.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/concepts.h"
diff --git a/libc/isystem/__ranges/container_compatible_range.h b/libc/isystem/__ranges/container_compatible_range.h
deleted file mode 100644
index 0139d6769..000000000
--- a/libc/isystem/__ranges/container_compatible_range.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/container_compatible_range.h"
diff --git a/libc/isystem/__ranges/copyable_box.h b/libc/isystem/__ranges/copyable_box.h
deleted file mode 100644
index 85dc87732..000000000
--- a/libc/isystem/__ranges/copyable_box.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/copyable_box.h"
diff --git a/libc/isystem/__ranges/counted.h b/libc/isystem/__ranges/counted.h
deleted file mode 100644
index b455c84df..000000000
--- a/libc/isystem/__ranges/counted.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/counted.h"
diff --git a/libc/isystem/__ranges/dangling.h b/libc/isystem/__ranges/dangling.h
deleted file mode 100644
index 0d4a25638..000000000
--- a/libc/isystem/__ranges/dangling.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/dangling.h"
diff --git a/libc/isystem/__ranges/data.h b/libc/isystem/__ranges/data.h
deleted file mode 100644
index 067c84437..000000000
--- a/libc/isystem/__ranges/data.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/data.h"
diff --git a/libc/isystem/__ranges/drop_view.h b/libc/isystem/__ranges/drop_view.h
deleted file mode 100644
index 22ba897fb..000000000
--- a/libc/isystem/__ranges/drop_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/drop_view.h"
diff --git a/libc/isystem/__ranges/drop_while_view.h b/libc/isystem/__ranges/drop_while_view.h
deleted file mode 100644
index 900e498e5..000000000
--- a/libc/isystem/__ranges/drop_while_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/drop_while_view.h"
diff --git a/libc/isystem/__ranges/elements_view.h b/libc/isystem/__ranges/elements_view.h
deleted file mode 100644
index 1cba59aa8..000000000
--- a/libc/isystem/__ranges/elements_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/elements_view.h"
diff --git a/libc/isystem/__ranges/empty.h b/libc/isystem/__ranges/empty.h
deleted file mode 100644
index 4e3547c5b..000000000
--- a/libc/isystem/__ranges/empty.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/empty.h"
diff --git a/libc/isystem/__ranges/empty_view.h b/libc/isystem/__ranges/empty_view.h
deleted file mode 100644
index 77c23486e..000000000
--- a/libc/isystem/__ranges/empty_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/empty_view.h"
diff --git a/libc/isystem/__ranges/enable_borrowed_range.h b/libc/isystem/__ranges/enable_borrowed_range.h
deleted file mode 100644
index 3e451211d..000000000
--- a/libc/isystem/__ranges/enable_borrowed_range.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/enable_borrowed_range.h"
diff --git a/libc/isystem/__ranges/enable_view.h b/libc/isystem/__ranges/enable_view.h
deleted file mode 100644
index 1298361b5..000000000
--- a/libc/isystem/__ranges/enable_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/enable_view.h"
diff --git a/libc/isystem/__ranges/filter_view.h b/libc/isystem/__ranges/filter_view.h
deleted file mode 100644
index af4411d34..000000000
--- a/libc/isystem/__ranges/filter_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/filter_view.h"
diff --git a/libc/isystem/__ranges/from_range.h b/libc/isystem/__ranges/from_range.h
deleted file mode 100644
index 68fd72b7e..000000000
--- a/libc/isystem/__ranges/from_range.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/from_range.h"
diff --git a/libc/isystem/__ranges/iota_view.h b/libc/isystem/__ranges/iota_view.h
deleted file mode 100644
index f5376c75c..000000000
--- a/libc/isystem/__ranges/iota_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/iota_view.h"
diff --git a/libc/isystem/__ranges/istream_view.h b/libc/isystem/__ranges/istream_view.h
deleted file mode 100644
index eda421941..000000000
--- a/libc/isystem/__ranges/istream_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/istream_view.h"
diff --git a/libc/isystem/__ranges/join_view.h b/libc/isystem/__ranges/join_view.h
deleted file mode 100644
index 54897c651..000000000
--- a/libc/isystem/__ranges/join_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/join_view.h"
diff --git a/libc/isystem/__ranges/lazy_split_view.h b/libc/isystem/__ranges/lazy_split_view.h
deleted file mode 100644
index f06c4210a..000000000
--- a/libc/isystem/__ranges/lazy_split_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/lazy_split_view.h"
diff --git a/libc/isystem/__ranges/non_propagating_cache.h b/libc/isystem/__ranges/non_propagating_cache.h
deleted file mode 100644
index 5ea20eb1b..000000000
--- a/libc/isystem/__ranges/non_propagating_cache.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/non_propagating_cache.h"
diff --git a/libc/isystem/__ranges/owning_view.h b/libc/isystem/__ranges/owning_view.h
deleted file mode 100644
index 575ea2ce8..000000000
--- a/libc/isystem/__ranges/owning_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/owning_view.h"
diff --git a/libc/isystem/__ranges/range_adaptor.h b/libc/isystem/__ranges/range_adaptor.h
deleted file mode 100644
index 6947a9511..000000000
--- a/libc/isystem/__ranges/range_adaptor.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/range_adaptor.h"
diff --git a/libc/isystem/__ranges/rbegin.h b/libc/isystem/__ranges/rbegin.h
deleted file mode 100644
index f20972e47..000000000
--- a/libc/isystem/__ranges/rbegin.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/rbegin.h"
diff --git a/libc/isystem/__ranges/ref_view.h b/libc/isystem/__ranges/ref_view.h
deleted file mode 100644
index d536ffe84..000000000
--- a/libc/isystem/__ranges/ref_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/ref_view.h"
diff --git a/libc/isystem/__ranges/rend.h b/libc/isystem/__ranges/rend.h
deleted file mode 100644
index 5d075f6ae..000000000
--- a/libc/isystem/__ranges/rend.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/rend.h"
diff --git a/libc/isystem/__ranges/reverse_view.h b/libc/isystem/__ranges/reverse_view.h
deleted file mode 100644
index b12903231..000000000
--- a/libc/isystem/__ranges/reverse_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/reverse_view.h"
diff --git a/libc/isystem/__ranges/single_view.h b/libc/isystem/__ranges/single_view.h
deleted file mode 100644
index 557ea13ff..000000000
--- a/libc/isystem/__ranges/single_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/single_view.h"
diff --git a/libc/isystem/__ranges/size.h b/libc/isystem/__ranges/size.h
deleted file mode 100644
index 48956a294..000000000
--- a/libc/isystem/__ranges/size.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/size.h"
diff --git a/libc/isystem/__ranges/split_view.h b/libc/isystem/__ranges/split_view.h
deleted file mode 100644
index e0a7e3b98..000000000
--- a/libc/isystem/__ranges/split_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/split_view.h"
diff --git a/libc/isystem/__ranges/subrange.h b/libc/isystem/__ranges/subrange.h
deleted file mode 100644
index 3f9f6267e..000000000
--- a/libc/isystem/__ranges/subrange.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/subrange.h"
diff --git a/libc/isystem/__ranges/take_view.h b/libc/isystem/__ranges/take_view.h
deleted file mode 100644
index 321b84983..000000000
--- a/libc/isystem/__ranges/take_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/take_view.h"
diff --git a/libc/isystem/__ranges/take_while_view.h b/libc/isystem/__ranges/take_while_view.h
deleted file mode 100644
index 50a752997..000000000
--- a/libc/isystem/__ranges/take_while_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/take_while_view.h"
diff --git a/libc/isystem/__ranges/transform_view.h b/libc/isystem/__ranges/transform_view.h
deleted file mode 100644
index fd58130fa..000000000
--- a/libc/isystem/__ranges/transform_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/transform_view.h"
diff --git a/libc/isystem/__ranges/view_interface.h b/libc/isystem/__ranges/view_interface.h
deleted file mode 100644
index d4d88d92e..000000000
--- a/libc/isystem/__ranges/view_interface.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/view_interface.h"
diff --git a/libc/isystem/__ranges/views.h b/libc/isystem/__ranges/views.h
deleted file mode 100644
index cabb6af44..000000000
--- a/libc/isystem/__ranges/views.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/views.h"
diff --git a/libc/isystem/__ranges/zip_view.h b/libc/isystem/__ranges/zip_view.h
deleted file mode 100644
index 8be240c44..000000000
--- a/libc/isystem/__ranges/zip_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__ranges/zip_view.h"
diff --git a/libc/isystem/__split_buffer b/libc/isystem/__split_buffer
deleted file mode 100644
index 902141724..000000000
--- a/libc/isystem/__split_buffer
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__split_buffer"
diff --git a/libc/isystem/__std_mbstate_t.h b/libc/isystem/__std_mbstate_t.h
deleted file mode 100644
index 16e4afab1..000000000
--- a/libc/isystem/__std_mbstate_t.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__std_mbstate_t.h"
diff --git a/libc/isystem/__stop_token/atomic_unique_lock.h b/libc/isystem/__stop_token/atomic_unique_lock.h
deleted file mode 100644
index cf7fe650d..000000000
--- a/libc/isystem/__stop_token/atomic_unique_lock.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__stop_token/atomic_unique_lock.h"
diff --git a/libc/isystem/__stop_token/intrusive_list_view.h b/libc/isystem/__stop_token/intrusive_list_view.h
deleted file mode 100644
index 8cf31de7b..000000000
--- a/libc/isystem/__stop_token/intrusive_list_view.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__stop_token/intrusive_list_view.h"
diff --git a/libc/isystem/__stop_token/intrusive_shared_ptr.h b/libc/isystem/__stop_token/intrusive_shared_ptr.h
deleted file mode 100644
index 4d8690f30..000000000
--- a/libc/isystem/__stop_token/intrusive_shared_ptr.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__stop_token/intrusive_shared_ptr.h"
diff --git a/libc/isystem/__string/char_traits.h b/libc/isystem/__string/char_traits.h
deleted file mode 100644
index 595ecc11d..000000000
--- a/libc/isystem/__string/char_traits.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__string/char_traits.h"
diff --git a/libc/isystem/__string/constexpr_c_functions.h b/libc/isystem/__string/constexpr_c_functions.h
deleted file mode 100644
index 43b738d8c..000000000
--- a/libc/isystem/__string/constexpr_c_functions.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__string/constexpr_c_functions.h"
diff --git a/libc/isystem/__string/extern_template_lists.h b/libc/isystem/__string/extern_template_lists.h
deleted file mode 100644
index 21ed1bd1e..000000000
--- a/libc/isystem/__string/extern_template_lists.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__string/extern_template_lists.h"
diff --git a/libc/isystem/__support/android/locale_bionic.h b/libc/isystem/__support/android/locale_bionic.h
deleted file mode 100644
index fda130e29..000000000
--- a/libc/isystem/__support/android/locale_bionic.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/android/locale_bionic.h"
diff --git a/libc/isystem/__support/fuchsia/xlocale.h b/libc/isystem/__support/fuchsia/xlocale.h
deleted file mode 100644
index d1009593c..000000000
--- a/libc/isystem/__support/fuchsia/xlocale.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/fuchsia/xlocale.h"
diff --git a/libc/isystem/__support/ibm/gettod_zos.h b/libc/isystem/__support/ibm/gettod_zos.h
deleted file mode 100644
index c16419704..000000000
--- a/libc/isystem/__support/ibm/gettod_zos.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/ibm/gettod_zos.h"
diff --git a/libc/isystem/__support/ibm/locale_mgmt_zos.h b/libc/isystem/__support/ibm/locale_mgmt_zos.h
deleted file mode 100644
index fb69a30cf..000000000
--- a/libc/isystem/__support/ibm/locale_mgmt_zos.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/ibm/locale_mgmt_zos.h"
diff --git a/libc/isystem/__support/ibm/nanosleep.h b/libc/isystem/__support/ibm/nanosleep.h
deleted file mode 100644
index 9a371298a..000000000
--- a/libc/isystem/__support/ibm/nanosleep.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/ibm/nanosleep.h"
diff --git a/libc/isystem/__support/ibm/xlocale.h b/libc/isystem/__support/ibm/xlocale.h
deleted file mode 100644
index 91f0cfaae..000000000
--- a/libc/isystem/__support/ibm/xlocale.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/ibm/xlocale.h"
diff --git a/libc/isystem/__support/musl/xlocale.h b/libc/isystem/__support/musl/xlocale.h
deleted file mode 100644
index 6adc3cfa5..000000000
--- a/libc/isystem/__support/musl/xlocale.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/musl/xlocale.h"
diff --git a/libc/isystem/__support/newlib/xlocale.h b/libc/isystem/__support/newlib/xlocale.h
deleted file mode 100644
index 0e48c4211..000000000
--- a/libc/isystem/__support/newlib/xlocale.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/newlib/xlocale.h"
diff --git a/libc/isystem/__support/openbsd/xlocale.h b/libc/isystem/__support/openbsd/xlocale.h
deleted file mode 100644
index 42661d821..000000000
--- a/libc/isystem/__support/openbsd/xlocale.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/openbsd/xlocale.h"
diff --git a/libc/isystem/__support/win32/locale_win32.h b/libc/isystem/__support/win32/locale_win32.h
deleted file mode 100644
index 3a35381fa..000000000
--- a/libc/isystem/__support/win32/locale_win32.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/win32/locale_win32.h"
diff --git a/libc/isystem/__support/xlocale/__nop_locale_mgmt.h b/libc/isystem/__support/xlocale/__nop_locale_mgmt.h
deleted file mode 100644
index 2fb6f4d0d..000000000
--- a/libc/isystem/__support/xlocale/__nop_locale_mgmt.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/xlocale/__nop_locale_mgmt.h"
diff --git a/libc/isystem/__support/xlocale/__posix_l_fallback.h b/libc/isystem/__support/xlocale/__posix_l_fallback.h
deleted file mode 100644
index 3d36f53b6..000000000
--- a/libc/isystem/__support/xlocale/__posix_l_fallback.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/xlocale/__posix_l_fallback.h"
diff --git a/libc/isystem/__support/xlocale/__strtonum_fallback.h b/libc/isystem/__support/xlocale/__strtonum_fallback.h
deleted file mode 100644
index 56345c0e3..000000000
--- a/libc/isystem/__support/xlocale/__strtonum_fallback.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__support/xlocale/__strtonum_fallback.h"
diff --git a/libc/isystem/__system_error/errc.h b/libc/isystem/__system_error/errc.h
deleted file mode 100644
index 316ed06a1..000000000
--- a/libc/isystem/__system_error/errc.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__system_error/errc.h"
diff --git a/libc/isystem/__system_error/error_category.h b/libc/isystem/__system_error/error_category.h
deleted file mode 100644
index 614dd4e08..000000000
--- a/libc/isystem/__system_error/error_category.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__system_error/error_category.h"
diff --git a/libc/isystem/__system_error/error_code.h b/libc/isystem/__system_error/error_code.h
deleted file mode 100644
index ac222e5de..000000000
--- a/libc/isystem/__system_error/error_code.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__system_error/error_code.h"
diff --git a/libc/isystem/__system_error/error_condition.h b/libc/isystem/__system_error/error_condition.h
deleted file mode 100644
index b401abeb4..000000000
--- a/libc/isystem/__system_error/error_condition.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__system_error/error_condition.h"
diff --git a/libc/isystem/__system_error/system_error.h b/libc/isystem/__system_error/system_error.h
deleted file mode 100644
index 058736285..000000000
--- a/libc/isystem/__system_error/system_error.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__system_error/system_error.h"
diff --git a/libc/isystem/__thread/poll_with_backoff.h b/libc/isystem/__thread/poll_with_backoff.h
deleted file mode 100644
index d30bc37e3..000000000
--- a/libc/isystem/__thread/poll_with_backoff.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__thread/poll_with_backoff.h"
diff --git a/libc/isystem/__thread/timed_backoff_policy.h b/libc/isystem/__thread/timed_backoff_policy.h
deleted file mode 100644
index daaa7d605..000000000
--- a/libc/isystem/__thread/timed_backoff_policy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__thread/timed_backoff_policy.h"
diff --git a/libc/isystem/__threading_support b/libc/isystem/__threading_support
deleted file mode 100644
index 118b4ff82..000000000
--- a/libc/isystem/__threading_support
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__threading_support"
diff --git a/libc/isystem/__tree b/libc/isystem/__tree
deleted file mode 100644
index 58ced574a..000000000
--- a/libc/isystem/__tree
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__tree"
diff --git a/libc/isystem/__tuple/make_tuple_types.h b/libc/isystem/__tuple/make_tuple_types.h
deleted file mode 100644
index b8cb61f50..000000000
--- a/libc/isystem/__tuple/make_tuple_types.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__tuple/make_tuple_types.h"
diff --git a/libc/isystem/__tuple/pair_like.h b/libc/isystem/__tuple/pair_like.h
deleted file mode 100644
index f0af1bb9f..000000000
--- a/libc/isystem/__tuple/pair_like.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__tuple/pair_like.h"
diff --git a/libc/isystem/__tuple/sfinae_helpers.h b/libc/isystem/__tuple/sfinae_helpers.h
deleted file mode 100644
index b303e7b90..000000000
--- a/libc/isystem/__tuple/sfinae_helpers.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__tuple/sfinae_helpers.h"
diff --git a/libc/isystem/__tuple/tuple_element.h b/libc/isystem/__tuple/tuple_element.h
deleted file mode 100644
index bad24fc7b..000000000
--- a/libc/isystem/__tuple/tuple_element.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__tuple/tuple_element.h"
diff --git a/libc/isystem/__tuple/tuple_indices.h b/libc/isystem/__tuple/tuple_indices.h
deleted file mode 100644
index 8e95917fe..000000000
--- a/libc/isystem/__tuple/tuple_indices.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__tuple/tuple_indices.h"
diff --git a/libc/isystem/__tuple/tuple_like.h b/libc/isystem/__tuple/tuple_like.h
deleted file mode 100644
index 12f6324f4..000000000
--- a/libc/isystem/__tuple/tuple_like.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__tuple/tuple_like.h"
diff --git a/libc/isystem/__tuple/tuple_like_ext.h b/libc/isystem/__tuple/tuple_like_ext.h
deleted file mode 100644
index 48bda7deb..000000000
--- a/libc/isystem/__tuple/tuple_like_ext.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__tuple/tuple_like_ext.h"
diff --git a/libc/isystem/__tuple/tuple_size.h b/libc/isystem/__tuple/tuple_size.h
deleted file mode 100644
index 7efcc527e..000000000
--- a/libc/isystem/__tuple/tuple_size.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__tuple/tuple_size.h"
diff --git a/libc/isystem/__tuple/tuple_types.h b/libc/isystem/__tuple/tuple_types.h
deleted file mode 100644
index 9f27a4acc..000000000
--- a/libc/isystem/__tuple/tuple_types.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__tuple/tuple_types.h"
diff --git a/libc/isystem/__type_traits/add_const.h b/libc/isystem/__type_traits/add_const.h
deleted file mode 100644
index f9f9622df..000000000
--- a/libc/isystem/__type_traits/add_const.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/add_const.h"
diff --git a/libc/isystem/__type_traits/add_cv.h b/libc/isystem/__type_traits/add_cv.h
deleted file mode 100644
index 9a012ffbb..000000000
--- a/libc/isystem/__type_traits/add_cv.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/add_cv.h"
diff --git a/libc/isystem/__type_traits/add_lvalue_reference.h b/libc/isystem/__type_traits/add_lvalue_reference.h
deleted file mode 100644
index af6e976da..000000000
--- a/libc/isystem/__type_traits/add_lvalue_reference.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/add_lvalue_reference.h"
diff --git a/libc/isystem/__type_traits/add_pointer.h b/libc/isystem/__type_traits/add_pointer.h
deleted file mode 100644
index fd3665007..000000000
--- a/libc/isystem/__type_traits/add_pointer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/add_pointer.h"
diff --git a/libc/isystem/__type_traits/add_rvalue_reference.h b/libc/isystem/__type_traits/add_rvalue_reference.h
deleted file mode 100644
index 4cdf48028..000000000
--- a/libc/isystem/__type_traits/add_rvalue_reference.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/add_rvalue_reference.h"
diff --git a/libc/isystem/__type_traits/add_volatile.h b/libc/isystem/__type_traits/add_volatile.h
deleted file mode 100644
index 73082c9e6..000000000
--- a/libc/isystem/__type_traits/add_volatile.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/add_volatile.h"
diff --git a/libc/isystem/__type_traits/aligned_storage.h b/libc/isystem/__type_traits/aligned_storage.h
deleted file mode 100644
index 3ee11fc58..000000000
--- a/libc/isystem/__type_traits/aligned_storage.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/aligned_storage.h"
diff --git a/libc/isystem/__type_traits/aligned_union.h b/libc/isystem/__type_traits/aligned_union.h
deleted file mode 100644
index c83dff35c..000000000
--- a/libc/isystem/__type_traits/aligned_union.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/aligned_union.h"
diff --git a/libc/isystem/__type_traits/alignment_of.h b/libc/isystem/__type_traits/alignment_of.h
deleted file mode 100644
index 8cca54a65..000000000
--- a/libc/isystem/__type_traits/alignment_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/alignment_of.h"
diff --git a/libc/isystem/__type_traits/apply_cv.h b/libc/isystem/__type_traits/apply_cv.h
deleted file mode 100644
index c7465dd1a..000000000
--- a/libc/isystem/__type_traits/apply_cv.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/apply_cv.h"
diff --git a/libc/isystem/__type_traits/can_extract_key.h b/libc/isystem/__type_traits/can_extract_key.h
deleted file mode 100644
index bf477ffa5..000000000
--- a/libc/isystem/__type_traits/can_extract_key.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/can_extract_key.h"
diff --git a/libc/isystem/__type_traits/common_reference.h b/libc/isystem/__type_traits/common_reference.h
deleted file mode 100644
index abd2af421..000000000
--- a/libc/isystem/__type_traits/common_reference.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/common_reference.h"
diff --git a/libc/isystem/__type_traits/common_type.h b/libc/isystem/__type_traits/common_type.h
deleted file mode 100644
index 61fc9f099..000000000
--- a/libc/isystem/__type_traits/common_type.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/common_type.h"
diff --git a/libc/isystem/__type_traits/conditional.h b/libc/isystem/__type_traits/conditional.h
deleted file mode 100644
index d14de120c..000000000
--- a/libc/isystem/__type_traits/conditional.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/conditional.h"
diff --git a/libc/isystem/__type_traits/conjunction.h b/libc/isystem/__type_traits/conjunction.h
deleted file mode 100644
index cd73d37bb..000000000
--- a/libc/isystem/__type_traits/conjunction.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/conjunction.h"
diff --git a/libc/isystem/__type_traits/copy_cv.h b/libc/isystem/__type_traits/copy_cv.h
deleted file mode 100644
index aa6d3fd76..000000000
--- a/libc/isystem/__type_traits/copy_cv.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/copy_cv.h"
diff --git a/libc/isystem/__type_traits/copy_cvref.h b/libc/isystem/__type_traits/copy_cvref.h
deleted file mode 100644
index b3f60045d..000000000
--- a/libc/isystem/__type_traits/copy_cvref.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/copy_cvref.h"
diff --git a/libc/isystem/__type_traits/decay.h b/libc/isystem/__type_traits/decay.h
deleted file mode 100644
index 5f073bd3d..000000000
--- a/libc/isystem/__type_traits/decay.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/decay.h"
diff --git a/libc/isystem/__type_traits/dependent_type.h b/libc/isystem/__type_traits/dependent_type.h
deleted file mode 100644
index fb4558646..000000000
--- a/libc/isystem/__type_traits/dependent_type.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/dependent_type.h"
diff --git a/libc/isystem/__type_traits/disjunction.h b/libc/isystem/__type_traits/disjunction.h
deleted file mode 100644
index 9089736d6..000000000
--- a/libc/isystem/__type_traits/disjunction.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/disjunction.h"
diff --git a/libc/isystem/__type_traits/enable_if.h b/libc/isystem/__type_traits/enable_if.h
deleted file mode 100644
index 834849bec..000000000
--- a/libc/isystem/__type_traits/enable_if.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/enable_if.h"
diff --git a/libc/isystem/__type_traits/extent.h b/libc/isystem/__type_traits/extent.h
deleted file mode 100644
index b796acdc0..000000000
--- a/libc/isystem/__type_traits/extent.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/extent.h"
diff --git a/libc/isystem/__type_traits/has_unique_object_representation.h b/libc/isystem/__type_traits/has_unique_object_representation.h
deleted file mode 100644
index 81b1b6835..000000000
--- a/libc/isystem/__type_traits/has_unique_object_representation.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/has_unique_object_representation.h"
diff --git a/libc/isystem/__type_traits/has_virtual_destructor.h b/libc/isystem/__type_traits/has_virtual_destructor.h
deleted file mode 100644
index 2c55e7dd7..000000000
--- a/libc/isystem/__type_traits/has_virtual_destructor.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/has_virtual_destructor.h"
diff --git a/libc/isystem/__type_traits/integral_constant.h b/libc/isystem/__type_traits/integral_constant.h
deleted file mode 100644
index e2998650e..000000000
--- a/libc/isystem/__type_traits/integral_constant.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/integral_constant.h"
diff --git a/libc/isystem/__type_traits/invoke.h b/libc/isystem/__type_traits/invoke.h
deleted file mode 100644
index 8bcb03c23..000000000
--- a/libc/isystem/__type_traits/invoke.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/invoke.h"
diff --git a/libc/isystem/__type_traits/is_abstract.h b/libc/isystem/__type_traits/is_abstract.h
deleted file mode 100644
index 7af736c48..000000000
--- a/libc/isystem/__type_traits/is_abstract.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_abstract.h"
diff --git a/libc/isystem/__type_traits/is_aggregate.h b/libc/isystem/__type_traits/is_aggregate.h
deleted file mode 100644
index 751dddd65..000000000
--- a/libc/isystem/__type_traits/is_aggregate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_aggregate.h"
diff --git a/libc/isystem/__type_traits/is_allocator.h b/libc/isystem/__type_traits/is_allocator.h
deleted file mode 100644
index 1149f184c..000000000
--- a/libc/isystem/__type_traits/is_allocator.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_allocator.h"
diff --git a/libc/isystem/__type_traits/is_always_bitcastable.h b/libc/isystem/__type_traits/is_always_bitcastable.h
deleted file mode 100644
index 167d6adff..000000000
--- a/libc/isystem/__type_traits/is_always_bitcastable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_always_bitcastable.h"
diff --git a/libc/isystem/__type_traits/is_arithmetic.h b/libc/isystem/__type_traits/is_arithmetic.h
deleted file mode 100644
index 1daf36b39..000000000
--- a/libc/isystem/__type_traits/is_arithmetic.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_arithmetic.h"
diff --git a/libc/isystem/__type_traits/is_array.h b/libc/isystem/__type_traits/is_array.h
deleted file mode 100644
index 510e0533b..000000000
--- a/libc/isystem/__type_traits/is_array.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_array.h"
diff --git a/libc/isystem/__type_traits/is_assignable.h b/libc/isystem/__type_traits/is_assignable.h
deleted file mode 100644
index feb481cfa..000000000
--- a/libc/isystem/__type_traits/is_assignable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_assignable.h"
diff --git a/libc/isystem/__type_traits/is_base_of.h b/libc/isystem/__type_traits/is_base_of.h
deleted file mode 100644
index 44c6370a7..000000000
--- a/libc/isystem/__type_traits/is_base_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_base_of.h"
diff --git a/libc/isystem/__type_traits/is_bounded_array.h b/libc/isystem/__type_traits/is_bounded_array.h
deleted file mode 100644
index 779a4c3d2..000000000
--- a/libc/isystem/__type_traits/is_bounded_array.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_bounded_array.h"
diff --git a/libc/isystem/__type_traits/is_callable.h b/libc/isystem/__type_traits/is_callable.h
deleted file mode 100644
index 55bb174ca..000000000
--- a/libc/isystem/__type_traits/is_callable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_callable.h"
diff --git a/libc/isystem/__type_traits/is_char_like_type.h b/libc/isystem/__type_traits/is_char_like_type.h
deleted file mode 100644
index fe739ebb0..000000000
--- a/libc/isystem/__type_traits/is_char_like_type.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_char_like_type.h"
diff --git a/libc/isystem/__type_traits/is_class.h b/libc/isystem/__type_traits/is_class.h
deleted file mode 100644
index 765c0e65c..000000000
--- a/libc/isystem/__type_traits/is_class.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_class.h"
diff --git a/libc/isystem/__type_traits/is_compound.h b/libc/isystem/__type_traits/is_compound.h
deleted file mode 100644
index 190ae4953..000000000
--- a/libc/isystem/__type_traits/is_compound.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_compound.h"
diff --git a/libc/isystem/__type_traits/is_const.h b/libc/isystem/__type_traits/is_const.h
deleted file mode 100644
index 13a04ef03..000000000
--- a/libc/isystem/__type_traits/is_const.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_const.h"
diff --git a/libc/isystem/__type_traits/is_constant_evaluated.h b/libc/isystem/__type_traits/is_constant_evaluated.h
deleted file mode 100644
index f83dd12a7..000000000
--- a/libc/isystem/__type_traits/is_constant_evaluated.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_constant_evaluated.h"
diff --git a/libc/isystem/__type_traits/is_constructible.h b/libc/isystem/__type_traits/is_constructible.h
deleted file mode 100644
index ff75c90f2..000000000
--- a/libc/isystem/__type_traits/is_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_constructible.h"
diff --git a/libc/isystem/__type_traits/is_convertible.h b/libc/isystem/__type_traits/is_convertible.h
deleted file mode 100644
index 47941c5eb..000000000
--- a/libc/isystem/__type_traits/is_convertible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_convertible.h"
diff --git a/libc/isystem/__type_traits/is_copy_assignable.h b/libc/isystem/__type_traits/is_copy_assignable.h
deleted file mode 100644
index 55f36e99d..000000000
--- a/libc/isystem/__type_traits/is_copy_assignable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_copy_assignable.h"
diff --git a/libc/isystem/__type_traits/is_copy_constructible.h b/libc/isystem/__type_traits/is_copy_constructible.h
deleted file mode 100644
index 279a7fcee..000000000
--- a/libc/isystem/__type_traits/is_copy_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_copy_constructible.h"
diff --git a/libc/isystem/__type_traits/is_core_convertible.h b/libc/isystem/__type_traits/is_core_convertible.h
deleted file mode 100644
index 4f62f122e..000000000
--- a/libc/isystem/__type_traits/is_core_convertible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_core_convertible.h"
diff --git a/libc/isystem/__type_traits/is_default_constructible.h b/libc/isystem/__type_traits/is_default_constructible.h
deleted file mode 100644
index 550bd34e6..000000000
--- a/libc/isystem/__type_traits/is_default_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_default_constructible.h"
diff --git a/libc/isystem/__type_traits/is_destructible.h b/libc/isystem/__type_traits/is_destructible.h
deleted file mode 100644
index 20e16dd9b..000000000
--- a/libc/isystem/__type_traits/is_destructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_destructible.h"
diff --git a/libc/isystem/__type_traits/is_empty.h b/libc/isystem/__type_traits/is_empty.h
deleted file mode 100644
index 0b67f378d..000000000
--- a/libc/isystem/__type_traits/is_empty.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_empty.h"
diff --git a/libc/isystem/__type_traits/is_enum.h b/libc/isystem/__type_traits/is_enum.h
deleted file mode 100644
index db7f368e3..000000000
--- a/libc/isystem/__type_traits/is_enum.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_enum.h"
diff --git a/libc/isystem/__type_traits/is_equality_comparable.h b/libc/isystem/__type_traits/is_equality_comparable.h
deleted file mode 100644
index 008522fa8..000000000
--- a/libc/isystem/__type_traits/is_equality_comparable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_equality_comparable.h"
diff --git a/libc/isystem/__type_traits/is_execution_policy.h b/libc/isystem/__type_traits/is_execution_policy.h
deleted file mode 100644
index dc634945f..000000000
--- a/libc/isystem/__type_traits/is_execution_policy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_execution_policy.h"
diff --git a/libc/isystem/__type_traits/is_final.h b/libc/isystem/__type_traits/is_final.h
deleted file mode 100644
index 6876cbfeb..000000000
--- a/libc/isystem/__type_traits/is_final.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_final.h"
diff --git a/libc/isystem/__type_traits/is_floating_point.h b/libc/isystem/__type_traits/is_floating_point.h
deleted file mode 100644
index a9d8bd5b8..000000000
--- a/libc/isystem/__type_traits/is_floating_point.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_floating_point.h"
diff --git a/libc/isystem/__type_traits/is_function.h b/libc/isystem/__type_traits/is_function.h
deleted file mode 100644
index 20126bba3..000000000
--- a/libc/isystem/__type_traits/is_function.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_function.h"
diff --git a/libc/isystem/__type_traits/is_fundamental.h b/libc/isystem/__type_traits/is_fundamental.h
deleted file mode 100644
index 29d4b6e2d..000000000
--- a/libc/isystem/__type_traits/is_fundamental.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_fundamental.h"
diff --git a/libc/isystem/__type_traits/is_implicitly_default_constructible.h b/libc/isystem/__type_traits/is_implicitly_default_constructible.h
deleted file mode 100644
index 6f51771da..000000000
--- a/libc/isystem/__type_traits/is_implicitly_default_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_implicitly_default_constructible.h"
diff --git a/libc/isystem/__type_traits/is_integral.h b/libc/isystem/__type_traits/is_integral.h
deleted file mode 100644
index 9c206e3d6..000000000
--- a/libc/isystem/__type_traits/is_integral.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_integral.h"
diff --git a/libc/isystem/__type_traits/is_literal_type.h b/libc/isystem/__type_traits/is_literal_type.h
deleted file mode 100644
index 45ca76824..000000000
--- a/libc/isystem/__type_traits/is_literal_type.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_literal_type.h"
diff --git a/libc/isystem/__type_traits/is_member_function_pointer.h b/libc/isystem/__type_traits/is_member_function_pointer.h
deleted file mode 100644
index 35dd4ff62..000000000
--- a/libc/isystem/__type_traits/is_member_function_pointer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_member_function_pointer.h"
diff --git a/libc/isystem/__type_traits/is_member_object_pointer.h b/libc/isystem/__type_traits/is_member_object_pointer.h
deleted file mode 100644
index b3416ddbc..000000000
--- a/libc/isystem/__type_traits/is_member_object_pointer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_member_object_pointer.h"
diff --git a/libc/isystem/__type_traits/is_member_pointer.h b/libc/isystem/__type_traits/is_member_pointer.h
deleted file mode 100644
index bf0f9074a..000000000
--- a/libc/isystem/__type_traits/is_member_pointer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_member_pointer.h"
diff --git a/libc/isystem/__type_traits/is_move_assignable.h b/libc/isystem/__type_traits/is_move_assignable.h
deleted file mode 100644
index ff502b025..000000000
--- a/libc/isystem/__type_traits/is_move_assignable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_move_assignable.h"
diff --git a/libc/isystem/__type_traits/is_move_constructible.h b/libc/isystem/__type_traits/is_move_constructible.h
deleted file mode 100644
index 86dc68397..000000000
--- a/libc/isystem/__type_traits/is_move_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_move_constructible.h"
diff --git a/libc/isystem/__type_traits/is_nothrow_assignable.h b/libc/isystem/__type_traits/is_nothrow_assignable.h
deleted file mode 100644
index 0ecb04386..000000000
--- a/libc/isystem/__type_traits/is_nothrow_assignable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_nothrow_assignable.h"
diff --git a/libc/isystem/__type_traits/is_nothrow_constructible.h b/libc/isystem/__type_traits/is_nothrow_constructible.h
deleted file mode 100644
index 78062675e..000000000
--- a/libc/isystem/__type_traits/is_nothrow_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_nothrow_constructible.h"
diff --git a/libc/isystem/__type_traits/is_nothrow_convertible.h b/libc/isystem/__type_traits/is_nothrow_convertible.h
deleted file mode 100644
index a9e7da15a..000000000
--- a/libc/isystem/__type_traits/is_nothrow_convertible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_nothrow_convertible.h"
diff --git a/libc/isystem/__type_traits/is_nothrow_copy_assignable.h b/libc/isystem/__type_traits/is_nothrow_copy_assignable.h
deleted file mode 100644
index 88d02b91d..000000000
--- a/libc/isystem/__type_traits/is_nothrow_copy_assignable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_nothrow_copy_assignable.h"
diff --git a/libc/isystem/__type_traits/is_nothrow_copy_constructible.h b/libc/isystem/__type_traits/is_nothrow_copy_constructible.h
deleted file mode 100644
index ca1961fb1..000000000
--- a/libc/isystem/__type_traits/is_nothrow_copy_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_nothrow_copy_constructible.h"
diff --git a/libc/isystem/__type_traits/is_nothrow_default_constructible.h b/libc/isystem/__type_traits/is_nothrow_default_constructible.h
deleted file mode 100644
index ed62c54cb..000000000
--- a/libc/isystem/__type_traits/is_nothrow_default_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_nothrow_default_constructible.h"
diff --git a/libc/isystem/__type_traits/is_nothrow_destructible.h b/libc/isystem/__type_traits/is_nothrow_destructible.h
deleted file mode 100644
index 07530bbc1..000000000
--- a/libc/isystem/__type_traits/is_nothrow_destructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_nothrow_destructible.h"
diff --git a/libc/isystem/__type_traits/is_nothrow_move_assignable.h b/libc/isystem/__type_traits/is_nothrow_move_assignable.h
deleted file mode 100644
index 34b36de9a..000000000
--- a/libc/isystem/__type_traits/is_nothrow_move_assignable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_nothrow_move_assignable.h"
diff --git a/libc/isystem/__type_traits/is_nothrow_move_constructible.h b/libc/isystem/__type_traits/is_nothrow_move_constructible.h
deleted file mode 100644
index 551fd299b..000000000
--- a/libc/isystem/__type_traits/is_nothrow_move_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_nothrow_move_constructible.h"
diff --git a/libc/isystem/__type_traits/is_null_pointer.h b/libc/isystem/__type_traits/is_null_pointer.h
deleted file mode 100644
index 34126db4f..000000000
--- a/libc/isystem/__type_traits/is_null_pointer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_null_pointer.h"
diff --git a/libc/isystem/__type_traits/is_object.h b/libc/isystem/__type_traits/is_object.h
deleted file mode 100644
index 12726de25..000000000
--- a/libc/isystem/__type_traits/is_object.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_object.h"
diff --git a/libc/isystem/__type_traits/is_pod.h b/libc/isystem/__type_traits/is_pod.h
deleted file mode 100644
index 564d5b017..000000000
--- a/libc/isystem/__type_traits/is_pod.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_pod.h"
diff --git a/libc/isystem/__type_traits/is_pointer.h b/libc/isystem/__type_traits/is_pointer.h
deleted file mode 100644
index 5a790de23..000000000
--- a/libc/isystem/__type_traits/is_pointer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_pointer.h"
diff --git a/libc/isystem/__type_traits/is_polymorphic.h b/libc/isystem/__type_traits/is_polymorphic.h
deleted file mode 100644
index 31f16c24a..000000000
--- a/libc/isystem/__type_traits/is_polymorphic.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_polymorphic.h"
diff --git a/libc/isystem/__type_traits/is_primary_template.h b/libc/isystem/__type_traits/is_primary_template.h
deleted file mode 100644
index 4efbc8287..000000000
--- a/libc/isystem/__type_traits/is_primary_template.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_primary_template.h"
diff --git a/libc/isystem/__type_traits/is_reference.h b/libc/isystem/__type_traits/is_reference.h
deleted file mode 100644
index 5d612d1bc..000000000
--- a/libc/isystem/__type_traits/is_reference.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_reference.h"
diff --git a/libc/isystem/__type_traits/is_reference_wrapper.h b/libc/isystem/__type_traits/is_reference_wrapper.h
deleted file mode 100644
index e5cde5867..000000000
--- a/libc/isystem/__type_traits/is_reference_wrapper.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_reference_wrapper.h"
diff --git a/libc/isystem/__type_traits/is_referenceable.h b/libc/isystem/__type_traits/is_referenceable.h
deleted file mode 100644
index 355e8ba81..000000000
--- a/libc/isystem/__type_traits/is_referenceable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_referenceable.h"
diff --git a/libc/isystem/__type_traits/is_same.h b/libc/isystem/__type_traits/is_same.h
deleted file mode 100644
index 3eb4654e9..000000000
--- a/libc/isystem/__type_traits/is_same.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_same.h"
diff --git a/libc/isystem/__type_traits/is_scalar.h b/libc/isystem/__type_traits/is_scalar.h
deleted file mode 100644
index e7b943bd1..000000000
--- a/libc/isystem/__type_traits/is_scalar.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_scalar.h"
diff --git a/libc/isystem/__type_traits/is_scoped_enum.h b/libc/isystem/__type_traits/is_scoped_enum.h
deleted file mode 100644
index 6d10abec5..000000000
--- a/libc/isystem/__type_traits/is_scoped_enum.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_scoped_enum.h"
diff --git a/libc/isystem/__type_traits/is_signed.h b/libc/isystem/__type_traits/is_signed.h
deleted file mode 100644
index cb478ab69..000000000
--- a/libc/isystem/__type_traits/is_signed.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_signed.h"
diff --git a/libc/isystem/__type_traits/is_signed_integer.h b/libc/isystem/__type_traits/is_signed_integer.h
deleted file mode 100644
index bcbb428ba..000000000
--- a/libc/isystem/__type_traits/is_signed_integer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_signed_integer.h"
diff --git a/libc/isystem/__type_traits/is_specialization.h b/libc/isystem/__type_traits/is_specialization.h
deleted file mode 100644
index eb5d1b280..000000000
--- a/libc/isystem/__type_traits/is_specialization.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_specialization.h"
diff --git a/libc/isystem/__type_traits/is_standard_layout.h b/libc/isystem/__type_traits/is_standard_layout.h
deleted file mode 100644
index c930c71dc..000000000
--- a/libc/isystem/__type_traits/is_standard_layout.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_standard_layout.h"
diff --git a/libc/isystem/__type_traits/is_swappable.h b/libc/isystem/__type_traits/is_swappable.h
deleted file mode 100644
index 749ac4eb4..000000000
--- a/libc/isystem/__type_traits/is_swappable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_swappable.h"
diff --git a/libc/isystem/__type_traits/is_trivial.h b/libc/isystem/__type_traits/is_trivial.h
deleted file mode 100644
index 46a57f6f9..000000000
--- a/libc/isystem/__type_traits/is_trivial.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivial.h"
diff --git a/libc/isystem/__type_traits/is_trivially_assignable.h b/libc/isystem/__type_traits/is_trivially_assignable.h
deleted file mode 100644
index 92ebe07f1..000000000
--- a/libc/isystem/__type_traits/is_trivially_assignable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivially_assignable.h"
diff --git a/libc/isystem/__type_traits/is_trivially_constructible.h b/libc/isystem/__type_traits/is_trivially_constructible.h
deleted file mode 100644
index 5987cb011..000000000
--- a/libc/isystem/__type_traits/is_trivially_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivially_constructible.h"
diff --git a/libc/isystem/__type_traits/is_trivially_copy_assignable.h b/libc/isystem/__type_traits/is_trivially_copy_assignable.h
deleted file mode 100644
index 78e9db695..000000000
--- a/libc/isystem/__type_traits/is_trivially_copy_assignable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivially_copy_assignable.h"
diff --git a/libc/isystem/__type_traits/is_trivially_copy_constructible.h b/libc/isystem/__type_traits/is_trivially_copy_constructible.h
deleted file mode 100644
index 6333c20fc..000000000
--- a/libc/isystem/__type_traits/is_trivially_copy_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivially_copy_constructible.h"
diff --git a/libc/isystem/__type_traits/is_trivially_copyable.h b/libc/isystem/__type_traits/is_trivially_copyable.h
deleted file mode 100644
index 818579907..000000000
--- a/libc/isystem/__type_traits/is_trivially_copyable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivially_copyable.h"
diff --git a/libc/isystem/__type_traits/is_trivially_default_constructible.h b/libc/isystem/__type_traits/is_trivially_default_constructible.h
deleted file mode 100644
index 1c81c485d..000000000
--- a/libc/isystem/__type_traits/is_trivially_default_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivially_default_constructible.h"
diff --git a/libc/isystem/__type_traits/is_trivially_destructible.h b/libc/isystem/__type_traits/is_trivially_destructible.h
deleted file mode 100644
index f36f1c412..000000000
--- a/libc/isystem/__type_traits/is_trivially_destructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivially_destructible.h"
diff --git a/libc/isystem/__type_traits/is_trivially_lexicographically_comparable.h b/libc/isystem/__type_traits/is_trivially_lexicographically_comparable.h
deleted file mode 100644
index 0be37bf25..000000000
--- a/libc/isystem/__type_traits/is_trivially_lexicographically_comparable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivially_lexicographically_comparable.h"
diff --git a/libc/isystem/__type_traits/is_trivially_move_assignable.h b/libc/isystem/__type_traits/is_trivially_move_assignable.h
deleted file mode 100644
index 0fd012dbe..000000000
--- a/libc/isystem/__type_traits/is_trivially_move_assignable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivially_move_assignable.h"
diff --git a/libc/isystem/__type_traits/is_trivially_move_constructible.h b/libc/isystem/__type_traits/is_trivially_move_constructible.h
deleted file mode 100644
index 12610f283..000000000
--- a/libc/isystem/__type_traits/is_trivially_move_constructible.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_trivially_move_constructible.h"
diff --git a/libc/isystem/__type_traits/is_unbounded_array.h b/libc/isystem/__type_traits/is_unbounded_array.h
deleted file mode 100644
index a40efc493..000000000
--- a/libc/isystem/__type_traits/is_unbounded_array.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_unbounded_array.h"
diff --git a/libc/isystem/__type_traits/is_union.h b/libc/isystem/__type_traits/is_union.h
deleted file mode 100644
index c70568c14..000000000
--- a/libc/isystem/__type_traits/is_union.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_union.h"
diff --git a/libc/isystem/__type_traits/is_unsigned.h b/libc/isystem/__type_traits/is_unsigned.h
deleted file mode 100644
index 06cbecdb7..000000000
--- a/libc/isystem/__type_traits/is_unsigned.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_unsigned.h"
diff --git a/libc/isystem/__type_traits/is_unsigned_integer.h b/libc/isystem/__type_traits/is_unsigned_integer.h
deleted file mode 100644
index 28a87ddbb..000000000
--- a/libc/isystem/__type_traits/is_unsigned_integer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_unsigned_integer.h"
diff --git a/libc/isystem/__type_traits/is_valid_expansion.h b/libc/isystem/__type_traits/is_valid_expansion.h
deleted file mode 100644
index 54b3b40dd..000000000
--- a/libc/isystem/__type_traits/is_valid_expansion.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_valid_expansion.h"
diff --git a/libc/isystem/__type_traits/is_void.h b/libc/isystem/__type_traits/is_void.h
deleted file mode 100644
index ff6e5ab16..000000000
--- a/libc/isystem/__type_traits/is_void.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_void.h"
diff --git a/libc/isystem/__type_traits/is_volatile.h b/libc/isystem/__type_traits/is_volatile.h
deleted file mode 100644
index 41e60d4fe..000000000
--- a/libc/isystem/__type_traits/is_volatile.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/is_volatile.h"
diff --git a/libc/isystem/__type_traits/lazy.h b/libc/isystem/__type_traits/lazy.h
deleted file mode 100644
index fafac0f65..000000000
--- a/libc/isystem/__type_traits/lazy.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/lazy.h"
diff --git a/libc/isystem/__type_traits/make_32_64_or_128_bit.h b/libc/isystem/__type_traits/make_32_64_or_128_bit.h
deleted file mode 100644
index ad6a8b84f..000000000
--- a/libc/isystem/__type_traits/make_32_64_or_128_bit.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/make_32_64_or_128_bit.h"
diff --git a/libc/isystem/__type_traits/make_const_lvalue_ref.h b/libc/isystem/__type_traits/make_const_lvalue_ref.h
deleted file mode 100644
index e68557857..000000000
--- a/libc/isystem/__type_traits/make_const_lvalue_ref.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/make_const_lvalue_ref.h"
diff --git a/libc/isystem/__type_traits/make_signed.h b/libc/isystem/__type_traits/make_signed.h
deleted file mode 100644
index 872328dfc..000000000
--- a/libc/isystem/__type_traits/make_signed.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/make_signed.h"
diff --git a/libc/isystem/__type_traits/make_unsigned.h b/libc/isystem/__type_traits/make_unsigned.h
deleted file mode 100644
index a66b4f91d..000000000
--- a/libc/isystem/__type_traits/make_unsigned.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/make_unsigned.h"
diff --git a/libc/isystem/__type_traits/maybe_const.h b/libc/isystem/__type_traits/maybe_const.h
deleted file mode 100644
index 96b7db155..000000000
--- a/libc/isystem/__type_traits/maybe_const.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/maybe_const.h"
diff --git a/libc/isystem/__type_traits/nat.h b/libc/isystem/__type_traits/nat.h
deleted file mode 100644
index e3e8f8e17..000000000
--- a/libc/isystem/__type_traits/nat.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/nat.h"
diff --git a/libc/isystem/__type_traits/negation.h b/libc/isystem/__type_traits/negation.h
deleted file mode 100644
index 4a7526d64..000000000
--- a/libc/isystem/__type_traits/negation.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/negation.h"
diff --git a/libc/isystem/__type_traits/noexcept_move_assign_container.h b/libc/isystem/__type_traits/noexcept_move_assign_container.h
deleted file mode 100644
index daed1653c..000000000
--- a/libc/isystem/__type_traits/noexcept_move_assign_container.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/noexcept_move_assign_container.h"
diff --git a/libc/isystem/__type_traits/predicate_traits.h b/libc/isystem/__type_traits/predicate_traits.h
deleted file mode 100644
index 35cd151b5..000000000
--- a/libc/isystem/__type_traits/predicate_traits.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/predicate_traits.h"
diff --git a/libc/isystem/__type_traits/promote.h b/libc/isystem/__type_traits/promote.h
deleted file mode 100644
index 8922694bd..000000000
--- a/libc/isystem/__type_traits/promote.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/promote.h"
diff --git a/libc/isystem/__type_traits/rank.h b/libc/isystem/__type_traits/rank.h
deleted file mode 100644
index 82d80b323..000000000
--- a/libc/isystem/__type_traits/rank.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/rank.h"
diff --git a/libc/isystem/__type_traits/remove_all_extents.h b/libc/isystem/__type_traits/remove_all_extents.h
deleted file mode 100644
index 92f1effee..000000000
--- a/libc/isystem/__type_traits/remove_all_extents.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/remove_all_extents.h"
diff --git a/libc/isystem/__type_traits/remove_const.h b/libc/isystem/__type_traits/remove_const.h
deleted file mode 100644
index cecaff288..000000000
--- a/libc/isystem/__type_traits/remove_const.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/remove_const.h"
diff --git a/libc/isystem/__type_traits/remove_const_ref.h b/libc/isystem/__type_traits/remove_const_ref.h
deleted file mode 100644
index c9ffba8ca..000000000
--- a/libc/isystem/__type_traits/remove_const_ref.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/remove_const_ref.h"
diff --git a/libc/isystem/__type_traits/remove_cv.h b/libc/isystem/__type_traits/remove_cv.h
deleted file mode 100644
index aa0c33a6d..000000000
--- a/libc/isystem/__type_traits/remove_cv.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/remove_cv.h"
diff --git a/libc/isystem/__type_traits/remove_cvref.h b/libc/isystem/__type_traits/remove_cvref.h
deleted file mode 100644
index 9783b669a..000000000
--- a/libc/isystem/__type_traits/remove_cvref.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/remove_cvref.h"
diff --git a/libc/isystem/__type_traits/remove_extent.h b/libc/isystem/__type_traits/remove_extent.h
deleted file mode 100644
index 591435551..000000000
--- a/libc/isystem/__type_traits/remove_extent.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/remove_extent.h"
diff --git a/libc/isystem/__type_traits/remove_pointer.h b/libc/isystem/__type_traits/remove_pointer.h
deleted file mode 100644
index 4debc55fc..000000000
--- a/libc/isystem/__type_traits/remove_pointer.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/remove_pointer.h"
diff --git a/libc/isystem/__type_traits/remove_reference.h b/libc/isystem/__type_traits/remove_reference.h
deleted file mode 100644
index 94093ed97..000000000
--- a/libc/isystem/__type_traits/remove_reference.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/remove_reference.h"
diff --git a/libc/isystem/__type_traits/remove_volatile.h b/libc/isystem/__type_traits/remove_volatile.h
deleted file mode 100644
index 1cc860aea..000000000
--- a/libc/isystem/__type_traits/remove_volatile.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/remove_volatile.h"
diff --git a/libc/isystem/__type_traits/result_of.h b/libc/isystem/__type_traits/result_of.h
deleted file mode 100644
index 140c19a93..000000000
--- a/libc/isystem/__type_traits/result_of.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/result_of.h"
diff --git a/libc/isystem/__type_traits/strip_signature.h b/libc/isystem/__type_traits/strip_signature.h
deleted file mode 100644
index bcd68770e..000000000
--- a/libc/isystem/__type_traits/strip_signature.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/strip_signature.h"
diff --git a/libc/isystem/__type_traits/type_identity.h b/libc/isystem/__type_traits/type_identity.h
deleted file mode 100644
index e848c9ae8..000000000
--- a/libc/isystem/__type_traits/type_identity.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/type_identity.h"
diff --git a/libc/isystem/__type_traits/type_list.h b/libc/isystem/__type_traits/type_list.h
deleted file mode 100644
index 0b09b0b71..000000000
--- a/libc/isystem/__type_traits/type_list.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/type_list.h"
diff --git a/libc/isystem/__type_traits/underlying_type.h b/libc/isystem/__type_traits/underlying_type.h
deleted file mode 100644
index b2ac822cb..000000000
--- a/libc/isystem/__type_traits/underlying_type.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/underlying_type.h"
diff --git a/libc/isystem/__type_traits/unwrap_ref.h b/libc/isystem/__type_traits/unwrap_ref.h
deleted file mode 100644
index c374c1159..000000000
--- a/libc/isystem/__type_traits/unwrap_ref.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/unwrap_ref.h"
diff --git a/libc/isystem/__type_traits/void_t.h b/libc/isystem/__type_traits/void_t.h
deleted file mode 100644
index 7d0770fb2..000000000
--- a/libc/isystem/__type_traits/void_t.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__type_traits/void_t.h"
diff --git a/libc/isystem/__undef_macros b/libc/isystem/__undef_macros
deleted file mode 100644
index e7cf229e8..000000000
--- a/libc/isystem/__undef_macros
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__undef_macros"
diff --git a/libc/isystem/__utility/as_const.h b/libc/isystem/__utility/as_const.h
deleted file mode 100644
index 27b4f0441..000000000
--- a/libc/isystem/__utility/as_const.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/as_const.h"
diff --git a/libc/isystem/__utility/auto_cast.h b/libc/isystem/__utility/auto_cast.h
deleted file mode 100644
index e1d2b1b21..000000000
--- a/libc/isystem/__utility/auto_cast.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/auto_cast.h"
diff --git a/libc/isystem/__utility/cmp.h b/libc/isystem/__utility/cmp.h
deleted file mode 100644
index e934c6834..000000000
--- a/libc/isystem/__utility/cmp.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/cmp.h"
diff --git a/libc/isystem/__utility/convert_to_integral.h b/libc/isystem/__utility/convert_to_integral.h
deleted file mode 100644
index 8e425f3a1..000000000
--- a/libc/isystem/__utility/convert_to_integral.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/convert_to_integral.h"
diff --git a/libc/isystem/__utility/declval.h b/libc/isystem/__utility/declval.h
deleted file mode 100644
index 29abde632..000000000
--- a/libc/isystem/__utility/declval.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/declval.h"
diff --git a/libc/isystem/__utility/exception_guard.h b/libc/isystem/__utility/exception_guard.h
deleted file mode 100644
index 3d82c94ab..000000000
--- a/libc/isystem/__utility/exception_guard.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/exception_guard.h"
diff --git a/libc/isystem/__utility/exchange.h b/libc/isystem/__utility/exchange.h
deleted file mode 100644
index 1829ac4c4..000000000
--- a/libc/isystem/__utility/exchange.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/exchange.h"
diff --git a/libc/isystem/__utility/forward.h b/libc/isystem/__utility/forward.h
deleted file mode 100644
index 78304269e..000000000
--- a/libc/isystem/__utility/forward.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/forward.h"
diff --git a/libc/isystem/__utility/forward_like.h b/libc/isystem/__utility/forward_like.h
deleted file mode 100644
index c7704f6c4..000000000
--- a/libc/isystem/__utility/forward_like.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/forward_like.h"
diff --git a/libc/isystem/__utility/in_place.h b/libc/isystem/__utility/in_place.h
deleted file mode 100644
index b00e62b97..000000000
--- a/libc/isystem/__utility/in_place.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/in_place.h"
diff --git a/libc/isystem/__utility/integer_sequence.h b/libc/isystem/__utility/integer_sequence.h
deleted file mode 100644
index ff7f69662..000000000
--- a/libc/isystem/__utility/integer_sequence.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/integer_sequence.h"
diff --git a/libc/isystem/__utility/move.h b/libc/isystem/__utility/move.h
deleted file mode 100644
index 73351f46e..000000000
--- a/libc/isystem/__utility/move.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/move.h"
diff --git a/libc/isystem/__utility/pair.h b/libc/isystem/__utility/pair.h
deleted file mode 100644
index cb75842e7..000000000
--- a/libc/isystem/__utility/pair.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/pair.h"
diff --git a/libc/isystem/__utility/piecewise_construct.h b/libc/isystem/__utility/piecewise_construct.h
deleted file mode 100644
index 838a91798..000000000
--- a/libc/isystem/__utility/piecewise_construct.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/piecewise_construct.h"
diff --git a/libc/isystem/__utility/priority_tag.h b/libc/isystem/__utility/priority_tag.h
deleted file mode 100644
index 03113256f..000000000
--- a/libc/isystem/__utility/priority_tag.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/priority_tag.h"
diff --git a/libc/isystem/__utility/rel_ops.h b/libc/isystem/__utility/rel_ops.h
deleted file mode 100644
index fb9995be0..000000000
--- a/libc/isystem/__utility/rel_ops.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/rel_ops.h"
diff --git a/libc/isystem/__utility/swap.h b/libc/isystem/__utility/swap.h
deleted file mode 100644
index 6a8b815a9..000000000
--- a/libc/isystem/__utility/swap.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/swap.h"
diff --git a/libc/isystem/__utility/terminate_on_exception.h b/libc/isystem/__utility/terminate_on_exception.h
deleted file mode 100644
index 7d5ce26b3..000000000
--- a/libc/isystem/__utility/terminate_on_exception.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/terminate_on_exception.h"
diff --git a/libc/isystem/__utility/to_underlying.h b/libc/isystem/__utility/to_underlying.h
deleted file mode 100644
index 2d99d1f1d..000000000
--- a/libc/isystem/__utility/to_underlying.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/to_underlying.h"
diff --git a/libc/isystem/__utility/unreachable.h b/libc/isystem/__utility/unreachable.h
deleted file mode 100644
index a0876cd42..000000000
--- a/libc/isystem/__utility/unreachable.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__utility/unreachable.h"
diff --git a/libc/isystem/__variant/monostate.h b/libc/isystem/__variant/monostate.h
deleted file mode 100644
index b6a59228d..000000000
--- a/libc/isystem/__variant/monostate.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__variant/monostate.h"
diff --git a/libc/isystem/__verbose_abort b/libc/isystem/__verbose_abort
deleted file mode 100644
index 7ce36bffb..000000000
--- a/libc/isystem/__verbose_abort
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/__verbose_abort"
diff --git a/libc/isystem/ammintrin.h b/libc/isystem/ammintrin.h
index 028098a89..c29f7c84a 100644
--- a/libc/isystem/ammintrin.h
+++ b/libc/isystem/ammintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_AMMINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_AMMINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/ammintrin.h"
+#else
 #include "third_party/intel/ammintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_AMMINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/amxcomplexintrin.h b/libc/isystem/amxcomplexintrin.h
new file mode 100644
index 000000000..be8122bd3
--- /dev/null
+++ b/libc/isystem/amxcomplexintrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/amxcomplexintrin.h"
+#else
+#include "third_party/intel/amxcomplexintrin.internal.h"
+#endif
diff --git a/libc/isystem/amxfp16intrin.h b/libc/isystem/amxfp16intrin.h
new file mode 100644
index 000000000..eb25dfc70
--- /dev/null
+++ b/libc/isystem/amxfp16intrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/amxfp16intrin.h"
+#else
+#include "third_party/intel/amxfp16intrin.internal.h"
+#endif
diff --git a/libc/isystem/arm_acle.h b/libc/isystem/arm_acle.h
index 5e695146a..70d0a1ed2 100644
--- a/libc/isystem/arm_acle.h
+++ b/libc/isystem/arm_acle.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_ARM_ACLE_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_ARM_ACLE_H_
+#ifdef __clang__
+#include "third_party/aarch64/clang/arm_acle.h"
+#else
 #include "third_party/aarch64/arm_acle.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_ARM_ACLE_H_ */
diff --git a/libc/isystem/arm_bf16.h b/libc/isystem/arm_bf16.h
index 8177f26c0..bbfdfe6ba 100644
--- a/libc/isystem/arm_bf16.h
+++ b/libc/isystem/arm_bf16.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_ARM_BF16_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_ARM_BF16_H_
+#ifdef __clang__
+#include "third_party/aarch64/clang/arm_bf16.h"
+#else
 #include "third_party/aarch64/arm_bf16.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_ARM_BF16_H_ */
diff --git a/libc/isystem/arm_fp16.h b/libc/isystem/arm_fp16.h
index 2df9b91a2..5c269e35d 100644
--- a/libc/isystem/arm_fp16.h
+++ b/libc/isystem/arm_fp16.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_ARM_FP16_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_ARM_FP16_H_
+#ifdef __clang__
+#include "third_party/aarch64/clang/arm_fp16.h"
+#else
 #include "third_party/aarch64/arm_fp16.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_ARM_FP16_H_ */
diff --git a/libc/isystem/arm_neon.h b/libc/isystem/arm_neon.h
index c59b01ae6..6beff8834 100644
--- a/libc/isystem/arm_neon.h
+++ b/libc/isystem/arm_neon.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_ARM_NEON_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_ARM_NEON_H_
+#ifdef __clang__
+#include "third_party/aarch64/clang/arm_neon.h"
+#else
 #include "third_party/aarch64/arm_neon.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_ARM_NEON_H_ */
diff --git a/libc/isystem/arm_sve.h b/libc/isystem/arm_sve.h
new file mode 100644
index 000000000..2e8fc6d18
--- /dev/null
+++ b/libc/isystem/arm_sve.h
@@ -0,0 +1,8 @@
+#ifndef COSMOPOLITAN_LIBC_ISYSTEM_ARM_SVE_H_
+#define COSMOPOLITAN_LIBC_ISYSTEM_ARM_SVE_H_
+#ifdef __clang__
+#include "third_party/aarch64/clang/arm_sve.h"
+#else
+#include "third_party/aarch64/arm_sve.internal.h"
+#endif
+#endif /* COSMOPOLITAN_LIBC_ISYSTEM_ARM_SVE_H_ */
diff --git a/libc/isystem/arm_vector_types.h b/libc/isystem/arm_vector_types.h
new file mode 100644
index 000000000..b2018e69d
--- /dev/null
+++ b/libc/isystem/arm_vector_types.h
@@ -0,0 +1,8 @@
+#ifndef COSMOPOLITAN_LIBC_ISYSTEM_ARM_VECTOR_TYPES_H_
+#define COSMOPOLITAN_LIBC_ISYSTEM_ARM_VECTOR_TYPES_H_
+#ifdef __clang__
+#include "third_party/aarch64/clang/arm_vector_types.h"
+#else
+#include "third_party/aarch64/arm_vector_types.internal.h"
+#endif
+#endif /* COSMOPOLITAN_LIBC_ISYSTEM_ARM_VECTOR_TYPES_H_ */
diff --git a/libc/isystem/avxifmaintrin.h b/libc/isystem/avxifmaintrin.h
new file mode 100644
index 000000000..8b94c5d8e
--- /dev/null
+++ b/libc/isystem/avxifmaintrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/avxifmaintrin.h"
+#else
+#include "third_party/intel/avxifmaintrin.internal.h"
+#endif
diff --git a/libc/isystem/avxneconvertintrin.h b/libc/isystem/avxneconvertintrin.h
new file mode 100644
index 000000000..fac905bc6
--- /dev/null
+++ b/libc/isystem/avxneconvertintrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/avxneconvertintrin.h"
+#else
+#include "third_party/intel/avxneconvertintrin.internal.h"
+#endif
diff --git a/libc/isystem/avxvnniint16intrin.h b/libc/isystem/avxvnniint16intrin.h
new file mode 100644
index 000000000..b7cce37b7
--- /dev/null
+++ b/libc/isystem/avxvnniint16intrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/avxvnniint16intrin.h"
+#else
+#include "third_party/intel/avxvnniint16intrin.internal.h"
+#endif
diff --git a/libc/isystem/avxvnniint8intrin.h b/libc/isystem/avxvnniint8intrin.h
new file mode 100644
index 000000000..e760b646d
--- /dev/null
+++ b/libc/isystem/avxvnniint8intrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/avxvnniint8intrin.h"
+#else
+#include "third_party/intel/avxvnniint8intrin.internal.h"
+#endif
diff --git a/libc/isystem/barrier b/libc/isystem/barrier
deleted file mode 100644
index 9f7236ad3..000000000
--- a/libc/isystem/barrier
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/barrier"
diff --git a/libc/isystem/bmmintrin.h b/libc/isystem/bmmintrin.h
new file mode 100644
index 000000000..6649e02b0
--- /dev/null
+++ b/libc/isystem/bmmintrin.h
@@ -0,0 +1 @@
+#include "third_party/intel/bmmintrin.internal.h"
diff --git a/libc/isystem/clzerointrin.h b/libc/isystem/clzerointrin.h
index 5c0be5400..5e9b053d6 100644
--- a/libc/isystem/clzerointrin.h
+++ b/libc/isystem/clzerointrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_CLZEROINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_CLZEROINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/clzerointrin.h"
+#else
 #include "third_party/intel/clzerointrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_CLZEROINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/cmpccxaddintrin.h b/libc/isystem/cmpccxaddintrin.h
new file mode 100644
index 000000000..10f4e9b7e
--- /dev/null
+++ b/libc/isystem/cmpccxaddintrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/cmpccxaddintrin.h"
+#else
+#include "third_party/intel/cmpccxaddintrin.internal.h"
+#endif
diff --git a/libc/isystem/complex.h b/libc/isystem/complex.h
index bd8c4569b..417707176 100644
--- a/libc/isystem/complex.h
+++ b/libc/isystem/complex.h
@@ -1,6 +1,6 @@
 #ifndef _COMPLEX_H
 #define _COMPLEX_H
+#include <math.h>
 #include "libc/complex.h"
-#include "libc/imag.internal.h"
-#include "libc/math.h"
+#include "libc/imag.h"
 #endif /* _COMPLEX_H */
diff --git a/libc/isystem/concepts b/libc/isystem/concepts
deleted file mode 100644
index f7d134987..000000000
--- a/libc/isystem/concepts
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/concepts"
diff --git a/libc/isystem/coroutine b/libc/isystem/coroutine
deleted file mode 100644
index e024e6a48..000000000
--- a/libc/isystem/coroutine
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/coroutine"
diff --git a/libc/isystem/cosmo.h b/libc/isystem/cosmo.h
index e8f15be72..5004c0a11 100644
--- a/libc/isystem/cosmo.h
+++ b/libc/isystem/cosmo.h
@@ -60,7 +60,6 @@
 #include "libc/str/utf16.h"
 #include "libc/sysv/errfuns.h"
 #include "net/http/http.h"
-#include "tool/args/args.h"
 
 #ifdef COSMO_ALREADY_DEFINED
 #undef COSMO_ALREADY_DEFINED
diff --git a/libc/isystem/cosmoaudio.h b/libc/isystem/cosmoaudio.h
new file mode 100644
index 000000000..84eabad2e
--- /dev/null
+++ b/libc/isystem/cosmoaudio.h
@@ -0,0 +1 @@
+#include "dsp/audio/cosmoaudio/cosmoaudio.h"
diff --git a/libc/isystem/ctype.h b/libc/isystem/ctype.h
index c375b5004..5fcf04c7a 100644
--- a/libc/isystem/ctype.h
+++ b/libc/isystem/ctype.h
@@ -1,4 +1,4 @@
 #ifndef _CTYPE_H
 #define _CTYPE_H
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 #endif /* _CTYPE_H */
diff --git a/libc/isystem/cuchar b/libc/isystem/cuchar
deleted file mode 100644
index 90ac28fd7..000000000
--- a/libc/isystem/cuchar
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/cuchar"
diff --git a/libc/isystem/emmintrin.h b/libc/isystem/emmintrin.h
index 1c670b16a..5123aa712 100644
--- a/libc/isystem/emmintrin.h
+++ b/libc/isystem/emmintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_EMMINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_EMMINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/emmintrin.h"
+#else
 #include "third_party/intel/emmintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_EMMINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/expected b/libc/isystem/expected
deleted file mode 100644
index 02ac281f6..000000000
--- a/libc/isystem/expected
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/expected"
diff --git a/libc/isystem/float.h b/libc/isystem/float.h
index c1effda08..a5cf995a2 100644
--- a/libc/isystem/float.h
+++ b/libc/isystem/float.h
@@ -1,5 +1,5 @@
 #ifndef _FLOAT_H
 #define _FLOAT_H
-#include "libc/math.h"
+#include <math.h>
 #include "libc/runtime/fenv.h"
 #endif /* _FLOAT_H */
diff --git a/libc/isystem/format b/libc/isystem/format
deleted file mode 100644
index 5e20f807c..000000000
--- a/libc/isystem/format
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/format"
diff --git a/libc/isystem/immintrin.h b/libc/isystem/immintrin.h
index 683eb5a7a..72cb67c80 100644
--- a/libc/isystem/immintrin.h
+++ b/libc/isystem/immintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_IMMINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_IMMINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/immintrin.h"
+#else
 #include "third_party/intel/immintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_IMMINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/iso646.h b/libc/isystem/iso646.h
index 5d203df5f..11e3a77c9 100644
--- a/libc/isystem/iso646.h
+++ b/libc/isystem/iso646.h
@@ -1,4 +1,4 @@
 #ifndef _ISO646_H
 #define _ISO646_H
-#include "libc/iso646.internal.h"
+#include "libc/iso646.h"
 #endif /* _ISO646_H */
diff --git a/libc/isystem/langinfo.h b/libc/isystem/langinfo.h
index 6be085243..fbc4c3d46 100644
--- a/libc/isystem/langinfo.h
+++ b/libc/isystem/langinfo.h
@@ -1,6 +1,4 @@
 #ifndef _LANGINFO_H
 #define _LANGINFO_H
 #include "libc/str/langinfo.h"
-#include "libc/str/locale.h"
-#include "libc/str/nltypes.h"
 #endif /* _LANGINFO_H */
diff --git a/libc/isystem/latch b/libc/isystem/latch
deleted file mode 100644
index 07ec09a4c..000000000
--- a/libc/isystem/latch
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/latch"
diff --git a/libc/isystem/mdspan b/libc/isystem/mdspan
deleted file mode 100644
index abfed35d9..000000000
--- a/libc/isystem/mdspan
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/mdspan"
diff --git a/libc/isystem/memory_resource b/libc/isystem/memory_resource
deleted file mode 100644
index d875d7b72..000000000
--- a/libc/isystem/memory_resource
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/memory_resource"
diff --git a/libc/isystem/mm_malloc.h b/libc/isystem/mm_malloc.h
index 7634fa6de..a81913524 100644
--- a/libc/isystem/mm_malloc.h
+++ b/libc/isystem/mm_malloc.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_MM_MALLOC_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_MM_MALLOC_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/mm_malloc.h"
+#else
 #include "third_party/intel/mm_malloc.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_MM_MALLOC_INTERNAL_H_ */
diff --git a/libc/isystem/mmintrin.h b/libc/isystem/mmintrin.h
index af089e7c6..f4fbbe9d3 100644
--- a/libc/isystem/mmintrin.h
+++ b/libc/isystem/mmintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_MMINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_MMINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/mmintrin.h"
+#else
 #include "third_party/intel/mmintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_MMINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/mwaitxintrin.h b/libc/isystem/mwaitxintrin.h
index 42a5f3e72..aa5d8ef88 100644
--- a/libc/isystem/mwaitxintrin.h
+++ b/libc/isystem/mwaitxintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_MWAITXINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_MWAITXINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/mwaitxintrin.h"
+#else
 #include "third_party/intel/mwaitxintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_MWAITXINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/nmmintrin.h b/libc/isystem/nmmintrin.h
index 0a5ef7c98..f2fcea020 100644
--- a/libc/isystem/nmmintrin.h
+++ b/libc/isystem/nmmintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_NMMINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_NMMINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/nmmintrin.h"
+#else
 #include "third_party/intel/nmmintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_NMMINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/numbers b/libc/isystem/numbers
deleted file mode 100644
index 2e2b78a74..000000000
--- a/libc/isystem/numbers
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/numbers"
diff --git a/libc/isystem/pmmintrin.h b/libc/isystem/pmmintrin.h
index 21e098b7c..5c557dc55 100644
--- a/libc/isystem/pmmintrin.h
+++ b/libc/isystem/pmmintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_PMMINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_PMMINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/pmmintrin.h"
+#else
 #include "third_party/intel/pmmintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_PMMINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/popcntintrin.h b/libc/isystem/popcntintrin.h
index 632667eb0..9583b31e4 100644
--- a/libc/isystem/popcntintrin.h
+++ b/libc/isystem/popcntintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_POPCNTINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_POPCNTINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/popcntintrin.h"
+#else
 #include "third_party/intel/popcntintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_POPCNTINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/prfchiintrin.h b/libc/isystem/prfchiintrin.h
new file mode 100644
index 000000000..059e1e0db
--- /dev/null
+++ b/libc/isystem/prfchiintrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/prfchiintrin.h"
+#else
+#include "third_party/intel/prfchiintrin.internal.h"
+#endif
diff --git a/libc/isystem/ranges b/libc/isystem/ranges
deleted file mode 100644
index d2d911734..000000000
--- a/libc/isystem/ranges
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/ranges"
diff --git a/libc/isystem/raointintrin.h b/libc/isystem/raointintrin.h
new file mode 100644
index 000000000..e9486ee29
--- /dev/null
+++ b/libc/isystem/raointintrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/raointintrin.h"
+#else
+#include "third_party/intel/raointintrin.internal.h"
+#endif
diff --git a/libc/isystem/semaphore b/libc/isystem/semaphore
deleted file mode 100644
index 757c40616..000000000
--- a/libc/isystem/semaphore
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/semaphore"
diff --git a/libc/isystem/sgxintrin.h b/libc/isystem/sgxintrin.h
index 0ba872436..e44b52753 100644
--- a/libc/isystem/sgxintrin.h
+++ b/libc/isystem/sgxintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_SGXINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_SGXINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/sgxintrin.h"
+#else
 #include "third_party/intel/sgxintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_SGXINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/sha512intrin.h b/libc/isystem/sha512intrin.h
new file mode 100644
index 000000000..1b1ed0d39
--- /dev/null
+++ b/libc/isystem/sha512intrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/sha512intrin.h"
+#else
+#include "third_party/intel/sha512intrin.internal.h"
+#endif
diff --git a/libc/isystem/sm3intrin.h b/libc/isystem/sm3intrin.h
new file mode 100644
index 000000000..80271fb9b
--- /dev/null
+++ b/libc/isystem/sm3intrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/sm3intrin.h"
+#else
+#include "third_party/intel/sm3intrin.internal.h"
+#endif
diff --git a/libc/isystem/sm4intrin.h b/libc/isystem/sm4intrin.h
new file mode 100644
index 000000000..2c9100603
--- /dev/null
+++ b/libc/isystem/sm4intrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/sm4intrin.h"
+#else
+#include "third_party/intel/sm4intrin.internal.h"
+#endif
diff --git a/libc/isystem/smmintrin.h b/libc/isystem/smmintrin.h
index fd7d9b648..4fdb44f60 100644
--- a/libc/isystem/smmintrin.h
+++ b/libc/isystem/smmintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_SMMINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_SMMINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/smmintrin.h"
+#else
 #include "third_party/intel/smmintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_SMMINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/source_location b/libc/isystem/source_location
deleted file mode 100644
index 19b35c368..000000000
--- a/libc/isystem/source_location
+++ /dev/null
@@ -1 +0,0 @@
-#include "third_party/libcxx/source_location"
diff --git a/libc/isystem/stdalign.h b/libc/isystem/stdalign.h
index 16874814a..9aeebe101 100644
--- a/libc/isystem/stdalign.h
+++ b/libc/isystem/stdalign.h
@@ -1,4 +1,4 @@
 #ifndef _STDALIGN_H
 #define _STDALIGN_H
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #endif /* _STDALIGN_H */
diff --git a/libc/isystem/sys/poll.h b/libc/isystem/sys/poll.h
index 98177f98c..df9126fb7 100644
--- a/libc/isystem/sys/poll.h
+++ b/libc/isystem/sys/poll.h
@@ -1,5 +1,7 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_SYS_POLL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_SYS_POLL_H_
+#include "libc/calls/weirdtypes.h"
 #include "libc/sock/sock.h"
+#include "libc/sock/struct/pollfd.h"
 #include "libc/sysv/consts/poll.h"
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_SYS_POLL_H_ */
diff --git a/libc/isystem/sys/vfs.h b/libc/isystem/sys/vfs.h
index 9d8ac9412..2904d0feb 100644
--- a/libc/isystem/sys/vfs.h
+++ b/libc/isystem/sys/vfs.h
@@ -1,4 +1,5 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_SYS_VFS_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_SYS_VFS_H_
 #include "libc/calls/struct/statfs.h"
+#include "libc/sysv/consts/st.h"
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_SYS_VFS_H_ */
diff --git a/libc/isystem/tgmath.h b/libc/isystem/tgmath.h
index 28d124486..8721bb944 100644
--- a/libc/isystem/tgmath.h
+++ b/libc/isystem/tgmath.h
@@ -1,7 +1,7 @@
 #ifndef _TGMATH_H
 #define _TGMATH_H
 #include "libc/complex.h"
-#include "libc/imag.internal.h"
+#include "libc/imag.h"
 #include "libc/math.h"
 #if __STDC_VERSION__ + 0 >= 201112
 
diff --git a/libc/isystem/tmmintrin.h b/libc/isystem/tmmintrin.h
index d1279467e..952e63841 100644
--- a/libc/isystem/tmmintrin.h
+++ b/libc/isystem/tmmintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_TMMINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_TMMINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/tmmintrin.h"
+#else
 #include "third_party/intel/tmmintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_TMMINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/usermsrintrin.h b/libc/isystem/usermsrintrin.h
new file mode 100644
index 000000000..d996e157c
--- /dev/null
+++ b/libc/isystem/usermsrintrin.h
@@ -0,0 +1,5 @@
+#ifdef __clang__
+#include "third_party/intel/clang/usermsrintrin.h"
+#else
+#include "third_party/intel/usermsrintrin.internal.h"
+#endif
diff --git a/libc/isystem/wctype.h b/libc/isystem/wctype.h
index ba782a3bc..4de842c45 100644
--- a/libc/isystem/wctype.h
+++ b/libc/isystem/wctype.h
@@ -1,6 +1,4 @@
 #ifndef _WCTYPE_H
 #define _WCTYPE_H
-#include "libc/calls/calls.h"
-#include "libc/fmt/conv.h"
-#include "libc/str/str.h"
+#include "libc/wctype.h"
 #endif /* _WCTYPE_H */
diff --git a/libc/isystem/windowsesque.h b/libc/isystem/windowsesque.h
index f228173de..4b27c516c 100644
--- a/libc/isystem/windowsesque.h
+++ b/libc/isystem/windowsesque.h
@@ -12,6 +12,7 @@
 #include "libc/nt/files.h"
 #include "libc/nt/ipc.h"
 #include "libc/nt/memory.h"
+#include "libc/nt/nls.h"
 #include "libc/nt/paint.h"
 #include "libc/nt/process.h"
 #include "libc/nt/registry.h"
@@ -1420,6 +1421,15 @@
 #define HKEY_CURRENT_CONFIG kNtHkeyCurrentConfig
 #define HKEY_DYN_DATA kNtHkeyDynData
 #define HKEY_CURRENT_USER_LOCAL_SETTINGS kNtHkeyCurrentUserLocalSettings
+#define KEY_QUERY_VALUE kNtKeyQueryValue
+#define KEY_SET_VALUE kNtKeySetValue
+#define KEY_CREATE_SUB_KEY kNtKeyCreateSubKey
+#define KEY_ENUMERATE_SUB_KEYS kNtKeyEnumerateSubKeys
+#define KEY_NOTIFY kNtKeyNotify
+#define KEY_CREATE_LINK kNtKeyCreateLink
+#define KEY_WOW64_32KEY kNtWow6432Key
+#define KEY_WOW64_64KEY kNtWow6464Key
+#define KEY_WOW64_RES kNtWow64Res
 #define KEY_READ kNtKeyRead
 #define KEY_WRITE kNtKeyWrite
 #define KEY_EXECUTE kNtKeyExecute
@@ -4291,6 +4301,13 @@
 #define MAKE_HRESULT(sev,fac,code) ((HRESULT) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )
 #define MAKE_SCODE(sev,fac,code) ((SCODE) (((unsigned long)(sev)<<31) | ((unsigned long)(fac)<<16) | ((unsigned long)(code))) )
 
+#define CP_ACP        0
+#define CP_OEMCP      1
+#define CP_MACCP      2
+#define CP_THREAD_ACP 3
+#define CP_SYMBOL     42
+
+#define CP_UTF7 65000
 #define CP_UTF8 65001
 
 #endif /* COSMOPOLITAN_LIBC_COMPAT_INCLUDE_WINDOWS_H_ */
diff --git a/libc/isystem/wmmintrin.h b/libc/isystem/wmmintrin.h
index 8c4f60e00..15ed4a9fe 100644
--- a/libc/isystem/wmmintrin.h
+++ b/libc/isystem/wmmintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_WMMINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_WMMINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/wmmintrin.h"
+#else
 #include "third_party/intel/wmmintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_WMMINTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/x86intrin.h b/libc/isystem/x86intrin.h
index fb8c3f971..da763450b 100644
--- a/libc/isystem/x86intrin.h
+++ b/libc/isystem/x86intrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_X86INTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_X86INTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/x86intrin.h"
+#else
 #include "third_party/intel/x86intrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_X86INTRIN_INTERNAL_H_ */
diff --git a/libc/isystem/xmmintrin.h b/libc/isystem/xmmintrin.h
index 594e650fd..3f528bcb3 100644
--- a/libc/isystem/xmmintrin.h
+++ b/libc/isystem/xmmintrin.h
@@ -1,4 +1,8 @@
 #ifndef COSMOPOLITAN_LIBC_ISYSTEM_XMMINTRIN_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_ISYSTEM_XMMINTRIN_INTERNAL_H_
+#ifdef __clang__
+#include "third_party/intel/clang/xmmintrin.h"
+#else
 #include "third_party/intel/xmmintrin.internal.h"
+#endif
 #endif /* COSMOPOLITAN_LIBC_ISYSTEM_XMMINTRIN_INTERNAL_H_ */
diff --git a/libc/log/addr2linepath.c b/libc/log/addr2linepath.c
index eb656175e..058b52d80 100644
--- a/libc/log/addr2linepath.c
+++ b/libc/log/addr2linepath.c
@@ -40,7 +40,7 @@ void GetAddr2linePathInit(void) {
   char *res;
   int e = errno;
   const char *env, *cmd, *path;
-  if ((env = getenv("ADDR2LINE"))) {
+  if ((env = secure_getenv("ADDR2LINE"))) {
     cmd = env;
     path = env;
   } else {
diff --git a/libc/log/attachdebugger.c b/libc/log/attachdebugger.c
index 337f6c4e8..6d0238c53 100644
--- a/libc/log/attachdebugger.c
+++ b/libc/log/attachdebugger.c
@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/log/color.internal.h"
 #include "libc/log/gdb.h"
 #include "libc/log/internal.h"
diff --git a/libc/log/backtrace2.c b/libc/log/backtrace2.c
index b3eeac606..34be29c7d 100644
--- a/libc/log/backtrace2.c
+++ b/libc/log/backtrace2.c
@@ -24,10 +24,10 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describebacktrace.internal.h"
-#include "libc/intrin/iscall.internal.h"
+#include "libc/intrin/describebacktrace.h"
+#include "libc/intrin/iscall.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/promises.internal.h"
+#include "libc/intrin/promises.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/backtrace.internal.h"
 #include "libc/log/color.internal.h"
diff --git a/libc/log/backtrace3.c b/libc/log/backtrace3.c
index 37d0c1462..2714e7d33 100644
--- a/libc/log/backtrace3.c
+++ b/libc/log/backtrace3.c
@@ -20,15 +20,17 @@
 #include "libc/calls/calls.h"
 #include "libc/cosmo.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/iscall.internal.h"
+#include "libc/intrin/iscall.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/backtrace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
+#include "libc/mem/alloca.h"
 #include "libc/nexgen32e/gc.internal.h"
 #include "libc/nexgen32e/stackframe.h"
 #include "libc/runtime/memtrack.internal.h"
 #include "libc/runtime/runtime.h"
+#include "libc/runtime/stack.h"
 #include "libc/runtime/symbols.internal.h"
 #include "libc/str/str.h"
 #include "libc/thread/thread.h"
@@ -46,13 +48,13 @@
  * @param st is open symbol table for current executable
  * @return -1 w/ errno if error happened
  */
-dontinstrument int PrintBacktraceUsingSymbols(int fd,
-                                              const struct StackFrame *bp,
-                                              struct SymbolTable *st) {
+int PrintBacktraceUsingSymbols(int fd, const struct StackFrame *bp,
+                               struct SymbolTable *st) {
   size_t gi;
+  char *cxxbuf;
   intptr_t addr;
   const char *name;
-  char cxxbuf[3000];
+  int cxxbufsize = 0;
   int i, symbol, addend;
   struct Garbages *garbage;
   const struct StackFrame *frame;
@@ -91,14 +93,25 @@ dontinstrument int PrintBacktraceUsingSymbols(int fd,
       symbol = 0;
       addend = 0;
     }
-    if ((name = __get_symbol_name(st, symbol)) &&
-        (_weaken(__is_mangled) && _weaken(__is_mangled)(name))) {
-      _weaken(__demangle)(cxxbuf, name, sizeof(cxxbuf));
-      kprintf("%012lx %lx %s%+d\n", frame, addr, cxxbuf, addend);
-      name = cxxbuf;
-    } else {
-      kprintf("%012lx %lx %s%+d\n", frame, addr, name, addend);
+    name = __get_symbol_name(st, symbol);
+#pragma GCC push_options
+#pragma GCC diagnostic ignored "-Walloca-larger-than="
+    // decipher c++ symbols if there's enough stack memory
+    // stack size requirement assumes max_depth's still 20
+    if (_weaken(__demangle) &&    //
+        _weaken(__is_mangled) &&  //
+        _weaken(__is_mangled)(name)) {
+      if (!cxxbufsize)
+        if ((cxxbufsize = __get_safe_size(8192, 8192)) >= 512) {
+          cxxbuf = alloca(cxxbufsize);
+          CheckLargeStackAllocation(cxxbuf, sizeof(cxxbufsize));
+        }
+      if (cxxbufsize >= 512)
+        if (_weaken(__demangle)(cxxbuf, name, cxxbufsize) != -1)
+          name = cxxbuf;
     }
+#pragma GCC pop_options
+    kprintf("%012lx %lx %s%+d\n", frame, addr, name, addend);
   }
   return 0;
 }
diff --git a/libc/log/check.h b/libc/log/check.h
index f4fda0c01..fa482304b 100644
--- a/libc/log/check.h
+++ b/libc/log/check.h
@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_LIBC_LOG_CHECK_H_
 #define COSMOPOLITAN_LIBC_LOG_CHECK_H_
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 COSMOPOLITAN_C_START_
 
 #define CHECK(X, ...)         __CHK(ne, !=, false, "false", !!(X), #X, "" __VA_ARGS__)
diff --git a/libc/log/checkfail.c b/libc/log/checkfail.c
index f1b0d26eb..51cb08efb 100644
--- a/libc/log/checkfail.c
+++ b/libc/log/checkfail.c
@@ -19,8 +19,8 @@
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/intrin/strace.h"
 #include "libc/log/check.h"
 #include "libc/log/color.internal.h"
 #include "libc/log/internal.h"
diff --git a/libc/log/commandvenv.c b/libc/log/commandvenv.c
index e028d89db..f0e2430fc 100644
--- a/libc/log/commandvenv.c
+++ b/libc/log/commandvenv.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/log/log.h"
 #include "libc/mem/mem.h"
diff --git a/libc/log/countbranch.h b/libc/log/countbranch.h
index 403a0c98e..7476e7b41 100644
--- a/libc/log/countbranch.h
+++ b/libc/log/countbranch.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_LIBC_LOG_COUNTBRANCH_H_
 #define COSMOPOLITAN_LIBC_LOG_COUNTBRANCH_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdbool.h"
 COSMOPOLITAN_C_START_
 
diff --git a/libc/log/countbranch_data.S b/libc/log/countbranch_data.S
index eaf3dc078..a0063f7a4 100644
--- a/libc/log/countbranch_data.S
+++ b/libc/log/countbranch_data.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.yoink	countbranch_report
 
diff --git a/libc/log/countbranch_report.c b/libc/log/countbranch_report.c
index a152dbc07..2e1c88158 100644
--- a/libc/log/countbranch_report.c
+++ b/libc/log/countbranch_report.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/log/countbranch.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/alg.h"
 #include "libc/runtime/runtime.h"
diff --git a/libc/log/countexpr.h b/libc/log/countexpr.h
index 51104bcbe..84e0be7fc 100644
--- a/libc/log/countexpr.h
+++ b/libc/log/countexpr.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_LIBC_LOG_COUNTEXPR_H_
 #define COSMOPOLITAN_LIBC_LOG_COUNTEXPR_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/bench.h"
 COSMOPOLITAN_C_START_
 
diff --git a/libc/log/countexpr_data.S b/libc/log/countexpr_data.S
index 72db2252f..2546e06a1 100644
--- a/libc/log/countexpr_data.S
+++ b/libc/log/countexpr_data.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.yoink	countexpr_report
 
diff --git a/libc/log/countexpr_report.c b/libc/log/countexpr_report.c
index 75be60857..e8f151d7f 100644
--- a/libc/log/countexpr_report.c
+++ b/libc/log/countexpr_report.c
@@ -21,7 +21,7 @@
 #include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
 #include "libc/log/countexpr.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdckdint.h"
diff --git a/libc/log/cxaprintexits.c b/libc/log/cxaprintexits.c
index a7be1130c..2264a6bbe 100644
--- a/libc/log/cxaprintexits.c
+++ b/libc/log/cxaprintexits.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bsf.h"
-#include "libc/intrin/cxaatexit.internal.h"
+#include "libc/intrin/cxaatexit.h"
 #include "libc/log/log.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
diff --git a/libc/log/die.c b/libc/log/die.c
index 30458102c..15f86e8e6 100644
--- a/libc/log/die.c
+++ b/libc/log/die.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
-#include "libc/intrin/describebacktrace.internal.h"
+#include "libc/intrin/describebacktrace.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/log/backtrace.internal.h"
 #include "libc/log/internal.h"
diff --git a/libc/log/gdb.h b/libc/log/gdb.h
index 26e252a7c..b7d29fc0c 100644
--- a/libc/log/gdb.h
+++ b/libc/log/gdb.h
@@ -3,7 +3,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/rusage.h"
 #include "libc/dce.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
 #include "libc/sysv/consts/nr.h"
 #include "libc/sysv/consts/w.h"
 COSMOPOLITAN_C_START_
diff --git a/libc/log/gdbexec.c b/libc/log/gdbexec.c
index 0d63a9682..a29bc4f98 100644
--- a/libc/log/gdbexec.c
+++ b/libc/log/gdbexec.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/log/gdb.h"
 #include "libc/log/log.h"
 #include "libc/nexgen32e/stackframe.h"
diff --git a/libc/log/libfatal.internal.h b/libc/log/libfatal.internal.h
index 4c55269c4..bd10073a1 100644
--- a/libc/log/libfatal.internal.h
+++ b/libc/log/libfatal.internal.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_LIBC_LOG_LIBFATAL_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_LOG_LIBFATAL_INTERNAL_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 COSMOPOLITAN_C_START_
 
 forceinline unsigned long __strlen(const char *s) {
diff --git a/libc/log/log.h b/libc/log/log.h
index d8e62f7ea..7f2498cc4 100644
--- a/libc/log/log.h
+++ b/libc/log/log.h
@@ -48,8 +48,6 @@ void PrintGarbage(void);
 void PrintGarbageNumeric(FILE *);
 void PrintWindowsMemory(const char *, size_t);
 
-#ifndef __STRICT_ANSI__
-
 #define _LOG_UNLIKELY(x) __builtin_expect(!!(x), 0)
 
 extern unsigned __log_level; /* log level for runtime check */
@@ -245,7 +243,6 @@ void vffatalf(ARGS, va_list) asm("vflogf") ATTRV relegated wontreturn libcesque;
 #undef ATTR
 #undef ATTRV
 
-#endif /* __STRICT_ANSI__ */
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_LOG_LOG_H_ */
 #endif /* _COSMO_SOURCE */
diff --git a/libc/log/minicrash.c b/libc/log/minicrash.c
index 6a02251ca..e6c7188b0 100644
--- a/libc/log/minicrash.c
+++ b/libc/log/minicrash.c
@@ -21,7 +21,7 @@
 #include "libc/calls/struct/ucontext.internal.h"
 #include "libc/calls/ucontext.h"
 #include "libc/errno.h"
-#include "libc/intrin/describebacktrace.internal.h"
+#include "libc/intrin/describebacktrace.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/log/internal.h"
 #include "libc/log/log.h"
@@ -73,4 +73,5 @@ relegated dontinstrument void __minicrash(int sig, siginfo_t *si, void *arg) {
       ctx ? ctx->uc_mcontext.PC : 0,
       DescribeBacktrace(ctx ? (struct StackFrame *)ctx->uc_mcontext.BP
                             : (struct StackFrame *)__builtin_frame_address(0)));
+  _Exit(1);
 }
diff --git a/libc/log/oncrash_amd64.c b/libc/log/oncrash_amd64.c
index 914e2aa44..f2726bb19 100644
--- a/libc/log/oncrash_amd64.c
+++ b/libc/log/oncrash_amd64.c
@@ -20,6 +20,7 @@
 #include "libc/atomic.h"
 #include "libc/calls/blockcancel.internal.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/siginfo.h"
@@ -32,16 +33,16 @@
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describebacktrace.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describebacktrace.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/backtrace.internal.h"
 #include "libc/log/gdb.h"
 #include "libc/log/internal.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/alloca.h"
 #include "libc/nexgen32e/stackframe.h"
@@ -241,14 +242,14 @@ static relegated void ShowCrashReport(int err, int sig, siginfo_t *si,
     klog(buf, p - buf);
   }
   kprintf("\n");
-  if (!IsWindows()) {
-    __print_maps();
-  }
-  if (__argv) {
-    for (i = 0; i < __argc; ++i) {
+  __print_maps(15);
+  if (g_fds.n)
+    kprintf("\n");
+  __printfds(g_fds.p, g_fds.n);
+  kprintf("\n");
+  if (__argv)
+    for (i = 0; i < __argc; ++i)
       kprintf("%s ", __argv[i]);
-    }
-  }
   kprintf("\n");
 }
 
diff --git a/libc/log/oncrash_arm64.c b/libc/log/oncrash_arm64.c
index 0e6530018..c91f39a92 100644
--- a/libc/log/oncrash_arm64.c
+++ b/libc/log/oncrash_arm64.c
@@ -36,17 +36,18 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describebacktrace.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describebacktrace.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/log/internal.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/stackframe.h"
 #include "libc/runtime/memtrack.internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
 #include "libc/runtime/symbols.internal.h"
+#include "libc/runtime/syslib.internal.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/auxv.h"
@@ -266,7 +267,8 @@ static relegated void __oncrash_impl(int sig, siginfo_t *si, ucontext_t *ctx) {
         if (j)
           Append(b, " ");
         Append(b, "%s%016lx%s x%d%s", ColorRegister(r),
-               ctx->uc_mcontext.regs[r], reset, r, r == 8 || r == 9 ? " " : "");
+               ((uint64_t *)ctx->uc_mcontext.regs)[r], reset, r,
+               r == 8 || r == 9 ? " " : "");
       }
       Append(b, "\n");
     }
@@ -395,12 +397,6 @@ relegated void __oncrash(int sig, siginfo_t *si, void *arg) {
   SpinLock(&lock);
   __oncrash_impl(sig, si, arg);
 
-  // unlike amd64, the instruction pointer on arm64 isn't advanced past
-  // the debugger breakpoint instruction automatically. we need this so
-  // execution can resume after __builtin_trap().
-  if (arg && sig == SIGTRAP)
-    ((ucontext_t *)arg)->uc_mcontext.PC += 4;
-
   // ensure execution doesn't resume for anything but SIGTRAP / SIGQUIT
   if (arg && sig != SIGTRAP && sig != SIGQUIT) {
     if (!IsXnu()) {
diff --git a/libc/log/printwindowsmemory.c b/libc/log/printwindowsmemory.c
index 9ec34dd57..9353b00ee 100644
--- a/libc/log/printwindowsmemory.c
+++ b/libc/log/printwindowsmemory.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/conv.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/memflags.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/struct/memorybasicinformation.h"
@@ -33,8 +33,8 @@ static const struct DescribeFlags kNtMemState[] = {
 };
 
 static const char *DescribeNtMemState(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kNtMemState, ARRAYLEN(kNtMemState), "kNtMem",
-                       x);
+  return _DescribeFlags(buf, 64, kNtMemState, ARRAYLEN(kNtMemState), "kNtMem",
+                        x);
 }
 
 static const struct DescribeFlags kNtMemType[] = {
@@ -44,7 +44,7 @@ static const struct DescribeFlags kNtMemType[] = {
 };
 
 static const char *DescribeNtMemType(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kNtMemType, ARRAYLEN(kNtMemType), "kNtMem", x);
+  return _DescribeFlags(buf, 64, kNtMemType, ARRAYLEN(kNtMemType), "kNtMem", x);
 }
 
 /**
@@ -77,7 +77,7 @@ void PrintWindowsMemory(const char *high, size_t size) {
             mi.AllocationBase, mi.BaseAddress, b[0],
             DescribeNtMemState(b[1], mi.State),
             DescribeNtMemType(b[2], mi.Type),
-            (DescribeNtPageFlags)(b[3], mi.AllocationProtect),
-            (DescribeNtPageFlags)(b[4], mi.Protect), stop);
+            _DescribeNtPageFlags(b[3], mi.AllocationProtect),
+            _DescribeNtPageFlags(b[4], mi.Protect), stop);
   }
 }
diff --git a/libc/log/showcrashreports.c b/libc/log/showcrashreports.c
index bd68fe1b5..7e3340e64 100644
--- a/libc/log/showcrashreports.c
+++ b/libc/log/showcrashreports.c
@@ -33,6 +33,7 @@ __static_yoink("__die");                       // for backtracing
 __static_yoink("ShowBacktrace");               // for backtracing
 __static_yoink("GetSymbolTable");              // for backtracing
 __static_yoink("PrintBacktraceUsingSymbols");  // for backtracing
+__static_yoink("__demangle");                  // for pretty c++ symbols
 __static_yoink("malloc_inspect_all");          // for asan memory origin
 __static_yoink("GetSymbolByAddr");             // for asan memory origin
 #endif
@@ -81,11 +82,7 @@ void ShowCrashReports(void) {
   ss.ss_sp = crashstack;
   unassert(!sigaltstack(&ss, 0));
   InstallCrashHandler(SIGQUIT, 0);
-#ifdef __x86_64__
   InstallCrashHandler(SIGTRAP, 0);
-#else
-  InstallCrashHandler(SIGTRAP, 0);
-#endif
   InstallCrashHandler(SIGFPE, 0);
   InstallCrashHandler(SIGILL, 0);
   InstallCrashHandler(SIGBUS, 0);
diff --git a/libc/log/showcrashreportsearly.S b/libc/log/showcrashreportsearly.S
index 757414263..dfc41fe19 100644
--- a/libc/log/showcrashreportsearly.S
+++ b/libc/log/showcrashreportsearly.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Normally we call ShowCrashReports() from main, but if
 //	there's a crash in a constructor, this will help with
diff --git a/libc/log/startfatal.c b/libc/log/startfatal.c
index 197c61659..7b1bc54d8 100644
--- a/libc/log/startfatal.c
+++ b/libc/log/startfatal.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/log/internal.h"
 #include "libc/thread/thread.h"
 
diff --git a/libc/log/vflogf.c b/libc/log/vflogf.c
index f90b118e3..53eed5421 100644
--- a/libc/log/vflogf.c
+++ b/libc/log/vflogf.c
@@ -25,8 +25,8 @@
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/libgen.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/intrin/strace.h"
 #include "libc/log/internal.h"
 #include "libc/log/log.h"
 #include "libc/math.h"
diff --git a/libc/log/watch-hook.S b/libc/log/watch-hook.S
index e73da1dc8..c8b99ba55 100644
--- a/libc/log/watch-hook.S
+++ b/libc/log/watch-hook.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 __watch_hook:
 	push	%rbp
diff --git a/libc/log/watch.c b/libc/log/watch.c
index 1cc96f767..794242ca2 100644
--- a/libc/log/watch.c
+++ b/libc/log/watch.c
@@ -33,14 +33,14 @@ static char __watch_last[4096];
 
 void __watch_hook(void);
 
-static dontinstrument inline void Copy(char *p, char *q, size_t n) {
+dontinstrument static inline void Copy(char *p, char *q, size_t n) {
   size_t i;
   for (i = 0; i < n; ++i) {
     p[i] = q[i];
   }
 }
 
-static dontinstrument inline int Cmp(char *p, char *q, size_t n) {
+dontinstrument static inline int Cmp(char *p, char *q, size_t n) {
   if (n == 8)
     return READ64LE(p) != READ64LE(q);
   if (n == 4)
diff --git a/libc/mach.internal.h b/libc/mach.h
similarity index 100%
rename from libc/mach.internal.h
rename to libc/mach.h
diff --git a/libc/macho.internal.h b/libc/macho.h
similarity index 100%
rename from libc/macho.internal.h
rename to libc/macho.h
diff --git a/libc/macros.h b/libc/macros.h
new file mode 100644
index 000000000..257007a84
--- /dev/null
+++ b/libc/macros.h
@@ -0,0 +1,548 @@
+#ifndef COSMOPOLITAN_LIBC_MACROS_H_
+#define COSMOPOLITAN_LIBC_MACROS_H_
+#if 0
+/*───────────────────────────────────────────────────────────────────────────│─╗
+│ cosmopolitan § macros                                                    ─╬─│┼
+╚────────────────────────────────────────────────────────────────────────────│*/
+#endif
+
+/**
+ * @fileoverview Common C preprocessor, assembler, and linker macros.
+ */
+
+#ifdef MAX
+#undef MAX
+#endif
+
+#ifdef MIN
+#undef MIN
+#endif
+
+#define TRUE  1
+#define FALSE 0
+
+#define IS2POW(X)       (!((X) & ((X) - 1)))
+#define ROUNDUP(X, K)   (((X) + (K) - 1) & -(K))
+#define ROUNDDOWN(X, K) ((X) & -(K))
+#ifndef __ASSEMBLER__
+#define ABS(X)    ((X) >= 0 ? (X) : -(X))
+#define MIN(X, Y) ((Y) > (X) ? (X) : (Y))
+#define MAX(X, Y) ((Y) < (X) ? (X) : (Y))
+#else
+// The GNU assembler does not grok the ?: ternary operator; furthermore,
+// boolean expressions yield -1 and 0 for "true" and "false", not 1 and 0.
+#define __MAPBOOL(P)      (!!(P) / (!!(P) + !(P)))
+#define __IFELSE(P, X, Y) (__MAPBOOL(P) * (X) + __MAPBOOL(!(P)) * (Y))
+#define MIN(X, Y)         (__IFELSE((Y) > (X), (X), (Y)))
+#define MAX(X, Y)         (__IFELSE((Y) < (X), (X), (Y)))
+#endif
+#define PASTE(A, B)         __PASTE(A, B)
+#define STRINGIFY(A)        __STRINGIFY(A)
+#define EQUIVALENT(X, Y)    (__builtin_constant_p((X) == (Y)) && ((X) == (Y)))
+#define TYPE_BIT(type)      (sizeof(type) * CHAR_BIT)
+#define TYPE_SIGNED(type)   (((type) - 1) < 0)
+#define TYPE_INTEGRAL(type) (((type)0.5) != 0.5)
+
+#define ARRAYLEN(A) \
+  ((sizeof(A) / sizeof(*(A))) / ((unsigned)!(sizeof(A) % sizeof(*(A)))))
+
+#define __STRINGIFY(A) #A
+#define __PASTE(A, B)  A##B
+#ifdef __ASSEMBLER__
+// clang-format off
+
+//	Ends function definition.
+//	@cost	saves 1-3 lines of code
+.macro	.endfn	name:req bnd vis
+ .size	"\name",.-"\name"
+ .type	"\name",@function
+ .ifnb	\bnd
+  .\bnd	"\name"
+ .endif
+ .ifnb	\vis
+  .\vis	"\name"
+ .endif
+.endm
+
+//	Ends variable definition.
+//	@cost	saves 1-3 lines of code
+.macro	.endobj	name:req bnd vis
+ .size	"\name",.-"\name"
+ .type	"\name",@object
+ .ifnb	\bnd
+  .\bnd	"\name"
+ .endif
+ .ifnb	\vis
+  .\vis	"\name"
+ .endif
+.endm
+
+//	Shorthand notation for widely-acknowledged sections.
+.macro	.rodata
+	.section .rodata,"a",@progbits
+.endm
+.macro	.init
+	.section .init,"ax",@progbits
+.endm
+.macro	.real
+	.section .text.real,"ax",@progbits
+.endm
+.macro	.head
+	.section .text.head,"ax",@progbits
+.endm
+.macro	.text.startup
+	.section .text.startup,"ax",@progbits
+.endm
+.macro	.text.exit
+	.section .text.exit,"ax",@progbits
+.endm
+.macro	.firstclass
+	.section .text.hot,"ax",@progbits
+.endm
+.macro	.text.unlikely
+	.section .text.unlikely,"ax",@progbits
+.endm
+.macro	.text.likely
+	.section .text.hot,"ax",@progbits
+.endm
+.macro	.text.modernity
+	.section .text.modernity,"ax",@progbits
+	.balign	16
+.endm
+.macro	.text.antiquity
+	.section .text.antiquity,"ax",@progbits
+.endm
+.macro	.text.hot
+	.section .text.hot,"ax",@progbits
+.endm
+.macro	.preinit_array
+	.section .preinit_array,"a",@init_array
+.endm
+.macro	.init_array
+	.section .init_array,"a",@init_array
+.endm
+.macro	.text.windows
+	.section .text.windows,"ax",@progbits
+.endm
+
+//	Mergeable NUL-terminated UTF-8 string constant section.
+//
+//	@note	linker de-dupes C strings here across whole compile
+//	@note	therefore item/values are reordered w.r.t. link order
+//	@note	therefore no section relative addressing
+.macro	.rodata.str1.1
+	.section .rodata.str1.1,"aMS",@progbits,1
+	.balign	1
+.endm
+
+//	Locates unreferenced code invulnerable to --gc-sections.
+.macro	.keep.text
+	.section .keep.text,"ax",@progbits
+.endm
+
+//	Flags code as only allowed for testing purposes.
+.macro	.testonly
+	.section .test,"ax",@progbits
+.endm
+
+//	Makes code runnable while code morphing.
+.macro	.privileged
+	.section .privileged,"ax",@progbits
+.endm
+
+//	Declares alternative implementation of function.
+//	@param	implement e.g. tinymath_pow
+//	@param	canonical e.g. pow
+.macro	.alias	implement:req canonical:req
+	.equ	\canonical,\implement
+	.weak	\canonical
+.endm
+
+.macro	beg
+	.cfi_startproc
+.endm
+
+.macro	pro
+#if defined(__x86_64__)
+	push	%rbp
+	.cfi_adjust_cfa_offset 8
+	.cfi_rel_offset %rbp,0
+	mov	%rsp,%rbp
+	.cfi_def_cfa_register %rbp
+#elif defined(__aarch64__)
+	stp	x29,x30,[sp,-16]!
+	mov	x29,sp
+	.cfi_adjust_cfa_offset 16
+	.cfi_rel_offset x29,0
+	.cfi_rel_offset x30,8
+#else
+#error "unsupported architecture"
+#endif
+.endm
+
+.macro	epi
+#if defined(__x86_64__)
+	.cfi_def_cfa_register %rsp
+	leave
+	.cfi_adjust_cfa_offset -8
+	.cfi_restore %rbp
+#elif defined(__aarch64__)
+	ldp	x29,x30,[sp],#16
+	.cfi_adjust_cfa_offset -16
+	.cfi_restore x30
+	.cfi_restore x29
+#else
+#error "unsupported architecture"
+#endif
+.endm
+
+.macro	end
+	.cfi_endproc
+.endm
+
+.macro	cpush	reg:req
+	push	\reg
+	.cfi_adjust_cfa_offset 8
+	.cfi_rel_offset \reg,0
+.endm
+
+.macro	cpop	reg:req
+	pop	\reg
+	.cfi_adjust_cfa_offset -8
+	.cfi_restore \reg
+.endm
+
+#ifdef __aarch64__
+.macro	jmp	dest:req
+	b	\dest
+.endm
+#endif
+
+//	Pulls unrelated module into linkage.
+//
+//	In order for this technique to work with --gc-sections, another
+//	module somewhere might want to weakly reference whats yoinked.
+.macro	.yoink	symbol:req
+	.section .yoink
+#ifdef __x86_64__
+	nopl	"\symbol"(%rip)
+#elif defined(__aarch64__)
+	b	"\symbol"
+#endif
+	.previous
+.endm
+
+//	Begins definition of frameless function that calls no functions.
+.macro	.leafprologue
+#if !(defined(TINY) && !defined(__PG__))
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+#elif defined(__aarch64__)
+	stp	x29,x30,[sp,#-16]!
+	mov	x29,sp
+#endif
+#endif
+.endm
+
+//	Ends definition of frameless function that calls no functions.
+.macro	.leafepilogue
+#if !(defined(TINY) && !defined(__PG__))
+#ifdef __x86_64__
+	pop	%rbp
+#elif defined(__aarch64__)
+	ldp	x29,x30,[sp],#16
+#endif
+#endif
+	ret
+.endm
+
+//	Documents unreachable assembly code.
+.macro	.unreachable
+#if !defined(NDEBUG) && defined(__x86_64__)
+	ud2		// crash if contract is broken
+#elif !defined(NDEBUG) && defined(__aarch64__)
+	brk	#1000
+#elif defined(__FNO_OMIT_FRAME_POINTER__) && defined(__x86_64__)
+	nop		// avoid noreturn tail call backtrace ambiguity
+#endif
+.endm
+
+//	Embeds Fixed-Width Zero-Padded String.
+//	@note	.fxstr is better
+.macro	.ascin str:req fieldsize:req
+1347:	.ascii	"\str"
+ .org	1347b+\fieldsize,0x00
+.endm
+
+//	Inserts --ftrace pre-prologue.
+//	This goes immediately before the function symbol.
+//	@see	.ftrace2
+.macro	.ftrace1
+#ifdef FTRACE
+#ifdef __x86_64__
+	.rept	9
+	nop
+	.endr
+#elif defined(__aarch64__)
+	.rept	6
+	nop
+	.endr
+#endif /* __x86_64__ */
+#endif /* FTRACE */
+.endm
+
+//	Inserts --ftrace prologue.
+//	This goes immediately after the function symbol.
+//	@see	.ftrace1
+.macro	.ftrace2
+#ifdef FTRACE
+#ifdef __x86_64__
+	xchg	%ax,%ax
+#elif defined(__aarch64__)
+	nop
+#endif /* __x86_64__ */
+#endif /* FTRACE */
+.endm
+
+#ifdef __x86_64__
+
+#if __MNO_VZEROUPPER__ + 0
+#define vzeroupper
+#endif
+
+//	Mergeable numeric constant sections.
+//
+//	@note	linker de-dupes item/values across whole compile
+//	@note	therefore item/values are reordered w.r.t. link order
+//	@note	therefore no section relative addressing
+.macro	.rodata.cst4
+	.section .rodata.cst4,"aM",@progbits,4
+	.balign	4
+.endm
+.macro	.rodata.cst8
+	.section .rodata.cst8,"aM",@progbits,8
+	.balign	8
+.endm
+.macro	.rodata.cst16
+	.section .rodata.cst16,"aM",@progbits,16
+	.balign	16
+.endm
+.macro	.rodata.cst32
+	.section .rodata.cst32,"aM",@progbits,32
+	.balign	32
+.endm
+.macro	.rodata.cst64
+	.section .rodata.cst64,"aM",@progbits,64
+	.balign	64
+.endm
+.macro	.tdata
+	.section .tdata,"awT",@progbits
+	.balign	4
+.endm
+.macro	.tbss
+	.section .tdata,"awT",@nobits
+	.balign	4
+.endm
+
+//	Helpers for Cosmopolitan _init() amalgamation magic.
+//	@param	name should be consistent across macros for a module
+//	@see	libc/runtime/_init.S
+.macro	.initro number:req name:req
+	.section ".initro.\number\().\name","a",@progbits
+	.balign	8
+.endm
+.macro	.initbss number:req name:req
+	.section ".piro.bss.init.2.\number\().\name","aw",@nobits
+	.balign	8
+.endm
+.macro	.init.start number:req name:req
+	.section ".init.\number\().\name","ax",@progbits
+"\name":
+.endm
+.macro	.init.end number:req name:req bnd=globl vis
+	.endfn	"\name",\bnd,\vis
+	.previous
+.endm
+
+//	LOOP Instruction Replacement.
+.macro	.loop	label:req
+	.byte	0x83
+	.byte	0xe9
+	.byte	0x01
+	jnz	\label
+.endm
+
+//	Pushes CONSTEXPR ∈ [-128,127].
+//	@note	assembler is wrong for non-literal constexprs
+.macro	pushb	x:req
+	.byte	0x6a
+	.byte	\x
+.endm
+
+//	Sign-extends CONSTEXPR ∈ [-128,127] to REGISTER.
+//	@cost	≥1 cycles, -2 bytes
+.macro	pushpop	constexpr:req register:req
+	pushb	\constexpr
+	pop	\register
+.endm
+
+//	Moves REGISTER to REGISTER.
+//	@cost	≥1 cycles, -1 REX byte
+.macro	movpp	src:req dest:req
+	push	\src
+	pop	\dest
+.endm
+
+//	Embeds fixed-width zero-filled string table.
+//	@note	zero-padded ≠ nul-terminated
+.macro	.fxstr	width head rest:vararg
+ .ifnb	\head
+0:	.ascii	"\head"
+	.org	0b+\width
+	.fxstr	\width,\rest
+ .endif
+.endm
+
+//	Marks symbols as object en-masse.
+//	@note	zero-padded ≠ nul-terminated
+.macro	.object	symbol rest:vararg
+ .ifnb	\symbol
+	.type	\symbol,@object
+	.object	\rest
+ .endif
+.endm
+
+//	Pads function prologue unconditionally for runtime hooking.
+//	@cost	≥0.3 cycles, 5 bytes
+//	@see	.ftrace1
+.macro	.hookable
+	.byte	0x0f
+	.byte	0x1f
+	.byte	0x44
+	.byte	0x00
+	.byte	0x00
+.endm
+
+//	Puts initialized data in uninitialized data section.
+.macro	.bsdata	name:req expr:req bnd vis
+  .section ".initbss.300._init_\name","aw",@nobits
+"\name":
+	.quad	0
+	.endobj	"\name",\bnd,\vis
+  .previous
+  .section ".initro.300._init_\name","a",@progbits
+	.quad	\expr
+  .previous
+  .section ".init.300._init_\name","ax",@progbits
+"_init_\name":
+	movsq
+	.endfn	"_init_\name"
+  .previous
+.endm
+
+//	ICE Breakpoint.
+//	Modern gas forgot this but objdump knows
+//	@mode	long,legacy,real
+	.macro	icebp
+	.byte	0xF1
+	.endm
+	.macro	int1
+	icebp
+	.endm
+
+//	Sets breakpoint for software debugger.
+//	@mode	long,legacy,real
+.macro	.softicebp
+	.byte	0x53		# push bx
+	.byte	0x87		# xchg bx,bx (bochs breakpoint)
+	.byte	0xdb
+	.byte	0x5b		# pop bx
+	.byte	0x66		# xchg ax,ax (microsoft breakpoint)
+	.byte	0x90
+	int3			# gdb breakpoint
+.endm
+
+//	Assembles Intel Official 4-Byte NOP.
+.macro	fatnop4
+ .byte	0x0f,0x1f,0x40,0x00
+.endm
+
+//	Calls Windows function.
+//
+//	@param	cx,dx,r8,r9,stack
+//	@return	ax
+//	@clob	ax,cx,dx,r8-r11
+.macro	ntcall	symbol:req
+	sub	$32,%rsp
+	call	*\symbol(%rip)
+	add	$32,%rsp
+.endm
+
+//	Custom emulator instruction for bottom stack frame.
+.macro	bofram	endfunc:req
+	.byte	0x0f,0x1f,0105,\endfunc-.	# nopl disp8(%rbp)
+.endm
+
+//	Good alignment for functions where alignment actually helps.
+//	@note 16-byte
+.macro	.alignfunc
+#ifndef	__OPTIMIZE_SIZE__
+	.p2align 4
+#endif
+.endm
+
+//	TODO(jart): delete
+//	Loads Effective Address
+//	Supporting security blankets
+.macro	ezlea	symbol:req reg:req
+#if	__pic__ + __pie__ + __code_model_medium__ + __code_model_large__ + 0 > 1
+//	lea	\symbol(%rip),%r\reg
+	mov	$\symbol,%e\reg
+#else
+	mov	$\symbol,%e\reg
+#endif
+.endm
+
+//	Loads address of linktime mergeable string literal into register.
+.macro	loadstr	text:req reg:req regsz bias=0
+ .section .rodata.str1.1,"aSM",@progbits,1
+  .type	.Lstr\@,@object
+.Lstr\@: .asciz	"\text"
+.Lstr\@.size = .-.Lstr\@ - 1
+  .size	.Lstr\@,.-.Lstr\@
+ .previous
+	ezlea	.Lstr\@,\reg
+ .ifnb	\regsz
+#ifdef	__OPTIMIZE_SIZE__
+  .if	.Lstr\@.size + \bias < 128
+	pushpop	.Lstr\@.size,%r\regsz
+  .else
+	mov	$.Lstr\@.size,%e\regsz
+  .endif
+#else
+	mov	$.Lstr\@.size,%e\regsz
+#endif
+ .endif
+.endm
+
+.macro	.poison	name:req kind:req
+.endm
+
+.macro	.underrun
+.endm
+
+.macro	.overrun
+.endm
+
+#else
+
+.macro	.underrun
+.endm
+.macro	.overrun
+.endm
+
+// clang-format on
+#endif /* __x86_64__ */
+#endif /* __ASSEMBLER__ */
+#endif /* COSMOPOLITAN_LIBC_MACROS_H_ */
diff --git a/libc/macros.internal.h b/libc/macros.internal.h
deleted file mode 100644
index cf00d0364..000000000
--- a/libc/macros.internal.h
+++ /dev/null
@@ -1,509 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_MACROS_H_
-#define COSMOPOLITAN_LIBC_MACROS_H_
-#if 0
-/*───────────────────────────────────────────────────────────────────────────│─╗
-│ cosmopolitan § macros                                                    ─╬─│┼
-╚────────────────────────────────────────────────────────────────────────────│*/
-#endif
-
-/**
- * @fileoverview Common C preprocessor, assembler, and linker macros.
- */
-
-#ifdef MAX
-#undef MAX
-#endif
-
-#ifdef MIN
-#undef MIN
-#endif
-
-#define TRUE  1
-#define FALSE 0
-
-#define IS2POW(X)       (!((X) & ((X) - 1)))
-#define ROUNDUP(X, K)   (((X) + (K) - 1) & -(K))
-#define ROUNDDOWN(X, K) ((X) & -(K))
-#ifndef __ASSEMBLER__
-#define ABS(X)    ((X) >= 0 ? (X) : -(X))
-#define MIN(X, Y) ((Y) > (X) ? (X) : (Y))
-#define MAX(X, Y) ((Y) < (X) ? (X) : (Y))
-#else
-// The GNU assembler does not grok the ?: ternary operator; furthermore,
-// boolean expressions yield -1 and 0 for "true" and "false", not 1 and 0.
-#define __MAPBOOL(P)      (!!(P) / (!!(P) + !(P)))
-#define __IFELSE(P, X, Y) (__MAPBOOL(P) * (X) + __MAPBOOL(!(P)) * (Y))
-#define MIN(X, Y)         (__IFELSE((Y) > (X), (X), (Y)))
-#define MAX(X, Y)         (__IFELSE((Y) < (X), (X), (Y)))
-#endif
-#define PASTE(A, B)         __PASTE(A, B)
-#define STRINGIFY(A)        __STRINGIFY(A)
-#define EQUIVALENT(X, Y)    (__builtin_constant_p((X) == (Y)) && ((X) == (Y)))
-#define TYPE_BIT(type)      (sizeof(type) * CHAR_BIT)
-#define TYPE_SIGNED(type)   (((type) - 1) < 0)
-#define TYPE_INTEGRAL(type) (((type)0.5) != 0.5)
-
-#define ARRAYLEN(A) \
-  ((sizeof(A) / sizeof(*(A))) / ((unsigned)!(sizeof(A) % sizeof(*(A)))))
-
-#define __STRINGIFY(A) #A
-#define __PASTE(A, B)  A##B
-#ifdef __ASSEMBLER__
-// clang-format off
-
-//	Ends function definition.
-//	@cost	saves 1-3 lines of code
-.macro	.endfn	name:req bnd vis
- .size	"\name",.-"\name"
- .type	"\name",@function
- .ifnb	\bnd
-  .\bnd	"\name"
- .endif
- .ifnb	\vis
-  .\vis	"\name"
- .endif
-.endm
-
-//	Ends variable definition.
-//	@cost	saves 1-3 lines of code
-.macro	.endobj	name:req bnd vis
- .size	"\name",.-"\name"
- .type	"\name",@object
- .ifnb	\bnd
-  .\bnd	"\name"
- .endif
- .ifnb	\vis
-  .\vis	"\name"
- .endif
-.endm
-
-//	Shorthand notation for widely-acknowledged sections.
-.macro	.rodata
-	.section .rodata,"a",@progbits
-.endm
-.macro	.init
-	.section .init,"ax",@progbits
-.endm
-.macro	.real
-	.section .text.real,"ax",@progbits
-.endm
-.macro	.head
-	.section .text.head,"ax",@progbits
-.endm
-.macro	.text.startup
-	.section .text.startup,"ax",@progbits
-.endm
-.macro	.text.exit
-	.section .text.exit,"ax",@progbits
-.endm
-.macro	.firstclass
-	.section .text.hot,"ax",@progbits
-.endm
-.macro	.text.unlikely
-	.section .text.unlikely,"ax",@progbits
-.endm
-.macro	.text.likely
-	.section .text.hot,"ax",@progbits
-.endm
-.macro	.text.modernity
-	.section .text.modernity,"ax",@progbits
-	.balign	16
-.endm
-.macro	.text.antiquity
-	.section .text.antiquity,"ax",@progbits
-.endm
-.macro	.text.hot
-	.section .text.hot,"ax",@progbits
-.endm
-.macro	.preinit_array
-	.section .preinit_array,"a",@init_array
-.endm
-.macro	.init_array
-	.section .init_array,"a",@init_array
-.endm
-.macro	.text.windows
-	.section .text.windows,"ax",@progbits
-.endm
-
-//	Mergeable NUL-terminated UTF-8 string constant section.
-//
-//	@note	linker de-dupes C strings here across whole compile
-//	@note	therefore item/values are reordered w.r.t. link order
-//	@note	therefore no section relative addressing
-.macro	.rodata.str1.1
-	.section .rodata.str1.1,"aMS",@progbits,1
-	.balign	1
-.endm
-
-//	Locates unreferenced code invulnerable to --gc-sections.
-.macro	.keep.text
-	.section .keep.text,"ax",@progbits
-.endm
-
-//	Flags code as only allowed for testing purposes.
-.macro	.testonly
-	.section .test,"ax",@progbits
-.endm
-
-//	Makes code runnable while code morphing.
-.macro	.privileged
-	.section .privileged,"ax",@progbits
-.endm
-
-//	Declares alternative implementation of function.
-//	@param	implement e.g. tinymath_pow
-//	@param	canonical e.g. pow
-.macro	.alias	implement:req canonical:req
-	.equ	\canonical,\implement
-	.weak	\canonical
-.endm
-
-#ifdef __aarch64__
-.macro	jmp	dest:req
-	b	\dest
-.endm
-#endif
-
-//	Pulls unrelated module into linkage.
-//
-//	In order for this technique to work with --gc-sections, another
-//	module somewhere might want to weakly reference whats yoinked.
-.macro	.yoink	symbol:req
-	.section .yoink
-#ifdef __x86_64__
-	nopl	"\symbol"(%rip)
-#elif defined(__aarch64__)
-	b	"\symbol"
-#endif
-	.previous
-.endm
-
-//	Begins definition of frameless function that calls no functions.
-.macro	.leafprologue
-#if !(defined(TINY) && !defined(__PG__))
-#ifdef __x86_64__
-	push	%rbp
-	mov	%rsp,%rbp
-#elif defined(__aarch64__)
-	stp	x29,x30,[sp,#-16]!
-	mov	x29,sp
-#endif
-#endif
-.endm
-
-//	Ends definition of frameless function that calls no functions.
-.macro	.leafepilogue
-#if !(defined(TINY) && !defined(__PG__))
-#ifdef __x86_64__
-	pop	%rbp
-#elif defined(__aarch64__)
-	ldp	x29,x30,[sp],#16
-#endif
-#endif
-	ret
-.endm
-
-//	Documents unreachable assembly code.
-.macro	.unreachable
-#if !defined(NDEBUG) && defined(__x86_64__)
-	ud2		// crash if contract is broken
-#elif !defined(NDEBUG) && defined(__aarch64__)
-	brk	#1000
-#elif defined(__FNO_OMIT_FRAME_POINTER__) && defined(__x86_64__)
-	nop		// avoid noreturn tail call backtrace ambiguity
-#endif
-.endm
-
-//	Embeds Fixed-Width Zero-Padded String.
-//	@note	.fxstr is better
-.macro	.ascin str:req fieldsize:req
-1347:	.ascii	"\str"
- .org	1347b+\fieldsize,0x00
-.endm
-
-//	Inserts --ftrace pre-prologue.
-//	This goes immediately before the function symbol.
-//	@see	.ftrace2
-.macro	.ftrace1
-#ifdef FTRACE
-#ifdef __x86_64__
-	.rept	9
-	nop
-	.endr
-#elif defined(__aarch64__)
-	.rept	6
-	nop
-	.endr
-#endif /* __x86_64__ */
-#endif /* FTRACE */
-.endm
-
-//	Inserts --ftrace prologue.
-//	This goes immediately after the function symbol.
-//	@see	.ftrace1
-.macro	.ftrace2
-#ifdef FTRACE
-#ifdef __x86_64__
-	xchg	%ax,%ax
-#elif defined(__aarch64__)
-	nop
-#endif /* __x86_64__ */
-#endif /* FTRACE */
-.endm
-
-#ifdef __x86_64__
-
-#if __MNO_VZEROUPPER__ + 0
-#define vzeroupper
-#endif
-
-//	Mergeable numeric constant sections.
-//
-//	@note	linker de-dupes item/values across whole compile
-//	@note	therefore item/values are reordered w.r.t. link order
-//	@note	therefore no section relative addressing
-.macro	.rodata.cst4
-	.section .rodata.cst4,"aM",@progbits,4
-	.balign	4
-.endm
-.macro	.rodata.cst8
-	.section .rodata.cst8,"aM",@progbits,8
-	.balign	8
-.endm
-.macro	.rodata.cst16
-	.section .rodata.cst16,"aM",@progbits,16
-	.balign	16
-.endm
-.macro	.rodata.cst32
-	.section .rodata.cst32,"aM",@progbits,32
-	.balign	32
-.endm
-.macro	.rodata.cst64
-	.section .rodata.cst64,"aM",@progbits,64
-	.balign	64
-.endm
-.macro	.tdata
-	.section .tdata,"awT",@progbits
-	.balign	4
-.endm
-.macro	.tbss
-	.section .tdata,"awT",@nobits
-	.balign	4
-.endm
-
-//	Loads address of errno into %rcx
-.macro	.errno
-	call	__errno_location
-.endm
-
-//	Post-Initialization Read-Only (PIRO) BSS section.
-//	@param	ss is an optional string, for control image locality
-.macro	.piro	ss
- .ifnb	\ss
-	.section .piro.sort.bss.\ss,"aw",@nobits
- .else
-	.section .piro.bss,"aw",@nobits
- .endif
-.endm
-
-//	Helpers for Cosmopolitan _init() amalgamation magic.
-//	@param	name should be consistent across macros for a module
-//	@see	libc/runtime/_init.S
-.macro	.initro number:req name:req
-	.section ".initro.\number\().\name","a",@progbits
-	.balign	8
-.endm
-.macro	.initbss number:req name:req
-	.section ".piro.bss.init.2.\number\().\name","aw",@nobits
-	.balign	8
-.endm
-.macro	.init.start number:req name:req
-	.section ".init.\number\().\name","ax",@progbits
-"\name":
-.endm
-.macro	.init.end number:req name:req bnd=globl vis
-	.endfn	"\name",\bnd,\vis
-	.previous
-.endm
-
-//	LOOP Instruction Replacement.
-.macro	.loop	label:req
-	.byte	0x83
-	.byte	0xe9
-	.byte	0x01
-	jnz	\label
-.endm
-
-//	Pushes CONSTEXPR ∈ [-128,127].
-//	@note	assembler is wrong for non-literal constexprs
-.macro	pushb	x:req
-	.byte	0x6a
-	.byte	\x
-.endm
-
-//	Sign-extends CONSTEXPR ∈ [-128,127] to REGISTER.
-//	@cost	≥1 cycles, -2 bytes
-.macro	pushpop	constexpr:req register:req
-	pushb	\constexpr
-	pop	\register
-.endm
-
-//	Moves REGISTER to REGISTER.
-//	@cost	≥1 cycles, -1 REX byte
-.macro	movpp	src:req dest:req
-	push	\src
-	pop	\dest
-.endm
-
-//	Embeds fixed-width zero-filled string table.
-//	@note	zero-padded ≠ nul-terminated
-.macro	.fxstr	width head rest:vararg
- .ifnb	\head
-0:	.ascii	"\head"
-	.org	0b+\width
-	.fxstr	\width,\rest
- .endif
-.endm
-
-//	Marks symbols as object en-masse.
-//	@note	zero-padded ≠ nul-terminated
-.macro	.object	symbol rest:vararg
- .ifnb	\symbol
-	.type	\symbol,@object
-	.object	\rest
- .endif
-.endm
-
-//	Pads function prologue unconditionally for runtime hooking.
-//	@cost	≥0.3 cycles, 5 bytes
-//	@see	.ftrace1
-.macro	.hookable
-	.byte	0x0f
-	.byte	0x1f
-	.byte	0x44
-	.byte	0x00
-	.byte	0x00
-.endm
-
-//	Puts initialized data in uninitialized data section.
-.macro	.bsdata	name:req expr:req bnd vis
-  .section ".initbss.300._init_\name","aw",@nobits
-"\name":
-	.quad	0
-	.endobj	"\name",\bnd,\vis
-  .previous
-  .section ".initro.300._init_\name","a",@progbits
-	.quad	\expr
-  .previous
-  .section ".init.300._init_\name","ax",@progbits
-"_init_\name":
-	movsq
-	.endfn	"_init_\name"
-  .previous
-.endm
-
-//	ICE Breakpoint.
-//	Modern gas forgot this but objdump knows
-//	@mode	long,legacy,real
-	.macro	icebp
-	.byte	0xF1
-	.endm
-	.macro	int1
-	icebp
-	.endm
-
-//	Sets breakpoint for software debugger.
-//	@mode	long,legacy,real
-.macro	.softicebp
-	.byte	0x53		# push bx
-	.byte	0x87		# xchg bx,bx (bochs breakpoint)
-	.byte	0xdb
-	.byte	0x5b		# pop bx
-	.byte	0x66		# xchg ax,ax (microsoft breakpoint)
-	.byte	0x90
-	int3			# gdb breakpoint
-.endm
-
-//	Assembles Intel Official 4-Byte NOP.
-.macro	fatnop4
- .byte	0x0f,0x1f,0x40,0x00
-.endm
-
-//	Calls Windows function.
-//
-//	@param	cx,dx,r8,r9,stack
-//	@return	ax
-//	@clob	ax,cx,dx,r8-r11
-.macro	ntcall	symbol:req
-	sub	$32,%rsp
-	call	*\symbol(%rip)
-	add	$32,%rsp
-.endm
-
-//	Custom emulator instruction for bottom stack frame.
-.macro	bofram	endfunc:req
-	.byte	0x0f,0x1f,0105,\endfunc-.	# nopl disp8(%rbp)
-.endm
-
-//	Good alignment for functions where alignment actually helps.
-//	@note 16-byte
-.macro	.alignfunc
-#ifndef	__OPTIMIZE_SIZE__
-	.p2align 4
-#endif
-.endm
-
-//	TODO(jart): delete
-//	Loads Effective Address
-//	Supporting security blankets
-.macro	ezlea	symbol:req reg:req
-#if	__pic__ + __pie__ + __code_model_medium__ + __code_model_large__ + 0 > 1
-//	lea	\symbol(%rip),%r\reg
-	mov	$\symbol,%e\reg
-#else
-	mov	$\symbol,%e\reg
-#endif
-.endm
-
-//	Loads address of linktime mergeable string literal into register.
-.macro	loadstr	text:req reg:req regsz bias=0
- .section .rodata.str1.1,"aSM",@progbits,1
-  .type	.Lstr\@,@object
-.Lstr\@: .asciz	"\text"
-.Lstr\@.size = .-.Lstr\@ - 1
-  .size	.Lstr\@,.-.Lstr\@
- .previous
-	ezlea	.Lstr\@,\reg
- .ifnb	\regsz
-#ifdef	__OPTIMIZE_SIZE__
-  .if	.Lstr\@.size + \bias < 128
-	pushpop	.Lstr\@.size,%r\regsz
-  .else
-	mov	$.Lstr\@.size,%e\regsz
-  .endif
-#else
-	mov	$.Lstr\@.size,%e\regsz
-#endif
- .endif
-.endm
-
-.macro	.poison	name:req kind:req
-.endm
-
-.macro	.underrun
-.endm
-
-.macro	.overrun
-.endm
-
-#else
-
-.macro	.underrun
-.endm
-.macro	.overrun
-.endm
-
-// clang-format on
-#endif /* __x86_64__ */
-#endif /* __ASSEMBLER__ */
-#endif /* COSMOPOLITAN_LIBC_MACROS_H_ */
diff --git a/libc/math.h b/libc/math.h
index 0b63b361a..6b8539a5e 100644
--- a/libc/math.h
+++ b/libc/math.h
@@ -159,10 +159,7 @@ typedef double double_t;
 #define fpclassify(x) \
   __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x)
 
-#define signbit(x)                                          \
-  (sizeof(x) == sizeof(long double) ? __builtin_signbitl(x) \
-   : sizeof(x) == sizeof(float)     ? __builtin_signbitf(x) \
-                                    : __builtin_signbit(x))
+#define signbit(x) __builtin_signbit(x)
 
 extern int signgam;
 
diff --git a/libc/mem/BUILD.mk b/libc/mem/BUILD.mk
index 438837a7a..52f2ff9f4 100644
--- a/libc/mem/BUILD.mk
+++ b/libc/mem/BUILD.mk
@@ -42,7 +42,8 @@ $(LIBC_MEM_A_OBJS): private				\
 		COPTS +=				\
 			-fno-sanitize=all		\
 			-Wframe-larger-than=4096	\
-			-Walloca-larger-than=4096
+			-Walloca-larger-than=4096	\
+			-fexceptions
 
 o/$(MODE)/libc/mem/asan.o: private			\
 		CFLAGS +=				\
diff --git a/libc/mem/alg.h b/libc/mem/alg.h
index ae519f76f..8a887a524 100644
--- a/libc/mem/alg.h
+++ b/libc/mem/alg.h
@@ -4,14 +4,10 @@ COSMOPOLITAN_C_START_
 
 void *bsearch(const void *, const void *, size_t, size_t,
               int (*)(const void *, const void *)) paramsnonnull() nosideeffect;
-void *bsearch_r(const void *, const void *, size_t, size_t,
-                int (*)(const void *, const void *, void *), void *)
-    paramsnonnull((1, 2, 5)) nosideeffect;
-void djbsort(int32_t *, size_t) libcesque;
-void qsort3(void *, size_t, size_t,
-            int (*)(const void *, const void *)) libcesque paramsnonnull();
-void qsort(void *, size_t, size_t,
-           int (*)(const void *, const void *)) libcesque paramsnonnull();
+void qsort3(void *, size_t, size_t, int (*)(const void *, const void *))
+    paramsnonnull();
+void qsort(void *, size_t, size_t, int (*)(const void *, const void *))
+    paramsnonnull();
 void qsort_r(void *, size_t, size_t,
              int (*)(const void *, const void *, void *), void *)
     paramsnonnull((1, 4));
@@ -25,8 +21,12 @@ int mergesort(void *, size_t, size_t, int (*)(const void *, const void *));
 int mergesort_r(void *, size_t, size_t,
                 int (*)(const void *, const void *, void *), void *);
 
+#ifdef _COSMO_SOURCE
+void djbsort(int32_t *, size_t) libcesque;
 int radix_sort_int32(int32_t *, size_t) libcesque;
 int radix_sort_int64(int64_t *, size_t) libcesque;
+double levenshtein(const char *, const char *) libcesque;
+#endif
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_ALG_ALG_H_ */
diff --git a/libc/mem/aligned_alloc.c b/libc/mem/aligned_alloc.c
index 3432bfbc7..27090f73e 100644
--- a/libc/mem/aligned_alloc.c
+++ b/libc/mem/aligned_alloc.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 
 /**
diff --git a/libc/mem/bisect.internal.h b/libc/mem/bisect.internal.h
deleted file mode 100644
index 2365f82cd..000000000
--- a/libc/mem/bisect.internal.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_ALG_BISECT_H_
-#define COSMOPOLITAN_LIBC_ALG_BISECT_H_
-COSMOPOLITAN_C_START_
-
-forceinline void *bisect(const void *k, const void *data, size_t n, size_t size,
-                         int cmp(const void *a, const void *b, void *arg),
-                         void *arg) {
-  int c;
-  const char *p;
-  ssize_t m, l, r;
-  if (n) {
-    l = 0;
-    r = n - 1;
-    p = data;
-    while (l <= r) {
-      m = (l & r) + ((l ^ r) >> 1);
-      c = cmp(k, p + m * size, arg);
-      if (c > 0) {
-        l = m + 1;
-      } else if (c < 0) {
-        r = m - 1;
-      } else {
-        return (char *)p + m * size;
-      }
-    }
-  }
-  return NULL;
-}
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_ALG_BISECT_H_ */
diff --git a/libc/mem/bsearch.c b/libc/mem/bsearch.c
deleted file mode 100644
index 5bfc7cb82..000000000
--- a/libc/mem/bsearch.c
+++ /dev/null
@@ -1,29 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/mem/alg.h"
-#include "libc/mem/bisect.internal.h"
-
-/**
- * Searches sorted array for exact item in logarithmic time.
- * @see bsearch_r()
- */
-void *bsearch(const void *key, const void *base, size_t nmemb, size_t size,
-              int cmp(const void *a, const void *b)) {
-  return bisect(key, base, nmemb, size, (void *)cmp, NULL);
-}
diff --git a/libc/mem/bsearch_r.c b/libc/mem/bsearch_r.c
deleted file mode 100644
index 832d79edd..000000000
--- a/libc/mem/bsearch_r.c
+++ /dev/null
@@ -1,29 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/mem/alg.h"
-#include "libc/mem/bisect.internal.h"
-
-/**
- * Searches sorted array for exact item in logarithmic time.
- * @see bsearch()
- */
-void *bsearch_r(const void *key, const void *base, size_t nmemb, size_t size,
-                int cmp(const void *a, const void *b, void *arg), void *arg) {
-  return bisect(key, base, nmemb, size, cmp, arg);
-}
diff --git a/libc/mem/calloc.c b/libc/mem/calloc.c
index df578353c..d70aefd3e 100644
--- a/libc/mem/calloc.c
+++ b/libc/mem/calloc.c
@@ -19,6 +19,8 @@
 #include "libc/mem/mem.h"
 #include "third_party/dlmalloc/dlmalloc.h"
 
+__static_yoink("free");
+
 /**
  * Allocates n * itemsize bytes, initialized to zero.
  *
@@ -31,4 +33,3 @@
 void *calloc(size_t n, size_t itemsize) {
   return dlcalloc(n, itemsize);
 }
-
diff --git a/libc/mem/gc.c b/libc/mem/gc.c
index 1ef55198c..7f34d9db5 100644
--- a/libc/mem/gc.c
+++ b/libc/mem/gc.c
@@ -33,28 +33,6 @@ forceinline bool PointerNotOwnedByParentStackFrame(struct StackFrame *frame,
            ((intptr_t)ptr < (intptr_t)parent));
 }
 
-static void TeardownGc(void) {
-  struct Garbages *g;
-  struct CosmoTib *t;
-  if (__tls_enabled) {
-    t = __get_tls();
-    if ((g = t->tib_garbages)) {
-      // exit() currently doesn't use gclongjmp() like pthread_exit()
-      // so we need to run the deferred functions manually.
-      while (g->i) {
-        --g->i;
-        ((void (*)(intptr_t))g->p[g->i].fn)(g->p[g->i].arg);
-      }
-      free(g->p);
-      free(g);
-    }
-  }
-}
-
-__attribute__((__constructor__(51))) static textstartup void InitGc(void) {
-  atexit(TeardownGc);
-}
-
 // add item to garbage shadow stack.
 // then rewrite caller's return address on stack.
 static void DeferFunction(struct StackFrame *frame, void *fn, void *arg) {
diff --git a/libc/runtime/grow.c b/libc/mem/grow.c
similarity index 95%
rename from libc/runtime/grow.c
rename to libc/mem/grow.c
index 1b865d499..1c69653a7 100644
--- a/libc/runtime/grow.c
+++ b/libc/mem/grow.c
@@ -19,8 +19,7 @@
 #include "ape/sections.internal.h"
 #include "libc/assert.h"
 #include "libc/fmt/conv.h"
-#include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdckdint.h"
@@ -53,7 +52,7 @@ bool __grow(void *pp, size_t *capacity, size_t itemsize, size_t extra) {
   n1 = *capacity;
   n2 = (*p ? n1 + (n1 >> 1) : MAX(4, INITIAL_CAPACITY / itemsize)) + extra;
   if (!ckd_mul(&t1, n1, itemsize) && !ckd_mul(&t2, n2, itemsize)) {
-    if (_weaken(realloc) && (p2 = _weaken(realloc)(p1, ROUNDUP(t2, 32)))) {
+    if ((p2 = realloc(p1, ROUNDUP(t2, 32)))) {
       if (!p1 && *p)
         memcpy(p2, *p, t1);
       bzero((char *)p2 + t1, t2 - t1);
diff --git a/libc/mem/leaks.c b/libc/mem/leaks.c
index bb70e05d6..97febe422 100644
--- a/libc/mem/leaks.c
+++ b/libc/mem/leaks.c
@@ -16,16 +16,19 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/mem/leaks.h"
 #include "libc/cxxabi.h"
-#include "libc/intrin/cxaatexit.internal.h"
+#include "libc/intrin/cxaatexit.h"
 #include "libc/intrin/dll.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/weaken.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/typedef/imagetlscallback.h"
 #include "libc/runtime/runtime.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
+#include "libc/thread/tls.h"
 
 #define LEAK_CONTAINER(e) DLL_CONTAINER(struct Leak, elem, e)
 
@@ -37,14 +40,14 @@ struct Leak {
 static int leak_count;
 static struct Dll *leaks;
 static struct Dll *freaks;
-static pthread_mutex_t lock;
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
 void __may_leak(void *alloc) {
   if (!alloc)
     return;
-  pthread_mutex_lock(&lock);
+  _pthread_mutex_lock(&lock);
   if (dll_is_empty(freaks)) {
-    int g = __granularity();
+    int g = __gransize;
     struct Leak *p = _mapanon(g);
     int n = g / sizeof(struct Leak);
     for (int i = 0; i < n; ++i) {
@@ -56,7 +59,7 @@ void __may_leak(void *alloc) {
   LEAK_CONTAINER(e)->alloc = alloc;
   dll_remove(&freaks, e);
   dll_make_first(&leaks, e);
-  pthread_mutex_unlock(&lock);
+  _pthread_mutex_unlock(&lock);
 }
 
 static void visitor(void *start, void *end, size_t used_bytes, void *arg) {
@@ -76,7 +79,7 @@ void CheckForMemoryLeaks(void) {
 
   // validate usage of this api
   if (_weaken(_pthread_decimate))
-    _weaken(_pthread_decimate)();
+    _weaken(_pthread_decimate)(kPosixThreadZombie);
   if (!pthread_orphan_np())
     kprintf("warning: called CheckForMemoryLeaks() from non-orphaned thread\n");
 
@@ -87,8 +90,29 @@ void CheckForMemoryLeaks(void) {
   // check for leaks
   malloc_inspect_all(visitor, 0);
   if (leak_count) {
-    kprintf("loser: you forgot to call free %'d time%s\n", leak_count,
+    kprintf("       you forgot to call free %'d time%s\n", leak_count,
             leak_count == 1 ? "" : "s");
     _exit(73);
   }
 }
+
+static bool IsHoldingLocks(struct CosmoTib *tib) {
+  for (int i = 0; i < ARRAYLEN(tib->tib_locks); ++i)
+    if (tib->tib_locks[i])
+      return true;
+  return false;
+}
+
+/**
+ * Aborts if any locks are held by calling thread.
+ */
+void AssertNoLocksAreHeld(void) {
+  struct CosmoTib *tib = __get_tls();
+  if (IsHoldingLocks(tib)) {
+    kprintf("error: the following locks are held by this thread:\n");
+    for (int i = 0; i < ARRAYLEN(tib->tib_locks); ++i)
+      if (tib->tib_locks[i])
+        kprintf("\t- %t\n", tib->tib_locks[i]);
+    _Exit(74);
+  }
+}
diff --git a/libc/mem/leaks.h b/libc/mem/leaks.h
index dcf2ad464..f77c609d2 100644
--- a/libc/mem/leaks.h
+++ b/libc/mem/leaks.h
@@ -4,6 +4,7 @@
 COSMOPOLITAN_C_START_
 
 void CheckForMemoryLeaks(void) libcesque;
+void AssertNoLocksAreHeld(void) libcesque;
 
 /**
  * Declares that allocation needn't be freed.
diff --git a/libc/mem/levenshtein.c b/libc/mem/levenshtein.c
new file mode 100644
index 000000000..f1e1cc131
--- /dev/null
+++ b/libc/mem/levenshtein.c
@@ -0,0 +1,49 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/mem/alg.h"
+#include "libc/mem/mem.h"
+#include "libc/str/str.h"
+
+#define MIN3(a, b, c) \
+  ((a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c)))
+
+/**
+ * Computes similarity between two strings.
+ */
+double levenshtein(const char *s0, const char *s1) {
+  int n0 = strlen(s0) + 1;
+  int n1 = strlen(s1) + 1;
+  int *col = (int *)malloc(n1 * sizeof(int));
+  int *pol = (int *)malloc(n1 * sizeof(int));
+  for (int i = 0; i < n1; i++)
+    pol[i] = i;
+  for (int i = 0; i < n0; i++) {
+    col[0] = i;
+    for (int j = 1; j < n1; j++)
+      col[j] = MIN3(1 + col[j - 1], 1 + pol[j],
+                    pol[j - 1] + !(i > 0 && s0[i - 1] == s1[j - 1]));
+    int *t = col;
+    col = pol;
+    pol = t;
+  }
+  int dist = pol[n1 - 1];
+  free(pol);
+  free(col);
+  return 1 - dist / ((n0 > n1 ? n0 : n1) - 1.);
+}
diff --git a/libc/mem/malloc.c b/libc/mem/malloc.c
index c843f2fc8..0d3793cf9 100644
--- a/libc/mem/malloc.c
+++ b/libc/mem/malloc.c
@@ -19,6 +19,8 @@
 #include "libc/mem/mem.h"
 #include "third_party/dlmalloc/dlmalloc.h"
 
+__static_yoink("free");
+
 /**
  * Allocates uninitialized memory.
  *
@@ -42,4 +44,3 @@
 void *malloc(size_t n) {
   return dlmalloc(n);
 }
-
diff --git a/libc/mem/memalign.c b/libc/mem/memalign.c
index bdf8f9ff7..94129aaba 100644
--- a/libc/mem/memalign.c
+++ b/libc/mem/memalign.c
@@ -19,6 +19,8 @@
 #include "libc/mem/mem.h"
 #include "third_party/dlmalloc/dlmalloc.h"
 
+__static_yoink("free");
+
 /**
  * Allocates aligned memory.
  *
@@ -35,4 +37,3 @@
 void *memalign(size_t align, size_t bytes) {
   return dlmemalign(align, bytes);
 }
-
diff --git a/libc/mem/mergesort.c b/libc/mem/mergesort.c
index 400b6dfe3..b79e67756 100644
--- a/libc/mem/mergesort.c
+++ b/libc/mem/mergesort.c
@@ -28,7 +28,7 @@
 │ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF       │
 │ SUCH DAMAGE.                                                                 │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
diff --git a/libc/mem/posix_memalign.c b/libc/mem/posix_memalign.c
index 32f9411aa..4cc5b65cb 100644
--- a/libc/mem/posix_memalign.c
+++ b/libc/mem/posix_memalign.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 
 /**
diff --git a/libc/mem/putenv.c b/libc/mem/putenv.c
index 3482f8b99..423b3eb69 100644
--- a/libc/mem/putenv.c
+++ b/libc/mem/putenv.c
@@ -16,9 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/getenv.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/getenv.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/mem/internal.h"
 #include "libc/mem/leaks.h"
 #include "libc/mem/mem.h"
diff --git a/libc/mem/pvalloc.c b/libc/mem/pvalloc.c
index 19479a0da..21346ab29 100644
--- a/libc/mem/pvalloc.c
+++ b/libc/mem/pvalloc.c
@@ -32,9 +32,9 @@
  * @see valloc()
  */
 void *pvalloc(size_t n) {
-  if (ckd_add(&n, n, __granularity() - 1)) {
+  if (ckd_add(&n, n, __pagesize - 1)) {
     errno = ENOMEM;
     return 0;
   }
-  return memalign(__granularity(), n & -__granularity());
+  return memalign(__pagesize, n & -__pagesize);
 }
diff --git a/libc/mem/qsort.c b/libc/mem/qsort.c
index 361f26a86..0a2c1e550 100644
--- a/libc/mem/qsort.c
+++ b/libc/mem/qsort.c
@@ -28,7 +28,7 @@
 │ OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF       │
 │ SUCH DAMAGE.                                                                 │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/str/str.h"
 __static_yoink("openbsd_sorting_notice");
diff --git a/libc/mem/realloc.c b/libc/mem/realloc.c
index 6d7451a8e..b9a4fe7b4 100644
--- a/libc/mem/realloc.c
+++ b/libc/mem/realloc.c
@@ -19,6 +19,8 @@
 #include "libc/mem/mem.h"
 #include "third_party/dlmalloc/dlmalloc.h"
 
+__static_yoink("free");
+
 /**
  * Allocates / resizes / frees memory, e.g.
  *
@@ -60,4 +62,3 @@
 void *realloc(void *p, size_t n) {
   return dlrealloc(p, n);
 }
-
diff --git a/libc/mem/realpath.c b/libc/mem/realpath.c
index 966921565..f74a16e05 100644
--- a/libc/mem/realpath.c
+++ b/libc/mem/realpath.c
@@ -29,7 +29,7 @@
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/log/backtrace.internal.h"
 #include "libc/mem/mem.h"
diff --git a/libc/mem/reverse.internal.h b/libc/mem/reverse.internal.h
index 07861b0ee..cc26e6e11 100644
--- a/libc/mem/reverse.internal.h
+++ b/libc/mem/reverse.internal.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_LIBC_ALG_REVERSE_H_
 #define COSMOPOLITAN_LIBC_ALG_REVERSE_H_
-#include "libc/intrin/xchg.internal.h"
+#include "libc/intrin/xchg.h"
 
 /**
  * Reverses array.
diff --git a/libc/mem/setenv.c b/libc/mem/setenv.c
index 10135428b..971e328ec 100644
--- a/libc/mem/setenv.c
+++ b/libc/mem/setenv.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/mem/internal.h"
 #include "libc/mem/leaks.h"
 #include "libc/mem/mem.h"
diff --git a/libc/mem/shuffle.internal.h b/libc/mem/shuffle.internal.h
deleted file mode 100644
index 229cc91b6..000000000
--- a/libc/mem/shuffle.internal.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_RAND_SHUFFLE_H_
-#define COSMOPOLITAN_LIBC_RAND_SHUFFLE_H_
-#include "libc/intrin/xchg.internal.h"
-
-/**
- * Fisher-Yates shuffle.
- *
- * @param R is a function like rand() → ≥0
- * @param A is a typed array
- * @param n is the number of items in A
- * @see ARRAYLEN()
- */
-#define shuffle(R, A, n)                      \
-  do {                                        \
-    autotype(A) Array = (A);                  \
-    for (size_t i = (n) - 1; i >= 1; --i) {   \
-      xchg(&Array[i], &Array[R() % (i + 1)]); \
-    }                                         \
-  } while (0)
-
-#endif /* COSMOPOLITAN_LIBC_RAND_SHUFFLE_H_ */
diff --git a/libc/mem/tinymalloc.inc b/libc/mem/tinymalloc.inc
index 019a4ec3f..6dd9b984f 100644
--- a/libc/mem/tinymalloc.inc
+++ b/libc/mem/tinymalloc.inc
@@ -16,8 +16,9 @@
 #include "libc/assert.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
+#include "libc/intrin/kprintf.h"
 #include "libc/mem/mem.h"
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
 
@@ -26,15 +27,35 @@
 #endif
 
 #ifndef TINYMALLOC_MAX_ALIGN
-#define TINYMALLOC_MAX_ALIGN 4096
+#define TINYMALLOC_MAX_ALIGN sizeof(max_align_t)
 #endif
 
-alignas(TINYMALLOC_MAX_ALIGN) static struct {
-  char memory[TINYMALLOC_MAX_BYTES];
-  size_t used, last, free;
+#pragma GCC push_options
+#pragma GCC diagnostic ignored "-Wanalyzer-malloc-leak"
+#pragma GCC diagnostic ignored "-Wanalyzer-use-after-free"
+
+static struct {
+  alignas(max_align_t) char bits[TINYMALLOC_MAX_BYTES];
+  char *memory;
+  int once;
+  size_t size, used, last, free;
 } heap;
 
-static inline bool isheap(char *mem) {
+static void tinymalloc_init(void) {
+  int align;
+  if (heap.once)
+    return;
+  align = TINYMALLOC_MAX_ALIGN;
+  heap.memory = (char *)(((uintptr_t)heap.bits + align - 1) & -align);
+  heap.size = sizeof(heap.bits) - (heap.memory - heap.bits);
+  heap.once = 1;
+}
+
+__attribute__((__destructor__)) static void destroy(void) {
+  kprintf("used = %'zu\n", heap.used);
+}
+
+static inline int isheap(char *mem) {
   return heap.memory <= mem && mem < heap.memory + heap.used;
 }
 
@@ -59,6 +80,7 @@ size_t malloc_usable_size(void *ptr) {
 void *memalign(size_t align, size_t need) {
   char *res;
   size_t next, next2, base, toto, *link, *link2;
+  tinymalloc_init();
 
   // normalize arguments
   while (align & (align - 1))
@@ -95,7 +117,7 @@ void *memalign(size_t align, size_t need) {
   base &= -align;
   if (ckd_add(&toto, base, need))
     goto OutOfMemory;
-  if (toto > TINYMALLOC_MAX_BYTES)
+  if (toto > heap.size)
     goto OutOfMemory;
   res = heap.memory + base;
   ((size_t *)res)[-1] = need;
@@ -148,7 +170,7 @@ void *realloc(void *ptr, size_t need) {
       need &= -sizeof(size_t);
       if (ckd_add(&toto, base, need))
         goto OutOfMemory;
-      if (toto > TINYMALLOC_MAX_BYTES)
+      if (toto > heap.size)
         goto OutOfMemory;
       ((size_t *)mem)[-1] = need;
       heap.used = toto;
@@ -165,3 +187,5 @@ OutOfMemory:
   errno = ENOMEM;
   return 0;
 }
+
+#pragma GCC pop_options
diff --git a/libc/mem/valloc.c b/libc/mem/valloc.c
index cc91f5f3e..f8f9e90bf 100644
--- a/libc/mem/valloc.c
+++ b/libc/mem/valloc.c
@@ -29,5 +29,5 @@
  * @see pvalloc()
  */
 void *valloc(size_t n) {
-  return memalign(__granularity(), n);
+  return memalign(__pagesize, n);
 }
diff --git a/libc/nexgen32e/BUILD.mk b/libc/nexgen32e/BUILD.mk
index cf50a81e7..d84d8d853 100644
--- a/libc/nexgen32e/BUILD.mk
+++ b/libc/nexgen32e/BUILD.mk
@@ -71,8 +71,6 @@ o/$(MODE)/libc/nexgen32e/ksha512.o: libc/nexgen32e/ksha512.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/nexgen32e/kcp437.o: libc/nexgen32e/kcp437.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/libc/nexgen32e/kreversebits.o: libc/nexgen32e/kreversebits.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/nexgen32e/ktensindex.o: libc/nexgen32e/ktensindex.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/nexgen32e/longjmp.o: libc/nexgen32e/longjmp.S
diff --git a/libc/nexgen32e/argc.S b/libc/nexgen32e/argc.S
index 9e85f4409..165c05447 100644
--- a/libc/nexgen32e/argc.S
+++ b/libc/nexgen32e/argc.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.initbss 300,_init_argc
 //	Global variable holding _start(argc) parameter.
diff --git a/libc/nexgen32e/argv.S b/libc/nexgen32e/argv.S
index 9ee093476..7963698c8 100644
--- a/libc/nexgen32e/argv.S
+++ b/libc/nexgen32e/argv.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.initbss 300,_init_argv
 //	Global variable holding _start(argv) parameter.
diff --git a/libc/nexgen32e/auxv.S b/libc/nexgen32e/auxv.S
index 0c921df7c..52381e1c6 100644
--- a/libc/nexgen32e/auxv.S
+++ b/libc/nexgen32e/auxv.S
@@ -16,15 +16,15 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
-	.initbss 300,_init_auxv
+	.initbss 250,_init_auxv
 //	Global variable holding _start(auxv) parameter.
 __auxv:	.quad	0
 	.endobj	__auxv,globl
 	.previous
 
-	.init.start 300,_init_auxv
+	.init.start 250,_init_auxv
 	mov	%r15,%rax
 	stosq
-	.init.end 300,_init_auxv
+	.init.end 250,_init_auxv
diff --git a/libc/nexgen32e/checkstackalign.S b/libc/nexgen32e/checkstackalign.S
index 18d360507..abe8dae61 100644
--- a/libc/nexgen32e/checkstackalign.S
+++ b/libc/nexgen32e/checkstackalign.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Checks that stack is 16-byte aligned.
 //
diff --git a/libc/nexgen32e/djbsort-avx2.S b/libc/nexgen32e/djbsort-avx2.S
index 70e24cbdd..70868472d 100644
--- a/libc/nexgen32e/djbsort-avx2.S
+++ b/libc/nexgen32e/djbsort-avx2.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	D.J. Bernstein's outrageously fast integer sorting algorithm.
 //
@@ -7,8 +7,8 @@
 //	@note	public domain
 //	@see	en.wikipedia.org/wiki/Sorting_network
 djbsort_avx2:
-	push	%rbp
-	mov	%rsp,%rbp
+	beg
+	pro
 	push	%r15
 	push	%r14
 	push	%r13
@@ -795,11 +795,13 @@ djbsort_avx2:
 	pop	%r13
 	pop	%r14
 	pop	%r15
-	pop	%rbp
+	epi
 	ret
+	end
 	.endfn	djbsort_avx2,globl,hidden
 
 minmax_vector:
+	beg
 	cmp	$7,%rdx
 	jg	.L13
 .L2:	test	%rdx,%rdx
@@ -838,9 +840,11 @@ minmax_vector:
 	sub	$8,%rdx
 	jne	.L7
 	ret
+	end
 	.endfn	minmax_vector
 
 int32_twostages_32:
+	beg
 	sub	$-128,%rdi
 .L17:	lea	-128(%rdi),%rax
 	test	%rsi,%rsi
@@ -866,13 +870,14 @@ int32_twostages_32:
 	add	$512,%rdi
 	jmp	.L17
 .L21:	ret
+	end
 	.endfn	int32_twostages_32
 
 int32_threestages:
-	push	%rbp
+	beg
+	pro
 	imul	$-24,%rdx,%r8
 	lea	0(,%rdx,8),%rax
-	mov	%rsp,%rbp
 	push	%r15
 	push	%r14
 	push	%r13
@@ -961,11 +966,13 @@ int32_threestages:
 	pop	%r13
 	pop	%r14
 	pop	%r15
-	pop	%rbp
+	epi
 	ret
+	end
 	.endfn	int32_threestages
 
 merge16_finish:
+	beg
 	vpminsd	%ymm1,%ymm0,%ymm3
 	vpmaxsd	%ymm1,%ymm0,%ymm0
 	vperm2i128 $32,%ymm0,%ymm3,%ymm2
@@ -994,9 +1001,11 @@ merge16_finish:
 .L31:	vmovdqu	%ymm2,(%rdi)
 	vmovdqu	%ymm0,32(%rdi)
 	ret
+	end
 	.endfn	merge16_finish
 
 int32_sort_2power:
+	beg
 	push	%r13
 	lea	16(%rsp),%r13
 	andq	$-32,%rsp
@@ -2075,6 +2084,7 @@ int32_sort_2power:
 	lea	-16(%r13),%rsp
 	pop	%r13
 	ret
+	end
 	.endfn	int32_sort_2power
 
 	.rodata.cst32
diff --git a/libc/nexgen32e/environ.S b/libc/nexgen32e/environ.S
index d1419a52c..dc3cb2d34 100644
--- a/libc/nexgen32e/environ.S
+++ b/libc/nexgen32e/environ.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Environment variable pointer list.
 	.bss
diff --git a/libc/nexgen32e/gc.S b/libc/nexgen32e/gc.S
index 6b60ae240..1e6f30266 100644
--- a/libc/nexgen32e/gc.S
+++ b/libc/nexgen32e/gc.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/dce.h"
 
 	nop
@@ -32,7 +32,8 @@
 //	@param	rax,rdx,xmm0,xmm1,st0,st1 is return value
 //	@see	test/libc/runtime/gc_test.c
 	.ftrace1
-__gc:	.ftrace2
+__gc:	beg
+	.ftrace2
 
 #ifdef __x86_64__
 
@@ -47,8 +48,7 @@ __gc:	.ftrace2
 	mov	8(%r8),%r9
 	mov	16(%r8),%rdi
 	push	24(%r8)
-	push	%rbp
-	mov	%rsp,%rbp
+	pro
 	sub	$32,%rsp
 	mov	%rax,-8(%rbp)
 	mov	%rdx,-16(%rbp)
@@ -57,7 +57,7 @@ __gc:	.ftrace2
 	movdqa	-32(%rbp),%xmm0
 	mov	-16(%rbp),%rdx
 	mov	-8(%rbp),%rax
-	leave
+	epi
 	ret
 9:	ud2
 	nop
@@ -66,7 +66,7 @@ __gc:	.ftrace2
 
 //	if this code fails
 //	check if CosmoTib's size changed
-	sub	x8,x28,#512			// __get_tls()
+	sub	x8,x28,#1024			// __get_tls()
 	ldr	x9,[x8,0x18]			// tib::garbages
 	ldr	x10,[x9]			// g->i
 	ldr	x8,[x9,8]			// g->p
@@ -102,4 +102,5 @@ __gc:	.ftrace2
 
 #endif /* __x86_64__ */
 
+	end
 	.endfn	__gc,globl,hidden
diff --git a/libc/nexgen32e/gclongjmp.S b/libc/nexgen32e/gclongjmp.S
index 1fb68131b..51f93cb15 100644
--- a/libc/nexgen32e/gclongjmp.S
+++ b/libc/nexgen32e/gclongjmp.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Jumps up stack to previous setjmp() invocation.
 //
@@ -31,7 +31,9 @@
 //	@noreturn
 	.ftrace1
 gclongjmp:
+	beg
 	.ftrace2
+	pro
 #ifdef __x86_64__
 	push	%rbp
 	mov	%rsp,%rbp
@@ -65,4 +67,5 @@ gclongjmp:
 #else
 #error "unsupported architecture"
 #endif /* __x86_64__ */
+	end
 	.endfn	gclongjmp,globl
diff --git a/libc/nexgen32e/identity.S b/libc/nexgen32e/identity.S
index 7fc23e4d8..804b65bda 100644
--- a/libc/nexgen32e/identity.S
+++ b/libc/nexgen32e/identity.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	The identity() function.
 //	@return	first argument
diff --git a/libc/nexgen32e/kbase36.c b/libc/nexgen32e/kbase36.c
index 8a105da1c..d490a966b 100644
--- a/libc/nexgen32e/kbase36.c
+++ b/libc/nexgen32e/kbase36.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdalign.internal.h"
-#include "libc/str/tab.internal.h"
+#include "libc/stdalign.h"
+#include "libc/str/tab.h"
 
 alignas(uint8_t) const uint8_t kBase36[256] = {
     ['0'] = 1,   //
diff --git a/libc/nexgen32e/kcp437.S b/libc/nexgen32e/kcp437.S
index 084313d8e..36f5bf28d 100644
--- a/libc/nexgen32e/kcp437.S
+++ b/libc/nexgen32e/kcp437.S
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/tab.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/str/tab.h"
+#include "libc/macros.h"
 .rodata
 .balign	2
 
diff --git a/libc/nexgen32e/kcpuids.S b/libc/nexgen32e/kcpuids.S
index adc6ef5d1..6cb2f1248 100644
--- a/libc/nexgen32e/kcpuids.S
+++ b/libc/nexgen32e/kcpuids.S
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/runtime/pc.internal.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/kcpuids.h"
 #include "libc/nexgen32e/x86feature.h"
 
diff --git a/libc/nexgen32e/khalfcache3.S b/libc/nexgen32e/khalfcache3.S
index 2d53f7167..b6e6c7a3b 100644
--- a/libc/nexgen32e/khalfcache3.S
+++ b/libc/nexgen32e/khalfcache3.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #ifdef __x86_64__
 
diff --git a/libc/nexgen32e/ksha256.S b/libc/nexgen32e/ksha256.S
index 0df26986e..58056ee47 100644
--- a/libc/nexgen32e/ksha256.S
+++ b/libc/nexgen32e/ksha256.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.rodata
 	.balign	64
diff --git a/libc/nexgen32e/ksha512.S b/libc/nexgen32e/ksha512.S
index 1d9450a8c..f039aa0c2 100644
--- a/libc/nexgen32e/ksha512.S
+++ b/libc/nexgen32e/ksha512.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.rodata
 	.balign	64
diff --git a/libc/nexgen32e/ktensindex.S b/libc/nexgen32e/ktensindex.S
index 0840a17db..7d9081c0c 100644
--- a/libc/nexgen32e/ktensindex.S
+++ b/libc/nexgen32e/ktensindex.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.rodata
 kTensIndex:
diff --git a/libc/nexgen32e/ktolower.c b/libc/nexgen32e/ktolower.c
index db169897e..40bf0127c 100644
--- a/libc/nexgen32e/ktolower.c
+++ b/libc/nexgen32e/ktolower.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdalign.internal.h"
-#include "libc/str/tab.internal.h"
+#include "libc/stdalign.h"
+#include "libc/str/tab.h"
 
 alignas(uint8_t) const uint8_t kToLower[256] = {
     0,   1,   2,   3,   4,   5,   6,    7,   8,    9,   10,  11,   12,  13,
diff --git a/libc/nexgen32e/ktoupper.c b/libc/nexgen32e/ktoupper.c
index 86e688a85..4c57cda9b 100644
--- a/libc/nexgen32e/ktoupper.c
+++ b/libc/nexgen32e/ktoupper.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdalign.internal.h"
-#include "libc/str/tab.internal.h"
+#include "libc/stdalign.h"
+#include "libc/str/tab.h"
 
 alignas(uint8_t) const uint8_t kToUpper[256] = {
     0,   1,   2,   3,   4,   5,   6,    7,   8,    9,   10,  11,   12,  13,
diff --git a/libc/nexgen32e/longjmp.S b/libc/nexgen32e/longjmp.S
index 985a2d657..5aefd029f 100644
--- a/libc/nexgen32e/longjmp.S
+++ b/libc/nexgen32e/longjmp.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Loads previously saved processor state.
 //
@@ -26,7 +26,7 @@
 //	@see	gclongjmp()
 //	@see	siglongjmp()
 	.ftrace1
-longjmp:
+longjmp:beg
 	.ftrace2
 _longjmp:
 #ifdef __x86_64__
@@ -61,6 +61,7 @@ _longjmp:
 #else
 #error "unsupported architecture"
 #endif
+	end
 	.endfn	longjmp,globl
 	.endfn	_longjmp,globl
 	.alias	longjmp,siglongjmp
diff --git a/libc/nexgen32e/mcount.S b/libc/nexgen32e/mcount.S
index 27076f1f6..f95b46cee 100644
--- a/libc/nexgen32e/mcount.S
+++ b/libc/nexgen32e/mcount.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Function Profiling Hook.
 //	cc -pg adds this to the start of global functions.
diff --git a/libc/nexgen32e/mul4x4adx.S b/libc/nexgen32e/mul4x4adx.S
index 67d7f7216..55643f75a 100644
--- a/libc/nexgen32e/mul4x4adx.S
+++ b/libc/nexgen32e/mul4x4adx.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Computes 512-bit product of 256-bit and 256-bit numbers.
 //
diff --git a/libc/nexgen32e/mul6x6adx.S b/libc/nexgen32e/mul6x6adx.S
index e0213a389..204bb4444 100644
--- a/libc/nexgen32e/mul6x6adx.S
+++ b/libc/nexgen32e/mul6x6adx.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Computes 768-bit product of 384-bit and 384-bit numbers.
 //
diff --git a/libc/nexgen32e/mul8x8adx.S b/libc/nexgen32e/mul8x8adx.S
index f83450d22..d4eeb0269 100644
--- a/libc/nexgen32e/mul8x8adx.S
+++ b/libc/nexgen32e/mul8x8adx.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Computes 1024-bit product of 512-bit and 512-bit numbers.
 //
diff --git a/libc/nexgen32e/nt2sysv.S b/libc/nexgen32e/nt2sysv.S
index ca9d87c19..185687de6 100644
--- a/libc/nexgen32e/nt2sysv.S
+++ b/libc/nexgen32e/nt2sysv.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.windows
 
 //	Translates function call from code built w/ MS-style compiler.
@@ -30,8 +30,8 @@
 //	@note	slower than __sysv2nt
 //	@see	NT2SYSV() macro
 __nt2sysv:
-	push	%rbp
-	mov	%rsp,%rbp
+	beg
+	pro
 	sub	$256,%rsp
 	push	%rbx
 	push	%rdi
@@ -48,6 +48,7 @@ __nt2sysv:
 	pop	%rsi
 	pop	%rdi
 	pop	%rbx
-	leave
+	epi
 	ret
+	end
 	.endfn	__nt2sysv,globl,hidden
diff --git a/libc/nexgen32e/nt2sysv.h b/libc/nexgen32e/nt2sysv.h
index 4b9373325..6afb40234 100644
--- a/libc/nexgen32e/nt2sysv.h
+++ b/libc/nexgen32e/nt2sysv.h
@@ -7,6 +7,10 @@
  *
  * This macro should be used when specifying callbacks in the WIN32 API.
  */
+#ifdef __x86_64__
 #define NT2SYSV(FUNCTION) TRAMPOLINE(FUNCTION, __nt2sysv)
+#else
+#define NT2SYSV(FUNCTION) FUNCTION
+#endif
 
 #endif /* COSMOPOLITAN_LIBC_NEXGEN32E_NT2SYSV_H_ */
diff --git a/libc/nexgen32e/pid.c b/libc/nexgen32e/pid.c
index 1abfb511e..235e575f1 100644
--- a/libc/nexgen32e/pid.c
+++ b/libc/nexgen32e/pid.c
@@ -17,5 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/runtime/internal.h"
+#ifndef __x86_64__
 
 int __pid;
+
+#endif
diff --git a/libc/nexgen32e/program_invocation_name.S b/libc/nexgen32e/program_invocation_name.S
index a5cd491d6..ab82db0b5 100644
--- a/libc/nexgen32e/program_invocation_name.S
+++ b/libc/nexgen32e/program_invocation_name.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.initbss 300,_init_program_invocation_name
 //	Supplies argv[0] the GNU way.
diff --git a/libc/nexgen32e/rldecode.S b/libc/nexgen32e/rldecode.S
index 06fcba57e..74d150faf 100644
--- a/libc/nexgen32e/rldecode.S
+++ b/libc/nexgen32e/rldecode.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.startup
 
 //	Thirteen byte decompressor.
diff --git a/libc/nexgen32e/setjmp.S b/libc/nexgen32e/setjmp.S
index 0dfac7df9..7f795ed4a 100644
--- a/libc/nexgen32e/setjmp.S
+++ b/libc/nexgen32e/setjmp.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Saves cpu state.
 //
diff --git a/libc/nexgen32e/sha1.S b/libc/nexgen32e/sha1.S
index 1016c0498..34ecfd2fe 100644
--- a/libc/nexgen32e/sha1.S
+++ b/libc/nexgen32e/sha1.S
@@ -31,7 +31,7 @@
 │  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.        │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.section .notice,"aR",@progbits
 	.asciz	"\n\n\
diff --git a/libc/nexgen32e/sha1ni.S b/libc/nexgen32e/sha1ni.S
index 223f5f25d..cfbc9f7bd 100644
--- a/libc/nexgen32e/sha1ni.S
+++ b/libc/nexgen32e/sha1ni.S
@@ -31,7 +31,7 @@
 │  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.        │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 .section .notice,"aR",@progbits
 .asciz "\n\n\
diff --git a/libc/nexgen32e/sha256.S b/libc/nexgen32e/sha256.S
index df175bf5b..fd5e42030 100644
--- a/libc/nexgen32e/sha256.S
+++ b/libc/nexgen32e/sha256.S
@@ -47,7 +47,7 @@
 /////////////////////////////////////////////////////////////////////////
 // This code schedules 2 blocks at a time, with 4 lanes per block
 /////////////////////////////////////////////////////////////////////////
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 .section .notice,"aR",@progbits
 .asciz "\n\n\
diff --git a/libc/nexgen32e/sha256ni.S b/libc/nexgen32e/sha256ni.S
index eb020d706..736524822 100644
--- a/libc/nexgen32e/sha256ni.S
+++ b/libc/nexgen32e/sha256ni.S
@@ -31,7 +31,7 @@
 │  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.        │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 .section .notice,"aR",@progbits
 .asciz "\n\n\
diff --git a/libc/nexgen32e/sha512.S b/libc/nexgen32e/sha512.S
index 6e36d6d1b..34f7c5fbb 100644
--- a/libc/nexgen32e/sha512.S
+++ b/libc/nexgen32e/sha512.S
@@ -48,7 +48,7 @@
 /////////////////////////////////////////////////////////////////////////
 // This code schedules 1 blocks at a time, with 4 lanes per block
 /////////////////////////////////////////////////////////////////////////
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 .section .notice,"aR",@progbits
 .asciz "\n\n\
diff --git a/libc/nexgen32e/threaded.c b/libc/nexgen32e/threaded.c
index 5524c4667..b2c53384b 100644
--- a/libc/nexgen32e/threaded.c
+++ b/libc/nexgen32e/threaded.c
@@ -18,13 +18,6 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/thread/tls.h"
 
-/**
- * Contains TID of main thread or 0 if threading isn't enabled.
- */
-int __threaded;
-
-#ifdef __x86_64__
-char __tls_enabled;
-#endif
-
+#ifndef __x86_64__
 unsigned __tls_index;
+#endif
diff --git a/libc/nexgen32e/x86info.h b/libc/nexgen32e/x86info.h
index 14eed9fd3..5e07d0e9e 100644
--- a/libc/nexgen32e/x86info.h
+++ b/libc/nexgen32e/x86info.h
@@ -65,7 +65,6 @@ struct X86ProcessorModel {
   unsigned char grade;
 };
 
-extern const size_t kX86ProcessorModelCount;
 extern const struct X86ProcessorModel kX86ProcessorModels[];
 
 const struct X86ProcessorModel *getx86processormodel(short) nosideeffect;
diff --git a/libc/nexgen32e/xmm.S b/libc/nexgen32e/xmm.S
index ef3658a2b..e944d6253 100644
--- a/libc/nexgen32e/xmm.S
+++ b/libc/nexgen32e/xmm.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .privileged
 
 __xmm_save:
diff --git a/libc/nexgen32e/zip.S b/libc/nexgen32e/zip.S
index 313f84e2d..b15142f06 100644
--- a/libc/nexgen32e/zip.S
+++ b/libc/nexgen32e/zip.S
@@ -16,9 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "ape/relocations.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 .section .zip.eocd,"",@progbits
 
 //	ZIP End Of Central Directory (EOCD) record.
diff --git a/libc/nt/kernel32/MapViewOfFile3.S b/libc/nt/API-MS-Win-Core-Memory-l1-1-6/MapViewOfFile3.S
similarity index 79%
rename from libc/nt/kernel32/MapViewOfFile3.S
rename to libc/nt/API-MS-Win-Core-Memory-l1-1-6/MapViewOfFile3.S
index 2b242dfd3..059fe827c 100644
--- a/libc/nt/kernel32/MapViewOfFile3.S
+++ b/libc/nt/API-MS-Win-Core-Memory-l1-1-6/MapViewOfFile3.S
@@ -1,5 +1,5 @@
 #include "libc/nt/codegen.h"
-.imp	kernel32,__imp_MapViewOfFile3,MapViewOfFile3
+.imp	API-MS-Win-Core-Memory-l1-1-6,__imp_MapViewOfFile3,MapViewOfFile3
 
 	.text.windows
 	.ftrace1
diff --git a/libc/nt/kernel32/VirtualAlloc2.S b/libc/nt/API-MS-Win-Core-Memory-l1-1-6/VirtualAlloc2.S
similarity index 79%
rename from libc/nt/kernel32/VirtualAlloc2.S
rename to libc/nt/API-MS-Win-Core-Memory-l1-1-6/VirtualAlloc2.S
index 77b2af26c..755aafb20 100644
--- a/libc/nt/kernel32/VirtualAlloc2.S
+++ b/libc/nt/API-MS-Win-Core-Memory-l1-1-6/VirtualAlloc2.S
@@ -1,5 +1,5 @@
 #include "libc/nt/codegen.h"
-.imp	kernel32,__imp_VirtualAlloc2,VirtualAlloc2
+.imp	API-MS-Win-Core-Memory-l1-1-6,__imp_VirtualAlloc2,VirtualAlloc2
 
 	.text.windows
 	.ftrace1
diff --git a/libc/nt/API-MS-Win-Core-Realtime-l1-1-1/QueryInterruptTime.S b/libc/nt/API-MS-Win-Core-Realtime-l1-1-1/QueryInterruptTime.S
new file mode 100644
index 000000000..ef2c8cd8a
--- /dev/null
+++ b/libc/nt/API-MS-Win-Core-Realtime-l1-1-1/QueryInterruptTime.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	API-MS-Win-Core-Realtime-l1-1-1,__imp_QueryInterruptTime,QueryInterruptTime
+
+	.text.windows
+	.ftrace1
+QueryInterruptTime:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_QueryInterruptTime(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	QueryInterruptTime,globl
+	.previous
diff --git a/libc/nt/API-MS-Win-Core-Realtime-l1-1-1/QueryInterruptTimePrecise.S b/libc/nt/API-MS-Win-Core-Realtime-l1-1-1/QueryInterruptTimePrecise.S
new file mode 100644
index 000000000..0fb28d032
--- /dev/null
+++ b/libc/nt/API-MS-Win-Core-Realtime-l1-1-1/QueryInterruptTimePrecise.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	API-MS-Win-Core-Realtime-l1-1-1,__imp_QueryInterruptTimePrecise,QueryInterruptTimePrecise
+
+	.text.windows
+	.ftrace1
+QueryInterruptTimePrecise:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_QueryInterruptTimePrecise(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	QueryInterruptTimePrecise,globl
+	.previous
diff --git a/libc/nt/API-MS-Win-Core-Realtime-l1-1-1/QueryUnbiasedInterruptTimePrecise.S b/libc/nt/API-MS-Win-Core-Realtime-l1-1-1/QueryUnbiasedInterruptTimePrecise.S
new file mode 100644
index 000000000..23fe67993
--- /dev/null
+++ b/libc/nt/API-MS-Win-Core-Realtime-l1-1-1/QueryUnbiasedInterruptTimePrecise.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	API-MS-Win-Core-Realtime-l1-1-1,__imp_QueryUnbiasedInterruptTimePrecise,QueryUnbiasedInterruptTimePrecise
+
+	.text.windows
+	.ftrace1
+QueryUnbiasedInterruptTimePrecise:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_QueryUnbiasedInterruptTimePrecise(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	QueryUnbiasedInterruptTimePrecise,globl
+	.previous
diff --git a/libc/nt/BUILD.mk b/libc/nt/BUILD.mk
index feaa79e24..b5660d1be 100644
--- a/libc/nt/BUILD.mk
+++ b/libc/nt/BUILD.mk
@@ -91,6 +91,27 @@ $(LIBC_NT_COMDLG32_A).pkg:				\
 
 #───────────────────────────────────────────────────────────────────────────────
 
+LIBC_NT_ARTIFACTS += LIBC_NT_SHELL32_A
+LIBC_NT_SHELL32 = $(LIBC_NT_SHELL32_A_DEPS) $(LIBC_NT_SHELL32_A)
+LIBC_NT_SHELL32_A = o/$(MODE)/libc/nt/shell32.a
+LIBC_NT_SHELL32_A_SRCS := $(wildcard libc/nt/shell32/*.S)
+LIBC_NT_SHELL32_A_OBJS = $(LIBC_NT_SHELL32_A_SRCS:%.S=o/$(MODE)/%.o)
+LIBC_NT_SHELL32_A_CHECKS = $(LIBC_NT_SHELL32_A).pkg
+LIBC_NT_SHELL32_A_DIRECTDEPS = LIBC_NT_KERNEL32
+LIBC_NT_SHELL32_A_DEPS :=					\
+	$(call uniq,$(foreach x,$(LIBC_NT_SHELL32_A_DIRECTDEPS),$($(x))))
+
+$(LIBC_NT_SHELL32_A):						\
+		libc/nt/shell32/				\
+		$(LIBC_NT_SHELL32_A).pkg			\
+		$(LIBC_NT_SHELL32_A_OBJS)
+
+$(LIBC_NT_SHELL32_A).pkg:					\
+		$(LIBC_NT_SHELL32_A_OBJS)			\
+		$(foreach x,$(LIBC_NT_SHELL32_A_DIRECTDEPS),$($(x)_A).pkg)
+
+#───────────────────────────────────────────────────────────────────────────────
+
 LIBC_NT_ARTIFACTS += LIBC_NT_GDI32_A
 LIBC_NT_GDI32 = $(LIBC_NT_GDI32_A_DEPS) $(LIBC_NT_GDI32_A)
 LIBC_NT_GDI32_A = o/$(MODE)/libc/nt/gdi32.a
@@ -158,6 +179,48 @@ $(LIBC_NT_SYNCHRONIZATION_A).pkg:				\
 
 #───────────────────────────────────────────────────────────────────────────────
 
+LIBC_NT_ARTIFACTS += LIBC_NT_MEMORY_A
+LIBC_NT_MEMORY = $(LIBC_NT_MEMORY_A_DEPS) $(LIBC_NT_MEMORY_A)
+LIBC_NT_MEMORY_A = o/$(MODE)/libc/nt/memory.a
+LIBC_NT_MEMORY_A_SRCS := $(wildcard libc/nt/API-MS-Win-Core-Memory-l1-1-6/*.S)
+LIBC_NT_MEMORY_A_OBJS = $(LIBC_NT_MEMORY_A_SRCS:%.S=o/$(MODE)/%.o)
+LIBC_NT_MEMORY_A_CHECKS = $(LIBC_NT_MEMORY_A).pkg
+LIBC_NT_MEMORY_A_DIRECTDEPS = LIBC_NT_KERNEL32
+LIBC_NT_MEMORY_A_DEPS :=				\
+	$(call uniq,$(foreach x,$(LIBC_NT_MEMORY_A_DIRECTDEPS),$($(x))))
+
+$(LIBC_NT_MEMORY_A):					\
+		libc/nt/API-MS-Win-Core-Memory-l1-1-6/	\
+		$(LIBC_NT_MEMORY_A).pkg			\
+		$(LIBC_NT_MEMORY_A_OBJS)
+
+$(LIBC_NT_MEMORY_A).pkg:				\
+		$(LIBC_NT_MEMORY_A_OBJS)		\
+		$(foreach x,$(LIBC_NT_MEMORY_A_DIRECTDEPS),$($(x)_A).pkg)
+
+#───────────────────────────────────────────────────────────────────────────────
+
+LIBC_NT_ARTIFACTS += LIBC_NT_REALTIME_A
+LIBC_NT_REALTIME = $(LIBC_NT_REALTIME_A_DEPS) $(LIBC_NT_REALTIME_A)
+LIBC_NT_REALTIME_A = o/$(MODE)/libc/nt/realtime.a
+LIBC_NT_REALTIME_A_SRCS := $(wildcard libc/nt/API-MS-Win-Core-Realtime-l1-1-1/*.S)
+LIBC_NT_REALTIME_A_OBJS = $(LIBC_NT_REALTIME_A_SRCS:%.S=o/$(MODE)/%.o)
+LIBC_NT_REALTIME_A_CHECKS = $(LIBC_NT_REALTIME_A).pkg
+LIBC_NT_REALTIME_A_DIRECTDEPS = LIBC_NT_KERNEL32
+LIBC_NT_REALTIME_A_DEPS :=					\
+	$(call uniq,$(foreach x,$(LIBC_NT_REALTIME_A_DIRECTDEPS),$($(x))))
+
+$(LIBC_NT_REALTIME_A):						\
+		libc/nt/API-MS-Win-Core-Realtime-l1-1-1/	\
+		$(LIBC_NT_REALTIME_A).pkg			\
+		$(LIBC_NT_REALTIME_A_OBJS)
+
+$(LIBC_NT_REALTIME_A).pkg:					\
+		$(LIBC_NT_REALTIME_A_OBJS)			\
+		$(foreach x,$(LIBC_NT_REALTIME_A_DIRECTDEPS),$($(x)_A).pkg)
+
+#───────────────────────────────────────────────────────────────────────────────
+
 LIBC_NT_ARTIFACTS += LIBC_NT_USER32_A
 LIBC_NT_USER32 = $(LIBC_NT_USER32_A_DEPS) $(LIBC_NT_USER32_A)
 LIBC_NT_USER32_A = o/$(MODE)/libc/nt/user32.a
diff --git a/libc/nt/advapi32/RegOpenKeyExA.S b/libc/nt/advapi32/RegOpenKeyExA.S
new file mode 100644
index 000000000..31ee26848
--- /dev/null
+++ b/libc/nt/advapi32/RegOpenKeyExA.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	advapi32,__imp_RegOpenKeyExA,RegOpenKeyExA
+
+	.text.windows
+	.ftrace1
+RegOpenKeyExA:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_RegOpenKeyExA(%rip),%rax
+	jmp	__sysv2nt6
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	RegOpenKeyExA,globl
+	.previous
diff --git a/libc/nt/enum/keyaccess.h b/libc/nt/enum/keyaccess.h
index 06709ad42..1abb200a4 100644
--- a/libc/nt/enum/keyaccess.h
+++ b/libc/nt/enum/keyaccess.h
@@ -1,6 +1,16 @@
 #ifndef COSMOPOLITAN_LIBC_NT_ENUM_KEYACCESS_H_
 #define COSMOPOLITAN_LIBC_NT_ENUM_KEYACCESS_H_
 
+#define kNtKeyQueryValue        0x00000001
+#define kNtKeySetValue          0x00000002
+#define kNtKeyCreateSubKey      0x00000004
+#define kNtKeyEnumerateSubKeys  0x00000008
+#define kNtKeyNotify            0x00000010
+#define kNtKeyCreateLink        0x00000020
+#define kNtWow6432Key           0x00000200
+#define kNtWow6464Key           0x00000100
+#define kNtWow64Res             0x00000300
+
 #define kNtKeyRead      0x00020019
 #define kNtKeyWrite     0x00020006
 #define kNtKeyExecute   0x00020019
diff --git a/libc/nt/enum/memflags.h b/libc/nt/enum/memflags.h
index fffb09ef9..7d7f11f61 100644
--- a/libc/nt/enum/memflags.h
+++ b/libc/nt/enum/memflags.h
@@ -16,6 +16,7 @@
 #define kNtMemLargePages 0x20000000
 #define kNtMem4mbPages   0x80000000
 
+#define kNtMemReservePlaceholder 0x00040000
 #define kNtMemReplacePlaceholder 0x00004000
 
 #endif /* COSMOPOLITAN_LIBC_NT_ENUM_MEMFLAGS_H_ */
diff --git a/libc/nt/enum/pageflags.h b/libc/nt/enum/pageflags.h
index 5cef3a2fa..40569decb 100644
--- a/libc/nt/enum/pageflags.h
+++ b/libc/nt/enum/pageflags.h
@@ -23,4 +23,7 @@
 #define kNtSecLargePages     0x80000000
 #define kNtSecWritecombine   0x40000000
 
+#define kNtPageTargetsInvalid  0x40000000
+#define kNtPageTargetsNoUpdate 0x40000000
+
 #endif /* COSMOPOLITAN_LIBC_NT_ENUM_PAGEFLAGS_H_ */
diff --git a/libc/nt/enum/status.h b/libc/nt/enum/status.h
index ed3dc8ff3..cc11bc96b 100644
--- a/libc/nt/enum/status.h
+++ b/libc/nt/enum/status.h
@@ -2,68 +2,68 @@
 #define COSMOPOLITAN_LIBC_NT_STATUS_H_
 
 /* high two bits = {success,informational,warning,error} */
-#define kNtStatusSuccess                  0x00000000 /* success statuses */
-#define kNtStatusWait0                    0x00000000
-#define kNtStatusAbandonedWait0           0x00000080
-#define kNtStatusUserApc                  0x000000C0
-#define kNtStatusTimeout                  0x00000102
-#define kNtStatusPending                  0x00000103
-#define kNtStatusGuardPageViolation       0x80000001 /* warning statuses */
-#define kNtStatusDatatypeMisalignment     0x80000002
-#define kNtStatusBreakpoint               0x80000003
-#define kNtStatusSingleStep               0x80000004
-#define kNtStatusLongjump                 0x80000026
-#define kNtStatusUnwindConsolidate        0x80000029
-#define kNtStatusAccessViolation          0xC0000005 /* error statuses */
-#define kNtStatusInPageError              0xC0000006
-#define kNtStatusInvalidHandle            0xC0000008
-#define kNtStatusInvalidParameter         0xC000000D
-#define kNtStatusNoMemory                 0xC0000017
-#define kNtStatusIllegalInstruction       0xC000001D
-#define kNtStatusNoncontinuableException  0xC0000025
-#define kNtStatusInvalidDisposition       0xC0000026
-#define kNtStatusArrayBoundsExceeded      0xC000008C
-#define kNtStatusFloatDenormalOperand     0xC000008D
-#define kNtStatusFloatDivideByZero        0xC000008E
-#define kNtStatusFloatInexactResult       0xC000008F
-#define kNtStatusFloatInvalidOperation    0xC0000090
-#define kNtStatusFloatOverflow            0xC0000091
-#define kNtStatusFloatStackCheck          0xC0000092
-#define kNtStatusFloatUnderflow           0xC0000093
-#define kNtStatusIntegerDivideBYZero      0xC0000094
-#define kNtStatusIntegerOverflow          0xC0000095
-#define kNtStatusPrivilegedInstruction    0xC0000096
-#define kNtStatusStackOverflow            0xC00000FD
-#define kNtStatusDllNotFound              0xC0000135
-#define kNtStatusOrdinalNotFound          0xC0000138
-#define kNtStatusEntrypointNotFound       0xC0000139
-#define kNtStatusControlCExit             0xC000013A
-#define kNtStatusDllInitFailed            0xC0000142
-#define kNtStatusFloatMultipleFaults      0xC00002B4
-#define kNtStatusFloatMultipleTraps       0xC00002B5
-#define kNtStatusRegNatConsumption        0xC00002C9
-#define kNtStatusHeapCorruption           0xC0000374
-#define kNtStatusStackBufferOverrun       0xC0000409
-#define kNtStatusInvalidCruntimeParameter 0xC0000417
-#define kNtStatusAssertionFailure         0xC0000420
-#define kNtStatusEnclaveViolation         0xC00004A2
-#define kNtStatusSegmentNotification      0x40000005
-#define kNtStatusFatalAppExit             0x40000015
-#define kNtStatusNotFound                 0xC0000225
-#define kNtStatusCancelled                0xC0000120
+#define kNtStatusSuccess                  0x00000000u /* success statuses */
+#define kNtStatusWait0                    0x00000000u
+#define kNtStatusAbandonedWait0           0x00000080u
+#define kNtStatusUserApc                  0x000000C0u
+#define kNtStatusTimeout                  0x00000102u
+#define kNtStatusPending                  0x00000103u
+#define kNtStatusGuardPageViolation       0x80000001u /* warning statuses */
+#define kNtStatusDatatypeMisalignment     0x80000002u
+#define kNtStatusBreakpoint               0x80000003u
+#define kNtStatusSingleStep               0x80000004u
+#define kNtStatusLongjump                 0x80000026u
+#define kNtStatusUnwindConsolidate        0x80000029u
+#define kNtStatusAccessViolation          0xC0000005u /* error statuses */
+#define kNtStatusInPageError              0xC0000006u
+#define kNtStatusInvalidHandle            0xC0000008u
+#define kNtStatusInvalidParameter         0xC000000Du
+#define kNtStatusNoMemory                 0xC0000017u
+#define kNtStatusIllegalInstruction       0xC000001Du
+#define kNtStatusNoncontinuableException  0xC0000025u
+#define kNtStatusInvalidDisposition       0xC0000026u
+#define kNtStatusArrayBoundsExceeded      0xC000008Cu
+#define kNtStatusFloatDenormalOperand     0xC000008Du
+#define kNtStatusFloatDivideByZero        0xC000008Eu
+#define kNtStatusFloatInexactResult       0xC000008Fu
+#define kNtStatusFloatInvalidOperation    0xC0000090u
+#define kNtStatusFloatOverflow            0xC0000091u
+#define kNtStatusFloatStackCheck          0xC0000092u
+#define kNtStatusFloatUnderflow           0xC0000093u
+#define kNtStatusIntegerDivideBYZero      0xC0000094u
+#define kNtStatusIntegerOverflow          0xC0000095u
+#define kNtStatusPrivilegedInstruction    0xC0000096u
+#define kNtStatusStackOverflow            0xC00000FDu
+#define kNtStatusDllNotFound              0xC0000135u
+#define kNtStatusOrdinalNotFound          0xC0000138u
+#define kNtStatusEntrypointNotFound       0xC0000139u
+#define kNtStatusControlCExit             0xC000013Au
+#define kNtStatusDllInitFailed            0xC0000142u
+#define kNtStatusFloatMultipleFaults      0xC00002B4u
+#define kNtStatusFloatMultipleTraps       0xC00002B5u
+#define kNtStatusRegNatConsumption        0xC00002C9u
+#define kNtStatusHeapCorruption           0xC0000374u
+#define kNtStatusStackBufferOverrun       0xC0000409u
+#define kNtStatusInvalidCruntimeParameter 0xC0000417u
+#define kNtStatusAssertionFailure         0xC0000420u
+#define kNtStatusEnclaveViolation         0xC00004A2u
+#define kNtStatusSegmentNotification      0x40000005u
+#define kNtStatusFatalAppExit             0x40000015u
+#define kNtStatusNotFound                 0xC0000225u
+#define kNtStatusCancelled                0xC0000120u
 
-#define kNtDbgExceptionHandled    0x00010001
-#define kNtDbgContinue            0x00010002
-#define kNtDbgReplyLater          0x40010001
-#define kNtDbgTerminateThread     0x40010003
-#define kNtDbgTerminateProcess    0x40010004
-#define kNtDbgControlC            0x40010005
-#define kNtDbgPrintexceptionC     0x40010006
-#define kNtDbgRipexception        0x40010007
-#define kNtDbgControlBreak        0x40010008
-#define kNtDbgCommandException    0x40010009
-#define kNtDbgPrintexceptionWideC 0x4001000A
-#define kNtDbgExceptionNotHandled 0x80010001
+#define kNtDbgExceptionHandled    0x00010001u
+#define kNtDbgContinue            0x00010002u
+#define kNtDbgReplyLater          0x40010001u
+#define kNtDbgTerminateThread     0x40010003u
+#define kNtDbgTerminateProcess    0x40010004u
+#define kNtDbgControlC            0x40010005u
+#define kNtDbgPrintexceptionC     0x40010006u
+#define kNtDbgRipexception        0x40010007u
+#define kNtDbgControlBreak        0x40010008u
+#define kNtDbgCommandException    0x40010009u
+#define kNtDbgPrintexceptionWideC 0x4001000Au
+#define kNtDbgExceptionNotHandled 0x80010001u
 #define kNtStillActive            kNtStatusPending
 
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
diff --git a/libc/nt/enum/wt.h b/libc/nt/enum/wt.h
index a79955ea8..74910853f 100644
--- a/libc/nt/enum/wt.h
+++ b/libc/nt/enum/wt.h
@@ -6,6 +6,6 @@
 #define kNtWtExecuteintimerthread      0x00000020u
 #define kNtWtExecuteinpersistentthread 0x00000080u
 #define kNtWtExecutelongfunction       0x00000010u
-#define kNtWtTransferImpersonation     0𝔵00000100𝔲
+#define kNtWtTransferImpersonation     0x00000100u
 
 #endif /* COSMOPOLITAN_LIBC_NT_ENUM_WT_H_ */
diff --git a/libc/nt/files.h b/libc/nt/files.h
index fcbc294cb..2b844c32f 100644
--- a/libc/nt/files.h
+++ b/libc/nt/files.h
@@ -49,6 +49,7 @@ COSMOPOLITAN_C_START_
 intptr_t LoadResource(int64_t hModule, int64_t hResInfo);
 uint32_t SetHandleCount(uint32_t uNumber);
 uint32_t GetLogicalDrives(void);
+uint32_t GetLogicalDriveStringsA(uint32_t nBufferLength, char *lpBuffer);
 bool32 FlushFileBuffers(int64_t hFile);
 
 int64_t ReOpenFile(int64_t hOriginalFile, uint32_t dwDesiredAccess,
@@ -205,6 +206,7 @@ uint32_t GetFinalPathNameByHandle(int64_t hFile, char16_t *out_path,
 
 uint32_t GetFullPathName(const char16_t *lpFileName, uint32_t nBufferLength,
                          char16_t *lpBuffer, char16_t **lpFilePart);
+uint32_t GetShortPathName(const char16_t *lpszLongPath, char16_t *out_lpszShortPath, uint32_t cchBuffer);
 
 bool32 GetOverlappedResult(int64_t hFile, struct NtOverlapped *lpOverlapped,
                            uint32_t *lpNumberOfBytesTransferred, bool32 bWait);
@@ -225,6 +227,10 @@ bool32 GetVolumeInformationByHandle(int64_t hFile,
                                     char16_t *opt_out_lpFileSystemNameBuffer,
                                     uint32_t nFileSystemNameSize);
 
+uint32_t SetFilePointer(intptr_t hFile, int32_t lDistanceToMove,
+                        long *opt_inout_lpDistanceToMoveHigh,
+                        uint32_t dwMoveMethod);
+
 #if ShouldUseMsabiAttribute()
 #include "libc/nt/thunk/files.inc"
 #endif /* ShouldUseMsabiAttribute() */
diff --git a/libc/nt/gdi32/DescribePixelFormat.S b/libc/nt/gdi32/DescribePixelFormat.S
new file mode 100644
index 000000000..44b3dc746
--- /dev/null
+++ b/libc/nt/gdi32/DescribePixelFormat.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	gdi32,__imp_DescribePixelFormat,DescribePixelFormat
+
+	.text.windows
+	.ftrace1
+DescribePixelFormat:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_DescribePixelFormat(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	DescribePixelFormat,globl
+	.previous
diff --git a/libc/nt/kernel32/GetACP.S b/libc/nt/kernel32/GetACP.S
new file mode 100644
index 000000000..f0121f7e0
--- /dev/null
+++ b/libc/nt/kernel32/GetACP.S
@@ -0,0 +1,19 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_GetACP,GetACP
+
+	.text.windows
+	.ftrace1
+GetACP:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	sub	$32,%rsp
+	call	*__imp_GetACP(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	GetACP,globl
+	.previous
diff --git a/libc/nt/kernel32/GetCPInfoExW.S b/libc/nt/kernel32/GetCPInfoExW.S
new file mode 100644
index 000000000..a58310911
--- /dev/null
+++ b/libc/nt/kernel32/GetCPInfoExW.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_GetCPInfoExW,GetCPInfoExW
+
+	.text.windows
+	.ftrace1
+GetCPInfoEx:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_GetCPInfoExW(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	GetCPInfoEx,globl
+	.previous
diff --git a/libc/nt/kernel32/GetLogicalDriveStringsA.S b/libc/nt/kernel32/GetLogicalDriveStringsA.S
new file mode 100644
index 000000000..de327c7fc
--- /dev/null
+++ b/libc/nt/kernel32/GetLogicalDriveStringsA.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_GetLogicalDriveStringsA,GetLogicalDriveStringsA
+
+	.text.windows
+	.ftrace1
+GetLogicalDriveStringsA:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_GetLogicalDriveStringsA(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	GetLogicalDriveStringsA,globl
+	.previous
diff --git a/libc/nt/kernel32/GetOEMCP.S b/libc/nt/kernel32/GetOEMCP.S
new file mode 100644
index 000000000..18227546f
--- /dev/null
+++ b/libc/nt/kernel32/GetOEMCP.S
@@ -0,0 +1,19 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_GetOEMCP,GetOEMCP
+
+	.text.windows
+	.ftrace1
+GetOEMCP:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	sub	$32,%rsp
+	call	*__imp_GetOEMCP(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	GetOEMCP,globl
+	.previous
diff --git a/libc/nt/kernel32/GetShortPathNameW.S b/libc/nt/kernel32/GetShortPathNameW.S
new file mode 100644
index 000000000..d0c28f2f6
--- /dev/null
+++ b/libc/nt/kernel32/GetShortPathNameW.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_GetShortPathNameW,GetShortPathNameW
+
+	.text.windows
+	.ftrace1
+GetShortPathName:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_GetShortPathNameW(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	GetShortPathName,globl
+	.previous
diff --git a/libc/nt/kernel32/GlobalLock.S b/libc/nt/kernel32/GlobalLock.S
new file mode 100644
index 000000000..1407a4427
--- /dev/null
+++ b/libc/nt/kernel32/GlobalLock.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_GlobalLock,GlobalLock
+
+	.text.windows
+	.ftrace1
+GlobalLock:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_GlobalLock(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	GlobalLock,globl
+	.previous
diff --git a/libc/nt/kernel32/GlobalUnlock.S b/libc/nt/kernel32/GlobalUnlock.S
new file mode 100644
index 000000000..b9ba550f8
--- /dev/null
+++ b/libc/nt/kernel32/GlobalUnlock.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_GlobalUnlock,GlobalUnlock
+
+	.text.windows
+	.ftrace1
+GlobalUnlock:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_GlobalUnlock(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	GlobalUnlock,globl
+	.previous
diff --git a/libc/nt/kernel32/IsWow64Process2.S b/libc/nt/kernel32/IsWow64Process2.S
new file mode 100644
index 000000000..4cb92ff17
--- /dev/null
+++ b/libc/nt/kernel32/IsWow64Process2.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_IsWow64Process2,IsWow64Process2
+
+	.text.windows
+	.ftrace1
+IsWow64Process2:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_IsWow64Process2(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	IsWow64Process2,globl
+	.previous
diff --git a/libc/nt/kernel32/QueryUnbiasedInterruptTime.S b/libc/nt/kernel32/QueryUnbiasedInterruptTime.S
new file mode 100644
index 000000000..ee296b5b6
--- /dev/null
+++ b/libc/nt/kernel32/QueryUnbiasedInterruptTime.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_QueryUnbiasedInterruptTime,QueryUnbiasedInterruptTime
+
+	.text.windows
+	.ftrace1
+QueryUnbiasedInterruptTime:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_QueryUnbiasedInterruptTime(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	QueryUnbiasedInterruptTime,globl
+	.previous
diff --git a/libc/nt/kernel32/SetFilePointer.S b/libc/nt/kernel32/SetFilePointer.S
new file mode 100644
index 000000000..2e14b9e3e
--- /dev/null
+++ b/libc/nt/kernel32/SetFilePointer.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_SetFilePointer,SetFilePointer
+
+	.text.windows
+	.ftrace1
+SetFilePointer:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_SetFilePointer(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	SetFilePointer,globl
+	.previous
diff --git a/libc/nt/kernel32/VirtualAlloc.S b/libc/nt/kernel32/VirtualAlloc.S
deleted file mode 100644
index f8e5f815a..000000000
--- a/libc/nt/kernel32/VirtualAlloc.S
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "libc/nt/codegen.h"
-.imp	kernel32,__imp_VirtualAlloc,VirtualAlloc
-
-	.text.windows
-	.ftrace1
-VirtualAlloc:
-	.ftrace2
-#ifdef __x86_64__
-	push	%rbp
-	mov	%rsp,%rbp
-	mov	__imp_VirtualAlloc(%rip),%rax
-	jmp	__sysv2nt
-#elif defined(__aarch64__)
-	mov	x0,#0
-	ret
-#endif
-	.endfn	VirtualAlloc,globl
-	.previous
diff --git a/libc/nt/kernel32/VirtualAllocEx.S b/libc/nt/kernel32/VirtualAllocEx.S
index bdf00950b..239913a84 100644
--- a/libc/nt/kernel32/VirtualAllocEx.S
+++ b/libc/nt/kernel32/VirtualAllocEx.S
@@ -1,18 +1,2 @@
 #include "libc/nt/codegen.h"
 .imp	kernel32,__imp_VirtualAllocEx,VirtualAllocEx
-
-	.text.windows
-	.ftrace1
-VirtualAllocEx:
-	.ftrace2
-#ifdef __x86_64__
-	push	%rbp
-	mov	%rsp,%rbp
-	mov	__imp_VirtualAllocEx(%rip),%rax
-	jmp	__sysv2nt6
-#elif defined(__aarch64__)
-	mov	x0,#0
-	ret
-#endif
-	.endfn	VirtualAllocEx,globl
-	.previous
diff --git a/libc/nt/kernel32/VirtualProtectEx.S b/libc/nt/kernel32/VirtualProtectEx.S
new file mode 100644
index 000000000..8d22b1789
--- /dev/null
+++ b/libc/nt/kernel32/VirtualProtectEx.S
@@ -0,0 +1,2 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_VirtualProtectEx,VirtualProtectEx
diff --git a/libc/nt/kernel32/VirtualQueryEx.S b/libc/nt/kernel32/VirtualQueryEx.S
new file mode 100644
index 000000000..d810cf97a
--- /dev/null
+++ b/libc/nt/kernel32/VirtualQueryEx.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_VirtualQueryEx,VirtualQueryEx
+
+	.text.windows
+	.ftrace1
+VirtualQueryEx:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_VirtualQueryEx(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	VirtualQueryEx,globl
+	.previous
diff --git a/libc/nt/kernel32/WriteProcessMemory.S b/libc/nt/kernel32/WriteProcessMemory.S
new file mode 100644
index 000000000..222dd5e72
--- /dev/null
+++ b/libc/nt/kernel32/WriteProcessMemory.S
@@ -0,0 +1,2 @@
+#include "libc/nt/codegen.h"
+.imp	kernel32,__imp_WriteProcessMemory,WriteProcessMemory
diff --git a/libc/nt/master.sh b/libc/nt/master.sh
index 21a07cdcd..570a77e72 100755
--- a/libc/nt/master.sh
+++ b/libc/nt/master.sh
@@ -40,9 +40,12 @@ imp	''							SetCurrentDirectoryW					kernel32	1
 imp	''							TerminateProcess					kernel32	2
 imp	''							UnlockFileEx						kernel32	5
 imp	''							UnmapViewOfFile						kernel32	1
+imp	''							VirtualAllocEx						kernel32	5
 imp	''							VirtualProtect						kernel32	4
+imp	''							VirtualProtectEx					kernel32	5
 imp	''							WaitForMultipleObjects					kernel32	4
 imp	''							WaitForSingleObject					kernel32	2
+imp	''							WriteProcessMemory					kernel32	5
 imp	'AcquireSRWLockExclusive'				AcquireSRWLockExclusive					kernel32	1
 imp	'AcquireSRWLockShared'					AcquireSRWLockShared					kernel32	1
 imp	'AddDllDirectory'					AddDllDirectory						kernel32	1
@@ -113,6 +116,7 @@ imp	'GetCurrentProcessId'					GetCurrentProcessId					kernel32	0
 imp	'GetCurrentProcessorNumberEx'				GetCurrentProcessorNumberEx				kernel32	1
 imp	'GetCurrentThread'					GetCurrentThread					kernel32	0
 imp	'GetCurrentThreadId'					GetCurrentThreadId					kernel32	0
+imp	'GetDynamicTimeZoneInformation'				GetDynamicTimeZoneInformation				kernel32	1
 imp	'GetEnvironmentStrings'					GetEnvironmentStringsW					kernel32	1
 imp	'GetEnvironmentVariable'				GetEnvironmentVariableW					kernel32	3
 imp	'GetExitCodeThread'					GetExitCodeThread					kernel32	2
@@ -125,10 +129,12 @@ imp	'GetFileTime'						GetFileTime						kernel32	4
 imp	'GetFileType'						GetFileType						kernel32	1
 imp	'GetFinalPathNameByHandle'				GetFinalPathNameByHandleW				kernel32	4
 imp	'GetFullPathName'					GetFullPathNameW					kernel32	4
+imp	'GetShortPathName'					GetShortPathNameW					kernel32	3
 imp	'GetHandleInformation'					GetHandleInformation					kernel32	2
 imp	'GetLargestConsoleWindowSize'				GetLargestConsoleWindowSize				kernel32	1
 imp	'GetLastError'						GetLastError						kernel32	0
 imp	'GetLogicalDrives'					GetLogicalDrives					kernel32	0
+imp	'GetLogicalDriveStringsA'				GetLogicalDriveStringsA					kernel32	2
 imp	'GetMaximumProcessorCount'				GetMaximumProcessorCount				kernel32	1	# Windows 7+
 imp	'GetModuleFileName'					GetModuleFileNameW					kernel32	3
 imp	'GetModuleHandle'					GetModuleHandleA					kernel32	1
@@ -168,8 +174,6 @@ imp	'GetSystemTimePreciseAsFileTime'			GetSystemTimePreciseAsFileTime				kernel3
 imp	'GetSystemTimes'					GetSystemTimes						kernel32	3
 imp	'GetTempPath'						GetTempPathW						kernel32	2
 imp	'GetTempPathA'						GetTempPathA						kernel32	2
-imp	'GetDynamicTimeZoneInformation'				GetDynamicTimeZoneInformation				kernel32	1
-imp	'GetTimeZoneInformation'				GetTimeZoneInformation					kernel32	1
 imp	'GetThreadContext'					GetThreadContext					kernel32	2
 imp	'GetThreadDescription'					GetThreadDescription					kernel32	2
 imp	'GetThreadIOPendingFlag'				GetThreadIOPendingFlag					kernel32	2
@@ -178,14 +182,20 @@ imp	'GetThreadPriority'					GetThreadPriority					kernel32	1
 imp	'GetThreadPriorityBoost'				GetThreadPriorityBoost					kernel32	2
 imp	'GetThreadTimes'					GetThreadTimes						kernel32	5
 imp	'GetTickCount64'					GetTickCount64						kernel32	0
+imp	'GetTimeZoneInformation'				GetTimeZoneInformation					kernel32	1
 imp	'GetVersionEx'						GetVersionExW						kernel32	1
 imp	'GetVolumeInformationByHandle'				GetVolumeInformationByHandleW				kernel32	8
 imp	'GetVolumePathName'					GetVolumePathNameW					kernel32	3
 imp	'GetWindowsDirectory'					GetWindowsDirectoryW					kernel32	2
 imp	'GetWindowsDirectoryA'					GetWindowsDirectoryA					kernel32	2
+imp	'GetOEMCP'						GetOEMCP						kernel32	0
+imp	'GetACP'						GetACP							kernel32	0
+imp	'GetCPInfoEx'						GetCPInfoExW						kernel32	3
 imp	'GlobalAlloc'						GlobalAlloc						kernel32	2
 imp	'GlobalFree'						GlobalFree						kernel32	1
+imp	'GlobalLock'						GlobalLock						kernel32	1
 imp	'GlobalMemoryStatusEx'					GlobalMemoryStatusEx					kernel32	1
+imp	'GlobalUnlock'						GlobalUnlock						kernel32	1
 imp	'HeapAlloc'						HeapAlloc						kernel32	3
 imp	'HeapCompact'						HeapCompact						kernel32	2
 imp	'HeapCreate'						HeapCreate						kernel32	3
@@ -197,6 +207,7 @@ imp	'InitializeCriticalSection'				InitializeCriticalSection				kernel32	1
 imp	'InitializeCriticalSectionAndSpinCount'			InitializeCriticalSectionAndSpinCount			kernel32	2
 imp	'InitializeProcThreadAttributeList'			InitializeProcThreadAttributeList			kernel32	4
 imp	'InitializeSRWLock'					InitializeSRWLock					kernel32	1
+imp	'IsWow64Process2'					IsWow64Process2						kernel32	3
 imp	'LeaveCriticalSection'					LeaveCriticalSection					kernel32	1
 imp	'LoadLibrary'						LoadLibraryW						kernel32	1
 imp	'LoadLibraryA'						LoadLibraryA						kernel32	1
@@ -205,7 +216,6 @@ imp	'LoadResource'						LoadResource						kernel32	2
 imp	'LocalFree'						LocalFree						kernel32	1
 imp	'LockFile'						LockFile						kernel32	5
 imp	'LockResource'						LockResource						kernel32	1
-imp	'MapViewOfFile3'					MapViewOfFile3						kernel32	9
 imp	'MoveFile'						MoveFileW						kernel32	2
 imp	'MultiByteToWideChar'					MultiByteToWideChar					kernel32	6
 imp	'OfferVirtualMemory'					OfferVirtualMemory					kernel32	3
@@ -218,8 +228,9 @@ imp	'Process32First'					Process32FirstW						kernel32	2
 imp	'Process32Next'						Process32NextW						kernel32	2
 imp	'PulseEvent'						PulseEvent						kernel32	1
 imp	'PurgeComm'						PurgeComm						kernel32	2
-imp	'QueryPerformanceCounter'				QueryPerformanceCounter					kernel32	1
+imp	'QueryPerformanceCounter'				QueryPerformanceCounter					kernel32	1	# Windows 7+
 imp	'QueryPerformanceFrequency'				QueryPerformanceFrequency				kernel32	1
+imp	'QueryUnbiasedInterruptTime'				QueryUnbiasedInterruptTime				kernel32	1	# Windows 7+
 imp	'ReadConsole'						ReadConsoleW						kernel32	5
 imp	'ReadConsoleInput'					ReadConsoleInputW					kernel32	4
 imp	'ReadConsoleOutput'					ReadConsoleOutputW					kernel32	5
@@ -258,6 +269,7 @@ imp	'SetEvent'						SetEvent						kernel32	1
 imp	'SetFileAttributes'					SetFileAttributesW					kernel32	2
 imp	'SetFileCompletionNotificationModes'			SetFileCompletionNotificationModes			kernel32	2
 imp	'SetFileInformationByHandle'				SetFileInformationByHandle				kernel32	4
+imp	'SetFilePointer'					SetFilePointer						kernel32	4
 imp	'SetFileTime'						SetFileTime						kernel32	4
 imp	'SetFileValidData'					SetFileValidData					kernel32	2
 imp	'SetHandleCount'					SetHandleCount						kernel32	1
@@ -295,12 +307,10 @@ imp	'UnlockFile'						UnlockFile						kernel32	5
 imp	'UnmapViewOfFile2'					UnmapViewOfFile2					kernel32	2
 imp	'UnmapViewOfFileEx'					UnmapViewOfFileEx					kernel32	3
 imp	'UpdateProcThreadAttribute'				UpdateProcThreadAttribute				kernel32	7
-imp	'VirtualAlloc'						VirtualAlloc						kernel32	4
-imp	'VirtualAlloc2'						VirtualAlloc2						kernel32	7
-imp	'VirtualAllocEx'					VirtualAllocEx						kernel32	5
 imp	'VirtualFree'						VirtualFree						kernel32	3
 imp	'VirtualLock'						VirtualLock						kernel32	2
 imp	'VirtualQuery'						VirtualQuery						kernel32	3
+imp	'VirtualQueryEx'					VirtualQueryEx						kernel32	4
 imp	'VirtualUnlock'						VirtualUnlock						kernel32	2
 imp	'WaitForMultipleObjectsEx'				WaitForMultipleObjectsEx				kernel32	5
 imp	'WaitForSingleObjectEx'					WaitForSingleObjectEx					kernel32	3
@@ -351,6 +361,7 @@ imp	'RegLoadKey'						RegLoadKeyW						advapi32	3
 imp	'RegNotifyChangeKeyValue'				RegNotifyChangeKeyValue					advapi32	5
 imp	'RegOpenCurrentUser'					RegOpenCurrentUser					advapi32	2
 imp	'RegOpenKeyEx'						RegOpenKeyExW						advapi32	5
+imp	'RegOpenKeyExA'						RegOpenKeyExA						advapi32	5
 imp	'RegOpenUserClassesRoot'				RegOpenUserClassesRoot					advapi32	4
 imp	'RegOverridePredefKey'					RegOverridePredefKey					advapi32	2
 imp	'RegQueryInfoKey'					RegQueryInfoKeyW					advapi32	12
@@ -375,6 +386,7 @@ imp	'TraceSetInformation'					TraceSetInformation					advapi32 # Windows 7+
 #
 #	Name							Actual							DLL		Arity
 imp	'AdjustWindowRect'					AdjustWindowRect					user32		3
+imp	'AdjustWindowRectEx'					AdjustWindowRectEx					user32		4
 imp	'AnimateWindow'						AnimateWindow						user32		3
 imp	'AppendMenuA'						AppendMenuA						user32		4
 imp	'AppendMenu'						AppendMenuW						user32		4
@@ -382,6 +394,9 @@ imp	'BeginPaint'						BeginPaint						user32		2
 imp	'BringWindowToTop'					BringWindowToTop					user32		1
 imp	'CallNextHookEx'					CallNextHookEx						user32		4
 imp	'CloseWindow'						CloseWindow						user32		1
+imp	'ClientToScreen'					ClientToScreen						user32		2
+imp	'ClipCursor'						ClipCursor						user32		1
+imp	'CloseClipboard'					CloseClipboard						user32		0
 imp	'CreateIconIndirect'					CreateIconIndirect					user32		1
 imp	'CreateMenu'						CreateMenu						user32		0
 imp	'CreatePopupMenu'					CreatePopupMenu						user32		0
@@ -394,12 +409,15 @@ imp	'DestroyWindow'						DestroyWindow						user32		1
 imp	'DispatchMessage'					DispatchMessageW					user32		1
 imp	'DrawText'						DrawTextW						user32		5
 imp	'DrawTextEx'						DrawTextExW						user32		6
+imp	'EmptyClipboard'					EmptyClipboard						user32		0
 imp	'EndPaint'						EndPaint						user32		2
 imp	'EnumChildWindows'					EnumChildWindows					user32		3
 imp	'FillRect'						FillRect						user32		3
 imp	'FindWindow'						FindWindowW						user32		2
 imp	'FindWindowEx'						FindWindowExW						user32		4
+imp	'GetAsyncKeyState'					GetAsyncKeyState					user32		1
 imp	'GetClientRect'						GetClientRect						user32		2
+imp	'GetClipboardData'					GetClipboardData					user32		1
 imp	'GetCursor'						GetCursor						user32		0
 imp	'GetCursorPos'						GetCursorPos						user32		1
 imp	'GetDC'							GetDC							user32		1
@@ -408,9 +426,12 @@ imp	'GetKeyState'						GetKeyState						user32		1
 imp	'GetKeyboardLayout'					GetKeyboardLayout					user32		1
 imp	'GetMenu'						GetMenu							user32		1
 imp	'GetMessage'						GetMessageW						user32		4
+imp	'GetMonitorInfo'					GetMonitorInfoW						user32		2
+imp	'GetRawInputData'					GetRawInputData						user32		5
 imp	'GetParent'						GetParent						user32		1
 imp	'GetShellWindow'					GetShellWindow						user32		0
 imp	'GetSystemMenu'						GetSystemMenu						user32		2
+imp	'GetSystemMetrics'					GetSystemMetrics					user32		1
 imp	'GetWindow'						GetWindow						user32		2
 imp	'GetWindowPlacement'					GetWindowPlacement					user32		2
 imp	'GetWindowRect'						GetWindowRect						user32		2
@@ -431,13 +452,22 @@ imp	'MapVirtualKeyEx'					MapVirtualKeyExW					user32		3
 imp	'MessageBox'						MessageBoxW						user32		4
 imp	'MessageBoxEx'						MessageBoxExW						user32		5
 imp	'MoveWindow'						MoveWindow						user32		6
+imp	'MonitorFromPoint'					MonitorFromPoint					user32		2
+imp	'MonitorFromWindow'					MonitorFromWindow					user32		2
+imp	'OpenClipboard'						OpenClipboard						user32		1
 imp	'PeekMessage'						PeekMessageW						user32		5
+imp	'PostMessage'						PostMessageW						user32		4
 imp	'PostQuitMessage'					PostQuitMessage						user32		1
+imp	'PtInRect'						PtInRect						user32		2
 imp	'RedrawWindow'						RedrawWindow						user32		4
 imp	'RegisterClass'						RegisterClassW						user32		1
 imp	'RegisterClassEx'					RegisterClassExW					user32		1
+imp	'RegisterRawInputDevices'				RegisterRawInputDevices					user32		3
 imp	'ReleaseCapture'					ReleaseCapture						user32		0
 imp	'ReleaseDC'						ReleaseDC						user32		2
+imp	'ScreenToClient'					ScreenToClient						user32		2
+imp	'SetClipboardData'					SetClipboardData					user32		2
+imp	'SetCursorPos'						SetCursorPos						user32		2
 imp	'SendMessage'						SendMessageW						user32		4
 imp	'SetCapture'						SetCapture						user32		1
 imp	'SetClassLong'						SetClassLongW						user32		3
@@ -445,6 +475,7 @@ imp	'SetCursor'						SetCursor						user32		1
 imp	'SetParent'						SetParent						user32		2
 imp	'SetTimer'						SetTimer						user32		4
 imp	'SetWindowLong'						SetWindowLongW						user32		3
+imp	'SetWindowLongPtr'					SetWindowLongPtrW					user32		3
 imp	'SetWindowPlacement'					SetWindowPlacement					user32		2
 imp	'SetWindowPos'						SetWindowPos						user32		7
 imp	'SetWindowText'						SetWindowTextW						user32		2
@@ -453,12 +484,23 @@ imp	'SetWindowsHookEx'					SetWindowsHookExW					user32		4
 imp	'ShowCaret'						ShowCaret						user32		1
 imp	'ShowCursor'						ShowCursor						user32		1
 imp	'ShowWindow'						ShowWindow						user32		2
+imp	'TrackMouseEvent'					TrackMouseEvent						user32		1
 imp	'TrackPopupMenu'					TrackPopupMenu						user32		7
 imp	'TranslateMessage'					TranslateMessage					user32		1
 imp	'UnhookWindowsHook'					UnhookWindowsHook					user32		2
 imp	'UnhookWindowsHookEx'					UnhookWindowsHookEx					user32		1
+imp	'UnregisterClass'					UnregisterClassW					user32		2
 imp	'UpdateWindow'						UpdateWindow						user32		1
 imp	'WaitForInputIdle'					WaitForInputIdle					user32		2
+imp	'WindowFromPoint'					WindowFromPoint						user32		1
+
+# SHELL32.DLL
+#
+#	Name							Actual							DLL		Arity
+imp	'CommandLineToArgv'					CommandLineToArgvW					shell32		2
+imp	'DragAcceptFiles'					DragAcceptFiles						shell32		2
+imp	'DragFinish'						DragFinish						shell32		1
+imp	'DragQueryFile'						DragQueryFileW						shell32		4
 
 # GDI32.DLL
 #
@@ -472,6 +514,7 @@ imp	'CreateDIBSection'					CreateDIBSection					gdi32		6
 imp	'CreateRectRgn'						CreateRectRgn						gdi32		4
 imp	'DeleteDC'						DeleteDC						gdi32		1
 imp	'DeleteObject'						DeleteObject						gdi32		1
+imp	'DescribePixelFormat'					DescribePixelFormat					gdi32		4
 imp	'GetPixel'						GetPixel						gdi32		3
 imp	'RestoreDC'						RestoreDC						gdi32		2
 imp	'SaveDC'						SaveDC							gdi32		1
@@ -629,6 +672,19 @@ imp	'WaitOnAddress'						WaitOnAddress						API-MS-Win-Core-Synch-l1-2-0		4
 imp	'WakeByAddressAll'					WakeByAddressAll					API-MS-Win-Core-Synch-l1-2-0		1
 imp	'WakeByAddressSingle'					WakeByAddressSingle					API-MS-Win-Core-Synch-l1-2-0		1
 
+# API-MS-Win-Core-Memory-l1-1-6.dll (Windows 10+)
+#
+#	Name							Actual							DLL					Arity
+imp	'MapViewOfFile3'					MapViewOfFile3						API-MS-Win-Core-Memory-l1-1-6		9
+imp	'VirtualAlloc2'						VirtualAlloc2						API-MS-Win-Core-Memory-l1-1-6		7
+
+# API-MS-Win-Core-Realtime-l1-1-1.dll (Windows 10+)
+#
+#	Name							Actual							DLL					Arity
+imp	'QueryInterruptTime'					QueryInterruptTime					API-MS-Win-Core-Realtime-l1-1-1		1
+imp	'QueryInterruptTimePrecise'				QueryInterruptTimePrecise				API-MS-Win-Core-Realtime-l1-1-1		1
+imp	'QueryUnbiasedInterruptTimePrecise'			QueryUnbiasedInterruptTimePrecise			API-MS-Win-Core-Realtime-l1-1-1		1
+
 # NTDLL.DLL
 # BEYOND THE PALE
 #
@@ -703,6 +759,7 @@ imp	'NtQuerySecurityObject'					NtQuerySecurityObject					ntdll		5
 imp	'NtQuerySymbolicLinkObject'				NtQuerySymbolicLinkObject				ntdll		3
 imp	'NtQuerySystemInformation'				NtQuerySystemInformation				ntdll		4
 imp	'NtQuerySystemTime'					NtQuerySystemTime					ntdll		1
+imp	'NtQueryTimerResolution'				NtQueryTimerResolution					ntdll		3
 imp	'NtQueryValueKey'					NtQueryValueKey						ntdll		6
 imp	'NtQueryVirtualMemory'					NtQueryVirtualMemory					ntdll		6
 imp	'NtQueryVolumeInformationFile'				NtQueryVolumeInformationFile				ntdll		5
@@ -719,6 +776,7 @@ imp	'NtSetInformationFile'					NtSetInformationFile					ntdll		5
 imp	'NtSetInformationThread'				NtSetInformationThread					ntdll		4
 imp	'NtSetIntervalProfile'					NtSetIntervalProfile					ntdll		2
 imp	'NtSetTimer'						NtSetTimer						ntdll		7
+imp	'NtSetTimerResolution'					NtSetTimerResolution					ntdll		3
 imp	'NtSetValueKey'						NtSetValueKey						ntdll		6
 imp	'NtSignalAndWaitForSingleObject'			NtSignalAndWaitForSingleObject				ntdll		4
 imp	'NtStartProfile'					NtStartProfile						ntdll		1
diff --git a/libc/nt/memory.h b/libc/nt/memory.h
index bfd662e2d..9f6792657 100644
--- a/libc/nt/memory.h
+++ b/libc/nt/memory.h
@@ -71,8 +71,17 @@ bool32 VirtualUnlock(const void *lpAddress, size_t dwSize);
 uint64_t VirtualQuery(const void *lpAddress,
                       struct NtMemoryBasicInformation *lpBuffer,
                       uint64_t dwLength);
+uint64_t VirtualQueryEx(int64_t hProcess, const void *lpAddress,
+                        struct NtMemoryBasicInformation *lpBuffer,
+                        uint64_t dwLength);
+
 void *VirtualAllocEx(int64_t hProcess, void *lpAddress, uint64_t dwSize,
                      uint32_t flAllocationType, uint32_t flProtect);
+bool32 VirtualProtectEx(int64_t hProcess, void *lpAddress, uint64_t dwSize,
+                        uint32_t flNewProtect, uint32_t *out_lpflOldProtect);
+bool32 WriteProcessMemory(int64_t hProcess, void *lpBaseAddress,
+                          const void *lpBuffer, uint64_t nSize,
+                          uint64_t *opt_out_lpNumberOfBytesWritten);
 
 int64_t GetProcessHeap(void);
 void *HeapAlloc(int64_t hHeap, uint32_t dwFlags, size_t dwBytes) __wur;
@@ -102,6 +111,12 @@ void *VirtualAlloc2(
     struct NtMemExtendedParameter *in_out_opt_ExtendedParameters,
     unsigned ParameterCount);
 
+bool32 PrefetchVirtualMemory(int64_t hProcess, uintptr_t NumberOfEntries,
+                             struct NtMemoryRangeEntry *VirtualAddresses,
+                             uint32_t reserved_Flags);
+bool32 OfferVirtualMemory(void *inout_VirtualAddress, size_t Size,
+                          int Priority);
+
 #if ShouldUseMsabiAttribute()
 #include "libc/nt/thunk/memory.inc"
 #endif /* ShouldUseMsabiAttribute() */
diff --git a/libc/nt/nls.h b/libc/nt/nls.h
new file mode 100644
index 000000000..4e2761519
--- /dev/null
+++ b/libc/nt/nls.h
@@ -0,0 +1,35 @@
+#ifndef COSMOPOLITAN_LIBC_NT_NLS_H_
+#define COSMOPOLITAN_LIBC_NT_NLS_H_
+#include "libc/nt/struct/cpinfoex.h"
+/*                            ░░░░
+                       ▒▒▒░░░▒▒▒▒▒▒▒▓▓▓░
+                      ▒▒▒▒░░░▒▒▒▒▒▒▓▓▓▓▓▓░
+                     ▒▒▒▒░░░▒▒▒▒▒▒▒▓▓▓▓▓▓  ▒▓░
+                     ▒▒▒░░░░▒▒▒▒▒▒▓▓▓▓▓▓   ▓▓▓▓▓▓▒        ▒▒▒▓▓█
+                    ▒▒▒▒░░░▒▒▒▒▒▒▒▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓
+                   ░▒▒▒░░░░▒▒▒▒▒▒▓▓▓▓▓▓   █▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓█
+                   ▒▒▒▒░░░▒▒▒▒▒▒▒▓▓▓▓▓░  ▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓
+                  ▒▒▒▒░░░▒▒▒▒▒▒▒▓▓▓▓▓▓  ▒▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▒
+                  ▒▒▒▒▓▓      ▓▒▒▓▓▓▓   ▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓█
+                                   ▒▓  ▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓
+                  ░░░░░░░░░░░▒▒▒▒      ▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓█
+                ▒▒░░░░░░░░░░▒▒▒▒▒▓▓▓     ▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓▓
+               ░▒░░░░░░░░░░░▒▒▒▒▒▓▓   ▓░      ░▓███▓
+               ▒▒░░░░░░░░░░▒▒▒▒▒▓▓░  ▒▓▓▓▒▒▒         ░▒▒▒▓   ████████████
+              ▒▒░░░░░░░░░░░▒▒▒▒▒▓▓  ▒▓▓▓▓▒▒▒▒▒▒▒▒░░░▒▒▒▒▒░           ░███
+              ▒░░░░░░░░░░░▒▒▒▒▒▓▓   ▓▓▓▓▒▒▒▒▒▒▒▒░░░░▒▒▒▒▓            ███
+             ▒▒░░░░░░░░░░▒▒▒▒▒▒▓▓  ▒▓▓▓▒▒▒▒▒▒▒▒░░░░▒▒▒▒▒            ▓██
+             ▒░░░░░░░░░░░▒▒▒▒▒▓▓   ▓▓▓▓▒▒▒▒▒▒▒▒░░░▒▒▒▒▒▓           ▓██
+            ▒▒░░░▒▒▒░░░▒▒░▒▒▒▓▓▒  ▒▓▓▓▒▒▒▒▒▒▒▒░░░░▒▒▒▒▒           ███
+                            ░▒▓  ░▓▓▓▓▒▒▒▒▒▒▒▒░░░░▒▒▒▒▓          ▓██
+╔────────────────────────────────────────────────────────────────▀▀▀─────────│─╗
+│ cosmopolitan § new technology » internationalization                      ─╬─│┼
+╚────────────────────────────────────────────────────────────────────────────│*/
+COSMOPOLITAN_C_START_
+
+uint32_t GetOEMCP();
+uint32_t GetACP();
+bool32 GetCPInfoEx(uint32_t CodePage, uint32_t dwFlags, struct NtCpInfoEx *out_lpCPInfoEx) paramsnonnull((3));
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_NT_NLS_H_ */
\ No newline at end of file
diff --git a/libc/nt/ntdll.h b/libc/nt/ntdll.h
index 04a8e60f3..f251b923a 100644
--- a/libc/nt/ntdll.h
+++ b/libc/nt/ntdll.h
@@ -224,6 +224,16 @@ NtStatus RtlUnlockHeap(int64_t heap);
 NtStatus RtlGetProcessHeaps(uint32_t count, void **out_Heaps);
 NtStatus RtlWalkHeap(int64_t heap, void *out_Info);
 
+/*───────────────────────────────────────────────────────────────────────────│─╗
+│ cosmopolitan § new technology » beyond the pale » i am the time lorde    ─╬─│┼
+╚────────────────────────────────────────────────────────────────────────────│*/
+
+NtStatus NtSetTimerResolution(uint32_t DesiredResolution, bool32 SetResolution,
+                              uint32_t *out_CurrentResolution);
+NtStatus NtQueryTimerResolution(uint32_t *out_MinimumResolution,
+                                uint32_t *out_MaximumResolution,
+                                uint32_t *out_CurrentResolution);
+
 #if ShouldUseMsabiAttribute()
 #include "libc/nt/thunk/ntdll.inc"
 #endif /* ShouldUseMsabiAttribute() */
diff --git a/libc/nt/ntdll/NtQueryTimerResolution.S b/libc/nt/ntdll/NtQueryTimerResolution.S
new file mode 100644
index 000000000..2bb696be7
--- /dev/null
+++ b/libc/nt/ntdll/NtQueryTimerResolution.S
@@ -0,0 +1,18 @@
+#include "libc/nt/ntdllimport.h"
+.ntimp	NtQueryTimerResolution,NtQueryTimerResolution
+
+	.text.windows
+	.ftrace1
+NtQueryTimerResolution:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_NtQueryTimerResolution(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	NtQueryTimerResolution,globl
+	.previous
diff --git a/libc/nt/ntdll/NtSetTimerResolution.S b/libc/nt/ntdll/NtSetTimerResolution.S
new file mode 100644
index 000000000..bbd707afe
--- /dev/null
+++ b/libc/nt/ntdll/NtSetTimerResolution.S
@@ -0,0 +1,18 @@
+#include "libc/nt/ntdllimport.h"
+.ntimp	NtSetTimerResolution,NtSetTimerResolution
+
+	.text.windows
+	.ftrace1
+NtSetTimerResolution:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_NtSetTimerResolution(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	NtSetTimerResolution,globl
+	.previous
diff --git a/libc/nt/ntdllimport.S b/libc/nt/ntdllimport.S
index b84411560..438f340f9 100644
--- a/libc/nt/ntdllimport.S
+++ b/libc/nt/ntdllimport.S
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/nt/enum/status.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #ifdef __x86_64__
 
 //	@fileoverview NTDLL.DLL Non-Mandatory Importer
diff --git a/libc/nt/ntdllimport.h b/libc/nt/ntdllimport.h
index 6eb8e93f6..657ed05ea 100644
--- a/libc/nt/ntdllimport.h
+++ b/libc/nt/ntdllimport.h
@@ -19,7 +19,7 @@
 #ifndef COSMOPOLITAN_LIBC_NT_NTDLLIMPORT_H_
 #define COSMOPOLITAN_LIBC_NT_NTDLLIMPORT_H_
 #include "ape/relocations.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #ifdef __ASSEMBLER__
 /* clang-format off */
 
diff --git a/libc/nt/registry.h b/libc/nt/registry.h
index d7f8abb99..a03abfc57 100644
--- a/libc/nt/registry.h
+++ b/libc/nt/registry.h
@@ -51,6 +51,8 @@ int RegOpenKey(int64_t hKey, const char16_t *opt_lpSubKey,
 int RegOpenKeyEx(int64_t hKey, const char16_t *opt_lpSubKey,
                  uint32_t opt_ulOptions, int samDesired, int64_t *out_phkResult)
     paramsnonnull((5));
+int RegOpenKeyExA(int64_t hKey, const char *opt_lpSubKey, uint32_t opt_ulOptions, 
+                  int samDesired, int64_t *out_phkResult) paramsnonnull((5));
 int RegCloseKey(int64_t hKey);
 
 int RegGetValue(int64_t hkey, const char16_t *opt_lpSubKey,
diff --git a/libc/nt/runtime.h b/libc/nt/runtime.h
index 953e77692..5aa2df862 100644
--- a/libc/nt/runtime.h
+++ b/libc/nt/runtime.h
@@ -43,6 +43,8 @@ bool32 SetDefaultDllDirectories(unsigned dirflags);
 bool32 ProcessPrng(void *RandomBuffer, uint32_t RandomBufferLength);
 uint32_t GetModuleFileName(int64_t hModule, char16_t *lpFilename,
                            uint32_t nSize);
+bool32 IsWow64Process2(intptr_t hProcess, uint16_t *out_pProcessMachine,
+                       uint16_t *out_opt_pNativeMachine);
 
 #if ShouldUseMsabiAttribute()
 #include "libc/nt/thunk/runtime.inc"
diff --git a/libc/nt/shell32/CommandLineToArgvW.S b/libc/nt/shell32/CommandLineToArgvW.S
new file mode 100644
index 000000000..ef2f71100
--- /dev/null
+++ b/libc/nt/shell32/CommandLineToArgvW.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	shell32,__imp_CommandLineToArgvW,CommandLineToArgvW
+
+	.text.windows
+	.ftrace1
+CommandLineToArgv:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_CommandLineToArgvW(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	CommandLineToArgv,globl
+	.previous
diff --git a/libc/nt/shell32/DragAcceptFiles.S b/libc/nt/shell32/DragAcceptFiles.S
new file mode 100644
index 000000000..2c3c78775
--- /dev/null
+++ b/libc/nt/shell32/DragAcceptFiles.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	shell32,__imp_DragAcceptFiles,DragAcceptFiles
+
+	.text.windows
+	.ftrace1
+DragAcceptFiles:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_DragAcceptFiles(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	DragAcceptFiles,globl
+	.previous
diff --git a/libc/nt/shell32/DragFinish.S b/libc/nt/shell32/DragFinish.S
new file mode 100644
index 000000000..5bb00758e
--- /dev/null
+++ b/libc/nt/shell32/DragFinish.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	shell32,__imp_DragFinish,DragFinish
+
+	.text.windows
+	.ftrace1
+DragFinish:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_DragFinish(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	DragFinish,globl
+	.previous
diff --git a/libc/nt/shell32/DragQueryFileW.S b/libc/nt/shell32/DragQueryFileW.S
new file mode 100644
index 000000000..efec6118d
--- /dev/null
+++ b/libc/nt/shell32/DragQueryFileW.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	shell32,__imp_DragQueryFileW,DragQueryFileW
+
+	.text.windows
+	.ftrace1
+DragQueryFile:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_DragQueryFileW(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	DragQueryFile,globl
+	.previous
diff --git a/libc/nt/struct/arm64.h b/libc/nt/struct/arm64.h
new file mode 100644
index 000000000..295da0fcd
--- /dev/null
+++ b/libc/nt/struct/arm64.h
@@ -0,0 +1,20 @@
+#ifndef COSMOPOLITAN_LIBC_NT_STRUCT_ARM64_H_
+#define COSMOPOLITAN_LIBC_NT_STRUCT_ARM64_H_
+
+struct NtArm64RuntimeFunction {
+  uint32_t BeginAddress;
+  union {
+    uint32_t UnwindData;
+    struct {
+      uint32_t Flag : 2;
+      uint32_t FunctionLength : 11;
+      uint32_t RegF : 3;
+      uint32_t RegI : 4;
+      uint32_t H : 1;
+      uint32_t CR : 2;
+      uint32_t FrameSize : 9;
+    };
+  };
+};
+
+#endif /* COSMOPOLITAN_LIBC_NT_STRUCT_ARM64_H_ */
diff --git a/libc/nt/struct/cpinfoex.h b/libc/nt/struct/cpinfoex.h
new file mode 100644
index 000000000..754501bb5
--- /dev/null
+++ b/libc/nt/struct/cpinfoex.h
@@ -0,0 +1,13 @@
+#ifndef COSMOPOLITAN_LIBC_NT_STRUCT_CPINFOEX_H_
+#define COSMOPOLITAN_LIBC_NT_STRUCT_CPINFOEX_H_
+
+struct NtCpInfoEx {
+  uint32_t MaxCharSize;
+  uint8_t DefaultChar[2];
+  uint8_t LeadByte[12];
+  char16_t UnicodeDefaultChar;
+  uint32_t CodePage;
+  char16_t CodePageName[260];
+};
+
+#endif /* COSMOPOLITAN_LIBC_NT_STRUCT_CPINFOEX_H_ */
diff --git a/libc/nt/struct/iovec.h b/libc/nt/struct/iovec.h
index b29f4bd8b..e2898da96 100644
--- a/libc/nt/struct/iovec.h
+++ b/libc/nt/struct/iovec.h
@@ -7,7 +7,7 @@ struct NtIovec {
   char *buf;
 };
 
-void DescribeIovNt(const struct NtIovec *, uint32_t, ssize_t);
+void _DescribeIovNt(const struct NtIovec *, uint32_t, ssize_t);
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_NT_STRUCT_IOVEC_H_ */
diff --git a/libc/nt/struct/memextendedparameter.h b/libc/nt/struct/memextendedparameter.h
index 6cd4d0f5d..5fdd3985c 100644
--- a/libc/nt/struct/memextendedparameter.h
+++ b/libc/nt/struct/memextendedparameter.h
@@ -9,26 +9,28 @@
 #define kNtMemExtendedParameterPartitionHandle     3
 #define kNtMemExtendedParameterUserPhysicalHandle  4
 #define kNtMemExtendedParameterAttributeFlags      5
-#define kNtMemExtendedParameterMax                 6
+#define kNtMemExtendedParameterImageMachine        6
+#define kNtMemExtendedParameterMax                 7
 
 #define kNtMemExtendedParameterGraphics          0x00000001
 #define kNtMemExtendedParameterNonpaged          0x00000002
 #define kNtMemExtendedParameterZeroPagesOptional 0x00000004
 #define kNtMemExtendedParameterNonpagedLarge     0x00000008
 #define kNtMemExtendedParameterNonpagedHuge      0x00000010
+#define kNtMemExtendedParameterSoftFaultPages    0x00000020
+#define kNtMemExtendedParameterEcCode            0x00000040
+#define kNtMemExtendedParameterImageNoHpat       0x00000080
 
 struct NtMemExtendedParameter {
-  struct {
-    uint64_t Type : kNtMemExtendedParameterTypeBits;
-    uint64_t Reserved : 64 - kNtMemExtendedParameterTypeBits;
-  } DUMMYSTRUCTNAME;
+  uint8_t Type;
+  uint8_t Reserved[7];
   union {
     uint64_t ULong64;
     void *Pointer;
     size_t Size;
     intptr_t Handle;
     unsigned ULong;
-  } DUMMYUNIONNAME;
+  };
 };
 
 #endif /* COSMOPOLITAN_LIBC_NT_STRUCT_MEMEXTENDEDPARAMETER_H_ */
diff --git a/libc/nt/struct/securityattributes.h b/libc/nt/struct/securityattributes.h
index e481ede22..05145944c 100644
--- a/libc/nt/struct/securityattributes.h
+++ b/libc/nt/struct/securityattributes.h
@@ -9,9 +9,9 @@ struct NtSecurityAttributes {
   bool32 bInheritHandle;
 };
 
-const char *DescribeNtSecurityAttributes(char[32],
-                                         const struct NtSecurityAttributes *);
+const char *_DescribeNtSecurityAttributes(char[32],
+                                          const struct NtSecurityAttributes *);
 #define DescribeNtSecurityAttributes(x) \
-  DescribeNtSecurityAttributes(alloca(32), x)
+  _DescribeNtSecurityAttributes(alloca(32), x)
 
 #endif /* COSMOPOLITAN_LIBC_NT_STRUCT_SECURITYATTRIBUTES_H_ */
diff --git a/libc/nt/time.h b/libc/nt/time.h
index 59c359ca3..a415075f9 100644
--- a/libc/nt/time.h
+++ b/libc/nt/time.h
@@ -33,5 +33,10 @@ uint32_t GetTimeZoneInformation(
 uint32_t GetDynamicTimeZoneInformation(
     struct NtDynamicTimeZoneInformation *out_lpTimeZoneInformation);
 
+bool32 QueryInterruptTime(uint64_t *);                /* Windows 10+ */
+bool32 QueryInterruptTimePrecise(uint64_t *);         /* Windows 10+ */
+bool32 QueryUnbiasedInterruptTime(uint64_t *);        /* Windows  7+ */
+bool32 QueryUnbiasedInterruptTimePrecise(uint64_t *); /* Windows 10+ */
+
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_NT_TIME_H_ */
diff --git a/libc/nt/user32/AdjustWindowRectEx.S b/libc/nt/user32/AdjustWindowRectEx.S
new file mode 100644
index 000000000..04416b211
--- /dev/null
+++ b/libc/nt/user32/AdjustWindowRectEx.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_AdjustWindowRectEx,AdjustWindowRectEx
+
+	.text.windows
+	.ftrace1
+AdjustWindowRectEx:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_AdjustWindowRectEx(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	AdjustWindowRectEx,globl
+	.previous
diff --git a/libc/nt/user32/ClientToScreen.S b/libc/nt/user32/ClientToScreen.S
new file mode 100644
index 000000000..9bc45dee8
--- /dev/null
+++ b/libc/nt/user32/ClientToScreen.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_ClientToScreen,ClientToScreen
+
+	.text.windows
+	.ftrace1
+ClientToScreen:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_ClientToScreen(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	ClientToScreen,globl
+	.previous
diff --git a/libc/nt/user32/ClipCursor.S b/libc/nt/user32/ClipCursor.S
new file mode 100644
index 000000000..f2c7f19ec
--- /dev/null
+++ b/libc/nt/user32/ClipCursor.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_ClipCursor,ClipCursor
+
+	.text.windows
+	.ftrace1
+ClipCursor:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_ClipCursor(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	ClipCursor,globl
+	.previous
diff --git a/libc/nt/user32/CloseClipboard.S b/libc/nt/user32/CloseClipboard.S
new file mode 100644
index 000000000..b57e82022
--- /dev/null
+++ b/libc/nt/user32/CloseClipboard.S
@@ -0,0 +1,19 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_CloseClipboard,CloseClipboard
+
+	.text.windows
+	.ftrace1
+CloseClipboard:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	sub	$32,%rsp
+	call	*__imp_CloseClipboard(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	CloseClipboard,globl
+	.previous
diff --git a/libc/nt/user32/EmptyClipboard.S b/libc/nt/user32/EmptyClipboard.S
new file mode 100644
index 000000000..6038d29da
--- /dev/null
+++ b/libc/nt/user32/EmptyClipboard.S
@@ -0,0 +1,19 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_EmptyClipboard,EmptyClipboard
+
+	.text.windows
+	.ftrace1
+EmptyClipboard:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	sub	$32,%rsp
+	call	*__imp_EmptyClipboard(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	EmptyClipboard,globl
+	.previous
diff --git a/libc/nt/user32/GetAsyncKeyState.S b/libc/nt/user32/GetAsyncKeyState.S
new file mode 100644
index 000000000..9b1d32e1d
--- /dev/null
+++ b/libc/nt/user32/GetAsyncKeyState.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_GetAsyncKeyState,GetAsyncKeyState
+
+	.text.windows
+	.ftrace1
+GetAsyncKeyState:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_GetAsyncKeyState(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	GetAsyncKeyState,globl
+	.previous
diff --git a/libc/nt/user32/GetClipboardData.S b/libc/nt/user32/GetClipboardData.S
new file mode 100644
index 000000000..b51af7d3a
--- /dev/null
+++ b/libc/nt/user32/GetClipboardData.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_GetClipboardData,GetClipboardData
+
+	.text.windows
+	.ftrace1
+GetClipboardData:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_GetClipboardData(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	GetClipboardData,globl
+	.previous
diff --git a/libc/nt/user32/GetMonitorInfoW.S b/libc/nt/user32/GetMonitorInfoW.S
new file mode 100644
index 000000000..2ec6986fe
--- /dev/null
+++ b/libc/nt/user32/GetMonitorInfoW.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_GetMonitorInfoW,GetMonitorInfoW
+
+	.text.windows
+	.ftrace1
+GetMonitorInfo:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_GetMonitorInfoW(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	GetMonitorInfo,globl
+	.previous
diff --git a/libc/nt/user32/GetRawInputData.S b/libc/nt/user32/GetRawInputData.S
new file mode 100644
index 000000000..6324125ea
--- /dev/null
+++ b/libc/nt/user32/GetRawInputData.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_GetRawInputData,GetRawInputData
+
+	.text.windows
+	.ftrace1
+GetRawInputData:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_GetRawInputData(%rip),%rax
+	jmp	__sysv2nt6
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	GetRawInputData,globl
+	.previous
diff --git a/libc/nt/user32/GetSystemMetrics.S b/libc/nt/user32/GetSystemMetrics.S
new file mode 100644
index 000000000..4a92d3184
--- /dev/null
+++ b/libc/nt/user32/GetSystemMetrics.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_GetSystemMetrics,GetSystemMetrics
+
+	.text.windows
+	.ftrace1
+GetSystemMetrics:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_GetSystemMetrics(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	GetSystemMetrics,globl
+	.previous
diff --git a/libc/nt/user32/MonitorFromPoint.S b/libc/nt/user32/MonitorFromPoint.S
new file mode 100644
index 000000000..b27b7a8aa
--- /dev/null
+++ b/libc/nt/user32/MonitorFromPoint.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_MonitorFromPoint,MonitorFromPoint
+
+	.text.windows
+	.ftrace1
+MonitorFromPoint:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_MonitorFromPoint(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	MonitorFromPoint,globl
+	.previous
diff --git a/libc/nt/user32/MonitorFromWindow.S b/libc/nt/user32/MonitorFromWindow.S
new file mode 100644
index 000000000..ec49593a4
--- /dev/null
+++ b/libc/nt/user32/MonitorFromWindow.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_MonitorFromWindow,MonitorFromWindow
+
+	.text.windows
+	.ftrace1
+MonitorFromWindow:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_MonitorFromWindow(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	MonitorFromWindow,globl
+	.previous
diff --git a/libc/nt/user32/OpenClipboard.S b/libc/nt/user32/OpenClipboard.S
new file mode 100644
index 000000000..f6b8afb7e
--- /dev/null
+++ b/libc/nt/user32/OpenClipboard.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_OpenClipboard,OpenClipboard
+
+	.text.windows
+	.ftrace1
+OpenClipboard:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_OpenClipboard(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	OpenClipboard,globl
+	.previous
diff --git a/libc/nt/user32/PostMessageW.S b/libc/nt/user32/PostMessageW.S
new file mode 100644
index 000000000..5da8cf132
--- /dev/null
+++ b/libc/nt/user32/PostMessageW.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_PostMessageW,PostMessageW
+
+	.text.windows
+	.ftrace1
+PostMessage:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_PostMessageW(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	PostMessage,globl
+	.previous
diff --git a/libc/nt/user32/PtInRect.S b/libc/nt/user32/PtInRect.S
new file mode 100644
index 000000000..3a3ae8c38
--- /dev/null
+++ b/libc/nt/user32/PtInRect.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_PtInRect,PtInRect
+
+	.text.windows
+	.ftrace1
+PtInRect:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_PtInRect(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	PtInRect,globl
+	.previous
diff --git a/libc/nt/user32/RegisterRawInputDevices.S b/libc/nt/user32/RegisterRawInputDevices.S
new file mode 100644
index 000000000..9f100d244
--- /dev/null
+++ b/libc/nt/user32/RegisterRawInputDevices.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_RegisterRawInputDevices,RegisterRawInputDevices
+
+	.text.windows
+	.ftrace1
+RegisterRawInputDevices:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_RegisterRawInputDevices(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	RegisterRawInputDevices,globl
+	.previous
diff --git a/libc/nt/user32/ScreenToClient.S b/libc/nt/user32/ScreenToClient.S
new file mode 100644
index 000000000..3c1d2ca54
--- /dev/null
+++ b/libc/nt/user32/ScreenToClient.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_ScreenToClient,ScreenToClient
+
+	.text.windows
+	.ftrace1
+ScreenToClient:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_ScreenToClient(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	ScreenToClient,globl
+	.previous
diff --git a/libc/nt/user32/SetClipboardData.S b/libc/nt/user32/SetClipboardData.S
new file mode 100644
index 000000000..ca8e59591
--- /dev/null
+++ b/libc/nt/user32/SetClipboardData.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_SetClipboardData,SetClipboardData
+
+	.text.windows
+	.ftrace1
+SetClipboardData:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_SetClipboardData(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	SetClipboardData,globl
+	.previous
diff --git a/libc/nt/user32/SetCursorPos.S b/libc/nt/user32/SetCursorPos.S
new file mode 100644
index 000000000..f29847884
--- /dev/null
+++ b/libc/nt/user32/SetCursorPos.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_SetCursorPos,SetCursorPos
+
+	.text.windows
+	.ftrace1
+SetCursorPos:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_SetCursorPos(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	SetCursorPos,globl
+	.previous
diff --git a/libc/nt/user32/SetWindowLongPtrW.S b/libc/nt/user32/SetWindowLongPtrW.S
new file mode 100644
index 000000000..3ff044c05
--- /dev/null
+++ b/libc/nt/user32/SetWindowLongPtrW.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_SetWindowLongPtrW,SetWindowLongPtrW
+
+	.text.windows
+	.ftrace1
+SetWindowLongPtr:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_SetWindowLongPtrW(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	SetWindowLongPtr,globl
+	.previous
diff --git a/libc/nt/user32/TrackMouseEvent.S b/libc/nt/user32/TrackMouseEvent.S
new file mode 100644
index 000000000..7220d178a
--- /dev/null
+++ b/libc/nt/user32/TrackMouseEvent.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_TrackMouseEvent,TrackMouseEvent
+
+	.text.windows
+	.ftrace1
+TrackMouseEvent:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_TrackMouseEvent(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	TrackMouseEvent,globl
+	.previous
diff --git a/libc/nt/user32/UnregisterClassW.S b/libc/nt/user32/UnregisterClassW.S
new file mode 100644
index 000000000..398af1b53
--- /dev/null
+++ b/libc/nt/user32/UnregisterClassW.S
@@ -0,0 +1,18 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_UnregisterClassW,UnregisterClassW
+
+	.text.windows
+	.ftrace1
+UnregisterClass:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	__imp_UnregisterClassW(%rip),%rax
+	jmp	__sysv2nt
+#elif defined(__aarch64__)
+	mov	x0,#0
+	ret
+#endif
+	.endfn	UnregisterClass,globl
+	.previous
diff --git a/libc/nt/user32/WindowFromPoint.S b/libc/nt/user32/WindowFromPoint.S
new file mode 100644
index 000000000..eaf6c0410
--- /dev/null
+++ b/libc/nt/user32/WindowFromPoint.S
@@ -0,0 +1,20 @@
+#include "libc/nt/codegen.h"
+.imp	user32,__imp_WindowFromPoint,WindowFromPoint
+
+	.text.windows
+	.ftrace1
+WindowFromPoint:
+	.ftrace2
+#ifdef __x86_64__
+	push	%rbp
+	mov	%rsp,%rbp
+	mov	%rdi,%rcx
+	sub	$32,%rsp
+	call	*__imp_WindowFromPoint(%rip)
+	leave
+#elif defined(__aarch64__)
+	mov	x0,#0
+#endif
+	ret
+	.endfn	WindowFromPoint,globl
+	.previous
diff --git a/libc/proc/BUILD.mk b/libc/proc/BUILD.mk
index 5c50271d5..8491e5635 100644
--- a/libc/proc/BUILD.mk
+++ b/libc/proc/BUILD.mk
@@ -30,12 +30,15 @@ LIBC_PROC_A_DIRECTDEPS =				\
 	LIBC_MEM					\
 	LIBC_NEXGEN32E					\
 	LIBC_NT_KERNEL32				\
+	LIBC_NT_NTDLL					\
 	LIBC_NT_PSAPI					\
 	LIBC_RUNTIME					\
 	LIBC_STR					\
 	LIBC_SYSV					\
 	LIBC_SYSV_CALLS					\
-	THIRD_PARTY_NSYNC
+	THIRD_PARTY_DLMALLOC				\
+	THIRD_PARTY_GDTOA				\
+	THIRD_PARTY_NSYNC				\
 
 LIBC_PROC_A_DEPS :=					\
 	$(call uniq,$(foreach x,$(LIBC_PROC_A_DIRECTDEPS),$($(x))))
diff --git a/libc/proc/describefds.c b/libc/proc/describefds.c
index 71d36c17f..4bc203fe3 100644
--- a/libc/proc/describefds.c
+++ b/libc/proc/describefds.c
@@ -17,17 +17,18 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
+#include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/maps.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/files.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/startupinfo.h"
 #include "libc/sysv/consts/o.h"
 
-#define FDS_VAR "_COSMO_FDS="
+#define FDS_VAR "_COSMO_FDS_V2="
 
 #define MAX_ENTRY_BYTES 256
 
@@ -99,6 +100,8 @@ textwindows char *__describe_fds(const struct Fd *fds, size_t fdslen,
     if (__is_cloexec(f))
       continue;
     ++handlecount;
+    if (f->cursor)
+      ++handlecount;
   }
   if (!(handles = calloc(handlecount, sizeof(*handles)))) {
   OnFailure:
@@ -116,17 +119,31 @@ textwindows char *__describe_fds(const struct Fd *fds, size_t fdslen,
     // make inheritable version of handle exist in creator process
     if (!DuplicateHandle(GetCurrentProcess(), f->handle, hCreatorProcess,
                          &handle, 0, true, kNtDuplicateSameAccess)) {
-      STRACE("__describe_fds() DuplicateHandle() failed w/ %d", GetLastError());
       __winerr();
       goto OnFailure;
     }
-    for (uint32_t i = 0; i < 3; ++i) {
-      if (lpStartupInfo->stdiofds[i] == f->handle) {
+    for (uint32_t i = 0; i < 3; ++i)
+      if (lpStartupInfo->stdiofds[i] == f->handle)
         lpStartupInfo->stdiofds[i] = handle;
-      }
-    }
     handles[hi++] = handle;
 
+    // get shared memory handle for the file offset pointer
+    intptr_t shand = 0;
+    if (f->cursor) {
+      struct Map *map;
+      if (!(map = __maps_floor((const char *)f->cursor->shared)) ||
+          map->addr != (const char *)f->cursor->shared) {
+        errno = EFAULT;
+        goto OnFailure;
+      }
+      if (!DuplicateHandle(GetCurrentProcess(), map->hand, hCreatorProcess,
+                           &shand, 0, true, kNtDuplicateSameAccess)) {
+        __winerr();
+        goto OnFailure;
+      }
+      handles[hi++] = shand;
+    }
+
     // ensure output string has enough space for new entry
     if (sb.i + MAX_ENTRY_BYTES > sb.n) {
       char *p2;
@@ -151,7 +168,7 @@ textwindows char *__describe_fds(const struct Fd *fds, size_t fdslen,
     *p++ = '_';
     p = FormatInt64(p, f->mode);
     *p++ = '_';
-    p = FormatInt64(p, f->pointer);
+    p = FormatInt64(p, shand);
     *p++ = '_';
     p = FormatInt64(p, f->type);
     *p++ = '_';
diff --git a/libc/proc/describefds.internal.h b/libc/proc/describefds.internal.h
index 437fabdf7..1cde5234b 100644
--- a/libc/proc/describefds.internal.h
+++ b/libc/proc/describefds.internal.h
@@ -1,9 +1,11 @@
 #ifndef COSMOPOLITAN_LIBC_PROC_DESCRIBEFDS_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_PROC_DESCRIBEFDS_INTERNAL_H_
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/nt/struct/startupinfo.h"
 COSMOPOLITAN_C_START_
 
+#define CURSOR_ADDRESS_FLAG 0x4000000000000000
+
 bool __is_cloexec(const struct Fd *) libcesque;
 void __undescribe_fds(int64_t, int64_t *, uint32_t) libcesque;
 char *__describe_fds(const struct Fd *, size_t, struct NtStartupInfo *, int64_t,
diff --git a/libc/proc/execve-nt.greg.c b/libc/proc/execve-nt.greg.c
index 03d8590c1..42cb01c67 100644
--- a/libc/proc/execve-nt.greg.c
+++ b/libc/proc/execve-nt.greg.c
@@ -17,53 +17,89 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/atomic.h"
+#include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
+#include "libc/intrin/dll.h"
+#include "libc/intrin/fds.h"
 #include "libc/intrin/kprintf.h"
+#include "libc/intrin/strace.h"
 #include "libc/mem/mem.h"
+#include "libc/nt/accounting.h"
 #include "libc/nt/enum/processaccess.h"
 #include "libc/nt/enum/startf.h"
+#include "libc/nt/enum/status.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/files.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/processinformation.h"
 #include "libc/nt/struct/startupinfo.h"
+#include "libc/nt/synchronization.h"
+#include "libc/nt/thread.h"
+#include "libc/nt/thunk/msabi.h"
 #include "libc/proc/describefds.internal.h"
 #include "libc/proc/ntspawn.h"
+#include "libc/runtime/internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/at.h"
 #include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #ifdef __x86_64__
 
+__msabi extern typeof(CloseHandle) *const __imp_CloseHandle;
+__msabi extern typeof(TerminateProcess) *const __imp_TerminateProcess;
+
+extern atomic_int __sig_worker_state;
+
+static void sys_execve_nt_abort(sigset_t sigmask) {
+  __sig_worker_state &= ~2;
+  __sig_unblock(sigmask);
+}
+
 textwindows int sys_execve_nt(const char *program, char *const argv[],
                               char *const envp[]) {
 
   // execve() needs to be @asyncsignalsafe
   sigset_t sigmask = __sig_block();
-  _pthread_lock();
+  __sig_worker_state |= 2;
+  for (;;)
+    if (__sig_worker_state & 1)
+      break;
 
   // new process should be a child of our parent
-  int64_t hParentProcess;
-  int ppid = sys_getppid_nt();
-  if (!(hParentProcess = OpenProcess(
-            kNtProcessDupHandle | kNtProcessCreateProcess, false, ppid))) {
-    _pthread_unlock();
-    __sig_unblock(sigmask);
-    return -1;
-  }
+  int64_t hParentProcess =
+      sys_getppid_nt_win32
+          ? OpenProcess(kNtProcessDupHandle | kNtProcessCreateProcess, false,
+                        sys_getppid_nt_win32)
+          : 0;
+
+  // inherit pid
+  char pidvar[11 + 21];
+  FormatUint64(stpcpy(pidvar, "_COSMO_PID="), __pid);
 
   // inherit signal mask
   char maskvar[6 + 21];
   FormatUint64(stpcpy(maskvar, "_MASK="), sigmask);
 
+  // inherit parent process id
+  char ppidvar[12 + 21 + 1 + 21 + 1], *p = ppidvar;
+  p = stpcpy(p, "_COSMO_PPID=");
+  if (hParentProcess) {
+    p = FormatUint64(p, sys_getppid_nt_win32);
+    *p++ = ':';
+    p = FormatUint64(p, __pid);
+    setenv("_COSMO_PPID", ppidvar, true);
+  }
+
   // define stdio handles for the spawned subprocess
   struct NtStartupInfo si = {
       .cb = sizeof(struct NtStartupInfo),
@@ -77,29 +113,44 @@ textwindows int sys_execve_nt(const char *program, char *const argv[],
     }
   }
 
+  // which process is responsible for spawning the child?
+  int64_t hCreatorProcess;
+  if (hParentProcess) {
+    hCreatorProcess = hParentProcess;
+  } else {
+    hCreatorProcess = GetCurrentProcess();
+  }
+
   // pass serialized file descriptor table in environment
   char *fdspec;
   int64_t *lpExplicitHandles;
   uint32_t dwExplicitHandleCount;
-  if (!(fdspec = __describe_fds(g_fds.p, g_fds.n, &si, hParentProcess,
+  if (!(fdspec = __describe_fds(g_fds.p, g_fds.n, &si, hCreatorProcess,
                                 &lpExplicitHandles, &dwExplicitHandleCount))) {
-    CloseHandle(hParentProcess);
-    _pthread_unlock();
-    __sig_unblock(sigmask);
+    if (hParentProcess)
+      __imp_CloseHandle(hParentProcess);
+    sys_execve_nt_abort(sigmask);
     return -1;
   }
 
+  // inherit pending signals
+  atomic_fetch_or_explicit(
+      __sig.process,
+      atomic_load_explicit(&__get_tls()->tib_sigpending, memory_order_acquire),
+      memory_order_release);
+
   // launch the process
   struct NtProcessInformation pi;
   int rc = ntspawn(&(struct NtSpawnArgs){
-      AT_FDCWD, program, argv, envp, (char *[]){fdspec, maskvar, 0}, 0, 0,
-      hParentProcess, lpExplicitHandles, dwExplicitHandleCount, &si, &pi});
-  __undescribe_fds(hParentProcess, lpExplicitHandles, dwExplicitHandleCount);
+      AT_FDCWD, program, argv, envp,
+      (char *[]){fdspec, maskvar, pidvar, ppidvar, 0}, 0, 0, hCreatorProcess,
+      lpExplicitHandles, dwExplicitHandleCount, &si, &pi});
+  __undescribe_fds(hCreatorProcess, lpExplicitHandles, dwExplicitHandleCount);
   if (rc == -1) {
     free(fdspec);
-    CloseHandle(hParentProcess);
-    _pthread_unlock();
-    __sig_unblock(sigmask);
+    if (hParentProcess)
+      __imp_CloseHandle(hParentProcess);
+    sys_execve_nt_abort(sigmask);
     if (GetLastError() == kNtErrorSharingViolation) {
       return etxtbsy();
     } else {
@@ -107,12 +158,56 @@ textwindows int sys_execve_nt(const char *program, char *const argv[],
     }
   }
 
-  // give child to libc/proc/proc.c worker thread in parent
-  int64_t handle;
-  unassert(DuplicateHandle(GetCurrentProcess(), pi.hProcess, hParentProcess,
-                           &handle, 0, false, kNtDuplicateSameAccess));
-  unassert(!(handle & 0xFFFFFFFFFF000000));
-  TerminateThisProcess(0x23000000u | handle);
+  // check if parent spoofing worked
+  if (hParentProcess) {
+    // give child to libc/proc/proc.c worker thread in parent
+    int64_t handle;
+    if (DuplicateHandle(GetCurrentProcess(), pi.hProcess, hParentProcess,
+                        &handle, 0, false, kNtDuplicateSameAccess)) {
+      unassert(!(handle & 0xFFFFFFFFFF000000));
+      __imp_TerminateProcess(-1, 0x23000000u | handle);
+    } else {
+      // TODO(jart): Why does `make loc` print this?
+      // kprintf("DuplicateHandle failed w/ %d\n", GetLastError());
+      __imp_TerminateProcess(-1, ECHILD);
+    }
+    __builtin_unreachable();
+  }
+
+  // we couldn't reparent the new process
+  STRACE("warning: execve() lingering due to non-cosmo parent process");
+
+  // terminate other threads
+  _pthread_lock();
+  struct Dll *e;
+  struct PosixThread *me = _pthread_self();
+  for (e = dll_first(_pthread_list); e; e = dll_next(_pthread_list, e)) {
+    struct PosixThread *pt = POSIXTHREAD_CONTAINER(e);
+    if (pt == me)
+      continue;
+    TerminateThread(
+        atomic_load_explicit(&pt->tib->tib_syshand, memory_order_relaxed),
+        SIGKILL);
+  }
+
+  // wait for child to terminate and propagate exit code
+  for (;;) {
+    uint32_t status;
+    WaitForSingleObject(pi.hProcess, -1u);
+    GetExitCodeProcess(pi.hProcess, &status);
+    if (status != kNtStillActive) {
+      if ((status & 0xFF000000u) == 0x23000000u) {
+        // handle child execve()
+        __imp_CloseHandle(pi.hProcess);
+        pi.hProcess = status & 0x00FFFFFF;
+      } else {
+        // handle child _Exit()
+        if (status == 0xc9af3d51u)
+          status = kNtStillActive;
+        TerminateThisProcess(status);
+      }
+    }
+  }
 }
 
 #endif /* __x86_64__ */
diff --git a/libc/proc/execve-sysv.c b/libc/proc/execve-sysv.c
index 93c22f8c0..e0dbc53b1 100644
--- a/libc/proc/execve-sysv.c
+++ b/libc/proc/execve-sysv.c
@@ -27,9 +27,9 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/mem/alloca.h"
 #include "libc/paths.h"
diff --git a/libc/proc/execve.c b/libc/proc/execve.c
index 2fde8ee9b..b610f8b29 100644
--- a/libc/proc/execve.c
+++ b/libc/proc/execve.c
@@ -22,10 +22,10 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/promises.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/promises.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/libfatal.internal.h"
 #include "libc/runtime/runtime.h"
@@ -36,14 +36,55 @@
 /**
  * Replaces current process with program.
  *
+ * Your `prog` may be an actually portable executable or a platform
+ * native binary (e.g. ELF, Mach-O, PE). On UNIX systems, your execve
+ * implementation will try to find where the `ape` interpreter program
+ * is installed on your system. The preferred location is `/usr/bin/ape`
+ * except on Apple Silicon where it's `/usr/local/bin/ape`. The $TMPDIR
+ * and $HOME locations that the APE shell script extracts the versioned
+ * ape binaries to will also be checked as a fallback path. Finally, if
+ * `prog` isn't an executable in any recognizable format, cosmo assumes
+ * it's a bourne shell script and launches it under /bin/sh.
+ *
+ * The signal mask and pending signals are inherited by the new process.
+ * Note the NetBSD kernel has a bug where pending signals are cleared.
+ *
+ * File descriptors that haven't been marked `O_CLOEXEC` through various
+ * devices such as open() and fcntl() will be inherited by the executed
+ * subprocess. The current file position of the duplicated descriptors
+ * is shared across processes. On Windows, `prog` needs to be built by
+ * cosmocc in order to properly inherit file descriptors. If a program
+ * compiled by MSVC or Cygwin is launched instead, then only the stdio
+ * file descriptors can be passed along.
+ *
  * On Windows, `argv` and `envp` can't contain binary strings. They need
  * to be valid UTF-8 in order to round-trip the WIN32 API, without being
  * corrupted.
  *
- * On Windows, only file descriptors 0, 1 and 2 can be passed to a child
- * process in such a way that allows them to be automatically discovered
- * when the child process initializes. Cosmpolitan currently treats your
- * other file descriptors as implicitly O_CLOEXEC.
+ * On Windows, cosmo execve uses parent spoofing to implement the UNIX
+ * behavior of replacing the current process. Since POSIX.1 also needs
+ * us to maintain the same PID number too, the _COSMO_PID environemnt
+ * variable is passed to the child process which specifies a spoofed
+ * PID. Whatever is in that variable will be reported by getpid() and
+ * other cosmo processes will be able to send signals to the process
+ * using that pid, via kill(). These synthetic PIDs which are only
+ * created by execve could potentially overlap with OS assignments if
+ * Windows recycles them. Cosmo avoids that by tracking handles of
+ * subprocesses. Each process has its own process manager thread, to
+ * associate pids with win32 handles, and execve will tell the parent
+ * process its new handle when it changes. However it's not perfect.
+ * There's still situations where processes created by execve() can
+ * cause surprising things to happen. For an alternative, consider
+ * posix_spawn() which is fastest and awesomest across all OSes.
+ *
+ * On Windows, support is currently not implemented for inheriting
+ * setitimer() and alarm() into an executed process.
+ *
+ * On Windows, support is currently not implemented for inheriting
+ * getrusage() statistics into an executed process.
+ *
+ * The executed process will share the same terminal and current
+ * directory.
  *
  * @param program will not be PATH searched, see commandv()
  * @param argv[0] is the name of the program to run
diff --git a/libc/proc/fexecve.c b/libc/proc/fexecve.c
index 9ed672c8d..762865acf 100644
--- a/libc/proc/fexecve.c
+++ b/libc/proc/fexecve.c
@@ -27,10 +27,10 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
 #include "libc/proc/execve.internal.h"
diff --git a/libc/proc/fork-nt.c b/libc/proc/fork-nt.c
index 7e8f89cac..7f0ddca2d 100644
--- a/libc/proc/fork-nt.c
+++ b/libc/proc/fork-nt.c
@@ -16,423 +16,306 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "ape/sections.internal.h"
-#include "libc/assert.h"
-#include "libc/atomic.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/state.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/errno.h"
-#include "libc/fmt/itoa.h"
-#include "libc/intrin/atomic.h"
-#include "libc/intrin/directmap.internal.h"
+#include "libc/intrin/directmap.h"
+#include "libc/intrin/dll.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/intrin/maps.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
-#include "libc/nt/createfile.h"
-#include "libc/nt/enum/accessmask.h"
+#include "libc/limits.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/creationdisposition.h"
 #include "libc/nt/enum/filemapflags.h"
+#include "libc/nt/enum/memflags.h"
 #include "libc/nt/enum/pageflags.h"
+#include "libc/nt/enum/processcreationflags.h"
 #include "libc/nt/enum/startf.h"
 #include "libc/nt/errors.h"
-#include "libc/nt/ipc.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
-#include "libc/nt/signals.h"
-#include "libc/nt/struct/ntexceptionpointers.h"
+#include "libc/nt/struct/processinformation.h"
+#include "libc/nt/struct/startupinfo.h"
 #include "libc/nt/thread.h"
 #include "libc/nt/thunk/msabi.h"
-#include "libc/proc/ntspawn.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/nt/winsock.h"
+#include "libc/proc/proc.h"
 #include "libc/runtime/internal.h"
-#include "libc/runtime/memtrack.internal.h"
 #include "libc/runtime/runtime.h"
-#include "libc/runtime/stack.h"
 #include "libc/runtime/symbols.internal.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/at.h"
-#include "libc/sysv/consts/limits.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/thread/itimer.internal.h"
-#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/tls.h"
 #ifdef __x86_64__
 
 extern long __klog_handle;
-extern atomic_uint free_waiters_mu;
-void WipeKeystrokes(void);
-__msabi extern typeof(GetCurrentProcessId) *const __imp_GetCurrentProcessId;
+extern bool __winmain_isfork;
+extern intptr_t __winmain_jmpbuf[5];
+extern struct CosmoTib *__winmain_tib;
 
-static textwindows wontreturn void AbortFork(const char *func) {
+__msabi extern typeof(TlsAlloc) *const __imp_TlsAlloc;
+__msabi extern typeof(MapViewOfFileEx) *const __imp_MapViewOfFileEx;
+__msabi extern typeof(VirtualProtectEx) *const __imp_VirtualProtectEx;
+
+textwindows wontreturn static void AbortFork(const char *func, void *addr) {
 #if SYSDEBUG
-  kprintf("fork() %s() failed with win32 error %d\n", func, GetLastError());
+  kprintf("fork() %!s(%lx) failed with win32 error %u\n", func, addr,
+          GetLastError());
 #endif
   TerminateThisProcess(SIGSTKFLT);
 }
 
-static textwindows char16_t *ParseInt(char16_t *p, int64_t *x) {
-  *x = 0;
-  while (*p == ' ')
-    p++;
-  while ('0' <= *p && *p <= '9') {
-    *x *= 10;
-    *x += *p++ - '0';
-  }
-  return p;
-}
-
-static inline textwindows ssize_t ForkIo(int64_t h, char *p, size_t n,
-                                         bool32 (*f)(int64_t, void *, uint32_t,
-                                                     uint32_t *,
-                                                     struct NtOverlapped *)) {
-  size_t i;
-  uint32_t x;
-  for (i = 0; i < n; i += x) {
-    if (!f(h, p + i, n - i, &x, NULL)) {
-      return __winerr();
-    }
-  }
-  return i;
-}
-
-static dontinline textwindows bool ForkIo2(int64_t h, void *buf, size_t n,
-                                           bool32 (*fn)(int64_t, void *,
-                                                        uint32_t, uint32_t *,
-                                                        struct NtOverlapped *),
-                                           const char *sf, bool ischild) {
-  ssize_t rc = ForkIo(h, buf, n, fn);
-  if (ischild) {
-    __tls_enabled_set(false);  // prevent tls crash in kprintf
-    __pid = __imp_GetCurrentProcessId();
-    __klog_handle = 0;
-  }
-  NTTRACE("%s(%ld, %p, %'zu) → %'zd% m", sf, h, buf, n, rc);
-  return rc != -1;
-}
-
-static dontinline textwindows bool WriteAll(int64_t h, void *buf, size_t n) {
-  bool ok;
-  ok = ForkIo2(h, buf, n, (void *)WriteFile, "WriteFile", false);
-#ifndef NDEBUG
-  if (ok)
-    ok = ForkIo2(h, &n, sizeof(n), (void *)WriteFile, "WriteFile", false);
-#endif
-#if SYSDEBUG
-  if (!ok) {
-    kprintf("failed to write %zu bytes to forked child: %d\n", n,
-            GetLastError());
-  }
-#endif
-  // Sleep(10);
-  return ok;
-}
-
-static textwindows dontinline void ReadOrDie(int64_t h, void *buf, size_t n) {
-  if (!ForkIo2(h, buf, n, ReadFile, "ReadFile", true)) {
-    AbortFork("ReadFile1");
-  }
-#ifndef NDEBUG
-  size_t got;
-  if (!ForkIo2(h, &got, sizeof(got), ReadFile, "ReadFile", true)) {
-    AbortFork("ReadFile2");
-  }
-  if (got != n) {
-    AbortFork("ReadFile_SIZE_CHECK");
-  }
-#endif
-}
-
-static textwindows int64_t MapOrDie(uint32_t prot, uint64_t size) {
-  int64_t h;
-  for (;;) {
-    if ((h = CreateFileMapping(-1, 0, prot, size >> 32, size, 0))) {
-      return h;
-    }
-    if (GetLastError() == kNtErrorAccessDenied) {
-      switch (prot) {
-        case kNtPageExecuteWritecopy:
-          prot = kNtPageWritecopy;
-          continue;
-        case kNtPageExecuteReadwrite:
-          prot = kNtPageReadwrite;
-          continue;
-        case kNtPageExecuteRead:
-          prot = kNtPageReadonly;
-          continue;
-        default:
-          break;
-      }
-    }
-    AbortFork("MapOrDie");
-  }
-}
-
-static textwindows void ViewOrDie(int64_t h, uint32_t access, size_t pos,
+textwindows static void ViewOrDie(int64_t h, uint32_t access, size_t pos,
                                   size_t size, void *base) {
 TryAgain:
-  if (!MapViewOfFileEx(h, access, pos >> 32, pos, size, base)) {
+  if (!__imp_MapViewOfFileEx(h, access, pos >> 32, pos, size, base)) {
     if ((access & kNtFileMapExecute) &&
         GetLastError() == kNtErrorAccessDenied) {
       access &= ~kNtFileMapExecute;
       goto TryAgain;
     }
-    AbortFork("ViewOrDie");
+    AbortFork("ViewOrDie", base);
   }
 }
 
-static __msabi textwindows int OnForkCrash(struct NtExceptionPointers *ep) {
-  kprintf("error: fork() child crashed!%n"
-          "\tExceptionCode = %#x%n"
-          "\tRip = %x%n",
-          ep->ExceptionRecord->ExceptionCode,
-          ep->ContextRecord ? ep->ContextRecord->Rip : -1);
-  TerminateThisProcess(SIGSTKFLT);
-}
+textwindows static void sys_fork_nt_child(void) {
 
-static textwindows void *Malloc(size_t size) {
-  return HeapAlloc(GetProcessHeap(), 0, size);
-}
+  // setup runtime
+  __klog_handle = 0;
+  __tls_index = __imp_TlsAlloc();
+  __morph_tls();
+  __set_tls_win32(__winmain_tib);
+  __tls_enabled = true;
 
-textwindows void WinMainForked(void) {
-  jmp_buf jb;
-  int64_t reader;
-  int64_t savetsc;
-  struct Map *map;
-  uint32_t varlen, oldprot;
-  char16_t fvar[21 + 1 + 21 + 1];
-  struct Fds *fds = __veil("r", &g_fds);
+  // resurrect shared memory mappings
+  struct Map *next;
+  for (struct Map *map = __maps_first(); map; map = next) {
+    next = __maps_next(map);
 
-  // check to see if the process was actually forked
-  // this variable should have the pipe handle numba
-  varlen = GetEnvironmentVariable(u"_FORK", fvar, ARRAYLEN(fvar));
-  if (!varlen || varlen >= ARRAYLEN(fvar))
-    return;
-  /* STRACE("WinMainForked()"); */
-  SetEnvironmentVariable(u"_FORK", NULL);
-#if SYSDEBUG
-  int64_t oncrash = AddVectoredExceptionHandler(1, (void *)OnForkCrash);
-#endif
-  ParseInt(fvar, &reader);
+    // cleanup nofork mappings
+    if (map->flags & MAP_NOFORK) {
+      if ((map->flags & MAP_TYPE) != MAP_FILE) {
+        tree_remove(&__maps.maps, &map->tree);
+        __maps.pages -= (map->size + __pagesize - 1) / __pagesize;
+        __maps.count -= 1;
+        __maps_free(map);
+      }
+      continue;
+    }
 
-  // read the cpu state from the parent process & plus
-  ReadOrDie(reader, jb, sizeof(jb));
-
-  // read memory mappings from parent process
-  struct Map *maps = __maps.maps;
-  for (;;) {
-    map = Malloc(sizeof(*map));
-    ReadOrDie(reader, map, sizeof(*map));
+    // private maps already copied/protected to child by parent
     if ((map->flags & MAP_TYPE) != MAP_SHARED) {
-      // we don't need to close the map handle because sys_mmap_nt
-      // doesn't mark it inheritable across fork() for MAP_PRIVATE
-      ViewOrDie((map->h = MapOrDie(kNtPageExecuteReadwrite, map->size)),
-                kNtFileMapWrite | kNtFileMapExecute, 0, map->size, map->addr);
-      ReadOrDie(reader, map->addr, map->size);
-    } else {
-      // we can however safely inherit MAP_SHARED with zero copy
-      ViewOrDie(map->h,
-                map->readonlyfile ? kNtFileMapRead | kNtFileMapExecute
-                                  : kNtFileMapWrite | kNtFileMapExecute,
-                map->off, map->size, map->addr);
+      // it's not copy-on-write anymore
+      map->iscow = false;
+      // but it used VirtualAlloc() so munmap() must VirtualFree()
+      if (map->hand > 0) {
+        CloseHandle(map->hand);
+        map->hand = MAPS_VIRTUAL;
+      }
+      continue;
     }
-    dll_init(&map->elem);
-    bool isdone = !map->next;
-    map->next = maps;
-    maps = map;
-    if (isdone)
-      break;
-  }
 
-  // read the .data and .bss program image sections
-  savetsc = kStartTsc;
-  ReadOrDie(reader, __data_start, __data_end - __data_start);
-  ReadOrDie(reader, __bss_start, __bss_end - __bss_start);
-  kStartTsc = savetsc;
-  __threaded = false;
-  __tls_index = 0;
-  __tls_enabled_set(false);
+    // handle granularity aligned shared mapping
+    if (__maps_isalloc(map)) {
 
-  // fixup memory manager
-  __maps.free = 0;
-  __maps.used = 0;
-  __maps.maps = maps;
-  __maps.count = 0;
-  __maps.pages = 0;
-  dll_init(&__maps.stack.elem);
-  dll_make_first(&__maps.used, &__maps.stack.elem);
-  for (struct Map *map = maps; map; map = map->next) {
-    __maps.count += 1;
-    __maps.pages += (map->size + 4095) / 4096;
-    dll_make_last(&__maps.used, &map->elem);
-    if (!VirtualProtect(map->addr, map->size, __prot2nt(map->prot, map->iscow),
-                        &oldprot)) {
-      AbortFork("VirtualProtect");
+      // get true size of win32 allocation
+      size_t allocsize = map->size;
+      for (struct Map *map2 = next; map2; map2 = __maps_next(map2)) {
+        if (!__maps_isalloc(map2) && map->addr + allocsize == map2->addr) {
+          allocsize += map2->size;
+        } else {
+          break;
+        }
+      }
+
+      // create allocation with most permissive access possible
+      // if we don't create as rwx then we can't mprotect(rwx) later
+      unsigned access;
+      if (map->readonlyfile) {
+        access = kNtFileMapRead | kNtFileMapExecute;
+      } else {
+        access = kNtFileMapWrite | kNtFileMapExecute;
+      }
+
+      // resurrect copyless memory via inherited win32 handle
+      ViewOrDie(map->hand, access, map->off, allocsize, map->addr);
     }
-  }
-  __maps_init();
 
-  // mitosis complete
-  if (!CloseHandle(reader)) {
-    AbortFork("CloseHandle");
+    // restore memory protection status on pages
+    unsigned old_protect;
+    if (!__imp_VirtualProtectEx(GetCurrentProcess(), map->addr, map->size,
+                                __prot2nt(map->prot, false), &old_protect))
+      AbortFork("VirtualProtectEx", map->addr);
   }
 
+  // function tracing is now safe
+  ftrace_enabled(+1);
+
+  // initialize winsock
+  void WinSockFork(void);
+  if (_weaken(WinSockFork))
+    _weaken(WinSockFork)();
+
   // rewrap the stdin named pipe hack
   // since the handles closed on fork
-  fds->p[0].handle = GetStdHandle(kNtStdInputHandle);
-  fds->p[1].handle = GetStdHandle(kNtStdOutputHandle);
-  fds->p[2].handle = GetStdHandle(kNtStdErrorHandle);
+  g_fds.p[0].handle = GetStdHandle(kNtStdInputHandle);
+  g_fds.p[1].handle = GetStdHandle(kNtStdOutputHandle);
+  g_fds.p[2].handle = GetStdHandle(kNtStdErrorHandle);
+}
 
-  // restore the crash reporting stuff
-#if SYSDEBUG
-  RemoveVectoredExceptionHandler(oncrash);
-#endif
-  if (_weaken(__sig_init)) {
-    _weaken(__sig_init)();
+textwindows static int sys_fork_nt_parent(uint32_t dwCreationFlags) {
+
+  // allocate process object
+  struct Proc *proc;
+  if (!(proc = __proc_new()))
+    return -1;
+
+  // get path of this executable
+  char16_t prog[PATH_MAX];
+  unsigned got = GetModuleFileName(0, prog, ARRAYLEN(prog));
+  if (!got || got >= ARRAYLEN(prog)) {
+    dll_make_first(&__proc.free, &proc->elem);
+    enomem();
+    return -1;
   }
 
-  // jump back into function below
-  longjmp(jb, 1);
+  // spawn new process in suspended state
+  struct NtProcessInformation procinfo;
+  struct NtStartupInfo startinfo = {
+      .cb = sizeof(struct NtStartupInfo),
+      .dwFlags = kNtStartfUsestdhandles,
+      .hStdInput = g_fds.p[0].handle,
+      .hStdOutput = g_fds.p[1].handle,
+      .hStdError = g_fds.p[2].handle,
+  };
+  if (!CreateProcess(prog, 0, 0, 0, true,
+                     dwCreationFlags | kNtCreateSuspended |
+                         kNtInheritParentAffinity |
+                         kNtCreateUnicodeEnvironment |
+                         GetPriorityClass(GetCurrentProcess()),
+                     0, 0, &startinfo, &procinfo)) {
+    STRACE("fork() %s() failed w/ %m %d", "CreateProcess", GetLastError());
+    dll_make_first(&__proc.free, &proc->elem);
+    if (errno != ENOMEM)
+      eagain();
+    return -1;
+  }
+
+  // ensure process can be signaled before returning
+  UnmapViewOfFile(__sig_map_process(procinfo.dwProcessId, kNtOpenAlways));
+
+  // let's go
+  bool ok = true;
+
+  // copy memory manager maps
+  for (struct MapSlab *slab =
+           atomic_load_explicit(&__maps.slabs, memory_order_acquire);
+       slab; slab = slab->next) {
+    ok = ok && !!VirtualAllocEx(procinfo.hProcess, slab, MAPS_SIZE,
+                                kNtMemReserve | kNtMemCommit, kNtPageReadwrite);
+    ok =
+        ok && !!WriteProcessMemory(procinfo.hProcess, slab, slab, MAPS_SIZE, 0);
+  }
+
+  // copy private memory maps
+  int alloc_prot = -1;
+  for (struct Map *map = __maps_first(); map; map = __maps_next(map)) {
+    if ((map->flags & MAP_TYPE) == MAP_SHARED)
+      continue;  // shared memory doesn't need to be copied to subprocess
+    if ((map->flags & MAP_NOFORK) && (map->flags & MAP_TYPE) != MAP_FILE)
+      continue;  // ignore things like signal worker stack memory
+    if (__maps_isalloc(map)) {
+      size_t allocsize = map->size;
+      for (struct Map *m2 = __maps_next(map); m2; m2 = __maps_next(m2)) {
+        if (!__maps_isalloc(m2) && map->addr + allocsize == m2->addr) {
+          allocsize += m2->size;
+        } else {
+          break;
+        }
+      }
+      if ((map->flags & MAP_NOFORK) && (map->flags & MAP_TYPE) == MAP_FILE) {
+        // portable executable segment
+        if (map->prot & PROT_EXEC)
+          // TODO(jart): write a __remorph_tls() function
+          continue;
+        if (!(map->prot & PROT_WRITE)) {
+          uint32_t child_old_protect;
+          ok = ok && !!VirtualProtectEx(procinfo.hProcess, map->addr, allocsize,
+                                        kNtPageReadwrite, &child_old_protect);
+          alloc_prot = PROT_READ | PROT_WRITE;
+        } else {
+          alloc_prot = map->prot;
+        }
+      } else {
+        // private mapping
+        uint32_t page_flags;
+        if (!(alloc_prot & PROT_WRITE)) {
+          page_flags = kNtPageReadwrite;
+          alloc_prot = PROT_READ | PROT_WRITE;
+        } else {
+          page_flags = __prot2nt(alloc_prot, false);
+        }
+        ok = ok && !!VirtualAllocEx(procinfo.hProcess, map->addr, allocsize,
+                                    kNtMemReserve | kNtMemCommit, page_flags);
+      }
+    }
+    uint32_t parent_old_protect;
+    if (!(map->prot & PROT_READ))
+      ok = ok && !!VirtualProtect(map->addr, map->size, kNtPageReadwrite,
+                                  &parent_old_protect);
+    ok = ok &&
+         !!WriteProcessMemory(procinfo.hProcess, map->addr, map->addr,
+                              (map->size + __pagesize - 1) & -__pagesize, 0);
+    if (map->prot != alloc_prot) {
+      uint32_t child_old_protect;
+      ok = ok &&
+           !!VirtualProtectEx(procinfo.hProcess, map->addr, map->size,
+                              __prot2nt(map->prot, false), &child_old_protect);
+    }
+    if (!(map->prot & PROT_READ))
+      ok = ok && !!VirtualProtect(map->addr, map->size, parent_old_protect,
+                                  &parent_old_protect);
+  }
+
+  // set process loose
+  ok = ok && ResumeThread(procinfo.hThread) != -1u;
+  ok &= !!CloseHandle(procinfo.hThread);
+
+  // return pid of new process
+  if (ok) {
+    proc->wasforked = true;
+    proc->handle = procinfo.hProcess;
+    proc->pid = procinfo.dwProcessId;
+    __proc_add(proc);
+    return procinfo.dwProcessId;
+  } else {
+    if (errno != ENOMEM)
+      eagain();  // posix fork() only specifies two errors
+    TerminateProcess(procinfo.hProcess, SIGKILL);
+    CloseHandle(procinfo.hProcess);
+    dll_make_first(&__proc.free, &proc->elem);
+    return -1;
+  }
 }
 
 textwindows int sys_fork_nt(uint32_t dwCreationFlags) {
-  char ok;
-  jmp_buf jb;
-  uint32_t op;
-  char **args;
-  int rc = -1;
-  struct Proc *proc;
-  struct CosmoTib *tib;
-  char16_t pipename[64];
-  int64_t reader, writer;
-  struct NtStartupInfo startinfo;
-  struct NtProcessInformation procinfo;
-  char *p, forkvar[6 + 21 + 1 + 21 + 1];
-  tib = __get_tls();
-  if (!(proc = __proc_new()))
-    return -1;
-  ftrace_enabled(-1);
-  strace_enabled(-1);
-  if (!setjmp(jb)) {
-    reader = CreateNamedPipe(__create_pipe_name(pipename), kNtPipeAccessInbound,
-                             kNtPipeTypeByte | kNtPipeReadmodeByte, 1, PIPE_BUF,
-                             PIPE_BUF, 0, &kNtIsInheritable);
-    writer = CreateFile(pipename, kNtGenericWrite, 0, 0, kNtOpenExisting, 0, 0);
-    if (reader != -1 && writer != -1) {
-      p = stpcpy(forkvar, "_FORK=");
-      p = FormatUint64(p, reader);
-      bzero(&startinfo, sizeof(startinfo));
-      startinfo.cb = sizeof(struct NtStartupInfo);
-      startinfo.dwFlags = kNtStartfUsestdhandles;
-      startinfo.hStdInput = g_fds.p[0].handle;
-      startinfo.hStdOutput = g_fds.p[1].handle;
-      startinfo.hStdError = g_fds.p[2].handle;
-      args = __argv;
-#if SYSDEBUG
-      int i;
-      // If --strace was passed to this program, then propagate it the
-      // forked process since the flag was removed by __intercept_flag
-      if (strace_enabled(0) > 0) {
-        int n;
-        for (n = 0; args[n];)
-          ++n;
-#pragma GCC push_options
-#pragma GCC diagnostic ignored "-Walloca-larger-than="
-        int nbytes = (n + 2) * sizeof(char *);
-        char **args2 = alloca(nbytes);
-        CheckLargeStackAllocation(args2, nbytes);
-#pragma GCC pop_options
-        for (i = 0; i < n; ++i)
-          args2[i] = args[i];
-        args2[i++] = "--strace";
-        args2[i] = 0;
-        args = args2;
-      }
-#endif
-      NTTRACE("STARTING SPAWN");
-      int spawnrc = ntspawn(&(struct NtSpawnArgs){
-          AT_FDCWD, GetProgramExecutableName(), args, environ,
-          (char *[]){forkvar, 0}, dwCreationFlags, 0, 0, 0, 0, &startinfo,
-          &procinfo});
-      if (spawnrc != -1) {
-        CloseHandle(procinfo.hThread);
-        ok = WriteAll(writer, jb, sizeof(jb));
-        for (struct Map *map = __maps.maps; ok && map; map = map->next) {
-          if (MAX((char *)__executable_start, map->addr) <
-              MIN((char *)_end, map->addr + map->size))
-            continue;  // executable image is loaded by windows
-          ok = WriteAll(writer, map, sizeof(*map));
-          if (ok && (map->flags & MAP_TYPE) != MAP_SHARED) {
-            // XXX: forking destroys thread guard pages currently
-            VirtualProtect(map->addr, map->size,
-                           __prot2nt(map->prot | PROT_READ, map->iscow), &op);
-            ok = WriteAll(writer, map->addr, map->size);
-          }
-        }
-        if (ok)
-          ok = WriteAll(writer, __data_start, __data_end - __data_start);
-        if (ok)
-          ok = WriteAll(writer, __bss_start, __bss_end - __bss_start);
-        if (ok) {
-          if (!CloseHandle(writer))
-            ok = false;
-          writer = -1;
-        }
-        if (ok) {
-          proc->wasforked = true;
-          proc->handle = procinfo.hProcess;
-          rc = proc->pid = procinfo.dwProcessId;
-          __proc_add(proc);
-        } else {
-          TerminateProcess(procinfo.hProcess, SIGKILL);
-          CloseHandle(procinfo.hProcess);
-        }
-      }
-    }
-    if (reader != -1)
-      CloseHandle(reader);
-    if (writer != -1)
-      CloseHandle(writer);
-    if (rc == -1 && errno != ENOMEM) {
-      eagain();  // posix fork() only specifies two errors
-    }
+  int rc;
+  __winmain_isfork = true;
+  __winmain_tib = __get_tls();
+  if (!__builtin_setjmp(__winmain_jmpbuf)) {
+    rc = sys_fork_nt_parent(dwCreationFlags);
   } else {
+    sys_fork_nt_child();
     rc = 0;
-    // re-apply code morphing for thread-local storage
-    __set_tls(tib);
-    __morph_tls();
-    __tls_enabled_set(true);
-    // the child's pending signals is initially empty
-    atomic_store_explicit(&__sig.pending, 0, memory_order_relaxed);
-    atomic_store_explicit(&tib->tib_sigpending, 0, memory_order_relaxed);
-    // re-enable threads
-    __enable_threads();
-    // re-apply code morphing for function tracing
-    if (ftrace_stackdigs) {
-      _weaken(__hook)(_weaken(ftrace_hook), _weaken(GetSymbolTable)());
-    }
-    // reset core runtime services
-    __proc_wipe();
-    WipeKeystrokes();
-    if (_weaken(__itimer_wipe)) {
-      _weaken(__itimer_wipe)();
-    }
-    // notify pthread join
-    atomic_store_explicit(&_pthread_static.ptid, GetCurrentThreadId(),
-                          memory_order_release);
   }
-  if (rc == -1) {
-    dll_make_first(&__proc.free, &proc->elem);
-  }
-  ftrace_enabled(+1);
-  strace_enabled(+1);
+  __winmain_isfork = false;
   return rc;
 }
 
diff --git a/libc/proc/fork.c b/libc/proc/fork.c
index d814902c9..fad92dc5a 100644
--- a/libc/proc/fork.c
+++ b/libc/proc/fork.c
@@ -16,79 +16,200 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
 #include "libc/atomic.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/internal.h"
+#include "libc/calls/sig.internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigset.h"
+#include "libc/calls/struct/metasigaltstack.h"
 #include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/struct/timespec.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/atomic.h"
+#include "libc/intrin/cxaatexit.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/kprintf.h"
 #include "libc/intrin/maps.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/stack.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/files.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
-#include "libc/nt/synchronization.h"
 #include "libc/nt/thread.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/nt/thunk/msabi.h"
+#include "libc/proc/proc.h"
 #include "libc/runtime/internal.h"
-#include "libc/runtime/memtrack.internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/syslib.internal.h"
-#include "libc/sysv/consts/sig.h"
+#include "libc/stdio/internal.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/ss.h"
+#include "libc/thread/itimer.h"
 #include "libc/thread/posixthread.internal.h"
-#include "libc/thread/tls.h"
+#include "libc/thread/thread.h"
+#include "third_party/dlmalloc/dlmalloc.h"
+#include "third_party/gdtoa/lock.h"
+#include "third_party/tz/lock.h"
 
-extern atomic_uint free_waiters_mu;
+__msabi extern typeof(GetCurrentProcessId) *const __imp_GetCurrentProcessId;
 
-static void _onfork_prepare(void) {
+extern atomic_int __sig_worker_state;
+extern pthread_mutex_t __cxa_lock_obj;
+extern pthread_mutex_t __pthread_lock_obj;
+
+void __rand64_lock(void);
+void __rand64_unlock(void);
+void __rand64_wipe(void);
+
+void __dlopen_lock(void);
+void __dlopen_unlock(void);
+void __dlopen_wipe(void);
+
+// first and last and always
+// it is the lord of all locks
+// subordinate to no other lock
+static pthread_mutex_t supreme_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static void fork_prepare_stdio(void) {
+  struct Dll *e;
+  // we acquire the following locks, in order
+  //
+  //   1. FILE objects created by the user
+  //   2. stdin, stdout, and stderr
+  //   3. __stdio.lock
+  //
+StartOver:
+  __stdio_lock();
+  for (e = dll_last(__stdio.files); e; e = dll_prev(__stdio.files, e)) {
+    FILE *f = FILE_CONTAINER(e);
+    if (f->forking)
+      continue;
+    f->forking = 1;
+    __stdio_ref(f);
+    __stdio_unlock();
+    _pthread_mutex_lock(&f->lock);
+    __stdio_unref(f);
+    goto StartOver;
+  }
+}
+
+static void fork_parent_stdio(void) {
+  struct Dll *e;
+  for (e = dll_first(__stdio.files); e; e = dll_next(__stdio.files, e)) {
+    FILE_CONTAINER(e)->forking = 0;
+    _pthread_mutex_unlock(&FILE_CONTAINER(e)->lock);
+  }
+  __stdio_unlock();
+}
+
+static void fork_child_stdio(void) {
+  struct Dll *e;
+  for (e = dll_first(__stdio.files); e; e = dll_next(__stdio.files, e)) {
+    _pthread_mutex_wipe_np(&FILE_CONTAINER(e)->lock);
+    FILE_CONTAINER(e)->forking = 0;
+  }
+  _pthread_mutex_wipe_np(&__stdio.lock);
+}
+
+static void fork_prepare(void) {
+  _pthread_mutex_lock(&supreme_lock);
   if (_weaken(_pthread_onfork_prepare))
     _weaken(_pthread_onfork_prepare)();
-  _pthread_lock();
-  __maps_lock();
-  __fds_lock();
-  while (atomic_exchange_explicit(&free_waiters_mu, 1, memory_order_acquire)) {
+  fork_prepare_stdio();
+  if (_weaken(__localtime_lock))
+    _weaken(__localtime_lock)();
+  if (_weaken(__dlopen_lock))
+    _weaken(__dlopen_lock)();
+  if (IsWindows())
+    __proc_lock();
+  if (_weaken(cosmo_stack_lock))
+    _weaken(cosmo_stack_lock)();
+  __cxa_lock();
+  if (_weaken(__gdtoa_lock)) {
+    _weaken(__gdtoa_lock1)();
+    _weaken(__gdtoa_lock)();
   }
+  _pthread_lock();
+  if (_weaken(dlmalloc_pre_fork))
+    _weaken(dlmalloc_pre_fork)();
+  __fds_lock();
+  if (_weaken(__rand64_lock))
+    _weaken(__rand64_lock)();
+  __maps_lock();
+  LOCKTRACE("READY TO LOCK AND ROLL");
 }
 
-static void _onfork_parent(void) {
-  atomic_store_explicit(&free_waiters_mu, 0, memory_order_release);
-  __fds_unlock();
+static void fork_parent(void) {
   __maps_unlock();
+  if (_weaken(__rand64_unlock))
+    _weaken(__rand64_unlock)();
+  __fds_unlock();
+  if (_weaken(dlmalloc_post_fork_parent))
+    _weaken(dlmalloc_post_fork_parent)();
   _pthread_unlock();
+  if (_weaken(__gdtoa_unlock)) {
+    _weaken(__gdtoa_unlock)();
+    _weaken(__gdtoa_unlock1)();
+  }
+  __cxa_unlock();
+  if (_weaken(cosmo_stack_unlock))
+    _weaken(cosmo_stack_unlock)();
+  if (IsWindows())
+    __proc_unlock();
+  if (_weaken(__dlopen_unlock))
+    _weaken(__dlopen_unlock)();
+  if (_weaken(__localtime_unlock))
+    _weaken(__localtime_unlock)();
+  fork_parent_stdio();
   if (_weaken(_pthread_onfork_parent))
     _weaken(_pthread_onfork_parent)();
+  _pthread_mutex_unlock(&supreme_lock);
 }
 
-static void _onfork_child(void) {
-  pthread_mutexattr_t attr;
-  pthread_mutexattr_init(&attr);
-  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-  pthread_mutex_init(&__fds_lock_obj, &attr);
-  atomic_store_explicit(&free_waiters_mu, 0, memory_order_relaxed);
-  pthread_mutexattr_destroy(&attr);
-  _pthread_init();
-  __maps_unlock();
-  if (_weaken(_pthread_onfork_child)) {
-    _weaken(_pthread_onfork_child)();
+static void fork_child(int ppid_win32, int ppid_cosmo) {
+  if (_weaken(__rand64_wipe))
+    _weaken(__rand64_wipe)();
+  _pthread_mutex_wipe_np(&__fds_lock_obj);
+  dlmalloc_post_fork_child();
+  if (_weaken(__gdtoa_wipe)) {
+    _weaken(__gdtoa_wipe)();
+    _weaken(__gdtoa_wipe1)();
   }
+  fork_child_stdio();
+  _pthread_mutex_wipe_np(&__pthread_lock_obj);
+  _pthread_mutex_wipe_np(&__cxa_lock_obj);
+  if (_weaken(cosmo_stack_wipe))
+    _weaken(cosmo_stack_wipe)();
+  if (_weaken(__dlopen_wipe))
+    _weaken(__dlopen_wipe)();
+  if (_weaken(__localtime_wipe))
+    _weaken(__localtime_wipe)();
+  if (IsWindows()) {
+    // we don't bother locking the proc/itimer/sig locks above since
+    // their state is reset in the forked child. nothing to protect.
+    sys_read_nt_wipe_keystrokes();
+    __proc_wipe_and_reset();
+    __itimer_wipe_and_reset();
+    atomic_init(&__sig_worker_state, 0);
+    if (_weaken(__sig_init))
+      _weaken(__sig_init)();
+    if (_weaken(sys_getppid_nt_wipe))
+      _weaken(sys_getppid_nt_wipe)(ppid_win32, ppid_cosmo);
+  }
+  if (_weaken(_pthread_onfork_child))
+    _weaken(_pthread_onfork_child)();
+  _pthread_mutex_wipe_np(&supreme_lock);
 }
 
 int _fork(uint32_t dwCreationFlags) {
   struct Dll *e;
-  int ax, dx, tid, parent;
-  parent = __pid;
+  int ax, dx, tid, ppid_win32, ppid_cosmo;
+  ppid_win32 = IsWindows() ? GetCurrentProcessId() : 0;
+  ppid_cosmo = __pid;
   BLOCK_SIGNALS;
-  if (IsWindows())
-    __proc_lock();
-  if (__threaded)
-    _onfork_prepare();
+  fork_prepare();
   if (!IsWindows()) {
     ax = sys_fork();
   } else {
@@ -100,28 +221,37 @@ int _fork(uint32_t dwCreationFlags) {
     if (!IsWindows()) {
       dx = sys_getpid().ax;
     } else {
-      dx = GetCurrentProcessId();
+      dx = __imp_GetCurrentProcessId();
     }
     __pid = dx;
 
+    // get new thread id
+    struct CosmoTib *tib = __get_tls();
+    struct PosixThread *me = (struct PosixThread *)tib->tib_pthread;
+    tid = IsLinux() || IsXnuSilicon() ? dx : sys_gettid();
+    atomic_init(&tib->tib_ctid, tid);
+    atomic_init(&tib->tib_ptid, tid);
+
+    // tracing and kisdangerous need this lock wiped a little earlier
+    atomic_init(&__maps.lock.word, 0);
+
+    /*
+     * it's now safe to call normal functions again
+     */
+
+    // this wipe must happen fast
+    void nsync_waiter_wipe_(void);
+    if (_weaken(nsync_waiter_wipe_))
+      _weaken(nsync_waiter_wipe_)();
+
     // turn other threads into zombies
     // we can't free() them since we're monopolizing all locks
     // we assume the operating system already reclaimed system handles
-    struct CosmoTib *tib = __get_tls();
-    struct PosixThread *pt = (struct PosixThread *)tib->tib_pthread;
-    dll_remove(&_pthread_list, &pt->list);
-    for (e = dll_first(_pthread_list); e; e = dll_next(_pthread_list, e)) {
-      atomic_store_explicit(&POSIXTHREAD_CONTAINER(e)->pt_status,
-                            kPosixThreadZombie, memory_order_relaxed);
-      atomic_store_explicit(&POSIXTHREAD_CONTAINER(e)->tib->tib_syshand, 0,
-                            memory_order_relaxed);
-    }
-    dll_make_first(&_pthread_list, &pt->list);
-
-    // get new main thread id
-    tid = IsLinux() || IsXnuSilicon() ? dx : sys_gettid();
-    atomic_store_explicit(&tib->tib_tid, tid, memory_order_relaxed);
-    atomic_store_explicit(&pt->ptid, tid, memory_order_relaxed);
+    dll_remove(&_pthread_list, &me->list);
+    struct Dll *old_threads = _pthread_list;
+    _pthread_list = 0;
+    dll_make_first(&_pthread_list, &me->list);
+    atomic_init(&_pthread_count, 1);
 
     // get new system thread handle
     intptr_t syshand = 0;
@@ -132,23 +262,52 @@ int _fork(uint32_t dwCreationFlags) {
                       GetCurrentProcess(), &syshand, 0, false,
                       kNtDuplicateSameAccess);
     }
-    atomic_store_explicit(&tib->tib_syshand, syshand, memory_order_relaxed);
+    atomic_init(&tib->tib_syshand, syshand);
+
+    // the child's pending signals is initially empty
+    atomic_init(&tib->tib_sigpending, 0);
 
     // we can't be canceled if the canceler no longer exists
-    atomic_store_explicit(&pt->pt_canceled, false, memory_order_relaxed);
+    atomic_init(&me->pt_canceled, false);
+
+    // forget locks
+    bzero(tib->tib_locks, sizeof(tib->tib_locks));
+
+    // xnu fork() doesn't preserve sigaltstack()
+    if (IsXnu() && me->tib->tib_sigstack_addr) {
+      struct sigaltstack_bsd ss;
+      ss.ss_sp = me->tib->tib_sigstack_addr;
+      ss.ss_size = me->tib->tib_sigstack_size;
+      ss.ss_flags = me->tib->tib_sigstack_flags;
+      if (IsXnuSilicon()) {
+        __syslib->__sigaltstack(&ss, 0);
+      } else {
+        sys_sigaltstack(&ss, 0);
+      }
+    }
 
     // run user fork callbacks
-    if (__threaded) {
-      _onfork_child();
+    fork_child(ppid_win32, ppid_cosmo);
+
+    // free threads
+    if (_weaken(_pthread_free)) {
+      while ((e = dll_first(old_threads))) {
+        struct PosixThread *pt = POSIXTHREAD_CONTAINER(e);
+        atomic_init(&pt->tib->tib_syshand, 0);
+        dll_remove(&old_threads, e);
+        _weaken(_pthread_free)(pt);
+      }
     }
-    STRACE("fork() → 0 (child of %d)", parent);
+
+    // reactivate ftrace
+    /* if (ftrace_stackdigs) */
+    /*   if (_weaken(ftrace_install)) */
+    /*     _weaken(ftrace_install)(); */
+
+    STRACE("fork() → 0 (child of %d)", ppid_cosmo);
   } else {
     // this is the parent process
-    if (__threaded) {
-      _onfork_parent();
-    }
-    if (IsWindows())
-      __proc_unlock();
+    fork_parent();
     STRACE("fork() → %d% m", ax);
   }
   ALLOW_SIGNALS;
diff --git a/libc/proc/getppid-nt.c b/libc/proc/getppid-nt.c
new file mode 100644
index 000000000..c602042e6
--- /dev/null
+++ b/libc/proc/getppid-nt.c
@@ -0,0 +1,93 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
+#include "libc/calls/syscall-nt.internal.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/fmt/itoa.h"
+#include "libc/nt/enum/status.h"
+#include "libc/nt/nt/process.h"
+#include "libc/nt/process.h"
+#include "libc/nt/runtime.h"
+#include "libc/nt/struct/processbasicinformation.h"
+#include "libc/runtime/internal.h"
+#include "libc/runtime/runtime.h"
+
+int sys_getppid_nt_win32;
+int sys_getppid_nt_cosmo;
+
+textwindows static int sys_getppid_nt_ntdll(void) {
+  struct NtProcessBasicInformation ProcessInformation;
+  uint32_t gotsize = 0;
+  if (!NtError(
+          NtQueryInformationProcess(GetCurrentProcess(), 0, &ProcessInformation,
+                                    sizeof(ProcessInformation), &gotsize)) &&
+      gotsize >= sizeof(ProcessInformation) &&
+      ProcessInformation.InheritedFromUniqueProcessId) {
+    return ProcessInformation.InheritedFromUniqueProcessId;
+  }
+  return 0;
+}
+
+static void sys_getppid_nt_extract(const char *str) {
+  int c;
+  int win32 = 0;
+  int cosmo = 0;
+  if (str) {
+    for (;;) {
+      c = *str;
+      if (!('0' <= c && c <= '9'))
+        break;
+      win32 *= 10;
+      win32 += c - '0';
+      ++str;
+    }
+    if (win32 && *str++ == ':') {
+      for (;;) {
+        c = *str;
+        if (!('0' <= c && c <= '9'))
+          break;
+        cosmo *= 10;
+        cosmo += c - '0';
+        ++str;
+      }
+      if (win32 == sys_getppid_nt_ntdll()) {
+        sys_getppid_nt_win32 = win32;
+        sys_getppid_nt_cosmo = cosmo;
+      }
+    }
+  }
+}
+
+__attribute__((__constructor__(90))) static void init(void) {
+  if (!IsWindows())
+    return;
+  sys_getppid_nt_extract(getenv("_COSMO_PPID"));
+}
+
+textwindows int sys_getppid_nt(void) {
+  if (sys_getppid_nt_cosmo)
+    return sys_getppid_nt_cosmo;
+  return sys_getppid_nt_ntdll();
+}
+
+textwindows void sys_getppid_nt_wipe(int win32, int cosmo) {
+  sys_getppid_nt_win32 = win32;
+  sys_getppid_nt_cosmo = cosmo;
+}
diff --git a/libc/calls/getppid.c b/libc/proc/getppid.c
similarity index 98%
rename from libc/calls/getppid.c
rename to libc/proc/getppid.c
index 075d610a7..e1f80863a 100644
--- a/libc/calls/getppid.c
+++ b/libc/proc/getppid.c
@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Returns parent process id.
diff --git a/libc/proc/getpriority-nt.c b/libc/proc/getpriority-nt.c
index 8cfbcc1fe..ff4fca305 100644
--- a/libc/proc/getpriority-nt.c
+++ b/libc/proc/getpriority-nt.c
@@ -17,12 +17,12 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/processcreationflags.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
 #include "libc/sysv/consts/prio.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/proc/getpriority.c b/libc/proc/getpriority.c
index b66cbc26a..fcaa7b756 100644
--- a/libc/proc/getpriority.c
+++ b/libc/proc/getpriority.c
@@ -22,8 +22,8 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/asmflag.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/proc/getrusage-nt.c b/libc/proc/getrusage-nt.c
index 2b0917843..07bde103a 100644
--- a/libc/proc/getrusage-nt.c
+++ b/libc/proc/getrusage-nt.c
@@ -29,7 +29,7 @@
 #include "libc/nt/struct/iocounters.h"
 #include "libc/nt/struct/processmemorycounters.h"
 #include "libc/nt/thread.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/rusage.h"
 #include "libc/sysv/errfuns.h"
@@ -58,9 +58,8 @@ textwindows int sys_getrusage_nt(int who, struct rusage *usage) {
     return einval();
   }
 
-  if (!usage) {
+  if (!usage)
     return 0;
-  }
 
   if (!(who == RUSAGE_THREAD ? GetThreadTimes : GetProcessTimes)(
           me, &ftCreation, &ftExit, &ftKernel, &ftUser) ||
diff --git a/libc/proc/getrusage.c b/libc/proc/getrusage.c
index 95d385a50..be0cec92d 100644
--- a/libc/proc/getrusage.c
+++ b/libc/proc/getrusage.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/rusage.h"
 #include "libc/calls/struct/rusage.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/proc/handle.c b/libc/proc/handle.c
index 10c220328..83c134e4a 100644
--- a/libc/proc/handle.c
+++ b/libc/proc/handle.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/runtime.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
 
 // retrieves handle of process
 // supports only current process and processes we created
diff --git a/libc/proc/kill-nt.c b/libc/proc/kill-nt.c
index 0a60bf350..a820bf932 100644
--- a/libc/proc/kill-nt.c
+++ b/libc/proc/kill-nt.c
@@ -16,19 +16,24 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/errno.h"
+#include "libc/intrin/atomic.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/console.h"
+#include "libc/nt/enum/creationdisposition.h"
 #include "libc/nt/enum/ctrlevent.h"
 #include "libc/nt/enum/processaccess.h"
 #include "libc/nt/errors.h"
+#include "libc/nt/memory.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
 #ifdef __x86_64__
@@ -36,31 +41,38 @@
 textwindows int sys_kill_nt(int pid, int sig) {
 
   // validate api usage
-  if (!(0 <= sig && sig <= 64)) {
+  if (!(0 <= sig && sig <= 64))
     return einval();
-  }
 
   // XXX: NT doesn't really have process groups. For instance the
   //      CreateProcess() flag for starting a process group actually
   //      just does an "ignore ctrl-c" internally.
-  if (pid < -1) {
+  if (pid < -1)
     pid = -pid;
-  }
 
   // no support for kill all yet
-  if (pid == -1) {
+  if (pid == -1)
     return einval();
-  }
 
   // just call raise() if we're targeting self
   if (pid <= 0 || pid == getpid()) {
     if (sig) {
       if (pid <= 0) {
+        // if pid is 0 or -1 then kill the processes beneath us too.
+        // this isn't entirely right but it's closer to being right.
+        // having this behavior is helpful for servers like redbean.
         struct Dll *e;
         BLOCK_SIGNALS;
         __proc_lock();
         for (e = dll_first(__proc.list); e; e = dll_next(__proc.list, e)) {
-          TerminateProcess(PROC_CONTAINER(e)->handle, sig);
+          atomic_ulong *sigproc;
+          struct Proc *pr = PROC_CONTAINER(e);
+          if (sig != 9 && (sigproc = __sig_map_process(pid, kNtOpenExisting))) {
+            atomic_fetch_or_explicit(sigproc, 1ull << (sig - 1),
+                                     memory_order_release);
+          } else {
+            TerminateProcess(pr->handle, sig);
+          }
         }
         __proc_unlock();
         ALLOW_SIGNALS;
@@ -71,33 +83,45 @@ textwindows int sys_kill_nt(int pid, int sig) {
     }
   }
 
+  // attempt to signal via shared memory file
+  //
+  // now that we know the process exists, if it has a shared memory file
+  // then we can be reasonably certain it's a cosmo process which should
+  // be trusted to deliver its signal, unless it's a nine exterminations
+  if (pid > 0 && sig != 9) {
+    atomic_ulong *sigproc;
+    if ((sigproc = __sig_map_process(pid, kNtOpenExisting))) {
+      if (sig > 0)
+        atomic_fetch_or_explicit(sigproc, 1ull << (sig - 1),
+                                 memory_order_release);
+      UnmapViewOfFile(sigproc);
+      if (sig != 9)
+        return 0;
+    }
+  }
+
   // find existing handle we own for process
+  //
+  // this step should come first to verify process existence. this is
+  // because there's no guarantee that just because the shared memory
+  // file exists, the process actually exists.
   int64_t handle, closeme = 0;
   if (!(handle = __proc_handle(pid))) {
-    if ((handle = OpenProcess(kNtProcessTerminate, false, pid))) {
-      closeme = handle;
-    } else {
-      goto OnError;
-    }
+    if (!(handle = OpenProcess(kNtProcessTerminate, false, pid)))
+      return eperm();
+    closeme = handle;
   }
 
   // perform actual kill
   // process will report WIFSIGNALED with WTERMSIG(sig)
+  if (sig != 9)
+    STRACE("warning: kill() sending %G via terminate", sig);
   bool32 ok = TerminateProcess(handle, sig);
   if (closeme)
     CloseHandle(closeme);
   if (ok)
     return 0;
-
-  // handle error
-OnError:
-  switch (GetLastError()) {
-    case kNtErrorInvalidHandle:
-    case kNtErrorInvalidParameter:
-      return esrch();
-    default:
-      return eperm();
-  }
+  return esrch();
 }
 
 #endif /* __x86_64__ */
diff --git a/libc/proc/kill.c b/libc/proc/kill.c
index 34342add9..5de445fd3 100644
--- a/libc/proc/kill.c
+++ b/libc/proc/kill.c
@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 
 /**
@@ -29,6 +29,20 @@
  * The impact of this action can be terminating the process, or
  * interrupting it to request something happen.
  *
+ * On Windows, signals are delivered between processes using shared
+ * memory files stored in C:\ProgramData\cosmo\sig\x\y.pid which hold
+ * the process signal mask. Any process that can access these files can
+ * signal a cosmo process. The targeting process will then notice that a
+ * signal has been added and delivers to any thread as soon as possible.
+ *
+ * On Windows, the only signal that's guaranteed to work on non-cosmocc
+ * processes is SIGKILL.
+ *
+ * On Windows, the concept of a process group isn't fully implemented.
+ * Saying `kill(0, sig)` will deliver `sig` to all direct descendent
+ * processes. Saying `kill(-pid, sig)` will be the same as saying
+ * `kill(pid, sig)`.
+ *
  * @param pid can be:
  *      >0 signals one process by id
  *      =0 signals all processes in current process group
diff --git a/libc/proc/nice.c b/libc/proc/nice.c
index 783ed4936..de243b93c 100644
--- a/libc/proc/nice.c
+++ b/libc/proc/nice.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/fmt/conv.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sysv/consts/prio.h"
 
 static int clamp(int p) {
diff --git a/libc/proc/posix_spawn.c b/libc/proc/posix_spawn.c
index 4e85e49b4..4dbbdcea9 100644
--- a/libc/proc/posix_spawn.c
+++ b/libc/proc/posix_spawn.c
@@ -22,7 +22,6 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/rlimit.h"
 #include "libc/calls/struct/rlimit.internal.h"
 #include "libc/calls/struct/rusage.internal.h"
@@ -37,9 +36,10 @@
 #include "libc/fmt/magnumstrs.internal.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/bsf.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/mem/alloca.h"
 #include "libc/mem/mem.h"
@@ -51,6 +51,7 @@
 #include "libc/nt/enum/processcreationflags.h"
 #include "libc/nt/enum/startf.h"
 #include "libc/nt/files.h"
+#include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/processinformation.h"
 #include "libc/nt/struct/startupinfo.h"
@@ -58,7 +59,8 @@
 #include "libc/proc/ntspawn.h"
 #include "libc/proc/posix_spawn.h"
 #include "libc/proc/posix_spawn.internal.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
+#include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sock/sock.h"
 #include "libc/stdio/stdio.h"
@@ -95,6 +97,10 @@
 
 #define CLOSER_CONTAINER(e) DLL_CONTAINER(struct Closer, elem, e)
 
+static atomic_bool has_vfork;  // i.e. not qemu/wsl/xnu/openbsd
+
+#ifdef __x86_64__
+
 struct Closer {
   int64_t handle;
   struct Dll elem;
@@ -106,8 +112,6 @@ struct SpawnFds {
   struct Dll *closers;
 };
 
-static atomic_bool has_vfork;  // i.e. not qemu/wsl/xnu/openbsd
-
 static textwindows int64_t spawnfds_handle(struct SpawnFds *fds, int fd) {
   if (__is_cloexec(fds->p + fd))
     return -1;
@@ -194,10 +198,21 @@ static textwindows errno_t spawnfds_open(struct SpawnFds *fds, int64_t dirhand,
   errno_t err;
   char16_t path16[PATH_MAX];
   uint32_t perm, share, disp, attr;
+  if (!strcmp(path, "/dev/null")) {
+    strcpy16(path16, u"NUL");
+  } else if (!strcmp(path, "/dev/stdin")) {
+    return spawnfds_dup2(fds, 0, fildes);
+  } else if (!strcmp(path, "/dev/stdout")) {
+    return spawnfds_dup2(fds, 1, fildes);
+  } else if (!strcmp(path, "/dev/stderr")) {
+    return spawnfds_dup2(fds, 2, fildes);
+  } else {
+    if (__mkntpathath(dirhand, path, 0, path16) == -1)
+      return errno;
+  }
   if ((err = spawnfds_ensure(fds, fildes)))
     return err;
-  if (__mkntpathath(dirhand, path, 0, path16) != -1 &&
-      GetNtOpenFlags(oflag, mode, &perm, &share, &disp, &attr) != -1 &&
+  if (GetNtOpenFlags(oflag, mode, &perm, &share, &disp, &attr) != -1 &&
       (h = CreateFile(path16, perm, share, &kNtIsInheritable, disp, attr, 0))) {
     spawnfds_closelater(fds, h);
     fds->p[fildes].kind = kFdFile;
@@ -300,30 +315,30 @@ static textwindows errno_t posix_spawn_nt_impl(
         case _POSIX_SPAWN_CLOSE:
           err = spawnfds_close(&fds, a->fildes);
           STRACE("spawnfds_close(%d) → %s", a->fildes,
-                 (DescribeErrno)(errno_buf, err));
+                 _DescribeErrno(errno_buf, err));
           break;
         case _POSIX_SPAWN_DUP2:
           err = spawnfds_dup2(&fds, a->fildes, a->newfildes);
           STRACE("spawnfds_dup2(%d, %d) → %s", a->fildes, a->newfildes,
-                 (DescribeErrno)(errno_buf, err));
+                 _DescribeErrno(errno_buf, err));
           break;
         case _POSIX_SPAWN_OPEN:
           err = spawnfds_open(&fds, dirhand, a->path, a->oflag, a->mode,
                               a->fildes);
           STRACE("spawnfds_open(%#s, %s, %s, %d) → %s", a->path,
-                 (DescribeOpenFlags)(oflags_buf, a->oflag),
-                 (DescribeOpenMode)(openmode_buf, a->oflag, a->mode), a->fildes,
-                 (DescribeErrno)(errno_buf, err));
+                 _DescribeOpenFlags(oflags_buf, a->oflag),
+                 _DescribeOpenMode(openmode_buf, a->oflag, a->mode), a->fildes,
+                 _DescribeErrno(errno_buf, err));
           break;
         case _POSIX_SPAWN_CHDIR:
           err = spawnfds_chdir(&fds, dirhand, a->path, &dirhand);
           STRACE("spawnfds_chdir(%#s) → %s", a->path,
-                 (DescribeErrno)(errno_buf, err));
+                 _DescribeErrno(errno_buf, err));
           break;
         case _POSIX_SPAWN_FCHDIR:
           err = spawnfds_fchdir(&fds, a->fildes, &dirhand);
           STRACE("spawnfds_fchdir(%d) → %s", a->fildes,
-                 (DescribeErrno)(errno_buf, err));
+                 _DescribeErrno(errno_buf, err));
           break;
         default:
           __builtin_unreachable();
@@ -337,12 +352,8 @@ static textwindows errno_t posix_spawn_nt_impl(
   // figure out flags
   uint32_t dwCreationFlags = 0;
   short flags = attrp && *attrp ? (*attrp)->flags : 0;
-  if (flags & POSIX_SPAWN_SETSID) {
-    dwCreationFlags |= kNtDetachedProcess;
-  }
-  if (flags & POSIX_SPAWN_SETPGROUP) {
+  if (flags & (POSIX_SPAWN_SETPGROUP | POSIX_SPAWN_SETSID))
     dwCreationFlags |= kNtCreateNewProcessGroup;
-  }
 
   // create process startinfo
   struct NtStartupInfo startinfo = {
@@ -364,6 +375,19 @@ static textwindows errno_t posix_spawn_nt_impl(
     }
   }
 
+  // UNC paths break some things when they are not needed.
+  if (lpCurrentDirectory) {
+    size_t n = strlen16(lpCurrentDirectory);
+    if (n > 4 && n < 260 &&               //
+        lpCurrentDirectory[0] == '\\' &&  //
+        lpCurrentDirectory[1] == '\\' &&  //
+        lpCurrentDirectory[2] == '?' &&   //
+        lpCurrentDirectory[3] == '\\') {
+      memmove(lpCurrentDirectory, lpCurrentDirectory + 4,
+              (n - 4 + 1) * sizeof(char16_t));
+    }
+  }
+
   // inherit signal mask
   sigset_t childmask;
   char maskvar[6 + 21];
@@ -374,6 +398,14 @@ static textwindows errno_t posix_spawn_nt_impl(
   }
   FormatUint64(stpcpy(maskvar, "_MASK="), childmask);
 
+  // inherit parent process id
+  char ppidvar[12 + 21 + 1 + 21 + 1], *p = ppidvar;
+  p = stpcpy(p, "_COSMO_PPID=");
+  p = FormatUint64(p, GetCurrentProcessId());
+  *p++ = ':';
+  p = FormatUint64(p, __pid);
+  setenv("_COSMO_PPID", ppidvar, true);
+
   // launch process
   int rc = -1;
   struct NtProcessInformation procinfo;
@@ -429,6 +461,8 @@ static textwindows dontinline errno_t posix_spawn_nt(
   return err;
 }
 
+#endif  // __x86_64__
+
 /**
  * Spawns process, the POSIX way, e.g.
  *
@@ -446,23 +480,101 @@ static textwindows dontinline errno_t posix_spawn_nt(
  *     posix_spawnattr_destroy(&sa);
  *     while (wait(&status) != -1);
  *
- * This provides superior process creation performance across systems
+ * The posix_spawn() function may be used to launch subprocesses. The
+ * primary advantage of using posix_spawn() instead of the traditional
+ * fork() / execve() combination for launching processes is efficiency
+ * and cross-platform compatibility.
  *
- * Processes are normally spawned by calling fork() and execve(), but
- * that goes slow on Windows if the caller has allocated a nontrivial
- * number of memory mappings, all of which need to be copied into the
- * forked child, only to be destroyed a moment later. On UNIX systems
- * fork() bears a similar cost that's 100x less bad, which is copying
- * the page tables. So what this implementation does is on Windows it
- * calls CreateProcess() directly and on UNIX it uses vfork() if it's
- * possible (XNU and OpenBSD don't have it). On UNIX this API has the
- * benefit of avoiding the footguns of using vfork() directly because
- * this implementation will ensure signal handlers can't be called in
- * the child process since that'd likely corrupt the parent's memory.
- * On systems with a real vfork() implementation, the execve() status
- * code is returned by this function via shared memory; otherwise, it
- * gets passed via a temporary pipe (on systems like QEmu, Blink, and
- * XNU/OpenBSD) whose support is auto-detected at runtime.
+ * 1. On Linux, FreeBSD, and NetBSD:
+ *
+ *    Cosmopolitan Libc's posix_spawn() uses vfork() under the hood on
+ *    these platforms automatically, since it's faster than fork(). It's
+ *    because vfork() creates a child process without needing to copy
+ *    the parent's page tables, making it more efficient, especially for
+ *    large processes. Furthermore, vfork() avoids the need to acquire
+ *    every single mutex (see pthread_atfork() for more details) which
+ *    makes it scalable in multi-threaded apps, since the other threads
+ *    in your app can keep going while the spawning thread waits for the
+ *    subprocess to call execve(). Normally vfork() is error-prone since
+ *    there exists few functions that are @vforksafe. the posix_spawn()
+ *    API is designed to offer maximum assurance that you can't shoot
+ *    yourself in the foot. If you do, then file a bug with Cosmo.
+ *
+ * 2. On Windows:
+ *
+ *    posix_spawn() avoids fork() entirely. Windows doesn't natively
+ *    support fork(), and emulating it can be slow and memory-intensive.
+ *    By using posix_spawn(), we get a much faster process creation on
+ *    Windows systems, because it only needs to call CreateProcess().
+ *    Your file actions are replayed beforehand in a simulated way. Only
+ *    Cosmopolitan Libc offers this level of quality. With Cygwin you'd
+ *    have to use its proprietary APIs to achieve the same performance.
+ *
+ * 3. Simplified error handling:
+ *
+ *    posix_spawn() combines process creation and program execution in a
+ *    single call, reducing the points of failure and simplifying error
+ *    handling. One important thing that happens with Cosmopolitan's
+ *    posix_spawn() implementation is that the error code of execve()
+ *    inside your subprocess, should it fail, will be propagated to your
+ *    parent process. This will happen efficiently via vfork() shared
+ *    memory in the event your Linux environment supports this. If it
+ *    doesn't, then Cosmopolitan will fall back to a throwaway pipe().
+ *    The pipe is needed on platforms like XNU and OpenBSD which do not
+ *    support vfork(). It's also needed under QEMU User.
+ *
+ * 4. Signal safety:
+ *
+ *    posix_spawn() guarantees your signal handler callback functions
+ *    won't be executed in the child process. By default, it'll remove
+ *    sigaction() callbacks atomically. This ensures that if something
+ *    like a SIGTERM or SIGHUP is sent to the child process before it's
+ *    had a chance to call execve(), then the child process will simply
+ *    be terminated (like the spawned process would) instead of running
+ *    whatever signal handlers the spawning process has installed. If
+ *    you've set some signals to SIG_IGN, then that'll be preserved for
+ *    the child process by posix_spawn(), unless you explicitly call
+ *    posix_spawnattr_setsigdefault() to reset them.
+ *
+ * 5. Portability:
+ *
+ *    posix_spawn() is part of the POSIX standard, making it more
+ *    portable across different UNIX-like systems and Windows (with
+ *    appropriate libraries). Even the non-POSIX APIs we use here are
+ *    portable; e.g. posix_spawn_file_actions_addchdir_np() is supported
+ *    by glibc, musl libc, and apple libc too.
+ *
+ * When using posix_spawn() you have the option of passing an attributes
+ * object that specifies how the child process should be created. These
+ * functions are provided by Cosmopolitan Libc for setting attributes:
+ *
+ * - posix_spawnattr_init()
+ * - posix_spawnattr_destroy()
+ * - posix_spawnattr_setflags()
+ * - posix_spawnattr_getflags()
+ * - posix_spawnattr_setsigmask()
+ * - posix_spawnattr_getsigmask()
+ * - posix_spawnattr_setpgroup()
+ * - posix_spawnattr_getpgroup()
+ * - posix_spawnattr_setrlimit_np()
+ * - posix_spawnattr_getrlimit_np()
+ * - posix_spawnattr_setschedparam()
+ * - posix_spawnattr_getschedparam()
+ * - posix_spawnattr_setschedpolicy()
+ * - posix_spawnattr_getschedpolicy()
+ * - posix_spawnattr_setsigdefault()
+ * - posix_spawnattr_getsigdefault()
+ *
+ * You can also pass an ordered list of file actions to perform. The
+ * following APIs are provided by Cosmopolitan Libc for doing that:
+ *
+ * - posix_spawn_file_actions_init()
+ * - posix_spawn_file_actions_destroy()
+ * - posix_spawn_file_actions_adddup2()
+ * - posix_spawn_file_actions_addopen()
+ * - posix_spawn_file_actions_addclose()
+ * - posix_spawn_file_actions_addchdir_np()
+ * - posix_spawn_file_actions_addfchdir_np()
  *
  * @param pid if non-null shall be set to child pid on success
  * @param path is resolved path of program which is not `$PATH` searched
@@ -482,100 +594,89 @@ errno_t posix_spawn(int *pid, const char *path,
                     const posix_spawn_file_actions_t *file_actions,
                     const posix_spawnattr_t *attrp, char *const argv[],
                     char *const envp[]) {
-  if (IsWindows()) {
+#ifdef __x86_64__
+  if (IsWindows())
     return posix_spawn_nt(pid, path, file_actions, attrp, argv, envp);
-  }
+#endif
   int pfds[2];
   bool use_pipe;
   volatile int status = 0;
   sigset_t blockall, oldmask;
   int child, res, cs, e = errno;
   volatile bool can_clobber = false;
+  short flags = attrp && *attrp ? (*attrp)->flags : 0;
   sigfillset(&blockall);
   sigprocmask(SIG_SETMASK, &blockall, &oldmask);
   pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
-  if ((use_pipe = !atomic_load_explicit(&has_vfork, memory_order_acquire))) {
+  if ((use_pipe = (flags & POSIX_SPAWN_USEFORK) ||
+                  !atomic_load_explicit(&has_vfork, memory_order_acquire))) {
     if (pipe2(pfds, O_CLOEXEC)) {
       res = errno;
       goto ParentFailed;
     }
   }
-  if (!(child = vfork())) {
+  if (!(child = (flags & POSIX_SPAWN_USEFORK) ? fork() : vfork())) {
     can_clobber = true;
     sigset_t childmask;
     bool lost_cloexec = 0;
     struct sigaction dfl = {0};
-    short flags = attrp && *attrp ? (*attrp)->flags : 0;
     if (use_pipe)
       close(pfds[0]);
-    for (int sig = 1; sig < _NSIG; sig++) {
+    for (int sig = 1; sig <= NSIG; sig++)
       if (__sighandrvas[sig] != (long)SIG_DFL &&
           (__sighandrvas[sig] != (long)SIG_IGN ||
            ((flags & POSIX_SPAWN_SETSIGDEF) &&
-            sigismember(&(*attrp)->sigdefault, sig) == 1))) {
+            sigismember(&(*attrp)->sigdefault, sig) == 1)))
         sigaction(sig, &dfl, 0);
-      }
-    }
-    if (flags & POSIX_SPAWN_SETSID) {
+    if (flags & POSIX_SPAWN_SETSID)
       setsid();
-    }
-    if ((flags & POSIX_SPAWN_SETPGROUP) && setpgid(0, (*attrp)->pgroup)) {
+    if ((flags & POSIX_SPAWN_SETPGROUP) && setpgid(0, (*attrp)->pgroup))
       goto ChildFailed;
-    }
-    if ((flags & POSIX_SPAWN_RESETIDS) && setgid(getgid())) {
+    if ((flags & POSIX_SPAWN_RESETIDS) && setgid(getgid()))
       goto ChildFailed;
-    }
-    if ((flags & POSIX_SPAWN_RESETIDS) && setuid(getuid())) {
+    if ((flags & POSIX_SPAWN_RESETIDS) && setuid(getuid()))
       goto ChildFailed;
-    }
     if (file_actions) {
       struct _posix_faction *a;
       for (a = *file_actions; a; a = a->next) {
         if (use_pipe && pfds[1] == a->fildes) {
           int p2;
-          if ((p2 = dup(pfds[1])) == -1) {
+          if ((p2 = dup(pfds[1])) == -1)
             goto ChildFailed;
-          }
           lost_cloexec = true;
           close(pfds[1]);
           pfds[1] = p2;
         }
         switch (a->action) {
           case _POSIX_SPAWN_CLOSE:
-            if (close(a->fildes)) {
+            if (close(a->fildes))
               goto ChildFailed;
-            }
             break;
           case _POSIX_SPAWN_DUP2:
-            if (dup2(a->fildes, a->newfildes) == -1) {
+            if (dup2(a->fildes, a->newfildes) == -1)
               goto ChildFailed;
-            }
             break;
           case _POSIX_SPAWN_OPEN: {
             int t;
-            if ((t = openat(AT_FDCWD, a->path, a->oflag, a->mode)) == -1) {
+            if ((t = openat(AT_FDCWD, a->path, a->oflag, a->mode)) == -1)
               goto ChildFailed;
-            }
             if (t != a->fildes) {
               if (dup2(t, a->fildes) == -1) {
                 close(t);
                 goto ChildFailed;
               }
-              if (close(t)) {
+              if (close(t))
                 goto ChildFailed;
-              }
             }
             break;
           }
           case _POSIX_SPAWN_CHDIR:
-            if (chdir(a->path) == -1) {
+            if (chdir(a->path) == -1)
               goto ChildFailed;
-            }
             break;
           case _POSIX_SPAWN_FCHDIR:
-            if (fchdir(a->fildes) == -1) {
+            if (fchdir(a->fildes) == -1)
               goto ChildFailed;
-            }
             break;
           default:
             __builtin_unreachable();
@@ -583,19 +684,15 @@ errno_t posix_spawn(int *pid, const char *path,
       }
     }
     if (IsLinux() || IsFreebsd() || IsNetbsd()) {
-      if (flags & POSIX_SPAWN_SETSCHEDULER) {
+      if (flags & POSIX_SPAWN_SETSCHEDULER)
         if (sched_setscheduler(0, (*attrp)->schedpolicy,
-                               &(*attrp)->schedparam) == -1) {
+                               &(*attrp)->schedparam) == -1)
           goto ChildFailed;
-        }
-      }
-      if (flags & POSIX_SPAWN_SETSCHEDPARAM) {
-        if (sched_setparam(0, &(*attrp)->schedparam)) {
+      if (flags & POSIX_SPAWN_SETSCHEDPARAM)
+        if (sched_setparam(0, &(*attrp)->schedparam))
           goto ChildFailed;
-        }
-      }
     }
-    if (flags & POSIX_SPAWN_SETRLIMIT) {
+    if (flags & POSIX_SPAWN_SETRLIMIT_NP) {
       int rlimset = (*attrp)->rlimset;
       while (rlimset) {
         int resource = bsf(rlimset);
@@ -608,9 +705,8 @@ errno_t posix_spawn(int *pid, const char *path,
         }
       }
     }
-    if (lost_cloexec) {
+    if (lost_cloexec)
       fcntl(pfds[1], F_SETFD, FD_CLOEXEC);
-    }
     if (flags & POSIX_SPAWN_SETSIGMASK) {
       childmask = (*attrp)->sigmask;
     } else {
@@ -629,16 +725,14 @@ errno_t posix_spawn(int *pid, const char *path,
     }
     _Exit(127);
   }
-  if (use_pipe) {
+  if (use_pipe)
     close(pfds[1]);
-  }
   if (child != -1) {
     if (!use_pipe) {
       res = status;
     } else {
-      if (can_clobber) {
+      if (can_clobber)
         atomic_store_explicit(&has_vfork, true, memory_order_release);
-      }
       res = 0;
       read(pfds[0], &res, sizeof(res));
     }
@@ -651,9 +745,8 @@ errno_t posix_spawn(int *pid, const char *path,
   } else {
     res = errno;
   }
-  if (use_pipe) {
+  if (use_pipe)
     close(pfds[0]);
-  }
 ParentFailed:
   sigprocmask(SIG_SETMASK, &oldmask, 0);
   pthread_setcancelstate(cs, 0);
diff --git a/libc/proc/posix_spawn.h b/libc/proc/posix_spawn.h
index 9da96f721..2efa2258a 100644
--- a/libc/proc/posix_spawn.h
+++ b/libc/proc/posix_spawn.h
@@ -12,7 +12,8 @@
 #define POSIX_SPAWN_SETSCHEDPARAM 16
 #define POSIX_SPAWN_SETSCHEDULER  32
 #define POSIX_SPAWN_SETSID        128
-#define POSIX_SPAWN_SETRLIMIT     256
+#define POSIX_SPAWN_SETRLIMIT_NP  256
+#define POSIX_SPAWN_USEFORK       512
 
 COSMOPOLITAN_C_START_
 
@@ -55,10 +56,10 @@ int posix_spawnattr_getsigdefault(const posix_spawnattr_t *,
                                   sigset_t *) libcesque;
 int posix_spawnattr_setsigdefault(posix_spawnattr_t *,
                                   const sigset_t *) libcesque;
-int posix_spawnattr_getrlimit(const posix_spawnattr_t *, int,
-                              struct rlimit *) libcesque;
-int posix_spawnattr_setrlimit(posix_spawnattr_t *, int,
-                              const struct rlimit *) libcesque;
+int posix_spawnattr_getrlimit_np(const posix_spawnattr_t *, int,
+                                 struct rlimit *) libcesque;
+int posix_spawnattr_setrlimit_np(posix_spawnattr_t *, int,
+                                 const struct rlimit *) libcesque;
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_STDIO_SPAWN_H_ */
diff --git a/libc/proc/posix_spawnattr_getrlimit.c b/libc/proc/posix_spawnattr_getrlimit.c
index 941e40889..c45a3387c 100644
--- a/libc/proc/posix_spawnattr_getrlimit.c
+++ b/libc/proc/posix_spawnattr_getrlimit.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/rlimit.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/proc/posix_spawn.h"
 #include "libc/proc/posix_spawn.internal.h"
 #include "libc/stdio/sysparam.h"
@@ -31,8 +31,8 @@
  * @raise EINVAL if `resource` is invalid or unsupported by host
  * @raise ENOENT if `resource` is absent
  */
-int posix_spawnattr_getrlimit(const posix_spawnattr_t *attr, int resource,
-                              struct rlimit *rlim) {
+int posix_spawnattr_getrlimit_np(const posix_spawnattr_t *attr, int resource,
+                                 struct rlimit *rlim) {
   if (0 <= resource && resource < MIN(RLIM_NLIMITS, ARRAYLEN((*attr)->rlim))) {
     if (((*attr)->rlimset & (1u << resource))) {
       *rlim = (*attr)->rlim[resource];
diff --git a/libc/proc/posix_spawnattr_setflags.c b/libc/proc/posix_spawnattr_setflags.c
index 13cb82f28..057306dec 100644
--- a/libc/proc/posix_spawnattr_setflags.c
+++ b/libc/proc/posix_spawnattr_setflags.c
@@ -25,6 +25,8 @@
  *
  * @param attr was initialized by posix_spawnattr_init()
  * @param flags may have any of the following
+ *     - `POSIX_SPAWN_USEFORK`
+ *     - `POSIX_SPAWN_USEVFORK`
  *     - `POSIX_SPAWN_RESETIDS`
  *     - `POSIX_SPAWN_SETPGROUP`
  *     - `POSIX_SPAWN_SETSIGDEF`
@@ -32,12 +34,13 @@
  *     - `POSIX_SPAWN_SETSCHEDPARAM`
  *     - `POSIX_SPAWN_SETSCHEDULER`
  *     - `POSIX_SPAWN_SETSID`
- *     - `POSIX_SPAWN_SETRLIMIT`
+ *     - `POSIX_SPAWN_SETRLIMIT_NP`
  * @return 0 on success, or errno on error
  * @raise EINVAL if `flags` has invalid bits
  */
 int posix_spawnattr_setflags(posix_spawnattr_t *attr, short flags) {
-  if (flags & ~(POSIX_SPAWN_USEVFORK |       //
+  if (flags & ~(POSIX_SPAWN_USEFORK |        //
+                POSIX_SPAWN_USEVFORK |       //
                 POSIX_SPAWN_RESETIDS |       //
                 POSIX_SPAWN_SETPGROUP |      //
                 POSIX_SPAWN_SETSIGDEF |      //
@@ -45,7 +48,7 @@ int posix_spawnattr_setflags(posix_spawnattr_t *attr, short flags) {
                 POSIX_SPAWN_SETSCHEDPARAM |  //
                 POSIX_SPAWN_SETSCHEDULER |   //
                 POSIX_SPAWN_SETSID |         //
-                POSIX_SPAWN_SETRLIMIT)) {
+                POSIX_SPAWN_SETRLIMIT_NP)) {
     return EINVAL;
   }
   (*attr)->flags = flags;
diff --git a/libc/proc/posix_spawnattr_setrlimit.c b/libc/proc/posix_spawnattr_setrlimit.c
index 0d0a7970b..60c68cdf2 100644
--- a/libc/proc/posix_spawnattr_setrlimit.c
+++ b/libc/proc/posix_spawnattr_setrlimit.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/rlimit.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/proc/posix_spawn.h"
 #include "libc/proc/posix_spawn.internal.h"
 #include "libc/sysv/consts/rlim.h"
@@ -26,14 +26,14 @@
 /**
  * Sets resource limit on spawned process.
  *
- * You also need to pass `POSIX_SPAWN_SETRLIMIT` to
+ * You also need to pass `POSIX_SPAWN_SETRLIMIT_NP` to
  * posix_spawnattr_setflags() for it to take effect.
  *
  * @return 0 on success, or errno on error
  * @raise EINVAL if resource is invalid
  */
-int posix_spawnattr_setrlimit(posix_spawnattr_t *attr, int resource,
-                              const struct rlimit *rlim) {
+int posix_spawnattr_setrlimit_np(posix_spawnattr_t *attr, int resource,
+                                 const struct rlimit *rlim) {
   if (0 <= resource && resource < MIN(RLIM_NLIMITS, ARRAYLEN((*attr)->rlim))) {
     (*attr)->rlimset |= 1u << resource;
     (*attr)->rlim[resource] = *rlim;
diff --git a/libc/proc/proc.c b/libc/proc/proc.c
index e43262ce8..0288075d1 100644
--- a/libc/proc/proc.c
+++ b/libc/proc/proc.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/proc/proc.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
@@ -23,20 +24,23 @@
 #include "libc/calls/struct/rusage.h"
 #include "libc/calls/struct/siginfo.h"
 #include "libc/calls/struct/sigset.internal.h"
+#include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/cosmo.h"
 #include "libc/errno.h"
 #include "libc/fmt/wintime.internal.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/maps.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/mem/leaks.h"
-#include "libc/mem/mem.h"
 #include "libc/nt/accounting.h"
+#include "libc/nt/enum/heap.h"
 #include "libc/nt/enum/processaccess.h"
 #include "libc/nt/enum/processcreationflags.h"
 #include "libc/nt/enum/status.h"
 #include "libc/nt/enum/wait.h"
 #include "libc/nt/events.h"
+#include "libc/nt/memory.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/struct/filetime.h"
@@ -44,22 +48,29 @@
 #include "libc/nt/struct/processmemorycounters.h"
 #include "libc/nt/synchronization.h"
 #include "libc/nt/thread.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
+#include "third_party/nsync/mu.h"
 #ifdef __x86_64__
 
 /**
  * @fileoverview Windows Subprocess Management.
  */
 
-struct Procs __proc;
+#define STACK_SIZE 65536
 
-static textwindows void __proc_stats(int64_t h, struct rusage *ru) {
+struct Procs __proc;
+static pthread_mutex_t __proc_lock_obj = PTHREAD_MUTEX_INITIALIZER;
+
+textwindows static void __proc_stats(int64_t h, struct rusage *ru) {
   bzero(ru, sizeof(*ru));
   struct NtProcessMemoryCountersEx memcount = {sizeof(memcount)};
   GetProcessMemoryInfo(h, &memcount, sizeof(memcount));
@@ -95,14 +106,14 @@ textwindows int __proc_harvest(struct Proc *pr, bool iswait4) {
     pr->handle = status & 0x00FFFFFF;
   } else {
     // handle child _Exit()
-    if (status == 0xc9af3d51u) {
+    if (status == 0xc9af3d51u)
       status = kNtStillActive;
-    }
     pr->wstatus = status;
     if (!iswait4 && !pr->waiters && !__proc.waiters &&
         (__sighandrvas[SIGCHLD] == (uintptr_t)SIG_IGN ||
          (__sighandflags[SIGCHLD] & SA_NOCLDWAIT))) {
       // perform automatic zombie reaping
+      STRACE("automatically reaping zombie");
       dll_remove(&__proc.list, &pr->elem);
       dll_make_first(&__proc.free, &pr->elem);
       CloseHandle(pr->handle);
@@ -125,9 +136,14 @@ textwindows int __proc_harvest(struct Proc *pr, bool iswait4) {
   return sic;
 }
 
-static textwindows dontinstrument uint32_t __proc_worker(void *arg) {
+textwindows dontinstrument static uint32_t __proc_worker(void *arg) {
   struct CosmoTib tls;
+  char *sp = __builtin_frame_address(0);
   __bootstrap_tls(&tls, __builtin_frame_address(0));
+  __maps_track(
+      (char *)(((uintptr_t)sp + __pagesize - 1) & -__pagesize) - STACK_SIZE,
+      STACK_SIZE, PROT_READ | PROT_WRITE,
+      MAP_PRIVATE | MAP_ANONYMOUS | MAP_NOFORK);
   for (;;) {
 
     // assemble a group of processes to wait on. if more than 64
@@ -159,7 +175,7 @@ static textwindows dontinstrument uint32_t __proc_worker(void *arg) {
 
     // wait for something to happen
     if (n == 64) {
-      millis = 5;
+      millis = POLL_INTERVAL_MS;
     } else {
       millis = -1u;
       handles[n++] = __proc.onbirth;
@@ -181,9 +197,8 @@ static textwindows dontinstrument uint32_t __proc_worker(void *arg) {
         continue;
       if (j == i)
         continue;
-      if (!--objects[j]->waiters && objects[j]->status == PROC_UNDEAD) {
+      if (!--objects[j]->waiters && objects[j]->status == PROC_UNDEAD)
         __proc_free(objects[j]);
-      }
     }
 
     // check if we need to churn due to >64 processes
@@ -208,9 +223,8 @@ static textwindows dontinstrument uint32_t __proc_worker(void *arg) {
       case PROC_ZOMBIE:
         break;
       case PROC_UNDEAD:
-        if (!objects[i]->waiters) {
+        if (!objects[i]->waiters)
           __proc_free(objects[i]);
-        }
         break;
       default:
         __builtin_unreachable();
@@ -222,9 +236,8 @@ static textwindows dontinstrument uint32_t __proc_worker(void *arg) {
     // 1. wait4() is being used
     // 2. SIGCHLD has SIG_IGN handler
     // 3. SIGCHLD has SA_NOCLDWAIT flag
-    if (sic) {
+    if (sic)
       __sig_generate(SIGCHLD, sic);
-    }
   }
   return 0;
 }
@@ -232,11 +245,10 @@ static textwindows dontinstrument uint32_t __proc_worker(void *arg) {
 /**
  * Lazy initializes process tracker data structures and worker.
  */
-static textwindows void __proc_setup(void) {
-  __enable_threads();
+textwindows static void __proc_setup(void) {
   __proc.onbirth = CreateEvent(0, 0, 0, 0);     // auto reset
   __proc.haszombies = CreateEvent(0, 1, 0, 0);  // manual reset
-  __proc.thread = CreateThread(0, 65536, __proc_worker, 0,
+  __proc.thread = CreateThread(0, STACK_SIZE, __proc_worker, 0,
                                kNtStackSizeParamIsAReservation, 0);
 }
 
@@ -245,20 +257,22 @@ static textwindows void __proc_setup(void) {
  */
 textwindows void __proc_lock(void) {
   cosmo_once(&__proc.once, __proc_setup);
-  nsync_mu_lock(&__proc.lock);
+  _pthread_mutex_lock(&__proc_lock_obj);
 }
 
 /**
  * Unlocks process tracker.
  */
 textwindows void __proc_unlock(void) {
-  nsync_mu_unlock(&__proc.lock);
+  _pthread_mutex_unlock(&__proc_lock_obj);
 }
 
 /**
  * Resets process tracker from forked child.
  */
-textwindows void __proc_wipe(void) {
+textwindows void __proc_wipe_and_reset(void) {
+  // TODO(jart): Should we preserve this state in forked children?
+  _pthread_mutex_wipe_np(&__proc_lock_obj);
   bzero(&__proc, sizeof(__proc));
 }
 
@@ -273,27 +287,14 @@ textwindows void __proc_wipe(void) {
 textwindows struct Proc *__proc_new(void) {
   struct Dll *e;
   struct Proc *proc = 0;
-  // fork() + wait() don't depend on malloc() so neither shall we
-  if (__proc.allocated < ARRAYLEN(__proc.pool)) {
-    proc = __proc.pool + __proc.allocated++;
-  } else {
-    if ((e = dll_first(__proc.free))) {
-      proc = PROC_CONTAINER(e);
-      dll_remove(&__proc.free, &proc->elem);
-    }
-    if (!proc) {
-      if (_weaken(malloc)) {
-        proc = may_leak(_weaken(malloc)(sizeof(struct Proc)));
-      } else {
-        enomem();
-        return 0;
-      }
-    }
-  }
-  if (proc) {
-    bzero(proc, sizeof(*proc));
-    dll_init(&proc->elem);
+  if ((e = dll_first(__proc.free))) {
+    proc = PROC_CONTAINER(e);
+    dll_remove(&__proc.free, &proc->elem);
   }
+  if (!proc && !(proc = HeapAlloc(GetProcessHeap(), 0, sizeof(struct Proc))))
+    return 0;
+  bzero(proc, sizeof(*proc));
+  dll_init(&proc->elem);
   return proc;
 }
 
@@ -320,6 +321,7 @@ textwindows int64_t __proc_search(int pid) {
   int64_t handle = 0;
   BLOCK_SIGNALS;
   __proc_lock();
+  // TODO(jart): we should increment a reference count when returning
   for (e = dll_first(__proc.list); e; e = dll_next(__proc.list, e)) {
     if (pid == PROC_CONTAINER(e)->pid) {
       handle = PROC_CONTAINER(e)->handle;
diff --git a/libc/proc/proc.h b/libc/proc/proc.h
new file mode 100644
index 000000000..44b4ed5ad
--- /dev/null
+++ b/libc/proc/proc.h
@@ -0,0 +1,55 @@
+#ifndef COSMOPOLITAN_LIBC_PROC_H_
+#define COSMOPOLITAN_LIBC_PROC_H_
+#include "libc/atomic.h"
+#include "libc/calls/struct/rusage.h"
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/dll.h"
+#include "libc/thread/thread.h"
+COSMOPOLITAN_C_START_
+
+#define PROC_ALIVE  0
+#define PROC_ZOMBIE 1
+#define PROC_UNDEAD 2
+
+#define PROC_CONTAINER(e) DLL_CONTAINER(struct Proc, elem, e)
+
+struct Proc {
+  int pid;
+  int status;
+  int waiters;
+  bool wasforked;
+  uint32_t wstatus;
+  int64_t handle;
+  struct Dll elem;
+  struct rusage ru;
+};
+
+struct Procs {
+  int waiters;
+  atomic_uint once;
+  intptr_t thread;
+  intptr_t onbirth;
+  intptr_t haszombies;
+  struct Dll *list;
+  struct Dll *free;
+  struct Dll *undead;
+  struct Dll *zombies;
+  unsigned allocated;
+  struct rusage ruchlds;
+};
+
+extern struct Procs __proc;
+
+void __proc_lock(void);
+void __proc_unlock(void);
+int64_t __proc_handle(int);
+int64_t __proc_search(int);
+struct Proc *__proc_new(void);
+void __proc_add(struct Proc *);
+void __proc_free(struct Proc *);
+void __proc_wipe_and_reset(void);
+int __proc_harvest(struct Proc *, bool);
+int sys_wait4_nt(int, int *, int, struct rusage *);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_PROC_H_ */
diff --git a/libc/proc/proc.internal.h b/libc/proc/proc.internal.h
deleted file mode 100644
index fc36c1c60..000000000
--- a/libc/proc/proc.internal.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_PROC_H_
-#define COSMOPOLITAN_LIBC_PROC_H_
-#include "libc/atomic.h"
-#include "libc/calls/struct/rusage.h"
-#include "libc/intrin/atomic.h"
-#include "libc/intrin/dll.h"
-#include "libc/thread/thread.h"
-#include "third_party/nsync/mu.h"
-COSMOPOLITAN_C_START_
-
-#define PROC_ALIVE  0
-#define PROC_ZOMBIE 1
-#define PROC_UNDEAD 2
-
-#define PROC_CONTAINER(e) DLL_CONTAINER(struct Proc, elem, e)
-
-struct Proc {
-  int pid;
-  int status;
-  int waiters;
-  bool wasforked;
-  uint32_t wstatus;
-  int64_t handle;
-  struct Dll elem;
-  struct rusage ru;
-};
-
-struct Procs {
-  int waiters;
-  atomic_uint once;
-  nsync_mu lock;
-  intptr_t thread;
-  intptr_t onbirth;
-  intptr_t haszombies;
-  struct Dll *list;
-  struct Dll *free;
-  struct Dll *undead;
-  struct Dll *zombies;
-  struct Proc pool[8];
-  unsigned allocated;
-  struct rusage ruchlds;
-};
-
-extern struct Procs __proc;
-
-void __proc_wipe(void) libcesque;
-void __proc_lock(void) libcesque;
-void __proc_unlock(void) libcesque;
-int64_t __proc_handle(int) libcesque;
-int64_t __proc_search(int) libcesque;
-struct Proc *__proc_new(void) libcesque;
-void __proc_add(struct Proc *) libcesque;
-void __proc_free(struct Proc *) libcesque;
-int __proc_harvest(struct Proc *, bool) libcesque;
-int sys_wait4_nt(int, int *, int, struct rusage *) libcesque;
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_PROC_H_ */
diff --git a/libc/proc/sched_getaffinity.c b/libc/proc/sched_getaffinity.c
index 095e28c3b..752bc9c79 100644
--- a/libc/proc/sched_getaffinity.c
+++ b/libc/proc/sched_getaffinity.c
@@ -20,11 +20,11 @@
 #include "libc/calls/struct/cpuset.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/proc/sched_setaffinity.c b/libc/proc/sched_setaffinity.c
index c7c43fefa..79ab9fcfe 100644
--- a/libc/proc/sched_setaffinity.c
+++ b/libc/proc/sched_setaffinity.c
@@ -20,11 +20,11 @@
 #include "libc/calls/struct/cpuset.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
 #include "libc/sysv/errfuns.h"
 
 static dontinline textwindows int sys_sched_setaffinity_nt(
diff --git a/libc/proc/setpriority-nt.c b/libc/proc/setpriority-nt.c
index fc3f2fb09..3aeb56dfc 100644
--- a/libc/proc/setpriority-nt.c
+++ b/libc/proc/setpriority-nt.c
@@ -18,12 +18,12 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/processcreationflags.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
 #include "libc/sysv/consts/prio.h"
 #include "libc/sysv/errfuns.h"
 
diff --git a/libc/proc/setpriority.c b/libc/proc/setpriority.c
index 07845826a..4b09a631c 100644
--- a/libc/proc/setpriority.c
+++ b/libc/proc/setpriority.c
@@ -20,8 +20,8 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 
 /**
  * Sets nice value of thing.
diff --git a/libc/proc/times.c b/libc/proc/times.c
index 1538e1a9b..28973c964 100644
--- a/libc/proc/times.c
+++ b/libc/proc/times.c
@@ -16,55 +16,38 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
 #include "libc/calls/struct/rusage.h"
+#include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timeval.h"
 #include "libc/calls/struct/tms.h"
-#include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/dce.h"
-#include "libc/fmt/wintime.internal.h"
-#include "libc/nt/accounting.h"
-#include "libc/nt/runtime.h"
 #include "libc/runtime/clktck.h"
-#include "libc/runtime/sysconf.h"
+#include "libc/sysv/consts/clock.h"
 #include "libc/sysv/consts/rusage.h"
-#include "libc/time.h"
 
-static dontinline long ConvertMicros(struct timeval tv) {
+static long MicrosToTicks(struct timeval tv) {
   return tv.tv_sec * CLK_TCK + tv.tv_usec / (1000000 / CLK_TCK);
 }
 
-static dontinline long times2(struct tms *out_times, struct rusage *ru) {
-  struct timeval tv;
-  struct NtFileTime CreationTime, ExitTime, KernelTime, UserTime;
-  if (!IsWindows()) {
-    if (getrusage(RUSAGE_SELF, ru) == -1)
-      return -1;
-    out_times->tms_utime = ConvertMicros(ru->ru_utime);
-    out_times->tms_stime = ConvertMicros(ru->ru_stime);
-    if (getrusage(RUSAGE_CHILDREN, ru) == -1)
-      return -1;
-    out_times->tms_cutime = ConvertMicros(ru->ru_utime);
-    out_times->tms_cstime = ConvertMicros(ru->ru_stime);
-  } else {
-    if (!GetProcessTimes(GetCurrentProcess(), &CreationTime, &ExitTime,
-                         &KernelTime, &UserTime)) {
-      return __winerr();
-    }
-    out_times->tms_utime = ReadFileTime(UserTime);
-    out_times->tms_stime = ReadFileTime(KernelTime);
-    out_times->tms_cutime = 0;
-    out_times->tms_cstime = 0;
-  }
-  if (gettimeofday(&tv, NULL) == -1)
-    return -1;
-  return ConvertMicros(tv);
+static long NanosToTicks(struct timespec ts) {
+  return ts.tv_sec * CLK_TCK + ts.tv_nsec / (1000000000 / CLK_TCK);
 }
 
 /**
  * Returns accounting data for process on time-sharing system.
+ * @return number of `CLK_TCK` from `CLOCK_BOOTTIME` epoch
  */
 long times(struct tms *out_times) {
-  struct rusage ru;
-  return times2(out_times, &ru);
+  struct timespec bt;
+  struct rusage rus, ruc;
+  if (getrusage(RUSAGE_SELF, &rus))
+    return -1;
+  if (getrusage(RUSAGE_CHILDREN, &ruc))
+    return -1;
+  if (clock_gettime(CLOCK_BOOTTIME, &bt))
+    return -1;
+  out_times->tms_utime = MicrosToTicks(rus.ru_utime);
+  out_times->tms_stime = MicrosToTicks(rus.ru_stime);
+  out_times->tms_cutime = MicrosToTicks(ruc.ru_utime);
+  out_times->tms_cstime = MicrosToTicks(ruc.ru_stime);
+  return NanosToTicks(bt);
 }
diff --git a/libc/proc/vfork.S b/libc/proc/vfork.S
index 482d3b23a..3f87d74e1 100644
--- a/libc/proc/vfork.S
+++ b/libc/proc/vfork.S
@@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/thread/tls.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Forks process without copying page tables.
 //
@@ -121,7 +121,7 @@ vfork:
 //	} else {
 //	  __get_tls()->tib_flags &= ~TIB_FLAG_VFORKED;
 //	}
-	sub	x1,x28,#512		// sizeof(CosmoTib)
+	sub	x1,x28,#1024		// sizeof(CosmoTib)
 	ldr	x2,[x1,64]
 	cbnz	x0,2f
 	orr	x2,x2,#TIB_FLAG_VFORKED
diff --git a/libc/proc/wait4-nt.c b/libc/proc/wait4-nt.c
index d1f2bc396..fe8e0d85d 100644
--- a/libc/proc/wait4-nt.c
+++ b/libc/proc/wait4-nt.c
@@ -16,36 +16,34 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/enum/wait.h"
 #include "libc/nt/events.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/synchronization.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/consts/w.h"
 #include "libc/sysv/errfuns.h"
 #ifdef __x86_64__
 
-static textwindows int __proc_reap(struct Proc *pr, int *wstatus,
+textwindows static int __proc_reap(struct Proc *pr, int *wstatus,
                                    struct rusage *opt_out_rusage) {
-  if (wstatus) {
+  if (wstatus)
     *wstatus = pr->wstatus;
-  }
-  if (opt_out_rusage) {
+  if (opt_out_rusage)
     *opt_out_rusage = pr->ru;
-  }
   dll_remove(&__proc.zombies, &pr->elem);
-  if (dll_is_empty(__proc.zombies)) {
+  if (dll_is_empty(__proc.zombies))
     ResetEvent(__proc.haszombies);
-  }
   if (pr->waiters) {
     pr->status = PROC_UNDEAD;
     dll_make_first(&__proc.undead, &pr->elem);
@@ -56,53 +54,51 @@ static textwindows int __proc_reap(struct Proc *pr, int *wstatus,
   return pr->pid;
 }
 
-static textwindows int __proc_check(int pid, int *wstatus,
+textwindows static int __proc_check(int pid, int *wstatus,
                                     struct rusage *opt_out_rusage) {
   struct Dll *e;
   for (e = dll_first(__proc.zombies); e; e = dll_next(__proc.zombies, e)) {
     struct Proc *pr = PROC_CONTAINER(e);
-    if (pid == -1 || pid == pr->pid) {
+    if (pid == -1 || pid == pr->pid)
       return __proc_reap(pr, wstatus, opt_out_rusage);
-    }
   }
   return 0;
 }
 
-static textwindows int __proc_wait(int pid, int *wstatus, int options,
+textwindows static int __proc_wait(int pid, int *wstatus, int options,
                                    struct rusage *rusage, sigset_t waitmask) {
   for (;;) {
 
     // check for signals and cancelation
     int sig, handler_was_called;
-    if (_check_cancel() == -1) {
+    if (_check_cancel() == -1)
       return -1;
-    }
     if (_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))) {
       handler_was_called = _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
-      if (_check_cancel() == -1) {
+      if (_check_cancel() == -1)
         return -1;  // ECANCELED because SIGTHR was just handled
-      }
-      if (handler_was_called & SIG_HANDLED_NO_RESTART) {
+      if (handler_was_called & SIG_HANDLED_NO_RESTART)
         return eintr();  // a non-SA_RESTART handler was called
-      }
     }
 
     // check for zombie to harvest
     __proc_lock();
   CheckForZombies:
     int rc = __proc_check(pid, wstatus, rusage);
+
+    // if there's no zombies left
+    // check if there's any living processes
+    if (!rc && dll_is_empty(__proc.list)) {
+      __proc_unlock();
+      return echild();
+    }
+
+    // otherwise return zombie or zero
     if (rc || (options & WNOHANG)) {
       __proc_unlock();
       return rc;
     }
 
-    // there's no zombies left
-    // check if there's any living processes
-    if (dll_is_empty(__proc.list)) {
-      __proc_unlock();
-      return echild();
-    }
-
     // get appropriate wait object
     // register ourself as waiting
     struct Proc *pr = 0;
@@ -134,15 +130,19 @@ static textwindows int __proc_wait(int pid, int *wstatus, int options,
 
     // perform blocking operation
     uint32_t wi;
-    uintptr_t sem;
-    struct PosixThread *pt = _pthread_self();
-    pt->pt_blkmask = waitmask;
-    pt->pt_semaphore = sem = CreateSemaphore(0, 0, 1, 0);
-    atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_SEM,
-                          memory_order_release);
-    wi = WaitForMultipleObjects(2, (intptr_t[2]){hWaitObject, sem}, 0, -1u);
-    atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
-    CloseHandle(sem);
+    uintptr_t event;
+    if ((event = CreateEvent(0, 0, 0, 0))) {
+      struct PosixThread *pt = _pthread_self();
+      pt->pt_event = event;
+      pt->pt_blkmask = waitmask;
+      atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_EVENT,
+                            memory_order_release);
+      wi = WaitForMultipleObjects(2, (intptr_t[2]){hWaitObject, event}, 0, -1u);
+      atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
+      CloseHandle(event);
+    } else {
+      wi = -1u;
+    }
 
     // log warning if handle unexpectedly closed
     if (wi & kNtWaitAbandoned) {
@@ -160,15 +160,14 @@ static textwindows int __proc_wait(int pid, int *wstatus, int options,
     // check if killed or win32 error
     if (wi) {
       if (pr) {
-        if (!--pr->waiters && pr->status == PROC_UNDEAD) {
+        if (!--pr->waiters && pr->status == PROC_UNDEAD)
           __proc_free(pr);
-        }
       } else {
         --__proc.waiters;
       }
       __proc_unlock();
       if (wi == 1) {
-        // __sig_cancel() woke our semaphore
+        // __sig_wake() woke our semaphore
         continue;
       } else {
         // neither posix or win32 define i/o error conditions for
@@ -179,17 +178,15 @@ static textwindows int __proc_wait(int pid, int *wstatus, int options,
 
     // handle process exit notification
     --pr->waiters;
-    if (pr->status == PROC_ALIVE) {
+    if (pr->status == PROC_ALIVE)
       __proc_harvest(pr, true);
-    }
     switch (pr->status) {
       case PROC_ALIVE:
         // exit caused by execve() reparenting
-        __proc_unlock();
-        if (!pr->waiters) {
+        if (!pr->waiters)
           // avoid deadlock that could theoretically happen
           SetEvent(__proc.onbirth);
-        }
+        __proc_unlock();
         break;
       case PROC_ZOMBIE:
         // exit happened and we're the first to know
@@ -198,9 +195,8 @@ static textwindows int __proc_wait(int pid, int *wstatus, int options,
         return rc;
       case PROC_UNDEAD:
         // exit happened but another thread waited first
-        if (!pr->waiters) {
+        if (!pr->waiters)
           __proc_free(pr);
-        }
         __proc_unlock();
         return echild();
       default:
diff --git a/libc/proc/wait4.c b/libc/proc/wait4.c
index 7d6056aff..0db1f4a81 100644
--- a/libc/proc/wait4.c
+++ b/libc/proc/wait4.c
@@ -20,8 +20,8 @@
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/struct/rusage.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/proc/proc.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/runtime/BUILD.mk b/libc/runtime/BUILD.mk
index 35843d5ff..f2f770cdc 100644
--- a/libc/runtime/BUILD.mk
+++ b/libc/runtime/BUILD.mk
@@ -107,8 +107,6 @@ o/$(MODE)/libc/runtime/clone-linux.o: libc/runtime/clone-linux.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/runtime/ftrace-hook.o: libc/runtime/ftrace-hook.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
-o/$(MODE)/libc/runtime/dsohandle.o: libc/runtime/dsohandle.S
-	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/runtime/zipos.o: libc/runtime/zipos.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
 o/$(MODE)/libc/runtime/switchstacks.o: libc/runtime/switchstacks.S
diff --git a/libc/runtime/at_quick_exit.c b/libc/runtime/at_quick_exit.c
index 4786d801b..c9aa389b9 100644
--- a/libc/runtime/at_quick_exit.c
+++ b/libc/runtime/at_quick_exit.c
@@ -16,35 +16,32 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/atomic.h"
-#include "libc/macros.internal.h"
-#include "libc/runtime/runtime.h"
-#include "libc/thread/thread.h"
+#include "libc/intrin/cxaatexit.h"
+#include "libc/macros.h"
+#include "libc/stdlib.h"
 
 static void (*funcs[32])(void);
 static int count;
-static pthread_spinlock_t lock;
-pthread_spinlock_t *const __at_quick_exit_lockptr = &lock;
 
 void __funcs_on_quick_exit(void) {
   void (*func)(void);
-  pthread_spin_lock(&lock);
+  __cxa_lock();
   while (count) {
     func = funcs[--count];
-    pthread_spin_unlock(&lock);
+    __cxa_unlock();
     func();
-    pthread_spin_lock(&lock);
+    __cxa_lock();
   }
 }
 
 int at_quick_exit(void func(void)) {
   int res = 0;
-  pthread_spin_lock(&lock);
+  __cxa_lock();
   if (count == ARRAYLEN(funcs)) {
     res = -1;
   } else {
     funcs[count++] = func;
   }
-  pthread_spin_unlock(&lock);
+  __cxa_unlock();
   return res;
 }
diff --git a/libc/runtime/clone-linux.S b/libc/runtime/clone-linux.S
index 2863daac8..909d525fe 100644
--- a/libc/runtime/clone-linux.S
+++ b/libc/runtime/clone-linux.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .privileged
 
 //	Invokes clone() system call on GNU/Systemd.
@@ -26,54 +26,46 @@
 //	@param	rdx	x2	is ptid
 //	@param	rcx	x3	is ctid
 //	@param	r8	x4	is tls
-//	@param	r9	x5	is func(void*,int)→int
+//	@param	r9	x5	is func(void*)→int
 //	@param	8(rsp)	x6	is arg
 //	@return	tid of child on success, or -errno on error
 sys_clone_linux:
+	beg
+	pro
 #ifdef __x86_64__
-	push	%rbp
-	mov	%rsp,%rbp
-	push	%rbx
+	cpush	%rbx
 	mov	%rcx,%r10
 	mov	16(%rbp),%rbx
 	mov	$56,%eax		// __NR_clone
 	syscall
 	test	%rax,%rax
 	jz	2f
-0:	pop	%rbx
-	pop	%rbp
+0:	cpop	%rbx
+	epi
 	ret
 2:	xor	%ebp,%ebp		// child thread
 	mov	%rbx,%rdi		// arg
-	mov	%r10,%r15		// experiment
-	mov	(%r10),%esi		// tid
 	call	*%r9			// func(arg,tid)
 	xchg	%eax,%edi		// func(arg,tid) → exitcode
-	mov	(%r15),%eax		// experiment
-	test	%eax,%eax		// experiment
-	jz	1f			// experiment
 	mov	$60,%eax		// __NR_exit(exitcode)
 	syscall
-1:	hlt				// ctid was corrupted by program!
 #elif defined(__aarch64__)
-	stp	x29,x30,[sp,#-16]!
-	mov	x29,sp
 	mov	x8,x3			// swap x3 and x4
 	mov	x3,x4			// swap x3 and x4
 	mov	x4,x8			// swap x3 and x4
 	mov	x8,#220			// __NR_clone
 	svc	#0
 	cbz	x0,2f
-	ldp	x29,x30,[sp],#16
+	epi
 	ret
 2:	mov	x29,#0			// wipe backtrace
 	mov	x28,x3			// set cosmo tls
 	mov	x0,x6			// child thread
-	ldr	w1,[x4]			// arg2 = *ctid
 	blr	x5
 	mov	x8,#93			// __NR_exit
 	svc	#0
 #else
 #error "unsupported architecture"
 #endif
+	end
 	.endfn	sys_clone_linux,globl,hidden
diff --git a/libc/runtime/clone-openbsd.S b/libc/runtime/clone-openbsd.S
index a1a9feb78..daa3cde0c 100644
--- a/libc/runtime/clone-openbsd.S
+++ b/libc/runtime/clone-openbsd.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #define SYS___tfork 8
 
diff --git a/libc/runtime/clone-xnu.S b/libc/runtime/clone-xnu.S
index fea63d203..66b1c4283 100644
--- a/libc/runtime/clone-xnu.S
+++ b/libc/runtime/clone-xnu.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 sys_clone_xnu:
 	mov	$0x02000168,%eax		# bsdthread_create
diff --git a/libc/runtime/clone.c b/libc/runtime/clone.c
index be9b73488..c2325896e 100644
--- a/libc/runtime/clone.c
+++ b/libc/runtime/clone.c
@@ -16,49 +16,27 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/sysv/consts/clone.h"
-#include "libc/assert.h"
 #include "libc/atomic.h"
-#include "libc/calls/calls.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/ucontext-netbsd.internal.h"
-#include "libc/calls/syscall-sysv.internal.h"
-#include "libc/calls/wincrash.internal.h"
 #include "libc/dce.h"
-#include "libc/errno.h"
+#include "libc/intrin/asmflag.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describeflags.internal.h"
 #include "libc/intrin/ulock.h"
-#include "libc/intrin/weaken.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
 #include "libc/mem/alloca.h"
 #include "libc/nt/enum/processcreationflags.h"
 #include "libc/nt/runtime.h"
-#include "libc/nt/signals.h"
 #include "libc/nt/synchronization.h"
 #include "libc/nt/thread.h"
 #include "libc/nt/thunk/msabi.h"
-#include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
-#include "libc/runtime/stack.h"
 #include "libc/runtime/syslib.internal.h"
 #include "libc/sock/internal.h"
-#include "libc/stdalign.internal.h"
-#include "libc/stdio/sysparam.h"
-#include "libc/str/str.h"
 #include "libc/sysv/consts/arch.h"
-#include "libc/sysv/consts/clone.h"
-#include "libc/sysv/consts/futex.h"
-#include "libc/sysv/consts/nr.h"
-#include "libc/sysv/consts/nrlinux.h"
-#include "libc/sysv/errfuns.h"
 #include "libc/thread/freebsd.internal.h"
 #include "libc/thread/openbsd.internal.h"
-#include "libc/thread/thread.h"
-#include "libc/thread/tls.h"
-#include "libc/thread/tls2.internal.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/xnu.internal.h"
 
 #define kMaxThreadIds 32768
@@ -78,85 +56,73 @@
 #define LWP_SUSPENDED                     0x00000080
 
 struct CloneArgs {
-  alignas(16) union {
-    struct {
-      atomic_int tid;
-      int this;
-    };
+  union {
+    long sp;
     int64_t tid64;
   };
   atomic_int *ptid;
   atomic_int *ctid;
-  atomic_int *ztid;
   char *tls;
-  int (*func)(void *, int);
+  int (*func)(void *);
   void *arg;
-  long sp;
 };
 
 int sys_set_tls(uintptr_t, void *);
-int __stack_call(void *, int, long, long, int (*)(void *, int), long);
-
-static long AlignStack(long sp, char *stk, long stksz, int mal) {
-  return sp & -mal;
-}
+int __stack_call(void *, int, long, long, int (*)(void *), long);
 
 #ifdef __x86_64__
 
 ////////////////////////////////////////////////////////////////////////////////
 // THE NEW TECHNOLOGY
 
-__msabi extern typeof(TlsSetValue) *const __imp_TlsSetValue;
 __msabi extern typeof(ExitThread) *const __imp_ExitThread;
+__msabi extern typeof(GetCurrentThreadId) *const __imp_GetCurrentThreadId;
 __msabi extern typeof(WakeByAddressAll) *const __imp_WakeByAddressAll;
 
-static textwindows dontinstrument wontreturn void  //
+textwindows dontinstrument wontreturn static void  //
 WinThreadEntry(int rdi,                            // rcx
                int rsi,                            // rdx
                int rdx,                            // r8
                struct CloneArgs *wt) {             // r9
-  int rc;
-  if (wt->tls)
-    __set_tls_win32(wt->tls);
-  *wt->ctid = GetCurrentThreadId();
-  rc = __stack_call(wt->arg, wt->tid, 0, 0, wt->func, wt->sp);
+  __set_tls_win32(wt->tls);
+  int tid = __imp_GetCurrentThreadId();
+  atomic_int *ctid = wt->ctid;
+  atomic_init(ctid, tid);
+  atomic_init(wt->ptid, tid);
+  int rc = __stack_call(wt->arg, tid, 0, 0, wt->func, wt->sp);
   // we can now clear ctid directly since we're no longer using our own
   // stack memory, which can now be safely free'd by the parent thread.
-  *wt->ztid = 0;
-  __imp_WakeByAddressAll(wt->ztid);
+  atomic_store_explicit(ctid, 0, memory_order_release);
+  __imp_WakeByAddressAll(ctid);
   // since we didn't indirect this function through NT2SYSV() it's not
   // safe to simply return, and as such, we need ExitThread().
   __imp_ExitThread(rc);
   __builtin_unreachable();
 }
 
-static textwindows errno_t CloneWindows(int (*func)(void *, int), char *stk,
-                                        size_t stksz, int flags, void *arg,
-                                        void *tls, atomic_int *ptid,
-                                        atomic_int *ctid) {
+textwindows static errno_t CloneWindows(int (*func)(void *), char *stk,
+                                        size_t stksz, void *arg, void *tls,
+                                        atomic_int *ptid, atomic_int *ctid) {
   long sp;
   int64_t h;
+  intptr_t tip;
   uint32_t utid;
   struct CloneArgs *wt;
-  sp = (intptr_t)stk + stksz;
-  sp = AlignStack(sp, stk, stksz, 16);
+  sp = tip = (intptr_t)stk + stksz;
   sp -= sizeof(struct CloneArgs);
   sp &= -alignof(struct CloneArgs);
   wt = (struct CloneArgs *)sp;
-  wt->ctid = flags & CLONE_CHILD_SETTID ? ctid : &wt->tid;
-  wt->ztid = flags & CLONE_CHILD_CLEARTID ? ctid : &wt->tid;
+  wt->ctid = ctid;
+  wt->ptid = ptid;
   wt->func = func;
   wt->arg = arg;
-  wt->tls = flags & CLONE_SETTLS ? tls : 0;
-  wt->sp = sp;
-  if ((h = CreateThread(&kNtIsInheritable, 65536, (void *)WinThreadEntry, wt,
+  wt->tls = tls;
+  wt->sp = tip & -16;
+  if ((h = CreateThread(0, 65536, (void *)WinThreadEntry, wt,
                         kNtStackSizeParamIsAReservation, &utid))) {
-    if (flags & CLONE_PARENT_SETTID)
-      *ptid = utid;
-    if (flags & CLONE_SETTLS) {
-      struct CosmoTib *tib = tls;
-      atomic_store_explicit(&tib->tib_syshand, h, memory_order_release);
-    }
+    atomic_init(ptid, utid);
+    struct CosmoTib *tib = tls;
+    atomic_store_explicit(&tib->tib_syshand, h, memory_order_release);
     return 0;
   } else {
     return __dos2errno(GetLastError());
@@ -180,36 +146,33 @@ asm("XnuThreadThunk:\n\t"
     ".size\tXnuThreadThunk,.-XnuThreadThunk");
 __attribute__((__used__))
 
-static wontreturn void
-XnuThreadMain(void *pthread,                    // rdi
-              int tid,                          // rsi
-              int (*func)(void *arg, int tid),  // rdx
-              void *arg,                        // rcx
-              struct CloneArgs *wt,             // r8
-              unsigned xnuflags) {              // r9
+dontinstrument wontreturn static void
+XnuThreadMain(void *pthread,           // rdi
+              int tid,                 // rsi
+              int (*func)(void *arg),  // rdx
+              void *arg,               // rcx
+              struct CloneArgs *wt,    // r8
+              unsigned xnuflags) {     // r9
+  atomic_init(wt->ctid, tid);
+  atomic_init(wt->ptid, tid);
+
+  // XNU uses the same 0x30 offset as the WIN32 TIB x64. They told the
+  // Go team at Google that they Apply stands by our ability to use it
+  // https://github.com/golang/go/issues/23617#issuecomment-376662373
   int ax;
-  wt->tid = tid;
-  *wt->ctid = tid;
-  *wt->ptid = tid;
+  asm volatile("syscall"
+               : "=a"(ax)
+               : "0"(__NR_thread_fast_set_cthread_self), "D"(wt->tls - 0x30)
+               : "rcx", "rdx", "r8", "r9", "r10", "r11", "memory", "cc");
 
-  if (wt->tls) {
-    // XNU uses the same 0x30 offset as the WIN32 TIB x64. They told the
-    // Go team at Google that they Apply stands by our ability to use it
-    // https://github.com/golang/go/issues/23617#issuecomment-376662373
-    asm volatile("syscall"
-                 : "=a"(ax)
-                 : "0"(__NR_thread_fast_set_cthread_self), "D"(wt->tls - 0x30)
-                 : "rcx", "rdx", "r8", "r9", "r10", "r11", "memory", "cc");
-  }
-
-  func(arg, tid);
+  func(arg);
 
   // we no longer use the stack after this point
   // %rax = int bsdthread_terminate(%rdi = void *stackaddr,
   //                                %rsi = size_t freesize,
   //                                %rdx = uint32_t port,
   //                                %r10 = uint32_t sem);
-  asm volatile("movl\t$0,(%%rsi)\n\t"        // *wt->ztid = 0
+  asm volatile("movl\t$0,(%%rsi)\n\t"        // *wt->ctid = 0
                "mov\t$0x101,%%edi\n\t"       // wake all
                "xor\t%%edx,%%edx\n\t"        // wake_value
                "mov\t$0x02000204,%%eax\n\t"  // ulock_wake()
@@ -221,19 +184,18 @@ XnuThreadMain(void *pthread,                    // rdi
                "mov\t$0x02000169,%%eax\n\t"  // bsdthread_terminate()
                "syscall"
                : /* no outputs */
-               : "S"(wt->ztid)
+               : "S"(wt->ctid)
                : "rax", "rcx", "r10", "r11", "memory");
   __builtin_unreachable();
 }
 
-static errno_t CloneXnu(int (*fn)(void *), char *stk, size_t stksz, int flags,
-                        void *arg, void *tls, atomic_int *ptid,
-                        atomic_int *ctid) {
+static errno_t CloneXnu(int (*fn)(void *), char *stk, size_t stksz, void *arg,
+                        void *tls, atomic_int *ptid, atomic_int *ctid) {
 
   // perform this weird mandatory system call once
   static bool once;
   if (!once) {
-    npassert(sys_bsdthread_register(XnuThreadThunk, 0, 0, 0, 0, 0, 0) != -1);
+    sys_bsdthread_register(XnuThreadThunk, 0, 0, 0, 0, 0, 0);
     once = true;
   }
 
@@ -241,16 +203,15 @@ static errno_t CloneXnu(int (*fn)(void *), char *stk, size_t stksz, int flags,
   long sp;
   struct CloneArgs *wt;
   sp = (intptr_t)stk + stksz;
-  sp = AlignStack(sp, stk, stksz, 16);
   sp -= sizeof(struct CloneArgs);
   sp &= -alignof(struct CloneArgs);
   wt = (struct CloneArgs *)sp;
+  sp &= -16;
 
   // pass parameters to new thread via xnu
-  wt->ptid = flags & CLONE_PARENT_SETTID ? ptid : &wt->tid;
-  wt->ctid = flags & CLONE_CHILD_SETTID ? ctid : &wt->tid;
-  wt->ztid = flags & CLONE_CHILD_CLEARTID ? ctid : &wt->tid;
-  wt->tls = flags & CLONE_SETTLS ? tls : 0;
+  wt->ctid = ctid;
+  wt->ptid = ptid;
+  wt->tls = tls;
   return sys_clone_xnu(fn, arg, wt, 0, PTHREAD_START_CUSTOM_XNU);
 }
 
@@ -259,26 +220,27 @@ static errno_t CloneXnu(int (*fn)(void *), char *stk, size_t stksz, int flags,
 
 // we can't use address sanitizer because:
 //   1. __asan_handle_no_return wipes stack [todo?]
-static wontreturn void OpenbsdThreadMain(void *p) {
+relegated dontinstrument wontreturn static void OpenbsdThreadMain(void *p) {
   struct CloneArgs *wt = p;
-  *wt->ctid = wt->tid;
-  wt->func(wt->arg, wt->tid);
-  asm volatile("mov\t%2,%%rsp\n\t"     // so syscall can validate stack exists
-               "movl\t$0,(%%rdi)\n\t"  // *wt->ztid = 0 (old stack now free'd)
+  int tid = atomic_load_explicit(wt->ctid, memory_order_relaxed);
+  atomic_init(wt->ptid, tid);
+  wt->func(wt->arg);
+  asm volatile("mov\t%1,%%rsp\n\t"     // so syscall can validate stack exists
+               "movl\t$0,(%2)\n\t"     // *wt->ctid = 0 (old stack now free'd)
                "syscall\n\t"           // futex(int*, op, val) will wake wait0
                "xor\t%%edi,%%edi\n\t"  // so kernel doesn't write to old stack
                "mov\t$302,%%eax\n\t"   // __threxit(int *notdead) doesn't wake
                "syscall"
-               : "=m"(*wt->ztid)
-               : "a"(83), "m"(__oldstack), "D"(wt->ztid),
+               : /* no outputs */
+               : "a"(83), "m"(__oldstack), "D"(wt->ctid),
                  "S"(2 /* FUTEX_WAKE */), "d"(INT_MAX)
                : "rcx", "r11", "memory");
   __builtin_unreachable();
 }
 
-static errno_t CloneOpenbsd(int (*func)(void *, int), char *stk, size_t stksz,
-                            int flags, void *arg, void *tls, atomic_int *ptid,
-                            atomic_int *ctid) {
+relegated static errno_t CloneOpenbsd(int (*func)(void *), char *stk,
+                                      size_t stksz, void *arg, void *tls,
+                                      atomic_int *ptid, atomic_int *ctid) {
   int rc;
   intptr_t sp;
   struct __tfork *tf;
@@ -290,19 +252,18 @@ static errno_t CloneOpenbsd(int (*func)(void *, int), char *stk, size_t stksz,
   sp -= sizeof(struct CloneArgs);
   sp &= -alignof(struct CloneArgs);
   wt = (struct CloneArgs *)sp;
-  sp = AlignStack(sp, stk, stksz, 16);
-  wt->ctid = flags & CLONE_CHILD_SETTID ? ctid : &wt->tid;
-  wt->ztid = flags & CLONE_CHILD_CLEARTID ? ctid : &wt->tid;
+  sp &= -16;
+  sp -= 8;
+  *(intptr_t *)sp = (intptr_t)CloneOpenbsd + 1;
+  wt->ctid = ctid;
+  wt->ptid = ptid;
   wt->arg = arg;
   wt->func = func;
-  tf->tf_stack = (char *)sp - 8;
-  tf->tf_tcb = flags & CLONE_SETTLS ? tls : 0;
-  tf->tf_tid = &wt->tid;
+  tf->tf_stack = (char *)sp;
+  tf->tf_tcb = tls;
+  tf->tf_tid = ctid;
   if ((rc = __tfork_thread(tf, sizeof(*tf), OpenbsdThreadMain, wt)) >= 0) {
-    npassert(rc);
-    if (flags & CLONE_PARENT_SETTID) {
-      *ptid = rc;
-    }
+    atomic_init(ptid, rc);
     return 0;
   } else {
     return -rc;
@@ -312,35 +273,35 @@ static errno_t CloneOpenbsd(int (*func)(void *, int), char *stk, size_t stksz,
 ////////////////////////////////////////////////////////////////////////////////
 // NET BESIYATA DISHMAYA
 
-static wontreturn void NetbsdThreadMain(void *arg,                 // rdi
-                                        int (*func)(void *, int),  // rsi
-                                        int *tid,                  // rdx
-                                        atomic_int *ctid,          // rcx
-                                        int *ztid) {               // r9
-  int ax, dx;
-  // TODO(jart): Why are we seeing flakes where *tid is zero?
-  // ax = *tid;
-  ax = sys_gettid();
-  *ctid = ax;
-  func(arg, ax);
+wontreturn dontinstrument static void NetbsdThreadMain(
+    void *arg,            // rdi
+    int (*func)(void *),  // rsi
+    atomic_int *ctid,     // rdx
+    atomic_int *ptid) {   // rcx
+  int ax;
+  asm("syscall"
+      : "=a"(ax)  // man says always succeeds
+      : "0"(311)  // _lwp_self()
+      : "rcx", "rdx", "r8", "r9", "r10", "r11", "memory", "cc");
+  atomic_init(ctid, ax);
+  atomic_init(ptid, ax);
+  func(arg);
   // we no longer use the stack after this point
   // %eax = int __lwp_exit(void);
-  asm volatile("movl\t$0,%2\n\t"  // *wt->ztid = 0
-               "syscall"          // __lwp_exit()
-               : "=a"(ax), "=d"(dx), "=m"(*ztid)
-               : "0"(310)
+  asm volatile("movl\t$0,(%2)\n\t"  // *ztid = 0
+               "syscall"            // __lwp_exit()
+               : "=a"(ax)
+               : "0"(310), "r"(ctid)
                : "rcx", "r11", "memory");
   __builtin_unreachable();
 }
 
-static int CloneNetbsd(int (*func)(void *, int), char *stk, size_t stksz,
-                       int flags, void *arg, void *tls, atomic_int *ptid,
-                       atomic_int *ctid) {
+static int CloneNetbsd(int (*func)(void *), char *stk, size_t stksz, void *arg,
+                       void *tls, atomic_int *ptid, atomic_int *ctid) {
   // NetBSD has its own clone() and it works, but it's technically a
   // second-class API, intended to help Linux folks migrate to this.
   int ax;
   bool failed;
-  atomic_int *tid;
   intptr_t dx, sp;
   static bool once;
   struct ucontext_netbsd *ctx;
@@ -352,19 +313,12 @@ static int CloneNetbsd(int (*func)(void *, int), char *stk, size_t stksz,
                  : CFLAG_CONSTRAINT(failed), "=a"(ax)
                  : "1"(__NR_getcontext_netbsd), "D"(&netbsd_clone_template)
                  : "rcx", "rdx", "r8", "r9", "r10", "r11", "memory");
-    npassert(!failed);
     once = true;
   }
   sp = (intptr_t)stk + stksz;
 
-  // allocate memory for tid
-  sp -= sizeof(atomic_int);
-  sp = sp & -alignof(atomic_int);
-  tid = (atomic_int *)sp;
-  *tid = 0;
-
   // align the stack
-  sp = AlignStack(sp, stk, stksz, 16);
+  sp &= -16;
 
   // simulate call to misalign stack and ensure backtrace looks good
   sp -= 8;
@@ -372,8 +326,7 @@ static int CloneNetbsd(int (*func)(void *, int), char *stk, size_t stksz,
 
   // place the giant 784 byte ucontext structure in the red zone!
   // it only has to live long enough for the thread to come alive
-  ctx = (struct ucontext_netbsd *)((sp - sizeof(struct ucontext_netbsd)) &
-                                   -alignof(struct ucontext_netbsd));
+  ctx = (struct ucontext_netbsd *)((sp - sizeof(struct ucontext_netbsd)) & -64);
 
   // pass parameters in process state
   memcpy(ctx, &netbsd_clone_template, sizeof(*ctx));
@@ -383,28 +336,23 @@ static int CloneNetbsd(int (*func)(void *, int), char *stk, size_t stksz,
   ctx->uc_mcontext.rip = (intptr_t)NetbsdThreadMain;
   ctx->uc_mcontext.rdi = (intptr_t)arg;
   ctx->uc_mcontext.rsi = (intptr_t)func;
-  ctx->uc_mcontext.rdx = (intptr_t)tid;
-  ctx->uc_mcontext.rcx = (intptr_t)(flags & CLONE_CHILD_SETTID ? ctid : tid);
-  ctx->uc_mcontext.r8 = (intptr_t)(flags & CLONE_CHILD_CLEARTID ? ctid : tid);
+  ctx->uc_mcontext.rdx = (intptr_t)ctid;
+  ctx->uc_mcontext.rcx = (intptr_t)ptid;
   ctx->uc_flags |= _UC_STACK;
   ctx->uc_stack.ss_sp = stk;
   ctx->uc_stack.ss_size = stksz;
   ctx->uc_stack.ss_flags = 0;
-  if (flags & CLONE_SETTLS) {
-    ctx->uc_flags |= _UC_TLSBASE;
-    ctx->uc_mcontext._mc_tlsbase = (intptr_t)tls;
-  }
+  ctx->uc_flags |= _UC_TLSBASE;
+  ctx->uc_mcontext._mc_tlsbase = (intptr_t)tls;
 
   // perform the system call
+  int tid = 0;
   asm volatile(CFLAG_ASM("syscall")
                : CFLAG_CONSTRAINT(failed), "=a"(ax), "=d"(dx)
-               : "1"(__NR__lwp_create), "D"(ctx), "S"(LWP_DETACHED), "2"(tid)
+               : "1"(__NR__lwp_create), "D"(ctx), "S"(LWP_DETACHED), "2"(&tid)
                : "rcx", "r8", "r9", "r10", "r11", "memory");
   if (!failed) {
-    npassert(*tid);
-    if (flags & CLONE_PARENT_SETTID) {
-      *ptid = *tid;
-    }
+    atomic_init(ptid, tid);
     return 0;
   } else {
     return ax;
@@ -416,41 +364,42 @@ static int CloneNetbsd(int (*func)(void *, int), char *stk, size_t stksz,
 ////////////////////////////////////////////////////////////////////////////////
 // FREE BESIYATA DISHMAYA
 
-static wontreturn void FreebsdThreadMain(void *p) {
+wontreturn dontinstrument static void FreebsdThreadMain(void *p) {
   struct CloneArgs *wt = p;
 #ifdef __aarch64__
   asm volatile("mov\tx28,%0" : /* no outputs */ : "r"(wt->tls));
 #elif defined(__x86_64__)
   sys_set_tls(AMD64_SET_GSBASE, wt->tls);
 #endif
-  *wt->ctid = wt->tid;
-  wt->func(wt->arg, wt->tid);
+  atomic_init(wt->ctid, wt->tid64);
+  atomic_init(wt->ptid, wt->tid64);
+  wt->func(wt->arg);
   // we no longer use the stack after this point
   // void thr_exit(%rdi = long *state);
 #ifdef __x86_64__
-  asm volatile("movl\t$0,%0\n\t"       // *wt->ztid = 0
-               "syscall\n\t"           // _umtx_op(wt->ztid, WAKE, INT_MAX)
+  asm volatile("movl\t$0,%0\n\t"       // *wt->ctid = 0
+               "syscall\n\t"           // _umtx_op(wt->ctid, WAKE, INT_MAX)
                "movl\t$431,%%eax\n\t"  // thr_exit(long *nonzeroes_and_wake)
                "xor\t%%edi,%%edi\n\t"  // sad we can't use this free futex op
                "syscall\n\t"           // thr_exit() fails if thread is orphaned
                "movl\t$1,%%eax\n\t"    // _exit()
                "syscall"               //
-               : "=m"(*wt->ztid)
-               : "a"(454), "D"(wt->ztid), "S"(UMTX_OP_WAKE), "d"(INT_MAX)
+               : "=m"(*wt->ctid)
+               : "a"(454), "D"(wt->ctid), "S"(UMTX_OP_WAKE), "d"(INT_MAX)
                : "rcx", "r8", "r9", "r10", "r11", "memory");
 #elif defined(__aarch64__)
-  register long x0 asm("x0") = (long)wt->ztid;
+  register long x0 asm("x0") = (long)wt->ctid;
   register long x1 asm("x1") = UMTX_OP_WAKE;
   register long x2 asm("x2") = INT_MAX;
   register long x8 asm("x8") = 454;  // _umtx_op
-  asm volatile("str\twzr,%0\n\t"     // *wt->ztid = 0
-               "svc\t0\n\t"          // _umtx_op(wt->ztid, WAKE, INT_MAX)
+  asm volatile("str\twzr,%0\n\t"     // *wt->ctid = 0
+               "svc\t0\n\t"          // _umtx_op(wt->ctid, WAKE, INT_MAX)
                "mov\tx0,#0\n\t"      // arg0 = 0
                "mov\tx8,#431\n\t"    // thr_exit
                "svc\t0\n\t"          // thr_exit(long *nonzeroes_and_wake = 0)
                "mov\tx8,#1\n\t"      // _exit
                "svc\t0"              // _exit(long *nonzeroes_and_wake = 0)
-               : "=m"(*wt->ztid)
+               : "=m"(*wt->ctid)
                : "r"(x0), "r"(x1), "r"(x2), "r"(x8));
 #else
 #error "unsupported architecture"
@@ -458,19 +407,19 @@ static wontreturn void FreebsdThreadMain(void *p) {
   __builtin_unreachable();
 }
 
-static errno_t CloneFreebsd(int (*func)(void *, int), char *stk, size_t stksz,
-                            int flags, void *arg, void *tls, atomic_int *ptid,
+static errno_t CloneFreebsd(int (*func)(void *), char *stk, size_t stksz,
+                            void *arg, void *tls, atomic_int *ptid,
                             atomic_int *ctid) {
   long sp;
-  int64_t tid;
+  int64_t tid64;
   struct CloneArgs *wt;
   sp = (intptr_t)stk + stksz;
   sp -= sizeof(struct CloneArgs);
   sp &= -alignof(struct CloneArgs);
   wt = (struct CloneArgs *)sp;
-  sp = AlignStack(sp, stk, stksz, 16);
-  wt->ctid = flags & CLONE_CHILD_SETTID ? ctid : &wt->tid;
-  wt->ztid = flags & CLONE_CHILD_CLEARTID ? ctid : &wt->tid;
+  sp &= -16;
+  wt->ctid = ctid;
+  wt->ptid = ptid;
   wt->tls = tls;
   wt->func = func;
   wt->arg = arg;
@@ -479,10 +428,10 @@ static errno_t CloneFreebsd(int (*func)(void *, int), char *stk, size_t stksz,
       .arg = wt,
       .stack_base = stk,
       .stack_size = sp - (long)stk,
-      .tls_base = flags & CLONE_SETTLS ? tls : 0,
+      .tls_base = tls,
       .tls_size = 64,
       .child_tid = &wt->tid64,
-      .parent_tid = &tid,
+      .parent_tid = &tid64,
   };
 #ifdef __x86_64__
   int ax;
@@ -503,8 +452,7 @@ static errno_t CloneFreebsd(int (*func)(void *, int), char *stk, size_t stksz,
 #else
 #error "unsupported architecture"
 #endif
-  if (flags & CLONE_PARENT_SETTID)
-    *ptid = tid;
+  atomic_init(ptid, tid64);
   return 0;
 }
 
@@ -513,57 +461,59 @@ static errno_t CloneFreebsd(int (*func)(void *, int), char *stk, size_t stksz,
 ////////////////////////////////////////////////////////////////////////////////
 // APPLE SILICON
 
-static void *SiliconThreadMain(void *arg) {
+dontinstrument static void *SiliconThreadMain(void *arg) {
   struct CloneArgs *wt = arg;
+  atomic_int *ctid = wt->ctid;
+  int tid = atomic_load_explicit(ctid, memory_order_relaxed);
   asm volatile("mov\tx28,%0" : /* no outputs */ : "r"(wt->tls));
-  *wt->ctid = wt->this;
-  __stack_call(wt->arg, wt->this, 0, 0, wt->func, wt->sp);
-  *wt->ztid = 0;
-  ulock_wake(UL_COMPARE_AND_WAIT | ULF_WAKE_ALL, wt->ztid, 0);
+  __stack_call(wt->arg, tid, 0, 0, wt->func, wt->sp);
+  atomic_store_explicit(ctid, 0, memory_order_release);
+  ulock_wake(UL_COMPARE_AND_WAIT | ULF_WAKE_ALL, ctid, 0);
   return 0;
 }
 
-static errno_t CloneSilicon(int (*fn)(void *, int), char *stk, size_t stksz,
-                            int flags, void *arg, void *tls, atomic_int *ptid,
+static errno_t CloneSilicon(int (*fn)(void *), char *stk, size_t stksz,
+                            void *arg, void *tls, atomic_int *ptid,
                             atomic_int *ctid) {
-  long sp;
-  void *attr;
-  errno_t res;
-  unsigned tid;
-  pthread_t th;
-  size_t babystack;
-  struct CloneArgs *wt;
+
+  // assign tid to new thread
   static atomic_uint tids;
-  sp = (intptr_t)stk + stksz;
+  unsigned tid = atomic_fetch_add_explicit(&tids, 1, memory_order_relaxed);
+  tid %= kMaxThreadIds;
+  tid += kMinThreadId;
+  atomic_init(ctid, tid);
+  atomic_init(ptid, tid);
+
+  // pass temp data on stack
+  intptr_t sp, tip;
+  struct CloneArgs *wt;
+  sp = tip = (intptr_t)stk + stksz;
   sp -= sizeof(struct CloneArgs);
   sp &= -alignof(struct CloneArgs);
   wt = (struct CloneArgs *)sp;
-  sp = AlignStack(sp, stk, stksz, 16);
-  tid = atomic_fetch_add_explicit(&tids, 1, memory_order_acq_rel);
-  wt->this = tid = (tid & (kMaxThreadIds - 1)) + kMinThreadId;
-  wt->ctid = flags & CLONE_CHILD_SETTID ? ctid : &wt->tid;
-  wt->ztid = flags & CLONE_CHILD_CLEARTID ? ctid : &wt->tid;
-  wt->tls = flags & CLONE_SETTLS ? tls : 0;
   wt->func = fn;
   wt->arg = arg;
-  wt->sp = sp;
-  babystack = __syslib->__pthread_stack_min;
+  wt->tls = tls;
+  wt->ctid = ctid;
+  wt->sp = tip & -16;
+
+  // ask apple libc to spawn thread
+  errno_t res;
+  pthread_t th;
+  size_t babystack = __syslib->__pthread_stack_min;
 #pragma GCC push_options
 #pragma GCC diagnostic ignored "-Walloca-larger-than="
-  attr = alloca(__syslib->__sizeof_pthread_attr_t);
+  void *attr = alloca(__syslib->__sizeof_pthread_attr_t);
 #pragma GCC pop_options
-  unassert(!__syslib->__pthread_attr_init(attr));
-  unassert(!__syslib->__pthread_attr_setguardsize(attr, 0));
-  unassert(!__syslib->__pthread_attr_setstacksize(attr, babystack));
-  if (!(res = __syslib->__pthread_create(&th, attr, SiliconThreadMain, wt)) &&
-      (flags & CLONE_PARENT_SETTID)) {
-    *ptid = tid;
-    if (flags & CLONE_SETTLS) {
-      struct CosmoTib *tib = tls;
-      atomic_store_explicit(&tib[-1].tib_syshand, th, memory_order_release);
-    }
+  __syslib->__pthread_attr_init(attr);
+  __syslib->__pthread_attr_setguardsize(attr, 0);
+  __syslib->__pthread_attr_setstacksize(attr, babystack);
+  if (!(res = __syslib->__pthread_create(&th, attr, SiliconThreadMain, wt))) {
+    atomic_init(ptid, tid);
+    struct CosmoTib *tib = tls;
+    atomic_store_explicit(&tib[-1].tib_syshand, th, memory_order_release);
   }
-  unassert(!__syslib->__pthread_attr_destroy(attr));
+  __syslib->__pthread_attr_destroy(attr);
   return res;
 }
 
@@ -573,10 +523,9 @@ static errno_t CloneSilicon(int (*fn)(void *, int), char *stk, size_t stksz,
 // GNU/SYSTEMD
 
 struct LinuxCloneArgs {
-  int (*func)(void *, int);
+  int (*func)(void *);
   void *arg;
   char *tls;
-  atomic_int ctid;
 };
 
 int sys_clone_linux(int flags,         // rdi
@@ -587,42 +536,34 @@ int sys_clone_linux(int flags,         // rdi
                     void *func,        // r9
                     void *arg);        // 8(rsp)
 
-static int LinuxThreadEntry(void *arg, int tid) {
+dontinstrument static int AmdLinuxThreadEntry(void *arg) {
   struct LinuxCloneArgs *wt = arg;
+#if defined(__x86_64__)
   sys_set_tls(ARCH_SET_GS, wt->tls);
-  return wt->func(wt->arg, tid);
+#endif
+  return wt->func(wt->arg);
 }
 
-static int CloneLinux(int (*func)(void *arg, int rc), char *stk, size_t stksz,
-                      int flags, void *arg, void *tls, atomic_int *ptid,
+static int CloneLinux(int (*func)(void *), char *stk, size_t stksz, int flags,
+                      void *arg, void *tls, atomic_int *ptid,
                       atomic_int *ctid) {
-  int rc;
-  long sp;
-  struct LinuxCloneArgs *wt;
-  sp = (intptr_t)stk + stksz;
+  long sp = (intptr_t)stk + stksz;
+
+#if defined(__x86_64__)
   sp -= sizeof(struct LinuxCloneArgs);
   sp &= -alignof(struct LinuxCloneArgs);
-  wt = (struct LinuxCloneArgs *)sp;
-  // align the stack
-#ifdef __aarch64__
-  sp = AlignStack(sp, stk, stksz, 128);  // for kernel <=4.6
-#else
-  sp = AlignStack(sp, stk, stksz, 16);
+  struct LinuxCloneArgs *wt = (struct LinuxCloneArgs *)sp;
+  sp &= -16;  // align the stack
+  wt->arg = arg;
+  wt->tls = tls;
+  wt->func = func;
+  func = AmdLinuxThreadEntry;
+  arg = wt;
+#elif defined(__aarch64__)
+  sp &= -128;  // for kernels <=4.6
 #endif
-#ifdef __x86_64__
-  if (flags & CLONE_SETTLS) {
-    flags &= ~CLONE_SETTLS;
-    wt->arg = arg;
-    wt->tls = tls;
-    wt->func = func;
-    func = LinuxThreadEntry;
-    arg = wt;
-  }
-#endif
-  if (~flags & CLONE_CHILD_SETTID) {
-    flags |= CLONE_CHILD_SETTID;
-    ctid = &wt->ctid;
-  }
+
+  int rc;
   if ((rc = sys_clone_linux(flags, sp, ptid, ctid, tls, func, arg)) >= 0) {
     // clone() is documented as setting ptid before return
     return 0;
@@ -635,154 +576,45 @@ static int CloneLinux(int (*func)(void *arg, int rc), char *stk, size_t stksz,
 // COSMOPOLITAN
 
 /**
- * Creates thread without malloc being linked.
+ * Creates thread without malloc() being linked.
  *
- * If you use clone() you're on your own. Example:
- *
- *     int worker(void *arg) { return 0; }
- *     struct CosmoTib tib = {.tib_self = &tib, .tib_tid = -1};
- *     atomic_int tid;
- *     char *stk = NewCosmoStack();
- *     clone(worker, stk, GetStackSize() - 16,
- *           CLONE_VM | CLONE_THREAD | CLONE_FS | CLONE_FILES |
- *           CLONE_SYSVSEM | CLONE_SIGHAND | CLONE_PARENT_SETTID |
- *           CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID | CLONE_SETTLS,
- *           arg, &tid, &tib, &tib.tib_tid);
- *     while (atomic_load(&tid) == 0) sched_yield();
- *     // thread is known
- *     while (atomic_load(&tib.tib_tid) < 0) sched_yield();
- *     // thread is running
- *     while (atomic_load(&tib.tib_tid) > 0) sched_yield();
- *     // thread has terminated
- *     FreeCosmoStack(stk);
- *
- * Threads are created in a detached manner. They currently can't be
- * synchronized using wait() or posix signals. Threads created by this
- * function should be synchronized using shared memory operations.
- *
- * Any memory that's required by this system call wrapper is allocated
- * to the top of your stack. This shouldn't be more than 128 bytes.
- *
- * Your function is called from within the stack you specify. A return
- * address is pushed onto your stack, that causes returning to jump to
- * _Exit1() which terminates the thread. Even though the callback says
- * it supports a return code, that'll only work on Linux and Windows.
- *
- * This function follows the same ABI convention as the Linux userspace
- * libraries, with a few small changes. The varargs has been removed to
- * help prevent broken code, and the stack size and tls size parameters
- * are introduced for compatibility with FreeBSD.
- *
- * To keep this system call lightweight, only the thread creation use
- * case is polyfilled across platforms. For example, if you want fork
- * that works on OpenBSD for example, don't do it with clone(SIGCHLD)
- * and please just call fork(). Even if you do that on Linux, it will
- * effectively work around libc features like atfork(), so that means
- * other calls like getpid() may return incorrect values.
- *
- * @param func is your callback function, which this wrapper requires
- *     not be null, otherwise EINVAL is raised. It is passed two args
- *     within the child thread: (1) the caller-supplied `arg` and (2)
- *     the new tid is always passed in the second arg for convenience
- *
- * @param stk points to the bottom of a caller allocated stack, which
- *     must be allocated via mmap() using the MAP_STACK flag, or else
- *     you won't get optimal performance and it won't work on OpenBSD
- *
- * @param stksz is the size of that stack in bytes, we recommend that
- *     that this be set to GetStackSize() or else memory safety tools
- *     like kprintf() can't do as good and quick of a job; this value
- *     must be 16-aligned plus it must be at least 4192 bytes in size
- *     and it's advised to have the bottom-most page, be a guard page
- *
- * @param flags which SHOULD always have all of these flags:
- *
- *     - `CLONE_THREAD`
- *     - `CLONE_VM`
- *     - `CLONE_FS`
- *     - `CLONE_FILES`
- *     - `CLONE_SIGHAND`
- *     - `CLONE_SYSVSEM`
- *
- *     This system call wrapper is intended for threads, and as such, we
- *     won't polyfill Linux's ability to simulate unrelated calls (e.g.
- *     fork, vfork) via clone() on other platforms. Please just call
- *     fork() and vfork() when that's what you want.
- *
- *     Your `flags` may also optionally also additionally bitwise-OR any
- *     combination of the following additional flags:
- *
- *     - `CLONE_CHILD_SETTID` must be specified if you intend to set the
- *       `ctid` argument, which will updated with the child tid once the
- *       child has started.
- *
- *     - `CLONE_PARENT_SETTID` must be specified if you intend to set
- *       the `ptid` argument, and it is updated at the most opportune
- *       moment. On all platforms except XNU x86, this happens before
- *       clone() returns. But since it might not be available yet you
- *       need to use pthread_getunique_np() to obtain it.
- *
- *     - `CLONE_CHILD_CLEARTID` causes `*ctid = 0` upon child thread
- *       termination. This is used to implement join so that the parent
- *       may know when it's safe to free the child's stack memory, and
- *       as such, is guaranteed to happen AFTER the child thread has
- *       either terminated or has finished using its stack memory
- *
- *     - `CLONE_SETTLS` is needed if you intend to specify the `tls`
- *       argument, which after thread creation may be accessed using
- *       __get_tls(). Doing this means that `errno`, gettid(), etc.
- *       correctly work. Caveat emptor if you choose not to do this.
- *
- * @param arg is passed as an argument to `func` in the child thread
- * @param tls may be used to set the thread local storage segment;
- *     this parameter is ignored if `CLONE_SETTLS` is not set
- * @param ctid lets the child receive its thread id without having to
- *     call gettid() and is ignored if `CLONE_CHILD_SETTID` isn't set
- * @return 0 on success, or errno on errno
+ * If you use clone() you're on your own.
  */
 errno_t clone(void *func, void *stk, size_t stksz, int flags, void *arg,
               void *ptid, void *tls, void *ctid) {
-  int rc;
+  errno_t err;
 
-  if (flags & CLONE_THREAD) {
-    __enable_threads();
-  }
+  atomic_fetch_add(&_pthread_count, 1);
 
-  if (!func) {
-    rc = EINVAL;
-  } else if (IsLinux()) {
-    rc = CloneLinux(func, stk, stksz, flags, arg, tls, ptid, ctid);
-  } else if (!IsTiny() &&
-             (flags & ~(CLONE_SETTLS | CLONE_PARENT_SETTID |
-                        CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID)) !=
-                 (CLONE_THREAD | CLONE_VM | CLONE_FS | CLONE_FILES |
-                  CLONE_SIGHAND | CLONE_SYSVSEM)) {
-    rc = EINVAL;
+  if (IsLinux()) {
+    err = CloneLinux(func, stk, stksz, flags, arg, tls, ptid, ctid);
   } else if (IsXnu()) {
-#ifdef __x86_64__
-    rc = CloneXnu(func, stk, stksz, flags, arg, tls, ptid, ctid);
+#if defined(__x86_64__)
+    err = CloneXnu(func, stk, stksz, arg, tls, ptid, ctid);
 #elif defined(__aarch64__)
-    rc = CloneSilicon(func, stk, stksz, flags, arg, tls, ptid, ctid);
+    err = CloneSilicon(func, stk, stksz, arg, tls, ptid, ctid);
 #else
 #error "unsupported architecture"
 #endif
   } else if (IsFreebsd()) {
-    rc = CloneFreebsd(func, stk, stksz, flags, arg, tls, ptid, ctid);
-#ifdef __x86_64__
-  } else if (IsNetbsd()) {
-    rc = CloneNetbsd(func, stk, stksz, flags, arg, tls, ptid, ctid);
-  } else if (IsOpenbsd()) {
-    rc = CloneOpenbsd(func, stk, stksz, flags, arg, tls, ptid, ctid);
+    err = CloneFreebsd(func, stk, stksz, arg, tls, ptid, ctid);
+#if defined(__x86_64__)
   } else if (IsWindows()) {
-    rc = CloneWindows(func, stk, stksz, flags, arg, tls, ptid, ctid);
+    err = CloneWindows(func, stk, stksz, arg, tls, ptid, ctid);
+  } else if (IsNetbsd()) {
+    err = CloneNetbsd(func, stk, stksz, arg, tls, ptid, ctid);
+  } else if (IsOpenbsd()) {
+    err = CloneOpenbsd(func, stk, stksz, arg, tls, ptid, ctid);
 #endif /* __x86_64__ */
   } else {
-    rc = ENOSYS;
+    err = ENOSYS;
   }
 
-  if (SupportsBsd() && rc == EPROCLIM) {
-    rc = EAGAIN;
-  }
+  if (SupportsBsd() && err == EPROCLIM)
+    err = EAGAIN;
 
-  return rc;
+  if (err)
+    atomic_fetch_sub(&_pthread_count, 1);
+
+  return err;
 }
diff --git a/libc/runtime/cosmo.S b/libc/runtime/cosmo.S
index fcaa2376e..59fe944c1 100644
--- a/libc/runtime/cosmo.S
+++ b/libc/runtime/cosmo.S
@@ -16,10 +16,10 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/map.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/dce.h"
 #ifdef __x86_64__
@@ -32,8 +32,8 @@
 //	@param	rdx is environ
 //	@param	rcx is auxv
 //	@noreturn
-cosmo:	push	%rbp
-	mov	%rsp,%rbp
+cosmo:	beg
+	pro
 	mov	%edi,%r12d
 	mov	%rsi,%r13
 	mov	%rdx,%r14
@@ -45,7 +45,7 @@ cosmo:	push	%rbp
 #endif /* SYSDEBUG */
 
 #ifndef NOX87
-//	Windows always initializes FPU to douuble precision.
+//	Windows always initializes FPU to double precision.
 //	WSL breaks Linux ABI by initializing FPU to double precision.
 //	This code makes long double long again.
 //
@@ -104,7 +104,10 @@ cosmo:	push	%rbp
 	je	2f
 	push	%rax
 	push	%rax
-	call	.Largs
+	mov	%r12d,%edi
+	mov	%r13,%rsi
+	mov	%r14,%rdx
+	mov	%r15,%rcx
 	call	*(%rax)
 	pop	%rax
 	pop	%rax
@@ -112,17 +115,15 @@ cosmo:	push	%rbp
 	jmp	1b
 
 //	call main()
-2:	call	.Largs
+2:	mov	%r12d,%edi
+	mov	%r13,%rsi
+	mov	%r14,%rdx
+	mov	%r15,%rcx
 	.weak	main
 	call	main
 	xchg	%eax,%edi
 	call	exit
-
-.Largs:	mov	%r12d,%edi
-	mov	%r13,%rsi
-	mov	%r14,%rdx
-	mov	%r15,%rcx
-	ret
+	end
 	.endfn	cosmo,weak
 
 //	Enables Thread Local Storage.
diff --git a/libc/runtime/cosmo2.c b/libc/runtime/cosmo2.c
index 8d962a9a6..a218af579 100644
--- a/libc/runtime/cosmo2.c
+++ b/libc/runtime/cosmo2.c
@@ -22,9 +22,9 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/maps.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/memtrack.internal.h"
@@ -66,6 +66,8 @@ extern char ape_stack_prot[] __attribute__((__weak__));
 extern pthread_mutex_t __mmi_lock_obj;
 extern int hostos asm("__hostos");
 
+void __pagesize_init(unsigned long *auxv);
+
 static const char *DecodeMagnum(const char *p, long *r) {
   int k = 0;
   unsigned long c, x = 0;
@@ -91,7 +93,8 @@ wontreturn textstartup void cosmo(long *sp, struct Syslib *m1, char *exename,
       .tib_sigmask = -1,
       .tib_sigstack_size = 57344,
       .tib_sigstack_addr = (char *)__builtin_frame_address(0) - 57344,
-      .tib_tid = 1,
+      .tib_ptid = 1,
+      .tib_ctid = 1,
   };
   __set_tls(&tib);
 
@@ -164,6 +167,7 @@ wontreturn textstartup void cosmo(long *sp, struct Syslib *m1, char *exename,
   __pid = sys_getpid().ax;
 
   // initialize file system
+  __pagesize_init(auxv);
   __maps_init();
   __init_fds(argc, argv, envp);
 
@@ -172,13 +176,6 @@ wontreturn textstartup void cosmo(long *sp, struct Syslib *m1, char *exename,
 
   __enable_tls();
 
-#if 0
-#if IsAsan()
-  // TODO(jart): Figure out ASAN data model on AARCH64.
-  __asan_init(argc, argv, envp, auxv);
-#endif
-#endif
-
   _init();
   // initialize program
 #if SYSDEBUG
diff --git a/libc/runtime/cxa_thread_atexit.c b/libc/runtime/cxa_thread_atexit.c
index 9d8eaa3f1..57ce06849 100644
--- a/libc/runtime/cxa_thread_atexit.c
+++ b/libc/runtime/cxa_thread_atexit.c
@@ -16,13 +16,13 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/cxaatexit.internal.h"
+#include "libc/intrin/cxaatexit.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/gc.internal.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/tls.h"
-#include "third_party/nsync/wait_s.internal.h"
 
 struct Dtor {
   void *fun;
@@ -30,8 +30,6 @@ struct Dtor {
   struct Dtor *next;
 };
 
-static _Thread_local struct Dtor *__cxa_thread_atexit_list;
-
 static void _pthread_unwind(struct CosmoTib *tib) {
   struct PosixThread *pt;
   struct _pthread_cleanup_buffer *cb;
@@ -42,24 +40,24 @@ static void _pthread_unwind(struct CosmoTib *tib) {
   }
 }
 
-static void __cxa_thread_unkey(struct CosmoTib *tib) {
-  void *val;
-  int i, j, gotsome;
-  pthread_key_dtor dtor;
-  for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; ++j) {
-    for (gotsome = i = 0; i < PTHREAD_KEYS_MAX; ++i) {
-      if ((val = tib->tib_keys[i]) &&
-          (dtor = atomic_load_explicit(_pthread_key_dtor + i,
-                                       memory_order_relaxed)) &&
-          dtor != (pthread_key_dtor)-1) {
-        gotsome = 1;
-        tib->tib_keys[i] = 0;
+static void _pthread_unkey(struct CosmoTib *tib) {
+  for (int j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; ++j) {
+    bool gotsome = false;
+    for (int i = 0; i < PTHREAD_KEYS_MAX; ++i) {
+      void *val;
+      pthread_key_dtor dtor;
+      if ((dtor = atomic_load_explicit(&_pthread_key_dtor[i],
+                                       memory_order_acquire)) &&
+          dtor != (pthread_key_dtor)-1 &&
+          (val = atomic_exchange_explicit(&tib->tib_keys[i], 0,
+                                          memory_order_relaxed))) {
+        STRACE("_pthread_unkey(%t, %p)", dtor, val);
+        gotsome = true;
         dtor(val);
       }
     }
-    if (!gotsome) {
+    if (!gotsome)
       break;
-    }
   }
 }
 
@@ -67,11 +65,12 @@ static void _pthread_ungarbage(struct CosmoTib *tib) {
   struct Garbages *g;
   while ((g = tib->tib_garbages)) {
     tib->tib_garbages = 0;
-    while (g->i--) {
+    while (g->i--)
       ((void (*)(intptr_t))g->p[g->i].fn)(g->p[g->i].arg);
+    if (_weaken(free)) {
+      _weaken(free)(g->p);
+      _weaken(free)(g);
     }
-    _weaken(free)(g->p);
-    _weaken(free)(g);
   }
 }
 
@@ -79,13 +78,22 @@ void __cxa_thread_finalize(void) {
   struct Dtor *dtor;
   struct CosmoTib *tib;
   tib = __get_tls();
+
+  // "Any cancellation cleanup handlers that have been pushed and not
+  //  yet popped shall be popped in the reverse order that they were
+  //  pushed and then executed." ──Quoth POSIX.1-2017
   _pthread_unwind(tib);
-  if (tib->tib_nsync)
-    _weaken(nsync_waiter_destroy)(tib->tib_nsync);
-  __cxa_thread_unkey(tib);
+
+  // "After all cancellation cleanup handlers have been executed, if the
+  //  thread has any thread-specific data, appropriate destructor
+  //  functions shall be called in an unspecified order."
+  //                              ──Quoth POSIX.1-2017
+  _pthread_unkey(tib);
   _pthread_ungarbage(tib);
-  while ((dtor = __cxa_thread_atexit_list)) {
-    __cxa_thread_atexit_list = dtor->next;
+
+  while ((dtor = tib->tib_atexit)) {
+    STRACE("__cxa_finalize(%t, %p)", dtor->fun, dtor->arg);
+    tib->tib_atexit = dtor->next;
     ((void (*)(void *))dtor->fun)(dtor->arg);
     _weaken(free)(dtor);
   }
@@ -97,9 +105,11 @@ int __cxa_thread_atexit_impl(void *fun, void *arg, void *dso_symbol) {
     return -1;
   if (!(dtor = _weaken(malloc)(sizeof(struct Dtor))))
     return -1;
+  struct CosmoTib *tib;
+  tib = __get_tls();
   dtor->fun = fun;
   dtor->arg = arg;
-  dtor->next = __cxa_thread_atexit_list;
-  __cxa_thread_atexit_list = dtor;
+  dtor->next = tib->tib_atexit;
+  tib->tib_atexit = dtor;
   return 0;
 }
diff --git a/libc/runtime/efimain.greg.c b/libc/runtime/efimain.greg.c
index 4ecda0eca..33aefcb21 100644
--- a/libc/runtime/efimain.greg.c
+++ b/libc/runtime/efimain.greg.c
@@ -21,7 +21,7 @@
 #include "libc/dce.h"
 #include "libc/intrin/newbie.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/efi.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/runtime/e820.internal.h"
diff --git a/libc/runtime/efipostboot.S b/libc/runtime/efipostboot.S
index 4a2f715de..6b3561562 100644
--- a/libc/runtime/efipostboot.S
+++ b/libc/runtime/efipostboot.S
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "ape/relocations.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/pc.internal.h"
 .real
 
diff --git a/libc/runtime/enable_tls.c b/libc/runtime/enable_tls.c
index ccc662568..0296e6fda 100644
--- a/libc/runtime/enable_tls.c
+++ b/libc/runtime/enable_tls.c
@@ -22,10 +22,11 @@
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/getenv.internal.h"
+#include "libc/intrin/getenv.h"
 #include "libc/intrin/kprintf.h"
+#include "libc/intrin/maps.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/files.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
@@ -34,9 +35,12 @@
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/syslib.internal.h"
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #include "libc/str/locale.h"
+#include "libc/str/locale.internal.h"
 #include "libc/str/str.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
@@ -138,24 +142,23 @@ textstartup void __enable_tls(void) {
   size_t siz = ROUNDUP(I(_tls_size) + sizeof(struct CosmoTib), TLS_ALIGNMENT);
   if (siz <= sizeof(__static_tls)) {
     // if tls requirement is small then use the static tls block
-    // which helps avoid a system call for appes with little tls
+    // which helps avoid a system call for apes with little tls.
     // this is crucial to keeping life.com 16 kilobytes in size!
     mem = __static_tls;
   } else {
-    // if this binary needs a hefty tls block then we'll bank on
-    // malloc() being linked, which links _mapanon().  otherwise
-    // if you exceed this, you need to __static_yoink("_mapanon").
-    // please note that it's probably too early to call calloc()
-    mem = _weaken(_mapanon)(siz);
+    // if a binary needs this much thread_local storage, then it
+    // surely must have linked the mmap() function at some point
+    // we can't call mmap() because it's too early for sig block
+    mem = _weaken(mmap)(0, siz, PROT_READ | PROT_WRITE,
+                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   }
 
   struct CosmoTib *tib = (struct CosmoTib *)(mem + siz - sizeof(*tib));
   char *tls = mem + siz - sizeof(*tib) - I(_tls_size);
 
   // copy in initialized data section
-  if (I(_tdata_size)) {
+  if (I(_tdata_size))
     memcpy(tls, _tdata_start, I(_tdata_size));
-  }
 
 #elif defined(__aarch64__)
 
@@ -166,9 +169,16 @@ textstartup void __enable_tls(void) {
 
   char *mem;
   if (I(_tls_align) <= TLS_ALIGNMENT && size <= sizeof(__static_tls)) {
+    // if tls requirement is small then use the static tls block
+    // which helps avoid a system call for apes with little tls.
+    // this is crucial to keeping life.com 16 kilobytes in size!
     mem = __static_tls;
   } else {
-    mem = _weaken(_mapanon)(size);
+    // if a binary needs this much thread_local storage, then it
+    // surely must have linked the mmap() function at some point
+    // we can't call mmap() because it's too early for sig block
+    mem = _weaken(mmap)(0, size, PROT_READ | PROT_WRITE,
+                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   }
 
   struct CosmoTib *tib =
@@ -180,9 +190,8 @@ textstartup void __enable_tls(void) {
   size_t dtv_size = sizeof(uintptr_t) * 2;
 
   char *tdata = (char *)dtv + ROUNDUP(dtv_size, I(_tdata_align));
-  if (I(_tdata_size)) {
+  if (I(_tdata_size))
     memmove(tdata, _tdata_start, I(_tdata_size));
-  }
 
   // Set the DTV.
   //
@@ -205,14 +214,13 @@ textstartup void __enable_tls(void) {
   tib->tib_errno = __errno;
   tib->tib_strace = __strace;
   tib->tib_ftrace = __ftrace;
-  tib->tib_locale = (intptr_t)&__c_dot_utf8_locale;
   tib->tib_pthread = (pthread_t)&_pthread_static;
   if (IsWindows()) {
     intptr_t hThread;
     DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
                     GetCurrentProcess(), &hThread, 0, false,
                     kNtDuplicateSameAccess);
-    atomic_store_explicit(&tib->tib_syshand, hThread, memory_order_relaxed);
+    atomic_init(&tib->tib_syshand, hThread);
   } else if (IsXnuSilicon()) {
     tib->tib_syshand = __syslib->__pthread_self();
   }
@@ -225,31 +233,32 @@ textstartup void __enable_tls(void) {
   } else {
     tid = sys_gettid();
   }
-  atomic_store_explicit(&tib->tib_tid, tid, memory_order_relaxed);
+  atomic_init(&tib->tib_ptid, tid);
+  atomic_init(&tib->tib_ctid, tid);
   // TODO(jart): set_tid_address?
 
   // inherit signal mask
-  if (IsWindows()) {
-    atomic_store_explicit(&tib->tib_sigmask,
-                          ParseMask(__getenv(environ, "_MASK").s),
-                          memory_order_relaxed);
-  }
+  if (IsWindows())
+    atomic_init(&tib->tib_sigmask, ParseMask(__getenv(environ, "_MASK").s));
 
   // initialize posix threads
   _pthread_static.tib = tib;
   _pthread_static.pt_flags = PT_STATIC;
+  _pthread_static.pt_locale = &__global_locale;
+  _pthread_static.pt_attr.__stackaddr = __maps.stack.addr;
+  _pthread_static.pt_attr.__stacksize = __maps.stack.size;
   dll_init(&_pthread_static.list);
   _pthread_list = &_pthread_static.list;
-  atomic_store_explicit(&_pthread_static.ptid, tid, memory_order_release);
 
   // ask the operating system to change the x86 segment register
+  if (IsWindows())
+    __tls_index = TlsAlloc();
   __set_tls(tib);
 
 #ifdef __x86_64__
   // rewrite the executable tls opcodes in memory
-  if (IsWindows() || IsOpenbsd() || IsNetbsd()) {
+  if (IsWindows() || IsOpenbsd() || IsNetbsd())
     __morph_tls();
-  }
 #endif
 
   // we are now allowed to use tls
diff --git a/libc/runtime/exit.c b/libc/runtime/exit.c
index 33456c7fe..6320d4323 100644
--- a/libc/runtime/exit.c
+++ b/libc/runtime/exit.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/cxxabi.h"
-#include "libc/intrin/cxaatexit.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/cxaatexit.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/runtime/internal.h"
 
diff --git a/libc/runtime/findcombinary.c b/libc/runtime/findcombinary.c
index 4c0084456..bc2214f8b 100644
--- a/libc/runtime/findcombinary.c
+++ b/libc/runtime/findcombinary.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/auxv.h"
diff --git a/libc/runtime/fpreset.S b/libc/runtime/fpreset.S
index 1a130ae18..ec817a942 100644
--- a/libc/runtime/fpreset.S
+++ b/libc/runtime/fpreset.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Re-initializes FPU.
 	.ftrace1
diff --git a/libc/runtime/ftrace-hook.S b/libc/runtime/ftrace-hook.S
index 9340d7f73..cd25a18c4 100644
--- a/libc/runtime/ftrace-hook.S
+++ b/libc/runtime/ftrace-hook.S
@@ -16,44 +16,59 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .privileged
 
 ftrace_hook:
 #ifdef __x86_64__
 
-//	We need to save saved registers because we have some functions
-//	like __errno_location which can be called from an inline asm()
-//	statement. It's nice to have the flexibility anyway.
+//	save argument registers
+//	we save %rax because __gc() takes it as an argument.
+//	we save %r10 because it's used as a syscall argument.
 
 	cmpl	$0,__ftrace(%rip)
 	jle	1f
+	.cfi_startproc
 	push	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset %rbp, -16
 	mov	%rsp,%rbp
+	.cfi_def_cfa_register %rbp
 	and	$-16,%rsp
-	sub	$256,%rsp
+	sub	$128,%rsp
+	movdqu	%xmm0,-0x80(%rbp)
+	movdqu	%xmm1,-0x70(%rbp)
+	movdqu	%xmm2,-0x60(%rbp)
+	movdqu	%xmm3,-0x50(%rbp)
+	movdqu	%xmm4,-0x40(%rbp)
+	movdqu	%xmm5,-0x30(%rbp)
+	movdqu	%xmm6,-0x20(%rbp)
+	movdqu	%xmm7,-0x10(%rbp)
 	push	%rax
-	push	%rbx
+	.cfi_offset %rax, -24
 	push	%rcx
+	.cfi_offset %rcx, -32
 	push	%rdx
+	.cfi_offset %rdx, -40
 	push	%rdi
+	.cfi_offset %rdi, -48
 	push	%rsi
+	.cfi_offset %rsi, -56
 	push	%r8
+	.cfi_offset %r8, -64
 	push	%r9
+	.cfi_offset %r9, -72
 	push	%r10
-	push	%r11
-	push	%r12
-	push	%r13
-	push	%r14
-	push	%r15
-	call	__xmm_save
+	.cfi_offset %r10, -80
 	call	ftracer
-	call	__xmm_load
-	pop	%r15
-	pop	%r14
-	pop	%r13
-	pop	%r12
-	pop	%r11
+	movdqu	-0x80(%rbp),%xmm0
+	movdqu	-0x70(%rbp),%xmm1
+	movdqu	-0x60(%rbp),%xmm2
+	movdqu	-0x50(%rbp),%xmm3
+	movdqu	-0x40(%rbp),%xmm4
+	movdqu	-0x30(%rbp),%xmm5
+	movdqu	-0x20(%rbp),%xmm6
+	movdqu	-0x10(%rbp),%xmm7
 	pop	%r10
 	pop	%r9
 	pop	%r8
@@ -61,15 +76,22 @@ ftrace_hook:
 	pop	%rdi
 	pop	%rdx
 	pop	%rcx
-	pop	%rbx
 	pop	%rax
 	leave
+	.cfi_restore %rbp
+	.cfi_def_cfa %rsp, 8
 1:	ret
+	.cfi_endproc
 
 #elif defined(__aarch64__)
 
 	stp	x29,x30,[sp,-384]!
+	.cfi_startproc
+	.cfi_def_cfa_offset 384
+	.cfi_offset 29, -384	// x29 (fp) is saved at [sp - 384]
+	.cfi_offset 30, -376	// x30 (lr) is saved at [sp - 376]
 	mov	x29,sp
+	.cfi_def_cfa_register 29
 	stp	x0,x1,[sp,16]
 
 	adrp	x0,__ftrace
@@ -78,18 +100,45 @@ ftrace_hook:
 	ble	1f
 
 	stp	x2,x3,[sp,32]
+	.cfi_offset 2, -352
+	.cfi_offset 3, -344
 	stp	x4,x5,[sp,48]
+	.cfi_offset 4, -336
+	.cfi_offset 5, -328
 	stp	x6,x7,[sp,64]
+	.cfi_offset 6, -320
+	.cfi_offset 7, -312
 	stp	x8,x9,[sp,80]
+	.cfi_offset 8, -304
+	.cfi_offset 9, -296
 	stp	x10,x11,[sp,96]
+	.cfi_offset 10, -288
+	.cfi_offset 11, -280
 	stp	x12,x13,[sp,112]
+	.cfi_offset 12, -272
+	.cfi_offset 13, -264
 	stp	x14,x15,[sp,128]
+	.cfi_offset 14, -256
+	.cfi_offset 15, -248
 	stp	x16,x19,[sp,160]
+	.cfi_offset 16, -224
+	.cfi_offset 19, -216
 	stp	x20,x21,[sp,176]
+	.cfi_offset 20, -208
+	.cfi_offset 21, -200
 	stp	x22,x23,[sp,192]
+	.cfi_offset 22, -192
+	.cfi_offset 23, -184
 	stp	x24,x25,[sp,208]
+	.cfi_offset 24, -176
+	.cfi_offset 25, -168
 	stp	x26,x27,[sp,224]
+	.cfi_offset 26, -160
+	.cfi_offset 27, -152
 	stp	x17,x28,[sp,240]
+	.cfi_offset 17, -144
+	.cfi_offset 28, -136
+	// No CFI directives needed for FP registers
 	stp	q0,q1,[sp,256]
 	stp	q2,q3,[sp,288]
 	stp	q4,q5,[sp,320]
@@ -117,7 +166,12 @@ ftrace_hook:
 
 1:	ldp	x0,x1,[sp,16]
 	ldp	x29,x30,[sp],384
+	.cfi_restore 29
+	.cfi_restore 30
+	.cfi_def_cfa 7, 0	// On some ARM systems the stack pointer is represented by register 7
+	.cfi_def_cfa_offset 0
 	ret
+	.cfi_endproc
 
 #endif /* __x86_64__ */
 	.endfn	ftrace_hook,globl,hidden
diff --git a/libc/runtime/ftraceinit.greg.c b/libc/runtime/ftraceinit.greg.c
index f0f4a1e48..0f18fcf68 100644
--- a/libc/runtime/ftraceinit.greg.c
+++ b/libc/runtime/ftraceinit.greg.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/dce.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
@@ -37,7 +38,7 @@ __static_yoink("zipos");
  * @see libc/runtime/_init.S for documentation
  */
 textstartup int ftrace_init(void) {
-  if (strace_enabled(0) > 0) {
+  if (IsModeDbg() || strace_enabled(0) > 0) {
     GetSymbolTable();
   }
   if (__intercept_flag(&__argc, __argv, "--ftrace")) {
diff --git a/libc/runtime/ftracer.c b/libc/runtime/ftracer.c
index d2e686d3b..56f4d53f9 100644
--- a/libc/runtime/ftracer.c
+++ b/libc/runtime/ftracer.c
@@ -21,7 +21,7 @@
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/cmpxchg.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/stackframe.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
@@ -29,14 +29,9 @@
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
-#include "libc/thread/tls2.internal.h"
 
 /**
- * @fileoverview Plain-text function call logging.
- *
- * Able to log ~2 million function calls per second, which is mostly
- * bottlenecked by system call overhead. Log size is reasonable if piped
- * into gzip.
+ * @fileoverview plain-text function call logging
  */
 
 #define MAX_NESTING 512
@@ -50,7 +45,7 @@
 static struct CosmoFtrace g_ftrace;
 
 __funline int GetNestingLevelImpl(struct StackFrame *frame) {
-  int nesting = -2;
+  int nesting = -1;
   while (frame && !kisdangerous(frame)) {
     ++nesting;
     frame = frame->next;
@@ -83,38 +78,63 @@ privileged void ftracer(void) {
   struct StackFrame *sf;
   struct CosmoFtrace *ft;
   struct PosixThread *pt;
+
+  // get interesting values
   sf = __builtin_frame_address(0);
   st = (uintptr_t)__argv - sizeof(uintptr_t);
   if (__ftrace <= 0)
     return;
+
+  // determine top of stack
+  // main thread won't consider kernel provided argblock
   if (__tls_enabled) {
     tib = __get_tls_privileged();
     if (tib->tib_ftrace <= 0)
       return;
     ft = &tib->tib_ftracer;
-    if ((char *)sf >= tib->tib_sigstack_addr &&
-        (char *)sf <= tib->tib_sigstack_addr + tib->tib_sigstack_size) {
-      st = (uintptr_t)tib->tib_sigstack_addr + tib->tib_sigstack_size;
-    } else if ((pt = (struct PosixThread *)tib->tib_pthread) &&
-               pt->pt_attr.__stacksize) {
-      st = (uintptr_t)pt->pt_attr.__stackaddr + pt->pt_attr.__stacksize;
+    pt = (struct PosixThread *)tib->tib_pthread;
+    if (pt != &_pthread_static) {
+      if ((char *)sf >= tib->tib_sigstack_addr &&
+          (char *)sf <= tib->tib_sigstack_addr + tib->tib_sigstack_size) {
+        st = (uintptr_t)tib->tib_sigstack_addr + tib->tib_sigstack_size;
+      } else if (pt && pt->pt_attr.__stacksize) {
+        st = (uintptr_t)pt->pt_attr.__stackaddr + pt->pt_attr.__stacksize;
+      }
     }
   } else {
     ft = &g_ftrace;
   }
-  stackuse = st - (intptr_t)sf;
-  if (_cmpxchg(&ft->ft_once, false, true)) {
+
+  // estimate stack pointer of hooked function
+  uintptr_t usp = (uintptr_t)sf;
+  usp += sizeof(struct StackFrame);  // overhead of this function
+#if defined(__x86_64__)
+  usp += 8;       // ftrace_hook() stack aligning
+  usp += 8 * 8;   // ftrace_hook() pushed 8x regs
+  usp += 8 * 16;  // ftrace_hook() pushed 8x xmms
+#elif defined(__aarch64__)
+  usp += 384;  // overhead of ftrace_hook()
+#else
+#error "unsupported architecture"
+#endif
+
+  // determine how much stack hooked function is using
+  stackuse = st - usp;
+
+  // log function call
+  //
+  //     FUN $PID $TID $STARTNANOS $STACKUSE $SYMBOL
+  //
+  if (!ft->ft_once) {
     ft->ft_lastaddr = -1;
     ft->ft_skew = GetNestingLevelImpl(sf);
+    ft->ft_once = true;
   }
-  if (_cmpxchg(&ft->ft_noreentry, false, true)) {
-    sf = sf->next;
-    fn = sf->addr + DETOUR_SKEW;
-    if (fn != ft->ft_lastaddr) {
-      kprintf("%rFUN %6P %6H %'18T %'*ld %*s%t\n", ftrace_stackdigs, stackuse,
-              GetNestingLevel(ft, sf) * 2, "", fn);
-      ft->ft_lastaddr = fn;
-    }
-    ft->ft_noreentry = false;
+  sf = sf->next;
+  fn = sf->addr + DETOUR_SKEW;
+  if (fn != ft->ft_lastaddr) {
+    kprintf("%rFUN %6P %6H %'18T %'*ld %*s%t\n", ftrace_stackdigs, stackuse,
+            GetNestingLevel(ft, sf) * 2, "", fn);
+    ft->ft_lastaddr = fn;
   }
 }
diff --git a/libc/runtime/getargmax.c b/libc/runtime/getargmax.c
index 37ce64c83..a94a3fa7c 100644
--- a/libc/runtime/getargmax.c
+++ b/libc/runtime/getargmax.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/sysparam.h"
 #include "libc/sysv/consts/_posix.h"
diff --git a/libc/runtime/getavphyspages.c b/libc/runtime/getavphyspages.c
index 326666fa5..fc88bfa15 100644
--- a/libc/runtime/getavphyspages.c
+++ b/libc/runtime/getavphyspages.c
@@ -23,5 +23,5 @@ long __get_avphys_pages(void) {
   struct sysinfo si;
   if (sysinfo(&si) == -1)
     return -1;
-  return (((int64_t)si.freeram + si.bufferram) * si.mem_unit) / __granularity();
+  return (((int64_t)si.freeram + si.bufferram) * si.mem_unit) / __pagesize;
 }
diff --git a/libc/runtime/getinterpreterexecutablename.c b/libc/runtime/getinterpreterexecutablename.c
index 6a93514d0..ba4069ccb 100644
--- a/libc/runtime/getinterpreterexecutablename.c
+++ b/libc/runtime/getinterpreterexecutablename.c
@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/at.h"
diff --git a/libc/runtime/getlogin.c b/libc/runtime/getlogin.c
index a62748cfa..72f92bbb6 100644
--- a/libc/runtime/getlogin.c
+++ b/libc/runtime/getlogin.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/nt/accounting.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
diff --git a/libc/runtime/getlogin_r.c b/libc/runtime/getlogin_r.c
index 197929644..53950be9a 100644
--- a/libc/runtime/getlogin_r.c
+++ b/libc/runtime/getlogin_r.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/nt/accounting.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
diff --git a/libc/runtime/getphyspages.c b/libc/runtime/getphyspages.c
index 9f6dd35ea..e732eafca 100644
--- a/libc/runtime/getphyspages.c
+++ b/libc/runtime/getphyspages.c
@@ -23,5 +23,5 @@ long __get_phys_pages(void) {
   struct sysinfo si;
   if (sysinfo(&si) == -1)
     return -1;
-  return ((int64_t)si.totalram * si.mem_unit) / __granularity();
+  return ((int64_t)si.totalram * si.mem_unit) / __pagesize;
 }
diff --git a/libc/runtime/getresourcelimit.c b/libc/runtime/getresourcelimit.c
index d68b256b3..48e10be8e 100644
--- a/libc/runtime/getresourcelimit.c
+++ b/libc/runtime/getresourcelimit.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/rlimit.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sysv/consts/rlim.h"
 
 long __get_rlimit(int resource) {
diff --git a/libc/runtime/getsymbol.c b/libc/runtime/getsymbol.c
index 855e13611..e7ced6883 100644
--- a/libc/runtime/getsymbol.c
+++ b/libc/runtime/getsymbol.c
@@ -33,24 +33,22 @@ privileged int __get_symbol(struct SymbolTable *t, intptr_t a) {
   // we don't want function tracing because:
   //   function tracing depends on this function via kprintf
   unsigned l, m, r, n, k;
-  if (!t && __symtab) {
+  if (!t && __symtab)
     t = __symtab;
-  }
   if (t) {
     l = 0;
     r = n = t->count;
     k = a - t->addr_base;
     while (l < r) {
       m = (l & r) + ((l ^ r) >> 1);  // floor((a+b)/2)
-      if (t->symbols[m].y < k) {
+      if (k < t->symbols[m].x) {
+        r = m;
+      } else if (k > t->symbols[m].y) {
         l = m + 1;
       } else {
-        r = m;
+        return m;
       }
     }
-    if (l < n && t->symbols[l].x <= k && k <= t->symbols[l].y) {
-      return l;
-    }
   }
   return -1;
 }
diff --git a/libc/runtime/getsymboltable.c b/libc/runtime/getsymboltable.c
index 9010c9a37..3ee47d5a3 100644
--- a/libc/runtime/getsymboltable.c
+++ b/libc/runtime/getsymboltable.c
@@ -17,24 +17,24 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/atomic.h"
+#include "libc/cosmo.h"
 #include "libc/errno.h"
-#include "libc/intrin/promises.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/promises.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/str/str.h"
-#include "libc/thread/thread.h"
 #include "libc/x/x.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "third_party/puff/puff.h"
 
 __static_yoink("__get_symbol");
 
-static pthread_spinlock_t g_lock;
 struct SymbolTable *__symtab;  // for kprintf
 
 static ssize_t GetZipFile(struct Zipos *zipos, const char *name) {
@@ -56,15 +56,14 @@ static ssize_t GetZipFile(struct Zipos *zipos, const char *name) {
  * @note This code can't depend on dlmalloc()
  */
 static struct SymbolTable *GetSymbolTableFromZip(struct Zipos *zipos) {
+  size_t size;
   ssize_t cf, lf;
-  size_t size, size2;
   struct SymbolTable *res = 0;
   if ((cf = GetZipFile(zipos, ".symtab." _ARCH_NAME)) != -1 ||
       (cf = GetZipFile(zipos, ".symtab")) != -1) {
     lf = GetZipCfileOffset(zipos->map + cf);
     size = GetZipLfileUncompressedSize(zipos->map + lf);
-    size2 = ROUNDUP(size, __granularity());
-    if ((res = _mapanon(size2))) {
+    if ((res = _mapanon(size))) {
       switch (ZIP_LFILE_COMPRESSIONMETHOD(zipos->map + lf)) {
         case kZipCompressionNone:
           memcpy(res, (void *)ZIP_LFILE_CONTENT(zipos->map + lf), size);
@@ -73,12 +72,12 @@ static struct SymbolTable *GetSymbolTableFromZip(struct Zipos *zipos) {
           if (__inflate((void *)res, size,
                         (void *)ZIP_LFILE_CONTENT(zipos->map + lf),
                         GetZipLfileCompressedSize(zipos->map + lf))) {
-            munmap(res, size2);
+            munmap(res, size);
             res = 0;
           }
           break;
         default:
-          munmap(res, size2);
+          munmap(res, size);
           res = 0;
           break;
       }
@@ -101,6 +100,25 @@ static struct SymbolTable *GetSymbolTableFromElf(void) {
   }
 }
 
+static void GetSymbolTableInit(void) {
+  struct Zipos *z;
+  int e = errno;
+  if (!__symtab && !__isworker) {
+    if (_weaken(__zipos_get) && (z = _weaken(__zipos_get)())) {
+      if ((__symtab = GetSymbolTableFromZip(z))) {
+        __symtab->names =
+            (uint32_t *)((char *)__symtab + __symtab->names_offset);
+        __symtab->name_base =
+            (char *)((char *)__symtab + __symtab->name_base_offset);
+      }
+    }
+    if (!__symtab) {
+      __symtab = GetSymbolTableFromElf();
+    }
+  }
+  errno = e;
+}
+
 /**
  * Returns symbol table singleton.
  *
@@ -122,24 +140,7 @@ static struct SymbolTable *GetSymbolTableFromElf(void) {
  * @return symbol table, or NULL if not found
  */
 struct SymbolTable *GetSymbolTable(void) {
-  struct Zipos *z;
-  if (pthread_spin_trylock(&g_lock))
-    return 0;
-  int e = errno;
-  if (!__symtab && !__isworker) {
-    if (_weaken(__zipos_get) && (z = _weaken(__zipos_get)())) {
-      if ((__symtab = GetSymbolTableFromZip(z))) {
-        __symtab->names =
-            (uint32_t *)((char *)__symtab + __symtab->names_offset);
-        __symtab->name_base =
-            (char *)((char *)__symtab + __symtab->name_base_offset);
-      }
-    }
-    if (!__symtab) {
-      __symtab = GetSymbolTableFromElf();
-    }
-  }
-  errno = e;
-  pthread_spin_unlock(&g_lock);
+  static atomic_uint once;
+  cosmo_once(&once, GetSymbolTableInit);
   return __symtab;
 }
diff --git a/libc/runtime/hook.greg.c b/libc/runtime/hook.greg.c
index 16596bf6a..795512481 100644
--- a/libc/runtime/hook.greg.c
+++ b/libc/runtime/hook.greg.c
@@ -19,7 +19,7 @@
 #include "ape/sections.internal.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
 
@@ -119,6 +119,7 @@ privileged int __hook(void *dest, struct SymbolTable *st) {
   if (!st)
     return -1;
   __morph_begin();
+  __jit_begin();
   lowest = MAX((intptr_t)__executable_start, (intptr_t)_ereal);
   for (i = 0; i < st->count; ++i) {
     if (st->symbols[i].x < 9)
@@ -138,6 +139,9 @@ privileged int __hook(void *dest, struct SymbolTable *st) {
       // kprintf("can't hook %t at %lx\n", p, p);
     }
   }
+  __clear_cache(MAX((char *)__executable_start, (char *)_ereal),
+                MIN((char *)__privileged_start, (char *)_etext));
+  __jit_end();
   __morph_end();
   return 0;
 }
diff --git a/libc/runtime/inflate.c b/libc/runtime/inflate.c
index 9a52edce3..f3264a3fe 100644
--- a/libc/runtime/inflate.c
+++ b/libc/runtime/inflate.c
@@ -16,9 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "third_party/puff/puff.h"
diff --git a/libc/runtime/init.S b/libc/runtime/init.S
index a3922476b..1cf5e035b 100644
--- a/libc/runtime/init.S
+++ b/libc/runtime/init.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/dce.h"
 
@@ -42,7 +42,7 @@
 //	@param	r15 is envp (still callee saved)
 //	@note	rdi is __init_bss_start (callee monotonic lockstep)
 //	@note	rsi is __init_rodata_start (callee monotonic lockstep)
-//	@see	.init.start & .init.end (libc/macros.internal.h)
+//	@see	.init.start & .init.end (libc/macros.h)
 //	@see	ape/ape.lds
 	.section .initprologue,"ax",@progbits
 	.type	_init,@function
@@ -86,7 +86,7 @@ _init_check_rdi_rsi:
 
 //	Decentralized section for packed data structures & initializers.
 //
-//	@see	.initro (libc/macros.internal.h)
+//	@see	.initro (libc/macros.h)
 //	@see	ape/ape.lds
 	.section .initroprologue,"a",@progbits
 	.type	__init_rodata_start,@object
@@ -110,7 +110,7 @@ __init_rodata_end:
 //
 //	Data in this section becomes read-only after initialization.
 //
-//	@see	.piro.bss.init (libc/macros.internal.h)
+//	@see	.piro.bss.init (libc/macros.h)
 //	@see	libc/runtime/piro.c
 //	@see	ape/ape.lds
 	.section .piro.bss.init.1,"aw",@nobits
diff --git a/libc/runtime/jit.c b/libc/runtime/jit.c
index 6ea45ecb5..a418f75dc 100644
--- a/libc/runtime/jit.c
+++ b/libc/runtime/jit.c
@@ -20,7 +20,7 @@
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/syslib.internal.h"
 
-void __jit_begin(void) {
+privileged void __jit_begin(void) {
   if (IsXnuSilicon()) {
     if (__syslib->__pthread_jit_write_protect_supported_np()) {
       __syslib->__pthread_jit_write_protect_np(false);
@@ -28,7 +28,7 @@ void __jit_begin(void) {
   }
 }
 
-void __jit_end(void) {
+privileged void __jit_end(void) {
   if (IsXnuSilicon()) {
     if (__syslib->__pthread_jit_write_protect_supported_np()) {
       __syslib->__pthread_jit_write_protect_np(true);
diff --git a/libc/runtime/login_tty.c b/libc/runtime/login_tty.c
index 14679663f..0a80916d8 100644
--- a/libc/runtime/login_tty.c
+++ b/libc/runtime/login_tty.c
@@ -21,7 +21,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/utmp.h"
 #include "libc/sysv/consts/termios.h"
diff --git a/libc/runtime/mapstack.c b/libc/runtime/mapstack.c
deleted file mode 100644
index 3bec5d639..000000000
--- a/libc/runtime/mapstack.c
+++ /dev/null
@@ -1,69 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/syscall-sysv.internal.h"
-#include "libc/dce.h"
-#include "libc/runtime/memtrack.internal.h"
-#include "libc/runtime/runtime.h"
-#include "libc/runtime/stack.h"
-#include "libc/sysv/consts/auxv.h"
-#include "libc/sysv/consts/map.h"
-#include "libc/sysv/consts/prot.h"
-
-#define MAP_ANON_OPENBSD  0x1000
-#define MAP_STACK_OPENBSD 0x4000
-
-/**
- * Allocates stack.
- *
- * The size of your returned stack is always GetStackSize().
- *
- * The bottom 4096 bytes of your stack can't be used, since it's always
- * reserved for a read-only guard page. With ASAN it'll be poisoned too.
- *
- * The top 16 bytes of a stack can't be used due to openbsd:stackbound
- * and those bytes are also poisoned under ASAN build modes.
- *
- * @return stack bottom address on success, or null w/ errno
- */
-void *NewCosmoStack(void) {
-  char *p;
-  size_t n = GetStackSize();
-  if ((p = mmap(0, n, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1,
-                0)) != MAP_FAILED) {
-    if (IsOpenbsd() && __sys_mmap(p, n, PROT_READ | PROT_WRITE,
-                                  MAP_PRIVATE | MAP_FIXED | MAP_ANON_OPENBSD |
-                                      MAP_STACK_OPENBSD,
-                                  -1, 0, 0) != p) {
-      notpossible;
-    }
-    return p;
-  } else {
-    return 0;
-  }
-}
-
-/**
- * Frees stack.
- *
- * @param stk was allocated by NewCosmoStack()
- */
-int FreeCosmoStack(void *stk) {
-  return munmap(stk, GetStackSize());
-}
diff --git a/libc/runtime/memtrack.internal.h b/libc/runtime/memtrack.internal.h
index 14abf4eed..7841fad40 100644
--- a/libc/runtime/memtrack.internal.h
+++ b/libc/runtime/memtrack.internal.h
@@ -3,19 +3,15 @@
 COSMOPOLITAN_C_START_
 
 #ifndef __SANITIZE_ADDRESS__
-#define kFixedmapStart      0x300000000
-#define kFixedmapSize       (0x400000000 - kFixedmapStart)
-#define kMemtrackFdsStart   0x6fe000000
-#define kMemtrackFdsSize    (0x6ff000000 - kMemtrackFdsStart)
-#define kMemtrackZiposStart 0x6fd000000
-#define kMemtrackZiposSize  (0xafe000000 - kMemtrackZiposStart)
+#define kFixedmapStart    0x300000000
+#define kFixedmapSize     (0x400000000 - kFixedmapStart)
+#define kMemtrackFdsStart 0x6fe000000
+#define kMemtrackFdsSize  (0x6ff000000 - kMemtrackFdsStart)
 #else
-#define kFixedmapStart      0x300000040000
-#define kFixedmapSize       (0x400000040000 - kFixedmapStart)
-#define kMemtrackFdsStart   0x6fe000040000
-#define kMemtrackFdsSize    (0x6feffffc0000 - kMemtrackFdsStart)
-#define kMemtrackZiposStart 0x6fd000040000
-#define kMemtrackZiposSize  (0x6fdffffc0000 - kMemtrackZiposStart)
+#define kFixedmapStart    0x300000040000
+#define kFixedmapSize     (0x400000040000 - kFixedmapStart)
+#define kMemtrackFdsStart 0x6fe000040000
+#define kMemtrackFdsSize  (0x6feffffc0000 - kMemtrackFdsStart)
 #endif
 
 COSMOPOLITAN_C_END_
diff --git a/libc/runtime/morph.c b/libc/runtime/morph.c
index 08abcc410..c3bcc4ae3 100644
--- a/libc/runtime/morph.c
+++ b/libc/runtime/morph.c
@@ -24,12 +24,13 @@
 #include "libc/intrin/kprintf.h"
 #include "libc/nt/enum/pageflags.h"
 #include "libc/nt/memory.h"
+#include "libc/nt/runtime.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/nr.h"
 #include "libc/sysv/consts/prot.h"
 
-__msabi extern typeof(VirtualProtect) *const __imp_VirtualProtect;
+__msabi extern typeof(VirtualProtectEx) *const __imp_VirtualProtectEx;
 
 __funline void __morph_mprotect(void *addr, size_t size, int prot, int ntprot) {
 #ifdef __x86_64__
@@ -54,7 +55,7 @@ __funline void __morph_mprotect(void *addr, size_t size, int prot, int ntprot) {
     }
 #endif
   } else {
-    __imp_VirtualProtect(addr, size, ntprot, &op);
+    __imp_VirtualProtectEx(GetCurrentProcess(), addr, size, ntprot, &op);
   }
 #elif defined(__aarch64__)
   register long r0 asm("x0") = (long)addr;
diff --git a/libc/runtime/opensymboltable.greg.c b/libc/runtime/opensymboltable.greg.c
index bbb32adcb..145c8be21 100644
--- a/libc/runtime/opensymboltable.greg.c
+++ b/libc/runtime/opensymboltable.greg.c
@@ -22,10 +22,10 @@
 #include "libc/dce.h"
 #include "libc/elf/tinyelf.internal.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/log/libfatal.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
@@ -49,7 +49,7 @@ static struct SymbolTable *OpenSymbolTableImpl(const char *filename) {
   size_t n, m, tsz, size;
   const Elf64_Sym *symtab, *sym;
   ptrdiff_t names_offset, name_base_offset, stp_offset;
-  long pagesz = getauxval(AT_PAGESZ);
+  long pagesz = __pagesize;
   map = MAP_FAILED;
   if ((fd = open(filename, O_RDONLY | O_CLOEXEC)) == -1)
     return 0;
@@ -130,7 +130,8 @@ static struct SymbolTable *OpenSymbolTableImpl(const char *filename) {
     ++j;
   }
   t->count = j;
-  munmap(stp, sizeof(const Elf64_Sym *) * n);
+  if (!IsWindows())
+    munmap(stp, sizeof(const Elf64_Sym *) * n);
   munmap(map, filesize);
   close(fd);
   return t;
@@ -144,9 +145,8 @@ RaiseEnoexec:
   errno = ENOEXEC;
 SystemError:
   STRACE("OpenSymbolTable()% m");
-  if (map != MAP_FAILED) {
+  if (map != MAP_FAILED)
     munmap(map, filesize);
-  }
   close(fd);
   return 0;
 }
diff --git a/libc/runtime/progname.S b/libc/runtime/progname.S
index c2f807dcc..e98f0fb3c 100644
--- a/libc/runtime/progname.S
+++ b/libc/runtime/progname.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Provides argv[0] The BSD Way.
 	.initbss 300,_init___progname
diff --git a/libc/runtime/runtime.h b/libc/runtime/runtime.h
index 9450bf435..4ea96a3cc 100644
--- a/libc/runtime/runtime.h
+++ b/libc/runtime/runtime.h
@@ -4,6 +4,7 @@ COSMOPOLITAN_C_START_
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § runtime                                                   ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
+/* clang-format off */
 
 #ifdef __x86_64__
 typedef long jmp_buf[8];
@@ -22,11 +23,9 @@ typedef unsigned long jmp_buf[26];
 void mcount(void) libcesque;
 int daemon(int, int) libcesque;
 unsigned long getauxval(unsigned long) libcesque;
-int setjmp(jmp_buf)
-libcesque returnstwice paramsnonnull();
+int setjmp(jmp_buf) libcesque returnstwice paramsnonnull();
 void longjmp(jmp_buf, int) libcesque wontreturn paramsnonnull();
-int _setjmp(jmp_buf)
-libcesque returnstwice paramsnonnull();
+int _setjmp(jmp_buf) libcesque returnstwice paramsnonnull();
 int sigsetjmp(sigjmp_buf, int) libcesque returnstwice paramsnonnull();
 void siglongjmp(sigjmp_buf, int) libcesque wontreturn paramsnonnull();
 void _longjmp(jmp_buf, int) libcesque wontreturn paramsnonnull();
@@ -37,12 +36,13 @@ void quick_exit(int) wontreturn;
 void abort(void) wontreturn;
 int atexit(void (*)(void)) paramsnonnull() libcesque;
 char *getenv(const char *) paramsnonnull() __wur nosideeffect libcesque;
-int putenv(char *) libcesque;
+int putenv(char *) libcesque __read_write(1);
 int setenv(const char *, const char *, int) libcesque;
 int unsetenv(const char *) libcesque;
 int clearenv(void) libcesque;
 void fpreset(void) libcesque;
 void *mmap(void *, uint64_t, int32_t, int32_t, int32_t, int64_t) libcesque;
+void *mremap(void *, size_t, size_t, int, ...) libcesque;
 int munmap(void *, uint64_t) libcesque;
 int mprotect(void *, uint64_t, int) libcesque;
 int msync(void *, size_t, int) libcesque;
@@ -51,9 +51,10 @@ int munlock(const void *, size_t) libcesque;
 long gethostid(void) libcesque;
 int sethostid(long) libcesque;
 char *getlogin(void) libcesque;
-int getlogin_r(char *, size_t) libcesque;
-int login_tty(int) libcesque;
-int getpagesize(void) libcesque;
+int getlogin_r(char *, size_t) libcesque __write_only(1, 2);
+int login_tty(int) libcesque __fd_arg(1);
+int getpagesize(void) pureconst libcesque;
+int getgransize(void) pureconst libcesque;
 int syncfs(int) dontthrow libcesque;
 int vhangup(void) libcesque;
 int getdtablesize(void) libcesque;
@@ -69,6 +70,8 @@ char *secure_getenv(const char *) paramsnonnull() __wur nosideeffect libcesque;
 extern int __argc;
 extern char **__argv;
 extern char **__envp;
+extern int __pagesize;
+extern int __gransize;
 extern unsigned long *__auxv;
 extern intptr_t __oldstack;
 extern char *__program_executable_name;
@@ -80,18 +83,18 @@ extern uint64_t kStartTsc;
 extern const char kNtSystemDirectory[];
 extern const char kNtWindowsDirectory[];
 extern size_t __virtualmax;
-extern size_t __virtualsize;
 extern size_t __stackmax;
 extern bool32 __isworker;
 /* utilities */
-void _intsort(int *, size_t) libcesque;
-void _longsort(long *, size_t) libcesque;
+void _intsort(int *, size_t) libcesque __read_write(1, 2);
+void _longsort(long *, size_t) libcesque __read_write(1, 2);
 /* diagnostics */
 void ShowCrashReports(void) libcesque;
 int ftrace_install(void) libcesque;
 int ftrace_enabled(int) libcesque;
 int strace_enabled(int) libcesque;
-void __print_maps(void) libcesque;
+void __print_maps(size_t) libcesque;
+void __print_maps_win32(int64_t, const char *, size_t) libcesque;
 void __printargs(const char *) libcesque;
 /* builtin sh-like system/popen dsl */
 int _cocmd(int, char **, char **) libcesque;
@@ -103,21 +106,20 @@ int __open_executable(void) libcesque;
 int verynice(void) libcesque;
 void __warn_if_powersave(void) libcesque;
 void _Exit1(int) libcesque wontreturn libcesque;
-void __paginate(int, const char *) libcesque;
-void __paginate_file(int, const char *) libcesque;
+void __paginate(int, const char *) libcesque __fd_arg(1);
+void __paginate_file(int, const char *) libcesque __fd_arg(1);
 /* memory management */
 void _weakfree(void *) libcesque;
 void *_mapanon(size_t) attributeallocsize((1)) mallocesque libcesque;
 void *_mapshared(size_t) attributeallocsize((1)) mallocesque libcesque;
 void CheckForFileLeaks(void) libcesque;
-void __enable_threads(void) libcesque;
 void __oom_hook(size_t) libcesque;
 /* code morphing */
 void __morph_begin(void) libcesque;
 void __morph_end(void) libcesque;
 void __jit_begin(void) libcesque;
 void __jit_end(void) libcesque;
-void __clear_cache(void *, void *) libcesque;
+void __clear_cache(void *, void *);
 /* portability */
 bool32 IsGenuineBlink(void) libcesque;
 bool32 IsCygwin(void) libcesque;
@@ -127,7 +129,6 @@ void GetCpuidBrand(char[13], uint32_t) libcesque;
 long __get_rlimit(int) libcesque;
 const char *__describe_os(void) libcesque;
 long __get_sysctl(int, int) libcesque;
-int __granularity(void) pureconst libcesque;
 int __get_arg_max(void) pureconst libcesque;
 int __get_cpu_count(void) pureconst libcesque;
 long __get_avphys_pages(void) pureconst libcesque;
diff --git a/libc/runtime/set_tls.c b/libc/runtime/set_tls.c
index 0f54e8d12..c8385bacc 100644
--- a/libc/runtime/set_tls.c
+++ b/libc/runtime/set_tls.c
@@ -24,7 +24,6 @@
 #include "libc/nt/thread.h"
 #include "libc/sysv/consts/arch.h"
 #include "libc/thread/tls.h"
-#include "libc/thread/tls2.internal.h"
 
 #define AMD64_SET_FSBASE 129
 #define AMD64_SET_GSBASE 131
@@ -38,7 +37,7 @@ dontinstrument textstartup void __set_tls(struct CosmoTib *tib) {
 #ifdef __x86_64__
   // ask the operating system to change the x86 segment register
   if (IsWindows()) {
-    asm("mov\t%1,%%gs:%0" : "=m"(*((long *)0x1480 + __tls_index)) : "r"(tib));
+    __set_tls_win32(tib);
   } else if (IsLinux()) {
     sys_set_tls(ARCH_SET_GS, tib);
   } else if (IsFreebsd()) {
@@ -57,7 +56,7 @@ dontinstrument textstartup void __set_tls(struct CosmoTib *tib) {
     uint64_t val = (uint64_t)tib;
     asm volatile("wrmsr"
                  : /* no outputs */
-                 : "c"(MSR_IA32_FS_BASE), "a"((uint32_t)val),
+                 : "c"(MSR_IA32_GS_BASE), "a"((uint32_t)val),
                    "d"((uint32_t)(val >> 32)));
   }
 #elif defined(__aarch64__)
diff --git a/libc/runtime/sigsetjmp.S b/libc/runtime/sigsetjmp.S
index 98598bd50..3187bd295 100644
--- a/libc/runtime/sigsetjmp.S
+++ b/libc/runtime/sigsetjmp.S
@@ -25,11 +25,11 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Saves caller CPU state and signal mask.
 //
-//	@param	rdi points to jmp_buf
+//	@param	rdi points to sigjmp_buf
 //	@param	esi if non-zero will cause mask to be saved
 //	@return	eax 0 when set and !0 when longjmp'd
 //	@returnstwice
diff --git a/libc/runtime/stack.h b/libc/runtime/stack.h
index a09fe61d8..d526bb3da 100644
--- a/libc/runtime/stack.h
+++ b/libc/runtime/stack.h
@@ -1,18 +1,23 @@
 #ifdef _COSMO_SOURCE
 #ifndef COSMOPOLITAN_LIBC_RUNTIME_STACK_H_
 #define COSMOPOLITAN_LIBC_RUNTIME_STACK_H_
+#include "libc/runtime/runtime.h"
 
 /**
  * Returns preferred size and alignment of thread stack.
  */
-#define GetStackSize() 262144
+#ifndef MODE_DBG
+#define GetStackSize() 81920
+#else
+#define GetStackSize() 163840
+#endif
 
 /**
  * Returns preferred stack guard size.
  *
  * This is the max cpu page size of supported architectures.
  */
-#define GetGuardSize() 16384
+#define GetGuardSize() __pagesize
 
 /**
  * Makes program stack executable if declared, e.g.
@@ -64,9 +69,8 @@ uintptr_t GetStackBottom(void) pureconst;
  * will also trigger the stack to grow down safely.
  */
 forceinline void CheckLargeStackAllocation(void *p, ssize_t n) {
-  for (; n > 0; n -= 4096) {
-    ((char *)p)[n - 1] = 0;
-  }
+  for (; n > 0; n -= 4096)
+    ((volatile char *)p)[n - 1] = 0;
 }
 
 void *NewCosmoStack(void) vallocesque;
diff --git a/libc/runtime/straceinit.greg.c b/libc/runtime/straceinit.greg.c
index ba2084888..92bf2ce18 100644
--- a/libc/runtime/straceinit.greg.c
+++ b/libc/runtime/straceinit.greg.c
@@ -16,8 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/getenv.internal.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/calls/calls.h"
+#include "libc/intrin/getenv.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/log/libfatal.internal.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
diff --git a/libc/runtime/sysconf.c b/libc/runtime/sysconf.c
index a99596458..4f3dafd75 100644
--- a/libc/runtime/sysconf.c
+++ b/libc/runtime/sysconf.c
@@ -22,10 +22,10 @@
 #include "libc/calls/struct/sysinfo.h"
 #include "libc/calls/struct/sysinfo.internal.h"
 #include "libc/dce.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "libc/runtime/clktck.h"
 #include "libc/intrin/maps.h"
+#include "libc/limits.h"
+#include "libc/macros.h"
+#include "libc/runtime/clktck.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/sysconf.h"
 #include "libc/sysv/consts/_posix.h"
@@ -41,11 +41,12 @@
  *
  * The following parameters are supported:
  *
+ * - `_SC_PAGESIZE` returns page size for mmap()
+ * - `_SC_GRANSIZE` returns addr alignment for mmap()
  * - `_SC_CLK_TCK` returns number of clock ticks per second
  * - `_SC_ARG_MAX` will perform expensive rlimit calculations
- * - `_SC_SIGSTKSZ` returns host platform's preferred SIGSTKSZ
- * - `_SC_MINSIGSTKSZ` returns host platform's required MINSIGSTKSZ
- * - `_SC_PAGESIZE` currently always returns 65536 due to Windows
+ * - `_SC_SIGSTKSZ` returns recommended `SIGSTKSZ` for platform
+ * - `_SC_MINSIGSTKSZ` returns size of kernel pushed signal frame
  * - `_SC_AVPHYS_PAGES` returns average physical memory pages
  * - `_SC_PHYS_PAGES` returns physical memory pages available
  * - `_SC_NPROCESSORS_ONLN` returns number of effective CPUs
@@ -60,11 +61,13 @@ long sysconf(int name) {
     case _SC_CLK_TCK:
       return CLK_TCK;
     case _SC_PAGESIZE:
-      return __granularity();
+      return __pagesize;
+    case _SC_GRANSIZE:
+      return __gransize;
     case _SC_ARG_MAX:
       return __get_arg_max();
     case _SC_SIGSTKSZ:
-      return _SIGSTKSZ;
+      return __get_minsigstksz() + SIGSTKSZ;
     case _SC_MINSIGSTKSZ:
       return __get_minsigstksz();
     case _SC_CHILD_MAX:
diff --git a/libc/runtime/sysconf.h b/libc/runtime/sysconf.h
index c44138c09..f3fd5bbd1 100644
--- a/libc/runtime/sysconf.h
+++ b/libc/runtime/sysconf.h
@@ -33,6 +33,8 @@
 #define _SC_VERSION                      29
 #define _SC_PAGE_SIZE                    30
 #define _SC_PAGESIZE                     30 /* !! */
+#define _SC_GRAN_SIZE                    3000
+#define _SC_GRANSIZE                     3000
 #define _SC_RTSIG_MAX                    31
 #define _SC_SEM_NSEMS_MAX                32
 #define _SC_SEM_VALUE_MAX                33
diff --git a/libc/runtime/syslib.internal.h b/libc/runtime/syslib.internal.h
index 90ed2994f..424034537 100644
--- a/libc/runtime/syslib.internal.h
+++ b/libc/runtime/syslib.internal.h
@@ -82,6 +82,7 @@ struct Syslib {
   char *(*__dlerror)(void);
   /* v9 (2024-01-31) */
   int (*__pthread_cpu_number_np)(size_t *);
+  /* v10 (2024-05-02) */
   long (*__sysctl)(int *, unsigned, void *, size_t *, void *, size_t);
   long (*__sysctlbyname)(const char *, void *, size_t *, void *, size_t);
   long (*__sysctlnametomib)(const char *, int *, size_t *);
diff --git a/libc/runtime/valist.c b/libc/runtime/valist.c
index 47294559b..b996e2732 100644
--- a/libc/runtime/valist.c
+++ b/libc/runtime/valist.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /* <sync libc/integral/lp64arg.inc> */
 struct __va_list {
diff --git a/libc/runtime/warnifpowersave.c b/libc/runtime/warnifpowersave.c
index 1a01d81d3..3ae40737f 100644
--- a/libc/runtime/warnifpowersave.c
+++ b/libc/runtime/warnifpowersave.c
@@ -36,6 +36,8 @@
   "/sys/devices/system/cpu/cpu*/cpufreq/scaling_governor\n"
 
 void __warn_if_powersave(void) {
+  if (1)
+    return;
   int e, fd;
   char buf[16] = {0};
   if (IsLinux()) {
diff --git a/libc/runtime/weakfree.c b/libc/runtime/weakfree.c
index bd6e561ec..5e5f57877 100644
--- a/libc/runtime/weakfree.c
+++ b/libc/runtime/weakfree.c
@@ -24,7 +24,6 @@
  * Thunks free() if it's linked, otherwise do nothing.
  */
 void _weakfree(void *p) {
-  if (_weaken(free)) {
+  if (_weaken(free))
     _weaken(free)(p);
-  }
 }
diff --git a/libc/runtime/winmain.greg.c b/libc/runtime/winmain.greg.c
index 1d92f976a..640314f93 100644
--- a/libc/runtime/winmain.greg.c
+++ b/libc/runtime/winmain.greg.c
@@ -17,19 +17,21 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/atomic.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/intrin/dll.h"
 #include "libc/intrin/maps.h"
-#include "libc/intrin/nomultics.internal.h"
+#include "libc/intrin/nomultics.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/nt/accounting.h"
 #include "libc/nt/console.h"
 #include "libc/nt/enum/consolemodeflags.h"
+#include "libc/nt/enum/creationdisposition.h"
 #include "libc/nt/enum/filemapflags.h"
 #include "libc/nt/enum/pageflags.h"
 #include "libc/nt/files.h"
@@ -38,6 +40,8 @@
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/signals.h"
+#include "libc/nt/struct/systeminfo.h"
+#include "libc/nt/systeminfo.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/memtrack.internal.h"
@@ -48,6 +52,7 @@
 #include "libc/sock/internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/prot.h"
+#include "libc/thread/tls.h"
 #ifdef __x86_64__
 
 #define abi __msabi textwindows dontinstrument
@@ -57,6 +62,7 @@ __msabi extern typeof(AddVectoredExceptionHandler) *const __imp_AddVectoredExcep
 __msabi extern typeof(CreateFileMapping) *const __imp_CreateFileMappingW;
 __msabi extern typeof(DuplicateHandle) *const __imp_DuplicateHandle;
 __msabi extern typeof(FreeEnvironmentStrings) *const __imp_FreeEnvironmentStringsW;
+__msabi extern typeof(GetCommandLine) *const __imp_GetCommandLineW;
 __msabi extern typeof(GetConsoleMode) *const __imp_GetConsoleMode;
 __msabi extern typeof(GetCurrentDirectory) *const __imp_GetCurrentDirectoryW;
 __msabi extern typeof(GetCurrentProcessId) *const __imp_GetCurrentProcessId;
@@ -64,6 +70,8 @@ __msabi extern typeof(GetEnvironmentStrings) *const __imp_GetEnvironmentStringsW
 __msabi extern typeof(GetEnvironmentVariable) *const __imp_GetEnvironmentVariableW;
 __msabi extern typeof(GetFileAttributes) *const __imp_GetFileAttributesW;
 __msabi extern typeof(GetStdHandle) *const __imp_GetStdHandle;
+__msabi extern typeof(GetSystemInfo) *const __imp_GetSystemInfo;
+__msabi extern typeof(GetSystemInfo) *const __imp_GetSystemInfo;
 __msabi extern typeof(GetUserName) *const __imp_GetUserNameW;
 __msabi extern typeof(MapViewOfFileEx) *const __imp_MapViewOfFileEx;
 __msabi extern typeof(SetConsoleCP) *const __imp_SetConsoleCP;
@@ -71,7 +79,7 @@ __msabi extern typeof(SetConsoleMode) *const __imp_SetConsoleMode;
 __msabi extern typeof(SetConsoleOutputCP) *const __imp_SetConsoleOutputCP;
 __msabi extern typeof(SetEnvironmentVariable) *const __imp_SetEnvironmentVariableW;
 __msabi extern typeof(SetStdHandle) *const __imp_SetStdHandle;
-__msabi extern typeof(VirtualProtect) *const __imp_VirtualProtect;
+__msabi extern typeof(VirtualProtectEx) *const __imp_VirtualProtectEx;
 __msabi extern typeof(WriteFile) *const __imp_WriteFile;
 // clang-format on
 
@@ -80,21 +88,15 @@ void __stack_call(int, char **, char **, long (*)[2],
                   void (*)(int, char **, char **, long (*)[2]),
                   intptr_t) wontreturn;
 
+bool __winmain_isfork;
+intptr_t __winmain_jmpbuf[5];
+struct CosmoTib *__winmain_tib;
+
 __funline int IsAlpha(int c) {
   return ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z');
 }
 
-// https://nullprogram.com/blog/2022/02/18/
-__funline char16_t *MyCommandLine(void) {
-  void *cmd;
-  asm("mov\t%%gs:(0x60),%0\n"
-      "mov\t0x20(%0),%0\n"
-      "mov\t0x78(%0),%0\n"
-      : "=r"(cmd));
-  return cmd;
-}
-
-static abi char16_t *StrStr(const char16_t *haystack, const char16_t *needle) {
+abi static char16_t *StrStr(const char16_t *haystack, const char16_t *needle) {
   size_t i;
   for (;;) {
     for (i = 0;; ++i) {
@@ -111,13 +113,13 @@ static abi char16_t *StrStr(const char16_t *haystack, const char16_t *needle) {
   return 0;
 }
 
-static abi void PrintError(const char *s, size_t n) {
+abi static void PrintError(const char *s, size_t n) {
 #define PrintError(s) PrintError(s, sizeof(s) - 1)
   __imp_WriteFile(__imp_GetStdHandle(kNtStdErrorHandle), s, n, 0, 0);
 }
 
 // detect the unholiest of environments
-static abi bool32 IsWslChimera(void) {
+abi static bool32 IsWslChimera(void) {
   char16_t path[PATH_MAX];
   return __imp_GetCurrentDirectoryW(PATH_MAX, path) &&  //
          path[0] == '\\' &&                             //
@@ -128,7 +130,7 @@ static abi bool32 IsWslChimera(void) {
 }
 
 // returns true if utf-8 path is a win32-style path that exists
-static abi bool32 WinFileExists(const char *path) {
+abi static bool32 WinFileExists(const char *path) {
   uint16_t path16[PATH_MAX];
   size_t z = ARRAYLEN(path16);
   size_t n = tprecode8to16(path16, z, path).ax;
@@ -138,7 +140,7 @@ static abi bool32 WinFileExists(const char *path) {
 }
 
 // this ensures close(1) won't accidentally close(2) for example
-static abi void DeduplicateStdioHandles(void) {
+abi static void DeduplicateStdioHandles(void) {
   for (long i = 0; i < 3; ++i) {
     int64_t h1 = __imp_GetStdHandle(kNtStdio[i]);
     for (long j = i + 1; j < 3; ++j) {
@@ -153,19 +155,19 @@ static abi void DeduplicateStdioHandles(void) {
   }
 }
 
-static bool32 HasEnvironmentVariable(const char16_t *name) {
+abi static bool32 HasEnvironmentVariable(const char16_t *name) {
   char16_t buf[4];
   return __imp_GetEnvironmentVariableW(name, buf, ARRAYLEN(buf));
 }
 
-static abi unsigned OnWinCrash(struct NtExceptionPointers *ep) {
-  int code, sig = __sig_crash_sig(ep, &code);
+abi static unsigned OnWinCrash(struct NtExceptionPointers *ep) {
+  int code, sig = __sig_crash_sig(ep->ExceptionRecord->ExceptionCode, &code);
   TerminateThisProcess(sig);
 }
 
 // main function of windows init process
 // i.e. first process spawned that isn't forked
-static abi wontreturn void WinInit(const char16_t *cmdline) {
+abi wontreturn static void WinInit(const char16_t *cmdline) {
   __oldstack = (intptr_t)__builtin_frame_address(0);
 
   __imp_SetConsoleOutputCP(kNtCpUtf8);
@@ -194,28 +196,28 @@ static abi wontreturn void WinInit(const char16_t *cmdline) {
   __imp_AddVectoredExceptionHandler(true, (void *)OnWinCrash);
 
   // allocate memory for stack and argument block
+  intptr_t stackhand;
   char *stackaddr = (char *)GetStaticStackAddr(0);
   size_t stacksize = GetStaticStackSize();
   __imp_MapViewOfFileEx(
-      (__maps.stack.h = __imp_CreateFileMappingW(
-           -1, 0, kNtPageExecuteReadwrite, stacksize >> 32, stacksize, NULL)),
+      (stackhand = __imp_CreateFileMappingW(-1, 0, kNtPageExecuteReadwrite,
+                                            stacksize >> 32, stacksize, NULL)),
       kNtFileMapWrite | kNtFileMapExecute, 0, 0, stacksize, stackaddr);
-  int prot = (intptr_t)ape_stack_prot;
-  if (~prot & PROT_EXEC) {
+  int stackprot = (intptr_t)ape_stack_prot;
+  if (~stackprot & PROT_EXEC) {
     uint32_t old;
-    __imp_VirtualProtect(stackaddr, stacksize, kNtPageReadwrite, &old);
+    __imp_VirtualProtectEx(GetCurrentProcess(), stackaddr, stacksize,
+                           kNtPageReadwrite, &old);
   }
   uint32_t oldattr;
-  __imp_VirtualProtect(stackaddr, GetGuardSize(),
-                       kNtPageReadwrite | kNtPageGuard, &oldattr);
-  __maps.stack.addr = stackaddr;
-  __maps.stack.size = stacksize;
-  __maps.stack.prot = prot;
-  __maps.maps = &__maps.stack;
-  __maps.pages = (stacksize + 4095) / 4096;
-  __maps.count = 1;
-  dll_init(&__maps.stack.elem);
-  dll_make_first(&__maps.used, &__maps.stack.elem);
+  __imp_VirtualProtectEx(GetCurrentProcess(), stackaddr, GetGuardSize(),
+                         kNtPageReadwrite | kNtPageGuard, &oldattr);
+  if (_weaken(__maps_stack)) {
+    struct NtSystemInfo si;
+    __imp_GetSystemInfo(&si);
+    _weaken(__maps_stack)(stackaddr, si.dwPageSize, GetGuardSize(), stacksize,
+                          stackprot, stackhand);
+  }
   struct WinArgs *wa =
       (struct WinArgs *)(stackaddr + (stacksize - sizeof(struct WinArgs)));
 
@@ -299,38 +301,78 @@ static abi wontreturn void WinInit(const char16_t *cmdline) {
                 ARRAYLEN(wa->envp) - 1);
   __imp_FreeEnvironmentStringsW(env16);
   __envp = &wa->envp[0];
-
   // handover control to cosmopolitan runtime
   __stack_call(count, wa->argv, wa->envp, wa->auxv, cosmo,
                (uintptr_t)(stackaddr + (stacksize - sizeof(struct WinArgs))));
 }
 
+static int Atoi(const char16_t *str) {
+  int c;
+  unsigned x = 0;
+  while ((c = *str++)) {
+    if ('0' <= c && c <= '9') {
+      x *= 10;
+      x += c - '0';
+    } else {
+      return -1;
+    }
+  }
+  return x;
+}
+
+abi static int WinGetPid(const char16_t *var, bool *out_is_inherited) {
+  uint32_t len;
+  char16_t val[12];
+  if ((len = __imp_GetEnvironmentVariableW(var, val, ARRAYLEN(val)))) {
+    int pid = -1;
+    if (len < ARRAYLEN(val))
+      pid = Atoi(val);
+    __imp_SetEnvironmentVariableW(var, NULL);
+    if (pid > 0) {
+      *out_is_inherited = true;
+      return pid;
+    }
+  }
+  *out_is_inherited = false;
+  return __imp_GetCurrentProcessId();
+}
+
 abi int64_t WinMain(int64_t hInstance, int64_t hPrevInstance,
                     const char *lpCmdLine, int64_t nCmdShow) {
+  static atomic_ulong fake_process_signals;
   const char16_t *cmdline;
   extern char os asm("__hostos");
   os = _HOSTWINDOWS;  // madness https://news.ycombinator.com/item?id=21019722
   kStartTsc = rdtsc();
+  __tls_enabled = false;
+  ftrace_enabled(-1);
   if (!IsTiny() && IsWslChimera()) {
     PrintError("error: APE is running on WIN32 inside WSL. You need to run: "
                "sudo sh -c 'echo -1 > /proc/sys/fs/binfmt_misc/WSLInterop'\n");
     return 77 << 8;  // exit(77)
   }
-  __umask = 077;
-  __pid = __imp_GetCurrentProcessId();
-  cmdline = MyCommandLine();
+  struct NtSystemInfo si;
+  __imp_GetSystemInfo(&si);
+  __pagesize = si.dwPageSize;
+  __gransize = si.dwAllocationGranularity;
+  bool pid_is_inherited;
+  __pid = WinGetPid(u"_COSMO_PID", &pid_is_inherited);
+  if (!(__sig.process = __sig_map_process(__pid, kNtOpenAlways)))
+    __sig.process = &fake_process_signals;
+  if (__winmain_isfork)
+    __builtin_longjmp(__winmain_jmpbuf, 1);
+  if (!pid_is_inherited)
+    atomic_store_explicit(__sig.process, 0, memory_order_release);
+  cmdline = __imp_GetCommandLineW();
 #if SYSDEBUG
   // sloppy flag-only check for early initialization
   if (StrStr(cmdline, u"--strace"))
     ++__strace;
 #endif
-  if (_weaken(WinSockInit)) {
+  ftrace_enabled(+1);
+  if (_weaken(WinSockInit))
     _weaken(WinSockInit)();
-  }
   DeduplicateStdioHandles();
-  if (_weaken(WinMainForked)) {
-    _weaken(WinMainForked)();
-  }
   WinInit(cmdline);
 }
 
diff --git a/libc/runtime/zipos-access.c b/libc/runtime/zipos-access.c
index 291000d27..eb3807b0f 100644
--- a/libc/runtime/zipos-access.c
+++ b/libc/runtime/zipos-access.c
@@ -22,7 +22,7 @@
 #include "libc/sysv/consts/ok.h"
 #include "libc/sysv/consts/s.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 // TODO: this should check parent directory components
 
diff --git a/libc/runtime/zipos-find.c b/libc/runtime/zipos-find.c
index 2fc30d442..7431c5e9a 100644
--- a/libc/runtime/zipos-find.c
+++ b/libc/runtime/zipos-find.c
@@ -16,13 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/s.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 static ssize_t __zipos_match(struct Zipos *z, struct ZiposUri *name, int len,
                              int i) {
@@ -44,9 +43,8 @@ ssize_t __zipos_scan(struct Zipos *zipos, struct ZiposUri *name) {
 
   // strip trailing slash from search name
   int len = name->len;
-  if (len && name->path[len - 1] == '/') {
+  if (len && name->path[len - 1] == '/')
     --len;
-  }
 
   // empty string means the /zip root directory
   if (!len) {
@@ -91,9 +89,8 @@ ssize_t __zipos_scan(struct Zipos *zipos, struct ZiposUri *name) {
       dx = dx < -1 ? -1 : dx;
       for (l += dx; 0 <= l && l < zipos->records; l += dx) {
         ssize_t cf;
-        if ((cf = __zipos_match(zipos, name, len, l)) != -1) {
+        if ((cf = __zipos_match(zipos, name, len, l)) != -1)
           return cf;
-        }
         cfile = zipos->index[l];
         zname = ZIP_CFILE_NAME(zipos->map + cfile);
         zsize = ZIP_CFILE_NAMESIZE(zipos->map + cfile);
diff --git a/libc/runtime/zipos-get.c b/libc/runtime/zipos-get.c
index a0ae6cc7e..e98b6b363 100644
--- a/libc/runtime/zipos-get.c
+++ b/libc/runtime/zipos-get.c
@@ -21,11 +21,12 @@
 #include "libc/calls/metalfile.internal.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/cosmo.h"
+#include "libc/dce.h"
 #include "libc/fmt/conv.h"
 #include "libc/intrin/cmpxchg.h"
-#include "libc/intrin/promises.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/promises.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/zipos.internal.h"
@@ -37,7 +38,7 @@
 #include "libc/sysv/consts/posix.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/thread/thread.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 #ifdef __x86_64__
 __static_yoink(APE_COM_NAME);
@@ -62,16 +63,9 @@ static void __zipos_dismiss(uint8_t *map, const uint8_t *cdir, long pg) {
   }
 
   // unmap the executable portion beneath the local files
-  mo = ROUNDDOWN(lo, __granularity());
-  if (mo)
+  mo = ROUNDDOWN(lo, __gransize);
+  if (mo && !IsWindows())
     munmap(map, mo);
-
-  // this is supposed to reduce our rss usage but does it really?
-  lo = ROUNDDOWN(lo, pg);
-  hi = MIN(ROUNDUP(hi, pg), ROUNDDOWN(c, pg));
-  if (hi > lo) {
-    posix_madvise(map + lo, hi - lo, POSIX_MADV_DONTNEED);
-  }
 }
 
 static int __zipos_compare_names(const void *a, const void *b, void *c) {
@@ -96,9 +90,8 @@ static void __zipos_generate_index(struct Zipos *zipos) {
   zipos->records = GetZipCdirRecords(zipos->cdir);
   zipos->index = _mapanon(zipos->records * sizeof(size_t));
   for (i = 0, c = GetZipCdirOffset(zipos->cdir); i < zipos->records;
-       ++i, c += ZIP_CFILE_HDRSIZE(zipos->map + c)) {
+       ++i, c += ZIP_CFILE_HDRSIZE(zipos->map + c))
     zipos->index[i] = c;
-  }
   // smoothsort() isn't the fastest algorithm, but it guarantees
   // o(nlogn) won't smash the stack and doesn't depend on malloc
   smoothsort_r(zipos->index, zipos->records, sizeof(size_t),
@@ -114,7 +107,7 @@ static void __zipos_init(void) {
   const char *progpath;
   if (!(s = getenv("COSMOPOLITAN_DISABLE_ZIPOS"))) {
     // this environment variable may be a filename or file descriptor
-    if ((progpath = getenv("COSMOPOLITAN_INIT_ZIPOS")) &&
+    if ((progpath = secure_getenv("COSMOPOLITAN_INIT_ZIPOS")) &&
         (x = strtol(progpath, &endptr, 10)) >= 0 && !*endptr) {
       fd = x;
     } else {
@@ -122,16 +115,15 @@ static void __zipos_init(void) {
     }
     if (fd != -1 || PLEDGED(RPATH)) {
       if (fd == -1) {
-        if (!progpath) {
+        if (!progpath)
           progpath = GetProgramExecutableName();
-        }
         fd = open(progpath, O_RDONLY);
       }
       if (fd != -1) {
         if (!fstat(fd, &st) && (map = mmap(0, st.st_size, PROT_READ, MAP_SHARED,
                                            fd, 0)) != MAP_FAILED) {
           if ((cdir = GetZipEocd(map, st.st_size, &err))) {
-            long pagesz = getauxval(AT_PAGESZ);
+            long pagesz = __pagesize;
             __zipos_dismiss(map, cdir, pagesz);
             __zipos.map = map;
             __zipos.cdir = cdir;
diff --git a/libc/runtime/zipos-inode.c b/libc/runtime/zipos-inode.c
index c4f26ae27..480d999c4 100644
--- a/libc/runtime/zipos-inode.c
+++ b/libc/runtime/zipos-inode.c
@@ -21,7 +21,7 @@
 #include "libc/runtime/zipos.internal.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 uint64_t __zipos_inode(struct Zipos *zipos, int64_t cfile,  //
                        const void *name, size_t namelen) {
diff --git a/libc/runtime/zipos-mmap.c b/libc/runtime/zipos-mmap.c
index 237b9d16a..d137d372d 100644
--- a/libc/runtime/zipos-mmap.c
+++ b/libc/runtime/zipos-mmap.c
@@ -21,7 +21,7 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/maps.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/zipos.internal.h"
@@ -29,7 +29,7 @@
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/s.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 #define IP(X)  (intptr_t)(X)
 #define VIP(X) (void *)IP(X)
@@ -77,7 +77,7 @@ void *__zipos_mmap(void *addr, size_t size, int prot, int flags,
   flags |= MAP_PRIVATE | MAP_ANONYMOUS;
 
   const int tempProt = !IsXnu() ? prot | PROT_WRITE : PROT_WRITE;
-  void *outAddr = __mmap(addr, size, tempProt, flags, -1, 0);
+  void *outAddr = mmap(addr, size, tempProt, flags, -1, 0);
   if (outAddr == MAP_FAILED) {
     return MAP_FAILED;
   }
diff --git a/libc/runtime/zipos-notat.c b/libc/runtime/zipos-notat.c
index 809d622df..cebe24757 100644
--- a/libc/runtime/zipos-notat.c
+++ b/libc/runtime/zipos-notat.c
@@ -23,9 +23,8 @@
 int __zipos_notat(int dirfd, const char *path) {
   struct ZiposUri zipname;
   if (!path)
-    return efault();
-  if (__isfdkind(dirfd, kFdZip) || __zipos_parseuri(path, &zipname) != -1) {
-    return einval();
-  }
+    return 0;
+  if (__isfdkind(dirfd, kFdZip) || __zipos_parseuri(path, &zipname) != -1)
+    return -1;
   return 0;
 }
diff --git a/libc/runtime/zipos-open.c b/libc/runtime/zipos-open.c
index 4a181ed51..af01a567c 100644
--- a/libc/runtime/zipos-open.c
+++ b/libc/runtime/zipos-open.c
@@ -16,112 +16,47 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/calls/calls.h"
+#include "libc/calls/blockcancel.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigset.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
-#include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/cmpxchg.h"
-#include "libc/intrin/directmap.internal.h"
-#include "libc/intrin/extend.internal.h"
-#include "libc/intrin/likely.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/maps.h"
 #include "libc/intrin/weaken.h"
-#include "libc/limits.h"
 #include "libc/runtime/internal.h"
-#include "libc/runtime/memtrack.internal.h"
+#include "libc/runtime/runtime.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/f.h"
-#include "libc/sysv/consts/fd.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/s.h"
-#include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/thread/thread.h"
-#include "libc/thread/tls.h"
-#include "libc/zip.internal.h"
-
-#define MAX_REFS SSIZE_MAX
-
-static char *__zipos_mapend;
-static size_t __zipos_maptotal;
-static pthread_mutex_t __zipos_lock_obj;
-
-static void __zipos_wipe(void) {
-  pthread_mutex_init(&__zipos_lock_obj, 0);
-}
-
-static void __zipos_lock(void) {
-  pthread_mutex_lock(&__zipos_lock_obj);
-}
-
-static void __zipos_unlock(void) {
-  pthread_mutex_unlock(&__zipos_lock_obj);
-}
-
-static void *__zipos_mmap_space(size_t mapsize) {
-  char *start;
-  size_t offset;
-  unassert(mapsize);
-  offset = __zipos_maptotal;
-  __zipos_maptotal += mapsize;
-  start = (char *)kMemtrackZiposStart;
-  if (!__zipos_mapend)
-    __zipos_mapend = start;
-  __zipos_mapend = _extend(start, __zipos_maptotal, __zipos_mapend, MAP_PRIVATE,
-                           kMemtrackZiposStart + kMemtrackZiposSize);
-  return start + offset;
-}
+#include "libc/zip.h"
 
 struct ZiposHandle *__zipos_keep(struct ZiposHandle *h) {
-  size_t refs = atomic_fetch_add_explicit(&h->refs, 1, memory_order_relaxed);
-  unassert(!VERY_UNLIKELY(refs > MAX_REFS));
+  atomic_fetch_add_explicit(&h->refs, 1, memory_order_relaxed);
   return h;
 }
 
 void __zipos_drop(struct ZiposHandle *h) {
-  if (atomic_fetch_sub_explicit(&h->refs, 1, memory_order_release)) {
+  if (atomic_fetch_sub_explicit(&h->refs, 1, memory_order_release))
     return;
-  }
   atomic_thread_fence(memory_order_acquire);
-  __zipos_lock();
-  do
-    h->next = h->zipos->freelist;
-  while (!_cmpxchg(&h->zipos->freelist, h->next, h));
-  __zipos_unlock();
+  munmap((char *)h, h->mapsize);
 }
 
 static struct ZiposHandle *__zipos_alloc(struct Zipos *zipos, size_t size) {
   size_t mapsize;
-  struct ZiposHandle *h, **ph;
-  __zipos_lock();
+  struct ZiposHandle *h;
   mapsize = sizeof(struct ZiposHandle) + size;
-  mapsize = ROUNDUP(mapsize, 4096);
-StartOver:
-  ph = &zipos->freelist;
-  while ((h = *ph)) {
-    if (h->mapsize >= mapsize) {
-      if (!_cmpxchg(ph, h, h->next))
-        goto StartOver;
-      break;
-    }
-    ph = &h->next;
-  }
-  if (!h) {
-    h = __zipos_mmap_space(mapsize);
-  }
-  __zipos_unlock();
-  if (h) {
-    atomic_store_explicit(&h->refs, 0, memory_order_relaxed);
+  if ((h = mmap(0, mapsize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
+                -1, 0)) != MAP_FAILED) {
     h->size = size;
     h->zipos = zipos;
     h->mapsize = mapsize;
@@ -158,6 +93,7 @@ static int __zipos_load(struct Zipos *zipos, size_t cf, int flags,
   size_t size;
   int fd, minfd;
   struct ZiposHandle *h;
+
   if (cf == ZIPOS_SYNTHETIC_DIRECTORY) {
     size = name->len;
     if (!(h = __zipos_alloc(zipos, size + 1)))
@@ -168,7 +104,6 @@ static int __zipos_load(struct Zipos *zipos, size_t cf, int flags,
     h->mem = h->data;
   } else {
     lf = GetZipCfileOffset(zipos->map + cf);
-    npassert((ZIP_LFILE_MAGIC(zipos->map + lf) == kZipLfileHdrMagic));
     size = GetZipLfileUncompressedSize(zipos->map + lf);
     switch (ZIP_LFILE_COMPRESSIONMETHOD(zipos->map + lf)) {
       case kZipCompressionNone:
@@ -191,18 +126,17 @@ static int __zipos_load(struct Zipos *zipos, size_t cf, int flags,
         return eio();
     }
   }
+
   atomic_store_explicit(&h->pos, 0, memory_order_relaxed);
   h->cfile = cf;
-  unassert(size < SIZE_MAX);
   h->size = size;
   if (h->mem) {
     minfd = 3;
     __fds_lock();
   TryAgain:
     if (IsWindows() || IsMetal()) {
-      if ((fd = __reservefd_unlocked(-1)) != -1) {
+      if ((fd = __reservefd_unlocked(-1)) != -1)
         return __zipos_setfd(fd, h, flags);
-      }
     } else if ((fd = __zipos_mkfd(minfd)) != -1) {
       if (__ensurefds_unlocked(fd) != -1) {
         if (g_fds.p[fd].kind) {
@@ -221,16 +155,15 @@ static int __zipos_load(struct Zipos *zipos, size_t cf, int flags,
 }
 
 void __zipos_postdup(int oldfd, int newfd) {
-  if (oldfd == newfd) {
+  if (oldfd == newfd)
     return;
-  }
   BLOCK_SIGNALS;
+  BLOCK_CANCELATION;
   __fds_lock();
   if (__isfdkind(newfd, kFdZip)) {
     __zipos_drop((struct ZiposHandle *)(intptr_t)g_fds.p[newfd].handle);
-    if (!__isfdkind(oldfd, kFdZip)) {
+    if (!__isfdkind(oldfd, kFdZip))
       bzero(g_fds.p + newfd, sizeof(*g_fds.p));
-    }
   }
   if (__isfdkind(oldfd, kFdZip)) {
     __zipos_keep((struct ZiposHandle *)(intptr_t)g_fds.p[oldfd].handle);
@@ -238,6 +171,7 @@ void __zipos_postdup(int oldfd, int newfd) {
     g_fds.p[newfd] = g_fds.p[oldfd];
   }
   __fds_unlock();
+  ALLOW_CANCELATION;
   ALLOW_SIGNALS;
 }
 
@@ -260,45 +194,36 @@ int __zipos_open(struct ZiposUri *name, int flags) {
   // validate api usage
   if ((flags & O_CREAT) ||  //
       (flags & O_TRUNC) ||  //
-      (flags & O_ACCMODE) != O_RDONLY) {
+      (flags & O_ACCMODE) != O_RDONLY)
     return erofs();
-  }
 
   // get the zipos global singleton
   struct Zipos *zipos;
-  if (!(zipos = __zipos_get())) {
+  if (!(zipos = __zipos_get()))
     return enoexec();
-  }
 
   // most open() calls are due to languages path searching assets. the
   // majority of these calls will return ENOENT or ENOTDIR. we need to
   // perform two extremely costly sigprocmask() calls below. thanks to
   // zipos being a read-only filesystem, we can avoid it in many cases
   ssize_t cf;
-  if ((cf = __zipos_find(zipos, name)) == -1) {
+  if ((cf = __zipos_find(zipos, name)) == -1)
     return -1;
-  }
-  if (flags & O_EXCL) {
+  if (flags & O_EXCL)
     return eexist();
-  }
   if (cf != ZIPOS_SYNTHETIC_DIRECTORY) {
     int mode = GetZipCfileMode(zipos->map + cf);
-    if ((flags & O_DIRECTORY) && !S_ISDIR(mode)) {
+    if ((flags & O_DIRECTORY) && !S_ISDIR(mode))
       return enotdir();
-    }
-    if (!(mode & 0444)) {
+    if (!(mode & 0444))
       return eacces();
-    }
   }
 
   // now do the heavy lifting
   BLOCK_SIGNALS;
+  BLOCK_CANCELATION;
   rc = __zipos_load(zipos, cf, flags, name);
+  ALLOW_CANCELATION;
   ALLOW_SIGNALS;
   return rc;
 }
-
-__attribute__((__constructor__(60))) static textstartup void zipos_ctor(void) {
-  __zipos_wipe();
-  pthread_atfork(__zipos_lock, __zipos_unlock, __zipos_wipe);
-}
diff --git a/libc/runtime/zipos-read.c b/libc/runtime/zipos-read.c
index 7bb1ce215..9b90c987b 100644
--- a/libc/runtime/zipos-read.c
+++ b/libc/runtime/zipos-read.c
@@ -27,23 +27,21 @@
 #include "libc/sysv/consts/s.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/tls.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 static ssize_t __zipos_read_impl(struct ZiposHandle *h, const struct iovec *iov,
                                  size_t iovlen, ssize_t opt_offset) {
   int i;
   int64_t b, x, y, start_pos;
   if (h->cfile == ZIPOS_SYNTHETIC_DIRECTORY ||
-      S_ISDIR(GetZipCfileMode(h->zipos->map + h->cfile))) {
+      S_ISDIR(GetZipCfileMode(h->zipos->map + h->cfile)))
     return eisdir();
-  }
   if (opt_offset == -1) {
   Restart:
     start_pos = atomic_load_explicit(&h->pos, memory_order_relaxed);
     do {
-      if (UNLIKELY(start_pos == SIZE_MAX)) {
+      if (UNLIKELY(start_pos == SIZE_MAX))
         goto Restart;
-      }
     } while (!LIKELY(atomic_compare_exchange_weak_explicit(
         &h->pos, &start_pos, SIZE_MAX, memory_order_acquire,
         memory_order_relaxed)));
diff --git a/libc/runtime/zipos-stat-impl.c b/libc/runtime/zipos-stat-impl.c
index 8c1e387f7..ef47bb207 100644
--- a/libc/runtime/zipos-stat-impl.c
+++ b/libc/runtime/zipos-stat-impl.c
@@ -19,19 +19,19 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/zipos.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/s.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 int __zipos_stat_impl(struct Zipos *zipos, size_t cf, struct stat *st) {
   size_t lf;
   bzero(st, sizeof(*st));
   st->st_nlink = 1;
   st->st_dev = zipos->dev;
-  st->st_blksize = __granularity();
+  st->st_blksize = __pagesize;
   if (cf == ZIPOS_SYNTHETIC_DIRECTORY) {
     st->st_mode = S_IFDIR | (0555 & ~atomic_load_explicit(
                                         &__umask, memory_order_acquire));
diff --git a/libc/runtime/zipos.S b/libc/runtime/zipos.S
index 507db9efe..df0ba39ff 100644
--- a/libc/runtime/zipos.S
+++ b/libc/runtime/zipos.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	static_yoink this symbol for open(/zip/...) support.
 	zipos = 0
diff --git a/libc/runtime/zipos.internal.h b/libc/runtime/zipos.internal.h
index b7549fc9f..1691cee5d 100644
--- a/libc/runtime/zipos.internal.h
+++ b/libc/runtime/zipos.internal.h
@@ -6,6 +6,12 @@ COSMOPOLITAN_C_START_
 
 #define ZIPOS_SYNTHETIC_DIRECTORY 0
 
+#ifndef __cplusplus
+#define _ZIPOS_ATOMIC(x) _Atomic(x)
+#else
+#define _ZIPOS_ATOMIC(x) x
+#endif
+
 struct stat;
 struct iovec;
 struct Zipos;
@@ -21,8 +27,8 @@ struct ZiposHandle {
   size_t size;
   size_t mapsize;
   size_t cfile;
-  _Atomic(size_t) refs;
-  _Atomic(size_t) pos;
+  _ZIPOS_ATOMIC(size_t) refs;
+  _ZIPOS_ATOMIC(size_t) pos;
   uint8_t *mem;
   uint8_t data[];
 };
@@ -34,7 +40,6 @@ struct Zipos {
   uint64_t dev;
   size_t *index;
   size_t records;
-  struct ZiposHandle *freelist;
 };
 
 int __zipos_close(int);
diff --git a/libc/sock/BUILD.mk b/libc/sock/BUILD.mk
index bd74fe141..3b8982eae 100644
--- a/libc/sock/BUILD.mk
+++ b/libc/sock/BUILD.mk
@@ -32,9 +32,9 @@ LIBC_SOCK_A_DIRECTDEPS =			\
 	LIBC_NEXGEN32E				\
 	LIBC_NT_ADVAPI32			\
 	LIBC_NT_IPHLPAPI			\
-	LIBC_NT_IPHLPAPI			\
 	LIBC_NT_KERNEL32			\
 	LIBC_NT_NTDLL				\
+	LIBC_NT_REALTIME			\
 	LIBC_NT_WS2_32				\
 	LIBC_RUNTIME				\
 	LIBC_STDIO				\
diff --git a/libc/sock/accept-nt.c b/libc/sock/accept-nt.c
index 9aa702760..1fef186d8 100644
--- a/libc/sock/accept-nt.c
+++ b/libc/sock/accept-nt.c
@@ -16,116 +16,74 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/atomic.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/sigset.internal.h"
-#include "libc/cosmo.h"
+#include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/errno.h"
-#include "libc/nt/enum/wsaid.h"
+#include "libc/nt/errors.h"
+#include "libc/nt/struct/pollfd.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
-#include "libc/sock/struct/sockaddr.h"
-#include "libc/sock/wsaid.internal.h"
-#include "libc/str/str.h"
+#include "libc/sock/syscall_fd.internal.h"
+#include "libc/sysv/consts/fio.h"
 #include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/poll.h"
 #include "libc/sysv/consts/sock.h"
 #include "libc/sysv/consts/sol.h"
-#include "libc/thread/thread.h"
+#include "libc/sysv/errfuns.h"
 #ifdef __x86_64__
 
-__msabi extern typeof(__sys_setsockopt_nt) *const __imp_setsockopt;
-__msabi extern typeof(__sys_closesocket_nt) *const __imp_closesocket;
+__msabi extern typeof(__sys_ioctlsocket_nt) *const __imp_ioctlsocket;
 
-union AcceptExAddr {
-  struct sockaddr_storage addr;
-  char buf[sizeof(struct sockaddr_storage) + 16];
-};
-
-struct AcceptExBuffer {
-  union AcceptExAddr local;
-  union AcceptExAddr remote;
-};
-
-struct AcceptResources {
+textwindows static int sys_accept_nt_impl(struct Fd *f,
+                                          struct sockaddr_storage *addr,
+                                          int accept4_flags,
+                                          sigset_t waitmask) {
   int64_t handle;
-};
-
-struct AcceptArgs {
-  int64_t listensock;
-  struct AcceptExBuffer *buffer;
-};
-
-static struct {
-  atomic_uint once;
-  bool32 (*__msabi lpAcceptEx)(
-      int64_t sListenSocket, int64_t sAcceptSocket,
-      void *out_lpOutputBuffer /*[recvlen+local+remoteaddrlen]*/,
-      uint32_t dwReceiveDataLength, uint32_t dwLocalAddressLength,
-      uint32_t dwRemoteAddressLength, uint32_t *out_lpdwBytesReceived,
-      struct NtOverlapped *inout_lpOverlapped);
-} g_acceptex;
-
-static void acceptex_init(void) {
-  static struct NtGuid AcceptExGuid = WSAID_ACCEPTEX;
-  g_acceptex.lpAcceptEx = __get_wsaid(&AcceptExGuid);
-}
-
-static void sys_accept_nt_unwind(void *arg) {
-  struct AcceptResources *resources = arg;
-  if (resources->handle != -1) {
-    __imp_closesocket(resources->handle);
-  }
-}
-
-static int sys_accept_nt_start(int64_t handle, struct NtOverlapped *overlap,
-                               uint32_t *flags, void *arg) {
-  struct AcceptArgs *args = arg;
-  cosmo_once(&g_acceptex.once, acceptex_init);
-  if (g_acceptex.lpAcceptEx(args->listensock, handle, args->buffer, 0,
-                            sizeof(args->buffer->local),
-                            sizeof(args->buffer->remote), 0, overlap)) {
-    return 0;
-  } else {
-    return -1;
-  }
-}
-
-textwindows int sys_accept_nt(struct Fd *f, struct sockaddr_storage *addr,
-                              int accept4_flags) {
   int client = -1;
-  sigset_t m = __sig_block();
-  struct AcceptResources resources = {-1};
-  pthread_cleanup_push(sys_accept_nt_unwind, &resources);
 
-  // creates resources for child socket
-  // inherit the listener configuration
-  if ((resources.handle = WSASocket(f->family, f->type, f->protocol, 0, 0,
-                                    kNtWsaFlagOverlapped)) == -1) {
-    client = __winsockerr();
-    goto Finish;
+  // accepting sockets must always be non-blocking at the os level. this
+  // is because WSAAccept doesn't support overlapped i/o operations. the
+  // AcceptEx function claims to support overlapped i/o however it can't
+  // be canceled by CancelIoEx, which makes it quite useless to us sadly
+  // this can't be called in listen(), because then fork() will break it
+  uint32_t mode = 1;
+  if (__imp_ioctlsocket(f->handle, FIONBIO, &mode))
+    return __winsockerr();
+
+  for (;;) {
+
+    // perform non-blocking accept
+    int32_t addrsize = sizeof(*addr);
+    struct sockaddr *paddr = (struct sockaddr *)addr;
+    if ((handle = WSAAccept(f->handle, paddr, &addrsize, 0, 0)) != -1)
+      break;
+
+    // return on genuine errors
+    uint32_t err = WSAGetLastError();
+    if (err != WSAEWOULDBLOCK) {
+      errno = __dos2errno(err);
+      if (errno == ECONNRESET)
+        errno = ECONNABORTED;
+      return -1;
+    }
+
+    // check for non-blocking
+    if (f->flags & O_NONBLOCK)
+      return eagain();
+
+    // check for signals and thread cancelation
+    // accept() will restart if SA_RESTART is used
+    if (__sigcheck(waitmask, true) == -1)
+      return -1;
+
+    // time to block
+    struct sys_pollfd_nt fds[1] = {{f->handle, POLLIN}};
+    if (WSAPoll(fds, 1, POLL_INTERVAL_MS) == -1)
+      return __winsockerr();
   }
 
-  // accept network connection
-  // this operation can re-enter, interrupt, cancel, block, timeout, etc.
-  struct AcceptExBuffer buffer;
-  ssize_t bytes_received = __winsock_block(
-      resources.handle, 0, !!(f->flags & O_NONBLOCK), f->rcvtimeo, m,
-      sys_accept_nt_start, &(struct AcceptArgs){f->handle, &buffer});
-  if (bytes_received == -1) {
-    __imp_closesocket(resources.handle);
-    goto Finish;
-  }
-
-  // inherit properties of listening socket
-  // errors ignored as if f->handle was created before forking
-  // this fails with WSAENOTSOCK, see
-  // https://github.com/jart/cosmopolitan/issues/1174
-  __imp_setsockopt(resources.handle, SOL_SOCKET, kNtSoUpdateAcceptContext,
-                   &f->handle, sizeof(f->handle));
-
   // create file descriptor for new socket
   // don't inherit the file open mode bits
   int oflags = 0;
@@ -141,18 +99,18 @@ textwindows int sys_accept_nt(struct Fd *f, struct sockaddr_storage *addr,
   g_fds.p[client].protocol = f->protocol;
   g_fds.p[client].sndtimeo = f->sndtimeo;
   g_fds.p[client].rcvtimeo = f->rcvtimeo;
-  g_fds.p[client].handle = resources.handle;
-  resources.handle = -1;
-  memcpy(addr, &buffer.remote.addr, sizeof(*addr));
+  g_fds.p[client].handle = handle;
   g_fds.p[client].kind = kFdSocket;
-
-Finish:
-  pthread_cleanup_pop(false);
-  __sig_unblock(m);
-  if (client == -1 && errno == ECONNRESET) {
-    errno = ECONNABORTED;
-  }
   return client;
 }
 
+textwindows int sys_accept_nt(struct Fd *f, struct sockaddr_storage *addr,
+                              int accept4_flags) {
+  int rc;
+  BLOCK_SIGNALS;
+  rc = sys_accept_nt_impl(f, addr, accept4_flags, _SigMask);
+  ALLOW_SIGNALS;
+  return rc;
+}
+
 #endif /* __x86_64__ */
diff --git a/libc/sock/accept.c b/libc/sock/accept.c
index 882f38752..02f5fba31 100644
--- a/libc/sock/accept.c
+++ b/libc/sock/accept.c
@@ -22,6 +22,9 @@
 /**
  * Creates client socket file descriptor for incoming connection.
  *
+ * On Windows, when this function blocks, there may be a 10 millisecond
+ * delay on the handling of signals or thread cancelation.
+ *
  * @param fd is the server socket file descriptor
  * @param opt_out_addr will receive the remote address
  * @param opt_inout_addrsize provides and receives addr's byte length
diff --git a/libc/sock/accept4-sysv.c b/libc/sock/accept4-sysv.c
index 20ed11c37..86065680e 100644
--- a/libc/sock/accept4-sysv.c
+++ b/libc/sock/accept4-sysv.c
@@ -40,7 +40,7 @@ int sys_accept4(int server, struct sockaddr_storage *addr, int flags) {
     if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
       return einval();
     if ((client = __sys_accept(server, addr, &size, 0)) != -1) {
-      // __sys_accept() has inconsistent flag inheritence across platforms
+      // __sys_accept() has inconsistent flag inheritance across platforms
       // this is one of the issues that accept4() was invented for solving
       unassert((file_mode = __sys_fcntl(client, F_GETFD)) != -1);
       unassert(!__sys_fcntl(client, F_SETFD,
diff --git a/libc/sock/accept4.c b/libc/sock/accept4.c
index 5aee5e465..ded323600 100644
--- a/libc/sock/accept4.c
+++ b/libc/sock/accept4.c
@@ -19,7 +19,7 @@
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/sockaddr.h"
@@ -30,12 +30,23 @@
 /**
  * Creates client socket file descriptor for incoming connection.
  *
+ * When `fd` is in `O_NONBLOCK` mode, this function will raise `EAGAIN`
+ * when no client is available to accept. To wait until a client exists
+ * the poll() function may be called using `POLLIN`.
+ *
+ * On Linux, your `SO_RCVTIMEO` will timeout accept4(). Other OSes (i.e.
+ * Windows, MacOS, and BSDs) do not support this and will block forever.
+ *
+ * On Windows, when this function blocks, there may be a 10 millisecond
+ * delay on the handling of signals or thread cancelation.
+ *
  * @param fd is the server socket file descriptor
  * @param opt_out_addr will receive the remote address
  * @param opt_inout_addrsize provides and receives out_addr's byte length
  * @param flags can have SOCK_{CLOEXEC,NONBLOCK}, which may apply to
  *     both the newly created socket and the server one
  * @return client fd which needs close(), or -1 w/ errno
+ * @raise EAGAIN if `O_NONBLOCK` and no clients pending
  * @cancelationpoint
  * @asyncsignalsafe
  * @restartable (unless SO_RCVTIMEO)
diff --git a/libc/sock/bind.c b/libc/sock/bind.c
index 5ff0ff37b..8401776f9 100644
--- a/libc/sock/bind.c
+++ b/libc/sock/bind.c
@@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/sockaddr.h"
diff --git a/libc/sock/closesocket-nt.c b/libc/sock/closesocket-nt.c
index ed6d41e97..1084ac363 100644
--- a/libc/sock/closesocket-nt.c
+++ b/libc/sock/closesocket-nt.c
@@ -16,8 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/weaken.h"
-#include "libc/mem/mem.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
@@ -32,9 +30,6 @@ __msabi extern typeof(__sys_closesocket_nt) *const __imp_closesocket;
  * This function should only be called by close().
  */
 textwindows int sys_closesocket_nt(struct Fd *f) {
-  if (_weaken(sys_connect_nt_cleanup)) {
-    _weaken(sys_connect_nt_cleanup)(f, true);
-  }
   if (!__imp_closesocket(f->handle)) {
     return 0;
   } else {
diff --git a/libc/sock/connect-nt.c b/libc/sock/connect-nt.c
index ce1951452..473066d0e 100644
--- a/libc/sock/connect-nt.c
+++ b/libc/sock/connect-nt.c
@@ -16,90 +16,46 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/atomic.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/calls/internal.h"
+#include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
-#include "libc/cosmo.h"
+#include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/errno.h"
-#include "libc/mem/mem.h"
-#include "libc/nt/enum/wsaid.h"
+#include "libc/macros.h"
 #include "libc/nt/errors.h"
-#include "libc/nt/struct/guid.h"
-#include "libc/nt/struct/overlapped.h"
-#include "libc/nt/thread.h"
+#include "libc/nt/struct/fdset.h"
+#include "libc/nt/struct/pollfd.h"
+#include "libc/nt/struct/timeval.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/struct/sockaddr.h"
 #include "libc/sock/syscall_fd.internal.h"
-#include "libc/sock/wsaid.internal.h"
+#include "libc/sysv/consts/fio.h"
 #include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/poll.h"
+#include "libc/sysv/consts/so.h"
 #include "libc/sysv/consts/sol.h"
 #include "libc/sysv/errfuns.h"
-
 #ifdef __x86_64__
-#include "libc/sock/yoink.inc"
 
-__msabi extern typeof(__sys_setsockopt_nt) *const __imp_setsockopt;
+#define UNCONNECTED 0
+#define CONNECTING  1
+#define CONNECTED   2
 
-struct ConnectArgs {
-  const void *addr;
-  uint32_t addrsize;
-};
+__msabi extern typeof(__sys_getsockopt_nt) *const __imp_getsockopt;
+__msabi extern typeof(__sys_ioctlsocket_nt) *const __imp_ioctlsocket;
+__msabi extern typeof(__sys_select_nt) *const __imp_select;
 
-static struct {
-  atomic_uint once;
-  bool32 (*__msabi lpConnectEx)(int64_t hSocket, const struct sockaddr *name,
-                                int namelen, const void *opt_lpSendBuffer,
-                                uint32_t dwSendDataLength,
-                                uint32_t *opt_out_lpdwBytesSent,
-                                struct NtOverlapped *lpOverlapped);
-} g_connectex;
+textwindows static int sys_connect_nt_impl(struct Fd *f, const void *addr,
+                                           uint32_t addrsize,
+                                           sigset_t waitmask) {
 
-static void connectex_init(void) {
-  static struct NtGuid ConnectExGuid = WSAID_CONNECTEX;
-  g_connectex.lpConnectEx = __get_wsaid(&ConnectExGuid);
-}
+  // check if already connected
+  if (f->connecting == 2)
+    return eisconn();
 
-void sys_connect_nt_cleanup(struct Fd *f, bool cancel) {
-  struct NtOverlapped *overlap;
-  if ((overlap = f->connect_op)) {
-    uint32_t got, flags;
-    if (cancel)
-      CancelIoEx(f->handle, overlap);
-    if (WSAGetOverlappedResult(f->handle, overlap, &got, cancel, &flags) ||
-        WSAGetLastError() != kNtErrorIoIncomplete) {
-      WSACloseEvent(overlap->hEvent);
-      free(overlap);
-      f->connect_op = 0;
-    }
-  }
-}
-
-static int sys_connect_nt_start(int64_t hSocket,
-                                struct NtOverlapped *lpOverlapped,
-                                uint32_t *flags, void *arg) {
-  struct ConnectArgs *args = arg;
-  if (g_connectex.lpConnectEx(hSocket, args->addr, args->addrsize, 0, 0, 0,
-                              lpOverlapped)) {
-    return 0;
-  } else {
-    return -1;
-  }
-}
-
-static textwindows int sys_connect_nt_impl(struct Fd *f, const void *addr,
-                                           uint32_t addrsize, sigset_t mask) {
-
-  // get connect function from winsock api
-  cosmo_once(&g_connectex.once, connectex_init);
-
-  // fail if previous connect() is still in progress
-  if (f->connect_op)
-    return ealready();
-
-  // ConnectEx() requires bind() be called beforehand
+  // winsock requires bind() be called beforehand
   if (!f->isbound) {
     struct sockaddr_storage ss = {0};
     ss.ss_family = ((struct sockaddr *)addr)->sa_family;
@@ -107,55 +63,121 @@ static textwindows int sys_connect_nt_impl(struct Fd *f, const void *addr,
       return -1;
   }
 
-  // perform normal connect
-  if (!(f->flags & O_NONBLOCK)) {
-    ssize_t rc = __winsock_block(f->handle, 0, false, f->sndtimeo, mask,
-                                 sys_connect_nt_start,
-                                 &(struct ConnectArgs){addr, addrsize});
-    if (rc == -1 && errno == EAGAIN) {
-      // return ETIMEDOUT if SO_SNDTIMEO elapsed
-      // note that Linux will return EINPROGRESS
-      errno = etimedout();
-    } else if (!rc) {
-      __imp_setsockopt(f->handle, SOL_SOCKET, kNtSoUpdateConnectContext, 0, 0);
+  if (f->connecting == UNCONNECTED) {
+
+    // make sure winsock is in non-blocking mode
+    uint32_t mode = 1;
+    if (__imp_ioctlsocket(f->handle, FIONBIO, &mode))
+      return __winsockerr();
+
+    // perform non-blocking connect
+    if (!WSAConnect(f->handle, addr, addrsize, 0, 0, 0, 0)) {
+      f->connecting = CONNECTED;
+      return 0;
+    }
+
+    // check for errors
+    switch (WSAGetLastError()) {
+      case WSAEISCONN:
+        f->connecting = CONNECTED;
+        return eisconn();
+      case WSAEALREADY:
+        f->connecting = CONNECTING;
+        break;
+      case WSAEWOULDBLOCK:
+        break;
+      default:
+        return __winsockerr();
+    }
+
+    // handle non-blocking
+    if (f->flags & O_NONBLOCK) {
+      if (f->connecting == UNCONNECTED) {
+        f->connecting = CONNECTING;
+        return einprogress();
+      } else {
+        return ealready();
+      }
+    } else {
+      f->connecting = CONNECTING;
     }
-    return rc;
   }
 
-  // perform nonblocking connect(), i.e.
-  // 1. connect(O_NONBLOCK) → EINPROGRESS
-  // 2. poll(POLLOUT)
-  bool32 ok;
-  struct NtOverlapped *overlap = calloc(1, sizeof(struct NtOverlapped));
-  if (!overlap)
-    return -1;
-  overlap->hEvent = WSACreateEvent();
-  ok = g_connectex.lpConnectEx(f->handle, addr, addrsize, 0, 0, 0, overlap);
-  if (ok) {
-    uint32_t dwBytes, dwFlags;
-    ok = WSAGetOverlappedResult(f->handle, overlap, &dwBytes, false, &dwFlags);
-    WSACloseEvent(overlap->hEvent);
-    free(overlap);
-    if (!ok) {
-      return __winsockerr();
+  for (;;) {
+
+    // check for signals and thread cancelation
+    // connect() will restart if SA_RESTART is used
+    if (!(f->flags & O_NONBLOCK))
+      if (__sigcheck(waitmask, true) == -1)
+        return -1;
+
+    //
+    // "Use select to determine the completion of the connection request
+    //  by checking if the socket is writable."
+    //
+    //                  —Quoth MSDN § WSAConnect function
+    //
+    // "If a socket is processing a connect call (nonblocking), failure
+    //  of the connect attempt is indicated in exceptfds (application
+    //  must then call getsockopt SO_ERROR to determine the error value
+    //  to describe why the failure occurred). This document does not
+    //  define which other errors will be included."
+    //
+    //                  —Quoth MSDN § select function
+    //
+    struct NtFdSet wrfds;
+    struct NtFdSet exfds;
+    struct NtTimeval timeout;
+    wrfds.fd_count = 1;
+    wrfds.fd_array[0] = f->handle;
+    exfds.fd_count = 1;
+    exfds.fd_array[0] = f->handle;
+    if (f->flags & O_NONBLOCK) {
+      timeout.tv_sec = 0;
+      timeout.tv_usec = 0;
+    } else {
+      timeout.tv_sec = POLL_INTERVAL_MS / 1000;
+      timeout.tv_usec = POLL_INTERVAL_MS % 1000 * 1000;
     }
-    __imp_setsockopt(f->handle, SOL_SOCKET, kNtSoUpdateConnectContext, 0, 0);
+    int ready = __imp_select(1, 0, &wrfds, &exfds, &timeout);
+    if (ready == -1)
+      return __winsockerr();
+
+    // check if we still need more time
+    if (!ready) {
+      if (f->flags & O_NONBLOCK) {
+        return etimedout();
+      } else {
+        continue;
+      }
+    }
+
+    // check if connect failed
+    if (exfds.fd_count) {
+      int err;
+      uint32_t len = sizeof(err);
+      if (__imp_getsockopt(f->handle, SOL_SOCKET, SO_ERROR, &err, &len) == -1)
+        return __winsockerr();
+      if (!err)
+        return eio();  // should be impossible
+      errno = __dos2errno(err);
+      return -1;
+    }
+
+    // handle successful connection
+    if (!wrfds.fd_count)
+      return eio();  // should be impossible
+    f->connecting = CONNECTED;
     return 0;
-  } else if (WSAGetLastError() == kNtErrorIoPending) {
-    f->connect_op = overlap;
-    return einprogress();
-  } else {
-    WSACloseEvent(overlap->hEvent);
-    free(overlap);
-    return __winsockerr();
   }
 }
 
 textwindows int sys_connect_nt(struct Fd *f, const void *addr,
                                uint32_t addrsize) {
-  sigset_t mask = __sig_block();
-  int rc = sys_connect_nt_impl(f, addr, addrsize, mask);
-  __sig_unblock(mask);
+  int rc;
+  BLOCK_SIGNALS;
+  rc = sys_connect_nt_impl(f, addr, addrsize, _SigMask);
+  ALLOW_SIGNALS;
   return rc;
 }
 
diff --git a/libc/sock/connect.c b/libc/sock/connect.c
index 9453c62d5..8426c2102 100644
--- a/libc/sock/connect.c
+++ b/libc/sock/connect.c
@@ -18,9 +18,9 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/strace.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/sockaddr.h"
@@ -31,11 +31,28 @@
 /**
  * Connects socket to remote end.
  *
- * ProTip: Connectionless sockets, e.g. UDP, can be connected too. The
- * benefit is not needing to specify the remote address on each send. It
- * also means getsockname() can be called to retrieve routing details.
+ * When `fd` is in `O_NONBLOCK` mode, this raises `EINPROGRESS`. To wait
+ * for establishment poll() function may be called using `POLLOUT`. Then
+ * `SO_ERROR` may be used to check for errors.
+ *
+ * Connectionless sockets, e.g. UDP, can be connected too. The benefit
+ * is not needing to specify the remote address on each send. It also
+ * means getsockname() can be called to retrieve routing details.
+ *
+ * On Linux, your `SO_SNDTIMEO` will timeout connect(). Other OSes (i.e.
+ * Windows, MacOS, and BSDs) do not support this and will block forever.
+ *
+ * On Windows, when this function blocks, there may be a 10 millisecond
+ * delay on the handling of signals or thread cancelation.
  *
  * @return 0 on success or -1 w/ errno
+ * @raise EINPROGRESS if `O_NONBLOCK` and connecting process initiated
+ * @raise EALREADY if a `O_NONBLOCK` connecting already in flight
+ * @raise EADDRINUSE if local address is already in use
+ * @raise EINTR if a signal handler was called instead
+ * @raise ENETUNREACH if network is unreachable
+ * @raise ETIMEDOUT if connection timed out
+ * @raise EISCONN if already connected
  * @cancelationpoint
  * @asyncsignalsafe
  * @restartable (unless SO_RCVTIMEO)
diff --git a/libc/sock/epoll.c b/libc/sock/epoll.c
deleted file mode 100644
index 1be06e4d5..000000000
--- a/libc/sock/epoll.c
+++ /dev/null
@@ -1,1655 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  wepoll                                                                      │
-│  https://github.com/piscisaureus/wepoll                                      │
-│                                                                              │
-│  Copyright 2012-2020, Bert Belder <bertbelder@gmail.com>                     │
-│  All rights reserved.                                                        │
-│                                                                              │
-│  Redistribution and use in source and binary forms, with or without          │
-│  modification, are permitted provided that the following conditions are      │
-│  met:                                                                        │
-│                                                                              │
-│    * Redistributions of source code must retain the above copyright          │
-│      notice, this list of conditions and the following disclaimer.           │
-│                                                                              │
-│    * 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.    │
-│                                                                              │
-│  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT        │
-│  OWNER 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.        │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/sock/epoll.h"
-#include "libc/assert.h"
-#include "libc/calls/cp.internal.h"
-#include "libc/calls/internal.h"
-#include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigset.internal.h"
-#include "libc/calls/syscall_support-sysv.internal.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "libc/mem/mem.h"
-#include "libc/nt/enum/accessmask.h"
-#include "libc/nt/enum/afd.h"
-#include "libc/nt/enum/filesharemode.h"
-#include "libc/nt/enum/ioctl.h"
-#include "libc/nt/enum/keyedevent.h"
-#include "libc/nt/enum/sio.h"
-#include "libc/nt/enum/status.h"
-#include "libc/nt/enum/wait.h"
-#include "libc/nt/errors.h"
-#include "libc/nt/files.h"
-#include "libc/nt/iocp.h"
-#include "libc/nt/nt/file.h"
-#include "libc/nt/nt/key.h"
-#include "libc/nt/ntdll.h"
-#include "libc/nt/process.h"
-#include "libc/nt/runtime.h"
-#include "libc/nt/struct/afd.h"
-#include "libc/nt/struct/criticalsection.h"
-#include "libc/nt/struct/objectattributes.h"
-#include "libc/nt/struct/overlappedentry.h"
-#include "libc/nt/struct/unicodestring.h"
-#include "libc/nt/synchronization.h"
-#include "libc/nt/winsock.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sock/internal.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/epoll.h"
-#include "libc/sysv/consts/sig.h"
-#include "libc/sysv/errfuns.h"
-
-/**
- * @fileoverview epoll
- *
- * This is an alternative to poll() that's popular for event driven
- * network servers that want >10,000 sockets per machine and don't do
- * cpu bound computations that would otherwise block the event loop.
- *
- * This works on Linux and is polyfilled on Windows. It's worth noting
- * that these polyfills depend on Microsoft's internal APIs. However
- * these particular NTDLL APIs are also used by libuv, nodejs, etc. so
- * we're reasonably certain Microsoft has compatibility policies in
- * place where they've promised not to break them.
- *
- * TODO(jart): Polyfill kqueue for XNU/FreeBSD/OpenBSD.
- */
-
-__notice(wepoll_notice, "\
-wepoll (BSD-2)\n\
-Copyright 2012-2020 Bert Belder\n\
-https://github.com/piscisaureus/wepoll");
-
-#define MAX_GROUP_SIZE 32
-
-#define REFLOCK__REF          0x00000001
-#define REFLOCK__REF_MASK     0x0fffffff
-#define REFLOCK__DESTROY      0x10000000
-#define REFLOCK__DESTROY_MASK 0xf0000000
-#define REFLOCK__POISON       0x300dead0
-
-#define KNOWN_EVENTS                                                   \
-  (EPOLLIN | EPOLLPRI | EPOLLOUT | EPOLLERR | EPOLLHUP | EPOLLRDNORM | \
-   EPOLLRDBAND | EPOLLWRNORM | EPOLLWRBAND | EPOLLMSG | EPOLLRDHUP)
-
-#define RTL_CONSTANT_STRING(s) \
-  { sizeof(s) - sizeof((s)[0]), sizeof(s), s }
-
-#define RTL_CONSTANT_OBJECT_ATTRIBUTES(ObjectName, Attributes) \
-  { sizeof(struct NtObjectAttributes), 0, ObjectName, Attributes, NULL, NULL }
-
-#define RETURN_MAP_ERROR(value) \
-  do {                          \
-    err_map_win_error();        \
-    return value;               \
-  } while (0)
-
-#define RETURN_SET_ERROR(value, error) \
-  do {                                 \
-    err_set_win_error(error);          \
-    return value;                      \
-  } while (0)
-
-#define CONTAINOF(ptr, type, member) \
-  ((type *)((uintptr_t)(ptr) - offsetof(type, member)))
-
-#define TREE__ROTATE(cis, trans)       \
-  struct TreeNode *p = node;           \
-  struct TreeNode *q = node->trans;    \
-  struct TreeNode *parent = p->parent; \
-  if (parent) {                        \
-    if (parent->left == p)             \
-      parent->left = q;                \
-    else                               \
-      parent->right = q;               \
-  } else {                             \
-    tree->root = q;                    \
-  }                                    \
-  q->parent = parent;                  \
-  p->parent = q;                       \
-  p->trans = q->cis;                   \
-  if (p->trans)                        \
-    p->trans->parent = p;              \
-  q->cis = p;
-
-#define TREE__INSERT_OR_DESCEND(side) \
-  if (parent->side) {                 \
-    parent = parent->side;            \
-  } else {                            \
-    parent->side = node;              \
-    break;                            \
-  }
-
-#define TREE__REBALANCE_AFTER_INSERT(cis, trans) \
-  struct TreeNode *grandparent = parent->parent; \
-  struct TreeNode *uncle = grandparent->trans;   \
-  if (uncle && uncle->red) {                     \
-    parent->red = uncle->red = false;            \
-    grandparent->red = true;                     \
-    node = grandparent;                          \
-  } else {                                       \
-    if (node == parent->trans) {                 \
-      tree__rotate_##cis(tree, parent);          \
-      node = parent;                             \
-      parent = node->parent;                     \
-    }                                            \
-    parent->red = false;                         \
-    grandparent->red = true;                     \
-    tree__rotate_##trans(tree, grandparent);     \
-  }
-
-#define TREE__REBALANCE_AFTER_REMOVE(cis, trans)   \
-  struct TreeNode *sibling = parent->trans;        \
-  if (sibling->red) {                              \
-    sibling->red = false;                          \
-    parent->red = true;                            \
-    tree__rotate_##cis(tree, parent);              \
-    sibling = parent->trans;                       \
-  }                                                \
-  if ((sibling->left && sibling->left->red) ||     \
-      (sibling->right && sibling->right->red)) {   \
-    if (!sibling->trans || !sibling->trans->red) { \
-      sibling->cis->red = false;                   \
-      sibling->red = true;                         \
-      tree__rotate_##trans(tree, sibling);         \
-      sibling = parent->trans;                     \
-    }                                              \
-    sibling->red = parent->red;                    \
-    parent->red = sibling->trans->red = false;     \
-    tree__rotate_##cis(tree, parent);              \
-    node = tree->root;                             \
-    break;                                         \
-  }                                                \
-  sibling->red = true;
-
-#define tree_root(t)                         (t)->root
-#define port_state_to_handle_tree_node(p)    (&(p)->handle_tree_node)
-#define sock_state_from_queue_node(q)        CONTAINOF(q, struct SockState, queue_node)
-#define sock_state_to_queue_node(s)          (&(s)->queue_node)
-#define sock_state_from_tree_node(t)         CONTAINOF(t, struct SockState, tree_node)
-#define sock_state_to_tree_node(s)           (&(s)->tree_node)
-#define poll_group_from_queue_node(q)        CONTAINOF(q, struct PollGroup, queue_node)
-#define poll_group_get_afd_device_handle(pg) (pg)->afd_device_handle
-
-enum PollStatus {
-  kPollIdle,
-  kPollPending,
-  kPollCancelled,
-};
-
-struct RefLock {
-  int state;
-};
-
-struct TreeNode {
-  struct TreeNode *left;
-  struct TreeNode *right;
-  struct TreeNode *parent;
-  uintptr_t key;
-  bool red;
-};
-
-struct Tree {
-  struct TreeNode *root;
-};
-
-struct TsTree {
-  struct Tree tree;
-  intptr_t lock;
-};
-
-struct TsTreeNode {
-  struct TreeNode tree_node;
-  struct RefLock reflock;
-};
-
-struct QueueNode {
-  struct QueueNode *prev;
-  struct QueueNode *next;
-};
-
-struct Queue {
-  struct QueueNode head;
-};
-
-struct PortState {
-  int64_t iocp_handle;
-  struct Tree sock_tree;
-  struct Queue sock_update_queue;
-  struct Queue sock_deleted_queue;
-  struct Queue poll_group_queue;
-  struct TsTreeNode handle_tree_node;
-  struct NtCriticalSection lock;
-  size_t active_poll_count;
-};
-
-struct PollGroup {
-  struct PortState *port_state;
-  struct QueueNode queue_node;
-  int64_t afd_device_handle;
-  size_t group_size;
-};
-
-struct SockState {
-  struct NtIoStatusBlock io_status_block;
-  struct NtAfdPollInfo poll_info;
-  struct QueueNode queue_node;
-  struct TreeNode tree_node;
-  struct PollGroup *poll_group;
-  int64_t base_socket;
-  epoll_data_t user_data;
-  uint32_t user_events;
-  uint32_t pending_events;
-  enum PollStatus poll_status;
-  bool delete_pending;
-};
-
-static const struct NtUnicodeString afd__device_name =
-    RTL_CONSTANT_STRING(u"\\Device\\Afd\\Wepoll");
-
-static const struct NtObjectAttributes afd__device_attributes =
-    RTL_CONSTANT_OBJECT_ATTRIBUTES(&afd__device_name, 0);
-
-static int64_t reflock__keyed_event;
-static struct TsTree epoll__handle_tree;
-
-static textwindows void err_map_win_error(void) {
-  errno = __dos2errno(GetLastError());
-}
-
-static textwindows void err_set_win_error(uint32_t error) {
-  SetLastError(error);
-  errno = __dos2errno(error);
-}
-
-static textwindows int err_check_handle(int64_t handle) {
-  uint32_t flags;
-  /* GetHandleInformation() succeeds when passed INVALID_HANDLE_VALUE,
-     so check for this condition explicitly. */
-  if (handle == kNtInvalidHandleValue) {
-    RETURN_SET_ERROR(-1, kNtErrorInvalidHandle);
-  }
-  if (!GetHandleInformation(handle, &flags)) {
-    RETURN_MAP_ERROR(-1);
-  }
-  return 0;
-}
-
-static textwindows void tree_init(struct Tree *tree) {
-  bzero(tree, sizeof *tree);
-}
-
-static textwindows void ts_tree_init(struct TsTree *ts_tree) {
-  tree_init(&ts_tree->tree);
-  InitializeSRWLock(&ts_tree->lock);
-}
-
-static textwindows int reflock_global_init(void) {
-  NtStatus status;
-  if ((status = NtCreateKeyedEvent(&reflock__keyed_event,
-                                   kNtKeyedeventAllAccess, NULL, 0)) !=
-      kNtStatusSuccess) {
-    RETURN_SET_ERROR(-1, RtlNtStatusToDosError(status));
-  }
-  return 0;
-}
-
-static textwindows int epoll_global_init(void) {
-  ts_tree_init(&epoll__handle_tree);
-  return 0;
-}
-
-static textwindows int wepoll_init(void) {
-  static bool once;
-  static bool result;
-  if (!once) {
-    if (reflock_global_init() < 0 || epoll_global_init() < 0) {
-      result = false;
-    } else {
-      result = true;
-    }
-    once = true;
-  }
-  return result;
-}
-
-static textwindows int afd_create_device_handle(
-    int64_t iocp_handle, int64_t *afd_device_handle_out) {
-  NtStatus status;
-  int64_t afd_device_handle;
-  struct NtIoStatusBlock iosb;
-  /* By opening \Device\Afd without specifying any extended attributes,
-     we'll get a handle that lets us talk to the AFD driver, but that
-     doesn't have an *associated endpoint (so it's not a socket). */
-  status = NtCreateFile(&afd_device_handle, kNtSynchronize,
-                        &afd__device_attributes, &iosb, NULL, 0,
-                        kNtFileShareRead | kNtFileShareWrite, 1, 0, NULL, 0);
-  if (status != kNtStatusSuccess) {
-    RETURN_SET_ERROR(-1, RtlNtStatusToDosError(status));
-  }
-  if (!CreateIoCompletionPort(afd_device_handle, iocp_handle, 0, 0)) {
-    goto error;
-  }
-  if (!SetFileCompletionNotificationModes(afd_device_handle,
-                                          kNtFileSkipSetEventOnHandle)) {
-    goto error;
-  }
-  *afd_device_handle_out = afd_device_handle;
-  return 0;
-error:
-  CloseHandle(afd_device_handle);
-  RETURN_MAP_ERROR(-1);
-}
-
-static textwindows int afd_poll(int64_t afd_device_handle,
-                                struct NtAfdPollInfo *poll_info,
-                                struct NtIoStatusBlock *io_status_block) {
-  NtStatus status;
-  /* Blocking operation is not supported.*/
-  npassert(io_status_block);
-  io_status_block->Status = kNtStatusPending;
-  status =
-      NtDeviceIoControlFile(afd_device_handle, 0, NULL, io_status_block,
-                            io_status_block, kNtIoctlAfdPoll, poll_info,
-                            sizeof(*poll_info), poll_info, sizeof(*poll_info));
-  if (status == kNtStatusSuccess) {
-    return 0;
-  } else if (status == kNtStatusPending) {
-    RETURN_SET_ERROR(-1, kNtErrorIoPending);
-  } else {
-    RETURN_SET_ERROR(-1, RtlNtStatusToDosError(status));
-  }
-}
-
-static textwindows int afd_cancel_poll(
-    int64_t afd_device_handle, struct NtIoStatusBlock *io_status_block) {
-  NtStatus cancel_status;
-  struct NtIoStatusBlock cancel_iosb;
-  /* If the poll operation has already completed or has been cancelled
-     earlier, there's nothing left for us to do. */
-  if (io_status_block->Status != kNtStatusPending)
-    return 0;
-  cancel_status =
-      NtCancelIoFileEx(afd_device_handle, io_status_block, &cancel_iosb);
-  /* NtCancelIoFileEx() may return STATUS_NOT_FOUND if the operation completed
-     just before calling NtCancelIoFileEx(). This is not an error. */
-  if (cancel_status == kNtStatusSuccess || cancel_status == kNtStatusNotFound) {
-    return 0;
-  } else {
-    RETURN_SET_ERROR(-1, RtlNtStatusToDosError(cancel_status));
-  }
-}
-
-static textwindows void queue_node_init(struct QueueNode *node) {
-  node->prev = node;
-  node->next = node;
-}
-
-static textwindows void queue_init(struct Queue *queue) {
-  queue_node_init(&queue->head);
-}
-
-static textwindows void queue__detach_node(struct QueueNode *node) {
-  node->prev->next = node->next;
-  node->next->prev = node->prev;
-}
-
-forceinline bool queue_is_enqueued(const struct QueueNode *node) {
-  return node->prev != node;
-}
-
-forceinline bool queue_is_empty(const struct Queue *queue) {
-  return !queue_is_enqueued(&queue->head);
-}
-
-static textwindows struct QueueNode *queue_first(const struct Queue *queue) {
-  return !queue_is_empty(queue) ? queue->head.next : NULL;
-}
-
-static textwindows struct QueueNode *queue_last(const struct Queue *queue) {
-  return !queue_is_empty(queue) ? queue->head.prev : NULL;
-}
-
-static textwindows void queue_prepend(struct Queue *queue,
-                                      struct QueueNode *node) {
-  node->next = queue->head.next;
-  node->prev = &queue->head;
-  node->next->prev = node;
-  queue->head.next = node;
-}
-
-static textwindows void queue_append(struct Queue *queue,
-                                     struct QueueNode *node) {
-  node->next = &queue->head;
-  node->prev = queue->head.prev;
-  node->prev->next = node;
-  queue->head.prev = node;
-}
-
-static textwindows void queue_move_to_start(struct Queue *queue,
-                                            struct QueueNode *node) {
-  queue__detach_node(node);
-  queue_prepend(queue, node);
-}
-
-static textwindows void queue_move_to_end(struct Queue *queue,
-                                          struct QueueNode *node) {
-  queue__detach_node(node);
-  queue_append(queue, node);
-}
-
-static textwindows void queue_remove(struct QueueNode *node) {
-  queue__detach_node(node);
-  queue_node_init(node);
-}
-
-static textwindows struct PortState *port__alloc(void) {
-  struct PortState *port_state = malloc(sizeof *port_state);
-  if (!port_state)
-    RETURN_SET_ERROR(NULL, kNtErrorNotEnoughMemory);
-  return port_state;
-}
-
-static textwindows int64_t port__create_iocp(void) {
-  int64_t iocp_handle = CreateIoCompletionPort(kNtInvalidHandleValue, 0, 0, 0);
-  if (!iocp_handle)
-    RETURN_MAP_ERROR(0);
-  return iocp_handle;
-}
-
-static textwindows int port__close_iocp(struct PortState *port_state) {
-  int64_t iocp_handle = port_state->iocp_handle;
-  port_state->iocp_handle = 0;
-  if (!CloseHandle(iocp_handle))
-    RETURN_MAP_ERROR(-1);
-  return 0;
-}
-
-static textwindows void tree_node_init(struct TreeNode *node) {
-  bzero(node, sizeof *node);
-}
-
-static textwindows void reflock_init(struct RefLock *reflock) {
-  reflock->state = 0;
-}
-
-static textwindows void ts_tree_node_init(struct TsTreeNode *node) {
-  tree_node_init(&node->tree_node);
-  reflock_init(&node->reflock);
-}
-
-static textwindows void tree__rotate_left(struct Tree *tree,
-                                          struct TreeNode *node) {
-  TREE__ROTATE(left, right)
-}
-
-static textwindows void tree__rotate_right(struct Tree *tree,
-                                           struct TreeNode *node) {
-  TREE__ROTATE(right, left)
-}
-
-static textwindows int tree_add(struct Tree *tree, struct TreeNode *node,
-                                uintptr_t key) {
-  struct TreeNode *parent;
-  parent = tree->root;
-  if (parent) {
-    for (;;) {
-      if (key < parent->key) {
-        TREE__INSERT_OR_DESCEND(left)
-      } else if (key > parent->key) {
-        TREE__INSERT_OR_DESCEND(right)
-      } else {
-        return -1;
-      }
-    }
-  } else {
-    tree->root = node;
-  }
-  node->key = key;
-  node->left = node->right = NULL;
-  node->parent = parent;
-  node->red = true;
-  for (; parent && parent->red; parent = node->parent) {
-    if (parent == parent->parent->left) {
-      TREE__REBALANCE_AFTER_INSERT(left, right)
-    } else {
-      TREE__REBALANCE_AFTER_INSERT(right, left)
-    }
-  }
-  tree->root->red = false;
-  return 0;
-}
-
-static textwindows int ts_tree_add(struct TsTree *ts_tree,
-                                   struct TsTreeNode *node, uintptr_t key) {
-  int r;
-  AcquireSRWLockExclusive(&ts_tree->lock);
-  r = tree_add(&ts_tree->tree, &node->tree_node, key);
-  ReleaseSRWLockExclusive(&ts_tree->lock);
-  return r;
-}
-
-static textwindows void port__free(struct PortState *port) {
-  npassert(port);
-  free(port);
-}
-
-static textwindows struct PortState *port_new(int64_t *iocp_handle_out) {
-  struct PortState *port_state;
-  int64_t iocp_handle;
-  port_state = port__alloc();
-  if (!port_state)
-    goto err1;
-  iocp_handle = port__create_iocp();
-  if (!iocp_handle)
-    goto err2;
-  bzero(port_state, sizeof *port_state);
-  port_state->iocp_handle = iocp_handle;
-  tree_init(&port_state->sock_tree);
-  queue_init(&port_state->sock_update_queue);
-  queue_init(&port_state->sock_deleted_queue);
-  queue_init(&port_state->poll_group_queue);
-  ts_tree_node_init(&port_state->handle_tree_node);
-  InitializeCriticalSection(&port_state->lock);
-  *iocp_handle_out = iocp_handle;
-  return port_state;
-err2:
-  port__free(port_state);
-err1:
-  return NULL;
-}
-
-static textwindows int sock__cancel_poll(struct SockState *sock_state) {
-  npassert(sock_state->poll_status == kPollPending);
-  if (afd_cancel_poll(poll_group_get_afd_device_handle(sock_state->poll_group),
-                      &sock_state->io_status_block) < 0) {
-    return -1;
-  }
-  sock_state->poll_status = kPollCancelled;
-  sock_state->pending_events = 0;
-  return 0;
-}
-
-static textwindows void port_cancel_socket_update(
-    struct PortState *port_state, struct SockState *sock_state) {
-  if (!queue_is_enqueued(sock_state_to_queue_node(sock_state)))
-    return;
-  queue_remove(sock_state_to_queue_node(sock_state));
-}
-
-static textwindows struct TreeNode *tree_find(const struct Tree *tree,
-                                              uintptr_t key) {
-  struct TreeNode *node = tree->root;
-  while (node) {
-    if (key < node->key) {
-      node = node->left;
-    } else if (key > node->key) {
-      node = node->right;
-    } else {
-      return node;
-    }
-  }
-  return NULL;
-}
-
-static textwindows struct TsTreeNode *ts_tree__find_node(struct TsTree *ts_tree,
-                                                         uintptr_t key) {
-  struct TreeNode *tree_node = tree_find(&ts_tree->tree, key);
-  if (!tree_node)
-    return NULL;
-  return CONTAINOF(tree_node, struct TsTreeNode, tree_node);
-}
-
-static textwindows void tree_del(struct Tree *tree, struct TreeNode *node) {
-  bool red;
-  struct TreeNode *parent, *left, *right, *next;
-  parent = node->parent;
-  left = node->left;
-  right = node->right;
-  if (!left) {
-    next = right;
-  } else if (!right) {
-    next = left;
-  } else {
-    next = right;
-    while (next->left)
-      next = next->left;
-  }
-  if (parent) {
-    if (parent->left == node) {
-      parent->left = next;
-    } else {
-      parent->right = next;
-    }
-  } else {
-    tree->root = next;
-  }
-  if (left && right) {
-    red = next->red;
-    next->red = node->red;
-    next->left = left;
-    left->parent = next;
-    if (next != right) {
-      parent = next->parent;
-      next->parent = node->parent;
-      node = next->right;
-      parent->left = node;
-      next->right = right;
-      right->parent = next;
-    } else {
-      next->parent = parent;
-      parent = next;
-      node = next->right;
-    }
-  } else {
-    red = node->red;
-    node = next;
-  }
-  if (node)
-    node->parent = parent;
-  if (red)
-    return;
-  if (node && node->red) {
-    node->red = false;
-    return;
-  }
-  do {
-    if (node == tree->root)
-      break;
-    if (node == parent->left) {
-      TREE__REBALANCE_AFTER_REMOVE(left, right)
-    } else {
-      TREE__REBALANCE_AFTER_REMOVE(right, left)
-    }
-    node = parent;
-    parent = parent->parent;
-  } while (!node->red);
-  if (node)
-    node->red = false;
-}
-
-static textwindows void reflock__signal_event(void *address) {
-  NtStatus status =
-      NtReleaseKeyedEvent(reflock__keyed_event, address, false, NULL);
-  if (status != kNtStatusSuccess)
-    abort();
-}
-
-static textwindows void reflock__await_event(void *address) {
-  NtStatus status =
-      NtWaitForKeyedEvent(reflock__keyed_event, address, false, NULL);
-  if (status != kNtStatusSuccess)
-    abort();
-}
-
-static textwindows void reflock_ref(struct RefLock *reflock) {
-  long state = InterlockedAdd(&reflock->state, REFLOCK__REF);
-  /* Verify that the counter didn 't overflow and the lock isn' t destroyed.*/
-  npassert((state & REFLOCK__DESTROY_MASK) == 0);
-}
-
-static textwindows void reflock_unref(struct RefLock *reflock) {
-  long state = InterlockedAdd(&reflock->state, -REFLOCK__REF);
-  /* Verify that the lock was referenced and not already destroyed.*/
-  npassert((state & REFLOCK__DESTROY_MASK & ~REFLOCK__DESTROY) == 0);
-  if (state == REFLOCK__DESTROY)
-    reflock__signal_event(reflock);
-}
-
-static textwindows struct TsTreeNode *ts_tree_del_and_ref(
-    struct TsTree *ts_tree, uintptr_t key) {
-  struct TsTreeNode *ts_tree_node;
-  AcquireSRWLockExclusive(&ts_tree->lock);
-  ts_tree_node = ts_tree__find_node(ts_tree, key);
-  if (ts_tree_node != NULL) {
-    tree_del(&ts_tree->tree, &ts_tree_node->tree_node);
-    reflock_ref(&ts_tree_node->reflock);
-  }
-  ReleaseSRWLockExclusive(&ts_tree->lock);
-  return ts_tree_node;
-}
-
-static textwindows struct TsTreeNode *ts_tree_find_and_ref(
-    struct TsTree *ts_tree, uintptr_t key) {
-  struct TsTreeNode *ts_tree_node;
-  AcquireSRWLockShared(&ts_tree->lock);
-  ts_tree_node = ts_tree__find_node(ts_tree, key);
-  if (ts_tree_node != NULL)
-    reflock_ref(&ts_tree_node->reflock);
-  ReleaseSRWLockShared(&ts_tree->lock);
-  return ts_tree_node;
-}
-
-static textwindows void ts_tree_node_unref(struct TsTreeNode *node) {
-  reflock_unref(&node->reflock);
-}
-
-static textwindows void reflock_unref_and_destroy(struct RefLock *reflock) {
-  long state, ref_count;
-  state = InterlockedAdd(&reflock->state, REFLOCK__DESTROY - REFLOCK__REF);
-  ref_count = state & REFLOCK__REF_MASK;
-  /* Verify that the lock was referenced and not already destroyed. */
-  npassert((state & REFLOCK__DESTROY_MASK) == REFLOCK__DESTROY);
-  if (ref_count != 0)
-    reflock__await_event(reflock);
-  state = InterlockedExchange(&reflock->state, REFLOCK__POISON);
-  npassert(state == REFLOCK__DESTROY);
-}
-
-static textwindows void ts_tree_node_unref_and_destroy(
-    struct TsTreeNode *node) {
-  reflock_unref_and_destroy(&node->reflock);
-}
-
-static textwindows void port_unregister_socket(struct PortState *port_state,
-                                               struct SockState *sock_state) {
-  tree_del(&port_state->sock_tree, sock_state_to_tree_node(sock_state));
-}
-
-static textwindows void port_remove_deleted_socket(
-    struct PortState *port_state, struct SockState *sock_state) {
-  if (!queue_is_enqueued(sock_state_to_queue_node(sock_state)))
-    return;
-  queue_remove(sock_state_to_queue_node(sock_state));
-}
-
-static textwindows struct Queue *port_get_poll_group_queue(
-    struct PortState *port_state) {
-  return &port_state->poll_group_queue;
-}
-
-static textwindows void poll_group_release(struct PollGroup *poll_group) {
-  struct PortState *port_state = poll_group->port_state;
-  struct Queue *poll_group_queue = port_get_poll_group_queue(port_state);
-  poll_group->group_size--;
-  npassert(poll_group->group_size < MAX_GROUP_SIZE);
-  queue_move_to_end(poll_group_queue, &poll_group->queue_node);
-  /* Poll groups are currently only freed when the epoll port is closed. */
-}
-
-static textwindows void sock__free(struct SockState *sock_state) {
-  npassert(sock_state != NULL);
-  free(sock_state);
-}
-
-static textwindows void port_add_deleted_socket(struct PortState *port_state,
-                                                struct SockState *sock_state) {
-  if (queue_is_enqueued(sock_state_to_queue_node(sock_state)))
-    return;
-  queue_append(&port_state->sock_deleted_queue,
-               sock_state_to_queue_node(sock_state));
-}
-
-static textwindows int sock__delete(struct PortState *port_state,
-                                    struct SockState *sock_state, bool force) {
-  if (!sock_state->delete_pending) {
-    if (sock_state->poll_status == kPollPending) {
-      sock__cancel_poll(sock_state);
-    }
-    port_cancel_socket_update(port_state, sock_state);
-    port_unregister_socket(port_state, sock_state);
-    sock_state->delete_pending = true;
-  }
-  /* If the poll request still needs to complete, the sock_state object
-     can't be free'd yet. `sock_feed_event()` or `port_close()` will
-     take care of this later. */
-  if (force || sock_state->poll_status == kPollIdle) {
-    port_remove_deleted_socket(port_state, sock_state);
-    poll_group_release(sock_state->poll_group);
-    sock__free(sock_state);
-  } else {
-    /* Free the socket later.*/
-    port_add_deleted_socket(port_state, sock_state);
-  }
-  return 0;
-}
-
-static textwindows void sock_delete(struct PortState *port_state,
-                                    struct SockState *sock_state) {
-  sock__delete(port_state, sock_state, false);
-}
-
-static textwindows void sock_force_delete(struct PortState *port_state,
-                                          struct SockState *sock_state) {
-  sock__delete(port_state, sock_state, true);
-}
-
-static textwindows void poll_group_delete(struct PollGroup *poll_group) {
-  npassert(poll_group->group_size == 0);
-  CloseHandle(poll_group->afd_device_handle);
-  queue_remove(&poll_group->queue_node);
-  free(poll_group);
-}
-
-static textwindows int port_delete(struct PortState *port_state) {
-  struct TreeNode *tree_node;
-  struct QueueNode *queue_node;
-  struct SockState *sock_state;
-  struct PollGroup *poll_group;
-  /* At this point the IOCP port should have been closed.*/
-  npassert(!port_state->iocp_handle);
-  while ((tree_node = tree_root(&port_state->sock_tree)) != NULL) {
-    sock_state = sock_state_from_tree_node(tree_node);
-    sock_force_delete(port_state, sock_state);
-  }
-  while ((queue_node = queue_first(&port_state->sock_deleted_queue)) != NULL) {
-    sock_state = sock_state_from_queue_node(queue_node);
-    sock_force_delete(port_state, sock_state);
-  }
-  while ((queue_node = queue_first(&port_state->poll_group_queue)) != NULL) {
-    poll_group = poll_group_from_queue_node(queue_node);
-    poll_group_delete(poll_group);
-  }
-  npassert(queue_is_empty(&port_state->sock_update_queue));
-  DeleteCriticalSection(&port_state->lock);
-  port__free(port_state);
-  return 0;
-}
-
-static textwindows int64_t port_get_iocp_handle(struct PortState *port_state) {
-  npassert(port_state->iocp_handle);
-  return port_state->iocp_handle;
-}
-
-static textwindows struct PollGroup *poll_group__new(
-    struct PortState *port_state) {
-  int64_t iocp_handle = port_get_iocp_handle(port_state);
-  struct Queue *poll_group_queue = port_get_poll_group_queue(port_state);
-  struct PollGroup *poll_group = malloc(sizeof *poll_group);
-  if (!poll_group)
-    RETURN_SET_ERROR(NULL, kNtErrorNotEnoughMemory);
-  bzero(poll_group, sizeof *poll_group);
-  queue_node_init(&poll_group->queue_node);
-  poll_group->port_state = port_state;
-  if (afd_create_device_handle(iocp_handle, &poll_group->afd_device_handle) <
-      0) {
-    free(poll_group);
-    return NULL;
-  }
-  queue_append(poll_group_queue, &poll_group->queue_node);
-  return poll_group;
-}
-
-static textwindows struct PollGroup *poll_group_acquire(
-    struct PortState *port_state) {
-  struct Queue *poll_group_queue = port_get_poll_group_queue(port_state);
-  struct PollGroup *poll_group = !queue_is_empty(poll_group_queue)
-                                     ? CONTAINOF(queue_last(poll_group_queue),
-                                                 struct PollGroup, queue_node)
-                                     : NULL;
-  if (!poll_group || poll_group->group_size >= MAX_GROUP_SIZE)
-    poll_group = poll_group__new(port_state);
-  if (!poll_group)
-    return NULL;
-  if (++poll_group->group_size == MAX_GROUP_SIZE)
-    queue_move_to_start(poll_group_queue, &poll_group->queue_node);
-  return poll_group;
-}
-
-static textwindows int port_close(struct PortState *port_state) {
-  int result;
-  EnterCriticalSection(&port_state->lock);
-  result = port__close_iocp(port_state);
-  LeaveCriticalSection(&port_state->lock);
-  return result;
-}
-
-static textwindows uint32_t sock__epoll_events_to_afd_events(uint32_t e) {
-  /* Always monitor for kNtAfdPollLocalClose, which is triggered when
-     the socket is closed with closesocket() or CloseHandle(). */
-  uint32_t a = kNtAfdPollLocalClose;
-  if (e & (EPOLLIN | EPOLLRDNORM))
-    a |= kNtAfdPollReceive | kNtAfdPollAccept;
-  if (e & (EPOLLPRI | EPOLLRDBAND))
-    a |= kNtAfdPollReceiveExpedited;
-  if (e & (EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND))
-    a |= kNtAfdPollSend;
-  if (e & (EPOLLIN | EPOLLRDNORM | EPOLLRDHUP))
-    a |= kNtAfdPollDisconnect;
-  if (e & EPOLLHUP)
-    a |= kNtAfdPollAbort;
-  if (e & EPOLLERR)
-    a |= kNtAfdPollConnectFail;
-  return a;
-}
-
-static textwindows uint32_t sock__afd_events_to_epoll_events(uint32_t a) {
-  uint32_t e = 0;
-  if (a & (kNtAfdPollReceive | kNtAfdPollAccept))
-    e |= EPOLLIN | EPOLLRDNORM;
-  if (a & kNtAfdPollReceiveExpedited)
-    e |= EPOLLPRI | EPOLLRDBAND;
-  if (a & kNtAfdPollSend)
-    e |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
-  if (a & kNtAfdPollDisconnect)
-    e |= EPOLLIN | EPOLLRDNORM | EPOLLRDHUP;
-  if (a & kNtAfdPollAbort)
-    e |= EPOLLHUP;
-  if (a & kNtAfdPollConnectFail) {
-    /* Linux reports all these events after connect() has failed. */
-    e |= EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLRDNORM | EPOLLWRNORM | EPOLLRDHUP;
-  }
-  return e;
-}
-
-static textwindows int sock_update(struct PortState *port_state,
-                                   struct SockState *sock_state) {
-  npassert(!sock_state->delete_pending);
-  if ((sock_state->poll_status == kPollPending) &&
-      !(sock_state->user_events & KNOWN_EVENTS & ~sock_state->pending_events)) {
-    /* All the events the user is interested in are already being
-       monitored by the pending poll operation. It might spuriously
-       complete because of an event that we're no longer interested in;
-       when that happens we'll submit a new poll operation with the
-       updated event mask. */
-  } else if (sock_state->poll_status == kPollPending) {
-    /* A poll operation is already pending, but it's not monitoring for
-       all the *events that the user is interested in. Therefore, cancel
-       the pending *poll operation; when we receive it's completion
-       package, a new poll *operation will be submitted with the correct
-       event mask. */
-    if (sock__cancel_poll(sock_state) < 0)
-      return -1;
-  } else if (sock_state->poll_status == kPollCancelled) {
-    /* The poll operation has already been cancelled, we're still waiting for
-       it to return.For now, there' s nothing that needs to be done. */
-  } else if (sock_state->poll_status == kPollIdle) {
-    /* No poll operation is pending; start one. */
-    sock_state->poll_info.Exclusive = false;
-    sock_state->poll_info.NumberOfHandles = 1;
-    sock_state->poll_info.Timeout = INT64_MAX;
-    sock_state->poll_info.Handles[0].Handle = (int64_t)sock_state->base_socket;
-    sock_state->poll_info.Handles[0].Status = 0;
-    sock_state->poll_info.Handles[0].Events =
-        sock__epoll_events_to_afd_events(sock_state->user_events);
-    if (afd_poll(poll_group_get_afd_device_handle(sock_state->poll_group),
-                 &sock_state->poll_info, &sock_state->io_status_block) < 0) {
-      switch (GetLastError()) {
-        case kNtErrorIoPending:
-          /* Overlapped poll operation in progress; this is expected. */
-          break;
-        case kNtErrorInvalidHandle:
-          /* Socket closed; it'll be dropped from the epoll set. */
-          return sock__delete(port_state, sock_state, false);
-        default:
-          /* Other errors are propagated to the caller. */
-          RETURN_MAP_ERROR(-1);
-      }
-    }
-    /* The poll request was successfully submitted.*/
-    sock_state->poll_status = kPollPending;
-    sock_state->pending_events = sock_state->user_events;
-  } else {
-    __builtin_unreachable();
-  }
-  port_cancel_socket_update(port_state, sock_state);
-  return 0;
-}
-
-static textwindows int port__update_events(struct PortState *port_state) {
-  struct QueueNode *queue_node;
-  struct SockState *sock_state;
-  struct Queue *sock_update_queue = &port_state->sock_update_queue;
-  /* Walk queue, submitting new poll requests for sockets needing it */
-  while (!queue_is_empty(sock_update_queue)) {
-    queue_node = queue_first(sock_update_queue);
-    sock_state = sock_state_from_queue_node(queue_node);
-    if (sock_update(port_state, sock_state) < 0)
-      return -1;
-    /* sock_update() removes the socket from the update queue.*/
-  }
-  return 0;
-}
-
-static textwindows void port__update_events_if_polling(
-    struct PortState *port_state) {
-  if (port_state->active_poll_count > 0)
-    port__update_events(port_state);
-}
-
-static textwindows void port_request_socket_update(
-    struct PortState *port_state, struct SockState *sock_state) {
-  if (queue_is_enqueued(sock_state_to_queue_node(sock_state)))
-    return;
-  queue_append(&port_state->sock_update_queue,
-               sock_state_to_queue_node(sock_state));
-}
-
-static textwindows int sock_feed_event(struct PortState *port_state,
-                                       struct NtIoStatusBlock *io_status_block,
-                                       struct epoll_event *ev) {
-  uint32_t epoll_events;
-  struct SockState *sock_state;
-  struct NtAfdPollInfo *poll_info;
-  epoll_events = 0;
-  sock_state = CONTAINOF(io_status_block, struct SockState, io_status_block);
-  poll_info = &sock_state->poll_info;
-  sock_state->poll_status = kPollIdle;
-  sock_state->pending_events = 0;
-  if (sock_state->delete_pending) {
-    /* Socket has been deleted earlier and can now be freed.*/
-    return sock__delete(port_state, sock_state, false);
-  } else if (io_status_block->Status == kNtStatusCancelled) {
-    /* The poll request was cancelled by CancelIoEx.*/
-  } else if (!NtSuccess(io_status_block->Status)) {
-    /* The overlapped request itself failed in an unexpected way.*/
-    epoll_events = EPOLLERR;
-  } else if (poll_info->NumberOfHandles < 1) {
-    /* This poll operation succeeded but didn't report any socket events. */
-  } else if (poll_info->Handles[0].Events & kNtAfdPollLocalClose) {
-    /* The poll operation reported that the socket was closed.*/
-    return sock__delete(port_state, sock_state, false);
-  } else {
-    /* Events related to our socket were reported.*/
-    epoll_events =
-        sock__afd_events_to_epoll_events(poll_info->Handles[0].Events);
-  }
-  /* Requeue the socket so a new poll request will be submitted.*/
-  port_request_socket_update(port_state, sock_state);
-  /* Filter out events that the user didn't ask for. */
-  epoll_events &= sock_state->user_events;
-  /* Return if there are no epoll events to report.*/
-  if (epoll_events == 0)
-    return 0;
-  /* If the the socket has the EPOLLONESHOT flag set, unmonitor all
-     events, even EPOLLERR and EPOLLHUP. But always keep looking for
-     closed sockets. */
-  if (sock_state->user_events & EPOLLONESHOT) {
-    sock_state->user_events = 0;
-  }
-  ev->data = sock_state->user_data;
-  ev->events = epoll_events;
-  return 1;
-}
-
-static textwindows int port__feed_events(struct PortState *port_state,
-                                         struct epoll_event *epoll_events,
-                                         struct NtOverlappedEntry *iocp_events,
-                                         uint32_t iocp_event_count) {
-  uint32_t i;
-  int epoll_event_count;
-  struct epoll_event *ev;
-  struct NtIoStatusBlock *io_status_block;
-  epoll_event_count = 0;
-  for (i = 0; i < iocp_event_count; i++) {
-    io_status_block = (struct NtIoStatusBlock *)iocp_events[i].lpOverlapped;
-    ev = &epoll_events[epoll_event_count];
-    epoll_event_count += sock_feed_event(port_state, io_status_block, ev);
-  }
-  return epoll_event_count;
-}
-
-static textwindows int port__poll(struct PortState *port_state,
-                                  struct epoll_event *epoll_events,
-                                  struct NtOverlappedEntry *iocp_events,
-                                  uint32_t maxevents, uint32_t timeout) {
-  bool32 r;
-  uint32_t completion_count;
-  if (port__update_events(port_state) < 0)
-    return -1;
-  port_state->active_poll_count++;
-  LeaveCriticalSection(&port_state->lock);
-  r = GetQueuedCompletionStatusEx(port_state->iocp_handle, iocp_events,
-                                  maxevents, &completion_count, timeout, false);
-  EnterCriticalSection(&port_state->lock);
-  port_state->active_poll_count--;
-  if (!r)
-    RETURN_MAP_ERROR(-1);
-  return port__feed_events(port_state, epoll_events, iocp_events,
-                           completion_count);
-}
-
-static textwindows int port_wait(struct PortState *port_state,
-                                 struct epoll_event *events, int maxevents,
-                                 int timeout) {
-  int result;
-  uint64_t now, due = 0;
-  uint32_t gqcs_timeout;
-  struct NtOverlappedEntry *iocp_events;
-  struct NtOverlappedEntry stack_iocp_events[64];
-  /* Check whether `maxevents` is in range.*/
-  if (maxevents <= 0)
-    RETURN_SET_ERROR(-1, kNtErrorInvalidParameter);
-  /* Decide whether the IOCP completion list can live on the stack, or
-     allocate memory for it on the heap. */
-  if ((size_t)maxevents <= ARRAYLEN(stack_iocp_events)) {
-    iocp_events = stack_iocp_events;
-  } else if ((iocp_events = malloc((size_t)maxevents * sizeof(*iocp_events))) ==
-             NULL) {
-    iocp_events = stack_iocp_events;
-    maxevents = ARRAYLEN(stack_iocp_events);
-  }
-  /* Compute the timeout for GetQueuedCompletionStatus, and the wait end
-     time, if the user specified a timeout other than zero or infinite. */
-  if (timeout > 0) {
-    due = GetTickCount64() + (uint64_t)timeout;
-    gqcs_timeout = (uint32_t)timeout;
-  } else if (timeout == 0) {
-    gqcs_timeout = 0;
-  } else {
-    gqcs_timeout = -1;
-  }
-  EnterCriticalSection(&port_state->lock);
-  /* Dequeue completion packets until either at least one interesting
-     event has been discovered, or the timeout is reached. */
-  for (;;) {
-    result = port__poll(port_state, events, iocp_events, (uint32_t)maxevents,
-                        gqcs_timeout);
-    if (result < 0 || result > 0)
-      break;
-    /* Result, error, or time - out. */
-    if (timeout < 0)
-      continue;
-    /* When timeout is negative, never time out. */
-    /* Update time. */
-    now = GetTickCount64();
-    /* Do not allow the due time to be in the past. */
-    if (now >= due) {
-      SetLastError(kNtWaitTimeout);
-      break;
-    }
-    /* Recompute time-out argument for GetQueuedCompletionStatus. */
-    gqcs_timeout = (uint32_t)(due - now);
-  }
-  port__update_events_if_polling(port_state);
-  LeaveCriticalSection(&port_state->lock);
-  if (iocp_events != stack_iocp_events) {
-    free(iocp_events);
-  }
-  if (result >= 0) {
-    return result;
-  } else if (GetLastError() == kNtWaitTimeout) {
-    return 0;
-  } else {
-    return -1;
-  }
-}
-
-static textwindows int64_t ws__ioctl_get_bsp_socket(int64_t socket,
-                                                    uint32_t ioctl) {
-  uint32_t bytes;
-  int64_t bsp_socket;
-  if (WSAIoctl(socket, ioctl, NULL, 0, &bsp_socket, sizeof(bsp_socket), &bytes,
-               NULL, NULL) != -1) {
-    return bsp_socket;
-  } else {
-    return -1;
-  }
-}
-
-static textwindows int64_t ws_get_base_socket(int64_t socket) {
-  uint32_t error;
-  int64_t base_socket;
-  for (;;) {
-    base_socket = ws__ioctl_get_bsp_socket(socket, kNtSioBaseHandle);
-    if (base_socket != -1) {
-      return base_socket;
-    }
-    error = GetLastError();
-    if (error == WSAENOTSOCK) {
-      RETURN_SET_ERROR(-1, error);
-    }
-    /*
-     * Even though Microsoft documentation clearly states that Layered
-     * Spyware Providers must never ever intercept the SIO_BASE_HANDLE
-     * ioctl, Komodia LSPs (that Lenovo got sued for preinstalling) do
-     * so anyway in order to redirect decrypted https requests through
-     * some foreign proxy and inject ads which breaks high-performance
-     * network event io. However it doesn't handle SIO_BSP_HANDLE_POLL
-     * which will at least let us obtain the socket associated with the
-     * next winsock protocol chain entry. If this succeeds, loop around
-     * and call SIO_BASE_HANDLE again with the returned BSP socket, to
-     * make sure we unwrap all layers and retrieve the real base socket.
-     */
-    base_socket = ws__ioctl_get_bsp_socket(socket, kNtSioBspHandlePoll);
-    if (base_socket != -1 && base_socket != socket) {
-      socket = base_socket;
-    } else {
-      RETURN_SET_ERROR(-1, error);
-    }
-  }
-}
-
-static textwindows struct SockState *sock__alloc(void) {
-  struct SockState *sock_state = malloc(sizeof *sock_state);
-  if (!sock_state)
-    RETURN_SET_ERROR(NULL, kNtErrorNotEnoughMemory);
-  return sock_state;
-}
-
-static textwindows int port_register_socket(struct PortState *port_state,
-                                            struct SockState *sock_state,
-                                            int64_t socket) {
-  if (tree_add(&port_state->sock_tree, sock_state_to_tree_node(sock_state),
-               socket) < 0) {
-    RETURN_SET_ERROR(-1, kNtErrorAlreadyExists);
-  }
-  return 0;
-}
-
-static textwindows struct SockState *sock_new(struct PortState *port_state,
-                                              int64_t socket) {
-  int64_t base_socket;
-  struct PollGroup *poll_group;
-  struct SockState *sock_state;
-  if (socket == 0 || socket == -1)
-    RETURN_SET_ERROR(0, kNtErrorInvalidHandle);
-  base_socket = ws_get_base_socket(socket);
-  if (base_socket == -1)
-    return NULL;
-  poll_group = poll_group_acquire(port_state);
-  if (!poll_group)
-    return NULL;
-  sock_state = sock__alloc();
-  if (!sock_state)
-    goto err1;
-  bzero(sock_state, sizeof *sock_state);
-  sock_state->base_socket = base_socket;
-  sock_state->poll_group = poll_group;
-  tree_node_init(&sock_state->tree_node);
-  queue_node_init(&sock_state->queue_node);
-  if (port_register_socket(port_state, sock_state, socket) < 0)
-    goto err2;
-  return sock_state;
-err2:
-  sock__free(sock_state);
-err1:
-  poll_group_release(poll_group);
-  return NULL;
-}
-
-static textwindows int sock_set_event(struct PortState *port_state,
-                                      struct SockState *sock_state,
-                                      const struct epoll_event *ev) {
-  /* EPOLLERR and EPOLLHUP are always reported, even when not requested
-     by the caller. However they are disabled after a event has been
-     reported for a socket for which the EPOLLONESHOT flag was set. */
-  uint32_t events = ev->events | EPOLLERR | EPOLLHUP;
-  sock_state->user_events = events;
-  sock_state->user_data = ev->data;
-  if ((events & KNOWN_EVENTS & ~sock_state->pending_events) != 0) {
-    port_request_socket_update(port_state, sock_state);
-  }
-  return 0;
-}
-
-static textwindows int port__ctl_add(struct PortState *port_state, int64_t sock,
-                                     struct epoll_event *ev) {
-  struct SockState *sock_state = sock_new(port_state, sock);
-  if (!sock_state)
-    return -1;
-  if (sock_set_event(port_state, sock_state, ev) < 0) {
-    sock_delete(port_state, sock_state);
-    return -1;
-  }
-  port__update_events_if_polling(port_state);
-  return 0;
-}
-
-static textwindows struct SockState *port_find_socket(
-    struct PortState *port_state, int64_t socket) {
-  struct TreeNode *tree_node = tree_find(&port_state->sock_tree, socket);
-  if (!tree_node)
-    RETURN_SET_ERROR(NULL, kNtErrorNotFound);
-  return sock_state_from_tree_node(tree_node);
-}
-
-static textwindows int port__ctl_mod(struct PortState *port_state, int64_t sock,
-                                     struct epoll_event *ev) {
-  struct SockState *sock_state = port_find_socket(port_state, sock);
-  if (!sock_state)
-    return -1;
-  if (sock_set_event(port_state, sock_state, ev) < 0)
-    return -1;
-  port__update_events_if_polling(port_state);
-  return 0;
-}
-
-static textwindows int port__ctl_del(struct PortState *port_state,
-                                     int64_t sock) {
-  struct SockState *sock_state = port_find_socket(port_state, sock);
-  if (!sock_state)
-    return -1;
-  sock_delete(port_state, sock_state);
-  return 0;
-}
-
-static textwindows int port__ctl_op(struct PortState *port_state, int op,
-                                    int64_t sock, struct epoll_event *ev) {
-  switch (op) {
-    case EPOLL_CTL_ADD:
-      return port__ctl_add(port_state, sock, ev);
-    case EPOLL_CTL_MOD:
-      return port__ctl_mod(port_state, sock, ev);
-    case EPOLL_CTL_DEL:
-      return port__ctl_del(port_state, sock);
-    default:
-      RETURN_SET_ERROR(-1, kNtErrorInvalidParameter);
-  }
-}
-
-static textwindows int port_ctl(struct PortState *port_state, int op,
-                                int64_t sock, struct epoll_event *ev) {
-  int result;
-  EnterCriticalSection(&port_state->lock);
-  result = port__ctl_op(port_state, op, sock, ev);
-  LeaveCriticalSection(&port_state->lock);
-  return result;
-}
-
-static textwindows struct PortState *port_state_from_handle_tree_node(
-    struct TsTreeNode *tree_node) {
-  return CONTAINOF(tree_node, struct PortState, handle_tree_node);
-}
-
-static textwindows dontinline int sys_epoll_create1_nt(uint32_t flags) {
-  int fd;
-  int64_t ephnd;
-  struct PortState *port_state;
-  struct TsTreeNode *tree_node;
-  if (wepoll_init() < 0)
-    return -1;
-  fd = __reservefd(-1);
-  if (fd == -1)
-    return -1;
-  port_state = port_new(&ephnd);
-  if (!port_state) {
-    __releasefd(fd);
-    return -1;
-  }
-  tree_node = port_state_to_handle_tree_node(port_state);
-  if (ts_tree_add(&epoll__handle_tree, tree_node, (uintptr_t)ephnd) < 0) {
-    /* This should never happen. */
-    port_delete(port_state);
-    err_set_win_error(kNtErrorAlreadyExists);
-    __releasefd(fd);
-    return -1;
-  }
-  __fds_lock();
-  g_fds.p[fd].kind = kFdEpoll;
-  g_fds.p[fd].handle = ephnd;
-  g_fds.p[fd].flags = flags;
-  g_fds.p[fd].mode = 0140666;
-  __fds_unlock();
-  return fd;
-}
-
-static textwindows dontinline int sys_epoll_ctl_nt(int epfd, int op, int fd,
-                                                   struct epoll_event *ev) {
-  int r;
-  struct PortState *port_state;
-  struct TsTreeNode *tree_node;
-  if (!IsWindows()) {
-    return sys_epoll_ctl(epfd, op, fd, ev);
-  } else {
-    if (wepoll_init() < 0)
-      return -1;
-    if (!__isfdopen(fd))
-      return ebadf();
-    if (!__isfdkind(epfd, kFdEpoll))
-      return ebadf();
-    tree_node = ts_tree_find_and_ref(&epoll__handle_tree, g_fds.p[epfd].handle);
-    if (!tree_node) {
-      err_set_win_error(kNtErrorInvalidParameter);
-      goto err;
-    }
-    port_state = port_state_from_handle_tree_node(tree_node);
-    r = port_ctl(port_state, op, g_fds.p[fd].handle, ev);
-    ts_tree_node_unref(tree_node);
-    if (r < 0)
-      goto err;
-    return 0;
-  err:
-    /* On Linux, in the case of epoll_ctl(), EBADF takes priority over
-       other *errors. Wepoll mimics this behavior. */
-    err_check_handle(g_fds.p[epfd].handle);
-    err_check_handle(g_fds.p[fd].handle);
-    return -1;
-  }
-}
-
-static textwindows dontinline int sys_epoll_wait_nt(int epfd,
-                                                    struct epoll_event *events,
-                                                    int maxevents,
-                                                    int timeoutms) {
-  int num_events;
-  struct PortState *port_state;
-  struct TsTreeNode *tree_node;
-  if (!__isfdkind(epfd, kFdEpoll))
-    return ebadf();
-  if (maxevents <= 0)
-    return einval();
-  if (wepoll_init() < 0)
-    return -1;
-  tree_node = ts_tree_find_and_ref(&epoll__handle_tree, g_fds.p[epfd].handle);
-  if (!tree_node) {
-    err_set_win_error(kNtErrorInvalidParameter);
-    goto err;
-  }
-  port_state = port_state_from_handle_tree_node(tree_node);
-  num_events = port_wait(port_state, events, maxevents, timeoutms);
-  ts_tree_node_unref(tree_node);
-  if (num_events < 0)
-    goto err;
-  return num_events;
-err:
-  err_check_handle(g_fds.p[epfd].handle);
-  return -1;
-}
-
-#if SupportsWindows()
-textwindows int sys_close_epoll_nt(int fd) {
-  struct PortState *port_state;
-  struct TsTreeNode *tree_node;
-  if (wepoll_init() < 0)
-    return -1;
-  tree_node = ts_tree_del_and_ref(&epoll__handle_tree, g_fds.p[fd].handle);
-  if (!tree_node) {
-    err_set_win_error(kNtErrorInvalidParameter);
-    goto err;
-  }
-  port_state = port_state_from_handle_tree_node(tree_node);
-  port_close(port_state);
-  ts_tree_node_unref_and_destroy(tree_node);
-  return port_delete(port_state);
-err:
-  err_check_handle(g_fds.p[fd].handle);
-  return -1;
-}
-#endif
-
-/**
- * Creates new epoll instance.
- *
- * @param size is ignored but must be greater than zero
- * @param flags must be zero as there are no supported flags
- * @return epoll file descriptor, or -1 on failure
- */
-int epoll_create(int size) {
-  int rc;
-  if (size <= 0) {
-    rc = einval();
-  } else {
-    BLOCK_SIGNALS;
-    rc = epoll_create1(0);
-    ALLOW_SIGNALS;
-  }
-  STRACE("epoll_create(%d) → %d% m", size, rc);
-  return rc;
-}
-
-/**
- * Creates new epoll instance.
- *
- * @param size is ignored but must be greater than zero
- * @param flags must be zero or can have O_CLOEXEC
- * @return epoll file descriptor, or -1 on failure
- */
-int epoll_create1(int flags) {
-  int rc;
-  if (flags & ~O_CLOEXEC) {
-    rc = einval();
-  } else if (!IsWindows()) {
-    rc = __fixupnewfd(sys_epoll_create(1337), flags);
-  } else {
-    BLOCK_SIGNALS;
-    rc = sys_epoll_create1_nt(flags);
-    ALLOW_SIGNALS;
-  }
-  STRACE("epoll_create1(%#x) → %d% m", flags, rc);
-  return rc;
-}
-
-/**
- * Controls which socket events are monitored.
- *
- * It is recommended to always explicitly remove a socket from its epoll
- * set using EPOLL_CTL_DEL before closing it. As on Linux, your closed
- * sockets are automatically removed from the epoll set, but wepoll may
- * not be able to detect that a socket was closed until the next call to
- * epoll_wait().
- *
- * @param epfd is file descriptor created by epoll_create()
- * @param op can be EPOLL_CTL_{ADD,MOD,DEL}
- * @param fd is file descriptor to monitor
- * @param ev is ignored if op is EPOLL_CTL_DEL
- * @param ev->events can have these flags:
- *     - `EPOLLIN`: trigger on fd readable
- *     - `EPOLLOUT`: trigger on fd writeable
- *     - `EPOLLERR`: trigger on fd error (superfluous: always reported)
- *     - `EPOLLHUP`: trigger on fd remote hangup (superfluous: always reported)
- *     - `EPOLLPRI`: trigger on fd exceptional conditions, e.g. oob
- *     - `EPOLLONESHOT`: report event(s) only once
- *     - `EPOLLEXCLUSIVE`: not supported on windows
- *     - `EPOLLWAKEUP`: not supported on windows
- *     - `EPOLLET`: edge triggered mode (not supported on windows)
- *     - `EPOLLRDNORM`
- *     - `EPOLLRDBAND`
- *     - `EPOLLWRNORM`
- *     - `EPOLLWRBAND`
- *     - `EPOLLRDHUP`
- *     - `EPOLLMSG`
- * @error ENOTSOCK on Windows if fd isn't a socket :(
- * @return 0 on success, or -1 w/ errno
- */
-int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev) {
-  int rc;
-  if (!IsWindows()) {
-    rc = sys_epoll_ctl(epfd, op, fd, ev);
-  } else {
-    BLOCK_SIGNALS;
-    rc = sys_epoll_ctl_nt(epfd, op, fd, ev);
-    ALLOW_SIGNALS;
-  }
-  STRACE("epoll_ctl(%d, %d, %d, %p) → %d% m", epfd, op, fd, ev, rc);
-  return rc;
-}
-
-/**
- * Receives socket events.
- *
- * @param events will receive information about what happened
- * @param maxevents is array length of events
- * @param timeoutms is milliseconds, 0 to not block, or -1 for forever
- * @return number of events stored, 0 on timeout, or -1 w/ errno
- * @cancelationpoint
- * @norestart
- */
-int epoll_wait(int epfd, struct epoll_event *events, int maxevents,
-               int timeoutms) {
-  int e, rc;
-  BEGIN_CANCELATION_POINT;
-  if (!IsWindows()) {
-    e = errno;
-    rc = sys_epoll_wait(epfd, events, maxevents, timeoutms);
-    if (rc == -1 && errno == ENOSYS) {
-      errno = e;
-      rc = sys_epoll_pwait(epfd, events, maxevents, timeoutms, 0, 0);
-    }
-  } else {
-    BLOCK_SIGNALS;
-    // eintr/ecanceled not implemented for epoll() on win32 yet
-    rc = sys_epoll_wait_nt(epfd, events, maxevents, timeoutms);
-    ALLOW_SIGNALS;
-  }
-  END_CANCELATION_POINT;
-  STRACE("epoll_wait(%d, %p, %d, %d) → %d% m", epfd, events, maxevents,
-         timeoutms, rc);
-  return rc;
-}
-
-/**
- * Receives socket events.
- *
- * @param events will receive information about what happened
- * @param maxevents is array length of events
- * @param timeoutms is milliseconds, 0 to not block, or -1 for forever
- * @param sigmask is an optional sigprocmask() to use during call
- * @return number of events stored, 0 on timeout, or -1 w/ errno
- * @cancelationpoint
- * @norestart
- */
-int epoll_pwait(int epfd, struct epoll_event *events, int maxevents,
-                int timeoutms, const sigset_t *sigmask) {
-  int e, rc;
-  sigset_t oldmask;
-  BEGIN_CANCELATION_POINT;
-  if (!IsWindows()) {
-    e = errno;
-    rc = sys_epoll_pwait(epfd, events, maxevents, timeoutms, sigmask,
-                         sizeof(*sigmask));
-    if (rc == -1 && errno == ENOSYS) {
-      errno = e;
-      if (sigmask)
-        sys_sigprocmask(SIG_SETMASK, sigmask, &oldmask);
-      rc = sys_epoll_wait(epfd, events, maxevents, timeoutms);
-      if (sigmask)
-        sys_sigprocmask(SIG_SETMASK, &oldmask, 0);
-    }
-  } else {
-    BLOCK_SIGNALS;
-    // eintr/ecanceled not implemented for epoll() on win32 yet
-    rc = sys_epoll_wait_nt(epfd, events, maxevents, timeoutms);
-    ALLOW_SIGNALS;
-  }
-  END_CANCELATION_POINT;
-  STRACE("epoll_pwait(%d, %p, %d, %d) → %d% m", epfd, events, maxevents,
-         timeoutms, DescribeSigset(0, sigmask), rc);
-  return rc;
-}
diff --git a/libc/sock/epoll.h b/libc/sock/epoll.h
deleted file mode 100644
index ff858f09d..000000000
--- a/libc/sock/epoll.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_SOCK_WEPOLL_H_
-#define COSMOPOLITAN_LIBC_SOCK_WEPOLL_H_
-COSMOPOLITAN_C_START_
-#include "libc/calls/struct/sigset.h"
-
-typedef union epoll_data {
-  void *ptr;
-  int fd;
-  uint32_t u32;
-  uint64_t u64;
-} epoll_data_t;
-
-struct thatispacked epoll_event {
-  uint32_t events;
-  epoll_data_t data;
-};
-
-int epoll_create(int) libcesque;
-int epoll_create1(int) libcesque;
-int epoll_ctl(int, int, int, struct epoll_event *) libcesque;
-int epoll_wait(int, struct epoll_event *, int, int) libcesque;
-int epoll_pwait(int, struct epoll_event *, int, int, const sigset_t *);
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_SOCK_WEPOLL_H_ */
diff --git a/libc/sock/gethostips.c b/libc/sock/gethostips.c
index 0e956c1b0..6a1234f0b 100644
--- a/libc/sock/gethostips.c
+++ b/libc/sock/gethostips.c
@@ -20,7 +20,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/iphlpapi.h"
diff --git a/libc/sock/getsockname.c b/libc/sock/getsockname.c
index e04d620ad..58012d056 100644
--- a/libc/sock/getsockname.c
+++ b/libc/sock/getsockname.c
@@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/fds.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
@@ -28,6 +28,7 @@
 #include "libc/sock/struct/sockaddr.h"
 #include "libc/sock/struct/sockaddr.internal.h"
 #include "libc/sock/syscall_fd.internal.h"
+#include "libc/sysv/consts/af.h"
 #include "libc/sysv/errfuns.h"
 
 __msabi extern typeof(__sys_getsockname_nt) *const __imp_getsockname;
diff --git a/libc/sock/getsockopt-nt.c b/libc/sock/getsockopt-nt.c
index a5b3e3dd8..631cd25e2 100644
--- a/libc/sock/getsockopt-nt.c
+++ b/libc/sock/getsockopt-nt.c
@@ -39,7 +39,6 @@ textwindows int sys_getsockopt_nt(struct Fd *fd, int level, int optname,
   uint64_t ms;
   uint32_t in_optlen;
   struct linger_nt linger;
-  npassert(fd->kind == kFdSocket);
 
   if (out_opt_optval && inout_optlen) {
     in_optlen = *inout_optlen;
@@ -47,28 +46,35 @@ textwindows int sys_getsockopt_nt(struct Fd *fd, int level, int optname,
     in_optlen = 0;
   }
 
+  if (level == SOL_SOCKET && optname == SO_ERROR) {
+    if (in_optlen < sizeof(int))
+      return einval();
+    int err;
+    uint32_t len = sizeof(err);
+    if (__imp_getsockopt(fd->handle, SOL_SOCKET, SO_ERROR, &err, &len) == -1)
+      return __winsockerr();
+    *(int *)out_opt_optval = __dos2errno(err);
+    *inout_optlen = sizeof(int);
+  }
+
   if (level == SOL_SOCKET &&
       (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)) {
-    if (in_optlen >= sizeof(struct timeval)) {
-      if (optname == SO_RCVTIMEO) {
-        ms = fd->rcvtimeo;
-      } else {
-        ms = fd->sndtimeo;
-      }
-      ((struct timeval *)out_opt_optval)->tv_sec = ms / 1000;
-      ((struct timeval *)out_opt_optval)->tv_usec = ms % 1000 * 1000;
-      *inout_optlen = sizeof(struct timeval);
-      return 0;
-    } else {
+    if (in_optlen < sizeof(struct timeval))
       return einval();
+    if (optname == SO_RCVTIMEO) {
+      ms = fd->rcvtimeo;
+    } else {
+      ms = fd->sndtimeo;
     }
+    *(struct timeval *)out_opt_optval = timeval_frommillis(ms);
+    *inout_optlen = sizeof(struct timeval);
+    return 0;
   }
 
   // TODO(jart): Use WSAIoctl?
   if (__imp_getsockopt(fd->handle, level, optname, out_opt_optval,
-                       inout_optlen) == -1) {
+                       inout_optlen) == -1)
     return __winsockerr();
-  }
 
   if (level == SOL_SOCKET) {
     if (optname == SO_LINGER && in_optlen == sizeof(struct linger)) {
diff --git a/libc/sock/getsockopt.c b/libc/sock/getsockopt.c
index 3a7106ddd..46957a415 100644
--- a/libc/sock/getsockopt.c
+++ b/libc/sock/getsockopt.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/syscall_fd.internal.h"
diff --git a/libc/sock/ifaddrs.c b/libc/sock/ifaddrs.c
index 01c0d8e05..9ea609e09 100644
--- a/libc/sock/ifaddrs.c
+++ b/libc/sock/ifaddrs.c
@@ -18,13 +18,19 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/sock/ifaddrs.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/dce.h"
+#include "libc/limits.h"
 #include "libc/mem/mem.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/ifconf.h"
 #include "libc/sock/struct/ifreq.h"
+#include "libc/sock/struct/sockaddr6.h"
+#include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/af.h"
 #include "libc/sysv/consts/iff.h"
+#include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/sio.h"
 #include "libc/sysv/consts/sock.h"
 
@@ -36,6 +42,20 @@ struct IfAddr {
   struct sockaddr_in bstaddr;
 };
 
+struct IfAddr6Info {
+  int addr_scope;
+  int addr_flags;
+};
+
+struct IfAddr6 {
+  struct ifaddrs ifaddrs;
+  char name[IFNAMSIZ];
+  struct sockaddr_in6 addr;
+  struct sockaddr_in6 netmask;
+  struct sockaddr_in6 bstaddr;  // unused
+  struct IfAddr6Info info;
+};
+
 /**
  * Frees network interface address list.
  */
@@ -48,6 +68,73 @@ void freeifaddrs(struct ifaddrs *ifp) {
   }
 }
 
+// hex repr to network order int
+static uint128_t hex2no(const char *str) {
+  uint128_t res = 0;
+  const int max_quads = sizeof(uint128_t) * 2;
+  int i = 0;
+  while ((i < max_quads) && str[i]) {
+    uint8_t acc = (((str[i] & 0xF) + (str[i] >> 6)) | ((str[i] >> 3) & 0x8));
+    acc = acc << 4;
+    i += 1;
+    if (str[i]) {
+      acc = acc | (((str[i] & 0xF) + (str[i] >> 6)) | ((str[i] >> 3) & 0x8));
+      i += 1;
+    }
+    res = (res >> 8) | (((uint128_t)acc) << ((sizeof(uint128_t) - 1) * 8));
+  }
+  res = res >> ((max_quads - i) * 4);
+  return res;
+}
+
+/**
+ * Gets network interface IPv6 address list on linux.
+ *
+ * @return 0 on success, or -1 w/ errno
+ */
+static int getifaddrs_linux_ip6(struct ifconf *conf) {
+  int fd;
+  int n = 0;
+  struct ifreq *ifreq = conf->ifc_req;
+  const int bufsz = 44 + IFNAMSIZ + 1;
+  char buf[bufsz + 1];  // one line max size
+  if ((fd = sys_openat(0, "/proc/net/if_inet6", O_RDONLY, 0)) == -1) {
+    return -1;
+  }
+
+  while ((n = sys_read(fd, &buf[n], bufsz - n)) &&
+         ((char *)ifreq < (conf->ifc_buf + conf->ifc_len))) {
+    // flags linux include/uapi/linux/if_addr.h:44
+    // scope linux include/net/ipv6.h:L99
+
+    //           *addr,   *index,   *plen,    *scope,   *flags,   *ifname
+    char *s[] = {&buf[0], &buf[33], &buf[36], &buf[39], &buf[42], &buf[45]};
+    int ifnamelen = 0;
+    while (*s[5] == ' ') {
+      ++s[5];
+    }
+    while (s[5][ifnamelen] > '\n') {
+      ++ifnamelen;
+    }
+    buf[32] = buf[35] = buf[38] = buf[41] = buf[44] = s[5][ifnamelen] = '\0';
+    bzero(ifreq, sizeof(*ifreq));
+    ifreq->ifr_addr.sa_family = AF_INET6;
+    memcpy(&ifreq->ifr_name, s[5], ifnamelen);
+    *((uint128_t *)&ifreq->ifr6_addr) = hex2no(s[0]);
+    ifreq->ifr6_ifindex = hex2no(s[1]);
+    ifreq->ifr6_prefixlen = hex2no(s[2]);
+    ifreq->ifr6_scope = hex2no(s[3]);
+    ifreq->ifr6_flags = hex2no(s[4]);
+    ++ifreq;
+    int tlen = &s[5][ifnamelen] - &buf[0] + 1;
+    n = bufsz - tlen;
+    memcpy(&buf, &buf[tlen], n);
+  }
+
+  conf->ifc_len = (char *)ifreq - conf->ifc_buf;
+  return sys_close(fd);
+}
+
 /**
  * Gets network interface address list.
  *
@@ -55,6 +142,7 @@ void freeifaddrs(struct ifaddrs *ifp) {
  * @see tool/viz/getifaddrs.c for example code
  */
 int getifaddrs(struct ifaddrs **out_ifpp) {
+  // printf("%d\n", sizeof(struct ifreq));
   int rc = -1;
   int fd;
   if ((fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0)) != -1) {
@@ -65,42 +153,88 @@ int getifaddrs(struct ifaddrs **out_ifpp) {
       conf.ifc_buf = data;
       conf.ifc_len = size;
       if (!ioctl(fd, SIOCGIFCONF, &conf)) {
+        if (IsLinux()) {
+          struct ifconf confl6;
+          confl6.ifc_buf = data + conf.ifc_len;
+          confl6.ifc_len = size - conf.ifc_len;
+          if ((rc = getifaddrs_linux_ip6(&confl6)))
+            return rc;
+          conf.ifc_len += confl6.ifc_len;
+        }
+
         struct ifaddrs *res = 0;
         for (struct ifreq *ifr = (struct ifreq *)data;
              (char *)ifr < data + conf.ifc_len; ++ifr) {
-          if (ifr->ifr_addr.sa_family != AF_INET) {
-            continue;  // TODO(jart): IPv6 support
-          }
-          struct IfAddr *addr;
-          if ((addr = calloc(1, sizeof(struct IfAddr)))) {
-            memcpy(addr->name, ifr->ifr_name, IFNAMSIZ);
-            addr->ifaddrs.ifa_name = addr->name;
-            memcpy(&addr->addr, &ifr->ifr_addr, sizeof(struct sockaddr_in));
-            addr->ifaddrs.ifa_addr = (struct sockaddr *)&addr->addr;
-            addr->ifaddrs.ifa_netmask = (struct sockaddr *)&addr->netmask;
-            if (!ioctl(fd, SIOCGIFFLAGS, ifr)) {
-              addr->ifaddrs.ifa_flags = ifr->ifr_flags;
+          uint16_t family = ifr->ifr_addr.sa_family;
+          if (family == AF_INET) {
+            struct IfAddr *addr;
+            if ((addr = calloc(1, sizeof(struct IfAddr)))) {
+              memcpy(addr->name, ifr->ifr_name, IFNAMSIZ);
+              addr->ifaddrs.ifa_name = addr->name;
+              memcpy(&addr->addr, &ifr->ifr_addr, sizeof(struct sockaddr_in));
+              addr->ifaddrs.ifa_addr = (struct sockaddr *)&addr->addr;
+              addr->ifaddrs.ifa_netmask = (struct sockaddr *)&addr->netmask;
+              if (!ioctl(fd, SIOCGIFFLAGS, ifr)) {
+                addr->ifaddrs.ifa_flags = ifr->ifr_flags;
+              }
+              if (!ioctl(fd, SIOCGIFNETMASK, ifr)) {
+                memcpy(&addr->netmask, &ifr->ifr_addr,
+                       sizeof(struct sockaddr_in));
+              }
+              unsigned long op;
+              if (addr->ifaddrs.ifa_flags & IFF_BROADCAST) {
+                op = SIOCGIFBRDADDR;
+              } else if (addr->ifaddrs.ifa_flags & IFF_POINTOPOINT) {
+                op = SIOCGIFDSTADDR;
+              } else {
+                op = 0;
+              }
+              if (op && !ioctl(fd, op, ifr)) {
+                memcpy(&addr->bstaddr, &ifr->ifr_addr,
+                       sizeof(struct sockaddr_in));
+                addr->ifaddrs.ifa_broadaddr =  // is union'd w/ ifu_dstaddr
+                    (struct sockaddr *)&addr->bstaddr;
+              }
+              addr->ifaddrs.ifa_next = res;
+              res = (struct ifaddrs *)addr;
             }
-            if (!ioctl(fd, SIOCGIFNETMASK, ifr)) {
-              memcpy(&addr->netmask, &ifr->ifr_addr,
-                     sizeof(struct sockaddr_in));
+          } else if (family == AF_INET6) {
+            struct IfAddr6 *addr6;
+            if ((addr6 = calloc(1, sizeof(struct IfAddr6)))) {
+              addr6->ifaddrs.ifa_name = addr6->name;
+              addr6->ifaddrs.ifa_addr = (struct sockaddr *)&addr6->addr;
+              addr6->ifaddrs.ifa_netmask = (struct sockaddr *)&addr6->netmask;
+              addr6->ifaddrs.ifa_broadaddr = (struct sockaddr *)&addr6->bstaddr;
+              addr6->ifaddrs.ifa_data = (void *)&addr6->info;
+
+              memcpy(&addr6->name, &ifr->ifr_name, IFNAMSIZ);
+              addr6->info.addr_flags = ifr->ifr6_flags;
+              addr6->info.addr_scope = ifr->ifr6_scope;
+
+              addr6->addr.sin6_family = AF_INET6;
+              addr6->addr.sin6_port = 0;
+              addr6->addr.sin6_flowinfo = 0;
+              addr6->addr.sin6_scope_id = ifr->ifr6_ifindex;
+              memcpy(&addr6->addr.sin6_addr, &ifr->ifr6_addr,
+                     sizeof(struct in6_addr));
+
+              addr6->netmask.sin6_family = AF_INET6;
+              addr6->netmask.sin6_port = 0;
+              addr6->netmask.sin6_flowinfo = 0;
+              addr6->addr.sin6_scope_id = ifr->ifr6_ifindex;
+              memcpy(&addr6->netmask.sin6_addr, &ifr->ifr6_addr,
+                     sizeof(struct in6_addr));
+              *((uint128_t *)&(addr6->netmask.sin6_addr)) &=
+                  (UINT128_MAX >> ifr->ifr6_prefixlen);
+
+              if (!ioctl(fd, SIOCGIFFLAGS, ifr)) {
+                addr6->ifaddrs.ifa_flags = ifr->ifr_flags;
+              }
+
+              bzero(&addr6->bstaddr, sizeof(struct sockaddr_in6));
+              addr6->ifaddrs.ifa_next = res;
+              res = (struct ifaddrs *)addr6;
             }
-            unsigned long op;
-            if (addr->ifaddrs.ifa_flags & IFF_BROADCAST) {
-              op = SIOCGIFBRDADDR;
-            } else if (addr->ifaddrs.ifa_flags & IFF_POINTOPOINT) {
-              op = SIOCGIFDSTADDR;
-            } else {
-              op = 0;
-            }
-            if (op && !ioctl(fd, op, ifr)) {
-              memcpy(&addr->bstaddr, &ifr->ifr_addr,
-                     sizeof(struct sockaddr_in));
-              addr->ifaddrs.ifa_broadaddr =  // is union'd w/ ifu_dstaddr
-                  (struct sockaddr *)&addr->bstaddr;
-            }
-            addr->ifaddrs.ifa_next = res;
-            res = (struct ifaddrs *)addr;
           }
         }
         *out_ifpp = res;
diff --git a/libc/sock/inet_aton.c b/libc/sock/inet_aton.c
index d08e5c0d9..270033eb0 100644
--- a/libc/sock/inet_aton.c
+++ b/libc/sock/inet_aton.c
@@ -25,6 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/fmt/conv.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/sockaddr.h"
diff --git a/libc/sock/inet_pton.c b/libc/sock/inet_pton.c
index 5693977b9..8ad1bbd24 100644
--- a/libc/sock/inet_pton.c
+++ b/libc/sock/inet_pton.c
@@ -16,7 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/ctype.h"
+#include "libc/macros.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sysv/consts/af.h"
diff --git a/libc/sock/internal.h b/libc/sock/internal.h
index 3cc13b061..927b531fe 100644
--- a/libc/sock/internal.h
+++ b/libc/sock/internal.h
@@ -2,6 +2,7 @@
 #define COSMOPOLITAN_LIBC_SOCK_INTERNAL_H_
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/sigset.h"
+#include "libc/calls/struct/timespec.h"
 #include "libc/nt/struct/overlapped.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
@@ -52,11 +53,6 @@ int32_t sys_select(int32_t, fd_set *, fd_set *, fd_set *, struct timeval *);
 int sys_pselect(int, fd_set *, fd_set *, fd_set *, struct timespec *,
                 const void *);
 int sys_setsockopt(int, int, int, const void *, uint32_t);
-int32_t sys_epoll_create(int32_t);
-int32_t sys_epoll_ctl(int32_t, int32_t, int32_t, void *);
-int32_t sys_epoll_wait(int32_t, void *, int32_t, int32_t);
-int32_t sys_epoll_pwait(int32_t, void *, int32_t, int32_t, const sigset_t *,
-                        size_t);
 
 int sys_socket_nt(int, int, int);
 
@@ -65,7 +61,7 @@ int sys_socketpair_nt_stream(int, int, int, int[2]) ;
 int sys_socketpair_nt_dgram(int, int, int, int[2]) ;
 */
 int sys_socketpair_nt(int, int, int, int[2]);
-int sys_select_nt(int, fd_set *, fd_set *, fd_set *, struct timeval *,
+int sys_select_nt(int, fd_set *, fd_set *, fd_set *, const struct timespec *,
                   const sigset_t *);
 
 size_t __iovec2nt(struct NtIovec[hasatleast 16], const struct iovec *, size_t);
diff --git a/libc/sock/iovec2nt.c b/libc/sock/iovec2nt.c
index cba7dce6b..3f13b22a2 100644
--- a/libc/sock/iovec2nt.c
+++ b/libc/sock/iovec2nt.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/iovec.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sock/internal.h"
 #include "libc/sysv/consts/iov.h"
 
@@ -29,15 +29,21 @@
  */
 textwindows size_t __iovec2nt(struct NtIovec iovnt[hasatleast 16],
                               const struct iovec *iov, size_t iovlen) {
-  size_t i, limit;
-  for (limit = 0x7ffff000, i = 0; i < MIN(16, iovlen); ++i) {
-    iovnt[i].buf = iov[i].iov_base;
+  size_t i, j, limit = 0x7ffff000;
+  for (j = i = 0; i < iovlen; ++i) {
+    if (!iov[i].iov_len)
+      continue;
+    if (j == 16)
+      break;
+    iovnt[j].buf = iov[i].iov_base;
     if (iov[i].iov_len < limit) {
-      limit -= (iovnt[i].len = iov[i].iov_len);
+      limit -= (iovnt[j].len = iov[i].iov_len);
+      ++j;
     } else {
-      iovnt[i].len = limit;
+      iovnt[j].len = limit;
+      ++j;
       break;
     }
   }
-  return i;
+  return j;
 }
diff --git a/libc/sock/kntwsadata.c b/libc/sock/kntwsadata.c
index a3450d88c..6e03dc588 100644
--- a/libc/sock/kntwsadata.c
+++ b/libc/sock/kntwsadata.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/winsock.h"
@@ -51,3 +51,7 @@ textwindows void WinSockInit(void) {
     _Exit(1);
   }
 }
+
+textwindows dontinstrument void WinSockFork(void) {
+  WSAStartup(VERSION, &kNtWsaData);
+}
diff --git a/libc/sock/listen-nt.c b/libc/sock/listen-nt.c
index b82bf4a5d..f39c9b313 100644
--- a/libc/sock/listen-nt.c
+++ b/libc/sock/listen-nt.c
@@ -20,18 +20,28 @@
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
+#include "libc/sock/struct/sockaddr.h"
 #include "libc/sock/syscall_fd.internal.h"
+#include "libc/sysv/consts/af.h"
+#include "libc/sysv/consts/fio.h"
 #ifdef __x86_64__
 
 __msabi extern typeof(__sys_listen_nt) *const __imp_listen;
 
-textwindows int sys_listen_nt(struct Fd *fd, int backlog) {
-  npassert(fd->kind == kFdSocket);
-  if (__imp_listen(fd->handle, backlog) != -1) {
-    return 0;
-  } else {
-    return __winsockerr();
+textwindows int sys_listen_nt(struct Fd *f, int backlog) {
+  unassert(f->kind == kFdSocket);
+
+  // winsock listen() requires bind() be called beforehand
+  if (!f->isbound) {
+    struct sockaddr_in sin = {AF_INET};
+    if (sys_bind_nt(f, (struct sockaddr *)&sin, sizeof(sin)) == -1)
+      return -1;
   }
+
+  if (__imp_listen(f->handle, backlog) == -1)
+    return __winsockerr();
+
+  return 0;
 }
 
 #endif /* __x86_64__ */
diff --git a/libc/sock/listen.c b/libc/sock/listen.c
index c4c51430d..b1262c51f 100644
--- a/libc/sock/listen.c
+++ b/libc/sock/listen.c
@@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/syscall_fd.internal.h"
diff --git a/libc/sock/recv-nt.c b/libc/sock/recv-nt.c
index 7ce09a186..013fc930a 100644
--- a/libc/sock/recv-nt.c
+++ b/libc/sock/recv-nt.c
@@ -17,15 +17,17 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
-#include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/nt/struct/iovec.h"
+#include "libc/nt/struct/overlapped.h"
+#include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/syscall_fd.internal.h"
+#include "libc/sysv/consts/fio.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/vga/vga.internal.h"
 #ifdef __x86_64__
 
 #define _MSG_OOB      1
@@ -33,13 +35,15 @@
 #define _MSG_WAITALL  8
 #define _MSG_DONTWAIT 64
 
+__msabi extern typeof(__sys_ioctlsocket_nt) *const __imp_ioctlsocket;
+
 struct RecvArgs {
   const struct iovec *iov;
   size_t iovlen;
   struct NtIovec iovnt[16];
 };
 
-static textwindows int sys_recv_nt_start(int64_t handle,
+textwindows static int sys_recv_nt_start(int64_t handle,
                                          struct NtOverlapped *overlap,
                                          uint32_t *flags, void *arg) {
   struct RecvArgs *args = arg;
@@ -50,18 +54,28 @@ static textwindows int sys_recv_nt_start(int64_t handle,
 
 textwindows ssize_t sys_recv_nt(int fd, const struct iovec *iov, size_t iovlen,
                                 uint32_t flags) {
-  if (flags & ~(_MSG_DONTWAIT | _MSG_OOB | _MSG_PEEK | _MSG_WAITALL)) {
+  if (flags & ~(_MSG_DONTWAIT | _MSG_OOB | _MSG_PEEK | _MSG_WAITALL))
     return einval();
-  }
   ssize_t rc;
   struct Fd *f = g_fds.p + fd;
-  sigset_t m = __sig_block();
-  bool nonblock = !(flags & _MSG_WAITALL) &&
-                  ((f->flags & O_NONBLOCK) || (flags & _MSG_DONTWAIT));
-  flags &= ~_MSG_DONTWAIT;
-  rc = __winsock_block(f->handle, flags, nonblock, f->rcvtimeo, m,
-                       sys_recv_nt_start, &(struct RecvArgs){iov, iovlen});
-  __sig_unblock(m);
+  sigset_t waitmask = __sig_block();
+
+  // "Be aware that if the underlying transport provider does not
+  //  support MSG_WAITALL, or if the socket is in a non-blocking mode,
+  //  then this call will fail with WSAEOPNOTSUPP. Also, if MSG_WAITALL
+  //  is specified along with MSG_OOB, MSG_PEEK, or MSG_PARTIAL, then
+  //  this call will fail with WSAEOPNOTSUPP."
+  //                             —Quoth MSDN § WSARecv
+  if (flags & _MSG_WAITALL)
+    __imp_ioctlsocket(f->handle, FIONBIO, (uint32_t[]){0});
+
+  rc = __winsock_block(f->handle, flags & ~_MSG_DONTWAIT,
+                       (f->flags & O_NONBLOCK) || (flags & _MSG_DONTWAIT),
+                       f->rcvtimeo, waitmask, sys_recv_nt_start,
+                       &(struct RecvArgs){iov, iovlen});
+
+  __sig_unblock(waitmask);
+
   return rc;
 }
 
diff --git a/libc/sock/recv.c b/libc/sock/recv.c
index 26b9a7436..31003e7fb 100644
--- a/libc/sock/recv.c
+++ b/libc/sock/recv.c
@@ -20,31 +20,55 @@
 #include "libc/calls/internal.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/syscall_fd.internal.h"
+#include "libc/sysv/consts/msg.h"
 #include "libc/sysv/errfuns.h"
 
 /**
  * Receives data from network socket.
  *
+ * Calling `recv(fd, p, n, 0)` is equivalent to `read(fd, p, n)`.
+ *
+ * Unlike files where the OS tries very hard to fulfill the entire
+ * requested `size` before returning, read operations on sockets aim to
+ * return as quickly as possible. For example, if 10 bytes are requested
+ * and a packet comes in with only 5 bytes, then recv() will most likely
+ * return those 5 bytes before waiting longer. The `MSG_WAITALL` flag
+ * may be passed when waiting longer is desired. In that case, short
+ * reads should only be possible when the connection status changes or
+ * the receive operation is interrupted by a signal.
+ *
  * @param fd is the file descriptor returned by socket()
  * @param buf is where received network data gets copied
  * @param size is the byte capacity of buf
  * @param flags can have `MSG_OOB`, `MSG_PEEK`, `MSG_DONTWAIT`, `MSG_WAITALL`
  * @return number of bytes received, 0 on remote close, or -1 w/ errno
+ * @raise EINTR if signal handler was called instead
+ * @raise EINVAL if unknown bits were passed in `flags`
+ * @raise EINVAL if flag isn't supported by host operating system
+ * @raise EINVAL if `MSG_WAITALL` and `MSG_PEEK` were both passed
+ * @raise EBADF if `fd` is an invalid file descriptor
+ * @raise EAGAIN if `MSG_DONTWAIT` was passed and no data was available
+ * @raise EAGAIN if `O_NONBLOCK` is in play and no data was available
  * @error EINTR, EHOSTUNREACH, ECONNRESET (UDP ICMP Port Unreachable),
  *     EPIPE (if MSG_NOSIGNAL), EMSGSIZE, ENOTSOCK, EFAULT, etc.
  * @cancelationpoint
  * @asyncsignalsafe
- * @restartable (unless SO_RCVTIMEO)
+ * @restartable (unless SO_RCVTIMEO on Linux or Windows)
  */
 ssize_t recv(int fd, void *buf, size_t size, int flags) {
   ssize_t rc;
   BEGIN_CANCELATION_POINT;
 
-  if (fd < g_fds.n && g_fds.p[fd].kind == kFdZip) {
+  if ((flags & (MSG_WAITALL | MSG_PEEK)) == (MSG_WAITALL | MSG_PEEK)) {
+    // this is possible on some OSes like Linux but it breaks FreeBSD
+    // and Windows will raise EOPNOTSUPP when it gets passed together
+    return einval();
+  } else if (fd < g_fds.n && g_fds.p[fd].kind == kFdZip) {
     rc = enotsock();
   } else if (!IsWindows()) {
     rc = sys_recvfrom(fd, buf, size, flags, 0, 0);
@@ -65,7 +89,8 @@ ssize_t recv(int fd, void *buf, size_t size, int flags) {
   }
 
   END_CANCELATION_POINT;
-  DATATRACE("recv(%d, [%#.*hhs%s], %'zu, %#x) → %'ld% lm", fd,
-            MAX(0, MIN(40, rc)), buf, rc > 40 ? "..." : "", size, flags);
+  DATATRACE("recv(%d, [%#.*hhs%s], %'zu, %s) → %'ld% lm", fd,
+            MAX(0, MIN(40, rc)), buf, rc > 40 ? "..." : "", size,
+            DescribeMsg(flags), rc);
   return rc;
 }
diff --git a/libc/sock/recvfrom-nt.c b/libc/sock/recvfrom-nt.c
index 25d571ad7..e40e6ed6a 100644
--- a/libc/sock/recvfrom-nt.c
+++ b/libc/sock/recvfrom-nt.c
@@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/sigset.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/nt/struct/iovec.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
@@ -42,7 +42,7 @@ struct RecvFromArgs {
   struct NtIovec iovnt[16];
 };
 
-static textwindows int sys_recvfrom_nt_start(int64_t handle,
+textwindows static int sys_recvfrom_nt_start(int64_t handle,
                                              struct NtOverlapped *overlap,
                                              uint32_t *flags, void *arg) {
   struct RecvFromArgs *args = arg;
@@ -59,14 +59,13 @@ textwindows ssize_t sys_recvfrom_nt(int fd, const struct iovec *iov,
     return einval();
   ssize_t rc;
   struct Fd *f = g_fds.p + fd;
-  sigset_t m = __sig_block();
-  bool nonblock = (f->flags & O_NONBLOCK) || (flags & _MSG_DONTWAIT);
-  flags &= ~_MSG_DONTWAIT;
-  rc = __winsock_block(f->handle, flags, nonblock, f->rcvtimeo, m,
-                       sys_recvfrom_nt_start,
+  sigset_t waitmask = __sig_block();
+  rc = __winsock_block(f->handle, flags & ~_MSG_DONTWAIT,
+                       (f->flags & O_NONBLOCK) || (flags & _MSG_DONTWAIT),
+                       f->rcvtimeo, waitmask, sys_recvfrom_nt_start,
                        &(struct RecvFromArgs){iov, iovlen, opt_out_srcaddr,
                                               opt_inout_srcaddrsize});
-  __sig_unblock(m);
+  __sig_unblock(waitmask);
   return rc;
 }
 
diff --git a/libc/sock/recvfrom.c b/libc/sock/recvfrom.c
index b015cf2af..dbcda5b2c 100644
--- a/libc/sock/recvfrom.c
+++ b/libc/sock/recvfrom.c
@@ -21,7 +21,8 @@
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
@@ -49,7 +50,7 @@
  *     EPIPE (if MSG_NOSIGNAL), EMSGSIZE, ENOTSOCK, EFAULT, etc.
  * @cancelationpoint
  * @asyncsignalsafe
- * @restartable (unless SO_RCVTIMEO)
+ * @restartable (unless SO_RCVTIMEO on Linux or Windows)
  */
 ssize_t recvfrom(int fd, void *buf, size_t size, int flags,
                  struct sockaddr *opt_out_srcaddr,
@@ -95,7 +96,11 @@ ssize_t recvfrom(int fd, void *buf, size_t size, int flags,
   }
 
   END_CANCELATION_POINT;
-  DATATRACE("recvfrom(%d, [%#.*hhs%s], %'zu, %#x) → %'ld% lm", fd,
-            MAX(0, MIN(40, rc)), buf, rc > 40 ? "..." : "", size, flags, rc);
+  DATATRACE(
+      "recvfrom(%d, [%#.*hhs%s], %'zu, %s, %s) → %'ld% lm", fd,
+      MAX(0, MIN(40, rc)), buf, rc > 40 ? "..." : "", size, DescribeMsg(flags),
+      DescribeSockaddr(opt_out_srcaddr,
+                       opt_inout_srcaddrsize ? *opt_inout_srcaddrsize : 0),
+      rc);
   return rc;
 }
diff --git a/libc/sock/recvmsg.c b/libc/sock/recvmsg.c
index 56f6d4762..c172f74c1 100644
--- a/libc/sock/recvmsg.c
+++ b/libc/sock/recvmsg.c
@@ -19,13 +19,13 @@
 #include "libc/assert.h"
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/msghdr.h"
diff --git a/libc/sock/select.internal.h b/libc/sock/select.internal.h
index d565635a6..5de28441a 100644
--- a/libc/sock/select.internal.h
+++ b/libc/sock/select.internal.h
@@ -4,8 +4,8 @@
 #include "libc/sock/select.h"
 COSMOPOLITAN_C_START_
 
-const char *DescribeFdSet(char[100], ssize_t, int, fd_set *) libcesque;
-#define DescribeFdSet(x, y, z) DescribeFdSet(alloca(100), x, y, z)
+const char *_DescribeFdSet(char[100], ssize_t, int, fd_set *) libcesque;
+#define DescribeFdSet(x, y, z) _DescribeFdSet(alloca(100), x, y, z)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_SOCK_SELECT_INTERNAL_H_ */
diff --git a/libc/sock/send-nt.c b/libc/sock/send-nt.c
index a186159b2..ba0570665 100644
--- a/libc/sock/send-nt.c
+++ b/libc/sock/send-nt.c
@@ -17,20 +17,25 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
-#include "libc/calls/struct/iovec.h"
+#include "libc/calls/sig.internal.h"
+#include "libc/calls/struct/iovec.internal.h"
 #include "libc/calls/struct/sigset.internal.h"
+#include "libc/errno.h"
+#include "libc/nt/errors.h"
 #include "libc/nt/struct/iovec.h"
+#include "libc/nt/struct/overlapped.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
-#include "libc/sock/syscall_fd.internal.h"
-#include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/sicode.h"
+#include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/vga/vga.internal.h"
 #ifdef __x86_64__
 
 #define _MSG_OOB       1
 #define _MSG_DONTROUTE 4
 #define _MSG_DONTWAIT  64
+#define _MSG_NOSIGNAL  0x10000000
 
 struct SendArgs {
   const struct iovec *iov;
@@ -38,7 +43,7 @@ struct SendArgs {
   struct NtIovec iovnt[16];
 };
 
-static textwindows int sys_send_nt_start(int64_t handle,
+textwindows static int sys_send_nt_start(int64_t handle,
                                          struct NtOverlapped *overlap,
                                          uint32_t *flags, void *arg) {
   struct SendArgs *args = arg;
@@ -49,16 +54,25 @@ static textwindows int sys_send_nt_start(int64_t handle,
 
 textwindows ssize_t sys_send_nt(int fd, const struct iovec *iov, size_t iovlen,
                                 uint32_t flags) {
-  if (flags & ~(_MSG_DONTWAIT | _MSG_OOB | _MSG_DONTROUTE))
+  if (flags & ~(_MSG_DONTWAIT | _MSG_OOB | _MSG_DONTROUTE | _MSG_NOSIGNAL))
     return einval();
   ssize_t rc;
   struct Fd *f = g_fds.p + fd;
-  sigset_t m = __sig_block();
-  bool nonblock = (f->flags & O_NONBLOCK) || (flags & _MSG_DONTWAIT);
-  flags &= ~_MSG_DONTWAIT;
-  rc = __winsock_block(f->handle, flags, nonblock, f->sndtimeo, m,
-                       sys_send_nt_start, &(struct SendArgs){iov, iovlen});
-  __sig_unblock(m);
+  sigset_t waitmask = __sig_block();
+
+  rc = __winsock_block(f->handle, flags & ~(_MSG_DONTWAIT | _MSG_NOSIGNAL),
+                       false, f->sndtimeo, waitmask, sys_send_nt_start,
+                       &(struct SendArgs){iov, iovlen});
+
+  __sig_unblock(waitmask);
+
+  if (rc == -1 && (errno == WSAESHUTDOWN ||      // ESHUTDOWN
+                   errno == WSAECONNABORTED)) {  // ECONNABORTED
+    errno = kNtErrorBrokenPipe;                  // EPIPE
+    if (!(flags & _MSG_NOSIGNAL))
+      __sig_raise(SIGPIPE, SI_KERNEL);
+  }
+
   return rc;
 }
 
diff --git a/libc/sock/send.c b/libc/sock/send.c
index b66ee698c..81831b27c 100644
--- a/libc/sock/send.c
+++ b/libc/sock/send.c
@@ -21,8 +21,9 @@
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sysv/errfuns.h"
@@ -30,6 +31,18 @@
 /**
  * Sends data to network socket.
  *
+ * Calling `send(fd, p, n, 0)` is equivalent to `write(fd, p, n)`.
+ *
+ * On Windows, calling send() or write() on a socket in `O_NONBLOCK`
+ * mode will block. This is done for many reasons. First, most UNIX OSes
+ * have a similar behavior, due to how little code checks the return
+ * status of write(). Secondly, WIN32 has bugs that prevent us from
+ * canceling an overlapped WSASend() operation safely. Programs that
+ * want to avoid send() blocking should call poll() beforehand with the
+ * POLLOUT flag to test when the socket can safely be written without
+ * blocking. It's also possible to pass `MSG_DONTWAIT` via `flags` in
+ * which case send() will do this for you automatically.
+ *
  * @param fd is the file descriptor returned by socket()
  * @param buf is the data to send, which we'll copy if necessary
  * @param size is the byte-length of buf
@@ -39,7 +52,7 @@
  *     EPIPE (if MSG_NOSIGNAL), EMSGSIZE, ENOTSOCK, EFAULT, etc.
  * @cancelationpoint
  * @asyncsignalsafe
- * @restartable (unless SO_RCVTIMEO)
+ * @restartable (unless SO_SNDTIMEO on Linux or Windows)
  */
 ssize_t send(int fd, const void *buf, size_t size, int flags) {
   ssize_t rc;
@@ -66,7 +79,7 @@ ssize_t send(int fd, const void *buf, size_t size, int flags) {
   }
 
   END_CANCELATION_POINT;
-  DATATRACE("send(%d, %#.*hhs%s, %'zu, %#x) → %'ld% lm", fd,
-            MAX(0, MIN(40, rc)), buf, rc > 40 ? "..." : "", size, flags, rc);
+  DATATRACE("send(%d, %#.*hhs%s, %'zu, %s) → %'ld% lm", fd, MAX(0, MIN(40, rc)),
+            buf, rc > 40 ? "..." : "", size, DescribeMsg(flags), rc);
   return rc;
 }
diff --git a/libc/sock/sendfile.c b/libc/sock/sendfile.c
index f5b107a1b..15a5c03cf 100644
--- a/libc/sock/sendfile.c
+++ b/libc/sock/sendfile.c
@@ -25,8 +25,8 @@
 #include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/wsaid.h"
 #include "libc/nt/errors.h"
 #include "libc/nt/events.h"
@@ -38,6 +38,7 @@
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sendfile.internal.h"
+#include "libc/sock/syscall_fd.internal.h"
 #include "libc/sock/wsaid.internal.h"
 #include "libc/stdio/sysparam.h"
 #include "libc/sysv/errfuns.h"
@@ -58,13 +59,14 @@ static void transmitfile_init(void) {
   g_transmitfile.lpTransmitFile = __get_wsaid(&TransmitfileGuid);
 }
 
-static dontinline textwindows ssize_t sys_sendfile_nt(
+textwindows dontinline static ssize_t sys_sendfile_nt(
     int outfd, int infd, int64_t *opt_in_out_inoffset, uint32_t uptobytes) {
   ssize_t rc;
   uint32_t flags = 0;
+  bool locked = false;
   int64_t ih, oh, eof, offset;
   struct NtByHandleFileInformation wst;
-  if (!__isfdkind(infd, kFdFile))
+  if (!__isfdkind(infd, kFdFile) || !g_fds.p[infd].cursor)
     return ebadf();
   if (!__isfdkind(outfd, kFdSocket))
     return ebadf();
@@ -73,7 +75,9 @@ static dontinline textwindows ssize_t sys_sendfile_nt(
   if (opt_in_out_inoffset) {
     offset = *opt_in_out_inoffset;
   } else {
-    offset = g_fds.p[infd].pointer;
+    locked = true;
+    __cursor_lock(g_fds.p[infd].cursor);
+    offset = g_fds.p[infd].cursor->shared->pointer;
   }
   if (GetFileInformationByHandle(ih, &wst)) {
     // TransmitFile() returns EINVAL if `uptobytes` goes past EOF.
@@ -82,20 +86,22 @@ static dontinline textwindows ssize_t sys_sendfile_nt(
       uptobytes = eof - offset;
     }
   } else {
+    if (locked)
+      __cursor_unlock(g_fds.p[infd].cursor);
     return ebadf();
   }
-  BLOCK_SIGNALS;
   struct NtOverlapped ov = {.hEvent = WSACreateEvent(), .Pointer = offset};
   cosmo_once(&g_transmitfile.once, transmitfile_init);
-  if (g_transmitfile.lpTransmitFile(oh, ih, uptobytes, 0, &ov, 0, 0) ||
-      WSAGetLastError() == kNtErrorIoPending ||
-      WSAGetLastError() == WSAEINPROGRESS) {
+  if (ov.hEvent &&
+      (g_transmitfile.lpTransmitFile(oh, ih, uptobytes, 0, &ov, 0, 0) ||
+       WSAGetLastError() == kNtErrorIoPending ||
+       WSAGetLastError() == WSAEINPROGRESS)) {
     if (WSAGetOverlappedResult(oh, &ov, &uptobytes, true, &flags)) {
       rc = uptobytes;
       if (opt_in_out_inoffset) {
         *opt_in_out_inoffset = offset + rc;
       } else {
-        g_fds.p[infd].pointer = offset + rc;
+        g_fds.p[infd].cursor->shared->pointer = offset + rc;
       }
     } else {
       rc = __winsockerr();
@@ -103,8 +109,9 @@ static dontinline textwindows ssize_t sys_sendfile_nt(
   } else {
     rc = __winsockerr();
   }
+  if (locked)
+    __cursor_unlock(g_fds.p[infd].cursor);
   WSACloseEvent(ov.hEvent);
-  ALLOW_SIGNALS;
   return rc;
 }
 
@@ -186,7 +193,9 @@ ssize_t sendfile(int outfd, int infd, int64_t *opt_in_out_inoffset,
   } else if (IsFreebsd() || IsXnu()) {
     rc = sys_sendfile_bsd(outfd, infd, opt_in_out_inoffset, uptobytes);
   } else if (IsWindows()) {
+    BLOCK_SIGNALS;
     rc = sys_sendfile_nt(outfd, infd, opt_in_out_inoffset, uptobytes);
+    ALLOW_SIGNALS;
   } else {
     rc = enosys();
   }
diff --git a/libc/sock/sendmsg.c b/libc/sock/sendmsg.c
index 1b1e32a1d..197e5fd8c 100644
--- a/libc/sock/sendmsg.c
+++ b/libc/sock/sendmsg.c
@@ -19,13 +19,13 @@
 #include "libc/assert.h"
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
diff --git a/libc/sock/sendto-nt.c b/libc/sock/sendto-nt.c
index e6fdb1f17..f0be2f4c9 100644
--- a/libc/sock/sendto-nt.c
+++ b/libc/sock/sendto-nt.c
@@ -17,20 +17,26 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/sigset.internal.h"
+#include "libc/errno.h"
+#include "libc/intrin/fds.h"
+#include "libc/nt/errors.h"
 #include "libc/nt/struct/iovec.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/syscall_fd.internal.h"
 #include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/sicode.h"
+#include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
 #ifdef __x86_64__
 
 #define _MSG_OOB       1
 #define _MSG_DONTROUTE 4
 #define _MSG_DONTWAIT  64
+#define _MSG_NOSIGNAL  0x10000000
 
 struct SendToArgs {
   const struct iovec *iov;
@@ -52,17 +58,26 @@ static textwindows int sys_sendto_nt_start(int64_t handle,
 textwindows ssize_t sys_sendto_nt(int fd, const struct iovec *iov,
                                   size_t iovlen, uint32_t flags,
                                   void *opt_in_addr, uint32_t in_addrsize) {
-  if (flags & ~(_MSG_DONTWAIT | _MSG_OOB | _MSG_DONTROUTE))
+  if (flags & ~(_MSG_DONTWAIT | _MSG_OOB | _MSG_DONTROUTE | _MSG_NOSIGNAL))
     return einval();
   ssize_t rc;
   struct Fd *f = g_fds.p + fd;
-  sigset_t m = __sig_block();
-  bool nonblock = (f->flags & O_NONBLOCK) || (flags & _MSG_DONTWAIT);
-  flags &= ~_MSG_DONTWAIT;
-  rc = __winsock_block(
-      f->handle, flags, nonblock, f->sndtimeo, m, sys_sendto_nt_start,
-      &(struct SendToArgs){iov, iovlen, opt_in_addr, in_addrsize});
-  __sig_unblock(m);
+  sigset_t waitmask = __sig_block();
+
+  rc = __winsock_block(f->handle, flags & ~(_MSG_DONTWAIT | _MSG_NOSIGNAL),
+                       false, f->sndtimeo, waitmask, sys_sendto_nt_start,
+                       &(struct SendToArgs){iov, iovlen,  //
+                                            opt_in_addr, in_addrsize});
+
+  __sig_unblock(waitmask);
+
+  if (rc == -1 && (errno == WSAESHUTDOWN ||      // ESHUTDOWN
+                   errno == WSAECONNABORTED)) {  // ECONNABORTED
+    errno = kNtErrorBrokenPipe;                  // EPIPE
+    if (!(flags & _MSG_NOSIGNAL))
+      __sig_raise(SIGPIPE, SI_KERNEL);
+  }
+
   return rc;
 }
 
diff --git a/libc/sock/sendto.c b/libc/sock/sendto.c
index 61638e132..f5a458aeb 100644
--- a/libc/sock/sendto.c
+++ b/libc/sock/sendto.c
@@ -22,8 +22,9 @@
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/sockaddr.h"
@@ -51,7 +52,7 @@
  *     EPIPE (if MSG_NOSIGNAL), EMSGSIZE, ENOTSOCK, EFAULT, etc.
  * @cancelationpoint
  * @asyncsignalsafe
- * @restartable (unless SO_RCVTIMEO)
+ * @restartable (unless SO_SNDTIMEO on Linux or Windows)
  */
 ssize_t sendto(int fd, const void *buf, size_t size, int flags,
                const struct sockaddr *opt_addr, uint32_t addrsize) {
@@ -88,8 +89,8 @@ ssize_t sendto(int fd, const void *buf, size_t size, int flags,
   }
 
   END_CANCELATION_POINT;
-  DATATRACE("sendto(%d, %#.*hhs%s, %'zu, %#x, %p, %u) → %'ld% lm", fd,
-            MAX(0, MIN(40, rc)), buf, rc > 40 ? "..." : "", size, flags,
-            opt_addr, addrsize, rc);
+  DATATRACE("sendto(%d, %#.*hhs%s, %'zu, %s, %s) → %'ld% lm", fd,
+            MAX(0, MIN(40, rc)), buf, rc > 40 ? "..." : "", size,
+            DescribeMsg(flags), DescribeSockaddr(opt_addr, addrsize), rc);
   return rc;
 }
diff --git a/libc/sock/setsockopt-nt.c b/libc/sock/setsockopt-nt.c
index c6a79b57a..670c9a150 100644
--- a/libc/sock/setsockopt-nt.c
+++ b/libc/sock/setsockopt-nt.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/timeval.h"
+#include "libc/intrin/fds.h"
 #include "libc/nt/struct/linger.h"
 #include "libc/nt/thunk/msabi.h"
 #include "libc/nt/winsock.h"
@@ -36,14 +36,17 @@ textwindows int sys_setsockopt_nt(struct Fd *fd, int level, int optname,
                                   const void *optval, uint32_t optlen) {
 
   // socket read/write timeouts
+  // timeout of zero means wait forever (default)
   if (level == SOL_SOCKET &&
       (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)) {
-    if (!(optval && optlen == sizeof(struct timeval)))
+    if (!optval)
+      return einval();
+    if (optlen < sizeof(struct timeval))
       return einval();
     const struct timeval *tv = optval;
     int64_t ms = timeval_tomillis(*tv);
-    if (ms >= 0xffffffffu)
-      ms = 0;  // wait forever (default)
+    if (ms > -1u)
+      ms = -1u;
     if (optname == SO_RCVTIMEO)
       fd->rcvtimeo = ms;
     if (optname == SO_SNDTIMEO)
@@ -51,7 +54,7 @@ textwindows int sys_setsockopt_nt(struct Fd *fd, int level, int optname,
     return 0;  // we want to handle this on our own
   }
 
-  // how to make close() a blocking i/o call
+  // how to make close() a blocking i/o call lool
   union {
     uint32_t millis;
     struct linger_nt linger;
diff --git a/libc/sock/setsockopt.c b/libc/sock/setsockopt.c
index c7c204eb9..5b4db5661 100644
--- a/libc/sock/setsockopt.c
+++ b/libc/sock/setsockopt.c
@@ -17,11 +17,11 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
diff --git a/libc/sock/shutdown.c b/libc/sock/shutdown.c
index bcf816928..1ec433181 100644
--- a/libc/sock/shutdown.c
+++ b/libc/sock/shutdown.c
@@ -17,9 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/syscall_fd.internal.h"
diff --git a/libc/sock/sock.h b/libc/sock/sock.h
index 43bcf8fb2..64221af63 100644
--- a/libc/sock/sock.h
+++ b/libc/sock/sock.h
@@ -17,21 +17,22 @@ libcesque uint32_t ntohl(uint32_t) pureconst;
 #define ntohl(x) __builtin_bswap32(x)
 #endif
 
+/* clang-format off */
 const char *inet_ntop(int, const void *, char *, uint32_t) libcesque;
 int inet_pton(int, const char *, void *) libcesque;
 uint32_t inet_addr(const char *) libcesque;
 libcesque uint32_t *GetHostIps(void) __wur;
 
 int socket(int, int, int) libcesque;
-int listen(int, int) libcesque;
-int shutdown(int, int) libcesque;
-ssize_t send(int, const void *, size_t, int) libcesque;
-ssize_t recv(int, void *, size_t, int) libcesque;
-ssize_t sendfile(int, int, int64_t *, size_t) libcesque;
-int getsockopt(int, int, int, void *, uint32_t *) libcesque;
-int setsockopt(int, int, int, const void *, uint32_t) libcesque;
+int listen(int, int) libcesque __fd_arg(1);
+int shutdown(int, int) libcesque __fd_arg(1);
+ssize_t send(int, const void *, size_t, int) libcesque __fd_arg(1) __read_only(2, 3);
+ssize_t recv(int, void *, size_t, int) libcesque __fd_arg(1) __write_only(2, 3);
+ssize_t sendfile(int, int, int64_t *, size_t) libcesque __fd_arg(1) __fd_arg(2) __read_write(3);
+int getsockopt(int, int, int, void *, uint32_t *) libcesque __fd_arg(1);
+int setsockopt(int, int, int, const void *, uint32_t) libcesque __fd_arg(1);
 int socketpair(int, int, int, int[2]) libcesque;
-int sockatmark(int) libcesque;
+int sockatmark(int) libcesque __fd_arg(1);
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_SOCK_SOCK_H_ */
diff --git a/libc/sock/sockaddr.c b/libc/sock/sockaddr.c
index f72f664ac..36973bde3 100644
--- a/libc/sock/sockaddr.c
+++ b/libc/sock/sockaddr.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/sock/struct/sockaddr.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/sockaddr.h"
 #include "libc/sock/struct/sockaddr.internal.h"
diff --git a/libc/sock/sockaddr2linux.c b/libc/sock/sockaddr2linux.c
index 69efdb9f1..26fd4e0f4 100644
--- a/libc/sock/sockaddr2linux.c
+++ b/libc/sock/sockaddr2linux.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/struct/sockaddr.internal.h"
 #include "libc/sock/struct/sockaddr6-bsd.internal.h"
diff --git a/libc/sock/sockatmark.c b/libc/sock/sockatmark.c
index 767305d7b..be6ed7696 100644
--- a/libc/sock/sockatmark.c
+++ b/libc/sock/sockatmark.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
diff --git a/libc/sock/sockdebug.c b/libc/sock/sockdebug.c
index 89e029fba..dbdb3e094 100644
--- a/libc/sock/sockdebug.c
+++ b/libc/sock/sockdebug.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/sockaddr.h"
 #include "libc/sock/struct/sockaddr6.h"
@@ -28,8 +28,8 @@
 #include "libc/sysv/consts/ipproto.h"
 #include "libc/sysv/consts/sock.h"
 
-const char *(DescribeSockaddr)(char buf[128], const struct sockaddr *sa,
-                               size_t sasize) {
+const char *_DescribeSockaddr(char buf[128], const struct sockaddr *sa,
+                              size_t sasize) {
   int e;
   size_t n;
   char *p, ip[72];
@@ -56,7 +56,7 @@ const char *(DescribeSockaddr)(char buf[128], const struct sockaddr *sa,
         p = stpcpy(p, ip);
         *p++ = ']';
         *p++ = ':';
-        p = FormatUint32(p, in6->sin6_port);
+        p = FormatUint32(p, ntohs(in6->sin6_port));
       }
     } else if (sa->sa_family == AF_UNIX &&
                sasize >= sizeof(struct sockaddr_un)) {
diff --git a/libc/sock/socket.c b/libc/sock/socket.c
index 23f8de2e3..61b6463ac 100644
--- a/libc/sock/socket.c
+++ b/libc/sock/socket.c
@@ -17,8 +17,8 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sock/internal.h"
 #include "libc/sock/sock.h"
 #include "libc/sysv/consts/af.h"
diff --git a/libc/sock/socketpair-nt.c b/libc/sock/socketpair-nt.c
index 8a6bdb625..833de4b82 100644
--- a/libc/sock/socketpair-nt.c
+++ b/libc/sock/socketpair-nt.c
@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/internal.h"
 #include "libc/calls/state.internal.h"
+#include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/nt/createfile.h"
 #include "libc/nt/enum/accessmask.h"
@@ -33,7 +34,8 @@
 #include "libc/sysv/errfuns.h"
 #ifdef __x86_64__
 
-textwindows int sys_socketpair_nt(int family, int type, int proto, int sv[2]) {
+textwindows static int sys_socketpair_nt_impl(int family, int type, int proto,
+                                              int sv[2]) {
   uint32_t mode;
   int64_t hpipe, h1;
   char16_t pipename[64];
@@ -111,4 +113,12 @@ textwindows int sys_socketpair_nt(int family, int type, int proto, int sv[2]) {
   return rc;
 }
 
+textwindows int sys_socketpair_nt(int family, int type, int proto, int sv[2]) {
+  int rc;
+  BLOCK_SIGNALS;
+  rc = sys_socketpair_nt_impl(family, type, proto, sv);
+  ALLOW_SIGNALS;
+  return rc;
+}
+
 #endif /* __x86_64__ */
diff --git a/libc/sock/struct/ifreq.h b/libc/sock/struct/ifreq.h
index 0f7061f5f..1f6317cb6 100644
--- a/libc/sock/struct/ifreq.h
+++ b/libc/sock/struct/ifreq.h
@@ -1,6 +1,7 @@
 #ifndef COSMOPOLITAN_LIBC_SOCK_STRUCT_IFREQ_H_
 #define COSMOPOLITAN_LIBC_SOCK_STRUCT_IFREQ_H_
 #include "libc/sock/struct/sockaddr.h"
+#include "libc/sock/struct/sockaddr6.h"
 COSMOPOLITAN_C_START_
 
 #define IF_NAMESIZE 16
@@ -11,6 +12,14 @@ struct ifreq {
     char ifrn_name[IFNAMSIZ]; /* Interface name, e.g. "en0".  */
   } ifr_ifrn;
   union {
+    struct {
+      uint16_t sa_family;
+      uint16_t ifr6_ifindex;  /* Interface index */
+      uint16_t ifr6_flags;    /* Flags */
+      uint8_t ifr6_scope;     /* Addr scope */
+      uint8_t ifr6_prefixlen; /* Prefix length */
+      struct in6_addr ifr6_addr;
+    } in6;
     struct sockaddr ifru_addr;      /* SIOCGIFADDR */
     struct sockaddr ifru_dstaddr;   /* SIOCGIFDSTADDR */
     struct sockaddr ifru_netmask;   /* SIOCGIFNETMASK */
@@ -29,5 +38,11 @@ struct ifreq {
 #define ifr_flags     ifr_ifru.ifru_flags     /* flags */
 #define ifr_ifindex   ifr_ifru.ifru_ivalue
 
+#define ifr6_addr      ifr_ifru.in6.ifr6_addr      /* IP6 Addr */
+#define ifr6_scope     ifr_ifru.in6.ifr6_scope     /* IP6 Addr scope */
+#define ifr6_prefixlen ifr_ifru.in6.ifr6_prefixlen /* IP6 Prefix length */
+#define ifr6_ifindex   ifr_ifru.in6.ifr6_ifindex   /* IP6 If index */
+#define ifr6_flags     ifr_ifru.in6.ifr6_flags     /* IP6 If flags */
+
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_SOCK_STRUCT_IFREQ_H_ */
diff --git a/libc/sock/struct/pollfd.internal.h b/libc/sock/struct/pollfd.internal.h
index 70b452258..69f58d30d 100644
--- a/libc/sock/struct/pollfd.internal.h
+++ b/libc/sock/struct/pollfd.internal.h
@@ -11,10 +11,11 @@ int32_t __sys_poll(struct pollfd *, uint64_t, signed);
 int sys_ppoll(struct pollfd *, size_t, const struct timespec *,
               const sigset_t *, size_t);
 int sys_poll_metal(struct pollfd *, size_t, unsigned);
-int sys_poll_nt(struct pollfd *, uint64_t, uint32_t *, const sigset_t *);
+int sys_poll_nt(struct pollfd *, uint64_t, const struct timespec *,
+                const sigset_t *);
 
-const char *DescribePollFds(char[300], ssize_t, struct pollfd *, size_t);
-#define DescribePollFds(x, y, z) DescribePollFds(alloca(300), x, y, z)
+const char *_DescribePollFds(char[300], ssize_t, struct pollfd *, size_t);
+#define DescribePollFds(x, y, z) _DescribePollFds(alloca(300), x, y, z)
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_SOCK_STRUCT_POLLFD_INTERNAL_H_ */
diff --git a/libc/sock/struct/sockaddr.internal.h b/libc/sock/struct/sockaddr.internal.h
index 59d996d4a..724478d2c 100644
--- a/libc/sock/struct/sockaddr.internal.h
+++ b/libc/sock/struct/sockaddr.internal.h
@@ -40,8 +40,8 @@ union sockaddr_storage_linux {
   struct sockaddr_un sun;
 };
 
-const char *DescribeSockaddr(char[128], const struct sockaddr *, size_t);
-#define DescribeSockaddr(sa, sz) DescribeSockaddr(alloca(128), sa, sz)
+const char *_DescribeSockaddr(char[128], const struct sockaddr *, size_t);
+#define DescribeSockaddr(sa, sz) _DescribeSockaddr(alloca(128), sa, sz)
 
 void __convert_bsd_to_sockaddr(struct sockaddr_storage *);
 void __convert_sockaddr_to_bsd(struct sockaddr_storage *);
diff --git a/libc/sock/sys_sendfile_freebsd.S b/libc/sock/sys_sendfile_freebsd.S
index 6e7a97334..a8443b42b 100644
--- a/libc/sock/sys_sendfile_freebsd.S
+++ b/libc/sock/sys_sendfile_freebsd.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 sys_sendfile_freebsd:
 	jmp	sys_sendfile
diff --git a/libc/sock/sys_sendfile_xnu.S b/libc/sock/sys_sendfile_xnu.S
index 99d28b1e4..ca04c39a7 100644
--- a/libc/sock/sys_sendfile_xnu.S
+++ b/libc/sock/sys_sendfile_xnu.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 sys_sendfile_xnu:
 	jmp	sys_sendfile
diff --git a/libc/sock/syscall_fd.internal.h b/libc/sock/syscall_fd.internal.h
index ef898b72e..51f7f8082 100644
--- a/libc/sock/syscall_fd.internal.h
+++ b/libc/sock/syscall_fd.internal.h
@@ -1,15 +1,15 @@
 #ifndef COSMOPOLITAN_LIBC_SOCK_SYSCALL_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_SOCK_SYSCALL_INTERNAL_H_
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/calls/struct/iovec.h"
+#include "libc/intrin/fds.h"
 #include "libc/nt/struct/overlapped.h"
 #include "libc/sock/struct/sockaddr.h"
 COSMOPOLITAN_C_START_
 
-void sys_connect_nt_cleanup(struct Fd *, bool);
 int sys_accept_nt(struct Fd *, struct sockaddr_storage *, int);
 int sys_bind_nt(struct Fd *, const void *, uint32_t);
 int sys_closesocket_nt(struct Fd *);
+int sys_ioctlsocket_nt(struct Fd *);
 int sys_connect_nt(struct Fd *, const void *, uint32_t);
 int sys_getpeername_nt(struct Fd *, void *, uint32_t *);
 int sys_getsockname_nt(struct Fd *, void *, uint32_t *);
diff --git a/libc/sock/winsockblock.c b/libc/sock/winsockblock.c
index e0d0b2848..32a7e0c82 100644
--- a/libc/sock/winsockblock.c
+++ b/libc/sock/winsockblock.c
@@ -16,17 +16,26 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/internal.h"
 #include "libc/calls/sig.internal.h"
 #include "libc/calls/struct/sigset.h"
+#include "libc/calls/struct/timespec.internal.h"
+#include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/errno.h"
+#include "libc/intrin/atomic.h"
 #include "libc/intrin/weaken.h"
 #include "libc/nt/enum/wait.h"
 #include "libc/nt/errors.h"
+#include "libc/nt/events.h"
+#include "libc/nt/runtime.h"
 #include "libc/nt/struct/overlapped.h"
+#include "libc/nt/struct/pollfd.h"
+#include "libc/nt/synchronization.h"
 #include "libc/nt/thread.h"
 #include "libc/nt/winsock.h"
 #include "libc/sock/internal.h"
+#include "libc/sysv/consts/poll.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/posixthread.internal.h"
@@ -39,69 +48,146 @@ __winsock_block(int64_t handle, uint32_t flags, bool nonblock,
                                   uint32_t *flags, void *arg),
                 void *arg) {
 
-RestartOperation:
-  int rc, sig, reason = 0;
-  uint32_t status, exchanged;
-  if (_check_cancel() == -1)
-    return -1;  // ECANCELED
-  if (_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))) {
-    goto HandleInterrupt;
+  // convert relative to absolute timeout
+  struct timespec deadline;
+  if (srwtimeout) {
+    deadline = timespec_add(sys_clock_gettime_monotonic_nt(),
+                            timespec_frommillis(srwtimeout));
+  } else {
+    deadline = timespec_max;
   }
 
-  struct NtOverlapped overlap = {.hEvent = WSACreateEvent()};
-  rc = StartSocketOp(handle, &overlap, &flags, arg);
-  if (rc && WSAGetLastError() == kNtErrorIoPending) {
-    if (nonblock) {
-      CancelIoEx(handle, &overlap);
-      reason = EAGAIN;
-    } else {
-      struct PosixThread *pt;
-      pt = _pthread_self();
-      pt->pt_blkmask = waitmask;
-      pt->pt_iohandle = handle;
-      pt->pt_ioverlap = &overlap;
-      atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_IO,
-                            memory_order_release);
-      status = WSAWaitForMultipleEvents(1, &overlap.hEvent, 0,
-                                        srwtimeout ? srwtimeout : -1u, 0);
-      atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
-      if (status) {
-        if (status == kNtWaitTimeout) {
-          reason = EAGAIN;  // SO_RCVTIMEO or SO_SNDTIMEO elapsed
-        } else {
-          reason = WSAGetLastError();  // ENETDOWN or ENOBUFS
-        }
+  for (;;) {
+    int got_sig = 0;
+    bool got_cancel = false;
+    bool got_eagain = false;
+    uint32_t other_error = 0;
+
+    // create event handle for overlapped i/o
+    intptr_t event;
+    if (!(event = WSACreateEvent()))
+      return __winsockerr();
+
+    struct NtOverlapped overlap = {.hEvent = event};
+    bool32 ok = !StartSocketOp(handle, &overlap, &flags, arg);
+    if (!ok && WSAGetLastError() == kNtErrorIoPending) {
+      if (nonblock) {
+        // send() and sendto() shall not pass O_NONBLOCK along to here
+        // because winsock has a bug that causes CancelIoEx() to cause
+        // WSAGetOverlappedResult() to report errors when it succeeded
         CancelIoEx(handle, &overlap);
+        got_eagain = true;
+      } else {
+        // atomic block on i/o completion, signal, or cancel
+        // it's not safe to acknowledge cancelation from here
+        // it's not safe to call any signal handlers from here
+        intptr_t sev;
+        if ((sev = CreateEvent(0, 0, 0, 0))) {
+          // installing semaphore before sig get makes wait atomic
+          struct PosixThread *pt = _pthread_self();
+          pt->pt_event = sev;
+          pt->pt_blkmask = waitmask;
+          atomic_store_explicit(&pt->pt_blocker, PT_BLOCKER_EVENT,
+                                memory_order_release);
+          if (_is_canceled()) {
+            got_cancel = true;
+            CancelIoEx(handle, &overlap);
+          } else if (_weaken(__sig_get) &&
+                     (got_sig = _weaken(__sig_get)(waitmask))) {
+            CancelIoEx(handle, &overlap);
+          } else {
+            struct timespec now = sys_clock_gettime_monotonic_nt();
+            struct timespec remain = timespec_subz(deadline, now);
+            int64_t millis = timespec_tomillis(remain);
+            uint32_t waitms = MIN(millis, 0xffffffffu);
+            intptr_t hands[] = {event, sev};
+            uint32_t wi = WSAWaitForMultipleEvents(2, hands, 0, waitms, 0);
+            if (wi == 1) {  // semaphore was signaled by signal enqueue
+              CancelIoEx(handle, &overlap);
+              if (_weaken(__sig_get))
+                got_sig = _weaken(__sig_get)(waitmask);
+            } else if (wi == kNtWaitTimeout) {
+              CancelIoEx(handle, &overlap);
+              got_eagain = true;
+            } else if (wi == -1u) {
+              other_error = WSAGetLastError();
+              CancelIoEx(handle, &overlap);
+            }
+          }
+          atomic_store_explicit(&pt->pt_blocker, 0, memory_order_release);
+          CloseHandle(sev);
+        } else {
+          other_error = GetLastError();
+          CancelIoEx(handle, &overlap);
+        }
       }
+      ok = true;
     }
-    rc = 0;
-  }
-  if (!rc) {
-    rc = WSAGetOverlappedResult(handle, &overlap, &exchanged, true, &flags)
-             ? 0
-             : -1;
-  }
-  WSACloseEvent(overlap.hEvent);
+    uint32_t exchanged = 0;
+    if (ok)
+      ok = WSAGetOverlappedResult(handle, &overlap, &exchanged, true, &flags);
+    uint32_t io_error = WSAGetLastError();
+    WSACloseEvent(event);
 
-  if (!rc) {
-    return exchanged;
-  }
-  if (WSAGetLastError() == kNtErrorOperationAborted) {
-    if (reason) {
-      errno = reason;
+    // check if i/o completed
+    // this could forseeably happen even if CancelIoEx was called
+    if (ok) {
+      if (got_sig)  // swallow dequeued signal
+        _weaken(__sig_relay)(got_sig, SI_KERNEL, waitmask);
+      return exchanged;
+    }
+
+    // check if i/o failed
+    if (io_error != kNtErrorOperationAborted) {
+      if (got_sig)  // swallow dequeued signal
+        _weaken(__sig_relay)(got_sig, SI_KERNEL, waitmask);
+      errno = __dos2errno(io_error);
       return -1;
     }
-    if (_weaken(__sig_get) && (sig = _weaken(__sig_get)(waitmask))) {
-    HandleInterrupt:
-      int handler_was_called = _weaken(__sig_relay)(sig, SI_KERNEL, waitmask);
+
+    // it's now reasonable to report semaphore creation error
+    if (other_error) {
+      unassert(!got_sig);
+      errno = __dos2errno(other_error);
+      return -1;
+    }
+
+    // check for non-block cancel or timeout
+    if (got_eagain && !got_sig && !got_cancel)
+      return eagain();
+
+    // check for thread cancelation and acknowledge
+    if (_check_cancel() == -1)
+      return -1;
+
+    // if signal module has been linked, then
+    if (_weaken(__sig_get)) {
+
+      // gobble up all unmasked pending signals
+      // it's now safe to recurse into signal handlers
+      int handler_was_called = 0;
+      do {
+        if (got_sig)
+          handler_was_called |=
+              _weaken(__sig_relay)(got_sig, SI_KERNEL, waitmask);
+      } while ((got_sig = _weaken(__sig_get)(waitmask)));
+
+      // check if SIGTHR handler was called
       if (_check_cancel() == -1)
         return -1;
-      if (handler_was_called != 1)
-        goto RestartOperation;
+
+      // check if signal handler without SA_RESTART was called
+      if (handler_was_called & SIG_HANDLED_NO_RESTART)
+        return eintr();
+
+      // emulates linux behavior of having timeouts @norestart
+      if (handler_was_called & SIG_HANDLED_SA_RESTART)
+        if (srwtimeout)
+          return eintr();
     }
-    return eintr();
+
+    // otherwise try the i/o operation again
   }
-  return __winsockerr();
 }
 
 #endif /* __x86_64__ */
diff --git a/libc/stdalign.h b/libc/stdalign.h
new file mode 100644
index 000000000..293b33799
--- /dev/null
+++ b/libc/stdalign.h
@@ -0,0 +1,12 @@
+#ifndef COSMOPOLITAN_LIBC_STDALIGN_H_
+#define COSMOPOLITAN_LIBC_STDALIGN_H_
+
+#ifndef __cplusplus
+#define alignas _Alignas
+#define alignof _Alignof
+#endif /* __cplusplus */
+
+#define __alignas_is_defined 1
+#define __alignof_is_defined 1
+
+#endif /* COSMOPOLITAN_LIBC_STDALIGN_H_ */
diff --git a/libc/stdalign.internal.h b/libc/stdalign.internal.h
deleted file mode 100644
index 9b4d39de4..000000000
--- a/libc/stdalign.internal.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_STDALIGN_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_STDALIGN_INTERNAL_H_
-
-#ifndef __cplusplus
-#define alignas _Alignas
-#define alignof _Alignof
-#endif /* __cplusplus */
-
-#define __alignas_is_defined 1
-#define __alignof_is_defined 1
-
-#endif /* COSMOPOLITAN_LIBC_STDALIGN_INTERNAL_H_ */
diff --git a/libc/stdckdint.h b/libc/stdckdint.h
index 2f9afb785..f7117b502 100644
--- a/libc/stdckdint.h
+++ b/libc/stdckdint.h
@@ -38,14 +38,13 @@
  * Instead, you'll get a pretty good pure C11 and C++11 implementation.
  *
  * @see https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3096.pdf
- * @version 0.1 (2023-07-22)
+ * @see https://github.com/jart/jtckdint
+ * @version 1.0 (2024-12-07)
  */
 
 #define __STDC_VERSION_STDCKDINT_H__ 202311L
 
-#if ((defined(__llvm__) ||                                              \
-      (defined(__GNUC__) && __GNUC__ * 100 + __GNUC_MINOR__ >= 406)) && \
-     !defined(__STRICT_ANSI__))
+#if (!defined(__STRICT_ANSI__) && defined(__SIZEOF_INT128__))
 #define __ckd_have_int128
 #define __ckd_intmax __int128
 #elif ((defined(__cplusplus) && __cplusplus >= 201103L) ||              \
@@ -58,19 +57,22 @@
 typedef signed __ckd_intmax __ckd_intmax_t;
 typedef unsigned __ckd_intmax __ckd_uintmax_t;
 
-#if (!defined(__STRICT_ANSI__) &&                       \
-     ((defined(__GNUC__) && __GNUC__ >= 5 &&            \
-       !defined(__chibicc__) && !defined(__ICC)) ||     \
-      (__has_builtin(__builtin_add_overflow) &&         \
-       __has_builtin(__builtin_sub_overflow) &&         \
+#if (!defined(__STRICT_ANSI__) &&                                       \
+     ((defined(__GNUC__) && __GNUC__ >= 5 && !defined(__ICC)) ||        \
+      (__has_builtin(__builtin_add_overflow) &&                         \
+       __has_builtin(__builtin_sub_overflow) &&                         \
        __has_builtin(__builtin_mul_overflow))))
 #define ckd_add(res, x, y) __builtin_add_overflow((x), (y), (res))
 #define ckd_sub(res, x, y) __builtin_sub_overflow((x), (y), (res))
 #define ckd_mul(res, x, y) __builtin_mul_overflow((x), (y), (res))
 
-#elif defined(__cplusplus) && __cplusplus >= 201103L
-#include "third_party/libcxx/type_traits"
-#include "third_party/libcxx/limits"
+#elif (defined(__cplusplus) &&                          \
+       (__cplusplus >= 201103L ||                       \
+        (defined(_MSC_VER) && __cplusplus >= 199711L && \
+         __ckd_has_include(<type_traits>) &&            \
+         __ckd_has_include(<limits>))))
+#include <type_traits>
+#include <limits>
 
 template <typename __T, typename __U, typename __V>
 inline bool ckd_add(__T *__res, __U __a, __V __b) {
@@ -158,16 +160,6 @@ inline bool ckd_sub(__T *__res, __U __a, __V __b) {
   __ckd_uintmax_t __y = __b;
   __ckd_uintmax_t __z = __x - __y;
   *__res = __z;
-  if (sizeof(__z) > sizeof(__U) && sizeof(__z) > sizeof(__V)) {
-    if (sizeof(__z) > sizeof(__T) || std::is_signed<__T>::value) {
-      return static_cast<__ckd_intmax_t>(__z) != static_cast<__T>(__z);
-    } else if (!std::is_same<__T, __ckd_uintmax_t>::value) {
-      return (__z != static_cast<__T>(__z) ||
-              ((std::is_signed<__U>::value ||
-                std::is_signed<__V>::value) &&
-               static_cast<__ckd_intmax_t>(__z) < 0));
-    }
-  }
   bool __truncated = false;
   if (sizeof(__T) < sizeof(__ckd_intmax_t)) {
     __truncated = __z != static_cast<__ckd_uintmax_t>(static_cast<__T>(__z));
@@ -266,8 +258,8 @@ inline bool ckd_mul(__T *__res, __U __a, __V __b) {
     case 3: { // u = s * s
       int __o = false;
       if (static_cast<__ckd_intmax_t>(__x & __y) < 0) {
-        __x = -__x;
-        __y = -__y;
+        __x = 0 - __x;
+        __y = 0 - __y;
       } else if (static_cast<__ckd_intmax_t>(__x ^ __y) < 0) {
         __o = __x && __y;
       }
@@ -286,12 +278,12 @@ inline bool ckd_mul(__T *__res, __U __a, __V __b) {
                __z != static_cast<__ckd_uintmax_t>(*__res)));
     }
     case 5: {  // s = u * s
-      __ckd_uintmax_t __t = -__y;
+      __ckd_uintmax_t __t = 0 - __y;
       __t = static_cast<__ckd_intmax_t>(__t) < 0 ? __y : __t;
       __ckd_uintmax_t __p = __t * __x;
       int __o = __t && __p / __t != __x;
       int __n = static_cast<__ckd_intmax_t>(__y) < 0;
-      __ckd_uintmax_t __z = __n ? -__p : __p;
+      __ckd_uintmax_t __z = __n ? 0 - __p : __p;
       *__res = __z;
       __ckd_uintmax_t __m = std::numeric_limits<__ckd_intmax_t>::max();
       return (__o | (__p > __m + __n) |
@@ -299,12 +291,12 @@ inline bool ckd_mul(__T *__res, __U __a, __V __b) {
                __z != static_cast<__ckd_uintmax_t>(*__res)));
     }
     case 6: {  // s = s * u
-      __ckd_uintmax_t __t = -__x;
+      __ckd_uintmax_t __t = 0 - __x;
       __t = static_cast<__ckd_intmax_t>(__t) < 0 ? __x : __t;
       __ckd_uintmax_t __p = __t * __y;
       int __o = __t && __p / __t != __y;
       int __n = static_cast<__ckd_intmax_t>(__x) < 0;
-      __ckd_uintmax_t __z = __n ? -__p : __p;
+      __ckd_uintmax_t __z = __n ? 0 - __p : __p;
       *__res = __z;
       __ckd_uintmax_t __m = std::numeric_limits<__ckd_intmax_t>::max();
       return (__o | (__p > __m + __n) |
@@ -540,8 +532,8 @@ __ckd_declare_sub(__ckd_sub_uint128, unsigned __int128)
       case 3: {  /* u = s * s */                                \
         int __o = 0;                                            \
         if ((__ckd_intmax_t)(__x & __y) < 0) {                  \
-          __x = -__x;                                           \
-          __y = -__y;                                           \
+          __x = 0 - __x;                                        \
+          __y = 0 - __y;                                        \
         } else if ((__ckd_intmax_t)(__x ^ __y) < 0) {           \
           __o = __x && __y;                                     \
         }                                                       \
@@ -560,12 +552,12 @@ __ckd_declare_sub(__ckd_sub_uint128, unsigned __int128)
                  __z != (__ckd_uintmax_t)*(T *)__res));         \
       }                                                         \
       case 5: {  /* s = u * s */                                \
-        __ckd_uintmax_t __t = -__y;                             \
+        __ckd_uintmax_t __t = 0 - __y;                          \
         __t = (__ckd_intmax_t)(__t) < 0 ? __y : __t;            \
         __ckd_uintmax_t __p = __t * __x;                        \
         int __o = __t && __p / __t != __x;                      \
         int __n = (__ckd_intmax_t)__y < 0;                      \
-        __ckd_uintmax_t __z = __n ? -__p : __p;                 \
+        __ckd_uintmax_t __z = __n ? 0 - __p : __p;              \
         *(T *)__res = __z;                                      \
         __ckd_uintmax_t __m = __ckd_sign(__ckd_uintmax_t) - 1;  \
         return (__o | (__p > __m + __n) |                       \
@@ -573,12 +565,12 @@ __ckd_declare_sub(__ckd_sub_uint128, unsigned __int128)
                  __z != (__ckd_uintmax_t)*(T *)__res));         \
       }                                                         \
       case 6: {  /* s = s * u */                                \
-        __ckd_uintmax_t __t = -__x;                             \
+        __ckd_uintmax_t __t = 0 - __x;                          \
         __t = (__ckd_intmax_t)(__t) < 0 ? __x : __t;            \
         __ckd_uintmax_t __p = __t * __y;                        \
         int __o = __t && __p / __t != __y;                      \
         int __n = (__ckd_intmax_t)__x < 0;                      \
-        __ckd_uintmax_t __z = __n ? -__p : __p;                 \
+        __ckd_uintmax_t __z = __n ? 0 - __p : __p;              \
         *(T *)__res = __z;                                      \
         __ckd_uintmax_t __m = __ckd_sign(__ckd_uintmax_t) - 1;  \
         return (__o | (__p > __m + __n) |                       \
diff --git a/libc/stdio/BUILD.mk b/libc/stdio/BUILD.mk
index 069e5cf08..c4d60fc7f 100644
--- a/libc/stdio/BUILD.mk
+++ b/libc/stdio/BUILD.mk
@@ -32,12 +32,13 @@ LIBC_STDIO_A_DIRECTDEPS =				\
 	LIBC_NEXGEN32E					\
 	LIBC_NT_ADVAPI32				\
 	LIBC_NT_KERNEL32				\
-	LIBC_RUNTIME					\
 	LIBC_PROC					\
+	LIBC_RUNTIME					\
 	LIBC_STR					\
 	LIBC_SYSV					\
 	LIBC_SYSV_CALLS					\
-	THIRD_PARTY_GDTOA
+	THIRD_PARTY_DLMALLOC				\
+	THIRD_PARTY_GDTOA				\
 
 LIBC_STDIO_A_DEPS :=					\
 	$(call uniq,$(foreach x,$(LIBC_STDIO_A_DIRECTDEPS),$($(x))))
diff --git a/libc/stdio/alloc.c b/libc/stdio/alloc.c
index ce348098d..ace00fa2f 100644
--- a/libc/stdio/alloc.c
+++ b/libc/stdio/alloc.c
@@ -22,20 +22,14 @@
 
 FILE *__stdio_alloc(void) {
   FILE *f;
+  __stdio_lock();
   if ((f = calloc(1, sizeof(FILE)))) {
-    pthread_mutexattr_t attr;
-    pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-    pthread_mutex_init(&f->lock, &attr);
-    pthread_mutexattr_destroy(&attr);
-    f->dynamic = 1;
+    f->freethis = 1;
+    f->fd = -1;
+    f->lock = (pthread_mutex_t)PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
+    dll_init(&f->elem);
+    dll_make_last(&__stdio.files, &f->elem);
   }
+  __stdio_unlock();
   return f;
 }
-
-void __stdio_free(FILE *f) {
-  pthread_mutex_destroy(&f->lock);
-  if (f->dynamic) {
-    free(f);
-  }
-}
diff --git a/libc/stdio/appendd.c b/libc/stdio/appendd.c
index 409f5d550..025a67055 100644
--- a/libc/stdio/appendd.c
+++ b/libc/stdio/appendd.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/append.h"
 #include "libc/str/str.h"
diff --git a/libc/stdio/appendr.c b/libc/stdio/appendr.c
index d5554531a..fbe47be03 100644
--- a/libc/stdio/appendr.c
+++ b/libc/stdio/appendr.c
@@ -19,7 +19,7 @@
 #include "libc/assert.h"
 #include "libc/dce.h"
 #include "libc/intrin/bsr.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/append.h"
 #include "libc/str/str.h"
diff --git a/libc/stdio/appendw.c b/libc/stdio/appendw.c
index 9c90ff6d0..ffff19be9 100644
--- a/libc/stdio/appendw.c
+++ b/libc/stdio/appendw.c
@@ -19,7 +19,7 @@
 #include "libc/assert.h"
 #include "libc/dce.h"
 #include "libc/intrin/bsr.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/serialize.h"
 #include "libc/stdio/append.h"
diff --git a/libc/stdio/dirstream.c b/libc/stdio/dirstream.c
index 2f080fabe..f77f4e06c 100644
--- a/libc/stdio/dirstream.c
+++ b/libc/stdio/dirstream.c
@@ -26,10 +26,10 @@
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/critbit0.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/createfile.h"
@@ -49,9 +49,10 @@
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/s.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * @fileoverview Directory Streams for Linux+Mac+Windows+FreeBSD+OpenBSD.
@@ -134,11 +135,11 @@ struct dirent_netbsd {
 };
 
 static void lockdir(DIR *dir) {
-  pthread_mutex_lock(&dir->lock);
+  _pthread_mutex_lock(&dir->lock);
 }
 
 static void unlockdir(DIR *dir) {
-  pthread_mutex_unlock(&dir->lock);
+  _pthread_mutex_unlock(&dir->lock);
 }
 
 static textwindows dontinline int fdopendir_nt(DIR *res, int fd) {
diff --git a/libc/stdio/dumphexc.c b/libc/stdio/dumphexc.c
index 3bf900cb6..90bab43eb 100644
--- a/libc/stdio/dumphexc.c
+++ b/libc/stdio/dumphexc.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/append.h"
 #include "libc/stdio/hex.internal.h"
diff --git a/libc/stdio/ecvt.c b/libc/stdio/ecvt.c
index ebb72075c..612a66335 100644
--- a/libc/stdio/ecvt.c
+++ b/libc/stdio/ecvt.c
@@ -22,6 +22,7 @@
 │ Materiel Command, USAF, under agreement number F39502-99-1-0512.             │
 │ SUCH DAMAGE.                                                                 │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/math.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
@@ -53,8 +54,11 @@ __cvt(double value, int ndigit, int *decpt, int *sign, int fmode, int pad)
 	char *p, *rve, c;
 	size_t siz;
 
-	if (ndigit == 0) {
-		*sign = value < 0.0;
+	// Note that we exclude the case of fmode here, since for fcvt having
+	// `ndigit == 0` just means we have to output 0 digits *after* the radix
+	// character
+	if (ndigit == 0 && !fmode) {
+		*sign = signbit(value);
 		*decpt = 0;
 		return ("");
 	}
@@ -71,10 +75,12 @@ __cvt(double value, int ndigit, int *decpt, int *sign, int fmode, int pad)
 	/* __dtoa() doesn't allocate space for 0 so we do it by hand */
 	if (value == 0.0) {
 		*decpt = 1 - fmode;	/* 1 for 'e', 0 for 'f' */
-		*sign = 0;
+		*sign = signbit(value);
 		if ((rve = s = malloc(siz)) == NULL)
 			return(NULL);
-		*rve++ = '0';
+		// handle fcvt(0, 0, ...) by returning ""
+		if (siz > 1)
+			*rve++ = '0';
 		*rve = '\0';
 	} else {
 		p = dtoa(value, fmode + 2, ndigit, decpt, sign, &rve);
diff --git a/libc/stdio/fclose.c b/libc/stdio/fclose.c
index b02c8bf20..2fcf0f790 100644
--- a/libc/stdio/fclose.c
+++ b/libc/stdio/fclose.c
@@ -16,47 +16,26 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
-#include "libc/intrin/weaken.h"
-#include "libc/mem/mem.h"
-#include "libc/runtime/runtime.h"
 #include "libc/stdio/internal.h"
-#include "libc/stdio/stdio.h"
 
 /**
  * Closes standard i/o stream and its underlying thing.
- *
- * @param f is the file object
- * @return 0 on success or -1 on error, which can be a trick for
- *     differentiating between EOF and real errors during previous
- *     i/o calls, without needing to call ferror()
+ * @return 0 on success, or EOF w/ errno
  */
 int fclose(FILE *f) {
-  int rc;
-  if (!f)
-    return 0;
-  __fflush_unregister(f);
-  fflush(f);
-  if (_weaken(free)) {
-    _weaken(free)(f->getln);
-    if (!f->nofree && f->buf != f->mem) {
-      _weaken(free)(f->buf);
-    }
-  }
-  f->state = EOF;
-  if (f->noclose) {
+  int rc = 0;
+  if (f) {
+    flockfile(f);
+    rc |= fflush(f);
+    int fd = f->fd;
     f->fd = -1;
-  } else if (f->fd != -1 && close(f->fd) == -1) {
-    f->state = errno;
+    f->state = EOF;
+    if (fd != -1)
+      rc |= close(fd);
+    funlockfile(f);
+    __stdio_unref(f);
   }
-  if (f->state == EOF) {
-    rc = 0;
-  } else {
-    errno = f->state;
-    rc = EOF;
-  }
-  __stdio_free(f);
   return rc;
 }
diff --git a/libc/stdio/fdopen.c b/libc/stdio/fdopen.c
index eb4437a0a..5f7191d07 100644
--- a/libc/stdio/fdopen.c
+++ b/libc/stdio/fdopen.c
@@ -16,14 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
+#include "libc/mem/mem.h"
 #include "libc/stdio/internal.h"
-#include "libc/stdio/stdio.h"
-#include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/s.h"
-#include "libc/sysv/errfuns.h"
-#include "libc/thread/thread.h"
+
+__static_yoink("fflush");
 
 /**
  * Allocates stream object for already-opened file descriptor.
@@ -38,16 +36,16 @@ FILE *fdopen(int fd, const char *mode) {
   struct stat st;
   if (fstat(fd, &st))
     return 0;
-  if ((f = __stdio_alloc())) {
-    f->fd = fd;
-    f->bufmode = S_ISREG(st.st_mode) ? _IOFBF : _IONBF;
-    f->iomode = fopenflags(mode);
-    f->buf = f->mem;
-    f->size = BUFSIZ;
-    if ((f->iomode & O_ACCMODE) != O_RDONLY) {
-      __fflush_register(f);
-    }
-    return f;
+  if (!(f = __stdio_alloc()))
+    return 0;
+  f->bufmode = S_ISCHR(st.st_mode) ? _IONBF : _IOFBF;
+  f->oflags = fopenflags(mode);
+  f->size = BUFSIZ;
+  if (!(f->buf = malloc(f->size))) {
+    __stdio_unref(f);
+    return 0;
   }
-  return NULL;
+  f->freebuf = 1;
+  f->fd = fd;
+  return f;
 }
diff --git a/libc/stdio/fflush.c b/libc/stdio/fflush.c
index 4a9ef6c8e..4a408d313 100644
--- a/libc/stdio/fflush.c
+++ b/libc/stdio/fflush.c
@@ -16,20 +16,38 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdio/stdio.h"
+#include "libc/cxxabi.h"
+#include "libc/stdio/internal.h"
 
 /**
  * Blocks until data from stream buffer is written out.
  *
  * @param f is the stream handle, or 0 for all streams
- * @return is 0 on success or -1 on error
+ * @return is 0 on success or EOF on error
  */
 int fflush(FILE *f) {
   int rc;
-  if (f)
+  if (f) {
     flockfile(f);
-  rc = fflush_unlocked(f);
-  if (f)
+    rc = fflush_unlocked(f);
     funlockfile(f);
+  } else {
+    __stdio_lock();
+    struct Dll *e, *e2;
+    for (rc = 0, e = dll_last(__stdio.files); e; e = e2) {
+      f = FILE_CONTAINER(e);
+      __stdio_ref(f);
+      __stdio_unlock();
+      rc |= fflush(FILE_CONTAINER(e));
+      __stdio_lock();
+      e2 = dll_prev(__stdio.files, e);
+      __stdio_unref_unlocked(f);
+    }
+    __stdio_unlock();
+  }
   return rc;
 }
+
+__attribute__((__constructor__(60))) static textstartup void fflush_init(void) {
+  __cxa_atexit((void *)fflush, 0, 0);
+}
diff --git a/libc/stdio/fflush.internal.h b/libc/stdio/fflush.internal.h
deleted file mode 100644
index 75e3f3fc2..000000000
--- a/libc/stdio/fflush.internal.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_STDIO_FFLUSH_H_
-#define COSMOPOLITAN_LIBC_STDIO_FFLUSH_H_
-#include "libc/stdio/stdio.h"
-#include "libc/thread/thread.h"
-#include "libc/thread/tls.h"
-COSMOPOLITAN_C_START_
-
-struct StdioFlushHandles {
-  size_t i, n;
-  FILE **p;
-};
-
-struct StdioFlush {
-  struct StdioFlushHandles handles;
-  FILE *handles_initmem[8];
-};
-
-extern struct StdioFlush __fflush;
-extern pthread_mutex_t __fflush_lock_obj;
-
-void __fflush_lock(void);
-void __fflush_unlock(void);
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_STDIO_FFLUSH_H_ */
diff --git a/libc/stdio/fflush_unlocked.c b/libc/stdio/fflush_unlocked.c
index fd8887d79..9532bf9d5 100644
--- a/libc/stdio/fflush_unlocked.c
+++ b/libc/stdio/fflush_unlocked.c
@@ -17,125 +17,45 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/cxxabi.h"
 #include "libc/errno.h"
-#include "libc/intrin/pushpop.internal.h"
-#include "libc/macros.internal.h"
-#include "libc/mem/arraylist.internal.h"
+#include "libc/intrin/weaken.h"
 #include "libc/mem/mem.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/fflush.internal.h"
 #include "libc/stdio/internal.h"
-#include "libc/stdio/stdio.h"
 #include "libc/sysv/consts/o.h"
-#include "libc/thread/thread.h"
-
-void(__fflush_lock)(void) {
-  pthread_mutex_lock(&__fflush_lock_obj);
-}
-
-void(__fflush_unlock)(void) {
-  pthread_mutex_unlock(&__fflush_lock_obj);
-}
-
-static void __stdio_fork_prepare(void) {
-  FILE *f;
-  __fflush_lock();
-  for (int i = 0; i < __fflush.handles.i; ++i) {
-    if ((f = __fflush.handles.p[i])) {
-      pthread_mutex_lock(&f->lock);
-    }
-  }
-}
-
-static void __stdio_fork_parent(void) {
-  FILE *f;
-  for (int i = __fflush.handles.i; i--;) {
-    if ((f = __fflush.handles.p[i])) {
-      pthread_mutex_unlock(&f->lock);
-    }
-  }
-  __fflush_unlock();
-}
-
-static void __stdio_fork_child(void) {
-  FILE *f;
-  for (int i = __fflush.handles.i; i--;) {
-    if ((f = __fflush.handles.p[i])) {
-      bzero(&f->lock, sizeof(f->lock));
-      f->lock._type = PTHREAD_MUTEX_RECURSIVE;
-    }
-  }
-  pthread_mutex_init(&__fflush_lock_obj, 0);
-}
-
-__attribute__((__constructor__(60))) static textstartup void stdioinit(void) {
-  pthread_atfork(__stdio_fork_prepare, __stdio_fork_parent, __stdio_fork_child);
-}
 
 /**
  * Blocks until data from stream buffer is written out.
  *
- * @param f is the stream handle, or 0 for all streams
- * @return is 0 on success or -1 on error
+ * @param f is the stream handle, which must not be null
+ * @return is 0 on success or EOF on error
  */
 int fflush_unlocked(FILE *f) {
-  int rc = 0;
   size_t i;
-  if (!f) {
-    __fflush_lock();
-    for (i = __fflush.handles.i; i; --i) {
-      if ((f = __fflush.handles.p[i - 1])) {
-        if (fflush(f) == -1) {
-          rc = -1;
+  if (f->getln) {
+    if (_weaken(free))
+      _weaken(free)(f->getln);
+    f->getln = 0;
+  }
+  if (f->fd != -1) {
+    if (f->beg && !f->end && (f->oflags & O_ACCMODE) != O_RDONLY) {
+      ssize_t rc;
+      for (i = 0; i < f->beg; i += rc) {
+        if ((rc = write(f->fd, f->buf + i, f->beg - i)) == -1) {
+          f->state = errno;
+          return EOF;
         }
       }
+      f->beg = 0;
     }
-    __fflush_unlock();
-  } else if (f->fd != -1) {
-    if (__fflush_impl(f) == -1) {
-      rc = -1;
+    if (f->beg < f->end && (f->oflags & O_ACCMODE) != O_WRONLY) {
+      if (lseek(f->fd, -(int)(f->end - f->beg), SEEK_CUR) == -1) {
+        f->state = errno;
+        return EOF;
+      }
+      f->end = f->beg;
     }
-  } else if (f->beg && f->beg < f->size) {
+  }
+  if (f->buf && f->beg && f->beg < f->size)
     f->buf[f->beg] = 0;
-  }
-  return rc;
-}
-
-textstartup int __fflush_register(FILE *f) {
-  int rc;
-  size_t i;
-  struct StdioFlush *sf;
-  __fflush_lock();
-  sf = &__fflush;
-  if (!sf->handles.p) {
-    sf->handles.p = sf->handles_initmem;
-    pushmov(&sf->handles.n, ARRAYLEN(sf->handles_initmem));
-    __cxa_atexit((void *)fflush_unlocked, 0, 0);
-  }
-  for (i = sf->handles.i; i; --i) {
-    if (!sf->handles.p[i - 1]) {
-      sf->handles.p[i - 1] = f;
-      __fflush_unlock();
-      return 0;
-    }
-  }
-  rc = append(&sf->handles, &f);
-  __fflush_unlock();
-  return rc;
-}
-
-void __fflush_unregister(FILE *f) {
-  size_t i;
-  struct StdioFlush *sf;
-  __fflush_lock();
-  sf = &__fflush;
-  sf = pushpop(sf);
-  for (i = sf->handles.i; i; --i) {
-    if (sf->handles.p[i - 1] == f) {
-      pushmov(&sf->handles.p[i - 1], 0);
-      break;
-    }
-  }
-  __fflush_unlock();
+  return 0;
 }
diff --git a/libc/stdio/fflushimpl.c b/libc/stdio/fflushimpl.c
deleted file mode 100644
index 41e047f01..000000000
--- a/libc/stdio/fflushimpl.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/errno.h"
-#include "libc/intrin/weaken.h"
-#include "libc/mem/mem.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/internal.h"
-#include "libc/stdio/stdio.h"
-#include "libc/sysv/consts/o.h"
-
-int __fflush_impl(FILE *f) {
-  size_t i;
-  ssize_t rc;
-  if (f->getln) {
-    if (_weaken(free)) {
-      _weaken(free)(f->getln);
-    }
-    f->getln = 0;
-  }
-  if (f->fd != -1) {
-    if (f->beg && !f->end && (f->iomode & O_ACCMODE) != O_RDONLY) {
-      for (i = 0; i < f->beg; i += rc) {
-        if ((rc = write(f->fd, f->buf + i, f->beg - i)) == -1) {
-          f->state = errno;
-          return -1;
-        }
-      }
-      f->beg = 0;
-    }
-    if (f->beg < f->end && (f->iomode & O_ACCMODE) != O_WRONLY) {
-      if (lseek(f->fd, -(int)(f->end - f->beg), SEEK_CUR) == -1) {
-        f->state = errno;
-        return -1;
-      }
-      f->end = f->beg;
-    }
-  }
-  return 0;
-}
diff --git a/libc/stdio/fgets_unlocked.c b/libc/stdio/fgets_unlocked.c
index 9fb38e00c..0210dc829 100644
--- a/libc/stdio/fgets_unlocked.c
+++ b/libc/stdio/fgets_unlocked.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdio/internal.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
diff --git a/libc/stdio/flockfile.c b/libc/stdio/flockfile.c
index 556f86b63..4b16a0778 100644
--- a/libc/stdio/flockfile.c
+++ b/libc/stdio/flockfile.c
@@ -16,13 +16,15 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/stdio/internal.h"
-#include "libc/stdio/stdio.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 
 /**
  * Acquires reentrant lock on stdio object, blocking if needed.
  */
 void flockfile(FILE *f) {
-  pthread_mutex_lock(&f->lock);
+  unassert(f != NULL);
+  _pthread_mutex_lock(&f->lock);
 }
diff --git a/libc/stdio/flushlbf.c b/libc/stdio/flushlbf.c
index 53a7d1a80..860e093b1 100644
--- a/libc/stdio/flushlbf.c
+++ b/libc/stdio/flushlbf.c
@@ -17,7 +17,6 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/stdio/fflush.internal.h"
 #include "libc/stdio/internal.h"
 #include "libc/stdio/stdio.h"
 #include "libc/stdio/stdio_ext.h"
@@ -26,17 +25,18 @@
  * Flushes all line-buffered streams.
  */
 void _flushlbf(void) {
-  int i;
-  FILE *f;
-  __fflush_lock();
-  for (i = 0; i < __fflush.handles.i; ++i) {
-    if ((f = __fflush.handles.p[i])) {
-      flockfile(f);
-      if (f->bufmode == _IOLBF) {
-        fflush_unlocked(f);
-      }
-      funlockfile(f);
+  __stdio_lock();
+  struct Dll *e, *e2;
+  for (e = dll_last(__stdio.files); e; e = e2) {
+    FILE *f = FILE_CONTAINER(e);
+    if (f->bufmode == _IOLBF) {
+      __stdio_ref(f);
+      __stdio_unlock();
+      fflush(FILE_CONTAINER(e));
+      __stdio_lock();
+      e2 = dll_prev(__stdio.files, e);
+      __stdio_unref_unlocked(f);
     }
   }
-  __fflush_unlock();
+  __stdio_unlock();
 }
diff --git a/libc/stdio/fmemopen.c b/libc/stdio/fmemopen.c
index 21945de76..3834a7d1e 100644
--- a/libc/stdio/fmemopen.c
+++ b/libc/stdio/fmemopen.c
@@ -37,36 +37,31 @@
 FILE *fmemopen(void *buf, size_t size, const char *mode) {
   FILE *f;
   char *p;
-  int iomode;
-  iomode = fopenflags(mode);
+  int oflags;
+  oflags = fopenflags(mode);
   if ((size && size > 0x7ffff000) ||  //
-      (!buf && (iomode & O_ACCMODE) != O_RDWR)) {
+      (!buf && (oflags & O_ACCMODE) != O_RDWR)) {
     einval();
     return NULL;
   }
-  if (!(f = __stdio_alloc())) {
+  if (!(f = __stdio_alloc()))
     return NULL;
-  }
-  if (buf) {
-    f->nofree = true;
-  } else {
+  if (!buf) {
     if (!size)
       size = BUFSIZ;
-    // TODO(jart): Why do we need calloc()?
-    if (!_weaken(calloc) || !(buf = _weaken(calloc)(1, size))) {
-      __stdio_free(f);
+    if (!(buf = malloc(size))) {
+      __stdio_unref(f);
       enomem();
       return NULL;
     }
+    f->freebuf = 1;
   }
-  f->fd = -1;
   f->buf = buf;
-  if (!(iomode & O_TRUNC)) {
+  if (!(oflags & O_TRUNC))
     f->end = size;
-  }
   f->size = size;
-  f->iomode = iomode;
-  if (iomode & O_APPEND) {
+  f->oflags = oflags;
+  if (oflags & O_APPEND) {
     if ((p = memchr(buf, '\0', size))) {
       f->beg = p - (char *)buf;
     } else {
diff --git a/libc/stdio/fmt.c b/libc/stdio/fmt.c
index b8c31bc63..5f476e1a0 100644
--- a/libc/stdio/fmt.c
+++ b/libc/stdio/fmt.c
@@ -39,23 +39,26 @@
 │ THIS SOFTWARE.                                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/ctype.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/divmod10.internal.h"
+#include "libc/fmt/internal.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/bsr.h"
-#include "libc/intrin/nomultics.internal.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/nomultics.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 #include "libc/mem/reverse.internal.h"
+#include "libc/runtime/fenv.h"
 #include "libc/runtime/internal.h"
 #include "libc/serialize.h"
 #include "libc/str/str.h"
 #include "libc/str/strwidth.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/str/thompike.h"
 #include "libc/str/unicode.h"
 #include "libc/str/utf16.h"
@@ -74,9 +77,9 @@
 #define FLAGS_PRECISION 0x20
 #define FLAGS_ISSIGNED  0x40
 #define FLAGS_NOQUOTE   0x80
-#define FLAGS_QUOTE     FLAGS_SPACE
+#define FLAGS_REPR      0x100
+#define FLAGS_QUOTE     0x200
 #define FLAGS_GROUPING  FLAGS_NOQUOTE
-#define FLAGS_REPR      FLAGS_PLUS
 
 #define __FMT_PUT(C)              \
   do {                            \
@@ -88,7 +91,7 @@
 
 struct FPBits {
   uint32_t bits[4];
-  const FPI *fpi;
+  FPI fpi;
   int sign;
   int ex;  // exponent
   int kind;
@@ -448,7 +451,10 @@ static int __fmt_stoa(int out(const char *, void *, size_t), void *arg,
     } else if (signbit == 15) {
       precision = strnlen16((const char16_t *)p, precision);
     } else {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-overread"
       precision = strnlen(p, precision);
+#pragma GCC diagnostic pop
     }
   }
 
@@ -558,7 +564,13 @@ static int __fmt_stoa(int out(const char *, void *, size_t), void *arg,
 
 static void __fmt_dfpbits(union U *u, struct FPBits *b) {
   int ex, i;
-  b->fpi = &kFpiDbl;
+  b->fpi = kFpiDbl;
+
+  // dtoa doesn't need this, unlike gdtoa, but we use it for __fmt_bround
+  i = FLT_ROUNDS;
+  if (i != -1)
+    b->fpi.rounding = i;
+
   b->sign = u->ui[1] & 0x80000000L;
   b->bits[1] = u->ui[1] & 0xfffff;
   b->bits[0] = u->ui[0];
@@ -577,6 +589,7 @@ static void __fmt_dfpbits(union U *u, struct FPBits *b) {
   } else {
     i = STRTOG_Zero;
   }
+  i |= signbit(u->d) ? STRTOG_Neg : 0;
   b->kind = i;
   b->ex = ex - (0x3ff + 52);
 }
@@ -602,7 +615,15 @@ static void __fmt_ldfpbits(union U *u, struct FPBits *b) {
 #else
 #error "unsupported architecture"
 #endif
-  b->fpi = &kFpiLdbl;
+  b->fpi = kFpiLdbl;
+
+  // gdtoa doesn't check for FLT_ROUNDS but for fpi.rounding (which has the
+  // same valid values as FLT_ROUNDS), so handle this here
+  // (we also use this in __fmt_bround now)
+  i = FLT_ROUNDS;
+  if (i != -1)
+    b->fpi.rounding = i;
+
   b->sign = sex & 0x8000;
   if ((ex = sex & 0x7fff) != 0) {
     if (ex != 0x7fff) {
@@ -610,7 +631,7 @@ static void __fmt_ldfpbits(union U *u, struct FPBits *b) {
 #if LDBL_MANT_DIG == 113
       b->bits[3] |= 1 << (112 - 32 * 3);  // set lowest exponent bit
 #endif
-    } else if (b->bits[0] | b->bits[1] | b->bits[2] | b->bits[3]) {
+    } else if (isnan(u->ld)) {
       i = STRTOG_NaN;
     } else {
       i = STRTOG_Infinite;
@@ -621,6 +642,7 @@ static void __fmt_ldfpbits(union U *u, struct FPBits *b) {
   } else {
     i = STRTOG_Zero;
   }
+  i |= signbit(u->ld) ? STRTOG_Neg : 0;
   b->kind = i;
   b->ex = ex - (0x3fff + (LDBL_MANT_DIG - 1));
 #endif
@@ -631,9 +653,9 @@ static int __fmt_fpiprec(struct FPBits *b) {
   const FPI *fpi;
   int i, j, k, m;
   uint32_t *bits;
-  if (b->kind == STRTOG_Zero)
+  if ((b->kind & STRTOG_Retmask) == STRTOG_Zero)
     return (b->ex = 0);
-  fpi = b->fpi;
+  fpi = &b->fpi;
   bits = b->bits;
   for (k = (fpi->nbits - 1) >> 2; k > 0; --k) {
     if ((bits[k >> 3] >> 4 * (k & 7)) & 0xf) {
@@ -672,26 +694,47 @@ static int __fmt_fpiprec(struct FPBits *b) {
 // prec1 = incoming precision (after ".")
 static int __fmt_bround(struct FPBits *b, int prec, int prec1) {
   uint32_t *bits, t;
-  int i, inc, j, k, m, n;
+  int i, j, k, m, n;
+  bool inc = false;
   m = prec1 - prec;
   bits = b->bits;
-  inc = 0;
   k = m - 1;
+
+  // The first two ifs here handle cases where rounding is simple, i.e. where we
+  // always know in which direction we must round because of the current
+  // rounding mode (note that if the correct value for inc is `false` then it
+  // doesn't need to be set as we have already done so above)
+  // They use the FLT_ROUNDS value, which are the same as gdtoa's FPI_Round_*
+  // enum values
+  if (b->fpi.rounding == FPI_Round_zero ||
+      (b->fpi.rounding == FPI_Round_up && b->sign) ||
+      (b->fpi.rounding == FPI_Round_down && !b->sign))
+    goto have_inc;
+  if ((b->fpi.rounding == FPI_Round_up && !b->sign) ||
+      (b->fpi.rounding == FPI_Round_down && b->sign))
+    goto inc_true;
+
+  // Rounding to nearest, ties to even
   if ((t = bits[k >> 3] >> (j = (k & 7) * 4)) & 8) {
     if (t & 7)
-      goto inc1;
-    if (j && bits[k >> 3] << (32 - j))
-      goto inc1;
+      goto inc_true;
+    // ((1 << (j * 4)) - 1) will mask appropriately for the lower bits
+    if ((bits[k >> 3] & ((1 << (j * 4)) - 1)) != 0)
+      goto inc_true;
+    // If exactly halfway and all lower bits are zero (tie), round to even
+    if ((bits[k >> 3] >> (j + 1) * 4) & 1)
+      goto inc_true;
     while (k >= 8) {
       k -= 8;
       if (bits[k >> 3]) {
-      inc1:
-        inc = 1;
-        goto haveinc;
+      inc_true:
+        inc = true;
+        goto have_inc;
       }
     }
   }
-haveinc:
+
+have_inc:
   b->ex += m * 4;
   i = m >> 3;
   k = prec1 >> 3;
@@ -715,7 +758,12 @@ haveinc:
       donothing;
     if (j > k) {
     onebit:
-      bits[0] = 1;
+      // We use 0x10 instead of 1 here to ensure that the digit before the
+      // decimal-point is non-0 (the C standard mandates this, i.e. considers
+      // that printing 0x0.1p+5 is illegal where 0x1.0p+1 is even though both
+      // evaluate to the same value because the first has 0 as the digit before
+      // the decimal-point character)
+      bits[0] = 0x10;
       b->ex += 4 * prec;
       return 1;
     }
@@ -816,7 +864,7 @@ static int __fmt_noop(const char *, void *, size_t) {
  * @asyncsignalsafe if floating point isn't used
  * @vforksafe if floating point isn't used
  */
-int __fmt(void *fn, void *arg, const char *format, va_list va) {
+int __fmt(void *fn, void *arg, const char *format, va_list va, int *wrote) {
   long ld;
   void *p;
   double x;
@@ -1042,9 +1090,10 @@ int __fmt(void *fn, void *arg, const char *format, va_list va) {
       case 'x':
         log2base = 4;
         goto FormatNumber;
+      case 'B':
       case 'b':
         log2base = 1;
-        alphabet = "0123456789abcdefpb";
+        alphabet = (d == 'b' ? "0123456789abcdefpb" : "0123456789ABCDEFPB");
         goto FormatNumber;
       case 'o':
         log2base = 3;
@@ -1068,6 +1117,9 @@ int __fmt(void *fn, void *arg, const char *format, va_list va) {
         }
         break;
       }
+      case 'C':
+        signbit = 63;
+        // fallthrough
       case 'c':
         if ((charbuf[0] = va_arg(va, int))) {
           p = charbuf;
@@ -1117,7 +1169,25 @@ int __fmt(void *fn, void *arg, const char *format, va_list va) {
         }
         break;
       case 'n':
-        __FMT_PUT('\n');
+        switch (signbit) {
+          case 7:
+            *va_arg(va, int8_t *) = *wrote;
+            break;
+          case 15:
+            *va_arg(va, int16_t *) = *wrote;
+            break;
+          case 31:
+            *va_arg(va, int32_t *) = *wrote;
+            break;
+          case 63:
+            *va_arg(va, int64_t *) = *wrote;
+            break;
+          case 127:
+            *va_arg(va, int128_t *) = *wrote;
+            break;
+          default:
+            npassert(false);
+        }
         break;
 
       case 'F':
@@ -1137,11 +1207,13 @@ int __fmt(void *fn, void *arg, const char *format, va_list va) {
         } else {
           un.ld = va_arg(va, long double);
           __fmt_ldfpbits(&un, &fpb);
-          s = s0 =
-              gdtoa(fpb.fpi, fpb.ex, fpb.bits, &fpb.kind, 3, prec, &decpt, &se);
+          s = s0 = gdtoa(&fpb.fpi, fpb.ex, fpb.bits, &fpb.kind, 3, prec, &decpt,
+                         &se);
         }
-        if (decpt == 9999) {
-        Format9999:
+        if (s0 == NULL)
+          return -1;
+        if (decpt == 9999 || decpt == -32768) {
+        FormatDecpt9999Or32768:
           if (s0)
             freedtoa(s0);
           bzero(special, sizeof(special));
@@ -1153,7 +1225,10 @@ int __fmt(void *fn, void *arg, const char *format, va_list va) {
           } else if (flags & FLAGS_SPACE) {
             *q++ = ' ';
           }
-          memcpy(q, kSpecialFloats[fpb.kind == STRTOG_NaN][d >= 'a'], 4);
+          memcpy(q,
+                 kSpecialFloats[(fpb.kind & STRTOG_Retmask) == STRTOG_NaN]
+                               [d >= 'a'],
+                 4);
           flags &= ~(FLAGS_PRECISION | FLAGS_PLUS | FLAGS_HASH | FLAGS_SPACE);
           prec = 0;
           rc = __fmt_stoa(out, arg, s, flags, prec, width, signbit, qchar);
@@ -1250,11 +1325,13 @@ int __fmt(void *fn, void *arg, const char *format, va_list va) {
         } else {
           un.ld = va_arg(va, long double);
           __fmt_ldfpbits(&un, &fpb);
-          s = s0 = gdtoa(fpb.fpi, fpb.ex, fpb.bits, &fpb.kind, prec ? 2 : 0,
+          s = s0 = gdtoa(&fpb.fpi, fpb.ex, fpb.bits, &fpb.kind, prec ? 2 : 0,
                          prec, &decpt, &se);
         }
-        if (decpt == 9999)
-          goto Format9999;
+        if (s0 == NULL)
+          return -1;
+        if (decpt == 9999 || decpt == -32768)
+          goto FormatDecpt9999Or32768;
         c = se - s;
         prec1 = prec;
         if (!prec) {
@@ -1296,11 +1373,13 @@ int __fmt(void *fn, void *arg, const char *format, va_list va) {
         } else {
           un.ld = va_arg(va, long double);
           __fmt_ldfpbits(&un, &fpb);
-          s = s0 = gdtoa(fpb.fpi, fpb.ex, fpb.bits, &fpb.kind, prec ? 2 : 0,
-                         prec, &decpt, &se);
+          s = s0 = gdtoa(&fpb.fpi, fpb.ex, fpb.bits, &fpb.kind, prec ? 2 : 0,
+                         prec + 1, &decpt, &se);
         }
-        if (decpt == 9999)
-          goto Format9999;
+        if (s0 == NULL)
+          return -1;
+        if (decpt == 9999 || decpt == -32768)
+          goto FormatDecpt9999Or32768;
       FormatExpo:
         if (fpb.sign /* && (x || sign) */)
           sign = '-';
@@ -1379,9 +1458,10 @@ int __fmt(void *fn, void *arg, const char *format, va_list va) {
           un.d = va_arg(va, double);
           __fmt_dfpbits(&un, &fpb);
         }
-        if (fpb.kind == STRTOG_Infinite || fpb.kind == STRTOG_NaN) {
+        if ((fpb.kind & STRTOG_Retmask) == STRTOG_Infinite ||
+            (fpb.kind & STRTOG_Retmask) == STRTOG_NaN) {
           s0 = 0;
-          goto Format9999;
+          goto FormatDecpt9999Or32768;
         }
         prec1 = __fmt_fpiprec(&fpb);
         if ((flags & FLAGS_PRECISION) && prec < prec1) {
@@ -1397,7 +1477,7 @@ int __fmt(void *fn, void *arg, const char *format, va_list va) {
             i1 /= 10;
           }
         }
-        if (fpb.sign /* && (sign || fpb.kind != STRTOG_Zero) */) {
+        if (fpb.sign /* && (sign || (fpb.kind & STRTOG_Retmask) != STRTOG_Zero) */) {
           sign = '-';
         }
         if ((width -= bw + 5) > 0) {
@@ -1424,9 +1504,13 @@ int __fmt(void *fn, void *arg, const char *format, va_list va) {
         i1 = prec1 & 7;
         k = prec1 >> 3;
         __FMT_PUT(alphabet[(fpb.bits[k] >> 4 * i1) & 0xf]);
-        if (prec1 > 0 || prec > 0) {
+
+        // decimal-point character appears if the precision isn't 0
+        // or the # flag is specified
+        if (prec1 > 0 || prec > 0 || (flags & FLAGS_HASH)) {
           __FMT_PUT('.');
         }
+
         while (prec1 > 0) {
           if (--i1 < 0) {
             if (--k < 0)
diff --git a/libc/stdio/fopen.c b/libc/stdio/fopen.c
index 0294c5c2d..d077f3c01 100644
--- a/libc/stdio/fopen.c
+++ b/libc/stdio/fopen.c
@@ -17,36 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/mem/mem.h"
-#include "libc/stdio/internal.h"
 #include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/o.h"
-#include "libc/sysv/errfuns.h"
 
-static const char *fixpathname(const char *pathname, int flags) {
-  if ((flags & O_ACCMODE) == O_RDONLY && strcmp(pathname, "-") == 0) {
-    return "/dev/stdin";
-  } else if ((flags & O_ACCMODE) == O_WRONLY && strcmp(pathname, "-") == 0) {
-    return "/dev/stdout";
-  } else {
-    return pathname;
-  }
-}
-
-static int openpathname(const char *pathname, int flags, bool *out_noclose) {
-  if ((flags & O_ACCMODE) == O_RDONLY && strcmp(pathname, "/dev/stdin") == 0) {
-    *out_noclose = true;
-    return fileno(stdin);
-  } else if ((flags & O_ACCMODE) == O_WRONLY &&
-             strcmp(pathname, "/dev/stdout") == 0) {
-    *out_noclose = true;
-    return fileno(stdout);
-  } else {
-    *out_noclose = false;
-    return open(pathname, flags, 0666);
-  }
-}
+__static_yoink("fflush");
 
 /**
  * Opens file as stream object.
@@ -57,21 +30,13 @@ static int openpathname(const char *pathname, int flags, bool *out_noclose) {
  * @note microsoft unilaterally deprecated this function lool
  */
 FILE *fopen(const char *pathname, const char *mode) {
-  FILE *f = 0;
-  bool noclose;
-  int fd, flags;
-  if (!pathname) {
-    efault();
+  int fd;
+  if ((fd = open(pathname, fopenflags(mode), 0666)) == -1)
+    return 0;
+  FILE *f;
+  if (!(f = fdopen(fd, mode))) {
+    close(fd);
     return 0;
-  }
-  flags = fopenflags(mode);
-  pathname = fixpathname(pathname, flags);
-  if ((fd = openpathname(pathname, flags, &noclose)) != -1) {
-    if ((f = fdopen(fd, mode)) != NULL) {
-      f->noclose = noclose;
-    } else if (!noclose) {
-      close(fd);
-    }
   }
   return f;
 }
diff --git a/libc/stdio/fread.c b/libc/stdio/fread.c
index 5c47656cb..22bf3d2f5 100644
--- a/libc/stdio/fread.c
+++ b/libc/stdio/fread.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/internal.h"
 
diff --git a/libc/stdio/fread_unlocked.c b/libc/stdio/fread_unlocked.c
index d76bd3216..98179bf52 100644
--- a/libc/stdio/fread_unlocked.c
+++ b/libc/stdio/fread_unlocked.c
@@ -20,7 +20,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdckdint.h"
 #include "libc/stdio/internal.h"
 #include "libc/stdio/stdio.h"
@@ -28,21 +28,27 @@
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/errfuns.h"
 
-static ssize_t readvall(int fd, struct iovec *iov, int iovlen) {
+static ssize_t readvall(FILE *f, struct iovec *iov, int iovlen, size_t need) {
   ssize_t rc;
   size_t got, toto;
-  toto = 0;
-  do {
-    if ((rc = readv(fd, iov, iovlen)) == -1) {
-      if (toto) {
-        if (errno == EINTR)
-          continue;
+  for (toto = 0;;) {
+
+    // perform i/o
+    if ((rc = readv(f->fd, iov, iovlen)) == -1) {
+      f->state = errno;
+      if (toto)
         return toto;
-      }
       return -1;
     }
     got = rc;
     toto += got;
+    if (!got) {
+      f->state = EOF;
+      return toto;
+    }
+
+    // roll forward iov
+    // skip over empty elements
     for (;;) {
       if (!iov->iov_len) {
         --iovlen;
@@ -56,9 +62,14 @@ static ssize_t readvall(int fd, struct iovec *iov, int iovlen) {
         iov->iov_len -= got;
         break;
       }
+      if (!iovlen)
+        return toto;
     }
-  } while (got && iovlen);
-  return toto;
+
+    // don't trigger eof condition if we're rolling greed to fill buffer
+    if (toto >= need)
+      return toto;
+  }
 }
 
 /**
@@ -75,7 +86,7 @@ size_t fread_unlocked(void *buf, size_t stride, size_t count, FILE *f) {
   size_t n, m, got, need;
 
   // check state and parameters
-  if ((f->iomode & O_ACCMODE) == O_WRONLY) {
+  if ((f->oflags & O_ACCMODE) == O_WRONLY) {
     f->state = errno = EBADF;
     return 0;
   }
@@ -134,27 +145,16 @@ size_t fread_unlocked(void *buf, size_t stride, size_t count, FILE *f) {
     iov[1].iov_base = NULL;
     iov[1].iov_len = 0;
   }
-  if (f->bufmode == _IONBF) {
-    rc = readv(f->fd, iov, 2);
-  } else {
-    rc = readvall(f->fd, iov, 2);
-  }
-  if (rc == -1) {
-    f->state = errno;
+  rc = readvall(f, iov, 2, need);
+  if (rc == -1)
     return 0;
-  }
   got = rc;
 
   // handle partial fulfillment
   if (got < need) {
     got += m;
-    if (got % stride) {
-      f->state = eio();
-      return 0;
-    }
     f->beg = 0;
     f->end = 0;
-    f->state = EOF;
     return got / stride;
   }
 
diff --git a/libc/stdio/freadable.c b/libc/stdio/freadable.c
index ff78a7a84..8a623623a 100644
--- a/libc/stdio/freadable.c
+++ b/libc/stdio/freadable.c
@@ -24,6 +24,6 @@
  * Returns nonzero if stream allows reading.
  */
 int __freadable(FILE *f) {
-  return (f->iomode & O_ACCMODE) == O_RDONLY ||
-         (f->iomode & O_ACCMODE) == O_RDWR;
+  return (f->oflags & O_ACCMODE) == O_RDONLY ||
+         (f->oflags & O_ACCMODE) == O_RDWR;
 }
diff --git a/libc/stdio/freading.c b/libc/stdio/freading.c
index 2e3782b3f..0f447bf5b 100644
--- a/libc/stdio/freading.c
+++ b/libc/stdio/freading.c
@@ -24,5 +24,5 @@
  * Returns nonzero if stream is read only.
  */
 int __freading(FILE *f) {
-  return (f->iomode & O_ACCMODE) == O_RDONLY;
+  return (f->oflags & O_ACCMODE) == O_RDONLY;
 }
diff --git a/libc/stdio/freopen.c b/libc/stdio/freopen.c
index aabcfa340..c2db89e60 100644
--- a/libc/stdio/freopen.c
+++ b/libc/stdio/freopen.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/stdio/internal.h"
 #include "libc/stdio/stdio.h"
@@ -37,8 +38,8 @@
  * @return stream object if successful, or NULL w/ errno
  */
 FILE *freopen(const char *pathname, const char *mode, FILE *stream) {
-  int fd;
   FILE *res;
+  int fd, fd2;
   unsigned flags;
   flags = fopenflags(mode);
   flockfile(stream);
@@ -46,19 +47,30 @@ FILE *freopen(const char *pathname, const char *mode, FILE *stream) {
   if (pathname) {
     /* open new stream, overwriting existing alloc */
     if ((fd = open(pathname, flags, 0666)) != -1) {
-      dup3(fd, stream->fd, flags & O_CLOEXEC);
+      fd2 = dup3(fd, stream->fd, flags & O_CLOEXEC);
       close(fd);
-      stream->iomode = flags;
-      stream->beg = 0;
-      stream->end = 0;
-      res = stream;
+      if (fd2 != -1) {
+        stream->fd = fd2;
+        stream->oflags = flags;
+        stream->beg = 0;
+        stream->end = 0;
+        res = stream;
+      } else {
+        res = NULL;
+      }
     } else {
       res = NULL;
     }
   } else {
-    fcntl(stream->fd, F_SETFD, !!(flags & O_CLOEXEC));
-    fcntl(stream->fd, F_SETFL, flags & ~O_CLOEXEC);
-    res = stream;
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wanalyzer-fd-use-without-check"
+    if (fcntl(stream->fd, F_SETFD, !!(flags & O_CLOEXEC)) != -1 &&
+        fcntl(stream->fd, F_SETFL, flags & ~O_CLOEXEC) != -1) {
+#pragma GCC diagnostic pop
+      res = stream;
+    } else {
+      res = NULL;
+    }
   }
   funlockfile(stream);
   return res;
diff --git a/libc/stdio/fseek.c b/libc/stdio/fseek.c
index 49235a912..d8a549ac5 100644
--- a/libc/stdio/fseek.c
+++ b/libc/stdio/fseek.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/stdio/internal.h"
 
 /**
diff --git a/libc/stdio/fseek_unlocked.c b/libc/stdio/fseek_unlocked.c
index 6703a59ec..b3fd2bbbe 100644
--- a/libc/stdio/fseek_unlocked.c
+++ b/libc/stdio/fseek_unlocked.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdio/internal.h"
 #include "libc/stdio/stdio.h"
 #include "libc/sysv/consts/o.h"
@@ -34,13 +34,13 @@
  * @param f is a non-null stream handle
  * @param offset is the byte delta
  * @param whence can be SEET_SET, SEEK_CUR, or SEEK_END
- * @returns 0 on success or -1 on error
+ * @returns 0 on success or -1 w/ errno
  */
 int fseek_unlocked(FILE *f, int64_t offset, int whence) {
   int res;
   int64_t pos;
   if (f->fd != -1) {
-    if (__fflush_impl(f) == -1)
+    if (fflush_unlocked(f) == EOF)
       return -1;
     if (whence == SEEK_CUR && f->beg < f->end) {
       offset -= f->end - f->beg;
diff --git a/libc/stdio/ftell.c b/libc/stdio/ftell.c
index 7330e35d6..103a7d217 100644
--- a/libc/stdio/ftell.c
+++ b/libc/stdio/ftell.c
@@ -26,7 +26,7 @@
 static inline int64_t ftell_unlocked(FILE *f) {
   int64_t pos;
   if (f->fd != -1) {
-    if (__fflush_impl(f) == -1)
+    if (fflush_unlocked(f) == EOF)
       return -1;
     if ((pos = lseek(f->fd, 0, SEEK_CUR)) != -1) {
       if (f->beg < f->end)
diff --git a/libc/stdio/funlockfile.c b/libc/stdio/funlockfile.c
index b47f8ab9d..cfeb7f534 100644
--- a/libc/stdio/funlockfile.c
+++ b/libc/stdio/funlockfile.c
@@ -18,11 +18,12 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/stdio/internal.h"
 #include "libc/stdio/stdio.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 
 /**
  * Releases lock on stdio object.
  */
 void funlockfile(FILE *f) {
-  pthread_mutex_unlock(&f->lock);
+  _pthread_mutex_unlock(&f->lock);
 }
diff --git a/libc/stdio/fwritable.c b/libc/stdio/fwritable.c
index df10a0aea..ef1205bb8 100644
--- a/libc/stdio/fwritable.c
+++ b/libc/stdio/fwritable.c
@@ -24,6 +24,6 @@
  * Returns nonzero if stream allows reading.
  */
 int __fwritable(FILE *f) {
-  return (f->iomode & O_ACCMODE) == O_WRONLY ||
-         (f->iomode & O_ACCMODE) == O_RDWR;
+  return (f->oflags & O_ACCMODE) == O_WRONLY ||
+         (f->oflags & O_ACCMODE) == O_RDWR;
 }
diff --git a/libc/stdio/fwrite.c b/libc/stdio/fwrite.c
index 11d2445ae..41d7141d9 100644
--- a/libc/stdio/fwrite.c
+++ b/libc/stdio/fwrite.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/stdio/internal.h"
 
 /**
diff --git a/libc/stdio/fwrite_unlocked.c b/libc/stdio/fwrite_unlocked.c
index ef29022fe..ed1cc7c39 100644
--- a/libc/stdio/fwrite_unlocked.c
+++ b/libc/stdio/fwrite_unlocked.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdckdint.h"
 #include "libc/stdio/internal.h"
 #include "libc/stdio/stdio.h"
@@ -74,10 +74,9 @@ size_t fwrite_unlocked(const void *data, size_t stride, size_t count, FILE *f) {
   size_t n, m;
   const char *p;
   struct iovec iov[2];
-  if (!stride || !count) {
+  if (!stride || !count)
     return 0;
-  }
-  if ((f->iomode & O_ACCMODE) == O_RDONLY) {
+  if ((f->oflags & O_ACCMODE) == O_RDONLY) {
     f->state = errno = EBADF;
     return 0;
   }
diff --git a/libc/stdio/fwriting.c b/libc/stdio/fwriting.c
index 8a4f012a1..8a755bcb2 100644
--- a/libc/stdio/fwriting.c
+++ b/libc/stdio/fwriting.c
@@ -24,5 +24,5 @@
  * Returns nonzero if stream is write only.
  */
 int __fwriting(FILE *f) {
-  return (f->iomode & O_ACCMODE) == O_WRONLY;
+  return (f->oflags & O_ACCMODE) == O_WRONLY;
 }
diff --git a/libc/stdio/g_rando.c b/libc/stdio/g_rando.c
deleted file mode 100644
index c702b2fd8..000000000
--- a/libc/stdio/g_rando.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdio/stdio.h"
-
-uint64_t g_rando = 1;
diff --git a/libc/stdio/getdelim_unlocked.c b/libc/stdio/getdelim_unlocked.c
index 036017097..569040836 100644
--- a/libc/stdio/getdelim_unlocked.c
+++ b/libc/stdio/getdelim_unlocked.c
@@ -32,7 +32,7 @@ ssize_t getdelim_unlocked(char **s, size_t *n, int delim, FILE *f) {
   ssize_t rc;
   char *p, *s2;
   size_t i, m, n2;
-  if ((f->iomode & O_ACCMODE) == O_WRONLY) {
+  if ((f->oflags & O_ACCMODE) == O_WRONLY) {
     f->state = errno = EBADF;
     return -1;
   }
@@ -44,9 +44,8 @@ ssize_t getdelim_unlocked(char **s, size_t *n, int delim, FILE *f) {
     *n = 0;
   for (i = 0;; i += m) {
     m = f->end - f->beg;
-    if ((p = memchr(f->buf + f->beg, delim, m))) {
+    if ((p = memchr(f->buf + f->beg, delim, m)))
       m = p + 1 - (f->buf + f->beg);
-    }
     if (i + m + 1 > *n) {
       n2 = i + m + 1;
       s2 = realloc(*s, n2);
@@ -59,10 +58,9 @@ ssize_t getdelim_unlocked(char **s, size_t *n, int delim, FILE *f) {
       }
     }
     memcpy(*s + i, f->buf + f->beg, m);
-    (*s)[i + m] = '\0';
-    if ((f->beg += m) == f->end) {
+    (*s)[i + m] = 0;
+    if ((f->beg += m) == f->end)
       f->beg = f->end = 0;
-    }
     if (p) {
       return i + m;
     } else if (f->fd == -1) {
@@ -71,7 +69,7 @@ ssize_t getdelim_unlocked(char **s, size_t *n, int delim, FILE *f) {
       if (!rc)
         break;
       f->end = rc;
-    } else if (errno != EINTR) {
+    } else {
       f->state = errno;
       return -1;
     }
diff --git a/libc/stdio/getentropy.c b/libc/stdio/getentropy.c
index c9cebf50b..ad8d357a8 100644
--- a/libc/stdio/getentropy.c
+++ b/libc/stdio/getentropy.c
@@ -17,17 +17,17 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/blockcancel.internal.h"
-#include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/stdio/rand.h"
+#include "libc/errno.h"
+#include "libc/intrin/strace.h"
+#include "libc/runtime/syslib.internal.h"
 #include "libc/sysv/errfuns.h"
 
 int sys_getentropy(void *, size_t) asm("sys_getrandom");
 
 /**
- * Returns random seeding bytes, the XNU/OpenBSD way.
+ * Returns random seeding bytes, the POSIX way.
  *
  * @return 0 on success, or -1 w/ errno
  * @raise EFAULT if the `n` bytes at `p` aren't valid memory
@@ -40,18 +40,26 @@ int getentropy(void *p, size_t n) {
     rc = eio();
   } else if ((!p && n)) {
     rc = efault();
+  } else if (IsXnuSilicon()) {
+    rc = __syslib->__getentropy(p, n);
   } else if (IsXnu() || IsOpenbsd()) {
-    if (sys_getentropy(p, n))
-      notpossible;
-    rc = 0;
+    rc = sys_getentropy(p, n);
   } else {
-    BLOCK_SIGNALS;
+    ssize_t got;
     BLOCK_CANCELATION;
-    if (__getrandom(p, n, 0) != n)
-      notpossible;
-    ALLOW_CANCELATION;
-    ALLOW_SIGNALS;
     rc = 0;
+    for (size_t i = 0; i < n; i += got) {
+      got = __getrandom(p + i, n - i, 0);
+      if (got == -1) {
+        if (errno == EAGAIN || errno == EINTR) {
+          got = 0;
+        } else {
+          rc = -1;
+          break;
+        }
+      }
+    }
+    ALLOW_CANCELATION;
   }
   STRACE("getentropy(%p, %'zu) → %'ld% m", p, n, rc);
   return rc;
diff --git a/libc/stdio/internal.h b/libc/stdio/internal.h
index e5f848f80..2f4857a71 100644
--- a/libc/stdio/internal.h
+++ b/libc/stdio/internal.h
@@ -1,39 +1,49 @@
 #ifndef COSMOPOLITAN_LIBC_STDIO_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_STDIO_INTERNAL_H_
+#include "libc/atomic.h"
+#include "libc/intrin/dll.h"
 #include "libc/stdio/stdio.h"
 #include "libc/thread/thread.h"
 
 #define PUSHBACK 12
 
+#define FILE_CONTAINER(e) DLL_CONTAINER(struct FILE, elem, e)
+
 COSMOPOLITAN_C_START_
 
 struct FILE {
-  uint8_t bufmode; /* _IOFBF, etc. (ignored if fd=-1) */
-  char noclose;    /* for fake dup() todo delete! */
-  char dynamic;    /* did malloc() create this object? */
-  uint32_t iomode; /* O_RDONLY, etc. (ignored if fd=-1) */
-  int32_t state;   /* 0=OK, -1=EOF, >0=errno */
-  int fd;          /* ≥0=fd, -1=closed|buffer */
-  uint32_t beg;
-  uint32_t end;
-  char *buf;
-  uint32_t size;
-  uint32_t nofree;
+  char bufmode;  /* _IOFBF, _IOLBF, or _IONBF */
+  char freethis; /* fclose() should free(this) */
+  char freebuf;  /* fclose() should free(this->buf) */
+  char forking;  /* used by fork() implementation */
+  int oflags;    /* O_RDONLY, etc. */
+  int state;     /* 0=OK, -1=EOF, >0=errno */
+  int fd;        /* ≥0=fd, -1=closed|buffer */
   int pid;
-  char *getln;
+  atomic_int refs;
+  unsigned size;
+  unsigned beg;
+  unsigned end;
+  char *buf;
   pthread_mutex_t lock;
-  struct FILE *next;
-  char mem[BUFSIZ];
+  struct Dll elem;
+  char *getln;
 };
 
-extern uint64_t g_rando;
+struct Stdio {
+  pthread_mutex_t lock; /* Subordinate to FILE::lock */
+  struct Dll *files;
+};
 
-int __fflush_impl(FILE *);
-int __fflush_register(FILE *);
-void __fflush_unregister(FILE *);
+extern struct Stdio __stdio;
+
+void __stdio_lock(void);
+void __stdio_unlock(void);
+void __stdio_ref(FILE *);
+void __stdio_unref(FILE *);
+void __stdio_unref_unlocked(FILE *);
 bool __stdio_isok(FILE *);
 FILE *__stdio_alloc(void);
-void __stdio_free(FILE *);
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_STDIO_INTERNAL_H_ */
diff --git a/libc/stdio/kvappendf.c b/libc/stdio/kvappendf.c
index 5c171a1c4..cdbf85b9c 100644
--- a/libc/stdio/kvappendf.c
+++ b/libc/stdio/kvappendf.c
@@ -19,7 +19,7 @@
 #include "libc/assert.h"
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/append.h"
 
diff --git a/libc/stdio/mt19937.c b/libc/stdio/mt19937.c
index 72fd5fce7..778cf2f1f 100644
--- a/libc/stdio/mt19937.c
+++ b/libc/stdio/mt19937.c
@@ -35,7 +35,7 @@
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/likely.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdio/rand.h"
 
 __notice(mt19937_notice, "mt19937 (BSD-3)\n\
diff --git a/libc/stdio/nftw.c b/libc/stdio/nftw.c
index 53c5ca2da..5bcd8dc06 100644
--- a/libc/stdio/nftw.c
+++ b/libc/stdio/nftw.c
@@ -102,15 +102,24 @@ static int do_nftw(char *path,
 		dfd = open(path, O_RDONLY | O_DIRECTORY);
 		err = errno;
 		if (dfd < 0 && err == EACCES) type = FTW_DNR;
-		if (!fd_limit) close(dfd);
+		if (!fd_limit) {
+			close(dfd);
+			dfd = -1;
+		}
         }
 
-	if (!(flags & FTW_DEPTH) && (r=fn(path, &st, type, &lev)))
+	if (!(flags & FTW_DEPTH) && (r=fn(path, &st, type, &lev))) {
+		if (dfd != -1)
+			close(dfd);
 		return r;
+	}
 
 	for (; h; h = h->chain)
-		if (h->dev == st.st_dev && h->ino == st.st_ino)
+		if (h->dev == st.st_dev && h->ino == st.st_ino) {
+			if (dfd != -1)
+				close(dfd);
 			return 0;
+		}
 
 	if ((type == FTW_D || type == FTW_DP) && fd_limit) {
 		if (dfd < 0) {
diff --git a/libc/stdio/printargs.c b/libc/stdio/printargs.c
index 2b549cbdf..b21008128 100644
--- a/libc/stdio/printargs.c
+++ b/libc/stdio/printargs.c
@@ -27,12 +27,12 @@
 #include "libc/calls/ttydefaults.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/promises.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/promises.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/cpuid4.internal.h"
 #include "libc/nexgen32e/kcpuids.h"
 #include "libc/nexgen32e/x86feature.h"
@@ -306,7 +306,7 @@ textstartup void __printargs(const char *prologue) {
       if (i && (u.pfds[i].revents & POLLNVAL))
         continue;
       PRINT(" ☼ %d (revents=%#hx fcntl(F_GETFL)=%s isatty()=%hhhd)", i,
-            u.pfds[i].revents, (DescribeOpenFlags)(oflagbuf, fcntl(i, F_GETFL)),
+            u.pfds[i].revents, _DescribeOpenFlags(oflagbuf, fcntl(i, F_GETFL)),
             isatty(i));
     }
   } else {
@@ -375,7 +375,7 @@ textstartup void __printargs(const char *prologue) {
         rlim.rlim_cur = -1;
       if (rlim.rlim_max == RLIM_INFINITY)
         rlim.rlim_max = -1;
-      PRINT(" ☼ %-20s %,16ld %,16ld", (DescribeRlimitName)(buf, i),
+      PRINT(" ☼ %-20s %,16ld %,16ld", _DescribeRlimitName(buf, i),
             rlim.rlim_cur, rlim.rlim_max);
       gotsome = true;
     }
@@ -468,7 +468,7 @@ textstartup void __printargs(const char *prologue) {
 
   PRINT("");
   PRINT("MEMTRACK");
-  __print_maps();
+  __print_maps(0);
 
   PRINT("");
   PRINT("TERMIOS");
diff --git a/libc/stdio/rand.c b/libc/stdio/rand.c
index 1802d99b2..1a5aad654 100644
--- a/libc/stdio/rand.c
+++ b/libc/stdio/rand.c
@@ -17,9 +17,17 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/stdio/rand.h"
-#include "libc/stdio/internal.h"
 #include "libc/stdio/lcg.internal.h"
 
+static uint64_t rando;
+
+/**
+ * Seeds random number generator that's used by rand().
+ */
+void srand(unsigned seed) {
+  rando = seed;
+}
+
 /**
  * Returns 31-bit linear congruential pseudorandom number, e.g.
  *
@@ -39,5 +47,5 @@
  * @threadunsafe
  */
 int rand(void) {
-  return KnuthLinearCongruentialGenerator(&g_rando) >> 33;
+  return KnuthLinearCongruentialGenerator(&rando) >> 33;
 }
diff --git a/libc/stdio/readpassphrase.c b/libc/stdio/readpassphrase.c
index bff7a96f3..140c2134e 100644
--- a/libc/stdio/readpassphrase.c
+++ b/libc/stdio/readpassphrase.c
@@ -26,6 +26,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/termios.h"
+#include "libc/ctype.h"
 #include "libc/errno.h"
 #include "libc/paths.h"
 #include "libc/str/str.h"
diff --git a/libc/stdio/scandir.c b/libc/stdio/scandir.c
index e9be6e664..2c1d9811d 100644
--- a/libc/stdio/scandir.c
+++ b/libc/stdio/scandir.c
@@ -69,7 +69,9 @@ int scandir(const char *path, struct dirent ***res,
 	}
 	errno = old_errno;
 
-	if (cmp) qsort(names, cnt, sizeof *names, (int (*)(const void *, const void *))cmp);
+	if (cmp && names) {
+		qsort(names, cnt, sizeof *names, (int (*)(const void *, const void *))cmp);
+	}
 	*res = names;
 	return cnt;
 }
diff --git a/libc/stdio/scanf.c b/libc/stdio/scanf.c
index 34f62f620..3afb23cad 100644
--- a/libc/stdio/scanf.c
+++ b/libc/stdio/scanf.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/fmt/internal.h"
 #include "libc/stdio/stdio.h"
 
diff --git a/libc/stdio/setvbuf.c b/libc/stdio/setvbuf.c
index 6be7ca74b..e3ef1d1fb 100644
--- a/libc/stdio/setvbuf.c
+++ b/libc/stdio/setvbuf.c
@@ -38,15 +38,13 @@ int setvbuf(FILE *f, char *buf, int mode, size_t size) {
   if (buf) {
     if (!size)
       size = BUFSIZ;
-    if (!f->nofree &&        //
-        f->buf != buf &&     //
-        f->buf != f->mem &&  //
-        _weaken(free)) {
-      _weaken(free)(f->buf);
-    }
+    if (f->freebuf)
+      if (f->buf != buf)
+        if (_weaken(free))
+          _weaken(free)(f->buf);
     f->buf = buf;
     f->size = size;
-    f->nofree = true;
+    f->freebuf = 0;
   }
   f->bufmode = mode;
   funlockfile(f);
diff --git a/libc/stdio/srand.c b/libc/stdio/srand.c
deleted file mode 100644
index 8b072163e..000000000
--- a/libc/stdio/srand.c
+++ /dev/null
@@ -1,28 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdio/rand.h"
-
-extern uint64_t g_rando;
-
-/**
- * Seeds random number generator that's used by rand().
- */
-void srand(unsigned seed) {
-  g_rando = seed;
-}
diff --git a/libc/stdio/stderr.c b/libc/stdio/stderr.c
index 444a3ed0c..72af4c828 100644
--- a/libc/stdio/stderr.c
+++ b/libc/stdio/stderr.c
@@ -1,5 +1,5 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=8 sts=2 sw=2 fenc=utf-8                               :vi │
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2020 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
@@ -16,27 +16,24 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
+#include "libc/intrin/dll.h"
 #include "libc/stdio/internal.h"
-#include "libc/stdio/stdio.h"
 #include "libc/sysv/consts/fileno.h"
 #include "libc/sysv/consts/o.h"
-#include "libc/thread/thread.h"
+
+static FILE __stderr = {
+    .fd = STDERR_FILENO,
+    .bufmode = _IONBF,
+    .oflags = O_WRONLY,
+    .lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP,
+    .elem = {&__stderr.elem, &__stderr.elem},
+};
 
 /**
  * Pointer to standard error stream.
  */
-FILE *stderr;
+FILE *stderr = &__stderr;
 
-static FILE __stderr;
-
-__attribute__((__constructor__(60))) static textstartup void errinit(void) {
-  stderr = &__stderr;
-  stderr->fd = STDERR_FILENO;
-  stderr->bufmode = _IONBF;
-  stderr->iomode = O_WRONLY;
-  stderr->buf = stderr->mem;
-  stderr->size = sizeof(stderr->mem);
-  stderr->lock._type = PTHREAD_MUTEX_RECURSIVE;
-  __fflush_register(stderr);
+__attribute__((__constructor__(60))) static textstartup void stderr_init(void) {
+  dll_make_last(&__stdio.files, &__stderr.elem);
 }
diff --git a/libc/stdio/stdin.c b/libc/stdio/stdin.c
index e90b18012..8b1b44b9d 100644
--- a/libc/stdio/stdin.c
+++ b/libc/stdio/stdin.c
@@ -1,5 +1,5 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=8 sts=2 sw=2 fenc=utf-8                               :vi │
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2020 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
@@ -16,31 +16,36 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
+#include "libc/intrin/dll.h"
 #include "libc/stdio/internal.h"
-#include "libc/stdio/stdio.h"
 #include "libc/sysv/consts/fileno.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/s.h"
 #include "libc/thread/thread.h"
 
+__static_yoink("fflush");
+
+static char __stdin_buf[BUFSIZ];
+
+static FILE __stdin = {
+    .fd = STDIN_FILENO,
+    .oflags = O_RDONLY,
+    .bufmode = _IOFBF,
+    .buf = __stdin_buf,
+    .size = sizeof(__stdin_buf),
+    .lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP,
+    .elem = {&__stdin.elem, &__stdin.elem},
+};
+
 /**
  * Pointer to standard input stream.
  */
-FILE *stdin;
+FILE *stdin = &__stdin;
 
-static FILE __stdin;
-
-__attribute__((__constructor__(60))) static textstartup void initin(void) {
+__attribute__((__constructor__(60))) static textstartup void stdin_init(void) {
   struct stat st;
-  stdin = &__stdin;
-  stdin->fd = STDIN_FILENO;
-  stdin->iomode = O_RDONLY;
-  stdin->buf = stdin->mem;
-  stdin->size = sizeof(stdin->mem);
-  stdin->lock._type = PTHREAD_MUTEX_RECURSIVE;
-  if (fstat(STDIN_FILENO, &st) || !S_ISREG(st.st_mode))
+  if (fstat(STDIN_FILENO, &st) || S_ISCHR(st.st_mode))
     stdin->bufmode = _IONBF;
-  __fflush_register(stdin);
+  dll_make_last(&__stdio.files, &__stdin.elem);
 }
diff --git a/libc/stdio/stdio.h b/libc/stdio/stdio.h
index d9f560b2b..8944d949f 100644
--- a/libc/stdio/stdio.h
+++ b/libc/stdio/stdio.h
@@ -1,11 +1,10 @@
 #ifndef COSMOPOLITAN_LIBC_STDIO_H_
 #define COSMOPOLITAN_LIBC_STDIO_H_
 
-#define EOF    -1  /* end of file */
-#define WEOF   -1u /* end of file (multibyte) */
-#define _IOFBF 0   /* fully buffered */
-#define _IOLBF 1   /* line buffered */
-#define _IONBF 2   /* no buffering */
+#define EOF    -1 /* end of file */
+#define _IOFBF 0  /* fully buffered */
+#define _IOLBF 1  /* line buffered */
+#define _IONBF 2  /* no buffering */
 
 #define L_tmpnam     20
 #define L_ctermid    20
@@ -20,6 +19,7 @@ COSMOPOLITAN_C_START_
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § standard i/o                                              ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
+/* clang-format off */
 
 struct FILE;
 typedef struct FILE FILE;
@@ -28,147 +28,146 @@ extern FILE *stdin;
 extern FILE *stdout;
 extern FILE *stderr;
 
-errno_t ferror(FILE *) libcesque paramsnonnull();
-void clearerr(FILE *) libcesque paramsnonnull();
-int feof(FILE *) libcesque paramsnonnull();
-int getc(FILE *) libcesque paramsnonnull();
-int putc(int, FILE *) libcesque paramsnonnull();
-int fflush(FILE *) libcesque;
-int fpurge(FILE *) libcesque;
-int fgetc(FILE *) libcesque paramsnonnull();
-char *fgetln(FILE *, size_t *) libcesque paramsnonnull((1));
-int ungetc(int, FILE *) libcesque paramsnonnull();
-int fileno(FILE *) libcesque paramsnonnull() nosideeffect;
-int fputc(int, FILE *) libcesque paramsnonnull();
-int fputs(const char *, FILE *) libcesque paramsnonnull();
-int fputws(const wchar_t *, FILE *) libcesque paramsnonnull();
-void flockfile(FILE *) libcesque paramsnonnull();
-void funlockfile(FILE *) libcesque paramsnonnull();
-int ftrylockfile(FILE *) libcesque paramsnonnull();
-char *fgets(char *, int, FILE *) libcesque paramsnonnull();
-wchar_t *fgetws(wchar_t *, int, FILE *) libcesque paramsnonnull();
-wint_t putwc(wchar_t, FILE *) libcesque paramsnonnull();
-wint_t fputwc(wchar_t, FILE *) libcesque paramsnonnull();
+errno_t ferror(FILE *) libcesque paramsnonnull() __read_write(1);
+void clearerr(FILE *) libcesque paramsnonnull() __read_write(1);
+int feof(FILE *) libcesque paramsnonnull() __read_write(1);
+int getc(FILE *) libcesque paramsnonnull() __read_write(1);
+int putc(int, FILE *) libcesque paramsnonnull() __read_write(2);
+int fflush(FILE *) libcesque __read_write(1);
+int fpurge(FILE *) libcesque __read_write(1);
+int fgetc(FILE *) libcesque paramsnonnull() __read_write(1);
+char *fgetln(FILE *, size_t *) libcesque paramsnonnull((1)) __read_write(1) __write_only(2);
+int ungetc(int, FILE *) libcesque paramsnonnull() __write_only(2);
+int fileno(FILE *) libcesque paramsnonnull() nosideeffect __write_only(1);
+int fputc(int, FILE *) libcesque paramsnonnull() __write_only(2);
+int fputs(const char *, FILE *) libcesque paramsnonnull() __write_only(2);
+int fputws(const wchar_t *, FILE *) libcesque paramsnonnull() __write_only(2);
+void flockfile(FILE *) libcesque __write_only(1);
+void funlockfile(FILE *) libcesque paramsnonnull() __write_only(1);
+int ftrylockfile(FILE *) libcesque paramsnonnull() __write_only(1);
+char *fgets(char *, int, FILE *) libcesque paramsnonnull() __write_only(1, 2) __read_write(3);
+wchar_t *fgetws(wchar_t *, int, FILE *) libcesque paramsnonnull() __write_only(1, 2) __read_write(3);
+wint_t putwc(wchar_t, FILE *) libcesque paramsnonnull() __write_only(2);
+wint_t fputwc(wchar_t, FILE *) libcesque paramsnonnull() __write_only(2);
 wint_t putwchar(wchar_t) libcesque;
 wint_t getwchar(void) libcesque;
-wint_t getwc(FILE *) libcesque paramsnonnull();
-wint_t fgetwc(FILE *) libcesque paramsnonnull();
-wint_t ungetwc(wint_t, FILE *) libcesque paramsnonnull();
+wint_t getwc(FILE *) libcesque paramsnonnull() __write_only(1);
+wint_t fgetwc(FILE *) libcesque paramsnonnull() __write_only(1);
+wint_t ungetwc(wint_t, FILE *) libcesque paramsnonnull() __write_only(2);
 int getchar(void) libcesque;
 int putchar(int) libcesque;
-int puts(const char *) libcesque;
-ssize_t getline(char **, size_t *, FILE *) libcesque paramsnonnull();
-ssize_t getdelim(char **, size_t *, int, FILE *) libcesque paramsnonnull();
-FILE *fopen(const char *, const char *) libcesque paramsnonnull((2)) __wur;
-FILE *fdopen(int, const char *) libcesque paramsnonnull() __wur;
-FILE *fmemopen(void *, size_t, const char *) libcesque paramsnonnull((3)) __wur;
-FILE *freopen(const char *, const char *, FILE *) paramsnonnull((2, 3));
-size_t fread(void *, size_t, size_t, FILE *) libcesque paramsnonnull((4));
-size_t fwrite(const void *, size_t, size_t, FILE *) paramsnonnull((4));
-int fclose(FILE *) libcesque;
-int fseek(FILE *, long, int) libcesque paramsnonnull();
-long ftell(FILE *) libcesque paramsnonnull();
-int fseeko(FILE *, int64_t, int) libcesque paramsnonnull();
-int64_t ftello(FILE *) libcesque paramsnonnull();
-void rewind(FILE *) libcesque paramsnonnull();
-int fopenflags(const char *) libcesque paramsnonnull();
-void setlinebuf(FILE *) libcesque;
-void setbuf(FILE *, char *) libcesque;
-void setbuffer(FILE *, char *, size_t) libcesque;
-int setvbuf(FILE *, char *, int, size_t) libcesque;
-int pclose(FILE *) libcesque;
-char *ctermid(char *) libcesque;
-void perror(const char *) libcesque relegated;
+int puts(const char *) libcesque __read_only(1);
+
+ssize_t getline(char **, size_t *, FILE *) libcesque paramsnonnull() __read_write(1) __read_write(2) __read_write(3);
+ssize_t getdelim(char **, size_t *, int, FILE *) libcesque paramsnonnull() __read_write(1) __read_write(2) __read_write(4);
+FILE *fopen(const char *, const char *) libcesque paramsnonnull((2)) __read_only(1) __read_only(2) __wur;
+FILE *fdopen(int, const char *) libcesque paramsnonnull() __read_only(2) __wur;
+FILE *fmemopen(void *, size_t, const char *) libcesque paramsnonnull((3)) __read_write(1) __read_only(3) __wur;
+FILE *freopen(const char *, const char *, FILE *) paramsnonnull((2, 3)) __read_only(1) __read_only(2) __read_write(3);
+size_t fread(void *, size_t, size_t, FILE *) libcesque paramsnonnull((4)) __write_only(1) __read_write(4);
+size_t fwrite(const void *, size_t, size_t, FILE *) paramsnonnull((4)) __read_only(1) __read_write(4);
+int fclose(FILE *) libcesque __read_write(1);
+int fseek(FILE *, long, int) libcesque paramsnonnull() __read_write(1);
+long ftell(FILE *) libcesque paramsnonnull() __read_write(1);
+int fseeko(FILE *, int64_t, int) libcesque paramsnonnull() __read_write(1);
+int64_t ftello(FILE *) libcesque paramsnonnull() __read_write(1);
+void rewind(FILE *) libcesque paramsnonnull() __read_write(1);
+int fopenflags(const char *) libcesque paramsnonnull() __read_only(1);
+void setlinebuf(FILE *) libcesque __read_write(1);
+void setbuf(FILE *, char *) libcesque __read_write(1) __write_only(2);
+void setbuffer(FILE *, char *, size_t) libcesque __read_write(1) __write_only(2);
+int setvbuf(FILE *, char *, int, size_t) libcesque __read_write(1);
+int pclose(FILE *) libcesque __read_write(1);
+char *ctermid(char *) libcesque __write_only(1);
+void perror(const char *) libcesque relegated __read_only(1);
 
 typedef uint64_t fpos_t;
-char *gets(char *) libcesque paramsnonnull();
-int fgetpos(FILE *, fpos_t *) libcesque paramsnonnull();
-int fsetpos(FILE *, const fpos_t *) libcesque paramsnonnull();
+char *gets(char *) libcesque paramsnonnull() __write_only(1);
+int fgetpos(FILE *, fpos_t *) libcesque paramsnonnull() __read_write(1) __write_only(2);
+int fsetpos(FILE *, const fpos_t *) libcesque paramsnonnull() __read_write(1) __read_only(2);
 
 FILE *tmpfile(void) libcesque __wur;
-char *tmpnam(char *) libcesque __wur;
-char *tmpnam_r(char *) libcesque __wur;
+char *tmpnam(char *) libcesque __write_only(1) __wur;
+char *tmpnam_r(char *) libcesque __write_only(1) __wur;
 
-FILE *popen(const char *, const char *) libcesque;
+FILE *popen(const char *, const char *) libcesque __read_only(1) __read_only(2);
 
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § standard i/o » formatting                                 ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
 
-int printf(const char *, ...) printfesque(1) paramsnonnull((1)) libcesque;
-int vprintf(const char *, va_list) paramsnonnull() libcesque;
-int fprintf(FILE *, const char *, ...) printfesque(2)
-    paramsnonnull((1, 2)) libcesque;
-int vfprintf(FILE *, const char *, va_list) paramsnonnull() libcesque;
-int scanf(const char *, ...) libcesque scanfesque(1);
-int vscanf(const char *, va_list) libcesque;
-int fscanf(FILE *, const char *, ...) libcesque scanfesque(2);
-int vfscanf(FILE *, const char *, va_list) libcesque;
+int printf(const char *, ...) printfesque(1) paramsnonnull((1)) libcesque __read_only(1);
+int vprintf(const char *, va_list) paramsnonnull() libcesque __read_only(1);
+int fprintf(FILE *, const char *, ...) printfesque(2) paramsnonnull((1, 2)) libcesque __read_write(1) __read_only(2);
+int vfprintf(FILE *, const char *, va_list) paramsnonnull() libcesque __read_write(1) __read_only(2);
+int scanf(const char *, ...) libcesque scanfesque(1) __read_only(1);
+int vscanf(const char *, va_list) libcesque __read_only(1);
+int fscanf(FILE *, const char *, ...) libcesque scanfesque(2) __read_write(1) __read_only(2);
+int vfscanf(FILE *, const char *, va_list) libcesque __read_write(1) __read_only(2);
 
-int snprintf(char *, size_t, const char *, ...) printfesque(3) libcesque;
-int vsnprintf(char *, size_t, const char *, va_list) libcesque;
-int sprintf(char *, const char *, ...) libcesque;
-int vsprintf(char *, const char *, va_list) libcesque;
+int snprintf(char *, size_t, const char *, ...) printfesque(3) libcesque __write_only(1) __read_only(3);
+int vsnprintf(char *, size_t, const char *, va_list) libcesque __write_only(1) __read_only(3);
+int sprintf(char *, const char *, ...) libcesque __write_only(1) __read_only(2);
+int vsprintf(char *, const char *, va_list) libcesque __write_only(1) __read_only(2);
 
-int fwprintf(FILE *, const wchar_t *, ...) libcesque;
-int fwscanf(FILE *, const wchar_t *, ...) libcesque;
-int swprintf(wchar_t *, size_t, const wchar_t *, ...) libcesque;
-int swscanf(const wchar_t *, const wchar_t *, ...) libcesque;
-int vfwprintf(FILE *, const wchar_t *, va_list) libcesque;
-int vfwscanf(FILE *, const wchar_t *, va_list) libcesque;
-int vswprintf(wchar_t *, size_t, const wchar_t *, va_list) libcesque;
-int vswscanf(const wchar_t *, const wchar_t *, va_list) libcesque;
-int vwprintf(const wchar_t *, va_list) libcesque;
-int vwscanf(const wchar_t *, va_list) libcesque;
-int wprintf(const wchar_t *, ...) libcesque;
-int wscanf(const wchar_t *, ...) libcesque;
-int fwide(FILE *, int) libcesque;
+int fwprintf(FILE *, const wchar_t *, ...) libcesque __read_write(1) __read_only(2);
+int fwscanf(FILE *, const wchar_t *, ...) libcesque __read_write(1) __read_only(2);
+int swprintf(wchar_t *, size_t, const wchar_t *, ...) libcesque __write_only(1) __read_only(3);
+int swscanf(const wchar_t *, const wchar_t *, ...) libcesque __read_only(1) __read_only(2);
+int vfwprintf(FILE *, const wchar_t *, va_list) libcesque __read_write(1) __read_only(2);
+int vfwscanf(FILE *, const wchar_t *, va_list) libcesque __read_write(1) __read_only(2);
+int vswprintf(wchar_t *, size_t, const wchar_t *, va_list) libcesque __write_only(1) __read_only(3);
+int vswscanf(const wchar_t *, const wchar_t *, va_list) libcesque __read_only(1) __read_only(2);
+int vwprintf(const wchar_t *, va_list) libcesque __read_only(1);
+int vwscanf(const wchar_t *, va_list) libcesque __read_only(1);
+int wprintf(const wchar_t *, ...) libcesque __read_only(1);
+int wscanf(const wchar_t *, ...) libcesque __read_only(1);
+int fwide(FILE *, int) libcesque __read_write(1);
 
-int sscanf(const char *, const char *, ...) libcesque scanfesque(2);
-int vsscanf(const char *, const char *, va_list) libcesque;
+int sscanf(const char *, const char *, ...) libcesque scanfesque(2) __read_only(1) __read_only(2);
+int vsscanf(const char *, const char *, va_list) libcesque __read_only(1) __read_only(2);
 
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § standard i/o » allocating                                 ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
 
-int asprintf(char **, const char *, ...) printfesque(2)
-    paramsnonnull((1, 2)) libcesque;
-int vasprintf(char **, const char *, va_list) paramsnonnull() libcesque;
+int asprintf(char **, const char *, ...) printfesque(2) paramsnonnull((1, 2)) libcesque __write_only(1);
+int vasprintf(char **, const char *, va_list) paramsnonnull() libcesque __write_only(1);
 
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § standard i/o » without mutexes                            ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
 
-int getc_unlocked(FILE *) libcesque paramsnonnull();
-int puts_unlocked(const char *) libcesque;
+int getc_unlocked(FILE *) libcesque paramsnonnull() __read_write(1);
+int puts_unlocked(const char *) libcesque __read_only(1);
 int getchar_unlocked(void) libcesque;
-int putc_unlocked(int, FILE *) libcesque paramsnonnull();
+int putc_unlocked(int, FILE *) libcesque paramsnonnull() __read_write(2);
 int putchar_unlocked(int) libcesque;
-void clearerr_unlocked(FILE *) libcesque;
-int feof_unlocked(FILE *) libcesque;
-int ferror_unlocked(FILE *) libcesque;
-int fileno_unlocked(FILE *) libcesque;
-int fflush_unlocked(FILE *) libcesque;
-int fgetc_unlocked(FILE *) libcesque;
-int fputc_unlocked(int, FILE *) libcesque;
-size_t fread_unlocked(void *, size_t, size_t, FILE *) libcesque;
-size_t fwrite_unlocked(const void *, size_t, size_t, FILE *) libcesque;
-char *fgets_unlocked(char *, int, FILE *) libcesque;
-int fputs_unlocked(const char *, FILE *) libcesque;
-wint_t getwc_unlocked(FILE *) libcesque;
+void clearerr_unlocked(FILE *) libcesque __write_only(1);
+int feof_unlocked(FILE *) libcesque __read_only(1);
+int ferror_unlocked(FILE *) libcesque __read_only(1);
+int fileno_unlocked(FILE *) libcesque __read_only(1);
+int fflush_unlocked(FILE *) libcesque __read_write(1);
+int fgetc_unlocked(FILE *) libcesque __read_write(1);
+int fputc_unlocked(int, FILE *) libcesque __read_write(2);
+size_t fread_unlocked(void *, size_t, size_t, FILE *) libcesque __write_only(1) __read_write(4);
+size_t fwrite_unlocked(const void *, size_t, size_t, FILE *) libcesque __read_only(1) __read_write(4);
+char *fgets_unlocked(char *, int, FILE *) libcesque __write_only(1) __read_write(3);
+int fputs_unlocked(const char *, FILE *) libcesque __read_only(1) __read_write(2);
+wint_t getwc_unlocked(FILE *) libcesque __read_write(1);
 wint_t getwchar_unlocked(void) libcesque;
-wint_t fgetwc_unlocked(FILE *) libcesque;
-wint_t fputwc_unlocked(wchar_t, FILE *) libcesque;
-wint_t putwc_unlocked(wchar_t, FILE *) libcesque;
+wint_t fgetwc_unlocked(FILE *) libcesque __read_write(1);
+wint_t fputwc_unlocked(wchar_t, FILE *) libcesque __read_write(2);
+wint_t putwc_unlocked(wchar_t, FILE *) libcesque __read_write(2);
 wint_t putwchar_unlocked(wchar_t) libcesque;
-wchar_t *fgetws_unlocked(wchar_t *, int, FILE *) libcesque;
-int fputws_unlocked(const wchar_t *, FILE *) libcesque;
-wint_t ungetwc_unlocked(wint_t, FILE *) libcesque paramsnonnull();
-int ungetc_unlocked(int, FILE *) libcesque paramsnonnull();
-int fseek_unlocked(FILE *, int64_t, int) libcesque paramsnonnull();
-ssize_t getdelim_unlocked(char **, size_t *, int, FILE *) paramsnonnull();
-int fprintf_unlocked(FILE *, const char *, ...) printfesque(2) libcesque;
-int vfprintf_unlocked(FILE *, const char *, va_list) paramsnonnull() libcesque;
+wchar_t *fgetws_unlocked(wchar_t *, int, FILE *) libcesque __write_only(1, 2) __read_write(3);
+int fputws_unlocked(const wchar_t *, FILE *) libcesque __read_only(1) __read_write(2);
+wint_t ungetwc_unlocked(wint_t, FILE *) libcesque paramsnonnull() __read_write(2);
+int ungetc_unlocked(int, FILE *) libcesque paramsnonnull() __read_write(2);
+int fseek_unlocked(FILE *, int64_t, int) libcesque paramsnonnull() __read_write(1);
+ssize_t getdelim_unlocked(char **, size_t *, int, FILE *) paramsnonnull() __read_write(1) __read_write(2) __read_write(4);
+int fprintf_unlocked(FILE *, const char *, ...) printfesque(2) libcesque __read_write(1) __read_only(2);
+int vfprintf_unlocked(FILE *, const char *, va_list) paramsnonnull() libcesque __read_write(1) __read_only(2);
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_STDIO_H_ */
diff --git a/libc/stdio/stdout.c b/libc/stdio/stdout.c
index 06eee4475..86a34f9f3 100644
--- a/libc/stdio/stdout.c
+++ b/libc/stdio/stdout.c
@@ -1,5 +1,5 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=8 sts=2 sw=2 fenc=utf-8                               :vi │
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
 │ Copyright 2020 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
@@ -16,39 +16,37 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/dce.h"
+#include "libc/intrin/dll.h"
 #include "libc/stdio/internal.h"
-#include "libc/stdio/stdio.h"
 #include "libc/sysv/consts/fileno.h"
 #include "libc/sysv/consts/o.h"
-#include "libc/thread/thread.h"
+
+__static_yoink("fflush");
+
+static char __stdout_buf[BUFSIZ];
+
+static FILE __stdout = {
+    .fd = STDOUT_FILENO,
+    .oflags = O_WRONLY,
+    .buf = __stdout_buf,
+    .size = sizeof(__stdout_buf),
+    .lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP,
+    .elem = {&__stdout.elem, &__stdout.elem},
+
+    // Unlike other C libraries we don't bother calling fstat() to check
+    // if stdio is a character device and we instead choose to always
+    // line buffer it. We need it because there's no way to use the
+    // unbuffer command on a statically linked binary. This still goes
+    // fast. We value latency more than throughput, and stdio isn't the
+    // best api when the goal is throughput.
+    .bufmode = _IOLBF,
+};
 
 /**
  * Pointer to standard output stream.
  */
-FILE *stdout;
+FILE *stdout = &__stdout;
 
-static FILE __stdout;
-
-__attribute__((__constructor__(60))) static textstartup void outinit(void) {
-  stdout = &__stdout;
-
-  stdout->fd = STDOUT_FILENO;
-  stdout->iomode = O_WRONLY;
-  stdout->buf = stdout->mem;
-  stdout->size = sizeof(stdout->mem);
-  stdout->lock._type = PTHREAD_MUTEX_RECURSIVE;
-
-  /*
-   * Unlike other C libraries we don't bother calling fstat() to check
-   * if stdio is a character device and we instead choose to always line
-   * buffer it. We need it because there's no way to use the unbuffer
-   * command on a statically linked binary. This still goes fast. We
-   * value latency more than throughput, and stdio isn't the best api
-   * when the goal is throughput.
-   */
-  stdout->bufmode = _IOLBF;
-
-  __fflush_register(stdout);
+__attribute__((__constructor__(60))) static textstartup void stdout_init(void) {
+  dll_make_last(&__stdio.files, &__stdout.elem);
 }
diff --git a/libc/stdio/strfry.c b/libc/stdio/strfry.c
index eac05107d..56a703cbd 100644
--- a/libc/stdio/strfry.c
+++ b/libc/stdio/strfry.c
@@ -16,14 +16,23 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/mem/shuffle.internal.h"
 #include "libc/stdio/rand.h"
 #include "libc/str/str.h"
 
 /**
- * Jumbles up string.
+ * Performs Fisher-Yates shuffle on string in-place to create anagram.
+ *
+ * This implementation uses rand() so `srand(time(0))` may be desired.
  */
 char *strfry(char *s) {
-  shuffle(rand, s, strlen(s));
+  size_t i = strlen(s);
+  while (i > 1) {
+    size_t x = rand();
+    size_t y = rand();
+    size_t j = ((x << 31) ^ y) % i--;
+    char t = s[j];
+    s[j] = s[i];
+    s[i] = t;
+  }
   return s;
 }
diff --git a/libc/stdio/vappendf.c b/libc/stdio/vappendf.c
index 726e59450..5ed5ab10f 100644
--- a/libc/stdio/vappendf.c
+++ b/libc/stdio/vappendf.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/append.h"
 #include "libc/stdio/stdio.h"
diff --git a/libc/stdio/vasprintf.c b/libc/stdio/vasprintf.c
index 3f05529d0..907ca8ffa 100644
--- a/libc/stdio/vasprintf.c
+++ b/libc/stdio/vasprintf.c
@@ -52,6 +52,7 @@ int vasprintf(char **strp, const char *fmt, va_list va) {
     *strp = p;
     return rc;
   } else {
+    free(p);
     return -1;
   }
 }
diff --git a/libc/stdio/vcscanf.c b/libc/stdio/vcscanf.c
index ad91f88d8..ddfa01097 100644
--- a/libc/stdio/vcscanf.c
+++ b/libc/stdio/vcscanf.c
@@ -23,7 +23,7 @@
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/str/tpdecodecb.internal.h"
 #include "libc/str/utf16.h"
 #include "libc/sysv/errfuns.h"
@@ -254,11 +254,15 @@ int __vcscanf(int callback(void *),    //
                 c = READ;
               }
               fpbufsize = FP_BUFFER_GROW;
-              fpbuf = malloc(fpbufsize);
-              fpbufcur = 0;
-              fpbuf[fpbufcur++] = c;
-              fpbuf[fpbufcur] = '\0';
-              goto ConsumeFloatingPointNumber;
+              if ((fpbuf = malloc(fpbufsize))) {
+                fpbufcur = 0;
+                fpbuf[fpbufcur++] = c;
+                fpbuf[fpbufcur] = '\0';
+                goto ConsumeFloatingPointNumber;
+              } else {
+                items = -1;
+                goto Done;
+              }
             default:
               items = einval();
               goto Done;
@@ -513,12 +517,16 @@ int __vcscanf(int callback(void *),    //
         if (discard) {
           buf = NULL;
         } else if (ismalloc) {
-          buf = malloc(bufsize * charbytes);
-          struct FreeMe *entry;
-          if (buf && (entry = calloc(1, sizeof(struct FreeMe)))) {
-            entry->ptr = buf;
-            entry->next = freeme;
-            freeme = entry;
+          if ((buf = malloc(bufsize * charbytes))) {
+            struct FreeMe *entry;
+            if (buf && (entry = calloc(1, sizeof(struct FreeMe)))) {
+              entry->ptr = buf;
+              entry->next = freeme;
+              freeme = entry;
+            }
+          } else {
+            items = -1;
+            goto Done;
           }
         } else {
           buf = va_arg(va, void *);
diff --git a/libc/stdio/vdprintf.c b/libc/stdio/vdprintf.c
index dc344804e..15d2d7909 100644
--- a/libc/stdio/vdprintf.c
+++ b/libc/stdio/vdprintf.c
@@ -20,7 +20,7 @@
 #include "libc/dce.h"
 #include "libc/fmt/internal.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/files.h"
 #include "libc/sock/sock.h"
 #include "libc/str/str.h"
@@ -63,7 +63,7 @@ int vdprintf(int fd, const char *fmt, va_list va) {
   t.n = 0;
   t.t = 0;
   t.fd = fd;
-  if (__fmt(vdprintf_putc, &t, fmt, va) == -1)
+  if (__fmt(vdprintf_putc, &t, fmt, va, &t.t) == -1)
     return -1;
   if (t.n) {
     iov[0].iov_base = t.b;
diff --git a/libc/stdio/vfprintf_unlocked.c b/libc/stdio/vfprintf_unlocked.c
index a6ed81dbd..d0285dcbd 100644
--- a/libc/stdio/vfprintf_unlocked.c
+++ b/libc/stdio/vfprintf_unlocked.c
@@ -19,6 +19,7 @@
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/fmt/internal.h"
+#include "libc/intrin/kprintf.h"
 #include "libc/stdckdint.h"
 #include "libc/stdio/internal.h"
 #include "libc/stdio/stdio.h"
@@ -46,9 +47,8 @@ static int __vfprintf_flbuf(const char *s, struct state *t, size_t n) {
     } else {
       rc = -1;
     }
-    if (ckd_add(&t->n, t->n, n)) {
+    if (ckd_add(&t->n, t->n, n))
       rc = eoverflow();
-    }
   } else {
     rc = 0;
   }
@@ -60,9 +60,8 @@ static int __vfprintf_nbuf(const char *s, struct state *t, size_t n) {
   for (i = 0; i < n; ++i) {
     t->b.p[t->b.n++] = s[i];
     if (t->b.n == sizeof(t->b.p)) {
-      if (!fwrite_unlocked(t->b.p, 1, t->b.n, t->f)) {
+      if (!fwrite_unlocked(t->b.p, 1, t->b.n, t->f))
         return -1;
-      }
       t->b.n = 0;
     } else if (ckd_add(&t->n, t->n, 1)) {
       return eoverflow();
@@ -87,13 +86,11 @@ int vfprintf_unlocked(FILE *f, const char *fmt, va_list va) {
   st.f = f;
   st.n = 0;
   st.b.n = 0;
-  if ((rc = __fmt(out, &st, fmt, va)) != -1) {
+  if ((rc = __fmt(out, &st, fmt, va, &st.n)) != -1) {
     if (!st.b.n) {
       rc = st.n;
     } else if (fwrite_unlocked(st.b.p, 1, st.b.n, st.f)) {
-      if (ckd_add(&rc, st.n, st.b.n)) {
-        rc = eoverflow();
-      }
+      rc = st.n;
     } else {
       rc = -1;
     }
diff --git a/libc/stdio/vsnprintf.c b/libc/stdio/vsnprintf.c
index cdc7d3521..a113335df 100644
--- a/libc/stdio/vsnprintf.c
+++ b/libc/stdio/vsnprintf.c
@@ -20,14 +20,14 @@
 #include "libc/dce.h"
 #include "libc/fmt/internal.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 
 struct SprintfStr {
   char *p;
-  size_t i;
-  size_t n;
+  int i;
+  int n;
 };
 
 static int vsnprintfputchar(const char *s, struct SprintfStr *t, size_t n) {
@@ -58,7 +58,7 @@ static int vsnprintfputchar(const char *s, struct SprintfStr *t, size_t n) {
  */
 int vsnprintf(char *buf, size_t size, const char *fmt, va_list va) {
   struct SprintfStr str = {buf, 0, size};
-  int rc = __fmt(vsnprintfputchar, &str, fmt, va);
+  int rc = __fmt(vsnprintfputchar, &str, fmt, va, &str.i);
   if (rc < 0)
     return rc;
   if (str.n)
diff --git a/libc/str/BUILD.mk b/libc/str/BUILD.mk
index ab0193593..b0b2a163a 100644
--- a/libc/str/BUILD.mk
+++ b/libc/str/BUILD.mk
@@ -12,16 +12,19 @@ LIBC_STR_A_INCS = $(filter %.inc,$(LIBC_STR_A_FILES))
 LIBC_STR_A_SRCS_A = $(filter %.s,$(LIBC_STR_A_FILES))
 LIBC_STR_A_SRCS_S = $(filter %.S,$(LIBC_STR_A_FILES))
 LIBC_STR_A_SRCS_C = $(filter %.c,$(LIBC_STR_A_FILES))
+LIBC_STR_A_SRCS_CC = $(filter %.cc,$(LIBC_STR_A_FILES))
 
 LIBC_STR_A_SRCS =						\
 	$(LIBC_STR_A_SRCS_A)					\
 	$(LIBC_STR_A_SRCS_S)					\
-	$(LIBC_STR_A_SRCS_C)
+	$(LIBC_STR_A_SRCS_C)					\
+	$(LIBC_STR_A_SRCS_CC)
 
 LIBC_STR_A_OBJS =						\
 	$(LIBC_STR_A_SRCS_A:%.s=o/$(MODE)/%.o)			\
 	$(LIBC_STR_A_SRCS_S:%.S=o/$(MODE)/%.o)			\
-	$(LIBC_STR_A_SRCS_C:%.c=o/$(MODE)/%.o)
+	$(LIBC_STR_A_SRCS_C:%.c=o/$(MODE)/%.o)			\
+	$(LIBC_STR_A_SRCS_CC:%.cc=o/$(MODE)/%.o)
 
 LIBC_STR_A_CHECKS =						\
 	$(LIBC_STR_A).pkg					\
@@ -44,9 +47,6 @@ $(LIBC_STR_A).pkg:						\
 		$(LIBC_STR_A_OBJS)				\
 		$(foreach x,$(LIBC_STR_A_DIRECTDEPS),$($(x)_A).pkg)
 
-o/$(MODE)/libc/str/wow.o: private				\
-		CC = gcc
-
 o/$(MODE)/libc/str/wmemset.o					\
 o/$(MODE)/libc/str/memset16.o					\
 o/$(MODE)/libc/str/dosdatetimetounix.o: private			\
@@ -77,13 +77,7 @@ o/$(MODE)/libc/str/iswseparator.o: private			\
 
 # ensure that division is optimized
 o/$(MODE)/libc/str/bcmp.o					\
-o/$(MODE)/libc/str/strcmp.o					\
-o/$(MODE)/libc/str/windowsdurationtotimeval.o			\
-o/$(MODE)/libc/str/windowsdurationtotimespec.o			\
-o/$(MODE)/libc/str/timevaltowindowstime.o			\
-o/$(MODE)/libc/str/timespectowindowstime.o			\
-o/$(MODE)/libc/str/windowstimetotimeval.o			\
-o/$(MODE)/libc/str/windowstimetotimespec.o: private		\
+o/$(MODE)/libc/str/strcmp.o: private				\
 		CFLAGS +=					\
 			-O2
 
diff --git a/libc/str/blake2.c b/libc/str/blake2.c
index acbeb1b70..f2e10416a 100644
--- a/libc/str/blake2.c
+++ b/libc/str/blake2.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/blake2.h"
 #include "libc/assert.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 
 #define ROR(v, n) (((v) >> (n)) | ((v) << (64 - (n))))
diff --git a/libc/str/c32rtomb.c b/libc/str/c32rtomb.c
deleted file mode 100644
index 4d258deda..000000000
--- a/libc/str/c32rtomb.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-size_t c32rtomb(char *s, char32_t c, mbstate_t *t) {
-  return wcrtomb(s, c, t);
-}
diff --git a/libc/str/compareslices.c b/libc/str/compareslices.c
index b57b902a6..0bca09438 100644
--- a/libc/str/compareslices.c
+++ b/libc/str/compareslices.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/slice.h"
 
 int CompareSlices(const char *a, size_t n, const char *b, size_t m) {
diff --git a/libc/str/compareslicescase.c b/libc/str/compareslicescase.c
index a4f881450..129d9b22c 100644
--- a/libc/str/compareslicescase.c
+++ b/libc/str/compareslicescase.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/slice.h"
 
 int CompareSlicesCase(const char *a, size_t n, const char *b, size_t m) {
diff --git a/libc/str/dosdatetimetounix.c b/libc/str/dosdatetimetounix.c
index 7cc956fd3..a4cd18109 100644
--- a/libc/str/dosdatetimetounix.c
+++ b/libc/str/dosdatetimetounix.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/conv.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/time.h"
 
 /**
diff --git a/libc/str/eastasianwidth.txt b/libc/str/eastasianwidth.txt
index 8e2a738fe..02df4df47 100644
--- a/libc/str/eastasianwidth.txt
+++ b/libc/str/eastasianwidth.txt
@@ -1,11 +1,11 @@
-# EastAsianWidth-15.0.0.txt
-# Date: 2022-01-28, 13:07:15 GMT [KW, LI]
-# © 2022 Unicode®, Inc.
+# EastAsianWidth-15.1.0.txt
+# Date: 2023-07-28, 23:34:08 GMT
+# © 2023 Unicode®, Inc.
 # Unicode and the Unicode Logo are registered trademarks of Unicode, Inc. in the U.S. and other countries.
 # For terms of use, see https://www.unicode.org/terms_of_use.html
 #
 # Unicode Character Database
-# For documentation, see https://www.unicode.org/reports/tr44/
+#   For documentation, see https://www.unicode.org/reports/tr44/
 #
 # East_Asian_Width Property
 #
@@ -30,2590 +30,2592 @@
 # Character ranges are specified as for other property files in the
 # Unicode Character Database.
 #
-# For legacy reasons, there are no spaces before or after the semicolon
-# which separates the two fields. The comments following the number sign
-# "#" list the General_Category property value or the L& alias of the
-# derived value LC, the Unicode character name or names, and, in lines
-# with ranges of code points, the code point count in square brackets.
+# The comments following the number sign "#" list the General_Category
+# property value or the L& alias of the derived value LC, the Unicode
+# character name or names, and, in lines with ranges of code points,
+# the code point count in square brackets.
 #
 # For more information, see UAX #11: East Asian Width,
 # at https://www.unicode.org/reports/tr11/
 #
 # @missing: 0000..10FFFF; N
-0000..001F;N     # Cc    [32] <control-0000>..<control-001F>
-0020;Na          # Zs         SPACE
-0021..0023;Na    # Po     [3] EXCLAMATION MARK..NUMBER SIGN
-0024;Na          # Sc         DOLLAR SIGN
-0025..0027;Na    # Po     [3] PERCENT SIGN..APOSTROPHE
-0028;Na          # Ps         LEFT PARENTHESIS
-0029;Na          # Pe         RIGHT PARENTHESIS
-002A;Na          # Po         ASTERISK
-002B;Na          # Sm         PLUS SIGN
-002C;Na          # Po         COMMA
-002D;Na          # Pd         HYPHEN-MINUS
-002E..002F;Na    # Po     [2] FULL STOP..SOLIDUS
-0030..0039;Na    # Nd    [10] DIGIT ZERO..DIGIT NINE
-003A..003B;Na    # Po     [2] COLON..SEMICOLON
-003C..003E;Na    # Sm     [3] LESS-THAN SIGN..GREATER-THAN SIGN
-003F..0040;Na    # Po     [2] QUESTION MARK..COMMERCIAL AT
-0041..005A;Na    # Lu    [26] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z
-005B;Na          # Ps         LEFT SQUARE BRACKET
-005C;Na          # Po         REVERSE SOLIDUS
-005D;Na          # Pe         RIGHT SQUARE BRACKET
-005E;Na          # Sk         CIRCUMFLEX ACCENT
-005F;Na          # Pc         LOW LINE
-0060;Na          # Sk         GRAVE ACCENT
-0061..007A;Na    # Ll    [26] LATIN SMALL LETTER A..LATIN SMALL LETTER Z
-007B;Na          # Ps         LEFT CURLY BRACKET
-007C;Na          # Sm         VERTICAL LINE
-007D;Na          # Pe         RIGHT CURLY BRACKET
-007E;Na          # Sm         TILDE
-007F;N           # Cc         <control-007F>
-0080..009F;N     # Cc    [32] <control-0080>..<control-009F>
-00A0;N           # Zs         NO-BREAK SPACE
-00A1;A           # Po         INVERTED EXCLAMATION MARK
-00A2..00A3;Na    # Sc     [2] CENT SIGN..POUND SIGN
-00A4;A           # Sc         CURRENCY SIGN
-00A5;Na          # Sc         YEN SIGN
-00A6;Na          # So         BROKEN BAR
-00A7;A           # Po         SECTION SIGN
-00A8;A           # Sk         DIAERESIS
-00A9;N           # So         COPYRIGHT SIGN
-00AA;A           # Lo         FEMININE ORDINAL INDICATOR
-00AB;N           # Pi         LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
-00AC;Na          # Sm         NOT SIGN
-00AD;A           # Cf         SOFT HYPHEN
-00AE;A           # So         REGISTERED SIGN
-00AF;Na          # Sk         MACRON
-00B0;A           # So         DEGREE SIGN
-00B1;A           # Sm         PLUS-MINUS SIGN
-00B2..00B3;A     # No     [2] SUPERSCRIPT TWO..SUPERSCRIPT THREE
-00B4;A           # Sk         ACUTE ACCENT
-00B5;N           # Ll         MICRO SIGN
-00B6..00B7;A     # Po     [2] PILCROW SIGN..MIDDLE DOT
-00B8;A           # Sk         CEDILLA
-00B9;A           # No         SUPERSCRIPT ONE
-00BA;A           # Lo         MASCULINE ORDINAL INDICATOR
-00BB;N           # Pf         RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
-00BC..00BE;A     # No     [3] VULGAR FRACTION ONE QUARTER..VULGAR FRACTION THREE QUARTERS
-00BF;A           # Po         INVERTED QUESTION MARK
-00C0..00C5;N     # Lu     [6] LATIN CAPITAL LETTER A WITH GRAVE..LATIN CAPITAL LETTER A WITH RING ABOVE
-00C6;A           # Lu         LATIN CAPITAL LETTER AE
-00C7..00CF;N     # Lu     [9] LATIN CAPITAL LETTER C WITH CEDILLA..LATIN CAPITAL LETTER I WITH DIAERESIS
-00D0;A           # Lu         LATIN CAPITAL LETTER ETH
-00D1..00D6;N     # Lu     [6] LATIN CAPITAL LETTER N WITH TILDE..LATIN CAPITAL LETTER O WITH DIAERESIS
-00D7;A           # Sm         MULTIPLICATION SIGN
-00D8;A           # Lu         LATIN CAPITAL LETTER O WITH STROKE
-00D9..00DD;N     # Lu     [5] LATIN CAPITAL LETTER U WITH GRAVE..LATIN CAPITAL LETTER Y WITH ACUTE
-00DE..00E1;A     # L&     [4] LATIN CAPITAL LETTER THORN..LATIN SMALL LETTER A WITH ACUTE
-00E2..00E5;N     # Ll     [4] LATIN SMALL LETTER A WITH CIRCUMFLEX..LATIN SMALL LETTER A WITH RING ABOVE
-00E6;A           # Ll         LATIN SMALL LETTER AE
-00E7;N           # Ll         LATIN SMALL LETTER C WITH CEDILLA
-00E8..00EA;A     # Ll     [3] LATIN SMALL LETTER E WITH GRAVE..LATIN SMALL LETTER E WITH CIRCUMFLEX
-00EB;N           # Ll         LATIN SMALL LETTER E WITH DIAERESIS
-00EC..00ED;A     # Ll     [2] LATIN SMALL LETTER I WITH GRAVE..LATIN SMALL LETTER I WITH ACUTE
-00EE..00EF;N     # Ll     [2] LATIN SMALL LETTER I WITH CIRCUMFLEX..LATIN SMALL LETTER I WITH DIAERESIS
-00F0;A           # Ll         LATIN SMALL LETTER ETH
-00F1;N           # Ll         LATIN SMALL LETTER N WITH TILDE
-00F2..00F3;A     # Ll     [2] LATIN SMALL LETTER O WITH GRAVE..LATIN SMALL LETTER O WITH ACUTE
-00F4..00F6;N     # Ll     [3] LATIN SMALL LETTER O WITH CIRCUMFLEX..LATIN SMALL LETTER O WITH DIAERESIS
-00F7;A           # Sm         DIVISION SIGN
-00F8..00FA;A     # Ll     [3] LATIN SMALL LETTER O WITH STROKE..LATIN SMALL LETTER U WITH ACUTE
-00FB;N           # Ll         LATIN SMALL LETTER U WITH CIRCUMFLEX
-00FC;A           # Ll         LATIN SMALL LETTER U WITH DIAERESIS
-00FD;N           # Ll         LATIN SMALL LETTER Y WITH ACUTE
-00FE;A           # Ll         LATIN SMALL LETTER THORN
-00FF;N           # Ll         LATIN SMALL LETTER Y WITH DIAERESIS
-0100;N           # Lu         LATIN CAPITAL LETTER A WITH MACRON
-0101;A           # Ll         LATIN SMALL LETTER A WITH MACRON
-0102..0110;N     # L&    [15] LATIN CAPITAL LETTER A WITH BREVE..LATIN CAPITAL LETTER D WITH STROKE
-0111;A           # Ll         LATIN SMALL LETTER D WITH STROKE
-0112;N           # Lu         LATIN CAPITAL LETTER E WITH MACRON
-0113;A           # Ll         LATIN SMALL LETTER E WITH MACRON
-0114..011A;N     # L&     [7] LATIN CAPITAL LETTER E WITH BREVE..LATIN CAPITAL LETTER E WITH CARON
-011B;A           # Ll         LATIN SMALL LETTER E WITH CARON
-011C..0125;N     # L&    [10] LATIN CAPITAL LETTER G WITH CIRCUMFLEX..LATIN SMALL LETTER H WITH CIRCUMFLEX
-0126..0127;A     # L&     [2] LATIN CAPITAL LETTER H WITH STROKE..LATIN SMALL LETTER H WITH STROKE
-0128..012A;N     # L&     [3] LATIN CAPITAL LETTER I WITH TILDE..LATIN CAPITAL LETTER I WITH MACRON
-012B;A           # Ll         LATIN SMALL LETTER I WITH MACRON
-012C..0130;N     # L&     [5] LATIN CAPITAL LETTER I WITH BREVE..LATIN CAPITAL LETTER I WITH DOT ABOVE
-0131..0133;A     # L&     [3] LATIN SMALL LETTER DOTLESS I..LATIN SMALL LIGATURE IJ
-0134..0137;N     # L&     [4] LATIN CAPITAL LETTER J WITH CIRCUMFLEX..LATIN SMALL LETTER K WITH CEDILLA
-0138;A           # Ll         LATIN SMALL LETTER KRA
-0139..013E;N     # L&     [6] LATIN CAPITAL LETTER L WITH ACUTE..LATIN SMALL LETTER L WITH CARON
-013F..0142;A     # L&     [4] LATIN CAPITAL LETTER L WITH MIDDLE DOT..LATIN SMALL LETTER L WITH STROKE
-0143;N           # Lu         LATIN CAPITAL LETTER N WITH ACUTE
-0144;A           # Ll         LATIN SMALL LETTER N WITH ACUTE
-0145..0147;N     # L&     [3] LATIN CAPITAL LETTER N WITH CEDILLA..LATIN CAPITAL LETTER N WITH CARON
-0148..014B;A     # L&     [4] LATIN SMALL LETTER N WITH CARON..LATIN SMALL LETTER ENG
-014C;N           # Lu         LATIN CAPITAL LETTER O WITH MACRON
-014D;A           # Ll         LATIN SMALL LETTER O WITH MACRON
-014E..0151;N     # L&     [4] LATIN CAPITAL LETTER O WITH BREVE..LATIN SMALL LETTER O WITH DOUBLE ACUTE
-0152..0153;A     # L&     [2] LATIN CAPITAL LIGATURE OE..LATIN SMALL LIGATURE OE
-0154..0165;N     # L&    [18] LATIN CAPITAL LETTER R WITH ACUTE..LATIN SMALL LETTER T WITH CARON
-0166..0167;A     # L&     [2] LATIN CAPITAL LETTER T WITH STROKE..LATIN SMALL LETTER T WITH STROKE
-0168..016A;N     # L&     [3] LATIN CAPITAL LETTER U WITH TILDE..LATIN CAPITAL LETTER U WITH MACRON
-016B;A           # Ll         LATIN SMALL LETTER U WITH MACRON
-016C..017F;N     # L&    [20] LATIN CAPITAL LETTER U WITH BREVE..LATIN SMALL LETTER LONG S
-0180..01BA;N     # L&    [59] LATIN SMALL LETTER B WITH STROKE..LATIN SMALL LETTER EZH WITH TAIL
-01BB;N           # Lo         LATIN LETTER TWO WITH STROKE
-01BC..01BF;N     # L&     [4] LATIN CAPITAL LETTER TONE FIVE..LATIN LETTER WYNN
-01C0..01C3;N     # Lo     [4] LATIN LETTER DENTAL CLICK..LATIN LETTER RETROFLEX CLICK
-01C4..01CD;N     # L&    [10] LATIN CAPITAL LETTER DZ WITH CARON..LATIN CAPITAL LETTER A WITH CARON
-01CE;A           # Ll         LATIN SMALL LETTER A WITH CARON
-01CF;N           # Lu         LATIN CAPITAL LETTER I WITH CARON
-01D0;A           # Ll         LATIN SMALL LETTER I WITH CARON
-01D1;N           # Lu         LATIN CAPITAL LETTER O WITH CARON
-01D2;A           # Ll         LATIN SMALL LETTER O WITH CARON
-01D3;N           # Lu         LATIN CAPITAL LETTER U WITH CARON
-01D4;A           # Ll         LATIN SMALL LETTER U WITH CARON
-01D5;N           # Lu         LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON
-01D6;A           # Ll         LATIN SMALL LETTER U WITH DIAERESIS AND MACRON
-01D7;N           # Lu         LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE
-01D8;A           # Ll         LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE
-01D9;N           # Lu         LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON
-01DA;A           # Ll         LATIN SMALL LETTER U WITH DIAERESIS AND CARON
-01DB;N           # Lu         LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE
-01DC;A           # Ll         LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE
-01DD..024F;N     # L&   [115] LATIN SMALL LETTER TURNED E..LATIN SMALL LETTER Y WITH STROKE
-0250;N           # Ll         LATIN SMALL LETTER TURNED A
-0251;A           # Ll         LATIN SMALL LETTER ALPHA
-0252..0260;N     # Ll    [15] LATIN SMALL LETTER TURNED ALPHA..LATIN SMALL LETTER G WITH HOOK
-0261;A           # Ll         LATIN SMALL LETTER SCRIPT G
-0262..0293;N     # Ll    [50] LATIN LETTER SMALL CAPITAL G..LATIN SMALL LETTER EZH WITH CURL
-0294;N           # Lo         LATIN LETTER GLOTTAL STOP
-0295..02AF;N     # Ll    [27] LATIN LETTER PHARYNGEAL VOICED FRICATIVE..LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL
-02B0..02C1;N     # Lm    [18] MODIFIER LETTER SMALL H..MODIFIER LETTER REVERSED GLOTTAL STOP
-02C2..02C3;N     # Sk     [2] MODIFIER LETTER LEFT ARROWHEAD..MODIFIER LETTER RIGHT ARROWHEAD
-02C4;A           # Sk         MODIFIER LETTER UP ARROWHEAD
-02C5;N           # Sk         MODIFIER LETTER DOWN ARROWHEAD
-02C6;N           # Lm         MODIFIER LETTER CIRCUMFLEX ACCENT
-02C7;A           # Lm         CARON
-02C8;N           # Lm         MODIFIER LETTER VERTICAL LINE
-02C9..02CB;A     # Lm     [3] MODIFIER LETTER MACRON..MODIFIER LETTER GRAVE ACCENT
-02CC;N           # Lm         MODIFIER LETTER LOW VERTICAL LINE
-02CD;A           # Lm         MODIFIER LETTER LOW MACRON
-02CE..02CF;N     # Lm     [2] MODIFIER LETTER LOW GRAVE ACCENT..MODIFIER LETTER LOW ACUTE ACCENT
-02D0;A           # Lm         MODIFIER LETTER TRIANGULAR COLON
-02D1;N           # Lm         MODIFIER LETTER HALF TRIANGULAR COLON
-02D2..02D7;N     # Sk     [6] MODIFIER LETTER CENTRED RIGHT HALF RING..MODIFIER LETTER MINUS SIGN
-02D8..02DB;A     # Sk     [4] BREVE..OGONEK
-02DC;N           # Sk         SMALL TILDE
-02DD;A           # Sk         DOUBLE ACUTE ACCENT
-02DE;N           # Sk         MODIFIER LETTER RHOTIC HOOK
-02DF;A           # Sk         MODIFIER LETTER CROSS ACCENT
-02E0..02E4;N     # Lm     [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP
-02E5..02EB;N     # Sk     [7] MODIFIER LETTER EXTRA-HIGH TONE BAR..MODIFIER LETTER YANG DEPARTING TONE MARK
-02EC;N           # Lm         MODIFIER LETTER VOICING
-02ED;N           # Sk         MODIFIER LETTER UNASPIRATED
-02EE;N           # Lm         MODIFIER LETTER DOUBLE APOSTROPHE
-02EF..02FF;N     # Sk    [17] MODIFIER LETTER LOW DOWN ARROWHEAD..MODIFIER LETTER LOW LEFT ARROW
-0300..036F;A     # Mn   [112] COMBINING GRAVE ACCENT..COMBINING LATIN SMALL LETTER X
-0370..0373;N     # L&     [4] GREEK CAPITAL LETTER HETA..GREEK SMALL LETTER ARCHAIC SAMPI
-0374;N           # Lm         GREEK NUMERAL SIGN
-0375;N           # Sk         GREEK LOWER NUMERAL SIGN
-0376..0377;N     # L&     [2] GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA..GREEK SMALL LETTER PAMPHYLIAN DIGAMMA
-037A;N           # Lm         GREEK YPOGEGRAMMENI
-037B..037D;N     # Ll     [3] GREEK SMALL REVERSED LUNATE SIGMA SYMBOL..GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL
-037E;N           # Po         GREEK QUESTION MARK
-037F;N           # Lu         GREEK CAPITAL LETTER YOT
-0384..0385;N     # Sk     [2] GREEK TONOS..GREEK DIALYTIKA TONOS
-0386;N           # Lu         GREEK CAPITAL LETTER ALPHA WITH TONOS
-0387;N           # Po         GREEK ANO TELEIA
-0388..038A;N     # Lu     [3] GREEK CAPITAL LETTER EPSILON WITH TONOS..GREEK CAPITAL LETTER IOTA WITH TONOS
-038C;N           # Lu         GREEK CAPITAL LETTER OMICRON WITH TONOS
-038E..0390;N     # L&     [3] GREEK CAPITAL LETTER UPSILON WITH TONOS..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
-0391..03A1;A     # Lu    [17] GREEK CAPITAL LETTER ALPHA..GREEK CAPITAL LETTER RHO
-03A3..03A9;A     # Lu     [7] GREEK CAPITAL LETTER SIGMA..GREEK CAPITAL LETTER OMEGA
-03AA..03B0;N     # L&     [7] GREEK CAPITAL LETTER IOTA WITH DIALYTIKA..GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
-03B1..03C1;A     # Ll    [17] GREEK SMALL LETTER ALPHA..GREEK SMALL LETTER RHO
-03C2;N           # Ll         GREEK SMALL LETTER FINAL SIGMA
-03C3..03C9;A     # Ll     [7] GREEK SMALL LETTER SIGMA..GREEK SMALL LETTER OMEGA
-03CA..03F5;N     # L&    [44] GREEK SMALL LETTER IOTA WITH DIALYTIKA..GREEK LUNATE EPSILON SYMBOL
-03F6;N           # Sm         GREEK REVERSED LUNATE EPSILON SYMBOL
-03F7..03FF;N     # L&     [9] GREEK CAPITAL LETTER SHO..GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL
-0400;N           # Lu         CYRILLIC CAPITAL LETTER IE WITH GRAVE
-0401;A           # Lu         CYRILLIC CAPITAL LETTER IO
-0402..040F;N     # Lu    [14] CYRILLIC CAPITAL LETTER DJE..CYRILLIC CAPITAL LETTER DZHE
-0410..044F;A     # L&    [64] CYRILLIC CAPITAL LETTER A..CYRILLIC SMALL LETTER YA
-0450;N           # Ll         CYRILLIC SMALL LETTER IE WITH GRAVE
-0451;A           # Ll         CYRILLIC SMALL LETTER IO
-0452..0481;N     # L&    [48] CYRILLIC SMALL LETTER DJE..CYRILLIC SMALL LETTER KOPPA
-0482;N           # So         CYRILLIC THOUSANDS SIGN
-0483..0487;N     # Mn     [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE
-0488..0489;N     # Me     [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN
-048A..04FF;N     # L&   [118] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER HA WITH STROKE
-0500..052F;N     # L&    [48] CYRILLIC CAPITAL LETTER KOMI DE..CYRILLIC SMALL LETTER EL WITH DESCENDER
-0531..0556;N     # Lu    [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH
-0559;N           # Lm         ARMENIAN MODIFIER LETTER LEFT HALF RING
-055A..055F;N     # Po     [6] ARMENIAN APOSTROPHE..ARMENIAN ABBREVIATION MARK
-0560..0588;N     # Ll    [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE
-0589;N           # Po         ARMENIAN FULL STOP
-058A;N           # Pd         ARMENIAN HYPHEN
-058D..058E;N     # So     [2] RIGHT-FACING ARMENIAN ETERNITY SIGN..LEFT-FACING ARMENIAN ETERNITY SIGN
-058F;N           # Sc         ARMENIAN DRAM SIGN
-0591..05BD;N     # Mn    [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG
-05BE;N           # Pd         HEBREW PUNCTUATION MAQAF
-05BF;N           # Mn         HEBREW POINT RAFE
-05C0;N           # Po         HEBREW PUNCTUATION PASEQ
-05C1..05C2;N     # Mn     [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT
-05C3;N           # Po         HEBREW PUNCTUATION SOF PASUQ
-05C4..05C5;N     # Mn     [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT
-05C6;N           # Po         HEBREW PUNCTUATION NUN HAFUKHA
-05C7;N           # Mn         HEBREW POINT QAMATS QATAN
-05D0..05EA;N     # Lo    [27] HEBREW LETTER ALEF..HEBREW LETTER TAV
-05EF..05F2;N     # Lo     [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD
-05F3..05F4;N     # Po     [2] HEBREW PUNCTUATION GERESH..HEBREW PUNCTUATION GERSHAYIM
-0600..0605;N     # Cf     [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE
-0606..0608;N     # Sm     [3] ARABIC-INDIC CUBE ROOT..ARABIC RAY
-0609..060A;N     # Po     [2] ARABIC-INDIC PER MILLE SIGN..ARABIC-INDIC PER TEN THOUSAND SIGN
-060B;N           # Sc         AFGHANI SIGN
-060C..060D;N     # Po     [2] ARABIC COMMA..ARABIC DATE SEPARATOR
-060E..060F;N     # So     [2] ARABIC POETIC VERSE SIGN..ARABIC SIGN MISRA
-0610..061A;N     # Mn    [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA
-061B;N           # Po         ARABIC SEMICOLON
-061C;N           # Cf         ARABIC LETTER MARK
-061D..061F;N     # Po     [3] ARABIC END OF TEXT MARK..ARABIC QUESTION MARK
-0620..063F;N     # Lo    [32] ARABIC LETTER KASHMIRI YEH..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE
-0640;N           # Lm         ARABIC TATWEEL
-0641..064A;N     # Lo    [10] ARABIC LETTER FEH..ARABIC LETTER YEH
-064B..065F;N     # Mn    [21] ARABIC FATHATAN..ARABIC WAVY HAMZA BELOW
-0660..0669;N     # Nd    [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE
-066A..066D;N     # Po     [4] ARABIC PERCENT SIGN..ARABIC FIVE POINTED STAR
-066E..066F;N     # Lo     [2] ARABIC LETTER DOTLESS BEH..ARABIC LETTER DOTLESS QAF
-0670;N           # Mn         ARABIC LETTER SUPERSCRIPT ALEF
-0671..06D3;N     # Lo    [99] ARABIC LETTER ALEF WASLA..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE
-06D4;N           # Po         ARABIC FULL STOP
-06D5;N           # Lo         ARABIC LETTER AE
-06D6..06DC;N     # Mn     [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN
-06DD;N           # Cf         ARABIC END OF AYAH
-06DE;N           # So         ARABIC START OF RUB EL HIZB
-06DF..06E4;N     # Mn     [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA
-06E5..06E6;N     # Lm     [2] ARABIC SMALL WAW..ARABIC SMALL YEH
-06E7..06E8;N     # Mn     [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON
-06E9;N           # So         ARABIC PLACE OF SAJDAH
-06EA..06ED;N     # Mn     [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM
-06EE..06EF;N     # Lo     [2] ARABIC LETTER DAL WITH INVERTED V..ARABIC LETTER REH WITH INVERTED V
-06F0..06F9;N     # Nd    [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE
-06FA..06FC;N     # Lo     [3] ARABIC LETTER SHEEN WITH DOT BELOW..ARABIC LETTER GHAIN WITH DOT BELOW
-06FD..06FE;N     # So     [2] ARABIC SIGN SINDHI AMPERSAND..ARABIC SIGN SINDHI POSTPOSITION MEN
-06FF;N           # Lo         ARABIC LETTER HEH WITH INVERTED V
-0700..070D;N     # Po    [14] SYRIAC END OF PARAGRAPH..SYRIAC HARKLEAN ASTERISCUS
-070F;N           # Cf         SYRIAC ABBREVIATION MARK
-0710;N           # Lo         SYRIAC LETTER ALAPH
-0711;N           # Mn         SYRIAC LETTER SUPERSCRIPT ALAPH
-0712..072F;N     # Lo    [30] SYRIAC LETTER BETH..SYRIAC LETTER PERSIAN DHALATH
-0730..074A;N     # Mn    [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH
-074D..074F;N     # Lo     [3] SYRIAC LETTER SOGDIAN ZHAIN..SYRIAC LETTER SOGDIAN FE
-0750..077F;N     # Lo    [48] ARABIC LETTER BEH WITH THREE DOTS HORIZONTALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS ABOVE
-0780..07A5;N     # Lo    [38] THAANA LETTER HAA..THAANA LETTER WAAVU
-07A6..07B0;N     # Mn    [11] THAANA ABAFILI..THAANA SUKUN
-07B1;N           # Lo         THAANA LETTER NAA
-07C0..07C9;N     # Nd    [10] NKO DIGIT ZERO..NKO DIGIT NINE
-07CA..07EA;N     # Lo    [33] NKO LETTER A..NKO LETTER JONA RA
-07EB..07F3;N     # Mn     [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE
-07F4..07F5;N     # Lm     [2] NKO HIGH TONE APOSTROPHE..NKO LOW TONE APOSTROPHE
-07F6;N           # So         NKO SYMBOL OO DENNEN
-07F7..07F9;N     # Po     [3] NKO SYMBOL GBAKURUNEN..NKO EXCLAMATION MARK
-07FA;N           # Lm         NKO LAJANYALAN
-07FD;N           # Mn         NKO DANTAYALAN
-07FE..07FF;N     # Sc     [2] NKO DOROME SIGN..NKO TAMAN SIGN
-0800..0815;N     # Lo    [22] SAMARITAN LETTER ALAF..SAMARITAN LETTER TAAF
-0816..0819;N     # Mn     [4] SAMARITAN MARK IN..SAMARITAN MARK DAGESH
-081A;N           # Lm         SAMARITAN MODIFIER LETTER EPENTHETIC YUT
-081B..0823;N     # Mn     [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A
-0824;N           # Lm         SAMARITAN MODIFIER LETTER SHORT A
-0825..0827;N     # Mn     [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U
-0828;N           # Lm         SAMARITAN MODIFIER LETTER I
-0829..082D;N     # Mn     [5] SAMARITAN VOWEL SIGN LONG I..SAMARITAN MARK NEQUDAA
-0830..083E;N     # Po    [15] SAMARITAN PUNCTUATION NEQUDAA..SAMARITAN PUNCTUATION ANNAAU
-0840..0858;N     # Lo    [25] MANDAIC LETTER HALQA..MANDAIC LETTER AIN
-0859..085B;N     # Mn     [3] MANDAIC AFFRICATION MARK..MANDAIC GEMINATION MARK
-085E;N           # Po         MANDAIC PUNCTUATION
-0860..086A;N     # Lo    [11] SYRIAC LETTER MALAYALAM NGA..SYRIAC LETTER MALAYALAM SSA
-0870..0887;N     # Lo    [24] ARABIC LETTER ALEF WITH ATTACHED FATHA..ARABIC BASELINE ROUND DOT
-0888;N           # Sk         ARABIC RAISED ROUND DOT
-0889..088E;N     # Lo     [6] ARABIC LETTER NOON WITH INVERTED SMALL V..ARABIC VERTICAL TAIL
-0890..0891;N     # Cf     [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE
-0898..089F;N     # Mn     [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA
-08A0..08C8;N     # Lo    [41] ARABIC LETTER BEH WITH SMALL V BELOW..ARABIC LETTER GRAF
-08C9;N           # Lm         ARABIC SMALL FARSI YEH
-08CA..08E1;N     # Mn    [24] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL HIGH SIGN SAFHA
-08E2;N           # Cf         ARABIC DISPUTED END OF AYAH
-08E3..08FF;N     # Mn    [29] ARABIC TURNED DAMMA BELOW..ARABIC MARK SIDEWAYS NOON GHUNNA
-0900..0902;N     # Mn     [3] DEVANAGARI SIGN INVERTED CANDRABINDU..DEVANAGARI SIGN ANUSVARA
-0903;N           # Mc         DEVANAGARI SIGN VISARGA
-0904..0939;N     # Lo    [54] DEVANAGARI LETTER SHORT A..DEVANAGARI LETTER HA
-093A;N           # Mn         DEVANAGARI VOWEL SIGN OE
-093B;N           # Mc         DEVANAGARI VOWEL SIGN OOE
-093C;N           # Mn         DEVANAGARI SIGN NUKTA
-093D;N           # Lo         DEVANAGARI SIGN AVAGRAHA
-093E..0940;N     # Mc     [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II
-0941..0948;N     # Mn     [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI
-0949..094C;N     # Mc     [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU
-094D;N           # Mn         DEVANAGARI SIGN VIRAMA
-094E..094F;N     # Mc     [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW
-0950;N           # Lo         DEVANAGARI OM
-0951..0957;N     # Mn     [7] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI VOWEL SIGN UUE
-0958..0961;N     # Lo    [10] DEVANAGARI LETTER QA..DEVANAGARI LETTER VOCALIC LL
-0962..0963;N     # Mn     [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL
-0964..0965;N     # Po     [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA
-0966..096F;N     # Nd    [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE
-0970;N           # Po         DEVANAGARI ABBREVIATION SIGN
-0971;N           # Lm         DEVANAGARI SIGN HIGH SPACING DOT
-0972..097F;N     # Lo    [14] DEVANAGARI LETTER CANDRA A..DEVANAGARI LETTER BBA
-0980;N           # Lo         BENGALI ANJI
-0981;N           # Mn         BENGALI SIGN CANDRABINDU
-0982..0983;N     # Mc     [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA
-0985..098C;N     # Lo     [8] BENGALI LETTER A..BENGALI LETTER VOCALIC L
-098F..0990;N     # Lo     [2] BENGALI LETTER E..BENGALI LETTER AI
-0993..09A8;N     # Lo    [22] BENGALI LETTER O..BENGALI LETTER NA
-09AA..09B0;N     # Lo     [7] BENGALI LETTER PA..BENGALI LETTER RA
-09B2;N           # Lo         BENGALI LETTER LA
-09B6..09B9;N     # Lo     [4] BENGALI LETTER SHA..BENGALI LETTER HA
-09BC;N           # Mn         BENGALI SIGN NUKTA
-09BD;N           # Lo         BENGALI SIGN AVAGRAHA
-09BE..09C0;N     # Mc     [3] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN II
-09C1..09C4;N     # Mn     [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR
-09C7..09C8;N     # Mc     [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI
-09CB..09CC;N     # Mc     [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU
-09CD;N           # Mn         BENGALI SIGN VIRAMA
-09CE;N           # Lo         BENGALI LETTER KHANDA TA
-09D7;N           # Mc         BENGALI AU LENGTH MARK
-09DC..09DD;N     # Lo     [2] BENGALI LETTER RRA..BENGALI LETTER RHA
-09DF..09E1;N     # Lo     [3] BENGALI LETTER YYA..BENGALI LETTER VOCALIC LL
-09E2..09E3;N     # Mn     [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL
-09E6..09EF;N     # Nd    [10] BENGALI DIGIT ZERO..BENGALI DIGIT NINE
-09F0..09F1;N     # Lo     [2] BENGALI LETTER RA WITH MIDDLE DIAGONAL..BENGALI LETTER RA WITH LOWER DIAGONAL
-09F2..09F3;N     # Sc     [2] BENGALI RUPEE MARK..BENGALI RUPEE SIGN
-09F4..09F9;N     # No     [6] BENGALI CURRENCY NUMERATOR ONE..BENGALI CURRENCY DENOMINATOR SIXTEEN
-09FA;N           # So         BENGALI ISSHAR
-09FB;N           # Sc         BENGALI GANDA MARK
-09FC;N           # Lo         BENGALI LETTER VEDIC ANUSVARA
-09FD;N           # Po         BENGALI ABBREVIATION SIGN
-09FE;N           # Mn         BENGALI SANDHI MARK
-0A01..0A02;N     # Mn     [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI
-0A03;N           # Mc         GURMUKHI SIGN VISARGA
-0A05..0A0A;N     # Lo     [6] GURMUKHI LETTER A..GURMUKHI LETTER UU
-0A0F..0A10;N     # Lo     [2] GURMUKHI LETTER EE..GURMUKHI LETTER AI
-0A13..0A28;N     # Lo    [22] GURMUKHI LETTER OO..GURMUKHI LETTER NA
-0A2A..0A30;N     # Lo     [7] GURMUKHI LETTER PA..GURMUKHI LETTER RA
-0A32..0A33;N     # Lo     [2] GURMUKHI LETTER LA..GURMUKHI LETTER LLA
-0A35..0A36;N     # Lo     [2] GURMUKHI LETTER VA..GURMUKHI LETTER SHA
-0A38..0A39;N     # Lo     [2] GURMUKHI LETTER SA..GURMUKHI LETTER HA
-0A3C;N           # Mn         GURMUKHI SIGN NUKTA
-0A3E..0A40;N     # Mc     [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II
-0A41..0A42;N     # Mn     [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU
-0A47..0A48;N     # Mn     [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI
-0A4B..0A4D;N     # Mn     [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA
-0A51;N           # Mn         GURMUKHI SIGN UDAAT
-0A59..0A5C;N     # Lo     [4] GURMUKHI LETTER KHHA..GURMUKHI LETTER RRA
-0A5E;N           # Lo         GURMUKHI LETTER FA
-0A66..0A6F;N     # Nd    [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE
-0A70..0A71;N     # Mn     [2] GURMUKHI TIPPI..GURMUKHI ADDAK
-0A72..0A74;N     # Lo     [3] GURMUKHI IRI..GURMUKHI EK ONKAR
-0A75;N           # Mn         GURMUKHI SIGN YAKASH
-0A76;N           # Po         GURMUKHI ABBREVIATION SIGN
-0A81..0A82;N     # Mn     [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA
-0A83;N           # Mc         GUJARATI SIGN VISARGA
-0A85..0A8D;N     # Lo     [9] GUJARATI LETTER A..GUJARATI VOWEL CANDRA E
-0A8F..0A91;N     # Lo     [3] GUJARATI LETTER E..GUJARATI VOWEL CANDRA O
-0A93..0AA8;N     # Lo    [22] GUJARATI LETTER O..GUJARATI LETTER NA
-0AAA..0AB0;N     # Lo     [7] GUJARATI LETTER PA..GUJARATI LETTER RA
-0AB2..0AB3;N     # Lo     [2] GUJARATI LETTER LA..GUJARATI LETTER LLA
-0AB5..0AB9;N     # Lo     [5] GUJARATI LETTER VA..GUJARATI LETTER HA
-0ABC;N           # Mn         GUJARATI SIGN NUKTA
-0ABD;N           # Lo         GUJARATI SIGN AVAGRAHA
-0ABE..0AC0;N     # Mc     [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II
-0AC1..0AC5;N     # Mn     [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E
-0AC7..0AC8;N     # Mn     [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI
-0AC9;N           # Mc         GUJARATI VOWEL SIGN CANDRA O
-0ACB..0ACC;N     # Mc     [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU
-0ACD;N           # Mn         GUJARATI SIGN VIRAMA
-0AD0;N           # Lo         GUJARATI OM
-0AE0..0AE1;N     # Lo     [2] GUJARATI LETTER VOCALIC RR..GUJARATI LETTER VOCALIC LL
-0AE2..0AE3;N     # Mn     [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL
-0AE6..0AEF;N     # Nd    [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE
-0AF0;N           # Po         GUJARATI ABBREVIATION SIGN
-0AF1;N           # Sc         GUJARATI RUPEE SIGN
-0AF9;N           # Lo         GUJARATI LETTER ZHA
-0AFA..0AFF;N     # Mn     [6] GUJARATI SIGN SUKUN..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE
-0B01;N           # Mn         ORIYA SIGN CANDRABINDU
-0B02..0B03;N     # Mc     [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA
-0B05..0B0C;N     # Lo     [8] ORIYA LETTER A..ORIYA LETTER VOCALIC L
-0B0F..0B10;N     # Lo     [2] ORIYA LETTER E..ORIYA LETTER AI
-0B13..0B28;N     # Lo    [22] ORIYA LETTER O..ORIYA LETTER NA
-0B2A..0B30;N     # Lo     [7] ORIYA LETTER PA..ORIYA LETTER RA
-0B32..0B33;N     # Lo     [2] ORIYA LETTER LA..ORIYA LETTER LLA
-0B35..0B39;N     # Lo     [5] ORIYA LETTER VA..ORIYA LETTER HA
-0B3C;N           # Mn         ORIYA SIGN NUKTA
-0B3D;N           # Lo         ORIYA SIGN AVAGRAHA
-0B3E;N           # Mc         ORIYA VOWEL SIGN AA
-0B3F;N           # Mn         ORIYA VOWEL SIGN I
-0B40;N           # Mc         ORIYA VOWEL SIGN II
-0B41..0B44;N     # Mn     [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR
-0B47..0B48;N     # Mc     [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI
-0B4B..0B4C;N     # Mc     [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU
-0B4D;N           # Mn         ORIYA SIGN VIRAMA
-0B55..0B56;N     # Mn     [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK
-0B57;N           # Mc         ORIYA AU LENGTH MARK
-0B5C..0B5D;N     # Lo     [2] ORIYA LETTER RRA..ORIYA LETTER RHA
-0B5F..0B61;N     # Lo     [3] ORIYA LETTER YYA..ORIYA LETTER VOCALIC LL
-0B62..0B63;N     # Mn     [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL
-0B66..0B6F;N     # Nd    [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE
-0B70;N           # So         ORIYA ISSHAR
-0B71;N           # Lo         ORIYA LETTER WA
-0B72..0B77;N     # No     [6] ORIYA FRACTION ONE QUARTER..ORIYA FRACTION THREE SIXTEENTHS
-0B82;N           # Mn         TAMIL SIGN ANUSVARA
-0B83;N           # Lo         TAMIL SIGN VISARGA
-0B85..0B8A;N     # Lo     [6] TAMIL LETTER A..TAMIL LETTER UU
-0B8E..0B90;N     # Lo     [3] TAMIL LETTER E..TAMIL LETTER AI
-0B92..0B95;N     # Lo     [4] TAMIL LETTER O..TAMIL LETTER KA
-0B99..0B9A;N     # Lo     [2] TAMIL LETTER NGA..TAMIL LETTER CA
-0B9C;N           # Lo         TAMIL LETTER JA
-0B9E..0B9F;N     # Lo     [2] TAMIL LETTER NYA..TAMIL LETTER TTA
-0BA3..0BA4;N     # Lo     [2] TAMIL LETTER NNA..TAMIL LETTER TA
-0BA8..0BAA;N     # Lo     [3] TAMIL LETTER NA..TAMIL LETTER PA
-0BAE..0BB9;N     # Lo    [12] TAMIL LETTER MA..TAMIL LETTER HA
-0BBE..0BBF;N     # Mc     [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN I
-0BC0;N           # Mn         TAMIL VOWEL SIGN II
-0BC1..0BC2;N     # Mc     [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU
-0BC6..0BC8;N     # Mc     [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI
-0BCA..0BCC;N     # Mc     [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU
-0BCD;N           # Mn         TAMIL SIGN VIRAMA
-0BD0;N           # Lo         TAMIL OM
-0BD7;N           # Mc         TAMIL AU LENGTH MARK
-0BE6..0BEF;N     # Nd    [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE
-0BF0..0BF2;N     # No     [3] TAMIL NUMBER TEN..TAMIL NUMBER ONE THOUSAND
-0BF3..0BF8;N     # So     [6] TAMIL DAY SIGN..TAMIL AS ABOVE SIGN
-0BF9;N           # Sc         TAMIL RUPEE SIGN
-0BFA;N           # So         TAMIL NUMBER SIGN
-0C00;N           # Mn         TELUGU SIGN COMBINING CANDRABINDU ABOVE
-0C01..0C03;N     # Mc     [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA
-0C04;N           # Mn         TELUGU SIGN COMBINING ANUSVARA ABOVE
-0C05..0C0C;N     # Lo     [8] TELUGU LETTER A..TELUGU LETTER VOCALIC L
-0C0E..0C10;N     # Lo     [3] TELUGU LETTER E..TELUGU LETTER AI
-0C12..0C28;N     # Lo    [23] TELUGU LETTER O..TELUGU LETTER NA
-0C2A..0C39;N     # Lo    [16] TELUGU LETTER PA..TELUGU LETTER HA
-0C3C;N           # Mn         TELUGU SIGN NUKTA
-0C3D;N           # Lo         TELUGU SIGN AVAGRAHA
-0C3E..0C40;N     # Mn     [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II
-0C41..0C44;N     # Mc     [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR
-0C46..0C48;N     # Mn     [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI
-0C4A..0C4D;N     # Mn     [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA
-0C55..0C56;N     # Mn     [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK
-0C58..0C5A;N     # Lo     [3] TELUGU LETTER TSA..TELUGU LETTER RRRA
-0C5D;N           # Lo         TELUGU LETTER NAKAARA POLLU
-0C60..0C61;N     # Lo     [2] TELUGU LETTER VOCALIC RR..TELUGU LETTER VOCALIC LL
-0C62..0C63;N     # Mn     [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL
-0C66..0C6F;N     # Nd    [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE
-0C77;N           # Po         TELUGU SIGN SIDDHAM
-0C78..0C7E;N     # No     [7] TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR..TELUGU FRACTION DIGIT THREE FOR EVEN POWERS OF FOUR
-0C7F;N           # So         TELUGU SIGN TUUMU
-0C80;N           # Lo         KANNADA SIGN SPACING CANDRABINDU
-0C81;N           # Mn         KANNADA SIGN CANDRABINDU
-0C82..0C83;N     # Mc     [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA
-0C84;N           # Po         KANNADA SIGN SIDDHAM
-0C85..0C8C;N     # Lo     [8] KANNADA LETTER A..KANNADA LETTER VOCALIC L
-0C8E..0C90;N     # Lo     [3] KANNADA LETTER E..KANNADA LETTER AI
-0C92..0CA8;N     # Lo    [23] KANNADA LETTER O..KANNADA LETTER NA
-0CAA..0CB3;N     # Lo    [10] KANNADA LETTER PA..KANNADA LETTER LLA
-0CB5..0CB9;N     # Lo     [5] KANNADA LETTER VA..KANNADA LETTER HA
-0CBC;N           # Mn         KANNADA SIGN NUKTA
-0CBD;N           # Lo         KANNADA SIGN AVAGRAHA
-0CBE;N           # Mc         KANNADA VOWEL SIGN AA
-0CBF;N           # Mn         KANNADA VOWEL SIGN I
-0CC0..0CC4;N     # Mc     [5] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN VOCALIC RR
-0CC6;N           # Mn         KANNADA VOWEL SIGN E
-0CC7..0CC8;N     # Mc     [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI
-0CCA..0CCB;N     # Mc     [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO
-0CCC..0CCD;N     # Mn     [2] KANNADA VOWEL SIGN AU..KANNADA SIGN VIRAMA
-0CD5..0CD6;N     # Mc     [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK
-0CDD..0CDE;N     # Lo     [2] KANNADA LETTER NAKAARA POLLU..KANNADA LETTER FA
-0CE0..0CE1;N     # Lo     [2] KANNADA LETTER VOCALIC RR..KANNADA LETTER VOCALIC LL
-0CE2..0CE3;N     # Mn     [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
-0CE6..0CEF;N     # Nd    [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
-0CF1..0CF2;N     # Lo     [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA
-0CF3;N           # Mc         KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT
-0D00..0D01;N     # Mn     [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU
-0D02..0D03;N     # Mc     [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
-0D04..0D0C;N     # Lo     [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L
-0D0E..0D10;N     # Lo     [3] MALAYALAM LETTER E..MALAYALAM LETTER AI
-0D12..0D3A;N     # Lo    [41] MALAYALAM LETTER O..MALAYALAM LETTER TTTA
-0D3B..0D3C;N     # Mn     [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA
-0D3D;N           # Lo         MALAYALAM SIGN AVAGRAHA
-0D3E..0D40;N     # Mc     [3] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN II
-0D41..0D44;N     # Mn     [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR
-0D46..0D48;N     # Mc     [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI
-0D4A..0D4C;N     # Mc     [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU
-0D4D;N           # Mn         MALAYALAM SIGN VIRAMA
-0D4E;N           # Lo         MALAYALAM LETTER DOT REPH
-0D4F;N           # So         MALAYALAM SIGN PARA
-0D54..0D56;N     # Lo     [3] MALAYALAM LETTER CHILLU M..MALAYALAM LETTER CHILLU LLL
-0D57;N           # Mc         MALAYALAM AU LENGTH MARK
-0D58..0D5E;N     # No     [7] MALAYALAM FRACTION ONE ONE-HUNDRED-AND-SIXTIETH..MALAYALAM FRACTION ONE FIFTH
-0D5F..0D61;N     # Lo     [3] MALAYALAM LETTER ARCHAIC II..MALAYALAM LETTER VOCALIC LL
-0D62..0D63;N     # Mn     [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL
-0D66..0D6F;N     # Nd    [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE
-0D70..0D78;N     # No     [9] MALAYALAM NUMBER TEN..MALAYALAM FRACTION THREE SIXTEENTHS
-0D79;N           # So         MALAYALAM DATE MARK
-0D7A..0D7F;N     # Lo     [6] MALAYALAM LETTER CHILLU NN..MALAYALAM LETTER CHILLU K
-0D81;N           # Mn         SINHALA SIGN CANDRABINDU
-0D82..0D83;N     # Mc     [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA
-0D85..0D96;N     # Lo    [18] SINHALA LETTER AYANNA..SINHALA LETTER AUYANNA
-0D9A..0DB1;N     # Lo    [24] SINHALA LETTER ALPAPRAANA KAYANNA..SINHALA LETTER DANTAJA NAYANNA
-0DB3..0DBB;N     # Lo     [9] SINHALA LETTER SANYAKA DAYANNA..SINHALA LETTER RAYANNA
-0DBD;N           # Lo         SINHALA LETTER DANTAJA LAYANNA
-0DC0..0DC6;N     # Lo     [7] SINHALA LETTER VAYANNA..SINHALA LETTER FAYANNA
-0DCA;N           # Mn         SINHALA SIGN AL-LAKUNA
-0DCF..0DD1;N     # Mc     [3] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA
-0DD2..0DD4;N     # Mn     [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA
-0DD6;N           # Mn         SINHALA VOWEL SIGN DIGA PAA-PILLA
-0DD8..0DDF;N     # Mc     [8] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN GAYANUKITTA
-0DE6..0DEF;N     # Nd    [10] SINHALA LITH DIGIT ZERO..SINHALA LITH DIGIT NINE
-0DF2..0DF3;N     # Mc     [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA
-0DF4;N           # Po         SINHALA PUNCTUATION KUNDDALIYA
-0E01..0E30;N     # Lo    [48] THAI CHARACTER KO KAI..THAI CHARACTER SARA A
-0E31;N           # Mn         THAI CHARACTER MAI HAN-AKAT
-0E32..0E33;N     # Lo     [2] THAI CHARACTER SARA AA..THAI CHARACTER SARA AM
-0E34..0E3A;N     # Mn     [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU
-0E3F;N           # Sc         THAI CURRENCY SYMBOL BAHT
-0E40..0E45;N     # Lo     [6] THAI CHARACTER SARA E..THAI CHARACTER LAKKHANGYAO
-0E46;N           # Lm         THAI CHARACTER MAIYAMOK
-0E47..0E4E;N     # Mn     [8] THAI CHARACTER MAITAIKHU..THAI CHARACTER YAMAKKAN
-0E4F;N           # Po         THAI CHARACTER FONGMAN
-0E50..0E59;N     # Nd    [10] THAI DIGIT ZERO..THAI DIGIT NINE
-0E5A..0E5B;N     # Po     [2] THAI CHARACTER ANGKHANKHU..THAI CHARACTER KHOMUT
-0E81..0E82;N     # Lo     [2] LAO LETTER KO..LAO LETTER KHO SUNG
-0E84;N           # Lo         LAO LETTER KHO TAM
-0E86..0E8A;N     # Lo     [5] LAO LETTER PALI GHA..LAO LETTER SO TAM
-0E8C..0EA3;N     # Lo    [24] LAO LETTER PALI JHA..LAO LETTER LO LING
-0EA5;N           # Lo         LAO LETTER LO LOOT
-0EA7..0EB0;N     # Lo    [10] LAO LETTER WO..LAO VOWEL SIGN A
-0EB1;N           # Mn         LAO VOWEL SIGN MAI KAN
-0EB2..0EB3;N     # Lo     [2] LAO VOWEL SIGN AA..LAO VOWEL SIGN AM
-0EB4..0EBC;N     # Mn     [9] LAO VOWEL SIGN I..LAO SEMIVOWEL SIGN LO
-0EBD;N           # Lo         LAO SEMIVOWEL SIGN NYO
-0EC0..0EC4;N     # Lo     [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
-0EC6;N           # Lm         LAO KO LA
-0EC8..0ECE;N     # Mn     [7] LAO TONE MAI EK..LAO YAMAKKAN
-0ED0..0ED9;N     # Nd    [10] LAO DIGIT ZERO..LAO DIGIT NINE
-0EDC..0EDF;N     # Lo     [4] LAO HO NO..LAO LETTER KHMU NYO
-0F00;N           # Lo         TIBETAN SYLLABLE OM
-0F01..0F03;N     # So     [3] TIBETAN MARK GTER YIG MGO TRUNCATED A..TIBETAN MARK GTER YIG MGO -UM GTER TSHEG MA
-0F04..0F12;N     # Po    [15] TIBETAN MARK INITIAL YIG MGO MDUN MA..TIBETAN MARK RGYA GRAM SHAD
-0F13;N           # So         TIBETAN MARK CARET -DZUD RTAGS ME LONG CAN
-0F14;N           # Po         TIBETAN MARK GTER TSHEG
-0F15..0F17;N     # So     [3] TIBETAN LOGOTYPE SIGN CHAD RTAGS..TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS
-0F18..0F19;N     # Mn     [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS
-0F1A..0F1F;N     # So     [6] TIBETAN SIGN RDEL DKAR GCIG..TIBETAN SIGN RDEL DKAR RDEL NAG
-0F20..0F29;N     # Nd    [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE
-0F2A..0F33;N     # No    [10] TIBETAN DIGIT HALF ONE..TIBETAN DIGIT HALF ZERO
-0F34;N           # So         TIBETAN MARK BSDUS RTAGS
-0F35;N           # Mn         TIBETAN MARK NGAS BZUNG NYI ZLA
-0F36;N           # So         TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN
-0F37;N           # Mn         TIBETAN MARK NGAS BZUNG SGOR RTAGS
-0F38;N           # So         TIBETAN MARK CHE MGO
-0F39;N           # Mn         TIBETAN MARK TSA -PHRU
-0F3A;N           # Ps         TIBETAN MARK GUG RTAGS GYON
-0F3B;N           # Pe         TIBETAN MARK GUG RTAGS GYAS
-0F3C;N           # Ps         TIBETAN MARK ANG KHANG GYON
-0F3D;N           # Pe         TIBETAN MARK ANG KHANG GYAS
-0F3E..0F3F;N     # Mc     [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES
-0F40..0F47;N     # Lo     [8] TIBETAN LETTER KA..TIBETAN LETTER JA
-0F49..0F6C;N     # Lo    [36] TIBETAN LETTER NYA..TIBETAN LETTER RRA
-0F71..0F7E;N     # Mn    [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO
-0F7F;N           # Mc         TIBETAN SIGN RNAM BCAD
-0F80..0F84;N     # Mn     [5] TIBETAN VOWEL SIGN REVERSED I..TIBETAN MARK HALANTA
-0F85;N           # Po         TIBETAN MARK PALUTA
-0F86..0F87;N     # Mn     [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS
-0F88..0F8C;N     # Lo     [5] TIBETAN SIGN LCE TSA CAN..TIBETAN SIGN INVERTED MCHU CAN
-0F8D..0F97;N     # Mn    [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA
-0F99..0FBC;N     # Mn    [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA
-0FBE..0FC5;N     # So     [8] TIBETAN KU RU KHA..TIBETAN SYMBOL RDO RJE
-0FC6;N           # Mn         TIBETAN SYMBOL PADMA GDAN
-0FC7..0FCC;N     # So     [6] TIBETAN SYMBOL RDO RJE RGYA GRAM..TIBETAN SYMBOL NOR BU BZHI -KHYIL
-0FCE..0FCF;N     # So     [2] TIBETAN SIGN RDEL NAG RDEL DKAR..TIBETAN SIGN RDEL NAG GSUM
-0FD0..0FD4;N     # Po     [5] TIBETAN MARK BSKA- SHOG GI MGO RGYAN..TIBETAN MARK CLOSING BRDA RNYING YIG MGO SGAB MA
-0FD5..0FD8;N     # So     [4] RIGHT-FACING SVASTI SIGN..LEFT-FACING SVASTI SIGN WITH DOTS
-0FD9..0FDA;N     # Po     [2] TIBETAN MARK LEADING MCHAN RTAGS..TIBETAN MARK TRAILING MCHAN RTAGS
-1000..102A;N     # Lo    [43] MYANMAR LETTER KA..MYANMAR LETTER AU
-102B..102C;N     # Mc     [2] MYANMAR VOWEL SIGN TALL AA..MYANMAR VOWEL SIGN AA
-102D..1030;N     # Mn     [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU
-1031;N           # Mc         MYANMAR VOWEL SIGN E
-1032..1037;N     # Mn     [6] MYANMAR VOWEL SIGN AI..MYANMAR SIGN DOT BELOW
-1038;N           # Mc         MYANMAR SIGN VISARGA
-1039..103A;N     # Mn     [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT
-103B..103C;N     # Mc     [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA
-103D..103E;N     # Mn     [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA
-103F;N           # Lo         MYANMAR LETTER GREAT SA
-1040..1049;N     # Nd    [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE
-104A..104F;N     # Po     [6] MYANMAR SIGN LITTLE SECTION..MYANMAR SYMBOL GENITIVE
-1050..1055;N     # Lo     [6] MYANMAR LETTER SHA..MYANMAR LETTER VOCALIC LL
-1056..1057;N     # Mc     [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR
-1058..1059;N     # Mn     [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL
-105A..105D;N     # Lo     [4] MYANMAR LETTER MON NGA..MYANMAR LETTER MON BBE
-105E..1060;N     # Mn     [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA
-1061;N           # Lo         MYANMAR LETTER SGAW KAREN SHA
-1062..1064;N     # Mc     [3] MYANMAR VOWEL SIGN SGAW KAREN EU..MYANMAR TONE MARK SGAW KAREN KE PHO
-1065..1066;N     # Lo     [2] MYANMAR LETTER WESTERN PWO KAREN THA..MYANMAR LETTER WESTERN PWO KAREN PWA
-1067..106D;N     # Mc     [7] MYANMAR VOWEL SIGN WESTERN PWO KAREN EU..MYANMAR SIGN WESTERN PWO KAREN TONE-5
-106E..1070;N     # Lo     [3] MYANMAR LETTER EASTERN PWO KAREN NNA..MYANMAR LETTER EASTERN PWO KAREN GHWA
-1071..1074;N     # Mn     [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE
-1075..1081;N     # Lo    [13] MYANMAR LETTER SHAN KA..MYANMAR LETTER SHAN HA
-1082;N           # Mn         MYANMAR CONSONANT SIGN SHAN MEDIAL WA
-1083..1084;N     # Mc     [2] MYANMAR VOWEL SIGN SHAN AA..MYANMAR VOWEL SIGN SHAN E
-1085..1086;N     # Mn     [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y
-1087..108C;N     # Mc     [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3
-108D;N           # Mn         MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE
-108E;N           # Lo         MYANMAR LETTER RUMAI PALAUNG FA
-108F;N           # Mc         MYANMAR SIGN RUMAI PALAUNG TONE-5
-1090..1099;N     # Nd    [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE
-109A..109C;N     # Mc     [3] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON A
-109D;N           # Mn         MYANMAR VOWEL SIGN AITON AI
-109E..109F;N     # So     [2] MYANMAR SYMBOL SHAN ONE..MYANMAR SYMBOL SHAN EXCLAMATION
-10A0..10C5;N     # Lu    [38] GEORGIAN CAPITAL LETTER AN..GEORGIAN CAPITAL LETTER HOE
-10C7;N           # Lu         GEORGIAN CAPITAL LETTER YN
-10CD;N           # Lu         GEORGIAN CAPITAL LETTER AEN
-10D0..10FA;N     # Ll    [43] GEORGIAN LETTER AN..GEORGIAN LETTER AIN
-10FB;N           # Po         GEORGIAN PARAGRAPH SEPARATOR
-10FC;N           # Lm         MODIFIER LETTER GEORGIAN NAR
-10FD..10FF;N     # Ll     [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN
-1100..115F;W     # Lo    [96] HANGUL CHOSEONG KIYEOK..HANGUL CHOSEONG FILLER
-1160..11FF;N     # Lo   [160] HANGUL JUNGSEONG FILLER..HANGUL JONGSEONG SSANGNIEUN
-1200..1248;N     # Lo    [73] ETHIOPIC SYLLABLE HA..ETHIOPIC SYLLABLE QWA
-124A..124D;N     # Lo     [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SYLLABLE QWE
-1250..1256;N     # Lo     [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SYLLABLE QHO
-1258;N           # Lo         ETHIOPIC SYLLABLE QHWA
-125A..125D;N     # Lo     [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC SYLLABLE QHWE
-1260..1288;N     # Lo    [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYLLABLE XWA
-128A..128D;N     # Lo     [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SYLLABLE XWE
-1290..12B0;N     # Lo    [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYLLABLE KWA
-12B2..12B5;N     # Lo     [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SYLLABLE KWE
-12B8..12BE;N     # Lo     [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SYLLABLE KXO
-12C0;N           # Lo         ETHIOPIC SYLLABLE KXWA
-12C2..12C5;N     # Lo     [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC SYLLABLE KXWE
-12C8..12D6;N     # Lo    [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYLLABLE PHARYNGEAL O
-12D8..1310;N     # Lo    [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYLLABLE GWA
-1312..1315;N     # Lo     [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SYLLABLE GWE
-1318..135A;N     # Lo    [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SYLLABLE FYA
-135D..135F;N     # Mn     [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK
-1360..1368;N     # Po     [9] ETHIOPIC SECTION MARK..ETHIOPIC PARAGRAPH SEPARATOR
-1369..137C;N     # No    [20] ETHIOPIC DIGIT ONE..ETHIOPIC NUMBER TEN THOUSAND
-1380..138F;N     # Lo    [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..ETHIOPIC SYLLABLE PWE
-1390..1399;N     # So    [10] ETHIOPIC TONAL MARK YIZET..ETHIOPIC TONAL MARK KURT
-13A0..13F5;N     # Lu    [86] CHEROKEE LETTER A..CHEROKEE LETTER MV
-13F8..13FD;N     # Ll     [6] CHEROKEE SMALL LETTER YE..CHEROKEE SMALL LETTER MV
-1400;N           # Pd         CANADIAN SYLLABICS HYPHEN
-1401..166C;N     # Lo   [620] CANADIAN SYLLABICS E..CANADIAN SYLLABICS CARRIER TTSA
-166D;N           # So         CANADIAN SYLLABICS CHI SIGN
-166E;N           # Po         CANADIAN SYLLABICS FULL STOP
-166F..167F;N     # Lo    [17] CANADIAN SYLLABICS QAI..CANADIAN SYLLABICS BLACKFOOT W
-1680;N           # Zs         OGHAM SPACE MARK
-1681..169A;N     # Lo    [26] OGHAM LETTER BEITH..OGHAM LETTER PEITH
-169B;N           # Ps         OGHAM FEATHER MARK
-169C;N           # Pe         OGHAM REVERSED FEATHER MARK
-16A0..16EA;N     # Lo    [75] RUNIC LETTER FEHU FEOH FE F..RUNIC LETTER X
-16EB..16ED;N     # Po     [3] RUNIC SINGLE PUNCTUATION..RUNIC CROSS PUNCTUATION
-16EE..16F0;N     # Nl     [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHOR SYMBOL
-16F1..16F8;N     # Lo     [8] RUNIC LETTER K..RUNIC LETTER FRANKS CASKET AESC
-1700..1711;N     # Lo    [18] TAGALOG LETTER A..TAGALOG LETTER HA
-1712..1714;N     # Mn     [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN VIRAMA
-1715;N           # Mc         TAGALOG SIGN PAMUDPOD
-171F;N           # Lo         TAGALOG LETTER ARCHAIC RA
-1720..1731;N     # Lo    [18] HANUNOO LETTER A..HANUNOO LETTER HA
-1732..1733;N     # Mn     [2] HANUNOO VOWEL SIGN I..HANUNOO VOWEL SIGN U
-1734;N           # Mc         HANUNOO SIGN PAMUDPOD
-1735..1736;N     # Po     [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION
-1740..1751;N     # Lo    [18] BUHID LETTER A..BUHID LETTER HA
-1752..1753;N     # Mn     [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U
-1760..176C;N     # Lo    [13] TAGBANWA LETTER A..TAGBANWA LETTER YA
-176E..1770;N     # Lo     [3] TAGBANWA LETTER LA..TAGBANWA LETTER SA
-1772..1773;N     # Mn     [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U
-1780..17B3;N     # Lo    [52] KHMER LETTER KA..KHMER INDEPENDENT VOWEL QAU
-17B4..17B5;N     # Mn     [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA
-17B6;N           # Mc         KHMER VOWEL SIGN AA
-17B7..17BD;N     # Mn     [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA
-17BE..17C5;N     # Mc     [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU
-17C6;N           # Mn         KHMER SIGN NIKAHIT
-17C7..17C8;N     # Mc     [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU
-17C9..17D3;N     # Mn    [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT
-17D4..17D6;N     # Po     [3] KHMER SIGN KHAN..KHMER SIGN CAMNUC PII KUUH
-17D7;N           # Lm         KHMER SIGN LEK TOO
-17D8..17DA;N     # Po     [3] KHMER SIGN BEYYAL..KHMER SIGN KOOMUUT
-17DB;N           # Sc         KHMER CURRENCY SYMBOL RIEL
-17DC;N           # Lo         KHMER SIGN AVAKRAHASANYA
-17DD;N           # Mn         KHMER SIGN ATTHACAN
-17E0..17E9;N     # Nd    [10] KHMER DIGIT ZERO..KHMER DIGIT NINE
-17F0..17F9;N     # No    [10] KHMER SYMBOL LEK ATTAK SON..KHMER SYMBOL LEK ATTAK PRAM-BUON
-1800..1805;N     # Po     [6] MONGOLIAN BIRGA..MONGOLIAN FOUR DOTS
-1806;N           # Pd         MONGOLIAN TODO SOFT HYPHEN
-1807..180A;N     # Po     [4] MONGOLIAN SIBE SYLLABLE BOUNDARY MARKER..MONGOLIAN NIRUGU
-180B..180D;N     # Mn     [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE
-180E;N           # Cf         MONGOLIAN VOWEL SEPARATOR
-180F;N           # Mn         MONGOLIAN FREE VARIATION SELECTOR FOUR
-1810..1819;N     # Nd    [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE
-1820..1842;N     # Lo    [35] MONGOLIAN LETTER A..MONGOLIAN LETTER CHI
-1843;N           # Lm         MONGOLIAN LETTER TODO LONG VOWEL SIGN
-1844..1878;N     # Lo    [53] MONGOLIAN LETTER TODO E..MONGOLIAN LETTER CHA WITH TWO DOTS
-1880..1884;N     # Lo     [5] MONGOLIAN LETTER ALI GALI ANUSVARA ONE..MONGOLIAN LETTER ALI GALI INVERTED UBADAMA
-1885..1886;N     # Mn     [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA
-1887..18A8;N     # Lo    [34] MONGOLIAN LETTER ALI GALI A..MONGOLIAN LETTER MANCHU ALI GALI BHA
-18A9;N           # Mn         MONGOLIAN LETTER ALI GALI DAGALGA
-18AA;N           # Lo         MONGOLIAN LETTER MANCHU ALI GALI LHA
-18B0..18F5;N     # Lo    [70] CANADIAN SYLLABICS OY..CANADIAN SYLLABICS CARRIER DENTAL S
-1900..191E;N     # Lo    [31] LIMBU VOWEL-CARRIER LETTER..LIMBU LETTER TRA
-1920..1922;N     # Mn     [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U
-1923..1926;N     # Mc     [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU
-1927..1928;N     # Mn     [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O
-1929..192B;N     # Mc     [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA
-1930..1931;N     # Mc     [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA
-1932;N           # Mn         LIMBU SMALL LETTER ANUSVARA
-1933..1938;N     # Mc     [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA
-1939..193B;N     # Mn     [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I
-1940;N           # So         LIMBU SIGN LOO
-1944..1945;N     # Po     [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK
-1946..194F;N     # Nd    [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE
-1950..196D;N     # Lo    [30] TAI LE LETTER KA..TAI LE LETTER AI
-1970..1974;N     # Lo     [5] TAI LE LETTER TONE-2..TAI LE LETTER TONE-6
-1980..19AB;N     # Lo    [44] NEW TAI LUE LETTER HIGH QA..NEW TAI LUE LETTER LOW SUA
-19B0..19C9;N     # Lo    [26] NEW TAI LUE VOWEL SIGN VOWEL SHORTENER..NEW TAI LUE TONE MARK-2
-19D0..19D9;N     # Nd    [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE
-19DA;N           # No         NEW TAI LUE THAM DIGIT ONE
-19DE..19DF;N     # So     [2] NEW TAI LUE SIGN LAE..NEW TAI LUE SIGN LAEV
-19E0..19FF;N     # So    [32] KHMER SYMBOL PATHAMASAT..KHMER SYMBOL DAP-PRAM ROC
-1A00..1A16;N     # Lo    [23] BUGINESE LETTER KA..BUGINESE LETTER HA
-1A17..1A18;N     # Mn     [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U
-1A19..1A1A;N     # Mc     [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O
-1A1B;N           # Mn         BUGINESE VOWEL SIGN AE
-1A1E..1A1F;N     # Po     [2] BUGINESE PALLAWA..BUGINESE END OF SECTION
-1A20..1A54;N     # Lo    [53] TAI THAM LETTER HIGH KA..TAI THAM LETTER GREAT SA
-1A55;N           # Mc         TAI THAM CONSONANT SIGN MEDIAL RA
-1A56;N           # Mn         TAI THAM CONSONANT SIGN MEDIAL LA
-1A57;N           # Mc         TAI THAM CONSONANT SIGN LA TANG LAI
-1A58..1A5E;N     # Mn     [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA
-1A60;N           # Mn         TAI THAM SIGN SAKOT
-1A61;N           # Mc         TAI THAM VOWEL SIGN A
-1A62;N           # Mn         TAI THAM VOWEL SIGN MAI SAT
-1A63..1A64;N     # Mc     [2] TAI THAM VOWEL SIGN AA..TAI THAM VOWEL SIGN TALL AA
-1A65..1A6C;N     # Mn     [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW
-1A6D..1A72;N     # Mc     [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI
-1A73..1A7C;N     # Mn    [10] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN KHUEN-LUE KARAN
-1A7F;N           # Mn         TAI THAM COMBINING CRYPTOGRAMMIC DOT
-1A80..1A89;N     # Nd    [10] TAI THAM HORA DIGIT ZERO..TAI THAM HORA DIGIT NINE
-1A90..1A99;N     # Nd    [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE
-1AA0..1AA6;N     # Po     [7] TAI THAM SIGN WIANG..TAI THAM SIGN REVERSED ROTATED RANA
-1AA7;N           # Lm         TAI THAM SIGN MAI YAMOK
-1AA8..1AAD;N     # Po     [6] TAI THAM SIGN KAAN..TAI THAM SIGN CAANG
-1AB0..1ABD;N     # Mn    [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW
-1ABE;N           # Me         COMBINING PARENTHESES OVERLAY
-1ABF..1ACE;N     # Mn    [16] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER INSULAR T
-1B00..1B03;N     # Mn     [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG
-1B04;N           # Mc         BALINESE SIGN BISAH
-1B05..1B33;N     # Lo    [47] BALINESE LETTER AKARA..BALINESE LETTER HA
-1B34;N           # Mn         BALINESE SIGN REREKAN
-1B35;N           # Mc         BALINESE VOWEL SIGN TEDUNG
-1B36..1B3A;N     # Mn     [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA
-1B3B;N           # Mc         BALINESE VOWEL SIGN RA REPA TEDUNG
-1B3C;N           # Mn         BALINESE VOWEL SIGN LA LENGA
-1B3D..1B41;N     # Mc     [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG
-1B42;N           # Mn         BALINESE VOWEL SIGN PEPET
-1B43..1B44;N     # Mc     [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG
-1B45..1B4C;N     # Lo     [8] BALINESE LETTER KAF SASAK..BALINESE LETTER ARCHAIC JNYA
-1B50..1B59;N     # Nd    [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE
-1B5A..1B60;N     # Po     [7] BALINESE PANTI..BALINESE PAMENENG
-1B61..1B6A;N     # So    [10] BALINESE MUSICAL SYMBOL DONG..BALINESE MUSICAL SYMBOL DANG GEDE
-1B6B..1B73;N     # Mn     [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG
-1B74..1B7C;N     # So     [9] BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DUG..BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PING
-1B7D..1B7E;N     # Po     [2] BALINESE PANTI LANTANG..BALINESE PAMADA LANTANG
-1B80..1B81;N     # Mn     [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR
-1B82;N           # Mc         SUNDANESE SIGN PANGWISAD
-1B83..1BA0;N     # Lo    [30] SUNDANESE LETTER A..SUNDANESE LETTER HA
-1BA1;N           # Mc         SUNDANESE CONSONANT SIGN PAMINGKAL
-1BA2..1BA5;N     # Mn     [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU
-1BA6..1BA7;N     # Mc     [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG
-1BA8..1BA9;N     # Mn     [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG
-1BAA;N           # Mc         SUNDANESE SIGN PAMAAEH
-1BAB..1BAD;N     # Mn     [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA
-1BAE..1BAF;N     # Lo     [2] SUNDANESE LETTER KHA..SUNDANESE LETTER SYA
-1BB0..1BB9;N     # Nd    [10] SUNDANESE DIGIT ZERO..SUNDANESE DIGIT NINE
-1BBA..1BBF;N     # Lo     [6] SUNDANESE AVAGRAHA..SUNDANESE LETTER FINAL M
-1BC0..1BE5;N     # Lo    [38] BATAK LETTER A..BATAK LETTER U
-1BE6;N           # Mn         BATAK SIGN TOMPI
-1BE7;N           # Mc         BATAK VOWEL SIGN E
-1BE8..1BE9;N     # Mn     [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE
-1BEA..1BEC;N     # Mc     [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O
-1BED;N           # Mn         BATAK VOWEL SIGN KARO O
-1BEE;N           # Mc         BATAK VOWEL SIGN U
-1BEF..1BF1;N     # Mn     [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H
-1BF2..1BF3;N     # Mc     [2] BATAK PANGOLAT..BATAK PANONGONAN
-1BFC..1BFF;N     # Po     [4] BATAK SYMBOL BINDU NA METEK..BATAK SYMBOL BINDU PANGOLAT
-1C00..1C23;N     # Lo    [36] LEPCHA LETTER KA..LEPCHA LETTER A
-1C24..1C2B;N     # Mc     [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU
-1C2C..1C33;N     # Mn     [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T
-1C34..1C35;N     # Mc     [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG
-1C36..1C37;N     # Mn     [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA
-1C3B..1C3F;N     # Po     [5] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION TSHOOK
-1C40..1C49;N     # Nd    [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE
-1C4D..1C4F;N     # Lo     [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA
-1C50..1C59;N     # Nd    [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGIT NINE
-1C5A..1C77;N     # Lo    [30] OL CHIKI LETTER LA..OL CHIKI LETTER OH
-1C78..1C7D;N     # Lm     [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD
-1C7E..1C7F;N     # Po     [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD
-1C80..1C88;N     # Ll     [9] CYRILLIC SMALL LETTER ROUNDED VE..CYRILLIC SMALL LETTER UNBLENDED UK
-1C90..1CBA;N     # Lu    [43] GEORGIAN MTAVRULI CAPITAL LETTER AN..GEORGIAN MTAVRULI CAPITAL LETTER AIN
-1CBD..1CBF;N     # Lu     [3] GEORGIAN MTAVRULI CAPITAL LETTER AEN..GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN
-1CC0..1CC7;N     # Po     [8] SUNDANESE PUNCTUATION BINDU SURYA..SUNDANESE PUNCTUATION BINDU BA SATANGA
-1CD0..1CD2;N     # Mn     [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA
-1CD3;N           # Po         VEDIC SIGN NIHSHVASA
-1CD4..1CE0;N     # Mn    [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA
-1CE1;N           # Mc         VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA
-1CE2..1CE8;N     # Mn     [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL
-1CE9..1CEC;N     # Lo     [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA..VEDIC SIGN ANUSVARA VAMAGOMUKHA WITH TAIL
-1CED;N           # Mn         VEDIC SIGN TIRYAK
-1CEE..1CF3;N     # Lo     [6] VEDIC SIGN HEXIFORM LONG ANUSVARA..VEDIC SIGN ROTATED ARDHAVISARGA
-1CF4;N           # Mn         VEDIC TONE CANDRA ABOVE
-1CF5..1CF6;N     # Lo     [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN UPADHMANIYA
-1CF7;N           # Mc         VEDIC SIGN ATIKRAMA
-1CF8..1CF9;N     # Mn     [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE
-1CFA;N           # Lo         VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA
-1D00..1D2B;N     # Ll    [44] LATIN LETTER SMALL CAPITAL A..CYRILLIC LETTER SMALL CAPITAL EL
-1D2C..1D6A;N     # Lm    [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI
-1D6B..1D77;N     # Ll    [13] LATIN SMALL LETTER UE..LATIN SMALL LETTER TURNED G
-1D78;N           # Lm         MODIFIER LETTER CYRILLIC EN
-1D79..1D7F;N     # Ll     [7] LATIN SMALL LETTER INSULAR G..LATIN SMALL LETTER UPSILON WITH STROKE
-1D80..1D9A;N     # Ll    [27] LATIN SMALL LETTER B WITH PALATAL HOOK..LATIN SMALL LETTER EZH WITH RETROFLEX HOOK
-1D9B..1DBF;N     # Lm    [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA
-1DC0..1DFF;N     # Mn    [64] COMBINING DOTTED GRAVE ACCENT..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW
-1E00..1EFF;N     # L&   [256] LATIN CAPITAL LETTER A WITH RING BELOW..LATIN SMALL LETTER Y WITH LOOP
-1F00..1F15;N     # L&    [22] GREEK SMALL LETTER ALPHA WITH PSILI..GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA
-1F18..1F1D;N     # Lu     [6] GREEK CAPITAL LETTER EPSILON WITH PSILI..GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA
-1F20..1F45;N     # L&    [38] GREEK SMALL LETTER ETA WITH PSILI..GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA
-1F48..1F4D;N     # Lu     [6] GREEK CAPITAL LETTER OMICRON WITH PSILI..GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA
-1F50..1F57;N     # Ll     [8] GREEK SMALL LETTER UPSILON WITH PSILI..GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI
-1F59;N           # Lu         GREEK CAPITAL LETTER UPSILON WITH DASIA
-1F5B;N           # Lu         GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA
-1F5D;N           # Lu         GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA
-1F5F..1F7D;N     # L&    [31] GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI..GREEK SMALL LETTER OMEGA WITH OXIA
-1F80..1FB4;N     # L&    [53] GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI..GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI
-1FB6..1FBC;N     # L&     [7] GREEK SMALL LETTER ALPHA WITH PERISPOMENI..GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI
-1FBD;N           # Sk         GREEK KORONIS
-1FBE;N           # Ll         GREEK PROSGEGRAMMENI
-1FBF..1FC1;N     # Sk     [3] GREEK PSILI..GREEK DIALYTIKA AND PERISPOMENI
-1FC2..1FC4;N     # Ll     [3] GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI
-1FC6..1FCC;N     # L&     [7] GREEK SMALL LETTER ETA WITH PERISPOMENI..GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
-1FCD..1FCF;N     # Sk     [3] GREEK PSILI AND VARIA..GREEK PSILI AND PERISPOMENI
-1FD0..1FD3;N     # Ll     [4] GREEK SMALL LETTER IOTA WITH VRACHY..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
-1FD6..1FDB;N     # L&     [6] GREEK SMALL LETTER IOTA WITH PERISPOMENI..GREEK CAPITAL LETTER IOTA WITH OXIA
-1FDD..1FDF;N     # Sk     [3] GREEK DASIA AND VARIA..GREEK DASIA AND PERISPOMENI
-1FE0..1FEC;N     # L&    [13] GREEK SMALL LETTER UPSILON WITH VRACHY..GREEK CAPITAL LETTER RHO WITH DASIA
-1FED..1FEF;N     # Sk     [3] GREEK DIALYTIKA AND VARIA..GREEK VARIA
-1FF2..1FF4;N     # Ll     [3] GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI
-1FF6..1FFC;N     # L&     [7] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
-1FFD..1FFE;N     # Sk     [2] GREEK OXIA..GREEK DASIA
-2000..200A;N     # Zs    [11] EN QUAD..HAIR SPACE
-200B..200F;N     # Cf     [5] ZERO WIDTH SPACE..RIGHT-TO-LEFT MARK
-2010;A           # Pd         HYPHEN
-2011..2012;N     # Pd     [2] NON-BREAKING HYPHEN..FIGURE DASH
-2013..2015;A     # Pd     [3] EN DASH..HORIZONTAL BAR
-2016;A           # Po         DOUBLE VERTICAL LINE
-2017;N           # Po         DOUBLE LOW LINE
-2018;A           # Pi         LEFT SINGLE QUOTATION MARK
-2019;A           # Pf         RIGHT SINGLE QUOTATION MARK
-201A;N           # Ps         SINGLE LOW-9 QUOTATION MARK
-201B;N           # Pi         SINGLE HIGH-REVERSED-9 QUOTATION MARK
-201C;A           # Pi         LEFT DOUBLE QUOTATION MARK
-201D;A           # Pf         RIGHT DOUBLE QUOTATION MARK
-201E;N           # Ps         DOUBLE LOW-9 QUOTATION MARK
-201F;N           # Pi         DOUBLE HIGH-REVERSED-9 QUOTATION MARK
-2020..2022;A     # Po     [3] DAGGER..BULLET
-2023;N           # Po         TRIANGULAR BULLET
-2024..2027;A     # Po     [4] ONE DOT LEADER..HYPHENATION POINT
-2028;N           # Zl         LINE SEPARATOR
-2029;N           # Zp         PARAGRAPH SEPARATOR
-202A..202E;N     # Cf     [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE
-202F;N           # Zs         NARROW NO-BREAK SPACE
-2030;A           # Po         PER MILLE SIGN
-2031;N           # Po         PER TEN THOUSAND SIGN
-2032..2033;A     # Po     [2] PRIME..DOUBLE PRIME
-2034;N           # Po         TRIPLE PRIME
-2035;A           # Po         REVERSED PRIME
-2036..2038;N     # Po     [3] REVERSED DOUBLE PRIME..CARET
-2039;N           # Pi         SINGLE LEFT-POINTING ANGLE QUOTATION MARK
-203A;N           # Pf         SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
-203B;A           # Po         REFERENCE MARK
-203C..203D;N     # Po     [2] DOUBLE EXCLAMATION MARK..INTERROBANG
-203E;A           # Po         OVERLINE
-203F..2040;N     # Pc     [2] UNDERTIE..CHARACTER TIE
-2041..2043;N     # Po     [3] CARET INSERTION POINT..HYPHEN BULLET
-2044;N           # Sm         FRACTION SLASH
-2045;N           # Ps         LEFT SQUARE BRACKET WITH QUILL
-2046;N           # Pe         RIGHT SQUARE BRACKET WITH QUILL
-2047..2051;N     # Po    [11] DOUBLE QUESTION MARK..TWO ASTERISKS ALIGNED VERTICALLY
-2052;N           # Sm         COMMERCIAL MINUS SIGN
-2053;N           # Po         SWUNG DASH
-2054;N           # Pc         INVERTED UNDERTIE
-2055..205E;N     # Po    [10] FLOWER PUNCTUATION MARK..VERTICAL FOUR DOTS
-205F;N           # Zs         MEDIUM MATHEMATICAL SPACE
-2060..2064;N     # Cf     [5] WORD JOINER..INVISIBLE PLUS
-2066..206F;N     # Cf    [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES
-2070;N           # No         SUPERSCRIPT ZERO
-2071;N           # Lm         SUPERSCRIPT LATIN SMALL LETTER I
-2074;A           # No         SUPERSCRIPT FOUR
-2075..2079;N     # No     [5] SUPERSCRIPT FIVE..SUPERSCRIPT NINE
-207A..207C;N     # Sm     [3] SUPERSCRIPT PLUS SIGN..SUPERSCRIPT EQUALS SIGN
-207D;N           # Ps         SUPERSCRIPT LEFT PARENTHESIS
-207E;N           # Pe         SUPERSCRIPT RIGHT PARENTHESIS
-207F;A           # Lm         SUPERSCRIPT LATIN SMALL LETTER N
-2080;N           # No         SUBSCRIPT ZERO
-2081..2084;A     # No     [4] SUBSCRIPT ONE..SUBSCRIPT FOUR
-2085..2089;N     # No     [5] SUBSCRIPT FIVE..SUBSCRIPT NINE
-208A..208C;N     # Sm     [3] SUBSCRIPT PLUS SIGN..SUBSCRIPT EQUALS SIGN
-208D;N           # Ps         SUBSCRIPT LEFT PARENTHESIS
-208E;N           # Pe         SUBSCRIPT RIGHT PARENTHESIS
-2090..209C;N     # Lm    [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T
-20A0..20A8;N     # Sc     [9] EURO-CURRENCY SIGN..RUPEE SIGN
-20A9;H           # Sc         WON SIGN
-20AA..20AB;N     # Sc     [2] NEW SHEQEL SIGN..DONG SIGN
-20AC;A           # Sc         EURO SIGN
-20AD..20C0;N     # Sc    [20] KIP SIGN..SOM SIGN
-20D0..20DC;N     # Mn    [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE
-20DD..20E0;N     # Me     [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH
-20E1;N           # Mn         COMBINING LEFT RIGHT ARROW ABOVE
-20E2..20E4;N     # Me     [3] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING UPWARD POINTING TRIANGLE
-20E5..20F0;N     # Mn    [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE
-2100..2101;N     # So     [2] ACCOUNT OF..ADDRESSED TO THE SUBJECT
-2102;N           # Lu         DOUBLE-STRUCK CAPITAL C
-2103;A           # So         DEGREE CELSIUS
-2104;N           # So         CENTRE LINE SYMBOL
-2105;A           # So         CARE OF
-2106;N           # So         CADA UNA
-2107;N           # Lu         EULER CONSTANT
-2108;N           # So         SCRUPLE
-2109;A           # So         DEGREE FAHRENHEIT
-210A..2112;N     # L&     [9] SCRIPT SMALL G..SCRIPT CAPITAL L
-2113;A           # Ll         SCRIPT SMALL L
-2114;N           # So         L B BAR SYMBOL
-2115;N           # Lu         DOUBLE-STRUCK CAPITAL N
-2116;A           # So         NUMERO SIGN
-2117;N           # So         SOUND RECORDING COPYRIGHT
-2118;N           # Sm         SCRIPT CAPITAL P
-2119..211D;N     # Lu     [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R
-211E..2120;N     # So     [3] PRESCRIPTION TAKE..SERVICE MARK
-2121..2122;A     # So     [2] TELEPHONE SIGN..TRADE MARK SIGN
-2123;N           # So         VERSICLE
-2124;N           # Lu         DOUBLE-STRUCK CAPITAL Z
-2125;N           # So         OUNCE SIGN
-2126;A           # Lu         OHM SIGN
-2127;N           # So         INVERTED OHM SIGN
-2128;N           # Lu         BLACK-LETTER CAPITAL Z
-2129;N           # So         TURNED GREEK SMALL LETTER IOTA
-212A;N           # Lu         KELVIN SIGN
-212B;A           # Lu         ANGSTROM SIGN
-212C..212D;N     # Lu     [2] SCRIPT CAPITAL B..BLACK-LETTER CAPITAL C
-212E;N           # So         ESTIMATED SYMBOL
-212F..2134;N     # L&     [6] SCRIPT SMALL E..SCRIPT SMALL O
-2135..2138;N     # Lo     [4] ALEF SYMBOL..DALET SYMBOL
-2139;N           # Ll         INFORMATION SOURCE
-213A..213B;N     # So     [2] ROTATED CAPITAL Q..FACSIMILE SIGN
-213C..213F;N     # L&     [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STRUCK CAPITAL PI
-2140..2144;N     # Sm     [5] DOUBLE-STRUCK N-ARY SUMMATION..TURNED SANS-SERIF CAPITAL Y
-2145..2149;N     # L&     [5] DOUBLE-STRUCK ITALIC CAPITAL D..DOUBLE-STRUCK ITALIC SMALL J
-214A;N           # So         PROPERTY LINE
-214B;N           # Sm         TURNED AMPERSAND
-214C..214D;N     # So     [2] PER SIGN..AKTIESELSKAB
-214E;N           # Ll         TURNED SMALL F
-214F;N           # So         SYMBOL FOR SAMARITAN SOURCE
-2150..2152;N     # No     [3] VULGAR FRACTION ONE SEVENTH..VULGAR FRACTION ONE TENTH
-2153..2154;A     # No     [2] VULGAR FRACTION ONE THIRD..VULGAR FRACTION TWO THIRDS
-2155..215A;N     # No     [6] VULGAR FRACTION ONE FIFTH..VULGAR FRACTION FIVE SIXTHS
-215B..215E;A     # No     [4] VULGAR FRACTION ONE EIGHTH..VULGAR FRACTION SEVEN EIGHTHS
-215F;N           # No         FRACTION NUMERATOR ONE
-2160..216B;A     # Nl    [12] ROMAN NUMERAL ONE..ROMAN NUMERAL TWELVE
-216C..216F;N     # Nl     [4] ROMAN NUMERAL FIFTY..ROMAN NUMERAL ONE THOUSAND
-2170..2179;A     # Nl    [10] SMALL ROMAN NUMERAL ONE..SMALL ROMAN NUMERAL TEN
-217A..2182;N     # Nl     [9] SMALL ROMAN NUMERAL ELEVEN..ROMAN NUMERAL TEN THOUSAND
-2183..2184;N     # L&     [2] ROMAN NUMERAL REVERSED ONE HUNDRED..LATIN SMALL LETTER REVERSED C
-2185..2188;N     # Nl     [4] ROMAN NUMERAL SIX LATE FORM..ROMAN NUMERAL ONE HUNDRED THOUSAND
-2189;A           # No         VULGAR FRACTION ZERO THIRDS
-218A..218B;N     # So     [2] TURNED DIGIT TWO..TURNED DIGIT THREE
-2190..2194;A     # Sm     [5] LEFTWARDS ARROW..LEFT RIGHT ARROW
-2195..2199;A     # So     [5] UP DOWN ARROW..SOUTH WEST ARROW
-219A..219B;N     # Sm     [2] LEFTWARDS ARROW WITH STROKE..RIGHTWARDS ARROW WITH STROKE
-219C..219F;N     # So     [4] LEFTWARDS WAVE ARROW..UPWARDS TWO HEADED ARROW
-21A0;N           # Sm         RIGHTWARDS TWO HEADED ARROW
-21A1..21A2;N     # So     [2] DOWNWARDS TWO HEADED ARROW..LEFTWARDS ARROW WITH TAIL
-21A3;N           # Sm         RIGHTWARDS ARROW WITH TAIL
-21A4..21A5;N     # So     [2] LEFTWARDS ARROW FROM BAR..UPWARDS ARROW FROM BAR
-21A6;N           # Sm         RIGHTWARDS ARROW FROM BAR
-21A7..21AD;N     # So     [7] DOWNWARDS ARROW FROM BAR..LEFT RIGHT WAVE ARROW
-21AE;N           # Sm         LEFT RIGHT ARROW WITH STROKE
-21AF..21B7;N     # So     [9] DOWNWARDS ZIGZAG ARROW..CLOCKWISE TOP SEMICIRCLE ARROW
-21B8..21B9;A     # So     [2] NORTH WEST ARROW TO LONG BAR..LEFTWARDS ARROW TO BAR OVER RIGHTWARDS ARROW TO BAR
-21BA..21CD;N     # So    [20] ANTICLOCKWISE OPEN CIRCLE ARROW..LEFTWARDS DOUBLE ARROW WITH STROKE
-21CE..21CF;N     # Sm     [2] LEFT RIGHT DOUBLE ARROW WITH STROKE..RIGHTWARDS DOUBLE ARROW WITH STROKE
-21D0..21D1;N     # So     [2] LEFTWARDS DOUBLE ARROW..UPWARDS DOUBLE ARROW
-21D2;A           # Sm         RIGHTWARDS DOUBLE ARROW
-21D3;N           # So         DOWNWARDS DOUBLE ARROW
-21D4;A           # Sm         LEFT RIGHT DOUBLE ARROW
-21D5..21E6;N     # So    [18] UP DOWN DOUBLE ARROW..LEFTWARDS WHITE ARROW
-21E7;A           # So         UPWARDS WHITE ARROW
-21E8..21F3;N     # So    [12] RIGHTWARDS WHITE ARROW..UP DOWN WHITE ARROW
-21F4..21FF;N     # Sm    [12] RIGHT ARROW WITH SMALL CIRCLE..LEFT RIGHT OPEN-HEADED ARROW
-2200;A           # Sm         FOR ALL
-2201;N           # Sm         COMPLEMENT
-2202..2203;A     # Sm     [2] PARTIAL DIFFERENTIAL..THERE EXISTS
-2204..2206;N     # Sm     [3] THERE DOES NOT EXIST..INCREMENT
-2207..2208;A     # Sm     [2] NABLA..ELEMENT OF
-2209..220A;N     # Sm     [2] NOT AN ELEMENT OF..SMALL ELEMENT OF
-220B;A           # Sm         CONTAINS AS MEMBER
-220C..220E;N     # Sm     [3] DOES NOT CONTAIN AS MEMBER..END OF PROOF
-220F;A           # Sm         N-ARY PRODUCT
-2210;N           # Sm         N-ARY COPRODUCT
-2211;A           # Sm         N-ARY SUMMATION
-2212..2214;N     # Sm     [3] MINUS SIGN..DOT PLUS
-2215;A           # Sm         DIVISION SLASH
-2216..2219;N     # Sm     [4] SET MINUS..BULLET OPERATOR
-221A;A           # Sm         SQUARE ROOT
-221B..221C;N     # Sm     [2] CUBE ROOT..FOURTH ROOT
-221D..2220;A     # Sm     [4] PROPORTIONAL TO..ANGLE
-2221..2222;N     # Sm     [2] MEASURED ANGLE..SPHERICAL ANGLE
-2223;A           # Sm         DIVIDES
-2224;N           # Sm         DOES NOT DIVIDE
-2225;A           # Sm         PARALLEL TO
-2226;N           # Sm         NOT PARALLEL TO
-2227..222C;A     # Sm     [6] LOGICAL AND..DOUBLE INTEGRAL
-222D;N           # Sm         TRIPLE INTEGRAL
-222E;A           # Sm         CONTOUR INTEGRAL
-222F..2233;N     # Sm     [5] SURFACE INTEGRAL..ANTICLOCKWISE CONTOUR INTEGRAL
-2234..2237;A     # Sm     [4] THEREFORE..PROPORTION
-2238..223B;N     # Sm     [4] DOT MINUS..HOMOTHETIC
-223C..223D;A     # Sm     [2] TILDE OPERATOR..REVERSED TILDE
-223E..2247;N     # Sm    [10] INVERTED LAZY S..NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO
-2248;A           # Sm         ALMOST EQUAL TO
-2249..224B;N     # Sm     [3] NOT ALMOST EQUAL TO..TRIPLE TILDE
-224C;A           # Sm         ALL EQUAL TO
-224D..2251;N     # Sm     [5] EQUIVALENT TO..GEOMETRICALLY EQUAL TO
-2252;A           # Sm         APPROXIMATELY EQUAL TO OR THE IMAGE OF
-2253..225F;N     # Sm    [13] IMAGE OF OR APPROXIMATELY EQUAL TO..QUESTIONED EQUAL TO
-2260..2261;A     # Sm     [2] NOT EQUAL TO..IDENTICAL TO
-2262..2263;N     # Sm     [2] NOT IDENTICAL TO..STRICTLY EQUIVALENT TO
-2264..2267;A     # Sm     [4] LESS-THAN OR EQUAL TO..GREATER-THAN OVER EQUAL TO
-2268..2269;N     # Sm     [2] LESS-THAN BUT NOT EQUAL TO..GREATER-THAN BUT NOT EQUAL TO
-226A..226B;A     # Sm     [2] MUCH LESS-THAN..MUCH GREATER-THAN
-226C..226D;N     # Sm     [2] BETWEEN..NOT EQUIVALENT TO
-226E..226F;A     # Sm     [2] NOT LESS-THAN..NOT GREATER-THAN
-2270..2281;N     # Sm    [18] NEITHER LESS-THAN NOR EQUAL TO..DOES NOT SUCCEED
-2282..2283;A     # Sm     [2] SUBSET OF..SUPERSET OF
-2284..2285;N     # Sm     [2] NOT A SUBSET OF..NOT A SUPERSET OF
-2286..2287;A     # Sm     [2] SUBSET OF OR EQUAL TO..SUPERSET OF OR EQUAL TO
-2288..2294;N     # Sm    [13] NEITHER A SUBSET OF NOR EQUAL TO..SQUARE CUP
-2295;A           # Sm         CIRCLED PLUS
-2296..2298;N     # Sm     [3] CIRCLED MINUS..CIRCLED DIVISION SLASH
-2299;A           # Sm         CIRCLED DOT OPERATOR
-229A..22A4;N     # Sm    [11] CIRCLED RING OPERATOR..DOWN TACK
-22A5;A           # Sm         UP TACK
-22A6..22BE;N     # Sm    [25] ASSERTION..RIGHT ANGLE WITH ARC
-22BF;A           # Sm         RIGHT TRIANGLE
-22C0..22FF;N     # Sm    [64] N-ARY LOGICAL AND..Z NOTATION BAG MEMBERSHIP
-2300..2307;N     # So     [8] DIAMETER SIGN..WAVY LINE
-2308;N           # Ps         LEFT CEILING
-2309;N           # Pe         RIGHT CEILING
-230A;N           # Ps         LEFT FLOOR
-230B;N           # Pe         RIGHT FLOOR
-230C..2311;N     # So     [6] BOTTOM RIGHT CROP..SQUARE LOZENGE
-2312;A           # So         ARC
-2313..2319;N     # So     [7] SEGMENT..TURNED NOT SIGN
-231A..231B;W     # So     [2] WATCH..HOURGLASS
-231C..231F;N     # So     [4] TOP LEFT CORNER..BOTTOM RIGHT CORNER
-2320..2321;N     # Sm     [2] TOP HALF INTEGRAL..BOTTOM HALF INTEGRAL
-2322..2328;N     # So     [7] FROWN..KEYBOARD
-2329;W           # Ps         LEFT-POINTING ANGLE BRACKET
-232A;W           # Pe         RIGHT-POINTING ANGLE BRACKET
-232B..237B;N     # So    [81] ERASE TO THE LEFT..NOT CHECK MARK
-237C;N           # Sm         RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW
-237D..239A;N     # So    [30] SHOULDERED OPEN BOX..CLEAR SCREEN SYMBOL
-239B..23B3;N     # Sm    [25] LEFT PARENTHESIS UPPER HOOK..SUMMATION BOTTOM
-23B4..23DB;N     # So    [40] TOP SQUARE BRACKET..FUSE
-23DC..23E1;N     # Sm     [6] TOP PARENTHESIS..BOTTOM TORTOISE SHELL BRACKET
-23E2..23E8;N     # So     [7] WHITE TRAPEZIUM..DECIMAL EXPONENT SYMBOL
-23E9..23EC;W     # So     [4] BLACK RIGHT-POINTING DOUBLE TRIANGLE..BLACK DOWN-POINTING DOUBLE TRIANGLE
-23ED..23EF;N     # So     [3] BLACK RIGHT-POINTING DOUBLE TRIANGLE WITH VERTICAL BAR..BLACK RIGHT-POINTING TRIANGLE WITH DOUBLE VERTICAL BAR
-23F0;W           # So         ALARM CLOCK
-23F1..23F2;N     # So     [2] STOPWATCH..TIMER CLOCK
-23F3;W           # So         HOURGLASS WITH FLOWING SAND
-23F4..23FF;N     # So    [12] BLACK MEDIUM LEFT-POINTING TRIANGLE..OBSERVER EYE SYMBOL
-2400..2426;N     # So    [39] SYMBOL FOR NULL..SYMBOL FOR SUBSTITUTE FORM TWO
-2440..244A;N     # So    [11] OCR HOOK..OCR DOUBLE BACKSLASH
-2460..249B;A     # No    [60] CIRCLED DIGIT ONE..NUMBER TWENTY FULL STOP
-249C..24E9;A     # So    [78] PARENTHESIZED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z
-24EA;N           # No         CIRCLED DIGIT ZERO
-24EB..24FF;A     # No    [21] NEGATIVE CIRCLED NUMBER ELEVEN..NEGATIVE CIRCLED DIGIT ZERO
-2500..254B;A     # So    [76] BOX DRAWINGS LIGHT HORIZONTAL..BOX DRAWINGS HEAVY VERTICAL AND HORIZONTAL
-254C..254F;N     # So     [4] BOX DRAWINGS LIGHT DOUBLE DASH HORIZONTAL..BOX DRAWINGS HEAVY DOUBLE DASH VERTICAL
-2550..2573;A     # So    [36] BOX DRAWINGS DOUBLE HORIZONTAL..BOX DRAWINGS LIGHT DIAGONAL CROSS
-2574..257F;N     # So    [12] BOX DRAWINGS LIGHT LEFT..BOX DRAWINGS HEAVY UP AND LIGHT DOWN
-2580..258F;A     # So    [16] UPPER HALF BLOCK..LEFT ONE EIGHTH BLOCK
-2590..2591;N     # So     [2] RIGHT HALF BLOCK..LIGHT SHADE
-2592..2595;A     # So     [4] MEDIUM SHADE..RIGHT ONE EIGHTH BLOCK
-2596..259F;N     # So    [10] QUADRANT LOWER LEFT..QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT
-25A0..25A1;A     # So     [2] BLACK SQUARE..WHITE SQUARE
-25A2;N           # So         WHITE SQUARE WITH ROUNDED CORNERS
-25A3..25A9;A     # So     [7] WHITE SQUARE CONTAINING BLACK SMALL SQUARE..SQUARE WITH DIAGONAL CROSSHATCH FILL
-25AA..25B1;N     # So     [8] BLACK SMALL SQUARE..WHITE PARALLELOGRAM
-25B2..25B3;A     # So     [2] BLACK UP-POINTING TRIANGLE..WHITE UP-POINTING TRIANGLE
-25B4..25B5;N     # So     [2] BLACK UP-POINTING SMALL TRIANGLE..WHITE UP-POINTING SMALL TRIANGLE
-25B6;A           # So         BLACK RIGHT-POINTING TRIANGLE
-25B7;A           # Sm         WHITE RIGHT-POINTING TRIANGLE
-25B8..25BB;N     # So     [4] BLACK RIGHT-POINTING SMALL TRIANGLE..WHITE RIGHT-POINTING POINTER
-25BC..25BD;A     # So     [2] BLACK DOWN-POINTING TRIANGLE..WHITE DOWN-POINTING TRIANGLE
-25BE..25BF;N     # So     [2] BLACK DOWN-POINTING SMALL TRIANGLE..WHITE DOWN-POINTING SMALL TRIANGLE
-25C0;A           # So         BLACK LEFT-POINTING TRIANGLE
-25C1;A           # Sm         WHITE LEFT-POINTING TRIANGLE
-25C2..25C5;N     # So     [4] BLACK LEFT-POINTING SMALL TRIANGLE..WHITE LEFT-POINTING POINTER
-25C6..25C8;A     # So     [3] BLACK DIAMOND..WHITE DIAMOND CONTAINING BLACK SMALL DIAMOND
-25C9..25CA;N     # So     [2] FISHEYE..LOZENGE
-25CB;A           # So         WHITE CIRCLE
-25CC..25CD;N     # So     [2] DOTTED CIRCLE..CIRCLE WITH VERTICAL FILL
-25CE..25D1;A     # So     [4] BULLSEYE..CIRCLE WITH RIGHT HALF BLACK
-25D2..25E1;N     # So    [16] CIRCLE WITH LOWER HALF BLACK..LOWER HALF CIRCLE
-25E2..25E5;A     # So     [4] BLACK LOWER RIGHT TRIANGLE..BLACK UPPER RIGHT TRIANGLE
-25E6..25EE;N     # So     [9] WHITE BULLET..UP-POINTING TRIANGLE WITH RIGHT HALF BLACK
-25EF;A           # So         LARGE CIRCLE
-25F0..25F7;N     # So     [8] WHITE SQUARE WITH UPPER LEFT QUADRANT..WHITE CIRCLE WITH UPPER RIGHT QUADRANT
-25F8..25FC;N     # Sm     [5] UPPER LEFT TRIANGLE..BLACK MEDIUM SQUARE
-25FD..25FE;W     # Sm     [2] WHITE MEDIUM SMALL SQUARE..BLACK MEDIUM SMALL SQUARE
-25FF;N           # Sm         LOWER RIGHT TRIANGLE
-2600..2604;N     # So     [5] BLACK SUN WITH RAYS..COMET
-2605..2606;A     # So     [2] BLACK STAR..WHITE STAR
-2607..2608;N     # So     [2] LIGHTNING..THUNDERSTORM
-2609;A           # So         SUN
-260A..260D;N     # So     [4] ASCENDING NODE..OPPOSITION
-260E..260F;A     # So     [2] BLACK TELEPHONE..WHITE TELEPHONE
-2610..2613;N     # So     [4] BALLOT BOX..SALTIRE
-2614..2615;W     # So     [2] UMBRELLA WITH RAIN DROPS..HOT BEVERAGE
-2616..261B;N     # So     [6] WHITE SHOGI PIECE..BLACK RIGHT POINTING INDEX
-261C;A           # So         WHITE LEFT POINTING INDEX
-261D;N           # So         WHITE UP POINTING INDEX
-261E;A           # So         WHITE RIGHT POINTING INDEX
-261F..263F;N     # So    [33] WHITE DOWN POINTING INDEX..MERCURY
-2640;A           # So         FEMALE SIGN
-2641;N           # So         EARTH
-2642;A           # So         MALE SIGN
-2643..2647;N     # So     [5] JUPITER..PLUTO
-2648..2653;W     # So    [12] ARIES..PISCES
-2654..265F;N     # So    [12] WHITE CHESS KING..BLACK CHESS PAWN
-2660..2661;A     # So     [2] BLACK SPADE SUIT..WHITE HEART SUIT
-2662;N           # So         WHITE DIAMOND SUIT
-2663..2665;A     # So     [3] BLACK CLUB SUIT..BLACK HEART SUIT
-2666;N           # So         BLACK DIAMOND SUIT
-2667..266A;A     # So     [4] WHITE CLUB SUIT..EIGHTH NOTE
-266B;N           # So         BEAMED EIGHTH NOTES
-266C..266D;A     # So     [2] BEAMED SIXTEENTH NOTES..MUSIC FLAT SIGN
-266E;N           # So         MUSIC NATURAL SIGN
-266F;A           # Sm         MUSIC SHARP SIGN
-2670..267E;N     # So    [15] WEST SYRIAC CROSS..PERMANENT PAPER SIGN
-267F;W           # So         WHEELCHAIR SYMBOL
-2680..2692;N     # So    [19] DIE FACE-1..HAMMER AND PICK
-2693;W           # So         ANCHOR
-2694..269D;N     # So    [10] CROSSED SWORDS..OUTLINED WHITE STAR
-269E..269F;A     # So     [2] THREE LINES CONVERGING RIGHT..THREE LINES CONVERGING LEFT
-26A0;N           # So         WARNING SIGN
-26A1;W           # So         HIGH VOLTAGE SIGN
-26A2..26A9;N     # So     [8] DOUBLED FEMALE SIGN..HORIZONTAL MALE WITH STROKE SIGN
-26AA..26AB;W     # So     [2] MEDIUM WHITE CIRCLE..MEDIUM BLACK CIRCLE
-26AC..26BC;N     # So    [17] MEDIUM SMALL WHITE CIRCLE..SESQUIQUADRATE
-26BD..26BE;W     # So     [2] SOCCER BALL..BASEBALL
-26BF;A           # So         SQUARED KEY
-26C0..26C3;N     # So     [4] WHITE DRAUGHTS MAN..BLACK DRAUGHTS KING
-26C4..26C5;W     # So     [2] SNOWMAN WITHOUT SNOW..SUN BEHIND CLOUD
-26C6..26CD;A     # So     [8] RAIN..DISABLED CAR
-26CE;W           # So         OPHIUCHUS
-26CF..26D3;A     # So     [5] PICK..CHAINS
-26D4;W           # So         NO ENTRY
-26D5..26E1;A     # So    [13] ALTERNATE ONE-WAY LEFT WAY TRAFFIC..RESTRICTED LEFT ENTRY-2
-26E2;N           # So         ASTRONOMICAL SYMBOL FOR URANUS
-26E3;A           # So         HEAVY CIRCLE WITH STROKE AND TWO DOTS ABOVE
-26E4..26E7;N     # So     [4] PENTAGRAM..INVERTED PENTAGRAM
-26E8..26E9;A     # So     [2] BLACK CROSS ON SHIELD..SHINTO SHRINE
-26EA;W           # So         CHURCH
-26EB..26F1;A     # So     [7] CASTLE..UMBRELLA ON GROUND
-26F2..26F3;W     # So     [2] FOUNTAIN..FLAG IN HOLE
-26F4;A           # So         FERRY
-26F5;W           # So         SAILBOAT
-26F6..26F9;A     # So     [4] SQUARE FOUR CORNERS..PERSON WITH BALL
-26FA;W           # So         TENT
-26FB..26FC;A     # So     [2] JAPANESE BANK SYMBOL..HEADSTONE GRAVEYARD SYMBOL
-26FD;W           # So         FUEL PUMP
-26FE..26FF;A     # So     [2] CUP ON BLACK SQUARE..WHITE FLAG WITH HORIZONTAL MIDDLE BLACK STRIPE
-2700..2704;N     # So     [5] BLACK SAFETY SCISSORS..WHITE SCISSORS
-2705;W           # So         WHITE HEAVY CHECK MARK
-2706..2709;N     # So     [4] TELEPHONE LOCATION SIGN..ENVELOPE
-270A..270B;W     # So     [2] RAISED FIST..RAISED HAND
-270C..2727;N     # So    [28] VICTORY HAND..WHITE FOUR POINTED STAR
-2728;W           # So         SPARKLES
-2729..273C;N     # So    [20] STRESS OUTLINED WHITE STAR..OPEN CENTRE TEARDROP-SPOKED ASTERISK
-273D;A           # So         HEAVY TEARDROP-SPOKED ASTERISK
-273E..274B;N     # So    [14] SIX PETALLED BLACK AND WHITE FLORETTE..HEAVY EIGHT TEARDROP-SPOKED PROPELLER ASTERISK
-274C;W           # So         CROSS MARK
-274D;N           # So         SHADOWED WHITE CIRCLE
-274E;W           # So         NEGATIVE SQUARED CROSS MARK
-274F..2752;N     # So     [4] LOWER RIGHT DROP-SHADOWED WHITE SQUARE..UPPER RIGHT SHADOWED WHITE SQUARE
-2753..2755;W     # So     [3] BLACK QUESTION MARK ORNAMENT..WHITE EXCLAMATION MARK ORNAMENT
-2756;N           # So         BLACK DIAMOND MINUS WHITE X
-2757;W           # So         HEAVY EXCLAMATION MARK SYMBOL
-2758..2767;N     # So    [16] LIGHT VERTICAL BAR..ROTATED FLORAL HEART BULLET
-2768;N           # Ps         MEDIUM LEFT PARENTHESIS ORNAMENT
-2769;N           # Pe         MEDIUM RIGHT PARENTHESIS ORNAMENT
-276A;N           # Ps         MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT
-276B;N           # Pe         MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT
-276C;N           # Ps         MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT
-276D;N           # Pe         MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT
-276E;N           # Ps         HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT
-276F;N           # Pe         HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT
-2770;N           # Ps         HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT
-2771;N           # Pe         HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT
-2772;N           # Ps         LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT
-2773;N           # Pe         LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT
-2774;N           # Ps         MEDIUM LEFT CURLY BRACKET ORNAMENT
-2775;N           # Pe         MEDIUM RIGHT CURLY BRACKET ORNAMENT
-2776..277F;A     # No    [10] DINGBAT NEGATIVE CIRCLED DIGIT ONE..DINGBAT NEGATIVE CIRCLED NUMBER TEN
-2780..2793;N     # No    [20] DINGBAT CIRCLED SANS-SERIF DIGIT ONE..DINGBAT NEGATIVE CIRCLED SANS-SERIF NUMBER TEN
-2794;N           # So         HEAVY WIDE-HEADED RIGHTWARDS ARROW
-2795..2797;W     # So     [3] HEAVY PLUS SIGN..HEAVY DIVISION SIGN
-2798..27AF;N     # So    [24] HEAVY SOUTH EAST ARROW..NOTCHED LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW
-27B0;W           # So         CURLY LOOP
-27B1..27BE;N     # So    [14] NOTCHED UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW..OPEN-OUTLINED RIGHTWARDS ARROW
-27BF;W           # So         DOUBLE CURLY LOOP
-27C0..27C4;N     # Sm     [5] THREE DIMENSIONAL ANGLE..OPEN SUPERSET
-27C5;N           # Ps         LEFT S-SHAPED BAG DELIMITER
-27C6;N           # Pe         RIGHT S-SHAPED BAG DELIMITER
-27C7..27E5;N     # Sm    [31] OR WITH DOT INSIDE..WHITE SQUARE WITH RIGHTWARDS TICK
-27E6;Na          # Ps         MATHEMATICAL LEFT WHITE SQUARE BRACKET
-27E7;Na          # Pe         MATHEMATICAL RIGHT WHITE SQUARE BRACKET
-27E8;Na          # Ps         MATHEMATICAL LEFT ANGLE BRACKET
-27E9;Na          # Pe         MATHEMATICAL RIGHT ANGLE BRACKET
-27EA;Na          # Ps         MATHEMATICAL LEFT DOUBLE ANGLE BRACKET
-27EB;Na          # Pe         MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET
-27EC;Na          # Ps         MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET
-27ED;Na          # Pe         MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET
-27EE;N           # Ps         MATHEMATICAL LEFT FLATTENED PARENTHESIS
-27EF;N           # Pe         MATHEMATICAL RIGHT FLATTENED PARENTHESIS
-27F0..27FF;N     # Sm    [16] UPWARDS QUADRUPLE ARROW..LONG RIGHTWARDS SQUIGGLE ARROW
-2800..28FF;N     # So   [256] BRAILLE PATTERN BLANK..BRAILLE PATTERN DOTS-12345678
-2900..297F;N     # Sm   [128] RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE..DOWN FISH TAIL
-2980..2982;N     # Sm     [3] TRIPLE VERTICAL BAR DELIMITER..Z NOTATION TYPE COLON
-2983;N           # Ps         LEFT WHITE CURLY BRACKET
-2984;N           # Pe         RIGHT WHITE CURLY BRACKET
-2985;Na          # Ps         LEFT WHITE PARENTHESIS
-2986;Na          # Pe         RIGHT WHITE PARENTHESIS
-2987;N           # Ps         Z NOTATION LEFT IMAGE BRACKET
-2988;N           # Pe         Z NOTATION RIGHT IMAGE BRACKET
-2989;N           # Ps         Z NOTATION LEFT BINDING BRACKET
-298A;N           # Pe         Z NOTATION RIGHT BINDING BRACKET
-298B;N           # Ps         LEFT SQUARE BRACKET WITH UNDERBAR
-298C;N           # Pe         RIGHT SQUARE BRACKET WITH UNDERBAR
-298D;N           # Ps         LEFT SQUARE BRACKET WITH TICK IN TOP CORNER
-298E;N           # Pe         RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
-298F;N           # Ps         LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
-2990;N           # Pe         RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER
-2991;N           # Ps         LEFT ANGLE BRACKET WITH DOT
-2992;N           # Pe         RIGHT ANGLE BRACKET WITH DOT
-2993;N           # Ps         LEFT ARC LESS-THAN BRACKET
-2994;N           # Pe         RIGHT ARC GREATER-THAN BRACKET
-2995;N           # Ps         DOUBLE LEFT ARC GREATER-THAN BRACKET
-2996;N           # Pe         DOUBLE RIGHT ARC LESS-THAN BRACKET
-2997;N           # Ps         LEFT BLACK TORTOISE SHELL BRACKET
-2998;N           # Pe         RIGHT BLACK TORTOISE SHELL BRACKET
-2999..29D7;N     # Sm    [63] DOTTED FENCE..BLACK HOURGLASS
-29D8;N           # Ps         LEFT WIGGLY FENCE
-29D9;N           # Pe         RIGHT WIGGLY FENCE
-29DA;N           # Ps         LEFT DOUBLE WIGGLY FENCE
-29DB;N           # Pe         RIGHT DOUBLE WIGGLY FENCE
-29DC..29FB;N     # Sm    [32] INCOMPLETE INFINITY..TRIPLE PLUS
-29FC;N           # Ps         LEFT-POINTING CURVED ANGLE BRACKET
-29FD;N           # Pe         RIGHT-POINTING CURVED ANGLE BRACKET
-29FE..29FF;N     # Sm     [2] TINY..MINY
-2A00..2AFF;N     # Sm   [256] N-ARY CIRCLED DOT OPERATOR..N-ARY WHITE VERTICAL BAR
-2B00..2B1A;N     # So    [27] NORTH EAST WHITE ARROW..DOTTED SQUARE
-2B1B..2B1C;W     # So     [2] BLACK LARGE SQUARE..WHITE LARGE SQUARE
-2B1D..2B2F;N     # So    [19] BLACK VERY SMALL SQUARE..WHITE VERTICAL ELLIPSE
-2B30..2B44;N     # Sm    [21] LEFT ARROW WITH SMALL CIRCLE..RIGHTWARDS ARROW THROUGH SUPERSET
-2B45..2B46;N     # So     [2] LEFTWARDS QUADRUPLE ARROW..RIGHTWARDS QUADRUPLE ARROW
-2B47..2B4C;N     # Sm     [6] REVERSE TILDE OPERATOR ABOVE RIGHTWARDS ARROW..RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR
-2B4D..2B4F;N     # So     [3] DOWNWARDS TRIANGLE-HEADED ZIGZAG ARROW..SHORT BACKSLANTED SOUTH ARROW
-2B50;W           # So         WHITE MEDIUM STAR
-2B51..2B54;N     # So     [4] BLACK SMALL STAR..WHITE RIGHT-POINTING PENTAGON
-2B55;W           # So         HEAVY LARGE CIRCLE
-2B56..2B59;A     # So     [4] HEAVY OVAL WITH OVAL INSIDE..HEAVY CIRCLED SALTIRE
-2B5A..2B73;N     # So    [26] SLANTED NORTH ARROW WITH HOOKED HEAD..DOWNWARDS TRIANGLE-HEADED ARROW TO BAR
-2B76..2B95;N     # So    [32] NORTH WEST TRIANGLE-HEADED ARROW TO BAR..RIGHTWARDS BLACK ARROW
-2B97..2BFF;N     # So   [105] SYMBOL FOR TYPE A ELECTRONICS..HELLSCHREIBER PAUSE SYMBOL
-2C00..2C5F;N     # L&    [96] GLAGOLITIC CAPITAL LETTER AZU..GLAGOLITIC SMALL LETTER CAUDATE CHRIVI
-2C60..2C7B;N     # L&    [28] LATIN CAPITAL LETTER L WITH DOUBLE BAR..LATIN LETTER SMALL CAPITAL TURNED E
-2C7C..2C7D;N     # Lm     [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V
-2C7E..2C7F;N     # Lu     [2] LATIN CAPITAL LETTER S WITH SWASH TAIL..LATIN CAPITAL LETTER Z WITH SWASH TAIL
-2C80..2CE4;N     # L&   [101] COPTIC CAPITAL LETTER ALFA..COPTIC SYMBOL KAI
-2CE5..2CEA;N     # So     [6] COPTIC SYMBOL MI RO..COPTIC SYMBOL SHIMA SIMA
-2CEB..2CEE;N     # L&     [4] COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI..COPTIC SMALL LETTER CRYPTOGRAMMIC GANGIA
-2CEF..2CF1;N     # Mn     [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS
-2CF2..2CF3;N     # L&     [2] COPTIC CAPITAL LETTER BOHAIRIC KHEI..COPTIC SMALL LETTER BOHAIRIC KHEI
-2CF9..2CFC;N     # Po     [4] COPTIC OLD NUBIAN FULL STOP..COPTIC OLD NUBIAN VERSE DIVIDER
-2CFD;N           # No         COPTIC FRACTION ONE HALF
-2CFE..2CFF;N     # Po     [2] COPTIC FULL STOP..COPTIC MORPHOLOGICAL DIVIDER
-2D00..2D25;N     # Ll    [38] GEORGIAN SMALL LETTER AN..GEORGIAN SMALL LETTER HOE
-2D27;N           # Ll         GEORGIAN SMALL LETTER YN
-2D2D;N           # Ll         GEORGIAN SMALL LETTER AEN
-2D30..2D67;N     # Lo    [56] TIFINAGH LETTER YA..TIFINAGH LETTER YO
-2D6F;N           # Lm         TIFINAGH MODIFIER LETTER LABIALIZATION MARK
-2D70;N           # Po         TIFINAGH SEPARATOR MARK
-2D7F;N           # Mn         TIFINAGH CONSONANT JOINER
-2D80..2D96;N     # Lo    [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SYLLABLE GGWE
-2DA0..2DA6;N     # Lo     [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SYLLABLE SSO
-2DA8..2DAE;N     # Lo     [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SYLLABLE CCO
-2DB0..2DB6;N     # Lo     [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SYLLABLE ZZO
-2DB8..2DBE;N     # Lo     [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC SYLLABLE CCHO
-2DC0..2DC6;N     # Lo     [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SYLLABLE QYO
-2DC8..2DCE;N     # Lo     [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SYLLABLE KYO
-2DD0..2DD6;N     # Lo     [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SYLLABLE XYO
-2DD8..2DDE;N     # Lo     [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SYLLABLE GYO
-2DE0..2DFF;N     # Mn    [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS
-2E00..2E01;N     # Po     [2] RIGHT ANGLE SUBSTITUTION MARKER..RIGHT ANGLE DOTTED SUBSTITUTION MARKER
-2E02;N           # Pi         LEFT SUBSTITUTION BRACKET
-2E03;N           # Pf         RIGHT SUBSTITUTION BRACKET
-2E04;N           # Pi         LEFT DOTTED SUBSTITUTION BRACKET
-2E05;N           # Pf         RIGHT DOTTED SUBSTITUTION BRACKET
-2E06..2E08;N     # Po     [3] RAISED INTERPOLATION MARKER..DOTTED TRANSPOSITION MARKER
-2E09;N           # Pi         LEFT TRANSPOSITION BRACKET
-2E0A;N           # Pf         RIGHT TRANSPOSITION BRACKET
-2E0B;N           # Po         RAISED SQUARE
-2E0C;N           # Pi         LEFT RAISED OMISSION BRACKET
-2E0D;N           # Pf         RIGHT RAISED OMISSION BRACKET
-2E0E..2E16;N     # Po     [9] EDITORIAL CORONIS..DOTTED RIGHT-POINTING ANGLE
-2E17;N           # Pd         DOUBLE OBLIQUE HYPHEN
-2E18..2E19;N     # Po     [2] INVERTED INTERROBANG..PALM BRANCH
-2E1A;N           # Pd         HYPHEN WITH DIAERESIS
-2E1B;N           # Po         TILDE WITH RING ABOVE
-2E1C;N           # Pi         LEFT LOW PARAPHRASE BRACKET
-2E1D;N           # Pf         RIGHT LOW PARAPHRASE BRACKET
-2E1E..2E1F;N     # Po     [2] TILDE WITH DOT ABOVE..TILDE WITH DOT BELOW
-2E20;N           # Pi         LEFT VERTICAL BAR WITH QUILL
-2E21;N           # Pf         RIGHT VERTICAL BAR WITH QUILL
-2E22;N           # Ps         TOP LEFT HALF BRACKET
-2E23;N           # Pe         TOP RIGHT HALF BRACKET
-2E24;N           # Ps         BOTTOM LEFT HALF BRACKET
-2E25;N           # Pe         BOTTOM RIGHT HALF BRACKET
-2E26;N           # Ps         LEFT SIDEWAYS U BRACKET
-2E27;N           # Pe         RIGHT SIDEWAYS U BRACKET
-2E28;N           # Ps         LEFT DOUBLE PARENTHESIS
-2E29;N           # Pe         RIGHT DOUBLE PARENTHESIS
-2E2A..2E2E;N     # Po     [5] TWO DOTS OVER ONE DOT PUNCTUATION..REVERSED QUESTION MARK
-2E2F;N           # Lm         VERTICAL TILDE
-2E30..2E39;N     # Po    [10] RING POINT..TOP HALF SECTION SIGN
-2E3A..2E3B;N     # Pd     [2] TWO-EM DASH..THREE-EM DASH
-2E3C..2E3F;N     # Po     [4] STENOGRAPHIC FULL STOP..CAPITULUM
-2E40;N           # Pd         DOUBLE HYPHEN
-2E41;N           # Po         REVERSED COMMA
-2E42;N           # Ps         DOUBLE LOW-REVERSED-9 QUOTATION MARK
-2E43..2E4F;N     # Po    [13] DASH WITH LEFT UPTURN..CORNISH VERSE DIVIDER
-2E50..2E51;N     # So     [2] CROSS PATTY WITH RIGHT CROSSBAR..CROSS PATTY WITH LEFT CROSSBAR
-2E52..2E54;N     # Po     [3] TIRONIAN SIGN CAPITAL ET..MEDIEVAL QUESTION MARK
-2E55;N           # Ps         LEFT SQUARE BRACKET WITH STROKE
-2E56;N           # Pe         RIGHT SQUARE BRACKET WITH STROKE
-2E57;N           # Ps         LEFT SQUARE BRACKET WITH DOUBLE STROKE
-2E58;N           # Pe         RIGHT SQUARE BRACKET WITH DOUBLE STROKE
-2E59;N           # Ps         TOP HALF LEFT PARENTHESIS
-2E5A;N           # Pe         TOP HALF RIGHT PARENTHESIS
-2E5B;N           # Ps         BOTTOM HALF LEFT PARENTHESIS
-2E5C;N           # Pe         BOTTOM HALF RIGHT PARENTHESIS
-2E5D;N           # Pd         OBLIQUE HYPHEN
-2E80..2E99;W     # So    [26] CJK RADICAL REPEAT..CJK RADICAL RAP
-2E9B..2EF3;W     # So    [89] CJK RADICAL CHOKE..CJK RADICAL C-SIMPLIFIED TURTLE
-2F00..2FD5;W     # So   [214] KANGXI RADICAL ONE..KANGXI RADICAL FLUTE
-2FF0..2FFB;W     # So    [12] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER OVERLAID
-3000;F           # Zs         IDEOGRAPHIC SPACE
-3001..3003;W     # Po     [3] IDEOGRAPHIC COMMA..DITTO MARK
-3004;W           # So         JAPANESE INDUSTRIAL STANDARD SYMBOL
-3005;W           # Lm         IDEOGRAPHIC ITERATION MARK
-3006;W           # Lo         IDEOGRAPHIC CLOSING MARK
-3007;W           # Nl         IDEOGRAPHIC NUMBER ZERO
-3008;W           # Ps         LEFT ANGLE BRACKET
-3009;W           # Pe         RIGHT ANGLE BRACKET
-300A;W           # Ps         LEFT DOUBLE ANGLE BRACKET
-300B;W           # Pe         RIGHT DOUBLE ANGLE BRACKET
-300C;W           # Ps         LEFT CORNER BRACKET
-300D;W           # Pe         RIGHT CORNER BRACKET
-300E;W           # Ps         LEFT WHITE CORNER BRACKET
-300F;W           # Pe         RIGHT WHITE CORNER BRACKET
-3010;W           # Ps         LEFT BLACK LENTICULAR BRACKET
-3011;W           # Pe         RIGHT BLACK LENTICULAR BRACKET
-3012..3013;W     # So     [2] POSTAL MARK..GETA MARK
-3014;W           # Ps         LEFT TORTOISE SHELL BRACKET
-3015;W           # Pe         RIGHT TORTOISE SHELL BRACKET
-3016;W           # Ps         LEFT WHITE LENTICULAR BRACKET
-3017;W           # Pe         RIGHT WHITE LENTICULAR BRACKET
-3018;W           # Ps         LEFT WHITE TORTOISE SHELL BRACKET
-3019;W           # Pe         RIGHT WHITE TORTOISE SHELL BRACKET
-301A;W           # Ps         LEFT WHITE SQUARE BRACKET
-301B;W           # Pe         RIGHT WHITE SQUARE BRACKET
-301C;W           # Pd         WAVE DASH
-301D;W           # Ps         REVERSED DOUBLE PRIME QUOTATION MARK
-301E..301F;W     # Pe     [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK
-3020;W           # So         POSTAL MARK FACE
-3021..3029;W     # Nl     [9] HANGZHOU NUMERAL ONE..HANGZHOU NUMERAL NINE
-302A..302D;W     # Mn     [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK
-302E..302F;W     # Mc     [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK
-3030;W           # Pd         WAVY DASH
-3031..3035;W     # Lm     [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF
-3036..3037;W     # So     [2] CIRCLED POSTAL MARK..IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL
-3038..303A;W     # Nl     [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY
-303B;W           # Lm         VERTICAL IDEOGRAPHIC ITERATION MARK
-303C;W           # Lo         MASU MARK
-303D;W           # Po         PART ALTERNATION MARK
-303E;W           # So         IDEOGRAPHIC VARIATION INDICATOR
-303F;N           # So         IDEOGRAPHIC HALF FILL SPACE
-3041..3096;W     # Lo    [86] HIRAGANA LETTER SMALL A..HIRAGANA LETTER SMALL KE
-3099..309A;W     # Mn     [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
-309B..309C;W     # Sk     [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
-309D..309E;W     # Lm     [2] HIRAGANA ITERATION MARK..HIRAGANA VOICED ITERATION MARK
-309F;W           # Lo         HIRAGANA DIGRAPH YORI
-30A0;W           # Pd         KATAKANA-HIRAGANA DOUBLE HYPHEN
-30A1..30FA;W     # Lo    [90] KATAKANA LETTER SMALL A..KATAKANA LETTER VO
-30FB;W           # Po         KATAKANA MIDDLE DOT
-30FC..30FE;W     # Lm     [3] KATAKANA-HIRAGANA PROLONGED SOUND MARK..KATAKANA VOICED ITERATION MARK
-30FF;W           # Lo         KATAKANA DIGRAPH KOTO
-3105..312F;W     # Lo    [43] BOPOMOFO LETTER B..BOPOMOFO LETTER NN
-3131..318E;W     # Lo    [94] HANGUL LETTER KIYEOK..HANGUL LETTER ARAEAE
-3190..3191;W     # So     [2] IDEOGRAPHIC ANNOTATION LINKING MARK..IDEOGRAPHIC ANNOTATION REVERSE MARK
-3192..3195;W     # No     [4] IDEOGRAPHIC ANNOTATION ONE MARK..IDEOGRAPHIC ANNOTATION FOUR MARK
-3196..319F;W     # So    [10] IDEOGRAPHIC ANNOTATION TOP MARK..IDEOGRAPHIC ANNOTATION MAN MARK
-31A0..31BF;W     # Lo    [32] BOPOMOFO LETTER BU..BOPOMOFO LETTER AH
-31C0..31E3;W     # So    [36] CJK STROKE T..CJK STROKE Q
-31F0..31FF;W     # Lo    [16] KATAKANA LETTER SMALL KU..KATAKANA LETTER SMALL RO
-3200..321E;W     # So    [31] PARENTHESIZED HANGUL KIYEOK..PARENTHESIZED KOREAN CHARACTER O HU
-3220..3229;W     # No    [10] PARENTHESIZED IDEOGRAPH ONE..PARENTHESIZED IDEOGRAPH TEN
-322A..3247;W     # So    [30] PARENTHESIZED IDEOGRAPH MOON..CIRCLED IDEOGRAPH KOTO
-3248..324F;A     # No     [8] CIRCLED NUMBER TEN ON BLACK SQUARE..CIRCLED NUMBER EIGHTY ON BLACK SQUARE
-3250;W           # So         PARTNERSHIP SIGN
-3251..325F;W     # No    [15] CIRCLED NUMBER TWENTY ONE..CIRCLED NUMBER THIRTY FIVE
-3260..327F;W     # So    [32] CIRCLED HANGUL KIYEOK..KOREAN STANDARD SYMBOL
-3280..3289;W     # No    [10] CIRCLED IDEOGRAPH ONE..CIRCLED IDEOGRAPH TEN
-328A..32B0;W     # So    [39] CIRCLED IDEOGRAPH MOON..CIRCLED IDEOGRAPH NIGHT
-32B1..32BF;W     # No    [15] CIRCLED NUMBER THIRTY SIX..CIRCLED NUMBER FIFTY
-32C0..32FF;W     # So    [64] IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY..SQUARE ERA NAME REIWA
-3300..33FF;W     # So   [256] SQUARE APAATO..SQUARE GAL
-3400..4DBF;W     # Lo  [6592] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-4DBF
-4DC0..4DFF;N     # So    [64] HEXAGRAM FOR THE CREATIVE HEAVEN..HEXAGRAM FOR BEFORE COMPLETION
-4E00..9FFF;W     # Lo [20992] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-9FFF
-A000..A014;W     # Lo    [21] YI SYLLABLE IT..YI SYLLABLE E
-A015;W           # Lm         YI SYLLABLE WU
-A016..A48C;W     # Lo  [1143] YI SYLLABLE BIT..YI SYLLABLE YYR
-A490..A4C6;W     # So    [55] YI RADICAL QOT..YI RADICAL KE
-A4D0..A4F7;N     # Lo    [40] LISU LETTER BA..LISU LETTER OE
-A4F8..A4FD;N     # Lm     [6] LISU LETTER TONE MYA TI..LISU LETTER TONE MYA JEU
-A4FE..A4FF;N     # Po     [2] LISU PUNCTUATION COMMA..LISU PUNCTUATION FULL STOP
-A500..A60B;N     # Lo   [268] VAI SYLLABLE EE..VAI SYLLABLE NG
-A60C;N           # Lm         VAI SYLLABLE LENGTHENER
-A60D..A60F;N     # Po     [3] VAI COMMA..VAI QUESTION MARK
-A610..A61F;N     # Lo    [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL JONG
-A620..A629;N     # Nd    [10] VAI DIGIT ZERO..VAI DIGIT NINE
-A62A..A62B;N     # Lo     [2] VAI SYLLABLE NDOLE MA..VAI SYLLABLE NDOLE DO
-A640..A66D;N     # L&    [46] CYRILLIC CAPITAL LETTER ZEMLYA..CYRILLIC SMALL LETTER DOUBLE MONOCULAR O
-A66E;N           # Lo         CYRILLIC LETTER MULTIOCULAR O
-A66F;N           # Mn         COMBINING CYRILLIC VZMET
-A670..A672;N     # Me     [3] COMBINING CYRILLIC TEN MILLIONS SIGN..COMBINING CYRILLIC THOUSAND MILLIONS SIGN
-A673;N           # Po         SLAVONIC ASTERISK
-A674..A67D;N     # Mn    [10] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC PAYEROK
-A67E;N           # Po         CYRILLIC KAVYKA
-A67F;N           # Lm         CYRILLIC PAYEROK
-A680..A69B;N     # L&    [28] CYRILLIC CAPITAL LETTER DWE..CYRILLIC SMALL LETTER CROSSED O
-A69C..A69D;N     # Lm     [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN
-A69E..A69F;N     # Mn     [2] COMBINING CYRILLIC LETTER EF..COMBINING CYRILLIC LETTER IOTIFIED E
-A6A0..A6E5;N     # Lo    [70] BAMUM LETTER A..BAMUM LETTER KI
-A6E6..A6EF;N     # Nl    [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM
-A6F0..A6F1;N     # Mn     [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS
-A6F2..A6F7;N     # Po     [6] BAMUM NJAEMLI..BAMUM QUESTION MARK
-A700..A716;N     # Sk    [23] MODIFIER LETTER CHINESE TONE YIN PING..MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR
-A717..A71F;N     # Lm     [9] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK
-A720..A721;N     # Sk     [2] MODIFIER LETTER STRESS AND HIGH TONE..MODIFIER LETTER STRESS AND LOW TONE
-A722..A76F;N     # L&    [78] LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF..LATIN SMALL LETTER CON
-A770;N           # Lm         MODIFIER LETTER US
-A771..A787;N     # L&    [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER INSULAR T
-A788;N           # Lm         MODIFIER LETTER LOW CIRCUMFLEX ACCENT
-A789..A78A;N     # Sk     [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN
-A78B..A78E;N     # L&     [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT
-A78F;N           # Lo         LATIN LETTER SINOLOGICAL DOT
-A790..A7CA;N     # L&    [59] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN SMALL LETTER S WITH SHORT STROKE OVERLAY
-A7D0..A7D1;N     # L&     [2] LATIN CAPITAL LETTER CLOSED INSULAR G..LATIN SMALL LETTER CLOSED INSULAR G
-A7D3;N           # Ll         LATIN SMALL LETTER DOUBLE THORN
-A7D5..A7D9;N     # L&     [5] LATIN SMALL LETTER DOUBLE WYNN..LATIN SMALL LETTER SIGMOID S
-A7F2..A7F4;N     # Lm     [3] MODIFIER LETTER CAPITAL C..MODIFIER LETTER CAPITAL Q
-A7F5..A7F6;N     # L&     [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H
-A7F7;N           # Lo         LATIN EPIGRAPHIC LETTER SIDEWAYS I
-A7F8..A7F9;N     # Lm     [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE
-A7FA;N           # Ll         LATIN LETTER SMALL CAPITAL TURNED M
-A7FB..A7FF;N     # Lo     [5] LATIN EPIGRAPHIC LETTER REVERSED F..LATIN EPIGRAPHIC LETTER ARCHAIC M
-A800..A801;N     # Lo     [2] SYLOTI NAGRI LETTER A..SYLOTI NAGRI LETTER I
-A802;N           # Mn         SYLOTI NAGRI SIGN DVISVARA
-A803..A805;N     # Lo     [3] SYLOTI NAGRI LETTER U..SYLOTI NAGRI LETTER O
-A806;N           # Mn         SYLOTI NAGRI SIGN HASANTA
-A807..A80A;N     # Lo     [4] SYLOTI NAGRI LETTER KO..SYLOTI NAGRI LETTER GHO
-A80B;N           # Mn         SYLOTI NAGRI SIGN ANUSVARA
-A80C..A822;N     # Lo    [23] SYLOTI NAGRI LETTER CO..SYLOTI NAGRI LETTER HO
-A823..A824;N     # Mc     [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I
-A825..A826;N     # Mn     [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E
-A827;N           # Mc         SYLOTI NAGRI VOWEL SIGN OO
-A828..A82B;N     # So     [4] SYLOTI NAGRI POETRY MARK-1..SYLOTI NAGRI POETRY MARK-4
-A82C;N           # Mn         SYLOTI NAGRI SIGN ALTERNATE HASANTA
-A830..A835;N     # No     [6] NORTH INDIC FRACTION ONE QUARTER..NORTH INDIC FRACTION THREE SIXTEENTHS
-A836..A837;N     # So     [2] NORTH INDIC QUARTER MARK..NORTH INDIC PLACEHOLDER MARK
-A838;N           # Sc         NORTH INDIC RUPEE MARK
-A839;N           # So         NORTH INDIC QUANTITY MARK
-A840..A873;N     # Lo    [52] PHAGS-PA LETTER KA..PHAGS-PA LETTER CANDRABINDU
-A874..A877;N     # Po     [4] PHAGS-PA SINGLE HEAD MARK..PHAGS-PA MARK DOUBLE SHAD
-A880..A881;N     # Mc     [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA
-A882..A8B3;N     # Lo    [50] SAURASHTRA LETTER A..SAURASHTRA LETTER LLA
-A8B4..A8C3;N     # Mc    [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU
-A8C4..A8C5;N     # Mn     [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA SIGN CANDRABINDU
-A8CE..A8CF;N     # Po     [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA
-A8D0..A8D9;N     # Nd    [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE
-A8E0..A8F1;N     # Mn    [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA
-A8F2..A8F7;N     # Lo     [6] DEVANAGARI SIGN SPACING CANDRABINDU..DEVANAGARI SIGN CANDRABINDU AVAGRAHA
-A8F8..A8FA;N     # Po     [3] DEVANAGARI SIGN PUSHPIKA..DEVANAGARI CARET
-A8FB;N           # Lo         DEVANAGARI HEADSTROKE
-A8FC;N           # Po         DEVANAGARI SIGN SIDDHAM
-A8FD..A8FE;N     # Lo     [2] DEVANAGARI JAIN OM..DEVANAGARI LETTER AY
-A8FF;N           # Mn         DEVANAGARI VOWEL SIGN AY
-A900..A909;N     # Nd    [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGIT NINE
-A90A..A925;N     # Lo    [28] KAYAH LI LETTER KA..KAYAH LI LETTER OO
-A926..A92D;N     # Mn     [8] KAYAH LI VOWEL UE..KAYAH LI TONE CALYA PLOPHU
-A92E..A92F;N     # Po     [2] KAYAH LI SIGN CWI..KAYAH LI SIGN SHYA
-A930..A946;N     # Lo    [23] REJANG LETTER KA..REJANG LETTER A
-A947..A951;N     # Mn    [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R
-A952..A953;N     # Mc     [2] REJANG CONSONANT SIGN H..REJANG VIRAMA
-A95F;N           # Po         REJANG SECTION MARK
-A960..A97C;W     # Lo    [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH
-A980..A982;N     # Mn     [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR
-A983;N           # Mc         JAVANESE SIGN WIGNYAN
-A984..A9B2;N     # Lo    [47] JAVANESE LETTER A..JAVANESE LETTER HA
-A9B3;N           # Mn         JAVANESE SIGN CECAK TELU
-A9B4..A9B5;N     # Mc     [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG
-A9B6..A9B9;N     # Mn     [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT
-A9BA..A9BB;N     # Mc     [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE
-A9BC..A9BD;N     # Mn     [2] JAVANESE VOWEL SIGN PEPET..JAVANESE CONSONANT SIGN KERET
-A9BE..A9C0;N     # Mc     [3] JAVANESE CONSONANT SIGN PENGKAL..JAVANESE PANGKON
-A9C1..A9CD;N     # Po    [13] JAVANESE LEFT RERENGGAN..JAVANESE TURNED PADA PISELEH
-A9CF;N           # Lm         JAVANESE PANGRANGKEP
-A9D0..A9D9;N     # Nd    [10] JAVANESE DIGIT ZERO..JAVANESE DIGIT NINE
-A9DE..A9DF;N     # Po     [2] JAVANESE PADA TIRTA TUMETES..JAVANESE PADA ISEN-ISEN
-A9E0..A9E4;N     # Lo     [5] MYANMAR LETTER SHAN GHA..MYANMAR LETTER SHAN BHA
-A9E5;N           # Mn         MYANMAR SIGN SHAN SAW
-A9E6;N           # Lm         MYANMAR MODIFIER LETTER SHAN REDUPLICATION
-A9E7..A9EF;N     # Lo     [9] MYANMAR LETTER TAI LAING NYA..MYANMAR LETTER TAI LAING NNA
-A9F0..A9F9;N     # Nd    [10] MYANMAR TAI LAING DIGIT ZERO..MYANMAR TAI LAING DIGIT NINE
-A9FA..A9FE;N     # Lo     [5] MYANMAR LETTER TAI LAING LLA..MYANMAR LETTER TAI LAING BHA
-AA00..AA28;N     # Lo    [41] CHAM LETTER A..CHAM LETTER HA
-AA29..AA2E;N     # Mn     [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE
-AA2F..AA30;N     # Mc     [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI
-AA31..AA32;N     # Mn     [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE
-AA33..AA34;N     # Mc     [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA
-AA35..AA36;N     # Mn     [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA
-AA40..AA42;N     # Lo     [3] CHAM LETTER FINAL K..CHAM LETTER FINAL NG
-AA43;N           # Mn         CHAM CONSONANT SIGN FINAL NG
-AA44..AA4B;N     # Lo     [8] CHAM LETTER FINAL CH..CHAM LETTER FINAL SS
-AA4C;N           # Mn         CHAM CONSONANT SIGN FINAL M
-AA4D;N           # Mc         CHAM CONSONANT SIGN FINAL H
-AA50..AA59;N     # Nd    [10] CHAM DIGIT ZERO..CHAM DIGIT NINE
-AA5C..AA5F;N     # Po     [4] CHAM PUNCTUATION SPIRAL..CHAM PUNCTUATION TRIPLE DANDA
-AA60..AA6F;N     # Lo    [16] MYANMAR LETTER KHAMTI GA..MYANMAR LETTER KHAMTI FA
-AA70;N           # Lm         MYANMAR MODIFIER LETTER KHAMTI REDUPLICATION
-AA71..AA76;N     # Lo     [6] MYANMAR LETTER KHAMTI XA..MYANMAR LOGOGRAM KHAMTI HM
-AA77..AA79;N     # So     [3] MYANMAR SYMBOL AITON EXCLAMATION..MYANMAR SYMBOL AITON TWO
-AA7A;N           # Lo         MYANMAR LETTER AITON RA
-AA7B;N           # Mc         MYANMAR SIGN PAO KAREN TONE
-AA7C;N           # Mn         MYANMAR SIGN TAI LAING TONE-2
-AA7D;N           # Mc         MYANMAR SIGN TAI LAING TONE-5
-AA7E..AA7F;N     # Lo     [2] MYANMAR LETTER SHWE PALAUNG CHA..MYANMAR LETTER SHWE PALAUNG SHA
-AA80..AAAF;N     # Lo    [48] TAI VIET LETTER LOW KO..TAI VIET LETTER HIGH O
-AAB0;N           # Mn         TAI VIET MAI KANG
-AAB1;N           # Lo         TAI VIET VOWEL AA
-AAB2..AAB4;N     # Mn     [3] TAI VIET VOWEL I..TAI VIET VOWEL U
-AAB5..AAB6;N     # Lo     [2] TAI VIET VOWEL E..TAI VIET VOWEL O
-AAB7..AAB8;N     # Mn     [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA
-AAB9..AABD;N     # Lo     [5] TAI VIET VOWEL UEA..TAI VIET VOWEL AN
-AABE..AABF;N     # Mn     [2] TAI VIET VOWEL AM..TAI VIET TONE MAI EK
-AAC0;N           # Lo         TAI VIET TONE MAI NUENG
-AAC1;N           # Mn         TAI VIET TONE MAI THO
-AAC2;N           # Lo         TAI VIET TONE MAI SONG
-AADB..AADC;N     # Lo     [2] TAI VIET SYMBOL KON..TAI VIET SYMBOL NUENG
-AADD;N           # Lm         TAI VIET SYMBOL SAM
-AADE..AADF;N     # Po     [2] TAI VIET SYMBOL HO HOI..TAI VIET SYMBOL KOI KOI
-AAE0..AAEA;N     # Lo    [11] MEETEI MAYEK LETTER E..MEETEI MAYEK LETTER SSA
-AAEB;N           # Mc         MEETEI MAYEK VOWEL SIGN II
-AAEC..AAED;N     # Mn     [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI
-AAEE..AAEF;N     # Mc     [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU
-AAF0..AAF1;N     # Po     [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM
-AAF2;N           # Lo         MEETEI MAYEK ANJI
-AAF3..AAF4;N     # Lm     [2] MEETEI MAYEK SYLLABLE REPETITION MARK..MEETEI MAYEK WORD REPETITION MARK
-AAF5;N           # Mc         MEETEI MAYEK VOWEL SIGN VISARGA
-AAF6;N           # Mn         MEETEI MAYEK VIRAMA
-AB01..AB06;N     # Lo     [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC SYLLABLE TTHO
-AB09..AB0E;N     # Lo     [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC SYLLABLE DDHO
-AB11..AB16;N     # Lo     [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SYLLABLE DZO
-AB20..AB26;N     # Lo     [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC SYLLABLE CCHHO
-AB28..AB2E;N     # Lo     [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SYLLABLE BBO
-AB30..AB5A;N     # Ll    [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LETTER Y WITH SHORT RIGHT LEG
-AB5B;N           # Sk         MODIFIER BREVE WITH INVERTED BREVE
-AB5C..AB5F;N     # Lm     [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK
-AB60..AB68;N     # Ll     [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE
-AB69;N           # Lm         MODIFIER LETTER SMALL TURNED W
-AB6A..AB6B;N     # Sk     [2] MODIFIER LETTER LEFT TACK..MODIFIER LETTER RIGHT TACK
-AB70..ABBF;N     # Ll    [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA
-ABC0..ABE2;N     # Lo    [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM
-ABE3..ABE4;N     # Mc     [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP
-ABE5;N           # Mn         MEETEI MAYEK VOWEL SIGN ANAP
-ABE6..ABE7;N     # Mc     [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP
-ABE8;N           # Mn         MEETEI MAYEK VOWEL SIGN UNAP
-ABE9..ABEA;N     # Mc     [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG
-ABEB;N           # Po         MEETEI MAYEK CHEIKHEI
-ABEC;N           # Mc         MEETEI MAYEK LUM IYEK
-ABED;N           # Mn         MEETEI MAYEK APUN IYEK
-ABF0..ABF9;N     # Nd    [10] MEETEI MAYEK DIGIT ZERO..MEETEI MAYEK DIGIT NINE
-AC00..D7A3;W     # Lo [11172] HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH
-D7B0..D7C6;N     # Lo    [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E
-D7CB..D7FB;N     # Lo    [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH
-D800..DB7F;N     # Cs   [896] <surrogate-D800>..<surrogate-DB7F>
-DB80..DBFF;N     # Cs   [128] <surrogate-DB80>..<surrogate-DBFF>
-DC00..DFFF;N     # Cs  [1024] <surrogate-DC00>..<surrogate-DFFF>
-E000..F8FF;A     # Co  [6400] <private-use-E000>..<private-use-F8FF>
-F900..FA6D;W     # Lo   [366] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA6D
-FA6E..FA6F;W     # Cn     [2] <reserved-FA6E>..<reserved-FA6F>
-FA70..FAD9;W     # Lo   [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9
-FADA..FAFF;W     # Cn    [38] <reserved-FADA>..<reserved-FAFF>
-FB00..FB06;N     # Ll     [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST
-FB13..FB17;N     # Ll     [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH
-FB1D;N           # Lo         HEBREW LETTER YOD WITH HIRIQ
-FB1E;N           # Mn         HEBREW POINT JUDEO-SPANISH VARIKA
-FB1F..FB28;N     # Lo    [10] HEBREW LIGATURE YIDDISH YOD YOD PATAH..HEBREW LETTER WIDE TAV
-FB29;N           # Sm         HEBREW LETTER ALTERNATIVE PLUS SIGN
-FB2A..FB36;N     # Lo    [13] HEBREW LETTER SHIN WITH SHIN DOT..HEBREW LETTER ZAYIN WITH DAGESH
-FB38..FB3C;N     # Lo     [5] HEBREW LETTER TET WITH DAGESH..HEBREW LETTER LAMED WITH DAGESH
-FB3E;N           # Lo         HEBREW LETTER MEM WITH DAGESH
-FB40..FB41;N     # Lo     [2] HEBREW LETTER NUN WITH DAGESH..HEBREW LETTER SAMEKH WITH DAGESH
-FB43..FB44;N     # Lo     [2] HEBREW LETTER FINAL PE WITH DAGESH..HEBREW LETTER PE WITH DAGESH
-FB46..FB4F;N     # Lo    [10] HEBREW LETTER TSADI WITH DAGESH..HEBREW LIGATURE ALEF LAMED
-FB50..FBB1;N     # Lo    [98] ARABIC LETTER ALEF WASLA ISOLATED FORM..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM
-FBB2..FBC2;N     # Sk    [17] ARABIC SYMBOL DOT ABOVE..ARABIC SYMBOL WASLA ABOVE
-FBD3..FD3D;N     # Lo   [363] ARABIC LETTER NG ISOLATED FORM..ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM
-FD3E;N           # Pe         ORNATE LEFT PARENTHESIS
-FD3F;N           # Ps         ORNATE RIGHT PARENTHESIS
-FD40..FD4F;N     # So    [16] ARABIC LIGATURE RAHIMAHU ALLAAH..ARABIC LIGATURE RAHIMAHUM ALLAAH
-FD50..FD8F;N     # Lo    [64] ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM..ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM
-FD92..FDC7;N     # Lo    [54] ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM..ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM
-FDCF;N           # So         ARABIC LIGATURE SALAAMUHU ALAYNAA
-FDF0..FDFB;N     # Lo    [12] ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM..ARABIC LIGATURE JALLAJALALOUHOU
-FDFC;N           # Sc         RIAL SIGN
-FDFD..FDFF;N     # So     [3] ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM..ARABIC LIGATURE AZZA WA JALL
-FE00..FE0F;A     # Mn    [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16
-FE10..FE16;W     # Po     [7] PRESENTATION FORM FOR VERTICAL COMMA..PRESENTATION FORM FOR VERTICAL QUESTION MARK
-FE17;W           # Ps         PRESENTATION FORM FOR VERTICAL LEFT WHITE LENTICULAR BRACKET
-FE18;W           # Pe         PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET
-FE19;W           # Po         PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS
-FE20..FE2F;N     # Mn    [16] COMBINING LIGATURE LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF
-FE30;W           # Po         PRESENTATION FORM FOR VERTICAL TWO DOT LEADER
-FE31..FE32;W     # Pd     [2] PRESENTATION FORM FOR VERTICAL EM DASH..PRESENTATION FORM FOR VERTICAL EN DASH
-FE33..FE34;W     # Pc     [2] PRESENTATION FORM FOR VERTICAL LOW LINE..PRESENTATION FORM FOR VERTICAL WAVY LOW LINE
-FE35;W           # Ps         PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS
-FE36;W           # Pe         PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS
-FE37;W           # Ps         PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET
-FE38;W           # Pe         PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET
-FE39;W           # Ps         PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET
-FE3A;W           # Pe         PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET
-FE3B;W           # Ps         PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET
-FE3C;W           # Pe         PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET
-FE3D;W           # Ps         PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET
-FE3E;W           # Pe         PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET
-FE3F;W           # Ps         PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET
-FE40;W           # Pe         PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET
-FE41;W           # Ps         PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET
-FE42;W           # Pe         PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET
-FE43;W           # Ps         PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET
-FE44;W           # Pe         PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET
-FE45..FE46;W     # Po     [2] SESAME DOT..WHITE SESAME DOT
-FE47;W           # Ps         PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET
-FE48;W           # Pe         PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET
-FE49..FE4C;W     # Po     [4] DASHED OVERLINE..DOUBLE WAVY OVERLINE
-FE4D..FE4F;W     # Pc     [3] DASHED LOW LINE..WAVY LOW LINE
-FE50..FE52;W     # Po     [3] SMALL COMMA..SMALL FULL STOP
-FE54..FE57;W     # Po     [4] SMALL SEMICOLON..SMALL EXCLAMATION MARK
-FE58;W           # Pd         SMALL EM DASH
-FE59;W           # Ps         SMALL LEFT PARENTHESIS
-FE5A;W           # Pe         SMALL RIGHT PARENTHESIS
-FE5B;W           # Ps         SMALL LEFT CURLY BRACKET
-FE5C;W           # Pe         SMALL RIGHT CURLY BRACKET
-FE5D;W           # Ps         SMALL LEFT TORTOISE SHELL BRACKET
-FE5E;W           # Pe         SMALL RIGHT TORTOISE SHELL BRACKET
-FE5F..FE61;W     # Po     [3] SMALL NUMBER SIGN..SMALL ASTERISK
-FE62;W           # Sm         SMALL PLUS SIGN
-FE63;W           # Pd         SMALL HYPHEN-MINUS
-FE64..FE66;W     # Sm     [3] SMALL LESS-THAN SIGN..SMALL EQUALS SIGN
-FE68;W           # Po         SMALL REVERSE SOLIDUS
-FE69;W           # Sc         SMALL DOLLAR SIGN
-FE6A..FE6B;W     # Po     [2] SMALL PERCENT SIGN..SMALL COMMERCIAL AT
-FE70..FE74;N     # Lo     [5] ARABIC FATHATAN ISOLATED FORM..ARABIC KASRATAN ISOLATED FORM
-FE76..FEFC;N     # Lo   [135] ARABIC FATHA ISOLATED FORM..ARABIC LIGATURE LAM WITH ALEF FINAL FORM
-FEFF;N           # Cf         ZERO WIDTH NO-BREAK SPACE
-FF01..FF03;F     # Po     [3] FULLWIDTH EXCLAMATION MARK..FULLWIDTH NUMBER SIGN
-FF04;F           # Sc         FULLWIDTH DOLLAR SIGN
-FF05..FF07;F     # Po     [3] FULLWIDTH PERCENT SIGN..FULLWIDTH APOSTROPHE
-FF08;F           # Ps         FULLWIDTH LEFT PARENTHESIS
-FF09;F           # Pe         FULLWIDTH RIGHT PARENTHESIS
-FF0A;F           # Po         FULLWIDTH ASTERISK
-FF0B;F           # Sm         FULLWIDTH PLUS SIGN
-FF0C;F           # Po         FULLWIDTH COMMA
-FF0D;F           # Pd         FULLWIDTH HYPHEN-MINUS
-FF0E..FF0F;F     # Po     [2] FULLWIDTH FULL STOP..FULLWIDTH SOLIDUS
-FF10..FF19;F     # Nd    [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE
-FF1A..FF1B;F     # Po     [2] FULLWIDTH COLON..FULLWIDTH SEMICOLON
-FF1C..FF1E;F     # Sm     [3] FULLWIDTH LESS-THAN SIGN..FULLWIDTH GREATER-THAN SIGN
-FF1F..FF20;F     # Po     [2] FULLWIDTH QUESTION MARK..FULLWIDTH COMMERCIAL AT
-FF21..FF3A;F     # Lu    [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER Z
-FF3B;F           # Ps         FULLWIDTH LEFT SQUARE BRACKET
-FF3C;F           # Po         FULLWIDTH REVERSE SOLIDUS
-FF3D;F           # Pe         FULLWIDTH RIGHT SQUARE BRACKET
-FF3E;F           # Sk         FULLWIDTH CIRCUMFLEX ACCENT
-FF3F;F           # Pc         FULLWIDTH LOW LINE
-FF40;F           # Sk         FULLWIDTH GRAVE ACCENT
-FF41..FF5A;F     # Ll    [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN SMALL LETTER Z
-FF5B;F           # Ps         FULLWIDTH LEFT CURLY BRACKET
-FF5C;F           # Sm         FULLWIDTH VERTICAL LINE
-FF5D;F           # Pe         FULLWIDTH RIGHT CURLY BRACKET
-FF5E;F           # Sm         FULLWIDTH TILDE
-FF5F;F           # Ps         FULLWIDTH LEFT WHITE PARENTHESIS
-FF60;F           # Pe         FULLWIDTH RIGHT WHITE PARENTHESIS
-FF61;H           # Po         HALFWIDTH IDEOGRAPHIC FULL STOP
-FF62;H           # Ps         HALFWIDTH LEFT CORNER BRACKET
-FF63;H           # Pe         HALFWIDTH RIGHT CORNER BRACKET
-FF64..FF65;H     # Po     [2] HALFWIDTH IDEOGRAPHIC COMMA..HALFWIDTH KATAKANA MIDDLE DOT
-FF66..FF6F;H     # Lo    [10] HALFWIDTH KATAKANA LETTER WO..HALFWIDTH KATAKANA LETTER SMALL TU
-FF70;H           # Lm         HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK
-FF71..FF9D;H     # Lo    [45] HALFWIDTH KATAKANA LETTER A..HALFWIDTH KATAKANA LETTER N
-FF9E..FF9F;H     # Lm     [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
-FFA0..FFBE;H     # Lo    [31] HALFWIDTH HANGUL FILLER..HALFWIDTH HANGUL LETTER HIEUH
-FFC2..FFC7;H     # Lo     [6] HALFWIDTH HANGUL LETTER A..HALFWIDTH HANGUL LETTER E
-FFCA..FFCF;H     # Lo     [6] HALFWIDTH HANGUL LETTER YEO..HALFWIDTH HANGUL LETTER OE
-FFD2..FFD7;H     # Lo     [6] HALFWIDTH HANGUL LETTER YO..HALFWIDTH HANGUL LETTER YU
-FFDA..FFDC;H     # Lo     [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL LETTER I
-FFE0..FFE1;F     # Sc     [2] FULLWIDTH CENT SIGN..FULLWIDTH POUND SIGN
-FFE2;F           # Sm         FULLWIDTH NOT SIGN
-FFE3;F           # Sk         FULLWIDTH MACRON
-FFE4;F           # So         FULLWIDTH BROKEN BAR
-FFE5..FFE6;F     # Sc     [2] FULLWIDTH YEN SIGN..FULLWIDTH WON SIGN
-FFE8;H           # So         HALFWIDTH FORMS LIGHT VERTICAL
-FFE9..FFEC;H     # Sm     [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS ARROW
-FFED..FFEE;H     # So     [2] HALFWIDTH BLACK SQUARE..HALFWIDTH WHITE CIRCLE
-FFF9..FFFB;N     # Cf     [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR
-FFFC;N           # So         OBJECT REPLACEMENT CHARACTER
-FFFD;A           # So         REPLACEMENT CHARACTER
-10000..1000B;N   # Lo    [12] LINEAR B SYLLABLE B008 A..LINEAR B SYLLABLE B046 JE
-1000D..10026;N   # Lo    [26] LINEAR B SYLLABLE B036 JO..LINEAR B SYLLABLE B032 QO
-10028..1003A;N   # Lo    [19] LINEAR B SYLLABLE B060 RA..LINEAR B SYLLABLE B042 WO
-1003C..1003D;N   # Lo     [2] LINEAR B SYLLABLE B017 ZA..LINEAR B SYLLABLE B074 ZE
-1003F..1004D;N   # Lo    [15] LINEAR B SYLLABLE B020 ZO..LINEAR B SYLLABLE B091 TWO
-10050..1005D;N   # Lo    [14] LINEAR B SYMBOL B018..LINEAR B SYMBOL B089
-10080..100FA;N   # Lo   [123] LINEAR B IDEOGRAM B100 MAN..LINEAR B IDEOGRAM VESSEL B305
-10100..10102;N   # Po     [3] AEGEAN WORD SEPARATOR LINE..AEGEAN CHECK MARK
-10107..10133;N   # No    [45] AEGEAN NUMBER ONE..AEGEAN NUMBER NINETY THOUSAND
-10137..1013F;N   # So     [9] AEGEAN WEIGHT BASE UNIT..AEGEAN MEASURE THIRD SUBUNIT
-10140..10174;N   # Nl    [53] GREEK ACROPHONIC ATTIC ONE QUARTER..GREEK ACROPHONIC STRATIAN FIFTY MNAS
-10175..10178;N   # No     [4] GREEK ONE HALF SIGN..GREEK THREE QUARTERS SIGN
-10179..10189;N   # So    [17] GREEK YEAR SIGN..GREEK TRYBLION BASE SIGN
-1018A..1018B;N   # No     [2] GREEK ZERO SIGN..GREEK ONE QUARTER SIGN
-1018C..1018E;N   # So     [3] GREEK SINUSOID SIGN..NOMISMA SIGN
-10190..1019C;N   # So    [13] ROMAN SEXTANS SIGN..ASCIA SYMBOL
-101A0;N          # So         GREEK SYMBOL TAU RHO
-101D0..101FC;N   # So    [45] PHAISTOS DISC SIGN PEDESTRIAN..PHAISTOS DISC SIGN WAVY BAND
-101FD;N          # Mn         PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE
-10280..1029C;N   # Lo    [29] LYCIAN LETTER A..LYCIAN LETTER X
-102A0..102D0;N   # Lo    [49] CARIAN LETTER A..CARIAN LETTER UUU3
-102E0;N          # Mn         COPTIC EPACT THOUSANDS MARK
-102E1..102FB;N   # No    [27] COPTIC EPACT DIGIT ONE..COPTIC EPACT NUMBER NINE HUNDRED
-10300..1031F;N   # Lo    [32] OLD ITALIC LETTER A..OLD ITALIC LETTER ESS
-10320..10323;N   # No     [4] OLD ITALIC NUMERAL ONE..OLD ITALIC NUMERAL FIFTY
-1032D..1032F;N   # Lo     [3] OLD ITALIC LETTER YE..OLD ITALIC LETTER SOUTHERN TSE
-10330..10340;N   # Lo    [17] GOTHIC LETTER AHSA..GOTHIC LETTER PAIRTHRA
-10341;N          # Nl         GOTHIC LETTER NINETY
-10342..10349;N   # Lo     [8] GOTHIC LETTER RAIDA..GOTHIC LETTER OTHAL
-1034A;N          # Nl         GOTHIC LETTER NINE HUNDRED
-10350..10375;N   # Lo    [38] OLD PERMIC LETTER AN..OLD PERMIC LETTER IA
-10376..1037A;N   # Mn     [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII
-10380..1039D;N   # Lo    [30] UGARITIC LETTER ALPA..UGARITIC LETTER SSU
-1039F;N          # Po         UGARITIC WORD DIVIDER
-103A0..103C3;N   # Lo    [36] OLD PERSIAN SIGN A..OLD PERSIAN SIGN HA
-103C8..103CF;N   # Lo     [8] OLD PERSIAN SIGN AURAMAZDAA..OLD PERSIAN SIGN BUUMISH
-103D0;N          # Po         OLD PERSIAN WORD DIVIDER
-103D1..103D5;N   # Nl     [5] OLD PERSIAN NUMBER ONE..OLD PERSIAN NUMBER HUNDRED
-10400..1044F;N   # L&    [80] DESERET CAPITAL LETTER LONG I..DESERET SMALL LETTER EW
-10450..1047F;N   # Lo    [48] SHAVIAN LETTER PEEP..SHAVIAN LETTER YEW
-10480..1049D;N   # Lo    [30] OSMANYA LETTER ALEF..OSMANYA LETTER OO
-104A0..104A9;N   # Nd    [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE
-104B0..104D3;N   # Lu    [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA
-104D8..104FB;N   # Ll    [36] OSAGE SMALL LETTER A..OSAGE SMALL LETTER ZHA
-10500..10527;N   # Lo    [40] ELBASAN LETTER A..ELBASAN LETTER KHE
-10530..10563;N   # Lo    [52] CAUCASIAN ALBANIAN LETTER ALT..CAUCASIAN ALBANIAN LETTER KIW
-1056F;N          # Po         CAUCASIAN ALBANIAN CITATION MARK
-10570..1057A;N   # Lu    [11] VITHKUQI CAPITAL LETTER A..VITHKUQI CAPITAL LETTER GA
-1057C..1058A;N   # Lu    [15] VITHKUQI CAPITAL LETTER HA..VITHKUQI CAPITAL LETTER RE
-1058C..10592;N   # Lu     [7] VITHKUQI CAPITAL LETTER SE..VITHKUQI CAPITAL LETTER XE
-10594..10595;N   # Lu     [2] VITHKUQI CAPITAL LETTER Y..VITHKUQI CAPITAL LETTER ZE
-10597..105A1;N   # Ll    [11] VITHKUQI SMALL LETTER A..VITHKUQI SMALL LETTER GA
-105A3..105B1;N   # Ll    [15] VITHKUQI SMALL LETTER HA..VITHKUQI SMALL LETTER RE
-105B3..105B9;N   # Ll     [7] VITHKUQI SMALL LETTER SE..VITHKUQI SMALL LETTER XE
-105BB..105BC;N   # Ll     [2] VITHKUQI SMALL LETTER Y..VITHKUQI SMALL LETTER ZE
-10600..10736;N   # Lo   [311] LINEAR A SIGN AB001..LINEAR A SIGN A664
-10740..10755;N   # Lo    [22] LINEAR A SIGN A701 A..LINEAR A SIGN A732 JE
-10760..10767;N   # Lo     [8] LINEAR A SIGN A800..LINEAR A SIGN A807
-10780..10785;N   # Lm     [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK
-10787..107B0;N   # Lm    [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK
-107B2..107BA;N   # Lm     [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL
-10800..10805;N   # Lo     [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA
-10808;N          # Lo         CYPRIOT SYLLABLE JO
-1080A..10835;N   # Lo    [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO
-10837..10838;N   # Lo     [2] CYPRIOT SYLLABLE XA..CYPRIOT SYLLABLE XE
-1083C;N          # Lo         CYPRIOT SYLLABLE ZA
-1083F;N          # Lo         CYPRIOT SYLLABLE ZO
-10840..10855;N   # Lo    [22] IMPERIAL ARAMAIC LETTER ALEPH..IMPERIAL ARAMAIC LETTER TAW
-10857;N          # Po         IMPERIAL ARAMAIC SECTION SIGN
-10858..1085F;N   # No     [8] IMPERIAL ARAMAIC NUMBER ONE..IMPERIAL ARAMAIC NUMBER TEN THOUSAND
-10860..10876;N   # Lo    [23] PALMYRENE LETTER ALEPH..PALMYRENE LETTER TAW
-10877..10878;N   # So     [2] PALMYRENE LEFT-POINTING FLEURON..PALMYRENE RIGHT-POINTING FLEURON
-10879..1087F;N   # No     [7] PALMYRENE NUMBER ONE..PALMYRENE NUMBER TWENTY
-10880..1089E;N   # Lo    [31] NABATAEAN LETTER FINAL ALEPH..NABATAEAN LETTER TAW
-108A7..108AF;N   # No     [9] NABATAEAN NUMBER ONE..NABATAEAN NUMBER ONE HUNDRED
-108E0..108F2;N   # Lo    [19] HATRAN LETTER ALEPH..HATRAN LETTER QOPH
-108F4..108F5;N   # Lo     [2] HATRAN LETTER SHIN..HATRAN LETTER TAW
-108FB..108FF;N   # No     [5] HATRAN NUMBER ONE..HATRAN NUMBER ONE HUNDRED
-10900..10915;N   # Lo    [22] PHOENICIAN LETTER ALF..PHOENICIAN LETTER TAU
-10916..1091B;N   # No     [6] PHOENICIAN NUMBER ONE..PHOENICIAN NUMBER THREE
-1091F;N          # Po         PHOENICIAN WORD SEPARATOR
-10920..10939;N   # Lo    [26] LYDIAN LETTER A..LYDIAN LETTER C
-1093F;N          # Po         LYDIAN TRIANGULAR MARK
-10980..1099F;N   # Lo    [32] MEROITIC HIEROGLYPHIC LETTER A..MEROITIC HIEROGLYPHIC SYMBOL VIDJ-2
-109A0..109B7;N   # Lo    [24] MEROITIC CURSIVE LETTER A..MEROITIC CURSIVE LETTER DA
-109BC..109BD;N   # No     [2] MEROITIC CURSIVE FRACTION ELEVEN TWELFTHS..MEROITIC CURSIVE FRACTION ONE HALF
-109BE..109BF;N   # Lo     [2] MEROITIC CURSIVE LOGOGRAM RMT..MEROITIC CURSIVE LOGOGRAM IMN
-109C0..109CF;N   # No    [16] MEROITIC CURSIVE NUMBER ONE..MEROITIC CURSIVE NUMBER SEVENTY
-109D2..109FF;N   # No    [46] MEROITIC CURSIVE NUMBER ONE HUNDRED..MEROITIC CURSIVE FRACTION TEN TWELFTHS
-10A00;N          # Lo         KHAROSHTHI LETTER A
-10A01..10A03;N   # Mn     [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R
-10A05..10A06;N   # Mn     [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O
-10A0C..10A0F;N   # Mn     [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA
-10A10..10A13;N   # Lo     [4] KHAROSHTHI LETTER KA..KHAROSHTHI LETTER GHA
-10A15..10A17;N   # Lo     [3] KHAROSHTHI LETTER CA..KHAROSHTHI LETTER JA
-10A19..10A35;N   # Lo    [29] KHAROSHTHI LETTER NYA..KHAROSHTHI LETTER VHA
-10A38..10A3A;N   # Mn     [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW
-10A3F;N          # Mn         KHAROSHTHI VIRAMA
-10A40..10A48;N   # No     [9] KHAROSHTHI DIGIT ONE..KHAROSHTHI FRACTION ONE HALF
-10A50..10A58;N   # Po     [9] KHAROSHTHI PUNCTUATION DOT..KHAROSHTHI PUNCTUATION LINES
-10A60..10A7C;N   # Lo    [29] OLD SOUTH ARABIAN LETTER HE..OLD SOUTH ARABIAN LETTER THETH
-10A7D..10A7E;N   # No     [2] OLD SOUTH ARABIAN NUMBER ONE..OLD SOUTH ARABIAN NUMBER FIFTY
-10A7F;N          # Po         OLD SOUTH ARABIAN NUMERIC INDICATOR
-10A80..10A9C;N   # Lo    [29] OLD NORTH ARABIAN LETTER HEH..OLD NORTH ARABIAN LETTER ZAH
-10A9D..10A9F;N   # No     [3] OLD NORTH ARABIAN NUMBER ONE..OLD NORTH ARABIAN NUMBER TWENTY
-10AC0..10AC7;N   # Lo     [8] MANICHAEAN LETTER ALEPH..MANICHAEAN LETTER WAW
-10AC8;N          # So         MANICHAEAN SIGN UD
-10AC9..10AE4;N   # Lo    [28] MANICHAEAN LETTER ZAYIN..MANICHAEAN LETTER TAW
-10AE5..10AE6;N   # Mn     [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW
-10AEB..10AEF;N   # No     [5] MANICHAEAN NUMBER ONE..MANICHAEAN NUMBER ONE HUNDRED
-10AF0..10AF6;N   # Po     [7] MANICHAEAN PUNCTUATION STAR..MANICHAEAN PUNCTUATION LINE FILLER
-10B00..10B35;N   # Lo    [54] AVESTAN LETTER A..AVESTAN LETTER HE
-10B39..10B3F;N   # Po     [7] AVESTAN ABBREVIATION MARK..LARGE ONE RING OVER TWO RINGS PUNCTUATION
-10B40..10B55;N   # Lo    [22] INSCRIPTIONAL PARTHIAN LETTER ALEPH..INSCRIPTIONAL PARTHIAN LETTER TAW
-10B58..10B5F;N   # No     [8] INSCRIPTIONAL PARTHIAN NUMBER ONE..INSCRIPTIONAL PARTHIAN NUMBER ONE THOUSAND
-10B60..10B72;N   # Lo    [19] INSCRIPTIONAL PAHLAVI LETTER ALEPH..INSCRIPTIONAL PAHLAVI LETTER TAW
-10B78..10B7F;N   # No     [8] INSCRIPTIONAL PAHLAVI NUMBER ONE..INSCRIPTIONAL PAHLAVI NUMBER ONE THOUSAND
-10B80..10B91;N   # Lo    [18] PSALTER PAHLAVI LETTER ALEPH..PSALTER PAHLAVI LETTER TAW
-10B99..10B9C;N   # Po     [4] PSALTER PAHLAVI SECTION MARK..PSALTER PAHLAVI FOUR DOTS WITH DOT
-10BA9..10BAF;N   # No     [7] PSALTER PAHLAVI NUMBER ONE..PSALTER PAHLAVI NUMBER ONE HUNDRED
-10C00..10C48;N   # Lo    [73] OLD TURKIC LETTER ORKHON A..OLD TURKIC LETTER ORKHON BASH
-10C80..10CB2;N   # Lu    [51] OLD HUNGARIAN CAPITAL LETTER A..OLD HUNGARIAN CAPITAL LETTER US
-10CC0..10CF2;N   # Ll    [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US
-10CFA..10CFF;N   # No     [6] OLD HUNGARIAN NUMBER ONE..OLD HUNGARIAN NUMBER ONE THOUSAND
-10D00..10D23;N   # Lo    [36] HANIFI ROHINGYA LETTER A..HANIFI ROHINGYA MARK NA KHONNA
-10D24..10D27;N   # Mn     [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI
-10D30..10D39;N   # Nd    [10] HANIFI ROHINGYA DIGIT ZERO..HANIFI ROHINGYA DIGIT NINE
-10E60..10E7E;N   # No    [31] RUMI DIGIT ONE..RUMI FRACTION TWO THIRDS
-10E80..10EA9;N   # Lo    [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET
-10EAB..10EAC;N   # Mn     [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK
-10EAD;N          # Pd         YEZIDI HYPHENATION MARK
-10EB0..10EB1;N   # Lo     [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE
-10EFD..10EFF;N   # Mn     [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA
-10F00..10F1C;N   # Lo    [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL
-10F1D..10F26;N   # No    [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF
-10F27;N          # Lo         OLD SOGDIAN LIGATURE AYIN-DALETH
-10F30..10F45;N   # Lo    [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN
-10F46..10F50;N   # Mn    [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW
-10F51..10F54;N   # No     [4] SOGDIAN NUMBER ONE..SOGDIAN NUMBER ONE HUNDRED
-10F55..10F59;N   # Po     [5] SOGDIAN PUNCTUATION TWO VERTICAL BARS..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT
-10F70..10F81;N   # Lo    [18] OLD UYGHUR LETTER ALEPH..OLD UYGHUR LETTER LESH
-10F82..10F85;N   # Mn     [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW
-10F86..10F89;N   # Po     [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS
-10FB0..10FC4;N   # Lo    [21] CHORASMIAN LETTER ALEPH..CHORASMIAN LETTER TAW
-10FC5..10FCB;N   # No     [7] CHORASMIAN NUMBER ONE..CHORASMIAN NUMBER ONE HUNDRED
-10FE0..10FF6;N   # Lo    [23] ELYMAIC LETTER ALEPH..ELYMAIC LIGATURE ZAYIN-YODH
-11000;N          # Mc         BRAHMI SIGN CANDRABINDU
-11001;N          # Mn         BRAHMI SIGN ANUSVARA
-11002;N          # Mc         BRAHMI SIGN VISARGA
-11003..11037;N   # Lo    [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI LETTER OLD TAMIL NNNA
-11038..11046;N   # Mn    [15] BRAHMI VOWEL SIGN AA..BRAHMI VIRAMA
-11047..1104D;N   # Po     [7] BRAHMI DANDA..BRAHMI PUNCTUATION LOTUS
-11052..11065;N   # No    [20] BRAHMI NUMBER ONE..BRAHMI NUMBER ONE THOUSAND
-11066..1106F;N   # Nd    [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT NINE
-11070;N          # Mn         BRAHMI SIGN OLD TAMIL VIRAMA
-11071..11072;N   # Lo     [2] BRAHMI LETTER OLD TAMIL SHORT E..BRAHMI LETTER OLD TAMIL SHORT O
-11073..11074;N   # Mn     [2] BRAHMI VOWEL SIGN OLD TAMIL SHORT E..BRAHMI VOWEL SIGN OLD TAMIL SHORT O
-11075;N          # Lo         BRAHMI LETTER OLD TAMIL LLA
-1107F;N          # Mn         BRAHMI NUMBER JOINER
-11080..11081;N   # Mn     [2] KAITHI SIGN CANDRABINDU..KAITHI SIGN ANUSVARA
-11082;N          # Mc         KAITHI SIGN VISARGA
-11083..110AF;N   # Lo    [45] KAITHI LETTER A..KAITHI LETTER HA
-110B0..110B2;N   # Mc     [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II
-110B3..110B6;N   # Mn     [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI
-110B7..110B8;N   # Mc     [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU
-110B9..110BA;N   # Mn     [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA
-110BB..110BC;N   # Po     [2] KAITHI ABBREVIATION SIGN..KAITHI ENUMERATION SIGN
-110BD;N          # Cf         KAITHI NUMBER SIGN
-110BE..110C1;N   # Po     [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA
-110C2;N          # Mn         KAITHI VOWEL SIGN VOCALIC R
-110CD;N          # Cf         KAITHI NUMBER SIGN ABOVE
-110D0..110E8;N   # Lo    [25] SORA SOMPENG LETTER SAH..SORA SOMPENG LETTER MAE
-110F0..110F9;N   # Nd    [10] SORA SOMPENG DIGIT ZERO..SORA SOMPENG DIGIT NINE
-11100..11102;N   # Mn     [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA
-11103..11126;N   # Lo    [36] CHAKMA LETTER AA..CHAKMA LETTER HAA
-11127..1112B;N   # Mn     [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU
-1112C;N          # Mc         CHAKMA VOWEL SIGN E
-1112D..11134;N   # Mn     [8] CHAKMA VOWEL SIGN AI..CHAKMA MAAYYAA
-11136..1113F;N   # Nd    [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT NINE
-11140..11143;N   # Po     [4] CHAKMA SECTION MARK..CHAKMA QUESTION MARK
-11144;N          # Lo         CHAKMA LETTER LHAA
-11145..11146;N   # Mc     [2] CHAKMA VOWEL SIGN AA..CHAKMA VOWEL SIGN EI
-11147;N          # Lo         CHAKMA LETTER VAA
-11150..11172;N   # Lo    [35] MAHAJANI LETTER A..MAHAJANI LETTER RRA
-11173;N          # Mn         MAHAJANI SIGN NUKTA
-11174..11175;N   # Po     [2] MAHAJANI ABBREVIATION SIGN..MAHAJANI SECTION MARK
-11176;N          # Lo         MAHAJANI LIGATURE SHRI
-11180..11181;N   # Mn     [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA
-11182;N          # Mc         SHARADA SIGN VISARGA
-11183..111B2;N   # Lo    [48] SHARADA LETTER A..SHARADA LETTER HA
-111B3..111B5;N   # Mc     [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II
-111B6..111BE;N   # Mn     [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O
-111BF..111C0;N   # Mc     [2] SHARADA VOWEL SIGN AU..SHARADA SIGN VIRAMA
-111C1..111C4;N   # Lo     [4] SHARADA SIGN AVAGRAHA..SHARADA OM
-111C5..111C8;N   # Po     [4] SHARADA DANDA..SHARADA SEPARATOR
-111C9..111CC;N   # Mn     [4] SHARADA SANDHI MARK..SHARADA EXTRA SHORT VOWEL MARK
-111CD;N          # Po         SHARADA SUTRA MARK
-111CE;N          # Mc         SHARADA VOWEL SIGN PRISHTHAMATRA E
-111CF;N          # Mn         SHARADA SIGN INVERTED CANDRABINDU
-111D0..111D9;N   # Nd    [10] SHARADA DIGIT ZERO..SHARADA DIGIT NINE
-111DA;N          # Lo         SHARADA EKAM
-111DB;N          # Po         SHARADA SIGN SIDDHAM
-111DC;N          # Lo         SHARADA HEADSTROKE
-111DD..111DF;N   # Po     [3] SHARADA CONTINUATION SIGN..SHARADA SECTION MARK-2
-111E1..111F4;N   # No    [20] SINHALA ARCHAIC DIGIT ONE..SINHALA ARCHAIC NUMBER ONE THOUSAND
-11200..11211;N   # Lo    [18] KHOJKI LETTER A..KHOJKI LETTER JJA
-11213..1122B;N   # Lo    [25] KHOJKI LETTER NYA..KHOJKI LETTER LLA
-1122C..1122E;N   # Mc     [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II
-1122F..11231;N   # Mn     [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI
-11232..11233;N   # Mc     [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU
-11234;N          # Mn         KHOJKI SIGN ANUSVARA
-11235;N          # Mc         KHOJKI SIGN VIRAMA
-11236..11237;N   # Mn     [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA
-11238..1123D;N   # Po     [6] KHOJKI DANDA..KHOJKI ABBREVIATION SIGN
-1123E;N          # Mn         KHOJKI SIGN SUKUN
-1123F..11240;N   # Lo     [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I
-11241;N          # Mn         KHOJKI VOWEL SIGN VOCALIC R
-11280..11286;N   # Lo     [7] MULTANI LETTER A..MULTANI LETTER GA
-11288;N          # Lo         MULTANI LETTER GHA
-1128A..1128D;N   # Lo     [4] MULTANI LETTER CA..MULTANI LETTER JJA
-1128F..1129D;N   # Lo    [15] MULTANI LETTER NYA..MULTANI LETTER BA
-1129F..112A8;N   # Lo    [10] MULTANI LETTER BHA..MULTANI LETTER RHA
-112A9;N          # Po         MULTANI SECTION MARK
-112B0..112DE;N   # Lo    [47] KHUDAWADI LETTER A..KHUDAWADI LETTER HA
-112DF;N          # Mn         KHUDAWADI SIGN ANUSVARA
-112E0..112E2;N   # Mc     [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II
-112E3..112EA;N   # Mn     [8] KHUDAWADI VOWEL SIGN U..KHUDAWADI SIGN VIRAMA
-112F0..112F9;N   # Nd    [10] KHUDAWADI DIGIT ZERO..KHUDAWADI DIGIT NINE
-11300..11301;N   # Mn     [2] GRANTHA SIGN COMBINING ANUSVARA ABOVE..GRANTHA SIGN CANDRABINDU
-11302..11303;N   # Mc     [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA
-11305..1130C;N   # Lo     [8] GRANTHA LETTER A..GRANTHA LETTER VOCALIC L
-1130F..11310;N   # Lo     [2] GRANTHA LETTER EE..GRANTHA LETTER AI
-11313..11328;N   # Lo    [22] GRANTHA LETTER OO..GRANTHA LETTER NA
-1132A..11330;N   # Lo     [7] GRANTHA LETTER PA..GRANTHA LETTER RA
-11332..11333;N   # Lo     [2] GRANTHA LETTER LA..GRANTHA LETTER LLA
-11335..11339;N   # Lo     [5] GRANTHA LETTER VA..GRANTHA LETTER HA
-1133B..1133C;N   # Mn     [2] COMBINING BINDU BELOW..GRANTHA SIGN NUKTA
-1133D;N          # Lo         GRANTHA SIGN AVAGRAHA
-1133E..1133F;N   # Mc     [2] GRANTHA VOWEL SIGN AA..GRANTHA VOWEL SIGN I
-11340;N          # Mn         GRANTHA VOWEL SIGN II
-11341..11344;N   # Mc     [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR
-11347..11348;N   # Mc     [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI
-1134B..1134D;N   # Mc     [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA
-11350;N          # Lo         GRANTHA OM
-11357;N          # Mc         GRANTHA AU LENGTH MARK
-1135D..11361;N   # Lo     [5] GRANTHA SIGN PLUTA..GRANTHA LETTER VOCALIC LL
-11362..11363;N   # Mc     [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL
-11366..1136C;N   # Mn     [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX
-11370..11374;N   # Mn     [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA
-11400..11434;N   # Lo    [53] NEWA LETTER A..NEWA LETTER HA
-11435..11437;N   # Mc     [3] NEWA VOWEL SIGN AA..NEWA VOWEL SIGN II
-11438..1143F;N   # Mn     [8] NEWA VOWEL SIGN U..NEWA VOWEL SIGN AI
-11440..11441;N   # Mc     [2] NEWA VOWEL SIGN O..NEWA VOWEL SIGN AU
-11442..11444;N   # Mn     [3] NEWA SIGN VIRAMA..NEWA SIGN ANUSVARA
-11445;N          # Mc         NEWA SIGN VISARGA
-11446;N          # Mn         NEWA SIGN NUKTA
-11447..1144A;N   # Lo     [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI
-1144B..1144F;N   # Po     [5] NEWA DANDA..NEWA ABBREVIATION SIGN
-11450..11459;N   # Nd    [10] NEWA DIGIT ZERO..NEWA DIGIT NINE
-1145A..1145B;N   # Po     [2] NEWA DOUBLE COMMA..NEWA PLACEHOLDER MARK
-1145D;N          # Po         NEWA INSERTION SIGN
-1145E;N          # Mn         NEWA SANDHI MARK
-1145F..11461;N   # Lo     [3] NEWA LETTER VEDIC ANUSVARA..NEWA SIGN UPADHMANIYA
-11480..114AF;N   # Lo    [48] TIRHUTA ANJI..TIRHUTA LETTER HA
-114B0..114B2;N   # Mc     [3] TIRHUTA VOWEL SIGN AA..TIRHUTA VOWEL SIGN II
-114B3..114B8;N   # Mn     [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL
-114B9;N          # Mc         TIRHUTA VOWEL SIGN E
-114BA;N          # Mn         TIRHUTA VOWEL SIGN SHORT E
-114BB..114BE;N   # Mc     [4] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN AU
-114BF..114C0;N   # Mn     [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA
-114C1;N          # Mc         TIRHUTA SIGN VISARGA
-114C2..114C3;N   # Mn     [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA
-114C4..114C5;N   # Lo     [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA GVANG
-114C6;N          # Po         TIRHUTA ABBREVIATION SIGN
-114C7;N          # Lo         TIRHUTA OM
-114D0..114D9;N   # Nd    [10] TIRHUTA DIGIT ZERO..TIRHUTA DIGIT NINE
-11580..115AE;N   # Lo    [47] SIDDHAM LETTER A..SIDDHAM LETTER HA
-115AF..115B1;N   # Mc     [3] SIDDHAM VOWEL SIGN AA..SIDDHAM VOWEL SIGN II
-115B2..115B5;N   # Mn     [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR
-115B8..115BB;N   # Mc     [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU
-115BC..115BD;N   # Mn     [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA
-115BE;N          # Mc         SIDDHAM SIGN VISARGA
-115BF..115C0;N   # Mn     [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA
-115C1..115D7;N   # Po    [23] SIDDHAM SIGN SIDDHAM..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES
-115D8..115DB;N   # Lo     [4] SIDDHAM LETTER THREE-CIRCLE ALTERNATE I..SIDDHAM LETTER ALTERNATE U
-115DC..115DD;N   # Mn     [2] SIDDHAM VOWEL SIGN ALTERNATE U..SIDDHAM VOWEL SIGN ALTERNATE UU
-11600..1162F;N   # Lo    [48] MODI LETTER A..MODI LETTER LLA
-11630..11632;N   # Mc     [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II
-11633..1163A;N   # Mn     [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI
-1163B..1163C;N   # Mc     [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU
-1163D;N          # Mn         MODI SIGN ANUSVARA
-1163E;N          # Mc         MODI SIGN VISARGA
-1163F..11640;N   # Mn     [2] MODI SIGN VIRAMA..MODI SIGN ARDHACANDRA
-11641..11643;N   # Po     [3] MODI DANDA..MODI ABBREVIATION SIGN
-11644;N          # Lo         MODI SIGN HUVA
-11650..11659;N   # Nd    [10] MODI DIGIT ZERO..MODI DIGIT NINE
-11660..1166C;N   # Po    [13] MONGOLIAN BIRGA WITH ORNAMENT..MONGOLIAN TURNED SWIRL BIRGA WITH DOUBLE ORNAMENT
-11680..116AA;N   # Lo    [43] TAKRI LETTER A..TAKRI LETTER RRA
-116AB;N          # Mn         TAKRI SIGN ANUSVARA
-116AC;N          # Mc         TAKRI SIGN VISARGA
-116AD;N          # Mn         TAKRI VOWEL SIGN AA
-116AE..116AF;N   # Mc     [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II
-116B0..116B5;N   # Mn     [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU
-116B6;N          # Mc         TAKRI SIGN VIRAMA
-116B7;N          # Mn         TAKRI SIGN NUKTA
-116B8;N          # Lo         TAKRI LETTER ARCHAIC KHA
-116B9;N          # Po         TAKRI ABBREVIATION SIGN
-116C0..116C9;N   # Nd    [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE
-11700..1171A;N   # Lo    [27] AHOM LETTER KA..AHOM LETTER ALTERNATE BA
-1171D..1171F;N   # Mn     [3] AHOM CONSONANT SIGN MEDIAL LA..AHOM CONSONANT SIGN MEDIAL LIGATING RA
-11720..11721;N   # Mc     [2] AHOM VOWEL SIGN A..AHOM VOWEL SIGN AA
-11722..11725;N   # Mn     [4] AHOM VOWEL SIGN I..AHOM VOWEL SIGN UU
-11726;N          # Mc         AHOM VOWEL SIGN E
-11727..1172B;N   # Mn     [5] AHOM VOWEL SIGN AW..AHOM SIGN KILLER
-11730..11739;N   # Nd    [10] AHOM DIGIT ZERO..AHOM DIGIT NINE
-1173A..1173B;N   # No     [2] AHOM NUMBER TEN..AHOM NUMBER TWENTY
-1173C..1173E;N   # Po     [3] AHOM SIGN SMALL SECTION..AHOM SIGN RULAI
-1173F;N          # So         AHOM SYMBOL VI
-11740..11746;N   # Lo     [7] AHOM LETTER CA..AHOM LETTER LLA
-11800..1182B;N   # Lo    [44] DOGRA LETTER A..DOGRA LETTER RRA
-1182C..1182E;N   # Mc     [3] DOGRA VOWEL SIGN AA..DOGRA VOWEL SIGN II
-1182F..11837;N   # Mn     [9] DOGRA VOWEL SIGN U..DOGRA SIGN ANUSVARA
-11838;N          # Mc         DOGRA SIGN VISARGA
-11839..1183A;N   # Mn     [2] DOGRA SIGN VIRAMA..DOGRA SIGN NUKTA
-1183B;N          # Po         DOGRA ABBREVIATION SIGN
-118A0..118DF;N   # L&    [64] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI SMALL LETTER VIYO
-118E0..118E9;N   # Nd    [10] WARANG CITI DIGIT ZERO..WARANG CITI DIGIT NINE
-118EA..118F2;N   # No     [9] WARANG CITI NUMBER TEN..WARANG CITI NUMBER NINETY
-118FF;N          # Lo         WARANG CITI OM
-11900..11906;N   # Lo     [7] DIVES AKURU LETTER A..DIVES AKURU LETTER E
-11909;N          # Lo         DIVES AKURU LETTER O
-1190C..11913;N   # Lo     [8] DIVES AKURU LETTER KA..DIVES AKURU LETTER JA
-11915..11916;N   # Lo     [2] DIVES AKURU LETTER NYA..DIVES AKURU LETTER TTA
-11918..1192F;N   # Lo    [24] DIVES AKURU LETTER DDA..DIVES AKURU LETTER ZA
-11930..11935;N   # Mc     [6] DIVES AKURU VOWEL SIGN AA..DIVES AKURU VOWEL SIGN E
-11937..11938;N   # Mc     [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O
-1193B..1193C;N   # Mn     [2] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN CANDRABINDU
-1193D;N          # Mc         DIVES AKURU SIGN HALANTA
-1193E;N          # Mn         DIVES AKURU VIRAMA
-1193F;N          # Lo         DIVES AKURU PREFIXED NASAL SIGN
-11940;N          # Mc         DIVES AKURU MEDIAL YA
-11941;N          # Lo         DIVES AKURU INITIAL RA
-11942;N          # Mc         DIVES AKURU MEDIAL RA
-11943;N          # Mn         DIVES AKURU SIGN NUKTA
-11944..11946;N   # Po     [3] DIVES AKURU DOUBLE DANDA..DIVES AKURU END OF TEXT MARK
-11950..11959;N   # Nd    [10] DIVES AKURU DIGIT ZERO..DIVES AKURU DIGIT NINE
-119A0..119A7;N   # Lo     [8] NANDINAGARI LETTER A..NANDINAGARI LETTER VOCALIC RR
-119AA..119D0;N   # Lo    [39] NANDINAGARI LETTER E..NANDINAGARI LETTER RRA
-119D1..119D3;N   # Mc     [3] NANDINAGARI VOWEL SIGN AA..NANDINAGARI VOWEL SIGN II
-119D4..119D7;N   # Mn     [4] NANDINAGARI VOWEL SIGN U..NANDINAGARI VOWEL SIGN VOCALIC RR
-119DA..119DB;N   # Mn     [2] NANDINAGARI VOWEL SIGN E..NANDINAGARI VOWEL SIGN AI
-119DC..119DF;N   # Mc     [4] NANDINAGARI VOWEL SIGN O..NANDINAGARI SIGN VISARGA
-119E0;N          # Mn         NANDINAGARI SIGN VIRAMA
-119E1;N          # Lo         NANDINAGARI SIGN AVAGRAHA
-119E2;N          # Po         NANDINAGARI SIGN SIDDHAM
-119E3;N          # Lo         NANDINAGARI HEADSTROKE
-119E4;N          # Mc         NANDINAGARI VOWEL SIGN PRISHTHAMATRA E
-11A00;N          # Lo         ZANABAZAR SQUARE LETTER A
-11A01..11A0A;N   # Mn    [10] ZANABAZAR SQUARE VOWEL SIGN I..ZANABAZAR SQUARE VOWEL LENGTH MARK
-11A0B..11A32;N   # Lo    [40] ZANABAZAR SQUARE LETTER KA..ZANABAZAR SQUARE LETTER KSSA
-11A33..11A38;N   # Mn     [6] ZANABAZAR SQUARE FINAL CONSONANT MARK..ZANABAZAR SQUARE SIGN ANUSVARA
-11A39;N          # Mc         ZANABAZAR SQUARE SIGN VISARGA
-11A3A;N          # Lo         ZANABAZAR SQUARE CLUSTER-INITIAL LETTER RA
-11A3B..11A3E;N   # Mn     [4] ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA
-11A3F..11A46;N   # Po     [8] ZANABAZAR SQUARE INITIAL HEAD MARK..ZANABAZAR SQUARE CLOSING DOUBLE-LINED HEAD MARK
-11A47;N          # Mn         ZANABAZAR SQUARE SUBJOINER
-11A50;N          # Lo         SOYOMBO LETTER A
-11A51..11A56;N   # Mn     [6] SOYOMBO VOWEL SIGN I..SOYOMBO VOWEL SIGN OE
-11A57..11A58;N   # Mc     [2] SOYOMBO VOWEL SIGN AI..SOYOMBO VOWEL SIGN AU
-11A59..11A5B;N   # Mn     [3] SOYOMBO VOWEL SIGN VOCALIC R..SOYOMBO VOWEL LENGTH MARK
-11A5C..11A89;N   # Lo    [46] SOYOMBO LETTER KA..SOYOMBO CLUSTER-INITIAL LETTER SA
-11A8A..11A96;N   # Mn    [13] SOYOMBO FINAL CONSONANT SIGN G..SOYOMBO SIGN ANUSVARA
-11A97;N          # Mc         SOYOMBO SIGN VISARGA
-11A98..11A99;N   # Mn     [2] SOYOMBO GEMINATION MARK..SOYOMBO SUBJOINER
-11A9A..11A9C;N   # Po     [3] SOYOMBO MARK TSHEG..SOYOMBO MARK DOUBLE SHAD
-11A9D;N          # Lo         SOYOMBO MARK PLUTA
-11A9E..11AA2;N   # Po     [5] SOYOMBO HEAD MARK WITH MOON AND SUN AND TRIPLE FLAME..SOYOMBO TERMINAL MARK-2
-11AB0..11ABF;N   # Lo    [16] CANADIAN SYLLABICS NATTILIK HI..CANADIAN SYLLABICS SPA
-11AC0..11AF8;N   # Lo    [57] PAU CIN HAU LETTER PA..PAU CIN HAU GLOTTAL STOP FINAL
-11B00..11B09;N   # Po    [10] DEVANAGARI HEAD MARK..DEVANAGARI SIGN MINDU
-11C00..11C08;N   # Lo     [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L
-11C0A..11C2E;N   # Lo    [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA
-11C2F;N          # Mc         BHAIKSUKI VOWEL SIGN AA
-11C30..11C36;N   # Mn     [7] BHAIKSUKI VOWEL SIGN I..BHAIKSUKI VOWEL SIGN VOCALIC L
-11C38..11C3D;N   # Mn     [6] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN ANUSVARA
-11C3E;N          # Mc         BHAIKSUKI SIGN VISARGA
-11C3F;N          # Mn         BHAIKSUKI SIGN VIRAMA
-11C40;N          # Lo         BHAIKSUKI SIGN AVAGRAHA
-11C41..11C45;N   # Po     [5] BHAIKSUKI DANDA..BHAIKSUKI GAP FILLER-2
-11C50..11C59;N   # Nd    [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI DIGIT NINE
-11C5A..11C6C;N   # No    [19] BHAIKSUKI NUMBER ONE..BHAIKSUKI HUNDREDS UNIT MARK
-11C70..11C71;N   # Po     [2] MARCHEN HEAD MARK..MARCHEN MARK SHAD
-11C72..11C8F;N   # Lo    [30] MARCHEN LETTER KA..MARCHEN LETTER A
-11C92..11CA7;N   # Mn    [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA
-11CA9;N          # Mc         MARCHEN SUBJOINED LETTER YA
-11CAA..11CB0;N   # Mn     [7] MARCHEN SUBJOINED LETTER RA..MARCHEN VOWEL SIGN AA
-11CB1;N          # Mc         MARCHEN VOWEL SIGN I
-11CB2..11CB3;N   # Mn     [2] MARCHEN VOWEL SIGN U..MARCHEN VOWEL SIGN E
-11CB4;N          # Mc         MARCHEN VOWEL SIGN O
-11CB5..11CB6;N   # Mn     [2] MARCHEN SIGN ANUSVARA..MARCHEN SIGN CANDRABINDU
-11D00..11D06;N   # Lo     [7] MASARAM GONDI LETTER A..MASARAM GONDI LETTER E
-11D08..11D09;N   # Lo     [2] MASARAM GONDI LETTER AI..MASARAM GONDI LETTER O
-11D0B..11D30;N   # Lo    [38] MASARAM GONDI LETTER AU..MASARAM GONDI LETTER TRA
-11D31..11D36;N   # Mn     [6] MASARAM GONDI VOWEL SIGN AA..MASARAM GONDI VOWEL SIGN VOCALIC R
-11D3A;N          # Mn         MASARAM GONDI VOWEL SIGN E
-11D3C..11D3D;N   # Mn     [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O
-11D3F..11D45;N   # Mn     [7] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI VIRAMA
-11D46;N          # Lo         MASARAM GONDI REPHA
-11D47;N          # Mn         MASARAM GONDI RA-KARA
-11D50..11D59;N   # Nd    [10] MASARAM GONDI DIGIT ZERO..MASARAM GONDI DIGIT NINE
-11D60..11D65;N   # Lo     [6] GUNJALA GONDI LETTER A..GUNJALA GONDI LETTER UU
-11D67..11D68;N   # Lo     [2] GUNJALA GONDI LETTER EE..GUNJALA GONDI LETTER AI
-11D6A..11D89;N   # Lo    [32] GUNJALA GONDI LETTER OO..GUNJALA GONDI LETTER SA
-11D8A..11D8E;N   # Mc     [5] GUNJALA GONDI VOWEL SIGN AA..GUNJALA GONDI VOWEL SIGN UU
-11D90..11D91;N   # Mn     [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI
-11D93..11D94;N   # Mc     [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU
-11D95;N          # Mn         GUNJALA GONDI SIGN ANUSVARA
-11D96;N          # Mc         GUNJALA GONDI SIGN VISARGA
-11D97;N          # Mn         GUNJALA GONDI VIRAMA
-11D98;N          # Lo         GUNJALA GONDI OM
-11DA0..11DA9;N   # Nd    [10] GUNJALA GONDI DIGIT ZERO..GUNJALA GONDI DIGIT NINE
-11EE0..11EF2;N   # Lo    [19] MAKASAR LETTER KA..MAKASAR ANGKA
-11EF3..11EF4;N   # Mn     [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U
-11EF5..11EF6;N   # Mc     [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O
-11EF7..11EF8;N   # Po     [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION
-11F00..11F01;N   # Mn     [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA
-11F02;N          # Lo         KAWI SIGN REPHA
-11F03;N          # Mc         KAWI SIGN VISARGA
-11F04..11F10;N   # Lo    [13] KAWI LETTER A..KAWI LETTER O
-11F12..11F33;N   # Lo    [34] KAWI LETTER KA..KAWI LETTER JNYA
-11F34..11F35;N   # Mc     [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA
-11F36..11F3A;N   # Mn     [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R
-11F3E..11F3F;N   # Mc     [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI
-11F40;N          # Mn         KAWI VOWEL SIGN EU
-11F41;N          # Mc         KAWI SIGN KILLER
-11F42;N          # Mn         KAWI CONJOINER
-11F43..11F4F;N   # Po    [13] KAWI DANDA..KAWI PUNCTUATION CLOSING SPIRAL
-11F50..11F59;N   # Nd    [10] KAWI DIGIT ZERO..KAWI DIGIT NINE
-11FB0;N          # Lo         LISU LETTER YHA
-11FC0..11FD4;N   # No    [21] TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH..TAMIL FRACTION DOWNSCALING FACTOR KIIZH
-11FD5..11FDC;N   # So     [8] TAMIL SIGN NEL..TAMIL SIGN MUKKURUNI
-11FDD..11FE0;N   # Sc     [4] TAMIL SIGN KAACU..TAMIL SIGN VARAAKAN
-11FE1..11FF1;N   # So    [17] TAMIL SIGN PAARAM..TAMIL SIGN VAKAIYARAA
-11FFF;N          # Po         TAMIL PUNCTUATION END OF TEXT
-12000..12399;N   # Lo   [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U
-12400..1246E;N   # Nl   [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM
-12470..12474;N   # Po     [5] CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER..CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON
-12480..12543;N   # Lo   [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU
-12F90..12FF0;N   # Lo    [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114
-12FF1..12FF2;N   # Po     [2] CYPRO-MINOAN SIGN CM301..CYPRO-MINOAN SIGN CM302
-13000..1342F;N   # Lo  [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D
-13430..13440;N   # Cf    [17] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY
-13441..13446;N   # Lo     [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN
-13447..13455;N   # Mn    [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED
-14400..14646;N   # Lo   [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530
-16800..16A38;N   # Lo   [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ
-16A40..16A5E;N   # Lo    [31] MRO LETTER TA..MRO LETTER TEK
-16A60..16A69;N   # Nd    [10] MRO DIGIT ZERO..MRO DIGIT NINE
-16A6E..16A6F;N   # Po     [2] MRO DANDA..MRO DOUBLE DANDA
-16A70..16ABE;N   # Lo    [79] TANGSA LETTER OZ..TANGSA LETTER ZA
-16AC0..16AC9;N   # Nd    [10] TANGSA DIGIT ZERO..TANGSA DIGIT NINE
-16AD0..16AED;N   # Lo    [30] BASSA VAH LETTER ENNI..BASSA VAH LETTER I
-16AF0..16AF4;N   # Mn     [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE
-16AF5;N          # Po         BASSA VAH FULL STOP
-16B00..16B2F;N   # Lo    [48] PAHAWH HMONG VOWEL KEEB..PAHAWH HMONG CONSONANT CAU
-16B30..16B36;N   # Mn     [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM
-16B37..16B3B;N   # Po     [5] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN VOS FEEM
-16B3C..16B3F;N   # So     [4] PAHAWH HMONG SIGN XYEEM NTXIV..PAHAWH HMONG SIGN XYEEM FAIB
-16B40..16B43;N   # Lm     [4] PAHAWH HMONG SIGN VOS SEEV..PAHAWH HMONG SIGN IB YAM
-16B44;N          # Po         PAHAWH HMONG SIGN XAUS
-16B45;N          # So         PAHAWH HMONG SIGN CIM TSOV ROG
-16B50..16B59;N   # Nd    [10] PAHAWH HMONG DIGIT ZERO..PAHAWH HMONG DIGIT NINE
-16B5B..16B61;N   # No     [7] PAHAWH HMONG NUMBER TENS..PAHAWH HMONG NUMBER TRILLIONS
-16B63..16B77;N   # Lo    [21] PAHAWH HMONG SIGN VOS LUB..PAHAWH HMONG SIGN CIM NRES TOS
-16B7D..16B8F;N   # Lo    [19] PAHAWH HMONG CLAN SIGN TSHEEJ..PAHAWH HMONG CLAN SIGN VWJ
-16E40..16E7F;N   # L&    [64] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN SMALL LETTER Y
-16E80..16E96;N   # No    [23] MEDEFAIDRIN DIGIT ZERO..MEDEFAIDRIN DIGIT THREE ALTERNATE FORM
-16E97..16E9A;N   # Po     [4] MEDEFAIDRIN COMMA..MEDEFAIDRIN EXCLAMATION OH
-16F00..16F4A;N   # Lo    [75] MIAO LETTER PA..MIAO LETTER RTE
-16F4F;N          # Mn         MIAO SIGN CONSONANT MODIFIER BAR
-16F50;N          # Lo         MIAO LETTER NASALIZATION
-16F51..16F87;N   # Mc    [55] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN UI
-16F8F..16F92;N   # Mn     [4] MIAO TONE RIGHT..MIAO TONE BELOW
-16F93..16F9F;N   # Lm    [13] MIAO LETTER TONE-2..MIAO LETTER REFORMED TONE-8
-16FE0..16FE1;W   # Lm     [2] TANGUT ITERATION MARK..NUSHU ITERATION MARK
-16FE2;W          # Po         OLD CHINESE HOOK MARK
-16FE3;W          # Lm         OLD CHINESE ITERATION MARK
-16FE4;W          # Mn         KHITAN SMALL SCRIPT FILLER
-16FF0..16FF1;W   # Mc     [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY
-17000..187F7;W   # Lo  [6136] TANGUT IDEOGRAPH-17000..TANGUT IDEOGRAPH-187F7
-18800..18AFF;W   # Lo   [768] TANGUT COMPONENT-001..TANGUT COMPONENT-768
-18B00..18CD5;W   # Lo   [470] KHITAN SMALL SCRIPT CHARACTER-18B00..KHITAN SMALL SCRIPT CHARACTER-18CD5
-18D00..18D08;W   # Lo     [9] TANGUT IDEOGRAPH-18D00..TANGUT IDEOGRAPH-18D08
-1AFF0..1AFF3;W   # Lm     [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5
-1AFF5..1AFFB;W   # Lm     [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5
-1AFFD..1AFFE;W   # Lm     [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8
-1B000..1B0FF;W   # Lo   [256] KATAKANA LETTER ARCHAIC E..HENTAIGANA LETTER RE-2
-1B100..1B122;W   # Lo    [35] HENTAIGANA LETTER RE-3..KATAKANA LETTER ARCHAIC WU
-1B132;W          # Lo         HIRAGANA LETTER SMALL KO
-1B150..1B152;W   # Lo     [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO
-1B155;W          # Lo         KATAKANA LETTER SMALL KO
-1B164..1B167;W   # Lo     [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N
-1B170..1B2FB;W   # Lo   [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB
-1BC00..1BC6A;N   # Lo   [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M
-1BC70..1BC7C;N   # Lo    [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK
-1BC80..1BC88;N   # Lo     [9] DUPLOYAN AFFIX HIGH ACUTE..DUPLOYAN AFFIX HIGH VERTICAL
-1BC90..1BC99;N   # Lo    [10] DUPLOYAN AFFIX LOW ACUTE..DUPLOYAN AFFIX LOW ARROW
-1BC9C;N          # So         DUPLOYAN SIGN O WITH CROSS
-1BC9D..1BC9E;N   # Mn     [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK
-1BC9F;N          # Po         DUPLOYAN PUNCTUATION CHINOOK FULL STOP
-1BCA0..1BCA3;N   # Cf     [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP
-1CF00..1CF2D;N   # Mn    [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT
-1CF30..1CF46;N   # Mn    [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG
-1CF50..1CFC3;N   # So   [116] ZNAMENNY NEUME KRYUK..ZNAMENNY NEUME PAUK
-1D000..1D0F5;N   # So   [246] BYZANTINE MUSICAL SYMBOL PSILI..BYZANTINE MUSICAL SYMBOL GORGON NEO KATO
-1D100..1D126;N   # So    [39] MUSICAL SYMBOL SINGLE BARLINE..MUSICAL SYMBOL DRUM CLEF-2
-1D129..1D164;N   # So    [60] MUSICAL SYMBOL MULTIPLE MEASURE REST..MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE
-1D165..1D166;N   # Mc     [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM
-1D167..1D169;N   # Mn     [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3
-1D16A..1D16C;N   # So     [3] MUSICAL SYMBOL FINGERED TREMOLO-1..MUSICAL SYMBOL FINGERED TREMOLO-3
-1D16D..1D172;N   # Mc     [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5
-1D173..1D17A;N   # Cf     [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE
-1D17B..1D182;N   # Mn     [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE
-1D183..1D184;N   # So     [2] MUSICAL SYMBOL ARPEGGIATO UP..MUSICAL SYMBOL ARPEGGIATO DOWN
-1D185..1D18B;N   # Mn     [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE
-1D18C..1D1A9;N   # So    [30] MUSICAL SYMBOL RINFORZANDO..MUSICAL SYMBOL DEGREE SLASH
-1D1AA..1D1AD;N   # Mn     [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO
-1D1AE..1D1EA;N   # So    [61] MUSICAL SYMBOL PEDAL MARK..MUSICAL SYMBOL KORON
-1D200..1D241;N   # So    [66] GREEK VOCAL NOTATION SYMBOL-1..GREEK INSTRUMENTAL NOTATION SYMBOL-54
-1D242..1D244;N   # Mn     [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME
-1D245;N          # So         GREEK MUSICAL LEIMMA
-1D2C0..1D2D3;N   # No    [20] KAKTOVIK NUMERAL ZERO..KAKTOVIK NUMERAL NINETEEN
-1D2E0..1D2F3;N   # No    [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN
-1D300..1D356;N   # So    [87] MONOGRAM FOR EARTH..TETRAGRAM FOR FOSTERING
-1D360..1D378;N   # No    [25] COUNTING ROD UNIT DIGIT ONE..TALLY MARK FIVE
-1D400..1D454;N   # L&    [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G
-1D456..1D49C;N   # L&    [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A
-1D49E..1D49F;N   # Lu     [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D
-1D4A2;N          # Lu         MATHEMATICAL SCRIPT CAPITAL G
-1D4A5..1D4A6;N   # Lu     [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K
-1D4A9..1D4AC;N   # Lu     [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q
-1D4AE..1D4B9;N   # L&    [12] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT SMALL D
-1D4BB;N          # Ll         MATHEMATICAL SCRIPT SMALL F
-1D4BD..1D4C3;N   # Ll     [7] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL N
-1D4C5..1D505;N   # L&    [65] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL FRAKTUR CAPITAL B
-1D507..1D50A;N   # Lu     [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G
-1D50D..1D514;N   # Lu     [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q
-1D516..1D51C;N   # Lu     [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y
-1D51E..1D539;N   # L&    [28] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B
-1D53B..1D53E;N   # Lu     [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G
-1D540..1D544;N   # Lu     [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M
-1D546;N          # Lu         MATHEMATICAL DOUBLE-STRUCK CAPITAL O
-1D54A..1D550;N   # Lu     [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y
-1D552..1D6A5;N   # L&   [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J
-1D6A8..1D6C0;N   # Lu    [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA
-1D6C1;N          # Sm         MATHEMATICAL BOLD NABLA
-1D6C2..1D6DA;N   # Ll    [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA
-1D6DB;N          # Sm         MATHEMATICAL BOLD PARTIAL DIFFERENTIAL
-1D6DC..1D6FA;N   # L&    [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA
-1D6FB;N          # Sm         MATHEMATICAL ITALIC NABLA
-1D6FC..1D714;N   # Ll    [25] MATHEMATICAL ITALIC SMALL ALPHA..MATHEMATICAL ITALIC SMALL OMEGA
-1D715;N          # Sm         MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL
-1D716..1D734;N   # L&    [31] MATHEMATICAL ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD ITALIC CAPITAL OMEGA
-1D735;N          # Sm         MATHEMATICAL BOLD ITALIC NABLA
-1D736..1D74E;N   # Ll    [25] MATHEMATICAL BOLD ITALIC SMALL ALPHA..MATHEMATICAL BOLD ITALIC SMALL OMEGA
-1D74F;N          # Sm         MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL
-1D750..1D76E;N   # L&    [31] MATHEMATICAL BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA
-1D76F;N          # Sm         MATHEMATICAL SANS-SERIF BOLD NABLA
-1D770..1D788;N   # Ll    [25] MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA
-1D789;N          # Sm         MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL
-1D78A..1D7A8;N   # L&    [31] MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA
-1D7A9;N          # Sm         MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA
-1D7AA..1D7C2;N   # Ll    [25] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA
-1D7C3;N          # Sm         MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL
-1D7C4..1D7CB;N   # L&     [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA
-1D7CE..1D7FF;N   # Nd    [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE
-1D800..1D9FF;N   # So   [512] SIGNWRITING HAND-FIST INDEX..SIGNWRITING HEAD
-1DA00..1DA36;N   # Mn    [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN
-1DA37..1DA3A;N   # So     [4] SIGNWRITING AIR BLOW SMALL ROTATIONS..SIGNWRITING BREATH EXHALE
-1DA3B..1DA6C;N   # Mn    [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT
-1DA6D..1DA74;N   # So     [8] SIGNWRITING SHOULDER HIP SPINE..SIGNWRITING TORSO-FLOORPLANE TWISTING
-1DA75;N          # Mn         SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS
-1DA76..1DA83;N   # So    [14] SIGNWRITING LIMB COMBINATION..SIGNWRITING LOCATION DEPTH
-1DA84;N          # Mn         SIGNWRITING LOCATION HEAD NECK
-1DA85..1DA86;N   # So     [2] SIGNWRITING LOCATION TORSO..SIGNWRITING LOCATION LIMBS DIGITS
-1DA87..1DA8B;N   # Po     [5] SIGNWRITING COMMA..SIGNWRITING PARENTHESIS
-1DA9B..1DA9F;N   # Mn     [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6
-1DAA1..1DAAF;N   # Mn    [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16
-1DF00..1DF09;N   # Ll    [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK
-1DF0A;N          # Lo         LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK
-1DF0B..1DF1E;N   # Ll    [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL
-1DF25..1DF2A;N   # Ll     [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK
-1E000..1E006;N   # Mn     [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE
-1E008..1E018;N   # Mn    [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU
-1E01B..1E021;N   # Mn     [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI
-1E023..1E024;N   # Mn     [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS
-1E026..1E02A;N   # Mn     [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA
-1E030..1E06D;N   # Lm    [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE
-1E08F;N          # Mn         COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
-1E100..1E12C;N   # Lo    [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W
-1E130..1E136;N   # Mn     [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D
-1E137..1E13D;N   # Lm     [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER
-1E140..1E149;N   # Nd    [10] NYIAKENG PUACHUE HMONG DIGIT ZERO..NYIAKENG PUACHUE HMONG DIGIT NINE
-1E14E;N          # Lo         NYIAKENG PUACHUE HMONG LOGOGRAM NYAJ
-1E14F;N          # So         NYIAKENG PUACHUE HMONG CIRCLED CA
-1E290..1E2AD;N   # Lo    [30] TOTO LETTER PA..TOTO LETTER A
-1E2AE;N          # Mn         TOTO SIGN RISING TONE
-1E2C0..1E2EB;N   # Lo    [44] WANCHO LETTER AA..WANCHO LETTER YIH
-1E2EC..1E2EF;N   # Mn     [4] WANCHO TONE TUP..WANCHO TONE KOINI
-1E2F0..1E2F9;N   # Nd    [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE
-1E2FF;N          # Sc         WANCHO NGUN SIGN
-1E4D0..1E4EA;N   # Lo    [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL
-1E4EB;N          # Lm         NAG MUNDARI SIGN OJOD
-1E4EC..1E4EF;N   # Mn     [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH
-1E4F0..1E4F9;N   # Nd    [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE
-1E7E0..1E7E6;N   # Lo     [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO
-1E7E8..1E7EB;N   # Lo     [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE
-1E7ED..1E7EE;N   # Lo     [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE
-1E7F0..1E7FE;N   # Lo    [15] ETHIOPIC SYLLABLE GURAGE QWI..ETHIOPIC SYLLABLE GURAGE PWEE
-1E800..1E8C4;N   # Lo   [197] MENDE KIKAKUI SYLLABLE M001 KI..MENDE KIKAKUI SYLLABLE M060 NYON
-1E8C7..1E8CF;N   # No     [9] MENDE KIKAKUI DIGIT ONE..MENDE KIKAKUI DIGIT NINE
-1E8D0..1E8D6;N   # Mn     [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS
-1E900..1E943;N   # L&    [68] ADLAM CAPITAL LETTER ALIF..ADLAM SMALL LETTER SHA
-1E944..1E94A;N   # Mn     [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA
-1E94B;N          # Lm         ADLAM NASALIZATION MARK
-1E950..1E959;N   # Nd    [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE
-1E95E..1E95F;N   # Po     [2] ADLAM INITIAL EXCLAMATION MARK..ADLAM INITIAL QUESTION MARK
-1EC71..1ECAB;N   # No    [59] INDIC SIYAQ NUMBER ONE..INDIC SIYAQ NUMBER PREFIXED NINE
-1ECAC;N          # So         INDIC SIYAQ PLACEHOLDER
-1ECAD..1ECAF;N   # No     [3] INDIC SIYAQ FRACTION ONE QUARTER..INDIC SIYAQ FRACTION THREE QUARTERS
-1ECB0;N          # Sc         INDIC SIYAQ RUPEE MARK
-1ECB1..1ECB4;N   # No     [4] INDIC SIYAQ NUMBER ALTERNATE ONE..INDIC SIYAQ ALTERNATE LAKH MARK
-1ED01..1ED2D;N   # No    [45] OTTOMAN SIYAQ NUMBER ONE..OTTOMAN SIYAQ NUMBER NINETY THOUSAND
-1ED2E;N          # So         OTTOMAN SIYAQ MARRATAN
-1ED2F..1ED3D;N   # No    [15] OTTOMAN SIYAQ ALTERNATE NUMBER TWO..OTTOMAN SIYAQ FRACTION ONE SIXTH
-1EE00..1EE03;N   # Lo     [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL
-1EE05..1EE1F;N   # Lo    [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF
-1EE21..1EE22;N   # Lo     [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM
-1EE24;N          # Lo         ARABIC MATHEMATICAL INITIAL HEH
-1EE27;N          # Lo         ARABIC MATHEMATICAL INITIAL HAH
-1EE29..1EE32;N   # Lo    [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF
-1EE34..1EE37;N   # Lo     [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH
-1EE39;N          # Lo         ARABIC MATHEMATICAL INITIAL DAD
-1EE3B;N          # Lo         ARABIC MATHEMATICAL INITIAL GHAIN
-1EE42;N          # Lo         ARABIC MATHEMATICAL TAILED JEEM
-1EE47;N          # Lo         ARABIC MATHEMATICAL TAILED HAH
-1EE49;N          # Lo         ARABIC MATHEMATICAL TAILED YEH
-1EE4B;N          # Lo         ARABIC MATHEMATICAL TAILED LAM
-1EE4D..1EE4F;N   # Lo     [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN
-1EE51..1EE52;N   # Lo     [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF
-1EE54;N          # Lo         ARABIC MATHEMATICAL TAILED SHEEN
-1EE57;N          # Lo         ARABIC MATHEMATICAL TAILED KHAH
-1EE59;N          # Lo         ARABIC MATHEMATICAL TAILED DAD
-1EE5B;N          # Lo         ARABIC MATHEMATICAL TAILED GHAIN
-1EE5D;N          # Lo         ARABIC MATHEMATICAL TAILED DOTLESS NOON
-1EE5F;N          # Lo         ARABIC MATHEMATICAL TAILED DOTLESS QAF
-1EE61..1EE62;N   # Lo     [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM
-1EE64;N          # Lo         ARABIC MATHEMATICAL STRETCHED HEH
-1EE67..1EE6A;N   # Lo     [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF
-1EE6C..1EE72;N   # Lo     [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF
-1EE74..1EE77;N   # Lo     [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH
-1EE79..1EE7C;N   # Lo     [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH
-1EE7E;N          # Lo         ARABIC MATHEMATICAL STRETCHED DOTLESS FEH
-1EE80..1EE89;N   # Lo    [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH
-1EE8B..1EE9B;N   # Lo    [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN
-1EEA1..1EEA3;N   # Lo     [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL
-1EEA5..1EEA9;N   # Lo     [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH
-1EEAB..1EEBB;N   # Lo    [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN
-1EEF0..1EEF1;N   # Sm     [2] ARABIC MATHEMATICAL OPERATOR MEEM WITH HAH WITH TATWEEL..ARABIC MATHEMATICAL OPERATOR HAH WITH DAL
-1F000..1F003;N   # So     [4] MAHJONG TILE EAST WIND..MAHJONG TILE NORTH WIND
-1F004;W          # So         MAHJONG TILE RED DRAGON
-1F005..1F02B;N   # So    [39] MAHJONG TILE GREEN DRAGON..MAHJONG TILE BACK
-1F030..1F093;N   # So   [100] DOMINO TILE HORIZONTAL BACK..DOMINO TILE VERTICAL-06-06
-1F0A0..1F0AE;N   # So    [15] PLAYING CARD BACK..PLAYING CARD KING OF SPADES
-1F0B1..1F0BF;N   # So    [15] PLAYING CARD ACE OF HEARTS..PLAYING CARD RED JOKER
-1F0C1..1F0CE;N   # So    [14] PLAYING CARD ACE OF DIAMONDS..PLAYING CARD KING OF DIAMONDS
-1F0CF;W          # So         PLAYING CARD BLACK JOKER
-1F0D1..1F0F5;N   # So    [37] PLAYING CARD ACE OF CLUBS..PLAYING CARD TRUMP-21
-1F100..1F10A;A   # No    [11] DIGIT ZERO FULL STOP..DIGIT NINE COMMA
-1F10B..1F10C;N   # No     [2] DINGBAT CIRCLED SANS-SERIF DIGIT ZERO..DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ZERO
-1F10D..1F10F;N   # So     [3] CIRCLED ZERO WITH SLASH..CIRCLED DOLLAR SIGN WITH OVERLAID BACKSLASH
-1F110..1F12D;A   # So    [30] PARENTHESIZED LATIN CAPITAL LETTER A..CIRCLED CD
-1F12E..1F12F;N   # So     [2] CIRCLED WZ..COPYLEFT SYMBOL
-1F130..1F169;A   # So    [58] SQUARED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z
-1F16A..1F16F;N   # So     [6] RAISED MC SIGN..CIRCLED HUMAN FIGURE
-1F170..1F18D;A   # So    [30] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED SA
-1F18E;W          # So         NEGATIVE SQUARED AB
-1F18F..1F190;A   # So     [2] NEGATIVE SQUARED WC..SQUARE DJ
-1F191..1F19A;W   # So    [10] SQUARED CL..SQUARED VS
-1F19B..1F1AC;A   # So    [18] SQUARED THREE D..SQUARED VOD
-1F1AD;N          # So         MASK WORK SYMBOL
-1F1E6..1F1FF;N   # So    [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z
-1F200..1F202;W   # So     [3] SQUARE HIRAGANA HOKA..SQUARED KATAKANA SA
-1F210..1F23B;W   # So    [44] SQUARED CJK UNIFIED IDEOGRAPH-624B..SQUARED CJK UNIFIED IDEOGRAPH-914D
-1F240..1F248;W   # So     [9] TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-672C..TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-6557
-1F250..1F251;W   # So     [2] CIRCLED IDEOGRAPH ADVANTAGE..CIRCLED IDEOGRAPH ACCEPT
-1F260..1F265;W   # So     [6] ROUNDED SYMBOL FOR FU..ROUNDED SYMBOL FOR CAI
-1F300..1F320;W   # So    [33] CYCLONE..SHOOTING STAR
-1F321..1F32C;N   # So    [12] THERMOMETER..WIND BLOWING FACE
-1F32D..1F335;W   # So     [9] HOT DOG..CACTUS
-1F336;N          # So         HOT PEPPER
-1F337..1F37C;W   # So    [70] TULIP..BABY BOTTLE
-1F37D;N          # So         FORK AND KNIFE WITH PLATE
-1F37E..1F393;W   # So    [22] BOTTLE WITH POPPING CORK..GRADUATION CAP
-1F394..1F39F;N   # So    [12] HEART WITH TIP ON THE LEFT..ADMISSION TICKETS
-1F3A0..1F3CA;W   # So    [43] CAROUSEL HORSE..SWIMMER
-1F3CB..1F3CE;N   # So     [4] WEIGHT LIFTER..RACING CAR
-1F3CF..1F3D3;W   # So     [5] CRICKET BAT AND BALL..TABLE TENNIS PADDLE AND BALL
-1F3D4..1F3DF;N   # So    [12] SNOW CAPPED MOUNTAIN..STADIUM
-1F3E0..1F3F0;W   # So    [17] HOUSE BUILDING..EUROPEAN CASTLE
-1F3F1..1F3F3;N   # So     [3] WHITE PENNANT..WAVING WHITE FLAG
-1F3F4;W          # So         WAVING BLACK FLAG
-1F3F5..1F3F7;N   # So     [3] ROSETTE..LABEL
-1F3F8..1F3FA;W   # So     [3] BADMINTON RACQUET AND SHUTTLECOCK..AMPHORA
-1F3FB..1F3FF;W   # Sk     [5] EMOJI MODIFIER FITZPATRICK TYPE-1-2..EMOJI MODIFIER FITZPATRICK TYPE-6
-1F400..1F43E;W   # So    [63] RAT..PAW PRINTS
-1F43F;N          # So         CHIPMUNK
-1F440;W          # So         EYES
-1F441;N          # So         EYE
-1F442..1F4FC;W   # So   [187] EAR..VIDEOCASSETTE
-1F4FD..1F4FE;N   # So     [2] FILM PROJECTOR..PORTABLE STEREO
-1F4FF..1F53D;W   # So    [63] PRAYER BEADS..DOWN-POINTING SMALL RED TRIANGLE
-1F53E..1F54A;N   # So    [13] LOWER RIGHT SHADOWED WHITE CIRCLE..DOVE OF PEACE
-1F54B..1F54E;W   # So     [4] KAABA..MENORAH WITH NINE BRANCHES
-1F54F;N          # So         BOWL OF HYGIEIA
-1F550..1F567;W   # So    [24] CLOCK FACE ONE OCLOCK..CLOCK FACE TWELVE-THIRTY
-1F568..1F579;N   # So    [18] RIGHT SPEAKER..JOYSTICK
-1F57A;W          # So         MAN DANCING
-1F57B..1F594;N   # So    [26] LEFT HAND TELEPHONE RECEIVER..REVERSED VICTORY HAND
-1F595..1F596;W   # So     [2] REVERSED HAND WITH MIDDLE FINGER EXTENDED..RAISED HAND WITH PART BETWEEN MIDDLE AND RING FINGERS
-1F597..1F5A3;N   # So    [13] WHITE DOWN POINTING LEFT HAND INDEX..BLACK DOWN POINTING BACKHAND INDEX
-1F5A4;W          # So         BLACK HEART
-1F5A5..1F5FA;N   # So    [86] DESKTOP COMPUTER..WORLD MAP
-1F5FB..1F5FF;W   # So     [5] MOUNT FUJI..MOYAI
-1F600..1F64F;W   # So    [80] GRINNING FACE..PERSON WITH FOLDED HANDS
-1F650..1F67F;N   # So    [48] NORTH WEST POINTING LEAF..REVERSE CHECKER BOARD
-1F680..1F6C5;W   # So    [70] ROCKET..LEFT LUGGAGE
-1F6C6..1F6CB;N   # So     [6] TRIANGLE WITH ROUNDED CORNERS..COUCH AND LAMP
-1F6CC;W          # So         SLEEPING ACCOMMODATION
-1F6CD..1F6CF;N   # So     [3] SHOPPING BAGS..BED
-1F6D0..1F6D2;W   # So     [3] PLACE OF WORSHIP..SHOPPING TROLLEY
-1F6D3..1F6D4;N   # So     [2] STUPA..PAGODA
-1F6D5..1F6D7;W   # So     [3] HINDU TEMPLE..ELEVATOR
-1F6DC..1F6DF;W   # So     [4] WIRELESS..RING BUOY
-1F6E0..1F6EA;N   # So    [11] HAMMER AND WRENCH..NORTHEAST-POINTING AIRPLANE
-1F6EB..1F6EC;W   # So     [2] AIRPLANE DEPARTURE..AIRPLANE ARRIVING
-1F6F0..1F6F3;N   # So     [4] SATELLITE..PASSENGER SHIP
-1F6F4..1F6FC;W   # So     [9] SCOOTER..ROLLER SKATE
-1F700..1F776;N   # So   [119] ALCHEMICAL SYMBOL FOR QUINTESSENCE..LUNAR ECLIPSE
-1F77B..1F77F;N   # So     [5] HAUMEA..ORCUS
-1F780..1F7D9;N   # So    [90] BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE..NINE POINTED WHITE STAR
-1F7E0..1F7EB;W   # So    [12] LARGE ORANGE CIRCLE..LARGE BROWN SQUARE
-1F7F0;W          # So         HEAVY EQUALS SIGN
-1F800..1F80B;N   # So    [12] LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD..DOWNWARDS ARROW WITH LARGE TRIANGLE ARROWHEAD
-1F810..1F847;N   # So    [56] LEFTWARDS ARROW WITH SMALL EQUILATERAL ARROWHEAD..DOWNWARDS HEAVY ARROW
-1F850..1F859;N   # So    [10] LEFTWARDS SANS-SERIF ARROW..UP DOWN SANS-SERIF ARROW
-1F860..1F887;N   # So    [40] WIDE-HEADED LEFTWARDS LIGHT BARB ARROW..WIDE-HEADED SOUTH WEST VERY HEAVY BARB ARROW
-1F890..1F8AD;N   # So    [30] LEFTWARDS TRIANGLE ARROWHEAD..WHITE ARROW SHAFT WIDTH TWO THIRDS
-1F8B0..1F8B1;N   # So     [2] ARROW POINTING UPWARDS THEN NORTH WEST..ARROW POINTING RIGHTWARDS THEN CURVING SOUTH WEST
-1F900..1F90B;N   # So    [12] CIRCLED CROSS FORMEE WITH FOUR DOTS..DOWNWARD FACING NOTCHED HOOK WITH DOT
-1F90C..1F93A;W   # So    [47] PINCHED FINGERS..FENCER
-1F93B;N          # So         MODERN PENTATHLON
-1F93C..1F945;W   # So    [10] WRESTLERS..GOAL NET
-1F946;N          # So         RIFLE
-1F947..1F9FF;W   # So   [185] FIRST PLACE MEDAL..NAZAR AMULET
-1FA00..1FA53;N   # So    [84] NEUTRAL CHESS KING..BLACK CHESS KNIGHT-BISHOP
-1FA60..1FA6D;N   # So    [14] XIANGQI RED GENERAL..XIANGQI BLACK SOLDIER
-1FA70..1FA7C;W   # So    [13] BALLET SHOES..CRUTCH
-1FA80..1FA88;W   # So     [9] YO-YO..FLUTE
-1FA90..1FABD;W   # So    [46] RINGED PLANET..WING
-1FABE;W          # Cn         <reserved-1FABE>
-1FABF..1FAC5;W   # So     [7] GOOSE..PERSON WITH CROWN
-1FACE..1FADB;W   # So    [14] MOOSE..PEA POD
-1FAE0..1FAE8;W   # So     [9] MELTING FACE..SHAKING FACE
-1FAF0..1FAF8;W   # So     [9] HAND WITH INDEX FINGER AND THUMB CROSSED..RIGHTWARDS PUSHING HAND
-1FB00..1FB92;N   # So   [147] BLOCK SEXTANT-1..UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK
-1FB94..1FBCA;N   # So    [55] LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK..WHITE UP-POINTING CHEVRON
-1FBF0..1FBF9;N   # Nd    [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE
-20000..2A6DF;W   # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF
-2A6E0..2A6FF;W   # Cn    [32] <reserved-2A6E0>..<reserved-2A6FF>
-2A700..2B738;W   # Lo  [4153] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B738
-2B739..2B73F;W   # Cn     [7] <reserved-2B739>..<reserved-2B73F>
-2B740..2B81D;W   # Lo   [222] CJK UNIFIED IDEOGRAPH-2B740..CJK UNIFIED IDEOGRAPH-2B81D
-2B81E..2B81F;W   # Cn     [2] <reserved-2B81E>..<reserved-2B81F>
-2B820..2CEA1;W   # Lo  [5762] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEA1
-2CEA2..2CEAF;W   # Cn    [14] <reserved-2CEA2>..<reserved-2CEAF>
-2CEB0..2EBE0;W   # Lo  [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0
-2EBE1..2F7FF;W   # Cn  [3103] <reserved-2EBE1>..<reserved-2F7FF>
-2F800..2FA1D;W   # Lo   [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D
-2FA1E..2FA1F;W   # Cn     [2] <reserved-2FA1E>..<reserved-2FA1F>
-2FA20..2FFFD;W   # Cn  [1502] <reserved-2FA20>..<reserved-2FFFD>
-30000..3134A;W   # Lo  [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A
-3134B..3134F;W   # Cn     [5] <reserved-3134B>..<reserved-3134F>
-31350..323AF;W   # Lo  [4192] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-323AF
-323B0..3FFFD;W   # Cn [56398] <reserved-323B0>..<reserved-3FFFD>
-E0001;N          # Cf         LANGUAGE TAG
-E0020..E007F;N   # Cf    [96] TAG SPACE..CANCEL TAG
-E0100..E01EF;A   # Mn   [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256
-F0000..FFFFD;A   # Co [65534] <private-use-F0000>..<private-use-FFFFD>
-100000..10FFFD;A # Co [65534] <private-use-100000>..<private-use-10FFFD>
+0000..001F     ; N  # Cc    [32] <control-0000>..<control-001F>
+0020           ; Na # Zs         SPACE
+0021..0023     ; Na # Po     [3] EXCLAMATION MARK..NUMBER SIGN
+0024           ; Na # Sc         DOLLAR SIGN
+0025..0027     ; Na # Po     [3] PERCENT SIGN..APOSTROPHE
+0028           ; Na # Ps         LEFT PARENTHESIS
+0029           ; Na # Pe         RIGHT PARENTHESIS
+002A           ; Na # Po         ASTERISK
+002B           ; Na # Sm         PLUS SIGN
+002C           ; Na # Po         COMMA
+002D           ; Na # Pd         HYPHEN-MINUS
+002E..002F     ; Na # Po     [2] FULL STOP..SOLIDUS
+0030..0039     ; Na # Nd    [10] DIGIT ZERO..DIGIT NINE
+003A..003B     ; Na # Po     [2] COLON..SEMICOLON
+003C..003E     ; Na # Sm     [3] LESS-THAN SIGN..GREATER-THAN SIGN
+003F..0040     ; Na # Po     [2] QUESTION MARK..COMMERCIAL AT
+0041..005A     ; Na # Lu    [26] LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z
+005B           ; Na # Ps         LEFT SQUARE BRACKET
+005C           ; Na # Po         REVERSE SOLIDUS
+005D           ; Na # Pe         RIGHT SQUARE BRACKET
+005E           ; Na # Sk         CIRCUMFLEX ACCENT
+005F           ; Na # Pc         LOW LINE
+0060           ; Na # Sk         GRAVE ACCENT
+0061..007A     ; Na # Ll    [26] LATIN SMALL LETTER A..LATIN SMALL LETTER Z
+007B           ; Na # Ps         LEFT CURLY BRACKET
+007C           ; Na # Sm         VERTICAL LINE
+007D           ; Na # Pe         RIGHT CURLY BRACKET
+007E           ; Na # Sm         TILDE
+007F           ; N  # Cc         <control-007F>
+0080..009F     ; N  # Cc    [32] <control-0080>..<control-009F>
+00A0           ; N  # Zs         NO-BREAK SPACE
+00A1           ; A  # Po         INVERTED EXCLAMATION MARK
+00A2..00A3     ; Na # Sc     [2] CENT SIGN..POUND SIGN
+00A4           ; A  # Sc         CURRENCY SIGN
+00A5           ; Na # Sc         YEN SIGN
+00A6           ; Na # So         BROKEN BAR
+00A7           ; A  # Po         SECTION SIGN
+00A8           ; A  # Sk         DIAERESIS
+00A9           ; N  # So         COPYRIGHT SIGN
+00AA           ; A  # Lo         FEMININE ORDINAL INDICATOR
+00AB           ; N  # Pi         LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+00AC           ; Na # Sm         NOT SIGN
+00AD           ; A  # Cf         SOFT HYPHEN
+00AE           ; A  # So         REGISTERED SIGN
+00AF           ; Na # Sk         MACRON
+00B0           ; A  # So         DEGREE SIGN
+00B1           ; A  # Sm         PLUS-MINUS SIGN
+00B2..00B3     ; A  # No     [2] SUPERSCRIPT TWO..SUPERSCRIPT THREE
+00B4           ; A  # Sk         ACUTE ACCENT
+00B5           ; N  # Ll         MICRO SIGN
+00B6..00B7     ; A  # Po     [2] PILCROW SIGN..MIDDLE DOT
+00B8           ; A  # Sk         CEDILLA
+00B9           ; A  # No         SUPERSCRIPT ONE
+00BA           ; A  # Lo         MASCULINE ORDINAL INDICATOR
+00BB           ; N  # Pf         RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+00BC..00BE     ; A  # No     [3] VULGAR FRACTION ONE QUARTER..VULGAR FRACTION THREE QUARTERS
+00BF           ; A  # Po         INVERTED QUESTION MARK
+00C0..00C5     ; N  # Lu     [6] LATIN CAPITAL LETTER A WITH GRAVE..LATIN CAPITAL LETTER A WITH RING ABOVE
+00C6           ; A  # Lu         LATIN CAPITAL LETTER AE
+00C7..00CF     ; N  # Lu     [9] LATIN CAPITAL LETTER C WITH CEDILLA..LATIN CAPITAL LETTER I WITH DIAERESIS
+00D0           ; A  # Lu         LATIN CAPITAL LETTER ETH
+00D1..00D6     ; N  # Lu     [6] LATIN CAPITAL LETTER N WITH TILDE..LATIN CAPITAL LETTER O WITH DIAERESIS
+00D7           ; A  # Sm         MULTIPLICATION SIGN
+00D8           ; A  # Lu         LATIN CAPITAL LETTER O WITH STROKE
+00D9..00DD     ; N  # Lu     [5] LATIN CAPITAL LETTER U WITH GRAVE..LATIN CAPITAL LETTER Y WITH ACUTE
+00DE..00E1     ; A  # L&     [4] LATIN CAPITAL LETTER THORN..LATIN SMALL LETTER A WITH ACUTE
+00E2..00E5     ; N  # Ll     [4] LATIN SMALL LETTER A WITH CIRCUMFLEX..LATIN SMALL LETTER A WITH RING ABOVE
+00E6           ; A  # Ll         LATIN SMALL LETTER AE
+00E7           ; N  # Ll         LATIN SMALL LETTER C WITH CEDILLA
+00E8..00EA     ; A  # Ll     [3] LATIN SMALL LETTER E WITH GRAVE..LATIN SMALL LETTER E WITH CIRCUMFLEX
+00EB           ; N  # Ll         LATIN SMALL LETTER E WITH DIAERESIS
+00EC..00ED     ; A  # Ll     [2] LATIN SMALL LETTER I WITH GRAVE..LATIN SMALL LETTER I WITH ACUTE
+00EE..00EF     ; N  # Ll     [2] LATIN SMALL LETTER I WITH CIRCUMFLEX..LATIN SMALL LETTER I WITH DIAERESIS
+00F0           ; A  # Ll         LATIN SMALL LETTER ETH
+00F1           ; N  # Ll         LATIN SMALL LETTER N WITH TILDE
+00F2..00F3     ; A  # Ll     [2] LATIN SMALL LETTER O WITH GRAVE..LATIN SMALL LETTER O WITH ACUTE
+00F4..00F6     ; N  # Ll     [3] LATIN SMALL LETTER O WITH CIRCUMFLEX..LATIN SMALL LETTER O WITH DIAERESIS
+00F7           ; A  # Sm         DIVISION SIGN
+00F8..00FA     ; A  # Ll     [3] LATIN SMALL LETTER O WITH STROKE..LATIN SMALL LETTER U WITH ACUTE
+00FB           ; N  # Ll         LATIN SMALL LETTER U WITH CIRCUMFLEX
+00FC           ; A  # Ll         LATIN SMALL LETTER U WITH DIAERESIS
+00FD           ; N  # Ll         LATIN SMALL LETTER Y WITH ACUTE
+00FE           ; A  # Ll         LATIN SMALL LETTER THORN
+00FF           ; N  # Ll         LATIN SMALL LETTER Y WITH DIAERESIS
+0100           ; N  # Lu         LATIN CAPITAL LETTER A WITH MACRON
+0101           ; A  # Ll         LATIN SMALL LETTER A WITH MACRON
+0102..0110     ; N  # L&    [15] LATIN CAPITAL LETTER A WITH BREVE..LATIN CAPITAL LETTER D WITH STROKE
+0111           ; A  # Ll         LATIN SMALL LETTER D WITH STROKE
+0112           ; N  # Lu         LATIN CAPITAL LETTER E WITH MACRON
+0113           ; A  # Ll         LATIN SMALL LETTER E WITH MACRON
+0114..011A     ; N  # L&     [7] LATIN CAPITAL LETTER E WITH BREVE..LATIN CAPITAL LETTER E WITH CARON
+011B           ; A  # Ll         LATIN SMALL LETTER E WITH CARON
+011C..0125     ; N  # L&    [10] LATIN CAPITAL LETTER G WITH CIRCUMFLEX..LATIN SMALL LETTER H WITH CIRCUMFLEX
+0126..0127     ; A  # L&     [2] LATIN CAPITAL LETTER H WITH STROKE..LATIN SMALL LETTER H WITH STROKE
+0128..012A     ; N  # L&     [3] LATIN CAPITAL LETTER I WITH TILDE..LATIN CAPITAL LETTER I WITH MACRON
+012B           ; A  # Ll         LATIN SMALL LETTER I WITH MACRON
+012C..0130     ; N  # L&     [5] LATIN CAPITAL LETTER I WITH BREVE..LATIN CAPITAL LETTER I WITH DOT ABOVE
+0131..0133     ; A  # L&     [3] LATIN SMALL LETTER DOTLESS I..LATIN SMALL LIGATURE IJ
+0134..0137     ; N  # L&     [4] LATIN CAPITAL LETTER J WITH CIRCUMFLEX..LATIN SMALL LETTER K WITH CEDILLA
+0138           ; A  # Ll         LATIN SMALL LETTER KRA
+0139..013E     ; N  # L&     [6] LATIN CAPITAL LETTER L WITH ACUTE..LATIN SMALL LETTER L WITH CARON
+013F..0142     ; A  # L&     [4] LATIN CAPITAL LETTER L WITH MIDDLE DOT..LATIN SMALL LETTER L WITH STROKE
+0143           ; N  # Lu         LATIN CAPITAL LETTER N WITH ACUTE
+0144           ; A  # Ll         LATIN SMALL LETTER N WITH ACUTE
+0145..0147     ; N  # L&     [3] LATIN CAPITAL LETTER N WITH CEDILLA..LATIN CAPITAL LETTER N WITH CARON
+0148..014B     ; A  # L&     [4] LATIN SMALL LETTER N WITH CARON..LATIN SMALL LETTER ENG
+014C           ; N  # Lu         LATIN CAPITAL LETTER O WITH MACRON
+014D           ; A  # Ll         LATIN SMALL LETTER O WITH MACRON
+014E..0151     ; N  # L&     [4] LATIN CAPITAL LETTER O WITH BREVE..LATIN SMALL LETTER O WITH DOUBLE ACUTE
+0152..0153     ; A  # L&     [2] LATIN CAPITAL LIGATURE OE..LATIN SMALL LIGATURE OE
+0154..0165     ; N  # L&    [18] LATIN CAPITAL LETTER R WITH ACUTE..LATIN SMALL LETTER T WITH CARON
+0166..0167     ; A  # L&     [2] LATIN CAPITAL LETTER T WITH STROKE..LATIN SMALL LETTER T WITH STROKE
+0168..016A     ; N  # L&     [3] LATIN CAPITAL LETTER U WITH TILDE..LATIN CAPITAL LETTER U WITH MACRON
+016B           ; A  # Ll         LATIN SMALL LETTER U WITH MACRON
+016C..017F     ; N  # L&    [20] LATIN CAPITAL LETTER U WITH BREVE..LATIN SMALL LETTER LONG S
+0180..01BA     ; N  # L&    [59] LATIN SMALL LETTER B WITH STROKE..LATIN SMALL LETTER EZH WITH TAIL
+01BB           ; N  # Lo         LATIN LETTER TWO WITH STROKE
+01BC..01BF     ; N  # L&     [4] LATIN CAPITAL LETTER TONE FIVE..LATIN LETTER WYNN
+01C0..01C3     ; N  # Lo     [4] LATIN LETTER DENTAL CLICK..LATIN LETTER RETROFLEX CLICK
+01C4..01CD     ; N  # L&    [10] LATIN CAPITAL LETTER DZ WITH CARON..LATIN CAPITAL LETTER A WITH CARON
+01CE           ; A  # Ll         LATIN SMALL LETTER A WITH CARON
+01CF           ; N  # Lu         LATIN CAPITAL LETTER I WITH CARON
+01D0           ; A  # Ll         LATIN SMALL LETTER I WITH CARON
+01D1           ; N  # Lu         LATIN CAPITAL LETTER O WITH CARON
+01D2           ; A  # Ll         LATIN SMALL LETTER O WITH CARON
+01D3           ; N  # Lu         LATIN CAPITAL LETTER U WITH CARON
+01D4           ; A  # Ll         LATIN SMALL LETTER U WITH CARON
+01D5           ; N  # Lu         LATIN CAPITAL LETTER U WITH DIAERESIS AND MACRON
+01D6           ; A  # Ll         LATIN SMALL LETTER U WITH DIAERESIS AND MACRON
+01D7           ; N  # Lu         LATIN CAPITAL LETTER U WITH DIAERESIS AND ACUTE
+01D8           ; A  # Ll         LATIN SMALL LETTER U WITH DIAERESIS AND ACUTE
+01D9           ; N  # Lu         LATIN CAPITAL LETTER U WITH DIAERESIS AND CARON
+01DA           ; A  # Ll         LATIN SMALL LETTER U WITH DIAERESIS AND CARON
+01DB           ; N  # Lu         LATIN CAPITAL LETTER U WITH DIAERESIS AND GRAVE
+01DC           ; A  # Ll         LATIN SMALL LETTER U WITH DIAERESIS AND GRAVE
+01DD..024F     ; N  # L&   [115] LATIN SMALL LETTER TURNED E..LATIN SMALL LETTER Y WITH STROKE
+0250           ; N  # Ll         LATIN SMALL LETTER TURNED A
+0251           ; A  # Ll         LATIN SMALL LETTER ALPHA
+0252..0260     ; N  # Ll    [15] LATIN SMALL LETTER TURNED ALPHA..LATIN SMALL LETTER G WITH HOOK
+0261           ; A  # Ll         LATIN SMALL LETTER SCRIPT G
+0262..0293     ; N  # Ll    [50] LATIN LETTER SMALL CAPITAL G..LATIN SMALL LETTER EZH WITH CURL
+0294           ; N  # Lo         LATIN LETTER GLOTTAL STOP
+0295..02AF     ; N  # Ll    [27] LATIN LETTER PHARYNGEAL VOICED FRICATIVE..LATIN SMALL LETTER TURNED H WITH FISHHOOK AND TAIL
+02B0..02C1     ; N  # Lm    [18] MODIFIER LETTER SMALL H..MODIFIER LETTER REVERSED GLOTTAL STOP
+02C2..02C3     ; N  # Sk     [2] MODIFIER LETTER LEFT ARROWHEAD..MODIFIER LETTER RIGHT ARROWHEAD
+02C4           ; A  # Sk         MODIFIER LETTER UP ARROWHEAD
+02C5           ; N  # Sk         MODIFIER LETTER DOWN ARROWHEAD
+02C6           ; N  # Lm         MODIFIER LETTER CIRCUMFLEX ACCENT
+02C7           ; A  # Lm         CARON
+02C8           ; N  # Lm         MODIFIER LETTER VERTICAL LINE
+02C9..02CB     ; A  # Lm     [3] MODIFIER LETTER MACRON..MODIFIER LETTER GRAVE ACCENT
+02CC           ; N  # Lm         MODIFIER LETTER LOW VERTICAL LINE
+02CD           ; A  # Lm         MODIFIER LETTER LOW MACRON
+02CE..02CF     ; N  # Lm     [2] MODIFIER LETTER LOW GRAVE ACCENT..MODIFIER LETTER LOW ACUTE ACCENT
+02D0           ; A  # Lm         MODIFIER LETTER TRIANGULAR COLON
+02D1           ; N  # Lm         MODIFIER LETTER HALF TRIANGULAR COLON
+02D2..02D7     ; N  # Sk     [6] MODIFIER LETTER CENTRED RIGHT HALF RING..MODIFIER LETTER MINUS SIGN
+02D8..02DB     ; A  # Sk     [4] BREVE..OGONEK
+02DC           ; N  # Sk         SMALL TILDE
+02DD           ; A  # Sk         DOUBLE ACUTE ACCENT
+02DE           ; N  # Sk         MODIFIER LETTER RHOTIC HOOK
+02DF           ; A  # Sk         MODIFIER LETTER CROSS ACCENT
+02E0..02E4     ; N  # Lm     [5] MODIFIER LETTER SMALL GAMMA..MODIFIER LETTER SMALL REVERSED GLOTTAL STOP
+02E5..02EB     ; N  # Sk     [7] MODIFIER LETTER EXTRA-HIGH TONE BAR..MODIFIER LETTER YANG DEPARTING TONE MARK
+02EC           ; N  # Lm         MODIFIER LETTER VOICING
+02ED           ; N  # Sk         MODIFIER LETTER UNASPIRATED
+02EE           ; N  # Lm         MODIFIER LETTER DOUBLE APOSTROPHE
+02EF..02FF     ; N  # Sk    [17] MODIFIER LETTER LOW DOWN ARROWHEAD..MODIFIER LETTER LOW LEFT ARROW
+0300..036F     ; A  # Mn   [112] COMBINING GRAVE ACCENT..COMBINING LATIN SMALL LETTER X
+0370..0373     ; N  # L&     [4] GREEK CAPITAL LETTER HETA..GREEK SMALL LETTER ARCHAIC SAMPI
+0374           ; N  # Lm         GREEK NUMERAL SIGN
+0375           ; N  # Sk         GREEK LOWER NUMERAL SIGN
+0376..0377     ; N  # L&     [2] GREEK CAPITAL LETTER PAMPHYLIAN DIGAMMA..GREEK SMALL LETTER PAMPHYLIAN DIGAMMA
+037A           ; N  # Lm         GREEK YPOGEGRAMMENI
+037B..037D     ; N  # Ll     [3] GREEK SMALL REVERSED LUNATE SIGMA SYMBOL..GREEK SMALL REVERSED DOTTED LUNATE SIGMA SYMBOL
+037E           ; N  # Po         GREEK QUESTION MARK
+037F           ; N  # Lu         GREEK CAPITAL LETTER YOT
+0384..0385     ; N  # Sk     [2] GREEK TONOS..GREEK DIALYTIKA TONOS
+0386           ; N  # Lu         GREEK CAPITAL LETTER ALPHA WITH TONOS
+0387           ; N  # Po         GREEK ANO TELEIA
+0388..038A     ; N  # Lu     [3] GREEK CAPITAL LETTER EPSILON WITH TONOS..GREEK CAPITAL LETTER IOTA WITH TONOS
+038C           ; N  # Lu         GREEK CAPITAL LETTER OMICRON WITH TONOS
+038E..0390     ; N  # L&     [3] GREEK CAPITAL LETTER UPSILON WITH TONOS..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
+0391..03A1     ; A  # Lu    [17] GREEK CAPITAL LETTER ALPHA..GREEK CAPITAL LETTER RHO
+03A3..03A9     ; A  # Lu     [7] GREEK CAPITAL LETTER SIGMA..GREEK CAPITAL LETTER OMEGA
+03AA..03B0     ; N  # L&     [7] GREEK CAPITAL LETTER IOTA WITH DIALYTIKA..GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
+03B1..03C1     ; A  # Ll    [17] GREEK SMALL LETTER ALPHA..GREEK SMALL LETTER RHO
+03C2           ; N  # Ll         GREEK SMALL LETTER FINAL SIGMA
+03C3..03C9     ; A  # Ll     [7] GREEK SMALL LETTER SIGMA..GREEK SMALL LETTER OMEGA
+03CA..03F5     ; N  # L&    [44] GREEK SMALL LETTER IOTA WITH DIALYTIKA..GREEK LUNATE EPSILON SYMBOL
+03F6           ; N  # Sm         GREEK REVERSED LUNATE EPSILON SYMBOL
+03F7..03FF     ; N  # L&     [9] GREEK CAPITAL LETTER SHO..GREEK CAPITAL REVERSED DOTTED LUNATE SIGMA SYMBOL
+0400           ; N  # Lu         CYRILLIC CAPITAL LETTER IE WITH GRAVE
+0401           ; A  # Lu         CYRILLIC CAPITAL LETTER IO
+0402..040F     ; N  # Lu    [14] CYRILLIC CAPITAL LETTER DJE..CYRILLIC CAPITAL LETTER DZHE
+0410..044F     ; A  # L&    [64] CYRILLIC CAPITAL LETTER A..CYRILLIC SMALL LETTER YA
+0450           ; N  # Ll         CYRILLIC SMALL LETTER IE WITH GRAVE
+0451           ; A  # Ll         CYRILLIC SMALL LETTER IO
+0452..0481     ; N  # L&    [48] CYRILLIC SMALL LETTER DJE..CYRILLIC SMALL LETTER KOPPA
+0482           ; N  # So         CYRILLIC THOUSANDS SIGN
+0483..0487     ; N  # Mn     [5] COMBINING CYRILLIC TITLO..COMBINING CYRILLIC POKRYTIE
+0488..0489     ; N  # Me     [2] COMBINING CYRILLIC HUNDRED THOUSANDS SIGN..COMBINING CYRILLIC MILLIONS SIGN
+048A..04FF     ; N  # L&   [118] CYRILLIC CAPITAL LETTER SHORT I WITH TAIL..CYRILLIC SMALL LETTER HA WITH STROKE
+0500..052F     ; N  # L&    [48] CYRILLIC CAPITAL LETTER KOMI DE..CYRILLIC SMALL LETTER EL WITH DESCENDER
+0531..0556     ; N  # Lu    [38] ARMENIAN CAPITAL LETTER AYB..ARMENIAN CAPITAL LETTER FEH
+0559           ; N  # Lm         ARMENIAN MODIFIER LETTER LEFT HALF RING
+055A..055F     ; N  # Po     [6] ARMENIAN APOSTROPHE..ARMENIAN ABBREVIATION MARK
+0560..0588     ; N  # Ll    [41] ARMENIAN SMALL LETTER TURNED AYB..ARMENIAN SMALL LETTER YI WITH STROKE
+0589           ; N  # Po         ARMENIAN FULL STOP
+058A           ; N  # Pd         ARMENIAN HYPHEN
+058D..058E     ; N  # So     [2] RIGHT-FACING ARMENIAN ETERNITY SIGN..LEFT-FACING ARMENIAN ETERNITY SIGN
+058F           ; N  # Sc         ARMENIAN DRAM SIGN
+0591..05BD     ; N  # Mn    [45] HEBREW ACCENT ETNAHTA..HEBREW POINT METEG
+05BE           ; N  # Pd         HEBREW PUNCTUATION MAQAF
+05BF           ; N  # Mn         HEBREW POINT RAFE
+05C0           ; N  # Po         HEBREW PUNCTUATION PASEQ
+05C1..05C2     ; N  # Mn     [2] HEBREW POINT SHIN DOT..HEBREW POINT SIN DOT
+05C3           ; N  # Po         HEBREW PUNCTUATION SOF PASUQ
+05C4..05C5     ; N  # Mn     [2] HEBREW MARK UPPER DOT..HEBREW MARK LOWER DOT
+05C6           ; N  # Po         HEBREW PUNCTUATION NUN HAFUKHA
+05C7           ; N  # Mn         HEBREW POINT QAMATS QATAN
+05D0..05EA     ; N  # Lo    [27] HEBREW LETTER ALEF..HEBREW LETTER TAV
+05EF..05F2     ; N  # Lo     [4] HEBREW YOD TRIANGLE..HEBREW LIGATURE YIDDISH DOUBLE YOD
+05F3..05F4     ; N  # Po     [2] HEBREW PUNCTUATION GERESH..HEBREW PUNCTUATION GERSHAYIM
+0600..0605     ; N  # Cf     [6] ARABIC NUMBER SIGN..ARABIC NUMBER MARK ABOVE
+0606..0608     ; N  # Sm     [3] ARABIC-INDIC CUBE ROOT..ARABIC RAY
+0609..060A     ; N  # Po     [2] ARABIC-INDIC PER MILLE SIGN..ARABIC-INDIC PER TEN THOUSAND SIGN
+060B           ; N  # Sc         AFGHANI SIGN
+060C..060D     ; N  # Po     [2] ARABIC COMMA..ARABIC DATE SEPARATOR
+060E..060F     ; N  # So     [2] ARABIC POETIC VERSE SIGN..ARABIC SIGN MISRA
+0610..061A     ; N  # Mn    [11] ARABIC SIGN SALLALLAHOU ALAYHE WASSALLAM..ARABIC SMALL KASRA
+061B           ; N  # Po         ARABIC SEMICOLON
+061C           ; N  # Cf         ARABIC LETTER MARK
+061D..061F     ; N  # Po     [3] ARABIC END OF TEXT MARK..ARABIC QUESTION MARK
+0620..063F     ; N  # Lo    [32] ARABIC LETTER KASHMIRI YEH..ARABIC LETTER FARSI YEH WITH THREE DOTS ABOVE
+0640           ; N  # Lm         ARABIC TATWEEL
+0641..064A     ; N  # Lo    [10] ARABIC LETTER FEH..ARABIC LETTER YEH
+064B..065F     ; N  # Mn    [21] ARABIC FATHATAN..ARABIC WAVY HAMZA BELOW
+0660..0669     ; N  # Nd    [10] ARABIC-INDIC DIGIT ZERO..ARABIC-INDIC DIGIT NINE
+066A..066D     ; N  # Po     [4] ARABIC PERCENT SIGN..ARABIC FIVE POINTED STAR
+066E..066F     ; N  # Lo     [2] ARABIC LETTER DOTLESS BEH..ARABIC LETTER DOTLESS QAF
+0670           ; N  # Mn         ARABIC LETTER SUPERSCRIPT ALEF
+0671..06D3     ; N  # Lo    [99] ARABIC LETTER ALEF WASLA..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE
+06D4           ; N  # Po         ARABIC FULL STOP
+06D5           ; N  # Lo         ARABIC LETTER AE
+06D6..06DC     ; N  # Mn     [7] ARABIC SMALL HIGH LIGATURE SAD WITH LAM WITH ALEF MAKSURA..ARABIC SMALL HIGH SEEN
+06DD           ; N  # Cf         ARABIC END OF AYAH
+06DE           ; N  # So         ARABIC START OF RUB EL HIZB
+06DF..06E4     ; N  # Mn     [6] ARABIC SMALL HIGH ROUNDED ZERO..ARABIC SMALL HIGH MADDA
+06E5..06E6     ; N  # Lm     [2] ARABIC SMALL WAW..ARABIC SMALL YEH
+06E7..06E8     ; N  # Mn     [2] ARABIC SMALL HIGH YEH..ARABIC SMALL HIGH NOON
+06E9           ; N  # So         ARABIC PLACE OF SAJDAH
+06EA..06ED     ; N  # Mn     [4] ARABIC EMPTY CENTRE LOW STOP..ARABIC SMALL LOW MEEM
+06EE..06EF     ; N  # Lo     [2] ARABIC LETTER DAL WITH INVERTED V..ARABIC LETTER REH WITH INVERTED V
+06F0..06F9     ; N  # Nd    [10] EXTENDED ARABIC-INDIC DIGIT ZERO..EXTENDED ARABIC-INDIC DIGIT NINE
+06FA..06FC     ; N  # Lo     [3] ARABIC LETTER SHEEN WITH DOT BELOW..ARABIC LETTER GHAIN WITH DOT BELOW
+06FD..06FE     ; N  # So     [2] ARABIC SIGN SINDHI AMPERSAND..ARABIC SIGN SINDHI POSTPOSITION MEN
+06FF           ; N  # Lo         ARABIC LETTER HEH WITH INVERTED V
+0700..070D     ; N  # Po    [14] SYRIAC END OF PARAGRAPH..SYRIAC HARKLEAN ASTERISCUS
+070F           ; N  # Cf         SYRIAC ABBREVIATION MARK
+0710           ; N  # Lo         SYRIAC LETTER ALAPH
+0711           ; N  # Mn         SYRIAC LETTER SUPERSCRIPT ALAPH
+0712..072F     ; N  # Lo    [30] SYRIAC LETTER BETH..SYRIAC LETTER PERSIAN DHALATH
+0730..074A     ; N  # Mn    [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH
+074D..074F     ; N  # Lo     [3] SYRIAC LETTER SOGDIAN ZHAIN..SYRIAC LETTER SOGDIAN FE
+0750..077F     ; N  # Lo    [48] ARABIC LETTER BEH WITH THREE DOTS HORIZONTALLY BELOW..ARABIC LETTER KAF WITH TWO DOTS ABOVE
+0780..07A5     ; N  # Lo    [38] THAANA LETTER HAA..THAANA LETTER WAAVU
+07A6..07B0     ; N  # Mn    [11] THAANA ABAFILI..THAANA SUKUN
+07B1           ; N  # Lo         THAANA LETTER NAA
+07C0..07C9     ; N  # Nd    [10] NKO DIGIT ZERO..NKO DIGIT NINE
+07CA..07EA     ; N  # Lo    [33] NKO LETTER A..NKO LETTER JONA RA
+07EB..07F3     ; N  # Mn     [9] NKO COMBINING SHORT HIGH TONE..NKO COMBINING DOUBLE DOT ABOVE
+07F4..07F5     ; N  # Lm     [2] NKO HIGH TONE APOSTROPHE..NKO LOW TONE APOSTROPHE
+07F6           ; N  # So         NKO SYMBOL OO DENNEN
+07F7..07F9     ; N  # Po     [3] NKO SYMBOL GBAKURUNEN..NKO EXCLAMATION MARK
+07FA           ; N  # Lm         NKO LAJANYALAN
+07FD           ; N  # Mn         NKO DANTAYALAN
+07FE..07FF     ; N  # Sc     [2] NKO DOROME SIGN..NKO TAMAN SIGN
+0800..0815     ; N  # Lo    [22] SAMARITAN LETTER ALAF..SAMARITAN LETTER TAAF
+0816..0819     ; N  # Mn     [4] SAMARITAN MARK IN..SAMARITAN MARK DAGESH
+081A           ; N  # Lm         SAMARITAN MODIFIER LETTER EPENTHETIC YUT
+081B..0823     ; N  # Mn     [9] SAMARITAN MARK EPENTHETIC YUT..SAMARITAN VOWEL SIGN A
+0824           ; N  # Lm         SAMARITAN MODIFIER LETTER SHORT A
+0825..0827     ; N  # Mn     [3] SAMARITAN VOWEL SIGN SHORT A..SAMARITAN VOWEL SIGN U
+0828           ; N  # Lm         SAMARITAN MODIFIER LETTER I
+0829..082D     ; N  # Mn     [5] SAMARITAN VOWEL SIGN LONG I..SAMARITAN MARK NEQUDAA
+0830..083E     ; N  # Po    [15] SAMARITAN PUNCTUATION NEQUDAA..SAMARITAN PUNCTUATION ANNAAU
+0840..0858     ; N  # Lo    [25] MANDAIC LETTER HALQA..MANDAIC LETTER AIN
+0859..085B     ; N  # Mn     [3] MANDAIC AFFRICATION MARK..MANDAIC GEMINATION MARK
+085E           ; N  # Po         MANDAIC PUNCTUATION
+0860..086A     ; N  # Lo    [11] SYRIAC LETTER MALAYALAM NGA..SYRIAC LETTER MALAYALAM SSA
+0870..0887     ; N  # Lo    [24] ARABIC LETTER ALEF WITH ATTACHED FATHA..ARABIC BASELINE ROUND DOT
+0888           ; N  # Sk         ARABIC RAISED ROUND DOT
+0889..088E     ; N  # Lo     [6] ARABIC LETTER NOON WITH INVERTED SMALL V..ARABIC VERTICAL TAIL
+0890..0891     ; N  # Cf     [2] ARABIC POUND MARK ABOVE..ARABIC PIASTRE MARK ABOVE
+0898..089F     ; N  # Mn     [8] ARABIC SMALL HIGH WORD AL-JUZ..ARABIC HALF MADDA OVER MADDA
+08A0..08C8     ; N  # Lo    [41] ARABIC LETTER BEH WITH SMALL V BELOW..ARABIC LETTER GRAF
+08C9           ; N  # Lm         ARABIC SMALL FARSI YEH
+08CA..08E1     ; N  # Mn    [24] ARABIC SMALL HIGH FARSI YEH..ARABIC SMALL HIGH SIGN SAFHA
+08E2           ; N  # Cf         ARABIC DISPUTED END OF AYAH
+08E3..08FF     ; N  # Mn    [29] ARABIC TURNED DAMMA BELOW..ARABIC MARK SIDEWAYS NOON GHUNNA
+0900..0902     ; N  # Mn     [3] DEVANAGARI SIGN INVERTED CANDRABINDU..DEVANAGARI SIGN ANUSVARA
+0903           ; N  # Mc         DEVANAGARI SIGN VISARGA
+0904..0939     ; N  # Lo    [54] DEVANAGARI LETTER SHORT A..DEVANAGARI LETTER HA
+093A           ; N  # Mn         DEVANAGARI VOWEL SIGN OE
+093B           ; N  # Mc         DEVANAGARI VOWEL SIGN OOE
+093C           ; N  # Mn         DEVANAGARI SIGN NUKTA
+093D           ; N  # Lo         DEVANAGARI SIGN AVAGRAHA
+093E..0940     ; N  # Mc     [3] DEVANAGARI VOWEL SIGN AA..DEVANAGARI VOWEL SIGN II
+0941..0948     ; N  # Mn     [8] DEVANAGARI VOWEL SIGN U..DEVANAGARI VOWEL SIGN AI
+0949..094C     ; N  # Mc     [4] DEVANAGARI VOWEL SIGN CANDRA O..DEVANAGARI VOWEL SIGN AU
+094D           ; N  # Mn         DEVANAGARI SIGN VIRAMA
+094E..094F     ; N  # Mc     [2] DEVANAGARI VOWEL SIGN PRISHTHAMATRA E..DEVANAGARI VOWEL SIGN AW
+0950           ; N  # Lo         DEVANAGARI OM
+0951..0957     ; N  # Mn     [7] DEVANAGARI STRESS SIGN UDATTA..DEVANAGARI VOWEL SIGN UUE
+0958..0961     ; N  # Lo    [10] DEVANAGARI LETTER QA..DEVANAGARI LETTER VOCALIC LL
+0962..0963     ; N  # Mn     [2] DEVANAGARI VOWEL SIGN VOCALIC L..DEVANAGARI VOWEL SIGN VOCALIC LL
+0964..0965     ; N  # Po     [2] DEVANAGARI DANDA..DEVANAGARI DOUBLE DANDA
+0966..096F     ; N  # Nd    [10] DEVANAGARI DIGIT ZERO..DEVANAGARI DIGIT NINE
+0970           ; N  # Po         DEVANAGARI ABBREVIATION SIGN
+0971           ; N  # Lm         DEVANAGARI SIGN HIGH SPACING DOT
+0972..097F     ; N  # Lo    [14] DEVANAGARI LETTER CANDRA A..DEVANAGARI LETTER BBA
+0980           ; N  # Lo         BENGALI ANJI
+0981           ; N  # Mn         BENGALI SIGN CANDRABINDU
+0982..0983     ; N  # Mc     [2] BENGALI SIGN ANUSVARA..BENGALI SIGN VISARGA
+0985..098C     ; N  # Lo     [8] BENGALI LETTER A..BENGALI LETTER VOCALIC L
+098F..0990     ; N  # Lo     [2] BENGALI LETTER E..BENGALI LETTER AI
+0993..09A8     ; N  # Lo    [22] BENGALI LETTER O..BENGALI LETTER NA
+09AA..09B0     ; N  # Lo     [7] BENGALI LETTER PA..BENGALI LETTER RA
+09B2           ; N  # Lo         BENGALI LETTER LA
+09B6..09B9     ; N  # Lo     [4] BENGALI LETTER SHA..BENGALI LETTER HA
+09BC           ; N  # Mn         BENGALI SIGN NUKTA
+09BD           ; N  # Lo         BENGALI SIGN AVAGRAHA
+09BE..09C0     ; N  # Mc     [3] BENGALI VOWEL SIGN AA..BENGALI VOWEL SIGN II
+09C1..09C4     ; N  # Mn     [4] BENGALI VOWEL SIGN U..BENGALI VOWEL SIGN VOCALIC RR
+09C7..09C8     ; N  # Mc     [2] BENGALI VOWEL SIGN E..BENGALI VOWEL SIGN AI
+09CB..09CC     ; N  # Mc     [2] BENGALI VOWEL SIGN O..BENGALI VOWEL SIGN AU
+09CD           ; N  # Mn         BENGALI SIGN VIRAMA
+09CE           ; N  # Lo         BENGALI LETTER KHANDA TA
+09D7           ; N  # Mc         BENGALI AU LENGTH MARK
+09DC..09DD     ; N  # Lo     [2] BENGALI LETTER RRA..BENGALI LETTER RHA
+09DF..09E1     ; N  # Lo     [3] BENGALI LETTER YYA..BENGALI LETTER VOCALIC LL
+09E2..09E3     ; N  # Mn     [2] BENGALI VOWEL SIGN VOCALIC L..BENGALI VOWEL SIGN VOCALIC LL
+09E6..09EF     ; N  # Nd    [10] BENGALI DIGIT ZERO..BENGALI DIGIT NINE
+09F0..09F1     ; N  # Lo     [2] BENGALI LETTER RA WITH MIDDLE DIAGONAL..BENGALI LETTER RA WITH LOWER DIAGONAL
+09F2..09F3     ; N  # Sc     [2] BENGALI RUPEE MARK..BENGALI RUPEE SIGN
+09F4..09F9     ; N  # No     [6] BENGALI CURRENCY NUMERATOR ONE..BENGALI CURRENCY DENOMINATOR SIXTEEN
+09FA           ; N  # So         BENGALI ISSHAR
+09FB           ; N  # Sc         BENGALI GANDA MARK
+09FC           ; N  # Lo         BENGALI LETTER VEDIC ANUSVARA
+09FD           ; N  # Po         BENGALI ABBREVIATION SIGN
+09FE           ; N  # Mn         BENGALI SANDHI MARK
+0A01..0A02     ; N  # Mn     [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI SIGN BINDI
+0A03           ; N  # Mc         GURMUKHI SIGN VISARGA
+0A05..0A0A     ; N  # Lo     [6] GURMUKHI LETTER A..GURMUKHI LETTER UU
+0A0F..0A10     ; N  # Lo     [2] GURMUKHI LETTER EE..GURMUKHI LETTER AI
+0A13..0A28     ; N  # Lo    [22] GURMUKHI LETTER OO..GURMUKHI LETTER NA
+0A2A..0A30     ; N  # Lo     [7] GURMUKHI LETTER PA..GURMUKHI LETTER RA
+0A32..0A33     ; N  # Lo     [2] GURMUKHI LETTER LA..GURMUKHI LETTER LLA
+0A35..0A36     ; N  # Lo     [2] GURMUKHI LETTER VA..GURMUKHI LETTER SHA
+0A38..0A39     ; N  # Lo     [2] GURMUKHI LETTER SA..GURMUKHI LETTER HA
+0A3C           ; N  # Mn         GURMUKHI SIGN NUKTA
+0A3E..0A40     ; N  # Mc     [3] GURMUKHI VOWEL SIGN AA..GURMUKHI VOWEL SIGN II
+0A41..0A42     ; N  # Mn     [2] GURMUKHI VOWEL SIGN U..GURMUKHI VOWEL SIGN UU
+0A47..0A48     ; N  # Mn     [2] GURMUKHI VOWEL SIGN EE..GURMUKHI VOWEL SIGN AI
+0A4B..0A4D     ; N  # Mn     [3] GURMUKHI VOWEL SIGN OO..GURMUKHI SIGN VIRAMA
+0A51           ; N  # Mn         GURMUKHI SIGN UDAAT
+0A59..0A5C     ; N  # Lo     [4] GURMUKHI LETTER KHHA..GURMUKHI LETTER RRA
+0A5E           ; N  # Lo         GURMUKHI LETTER FA
+0A66..0A6F     ; N  # Nd    [10] GURMUKHI DIGIT ZERO..GURMUKHI DIGIT NINE
+0A70..0A71     ; N  # Mn     [2] GURMUKHI TIPPI..GURMUKHI ADDAK
+0A72..0A74     ; N  # Lo     [3] GURMUKHI IRI..GURMUKHI EK ONKAR
+0A75           ; N  # Mn         GURMUKHI SIGN YAKASH
+0A76           ; N  # Po         GURMUKHI ABBREVIATION SIGN
+0A81..0A82     ; N  # Mn     [2] GUJARATI SIGN CANDRABINDU..GUJARATI SIGN ANUSVARA
+0A83           ; N  # Mc         GUJARATI SIGN VISARGA
+0A85..0A8D     ; N  # Lo     [9] GUJARATI LETTER A..GUJARATI VOWEL CANDRA E
+0A8F..0A91     ; N  # Lo     [3] GUJARATI LETTER E..GUJARATI VOWEL CANDRA O
+0A93..0AA8     ; N  # Lo    [22] GUJARATI LETTER O..GUJARATI LETTER NA
+0AAA..0AB0     ; N  # Lo     [7] GUJARATI LETTER PA..GUJARATI LETTER RA
+0AB2..0AB3     ; N  # Lo     [2] GUJARATI LETTER LA..GUJARATI LETTER LLA
+0AB5..0AB9     ; N  # Lo     [5] GUJARATI LETTER VA..GUJARATI LETTER HA
+0ABC           ; N  # Mn         GUJARATI SIGN NUKTA
+0ABD           ; N  # Lo         GUJARATI SIGN AVAGRAHA
+0ABE..0AC0     ; N  # Mc     [3] GUJARATI VOWEL SIGN AA..GUJARATI VOWEL SIGN II
+0AC1..0AC5     ; N  # Mn     [5] GUJARATI VOWEL SIGN U..GUJARATI VOWEL SIGN CANDRA E
+0AC7..0AC8     ; N  # Mn     [2] GUJARATI VOWEL SIGN E..GUJARATI VOWEL SIGN AI
+0AC9           ; N  # Mc         GUJARATI VOWEL SIGN CANDRA O
+0ACB..0ACC     ; N  # Mc     [2] GUJARATI VOWEL SIGN O..GUJARATI VOWEL SIGN AU
+0ACD           ; N  # Mn         GUJARATI SIGN VIRAMA
+0AD0           ; N  # Lo         GUJARATI OM
+0AE0..0AE1     ; N  # Lo     [2] GUJARATI LETTER VOCALIC RR..GUJARATI LETTER VOCALIC LL
+0AE2..0AE3     ; N  # Mn     [2] GUJARATI VOWEL SIGN VOCALIC L..GUJARATI VOWEL SIGN VOCALIC LL
+0AE6..0AEF     ; N  # Nd    [10] GUJARATI DIGIT ZERO..GUJARATI DIGIT NINE
+0AF0           ; N  # Po         GUJARATI ABBREVIATION SIGN
+0AF1           ; N  # Sc         GUJARATI RUPEE SIGN
+0AF9           ; N  # Lo         GUJARATI LETTER ZHA
+0AFA..0AFF     ; N  # Mn     [6] GUJARATI SIGN SUKUN..GUJARATI SIGN TWO-CIRCLE NUKTA ABOVE
+0B01           ; N  # Mn         ORIYA SIGN CANDRABINDU
+0B02..0B03     ; N  # Mc     [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VISARGA
+0B05..0B0C     ; N  # Lo     [8] ORIYA LETTER A..ORIYA LETTER VOCALIC L
+0B0F..0B10     ; N  # Lo     [2] ORIYA LETTER E..ORIYA LETTER AI
+0B13..0B28     ; N  # Lo    [22] ORIYA LETTER O..ORIYA LETTER NA
+0B2A..0B30     ; N  # Lo     [7] ORIYA LETTER PA..ORIYA LETTER RA
+0B32..0B33     ; N  # Lo     [2] ORIYA LETTER LA..ORIYA LETTER LLA
+0B35..0B39     ; N  # Lo     [5] ORIYA LETTER VA..ORIYA LETTER HA
+0B3C           ; N  # Mn         ORIYA SIGN NUKTA
+0B3D           ; N  # Lo         ORIYA SIGN AVAGRAHA
+0B3E           ; N  # Mc         ORIYA VOWEL SIGN AA
+0B3F           ; N  # Mn         ORIYA VOWEL SIGN I
+0B40           ; N  # Mc         ORIYA VOWEL SIGN II
+0B41..0B44     ; N  # Mn     [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SIGN VOCALIC RR
+0B47..0B48     ; N  # Mc     [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SIGN AI
+0B4B..0B4C     ; N  # Mc     [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SIGN AU
+0B4D           ; N  # Mn         ORIYA SIGN VIRAMA
+0B55..0B56     ; N  # Mn     [2] ORIYA SIGN OVERLINE..ORIYA AI LENGTH MARK
+0B57           ; N  # Mc         ORIYA AU LENGTH MARK
+0B5C..0B5D     ; N  # Lo     [2] ORIYA LETTER RRA..ORIYA LETTER RHA
+0B5F..0B61     ; N  # Lo     [3] ORIYA LETTER YYA..ORIYA LETTER VOCALIC LL
+0B62..0B63     ; N  # Mn     [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA VOWEL SIGN VOCALIC LL
+0B66..0B6F     ; N  # Nd    [10] ORIYA DIGIT ZERO..ORIYA DIGIT NINE
+0B70           ; N  # So         ORIYA ISSHAR
+0B71           ; N  # Lo         ORIYA LETTER WA
+0B72..0B77     ; N  # No     [6] ORIYA FRACTION ONE QUARTER..ORIYA FRACTION THREE SIXTEENTHS
+0B82           ; N  # Mn         TAMIL SIGN ANUSVARA
+0B83           ; N  # Lo         TAMIL SIGN VISARGA
+0B85..0B8A     ; N  # Lo     [6] TAMIL LETTER A..TAMIL LETTER UU
+0B8E..0B90     ; N  # Lo     [3] TAMIL LETTER E..TAMIL LETTER AI
+0B92..0B95     ; N  # Lo     [4] TAMIL LETTER O..TAMIL LETTER KA
+0B99..0B9A     ; N  # Lo     [2] TAMIL LETTER NGA..TAMIL LETTER CA
+0B9C           ; N  # Lo         TAMIL LETTER JA
+0B9E..0B9F     ; N  # Lo     [2] TAMIL LETTER NYA..TAMIL LETTER TTA
+0BA3..0BA4     ; N  # Lo     [2] TAMIL LETTER NNA..TAMIL LETTER TA
+0BA8..0BAA     ; N  # Lo     [3] TAMIL LETTER NA..TAMIL LETTER PA
+0BAE..0BB9     ; N  # Lo    [12] TAMIL LETTER MA..TAMIL LETTER HA
+0BBE..0BBF     ; N  # Mc     [2] TAMIL VOWEL SIGN AA..TAMIL VOWEL SIGN I
+0BC0           ; N  # Mn         TAMIL VOWEL SIGN II
+0BC1..0BC2     ; N  # Mc     [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SIGN UU
+0BC6..0BC8     ; N  # Mc     [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SIGN AI
+0BCA..0BCC     ; N  # Mc     [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SIGN AU
+0BCD           ; N  # Mn         TAMIL SIGN VIRAMA
+0BD0           ; N  # Lo         TAMIL OM
+0BD7           ; N  # Mc         TAMIL AU LENGTH MARK
+0BE6..0BEF     ; N  # Nd    [10] TAMIL DIGIT ZERO..TAMIL DIGIT NINE
+0BF0..0BF2     ; N  # No     [3] TAMIL NUMBER TEN..TAMIL NUMBER ONE THOUSAND
+0BF3..0BF8     ; N  # So     [6] TAMIL DAY SIGN..TAMIL AS ABOVE SIGN
+0BF9           ; N  # Sc         TAMIL RUPEE SIGN
+0BFA           ; N  # So         TAMIL NUMBER SIGN
+0C00           ; N  # Mn         TELUGU SIGN COMBINING CANDRABINDU ABOVE
+0C01..0C03     ; N  # Mc     [3] TELUGU SIGN CANDRABINDU..TELUGU SIGN VISARGA
+0C04           ; N  # Mn         TELUGU SIGN COMBINING ANUSVARA ABOVE
+0C05..0C0C     ; N  # Lo     [8] TELUGU LETTER A..TELUGU LETTER VOCALIC L
+0C0E..0C10     ; N  # Lo     [3] TELUGU LETTER E..TELUGU LETTER AI
+0C12..0C28     ; N  # Lo    [23] TELUGU LETTER O..TELUGU LETTER NA
+0C2A..0C39     ; N  # Lo    [16] TELUGU LETTER PA..TELUGU LETTER HA
+0C3C           ; N  # Mn         TELUGU SIGN NUKTA
+0C3D           ; N  # Lo         TELUGU SIGN AVAGRAHA
+0C3E..0C40     ; N  # Mn     [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL SIGN II
+0C41..0C44     ; N  # Mc     [4] TELUGU VOWEL SIGN U..TELUGU VOWEL SIGN VOCALIC RR
+0C46..0C48     ; N  # Mn     [3] TELUGU VOWEL SIGN E..TELUGU VOWEL SIGN AI
+0C4A..0C4D     ; N  # Mn     [4] TELUGU VOWEL SIGN O..TELUGU SIGN VIRAMA
+0C55..0C56     ; N  # Mn     [2] TELUGU LENGTH MARK..TELUGU AI LENGTH MARK
+0C58..0C5A     ; N  # Lo     [3] TELUGU LETTER TSA..TELUGU LETTER RRRA
+0C5D           ; N  # Lo         TELUGU LETTER NAKAARA POLLU
+0C60..0C61     ; N  # Lo     [2] TELUGU LETTER VOCALIC RR..TELUGU LETTER VOCALIC LL
+0C62..0C63     ; N  # Mn     [2] TELUGU VOWEL SIGN VOCALIC L..TELUGU VOWEL SIGN VOCALIC LL
+0C66..0C6F     ; N  # Nd    [10] TELUGU DIGIT ZERO..TELUGU DIGIT NINE
+0C77           ; N  # Po         TELUGU SIGN SIDDHAM
+0C78..0C7E     ; N  # No     [7] TELUGU FRACTION DIGIT ZERO FOR ODD POWERS OF FOUR..TELUGU FRACTION DIGIT THREE FOR EVEN POWERS OF FOUR
+0C7F           ; N  # So         TELUGU SIGN TUUMU
+0C80           ; N  # Lo         KANNADA SIGN SPACING CANDRABINDU
+0C81           ; N  # Mn         KANNADA SIGN CANDRABINDU
+0C82..0C83     ; N  # Mc     [2] KANNADA SIGN ANUSVARA..KANNADA SIGN VISARGA
+0C84           ; N  # Po         KANNADA SIGN SIDDHAM
+0C85..0C8C     ; N  # Lo     [8] KANNADA LETTER A..KANNADA LETTER VOCALIC L
+0C8E..0C90     ; N  # Lo     [3] KANNADA LETTER E..KANNADA LETTER AI
+0C92..0CA8     ; N  # Lo    [23] KANNADA LETTER O..KANNADA LETTER NA
+0CAA..0CB3     ; N  # Lo    [10] KANNADA LETTER PA..KANNADA LETTER LLA
+0CB5..0CB9     ; N  # Lo     [5] KANNADA LETTER VA..KANNADA LETTER HA
+0CBC           ; N  # Mn         KANNADA SIGN NUKTA
+0CBD           ; N  # Lo         KANNADA SIGN AVAGRAHA
+0CBE           ; N  # Mc         KANNADA VOWEL SIGN AA
+0CBF           ; N  # Mn         KANNADA VOWEL SIGN I
+0CC0..0CC4     ; N  # Mc     [5] KANNADA VOWEL SIGN II..KANNADA VOWEL SIGN VOCALIC RR
+0CC6           ; N  # Mn         KANNADA VOWEL SIGN E
+0CC7..0CC8     ; N  # Mc     [2] KANNADA VOWEL SIGN EE..KANNADA VOWEL SIGN AI
+0CCA..0CCB     ; N  # Mc     [2] KANNADA VOWEL SIGN O..KANNADA VOWEL SIGN OO
+0CCC..0CCD     ; N  # Mn     [2] KANNADA VOWEL SIGN AU..KANNADA SIGN VIRAMA
+0CD5..0CD6     ; N  # Mc     [2] KANNADA LENGTH MARK..KANNADA AI LENGTH MARK
+0CDD..0CDE     ; N  # Lo     [2] KANNADA LETTER NAKAARA POLLU..KANNADA LETTER FA
+0CE0..0CE1     ; N  # Lo     [2] KANNADA LETTER VOCALIC RR..KANNADA LETTER VOCALIC LL
+0CE2..0CE3     ; N  # Mn     [2] KANNADA VOWEL SIGN VOCALIC L..KANNADA VOWEL SIGN VOCALIC LL
+0CE6..0CEF     ; N  # Nd    [10] KANNADA DIGIT ZERO..KANNADA DIGIT NINE
+0CF1..0CF2     ; N  # Lo     [2] KANNADA SIGN JIHVAMULIYA..KANNADA SIGN UPADHMANIYA
+0CF3           ; N  # Mc         KANNADA SIGN COMBINING ANUSVARA ABOVE RIGHT
+0D00..0D01     ; N  # Mn     [2] MALAYALAM SIGN COMBINING ANUSVARA ABOVE..MALAYALAM SIGN CANDRABINDU
+0D02..0D03     ; N  # Mc     [2] MALAYALAM SIGN ANUSVARA..MALAYALAM SIGN VISARGA
+0D04..0D0C     ; N  # Lo     [9] MALAYALAM LETTER VEDIC ANUSVARA..MALAYALAM LETTER VOCALIC L
+0D0E..0D10     ; N  # Lo     [3] MALAYALAM LETTER E..MALAYALAM LETTER AI
+0D12..0D3A     ; N  # Lo    [41] MALAYALAM LETTER O..MALAYALAM LETTER TTTA
+0D3B..0D3C     ; N  # Mn     [2] MALAYALAM SIGN VERTICAL BAR VIRAMA..MALAYALAM SIGN CIRCULAR VIRAMA
+0D3D           ; N  # Lo         MALAYALAM SIGN AVAGRAHA
+0D3E..0D40     ; N  # Mc     [3] MALAYALAM VOWEL SIGN AA..MALAYALAM VOWEL SIGN II
+0D41..0D44     ; N  # Mn     [4] MALAYALAM VOWEL SIGN U..MALAYALAM VOWEL SIGN VOCALIC RR
+0D46..0D48     ; N  # Mc     [3] MALAYALAM VOWEL SIGN E..MALAYALAM VOWEL SIGN AI
+0D4A..0D4C     ; N  # Mc     [3] MALAYALAM VOWEL SIGN O..MALAYALAM VOWEL SIGN AU
+0D4D           ; N  # Mn         MALAYALAM SIGN VIRAMA
+0D4E           ; N  # Lo         MALAYALAM LETTER DOT REPH
+0D4F           ; N  # So         MALAYALAM SIGN PARA
+0D54..0D56     ; N  # Lo     [3] MALAYALAM LETTER CHILLU M..MALAYALAM LETTER CHILLU LLL
+0D57           ; N  # Mc         MALAYALAM AU LENGTH MARK
+0D58..0D5E     ; N  # No     [7] MALAYALAM FRACTION ONE ONE-HUNDRED-AND-SIXTIETH..MALAYALAM FRACTION ONE FIFTH
+0D5F..0D61     ; N  # Lo     [3] MALAYALAM LETTER ARCHAIC II..MALAYALAM LETTER VOCALIC LL
+0D62..0D63     ; N  # Mn     [2] MALAYALAM VOWEL SIGN VOCALIC L..MALAYALAM VOWEL SIGN VOCALIC LL
+0D66..0D6F     ; N  # Nd    [10] MALAYALAM DIGIT ZERO..MALAYALAM DIGIT NINE
+0D70..0D78     ; N  # No     [9] MALAYALAM NUMBER TEN..MALAYALAM FRACTION THREE SIXTEENTHS
+0D79           ; N  # So         MALAYALAM DATE MARK
+0D7A..0D7F     ; N  # Lo     [6] MALAYALAM LETTER CHILLU NN..MALAYALAM LETTER CHILLU K
+0D81           ; N  # Mn         SINHALA SIGN CANDRABINDU
+0D82..0D83     ; N  # Mc     [2] SINHALA SIGN ANUSVARAYA..SINHALA SIGN VISARGAYA
+0D85..0D96     ; N  # Lo    [18] SINHALA LETTER AYANNA..SINHALA LETTER AUYANNA
+0D9A..0DB1     ; N  # Lo    [24] SINHALA LETTER ALPAPRAANA KAYANNA..SINHALA LETTER DANTAJA NAYANNA
+0DB3..0DBB     ; N  # Lo     [9] SINHALA LETTER SANYAKA DAYANNA..SINHALA LETTER RAYANNA
+0DBD           ; N  # Lo         SINHALA LETTER DANTAJA LAYANNA
+0DC0..0DC6     ; N  # Lo     [7] SINHALA LETTER VAYANNA..SINHALA LETTER FAYANNA
+0DCA           ; N  # Mn         SINHALA SIGN AL-LAKUNA
+0DCF..0DD1     ; N  # Mc     [3] SINHALA VOWEL SIGN AELA-PILLA..SINHALA VOWEL SIGN DIGA AEDA-PILLA
+0DD2..0DD4     ; N  # Mn     [3] SINHALA VOWEL SIGN KETTI IS-PILLA..SINHALA VOWEL SIGN KETTI PAA-PILLA
+0DD6           ; N  # Mn         SINHALA VOWEL SIGN DIGA PAA-PILLA
+0DD8..0DDF     ; N  # Mc     [8] SINHALA VOWEL SIGN GAETTA-PILLA..SINHALA VOWEL SIGN GAYANUKITTA
+0DE6..0DEF     ; N  # Nd    [10] SINHALA LITH DIGIT ZERO..SINHALA LITH DIGIT NINE
+0DF2..0DF3     ; N  # Mc     [2] SINHALA VOWEL SIGN DIGA GAETTA-PILLA..SINHALA VOWEL SIGN DIGA GAYANUKITTA
+0DF4           ; N  # Po         SINHALA PUNCTUATION KUNDDALIYA
+0E01..0E30     ; N  # Lo    [48] THAI CHARACTER KO KAI..THAI CHARACTER SARA A
+0E31           ; N  # Mn         THAI CHARACTER MAI HAN-AKAT
+0E32..0E33     ; N  # Lo     [2] THAI CHARACTER SARA AA..THAI CHARACTER SARA AM
+0E34..0E3A     ; N  # Mn     [7] THAI CHARACTER SARA I..THAI CHARACTER PHINTHU
+0E3F           ; N  # Sc         THAI CURRENCY SYMBOL BAHT
+0E40..0E45     ; N  # Lo     [6] THAI CHARACTER SARA E..THAI CHARACTER LAKKHANGYAO
+0E46           ; N  # Lm         THAI CHARACTER MAIYAMOK
+0E47..0E4E     ; N  # Mn     [8] THAI CHARACTER MAITAIKHU..THAI CHARACTER YAMAKKAN
+0E4F           ; N  # Po         THAI CHARACTER FONGMAN
+0E50..0E59     ; N  # Nd    [10] THAI DIGIT ZERO..THAI DIGIT NINE
+0E5A..0E5B     ; N  # Po     [2] THAI CHARACTER ANGKHANKHU..THAI CHARACTER KHOMUT
+0E81..0E82     ; N  # Lo     [2] LAO LETTER KO..LAO LETTER KHO SUNG
+0E84           ; N  # Lo         LAO LETTER KHO TAM
+0E86..0E8A     ; N  # Lo     [5] LAO LETTER PALI GHA..LAO LETTER SO TAM
+0E8C..0EA3     ; N  # Lo    [24] LAO LETTER PALI JHA..LAO LETTER LO LING
+0EA5           ; N  # Lo         LAO LETTER LO LOOT
+0EA7..0EB0     ; N  # Lo    [10] LAO LETTER WO..LAO VOWEL SIGN A
+0EB1           ; N  # Mn         LAO VOWEL SIGN MAI KAN
+0EB2..0EB3     ; N  # Lo     [2] LAO VOWEL SIGN AA..LAO VOWEL SIGN AM
+0EB4..0EBC     ; N  # Mn     [9] LAO VOWEL SIGN I..LAO SEMIVOWEL SIGN LO
+0EBD           ; N  # Lo         LAO SEMIVOWEL SIGN NYO
+0EC0..0EC4     ; N  # Lo     [5] LAO VOWEL SIGN E..LAO VOWEL SIGN AI
+0EC6           ; N  # Lm         LAO KO LA
+0EC8..0ECE     ; N  # Mn     [7] LAO TONE MAI EK..LAO YAMAKKAN
+0ED0..0ED9     ; N  # Nd    [10] LAO DIGIT ZERO..LAO DIGIT NINE
+0EDC..0EDF     ; N  # Lo     [4] LAO HO NO..LAO LETTER KHMU NYO
+0F00           ; N  # Lo         TIBETAN SYLLABLE OM
+0F01..0F03     ; N  # So     [3] TIBETAN MARK GTER YIG MGO TRUNCATED A..TIBETAN MARK GTER YIG MGO -UM GTER TSHEG MA
+0F04..0F12     ; N  # Po    [15] TIBETAN MARK INITIAL YIG MGO MDUN MA..TIBETAN MARK RGYA GRAM SHAD
+0F13           ; N  # So         TIBETAN MARK CARET -DZUD RTAGS ME LONG CAN
+0F14           ; N  # Po         TIBETAN MARK GTER TSHEG
+0F15..0F17     ; N  # So     [3] TIBETAN LOGOTYPE SIGN CHAD RTAGS..TIBETAN ASTROLOGICAL SIGN SGRA GCAN -CHAR RTAGS
+0F18..0F19     ; N  # Mn     [2] TIBETAN ASTROLOGICAL SIGN -KHYUD PA..TIBETAN ASTROLOGICAL SIGN SDONG TSHUGS
+0F1A..0F1F     ; N  # So     [6] TIBETAN SIGN RDEL DKAR GCIG..TIBETAN SIGN RDEL DKAR RDEL NAG
+0F20..0F29     ; N  # Nd    [10] TIBETAN DIGIT ZERO..TIBETAN DIGIT NINE
+0F2A..0F33     ; N  # No    [10] TIBETAN DIGIT HALF ONE..TIBETAN DIGIT HALF ZERO
+0F34           ; N  # So         TIBETAN MARK BSDUS RTAGS
+0F35           ; N  # Mn         TIBETAN MARK NGAS BZUNG NYI ZLA
+0F36           ; N  # So         TIBETAN MARK CARET -DZUD RTAGS BZHI MIG CAN
+0F37           ; N  # Mn         TIBETAN MARK NGAS BZUNG SGOR RTAGS
+0F38           ; N  # So         TIBETAN MARK CHE MGO
+0F39           ; N  # Mn         TIBETAN MARK TSA -PHRU
+0F3A           ; N  # Ps         TIBETAN MARK GUG RTAGS GYON
+0F3B           ; N  # Pe         TIBETAN MARK GUG RTAGS GYAS
+0F3C           ; N  # Ps         TIBETAN MARK ANG KHANG GYON
+0F3D           ; N  # Pe         TIBETAN MARK ANG KHANG GYAS
+0F3E..0F3F     ; N  # Mc     [2] TIBETAN SIGN YAR TSHES..TIBETAN SIGN MAR TSHES
+0F40..0F47     ; N  # Lo     [8] TIBETAN LETTER KA..TIBETAN LETTER JA
+0F49..0F6C     ; N  # Lo    [36] TIBETAN LETTER NYA..TIBETAN LETTER RRA
+0F71..0F7E     ; N  # Mn    [14] TIBETAN VOWEL SIGN AA..TIBETAN SIGN RJES SU NGA RO
+0F7F           ; N  # Mc         TIBETAN SIGN RNAM BCAD
+0F80..0F84     ; N  # Mn     [5] TIBETAN VOWEL SIGN REVERSED I..TIBETAN MARK HALANTA
+0F85           ; N  # Po         TIBETAN MARK PALUTA
+0F86..0F87     ; N  # Mn     [2] TIBETAN SIGN LCI RTAGS..TIBETAN SIGN YANG RTAGS
+0F88..0F8C     ; N  # Lo     [5] TIBETAN SIGN LCE TSA CAN..TIBETAN SIGN INVERTED MCHU CAN
+0F8D..0F97     ; N  # Mn    [11] TIBETAN SUBJOINED SIGN LCE TSA CAN..TIBETAN SUBJOINED LETTER JA
+0F99..0FBC     ; N  # Mn    [36] TIBETAN SUBJOINED LETTER NYA..TIBETAN SUBJOINED LETTER FIXED-FORM RA
+0FBE..0FC5     ; N  # So     [8] TIBETAN KU RU KHA..TIBETAN SYMBOL RDO RJE
+0FC6           ; N  # Mn         TIBETAN SYMBOL PADMA GDAN
+0FC7..0FCC     ; N  # So     [6] TIBETAN SYMBOL RDO RJE RGYA GRAM..TIBETAN SYMBOL NOR BU BZHI -KHYIL
+0FCE..0FCF     ; N  # So     [2] TIBETAN SIGN RDEL NAG RDEL DKAR..TIBETAN SIGN RDEL NAG GSUM
+0FD0..0FD4     ; N  # Po     [5] TIBETAN MARK BSKA- SHOG GI MGO RGYAN..TIBETAN MARK CLOSING BRDA RNYING YIG MGO SGAB MA
+0FD5..0FD8     ; N  # So     [4] RIGHT-FACING SVASTI SIGN..LEFT-FACING SVASTI SIGN WITH DOTS
+0FD9..0FDA     ; N  # Po     [2] TIBETAN MARK LEADING MCHAN RTAGS..TIBETAN MARK TRAILING MCHAN RTAGS
+1000..102A     ; N  # Lo    [43] MYANMAR LETTER KA..MYANMAR LETTER AU
+102B..102C     ; N  # Mc     [2] MYANMAR VOWEL SIGN TALL AA..MYANMAR VOWEL SIGN AA
+102D..1030     ; N  # Mn     [4] MYANMAR VOWEL SIGN I..MYANMAR VOWEL SIGN UU
+1031           ; N  # Mc         MYANMAR VOWEL SIGN E
+1032..1037     ; N  # Mn     [6] MYANMAR VOWEL SIGN AI..MYANMAR SIGN DOT BELOW
+1038           ; N  # Mc         MYANMAR SIGN VISARGA
+1039..103A     ; N  # Mn     [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ASAT
+103B..103C     ; N  # Mc     [2] MYANMAR CONSONANT SIGN MEDIAL YA..MYANMAR CONSONANT SIGN MEDIAL RA
+103D..103E     ; N  # Mn     [2] MYANMAR CONSONANT SIGN MEDIAL WA..MYANMAR CONSONANT SIGN MEDIAL HA
+103F           ; N  # Lo         MYANMAR LETTER GREAT SA
+1040..1049     ; N  # Nd    [10] MYANMAR DIGIT ZERO..MYANMAR DIGIT NINE
+104A..104F     ; N  # Po     [6] MYANMAR SIGN LITTLE SECTION..MYANMAR SYMBOL GENITIVE
+1050..1055     ; N  # Lo     [6] MYANMAR LETTER SHA..MYANMAR LETTER VOCALIC LL
+1056..1057     ; N  # Mc     [2] MYANMAR VOWEL SIGN VOCALIC R..MYANMAR VOWEL SIGN VOCALIC RR
+1058..1059     ; N  # Mn     [2] MYANMAR VOWEL SIGN VOCALIC L..MYANMAR VOWEL SIGN VOCALIC LL
+105A..105D     ; N  # Lo     [4] MYANMAR LETTER MON NGA..MYANMAR LETTER MON BBE
+105E..1060     ; N  # Mn     [3] MYANMAR CONSONANT SIGN MON MEDIAL NA..MYANMAR CONSONANT SIGN MON MEDIAL LA
+1061           ; N  # Lo         MYANMAR LETTER SGAW KAREN SHA
+1062..1064     ; N  # Mc     [3] MYANMAR VOWEL SIGN SGAW KAREN EU..MYANMAR TONE MARK SGAW KAREN KE PHO
+1065..1066     ; N  # Lo     [2] MYANMAR LETTER WESTERN PWO KAREN THA..MYANMAR LETTER WESTERN PWO KAREN PWA
+1067..106D     ; N  # Mc     [7] MYANMAR VOWEL SIGN WESTERN PWO KAREN EU..MYANMAR SIGN WESTERN PWO KAREN TONE-5
+106E..1070     ; N  # Lo     [3] MYANMAR LETTER EASTERN PWO KAREN NNA..MYANMAR LETTER EASTERN PWO KAREN GHWA
+1071..1074     ; N  # Mn     [4] MYANMAR VOWEL SIGN GEBA KAREN I..MYANMAR VOWEL SIGN KAYAH EE
+1075..1081     ; N  # Lo    [13] MYANMAR LETTER SHAN KA..MYANMAR LETTER SHAN HA
+1082           ; N  # Mn         MYANMAR CONSONANT SIGN SHAN MEDIAL WA
+1083..1084     ; N  # Mc     [2] MYANMAR VOWEL SIGN SHAN AA..MYANMAR VOWEL SIGN SHAN E
+1085..1086     ; N  # Mn     [2] MYANMAR VOWEL SIGN SHAN E ABOVE..MYANMAR VOWEL SIGN SHAN FINAL Y
+1087..108C     ; N  # Mc     [6] MYANMAR SIGN SHAN TONE-2..MYANMAR SIGN SHAN COUNCIL TONE-3
+108D           ; N  # Mn         MYANMAR SIGN SHAN COUNCIL EMPHATIC TONE
+108E           ; N  # Lo         MYANMAR LETTER RUMAI PALAUNG FA
+108F           ; N  # Mc         MYANMAR SIGN RUMAI PALAUNG TONE-5
+1090..1099     ; N  # Nd    [10] MYANMAR SHAN DIGIT ZERO..MYANMAR SHAN DIGIT NINE
+109A..109C     ; N  # Mc     [3] MYANMAR SIGN KHAMTI TONE-1..MYANMAR VOWEL SIGN AITON A
+109D           ; N  # Mn         MYANMAR VOWEL SIGN AITON AI
+109E..109F     ; N  # So     [2] MYANMAR SYMBOL SHAN ONE..MYANMAR SYMBOL SHAN EXCLAMATION
+10A0..10C5     ; N  # Lu    [38] GEORGIAN CAPITAL LETTER AN..GEORGIAN CAPITAL LETTER HOE
+10C7           ; N  # Lu         GEORGIAN CAPITAL LETTER YN
+10CD           ; N  # Lu         GEORGIAN CAPITAL LETTER AEN
+10D0..10FA     ; N  # Ll    [43] GEORGIAN LETTER AN..GEORGIAN LETTER AIN
+10FB           ; N  # Po         GEORGIAN PARAGRAPH SEPARATOR
+10FC           ; N  # Lm         MODIFIER LETTER GEORGIAN NAR
+10FD..10FF     ; N  # Ll     [3] GEORGIAN LETTER AEN..GEORGIAN LETTER LABIAL SIGN
+1100..115F     ; W  # Lo    [96] HANGUL CHOSEONG KIYEOK..HANGUL CHOSEONG FILLER
+1160..11FF     ; N  # Lo   [160] HANGUL JUNGSEONG FILLER..HANGUL JONGSEONG SSANGNIEUN
+1200..1248     ; N  # Lo    [73] ETHIOPIC SYLLABLE HA..ETHIOPIC SYLLABLE QWA
+124A..124D     ; N  # Lo     [4] ETHIOPIC SYLLABLE QWI..ETHIOPIC SYLLABLE QWE
+1250..1256     ; N  # Lo     [7] ETHIOPIC SYLLABLE QHA..ETHIOPIC SYLLABLE QHO
+1258           ; N  # Lo         ETHIOPIC SYLLABLE QHWA
+125A..125D     ; N  # Lo     [4] ETHIOPIC SYLLABLE QHWI..ETHIOPIC SYLLABLE QHWE
+1260..1288     ; N  # Lo    [41] ETHIOPIC SYLLABLE BA..ETHIOPIC SYLLABLE XWA
+128A..128D     ; N  # Lo     [4] ETHIOPIC SYLLABLE XWI..ETHIOPIC SYLLABLE XWE
+1290..12B0     ; N  # Lo    [33] ETHIOPIC SYLLABLE NA..ETHIOPIC SYLLABLE KWA
+12B2..12B5     ; N  # Lo     [4] ETHIOPIC SYLLABLE KWI..ETHIOPIC SYLLABLE KWE
+12B8..12BE     ; N  # Lo     [7] ETHIOPIC SYLLABLE KXA..ETHIOPIC SYLLABLE KXO
+12C0           ; N  # Lo         ETHIOPIC SYLLABLE KXWA
+12C2..12C5     ; N  # Lo     [4] ETHIOPIC SYLLABLE KXWI..ETHIOPIC SYLLABLE KXWE
+12C8..12D6     ; N  # Lo    [15] ETHIOPIC SYLLABLE WA..ETHIOPIC SYLLABLE PHARYNGEAL O
+12D8..1310     ; N  # Lo    [57] ETHIOPIC SYLLABLE ZA..ETHIOPIC SYLLABLE GWA
+1312..1315     ; N  # Lo     [4] ETHIOPIC SYLLABLE GWI..ETHIOPIC SYLLABLE GWE
+1318..135A     ; N  # Lo    [67] ETHIOPIC SYLLABLE GGA..ETHIOPIC SYLLABLE FYA
+135D..135F     ; N  # Mn     [3] ETHIOPIC COMBINING GEMINATION AND VOWEL LENGTH MARK..ETHIOPIC COMBINING GEMINATION MARK
+1360..1368     ; N  # Po     [9] ETHIOPIC SECTION MARK..ETHIOPIC PARAGRAPH SEPARATOR
+1369..137C     ; N  # No    [20] ETHIOPIC DIGIT ONE..ETHIOPIC NUMBER TEN THOUSAND
+1380..138F     ; N  # Lo    [16] ETHIOPIC SYLLABLE SEBATBEIT MWA..ETHIOPIC SYLLABLE PWE
+1390..1399     ; N  # So    [10] ETHIOPIC TONAL MARK YIZET..ETHIOPIC TONAL MARK KURT
+13A0..13F5     ; N  # Lu    [86] CHEROKEE LETTER A..CHEROKEE LETTER MV
+13F8..13FD     ; N  # Ll     [6] CHEROKEE SMALL LETTER YE..CHEROKEE SMALL LETTER MV
+1400           ; N  # Pd         CANADIAN SYLLABICS HYPHEN
+1401..166C     ; N  # Lo   [620] CANADIAN SYLLABICS E..CANADIAN SYLLABICS CARRIER TTSA
+166D           ; N  # So         CANADIAN SYLLABICS CHI SIGN
+166E           ; N  # Po         CANADIAN SYLLABICS FULL STOP
+166F..167F     ; N  # Lo    [17] CANADIAN SYLLABICS QAI..CANADIAN SYLLABICS BLACKFOOT W
+1680           ; N  # Zs         OGHAM SPACE MARK
+1681..169A     ; N  # Lo    [26] OGHAM LETTER BEITH..OGHAM LETTER PEITH
+169B           ; N  # Ps         OGHAM FEATHER MARK
+169C           ; N  # Pe         OGHAM REVERSED FEATHER MARK
+16A0..16EA     ; N  # Lo    [75] RUNIC LETTER FEHU FEOH FE F..RUNIC LETTER X
+16EB..16ED     ; N  # Po     [3] RUNIC SINGLE PUNCTUATION..RUNIC CROSS PUNCTUATION
+16EE..16F0     ; N  # Nl     [3] RUNIC ARLAUG SYMBOL..RUNIC BELGTHOR SYMBOL
+16F1..16F8     ; N  # Lo     [8] RUNIC LETTER K..RUNIC LETTER FRANKS CASKET AESC
+1700..1711     ; N  # Lo    [18] TAGALOG LETTER A..TAGALOG LETTER HA
+1712..1714     ; N  # Mn     [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN VIRAMA
+1715           ; N  # Mc         TAGALOG SIGN PAMUDPOD
+171F           ; N  # Lo         TAGALOG LETTER ARCHAIC RA
+1720..1731     ; N  # Lo    [18] HANUNOO LETTER A..HANUNOO LETTER HA
+1732..1733     ; N  # Mn     [2] HANUNOO VOWEL SIGN I..HANUNOO VOWEL SIGN U
+1734           ; N  # Mc         HANUNOO SIGN PAMUDPOD
+1735..1736     ; N  # Po     [2] PHILIPPINE SINGLE PUNCTUATION..PHILIPPINE DOUBLE PUNCTUATION
+1740..1751     ; N  # Lo    [18] BUHID LETTER A..BUHID LETTER HA
+1752..1753     ; N  # Mn     [2] BUHID VOWEL SIGN I..BUHID VOWEL SIGN U
+1760..176C     ; N  # Lo    [13] TAGBANWA LETTER A..TAGBANWA LETTER YA
+176E..1770     ; N  # Lo     [3] TAGBANWA LETTER LA..TAGBANWA LETTER SA
+1772..1773     ; N  # Mn     [2] TAGBANWA VOWEL SIGN I..TAGBANWA VOWEL SIGN U
+1780..17B3     ; N  # Lo    [52] KHMER LETTER KA..KHMER INDEPENDENT VOWEL QAU
+17B4..17B5     ; N  # Mn     [2] KHMER VOWEL INHERENT AQ..KHMER VOWEL INHERENT AA
+17B6           ; N  # Mc         KHMER VOWEL SIGN AA
+17B7..17BD     ; N  # Mn     [7] KHMER VOWEL SIGN I..KHMER VOWEL SIGN UA
+17BE..17C5     ; N  # Mc     [8] KHMER VOWEL SIGN OE..KHMER VOWEL SIGN AU
+17C6           ; N  # Mn         KHMER SIGN NIKAHIT
+17C7..17C8     ; N  # Mc     [2] KHMER SIGN REAHMUK..KHMER SIGN YUUKALEAPINTU
+17C9..17D3     ; N  # Mn    [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN BATHAMASAT
+17D4..17D6     ; N  # Po     [3] KHMER SIGN KHAN..KHMER SIGN CAMNUC PII KUUH
+17D7           ; N  # Lm         KHMER SIGN LEK TOO
+17D8..17DA     ; N  # Po     [3] KHMER SIGN BEYYAL..KHMER SIGN KOOMUUT
+17DB           ; N  # Sc         KHMER CURRENCY SYMBOL RIEL
+17DC           ; N  # Lo         KHMER SIGN AVAKRAHASANYA
+17DD           ; N  # Mn         KHMER SIGN ATTHACAN
+17E0..17E9     ; N  # Nd    [10] KHMER DIGIT ZERO..KHMER DIGIT NINE
+17F0..17F9     ; N  # No    [10] KHMER SYMBOL LEK ATTAK SON..KHMER SYMBOL LEK ATTAK PRAM-BUON
+1800..1805     ; N  # Po     [6] MONGOLIAN BIRGA..MONGOLIAN FOUR DOTS
+1806           ; N  # Pd         MONGOLIAN TODO SOFT HYPHEN
+1807..180A     ; N  # Po     [4] MONGOLIAN SIBE SYLLABLE BOUNDARY MARKER..MONGOLIAN NIRUGU
+180B..180D     ; N  # Mn     [3] MONGOLIAN FREE VARIATION SELECTOR ONE..MONGOLIAN FREE VARIATION SELECTOR THREE
+180E           ; N  # Cf         MONGOLIAN VOWEL SEPARATOR
+180F           ; N  # Mn         MONGOLIAN FREE VARIATION SELECTOR FOUR
+1810..1819     ; N  # Nd    [10] MONGOLIAN DIGIT ZERO..MONGOLIAN DIGIT NINE
+1820..1842     ; N  # Lo    [35] MONGOLIAN LETTER A..MONGOLIAN LETTER CHI
+1843           ; N  # Lm         MONGOLIAN LETTER TODO LONG VOWEL SIGN
+1844..1878     ; N  # Lo    [53] MONGOLIAN LETTER TODO E..MONGOLIAN LETTER CHA WITH TWO DOTS
+1880..1884     ; N  # Lo     [5] MONGOLIAN LETTER ALI GALI ANUSVARA ONE..MONGOLIAN LETTER ALI GALI INVERTED UBADAMA
+1885..1886     ; N  # Mn     [2] MONGOLIAN LETTER ALI GALI BALUDA..MONGOLIAN LETTER ALI GALI THREE BALUDA
+1887..18A8     ; N  # Lo    [34] MONGOLIAN LETTER ALI GALI A..MONGOLIAN LETTER MANCHU ALI GALI BHA
+18A9           ; N  # Mn         MONGOLIAN LETTER ALI GALI DAGALGA
+18AA           ; N  # Lo         MONGOLIAN LETTER MANCHU ALI GALI LHA
+18B0..18F5     ; N  # Lo    [70] CANADIAN SYLLABICS OY..CANADIAN SYLLABICS CARRIER DENTAL S
+1900..191E     ; N  # Lo    [31] LIMBU VOWEL-CARRIER LETTER..LIMBU LETTER TRA
+1920..1922     ; N  # Mn     [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SIGN U
+1923..1926     ; N  # Mc     [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL SIGN AU
+1927..1928     ; N  # Mn     [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SIGN O
+1929..192B     ; N  # Mc     [3] LIMBU SUBJOINED LETTER YA..LIMBU SUBJOINED LETTER WA
+1930..1931     ; N  # Mc     [2] LIMBU SMALL LETTER KA..LIMBU SMALL LETTER NGA
+1932           ; N  # Mn         LIMBU SMALL LETTER ANUSVARA
+1933..1938     ; N  # Mc     [6] LIMBU SMALL LETTER TA..LIMBU SMALL LETTER LA
+1939..193B     ; N  # Mn     [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I
+1940           ; N  # So         LIMBU SIGN LOO
+1944..1945     ; N  # Po     [2] LIMBU EXCLAMATION MARK..LIMBU QUESTION MARK
+1946..194F     ; N  # Nd    [10] LIMBU DIGIT ZERO..LIMBU DIGIT NINE
+1950..196D     ; N  # Lo    [30] TAI LE LETTER KA..TAI LE LETTER AI
+1970..1974     ; N  # Lo     [5] TAI LE LETTER TONE-2..TAI LE LETTER TONE-6
+1980..19AB     ; N  # Lo    [44] NEW TAI LUE LETTER HIGH QA..NEW TAI LUE LETTER LOW SUA
+19B0..19C9     ; N  # Lo    [26] NEW TAI LUE VOWEL SIGN VOWEL SHORTENER..NEW TAI LUE TONE MARK-2
+19D0..19D9     ; N  # Nd    [10] NEW TAI LUE DIGIT ZERO..NEW TAI LUE DIGIT NINE
+19DA           ; N  # No         NEW TAI LUE THAM DIGIT ONE
+19DE..19DF     ; N  # So     [2] NEW TAI LUE SIGN LAE..NEW TAI LUE SIGN LAEV
+19E0..19FF     ; N  # So    [32] KHMER SYMBOL PATHAMASAT..KHMER SYMBOL DAP-PRAM ROC
+1A00..1A16     ; N  # Lo    [23] BUGINESE LETTER KA..BUGINESE LETTER HA
+1A17..1A18     ; N  # Mn     [2] BUGINESE VOWEL SIGN I..BUGINESE VOWEL SIGN U
+1A19..1A1A     ; N  # Mc     [2] BUGINESE VOWEL SIGN E..BUGINESE VOWEL SIGN O
+1A1B           ; N  # Mn         BUGINESE VOWEL SIGN AE
+1A1E..1A1F     ; N  # Po     [2] BUGINESE PALLAWA..BUGINESE END OF SECTION
+1A20..1A54     ; N  # Lo    [53] TAI THAM LETTER HIGH KA..TAI THAM LETTER GREAT SA
+1A55           ; N  # Mc         TAI THAM CONSONANT SIGN MEDIAL RA
+1A56           ; N  # Mn         TAI THAM CONSONANT SIGN MEDIAL LA
+1A57           ; N  # Mc         TAI THAM CONSONANT SIGN LA TANG LAI
+1A58..1A5E     ; N  # Mn     [7] TAI THAM SIGN MAI KANG LAI..TAI THAM CONSONANT SIGN SA
+1A60           ; N  # Mn         TAI THAM SIGN SAKOT
+1A61           ; N  # Mc         TAI THAM VOWEL SIGN A
+1A62           ; N  # Mn         TAI THAM VOWEL SIGN MAI SAT
+1A63..1A64     ; N  # Mc     [2] TAI THAM VOWEL SIGN AA..TAI THAM VOWEL SIGN TALL AA
+1A65..1A6C     ; N  # Mn     [8] TAI THAM VOWEL SIGN I..TAI THAM VOWEL SIGN OA BELOW
+1A6D..1A72     ; N  # Mc     [6] TAI THAM VOWEL SIGN OY..TAI THAM VOWEL SIGN THAM AI
+1A73..1A7C     ; N  # Mn    [10] TAI THAM VOWEL SIGN OA ABOVE..TAI THAM SIGN KHUEN-LUE KARAN
+1A7F           ; N  # Mn         TAI THAM COMBINING CRYPTOGRAMMIC DOT
+1A80..1A89     ; N  # Nd    [10] TAI THAM HORA DIGIT ZERO..TAI THAM HORA DIGIT NINE
+1A90..1A99     ; N  # Nd    [10] TAI THAM THAM DIGIT ZERO..TAI THAM THAM DIGIT NINE
+1AA0..1AA6     ; N  # Po     [7] TAI THAM SIGN WIANG..TAI THAM SIGN REVERSED ROTATED RANA
+1AA7           ; N  # Lm         TAI THAM SIGN MAI YAMOK
+1AA8..1AAD     ; N  # Po     [6] TAI THAM SIGN KAAN..TAI THAM SIGN CAANG
+1AB0..1ABD     ; N  # Mn    [14] COMBINING DOUBLED CIRCUMFLEX ACCENT..COMBINING PARENTHESES BELOW
+1ABE           ; N  # Me         COMBINING PARENTHESES OVERLAY
+1ABF..1ACE     ; N  # Mn    [16] COMBINING LATIN SMALL LETTER W BELOW..COMBINING LATIN SMALL LETTER INSULAR T
+1B00..1B03     ; N  # Mn     [4] BALINESE SIGN ULU RICEM..BALINESE SIGN SURANG
+1B04           ; N  # Mc         BALINESE SIGN BISAH
+1B05..1B33     ; N  # Lo    [47] BALINESE LETTER AKARA..BALINESE LETTER HA
+1B34           ; N  # Mn         BALINESE SIGN REREKAN
+1B35           ; N  # Mc         BALINESE VOWEL SIGN TEDUNG
+1B36..1B3A     ; N  # Mn     [5] BALINESE VOWEL SIGN ULU..BALINESE VOWEL SIGN RA REPA
+1B3B           ; N  # Mc         BALINESE VOWEL SIGN RA REPA TEDUNG
+1B3C           ; N  # Mn         BALINESE VOWEL SIGN LA LENGA
+1B3D..1B41     ; N  # Mc     [5] BALINESE VOWEL SIGN LA LENGA TEDUNG..BALINESE VOWEL SIGN TALING REPA TEDUNG
+1B42           ; N  # Mn         BALINESE VOWEL SIGN PEPET
+1B43..1B44     ; N  # Mc     [2] BALINESE VOWEL SIGN PEPET TEDUNG..BALINESE ADEG ADEG
+1B45..1B4C     ; N  # Lo     [8] BALINESE LETTER KAF SASAK..BALINESE LETTER ARCHAIC JNYA
+1B50..1B59     ; N  # Nd    [10] BALINESE DIGIT ZERO..BALINESE DIGIT NINE
+1B5A..1B60     ; N  # Po     [7] BALINESE PANTI..BALINESE PAMENENG
+1B61..1B6A     ; N  # So    [10] BALINESE MUSICAL SYMBOL DONG..BALINESE MUSICAL SYMBOL DANG GEDE
+1B6B..1B73     ; N  # Mn     [9] BALINESE MUSICAL SYMBOL COMBINING TEGEH..BALINESE MUSICAL SYMBOL COMBINING GONG
+1B74..1B7C     ; N  # So     [9] BALINESE MUSICAL SYMBOL RIGHT-HAND OPEN DUG..BALINESE MUSICAL SYMBOL LEFT-HAND OPEN PING
+1B7D..1B7E     ; N  # Po     [2] BALINESE PANTI LANTANG..BALINESE PAMADA LANTANG
+1B80..1B81     ; N  # Mn     [2] SUNDANESE SIGN PANYECEK..SUNDANESE SIGN PANGLAYAR
+1B82           ; N  # Mc         SUNDANESE SIGN PANGWISAD
+1B83..1BA0     ; N  # Lo    [30] SUNDANESE LETTER A..SUNDANESE LETTER HA
+1BA1           ; N  # Mc         SUNDANESE CONSONANT SIGN PAMINGKAL
+1BA2..1BA5     ; N  # Mn     [4] SUNDANESE CONSONANT SIGN PANYAKRA..SUNDANESE VOWEL SIGN PANYUKU
+1BA6..1BA7     ; N  # Mc     [2] SUNDANESE VOWEL SIGN PANAELAENG..SUNDANESE VOWEL SIGN PANOLONG
+1BA8..1BA9     ; N  # Mn     [2] SUNDANESE VOWEL SIGN PAMEPET..SUNDANESE VOWEL SIGN PANEULEUNG
+1BAA           ; N  # Mc         SUNDANESE SIGN PAMAAEH
+1BAB..1BAD     ; N  # Mn     [3] SUNDANESE SIGN VIRAMA..SUNDANESE CONSONANT SIGN PASANGAN WA
+1BAE..1BAF     ; N  # Lo     [2] SUNDANESE LETTER KHA..SUNDANESE LETTER SYA
+1BB0..1BB9     ; N  # Nd    [10] SUNDANESE DIGIT ZERO..SUNDANESE DIGIT NINE
+1BBA..1BBF     ; N  # Lo     [6] SUNDANESE AVAGRAHA..SUNDANESE LETTER FINAL M
+1BC0..1BE5     ; N  # Lo    [38] BATAK LETTER A..BATAK LETTER U
+1BE6           ; N  # Mn         BATAK SIGN TOMPI
+1BE7           ; N  # Mc         BATAK VOWEL SIGN E
+1BE8..1BE9     ; N  # Mn     [2] BATAK VOWEL SIGN PAKPAK E..BATAK VOWEL SIGN EE
+1BEA..1BEC     ; N  # Mc     [3] BATAK VOWEL SIGN I..BATAK VOWEL SIGN O
+1BED           ; N  # Mn         BATAK VOWEL SIGN KARO O
+1BEE           ; N  # Mc         BATAK VOWEL SIGN U
+1BEF..1BF1     ; N  # Mn     [3] BATAK VOWEL SIGN U FOR SIMALUNGUN SA..BATAK CONSONANT SIGN H
+1BF2..1BF3     ; N  # Mc     [2] BATAK PANGOLAT..BATAK PANONGONAN
+1BFC..1BFF     ; N  # Po     [4] BATAK SYMBOL BINDU NA METEK..BATAK SYMBOL BINDU PANGOLAT
+1C00..1C23     ; N  # Lo    [36] LEPCHA LETTER KA..LEPCHA LETTER A
+1C24..1C2B     ; N  # Mc     [8] LEPCHA SUBJOINED LETTER YA..LEPCHA VOWEL SIGN UU
+1C2C..1C33     ; N  # Mn     [8] LEPCHA VOWEL SIGN E..LEPCHA CONSONANT SIGN T
+1C34..1C35     ; N  # Mc     [2] LEPCHA CONSONANT SIGN NYIN-DO..LEPCHA CONSONANT SIGN KANG
+1C36..1C37     ; N  # Mn     [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA
+1C3B..1C3F     ; N  # Po     [5] LEPCHA PUNCTUATION TA-ROL..LEPCHA PUNCTUATION TSHOOK
+1C40..1C49     ; N  # Nd    [10] LEPCHA DIGIT ZERO..LEPCHA DIGIT NINE
+1C4D..1C4F     ; N  # Lo     [3] LEPCHA LETTER TTA..LEPCHA LETTER DDA
+1C50..1C59     ; N  # Nd    [10] OL CHIKI DIGIT ZERO..OL CHIKI DIGIT NINE
+1C5A..1C77     ; N  # Lo    [30] OL CHIKI LETTER LA..OL CHIKI LETTER OH
+1C78..1C7D     ; N  # Lm     [6] OL CHIKI MU TTUDDAG..OL CHIKI AHAD
+1C7E..1C7F     ; N  # Po     [2] OL CHIKI PUNCTUATION MUCAAD..OL CHIKI PUNCTUATION DOUBLE MUCAAD
+1C80..1C88     ; N  # Ll     [9] CYRILLIC SMALL LETTER ROUNDED VE..CYRILLIC SMALL LETTER UNBLENDED UK
+1C90..1CBA     ; N  # Lu    [43] GEORGIAN MTAVRULI CAPITAL LETTER AN..GEORGIAN MTAVRULI CAPITAL LETTER AIN
+1CBD..1CBF     ; N  # Lu     [3] GEORGIAN MTAVRULI CAPITAL LETTER AEN..GEORGIAN MTAVRULI CAPITAL LETTER LABIAL SIGN
+1CC0..1CC7     ; N  # Po     [8] SUNDANESE PUNCTUATION BINDU SURYA..SUNDANESE PUNCTUATION BINDU BA SATANGA
+1CD0..1CD2     ; N  # Mn     [3] VEDIC TONE KARSHANA..VEDIC TONE PRENKHA
+1CD3           ; N  # Po         VEDIC SIGN NIHSHVASA
+1CD4..1CE0     ; N  # Mn    [13] VEDIC SIGN YAJURVEDIC MIDLINE SVARITA..VEDIC TONE RIGVEDIC KASHMIRI INDEPENDENT SVARITA
+1CE1           ; N  # Mc         VEDIC TONE ATHARVAVEDIC INDEPENDENT SVARITA
+1CE2..1CE8     ; N  # Mn     [7] VEDIC SIGN VISARGA SVARITA..VEDIC SIGN VISARGA ANUDATTA WITH TAIL
+1CE9..1CEC     ; N  # Lo     [4] VEDIC SIGN ANUSVARA ANTARGOMUKHA..VEDIC SIGN ANUSVARA VAMAGOMUKHA WITH TAIL
+1CED           ; N  # Mn         VEDIC SIGN TIRYAK
+1CEE..1CF3     ; N  # Lo     [6] VEDIC SIGN HEXIFORM LONG ANUSVARA..VEDIC SIGN ROTATED ARDHAVISARGA
+1CF4           ; N  # Mn         VEDIC TONE CANDRA ABOVE
+1CF5..1CF6     ; N  # Lo     [2] VEDIC SIGN JIHVAMULIYA..VEDIC SIGN UPADHMANIYA
+1CF7           ; N  # Mc         VEDIC SIGN ATIKRAMA
+1CF8..1CF9     ; N  # Mn     [2] VEDIC TONE RING ABOVE..VEDIC TONE DOUBLE RING ABOVE
+1CFA           ; N  # Lo         VEDIC SIGN DOUBLE ANUSVARA ANTARGOMUKHA
+1D00..1D2B     ; N  # Ll    [44] LATIN LETTER SMALL CAPITAL A..CYRILLIC LETTER SMALL CAPITAL EL
+1D2C..1D6A     ; N  # Lm    [63] MODIFIER LETTER CAPITAL A..GREEK SUBSCRIPT SMALL LETTER CHI
+1D6B..1D77     ; N  # Ll    [13] LATIN SMALL LETTER UE..LATIN SMALL LETTER TURNED G
+1D78           ; N  # Lm         MODIFIER LETTER CYRILLIC EN
+1D79..1D7F     ; N  # Ll     [7] LATIN SMALL LETTER INSULAR G..LATIN SMALL LETTER UPSILON WITH STROKE
+1D80..1D9A     ; N  # Ll    [27] LATIN SMALL LETTER B WITH PALATAL HOOK..LATIN SMALL LETTER EZH WITH RETROFLEX HOOK
+1D9B..1DBF     ; N  # Lm    [37] MODIFIER LETTER SMALL TURNED ALPHA..MODIFIER LETTER SMALL THETA
+1DC0..1DFF     ; N  # Mn    [64] COMBINING DOTTED GRAVE ACCENT..COMBINING RIGHT ARROWHEAD AND DOWN ARROWHEAD BELOW
+1E00..1EFF     ; N  # L&   [256] LATIN CAPITAL LETTER A WITH RING BELOW..LATIN SMALL LETTER Y WITH LOOP
+1F00..1F15     ; N  # L&    [22] GREEK SMALL LETTER ALPHA WITH PSILI..GREEK SMALL LETTER EPSILON WITH DASIA AND OXIA
+1F18..1F1D     ; N  # Lu     [6] GREEK CAPITAL LETTER EPSILON WITH PSILI..GREEK CAPITAL LETTER EPSILON WITH DASIA AND OXIA
+1F20..1F45     ; N  # L&    [38] GREEK SMALL LETTER ETA WITH PSILI..GREEK SMALL LETTER OMICRON WITH DASIA AND OXIA
+1F48..1F4D     ; N  # Lu     [6] GREEK CAPITAL LETTER OMICRON WITH PSILI..GREEK CAPITAL LETTER OMICRON WITH DASIA AND OXIA
+1F50..1F57     ; N  # Ll     [8] GREEK SMALL LETTER UPSILON WITH PSILI..GREEK SMALL LETTER UPSILON WITH DASIA AND PERISPOMENI
+1F59           ; N  # Lu         GREEK CAPITAL LETTER UPSILON WITH DASIA
+1F5B           ; N  # Lu         GREEK CAPITAL LETTER UPSILON WITH DASIA AND VARIA
+1F5D           ; N  # Lu         GREEK CAPITAL LETTER UPSILON WITH DASIA AND OXIA
+1F5F..1F7D     ; N  # L&    [31] GREEK CAPITAL LETTER UPSILON WITH DASIA AND PERISPOMENI..GREEK SMALL LETTER OMEGA WITH OXIA
+1F80..1FB4     ; N  # L&    [53] GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI..GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI
+1FB6..1FBC     ; N  # L&     [7] GREEK SMALL LETTER ALPHA WITH PERISPOMENI..GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI
+1FBD           ; N  # Sk         GREEK KORONIS
+1FBE           ; N  # Ll         GREEK PROSGEGRAMMENI
+1FBF..1FC1     ; N  # Sk     [3] GREEK PSILI..GREEK DIALYTIKA AND PERISPOMENI
+1FC2..1FC4     ; N  # Ll     [3] GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI
+1FC6..1FCC     ; N  # L&     [7] GREEK SMALL LETTER ETA WITH PERISPOMENI..GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
+1FCD..1FCF     ; N  # Sk     [3] GREEK PSILI AND VARIA..GREEK PSILI AND PERISPOMENI
+1FD0..1FD3     ; N  # Ll     [4] GREEK SMALL LETTER IOTA WITH VRACHY..GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
+1FD6..1FDB     ; N  # L&     [6] GREEK SMALL LETTER IOTA WITH PERISPOMENI..GREEK CAPITAL LETTER IOTA WITH OXIA
+1FDD..1FDF     ; N  # Sk     [3] GREEK DASIA AND VARIA..GREEK DASIA AND PERISPOMENI
+1FE0..1FEC     ; N  # L&    [13] GREEK SMALL LETTER UPSILON WITH VRACHY..GREEK CAPITAL LETTER RHO WITH DASIA
+1FED..1FEF     ; N  # Sk     [3] GREEK DIALYTIKA AND VARIA..GREEK VARIA
+1FF2..1FF4     ; N  # Ll     [3] GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI..GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI
+1FF6..1FFC     ; N  # L&     [7] GREEK SMALL LETTER OMEGA WITH PERISPOMENI..GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
+1FFD..1FFE     ; N  # Sk     [2] GREEK OXIA..GREEK DASIA
+2000..200A     ; N  # Zs    [11] EN QUAD..HAIR SPACE
+200B..200F     ; N  # Cf     [5] ZERO WIDTH SPACE..RIGHT-TO-LEFT MARK
+2010           ; A  # Pd         HYPHEN
+2011..2012     ; N  # Pd     [2] NON-BREAKING HYPHEN..FIGURE DASH
+2013..2015     ; A  # Pd     [3] EN DASH..HORIZONTAL BAR
+2016           ; A  # Po         DOUBLE VERTICAL LINE
+2017           ; N  # Po         DOUBLE LOW LINE
+2018           ; A  # Pi         LEFT SINGLE QUOTATION MARK
+2019           ; A  # Pf         RIGHT SINGLE QUOTATION MARK
+201A           ; N  # Ps         SINGLE LOW-9 QUOTATION MARK
+201B           ; N  # Pi         SINGLE HIGH-REVERSED-9 QUOTATION MARK
+201C           ; A  # Pi         LEFT DOUBLE QUOTATION MARK
+201D           ; A  # Pf         RIGHT DOUBLE QUOTATION MARK
+201E           ; N  # Ps         DOUBLE LOW-9 QUOTATION MARK
+201F           ; N  # Pi         DOUBLE HIGH-REVERSED-9 QUOTATION MARK
+2020..2022     ; A  # Po     [3] DAGGER..BULLET
+2023           ; N  # Po         TRIANGULAR BULLET
+2024..2027     ; A  # Po     [4] ONE DOT LEADER..HYPHENATION POINT
+2028           ; N  # Zl         LINE SEPARATOR
+2029           ; N  # Zp         PARAGRAPH SEPARATOR
+202A..202E     ; N  # Cf     [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-LEFT OVERRIDE
+202F           ; N  # Zs         NARROW NO-BREAK SPACE
+2030           ; A  # Po         PER MILLE SIGN
+2031           ; N  # Po         PER TEN THOUSAND SIGN
+2032..2033     ; A  # Po     [2] PRIME..DOUBLE PRIME
+2034           ; N  # Po         TRIPLE PRIME
+2035           ; A  # Po         REVERSED PRIME
+2036..2038     ; N  # Po     [3] REVERSED DOUBLE PRIME..CARET
+2039           ; N  # Pi         SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+203A           ; N  # Pf         SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+203B           ; A  # Po         REFERENCE MARK
+203C..203D     ; N  # Po     [2] DOUBLE EXCLAMATION MARK..INTERROBANG
+203E           ; A  # Po         OVERLINE
+203F..2040     ; N  # Pc     [2] UNDERTIE..CHARACTER TIE
+2041..2043     ; N  # Po     [3] CARET INSERTION POINT..HYPHEN BULLET
+2044           ; N  # Sm         FRACTION SLASH
+2045           ; N  # Ps         LEFT SQUARE BRACKET WITH QUILL
+2046           ; N  # Pe         RIGHT SQUARE BRACKET WITH QUILL
+2047..2051     ; N  # Po    [11] DOUBLE QUESTION MARK..TWO ASTERISKS ALIGNED VERTICALLY
+2052           ; N  # Sm         COMMERCIAL MINUS SIGN
+2053           ; N  # Po         SWUNG DASH
+2054           ; N  # Pc         INVERTED UNDERTIE
+2055..205E     ; N  # Po    [10] FLOWER PUNCTUATION MARK..VERTICAL FOUR DOTS
+205F           ; N  # Zs         MEDIUM MATHEMATICAL SPACE
+2060..2064     ; N  # Cf     [5] WORD JOINER..INVISIBLE PLUS
+2066..206F     ; N  # Cf    [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIGIT SHAPES
+2070           ; N  # No         SUPERSCRIPT ZERO
+2071           ; N  # Lm         SUPERSCRIPT LATIN SMALL LETTER I
+2074           ; A  # No         SUPERSCRIPT FOUR
+2075..2079     ; N  # No     [5] SUPERSCRIPT FIVE..SUPERSCRIPT NINE
+207A..207C     ; N  # Sm     [3] SUPERSCRIPT PLUS SIGN..SUPERSCRIPT EQUALS SIGN
+207D           ; N  # Ps         SUPERSCRIPT LEFT PARENTHESIS
+207E           ; N  # Pe         SUPERSCRIPT RIGHT PARENTHESIS
+207F           ; A  # Lm         SUPERSCRIPT LATIN SMALL LETTER N
+2080           ; N  # No         SUBSCRIPT ZERO
+2081..2084     ; A  # No     [4] SUBSCRIPT ONE..SUBSCRIPT FOUR
+2085..2089     ; N  # No     [5] SUBSCRIPT FIVE..SUBSCRIPT NINE
+208A..208C     ; N  # Sm     [3] SUBSCRIPT PLUS SIGN..SUBSCRIPT EQUALS SIGN
+208D           ; N  # Ps         SUBSCRIPT LEFT PARENTHESIS
+208E           ; N  # Pe         SUBSCRIPT RIGHT PARENTHESIS
+2090..209C     ; N  # Lm    [13] LATIN SUBSCRIPT SMALL LETTER A..LATIN SUBSCRIPT SMALL LETTER T
+20A0..20A8     ; N  # Sc     [9] EURO-CURRENCY SIGN..RUPEE SIGN
+20A9           ; H  # Sc         WON SIGN
+20AA..20AB     ; N  # Sc     [2] NEW SHEQEL SIGN..DONG SIGN
+20AC           ; A  # Sc         EURO SIGN
+20AD..20C0     ; N  # Sc    [20] KIP SIGN..SOM SIGN
+20D0..20DC     ; N  # Mn    [13] COMBINING LEFT HARPOON ABOVE..COMBINING FOUR DOTS ABOVE
+20DD..20E0     ; N  # Me     [4] COMBINING ENCLOSING CIRCLE..COMBINING ENCLOSING CIRCLE BACKSLASH
+20E1           ; N  # Mn         COMBINING LEFT RIGHT ARROW ABOVE
+20E2..20E4     ; N  # Me     [3] COMBINING ENCLOSING SCREEN..COMBINING ENCLOSING UPWARD POINTING TRIANGLE
+20E5..20F0     ; N  # Mn    [12] COMBINING REVERSE SOLIDUS OVERLAY..COMBINING ASTERISK ABOVE
+2100..2101     ; N  # So     [2] ACCOUNT OF..ADDRESSED TO THE SUBJECT
+2102           ; N  # Lu         DOUBLE-STRUCK CAPITAL C
+2103           ; A  # So         DEGREE CELSIUS
+2104           ; N  # So         CENTRE LINE SYMBOL
+2105           ; A  # So         CARE OF
+2106           ; N  # So         CADA UNA
+2107           ; N  # Lu         EULER CONSTANT
+2108           ; N  # So         SCRUPLE
+2109           ; A  # So         DEGREE FAHRENHEIT
+210A..2112     ; N  # L&     [9] SCRIPT SMALL G..SCRIPT CAPITAL L
+2113           ; A  # Ll         SCRIPT SMALL L
+2114           ; N  # So         L B BAR SYMBOL
+2115           ; N  # Lu         DOUBLE-STRUCK CAPITAL N
+2116           ; A  # So         NUMERO SIGN
+2117           ; N  # So         SOUND RECORDING COPYRIGHT
+2118           ; N  # Sm         SCRIPT CAPITAL P
+2119..211D     ; N  # Lu     [5] DOUBLE-STRUCK CAPITAL P..DOUBLE-STRUCK CAPITAL R
+211E..2120     ; N  # So     [3] PRESCRIPTION TAKE..SERVICE MARK
+2121..2122     ; A  # So     [2] TELEPHONE SIGN..TRADE MARK SIGN
+2123           ; N  # So         VERSICLE
+2124           ; N  # Lu         DOUBLE-STRUCK CAPITAL Z
+2125           ; N  # So         OUNCE SIGN
+2126           ; A  # Lu         OHM SIGN
+2127           ; N  # So         INVERTED OHM SIGN
+2128           ; N  # Lu         BLACK-LETTER CAPITAL Z
+2129           ; N  # So         TURNED GREEK SMALL LETTER IOTA
+212A           ; N  # Lu         KELVIN SIGN
+212B           ; A  # Lu         ANGSTROM SIGN
+212C..212D     ; N  # Lu     [2] SCRIPT CAPITAL B..BLACK-LETTER CAPITAL C
+212E           ; N  # So         ESTIMATED SYMBOL
+212F..2134     ; N  # L&     [6] SCRIPT SMALL E..SCRIPT SMALL O
+2135..2138     ; N  # Lo     [4] ALEF SYMBOL..DALET SYMBOL
+2139           ; N  # Ll         INFORMATION SOURCE
+213A..213B     ; N  # So     [2] ROTATED CAPITAL Q..FACSIMILE SIGN
+213C..213F     ; N  # L&     [4] DOUBLE-STRUCK SMALL PI..DOUBLE-STRUCK CAPITAL PI
+2140..2144     ; N  # Sm     [5] DOUBLE-STRUCK N-ARY SUMMATION..TURNED SANS-SERIF CAPITAL Y
+2145..2149     ; N  # L&     [5] DOUBLE-STRUCK ITALIC CAPITAL D..DOUBLE-STRUCK ITALIC SMALL J
+214A           ; N  # So         PROPERTY LINE
+214B           ; N  # Sm         TURNED AMPERSAND
+214C..214D     ; N  # So     [2] PER SIGN..AKTIESELSKAB
+214E           ; N  # Ll         TURNED SMALL F
+214F           ; N  # So         SYMBOL FOR SAMARITAN SOURCE
+2150..2152     ; N  # No     [3] VULGAR FRACTION ONE SEVENTH..VULGAR FRACTION ONE TENTH
+2153..2154     ; A  # No     [2] VULGAR FRACTION ONE THIRD..VULGAR FRACTION TWO THIRDS
+2155..215A     ; N  # No     [6] VULGAR FRACTION ONE FIFTH..VULGAR FRACTION FIVE SIXTHS
+215B..215E     ; A  # No     [4] VULGAR FRACTION ONE EIGHTH..VULGAR FRACTION SEVEN EIGHTHS
+215F           ; N  # No         FRACTION NUMERATOR ONE
+2160..216B     ; A  # Nl    [12] ROMAN NUMERAL ONE..ROMAN NUMERAL TWELVE
+216C..216F     ; N  # Nl     [4] ROMAN NUMERAL FIFTY..ROMAN NUMERAL ONE THOUSAND
+2170..2179     ; A  # Nl    [10] SMALL ROMAN NUMERAL ONE..SMALL ROMAN NUMERAL TEN
+217A..2182     ; N  # Nl     [9] SMALL ROMAN NUMERAL ELEVEN..ROMAN NUMERAL TEN THOUSAND
+2183..2184     ; N  # L&     [2] ROMAN NUMERAL REVERSED ONE HUNDRED..LATIN SMALL LETTER REVERSED C
+2185..2188     ; N  # Nl     [4] ROMAN NUMERAL SIX LATE FORM..ROMAN NUMERAL ONE HUNDRED THOUSAND
+2189           ; A  # No         VULGAR FRACTION ZERO THIRDS
+218A..218B     ; N  # So     [2] TURNED DIGIT TWO..TURNED DIGIT THREE
+2190..2194     ; A  # Sm     [5] LEFTWARDS ARROW..LEFT RIGHT ARROW
+2195..2199     ; A  # So     [5] UP DOWN ARROW..SOUTH WEST ARROW
+219A..219B     ; N  # Sm     [2] LEFTWARDS ARROW WITH STROKE..RIGHTWARDS ARROW WITH STROKE
+219C..219F     ; N  # So     [4] LEFTWARDS WAVE ARROW..UPWARDS TWO HEADED ARROW
+21A0           ; N  # Sm         RIGHTWARDS TWO HEADED ARROW
+21A1..21A2     ; N  # So     [2] DOWNWARDS TWO HEADED ARROW..LEFTWARDS ARROW WITH TAIL
+21A3           ; N  # Sm         RIGHTWARDS ARROW WITH TAIL
+21A4..21A5     ; N  # So     [2] LEFTWARDS ARROW FROM BAR..UPWARDS ARROW FROM BAR
+21A6           ; N  # Sm         RIGHTWARDS ARROW FROM BAR
+21A7..21AD     ; N  # So     [7] DOWNWARDS ARROW FROM BAR..LEFT RIGHT WAVE ARROW
+21AE           ; N  # Sm         LEFT RIGHT ARROW WITH STROKE
+21AF..21B7     ; N  # So     [9] DOWNWARDS ZIGZAG ARROW..CLOCKWISE TOP SEMICIRCLE ARROW
+21B8..21B9     ; A  # So     [2] NORTH WEST ARROW TO LONG BAR..LEFTWARDS ARROW TO BAR OVER RIGHTWARDS ARROW TO BAR
+21BA..21CD     ; N  # So    [20] ANTICLOCKWISE OPEN CIRCLE ARROW..LEFTWARDS DOUBLE ARROW WITH STROKE
+21CE..21CF     ; N  # Sm     [2] LEFT RIGHT DOUBLE ARROW WITH STROKE..RIGHTWARDS DOUBLE ARROW WITH STROKE
+21D0..21D1     ; N  # So     [2] LEFTWARDS DOUBLE ARROW..UPWARDS DOUBLE ARROW
+21D2           ; A  # Sm         RIGHTWARDS DOUBLE ARROW
+21D3           ; N  # So         DOWNWARDS DOUBLE ARROW
+21D4           ; A  # Sm         LEFT RIGHT DOUBLE ARROW
+21D5..21E6     ; N  # So    [18] UP DOWN DOUBLE ARROW..LEFTWARDS WHITE ARROW
+21E7           ; A  # So         UPWARDS WHITE ARROW
+21E8..21F3     ; N  # So    [12] RIGHTWARDS WHITE ARROW..UP DOWN WHITE ARROW
+21F4..21FF     ; N  # Sm    [12] RIGHT ARROW WITH SMALL CIRCLE..LEFT RIGHT OPEN-HEADED ARROW
+2200           ; A  # Sm         FOR ALL
+2201           ; N  # Sm         COMPLEMENT
+2202..2203     ; A  # Sm     [2] PARTIAL DIFFERENTIAL..THERE EXISTS
+2204..2206     ; N  # Sm     [3] THERE DOES NOT EXIST..INCREMENT
+2207..2208     ; A  # Sm     [2] NABLA..ELEMENT OF
+2209..220A     ; N  # Sm     [2] NOT AN ELEMENT OF..SMALL ELEMENT OF
+220B           ; A  # Sm         CONTAINS AS MEMBER
+220C..220E     ; N  # Sm     [3] DOES NOT CONTAIN AS MEMBER..END OF PROOF
+220F           ; A  # Sm         N-ARY PRODUCT
+2210           ; N  # Sm         N-ARY COPRODUCT
+2211           ; A  # Sm         N-ARY SUMMATION
+2212..2214     ; N  # Sm     [3] MINUS SIGN..DOT PLUS
+2215           ; A  # Sm         DIVISION SLASH
+2216..2219     ; N  # Sm     [4] SET MINUS..BULLET OPERATOR
+221A           ; A  # Sm         SQUARE ROOT
+221B..221C     ; N  # Sm     [2] CUBE ROOT..FOURTH ROOT
+221D..2220     ; A  # Sm     [4] PROPORTIONAL TO..ANGLE
+2221..2222     ; N  # Sm     [2] MEASURED ANGLE..SPHERICAL ANGLE
+2223           ; A  # Sm         DIVIDES
+2224           ; N  # Sm         DOES NOT DIVIDE
+2225           ; A  # Sm         PARALLEL TO
+2226           ; N  # Sm         NOT PARALLEL TO
+2227..222C     ; A  # Sm     [6] LOGICAL AND..DOUBLE INTEGRAL
+222D           ; N  # Sm         TRIPLE INTEGRAL
+222E           ; A  # Sm         CONTOUR INTEGRAL
+222F..2233     ; N  # Sm     [5] SURFACE INTEGRAL..ANTICLOCKWISE CONTOUR INTEGRAL
+2234..2237     ; A  # Sm     [4] THEREFORE..PROPORTION
+2238..223B     ; N  # Sm     [4] DOT MINUS..HOMOTHETIC
+223C..223D     ; A  # Sm     [2] TILDE OPERATOR..REVERSED TILDE
+223E..2247     ; N  # Sm    [10] INVERTED LAZY S..NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO
+2248           ; A  # Sm         ALMOST EQUAL TO
+2249..224B     ; N  # Sm     [3] NOT ALMOST EQUAL TO..TRIPLE TILDE
+224C           ; A  # Sm         ALL EQUAL TO
+224D..2251     ; N  # Sm     [5] EQUIVALENT TO..GEOMETRICALLY EQUAL TO
+2252           ; A  # Sm         APPROXIMATELY EQUAL TO OR THE IMAGE OF
+2253..225F     ; N  # Sm    [13] IMAGE OF OR APPROXIMATELY EQUAL TO..QUESTIONED EQUAL TO
+2260..2261     ; A  # Sm     [2] NOT EQUAL TO..IDENTICAL TO
+2262..2263     ; N  # Sm     [2] NOT IDENTICAL TO..STRICTLY EQUIVALENT TO
+2264..2267     ; A  # Sm     [4] LESS-THAN OR EQUAL TO..GREATER-THAN OVER EQUAL TO
+2268..2269     ; N  # Sm     [2] LESS-THAN BUT NOT EQUAL TO..GREATER-THAN BUT NOT EQUAL TO
+226A..226B     ; A  # Sm     [2] MUCH LESS-THAN..MUCH GREATER-THAN
+226C..226D     ; N  # Sm     [2] BETWEEN..NOT EQUIVALENT TO
+226E..226F     ; A  # Sm     [2] NOT LESS-THAN..NOT GREATER-THAN
+2270..2281     ; N  # Sm    [18] NEITHER LESS-THAN NOR EQUAL TO..DOES NOT SUCCEED
+2282..2283     ; A  # Sm     [2] SUBSET OF..SUPERSET OF
+2284..2285     ; N  # Sm     [2] NOT A SUBSET OF..NOT A SUPERSET OF
+2286..2287     ; A  # Sm     [2] SUBSET OF OR EQUAL TO..SUPERSET OF OR EQUAL TO
+2288..2294     ; N  # Sm    [13] NEITHER A SUBSET OF NOR EQUAL TO..SQUARE CUP
+2295           ; A  # Sm         CIRCLED PLUS
+2296..2298     ; N  # Sm     [3] CIRCLED MINUS..CIRCLED DIVISION SLASH
+2299           ; A  # Sm         CIRCLED DOT OPERATOR
+229A..22A4     ; N  # Sm    [11] CIRCLED RING OPERATOR..DOWN TACK
+22A5           ; A  # Sm         UP TACK
+22A6..22BE     ; N  # Sm    [25] ASSERTION..RIGHT ANGLE WITH ARC
+22BF           ; A  # Sm         RIGHT TRIANGLE
+22C0..22FF     ; N  # Sm    [64] N-ARY LOGICAL AND..Z NOTATION BAG MEMBERSHIP
+2300..2307     ; N  # So     [8] DIAMETER SIGN..WAVY LINE
+2308           ; N  # Ps         LEFT CEILING
+2309           ; N  # Pe         RIGHT CEILING
+230A           ; N  # Ps         LEFT FLOOR
+230B           ; N  # Pe         RIGHT FLOOR
+230C..2311     ; N  # So     [6] BOTTOM RIGHT CROP..SQUARE LOZENGE
+2312           ; A  # So         ARC
+2313..2319     ; N  # So     [7] SEGMENT..TURNED NOT SIGN
+231A..231B     ; W  # So     [2] WATCH..HOURGLASS
+231C..231F     ; N  # So     [4] TOP LEFT CORNER..BOTTOM RIGHT CORNER
+2320..2321     ; N  # Sm     [2] TOP HALF INTEGRAL..BOTTOM HALF INTEGRAL
+2322..2328     ; N  # So     [7] FROWN..KEYBOARD
+2329           ; W  # Ps         LEFT-POINTING ANGLE BRACKET
+232A           ; W  # Pe         RIGHT-POINTING ANGLE BRACKET
+232B..237B     ; N  # So    [81] ERASE TO THE LEFT..NOT CHECK MARK
+237C           ; N  # Sm         RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW
+237D..239A     ; N  # So    [30] SHOULDERED OPEN BOX..CLEAR SCREEN SYMBOL
+239B..23B3     ; N  # Sm    [25] LEFT PARENTHESIS UPPER HOOK..SUMMATION BOTTOM
+23B4..23DB     ; N  # So    [40] TOP SQUARE BRACKET..FUSE
+23DC..23E1     ; N  # Sm     [6] TOP PARENTHESIS..BOTTOM TORTOISE SHELL BRACKET
+23E2..23E8     ; N  # So     [7] WHITE TRAPEZIUM..DECIMAL EXPONENT SYMBOL
+23E9..23EC     ; W  # So     [4] BLACK RIGHT-POINTING DOUBLE TRIANGLE..BLACK DOWN-POINTING DOUBLE TRIANGLE
+23ED..23EF     ; N  # So     [3] BLACK RIGHT-POINTING DOUBLE TRIANGLE WITH VERTICAL BAR..BLACK RIGHT-POINTING TRIANGLE WITH DOUBLE VERTICAL BAR
+23F0           ; W  # So         ALARM CLOCK
+23F1..23F2     ; N  # So     [2] STOPWATCH..TIMER CLOCK
+23F3           ; W  # So         HOURGLASS WITH FLOWING SAND
+23F4..23FF     ; N  # So    [12] BLACK MEDIUM LEFT-POINTING TRIANGLE..OBSERVER EYE SYMBOL
+2400..2426     ; N  # So    [39] SYMBOL FOR NULL..SYMBOL FOR SUBSTITUTE FORM TWO
+2440..244A     ; N  # So    [11] OCR HOOK..OCR DOUBLE BACKSLASH
+2460..249B     ; A  # No    [60] CIRCLED DIGIT ONE..NUMBER TWENTY FULL STOP
+249C..24E9     ; A  # So    [78] PARENTHESIZED LATIN SMALL LETTER A..CIRCLED LATIN SMALL LETTER Z
+24EA           ; N  # No         CIRCLED DIGIT ZERO
+24EB..24FF     ; A  # No    [21] NEGATIVE CIRCLED NUMBER ELEVEN..NEGATIVE CIRCLED DIGIT ZERO
+2500..254B     ; A  # So    [76] BOX DRAWINGS LIGHT HORIZONTAL..BOX DRAWINGS HEAVY VERTICAL AND HORIZONTAL
+254C..254F     ; N  # So     [4] BOX DRAWINGS LIGHT DOUBLE DASH HORIZONTAL..BOX DRAWINGS HEAVY DOUBLE DASH VERTICAL
+2550..2573     ; A  # So    [36] BOX DRAWINGS DOUBLE HORIZONTAL..BOX DRAWINGS LIGHT DIAGONAL CROSS
+2574..257F     ; N  # So    [12] BOX DRAWINGS LIGHT LEFT..BOX DRAWINGS HEAVY UP AND LIGHT DOWN
+2580..258F     ; A  # So    [16] UPPER HALF BLOCK..LEFT ONE EIGHTH BLOCK
+2590..2591     ; N  # So     [2] RIGHT HALF BLOCK..LIGHT SHADE
+2592..2595     ; A  # So     [4] MEDIUM SHADE..RIGHT ONE EIGHTH BLOCK
+2596..259F     ; N  # So    [10] QUADRANT LOWER LEFT..QUADRANT UPPER RIGHT AND LOWER LEFT AND LOWER RIGHT
+25A0..25A1     ; A  # So     [2] BLACK SQUARE..WHITE SQUARE
+25A2           ; N  # So         WHITE SQUARE WITH ROUNDED CORNERS
+25A3..25A9     ; A  # So     [7] WHITE SQUARE CONTAINING BLACK SMALL SQUARE..SQUARE WITH DIAGONAL CROSSHATCH FILL
+25AA..25B1     ; N  # So     [8] BLACK SMALL SQUARE..WHITE PARALLELOGRAM
+25B2..25B3     ; A  # So     [2] BLACK UP-POINTING TRIANGLE..WHITE UP-POINTING TRIANGLE
+25B4..25B5     ; N  # So     [2] BLACK UP-POINTING SMALL TRIANGLE..WHITE UP-POINTING SMALL TRIANGLE
+25B6           ; A  # So         BLACK RIGHT-POINTING TRIANGLE
+25B7           ; A  # Sm         WHITE RIGHT-POINTING TRIANGLE
+25B8..25BB     ; N  # So     [4] BLACK RIGHT-POINTING SMALL TRIANGLE..WHITE RIGHT-POINTING POINTER
+25BC..25BD     ; A  # So     [2] BLACK DOWN-POINTING TRIANGLE..WHITE DOWN-POINTING TRIANGLE
+25BE..25BF     ; N  # So     [2] BLACK DOWN-POINTING SMALL TRIANGLE..WHITE DOWN-POINTING SMALL TRIANGLE
+25C0           ; A  # So         BLACK LEFT-POINTING TRIANGLE
+25C1           ; A  # Sm         WHITE LEFT-POINTING TRIANGLE
+25C2..25C5     ; N  # So     [4] BLACK LEFT-POINTING SMALL TRIANGLE..WHITE LEFT-POINTING POINTER
+25C6..25C8     ; A  # So     [3] BLACK DIAMOND..WHITE DIAMOND CONTAINING BLACK SMALL DIAMOND
+25C9..25CA     ; N  # So     [2] FISHEYE..LOZENGE
+25CB           ; A  # So         WHITE CIRCLE
+25CC..25CD     ; N  # So     [2] DOTTED CIRCLE..CIRCLE WITH VERTICAL FILL
+25CE..25D1     ; A  # So     [4] BULLSEYE..CIRCLE WITH RIGHT HALF BLACK
+25D2..25E1     ; N  # So    [16] CIRCLE WITH LOWER HALF BLACK..LOWER HALF CIRCLE
+25E2..25E5     ; A  # So     [4] BLACK LOWER RIGHT TRIANGLE..BLACK UPPER RIGHT TRIANGLE
+25E6..25EE     ; N  # So     [9] WHITE BULLET..UP-POINTING TRIANGLE WITH RIGHT HALF BLACK
+25EF           ; A  # So         LARGE CIRCLE
+25F0..25F7     ; N  # So     [8] WHITE SQUARE WITH UPPER LEFT QUADRANT..WHITE CIRCLE WITH UPPER RIGHT QUADRANT
+25F8..25FC     ; N  # Sm     [5] UPPER LEFT TRIANGLE..BLACK MEDIUM SQUARE
+25FD..25FE     ; W  # Sm     [2] WHITE MEDIUM SMALL SQUARE..BLACK MEDIUM SMALL SQUARE
+25FF           ; N  # Sm         LOWER RIGHT TRIANGLE
+2600..2604     ; N  # So     [5] BLACK SUN WITH RAYS..COMET
+2605..2606     ; A  # So     [2] BLACK STAR..WHITE STAR
+2607..2608     ; N  # So     [2] LIGHTNING..THUNDERSTORM
+2609           ; A  # So         SUN
+260A..260D     ; N  # So     [4] ASCENDING NODE..OPPOSITION
+260E..260F     ; A  # So     [2] BLACK TELEPHONE..WHITE TELEPHONE
+2610..2613     ; N  # So     [4] BALLOT BOX..SALTIRE
+2614..2615     ; W  # So     [2] UMBRELLA WITH RAIN DROPS..HOT BEVERAGE
+2616..261B     ; N  # So     [6] WHITE SHOGI PIECE..BLACK RIGHT POINTING INDEX
+261C           ; A  # So         WHITE LEFT POINTING INDEX
+261D           ; N  # So         WHITE UP POINTING INDEX
+261E           ; A  # So         WHITE RIGHT POINTING INDEX
+261F..263F     ; N  # So    [33] WHITE DOWN POINTING INDEX..MERCURY
+2640           ; A  # So         FEMALE SIGN
+2641           ; N  # So         EARTH
+2642           ; A  # So         MALE SIGN
+2643..2647     ; N  # So     [5] JUPITER..PLUTO
+2648..2653     ; W  # So    [12] ARIES..PISCES
+2654..265F     ; N  # So    [12] WHITE CHESS KING..BLACK CHESS PAWN
+2660..2661     ; A  # So     [2] BLACK SPADE SUIT..WHITE HEART SUIT
+2662           ; N  # So         WHITE DIAMOND SUIT
+2663..2665     ; A  # So     [3] BLACK CLUB SUIT..BLACK HEART SUIT
+2666           ; N  # So         BLACK DIAMOND SUIT
+2667..266A     ; A  # So     [4] WHITE CLUB SUIT..EIGHTH NOTE
+266B           ; N  # So         BEAMED EIGHTH NOTES
+266C..266D     ; A  # So     [2] BEAMED SIXTEENTH NOTES..MUSIC FLAT SIGN
+266E           ; N  # So         MUSIC NATURAL SIGN
+266F           ; A  # Sm         MUSIC SHARP SIGN
+2670..267E     ; N  # So    [15] WEST SYRIAC CROSS..PERMANENT PAPER SIGN
+267F           ; W  # So         WHEELCHAIR SYMBOL
+2680..2692     ; N  # So    [19] DIE FACE-1..HAMMER AND PICK
+2693           ; W  # So         ANCHOR
+2694..269D     ; N  # So    [10] CROSSED SWORDS..OUTLINED WHITE STAR
+269E..269F     ; A  # So     [2] THREE LINES CONVERGING RIGHT..THREE LINES CONVERGING LEFT
+26A0           ; N  # So         WARNING SIGN
+26A1           ; W  # So         HIGH VOLTAGE SIGN
+26A2..26A9     ; N  # So     [8] DOUBLED FEMALE SIGN..HORIZONTAL MALE WITH STROKE SIGN
+26AA..26AB     ; W  # So     [2] MEDIUM WHITE CIRCLE..MEDIUM BLACK CIRCLE
+26AC..26BC     ; N  # So    [17] MEDIUM SMALL WHITE CIRCLE..SESQUIQUADRATE
+26BD..26BE     ; W  # So     [2] SOCCER BALL..BASEBALL
+26BF           ; A  # So         SQUARED KEY
+26C0..26C3     ; N  # So     [4] WHITE DRAUGHTS MAN..BLACK DRAUGHTS KING
+26C4..26C5     ; W  # So     [2] SNOWMAN WITHOUT SNOW..SUN BEHIND CLOUD
+26C6..26CD     ; A  # So     [8] RAIN..DISABLED CAR
+26CE           ; W  # So         OPHIUCHUS
+26CF..26D3     ; A  # So     [5] PICK..CHAINS
+26D4           ; W  # So         NO ENTRY
+26D5..26E1     ; A  # So    [13] ALTERNATE ONE-WAY LEFT WAY TRAFFIC..RESTRICTED LEFT ENTRY-2
+26E2           ; N  # So         ASTRONOMICAL SYMBOL FOR URANUS
+26E3           ; A  # So         HEAVY CIRCLE WITH STROKE AND TWO DOTS ABOVE
+26E4..26E7     ; N  # So     [4] PENTAGRAM..INVERTED PENTAGRAM
+26E8..26E9     ; A  # So     [2] BLACK CROSS ON SHIELD..SHINTO SHRINE
+26EA           ; W  # So         CHURCH
+26EB..26F1     ; A  # So     [7] CASTLE..UMBRELLA ON GROUND
+26F2..26F3     ; W  # So     [2] FOUNTAIN..FLAG IN HOLE
+26F4           ; A  # So         FERRY
+26F5           ; W  # So         SAILBOAT
+26F6..26F9     ; A  # So     [4] SQUARE FOUR CORNERS..PERSON WITH BALL
+26FA           ; W  # So         TENT
+26FB..26FC     ; A  # So     [2] JAPANESE BANK SYMBOL..HEADSTONE GRAVEYARD SYMBOL
+26FD           ; W  # So         FUEL PUMP
+26FE..26FF     ; A  # So     [2] CUP ON BLACK SQUARE..WHITE FLAG WITH HORIZONTAL MIDDLE BLACK STRIPE
+2700..2704     ; N  # So     [5] BLACK SAFETY SCISSORS..WHITE SCISSORS
+2705           ; W  # So         WHITE HEAVY CHECK MARK
+2706..2709     ; N  # So     [4] TELEPHONE LOCATION SIGN..ENVELOPE
+270A..270B     ; W  # So     [2] RAISED FIST..RAISED HAND
+270C..2727     ; N  # So    [28] VICTORY HAND..WHITE FOUR POINTED STAR
+2728           ; W  # So         SPARKLES
+2729..273C     ; N  # So    [20] STRESS OUTLINED WHITE STAR..OPEN CENTRE TEARDROP-SPOKED ASTERISK
+273D           ; A  # So         HEAVY TEARDROP-SPOKED ASTERISK
+273E..274B     ; N  # So    [14] SIX PETALLED BLACK AND WHITE FLORETTE..HEAVY EIGHT TEARDROP-SPOKED PROPELLER ASTERISK
+274C           ; W  # So         CROSS MARK
+274D           ; N  # So         SHADOWED WHITE CIRCLE
+274E           ; W  # So         NEGATIVE SQUARED CROSS MARK
+274F..2752     ; N  # So     [4] LOWER RIGHT DROP-SHADOWED WHITE SQUARE..UPPER RIGHT SHADOWED WHITE SQUARE
+2753..2755     ; W  # So     [3] BLACK QUESTION MARK ORNAMENT..WHITE EXCLAMATION MARK ORNAMENT
+2756           ; N  # So         BLACK DIAMOND MINUS WHITE X
+2757           ; W  # So         HEAVY EXCLAMATION MARK SYMBOL
+2758..2767     ; N  # So    [16] LIGHT VERTICAL BAR..ROTATED FLORAL HEART BULLET
+2768           ; N  # Ps         MEDIUM LEFT PARENTHESIS ORNAMENT
+2769           ; N  # Pe         MEDIUM RIGHT PARENTHESIS ORNAMENT
+276A           ; N  # Ps         MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT
+276B           ; N  # Pe         MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT
+276C           ; N  # Ps         MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT
+276D           ; N  # Pe         MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT
+276E           ; N  # Ps         HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT
+276F           ; N  # Pe         HEAVY RIGHT-POINTING ANGLE QUOTATION MARK ORNAMENT
+2770           ; N  # Ps         HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT
+2771           ; N  # Pe         HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT
+2772           ; N  # Ps         LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT
+2773           ; N  # Pe         LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT
+2774           ; N  # Ps         MEDIUM LEFT CURLY BRACKET ORNAMENT
+2775           ; N  # Pe         MEDIUM RIGHT CURLY BRACKET ORNAMENT
+2776..277F     ; A  # No    [10] DINGBAT NEGATIVE CIRCLED DIGIT ONE..DINGBAT NEGATIVE CIRCLED NUMBER TEN
+2780..2793     ; N  # No    [20] DINGBAT CIRCLED SANS-SERIF DIGIT ONE..DINGBAT NEGATIVE CIRCLED SANS-SERIF NUMBER TEN
+2794           ; N  # So         HEAVY WIDE-HEADED RIGHTWARDS ARROW
+2795..2797     ; W  # So     [3] HEAVY PLUS SIGN..HEAVY DIVISION SIGN
+2798..27AF     ; N  # So    [24] HEAVY SOUTH EAST ARROW..NOTCHED LOWER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW
+27B0           ; W  # So         CURLY LOOP
+27B1..27BE     ; N  # So    [14] NOTCHED UPPER RIGHT-SHADOWED WHITE RIGHTWARDS ARROW..OPEN-OUTLINED RIGHTWARDS ARROW
+27BF           ; W  # So         DOUBLE CURLY LOOP
+27C0..27C4     ; N  # Sm     [5] THREE DIMENSIONAL ANGLE..OPEN SUPERSET
+27C5           ; N  # Ps         LEFT S-SHAPED BAG DELIMITER
+27C6           ; N  # Pe         RIGHT S-SHAPED BAG DELIMITER
+27C7..27E5     ; N  # Sm    [31] OR WITH DOT INSIDE..WHITE SQUARE WITH RIGHTWARDS TICK
+27E6           ; Na # Ps         MATHEMATICAL LEFT WHITE SQUARE BRACKET
+27E7           ; Na # Pe         MATHEMATICAL RIGHT WHITE SQUARE BRACKET
+27E8           ; Na # Ps         MATHEMATICAL LEFT ANGLE BRACKET
+27E9           ; Na # Pe         MATHEMATICAL RIGHT ANGLE BRACKET
+27EA           ; Na # Ps         MATHEMATICAL LEFT DOUBLE ANGLE BRACKET
+27EB           ; Na # Pe         MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET
+27EC           ; Na # Ps         MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET
+27ED           ; Na # Pe         MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET
+27EE           ; N  # Ps         MATHEMATICAL LEFT FLATTENED PARENTHESIS
+27EF           ; N  # Pe         MATHEMATICAL RIGHT FLATTENED PARENTHESIS
+27F0..27FF     ; N  # Sm    [16] UPWARDS QUADRUPLE ARROW..LONG RIGHTWARDS SQUIGGLE ARROW
+2800..28FF     ; N  # So   [256] BRAILLE PATTERN BLANK..BRAILLE PATTERN DOTS-12345678
+2900..297F     ; N  # Sm   [128] RIGHTWARDS TWO-HEADED ARROW WITH VERTICAL STROKE..DOWN FISH TAIL
+2980..2982     ; N  # Sm     [3] TRIPLE VERTICAL BAR DELIMITER..Z NOTATION TYPE COLON
+2983           ; N  # Ps         LEFT WHITE CURLY BRACKET
+2984           ; N  # Pe         RIGHT WHITE CURLY BRACKET
+2985           ; Na # Ps         LEFT WHITE PARENTHESIS
+2986           ; Na # Pe         RIGHT WHITE PARENTHESIS
+2987           ; N  # Ps         Z NOTATION LEFT IMAGE BRACKET
+2988           ; N  # Pe         Z NOTATION RIGHT IMAGE BRACKET
+2989           ; N  # Ps         Z NOTATION LEFT BINDING BRACKET
+298A           ; N  # Pe         Z NOTATION RIGHT BINDING BRACKET
+298B           ; N  # Ps         LEFT SQUARE BRACKET WITH UNDERBAR
+298C           ; N  # Pe         RIGHT SQUARE BRACKET WITH UNDERBAR
+298D           ; N  # Ps         LEFT SQUARE BRACKET WITH TICK IN TOP CORNER
+298E           ; N  # Pe         RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+298F           ; N  # Ps         LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+2990           ; N  # Pe         RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER
+2991           ; N  # Ps         LEFT ANGLE BRACKET WITH DOT
+2992           ; N  # Pe         RIGHT ANGLE BRACKET WITH DOT
+2993           ; N  # Ps         LEFT ARC LESS-THAN BRACKET
+2994           ; N  # Pe         RIGHT ARC GREATER-THAN BRACKET
+2995           ; N  # Ps         DOUBLE LEFT ARC GREATER-THAN BRACKET
+2996           ; N  # Pe         DOUBLE RIGHT ARC LESS-THAN BRACKET
+2997           ; N  # Ps         LEFT BLACK TORTOISE SHELL BRACKET
+2998           ; N  # Pe         RIGHT BLACK TORTOISE SHELL BRACKET
+2999..29D7     ; N  # Sm    [63] DOTTED FENCE..BLACK HOURGLASS
+29D8           ; N  # Ps         LEFT WIGGLY FENCE
+29D9           ; N  # Pe         RIGHT WIGGLY FENCE
+29DA           ; N  # Ps         LEFT DOUBLE WIGGLY FENCE
+29DB           ; N  # Pe         RIGHT DOUBLE WIGGLY FENCE
+29DC..29FB     ; N  # Sm    [32] INCOMPLETE INFINITY..TRIPLE PLUS
+29FC           ; N  # Ps         LEFT-POINTING CURVED ANGLE BRACKET
+29FD           ; N  # Pe         RIGHT-POINTING CURVED ANGLE BRACKET
+29FE..29FF     ; N  # Sm     [2] TINY..MINY
+2A00..2AFF     ; N  # Sm   [256] N-ARY CIRCLED DOT OPERATOR..N-ARY WHITE VERTICAL BAR
+2B00..2B1A     ; N  # So    [27] NORTH EAST WHITE ARROW..DOTTED SQUARE
+2B1B..2B1C     ; W  # So     [2] BLACK LARGE SQUARE..WHITE LARGE SQUARE
+2B1D..2B2F     ; N  # So    [19] BLACK VERY SMALL SQUARE..WHITE VERTICAL ELLIPSE
+2B30..2B44     ; N  # Sm    [21] LEFT ARROW WITH SMALL CIRCLE..RIGHTWARDS ARROW THROUGH SUPERSET
+2B45..2B46     ; N  # So     [2] LEFTWARDS QUADRUPLE ARROW..RIGHTWARDS QUADRUPLE ARROW
+2B47..2B4C     ; N  # Sm     [6] REVERSE TILDE OPERATOR ABOVE RIGHTWARDS ARROW..RIGHTWARDS ARROW ABOVE REVERSE TILDE OPERATOR
+2B4D..2B4F     ; N  # So     [3] DOWNWARDS TRIANGLE-HEADED ZIGZAG ARROW..SHORT BACKSLANTED SOUTH ARROW
+2B50           ; W  # So         WHITE MEDIUM STAR
+2B51..2B54     ; N  # So     [4] BLACK SMALL STAR..WHITE RIGHT-POINTING PENTAGON
+2B55           ; W  # So         HEAVY LARGE CIRCLE
+2B56..2B59     ; A  # So     [4] HEAVY OVAL WITH OVAL INSIDE..HEAVY CIRCLED SALTIRE
+2B5A..2B73     ; N  # So    [26] SLANTED NORTH ARROW WITH HOOKED HEAD..DOWNWARDS TRIANGLE-HEADED ARROW TO BAR
+2B76..2B95     ; N  # So    [32] NORTH WEST TRIANGLE-HEADED ARROW TO BAR..RIGHTWARDS BLACK ARROW
+2B97..2BFF     ; N  # So   [105] SYMBOL FOR TYPE A ELECTRONICS..HELLSCHREIBER PAUSE SYMBOL
+2C00..2C5F     ; N  # L&    [96] GLAGOLITIC CAPITAL LETTER AZU..GLAGOLITIC SMALL LETTER CAUDATE CHRIVI
+2C60..2C7B     ; N  # L&    [28] LATIN CAPITAL LETTER L WITH DOUBLE BAR..LATIN LETTER SMALL CAPITAL TURNED E
+2C7C..2C7D     ; N  # Lm     [2] LATIN SUBSCRIPT SMALL LETTER J..MODIFIER LETTER CAPITAL V
+2C7E..2C7F     ; N  # Lu     [2] LATIN CAPITAL LETTER S WITH SWASH TAIL..LATIN CAPITAL LETTER Z WITH SWASH TAIL
+2C80..2CE4     ; N  # L&   [101] COPTIC CAPITAL LETTER ALFA..COPTIC SYMBOL KAI
+2CE5..2CEA     ; N  # So     [6] COPTIC SYMBOL MI RO..COPTIC SYMBOL SHIMA SIMA
+2CEB..2CEE     ; N  # L&     [4] COPTIC CAPITAL LETTER CRYPTOGRAMMIC SHEI..COPTIC SMALL LETTER CRYPTOGRAMMIC GANGIA
+2CEF..2CF1     ; N  # Mn     [3] COPTIC COMBINING NI ABOVE..COPTIC COMBINING SPIRITUS LENIS
+2CF2..2CF3     ; N  # L&     [2] COPTIC CAPITAL LETTER BOHAIRIC KHEI..COPTIC SMALL LETTER BOHAIRIC KHEI
+2CF9..2CFC     ; N  # Po     [4] COPTIC OLD NUBIAN FULL STOP..COPTIC OLD NUBIAN VERSE DIVIDER
+2CFD           ; N  # No         COPTIC FRACTION ONE HALF
+2CFE..2CFF     ; N  # Po     [2] COPTIC FULL STOP..COPTIC MORPHOLOGICAL DIVIDER
+2D00..2D25     ; N  # Ll    [38] GEORGIAN SMALL LETTER AN..GEORGIAN SMALL LETTER HOE
+2D27           ; N  # Ll         GEORGIAN SMALL LETTER YN
+2D2D           ; N  # Ll         GEORGIAN SMALL LETTER AEN
+2D30..2D67     ; N  # Lo    [56] TIFINAGH LETTER YA..TIFINAGH LETTER YO
+2D6F           ; N  # Lm         TIFINAGH MODIFIER LETTER LABIALIZATION MARK
+2D70           ; N  # Po         TIFINAGH SEPARATOR MARK
+2D7F           ; N  # Mn         TIFINAGH CONSONANT JOINER
+2D80..2D96     ; N  # Lo    [23] ETHIOPIC SYLLABLE LOA..ETHIOPIC SYLLABLE GGWE
+2DA0..2DA6     ; N  # Lo     [7] ETHIOPIC SYLLABLE SSA..ETHIOPIC SYLLABLE SSO
+2DA8..2DAE     ; N  # Lo     [7] ETHIOPIC SYLLABLE CCA..ETHIOPIC SYLLABLE CCO
+2DB0..2DB6     ; N  # Lo     [7] ETHIOPIC SYLLABLE ZZA..ETHIOPIC SYLLABLE ZZO
+2DB8..2DBE     ; N  # Lo     [7] ETHIOPIC SYLLABLE CCHA..ETHIOPIC SYLLABLE CCHO
+2DC0..2DC6     ; N  # Lo     [7] ETHIOPIC SYLLABLE QYA..ETHIOPIC SYLLABLE QYO
+2DC8..2DCE     ; N  # Lo     [7] ETHIOPIC SYLLABLE KYA..ETHIOPIC SYLLABLE KYO
+2DD0..2DD6     ; N  # Lo     [7] ETHIOPIC SYLLABLE XYA..ETHIOPIC SYLLABLE XYO
+2DD8..2DDE     ; N  # Lo     [7] ETHIOPIC SYLLABLE GYA..ETHIOPIC SYLLABLE GYO
+2DE0..2DFF     ; N  # Mn    [32] COMBINING CYRILLIC LETTER BE..COMBINING CYRILLIC LETTER IOTIFIED BIG YUS
+2E00..2E01     ; N  # Po     [2] RIGHT ANGLE SUBSTITUTION MARKER..RIGHT ANGLE DOTTED SUBSTITUTION MARKER
+2E02           ; N  # Pi         LEFT SUBSTITUTION BRACKET
+2E03           ; N  # Pf         RIGHT SUBSTITUTION BRACKET
+2E04           ; N  # Pi         LEFT DOTTED SUBSTITUTION BRACKET
+2E05           ; N  # Pf         RIGHT DOTTED SUBSTITUTION BRACKET
+2E06..2E08     ; N  # Po     [3] RAISED INTERPOLATION MARKER..DOTTED TRANSPOSITION MARKER
+2E09           ; N  # Pi         LEFT TRANSPOSITION BRACKET
+2E0A           ; N  # Pf         RIGHT TRANSPOSITION BRACKET
+2E0B           ; N  # Po         RAISED SQUARE
+2E0C           ; N  # Pi         LEFT RAISED OMISSION BRACKET
+2E0D           ; N  # Pf         RIGHT RAISED OMISSION BRACKET
+2E0E..2E16     ; N  # Po     [9] EDITORIAL CORONIS..DOTTED RIGHT-POINTING ANGLE
+2E17           ; N  # Pd         DOUBLE OBLIQUE HYPHEN
+2E18..2E19     ; N  # Po     [2] INVERTED INTERROBANG..PALM BRANCH
+2E1A           ; N  # Pd         HYPHEN WITH DIAERESIS
+2E1B           ; N  # Po         TILDE WITH RING ABOVE
+2E1C           ; N  # Pi         LEFT LOW PARAPHRASE BRACKET
+2E1D           ; N  # Pf         RIGHT LOW PARAPHRASE BRACKET
+2E1E..2E1F     ; N  # Po     [2] TILDE WITH DOT ABOVE..TILDE WITH DOT BELOW
+2E20           ; N  # Pi         LEFT VERTICAL BAR WITH QUILL
+2E21           ; N  # Pf         RIGHT VERTICAL BAR WITH QUILL
+2E22           ; N  # Ps         TOP LEFT HALF BRACKET
+2E23           ; N  # Pe         TOP RIGHT HALF BRACKET
+2E24           ; N  # Ps         BOTTOM LEFT HALF BRACKET
+2E25           ; N  # Pe         BOTTOM RIGHT HALF BRACKET
+2E26           ; N  # Ps         LEFT SIDEWAYS U BRACKET
+2E27           ; N  # Pe         RIGHT SIDEWAYS U BRACKET
+2E28           ; N  # Ps         LEFT DOUBLE PARENTHESIS
+2E29           ; N  # Pe         RIGHT DOUBLE PARENTHESIS
+2E2A..2E2E     ; N  # Po     [5] TWO DOTS OVER ONE DOT PUNCTUATION..REVERSED QUESTION MARK
+2E2F           ; N  # Lm         VERTICAL TILDE
+2E30..2E39     ; N  # Po    [10] RING POINT..TOP HALF SECTION SIGN
+2E3A..2E3B     ; N  # Pd     [2] TWO-EM DASH..THREE-EM DASH
+2E3C..2E3F     ; N  # Po     [4] STENOGRAPHIC FULL STOP..CAPITULUM
+2E40           ; N  # Pd         DOUBLE HYPHEN
+2E41           ; N  # Po         REVERSED COMMA
+2E42           ; N  # Ps         DOUBLE LOW-REVERSED-9 QUOTATION MARK
+2E43..2E4F     ; N  # Po    [13] DASH WITH LEFT UPTURN..CORNISH VERSE DIVIDER
+2E50..2E51     ; N  # So     [2] CROSS PATTY WITH RIGHT CROSSBAR..CROSS PATTY WITH LEFT CROSSBAR
+2E52..2E54     ; N  # Po     [3] TIRONIAN SIGN CAPITAL ET..MEDIEVAL QUESTION MARK
+2E55           ; N  # Ps         LEFT SQUARE BRACKET WITH STROKE
+2E56           ; N  # Pe         RIGHT SQUARE BRACKET WITH STROKE
+2E57           ; N  # Ps         LEFT SQUARE BRACKET WITH DOUBLE STROKE
+2E58           ; N  # Pe         RIGHT SQUARE BRACKET WITH DOUBLE STROKE
+2E59           ; N  # Ps         TOP HALF LEFT PARENTHESIS
+2E5A           ; N  # Pe         TOP HALF RIGHT PARENTHESIS
+2E5B           ; N  # Ps         BOTTOM HALF LEFT PARENTHESIS
+2E5C           ; N  # Pe         BOTTOM HALF RIGHT PARENTHESIS
+2E5D           ; N  # Pd         OBLIQUE HYPHEN
+2E80..2E99     ; W  # So    [26] CJK RADICAL REPEAT..CJK RADICAL RAP
+2E9B..2EF3     ; W  # So    [89] CJK RADICAL CHOKE..CJK RADICAL C-SIMPLIFIED TURTLE
+2F00..2FD5     ; W  # So   [214] KANGXI RADICAL ONE..KANGXI RADICAL FLUTE
+2FF0..2FFF     ; W  # So    [16] IDEOGRAPHIC DESCRIPTION CHARACTER LEFT TO RIGHT..IDEOGRAPHIC DESCRIPTION CHARACTER ROTATION
+3000           ; F  # Zs         IDEOGRAPHIC SPACE
+3001..3003     ; W  # Po     [3] IDEOGRAPHIC COMMA..DITTO MARK
+3004           ; W  # So         JAPANESE INDUSTRIAL STANDARD SYMBOL
+3005           ; W  # Lm         IDEOGRAPHIC ITERATION MARK
+3006           ; W  # Lo         IDEOGRAPHIC CLOSING MARK
+3007           ; W  # Nl         IDEOGRAPHIC NUMBER ZERO
+3008           ; W  # Ps         LEFT ANGLE BRACKET
+3009           ; W  # Pe         RIGHT ANGLE BRACKET
+300A           ; W  # Ps         LEFT DOUBLE ANGLE BRACKET
+300B           ; W  # Pe         RIGHT DOUBLE ANGLE BRACKET
+300C           ; W  # Ps         LEFT CORNER BRACKET
+300D           ; W  # Pe         RIGHT CORNER BRACKET
+300E           ; W  # Ps         LEFT WHITE CORNER BRACKET
+300F           ; W  # Pe         RIGHT WHITE CORNER BRACKET
+3010           ; W  # Ps         LEFT BLACK LENTICULAR BRACKET
+3011           ; W  # Pe         RIGHT BLACK LENTICULAR BRACKET
+3012..3013     ; W  # So     [2] POSTAL MARK..GETA MARK
+3014           ; W  # Ps         LEFT TORTOISE SHELL BRACKET
+3015           ; W  # Pe         RIGHT TORTOISE SHELL BRACKET
+3016           ; W  # Ps         LEFT WHITE LENTICULAR BRACKET
+3017           ; W  # Pe         RIGHT WHITE LENTICULAR BRACKET
+3018           ; W  # Ps         LEFT WHITE TORTOISE SHELL BRACKET
+3019           ; W  # Pe         RIGHT WHITE TORTOISE SHELL BRACKET
+301A           ; W  # Ps         LEFT WHITE SQUARE BRACKET
+301B           ; W  # Pe         RIGHT WHITE SQUARE BRACKET
+301C           ; W  # Pd         WAVE DASH
+301D           ; W  # Ps         REVERSED DOUBLE PRIME QUOTATION MARK
+301E..301F     ; W  # Pe     [2] DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME QUOTATION MARK
+3020           ; W  # So         POSTAL MARK FACE
+3021..3029     ; W  # Nl     [9] HANGZHOU NUMERAL ONE..HANGZHOU NUMERAL NINE
+302A..302D     ; W  # Mn     [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOGRAPHIC ENTERING TONE MARK
+302E..302F     ; W  # Mc     [2] HANGUL SINGLE DOT TONE MARK..HANGUL DOUBLE DOT TONE MARK
+3030           ; W  # Pd         WAVY DASH
+3031..3035     ; W  # Lm     [5] VERTICAL KANA REPEAT MARK..VERTICAL KANA REPEAT MARK LOWER HALF
+3036..3037     ; W  # So     [2] CIRCLED POSTAL MARK..IDEOGRAPHIC TELEGRAPH LINE FEED SEPARATOR SYMBOL
+3038..303A     ; W  # Nl     [3] HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY
+303B           ; W  # Lm         VERTICAL IDEOGRAPHIC ITERATION MARK
+303C           ; W  # Lo         MASU MARK
+303D           ; W  # Po         PART ALTERNATION MARK
+303E           ; W  # So         IDEOGRAPHIC VARIATION INDICATOR
+303F           ; N  # So         IDEOGRAPHIC HALF FILL SPACE
+3041..3096     ; W  # Lo    [86] HIRAGANA LETTER SMALL A..HIRAGANA LETTER SMALL KE
+3099..309A     ; W  # Mn     [2] COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK..COMBINING KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+309B..309C     ; W  # Sk     [2] KATAKANA-HIRAGANA VOICED SOUND MARK..KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK
+309D..309E     ; W  # Lm     [2] HIRAGANA ITERATION MARK..HIRAGANA VOICED ITERATION MARK
+309F           ; W  # Lo         HIRAGANA DIGRAPH YORI
+30A0           ; W  # Pd         KATAKANA-HIRAGANA DOUBLE HYPHEN
+30A1..30FA     ; W  # Lo    [90] KATAKANA LETTER SMALL A..KATAKANA LETTER VO
+30FB           ; W  # Po         KATAKANA MIDDLE DOT
+30FC..30FE     ; W  # Lm     [3] KATAKANA-HIRAGANA PROLONGED SOUND MARK..KATAKANA VOICED ITERATION MARK
+30FF           ; W  # Lo         KATAKANA DIGRAPH KOTO
+3105..312F     ; W  # Lo    [43] BOPOMOFO LETTER B..BOPOMOFO LETTER NN
+3131..318E     ; W  # Lo    [94] HANGUL LETTER KIYEOK..HANGUL LETTER ARAEAE
+3190..3191     ; W  # So     [2] IDEOGRAPHIC ANNOTATION LINKING MARK..IDEOGRAPHIC ANNOTATION REVERSE MARK
+3192..3195     ; W  # No     [4] IDEOGRAPHIC ANNOTATION ONE MARK..IDEOGRAPHIC ANNOTATION FOUR MARK
+3196..319F     ; W  # So    [10] IDEOGRAPHIC ANNOTATION TOP MARK..IDEOGRAPHIC ANNOTATION MAN MARK
+31A0..31BF     ; W  # Lo    [32] BOPOMOFO LETTER BU..BOPOMOFO LETTER AH
+31C0..31E3     ; W  # So    [36] CJK STROKE T..CJK STROKE Q
+31EF           ; W  # So         IDEOGRAPHIC DESCRIPTION CHARACTER SUBTRACTION
+31F0..31FF     ; W  # Lo    [16] KATAKANA LETTER SMALL KU..KATAKANA LETTER SMALL RO
+3200..321E     ; W  # So    [31] PARENTHESIZED HANGUL KIYEOK..PARENTHESIZED KOREAN CHARACTER O HU
+3220..3229     ; W  # No    [10] PARENTHESIZED IDEOGRAPH ONE..PARENTHESIZED IDEOGRAPH TEN
+322A..3247     ; W  # So    [30] PARENTHESIZED IDEOGRAPH MOON..CIRCLED IDEOGRAPH KOTO
+3248..324F     ; A  # No     [8] CIRCLED NUMBER TEN ON BLACK SQUARE..CIRCLED NUMBER EIGHTY ON BLACK SQUARE
+3250           ; W  # So         PARTNERSHIP SIGN
+3251..325F     ; W  # No    [15] CIRCLED NUMBER TWENTY ONE..CIRCLED NUMBER THIRTY FIVE
+3260..327F     ; W  # So    [32] CIRCLED HANGUL KIYEOK..KOREAN STANDARD SYMBOL
+3280..3289     ; W  # No    [10] CIRCLED IDEOGRAPH ONE..CIRCLED IDEOGRAPH TEN
+328A..32B0     ; W  # So    [39] CIRCLED IDEOGRAPH MOON..CIRCLED IDEOGRAPH NIGHT
+32B1..32BF     ; W  # No    [15] CIRCLED NUMBER THIRTY SIX..CIRCLED NUMBER FIFTY
+32C0..32FF     ; W  # So    [64] IDEOGRAPHIC TELEGRAPH SYMBOL FOR JANUARY..SQUARE ERA NAME REIWA
+3300..33FF     ; W  # So   [256] SQUARE APAATO..SQUARE GAL
+3400..4DBF     ; W  # Lo  [6592] CJK UNIFIED IDEOGRAPH-3400..CJK UNIFIED IDEOGRAPH-4DBF
+4DC0..4DFF     ; N  # So    [64] HEXAGRAM FOR THE CREATIVE HEAVEN..HEXAGRAM FOR BEFORE COMPLETION
+4E00..9FFF     ; W  # Lo [20992] CJK UNIFIED IDEOGRAPH-4E00..CJK UNIFIED IDEOGRAPH-9FFF
+A000..A014     ; W  # Lo    [21] YI SYLLABLE IT..YI SYLLABLE E
+A015           ; W  # Lm         YI SYLLABLE WU
+A016..A48C     ; W  # Lo  [1143] YI SYLLABLE BIT..YI SYLLABLE YYR
+A490..A4C6     ; W  # So    [55] YI RADICAL QOT..YI RADICAL KE
+A4D0..A4F7     ; N  # Lo    [40] LISU LETTER BA..LISU LETTER OE
+A4F8..A4FD     ; N  # Lm     [6] LISU LETTER TONE MYA TI..LISU LETTER TONE MYA JEU
+A4FE..A4FF     ; N  # Po     [2] LISU PUNCTUATION COMMA..LISU PUNCTUATION FULL STOP
+A500..A60B     ; N  # Lo   [268] VAI SYLLABLE EE..VAI SYLLABLE NG
+A60C           ; N  # Lm         VAI SYLLABLE LENGTHENER
+A60D..A60F     ; N  # Po     [3] VAI COMMA..VAI QUESTION MARK
+A610..A61F     ; N  # Lo    [16] VAI SYLLABLE NDOLE FA..VAI SYMBOL JONG
+A620..A629     ; N  # Nd    [10] VAI DIGIT ZERO..VAI DIGIT NINE
+A62A..A62B     ; N  # Lo     [2] VAI SYLLABLE NDOLE MA..VAI SYLLABLE NDOLE DO
+A640..A66D     ; N  # L&    [46] CYRILLIC CAPITAL LETTER ZEMLYA..CYRILLIC SMALL LETTER DOUBLE MONOCULAR O
+A66E           ; N  # Lo         CYRILLIC LETTER MULTIOCULAR O
+A66F           ; N  # Mn         COMBINING CYRILLIC VZMET
+A670..A672     ; N  # Me     [3] COMBINING CYRILLIC TEN MILLIONS SIGN..COMBINING CYRILLIC THOUSAND MILLIONS SIGN
+A673           ; N  # Po         SLAVONIC ASTERISK
+A674..A67D     ; N  # Mn    [10] COMBINING CYRILLIC LETTER UKRAINIAN IE..COMBINING CYRILLIC PAYEROK
+A67E           ; N  # Po         CYRILLIC KAVYKA
+A67F           ; N  # Lm         CYRILLIC PAYEROK
+A680..A69B     ; N  # L&    [28] CYRILLIC CAPITAL LETTER DWE..CYRILLIC SMALL LETTER CROSSED O
+A69C..A69D     ; N  # Lm     [2] MODIFIER LETTER CYRILLIC HARD SIGN..MODIFIER LETTER CYRILLIC SOFT SIGN
+A69E..A69F     ; N  # Mn     [2] COMBINING CYRILLIC LETTER EF..COMBINING CYRILLIC LETTER IOTIFIED E
+A6A0..A6E5     ; N  # Lo    [70] BAMUM LETTER A..BAMUM LETTER KI
+A6E6..A6EF     ; N  # Nl    [10] BAMUM LETTER MO..BAMUM LETTER KOGHOM
+A6F0..A6F1     ; N  # Mn     [2] BAMUM COMBINING MARK KOQNDON..BAMUM COMBINING MARK TUKWENTIS
+A6F2..A6F7     ; N  # Po     [6] BAMUM NJAEMLI..BAMUM QUESTION MARK
+A700..A716     ; N  # Sk    [23] MODIFIER LETTER CHINESE TONE YIN PING..MODIFIER LETTER EXTRA-LOW LEFT-STEM TONE BAR
+A717..A71F     ; N  # Lm     [9] MODIFIER LETTER DOT VERTICAL BAR..MODIFIER LETTER LOW INVERTED EXCLAMATION MARK
+A720..A721     ; N  # Sk     [2] MODIFIER LETTER STRESS AND HIGH TONE..MODIFIER LETTER STRESS AND LOW TONE
+A722..A76F     ; N  # L&    [78] LATIN CAPITAL LETTER EGYPTOLOGICAL ALEF..LATIN SMALL LETTER CON
+A770           ; N  # Lm         MODIFIER LETTER US
+A771..A787     ; N  # L&    [23] LATIN SMALL LETTER DUM..LATIN SMALL LETTER INSULAR T
+A788           ; N  # Lm         MODIFIER LETTER LOW CIRCUMFLEX ACCENT
+A789..A78A     ; N  # Sk     [2] MODIFIER LETTER COLON..MODIFIER LETTER SHORT EQUALS SIGN
+A78B..A78E     ; N  # L&     [4] LATIN CAPITAL LETTER SALTILLO..LATIN SMALL LETTER L WITH RETROFLEX HOOK AND BELT
+A78F           ; N  # Lo         LATIN LETTER SINOLOGICAL DOT
+A790..A7CA     ; N  # L&    [59] LATIN CAPITAL LETTER N WITH DESCENDER..LATIN SMALL LETTER S WITH SHORT STROKE OVERLAY
+A7D0..A7D1     ; N  # L&     [2] LATIN CAPITAL LETTER CLOSED INSULAR G..LATIN SMALL LETTER CLOSED INSULAR G
+A7D3           ; N  # Ll         LATIN SMALL LETTER DOUBLE THORN
+A7D5..A7D9     ; N  # L&     [5] LATIN SMALL LETTER DOUBLE WYNN..LATIN SMALL LETTER SIGMOID S
+A7F2..A7F4     ; N  # Lm     [3] MODIFIER LETTER CAPITAL C..MODIFIER LETTER CAPITAL Q
+A7F5..A7F6     ; N  # L&     [2] LATIN CAPITAL LETTER REVERSED HALF H..LATIN SMALL LETTER REVERSED HALF H
+A7F7           ; N  # Lo         LATIN EPIGRAPHIC LETTER SIDEWAYS I
+A7F8..A7F9     ; N  # Lm     [2] MODIFIER LETTER CAPITAL H WITH STROKE..MODIFIER LETTER SMALL LIGATURE OE
+A7FA           ; N  # Ll         LATIN LETTER SMALL CAPITAL TURNED M
+A7FB..A7FF     ; N  # Lo     [5] LATIN EPIGRAPHIC LETTER REVERSED F..LATIN EPIGRAPHIC LETTER ARCHAIC M
+A800..A801     ; N  # Lo     [2] SYLOTI NAGRI LETTER A..SYLOTI NAGRI LETTER I
+A802           ; N  # Mn         SYLOTI NAGRI SIGN DVISVARA
+A803..A805     ; N  # Lo     [3] SYLOTI NAGRI LETTER U..SYLOTI NAGRI LETTER O
+A806           ; N  # Mn         SYLOTI NAGRI SIGN HASANTA
+A807..A80A     ; N  # Lo     [4] SYLOTI NAGRI LETTER KO..SYLOTI NAGRI LETTER GHO
+A80B           ; N  # Mn         SYLOTI NAGRI SIGN ANUSVARA
+A80C..A822     ; N  # Lo    [23] SYLOTI NAGRI LETTER CO..SYLOTI NAGRI LETTER HO
+A823..A824     ; N  # Mc     [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI NAGRI VOWEL SIGN I
+A825..A826     ; N  # Mn     [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI NAGRI VOWEL SIGN E
+A827           ; N  # Mc         SYLOTI NAGRI VOWEL SIGN OO
+A828..A82B     ; N  # So     [4] SYLOTI NAGRI POETRY MARK-1..SYLOTI NAGRI POETRY MARK-4
+A82C           ; N  # Mn         SYLOTI NAGRI SIGN ALTERNATE HASANTA
+A830..A835     ; N  # No     [6] NORTH INDIC FRACTION ONE QUARTER..NORTH INDIC FRACTION THREE SIXTEENTHS
+A836..A837     ; N  # So     [2] NORTH INDIC QUARTER MARK..NORTH INDIC PLACEHOLDER MARK
+A838           ; N  # Sc         NORTH INDIC RUPEE MARK
+A839           ; N  # So         NORTH INDIC QUANTITY MARK
+A840..A873     ; N  # Lo    [52] PHAGS-PA LETTER KA..PHAGS-PA LETTER CANDRABINDU
+A874..A877     ; N  # Po     [4] PHAGS-PA SINGLE HEAD MARK..PHAGS-PA MARK DOUBLE SHAD
+A880..A881     ; N  # Mc     [2] SAURASHTRA SIGN ANUSVARA..SAURASHTRA SIGN VISARGA
+A882..A8B3     ; N  # Lo    [50] SAURASHTRA LETTER A..SAURASHTRA LETTER LLA
+A8B4..A8C3     ; N  # Mc    [16] SAURASHTRA CONSONANT SIGN HAARU..SAURASHTRA VOWEL SIGN AU
+A8C4..A8C5     ; N  # Mn     [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA SIGN CANDRABINDU
+A8CE..A8CF     ; N  # Po     [2] SAURASHTRA DANDA..SAURASHTRA DOUBLE DANDA
+A8D0..A8D9     ; N  # Nd    [10] SAURASHTRA DIGIT ZERO..SAURASHTRA DIGIT NINE
+A8E0..A8F1     ; N  # Mn    [18] COMBINING DEVANAGARI DIGIT ZERO..COMBINING DEVANAGARI SIGN AVAGRAHA
+A8F2..A8F7     ; N  # Lo     [6] DEVANAGARI SIGN SPACING CANDRABINDU..DEVANAGARI SIGN CANDRABINDU AVAGRAHA
+A8F8..A8FA     ; N  # Po     [3] DEVANAGARI SIGN PUSHPIKA..DEVANAGARI CARET
+A8FB           ; N  # Lo         DEVANAGARI HEADSTROKE
+A8FC           ; N  # Po         DEVANAGARI SIGN SIDDHAM
+A8FD..A8FE     ; N  # Lo     [2] DEVANAGARI JAIN OM..DEVANAGARI LETTER AY
+A8FF           ; N  # Mn         DEVANAGARI VOWEL SIGN AY
+A900..A909     ; N  # Nd    [10] KAYAH LI DIGIT ZERO..KAYAH LI DIGIT NINE
+A90A..A925     ; N  # Lo    [28] KAYAH LI LETTER KA..KAYAH LI LETTER OO
+A926..A92D     ; N  # Mn     [8] KAYAH LI VOWEL UE..KAYAH LI TONE CALYA PLOPHU
+A92E..A92F     ; N  # Po     [2] KAYAH LI SIGN CWI..KAYAH LI SIGN SHYA
+A930..A946     ; N  # Lo    [23] REJANG LETTER KA..REJANG LETTER A
+A947..A951     ; N  # Mn    [11] REJANG VOWEL SIGN I..REJANG CONSONANT SIGN R
+A952..A953     ; N  # Mc     [2] REJANG CONSONANT SIGN H..REJANG VIRAMA
+A95F           ; N  # Po         REJANG SECTION MARK
+A960..A97C     ; W  # Lo    [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANGUL CHOSEONG SSANGYEORINHIEUH
+A980..A982     ; N  # Mn     [3] JAVANESE SIGN PANYANGGA..JAVANESE SIGN LAYAR
+A983           ; N  # Mc         JAVANESE SIGN WIGNYAN
+A984..A9B2     ; N  # Lo    [47] JAVANESE LETTER A..JAVANESE LETTER HA
+A9B3           ; N  # Mn         JAVANESE SIGN CECAK TELU
+A9B4..A9B5     ; N  # Mc     [2] JAVANESE VOWEL SIGN TARUNG..JAVANESE VOWEL SIGN TOLONG
+A9B6..A9B9     ; N  # Mn     [4] JAVANESE VOWEL SIGN WULU..JAVANESE VOWEL SIGN SUKU MENDUT
+A9BA..A9BB     ; N  # Mc     [2] JAVANESE VOWEL SIGN TALING..JAVANESE VOWEL SIGN DIRGA MURE
+A9BC..A9BD     ; N  # Mn     [2] JAVANESE VOWEL SIGN PEPET..JAVANESE CONSONANT SIGN KERET
+A9BE..A9C0     ; N  # Mc     [3] JAVANESE CONSONANT SIGN PENGKAL..JAVANESE PANGKON
+A9C1..A9CD     ; N  # Po    [13] JAVANESE LEFT RERENGGAN..JAVANESE TURNED PADA PISELEH
+A9CF           ; N  # Lm         JAVANESE PANGRANGKEP
+A9D0..A9D9     ; N  # Nd    [10] JAVANESE DIGIT ZERO..JAVANESE DIGIT NINE
+A9DE..A9DF     ; N  # Po     [2] JAVANESE PADA TIRTA TUMETES..JAVANESE PADA ISEN-ISEN
+A9E0..A9E4     ; N  # Lo     [5] MYANMAR LETTER SHAN GHA..MYANMAR LETTER SHAN BHA
+A9E5           ; N  # Mn         MYANMAR SIGN SHAN SAW
+A9E6           ; N  # Lm         MYANMAR MODIFIER LETTER SHAN REDUPLICATION
+A9E7..A9EF     ; N  # Lo     [9] MYANMAR LETTER TAI LAING NYA..MYANMAR LETTER TAI LAING NNA
+A9F0..A9F9     ; N  # Nd    [10] MYANMAR TAI LAING DIGIT ZERO..MYANMAR TAI LAING DIGIT NINE
+A9FA..A9FE     ; N  # Lo     [5] MYANMAR LETTER TAI LAING LLA..MYANMAR LETTER TAI LAING BHA
+AA00..AA28     ; N  # Lo    [41] CHAM LETTER A..CHAM LETTER HA
+AA29..AA2E     ; N  # Mn     [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIGN OE
+AA2F..AA30     ; N  # Mc     [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI
+AA31..AA32     ; N  # Mn     [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIGN UE
+AA33..AA34     ; N  # Mc     [2] CHAM CONSONANT SIGN YA..CHAM CONSONANT SIGN RA
+AA35..AA36     ; N  # Mn     [2] CHAM CONSONANT SIGN LA..CHAM CONSONANT SIGN WA
+AA40..AA42     ; N  # Lo     [3] CHAM LETTER FINAL K..CHAM LETTER FINAL NG
+AA43           ; N  # Mn         CHAM CONSONANT SIGN FINAL NG
+AA44..AA4B     ; N  # Lo     [8] CHAM LETTER FINAL CH..CHAM LETTER FINAL SS
+AA4C           ; N  # Mn         CHAM CONSONANT SIGN FINAL M
+AA4D           ; N  # Mc         CHAM CONSONANT SIGN FINAL H
+AA50..AA59     ; N  # Nd    [10] CHAM DIGIT ZERO..CHAM DIGIT NINE
+AA5C..AA5F     ; N  # Po     [4] CHAM PUNCTUATION SPIRAL..CHAM PUNCTUATION TRIPLE DANDA
+AA60..AA6F     ; N  # Lo    [16] MYANMAR LETTER KHAMTI GA..MYANMAR LETTER KHAMTI FA
+AA70           ; N  # Lm         MYANMAR MODIFIER LETTER KHAMTI REDUPLICATION
+AA71..AA76     ; N  # Lo     [6] MYANMAR LETTER KHAMTI XA..MYANMAR LOGOGRAM KHAMTI HM
+AA77..AA79     ; N  # So     [3] MYANMAR SYMBOL AITON EXCLAMATION..MYANMAR SYMBOL AITON TWO
+AA7A           ; N  # Lo         MYANMAR LETTER AITON RA
+AA7B           ; N  # Mc         MYANMAR SIGN PAO KAREN TONE
+AA7C           ; N  # Mn         MYANMAR SIGN TAI LAING TONE-2
+AA7D           ; N  # Mc         MYANMAR SIGN TAI LAING TONE-5
+AA7E..AA7F     ; N  # Lo     [2] MYANMAR LETTER SHWE PALAUNG CHA..MYANMAR LETTER SHWE PALAUNG SHA
+AA80..AAAF     ; N  # Lo    [48] TAI VIET LETTER LOW KO..TAI VIET LETTER HIGH O
+AAB0           ; N  # Mn         TAI VIET MAI KANG
+AAB1           ; N  # Lo         TAI VIET VOWEL AA
+AAB2..AAB4     ; N  # Mn     [3] TAI VIET VOWEL I..TAI VIET VOWEL U
+AAB5..AAB6     ; N  # Lo     [2] TAI VIET VOWEL E..TAI VIET VOWEL O
+AAB7..AAB8     ; N  # Mn     [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA
+AAB9..AABD     ; N  # Lo     [5] TAI VIET VOWEL UEA..TAI VIET VOWEL AN
+AABE..AABF     ; N  # Mn     [2] TAI VIET VOWEL AM..TAI VIET TONE MAI EK
+AAC0           ; N  # Lo         TAI VIET TONE MAI NUENG
+AAC1           ; N  # Mn         TAI VIET TONE MAI THO
+AAC2           ; N  # Lo         TAI VIET TONE MAI SONG
+AADB..AADC     ; N  # Lo     [2] TAI VIET SYMBOL KON..TAI VIET SYMBOL NUENG
+AADD           ; N  # Lm         TAI VIET SYMBOL SAM
+AADE..AADF     ; N  # Po     [2] TAI VIET SYMBOL HO HOI..TAI VIET SYMBOL KOI KOI
+AAE0..AAEA     ; N  # Lo    [11] MEETEI MAYEK LETTER E..MEETEI MAYEK LETTER SSA
+AAEB           ; N  # Mc         MEETEI MAYEK VOWEL SIGN II
+AAEC..AAED     ; N  # Mn     [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI MAYEK VOWEL SIGN AAI
+AAEE..AAEF     ; N  # Mc     [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI MAYEK VOWEL SIGN AAU
+AAF0..AAF1     ; N  # Po     [2] MEETEI MAYEK CHEIKHAN..MEETEI MAYEK AHANG KHUDAM
+AAF2           ; N  # Lo         MEETEI MAYEK ANJI
+AAF3..AAF4     ; N  # Lm     [2] MEETEI MAYEK SYLLABLE REPETITION MARK..MEETEI MAYEK WORD REPETITION MARK
+AAF5           ; N  # Mc         MEETEI MAYEK VOWEL SIGN VISARGA
+AAF6           ; N  # Mn         MEETEI MAYEK VIRAMA
+AB01..AB06     ; N  # Lo     [6] ETHIOPIC SYLLABLE TTHU..ETHIOPIC SYLLABLE TTHO
+AB09..AB0E     ; N  # Lo     [6] ETHIOPIC SYLLABLE DDHU..ETHIOPIC SYLLABLE DDHO
+AB11..AB16     ; N  # Lo     [6] ETHIOPIC SYLLABLE DZU..ETHIOPIC SYLLABLE DZO
+AB20..AB26     ; N  # Lo     [7] ETHIOPIC SYLLABLE CCHHA..ETHIOPIC SYLLABLE CCHHO
+AB28..AB2E     ; N  # Lo     [7] ETHIOPIC SYLLABLE BBA..ETHIOPIC SYLLABLE BBO
+AB30..AB5A     ; N  # Ll    [43] LATIN SMALL LETTER BARRED ALPHA..LATIN SMALL LETTER Y WITH SHORT RIGHT LEG
+AB5B           ; N  # Sk         MODIFIER BREVE WITH INVERTED BREVE
+AB5C..AB5F     ; N  # Lm     [4] MODIFIER LETTER SMALL HENG..MODIFIER LETTER SMALL U WITH LEFT HOOK
+AB60..AB68     ; N  # Ll     [9] LATIN SMALL LETTER SAKHA YAT..LATIN SMALL LETTER TURNED R WITH MIDDLE TILDE
+AB69           ; N  # Lm         MODIFIER LETTER SMALL TURNED W
+AB6A..AB6B     ; N  # Sk     [2] MODIFIER LETTER LEFT TACK..MODIFIER LETTER RIGHT TACK
+AB70..ABBF     ; N  # Ll    [80] CHEROKEE SMALL LETTER A..CHEROKEE SMALL LETTER YA
+ABC0..ABE2     ; N  # Lo    [35] MEETEI MAYEK LETTER KOK..MEETEI MAYEK LETTER I LONSUM
+ABE3..ABE4     ; N  # Mc     [2] MEETEI MAYEK VOWEL SIGN ONAP..MEETEI MAYEK VOWEL SIGN INAP
+ABE5           ; N  # Mn         MEETEI MAYEK VOWEL SIGN ANAP
+ABE6..ABE7     ; N  # Mc     [2] MEETEI MAYEK VOWEL SIGN YENAP..MEETEI MAYEK VOWEL SIGN SOUNAP
+ABE8           ; N  # Mn         MEETEI MAYEK VOWEL SIGN UNAP
+ABE9..ABEA     ; N  # Mc     [2] MEETEI MAYEK VOWEL SIGN CHEINAP..MEETEI MAYEK VOWEL SIGN NUNG
+ABEB           ; N  # Po         MEETEI MAYEK CHEIKHEI
+ABEC           ; N  # Mc         MEETEI MAYEK LUM IYEK
+ABED           ; N  # Mn         MEETEI MAYEK APUN IYEK
+ABF0..ABF9     ; N  # Nd    [10] MEETEI MAYEK DIGIT ZERO..MEETEI MAYEK DIGIT NINE
+AC00..D7A3     ; W  # Lo [11172] HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH
+D7B0..D7C6     ; N  # Lo    [23] HANGUL JUNGSEONG O-YEO..HANGUL JUNGSEONG ARAEA-E
+D7CB..D7FB     ; N  # Lo    [49] HANGUL JONGSEONG NIEUN-RIEUL..HANGUL JONGSEONG PHIEUPH-THIEUTH
+D800..DB7F     ; N  # Cs   [896] <surrogate-D800>..<surrogate-DB7F>
+DB80..DBFF     ; N  # Cs   [128] <surrogate-DB80>..<surrogate-DBFF>
+DC00..DFFF     ; N  # Cs  [1024] <surrogate-DC00>..<surrogate-DFFF>
+E000..F8FF     ; A  # Co  [6400] <private-use-E000>..<private-use-F8FF>
+F900..FA6D     ; W  # Lo   [366] CJK COMPATIBILITY IDEOGRAPH-F900..CJK COMPATIBILITY IDEOGRAPH-FA6D
+FA6E..FA6F     ; W  # Cn     [2] <reserved-FA6E>..<reserved-FA6F>
+FA70..FAD9     ; W  # Lo   [106] CJK COMPATIBILITY IDEOGRAPH-FA70..CJK COMPATIBILITY IDEOGRAPH-FAD9
+FADA..FAFF     ; W  # Cn    [38] <reserved-FADA>..<reserved-FAFF>
+FB00..FB06     ; N  # Ll     [7] LATIN SMALL LIGATURE FF..LATIN SMALL LIGATURE ST
+FB13..FB17     ; N  # Ll     [5] ARMENIAN SMALL LIGATURE MEN NOW..ARMENIAN SMALL LIGATURE MEN XEH
+FB1D           ; N  # Lo         HEBREW LETTER YOD WITH HIRIQ
+FB1E           ; N  # Mn         HEBREW POINT JUDEO-SPANISH VARIKA
+FB1F..FB28     ; N  # Lo    [10] HEBREW LIGATURE YIDDISH YOD YOD PATAH..HEBREW LETTER WIDE TAV
+FB29           ; N  # Sm         HEBREW LETTER ALTERNATIVE PLUS SIGN
+FB2A..FB36     ; N  # Lo    [13] HEBREW LETTER SHIN WITH SHIN DOT..HEBREW LETTER ZAYIN WITH DAGESH
+FB38..FB3C     ; N  # Lo     [5] HEBREW LETTER TET WITH DAGESH..HEBREW LETTER LAMED WITH DAGESH
+FB3E           ; N  # Lo         HEBREW LETTER MEM WITH DAGESH
+FB40..FB41     ; N  # Lo     [2] HEBREW LETTER NUN WITH DAGESH..HEBREW LETTER SAMEKH WITH DAGESH
+FB43..FB44     ; N  # Lo     [2] HEBREW LETTER FINAL PE WITH DAGESH..HEBREW LETTER PE WITH DAGESH
+FB46..FB4F     ; N  # Lo    [10] HEBREW LETTER TSADI WITH DAGESH..HEBREW LIGATURE ALEF LAMED
+FB50..FBB1     ; N  # Lo    [98] ARABIC LETTER ALEF WASLA ISOLATED FORM..ARABIC LETTER YEH BARREE WITH HAMZA ABOVE FINAL FORM
+FBB2..FBC2     ; N  # Sk    [17] ARABIC SYMBOL DOT ABOVE..ARABIC SYMBOL WASLA ABOVE
+FBD3..FD3D     ; N  # Lo   [363] ARABIC LETTER NG ISOLATED FORM..ARABIC LIGATURE ALEF WITH FATHATAN ISOLATED FORM
+FD3E           ; N  # Pe         ORNATE LEFT PARENTHESIS
+FD3F           ; N  # Ps         ORNATE RIGHT PARENTHESIS
+FD40..FD4F     ; N  # So    [16] ARABIC LIGATURE RAHIMAHU ALLAAH..ARABIC LIGATURE RAHIMAHUM ALLAAH
+FD50..FD8F     ; N  # Lo    [64] ARABIC LIGATURE TEH WITH JEEM WITH MEEM INITIAL FORM..ARABIC LIGATURE MEEM WITH KHAH WITH MEEM INITIAL FORM
+FD92..FDC7     ; N  # Lo    [54] ARABIC LIGATURE MEEM WITH JEEM WITH KHAH INITIAL FORM..ARABIC LIGATURE NOON WITH JEEM WITH YEH FINAL FORM
+FDCF           ; N  # So         ARABIC LIGATURE SALAAMUHU ALAYNAA
+FDF0..FDFB     ; N  # Lo    [12] ARABIC LIGATURE SALLA USED AS KORANIC STOP SIGN ISOLATED FORM..ARABIC LIGATURE JALLAJALALOUHOU
+FDFC           ; N  # Sc         RIAL SIGN
+FDFD..FDFF     ; N  # So     [3] ARABIC LIGATURE BISMILLAH AR-RAHMAN AR-RAHEEM..ARABIC LIGATURE AZZA WA JALL
+FE00..FE0F     ; A  # Mn    [16] VARIATION SELECTOR-1..VARIATION SELECTOR-16
+FE10..FE16     ; W  # Po     [7] PRESENTATION FORM FOR VERTICAL COMMA..PRESENTATION FORM FOR VERTICAL QUESTION MARK
+FE17           ; W  # Ps         PRESENTATION FORM FOR VERTICAL LEFT WHITE LENTICULAR BRACKET
+FE18           ; W  # Pe         PRESENTATION FORM FOR VERTICAL RIGHT WHITE LENTICULAR BRAKCET
+FE19           ; W  # Po         PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS
+FE20..FE2F     ; N  # Mn    [16] COMBINING LIGATURE LEFT HALF..COMBINING CYRILLIC TITLO RIGHT HALF
+FE30           ; W  # Po         PRESENTATION FORM FOR VERTICAL TWO DOT LEADER
+FE31..FE32     ; W  # Pd     [2] PRESENTATION FORM FOR VERTICAL EM DASH..PRESENTATION FORM FOR VERTICAL EN DASH
+FE33..FE34     ; W  # Pc     [2] PRESENTATION FORM FOR VERTICAL LOW LINE..PRESENTATION FORM FOR VERTICAL WAVY LOW LINE
+FE35           ; W  # Ps         PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS
+FE36           ; W  # Pe         PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS
+FE37           ; W  # Ps         PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET
+FE38           ; W  # Pe         PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET
+FE39           ; W  # Ps         PRESENTATION FORM FOR VERTICAL LEFT TORTOISE SHELL BRACKET
+FE3A           ; W  # Pe         PRESENTATION FORM FOR VERTICAL RIGHT TORTOISE SHELL BRACKET
+FE3B           ; W  # Ps         PRESENTATION FORM FOR VERTICAL LEFT BLACK LENTICULAR BRACKET
+FE3C           ; W  # Pe         PRESENTATION FORM FOR VERTICAL RIGHT BLACK LENTICULAR BRACKET
+FE3D           ; W  # Ps         PRESENTATION FORM FOR VERTICAL LEFT DOUBLE ANGLE BRACKET
+FE3E           ; W  # Pe         PRESENTATION FORM FOR VERTICAL RIGHT DOUBLE ANGLE BRACKET
+FE3F           ; W  # Ps         PRESENTATION FORM FOR VERTICAL LEFT ANGLE BRACKET
+FE40           ; W  # Pe         PRESENTATION FORM FOR VERTICAL RIGHT ANGLE BRACKET
+FE41           ; W  # Ps         PRESENTATION FORM FOR VERTICAL LEFT CORNER BRACKET
+FE42           ; W  # Pe         PRESENTATION FORM FOR VERTICAL RIGHT CORNER BRACKET
+FE43           ; W  # Ps         PRESENTATION FORM FOR VERTICAL LEFT WHITE CORNER BRACKET
+FE44           ; W  # Pe         PRESENTATION FORM FOR VERTICAL RIGHT WHITE CORNER BRACKET
+FE45..FE46     ; W  # Po     [2] SESAME DOT..WHITE SESAME DOT
+FE47           ; W  # Ps         PRESENTATION FORM FOR VERTICAL LEFT SQUARE BRACKET
+FE48           ; W  # Pe         PRESENTATION FORM FOR VERTICAL RIGHT SQUARE BRACKET
+FE49..FE4C     ; W  # Po     [4] DASHED OVERLINE..DOUBLE WAVY OVERLINE
+FE4D..FE4F     ; W  # Pc     [3] DASHED LOW LINE..WAVY LOW LINE
+FE50..FE52     ; W  # Po     [3] SMALL COMMA..SMALL FULL STOP
+FE54..FE57     ; W  # Po     [4] SMALL SEMICOLON..SMALL EXCLAMATION MARK
+FE58           ; W  # Pd         SMALL EM DASH
+FE59           ; W  # Ps         SMALL LEFT PARENTHESIS
+FE5A           ; W  # Pe         SMALL RIGHT PARENTHESIS
+FE5B           ; W  # Ps         SMALL LEFT CURLY BRACKET
+FE5C           ; W  # Pe         SMALL RIGHT CURLY BRACKET
+FE5D           ; W  # Ps         SMALL LEFT TORTOISE SHELL BRACKET
+FE5E           ; W  # Pe         SMALL RIGHT TORTOISE SHELL BRACKET
+FE5F..FE61     ; W  # Po     [3] SMALL NUMBER SIGN..SMALL ASTERISK
+FE62           ; W  # Sm         SMALL PLUS SIGN
+FE63           ; W  # Pd         SMALL HYPHEN-MINUS
+FE64..FE66     ; W  # Sm     [3] SMALL LESS-THAN SIGN..SMALL EQUALS SIGN
+FE68           ; W  # Po         SMALL REVERSE SOLIDUS
+FE69           ; W  # Sc         SMALL DOLLAR SIGN
+FE6A..FE6B     ; W  # Po     [2] SMALL PERCENT SIGN..SMALL COMMERCIAL AT
+FE70..FE74     ; N  # Lo     [5] ARABIC FATHATAN ISOLATED FORM..ARABIC KASRATAN ISOLATED FORM
+FE76..FEFC     ; N  # Lo   [135] ARABIC FATHA ISOLATED FORM..ARABIC LIGATURE LAM WITH ALEF FINAL FORM
+FEFF           ; N  # Cf         ZERO WIDTH NO-BREAK SPACE
+FF01..FF03     ; F  # Po     [3] FULLWIDTH EXCLAMATION MARK..FULLWIDTH NUMBER SIGN
+FF04           ; F  # Sc         FULLWIDTH DOLLAR SIGN
+FF05..FF07     ; F  # Po     [3] FULLWIDTH PERCENT SIGN..FULLWIDTH APOSTROPHE
+FF08           ; F  # Ps         FULLWIDTH LEFT PARENTHESIS
+FF09           ; F  # Pe         FULLWIDTH RIGHT PARENTHESIS
+FF0A           ; F  # Po         FULLWIDTH ASTERISK
+FF0B           ; F  # Sm         FULLWIDTH PLUS SIGN
+FF0C           ; F  # Po         FULLWIDTH COMMA
+FF0D           ; F  # Pd         FULLWIDTH HYPHEN-MINUS
+FF0E..FF0F     ; F  # Po     [2] FULLWIDTH FULL STOP..FULLWIDTH SOLIDUS
+FF10..FF19     ; F  # Nd    [10] FULLWIDTH DIGIT ZERO..FULLWIDTH DIGIT NINE
+FF1A..FF1B     ; F  # Po     [2] FULLWIDTH COLON..FULLWIDTH SEMICOLON
+FF1C..FF1E     ; F  # Sm     [3] FULLWIDTH LESS-THAN SIGN..FULLWIDTH GREATER-THAN SIGN
+FF1F..FF20     ; F  # Po     [2] FULLWIDTH QUESTION MARK..FULLWIDTH COMMERCIAL AT
+FF21..FF3A     ; F  # Lu    [26] FULLWIDTH LATIN CAPITAL LETTER A..FULLWIDTH LATIN CAPITAL LETTER Z
+FF3B           ; F  # Ps         FULLWIDTH LEFT SQUARE BRACKET
+FF3C           ; F  # Po         FULLWIDTH REVERSE SOLIDUS
+FF3D           ; F  # Pe         FULLWIDTH RIGHT SQUARE BRACKET
+FF3E           ; F  # Sk         FULLWIDTH CIRCUMFLEX ACCENT
+FF3F           ; F  # Pc         FULLWIDTH LOW LINE
+FF40           ; F  # Sk         FULLWIDTH GRAVE ACCENT
+FF41..FF5A     ; F  # Ll    [26] FULLWIDTH LATIN SMALL LETTER A..FULLWIDTH LATIN SMALL LETTER Z
+FF5B           ; F  # Ps         FULLWIDTH LEFT CURLY BRACKET
+FF5C           ; F  # Sm         FULLWIDTH VERTICAL LINE
+FF5D           ; F  # Pe         FULLWIDTH RIGHT CURLY BRACKET
+FF5E           ; F  # Sm         FULLWIDTH TILDE
+FF5F           ; F  # Ps         FULLWIDTH LEFT WHITE PARENTHESIS
+FF60           ; F  # Pe         FULLWIDTH RIGHT WHITE PARENTHESIS
+FF61           ; H  # Po         HALFWIDTH IDEOGRAPHIC FULL STOP
+FF62           ; H  # Ps         HALFWIDTH LEFT CORNER BRACKET
+FF63           ; H  # Pe         HALFWIDTH RIGHT CORNER BRACKET
+FF64..FF65     ; H  # Po     [2] HALFWIDTH IDEOGRAPHIC COMMA..HALFWIDTH KATAKANA MIDDLE DOT
+FF66..FF6F     ; H  # Lo    [10] HALFWIDTH KATAKANA LETTER WO..HALFWIDTH KATAKANA LETTER SMALL TU
+FF70           ; H  # Lm         HALFWIDTH KATAKANA-HIRAGANA PROLONGED SOUND MARK
+FF71..FF9D     ; H  # Lo    [45] HALFWIDTH KATAKANA LETTER A..HALFWIDTH KATAKANA LETTER N
+FF9E..FF9F     ; H  # Lm     [2] HALFWIDTH KATAKANA VOICED SOUND MARK..HALFWIDTH KATAKANA SEMI-VOICED SOUND MARK
+FFA0..FFBE     ; H  # Lo    [31] HALFWIDTH HANGUL FILLER..HALFWIDTH HANGUL LETTER HIEUH
+FFC2..FFC7     ; H  # Lo     [6] HALFWIDTH HANGUL LETTER A..HALFWIDTH HANGUL LETTER E
+FFCA..FFCF     ; H  # Lo     [6] HALFWIDTH HANGUL LETTER YEO..HALFWIDTH HANGUL LETTER OE
+FFD2..FFD7     ; H  # Lo     [6] HALFWIDTH HANGUL LETTER YO..HALFWIDTH HANGUL LETTER YU
+FFDA..FFDC     ; H  # Lo     [3] HALFWIDTH HANGUL LETTER EU..HALFWIDTH HANGUL LETTER I
+FFE0..FFE1     ; F  # Sc     [2] FULLWIDTH CENT SIGN..FULLWIDTH POUND SIGN
+FFE2           ; F  # Sm         FULLWIDTH NOT SIGN
+FFE3           ; F  # Sk         FULLWIDTH MACRON
+FFE4           ; F  # So         FULLWIDTH BROKEN BAR
+FFE5..FFE6     ; F  # Sc     [2] FULLWIDTH YEN SIGN..FULLWIDTH WON SIGN
+FFE8           ; H  # So         HALFWIDTH FORMS LIGHT VERTICAL
+FFE9..FFEC     ; H  # Sm     [4] HALFWIDTH LEFTWARDS ARROW..HALFWIDTH DOWNWARDS ARROW
+FFED..FFEE     ; H  # So     [2] HALFWIDTH BLACK SQUARE..HALFWIDTH WHITE CIRCLE
+FFF9..FFFB     ; N  # Cf     [3] INTERLINEAR ANNOTATION ANCHOR..INTERLINEAR ANNOTATION TERMINATOR
+FFFC           ; N  # So         OBJECT REPLACEMENT CHARACTER
+FFFD           ; A  # So         REPLACEMENT CHARACTER
+10000..1000B   ; N  # Lo    [12] LINEAR B SYLLABLE B008 A..LINEAR B SYLLABLE B046 JE
+1000D..10026   ; N  # Lo    [26] LINEAR B SYLLABLE B036 JO..LINEAR B SYLLABLE B032 QO
+10028..1003A   ; N  # Lo    [19] LINEAR B SYLLABLE B060 RA..LINEAR B SYLLABLE B042 WO
+1003C..1003D   ; N  # Lo     [2] LINEAR B SYLLABLE B017 ZA..LINEAR B SYLLABLE B074 ZE
+1003F..1004D   ; N  # Lo    [15] LINEAR B SYLLABLE B020 ZO..LINEAR B SYLLABLE B091 TWO
+10050..1005D   ; N  # Lo    [14] LINEAR B SYMBOL B018..LINEAR B SYMBOL B089
+10080..100FA   ; N  # Lo   [123] LINEAR B IDEOGRAM B100 MAN..LINEAR B IDEOGRAM VESSEL B305
+10100..10102   ; N  # Po     [3] AEGEAN WORD SEPARATOR LINE..AEGEAN CHECK MARK
+10107..10133   ; N  # No    [45] AEGEAN NUMBER ONE..AEGEAN NUMBER NINETY THOUSAND
+10137..1013F   ; N  # So     [9] AEGEAN WEIGHT BASE UNIT..AEGEAN MEASURE THIRD SUBUNIT
+10140..10174   ; N  # Nl    [53] GREEK ACROPHONIC ATTIC ONE QUARTER..GREEK ACROPHONIC STRATIAN FIFTY MNAS
+10175..10178   ; N  # No     [4] GREEK ONE HALF SIGN..GREEK THREE QUARTERS SIGN
+10179..10189   ; N  # So    [17] GREEK YEAR SIGN..GREEK TRYBLION BASE SIGN
+1018A..1018B   ; N  # No     [2] GREEK ZERO SIGN..GREEK ONE QUARTER SIGN
+1018C..1018E   ; N  # So     [3] GREEK SINUSOID SIGN..NOMISMA SIGN
+10190..1019C   ; N  # So    [13] ROMAN SEXTANS SIGN..ASCIA SYMBOL
+101A0          ; N  # So         GREEK SYMBOL TAU RHO
+101D0..101FC   ; N  # So    [45] PHAISTOS DISC SIGN PEDESTRIAN..PHAISTOS DISC SIGN WAVY BAND
+101FD          ; N  # Mn         PHAISTOS DISC SIGN COMBINING OBLIQUE STROKE
+10280..1029C   ; N  # Lo    [29] LYCIAN LETTER A..LYCIAN LETTER X
+102A0..102D0   ; N  # Lo    [49] CARIAN LETTER A..CARIAN LETTER UUU3
+102E0          ; N  # Mn         COPTIC EPACT THOUSANDS MARK
+102E1..102FB   ; N  # No    [27] COPTIC EPACT DIGIT ONE..COPTIC EPACT NUMBER NINE HUNDRED
+10300..1031F   ; N  # Lo    [32] OLD ITALIC LETTER A..OLD ITALIC LETTER ESS
+10320..10323   ; N  # No     [4] OLD ITALIC NUMERAL ONE..OLD ITALIC NUMERAL FIFTY
+1032D..1032F   ; N  # Lo     [3] OLD ITALIC LETTER YE..OLD ITALIC LETTER SOUTHERN TSE
+10330..10340   ; N  # Lo    [17] GOTHIC LETTER AHSA..GOTHIC LETTER PAIRTHRA
+10341          ; N  # Nl         GOTHIC LETTER NINETY
+10342..10349   ; N  # Lo     [8] GOTHIC LETTER RAIDA..GOTHIC LETTER OTHAL
+1034A          ; N  # Nl         GOTHIC LETTER NINE HUNDRED
+10350..10375   ; N  # Lo    [38] OLD PERMIC LETTER AN..OLD PERMIC LETTER IA
+10376..1037A   ; N  # Mn     [5] COMBINING OLD PERMIC LETTER AN..COMBINING OLD PERMIC LETTER SII
+10380..1039D   ; N  # Lo    [30] UGARITIC LETTER ALPA..UGARITIC LETTER SSU
+1039F          ; N  # Po         UGARITIC WORD DIVIDER
+103A0..103C3   ; N  # Lo    [36] OLD PERSIAN SIGN A..OLD PERSIAN SIGN HA
+103C8..103CF   ; N  # Lo     [8] OLD PERSIAN SIGN AURAMAZDAA..OLD PERSIAN SIGN BUUMISH
+103D0          ; N  # Po         OLD PERSIAN WORD DIVIDER
+103D1..103D5   ; N  # Nl     [5] OLD PERSIAN NUMBER ONE..OLD PERSIAN NUMBER HUNDRED
+10400..1044F   ; N  # L&    [80] DESERET CAPITAL LETTER LONG I..DESERET SMALL LETTER EW
+10450..1047F   ; N  # Lo    [48] SHAVIAN LETTER PEEP..SHAVIAN LETTER YEW
+10480..1049D   ; N  # Lo    [30] OSMANYA LETTER ALEF..OSMANYA LETTER OO
+104A0..104A9   ; N  # Nd    [10] OSMANYA DIGIT ZERO..OSMANYA DIGIT NINE
+104B0..104D3   ; N  # Lu    [36] OSAGE CAPITAL LETTER A..OSAGE CAPITAL LETTER ZHA
+104D8..104FB   ; N  # Ll    [36] OSAGE SMALL LETTER A..OSAGE SMALL LETTER ZHA
+10500..10527   ; N  # Lo    [40] ELBASAN LETTER A..ELBASAN LETTER KHE
+10530..10563   ; N  # Lo    [52] CAUCASIAN ALBANIAN LETTER ALT..CAUCASIAN ALBANIAN LETTER KIW
+1056F          ; N  # Po         CAUCASIAN ALBANIAN CITATION MARK
+10570..1057A   ; N  # Lu    [11] VITHKUQI CAPITAL LETTER A..VITHKUQI CAPITAL LETTER GA
+1057C..1058A   ; N  # Lu    [15] VITHKUQI CAPITAL LETTER HA..VITHKUQI CAPITAL LETTER RE
+1058C..10592   ; N  # Lu     [7] VITHKUQI CAPITAL LETTER SE..VITHKUQI CAPITAL LETTER XE
+10594..10595   ; N  # Lu     [2] VITHKUQI CAPITAL LETTER Y..VITHKUQI CAPITAL LETTER ZE
+10597..105A1   ; N  # Ll    [11] VITHKUQI SMALL LETTER A..VITHKUQI SMALL LETTER GA
+105A3..105B1   ; N  # Ll    [15] VITHKUQI SMALL LETTER HA..VITHKUQI SMALL LETTER RE
+105B3..105B9   ; N  # Ll     [7] VITHKUQI SMALL LETTER SE..VITHKUQI SMALL LETTER XE
+105BB..105BC   ; N  # Ll     [2] VITHKUQI SMALL LETTER Y..VITHKUQI SMALL LETTER ZE
+10600..10736   ; N  # Lo   [311] LINEAR A SIGN AB001..LINEAR A SIGN A664
+10740..10755   ; N  # Lo    [22] LINEAR A SIGN A701 A..LINEAR A SIGN A732 JE
+10760..10767   ; N  # Lo     [8] LINEAR A SIGN A800..LINEAR A SIGN A807
+10780..10785   ; N  # Lm     [6] MODIFIER LETTER SMALL CAPITAL AA..MODIFIER LETTER SMALL B WITH HOOK
+10787..107B0   ; N  # Lm    [42] MODIFIER LETTER SMALL DZ DIGRAPH..MODIFIER LETTER SMALL V WITH RIGHT HOOK
+107B2..107BA   ; N  # Lm     [9] MODIFIER LETTER SMALL CAPITAL Y..MODIFIER LETTER SMALL S WITH CURL
+10800..10805   ; N  # Lo     [6] CYPRIOT SYLLABLE A..CYPRIOT SYLLABLE JA
+10808          ; N  # Lo         CYPRIOT SYLLABLE JO
+1080A..10835   ; N  # Lo    [44] CYPRIOT SYLLABLE KA..CYPRIOT SYLLABLE WO
+10837..10838   ; N  # Lo     [2] CYPRIOT SYLLABLE XA..CYPRIOT SYLLABLE XE
+1083C          ; N  # Lo         CYPRIOT SYLLABLE ZA
+1083F          ; N  # Lo         CYPRIOT SYLLABLE ZO
+10840..10855   ; N  # Lo    [22] IMPERIAL ARAMAIC LETTER ALEPH..IMPERIAL ARAMAIC LETTER TAW
+10857          ; N  # Po         IMPERIAL ARAMAIC SECTION SIGN
+10858..1085F   ; N  # No     [8] IMPERIAL ARAMAIC NUMBER ONE..IMPERIAL ARAMAIC NUMBER TEN THOUSAND
+10860..10876   ; N  # Lo    [23] PALMYRENE LETTER ALEPH..PALMYRENE LETTER TAW
+10877..10878   ; N  # So     [2] PALMYRENE LEFT-POINTING FLEURON..PALMYRENE RIGHT-POINTING FLEURON
+10879..1087F   ; N  # No     [7] PALMYRENE NUMBER ONE..PALMYRENE NUMBER TWENTY
+10880..1089E   ; N  # Lo    [31] NABATAEAN LETTER FINAL ALEPH..NABATAEAN LETTER TAW
+108A7..108AF   ; N  # No     [9] NABATAEAN NUMBER ONE..NABATAEAN NUMBER ONE HUNDRED
+108E0..108F2   ; N  # Lo    [19] HATRAN LETTER ALEPH..HATRAN LETTER QOPH
+108F4..108F5   ; N  # Lo     [2] HATRAN LETTER SHIN..HATRAN LETTER TAW
+108FB..108FF   ; N  # No     [5] HATRAN NUMBER ONE..HATRAN NUMBER ONE HUNDRED
+10900..10915   ; N  # Lo    [22] PHOENICIAN LETTER ALF..PHOENICIAN LETTER TAU
+10916..1091B   ; N  # No     [6] PHOENICIAN NUMBER ONE..PHOENICIAN NUMBER THREE
+1091F          ; N  # Po         PHOENICIAN WORD SEPARATOR
+10920..10939   ; N  # Lo    [26] LYDIAN LETTER A..LYDIAN LETTER C
+1093F          ; N  # Po         LYDIAN TRIANGULAR MARK
+10980..1099F   ; N  # Lo    [32] MEROITIC HIEROGLYPHIC LETTER A..MEROITIC HIEROGLYPHIC SYMBOL VIDJ-2
+109A0..109B7   ; N  # Lo    [24] MEROITIC CURSIVE LETTER A..MEROITIC CURSIVE LETTER DA
+109BC..109BD   ; N  # No     [2] MEROITIC CURSIVE FRACTION ELEVEN TWELFTHS..MEROITIC CURSIVE FRACTION ONE HALF
+109BE..109BF   ; N  # Lo     [2] MEROITIC CURSIVE LOGOGRAM RMT..MEROITIC CURSIVE LOGOGRAM IMN
+109C0..109CF   ; N  # No    [16] MEROITIC CURSIVE NUMBER ONE..MEROITIC CURSIVE NUMBER SEVENTY
+109D2..109FF   ; N  # No    [46] MEROITIC CURSIVE NUMBER ONE HUNDRED..MEROITIC CURSIVE FRACTION TEN TWELFTHS
+10A00          ; N  # Lo         KHAROSHTHI LETTER A
+10A01..10A03   ; N  # Mn     [3] KHAROSHTHI VOWEL SIGN I..KHAROSHTHI VOWEL SIGN VOCALIC R
+10A05..10A06   ; N  # Mn     [2] KHAROSHTHI VOWEL SIGN E..KHAROSHTHI VOWEL SIGN O
+10A0C..10A0F   ; N  # Mn     [4] KHAROSHTHI VOWEL LENGTH MARK..KHAROSHTHI SIGN VISARGA
+10A10..10A13   ; N  # Lo     [4] KHAROSHTHI LETTER KA..KHAROSHTHI LETTER GHA
+10A15..10A17   ; N  # Lo     [3] KHAROSHTHI LETTER CA..KHAROSHTHI LETTER JA
+10A19..10A35   ; N  # Lo    [29] KHAROSHTHI LETTER NYA..KHAROSHTHI LETTER VHA
+10A38..10A3A   ; N  # Mn     [3] KHAROSHTHI SIGN BAR ABOVE..KHAROSHTHI SIGN DOT BELOW
+10A3F          ; N  # Mn         KHAROSHTHI VIRAMA
+10A40..10A48   ; N  # No     [9] KHAROSHTHI DIGIT ONE..KHAROSHTHI FRACTION ONE HALF
+10A50..10A58   ; N  # Po     [9] KHAROSHTHI PUNCTUATION DOT..KHAROSHTHI PUNCTUATION LINES
+10A60..10A7C   ; N  # Lo    [29] OLD SOUTH ARABIAN LETTER HE..OLD SOUTH ARABIAN LETTER THETH
+10A7D..10A7E   ; N  # No     [2] OLD SOUTH ARABIAN NUMBER ONE..OLD SOUTH ARABIAN NUMBER FIFTY
+10A7F          ; N  # Po         OLD SOUTH ARABIAN NUMERIC INDICATOR
+10A80..10A9C   ; N  # Lo    [29] OLD NORTH ARABIAN LETTER HEH..OLD NORTH ARABIAN LETTER ZAH
+10A9D..10A9F   ; N  # No     [3] OLD NORTH ARABIAN NUMBER ONE..OLD NORTH ARABIAN NUMBER TWENTY
+10AC0..10AC7   ; N  # Lo     [8] MANICHAEAN LETTER ALEPH..MANICHAEAN LETTER WAW
+10AC8          ; N  # So         MANICHAEAN SIGN UD
+10AC9..10AE4   ; N  # Lo    [28] MANICHAEAN LETTER ZAYIN..MANICHAEAN LETTER TAW
+10AE5..10AE6   ; N  # Mn     [2] MANICHAEAN ABBREVIATION MARK ABOVE..MANICHAEAN ABBREVIATION MARK BELOW
+10AEB..10AEF   ; N  # No     [5] MANICHAEAN NUMBER ONE..MANICHAEAN NUMBER ONE HUNDRED
+10AF0..10AF6   ; N  # Po     [7] MANICHAEAN PUNCTUATION STAR..MANICHAEAN PUNCTUATION LINE FILLER
+10B00..10B35   ; N  # Lo    [54] AVESTAN LETTER A..AVESTAN LETTER HE
+10B39..10B3F   ; N  # Po     [7] AVESTAN ABBREVIATION MARK..LARGE ONE RING OVER TWO RINGS PUNCTUATION
+10B40..10B55   ; N  # Lo    [22] INSCRIPTIONAL PARTHIAN LETTER ALEPH..INSCRIPTIONAL PARTHIAN LETTER TAW
+10B58..10B5F   ; N  # No     [8] INSCRIPTIONAL PARTHIAN NUMBER ONE..INSCRIPTIONAL PARTHIAN NUMBER ONE THOUSAND
+10B60..10B72   ; N  # Lo    [19] INSCRIPTIONAL PAHLAVI LETTER ALEPH..INSCRIPTIONAL PAHLAVI LETTER TAW
+10B78..10B7F   ; N  # No     [8] INSCRIPTIONAL PAHLAVI NUMBER ONE..INSCRIPTIONAL PAHLAVI NUMBER ONE THOUSAND
+10B80..10B91   ; N  # Lo    [18] PSALTER PAHLAVI LETTER ALEPH..PSALTER PAHLAVI LETTER TAW
+10B99..10B9C   ; N  # Po     [4] PSALTER PAHLAVI SECTION MARK..PSALTER PAHLAVI FOUR DOTS WITH DOT
+10BA9..10BAF   ; N  # No     [7] PSALTER PAHLAVI NUMBER ONE..PSALTER PAHLAVI NUMBER ONE HUNDRED
+10C00..10C48   ; N  # Lo    [73] OLD TURKIC LETTER ORKHON A..OLD TURKIC LETTER ORKHON BASH
+10C80..10CB2   ; N  # Lu    [51] OLD HUNGARIAN CAPITAL LETTER A..OLD HUNGARIAN CAPITAL LETTER US
+10CC0..10CF2   ; N  # Ll    [51] OLD HUNGARIAN SMALL LETTER A..OLD HUNGARIAN SMALL LETTER US
+10CFA..10CFF   ; N  # No     [6] OLD HUNGARIAN NUMBER ONE..OLD HUNGARIAN NUMBER ONE THOUSAND
+10D00..10D23   ; N  # Lo    [36] HANIFI ROHINGYA LETTER A..HANIFI ROHINGYA MARK NA KHONNA
+10D24..10D27   ; N  # Mn     [4] HANIFI ROHINGYA SIGN HARBAHAY..HANIFI ROHINGYA SIGN TASSI
+10D30..10D39   ; N  # Nd    [10] HANIFI ROHINGYA DIGIT ZERO..HANIFI ROHINGYA DIGIT NINE
+10E60..10E7E   ; N  # No    [31] RUMI DIGIT ONE..RUMI FRACTION TWO THIRDS
+10E80..10EA9   ; N  # Lo    [42] YEZIDI LETTER ELIF..YEZIDI LETTER ET
+10EAB..10EAC   ; N  # Mn     [2] YEZIDI COMBINING HAMZA MARK..YEZIDI COMBINING MADDA MARK
+10EAD          ; N  # Pd         YEZIDI HYPHENATION MARK
+10EB0..10EB1   ; N  # Lo     [2] YEZIDI LETTER LAM WITH DOT ABOVE..YEZIDI LETTER YOT WITH CIRCUMFLEX ABOVE
+10EFD..10EFF   ; N  # Mn     [3] ARABIC SMALL LOW WORD SAKTA..ARABIC SMALL LOW WORD MADDA
+10F00..10F1C   ; N  # Lo    [29] OLD SOGDIAN LETTER ALEPH..OLD SOGDIAN LETTER FINAL TAW WITH VERTICAL TAIL
+10F1D..10F26   ; N  # No    [10] OLD SOGDIAN NUMBER ONE..OLD SOGDIAN FRACTION ONE HALF
+10F27          ; N  # Lo         OLD SOGDIAN LIGATURE AYIN-DALETH
+10F30..10F45   ; N  # Lo    [22] SOGDIAN LETTER ALEPH..SOGDIAN INDEPENDENT SHIN
+10F46..10F50   ; N  # Mn    [11] SOGDIAN COMBINING DOT BELOW..SOGDIAN COMBINING STROKE BELOW
+10F51..10F54   ; N  # No     [4] SOGDIAN NUMBER ONE..SOGDIAN NUMBER ONE HUNDRED
+10F55..10F59   ; N  # Po     [5] SOGDIAN PUNCTUATION TWO VERTICAL BARS..SOGDIAN PUNCTUATION HALF CIRCLE WITH DOT
+10F70..10F81   ; N  # Lo    [18] OLD UYGHUR LETTER ALEPH..OLD UYGHUR LETTER LESH
+10F82..10F85   ; N  # Mn     [4] OLD UYGHUR COMBINING DOT ABOVE..OLD UYGHUR COMBINING TWO DOTS BELOW
+10F86..10F89   ; N  # Po     [4] OLD UYGHUR PUNCTUATION BAR..OLD UYGHUR PUNCTUATION FOUR DOTS
+10FB0..10FC4   ; N  # Lo    [21] CHORASMIAN LETTER ALEPH..CHORASMIAN LETTER TAW
+10FC5..10FCB   ; N  # No     [7] CHORASMIAN NUMBER ONE..CHORASMIAN NUMBER ONE HUNDRED
+10FE0..10FF6   ; N  # Lo    [23] ELYMAIC LETTER ALEPH..ELYMAIC LIGATURE ZAYIN-YODH
+11000          ; N  # Mc         BRAHMI SIGN CANDRABINDU
+11001          ; N  # Mn         BRAHMI SIGN ANUSVARA
+11002          ; N  # Mc         BRAHMI SIGN VISARGA
+11003..11037   ; N  # Lo    [53] BRAHMI SIGN JIHVAMULIYA..BRAHMI LETTER OLD TAMIL NNNA
+11038..11046   ; N  # Mn    [15] BRAHMI VOWEL SIGN AA..BRAHMI VIRAMA
+11047..1104D   ; N  # Po     [7] BRAHMI DANDA..BRAHMI PUNCTUATION LOTUS
+11052..11065   ; N  # No    [20] BRAHMI NUMBER ONE..BRAHMI NUMBER ONE THOUSAND
+11066..1106F   ; N  # Nd    [10] BRAHMI DIGIT ZERO..BRAHMI DIGIT NINE
+11070          ; N  # Mn         BRAHMI SIGN OLD TAMIL VIRAMA
+11071..11072   ; N  # Lo     [2] BRAHMI LETTER OLD TAMIL SHORT E..BRAHMI LETTER OLD TAMIL SHORT O
+11073..11074   ; N  # Mn     [2] BRAHMI VOWEL SIGN OLD TAMIL SHORT E..BRAHMI VOWEL SIGN OLD TAMIL SHORT O
+11075          ; N  # Lo         BRAHMI LETTER OLD TAMIL LLA
+1107F          ; N  # Mn         BRAHMI NUMBER JOINER
+11080..11081   ; N  # Mn     [2] KAITHI SIGN CANDRABINDU..KAITHI SIGN ANUSVARA
+11082          ; N  # Mc         KAITHI SIGN VISARGA
+11083..110AF   ; N  # Lo    [45] KAITHI LETTER A..KAITHI LETTER HA
+110B0..110B2   ; N  # Mc     [3] KAITHI VOWEL SIGN AA..KAITHI VOWEL SIGN II
+110B3..110B6   ; N  # Mn     [4] KAITHI VOWEL SIGN U..KAITHI VOWEL SIGN AI
+110B7..110B8   ; N  # Mc     [2] KAITHI VOWEL SIGN O..KAITHI VOWEL SIGN AU
+110B9..110BA   ; N  # Mn     [2] KAITHI SIGN VIRAMA..KAITHI SIGN NUKTA
+110BB..110BC   ; N  # Po     [2] KAITHI ABBREVIATION SIGN..KAITHI ENUMERATION SIGN
+110BD          ; N  # Cf         KAITHI NUMBER SIGN
+110BE..110C1   ; N  # Po     [4] KAITHI SECTION MARK..KAITHI DOUBLE DANDA
+110C2          ; N  # Mn         KAITHI VOWEL SIGN VOCALIC R
+110CD          ; N  # Cf         KAITHI NUMBER SIGN ABOVE
+110D0..110E8   ; N  # Lo    [25] SORA SOMPENG LETTER SAH..SORA SOMPENG LETTER MAE
+110F0..110F9   ; N  # Nd    [10] SORA SOMPENG DIGIT ZERO..SORA SOMPENG DIGIT NINE
+11100..11102   ; N  # Mn     [3] CHAKMA SIGN CANDRABINDU..CHAKMA SIGN VISARGA
+11103..11126   ; N  # Lo    [36] CHAKMA LETTER AA..CHAKMA LETTER HAA
+11127..1112B   ; N  # Mn     [5] CHAKMA VOWEL SIGN A..CHAKMA VOWEL SIGN UU
+1112C          ; N  # Mc         CHAKMA VOWEL SIGN E
+1112D..11134   ; N  # Mn     [8] CHAKMA VOWEL SIGN AI..CHAKMA MAAYYAA
+11136..1113F   ; N  # Nd    [10] CHAKMA DIGIT ZERO..CHAKMA DIGIT NINE
+11140..11143   ; N  # Po     [4] CHAKMA SECTION MARK..CHAKMA QUESTION MARK
+11144          ; N  # Lo         CHAKMA LETTER LHAA
+11145..11146   ; N  # Mc     [2] CHAKMA VOWEL SIGN AA..CHAKMA VOWEL SIGN EI
+11147          ; N  # Lo         CHAKMA LETTER VAA
+11150..11172   ; N  # Lo    [35] MAHAJANI LETTER A..MAHAJANI LETTER RRA
+11173          ; N  # Mn         MAHAJANI SIGN NUKTA
+11174..11175   ; N  # Po     [2] MAHAJANI ABBREVIATION SIGN..MAHAJANI SECTION MARK
+11176          ; N  # Lo         MAHAJANI LIGATURE SHRI
+11180..11181   ; N  # Mn     [2] SHARADA SIGN CANDRABINDU..SHARADA SIGN ANUSVARA
+11182          ; N  # Mc         SHARADA SIGN VISARGA
+11183..111B2   ; N  # Lo    [48] SHARADA LETTER A..SHARADA LETTER HA
+111B3..111B5   ; N  # Mc     [3] SHARADA VOWEL SIGN AA..SHARADA VOWEL SIGN II
+111B6..111BE   ; N  # Mn     [9] SHARADA VOWEL SIGN U..SHARADA VOWEL SIGN O
+111BF..111C0   ; N  # Mc     [2] SHARADA VOWEL SIGN AU..SHARADA SIGN VIRAMA
+111C1..111C4   ; N  # Lo     [4] SHARADA SIGN AVAGRAHA..SHARADA OM
+111C5..111C8   ; N  # Po     [4] SHARADA DANDA..SHARADA SEPARATOR
+111C9..111CC   ; N  # Mn     [4] SHARADA SANDHI MARK..SHARADA EXTRA SHORT VOWEL MARK
+111CD          ; N  # Po         SHARADA SUTRA MARK
+111CE          ; N  # Mc         SHARADA VOWEL SIGN PRISHTHAMATRA E
+111CF          ; N  # Mn         SHARADA SIGN INVERTED CANDRABINDU
+111D0..111D9   ; N  # Nd    [10] SHARADA DIGIT ZERO..SHARADA DIGIT NINE
+111DA          ; N  # Lo         SHARADA EKAM
+111DB          ; N  # Po         SHARADA SIGN SIDDHAM
+111DC          ; N  # Lo         SHARADA HEADSTROKE
+111DD..111DF   ; N  # Po     [3] SHARADA CONTINUATION SIGN..SHARADA SECTION MARK-2
+111E1..111F4   ; N  # No    [20] SINHALA ARCHAIC DIGIT ONE..SINHALA ARCHAIC NUMBER ONE THOUSAND
+11200..11211   ; N  # Lo    [18] KHOJKI LETTER A..KHOJKI LETTER JJA
+11213..1122B   ; N  # Lo    [25] KHOJKI LETTER NYA..KHOJKI LETTER LLA
+1122C..1122E   ; N  # Mc     [3] KHOJKI VOWEL SIGN AA..KHOJKI VOWEL SIGN II
+1122F..11231   ; N  # Mn     [3] KHOJKI VOWEL SIGN U..KHOJKI VOWEL SIGN AI
+11232..11233   ; N  # Mc     [2] KHOJKI VOWEL SIGN O..KHOJKI VOWEL SIGN AU
+11234          ; N  # Mn         KHOJKI SIGN ANUSVARA
+11235          ; N  # Mc         KHOJKI SIGN VIRAMA
+11236..11237   ; N  # Mn     [2] KHOJKI SIGN NUKTA..KHOJKI SIGN SHADDA
+11238..1123D   ; N  # Po     [6] KHOJKI DANDA..KHOJKI ABBREVIATION SIGN
+1123E          ; N  # Mn         KHOJKI SIGN SUKUN
+1123F..11240   ; N  # Lo     [2] KHOJKI LETTER QA..KHOJKI LETTER SHORT I
+11241          ; N  # Mn         KHOJKI VOWEL SIGN VOCALIC R
+11280..11286   ; N  # Lo     [7] MULTANI LETTER A..MULTANI LETTER GA
+11288          ; N  # Lo         MULTANI LETTER GHA
+1128A..1128D   ; N  # Lo     [4] MULTANI LETTER CA..MULTANI LETTER JJA
+1128F..1129D   ; N  # Lo    [15] MULTANI LETTER NYA..MULTANI LETTER BA
+1129F..112A8   ; N  # Lo    [10] MULTANI LETTER BHA..MULTANI LETTER RHA
+112A9          ; N  # Po         MULTANI SECTION MARK
+112B0..112DE   ; N  # Lo    [47] KHUDAWADI LETTER A..KHUDAWADI LETTER HA
+112DF          ; N  # Mn         KHUDAWADI SIGN ANUSVARA
+112E0..112E2   ; N  # Mc     [3] KHUDAWADI VOWEL SIGN AA..KHUDAWADI VOWEL SIGN II
+112E3..112EA   ; N  # Mn     [8] KHUDAWADI VOWEL SIGN U..KHUDAWADI SIGN VIRAMA
+112F0..112F9   ; N  # Nd    [10] KHUDAWADI DIGIT ZERO..KHUDAWADI DIGIT NINE
+11300..11301   ; N  # Mn     [2] GRANTHA SIGN COMBINING ANUSVARA ABOVE..GRANTHA SIGN CANDRABINDU
+11302..11303   ; N  # Mc     [2] GRANTHA SIGN ANUSVARA..GRANTHA SIGN VISARGA
+11305..1130C   ; N  # Lo     [8] GRANTHA LETTER A..GRANTHA LETTER VOCALIC L
+1130F..11310   ; N  # Lo     [2] GRANTHA LETTER EE..GRANTHA LETTER AI
+11313..11328   ; N  # Lo    [22] GRANTHA LETTER OO..GRANTHA LETTER NA
+1132A..11330   ; N  # Lo     [7] GRANTHA LETTER PA..GRANTHA LETTER RA
+11332..11333   ; N  # Lo     [2] GRANTHA LETTER LA..GRANTHA LETTER LLA
+11335..11339   ; N  # Lo     [5] GRANTHA LETTER VA..GRANTHA LETTER HA
+1133B..1133C   ; N  # Mn     [2] COMBINING BINDU BELOW..GRANTHA SIGN NUKTA
+1133D          ; N  # Lo         GRANTHA SIGN AVAGRAHA
+1133E..1133F   ; N  # Mc     [2] GRANTHA VOWEL SIGN AA..GRANTHA VOWEL SIGN I
+11340          ; N  # Mn         GRANTHA VOWEL SIGN II
+11341..11344   ; N  # Mc     [4] GRANTHA VOWEL SIGN U..GRANTHA VOWEL SIGN VOCALIC RR
+11347..11348   ; N  # Mc     [2] GRANTHA VOWEL SIGN EE..GRANTHA VOWEL SIGN AI
+1134B..1134D   ; N  # Mc     [3] GRANTHA VOWEL SIGN OO..GRANTHA SIGN VIRAMA
+11350          ; N  # Lo         GRANTHA OM
+11357          ; N  # Mc         GRANTHA AU LENGTH MARK
+1135D..11361   ; N  # Lo     [5] GRANTHA SIGN PLUTA..GRANTHA LETTER VOCALIC LL
+11362..11363   ; N  # Mc     [2] GRANTHA VOWEL SIGN VOCALIC L..GRANTHA VOWEL SIGN VOCALIC LL
+11366..1136C   ; N  # Mn     [7] COMBINING GRANTHA DIGIT ZERO..COMBINING GRANTHA DIGIT SIX
+11370..11374   ; N  # Mn     [5] COMBINING GRANTHA LETTER A..COMBINING GRANTHA LETTER PA
+11400..11434   ; N  # Lo    [53] NEWA LETTER A..NEWA LETTER HA
+11435..11437   ; N  # Mc     [3] NEWA VOWEL SIGN AA..NEWA VOWEL SIGN II
+11438..1143F   ; N  # Mn     [8] NEWA VOWEL SIGN U..NEWA VOWEL SIGN AI
+11440..11441   ; N  # Mc     [2] NEWA VOWEL SIGN O..NEWA VOWEL SIGN AU
+11442..11444   ; N  # Mn     [3] NEWA SIGN VIRAMA..NEWA SIGN ANUSVARA
+11445          ; N  # Mc         NEWA SIGN VISARGA
+11446          ; N  # Mn         NEWA SIGN NUKTA
+11447..1144A   ; N  # Lo     [4] NEWA SIGN AVAGRAHA..NEWA SIDDHI
+1144B..1144F   ; N  # Po     [5] NEWA DANDA..NEWA ABBREVIATION SIGN
+11450..11459   ; N  # Nd    [10] NEWA DIGIT ZERO..NEWA DIGIT NINE
+1145A..1145B   ; N  # Po     [2] NEWA DOUBLE COMMA..NEWA PLACEHOLDER MARK
+1145D          ; N  # Po         NEWA INSERTION SIGN
+1145E          ; N  # Mn         NEWA SANDHI MARK
+1145F..11461   ; N  # Lo     [3] NEWA LETTER VEDIC ANUSVARA..NEWA SIGN UPADHMANIYA
+11480..114AF   ; N  # Lo    [48] TIRHUTA ANJI..TIRHUTA LETTER HA
+114B0..114B2   ; N  # Mc     [3] TIRHUTA VOWEL SIGN AA..TIRHUTA VOWEL SIGN II
+114B3..114B8   ; N  # Mn     [6] TIRHUTA VOWEL SIGN U..TIRHUTA VOWEL SIGN VOCALIC LL
+114B9          ; N  # Mc         TIRHUTA VOWEL SIGN E
+114BA          ; N  # Mn         TIRHUTA VOWEL SIGN SHORT E
+114BB..114BE   ; N  # Mc     [4] TIRHUTA VOWEL SIGN AI..TIRHUTA VOWEL SIGN AU
+114BF..114C0   ; N  # Mn     [2] TIRHUTA SIGN CANDRABINDU..TIRHUTA SIGN ANUSVARA
+114C1          ; N  # Mc         TIRHUTA SIGN VISARGA
+114C2..114C3   ; N  # Mn     [2] TIRHUTA SIGN VIRAMA..TIRHUTA SIGN NUKTA
+114C4..114C5   ; N  # Lo     [2] TIRHUTA SIGN AVAGRAHA..TIRHUTA GVANG
+114C6          ; N  # Po         TIRHUTA ABBREVIATION SIGN
+114C7          ; N  # Lo         TIRHUTA OM
+114D0..114D9   ; N  # Nd    [10] TIRHUTA DIGIT ZERO..TIRHUTA DIGIT NINE
+11580..115AE   ; N  # Lo    [47] SIDDHAM LETTER A..SIDDHAM LETTER HA
+115AF..115B1   ; N  # Mc     [3] SIDDHAM VOWEL SIGN AA..SIDDHAM VOWEL SIGN II
+115B2..115B5   ; N  # Mn     [4] SIDDHAM VOWEL SIGN U..SIDDHAM VOWEL SIGN VOCALIC RR
+115B8..115BB   ; N  # Mc     [4] SIDDHAM VOWEL SIGN E..SIDDHAM VOWEL SIGN AU
+115BC..115BD   ; N  # Mn     [2] SIDDHAM SIGN CANDRABINDU..SIDDHAM SIGN ANUSVARA
+115BE          ; N  # Mc         SIDDHAM SIGN VISARGA
+115BF..115C0   ; N  # Mn     [2] SIDDHAM SIGN VIRAMA..SIDDHAM SIGN NUKTA
+115C1..115D7   ; N  # Po    [23] SIDDHAM SIGN SIDDHAM..SIDDHAM SECTION MARK WITH CIRCLES AND FOUR ENCLOSURES
+115D8..115DB   ; N  # Lo     [4] SIDDHAM LETTER THREE-CIRCLE ALTERNATE I..SIDDHAM LETTER ALTERNATE U
+115DC..115DD   ; N  # Mn     [2] SIDDHAM VOWEL SIGN ALTERNATE U..SIDDHAM VOWEL SIGN ALTERNATE UU
+11600..1162F   ; N  # Lo    [48] MODI LETTER A..MODI LETTER LLA
+11630..11632   ; N  # Mc     [3] MODI VOWEL SIGN AA..MODI VOWEL SIGN II
+11633..1163A   ; N  # Mn     [8] MODI VOWEL SIGN U..MODI VOWEL SIGN AI
+1163B..1163C   ; N  # Mc     [2] MODI VOWEL SIGN O..MODI VOWEL SIGN AU
+1163D          ; N  # Mn         MODI SIGN ANUSVARA
+1163E          ; N  # Mc         MODI SIGN VISARGA
+1163F..11640   ; N  # Mn     [2] MODI SIGN VIRAMA..MODI SIGN ARDHACANDRA
+11641..11643   ; N  # Po     [3] MODI DANDA..MODI ABBREVIATION SIGN
+11644          ; N  # Lo         MODI SIGN HUVA
+11650..11659   ; N  # Nd    [10] MODI DIGIT ZERO..MODI DIGIT NINE
+11660..1166C   ; N  # Po    [13] MONGOLIAN BIRGA WITH ORNAMENT..MONGOLIAN TURNED SWIRL BIRGA WITH DOUBLE ORNAMENT
+11680..116AA   ; N  # Lo    [43] TAKRI LETTER A..TAKRI LETTER RRA
+116AB          ; N  # Mn         TAKRI SIGN ANUSVARA
+116AC          ; N  # Mc         TAKRI SIGN VISARGA
+116AD          ; N  # Mn         TAKRI VOWEL SIGN AA
+116AE..116AF   ; N  # Mc     [2] TAKRI VOWEL SIGN I..TAKRI VOWEL SIGN II
+116B0..116B5   ; N  # Mn     [6] TAKRI VOWEL SIGN U..TAKRI VOWEL SIGN AU
+116B6          ; N  # Mc         TAKRI SIGN VIRAMA
+116B7          ; N  # Mn         TAKRI SIGN NUKTA
+116B8          ; N  # Lo         TAKRI LETTER ARCHAIC KHA
+116B9          ; N  # Po         TAKRI ABBREVIATION SIGN
+116C0..116C9   ; N  # Nd    [10] TAKRI DIGIT ZERO..TAKRI DIGIT NINE
+11700..1171A   ; N  # Lo    [27] AHOM LETTER KA..AHOM LETTER ALTERNATE BA
+1171D..1171F   ; N  # Mn     [3] AHOM CONSONANT SIGN MEDIAL LA..AHOM CONSONANT SIGN MEDIAL LIGATING RA
+11720..11721   ; N  # Mc     [2] AHOM VOWEL SIGN A..AHOM VOWEL SIGN AA
+11722..11725   ; N  # Mn     [4] AHOM VOWEL SIGN I..AHOM VOWEL SIGN UU
+11726          ; N  # Mc         AHOM VOWEL SIGN E
+11727..1172B   ; N  # Mn     [5] AHOM VOWEL SIGN AW..AHOM SIGN KILLER
+11730..11739   ; N  # Nd    [10] AHOM DIGIT ZERO..AHOM DIGIT NINE
+1173A..1173B   ; N  # No     [2] AHOM NUMBER TEN..AHOM NUMBER TWENTY
+1173C..1173E   ; N  # Po     [3] AHOM SIGN SMALL SECTION..AHOM SIGN RULAI
+1173F          ; N  # So         AHOM SYMBOL VI
+11740..11746   ; N  # Lo     [7] AHOM LETTER CA..AHOM LETTER LLA
+11800..1182B   ; N  # Lo    [44] DOGRA LETTER A..DOGRA LETTER RRA
+1182C..1182E   ; N  # Mc     [3] DOGRA VOWEL SIGN AA..DOGRA VOWEL SIGN II
+1182F..11837   ; N  # Mn     [9] DOGRA VOWEL SIGN U..DOGRA SIGN ANUSVARA
+11838          ; N  # Mc         DOGRA SIGN VISARGA
+11839..1183A   ; N  # Mn     [2] DOGRA SIGN VIRAMA..DOGRA SIGN NUKTA
+1183B          ; N  # Po         DOGRA ABBREVIATION SIGN
+118A0..118DF   ; N  # L&    [64] WARANG CITI CAPITAL LETTER NGAA..WARANG CITI SMALL LETTER VIYO
+118E0..118E9   ; N  # Nd    [10] WARANG CITI DIGIT ZERO..WARANG CITI DIGIT NINE
+118EA..118F2   ; N  # No     [9] WARANG CITI NUMBER TEN..WARANG CITI NUMBER NINETY
+118FF          ; N  # Lo         WARANG CITI OM
+11900..11906   ; N  # Lo     [7] DIVES AKURU LETTER A..DIVES AKURU LETTER E
+11909          ; N  # Lo         DIVES AKURU LETTER O
+1190C..11913   ; N  # Lo     [8] DIVES AKURU LETTER KA..DIVES AKURU LETTER JA
+11915..11916   ; N  # Lo     [2] DIVES AKURU LETTER NYA..DIVES AKURU LETTER TTA
+11918..1192F   ; N  # Lo    [24] DIVES AKURU LETTER DDA..DIVES AKURU LETTER ZA
+11930..11935   ; N  # Mc     [6] DIVES AKURU VOWEL SIGN AA..DIVES AKURU VOWEL SIGN E
+11937..11938   ; N  # Mc     [2] DIVES AKURU VOWEL SIGN AI..DIVES AKURU VOWEL SIGN O
+1193B..1193C   ; N  # Mn     [2] DIVES AKURU SIGN ANUSVARA..DIVES AKURU SIGN CANDRABINDU
+1193D          ; N  # Mc         DIVES AKURU SIGN HALANTA
+1193E          ; N  # Mn         DIVES AKURU VIRAMA
+1193F          ; N  # Lo         DIVES AKURU PREFIXED NASAL SIGN
+11940          ; N  # Mc         DIVES AKURU MEDIAL YA
+11941          ; N  # Lo         DIVES AKURU INITIAL RA
+11942          ; N  # Mc         DIVES AKURU MEDIAL RA
+11943          ; N  # Mn         DIVES AKURU SIGN NUKTA
+11944..11946   ; N  # Po     [3] DIVES AKURU DOUBLE DANDA..DIVES AKURU END OF TEXT MARK
+11950..11959   ; N  # Nd    [10] DIVES AKURU DIGIT ZERO..DIVES AKURU DIGIT NINE
+119A0..119A7   ; N  # Lo     [8] NANDINAGARI LETTER A..NANDINAGARI LETTER VOCALIC RR
+119AA..119D0   ; N  # Lo    [39] NANDINAGARI LETTER E..NANDINAGARI LETTER RRA
+119D1..119D3   ; N  # Mc     [3] NANDINAGARI VOWEL SIGN AA..NANDINAGARI VOWEL SIGN II
+119D4..119D7   ; N  # Mn     [4] NANDINAGARI VOWEL SIGN U..NANDINAGARI VOWEL SIGN VOCALIC RR
+119DA..119DB   ; N  # Mn     [2] NANDINAGARI VOWEL SIGN E..NANDINAGARI VOWEL SIGN AI
+119DC..119DF   ; N  # Mc     [4] NANDINAGARI VOWEL SIGN O..NANDINAGARI SIGN VISARGA
+119E0          ; N  # Mn         NANDINAGARI SIGN VIRAMA
+119E1          ; N  # Lo         NANDINAGARI SIGN AVAGRAHA
+119E2          ; N  # Po         NANDINAGARI SIGN SIDDHAM
+119E3          ; N  # Lo         NANDINAGARI HEADSTROKE
+119E4          ; N  # Mc         NANDINAGARI VOWEL SIGN PRISHTHAMATRA E
+11A00          ; N  # Lo         ZANABAZAR SQUARE LETTER A
+11A01..11A0A   ; N  # Mn    [10] ZANABAZAR SQUARE VOWEL SIGN I..ZANABAZAR SQUARE VOWEL LENGTH MARK
+11A0B..11A32   ; N  # Lo    [40] ZANABAZAR SQUARE LETTER KA..ZANABAZAR SQUARE LETTER KSSA
+11A33..11A38   ; N  # Mn     [6] ZANABAZAR SQUARE FINAL CONSONANT MARK..ZANABAZAR SQUARE SIGN ANUSVARA
+11A39          ; N  # Mc         ZANABAZAR SQUARE SIGN VISARGA
+11A3A          ; N  # Lo         ZANABAZAR SQUARE CLUSTER-INITIAL LETTER RA
+11A3B..11A3E   ; N  # Mn     [4] ZANABAZAR SQUARE CLUSTER-FINAL LETTER YA..ZANABAZAR SQUARE CLUSTER-FINAL LETTER VA
+11A3F..11A46   ; N  # Po     [8] ZANABAZAR SQUARE INITIAL HEAD MARK..ZANABAZAR SQUARE CLOSING DOUBLE-LINED HEAD MARK
+11A47          ; N  # Mn         ZANABAZAR SQUARE SUBJOINER
+11A50          ; N  # Lo         SOYOMBO LETTER A
+11A51..11A56   ; N  # Mn     [6] SOYOMBO VOWEL SIGN I..SOYOMBO VOWEL SIGN OE
+11A57..11A58   ; N  # Mc     [2] SOYOMBO VOWEL SIGN AI..SOYOMBO VOWEL SIGN AU
+11A59..11A5B   ; N  # Mn     [3] SOYOMBO VOWEL SIGN VOCALIC R..SOYOMBO VOWEL LENGTH MARK
+11A5C..11A89   ; N  # Lo    [46] SOYOMBO LETTER KA..SOYOMBO CLUSTER-INITIAL LETTER SA
+11A8A..11A96   ; N  # Mn    [13] SOYOMBO FINAL CONSONANT SIGN G..SOYOMBO SIGN ANUSVARA
+11A97          ; N  # Mc         SOYOMBO SIGN VISARGA
+11A98..11A99   ; N  # Mn     [2] SOYOMBO GEMINATION MARK..SOYOMBO SUBJOINER
+11A9A..11A9C   ; N  # Po     [3] SOYOMBO MARK TSHEG..SOYOMBO MARK DOUBLE SHAD
+11A9D          ; N  # Lo         SOYOMBO MARK PLUTA
+11A9E..11AA2   ; N  # Po     [5] SOYOMBO HEAD MARK WITH MOON AND SUN AND TRIPLE FLAME..SOYOMBO TERMINAL MARK-2
+11AB0..11ABF   ; N  # Lo    [16] CANADIAN SYLLABICS NATTILIK HI..CANADIAN SYLLABICS SPA
+11AC0..11AF8   ; N  # Lo    [57] PAU CIN HAU LETTER PA..PAU CIN HAU GLOTTAL STOP FINAL
+11B00..11B09   ; N  # Po    [10] DEVANAGARI HEAD MARK..DEVANAGARI SIGN MINDU
+11C00..11C08   ; N  # Lo     [9] BHAIKSUKI LETTER A..BHAIKSUKI LETTER VOCALIC L
+11C0A..11C2E   ; N  # Lo    [37] BHAIKSUKI LETTER E..BHAIKSUKI LETTER HA
+11C2F          ; N  # Mc         BHAIKSUKI VOWEL SIGN AA
+11C30..11C36   ; N  # Mn     [7] BHAIKSUKI VOWEL SIGN I..BHAIKSUKI VOWEL SIGN VOCALIC L
+11C38..11C3D   ; N  # Mn     [6] BHAIKSUKI VOWEL SIGN E..BHAIKSUKI SIGN ANUSVARA
+11C3E          ; N  # Mc         BHAIKSUKI SIGN VISARGA
+11C3F          ; N  # Mn         BHAIKSUKI SIGN VIRAMA
+11C40          ; N  # Lo         BHAIKSUKI SIGN AVAGRAHA
+11C41..11C45   ; N  # Po     [5] BHAIKSUKI DANDA..BHAIKSUKI GAP FILLER-2
+11C50..11C59   ; N  # Nd    [10] BHAIKSUKI DIGIT ZERO..BHAIKSUKI DIGIT NINE
+11C5A..11C6C   ; N  # No    [19] BHAIKSUKI NUMBER ONE..BHAIKSUKI HUNDREDS UNIT MARK
+11C70..11C71   ; N  # Po     [2] MARCHEN HEAD MARK..MARCHEN MARK SHAD
+11C72..11C8F   ; N  # Lo    [30] MARCHEN LETTER KA..MARCHEN LETTER A
+11C92..11CA7   ; N  # Mn    [22] MARCHEN SUBJOINED LETTER KA..MARCHEN SUBJOINED LETTER ZA
+11CA9          ; N  # Mc         MARCHEN SUBJOINED LETTER YA
+11CAA..11CB0   ; N  # Mn     [7] MARCHEN SUBJOINED LETTER RA..MARCHEN VOWEL SIGN AA
+11CB1          ; N  # Mc         MARCHEN VOWEL SIGN I
+11CB2..11CB3   ; N  # Mn     [2] MARCHEN VOWEL SIGN U..MARCHEN VOWEL SIGN E
+11CB4          ; N  # Mc         MARCHEN VOWEL SIGN O
+11CB5..11CB6   ; N  # Mn     [2] MARCHEN SIGN ANUSVARA..MARCHEN SIGN CANDRABINDU
+11D00..11D06   ; N  # Lo     [7] MASARAM GONDI LETTER A..MASARAM GONDI LETTER E
+11D08..11D09   ; N  # Lo     [2] MASARAM GONDI LETTER AI..MASARAM GONDI LETTER O
+11D0B..11D30   ; N  # Lo    [38] MASARAM GONDI LETTER AU..MASARAM GONDI LETTER TRA
+11D31..11D36   ; N  # Mn     [6] MASARAM GONDI VOWEL SIGN AA..MASARAM GONDI VOWEL SIGN VOCALIC R
+11D3A          ; N  # Mn         MASARAM GONDI VOWEL SIGN E
+11D3C..11D3D   ; N  # Mn     [2] MASARAM GONDI VOWEL SIGN AI..MASARAM GONDI VOWEL SIGN O
+11D3F..11D45   ; N  # Mn     [7] MASARAM GONDI VOWEL SIGN AU..MASARAM GONDI VIRAMA
+11D46          ; N  # Lo         MASARAM GONDI REPHA
+11D47          ; N  # Mn         MASARAM GONDI RA-KARA
+11D50..11D59   ; N  # Nd    [10] MASARAM GONDI DIGIT ZERO..MASARAM GONDI DIGIT NINE
+11D60..11D65   ; N  # Lo     [6] GUNJALA GONDI LETTER A..GUNJALA GONDI LETTER UU
+11D67..11D68   ; N  # Lo     [2] GUNJALA GONDI LETTER EE..GUNJALA GONDI LETTER AI
+11D6A..11D89   ; N  # Lo    [32] GUNJALA GONDI LETTER OO..GUNJALA GONDI LETTER SA
+11D8A..11D8E   ; N  # Mc     [5] GUNJALA GONDI VOWEL SIGN AA..GUNJALA GONDI VOWEL SIGN UU
+11D90..11D91   ; N  # Mn     [2] GUNJALA GONDI VOWEL SIGN EE..GUNJALA GONDI VOWEL SIGN AI
+11D93..11D94   ; N  # Mc     [2] GUNJALA GONDI VOWEL SIGN OO..GUNJALA GONDI VOWEL SIGN AU
+11D95          ; N  # Mn         GUNJALA GONDI SIGN ANUSVARA
+11D96          ; N  # Mc         GUNJALA GONDI SIGN VISARGA
+11D97          ; N  # Mn         GUNJALA GONDI VIRAMA
+11D98          ; N  # Lo         GUNJALA GONDI OM
+11DA0..11DA9   ; N  # Nd    [10] GUNJALA GONDI DIGIT ZERO..GUNJALA GONDI DIGIT NINE
+11EE0..11EF2   ; N  # Lo    [19] MAKASAR LETTER KA..MAKASAR ANGKA
+11EF3..11EF4   ; N  # Mn     [2] MAKASAR VOWEL SIGN I..MAKASAR VOWEL SIGN U
+11EF5..11EF6   ; N  # Mc     [2] MAKASAR VOWEL SIGN E..MAKASAR VOWEL SIGN O
+11EF7..11EF8   ; N  # Po     [2] MAKASAR PASSIMBANG..MAKASAR END OF SECTION
+11F00..11F01   ; N  # Mn     [2] KAWI SIGN CANDRABINDU..KAWI SIGN ANUSVARA
+11F02          ; N  # Lo         KAWI SIGN REPHA
+11F03          ; N  # Mc         KAWI SIGN VISARGA
+11F04..11F10   ; N  # Lo    [13] KAWI LETTER A..KAWI LETTER O
+11F12..11F33   ; N  # Lo    [34] KAWI LETTER KA..KAWI LETTER JNYA
+11F34..11F35   ; N  # Mc     [2] KAWI VOWEL SIGN AA..KAWI VOWEL SIGN ALTERNATE AA
+11F36..11F3A   ; N  # Mn     [5] KAWI VOWEL SIGN I..KAWI VOWEL SIGN VOCALIC R
+11F3E..11F3F   ; N  # Mc     [2] KAWI VOWEL SIGN E..KAWI VOWEL SIGN AI
+11F40          ; N  # Mn         KAWI VOWEL SIGN EU
+11F41          ; N  # Mc         KAWI SIGN KILLER
+11F42          ; N  # Mn         KAWI CONJOINER
+11F43..11F4F   ; N  # Po    [13] KAWI DANDA..KAWI PUNCTUATION CLOSING SPIRAL
+11F50..11F59   ; N  # Nd    [10] KAWI DIGIT ZERO..KAWI DIGIT NINE
+11FB0          ; N  # Lo         LISU LETTER YHA
+11FC0..11FD4   ; N  # No    [21] TAMIL FRACTION ONE THREE-HUNDRED-AND-TWENTIETH..TAMIL FRACTION DOWNSCALING FACTOR KIIZH
+11FD5..11FDC   ; N  # So     [8] TAMIL SIGN NEL..TAMIL SIGN MUKKURUNI
+11FDD..11FE0   ; N  # Sc     [4] TAMIL SIGN KAACU..TAMIL SIGN VARAAKAN
+11FE1..11FF1   ; N  # So    [17] TAMIL SIGN PAARAM..TAMIL SIGN VAKAIYARAA
+11FFF          ; N  # Po         TAMIL PUNCTUATION END OF TEXT
+12000..12399   ; N  # Lo   [922] CUNEIFORM SIGN A..CUNEIFORM SIGN U U
+12400..1246E   ; N  # Nl   [111] CUNEIFORM NUMERIC SIGN TWO ASH..CUNEIFORM NUMERIC SIGN NINE U VARIANT FORM
+12470..12474   ; N  # Po     [5] CUNEIFORM PUNCTUATION SIGN OLD ASSYRIAN WORD DIVIDER..CUNEIFORM PUNCTUATION SIGN DIAGONAL QUADCOLON
+12480..12543   ; N  # Lo   [196] CUNEIFORM SIGN AB TIMES NUN TENU..CUNEIFORM SIGN ZU5 TIMES THREE DISH TENU
+12F90..12FF0   ; N  # Lo    [97] CYPRO-MINOAN SIGN CM001..CYPRO-MINOAN SIGN CM114
+12FF1..12FF2   ; N  # Po     [2] CYPRO-MINOAN SIGN CM301..CYPRO-MINOAN SIGN CM302
+13000..1342F   ; N  # Lo  [1072] EGYPTIAN HIEROGLYPH A001..EGYPTIAN HIEROGLYPH V011D
+13430..1343F   ; N  # Cf    [16] EGYPTIAN HIEROGLYPH VERTICAL JOINER..EGYPTIAN HIEROGLYPH END WALLED ENCLOSURE
+13440          ; N  # Mn         EGYPTIAN HIEROGLYPH MIRROR HORIZONTALLY
+13441..13446   ; N  # Lo     [6] EGYPTIAN HIEROGLYPH FULL BLANK..EGYPTIAN HIEROGLYPH WIDE LOST SIGN
+13447..13455   ; N  # Mn    [15] EGYPTIAN HIEROGLYPH MODIFIER DAMAGED AT TOP START..EGYPTIAN HIEROGLYPH MODIFIER DAMAGED
+14400..14646   ; N  # Lo   [583] ANATOLIAN HIEROGLYPH A001..ANATOLIAN HIEROGLYPH A530
+16800..16A38   ; N  # Lo   [569] BAMUM LETTER PHASE-A NGKUE MFON..BAMUM LETTER PHASE-F VUEQ
+16A40..16A5E   ; N  # Lo    [31] MRO LETTER TA..MRO LETTER TEK
+16A60..16A69   ; N  # Nd    [10] MRO DIGIT ZERO..MRO DIGIT NINE
+16A6E..16A6F   ; N  # Po     [2] MRO DANDA..MRO DOUBLE DANDA
+16A70..16ABE   ; N  # Lo    [79] TANGSA LETTER OZ..TANGSA LETTER ZA
+16AC0..16AC9   ; N  # Nd    [10] TANGSA DIGIT ZERO..TANGSA DIGIT NINE
+16AD0..16AED   ; N  # Lo    [30] BASSA VAH LETTER ENNI..BASSA VAH LETTER I
+16AF0..16AF4   ; N  # Mn     [5] BASSA VAH COMBINING HIGH TONE..BASSA VAH COMBINING HIGH-LOW TONE
+16AF5          ; N  # Po         BASSA VAH FULL STOP
+16B00..16B2F   ; N  # Lo    [48] PAHAWH HMONG VOWEL KEEB..PAHAWH HMONG CONSONANT CAU
+16B30..16B36   ; N  # Mn     [7] PAHAWH HMONG MARK CIM TUB..PAHAWH HMONG MARK CIM TAUM
+16B37..16B3B   ; N  # Po     [5] PAHAWH HMONG SIGN VOS THOM..PAHAWH HMONG SIGN VOS FEEM
+16B3C..16B3F   ; N  # So     [4] PAHAWH HMONG SIGN XYEEM NTXIV..PAHAWH HMONG SIGN XYEEM FAIB
+16B40..16B43   ; N  # Lm     [4] PAHAWH HMONG SIGN VOS SEEV..PAHAWH HMONG SIGN IB YAM
+16B44          ; N  # Po         PAHAWH HMONG SIGN XAUS
+16B45          ; N  # So         PAHAWH HMONG SIGN CIM TSOV ROG
+16B50..16B59   ; N  # Nd    [10] PAHAWH HMONG DIGIT ZERO..PAHAWH HMONG DIGIT NINE
+16B5B..16B61   ; N  # No     [7] PAHAWH HMONG NUMBER TENS..PAHAWH HMONG NUMBER TRILLIONS
+16B63..16B77   ; N  # Lo    [21] PAHAWH HMONG SIGN VOS LUB..PAHAWH HMONG SIGN CIM NRES TOS
+16B7D..16B8F   ; N  # Lo    [19] PAHAWH HMONG CLAN SIGN TSHEEJ..PAHAWH HMONG CLAN SIGN VWJ
+16E40..16E7F   ; N  # L&    [64] MEDEFAIDRIN CAPITAL LETTER M..MEDEFAIDRIN SMALL LETTER Y
+16E80..16E96   ; N  # No    [23] MEDEFAIDRIN DIGIT ZERO..MEDEFAIDRIN DIGIT THREE ALTERNATE FORM
+16E97..16E9A   ; N  # Po     [4] MEDEFAIDRIN COMMA..MEDEFAIDRIN EXCLAMATION OH
+16F00..16F4A   ; N  # Lo    [75] MIAO LETTER PA..MIAO LETTER RTE
+16F4F          ; N  # Mn         MIAO SIGN CONSONANT MODIFIER BAR
+16F50          ; N  # Lo         MIAO LETTER NASALIZATION
+16F51..16F87   ; N  # Mc    [55] MIAO SIGN ASPIRATION..MIAO VOWEL SIGN UI
+16F8F..16F92   ; N  # Mn     [4] MIAO TONE RIGHT..MIAO TONE BELOW
+16F93..16F9F   ; N  # Lm    [13] MIAO LETTER TONE-2..MIAO LETTER REFORMED TONE-8
+16FE0..16FE1   ; W  # Lm     [2] TANGUT ITERATION MARK..NUSHU ITERATION MARK
+16FE2          ; W  # Po         OLD CHINESE HOOK MARK
+16FE3          ; W  # Lm         OLD CHINESE ITERATION MARK
+16FE4          ; W  # Mn         KHITAN SMALL SCRIPT FILLER
+16FF0..16FF1   ; W  # Mc     [2] VIETNAMESE ALTERNATE READING MARK CA..VIETNAMESE ALTERNATE READING MARK NHAY
+17000..187F7   ; W  # Lo  [6136] TANGUT IDEOGRAPH-17000..TANGUT IDEOGRAPH-187F7
+18800..18AFF   ; W  # Lo   [768] TANGUT COMPONENT-001..TANGUT COMPONENT-768
+18B00..18CD5   ; W  # Lo   [470] KHITAN SMALL SCRIPT CHARACTER-18B00..KHITAN SMALL SCRIPT CHARACTER-18CD5
+18D00..18D08   ; W  # Lo     [9] TANGUT IDEOGRAPH-18D00..TANGUT IDEOGRAPH-18D08
+1AFF0..1AFF3   ; W  # Lm     [4] KATAKANA LETTER MINNAN TONE-2..KATAKANA LETTER MINNAN TONE-5
+1AFF5..1AFFB   ; W  # Lm     [7] KATAKANA LETTER MINNAN TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-5
+1AFFD..1AFFE   ; W  # Lm     [2] KATAKANA LETTER MINNAN NASALIZED TONE-7..KATAKANA LETTER MINNAN NASALIZED TONE-8
+1B000..1B0FF   ; W  # Lo   [256] KATAKANA LETTER ARCHAIC E..HENTAIGANA LETTER RE-2
+1B100..1B122   ; W  # Lo    [35] HENTAIGANA LETTER RE-3..KATAKANA LETTER ARCHAIC WU
+1B132          ; W  # Lo         HIRAGANA LETTER SMALL KO
+1B150..1B152   ; W  # Lo     [3] HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO
+1B155          ; W  # Lo         KATAKANA LETTER SMALL KO
+1B164..1B167   ; W  # Lo     [4] KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N
+1B170..1B2FB   ; W  # Lo   [396] NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB
+1BC00..1BC6A   ; N  # Lo   [107] DUPLOYAN LETTER H..DUPLOYAN LETTER VOCALIC M
+1BC70..1BC7C   ; N  # Lo    [13] DUPLOYAN AFFIX LEFT HORIZONTAL SECANT..DUPLOYAN AFFIX ATTACHED TANGENT HOOK
+1BC80..1BC88   ; N  # Lo     [9] DUPLOYAN AFFIX HIGH ACUTE..DUPLOYAN AFFIX HIGH VERTICAL
+1BC90..1BC99   ; N  # Lo    [10] DUPLOYAN AFFIX LOW ACUTE..DUPLOYAN AFFIX LOW ARROW
+1BC9C          ; N  # So         DUPLOYAN SIGN O WITH CROSS
+1BC9D..1BC9E   ; N  # Mn     [2] DUPLOYAN THICK LETTER SELECTOR..DUPLOYAN DOUBLE MARK
+1BC9F          ; N  # Po         DUPLOYAN PUNCTUATION CHINOOK FULL STOP
+1BCA0..1BCA3   ; N  # Cf     [4] SHORTHAND FORMAT LETTER OVERLAP..SHORTHAND FORMAT UP STEP
+1CF00..1CF2D   ; N  # Mn    [46] ZNAMENNY COMBINING MARK GORAZDO NIZKO S KRYZHEM ON LEFT..ZNAMENNY COMBINING MARK KRYZH ON LEFT
+1CF30..1CF46   ; N  # Mn    [23] ZNAMENNY COMBINING TONAL RANGE MARK MRACHNO..ZNAMENNY PRIZNAK MODIFIER ROG
+1CF50..1CFC3   ; N  # So   [116] ZNAMENNY NEUME KRYUK..ZNAMENNY NEUME PAUK
+1D000..1D0F5   ; N  # So   [246] BYZANTINE MUSICAL SYMBOL PSILI..BYZANTINE MUSICAL SYMBOL GORGON NEO KATO
+1D100..1D126   ; N  # So    [39] MUSICAL SYMBOL SINGLE BARLINE..MUSICAL SYMBOL DRUM CLEF-2
+1D129..1D164   ; N  # So    [60] MUSICAL SYMBOL MULTIPLE MEASURE REST..MUSICAL SYMBOL ONE HUNDRED TWENTY-EIGHTH NOTE
+1D165..1D166   ; N  # Mc     [2] MUSICAL SYMBOL COMBINING STEM..MUSICAL SYMBOL COMBINING SPRECHGESANG STEM
+1D167..1D169   ; N  # Mn     [3] MUSICAL SYMBOL COMBINING TREMOLO-1..MUSICAL SYMBOL COMBINING TREMOLO-3
+1D16A..1D16C   ; N  # So     [3] MUSICAL SYMBOL FINGERED TREMOLO-1..MUSICAL SYMBOL FINGERED TREMOLO-3
+1D16D..1D172   ; N  # Mc     [6] MUSICAL SYMBOL COMBINING AUGMENTATION DOT..MUSICAL SYMBOL COMBINING FLAG-5
+1D173..1D17A   ; N  # Cf     [8] MUSICAL SYMBOL BEGIN BEAM..MUSICAL SYMBOL END PHRASE
+1D17B..1D182   ; N  # Mn     [8] MUSICAL SYMBOL COMBINING ACCENT..MUSICAL SYMBOL COMBINING LOURE
+1D183..1D184   ; N  # So     [2] MUSICAL SYMBOL ARPEGGIATO UP..MUSICAL SYMBOL ARPEGGIATO DOWN
+1D185..1D18B   ; N  # Mn     [7] MUSICAL SYMBOL COMBINING DOIT..MUSICAL SYMBOL COMBINING TRIPLE TONGUE
+1D18C..1D1A9   ; N  # So    [30] MUSICAL SYMBOL RINFORZANDO..MUSICAL SYMBOL DEGREE SLASH
+1D1AA..1D1AD   ; N  # Mn     [4] MUSICAL SYMBOL COMBINING DOWN BOW..MUSICAL SYMBOL COMBINING SNAP PIZZICATO
+1D1AE..1D1EA   ; N  # So    [61] MUSICAL SYMBOL PEDAL MARK..MUSICAL SYMBOL KORON
+1D200..1D241   ; N  # So    [66] GREEK VOCAL NOTATION SYMBOL-1..GREEK INSTRUMENTAL NOTATION SYMBOL-54
+1D242..1D244   ; N  # Mn     [3] COMBINING GREEK MUSICAL TRISEME..COMBINING GREEK MUSICAL PENTASEME
+1D245          ; N  # So         GREEK MUSICAL LEIMMA
+1D2C0..1D2D3   ; N  # No    [20] KAKTOVIK NUMERAL ZERO..KAKTOVIK NUMERAL NINETEEN
+1D2E0..1D2F3   ; N  # No    [20] MAYAN NUMERAL ZERO..MAYAN NUMERAL NINETEEN
+1D300..1D356   ; N  # So    [87] MONOGRAM FOR EARTH..TETRAGRAM FOR FOSTERING
+1D360..1D378   ; N  # No    [25] COUNTING ROD UNIT DIGIT ONE..TALLY MARK FIVE
+1D400..1D454   ; N  # L&    [85] MATHEMATICAL BOLD CAPITAL A..MATHEMATICAL ITALIC SMALL G
+1D456..1D49C   ; N  # L&    [71] MATHEMATICAL ITALIC SMALL I..MATHEMATICAL SCRIPT CAPITAL A
+1D49E..1D49F   ; N  # Lu     [2] MATHEMATICAL SCRIPT CAPITAL C..MATHEMATICAL SCRIPT CAPITAL D
+1D4A2          ; N  # Lu         MATHEMATICAL SCRIPT CAPITAL G
+1D4A5..1D4A6   ; N  # Lu     [2] MATHEMATICAL SCRIPT CAPITAL J..MATHEMATICAL SCRIPT CAPITAL K
+1D4A9..1D4AC   ; N  # Lu     [4] MATHEMATICAL SCRIPT CAPITAL N..MATHEMATICAL SCRIPT CAPITAL Q
+1D4AE..1D4B9   ; N  # L&    [12] MATHEMATICAL SCRIPT CAPITAL S..MATHEMATICAL SCRIPT SMALL D
+1D4BB          ; N  # Ll         MATHEMATICAL SCRIPT SMALL F
+1D4BD..1D4C3   ; N  # Ll     [7] MATHEMATICAL SCRIPT SMALL H..MATHEMATICAL SCRIPT SMALL N
+1D4C5..1D505   ; N  # L&    [65] MATHEMATICAL SCRIPT SMALL P..MATHEMATICAL FRAKTUR CAPITAL B
+1D507..1D50A   ; N  # Lu     [4] MATHEMATICAL FRAKTUR CAPITAL D..MATHEMATICAL FRAKTUR CAPITAL G
+1D50D..1D514   ; N  # Lu     [8] MATHEMATICAL FRAKTUR CAPITAL J..MATHEMATICAL FRAKTUR CAPITAL Q
+1D516..1D51C   ; N  # Lu     [7] MATHEMATICAL FRAKTUR CAPITAL S..MATHEMATICAL FRAKTUR CAPITAL Y
+1D51E..1D539   ; N  # L&    [28] MATHEMATICAL FRAKTUR SMALL A..MATHEMATICAL DOUBLE-STRUCK CAPITAL B
+1D53B..1D53E   ; N  # Lu     [4] MATHEMATICAL DOUBLE-STRUCK CAPITAL D..MATHEMATICAL DOUBLE-STRUCK CAPITAL G
+1D540..1D544   ; N  # Lu     [5] MATHEMATICAL DOUBLE-STRUCK CAPITAL I..MATHEMATICAL DOUBLE-STRUCK CAPITAL M
+1D546          ; N  # Lu         MATHEMATICAL DOUBLE-STRUCK CAPITAL O
+1D54A..1D550   ; N  # Lu     [7] MATHEMATICAL DOUBLE-STRUCK CAPITAL S..MATHEMATICAL DOUBLE-STRUCK CAPITAL Y
+1D552..1D6A5   ; N  # L&   [340] MATHEMATICAL DOUBLE-STRUCK SMALL A..MATHEMATICAL ITALIC SMALL DOTLESS J
+1D6A8..1D6C0   ; N  # Lu    [25] MATHEMATICAL BOLD CAPITAL ALPHA..MATHEMATICAL BOLD CAPITAL OMEGA
+1D6C1          ; N  # Sm         MATHEMATICAL BOLD NABLA
+1D6C2..1D6DA   ; N  # Ll    [25] MATHEMATICAL BOLD SMALL ALPHA..MATHEMATICAL BOLD SMALL OMEGA
+1D6DB          ; N  # Sm         MATHEMATICAL BOLD PARTIAL DIFFERENTIAL
+1D6DC..1D6FA   ; N  # L&    [31] MATHEMATICAL BOLD EPSILON SYMBOL..MATHEMATICAL ITALIC CAPITAL OMEGA
+1D6FB          ; N  # Sm         MATHEMATICAL ITALIC NABLA
+1D6FC..1D714   ; N  # Ll    [25] MATHEMATICAL ITALIC SMALL ALPHA..MATHEMATICAL ITALIC SMALL OMEGA
+1D715          ; N  # Sm         MATHEMATICAL ITALIC PARTIAL DIFFERENTIAL
+1D716..1D734   ; N  # L&    [31] MATHEMATICAL ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD ITALIC CAPITAL OMEGA
+1D735          ; N  # Sm         MATHEMATICAL BOLD ITALIC NABLA
+1D736..1D74E   ; N  # Ll    [25] MATHEMATICAL BOLD ITALIC SMALL ALPHA..MATHEMATICAL BOLD ITALIC SMALL OMEGA
+1D74F          ; N  # Sm         MATHEMATICAL BOLD ITALIC PARTIAL DIFFERENTIAL
+1D750..1D76E   ; N  # L&    [31] MATHEMATICAL BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD CAPITAL OMEGA
+1D76F          ; N  # Sm         MATHEMATICAL SANS-SERIF BOLD NABLA
+1D770..1D788   ; N  # Ll    [25] MATHEMATICAL SANS-SERIF BOLD SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD SMALL OMEGA
+1D789          ; N  # Sm         MATHEMATICAL SANS-SERIF BOLD PARTIAL DIFFERENTIAL
+1D78A..1D7A8   ; N  # L&    [31] MATHEMATICAL SANS-SERIF BOLD EPSILON SYMBOL..MATHEMATICAL SANS-SERIF BOLD ITALIC CAPITAL OMEGA
+1D7A9          ; N  # Sm         MATHEMATICAL SANS-SERIF BOLD ITALIC NABLA
+1D7AA..1D7C2   ; N  # Ll    [25] MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL ALPHA..MATHEMATICAL SANS-SERIF BOLD ITALIC SMALL OMEGA
+1D7C3          ; N  # Sm         MATHEMATICAL SANS-SERIF BOLD ITALIC PARTIAL DIFFERENTIAL
+1D7C4..1D7CB   ; N  # L&     [8] MATHEMATICAL SANS-SERIF BOLD ITALIC EPSILON SYMBOL..MATHEMATICAL BOLD SMALL DIGAMMA
+1D7CE..1D7FF   ; N  # Nd    [50] MATHEMATICAL BOLD DIGIT ZERO..MATHEMATICAL MONOSPACE DIGIT NINE
+1D800..1D9FF   ; N  # So   [512] SIGNWRITING HAND-FIST INDEX..SIGNWRITING HEAD
+1DA00..1DA36   ; N  # Mn    [55] SIGNWRITING HEAD RIM..SIGNWRITING AIR SUCKING IN
+1DA37..1DA3A   ; N  # So     [4] SIGNWRITING AIR BLOW SMALL ROTATIONS..SIGNWRITING BREATH EXHALE
+1DA3B..1DA6C   ; N  # Mn    [50] SIGNWRITING MOUTH CLOSED NEUTRAL..SIGNWRITING EXCITEMENT
+1DA6D..1DA74   ; N  # So     [8] SIGNWRITING SHOULDER HIP SPINE..SIGNWRITING TORSO-FLOORPLANE TWISTING
+1DA75          ; N  # Mn         SIGNWRITING UPPER BODY TILTING FROM HIP JOINTS
+1DA76..1DA83   ; N  # So    [14] SIGNWRITING LIMB COMBINATION..SIGNWRITING LOCATION DEPTH
+1DA84          ; N  # Mn         SIGNWRITING LOCATION HEAD NECK
+1DA85..1DA86   ; N  # So     [2] SIGNWRITING LOCATION TORSO..SIGNWRITING LOCATION LIMBS DIGITS
+1DA87..1DA8B   ; N  # Po     [5] SIGNWRITING COMMA..SIGNWRITING PARENTHESIS
+1DA9B..1DA9F   ; N  # Mn     [5] SIGNWRITING FILL MODIFIER-2..SIGNWRITING FILL MODIFIER-6
+1DAA1..1DAAF   ; N  # Mn    [15] SIGNWRITING ROTATION MODIFIER-2..SIGNWRITING ROTATION MODIFIER-16
+1DF00..1DF09   ; N  # Ll    [10] LATIN SMALL LETTER FENG DIGRAPH WITH TRILL..LATIN SMALL LETTER T WITH HOOK AND RETROFLEX HOOK
+1DF0A          ; N  # Lo         LATIN LETTER RETROFLEX CLICK WITH RETROFLEX HOOK
+1DF0B..1DF1E   ; N  # Ll    [20] LATIN SMALL LETTER ESH WITH DOUBLE BAR..LATIN SMALL LETTER S WITH CURL
+1DF25..1DF2A   ; N  # Ll     [6] LATIN SMALL LETTER D WITH MID-HEIGHT LEFT HOOK..LATIN SMALL LETTER T WITH MID-HEIGHT LEFT HOOK
+1E000..1E006   ; N  # Mn     [7] COMBINING GLAGOLITIC LETTER AZU..COMBINING GLAGOLITIC LETTER ZHIVETE
+1E008..1E018   ; N  # Mn    [17] COMBINING GLAGOLITIC LETTER ZEMLJA..COMBINING GLAGOLITIC LETTER HERU
+1E01B..1E021   ; N  # Mn     [7] COMBINING GLAGOLITIC LETTER SHTA..COMBINING GLAGOLITIC LETTER YATI
+1E023..1E024   ; N  # Mn     [2] COMBINING GLAGOLITIC LETTER YU..COMBINING GLAGOLITIC LETTER SMALL YUS
+1E026..1E02A   ; N  # Mn     [5] COMBINING GLAGOLITIC LETTER YO..COMBINING GLAGOLITIC LETTER FITA
+1E030..1E06D   ; N  # Lm    [62] MODIFIER LETTER CYRILLIC SMALL A..MODIFIER LETTER CYRILLIC SMALL STRAIGHT U WITH STROKE
+1E08F          ; N  # Mn         COMBINING CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
+1E100..1E12C   ; N  # Lo    [45] NYIAKENG PUACHUE HMONG LETTER MA..NYIAKENG PUACHUE HMONG LETTER W
+1E130..1E136   ; N  # Mn     [7] NYIAKENG PUACHUE HMONG TONE-B..NYIAKENG PUACHUE HMONG TONE-D
+1E137..1E13D   ; N  # Lm     [7] NYIAKENG PUACHUE HMONG SIGN FOR PERSON..NYIAKENG PUACHUE HMONG SYLLABLE LENGTHENER
+1E140..1E149   ; N  # Nd    [10] NYIAKENG PUACHUE HMONG DIGIT ZERO..NYIAKENG PUACHUE HMONG DIGIT NINE
+1E14E          ; N  # Lo         NYIAKENG PUACHUE HMONG LOGOGRAM NYAJ
+1E14F          ; N  # So         NYIAKENG PUACHUE HMONG CIRCLED CA
+1E290..1E2AD   ; N  # Lo    [30] TOTO LETTER PA..TOTO LETTER A
+1E2AE          ; N  # Mn         TOTO SIGN RISING TONE
+1E2C0..1E2EB   ; N  # Lo    [44] WANCHO LETTER AA..WANCHO LETTER YIH
+1E2EC..1E2EF   ; N  # Mn     [4] WANCHO TONE TUP..WANCHO TONE KOINI
+1E2F0..1E2F9   ; N  # Nd    [10] WANCHO DIGIT ZERO..WANCHO DIGIT NINE
+1E2FF          ; N  # Sc         WANCHO NGUN SIGN
+1E4D0..1E4EA   ; N  # Lo    [27] NAG MUNDARI LETTER O..NAG MUNDARI LETTER ELL
+1E4EB          ; N  # Lm         NAG MUNDARI SIGN OJOD
+1E4EC..1E4EF   ; N  # Mn     [4] NAG MUNDARI SIGN MUHOR..NAG MUNDARI SIGN SUTUH
+1E4F0..1E4F9   ; N  # Nd    [10] NAG MUNDARI DIGIT ZERO..NAG MUNDARI DIGIT NINE
+1E7E0..1E7E6   ; N  # Lo     [7] ETHIOPIC SYLLABLE HHYA..ETHIOPIC SYLLABLE HHYO
+1E7E8..1E7EB   ; N  # Lo     [4] ETHIOPIC SYLLABLE GURAGE HHWA..ETHIOPIC SYLLABLE HHWE
+1E7ED..1E7EE   ; N  # Lo     [2] ETHIOPIC SYLLABLE GURAGE MWI..ETHIOPIC SYLLABLE GURAGE MWEE
+1E7F0..1E7FE   ; N  # Lo    [15] ETHIOPIC SYLLABLE GURAGE QWI..ETHIOPIC SYLLABLE GURAGE PWEE
+1E800..1E8C4   ; N  # Lo   [197] MENDE KIKAKUI SYLLABLE M001 KI..MENDE KIKAKUI SYLLABLE M060 NYON
+1E8C7..1E8CF   ; N  # No     [9] MENDE KIKAKUI DIGIT ONE..MENDE KIKAKUI DIGIT NINE
+1E8D0..1E8D6   ; N  # Mn     [7] MENDE KIKAKUI COMBINING NUMBER TEENS..MENDE KIKAKUI COMBINING NUMBER MILLIONS
+1E900..1E943   ; N  # L&    [68] ADLAM CAPITAL LETTER ALIF..ADLAM SMALL LETTER SHA
+1E944..1E94A   ; N  # Mn     [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA
+1E94B          ; N  # Lm         ADLAM NASALIZATION MARK
+1E950..1E959   ; N  # Nd    [10] ADLAM DIGIT ZERO..ADLAM DIGIT NINE
+1E95E..1E95F   ; N  # Po     [2] ADLAM INITIAL EXCLAMATION MARK..ADLAM INITIAL QUESTION MARK
+1EC71..1ECAB   ; N  # No    [59] INDIC SIYAQ NUMBER ONE..INDIC SIYAQ NUMBER PREFIXED NINE
+1ECAC          ; N  # So         INDIC SIYAQ PLACEHOLDER
+1ECAD..1ECAF   ; N  # No     [3] INDIC SIYAQ FRACTION ONE QUARTER..INDIC SIYAQ FRACTION THREE QUARTERS
+1ECB0          ; N  # Sc         INDIC SIYAQ RUPEE MARK
+1ECB1..1ECB4   ; N  # No     [4] INDIC SIYAQ NUMBER ALTERNATE ONE..INDIC SIYAQ ALTERNATE LAKH MARK
+1ED01..1ED2D   ; N  # No    [45] OTTOMAN SIYAQ NUMBER ONE..OTTOMAN SIYAQ NUMBER NINETY THOUSAND
+1ED2E          ; N  # So         OTTOMAN SIYAQ MARRATAN
+1ED2F..1ED3D   ; N  # No    [15] OTTOMAN SIYAQ ALTERNATE NUMBER TWO..OTTOMAN SIYAQ FRACTION ONE SIXTH
+1EE00..1EE03   ; N  # Lo     [4] ARABIC MATHEMATICAL ALEF..ARABIC MATHEMATICAL DAL
+1EE05..1EE1F   ; N  # Lo    [27] ARABIC MATHEMATICAL WAW..ARABIC MATHEMATICAL DOTLESS QAF
+1EE21..1EE22   ; N  # Lo     [2] ARABIC MATHEMATICAL INITIAL BEH..ARABIC MATHEMATICAL INITIAL JEEM
+1EE24          ; N  # Lo         ARABIC MATHEMATICAL INITIAL HEH
+1EE27          ; N  # Lo         ARABIC MATHEMATICAL INITIAL HAH
+1EE29..1EE32   ; N  # Lo    [10] ARABIC MATHEMATICAL INITIAL YEH..ARABIC MATHEMATICAL INITIAL QAF
+1EE34..1EE37   ; N  # Lo     [4] ARABIC MATHEMATICAL INITIAL SHEEN..ARABIC MATHEMATICAL INITIAL KHAH
+1EE39          ; N  # Lo         ARABIC MATHEMATICAL INITIAL DAD
+1EE3B          ; N  # Lo         ARABIC MATHEMATICAL INITIAL GHAIN
+1EE42          ; N  # Lo         ARABIC MATHEMATICAL TAILED JEEM
+1EE47          ; N  # Lo         ARABIC MATHEMATICAL TAILED HAH
+1EE49          ; N  # Lo         ARABIC MATHEMATICAL TAILED YEH
+1EE4B          ; N  # Lo         ARABIC MATHEMATICAL TAILED LAM
+1EE4D..1EE4F   ; N  # Lo     [3] ARABIC MATHEMATICAL TAILED NOON..ARABIC MATHEMATICAL TAILED AIN
+1EE51..1EE52   ; N  # Lo     [2] ARABIC MATHEMATICAL TAILED SAD..ARABIC MATHEMATICAL TAILED QAF
+1EE54          ; N  # Lo         ARABIC MATHEMATICAL TAILED SHEEN
+1EE57          ; N  # Lo         ARABIC MATHEMATICAL TAILED KHAH
+1EE59          ; N  # Lo         ARABIC MATHEMATICAL TAILED DAD
+1EE5B          ; N  # Lo         ARABIC MATHEMATICAL TAILED GHAIN
+1EE5D          ; N  # Lo         ARABIC MATHEMATICAL TAILED DOTLESS NOON
+1EE5F          ; N  # Lo         ARABIC MATHEMATICAL TAILED DOTLESS QAF
+1EE61..1EE62   ; N  # Lo     [2] ARABIC MATHEMATICAL STRETCHED BEH..ARABIC MATHEMATICAL STRETCHED JEEM
+1EE64          ; N  # Lo         ARABIC MATHEMATICAL STRETCHED HEH
+1EE67..1EE6A   ; N  # Lo     [4] ARABIC MATHEMATICAL STRETCHED HAH..ARABIC MATHEMATICAL STRETCHED KAF
+1EE6C..1EE72   ; N  # Lo     [7] ARABIC MATHEMATICAL STRETCHED MEEM..ARABIC MATHEMATICAL STRETCHED QAF
+1EE74..1EE77   ; N  # Lo     [4] ARABIC MATHEMATICAL STRETCHED SHEEN..ARABIC MATHEMATICAL STRETCHED KHAH
+1EE79..1EE7C   ; N  # Lo     [4] ARABIC MATHEMATICAL STRETCHED DAD..ARABIC MATHEMATICAL STRETCHED DOTLESS BEH
+1EE7E          ; N  # Lo         ARABIC MATHEMATICAL STRETCHED DOTLESS FEH
+1EE80..1EE89   ; N  # Lo    [10] ARABIC MATHEMATICAL LOOPED ALEF..ARABIC MATHEMATICAL LOOPED YEH
+1EE8B..1EE9B   ; N  # Lo    [17] ARABIC MATHEMATICAL LOOPED LAM..ARABIC MATHEMATICAL LOOPED GHAIN
+1EEA1..1EEA3   ; N  # Lo     [3] ARABIC MATHEMATICAL DOUBLE-STRUCK BEH..ARABIC MATHEMATICAL DOUBLE-STRUCK DAL
+1EEA5..1EEA9   ; N  # Lo     [5] ARABIC MATHEMATICAL DOUBLE-STRUCK WAW..ARABIC MATHEMATICAL DOUBLE-STRUCK YEH
+1EEAB..1EEBB   ; N  # Lo    [17] ARABIC MATHEMATICAL DOUBLE-STRUCK LAM..ARABIC MATHEMATICAL DOUBLE-STRUCK GHAIN
+1EEF0..1EEF1   ; N  # Sm     [2] ARABIC MATHEMATICAL OPERATOR MEEM WITH HAH WITH TATWEEL..ARABIC MATHEMATICAL OPERATOR HAH WITH DAL
+1F000..1F003   ; N  # So     [4] MAHJONG TILE EAST WIND..MAHJONG TILE NORTH WIND
+1F004          ; W  # So         MAHJONG TILE RED DRAGON
+1F005..1F02B   ; N  # So    [39] MAHJONG TILE GREEN DRAGON..MAHJONG TILE BACK
+1F030..1F093   ; N  # So   [100] DOMINO TILE HORIZONTAL BACK..DOMINO TILE VERTICAL-06-06
+1F0A0..1F0AE   ; N  # So    [15] PLAYING CARD BACK..PLAYING CARD KING OF SPADES
+1F0B1..1F0BF   ; N  # So    [15] PLAYING CARD ACE OF HEARTS..PLAYING CARD RED JOKER
+1F0C1..1F0CE   ; N  # So    [14] PLAYING CARD ACE OF DIAMONDS..PLAYING CARD KING OF DIAMONDS
+1F0CF          ; W  # So         PLAYING CARD BLACK JOKER
+1F0D1..1F0F5   ; N  # So    [37] PLAYING CARD ACE OF CLUBS..PLAYING CARD TRUMP-21
+1F100..1F10A   ; A  # No    [11] DIGIT ZERO FULL STOP..DIGIT NINE COMMA
+1F10B..1F10C   ; N  # No     [2] DINGBAT CIRCLED SANS-SERIF DIGIT ZERO..DINGBAT NEGATIVE CIRCLED SANS-SERIF DIGIT ZERO
+1F10D..1F10F   ; N  # So     [3] CIRCLED ZERO WITH SLASH..CIRCLED DOLLAR SIGN WITH OVERLAID BACKSLASH
+1F110..1F12D   ; A  # So    [30] PARENTHESIZED LATIN CAPITAL LETTER A..CIRCLED CD
+1F12E..1F12F   ; N  # So     [2] CIRCLED WZ..COPYLEFT SYMBOL
+1F130..1F169   ; A  # So    [58] SQUARED LATIN CAPITAL LETTER A..NEGATIVE CIRCLED LATIN CAPITAL LETTER Z
+1F16A..1F16F   ; N  # So     [6] RAISED MC SIGN..CIRCLED HUMAN FIGURE
+1F170..1F18D   ; A  # So    [30] NEGATIVE SQUARED LATIN CAPITAL LETTER A..NEGATIVE SQUARED SA
+1F18E          ; W  # So         NEGATIVE SQUARED AB
+1F18F..1F190   ; A  # So     [2] NEGATIVE SQUARED WC..SQUARE DJ
+1F191..1F19A   ; W  # So    [10] SQUARED CL..SQUARED VS
+1F19B..1F1AC   ; A  # So    [18] SQUARED THREE D..SQUARED VOD
+1F1AD          ; N  # So         MASK WORK SYMBOL
+1F1E6..1F1FF   ; N  # So    [26] REGIONAL INDICATOR SYMBOL LETTER A..REGIONAL INDICATOR SYMBOL LETTER Z
+1F200..1F202   ; W  # So     [3] SQUARE HIRAGANA HOKA..SQUARED KATAKANA SA
+1F210..1F23B   ; W  # So    [44] SQUARED CJK UNIFIED IDEOGRAPH-624B..SQUARED CJK UNIFIED IDEOGRAPH-914D
+1F240..1F248   ; W  # So     [9] TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-672C..TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH-6557
+1F250..1F251   ; W  # So     [2] CIRCLED IDEOGRAPH ADVANTAGE..CIRCLED IDEOGRAPH ACCEPT
+1F260..1F265   ; W  # So     [6] ROUNDED SYMBOL FOR FU..ROUNDED SYMBOL FOR CAI
+1F300..1F320   ; W  # So    [33] CYCLONE..SHOOTING STAR
+1F321..1F32C   ; N  # So    [12] THERMOMETER..WIND BLOWING FACE
+1F32D..1F335   ; W  # So     [9] HOT DOG..CACTUS
+1F336          ; N  # So         HOT PEPPER
+1F337..1F37C   ; W  # So    [70] TULIP..BABY BOTTLE
+1F37D          ; N  # So         FORK AND KNIFE WITH PLATE
+1F37E..1F393   ; W  # So    [22] BOTTLE WITH POPPING CORK..GRADUATION CAP
+1F394..1F39F   ; N  # So    [12] HEART WITH TIP ON THE LEFT..ADMISSION TICKETS
+1F3A0..1F3CA   ; W  # So    [43] CAROUSEL HORSE..SWIMMER
+1F3CB..1F3CE   ; N  # So     [4] WEIGHT LIFTER..RACING CAR
+1F3CF..1F3D3   ; W  # So     [5] CRICKET BAT AND BALL..TABLE TENNIS PADDLE AND BALL
+1F3D4..1F3DF   ; N  # So    [12] SNOW CAPPED MOUNTAIN..STADIUM
+1F3E0..1F3F0   ; W  # So    [17] HOUSE BUILDING..EUROPEAN CASTLE
+1F3F1..1F3F3   ; N  # So     [3] WHITE PENNANT..WAVING WHITE FLAG
+1F3F4          ; W  # So         WAVING BLACK FLAG
+1F3F5..1F3F7   ; N  # So     [3] ROSETTE..LABEL
+1F3F8..1F3FA   ; W  # So     [3] BADMINTON RACQUET AND SHUTTLECOCK..AMPHORA
+1F3FB..1F3FF   ; W  # Sk     [5] EMOJI MODIFIER FITZPATRICK TYPE-1-2..EMOJI MODIFIER FITZPATRICK TYPE-6
+1F400..1F43E   ; W  # So    [63] RAT..PAW PRINTS
+1F43F          ; N  # So         CHIPMUNK
+1F440          ; W  # So         EYES
+1F441          ; N  # So         EYE
+1F442..1F4FC   ; W  # So   [187] EAR..VIDEOCASSETTE
+1F4FD..1F4FE   ; N  # So     [2] FILM PROJECTOR..PORTABLE STEREO
+1F4FF..1F53D   ; W  # So    [63] PRAYER BEADS..DOWN-POINTING SMALL RED TRIANGLE
+1F53E..1F54A   ; N  # So    [13] LOWER RIGHT SHADOWED WHITE CIRCLE..DOVE OF PEACE
+1F54B..1F54E   ; W  # So     [4] KAABA..MENORAH WITH NINE BRANCHES
+1F54F          ; N  # So         BOWL OF HYGIEIA
+1F550..1F567   ; W  # So    [24] CLOCK FACE ONE OCLOCK..CLOCK FACE TWELVE-THIRTY
+1F568..1F579   ; N  # So    [18] RIGHT SPEAKER..JOYSTICK
+1F57A          ; W  # So         MAN DANCING
+1F57B..1F594   ; N  # So    [26] LEFT HAND TELEPHONE RECEIVER..REVERSED VICTORY HAND
+1F595..1F596   ; W  # So     [2] REVERSED HAND WITH MIDDLE FINGER EXTENDED..RAISED HAND WITH PART BETWEEN MIDDLE AND RING FINGERS
+1F597..1F5A3   ; N  # So    [13] WHITE DOWN POINTING LEFT HAND INDEX..BLACK DOWN POINTING BACKHAND INDEX
+1F5A4          ; W  # So         BLACK HEART
+1F5A5..1F5FA   ; N  # So    [86] DESKTOP COMPUTER..WORLD MAP
+1F5FB..1F5FF   ; W  # So     [5] MOUNT FUJI..MOYAI
+1F600..1F64F   ; W  # So    [80] GRINNING FACE..PERSON WITH FOLDED HANDS
+1F650..1F67F   ; N  # So    [48] NORTH WEST POINTING LEAF..REVERSE CHECKER BOARD
+1F680..1F6C5   ; W  # So    [70] ROCKET..LEFT LUGGAGE
+1F6C6..1F6CB   ; N  # So     [6] TRIANGLE WITH ROUNDED CORNERS..COUCH AND LAMP
+1F6CC          ; W  # So         SLEEPING ACCOMMODATION
+1F6CD..1F6CF   ; N  # So     [3] SHOPPING BAGS..BED
+1F6D0..1F6D2   ; W  # So     [3] PLACE OF WORSHIP..SHOPPING TROLLEY
+1F6D3..1F6D4   ; N  # So     [2] STUPA..PAGODA
+1F6D5..1F6D7   ; W  # So     [3] HINDU TEMPLE..ELEVATOR
+1F6DC..1F6DF   ; W  # So     [4] WIRELESS..RING BUOY
+1F6E0..1F6EA   ; N  # So    [11] HAMMER AND WRENCH..NORTHEAST-POINTING AIRPLANE
+1F6EB..1F6EC   ; W  # So     [2] AIRPLANE DEPARTURE..AIRPLANE ARRIVING
+1F6F0..1F6F3   ; N  # So     [4] SATELLITE..PASSENGER SHIP
+1F6F4..1F6FC   ; W  # So     [9] SCOOTER..ROLLER SKATE
+1F700..1F776   ; N  # So   [119] ALCHEMICAL SYMBOL FOR QUINTESSENCE..LUNAR ECLIPSE
+1F77B..1F77F   ; N  # So     [5] HAUMEA..ORCUS
+1F780..1F7D9   ; N  # So    [90] BLACK LEFT-POINTING ISOSCELES RIGHT TRIANGLE..NINE POINTED WHITE STAR
+1F7E0..1F7EB   ; W  # So    [12] LARGE ORANGE CIRCLE..LARGE BROWN SQUARE
+1F7F0          ; W  # So         HEAVY EQUALS SIGN
+1F800..1F80B   ; N  # So    [12] LEFTWARDS ARROW WITH SMALL TRIANGLE ARROWHEAD..DOWNWARDS ARROW WITH LARGE TRIANGLE ARROWHEAD
+1F810..1F847   ; N  # So    [56] LEFTWARDS ARROW WITH SMALL EQUILATERAL ARROWHEAD..DOWNWARDS HEAVY ARROW
+1F850..1F859   ; N  # So    [10] LEFTWARDS SANS-SERIF ARROW..UP DOWN SANS-SERIF ARROW
+1F860..1F887   ; N  # So    [40] WIDE-HEADED LEFTWARDS LIGHT BARB ARROW..WIDE-HEADED SOUTH WEST VERY HEAVY BARB ARROW
+1F890..1F8AD   ; N  # So    [30] LEFTWARDS TRIANGLE ARROWHEAD..WHITE ARROW SHAFT WIDTH TWO THIRDS
+1F8B0..1F8B1   ; N  # So     [2] ARROW POINTING UPWARDS THEN NORTH WEST..ARROW POINTING RIGHTWARDS THEN CURVING SOUTH WEST
+1F900..1F90B   ; N  # So    [12] CIRCLED CROSS FORMEE WITH FOUR DOTS..DOWNWARD FACING NOTCHED HOOK WITH DOT
+1F90C..1F93A   ; W  # So    [47] PINCHED FINGERS..FENCER
+1F93B          ; N  # So         MODERN PENTATHLON
+1F93C..1F945   ; W  # So    [10] WRESTLERS..GOAL NET
+1F946          ; N  # So         RIFLE
+1F947..1F9FF   ; W  # So   [185] FIRST PLACE MEDAL..NAZAR AMULET
+1FA00..1FA53   ; N  # So    [84] NEUTRAL CHESS KING..BLACK CHESS KNIGHT-BISHOP
+1FA60..1FA6D   ; N  # So    [14] XIANGQI RED GENERAL..XIANGQI BLACK SOLDIER
+1FA70..1FA7C   ; W  # So    [13] BALLET SHOES..CRUTCH
+1FA80..1FA88   ; W  # So     [9] YO-YO..FLUTE
+1FA90..1FABD   ; W  # So    [46] RINGED PLANET..WING
+1FABF..1FAC5   ; W  # So     [7] GOOSE..PERSON WITH CROWN
+1FACE..1FADB   ; W  # So    [14] MOOSE..PEA POD
+1FAE0..1FAE8   ; W  # So     [9] MELTING FACE..SHAKING FACE
+1FAF0..1FAF8   ; W  # So     [9] HAND WITH INDEX FINGER AND THUMB CROSSED..RIGHTWARDS PUSHING HAND
+1FB00..1FB92   ; N  # So   [147] BLOCK SEXTANT-1..UPPER HALF INVERSE MEDIUM SHADE AND LOWER HALF BLOCK
+1FB94..1FBCA   ; N  # So    [55] LEFT HALF INVERSE MEDIUM SHADE AND RIGHT HALF BLOCK..WHITE UP-POINTING CHEVRON
+1FBF0..1FBF9   ; N  # Nd    [10] SEGMENTED DIGIT ZERO..SEGMENTED DIGIT NINE
+20000..2A6DF   ; W  # Lo [42720] CJK UNIFIED IDEOGRAPH-20000..CJK UNIFIED IDEOGRAPH-2A6DF
+2A6E0..2A6FF   ; W  # Cn    [32] <reserved-2A6E0>..<reserved-2A6FF>
+2A700..2B739   ; W  # Lo  [4154] CJK UNIFIED IDEOGRAPH-2A700..CJK UNIFIED IDEOGRAPH-2B739
+2B73A..2B73F   ; W  # Cn     [6] <reserved-2B73A>..<reserved-2B73F>
+2B740..2B81D   ; W  # Lo   [222] CJK UNIFIED IDEOGRAPH-2B740..CJK UNIFIED IDEOGRAPH-2B81D
+2B81E..2B81F   ; W  # Cn     [2] <reserved-2B81E>..<reserved-2B81F>
+2B820..2CEA1   ; W  # Lo  [5762] CJK UNIFIED IDEOGRAPH-2B820..CJK UNIFIED IDEOGRAPH-2CEA1
+2CEA2..2CEAF   ; W  # Cn    [14] <reserved-2CEA2>..<reserved-2CEAF>
+2CEB0..2EBE0   ; W  # Lo  [7473] CJK UNIFIED IDEOGRAPH-2CEB0..CJK UNIFIED IDEOGRAPH-2EBE0
+2EBE1..2EBEF   ; W  # Cn    [15] <reserved-2EBE1>..<reserved-2EBEF>
+2EBF0..2EE5D   ; W  # Lo   [622] CJK UNIFIED IDEOGRAPH-2EBF0..CJK UNIFIED IDEOGRAPH-2EE5D
+2EE5E..2F7FF   ; W  # Cn  [2466] <reserved-2EE5E>..<reserved-2F7FF>
+2F800..2FA1D   ; W  # Lo   [542] CJK COMPATIBILITY IDEOGRAPH-2F800..CJK COMPATIBILITY IDEOGRAPH-2FA1D
+2FA1E..2FA1F   ; W  # Cn     [2] <reserved-2FA1E>..<reserved-2FA1F>
+2FA20..2FFFD   ; W  # Cn  [1502] <reserved-2FA20>..<reserved-2FFFD>
+30000..3134A   ; W  # Lo  [4939] CJK UNIFIED IDEOGRAPH-30000..CJK UNIFIED IDEOGRAPH-3134A
+3134B..3134F   ; W  # Cn     [5] <reserved-3134B>..<reserved-3134F>
+31350..323AF   ; W  # Lo  [4192] CJK UNIFIED IDEOGRAPH-31350..CJK UNIFIED IDEOGRAPH-323AF
+323B0..3FFFD   ; W  # Cn [56398] <reserved-323B0>..<reserved-3FFFD>
+E0001          ; N  # Cf         LANGUAGE TAG
+E0020..E007F   ; N  # Cf    [96] TAG SPACE..CANCEL TAG
+E0100..E01EF   ; A  # Mn   [240] VARIATION SELECTOR-17..VARIATION SELECTOR-256
+F0000..FFFFD   ; A  # Co [65534] <private-use-F0000>..<private-use-FFFFD>
+100000..10FFFD ; A  # Co [65534] <private-use-100000>..<private-use-10FFFD>
 
 # EOF
diff --git a/libc/str/freelocale.c b/libc/str/freelocale.c
deleted file mode 100644
index eba6fad5c..000000000
--- a/libc/str/freelocale.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/locale.h"
-
-void freelocale(locale_t l) {
-  // TODO: implement me
-}
diff --git a/libc/str/getx86processormodel.c b/libc/str/getx86processormodel.c
index 3ac7c77fe..9746cc4be 100644
--- a/libc/str/getx86processormodel.c
+++ b/libc/str/getx86processormodel.c
@@ -16,7 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/mem/bisect.internal.h"
 #include "libc/nexgen32e/x86info.h"
 
 static int CmpX86ProcModelKey(const struct X86ProcessorModel *a,
@@ -32,7 +31,8 @@ static int CmpX86ProcModelKey(const struct X86ProcessorModel *a,
  * @see https://a4lg.com/tech/x86/database/x86-families-and-models.en.html
  */
 const struct X86ProcessorModel *getx86processormodel(short key) {
-  return bisect(&(struct X86ProcessorModel){key}, kX86ProcessorModels,
-                kX86ProcessorModelCount, sizeof(struct X86ProcessorModel),
-                (void *)CmpX86ProcModelKey, NULL);
+  for (int i = 0; kX86ProcessorModels[i].key; ++i)
+    if (kX86ProcessorModels[i].key == key)
+      return &kX86ProcessorModels[i];
+  return 0;
 }
diff --git a/libc/str/getzipcdircomment.c b/libc/str/getzipcdircomment.c
index 35ca8b38f..85d8d8ce7 100644
--- a/libc/str/getzipcdircomment.c
+++ b/libc/str/getzipcdircomment.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns comment of zip central directory.
diff --git a/libc/str/getzipcdircommentsize.c b/libc/str/getzipcdircommentsize.c
index ac83f995b..c4fbc77d8 100644
--- a/libc/str/getzipcdircommentsize.c
+++ b/libc/str/getzipcdircommentsize.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns comment of zip central directory.
diff --git a/libc/str/getzipcdiroffset.c b/libc/str/getzipcdiroffset.c
index 6698290ce..0aaefb03d 100644
--- a/libc/str/getzipcdiroffset.c
+++ b/libc/str/getzipcdiroffset.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns offset of zip central directory.
diff --git a/libc/str/getzipcdirrecords.c b/libc/str/getzipcdirrecords.c
index 20f0cef59..f127dd299 100644
--- a/libc/str/getzipcdirrecords.c
+++ b/libc/str/getzipcdirrecords.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns number of records in zip central directory.
diff --git a/libc/str/getzipcdirsize.c b/libc/str/getzipcdirsize.c
index 3ea16c201..c8a1e3da9 100644
--- a/libc/str/getzipcdirsize.c
+++ b/libc/str/getzipcdirsize.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns size of zip central directory.
diff --git a/libc/str/getzipcfilecompressedsize.c b/libc/str/getzipcfilecompressedsize.c
index f2c26ba36..96a492e84 100644
--- a/libc/str/getzipcfilecompressedsize.c
+++ b/libc/str/getzipcfilecompressedsize.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns compressed size in bytes from zip central directory header.
diff --git a/libc/str/getzipcfilemode.c b/libc/str/getzipcfilemode.c
index f4a944301..d73e708a4 100644
--- a/libc/str/getzipcfilemode.c
+++ b/libc/str/getzipcfilemode.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/nt/enum/fileflagandattributes.h"
 #include "libc/sysv/consts/s.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 static int ConvertWindowsToUnixMode(int x) {
   int m;
diff --git a/libc/str/getzipcfileoffset.c b/libc/str/getzipcfileoffset.c
index 5a18f6a92..66726cea8 100644
--- a/libc/str/getzipcfileoffset.c
+++ b/libc/str/getzipcfileoffset.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns offset of local file header.
diff --git a/libc/str/getzipcfiletimestamps.c b/libc/str/getzipcfiletimestamps.c
index 0a06b6992..4d246c4ab 100644
--- a/libc/str/getzipcfiletimestamps.c
+++ b/libc/str/getzipcfiletimestamps.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/wintime.internal.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 static inline int pop(int x) {
   return !!(x & 1) + !!(x & 2) + !!(x & 4);
diff --git a/libc/str/getzipcfileuncompressedsize.c b/libc/str/getzipcfileuncompressedsize.c
index 3a38bd29e..d129b55e5 100644
--- a/libc/str/getzipcfileuncompressedsize.c
+++ b/libc/str/getzipcfileuncompressedsize.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns uncompressed size in bytes from zip central directory header.
diff --git a/libc/str/getzipeocd.c b/libc/str/getzipeocd.c
index ee862cc19..86c1cc1e7 100644
--- a/libc/str/getzipeocd.c
+++ b/libc/str/getzipeocd.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 typedef char v16qi __attribute__((__vector_size__(16)));
 typedef short v8hi __attribute__((__vector_size__(16)));
diff --git a/libc/str/getziplfilecompressedsize.c b/libc/str/getziplfilecompressedsize.c
index 26403d300..5147c8934 100644
--- a/libc/str/getziplfilecompressedsize.c
+++ b/libc/str/getziplfilecompressedsize.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns compressed size in bytes from zip local file header.
diff --git a/libc/str/getziplfileuncompressedsize.c b/libc/str/getziplfileuncompressedsize.c
index 86a6b3621..e76b74bc9 100644
--- a/libc/str/getziplfileuncompressedsize.c
+++ b/libc/str/getziplfileuncompressedsize.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns uncompressed size in bytes from zip local file header.
diff --git a/libc/str/has_char.h b/libc/str/has_char.h
new file mode 100644
index 000000000..64c5a4763
--- /dev/null
+++ b/libc/str/has_char.h
@@ -0,0 +1,24 @@
+// -*- c++ -*-
+#ifndef COSMOPOLITAN_LIBC_STR_HAS_CHAR_H_
+#define COSMOPOLITAN_LIBC_STR_HAS_CHAR_H_
+#ifdef __cplusplus
+
+template <typename T>
+static bool has_char(const T (*ranges)[2], size_t n, T c) {
+  unsigned l = 0;
+  unsigned r = n;
+  while (l < r) {
+    unsigned m = (l & r) + ((l ^ r) >> 1);  // floor((a+b)/2)
+    if (c < ranges[m][0]) {
+      r = m;
+    } else if (c > ranges[m][1]) {
+      l = m + 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+
+#endif /* __cplusplus */
+#endif /* COSMOPOLITAN_LIBC_STR_HAS_CHAR_H_ */
diff --git a/libc/str/intsort.c b/libc/str/intsort.c
index 335b7f98d..2b71b1c41 100644
--- a/libc/str/intsort.c
+++ b/libc/str/intsort.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 
 static inline void InsertionSort(int *A, long n) {
diff --git a/libc/str/isalnum.c b/libc/str/isalnum.c
index e202f503b..910cebbe3 100644
--- a/libc/str/isalnum.c
+++ b/libc/str/isalnum.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is lower, alpha, or digit.
diff --git a/libc/str/isalpha.c b/libc/str/isalpha.c
index 6aee95aa8..5e4823f08 100644
--- a/libc/str/isalpha.c
+++ b/libc/str/isalpha.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is upper or lower.
diff --git a/libc/str/isascii.c b/libc/str/isascii.c
index 1a85dd308..617830d5b 100644
--- a/libc/str/isascii.c
+++ b/libc/str/isascii.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is ascii.
diff --git a/libc/str/isblank.c b/libc/str/isblank.c
index c99897b19..71b63e3ae 100644
--- a/libc/str/isblank.c
+++ b/libc/str/isblank.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is space or tab.
diff --git a/libc/str/iscntrl.c b/libc/str/iscntrl.c
index 7e3fef430..a98c3f754 100644
--- a/libc/str/iscntrl.c
+++ b/libc/str/iscntrl.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is C0 ASCII control code or DEL.
diff --git a/libc/str/isdigit.c b/libc/str/isdigit.c
index b7400f4ad..da34a2f85 100644
--- a/libc/str/isdigit.c
+++ b/libc/str/isdigit.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is decimal digit.
diff --git a/libc/str/isgraph.c b/libc/str/isgraph.c
index cd2401b50..46bc713f4 100644
--- a/libc/str/isgraph.c
+++ b/libc/str/isgraph.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is printable ascii that isn't space.
diff --git a/libc/str/islower.c b/libc/str/islower.c
index 49ecc83b4..f9a764d81 100644
--- a/libc/str/islower.c
+++ b/libc/str/islower.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is lowercase alpha ascii character.
diff --git a/libc/str/isprint.c b/libc/str/isprint.c
index d27c40dd2..8f3c81edb 100644
--- a/libc/str/isprint.c
+++ b/libc/str/isprint.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is printable ascii including space.
diff --git a/libc/str/ispunct.c b/libc/str/ispunct.c
index 6928950d7..a67f9137b 100644
--- a/libc/str/ispunct.c
+++ b/libc/str/ispunct.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if ``c ∈ !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~``
diff --git a/libc/str/isspace.c b/libc/str/isspace.c
index a82c74be4..350efb337 100644
--- a/libc/str/isspace.c
+++ b/libc/str/isspace.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is space, \t, \r, \n, \f, or \v.
diff --git a/libc/str/isupper.c b/libc/str/isupper.c
index 1666bc28b..d07bace8b 100644
--- a/libc/str/isupper.c
+++ b/libc/str/isupper.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns nonzero if c is uppercase alpha ascii character.
diff --git a/libc/str/iswalpha.c b/libc/str/iswalpha.c
deleted file mode 100644
index db8872b1f..000000000
--- a/libc/str/iswalpha.c
+++ /dev/null
@@ -1,28 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-/**
- * Returns nonzero if c is alphabetical.
- */
-int iswalpha(wint_t c) {
-  return iswupper(c) || iswlower(c);
-}
-
-__weak_reference(iswalpha, iswalpha_l);
diff --git a/libc/str/iswblank.c b/libc/str/iswblank.c
index 07a7b9bb9..4d42bcc6d 100644
--- a/libc/str/iswblank.c
+++ b/libc/str/iswblank.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Returns nonzero if c is space or tab.
diff --git a/libc/str/iswcntrl.c b/libc/str/iswcntrl.c
index 2a103395f..a8f63aba3 100644
--- a/libc/str/iswcntrl.c
+++ b/libc/str/iswcntrl.c
@@ -16,13 +16,18 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
- * Returns nonzero if c is C0 or C1 control code.
+ * Returns nonzero if `c` is control code.
+ *
+ * This includes C0 or C1 control codes, in addition to the "LINE
+ * SEPARATOR" and "PARAGRAPH SEPARATOR" characters.
  */
 int iswcntrl(wint_t c) {
-  return (0x00 <= c && c <= 0x1F) || (0x7F <= c && c <= 0x9F);
+  return (0x0000 <= c && c <= 0x001F) ||  //
+         (0x007F <= c && c <= 0x009F) ||  //
+         (0x2028 <= c && c <= 0x2029);
 }
 
 __weak_reference(iswcntrl, iswcntrl_l);
diff --git a/libc/str/iswdigit.c b/libc/str/iswdigit.c
index 6d7b0232c..16ae3d9a6 100644
--- a/libc/str/iswdigit.c
+++ b/libc/str/iswdigit.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Returns nonzero if c is decimal digit.
diff --git a/libc/str/iswgraph.c b/libc/str/iswgraph.c
index 8e420286a..def864fc0 100644
--- a/libc/str/iswgraph.c
+++ b/libc/str/iswgraph.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Returns nonzero if c is printable and not a space.
diff --git a/libc/str/iswlower.c b/libc/str/iswlower.c
deleted file mode 100644
index aba9180c6..000000000
--- a/libc/str/iswlower.c
+++ /dev/null
@@ -1,520 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-/**
- * Returns nonzero if c is lowercase letter.
- */
-int iswlower(wint_t c) {
-  if (c < 0200) {
-    return 'a' <= c && c <= 'z';
-  } else {
-    if (towupper(c) != c)
-      return 1;
-    switch (c) {
-      case 0x00df:  /* ß Watin */
-      case 0x0138:  /* ĸ Watin-A */
-      case 0x0149:  /* ʼn Watin-A */
-      case 0x018d:  /* ƍ Watin-B */
-      case 0x019b:  /* ƛ Watin-B */
-      case 0x01aa:  /* ƪ Watin-B */
-      case 0x01ab:  /* ƫ Watin-B */
-      case 0x01ba:  /* ƺ Watin-B */
-      case 0x01be:  /* ƾ Watin-B */
-      case 0x01f0:  /* ǰ Watin-B */
-      case 0x0221:  /* ȡ Watin-B */
-      case 0x0234:  /* ȴ Watin-B */
-      case 0x0235:  /* ȵ Watin-B */
-      case 0x0236:  /* ȶ Watin-B */
-      case 0x0237:  /* ȷ Watin-B */
-      case 0x0238:  /* ȸ Watin-B */
-      case 0x0239:  /* ȹ Watin-B */
-      case 0x0255:  /* ɕ IPA */
-      case 0x0258:  /* ɘ IPA */
-      case 0x025a:  /* ɚ IPA */
-      case 0x025d:  /* ɝ IPA */
-      case 0x025e:  /* ɞ IPA */
-      case 0x025f:  /* ɟ IPA */
-      case 0x0262:  /* ɢ IPA */
-      case 0x0264:  /* ɤ IPA */
-      case 0x0267:  /* ɧ IPA */
-      case 0x026d:  /* ɭ IPA */
-      case 0x026e:  /* ɮ IPA */
-      case 0x0270:  /* ɰ IPA */
-      case 0x0273:  /* ɳ IPA */
-      case 0x0274:  /* ɴ IPA */
-      case 0x0276:  /* ɶ IPA */
-      case 0x0277:  /* ɷ IPA */
-      case 0x0278:  /* ɸ IPA */
-      case 0x0279:  /* ɹ IPA */
-      case 0x027a:  /* ɺ IPA */
-      case 0x027b:  /* ɻ IPA */
-      case 0x027c:  /* ɼ IPA */
-      case 0x027e:  /* ɾ IPA */
-      case 0x027f:  /* ɿ IPA */
-      case 0x0281:  /* ʁ IPA */
-      case 0x0284:  /* ʄ IPA */
-      case 0x0285:  /* ʅ IPA */
-      case 0x0286:  /* ʆ IPA */
-      case 0x028d:  /* ʍ IPA */
-      case 0x028e:  /* ʎ IPA */
-      case 0x028f:  /* ʏ IPA */
-      case 0x0290:  /* ʐ IPA */
-      case 0x0291:  /* ʑ IPA */
-      case 0x0293:  /* ʓ IPA */
-      case 0x0295:  /* ʕ IPA */
-      case 0x0296:  /* ʖ IPA */
-      case 0x0297:  /* ʗ IPA */
-      case 0x0298:  /* ʘ IPA */
-      case 0x0299:  /* ʙ IPA */
-      case 0x029a:  /* ʚ IPA */
-      case 0x029b:  /* ʛ IPA */
-      case 0x029c:  /* ʜ IPA */
-      case 0x029f:  /* ʟ IPA */
-      case 0x02a0:  /* ʠ IPA */
-      case 0x02a1:  /* ʡ IPA */
-      case 0x02a2:  /* ʢ IPA */
-      case 0x02a3:  /* ʣ IPA */
-      case 0x02a4:  /* ʤ IPA */
-      case 0x02a5:  /* ʥ IPA */
-      case 0x02a6:  /* ʦ IPA */
-      case 0x02a7:  /* ʧ IPA */
-      case 0x02a8:  /* ʨ IPA */
-      case 0x02a9:  /* ʩ IPA */
-      case 0x02aa:  /* ʪ IPA */
-      case 0x02ab:  /* ʫ IPA */
-      case 0x02ac:  /* ʬ IPA */
-      case 0x02ad:  /* ʭ IPA */
-      case 0x02ae:  /* ʮ IPA */
-      case 0x02af:  /* ʯ IPA */
-      case 0x0390:  /* ΐ Greek */
-      case 0x03b0:  /* ΰ Greek */
-      case 0x03fc:  /* ϼ Greek */
-      case 0x0560:  /* ՠ Armenian */
-      case 0x0587:  /* և Armenian */
-      case 0x0588:  /* ֈ Armenian */
-      case 0x1d00:  /* ᴀ Phonetic Extensions */
-      case 0x1d01:  /* ᴁ Phonetic Extensions */
-      case 0x1d02:  /* ᴂ Phonetic Extensions */
-      case 0x1d03:  /* ᴃ Phonetic Extensions */
-      case 0x1d04:  /* ᴄ Phonetic Extensions */
-      case 0x1d05:  /* ᴅ Phonetic Extensions */
-      case 0x1d06:  /* ᴆ Phonetic Extensions */
-      case 0x1d07:  /* ᴇ Phonetic Extensions */
-      case 0x1d08:  /* ᴈ Phonetic Extensions */
-      case 0x1d09:  /* ᴉ Phonetic Extensions */
-      case 0x1d0a:  /* ᴊ Phonetic Extensions */
-      case 0x1d0b:  /* ᴋ Phonetic Extensions */
-      case 0x1d0c:  /* ᴌ Phonetic Extensions */
-      case 0x1d0d:  /* ᴍ Phonetic Extensions */
-      case 0x1d0e:  /* ᴎ Phonetic Extensions */
-      case 0x1d0f:  /* ᴏ Phonetic Extensions */
-      case 0x1d10:  /* ᴐ Phonetic Extensions */
-      case 0x1d11:  /* ᴑ Phonetic Extensions */
-      case 0x1d12:  /* ᴒ Phonetic Extensions */
-      case 0x1d13:  /* ᴓ Phonetic Extensions */
-      case 0x1d14:  /* ᴔ Phonetic Extensions */
-      case 0x1d15:  /* ᴕ Phonetic Extensions */
-      case 0x1d16:  /* ᴖ Phonetic Extensions */
-      case 0x1d17:  /* ᴗ Phonetic Extensions */
-      case 0x1d18:  /* ᴘ Phonetic Extensions */
-      case 0x1d19:  /* ᴙ Phonetic Extensions */
-      case 0x1d1a:  /* ᴚ Phonetic Extensions */
-      case 0x1d1b:  /* ᴛ Phonetic Extensions */
-      case 0x1d1c:  /* ᴜ Phonetic Extensions */
-      case 0x1d1d:  /* ᴝ Phonetic Extensions */
-      case 0x1d1e:  /* ᴞ Phonetic Extensions */
-      case 0x1d1f:  /* ᴟ Phonetic Extensions */
-      case 0x1d20:  /* ᴠ Phonetic Extensions */
-      case 0x1d21:  /* ᴡ Phonetic Extensions */
-      case 0x1d22:  /* ᴢ Phonetic Extensions */
-      case 0x1d23:  /* ᴣ Phonetic Extensions */
-      case 0x1d24:  /* ᴤ Phonetic Extensions */
-      case 0x1d25:  /* ᴥ Phonetic Extensions */
-      case 0x1d26:  /* ᴦ Phonetic Extensions */
-      case 0x1d27:  /* ᴧ Phonetic Extensions */
-      case 0x1d28:  /* ᴨ Phonetic Extensions */
-      case 0x1d29:  /* ᴩ Phonetic Extensions */
-      case 0x1d2a:  /* ᴪ Phonetic Extensions */
-      case 0x1d2b:  /* ᴫ Phonetic Extensions */
-      case 0x1d6b:  /* ᵫ Phonetic Extensions */
-      case 0x1d6c:  /* ᵬ Phonetic Extensions */
-      case 0x1d6d:  /* ᵭ Phonetic Extensions */
-      case 0x1d6e:  /* ᵮ Phonetic Extensions */
-      case 0x1d6f:  /* ᵯ Phonetic Extensions */
-      case 0x1d70:  /* ᵰ Phonetic Extensions */
-      case 0x1d71:  /* ᵱ Phonetic Extensions */
-      case 0x1d72:  /* ᵲ Phonetic Extensions */
-      case 0x1d73:  /* ᵳ Phonetic Extensions */
-      case 0x1d74:  /* ᵴ Phonetic Extensions */
-      case 0x1d75:  /* ᵵ Phonetic Extensions */
-      case 0x1d76:  /* ᵶ Phonetic Extensions */
-      case 0x1d77:  /* ᵷ Phonetic Extensions */
-      case 0x1d7a:  /* ᵺ Phonetic Extensions */
-      case 0x1d7b:  /* ᵻ Phonetic Extensions */
-      case 0x1d7c:  /* ᵼ Phonetic Extensions */
-      case 0x1d7e:  /* ᵾ Phonetic Extensions */
-      case 0x1d7f:  /* ᵿ Phonetic Extensions */
-      case 0x1d80:  /* . Phonetic Extensions Supplement */
-      case 0x1d81:  /* . Phonetic Extensions Supplement */
-      case 0x1d82:  /* . Phonetic Extensions Supplement */
-      case 0x1d83:  /* . Phonetic Extensions Supplement */
-      case 0x1d84:  /* . Phonetic Extensions Supplement */
-      case 0x1d85:  /* . Phonetic Extensions Supplement */
-      case 0x1d86:  /* . Phonetic Extensions Supplement */
-      case 0x1d87:  /* . Phonetic Extensions Supplement */
-      case 0x1d88:  /* . Phonetic Extensions Supplement */
-      case 0x1d89:  /* . Phonetic Extensions Supplement */
-      case 0x1d8a:  /* . Phonetic Extensions Supplement */
-      case 0x1d8b:  /* . Phonetic Extensions Supplement */
-      case 0x1d8c:  /* . Phonetic Extensions Supplement */
-      case 0x1d8d:  /* . Phonetic Extensions Supplement */
-      case 0x1d8f:  /* . Phonetic Extensions Supplement */
-      case 0x1d90:  /* . Phonetic Extensions Supplement */
-      case 0x1d91:  /* . Phonetic Extensions Supplement */
-      case 0x1d92:  /* . Phonetic Extensions Supplement */
-      case 0x1d93:  /* . Phonetic Extensions Supplement */
-      case 0x1d94:  /* . Phonetic Extensions Supplement */
-      case 0x1d95:  /* . Phonetic Extensions Supplement */
-      case 0x1d96:  /* . Phonetic Extensions Supplement */
-      case 0x1d97:  /* . Phonetic Extensions Supplement */
-      case 0x1d98:  /* . Phonetic Extensions Supplement */
-      case 0x1d99:  /* . Phonetic Extensions Supplement */
-      case 0x1d9a:  /* . Phonetic Extensions Supplement */
-      case 0x1e96:  /* ẖ Watin-C */
-      case 0x1e97:  /* ẗ Watin-C */
-      case 0x1e98:  /* ẘ Watin-C */
-      case 0x1e99:  /* ẙ Watin-C */
-      case 0x1e9a:  /* ẚ Watin-C */
-      case 0x1e9c:  /* ẜ Watin-C */
-      case 0x1e9d:  /* ẝ Watin-C */
-      case 0x1e9f:  /* ẟ Watin-C */
-      case 0x1f50:  /* ὐ Greek2 */
-      case 0x1f52:  /* ὒ Greek2 */
-      case 0x1f54:  /* ὔ Greek2 */
-      case 0x1f56:  /* ὖ Greek2 */
-      case 0x1fb2:  /* ᾲ Greek2 */
-      case 0x1fb4:  /* ᾴ Greek2 */
-      case 0x1fb6:  /* ᾶ Greek2 */
-      case 0x1fb7:  /* ᾷ Greek2 */
-      case 0x1fc2:  /* ῂ Greek2 */
-      case 0x1fc4:  /* ῄ Greek2 */
-      case 0x1fc6:  /* ῆ Greek2 */
-      case 0x1fc7:  /* ῇ Greek2 */
-      case 0x1fd2:  /* ῒ Greek2 */
-      case 0x1fd3:  /* ΐ Greek2 */
-      case 0x1fd6:  /* ῖ Greek2 */
-      case 0x1fd7:  /* ῗ Greek2 */
-      case 0x1fe2:  /* ῢ Greek2 */
-      case 0x1fe3:  /* ΰ Greek2 */
-      case 0x1fe4:  /* ῤ Greek2 */
-      case 0x1fe6:  /* ῦ Greek2 */
-      case 0x1fe7:  /* ῧ Greek2 */
-      case 0x1ff2:  /* ῲ Greek2 */
-      case 0x1ff4:  /* ῴ Greek2 */
-      case 0x1ff6:  /* ῶ Greek2 */
-      case 0x1ff7:  /* ῷ Greek2 */
-      case 0x210a:  /* ℊ Letterlike */
-      case 0x210e:  /* ℎ Letterlike */
-      case 0x210f:  /* ℏ Letterlike */
-      case 0x2113:  /* ℓ Letterlike */
-      case 0x212f:  /* ℯ Letterlike */
-      case 0x2134:  /* ℴ Letterlike */
-      case 0x2139:  /* ℹ Letterlike */
-      case 0x213c:  /* ℼ Letterlike */
-      case 0x213d:  /* ℽ Letterlike */
-      case 0x2146:  /* ⅆ Letterlike */
-      case 0x2147:  /* ⅇ Letterlike */
-      case 0x2148:  /* ⅈ Letterlike */
-      case 0x2149:  /* ⅉ Letterlike */
-      case 0x2c71:  /* . Watin-D */
-      case 0x2c74:  /* . Watin-D */
-      case 0x2c77:  /* . Watin-D */
-      case 0x2c78:  /* . Watin-D */
-      case 0x2c79:  /* . Watin-D */
-      case 0x2c7a:  /* . Watin-D */
-      case 0x2c7b:  /* . Watin-D */
-      case 0x2ce4:  /* . Coptic */
-      case 0xa730:  /* . Latin Extended-D */
-      case 0xa731:  /* . Latin Extended-D */
-      case 0xa771:  /* . Latin Extended-D */
-      case 0xa772:  /* . Latin Extended-D */
-      case 0xa773:  /* . Latin Extended-D */
-      case 0xa774:  /* . Latin Extended-D */
-      case 0xa775:  /* . Latin Extended-D */
-      case 0xa776:  /* . Latin Extended-D */
-      case 0xa777:  /* . Latin Extended-D */
-      case 0xa778:  /* . Latin Extended-D */
-      case 0xa78e:  /* . Latin Extended-D */
-      case 0xa795:  /* . Latin Extended-D */
-      case 0xa7af:  /* . Latin Extended-D */
-      case 0xa7fa:  /* . Latin Extended-D */
-      case 0xab30:  /* . Latin Extended-E */
-      case 0xab31:  /* . Latin Extended-E */
-      case 0xab32:  /* . Latin Extended-E */
-      case 0xab33:  /* . Latin Extended-E */
-      case 0xab34:  /* . Latin Extended-E */
-      case 0xab35:  /* . Latin Extended-E */
-      case 0xab36:  /* . Latin Extended-E */
-      case 0xab37:  /* . Latin Extended-E */
-      case 0xab38:  /* . Latin Extended-E */
-      case 0xab39:  /* . Latin Extended-E */
-      case 0xab3a:  /* . Latin Extended-E */
-      case 0xab3b:  /* . Latin Extended-E */
-      case 0xab3c:  /* . Latin Extended-E */
-      case 0xab3d:  /* . Latin Extended-E */
-      case 0xab3e:  /* . Latin Extended-E */
-      case 0xab3f:  /* . Latin Extended-E */
-      case 0xab40:  /* . Latin Extended-E */
-      case 0xab41:  /* . Latin Extended-E */
-      case 0xab42:  /* . Latin Extended-E */
-      case 0xab43:  /* . Latin Extended-E */
-      case 0xab44:  /* . Latin Extended-E */
-      case 0xab45:  /* . Latin Extended-E */
-      case 0xab46:  /* . Latin Extended-E */
-      case 0xab47:  /* . Latin Extended-E */
-      case 0xab48:  /* . Latin Extended-E */
-      case 0xab49:  /* . Latin Extended-E */
-      case 0xab4a:  /* . Latin Extended-E */
-      case 0xab4b:  /* . Latin Extended-E */
-      case 0xab4c:  /* . Latin Extended-E */
-      case 0xab4d:  /* . Latin Extended-E */
-      case 0xab4e:  /* . Latin Extended-E */
-      case 0xab4f:  /* . Latin Extended-E */
-      case 0xab50:  /* . Latin Extended-E */
-      case 0xab51:  /* . Latin Extended-E */
-      case 0xab52:  /* . Latin Extended-E */
-      case 0xab54:  /* . Latin Extended-E */
-      case 0xab55:  /* . Latin Extended-E */
-      case 0xab56:  /* . Latin Extended-E */
-      case 0xab57:  /* . Latin Extended-E */
-      case 0xab58:  /* . Latin Extended-E */
-      case 0xab59:  /* . Latin Extended-E */
-      case 0xab5a:  /* . Latin Extended-E */
-      case 0xab60:  /* . Latin Extended-E */
-      case 0xab61:  /* . Latin Extended-E */
-      case 0xab62:  /* . Latin Extended-E */
-      case 0xab63:  /* . Latin Extended-E */
-      case 0xab64:  /* . Latin Extended-E */
-      case 0xab65:  /* . Latin Extended-E */
-      case 0xab66:  /* . Latin Extended-E */
-      case 0xab67:  /* . Latin Extended-E */
-      case 0xfb00:  /* . Alphabetic Presentation Forms */
-      case 0xfb01:  /* . Alphabetic Presentation Forms */
-      case 0xfb02:  /* . Alphabetic Presentation Forms */
-      case 0xfb03:  /* . Alphabetic Presentation Forms */
-      case 0xfb04:  /* . Alphabetic Presentation Forms */
-      case 0xfb05:  /* . Alphabetic Presentation Forms */
-      case 0xfb06:  /* . Alphabetic Presentation Forms */
-      case 0xfb13:  /* . Alphabetic Presentation Forms */
-      case 0xfb14:  /* . Alphabetic Presentation Forms */
-      case 0xfb15:  /* . Alphabetic Presentation Forms */
-      case 0xfb16:  /* . Alphabetic Presentation Forms */
-      case 0xfb17:  /* . Alphabetic Presentation Forms */
-      case 0x1d44e: /* 𝑎 Math */
-      case 0x1d44f: /* 𝑏 Math */
-      case 0x1d450: /* 𝑐 Math */
-      case 0x1d451: /* 𝑑 Math */
-      case 0x1d452: /* 𝑒 Math */
-      case 0x1d453: /* 𝑓 Math */
-      case 0x1d454: /* 𝑔 Math */
-      case 0x1d45e: /* 𝑞 Math */
-      case 0x1d45f: /* 𝑟 Math */
-      case 0x1d460: /* 𝑠 Math */
-      case 0x1d461: /* 𝑡 Math */
-      case 0x1d462: /* 𝑢 Math */
-      case 0x1d463: /* 𝑣 Math */
-      case 0x1d464: /* 𝑤 Math */
-      case 0x1d465: /* 𝑥 Math */
-      case 0x1d466: /* 𝑦 Math */
-      case 0x1d467: /* 𝑧 Math */
-      case 0x1d4b6: /* 𝒶 Math */
-      case 0x1d4b7: /* 𝒷 Math */
-      case 0x1d4b8: /* 𝒸 Math */
-      case 0x1d4b9: /* 𝒹 Math */
-      case 0x1d4bb: /* 𝒻 Math */
-      case 0x1d4bd: /* 𝒽 Math */
-      case 0x1d4be: /* 𝒾 Math */
-      case 0x1d4bf: /* 𝒿 Math */
-      case 0x1d4c0: /* 𝓀 Math */
-      case 0x1d4c1: /* 𝓁 Math */
-      case 0x1d4c2: /* 𝓂 Math */
-      case 0x1d4c3: /* 𝓃 Math */
-      case 0x1d4c5: /* 𝓅 Math */
-      case 0x1d4c6: /* 𝓆 Math */
-      case 0x1d4c7: /* 𝓇 Math */
-      case 0x1d51e: /* 𝔞 Math */
-      case 0x1d51f: /* 𝔟 Math */
-      case 0x1d520: /* 𝔠 Math */
-      case 0x1d521: /* 𝔡 Math */
-      case 0x1d522: /* 𝔢 Math */
-      case 0x1d523: /* 𝔣 Math */
-      case 0x1d524: /* 𝔤 Math */
-      case 0x1d525: /* 𝔥 Math */
-      case 0x1d526: /* 𝔦 Math */
-      case 0x1d52f: /* 𝔯 Math */
-      case 0x1d530: /* 𝔰 Math */
-      case 0x1d531: /* 𝔱 Math */
-      case 0x1d532: /* 𝔲 Math */
-      case 0x1d533: /* 𝔳 Math */
-      case 0x1d534: /* 𝔴 Math */
-      case 0x1d535: /* 𝔵 Math */
-      case 0x1d536: /* 𝔶 Math */
-      case 0x1d537: /* 𝔷 Math */
-      case 0x1d552: /* 𝕒 Math */
-      case 0x1d553: /* 𝕓 Math */
-      case 0x1d554: /* 𝕔 Math */
-      case 0x1d555: /* 𝕕 Math */
-      case 0x1d556: /* 𝕖 Math */
-      case 0x1d557: /* 𝕗 Math */
-      case 0x1d558: /* 𝕘 Math */
-      case 0x1d559: /* 𝕙 Math */
-      case 0x1d55a: /* 𝕚 Math */
-      case 0x1d55b: /* 𝕛 Math */
-      case 0x1d55c: /* 𝕜 Math */
-      case 0x1d55d: /* 𝕝 Math */
-      case 0x1d55e: /* 𝕞 Math */
-      case 0x1d55f: /* 𝕟 Math */
-      case 0x1d560: /* 𝕠 Math */
-      case 0x1d561: /* 𝕡 Math */
-      case 0x1d562: /* 𝕢 Math */
-      case 0x1d563: /* 𝕣 Math */
-      case 0x1d564: /* 𝕤 Math */
-      case 0x1d565: /* 𝕥 Math */
-      case 0x1d566: /* 𝕦 Math */
-      case 0x1d567: /* 𝕧 Math */
-      case 0x1d568: /* 𝕨 Math */
-      case 0x1d569: /* 𝕩 Math */
-      case 0x1d56a: /* 𝕪 Math */
-      case 0x1d56b: /* 𝕫 Math */
-      case 0x1d656: /* 𝙖 Math */
-      case 0x1d657: /* 𝙗 Math */
-      case 0x1d658: /* 𝙘 Math */
-      case 0x1d659: /* 𝙙 Math */
-      case 0x1d65a: /* 𝙚 Math */
-      case 0x1d65b: /* 𝙛 Math */
-      case 0x1d65c: /* 𝙜 Math */
-      case 0x1d65d: /* 𝙝 Math */
-      case 0x1d65e: /* 𝙞 Math */
-      case 0x1d65f: /* 𝙟 Math */
-      case 0x1d660: /* 𝙠 Math */
-      case 0x1d661: /* 𝙡 Math */
-      case 0x1d662: /* 𝙢 Math */
-      case 0x1d663: /* 𝙣 Math */
-      case 0x1d664: /* 𝙤 Math */
-      case 0x1d665: /* 𝙥 Math */
-      case 0x1d666: /* 𝙦 Math */
-      case 0x1d667: /* 𝙧 Math */
-      case 0x1d668: /* 𝙨 Math */
-      case 0x1d669: /* 𝙩 Math */
-      case 0x1d66a: /* 𝙪 Math */
-      case 0x1d66b: /* 𝙫 Math */
-      case 0x1d66c: /* 𝙬 Math */
-      case 0x1d66d: /* 𝙭 Math */
-      case 0x1d66e: /* 𝙮 Math */
-      case 0x1d66f: /* 𝙯 Math */
-      case 0x1d6da: /* 𝛚 Math */
-      case 0x1d6dc: /* 𝛜 Math */
-      case 0x1d6dd: /* 𝛝 Math */
-      case 0x1d6de: /* 𝛞 Math */
-      case 0x1d6df: /* 𝛟 Math */
-      case 0x1d6e0: /* 𝛠 Math */
-      case 0x1d6e1: /* 𝛡 Math */
-      case 0x1d70d: /* 𝜍 Math */
-      case 0x1d70e: /* 𝜎 Math */
-      case 0x1d70f: /* 𝜏 Math */
-      case 0x1d710: /* 𝜐 Math */
-      case 0x1d711: /* 𝜑 Math */
-      case 0x1d712: /* 𝜒 Math */
-      case 0x1d713: /* 𝜓 Math */
-      case 0x1d714: /* 𝜔 Math */
-      case 0x1d716: /* 𝜖 Math */
-      case 0x1d717: /* 𝜗 Math */
-      case 0x1d718: /* 𝜘 Math */
-      case 0x1d719: /* 𝜙 Math */
-      case 0x1d71a: /* 𝜚 Math */
-      case 0x1d71b: /* 𝜛 Math */
-      case 0x1d747: /* 𝝇 Math */
-      case 0x1d748: /* 𝝈 Math */
-      case 0x1d749: /* 𝝉 Math */
-      case 0x1d74a: /* 𝝊 Math */
-      case 0x1d74b: /* 𝝋 Math */
-      case 0x1d74c: /* 𝝌 Math */
-      case 0x1d74d: /* 𝝍 Math */
-      case 0x1d74e: /* 𝝎 Math */
-      case 0x1d750: /* 𝝐 Math */
-      case 0x1d751: /* 𝝑 Math */
-      case 0x1d752: /* 𝝒 Math */
-      case 0x1d753: /* 𝝓 Math */
-      case 0x1d754: /* 𝝔 Math */
-      case 0x1d755: /* 𝝕 Math */
-      case 0x1d781: /* 𝞁 Math */
-      case 0x1d782: /* 𝞂 Math */
-      case 0x1d783: /* 𝞃 Math */
-      case 0x1d784: /* 𝞄 Math */
-      case 0x1d785: /* 𝞅 Math */
-      case 0x1d786: /* 𝞆 Math */
-      case 0x1d787: /* 𝞇 Math */
-      case 0x1d788: /* 𝞈 Math */
-      case 0x1d78a: /* 𝞊 Math */
-      case 0x1d78b: /* 𝞋 Math */
-      case 0x1d78c: /* 𝞌 Math */
-      case 0x1d78d: /* 𝞍 Math */
-      case 0x1d78e: /* 𝞎 Math */
-      case 0x1d78f: /* 𝞏 Math */
-      case 0x1d7aa: /* 𝞪 Math */
-      case 0x1d7ab: /* 𝞫 Math */
-      case 0x1d7ac: /* 𝞬 Math */
-      case 0x1d7ad: /* 𝞭 Math */
-      case 0x1d7ae: /* 𝞮 Math */
-      case 0x1d7af: /* 𝞯 Math */
-      case 0x1d7b0: /* 𝞰 Math */
-      case 0x1d7b1: /* 𝞱 Math */
-      case 0x1d7b2: /* 𝞲 Math */
-      case 0x1d7b3: /* 𝞳 Math */
-      case 0x1d7b4: /* 𝞴 Math */
-      case 0x1d7b5: /* 𝞵 Math */
-      case 0x1d7b6: /* 𝞶 Math */
-      case 0x1d7b7: /* 𝞷 Math */
-      case 0x1d7b8: /* 𝞸 Math */
-      case 0x1d7b9: /* 𝞹 Math */
-      case 0x1d7ba: /* 𝞺 Math */
-      case 0x1d7bb: /* 𝞻 Math */
-      case 0x1d7bc: /* 𝞼 Math */
-      case 0x1d7bd: /* 𝞽 Math */
-      case 0x1d7be: /* 𝞾 Math */
-      case 0x1d7bf: /* 𝞿 Math */
-      case 0x1d7c0: /* 𝟀 Math */
-      case 0x1d7c1: /* 𝟁 Math */
-      case 0x1d7c2: /* 𝟂 Math */
-      case 0x1d7c4: /* 𝟄 Math */
-      case 0x1d7c5: /* 𝟅 Math */
-      case 0x1d7c6: /* 𝟆 Math */
-      case 0x1d7c7: /* 𝟇 Math */
-      case 0x1d7c8: /* 𝟈 Math */
-      case 0x1d7c9: /* 𝟉 Math */
-      case 0x1d7cb: /* 𝟋 Math */
-        return 1;
-      default:
-        return 0;
-    }
-  }
-}
-
-__weak_reference(iswlower, iswlower_l);
diff --git a/libc/str/iswlower.cc b/libc/str/iswlower.cc
new file mode 100644
index 000000000..a0b5778d6
--- /dev/null
+++ b/libc/str/iswlower.cc
@@ -0,0 +1,712 @@
+/*-*-mode:c++;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8-*-│
+│ vi: set et ft=c++ ts=2 sts=2 sw=2 fenc=utf-8                             :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/dce.h"
+#include "libc/macros.h"
+#include "libc/str/has_char.h"
+#include "libc/wctype.h"
+
+static const unsigned short kLower[][2] = {
+    {0x61, 0x7a},      //
+    {0xaa, 0xaa},      //
+    {0xb5, 0xb5},      //
+    {0xba, 0xba},      //
+    {0xdf, 0xf6},      //
+    {0xf8, 0xff},      //
+    {0x101, 0x101},    //
+    {0x103, 0x103},    //
+    {0x105, 0x105},    //
+    {0x107, 0x107},    //
+    {0x109, 0x109},    //
+    {0x10b, 0x10b},    //
+    {0x10d, 0x10d},    //
+    {0x10f, 0x10f},    //
+    {0x111, 0x111},    //
+    {0x113, 0x113},    //
+    {0x115, 0x115},    //
+    {0x117, 0x117},    //
+    {0x119, 0x119},    //
+    {0x11b, 0x11b},    //
+    {0x11d, 0x11d},    //
+    {0x11f, 0x11f},    //
+    {0x121, 0x121},    //
+    {0x123, 0x123},    //
+    {0x125, 0x125},    //
+    {0x127, 0x127},    //
+    {0x129, 0x129},    //
+    {0x12b, 0x12b},    //
+    {0x12d, 0x12d},    //
+    {0x12f, 0x12f},    //
+    {0x131, 0x131},    //
+    {0x133, 0x133},    //
+    {0x135, 0x135},    //
+    {0x137, 0x138},    //
+    {0x13a, 0x13a},    //
+    {0x13c, 0x13c},    //
+    {0x13e, 0x13e},    //
+    {0x140, 0x140},    //
+    {0x142, 0x142},    //
+    {0x144, 0x144},    //
+    {0x146, 0x146},    //
+    {0x148, 0x149},    //
+    {0x14b, 0x14b},    //
+    {0x14d, 0x14d},    //
+    {0x14f, 0x14f},    //
+    {0x151, 0x151},    //
+    {0x153, 0x153},    //
+    {0x155, 0x155},    //
+    {0x157, 0x157},    //
+    {0x159, 0x159},    //
+    {0x15b, 0x15b},    //
+    {0x15d, 0x15d},    //
+    {0x15f, 0x15f},    //
+    {0x161, 0x161},    //
+    {0x163, 0x163},    //
+    {0x165, 0x165},    //
+    {0x167, 0x167},    //
+    {0x169, 0x169},    //
+    {0x16b, 0x16b},    //
+    {0x16d, 0x16d},    //
+    {0x16f, 0x16f},    //
+    {0x171, 0x171},    //
+    {0x173, 0x173},    //
+    {0x175, 0x175},    //
+    {0x177, 0x177},    //
+    {0x17a, 0x17a},    //
+    {0x17c, 0x17c},    //
+    {0x17e, 0x180},    //
+    {0x183, 0x183},    //
+    {0x185, 0x185},    //
+    {0x188, 0x188},    //
+    {0x18c, 0x18d},    //
+    {0x192, 0x192},    //
+    {0x195, 0x195},    //
+    {0x199, 0x19b},    //
+    {0x19e, 0x19e},    //
+    {0x1a1, 0x1a1},    //
+    {0x1a3, 0x1a3},    //
+    {0x1a5, 0x1a5},    //
+    {0x1a8, 0x1a8},    //
+    {0x1aa, 0x1ab},    //
+    {0x1ad, 0x1ad},    //
+    {0x1b0, 0x1b0},    //
+    {0x1b4, 0x1b4},    //
+    {0x1b6, 0x1b6},    //
+    {0x1b9, 0x1ba},    //
+    {0x1bd, 0x1bf},    //
+    {0x1c5, 0x1c6},    //
+    {0x1c8, 0x1c9},    //
+    {0x1cb, 0x1cc},    //
+    {0x1ce, 0x1ce},    //
+    {0x1d0, 0x1d0},    //
+    {0x1d2, 0x1d2},    //
+    {0x1d4, 0x1d4},    //
+    {0x1d6, 0x1d6},    //
+    {0x1d8, 0x1d8},    //
+    {0x1da, 0x1da},    //
+    {0x1dc, 0x1dd},    //
+    {0x1df, 0x1df},    //
+    {0x1e1, 0x1e1},    //
+    {0x1e3, 0x1e3},    //
+    {0x1e5, 0x1e5},    //
+    {0x1e7, 0x1e7},    //
+    {0x1e9, 0x1e9},    //
+    {0x1eb, 0x1eb},    //
+    {0x1ed, 0x1ed},    //
+    {0x1ef, 0x1f0},    //
+    {0x1f2, 0x1f3},    //
+    {0x1f5, 0x1f5},    //
+    {0x1f9, 0x1f9},    //
+    {0x1fb, 0x1fb},    //
+    {0x1fd, 0x1fd},    //
+    {0x1ff, 0x1ff},    //
+    {0x201, 0x201},    //
+    {0x203, 0x203},    //
+    {0x205, 0x205},    //
+    {0x207, 0x207},    //
+    {0x209, 0x209},    //
+    {0x20b, 0x20b},    //
+    {0x20d, 0x20d},    //
+    {0x20f, 0x20f},    //
+    {0x211, 0x211},    //
+    {0x213, 0x213},    //
+    {0x215, 0x215},    //
+    {0x217, 0x217},    //
+    {0x219, 0x219},    //
+    {0x21b, 0x21b},    //
+    {0x21d, 0x21d},    //
+    {0x21f, 0x21f},    //
+    {0x221, 0x221},    //
+    {0x223, 0x223},    //
+    {0x225, 0x225},    //
+    {0x227, 0x227},    //
+    {0x229, 0x229},    //
+    {0x22b, 0x22b},    //
+    {0x22d, 0x22d},    //
+    {0x22f, 0x22f},    //
+    {0x231, 0x231},    //
+    {0x233, 0x239},    //
+    {0x23c, 0x23c},    //
+    {0x23f, 0x240},    //
+    {0x242, 0x242},    //
+    {0x247, 0x247},    //
+    {0x249, 0x249},    //
+    {0x24b, 0x24b},    //
+    {0x24d, 0x24d},    //
+    {0x24f, 0x293},    //
+    {0x295, 0x2b8},    //
+    {0x2c0, 0x2c1},    //
+    {0x2e0, 0x2e4},    //
+    {0x345, 0x345},    //
+    {0x371, 0x371},    //
+    {0x373, 0x373},    //
+    {0x377, 0x377},    //
+    {0x37a, 0x37d},    //
+    {0x390, 0x390},    //
+    {0x3ac, 0x3ce},    //
+    {0x3d0, 0x3d1},    //
+    {0x3d5, 0x3d7},    //
+    {0x3d9, 0x3d9},    //
+    {0x3db, 0x3db},    //
+    {0x3dd, 0x3dd},    //
+    {0x3df, 0x3df},    //
+    {0x3e1, 0x3e1},    //
+    {0x3e3, 0x3e3},    //
+    {0x3e5, 0x3e5},    //
+    {0x3e7, 0x3e7},    //
+    {0x3e9, 0x3e9},    //
+    {0x3eb, 0x3eb},    //
+    {0x3ed, 0x3ed},    //
+    {0x3ef, 0x3f3},    //
+    {0x3f5, 0x3f5},    //
+    {0x3f8, 0x3f8},    //
+    {0x3fb, 0x3fc},    //
+    {0x430, 0x45f},    //
+    {0x461, 0x461},    //
+    {0x463, 0x463},    //
+    {0x465, 0x465},    //
+    {0x467, 0x467},    //
+    {0x469, 0x469},    //
+    {0x46b, 0x46b},    //
+    {0x46d, 0x46d},    //
+    {0x46f, 0x46f},    //
+    {0x471, 0x471},    //
+    {0x473, 0x473},    //
+    {0x475, 0x475},    //
+    {0x477, 0x477},    //
+    {0x479, 0x479},    //
+    {0x47b, 0x47b},    //
+    {0x47d, 0x47d},    //
+    {0x47f, 0x47f},    //
+    {0x481, 0x481},    //
+    {0x48b, 0x48b},    //
+    {0x48d, 0x48d},    //
+    {0x48f, 0x48f},    //
+    {0x491, 0x491},    //
+    {0x493, 0x493},    //
+    {0x495, 0x495},    //
+    {0x497, 0x497},    //
+    {0x499, 0x499},    //
+    {0x49b, 0x49b},    //
+    {0x49d, 0x49d},    //
+    {0x49f, 0x49f},    //
+    {0x4a1, 0x4a1},    //
+    {0x4a3, 0x4a3},    //
+    {0x4a5, 0x4a5},    //
+    {0x4a7, 0x4a7},    //
+    {0x4a9, 0x4a9},    //
+    {0x4ab, 0x4ab},    //
+    {0x4ad, 0x4ad},    //
+    {0x4af, 0x4af},    //
+    {0x4b1, 0x4b1},    //
+    {0x4b3, 0x4b3},    //
+    {0x4b5, 0x4b5},    //
+    {0x4b7, 0x4b7},    //
+    {0x4b9, 0x4b9},    //
+    {0x4bb, 0x4bb},    //
+    {0x4bd, 0x4bd},    //
+    {0x4bf, 0x4bf},    //
+    {0x4c2, 0x4c2},    //
+    {0x4c4, 0x4c4},    //
+    {0x4c6, 0x4c6},    //
+    {0x4c8, 0x4c8},    //
+    {0x4ca, 0x4ca},    //
+    {0x4cc, 0x4cc},    //
+    {0x4ce, 0x4cf},    //
+    {0x4d1, 0x4d1},    //
+    {0x4d3, 0x4d3},    //
+    {0x4d5, 0x4d5},    //
+    {0x4d7, 0x4d7},    //
+    {0x4d9, 0x4d9},    //
+    {0x4db, 0x4db},    //
+    {0x4dd, 0x4dd},    //
+    {0x4df, 0x4df},    //
+    {0x4e1, 0x4e1},    //
+    {0x4e3, 0x4e3},    //
+    {0x4e5, 0x4e5},    //
+    {0x4e7, 0x4e7},    //
+    {0x4e9, 0x4e9},    //
+    {0x4eb, 0x4eb},    //
+    {0x4ed, 0x4ed},    //
+    {0x4ef, 0x4ef},    //
+    {0x4f1, 0x4f1},    //
+    {0x4f3, 0x4f3},    //
+    {0x4f5, 0x4f5},    //
+    {0x4f7, 0x4f7},    //
+    {0x4f9, 0x4f9},    //
+    {0x4fb, 0x4fb},    //
+    {0x4fd, 0x4fd},    //
+    {0x4ff, 0x4ff},    //
+    {0x501, 0x501},    //
+    {0x503, 0x503},    //
+    {0x505, 0x505},    //
+    {0x507, 0x507},    //
+    {0x509, 0x509},    //
+    {0x50b, 0x50b},    //
+    {0x50d, 0x50d},    //
+    {0x50f, 0x50f},    //
+    {0x511, 0x511},    //
+    {0x513, 0x513},    //
+    {0x515, 0x515},    //
+    {0x517, 0x517},    //
+    {0x519, 0x519},    //
+    {0x51b, 0x51b},    //
+    {0x51d, 0x51d},    //
+    {0x51f, 0x51f},    //
+    {0x521, 0x521},    //
+    {0x523, 0x523},    //
+    {0x525, 0x525},    //
+    {0x527, 0x527},    //
+    {0x529, 0x529},    //
+    {0x52b, 0x52b},    //
+    {0x52d, 0x52d},    //
+    {0x52f, 0x52f},    //
+    {0x560, 0x588},    //
+    {0x10d0, 0x10fa},  //
+    {0x10fc, 0x10ff},  //
+    {0x13f8, 0x13fd},  //
+    {0x1c80, 0x1c88},  //
+    {0x1d00, 0x1dbf},  //
+    {0x1e01, 0x1e01},  //
+    {0x1e03, 0x1e03},  //
+    {0x1e05, 0x1e05},  //
+    {0x1e07, 0x1e07},  //
+    {0x1e09, 0x1e09},  //
+    {0x1e0b, 0x1e0b},  //
+    {0x1e0d, 0x1e0d},  //
+    {0x1e0f, 0x1e0f},  //
+    {0x1e11, 0x1e11},  //
+    {0x1e13, 0x1e13},  //
+    {0x1e15, 0x1e15},  //
+    {0x1e17, 0x1e17},  //
+    {0x1e19, 0x1e19},  //
+    {0x1e1b, 0x1e1b},  //
+    {0x1e1d, 0x1e1d},  //
+    {0x1e1f, 0x1e1f},  //
+    {0x1e21, 0x1e21},  //
+    {0x1e23, 0x1e23},  //
+    {0x1e25, 0x1e25},  //
+    {0x1e27, 0x1e27},  //
+    {0x1e29, 0x1e29},  //
+    {0x1e2b, 0x1e2b},  //
+    {0x1e2d, 0x1e2d},  //
+    {0x1e2f, 0x1e2f},  //
+    {0x1e31, 0x1e31},  //
+    {0x1e33, 0x1e33},  //
+    {0x1e35, 0x1e35},  //
+    {0x1e37, 0x1e37},  //
+    {0x1e39, 0x1e39},  //
+    {0x1e3b, 0x1e3b},  //
+    {0x1e3d, 0x1e3d},  //
+    {0x1e3f, 0x1e3f},  //
+    {0x1e41, 0x1e41},  //
+    {0x1e43, 0x1e43},  //
+    {0x1e45, 0x1e45},  //
+    {0x1e47, 0x1e47},  //
+    {0x1e49, 0x1e49},  //
+    {0x1e4b, 0x1e4b},  //
+    {0x1e4d, 0x1e4d},  //
+    {0x1e4f, 0x1e4f},  //
+    {0x1e51, 0x1e51},  //
+    {0x1e53, 0x1e53},  //
+    {0x1e55, 0x1e55},  //
+    {0x1e57, 0x1e57},  //
+    {0x1e59, 0x1e59},  //
+    {0x1e5b, 0x1e5b},  //
+    {0x1e5d, 0x1e5d},  //
+    {0x1e5f, 0x1e5f},  //
+    {0x1e61, 0x1e61},  //
+    {0x1e63, 0x1e63},  //
+    {0x1e65, 0x1e65},  //
+    {0x1e67, 0x1e67},  //
+    {0x1e69, 0x1e69},  //
+    {0x1e6b, 0x1e6b},  //
+    {0x1e6d, 0x1e6d},  //
+    {0x1e6f, 0x1e6f},  //
+    {0x1e71, 0x1e71},  //
+    {0x1e73, 0x1e73},  //
+    {0x1e75, 0x1e75},  //
+    {0x1e77, 0x1e77},  //
+    {0x1e79, 0x1e79},  //
+    {0x1e7b, 0x1e7b},  //
+    {0x1e7d, 0x1e7d},  //
+    {0x1e7f, 0x1e7f},  //
+    {0x1e81, 0x1e81},  //
+    {0x1e83, 0x1e83},  //
+    {0x1e85, 0x1e85},  //
+    {0x1e87, 0x1e87},  //
+    {0x1e89, 0x1e89},  //
+    {0x1e8b, 0x1e8b},  //
+    {0x1e8d, 0x1e8d},  //
+    {0x1e8f, 0x1e8f},  //
+    {0x1e91, 0x1e91},  //
+    {0x1e93, 0x1e93},  //
+    {0x1e95, 0x1e9d},  //
+    {0x1e9f, 0x1e9f},  //
+    {0x1ea1, 0x1ea1},  //
+    {0x1ea3, 0x1ea3},  //
+    {0x1ea5, 0x1ea5},  //
+    {0x1ea7, 0x1ea7},  //
+    {0x1ea9, 0x1ea9},  //
+    {0x1eab, 0x1eab},  //
+    {0x1ead, 0x1ead},  //
+    {0x1eaf, 0x1eaf},  //
+    {0x1eb1, 0x1eb1},  //
+    {0x1eb3, 0x1eb3},  //
+    {0x1eb5, 0x1eb5},  //
+    {0x1eb7, 0x1eb7},  //
+    {0x1eb9, 0x1eb9},  //
+    {0x1ebb, 0x1ebb},  //
+    {0x1ebd, 0x1ebd},  //
+    {0x1ebf, 0x1ebf},  //
+    {0x1ec1, 0x1ec1},  //
+    {0x1ec3, 0x1ec3},  //
+    {0x1ec5, 0x1ec5},  //
+    {0x1ec7, 0x1ec7},  //
+    {0x1ec9, 0x1ec9},  //
+    {0x1ecb, 0x1ecb},  //
+    {0x1ecd, 0x1ecd},  //
+    {0x1ecf, 0x1ecf},  //
+    {0x1ed1, 0x1ed1},  //
+    {0x1ed3, 0x1ed3},  //
+    {0x1ed5, 0x1ed5},  //
+    {0x1ed7, 0x1ed7},  //
+    {0x1ed9, 0x1ed9},  //
+    {0x1edb, 0x1edb},  //
+    {0x1edd, 0x1edd},  //
+    {0x1edf, 0x1edf},  //
+    {0x1ee1, 0x1ee1},  //
+    {0x1ee3, 0x1ee3},  //
+    {0x1ee5, 0x1ee5},  //
+    {0x1ee7, 0x1ee7},  //
+    {0x1ee9, 0x1ee9},  //
+    {0x1eeb, 0x1eeb},  //
+    {0x1eed, 0x1eed},  //
+    {0x1eef, 0x1eef},  //
+    {0x1ef1, 0x1ef1},  //
+    {0x1ef3, 0x1ef3},  //
+    {0x1ef5, 0x1ef5},  //
+    {0x1ef7, 0x1ef7},  //
+    {0x1ef9, 0x1ef9},  //
+    {0x1efb, 0x1efb},  //
+    {0x1efd, 0x1efd},  //
+    {0x1eff, 0x1f07},  //
+    {0x1f10, 0x1f15},  //
+    {0x1f20, 0x1f27},  //
+    {0x1f30, 0x1f37},  //
+    {0x1f40, 0x1f45},  //
+    {0x1f50, 0x1f57},  //
+    {0x1f60, 0x1f67},  //
+    {0x1f70, 0x1f7d},  //
+    {0x1f80, 0x1f87},  //
+    {0x1f90, 0x1f97},  //
+    {0x1fa0, 0x1fa7},  //
+    {0x1fb0, 0x1fb4},  //
+    {0x1fb6, 0x1fb7},  //
+    {0x1fbe, 0x1fbe},  //
+    {0x1fc2, 0x1fc4},  //
+    {0x1fc6, 0x1fc7},  //
+    {0x1fd0, 0x1fd3},  //
+    {0x1fd6, 0x1fd7},  //
+    {0x1fe0, 0x1fe7},  //
+    {0x1ff2, 0x1ff4},  //
+    {0x1ff6, 0x1ff7},  //
+    {0x2071, 0x2071},  //
+    {0x207f, 0x207f},  //
+    {0x2090, 0x209c},  //
+    {0x210a, 0x210a},  //
+    {0x210e, 0x210f},  //
+    {0x2113, 0x2113},  //
+    {0x212f, 0x212f},  //
+    {0x2134, 0x2134},  //
+    {0x2139, 0x2139},  //
+    {0x213c, 0x213d},  //
+    {0x2146, 0x2149},  //
+    {0x214e, 0x214e},  //
+    {0x2170, 0x217f},  //
+    {0x2184, 0x2184},  //
+    {0x24d0, 0x24e9},  //
+    {0x2c30, 0x2c5f},  //
+    {0x2c61, 0x2c61},  //
+    {0x2c65, 0x2c66},  //
+    {0x2c68, 0x2c68},  //
+    {0x2c6a, 0x2c6a},  //
+    {0x2c6c, 0x2c6c},  //
+    {0x2c71, 0x2c71},  //
+    {0x2c73, 0x2c74},  //
+    {0x2c76, 0x2c7d},  //
+    {0x2c81, 0x2c81},  //
+    {0x2c83, 0x2c83},  //
+    {0x2c85, 0x2c85},  //
+    {0x2c87, 0x2c87},  //
+    {0x2c89, 0x2c89},  //
+    {0x2c8b, 0x2c8b},  //
+    {0x2c8d, 0x2c8d},  //
+    {0x2c8f, 0x2c8f},  //
+    {0x2c91, 0x2c91},  //
+    {0x2c93, 0x2c93},  //
+    {0x2c95, 0x2c95},  //
+    {0x2c97, 0x2c97},  //
+    {0x2c99, 0x2c99},  //
+    {0x2c9b, 0x2c9b},  //
+    {0x2c9d, 0x2c9d},  //
+    {0x2c9f, 0x2c9f},  //
+    {0x2ca1, 0x2ca1},  //
+    {0x2ca3, 0x2ca3},  //
+    {0x2ca5, 0x2ca5},  //
+    {0x2ca7, 0x2ca7},  //
+    {0x2ca9, 0x2ca9},  //
+    {0x2cab, 0x2cab},  //
+    {0x2cad, 0x2cad},  //
+    {0x2caf, 0x2caf},  //
+    {0x2cb1, 0x2cb1},  //
+    {0x2cb3, 0x2cb3},  //
+    {0x2cb5, 0x2cb5},  //
+    {0x2cb7, 0x2cb7},  //
+    {0x2cb9, 0x2cb9},  //
+    {0x2cbb, 0x2cbb},  //
+    {0x2cbd, 0x2cbd},  //
+    {0x2cbf, 0x2cbf},  //
+    {0x2cc1, 0x2cc1},  //
+    {0x2cc3, 0x2cc3},  //
+    {0x2cc5, 0x2cc5},  //
+    {0x2cc7, 0x2cc7},  //
+    {0x2cc9, 0x2cc9},  //
+    {0x2ccb, 0x2ccb},  //
+    {0x2ccd, 0x2ccd},  //
+    {0x2ccf, 0x2ccf},  //
+    {0x2cd1, 0x2cd1},  //
+    {0x2cd3, 0x2cd3},  //
+    {0x2cd5, 0x2cd5},  //
+    {0x2cd7, 0x2cd7},  //
+    {0x2cd9, 0x2cd9},  //
+    {0x2cdb, 0x2cdb},  //
+    {0x2cdd, 0x2cdd},  //
+    {0x2cdf, 0x2cdf},  //
+    {0x2ce1, 0x2ce1},  //
+    {0x2ce3, 0x2ce4},  //
+    {0x2cec, 0x2cec},  //
+    {0x2cee, 0x2cee},  //
+    {0x2cf3, 0x2cf3},  //
+    {0x2d00, 0x2d25},  //
+    {0x2d27, 0x2d27},  //
+    {0x2d2d, 0x2d2d},  //
+    {0xa641, 0xa641},  //
+    {0xa643, 0xa643},  //
+    {0xa645, 0xa645},  //
+    {0xa647, 0xa647},  //
+    {0xa649, 0xa649},  //
+    {0xa64b, 0xa64b},  //
+    {0xa64d, 0xa64d},  //
+    {0xa64f, 0xa64f},  //
+    {0xa651, 0xa651},  //
+    {0xa653, 0xa653},  //
+    {0xa655, 0xa655},  //
+    {0xa657, 0xa657},  //
+    {0xa659, 0xa659},  //
+    {0xa65b, 0xa65b},  //
+    {0xa65d, 0xa65d},  //
+    {0xa65f, 0xa65f},  //
+    {0xa661, 0xa661},  //
+    {0xa663, 0xa663},  //
+    {0xa665, 0xa665},  //
+    {0xa667, 0xa667},  //
+    {0xa669, 0xa669},  //
+    {0xa66b, 0xa66b},  //
+    {0xa66d, 0xa66d},  //
+    {0xa681, 0xa681},  //
+    {0xa683, 0xa683},  //
+    {0xa685, 0xa685},  //
+    {0xa687, 0xa687},  //
+    {0xa689, 0xa689},  //
+    {0xa68b, 0xa68b},  //
+    {0xa68d, 0xa68d},  //
+    {0xa68f, 0xa68f},  //
+    {0xa691, 0xa691},  //
+    {0xa693, 0xa693},  //
+    {0xa695, 0xa695},  //
+    {0xa697, 0xa697},  //
+    {0xa699, 0xa699},  //
+    {0xa69b, 0xa69d},  //
+    {0xa723, 0xa723},  //
+    {0xa725, 0xa725},  //
+    {0xa727, 0xa727},  //
+    {0xa729, 0xa729},  //
+    {0xa72b, 0xa72b},  //
+    {0xa72d, 0xa72d},  //
+    {0xa72f, 0xa731},  //
+    {0xa733, 0xa733},  //
+    {0xa735, 0xa735},  //
+    {0xa737, 0xa737},  //
+    {0xa739, 0xa739},  //
+    {0xa73b, 0xa73b},  //
+    {0xa73d, 0xa73d},  //
+    {0xa73f, 0xa73f},  //
+    {0xa741, 0xa741},  //
+    {0xa743, 0xa743},  //
+    {0xa745, 0xa745},  //
+    {0xa747, 0xa747},  //
+    {0xa749, 0xa749},  //
+    {0xa74b, 0xa74b},  //
+    {0xa74d, 0xa74d},  //
+    {0xa74f, 0xa74f},  //
+    {0xa751, 0xa751},  //
+    {0xa753, 0xa753},  //
+    {0xa755, 0xa755},  //
+    {0xa757, 0xa757},  //
+    {0xa759, 0xa759},  //
+    {0xa75b, 0xa75b},  //
+    {0xa75d, 0xa75d},  //
+    {0xa75f, 0xa75f},  //
+    {0xa761, 0xa761},  //
+    {0xa763, 0xa763},  //
+    {0xa765, 0xa765},  //
+    {0xa767, 0xa767},  //
+    {0xa769, 0xa769},  //
+    {0xa76b, 0xa76b},  //
+    {0xa76d, 0xa76d},  //
+    {0xa76f, 0xa778},  //
+    {0xa77a, 0xa77a},  //
+    {0xa77c, 0xa77c},  //
+    {0xa77f, 0xa77f},  //
+    {0xa781, 0xa781},  //
+    {0xa783, 0xa783},  //
+    {0xa785, 0xa785},  //
+    {0xa787, 0xa787},  //
+    {0xa78c, 0xa78c},  //
+    {0xa78e, 0xa78e},  //
+    {0xa791, 0xa791},  //
+    {0xa793, 0xa795},  //
+    {0xa797, 0xa797},  //
+    {0xa799, 0xa799},  //
+    {0xa79b, 0xa79b},  //
+    {0xa79d, 0xa79d},  //
+    {0xa79f, 0xa79f},  //
+    {0xa7a1, 0xa7a1},  //
+    {0xa7a3, 0xa7a3},  //
+    {0xa7a5, 0xa7a5},  //
+    {0xa7a7, 0xa7a7},  //
+    {0xa7a9, 0xa7a9},  //
+    {0xa7af, 0xa7af},  //
+    {0xa7b5, 0xa7b5},  //
+    {0xa7b7, 0xa7b7},  //
+    {0xa7b9, 0xa7b9},  //
+    {0xa7bb, 0xa7bb},  //
+    {0xa7bd, 0xa7bd},  //
+    {0xa7bf, 0xa7bf},  //
+    {0xa7c1, 0xa7c1},  //
+    {0xa7c3, 0xa7c3},  //
+    {0xa7c8, 0xa7c8},  //
+    {0xa7ca, 0xa7ca},  //
+    {0xa7d1, 0xa7d1},  //
+    {0xa7d3, 0xa7d3},  //
+    {0xa7d5, 0xa7d5},  //
+    {0xa7d7, 0xa7d7},  //
+    {0xa7d9, 0xa7d9},  //
+    {0xa7f2, 0xa7f4},  //
+    {0xa7f6, 0xa7f6},  //
+    {0xa7f8, 0xa7fa},  //
+    {0xab30, 0xab5a},  //
+    {0xab5c, 0xab69},  //
+    {0xab70, 0xabbf},  //
+    {0xfb00, 0xfb06},  //
+    {0xfb13, 0xfb17},  //
+    {0xff41, 0xff5a},  //
+};
+
+static const unsigned kLowerAstral[][2] = {
+    {0x10428, 0x1044f},  //
+    {0x104d8, 0x104fb},  //
+    {0x10597, 0x105a1},  //
+    {0x105a3, 0x105b1},  //
+    {0x105b3, 0x105b9},  //
+    {0x105bb, 0x105bc},  //
+    {0x10780, 0x10780},  //
+    {0x10783, 0x10785},  //
+    {0x10787, 0x107b0},  //
+    {0x107b2, 0x107ba},  //
+    {0x10cc0, 0x10cf2},  //
+    {0x118c0, 0x118df},  //
+    {0x16e60, 0x16e7f},  //
+    {0x1d41a, 0x1d433},  //
+    {0x1d44e, 0x1d454},  //
+    {0x1d456, 0x1d467},  //
+    {0x1d482, 0x1d49b},  //
+    {0x1d4b6, 0x1d4b9},  //
+    {0x1d4bb, 0x1d4bb},  //
+    {0x1d4bd, 0x1d4c3},  //
+    {0x1d4c5, 0x1d4cf},  //
+    {0x1d4ea, 0x1d503},  //
+    {0x1d51e, 0x1d537},  //
+    {0x1d552, 0x1d56b},  //
+    {0x1d586, 0x1d59f},  //
+    {0x1d5ba, 0x1d5d3},  //
+    {0x1d5ee, 0x1d607},  //
+    {0x1d622, 0x1d63b},  //
+    {0x1d656, 0x1d66f},  //
+    {0x1d68a, 0x1d6a5},  //
+    {0x1d6c2, 0x1d6da},  //
+    {0x1d6dc, 0x1d6e1},  //
+    {0x1d6fc, 0x1d714},  //
+    {0x1d716, 0x1d71b},  //
+    {0x1d736, 0x1d74e},  //
+    {0x1d750, 0x1d755},  //
+    {0x1d770, 0x1d788},  //
+    {0x1d78a, 0x1d78f},  //
+    {0x1d7aa, 0x1d7c2},  //
+    {0x1d7c4, 0x1d7c9},  //
+    {0x1d7cb, 0x1d7cb},  //
+    {0x1df00, 0x1df09},  //
+    {0x1df0b, 0x1df1e},  //
+    {0x1df25, 0x1df2a},  //
+    {0x1e030, 0x1e06d},  //
+    {0x1e922, 0x1e943},  //
+};
+
+/**
+ * Returns nonzero if c is lowercase letter.
+ */
+int iswlower(wint_t c) {
+  if (!IsTiny() && c < 128)
+    return 'a' <= c && c <= 'z';
+  if (c < 65536)
+    return has_char(kLower, ARRAYLEN(kLower), (unsigned short)c);
+  return has_char(kLowerAstral, ARRAYLEN(kLowerAstral), (unsigned)c);
+}
+
+__weak_reference(iswlower, iswlower_l);
diff --git a/libc/str/iswprint.c b/libc/str/iswprint.c
index 95e2e6cf1..9a4875c3e 100644
--- a/libc/str/iswprint.c
+++ b/libc/str/iswprint.c
@@ -16,14 +16,17 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Returns nonzero if c is printable.
  */
 int iswprint(wint_t c) {
-  return !((0x00 <= c && c <= 0x1F) || (0x7F <= c && c <= 0x9F) ||
-           (0xFFF9 <= c && c <= 0xFFFB) || c == 0x2028 || c == 0x2029);
+  return (0 <= c && c <= 0x10FFFD) &&      // legal unicode
+         !(0x0000 <= c && c <= 0x001F) &&  // c0 control codes
+         !(0x007F <= c && c <= 0x009F) &&  // c1 control codes
+         !(0x2028 <= c && c <= 0x2029) &&  // line / paragraph separator
+         !(0xFFF9 <= c && c <= 0xFFFB);    // interlinear annotation controls
 }
 
 __weak_reference(iswprint, iswprint_l);
diff --git a/libc/str/iswpunct.c b/libc/str/iswpunct.c
deleted file mode 100644
index 96c16f34b..000000000
--- a/libc/str/iswpunct.c
+++ /dev/null
@@ -1,543 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-/**
- * Returns nonzero if c is punctuation mark.
- */
-int iswpunct(wint_t c) {
-  if (c < 0xa0) {
-    switch (c) {
-      case '!':
-      case '"':
-      case '#':
-      case '$':
-      case '%':
-      case '&':
-      case '\'':
-      case '(':
-      case ')':
-      case '*':
-      case '+':
-      case ',':
-      case '-':
-      case '.':
-      case '/':
-      case ':':
-      case ';':
-      case '<':
-      case '=':
-      case '>':
-      case '?':
-      case '@':
-      case '[':
-      case '\\':
-      case ']':
-      case '^':
-      case '_':
-      case '`':
-      case '{':
-      case '|':
-      case '}':
-      case '~':
-        return 1;
-      default:
-        return 0;
-    }
-  }
-  switch (c) {
-    case u'¡':    // INVERTED EXCLAMATION MARK (0x00a1 Po)
-    case u'§':    // SECTION SIGN (0x00a7 Po)
-    case u'«':    // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK (0x00ab Pi)
-    case u'¶':    // PILCROW SIGN (0x00b6 Po)
-    case u'·':    // MIDDLE DOT (0x00b7 Po)
-    case u'»':    // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK (0x00bb Pf)
-    case u'¿':    // INVERTED QUESTION MARK (0x00bf Po)
-    case u';':    // GREEK QUESTION MARK (0x037e Po)
-    case u'·':    // GREEK ANO TELEIA (0x0387 Po)
-    case u'՚':    // ARMENIAN APOSTROPHE (0x055a Po)
-    case u'՛':    // ARMENIAN EMPHASIS MARK (0x055b Po)
-    case u'՜':    // ARMENIAN EXCLAMATION MARK (0x055c Po)
-    case u'՝':    // ARMENIAN COMMA (0x055d Po)
-    case u'՞':    // ARMENIAN QUESTION MARK (0x055e Po)
-    case u'՟':    // ARMENIAN ABBREVIATION MARK (0x055f Po)
-    case u'։':    // ARMENIAN FULL STOP (0x0589 Po)
-    case u'֊':    // ARMENIAN HYPHEN (0x058a Pd)
-    case 0x05be:  // HEBREW PUNCTUATION MAQAF (0x05be Pd)
-    case 0x05c0:  // HEBREW PUNCTUATION PASEQ (0x05c0 Po)
-    case 0x05c3:  // HEBREW PUNCTUATION SOF PASUQ (0x05c3 Po)
-    case 0x05c6:  // HEBREW PUNCTUATION NUN HAFUKHA (0x05c6 Po)
-    case 0x05f3:  // HEBREW PUNCTUATION GERESH (0x05f3 Po)
-    case 0x05f4:  // HEBREW PUNCTUATION GERSHAYIM (0x05f4 Po)
-    case 0x0609:  // ARABIC-INDIC PER MILLE SIGN (0x0609 Po)
-    case 0x060a:  // ARABIC-INDIC PER TEN THOUSAND SIGN (0x060a Po)
-    case 0x060c:  // ARABIC COMMA (0x060c Po)
-    case 0x060d:  // ARABIC DATE SEPARATOR (0x060d Po)
-    case 0x061b:  // ARABIC SEMICOLON (0x061b Po)
-    case u'؞':    // ARABIC TRIPLE DOT PUNCTUATION MARK (0x061e Po)
-    case u'؟':    // ARABIC QUESTION MARK (0x061f Po)
-    case u'٪':    // ARABIC PERCENT SIGN (0x066a Po)
-    case u'٫':    // ARABIC DECIMAL SEPARATOR (0x066b Po)
-    case u'٬':    // ARABIC THOUSANDS SEPARATOR (0x066c Po)
-    case u'٭':    // ARABIC FIVE POINTED STAR (0x066d Po)
-    case u'۔':    // ARABIC FULL STOP (0x06d4 Po)
-    case u'߷':    // NKO SYMBOL GBAKURUNEN (0x07f7 Po)
-    case u'߸':    // NKO COMMA (0x07f8 Po)
-    case u'߹':    // NKO EXCLAMATION MARK (0x07f9 Po)
-    case u'।':    // DEVANAGARI DANDA (0x0964 Po)
-    case u'॥':    // DEVANAGARI DOUBLE DANDA (0x0965 Po)
-    case u'॰':    // DEVANAGARI ABBREVIATION SIGN (0x0970 Po)
-    case 0x09fd:  // BENGALI ABBREVIATION SIGN (0x09fd Po)
-    case 0x0a76:  // GURMUKHI ABBREVIATION SIGN (0x0a76 Po)
-    case 0x0af0:  // GUJARATI ABBREVIATION SIGN (0x0af0 Po)
-    case 0x0c77:  // TELUGU SIGN SIDDHAM (0x0c77 Po)
-    case 0x0c84:  // KANNADA SIGN SIDDHAM (0x0c84 Po)
-    case u'෴':    // SINHALA PUNCTUATION KUNDDALIYA (0x0df4 Po)
-    case u'๏':    // THAI CHARACTER FONGMAN (0x0e4f Po)
-    case u'๚':    // THAI CHARACTER ANGKHANKHU (0x0e5a Po)
-    case u'๛':    // THAI CHARACTER KHOMUT (0x0e5b Po)
-    case u'༄':    // TIBETAN MARK INITIAL YIG MGO MDUN MA (0x0f04 Po)
-    case u'༅':    // TIBETAN MARK CLOSING YIG MGO SGAB MA (0x0f05 Po)
-    case u'༆':    // TIBETAN MARK CARET YIG MGO PHUR SHAD MA (0x0f06 Po)
-    case u'༇':    // TIBETAN MARK YIG MGO TSHEG SHAD MA (0x0f07 Po)
-    case u'༈':    // TIBETAN MARK SBRUL SHAD (0x0f08 Po)
-    case u'༉':    // TIBETAN MARK BSKUR YIG MGO (0x0f09 Po)
-    case u'༊':    // TIBETAN MARK BKA- SHOG YIG MGO (0x0f0a Po)
-    case u'་':    // TIBETAN MARK INTERSYLLABIC TSHEG (0x0f0b Po)
-    case u'༌':    // TIBETAN MARK DELIMITER TSHEG BSTAR (0x0f0c Po)
-    case u'།':    // TIBETAN MARK SHAD (0x0f0d Po)
-    case u'༎':    // TIBETAN MARK NYIS SHAD (0x0f0e Po)
-    case u'༏':    // TIBETAN MARK TSHEG SHAD (0x0f0f Po)
-    case u'༐':    // TIBETAN MARK NYIS TSHEG SHAD (0x0f10 Po)
-    case u'༑':    // TIBETAN MARK RIN CHEN SPUNGS SHAD (0x0f11 Po)
-    case u'༒':    // TIBETAN MARK RGYA GRAM SHAD (0x0f12 Po)
-    case u'༔':    // TIBETAN MARK GTER TSHEG (0x0f14 Po)
-    case u'༺':    // TIBETAN MARK GUG RTAGS GYON (0x0f3a Ps)
-    case u'༻':    // TIBETAN MARK GUG RTAGS GYAS (0x0f3b Pe)
-    case u'༼':    // TIBETAN MARK ANG KHANG GYON (0x0f3c Ps)
-    case u'༽':    // TIBETAN MARK ANG KHANG GYAS (0x0f3d Pe)
-    case u'྅':    // TIBETAN MARK PALUTA (0x0f85 Po)
-    case u'࿐':    // TIBETAN MARK BSKA- SHOG GI MGO RGYAN (0x0fd0 Po)
-    case u'࿑':    // TIBETAN MARK MNYAM YIG GI MGO RGYAN (0x0fd1 Po)
-    case u'࿒':    // TIBETAN MARK NYIS TSHEG (0x0fd2 Po)
-    case u'࿓':   // TIBETAN MARK INITIAL BRDA RNYING YIG MGO MDUN MA (0x0fd3 Po)
-    case u'࿔':   // TIBETAN MARK CLOSING BRDA RNYING YIG MGO SGAB MA (0x0fd4 Po)
-    case u'࿙':   // TIBETAN MARK LEADING MCHAN RTAGS (0x0fd9 Po)
-    case u'࿚':   // TIBETAN MARK TRAILING MCHAN RTAGS (0x0fda Po)
-    case u'၊':   // MYANMAR SIGN LITTLE SECTION (0x104a Po)
-    case u'။':   // MYANMAR SIGN SECTION (0x104b Po)
-    case u'၌':   // MYANMAR SYMBOL LOCATIVE (0x104c Po)
-    case u'၍':   // MYANMAR SYMBOL COMPLETED (0x104d Po)
-    case u'၎':   // MYANMAR SYMBOL AFOREMENTIONED (0x104e Po)
-    case u'၏':   // MYANMAR SYMBOL GENITIVE (0x104f Po)
-    case u'჻':   // GEORGIAN PARAGRAPH SEPARATOR (0x10fb Po)
-    case u'፠':   // ETHIOPIC SECTION MARK (0x1360 Po)
-    case u'፡':   // ETHIOPIC WORDSPACE (0x1361 Po)
-    case u'።':   // ETHIOPIC FULL STOP (0x1362 Po)
-    case u'፣':   // ETHIOPIC COMMA (0x1363 Po)
-    case u'፤':   // ETHIOPIC SEMICOLON (0x1364 Po)
-    case u'፥':   // ETHIOPIC COLON (0x1365 Po)
-    case u'፦':   // ETHIOPIC PREFACE COLON (0x1366 Po)
-    case u'፧':   // ETHIOPIC QUESTION MARK (0x1367 Po)
-    case u'፨':   // ETHIOPIC PARAGRAPH SEPARATOR (0x1368 Po)
-    case u'᐀':   // CANADIAN SYLLABICS HYPHEN (0x1400 Pd)
-    case u'᙮':   // CANADIAN SYLLABICS FULL STOP (0x166e Po)
-    case u'᚛':   // OGHAM FEATHER MARK (0x169b Ps)
-    case u'᚜':   // OGHAM REVERSED FEATHER MARK (0x169c Pe)
-    case u'᛫':   // RUNIC SINGLE PUNCTUATION (0x16eb Po)
-    case u'᛬':   // RUNIC MULTIPLE PUNCTUATION (0x16ec Po)
-    case u'᛭':   // RUNIC CROSS PUNCTUATION (0x16ed Po)
-    case u'᜵':   // PHILIPPINE SINGLE PUNCTUATION (0x1735 Po)
-    case u'᜶':   // PHILIPPINE DOUBLE PUNCTUATION (0x1736 Po)
-    case u'។':   // KHMER SIGN KHAN (0x17d4 Po)
-    case u'៕':   // KHMER SIGN BARIYOOSAN (0x17d5 Po)
-    case u'៖':   // KHMER SIGN CAMNUC PII KUUH (0x17d6 Po)
-    case u'៘':   // KHMER SIGN BEYYAL (0x17d8 Po)
-    case u'៙':   // KHMER SIGN PHNAEK MUAN (0x17d9 Po)
-    case u'៚':   // KHMER SIGN KOOMUUT (0x17da Po)
-    case u'᠀':   // MONGOLIAN BIRGA (0x1800 Po)
-    case u'᠁':   // MONGOLIAN ELLIPSIS (0x1801 Po)
-    case u'᠂':   // MONGOLIAN COMMA (0x1802 Po)
-    case u'᠃':   // MONGOLIAN FULL STOP (0x1803 Po)
-    case u'᠄':   // MONGOLIAN COLON (0x1804 Po)
-    case u'᠅':   // MONGOLIAN FOUR DOTS (0x1805 Po)
-    case u'᠆':   // MONGOLIAN TODO SOFT HYPHEN (0x1806 Pd)
-    case u'᠇':   // MONGOLIAN SIBE SYLLABLE BOUNDARY MARKER (0x1807 Po)
-    case u'᠈':   // MONGOLIAN MANCHU COMMA (0x1808 Po)
-    case u'᠉':   // MONGOLIAN MANCHU FULL STOP (0x1809 Po)
-    case u'᠊':   // MONGOLIAN NIRUGU (0x180a Po)
-    case u'᥄':   // LIMBU EXCLAMATION MARK (0x1944 Po)
-    case u'᥅':   // LIMBU QUESTION MARK (0x1945 Po)
-    case u'᨞':   // BUGINESE PALLAWA (0x1a1e Po)
-    case u'᨟':   // BUGINESE END OF SECTION (0x1a1f Po)
-    case u'᱾':   // OL CHIKI PUNCTUATION MUCAAD (0x1c7e Po)
-    case u'᱿':   // OL CHIKI PUNCTUATION DOUBLE MUCAAD (0x1c7f Po)
-    case u'‐':   // HYPHEN (0x2010 Pd)
-    case u'‑':   // NON-BREAKING HYPHEN (0x2011 Pd)
-    case u'‒':   // FIGURE DASH (0x2012 Pd)
-    case u'–':   // EN DASH (0x2013 Pd)
-    case u'—':   // EM DASH (0x2014 Pd)
-    case u'―':   // HORIZONTAL BAR (0x2015 Pd)
-    case u'‖':   // DOUBLE VERTICAL LINE (0x2016 Po)
-    case u'‗':   // DOUBLE LOW LINE (0x2017 Po)
-    case u'‘':   // LEFT SINGLE QUOTATION MARK (0x2018 Pi)
-    case u'’':   // RIGHT SINGLE QUOTATION MARK (0x2019 Pf)
-    case u'‚':   // SINGLE LOW-9 QUOTATION MARK (0x201a Ps)
-    case u'‛':   // SINGLE HIGH-REVERSED-9 QUOTATION MARK (0x201b Pi)
-    case u'“':   // LEFT DOUBLE QUOTATION MARK (0x201c Pi)
-    case u'”':   // RIGHT DOUBLE QUOTATION MARK (0x201d Pf)
-    case u'„':   // DOUBLE LOW-9 QUOTATION MARK (0x201e Ps)
-    case u'‟':   // DOUBLE HIGH-REVERSED-9 QUOTATION MARK (0x201f Pi)
-    case u'†':   // DAGGER (0x2020 Po)
-    case u'‡':   // DOUBLE DAGGER (0x2021 Po)
-    case u'•':   // BULLET (0x2022 Po)
-    case u'‣':   // TRIANGULAR BULLET (0x2023 Po)
-    case u'․':   // ONE DOT LEADER (0x2024 Po)
-    case u'‥':   // TWO DOT LEADER (0x2025 Po)
-    case u'…':   // HORIZONTAL ELLIPSIS (0x2026 Po)
-    case u'‧':   // HYPHENATION POINT (0x2027 Po)
-    case u'‰':   // PER MILLE SIGN (0x2030 Po)
-    case u'‱':   // PER TEN THOUSAND SIGN (0x2031 Po)
-    case u'′':   // PRIME (0x2032 Po)
-    case u'″':   // DOUBLE PRIME (0x2033 Po)
-    case u'‴':   // TRIPLE PRIME (0x2034 Po)
-    case u'‵':   // REVERSED PRIME (0x2035 Po)
-    case u'‶':   // REVERSED DOUBLE PRIME (0x2036 Po)
-    case u'‷':   // REVERSED TRIPLE PRIME (0x2037 Po)
-    case u'‸':   // CARET (0x2038 Po)
-    case u'‹':   // SINGLE LEFT-POINTING ANGLE QUOTATION MARK (0x2039 Pi)
-    case u'›':   // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK (0x203a Pf)
-    case u'※':   // REFERENCE MARK (0x203b Po)
-    case u'‼':   // DOUBLE EXCLAMATION MARK (0x203c Po)
-    case u'‽':   // INTERROBANG (0x203d Po)
-    case u'‾':   // OVERLINE (0x203e Po)
-    case u'‿':   // UNDERTIE (0x203f Pc)
-    case u'⁀':   // CHARACTER TIE (0x2040 Pc)
-    case u'⁁':   // CARET INSERTION POINT (0x2041 Po)
-    case u'⁂':   // ASTERISM (0x2042 Po)
-    case u'⁃':   // HYPHEN BULLET (0x2043 Po)
-    case u'⁅':   // LEFT SQUARE BRACKET WITH QUILL (0x2045 Ps)
-    case u'⁆':   // RIGHT SQUARE BRACKET WITH QUILL (0x2046 Pe)
-    case u'⁇':   // DOUBLE QUESTION MARK (0x2047 Po)
-    case u'⁈':   // QUESTION EXCLAMATION MARK (0x2048 Po)
-    case u'⁉':   // EXCLAMATION QUESTION MARK (0x2049 Po)
-    case u'⁊':   // TIRONIAN SIGN ET (0x204a Po)
-    case u'⁋':   // REVERSED PILCROW SIGN (0x204b Po)
-    case u'⁌':   // BLACK LEFTWARDS BULLET (0x204c Po)
-    case u'⁍':   // BLACK RIGHTWARDS BULLET (0x204d Po)
-    case u'⁎':   // LOW ASTERISK (0x204e Po)
-    case u'⁏':   // REVERSED SEMICOLON (0x204f Po)
-    case u'⁐':   // CLOSE UP (0x2050 Po)
-    case u'⁑':   // TWO ASTERISKS ALIGNED VERTICALLY (0x2051 Po)
-    case u'⁓':   // SWUNG DASH (0x2053 Po)
-    case u'⁔':   // INVERTED UNDERTIE (0x2054 Pc)
-    case u'⁕':   // FLOWER PUNCTUATION MARK (0x2055 Po)
-    case u'⁖':   // THREE DOT PUNCTUATION (0x2056 Po)
-    case u'⁗':   // QUADRUPLE PRIME (0x2057 Po)
-    case u'⁘':   // FOUR DOT PUNCTUATION (0x2058 Po)
-    case u'⁙':   // FIVE DOT PUNCTUATION (0x2059 Po)
-    case u'⁚':   // TWO DOT PUNCTUATION (0x205a Po)
-    case u'⁛':   // FOUR DOT MARK (0x205b Po)
-    case u'⁜':   // DOTTED CROSS (0x205c Po)
-    case u'⁝':   // TRICOLON (0x205d Po)
-    case u'⁞':   // VERTICAL FOUR DOTS (0x205e Po)
-    case u'⁽':   // SUPERSCRIPT LEFT PARENTHESIS (0x207d Ps)
-    case u'⁾':   // SUPERSCRIPT RIGHT PARENTHESIS (0x207e Pe)
-    case u'₍':   // SUBSCRIPT LEFT PARENTHESIS (0x208d Ps)
-    case u'₎':   // SUBSCRIPT RIGHT PARENTHESIS (0x208e Pe)
-    case u'⌈':   // LEFT CEILING (0x2308 Ps)
-    case u'⌉':   // RIGHT CEILING (0x2309 Pe)
-    case u'⌊':   // LEFT FLOOR (0x230a Ps)
-    case u'⌋':   // RIGHT FLOOR (0x230b Pe)
-    case u'〈':  // LEFT-POINTING ANGLE BRACKET (0x2329 Ps)
-    case u'〉':  // RIGHT-POINTING ANGLE BRACKET (0x232a Pe)
-    case u'❨':   // MEDIUM LEFT PARENTHESIS ORNAMENT (0x2768 Ps)
-    case u'❩':   // MEDIUM RIGHT PARENTHESIS ORNAMENT (0x2769 Pe)
-    case u'❪':   // MEDIUM FLATTENED LEFT PARENTHESIS ORNAMENT (0x276a Ps)
-    case u'❫':   // MEDIUM FLATTENED RIGHT PARENTHESIS ORNAMENT (0x276b Pe)
-    case u'❬':   // MEDIUM LEFT-POINTING ANGLE BRACKET ORNAMENT (0x276c Ps)
-    case u'❭':   // MEDIUM RIGHT-POINTING ANGLE BRACKET ORNAMENT (0x276d Pe)
-    case u'❮':  // HEAVY LEFT-POINTING ANGLE QUOTATION MARK ORNAMENT (0x276e Ps)
-    case u'❯':  // HEAVY RIGHT-POINTING ANGLE QUOT MARK ORNAMENT (0x276f Pe)
-    case u'❰':  // HEAVY LEFT-POINTING ANGLE BRACKET ORNAMENT (0x2770 Ps)
-    case u'❱':  // HEAVY RIGHT-POINTING ANGLE BRACKET ORNAMENT (0x2771 Pe)
-    case u'❲':  // LIGHT LEFT TORTOISE SHELL BRACKET ORNAMENT (0x2772 Ps)
-    case u'❳':  // LIGHT RIGHT TORTOISE SHELL BRACKET ORNAMENT (0x2773 Pe)
-    case u'❴':  // MEDIUM LEFT CURLY BRACKET ORNAMENT (0x2774 Ps)
-    case u'❵':  // MEDIUM RIGHT CURLY BRACKET ORNAMENT (0x2775 Pe)
-    case u'⟅':  // LEFT S-SHAPED BAG DELIMITER (0x27c5 Ps)
-    case u'⟆':  // RIGHT S-SHAPED BAG DELIMITER (0x27c6 Pe)
-    case u'⟦':  // MATHEMATICAL LEFT WHITE SQUARE BRACKET (0x27e6 Ps)
-    case u'⟧':  // MATHEMATICAL RIGHT WHITE SQUARE BRACKET (0x27e7 Pe)
-    case u'⟨':  // MATHEMATICAL LEFT ANGLE BRACKET (0x27e8 Ps)
-    case u'⟩':  // MATHEMATICAL RIGHT ANGLE BRACKET (0x27e9 Pe)
-    case u'⟪':  // MATHEMATICAL LEFT DOUBLE ANGLE BRACKET (0x27ea Ps)
-    case u'⟫':  // MATHEMATICAL RIGHT DOUBLE ANGLE BRACKET (0x27eb Pe)
-    case u'⟬':  // MATHEMATICAL LEFT WHITE TORTOISE SHELL BRACKET (0x27ec Ps)
-    case u'⟭':  // MATHEMATICAL RIGHT WHITE TORTOISE SHELL BRACKET (0x27ed Pe)
-    case u'⟮':  // MATHEMATICAL LEFT FLATTENED PARENTHESIS (0x27ee Ps)
-    case u'⟯':  // MATHEMATICAL RIGHT FLATTENED PARENTHESIS (0x27ef Pe)
-    case u'⦃':  // LEFT WHITE CURLY BRACKET (0x2983 Ps)
-    case u'⦄':  // RIGHT WHITE CURLY BRACKET (0x2984 Pe)
-    case u'⦅':  // LEFT WHITE PARENTHESIS (0x2985 Ps)
-    case u'⦆':  // RIGHT WHITE PARENTHESIS (0x2986 Pe)
-    case u'⦇':  // Z NOTATION LEFT IMAGE BRACKET (0x2987 Ps)
-    case u'⦈':  // Z NOTATION RIGHT IMAGE BRACKET (0x2988 Pe)
-    case u'⦉':  // Z NOTATION LEFT BINDING BRACKET (0x2989 Ps)
-    case u'⦊':  // Z NOTATION RIGHT BINDING BRACKET (0x298a Pe)
-    case u'⦋':  // LEFT SQUARE BRACKET WITH UNDERBAR (0x298b Ps)
-    case u'⦌':  // RIGHT SQUARE BRACKET WITH UNDERBAR (0x298c Pe)
-    case u'⦍':  // LEFT SQUARE BRACKET WITH TICK IN TOP CORNER (0x298d Ps)
-    case u'⦎':  // RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER (0x298e Pe)
-    case u'⦏':  // LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER (0x298f Ps)
-    case u'⦐':  // RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER (0x2990 Pe)
-    case u'⦑':  // LEFT ANGLE BRACKET WITH DOT (0x2991 Ps)
-    case u'⦒':  // RIGHT ANGLE BRACKET WITH DOT (0x2992 Pe)
-    case u'⦓':  // LEFT ARC LESS-THAN BRACKET (0x2993 Ps)
-    case u'⦔':  // RIGHT ARC GREATER-THAN BRACKET (0x2994 Pe)
-    case u'⦗':  // LEFT BLACK TORTOISE SHELL BRACKET (0x2997 Ps)
-    case u'⦘':  // RIGHT BLACK TORTOISE SHELL BRACKET (0x2998 Pe)
-    case u'⧘':  // LEFT WIGGLY FENCE (0x29d8 Ps)
-    case u'⧙':  // RIGHT WIGGLY FENCE (0x29d9 Pe)
-    case u'⧚':  // LEFT DOUBLE WIGGLY FENCE (0x29da Ps)
-    case u'⧛':  // RIGHT DOUBLE WIGGLY FENCE (0x29db Pe)
-    case u'⧼':  // LEFT-POINTING CURVED ANGLE BRACKET (0x29fc Ps)
-    case u'⧽':  // RIGHT-POINTING CURVED ANGLE BRACKET (0x29fd Pe)
-    case u'⵰':  // TIFINAGH SEPARATOR MARK (0x2d70 Po)
-    case u'⸎':  // EDITORIAL CORONIS (0x2e0e Po)
-    case u'⸏':  // PARAGRAPHOS (0x2e0f Po)
-    case u'⸐':  // FORKED PARAGRAPHOS (0x2e10 Po)
-    case u'⸑':  // REVERSED FORKED PARAGRAPHOS (0x2e11 Po)
-    case u'⸒':  // HYPODIASTOLE (0x2e12 Po)
-    case u'⸓':  // DOTTED OBELOS (0x2e13 Po)
-    case u'⸔':  // DOWNWARDS ANCORA (0x2e14 Po)
-    case u'⸕':  // UPWARDS ANCORA (0x2e15 Po)
-    case u'⸖':  // DOTTED RIGHT-POINTING ANGLE (0x2e16 Po)
-    case u'⸗':  // DOUBLE OBLIQUE HYPHEN (0x2e17 Pd)
-    case u'⸙':  // PALM BRANCH (0x2e19 Po)
-    case u'⸚':  // HYPHEN WITH DIAERESIS (0x2e1a Pd)
-    case u'⸛':  // TILDE WITH RING ABOVE (0x2e1b Po)
-    case u'⸞':  // TILDE WITH DOT ABOVE (0x2e1e Po)
-    case u'⸟':  // TILDE WITH DOT BELOW (0x2e1f Po)
-    case u'⸪':  // TWO DOTS OVER ONE DOT PUNCTUATION (0x2e2a Po)
-    case u'⸫':  // ONE DOT OVER TWO DOTS PUNCTUATION (0x2e2b Po)
-    case u'⸬':  // SQUARED FOUR DOT PUNCTUATION (0x2e2c Po)
-    case u'⸭':  // FIVE DOT MARK (0x2e2d Po)
-    case u'⸮':  // REVERSED QUESTION MARK (0x2e2e Po)
-    case u'⸰':  // RING POINT (0x2e30 Po)
-    case u'⸱':  // WORD SEPARATOR MIDDLE DOT (0x2e31 Po)
-    case u'⸲':  // TURNED COMMA (0x2e32 Po)
-    case u'⸳':  // RAISED DOT (0x2e33 Po)
-    case u'⸴':  // RAISED COMMA (0x2e34 Po)
-    case u'⸵':  // TURNED SEMICOLON (0x2e35 Po)
-    case u'⸶':  // DAGGER WITH LEFT GUARD (0x2e36 Po)
-    case u'⸷':  // DAGGER WITH RIGHT GUARD (0x2e37 Po)
-    case u'⸸':  // TURNED DAGGER (0x2e38 Po)
-    case u'⸹':  // TOP HALF SECTION SIGN (0x2e39 Po)
-    case u'⸺':  // TWO-EM DASH (0x2e3a Pd)
-    case u'⸻':  // THREE-EM DASH (0x2e3b Pd)
-    case u'⸼':  // STENOGRAPHIC FULL STOP (0x2e3c Po)
-    case u'⸽':  // VERTICAL SIX DOTS (0x2e3d Po)
-    case u'⸾':  // WIGGLY VERTICAL LINE (0x2e3e Po)
-    case u'⸿':  // CAPITULUM (0x2e3f Po)
-    case u'⹀':  // DOUBLE HYPHEN (0x2e40 Pd)
-    case u'⹁':  // REVERSED COMMA (0x2e41 Po)
-    case u'⹂':  // DOUBLE LOW-REVERSED-9 QUOTATION MARK (0x2e42 Ps)
-    case u'⹃':  // DASH WITH LEFT UPTURN (0x2e43 Po)
-    case u'⹄':  // DOUBLE SUSPENSION MARK (0x2e44 Po)
-    case u'⹅':  // INVERTED LOW KAVYKA (0x2e45 Po)
-    case u'⹆':  // INVERTED LOW KAVYKA WITH KAVYKA ABOVE (0x2e46 Po)
-    case u'⹇':  // LOW KAVYKA (0x2e47 Po)
-    case u'⹈':  // LOW KAVYKA WITH DOT (0x2e48 Po)
-    case u'⹉':  // DOUBLE STACKED COMMA (0x2e49 Po)
-    case u'⹊':  // DOTTED SOLIDUS (0x2e4a Po)
-    case u'⹋':  // TRIPLE DAGGER (0x2e4b Po)
-    case u'⹌':  // MEDIEVAL COMMA (0x2e4c Po)
-    case u'⹍':  // PARAGRAPHUS MARK (0x2e4d Po)
-    case u'⹎':  // PUNCTUS ELEVATUS MARK (0x2e4e Po)
-    case u'⹏':  // CORNISH VERSE DIVIDER (0x2e4f Po)
-    case u'、':  // IDEOGRAPHIC COMMA (0x3001 Po)
-    case u'。':  // IDEOGRAPHIC FULL STOP (0x3002 Po)
-    case u'〃':  // DITTO MARK (0x3003 Po)
-    case u'〈':  // LEFT ANGLE BRACKET (0x3008 Ps)
-    case u'〉':  // RIGHT ANGLE BRACKET (0x3009 Pe)
-    case u'《':  // LEFT DOUBLE ANGLE BRACKET (0x300a Ps)
-    case u'》':  // RIGHT DOUBLE ANGLE BRACKET (0x300b Pe)
-    case u'「':  // LEFT CORNER BRACKET (0x300c Ps)
-    case u'」':  // RIGHT CORNER BRACKET (0x300d Pe)
-    case u'『':  // LEFT WHITE CORNER BRACKET (0x300e Ps)
-    case u'』':  // RIGHT WHITE CORNER BRACKET (0x300f Pe)
-    case u'【':  // LEFT BLACK LENTICULAR BRACKET (0x3010 Ps)
-    case u'】':  // RIGHT BLACK LENTICULAR BRACKET (0x3011 Pe)
-    case u'〔':  // LEFT TORTOISE SHELL BRACKET (0x3014 Ps)
-    case u'〕':  // RIGHT TORTOISE SHELL BRACKET (0x3015 Pe)
-    case u'〖':  // LEFT WHITE LENTICULAR BRACKET (0x3016 Ps)
-    case u'〗':  // RIGHT WHITE LENTICULAR BRACKET (0x3017 Pe)
-    case u'〘':  // LEFT WHITE TORTOISE SHELL BRACKET (0x3018 Ps)
-    case u'〙':  // RIGHT WHITE TORTOISE SHELL BRACKET (0x3019 Pe)
-    case u'〚':  // LEFT WHITE SQUARE BRACKET (0x301a Ps)
-    case u'〛':  // RIGHT WHITE SQUARE BRACKET (0x301b Pe)
-    case u'〜':  // WAVE DASH (0x301c Pd)
-    case u'〝':  // REVERSED DOUBLE PRIME QUOTATION MARK (0x301d Ps)
-    case u'〞':  // DOUBLE PRIME QUOTATION MARK (0x301e Pe)
-    case u'〟':  // LOW DOUBLE PRIME QUOTATION MARK (0x301f Pe)
-    case u'〰':  // WAVY DASH (0x3030 Pd)
-    case u'〽':  // PART ALTERNATION MARK (0x303d Po)
-    case u'゠':  // KATAKANA-HIRAGANA DOUBLE HYPHEN (0x30a0 Pd)
-    case u'・':  // KATAKANA MIDDLE DOT (0x30fb Po)
-    case u'꓾':   // LISU PUNCTUATION COMMA (0xa4fe Po)
-    case u'꓿':   // LISU PUNCTUATION FULL STOP (0xa4ff Po)
-    case u'꘍':   // VAI COMMA (0xa60d Po)
-    case u'꘎':   // VAI FULL STOP (0xa60e Po)
-    case u'꘏':   // VAI QUESTION MARK (0xa60f Po)
-    case u'꙾':   // CYRILLIC KAVYKA (0xa67e Po)
-    case u'꡴':   // PHAGS-PA SINGLE HEAD MARK (0xa874 Po)
-    case u'꡵':   // PHAGS-PA DOUBLE HEAD MARK (0xa875 Po)
-    case u'꡶':   // PHAGS-PA MARK SHAD (0xa876 Po)
-    case u'꡷':   // PHAGS-PA MARK DOUBLE SHAD (0xa877 Po)
-    case u'꣎':   // SAURASHTRA DANDA (0xa8ce Po)
-    case u'꣏':   // SAURASHTRA DOUBLE DANDA (0xa8cf Po)
-    case u'꣸':   // DEVANAGARI SIGN PUSHPIKA (0xa8f8 Po)
-    case u'꣹':   // DEVANAGARI GAP FILLER (0xa8f9 Po)
-    case u'꣺':   // DEVANAGARI CARET (0xa8fa Po)
-    case u'꣼':   // DEVANAGARI SIGN SIDDHAM (0xa8fc Po)
-    case u'꧁':   // JAVANESE LEFT RERENGGAN (0xa9c1 Po)
-    case u'꧂':   // JAVANESE RIGHT RERENGGAN (0xa9c2 Po)
-    case u'꧃':   // JAVANESE PADA ANDAP (0xa9c3 Po)
-    case u'꧄':   // JAVANESE PADA MADYA (0xa9c4 Po)
-    case u'꧅':   // JAVANESE PADA LUHUR (0xa9c5 Po)
-    case u'꧆':   // JAVANESE PADA WINDU (0xa9c6 Po)
-    case u'꧇':   // JAVANESE PADA PANGKAT (0xa9c7 Po)
-    case u'꧈':   // JAVANESE PADA LINGSA (0xa9c8 Po)
-    case u'꧉':   // JAVANESE PADA LUNGSI (0xa9c9 Po)
-    case u'꧊':   // JAVANESE PADA ADEG (0xa9ca Po)
-    case u'꧋':   // JAVANESE PADA ADEG ADEG (0xa9cb Po)
-    case u'꧌':   // JAVANESE PADA PISELEH (0xa9cc Po)
-    case u'꧍':   // JAVANESE TURNED PADA PISELEH (0xa9cd Po)
-    case u'꧞':   // JAVANESE PADA TIRTA TUMETES (0xa9de Po)
-    case u'꧟':   // JAVANESE PADA ISEN-ISEN (0xa9df Po)
-    case u'꩜':   // CHAM PUNCTUATION SPIRAL (0xaa5c Po)
-    case u'꩝':   // CHAM PUNCTUATION DANDA (0xaa5d Po)
-    case u'꩞':   // CHAM PUNCTUATION DOUBLE DANDA (0xaa5e Po)
-    case u'꩟':   // CHAM PUNCTUATION TRIPLE DANDA (0xaa5f Po)
-    case u'꫞':   // TAI VIET SYMBOL HO HOI (0xaade Po)
-    case u'꫟':   // TAI VIET SYMBOL KOI KOI (0xaadf Po)
-    case u'꫰':   // MEETEI MAYEK CHEIKHAN (0xaaf0 Po)
-    case u'꫱':   // MEETEI MAYEK AHANG KHUDAM (0xaaf1 Po)
-    case u'꯫':   // MEETEI MAYEK CHEIKHEI (0xabeb Po)
-    case u'︐':  // PRESENTATION FORM FOR VERTICAL COMMA (0xfe10 Po)
-    case u'︑':  // PRESENTATION FORM FOR VERTICAL IDEOGRAPHIC COMMA (0xfe11 Po)
-    case u'︒':  // PRESENTATION FORM FOR VERTICAL IDEO FULL STOP (0xfe12 Po)
-    case u'︓':  // PRESENTATION FORM FOR VERTICAL COLON (0xfe13 Po)
-    case u'︔':  // PRESENTATION FORM FOR VERTICAL SEMICOLON (0xfe14 Po)
-    case u'︕':  // PRESENTATION FORM FOR VERTICAL EXCLAMATION MARK (0xfe15 Po)
-    case u'︖':  // PRESENTATION FORM FOR VERTICAL QUESTION MARK (0xfe16 Po)
-    case u'︗':  // PRESENTATION ... LEFT WHITE LENTICULAR BRACKET (0xfe17 Ps)
-    case u'︘':  // PRESENTATION ... RIGHT WHITE LENTICULAR BRAKCET (0xfe18 Pe)
-    case u'︙':  // PRESENTATION ... VERTICAL HORIZONTAL ELLIPSIS (0xfe19 Po)
-    case u'︰':  // PRESENTATION FORM FOR VERTICAL TWO DOT LEADER (0xfe30 Po)
-    case u'︱':  // PRESENTATION FORM FOR VERTICAL EM DASH (0xfe31 Pd)
-    case u'︲':  // PRESENTATION FORM FOR VERTICAL EN DASH (0xfe32 Pd)
-    case u'︳':  // PRESENTATION FORM FOR VERTICAL LOW LINE (0xfe33 Pc)
-    case u'︴':  // PRESENTATION FORM FOR VERTICAL WAVY LOW LINE (0xfe34 Pc)
-    case u'︵':  // PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS (0xfe35 Ps)
-    case u'︶':  // PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS (0xfe36 Pe)
-    case u'︷':  // PRESENTATION ... VERTICAL LEFT CURLY BRACKET (0xfe37 Ps)
-    case u'︸':  // PRESENTATION ... VERTICAL RIGHT CURLY BRACKET (0xfe38 Pe)
-    case u'︹':  // PRESENTATION ... LEFT TORTOISE SHELL BRACKET (0xfe39 Ps)
-    case u'︺':  // PRESENTATION ... RIGHT TORTOISE SHELL BRACKET (0xfe3a Pe)
-    case u'︻':  // PRESENTATION ... LEFT BLACK LENTICULAR BRACKET (0xfe3b Ps)
-    case u'︼':  // PRESENTATION ... RIGHT BLACK LENTICULAR BRACKET (0xfe3c Pe)
-    case u'︽':  // PRESENTATION ... LEFT DOUBLE ANGLE BRACKET (0xfe3d Ps)
-    case u'︾':  // PRESENTATION ... RIGHT DOUBLE ANGLE BRACKET (0xfe3e Pe)
-    case u'︿':  // PRESENTATION ... LEFT ANGLE BRACKET (0xfe3f Ps)
-    case u'﹀':  // PRESENTATION ... RIGHT ANGLE BRACKET (0xfe40 Pe)
-    case u'﹁':  // PRESENTATION ... LEFT CORNER BRACKET (0xfe41 Ps)
-    case u'﹂':  // PRESENTATION ... RIGHT CORNER BRACKET (0xfe42 Pe)
-    case u'﹃':  // PRESENTATION ... LEFT WHITE CORNER BRACKET (0xfe43 Ps)
-    case u'﹄':  // PRESENTATION ... RIGHT WHITE CORNER BRACKET Pe)
-    case u'﹅':  // SESAME DOT (0xfe45 Po)
-    case u'﹆':  // WHITE SESAME DOT (0xfe46 Po)
-    case u'﹇':  // PRESENTATION ... VERTICAL LEFT SQUARE BRACKET (0xfe47 Ps)
-    case u'﹈':  // PRESENTATION ... VERTICAL RIGHT SQUARE BRACKET (0xfe48 Pe)
-    case u'﹉':  // DASHED OVERLINE (0xfe49 Po)
-    case u'﹊':  // CENTRELINE OVERLINE (0xfe4a Po)
-    case u'﹋':  // WAVY OVERLINE (0xfe4b Po)
-    case u'﹌':  // DOUBLE WAVY OVERLINE (0xfe4c Po)
-    case u'﹍':  // DASHED LOW LINE (0xfe4d Pc)
-    case u'﹎':  // CENTRELINE LOW LINE (0xfe4e Pc)
-    case u'﹏':  // WAVY LOW LINE (0xfe4f Pc)
-    case u'﹐':  // SMALL COMMA (0xfe50 Po)
-    case u'﹑':  // SMALL IDEOGRAPHIC COMMA (0xfe51 Po)
-    case u'﹒':  // SMALL FULL STOP (0xfe52 Po)
-    case u'﹔':  // SMALL SEMICOLON (0xfe54 Po)
-    case u'﹕':  // SMALL COLON (0xfe55 Po)
-    case u'﹖':  // SMALL QUESTION MARK (0xfe56 Po)
-    case u'﹗':  // SMALL EXCLAMATION MARK (0xfe57 Po)
-    case u'﹘':  // SMALL EM DASH (0xfe58 Pd)
-    case u'﹙':  // SMALL LEFT PARENTHESIS (0xfe59 Ps)
-    case u'﹚':  // SMALL RIGHT PARENTHESIS (0xfe5a Pe)
-    case u'﹛':  // SMALL LEFT CURLY BRACKET (0xfe5b Ps)
-    case u'﹜':  // SMALL RIGHT CURLY BRACKET (0xfe5c Pe)
-    case u'﹝':  // SMALL LEFT TORTOISE SHELL BRACKET (0xfe5d Ps)
-    case u'﹞':  // SMALL RIGHT TORTOISE SHELL BRACKET (0xfe5e Pe)
-    case u'﹟':  // SMALL NUMBER SIGN (0xfe5f Po)
-    case u'﹠':  // SMALL AMPERSAND (0xfe60 Po)
-    case u'﹡':  // SMALL ASTERISK (0xfe61 Po)
-    case u'﹣':  // SMALL HYPHEN-MINUS (0xfe63 Pd)
-    case u'﹨':  // SMALL REVERSE SOLIDUS (0xfe68 Po)
-    case u'﹪':  // SMALL PERCENT SIGN (0xfe6a Po)
-    case u'﹫':  // SMALL COMMERCIAL AT (0xfe6b Po)
-    case u'！':  // FULLWIDTH EXCLAMATION MARK (0xff01 Po)
-    case u'＂':  // FULLWIDTH QUOTATION MARK (0xff02 Po)
-    case u'＃':  // FULLWIDTH NUMBER SIGN (0xff03 Po)
-    case u'％':  // FULLWIDTH PERCENT SIGN (0xff05 Po)
-    case u'＆':  // FULLWIDTH AMPERSAND (0xff06 Po)
-    case u'＇':  // FULLWIDTH APOSTROPHE (0xff07 Po)
-    case u'（':  // FULLWIDTH LEFT PARENTHESIS (0xff08 Ps)
-    case u'）':  // FULLWIDTH RIGHT PARENTHESIS (0xff09 Pe)
-    case u'＊':  // FULLWIDTH ASTERISK (0xff0a Po)
-    case u'，':  // FULLWIDTH COMMA (0xff0c Po)
-    case u'－':  // FULLWIDTH HYPHEN-MINUS (0xff0d Pd)
-    case u'．':  // FULLWIDTH FULL STOP (0xff0e Po)
-    case u'／':  // FULLWIDTH SOLIDUS (0xff0f Po)
-    case u'：':  // FULLWIDTH COLON (0xff1a Po)
-    case u'；':  // FULLWIDTH SEMICOLON (0xff1b Po)
-    case u'？':  // FULLWIDTH QUESTION MARK (0xff1f Po)
-    case u'＠':  // FULLWIDTH COMMERCIAL AT (0xff20 Po)
-    case u'［':  // FULLWIDTH LEFT SQUARE BRACKET (0xff3b Ps)
-    case u'＼':  // FULLWIDTH REVERSE SOLIDUS (0xff3c Po)
-    case u'］':  // FULLWIDTH RIGHT SQUARE BRACKET (0xff3d Pe)
-    case u'＿':  // FULLWIDTH LOW LINE (0xff3f Pc)
-    case u'｛':  // FULLWIDTH LEFT CURLY BRACKET (0xff5b Ps)
-    case u'｝':  // FULLWIDTH RIGHT CURLY BRACKET (0xff5d Pe)
-    case u'｟':  // FULLWIDTH LEFT WHITE PARENTHESIS (0xff5f Ps)
-    case u'｠':  // FULLWIDTH RIGHT WHITE PARENTHESIS (0xff60 Pe)
-    case u'｡':   // HALFWIDTH IDEOGRAPHIC FULL STOP (0xff61 Po)
-    case u'｢':   // HALFWIDTH LEFT CORNER BRACKET (0xff62 Ps)
-    case u'｣':   // HALFWIDTH RIGHT CORNER BRACKET (0xff63 Pe)
-    case u'､':   // HALFWIDTH IDEOGRAPHIC COMMA (0xff64 Po)
-    case u'･':   // HALFWIDTH KATAKANA MIDDLE DOT (0xff65 Po)
-      return 1;
-    default:
-      return 0;
-  }
-}
-
-__weak_reference(iswpunct, iswpunct_l);
diff --git a/libc/str/iswseparator.c b/libc/str/iswseparator.c
deleted file mode 100644
index 2a3a24d86..000000000
--- a/libc/str/iswseparator.c
+++ /dev/null
@@ -1,423 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-static const unsigned short kCodes[][2] = {
-    {0x00aa, 0x00aa}, /*     1x English */
-    {0x00b2, 0x00b3}, /*     2x English Arabic */
-    {0x00b5, 0x00b5}, /*     1x Greek */
-    {0x00b9, 0x00ba}, /*     2x English Arabic */
-    {0x00bc, 0x00be}, /*     3x Vulgar English Arabic */
-    {0x00c0, 0x00d6}, /*    23x Watin */
-    {0x00d8, 0x00f6}, /*    31x Watin */
-    {0x0100, 0x02c1}, /*   450x Watin-AB,IPA,Spacemod */
-    {0x02c6, 0x02d1}, /*    12x Spacemod */
-    {0x02e0, 0x02e4}, /*     5x Spacemod */
-    {0x02ec, 0x02ec}, /*     1x Spacemod */
-    {0x02ee, 0x02ee}, /*     1x Spacemod */
-    {0x0370, 0x0374}, /*     5x Greek */
-    {0x0376, 0x0377}, /*     2x Greek */
-    {0x037a, 0x037d}, /*     4x Greek */
-    {0x037f, 0x037f}, /*     1x Greek */
-    {0x0386, 0x0386}, /*     1x Greek */
-    {0x0388, 0x038a}, /*     3x Greek */
-    {0x038c, 0x038c}, /*     1x Greek */
-    {0x038e, 0x03a1}, /*    20x Greek */
-    {0x03a3, 0x03f5}, /*    83x Greek */
-    {0x03f7, 0x0481}, /*   139x Greek */
-    {0x048a, 0x052f}, /*   166x Cyrillic */
-    {0x0531, 0x0556}, /*    38x Armenian */
-    {0x0560, 0x0588}, /*    41x Armenian */
-    {0x05d0, 0x05ea}, /*    27x Hebrew */
-    {0x0620, 0x064a}, /*    43x Arabic */
-    {0x0660, 0x0669}, /*    10x Arabic */
-    {0x0671, 0x06d3}, /*    99x Arabic */
-    {0x06ee, 0x06fc}, /*    15x Arabic */
-    {0x0712, 0x072f}, /*    30x Syriac */
-    {0x074d, 0x07a5}, /*    89x Syriac,Arabic2,Thaana */
-    {0x07c0, 0x07ea}, /*    43x NKo */
-    {0x0800, 0x0815}, /*    22x Samaritan */
-    {0x0840, 0x0858}, /*    25x Mandaic */
-    {0x0904, 0x0939}, /*    54x Devanagari */
-    {0x0993, 0x09a8}, /*    22x Bengali */
-    {0x09e6, 0x09f1}, /*    12x Bengali */
-    {0x0a13, 0x0a28}, /*    22x Gurmukhi */
-    {0x0a66, 0x0a6f}, /*    10x Gurmukhi */
-    {0x0a93, 0x0aa8}, /*    22x Gujarati */
-    {0x0b13, 0x0b28}, /*    22x Oriya */
-    {0x0c92, 0x0ca8}, /*    23x Kannada */
-    {0x0caa, 0x0cb3}, /*    10x Kannada */
-    {0x0ce6, 0x0cef}, /*    10x Kannada */
-    {0x0d12, 0x0d3a}, /*    41x Malayalam */
-    {0x0d85, 0x0d96}, /*    18x Sinhala */
-    {0x0d9a, 0x0db1}, /*    24x Sinhala */
-    {0x0de6, 0x0def}, /*    10x Sinhala */
-    {0x0e01, 0x0e30}, /*    48x Thai */
-    {0x0e8c, 0x0ea3}, /*    24x Lao */
-    {0x0f20, 0x0f33}, /*    20x Tibetan */
-    {0x0f49, 0x0f6c}, /*    36x Tibetan */
-    {0x109e, 0x10c5}, /*    40x Myanmar,Georgian */
-    {0x10d0, 0x10fa}, /*    43x Georgian */
-    {0x10fc, 0x1248}, /*   333x Georgian,Hangul,Ethiopic */
-    {0x13a0, 0x13f5}, /*    86x Cherokee */
-    {0x1401, 0x166d}, /*   621x Aboriginal */
-    {0x16a0, 0x16ea}, /*    75x Runic */
-    {0x1700, 0x170c}, /*    13x Tagalog */
-    {0x1780, 0x17b3}, /*    52x Khmer */
-    {0x1820, 0x1878}, /*    89x Mongolian */
-    {0x1a00, 0x1a16}, /*    23x Buginese */
-    {0x1a20, 0x1a54}, /*    53x Tai Tham */
-    {0x1a80, 0x1a89}, /*    10x Tai Tham */
-    {0x1a90, 0x1a99}, /*    10x Tai Tham */
-    {0x1b05, 0x1b33}, /*    47x Balinese */
-    {0x1b50, 0x1b59}, /*    10x Balinese */
-    {0x1b83, 0x1ba0}, /*    30x Sundanese */
-    {0x1bae, 0x1be5}, /*    56x Sundanese */
-    {0x1c90, 0x1cba}, /*    43x Georgian2 */
-    {0x1cbd, 0x1cbf}, /*     3x Georgian2 */
-    {0x1e00, 0x1f15}, /*   278x Watin-C,Greek2 */
-    {0x2070, 0x2071}, /*     2x Supersub */
-    {0x2074, 0x2079}, /*     6x Supersub */
-    {0x207f, 0x2089}, /*    11x Supersub */
-    {0x2090, 0x209c}, /*    13x Supersub */
-    {0x2100, 0x2117}, /*    24x Letterlike */
-    {0x2119, 0x213f}, /*    39x Letterlike */
-    {0x2145, 0x214a}, /*     6x Letterlike */
-    {0x214c, 0x218b}, /*    64x Letterlike,Numbery */
-    {0x21af, 0x21cd}, /*    31x Arrows */
-    {0x21d5, 0x21f3}, /*    31x Arrows */
-    {0x230c, 0x231f}, /*    20x Technical */
-    {0x232b, 0x237b}, /*    81x Technical */
-    {0x237d, 0x239a}, /*    30x Technical */
-    {0x23b4, 0x23db}, /*    40x Technical */
-    {0x23e2, 0x2426}, /*    69x Technical,ControlPictures */
-    {0x2460, 0x25b6}, /*   343x Enclosed,Boxes,Blocks,Shapes */
-    {0x25c2, 0x25f7}, /*    54x Shapes */
-    {0x2600, 0x266e}, /*   111x Symbols */
-    {0x2670, 0x2767}, /*   248x Symbols,Dingbats */
-    {0x2776, 0x27bf}, /*    74x Dingbats */
-    {0x2800, 0x28ff}, /*   256x Braille */
-    {0x2c00, 0x2c2e}, /*    47x Glagolitic */
-    {0x2c30, 0x2c5e}, /*    47x Glagolitic */
-    {0x2c60, 0x2ce4}, /*   133x Watin-D */
-    {0x2d00, 0x2d25}, /*    38x Georgian2 */
-    {0x2d30, 0x2d67}, /*    56x Tifinagh */
-    {0x2d80, 0x2d96}, /*    23x Ethiopic2 */
-    {0x2e2f, 0x2e2f}, /*     1x Punctuation2 */
-    {0x3005, 0x3007}, /*     3x CJK Symbols & Punctuation */
-    {0x3021, 0x3029}, /*     9x CJK Symbols & Punctuation */
-    {0x3031, 0x3035}, /*     5x CJK Symbols & Punctuation */
-    {0x3038, 0x303c}, /*     5x CJK Symbols & Punctuation */
-    {0x3041, 0x3096}, /*    86x Hiragana */
-    {0x30a1, 0x30fa}, /*    90x Katakana */
-    {0x3105, 0x312f}, /*    43x Bopomofo */
-    {0x3131, 0x318e}, /*    94x Hangul Compatibility Jamo */
-    {0x31a0, 0x31ba}, /*    27x Bopomofo Extended */
-    {0x31f0, 0x31ff}, /*    16x Katakana Phonetic Extensions */
-    {0x3220, 0x3229}, /*    10x Enclosed CJK Letters & Months */
-    {0x3248, 0x324f}, /*     8x Enclosed CJK Letters & Months */
-    {0x3251, 0x325f}, /*    15x Enclosed CJK Letters & Months */
-    {0x3280, 0x3289}, /*    10x Enclosed CJK Letters & Months */
-    {0x32b1, 0x32bf}, /*    15x Enclosed CJK Letters & Months */
-    {0x3400, 0x4db5}, /*  6582x CJK Unified Ideographs Extension A */
-    {0x4dc0, 0x9fef}, /* 21040x Yijing Hexagram, CJK Unified Ideographs */
-    {0xa000, 0xa48c}, /*  1165x Yi Syllables */
-    {0xa4d0, 0xa4fd}, /*    46x Lisu */
-    {0xa500, 0xa60c}, /*   269x Vai */
-    {0xa610, 0xa62b}, /*    28x Vai */
-    {0xa6a0, 0xa6ef}, /*    80x Bamum */
-    {0xa80c, 0xa822}, /*    23x Syloti Nagri */
-    {0xa840, 0xa873}, /*    52x Phags-pa */
-    {0xa882, 0xa8b3}, /*    50x Saurashtra */
-    {0xa8d0, 0xa8d9}, /*    10x Saurashtra */
-    {0xa900, 0xa925}, /*    38x Kayah Li */
-    {0xa930, 0xa946}, /*    23x Rejang */
-    {0xa960, 0xa97c}, /*    29x Hangul Jamo Extended-A */
-    {0xa984, 0xa9b2}, /*    47x Javanese */
-    {0xa9cf, 0xa9d9}, /*    11x Javanese */
-    {0xaa00, 0xaa28}, /*    41x Cham */
-    {0xaa50, 0xaa59}, /*    10x Cham */
-    {0xabf0, 0xabf9}, /*    10x Meetei Mayek */
-    {0xac00, 0xd7a3}, /* 11172x Hangul Syllables */
-    {0xf900, 0xfa6d}, /*   366x CJK Compatibility Ideographs */
-    {0xfa70, 0xfad9}, /*   106x CJK Compatibility Ideographs */
-    {0xfb1f, 0xfb28}, /*    10x Alphabetic Presentation Forms */
-    {0xfb2a, 0xfb36}, /*    13x Alphabetic Presentation Forms */
-    {0xfb46, 0xfbb1}, /*   108x Alphabetic Presentation Forms */
-    {0xfbd3, 0xfd3d}, /*   363x Arabic Presentation Forms-A */
-    {0xfe76, 0xfefc}, /*   135x Arabic Presentation Forms-B */
-    {0xff10, 0xff19}, /*    10x Dubs */
-    {0xff21, 0xff3a}, /*    26x Dubs */
-    {0xff41, 0xff5a}, /*    26x Dubs */
-    {0xff66, 0xffbe}, /*    89x Dubs */
-    {0xffc2, 0xffc7}, /*     6x Dubs */
-    {0xffca, 0xffcf}, /*     6x Dubs */
-    {0xffd2, 0xffd7}, /*     6x Dubs */
-    {0xffda, 0xffdc}, /*     3x Dubs */
-};
-
-static const unsigned kAstralCodes[][2] = {
-    {0x10107, 0x10133}, /*    45x Aegean */
-    {0x10140, 0x10178}, /*    57x Ancient Greek Numbers */
-    {0x1018a, 0x1018b}, /*     2x Ancient Greek Numbers */
-    {0x10280, 0x1029c}, /*    29x Lycian */
-    {0x102a0, 0x102d0}, /*    49x Carian */
-    {0x102e1, 0x102fb}, /*    27x Coptic Epact Numbers */
-    {0x10300, 0x10323}, /*    36x Old Italic */
-    {0x1032d, 0x1034a}, /*    30x Old Italic, Gothic */
-    {0x10350, 0x10375}, /*    38x Old Permic */
-    {0x10380, 0x1039d}, /*    30x Ugaritic */
-    {0x103a0, 0x103c3}, /*    36x Old Persian */
-    {0x103c8, 0x103cf}, /*     8x Old Persian */
-    {0x103d1, 0x103d5}, /*     5x Old Persian */
-    {0x10400, 0x1049d}, /*    158x Deseret, Shavian, Osmanya */
-    {0x104b0, 0x104d3}, /*    36x Osage */
-    {0x104d8, 0x104fb}, /*    36x Osage */
-    {0x10500, 0x10527}, /*    40x Elbasan */
-    {0x10530, 0x10563}, /*    52x Caucasian Albanian */
-    {0x10600, 0x10736}, /*   311x Linear A */
-    {0x10800, 0x10805}, /*     6x Cypriot Syllabary */
-    {0x1080a, 0x10835}, /*    44x Cypriot Syllabary */
-    {0x10837, 0x10838}, /*     2x Cypriot Syllabary */
-    {0x1083f, 0x1089e}, /*    86x Cypriot,ImperialAramaic,Palmyrene,Nabataean */
-    {0x108e0, 0x108f2}, /*    19x Hatran */
-    {0x108f4, 0x108f5}, /*     2x Hatran */
-    {0x108fb, 0x1091b}, /*    33x Hatran */
-    {0x10920, 0x10939}, /*    26x Lydian */
-    {0x10980, 0x109b7}, /*    56x Meroitic Hieromarks */
-    {0x109bc, 0x109cf}, /*    20x Meroitic Cursive */
-    {0x109d2, 0x10a00}, /*    47x Meroitic Cursive */
-    {0x10a10, 0x10a13}, /*     4x Kharoshthi */
-    {0x10a15, 0x10a17}, /*     3x Kharoshthi */
-    {0x10a19, 0x10a35}, /*    29x Kharoshthi */
-    {0x10a40, 0x10a48}, /*     9x Kharoshthi */
-    {0x10a60, 0x10a7e}, /*    31x Old South Arabian */
-    {0x10a80, 0x10a9f}, /*    32x Old North Arabian */
-    {0x10ac0, 0x10ac7}, /*     8x Manichaean */
-    {0x10ac9, 0x10ae4}, /*    28x Manichaean */
-    {0x10aeb, 0x10aef}, /*     5x Manichaean */
-    {0x10b00, 0x10b35}, /*    54x Avestan */
-    {0x10b40, 0x10b55}, /*    22x Inscriptional Parthian */
-    {0x10b58, 0x10b72}, /*    27x Inscriptional Parthian and Pahlavi */
-    {0x10b78, 0x10b91}, /*    26x Inscriptional Pahlavi, Psalter Pahlavi */
-    {0x10c00, 0x10c48}, /*    73x Old Turkic */
-    {0x10c80, 0x10cb2}, /*    51x Old Hungarian */
-    {0x10cc0, 0x10cf2}, /*    51x Old Hungarian */
-    {0x10cfa, 0x10d23}, /*    42x Old Hungarian, Hanifi Rohingya */
-    {0x10d30, 0x10d39}, /*    10x Hanifi Rohingya */
-    {0x10e60, 0x10e7e}, /*    31x Rumi Numeral Symbols */
-    {0x10f00, 0x10f27}, /*    40x Old Sogdian */
-    {0x10f30, 0x10f45}, /*    22x Sogdian */
-    {0x10f51, 0x10f54}, /*     4x Sogdian */
-    {0x10fe0, 0x10ff6}, /*    23x Elymaic */
-    {0x11003, 0x11037}, /*    53x Brahmi */
-    {0x11052, 0x1106f}, /*    30x Brahmi */
-    {0x11083, 0x110af}, /*    45x Kaithi */
-    {0x110d0, 0x110e8}, /*    25x Sora Sompeng */
-    {0x110f0, 0x110f9}, /*    10x Sora Sompeng */
-    {0x11103, 0x11126}, /*    36x Chakma */
-    {0x11136, 0x1113f}, /*    10x Chakma */
-    {0x11144, 0x11144}, /*     1x Chakma */
-    {0x11150, 0x11172}, /*    35x Mahajani */
-    {0x11176, 0x11176}, /*     1x Mahajani */
-    {0x11183, 0x111b2}, /*    48x Sharada */
-    {0x111c1, 0x111c4}, /*     4x Sharada */
-    {0x111d0, 0x111da}, /*    11x Sharada */
-    {0x111dc, 0x111dc}, /*     1x Sharada */
-    {0x111e1, 0x111f4}, /*    20x Sinhala Archaic Numbers */
-    {0x11200, 0x11211}, /*    18x Khojki */
-    {0x11213, 0x1122b}, /*    25x Khojki */
-    {0x11280, 0x11286}, /*     7x Multani */
-    {0x11288, 0x11288}, /*     1x Multani */
-    {0x1128a, 0x1128d}, /*     4x Multani */
-    {0x1128f, 0x1129d}, /*    15x Multani */
-    {0x1129f, 0x112a8}, /*    10x Multani */
-    {0x112b0, 0x112de}, /*    47x Khudawadi */
-    {0x112f0, 0x112f9}, /*    10x Khudawadi */
-    {0x11305, 0x1130c}, /*     8x Grantha */
-    {0x1130f, 0x11310}, /*     2x Grantha */
-    {0x11313, 0x11328}, /*    22x Grantha */
-    {0x1132a, 0x11330}, /*     7x Grantha */
-    {0x11332, 0x11333}, /*     2x Grantha */
-    {0x11335, 0x11339}, /*     5x Grantha */
-    {0x1133d, 0x1133d}, /*     1x Grantha */
-    {0x11350, 0x11350}, /*     1x Grantha */
-    {0x1135d, 0x11361}, /*     5x Grantha */
-    {0x11400, 0x11434}, /*    53x Newa */
-    {0x11447, 0x1144a}, /*     4x Newa */
-    {0x11450, 0x11459}, /*    10x Newa */
-    {0x1145f, 0x1145f}, /*     1x Newa */
-    {0x11480, 0x114af}, /*    48x Tirhuta */
-    {0x114c4, 0x114c5}, /*     2x Tirhuta */
-    {0x114c7, 0x114c7}, /*     1x Tirhuta */
-    {0x114d0, 0x114d9}, /*    10x Tirhuta */
-    {0x11580, 0x115ae}, /*    47x Siddham */
-    {0x115d8, 0x115db}, /*     4x Siddham */
-    {0x11600, 0x1162f}, /*    48x Modi */
-    {0x11644, 0x11644}, /*     1x Modi */
-    {0x11650, 0x11659}, /*    10x Modi */
-    {0x11680, 0x116aa}, /*    43x Takri */
-    {0x116b8, 0x116b8}, /*     1x Takri */
-    {0x116c0, 0x116c9}, /*    10x Takri */
-    {0x11700, 0x1171a}, /*    27x Ahom */
-    {0x11730, 0x1173b}, /*    12x Ahom */
-    {0x11800, 0x1182b}, /*    44x Dogra */
-    {0x118a0, 0x118f2}, /*    83x Warang Citi */
-    {0x118ff, 0x118ff}, /*     1x Warang Citi */
-    {0x119a0, 0x119a7}, /*     8x Nandinagari */
-    {0x119aa, 0x119d0}, /*    39x Nandinagari */
-    {0x119e1, 0x119e1}, /*     1x Nandinagari */
-    {0x119e3, 0x119e3}, /*     1x Nandinagari */
-    {0x11a00, 0x11a00}, /*     1x Zanabazar Square */
-    {0x11a0b, 0x11a32}, /*    40x Zanabazar Square */
-    {0x11a3a, 0x11a3a}, /*     1x Zanabazar Square */
-    {0x11a50, 0x11a50}, /*     1x Soyombo */
-    {0x11a5c, 0x11a89}, /*    46x Soyombo */
-    {0x11a9d, 0x11a9d}, /*     1x Soyombo */
-    {0x11ac0, 0x11af8}, /*    57x Pau Cin Hau */
-    {0x11c00, 0x11c08}, /*     9x Bhaiksuki */
-    {0x11c0a, 0x11c2e}, /*    37x Bhaiksuki */
-    {0x11c40, 0x11c40}, /*     1x Bhaiksuki */
-    {0x11c50, 0x11c6c}, /*    29x Bhaiksuki */
-    {0x11c72, 0x11c8f}, /*    30x Marchen */
-    {0x11d00, 0x11d06}, /*     7x Masaram Gondi */
-    {0x11d08, 0x11d09}, /*     2x Masaram Gondi */
-    {0x11d0b, 0x11d30}, /*    38x Masaram Gondi */
-    {0x11d46, 0x11d46}, /*     1x Masaram Gondi */
-    {0x11d50, 0x11d59}, /*    10x Masaram Gondi */
-    {0x11d60, 0x11d65}, /*     6x Gunjala Gondi */
-    {0x11d67, 0x11d68}, /*     2x Gunjala Gondi */
-    {0x11d6a, 0x11d89}, /*    32x Gunjala Gondi */
-    {0x11d98, 0x11d98}, /*     1x Gunjala Gondi */
-    {0x11da0, 0x11da9}, /*    10x Gunjala Gondi */
-    {0x11ee0, 0x11ef2}, /*    19x Makasar */
-    {0x11fc0, 0x11fd4}, /*    21x Tamil Supplement */
-    {0x12000, 0x12399}, /*   922x Cuneiform */
-    {0x12400, 0x1246e}, /*   111x Cuneiform Numbers & Punctuation */
-    {0x12480, 0x12543}, /*   196x Early Dynastic Cuneiform */
-    {0x13000, 0x1342e}, /*  1071x Egyptian Hieromarks */
-    {0x14400, 0x14646}, /*   583x Anatolian Hieromarks */
-    {0x16800, 0x16a38}, /*   569x Bamum Supplement */
-    {0x16a40, 0x16a5e}, /*    31x Mro */
-    {0x16a60, 0x16a69}, /*    10x Mro */
-    {0x16ad0, 0x16aed}, /*    30x Bassa Vah */
-    {0x16b00, 0x16b2f}, /*    48x Pahawh Hmong */
-    {0x16b40, 0x16b43}, /*     4x Pahawh Hmong */
-    {0x16b50, 0x16b59}, /*    10x Pahawh Hmong */
-    {0x16b5b, 0x16b61}, /*     7x Pahawh Hmong */
-    {0x16b63, 0x16b77}, /*    21x Pahawh Hmong */
-    {0x16b7d, 0x16b8f}, /*    19x Pahawh Hmong */
-    {0x16e40, 0x16e96}, /*    87x Medefaidrin */
-    {0x16f00, 0x16f4a}, /*    75x Miao */
-    {0x16f50, 0x16f50}, /*     1x Miao */
-    {0x16f93, 0x16f9f}, /*    13x Miao */
-    {0x16fe0, 0x16fe1}, /*     2x Ideographic Symbols & Punctuation */
-    {0x16fe3, 0x16fe3}, /*     1x Ideographic Symbols & Punctuation */
-    {0x17000, 0x187f7}, /*  6136x Tangut */
-    {0x18800, 0x18af2}, /*   755x Tangut Components */
-    {0x1b000, 0x1b11e}, /*   287x Kana Supplement */
-    {0x1b150, 0x1b152}, /*     3x Small Kana Extension */
-    {0x1b164, 0x1b167}, /*     4x Small Kana Extension */
-    {0x1b170, 0x1b2fb}, /*   396x Nushu */
-    {0x1bc00, 0x1bc6a}, /*   107x Duployan */
-    {0x1bc70, 0x1bc7c}, /*    13x Duployan */
-    {0x1bc80, 0x1bc88}, /*     9x Duployan */
-    {0x1bc90, 0x1bc99}, /*    10x Duployan */
-    {0x1d2e0, 0x1d2f3}, /*    20x Mayan Numerals */
-    {0x1d360, 0x1d378}, /*    25x Counting Rod Numerals */
-    {0x1d400, 0x1d454}, /*    85x 𝐀..𝑔 Math */
-    {0x1d456, 0x1d49c}, /*    71x 𝑖..𝒜 Math */
-    {0x1d49e, 0x1d49f}, /*     2x 𝒞..𝒟 Math */
-    {0x1d4a2, 0x1d4a2}, /*     1x 𝒢..𝒢 Math */
-    {0x1d4a5, 0x1d4a6}, /*     2x 𝒥..𝒦 Math */
-    {0x1d4a9, 0x1d4ac}, /*     4x 𝒩..𝒬 Math */
-    {0x1d4ae, 0x1d4b9}, /*    12x 𝒮..𝒹 Math */
-    {0x1d4bb, 0x1d4bb}, /*     1x 𝒻..𝒻 Math */
-    {0x1d4bd, 0x1d4c3}, /*     7x 𝒽..𝓃 Math */
-    {0x1d4c5, 0x1d505}, /*    65x 𝓅..𝔅 Math */
-    {0x1d507, 0x1d50a}, /*     4x 𝔇..𝔊 Math */
-    {0x1d50d, 0x1d514}, /*     8x 𝔍..𝔔 Math */
-    {0x1d516, 0x1d51c}, /*     7x 𝔖..𝔜 Math */
-    {0x1d51e, 0x1d539}, /*    28x 𝔞..𝔹 Math */
-    {0x1d53b, 0x1d53e}, /*     4x 𝔻..𝔾 Math */
-    {0x1d540, 0x1d544}, /*     5x 𝕀..𝕄 Math */
-    {0x1d546, 0x1d546}, /*     1x 𝕆..𝕆 Math */
-    {0x1d54a, 0x1d550}, /*     7x 𝕊..𝕐 Math */
-    {0x1d552, 0x1d6a5}, /*   340x 𝕒..𝚥 Math */
-    {0x1d6a8, 0x1d6c0}, /*    25x 𝚨..𝛀 Math */
-    {0x1d6c2, 0x1d6da}, /*    25x 𝛂..𝛚 Math */
-    {0x1d6dc, 0x1d6fa}, /*    31x 𝛜..𝛺 Math */
-    {0x1d6fc, 0x1d714}, /*    25x 𝛼..𝜔 Math */
-    {0x1d716, 0x1d734}, /*    31x 𝜖..𝜴 Math */
-    {0x1d736, 0x1d74e}, /*    25x 𝜶..𝝎 Math */
-    {0x1d750, 0x1d76e}, /*    31x 𝝐..𝝮 Math */
-    {0x1d770, 0x1d788}, /*    25x 𝝰..𝞈 Math */
-    {0x1d78a, 0x1d7a8}, /*    31x 𝞊..𝞨 Math */
-    {0x1d7aa, 0x1d7c2}, /*    25x 𝞪..𝟂 Math */
-    {0x1d7c4, 0x1d7cb}, /*     8x 𝟄..𝟋 Math */
-    {0x1d7ce, 0x1d9ff}, /*   562x Math, Sutton SignWriting */
-    {0x1f100, 0x1f10c}, /*    13x Enclosed Alphanumeric Supplement */
-    {0x20000, 0x2a6d6}, /* 42711x CJK Unified Ideographs Extension B */
-    {0x2a700, 0x2b734}, /*  4149x CJK Unified Ideographs Extension C */
-    {0x2b740, 0x2b81d}, /*   222x CJK Unified Ideographs Extension D */
-    {0x2b820, 0x2cea1}, /*  5762x CJK Unified Ideographs Extension E */
-    {0x2ceb0, 0x2ebe0}, /*  7473x CJK Unified Ideographs Extension F */
-    {0x2f800, 0x2fa1d}, /*   542x CJK Compatibility Ideographs Supplement */
-};
-
-/**
- * Returns nonzero if 𝑐 isn't alphanumeric.
- *
- * Line reading interfaces generally define this operation as UNICODE
- * characters that aren't in the letter category (Lu, Ll, Lt, Lm, Lo)
- * and aren't in the number categorie (Nd, Nl, No). We also add a few
- * other things like blocks and emoji (So).
- */
-int iswseparator(wint_t c) {
-  int m, l, r, n;
-  if (c < 0200) {
-    return !(('0' <= c && c <= '9') || ('A' <= c && c <= 'Z') ||
-             ('a' <= c && c <= 'z'));
-  }
-  if (c <= 0xffff) {
-    l = 0;
-    r = n = sizeof(kCodes) / sizeof(kCodes[0]);
-    while (l < r) {
-      m = (l & r) + ((l ^ r) >> 1);  // floor((a+b)/2)
-      if (kCodes[m][1] < c) {
-        l = m + 1;
-      } else {
-        r = m;
-      }
-    }
-    return !(l < n && kCodes[l][0] <= c && c <= kCodes[l][1]);
-  } else {
-    l = 0;
-    r = n = sizeof(kAstralCodes) / sizeof(kAstralCodes[0]);
-    while (l < r) {
-      m = (l & r) + ((l ^ r) >> 1);  // floor((a+b)/2)
-      if (kAstralCodes[m][1] < c) {
-        l = m + 1;
-      } else {
-        r = m;
-      }
-    }
-    return !(l < n && kAstralCodes[l][0] <= c && c <= kAstralCodes[l][1]);
-  }
-}
diff --git a/libc/str/iswseparator.cc b/libc/str/iswseparator.cc
new file mode 100644
index 000000000..6ed2c7788
--- /dev/null
+++ b/libc/str/iswseparator.cc
@@ -0,0 +1,402 @@
+/*-*-mode:c++;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8-*-│
+│ vi: set et ft=c++ ts=2 sts=2 sw=2 fenc=utf-8                             :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/macros.h"
+#include "libc/str/has_char.h"
+#include "libc/wctype.h"
+
+static const unsigned short kSeparators[][2] = {
+    {0x00aa, 0x00aa}, /*     1x English */
+    {0x00b2, 0x00b3}, /*     2x English Arabic */
+    {0x00b5, 0x00b5}, /*     1x Greek */
+    {0x00b9, 0x00ba}, /*     2x English Arabic */
+    {0x00bc, 0x00be}, /*     3x Vulgar English Arabic */
+    {0x00c0, 0x00d6}, /*    23x Watin */
+    {0x00d8, 0x00f6}, /*    31x Watin */
+    {0x0100, 0x02c1}, /*   450x Watin-AB,IPA,Spacemod */
+    {0x02c6, 0x02d1}, /*    12x Spacemod */
+    {0x02e0, 0x02e4}, /*     5x Spacemod */
+    {0x02ec, 0x02ec}, /*     1x Spacemod */
+    {0x02ee, 0x02ee}, /*     1x Spacemod */
+    {0x0370, 0x0374}, /*     5x Greek */
+    {0x0376, 0x0377}, /*     2x Greek */
+    {0x037a, 0x037d}, /*     4x Greek */
+    {0x037f, 0x037f}, /*     1x Greek */
+    {0x0386, 0x0386}, /*     1x Greek */
+    {0x0388, 0x038a}, /*     3x Greek */
+    {0x038c, 0x038c}, /*     1x Greek */
+    {0x038e, 0x03a1}, /*    20x Greek */
+    {0x03a3, 0x03f5}, /*    83x Greek */
+    {0x03f7, 0x0481}, /*   139x Greek */
+    {0x048a, 0x052f}, /*   166x Cyrillic */
+    {0x0531, 0x0556}, /*    38x Armenian */
+    {0x0560, 0x0588}, /*    41x Armenian */
+    {0x05d0, 0x05ea}, /*    27x Hebrew */
+    {0x0620, 0x064a}, /*    43x Arabic */
+    {0x0660, 0x0669}, /*    10x Arabic */
+    {0x0671, 0x06d3}, /*    99x Arabic */
+    {0x06ee, 0x06fc}, /*    15x Arabic */
+    {0x0712, 0x072f}, /*    30x Syriac */
+    {0x074d, 0x07a5}, /*    89x Syriac,Arabic2,Thaana */
+    {0x07c0, 0x07ea}, /*    43x NKo */
+    {0x0800, 0x0815}, /*    22x Samaritan */
+    {0x0840, 0x0858}, /*    25x Mandaic */
+    {0x0904, 0x0939}, /*    54x Devanagari */
+    {0x0993, 0x09a8}, /*    22x Bengali */
+    {0x09e6, 0x09f1}, /*    12x Bengali */
+    {0x0a13, 0x0a28}, /*    22x Gurmukhi */
+    {0x0a66, 0x0a6f}, /*    10x Gurmukhi */
+    {0x0a93, 0x0aa8}, /*    22x Gujarati */
+    {0x0b13, 0x0b28}, /*    22x Oriya */
+    {0x0c92, 0x0ca8}, /*    23x Kannada */
+    {0x0caa, 0x0cb3}, /*    10x Kannada */
+    {0x0ce6, 0x0cef}, /*    10x Kannada */
+    {0x0d12, 0x0d3a}, /*    41x Malayalam */
+    {0x0d85, 0x0d96}, /*    18x Sinhala */
+    {0x0d9a, 0x0db1}, /*    24x Sinhala */
+    {0x0de6, 0x0def}, /*    10x Sinhala */
+    {0x0e01, 0x0e30}, /*    48x Thai */
+    {0x0e8c, 0x0ea3}, /*    24x Lao */
+    {0x0f20, 0x0f33}, /*    20x Tibetan */
+    {0x0f49, 0x0f6c}, /*    36x Tibetan */
+    {0x109e, 0x10c5}, /*    40x Myanmar,Georgian */
+    {0x10d0, 0x10fa}, /*    43x Georgian */
+    {0x10fc, 0x1248}, /*   333x Georgian,Hangul,Ethiopic */
+    {0x13a0, 0x13f5}, /*    86x Cherokee */
+    {0x1401, 0x166d}, /*   621x Aboriginal */
+    {0x16a0, 0x16ea}, /*    75x Runic */
+    {0x1700, 0x170c}, /*    13x Tagalog */
+    {0x1780, 0x17b3}, /*    52x Khmer */
+    {0x1820, 0x1878}, /*    89x Mongolian */
+    {0x1a00, 0x1a16}, /*    23x Buginese */
+    {0x1a20, 0x1a54}, /*    53x Tai Tham */
+    {0x1a80, 0x1a89}, /*    10x Tai Tham */
+    {0x1a90, 0x1a99}, /*    10x Tai Tham */
+    {0x1b05, 0x1b33}, /*    47x Balinese */
+    {0x1b50, 0x1b59}, /*    10x Balinese */
+    {0x1b83, 0x1ba0}, /*    30x Sundanese */
+    {0x1bae, 0x1be5}, /*    56x Sundanese */
+    {0x1c90, 0x1cba}, /*    43x Georgian2 */
+    {0x1cbd, 0x1cbf}, /*     3x Georgian2 */
+    {0x1e00, 0x1f15}, /*   278x Watin-C,Greek2 */
+    {0x2070, 0x2071}, /*     2x Supersub */
+    {0x2074, 0x2079}, /*     6x Supersub */
+    {0x207f, 0x2089}, /*    11x Supersub */
+    {0x2090, 0x209c}, /*    13x Supersub */
+    {0x2100, 0x2117}, /*    24x Letterlike */
+    {0x2119, 0x213f}, /*    39x Letterlike */
+    {0x2145, 0x214a}, /*     6x Letterlike */
+    {0x214c, 0x218b}, /*    64x Letterlike,Numbery */
+    {0x21af, 0x21cd}, /*    31x Arrows */
+    {0x21d5, 0x21f3}, /*    31x Arrows */
+    {0x230c, 0x231f}, /*    20x Technical */
+    {0x232b, 0x237b}, /*    81x Technical */
+    {0x237d, 0x239a}, /*    30x Technical */
+    {0x23b4, 0x23db}, /*    40x Technical */
+    {0x23e2, 0x2426}, /*    69x Technical,ControlPictures */
+    {0x2460, 0x25b6}, /*   343x Enclosed,Boxes,Blocks,Shapes */
+    {0x25c2, 0x25f7}, /*    54x Shapes */
+    {0x2600, 0x266e}, /*   111x Symbols */
+    {0x2670, 0x2767}, /*   248x Symbols,Dingbats */
+    {0x2776, 0x27bf}, /*    74x Dingbats */
+    {0x2800, 0x28ff}, /*   256x Braille */
+    {0x2c00, 0x2c2e}, /*    47x Glagolitic */
+    {0x2c30, 0x2c5e}, /*    47x Glagolitic */
+    {0x2c60, 0x2ce4}, /*   133x Watin-D */
+    {0x2d00, 0x2d25}, /*    38x Georgian2 */
+    {0x2d30, 0x2d67}, /*    56x Tifinagh */
+    {0x2d80, 0x2d96}, /*    23x Ethiopic2 */
+    {0x2e2f, 0x2e2f}, /*     1x Punctuation2 */
+    {0x3005, 0x3007}, /*     3x CJK Symbols & Punctuation */
+    {0x3021, 0x3029}, /*     9x CJK Symbols & Punctuation */
+    {0x3031, 0x3035}, /*     5x CJK Symbols & Punctuation */
+    {0x3038, 0x303c}, /*     5x CJK Symbols & Punctuation */
+    {0x3041, 0x3096}, /*    86x Hiragana */
+    {0x30a1, 0x30fa}, /*    90x Katakana */
+    {0x3105, 0x312f}, /*    43x Bopomofo */
+    {0x3131, 0x318e}, /*    94x Hangul Compatibility Jamo */
+    {0x31a0, 0x31ba}, /*    27x Bopomofo Extended */
+    {0x31f0, 0x31ff}, /*    16x Katakana Phonetic Extensions */
+    {0x3220, 0x3229}, /*    10x Enclosed CJK Letters & Months */
+    {0x3248, 0x324f}, /*     8x Enclosed CJK Letters & Months */
+    {0x3251, 0x325f}, /*    15x Enclosed CJK Letters & Months */
+    {0x3280, 0x3289}, /*    10x Enclosed CJK Letters & Months */
+    {0x32b1, 0x32bf}, /*    15x Enclosed CJK Letters & Months */
+    {0x3400, 0x4db5}, /*  6582x CJK Unified Ideographs Extension A */
+    {0x4dc0, 0x9fef}, /* 21040x Yijing Hexagram, CJK Unified Ideographs */
+    {0xa000, 0xa48c}, /*  1165x Yi Syllables */
+    {0xa4d0, 0xa4fd}, /*    46x Lisu */
+    {0xa500, 0xa60c}, /*   269x Vai */
+    {0xa610, 0xa62b}, /*    28x Vai */
+    {0xa6a0, 0xa6ef}, /*    80x Bamum */
+    {0xa80c, 0xa822}, /*    23x Syloti Nagri */
+    {0xa840, 0xa873}, /*    52x Phags-pa */
+    {0xa882, 0xa8b3}, /*    50x Saurashtra */
+    {0xa8d0, 0xa8d9}, /*    10x Saurashtra */
+    {0xa900, 0xa925}, /*    38x Kayah Li */
+    {0xa930, 0xa946}, /*    23x Rejang */
+    {0xa960, 0xa97c}, /*    29x Hangul Jamo Extended-A */
+    {0xa984, 0xa9b2}, /*    47x Javanese */
+    {0xa9cf, 0xa9d9}, /*    11x Javanese */
+    {0xaa00, 0xaa28}, /*    41x Cham */
+    {0xaa50, 0xaa59}, /*    10x Cham */
+    {0xabf0, 0xabf9}, /*    10x Meetei Mayek */
+    {0xac00, 0xd7a3}, /* 11172x Hangul Syllables */
+    {0xf900, 0xfa6d}, /*   366x CJK Compatibility Ideographs */
+    {0xfa70, 0xfad9}, /*   106x CJK Compatibility Ideographs */
+    {0xfb1f, 0xfb28}, /*    10x Alphabetic Presentation Forms */
+    {0xfb2a, 0xfb36}, /*    13x Alphabetic Presentation Forms */
+    {0xfb46, 0xfbb1}, /*   108x Alphabetic Presentation Forms */
+    {0xfbd3, 0xfd3d}, /*   363x Arabic Presentation Forms-A */
+    {0xfe76, 0xfefc}, /*   135x Arabic Presentation Forms-B */
+    {0xff10, 0xff19}, /*    10x Dubs */
+    {0xff21, 0xff3a}, /*    26x Dubs */
+    {0xff41, 0xff5a}, /*    26x Dubs */
+    {0xff66, 0xffbe}, /*    89x Dubs */
+    {0xffc2, 0xffc7}, /*     6x Dubs */
+    {0xffca, 0xffcf}, /*     6x Dubs */
+    {0xffd2, 0xffd7}, /*     6x Dubs */
+    {0xffda, 0xffdc}, /*     3x Dubs */
+};
+
+static const unsigned kAstralSeparators[][2] = {
+    {0x10107, 0x10133}, /*    45x Aegean */
+    {0x10140, 0x10178}, /*    57x Ancient Greek Numbers */
+    {0x1018a, 0x1018b}, /*     2x Ancient Greek Numbers */
+    {0x10280, 0x1029c}, /*    29x Lycian */
+    {0x102a0, 0x102d0}, /*    49x Carian */
+    {0x102e1, 0x102fb}, /*    27x Coptic Epact Numbers */
+    {0x10300, 0x10323}, /*    36x Old Italic */
+    {0x1032d, 0x1034a}, /*    30x Old Italic, Gothic */
+    {0x10350, 0x10375}, /*    38x Old Permic */
+    {0x10380, 0x1039d}, /*    30x Ugaritic */
+    {0x103a0, 0x103c3}, /*    36x Old Persian */
+    {0x103c8, 0x103cf}, /*     8x Old Persian */
+    {0x103d1, 0x103d5}, /*     5x Old Persian */
+    {0x10400, 0x1049d}, /*    158x Deseret, Shavian, Osmanya */
+    {0x104b0, 0x104d3}, /*    36x Osage */
+    {0x104d8, 0x104fb}, /*    36x Osage */
+    {0x10500, 0x10527}, /*    40x Elbasan */
+    {0x10530, 0x10563}, /*    52x Caucasian Albanian */
+    {0x10600, 0x10736}, /*   311x Linear A */
+    {0x10800, 0x10805}, /*     6x Cypriot Syllabary */
+    {0x1080a, 0x10835}, /*    44x Cypriot Syllabary */
+    {0x10837, 0x10838}, /*     2x Cypriot Syllabary */
+    {0x1083f, 0x1089e}, /*    86x Cypriot,ImperialAramaic,Palmyrene,Nabataean */
+    {0x108e0, 0x108f2}, /*    19x Hatran */
+    {0x108f4, 0x108f5}, /*     2x Hatran */
+    {0x108fb, 0x1091b}, /*    33x Hatran */
+    {0x10920, 0x10939}, /*    26x Lydian */
+    {0x10980, 0x109b7}, /*    56x Meroitic Hieromarks */
+    {0x109bc, 0x109cf}, /*    20x Meroitic Cursive */
+    {0x109d2, 0x10a00}, /*    47x Meroitic Cursive */
+    {0x10a10, 0x10a13}, /*     4x Kharoshthi */
+    {0x10a15, 0x10a17}, /*     3x Kharoshthi */
+    {0x10a19, 0x10a35}, /*    29x Kharoshthi */
+    {0x10a40, 0x10a48}, /*     9x Kharoshthi */
+    {0x10a60, 0x10a7e}, /*    31x Old South Arabian */
+    {0x10a80, 0x10a9f}, /*    32x Old North Arabian */
+    {0x10ac0, 0x10ac7}, /*     8x Manichaean */
+    {0x10ac9, 0x10ae4}, /*    28x Manichaean */
+    {0x10aeb, 0x10aef}, /*     5x Manichaean */
+    {0x10b00, 0x10b35}, /*    54x Avestan */
+    {0x10b40, 0x10b55}, /*    22x Inscriptional Parthian */
+    {0x10b58, 0x10b72}, /*    27x Inscriptional Parthian and Pahlavi */
+    {0x10b78, 0x10b91}, /*    26x Inscriptional Pahlavi, Psalter Pahlavi */
+    {0x10c00, 0x10c48}, /*    73x Old Turkic */
+    {0x10c80, 0x10cb2}, /*    51x Old Hungarian */
+    {0x10cc0, 0x10cf2}, /*    51x Old Hungarian */
+    {0x10cfa, 0x10d23}, /*    42x Old Hungarian, Hanifi Rohingya */
+    {0x10d30, 0x10d39}, /*    10x Hanifi Rohingya */
+    {0x10e60, 0x10e7e}, /*    31x Rumi Numeral Symbols */
+    {0x10f00, 0x10f27}, /*    40x Old Sogdian */
+    {0x10f30, 0x10f45}, /*    22x Sogdian */
+    {0x10f51, 0x10f54}, /*     4x Sogdian */
+    {0x10fe0, 0x10ff6}, /*    23x Elymaic */
+    {0x11003, 0x11037}, /*    53x Brahmi */
+    {0x11052, 0x1106f}, /*    30x Brahmi */
+    {0x11083, 0x110af}, /*    45x Kaithi */
+    {0x110d0, 0x110e8}, /*    25x Sora Sompeng */
+    {0x110f0, 0x110f9}, /*    10x Sora Sompeng */
+    {0x11103, 0x11126}, /*    36x Chakma */
+    {0x11136, 0x1113f}, /*    10x Chakma */
+    {0x11144, 0x11144}, /*     1x Chakma */
+    {0x11150, 0x11172}, /*    35x Mahajani */
+    {0x11176, 0x11176}, /*     1x Mahajani */
+    {0x11183, 0x111b2}, /*    48x Sharada */
+    {0x111c1, 0x111c4}, /*     4x Sharada */
+    {0x111d0, 0x111da}, /*    11x Sharada */
+    {0x111dc, 0x111dc}, /*     1x Sharada */
+    {0x111e1, 0x111f4}, /*    20x Sinhala Archaic Numbers */
+    {0x11200, 0x11211}, /*    18x Khojki */
+    {0x11213, 0x1122b}, /*    25x Khojki */
+    {0x11280, 0x11286}, /*     7x Multani */
+    {0x11288, 0x11288}, /*     1x Multani */
+    {0x1128a, 0x1128d}, /*     4x Multani */
+    {0x1128f, 0x1129d}, /*    15x Multani */
+    {0x1129f, 0x112a8}, /*    10x Multani */
+    {0x112b0, 0x112de}, /*    47x Khudawadi */
+    {0x112f0, 0x112f9}, /*    10x Khudawadi */
+    {0x11305, 0x1130c}, /*     8x Grantha */
+    {0x1130f, 0x11310}, /*     2x Grantha */
+    {0x11313, 0x11328}, /*    22x Grantha */
+    {0x1132a, 0x11330}, /*     7x Grantha */
+    {0x11332, 0x11333}, /*     2x Grantha */
+    {0x11335, 0x11339}, /*     5x Grantha */
+    {0x1133d, 0x1133d}, /*     1x Grantha */
+    {0x11350, 0x11350}, /*     1x Grantha */
+    {0x1135d, 0x11361}, /*     5x Grantha */
+    {0x11400, 0x11434}, /*    53x Newa */
+    {0x11447, 0x1144a}, /*     4x Newa */
+    {0x11450, 0x11459}, /*    10x Newa */
+    {0x1145f, 0x1145f}, /*     1x Newa */
+    {0x11480, 0x114af}, /*    48x Tirhuta */
+    {0x114c4, 0x114c5}, /*     2x Tirhuta */
+    {0x114c7, 0x114c7}, /*     1x Tirhuta */
+    {0x114d0, 0x114d9}, /*    10x Tirhuta */
+    {0x11580, 0x115ae}, /*    47x Siddham */
+    {0x115d8, 0x115db}, /*     4x Siddham */
+    {0x11600, 0x1162f}, /*    48x Modi */
+    {0x11644, 0x11644}, /*     1x Modi */
+    {0x11650, 0x11659}, /*    10x Modi */
+    {0x11680, 0x116aa}, /*    43x Takri */
+    {0x116b8, 0x116b8}, /*     1x Takri */
+    {0x116c0, 0x116c9}, /*    10x Takri */
+    {0x11700, 0x1171a}, /*    27x Ahom */
+    {0x11730, 0x1173b}, /*    12x Ahom */
+    {0x11800, 0x1182b}, /*    44x Dogra */
+    {0x118a0, 0x118f2}, /*    83x Warang Citi */
+    {0x118ff, 0x118ff}, /*     1x Warang Citi */
+    {0x119a0, 0x119a7}, /*     8x Nandinagari */
+    {0x119aa, 0x119d0}, /*    39x Nandinagari */
+    {0x119e1, 0x119e1}, /*     1x Nandinagari */
+    {0x119e3, 0x119e3}, /*     1x Nandinagari */
+    {0x11a00, 0x11a00}, /*     1x Zanabazar Square */
+    {0x11a0b, 0x11a32}, /*    40x Zanabazar Square */
+    {0x11a3a, 0x11a3a}, /*     1x Zanabazar Square */
+    {0x11a50, 0x11a50}, /*     1x Soyombo */
+    {0x11a5c, 0x11a89}, /*    46x Soyombo */
+    {0x11a9d, 0x11a9d}, /*     1x Soyombo */
+    {0x11ac0, 0x11af8}, /*    57x Pau Cin Hau */
+    {0x11c00, 0x11c08}, /*     9x Bhaiksuki */
+    {0x11c0a, 0x11c2e}, /*    37x Bhaiksuki */
+    {0x11c40, 0x11c40}, /*     1x Bhaiksuki */
+    {0x11c50, 0x11c6c}, /*    29x Bhaiksuki */
+    {0x11c72, 0x11c8f}, /*    30x Marchen */
+    {0x11d00, 0x11d06}, /*     7x Masaram Gondi */
+    {0x11d08, 0x11d09}, /*     2x Masaram Gondi */
+    {0x11d0b, 0x11d30}, /*    38x Masaram Gondi */
+    {0x11d46, 0x11d46}, /*     1x Masaram Gondi */
+    {0x11d50, 0x11d59}, /*    10x Masaram Gondi */
+    {0x11d60, 0x11d65}, /*     6x Gunjala Gondi */
+    {0x11d67, 0x11d68}, /*     2x Gunjala Gondi */
+    {0x11d6a, 0x11d89}, /*    32x Gunjala Gondi */
+    {0x11d98, 0x11d98}, /*     1x Gunjala Gondi */
+    {0x11da0, 0x11da9}, /*    10x Gunjala Gondi */
+    {0x11ee0, 0x11ef2}, /*    19x Makasar */
+    {0x11fc0, 0x11fd4}, /*    21x Tamil Supplement */
+    {0x12000, 0x12399}, /*   922x Cuneiform */
+    {0x12400, 0x1246e}, /*   111x Cuneiform Numbers & Punctuation */
+    {0x12480, 0x12543}, /*   196x Early Dynastic Cuneiform */
+    {0x13000, 0x1342e}, /*  1071x Egyptian Hieromarks */
+    {0x14400, 0x14646}, /*   583x Anatolian Hieromarks */
+    {0x16800, 0x16a38}, /*   569x Bamum Supplement */
+    {0x16a40, 0x16a5e}, /*    31x Mro */
+    {0x16a60, 0x16a69}, /*    10x Mro */
+    {0x16ad0, 0x16aed}, /*    30x Bassa Vah */
+    {0x16b00, 0x16b2f}, /*    48x Pahawh Hmong */
+    {0x16b40, 0x16b43}, /*     4x Pahawh Hmong */
+    {0x16b50, 0x16b59}, /*    10x Pahawh Hmong */
+    {0x16b5b, 0x16b61}, /*     7x Pahawh Hmong */
+    {0x16b63, 0x16b77}, /*    21x Pahawh Hmong */
+    {0x16b7d, 0x16b8f}, /*    19x Pahawh Hmong */
+    {0x16e40, 0x16e96}, /*    87x Medefaidrin */
+    {0x16f00, 0x16f4a}, /*    75x Miao */
+    {0x16f50, 0x16f50}, /*     1x Miao */
+    {0x16f93, 0x16f9f}, /*    13x Miao */
+    {0x16fe0, 0x16fe1}, /*     2x Ideographic Symbols & Punctuation */
+    {0x16fe3, 0x16fe3}, /*     1x Ideographic Symbols & Punctuation */
+    {0x17000, 0x187f7}, /*  6136x Tangut */
+    {0x18800, 0x18af2}, /*   755x Tangut Components */
+    {0x1b000, 0x1b11e}, /*   287x Kana Supplement */
+    {0x1b150, 0x1b152}, /*     3x Small Kana Extension */
+    {0x1b164, 0x1b167}, /*     4x Small Kana Extension */
+    {0x1b170, 0x1b2fb}, /*   396x Nushu */
+    {0x1bc00, 0x1bc6a}, /*   107x Duployan */
+    {0x1bc70, 0x1bc7c}, /*    13x Duployan */
+    {0x1bc80, 0x1bc88}, /*     9x Duployan */
+    {0x1bc90, 0x1bc99}, /*    10x Duployan */
+    {0x1d2e0, 0x1d2f3}, /*    20x Mayan Numerals */
+    {0x1d360, 0x1d378}, /*    25x Counting Rod Numerals */
+    {0x1d400, 0x1d454}, /*    85x 𝐀..𝑔 Math */
+    {0x1d456, 0x1d49c}, /*    71x 𝑖..𝒜 Math */
+    {0x1d49e, 0x1d49f}, /*     2x 𝒞..𝒟 Math */
+    {0x1d4a2, 0x1d4a2}, /*     1x 𝒢..𝒢 Math */
+    {0x1d4a5, 0x1d4a6}, /*     2x 𝒥..𝒦 Math */
+    {0x1d4a9, 0x1d4ac}, /*     4x 𝒩..𝒬 Math */
+    {0x1d4ae, 0x1d4b9}, /*    12x 𝒮..𝒹 Math */
+    {0x1d4bb, 0x1d4bb}, /*     1x 𝒻..𝒻 Math */
+    {0x1d4bd, 0x1d4c3}, /*     7x 𝒽..𝓃 Math */
+    {0x1d4c5, 0x1d505}, /*    65x 𝓅..𝔅 Math */
+    {0x1d507, 0x1d50a}, /*     4x 𝔇..𝔊 Math */
+    {0x1d50d, 0x1d514}, /*     8x 𝔍..𝔔 Math */
+    {0x1d516, 0x1d51c}, /*     7x 𝔖..𝔜 Math */
+    {0x1d51e, 0x1d539}, /*    28x 𝔞..𝔹 Math */
+    {0x1d53b, 0x1d53e}, /*     4x 𝔻..𝔾 Math */
+    {0x1d540, 0x1d544}, /*     5x 𝕀..𝕄 Math */
+    {0x1d546, 0x1d546}, /*     1x 𝕆..𝕆 Math */
+    {0x1d54a, 0x1d550}, /*     7x 𝕊..𝕐 Math */
+    {0x1d552, 0x1d6a5}, /*   340x 𝕒..𝚥 Math */
+    {0x1d6a8, 0x1d6c0}, /*    25x 𝚨..𝛀 Math */
+    {0x1d6c2, 0x1d6da}, /*    25x 𝛂..𝛚 Math */
+    {0x1d6dc, 0x1d6fa}, /*    31x 𝛜..𝛺 Math */
+    {0x1d6fc, 0x1d714}, /*    25x 𝛼..𝜔 Math */
+    {0x1d716, 0x1d734}, /*    31x 𝜖..𝜴 Math */
+    {0x1d736, 0x1d74e}, /*    25x 𝜶..𝝎 Math */
+    {0x1d750, 0x1d76e}, /*    31x 𝝐..𝝮 Math */
+    {0x1d770, 0x1d788}, /*    25x 𝝰..𝞈 Math */
+    {0x1d78a, 0x1d7a8}, /*    31x 𝞊..𝞨 Math */
+    {0x1d7aa, 0x1d7c2}, /*    25x 𝞪..𝟂 Math */
+    {0x1d7c4, 0x1d7cb}, /*     8x 𝟄..𝟋 Math */
+    {0x1d7ce, 0x1d9ff}, /*   562x Math, Sutton SignWriting */
+    {0x1f100, 0x1f10c}, /*    13x Enclosed Alphanumeric Supplement */
+    {0x20000, 0x2a6d6}, /* 42711x CJK Unified Ideographs Extension B */
+    {0x2a700, 0x2b734}, /*  4149x CJK Unified Ideographs Extension C */
+    {0x2b740, 0x2b81d}, /*   222x CJK Unified Ideographs Extension D */
+    {0x2b820, 0x2cea1}, /*  5762x CJK Unified Ideographs Extension E */
+    {0x2ceb0, 0x2ebe0}, /*  7473x CJK Unified Ideographs Extension F */
+    {0x2f800, 0x2fa1d}, /*   542x CJK Compatibility Ideographs Supplement */
+};
+
+/**
+ * Returns nonzero if 𝑐 isn't alphanumeric.
+ *
+ * Line reading interfaces generally define this operation as UNICODE
+ * characters that aren't in the letter category (Lu, Ll, Lt, Lm, Lo)
+ * and aren't in the number categorie (Nd, Nl, No). We also add a few
+ * other things like blocks and emoji (So).
+ */
+int iswseparator(wint_t c) {
+  if (c < 128)
+    return !(('0' <= c && c <= '9') ||  //
+             ('A' <= c && c <= 'Z') ||  //
+             ('a' <= c && c <= 'z'));
+  if (c < 65536)
+    return has_char(kSeparators, ARRAYLEN(kSeparators), (unsigned short)c);
+  return has_char(kAstralSeparators, ARRAYLEN(kAstralSeparators), (unsigned)c);
+}
diff --git a/libc/str/iswspace.c b/libc/str/iswspace.c
index d97a48242..097e6ce51 100644
--- a/libc/str/iswspace.c
+++ b/libc/str/iswspace.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Returns nonzero if c is space character.
@@ -41,7 +41,6 @@ int iswspace(wint_t c) {
     case 0x2004:  // THREE-PER-EM SPACE (Zs)
     case 0x2005:  // FOUR-PER-EM SPACE (Zs)
     case 0x2006:  // SIX-PER-EM SPACE (Zs)
-    case 0x2007:  // FIGURE SPACE (Zs)
     case 0x2008:  // PUNCTUATION SPACE (Zs)
     case 0x2009:  // THIN SPACE (Zs)
     case 0x200a:  // HAIR SPACE (Zs)
diff --git a/libc/str/iswupper.c b/libc/str/iswupper.c
deleted file mode 100644
index f965d51a6..000000000
--- a/libc/str/iswupper.c
+++ /dev/null
@@ -1,164 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-/**
- * Returns nonzero if c is uppercase letter.
- */
-int iswupper(wint_t c) {
-  if (c < 0200) {
-    return 'A' <= c && c <= 'Z';
-  } else {
-    if (towlower(c) != c)
-      return 1;
-    switch (c) {
-      case 0x03d2:  /* ϒ Greek */
-      case 0x03d3:  /* ϓ Greek */
-      case 0x03d4:  /* ϔ Greek */
-      case 0x2102:  /* ℂ Letterlike */
-      case 0x2107:  /* ℇ Letterlike */
-      case 0x210b:  /* ℋ Letterlike */
-      case 0x210c:  /* ℌ Letterlike */
-      case 0x210d:  /* ℍ Letterlike */
-      case 0x2110:  /* ℐ Letterlike */
-      case 0x2111:  /* ℑ Letterlike */
-      case 0x2112:  /* ℒ Letterlike */
-      case 0x2115:  /* ℕ Letterlike */
-      case 0x2119:  /* ℙ Letterlike */
-      case 0x211a:  /* ℚ Letterlike */
-      case 0x211b:  /* ℛ Letterlike */
-      case 0x211c:  /* ℜ Letterlike */
-      case 0x211d:  /* ℝ Letterlike */
-      case 0x2124:  /* ℤ Letterlike */
-      case 0x2128:  /* ℨ Letterlike */
-      case 0x212c:  /* ℬ Letterlike */
-      case 0x212d:  /* ℭ Letterlike */
-      case 0x2130:  /* ℰ Letterlike */
-      case 0x2131:  /* ℱ Letterlike */
-      case 0x2133:  /* ℳ Letterlike */
-      case 0x213e:  /* ℾ Letterlike */
-      case 0x213f:  /* ℿ Letterlike */
-      case 0x2145:  /* ⅅ Letterlike */
-      case 0x1d434: /* 𝐴 Math */
-      case 0x1d435: /* 𝐵 Math */
-      case 0x1d436: /* 𝐶 Math */
-      case 0x1d437: /* 𝐷 Math */
-      case 0x1d438: /* 𝐸 Math */
-      case 0x1d439: /* 𝐹 Math */
-      case 0x1d43a: /* 𝐺 Math */
-      case 0x1d43b: /* 𝐻 Math */
-      case 0x1d49c: /* 𝒜 Math */
-      case 0x1d49e: /* 𝒞 Math */
-      case 0x1d49f: /* 𝒟 Math */
-      case 0x1d4a2: /* 𝒢 Math */
-      case 0x1d4a5: /* 𝒥 Math */
-      case 0x1d4a6: /* 𝒦 Math */
-      case 0x1d4a9: /* 𝒩 Math */
-      case 0x1d4aa: /* 𝒪 Math */
-      case 0x1d4ab: /* 𝒫 Math */
-      case 0x1d4ac: /* 𝒬 Math */
-      case 0x1d504: /* 𝔄 Math */
-      case 0x1d505: /* 𝔅 Math */
-      case 0x1d507: /* 𝔇 Math */
-      case 0x1d508: /* 𝔈 Math */
-      case 0x1d509: /* 𝔉 Math */
-      case 0x1d50a: /* 𝔊 Math */
-      case 0x1d516: /* 𝔖 Math */
-      case 0x1d517: /* 𝔗 Math */
-      case 0x1d518: /* 𝔘 Math */
-      case 0x1d519: /* 𝔙 Math */
-      case 0x1d51a: /* 𝔚 Math */
-      case 0x1d51b: /* 𝔛 Math */
-      case 0x1d51c: /* 𝔜 Math */
-      case 0x1d538: /* 𝔸 Math */
-      case 0x1d539: /* 𝔹 Math */
-      case 0x1d53b: /* 𝔻 Math */
-      case 0x1d53c: /* 𝔼 Math */
-      case 0x1d53d: /* 𝔽 Math */
-      case 0x1d53e: /* 𝔾 Math */
-      case 0x1d540: /* 𝕀 Math */
-      case 0x1d541: /* 𝕁 Math */
-      case 0x1d542: /* 𝕂 Math */
-      case 0x1d543: /* 𝕃 Math */
-      case 0x1d544: /* 𝕄 Math */
-      case 0x1d546: /* 𝕆 Math */
-      case 0x1d54a: /* 𝕊 Math */
-      case 0x1d54b: /* 𝕋 Math */
-      case 0x1d54c: /* 𝕌 Math */
-      case 0x1d54d: /* 𝕍 Math */
-      case 0x1d54e: /* 𝕎 Math */
-      case 0x1d54f: /* 𝕏 Math */
-      case 0x1d550: /* 𝕐 Math */
-      case 0x1d6e3: /* 𝛣 Math */
-      case 0x1d6e4: /* 𝛤 Math */
-      case 0x1d6e5: /* 𝛥 Math */
-      case 0x1d6e6: /* 𝛦 Math */
-      case 0x1d6e7: /* 𝛧 Math */
-      case 0x1d6e8: /* 𝛨 Math */
-      case 0x1d6e9: /* 𝛩 Math */
-      case 0x1d6ea: /* 𝛪 Math */
-      case 0x1d6eb: /* 𝛫 Math */
-      case 0x1d6ec: /* 𝛬 Math */
-      case 0x1d6ed: /* 𝛭 Math */
-      case 0x1d6ee: /* 𝛮 Math */
-      case 0x1d6ef: /* 𝛯 Math */
-      case 0x1d6f0: /* 𝛰 Math */
-      case 0x1d6f1: /* 𝛱 Math */
-      case 0x1d6f2: /* 𝛲 Math */
-      case 0x1d6f3: /* 𝛳 Math */
-      case 0x1d6f4: /* 𝛴 Math */
-      case 0x1d6f5: /* 𝛵 Math */
-      case 0x1d6f6: /* 𝛶 Math */
-      case 0x1d6f7: /* 𝛷 Math */
-      case 0x1d6f8: /* 𝛸 Math */
-      case 0x1d6f9: /* 𝛹 Math */
-      case 0x1d6fa: /* 𝛺 Math */
-      case 0x1d72d: /* 𝜭 Math */
-      case 0x1d72e: /* 𝜮 Math */
-      case 0x1d72f: /* 𝜯 Math */
-      case 0x1d730: /* 𝜰 Math */
-      case 0x1d731: /* 𝜱 Math */
-      case 0x1d732: /* 𝜲 Math */
-      case 0x1d733: /* 𝜳 Math */
-      case 0x1d734: /* 𝜴 Math */
-      case 0x1d767: /* 𝝧 Math */
-      case 0x1d768: /* 𝝨 Math */
-      case 0x1d769: /* 𝝩 Math */
-      case 0x1d76a: /* 𝝪 Math */
-      case 0x1d76b: /* 𝝫 Math */
-      case 0x1d76c: /* 𝝬 Math */
-      case 0x1d76d: /* 𝝭 Math */
-      case 0x1d76e: /* 𝝮 Math */
-      case 0x1d7a1: /* 𝞡 Math */
-      case 0x1d7a2: /* 𝞢 Math */
-      case 0x1d7a3: /* 𝞣 Math */
-      case 0x1d7a4: /* 𝞤 Math */
-      case 0x1d7a5: /* 𝞥 Math */
-      case 0x1d7a6: /* 𝞦 Math */
-      case 0x1d7a7: /* 𝞧 Math */
-      case 0x1d7a8: /* 𝞨 Math */
-      case 0x1d7ca: /* 𝟊 Math */
-        return 1;
-      default:
-        return 0;
-    }
-  }
-}
-
-__weak_reference(iswupper, iswupper_l);
diff --git a/libc/str/iswupper.cc b/libc/str/iswupper.cc
new file mode 100644
index 000000000..4db11a3f4
--- /dev/null
+++ b/libc/str/iswupper.cc
@@ -0,0 +1,695 @@
+/*-*-mode:c++;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8-*-│
+│ vi: set et ft=c++ ts=2 sts=2 sw=2 fenc=utf-8                             :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/dce.h"
+#include "libc/macros.h"
+#include "libc/str/has_char.h"
+#include "libc/wctype.h"
+
+static const unsigned short kUpper[][2] = {
+    {0x41, 0x5a},      //
+    {0xc0, 0xd6},      //
+    {0xd8, 0xde},      //
+    {0x100, 0x100},    //
+    {0x102, 0x102},    //
+    {0x104, 0x104},    //
+    {0x106, 0x106},    //
+    {0x108, 0x108},    //
+    {0x10a, 0x10a},    //
+    {0x10c, 0x10c},    //
+    {0x10e, 0x10e},    //
+    {0x110, 0x110},    //
+    {0x112, 0x112},    //
+    {0x114, 0x114},    //
+    {0x116, 0x116},    //
+    {0x118, 0x118},    //
+    {0x11a, 0x11a},    //
+    {0x11c, 0x11c},    //
+    {0x11e, 0x11e},    //
+    {0x120, 0x120},    //
+    {0x122, 0x122},    //
+    {0x124, 0x124},    //
+    {0x126, 0x126},    //
+    {0x128, 0x128},    //
+    {0x12a, 0x12a},    //
+    {0x12c, 0x12c},    //
+    {0x12e, 0x12e},    //
+    {0x130, 0x130},    //
+    {0x132, 0x132},    //
+    {0x134, 0x134},    //
+    {0x136, 0x136},    //
+    {0x139, 0x139},    //
+    {0x13b, 0x13b},    //
+    {0x13d, 0x13d},    //
+    {0x13f, 0x13f},    //
+    {0x141, 0x141},    //
+    {0x143, 0x143},    //
+    {0x145, 0x145},    //
+    {0x147, 0x147},    //
+    {0x14a, 0x14a},    //
+    {0x14c, 0x14c},    //
+    {0x14e, 0x14e},    //
+    {0x150, 0x150},    //
+    {0x152, 0x152},    //
+    {0x154, 0x154},    //
+    {0x156, 0x156},    //
+    {0x158, 0x158},    //
+    {0x15a, 0x15a},    //
+    {0x15c, 0x15c},    //
+    {0x15e, 0x15e},    //
+    {0x160, 0x160},    //
+    {0x162, 0x162},    //
+    {0x164, 0x164},    //
+    {0x166, 0x166},    //
+    {0x168, 0x168},    //
+    {0x16a, 0x16a},    //
+    {0x16c, 0x16c},    //
+    {0x16e, 0x16e},    //
+    {0x170, 0x170},    //
+    {0x172, 0x172},    //
+    {0x174, 0x174},    //
+    {0x176, 0x176},    //
+    {0x178, 0x179},    //
+    {0x17b, 0x17b},    //
+    {0x17d, 0x17d},    //
+    {0x181, 0x182},    //
+    {0x184, 0x184},    //
+    {0x186, 0x187},    //
+    {0x189, 0x18b},    //
+    {0x18e, 0x191},    //
+    {0x193, 0x194},    //
+    {0x196, 0x198},    //
+    {0x19c, 0x19d},    //
+    {0x19f, 0x1a0},    //
+    {0x1a2, 0x1a2},    //
+    {0x1a4, 0x1a4},    //
+    {0x1a6, 0x1a7},    //
+    {0x1a9, 0x1a9},    //
+    {0x1ac, 0x1ac},    //
+    {0x1ae, 0x1af},    //
+    {0x1b1, 0x1b3},    //
+    {0x1b5, 0x1b5},    //
+    {0x1b7, 0x1b8},    //
+    {0x1bc, 0x1bc},    //
+    {0x1c4, 0x1c5},    //
+    {0x1c7, 0x1c8},    //
+    {0x1ca, 0x1cb},    //
+    {0x1cd, 0x1cd},    //
+    {0x1cf, 0x1cf},    //
+    {0x1d1, 0x1d1},    //
+    {0x1d3, 0x1d3},    //
+    {0x1d5, 0x1d5},    //
+    {0x1d7, 0x1d7},    //
+    {0x1d9, 0x1d9},    //
+    {0x1db, 0x1db},    //
+    {0x1de, 0x1de},    //
+    {0x1e0, 0x1e0},    //
+    {0x1e2, 0x1e2},    //
+    {0x1e4, 0x1e4},    //
+    {0x1e6, 0x1e6},    //
+    {0x1e8, 0x1e8},    //
+    {0x1ea, 0x1ea},    //
+    {0x1ec, 0x1ec},    //
+    {0x1ee, 0x1ee},    //
+    {0x1f1, 0x1f2},    //
+    {0x1f4, 0x1f4},    //
+    {0x1f6, 0x1f8},    //
+    {0x1fa, 0x1fa},    //
+    {0x1fc, 0x1fc},    //
+    {0x1fe, 0x1fe},    //
+    {0x200, 0x200},    //
+    {0x202, 0x202},    //
+    {0x204, 0x204},    //
+    {0x206, 0x206},    //
+    {0x208, 0x208},    //
+    {0x20a, 0x20a},    //
+    {0x20c, 0x20c},    //
+    {0x20e, 0x20e},    //
+    {0x210, 0x210},    //
+    {0x212, 0x212},    //
+    {0x214, 0x214},    //
+    {0x216, 0x216},    //
+    {0x218, 0x218},    //
+    {0x21a, 0x21a},    //
+    {0x21c, 0x21c},    //
+    {0x21e, 0x21e},    //
+    {0x220, 0x220},    //
+    {0x222, 0x222},    //
+    {0x224, 0x224},    //
+    {0x226, 0x226},    //
+    {0x228, 0x228},    //
+    {0x22a, 0x22a},    //
+    {0x22c, 0x22c},    //
+    {0x22e, 0x22e},    //
+    {0x230, 0x230},    //
+    {0x232, 0x232},    //
+    {0x23a, 0x23b},    //
+    {0x23d, 0x23e},    //
+    {0x241, 0x241},    //
+    {0x243, 0x246},    //
+    {0x248, 0x248},    //
+    {0x24a, 0x24a},    //
+    {0x24c, 0x24c},    //
+    {0x24e, 0x24e},    //
+    {0x370, 0x370},    //
+    {0x372, 0x372},    //
+    {0x376, 0x376},    //
+    {0x37f, 0x37f},    //
+    {0x386, 0x386},    //
+    {0x388, 0x38a},    //
+    {0x38c, 0x38c},    //
+    {0x38e, 0x38f},    //
+    {0x391, 0x3a1},    //
+    {0x3a3, 0x3ab},    //
+    {0x3cf, 0x3cf},    //
+    {0x3d2, 0x3d4},    //
+    {0x3d8, 0x3d8},    //
+    {0x3da, 0x3da},    //
+    {0x3dc, 0x3dc},    //
+    {0x3de, 0x3de},    //
+    {0x3e0, 0x3e0},    //
+    {0x3e2, 0x3e2},    //
+    {0x3e4, 0x3e4},    //
+    {0x3e6, 0x3e6},    //
+    {0x3e8, 0x3e8},    //
+    {0x3ea, 0x3ea},    //
+    {0x3ec, 0x3ec},    //
+    {0x3ee, 0x3ee},    //
+    {0x3f4, 0x3f4},    //
+    {0x3f7, 0x3f7},    //
+    {0x3f9, 0x3fa},    //
+    {0x3fd, 0x42f},    //
+    {0x460, 0x460},    //
+    {0x462, 0x462},    //
+    {0x464, 0x464},    //
+    {0x466, 0x466},    //
+    {0x468, 0x468},    //
+    {0x46a, 0x46a},    //
+    {0x46c, 0x46c},    //
+    {0x46e, 0x46e},    //
+    {0x470, 0x470},    //
+    {0x472, 0x472},    //
+    {0x474, 0x474},    //
+    {0x476, 0x476},    //
+    {0x478, 0x478},    //
+    {0x47a, 0x47a},    //
+    {0x47c, 0x47c},    //
+    {0x47e, 0x47e},    //
+    {0x480, 0x480},    //
+    {0x48a, 0x48a},    //
+    {0x48c, 0x48c},    //
+    {0x48e, 0x48e},    //
+    {0x490, 0x490},    //
+    {0x492, 0x492},    //
+    {0x494, 0x494},    //
+    {0x496, 0x496},    //
+    {0x498, 0x498},    //
+    {0x49a, 0x49a},    //
+    {0x49c, 0x49c},    //
+    {0x49e, 0x49e},    //
+    {0x4a0, 0x4a0},    //
+    {0x4a2, 0x4a2},    //
+    {0x4a4, 0x4a4},    //
+    {0x4a6, 0x4a6},    //
+    {0x4a8, 0x4a8},    //
+    {0x4aa, 0x4aa},    //
+    {0x4ac, 0x4ac},    //
+    {0x4ae, 0x4ae},    //
+    {0x4b0, 0x4b0},    //
+    {0x4b2, 0x4b2},    //
+    {0x4b4, 0x4b4},    //
+    {0x4b6, 0x4b6},    //
+    {0x4b8, 0x4b8},    //
+    {0x4ba, 0x4ba},    //
+    {0x4bc, 0x4bc},    //
+    {0x4be, 0x4be},    //
+    {0x4c0, 0x4c1},    //
+    {0x4c3, 0x4c3},    //
+    {0x4c5, 0x4c5},    //
+    {0x4c7, 0x4c7},    //
+    {0x4c9, 0x4c9},    //
+    {0x4cb, 0x4cb},    //
+    {0x4cd, 0x4cd},    //
+    {0x4d0, 0x4d0},    //
+    {0x4d2, 0x4d2},    //
+    {0x4d4, 0x4d4},    //
+    {0x4d6, 0x4d6},    //
+    {0x4d8, 0x4d8},    //
+    {0x4da, 0x4da},    //
+    {0x4dc, 0x4dc},    //
+    {0x4de, 0x4de},    //
+    {0x4e0, 0x4e0},    //
+    {0x4e2, 0x4e2},    //
+    {0x4e4, 0x4e4},    //
+    {0x4e6, 0x4e6},    //
+    {0x4e8, 0x4e8},    //
+    {0x4ea, 0x4ea},    //
+    {0x4ec, 0x4ec},    //
+    {0x4ee, 0x4ee},    //
+    {0x4f0, 0x4f0},    //
+    {0x4f2, 0x4f2},    //
+    {0x4f4, 0x4f4},    //
+    {0x4f6, 0x4f6},    //
+    {0x4f8, 0x4f8},    //
+    {0x4fa, 0x4fa},    //
+    {0x4fc, 0x4fc},    //
+    {0x4fe, 0x4fe},    //
+    {0x500, 0x500},    //
+    {0x502, 0x502},    //
+    {0x504, 0x504},    //
+    {0x506, 0x506},    //
+    {0x508, 0x508},    //
+    {0x50a, 0x50a},    //
+    {0x50c, 0x50c},    //
+    {0x50e, 0x50e},    //
+    {0x510, 0x510},    //
+    {0x512, 0x512},    //
+    {0x514, 0x514},    //
+    {0x516, 0x516},    //
+    {0x518, 0x518},    //
+    {0x51a, 0x51a},    //
+    {0x51c, 0x51c},    //
+    {0x51e, 0x51e},    //
+    {0x520, 0x520},    //
+    {0x522, 0x522},    //
+    {0x524, 0x524},    //
+    {0x526, 0x526},    //
+    {0x528, 0x528},    //
+    {0x52a, 0x52a},    //
+    {0x52c, 0x52c},    //
+    {0x52e, 0x52e},    //
+    {0x531, 0x556},    //
+    {0x10a0, 0x10c5},  //
+    {0x10c7, 0x10c7},  //
+    {0x10cd, 0x10cd},  //
+    {0x13a0, 0x13f5},  //
+    {0x1c90, 0x1cba},  //
+    {0x1cbd, 0x1cbf},  //
+    {0x1e00, 0x1e00},  //
+    {0x1e02, 0x1e02},  //
+    {0x1e04, 0x1e04},  //
+    {0x1e06, 0x1e06},  //
+    {0x1e08, 0x1e08},  //
+    {0x1e0a, 0x1e0a},  //
+    {0x1e0c, 0x1e0c},  //
+    {0x1e0e, 0x1e0e},  //
+    {0x1e10, 0x1e10},  //
+    {0x1e12, 0x1e12},  //
+    {0x1e14, 0x1e14},  //
+    {0x1e16, 0x1e16},  //
+    {0x1e18, 0x1e18},  //
+    {0x1e1a, 0x1e1a},  //
+    {0x1e1c, 0x1e1c},  //
+    {0x1e1e, 0x1e1e},  //
+    {0x1e20, 0x1e20},  //
+    {0x1e22, 0x1e22},  //
+    {0x1e24, 0x1e24},  //
+    {0x1e26, 0x1e26},  //
+    {0x1e28, 0x1e28},  //
+    {0x1e2a, 0x1e2a},  //
+    {0x1e2c, 0x1e2c},  //
+    {0x1e2e, 0x1e2e},  //
+    {0x1e30, 0x1e30},  //
+    {0x1e32, 0x1e32},  //
+    {0x1e34, 0x1e34},  //
+    {0x1e36, 0x1e36},  //
+    {0x1e38, 0x1e38},  //
+    {0x1e3a, 0x1e3a},  //
+    {0x1e3c, 0x1e3c},  //
+    {0x1e3e, 0x1e3e},  //
+    {0x1e40, 0x1e40},  //
+    {0x1e42, 0x1e42},  //
+    {0x1e44, 0x1e44},  //
+    {0x1e46, 0x1e46},  //
+    {0x1e48, 0x1e48},  //
+    {0x1e4a, 0x1e4a},  //
+    {0x1e4c, 0x1e4c},  //
+    {0x1e4e, 0x1e4e},  //
+    {0x1e50, 0x1e50},  //
+    {0x1e52, 0x1e52},  //
+    {0x1e54, 0x1e54},  //
+    {0x1e56, 0x1e56},  //
+    {0x1e58, 0x1e58},  //
+    {0x1e5a, 0x1e5a},  //
+    {0x1e5c, 0x1e5c},  //
+    {0x1e5e, 0x1e5e},  //
+    {0x1e60, 0x1e60},  //
+    {0x1e62, 0x1e62},  //
+    {0x1e64, 0x1e64},  //
+    {0x1e66, 0x1e66},  //
+    {0x1e68, 0x1e68},  //
+    {0x1e6a, 0x1e6a},  //
+    {0x1e6c, 0x1e6c},  //
+    {0x1e6e, 0x1e6e},  //
+    {0x1e70, 0x1e70},  //
+    {0x1e72, 0x1e72},  //
+    {0x1e74, 0x1e74},  //
+    {0x1e76, 0x1e76},  //
+    {0x1e78, 0x1e78},  //
+    {0x1e7a, 0x1e7a},  //
+    {0x1e7c, 0x1e7c},  //
+    {0x1e7e, 0x1e7e},  //
+    {0x1e80, 0x1e80},  //
+    {0x1e82, 0x1e82},  //
+    {0x1e84, 0x1e84},  //
+    {0x1e86, 0x1e86},  //
+    {0x1e88, 0x1e88},  //
+    {0x1e8a, 0x1e8a},  //
+    {0x1e8c, 0x1e8c},  //
+    {0x1e8e, 0x1e8e},  //
+    {0x1e90, 0x1e90},  //
+    {0x1e92, 0x1e92},  //
+    {0x1e94, 0x1e94},  //
+    {0x1e9e, 0x1e9e},  //
+    {0x1ea0, 0x1ea0},  //
+    {0x1ea2, 0x1ea2},  //
+    {0x1ea4, 0x1ea4},  //
+    {0x1ea6, 0x1ea6},  //
+    {0x1ea8, 0x1ea8},  //
+    {0x1eaa, 0x1eaa},  //
+    {0x1eac, 0x1eac},  //
+    {0x1eae, 0x1eae},  //
+    {0x1eb0, 0x1eb0},  //
+    {0x1eb2, 0x1eb2},  //
+    {0x1eb4, 0x1eb4},  //
+    {0x1eb6, 0x1eb6},  //
+    {0x1eb8, 0x1eb8},  //
+    {0x1eba, 0x1eba},  //
+    {0x1ebc, 0x1ebc},  //
+    {0x1ebe, 0x1ebe},  //
+    {0x1ec0, 0x1ec0},  //
+    {0x1ec2, 0x1ec2},  //
+    {0x1ec4, 0x1ec4},  //
+    {0x1ec6, 0x1ec6},  //
+    {0x1ec8, 0x1ec8},  //
+    {0x1eca, 0x1eca},  //
+    {0x1ecc, 0x1ecc},  //
+    {0x1ece, 0x1ece},  //
+    {0x1ed0, 0x1ed0},  //
+    {0x1ed2, 0x1ed2},  //
+    {0x1ed4, 0x1ed4},  //
+    {0x1ed6, 0x1ed6},  //
+    {0x1ed8, 0x1ed8},  //
+    {0x1eda, 0x1eda},  //
+    {0x1edc, 0x1edc},  //
+    {0x1ede, 0x1ede},  //
+    {0x1ee0, 0x1ee0},  //
+    {0x1ee2, 0x1ee2},  //
+    {0x1ee4, 0x1ee4},  //
+    {0x1ee6, 0x1ee6},  //
+    {0x1ee8, 0x1ee8},  //
+    {0x1eea, 0x1eea},  //
+    {0x1eec, 0x1eec},  //
+    {0x1eee, 0x1eee},  //
+    {0x1ef0, 0x1ef0},  //
+    {0x1ef2, 0x1ef2},  //
+    {0x1ef4, 0x1ef4},  //
+    {0x1ef6, 0x1ef6},  //
+    {0x1ef8, 0x1ef8},  //
+    {0x1efa, 0x1efa},  //
+    {0x1efc, 0x1efc},  //
+    {0x1efe, 0x1efe},  //
+    {0x1f08, 0x1f0f},  //
+    {0x1f18, 0x1f1d},  //
+    {0x1f28, 0x1f2f},  //
+    {0x1f38, 0x1f3f},  //
+    {0x1f48, 0x1f4d},  //
+    {0x1f59, 0x1f59},  //
+    {0x1f5b, 0x1f5b},  //
+    {0x1f5d, 0x1f5d},  //
+    {0x1f5f, 0x1f5f},  //
+    {0x1f68, 0x1f6f},  //
+    {0x1f88, 0x1f8f},  //
+    {0x1f98, 0x1f9f},  //
+    {0x1fa8, 0x1faf},  //
+    {0x1fb8, 0x1fbc},  //
+    {0x1fc8, 0x1fcc},  //
+    {0x1fd8, 0x1fdb},  //
+    {0x1fe8, 0x1fec},  //
+    {0x1ff8, 0x1ffc},  //
+    {0x2102, 0x2102},  //
+    {0x2107, 0x2107},  //
+    {0x210b, 0x210d},  //
+    {0x2110, 0x2112},  //
+    {0x2115, 0x2115},  //
+    {0x2119, 0x211d},  //
+    {0x2124, 0x2124},  //
+    {0x2126, 0x2126},  //
+    {0x2128, 0x2128},  //
+    {0x212a, 0x212d},  //
+    {0x2130, 0x2133},  //
+    {0x213e, 0x213f},  //
+    {0x2145, 0x2145},  //
+    {0x2160, 0x216f},  //
+    {0x2183, 0x2183},  //
+    {0x24b6, 0x24cf},  //
+    {0x2c00, 0x2c2f},  //
+    {0x2c60, 0x2c60},  //
+    {0x2c62, 0x2c64},  //
+    {0x2c67, 0x2c67},  //
+    {0x2c69, 0x2c69},  //
+    {0x2c6b, 0x2c6b},  //
+    {0x2c6d, 0x2c70},  //
+    {0x2c72, 0x2c72},  //
+    {0x2c75, 0x2c75},  //
+    {0x2c7e, 0x2c80},  //
+    {0x2c82, 0x2c82},  //
+    {0x2c84, 0x2c84},  //
+    {0x2c86, 0x2c86},  //
+    {0x2c88, 0x2c88},  //
+    {0x2c8a, 0x2c8a},  //
+    {0x2c8c, 0x2c8c},  //
+    {0x2c8e, 0x2c8e},  //
+    {0x2c90, 0x2c90},  //
+    {0x2c92, 0x2c92},  //
+    {0x2c94, 0x2c94},  //
+    {0x2c96, 0x2c96},  //
+    {0x2c98, 0x2c98},  //
+    {0x2c9a, 0x2c9a},  //
+    {0x2c9c, 0x2c9c},  //
+    {0x2c9e, 0x2c9e},  //
+    {0x2ca0, 0x2ca0},  //
+    {0x2ca2, 0x2ca2},  //
+    {0x2ca4, 0x2ca4},  //
+    {0x2ca6, 0x2ca6},  //
+    {0x2ca8, 0x2ca8},  //
+    {0x2caa, 0x2caa},  //
+    {0x2cac, 0x2cac},  //
+    {0x2cae, 0x2cae},  //
+    {0x2cb0, 0x2cb0},  //
+    {0x2cb2, 0x2cb2},  //
+    {0x2cb4, 0x2cb4},  //
+    {0x2cb6, 0x2cb6},  //
+    {0x2cb8, 0x2cb8},  //
+    {0x2cba, 0x2cba},  //
+    {0x2cbc, 0x2cbc},  //
+    {0x2cbe, 0x2cbe},  //
+    {0x2cc0, 0x2cc0},  //
+    {0x2cc2, 0x2cc2},  //
+    {0x2cc4, 0x2cc4},  //
+    {0x2cc6, 0x2cc6},  //
+    {0x2cc8, 0x2cc8},  //
+    {0x2cca, 0x2cca},  //
+    {0x2ccc, 0x2ccc},  //
+    {0x2cce, 0x2cce},  //
+    {0x2cd0, 0x2cd0},  //
+    {0x2cd2, 0x2cd2},  //
+    {0x2cd4, 0x2cd4},  //
+    {0x2cd6, 0x2cd6},  //
+    {0x2cd8, 0x2cd8},  //
+    {0x2cda, 0x2cda},  //
+    {0x2cdc, 0x2cdc},  //
+    {0x2cde, 0x2cde},  //
+    {0x2ce0, 0x2ce0},  //
+    {0x2ce2, 0x2ce2},  //
+    {0x2ceb, 0x2ceb},  //
+    {0x2ced, 0x2ced},  //
+    {0x2cf2, 0x2cf2},  //
+    {0xa640, 0xa640},  //
+    {0xa642, 0xa642},  //
+    {0xa644, 0xa644},  //
+    {0xa646, 0xa646},  //
+    {0xa648, 0xa648},  //
+    {0xa64a, 0xa64a},  //
+    {0xa64c, 0xa64c},  //
+    {0xa64e, 0xa64e},  //
+    {0xa650, 0xa650},  //
+    {0xa652, 0xa652},  //
+    {0xa654, 0xa654},  //
+    {0xa656, 0xa656},  //
+    {0xa658, 0xa658},  //
+    {0xa65a, 0xa65a},  //
+    {0xa65c, 0xa65c},  //
+    {0xa65e, 0xa65e},  //
+    {0xa660, 0xa660},  //
+    {0xa662, 0xa662},  //
+    {0xa664, 0xa664},  //
+    {0xa666, 0xa666},  //
+    {0xa668, 0xa668},  //
+    {0xa66a, 0xa66a},  //
+    {0xa66c, 0xa66c},  //
+    {0xa680, 0xa680},  //
+    {0xa682, 0xa682},  //
+    {0xa684, 0xa684},  //
+    {0xa686, 0xa686},  //
+    {0xa688, 0xa688},  //
+    {0xa68a, 0xa68a},  //
+    {0xa68c, 0xa68c},  //
+    {0xa68e, 0xa68e},  //
+    {0xa690, 0xa690},  //
+    {0xa692, 0xa692},  //
+    {0xa694, 0xa694},  //
+    {0xa696, 0xa696},  //
+    {0xa698, 0xa698},  //
+    {0xa69a, 0xa69a},  //
+    {0xa722, 0xa722},  //
+    {0xa724, 0xa724},  //
+    {0xa726, 0xa726},  //
+    {0xa728, 0xa728},  //
+    {0xa72a, 0xa72a},  //
+    {0xa72c, 0xa72c},  //
+    {0xa72e, 0xa72e},  //
+    {0xa732, 0xa732},  //
+    {0xa734, 0xa734},  //
+    {0xa736, 0xa736},  //
+    {0xa738, 0xa738},  //
+    {0xa73a, 0xa73a},  //
+    {0xa73c, 0xa73c},  //
+    {0xa73e, 0xa73e},  //
+    {0xa740, 0xa740},  //
+    {0xa742, 0xa742},  //
+    {0xa744, 0xa744},  //
+    {0xa746, 0xa746},  //
+    {0xa748, 0xa748},  //
+    {0xa74a, 0xa74a},  //
+    {0xa74c, 0xa74c},  //
+    {0xa74e, 0xa74e},  //
+    {0xa750, 0xa750},  //
+    {0xa752, 0xa752},  //
+    {0xa754, 0xa754},  //
+    {0xa756, 0xa756},  //
+    {0xa758, 0xa758},  //
+    {0xa75a, 0xa75a},  //
+    {0xa75c, 0xa75c},  //
+    {0xa75e, 0xa75e},  //
+    {0xa760, 0xa760},  //
+    {0xa762, 0xa762},  //
+    {0xa764, 0xa764},  //
+    {0xa766, 0xa766},  //
+    {0xa768, 0xa768},  //
+    {0xa76a, 0xa76a},  //
+    {0xa76c, 0xa76c},  //
+    {0xa76e, 0xa76e},  //
+    {0xa779, 0xa779},  //
+    {0xa77b, 0xa77b},  //
+    {0xa77d, 0xa77e},  //
+    {0xa780, 0xa780},  //
+    {0xa782, 0xa782},  //
+    {0xa784, 0xa784},  //
+    {0xa786, 0xa786},  //
+    {0xa78b, 0xa78b},  //
+    {0xa78d, 0xa78d},  //
+    {0xa790, 0xa790},  //
+    {0xa792, 0xa792},  //
+    {0xa796, 0xa796},  //
+    {0xa798, 0xa798},  //
+    {0xa79a, 0xa79a},  //
+    {0xa79c, 0xa79c},  //
+    {0xa79e, 0xa79e},  //
+    {0xa7a0, 0xa7a0},  //
+    {0xa7a2, 0xa7a2},  //
+    {0xa7a4, 0xa7a4},  //
+    {0xa7a6, 0xa7a6},  //
+    {0xa7a8, 0xa7a8},  //
+    {0xa7aa, 0xa7ae},  //
+    {0xa7b0, 0xa7b4},  //
+    {0xa7b6, 0xa7b6},  //
+    {0xa7b8, 0xa7b8},  //
+    {0xa7ba, 0xa7ba},  //
+    {0xa7bc, 0xa7bc},  //
+    {0xa7be, 0xa7be},  //
+    {0xa7c0, 0xa7c0},  //
+    {0xa7c2, 0xa7c2},  //
+    {0xa7c4, 0xa7c7},  //
+    {0xa7c9, 0xa7c9},  //
+    {0xa7d0, 0xa7d0},  //
+    {0xa7d6, 0xa7d6},  //
+    {0xa7d8, 0xa7d8},  //
+    {0xa7f5, 0xa7f5},  //
+    {0xff21, 0xff3a},  //
+};
+
+static const unsigned kUpperAstral[][2] = {
+    {0x10400, 0x10427},  //
+    {0x104b0, 0x104d3},  //
+    {0x10570, 0x1057a},  //
+    {0x1057c, 0x1058a},  //
+    {0x1058c, 0x10592},  //
+    {0x10594, 0x10595},  //
+    {0x10c80, 0x10cb2},  //
+    {0x118a0, 0x118bf},  //
+    {0x16e40, 0x16e5f},  //
+    {0x1d400, 0x1d419},  //
+    {0x1d434, 0x1d44d},  //
+    {0x1d468, 0x1d481},  //
+    {0x1d49c, 0x1d49c},  //
+    {0x1d49e, 0x1d49f},  //
+    {0x1d4a2, 0x1d4a2},  //
+    {0x1d4a5, 0x1d4a6},  //
+    {0x1d4a9, 0x1d4ac},  //
+    {0x1d4ae, 0x1d4b5},  //
+    {0x1d4d0, 0x1d4e9},  //
+    {0x1d504, 0x1d505},  //
+    {0x1d507, 0x1d50a},  //
+    {0x1d50d, 0x1d514},  //
+    {0x1d516, 0x1d51c},  //
+    {0x1d538, 0x1d539},  //
+    {0x1d53b, 0x1d53e},  //
+    {0x1d540, 0x1d544},  //
+    {0x1d546, 0x1d546},  //
+    {0x1d54a, 0x1d550},  //
+    {0x1d56c, 0x1d585},  //
+    {0x1d5a0, 0x1d5b9},  //
+    {0x1d5d4, 0x1d5ed},  //
+    {0x1d608, 0x1d621},  //
+    {0x1d63c, 0x1d655},  //
+    {0x1d670, 0x1d689},  //
+    {0x1d6a8, 0x1d6c0},  //
+    {0x1d6e2, 0x1d6fa},  //
+    {0x1d71c, 0x1d734},  //
+    {0x1d756, 0x1d76e},  //
+    {0x1d790, 0x1d7a8},  //
+    {0x1d7ca, 0x1d7ca},  //
+    {0x1e900, 0x1e921},  //
+    {0x1f130, 0x1f149},  //
+    {0x1f150, 0x1f169},  //
+    {0x1f170, 0x1f189},  //
+};
+
+/**
+ * Returns nonzero if c is uppercase letter.
+ */
+int iswupper(wint_t c) {
+  if (!IsTiny() && c < 128)
+    return 'A' <= c && c <= 'Z';
+  if (c < 65536)
+    return has_char(kUpper, ARRAYLEN(kUpper), (unsigned short)c);
+  return has_char(kUpperAstral, ARRAYLEN(kUpperAstral), (unsigned)c);
+}
+
+__weak_reference(iswupper, iswupper_l);
diff --git a/libc/str/iswxdigit.c b/libc/str/iswxdigit.c
index c325efc6f..cccf9e4de 100644
--- a/libc/str/iswxdigit.c
+++ b/libc/str/iswxdigit.c
@@ -16,13 +16,14 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Returns nonzero if c is ascii hex digit.
  */
 int iswxdigit(wint_t c) {
-  return ('0' <= c && c <= '9') || ('A' <= c && c <= 'F') ||
+  return ('0' <= c && c <= '9') ||  //
+         ('A' <= c && c <= 'F') ||  //
          ('a' <= c && c <= 'f');
 }
 
diff --git a/libc/str/isxdigit.c b/libc/str/isxdigit.c
index e31788738..a5f325698 100644
--- a/libc/str/isxdigit.c
+++ b/libc/str/isxdigit.c
@@ -16,16 +16,14 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/calls/calls.h"
-#include "libc/limits.h"
-#include "libc/str/str.h"
+#include "libc/ctype.h"
 
 /**
  * Returns true if c is hexadecimal digit.
  */
 int isxdigit(int c) {
-  return ('0' <= c && c <= '9') || ('A' <= c && c <= 'F') ||
+  return ('0' <= c && c <= '9') ||  //
+         ('A' <= c && c <= 'F') ||  //
          ('a' <= c && c <= 'f');
 }
 
diff --git a/libc/str/iszipeocd32.c b/libc/str/iszipeocd32.c
index 883bf93db..a516b0f21 100644
--- a/libc/str/iszipeocd32.c
+++ b/libc/str/iszipeocd32.c
@@ -17,39 +17,30 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/stdckdint.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Determines if ZIP EOCD record seems legit.
  */
 int IsZipEocd32(const uint8_t *p, size_t n, size_t i) {
   size_t offset;
-  if (i > n || n - i < kZipCdirHdrMinSize) {
+  if (i > n || n - i < kZipCdirHdrMinSize)
     return kZipErrorEocdOffsetOverflow;
-  }
-  if (ZIP_READ32(p + i) != kZipCdirHdrMagic) {
+  if (ZIP_READ32(p + i) != kZipCdirHdrMagic)
     return kZipErrorEocdMagicNotFound;
-  }
-  if (i + ZIP_CDIR_HDRSIZE(p + i) > n) {
+  if (i + ZIP_CDIR_HDRSIZE(p + i) > n)
     return kZipErrorEocdSizeOverflow;
-  }
-  if (ZIP_CDIR_DISK(p + i) != ZIP_CDIR_STARTINGDISK(p + i)) {
+  if (ZIP_CDIR_DISK(p + i) != ZIP_CDIR_STARTINGDISK(p + i))
     return kZipErrorEocdDiskMismatch;
-  }
-  if (ZIP_CDIR_RECORDSONDISK(p + i) != ZIP_CDIR_RECORDS(p + i)) {
+  if (ZIP_CDIR_RECORDSONDISK(p + i) != ZIP_CDIR_RECORDS(p + i))
     return kZipErrorEocdRecordsMismatch;
-  }
-  if (ZIP_CDIR_RECORDS(p + i) * kZipCfileHdrMinSize > ZIP_CDIR_SIZE(p + i)) {
+  if (ZIP_CDIR_RECORDS(p + i) * kZipCfileHdrMinSize > ZIP_CDIR_SIZE(p + i))
     return kZipErrorEocdRecordsOverflow;
-  }
-  if (ZIP_CDIR_OFFSET(p + i) == 0xFFFFFFFFu) {
+  if (ZIP_CDIR_OFFSET(p + i) == 0xFFFFFFFFu)
     return kZipErrorEocdRecordsOverflow;
-  }
-  if (ckd_add(&offset, ZIP_CDIR_OFFSET(p + i), ZIP_CDIR_SIZE(p + i))) {
+  if (ckd_add(&offset, ZIP_CDIR_OFFSET(p + i), ZIP_CDIR_SIZE(p + i)))
     return kZipErrorEocdOffsetSizeOverflow;
-  }
-  if (offset > i) {
+  if (offset > i)
     return kZipErrorCdirOffsetPastEocd;
-  }
   return kZipOk;
 }
diff --git a/libc/str/iszipeocd64.c b/libc/str/iszipeocd64.c
index cbc37af29..ff29795d6 100644
--- a/libc/str/iszipeocd64.c
+++ b/libc/str/iszipeocd64.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/stdckdint.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 /**
  * Returns kZipOk if zip64 end of central directory header seems legit.
diff --git a/libc/str/khextoint.c b/libc/str/khextoint.c
index 53e2093d0..fd30e72cf 100644
--- a/libc/str/khextoint.c
+++ b/libc/str/khextoint.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdalign.internal.h"
-#include "libc/str/tab.internal.h"
+#include "libc/stdalign.h"
+#include "libc/str/tab.h"
 
 alignas(int8_t) const int8_t kHexToInt[256] = {
     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  // 0x00
diff --git a/libc/str/kmp.c b/libc/str/kmp.c
new file mode 100644
index 000000000..d904a4378
--- /dev/null
+++ b/libc/str/kmp.c
@@ -0,0 +1,74 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/str/kmp.h"
+#include "libc/mem/alloca.h"
+#include "libc/runtime/stack.h"
+
+static void computeLPS(const char *pattern, long M, long *lps) {
+  long len = 0;
+  lps[0] = 0;
+  long i = 1;
+  while (i < M) {
+    if (pattern[i] == pattern[len]) {
+      len++;
+      lps[i] = len;
+      i++;
+    } else {
+      if (len != 0) {
+        len = lps[len - 1];
+      } else {
+        lps[i] = 0;
+        i++;
+      }
+    }
+  }
+}
+
+char *__memmem_kmp(const char *s, size_t n, const char *ss, size_t m) {
+  if (!m)
+    return (char *)s;
+  if (n < m)
+    return NULL;
+#pragma GCC push_options
+#pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
+  long need = sizeof(long) * m;
+  long *lps = (long *)alloca(need);
+  CheckLargeStackAllocation(lps, need);
+#pragma GCC pop_options
+  computeLPS(ss, m, lps);
+  long i = 0;
+  long j = 0;
+  while (i < n) {
+    if (ss[j] == s[i]) {
+      i++;
+      j++;
+    }
+    if (j == m) {
+      return (char *)(s + i - j);
+    } else if (i < n && ss[j] != s[i]) {
+      if (j != 0) {
+        j = lps[j - 1];
+      } else {
+        i++;
+      }
+    }
+  }
+  return NULL;
+}
diff --git a/libc/str/kmp.h b/libc/str/kmp.h
new file mode 100644
index 000000000..5c5a85736
--- /dev/null
+++ b/libc/str/kmp.h
@@ -0,0 +1,10 @@
+#ifndef COSMOPOLITAN_LIBC_STR_KMP_H_
+#define COSMOPOLITAN_LIBC_STR_KMP_H_
+COSMOPOLITAN_C_START_
+
+char *__memmem_kmp(const char *, size_t, const char *, size_t);
+char16_t *__memmem_kmp16(const char16_t *, size_t, const char16_t *, size_t);
+wchar_t *__memmem_kmp32(const wchar_t *, size_t, const wchar_t *, size_t);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_STR_KMP_H_ */
diff --git a/libc/str/kmp16.c b/libc/str/kmp16.c
new file mode 100644
index 000000000..0e30f57ad
--- /dev/null
+++ b/libc/str/kmp16.c
@@ -0,0 +1,75 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/mem/alloca.h"
+#include "libc/runtime/stack.h"
+#include "libc/str/kmp.h"
+
+static void computeLPS(const char16_t *pattern, long M, long *lps) {
+  long len = 0;
+  lps[0] = 0;
+  long i = 1;
+  while (i < M) {
+    if (pattern[i] == pattern[len]) {
+      len++;
+      lps[i] = len;
+      i++;
+    } else {
+      if (len != 0) {
+        len = lps[len - 1];
+      } else {
+        lps[i] = 0;
+        i++;
+      }
+    }
+  }
+}
+
+char16_t *__memmem_kmp16(const char16_t *s, size_t n, const char16_t *ss,
+                         size_t m) {
+  if (!m)
+    return (char16_t *)s;
+  if (n < m)
+    return NULL;
+#pragma GCC push_options
+#pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
+  long need = sizeof(long) * m;
+  long *lps = (long *)alloca(need);
+  CheckLargeStackAllocation(lps, need);
+#pragma GCC pop_options
+  computeLPS(ss, m, lps);
+  long i = 0;
+  long j = 0;
+  while (i < n) {
+    if (ss[j] == s[i]) {
+      i++;
+      j++;
+    }
+    if (j == m) {
+      return (char16_t *)(s + i - j);
+    } else if (i < n && ss[j] != s[i]) {
+      if (j != 0) {
+        j = lps[j - 1];
+      } else {
+        i++;
+      }
+    }
+  }
+  return NULL;
+}
diff --git a/libc/str/kmp32.c b/libc/str/kmp32.c
new file mode 100644
index 000000000..efd1a07a8
--- /dev/null
+++ b/libc/str/kmp32.c
@@ -0,0 +1,75 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/mem/alloca.h"
+#include "libc/runtime/stack.h"
+#include "libc/str/kmp.h"
+
+static void computeLPS(const wchar_t *pattern, long M, long *lps) {
+  long len = 0;
+  lps[0] = 0;
+  long i = 1;
+  while (i < M) {
+    if (pattern[i] == pattern[len]) {
+      len++;
+      lps[i] = len;
+      i++;
+    } else {
+      if (len != 0) {
+        len = lps[len - 1];
+      } else {
+        lps[i] = 0;
+        i++;
+      }
+    }
+  }
+}
+
+wchar_t *__memmem_kmp32(const wchar_t *s, size_t n, const wchar_t *ss,
+                        size_t m) {
+  if (!m)
+    return (wchar_t *)s;
+  if (n < m)
+    return NULL;
+#pragma GCC push_options
+#pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
+  long need = sizeof(long) * m;
+  long *lps = (long *)alloca(need);
+  CheckLargeStackAllocation(lps, need);
+#pragma GCC pop_options
+  computeLPS(ss, m, lps);
+  long i = 0;
+  long j = 0;
+  while (i < n) {
+    if (ss[j] == s[i]) {
+      i++;
+      j++;
+    }
+    if (j == m) {
+      return (wchar_t *)(s + i - j);
+    } else if (i < n && ss[j] != s[i]) {
+      if (j != 0) {
+        j = lps[j - 1];
+      } else {
+        i++;
+      }
+    }
+  }
+  return NULL;
+}
diff --git a/libc/str/kx86processormodels.c b/libc/str/kx86processormodels.c
index d5f62ea3c..ba055d84b 100644
--- a/libc/str/kx86processormodels.c
+++ b/libc/str/kx86processormodels.c
@@ -16,11 +16,10 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/x86info.h"
 
 const struct X86ProcessorModel kX86ProcessorModels[] = {
-    /* <SORTED> */
     {0x060F, X86_MARCH_CORE2, X86_GRADE_CLIENT},
     {0x0616, X86_MARCH_CORE2, X86_GRADE_MOBILE},
     {0x0617, X86_MARCH_CORE2, X86_GRADE_SERVER},
@@ -85,7 +84,5 @@ const struct X86ProcessorModel kX86ProcessorModels[] = {
     {0x06A7, X86_MARCH_ROCKETLAKE, X86_GRADE_CLIENT},
     {0x06B7, X86_MARCH_RAPTORLAKE, X86_GRADE_CLIENT},
     {0x06BA, X86_MARCH_RAPTORLAKE, X86_GRADE_CLIENT},
-    /* </SORTED> */
+    {0},
 };
-
-const size_t kX86ProcessorModelCount = ARRAYLEN(kX86ProcessorModels);
diff --git a/libc/str/langinfo.h b/libc/str/langinfo.h
index edb8ce75e..5427efa4d 100644
--- a/libc/str/langinfo.h
+++ b/libc/str/langinfo.h
@@ -1,5 +1,7 @@
 #ifndef COSMOPOLITAN_LIBC_STR_LANGINFO_H_
 #define COSMOPOLITAN_LIBC_STR_LANGINFO_H_
+#include "libc/str/locale.h"
+#include "libc/str/nltypes.h"
 COSMOPOLITAN_C_START_
 
 #define ABDAY_1 0x20000
@@ -78,7 +80,8 @@ COSMOPOLITAN_C_START_
 #define NOSTR  0x50003
 #endif
 
-char *nl_langinfo(int);
+char *nl_langinfo(nl_item);
+char *nl_langinfo_l(nl_item, locale_t);
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_STR_LANGINFO_H_ */
diff --git a/libc/str/locale.c b/libc/str/locale.c
index 8db705895..d818e76d4 100644
--- a/libc/str/locale.c
+++ b/libc/str/locale.c
@@ -16,10 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/locale.h"
+#include "libc/str/locale.internal.h"
 #include "libc/str/str.h"
 
-static const uint32_t empty_mo[] = {0x950412de, 0, -1, -1, -1};
+static const uint32_t empty_mo[] = {
+    0x950412de, 0, -1, -1, -1,
+};
 
 const struct __locale_map __c_dot_utf8 = {
     .map = empty_mo,
@@ -27,8 +29,11 @@ const struct __locale_map __c_dot_utf8 = {
     .name = "C.UTF-8",
 };
 
-const struct __locale_struct __c_locale;
-
+const struct __locale_struct __c_locale = {0};
 const struct __locale_struct __c_dot_utf8_locale = {
     .cat[LC_CTYPE] = &__c_dot_utf8,
 };
+
+struct __locale_struct __global_locale;
+
+pthread_mutex_t __locale_lock = PTHREAD_MUTEX_INITIALIZER;
diff --git a/libc/str/locale.h b/libc/str/locale.h
index ec66e45dd..2b772639f 100644
--- a/libc/str/locale.h
+++ b/libc/str/locale.h
@@ -17,29 +17,13 @@
 #define LC_MONETARY_MASK 16
 #define LC_MESSAGES_MASK 32
 #define LC_ALL_MASK      0x1fbf
-#define LOCALE_NAME_MAX  23
 
 COSMOPOLITAN_C_START_
 
 #define LC_GLOBAL_LOCALE ((locale_t) - 1)
 
-struct __locale_map {
-  const void *map;
-  size_t map_size;
-  char name[LOCALE_NAME_MAX + 1];
-  const struct __locale_map *next;
-};
-
-struct __locale_struct {
-  const struct __locale_map *cat[6];
-};
-
 typedef struct __locale_struct *locale_t;
 
-extern const struct __locale_map __c_dot_utf8;
-extern const struct __locale_struct __c_locale;
-extern const struct __locale_struct __c_dot_utf8_locale;
-
 char *nl_langinfo_l(int, locale_t) libcesque;
 char *setlocale(int, const char *) libcesque;
 double strtod_l(const char *, char **, locale_t) libcesque;
diff --git a/libc/str/locale.internal.h b/libc/str/locale.internal.h
new file mode 100644
index 000000000..e6dad969c
--- /dev/null
+++ b/libc/str/locale.internal.h
@@ -0,0 +1,52 @@
+#ifndef COSMOPOLITAN_LIBC_STR_LOCALE_INTERNAL_H_
+#define COSMOPOLITAN_LIBC_STR_LOCALE_INTERNAL_H_
+#include "libc/limits.h"
+#include "libc/str/locale.h"
+#include "libc/thread/posixthread.internal.h"
+COSMOPOLITAN_C_START_
+
+#define LOCALE_NAME_MAX 23
+
+struct __locale_map {
+  const void *map;
+  size_t map_size;
+  char name[LOCALE_NAME_MAX + 1];
+  const struct __locale_map *next;
+};
+
+struct __locale_struct {
+  const struct __locale_map *cat[6];
+};
+
+extern pthread_mutex_t __locale_lock;
+
+extern struct __locale_struct __global_locale;
+extern const struct __locale_map __c_dot_utf8;
+extern const struct __locale_struct __c_locale;
+extern const struct __locale_struct __c_dot_utf8_locale;
+
+const struct __locale_map *__get_locale(int, const char *);
+const char *__mo_lookup(const void *, size_t, const char *);
+const char *__lctrans(const char *, const struct __locale_map *);
+const char *__lctrans_cur(const char *);
+const char *__lctrans_impl(const char *, const struct __locale_map *);
+int __loc_is_allocated(locale_t);
+char *__gettextdomain(void);
+
+#define LOC_MAP_FAILED ((const struct __locale_map *)-1)
+
+#define LCTRANS(msg, lc, loc) __lctrans(msg, (loc)->cat[(lc)])
+#define LCTRANS_CUR(msg)      __lctrans_cur(msg)
+
+#define C_LOCALE    ((locale_t) & __c_locale)
+#define UTF8_LOCALE ((locale_t) & __c_dot_utf8_locale)
+
+#define CURRENT_LOCALE _pthread_self()->pt_locale
+
+#define CURRENT_UTF8 (!!_pthread_self()->pt_locale->cat[LC_CTYPE])
+
+#undef MB_CUR_MAX
+#define MB_CUR_MAX (CURRENT_UTF8 ? 4 : 1)
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_STR_LOCALE_INTERNAL_H_ */
diff --git a/libc/str/longsort.c b/libc/str/longsort.c
index 5ed1911cf..e5d091f7f 100644
--- a/libc/str/longsort.c
+++ b/libc/str/longsort.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 
 static inline void InsertionSort(long *A, long n) {
diff --git a/libc/str/lz4cpy.c b/libc/str/lz4cpy.c
index 832501510..125114985 100644
--- a/libc/str/lz4cpy.c
+++ b/libc/str/lz4cpy.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pushpop.internal.h"
+#include "libc/intrin/pushpop.h"
 #include "libc/intrin/repmovsb.h"
 #include "libc/nexgen32e/kompressor.h"
 #include "libc/serialize.h"
diff --git a/libc/str/lz4len.c b/libc/str/lz4len.c
index 8dd0fcf04..3b4147794 100644
--- a/libc/str/lz4len.c
+++ b/libc/str/lz4len.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pushpop.internal.h"
+#include "libc/intrin/pushpop.h"
 #include "libc/nexgen32e/kompressor.h"
 #include "libc/str/str.h"
 
diff --git a/libc/str/mb.c b/libc/str/mb.c
deleted file mode 100644
index 98cbf47dd..000000000
--- a/libc/str/mb.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  Musl Libc                                                                   │
-│  Copyright © 2005-2014 Rich Felker, et al.                                   │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files (the             │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and/or sell copies of the Software, and to          │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│  The above copyright notice and this permission notice shall be              │
-│  included in all copies or substantial portions of the Software.             │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
-│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
-│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
-│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
-│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/mb.internal.h"
-__static_yoink("musl_libc_notice");
-
-#define C(x) (x < 2 ? -1 : (R(0x80, 0xc0) | x))
-#define D(x) C((x + 16))
-#define E(x)                      \
-  ((x == 0     ? R(0xa0, 0xc0)    \
-    : x == 0xd ? R(0x80, 0xa0)    \
-               : R(0x80, 0xc0)) | \
-   (R(0x80, 0xc0) >> 6) | x)
-#define F(x)                    \
-  ((x >= 5   ? 0                \
-    : x == 0 ? R(0x90, 0xc0)    \
-    : x == 4 ? R(0x80, 0x90)    \
-             : R(0x80, 0xc0)) | \
-   (R(0x80, 0xc0) >> 6) | (R(0x80, 0xc0) >> 12) | x)
-
-const uint32_t kMbBittab[51 /* ?! */] = {
-    C(0x2), C(0x3), C(0x4), C(0x5), C(0x6), C(0x7), C(0x8), C(0x9), C(0xa),
-    C(0xb), C(0xc), C(0xd), C(0xe), C(0xf), D(0x0), D(0x1), D(0x2), D(0x3),
-    D(0x4), D(0x5), D(0x6), D(0x7), D(0x8), D(0x9), D(0xa), D(0xb), D(0xc),
-    D(0xd), D(0xe), D(0xf), E(0x0), E(0x1), E(0x2), E(0x3), E(0x4), E(0x5),
-    E(0x6), E(0x7), E(0x8), E(0x9), E(0xa), E(0xb), E(0xc), E(0xd), E(0xe),
-    E(0xf), F(0x0), F(0x1), F(0x2), F(0x3), F(0x4),
-};
diff --git a/libc/str/mb.internal.h b/libc/str/mb.internal.h
deleted file mode 100644
index d5f2748c6..000000000
--- a/libc/str/mb.internal.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_STR_MB_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_STR_MB_INTERNAL_H_
-COSMOPOLITAN_C_START_
-
-#define SA             0xc2u
-#define SB             0xf4u
-#define CODEUNIT(c)    (0xdfff & (signed char)(c))
-#define IS_CODEUNIT(c) ((unsigned)(c) - 0xdf80 < 0x80)
-#define R(a, b)        ((uint32_t)((a == 0x80 ? 0x40u - b : 0u - a) << 23))
-#define FAILSTATE      R(0x80, 0x80)
-#define OOB(c, b) \
-  (((((b) >> 3) - 0x10) | (((b) >> 3) + ((int32_t)(c) >> 26))) & ~7)
-
-extern const uint32_t kMbBittab[51];
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_STR_MB_INTERNAL_H_ */
diff --git a/libc/str/mblen.c b/libc/str/mblen.c
deleted file mode 100644
index 807cfbd51..000000000
--- a/libc/str/mblen.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-int mblen(const char *s, size_t n) {
-  return mbtowc(0, s, n);
-}
diff --git a/libc/str/mbrlen.c b/libc/str/mbrlen.c
deleted file mode 100644
index 4f20fe1a0..000000000
--- a/libc/str/mbrlen.c
+++ /dev/null
@@ -1,26 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-size_t mbrlen(const char *s, size_t n, mbstate_t *t) {
-  static mbstate_t ss;
-  if (!t)
-    t = &ss;
-  return mbrtowc(0, s, n, t);
-}
diff --git a/libc/str/mbrtoc16.c b/libc/str/mbrtoc16.c
deleted file mode 100644
index 492ae68b6..000000000
--- a/libc/str/mbrtoc16.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  Musl Libc                                                                   │
-│  Copyright © 2005-2014 Rich Felker, et al.                                   │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files (the             │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and/or sell copies of the Software, and to          │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│  The above copyright notice and this permission notice shall be              │
-│  included in all copies or substantial portions of the Software.             │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
-│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
-│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
-│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
-│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/limits.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
-__static_yoink("musl_libc_notice");
-
-size_t mbrtoc16(char16_t *pc16, const char *s, size_t n, mbstate_t *ps) {
-  static unsigned internal_state;
-  if (!ps)
-    ps = (void *)&internal_state;
-  unsigned *pending = (unsigned *)ps;
-  if (!s)
-    return mbrtoc16(0, "", 1, ps);
-  /* mbrtowc states for partial UTF-8 characters have the high bit set;
-   * we use nonzero states without high bit for pending surrogates. */
-  if ((int)*pending > 0) {
-    if (pc16)
-      *pc16 = *pending;
-    *pending = 0;
-    return -3;
-  }
-  wchar_t wc;
-  size_t ret = mbrtowc(&wc, s, n, ps);
-  if (ret <= 4) {
-    if (wc >= 0x10000) {
-      *pending = (wc & 0x3ff) + 0xdc00;
-      wc = 0xd7c0 + (wc >> 10);
-    }
-    if (pc16)
-      *pc16 = wc;
-  }
-  return ret;
-}
diff --git a/libc/str/mbrtowc.c b/libc/str/mbrtowc.c
deleted file mode 100644
index c62d98dfc..000000000
--- a/libc/str/mbrtowc.c
+++ /dev/null
@@ -1,89 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  Musl Libc                                                                   │
-│  Copyright © 2005-2014 Rich Felker, et al.                                   │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files (the             │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and/or sell copies of the Software, and to          │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│  The above copyright notice and this permission notice shall be              │
-│  included in all copies or substantial portions of the Software.             │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
-│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
-│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
-│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
-│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
-__static_yoink("musl_libc_notice");
-
-size_t mbrtowc(wchar_t *wc, const char *src, size_t n, mbstate_t *st) {
-  static unsigned internal_state;
-  long wut;
-  unsigned c;
-  const unsigned char *s = (const void *)src;
-  const unsigned N = n;
-  wchar_t dummy;
-  if (!st)
-    st = (void *)&internal_state;
-  c = *(unsigned *)st;
-  if (!s) {
-    if (c)
-      goto ilseq;
-    return 0;
-  } else if (!wc) {
-    wc = &dummy;
-  }
-  if (!n)
-    return -2;
-  if (!c) {
-    if (*s < 0x80)
-      return !!(*wc = *s);
-    if (MB_CUR_MAX == 1)
-      return (*wc = CODEUNIT(*s)), 1;
-    if (*s - SA > SB - SA)
-      goto ilseq;
-    wut = *s++ - SA;
-    wut = MAX(0, MIN(ARRAYLEN(kMbBittab) - 1, wut));
-    c = kMbBittab[wut];
-    n--;
-  }
-  if (n) {
-    if (OOB(c, *s))
-      goto ilseq;
-  loop:
-    c = c << 6 | (*s++ - 0x80);
-    n--;
-    if (!(c & (1U << 31))) {
-      *(unsigned *)st = 0;
-      *wc = c;
-      return N - n;
-    }
-    if (n) {
-      if (*s - 0x80u >= 0x40)
-        goto ilseq;
-      goto loop;
-    }
-  }
-  *(unsigned *)st = c;
-  return -2;
-ilseq:
-  *(unsigned *)st = 0;
-  errno = EILSEQ;
-  return -1;
-}
diff --git a/libc/str/mbsinit.c b/libc/str/mbsinit.c
deleted file mode 100644
index e7bac0d7f..000000000
--- a/libc/str/mbsinit.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-int mbsinit(const mbstate_t *t) {
-  return !t || !*t;
-}
diff --git a/libc/str/mbsnrtowcs.c b/libc/str/mbsnrtowcs.c
deleted file mode 100644
index 9884cc3a9..000000000
--- a/libc/str/mbsnrtowcs.c
+++ /dev/null
@@ -1,92 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  Musl Libc                                                                   │
-│  Copyright © 2005-2014 Rich Felker, et al.                                   │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files (the             │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and/or sell copies of the Software, and to          │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│  The above copyright notice and this permission notice shall be              │
-│  included in all copies or substantial portions of the Software.             │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
-│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
-│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
-│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
-│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
-__static_yoink("musl_libc_notice");
-
-size_t mbsnrtowcs(wchar_t *wcs, const char **src, size_t n, size_t wn,
-                  mbstate_t *st) {
-  size_t l, cnt = 0, n2;
-  wchar_t *ws, wbuf[256];
-  const char *s = *src;
-  const char *tmp_s;
-  if (!wcs) {
-    ws = wbuf, wn = sizeof(wbuf) / sizeof(*wbuf);
-  } else {
-    ws = wcs;
-  }
-  /* making sure output buffer size is at most n/4 will ensure
-   * that mbsrtowcs never reads more than n input bytes. thus
-   * we can use mbsrtowcs as long as it's practical.. */
-  while (s && wn && ((n2 = n / 4) >= wn || n2 > 32)) {
-    if (n2 >= wn)
-      n2 = wn;
-    tmp_s = s;
-    l = mbsrtowcs(ws, &s, n2, st);
-    if (!(l + 1)) {
-      cnt = l;
-      wn = 0;
-      break;
-    }
-    if (ws != wbuf) {
-      ws += l;
-      wn -= l;
-    }
-    n = s ? n - (s - tmp_s) : 0;
-    cnt += l;
-  }
-  if (s)
-    while (wn && n) {
-      l = mbrtowc(ws, s, n, st);
-      if (l + 2 <= 2) {
-        if (!(l + 1)) {
-          cnt = l;
-          break;
-        }
-        if (!l) {
-          s = 0;
-          break;
-        }
-        /* have to roll back partial character */
-        *(unsigned *)st = 0;
-        break;
-      }
-      s += l;
-      n -= l;
-      /* safe - this loop runs fewer than sizeof(wbuf)/8 times */
-      ws++;
-      wn--;
-      cnt++;
-    }
-  if (wcs)
-    *src = s;
-  return cnt;
-}
diff --git a/libc/str/mbsrtowcs.c b/libc/str/mbsrtowcs.c
deleted file mode 100644
index eaebe234c..000000000
--- a/libc/str/mbsrtowcs.c
+++ /dev/null
@@ -1,147 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  Musl Libc                                                                   │
-│  Copyright © 2005-2014 Rich Felker, et al.                                   │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files (the             │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and/or sell copies of the Software, and to          │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│  The above copyright notice and this permission notice shall be              │
-│  included in all copies or substantial portions of the Software.             │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
-│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
-│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
-│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
-│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
-__static_yoink("musl_libc_notice");
-
-size_t mbsrtowcs(wchar_t *ws, const char **src, size_t wn, mbstate_t *st) {
-  const unsigned char *s = (const void *)*src;
-  size_t wn0 = wn;
-  unsigned c = 0;
-  if (st && (c = *(unsigned *)st)) {
-    if (ws) {
-      *(unsigned *)st = 0;
-      goto resume;
-    } else {
-      goto resume0;
-    }
-  }
-  if (MB_CUR_MAX == 1) {
-    if (!ws)
-      return strlen((const char *)s);
-    for (;;) {
-      if (!wn) {
-        *src = (const void *)s;
-        return wn0;
-      }
-      if (!*s)
-        break;
-      c = *s++;
-      *ws++ = CODEUNIT(c);
-      wn--;
-    }
-    *ws = 0;
-    *src = 0;
-    return wn0 - wn;
-  }
-  if (!ws)
-    for (;;) {
-      if (*s - 1u < 0x7f) {
-        s++;
-        wn--;
-        continue;
-      }
-      if (*s - SA > SB - SA)
-        break;
-      c = kMbBittab[*s++ - SA];
-    resume0:
-      if (OOB(c, *s)) {
-        s--;
-        break;
-      }
-      s++;
-      if (c & (1U << 25)) {
-        if (*s - 0x80u >= 0x40) {
-          s -= 2;
-          break;
-        }
-        s++;
-        if (c & (1U << 19)) {
-          if (*s - 0x80u >= 0x40) {
-            s -= 3;
-            break;
-          }
-          s++;
-        }
-      }
-      wn--;
-      c = 0;
-    }
-  else
-    for (;;) {
-      if (!wn) {
-        *src = (const void *)s;
-        return wn0;
-      }
-      if (*s - 1u < 0x7f) {
-        *ws++ = *s++;
-        wn--;
-        continue;
-      }
-      if (*s - SA > SB - SA)
-        break;
-      c = kMbBittab[*s++ - SA];
-    resume:
-      if (OOB(c, *s)) {
-        s--;
-        break;
-      }
-      c = (c << 6) | (*s++ - 0x80);
-      if (c & (1U << 31)) {
-        if (*s - 0x80u >= 0x40) {
-          s -= 2;
-          break;
-        }
-        c = (c << 6) | (*s++ - 0x80);
-        if (c & (1U << 31)) {
-          if (*s - 0x80u >= 0x40) {
-            s -= 3;
-            break;
-          }
-          c = (c << 6) | (*s++ - 0x80);
-        }
-      }
-      *ws++ = c;
-      wn--;
-      c = 0;
-    }
-  if (!c && !*s) {
-    if (ws) {
-      *ws = 0;
-      *src = 0;
-    }
-    return wn0 - wn;
-  }
-  errno = EILSEQ;
-  if (ws)
-    *src = (const void *)s;
-  return -1;
-}
diff --git a/libc/str/mbstowcs.c b/libc/str/mbstowcs.c
deleted file mode 100644
index 936499e03..000000000
--- a/libc/str/mbstowcs.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-size_t mbstowcs(wchar_t *pwc, const char *s, size_t wn) {
-  return mbsrtowcs(pwc, (void *)&s, wn, 0);
-}
diff --git a/libc/str/mbtowc.c b/libc/str/mbtowc.c
deleted file mode 100644
index 34b5f773d..000000000
--- a/libc/str/mbtowc.c
+++ /dev/null
@@ -1,77 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  Musl Libc                                                                   │
-│  Copyright © 2005-2014 Rich Felker, et al.                                   │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files (the             │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and/or sell copies of the Software, and to          │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│  The above copyright notice and this permission notice shall be              │
-│  included in all copies or substantial portions of the Software.             │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
-│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
-│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
-│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
-│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
-__static_yoink("musl_libc_notice");
-
-int mbtowc(wchar_t *restrict wc, const char *restrict src, size_t n) {
-  unsigned c;
-  const unsigned char *s = (const void *)src;
-  wchar_t dummy;
-  if (!s)
-    return 0;
-  if (!n)
-    goto ilseq;
-  if (!wc)
-    wc = &dummy;
-  if (*s < 0x80)
-    return !!(*wc = *s);
-  if (MB_CUR_MAX == 1)
-    return (*wc = CODEUNIT(*s)), 1;
-  if (*s - SA > SB - SA)
-    goto ilseq;
-  c = kMbBittab[*s++ - SA];
-  /* Avoid excessive checks against n: If shifting the state n-1
-   * times does not clear the high bit, then the value of n is
-   * insufficient to read a character */
-  if (n < 4 && ((c << (6 * n - 6)) & (1U << 31)))
-    goto ilseq;
-  if (OOB(c, *s))
-    goto ilseq;
-  c = c << 6 | (*s++ - 0x80);
-  if (!(c & (1U << 31))) {
-    *wc = c;
-    return 2;
-  }
-  if (*s - 0x80u >= 0x40)
-    goto ilseq;
-  c = c << 6 | (*s++ - 0x80);
-  if (!(c & (1U << 31))) {
-    *wc = c;
-    return 3;
-  }
-  if (*s - 0x80u >= 0x40)
-    goto ilseq;
-  *wc = c << 6 | (*s++ - 0x80);
-  return 4;
-ilseq:
-  errno = EILSEQ;
-  return -1;
-}
diff --git a/libc/str/memcasecmp.c b/libc/str/memcasecmp.c
index 05e552f0b..28a221c5f 100644
--- a/libc/str/memcasecmp.c
+++ b/libc/str/memcasecmp.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/serialize.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * Compares memory case-insensitively.
diff --git a/libc/str/memccpy.c b/libc/str/memccpy.c
index e910f0929..2d42920a6 100644
--- a/libc/str/memccpy.c
+++ b/libc/str/memccpy.c
@@ -45,13 +45,14 @@
  * @asyncsignalsafe
  */
 void *memccpy(void *dst, const void *src, int c, size_t n) {
-  char *d;
-  size_t i;
-  const char *s;
-  for (d = dst, s = src, i = 0; i < n; ++i) {
-    if (((d[i] = s[i]) & 255) == (c & 255)) {
-      return d + i + 1;
-    }
+  const char *p;
+  // this memchr() call is only correct if your memchr() implementation
+  // offers the same readahead safety guarantees as cosmopolitan's does
+  if ((p = memchr(src, c, n))) {
+    size_t m = p + 1 - (const char *)src;
+    memmove(dst, src, m);
+    return (char *)dst + m;
   }
+  memmove(dst, src, n);
   return 0;
 }
diff --git a/libc/str/memmem.c b/libc/str/memmem.c
index ef3f721f0..f2b072275 100644
--- a/libc/str/memmem.c
+++ b/libc/str/memmem.c
@@ -16,49 +16,60 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/dce.h"
 #include "libc/intrin/likely.h"
+#include "libc/str/kmp.h"
 #include "libc/str/str.h"
-
-typedef char xmm_t __attribute__((__vector_size__(16), __aligned__(16)));
+#include "third_party/aarch64/arm_neon.internal.h"
+#include "third_party/intel/emmintrin.internal.h"
 
 /**
  * Searches for fixed-length substring in memory region.
  *
+ * This function offers assurances against pathological cases, using KMP
+ * if no progress is being made on the O(nm) vectorized fast path. It is
+ * important to note that, if `needle` is untrusted, that it not be long
+ * enough to overflow the stack. That's because KMP needs to allocate an
+ * array of longs the same length as `needle` and it needs to do it with
+ * stack memory because this function is safe to call in signal handlers
+ *
  * @param haystack is the region of memory to be searched
  * @param haystacklen is its character count
  * @param needle contains the memory for which we're searching
  * @param needlelen is its character count
  * @return pointer to first result or NULL if not found
+ * @asyncsignalsafe
  */
 __vex void *memmem(const void *haystack, size_t haystacklen, const void *needle,
                    size_t needlelen) {
 #if defined(__x86_64__) && !defined(__chibicc__)
   char c;
-  xmm_t n;
-  const xmm_t *v;
+  __m128i n;
+  const __m128i *v;
   unsigned i, k, m;
+  long progress = 0;
   const char *p, *q, *e;
+  long scare = -(needlelen * 10);
   if (!needlelen)
     return (void *)haystack;
   if (UNLIKELY(needlelen > haystacklen))
     return 0;
   q = needle;
   c = *q;
-  n = (xmm_t){c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c};
+  n = _mm_set1_epi8(c);
   p = haystack;
   e = p + haystacklen;
   k = (uintptr_t)p & 15;
-  v = (const xmm_t *)((uintptr_t)p & -16);
-  m = __builtin_ia32_pmovmskb128(*v == n);
+  v = (const __m128i *)((uintptr_t)p & -16);
+  m = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_load_si128(v), n));
   m >>= k;
   m <<= k;
   for (;;) {
     while (!m) {
       ++v;
+      progress += 16;
       if ((const char *)v >= e)
         return 0;
-      m = __builtin_ia32_pmovmskb128(*v == n);
+      m = _mm_movemask_epi8(_mm_cmpeq_epi8(_mm_load_si128(v), n));
     }
     do {
       k = __builtin_ctzl(m);
@@ -66,6 +77,8 @@ __vex void *memmem(const void *haystack, size_t haystacklen, const void *needle,
       if (UNLIKELY(p + needlelen > e))
         return 0;
       for (i = 1;; ++i) {
+        if (--progress <= scare)
+          goto OfferPathologicalAssurances;
         if (i == needlelen)
           return (/*unconst*/ char *)p;
         if (p[i] != q[i])
@@ -74,22 +87,59 @@ __vex void *memmem(const void *haystack, size_t haystacklen, const void *needle,
       m &= ~(1 << k);
     } while (m);
   }
-#else
-  size_t i, j;
+OfferPathologicalAssurances:
+#elif defined(__aarch64__) && defined(__ARM_NEON)
+  char c;
+  uint8x16_t n;
+  const uint8x16_t *v;
+  size_t i, k;
+  uint64_t m;
+  long progress = 0;
+  const char *p, *q, *e;
+  long scare = -(needlelen * 10);
   if (!needlelen)
     return (void *)haystack;
-  if (needlelen > haystacklen)
+  if (UNLIKELY(needlelen > haystacklen))
     return 0;
-  for (i = 0; i < haystacklen; ++i) {
-    for (j = 0;; ++j) {
-      if (j == needlelen)
-        return (/*unconst*/ char *)haystack + i;
-      if (i + j == haystacklen)
-        break;
-      if (((char *)haystack)[i + j] != ((char *)needle)[j])
-        break;
+  q = needle;
+  c = *q;
+  n = vdupq_n_u8(c);
+  p = haystack;
+  e = p + haystacklen;
+  k = (uintptr_t)p & 15;
+  v = (const uint8x16_t *)((uintptr_t)p & -16);
+  uint8x16_t cmp = vceqq_u8(vld1q_u8((const uint8_t *)v), n);
+  uint8x8_t mask = vshrn_n_u16(vreinterpretq_u16_u8(cmp), 4);
+  vst1_u8((uint8_t *)&m, mask);
+  m >>= k * 4;
+  m <<= k * 4;
+  for (;;) {
+    while (!m) {
+      ++v;
+      progress += 16;
+      if ((const char *)v >= e)
+        return 0;
+      cmp = vceqq_u8(vld1q_u8((const uint8_t *)v), n);
+      mask = vshrn_n_u16(vreinterpretq_u16_u8(cmp), 4);
+      vst1_u8((uint8_t *)&m, mask);
     }
+    do {
+      k = __builtin_ctzll(m) >> 2;
+      p = (const char *)v + k;
+      if (UNLIKELY(p + needlelen > e))
+        return 0;
+      for (i = 1;; ++i) {
+        if (--progress <= scare)
+          goto OfferPathologicalAssurances;
+        if (i == needlelen)
+          return (/*unconst*/ char *)p;
+        if (p[i] != q[i])
+          break;
+      }
+      m &= ~(0xFULL << (k * 4));
+    } while (m);
   }
-  return 0;
+OfferPathologicalAssurances:
 #endif
+  return __memmem_kmp(haystack, haystacklen, needle, needlelen);
 }
diff --git a/libc/str/newlocale.c b/libc/str/newlocale.c
deleted file mode 100644
index ad0d5ff2e..000000000
--- a/libc/str/newlocale.c
+++ /dev/null
@@ -1,25 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/locale.h"
-#include "libc/sysv/errfuns.h"
-
-locale_t newlocale(int catmask, const char *locale, locale_t base) {
-  // TODO: implement me
-  return 0;
-}
diff --git a/libc/str/nonspacing.inc b/libc/str/nonspacing.inc
new file mode 100644
index 000000000..7746f3b60
--- /dev/null
+++ b/libc/str/nonspacing.inc
@@ -0,0 +1,91 @@
+16,16,16,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,16,33,16,16,16,34,35,36,
+37,38,39,40,16,16,41,16,16,16,16,16,16,16,16,16,16,16,42,43,16,16,44,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,45,16,46,47,48,49,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,50,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,51,16,16,52,
+53,16,54,55,56,16,16,16,16,16,16,57,16,16,58,16,59,60,61,62,63,64,65,66,67,68,
+69,70,16,71,72,73,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,74,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,75,76,16,16,16,77,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,78,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,79,80,16,16,16,16,16,16,16,81,16,16,16,16,16,82,83,84,16,16,16,16,16,85,
+86,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,248,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,254,255,255,255,255,191,182,0,0,0,0,0,0,0,63,0,255,23,0,0,0,0,0,248,255,
+255,0,0,1,0,0,0,0,0,0,0,0,0,0,0,192,191,159,61,0,0,0,128,2,0,0,0,255,255,255,
+7,0,0,0,0,0,0,0,0,0,0,192,255,1,0,0,0,0,0,0,248,15,32,0,0,192,251,239,62,0,0,
+0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,255,255,255,255,
+255,7,0,0,0,0,0,0,20,254,33,254,0,12,0,0,0,2,0,0,0,0,0,0,16,30,32,0,0,12,0,0,
+64,6,0,0,0,0,0,0,16,134,57,2,0,0,0,35,0,6,0,0,0,0,0,0,16,190,33,0,0,12,0,0,
+252,2,0,0,0,0,0,0,144,30,32,64,0,12,0,0,0,4,0,0,0,0,0,0,0,1,32,0,0,0,0,0,0,17,
+0,0,0,0,0,0,192,193,61,96,0,12,0,0,0,2,0,0,0,0,0,0,144,64,48,0,0,12,0,0,0,3,0,
+0,0,0,0,0,24,30,32,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,4,92,0,0,0,0,0,0,0,0,0,0,0,
+242,7,128,127,0,0,0,0,0,0,0,0,0,0,0,0,242,31,0,63,0,0,0,0,0,0,0,0,0,3,0,0,160,
+2,0,0,0,0,0,0,254,127,223,224,255,254,255,255,255,31,64,0,0,0,0,0,0,0,0,0,0,0,
+0,224,253,102,0,0,0,195,1,0,30,0,100,32,0,32,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,224,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,28,0,0,0,28,0,0,0,12,0,0,0,12,0,0,0,0,0,0,0,176,63,64,254,
+15,32,0,0,0,0,0,120,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,0,2,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,135,1,4,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+128,9,0,0,0,0,0,0,64,127,229,31,248,159,0,0,0,0,0,0,255,127,0,0,0,0,0,0,0,0,
+15,0,0,0,0,0,208,23,4,0,0,0,0,248,15,0,3,0,0,0,60,59,0,0,0,0,0,0,64,163,3,0,0,
+0,0,0,0,240,207,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,247,255,253,33,16,
+3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,
+251,0,248,0,0,0,124,0,0,0,0,0,0,223,255,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,
+255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,0,0,0,0,
+0,60,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,128,247,63,0,0,0,192,0,0,0,0,0,0,0,0,0,0,3,0,68,8,0,0,96,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,48,0,0,0,255,255,3,128,0,0,0,0,192,63,0,0,128,255,3,0,
+0,0,0,0,7,0,0,0,0,0,200,51,0,0,0,0,32,0,0,
+0,0,0,0,0,0,126,102,0,8,16,0,0,0,0,0,16,0,0,0,0,0,0,157,193,2,0,0,0,0,48,64,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,33,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,0,0,0,
+64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,0,0,255,
+255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,1,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,240,0,
+0,0,0,0,135,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,0,0,0,0,0,240,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,1,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,255,127,0,0,0,0,0,0,128,
+3,0,0,0,0,0,120,38,0,32,0,0,0,0,0,0,7,0,0,0,128,239,31,0,0,0,0,0,0,0,8,0,3,0,
+0,0,0,0,192,127,0,30,0,0,0,0,0,0,0,0,0,0,0,128,211,64,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,128,248,7,0,0,3,0,0,0,0,0,0,24,1,0,0,0,192,31,31,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,255,92,0,0,64,0,0,0,0,0,0,0,0,0,0,248,133,13,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,60,176,1,0,0,48,0,0,0,0,0,0,0,0,0,0,
+248,167,1,0,0,0,0,0,0,0,0,0,0,0,0,40,191,0,0,0,0,0,0,0,0,0,0,0,0,224,188,15,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,6,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,240,12,1,0,0,0,254,7,0,0,0,0,248,121,128,0,126,14,0,0,0,0,0,252,
+127,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,191,0,0,0,0,0,0,0,0,0,0,252,255,
+255,252,109,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,126,180,191,0,0,0,0,0,0,0,0,0,163,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,0,255,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,128,7,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,15,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,3,248,255,231,15,0,0,0,60,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,28,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
+255,255,255,255,127,248,255,255,255,255,255,31,32,0,16,0,0,248,254,255,0,0,0,
+0,0,0,0,0,0,0,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,240,7,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
diff --git a/libc/str/setlocale.c b/libc/str/setlocale.c
deleted file mode 100644
index 409e97590..000000000
--- a/libc/str/setlocale.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/str/locale.h"
-#include "libc/str/str.h"
-
-/**
- * Sets program locale.
- *
- * Cosmopolitan only supports the C or POSIX locale with UTF-8.
- */
-char *setlocale(int category, const char *locale) {
-  char *res;
-  if (!locale || (*locale == '\0')) {
-    res = "C";
-  } else if (!strcmp(locale, "C") ||        //
-             !strcmp(locale, "POSIX") ||    //
-             !strcmp(locale, "C.UTF-8") ||  //
-             !strcmp(locale, "en_US.UTF-8")) {
-    res = (char *)locale;
-  } else {
-    res = NULL;
-  }
-  STRACE("setlocale(%d, %#s) → %s", category, locale, res);
-  return res;
-}
diff --git a/libc/str/startswithi.c b/libc/str/startswithi.c
index 974ece794..136192abf 100644
--- a/libc/str/startswithi.c
+++ b/libc/str/startswithi.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * Checks if string starts with prefix, case insensitively.
diff --git a/libc/str/stpncpy.c b/libc/str/stpncpy.c
index 30b6f2bb9..66d2d3e55 100644
--- a/libc/str/stpncpy.c
+++ b/libc/str/stpncpy.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 
 /**
diff --git a/libc/str/str.h b/libc/str/str.h
index fdc97b244..2075dcf4b 100644
--- a/libc/str/str.h
+++ b/libc/str/str.h
@@ -3,9 +3,6 @@
 
 #define INVALID_CODEPOINT 0xfffd
 
-#define _tolower(u) (0040 | (u))
-#define _toupper(u) (0137 & (u))
-
 #ifdef _COSMO_SOURCE
 #define chomp         _chomp
 #define chomp16       _chomp16
@@ -20,49 +17,17 @@
 #define wcsstartswith _wcsstartswith
 #endif /* _COSMO_SOURCE */
 
+#ifndef WEOF
+#define WEOF -1u
+#endif
+
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-int isascii(int) libcesque;
-int isspace(int) libcesque;
-int isalpha(int) libcesque;
-int isdigit(int) libcesque;
-int isalnum(int) libcesque;
-int isxdigit(int) libcesque;
-int isprint(int) libcesque;
-int islower(int) libcesque;
-int isupper(int) libcesque;
-int isblank(int) libcesque;
-int iscntrl(int) libcesque;
-int isgraph(int) libcesque;
-int tolower(int) libcesque;
-int ispunct(int) libcesque;
-int toupper(int) libcesque;
-int toascii(int) libcesque;
-
-int iswalnum(wint_t) libcesque;
-int iswalpha(wint_t) libcesque;
-int iswblank(wint_t) libcesque;
-int iswcntrl(wint_t) libcesque;
-int iswdigit(wint_t) libcesque;
-int iswgraph(wint_t) libcesque;
-int iswlower(wint_t) libcesque;
-int iswspace(wint_t) libcesque;
-int iswupper(wint_t) libcesque;
-int iswxdigit(wint_t) libcesque;
-int iswpunct(wint_t) libcesque;
-int iswprint(wint_t) libcesque;
-int iswseparator(wint_t) libcesque;
-wint_t towlower(wint_t) libcesque;
-wint_t towupper(wint_t) libcesque;
-
 void *memset(void *, int, size_t) memcpyesque;
 void *memmove(void *, const void *, size_t) memcpyesque;
-void *memcpy(void *restrict, const void *restrict, size_t) memcpyesque;
-void *mempcpy(void *restrict, const void *restrict, size_t) memcpyesque;
-char *hexpcpy(char *restrict, const void *restrict, size_t) memcpyesque;
-void *memccpy(void *restrict, const void *restrict, int, size_t) memcpyesque;
-void explicit_bzero(void *, size_t);
+void *memcpy(void *, const void *, size_t) memcpyesque;
+char *hexpcpy(char *, const void *, size_t) memcpyesque;
 
 int memcmp(const void *, const void *, size_t) strlenesque;
 int timingsafe_bcmp(const void *, const void *, size_t) libcesque;
@@ -73,7 +38,6 @@ size_t strnlen(const char *, size_t) strlenesque;
 size_t strnlen_s(const char *, size_t) libcesque;
 char *strchr(const char *, int) strlenesque;
 void *memchr(const void *, int, size_t) strlenesque;
-char *strchrnul(const char *, int) strlenesque returnsnonnull;
 void *rawmemchr(const void *, int) strlenesque returnsnonnull;
 size_t wcslen(const wchar_t *) strlenesque;
 size_t wcsnlen(const wchar_t *, size_t) strlenesque;
@@ -83,7 +47,6 @@ wchar_t *wmemchr(const wchar_t *, wchar_t, size_t) strlenesque;
 wchar_t *wcschrnul(const wchar_t *, wchar_t)
 strlenesque returnsnonnull;
 char *strstr(const char *, const char *) strlenesque;
-char *strcasestr(const char *, const char *) strlenesque;
 wchar_t *wcsstr(const wchar_t *, const wchar_t *) strlenesque;
 int strcmp(const char *, const char *) strlenesque;
 int strncmp(const char *, const char *, size_t) strlenesque;
@@ -91,14 +54,11 @@ int wcscmp(const wchar_t *, const wchar_t *) strlenesque;
 int wcsncmp(const wchar_t *, const wchar_t *, size_t) strlenesque;
 int wmemcmp(const wchar_t *, const wchar_t *, size_t) strlenesque;
 int strcasecmp(const char *, const char *) strlenesque;
-int memcasecmp(const void *, const void *, size_t) strlenesque;
 int wcscasecmp(const wchar_t *, const wchar_t *) strlenesque;
 int strncasecmp(const char *, const char *, size_t) strlenesque;
 int wcsncasecmp(const wchar_t *, const wchar_t *, size_t) strlenesque;
 char *strrchr(const char *, int) strlenesque;
-void *memrchr(const void *, int, size_t) strlenesque;
 wchar_t *wcsrchr(const wchar_t *, wchar_t) strlenesque;
-void *wmemrchr(const wchar_t *, wchar_t, size_t) strlenesque;
 char *strpbrk(const char *, const char *) strlenesque;
 wchar_t *wcspbrk(const wchar_t *, const wchar_t *) strlenesque;
 size_t strspn(const char *, const char *) strlenesque;
@@ -107,13 +67,10 @@ size_t strcspn(const char *, const char *) strlenesque;
 size_t wcscspn(const wchar_t *, const wchar_t *) strlenesque;
 void *memfrob(void *, size_t) memcpyesque;
 int strcoll(const char *, const char *) strlenesque;
-char *strsep(char **, const char *) libcesque paramsnonnull();
 char *stpcpy(char *, const char *) memcpyesque;
 char *stpncpy(char *, const char *, size_t) memcpyesque;
 char *strcat(char *, const char *) memcpyesque;
 wchar_t *wcscat(wchar_t *, const wchar_t *) memcpyesque;
-size_t strlcpy(char *, const char *, size_t) libcesque;
-size_t strlcat(char *, const char *, size_t) libcesque;
 size_t strxfrm(char *, const char *, size_t) libcesque;
 char *strcpy(char *, const char *) memcpyesque;
 wchar_t *wcscpy(wchar_t *, const wchar_t *) memcpyesque;
@@ -123,13 +80,9 @@ char *strncpy(char *, const char *, size_t) memcpyesque;
 char *strtok(char *, const char *) paramsnonnull((2)) libcesque;
 char *strtok_r(char *, const char *, char **) paramsnonnull((2, 3));
 wchar_t *wcstok(wchar_t *, const wchar_t *, wchar_t **) paramsnonnull((2, 3));
-int strverscmp(const char *, const char *) libcesque;
 wchar_t *wmemset(wchar_t *, wchar_t, size_t) memcpyesque;
 wchar_t *wmemcpy(wchar_t *, const wchar_t *, size_t) memcpyesque;
-wchar_t *wmempcpy(wchar_t *, const wchar_t *, size_t) memcpyesque;
 wchar_t *wmemmove(wchar_t *, const wchar_t *, size_t) memcpyesque;
-void *memmem(const void *, size_t, const void *, size_t)
-libcesque nosideeffect;
 ssize_t strfmon(char *, size_t, const char *, ...) libcesque;
 long a64l(const char *) libcesque;
 char *l64a(long) libcesque;
@@ -157,20 +110,40 @@ int wctomb(char *, wchar_t) libcesque;
 int wctob(wint_t) libcesque;
 wint_t btowc(int) libcesque;
 
-typedef unsigned wctype_t;
-wctype_t wctype(const char *) strlenesque;
-pureconst int iswctype(wint_t, wctype_t) libcesque;
-
-typedef const int *wctrans_t;
-wctrans_t wctrans(const char *) libcesque;
-wint_t towctrans(wint_t, wctrans_t) libcesque;
-
 int getsubopt(char **, char *const *, char **) libcesque paramsnonnull();
 char *strsignal(int) returnsnonnull libcesque;
 char *strerror(int) returnsnonnull dontthrow dontcallback;
 errno_t strerror_r(int, char *, size_t) libcesque;
 char *__xpg_strerror_r(int, char *, size_t) libcesque;
 
+int bcmp(const void *, const void *, size_t) strlenesque;
+void bcopy(const void *, void *, size_t) memcpyesque;
+void bzero(void *, size_t) memcpyesque;
+char *index(const char *, int) strlenesque;
+char *rindex(const char *, int) strlenesque;
+
+#if defined(_COSMO_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE) || \
+    defined(_XOPEN_SOURCE)
+void *memccpy(void *, const void *, int, size_t) memcpyesque;
+#endif
+
+#if defined(_COSMO_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
+char *strsep(char **, const char *) libcesque paramsnonnull();
+void explicit_bzero(void *, size_t);
+size_t strlcpy(char *, const char *, size_t) libcesque;
+size_t strlcat(char *, const char *, size_t) libcesque;
+#endif
+
+#if defined(_COSMO_SOURCE) || defined(_GNU_SOURCE)
+int strverscmp(const char *, const char *) libcesque;
+char *strchrnul(const char *, int) strlenesque returnsnonnull;
+char *strcasestr(const char *, const char *) strlenesque;
+void *memmem(const void *, size_t, const void *, size_t) libcesque;
+void *memrchr(const void *, int, size_t) strlenesque;
+void *mempcpy(void *, const void *, size_t) memcpyesque;
+wchar_t *wmempcpy(wchar_t *, const wchar_t *, size_t) memcpyesque;
+#endif
+
 #ifdef _COSMO_SOURCE
 pureconst uint64_t tpenc(uint32_t) libcesque;
 char *chomp(char *) libcesque;
@@ -181,6 +154,7 @@ bool32 startswithi(const char *, const char *) strlenesque;
 bool32 endswith(const char *, const char *) strlenesque;
 bool32 istext(const void *, size_t) libcesque;
 bool32 isutf8(const void *, size_t) libcesque;
+void *wmemrchr(const wchar_t *, wchar_t, size_t) strlenesque;
 const char *strsignal_r(int, char[21]) returnsnonnull libcesque __wur;
 char16_t *chomp16(char16_t *) libcesque;
 size_t strlen16(const char16_t *) strlenesque;
@@ -190,6 +164,7 @@ void *memchr16(const void *, int, size_t) strlenesque;
 char16_t *strchrnul16(const char16_t *, int) strlenesque returnsnonnull;
 void *rawmemchr16(const void *, int) strlenesque returnsnonnull;
 char16_t *strstr16(const char16_t *, const char16_t *) strlenesque;
+int memcasecmp(const void *, const void *, size_t) strlenesque;
 int strcmp16(const char16_t *, const char16_t *) strlenesque;
 int strncmp16(const char16_t *, const char16_t *, size_t) strlenesque;
 int strcasecmp16(const char16_t *, const char16_t *) strlenesque;
@@ -213,17 +188,6 @@ char *__join_paths(char *, size_t, const char *, const char *) libcesque __wur;
 int __mkntpathat(int, const char *, int, char16_t[hasatleast 1024]);
 #endif /* _COSMO_SOURCE */
 
-#if defined(_COSMO_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE) || \
-    defined(_POSIX_SOURCE) ||                                                 \
-    (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE + 0 < 200809L) ||            \
-    (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE + 0 < 700)
-int bcmp(const void *, const void *, size_t) strlenesque;
-void bcopy(const void *, void *, size_t) memcpyesque;
-void bzero(void *, size_t) memcpyesque;
-char *index(const char *, int) strlenesque;
-char *rindex(const char *, int) strlenesque;
-#endif
-
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
 #endif /* COSMOPOLITAN_LIBC_STR_STR_H_ */
diff --git a/libc/str/strcasecmp.c b/libc/str/strcasecmp.c
index 2443afd93..8510f6034 100644
--- a/libc/str/strcasecmp.c
+++ b/libc/str/strcasecmp.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * Compares NUL-terminated strings ascii case-insensitively.
diff --git a/libc/str/strcasestr.c b/libc/str/strcasestr.c
index 26f969c09..cf0cfe2d5 100644
--- a/libc/str/strcasestr.c
+++ b/libc/str/strcasestr.c
@@ -17,10 +17,69 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
-#include "libc/dce.h"
-#include "libc/str/tab.internal.h"
+#include "libc/ctype.h"
+#include "libc/mem/alloca.h"
+#include "libc/runtime/stack.h"
+#include "libc/str/tab.h"
+#include "third_party/aarch64/arm_neon.internal.h"
+#include "third_party/intel/immintrin.internal.h"
 
-typedef char xmm_t __attribute__((__vector_size__(16), __aligned__(16)));
+static int ToUpper(int c) {
+  return 'a' <= c && c <= 'z' ? c - ('a' - 'A') : c;
+}
+
+static void computeLPS(const char *pattern, long M, long *lps) {
+  long len = 0;
+  lps[0] = 0;
+  long i = 1;
+  while (i < M) {
+    if (kToLower[pattern[i] & 255] == kToLower[pattern[len] & 255]) {
+      len++;
+      lps[i] = len;
+      i++;
+    } else {
+      if (len != 0) {
+        len = lps[len - 1];
+      } else {
+        lps[i] = 0;
+        i++;
+      }
+    }
+  }
+}
+
+static char *kmp(const char *s, size_t n, const char *ss, size_t m) {
+  if (!m)
+    return (char *)s;
+  if (n < m)
+    return NULL;
+#pragma GCC push_options
+#pragma GCC diagnostic ignored "-Walloca-larger-than="
+#pragma GCC diagnostic ignored "-Wanalyzer-out-of-bounds"
+  long need = sizeof(long) * m;
+  long *lps = (long *)alloca(need);
+  CheckLargeStackAllocation(lps, need);
+#pragma GCC pop_options
+  computeLPS(ss, m, lps);
+  long i = 0;
+  long j = 0;
+  while (i < n) {
+    if (kToLower[ss[j] & 255] == kToLower[s[i] & 255]) {
+      i++;
+      j++;
+    }
+    if (j == m) {
+      return (char *)(s + i - j);
+    } else if (i < n && kToLower[ss[j] & 255] != kToLower[s[i] & 255]) {
+      if (j != 0) {
+        j = lps[j - 1];
+      } else {
+        i++;
+      }
+    }
+  }
+  return NULL;
+}
 
 /**
  * Searches for substring case-insensitively.
@@ -28,65 +87,108 @@ typedef char xmm_t __attribute__((__vector_size__(16), __aligned__(16)));
  * @param haystack is the search area, as a NUL-terminated string
  * @param needle is the desired substring, also NUL-terminated
  * @return pointer to first substring within haystack, or NULL
- * @note this implementation goes fast in practice but isn't hardened
- *     against pathological cases, and therefore shouldn't be used on
- *     untrustworthy data
  * @asyncsignalsafe
  * @see strstr()
  */
-__vex char *strcasestr(const char *haystack, const char *needle) {
-#if defined(__x86_64__) && !defined(__chibicc__)
-  char c;
-  size_t i;
-  unsigned k, m;
-  const xmm_t *p;
-  xmm_t v, n1, n2, z = {0};
+char *strcasestr(const char *haystack, const char *needle) {
   if (haystack == needle || !*needle)
     return (char *)haystack;
-  c = *needle;
-  n1 = (xmm_t){c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c};
-  c = kToLower[c & 255];
-  n2 = (xmm_t){c, c, c, c, c, c, c, c, c, c, c, c, c, c, c, c};
+#if defined(__x86_64__) && !defined(__chibicc__)
+  size_t i;
+  unsigned k, m;
+  const __m128i *p;
+  long progress = 0;
+  __m128i v, nl, nu, z = _mm_setzero_si128();
+  const char *hay = haystack;
+  char first_lower = kToLower[*needle & 255];
+  char first_upper = ToUpper(*needle);
+  nl = _mm_set1_epi8(first_lower);
+  nu = _mm_set1_epi8(first_upper);
   for (;;) {
-    k = (uintptr_t)haystack & 15;
-    p = (const xmm_t *)((uintptr_t)haystack & -16);
-    v = *p;
-    m = __builtin_ia32_pmovmskb128((v == z) | (v == n1) | (v == n2));
+    k = (uintptr_t)hay & 15;
+    p = (const __m128i *)((uintptr_t)hay & -16);
+    v = _mm_load_si128(p);
+    m = _mm_movemask_epi8(_mm_or_si128(
+        _mm_or_si128(_mm_cmpeq_epi8(v, z),    // Check for null terminator
+                     _mm_cmpeq_epi8(v, nl)),  // Check lowercase
+        _mm_cmpeq_epi8(v, nu)));              // Check uppercase
     m >>= k;
     m <<= k;
     while (!m) {
-      v = *++p;
-      m = __builtin_ia32_pmovmskb128((v == z) | (v == n1) | (v == n2));
+      progress += 16;
+      v = _mm_load_si128(++p);
+      m = _mm_movemask_epi8(_mm_or_si128(
+          _mm_or_si128(_mm_cmpeq_epi8(v, z), _mm_cmpeq_epi8(v, nl)),
+          _mm_cmpeq_epi8(v, nu)));
     }
-    haystack = (const char *)p + __builtin_ctzl(m);
+    int offset = __builtin_ctzl(m);
+    progress += offset;
+    hay = (const char *)p + offset;
     for (i = 0;; ++i) {
+      if (--progress <= -512)
+        goto OfferPathologicalAssurances;
       if (!needle[i])
-        return (/*unconst*/ char *)haystack;
-      if (!haystack[i])
+        return (char *)hay;
+      if (!hay[i])
         break;
-      if (kToLower[needle[i] & 255] != kToLower[haystack[i] & 255])
+      if (kToLower[needle[i] & 255] != kToLower[hay[i] & 255])
         break;
     }
-    if (!*haystack++)
+    if (!*hay++)
       break;
   }
   return 0;
-#else
+#elif defined(__aarch64__) && defined(__ARM_NEON)
   size_t i;
-  if (haystack == needle || !*needle)
-    return (void *)haystack;
+  const char *hay = haystack;
+  uint8_t first_lower = kToLower[*needle & 255];
+  uint8_t first_upper = ToUpper(*needle);
+  uint8x16_t nl = vdupq_n_u8(first_lower);
+  uint8x16_t nu = vdupq_n_u8(first_upper);
+  uint8x16_t z = vdupq_n_u8(0);
+  long progress = 0;
   for (;;) {
+    int k = (uintptr_t)hay & 15;
+    hay = (const char *)((uintptr_t)hay & -16);
+    uint8x16_t v = vld1q_u8((const uint8_t *)hay);
+    uint8x16_t cmp_lower = vceqq_u8(v, nl);
+    uint8x16_t cmp_upper = vceqq_u8(v, nu);
+    uint8x16_t cmp_null = vceqq_u8(v, z);
+    uint8x16_t cmp = vorrq_u8(vorrq_u8(cmp_lower, cmp_upper), cmp_null);
+    uint8x8_t mask = vshrn_n_u16(vreinterpretq_u16_u8(cmp), 4);
+    uint64_t m;
+    vst1_u8((uint8_t *)&m, mask);
+    m >>= k * 4;
+    m <<= k * 4;
+    while (!m) {
+      hay += 16;
+      progress += 16;
+      v = vld1q_u8((const uint8_t *)hay);
+      cmp_lower = vceqq_u8(v, nl);
+      cmp_upper = vceqq_u8(v, nu);
+      cmp_null = vceqq_u8(v, z);
+      cmp = vorrq_u8(vorrq_u8(cmp_lower, cmp_upper), cmp_null);
+      mask = vshrn_n_u16(vreinterpretq_u16_u8(cmp), 4);
+      vst1_u8((uint8_t *)&m, mask);
+    }
+    int offset = __builtin_ctzll(m) >> 2;
+    progress += offset;
+    hay += offset;
     for (i = 0;; ++i) {
+      if (--progress <= -512)
+        goto OfferPathologicalAssurances;
       if (!needle[i])
-        return (/*unconst*/ char *)haystack;
-      if (!haystack[i])
+        return (char *)hay;
+      if (!hay[i])
         break;
-      if (kToLower[needle[i] & 255] != kToLower[haystack[i] & 255])
+      if (kToLower[needle[i] & 255] != kToLower[hay[i] & 255])
         break;
     }
-    if (!*haystack++)
+    if (!*hay++)
       break;
   }
   return 0;
 #endif
+OfferPathologicalAssurances:
+  return kmp(haystack, strlen(haystack), needle, strlen(needle));
 }
diff --git a/libc/str/strncasecmp.c b/libc/str/strncasecmp.c
index 419b7eec8..756732454 100644
--- a/libc/str/strncasecmp.c
+++ b/libc/str/strncasecmp.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * Compares NUL-terminated strings case-insensitively w/ limit.
diff --git a/libc/str/strncpy.c b/libc/str/strncpy.c
index 26ac33e02..052b00217 100644
--- a/libc/str/strncpy.c
+++ b/libc/str/strncpy.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 
 /**
diff --git a/libc/str/strnwidth.c b/libc/str/strnwidth.c
index 0e39fc70a..b67436e57 100644
--- a/libc/str/strnwidth.c
+++ b/libc/str/strnwidth.c
@@ -17,9 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bsf.h"
-#include "libc/intrin/pcmpgtb.h"
-#include "libc/intrin/pmovmskb.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/str/thompike.h"
 #include "libc/str/unicode.h"
diff --git a/libc/str/strnwidth16.c b/libc/str/strnwidth16.c
index c07f5144d..afc854bc9 100644
--- a/libc/str/strnwidth16.c
+++ b/libc/str/strnwidth16.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/str/str.h"
 #include "libc/str/unicode.h"
 #include "libc/str/utf16.h"
diff --git a/libc/str/strstr.c b/libc/str/strstr.c
index 6557ac91a..6b16e51d5 100644
--- a/libc/str/strstr.c
+++ b/libc/str/strstr.c
@@ -17,74 +17,113 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
-#include "libc/dce.h"
-
-typedef char xmm_t __attribute__((__vector_size__(16), __aligned__(16)));
+#include "libc/str/kmp.h"
+#include "third_party/aarch64/arm_neon.internal.h"
+#include "third_party/intel/immintrin.internal.h"
 
 /**
  * Searches for substring.
  *
+ * This function offers assurances against pathological cases, using KMP
+ * if no progress is being made on the O(nm) vectorized fast path. It is
+ * important to note that, if `needle` is untrusted, that it not be long
+ * enough to overflow the stack. That's because KMP needs to allocate an
+ * array of longs the same length as `needle` and it needs to do it with
+ * stack memory since POSIX requires this function to be safe to call in
+ * signal handlers.
+ *
  * @param haystack is the search area, as a NUL-terminated string
  * @param needle is the desired substring, also NUL-terminated
  * @return pointer to first substring within haystack, or NULL
- * @note this implementation goes fast in practice but isn't hardened
- *     against pathological cases, and therefore shouldn't be used on
- *     untrustworthy data
  * @asyncsignalsafe
  * @see strcasestr()
  * @see memmem()
  */
 __vex char *strstr(const char *haystack, const char *needle) {
+  if (haystack == needle || !*needle)
+    return (char *)haystack;
 #if defined(__x86_64__) && !defined(__chibicc__)
   size_t i;
   unsigned k, m;
-  const xmm_t *p;
-  xmm_t v, n, z = {0};
-  if (haystack == needle || !*needle)
-    return (char *)haystack;
-  n = (xmm_t){*needle, *needle, *needle, *needle, *needle, *needle,
-              *needle, *needle, *needle, *needle, *needle, *needle,
-              *needle, *needle, *needle, *needle};
+  const __m128i *p;
+  long progress = 0;
+  __m128i v, n, z = _mm_setzero_si128();
+  const char *hay = haystack;
+  n = _mm_set1_epi8(*needle);
   for (;;) {
-    k = (uintptr_t)haystack & 15;
-    p = (const xmm_t *)((uintptr_t)haystack & -16);
-    v = *p;
-    m = __builtin_ia32_pmovmskb128((v == z) | (v == n));
+    k = (uintptr_t)hay & 15;
+    p = (const __m128i *)((uintptr_t)hay & -16);
+    v = _mm_load_si128(p);
+    m = _mm_movemask_epi8(
+        _mm_or_si128(_mm_cmpeq_epi8(v, z), _mm_cmpeq_epi8(v, n)));
     m >>= k;
     m <<= k;
     while (!m) {
-      v = *++p;
-      m = __builtin_ia32_pmovmskb128((v == z) | (v == n));
+      progress += 16;
+      v = _mm_load_si128(++p);
+      m = _mm_movemask_epi8(
+          _mm_or_si128(_mm_cmpeq_epi8(v, z), _mm_cmpeq_epi8(v, n)));
     }
-    haystack = (const char *)p + __builtin_ctzl(m);
+    int offset = __builtin_ctzl(m);
+    progress += offset;
+    hay = (const char *)p + offset;
     for (i = 0;; ++i) {
+      if (--progress <= -512)
+        goto OfferPathologicalAssurances;
       if (!needle[i])
-        return (/*unconst*/ char *)haystack;
-      if (!haystack[i])
+        return (/*unconst*/ char *)hay;
+      if (!hay[i])
         break;
-      if (needle[i] != haystack[i])
+      if (needle[i] != hay[i])
         break;
     }
-    if (!*haystack++)
+    if (!*hay++)
       break;
   }
   return 0;
-#else
+OfferPathologicalAssurances:
+#elif defined(__aarch64__) && defined(__ARM_NEON)
   size_t i;
-  if (haystack == needle || !*needle)
-    return (void *)haystack;
+  const char *hay = haystack;
+  uint8x16_t n = vdupq_n_u8(*needle);
+  uint8x16_t z = vdupq_n_u8(0);
+  long progress = 0;
   for (;;) {
+    int k = (uintptr_t)hay & 15;
+    hay = (const char *)((uintptr_t)hay & -16);
+    uint8x16_t v = vld1q_u8((const uint8_t *)hay);
+    uint8x16_t cmp = vorrq_u8(vceqq_u8(v, z), vceqq_u8(v, n));
+    uint8x8_t mask = vshrn_n_u16(vreinterpretq_u16_u8(cmp), 4);
+    uint64_t m;
+    vst1_u8((uint8_t *)&m, mask);
+    m >>= k * 4;
+    m <<= k * 4;
+    while (!m) {
+      hay += 16;
+      progress += 16;
+      v = vld1q_u8((const uint8_t *)hay);
+      cmp = vorrq_u8(vceqq_u8(v, z), vceqq_u8(v, n));
+      mask = vshrn_n_u16(vreinterpretq_u16_u8(cmp), 4);
+      vst1_u8((uint8_t *)&m, mask);
+    }
+    int offset = __builtin_ctzll(m) >> 2;
+    progress += offset;
+    hay += offset;
     for (i = 0;; ++i) {
+      if (--progress <= -512)
+        goto OfferPathologicalAssurances;
       if (!needle[i])
-        return (/*unconst*/ char *)haystack;
-      if (!haystack[i])
+        return (/*unconst*/ char *)hay;
+      if (!hay[i])
         break;
-      if (needle[i] != haystack[i])
+      if (needle[i] != hay[i])
         break;
     }
-    if (!*haystack++)
+    if (!*hay++)
       break;
   }
   return 0;
+OfferPathologicalAssurances:
 #endif
+  return __memmem_kmp(haystack, strlen(haystack), needle, strlen(needle));
 }
diff --git a/libc/str/strstr16.c b/libc/str/strstr16.c
index aac0f8e3e..a139d0fd4 100644
--- a/libc/str/strstr16.c
+++ b/libc/str/strstr16.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/str/kmp.h"
 #include "libc/str/str.h"
 
 /**
@@ -28,19 +29,5 @@
  * @see memmem()
  */
 char16_t *strstr16(const char16_t *haystack, const char16_t *needle) {
-  size_t i;
-  for (;;) {
-    for (i = 0;;) {
-      if (!needle[i])
-        return (/*unconst*/ char16_t *)haystack;
-      if (!haystack[i])
-        break;
-      if (needle[i] != haystack[i])
-        break;
-      ++i;
-    }
-    if (!*haystack++)
-      break;
-  }
-  return NULL;
+  return __memmem_kmp16(haystack, strlen16(haystack), needle, strlen16(needle));
 }
diff --git a/libc/str/strtol.c b/libc/str/strtol.c
index 0548bb265..aa7bdd3b2 100644
--- a/libc/str/strtol.c
+++ b/libc/str/strtol.c
@@ -22,7 +22,7 @@
 #include "libc/limits.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * Decodes signed integer from ASCII string.
diff --git a/libc/str/strtoul.c b/libc/str/strtoul.c
index ee8f01fbd..37f28fe1e 100644
--- a/libc/str/strtoul.c
+++ b/libc/str/strtoul.c
@@ -22,7 +22,7 @@
 #include "libc/limits.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * Decodes unsigned integer from ASCII string.
diff --git a/libc/str/strverscmp.c b/libc/str/strverscmp.c
index 3cc3740ef..22596fc49 100644
--- a/libc/str/strverscmp.c
+++ b/libc/str/strverscmp.c
@@ -25,6 +25,7 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/str/str.h"
 __static_yoink("musl_libc_notice");
 
diff --git a/libc/str/strwidth16.c b/libc/str/strwidth16.c
index ddcab3bad..b2a2355d1 100644
--- a/libc/str/strwidth16.c
+++ b/libc/str/strwidth16.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/str/strwidth.h"
 
diff --git a/libc/str/tab.h b/libc/str/tab.h
new file mode 100644
index 000000000..ea1310bbc
--- /dev/null
+++ b/libc/str/tab.h
@@ -0,0 +1,23 @@
+#ifndef COSMOPOLITAN_LIBC_STR_TAB_H_
+#define COSMOPOLITAN_LIBC_STR_TAB_H_
+
+#define kHexToInt __kHexToInt
+#define kToLower  __kToLower
+#define kToUpper  __kToUpper
+#define kBase36   __kBase36
+#define kCp437    __kCp437
+
+#if !(__ASSEMBLER__ + __LINKER__ + 0)
+COSMOPOLITAN_C_START_
+
+#define gperf_downcase kToLower
+
+extern const int8_t kHexToInt[256];
+extern const uint8_t kToLower[256];
+extern const uint8_t kToUpper[256];
+extern const uint8_t kBase36[256];
+extern const char16_t kCp437[256];
+
+COSMOPOLITAN_C_END_
+#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
+#endif /* COSMOPOLITAN_LIBC_STR_TAB_H_ */
diff --git a/libc/str/tab.internal.h b/libc/str/tab.internal.h
deleted file mode 100644
index c40d9f663..000000000
--- a/libc/str/tab.internal.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_STR_TAB_INTERNAL_H_
-#define COSMOPOLITAN_LIBC_STR_TAB_INTERNAL_H_
-
-#define kHexToInt __kHexToInt
-#define kToLower  __kToLower
-#define kToUpper  __kToUpper
-#define kBase36   __kBase36
-#define kCp437    __kCp437
-
-#if !(__ASSEMBLER__ + __LINKER__ + 0)
-COSMOPOLITAN_C_START_
-
-#define gperf_downcase kToLower
-
-extern const int8_t kHexToInt[256];
-extern const uint8_t kToLower[256];
-extern const uint8_t kToUpper[256];
-extern const uint8_t kBase36[256];
-extern const char16_t kCp437[256];
-
-COSMOPOLITAN_C_END_
-#endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
-#endif /* COSMOPOLITAN_LIBC_STR_TAB_INTERNAL_H_ */
diff --git a/libc/str/towctrans.c b/libc/str/towctrans.c
deleted file mode 100644
index 87f1a87bc..000000000
--- a/libc/str/towctrans.c
+++ /dev/null
@@ -1,27 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-wint_t towctrans(wint_t c, wctrans_t t) {
-  if (t == (wctrans_t)1)
-    return towupper(c);
-  if (t == (wctrans_t)2)
-    return towlower(c);
-  return c;
-}
diff --git a/libc/str/towlower.c b/libc/str/towlower.c
deleted file mode 100644
index 313a53079..000000000
--- a/libc/str/towlower.c
+++ /dev/null
@@ -1,236 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/dce.h"
-#include "libc/macros.internal.h"
-#include "libc/str/str.h"
-/* clang-format off */
-
-static const struct {
-  unsigned short x;
-  unsigned short y;
-  short d;
-} kLower[] = {
-    {0x00c0, 0x00d6, +32},    /* 23x À ..Ö  → à ..ö  Watin */
-    {0x00d8, 0x00de, +32},    /*  7x Ø ..Þ  → ø ..þ  Watin */
-    {0x0178, 0x0178, -121},   /*  1x Ÿ ..Ÿ  → ÿ ..ÿ  Watin-A */
-    {0x0179, 0x0179, +1},     /*  1x Ź ..Ź  → ź ..ź  Watin-A */
-    {0x017b, 0x017b, +1},     /*  1x Ż ..Ż  → ż ..ż  Watin-A */
-    {0x017d, 0x017d, +1},     /*  1x Ž ..Ž  → ž ..ž  Watin-A */
-    {0x0181, 0x0181, +210},   /*  1x Ɓ ..Ɓ  → ɓ ..ɓ  Watin-B */
-    {0x0182, 0x0182, +1},     /*  1x Ƃ ..Ƃ  → ƃ ..ƃ  Watin-B */
-    {0x0184, 0x0184, +1},     /*  1x Ƅ ..Ƅ  → ƅ ..ƅ  Watin-B */
-    {0x0186, 0x0186, +206},   /*  1x Ɔ ..Ɔ  → ɔ ..ɔ  Watin-B */
-    {0x0187, 0x0187, +1},     /*  1x Ƈ ..Ƈ  → ƈ ..ƈ  Watin-B */
-    {0x0189, 0x018a, +205},   /*  2x Ɖ ..Ɗ  → ɖ ..ɗ  Watin-B */
-    {0x018b, 0x018b, +1},     /*  1x Ƌ ..Ƌ  → ƌ ..ƌ  Watin-B */
-    {0x018e, 0x018e, +79},    /*  1x Ǝ ..Ǝ  → ǝ ..ǝ  Watin-B */
-    {0x018f, 0x018f, +202},   /*  1x Ə ..Ə  → ə ..ə  Watin-B */
-    {0x0190, 0x0190, +203},   /*  1x Ɛ ..Ɛ  → ɛ ..ɛ  Watin-B */
-    {0x0191, 0x0191, +1},     /*  1x Ƒ ..Ƒ  → ƒ ..ƒ  Watin-B */
-    {0x0193, 0x0193, +205},   /*  1x Ɠ ..Ɠ  → ɠ ..ɠ  Watin-B */
-    {0x0194, 0x0194, +207},   /*  1x Ɣ ..Ɣ  → ɣ ..ɣ  Watin-B */
-    {0x0196, 0x0196, +211},   /*  1x Ɩ ..Ɩ  → ɩ ..ɩ  Watin-B */
-    {0x0197, 0x0197, +209},   /*  1x Ɨ ..Ɨ  → ɨ ..ɨ  Watin-B */
-    {0x0198, 0x0198, +1},     /*  1x Ƙ ..Ƙ  → ƙ ..ƙ  Watin-B */
-    {0x019c, 0x019c, +211},   /*  1x Ɯ ..Ɯ  → ɯ ..ɯ  Watin-B */
-    {0x019d, 0x019d, +213},   /*  1x Ɲ ..Ɲ  → ɲ ..ɲ  Watin-B */
-    {0x019f, 0x019f, +214},   /*  1x Ɵ ..Ɵ  → ɵ ..ɵ  Watin-B */
-    {0x01a0, 0x01a0, +1},     /*  1x Ơ ..Ơ  → ơ ..ơ  Watin-B */
-    {0x01a2, 0x01a2, +1},     /*  1x Ƣ ..Ƣ  → ƣ ..ƣ  Watin-B */
-    {0x01a4, 0x01a4, +1},     /*  1x Ƥ ..Ƥ  → ƥ ..ƥ  Watin-B */
-    {0x01a6, 0x01a6, +218},   /*  1x Ʀ ..Ʀ  → ʀ ..ʀ  Watin-B */
-    {0x01a7, 0x01a7, +1},     /*  1x Ƨ ..Ƨ  → ƨ ..ƨ  Watin-B */
-    {0x01a9, 0x01a9, +218},   /*  1x Ʃ ..Ʃ  → ʃ ..ʃ  Watin-B */
-    {0x01ac, 0x01ac, +1},     /*  1x Ƭ ..Ƭ  → ƭ ..ƭ  Watin-B */
-    {0x01ae, 0x01ae, +218},   /*  1x Ʈ ..Ʈ  → ʈ ..ʈ  Watin-B */
-    {0x01af, 0x01af, +1},     /*  1x Ư ..Ư  → ư ..ư  Watin-B */
-    {0x01b1, 0x01b2, +217},   /*  2x Ʊ ..Ʋ  → ʊ ..ʋ  Watin-B */
-    {0x01b3, 0x01b3, +1},     /*  1x Ƴ ..Ƴ  → ƴ ..ƴ  Watin-B */
-    {0x01b5, 0x01b5, +1},     /*  1x Ƶ ..Ƶ  → ƶ ..ƶ  Watin-B */
-    {0x01b7, 0x01b7, +219},   /*  1x Ʒ ..Ʒ  → ʒ ..ʒ  Watin-B */
-    {0x01b8, 0x01b8, +1},     /*  1x Ƹ ..Ƹ  → ƹ ..ƹ  Watin-B */
-    {0x01bc, 0x01bc, +1},     /*  1x Ƽ ..Ƽ  → ƽ ..ƽ  Watin-B */
-    {0x01c4, 0x01c4, +2},     /*  1x DŽ ..DŽ  → dž ..dž  Watin-B */
-    {0x01c5, 0x01c5, +1},     /*  1x Dž ..Dž  → dž ..dž  Watin-B */
-    {0x01c7, 0x01c7, +2},     /*  1x LJ ..LJ  → lj ..lj  Watin-B */
-    {0x01c8, 0x01c8, +1},     /*  1x Lj ..Lj  → lj ..lj  Watin-B */
-    {0x01ca, 0x01ca, +2},     /*  1x NJ ..NJ  → nj ..nj  Watin-B */
-    {0x01cb, 0x01cb, +1},     /*  1x Nj ..Nj  → nj ..nj  Watin-B */
-    {0x01cd, 0x01cd, +1},     /*  1x Ǎ ..Ǎ  → ǎ ..ǎ  Watin-B */
-    {0x01f1, 0x01f1, +2},     /*  1x DZ ..DZ  → dz ..dz  Watin-B */
-    {0x01f2, 0x01f2, +1},     /*  1x Dz ..Dz  → dz ..dz  Watin-B */
-    {0x01f4, 0x01f4, +1},     /*  1x Ǵ ..Ǵ  → ǵ ..ǵ  Watin-B */
-    {0x01f6, 0x01f6, -97},    /*  1x Ƕ ..Ƕ  → ƕ ..ƕ  Watin-B */
-    {0x01f7, 0x01f7, -56},    /*  1x Ƿ ..Ƿ  → ƿ ..ƿ  Watin-B */
-    {0x0220, 0x0220, -130},   /*  1x Ƞ ..Ƞ  → ƞ ..ƞ  Watin-B */
-    {0x023b, 0x023b, +1},     /*  1x Ȼ ..Ȼ  → ȼ ..ȼ  Watin-B */
-    {0x023d, 0x023d, -163},   /*  1x Ƚ ..Ƚ  → ƚ ..ƚ  Watin-B */
-    {0x0241, 0x0241, +1},     /*  1x Ɂ ..Ɂ  → ɂ ..ɂ  Watin-B */
-    {0x0243, 0x0243, -195},   /*  1x Ƀ ..Ƀ  → ƀ ..ƀ  Watin-B */
-    {0x0244, 0x0244, +69},    /*  1x Ʉ ..Ʉ  → ʉ ..ʉ  Watin-B */
-    {0x0245, 0x0245, +71},    /*  1x Ʌ ..Ʌ  → ʌ ..ʌ  Watin-B */
-    {0x0246, 0x0246, +1},     /*  1x Ɇ ..Ɇ  → ɇ ..ɇ  Watin-B */
-    {0x0248, 0x0248, +1},     /*  1x Ɉ ..Ɉ  → ɉ ..ɉ  Watin-B */
-    {0x024a, 0x024a, +1},     /*  1x Ɋ ..Ɋ  → ɋ ..ɋ  Watin-B */
-    {0x024c, 0x024c, +1},     /*  1x Ɍ ..Ɍ  → ɍ ..ɍ  Watin-B */
-    {0x024e, 0x024e, +1},     /*  1x Ɏ ..Ɏ  → ɏ ..ɏ  Watin-B */
-    {0x0386, 0x0386, +38},    /*  1x Ά ..Ά  → ά ..ά  Greek */
-    {0x0388, 0x038a, +37},    /*  3x Έ ..Ί  → έ ..ί  Greek */
-    {0x038c, 0x038c, +64},    /*  1x Ό ..Ό  → ό ..ό  Greek */
-    {0x038e, 0x038f, +63},    /*  2x Ύ ..Ώ  → ύ ..ώ  Greek */
-    {0x0391, 0x03a1, +32},    /* 17x Α ..Ρ  → α ..ρ  Greek */
-    {0x03a3, 0x03ab, +32},    /*  9x Σ ..Ϋ  → σ ..ϋ  Greek */
-    {0x03dc, 0x03dc, +1},     /*  1x Ϝ ..Ϝ  → ϝ ..ϝ  Greek */
-    {0x03f4, 0x03f4, -60},    /*  1x ϴ ..ϴ  → θ ..θ  Greek */
-    {0x0400, 0x040f, +80},    /* 16x Ѐ ..Џ  → ѐ ..џ  Cyrillic */
-    {0x0410, 0x042f, +32},    /* 32x А ..Я  → а ..я  Cyrillic */
-    {0x0460, 0x0460, +1},     /*  1x Ѡ ..Ѡ  → ѡ ..ѡ  Cyrillic */
-    {0x0462, 0x0462, +1},     /*  1x Ѣ ..Ѣ  → ѣ ..ѣ  Cyrillic */
-    {0x0464, 0x0464, +1},     /*  1x Ѥ ..Ѥ  → ѥ ..ѥ  Cyrillic */
-    {0x0472, 0x0472, +1},     /*  1x Ѳ ..Ѳ  → ѳ ..ѳ  Cyrillic */
-    {0x0490, 0x0490, +1},     /*  1x Ґ ..Ґ  → ґ ..ґ  Cyrillic */
-    {0x0498, 0x0498, +1},     /*  1x Ҙ ..Ҙ  → ҙ ..ҙ  Cyrillic */
-    {0x049a, 0x049a, +1},     /*  1x Қ ..Қ  → қ ..қ  Cyrillic */
-    {0x0531, 0x0556, +48},    /* 38x Ա ..Ֆ  → ա ..ֆ  Armenian */
-    {0x10a0, 0x10c5, +7264},  /* 38x Ⴀ ..Ⴥ  → ⴀ ..ⴥ  Georgian */
-    {0x10c7, 0x10c7, +7264},  /*  1x Ⴧ ..Ⴧ  → ⴧ ..ⴧ  Georgian */
-    {0x10cd, 0x10cd, +7264},  /*  1x Ⴭ ..Ⴭ  → ⴭ ..ⴭ  Georgian */
-    {0x13f0, 0x13f5, +8},     /*  6x Ᏸ ..Ᏽ  → ᏸ ..ᏽ  Cherokee */
-    {0x1c90, 0x1cba, -3008}, /* 43x Ა ..Ჺ  → ა ..ჺ  Georgian2 */
-    {0x1cbd, 0x1cbf, -3008}, /*  3x Ჽ ..Ჿ  → ჽ ..ჿ  Georgian2 */
-    {0x1f08, 0x1f0f, -8},    /*  8x Ἀ ..Ἇ  → ἀ ..ἇ  Greek2 */
-    {0x1f18, 0x1f1d, -8},    /*  6x Ἐ ..Ἕ  → ἐ ..ἕ  Greek2 */
-    {0x1f28, 0x1f2f, -8},    /*  8x Ἠ ..Ἧ  → ἠ ..ἧ  Greek2 */
-    {0x1f38, 0x1f3f, -8},    /*  8x Ἰ ..Ἷ  → ἰ ..ἷ  Greek2 */
-    {0x1f48, 0x1f4d, -8},    /*  6x Ὀ ..Ὅ  → ὀ ..ὅ  Greek2 */
-    {0x1f59, 0x1f59, -8},    /*  1x Ὑ ..Ὑ  → ὑ ..ὑ  Greek2 */
-    {0x1f5b, 0x1f5b, -8},    /*  1x Ὓ ..Ὓ  → ὓ ..ὓ  Greek2 */
-    {0x1f5d, 0x1f5d, -8},    /*  1x Ὕ ..Ὕ  → ὕ ..ὕ  Greek2 */
-    {0x1f5f, 0x1f5f, -8},    /*  1x Ὗ ..Ὗ  → ὗ ..ὗ  Greek2 */
-    {0x1f68, 0x1f6f, -8},    /*  8x Ὠ ..Ὧ  → ὠ ..ὧ  Greek2 */
-    {0x1f88, 0x1f8f, -8},    /*  8x ᾈ ..ᾏ  → ᾀ ..ᾇ  Greek2 */
-    {0x1f98, 0x1f9f, -8},    /*  8x ᾘ ..ᾟ  → ᾐ ..ᾗ  Greek2 */
-    {0x1fa8, 0x1faf, -8},    /*  8x ᾨ ..ᾯ  → ᾠ ..ᾧ  Greek2 */
-    {0x1fb8, 0x1fb9, -8},    /*  2x Ᾰ ..Ᾱ  → ᾰ ..ᾱ  Greek2 */
-    {0x1fba, 0x1fbb, -74},   /*  2x Ὰ ..Ά  → ὰ ..ά  Greek2 */
-    {0x1fbc, 0x1fbc, -9},    /*  1x ᾼ ..ᾼ  → ᾳ ..ᾳ  Greek2 */
-    {0x1fc8, 0x1fcb, -86},   /*  4x Ὲ ..Ή  → ὲ ..ή  Greek2 */
-    {0x1fcc, 0x1fcc, -9},    /*  1x ῌ ..ῌ  → ῃ ..ῃ  Greek2 */
-    {0x1fd8, 0x1fd9, -8},    /*  2x Ῐ ..Ῑ  → ῐ ..ῑ  Greek2 */
-    {0x1fda, 0x1fdb, -100},  /*  2x Ὶ ..Ί  → ὶ ..ί  Greek2 */
-    {0x1fe8, 0x1fe9, -8},    /*  2x Ῠ ..Ῡ  → ῠ ..ῡ  Greek2 */
-    {0x1fea, 0x1feb, -112},  /*  2x Ὺ ..Ύ  → ὺ ..ύ  Greek2 */
-    {0x1fec, 0x1fec, -7},    /*  1x Ῥ ..Ῥ  → ῥ ..ῥ  Greek2 */
-    {0x1ff8, 0x1ff9, -128},  /*  2x Ὸ ..Ό  → ὸ ..ό  Greek2 */
-    {0x1ffa, 0x1ffb, -126},  /*  2x Ὼ ..Ώ  → ὼ ..ώ  Greek2 */
-    {0x1ffc, 0x1ffc, -9},    /*  1x ῼ ..ῼ  → ῳ ..ῳ  Greek2 */
-    {0x2126, 0x2126, -7517}, /*  1x Ω ..Ω  → ω ..ω  Letterlike */
-    {0x212a, 0x212a, -8383}, /*  1x K ..K  → k ..k  Letterlike */
-    {0x212b, 0x212b, -8262}, /*  1x Å ..Å  → å ..å  Letterlike */
-    {0x2132, 0x2132, +28}, /*  1x Ⅎ ..Ⅎ  → ⅎ ..ⅎ  Letterlike */
-    {0x2160, 0x216f, +16}, /* 16x Ⅰ ..Ⅿ  → ⅰ ..ⅿ  Numbery */
-    {0x2183, 0x2183, +1},  /*  1x Ↄ ..Ↄ  → ↄ ..ↄ  Numbery */
-    {0x24b6, 0x24cf, +26}, /* 26x Ⓐ ..Ⓩ  → ⓐ ..ⓩ  Enclosed */
-    {0x2c00, 0x2c2e, +48}, /* 47x Ⰰ ..Ⱞ  → ⰰ ..ⱞ  Glagolitic */
-    {0xff21, 0xff3a, +32}, /* 26x Ａ..Ｚ → ａ..ｚ Dubs */
-};
-
-static const int kAstralLower[][3] = {
-    {0x10400, 0x10427, +40}, /* 40x 𐐀 ..𐐧  → 𐐨 ..𐑏  Deseret */
-    {0x104b0, 0x104d3, +40}, /* 36x 𐒰 ..𐓓  → 𐓘 ..𐓻  Osage */
-    {0x1d400, 0x1d419, +26}, /* 26x 𝐀 ..𝐙  → 𝐚 ..𝐳  Math */
-    {0x1d43c, 0x1d44d, +26}, /* 18x 𝐼 ..𝑍  → 𝑖 ..𝑧  Math */
-    {0x1d468, 0x1d481, +26}, /* 26x 𝑨 ..𝒁  → 𝒂 ..𝒛  Math */
-    {0x1d4ae, 0x1d4b5, +26}, /*  8x 𝒮 ..𝒵  → 𝓈 ..𝓏  Math */
-    {0x1d4d0, 0x1d4e9, +26}, /* 26x 𝓐 ..𝓩  → 𝓪 ..𝔃  Math */
-    {0x1d50d, 0x1d514, +26}, /*  8x 𝔍 ..𝔔  → 𝔧 ..𝔮  Math */
-    {0x1d56c, 0x1d585, +26}, /* 26x 𝕬 ..𝖅  → 𝖆 ..𝖟  Math */
-    {0x1d5a0, 0x1d5b9, +26}, /* 26x 𝖠 ..𝖹  → 𝖺 ..𝗓  Math */
-    {0x1d5d4, 0x1d5ed, +26}, /* 26x 𝗔 ..𝗭  → 𝗮 ..𝘇  Math */
-    {0x1d608, 0x1d621, +26}, /* 26x 𝘈 ..𝘡  → 𝘢 ..𝘻  Math */
-    {0x1d63c, 0x1d655, -442}, /* 26x 𝘼 ..𝙕  → 𝒂 ..𝒛  Math */
-    {0x1d670, 0x1d689, +26},  /* 26x 𝙰 ..𝚉  → 𝚊 ..𝚣  Math */
-    {0x1d6a8, 0x1d6b8, +26},  /* 17x 𝚨 ..𝚸  → 𝛂 ..𝛒  Math */
-    {0x1d6e2, 0x1d6f2, +26},  /* 17x 𝛢 ..𝛲  → 𝛼 ..𝜌  Math */
-    {0x1d71c, 0x1d72c, +26},  /* 17x 𝜜 ..𝜬  → 𝜶 ..𝝆  Math */
-    {0x1d756, 0x1d766, +26},  /* 17x 𝝖 ..𝝦  → 𝝰 ..𝞀  Math */
-    {0x1d790, 0x1d7a0, -90},  /* 17x 𝞐 ..𝞠  → 𝜶 ..𝝆  Math */
-};
-
-/**
- * Converts wide character to lower case.
- */
-wint_t towlower(wint_t c) {
-  int m, l, r, n;
-  if (c < 0200) {
-    if ('A' <= c && c <= 'Z') {
-      return c + 32;
-    } else {
-      return c;
-    }
-  } else if (c <= 0xffff) {
-    if ((0x0100 <= c && c <= 0x0176) || /* 60x Ā..ā → ā..ŵ Watin-A */
-        (0x01de <= c && c <= 0x01ee) || /*  9x Ǟ..Ǯ → ǟ..ǯ Watin-B */
-        (0x01f8 <= c && c <= 0x021e) || /* 20x Ǹ..Ȟ → ǹ..ȟ Watin-B */
-        (0x0222 <= c && c <= 0x0232) || /*  9x Ȣ..Ȳ → ȣ..ȳ Watin-B */
-        (0x1e00 <= c && c <= 0x1eff)) { /*256x Ḁ..Ỿ → ḁ..ỿ Watin-C */
-      if (c == 0x0130) return c - 199;
-      if (c == 0x1e9e) return c;
-      return c + (~c & 1);
-    } else if (0x01cf <= c && c <= 0x01db) {
-      return c + (c & 1); /* 7x Ǐ..Ǜ → ǐ..ǜ Watin-B */
-    } else if (0x13a0 <= c && c <= 0x13ef) {
-      return c + 38864; /* 80x Ꭰ ..Ꮿ  → ꭰ ..ꮿ  Cherokee */
-    } else {
-      l = 0;
-      r = n = sizeof(kLower) / sizeof(kLower[0]);
-      while (l < r) {
-        m = (l & r) + ((l ^ r) >> 1);  // floor((a+b)/2)
-        if (kLower[m].y < c) {
-          l = m + 1;
-        } else {
-          r = m;
-        }
-      }
-      if (l < n && kLower[l].x <= c && c <= kLower[l].y) {
-        return c + kLower[l].d;
-      } else {
-        return c;
-      }
-    }
-  } else {
-    l = 0;
-    r = n = sizeof(kAstralLower) / sizeof(kAstralLower[0]);
-    while (l < r) {
-      m = (l & r) + ((l ^ r) >> 1);  // floor((a+b)/2)
-      if (kAstralLower[m][1] < c) {
-        l = m + 1;
-      } else {
-        r = m;
-      }
-    }
-    if (l < n && kAstralLower[l][0] <= c && c <= kAstralLower[l][1]) {
-      return c + kAstralLower[l][2];
-    } else {
-      return c;
-    }
-  }
-}
-
-__weak_reference(towlower, towlower_l);
diff --git a/libc/str/towupper.c b/libc/str/towupper.c
deleted file mode 100644
index e946cd142..000000000
--- a/libc/str/towupper.c
+++ /dev/null
@@ -1,199 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/dce.h"
-#include "libc/macros.internal.h"
-#include "libc/str/str.h"
-// clang-format off
-
-static const struct {
-  unsigned short x;
-  unsigned short y;
-  short d;
-} kUpper[] = {
-    {0x00b5, 0x00b5, +743},   /*  1x µ ..µ  → Μ ..Μ  Watin */
-    {0x00e0, 0x00f6, -32},    /* 23x à ..ö  → À ..Ö  Watin */
-    {0x00f8, 0x00fe, -32},    /*  7x ø ..þ  → Ø ..Þ  Watin */
-    {0x00ff, 0x00ff, +121},   /*  1x ÿ ..ÿ  → Ÿ ..Ÿ  Watin */
-    {0x017a, 0x017a, -1},     /*  1x ź ..ź  → Ź ..Ź  Watin-A */
-    {0x017c, 0x017c, -1},     /*  1x ż ..ż  → Ż ..Ż  Watin-A */
-    {0x017e, 0x017e, -1},     /*  1x ž ..ž  → Ž ..Ž  Watin-A */
-    {0x017f, 0x017f, -300},   /*  1x ſ ..ſ  → S ..S  Watin-A */
-    {0x0180, 0x0180, +195},   /*  1x ƀ ..ƀ  → Ƀ ..Ƀ  Watin-B */
-    {0x0183, 0x0183, -1},     /*  1x ƃ ..ƃ  → Ƃ ..Ƃ  Watin-B */
-    {0x0185, 0x0185, -1},     /*  1x ƅ ..ƅ  → Ƅ ..Ƅ  Watin-B */
-    {0x0188, 0x0188, -1},     /*  1x ƈ ..ƈ  → Ƈ ..Ƈ  Watin-B */
-    {0x018c, 0x018c, -1},     /*  1x ƌ ..ƌ  → Ƌ ..Ƌ  Watin-B */
-    {0x0192, 0x0192, -1},     /*  1x ƒ ..ƒ  → Ƒ ..Ƒ  Watin-B */
-    {0x0195, 0x0195, +97},    /*  1x ƕ ..ƕ  → Ƕ ..Ƕ  Watin-B */
-    {0x0199, 0x0199, -1},     /*  1x ƙ ..ƙ  → Ƙ ..Ƙ  Watin-B */
-    {0x019a, 0x019a, +163},   /*  1x ƚ ..ƚ  → Ƚ ..Ƚ  Watin-B */
-    {0x019e, 0x019e, +130},   /*  1x ƞ ..ƞ  → Ƞ ..Ƞ  Watin-B */
-    {0x01a1, 0x01a1, -1},     /*  1x ơ ..ơ  → Ơ ..Ơ  Watin-B */
-    {0x01a3, 0x01a3, -1},     /*  1x ƣ ..ƣ  → Ƣ ..Ƣ  Watin-B */
-    {0x01a5, 0x01a5, -1},     /*  1x ƥ ..ƥ  → Ƥ ..Ƥ  Watin-B */
-    {0x01a8, 0x01a8, -1},     /*  1x ƨ ..ƨ  → Ƨ ..Ƨ  Watin-B */
-    {0x01ad, 0x01ad, -1},     /*  1x ƭ ..ƭ  → Ƭ ..Ƭ  Watin-B */
-    {0x01b0, 0x01b0, -1},     /*  1x ư ..ư  → Ư ..Ư  Watin-B */
-    {0x01b4, 0x01b4, -1},     /*  1x ƴ ..ƴ  → Ƴ ..Ƴ  Watin-B */
-    {0x01b6, 0x01b6, -1},     /*  1x ƶ ..ƶ  → Ƶ ..Ƶ  Watin-B */
-    {0x01b9, 0x01b9, -1},     /*  1x ƹ ..ƹ  → Ƹ ..Ƹ  Watin-B */
-    {0x01bd, 0x01bd, -1},     /*  1x ƽ ..ƽ  → Ƽ ..Ƽ  Watin-B */
-    {0x01bf, 0x01bf, +56},    /*  1x ƿ ..ƿ  → Ƿ ..Ƿ  Watin-B */
-    {0x01c5, 0x01c5, -1},     /*  1x Dž ..Dž  → DŽ ..DŽ  Watin-B */
-    {0x01c6, 0x01c6, -2},     /*  1x dž ..dž  → DŽ ..DŽ  Watin-B */
-    {0x01c8, 0x01c8, -1},     /*  1x Lj ..Lj  → LJ ..LJ  Watin-B */
-    {0x01c9, 0x01c9, -2},     /*  1x lj ..lj  → LJ ..LJ  Watin-B */
-    {0x01cb, 0x01cb, -1},     /*  1x Nj ..Nj  → NJ ..NJ  Watin-B */
-    {0x01cc, 0x01cc, -2},     /*  1x nj ..nj  → NJ ..NJ  Watin-B */
-    {0x01ce, 0x01ce, -1},     /*  1x ǎ ..ǎ  → Ǎ ..Ǎ  Watin-B */
-    {0x01dd, 0x01dd, -79},    /*  1x ǝ ..ǝ  → Ǝ ..Ǝ  Watin-B */
-    {0x01f2, 0x01f2, -1},     /*  1x Dz ..Dz  → DZ ..DZ  Watin-B */
-    {0x01f3, 0x01f3, -2},     /*  1x dz ..dz  → DZ ..DZ  Watin-B */
-    {0x01f5, 0x01f5, -1},     /*  1x ǵ ..ǵ  → Ǵ ..Ǵ  Watin-B */
-    {0x023c, 0x023c, -1},     /*  1x ȼ ..ȼ  → Ȼ ..Ȼ  Watin-B */
-    {0x023f, 0x0240, +10815}, /*  2x ȿ ..ɀ  → Ȿ ..Ɀ  Watin-B */
-    {0x0242, 0x0242, -1},     /*  1x ɂ ..ɂ  → Ɂ ..Ɂ  Watin-B */
-    {0x0247, 0x0247, -1},     /*  1x ɇ ..ɇ  → Ɇ ..Ɇ  Watin-B */
-    {0x0249, 0x0249, -1},     /*  1x ɉ ..ɉ  → Ɉ ..Ɉ  Watin-B */
-    {0x024b, 0x024b, -1},     /*  1x ɋ ..ɋ  → Ɋ ..Ɋ  Watin-B */
-    {0x024d, 0x024d, -1},     /*  1x ɍ ..ɍ  → Ɍ ..Ɍ  Watin-B */
-    {0x024f, 0x024f, -1},     /*  1x ɏ ..ɏ  → Ɏ ..Ɏ  Watin-B */
-    {0x037b, 0x037d, +130},   /*  3x ͻ ..ͽ  → Ͻ ..Ͽ  Greek */
-    {0x03ac, 0x03ac, -38},    /*  1x ά ..ά  → Ά ..Ά  Greek */
-    {0x03ad, 0x03af, -37},    /*  3x έ ..ί  → Έ ..Ί  Greek */
-    {0x03b1, 0x03c1, -32},    /* 17x α ..ρ  → Α ..Ρ  Greek */
-    {0x03c2, 0x03c2, -31},    /*  1x ς ..ς  → Σ ..Σ  Greek */
-    {0x03c3, 0x03cb, -32},    /*  9x σ ..ϋ  → Σ ..Ϋ  Greek */
-    {0x03cc, 0x03cc, -64},    /*  1x ό ..ό  → Ό ..Ό  Greek */
-    {0x03cd, 0x03ce, -63},    /*  2x ύ ..ώ  → Ύ ..Ώ  Greek */
-    {0x03d0, 0x03d0, -62},    /*  1x ϐ ..ϐ  → Β ..Β  Greek */
-    {0x03d1, 0x03d1, -57},    /*  1x ϑ ..ϑ  → Θ ..Θ  Greek */
-    {0x03d5, 0x03d5, -47},    /*  1x ϕ ..ϕ  → Φ ..Φ  Greek */
-    {0x03d6, 0x03d6, -54},    /*  1x ϖ ..ϖ  → Π ..Π  Greek */
-    {0x03dd, 0x03dd, -1},     /*  1x ϝ ..ϝ  → Ϝ ..Ϝ  Greek */
-    {0x03f0, 0x03f0, -86},    /*  1x ϰ ..ϰ  → Κ ..Κ  Greek */
-    {0x03f1, 0x03f1, -80},    /*  1x ϱ ..ϱ  → Ρ ..Ρ  Greek */
-    {0x03f5, 0x03f5, -96},    /*  1x ϵ ..ϵ  → Ε ..Ε  Greek */
-    {0x0430, 0x044f, -32},    /* 32x а ..я  → А ..Я  Cyrillic */
-    {0x0450, 0x045f, -80},    /* 16x ѐ ..џ  → Ѐ ..Џ  Cyrillic */
-    {0x0461, 0x0461, -1},     /*  1x ѡ ..ѡ  → Ѡ ..Ѡ  Cyrillic */
-    {0x0463, 0x0463, -1},     /*  1x ѣ ..ѣ  → Ѣ ..Ѣ  Cyrillic */
-    {0x0465, 0x0465, -1},     /*  1x ѥ ..ѥ  → Ѥ ..Ѥ  Cyrillic */
-    {0x0473, 0x0473, -1},     /*  1x ѳ ..ѳ  → Ѳ ..Ѳ  Cyrillic */
-    {0x0491, 0x0491, -1},     /*  1x ґ ..ґ  → Ґ ..Ґ  Cyrillic */
-    {0x0499, 0x0499, -1},     /*  1x ҙ ..ҙ  → Ҙ ..Ҙ  Cyrillic */
-    {0x049b, 0x049b, -1},     /*  1x қ ..қ  → Қ ..Қ  Cyrillic */
-    {0x0561, 0x0586, -48},    /* 38x ա ..ֆ  → Ա ..Ֆ  Armenian */
-    {0x10d0, 0x10fa, +3008},  /* 43x ა ..ჺ  → Ა ..Ჺ  Georgian */
-    {0x10fd, 0x10ff, +3008},  /*  3x ჽ ..ჿ  → Ჽ ..Ჿ  Georgian */
-    {0x13f8, 0x13fd, -8},     /*  6x ᏸ ..ᏽ  → Ᏸ ..Ᏽ  Cherokee */
-    {0x214e, 0x214e, -28},    /*  1x ⅎ ..ⅎ  → Ⅎ ..Ⅎ  Letterlike */
-    {0x2170, 0x217f, -16},    /* 16x ⅰ ..ⅿ  → Ⅰ ..Ⅿ  Numbery */
-    {0x2184, 0x2184, -1},     /*  1x ↄ ..ↄ  → Ↄ ..Ↄ  Numbery */
-    {0x24d0, 0x24e9, -26},    /* 26x ⓐ ..ⓩ  → Ⓐ ..Ⓩ  Enclosed */
-    {0x2c30, 0x2c5e, -48},    /* 47x ⰰ ..ⱞ  → Ⰰ ..Ⱞ  Glagolitic */
-    {0x2d00, 0x2d25, -7264},  /* 38x ⴀ ..ⴥ  → Ⴀ ..Ⴥ  Georgian2 */
-    {0x2d27, 0x2d27, -7264},  /*  1x ⴧ ..ⴧ  → Ⴧ ..Ⴧ  Georgian2 */
-    {0x2d2d, 0x2d2d, -7264},  /*  1x ⴭ ..ⴭ  → Ⴭ ..Ⴭ  Georgian2 */
-    {0xff41, 0xff5a, -32},    /* 26x ａ..ｚ → Ａ..Ｚ Dubs */
-};
-
-static const int kAstralUpper[][3] = {
-    {0x10428, 0x1044f, -40},  /* 40x 𐐨..𐑏 → 𐐀..𐐧 Deseret */
-    {0x104d8, 0x104fb, -40},  /* 36x 𐓘..𐓻 → 𐒰..𐓓 Osage */
-    {0x1d41a, 0x1d433, -26},  /* 26x 𝐚..𝐳 → 𝐀..𝐙 Math */
-    {0x1d456, 0x1d467, -26},  /* 18x 𝑖..𝑧 → 𝐼..𝑍 Math */
-    {0x1d482, 0x1d49b, -26},  /* 26x 𝒂..𝒛 → 𝑨..𝒁 Math */
-    {0x1d4c8, 0x1d4cf, -26},  /*  8x 𝓈..𝓏 → 𝒮..𝒵 Math */
-    {0x1d4ea, 0x1d503, -26},  /* 26x 𝓪..𝔃 → 𝓐..𝓩 Math */
-    {0x1d527, 0x1d52e, -26},  /*  8x 𝔧..𝔮 → 𝔍..𝔔 Math */
-    {0x1d586, 0x1d59f, -26},  /* 26x 𝖆..𝖟 → 𝕬..𝖅 Math */
-    {0x1d5ba, 0x1d5d3, -26},  /* 26x 𝖺..𝗓 → 𝖠..𝖹 Math */
-    {0x1d5ee, 0x1d607, -26},  /* 26x 𝗮..𝘇 → 𝗔..𝗭 Math */
-    {0x1d622, 0x1d63b, -26},  /* 26x 𝘢..𝘻 → 𝘈..𝘡 Math */
-    {0x1d68a, 0x1d6a3, +442}, /* 26x 𝒂..𝒛 → 𝘼..𝙕 Math */
-    {0x1d6c2, 0x1d6d2, -26},  /* 26x 𝚊..𝚣 → 𝙰..𝚉 Math */
-    {0x1d6fc, 0x1d70c, -26},  /* 17x 𝛂..𝛒 → 𝚨..𝚸 Math */
-    {0x1d736, 0x1d746, -26},  /* 17x 𝛼..𝜌 → 𝛢..𝛲 Math */
-    {0x1d770, 0x1d780, -26},  /* 17x 𝜶..𝝆 → 𝜜..𝜬 Math */
-    {0x1d770, 0x1d756, -26},  /* 17x 𝝰..𝞀 → 𝝖..𝝦 Math */
-    {0x1d736, 0x1d790, -90},  /* 17x 𝜶..𝝆 → 𝞐..𝞠 Math */
-};
-
-/**
- * Converts wide character to upper case.
- */
-wint_t towupper(wint_t c) {
-  int m, l, r, n;
-  if (c < 0200) {
-    if ('a' <= c && c <= 'z') {
-      return c - 32;
-    } else {
-      return c;
-    }
-  } else if (c <= 0xffff) {
-    if ((0x0101 <= c && c <= 0x0177) || /* 60x ā..ŵ → Ā..ā Watin-A */
-        (0x01df <= c && c <= 0x01ef) || /*  9x ǟ..ǯ → Ǟ..Ǯ Watin-B */
-        (0x01f8 <= c && c <= 0x021e) || /* 20x ǹ..ȟ → Ǹ..Ȟ Watin-B */
-        (0x0222 <= c && c <= 0x0232) || /*  9x ȣ..ȳ → Ȣ..Ȳ Watin-B */
-        (0x1e01 <= c && c <= 0x1eff)) { /*256x ḁ..ỿ → Ḁ..Ỿ Watin-C */
-      if (c == 0x0131) return c + 232;
-      if (c == 0x1e9e) return c;
-      return c - (c & 1);
-    } else if (0x01d0 <= c && c <= 0x01dc) {
-      return c - (~c & 1); /* 7x ǐ..ǜ → Ǐ..Ǜ Watin-B */
-    } else if (0xab70 <= c && c <= 0xabbf) {
-      return c - 38864; /* 80x ꭰ ..ꮿ  → Ꭰ ..Ꮿ  Cherokee Supplement */
-    } else {
-      l = 0;
-      r = n = sizeof(kUpper) / sizeof(kUpper[0]);
-      while (l < r) {
-        m = (l & r) + ((l ^ r) >> 1);  // floor((a+b)/2)
-        if (kUpper[m].y < c) {
-          l = m + 1;
-        } else {
-          r = m;
-        }
-      }
-      if (l < n && kUpper[l].x <= c && c <= kUpper[l].y) {
-        return c + kUpper[l].d;
-      } else {
-        return c;
-      }
-    }
-  } else {
-    l = 0;
-    r = n = sizeof(kAstralUpper) / sizeof(kAstralUpper[0]);
-    while (l < r) {
-      m = (l & r) + ((l ^ r) >> 1);  // floor((a+b)/2)
-      if (kAstralUpper[m][1] < c) {
-        l = m + 1;
-      } else {
-        r = m;
-      }
-    }
-    if (l < n && kAstralUpper[l][0] <= c && c <= kAstralUpper[l][1]) {
-      return c + kAstralUpper[l][2];
-    } else {
-      return c;
-    }
-  }
-}
-
-__weak_reference(towupper, towupper_l);
diff --git a/libc/str/tprecode16to8.c b/libc/str/tprecode16to8.c
index 9bea83682..d23eb0b5d 100644
--- a/libc/str/tprecode16to8.c
+++ b/libc/str/tprecode16to8.c
@@ -18,35 +18,55 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/fmt/conv.h"
-#include "libc/intrin/packsswb.h"
-#include "libc/intrin/pandn.h"
-#include "libc/intrin/pcmpgtw.h"
-#include "libc/intrin/pmovmskb.h"
 #include "libc/str/str.h"
 #include "libc/str/utf16.h"
+#include "third_party/aarch64/arm_neon.internal.h"
+#include "third_party/intel/emmintrin.internal.h"
 
-static const int16_t kDel16[8] = {127, 127, 127, 127, 127, 127, 127, 127};
+#if !IsModeDbg()
+#if defined(__x86_64__)
 
-/* 10x speedup for ascii */
 static axdx_t tprecode16to8_sse2(char *dst, size_t dstsize, const char16_t *src,
                                  axdx_t r) {
-  int16_t v1[8], v2[8], v3[8], vz[8];
-  memset(vz, 0, 16);
+  __m128i v1, v2, v3, vz;
+  vz = _mm_setzero_si128();
   while (r.ax + 8 < dstsize) {
-    memcpy(v1, src + r.dx, 16);
-    pcmpgtw(v2, v1, vz);
-    pcmpgtw(v3, v1, kDel16);
-    pandn((void *)v2, (void *)v3, (void *)v2);
-    if (pmovmskb((void *)v2) != 0xFFFF)
+    v1 = _mm_loadu_si128((__m128i *)(src + r.dx));
+    v2 = _mm_cmpgt_epi16(v1, vz);
+    v3 = _mm_cmpgt_epi16(v1, _mm_set1_epi16(0x7F));
+    v2 = _mm_andnot_si128(v3, v2);
+    if (_mm_movemask_epi8(v2) != 0xFFFF)
       break;
-    packsswb((void *)v1, v1, v1);
-    memcpy(dst + r.ax, v1, 8);
+    v1 = _mm_packs_epi16(v1, v1);
+    _mm_storel_epi64((__m128i *)(dst + r.ax), v1);
     r.ax += 8;
     r.dx += 8;
   }
   return r;
 }
 
+#elif defined(__aarch64__)
+
+static axdx_t tprecode16to8_neon(char *dst, size_t dstsize, const char16_t *src,
+                                 axdx_t r) {
+  uint16x8_t v1, v2, v3;
+  while (r.ax + 8 < dstsize) {
+    v1 = vld1q_u16((const uint16_t *)(src + r.dx));
+    v2 = vcgtq_u16(v1, vdupq_n_u16(0));
+    v3 = vcgtq_u16(v1, vdupq_n_u16(0x7F));
+    v2 = vbicq_u16(v2, v3);
+    if (vaddvq_u16(v2) != 8 * 0xFFFF)
+      break;
+    vst1_u8((uint8_t *)(dst + r.ax), vqmovn_u16(v1));
+    r.ax += 8;
+    r.dx += 8;
+  }
+  return r;
+}
+
+#endif
+#endif
+
 /**
  * Transcodes UTF-16 to UTF-8.
  *
@@ -66,10 +86,14 @@ axdx_t tprecode16to8(char *dst, size_t dstsize, const char16_t *src) {
   r.ax = 0;
   r.dx = 0;
   for (;;) {
-#if defined(__x86_64__) && !IsModeDbg() && !IsTiny()
-    if (!((uintptr_t)(src + r.dx) & 15)) {
+#if !IsModeDbg()
+#if defined(__x86_64__)
+    if (!((uintptr_t)(src + r.dx) & 15))
       r = tprecode16to8_sse2(dst, dstsize, src, r);
-    }
+#elif defined(__aarch64__)
+    if (!((uintptr_t)(src + r.dx) & 15))
+      r = tprecode16to8_neon(dst, dstsize, src, r);
+#endif
 #endif
     if (!(x = src[r.dx++]))
       break;
diff --git a/libc/str/tprecode8to16.c b/libc/str/tprecode8to16.c
index d823f3163..2924184f8 100644
--- a/libc/str/tprecode8to16.c
+++ b/libc/str/tprecode8to16.c
@@ -16,34 +16,61 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pcmpgtb.h"
-#include "libc/intrin/pmovmskb.h"
-#include "libc/intrin/punpckhbw.h"
-#include "libc/intrin/punpcklbw.h"
+#include <arm_neon.h>
+#include <stdint.h>
+#include <string.h>
+#include "libc/dce.h"
 #include "libc/str/str.h"
 #include "libc/str/thompike.h"
 #include "libc/str/utf16.h"
+#include "third_party/aarch64/arm_neon.internal.h"
+#include "third_party/intel/emmintrin.internal.h"
+
+#if !IsModeDbg()
+#if defined(__x86_64__)
 
-// 34x speedup for ascii
 static inline axdx_t tprecode8to16_sse2(char16_t *dst, size_t dstsize,
                                         const char *src, axdx_t r) {
-  uint8_t v1[16], v2[16], vz[16];
-  memset(vz, 0, 16);
+  __m128i v1, v2, vz;
+  vz = _mm_setzero_si128();
   while (r.ax + 16 < dstsize) {
-    memcpy(v1, src + r.dx, 16);
-    pcmpgtb((int8_t *)v2, (int8_t *)v1, (int8_t *)vz);
-    if (pmovmskb(v2) != 0xFFFF)
+    v1 = _mm_loadu_si128((__m128i *)(src + r.dx));
+    v2 = _mm_cmpgt_epi8(v1, vz);
+    if (_mm_movemask_epi8(v2) != 0xFFFF)
       break;
-    punpcklbw(v2, v1, vz);
-    punpckhbw(v1, v1, vz);
-    memcpy(dst + r.ax + 0, v2, 16);
-    memcpy(dst + r.ax + 8, v1, 16);
+    __m128i lo = _mm_unpacklo_epi8(v1, vz);
+    __m128i hi = _mm_unpackhi_epi8(v1, vz);
+    _mm_storeu_si128((__m128i *)(dst + r.ax), lo);
+    _mm_storeu_si128((__m128i *)(dst + r.ax + 8), hi);
     r.ax += 16;
     r.dx += 16;
   }
   return r;
 }
 
+#elif defined(__aarch64__)
+
+static inline axdx_t tprecode8to16_neon(char16_t *dst, size_t dstsize,
+                                        const char *src, axdx_t r) {
+  uint8x16_t v1;
+  while (r.ax + 16 < dstsize) {
+    v1 = vld1q_u8((const uint8_t *)(src + r.dx));
+    uint8x16_t cmp = vcgtq_u8(v1, vdupq_n_u8(0));
+    if (vaddvq_u8(cmp) != 16 * 0xFF)
+      break;
+    uint16x8_t lo = vmovl_u8(vget_low_u8(v1));
+    uint16x8_t hi = vmovl_u8(vget_high_u8(v1));
+    vst1q_u16((uint16_t *)(dst + r.ax), lo);
+    vst1q_u16((uint16_t *)(dst + r.ax + 8), hi);
+    r.ax += 16;
+    r.dx += 16;
+  }
+  return r;
+}
+
+#endif
+#endif
+
 /**
  * Transcodes UTF-8 to UTF-16.
  *
@@ -64,10 +91,14 @@ axdx_t tprecode8to16(char16_t *dst, size_t dstsize, const char *src) {
   r.ax = 0;
   r.dx = 0;
   for (;;) {
-#if defined(__x86_64__) && !IsModeDbg()
-    if (!((uintptr_t)(src + r.dx) & 15)) {
+#if !IsModeDbg()
+#if defined(__x86_64__)
+    if (!((uintptr_t)(src + r.dx) & 15))
       r = tprecode8to16_sse2(dst, dstsize, src, r);
-    }
+#elif defined(__aarch64__)
+    if (!((uintptr_t)(src + r.dx) & 15))
+      r = tprecode8to16_neon(dst, dstsize, src, r);
+#endif
 #endif
     x = src[r.dx++] & 0377;
     if (x >= 0300) {
diff --git a/libc/str/uselocale.c b/libc/str/uselocale.c
deleted file mode 100644
index 408c1ce5d..000000000
--- a/libc/str/uselocale.c
+++ /dev/null
@@ -1,25 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/locale.h"
-#include "libc/sysv/errfuns.h"
-
-locale_t uselocale(locale_t l) {
-  // TODO: implement me!
-  return 0;
-}
diff --git a/libc/str/wcrtomb.c b/libc/str/wcrtomb.c
deleted file mode 100644
index 1596c63e6..000000000
--- a/libc/str/wcrtomb.c
+++ /dev/null
@@ -1,65 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  Musl Libc                                                                   │
-│  Copyright © 2005-2014 Rich Felker, et al.                                   │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files (the             │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and/or sell copies of the Software, and to          │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│  The above copyright notice and this permission notice shall be              │
-│  included in all copies or substantial portions of the Software.             │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
-│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
-│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
-│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
-│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
-__static_yoink("musl_libc_notice");
-
-size_t wcrtomb(char *s, wchar_t wc, mbstate_t *st) {
-  if (!s)
-    return 1;
-  if ((unsigned)wc < 0x80) {
-    *s = wc;
-    return 1;
-  } else if (MB_CUR_MAX == 1) {
-    if (!IS_CODEUNIT(wc)) {
-      errno = EILSEQ;
-      return -1;
-    }
-    *s = wc;
-    return 1;
-  } else if ((unsigned)wc < 0x800) {
-    *s++ = 0xc0 | (wc >> 6);
-    *s = 0x80 | (wc & 0x3f);
-    return 2;
-  } else if ((unsigned)wc < 0xd800 || (unsigned)wc - 0xe000 < 0x2000) {
-    *s++ = 0xe0 | (wc >> 12);
-    *s++ = 0x80 | ((wc >> 6) & 0x3f);
-    *s = 0x80 | (wc & 0x3f);
-    return 3;
-  } else if ((unsigned)wc - 0x10000 < 0x100000) {
-    *s++ = 0xf0 | (wc >> 18);
-    *s++ = 0x80 | ((wc >> 12) & 0x3f);
-    *s++ = 0x80 | ((wc >> 6) & 0x3f);
-    *s = 0x80 | (wc & 0x3f);
-    return 4;
-  }
-  errno = EILSEQ;
-  return -1;
-}
diff --git a/libc/str/wcsnrtombs.c b/libc/str/wcsnrtombs.c
deleted file mode 100644
index 549a706f9..000000000
--- a/libc/str/wcsnrtombs.c
+++ /dev/null
@@ -1,67 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  Musl Libc                                                                   │
-│  Copyright © 2005-2014 Rich Felker, et al.                                   │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files (the             │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and/or sell copies of the Software, and to          │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│  The above copyright notice and this permission notice shall be              │
-│  included in all copies or substantial portions of the Software.             │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
-│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
-│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
-│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
-│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
-__static_yoink("musl_libc_notice");
-
-size_t wcsnrtombs(char *dst, const wchar_t **wcs, size_t wn, size_t n,
-                  mbstate_t *st) {
-  const wchar_t *ws = *wcs;
-  size_t cnt = 0;
-  if (!dst)
-    n = 0;
-  while (ws && wn) {
-    char tmp[MB_LEN_MAX];
-    size_t l = wcrtomb(n < MB_LEN_MAX ? tmp : dst, *ws, 0);
-    if (l == -1) {
-      cnt = -1;
-      break;
-    }
-    if (dst) {
-      if (n < MB_LEN_MAX) {
-        if (l > n)
-          break;
-        memcpy(dst, tmp, l);
-      }
-      dst += l;
-      n -= l;
-    }
-    if (!*ws) {
-      ws = 0;
-      break;
-    }
-    ws++;
-    wn--;
-    cnt += l;
-  }
-  if (dst)
-    *wcs = ws;
-  return cnt;
-}
diff --git a/libc/str/wcsrtombs.c b/libc/str/wcsrtombs.c
deleted file mode 100644
index 70d115684..000000000
--- a/libc/str/wcsrtombs.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  Musl Libc                                                                   │
-│  Copyright © 2005-2014 Rich Felker, et al.                                   │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files (the             │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and/or sell copies of the Software, and to          │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│  The above copyright notice and this permission notice shall be              │
-│  included in all copies or substantial portions of the Software.             │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
-│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
-│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
-│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
-│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
-__static_yoink("musl_libc_notice");
-
-size_t wcsrtombs(char *s, const wchar_t **ws, size_t n, mbstate_t *st) {
-  const wchar_t *ws2;
-  char buf[4];
-  size_t N = n, l;
-  if (!s) {
-    for (n = 0, ws2 = *ws; *ws2; ws2++) {
-      if (*ws2 >= 0x80u) {
-        l = wcrtomb(buf, *ws2, 0);
-        if (!(l + 1))
-          return -1;
-        n += l;
-      } else
-        n++;
-    }
-    return n;
-  }
-  while (n >= 4) {
-    if (**ws - 1u >= 0x7fu) {
-      if (!**ws) {
-        *s = 0;
-        *ws = 0;
-        return N - n;
-      }
-      l = wcrtomb(s, **ws, 0);
-      if (!(l + 1))
-        return -1;
-      s += l;
-      n -= l;
-    } else {
-      *s++ = **ws;
-      n--;
-    }
-    (*ws)++;
-  }
-  while (n) {
-    if (**ws - 1u >= 0x7fu) {
-      if (!**ws) {
-        *s = 0;
-        *ws = 0;
-        return N - n;
-      }
-      l = wcrtomb(buf, **ws, 0);
-      if (!(l + 1))
-        return -1;
-      if (l > n)
-        return N - n;
-      wcrtomb(s, **ws, 0);
-      s += l;
-      n -= l;
-    } else {
-      *s++ = **ws;
-      n--;
-    }
-    (*ws)++;
-  }
-  return N;
-}
diff --git a/libc/str/wcsstr.c b/libc/str/wcsstr.c
index 1867ecd93..bbf064c59 100644
--- a/libc/str/wcsstr.c
+++ b/libc/str/wcsstr.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/str/kmp.h"
 #include "libc/str/str.h"
 
 /**
@@ -28,19 +29,5 @@
  * @see memmem()
  */
 wchar_t *wcsstr(const wchar_t *haystack, const wchar_t *needle) {
-  size_t i;
-  for (;;) {
-    for (i = 0;;) {
-      if (!needle[i])
-        return (/*unconst*/ wchar_t *)haystack;
-      if (!haystack[i])
-        break;
-      if (needle[i] != haystack[i])
-        break;
-      ++i;
-    }
-    if (!*haystack++)
-      break;
-  }
-  return NULL;
+  return __memmem_kmp32(haystack, wcslen(haystack), needle, wcslen(needle));
 }
diff --git a/libc/str/wcstombs.c b/libc/str/wcstombs.c
deleted file mode 100644
index b269fce52..000000000
--- a/libc/str/wcstombs.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-size_t wcstombs(char *s, const wchar_t *ws, size_t n) {
-  return wcsrtombs(s, &(const wchar_t *){ws}, n, 0);
-}
diff --git a/libc/str/wctomb.c b/libc/str/wctomb.c
deleted file mode 100644
index e2ca942d1..000000000
--- a/libc/str/wctomb.c
+++ /dev/null
@@ -1,26 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/limits.h"
-#include "libc/str/str.h"
-
-int wctomb(char *s, wchar_t wc) {
-  if (!s)
-    return 0;
-  return wcrtomb(s, wc, 0);
-}
diff --git a/libc/str/wctrans.c b/libc/str/wctrans.c
deleted file mode 100644
index 2fa75a817..000000000
--- a/libc/str/wctrans.c
+++ /dev/null
@@ -1,27 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-
-wctrans_t wctrans(const char *s) {
-  if (!strcmp(s, "toupper"))
-    return (wctrans_t)1;
-  if (!strcmp(s, "tolower"))
-    return (wctrans_t)2;
-  return 0;
-}
diff --git a/libc/str/wctype.c b/libc/str/wctype.c
index 588439a25..e20ef27be 100644
--- a/libc/str/wctype.c
+++ b/libc/str/wctype.c
@@ -16,9 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/wctype.h"
+#include "libc/macros.h"
 #include "libc/serialize.h"
-#include "libc/str/str.h"
 
 static const char kWcTypeNames[][8] = {
     "alnum",   //
diff --git a/libc/str/wcwidth.c b/libc/str/wcwidth.c
index 093133c2e..379a11454 100644
--- a/libc/str/wcwidth.c
+++ b/libc/str/wcwidth.c
@@ -1,44 +1,61 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
 │                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/likely.h"
-#include "libc/str/str.h"
 #include "libc/str/unicode.h"
-#include "libc/str/wcwidth_osx.internal.h"
+__static_yoink("musl_libc_notice");
+// clang-format off
 
-/**
- * Returns cell width of monospace character.
- */
-int wcwidth(wchar_t c) {
-  int res;
-  if (LIKELY(32 <= c && c < 127))
-    return 1;
-  if (VERY_UNLIKELY((uint32_t)c >= 0x100000)) {
-    if ((uint32_t)c <= 0x10FFFD)
-      return 1;
-    return -1;
-  }
-  res = _wcwidth_osx(c);
-  if (VERY_UNLIKELY(!res)) {
-    if (!c)
-      return 0;
-    if (iswcntrl(c))
-      return -1;
-  }
-  return res;
+static const unsigned char table[] = {
+#include "nonspacing.inc"
+};
+
+static const unsigned char wtable[] = {
+#include "wide.inc"
+};
+
+int wcwidth(wchar_t wc)
+{
+	if ((int)wc < 0xff) {
+		if ((int)wc >= 0)
+			return ((wc+1) & 0x7f) >= 0x21 ? 1 : wc ? -1 : 0;
+		return -1;
+	}
+	if ((wc & 0xfffeffffU) < 0xfffe) {
+		if ((table[table[wc>>8]*32+((wc&255)>>3)]>>(wc&7))&1)
+			return 0;
+		if ((wtable[wtable[wc>>8]*32+((wc&255)>>3)]>>(wc&7))&1)
+			return 2;
+		return 1;
+	}
+	if ((wc & 0xfffe) == 0xfffe)
+		return -1;
+	if (wc-0x20000U < 0x20000)
+		return 2;
+	if (wc == 0xe0001 || wc-0xe0020U < 0x5f || wc-0xe0100U < 0xef)
+		return 0;
+	return 1;
 }
diff --git a/libc/str/wcwidth_osx.c b/libc/str/wcwidth_osx.c
deleted file mode 100644
index 6a2b64c01..000000000
--- a/libc/str/wcwidth_osx.c
+++ /dev/null
@@ -1,238 +0,0 @@
-// Copyright (c) 2012 Byron Lai
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-// BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#include "libc/macros.internal.h"
-#include "libc/str/wcwidth_osx.internal.h"
-
-const uint8_t kWcwidthOsxIndex1[] = {
-    0,   16,  26,  33,  34,  50,  56,  72,  88,  104, 107, 107, 107, 107,
-    115, 127, 143, 143, 143, 143, 143, 156, 160, 164, 178, 178, 178, 178,
-    178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
-    178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
-    178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
-    178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
-    178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
-    178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178, 178,
-    178, 178, 178, 178, 178, 178, 178, 178, 194, 194, 194, 194, 194, 194,
-    194, 195, 211, 211, 211, 211, 211, 211, 211, 212,
-};
-
-const uint16_t kWcwidthOsxIndex2[] = {
-    0,   8,   22,  38,  54,  70,  86,  102, 118, 134, 150, 163, 179, 195, 211,
-    227, 243, 256, 272, 284, 299, 305, 321, 336, 352, 368, 376, 376, 376, 376,
-    376, 376, 379, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393, 393,
-    393, 393, 393, 393, 396, 412, 412, 424, 439, 455, 471, 487, 487, 487, 487,
-    487, 487, 487, 487, 487, 487, 487, 490, 504, 504, 504, 504, 520, 520, 520,
-    520, 520, 520, 520, 520, 520, 520, 520, 520, 529, 544, 559, 575, 591, 607,
-    623, 629, 645, 661, 664, 664, 664, 664, 664, 664, 664, 664, 664, 664, 680,
-    685, 701, 705, 705, 705, 705, 705, 705, 705, 705, 705, 705, 705, 705, 705,
-    705, 705, 705, 721, 737, 753, 764, 780, 780, 780, 780, 780, 780, 780, 780,
-    796, 801, 801, 801, 801, 801, 801, 801, 817, 817, 817, 817, 817, 817, 817,
-    817, 817, 817, 817, 817, 817, 817, 817, 817, 827, 834, 834, 834, 834, 834,
-    834, 834, 834, 834, 834, 834, 834, 834, 834, 834, 834, 850, 866, 867, 867,
-    867, 867, 867, 867, 867, 867, 867, 867, 867, 867, 867, 867, 867, 867, 883,
-    883, 883, 883, 883, 883, 883, 883, 883, 883, 883, 883, 883, 883, 883, 883,
-    884, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, 900,
-    900, 900, 901,
-};
-
-const uint32_t kWcwidthOsxIndex3[] = {
-    0,    32,   32,   33,   64,   96,   96,   96,   96,   96,   96,   96,
-    96,   96,   96,   96,   128,  128,  128,  144,  175,  205,  208,  208,
-    208,  208,  237,  247,  247,  247,  247,  275,  292,  316,  340,  351,
-    381,  402,  428,  457,  478,  510,  527,  527,  537,  564,  582,  600,
-    619,  632,  632,  658,  690,  711,  738,  738,  738,  738,  738,  738,
-    738,  738,  767,  773,  804,  834,  866,  889,  920,  951,  980,  1003,
-    1034, 1065, 1094, 1117, 1148, 1180, 1210, 1233, 1263, 1294, 1323, 1355,
-    1384, 1410, 1441, 1464, 1495, 1527, 1559, 1582, 1611, 1643, 1673, 1696,
-    1727, 1759, 1791, 1817, 1849, 1881, 1912, 1927, 1958, 1986, 2017, 2049,
-    2081, 2111, 2143, 2169, 2195, 2214, 2240, 2252, 2282, 2303, 2335, 2354,
-    2380, 2406, 2412, 2442, 2468, 2484, 2516, 2516, 2522, 2554, 2554, 2554,
-    2554, 2554, 2586, 2586, 2609, 2641, 2664, 2680, 2710, 2734, 2749, 2773,
-    2778, 2810, 2813, 2845, 2845, 2856, 2887, 2888, 2888, 2888, 2888, 2888,
-    2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2888, 2897, 2929,
-    2961, 2961, 2976, 3008, 3040, 3072, 3104, 3136, 3148, 3178, 3210, 3242,
-    3274, 3274, 3282, 3314, 3337, 3348, 3348, 3380, 3409, 3441, 3459, 3491,
-    3513, 3535, 3565, 3574, 3606, 3606, 3606, 3606, 3606, 3606, 3606, 3634,
-    3646, 3676, 3697, 3729, 3750, 3776, 3776, 3808, 3816, 3830, 3843, 3875,
-    3875, 3875, 3875, 3907, 3907, 3907, 3907, 3907, 3907, 3939, 3964, 3996,
-    3996, 3996, 3996, 3996, 3996, 3996, 3996, 4006, 4038, 4064, 4095, 4127,
-    4138, 4154, 4183, 4215, 4239, 4254, 4286, 4306, 4338, 4360, 4376, 4408,
-    4408, 4424, 4443, 4466, 4482, 4482, 4482, 4482, 4482, 4482, 4482, 4482,
-    4482, 4505, 4516, 4516, 4516, 4516, 4516, 4540, 4572, 4597, 4629, 4661,
-    4661, 4661, 4661, 4661, 4661, 4661, 4661, 4661, 4661, 4661, 4661, 4661,
-    4663, 4695, 4723, 4727, 4758, 4782, 4802, 4833, 4844, 4868, 4888, 4904,
-    4904, 4904, 4904, 4904, 4904, 4904, 4904, 4904, 4904, 4904, 4904, 4904,
-    4904, 4904, 4904, 4923, 4944, 4944, 4944, 4944, 4944, 4976, 4993, 5009,
-    5024, 5056, 5056, 5056, 5077, 5102, 5128, 5144, 5170, 5202, 5234, 5234,
-    5266, 5281, 5298, 5298, 5330, 5357, 5357, 5369, 5401, 5401, 5401, 5401,
-    5401, 5401, 5411, 5433, 5465, 5487, 5519, 5520, 5529, 5556, 5556, 5556,
-    5588, 5606, 5623, 5623, 5640, 5656, 5664, 5680, 5696, 5728, 5756, 5772,
-    5772, 5772, 5772, 5773, 5805, 5805, 5805, 5805, 5805, 5805, 5805, 5805,
-    5805, 5805, 5805, 5805, 5805, 5805, 5805, 5805, 5815, 5847, 5847, 5847,
-    5847, 5847, 5847, 5847, 5847, 5847, 5847, 5847, 5847, 5847, 5847, 5847,
-    5847, 5851, 5879, 5879, 5911, 5911, 5911, 5911, 5911, 5911, 5911, 5911,
-    5911, 5911, 5911, 5911, 5911, 5911, 5911, 5911, 5930, 5946, 5971, 5978,
-    6010, 6010, 6010, 6010, 6010, 6010, 6010, 6010, 6030, 6062, 6094, 6122,
-    6146, 6146, 6146, 6178, 6178, 6178, 6178, 6197, 6210, 6210, 6215, 6245,
-    6272, 6304, 6312, 6344, 6344, 6371, 6397, 6429, 6429, 6441, 6473, 6473,
-    6473, 6473, 6473, 6505, 6514, 6546, 6578, 6578, 6578, 6578, 6578, 6578,
-    6578, 6578, 6578, 6578, 6578, 6578, 6578, 6610, 6610, 6610, 6610, 6610,
-    6610, 6610, 6610, 6610, 6610, 6610, 6610, 6610, 6610, 6610, 6610, 6638,
-    6642, 6642, 6642, 6642, 6642, 6642, 6642, 6642, 6642, 6642, 6642, 6642,
-    6642, 6642, 6642, 6642, 6674, 6674, 6674, 6674, 6674, 6674, 6674, 6674,
-    6674, 6674, 6674, 6674, 6674, 6674, 6674, 6674, 6690, 6722, 6722, 6722,
-    6722, 6722, 6722, 6722, 6722, 6740, 6756, 6777, 6793, 6793, 6799, 6825,
-    6857, 6888, 6920, 6926, 6926, 6940, 6958, 6977, 6977, 6977, 6977, 6977,
-    6977, 6977, 6977, 6977, 6977, 7009, 7025, 7041, 7059, 7083, 7099, 7129,
-    7157, 7173, 7198, 7220, 7220, 7220, 7223, 7254, 7255, 7255, 7286, 7287,
-    7288, 7319, 7351, 7383, 7388, 7419, 7449, 7481, 7481, 7481, 7486, 7518,
-    7530, 7553, 7553, 7574, 7602, 7618, 7634, 7664, 7664, 7664, 7664, 7696,
-    7728, 7743, 7760, 7792, 7819, 7840, 7851, 7883, 7914, 7942, 7964, 7996,
-    7996, 7996, 7996, 7998, 8018, 8028, 8028, 8028, 8028, 8028, 8028, 8028,
-    8028, 8028, 8028, 8028, 8028, 8028, 8028, 8028, 8028, 8060, 8070, 8102,
-    8102, 8102, 8102, 8102, 8102, 8134, 8166, 8166, 8166, 8166, 8166, 8166,
-    8166, 8198, 8223, 8255, 8280, 8280, 8280, 8280, 8280, 8280, 8280, 8280,
-    8280, 8280, 8280, 8280, 8280, 8280, 8280, 8280, 8312, 8312, 8312, 8312,
-    8312, 8312, 8312, 8312, 8312, 8312, 8312, 8312, 8312, 8312, 8312, 8312,
-    8329, 8344, 8344, 8344, 8344, 8376, 8376, 8376, 8405, 8425, 8425, 8425,
-    8425, 8425, 8425, 8425, 8425, 8425, 8425, 8425, 8425, 8425, 8425, 8425,
-    8425, 8457, 8457, 8457, 8457, 8457, 8457, 8457, 8467, 8499, 8524, 8533,
-    8558, 8587, 8609, 8623, 8653, 8685, 8685, 8715, 8721, 8721, 8721, 8721,
-    8721, 8753, 8753, 8762, 8767, 8785, 8785, 8785, 8785, 8817, 8817, 8828,
-    8850, 8853, 8885, 8914, 8919, 8945, 8975, 9007, 9025, 9025, 9025, 9025,
-    9025, 9051, 9059, 9059, 9059, 9059, 9059, 9059, 9059, 9059, 9079, 9093,
-    9125, 9125, 9125, 9125, 9125, 9125, 9125, 9125, 9125, 9125, 9125, 9125,
-    9125, 9125, 9125, 9125, 9157, 9177, 9193, 9193, 9205, 9225, 9225, 9225,
-    9225, 9225, 9225, 9225, 9225, 9225, 9225, 9225, 9225, 9225, 9225, 9225,
-    9225, 9257, 9257, 9257, 9257, 9257, 9257, 9257, 9257, 9257, 9257, 9257,
-    9257, 9257, 9257, 9257, 9257, 9266, 9289, 9289, 9289, 9289, 9289, 9289,
-    9289, 9289, 9289, 9289, 9289, 9289, 9289, 9289, 9289, 9289, 9321, 9321,
-    9321, 9321, 9321, 9321, 9321, 9321, 9321, 9321, 9321, 9321, 9321, 9321,
-    9321, 9321, 9323, 9353, 9353, 9353, 9353, 9353, 9353, 9353, 9353, 9353,
-    9353, 9353, 9353, 9353, 9353, 9353, 9353, 9385, 9385, 9385, 9385, 9385,
-    9385, 9385, 9385, 9385, 9385, 9385, 9385, 9385, 9385, 9385, 9385, 9387,
-    9419, 9419, 9419, 9419, 9419, 9419, 9419, 9419, 9419, 9419, 9419, 9419,
-    9419, 9419, 9419, 9419, 9421,
-};
-
-const uint32_t kWcwidthOsx[] = {
-    0x00000000, 0x00000000, 0x55555555, 0x55555555, 0x00000000, 0x00000000,
-    0x55555555, 0x55555555, 0x00000000, 0x00000000, 0x15505555, 0x54455540,
-    0x15555555, 0x55555555, 0x55555555, 0x55554000, 0x55555555, 0x00001555,
-    0x55555500, 0x54155555, 0x55555555, 0x14555555, 0x00000000, 0x04000000,
-    0x54000041, 0x01555555, 0x00001550, 0x00555550, 0x55505550, 0x55555555,
-    0x00015555, 0x50000000, 0x45555555, 0x55555555, 0x15555555, 0x04140000,
-    0x55555550, 0x55551055, 0x00005555, 0x55550000, 0x55555555, 0x00005555,
-    0x00000040, 0x55555550, 0x55555555, 0x55400005, 0x00000005, 0x00000000,
-    0x55555550, 0x15555555, 0x54000150, 0x55000101, 0x55555055, 0x54000155,
-    0x15554505, 0x55555414, 0x40455545, 0x40015015, 0x40001141, 0x54014500,
-    0x55555555, 0x15544005, 0x55554140, 0x14555455, 0x00140145, 0x00400000,
-    0x40011540, 0x15415555, 0x55440000, 0x55545455, 0x45554555, 0x01501551,
-    0x01014400, 0x05000000, 0x04555550, 0x45000000, 0x54141555, 0x55455555,
-    0x50155145, 0x00505040, 0x51401000, 0x55555505, 0x10000000, 0x54540555,
-    0x50144501, 0x55540540, 0x50140155, 0x40010151, 0x55550000, 0x01555555,
-    0x45555150, 0x55555545, 0x54555551, 0x00550405, 0x40000000, 0x54154001,
-    0x40001555, 0x55141555, 0x55545455, 0x55551555, 0x55405545, 0x00001454,
-    0x01440005, 0x05155554, 0x51400000, 0x55454555, 0x55515555, 0x54055555,
-    0x00545440, 0x40001000, 0x55555415, 0x15550155, 0x55555514, 0x55540555,
-    0x55155555, 0x55541155, 0x00150000, 0x00015554, 0x05400000, 0x55540000,
-    0x55555555, 0x00145555, 0x01555000, 0x55555400, 0x00000005, 0x00000000,
-    0x10450450, 0x55515400, 0x51411151, 0x10000145, 0x00004554, 0x14155554,
-    0x00000000, 0x40000000, 0x55555555, 0x55541555, 0x45555555, 0x55155544,
-    0x55555555, 0x00000015, 0x00550400, 0x00000000, 0x55500000, 0x15551554,
-    0x00000000, 0x40000000, 0x55555555, 0x15555555, 0x55105440, 0x55555555,
-    0x55555055, 0x55555555, 0x55500555, 0x55555555, 0x00055555, 0x55555500,
-    0x55555555, 0xaaaaaa01, 0xaaaaaaaa, 0x000800aa, 0x00000000, 0x55500000,
-    0x55555555, 0x15455555, 0x15445554, 0x55555554, 0x55555555, 0x55550551,
-    0x05515555, 0x50551555, 0x51555555, 0x55555555, 0x45555555, 0x55555415,
-    0x55555555, 0x55500155, 0x55555555, 0x54001555, 0x55555555, 0x01555555,
-    0x55550000, 0x55555555, 0x00005555, 0x55555554, 0x05555555, 0x55555554,
-    0x55555555, 0x00000001, 0x51555555, 0x00000005, 0x55555555, 0x00001405,
-    0x55555555, 0x00000005, 0x51555555, 0x00000001, 0x55555555, 0x55555555,
-    0x55500010, 0x50000014, 0x55501555, 0x55500055, 0x55500055, 0x55510155,
-    0x55500055, 0x55555555, 0x00055555, 0x55555550, 0x55555555, 0x00000045,
-    0x00000000, 0x55555500, 0x55555555, 0x00005501, 0x00055514, 0x55555404,
-    0x55555555, 0x00005541, 0x55555540, 0x55555555, 0x55540015, 0x40015555,
-    0x54015555, 0x55555555, 0x41555555, 0x00000505, 0x00000000, 0x55555000,
-    0x55555555, 0x45440045, 0x55005555, 0x00555555, 0x05555400, 0x55555554,
-    0x55555555, 0x55555501, 0x00000000, 0x00000000, 0x55555555, 0x55555555,
-    0x55555540, 0x55555555, 0x00000015, 0x00000000, 0x55555540, 0x55555555,
-    0x50000015, 0x55555555, 0x00000015, 0x55000000, 0x55555555, 0x50555555,
-    0x55555055, 0x55555555, 0x05550555, 0x44445555, 0x55555555, 0x41555555,
-    0x55555555, 0x15555555, 0x05555555, 0x55554555, 0x54541555, 0x55554555,
-    0x55554005, 0x50001555, 0x55555555, 0x05555555, 0x50000010, 0x55555550,
-    0x00001551, 0x55555550, 0x00005555, 0x00000000, 0x00010000, 0x55550000,
-    0x55555555, 0x55405555, 0x55555555, 0x00155555, 0x55555550, 0x55555555,
-    0x555555a5, 0x55555555, 0x00000055, 0x55000000, 0x55555555, 0x00555555,
-    0x00000000, 0x55555400, 0x00000000, 0x55555400, 0x55555555, 0x55554155,
-    0x55555555, 0x00001555, 0x00000000, 0x55154000, 0x55555550, 0x55554555,
-    0x45555555, 0x55510154, 0x55555551, 0x55555555, 0x55555501, 0x55555455,
-    0x55550115, 0x55555555, 0x55405555, 0x00000000, 0x00000000, 0x55555555,
-    0x55555555, 0x55555554, 0x55555555, 0x05555554, 0x55555555, 0x55555555,
-    0x50000000, 0x55555555, 0x05555555, 0x55550000, 0x55555555, 0x00005555,
-    0x00000004, 0x55555550, 0x00015555, 0x55515550, 0x55515551, 0x55555551,
-    0x55555555, 0x00000005, 0x00000000, 0xaaaaaaa0, 0xa8aaaaaa, 0xaaaaaaaa,
-    0x02aaaaaa, 0xaaa80000, 0xaaaaaaaa, 0x0002aaaa, 0xaaa80000, 0xaaa802aa,
-    0xaaaaaaaa, 0x8002aaaa, 0x1aaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaa00,
-    0xaaaaaaaa, 0xaaa800aa, 0xaaaaaaaa, 0xaaaa80aa, 0xaaaaaaaa, 0xaaaa2aaa,
-    0xaaaaaaaa, 0x00000000, 0xaaaaaaaa, 0x2aaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
-    0xaa000000, 0xaaaaaaaa, 0xa8aaaaaa, 0xaaaaaaaa, 0x02aaaaaa, 0xaaaa8000,
-    0xaaaaaaaa, 0x00002aaa, 0x00000000, 0xaaaa8000, 0xaaaaaaaa, 0xaaa02aaa,
-    0xaaaaaaaa, 0x000aaaaa, 0x00000000, 0x55500000, 0x55555555, 0x00055555,
-    0x50000000, 0x55555555, 0x05555555, 0x55555555, 0x55500005, 0x55555555,
-    0x00000005, 0x00000000, 0x55555550, 0x55555555, 0x00000005, 0x00000000,
-    0x55151550, 0x55555554, 0x00554155, 0x00000000, 0x55555555, 0x55555555,
-    0x55550000, 0x55555555, 0x00005555, 0x01555554, 0x00000000, 0x54000000,
-    0x55555555, 0x01555555, 0x00010000, 0x00000000, 0x55540000, 0x55555555,
-    0x00015555, 0x55555550, 0x50555550, 0x00000005, 0x00000000, 0xaaaaaaa0,
-    0xaaaaaaaa, 0x0000000a, 0x00000000, 0x55555550, 0x55555555, 0x00000005,
-    0xaaaaaaa0, 0xaaaaaaaa, 0xaaaaaa0a, 0xaaaaaaaa, 0xaaa800aa, 0xaaaaaaaa,
-    0x0002aaaa, 0x00000000, 0x55540000, 0x55000000, 0x55551001, 0x15555555,
-    0x51451155, 0x55555555, 0x05555555, 0x00000000, 0x55555554, 0x55555555,
-    0x00000001, 0x55555554, 0x55555555, 0x55555541, 0x55555555, 0x00000015,
-    0x55400000, 0x00015555, 0xaaa80000, 0x0054002a, 0xaaaaa800, 0xaaa8aaaa,
-    0x500aa2aa, 0x55555515, 0x55555555, 0xaaaa8055, 0xaaaaaaaa, 0x55556aaa,
-    0x55555555, 0x15541555, 0x15541554, 0x4aaa8054, 0x00000555, 0x55554140,
-    0x55555515, 0x55451555, 0x55415555, 0x00015555, 0x00000000, 0x55540000,
-    0x55555555, 0x50015555, 0x55555401, 0x05555555, 0x55555554, 0x55555555,
-    0x55555001, 0x00000005, 0x00000000, 0x55555550, 0x55555555, 0x00000000,
-    0x00000000, 0x55555555, 0x01555555, 0x55555555, 0x55555555, 0x00000000,
-    0x00000000, 0x55555555, 0x15555555, 0x55400000, 0x00155555, 0x00000000,
-    0x55400000, 0x55555555, 0x55515555, 0x55555555, 0x50055555, 0x00555555,
-    0x00000000, 0x55000000, 0x55555555, 0x00555555, 0x00000000, 0x55000000,
-    0x55555105, 0x14555555, 0x00000410, 0x00000000, 0x55555000, 0x55555555,
-    0x00000400, 0x00000000, 0x00001000, 0x45455000, 0x55555555, 0x40000015,
-    0x40001555, 0x00005555, 0x00000000, 0x55550000, 0x55555555, 0x00005555,
-    0x00000000, 0x55550000, 0x55555555, 0x00005555, 0x00015400, 0x00000000,
-    0x55540000, 0x55555555, 0x00015555, 0x55555540, 0x55555555, 0x55555415,
-    0x55555555, 0x55550155, 0x50000001, 0x55554000, 0x40155555, 0x55555555,
-    0x01555555, 0x00000000, 0x54000000, 0x55555555, 0x01555555, 0x00000001,
-    0x00000000, 0x55555554, 0x55555555, 0x00000001, 0x00000000, 0x55555554,
-    0x55555555, 0x55555551, 0x55555555, 0x50504145, 0x15555545, 0x55554551,
-    0x55555555, 0x50551555, 0x45554555, 0x55555555, 0x45515555, 0x55540455,
-    0x55555554, 0x55555555, 0x55555541, 0x55555555, 0x55555415, 0x55555555,
-    0x00000155, 0x00000000, 0x55555400, 0x55555555, 0x55540155, 0x55555555,
-    0x00015555, 0x00000000, 0xaaa80000, 0xaaaaaaaa, 0x0002aaaa, 0x00000000,
-    0xaaa80000, 0xaaaaaaaa, 0x0002aaaa, 0x00000000, 0x55540000, 0x55555555,
-    0x55415555, 0x55555555, 0x00155555,
-};
diff --git a/libc/str/wcwidth_osx.internal.h b/libc/str/wcwidth_osx.internal.h
deleted file mode 100644
index 89ff0808c..000000000
--- a/libc/str/wcwidth_osx.internal.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_STR_WCWIDTH_OSX_H_
-#define COSMOPOLITAN_LIBC_STR_WCWIDTH_OSX_H_
-COSMOPOLITAN_C_START_
-
-extern const uint32_t kWcwidthOsx[591];
-extern const uint8_t kWcwidthOsxIndex1[136];
-extern const uint16_t kWcwidthOsxIndex2[228];
-extern const uint32_t kWcwidthOsxIndex3[917];
-
-static inline int _wcwidth_osx(uint32_t codePoint) {
-  uint32_t a, b, c, d;
-  a = kWcwidthOsxIndex1[codePoint >> 13];
-  b = kWcwidthOsxIndex2[a + ((codePoint >> 9) & 0xf)];
-  c = kWcwidthOsxIndex3[b + ((codePoint >> 5) & 0xf)];
-  d = c + (codePoint & 0x1f);
-  return (kWcwidthOsx[d >> 4] >> ((d & 0xf) << 1)) & 3;
-}
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_STR_WCWIDTH_OSX_H_ */
diff --git a/libc/str/wide.inc b/libc/str/wide.inc
new file mode 100644
index 000000000..e403c9a5a
--- /dev/null
+++ b/libc/str/wide.inc
@@ -0,0 +1,65 @@
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,18,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,19,16,20,21,22,16,16,16,23,16,16,24,25,26,27,28,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,29,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,30,16,16,16,16,31,16,16,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,32,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,16,16,16,33,
+34,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,35,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,36,17,17,37,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,38,39,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,40,41,42,43,44,45,46,47,16,48,49,16,16,16,16,
+16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,6,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,30,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,0,48,0,0,0,0,0,0,255,15,0,0,0,0,128,0,0,8,
+0,2,12,0,96,48,64,16,0,0,4,44,36,32,12,0,0,0,1,0,0,0,80,184,0,0,0,0,0,0,0,224,
+0,0,0,1,128,0,0,0,0,0,0,0,0,0,0,0,24,0,0,0,0,0,0,33,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,251,255,255,255,255,255,255,255,
+255,255,255,15,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,63,0,0,0,255,15,255,255,255,255,
+255,255,255,127,254,255,255,255,255,255,255,255,255,255,127,254,255,255,255,
+255,255,255,255,255,255,255,255,255,224,255,255,255,255,255,254,255,255,255,
+255,255,255,255,255,255,255,127,255,255,255,255,255,7,255,255,255,255,15,0,
+255,255,255,255,255,127,255,255,255,255,255,0,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,
+0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,31,255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,
+255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,255,3,0,0,255,255,255,255,247,255,127,15,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,254,255,255,255,255,255,255,255,255,255,255,
+255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,15,0,0,0,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,7,0,255,255,255,127,0,0,0,0,0,
+0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+15,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,64,254,7,0,0,0,0,0,0,0,0,0,0,0,0,7,0,255,255,255,
+255,255,15,255,1,3,0,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,
+1,224,191,255,255,255,255,255,255,255,255,223,255,255,15,0,255,255,255,255,
+255,135,15,0,255,255,17,255,255,255,255,255,255,255,255,127,253,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+159,255,255,255,255,255,255,255,63,0,120,255,255,255,0,0,4,0,0,96,0,16,0,0,0,
+0,0,0,0,0,0,0,248,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,255,255,
+255,255,255,255,255,255,63,16,39,0,0,24,240,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,255,15,0,
+0,0,224,255,255,255,255,255,255,255,255,255,255,255,255,123,252,255,255,255,
+255,231,199,255,255,255,231,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,15,7,7,0,63,0,0,0,0,0,0,0,0,0,0,0,0,0,
diff --git a/libc/system/BUILD.mk b/libc/system/BUILD.mk
new file mode 100644
index 000000000..00d4aaae9
--- /dev/null
+++ b/libc/system/BUILD.mk
@@ -0,0 +1,83 @@
+#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
+#── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
+
+PKGS += LIBC_SYSTEM
+
+LIBC_SYSTEM_ARTIFACTS += LIBC_SYSTEM_A
+LIBC_SYSTEM = $(LIBC_SYSTEM_A_DEPS) $(LIBC_SYSTEM_A)
+LIBC_SYSTEM_A = o/$(MODE)/libc/system/system.a
+LIBC_SYSTEM_A_FILES := $(wildcard libc/system/*)
+LIBC_SYSTEM_A_HDRS = $(filter %.h,$(LIBC_SYSTEM_A_FILES))
+LIBC_SYSTEM_A_INCS = $(filter %.inc,$(LIBC_SYSTEM_A_FILES))
+LIBC_SYSTEM_A_SRCS_S = $(filter %.S,$(LIBC_SYSTEM_A_FILES))
+LIBC_SYSTEM_A_SRCS_C = $(filter %.c,$(LIBC_SYSTEM_A_FILES))
+
+LIBC_SYSTEM_A_SRCS =					\
+	$(LIBC_SYSTEM_A_SRCS_S)				\
+	$(LIBC_SYSTEM_A_SRCS_C)
+
+LIBC_SYSTEM_A_OBJS =					\
+	$(LIBC_SYSTEM_A_SRCS_S:%.S=o/$(MODE)/%.o)	\
+	$(LIBC_SYSTEM_A_SRCS_C:%.c=o/$(MODE)/%.o)
+
+LIBC_SYSTEM_A_CHECKS =					\
+	$(LIBC_SYSTEM_A).pkg				\
+	$(LIBC_SYSTEM_A_HDRS:%=o/$(MODE)/%.ok)
+
+LIBC_SYSTEM_A_DIRECTDEPS =				\
+	LIBC_CALLS					\
+	LIBC_FMT					\
+	LIBC_INTRIN					\
+	LIBC_NEXGEN32E					\
+	LIBC_PROC					\
+	LIBC_RUNTIME					\
+	LIBC_STDIO					\
+	LIBC_STR					\
+	LIBC_SYSV					\
+	THIRD_PARTY_MUSL				\
+	THIRD_PARTY_SED					\
+	THIRD_PARTY_TR					\
+
+LIBC_SYSTEM_A_DEPS :=					\
+	$(call uniq,$(foreach x,$(LIBC_SYSTEM_A_DIRECTDEPS),$($(x))))
+
+$(LIBC_SYSTEM_A):libc/system/				\
+		$(LIBC_SYSTEM_A).pkg			\
+		$(LIBC_SYSTEM_A_OBJS)
+
+$(LIBC_SYSTEM_A).pkg:					\
+		$(LIBC_SYSTEM_A_OBJS)			\
+		$(foreach x,$(LIBC_SYSTEM_A_DIRECTDEPS),$($(x)_A).pkg)
+
+# offer assurances about the stack safety of cosmo libc
+$(LIBC_SYSTEM_A_OBJS): private COPTS += -Wframe-larger-than=4096 -Walloca-larger-than=4096
+
+$(LIBC_SYSTEM_A_OBJS): private				\
+		CFLAGS +=				\
+			-fno-sanitize=all		\
+			-Wframe-larger-than=4096	\
+			-Walloca-larger-than=4096
+
+o/$(MODE)/libc/system/fputc.o: private			\
+		CFLAGS +=				\
+			-O3
+
+o//libc/system/appendw.o: private			\
+		CFLAGS +=				\
+			-Os
+
+o/$(MODE)/libc/system/dirstream.o			\
+o/$(MODE)/libc/system/mt19937.o: private			\
+		CFLAGS +=				\
+			-ffunction-sections
+
+LIBC_SYSTEM_LIBS = $(foreach x,$(LIBC_SYSTEM_ARTIFACTS),$($(x)))
+LIBC_SYSTEM_SRCS = $(foreach x,$(LIBC_SYSTEM_ARTIFACTS),$($(x)_SRCS))
+LIBC_SYSTEM_HDRS = $(foreach x,$(LIBC_SYSTEM_ARTIFACTS),$($(x)_HDRS))
+LIBC_SYSTEM_INCS = $(foreach x,$(LIBC_SYSTEM_ARTIFACTS),$($(x)_INCS))
+LIBC_SYSTEM_CHECKS = $(foreach x,$(LIBC_SYSTEM_ARTIFACTS),$($(x)_CHECKS))
+LIBC_SYSTEM_OBJS = $(foreach x,$(LIBC_SYSTEM_ARTIFACTS),$($(x)_OBJS))
+$(LIBC_SYSTEM_OBJS): $(BUILD_FILES) libc/system/BUILD.mk
+
+.PHONY: o/$(MODE)/libc/system
+o/$(MODE)/libc/system: $(LIBC_SYSTEM_CHECKS)
diff --git a/libc/proc/cocmd.c b/libc/system/cocmd.c
similarity index 96%
rename from libc/proc/cocmd.c
rename to libc/system/cocmd.c
index 59aba86cc..36bbbf5ba 100644
--- a/libc/proc/cocmd.c
+++ b/libc/system/cocmd.c
@@ -20,15 +20,16 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/calls/struct/timespec.h"
+#include "libc/ctype.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/getenv.internal.h"
+#include "libc/intrin/getenv.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/serialize.h"
 #include "libc/stdio/stdio.h"
@@ -742,15 +743,12 @@ static int TryBuiltin(bool wantexec) {
     return Usleep();
   if (!strcmp(args[0], "toupper"))
     return Toupper();
-  if (_weaken(_tr) && !strcmp(args[0], "tr")) {
-    return Fake(_weaken(_tr), wantexec);
-  }
-  if (_weaken(_sed) && !strcmp(args[0], "sed")) {
-    return Fake(_weaken(_sed), wantexec);
-  }
-  if (_weaken(_awk) && !strcmp(args[0], "awk")) {
+  if (!strcmp(args[0], "tr"))
+    return Fake(_tr, wantexec);
+  if (!strcmp(args[0], "sed"))
+    return Fake(_sed, wantexec);
+  if (_weaken(_awk) && strcmp(args[0], "awk"))
     return Fake(_weaken(_awk), wantexec);
-  }
   if (_weaken(_curl) && !strcmp(args[0], "curl")) {
     return Fake(_weaken(_curl), wantexec);
   }
@@ -1054,12 +1052,9 @@ int _cocmd(int argc, char **argv, char **envp) {
   unsupported['('] = true;
   unsupported[')'] = true;
   unsupported['{'] = true;
-  unsupported['}'] = false;  // Perl t/op/exec.t depends on unpaired } being
-                             // passed from the shell to Perl
-  if (!_weaken(glob)) {
-    unsupported['*'] = true;
-    unsupported['?'] = true;
-  }
+  // Perl t/op/exec.t depends on unpaired } being
+  // passed from the shell to Perl
+  unsupported['}'] = false;
 
   if (argc >= 3 && !strcmp(argv[1], "--")) {
     for (i = 2; i < argc; ++i) {
@@ -1120,18 +1115,16 @@ int _cocmd(int argc, char **argv, char **envp) {
         Open(GetRedirectArg(prog, arg, 1), 0, O_RDONLY);
       } else {
         int globrc = GLOB_NOMATCH;
-        if (_weaken(glob)) {
-          globrc = _weaken(glob)(arg, globFlags, NULL, &globTheBuilder);
-          if (globrc == 0) {
-            for (; globCount < globTheBuilder.gl_pathc; globCount++) {
-              args[n++] = globTheBuilder.gl_pathv[globCount];
-            }
-          } else if (globrc != GLOB_NOMATCH) {
-            tinyprint(2, prog, ": error: with glob\n", NULL);
-            _Exit(16);
+        globrc = glob(arg, globFlags, NULL, &globTheBuilder);
+        if (globrc == 0) {
+          for (; globCount < globTheBuilder.gl_pathc; globCount++) {
+            args[n++] = globTheBuilder.gl_pathv[globCount];
           }
-          globFlags |= GLOB_APPEND;
+        } else if (globrc != GLOB_NOMATCH) {
+          tinyprint(2, prog, ": error: with glob\n", NULL);
+          _Exit(16);
         }
+        globFlags |= GLOB_APPEND;
         if (globrc == GLOB_NOMATCH) {
           args[n++] = arg;
         }
diff --git a/libc/stdio/fleaks.c b/libc/system/fleaks.c
similarity index 97%
rename from libc/stdio/fleaks.c
rename to libc/system/fleaks.c
index 20a1d4a7b..e4f0bfd90 100644
--- a/libc/stdio/fleaks.c
+++ b/libc/system/fleaks.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
 #include "libc/runtime/runtime.h"
@@ -31,6 +32,8 @@ void CheckForFileLeaks(void) {
   char *p = msg;
   char *pe = msg + 256;
   bool gotsome = false;
+  if (IsQemuUser())
+    usleep(10000);  // weird qemu mt flake
   for (int fd = 3; fd < MIN_CLANDESTINE_FD; ++fd) {
     if (fcntl(fd, F_GETFL) != -1) {
       if (!gotsome) {
diff --git a/libc/stdio/pclose.c b/libc/system/pclose.c
similarity index 100%
rename from libc/stdio/pclose.c
rename to libc/system/pclose.c
diff --git a/libc/stdio/popen.c b/libc/system/popen.c
similarity index 93%
rename from libc/stdio/popen.c
rename to libc/system/popen.c
index d53d5a426..2636cc5ff 100644
--- a/libc/stdio/popen.c
+++ b/libc/system/popen.c
@@ -22,7 +22,6 @@
 #include "libc/intrin/weaken.h"
 #include "libc/paths.h"
 #include "libc/runtime/runtime.h"
-#include "libc/stdio/fflush.internal.h"
 #include "libc/stdio/internal.h"
 #include "libc/stdio/stdio.h"
 #include "libc/sysv/consts/f.h"
@@ -54,7 +53,7 @@
  * @cancelationpoint
  */
 FILE *popen(const char *cmdline, const char *mode) {
-  FILE *f, *f2;
+  FILE *f;
   int e, rc, pid, dir, flags, pipefds[2];
   flags = fopenflags(mode);
   if ((flags & O_ACCMODE) == O_RDONLY) {
@@ -75,20 +74,28 @@ FILE *popen(const char *cmdline, const char *mode) {
   if ((f = fdopen(pipefds[dir], mode))) {
     switch ((pid = fork())) {
       case 0:
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wanalyzer-fd-leak"
         unassert(dup2(pipefds[!dir], !dir) == !dir);
+#pragma GCC diagnostic pop
         // we can't rely on cloexec because cocmd builtins don't execve
         if (pipefds[0] != !dir)
           unassert(!close(pipefds[0]));
         if (pipefds[1] != !dir)
           unassert(!close(pipefds[1]));
+
         // "The popen() function shall ensure that any streams from
         //  previous popen() calls that remain open in the parent
         //  process are closed in the new child process." -POSIX
-        for (int i = 0; i < __fflush.handles.i; ++i) {
-          if ((f2 = __fflush.handles.p[i]) && f2->pid) {
+        for (struct Dll *e = dll_first(__stdio.files); e;
+             e = dll_next(__stdio.files, e)) {
+          FILE *f2 = FILE_CONTAINER(e);
+          if (f != f2 && f2->pid && f2->fd != -1) {
             close(f2->fd);
+            f2->fd = -1;
           }
         }
+
         _Exit(_cocmd(3,
                      (char *[]){
                          "popen",
diff --git a/libc/proc/system.c b/libc/system/system.c
similarity index 96%
rename from libc/proc/system.c
rename to libc/system/system.c
index fddb4a0dd..6755d1f06 100644
--- a/libc/proc/system.c
+++ b/libc/system/system.c
@@ -38,9 +38,7 @@
  * provides Bourne-like syntax on all platforms, including Windows. Many
  * builtin commands are included, e.g. exit, cd, rm, [, cat, wait, exec,
  * env, echo, read, true, test, kill, touch, rmdir, mkdir, false, mktemp
- * and usleep. It's also possible to __static_yoink() the symbols `_tr`,
- * `_sed`, `_awk`, and `_curl` for the tr, sed, awk and curl commands if
- * you're using the Cosmopolitan mono-repo.
+ * sed, tr, and usleep.
  *
  * If you just have a program name and arguments, and you don't need the
  * full power of a UNIX-like shell, then consider using the Cosmopolitan
diff --git a/libc/proc/systemvpe.c b/libc/system/systemvpe.c
similarity index 97%
rename from libc/proc/systemvpe.c
rename to libc/system/systemvpe.c
index e44ed8d66..1165d45c3 100644
--- a/libc/proc/systemvpe.c
+++ b/libc/system/systemvpe.c
@@ -52,9 +52,8 @@ int systemvpe(const char *prog, char *const argv[], char *const envp[]) {
   int pid, wstatus;
   char pathbuf[PATH_MAX + 1];
   sigset_t chldmask, savemask;
-  if (!(exe = commandv(prog, pathbuf, sizeof(pathbuf)))) {
+  if (!(exe = commandv(prog, pathbuf, sizeof(pathbuf))))
     return -1;
-  }
   sigemptyset(&chldmask);
   sigaddset(&chldmask, SIGINT);
   sigaddset(&chldmask, SIGQUIT);
@@ -62,7 +61,7 @@ int systemvpe(const char *prog, char *const argv[], char *const envp[]) {
   sigprocmask(SIG_BLOCK, &chldmask, &savemask);
   if (!(pid = vfork())) {
     sigprocmask(SIG_SETMASK, &savemask, 0);
-    execve(prog, argv, envp);
+    execve(exe, argv, envp);
     _Exit(127);
   } else if (pid == -1) {
     wstatus = -1;
diff --git a/libc/sysv/BUILD.mk b/libc/sysv/BUILD.mk
index ec1b3b1fb..19f328784 100644
--- a/libc/sysv/BUILD.mk
+++ b/libc/sysv/BUILD.mk
@@ -84,11 +84,12 @@ o/$(MODE)/libc/sysv/sysret.o: private			\
 		CFLAGS +=				\
 			-ffreestanding			\
 			-fno-stack-protector		\
-			-fno-sanitize=all
+			-fno-sanitize=all		\
+			-mgeneral-regs-only
 
 ifeq ($(ARCH),aarch64)
 o/$(MODE)/libc/sysv/sysv.o: private			\
-		CFLAGS +=				\
+		OVERRIDE_CFLAGS +=			\
 			-ffixed-x0			\
 			-ffixed-x1			\
 			-ffixed-x2			\
diff --git a/libc/sysv/calls/__sys_mremap.S b/libc/sysv/calls/__sys_mremap.S
deleted file mode 100644
index 97fc160d0..000000000
--- a/libc/sysv/calls/__sys_mremap.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/macros.internal.h"
-.scall __sys_mremap,0x19bffffffffff019,216,4095,4095,globl,hidden
diff --git a/libc/sysv/calls/getpagesize_freebsd.S b/libc/sysv/calls/getpagesize_freebsd.S
deleted file mode 100644
index 23eb9eae1..000000000
--- a/libc/sysv/calls/getpagesize_freebsd.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/macros.internal.h"
-.scall getpagesize_freebsd,0xffffff040fffffff,4095,4095,64,globl,hidden
diff --git a/libc/sysv/calls/sys_mremap.S b/libc/sysv/calls/sys_mremap.S
new file mode 100644
index 000000000..87e3e314c
--- /dev/null
+++ b/libc/sysv/calls/sys_mremap.S
@@ -0,0 +1,2 @@
+#include "libc/sysv/macros.internal.h"
+.scall sys_mremap,0x19bffffffffff019,216,4095,4095,globl,hidden
diff --git a/libc/sysv/consts.sh b/libc/sysv/consts.sh
index 233c11edc..353bfc464 100755
--- a/libc/sysv/consts.sh
+++ b/libc/sysv/consts.sh
@@ -223,7 +223,6 @@ syscon	mmap	MAP_TYPE				15			15			15			15			15			15			15			15			# mask for type
 syscon	mmap	MAP_FIXED				0x00000010		0x00000010		0x00000010		0x00000010		0x00000010		0x00000010		0x00000010		0x00000010		# unix consensus; openbsd appears to forbid; faked nt
 syscon	mmap	MAP_FIXED_NOREPLACE			0x08000000		0x08000000		0x00004000		0x00004000		0x08000000		0x08000000		0x08000000		0x08000000     		# handled and defined by cosmo runtime; 0x100000 on linux 4.7+; MAP_FIXED|MAP_EXCL on FreeBSD
 syscon	mmap	MAP_ANONYMOUS				0x00000020		0x00000020		0x00001000		0x00001000		0x00001000		0x00001000		0x00001000		0x00000020		# bsd consensus; faked nt
-syscon	mmap	MAP_GROWSDOWN				0x00000100		0x00000100		0			0			0			0			0			0			# use MAP_STACK; abstracted by MAP_STACK; may be passed to __sys_mmap() for low-level Linux fiddling
 syscon	mmap	MAP_LOCKED				0x00002000		0x00002000		0			0			0			0			0			0
 syscon	mmap	MAP_NORESERVE				0x00004000		0x00004000		0x00000040		0x00000040		0			0			0x00000040		0			# Linux calls it "reserve"; NT calls it "commit"? which is default?
 syscon	mmap	MAP_POPULATE				0x00008000		0x00008000		0			0			0x00040000		0			0			0			# MAP_PREFAULT_READ on FreeBSD; can avoid madvise(MADV_WILLNEED) on private file mapping
@@ -292,13 +291,7 @@ syscon	mprot	PROT_NONE				0			0			0			0			0			0			0			0			# mmap, mprotect, unix
 syscon	mprot	PROT_READ				1			1			1			1			1			1			1			1			# mmap, mprotect, unix consensus
 syscon	mprot	PROT_WRITE				2			2			2			2			2			2			2			2			# mmap, mprotect, unix consensus
 syscon	mprot	PROT_EXEC				4			4			4			4			4			4			4			4			# mmap, mprotect, unix consensus
-
-#	mremap() flags
-#	the revolutionary praxis of realloc()
-#
-#	group	name					GNU/Systemd		GNU/Systemd (Aarch64)	XNU's Not UNIX!		MacOS (Arm64)		FreeBSD			OpenBSD			NetBSD			The New Technology	Commentary
-syscon	mremap	MREMAP_MAYMOVE				1			1			1			1			1			1			1			1			# faked non-linux (b/c linux only)
-syscon	mremap	MREMAP_FIXED				2			2			2			2			2			2			2			2			# faked non-linux (b/c linux only)
+syscon	mprot	PROT_GUARD				0			0			0			0			0			0			0			0x100			# mmap, mprotect, unix consensus
 
 #	sigprocmask() flags
 #
@@ -471,7 +464,7 @@ syscon	rlimit	RLIMIT_RSS				5			5			5			5			5			5			5			127			# max physical mem
 syscon	rlimit	RLIMIT_NPROC				6			6			7			7			7			7			7			127			# max number of processes; see fork()→EAGAIN; bsd consensus
 syscon	rlimit	RLIMIT_NOFILE				7			7			8			8			8			8			8			127			# max number of open files; see accept()→EMFILE/ENFILE; bsd consensus
 syscon	rlimit	RLIMIT_MEMLOCK				8			8			6			6			6			6			6			127			# max locked-in-memory address space; bsd consensus
-syscon	rlimit	RLIMIT_AS				9\			9			5			5			10			2			10			0			# max virtual memory size in bytes; this one actually works; fudged as RLIMIT_DATA on OpenBSD
+syscon	rlimit	RLIMIT_AS				9			9			5			5			10			2			10			0			# max virtual memory size in bytes; this one actually works; fudged as RLIMIT_DATA on OpenBSD
 syscon	rlimit	RLIMIT_LOCKS				10			10			127			127			127			127			127			127			# max flock() / fcntl() locks; bsd consensus
 syscon	rlimit	RLIMIT_SIGPENDING			11			11			127			127			127			127			127			127			# max sigqueue() can enqueue; bsd consensus
 syscon	rlimit	RLIMIT_MSGQUEUE				12			12			127			127			127			127			127			127			# meh posix message queues; bsd consensus
@@ -577,27 +570,60 @@ syscon	close	CLOSE_RANGE_CLOEXEC			4			4			-1			-1			-1			-1			-1			-1			#
 
 #	clock_{gettime,settime} timers
 #
+#	Executive Summary
+#	- CLOCK_MONOTONIC shouldn't count suspended time
+#	- CLOCK_BOOTTIME is monotonic and should count suspended time
+#	- Only CLOCK_REALTIME and CLOCK_MONOTONIC can be used with futexes
+#	- CLOCK_MONOTONIC_RAW should fail with EINVAL if host lacks support
+#	- CLOCK_MONOTONIC and CLOCK_BOOTTIME should be relative to system boot time
+#	- COARSE can be CLK_TCK behind (~20ms) and will EINVAL on RHEL5 which isn't worth polyfilling
+#
+#	FreeBSD defines the following rosetta stone
+#	Taken from freebsd/sys/compat/linux/linux_time.c
+#	- Linux CLOCK_MONOTONIC        -> FreeBSD CLOCK_UPTIME [5]
+#	- Linux CLOCK_MONOTONIC_RAW    -> FreeBSD CLOCK_UPTIME_FAST [8]
+#	- Linux CLOCK_REALTIME_COARSE  -> FreeBSD CLOCK_REALTIME_FAST [10]
+#	- Linux CLOCK_MONOTONIC_COARSE -> FreeBSD CLOCK_UPTIME_FAST [8]
+#	- Linux CLOCK_BOOTTIME         -> FreeBSD CLOCK_MONOTONIC [4]
+#
+#	For MacOS we define the following mappings
+#	- Linux CLOCK_MONOTONIC        -> MacOS CLOCK_UPTIME_RAW [8]
+#	- Linux CLOCK_MONOTONIC_RAW    -> MacOS CLOCK_UPTIME_RAW [8]
+#	- Linux CLOCK_REALTIME_COARSE  -> MacOS CLOCK_REALTIME [0]
+#	- Linux CLOCK_MONOTONIC_COARSE -> MacOS CLOCK_UPTIME_RAW_APPROX [9]
+#	- Linux CLOCK_BOOTTIME         -> MacOS CLOCK_MONOTONIC [6]
+#
+#	For OpenBSD we define the following mappings
+#	- Linux CLOCK_MONOTONIC        -> OpenBSD CLOCK_UPTIME [5]
+#	- Linux CLOCK_MONOTONIC_RAW    -> EINVAL because OpenBSD ntpd can adjfreq(2)
+#	- Linux CLOCK_REALTIME_COARSE  -> OpenBSD CLOCK_REALTIME [0]
+#	- Linux CLOCK_MONOTONIC_COARSE -> OpenBSD CLOCK_UPTIME [5]
+#	- Linux CLOCK_BOOTTIME         -> OpenBSD CLOCK_MONOTONIC [3]
+#
+#	For NetBSD we define the following mappings
+#	- Linux CLOCK_MONOTONIC        -> NetBSD CLOCK_MONOTONIC [3] TODO: suspend?
+#	- Linux CLOCK_MONOTONIC_RAW    -> NetBSD CLOCK_MONOTONIC [3] NetBSD clock_gettime(2) says it isn't impacted by adjfreq(2)
+#	- Linux CLOCK_REALTIME_COARSE  -> NetBSD CLOCK_REALTIME [0]
+#	- Linux CLOCK_MONOTONIC_COARSE -> NetBSD CLOCK_MONOTONIC [3]
+#	- Linux CLOCK_BOOTTIME         -> NetBSD CLOCK_MONOTONIC [3] TODO: suspend?
+#
+#	For Windows we define the following mappings
+#	- Linux CLOCK_REALTIME         -> GetSystemTimePreciseAsFileTime()
+#	- Linux CLOCK_MONOTONIC        -> QueryUnbiasedInterruptTimePrecise()
+#	- Linux CLOCK_MONOTONIC_RAW    -> QueryUnbiasedInterruptTimePrecise()
+#	- Linux CLOCK_REALTIME_COARSE  -> GetSystemTimeAsFileTime()
+#	- Linux CLOCK_MONOTONIC_COARSE -> QueryUnbiasedInterruptTime()
+#	- Linux CLOCK_BOOTTIME         -> QueryInterruptTimePrecise()
+#
 #	group	name					GNU/Systemd		GNU/Systemd (Aarch64)	XNU's Not UNIX!		MacOS (Arm64)		FreeBSD			OpenBSD			NetBSD			The New Technology	Commentary
-syscon	clock	CLOCK_REALTIME				0			0			0			0			0			0			0			0			# consensus
-syscon	clock	CLOCK_REALTIME_PRECISE			0			0			0			0			9			0			0			0			#
-syscon	clock	CLOCK_REALTIME_FAST			0			0			0			0			10			0			0			0			#
-syscon	clock	CLOCK_REALTIME_COARSE			5			5			0			0			10			0			0			2			# Linux 2.6.32+; bsd consensus; not available on RHEL5
-syscon	clock	CLOCK_MONOTONIC				1			1			6			6			4			3			3			1			# XNU/NT faked; could move backwards if NTP introduces negative leap second
-syscon	clock	CLOCK_MONOTONIC_PRECISE			1			1			6			6			11			3			3			1			#
-syscon	clock	CLOCK_MONOTONIC_FAST			1			1			6			6			12			3			3			1			#
-syscon	clock	CLOCK_MONOTONIC_COARSE			6			6			5			5			12			3			3			1			# Linux 2.6.32+; bsd consensus; not available on RHEL5
-syscon	clock	CLOCK_MONOTONIC_RAW			4			4			4			4			127			127			127			127			# actually monotonic; not subject to NTP adjustments; Linux 2.6.28+; XNU/NT/FreeBSD/OpenBSD faked; not available on RHEL5
-syscon	clock	CLOCK_PROCESS_CPUTIME_ID		2			2			12			12			15			2			0x40000000		4			# NetBSD lets you bitwise a PID into clockid_t
+syscon	clock	CLOCK_REALTIME				0			0			0			0			0			0			0			0			#
+syscon	clock	CLOCK_MONOTONIC				1			1			8			8			5			5			3			1			#
+syscon	clock	CLOCK_PROCESS_CPUTIME_ID		2			2			12			12			15			2			0x40000000		4			#
 syscon	clock	CLOCK_THREAD_CPUTIME_ID			3			3			16			16			14			4			0x20000000		5			#
-syscon	clock	CLOCK_PROF				127			127			127			127			2			127			2			127			#
-syscon	clock	CLOCK_BOOTTIME				7			7			7			127			127			6			127			3			#
-syscon	clock	CLOCK_REALTIME_ALARM			8			8			127			127			127			127			127			127			#
-syscon	clock	CLOCK_BOOTTIME_ALARM			9			9			127			127			127			127			127			127			#
-syscon	clock	CLOCK_TAI				11			11			127			127			127			127			127			127			#
-syscon	clock	CLOCK_UPTIME				127			127			8			8			5			5			127			127			#
-syscon	clock	CLOCK_UPTIME_PRECISE			127			127			127			127			7			127			127			127			#
-syscon	clock	CLOCK_UPTIME_FAST			127			127			127			127			8			127			127			127			#
-syscon	clock	CLOCK_SECOND				127			127			127			127			13			127			127			127			#
+syscon	clock	CLOCK_MONOTONIC_RAW			4			4			127			8			8			127			3			1			# Linux 2.6.28+
+syscon	clock	CLOCK_REALTIME_COARSE			5			5			0			0			10			0			0			2			# Linux 2.6.32+
+syscon	clock	CLOCK_MONOTONIC_COARSE			6			6			9			9			8			5			3			6			# Linux 2.6.32+
+syscon	clock	CLOCK_BOOTTIME				7			7			6			6			4			3			3			3			# Linux 2.6.39+
 
 #	poll()
 #
@@ -624,14 +650,14 @@ syscon	so	SO_DEBUG				1			1			1			1			1			1			1			1			# debugging is enabled; co
 syscon	so	SO_TYPE					3			3			0x1008			0x1008			0x1008			0x1008			0x1008			0x1008			# bsd consensus
 syscon	so	SO_ERROR				4			4			0x1007			0x1007			0x1007			0x1007			0x1007			0x1007			# takes int pointer and stores/clears the pending error code; bsd consensus
 syscon	so	SO_ACCEPTCONN				30			30			2			2			2			2			2			2			# takes int pointer and stores boolean indicating if listen() was called on fd; bsd consensus
-syscon	so	SO_REUSEPORT				15			15			0x0200			0x0200			0x0200			0x0200			0x0200			0			# bsd consensus; no windows support
+syscon	so	SO_REUSEPORT				15			15			512			512			512			512			512			0			# bsd consensus; no windows support
 syscon	so	SO_REUSEADDR				2			2			4			4			4			4			4			-5			# SO_EXCLUSIVEADDRUSE on Windows (see third_party/python/Lib/test/support/__init__.py)
 syscon	so	SO_KEEPALIVE				9			9			8			8			8			8			8			8			# bsd consensus
-syscon	so	SO_DONTROUTE				5			5			0x10			0x10			0x10			0x10			0x10			0x10			# bsd consensus
-syscon	so	SO_BROADCAST				6			6			0x20			0x20			0x20			0x20			0x20			0x20			# socket is configured for broadcast messages; bsd consensus
-syscon	so	SO_USELOOPBACK				0			0			0x40			0x40			0x40			0x40			0x40			0x40			# bsd consensus
-syscon	so	SO_LINGER				13			13			0x1080			0x1080			0x80			0x80			0x80			0x80			# takes struct linger; causes close() return value to actually mean something; SO_LINGER_SEC on XNU; bsd consensus
-syscon	so	SO_OOBINLINE				10			10			0x0100			0x0100			0x0100			0x0100			0x0100			0x0100			# bsd consensus
+syscon	so	SO_DONTROUTE				5			5			16			16			16			16			16			16			# bsd consensus
+syscon	so	SO_BROADCAST				6			6			32			32			32			32			32			32			# socket is configured for broadcast messages; bsd consensus
+syscon	so	SO_USELOOPBACK				0			0			64			64			64			64			64			64			# bsd consensus
+syscon	so	SO_LINGER				13			13			4224			4224			128			128			128			128			# takes struct linger; causes close() return value to actually mean something; SO_LINGER_SEC on XNU; bsd consensus
+syscon	so	SO_OOBINLINE				10			10			256			256			256			256			256			256			# bsd consensus
 syscon	so	SO_SNDBUF				7			7			0x1001			0x1001			0x1001			0x1001			0x1001			0x1001			# bsd consensus
 syscon	so	SO_RCVBUF				8			8			0x1002			0x1002			0x1002			0x1002			0x1002			0x1002			# bsd consensus
 syscon	so	SO_RCVTIMEO				20			20			0x1006			0x1006			0x1006			0x1006			0x100c			0x1006			# recv timeout; takes struct timeval (overrides SA_RESTART restoring EINTR behavior on recv/send/connect/accept/etc.; bsd consensus)
@@ -651,18 +677,18 @@ syscon	tcp	TCP_CORK				3			3			4			4			4			16			4			0			# nagle's algorithm stri
 syscon	tcp	TCP_MAXSEG				2			2			2			2			2			2			2			0			# reduces tcp segment size; see also tcp offloading
 syscon	tcp	TCP_FASTOPEN				23			23			0x105			0x105			0x0401			0			0			15			# reduces roundtrips; for listener; Linux 3.7+ (c. 2012) / or is windows it 0x22? /proc/sys/net/ipv4/tcp_fastopen TODO(jart): MSG_FASTOPEN; XNU sources say 261 but not sure if that's true
 syscon	tcp	TCP_FASTOPEN_CONNECT			30			30			0			0			0			0			0			0			# reduces roundtrips; for listener; Linux 3.7+ (c. 2012) / or is windows it 0x22? /proc/sys/net/ipv4/tcp_fastopen TODO(jart): MSG_FASTOPEN; XNU sources say 261 but not sure if that's true
-syscon	tcp	TCP_KEEPIDLE				4			4			0			0			0x100			0			3			0			# start keepalives after this period
-syscon	tcp	TCP_KEEPINTVL				5			5			0x101			0x101			0x200			0			5			0			# interval between keepalives
-syscon	tcp	TCP_KEEPCNT				6			6			0x102			0x102			0x400			0			6			0			# number of keepalives before death
+syscon	tcp	TCP_KEEPIDLE				4			4			0			0			0x100			0			3			3			# start keepalives after this period
+syscon	tcp	TCP_KEEPINTVL				5			5			0x101			0x101			0x200			0			5			17			# interval between keepalives
+syscon	tcp	TCP_KEEPCNT				6			6			0x102			0x102			0x400			0			6			16			# number of keepalives before death
+syscon	tcp	TCP_INFO				11			11			0x200			0x200			32			9			9			0			# get connection info
+syscon	tcp	TCP_NOTSENT_LOWAT			25			25			513			513			0			0			0			0			# limit unset byte queue
+syscon	tcp	TCP_MD5SIG				14			14			0			0			16			4			16			0			# what is it (rfc2385)
+syscon	tcp	TCP_CONGESTION				13			13			0			0			64			0			0			0			# set traffic control
 syscon	tcp	TCP_SYNCNT				7			7			0			0			0			0			0			0			# how hard to syn packet the enemy
 syscon	tcp	TCP_ULP					31			31			0			0			0			0			0			0			# setsockopt(sock, IPPROTO_TCP, TCP_ULP, "tls", 4)
 syscon	tcp	TCP_COOKIE_TRANSACTIONS			15			15			0			0			0			0			0			0			# defense against the syn packets
 syscon	tcp	TCP_LINGER2				8			8			0			0			0			0			0			0			# orphaned fin-wait-2 lifetime cf. net.ipv4.tcp_fin_timeout see cloudflare blog
-syscon	tcp	TCP_NOTSENT_LOWAT			25			25			513			513			0			0			0			0			# limit unset byte queue
-syscon	tcp	TCP_INFO				11			11			0			0			0x20			0			9			0			# get connection info
 syscon	tcp	TCP_CC_INFO				26			26			0			0			0			0			0			0			# get congestion control info
-syscon	tcp	TCP_CONGESTION				13			13			0			0			0x40			0			0			0			# set traffic control
-syscon	tcp	TCP_MD5SIG				14			14			0			0			0x10			4			16			0			# what is it (rfc2385)
 syscon	tcp	TCP_MD5SIG_MAXKEYLEN			80			80			0			0			0			0			0			0			# what is it
 syscon	tcp	TCP_TIMESTAMP				24			24			0			0			0			0			0			0			# what is it
 syscon	tcp	TCP_USER_TIMEOUT			18			18			0			0			0			0			0			0			# what is it
@@ -678,6 +704,79 @@ syscon	tcp	TCP_REPAIR_OPTIONS			22			22			0			0			0			0			0			0			# what is it
 syscon	tcp	TCP_REPAIR_QUEUE			20			20			0			0			0			0			0			0			# what is it
 syscon	tcp	TCP_THIN_LINEAR_TIMEOUTS		16			16			0			0			0			0			0			0			# what is it
 
+#	IPPROTO_IP (or SOL_IP) socket options
+#
+#	group	name					GNU/Systemd		GNU/Systemd (Aarch64)	XNU's Not UNIX!		MacOS (Arm64)		FreeBSD			OpenBSD			NetBSD			The New Technology	Commentary
+syscon	ip	IP_TOS					1			1			3			3			3			3			3			3			# bsd consensus
+syscon	ip	IP_TTL					2			2			4			4			4			4			4			4			# bsd consensus
+syscon	ip	IP_MTU					14			14			0			0			0			0			0			73			# bsd consensus
+syscon	ip	IP_HDRINCL				3			3			2			2			2			2			2			2			# bsd consensus
+syscon	ip	IP_OPTIONS				4			4			1			1			1			1			1			1			# bsd consensus
+syscon	ip	IP_RECVTTL				12			12			24			24			65			31			23			21
+syscon	ip	IP_ADD_MEMBERSHIP			35			35			12			12			12			12			12			12			# bsd consensus
+syscon	ip	IP_DROP_MEMBERSHIP			36			36			13			13			13			13			13			13			# bsd consensus
+syscon	ip	IP_MULTICAST_IF				32			32			9			9			9			9			9			9			# bsd consensus
+syscon	ip	IP_MULTICAST_LOOP			34			34			11			11			11			11			11			11			# bsd consensus
+syscon	ip	IP_MULTICAST_TTL			33			33			10			10			10			10			10			10			# bsd consensus
+syscon	ip	IP_PKTINFO				8			8			26			26			0			0			25			19
+syscon	ip	IP_RECVTOS				13			13			0			0			68			0			0			40
+
+#	IPPROTO_IPV6 (or SOL_IPV6) socket options
+#
+#	group	name					GNU/Systemd		GNU/Systemd (Aarch64)	XNU's Not UNIX!		MacOS (Arm64)		FreeBSD			OpenBSD			NetBSD			The New Technology	Commentary
+syscon	ipv6	IPV6_V6ONLY				26			26			27			27			27			27			27			27			# bsd consensus
+syscon	ipv6	IPV6_CHECKSUM				7			7			26			26			26			26			26			26			# bsd consensus
+syscon	ipv6	IPV6_JOIN_GROUP				20			20			12			12			12			12			12			12			# bsd consensus
+syscon	ipv6	IPV6_LEAVE_GROUP			21			21			13			13			13			13			13			13			# bsd consensus
+syscon	ipv6	IPV6_MULTICAST_HOPS			18			18			10			10			10			10			10			10			# bsd consensus
+syscon	ipv6	IPV6_MULTICAST_IF			17			17			9			9			9			9			9			9			# bsd consensus
+syscon	ipv6	IPV6_MULTICAST_LOOP			19			19			11			11			11			11			11			11			# bsd consensus
+syscon	ipv6	IPV6_UNICAST_HOPS			16			16			4			4			4			4			4			4			# bsd consensus
+syscon	ipv6	IPV6_RECVTCLASS				66			66			35			35			57			57			57			40
+syscon	ipv6	IPV6_TCLASS				67			67			36			36			61			61			61			39
+syscon	ipv6	IPV6_DONTFRAG				62			62			0			0			62			62			62			14
+syscon	ipv6	IPV6_HOPLIMIT				52			52			0			0			47			47			47			21
+syscon	ipv6	IPV6_HOPOPTS				54			54			0			0			49			49			49			1
+syscon	ipv6	IPV6_PKTINFO				50			50			0			0			46			46			46			19
+syscon	ipv6	IPV6_RECVRTHDR				56			56			0			0			38			38			38			38
+syscon	ipv6	IPV6_RTHDR				57			57			0			0			51			51			51			32
+
+#	IPPROTO_ICMPV6 (or SOL_ICMPV6) socket options
+#
+#	group	name					GNU/Systemd		GNU/Systemd (Aarch64)	XNU's Not UNIX!		MacOS (Arm64)		FreeBSD			OpenBSD			NetBSD			The New Technology	Commentary
+syscon	icmp6	ICMP6_DST_UNREACH_NOROUTE		0			0			0			0			0			0			0			0			# consensus
+syscon	icmp6	ICMP6_PARAMPROB_HEADER			0			0			0			0			0			0			0			0			# consensus
+syscon	icmp6	ICMP6_TIME_EXCEED_TRANSIT		0			0			0			0			0			0			0			0			# consensus
+syscon	icmp6	ICMP6_DST_UNREACH_ADMIN			1			1			1			1			1			1			1			1			# consensus
+syscon	icmp6	ICMP6_PARAMPROB_NEXTHEADER		1			1			1			1			1			1			1			1			# consensus
+syscon	icmp6	ICMP6_TIME_EXCEED_REASSEMBLY		1			1			1			1			1			1			1			1			# consensus
+syscon	icmp6	ICMP6_DST_UNREACH			1			1			1			1			1			1			1			0			# unix consensus
+syscon	icmp6	ICMP6_FILTER				1			1			18			18			18			18			18			0			# bsd consensus
+syscon	icmp6	ICMP6_DST_UNREACH_BEYONDSCOPE		2			2			2			2			2			2			2			2			# consensus
+syscon	icmp6	ICMP6_PARAMPROB_OPTION			2			2			2			2			2			2			2			2			# consensus
+syscon	icmp6	ICMP6_PACKET_TOO_BIG			2			2			2			2			2			2			2			0			# unix consensus
+syscon	icmp6	ICMP6_DST_UNREACH_ADDR			3			3			3			3			3			3			3			3			# consensus
+syscon	icmp6	ICMP6_TIME_EXCEEDED			3			3			3			3			3			3			3			0			# unix consensus
+syscon	icmp6	ICMP6_DST_UNREACH_NOPORT		4			4			4			4			4			4			4			4			# consensus
+syscon	icmp6	ICMP6_PARAM_PROB			4			4			4			4			4			4			4			0			# unix consensus
+syscon	icmp6	ICMP6_RR_FLAGS_PREVDONE			8			8			8			8			8			8			8			0			# unix consensus
+syscon	icmp6	ICMP6_RR_FLAGS_SPECSITE			0x10			0x10			0x10			0x10			0x10			0x10			0x10			0			# unix consensus
+syscon	icmp6	ICMP6_RR_PCOUSE_RAFLAGS_AUTO		0x10			0x10			0x40			0x40			0x40			0x40			0x40			0			# bsd consensus
+syscon	icmp6	ICMP6_RR_FLAGS_FORCEAPPLY		0x20			0x20			0x20			0x20			0x20			0x20			0x20			0			# unix consensus
+syscon	icmp6	ICMP6_RR_PCOUSE_RAFLAGS_ONLINK		0x20			0x20			0x80			0x80			0x80			0x80			0x80			0			# bsd consensus
+syscon	icmp6	ICMP6_RR_FLAGS_REQRESULT		0x40			0x40			0x40			0x40			0x40			0x40			0x40			0			# unix consensus
+syscon	icmp6	ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME	0x40			0x40			0x40			0x40			0x40			0x40			0x40			0			# unix consensus
+syscon	icmp6	ICMP6_INFOMSG_MASK			0x80			0x80			0x80			0x80			0x80			0x80			0x80			0x80			# consensus
+syscon	icmp6	ICMP6_ECHO_REQUEST			0x80			0x80			0x80			0x80			0x80			0x80			0x80			0			# unix consensus
+syscon	icmp6	ICMP6_RR_FLAGS_TEST			0x80			0x80			0x80			0x80			0x80			0x80			0x80			0			# unix consensus
+syscon	icmp6	ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME	0x80			0x80			0x80			0x80			0x80			0x80			0x80			0			# unix consensus
+syscon	icmp6	ICMP6_ECHO_REPLY			129			129			129			129			129			129			129			0			# unix consensus
+syscon	icmp6	ICMP6_ROUTER_RENUMBERING		138			138			138			138			138			138			138			0			# unix consensus
+syscon	icmp6	ICMP6_RR_RESULT_FLAGS_FORBIDDEN		0x0100			0x0100			0x0100			0x0100			0x0100			0x0100			0x0100			0			# unix consensus
+syscon	icmp6	ICMP6_RR_RESULT_FLAGS_OOB		0x0200			0x0200			0x0200			0x0200			0x0200			0x0200			0x0200			0			# unix consensus
+
+syscon	ipport	IPPORT_USERRESERVED			5000			5000			5000			5000			5000			49151			5000			5000
+
 #	https://blog.cloudflare.com/know-your-scm_rights/
 #
 #	group	name					GNU/Systemd		GNU/Systemd (Aarch64)	XNU's Not UNIX!		MacOS (Arm64)		FreeBSD			OpenBSD			NetBSD			The New Technology	Commentary
@@ -688,60 +787,6 @@ syscon	scm	SCM_TIMESTAMPING			37			37			0			0			0			0			0			0
 syscon	scm	SCM_TIMESTAMPNS				35			35			0			0			0			0			0			0
 syscon	scm	SCM_WIFI_STATUS				41			41			0			0			0			0			0			0
 
-#	group	name					GNU/Systemd		GNU/Systemd (Aarch64)	XNU's Not UNIX!		MacOS (Arm64)		FreeBSD			OpenBSD			NetBSD			The New Technology	Commentary
-syscon	ip	IP_TOS					1			1			3			3			3			3			3			3			# bsd consensus
-syscon	ip	IP_TTL					2			2			4			4			4			4			4			4			# bsd consensus
-syscon	ip	IP_HDRINCL				3			3			2			2			2			2			2			2			# bsd consensus
-syscon	ip	IP_DEFAULT_MULTICAST_LOOP		1			1			1			1			1			1			1			1			# consensus
-syscon	ip	IP_DEFAULT_MULTICAST_TTL		1			1			1			1			1			1			1			1			# consensus
-syscon	ip	IP_PMTUDISC_DONT			0			0			0			0			0			0			0			0			# consensus
-syscon	ip	IP_MAX_MEMBERSHIPS			20			20			0x0fff			0x0fff			0x0fff			0x0fff			0x0fff			20			# bsd consensus
-syscon	ip	IP_OPTIONS				4			4			1			1			1			1			1			1			# bsd consensus
-syscon	ip	IP_RECVTTL				12			12			24			24			65			31			23			21
-syscon	ip	IP_ADD_MEMBERSHIP			35			35			12			12			12			12			12			12			# bsd consensus
-syscon	ip	IP_DROP_MEMBERSHIP			36			36			13			13			13			13			13			13			# bsd consensus
-syscon	ip	IP_MULTICAST_IF				0x20			0x20			9			9			9			9			9			9			# bsd consensus
-syscon	ip	IP_MULTICAST_LOOP			34			34			11			11			11			11			11			11			# bsd consensus
-syscon	ip	IP_MULTICAST_TTL			33			33			10			10			10			10			10			10			# bsd consensus
-syscon	ip	IP_RECVOPTS				6			6			5			5			5			5			5			0			# bsd consensus
-syscon	ip	IP_RECVRETOPTS				7			7			6			6			6			6			6			0			# bsd consensus
-syscon	ip	IP_RECVDSTADDR				0			0			7			7			7			7			7			0			# bsd consensus
-syscon	ip	IP_RETOPTS				7			7			8			8			8			8			8			0			# bsd consensus
-syscon	ip	IP_ADD_SOURCE_MEMBERSHIP		39			39			70			70			70			0			0			15
-syscon	ip	IP_BLOCK_SOURCE				38			38			72			72			72			0			0			17
-syscon	ip	IP_DROP_SOURCE_MEMBERSHIP		40			40			71			71			71			0			0			16
-syscon	ip	IP_UNBLOCK_SOURCE			37			37			73			73			73			0			0			18
-syscon	ip	IP_IPSEC_POLICY				0x10			0x10			21			21			21			0			0			0
-syscon	ip	IP_MINTTL				21			21			0			0			66			32			24			0			# minimum ttl for packet or drop
-syscon	ip	IP_MSFILTER				41			41			74			74			74			0			0			0
-syscon	ip	IP_PKTINFO				8			8			26			26			0			0			25			19
-syscon	ip	IP_RECVTOS				13			13			0			0			68			0			0			40
-syscon	ip	IP_MTU					14			14			0			0			0			0			0			73			# bsd consensus
-syscon	ip	IP_MTU_DISCOVER				10			10			0			0			0			0			0			71			# bsd consensus
-syscon	ip	IP_RECVERR				11			11			0			0			0			0			0			75			# bsd consensus
-syscon	ip	IP_UNICAST_IF				50			50			0			0			0			0			0			31			# bsd consensus
-syscon	ip	IP_ORIGDSTADDR				20			20			0			0			27			0			0			0
-syscon	ip	IP_RECVORIGDSTADDR			20			20			0			0			27			0			0			0
-syscon	ip	IP_BIND_ADDRESS_NO_PORT			24			24			0			0			0			0			0			0
-syscon	ip	IP_CHECKSUM				23			23			0			0			0			0			0			0
-syscon	ip	IP_FREEBIND				15			15			0			0			0			0			0			0
-syscon	ip	IP_MULTICAST_ALL			49			49			0			0			0			0			0			0
-syscon	ip	IP_NODEFRAG				22			22			0			0			0			0			0			0
-syscon	ip	IP_PASSSEC				18			18			0			0			0			0			0			0
-syscon	ip	IP_PKTOPTIONS				9			9			0			0			0			0			0			0
-syscon	ip	IP_PMTUDISC				10			10			0			0			0			0			0			0
-syscon	ip	IP_PMTUDISC_DO				2			2			0			0			0			0			0			0
-syscon	ip	IP_PMTUDISC_INTERFACE			4			4			0			0			0			0			0			0
-syscon	ip	IP_PMTUDISC_OMIT			5			5			0			0			0			0			0			0
-syscon	ip	IP_PMTUDISC_PROBE			3			3			0			0			0			0			0			0
-syscon	ip	IP_PMTUDISC_WANT			1			1			0			0			0			0			0			0
-syscon	ip	IP_ROUTER_ALERT				5			5			0			0			0			0			0			0
-syscon	ip	IP_TRANSPARENT				19			19			0			0			0			0			0			0
-syscon	ip	IP_XFRM_POLICY				17			17			0			0			0			0			0			0
-syscon	ip	INET_ADDRSTRLEN				0x10			0x10			0x10			0x10			0x10			0x10			0x10			22			# unix consensus
-
-syscon	ipport	IPPORT_USERRESERVED			5000			5000			5000			5000			5000			49151			5000			5000
-
 #	ptrace() codes
 #
 #	group	name					GNU/Systemd		GNU/Systemd (Aarch64)	XNU's Not UNIX!		MacOS (Arm64)		FreeBSD			OpenBSD			NetBSD			The New Technology	Commentary
@@ -1058,8 +1103,8 @@ syscon	limits	_ARG_MAX				128*1024		128*1024		1024*1024		1024*1024		512*1024		51
 syscon	limits	_NAME_MAX				255			255			255			255			255			255			511			255			# probably higher on windows?
 syscon	limits	_PATH_MAX				4096			4096			1024			1024			1024			1024			1024			260			#
 syscon	limits	_NSIG					64			64			32			32			128			32			64			64			# _SIG_MAXSIG on FreeBSD
-syscon	limits	_MINSIGSTKSZ				2048			2048			32768			32768			4096			12288			8192			2048			#
-syscon	limits	_SIGSTKSZ				8192			2048			131072			131072			36864			28672			40960			8192			#
+syscon	limits	_MINSIGSTKSZ				2048			6144			8192			32768			6656			14336			8192			2048			# FreeBSD upscaled a bit for ARM
+syscon	limits	_SIGSTKSZ				10240			10240			131072			131072			36864			28672			40960			10240			#
 
 #	unmount() flags
 #	a.k.a. umount2() on linux
@@ -1092,32 +1137,12 @@ syscon	reboot	RB_NOSYNC				0x20000000		0x20000000		4			4			4			4			4			0x2000000
 syscon	msg	MSG_OOB					1			1			1			1			1			1			1			1			# consensus
 syscon	msg	MSG_PEEK				2			2			2			2			2			2			2			2			# consensus
 syscon	msg	MSG_DONTROUTE				4			4			4			4			4			4			4			4			# consensus
-syscon	msg	MSG_FASTOPEN				0x20000000		0x20000000		0			0			0			0			0			0			# TODO
-syscon	msg	MSG_WAITALL				0x0100			0x0100			0x40			0x40			0x40			0x40			0x40			8			# bsd consensus
-syscon	msg	MSG_MORE				0x8000			0x8000			0			0			0			0			0			0			# send/sendto: manual TCP_CORK hbasically
-syscon	msg	MSG_NOSIGNAL				0x4000			0x4000			0x80000			0x80000			0x020000		0x0400			0x0400			0			# send/sendto: don't SIGPIPE on EOF
 syscon	msg	MSG_DONTWAIT				0x40			0x40			0x80			0x80			0x80			0x80			0x80			0x40			# send/sendto: manual non-blocking
+syscon	msg	MSG_WAITALL				0x0100			0x0100			0x40			0x40			0x40			0x40			0x40			8			# bsd consensus
+syscon	msg	MSG_NOSIGNAL				0x4000			0x4000			0x80000			0x80000			0x020000		0x0400			0x0400			0x10000000		# send/sendto: don't raise sigpipe on local shutdown
 syscon	msg	MSG_TRUNC				0x20			0x20			0x10			0x10			0x10			0x10			0x10			0x0100			# bsd consensus
 syscon	msg	MSG_CTRUNC				8			8			0x20			0x20			0x20			0x20			0x20			0x0200			# bsd consensus
-syscon	msg	MSG_ERRQUEUE				0x2000			0x2000			0			0			0			0			0			0x1000			# bsd consensus
-syscon	msg	MSG_NOERROR				0x1000			0x1000			0x1000			0x1000			0x1000			0x1000			0x1000			0			# unix consensus
-syscon	msg	MSG_EOR					0x80			0x80			8			8			8			8			8			0			# bsd consensus
-syscon	msg	MSG_CMSG_CLOEXEC			0x40000000		0x40000000		0			0			0x040000		0x0800			0x0800			0
-syscon	msg	MSG_WAITFORONE				0x010000		0x010000		0			0			0x080000		0			0x2000			0
-syscon	msg	MSG_BATCH				0x040000		0x040000		0			0			0			0			0			0
-syscon	msg	MSG_CONFIRM				0x0800			0x0800			0			0			0			0			0			0
-syscon	msg	MSG_EXCEPT				0x2000			0x2000			0			0			0			0			0			0
-syscon	msg	MSG_FIN					0x0200			0x0200			0x0100			0x0100			0x0100			0			0			0
-syscon	msg	MSG_EOF					0x0200			0x0200			0x0100			0x0100			0x0100			0			0			0
-syscon	msg	MSG_INFO				12			12			0			0			0			0			0			0
-syscon	msg	MSG_PARITY_ERROR			9			9			0			0			0			0			0			0
-syscon	msg	MSG_PROXY				0x10			0x10			0			0			0			0			0			0
-syscon	msg	MSG_RST					0x1000			0x1000			0			0			0			0			0			0
-syscon	msg	MSG_STAT				11			11			0			0			0			0			0			0
-syscon	msg	MSG_SYN					0x0400			0x0400			0			0			0			0			0			0
-syscon	msg	MSG_BCAST				0			0			0			0			0			0x100			0x100			0
-syscon	msg	MSG_MCAST				0			0			0			0			0			0x200			0x200			0
-syscon	msg	MSG_NOTIFICATION			0x8000			0x8000			0			0			0x2000			0			0x4000			0
+syscon	msg	MSG_FASTOPEN				0x20000000		0x20000000		-1			-1			-1			-1			-1			-1			#
 
 #	getpriority() / setpriority() magnums (a.k.a. nice)
 #
@@ -1389,16 +1414,6 @@ syscon	shm	SHM_NORESERVE				0x1000			0x1000			0			0			0			0			0			0
 syscon	shm	SHM_REMAP				0x4000			0x4000			0			0			0			0			0			0
 syscon	shm	SHM_ANON				0			0			0			0			1			0			0			0
 
-syscon	lock	LOCK_UNLOCK_CACHE			54			54			0			0			0			0			0			0			# wut
-
-syscon	misc	IP6F_MORE_FRAG				0x0100			0x0100			0x0100			0x0100			0x0100			0x0100			0x0100			0x0100			# consensus
-syscon	misc	IP6F_OFF_MASK				0xf8ff			0xf8ff			0xf8ff			0xf8ff			0xf8ff			0xf8ff			0xf8ff			0xf8ff			# consensus
-syscon	misc	IP6F_RESERVED_MASK			0x0600			0x0600			0x0600			0x0600			0x0600			0x0600			0x0600			0x0600			# consensus
-
-syscon	misc	L_SET					0			0			0			0			0			0			0			0			# consensus
-syscon	misc	L_INCR					1			1			1			1			1			1			1			0			# unix consensus
-syscon	misc	L_XTND					2			2			2			2			2			2			2			0			# unix consensus
-
 syscon	misc	SHUT_RD					0			0			0			0			0			0			0			0			# consensus (SD_RECEIVE)
 syscon	misc	SHUT_WR					1			1			1			1			1			1			1			1			# consensus (SD_SEND)
 syscon	misc	SHUT_RDWR				2			2			2			2			2			2			2			2			# consensus (SD_BOTH)
@@ -1444,11 +1459,6 @@ syscon	misc	ACCT_COMM				0x10			0x10			0			0			0			0			0			0
 syscon	misc	COMMAND_COMPLETE			0			0			0			0			0			0			0			0			# consensus
 syscon	misc	COMMAND_TERMINATED			17			17			0			0			0			0			0			0
 
-syscon	select	FD_SETSIZE				0x0400			0x0400			0x0400			0x0400			0x0400			0x0400			0x0400			0x0400			# forced consensus (0x40 on NT)
-
-syscon	misc	MATH_ERREXCEPT				2			2			2			2			2			2			2			0			# unix consensus
-syscon	misc	MATH_ERRNO				1			1			1			1			1			1			1			0			# unix consensus
-
 syscon	misc	MCAST_BLOCK_SOURCE			43			43			84			84			84			0			0			43
 syscon	misc	MCAST_JOIN_GROUP			42			42			80			80			80			0			0			41
 syscon	misc	MCAST_JOIN_SOURCE_GROUP			46			46			82			82			82			0			0			45
@@ -1917,180 +1927,8 @@ syscon	junkerr	EKEYREJECTED				129			129			-1			-1			-1			-1			-1			-1
 syscon	junkerr	ERFKILL					132			132			-1			-1			-1			-1			-1			-1
 syscon	junkerr	EHWPOISON				133			133			-1			-1			-1			-1			-1			-1
 
-#	arpanet fork combating human-induced exhaustion of our ipv4 address space
-#
-#	group	name					GNU/Systemd		GNU/Systemd (Aarch64)	XNU's Not UNIX!		MacOS (Arm64)		FreeBSD			OpenBSD			NetBSD			The New Technology	Commentary
-syscon	ipv6	IPV6_PMTUDISC_DONT			0			0			0			0			0			0			0			0			# consensus
-syscon	ipv6	IPV6_RTHDR_LOOSE			0			0			0			0			0			0			0			0			# consensus
-syscon	ipv6	IPV6_RTHDR_TYPE_0			0			0			0			0			0			0			0			0			# consensus
-syscon	ipv6	IPV6_CHECKSUM				7			7			26			26			26			26			26			26			# bsd consensus
-syscon	ipv6	IPV6_JOIN_GROUP				20			20			12			12			12			12			12			12			# bsd consensus
-syscon	ipv6	IPV6_LEAVE_GROUP			21			21			13			13			13			13			13			13			# bsd consensus
-syscon	ipv6	IPV6_MULTICAST_HOPS			18			18			10			10			10			10			10			10			# bsd consensus
-syscon	ipv6	IPV6_MULTICAST_IF			17			17			9			9			9			9			9			9			# bsd consensus
-syscon	ipv6	IPV6_MULTICAST_LOOP			19			19			11			11			11			11			11			11			# bsd consensus
-syscon	ipv6	IPV6_UNICAST_HOPS			0x10			0x10			4			4			4			4			4			4			# bsd consensus
-syscon	ipv6	IPV6_V6ONLY				26			26			27			27			27			27			27			27			# bsd consensus
-syscon	ipv6	IPV6_RECVTCLASS				66			66			35			35			57			57			57			40
-syscon	ipv6	IPV6_TCLASS				67			67			36			36			61			61			61			39
-syscon	ipv6	IPV6_DONTFRAG				62			62			0			0			62			62			62			14
-syscon	ipv6	IPV6_HOPLIMIT				52			52			0			0			47			47			47			21
-syscon	ipv6	IPV6_HOPOPTS				54			54			0			0			49			49			49			1
-syscon	ipv6	IPV6_PKTINFO				50			50			0			0			46			46			46			19
-syscon	ipv6	IPV6_RECVRTHDR				56			56			0			0			38			38			38			38
-syscon	ipv6	IPV6_RTHDR				57			57			0			0			51			51			51			0x20
-syscon	ipv6	IPV6_DSTOPTS				59			59			0			0			50			50			50			0
-syscon	ipv6	IPV6_IPSEC_POLICY			34			34			28			28			28			0			0			0
-syscon	ipv6	IPV6_NEXTHOP				9			9			0			0			48			48			48			0
-syscon	ipv6	IPV6_PATHMTU				61			61			0			0			44			44			44			0
-syscon	ipv6	IPV6_RECVDSTOPTS			58			58			0			0			40			40			40			0
-syscon	ipv6	IPV6_RECVHOPLIMIT			51			51			0			0			37			37			37			0
-syscon	ipv6	IPV6_RECVHOPOPTS			53			53			0			0			39			39			39			0
-syscon	ipv6	IPV6_RECVPATHMTU			60			60			0			0			43			43			43			0
-syscon	ipv6	IPV6_RECVPKTINFO			49			49			0			0			36			36			36			0
-syscon	ipv6	IPV6_RTHDRDSTOPTS			55			55			0			0			35			35			35			0
-syscon	ipv6	IPV6_RTHDR_STRICT			1			1			1			1			1			0			0			0
-syscon	ipv6	IPV6_ADD_MEMBERSHIP			20			20			0			0			0			0			0			12			# bsd consensus
-syscon	ipv6	IPV6_DROP_MEMBERSHIP			21			21			0			0			0			0			0			13			# bsd consensus
-syscon	ipv6	IPV6_HDRINCL				36			36			0			0			0			0			0			2			# bsd consensus
-syscon	ipv6	IPV6_MTU				24			24			0			0			0			0			0			72			# bsd consensus
-syscon	ipv6	IPV6_MTU_DISCOVER			23			23			0			0			0			0			0			71			# bsd consensus
-syscon	ipv6	IPV6_RECVERR				25			25			0			0			0			0			0			75			# bsd consensus
-syscon	ipv6	IPV6_2292DSTOPTS			4			4			23			23			0			0			0			0
-syscon	ipv6	IPV6_2292HOPLIMIT			8			8			20			20			0			0			0			0
-syscon	ipv6	IPV6_2292HOPOPTS			3			3			22			22			0			0			0			0
-syscon	ipv6	IPV6_2292PKTINFO			2			2			19			19			0			0			0			0
-syscon	ipv6	IPV6_2292PKTOPTIONS			6			6			25			25			0			0			0			0
-syscon	ipv6	IPV6_2292RTHDR				5			5			24			24			0			0			0			0
-syscon	ipv6	IPV6_AUTOFLOWLABEL			0			0			0			0			59			59			59			0
-syscon	ipv6	IPV6_ADDRFORM				1			1			0			0			0			0			0			0
-syscon	ipv6	IPV6_AUTHHDR				10			10			0			0			0			0			0			0
-syscon	ipv6	IPV6_JOIN_ANYCAST			27			27			0			0			0			0			0			0
-syscon	ipv6	IPV6_LEAVE_ANYCAST			28			28			0			0			0			0			0			0
-syscon	ipv6	IPV6_PMTUDISC_DO			2			2			0			0			0			0			0			0
-syscon	ipv6	IPV6_PMTUDISC_INTERFACE			4			4			0			0			0			0			0			0
-syscon	ipv6	IPV6_PMTUDISC_OMIT			5			5			0			0			0			0			0			0
-syscon	ipv6	IPV6_PMTUDISC_PROBE			3			3			0			0			0			0			0			0
-syscon	ipv6	IPV6_PMTUDISC_WANT			1			1			0			0			0			0			0			0
-syscon	ipv6	IPV6_ROUTER_ALERT			22			22			0			0			0			0			0			0
-syscon	ipv6	IPV6_RXDSTOPTS				59			59			0			0			0			0			0			0
-syscon	ipv6	IPV6_RXHOPOPTS				54			54			0			0			0			0			0			0
-syscon	ipv6	IPV6_XFRM_POLICY			35			35			0			0			0			0			0			0
-syscon	ipv6	IPV6_MINHOPCOUNT			0			0			0			0			0			65			65			0
-syscon	ipv6	IPV6_ORIGDSTADDR			0			0			0			0			72			0			0			0
-syscon	ipv6	IPV6_RECVORIGDSTADDR			0			0			0			0			72			0			0			0
-syscon	ipv6	INET6_ADDRSTRLEN			46			46			46			46			46			46			46			65			# unix consensus
-syscon	icmp6	ICMP6_DST_UNREACH_NOROUTE		0			0			0			0			0			0			0			0			# consensus
-syscon	icmp6	ICMP6_PARAMPROB_HEADER			0			0			0			0			0			0			0			0			# consensus
-syscon	icmp6	ICMP6_TIME_EXCEED_TRANSIT		0			0			0			0			0			0			0			0			# consensus
-syscon	icmp6	ICMP6_DST_UNREACH_ADMIN			1			1			1			1			1			1			1			1			# consensus
-syscon	icmp6	ICMP6_PARAMPROB_NEXTHEADER		1			1			1			1			1			1			1			1			# consensus
-syscon	icmp6	ICMP6_TIME_EXCEED_REASSEMBLY		1			1			1			1			1			1			1			1			# consensus
-syscon	icmp6	ICMP6_DST_UNREACH			1			1			1			1			1			1			1			0			# unix consensus
-syscon	icmp6	ICMP6_FILTER				1			1			18			18			18			18			18			0			# bsd consensus
-syscon	icmp6	ICMP6_DST_UNREACH_BEYONDSCOPE		2			2			2			2			2			2			2			2			# consensus
-syscon	icmp6	ICMP6_PARAMPROB_OPTION			2			2			2			2			2			2			2			2			# consensus
-syscon	icmp6	ICMP6_PACKET_TOO_BIG			2			2			2			2			2			2			2			0			# unix consensus
-syscon	icmp6	ICMP6_DST_UNREACH_ADDR			3			3			3			3			3			3			3			3			# consensus
-syscon	icmp6	ICMP6_TIME_EXCEEDED			3			3			3			3			3			3			3			0			# unix consensus
-syscon	icmp6	ICMP6_DST_UNREACH_NOPORT		4			4			4			4			4			4			4			4			# consensus
-syscon	icmp6	ICMP6_PARAM_PROB			4			4			4			4			4			4			4			0			# unix consensus
-syscon	icmp6	ICMP6_RR_FLAGS_PREVDONE			8			8			8			8			8			8			8			0			# unix consensus
-syscon	icmp6	ICMP6_RR_FLAGS_SPECSITE			0x10			0x10			0x10			0x10			0x10			0x10			0x10			0			# unix consensus
-syscon	icmp6	ICMP6_RR_PCOUSE_RAFLAGS_AUTO		0x10			0x10			0x40			0x40			0x40			0x40			0x40			0			# bsd consensus
-syscon	icmp6	ICMP6_RR_FLAGS_FORCEAPPLY		0x20			0x20			0x20			0x20			0x20			0x20			0x20			0			# unix consensus
-syscon	icmp6	ICMP6_RR_PCOUSE_RAFLAGS_ONLINK		0x20			0x20			0x80			0x80			0x80			0x80			0x80			0			# bsd consensus
-syscon	icmp6	ICMP6_RR_FLAGS_REQRESULT		0x40			0x40			0x40			0x40			0x40			0x40			0x40			0			# unix consensus
-syscon	icmp6	ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME	0x40			0x40			0x40			0x40			0x40			0x40			0x40			0			# unix consensus
-syscon	icmp6	ICMP6_INFOMSG_MASK			0x80			0x80			0x80			0x80			0x80			0x80			0x80			0x80			# consensus
-syscon	icmp6	ICMP6_ECHO_REQUEST			0x80			0x80			0x80			0x80			0x80			0x80			0x80			0			# unix consensus
-syscon	icmp6	ICMP6_RR_FLAGS_TEST			0x80			0x80			0x80			0x80			0x80			0x80			0x80			0			# unix consensus
-syscon	icmp6	ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME	0x80			0x80			0x80			0x80			0x80			0x80			0x80			0			# unix consensus
-syscon	icmp6	ICMP6_ECHO_REPLY			129			129			129			129			129			129			129			0			# unix consensus
-syscon	icmp6	ICMP6_ROUTER_RENUMBERING		138			138			138			138			138			138			138			0			# unix consensus
-syscon	icmp6	ICMP6_RR_RESULT_FLAGS_FORBIDDEN		0x0100			0x0100			0x0100			0x0100			0x0100			0x0100			0x0100			0			# unix consensus
-syscon	icmp6	ICMP6_RR_RESULT_FLAGS_OOB		0x0200			0x0200			0x0200			0x0200			0x0200			0x0200			0x0200			0			# unix consensus
-
-syscon	misc	FIFOTYPE				54			54			54			54			54			54			54			0			# unix consensus
-syscon	misc	GRPQUOTA				1			1			1			1			1			1			1			0			# unix consensus
-syscon	misc	IF_NAMESIZE				0x10			0x10			0x10			0x10			0x10			0x10			0x10			0			# unix consensus
-syscon	misc	INTERMEDIATE_C_GOOD			10			10			0			0			0			0			0			0
-syscon	misc	INTERMEDIATE_GOOD			8			8			0			0			0			0			0			0
-
-syscon	misc	IOV_MAX					0x0400			0x0400			0x0400			0x0400			0x0400			0x0400			0x0400			16			# unix consensus & MSG_MAXIOVLEN
-syscon	misc	LINE_MAX				0x0800			0x0800			0x0800			0x0800			0x0800			0x0800			0x0800			0			# unix consensus
-syscon	misc	LINKED_CMD_COMPLETE			10			10			0			0			0			0			0			0
-syscon	misc	LINKED_FLG_CMD_COMPLETE			11			11			0			0			0			0			0			0
-
-syscon	misc	LNKTYPE					49			49			49			49			49			49			49			0			# unix consensus
-syscon	misc	MAXNAMLEN				255			255			255			255			255			255			255			0			# unix consensus
-syscon	misc	MAXQUOTAS				2			2			2			2			2			2			2			0			# unix consensus
-syscon	misc	MEDIUM_ERROR				3			3			0			0			0			0			0			0
-syscon	misc	MEDIUM_SCAN				56			56			0			0			0			0			0			0
-
-syscon	misc	NBBY					8			8			8			8			8			8			8			0			# unix consensus
-syscon	misc	NR_DQHASH				43			43			0			0			0			0			0			0
-syscon	misc	NR_DQUOTS				0x0100			0x0100			0			0			0			0			0			0
-
-syscon	misc	PERSISTENT_RESERVE_IN			94			94			0			0			0			0			0			0
-syscon	misc	PERSISTENT_RESERVE_OUT			95			95			0			0			0			0			0			0
-
-syscon	misc	PRELIM					1			1			1			1			1			1			1			0			# unix consensus
-syscon	misc	REGTYPE					48			48			48			48			48			48			48			0			# unix consensus
-syscon	misc	RES_PRF_CLASS				4			4			4			4			4			4			4			0			# unix consensus
-syscon	misc	RHF_GUARANTEE_START_INIT		0x80			0x80			0			0			0			0			0			0
-syscon	misc	RHF_NO_LIBRARY_REPLACEMENT		4			4			0			0			0			0			0			0
-
-syscon	misc	RRQ					1			1			1			1			1			1			1			0			# unix consensus
-syscon	misc	RTF_NOFORWARD				0x1000			0x1000			0			0			0			0			0			0
-syscon	misc	RTF_NOPMTUDISC				0x4000			0x4000			0			0			0			0			0			0
-
-syscon	misc	SARMAG					8			8			8			8			8			8			8			0			# unix consensus
-syscon	misc	SEGSIZE					0x0200			0x0200			0x0200			0x0200			0x0200			0x0200			0x0200			0			# unix consensus
-syscon	misc	SEND_DIAGNOSTIC				29			29			0			0			0			0			0			0
-syscon	misc	SEND_VOLUME_TAG				182			182			0			0			0			0			0			0
-
-syscon	misc	SET_LIMITS				51			51			0			0			0			0			0			0
-syscon	misc	SET_WINDOW				36			36			0			0			0			0			0			0
-
-syscon	misc	SFD_CLOEXEC				0x080000		0x080000		0			0			0			0			0			0
-syscon	misc	SFD_NONBLOCK				0x0800			0x0800			0			0			0			0			0			0
-
-syscon	misc	SUBCMDMASK				255			255			255			255			255			255			255			0			# unix consensus
-syscon	misc	SUBCMDSHIFT				8			8			8			8			8			8			8			0			# unix consensus
-syscon	misc	SYMTYPE					50			50			50			50			50			50			50			0			# unix consensus
-syscon	misc	TGEXEC					8			8			8			8			8			8			8			0			# unix consensus
-syscon	misc	TGREAD					0x20			0x20			0x20			0x20			0x20			0x20			0x20			0			# unix consensus
-syscon	misc	TGWRITE					0x10			0x10			0x10			0x10			0x10			0x10			0x10			0			# unix consensus
-syscon	misc	TMAGLEN					6			6			6			6			6			6			6			0			# unix consensus
-syscon	misc	TOEXEC					1			1			1			1			1			1			1			0			# unix consensus
-syscon	misc	TOREAD					4			4			4			4			4			4			4			0			# unix consensus
-syscon	misc	TOWRITE					2			2			2			2			2			2			2			0			# unix consensus
-syscon	misc	TRANSIENT				4			4			4			4			4			4			4			0			# unix consensus
-syscon	misc	TSGID					0x0400			0x0400			0x0400			0x0400			0x0400			0x0400			0x0400			0			# unix consensus
-syscon	misc	TSUID					0x0800			0x0800			0x0800			0x0800			0x0800			0x0800			0x0800			0			# unix consensus
-syscon	misc	TSVTX					0x0200			0x0200			0x0200			0x0200			0x0200			0x0200			0x0200			0			# unix consensus
-syscon	misc	TUEXEC					0x40			0x40			0x40			0x40			0x40			0x40			0x40			0			# unix consensus
-syscon	misc	TUREAD					0x0100			0x0100			0x0100			0x0100			0x0100			0x0100			0x0100			0			# unix consensus
-syscon	misc	TUWRITE					0x80			0x80			0x80			0x80			0x80			0x80			0x80			0			# unix consensus
-syscon	misc	TVERSLEN				2			2			2			2			2			2			2			0			# unix consensus
-syscon	misc	WORD_BIT				0x20			0x20			0x20			0x20			0x20			0x20			0x20			0			# unix consensus
-syscon	misc	WRQ					2			2			2			2			2			2			2			0			# unix consensus
-syscon	misc	SIGEV_THREAD				2			2			3			3			2			0			2			0
-syscon	misc	SIGEV_SIGNAL				0			0			1			1			1			0			1			0
-syscon	misc	SIGEV_NONE				1			1			0			0			0			0			0			0
-
-syscon	misc	BC_BASE_MAX				99			99			99			99			99			0x7fffffff		0x7fffffff		0
-syscon	misc	BC_DIM_MAX				0x0800			0x0800			0x0800			0x0800			0x0800			0xffff			0xffff			0
-syscon	misc	BC_SCALE_MAX				99			99			99			99			99			0x7fffffff		0x7fffffff		0
-syscon	misc	BC_STRING_MAX				0x03e8			0x03e8			0x03e8			0x03e8			0x03e8			0x7fffffff		0x7fffffff		0
-
-syscon	misc	ABORTED_COMMAND				11			11			0			0			0			0			0			0
-syscon	misc	ACORE					0			0			8			8			8			8			8			0			# bsd consensus
-syscon	misc	AFORK					0			0			1			1			1			1			1			0			# bsd consensus
-syscon	misc	AIO_ALLDONE				2			2			1			1			3			0			0			0
-syscon	misc	AIO_NOTCANCELED				1			1			4			4			2			0			0			0
-syscon	misc	AIO_CANCELED				0			0			2			2			1			0			0			0
+syscon	select	FD_SETSIZE				0x0400			0x0400			0x0400			0x0400			0x0400			0x0400			0x0400			0x0400			# forced consensus (0x40 on NT)
+syscon	misc	IOV_MAX					1024			1024			1024			1024			1024			1024			1024			16			# unix consensus & MSG_MAXIOVLEN
 
 #	baud rates
 #
@@ -2143,4 +1981,4 @@ syscon	misc	UL_SETFSIZE				2			2			2			2			2			0			0			0
 syscon	misc	XATTR_CREATE				1			1			2			2			0			0			0			0
 syscon	misc	XATTR_REPLACE				2			2			4			4			0			0			0			0
 
-# https://youtu.be/GUQUD3IMbb4?t=85
+# https://youtu.be/3SNBXoWs4GM
diff --git a/libc/sysv/consts/ABORTED_COMMAND.S b/libc/sysv/consts/ABORTED_COMMAND.S
deleted file mode 100644
index afb9abbae..000000000
--- a/libc/sysv/consts/ABORTED_COMMAND.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,ABORTED_COMMAND,11,11,0,0,0,0,0,0
diff --git a/libc/sysv/consts/ACORE.S b/libc/sysv/consts/ACORE.S
deleted file mode 100644
index 72447040a..000000000
--- a/libc/sysv/consts/ACORE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,ACORE,0,0,8,8,8,8,8,0
diff --git a/libc/sysv/consts/AFORK.S b/libc/sysv/consts/AFORK.S
deleted file mode 100644
index 992cacc80..000000000
--- a/libc/sysv/consts/AFORK.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,AFORK,0,0,1,1,1,1,1,0
diff --git a/libc/sysv/consts/AIO_ALLDONE.S b/libc/sysv/consts/AIO_ALLDONE.S
deleted file mode 100644
index 63584ff7a..000000000
--- a/libc/sysv/consts/AIO_ALLDONE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,AIO_ALLDONE,2,2,1,1,3,0,0,0
diff --git a/libc/sysv/consts/AIO_CANCELED.S b/libc/sysv/consts/AIO_CANCELED.S
deleted file mode 100644
index 6124168e4..000000000
--- a/libc/sysv/consts/AIO_CANCELED.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,AIO_CANCELED,0,0,2,2,1,0,0,0
diff --git a/libc/sysv/consts/AIO_NOTCANCELED.S b/libc/sysv/consts/AIO_NOTCANCELED.S
deleted file mode 100644
index 6ef85d564..000000000
--- a/libc/sysv/consts/AIO_NOTCANCELED.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,AIO_NOTCANCELED,1,1,4,4,2,0,0,0
diff --git a/libc/sysv/consts/BC_BASE_MAX.S b/libc/sysv/consts/BC_BASE_MAX.S
deleted file mode 100644
index b6bc0ec08..000000000
--- a/libc/sysv/consts/BC_BASE_MAX.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,BC_BASE_MAX,99,99,99,99,99,0x7fffffff,0x7fffffff,0
diff --git a/libc/sysv/consts/BC_DIM_MAX.S b/libc/sysv/consts/BC_DIM_MAX.S
deleted file mode 100644
index 267a893bc..000000000
--- a/libc/sysv/consts/BC_DIM_MAX.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,BC_DIM_MAX,0x0800,0x0800,0x0800,0x0800,0x0800,0xffff,0xffff,0
diff --git a/libc/sysv/consts/BC_SCALE_MAX.S b/libc/sysv/consts/BC_SCALE_MAX.S
deleted file mode 100644
index c7fd64227..000000000
--- a/libc/sysv/consts/BC_SCALE_MAX.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,BC_SCALE_MAX,99,99,99,99,99,0x7fffffff,0x7fffffff,0
diff --git a/libc/sysv/consts/BC_STRING_MAX.S b/libc/sysv/consts/BC_STRING_MAX.S
deleted file mode 100644
index 883450d84..000000000
--- a/libc/sysv/consts/BC_STRING_MAX.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,BC_STRING_MAX,0x03e8,0x03e8,0x03e8,0x03e8,0x03e8,0x7fffffff,0x7fffffff,0
diff --git a/libc/sysv/consts/CLOCK_BOOTTIME.S b/libc/sysv/consts/CLOCK_BOOTTIME.S
index ead5f9008..966970d27 100644
--- a/libc/sysv/consts/CLOCK_BOOTTIME.S
+++ b/libc/sysv/consts/CLOCK_BOOTTIME.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_BOOTTIME,7,7,7,127,127,6,127,3
+.syscon clock,CLOCK_BOOTTIME,7,7,6,6,4,3,3,3
diff --git a/libc/sysv/consts/CLOCK_BOOTTIME_ALARM.S b/libc/sysv/consts/CLOCK_BOOTTIME_ALARM.S
deleted file mode 100644
index 88265bcc8..000000000
--- a/libc/sysv/consts/CLOCK_BOOTTIME_ALARM.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_BOOTTIME_ALARM,9,9,127,127,127,127,127,127
diff --git a/libc/sysv/consts/CLOCK_MONOTONIC.S b/libc/sysv/consts/CLOCK_MONOTONIC.S
index 2275c6cf1..66d85a317 100644
--- a/libc/sysv/consts/CLOCK_MONOTONIC.S
+++ b/libc/sysv/consts/CLOCK_MONOTONIC.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_MONOTONIC,1,1,6,6,4,3,3,1
+.syscon clock,CLOCK_MONOTONIC,1,1,8,8,5,5,3,1
diff --git a/libc/sysv/consts/CLOCK_MONOTONIC_COARSE.S b/libc/sysv/consts/CLOCK_MONOTONIC_COARSE.S
index 225972c1d..494834f22 100644
--- a/libc/sysv/consts/CLOCK_MONOTONIC_COARSE.S
+++ b/libc/sysv/consts/CLOCK_MONOTONIC_COARSE.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_MONOTONIC_COARSE,6,6,5,5,12,3,3,1
+.syscon clock,CLOCK_MONOTONIC_COARSE,6,6,9,9,8,5,3,6
diff --git a/libc/sysv/consts/CLOCK_MONOTONIC_FAST.S b/libc/sysv/consts/CLOCK_MONOTONIC_FAST.S
deleted file mode 100644
index 0069c82cf..000000000
--- a/libc/sysv/consts/CLOCK_MONOTONIC_FAST.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_MONOTONIC_FAST,1,1,6,6,12,3,3,1
diff --git a/libc/sysv/consts/CLOCK_MONOTONIC_PRECISE.S b/libc/sysv/consts/CLOCK_MONOTONIC_PRECISE.S
deleted file mode 100644
index e9e77f345..000000000
--- a/libc/sysv/consts/CLOCK_MONOTONIC_PRECISE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_MONOTONIC_PRECISE,1,1,6,6,11,3,3,1
diff --git a/libc/sysv/consts/CLOCK_MONOTONIC_RAW.S b/libc/sysv/consts/CLOCK_MONOTONIC_RAW.S
index 1c158565e..45dcd0e7d 100644
--- a/libc/sysv/consts/CLOCK_MONOTONIC_RAW.S
+++ b/libc/sysv/consts/CLOCK_MONOTONIC_RAW.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_MONOTONIC_RAW,4,4,4,4,127,127,127,127
+.syscon clock,CLOCK_MONOTONIC_RAW,4,4,127,8,8,127,3,1
diff --git a/libc/sysv/consts/CLOCK_PROF.S b/libc/sysv/consts/CLOCK_PROF.S
deleted file mode 100644
index a91213a17..000000000
--- a/libc/sysv/consts/CLOCK_PROF.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_PROF,127,127,127,127,2,127,2,127
diff --git a/libc/sysv/consts/CLOCK_REALTIME_ALARM.S b/libc/sysv/consts/CLOCK_REALTIME_ALARM.S
deleted file mode 100644
index 0d497e110..000000000
--- a/libc/sysv/consts/CLOCK_REALTIME_ALARM.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_REALTIME_ALARM,8,8,127,127,127,127,127,127
diff --git a/libc/sysv/consts/CLOCK_REALTIME_FAST.S b/libc/sysv/consts/CLOCK_REALTIME_FAST.S
deleted file mode 100644
index fd0774e29..000000000
--- a/libc/sysv/consts/CLOCK_REALTIME_FAST.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_REALTIME_FAST,0,0,0,0,10,0,0,0
diff --git a/libc/sysv/consts/CLOCK_REALTIME_PRECISE.S b/libc/sysv/consts/CLOCK_REALTIME_PRECISE.S
deleted file mode 100644
index e3ce38e79..000000000
--- a/libc/sysv/consts/CLOCK_REALTIME_PRECISE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_REALTIME_PRECISE,0,0,0,0,9,0,0,0
diff --git a/libc/sysv/consts/CLOCK_SECOND.S b/libc/sysv/consts/CLOCK_SECOND.S
deleted file mode 100644
index f39711a0c..000000000
--- a/libc/sysv/consts/CLOCK_SECOND.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_SECOND,127,127,127,127,13,127,127,127
diff --git a/libc/sysv/consts/CLOCK_TAI.S b/libc/sysv/consts/CLOCK_TAI.S
deleted file mode 100644
index 041e63585..000000000
--- a/libc/sysv/consts/CLOCK_TAI.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_TAI,11,11,127,127,127,127,127,127
diff --git a/libc/sysv/consts/CLOCK_UPTIME.S b/libc/sysv/consts/CLOCK_UPTIME.S
deleted file mode 100644
index 281eaa508..000000000
--- a/libc/sysv/consts/CLOCK_UPTIME.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_UPTIME,127,127,8,8,5,5,127,127
diff --git a/libc/sysv/consts/CLOCK_UPTIME_FAST.S b/libc/sysv/consts/CLOCK_UPTIME_FAST.S
deleted file mode 100644
index 3d1ecfd4c..000000000
--- a/libc/sysv/consts/CLOCK_UPTIME_FAST.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_UPTIME_FAST,127,127,127,127,8,127,127,127
diff --git a/libc/sysv/consts/CLOCK_UPTIME_PRECISE.S b/libc/sysv/consts/CLOCK_UPTIME_PRECISE.S
deleted file mode 100644
index 581afe2dd..000000000
--- a/libc/sysv/consts/CLOCK_UPTIME_PRECISE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon clock,CLOCK_UPTIME_PRECISE,127,127,127,127,7,127,127,127
diff --git a/libc/sysv/consts/FIFOTYPE.S b/libc/sysv/consts/FIFOTYPE.S
deleted file mode 100644
index 544cea69d..000000000
--- a/libc/sysv/consts/FIFOTYPE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,FIFOTYPE,54,54,54,54,54,54,54,0
diff --git a/libc/sysv/consts/GRPQUOTA.S b/libc/sysv/consts/GRPQUOTA.S
deleted file mode 100644
index 0418f4462..000000000
--- a/libc/sysv/consts/GRPQUOTA.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,GRPQUOTA,1,1,1,1,1,1,1,0
diff --git a/libc/sysv/consts/IF_NAMESIZE.S b/libc/sysv/consts/IF_NAMESIZE.S
deleted file mode 100644
index 314fb2084..000000000
--- a/libc/sysv/consts/IF_NAMESIZE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,IF_NAMESIZE,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0
diff --git a/libc/sysv/consts/INET6_ADDRSTRLEN.S b/libc/sysv/consts/INET6_ADDRSTRLEN.S
deleted file mode 100644
index df458d2b1..000000000
--- a/libc/sysv/consts/INET6_ADDRSTRLEN.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,INET6_ADDRSTRLEN,46,46,46,46,46,46,46,65
diff --git a/libc/sysv/consts/INET_ADDRSTRLEN.S b/libc/sysv/consts/INET_ADDRSTRLEN.S
deleted file mode 100644
index ae2997334..000000000
--- a/libc/sysv/consts/INET_ADDRSTRLEN.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,INET_ADDRSTRLEN,0x10,0x10,0x10,0x10,0x10,0x10,0x10,22
diff --git a/libc/sysv/consts/INTERMEDIATE_C_GOOD.S b/libc/sysv/consts/INTERMEDIATE_C_GOOD.S
deleted file mode 100644
index ced82c458..000000000
--- a/libc/sysv/consts/INTERMEDIATE_C_GOOD.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,INTERMEDIATE_C_GOOD,10,10,0,0,0,0,0,0
diff --git a/libc/sysv/consts/INTERMEDIATE_GOOD.S b/libc/sysv/consts/INTERMEDIATE_GOOD.S
deleted file mode 100644
index 9a500bbf2..000000000
--- a/libc/sysv/consts/INTERMEDIATE_GOOD.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,INTERMEDIATE_GOOD,8,8,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IOV_MAX.S b/libc/sysv/consts/IOV_MAX.S
index 120790cc7..bc75cf2c3 100644
--- a/libc/sysv/consts/IOV_MAX.S
+++ b/libc/sysv/consts/IOV_MAX.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,IOV_MAX,0x0400,0x0400,0x0400,0x0400,0x0400,0x0400,0x0400,16
+.syscon misc,IOV_MAX,1024,1024,1024,1024,1024,1024,1024,16
diff --git a/libc/sysv/consts/IP6F_MORE_FRAG.S b/libc/sysv/consts/IP6F_MORE_FRAG.S
deleted file mode 100644
index cfa0f7681..000000000
--- a/libc/sysv/consts/IP6F_MORE_FRAG.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,IP6F_MORE_FRAG,0x0100,0x0100,0x0100,0x0100,0x0100,0x0100,0x0100,0x0100
diff --git a/libc/sysv/consts/IP6F_OFF_MASK.S b/libc/sysv/consts/IP6F_OFF_MASK.S
deleted file mode 100644
index 1c927ebfe..000000000
--- a/libc/sysv/consts/IP6F_OFF_MASK.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,IP6F_OFF_MASK,0xf8ff,0xf8ff,0xf8ff,0xf8ff,0xf8ff,0xf8ff,0xf8ff,0xf8ff
diff --git a/libc/sysv/consts/IP6F_RESERVED_MASK.S b/libc/sysv/consts/IP6F_RESERVED_MASK.S
deleted file mode 100644
index 19997c100..000000000
--- a/libc/sysv/consts/IP6F_RESERVED_MASK.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,IP6F_RESERVED_MASK,0x0600,0x0600,0x0600,0x0600,0x0600,0x0600,0x0600,0x0600
diff --git a/libc/sysv/consts/IPV6_2292DSTOPTS.S b/libc/sysv/consts/IPV6_2292DSTOPTS.S
deleted file mode 100644
index 2a6dbbf2e..000000000
--- a/libc/sysv/consts/IPV6_2292DSTOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_2292DSTOPTS,4,4,23,23,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_2292HOPLIMIT.S b/libc/sysv/consts/IPV6_2292HOPLIMIT.S
deleted file mode 100644
index 26e86fd91..000000000
--- a/libc/sysv/consts/IPV6_2292HOPLIMIT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_2292HOPLIMIT,8,8,20,20,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_2292HOPOPTS.S b/libc/sysv/consts/IPV6_2292HOPOPTS.S
deleted file mode 100644
index e10f84c01..000000000
--- a/libc/sysv/consts/IPV6_2292HOPOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_2292HOPOPTS,3,3,22,22,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_2292PKTINFO.S b/libc/sysv/consts/IPV6_2292PKTINFO.S
deleted file mode 100644
index 1673a96d6..000000000
--- a/libc/sysv/consts/IPV6_2292PKTINFO.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_2292PKTINFO,2,2,19,19,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_2292PKTOPTIONS.S b/libc/sysv/consts/IPV6_2292PKTOPTIONS.S
deleted file mode 100644
index 069cf9603..000000000
--- a/libc/sysv/consts/IPV6_2292PKTOPTIONS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_2292PKTOPTIONS,6,6,25,25,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_2292RTHDR.S b/libc/sysv/consts/IPV6_2292RTHDR.S
deleted file mode 100644
index 1fa611ef1..000000000
--- a/libc/sysv/consts/IPV6_2292RTHDR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_2292RTHDR,5,5,24,24,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_ADDRFORM.S b/libc/sysv/consts/IPV6_ADDRFORM.S
deleted file mode 100644
index dd171ca8f..000000000
--- a/libc/sysv/consts/IPV6_ADDRFORM.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_ADDRFORM,1,1,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_ADD_MEMBERSHIP.S b/libc/sysv/consts/IPV6_ADD_MEMBERSHIP.S
deleted file mode 100644
index d65647e8b..000000000
--- a/libc/sysv/consts/IPV6_ADD_MEMBERSHIP.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_ADD_MEMBERSHIP,20,20,0,0,0,0,0,12
diff --git a/libc/sysv/consts/IPV6_AUTHHDR.S b/libc/sysv/consts/IPV6_AUTHHDR.S
deleted file mode 100644
index 8e9919123..000000000
--- a/libc/sysv/consts/IPV6_AUTHHDR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_AUTHHDR,10,10,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_AUTOFLOWLABEL.S b/libc/sysv/consts/IPV6_AUTOFLOWLABEL.S
deleted file mode 100644
index d086a55b7..000000000
--- a/libc/sysv/consts/IPV6_AUTOFLOWLABEL.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_AUTOFLOWLABEL,0,0,0,0,59,59,59,0
diff --git a/libc/sysv/consts/IPV6_DROP_MEMBERSHIP.S b/libc/sysv/consts/IPV6_DROP_MEMBERSHIP.S
deleted file mode 100644
index 3cc6ff63b..000000000
--- a/libc/sysv/consts/IPV6_DROP_MEMBERSHIP.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_DROP_MEMBERSHIP,21,21,0,0,0,0,0,13
diff --git a/libc/sysv/consts/IPV6_DSTOPTS.S b/libc/sysv/consts/IPV6_DSTOPTS.S
deleted file mode 100644
index 6ca099353..000000000
--- a/libc/sysv/consts/IPV6_DSTOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_DSTOPTS,59,59,0,0,50,50,50,0
diff --git a/libc/sysv/consts/IPV6_HDRINCL.S b/libc/sysv/consts/IPV6_HDRINCL.S
deleted file mode 100644
index a2efd7c08..000000000
--- a/libc/sysv/consts/IPV6_HDRINCL.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_HDRINCL,36,36,0,0,0,0,0,2
diff --git a/libc/sysv/consts/IPV6_IPSEC_POLICY.S b/libc/sysv/consts/IPV6_IPSEC_POLICY.S
deleted file mode 100644
index d02507ea3..000000000
--- a/libc/sysv/consts/IPV6_IPSEC_POLICY.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_IPSEC_POLICY,34,34,28,28,28,0,0,0
diff --git a/libc/sysv/consts/IPV6_JOIN_ANYCAST.S b/libc/sysv/consts/IPV6_JOIN_ANYCAST.S
deleted file mode 100644
index 7dc3a28cd..000000000
--- a/libc/sysv/consts/IPV6_JOIN_ANYCAST.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_JOIN_ANYCAST,27,27,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_LEAVE_ANYCAST.S b/libc/sysv/consts/IPV6_LEAVE_ANYCAST.S
deleted file mode 100644
index 59bfa4c19..000000000
--- a/libc/sysv/consts/IPV6_LEAVE_ANYCAST.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_LEAVE_ANYCAST,28,28,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_MINHOPCOUNT.S b/libc/sysv/consts/IPV6_MINHOPCOUNT.S
deleted file mode 100644
index 7cc084a51..000000000
--- a/libc/sysv/consts/IPV6_MINHOPCOUNT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_MINHOPCOUNT,0,0,0,0,0,65,65,0
diff --git a/libc/sysv/consts/IPV6_MTU.S b/libc/sysv/consts/IPV6_MTU.S
deleted file mode 100644
index 17264a0f5..000000000
--- a/libc/sysv/consts/IPV6_MTU.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_MTU,24,24,0,0,0,0,0,72
diff --git a/libc/sysv/consts/IPV6_MTU_DISCOVER.S b/libc/sysv/consts/IPV6_MTU_DISCOVER.S
deleted file mode 100644
index c2bb09127..000000000
--- a/libc/sysv/consts/IPV6_MTU_DISCOVER.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_MTU_DISCOVER,23,23,0,0,0,0,0,71
diff --git a/libc/sysv/consts/IPV6_NEXTHOP.S b/libc/sysv/consts/IPV6_NEXTHOP.S
deleted file mode 100644
index 66707028f..000000000
--- a/libc/sysv/consts/IPV6_NEXTHOP.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_NEXTHOP,9,9,0,0,48,48,48,0
diff --git a/libc/sysv/consts/IPV6_ORIGDSTADDR.S b/libc/sysv/consts/IPV6_ORIGDSTADDR.S
deleted file mode 100644
index d4b63d6fb..000000000
--- a/libc/sysv/consts/IPV6_ORIGDSTADDR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_ORIGDSTADDR,0,0,0,0,72,0,0,0
diff --git a/libc/sysv/consts/IPV6_PATHMTU.S b/libc/sysv/consts/IPV6_PATHMTU.S
deleted file mode 100644
index 451946e08..000000000
--- a/libc/sysv/consts/IPV6_PATHMTU.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_PATHMTU,61,61,0,0,44,44,44,0
diff --git a/libc/sysv/consts/IPV6_PMTUDISC_DO.S b/libc/sysv/consts/IPV6_PMTUDISC_DO.S
deleted file mode 100644
index 01bec78bd..000000000
--- a/libc/sysv/consts/IPV6_PMTUDISC_DO.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_PMTUDISC_DO,2,2,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_PMTUDISC_DONT.S b/libc/sysv/consts/IPV6_PMTUDISC_DONT.S
deleted file mode 100644
index f9463aa4c..000000000
--- a/libc/sysv/consts/IPV6_PMTUDISC_DONT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_PMTUDISC_DONT,0,0,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_PMTUDISC_INTERFACE.S b/libc/sysv/consts/IPV6_PMTUDISC_INTERFACE.S
deleted file mode 100644
index cd2a558a8..000000000
--- a/libc/sysv/consts/IPV6_PMTUDISC_INTERFACE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_PMTUDISC_INTERFACE,4,4,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_PMTUDISC_OMIT.S b/libc/sysv/consts/IPV6_PMTUDISC_OMIT.S
deleted file mode 100644
index 99d88d940..000000000
--- a/libc/sysv/consts/IPV6_PMTUDISC_OMIT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_PMTUDISC_OMIT,5,5,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_PMTUDISC_PROBE.S b/libc/sysv/consts/IPV6_PMTUDISC_PROBE.S
deleted file mode 100644
index ab10f54f4..000000000
--- a/libc/sysv/consts/IPV6_PMTUDISC_PROBE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_PMTUDISC_PROBE,3,3,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_PMTUDISC_WANT.S b/libc/sysv/consts/IPV6_PMTUDISC_WANT.S
deleted file mode 100644
index e9bf56f99..000000000
--- a/libc/sysv/consts/IPV6_PMTUDISC_WANT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_PMTUDISC_WANT,1,1,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_RECVDSTOPTS.S b/libc/sysv/consts/IPV6_RECVDSTOPTS.S
deleted file mode 100644
index cd0aa3257..000000000
--- a/libc/sysv/consts/IPV6_RECVDSTOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RECVDSTOPTS,58,58,0,0,40,40,40,0
diff --git a/libc/sysv/consts/IPV6_RECVERR.S b/libc/sysv/consts/IPV6_RECVERR.S
deleted file mode 100644
index 1c36df28f..000000000
--- a/libc/sysv/consts/IPV6_RECVERR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RECVERR,25,25,0,0,0,0,0,75
diff --git a/libc/sysv/consts/IPV6_RECVHOPLIMIT.S b/libc/sysv/consts/IPV6_RECVHOPLIMIT.S
deleted file mode 100644
index 2e7b97112..000000000
--- a/libc/sysv/consts/IPV6_RECVHOPLIMIT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RECVHOPLIMIT,51,51,0,0,37,37,37,0
diff --git a/libc/sysv/consts/IPV6_RECVHOPOPTS.S b/libc/sysv/consts/IPV6_RECVHOPOPTS.S
deleted file mode 100644
index d2bb20708..000000000
--- a/libc/sysv/consts/IPV6_RECVHOPOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RECVHOPOPTS,53,53,0,0,39,39,39,0
diff --git a/libc/sysv/consts/IPV6_RECVORIGDSTADDR.S b/libc/sysv/consts/IPV6_RECVORIGDSTADDR.S
deleted file mode 100644
index c4e179301..000000000
--- a/libc/sysv/consts/IPV6_RECVORIGDSTADDR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RECVORIGDSTADDR,0,0,0,0,72,0,0,0
diff --git a/libc/sysv/consts/IPV6_RECVPATHMTU.S b/libc/sysv/consts/IPV6_RECVPATHMTU.S
deleted file mode 100644
index 4a8fdc77d..000000000
--- a/libc/sysv/consts/IPV6_RECVPATHMTU.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RECVPATHMTU,60,60,0,0,43,43,43,0
diff --git a/libc/sysv/consts/IPV6_RECVPKTINFO.S b/libc/sysv/consts/IPV6_RECVPKTINFO.S
deleted file mode 100644
index 49141d5f1..000000000
--- a/libc/sysv/consts/IPV6_RECVPKTINFO.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RECVPKTINFO,49,49,0,0,36,36,36,0
diff --git a/libc/sysv/consts/IPV6_ROUTER_ALERT.S b/libc/sysv/consts/IPV6_ROUTER_ALERT.S
deleted file mode 100644
index ea8557cd9..000000000
--- a/libc/sysv/consts/IPV6_ROUTER_ALERT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_ROUTER_ALERT,22,22,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_RTHDR.S b/libc/sysv/consts/IPV6_RTHDR.S
index 7e464ebd8..eddbf9ed8 100644
--- a/libc/sysv/consts/IPV6_RTHDR.S
+++ b/libc/sysv/consts/IPV6_RTHDR.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RTHDR,57,57,0,0,51,51,51,0x20
+.syscon ipv6,IPV6_RTHDR,57,57,0,0,51,51,51,32
diff --git a/libc/sysv/consts/IPV6_RTHDRDSTOPTS.S b/libc/sysv/consts/IPV6_RTHDRDSTOPTS.S
deleted file mode 100644
index 1df68a921..000000000
--- a/libc/sysv/consts/IPV6_RTHDRDSTOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RTHDRDSTOPTS,55,55,0,0,35,35,35,0
diff --git a/libc/sysv/consts/IPV6_RTHDR_LOOSE.S b/libc/sysv/consts/IPV6_RTHDR_LOOSE.S
deleted file mode 100644
index a61ea0a6e..000000000
--- a/libc/sysv/consts/IPV6_RTHDR_LOOSE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RTHDR_LOOSE,0,0,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_RTHDR_STRICT.S b/libc/sysv/consts/IPV6_RTHDR_STRICT.S
deleted file mode 100644
index 52e7e5561..000000000
--- a/libc/sysv/consts/IPV6_RTHDR_STRICT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RTHDR_STRICT,1,1,1,1,1,0,0,0
diff --git a/libc/sysv/consts/IPV6_RTHDR_TYPE_0.S b/libc/sysv/consts/IPV6_RTHDR_TYPE_0.S
deleted file mode 100644
index 79bbce89d..000000000
--- a/libc/sysv/consts/IPV6_RTHDR_TYPE_0.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RTHDR_TYPE_0,0,0,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_RXDSTOPTS.S b/libc/sysv/consts/IPV6_RXDSTOPTS.S
deleted file mode 100644
index 81f8647a3..000000000
--- a/libc/sysv/consts/IPV6_RXDSTOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RXDSTOPTS,59,59,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_RXHOPOPTS.S b/libc/sysv/consts/IPV6_RXHOPOPTS.S
deleted file mode 100644
index a5a089d0f..000000000
--- a/libc/sysv/consts/IPV6_RXHOPOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_RXHOPOPTS,54,54,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IPV6_UNICAST_HOPS.S b/libc/sysv/consts/IPV6_UNICAST_HOPS.S
index dd3c23fbe..40a3a4686 100644
--- a/libc/sysv/consts/IPV6_UNICAST_HOPS.S
+++ b/libc/sysv/consts/IPV6_UNICAST_HOPS.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_UNICAST_HOPS,0x10,0x10,4,4,4,4,4,4
+.syscon ipv6,IPV6_UNICAST_HOPS,16,16,4,4,4,4,4,4
diff --git a/libc/sysv/consts/IPV6_XFRM_POLICY.S b/libc/sysv/consts/IPV6_XFRM_POLICY.S
deleted file mode 100644
index bf31a4bd6..000000000
--- a/libc/sysv/consts/IPV6_XFRM_POLICY.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ipv6,IPV6_XFRM_POLICY,35,35,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_ADD_SOURCE_MEMBERSHIP.S b/libc/sysv/consts/IP_ADD_SOURCE_MEMBERSHIP.S
deleted file mode 100644
index fc8e01943..000000000
--- a/libc/sysv/consts/IP_ADD_SOURCE_MEMBERSHIP.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_ADD_SOURCE_MEMBERSHIP,39,39,70,70,70,0,0,15
diff --git a/libc/sysv/consts/IP_BIND_ADDRESS_NO_PORT.S b/libc/sysv/consts/IP_BIND_ADDRESS_NO_PORT.S
deleted file mode 100644
index ac616ee14..000000000
--- a/libc/sysv/consts/IP_BIND_ADDRESS_NO_PORT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_BIND_ADDRESS_NO_PORT,24,24,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_BLOCK_SOURCE.S b/libc/sysv/consts/IP_BLOCK_SOURCE.S
deleted file mode 100644
index 3a00c226f..000000000
--- a/libc/sysv/consts/IP_BLOCK_SOURCE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_BLOCK_SOURCE,38,38,72,72,72,0,0,17
diff --git a/libc/sysv/consts/IP_CHECKSUM.S b/libc/sysv/consts/IP_CHECKSUM.S
deleted file mode 100644
index 3e1cb4251..000000000
--- a/libc/sysv/consts/IP_CHECKSUM.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_CHECKSUM,23,23,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_DEFAULT_MULTICAST_LOOP.S b/libc/sysv/consts/IP_DEFAULT_MULTICAST_LOOP.S
deleted file mode 100644
index 7bc60ef5d..000000000
--- a/libc/sysv/consts/IP_DEFAULT_MULTICAST_LOOP.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_DEFAULT_MULTICAST_LOOP,1,1,1,1,1,1,1,1
diff --git a/libc/sysv/consts/IP_DEFAULT_MULTICAST_TTL.S b/libc/sysv/consts/IP_DEFAULT_MULTICAST_TTL.S
deleted file mode 100644
index 2685d71c8..000000000
--- a/libc/sysv/consts/IP_DEFAULT_MULTICAST_TTL.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_DEFAULT_MULTICAST_TTL,1,1,1,1,1,1,1,1
diff --git a/libc/sysv/consts/IP_DROP_SOURCE_MEMBERSHIP.S b/libc/sysv/consts/IP_DROP_SOURCE_MEMBERSHIP.S
deleted file mode 100644
index 9e070555d..000000000
--- a/libc/sysv/consts/IP_DROP_SOURCE_MEMBERSHIP.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_DROP_SOURCE_MEMBERSHIP,40,40,71,71,71,0,0,16
diff --git a/libc/sysv/consts/IP_FREEBIND.S b/libc/sysv/consts/IP_FREEBIND.S
deleted file mode 100644
index db3eb4129..000000000
--- a/libc/sysv/consts/IP_FREEBIND.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_FREEBIND,15,15,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_IPSEC_POLICY.S b/libc/sysv/consts/IP_IPSEC_POLICY.S
deleted file mode 100644
index d5b73607d..000000000
--- a/libc/sysv/consts/IP_IPSEC_POLICY.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_IPSEC_POLICY,0x10,0x10,21,21,21,0,0,0
diff --git a/libc/sysv/consts/IP_MAX_MEMBERSHIPS.S b/libc/sysv/consts/IP_MAX_MEMBERSHIPS.S
deleted file mode 100644
index 648c49960..000000000
--- a/libc/sysv/consts/IP_MAX_MEMBERSHIPS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_MAX_MEMBERSHIPS,20,20,0x0fff,0x0fff,0x0fff,0x0fff,0x0fff,20
diff --git a/libc/sysv/consts/IP_MINTTL.S b/libc/sysv/consts/IP_MINTTL.S
deleted file mode 100644
index 5295aa259..000000000
--- a/libc/sysv/consts/IP_MINTTL.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_MINTTL,21,21,0,0,66,32,24,0
diff --git a/libc/sysv/consts/IP_MSFILTER.S b/libc/sysv/consts/IP_MSFILTER.S
deleted file mode 100644
index 07628afaa..000000000
--- a/libc/sysv/consts/IP_MSFILTER.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_MSFILTER,41,41,74,74,74,0,0,0
diff --git a/libc/sysv/consts/IP_MTU_DISCOVER.S b/libc/sysv/consts/IP_MTU_DISCOVER.S
deleted file mode 100644
index b86381b44..000000000
--- a/libc/sysv/consts/IP_MTU_DISCOVER.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_MTU_DISCOVER,10,10,0,0,0,0,0,71
diff --git a/libc/sysv/consts/IP_MULTICAST_ALL.S b/libc/sysv/consts/IP_MULTICAST_ALL.S
deleted file mode 100644
index 58533ee80..000000000
--- a/libc/sysv/consts/IP_MULTICAST_ALL.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_MULTICAST_ALL,49,49,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_MULTICAST_IF.S b/libc/sysv/consts/IP_MULTICAST_IF.S
index d1cdf8a7d..1e2e5e93c 100644
--- a/libc/sysv/consts/IP_MULTICAST_IF.S
+++ b/libc/sysv/consts/IP_MULTICAST_IF.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_MULTICAST_IF,0x20,0x20,9,9,9,9,9,9
+.syscon ip,IP_MULTICAST_IF,32,32,9,9,9,9,9,9
diff --git a/libc/sysv/consts/IP_NODEFRAG.S b/libc/sysv/consts/IP_NODEFRAG.S
deleted file mode 100644
index c70a3ba11..000000000
--- a/libc/sysv/consts/IP_NODEFRAG.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_NODEFRAG,22,22,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_ORIGDSTADDR.S b/libc/sysv/consts/IP_ORIGDSTADDR.S
deleted file mode 100644
index 60293c97a..000000000
--- a/libc/sysv/consts/IP_ORIGDSTADDR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_ORIGDSTADDR,20,20,0,0,27,0,0,0
diff --git a/libc/sysv/consts/IP_PASSSEC.S b/libc/sysv/consts/IP_PASSSEC.S
deleted file mode 100644
index baa3afcfe..000000000
--- a/libc/sysv/consts/IP_PASSSEC.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_PASSSEC,18,18,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_PKTOPTIONS.S b/libc/sysv/consts/IP_PKTOPTIONS.S
deleted file mode 100644
index fdeefe4d6..000000000
--- a/libc/sysv/consts/IP_PKTOPTIONS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_PKTOPTIONS,9,9,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_PMTUDISC.S b/libc/sysv/consts/IP_PMTUDISC.S
deleted file mode 100644
index f96b04640..000000000
--- a/libc/sysv/consts/IP_PMTUDISC.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_PMTUDISC,10,10,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_PMTUDISC_DO.S b/libc/sysv/consts/IP_PMTUDISC_DO.S
deleted file mode 100644
index 1dfb7eff0..000000000
--- a/libc/sysv/consts/IP_PMTUDISC_DO.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_PMTUDISC_DO,2,2,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_PMTUDISC_DONT.S b/libc/sysv/consts/IP_PMTUDISC_DONT.S
deleted file mode 100644
index 2eca2c25f..000000000
--- a/libc/sysv/consts/IP_PMTUDISC_DONT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_PMTUDISC_DONT,0,0,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_PMTUDISC_INTERFACE.S b/libc/sysv/consts/IP_PMTUDISC_INTERFACE.S
deleted file mode 100644
index bf21b44ec..000000000
--- a/libc/sysv/consts/IP_PMTUDISC_INTERFACE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_PMTUDISC_INTERFACE,4,4,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_PMTUDISC_OMIT.S b/libc/sysv/consts/IP_PMTUDISC_OMIT.S
deleted file mode 100644
index 737719692..000000000
--- a/libc/sysv/consts/IP_PMTUDISC_OMIT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_PMTUDISC_OMIT,5,5,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_PMTUDISC_PROBE.S b/libc/sysv/consts/IP_PMTUDISC_PROBE.S
deleted file mode 100644
index a8f3d6963..000000000
--- a/libc/sysv/consts/IP_PMTUDISC_PROBE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_PMTUDISC_PROBE,3,3,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_PMTUDISC_WANT.S b/libc/sysv/consts/IP_PMTUDISC_WANT.S
deleted file mode 100644
index 6e6a2a910..000000000
--- a/libc/sysv/consts/IP_PMTUDISC_WANT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_PMTUDISC_WANT,1,1,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_RECVDSTADDR.S b/libc/sysv/consts/IP_RECVDSTADDR.S
deleted file mode 100644
index f2c5257ba..000000000
--- a/libc/sysv/consts/IP_RECVDSTADDR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_RECVDSTADDR,0,0,7,7,7,7,7,0
diff --git a/libc/sysv/consts/IP_RECVERR.S b/libc/sysv/consts/IP_RECVERR.S
deleted file mode 100644
index 0e861735a..000000000
--- a/libc/sysv/consts/IP_RECVERR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_RECVERR,11,11,0,0,0,0,0,75
diff --git a/libc/sysv/consts/IP_RECVOPTS.S b/libc/sysv/consts/IP_RECVOPTS.S
deleted file mode 100644
index 76f152929..000000000
--- a/libc/sysv/consts/IP_RECVOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_RECVOPTS,6,6,5,5,5,5,5,0
diff --git a/libc/sysv/consts/IP_RECVORIGDSTADDR.S b/libc/sysv/consts/IP_RECVORIGDSTADDR.S
deleted file mode 100644
index ebcad0265..000000000
--- a/libc/sysv/consts/IP_RECVORIGDSTADDR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_RECVORIGDSTADDR,20,20,0,0,27,0,0,0
diff --git a/libc/sysv/consts/IP_RECVRETOPTS.S b/libc/sysv/consts/IP_RECVRETOPTS.S
deleted file mode 100644
index 2eb706438..000000000
--- a/libc/sysv/consts/IP_RECVRETOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_RECVRETOPTS,7,7,6,6,6,6,6,0
diff --git a/libc/sysv/consts/IP_RETOPTS.S b/libc/sysv/consts/IP_RETOPTS.S
deleted file mode 100644
index 8056e7551..000000000
--- a/libc/sysv/consts/IP_RETOPTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_RETOPTS,7,7,8,8,8,8,8,0
diff --git a/libc/sysv/consts/IP_ROUTER_ALERT.S b/libc/sysv/consts/IP_ROUTER_ALERT.S
deleted file mode 100644
index f4306aef7..000000000
--- a/libc/sysv/consts/IP_ROUTER_ALERT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_ROUTER_ALERT,5,5,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_TRANSPARENT.S b/libc/sysv/consts/IP_TRANSPARENT.S
deleted file mode 100644
index 9dab2efa4..000000000
--- a/libc/sysv/consts/IP_TRANSPARENT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_TRANSPARENT,19,19,0,0,0,0,0,0
diff --git a/libc/sysv/consts/IP_UNBLOCK_SOURCE.S b/libc/sysv/consts/IP_UNBLOCK_SOURCE.S
deleted file mode 100644
index c33465f09..000000000
--- a/libc/sysv/consts/IP_UNBLOCK_SOURCE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_UNBLOCK_SOURCE,37,37,73,73,73,0,0,18
diff --git a/libc/sysv/consts/IP_UNICAST_IF.S b/libc/sysv/consts/IP_UNICAST_IF.S
deleted file mode 100644
index 8e6ffbb85..000000000
--- a/libc/sysv/consts/IP_UNICAST_IF.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_UNICAST_IF,50,50,0,0,0,0,0,31
diff --git a/libc/sysv/consts/IP_XFRM_POLICY.S b/libc/sysv/consts/IP_XFRM_POLICY.S
deleted file mode 100644
index c5ac226bc..000000000
--- a/libc/sysv/consts/IP_XFRM_POLICY.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon ip,IP_XFRM_POLICY,17,17,0,0,0,0,0,0
diff --git a/libc/sysv/consts/LINE_MAX.S b/libc/sysv/consts/LINE_MAX.S
deleted file mode 100644
index 38afae7a3..000000000
--- a/libc/sysv/consts/LINE_MAX.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,LINE_MAX,0x0800,0x0800,0x0800,0x0800,0x0800,0x0800,0x0800,0
diff --git a/libc/sysv/consts/LINKED_CMD_COMPLETE.S b/libc/sysv/consts/LINKED_CMD_COMPLETE.S
deleted file mode 100644
index cbfd020ff..000000000
--- a/libc/sysv/consts/LINKED_CMD_COMPLETE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,LINKED_CMD_COMPLETE,10,10,0,0,0,0,0,0
diff --git a/libc/sysv/consts/LINKED_FLG_CMD_COMPLETE.S b/libc/sysv/consts/LINKED_FLG_CMD_COMPLETE.S
deleted file mode 100644
index e1b654e9c..000000000
--- a/libc/sysv/consts/LINKED_FLG_CMD_COMPLETE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,LINKED_FLG_CMD_COMPLETE,11,11,0,0,0,0,0,0
diff --git a/libc/sysv/consts/LNKTYPE.S b/libc/sysv/consts/LNKTYPE.S
deleted file mode 100644
index 5c92f4df1..000000000
--- a/libc/sysv/consts/LNKTYPE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,LNKTYPE,49,49,49,49,49,49,49,0
diff --git a/libc/sysv/consts/LOCK_UNLOCK_CACHE.S b/libc/sysv/consts/LOCK_UNLOCK_CACHE.S
deleted file mode 100644
index 79f898e0f..000000000
--- a/libc/sysv/consts/LOCK_UNLOCK_CACHE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon lock,LOCK_UNLOCK_CACHE,54,54,0,0,0,0,0,0
diff --git a/libc/sysv/consts/L_INCR.S b/libc/sysv/consts/L_INCR.S
deleted file mode 100644
index 7fa6739c4..000000000
--- a/libc/sysv/consts/L_INCR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,L_INCR,1,1,1,1,1,1,1,0
diff --git a/libc/sysv/consts/L_SET.S b/libc/sysv/consts/L_SET.S
deleted file mode 100644
index 17fa679f8..000000000
--- a/libc/sysv/consts/L_SET.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,L_SET,0,0,0,0,0,0,0,0
diff --git a/libc/sysv/consts/L_XTND.S b/libc/sysv/consts/L_XTND.S
deleted file mode 100644
index d21b49d21..000000000
--- a/libc/sysv/consts/L_XTND.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,L_XTND,2,2,2,2,2,2,2,0
diff --git a/libc/sysv/consts/MAP_GROWSDOWN.S b/libc/sysv/consts/MAP_GROWSDOWN.S
deleted file mode 100644
index 62bed1141..000000000
--- a/libc/sysv/consts/MAP_GROWSDOWN.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon mmap,MAP_GROWSDOWN,0x00000100,0x00000100,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MATH_ERREXCEPT.S b/libc/sysv/consts/MATH_ERREXCEPT.S
deleted file mode 100644
index b4b21e1d4..000000000
--- a/libc/sysv/consts/MATH_ERREXCEPT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,MATH_ERREXCEPT,2,2,2,2,2,2,2,0
diff --git a/libc/sysv/consts/MATH_ERRNO.S b/libc/sysv/consts/MATH_ERRNO.S
deleted file mode 100644
index 1feafb8f4..000000000
--- a/libc/sysv/consts/MATH_ERRNO.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,MATH_ERRNO,1,1,1,1,1,1,1,0
diff --git a/libc/sysv/consts/MAXNAMLEN.S b/libc/sysv/consts/MAXNAMLEN.S
deleted file mode 100644
index 39e41287f..000000000
--- a/libc/sysv/consts/MAXNAMLEN.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,MAXNAMLEN,255,255,255,255,255,255,255,0
diff --git a/libc/sysv/consts/MAXQUOTAS.S b/libc/sysv/consts/MAXQUOTAS.S
deleted file mode 100644
index 6f75185e0..000000000
--- a/libc/sysv/consts/MAXQUOTAS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,MAXQUOTAS,2,2,2,2,2,2,2,0
diff --git a/libc/sysv/consts/MEDIUM_ERROR.S b/libc/sysv/consts/MEDIUM_ERROR.S
deleted file mode 100644
index 5197ba6e3..000000000
--- a/libc/sysv/consts/MEDIUM_ERROR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,MEDIUM_ERROR,3,3,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MEDIUM_SCAN.S b/libc/sysv/consts/MEDIUM_SCAN.S
deleted file mode 100644
index abe6fdede..000000000
--- a/libc/sysv/consts/MEDIUM_SCAN.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,MEDIUM_SCAN,56,56,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MREMAP_FIXED.S b/libc/sysv/consts/MREMAP_FIXED.S
deleted file mode 100644
index ac6a13656..000000000
--- a/libc/sysv/consts/MREMAP_FIXED.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon mremap,MREMAP_FIXED,2,2,2,2,2,2,2,2
diff --git a/libc/sysv/consts/MREMAP_MAYMOVE.S b/libc/sysv/consts/MREMAP_MAYMOVE.S
deleted file mode 100644
index 7e65b360a..000000000
--- a/libc/sysv/consts/MREMAP_MAYMOVE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon mremap,MREMAP_MAYMOVE,1,1,1,1,1,1,1,1
diff --git a/libc/sysv/consts/MSG_BATCH.S b/libc/sysv/consts/MSG_BATCH.S
deleted file mode 100644
index e171f4f2f..000000000
--- a/libc/sysv/consts/MSG_BATCH.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_BATCH,0x040000,0x040000,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MSG_BCAST.S b/libc/sysv/consts/MSG_BCAST.S
deleted file mode 100644
index 082634257..000000000
--- a/libc/sysv/consts/MSG_BCAST.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_BCAST,0,0,0,0,0,0x100,0x100,0
diff --git a/libc/sysv/consts/MSG_CMSG_CLOEXEC.S b/libc/sysv/consts/MSG_CMSG_CLOEXEC.S
deleted file mode 100644
index ea66034e3..000000000
--- a/libc/sysv/consts/MSG_CMSG_CLOEXEC.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_CMSG_CLOEXEC,0x40000000,0x40000000,0,0,0x040000,0x0800,0x0800,0
diff --git a/libc/sysv/consts/MSG_CONFIRM.S b/libc/sysv/consts/MSG_CONFIRM.S
deleted file mode 100644
index 1948be63a..000000000
--- a/libc/sysv/consts/MSG_CONFIRM.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_CONFIRM,0x0800,0x0800,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MSG_EOF.S b/libc/sysv/consts/MSG_EOF.S
deleted file mode 100644
index 3e8168a2a..000000000
--- a/libc/sysv/consts/MSG_EOF.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_EOF,0x0200,0x0200,0x0100,0x0100,0x0100,0,0,0
diff --git a/libc/sysv/consts/MSG_EOR.S b/libc/sysv/consts/MSG_EOR.S
deleted file mode 100644
index fe773b16a..000000000
--- a/libc/sysv/consts/MSG_EOR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_EOR,0x80,0x80,8,8,8,8,8,0
diff --git a/libc/sysv/consts/MSG_ERRQUEUE.S b/libc/sysv/consts/MSG_ERRQUEUE.S
deleted file mode 100644
index 02f1934ff..000000000
--- a/libc/sysv/consts/MSG_ERRQUEUE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_ERRQUEUE,0x2000,0x2000,0,0,0,0,0,0x1000
diff --git a/libc/sysv/consts/MSG_EXCEPT.S b/libc/sysv/consts/MSG_EXCEPT.S
deleted file mode 100644
index da072f0a9..000000000
--- a/libc/sysv/consts/MSG_EXCEPT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_EXCEPT,0x2000,0x2000,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MSG_FASTOPEN.S b/libc/sysv/consts/MSG_FASTOPEN.S
index ff034a75b..17aa7bab6 100644
--- a/libc/sysv/consts/MSG_FASTOPEN.S
+++ b/libc/sysv/consts/MSG_FASTOPEN.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_FASTOPEN,0x20000000,0x20000000,0,0,0,0,0,0
+.syscon msg,MSG_FASTOPEN,0x20000000,0x20000000,-1,-1,-1,-1,-1,-1
diff --git a/libc/sysv/consts/MSG_FIN.S b/libc/sysv/consts/MSG_FIN.S
deleted file mode 100644
index f0631e333..000000000
--- a/libc/sysv/consts/MSG_FIN.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_FIN,0x0200,0x0200,0x0100,0x0100,0x0100,0,0,0
diff --git a/libc/sysv/consts/MSG_INFO.S b/libc/sysv/consts/MSG_INFO.S
deleted file mode 100644
index d882e3a75..000000000
--- a/libc/sysv/consts/MSG_INFO.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_INFO,12,12,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MSG_MCAST.S b/libc/sysv/consts/MSG_MCAST.S
deleted file mode 100644
index 0f68f5321..000000000
--- a/libc/sysv/consts/MSG_MCAST.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_MCAST,0,0,0,0,0,0x200,0x200,0
diff --git a/libc/sysv/consts/MSG_MORE.S b/libc/sysv/consts/MSG_MORE.S
deleted file mode 100644
index fa8717d4f..000000000
--- a/libc/sysv/consts/MSG_MORE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_MORE,0x8000,0x8000,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MSG_NOERROR.S b/libc/sysv/consts/MSG_NOERROR.S
deleted file mode 100644
index 22764bb8d..000000000
--- a/libc/sysv/consts/MSG_NOERROR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_NOERROR,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0x1000,0
diff --git a/libc/sysv/consts/MSG_NOSIGNAL.S b/libc/sysv/consts/MSG_NOSIGNAL.S
index 48be7e922..1a0539eef 100644
--- a/libc/sysv/consts/MSG_NOSIGNAL.S
+++ b/libc/sysv/consts/MSG_NOSIGNAL.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_NOSIGNAL,0x4000,0x4000,0x80000,0x80000,0x020000,0x0400,0x0400,0
+.syscon msg,MSG_NOSIGNAL,0x4000,0x4000,0x80000,0x80000,0x020000,0x0400,0x0400,0x10000000
diff --git a/libc/sysv/consts/MSG_NOTIFICATION.S b/libc/sysv/consts/MSG_NOTIFICATION.S
deleted file mode 100644
index 7503b5a50..000000000
--- a/libc/sysv/consts/MSG_NOTIFICATION.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_NOTIFICATION,0x8000,0x8000,0,0,0x2000,0,0x4000,0
diff --git a/libc/sysv/consts/MSG_PARITY_ERROR.S b/libc/sysv/consts/MSG_PARITY_ERROR.S
deleted file mode 100644
index 7abd7fafd..000000000
--- a/libc/sysv/consts/MSG_PARITY_ERROR.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_PARITY_ERROR,9,9,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MSG_PROXY.S b/libc/sysv/consts/MSG_PROXY.S
deleted file mode 100644
index e6216ce64..000000000
--- a/libc/sysv/consts/MSG_PROXY.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_PROXY,0x10,0x10,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MSG_RST.S b/libc/sysv/consts/MSG_RST.S
deleted file mode 100644
index 3bed0246b..000000000
--- a/libc/sysv/consts/MSG_RST.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_RST,0x1000,0x1000,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MSG_STAT.S b/libc/sysv/consts/MSG_STAT.S
deleted file mode 100644
index cdee6a110..000000000
--- a/libc/sysv/consts/MSG_STAT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_STAT,11,11,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MSG_SYN.S b/libc/sysv/consts/MSG_SYN.S
deleted file mode 100644
index b57fbeb86..000000000
--- a/libc/sysv/consts/MSG_SYN.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_SYN,0x0400,0x0400,0,0,0,0,0,0
diff --git a/libc/sysv/consts/MSG_WAITFORONE.S b/libc/sysv/consts/MSG_WAITFORONE.S
deleted file mode 100644
index e89b311e2..000000000
--- a/libc/sysv/consts/MSG_WAITFORONE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon msg,MSG_WAITFORONE,0x010000,0x010000,0,0,0x080000,0,0x2000,0
diff --git a/libc/sysv/consts/NBBY.S b/libc/sysv/consts/NBBY.S
deleted file mode 100644
index 72b368fb5..000000000
--- a/libc/sysv/consts/NBBY.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,NBBY,8,8,8,8,8,8,8,0
diff --git a/libc/sysv/consts/NR_DQHASH.S b/libc/sysv/consts/NR_DQHASH.S
deleted file mode 100644
index c485c1cd4..000000000
--- a/libc/sysv/consts/NR_DQHASH.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,NR_DQHASH,43,43,0,0,0,0,0,0
diff --git a/libc/sysv/consts/NR_DQUOTS.S b/libc/sysv/consts/NR_DQUOTS.S
deleted file mode 100644
index 43ac329ef..000000000
--- a/libc/sysv/consts/NR_DQUOTS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,NR_DQUOTS,0x0100,0x0100,0,0,0,0,0,0
diff --git a/libc/sysv/consts/PERSISTENT_RESERVE_IN.S b/libc/sysv/consts/PERSISTENT_RESERVE_IN.S
deleted file mode 100644
index de777b3c6..000000000
--- a/libc/sysv/consts/PERSISTENT_RESERVE_IN.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,PERSISTENT_RESERVE_IN,94,94,0,0,0,0,0,0
diff --git a/libc/sysv/consts/PERSISTENT_RESERVE_OUT.S b/libc/sysv/consts/PERSISTENT_RESERVE_OUT.S
deleted file mode 100644
index 791a63475..000000000
--- a/libc/sysv/consts/PERSISTENT_RESERVE_OUT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,PERSISTENT_RESERVE_OUT,95,95,0,0,0,0,0,0
diff --git a/libc/sysv/consts/PRELIM.S b/libc/sysv/consts/PRELIM.S
deleted file mode 100644
index 0d97154e6..000000000
--- a/libc/sysv/consts/PRELIM.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,PRELIM,1,1,1,1,1,1,1,0
diff --git a/libc/sysv/consts/PROT_GUARD.S b/libc/sysv/consts/PROT_GUARD.S
new file mode 100644
index 000000000..e04cb73ee
--- /dev/null
+++ b/libc/sysv/consts/PROT_GUARD.S
@@ -0,0 +1,2 @@
+#include "libc/sysv/consts/syscon.internal.h"
+.syscon mprot,PROT_GUARD,0,0,0,0,0,0,0,0x100
diff --git a/libc/sysv/consts/REGTYPE.S b/libc/sysv/consts/REGTYPE.S
deleted file mode 100644
index 23ea4bcc2..000000000
--- a/libc/sysv/consts/REGTYPE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,REGTYPE,48,48,48,48,48,48,48,0
diff --git a/libc/sysv/consts/RES_PRF_CLASS.S b/libc/sysv/consts/RES_PRF_CLASS.S
deleted file mode 100644
index ec3d33e78..000000000
--- a/libc/sysv/consts/RES_PRF_CLASS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,RES_PRF_CLASS,4,4,4,4,4,4,4,0
diff --git a/libc/sysv/consts/RHF_GUARANTEE_START_INIT.S b/libc/sysv/consts/RHF_GUARANTEE_START_INIT.S
deleted file mode 100644
index 6cfba6bb4..000000000
--- a/libc/sysv/consts/RHF_GUARANTEE_START_INIT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,RHF_GUARANTEE_START_INIT,0x80,0x80,0,0,0,0,0,0
diff --git a/libc/sysv/consts/RHF_NO_LIBRARY_REPLACEMENT.S b/libc/sysv/consts/RHF_NO_LIBRARY_REPLACEMENT.S
deleted file mode 100644
index 7129c23c6..000000000
--- a/libc/sysv/consts/RHF_NO_LIBRARY_REPLACEMENT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,RHF_NO_LIBRARY_REPLACEMENT,4,4,0,0,0,0,0,0
diff --git a/libc/sysv/consts/RLIMIT_AS.S b/libc/sysv/consts/RLIMIT_AS.S
index 03c20c065..7c5fc850c 100644
--- a/libc/sysv/consts/RLIMIT_AS.S
+++ b/libc/sysv/consts/RLIMIT_AS.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon rlimit,RLIMIT_AS,9	,9,5,5,10,2,10,0
+.syscon rlimit,RLIMIT_AS,9,9,5,5,10,2,10,0
diff --git a/libc/sysv/consts/RRQ.S b/libc/sysv/consts/RRQ.S
deleted file mode 100644
index 2d714fad7..000000000
--- a/libc/sysv/consts/RRQ.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,RRQ,1,1,1,1,1,1,1,0
diff --git a/libc/sysv/consts/RTF_NOFORWARD.S b/libc/sysv/consts/RTF_NOFORWARD.S
deleted file mode 100644
index bd1a57d66..000000000
--- a/libc/sysv/consts/RTF_NOFORWARD.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,RTF_NOFORWARD,0x1000,0x1000,0,0,0,0,0,0
diff --git a/libc/sysv/consts/RTF_NOPMTUDISC.S b/libc/sysv/consts/RTF_NOPMTUDISC.S
deleted file mode 100644
index b31c84352..000000000
--- a/libc/sysv/consts/RTF_NOPMTUDISC.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,RTF_NOPMTUDISC,0x4000,0x4000,0,0,0,0,0,0
diff --git a/libc/sysv/consts/SARMAG.S b/libc/sysv/consts/SARMAG.S
deleted file mode 100644
index cae2eee96..000000000
--- a/libc/sysv/consts/SARMAG.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SARMAG,8,8,8,8,8,8,8,0
diff --git a/libc/sysv/consts/SEGSIZE.S b/libc/sysv/consts/SEGSIZE.S
deleted file mode 100644
index ae243d93f..000000000
--- a/libc/sysv/consts/SEGSIZE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SEGSIZE,0x0200,0x0200,0x0200,0x0200,0x0200,0x0200,0x0200,0
diff --git a/libc/sysv/consts/SEND_DIAGNOSTIC.S b/libc/sysv/consts/SEND_DIAGNOSTIC.S
deleted file mode 100644
index 83da87ff2..000000000
--- a/libc/sysv/consts/SEND_DIAGNOSTIC.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SEND_DIAGNOSTIC,29,29,0,0,0,0,0,0
diff --git a/libc/sysv/consts/SEND_VOLUME_TAG.S b/libc/sysv/consts/SEND_VOLUME_TAG.S
deleted file mode 100644
index 4303e011d..000000000
--- a/libc/sysv/consts/SEND_VOLUME_TAG.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SEND_VOLUME_TAG,182,182,0,0,0,0,0,0
diff --git a/libc/sysv/consts/SET_LIMITS.S b/libc/sysv/consts/SET_LIMITS.S
deleted file mode 100644
index de5e6f1b8..000000000
--- a/libc/sysv/consts/SET_LIMITS.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SET_LIMITS,51,51,0,0,0,0,0,0
diff --git a/libc/sysv/consts/SET_WINDOW.S b/libc/sysv/consts/SET_WINDOW.S
deleted file mode 100644
index 5c39025c8..000000000
--- a/libc/sysv/consts/SET_WINDOW.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SET_WINDOW,36,36,0,0,0,0,0,0
diff --git a/libc/sysv/consts/SFD_CLOEXEC.S b/libc/sysv/consts/SFD_CLOEXEC.S
deleted file mode 100644
index 8cdb0e1ce..000000000
--- a/libc/sysv/consts/SFD_CLOEXEC.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SFD_CLOEXEC,0x080000,0x080000,0,0,0,0,0,0
diff --git a/libc/sysv/consts/SFD_NONBLOCK.S b/libc/sysv/consts/SFD_NONBLOCK.S
deleted file mode 100644
index 7c81b0a84..000000000
--- a/libc/sysv/consts/SFD_NONBLOCK.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SFD_NONBLOCK,0x0800,0x0800,0,0,0,0,0,0
diff --git a/libc/sysv/consts/SIGEV_NONE.S b/libc/sysv/consts/SIGEV_NONE.S
deleted file mode 100644
index f36a315c9..000000000
--- a/libc/sysv/consts/SIGEV_NONE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SIGEV_NONE,1,1,0,0,0,0,0,0
diff --git a/libc/sysv/consts/SIGEV_SIGNAL.S b/libc/sysv/consts/SIGEV_SIGNAL.S
deleted file mode 100644
index 083f4d54c..000000000
--- a/libc/sysv/consts/SIGEV_SIGNAL.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SIGEV_SIGNAL,0,0,1,1,1,0,1,0
diff --git a/libc/sysv/consts/SIGEV_THREAD.S b/libc/sysv/consts/SIGEV_THREAD.S
deleted file mode 100644
index 0b4173693..000000000
--- a/libc/sysv/consts/SIGEV_THREAD.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SIGEV_THREAD,2,2,3,3,2,0,2,0
diff --git a/libc/sysv/consts/SO_BROADCAST.S b/libc/sysv/consts/SO_BROADCAST.S
index 47cf8c307..7b8652b81 100644
--- a/libc/sysv/consts/SO_BROADCAST.S
+++ b/libc/sysv/consts/SO_BROADCAST.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon so,SO_BROADCAST,6,6,0x20,0x20,0x20,0x20,0x20,0x20
+.syscon so,SO_BROADCAST,6,6,32,32,32,32,32,32
diff --git a/libc/sysv/consts/SO_DONTROUTE.S b/libc/sysv/consts/SO_DONTROUTE.S
index 0b29ceb10..4bd9d3746 100644
--- a/libc/sysv/consts/SO_DONTROUTE.S
+++ b/libc/sysv/consts/SO_DONTROUTE.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon so,SO_DONTROUTE,5,5,0x10,0x10,0x10,0x10,0x10,0x10
+.syscon so,SO_DONTROUTE,5,5,16,16,16,16,16,16
diff --git a/libc/sysv/consts/SO_LINGER.S b/libc/sysv/consts/SO_LINGER.S
index 6b40dbf92..f839d09e0 100644
--- a/libc/sysv/consts/SO_LINGER.S
+++ b/libc/sysv/consts/SO_LINGER.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon so,SO_LINGER,13,13,0x1080,0x1080,0x80,0x80,0x80,0x80
+.syscon so,SO_LINGER,13,13,4224,4224,128,128,128,128
diff --git a/libc/sysv/consts/SO_OOBINLINE.S b/libc/sysv/consts/SO_OOBINLINE.S
index b7fa38130..0d3690b39 100644
--- a/libc/sysv/consts/SO_OOBINLINE.S
+++ b/libc/sysv/consts/SO_OOBINLINE.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon so,SO_OOBINLINE,10,10,0x0100,0x0100,0x0100,0x0100,0x0100,0x0100
+.syscon so,SO_OOBINLINE,10,10,256,256,256,256,256,256
diff --git a/libc/sysv/consts/SO_REUSEPORT.S b/libc/sysv/consts/SO_REUSEPORT.S
index c1b3e8dd0..ea4cdc97d 100644
--- a/libc/sysv/consts/SO_REUSEPORT.S
+++ b/libc/sysv/consts/SO_REUSEPORT.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon so,SO_REUSEPORT,15,15,0x0200,0x0200,0x0200,0x0200,0x0200,0
+.syscon so,SO_REUSEPORT,15,15,512,512,512,512,512,0
diff --git a/libc/sysv/consts/SO_USELOOPBACK.S b/libc/sysv/consts/SO_USELOOPBACK.S
index c9b46d3f7..6b58c7841 100644
--- a/libc/sysv/consts/SO_USELOOPBACK.S
+++ b/libc/sysv/consts/SO_USELOOPBACK.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon so,SO_USELOOPBACK,0,0,0x40,0x40,0x40,0x40,0x40,0x40
+.syscon so,SO_USELOOPBACK,0,0,64,64,64,64,64,64
diff --git a/libc/sysv/consts/SUBCMDMASK.S b/libc/sysv/consts/SUBCMDMASK.S
deleted file mode 100644
index 84d9e6756..000000000
--- a/libc/sysv/consts/SUBCMDMASK.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SUBCMDMASK,255,255,255,255,255,255,255,0
diff --git a/libc/sysv/consts/SUBCMDSHIFT.S b/libc/sysv/consts/SUBCMDSHIFT.S
deleted file mode 100644
index bb41322bc..000000000
--- a/libc/sysv/consts/SUBCMDSHIFT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SUBCMDSHIFT,8,8,8,8,8,8,8,0
diff --git a/libc/sysv/consts/SYMTYPE.S b/libc/sysv/consts/SYMTYPE.S
deleted file mode 100644
index a285acd5e..000000000
--- a/libc/sysv/consts/SYMTYPE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,SYMTYPE,50,50,50,50,50,50,50,0
diff --git a/libc/sysv/consts/TCP_CONGESTION.S b/libc/sysv/consts/TCP_CONGESTION.S
index aed94356e..5817b15c7 100644
--- a/libc/sysv/consts/TCP_CONGESTION.S
+++ b/libc/sysv/consts/TCP_CONGESTION.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon tcp,TCP_CONGESTION,13,13,0,0,0x40,0,0,0
+.syscon tcp,TCP_CONGESTION,13,13,0,0,64,0,0,0
diff --git a/libc/sysv/consts/TCP_INFO.S b/libc/sysv/consts/TCP_INFO.S
index a1aba3722..ed51f0771 100644
--- a/libc/sysv/consts/TCP_INFO.S
+++ b/libc/sysv/consts/TCP_INFO.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon tcp,TCP_INFO,11,11,0,0,0x20,0,9,0
+.syscon tcp,TCP_INFO,11,11,0x200,0x200,32,9,9,0
diff --git a/libc/sysv/consts/TCP_KEEPCNT.S b/libc/sysv/consts/TCP_KEEPCNT.S
index 97c36dcfc..4bc84b47a 100644
--- a/libc/sysv/consts/TCP_KEEPCNT.S
+++ b/libc/sysv/consts/TCP_KEEPCNT.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon tcp,TCP_KEEPCNT,6,6,0x102,0x102,0x400,0,6,0
+.syscon tcp,TCP_KEEPCNT,6,6,0x102,0x102,0x400,0,6,16
diff --git a/libc/sysv/consts/TCP_KEEPIDLE.S b/libc/sysv/consts/TCP_KEEPIDLE.S
index 5751644c2..f5886f4cc 100644
--- a/libc/sysv/consts/TCP_KEEPIDLE.S
+++ b/libc/sysv/consts/TCP_KEEPIDLE.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon tcp,TCP_KEEPIDLE,4,4,0,0,0x100,0,3,0
+.syscon tcp,TCP_KEEPIDLE,4,4,0,0,0x100,0,3,3
diff --git a/libc/sysv/consts/TCP_KEEPINTVL.S b/libc/sysv/consts/TCP_KEEPINTVL.S
index 3b94ca585..6f94429df 100644
--- a/libc/sysv/consts/TCP_KEEPINTVL.S
+++ b/libc/sysv/consts/TCP_KEEPINTVL.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon tcp,TCP_KEEPINTVL,5,5,0x101,0x101,0x200,0,5,0
+.syscon tcp,TCP_KEEPINTVL,5,5,0x101,0x101,0x200,0,5,17
diff --git a/libc/sysv/consts/TCP_MD5SIG.S b/libc/sysv/consts/TCP_MD5SIG.S
index 7ee7876b3..fc1388aa4 100644
--- a/libc/sysv/consts/TCP_MD5SIG.S
+++ b/libc/sysv/consts/TCP_MD5SIG.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon tcp,TCP_MD5SIG,14,14,0,0,0x10,4,16,0
+.syscon tcp,TCP_MD5SIG,14,14,0,0,16,4,16,0
diff --git a/libc/sysv/consts/TGEXEC.S b/libc/sysv/consts/TGEXEC.S
deleted file mode 100644
index 67216cff5..000000000
--- a/libc/sysv/consts/TGEXEC.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TGEXEC,8,8,8,8,8,8,8,0
diff --git a/libc/sysv/consts/TGREAD.S b/libc/sysv/consts/TGREAD.S
deleted file mode 100644
index 0d8ac6ba5..000000000
--- a/libc/sysv/consts/TGREAD.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TGREAD,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0
diff --git a/libc/sysv/consts/TGWRITE.S b/libc/sysv/consts/TGWRITE.S
deleted file mode 100644
index f4b54f296..000000000
--- a/libc/sysv/consts/TGWRITE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TGWRITE,0x10,0x10,0x10,0x10,0x10,0x10,0x10,0
diff --git a/libc/sysv/consts/TMAGLEN.S b/libc/sysv/consts/TMAGLEN.S
deleted file mode 100644
index 132be740f..000000000
--- a/libc/sysv/consts/TMAGLEN.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TMAGLEN,6,6,6,6,6,6,6,0
diff --git a/libc/sysv/consts/TOEXEC.S b/libc/sysv/consts/TOEXEC.S
deleted file mode 100644
index 55f00072e..000000000
--- a/libc/sysv/consts/TOEXEC.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TOEXEC,1,1,1,1,1,1,1,0
diff --git a/libc/sysv/consts/TOREAD.S b/libc/sysv/consts/TOREAD.S
deleted file mode 100644
index 802694d71..000000000
--- a/libc/sysv/consts/TOREAD.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TOREAD,4,4,4,4,4,4,4,0
diff --git a/libc/sysv/consts/TOWRITE.S b/libc/sysv/consts/TOWRITE.S
deleted file mode 100644
index 14bb0c7ca..000000000
--- a/libc/sysv/consts/TOWRITE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TOWRITE,2,2,2,2,2,2,2,0
diff --git a/libc/sysv/consts/TRANSIENT.S b/libc/sysv/consts/TRANSIENT.S
deleted file mode 100644
index c7f7807e2..000000000
--- a/libc/sysv/consts/TRANSIENT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TRANSIENT,4,4,4,4,4,4,4,0
diff --git a/libc/sysv/consts/TSGID.S b/libc/sysv/consts/TSGID.S
deleted file mode 100644
index 253a91ac7..000000000
--- a/libc/sysv/consts/TSGID.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TSGID,0x0400,0x0400,0x0400,0x0400,0x0400,0x0400,0x0400,0
diff --git a/libc/sysv/consts/TSUID.S b/libc/sysv/consts/TSUID.S
deleted file mode 100644
index c369b647b..000000000
--- a/libc/sysv/consts/TSUID.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TSUID,0x0800,0x0800,0x0800,0x0800,0x0800,0x0800,0x0800,0
diff --git a/libc/sysv/consts/TSVTX.S b/libc/sysv/consts/TSVTX.S
deleted file mode 100644
index 8269bb0ff..000000000
--- a/libc/sysv/consts/TSVTX.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TSVTX,0x0200,0x0200,0x0200,0x0200,0x0200,0x0200,0x0200,0
diff --git a/libc/sysv/consts/TUEXEC.S b/libc/sysv/consts/TUEXEC.S
deleted file mode 100644
index 0a810cd15..000000000
--- a/libc/sysv/consts/TUEXEC.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TUEXEC,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0
diff --git a/libc/sysv/consts/TUREAD.S b/libc/sysv/consts/TUREAD.S
deleted file mode 100644
index aa151e389..000000000
--- a/libc/sysv/consts/TUREAD.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TUREAD,0x0100,0x0100,0x0100,0x0100,0x0100,0x0100,0x0100,0
diff --git a/libc/sysv/consts/TUWRITE.S b/libc/sysv/consts/TUWRITE.S
deleted file mode 100644
index 46e307643..000000000
--- a/libc/sysv/consts/TUWRITE.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TUWRITE,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0
diff --git a/libc/sysv/consts/TVERSLEN.S b/libc/sysv/consts/TVERSLEN.S
deleted file mode 100644
index d09006b08..000000000
--- a/libc/sysv/consts/TVERSLEN.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,TVERSLEN,2,2,2,2,2,2,2,0
diff --git a/libc/sysv/consts/WORD_BIT.S b/libc/sysv/consts/WORD_BIT.S
deleted file mode 100644
index 1dc138b99..000000000
--- a/libc/sysv/consts/WORD_BIT.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,WORD_BIT,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0
diff --git a/libc/sysv/consts/WRQ.S b/libc/sysv/consts/WRQ.S
deleted file mode 100644
index c101d655b..000000000
--- a/libc/sysv/consts/WRQ.S
+++ /dev/null
@@ -1,2 +0,0 @@
-#include "libc/sysv/consts/syscon.internal.h"
-.syscon misc,WRQ,2,2,2,2,2,2,2,0
diff --git a/libc/sysv/consts/_MINSIGSTKSZ.S b/libc/sysv/consts/_MINSIGSTKSZ.S
index b55cbcca9..94d7efe53 100644
--- a/libc/sysv/consts/_MINSIGSTKSZ.S
+++ b/libc/sysv/consts/_MINSIGSTKSZ.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon limits,_MINSIGSTKSZ,2048,2048,32768,32768,4096,12288,8192,2048
+.syscon limits,_MINSIGSTKSZ,2048,6144,8192,32768,6656,14336,8192,2048
diff --git a/libc/sysv/consts/_SIGSTKSZ.S b/libc/sysv/consts/_SIGSTKSZ.S
index 6347f2877..8484e6596 100644
--- a/libc/sysv/consts/_SIGSTKSZ.S
+++ b/libc/sysv/consts/_SIGSTKSZ.S
@@ -1,2 +1,2 @@
 #include "libc/sysv/consts/syscon.internal.h"
-.syscon limits,_SIGSTKSZ,8192,2048,131072,131072,36864,28672,40960,8192
+.syscon limits,_SIGSTKSZ,10240,10240,131072,131072,36864,28672,40960,10240
diff --git a/libc/sysv/consts/clock.h b/libc/sysv/consts/clock.h
index ae4f010e0..eefa79217 100644
--- a/libc/sysv/consts/clock.h
+++ b/libc/sysv/consts/clock.h
@@ -2,29 +2,26 @@
 #define COSMOPOLITAN_LIBC_SYSV_CONSTS_CLOCK_H_
 COSMOPOLITAN_C_START_
 
-extern const int CLOCK_BOOTTIME;
-extern const int CLOCK_BOOTTIME_ALARM;
+extern int CLOCK_REALTIME_COARSE;
 extern const int CLOCK_MONOTONIC;
-extern const int CLOCK_MONOTONIC_COARSE;
-extern const int CLOCK_MONOTONIC_FAST;
-extern const int CLOCK_MONOTONIC_PRECISE;
-extern const int CLOCK_MONOTONIC_RAW;
-extern const int CLOCK_PROCESS_CPUTIME_ID;
-extern const int CLOCK_PROF;
-extern const int CLOCK_REALTIME_ALARM;
-extern const int CLOCK_REALTIME_COARSE;
-extern const int CLOCK_REALTIME_FAST;
-extern const int CLOCK_REALTIME_PRECISE;
-extern const int CLOCK_SECOND;
-extern const int CLOCK_TAI;
+extern int CLOCK_MONOTONIC_RAW;
+extern int CLOCK_MONOTONIC_COARSE;
 extern const int CLOCK_THREAD_CPUTIME_ID;
-extern const int CLOCK_UPTIME;
-extern const int CLOCK_UPTIME_FAST;
-extern const int CLOCK_UPTIME_PRECISE;
+extern const int CLOCK_PROCESS_CPUTIME_ID;
+extern const int CLOCK_BOOTTIME;
 
 COSMOPOLITAN_C_END_
 
-#define CLOCK_REALTIME  0
-#define CLOCK_MONOTONIC CLOCK_MONOTONIC
+#define CLOCK_REALTIME        0
+#define CLOCK_REALTIME_COARSE CLOCK_REALTIME_COARSE
+
+#define CLOCK_MONOTONIC        CLOCK_MONOTONIC
+#define CLOCK_MONOTONIC_RAW    CLOCK_MONOTONIC_RAW
+#define CLOCK_MONOTONIC_COARSE CLOCK_MONOTONIC_COARSE
+
+#define CLOCK_THREAD_CPUTIME_ID  CLOCK_THREAD_CPUTIME_ID
+#define CLOCK_PROCESS_CPUTIME_ID CLOCK_PROCESS_CPUTIME_ID
+
+#define CLOCK_BOOTTIME CLOCK_BOOTTIME
 
 #endif /* COSMOPOLITAN_LIBC_SYSV_CONSTS_CLOCK_H_ */
diff --git a/libc/sysv/consts/epoll.h b/libc/sysv/consts/epoll.h
deleted file mode 100644
index a2d11e643..000000000
--- a/libc/sysv/consts/epoll.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_SYSV_CONSTS_EPOLL_H_
-#define COSMOPOLITAN_LIBC_SYSV_CONSTS_EPOLL_H_
-#include "libc/sysv/consts/o.h"
-
-#define EPOLL_CTL_ADD 1
-#define EPOLL_CTL_DEL 2
-#define EPOLL_CTL_MOD 3
-
-#define EPOLLIN        1
-#define EPOLLPRI       2
-#define EPOLLOUT       4
-#define EPOLLERR       8
-#define EPOLLHUP       0x10
-#define EPOLLRDNORM    0x40
-#define EPOLLRDBAND    0x80
-#define EPOLLWRNORM    0x0100
-#define EPOLLWRBAND    0x0200
-#define EPOLLMSG       0x0400
-#define EPOLLRDHUP     0x2000
-#define EPOLLEXCLUSIVE 0x10000000
-#define EPOLLWAKEUP    0x20000000
-#define EPOLLONESHOT   0x40000000
-#define EPOLLET        0x80000000
-
-COSMOPOLITAN_C_START_
-
-extern const int EPOLL_CLOEXEC;
-#define EPOLL_CLOEXEC O_CLOEXEC
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_SYSV_CONSTS_EPOLL_H_ */
diff --git a/libc/sysv/consts/icmp6.h b/libc/sysv/consts/icmp6.h
index 43ce452b8..56a63774e 100644
--- a/libc/sysv/consts/icmp6.h
+++ b/libc/sysv/consts/icmp6.h
@@ -1,37 +1,5 @@
 #ifndef COSMOPOLITAN_LIBC_SYSV_CONSTS_ICMP6_H_
 #define COSMOPOLITAN_LIBC_SYSV_CONSTS_ICMP6_H_
-
-#define ICMP6_DST_UNREACH                ICMP6_DST_UNREACH
-#define ICMP6_DST_UNREACH_ADDR           ICMP6_DST_UNREACH_ADDR
-#define ICMP6_DST_UNREACH_ADMIN          ICMP6_DST_UNREACH_ADMIN
-#define ICMP6_DST_UNREACH_BEYONDSCOPE    ICMP6_DST_UNREACH_BEYONDSCOPE
-#define ICMP6_DST_UNREACH_NOPORT         ICMP6_DST_UNREACH_NOPORT
-#define ICMP6_DST_UNREACH_NOROUTE        ICMP6_DST_UNREACH_NOROUTE
-#define ICMP6_ECHO_REPLY                 ICMP6_ECHO_REPLY
-#define ICMP6_ECHO_REQUEST               ICMP6_ECHO_REQUEST
-#define ICMP6_FILTER                     ICMP6_FILTER
-#define ICMP6_INFOMSG_MASK               ICMP6_INFOMSG_MASK
-#define ICMP6_PACKET_TOO_BIG             ICMP6_PACKET_TOO_BIG
-#define ICMP6_PARAMPROB_HEADER           ICMP6_PARAMPROB_HEADER
-#define ICMP6_PARAMPROB_NEXTHEADER       ICMP6_PARAMPROB_NEXTHEADER
-#define ICMP6_PARAMPROB_OPTION           ICMP6_PARAMPROB_OPTION
-#define ICMP6_PARAM_PROB                 ICMP6_PARAM_PROB
-#define ICMP6_ROUTER_RENUMBERING         ICMP6_ROUTER_RENUMBERING
-#define ICMP6_RR_FLAGS_FORCEAPPLY        ICMP6_RR_FLAGS_FORCEAPPLY
-#define ICMP6_RR_FLAGS_PREVDONE          ICMP6_RR_FLAGS_PREVDONE
-#define ICMP6_RR_FLAGS_REQRESULT         ICMP6_RR_FLAGS_REQRESULT
-#define ICMP6_RR_FLAGS_SPECSITE          ICMP6_RR_FLAGS_SPECSITE
-#define ICMP6_RR_FLAGS_TEST              ICMP6_RR_FLAGS_TEST
-#define ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME ICMP6_RR_PCOUSE_FLAGS_DECRPLTIME
-#define ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME ICMP6_RR_PCOUSE_FLAGS_DECRVLTIME
-#define ICMP6_RR_PCOUSE_RAFLAGS_AUTO     ICMP6_RR_PCOUSE_RAFLAGS_AUTO
-#define ICMP6_RR_PCOUSE_RAFLAGS_ONLINK   ICMP6_RR_PCOUSE_RAFLAGS_ONLINK
-#define ICMP6_RR_RESULT_FLAGS_FORBIDDEN  ICMP6_RR_RESULT_FLAGS_FORBIDDEN
-#define ICMP6_RR_RESULT_FLAGS_OOB        ICMP6_RR_RESULT_FLAGS_OOB
-#define ICMP6_TIME_EXCEEDED              ICMP6_TIME_EXCEEDED
-#define ICMP6_TIME_EXCEED_REASSEMBLY     ICMP6_TIME_EXCEED_REASSEMBLY
-#define ICMP6_TIME_EXCEED_TRANSIT        ICMP6_TIME_EXCEED_TRANSIT
-
 COSMOPOLITAN_C_START_
 
 extern const uint8_t ICMP6_DST_UNREACH;
diff --git a/libc/sysv/consts/ip.h b/libc/sysv/consts/ip.h
index 3d3c82b08..68c4d8b3f 100644
--- a/libc/sysv/consts/ip.h
+++ b/libc/sysv/consts/ip.h
@@ -2,105 +2,34 @@
 #define COSMOPOLITAN_LIBC_SYSV_CONSTS_IP_H_
 COSMOPOLITAN_C_START_
 
-extern const int IP_ADD_MEMBERSHIP;
-extern const int IP_ADD_SOURCE_MEMBERSHIP;
-extern const int IP_BIND_ADDRESS_NO_PORT;
-extern const int IP_BLOCK_SOURCE;
-extern const int IP_CHECKSUM;
-extern const int IP_DEFAULT_MULTICAST_LOOP;
-extern const int IP_DEFAULT_MULTICAST_TTL;
-extern const int IP_DROP_MEMBERSHIP;
-extern const int IP_DROP_SOURCE_MEMBERSHIP;
-extern const int IP_FREEBIND;
-extern const int IP_HDRINCL;
-extern const int IP_IPSEC_POLICY;
-extern const int IP_MAX_MEMBERSHIPS;
-extern const int IP_MINTTL;
-extern const int IP_MSFILTER;
+extern const int IP_TOS;
+extern const int IP_TTL;
 extern const int IP_MTU;
-extern const int IP_MTU_DISCOVER;
-extern const int IP_MULTICAST_ALL;
+extern const int IP_HDRINCL;
+extern const int IP_OPTIONS;
+extern const int IP_RECVTTL;
+extern const int IP_ADD_MEMBERSHIP;
+extern const int IP_DROP_MEMBERSHIP;
 extern const int IP_MULTICAST_IF;
 extern const int IP_MULTICAST_LOOP;
 extern const int IP_MULTICAST_TTL;
-extern const int IP_NODEFRAG;
-extern const int IP_OPTIONS;
-extern const int IP_ORIGDSTADDR;
-extern const int IP_PASSSEC;
 extern const int IP_PKTINFO;
-extern const int IP_PKTOPTIONS;
-extern const int IP_PMTUDISC;
-extern const int IP_PMTUDISC_DO;
-extern const int IP_PMTUDISC_DONT;
-extern const int IP_PMTUDISC_INTERFACE;
-extern const int IP_PMTUDISC_OMIT;
-extern const int IP_PMTUDISC_PROBE;
-extern const int IP_PMTUDISC_WANT;
-extern const int IP_RECVDSTADDR;
-extern const int IP_RECVERR;
-extern const int IP_RECVOPTS;
-extern const int IP_RECVORIGDSTADDR;
-extern const int IP_RECVRETOPTS;
 extern const int IP_RECVTOS;
-extern const int IP_RECVTTL;
-extern const int IP_RETOPTS;
-extern const int IP_ROUTER_ALERT;
-extern const int IP_TOS;
-extern const int IP_TRANSPARENT;
-extern const int IP_TTL;
-extern const int IP_UNBLOCK_SOURCE;
-extern const int IP_UNICAST_IF;
-extern const int IP_XFRM_POLICY;
 
-#define IP_ADD_MEMBERSHIP         IP_ADD_MEMBERSHIP
-#define IP_ADD_SOURCE_MEMBERSHIP  IP_ADD_SOURCE_MEMBERSHIP
-#define IP_BIND_ADDRESS_NO_PORT   IP_BIND_ADDRESS_NO_PORT
-#define IP_BLOCK_SOURCE           IP_BLOCK_SOURCE
-#define IP_CHECKSUM               IP_CHECKSUM
-#define IP_DEFAULT_MULTICAST_LOOP IP_DEFAULT_MULTICAST_LOOP
-#define IP_DEFAULT_MULTICAST_TTL  IP_DEFAULT_MULTICAST_TTL
-#define IP_DROP_MEMBERSHIP        IP_DROP_MEMBERSHIP
-#define IP_DROP_SOURCE_MEMBERSHIP IP_DROP_SOURCE_MEMBERSHIP
-#define IP_FREEBIND               IP_FREEBIND
-#define IP_HDRINCL                IP_HDRINCL
-#define IP_IPSEC_POLICY           IP_IPSEC_POLICY
-#define IP_MAX_MEMBERSHIPS        IP_MAX_MEMBERSHIPS
-#define IP_MINTTL                 IP_MINTTL
-#define IP_MSFILTER               IP_MSFILTER
-#define IP_MTU                    IP_MTU
-#define IP_MTU_DISCOVER           IP_MTU_DISCOVER
-#define IP_MULTICAST_ALL          IP_MULTICAST_ALL
-#define IP_MULTICAST_IF           IP_MULTICAST_IF
-#define IP_MULTICAST_LOOP         IP_MULTICAST_LOOP
-#define IP_MULTICAST_TTL          IP_MULTICAST_TTL
-#define IP_NODEFRAG               IP_NODEFRAG
-#define IP_OPTIONS                IP_OPTIONS
-#define IP_ORIGDSTADDR            IP_ORIGDSTADDR
-#define IP_PASSSEC                IP_PASSSEC
-#define IP_PKTINFO                IP_PKTINFO
-#define IP_PKTOPTIONS             IP_PKTOPTIONS
-#define IP_PMTUDISC               IP_PMTUDISC
-#define IP_PMTUDISC_DO            IP_PMTUDISC_DO
-#define IP_PMTUDISC_DONT          IP_PMTUDISC_DONT
-#define IP_PMTUDISC_INTERFACE     IP_PMTUDISC_INTERFACE
-#define IP_PMTUDISC_OMIT          IP_PMTUDISC_OMIT
-#define IP_PMTUDISC_PROBE         IP_PMTUDISC_PROBE
-#define IP_PMTUDISC_WANT          IP_PMTUDISC_WANT
-#define IP_RECVDSTADDR            IP_RECVDSTADDR
-#define IP_RECVERR                IP_RECVERR
-#define IP_RECVOPTS               IP_RECVOPTS
-#define IP_RECVORIGDSTADDR        IP_RECVORIGDSTADDR
-#define IP_RECVRETOPTS            IP_RECVRETOPTS
-#define IP_RECVTOS                IP_RECVTOS
-#define IP_RECVTTL                IP_RECVTTL
-#define IP_RETOPTS                IP_RETOPTS
-#define IP_ROUTER_ALERT           IP_ROUTER_ALERT
-#define IP_TOS                    IP_TOS
-#define IP_TRANSPARENT            IP_TRANSPARENT
-#define IP_TTL                    IP_TTL
-#define IP_UNBLOCK_SOURCE         IP_UNBLOCK_SOURCE
-#define IP_UNICAST_IF             IP_UNICAST_IF
-#define IP_XFRM_POLICY            IP_XFRM_POLICY
+#define IP_TOS             IP_TOS
+#define IP_TTL             IP_TTL
+#define IP_MTU             IP_MTU
+#define IP_HDRINCL         IP_HDRINCL
+#define IP_OPTIONS         IP_OPTIONS
+#define IP_RECVTTL         IP_RECVTTL
+#define IP_ADD_MEMBERSHIP  IP_ADD_MEMBERSHIP
+#define IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP
+#define IP_MULTICAST_IF    IP_MULTICAST_IF
+#define IP_MULTICAST_LOOP  IP_MULTICAST_LOOP
+#define IP_MULTICAST_TTL   IP_MULTICAST_TTL
+
+#define IP_DEFAULT_MULTICAST_TTL  1
+#define IP_DEFAULT_MULTICAST_LOOP 1
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_SYSV_CONSTS_IP_H_ */
diff --git a/libc/sysv/consts/ipv6.h b/libc/sysv/consts/ipv6.h
index 4e5c5471c..febc3389b 100644
--- a/libc/sysv/consts/ipv6.h
+++ b/libc/sysv/consts/ipv6.h
@@ -2,125 +2,39 @@
 #define COSMOPOLITAN_LIBC_SYSV_CONSTS_IPV6_H_
 COSMOPOLITAN_C_START_
 
-extern const int IPV6_2292DSTOPTS;
-extern const int IPV6_2292HOPLIMIT;
-extern const int IPV6_2292HOPOPTS;
-extern const int IPV6_2292PKTINFO;
-extern const int IPV6_2292PKTOPTIONS;
-extern const int IPV6_2292RTHDR;
-extern const int IPV6_ADDRFORM;
-extern const int IPV6_ADD_MEMBERSHIP;
-extern const int IPV6_AUTHHDR;
-extern const int IPV6_AUTOFLOWLABEL;
+extern const int IPV6_V6ONLY;
 extern const int IPV6_CHECKSUM;
-extern const int IPV6_DONTFRAG;
-extern const int IPV6_DROP_MEMBERSHIP;
-extern const int IPV6_DSTOPTS;
-extern const int IPV6_HDRINCL;
-extern const int IPV6_HOPLIMIT;
-extern const int IPV6_HOPOPTS;
-extern const int IPV6_IPSEC_POLICY;
-extern const int IPV6_JOIN_ANYCAST;
 extern const int IPV6_JOIN_GROUP;
-extern const int IPV6_LEAVE_ANYCAST;
 extern const int IPV6_LEAVE_GROUP;
-extern const int IPV6_MINHOPCOUNT;
-extern const int IPV6_MTU;
-extern const int IPV6_MTU_DISCOVER;
 extern const int IPV6_MULTICAST_HOPS;
 extern const int IPV6_MULTICAST_IF;
 extern const int IPV6_MULTICAST_LOOP;
-extern const int IPV6_NEXTHOP;
-extern const int IPV6_ORIGDSTADDR;
-extern const int IPV6_PATHMTU;
-extern const int IPV6_PKTINFO;
-extern const int IPV6_PMTUDISC_DO;
-extern const int IPV6_PMTUDISC_DONT;
-extern const int IPV6_PMTUDISC_INTERFACE;
-extern const int IPV6_PMTUDISC_OMIT;
-extern const int IPV6_PMTUDISC_PROBE;
-extern const int IPV6_PMTUDISC_WANT;
-extern const int IPV6_RECVDSTOPTS;
-extern const int IPV6_RECVERR;
-extern const int IPV6_RECVHOPLIMIT;
-extern const int IPV6_RECVHOPOPTS;
-extern const int IPV6_RECVORIGDSTADDR;
-extern const int IPV6_RECVPATHMTU;
-extern const int IPV6_RECVPKTINFO;
-extern const int IPV6_RECVRTHDR;
-extern const int IPV6_RECVTCLASS;
-extern const int IPV6_ROUTER_ALERT;
-extern const int IPV6_RTHDR;
-extern const int IPV6_RTHDRDSTOPTS;
-extern const int IPV6_RTHDR_LOOSE;
-extern const int IPV6_RTHDR_STRICT;
-extern const int IPV6_RTHDR_TYPE_0;
-extern const int IPV6_RXDSTOPTS;
-extern const int IPV6_RXHOPOPTS;
-extern const int IPV6_TCLASS;
 extern const int IPV6_UNICAST_HOPS;
-extern const int IPV6_V6ONLY;
-extern const int IPV6_XFRM_POLICY;
+extern const int IPV6_RECVTCLASS;
+extern const int IPV6_TCLASS;
+extern const int IPV6_DONTFRAG;
+extern const int IPV6_HOPLIMIT;
+extern const int IPV6_HOPOPTS;
+extern const int IPV6_PKTINFO;
+extern const int IPV6_RECVRTHDR;
+extern const int IPV6_RTHDR;
 
-#define IPV6_2292DSTOPTS        IPV6_2292DSTOPTS
-#define IPV6_2292HOPLIMIT       IPV6_2292HOPLIMIT
-#define IPV6_2292HOPOPTS        IPV6_2292HOPOPTS
-#define IPV6_2292PKTINFO        IPV6_2292PKTINFO
-#define IPV6_2292PKTOPTIONS     IPV6_2292PKTOPTIONS
-#define IPV6_2292RTHDR          IPV6_2292RTHDR
-#define IPV6_ADDRFORM           IPV6_ADDRFORM
-#define IPV6_ADD_MEMBERSHIP     IPV6_ADD_MEMBERSHIP
-#define IPV6_AUTHHDR            IPV6_AUTHHDR
-#define IPV6_AUTOFLOWLABEL      IPV6_AUTOFLOWLABEL
-#define IPV6_CHECKSUM           IPV6_CHECKSUM
-#define IPV6_DONTFRAG           IPV6_DONTFRAG
-#define IPV6_DROP_MEMBERSHIP    IPV6_DROP_MEMBERSHIP
-#define IPV6_DSTOPTS            IPV6_DSTOPTS
-#define IPV6_HDRINCL            IPV6_HDRINCL
-#define IPV6_HOPLIMIT           IPV6_HOPLIMIT
-#define IPV6_HOPOPTS            IPV6_HOPOPTS
-#define IPV6_IPSEC_POLICY       IPV6_IPSEC_POLICY
-#define IPV6_JOIN_ANYCAST       IPV6_JOIN_ANYCAST
-#define IPV6_JOIN_GROUP         IPV6_JOIN_GROUP
-#define IPV6_LEAVE_ANYCAST      IPV6_LEAVE_ANYCAST
-#define IPV6_LEAVE_GROUP        IPV6_LEAVE_GROUP
-#define IPV6_MINHOPCOUNT        IPV6_MINHOPCOUNT
-#define IPV6_MTU                IPV6_MTU
-#define IPV6_MTU_DISCOVER       IPV6_MTU_DISCOVER
-#define IPV6_MULTICAST_HOPS     IPV6_MULTICAST_HOPS
-#define IPV6_MULTICAST_IF       IPV6_MULTICAST_IF
-#define IPV6_MULTICAST_LOOP     IPV6_MULTICAST_LOOP
-#define IPV6_NEXTHOP            IPV6_NEXTHOP
-#define IPV6_ORIGDSTADDR        IPV6_ORIGDSTADDR
-#define IPV6_PATHMTU            IPV6_PATHMTU
-#define IPV6_PKTINFO            IPV6_PKTINFO
-#define IPV6_PMTUDISC_DO        IPV6_PMTUDISC_DO
-#define IPV6_PMTUDISC_DONT      IPV6_PMTUDISC_DONT
-#define IPV6_PMTUDISC_INTERFACE IPV6_PMTUDISC_INTERFACE
-#define IPV6_PMTUDISC_OMIT      IPV6_PMTUDISC_OMIT
-#define IPV6_PMTUDISC_PROBE     IPV6_PMTUDISC_PROBE
-#define IPV6_PMTUDISC_WANT      IPV6_PMTUDISC_WANT
-#define IPV6_RECVDSTOPTS        IPV6_RECVDSTOPTS
-#define IPV6_RECVERR            IPV6_RECVERR
-#define IPV6_RECVHOPLIMIT       IPV6_RECVHOPLIMIT
-#define IPV6_RECVHOPOPTS        IPV6_RECVHOPOPTS
-#define IPV6_RECVORIGDSTADDR    IPV6_RECVORIGDSTADDR
-#define IPV6_RECVPATHMTU        IPV6_RECVPATHMTU
-#define IPV6_RECVPKTINFO        IPV6_RECVPKTINFO
-#define IPV6_RECVRTHDR          IPV6_RECVRTHDR
-#define IPV6_RECVTCLASS         IPV6_RECVTCLASS
-#define IPV6_ROUTER_ALERT       IPV6_ROUTER_ALERT
-#define IPV6_RTHDR              IPV6_RTHDR
-#define IPV6_RTHDRDSTOPTS       IPV6_RTHDRDSTOPTS
-#define IPV6_RTHDR_LOOSE        IPV6_RTHDR_LOOSE
-#define IPV6_RTHDR_STRICT       IPV6_RTHDR_STRICT
-#define IPV6_RTHDR_TYPE_0       IPV6_RTHDR_TYPE_0
-#define IPV6_RXDSTOPTS          IPV6_RXDSTOPTS
-#define IPV6_RXHOPOPTS          IPV6_RXHOPOPTS
-#define IPV6_TCLASS             IPV6_TCLASS
-#define IPV6_UNICAST_HOPS       IPV6_UNICAST_HOPS
-#define IPV6_V6ONLY             IPV6_V6ONLY
-#define IPV6_XFRM_POLICY        IPV6_XFRM_POLICY
+#define IPV6_V6ONLY         IPV6_V6ONLY
+#define IPV6_CHECKSUM       IPV6_CHECKSUM
+#define IPV6_JOIN_GROUP     IPV6_JOIN_GROUP
+#define IPV6_LEAVE_GROUP    IPV6_LEAVE_GROUP
+#define IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS
+#define IPV6_MULTICAST_IF   IPV6_MULTICAST_IF
+#define IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP
+#define IPV6_UNICAST_HOPS   IPV6_UNICAST_HOPS
+#define IPV6_RECVTCLASS     IPV6_RECVTCLASS
+#define IPV6_TCLASS         IPV6_TCLASS
+#define IPV6_DONTFRAG       IPV6_DONTFRAG
+#define IPV6_HOPLIMIT       IPV6_HOPLIMIT
+#define IPV6_HOPOPTS        IPV6_HOPOPTS
+#define IPV6_PKTINFO        IPV6_PKTINFO
+#define IPV6_RECVRTHDR      IPV6_RECVRTHDR
+#define IPV6_RTHDR          IPV6_RTHDR
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_SYSV_CONSTS_IPV6_H_ */
diff --git a/libc/sysv/consts/msg.h b/libc/sysv/consts/msg.h
index 74deaca26..3694fc6f6 100644
--- a/libc/sysv/consts/msg.h
+++ b/libc/sysv/consts/msg.h
@@ -2,41 +2,18 @@
 #define COSMOPOLITAN_LIBC_SYSV_CONSTS_MSG_H_
 COSMOPOLITAN_C_START_
 
-extern const int MSG_BATCH;
-extern const int MSG_BCAST;
-extern const int MSG_CMSG_CLOEXEC;
-extern const int MSG_CONFIRM;
-extern const int MSG_CTRUNC;
-extern const int MSG_DONTROUTE;
 extern const int MSG_DONTWAIT;
-extern const int MSG_EOF;
-extern const int MSG_EOR;
-extern const int MSG_ERRQUEUE;
-extern const int MSG_EXCEPT;
-extern const int MSG_FASTOPEN;
-extern const int MSG_FIN;
-extern const int MSG_INFO;
-extern const int MSG_MCAST;
-extern const int MSG_MORE;
-extern const int MSG_NOERROR;
-extern const int MSG_NOSIGNAL;
-extern const int MSG_NOTIFICATION;
-extern const int MSG_OOB;
-extern const int MSG_PARITY_ERROR;
-extern const int MSG_PEEK;
-extern const int MSG_PROXY;
-extern const int MSG_RST;
-extern const int MSG_STAT;
-extern const int MSG_SYN;
-extern const int MSG_TRUNC;
 extern const int MSG_WAITALL;
-extern const int MSG_WAITFORONE;
+extern const int MSG_NOSIGNAL;
+extern const int MSG_TRUNC;
+extern const int MSG_CTRUNC;
+extern const int MSG_FASTOPEN; /* linux only */
 
 #define MSG_OOB       1
 #define MSG_PEEK      2
 #define MSG_DONTROUTE 4
 #define MSG_DONTWAIT  MSG_DONTWAIT
-#define MSG_FASTOPEN  MSG_FASTOPEN
+#define MSG_NOSIGNAL  MSG_NOSIGNAL
 #define MSG_WAITALL   MSG_WAITALL
 #define MSG_TRUNC     MSG_TRUNC
 #define MSG_CTRUNC    MSG_CTRUNC
diff --git a/libc/sysv/consts/prot.h b/libc/sysv/consts/prot.h
index 032a6b1a7..ea026f869 100644
--- a/libc/sysv/consts/prot.h
+++ b/libc/sysv/consts/prot.h
@@ -3,10 +3,7 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-extern const int PROT_NONE;
-extern const int PROT_READ;
-extern const int PROT_WRITE;
-extern const int PROT_EXEC;
+extern const int PROT_GUARD;
 
 COSMOPOLITAN_C_END_
 #endif /* !(__ASSEMBLER__ + __LINKER__ + 0) */
diff --git a/libc/sysv/consts/sig.h b/libc/sysv/consts/sig.h
index 3a66c711b..d0c6808d2 100644
--- a/libc/sysv/consts/sig.h
+++ b/libc/sysv/consts/sig.h
@@ -2,45 +2,25 @@
 #define COSMOPOLITAN_LIBC_SYSV_CONSTS_SIG_H_
 COSMOPOLITAN_C_START_
 
-extern const int SIGABRT;
-extern const int SIGALRM;
 extern const int SIGBUS;
 extern const int SIGTHR;
 extern const int SIGCHLD;
 extern const int SIGCONT;
 extern const int SIGEMT;
-extern const int SIGFPE;
-extern const int SIGHUP;
-extern const int SIGILL;
 extern const int SIGINFO;
-extern const int SIGINT;
 extern const int SIGIO;
-extern const int SIGIOT;
-extern const int SIGKILL;
-extern const int SIGPIPE;
 extern const int SIGPOLL;
-extern const int SIGPROF;
 extern const int SIGPWR;
-extern const int SIGQUIT;
 extern const int SIGRTMAX;
 extern const int SIGRTMIN;
-extern const int SIGSEGV;
 extern const int SIGSTKFLT;
 extern const int SIGSTOP;
 extern const int SIGSYS;
-extern const int SIGTERM;
-extern const int SIGTRAP;
 extern const int SIGTSTP;
-extern const int SIGTTIN;
-extern const int SIGTTOU;
 extern const int SIGUNUSED;
 extern const int SIGURG;
 extern const int SIGUSR1;
 extern const int SIGUSR2;
-extern const int SIGVTALRM;
-extern const int SIGWINCH;
-extern const int SIGXCPU;
-extern const int SIGXFSZ;
 
 extern const int SIG_BLOCK;
 extern const int SIG_SETMASK;
diff --git a/libc/sysv/consts/ss.h b/libc/sysv/consts/ss.h
index ef83ec6ec..626a696d6 100644
--- a/libc/sysv/consts/ss.h
+++ b/libc/sysv/consts/ss.h
@@ -8,7 +8,7 @@ extern const int _MINSIGSTKSZ;
 
 COSMOPOLITAN_C_END_
 
-#define SIGSTKSZ    32768
+#define SIGSTKSZ    32768 /* just itself believed to be safe */
 #define MINSIGSTKSZ 32768 /* xnu defines the highest minimum */
 #define SS_ONSTACK  1
 #define SS_DISABLE  SS_DISABLE
diff --git a/libc/sysv/consts/syscon.internal.h b/libc/sysv/consts/syscon.internal.h
index 33b97c9a0..396f0b671 100644
--- a/libc/sysv/consts/syscon.internal.h
+++ b/libc/sysv/consts/syscon.internal.h
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 // clang-format off
 
 #ifdef __x86_64__
diff --git a/libc/sysv/errfun.S b/libc/sysv/errfun.S
index debb98d2f..e1ef6908a 100644
--- a/libc/sysv/errfun.S
+++ b/libc/sysv/errfun.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 __errfun:
diff --git a/libc/sysv/errfuns/e2big.S b/libc/sysv/errfuns/e2big.S
index 32ac86542..7b6fd6a20 100644
--- a/libc/sysv/errfuns/e2big.S
+++ b/libc/sysv/errfuns/e2big.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eacces.S b/libc/sysv/errfuns/eacces.S
index 2ba289170..5657ed497 100644
--- a/libc/sysv/errfuns/eacces.S
+++ b/libc/sysv/errfuns/eacces.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eaddrinuse.S b/libc/sysv/errfuns/eaddrinuse.S
index 4d8c41d34..77dee3e32 100644
--- a/libc/sysv/errfuns/eaddrinuse.S
+++ b/libc/sysv/errfuns/eaddrinuse.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eaddrnotavail.S b/libc/sysv/errfuns/eaddrnotavail.S
index 101b936a6..28a3a3998 100644
--- a/libc/sysv/errfuns/eaddrnotavail.S
+++ b/libc/sysv/errfuns/eaddrnotavail.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eadv.S b/libc/sysv/errfuns/eadv.S
index aeadda509..acf8e5f86 100644
--- a/libc/sysv/errfuns/eadv.S
+++ b/libc/sysv/errfuns/eadv.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eafnosupport.S b/libc/sysv/errfuns/eafnosupport.S
index 0f4fa0b5a..4e4787cc8 100644
--- a/libc/sysv/errfuns/eafnosupport.S
+++ b/libc/sysv/errfuns/eafnosupport.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eagain.S b/libc/sysv/errfuns/eagain.S
index 5124a43f1..e19df5a4f 100644
--- a/libc/sysv/errfuns/eagain.S
+++ b/libc/sysv/errfuns/eagain.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ealready.S b/libc/sysv/errfuns/ealready.S
index e8b32b0eb..4f39c44d8 100644
--- a/libc/sysv/errfuns/ealready.S
+++ b/libc/sysv/errfuns/ealready.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ebade.S b/libc/sysv/errfuns/ebade.S
index 8d0a0c19f..0eb25fca3 100644
--- a/libc/sysv/errfuns/ebade.S
+++ b/libc/sysv/errfuns/ebade.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ebadf.S b/libc/sysv/errfuns/ebadf.S
index 693fe7c46..34318ce18 100644
--- a/libc/sysv/errfuns/ebadf.S
+++ b/libc/sysv/errfuns/ebadf.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ebadfd.S b/libc/sysv/errfuns/ebadfd.S
index fb4fc502d..a2900bc3d 100644
--- a/libc/sysv/errfuns/ebadfd.S
+++ b/libc/sysv/errfuns/ebadfd.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ebadmsg.S b/libc/sysv/errfuns/ebadmsg.S
index e650ed296..5781527bd 100644
--- a/libc/sysv/errfuns/ebadmsg.S
+++ b/libc/sysv/errfuns/ebadmsg.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ebadr.S b/libc/sysv/errfuns/ebadr.S
index e8f9ab68d..f80316c45 100644
--- a/libc/sysv/errfuns/ebadr.S
+++ b/libc/sysv/errfuns/ebadr.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ebadrqc.S b/libc/sysv/errfuns/ebadrqc.S
index e5fd44915..1debb93f5 100644
--- a/libc/sysv/errfuns/ebadrqc.S
+++ b/libc/sysv/errfuns/ebadrqc.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ebadslt.S b/libc/sysv/errfuns/ebadslt.S
index 4bc407c0e..38a091a3e 100644
--- a/libc/sysv/errfuns/ebadslt.S
+++ b/libc/sysv/errfuns/ebadslt.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ebusy.S b/libc/sysv/errfuns/ebusy.S
index 54a436001..a677d254b 100644
--- a/libc/sysv/errfuns/ebusy.S
+++ b/libc/sysv/errfuns/ebusy.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ecanceled.S b/libc/sysv/errfuns/ecanceled.S
index 58007cb2d..ac974c3f4 100644
--- a/libc/sysv/errfuns/ecanceled.S
+++ b/libc/sysv/errfuns/ecanceled.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/echild.S b/libc/sysv/errfuns/echild.S
index e3e79409b..7733922f5 100644
--- a/libc/sysv/errfuns/echild.S
+++ b/libc/sysv/errfuns/echild.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/echrng.S b/libc/sysv/errfuns/echrng.S
index 0ffa5c922..0f20dda56 100644
--- a/libc/sysv/errfuns/echrng.S
+++ b/libc/sysv/errfuns/echrng.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ecomm.S b/libc/sysv/errfuns/ecomm.S
index 1a9a98286..4afe7326b 100644
--- a/libc/sysv/errfuns/ecomm.S
+++ b/libc/sysv/errfuns/ecomm.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/econnaborted.S b/libc/sysv/errfuns/econnaborted.S
index ec62e3e67..7f8c2737f 100644
--- a/libc/sysv/errfuns/econnaborted.S
+++ b/libc/sysv/errfuns/econnaborted.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/econnrefused.S b/libc/sysv/errfuns/econnrefused.S
index b16e4ce73..20adf6b88 100644
--- a/libc/sysv/errfuns/econnrefused.S
+++ b/libc/sysv/errfuns/econnrefused.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/econnreset.S b/libc/sysv/errfuns/econnreset.S
index 0c8fd94f4..8255f0bdc 100644
--- a/libc/sysv/errfuns/econnreset.S
+++ b/libc/sysv/errfuns/econnreset.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/edeadlk.S b/libc/sysv/errfuns/edeadlk.S
index caf4dbc2f..b812e07e9 100644
--- a/libc/sysv/errfuns/edeadlk.S
+++ b/libc/sysv/errfuns/edeadlk.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/edestaddrreq.S b/libc/sysv/errfuns/edestaddrreq.S
index 74dd51f96..bd3b8d56f 100644
--- a/libc/sysv/errfuns/edestaddrreq.S
+++ b/libc/sysv/errfuns/edestaddrreq.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/edom.S b/libc/sysv/errfuns/edom.S
index c26449ac2..a3f40bb7c 100644
--- a/libc/sysv/errfuns/edom.S
+++ b/libc/sysv/errfuns/edom.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/edotdot.S b/libc/sysv/errfuns/edotdot.S
index e1a347a3a..6cdc94739 100644
--- a/libc/sysv/errfuns/edotdot.S
+++ b/libc/sysv/errfuns/edotdot.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/edquot.S b/libc/sysv/errfuns/edquot.S
index 0e3e6fe79..2d62f6124 100644
--- a/libc/sysv/errfuns/edquot.S
+++ b/libc/sysv/errfuns/edquot.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eexist.S b/libc/sysv/errfuns/eexist.S
index d1fb3a314..65cc2e363 100644
--- a/libc/sysv/errfuns/eexist.S
+++ b/libc/sysv/errfuns/eexist.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/efault.S b/libc/sysv/errfuns/efault.S
index a219fff84..802d9f12f 100644
--- a/libc/sysv/errfuns/efault.S
+++ b/libc/sysv/errfuns/efault.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/efbig.S b/libc/sysv/errfuns/efbig.S
index 0d614e720..32be5b137 100644
--- a/libc/sysv/errfuns/efbig.S
+++ b/libc/sysv/errfuns/efbig.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ehostdown.S b/libc/sysv/errfuns/ehostdown.S
index 55a766ca9..b472f021a 100644
--- a/libc/sysv/errfuns/ehostdown.S
+++ b/libc/sysv/errfuns/ehostdown.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ehostunreach.S b/libc/sysv/errfuns/ehostunreach.S
index bc5c311f0..8fa84fca1 100644
--- a/libc/sysv/errfuns/ehostunreach.S
+++ b/libc/sysv/errfuns/ehostunreach.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ehwpoison.S b/libc/sysv/errfuns/ehwpoison.S
index d1d261565..d7df790b1 100644
--- a/libc/sysv/errfuns/ehwpoison.S
+++ b/libc/sysv/errfuns/ehwpoison.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eidrm.S b/libc/sysv/errfuns/eidrm.S
index 0c0d72542..3ba2f2bca 100644
--- a/libc/sysv/errfuns/eidrm.S
+++ b/libc/sysv/errfuns/eidrm.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eilseq.S b/libc/sysv/errfuns/eilseq.S
index d34482cea..25fdac2c6 100644
--- a/libc/sysv/errfuns/eilseq.S
+++ b/libc/sysv/errfuns/eilseq.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/einprogress.S b/libc/sysv/errfuns/einprogress.S
index 9d356fd2a..db22b1bc6 100644
--- a/libc/sysv/errfuns/einprogress.S
+++ b/libc/sysv/errfuns/einprogress.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eintr.S b/libc/sysv/errfuns/eintr.S
index e6a3f88d3..96d03d28a 100644
--- a/libc/sysv/errfuns/eintr.S
+++ b/libc/sysv/errfuns/eintr.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/einval.S b/libc/sysv/errfuns/einval.S
index 537af95c8..1b23f8ba1 100644
--- a/libc/sysv/errfuns/einval.S
+++ b/libc/sysv/errfuns/einval.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eio.S b/libc/sysv/errfuns/eio.S
index cdf541c95..dade87a54 100644
--- a/libc/sysv/errfuns/eio.S
+++ b/libc/sysv/errfuns/eio.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eisconn.S b/libc/sysv/errfuns/eisconn.S
index 148423224..36db72604 100644
--- a/libc/sysv/errfuns/eisconn.S
+++ b/libc/sysv/errfuns/eisconn.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eisdir.S b/libc/sysv/errfuns/eisdir.S
index 83e775f51..533071086 100644
--- a/libc/sysv/errfuns/eisdir.S
+++ b/libc/sysv/errfuns/eisdir.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eisnam.S b/libc/sysv/errfuns/eisnam.S
index 4450ca1ea..a8b632d20 100644
--- a/libc/sysv/errfuns/eisnam.S
+++ b/libc/sysv/errfuns/eisnam.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ekeyexpired.S b/libc/sysv/errfuns/ekeyexpired.S
index 89f4507bc..810d2078f 100644
--- a/libc/sysv/errfuns/ekeyexpired.S
+++ b/libc/sysv/errfuns/ekeyexpired.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ekeyrejected.S b/libc/sysv/errfuns/ekeyrejected.S
index fda4019bd..874b25707 100644
--- a/libc/sysv/errfuns/ekeyrejected.S
+++ b/libc/sysv/errfuns/ekeyrejected.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/ekeyrevoked.S b/libc/sysv/errfuns/ekeyrevoked.S
index d8e2e11c2..fa5b4ce5c 100644
--- a/libc/sysv/errfuns/ekeyrevoked.S
+++ b/libc/sysv/errfuns/ekeyrevoked.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/el2hlt.S b/libc/sysv/errfuns/el2hlt.S
index 5462d3ec9..b8400dca8 100644
--- a/libc/sysv/errfuns/el2hlt.S
+++ b/libc/sysv/errfuns/el2hlt.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/el2nsync.S b/libc/sysv/errfuns/el2nsync.S
index bb249b131..bbf443613 100644
--- a/libc/sysv/errfuns/el2nsync.S
+++ b/libc/sysv/errfuns/el2nsync.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/el3hlt.S b/libc/sysv/errfuns/el3hlt.S
index 40535b6d6..c527a2cf4 100644
--- a/libc/sysv/errfuns/el3hlt.S
+++ b/libc/sysv/errfuns/el3hlt.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/el3rst.S b/libc/sysv/errfuns/el3rst.S
index 036afd48e..b277a12dd 100644
--- a/libc/sysv/errfuns/el3rst.S
+++ b/libc/sysv/errfuns/el3rst.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/elibacc.S b/libc/sysv/errfuns/elibacc.S
index b598c2e47..ecaa787ce 100644
--- a/libc/sysv/errfuns/elibacc.S
+++ b/libc/sysv/errfuns/elibacc.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/elibbad.S b/libc/sysv/errfuns/elibbad.S
index 4a0f7f72b..6929d6c18 100644
--- a/libc/sysv/errfuns/elibbad.S
+++ b/libc/sysv/errfuns/elibbad.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/elibexec.S b/libc/sysv/errfuns/elibexec.S
index 6b5093216..141f1acef 100644
--- a/libc/sysv/errfuns/elibexec.S
+++ b/libc/sysv/errfuns/elibexec.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/elibmax.S b/libc/sysv/errfuns/elibmax.S
index 73dc1d570..5738b1ebd 100644
--- a/libc/sysv/errfuns/elibmax.S
+++ b/libc/sysv/errfuns/elibmax.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/elibscn.S b/libc/sysv/errfuns/elibscn.S
index fd3fbe245..730a3da62 100644
--- a/libc/sysv/errfuns/elibscn.S
+++ b/libc/sysv/errfuns/elibscn.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/elnrng.S b/libc/sysv/errfuns/elnrng.S
index 0e0e37ed4..7db38cca6 100644
--- a/libc/sysv/errfuns/elnrng.S
+++ b/libc/sysv/errfuns/elnrng.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eloop.S b/libc/sysv/errfuns/eloop.S
index faef0e95c..e7edbbc92 100644
--- a/libc/sysv/errfuns/eloop.S
+++ b/libc/sysv/errfuns/eloop.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/emediumtype.S b/libc/sysv/errfuns/emediumtype.S
index 448080938..0d7de3b51 100644
--- a/libc/sysv/errfuns/emediumtype.S
+++ b/libc/sysv/errfuns/emediumtype.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/emfile.S b/libc/sysv/errfuns/emfile.S
index 6adb57077..a7f1d6e2b 100644
--- a/libc/sysv/errfuns/emfile.S
+++ b/libc/sysv/errfuns/emfile.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/emlink.S b/libc/sysv/errfuns/emlink.S
index 8c6b7d95a..e0d810f9c 100644
--- a/libc/sysv/errfuns/emlink.S
+++ b/libc/sysv/errfuns/emlink.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/emsgsize.S b/libc/sysv/errfuns/emsgsize.S
index 9870b85a1..d2c22cb06 100644
--- a/libc/sysv/errfuns/emsgsize.S
+++ b/libc/sysv/errfuns/emsgsize.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/emultihop.S b/libc/sysv/errfuns/emultihop.S
index 27140db9f..cb54b9520 100644
--- a/libc/sysv/errfuns/emultihop.S
+++ b/libc/sysv/errfuns/emultihop.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enametoolong.S b/libc/sysv/errfuns/enametoolong.S
index d46f2bfa1..d085fc6bf 100644
--- a/libc/sysv/errfuns/enametoolong.S
+++ b/libc/sysv/errfuns/enametoolong.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enavail.S b/libc/sysv/errfuns/enavail.S
index d7aa15d49..a86a5b386 100644
--- a/libc/sysv/errfuns/enavail.S
+++ b/libc/sysv/errfuns/enavail.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enetdown.S b/libc/sysv/errfuns/enetdown.S
index 7850a5892..fe4f2f908 100644
--- a/libc/sysv/errfuns/enetdown.S
+++ b/libc/sysv/errfuns/enetdown.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enetreset.S b/libc/sysv/errfuns/enetreset.S
index fd6cf0c53..31126c73b 100644
--- a/libc/sysv/errfuns/enetreset.S
+++ b/libc/sysv/errfuns/enetreset.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enetunreach.S b/libc/sysv/errfuns/enetunreach.S
index 36a6ee69e..ec730c637 100644
--- a/libc/sysv/errfuns/enetunreach.S
+++ b/libc/sysv/errfuns/enetunreach.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enfile.S b/libc/sysv/errfuns/enfile.S
index a2b5157dd..5df56837a 100644
--- a/libc/sysv/errfuns/enfile.S
+++ b/libc/sysv/errfuns/enfile.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enoano.S b/libc/sysv/errfuns/enoano.S
index f3a713901..81724c4b3 100644
--- a/libc/sysv/errfuns/enoano.S
+++ b/libc/sysv/errfuns/enoano.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enobufs.S b/libc/sysv/errfuns/enobufs.S
index 7936a1e1f..3ba3a8b9c 100644
--- a/libc/sysv/errfuns/enobufs.S
+++ b/libc/sysv/errfuns/enobufs.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enocsi.S b/libc/sysv/errfuns/enocsi.S
index ab63ad071..c6e6fdd22 100644
--- a/libc/sysv/errfuns/enocsi.S
+++ b/libc/sysv/errfuns/enocsi.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enodata.S b/libc/sysv/errfuns/enodata.S
index e5fd06425..4394c5f8b 100644
--- a/libc/sysv/errfuns/enodata.S
+++ b/libc/sysv/errfuns/enodata.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enodev.S b/libc/sysv/errfuns/enodev.S
index 1be5d5846..da1741b1d 100644
--- a/libc/sysv/errfuns/enodev.S
+++ b/libc/sysv/errfuns/enodev.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enoent.S b/libc/sysv/errfuns/enoent.S
index 3929a214d..4bd569d9d 100644
--- a/libc/sysv/errfuns/enoent.S
+++ b/libc/sysv/errfuns/enoent.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enoexec.S b/libc/sysv/errfuns/enoexec.S
index 30cee1e8a..4b6f00228 100644
--- a/libc/sysv/errfuns/enoexec.S
+++ b/libc/sysv/errfuns/enoexec.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enokey.S b/libc/sysv/errfuns/enokey.S
index 399aa97c9..5c5c20048 100644
--- a/libc/sysv/errfuns/enokey.S
+++ b/libc/sysv/errfuns/enokey.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enolck.S b/libc/sysv/errfuns/enolck.S
index ceda33862..9d5b995e9 100644
--- a/libc/sysv/errfuns/enolck.S
+++ b/libc/sysv/errfuns/enolck.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enolink.S b/libc/sysv/errfuns/enolink.S
index 189d8ad7b..e35ae060e 100644
--- a/libc/sysv/errfuns/enolink.S
+++ b/libc/sysv/errfuns/enolink.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enomedium.S b/libc/sysv/errfuns/enomedium.S
index c7a6893ec..3bf1573fb 100644
--- a/libc/sysv/errfuns/enomedium.S
+++ b/libc/sysv/errfuns/enomedium.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enomem.S b/libc/sysv/errfuns/enomem.S
index d9a7050c8..62a49eb7c 100644
--- a/libc/sysv/errfuns/enomem.S
+++ b/libc/sysv/errfuns/enomem.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enomsg.S b/libc/sysv/errfuns/enomsg.S
index 0307c3ec2..49d558667 100644
--- a/libc/sysv/errfuns/enomsg.S
+++ b/libc/sysv/errfuns/enomsg.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enonet.S b/libc/sysv/errfuns/enonet.S
index fc2e5468c..e84f00121 100644
--- a/libc/sysv/errfuns/enonet.S
+++ b/libc/sysv/errfuns/enonet.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enopkg.S b/libc/sysv/errfuns/enopkg.S
index 3b08e87a5..5431b0c9e 100644
--- a/libc/sysv/errfuns/enopkg.S
+++ b/libc/sysv/errfuns/enopkg.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enoprotoopt.S b/libc/sysv/errfuns/enoprotoopt.S
index 80fca7bb5..8ffec6963 100644
--- a/libc/sysv/errfuns/enoprotoopt.S
+++ b/libc/sysv/errfuns/enoprotoopt.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enospc.S b/libc/sysv/errfuns/enospc.S
index 69023893d..afbe6a497 100644
--- a/libc/sysv/errfuns/enospc.S
+++ b/libc/sysv/errfuns/enospc.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enosr.S b/libc/sysv/errfuns/enosr.S
index 9d7119e53..289c4b645 100644
--- a/libc/sysv/errfuns/enosr.S
+++ b/libc/sysv/errfuns/enosr.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enostr.S b/libc/sysv/errfuns/enostr.S
index 6705b7155..e9f64241e 100644
--- a/libc/sysv/errfuns/enostr.S
+++ b/libc/sysv/errfuns/enostr.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enosys.S b/libc/sysv/errfuns/enosys.S
index c0f6e7c36..4f2132726 100644
--- a/libc/sysv/errfuns/enosys.S
+++ b/libc/sysv/errfuns/enosys.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enotblk.S b/libc/sysv/errfuns/enotblk.S
index c4812cb03..c04ba77b4 100644
--- a/libc/sysv/errfuns/enotblk.S
+++ b/libc/sysv/errfuns/enotblk.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enotconn.S b/libc/sysv/errfuns/enotconn.S
index b6c26d55c..1ea6d6eca 100644
--- a/libc/sysv/errfuns/enotconn.S
+++ b/libc/sysv/errfuns/enotconn.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enotdir.S b/libc/sysv/errfuns/enotdir.S
index 7afc1762f..14103122d 100644
--- a/libc/sysv/errfuns/enotdir.S
+++ b/libc/sysv/errfuns/enotdir.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enotempty.S b/libc/sysv/errfuns/enotempty.S
index 67bbdc837..dd014acbc 100644
--- a/libc/sysv/errfuns/enotempty.S
+++ b/libc/sysv/errfuns/enotempty.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enotnam.S b/libc/sysv/errfuns/enotnam.S
index 7a1094e5b..259a7bdae 100644
--- a/libc/sysv/errfuns/enotnam.S
+++ b/libc/sysv/errfuns/enotnam.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enotrecoverable.S b/libc/sysv/errfuns/enotrecoverable.S
index e50430452..85ed3a663 100644
--- a/libc/sysv/errfuns/enotrecoverable.S
+++ b/libc/sysv/errfuns/enotrecoverable.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enotsock.S b/libc/sysv/errfuns/enotsock.S
index 8f0753ce5..02e2b93ff 100644
--- a/libc/sysv/errfuns/enotsock.S
+++ b/libc/sysv/errfuns/enotsock.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enotsup.S b/libc/sysv/errfuns/enotsup.S
index 59d130623..01888f280 100644
--- a/libc/sysv/errfuns/enotsup.S
+++ b/libc/sysv/errfuns/enotsup.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enotty.S b/libc/sysv/errfuns/enotty.S
index beed92e95..e07629a98 100644
--- a/libc/sysv/errfuns/enotty.S
+++ b/libc/sysv/errfuns/enotty.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enotuniq.S b/libc/sysv/errfuns/enotuniq.S
index 57b04e9ba..a40cf8982 100644
--- a/libc/sysv/errfuns/enotuniq.S
+++ b/libc/sysv/errfuns/enotuniq.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/enxio.S b/libc/sysv/errfuns/enxio.S
index 637241908..6e827d4c6 100644
--- a/libc/sysv/errfuns/enxio.S
+++ b/libc/sysv/errfuns/enxio.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eopnotsupp.S b/libc/sysv/errfuns/eopnotsupp.S
index fa974a998..0c740d2ab 100644
--- a/libc/sysv/errfuns/eopnotsupp.S
+++ b/libc/sysv/errfuns/eopnotsupp.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eoverflow.S b/libc/sysv/errfuns/eoverflow.S
index 81aad5b64..98fae88a9 100644
--- a/libc/sysv/errfuns/eoverflow.S
+++ b/libc/sysv/errfuns/eoverflow.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eownerdead.S b/libc/sysv/errfuns/eownerdead.S
index 5968f3807..033cab8bf 100644
--- a/libc/sysv/errfuns/eownerdead.S
+++ b/libc/sysv/errfuns/eownerdead.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eperm.S b/libc/sysv/errfuns/eperm.S
index cc4fefa78..54df77607 100644
--- a/libc/sysv/errfuns/eperm.S
+++ b/libc/sysv/errfuns/eperm.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/epfnosupport.S b/libc/sysv/errfuns/epfnosupport.S
index 73da7dd25..9732440f5 100644
--- a/libc/sysv/errfuns/epfnosupport.S
+++ b/libc/sysv/errfuns/epfnosupport.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/epipe.S b/libc/sysv/errfuns/epipe.S
index 5c1f01948..fcf57e4c8 100644
--- a/libc/sysv/errfuns/epipe.S
+++ b/libc/sysv/errfuns/epipe.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eproto.S b/libc/sysv/errfuns/eproto.S
index 22ceb6bd7..f5c7e0c1f 100644
--- a/libc/sysv/errfuns/eproto.S
+++ b/libc/sysv/errfuns/eproto.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eprotonosupport.S b/libc/sysv/errfuns/eprotonosupport.S
index f8f9bcd6a..3934683f9 100644
--- a/libc/sysv/errfuns/eprotonosupport.S
+++ b/libc/sysv/errfuns/eprotonosupport.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eprototype.S b/libc/sysv/errfuns/eprototype.S
index ceb8efbb3..208d4989f 100644
--- a/libc/sysv/errfuns/eprototype.S
+++ b/libc/sysv/errfuns/eprototype.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/erange.S b/libc/sysv/errfuns/erange.S
index 1dc1b07e3..e9e8e727c 100644
--- a/libc/sysv/errfuns/erange.S
+++ b/libc/sysv/errfuns/erange.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eremchg.S b/libc/sysv/errfuns/eremchg.S
index 201ae2688..2bdcac692 100644
--- a/libc/sysv/errfuns/eremchg.S
+++ b/libc/sysv/errfuns/eremchg.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eremote.S b/libc/sysv/errfuns/eremote.S
index db3ddb627..515e7d5b6 100644
--- a/libc/sysv/errfuns/eremote.S
+++ b/libc/sysv/errfuns/eremote.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eremoteio.S b/libc/sysv/errfuns/eremoteio.S
index 12e2a74b5..d57d9e119 100644
--- a/libc/sysv/errfuns/eremoteio.S
+++ b/libc/sysv/errfuns/eremoteio.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/erestart.S b/libc/sysv/errfuns/erestart.S
index 30eaa1d0b..67bc02b9b 100644
--- a/libc/sysv/errfuns/erestart.S
+++ b/libc/sysv/errfuns/erestart.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/erfkill.S b/libc/sysv/errfuns/erfkill.S
index 141b8e85a..49be57d27 100644
--- a/libc/sysv/errfuns/erfkill.S
+++ b/libc/sysv/errfuns/erfkill.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/erofs.S b/libc/sysv/errfuns/erofs.S
index fdab8c9a8..6d926c890 100644
--- a/libc/sysv/errfuns/erofs.S
+++ b/libc/sysv/errfuns/erofs.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eshutdown.S b/libc/sysv/errfuns/eshutdown.S
index 1f6d8cfd1..dfbcce120 100644
--- a/libc/sysv/errfuns/eshutdown.S
+++ b/libc/sysv/errfuns/eshutdown.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/esocktnosupport.S b/libc/sysv/errfuns/esocktnosupport.S
index 6a29e9c81..6891eb9d9 100644
--- a/libc/sysv/errfuns/esocktnosupport.S
+++ b/libc/sysv/errfuns/esocktnosupport.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/espipe.S b/libc/sysv/errfuns/espipe.S
index 373a08844..4b8bbd3b9 100644
--- a/libc/sysv/errfuns/espipe.S
+++ b/libc/sysv/errfuns/espipe.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/esrch.S b/libc/sysv/errfuns/esrch.S
index 91dc831d6..d7220c067 100644
--- a/libc/sysv/errfuns/esrch.S
+++ b/libc/sysv/errfuns/esrch.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/esrmnt.S b/libc/sysv/errfuns/esrmnt.S
index 109dc659e..3cea68263 100644
--- a/libc/sysv/errfuns/esrmnt.S
+++ b/libc/sysv/errfuns/esrmnt.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/estale.S b/libc/sysv/errfuns/estale.S
index 88a27e0c8..8653aa5b4 100644
--- a/libc/sysv/errfuns/estale.S
+++ b/libc/sysv/errfuns/estale.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/estrpipe.S b/libc/sysv/errfuns/estrpipe.S
index 52a5c083e..037d0644d 100644
--- a/libc/sysv/errfuns/estrpipe.S
+++ b/libc/sysv/errfuns/estrpipe.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/etime.S b/libc/sysv/errfuns/etime.S
index a0071f600..b3f273c25 100644
--- a/libc/sysv/errfuns/etime.S
+++ b/libc/sysv/errfuns/etime.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/etimedout.S b/libc/sysv/errfuns/etimedout.S
index 7787c672a..878b9a7e9 100644
--- a/libc/sysv/errfuns/etimedout.S
+++ b/libc/sysv/errfuns/etimedout.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/etoomanyrefs.S b/libc/sysv/errfuns/etoomanyrefs.S
index 5e2fe7174..7f22e9ef6 100644
--- a/libc/sysv/errfuns/etoomanyrefs.S
+++ b/libc/sysv/errfuns/etoomanyrefs.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/etxtbsy.S b/libc/sysv/errfuns/etxtbsy.S
index 672146f58..8cf8c93fb 100644
--- a/libc/sysv/errfuns/etxtbsy.S
+++ b/libc/sysv/errfuns/etxtbsy.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/euclean.S b/libc/sysv/errfuns/euclean.S
index 891e5f866..80aeddd80 100644
--- a/libc/sysv/errfuns/euclean.S
+++ b/libc/sysv/errfuns/euclean.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eunatch.S b/libc/sysv/errfuns/eunatch.S
index 655cfc37d..fc675e49d 100644
--- a/libc/sysv/errfuns/eunatch.S
+++ b/libc/sysv/errfuns/eunatch.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/eusers.S b/libc/sysv/errfuns/eusers.S
index de75227d8..b6ffd4571 100644
--- a/libc/sysv/errfuns/eusers.S
+++ b/libc/sysv/errfuns/eusers.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/exdev.S b/libc/sysv/errfuns/exdev.S
index 679c3a67b..76fb8f71f 100644
--- a/libc/sysv/errfuns/exdev.S
+++ b/libc/sysv/errfuns/exdev.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errfuns/exfull.S b/libc/sysv/errfuns/exfull.S
index fdc83132a..2d8f37848 100644
--- a/libc/sysv/errfuns/exfull.S
+++ b/libc/sysv/errfuns/exfull.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .text.unlikely
 
 	.ftrace1
diff --git a/libc/sysv/errno.c b/libc/sysv/errno.c
index 438ee9508..038eca137 100644
--- a/libc/sysv/errno.c
+++ b/libc/sysv/errno.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
-#include "libc/thread/tls2.internal.h"
+#include "libc/thread/tls.h"
 
 /**
  * Global variable for last error.
@@ -35,8 +35,10 @@ errno_t __errno;
 
 /**
  * Returns address of `errno` variable.
+ *
+ * This function promises to not clobber argument registers.
  */
-errno_t *__errno_location(void) {
+nocallersavedregisters errno_t *__errno_location(void) {
   if (__tls_enabled) {
     return &__get_tls()->tib_errno;
   } else {
diff --git a/libc/sysv/gen.sh b/libc/sysv/gen.sh
index da514a903..7abdf723d 100644
--- a/libc/sysv/gen.sh
+++ b/libc/sysv/gen.sh
@@ -66,7 +66,7 @@ errfun() {
   NAME="$1"
   ERRNO="$2"
   {
-    printf '#include "libc/macros.internal.h"\n.text.unlikely\n\n'
+    printf '#include "libc/macros.h"\n.text.unlikely\n\n'
     printf '\t.ftrace1\n'
     printf '%s:\n' "$NAME"
     printf '\t.ftrace2\n'
diff --git a/libc/sysv/hostos.S b/libc/sysv/hostos.S
index a378a5c70..5adcfc603 100644
--- a/libc/sysv/hostos.S
+++ b/libc/sysv/hostos.S
@@ -16,10 +16,16 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.bss
 	.balign	8
 __hostos:
 	.quad	0
-	.endfn	__hostos,globl
+	.endobj	__hostos,globl
+__tls_index:
+	.long	0
+	.endobj	__tls_index,globl
+__tls_enabled:
+	.long	0
+	.endobj	__tls_enabled,globl
diff --git a/libc/sysv/macros.internal.h b/libc/sysv/macros.internal.h
index da2ec43d6..4d348d5da 100644
--- a/libc/sysv/macros.internal.h
+++ b/libc/sysv/macros.internal.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_LIBC_SYSV_MACROS_H_
 #define COSMOPOLITAN_LIBC_SYSV_MACROS_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #ifdef __ASSEMBLER__
 /* clang-format off */
 
diff --git a/libc/sysv/restorert.S b/libc/sysv/restorert.S
index 864e1d5d9..356fa575e 100644
--- a/libc/sysv/restorert.S
+++ b/libc/sysv/restorert.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/sysv/consts/nrlinux.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .privileged
 
 //	Linux Signal Trampoline (HOLY CODE)
diff --git a/libc/sysv/syscall2.S b/libc/sysv/syscall2.S
index c420783ef..30cf685b1 100644
--- a/libc/sysv/syscall2.S
+++ b/libc/sysv/syscall2.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Invokes system call w/ arity of two.
 //
diff --git a/libc/sysv/syscall3.S b/libc/sysv/syscall3.S
index 06058bb29..fc9ee1051 100644
--- a/libc/sysv/syscall3.S
+++ b/libc/sysv/syscall3.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Invokes system call w/ arity of three.
 //
diff --git a/libc/sysv/syscall4.S b/libc/sysv/syscall4.S
index c5d37788a..30aa9f4e3 100644
--- a/libc/sysv/syscall4.S
+++ b/libc/sysv/syscall4.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Invokes system call w/ arity of four.
 //
diff --git a/libc/sysv/syscalls.sh b/libc/sysv/syscalls.sh
index d497dbaf7..930516052 100755
--- a/libc/sysv/syscalls.sh
+++ b/libc/sysv/syscalls.sh
@@ -59,7 +59,7 @@ scall	__sys_pipe		0x02a10721e202a016	0x03b	globl hidden # NOTE: pipe2() on FreeB
 scall	sys_select		0x9a184785d285d817	0xfff	globl hidden
 scall	sys_pselect		0x9b486ea0a298a90e	0x848	globl hidden # pselect6() on gnu/systemd
 scall	sys_sched_yield		0x15e12a14bf25d018	0x07c	globl hidden # select() on XNU (previously swtch() but removed in 12.4)
-scall	__sys_mremap		0x19bffffffffff019	0x0d8	globl hidden
+scall	sys_mremap		0x19bffffffffff019	0x0d8	globl hidden
 scall	sys_mincore		0x04e04e04e204e01b	0x0e8	globl hidden
 scall	sys_madvise		0x04b04b04b204b01c	0x0e9	globl hidden
 scall	sys_shmget		0x0e71210e7210901d	0x0c2	globl # no wrapper
@@ -679,7 +679,6 @@ scall	sys_getcontext		0x133fff1a5fffffff	0xfff	globl hidden
 #scall	gethostname		0xffff0057ffffffff	0xfff	globl
 #scall	getkerninfo		0xffffff03ffffffff	0xfff	globl
 #scall	getloginclass		0xffffff20bfffffff	0xfff	globl
-scall	getpagesize_freebsd	0xffffff040fffffff	0xfff	globl hidden
 #scall	gssd_syscall		0xffffff1f9fffffff	0xfff	globl
 #scall	jail			0xffffff152fffffff	0xfff	globl
 #scall	jail_attach		0xffffff1b4fffffff	0xfff	globl
diff --git a/libc/sysv/syscon.S b/libc/sysv/syscon.S
index 9aeae721a..e3d6e812c 100644
--- a/libc/sysv/syscon.S
+++ b/libc/sysv/syscon.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Sections for varint encoded magic numbers.
 //
diff --git a/libc/sysv/syscount.S b/libc/sysv/syscount.S
index 6ede1dc3e..4bf4ec6d0 100644
--- a/libc/sysv/syscount.S
+++ b/libc/sysv/syscount.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	RII System Five system call counter.
 //
diff --git a/libc/sysv/syslib.S b/libc/sysv/syslib.S
index e9c165588..9c24943ad 100644
--- a/libc/sysv/syslib.S
+++ b/libc/sysv/syslib.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 	.bss
 	.balign	8
diff --git a/libc/sysv/systemfive.S b/libc/sysv/systemfive.S
index 879edaf05..178892482 100644
--- a/libc/sysv/systemfive.S
+++ b/libc/sysv/systemfive.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/thread/pt.internal.h"
 
 #define SIG_IGN 1
@@ -102,8 +102,8 @@ __pid:	.quad	0
 	.previous
 
 systemfive_cp:
-	push	%rbp
-	mov	%rsp,%rbp		// so backtraces work
+	beg
+	pro
 systemfive_cancellable:			// our pthread_cancel() miracle code
 	cmpb	$0,__tls_enabled(%rip)	// inspired by the musl libc design!
 	je	1f			// we handle linux and bsd together!
@@ -123,7 +123,7 @@ systemfive_cancellable:			// our pthread_cancel() miracle code
 	clc				// no cancellable system calls exist
 	syscall				// that have 7+ args on the bsd OSes
 systemfive_cancellable_end:		// i/o calls park here for long time
-	pop	%rbp
+	epi
 	jnc	2f
 	neg	%rax			// turns bsd errno to system v errno
 2:	cmp	$-4095,%rax		// but we still check again on eintr
@@ -144,11 +144,13 @@ systemfive_cancellable_end:		// i/o calls park here for long time
 	je	systemfive_errno	// we aren't actually cancelled
 	jmp	4f			// now we are in fact cancelled
 systemfive_cancel:			// SIGTHR will jump here too
-	pop	%rbp
+	epi
 4:	jmp	_pthread_cancel_ack	// tail call
 	.weak	_pthread_cancel_ack	// must be linked if we're cancelled
+	end
 #if IsModeDbg()
 not_a_cancellation_point:		// need BEGIN/END_CANCELLATION_POINT
+	beg
 	nop
 	.weak	report_cancellation_point
 5:	ezlea	report_cancellation_point,cx
@@ -157,6 +159,7 @@ not_a_cancellation_point:		// need BEGIN/END_CANCELLATION_POINT
 	call	*%rcx
 6:	ud2
 	nop
+	end
 #endif
 	.globl	systemfive_cancellable_end
 	.globl	systemfive_cancellable
@@ -166,19 +169,20 @@ not_a_cancellation_point:		// need BEGIN/END_CANCELLATION_POINT
 .Lanchorpoint:
 #if SupportsLinux() || SupportsMetal()
 systemfive_linux:
+	beg
 	and	$0xfff,%eax		// remove nonlinux bits from ordinal
 	cmp	$0xfff,%eax		// checks if unsupported by platform
 	je	systemfive_enosys	// never taken branches cost nothing
 	btr	$11,%eax		// 0x800 means a call is cancellable
 	jc	systemfive_cp		// it is handled by the holiest code
 	mov	%rcx,%r10		// syscall instruction clobbers %rcx
-	push	%rbp			// linux never reads args from stack
-	mov	%rsp,%rbp		// having frame will help backtraces
+	pro				// linux never reads args from stack
 	syscall				// this is known as a context switch
-	pop	%rbp			// next we check to see if it failed
+	epi				// next we check to see if it failed
 	cmp	$-4095,%rax		// system five nexgen32e abi § a.2.1
 	jae	systemfive_error	// encodes errno as neg return value
 	ret
+	end
 	.endfn	systemfive_linux,globl,hidden
 systemfive_error:
 	neg	%eax
@@ -186,27 +190,35 @@ systemfive_error:
 	.endfn	systemfive_error,globl,hidden
 #endif
 systemfive_errno:
+	beg
 	xchg	%eax,%ecx
-	.errno
+	call	__errno_location
 	mov	%ecx,(%rax)		// normalize to c library convention
 	push	$-1			// negative one is only error result
 	pop	%rax			// the push pop is to save code size
 	ret
+	end
 	.endfn	systemfive_errno,globl,hidden
 systemfive_enosys:
+	beg
 	mov	ENOSYS(%rip),%eax
 	jmp	systemfive_errno
+	end
 	.endfn	systemfive_enosys,globl,hidden
 #if SupportsNetbsd()
 systemfive_netbsd:
+	beg
 	shr	$4*13,%rax
 	jmp	systemfive_bsdscrub
+	end
 	.endfn	systemfive_netbsd,globl,hidden
 #endif
 #if SupportsOpenbsd()
 systemfive_openbsd:
+	beg
 	shr	$4*10,%rax
 	jmp	systemfive_bsdscrub
+	end
 	.endfn	systemfive_openbsd,globl,hidden
 #endif
 #if SupportsFreebsd()
@@ -222,6 +234,7 @@ systemfive_bsdscrub:
 //	𝑠𝑙𝑖𝑑𝑒
 	.endfn	systemfive_bsdscrub,globl,hidden
 systemfive_bsd:
+	beg
 	cmp	$0xfff,%ax
 	je	systemfive_enosys
 	btr	$11,%eax		// checks/reset the 800 cancellable bit
@@ -230,6 +243,7 @@ systemfive_bsd:
 	syscall				// bsd will need arg on stack sometimes
 	jc	systemfive_errno	// bsd sets carry flag if %rax is errno
 	ret
+	end
 	.endfn	systemfive_bsd
 #endif
 #if SupportsXnu()
diff --git a/libc/sysv/sysv.c b/libc/sysv/sysv.c
index afb3496b8..8c78202bf 100644
--- a/libc/sysv/sysv.c
+++ b/libc/sysv/sysv.c
@@ -37,7 +37,7 @@ register long freebsd_ordinal asm("x9");
 register long xnu_ordinal asm("x16");
 register long cosmo_tls_register asm("x28");
 
-void report_cancelation_point(void);
+void report_cancelation_point(int, int);
 
 dontinline long systemfive_cancel(void) {
   return _weaken(_pthread_cancel_ack)();
@@ -58,9 +58,9 @@ dontinline long systemfive_cancellable(void) {
       return systemfive_cancel();
     }
 #if IsModeDbg()
-    if (!(pth->pt_flags & PT_INCANCEL)) {
+    if (!(pth->pt_flags & PT_INCANCEL) && !(pth->pt_flags & PT_NOCANCEL)) {
       if (_weaken(report_cancelation_point)) {
-        _weaken(report_cancelation_point)();
+        _weaken(report_cancelation_point)(sysv_ordinal, xnu_ordinal);
       }
       __builtin_trap();
     }
diff --git a/libc/testlib/BUILD.mk b/libc/testlib/BUILD.mk
index 236d8ab96..a81790c86 100644
--- a/libc/testlib/BUILD.mk
+++ b/libc/testlib/BUILD.mk
@@ -22,14 +22,17 @@ LIBC_TESTLIB_A_ASSETS =						\
 LIBC_TESTLIB_A_HDRS =						\
 	libc/testlib/aspect.internal.h				\
 	libc/testlib/bench.h					\
+	libc/testlib/benchmark.h				\
 	libc/testlib/blocktronics.h				\
 	libc/testlib/ezbench.h					\
 	libc/testlib/fastrandomstring.h				\
 	libc/testlib/hyperion.h					\
+	libc/testlib/manystack.h				\
 	libc/testlib/moby.h					\
 	libc/testlib/subprocess.h				\
 	libc/testlib/testlib.h					\
-	libc/testlib/viewables.h
+	libc/testlib/trace.h					\
+	libc/testlib/viewables.h				\
 
 LIBC_TESTLIB_A_SRCS_S =						\
 	libc/testlib/bench.S					\
@@ -49,6 +52,7 @@ LIBC_TESTLIB_A_SRCS_C =						\
 	libc/testlib/clearxmmregisters.c			\
 	libc/testlib/contains.c					\
 	libc/testlib/endswith.c					\
+	libc/testlib/exactlyequallongdouble.c		 	\
 	libc/testlib/extract.c					\
 	libc/testlib/ezbenchcontrol.c				\
 	libc/testlib/ezbenchreport.c				\
@@ -67,6 +71,7 @@ LIBC_TESTLIB_A_SRCS_C =						\
 	libc/testlib/globals.c					\
 	libc/testlib/hexequals.c				\
 	libc/testlib/incrementfailed.c				\
+	libc/testlib/manystack.c				\
 	libc/testlib/memoryexists.c				\
 	libc/testlib/seterrno.c					\
 	libc/testlib/shoulddebugbreak.c				\
@@ -78,9 +83,10 @@ LIBC_TESTLIB_A_SRCS_C =						\
 	libc/testlib/testrunner.c				\
 	libc/testlib/thunks.c					\
 	libc/testlib/tmptest.c					\
+	libc/testlib/trace.c					\
 	libc/testlib/waitforexit.c				\
 	libc/testlib/waitforterm.c				\
-	libc/testlib/yield.c
+	libc/testlib/yield.c					\
 
 LIBC_TESTLIB_A_SRCS =						\
 	$(LIBC_TESTLIB_A_SRCS_S)				\
@@ -106,13 +112,15 @@ LIBC_TESTLIB_A_DIRECTDEPS =					\
 	LIBC_STR						\
 	LIBC_SYSV						\
 	LIBC_SYSV_CALLS						\
+	LIBC_THREAD						\
 	LIBC_TINYMATH						\
 	LIBC_X							\
 	THIRD_PARTY_COMPILER_RT					\
 	THIRD_PARTY_DLMALLOC					\
 	THIRD_PARTY_GDTOA					\
+	THIRD_PARTY_MUSL					\
+	THIRD_PARTY_TZ						\
 	THIRD_PARTY_XED						\
-	THIRD_PARTY_TZ
 
 LIBC_TESTLIB_A_DEPS :=						\
 	$(call uniq,$(foreach x,$(LIBC_TESTLIB_A_DIRECTDEPS),$($(x))))
@@ -207,6 +215,7 @@ LIBC_TESTMAIN_DIRECTDEPS =					\
 	LIBC_LOG						\
 	LIBC_MEM						\
 	LIBC_NEXGEN32E						\
+	LIBC_PROC						\
 	LIBC_RUNTIME						\
 	LIBC_STDIO						\
 	LIBC_SYSV						\
@@ -214,7 +223,7 @@ LIBC_TESTMAIN_DIRECTDEPS =					\
 	LIBC_TESTLIB						\
 	LIBC_TESTLIB_RUNNER					\
 	THIRD_PARTY_DLMALLOC					\
-	THIRD_PARTY_GETOPT
+	THIRD_PARTY_GETOPT					\
 
 LIBC_TESTMAIN_DEPS :=						\
 	$(call uniq,$(foreach x,$(LIBC_TESTMAIN_DIRECTDEPS),$($(x))))
diff --git a/libc/testlib/bench.S b/libc/testlib/bench.S
index 730d0beb7..49e1e83db 100644
--- a/libc/testlib/bench.S
+++ b/libc/testlib/bench.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .yoink	testlib_runallbenchmarks
 
 //	Decentralized section for benchmark registration.
diff --git a/libc/testlib/benchmark.h b/libc/testlib/benchmark.h
new file mode 100644
index 000000000..8915dfb6e
--- /dev/null
+++ b/libc/testlib/benchmark.h
@@ -0,0 +1,80 @@
+#ifndef COSMOPOLITAN_LIBC_TESTLIB_BENCHMARK_H_
+#define COSMOPOLITAN_LIBC_TESTLIB_BENCHMARK_H_
+#include "libc/calls/struct/timespec.h"
+#include "libc/stdio/stdio.h"
+COSMOPOLITAN_C_START_
+
+#define X(x) __expropriate(x)
+#define V(x) __veil("r", x)
+
+#define BENCHMARK(ITERATIONS, WORK_PER_RUN, CODE)                     \
+  do {                                                                \
+    struct timespec start = timespec_real();                          \
+    for (int __i = 0; __i < ITERATIONS; ++__i) {                      \
+      asm volatile("" ::: "memory");                                  \
+      CODE;                                                           \
+    }                                                                 \
+    long ns = timespec_tonanos(timespec_sub(timespec_real(), start)); \
+    _print_benchmark_result(ns, WORK_PER_RUN, ITERATIONS, #CODE);     \
+  } while (0)
+
+static void _print_benchmark_result(double total_nanos, double work_per_run,
+                                    int iterations, const char* code) {
+  double time_per_op = total_nanos / (work_per_run * iterations);
+  double throughput = work_per_run / (total_nanos / iterations * 1e-9);
+
+  const char* throughput_unit;
+  const char* time_unit;
+  double time_value;
+
+  // Determine throughput unit
+  if (throughput >= 1e9) {
+    throughput /= 1e9;
+    throughput_unit = "G";
+  } else if (throughput >= 1e6) {
+    throughput /= 1e6;
+    throughput_unit = "M";
+  } else if (throughput >= 1e3) {
+    throughput /= 1e3;
+    throughput_unit = "K";
+  } else {
+    throughput_unit = " ";
+  }
+
+  // Determine time unit
+  if (time_per_op >= 1e6) {
+    time_value = time_per_op / 1e6;
+    time_unit = "ms";
+  } else if (time_per_op >= 1e3) {
+    time_value = time_per_op / 1e3;
+    time_unit = "µs";
+  } else if (time_per_op >= .01) {
+    time_value = time_per_op;
+    time_unit = "ns";
+  } else {
+    time_value = time_per_op * 1e3;
+    time_unit = "ps";
+  }
+
+  // Determine work unit
+  const char* work_unit;
+  if (work_per_run >= 1e9) {
+    work_per_run /= 1e9;
+    work_unit = "G";
+  } else if (work_per_run >= 1e6) {
+    work_per_run /= 1e6;
+    work_unit = "M";
+  } else if (work_per_run >= 1e3) {
+    work_per_run /= 1e3;
+    work_unit = "K";
+  } else {
+    work_unit = " ";
+  }
+
+  printf("%8.2f %-2s %8.2f %s/s %6.2f %s %3dx %s\n", time_value, time_unit,
+         throughput, throughput_unit, work_per_run, work_unit, iterations,
+         code);
+}
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_TESTLIB_BENCHMARK_H_ */
diff --git a/libc/testlib/binequals.c b/libc/testlib/binequals.c
index f56000a38..79ab6c9f5 100644
--- a/libc/testlib/binequals.c
+++ b/libc/testlib/binequals.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/testlib/testlib.h"
 
 /**
diff --git a/libc/testlib/blake2b256_tests.S b/libc/testlib/blake2b256_tests.S
index d5d600e19..50d02704f 100644
--- a/libc/testlib/blake2b256_tests.S
+++ b/libc/testlib/blake2b256_tests.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .rodata
 
 //	Blake2B256 test vectors.
diff --git a/libc/testlib/blocktronics.S b/libc/testlib/blocktronics.S
index 055803694..dcbff573b 100644
--- a/libc/testlib/blocktronics.S
+++ b/libc/testlib/blocktronics.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .rodata
 
 //	Nontrivial NUL-terminated string test vector.
diff --git a/libc/testlib/exactlyequallongdouble.c b/libc/testlib/exactlyequallongdouble.c
new file mode 100644
index 000000000..fa6f73e6c
--- /dev/null
+++ b/libc/testlib/exactlyequallongdouble.c
@@ -0,0 +1,35 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/math.h"
+#include "libc/testlib/testlib.h"
+
+bool testlib_exactlyequallongdouble(long double x, long double y) {
+  if (isnan(x) && isnan(y))
+    return true;
+  // Check that we don't have e.g. one input denormal and the other not
+  // (a denormal and a non-denormal can sometimes compare equal)
+  if (fpclassify(x) != fpclassify(y))
+    return false;
+  // Check that we don't have -0 and 0
+  if (signbit(x) != signbit(y))
+    return false;
+  if (x != y)
+    return false;
+  return true;
+}
diff --git a/libc/testlib/ezbench.h b/libc/testlib/ezbench.h
index 35fa23e33..70bb39dd3 100644
--- a/libc/testlib/ezbench.h
+++ b/libc/testlib/ezbench.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_LIBC_TESTLIB_EZBENCH_H_
 #define COSMOPOLITAN_LIBC_TESTLIB_EZBENCH_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/nexgen32e/bench.h"
 #include "libc/nexgen32e/x86feature.h"
diff --git a/libc/testlib/ezbenchreport.c b/libc/testlib/ezbenchreport.c
index 04ad5facd..3af989847 100644
--- a/libc/testlib/ezbenchreport.c
+++ b/libc/testlib/ezbenchreport.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/math.h"
 #include "libc/runtime/runtime.h"
 
diff --git a/libc/testlib/fixture.S b/libc/testlib/fixture.S
index 03139e2ab..bea3297bd 100644
--- a/libc/testlib/fixture.S
+++ b/libc/testlib/fixture.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Decentralized section for test fixture registration.
 //
diff --git a/libc/testlib/formatint.c b/libc/testlib/formatint.c
index 169ab7654..cf349237b 100644
--- a/libc/testlib/formatint.c
+++ b/libc/testlib/formatint.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/atomic.h"
+#include "libc/ctype.h"
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
 #include "libc/intrin/atomic.h"
diff --git a/libc/testlib/formatstr.c b/libc/testlib/formatstr.c
index be7ffc145..9775cbbaa 100644
--- a/libc/testlib/formatstr.c
+++ b/libc/testlib/formatstr.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/intrin/atomic.h"
 #include "libc/serialize.h"
 #include "libc/str/str.h"
diff --git a/libc/testlib/hexequals.c b/libc/testlib/hexequals.c
index a4f8b5cf9..1fadd63ed 100644
--- a/libc/testlib/hexequals.c
+++ b/libc/testlib/hexequals.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/testlib/testlib.h"
 
 /**
diff --git a/libc/testlib/hyperion.S b/libc/testlib/hyperion.S
index 0e2925b5e..66bdf3cf8 100644
--- a/libc/testlib/hyperion.S
+++ b/libc/testlib/hyperion.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .rodata
 
 //	Nontrivial NUL-terminated string test vector.
diff --git a/libc/testlib/manystack.c b/libc/testlib/manystack.c
new file mode 100644
index 000000000..b0b022ba1
--- /dev/null
+++ b/libc/testlib/manystack.c
@@ -0,0 +1,69 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/testlib/manystack.h"
+#include "libc/atomic.h"
+#include "libc/calls/struct/sigaction.h"
+#include "libc/calls/struct/sigset.h"
+#include "libc/intrin/dll.h"
+#include "libc/sysv/consts/sig.h"
+#include "libc/thread/posixthread.internal.h"
+
+static atomic_int manystack_gotsig;
+static atomic_bool manystack_shutdown;
+
+static void manystack_signal(int sig) {
+  manystack_gotsig = sig;
+}
+
+static void *manystack_thread(void *arg) {
+  sigset_t ss;
+  sigfillset(&ss);
+  sigdelset(&ss, SIGUSR2);
+  while (!manystack_shutdown) {
+    sigsuspend(&ss);
+    if (!manystack_shutdown) {
+      _pthread_lock();
+      for (struct Dll *e = dll_first(_pthread_list); e;
+           e = dll_next(_pthread_list, e)) {
+        pthread_t th = (pthread_t)POSIXTHREAD_CONTAINER(e);
+        if (!pthread_equal(th, pthread_self()))
+          pthread_kill(th, SIGQUIT);
+      }
+      _pthread_unlock();
+    }
+  }
+  return 0;
+}
+
+pthread_t manystack_start(void) {
+  sigset_t ss;
+  pthread_t msh;
+  sigemptyset(&ss);
+  sigaddset(&ss, SIGUSR2);
+  sigprocmask(SIG_BLOCK, &ss, 0);
+  signal(SIGUSR2, manystack_signal);
+  pthread_create(&msh, 0, manystack_thread, 0);
+  return msh;
+}
+
+void manystack_stop(pthread_t msh) {
+  manystack_shutdown = true;
+  pthread_kill(msh, SIGUSR2);
+  pthread_join(msh, 0);
+}
diff --git a/libc/testlib/manystack.h b/libc/testlib/manystack.h
new file mode 100644
index 000000000..a175ecbea
--- /dev/null
+++ b/libc/testlib/manystack.h
@@ -0,0 +1,10 @@
+#ifndef COSMOPOLITAN_LIBC_TESTLIB_MANYSTACK_H_
+#define COSMOPOLITAN_LIBC_TESTLIB_MANYSTACK_H_
+#include "libc/thread/thread.h"
+COSMOPOLITAN_C_START_
+
+pthread_t manystack_start(void);
+void manystack_stop(pthread_t);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_TESTLIB_MANYSTACK_H_ */
diff --git a/libc/testlib/memoryexists.c b/libc/testlib/memoryexists.c
index d18c173ba..014497658 100644
--- a/libc/testlib/memoryexists.c
+++ b/libc/testlib/memoryexists.c
@@ -22,6 +22,7 @@
 #include "libc/calls/struct/siginfo.h"
 #include "libc/calls/ucontext.h"
 #include "libc/intrin/atomic.h"
+#include "libc/intrin/kprintf.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/testlib.h"
@@ -44,14 +45,7 @@ static void ContinueOnError(int sig, siginfo_t *si, void *vctx) {
 #endif /* __x86_64__ */
 }
 
-/**
- * Returns true if byte at address `p` is readable.
- *
- * This function temporarily catches `SIGSEGV` and `SIGBUS` to recover
- * on error. It then attempts a volatile read and if it faults, then
- * this function shall return false. The value at `p` isn't considered.
- */
-bool testlib_memoryexists(const void *p) {
+bool testlib_pokememory(const void *p) {
   volatile char c;
   const atomic_char *mem = p;
   struct sigaction old[2];
@@ -68,3 +62,16 @@ bool testlib_memoryexists(const void *p) {
   npassert(!sigaction(SIGSEGV, old + 0, 0));
   return !gotsignal;
 }
+
+/**
+ * Returns true if byte at address `p` is readable.
+ *
+ * This function temporarily catches `SIGSEGV` and `SIGBUS` to recover
+ * on error. It then attempts a volatile read and if it faults, then
+ * this function shall return false. The value at `p` isn't considered.
+ */
+bool testlib_memoryexists(const void *p) {
+  if (kisdangerous(p))
+    return false;
+  return testlib_pokememory(p);
+}
diff --git a/libc/testlib/moby.S b/libc/testlib/moby.S
index aa382f5e4..fff6bcaaa 100644
--- a/libc/testlib/moby.S
+++ b/libc/testlib/moby.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .rodata
 
 //	Nontrivial NUL-terminated string test vector.
diff --git a/libc/testlib/polluteregisters.S b/libc/testlib/polluteregisters.S
index b26144eb4..50cf2d5e4 100644
--- a/libc/testlib/polluteregisters.S
+++ b/libc/testlib/polluteregisters.S
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/nexgen32e/x86feature.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 __polluteregisters:
 #ifdef __x86_64__
diff --git a/libc/testlib/showerror.c b/libc/testlib/showerror.c
index 713afbb67..2197956ca 100644
--- a/libc/testlib/showerror.c
+++ b/libc/testlib/showerror.c
@@ -23,7 +23,7 @@
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/color.internal.h"
 #include "libc/log/internal.h"
diff --git a/libc/testlib/subprocess.h b/libc/testlib/subprocess.h
index 0d396de75..c09ee56c0 100644
--- a/libc/testlib/subprocess.h
+++ b/libc/testlib/subprocess.h
@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_LIBC_TESTLIB_SUBPROCESS_H_
 #define COSMOPOLITAN_LIBC_TESTLIB_SUBPROCESS_H_
 #include "libc/calls/calls.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/testlib/testlib.h"
 COSMOPOLITAN_C_START_
diff --git a/libc/testlib/testcase.S b/libc/testlib/testcase.S
index 272521378..46a76c374 100644
--- a/libc/testlib/testcase.S
+++ b/libc/testlib/testcase.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Decentralized section for test testcase registration.
 //
diff --git a/libc/testlib/testlib.h b/libc/testlib/testlib.h
index 8ff94e2da..9c8053c71 100644
--- a/libc/testlib/testlib.h
+++ b/libc/testlib/testlib.h
@@ -195,6 +195,13 @@ void TearDownOnce(void);
 #define ASSERT_LDBL_LT(VAL, GOT) \
   assertLongDoubleLessThan(VAL, GOT, #VAL " < " #GOT, true)
 
+#define ASSERT_FLOAT_EXACTLY_EQ(WANT, GOT) \
+  assertLongDoubleExactlyEquals(FILIFU WANT, GOT, #GOT, true)
+#define ASSERT_DOUBLE_EXACTLY_EQ(WANT, GOT) \
+  assertLongDoubleExactlyEquals(FILIFU WANT, GOT, #GOT, true)
+#define ASSERT_LDBL_EXACTLY_EQ(WANT, GOT) \
+  assertLongDoubleExactlyEquals(FILIFU WANT, GOT, #GOT, true)
+
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § testing library » assert or log                           ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
@@ -271,6 +278,13 @@ void TearDownOnce(void);
 #define EXPECT_LGBL_LT(VAL, GOT) \
   expectLongDoubleLessThan(VAL, GOT, #VAL " < " #GOT, false)
 
+#define EXPECT_FLOAT_EXACTLY_EQ(WANT, GOT) \
+  assertLongDoubleExactlyEquals(FILIFU WANT, GOT, #GOT, false)
+#define EXPECT_DOUBLE_EXACTLY_EQ(WANT, GOT) \
+  assertLongDoubleExactlyEquals(FILIFU WANT, GOT, #GOT, false)
+#define EXPECT_LDBL_EXACTLY_EQ(WANT, GOT) \
+  assertLongDoubleExactlyEquals(FILIFU WANT, GOT, #GOT, false)
+
 /*───────────────────────────────────────────────────────────────────────────│─╗
 │ cosmopolitan § testing library » implementation details                  ─╬─│┼
 ╚────────────────────────────────────────────────────────────────────────────│*/
@@ -372,6 +386,7 @@ void testlib_seterrno(int);
 void testlib_runalltests(void);
 const char *testlib_strerror(void);
 void testlib_runallbenchmarks(void);
+bool testlib_pokememory(const void *);
 bool testlib_memoryexists(const void *);
 void testlib_runtestcases(const testfn_t *, const testfn_t *, testfn_t);
 void testlib_runfixtures(const testfn_t *, const testfn_t *,
@@ -403,6 +418,7 @@ void testlib_formatbinaryashex(const char *, const void *, size_t, char **,
 void testlib_formatbinaryasglyphs(const char16_t *, const void *, size_t,
                                   char **, char **);
 bool testlib_almostequallongdouble(long double, long double);
+bool testlib_exactlyequallongdouble(long double, long double);
 void testlib_incrementfailed(void);
 void testlib_clearxmmregisters(void);
 
@@ -695,5 +711,20 @@ forceinline void assertLongDoubleEquals(FILIFU_ARGS long double want,
   testlib_onfail2(isfatal);
 }
 
+forceinline void assertLongDoubleExactlyEquals(FILIFU_ARGS long double want,
+                                               long double got,
+                                               const char *gotcode,
+                                               bool isfatal) {
+  ++g_testlib_ran;
+  if (testlib_exactlyequallongdouble(want, got))
+    return;
+  if (g_testlib_shoulddebugbreak)
+    DebugBreak();
+  testlib_showerror(file, line, func, "assertLongDoubleExactlyEquals", "≠",
+                    gotcode, testlib_formatfloat(want),
+                    testlib_formatfloat(got));
+  testlib_onfail2(isfatal);
+}
+
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_TESTLIB_H_ */
diff --git a/libc/testlib/testmain.c b/libc/testlib/testmain.c
index 78cacd2a4..538ca3ec5 100644
--- a/libc/testlib/testmain.c
+++ b/libc/testlib/testmain.c
@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/struct/cpuset.h"
 #include "libc/calls/struct/rlimit.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/siginfo.h"
@@ -26,21 +27,25 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/getenv.internal.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/getenv.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/ubsan.h"
 #include "libc/intrin/weaken.h"
+#include "libc/limits.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/leaks.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/nexgen32e.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
+#include "libc/stdio/rand.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/f.h"
+#include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/rlimit.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/aspect.internal.h"
@@ -49,6 +54,8 @@
 #include "libc/thread/tls.h"
 #include "third_party/getopt/getopt.internal.h"
 
+#pragma weak main
+
 #define USAGE \
   " [FLAGS]\n\
 \n\
@@ -85,7 +92,41 @@ static void GetOpts(int argc, char *argv[]) {
   }
 }
 
-#pragma weak main
+static int rando(void) {
+  return _rand64() & INT_MAX;
+}
+
+static void limit_process_to_single_cpu(void) {
+  extern int disable_limit_process_to_single_cpu;
+  if (_weaken(disable_limit_process_to_single_cpu))
+    return;
+  if (!(IsLinux() || IsFreebsd() || IsNetbsd() || IsWindows()))
+    return;
+  if (IsFreebsd() && getuid())
+    return;
+  cpu_set_t legal;
+  if (sched_getaffinity(0, sizeof(cpu_set_t), &legal) == -1) {
+    perror("sched_setaffinity failed");
+    exit(1);
+  }
+  int count = CPU_COUNT(&legal);
+  cpu_set_t newset;
+  CPU_ZERO(&newset);
+  bool done = false;
+  while (!done) {
+    for (int i = 0; i < CPU_SETSIZE; ++i) {
+      if (CPU_ISSET(i, &legal) && !(rando() % count)) {
+        CPU_SET(rando() % count, &newset);
+        done = true;
+        break;
+      }
+    }
+  }
+  if (sched_setaffinity(0, sizeof(cpu_set_t), &newset) == -1) {
+    perror("sched_setaffinity failed");
+    exit(1);
+  }
+}
 
 /**
  * Generic test program main function.
@@ -95,19 +136,33 @@ int main(int argc, char *argv[]) {
   struct Dll *e;
   struct TestAspect *a;
 
+  // some settings
+  __ubsan_strict = true;
+  __log_level = kLogInfo;
+
   if (errno) {
     tinyprint(2, "error: the errno variable was contaminated by constructors\n",
               NULL);
     return 1;
   }
 
-  __ubsan_strict = true;
-  __log_level = kLogInfo;
+  // // this sometimes helps tease out mt bugs
+  // limit_process_to_single_cpu();
+
+  // test huge pointers by enabling pml5t
+  if (rando() % 2) {
+    errno_t e = errno;
+    mmap((char *)0x80000000000000, 1, PROT_NONE,  //
+         MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    errno = e;
+  }
+
   GetOpts(argc, argv);
 
-  for (fd = 3; fd < 10; ++fd) {
+  int oe = errno;
+  for (fd = 3; fd < 100; ++fd)
     close(fd);
-  }
+  errno = oe;
 
 #ifndef TINY
   setenv("GDB", "", true);
@@ -151,23 +206,21 @@ int main(int argc, char *argv[]) {
       a->teardown(0);
     }
   }
-  if (_weaken(TearDownOnce)) {
+  if (_weaken(TearDownOnce))
     _weaken(TearDownOnce)();
-  }
 
   // make sure threads are in a good state
-  if (_weaken(_pthread_decimate)) {
-    _weaken(_pthread_decimate)();
-  }
+  if (_weaken(_pthread_decimate))
+    _weaken(_pthread_decimate)(kPosixThreadZombie);
   if (_weaken(pthread_orphan_np) && !_weaken(pthread_orphan_np)()) {
     tinyprint(2, "error: tests ended with threads still active\n", NULL);
     _Exit(1);
   }
 
   // check for memory leaks
-  if (!g_testlib_failed) {
+  AssertNoLocksAreHeld();
+  if (!g_testlib_failed)
     CheckForMemoryLeaks();
-  }
 
   // we're done!
   int status = MIN(255, g_testlib_failed);
diff --git a/libc/testlib/testrunner.c b/libc/testlib/testrunner.c
index f77738c05..b8498e1eb 100644
--- a/libc/testlib/testrunner.c
+++ b/libc/testlib/testrunner.c
@@ -22,11 +22,11 @@
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/getenv.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/getenv.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/process.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/rand.h"
@@ -34,6 +34,7 @@
 #include "libc/str/str.h"
 #include "libc/testlib/aspect.internal.h"
 #include "libc/testlib/testlib.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/x/x.h"
 
@@ -52,7 +53,7 @@ void testlib_finish(void) {
 void testlib_error_enter(const char *file, const char *func) {
   ftrace_enabled(-1);
   strace_enabled(-1);
-  pthread_mutex_lock(&testlib_error_lock);
+  _pthread_mutex_lock(&testlib_error_lock);
   if (!IsWindows())
     sys_getpid(); /* make strace easier to read */
   if (!IsWindows())
@@ -67,7 +68,7 @@ void testlib_error_enter(const char *file, const char *func) {
 void testlib_error_leave(void) {
   strace_enabled(+1);
   ftrace_enabled(+1);
-  pthread_mutex_unlock(&testlib_error_lock);
+  _pthread_mutex_unlock(&testlib_error_lock);
 }
 
 wontreturn void testlib_abort(void) {
diff --git a/libc/testlib/trace.c b/libc/testlib/trace.c
new file mode 100644
index 000000000..ca9b753c8
--- /dev/null
+++ b/libc/testlib/trace.c
@@ -0,0 +1,151 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "trace.h"
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <threads.h>
+#include <unistd.h>
+
+struct TraceEvent {
+  unsigned long long ts;
+  int pid;
+  int tid;
+  const char* name;
+  const char* cat;
+  char ph;
+};
+
+static int g_pid;
+static atomic_bool g_oom;
+static atomic_int g_count;
+static thread_local int g_id;
+static thread_local int g_ids;
+static thread_local int g_tid;
+static unsigned long g_start_rdtsc;
+static struct TraceEvent g_events[1000000];
+
+static unsigned long rdtsc(void) {
+#ifdef __x86_64__
+  unsigned ax, dx;
+  __asm__ volatile("rdtsc" : "=a"(ax), "=d"(dx));
+  return (unsigned long)dx << 32 | ax;
+#else
+  unsigned long c;
+  __asm__ volatile("mrs %0, cntvct_el0" : "=r"(c));
+  return c * 48;  // the fudge factor
+#endif
+}
+
+static int cosmo_trace_oom(void) {
+  if (atomic_load_explicit(&g_oom, memory_order_relaxed))
+    return -1;
+  if (atomic_exchange_explicit(&g_oom, true, memory_order_acq_rel))
+    return -1;
+  fprintf(stderr, "warning: ran out of trace event memory\n");
+  return -1;
+}
+
+static int cosmo_trace_reserve(int count) {
+  int id = atomic_load_explicit(&g_count, memory_order_relaxed);
+  if (id + count > sizeof(g_events) / sizeof(*g_events))
+    return cosmo_trace_oom();
+  id = atomic_fetch_add_explicit(&g_count, count, memory_order_acq_rel);
+  if (id + count > sizeof(g_events) / sizeof(*g_events))
+    return cosmo_trace_oom();
+  return id;
+}
+
+static void cosmo_trace_event(int id, const char* name, const char* cat,
+                              char ph) {
+  g_events[id].ts = rdtsc();
+  g_events[id].pid = g_pid ? g_pid - 1 : getpid();
+  g_events[id].tid = g_tid ? g_tid - 1 : gettid();
+  g_events[id].name = name;
+  g_events[id].cat = cat;
+  g_events[id].ph = ph;
+}
+
+void cosmo_trace_set_pid(int pid) {
+  g_pid = pid + 1;
+}
+
+void cosmo_trace_set_tid(int tid) {
+  g_tid = tid + 1;
+}
+
+void cosmo_trace_begin(const char* name) {
+  if (g_ids < 2) {
+    g_ids = 20;
+    g_id = cosmo_trace_reserve(g_ids);
+    if (g_id == -1) {
+      g_ids = 0;
+      return;
+    }
+  }
+  cosmo_trace_event(g_id++, name, "category", 'B');
+  --g_ids;
+}
+
+void cosmo_trace_end(const char* name) {
+  if (g_ids < 1)
+    return;
+  cosmo_trace_event(g_id++, name, "category", 'E');
+  --g_ids;
+}
+
+static void cosmo_trace_save(const char* filename) {
+  int count = atomic_load_explicit(&g_count, memory_order_relaxed);
+  if (!count)
+    return;
+  fprintf(stderr, "saving trace to %s...\n", filename);
+  FILE* file = fopen(filename, "w");
+  if (!file) {
+    perror(filename);
+    return;
+  }
+  fprintf(file, "[\n");
+  bool once = false;
+  for (int i = 0; i < count; i++) {
+    if (!g_events[i].name)
+      continue;
+    if (!once) {
+      once = true;
+    } else {
+      fputs(",\n", file);
+    }
+    fprintf(file,
+            "{\"name\": \"%s\", \"cat\": \"%s\", \"ph\": \"%c\", "
+            "\"ts\": %.3f, \"pid\": %d, \"tid\": %d}",
+            g_events[i].name, g_events[i].cat, g_events[i].ph,
+            (g_events[i].ts - g_start_rdtsc) / 3000., g_events[i].pid,
+            g_events[i].tid);
+  }
+  fprintf(file, "\n]\n");
+  fclose(file);
+}
+
+__attribute__((__constructor__)) static void trace_startup(void) {
+  g_start_rdtsc = rdtsc();
+}
+
+__attribute__((__destructor__)) static void trace_shutdown(void) {
+  cosmo_trace_save("trace.json");  // see chrome://tracing/
+}
diff --git a/libc/testlib/trace.h b/libc/testlib/trace.h
new file mode 100644
index 000000000..05d438ff5
--- /dev/null
+++ b/libc/testlib/trace.h
@@ -0,0 +1,11 @@
+#ifndef COSMOPOLITAN_LIBC_TESTLIB_TRACE_H_
+#define COSMOPOLITAN_LIBC_TESTLIB_TRACE_H_
+COSMOPOLITAN_C_START_
+
+void cosmo_trace_set_pid(int);
+void cosmo_trace_set_tid(int);
+void cosmo_trace_begin(const char*);
+void cosmo_trace_end(const char*);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_TESTLIB_TRACE_H_ */
diff --git a/libc/testlib/viewables.S b/libc/testlib/viewables.S
index aa5154a93..f367d3577 100644
--- a/libc/testlib/viewables.S
+++ b/libc/testlib/viewables.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 .rodata
 
 //	Nontrivial NUL-terminated string test vector.
diff --git a/libc/thread/freebsd.internal.h b/libc/thread/freebsd.internal.h
index 97a7c9e06..f7fec2ed5 100644
--- a/libc/thread/freebsd.internal.h
+++ b/libc/thread/freebsd.internal.h
@@ -47,7 +47,8 @@ struct _umtx_time {
   uint32_t _clockid;
 };
 
-int sys_umtx_timedwait_uint(_Atomic(int) *, int, bool, const struct timespec *);
+int sys_umtx_timedwait_uint(_Atomic(int) *, int, bool, int,
+                            const struct timespec *);
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_THREAD_FREEBSD_INTERNAL_H_ */
diff --git a/libc/thread/getitimer.c b/libc/thread/getitimer.c
index 4e37b0d40..afa356d18 100644
--- a/libc/thread/getitimer.c
+++ b/libc/thread/getitimer.c
@@ -20,8 +20,8 @@
 #include "libc/calls/struct/itimerval.h"
 #include "libc/calls/struct/itimerval.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 
 /**
diff --git a/libc/runtime/isstackoverflow.c b/libc/thread/isstackoverflow.c
similarity index 75%
rename from libc/runtime/isstackoverflow.c
rename to libc/thread/isstackoverflow.c
index efe0d0696..850eb5a60 100644
--- a/libc/runtime/isstackoverflow.c
+++ b/libc/thread/isstackoverflow.c
@@ -19,21 +19,40 @@
 #include "libc/calls/struct/siginfo.h"
 #include "libc/calls/struct/ucontext.internal.h"
 #include "libc/calls/ucontext.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/auxv.h"
 #include "libc/sysv/consts/sig.h"
+#include "libc/thread/thread.h"
 
 /**
- * Returns true if signal is most likely a stack overflow.
+ * Returns true if signal is caused by stack overflow.
  */
 char __is_stack_overflow(siginfo_t *si, void *arg) {
+
+  // sanity check
   ucontext_t *uc = arg;
   if (!si || !uc)
     return false;
-  if (si->si_signo != SIGSEGV && si->si_signo != SIGBUS)
+  if (si->si_signo != SIGSEGV &&  //
+      si->si_signo != SIGBUS)
     return false;
-  intptr_t sp = uc->uc_mcontext.SP;
-  intptr_t fp = (intptr_t)si->si_addr;
-  return ABS(fp - sp) < getauxval(AT_PAGESZ);
+
+  // get stack information
+  pthread_attr_t attr;
+  if (pthread_getattr_np(pthread_self(), &attr))
+    return false;
+  size_t guardsize;
+  if (pthread_attr_getguardsize(&attr, &guardsize))
+    return false;
+  void *stackaddr;
+  size_t stacksize;
+  if (pthread_attr_getstack(&attr, &stackaddr, &stacksize))
+    return false;
+
+  // determine if faulting address is inside guard region
+  char *x = (char *)si->si_addr;
+  char *lo = (char *)stackaddr - guardsize;
+  char *hi = (char *)stackaddr;
+  return lo <= x && x < hi;
 }
diff --git a/libc/thread/itimer.c b/libc/thread/itimer.c
index a4b63a0d5..fd93cf00d 100644
--- a/libc/thread/itimer.c
+++ b/libc/thread/itimer.c
@@ -24,27 +24,38 @@
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/struct/timeval.h"
 #include "libc/cosmo.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/maps.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/processcreationflags.h"
 #include "libc/nt/thread.h"
+#include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
-#include "libc/thread/itimer.internal.h"
+#include "libc/thread/itimer.h"
+#include "libc/thread/posixthread.internal.h"
+#include "libc/thread/thread2.h"
 #include "libc/thread/tls.h"
-#include "third_party/nsync/mu.h"
 #ifdef __x86_64__
 
-struct IntervalTimer __itimer;
+#define STACK_SIZE 65536
 
-static textwindows dontinstrument uint32_t __itimer_worker(void *arg) {
+textwindows dontinstrument static uint32_t __itimer_worker(void *arg) {
   struct CosmoTib tls;
-  __bootstrap_tls(&tls, __builtin_frame_address(0));
+  char *sp = __builtin_frame_address(0);
+  __bootstrap_tls(&tls, sp);
+  __maps_track(
+      (char *)(((uintptr_t)sp + __pagesize - 1) & -__pagesize) - STACK_SIZE,
+      STACK_SIZE, PROT_READ | PROT_WRITE,
+      MAP_PRIVATE | MAP_ANONYMOUS | MAP_NOFORK);
   for (;;) {
     bool dosignal = false;
     struct timeval now, waituntil;
-    nsync_mu_lock(&__itimer.lock);
+    __itimer_lock();
     now = timeval_real();
     if (timeval_iszero(__itimer.it.it_value)) {
       waituntil = timeval_max;
@@ -65,56 +76,46 @@ static textwindows dontinstrument uint32_t __itimer_worker(void *arg) {
         dosignal = true;
       }
     }
-    nsync_mu_unlock(&__itimer.lock);
-    if (dosignal) {
+    __itimer_unlock();
+    if (dosignal)
       __sig_generate(SIGALRM, SI_TIMER);
-    }
-    nsync_mu_lock(&__itimer.lock);
-    nsync_cv_wait_with_deadline(&__itimer.cond, &__itimer.lock,
-                                timeval_totimespec(waituntil), 0);
-    nsync_mu_unlock(&__itimer.lock);
+    __itimer_lock();
+    struct timespec deadline = timeval_totimespec(waituntil);
+    _pthread_cond_timedwait(&__itimer.cond, &__itimer.lock, &deadline);
+    __itimer_unlock();
   }
   return 0;
 }
 
-static textwindows void __itimer_setup(void) {
-  __itimer.thread = CreateThread(0, 65536, __itimer_worker, 0,
+textwindows static void __itimer_setup(void) {
+  __itimer.thread = CreateThread(0, STACK_SIZE, __itimer_worker, 0,
                                  kNtStackSizeParamIsAReservation, 0);
 }
 
-textwindows void __itimer_wipe(void) {
-  // this function is called by fork(), because
-  // timers aren't inherited by forked subprocesses
-  bzero(&__itimer, sizeof(__itimer));
-}
-
 textwindows int sys_setitimer_nt(int which, const struct itimerval *neu,
                                  struct itimerval *old) {
   struct itimerval config;
   cosmo_once(&__itimer.once, __itimer_setup);
   if (which != ITIMER_REAL || (neu && (!timeval_isvalid(neu->it_value) ||
-                                       !timeval_isvalid(neu->it_interval)))) {
+                                       !timeval_isvalid(neu->it_interval))))
     return einval();
-  }
-  if (neu) {
+  if (neu)
     // POSIX defines setitimer() with the restrict keyword but let's
     // accommodate the usage setitimer(ITIMER_REAL, &it, &it) anyway
     config = *neu;
-  }
   BLOCK_SIGNALS;
-  nsync_mu_lock(&__itimer.lock);
+  __itimer_lock();
   if (old) {
     old->it_interval = __itimer.it.it_interval;
     old->it_value = timeval_subz(__itimer.it.it_value, timeval_real());
   }
   if (neu) {
-    if (!timeval_iszero(config.it_value)) {
+    if (!timeval_iszero(config.it_value))
       config.it_value = timeval_add(config.it_value, timeval_real());
-    }
     __itimer.it = config;
-    nsync_cv_signal(&__itimer.cond);
+    _pthread_cond_signal(&__itimer.cond);
   }
-  nsync_mu_unlock(&__itimer.lock);
+  __itimer_unlock();
   ALLOW_SIGNALS;
   return 0;
 }
diff --git a/libc/thread/itimer.h b/libc/thread/itimer.h
new file mode 100644
index 000000000..a5193d987
--- /dev/null
+++ b/libc/thread/itimer.h
@@ -0,0 +1,23 @@
+#ifndef COSMOPOLITAN_LIBC_ITIMER_H_
+#define COSMOPOLITAN_LIBC_ITIMER_H_
+#include "libc/atomic.h"
+#include "libc/calls/struct/itimerval.h"
+#include "libc/thread/thread.h"
+COSMOPOLITAN_C_START_
+
+struct IntervalTimer {
+  atomic_uint once;
+  intptr_t thread;
+  pthread_mutex_t lock;
+  pthread_cond_t cond;
+  struct itimerval it;
+};
+
+extern struct IntervalTimer __itimer;
+
+void __itimer_lock(void);
+void __itimer_unlock(void);
+void __itimer_wipe_and_reset(void);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_ITIMER_H_ */
diff --git a/libc/thread/itimer.internal.h b/libc/thread/itimer.internal.h
deleted file mode 100644
index 41d721216..000000000
--- a/libc/thread/itimer.internal.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_ITIMER_H_
-#define COSMOPOLITAN_LIBC_ITIMER_H_
-#include "libc/atomic.h"
-#include "libc/calls/struct/itimerval.h"
-#include "third_party/nsync/cv.h"
-#include "third_party/nsync/mu.h"
-COSMOPOLITAN_C_START_
-
-struct IntervalTimer {
-  atomic_uint once;
-  intptr_t thread;
-  nsync_mu lock;
-  nsync_cv cond;
-  struct itimerval it;
-};
-
-extern struct IntervalTimer __itimer;
-
-void __itimer_wipe(void);
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_ITIMER_H_ */
diff --git a/libc/thread/lock.h b/libc/thread/lock.h
new file mode 100644
index 000000000..75b0177a2
--- /dev/null
+++ b/libc/thread/lock.h
@@ -0,0 +1,46 @@
+#ifndef COSMOPOLITAN_LIBC_THREAD_LOCK_H_
+#define COSMOPOLITAN_LIBC_THREAD_LOCK_H_
+COSMOPOLITAN_C_START_
+
+//
+//                                                     ┌undead
+//                                                     │
+//                                                     │┌dead
+//                                                     ││
+//                                                     ││┌robust
+//                                                     │││
+//                                                     │││  ┌depth
+//                                                     │││  │
+//         COSMOPOLITAN MUTEXES                        │││  │   ┌waited
+//                                                     │││  │   │
+//                                                     │││  │   │┌locked
+//                                                     │││  │   ││
+//                                                     │││  │   ││┌pshared
+//                owner                                │││  │   │││
+//                 tid                                 │││  │   │││┌type
+//                  │                                  │││  │   ││││
+//   ┌──────────────┴───────────────┐                  │││┌─┴──┐│││├┐
+// 0b0000000000000000000000000000000000000000000000000000000000000000
+//
+
+#define MUTEX_DEPTH_MIN 0x00000020ull
+#define MUTEX_DEPTH_MAX 0x000007e0ull
+
+#define MUTEX_TYPE(word)    ((word) & 3)
+#define MUTEX_PSHARED(word) ((word) & 4)
+#define MUTEX_LOCKED(word)  ((word) & 8)
+#define MUTEX_WAITED(word)  ((word) & 16)
+#define MUTEX_DEPTH(word)   ((word) & MUTEX_DEPTH_MAX)
+#define MUTEX_OWNER(word)   ((word) >> 32)
+
+#define MUTEX_LOCK(word)                 (((word) & 7) | 8)
+#define MUTEX_UNLOCK(word)               ((word) & 7)
+#define MUTEX_SET_WAITED(word)           ((word) | 16)
+#define MUTEX_SET_TYPE(word, type)       (((word) & ~3ull) | (type))
+#define MUTEX_SET_PSHARED(word, pshared) (((word) & ~4ull) | (pshared))
+#define MUTEX_INC_DEPTH(word)            ((word) + MUTEX_DEPTH_MIN)
+#define MUTEX_DEC_DEPTH(word)            ((word) - MUTEX_DEPTH_MIN)
+#define MUTEX_SET_OWNER(word, tid)       ((uint64_t)(tid) << 32 | (uint32_t)(word))
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_LIBC_THREAD_LOCK_H_ */
diff --git a/libc/thread/makecontext.c b/libc/thread/makecontext.c
index 0108979f7..328ff6a4e 100644
--- a/libc/thread/makecontext.c
+++ b/libc/thread/makecontext.c
@@ -23,7 +23,7 @@
 #include "libc/nexgen32e/nexgen32e.h"
 #include "libc/nexgen32e/stackframe.h"
 #include "libc/runtime/runtime.h"
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #include "libc/str/str.h"
 #include "libc/thread/thread.h"
 
diff --git a/libc/thread/mapstack.c b/libc/thread/mapstack.c
new file mode 100644
index 000000000..470ab58a6
--- /dev/null
+++ b/libc/thread/mapstack.c
@@ -0,0 +1,56 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/cosmo.h"
+#include "libc/errno.h"
+#include "libc/runtime/stack.h"
+
+/**
+ * Allocates stack.
+ *
+ * The size of your returned stack is always GetStackSize().
+ *
+ * The bottom 4096 bytes of your stack can't be used, since it's always
+ * reserved for a read-only guard page. With ASAN it'll be poisoned too.
+ *
+ * The top 16 bytes of a stack can't be used due to openbsd:stackbound
+ * and those bytes are also poisoned under ASAN build modes.
+ *
+ * @return stack bottom address on success, or null w/ errno
+ */
+void *NewCosmoStack(void) {
+  void *stackaddr;
+  size_t stacksize = GetStackSize();
+  size_t guardsize = GetGuardSize();
+  errno_t err = cosmo_stack_alloc(&stacksize, &guardsize, &stackaddr);
+  if (!err)
+    return stackaddr;
+  errno = err;
+  return 0;
+}
+
+/**
+ * Frees stack.
+ *
+ * @param stackaddr was allocated by NewCosmoStack()
+ * @return 0 on success, or -1 w/ errno
+ */
+int FreeCosmoStack(void *stackaddr) {
+  cosmo_stack_free(stackaddr, GetStackSize(), GetGuardSize());
+  return 0;
+}
diff --git a/libc/thread/mktls.c b/libc/thread/mktls.c
index 2f7129a5c..20d574b93 100644
--- a/libc/thread/mktls.c
+++ b/libc/thread/mktls.c
@@ -19,7 +19,7 @@
 #include "ape/sections.internal.h"
 #include "libc/dce.h"
 #include "libc/intrin/atomic.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
@@ -40,11 +40,9 @@ static char *_mktls_finish(struct CosmoTib **out_tib, char *mem,
   tib->tib_ftrace = old->tib_ftrace;
   tib->tib_strace = old->tib_strace;
   tib->tib_sigmask = old->tib_sigmask;
-  tib->tib_locale = (intptr_t)&__c_dot_utf8_locale;
-  atomic_store_explicit(&tib->tib_tid, -1, memory_order_relaxed);
-  if (out_tib) {
+  atomic_init(&tib->tib_ctid, -1);
+  if (out_tib)
     *out_tib = tib;
-  }
   return mem;
 }
 
diff --git a/libc/thread/posixthread.internal.h b/libc/thread/posixthread.internal.h
index cc9389d8c..2a4ca4c19 100644
--- a/libc/thread/posixthread.internal.h
+++ b/libc/thread/posixthread.internal.h
@@ -9,8 +9,7 @@
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 
-#define PT_BLOCKER_SEM ((atomic_int *)-1)
-#define PT_BLOCKER_IO  ((atomic_int *)-2)
+#define PT_BLOCKER_EVENT ((atomic_int *)-1)
 
 COSMOPOLITAN_C_START_
 
@@ -69,50 +68,60 @@ enum PosixThreadStatus {
 
 #define POSIXTHREAD_CONTAINER(e) DLL_CONTAINER(struct PosixThread, list, e)
 
+typedef struct __locale_struct *locale_t;
+
 struct PosixThread {
   int pt_flags;            // 0x00: see PT_* constants
   atomic_int pt_canceled;  // 0x04: thread has bad beliefs
   _Atomic(enum PosixThreadStatus) pt_status;
-  atomic_int ptid;            // transitions 0 → tid
-  atomic_int pt_refs;         // negative means free
+  _Atomic(atomic_int *) pt_blocker;
+  atomic_int pt_refs;         // prevents decimation
   void *(*pt_start)(void *);  // creation callback
-  void *pt_arg;               // start's parameter
-  void *pt_rc;                // start's return value
+  void *pt_val;               // start param / return val
   char *pt_tls;               // bottom of tls allocation
   struct CosmoTib *tib;       // middle of tls allocation
   struct Dll list;            // list of threads
   struct _pthread_cleanup_buffer *pt_cleanup;
-  _Atomic(atomic_int *) pt_blocker;
   uint64_t pt_blkmask;
-  int64_t pt_semaphore;
-  intptr_t pt_iohandle;
-  void *pt_ioverlap;
-  jmp_buf pt_exiter;
+  int64_t pt_event;
+  locale_t pt_locale;
+  intptr_t pt_exiter[5];
   pthread_attr_t pt_attr;
+  atomic_bool pt_intoff;
 };
 
 typedef void (*atfork_f)(void);
 
 extern struct Dll *_pthread_list;
+extern atomic_uint _pthread_count;
 extern struct PosixThread _pthread_static;
 extern _Atomic(pthread_key_dtor) _pthread_key_dtor[PTHREAD_KEYS_MAX];
 
-int _pthread_atfork(atfork_f, atfork_f, atfork_f) libcesque;
+int _pthread_cond_signal(pthread_cond_t *) dontthrow paramsnonnull();
+int _pthread_mutex_lock(pthread_mutex_t *) dontthrow paramsnonnull();
+int _pthread_mutex_trylock(pthread_mutex_t *) dontthrow paramsnonnull();
+int _pthread_mutex_unlock(pthread_mutex_t *) dontthrow paramsnonnull();
+int _pthread_mutex_wipe_np(pthread_mutex_t *) libcesque paramsnonnull();
 int _pthread_reschedule(struct PosixThread *) libcesque;
 int _pthread_setschedparam_freebsd(int, int, const struct sched_param *);
 int _pthread_tid(struct PosixThread *) libcesque;
 intptr_t _pthread_syshand(struct PosixThread *) libcesque;
 long _pthread_cancel_ack(void) libcesque;
-void _pthread_decimate(void) libcesque;
-void _pthread_free(struct PosixThread *, bool) libcesque;
-void _pthread_init(void) libcesque;
-void _pthread_lock(void) libcesque;
-void _pthread_onfork_child(void) libcesque;
-void _pthread_onfork_parent(void) libcesque;
-void _pthread_onfork_prepare(void) libcesque;
-void _pthread_unlock(void) libcesque;
-void _pthread_unref(struct PosixThread *) libcesque;
-void _pthread_zombify(struct PosixThread *) libcesque;
+void _pthread_decimate(enum PosixThreadStatus) dontthrow;
+void _pthread_free(struct PosixThread *) libcesque paramsnonnull();
+void _pthread_lock(void) dontthrow;
+void _pthread_onfork_child(void) dontthrow;
+void _pthread_onfork_parent(void) dontthrow;
+void _pthread_onfork_prepare(void) dontthrow;
+void _pthread_unlock(void) dontthrow;
+void _pthread_zombify(struct PosixThread *) dontthrow;
+
+int _pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *) dontthrow
+    paramsnonnull();
+
+int _pthread_cond_timedwait(pthread_cond_t *, pthread_mutex_t *,
+                            const struct timespec *) dontthrow
+    paramsnonnull((1, 2));
 
 forceinline pureconst struct PosixThread *_pthread_self(void) {
   return (struct PosixThread *)__get_tls()->tib_pthread;
@@ -122,5 +131,9 @@ forceinline void _pthread_ref(struct PosixThread *pt) {
   atomic_fetch_add_explicit(&pt->pt_refs, 1, memory_order_relaxed);
 }
 
+forceinline void _pthread_unref(struct PosixThread *pt) {
+  atomic_fetch_sub_explicit(&pt->pt_refs, 1, memory_order_acq_rel);
+}
+
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_THREAD_POSIXTHREAD_INTERNAL_H_ */
diff --git a/libc/thread/pt.internal.h b/libc/thread/pt.internal.h
index d054c8bab..c211c273f 100644
--- a/libc/thread/pt.internal.h
+++ b/libc/thread/pt.internal.h
@@ -8,5 +8,7 @@
 #define PT_MASKED         16
 #define PT_INCANCEL       32
 #define PT_OPENBSD_KLUDGE 64
+#define PT_EXITING        128
+#define PT_OWNSIGALTSTACK 256
 
 #endif /* COSMOPOLITAN_LIBC_THREAD_PT_H_ */
diff --git a/libc/thread/pthread_atfork.c b/libc/thread/pthread_atfork.c
index 251d9c81f..ec8cc05fc 100644
--- a/libc/thread/pthread_atfork.c
+++ b/libc/thread/pthread_atfork.c
@@ -17,37 +17,42 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/atomic.h"
-#include "libc/calls/state.internal.h"
 #include "libc/cosmo.h"
-#include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/atomic.h"
-#include "libc/intrin/dll.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
-#include "libc/proc/proc.internal.h"
-#include "libc/runtime/runtime.h"
-#include "libc/str/str.h"
+#include "libc/intrin/strace.h"
+#include "libc/mem/mem.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
-#include "libc/thread/tls.h"
 
 struct AtFork {
   struct AtFork *p[2];
   atfork_f f[3];
 };
 
-static struct AtForks {
-  pthread_spinlock_t lock;
+struct AtForks {
+  atomic_uint once;
+  pthread_mutex_t lock;
   struct AtFork *list;
-  struct AtFork pool[64];
-  atomic_int allocated;
-} _atforks;
+};
+
+static struct AtForks _atforks = {
+    .lock = PTHREAD_MUTEX_INITIALIZER,
+};
+
+static void pthread_atfork_clear(void) {
+  struct AtFork *a, *b;
+  for (a = _atforks.list; a; a = b) {
+    b = a->p[0];
+    free(a);
+  }
+}
+
+static void pthread_atfork_init(void) {
+  atexit(pthread_atfork_clear);
+}
 
 static void _pthread_onfork(int i, const char *op) {
   struct AtFork *a;
-  if (!i)
-    pthread_spin_lock(&_atforks.lock);
   for (a = _atforks.list; a; a = a->p[!i]) {
     if (a->f[i]) {
       STRACE("pthread_atfork(%s, %t)", op, a->f[i]);
@@ -55,47 +60,123 @@ static void _pthread_onfork(int i, const char *op) {
     }
     _atforks.list = a;
   }
-  if (i)
-    pthread_spin_unlock(&_atforks.lock);
 }
 
 void _pthread_onfork_prepare(void) {
+  _pthread_mutex_lock(&_atforks.lock);
   _pthread_onfork(0, "prepare");
 }
 
 void _pthread_onfork_parent(void) {
   _pthread_onfork(1, "parent");
+  _pthread_mutex_unlock(&_atforks.lock);
 }
 
 void _pthread_onfork_child(void) {
+  _pthread_mutex_wipe_np(&_atforks.lock);
   _pthread_onfork(2, "child");
 }
 
-static struct AtFork *_pthread_atfork_alloc(void) {
-  int i, n = ARRAYLEN(_atforks.pool);
-  if (atomic_load_explicit(&_atforks.allocated, memory_order_relaxed) < n &&
-      (i = atomic_fetch_add(&_atforks.allocated, 1)) < n) {
-    return _atforks.pool + i;
-  } else {
-    return 0;
-  }
-}
-
-int _pthread_atfork(atfork_f prepare, atfork_f parent, atfork_f child) {
-  int rc;
+/**
+ * Registers fork callbacks.
+ *
+ * When fork happens, your prepare functions will be called in the
+ * reverse order they were registered. Then, in the parent and child
+ * processes, their callbacks will be called in the same order they were
+ * registered.
+ *
+ * One big caveat with fork() is that it hard kills all threads except
+ * the calling thread. So let's say one of those threads was printing to
+ * stdout while it was killed. In that case, the stdout lock will still
+ * be held when your child process comes alive, which means that the
+ * child will deadlock next time it tries to print.
+ *
+ * The solution for that is simple. Every lock in your process should be
+ * registered with this interface. However there's one highly important
+ * thing you need to know. Locks must follow a consistent hierarchy. So
+ * the order in which you register locks matters. If nested locks aren't
+ * acquired in the same order globally, then rarely occurring deadlocks
+ * will happen. So what we recommend is that you hunt down all the locks
+ * that exist in your app and its dependencies, and register them all at
+ * once from your main() function at startup. This ensures a clear order
+ * and if you aren't sure what that order should be, cosmo libc has got
+ * you covered. Simply link your program with the `cosmocc -mdbg` flag
+ * and cosmo will detect locking violations with your `pthread_mutex_t`
+ * objects and report them by printing the strongly connected component.
+ * This will include the demangled symbol name of each mutex, assuming
+ * the `pthread_mutex_t` objects are stored in static memory. cosmo.h
+ * also exposes a deadlock API that lets you incorporate your own lock
+ * object types into this error checking system, which we also use to
+ * verify the entire libc runtime itself. See libc/intrin/deadlock.c.
+ *
+ * Special care should be taken when using this interface in libraries.
+ * While it may seem tempting to use something like a `__constructor__`
+ * attribute to register your mutexes in a clean and abstracted way, it
+ * is only appropriate if your mutex is guarding pure memory operations
+ * and poses zero risk of nesting with locks outside your library. For
+ * example, calling open() or printf() while holding your lock will do
+ * just that, since the C runtime functions you may consider pure will
+ * actually use mutexes under the hood, which are also validated under
+ * `cosmocc -mdbg` builds. So if your locks can't be made unnestable
+ * pure memory operations, then you should consider revealing their
+ * existence to users of your library.
+ *
+ * Here's an example of how pthread_atfork() can be used:
+ *
+ *     static struct {
+ *       pthread_once_t once;
+ *       pthread_mutex_t lock;
+ *       // data structures...
+ *     } g_lib;
+ *
+ *     static void lib_lock(void) {
+ *       pthread_mutex_lock(&g_lib.lock);
+ *     }
+ *
+ *     static void lib_unlock(void) {
+ *       pthread_mutex_unlock(&g_lib.lock);
+ *     }
+ *
+ *     static void lib_wipe(void) {
+ *       pthread_mutex_wipe_np(&g_lib.lock);
+ *     }
+ *
+ *     static void lib_setup(void) {
+ *       pthread_mutex_init(&g_lib.lock, 0);
+ *       pthread_atfork(lib_lock, lib_unlock, lib_wipe);
+ *     }
+ *
+ *     static void lib_init(void) {
+ *       pthread_once(&g_lib.once, lib_setup);
+ *     }
+ *
+ *     void lib(void) {
+ *       lib_init();
+ *       lib_lock();
+ *       // do stuff...
+ *       lib_unlock();
+ *     }
+ *
+ * @param prepare is run by fork() before forking happens
+ * @param parent is run by fork() after forking happens in parent process
+ * @param child is run by fork() after forking happens in childe process
+ * @return 0 on success, or errno on error
+ * @raise ENOMEM if we require more vespene gas
+ */
+int pthread_atfork(atfork_f prepare, atfork_f parent, atfork_f child) {
+  cosmo_once(&_atforks.once, pthread_atfork_init);
   struct AtFork *a;
-  if (!(a = _pthread_atfork_alloc()))
+  if (!(a = calloc(1, sizeof(struct AtFork))))
     return ENOMEM;
   a->f[0] = prepare;
   a->f[1] = parent;
   a->f[2] = child;
-  pthread_spin_lock(&_atforks.lock);
+  _pthread_mutex_lock(&_atforks.lock);
   a->p[0] = 0;
   a->p[1] = _atforks.list;
   if (_atforks.list)
     _atforks.list->p[0] = a;
   _atforks.list = a;
-  pthread_spin_unlock(&_atforks.lock);
-  rc = 0;
-  return rc;
+  _pthread_mutex_unlock(&_atforks.lock);
+  return 0;
 }
diff --git a/libc/thread/pthread_attr_getguardsize.c b/libc/thread/pthread_attr_getguardsize.c
index 3d4f394d3..ba10c3014 100644
--- a/libc/thread/pthread_attr_getguardsize.c
+++ b/libc/thread/pthread_attr_getguardsize.c
@@ -19,7 +19,7 @@
 #include "libc/thread/thread.h"
 
 /**
- * Returns size of unmapped pages at bottom of stack.
+ * Returns size of protected region beneath thread stack.
  *
  * @param guardsize will be set to guard size in bytes
  * @return 0 on success, or errno on error
diff --git a/libc/thread/pthread_attr_getsigaltstack_np.c b/libc/thread/pthread_attr_getsigaltstack_np.c
new file mode 100644
index 000000000..c261a57a4
--- /dev/null
+++ b/libc/thread/pthread_attr_getsigaltstack_np.c
@@ -0,0 +1,34 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/runtime/stack.h"
+#include "libc/thread/thread.h"
+
+/**
+ * Returns configuration for thread signal stack.
+ *
+ * @param stackaddr will be set to signal stack address
+ * @return 0 on success, or errno on error
+ * @see pthread_attr_setsigaltstacksize_np()
+ */
+errno_t pthread_attr_getsigaltstack_np(const pthread_attr_t *attr,
+                                       void **stackaddr, size_t *stacksize) {
+  *stackaddr = attr->__sigaltstackaddr;
+  *stacksize = attr->__sigaltstacksize;
+  return 0;
+}
diff --git a/libc/thread/pthread_attr_getsigaltstacksize_np.c b/libc/thread/pthread_attr_getsigaltstacksize_np.c
new file mode 100644
index 000000000..b6115357a
--- /dev/null
+++ b/libc/thread/pthread_attr_getsigaltstacksize_np.c
@@ -0,0 +1,36 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/runtime/stack.h"
+#include "libc/thread/thread.h"
+
+/**
+ * Returns size of thread signal stack.
+ *
+ * This defaults to zero, which means that cosmo won't allocate a
+ * managed signal stack for newly created threads.
+ *
+ * @param x will be set to stack size in bytes
+ * @return 0 on success, or errno on error
+ * @see pthread_attr_setsigaltstacksize_np()
+ */
+errno_t pthread_attr_getsigaltstacksize_np(const pthread_attr_t *a,
+                                           size_t *stacksize) {
+  *stacksize = a->__sigaltstacksize;
+  return 0;
+}
diff --git a/libc/thread/pthread_attr_getstack.c b/libc/thread/pthread_attr_getstack.c
index 8b9a9c06d..27c744d81 100644
--- a/libc/thread/pthread_attr_getstack.c
+++ b/libc/thread/pthread_attr_getstack.c
@@ -20,15 +20,13 @@
 #include "libc/thread/thread.h"
 
 /**
- * Returns configuration for thread stack.
+ * Returns configuration for custom thread stack.
  *
- * This is a getter for a configuration attribute. By default, zeros are
- * returned. If pthread_attr_setstack() was called earlier, then this'll
- * return those earlier supplied values.
+ * If zero is returned to `*stackaddr` then a custom stack hasn't been
+ * specified by a previous call to pthread_attr_setstack().
  *
  * @param stackaddr will be set to stack address in bytes
  * @return 0 on success, or errno on error
- * @see pthread_attr_setstacksize()
  */
 errno_t pthread_attr_getstack(const pthread_attr_t *attr, void **stackaddr,
                               size_t *stacksize) {
diff --git a/libc/thread/pthread_attr_init.c b/libc/thread/pthread_attr_init.c
index 9db001b24..4ef1e9207 100644
--- a/libc/thread/pthread_attr_init.c
+++ b/libc/thread/pthread_attr_init.c
@@ -34,11 +34,13 @@
  * @see pthread_attr_setschedpolicy()
  * @see pthread_attr_setinheritsched()
  * @see pthread_attr_setscope()
+ * @see pthread_attr_setsigaltstack_np()
+ * @see pthread_attr_setsigaltstacksize_np()
  */
 errno_t pthread_attr_init(pthread_attr_t *attr) {
   *attr = (pthread_attr_t){
       .__stacksize = GetStackSize(),
-      .__guardsize = getauxval(AT_PAGESZ),
+      .__guardsize = GetGuardSize(),
   };
   return 0;
 }
diff --git a/libc/thread/pthread_attr_setdetachstate.c b/libc/thread/pthread_attr_setdetachstate.c
index 253f04495..e9a57a084 100644
--- a/libc/thread/pthread_attr_setdetachstate.c
+++ b/libc/thread/pthread_attr_setdetachstate.c
@@ -28,6 +28,10 @@
  *     pthread_create(0, &attr, func, 0);
  *     pthread_attr_destroy(&attr);
  *
+ * If you use this, please be warned that your thread might run and exit
+ * before pthread_create() even returns. You really should assume it can
+ * not be used with any pthread APIs from the calling thread.
+ *
  * @param detachstate can be one of
  *     - `PTHREAD_CREATE_JOINABLE` (default)
  *     - `PTHREAD_CREATE_DETACHED`
diff --git a/libc/thread/pthread_attr_setguardsize.c b/libc/thread/pthread_attr_setguardsize.c
index 2905a7605..4b776cdd9 100644
--- a/libc/thread/pthread_attr_setguardsize.c
+++ b/libc/thread/pthread_attr_setguardsize.c
@@ -16,28 +16,16 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/errno.h"
 #include "libc/thread/thread.h"
 
 /**
- * Sets size of unmapped pages at bottom of stack.
+ * Sets minimum size of protected region beneath thread stack.
  *
- * This value will be rounded up to the host microprocessor page size,
- * which is usually 4096 or 16384. It's important to write code in such
- * a way that that code can't skip over the guard area. GCC has warnings
- * like `-Wframe-larger-than=4096 -Walloca-larger-than=4096` which help
- * guarantee your code is safe in this regard. It should be assumed the
- * guard pages exist beneath the stack pointer, rather than the bottom
- * of the stack, since guard pages are also used to grow down commit,
- * which can be poked using CheckLargeStackAllocation().
- *
- * @param guardsize contains guard size in bytes
+ * @param guardsize contains guard size in bytes, which is implicitly
+ *     rounded up to `sysconf(_SC_PAGESIZE)`, or zero to disable
  * @return 0 on success, or errno on error
- * @raise EINVAL if `guardsize` is zero
  */
 errno_t pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize) {
-  if (!guardsize)
-    return EINVAL;
   attr->__guardsize = guardsize;
   return 0;
 }
diff --git a/libc/thread/pthread_attr_setsigaltstack_np.c b/libc/thread/pthread_attr_setsigaltstack_np.c
new file mode 100644
index 000000000..91c08f107
--- /dev/null
+++ b/libc/thread/pthread_attr_setsigaltstack_np.c
@@ -0,0 +1,42 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/limits.h"
+#include "libc/runtime/runtime.h"
+#include "libc/thread/thread.h"
+
+/**
+ * Defines user-owned signal stack for thread.
+ */
+errno_t pthread_attr_setsigaltstack_np(pthread_attr_t *attr, void *stackaddr,
+                                       size_t stacksize) {
+  if (!stackaddr) {
+    attr->__sigaltstackaddr = 0;
+    attr->__sigaltstacksize = 0;
+    return 0;
+  }
+  if (stacksize > INT_MAX)
+    return EINVAL;
+  if (stacksize < __get_minsigstksz())
+    return EINVAL;
+  attr->__sigaltstackaddr = stackaddr;
+  attr->__sigaltstacksize = stacksize;
+  return 0;
+}
diff --git a/libc/thread/pthread_attr_setsigaltstacksize_np.c b/libc/thread/pthread_attr_setsigaltstacksize_np.c
new file mode 100644
index 000000000..73da4ad30
--- /dev/null
+++ b/libc/thread/pthread_attr_setsigaltstacksize_np.c
@@ -0,0 +1,78 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/errno.h"
+#include "libc/limits.h"
+#include "libc/runtime/runtime.h"
+#include "libc/thread/thread.h"
+
+/**
+ * Defines size of cosmo-owned signal stack for thread.
+ *
+ * The sigaltstack() function is useful for writing robust programs that
+ * can recover from the occasional thread having a stack overflow rather
+ * than having the entire process crash. To use it normally, sigaltstack
+ * needs to be called at the start of each thread with a unique piece of
+ * memory. However this is challenging to do *correctly* without support
+ * from the POSIX threads runtime, since canceled or crashed threads may
+ * need to execute on the signal stack during pthread_exit() which would
+ * prevent a thread-local storage key destructor from free()'ing it.
+ *
+ * By default pthread_create() will not install a sigaltstack() on newly
+ * created threads. If this function is called, on the attributes object
+ * that gets passed to pthread_create(), then it'll use malloc() to make
+ * a stack for the thread using the size you specify here. The threading
+ * runtime will also free that memory safely after complete termination.
+ *
+ *     pthread_t id;
+ *     pthread_attr_t attr;
+ *     pthread_attr_init(&attr);
+ *     pthread_attr_setguardsize(&attr, getpagesize());
+ *     pthread_attr_setsigaltstacksize_np(&attr, stacksize);
+ *     pthread_create(&id, &attr, func, 0);
+ *     pthread_attr_destroy(&attr);
+ *     pthread_join(id, 0);
+ *
+ * Try using a size of `sysconf(_SC_SIGSTKSZ)`. If you want the smallest
+ * size possible, then `sysconf(_SC_MINSIGSTKSZ) + 2048` is probably the
+ * smallest value that can reasonably expected to work with pthread_exit
+ *
+ *     struct sigaction sa;
+ *     sigemptyset(&sa.sa_mask);
+ *     sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
+ *     sa.sa_sigaction = on_crash_signal;
+ *     sigaction(SIGSEGV, &sa, 0);
+ *
+ * Please note that in order for this to work, your handlers for signals
+ * such as SIGSEGV and SIGBUS need to use SA_ONSTACK in your sa_flags.
+ *
+ * @param stacksize contains stack size in bytes, or 0 to disable
+ * @return 0 on success, or errno on error
+ * @raise EINVAL if `stacksize` is less than `sysconf(_SC_MINSIGSTKSZ)`
+ */
+errno_t pthread_attr_setsigaltstacksize_np(pthread_attr_t *a,
+                                           size_t stacksize) {
+  if (stacksize) {
+    if (stacksize > INT_MAX)
+      return EINVAL;
+    if (stacksize < __get_minsigstksz())
+      return EINVAL;
+  }
+  a->__sigaltstacksize = stacksize;
+  return 0;
+}
diff --git a/libc/thread/pthread_attr_setsigmask_np.c b/libc/thread/pthread_attr_setsigmask_np.c
index b46c94e57..a42e8b055 100644
--- a/libc/thread/pthread_attr_setsigmask_np.c
+++ b/libc/thread/pthread_attr_setsigmask_np.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
+#include "libc/sysv/consts/sig.h"
 #include "libc/thread/thread2.h"
 
 /**
diff --git a/libc/thread/pthread_attr_setstack.c b/libc/thread/pthread_attr_setstack.c
index f82be129f..9017362af 100644
--- a/libc/thread/pthread_attr_setstack.c
+++ b/libc/thread/pthread_attr_setstack.c
@@ -16,59 +16,40 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/dce.h"
 #include "libc/errno.h"
+#include "libc/runtime/stack.h"
 #include "libc/thread/thread.h"
 
 /**
- * Configures custom allocated stack for thread, e.g.
+ * Configures custom stack for thread.
  *
- *     pthread_t id;
- *     pthread_attr_t attr;
- *     char *stk = NewCosmoStack();
- *     pthread_attr_init(&attr);
- *     pthread_attr_setstack(&attr, stk, GetStackSize());
- *     pthread_create(&id, &attr, func, 0);
- *     pthread_attr_destroy(&attr);
- *     pthread_join(id, 0);
- *     FreeCosmoStack(stk);
+ * Normally you want to use pthread_attr_setstacksize() and
+ * pthread_attr_setguardsize() to configure how pthread_create()
+ * allocates stack memory for newly created threads. Cosmopolitan is
+ * very good at managing stack memory. However if you still want to
+ * allocate stack memory on your own, POSIX defines this function.
  *
- * Your stack must have at least `PTHREAD_STACK_MIN` bytes, which
- * Cosmpolitan Libc defines as `GetStackSize()`. It's a link-time
- * constant used by Actually Portable Executable that's 128 kb by
- * default. See libc/runtime/stack.h for docs on your stack limit
- * since the APE ELF phdrs are the one true source of truth here.
+ * Your `stackaddr` points to the byte at the very bottom of your stack.
+ * You are responsible for this memory. Your POSIX threads runtime will
+ * not free or unmap this allocation when the thread has terminated. If
+ * `stackaddr` is null then `stacksize` is ignored and default behavior
+ * is restored, i.e. pthread_create() will manage stack allocations.
  *
- * Cosmpolitan Libc runtime magic (e.g. ftrace) and memory safety
- * (e.g. kprintf) assumes that stack sizes are two-powers and are
- * aligned to that two-power. Conformance isn't required since we
- * say caveat emptor to those who don't maintain these invariants
- * please consider using NewCosmoStack(), which is always perfect
- * or use `mmap(0, GetStackSize() << 1, ...)` for a bigger stack.
+ * Your `stackaddr` could be created by malloc(). On OpenBSD,
+ * pthread_create() will augment your custom allocation so it's
+ * permissable by the kernel to use as a stack. You may also call
+ * Cosmopolitan APIs such NewCosmoStack() and cosmo_stack_alloc().
+ * Static memory can be used, but it won't reduce pthread footprint.
  *
- * Unlike pthread_attr_setstacksize(), this function permits just
- * about any parameters and will change the values and allocation
- * as needed to conform to the mandatory requirements of the host
- * operating system even if it doesn't meet the stricter needs of
- * Cosmopolitan Libc userspace libraries. For example with malloc
- * allocations, things like page size alignment, shall be handled
- * automatically for compatibility with existing codebases.
- *
- * The same stack shouldn't be used for two separate threads. Use
- * fresh stacks for each thread so that ASAN can be much happier.
- *
- * @param stackaddr is address of stack allocated by caller, and
- *     may be NULL in which case default behavior is restored
- * @param stacksize is size of caller allocated stack
  * @return 0 on success, or errno on error
- * @raise EINVAL if parameters were unacceptable
+ * @raise EINVAL if `stacksize` is less than `PTHREAD_STACK_MIN`
  * @see pthread_attr_setstacksize()
  */
 errno_t pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr,
                               size_t stacksize) {
   if (!stackaddr) {
     attr->__stackaddr = 0;
-    attr->__stacksize = 0;
+    attr->__stacksize = GetStackSize();
     return 0;
   }
   if (stacksize < PTHREAD_STACK_MIN)
diff --git a/libc/thread/pthread_attr_setstacksize.c b/libc/thread/pthread_attr_setstacksize.c
index f2ccb0c99..217b62fad 100644
--- a/libc/thread/pthread_attr_setstacksize.c
+++ b/libc/thread/pthread_attr_setstacksize.c
@@ -20,7 +20,27 @@
 #include "libc/thread/thread.h"
 
 /**
- * Defines minimum stack size for thread.
+ * Specifies minimum stack size for thread, e.g.
+ *
+ *     pthread_t th;
+ *     pthread_attr_t attr;
+ *     pthread_attr_init(&attr);
+ *     pthread_attr_setguardsize(&attr, 4096);
+ *     pthread_attr_setstacksize(&attr, 61440);
+ *     pthread_create(&th, &attr, thfunc, arg);
+ *     pthread_attr_destroy(&attr);
+ *
+ * On Linux, if you're not using `cosmocc -mtiny`, and you're not using
+ * cosmo_dlopen(), and guard size is nonzero, then `MAP_GROWSDOWN` will
+ * be used to create your stack memory. This helps minimize virtual
+ * memory consumption. Please note this is only possible if `stacksize`
+ * is no larger than the current `RLIMIT_STACK`, otherwise the runtime
+ * will map your stack using plain old mmap().
+ *
+ * Non-custom stacks may be recycled by the cosmo runtime. You can
+ * control this behavior by calling cosmo_stack_setmaxstacks(). It's
+ * useful for both tuning performance and hardening security. See also
+ * pthread_attr_setguardsize() which is important for security too.
  *
  * @param stacksize contains stack size in bytes
  * @return 0 on success, or errno on error
diff --git a/libc/thread/pthread_barrier_destroy.c b/libc/thread/pthread_barrier_destroy.c
index 5893558ac..5a75ad3e3 100644
--- a/libc/thread/pthread_barrier_destroy.c
+++ b/libc/thread/pthread_barrier_destroy.c
@@ -16,9 +16,10 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/errno.h"
+#include "libc/intrin/atomic.h"
 #include "libc/str/str.h"
 #include "libc/thread/thread.h"
-#include "third_party/nsync/counter.h"
 
 /**
  * Destroys barrier.
@@ -27,9 +28,8 @@
  * @raise EINVAL if threads are still inside the barrier
  */
 errno_t pthread_barrier_destroy(pthread_barrier_t *barrier) {
-  if (barrier->_nsync) {
-    nsync_counter_free(barrier->_nsync);
-    barrier->_nsync = 0;
-  }
+  if (atomic_load_explicit(&barrier->_waiters, memory_order_relaxed))
+    return EINVAL;
+  memset(barrier, -1, sizeof(*barrier));
   return 0;
 }
diff --git a/libc/thread/pthread_barrier_init.c b/libc/thread/pthread_barrier_init.c
index 43770caa2..77079c54a 100644
--- a/libc/thread/pthread_barrier_init.c
+++ b/libc/thread/pthread_barrier_init.c
@@ -17,8 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
+#include "libc/intrin/atomic.h"
+#include "libc/limits.h"
 #include "libc/thread/thread.h"
-#include "third_party/nsync/counter.h"
 
 /**
  * Initializes barrier.
@@ -28,16 +29,17 @@
  *     before the barrier is released, which must be greater than zero
  * @return 0 on success, or error number on failure
  * @raise EINVAL if `count` isn't greater than zero
- * @raise ENOMEM if insufficient memory exists
  */
 errno_t pthread_barrier_init(pthread_barrier_t *barrier,
                              const pthread_barrierattr_t *attr,
                              unsigned count) {
-  nsync_counter c;
   if (!count)
     return EINVAL;
-  if (!(c = nsync_counter_new(count)))
-    return ENOMEM;
-  *barrier = (pthread_barrier_t){._nsync = c};
+  if (count > INT_MAX)
+    return EINVAL;
+  barrier->_count = count;
+  barrier->_pshared = attr ? *attr : PTHREAD_PROCESS_PRIVATE;
+  atomic_store_explicit(&barrier->_counter, count, memory_order_relaxed);
+  atomic_store_explicit(&barrier->_waiters, 0, memory_order_relaxed);
   return 0;
 }
diff --git a/libc/thread/pthread_barrier_wait.c b/libc/thread/pthread_barrier_wait.c
index 3dfcec5b5..5a318feed 100644
--- a/libc/thread/pthread_barrier_wait.c
+++ b/libc/thread/pthread_barrier_wait.c
@@ -16,25 +16,53 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/blockcancel.internal.h"
+#include "libc/cosmo.h"
+#include "libc/errno.h"
+#include "libc/intrin/atomic.h"
+#include "libc/limits.h"
 #include "libc/thread/thread.h"
-#include "third_party/nsync/counter.h"
 
 /**
  * Waits for all threads to arrive at barrier.
  *
  * When the barrier is broken, the state becomes reset to what it was
  * when pthread_barrier_init() was called, so that the barrior may be
- * used again in the same way. The last thread to arrive shall be the
- * last to leave and it returns a magic value.
+ * used again in the same way.
+ *
+ * Unlike pthread_cond_timedwait() this function is not a cancelation
+ * point. It is not needed to have cleanup handlers on block cancels.
  *
  * @return 0 on success, `PTHREAD_BARRIER_SERIAL_THREAD` to one lucky
  *     thread which was the last arrival, or an errno on error
+ * @raise EINVAL if barrier is used incorrectly
  */
 errno_t pthread_barrier_wait(pthread_barrier_t *barrier) {
-  if (nsync_counter_add(barrier->_nsync, -1)) {
-    nsync_counter_wait(barrier->_nsync, nsync_time_no_deadline);
-    return 0;
-  } else {
+  int n;
+
+  // enter barrier
+  atomic_fetch_add_explicit(&barrier->_waiters, 1, memory_order_acq_rel);
+  n = atomic_fetch_sub_explicit(&barrier->_counter, 1, memory_order_acq_rel);
+  n = n - 1;
+
+  // this can only happen on invalid usage
+  if (n < 0)
+    return EINVAL;
+
+  // reset count and wake waiters if we're last at barrier
+  if (!n) {
+    atomic_store_explicit(&barrier->_counter, barrier->_count,
+                          memory_order_release);
+    atomic_store_explicit(&barrier->_waiters, 0, memory_order_release);
+    cosmo_futex_wake(&barrier->_waiters, INT_MAX, barrier->_pshared);
     return PTHREAD_BARRIER_SERIAL_THREAD;
   }
+
+  // wait for everyone else to arrive at barrier
+  BLOCK_CANCELATION;
+  while ((n = atomic_load_explicit(&barrier->_waiters, memory_order_acquire)))
+    cosmo_futex_wait(&barrier->_waiters, n, barrier->_pshared, 0, 0);
+  ALLOW_CANCELATION;
+
+  return 0;
 }
diff --git a/libc/thread/pthread_barrierattr_getpshared.c b/libc/thread/pthread_barrierattr_getpshared.c
index 8c0725963..e71846dd2 100644
--- a/libc/thread/pthread_barrierattr_getpshared.c
+++ b/libc/thread/pthread_barrierattr_getpshared.c
@@ -23,7 +23,7 @@
  *
  * @param pshared is set to one of the following
  *     - `PTHREAD_PROCESS_PRIVATE` (default)
- *     - `PTHREAD_PROCESS_SHARED` (unsupported)
+ *     - `PTHREAD_PROCESS_SHARED`
  * @return 0 on success, or error on failure
  */
 errno_t pthread_barrierattr_getpshared(const pthread_barrierattr_t *attr,
diff --git a/libc/thread/pthread_barrierattr_init.c b/libc/thread/pthread_barrierattr_init.c
index 473038114..f4abec468 100644
--- a/libc/thread/pthread_barrierattr_init.c
+++ b/libc/thread/pthread_barrierattr_init.c
@@ -24,6 +24,6 @@
  * @return 0 on success, or error on failure
  */
 errno_t pthread_barrierattr_init(pthread_barrierattr_t *attr) {
-  *attr = 0;
+  *attr = PTHREAD_PROCESS_PRIVATE;
   return 0;
 }
diff --git a/libc/thread/pthread_barrierattr_setpshared.c b/libc/thread/pthread_barrierattr_setpshared.c
index 05dcee1c1..0f74e0436 100644
--- a/libc/thread/pthread_barrierattr_setpshared.c
+++ b/libc/thread/pthread_barrierattr_setpshared.c
@@ -24,13 +24,14 @@
  *
  * @param pshared can be one of
  *     - `PTHREAD_PROCESS_PRIVATE` (default)
- *     - `PTHREAD_PROCESS_SHARED` (unsupported)
+ *     - `PTHREAD_PROCESS_SHARED`
  * @return 0 on success, or error on failure
  * @raises EINVAL if `pshared` is invalid
  */
 errno_t pthread_barrierattr_setpshared(pthread_barrierattr_t *attr,
                                        int pshared) {
   switch (pshared) {
+    case PTHREAD_PROCESS_SHARED:
     case PTHREAD_PROCESS_PRIVATE:
       *attr = pshared;
       return 0;
diff --git a/libc/thread/pthread_cancel.c b/libc/thread/pthread_cancel.c
index bc9dfd79e..2ac5cf305 100644
--- a/libc/thread/pthread_cancel.c
+++ b/libc/thread/pthread_cancel.c
@@ -29,9 +29,9 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
@@ -54,9 +54,8 @@ long _pthread_cancel_ack(void) {
     pthread_exit(PTHREAD_CANCELED);
   }
   pt->pt_flags |= PT_NOCANCEL;
-  if (IsOpenbsd()) {
+  if (IsOpenbsd())
     pt->pt_flags |= PT_OPENBSD_KLUDGE;
-  }
   return ecanceled();
 }
 
@@ -189,7 +188,6 @@ static errno_t _pthread_cancel_everyone(void) {
  * - `connect`
  * - `copy_file_range`
  * - `creat`
- * - `epoll_wait`
  * - `fcntl(F_OFD_SETLKW)`
  * - `fcntl(F_SETLKW)`
  * - `fdatasync`
@@ -351,6 +349,7 @@ static errno_t _pthread_cancel_everyone(void) {
  * @param thread may be 0 to cancel all threads except self
  * @return 0 on success, or errno on error
  * @raise ESRCH if system thread wasn't alive or we lost a race
+ * @cancelationpoint
  */
 errno_t pthread_cancel(pthread_t thread) {
   struct PosixThread *arg;
@@ -401,6 +400,7 @@ void pthread_testcancel(void) {
  *
  * @return 0 if not cancelled or cancelation is blocked or `ECANCELED`
  *     in masked mode when the calling thread has been cancelled
+ * @cancelationpoint
  */
 errno_t pthread_testcancel_np(void) {
   struct PosixThread *pt;
diff --git a/libc/thread/pthread_cond_broadcast.c b/libc/thread/pthread_cond_broadcast.c
index df68a2ec1..894a76fb4 100644
--- a/libc/thread/pthread_cond_broadcast.c
+++ b/libc/thread/pthread_cond_broadcast.c
@@ -1,7 +1,7 @@
 /*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
 │ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
 ╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
 │                                                                              │
 │ Permission to use, copy, modify, and/or distribute this software for         │
 │ any purpose with or without fee is hereby granted, provided that the         │
@@ -16,9 +16,17 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/intrin/atomic.h"
+#include "libc/limits.h"
 #include "libc/thread/thread.h"
 #include "third_party/nsync/cv.h"
 
+__static_yoink("nsync_mu_lock");
+__static_yoink("nsync_mu_unlock");
+__static_yoink("nsync_mu_trylock");
+
 /**
  * Wakes all threads waiting on condition, e.g.
  *
@@ -37,6 +45,24 @@
  * @see pthread_cond_wait
  */
 errno_t pthread_cond_broadcast(pthread_cond_t *cond) {
-  nsync_cv_broadcast((nsync_cv *)cond);
+
+#if PTHREAD_USE_NSYNC
+  // do nothing if pthread_cond_timedwait() hasn't been called yet
+  // this is because we dont know for certain if nsync use is safe
+  if (!atomic_load_explicit(&cond->_waited, memory_order_acquire))
+    return 0;
+
+  // favor *NSYNC if this is a process private condition variable
+  // if using Mike Burrows' code isn't possible, use a naive impl
+  if (!cond->_footek) {
+    nsync_cv_broadcast((nsync_cv *)cond->_nsync);
+    return 0;
+  }
+#endif
+
+  // roll forward the monotonic sequence
+  atomic_fetch_add_explicit(&cond->_sequence, 1, memory_order_acq_rel);
+  if (atomic_load_explicit(&cond->_waiters, memory_order_acquire))
+    cosmo_futex_wake((atomic_int *)&cond->_sequence, INT_MAX, cond->_pshared);
   return 0;
 }
diff --git a/libc/thread/pthread_cond_destroy.c b/libc/thread/pthread_cond_destroy.c
index 3dbd8971b..bb0783671 100644
--- a/libc/thread/pthread_cond_destroy.c
+++ b/libc/thread/pthread_cond_destroy.c
@@ -16,8 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/errno.h"
+#include "libc/intrin/atomic.h"
 #include "libc/str/str.h"
 #include "libc/thread/thread.h"
+#include "third_party/nsync/cv.h"
 
 /**
  * Destroys condition.
@@ -26,6 +29,22 @@
  * @raise EINVAL if threads are still waiting on condition
  */
 errno_t pthread_cond_destroy(pthread_cond_t *cond) {
+
+  // check if there's active waiters
+#if PTHREAD_USE_NSYNC
+  if (!cond->_pshared) {
+    if (((nsync_cv *)cond->_nsync)->waiters)
+      return EINVAL;
+  } else {
+    if (atomic_load_explicit(&cond->_waiters, memory_order_relaxed))
+      return EINVAL;
+  }
+#else
+  if (atomic_load_explicit(&cond->_waiters, memory_order_relaxed))
+    return EINVAL;
+#endif
+
+  // destroy object
   memset(cond, -1, sizeof(*cond));
   return 0;
 }
diff --git a/libc/thread/pthread_cond_init.c b/libc/thread/pthread_cond_init.c
index 915e6bc6f..731ff48c1 100644
--- a/libc/thread/pthread_cond_init.c
+++ b/libc/thread/pthread_cond_init.c
@@ -16,10 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/dce.h"
+#include "libc/sysv/consts/clock.h"
 #include "libc/thread/thread.h"
 
 /**
- * Initializes condition.
+ * Initializes condition variable.
  *
  * @param attr may be null
  * @return 0 on success, or error number on failure
@@ -27,5 +29,9 @@
 errno_t pthread_cond_init(pthread_cond_t *cond,
                           const pthread_condattr_t *attr) {
   *cond = (pthread_cond_t){0};
+  if (attr) {
+    cond->_pshared = attr->_pshared;
+    cond->_clock = attr->_clock;
+  }
   return 0;
 }
diff --git a/libc/thread/pthread_cond_signal.c b/libc/thread/pthread_cond_signal.c
index 3e3c54f7b..fe6244d1e 100644
--- a/libc/thread/pthread_cond_signal.c
+++ b/libc/thread/pthread_cond_signal.c
@@ -16,9 +16,16 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/intrin/atomic.h"
 #include "libc/thread/thread.h"
 #include "third_party/nsync/cv.h"
 
+__static_yoink("nsync_mu_lock");
+__static_yoink("nsync_mu_unlock");
+__static_yoink("nsync_mu_trylock");
+
 /**
  * Wakes at least one thread waiting on condition, e.g.
  *
@@ -26,7 +33,7 @@
  *     pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
  *     // ...
  *     pthread_mutex_lock(&lock);
- *     pthread_cond_signal(&cond, &lock);
+ *     pthread_cond_signal(&cond);
  *     pthread_mutex_unlock(&lock);
  *
  * This function has no effect if there aren't any threads currently
@@ -36,7 +43,27 @@
  * @see pthread_cond_broadcast
  * @see pthread_cond_wait
  */
-errno_t pthread_cond_signal(pthread_cond_t *cond) {
-  nsync_cv_signal((nsync_cv *)cond);
+errno_t _pthread_cond_signal(pthread_cond_t *cond) {
+
+#if PTHREAD_USE_NSYNC
+  // do nothing if pthread_cond_timedwait() hasn't been called yet
+  // this is because we dont know for certain if nsync use is safe
+  if (!atomic_load_explicit(&cond->_waited, memory_order_acquire))
+    return 0;
+
+  // favor *NSYNC if this is a process private condition variable
+  // if using Mike Burrows' code isn't possible, use a naive impl
+  if (!cond->_footek) {
+    nsync_cv_signal((nsync_cv *)cond->_nsync);
+    return 0;
+  }
+#endif
+
+  // roll forward the monotonic sequence
+  atomic_fetch_add_explicit(&cond->_sequence, 1, memory_order_acq_rel);
+  if (atomic_load_explicit(&cond->_waiters, memory_order_acquire))
+    cosmo_futex_wake((atomic_int *)&cond->_sequence, 1, cond->_pshared);
   return 0;
 }
+
+__weak_reference(_pthread_cond_signal, pthread_cond_signal);
diff --git a/libc/thread/pthread_cond_timedwait.c b/libc/thread/pthread_cond_timedwait.c
index 593bd6bfe..9e4daff39 100644
--- a/libc/thread/pthread_cond_timedwait.c
+++ b/libc/thread/pthread_cond_timedwait.c
@@ -16,13 +16,75 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/calls/cp.internal.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
 #include "libc/errno.h"
+#include "libc/intrin/atomic.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/thread/lock.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/thread2.h"
 #include "third_party/nsync/common.internal.h"
 #include "third_party/nsync/cv.h"
 #include "third_party/nsync/time.h"
 
+__static_yoink("nsync_mu_lock");
+__static_yoink("nsync_mu_unlock");
+__static_yoink("nsync_mu_trylock");
+
+struct PthreadWait {
+  pthread_cond_t *cond;
+  pthread_mutex_t *mutex;
+};
+
+static bool can_use_nsync(uint64_t muword) {
+  return !IsXnuSilicon() &&  //
+         MUTEX_TYPE(muword) != PTHREAD_MUTEX_RECURSIVE &&
+         MUTEX_PSHARED(muword) == PTHREAD_PROCESS_PRIVATE;
+}
+
+static void pthread_cond_leave(void *arg) {
+  struct PthreadWait *wait = (struct PthreadWait *)arg;
+  if (_pthread_mutex_lock(wait->mutex))
+    __builtin_trap();
+  atomic_fetch_sub_explicit(&wait->cond->_waiters, 1, memory_order_acq_rel);
+}
+
+static errno_t pthread_cond_timedwait_impl(pthread_cond_t *cond,
+                                           pthread_mutex_t *mutex,
+                                           const struct timespec *abstime) {
+
+  // this is a cancelation point
+  // check the cancelation status before we begin waiting
+  if (pthread_testcancel_np() == ECANCELED)
+    return ECANCELED;
+
+  // get original monotonic sequence while lock is held
+  uint32_t seq1 = atomic_load_explicit(&cond->_sequence, memory_order_relaxed);
+
+  // start waiting on condition variable
+  atomic_fetch_add_explicit(&cond->_waiters, 1, memory_order_acq_rel);
+  if (_pthread_mutex_unlock(mutex))
+    __builtin_trap();
+
+  // wait for sequence change, timeout, or cancelation
+  int rc;
+  struct PthreadWait waiter = {cond, mutex};
+  pthread_cleanup_push(pthread_cond_leave, &waiter);
+  rc = cosmo_futex_wait((atomic_int *)&cond->_sequence, seq1, cond->_pshared,
+                        cond->_clock, abstime);
+  pthread_cleanup_pop(true);
+  if (rc == -EAGAIN)
+    rc = 0;
+
+  // turn linux syscall status into posix errno
+  return -rc;
+}
+
 /**
  * Waits for condition with optional time limit, e.g.
  *
@@ -33,8 +95,10 @@
  *     }
  *
  * @param mutex needs to be held by thread when calling this function
- * @param abstime may be null to wait indefinitely and should contain
- *     some arbitrary interval added to a `CLOCK_REALTIME` timestamp
+ * @param abstime is an absolute timestamp, which may be null to wait
+ *     forever; it's relative to `clock_gettime(CLOCK_REALTIME)` by
+ *     default; pthread_condattr_setclock() may be used to customize
+ *     which system clock is used
  * @return 0 on success, or errno on error
  * @raise ETIMEDOUT if `abstime` was specified and the current time
  *     exceeded its value
@@ -46,15 +110,60 @@
  * @see pthread_cond_signal()
  * @cancelationpoint
  */
-errno_t pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
-                               const struct timespec *abstime) {
-  if (abstime && !(0 <= abstime->tv_nsec && abstime->tv_nsec < 1000000000)) {
+errno_t _pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
+                                const struct timespec *abstime) {
+
+  // validate arguments
+  struct PosixThread *pt;
+  if (!(pt = _pthread_self()))
     return EINVAL;
+  if (abstime && !(0 <= abstime->tv_nsec && abstime->tv_nsec < 1000000000))
+    return EINVAL;
+
+  // look at the mutex argument
+  uint64_t muword = atomic_load_explicit(&mutex->_word, memory_order_relaxed);
+
+  // check that mutex is held by caller
+  if (IsModeDbg() || MUTEX_TYPE(muword) == PTHREAD_MUTEX_ERRORCHECK)
+    if (__deadlock_tracked(mutex) == 0)
+      return EPERM;
+
+  // if the cond is process shared then the mutex needs to be too
+  if ((cond->_pshared == PTHREAD_PROCESS_SHARED) ^
+      (MUTEX_PSHARED(muword) == PTHREAD_PROCESS_SHARED))
+    return EINVAL;
+
+#if PTHREAD_USE_NSYNC
+  // the first time pthread_cond_timedwait() is called we learn if the
+  // associated mutex is normal and private. that means *NSYNC is safe
+  // this decision is permanent. you can't use a recursive mutex later
+  if (!atomic_load_explicit(&cond->_waited, memory_order_acquire)) {
+    cond->_footek = !can_use_nsync(muword);
+    atomic_store_explicit(&cond->_waited, true, memory_order_release);
+  } else if (!cond->_footek) {
+    if (!can_use_nsync(muword))
+      return EINVAL;
   }
-  if (mutex->_type != PTHREAD_MUTEX_NORMAL) {
-    nsync_panic_("pthread cond needs normal mutex\n");
+#endif
+
+  // now perform the actual wait
+  errno_t err;
+  BEGIN_CANCELATION_POINT;
+#if PTHREAD_USE_NSYNC
+  // favor *NSYNC if this is a process private condition variable
+  // if using Mike Burrows' code isn't possible, use a naive impl
+  if (!cond->_footek) {
+    err = nsync_cv_wait_with_deadline(
+        (nsync_cv *)cond->_nsync, (nsync_mu *)mutex->_nsync, cond->_clock,
+        abstime ? *abstime : nsync_time_no_deadline, 0);
+  } else {
+    err = pthread_cond_timedwait_impl(cond, mutex, abstime);
   }
-  return nsync_cv_wait_with_deadline(
-      (nsync_cv *)cond, (nsync_mu *)mutex,
-      abstime ? *abstime : nsync_time_no_deadline, 0);
+#else
+  err = pthread_cond_timedwait_impl(cond, mutex, abstime);
+#endif
+  END_CANCELATION_POINT;
+  return err;
 }
+
+__weak_reference(_pthread_cond_timedwait, pthread_cond_timedwait);
diff --git a/libc/thread/pthread_cond_wait.c b/libc/thread/pthread_cond_wait.c
index df7d42dd1..e6ffd619c 100644
--- a/libc/thread/pthread_cond_wait.c
+++ b/libc/thread/pthread_cond_wait.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/thread2.h"
 
@@ -39,6 +40,8 @@
  * @see pthread_cond_signal
  * @cancelationpoint
  */
-errno_t pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) {
+errno_t _pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) {
   return pthread_cond_timedwait(cond, mutex, 0);
 }
+
+__weak_reference(_pthread_cond_wait, pthread_cond_wait);
diff --git a/libc/thread/pthread_condattr_getclock.c b/libc/thread/pthread_condattr_getclock.c
new file mode 100644
index 000000000..3cb9b22d5
--- /dev/null
+++ b/libc/thread/pthread_condattr_getclock.c
@@ -0,0 +1,34 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/thread.h"
+
+/**
+ * Gets clock on condition variable attributes.
+ *
+ * @param clock will be set to one of
+ *     - `CLOCK_REALTIME` (default)
+ *     - `CLOCK_MONOTONIC`
+ *     - `CLOCK_REALTIME_COARSE`
+ *     - `CLOCK_MONOTONIC_COARSE`
+ * @return 0 on success, or error on failure
+ */
+int pthread_condattr_getclock(const pthread_condattr_t *attr, int *clock) {
+  *clock = attr->_clock;
+  return 0;
+}
diff --git a/libc/thread/pthread_condattr_getpshared.c b/libc/thread/pthread_condattr_getpshared.c
index 81963c4c3..e1b5dc7fc 100644
--- a/libc/thread/pthread_condattr_getpshared.c
+++ b/libc/thread/pthread_condattr_getpshared.c
@@ -28,6 +28,6 @@
  */
 errno_t pthread_condattr_getpshared(const pthread_condattr_t *attr,
                                     int *pshared) {
-  *pshared = *attr;
+  *pshared = attr->_pshared;
   return 0;
 }
diff --git a/libc/thread/pthread_condattr_init.c b/libc/thread/pthread_condattr_init.c
index 575912210..cd377f087 100644
--- a/libc/thread/pthread_condattr_init.c
+++ b/libc/thread/pthread_condattr_init.c
@@ -24,6 +24,6 @@
  * @return 0 on success, or error on failure
  */
 errno_t pthread_condattr_init(pthread_condattr_t *attr) {
-  *attr = 0;
+  *attr = (pthread_condattr_t){0};
   return 0;
 }
diff --git a/libc/thread/pthread_condattr_setclock.c b/libc/thread/pthread_condattr_setclock.c
new file mode 100644
index 000000000..7d5176b02
--- /dev/null
+++ b/libc/thread/pthread_condattr_setclock.c
@@ -0,0 +1,42 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/errno.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/thread/thread.h"
+
+/**
+ * Sets clock for condition variable.
+ *
+ * @param clock can be one of
+ *     - `CLOCK_REALTIME` (default)
+ *     - `CLOCK_MONOTONIC`
+ *     - `CLOCK_REALTIME_COARSE`
+ *     - `CLOCK_MONOTONIC_COARSE`
+ * @return 0 on success, or error on failure
+ * @raises EINVAL if `clock` is invalid
+ */
+int pthread_condattr_setclock(pthread_condattr_t *attr, int clock) {
+  if (clock != CLOCK_REALTIME &&         //
+      clock != CLOCK_REALTIME_COARSE &&  //
+      clock != CLOCK_MONOTONIC &&        //
+      clock != CLOCK_MONOTONIC_COARSE)
+    return EINVAL;
+  attr->_clock = clock;
+  return 0;
+}
diff --git a/libc/thread/pthread_condattr_setpshared.c b/libc/thread/pthread_condattr_setpshared.c
index 801017c67..f109fe518 100644
--- a/libc/thread/pthread_condattr_setpshared.c
+++ b/libc/thread/pthread_condattr_setpshared.c
@@ -24,14 +24,15 @@
  *
  * @param pshared can be one of
  *     - `PTHREAD_PROCESS_PRIVATE` (default)
- *     - `PTHREAD_PROCESS_SHARED` (unsupported)
+ *     - `PTHREAD_PROCESS_SHARED`
  * @return 0 on success, or error on failure
  * @raises EINVAL if `pshared` is invalid
  */
 errno_t pthread_condattr_setpshared(pthread_condattr_t *attr, int pshared) {
   switch (pshared) {
+    case PTHREAD_PROCESS_SHARED:
     case PTHREAD_PROCESS_PRIVATE:
-      *attr = pshared;
+      attr->_pshared = pshared;
       return 0;
     default:
       return EINVAL;
diff --git a/libc/thread/pthread_create.c b/libc/thread/pthread_create.c
index 4312c114d..974a3b592 100644
--- a/libc/thread/pthread_create.c
+++ b/libc/thread/pthread_create.c
@@ -18,20 +18,24 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/sig.internal.h"
+#include "libc/calls/struct/sigaltstack.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
+#include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/bsr.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/dll.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/stack.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alloca.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/crc32.h"
@@ -43,149 +47,172 @@
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
 #include "libc/runtime/syslib.internal.h"
+#include "libc/str/locale.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/auxv.h"
 #include "libc/sysv/consts/clone.h"
-#include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/consts/ss.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
+#include "third_party/nsync/wait_s.internal.h"
 
 __static_yoink("nsync_mu_lock");
 __static_yoink("nsync_mu_unlock");
 __static_yoink("nsync_mu_trylock");
 __static_yoink("nsync_mu_rlock");
 __static_yoink("nsync_mu_runlock");
-__static_yoink("_pthread_atfork");
 __static_yoink("_pthread_onfork_prepare");
 __static_yoink("_pthread_onfork_parent");
 __static_yoink("_pthread_onfork_child");
 
-#define MAP_ANON_OPENBSD  0x1000
-#define MAP_STACK_OPENBSD 0x4000
+void _pthread_free(struct PosixThread *pt) {
 
-void _pthread_free(struct PosixThread *pt, bool isfork) {
+  // thread must be removed from _pthread_list before calling
   unassert(dll_is_alone(&pt->list) && &pt->list != _pthread_list);
+
+  // do nothing for the one and only magical statical posix thread
   if (pt->pt_flags & PT_STATIC)
     return;
+
+  // unmap stack if the cosmo runtime was responsible for mapping it
   if (pt->pt_flags & PT_OWNSTACK)
-    unassert(!munmap(pt->pt_attr.__stackaddr, pt->pt_attr.__stacksize));
-  if (!isfork) {
-    uint64_t syshand =
-        atomic_load_explicit(&pt->tib->tib_syshand, memory_order_acquire);
-    if (syshand) {
-      if (IsWindows())
-        unassert(CloseHandle(syshand));
-      else if (IsXnuSilicon())
-        __syslib->__pthread_join(syshand, 0);
-    }
+    cosmo_stack_free(pt->pt_attr.__stackaddr, pt->pt_attr.__stacksize,
+                     pt->pt_attr.__guardsize);
+
+  // reclaim thread's cached nsync waiter object
+  if (pt->tib->tib_nsync)
+    nsync_waiter_destroy_(pt->tib->tib_nsync);
+
+  // free any additional upstream system resources
+  // our fork implementation wipes this handle in child automatically
+  uint64_t syshand =
+      atomic_load_explicit(&pt->tib->tib_syshand, memory_order_relaxed);
+  if (syshand) {
+    if (IsWindows())
+      unassert(CloseHandle(syshand));  // non-inheritable
+    else if (IsXnuSilicon())
+      unassert(!__syslib->__pthread_join(syshand, 0));
   }
-  free(pt->pt_tls);
-  free(pt);
+
+  // free heap memory associated with thread
+  bulk_free(
+      (void *[]){
+          pt->pt_flags & PT_OWNSIGALTSTACK ? pt->pt_attr.__sigaltstackaddr : 0,
+          pt->pt_tls,
+          pt,
+      },
+      3);
 }
 
-void _pthread_decimate(void) {
-  struct Dll *e;
+void _pthread_decimate(enum PosixThreadStatus threshold) {
   struct PosixThread *pt;
+  struct Dll *e, *e2, *list = 0;
   enum PosixThreadStatus status;
-StartOver:
+
+  // acquire posix threads gil
   _pthread_lock();
-  for (e = dll_last(_pthread_list); e; e = dll_prev(_pthread_list, e)) {
+
+  // swiftly remove every single zombie
+  // that isn't being held by a killing thread
+  for (e = dll_last(_pthread_list); e; e = e2) {
+    e2 = dll_prev(_pthread_list, e);
     pt = POSIXTHREAD_CONTAINER(e);
+    if (atomic_load_explicit(&pt->pt_refs, memory_order_acquire) > 0)
+      continue;  // pthread_kill() has a lease on this thread
+    if (atomic_load_explicit(&pt->tib->tib_ctid, memory_order_acquire))
+      continue;  // thread is still using stack so leave alone
     status = atomic_load_explicit(&pt->pt_status, memory_order_acquire);
-    if (status != kPosixThreadZombie)
-      break;
-    if (!atomic_load_explicit(&pt->tib->tib_tid, memory_order_acquire)) {
-      dll_remove(&_pthread_list, e);
-      _pthread_unlock();
-      _pthread_unref(pt);
-      goto StartOver;
+    if (status < threshold) {
+      if (threshold == kPosixThreadZombie)
+        break;  // zombies only exist at the end of the linked list
+      continue;
     }
+    if (status == kPosixThreadTerminated)
+      if (!(pt->pt_flags & PT_STATIC))
+        STRACE("warning: you forgot to join or detach thread id %d",
+               atomic_load_explicit(&pt->tib->tib_ptid, memory_order_acquire));
+    dll_remove(&_pthread_list, e);
+    dll_make_first(&list, e);
   }
+
+  // release posix threads gil
   _pthread_unlock();
+
+  // now free our thread local batch of zombies
+  // because death is a release and not a punishment
+  // this is advantaged by not holding locks over munmap
+  while ((e = dll_first(list))) {
+    pt = POSIXTHREAD_CONTAINER(e);
+    dll_remove(&list, e);
+    _pthread_free(pt);
+  }
 }
 
-static int PosixThread(void *arg, int tid) {
-  void *rc;
+static int PosixThread(void *arg) {
   struct PosixThread *pt = arg;
+
+  // setup scheduling
   if (pt->pt_attr.__inheritsched == PTHREAD_EXPLICIT_SCHED) {
     unassert(_weaken(_pthread_reschedule));
     _weaken(_pthread_reschedule)(pt);  // yoinked by attribute builder
   }
+
+  // setup signal stack
+  if (pt->pt_attr.__sigaltstacksize) {
+    struct sigaltstack *ss = alloca(sizeof(struct sigaltstack));
+    ss->ss_sp = pt->pt_attr.__sigaltstackaddr;
+    ss->ss_size = pt->pt_attr.__sigaltstacksize;
+    ss->ss_flags = 0;
+    unassert(!sigaltstack(ss, 0));
+  }
+
   // set long jump handler so pthread_exit can bring control back here
-  if (!setjmp(pt->pt_exiter)) {
-    if (IsWindows()) {
+  if (!__builtin_setjmp(pt->pt_exiter)) {
+    // setup signals for new thread
+    pt->pt_attr.__sigmask &= ~(1ull << (SIGTHR - 1));
+    if (IsWindows() || IsMetal()) {
       atomic_store_explicit(&__get_tls()->tib_sigmask, pt->pt_attr.__sigmask,
                             memory_order_release);
+      if (_weaken(__sig_check))
+        _weaken(__sig_check)();
     } else {
       sys_sigprocmask(SIG_SETMASK, &pt->pt_attr.__sigmask, 0);
     }
-    rc = pt->pt_start(pt->pt_arg);
+    void *ret = pt->pt_start(pt->pt_val);
     // ensure pthread_cleanup_pop(), and pthread_exit() popped cleanup
     unassert(!pt->pt_cleanup);
     // calling pthread_exit() will either jump back here, or call exit
-    pthread_exit(rc);
+    pthread_exit(ret);
   }
+
   // avoid signal handler being triggered after we trash our own stack
   __sig_block();
+
   // return to clone polyfill which clears tid, wakes futex, and exits
   return 0;
 }
 
-static int FixupCustomStackOnOpenbsd(pthread_attr_t *attr) {
-  // OpenBSD: Only permits RSP to occupy memory that's been explicitly
-  // defined as stack memory. We need to squeeze the provided interval
-  // in order to successfully call mmap(), which will return EINVAL if
-  // these calculations should overflow.
-  size_t n;
-  uintptr_t x, y;
-  int e, rc, pagesz;
-  pagesz = getauxval(AT_PAGESZ);
-  n = attr->__stacksize;
-  x = (uintptr_t)attr->__stackaddr;
-  y = ROUNDUP(x, pagesz);
-  n -= y - x;
-  n = ROUNDDOWN(n, pagesz);
-  e = errno;
-  if (__sys_mmap((void *)y, n, PROT_READ | PROT_WRITE,
-                 MAP_PRIVATE | MAP_FIXED | MAP_ANON_OPENBSD | MAP_STACK_OPENBSD,
-                 -1, 0, 0) == (void *)y) {
-    attr->__stackaddr = (void *)y;
-    attr->__stacksize = n;
-    return 0;
-  } else {
-    rc = errno;
-    errno = e;
-    if (rc == EOVERFLOW) {
-      rc = EINVAL;
-    }
-    return rc;
-  }
-}
-
 static errno_t pthread_create_impl(pthread_t *thread,
                                    const pthread_attr_t *attr,
                                    void *(*start_routine)(void *), void *arg,
                                    sigset_t oldsigs) {
-  int rc, e = errno;
+  errno_t err;
   struct PosixThread *pt;
 
   // create posix thread object
-  if (!(pt = calloc(1, sizeof(struct PosixThread)))) {
-    errno = e;
+  if (!(pt = calloc(1, sizeof(struct PosixThread))))
     return EAGAIN;
-  }
   dll_init(&pt->list);
+  pt->pt_locale = &__global_locale;
   pt->pt_start = start_routine;
-  pt->pt_arg = arg;
+  pt->pt_val = arg;
 
   // create thread local storage memory
   if (!(pt->pt_tls = _mktls(&pt->tib))) {
     free(pt);
-    errno = e;
     return EAGAIN;
   }
 
@@ -202,58 +229,37 @@ static errno_t pthread_create_impl(pthread_t *thread,
     // caller supplied their own stack
     // assume they know what they're doing as much as possible
     if (IsOpenbsd()) {
-      if ((rc = FixupCustomStackOnOpenbsd(&pt->pt_attr))) {
-        _pthread_free(pt, false);
-        return rc;
+      if (!FixupCustomStackOnOpenbsd(&pt->pt_attr)) {
+        _pthread_free(pt);
+        return EPERM;
       }
     }
   } else {
     // cosmo is managing the stack
-    int pagesize = getauxval(AT_PAGESZ);
-    pt->pt_attr.__guardsize = ROUNDUP(pt->pt_attr.__guardsize, pagesize);
-    pt->pt_attr.__stacksize = pt->pt_attr.__stacksize;
-    if (pt->pt_attr.__guardsize + pagesize > pt->pt_attr.__stacksize) {
-      _pthread_free(pt, false);
-      return EINVAL;
-    }
-    pt->pt_attr.__stackaddr =
-        mmap(0, pt->pt_attr.__stacksize, PROT_READ | PROT_WRITE,
-             MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-    if (pt->pt_attr.__stackaddr != MAP_FAILED) {
-      if (IsOpenbsd() &&
-          __sys_mmap(
-              pt->pt_attr.__stackaddr, pt->pt_attr.__stacksize,
-              PROT_READ | PROT_WRITE,
-              MAP_PRIVATE | MAP_FIXED | MAP_ANON_OPENBSD | MAP_STACK_OPENBSD,
-              -1, 0, 0) != pt->pt_attr.__stackaddr) {
-        notpossible;
-      }
-      if (pt->pt_attr.__guardsize) {
-        if (!IsWindows()) {
-          if (mprotect(pt->pt_attr.__stackaddr, pt->pt_attr.__guardsize,
-                       PROT_NONE)) {
-            notpossible;
-          }
-        } else {
-          uint32_t oldattr;
-          if (!VirtualProtect(pt->pt_attr.__stackaddr, pt->pt_attr.__guardsize,
-                              kNtPageReadwrite | kNtPageGuard, &oldattr)) {
-            notpossible;
-          }
-        }
-      }
-    }
-    if (!pt->pt_attr.__stackaddr || pt->pt_attr.__stackaddr == MAP_FAILED) {
-      rc = errno;
-      _pthread_free(pt, false);
-      errno = e;
-      if (rc == EINVAL || rc == EOVERFLOW) {
+    pt->pt_flags |= PT_OWNSTACK;
+    errno_t err =
+        cosmo_stack_alloc(&pt->pt_attr.__stacksize, &pt->pt_attr.__guardsize,
+                          &pt->pt_attr.__stackaddr);
+    if (err) {
+      _pthread_free(pt);
+      if (err == EINVAL || err == EOVERFLOW) {
         return EINVAL;
       } else {
         return EAGAIN;
       }
     }
-    pt->pt_flags |= PT_OWNSTACK;
+  }
+
+  // setup signal stack
+  if (pt->pt_attr.__sigaltstacksize) {
+    if (!pt->pt_attr.__sigaltstackaddr) {
+      if (!(pt->pt_attr.__sigaltstackaddr =
+                malloc(pt->pt_attr.__sigaltstacksize))) {
+        _pthread_free(pt);
+        return EAGAIN;
+      }
+      pt->pt_flags |= PT_OWNSIGALTSTACK;
+    }
   }
 
   // set initial status
@@ -273,31 +279,41 @@ static errno_t pthread_create_impl(pthread_t *thread,
                             memory_order_relaxed);
       break;
     default:
-      _pthread_free(pt, false);
-      return EINVAL;
+      // pthread_attr_setdetachstate() makes this impossible
+      __builtin_unreachable();
   }
 
+  // if pthread_attr_setdetachstate() was used then it's possible for
+  // the `pt` object to be freed before this clone call has returned!
+  atomic_store_explicit(&pt->pt_refs, 1, memory_order_relaxed);
+
   // add thread to global list
   // we add it to the beginning since zombies go at the end
   _pthread_lock();
   dll_make_first(&_pthread_list, &pt->list);
   _pthread_unlock();
 
+  // we don't normally do this, but it's important to write the result
+  // memory before spawning the thread, so it's visible to the threads
+  *thread = (pthread_t)pt;
+
   // launch PosixThread(pt) in new thread
-  if ((rc = clone(PosixThread, pt->pt_attr.__stackaddr, pt->pt_attr.__stacksize,
-                  CLONE_VM | CLONE_THREAD | CLONE_FS | CLONE_FILES |
-                      CLONE_SIGHAND | CLONE_SYSVSEM | CLONE_SETTLS |
-                      CLONE_PARENT_SETTID | CLONE_CHILD_SETTID |
-                      CLONE_CHILD_CLEARTID,
-                  pt, &pt->ptid, __adj_tls(pt->tib), &pt->tib->tib_tid))) {
+  if ((err = clone(
+           PosixThread, pt->pt_attr.__stackaddr, pt->pt_attr.__stacksize,
+           CLONE_VM | CLONE_THREAD | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
+               CLONE_SYSVSEM | CLONE_SETTLS | CLONE_PARENT_SETTID |
+               CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID,
+           pt, &pt->tib->tib_ptid, __adj_tls(pt->tib), &pt->tib->tib_ctid))) {
+    *thread = 0;  // posix doesn't require we do this
     _pthread_lock();
     dll_remove(&_pthread_list, &pt->list);
     _pthread_unlock();
-    _pthread_free(pt, false);
-    return rc;
+    _pthread_free(pt);
+    if (err == ENOMEM)
+      err = EAGAIN;
+    return err;
   }
 
-  *thread = (pthread_t)pt;
   return 0;
 }
 
@@ -345,8 +361,8 @@ static const char *DescribeHandle(char buf[12], errno_t err, pthread_t *th) {
  *                 │ _lwp_create  │
  *                 └──────────────┘
  *
- * @param thread if non-null is used to output the thread id
- *     upon successful completion
+ * @param thread is used to output the thread id upon success, which
+ *     must be non-null; upon failure, its value is undefined
  * @param attr points to launch configuration, or may be null
  *     to use sensible defaults; it must be initialized using
  *     pthread_attr_init()
@@ -362,12 +378,18 @@ static const char *DescribeHandle(char buf[12], errno_t err, pthread_t *th) {
 errno_t pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                        void *(*start_routine)(void *), void *arg) {
   errno_t err;
-  _pthread_decimate();
+  errno_t olderr = errno;
+  _pthread_decimate(kPosixThreadZombie);
   BLOCK_SIGNALS;
   err = pthread_create_impl(thread, attr, start_routine, arg, _SigMask);
   ALLOW_SIGNALS;
   STRACE("pthread_create([%s], %p, %t, %p) → %s",
          DescribeHandle(alloca(12), err, thread), attr, start_routine, arg,
          DescribeErrno(err));
+  if (!err) {
+    _pthread_unref(*(struct PosixThread **)thread);
+  } else {
+    errno = olderr;
+  }
   return err;
 }
diff --git a/libc/thread/pthread_decimate_np.c b/libc/thread/pthread_decimate_np.c
new file mode 100644
index 000000000..8299db3a2
--- /dev/null
+++ b/libc/thread/pthread_decimate_np.c
@@ -0,0 +1,47 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/cosmo.h"
+#include "libc/intrin/stack.h"
+#include "libc/thread/posixthread.internal.h"
+#include "libc/thread/thread.h"
+
+/**
+ * Garbage collects POSIX threads runtime.
+ *
+ * This function frees unreferenced zombie threads and empties cache
+ * memory associated with the Cosmopolitan POSIX threads runtime.
+ *
+ * Here's an example use case for this function. Let's say you want to
+ * create a malloc() memory leak detector. If your program was running
+ * threads earlier, then there might still be allocations lingering
+ * around, that'll give you false positives. To fix this, what you would
+ * do is call the following, right before running your leak detector:
+ *
+ *     while (!pthread_orphan_np())
+ *       pthread_decimate_np();
+ *
+ * Which will wait until all threads have exited and their memory freed.
+ *
+ * @return 0 on success, or errno on error
+ */
+int pthread_decimate_np(void) {
+  _pthread_decimate(kPosixThreadZombie);
+  cosmo_stack_clear();
+  return 0;
+}
diff --git a/libc/thread/pthread_detach.c b/libc/thread/pthread_detach.c
index 16557e2f0..5e9db049a 100644
--- a/libc/thread/pthread_detach.c
+++ b/libc/thread/pthread_detach.c
@@ -19,17 +19,17 @@
 #include "libc/assert.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 
 static errno_t pthread_detach_impl(struct PosixThread *pt) {
   enum PosixThreadStatus status, transition;
+  status = atomic_load_explicit(&pt->pt_status, memory_order_relaxed);
   for (;;) {
-    status = atomic_load_explicit(&pt->pt_status, memory_order_acquire);
     if (status == kPosixThreadJoinable) {
       transition = kPosixThreadDetached;
     } else if (status == kPosixThreadTerminated) {
@@ -40,10 +40,8 @@ static errno_t pthread_detach_impl(struct PosixThread *pt) {
     if (atomic_compare_exchange_weak_explicit(&pt->pt_status, &status,
                                               transition, memory_order_release,
                                               memory_order_relaxed)) {
-      if (transition == kPosixThreadZombie) {
+      if (transition == kPosixThreadZombie)
         _pthread_zombify(pt);
-      }
-      _pthread_decimate();
       return 0;
     }
   }
@@ -52,10 +50,6 @@ static errno_t pthread_detach_impl(struct PosixThread *pt) {
 /**
  * Asks POSIX thread to free itself automatically upon termination.
  *
- * If this function is used, then it's important to use pthread_exit()
- * rather than exit() since otherwise your program isn't guaranteed to
- * gracefully terminate.
- *
  * Detaching a non-joinable thread is undefined behavior. For example,
  * pthread_detach() can't be called twice on the same thread.
  *
@@ -64,8 +58,12 @@ static errno_t pthread_detach_impl(struct PosixThread *pt) {
  * @returnserrno
  */
 errno_t pthread_detach(pthread_t thread) {
+  unassert(thread);
   struct PosixThread *pt = (struct PosixThread *)thread;
+  _pthread_ref(pt);
+  int tid = _pthread_tid(pt);
   errno_t err = pthread_detach_impl(pt);
-  STRACE("pthread_detach(%d) → %s", _pthread_tid(pt), DescribeErrno(err));
+  _pthread_unref(pt);
+  STRACE("pthread_detach(%d) → %s", tid, DescribeErrno(err));
   return err;
 }
diff --git a/libc/thread/pthread_exit.c b/libc/thread/pthread_exit.c
index 60524f5e7..6f8199203 100644
--- a/libc/thread/pthread_exit.c
+++ b/libc/thread/pthread_exit.c
@@ -18,11 +18,14 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/atomic.h"
+#include "libc/calls/calls.h"
+#include "libc/cosmo.h"
 #include "libc/cxxabi.h"
 #include "libc/dce.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/cxaatexit.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/cxaatexit.h"
+#include "libc/intrin/describebacktrace.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
 #include "libc/mem/gc.h"
@@ -33,7 +36,6 @@
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
-#include "third_party/nsync/futex.internal.h"
 #include "third_party/nsync/wait_s.internal.h"
 
 /**
@@ -69,69 +71,94 @@
  * @noreturn
  */
 wontreturn void pthread_exit(void *rc) {
+  unsigned population;
   struct CosmoTib *tib;
   struct PosixThread *pt;
   enum PosixThreadStatus status, transition;
 
+  STRACE("pthread_exit(%p)", rc);
+
+  // get posix thread object
   tib = __get_tls();
   pt = (struct PosixThread *)tib->tib_pthread;
-  pt->pt_flags |= PT_NOCANCEL;
-  pt->pt_rc = rc;
 
-  STRACE("pthread_exit(%p)", rc);
+  // "The behavior of pthread_exit() is undefined if called from a
+  //  cancellation cleanup handler or destructor function that was
+  //  invoked as a result of either an implicit or explicit call to
+  //  pthread_exit()." ──Quoth POSIX.1-2017
+  unassert(!(pt->pt_flags & PT_EXITING));
+
+  // set state
+  pt->pt_flags |= PT_NOCANCEL | PT_EXITING;
+  pt->pt_val = rc;
 
   // free resources
   __cxa_thread_finalize();
-  _pthread_decimate();
 
   // run atexit handlers if orphaned thread
-  if (pthread_orphan_np()) {
-    if (_weaken(__cxa_finalize)) {
-      _weaken(__cxa_finalize)(NULL);
+  // notice how we avoid acquiring the pthread gil
+  if (!(population = atomic_fetch_sub(&_pthread_count, 1) - 1)) {
+    // we know for certain we're an orphan. any other threads that
+    // exist, will terminate and clear their tid very soon. but some
+    // goofball could spawn more threads from atexit() handlers. we'd
+    // also like to avoid looping forever here, by auto-joining threads
+    // that leaked, because the user forgot to join them or detach them
+    for (;;) {
+      if (_weaken(__cxa_finalize))
+        _weaken(__cxa_finalize)(NULL);
+      _pthread_decimate(kPosixThreadTerminated);
+      if (pthread_orphan_np()) {
+        population = atomic_load(&_pthread_count);
+        break;
+      }
     }
   }
 
   // transition the thread to a terminated state
   status = atomic_load_explicit(&pt->pt_status, memory_order_acquire);
   do {
-    switch (status) {
-      case kPosixThreadJoinable:
-        transition = kPosixThreadTerminated;
-        break;
-      case kPosixThreadDetached:
-        transition = kPosixThreadZombie;
-        break;
-      default:
-        __builtin_unreachable();
+    if (status == kPosixThreadZombie) {
+      transition = kPosixThreadZombie;
+      break;
+    } else if (status == kPosixThreadTerminated) {
+      transition = kPosixThreadTerminated;
+      break;
+    } else if (status == kPosixThreadJoinable) {
+      transition = kPosixThreadTerminated;
+    } else if (status == kPosixThreadDetached) {
+      transition = kPosixThreadZombie;
+    } else {
+      __builtin_trap();
     }
   } while (!atomic_compare_exchange_weak_explicit(
       &pt->pt_status, &status, transition, memory_order_release,
       memory_order_relaxed));
 
   // make this thread a zombie if it was detached
-  if (transition == kPosixThreadZombie) {
+  if (transition == kPosixThreadZombie)
     _pthread_zombify(pt);
-  }
 
-  // check if this is the last survivor
-  if (pthread_orphan_np()) {
-    for (const uintptr_t *p = __fini_array_end; p > __fini_array_start;) {
-      ((void (*)(void))(*--p))();
-    }
+  // "The process shall exit with an exit status of 0 after the last
+  //  thread has been terminated. The behavior shall be as if the
+  //  implementation called exit() with a zero argument at thread
+  //  termination time." ──Quoth POSIX.1-2017
+  if (!population) {
+    for (int i = __fini_array_end - __fini_array_start; i--;)
+      ((void (*)(void))__fini_array_start[i])();
     _Exit(0);
   }
 
   // check if the main thread has died whilst children live
   // note that the main thread is joinable by child threads
   if (pt->pt_flags & PT_STATIC) {
-    atomic_store_explicit(&tib->tib_tid, 0, memory_order_release);
-    nsync_futex_wake_((atomic_int *)&tib->tib_tid, INT_MAX,
-                      !IsWindows() && !IsXnu());
+    atomic_store_explicit(&tib->tib_ctid, 0, memory_order_release);
+    cosmo_futex_wake((atomic_int *)&tib->tib_ctid, INT_MAX,
+                     !IsWindows() && !IsXnu());
     _Exit1(0);
   }
 
   // this is a child thread
-  longjmp(pt->pt_exiter, 1);
+  __builtin_longjmp(pt->pt_exiter, 1);
 }
 
 __weak_reference(pthread_exit, thr_exit);
diff --git a/libc/thread/pthread_getaffinity_np.c b/libc/thread/pthread_getaffinity_np.c
index 1cd9aad31..83c134ac9 100644
--- a/libc/thread/pthread_getaffinity_np.c
+++ b/libc/thread/pthread_getaffinity_np.c
@@ -16,13 +16,14 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/sched-sysv.internal.h"
 #include "libc/calls/struct/cpuset.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/posixthread.internal.h"
@@ -39,6 +40,8 @@
 errno_t pthread_getaffinity_np(pthread_t thread, size_t size,
                                cpu_set_t *bitset) {
   int rc, tid;
+  unassert(thread);
+  unassert(bitset);
   tid = _pthread_tid((struct PosixThread *)thread);
 
   if (size != sizeof(cpu_set_t)) {
diff --git a/libc/thread/pthread_getattr_np.c b/libc/thread/pthread_getattr_np.c
index 65f8c470a..a57472149 100644
--- a/libc/thread/pthread_getattr_np.c
+++ b/libc/thread/pthread_getattr_np.c
@@ -16,18 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/calls/struct/rlimit.h"
-#include "libc/dce.h"
-#include "libc/intrin/atomic.h"
-#include "libc/intrin/maps.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
-#include "libc/sysv/consts/auxv.h"
-#include "libc/sysv/consts/rlim.h"
-#include "libc/sysv/consts/rlimit.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 
@@ -72,10 +61,5 @@ errno_t pthread_getattr_np(pthread_t thread, pthread_attr_t *attr) {
     default:
       __builtin_unreachable();
   }
-  if (!attr->__stacksize && (pt->pt_flags & PT_STATIC)) {
-    attr->__stackaddr = __maps.stack.addr;
-    attr->__stacksize = __maps.stack.size;
-    attr->__guardsize = 0;
-  }
   return 0;
 }
diff --git a/libc/thread/pthread_getname_np.c b/libc/thread/pthread_getname_np.c
index cca44d59d..5f31b8287 100644
--- a/libc/thread/pthread_getname_np.c
+++ b/libc/thread/pthread_getname_np.c
@@ -24,7 +24,7 @@
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/asmflag.h"
 #include "libc/intrin/atomic.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/at.h"
 #include "libc/sysv/consts/o.h"
diff --git a/libc/thread/pthread_key_create.c b/libc/thread/pthread_key_create.c
index 1f04da7a8..bc749a2be 100644
--- a/libc/thread/pthread_key_create.c
+++ b/libc/thread/pthread_key_create.c
@@ -48,9 +48,9 @@ int pthread_key_create(pthread_key_t *key, pthread_key_dtor dtor) {
   if (!dtor)
     dtor = (pthread_key_dtor)-1;
   for (i = 0; i < PTHREAD_KEYS_MAX; ++i) {
-    if (!(expect = atomic_load_explicit(_pthread_key_dtor + i,
-                                        memory_order_acquire)) &&
-        atomic_compare_exchange_strong_explicit(_pthread_key_dtor + i, &expect,
+    if (!(expect = atomic_load_explicit(&_pthread_key_dtor[i],
+                                        memory_order_relaxed)) &&
+        atomic_compare_exchange_strong_explicit(&_pthread_key_dtor[i], &expect,
                                                 dtor, memory_order_release,
                                                 memory_order_relaxed)) {
       *key = i;
diff --git a/libc/thread/pthread_key_delete.c b/libc/thread/pthread_key_delete.c
index a22239d13..b0b649c84 100644
--- a/libc/thread/pthread_key_delete.c
+++ b/libc/thread/pthread_key_delete.c
@@ -16,7 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
 #include "libc/thread/posixthread.internal.h"
@@ -32,10 +31,12 @@
  *
  * @param key was created by pthread_key_create()
  * @return 0 on success, or errno on error
+ * @raise EINVAL if `key` is invalid
  */
 int pthread_key_delete(pthread_key_t k) {
-  unassert(0 <= k && k < PTHREAD_KEYS_MAX);
-  unassert(atomic_load_explicit(_pthread_key_dtor + k, memory_order_acquire));
-  atomic_store_explicit(_pthread_key_dtor + k, 0, memory_order_release);
+  if (!(0 <= k && k < PTHREAD_KEYS_MAX))
+    return EINVAL;  // corrupt key identifier
+  if (!atomic_exchange_explicit(&_pthread_key_dtor[k], 0, memory_order_acq_rel))
+    return EINVAL;  // delete called twice
   return 0;
 }
diff --git a/libc/thread/pthread_kill.c b/libc/thread/pthread_kill.c
index c1a1c4fc2..6c1722965 100644
--- a/libc/thread/pthread_kill.c
+++ b/libc/thread/pthread_kill.c
@@ -22,8 +22,9 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
+#include "libc/runtime/internal.h"
 #include "libc/runtime/syslib.internal.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/thread/posixthread.internal.h"
@@ -43,7 +44,15 @@ errno_t pthread_kill(pthread_t thread, int sig) {
   int err = 0;
   struct PosixThread *pt;
   pt = (struct PosixThread *)thread;
-  if (!(1 <= sig && sig <= 64)) {
+  if (pt)
+    _pthread_ref(pt);
+  if (!thread) {
+    // avoid crashing on easily predictable npe
+    // chances are you need a barrier to synchronize startup
+    err = EFAULT;
+  } else if (!(1 <= sig && sig <= 64)) {
+    // cosmo only supports this many signals
+    // some platforms have more but we're not sure what they do
     err = EINVAL;
   } else if (thread == __get_tls()->tib_pthread) {
     err = raise(sig);  // XNU will EDEADLK it otherwise
@@ -56,17 +65,25 @@ errno_t pthread_kill(pthread_t thread, int sig) {
     if (IsXnuSilicon()) {
       err = __syslib->__pthread_kill(_pthread_syshand(pt), sig);
     } else {
+      int r = 0;
       int e = errno;
-      if (sys_tkill(_pthread_tid(pt), sig, pt->tib)) {
+      int tid = _pthread_tid(pt);
+      if (IsLinux() || IsFreebsd()) {
+        r = sys_tgkill(__pid, tid, sig);
+      } else {
+        r = sys_tkill(tid, sig, pt->tib);
+      }
+      if (r) {
         err = errno;
         errno = e;
       }
     }
-    if (err == ESRCH) {
+    if (err == ESRCH)
       err = 0;  // we already reported this
-    }
   }
   STRACE("pthread_kill(%d, %G) → %s", _pthread_tid(pt), sig,
          DescribeErrno(err));
+  if (pt)
+    _pthread_unref(pt);
   return err;
 }
diff --git a/libc/thread/pthread_mutex_consistent.c b/libc/thread/pthread_mutex_consistent.c
new file mode 100644
index 000000000..44a5fd5f6
--- /dev/null
+++ b/libc/thread/pthread_mutex_consistent.c
@@ -0,0 +1,41 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/intrin/atomic.h"
+#include "libc/thread/lock.h"
+#include "libc/thread/thread.h"
+
+/**
+ * Recovers mutex whose owner died.
+ *
+ * @return 0 on success, or errno on error
+ */
+int pthread_mutex_consistent(pthread_mutex_t *mutex) {
+
+  // The POSIX concept of robust mutexes is a bit cray. So let's change
+  // things up a bit. Rather than implementing all those goofy behaviors
+  // we shall simply use this function to weasel around the ownership
+  // check in pthread_mutex_unlock().
+  uint64_t word = atomic_load_explicit(&mutex->_word, memory_order_relaxed);
+  if (IsModeDbg() || MUTEX_TYPE(word) == PTHREAD_MUTEX_ERRORCHECK)
+    __deadlock_track(mutex, 0);
+
+  return 0;
+}
diff --git a/libc/intrin/pthread_mutex_destroy.c b/libc/thread/pthread_mutex_destroy.c
similarity index 95%
rename from libc/intrin/pthread_mutex_destroy.c
rename to libc/thread/pthread_mutex_destroy.c
index 297067be7..a955bb22c 100644
--- a/libc/intrin/pthread_mutex_destroy.c
+++ b/libc/thread/pthread_mutex_destroy.c
@@ -22,8 +22,10 @@
 /**
  * Destroys mutex.
  *
+ * Destroying a mutex that's currently locked or being waited upon, will
+ * result in undefined behavior.
+ *
  * @return 0 on success, or error number on failure
- * @raise EINVAL if mutex is locked in our implementation
  */
 errno_t pthread_mutex_destroy(pthread_mutex_t *mutex) {
   memset(mutex, -1, sizeof(*mutex));
diff --git a/libc/intrin/pthread_mutex_init.c b/libc/thread/pthread_mutex_init.c
similarity index 92%
rename from libc/intrin/pthread_mutex_init.c
rename to libc/thread/pthread_mutex_init.c
index 7aa536aad..1ce34716b 100644
--- a/libc/intrin/pthread_mutex_init.c
+++ b/libc/thread/pthread_mutex_init.c
@@ -24,7 +24,7 @@
  *     pthread_mutex_t lock;
  *     pthread_mutexattr_t attr;
  *     pthread_mutexattr_init(&attr);
- *     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
+ *     pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
  *     pthread_mutex_init(&lock, &attr);
  *     pthread_mutexattr_destroy(&attr);
  *     // ...
@@ -35,9 +35,6 @@
  */
 int pthread_mutex_init(pthread_mutex_t *mutex,
                        const pthread_mutexattr_t *attr) {
-  *mutex = (pthread_mutex_t){
-      ._type = attr ? attr->_type : 0,
-      ._pshared = attr ? attr->_pshared : 0,
-  };
+  *mutex = (pthread_mutex_t){._word = attr ? attr->_word : 0};
   return 0;
 }
diff --git a/libc/intrin/pthread_mutexattr_destroy.c b/libc/thread/pthread_mutexattr_destroy.c
similarity index 100%
rename from libc/intrin/pthread_mutexattr_destroy.c
rename to libc/thread/pthread_mutexattr_destroy.c
diff --git a/libc/intrin/pthread_mutexattr_getpshared.c b/libc/thread/pthread_mutexattr_getpshared.c
similarity index 96%
rename from libc/intrin/pthread_mutexattr_getpshared.c
rename to libc/thread/pthread_mutexattr_getpshared.c
index 14897885e..0da7c3bc1 100644
--- a/libc/intrin/pthread_mutexattr_getpshared.c
+++ b/libc/thread/pthread_mutexattr_getpshared.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/lock.h"
 #include "libc/thread/thread.h"
 
 /**
@@ -28,6 +29,6 @@
  */
 errno_t pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr,
                                      int *pshared) {
-  *pshared = attr->_pshared;
+  *pshared = MUTEX_PSHARED(attr->_word);
   return 0;
 }
diff --git a/libc/intrin/pthread_mutexattr_gettype.c b/libc/thread/pthread_mutexattr_gettype.c
similarity index 95%
rename from libc/intrin/pthread_mutexattr_gettype.c
rename to libc/thread/pthread_mutexattr_gettype.c
index 5b40f9df1..6e4caa149 100644
--- a/libc/intrin/pthread_mutexattr_gettype.c
+++ b/libc/thread/pthread_mutexattr_gettype.c
@@ -16,18 +16,20 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/lock.h"
 #include "libc/thread/thread.h"
 
 /**
  * Gets mutex type.
  *
  * @param type will be set to one of these on success
+ *     - `PTHREAD_MUTEX_DEFAULT`
  *     - `PTHREAD_MUTEX_NORMAL`
  *     - `PTHREAD_MUTEX_RECURSIVE`
  *     - `PTHREAD_MUTEX_ERRORCHECK`
  * @return 0 on success, or error on failure
  */
 errno_t pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type) {
-  *type = attr->_type;
+  *type = MUTEX_TYPE(attr->_word);
   return 0;
 }
diff --git a/libc/intrin/pthread_mutexattr_init.c b/libc/thread/pthread_mutexattr_init.c
similarity index 100%
rename from libc/intrin/pthread_mutexattr_init.c
rename to libc/thread/pthread_mutexattr_init.c
diff --git a/libc/intrin/pthread_mutexattr_setpshared.c b/libc/thread/pthread_mutexattr_setpshared.c
similarity index 96%
rename from libc/intrin/pthread_mutexattr_setpshared.c
rename to libc/thread/pthread_mutexattr_setpshared.c
index 5cb009562..088552b6e 100644
--- a/libc/intrin/pthread_mutexattr_setpshared.c
+++ b/libc/thread/pthread_mutexattr_setpshared.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
+#include "libc/thread/lock.h"
 #include "libc/thread/thread.h"
 
 /**
@@ -32,7 +33,7 @@ errno_t pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared) {
   switch (pshared) {
     case PTHREAD_PROCESS_SHARED:
     case PTHREAD_PROCESS_PRIVATE:
-      attr->_pshared = pshared;
+      attr->_word = MUTEX_SET_PSHARED(attr->_word, pshared);
       return 0;
     default:
       return EINVAL;
diff --git a/libc/intrin/pthread_mutexattr_settype.c b/libc/thread/pthread_mutexattr_settype.c
similarity index 95%
rename from libc/intrin/pthread_mutexattr_settype.c
rename to libc/thread/pthread_mutexattr_settype.c
index 7a8e78a8f..aefe262f4 100644
--- a/libc/intrin/pthread_mutexattr_settype.c
+++ b/libc/thread/pthread_mutexattr_settype.c
@@ -17,14 +17,15 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
+#include "libc/thread/lock.h"
 #include "libc/thread/thread.h"
 
 /**
  * Sets mutex type.
  *
  * @param type can be one of
- *     - `PTHREAD_MUTEX_NORMAL`
  *     - `PTHREAD_MUTEX_DEFAULT`
+ *     - `PTHREAD_MUTEX_NORMAL`
  *     - `PTHREAD_MUTEX_RECURSIVE`
  *     - `PTHREAD_MUTEX_ERRORCHECK`
  * @return 0 on success, or error on failure
@@ -32,10 +33,11 @@
  */
 errno_t pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type) {
   switch (type) {
+    case PTHREAD_MUTEX_DEFAULT:
     case PTHREAD_MUTEX_NORMAL:
     case PTHREAD_MUTEX_RECURSIVE:
     case PTHREAD_MUTEX_ERRORCHECK:
-      attr->_type = type;
+      attr->_word = MUTEX_SET_TYPE(attr->_word, type);
       return 0;
     default:
       return EINVAL;
diff --git a/libc/thread/pthread_rwlock_destroy.c b/libc/thread/pthread_rwlock_destroy.c
index 39942c2d0..a3b693d6f 100644
--- a/libc/thread/pthread_rwlock_destroy.c
+++ b/libc/thread/pthread_rwlock_destroy.c
@@ -16,16 +16,30 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/errno.h"
+#include "libc/intrin/atomic.h"
 #include "libc/str/str.h"
 #include "libc/thread/thread.h"
+#include "third_party/nsync/mu.h"
 
 /**
  * Destroys read-write lock.
  *
  * @return 0 on success, or error number on failure
- * @raise EINVAL if any threads still hold the lock
+ * @raise EBUSY if any threads still hold the lock
  */
 errno_t pthread_rwlock_destroy(pthread_rwlock_t *rwlock) {
+
+  // check if lock is held
+  if (!rwlock->_pshared) {
+    nsync_mu *mu = (nsync_mu *)rwlock->_nsync;
+    if (atomic_load_explicit(&mu->word, memory_order_relaxed))
+      return EBUSY;
+  } else {
+    if (atomic_load_explicit(&rwlock->_word, memory_order_relaxed))
+      return EBUSY;
+  }
+
   memset(rwlock, -1, sizeof(*rwlock));
   return 0;
 }
diff --git a/libc/thread/pthread_rwlock_init.c b/libc/thread/pthread_rwlock_init.c
index 54fe08ece..dea3f67a9 100644
--- a/libc/thread/pthread_rwlock_init.c
+++ b/libc/thread/pthread_rwlock_init.c
@@ -26,6 +26,8 @@
  */
 errno_t pthread_rwlock_init(pthread_rwlock_t *rwlock,
                             const pthread_rwlockattr_t *attr) {
-  *rwlock = (pthread_rwlock_t){0};
+  *rwlock = (pthread_rwlock_t){
+      ._pshared = attr ? *attr : PTHREAD_PROCESS_PRIVATE,
+  };
   return 0;
 }
diff --git a/libc/thread/pthread_rwlock_rdlock.c b/libc/thread/pthread_rwlock_rdlock.c
index 781c0b6c9..e097bb0ef 100644
--- a/libc/thread/pthread_rwlock_rdlock.c
+++ b/libc/thread/pthread_rwlock_rdlock.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/atomic.h"
 #include "libc/thread/thread.h"
 #include "third_party/nsync/mu.h"
 
@@ -24,7 +25,28 @@
  *
  * @return 0 on success, or errno on error
  */
-errno_t pthread_rwlock_rdlock(pthread_rwlock_t *rwlock) {
-  nsync_mu_rlock((nsync_mu *)rwlock);
-  return 0;
+errno_t pthread_rwlock_rdlock(pthread_rwlock_t *lk) {
+
+#if PTHREAD_USE_NSYNC
+  // use nsync if possible
+  if (!lk->_pshared) {
+    nsync_mu_rlock((nsync_mu *)lk->_nsync);
+    return 0;
+  }
+#endif
+
+  // naive implementation
+  uint32_t w = 0;
+  for (;;) {
+    if (w & 1)
+      for (;;)
+        if (~(w = atomic_load_explicit(&lk->_word, memory_order_relaxed)) & 1)
+          break;
+    // xxx: avoid writer starvation in pthread_rwlock_rdlock_test
+    while (atomic_load(&lk->_waiters))
+      pthread_yield_np();
+    if (atomic_compare_exchange_weak_explicit(
+            &lk->_word, &w, w + 2, memory_order_acquire, memory_order_relaxed))
+      return 0;
+  }
 }
diff --git a/libc/thread/pthread_rwlock_tryrdlock.c b/libc/thread/pthread_rwlock_tryrdlock.c
index 35d51a051..1969c3a41 100644
--- a/libc/thread/pthread_rwlock_tryrdlock.c
+++ b/libc/thread/pthread_rwlock_tryrdlock.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
+#include "libc/intrin/atomic.h"
 #include "libc/thread/thread.h"
 #include "third_party/nsync/mu.h"
 
@@ -29,9 +30,26 @@
  * @raise EINVAL if `rwlock` doesn't refer to an initialized r/w lock
  */
 errno_t pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock) {
-  if (nsync_mu_rtrylock((nsync_mu *)rwlock)) {
-    return 0;
-  } else {
-    return EBUSY;
+
+#if PTHREAD_USE_NSYNC
+  // use nsync if possible
+  if (!rwlock->_pshared) {
+    if (nsync_mu_rtrylock((nsync_mu *)rwlock->_nsync)) {
+      return 0;
+    } else {
+      return EBUSY;
+    }
+  }
+#endif
+
+  // naive implementation
+  uint32_t word = 0;
+  for (;;) {
+    if (word & 1)
+      return EBUSY;
+    if (atomic_compare_exchange_weak_explicit(&rwlock->_word, &word, word + 2,
+                                              memory_order_acquire,
+                                              memory_order_relaxed))
+      return 0;
   }
 }
diff --git a/libc/thread/pthread_rwlock_trywrlock.c b/libc/thread/pthread_rwlock_trywrlock.c
index c685a39dc..49b39e38f 100644
--- a/libc/thread/pthread_rwlock_trywrlock.c
+++ b/libc/thread/pthread_rwlock_trywrlock.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
+#include "libc/intrin/atomic.h"
 #include "libc/thread/thread.h"
 #include "third_party/nsync/mu.h"
 
@@ -28,10 +29,23 @@
  * @raise EINVAL if `rwlock` doesn't refer to an initialized r/w lock
  */
 errno_t pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock) {
-  if (nsync_mu_trylock((nsync_mu *)rwlock)) {
-    rwlock->_iswrite = 1;
-    return 0;
-  } else {
-    return EBUSY;
+
+#if PTHREAD_USE_NSYNC
+  // use nsync if possible
+  if (!rwlock->_pshared) {
+    if (nsync_mu_trylock((nsync_mu *)rwlock->_nsync)) {
+      rwlock->_iswrite = 1;
+      return 0;
+    } else {
+      return EBUSY;
+    }
   }
+#endif
+
+  // naive implementation
+  uint32_t word = 0;
+  if (atomic_compare_exchange_strong_explicit(
+          &rwlock->_word, &word, 1, memory_order_acquire, memory_order_relaxed))
+    return 0;
+  return EBUSY;
 }
diff --git a/libc/thread/pthread_rwlock_unlock.c b/libc/thread/pthread_rwlock_unlock.c
index 1918491c8..5b5feaa02 100644
--- a/libc/thread/pthread_rwlock_unlock.c
+++ b/libc/thread/pthread_rwlock_unlock.c
@@ -16,6 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/errno.h"
+#include "libc/intrin/atomic.h"
 #include "libc/thread/thread.h"
 #include "third_party/nsync/mu.h"
 
@@ -26,11 +28,33 @@
  * @raise EINVAL if lock is in a bad state
  */
 errno_t pthread_rwlock_unlock(pthread_rwlock_t *rwlock) {
-  if (rwlock->_iswrite) {
-    rwlock->_iswrite = 0;
-    nsync_mu_unlock((nsync_mu *)rwlock);
-  } else {
-    nsync_mu_runlock((nsync_mu *)rwlock);
+
+#if PTHREAD_USE_NSYNC
+  // use nsync if possible
+  if (!rwlock->_pshared) {
+    if (rwlock->_iswrite) {
+      rwlock->_iswrite = 0;
+      nsync_mu_unlock((nsync_mu *)rwlock->_nsync);
+    } else {
+      nsync_mu_runlock((nsync_mu *)rwlock->_nsync);
+    }
+    return 0;
+  }
+#endif
+
+  // naive implementation
+  uint32_t word = atomic_load_explicit(&rwlock->_word, memory_order_relaxed);
+  for (;;) {
+    if (word & 1) {
+      atomic_store_explicit(&rwlock->_word, 0, memory_order_release);
+      return 0;
+    } else if (word) {
+      if (atomic_compare_exchange_weak_explicit(&rwlock->_word, &word, word - 2,
+                                                memory_order_release,
+                                                memory_order_relaxed))
+        return 0;
+    } else {
+      return EPERM;
+    }
   }
-  return 0;
 }
diff --git a/libc/thread/pthread_rwlock_wrlock.c b/libc/thread/pthread_rwlock_wrlock.c
index 3eea88db7..382eba828 100644
--- a/libc/thread/pthread_rwlock_wrlock.c
+++ b/libc/thread/pthread_rwlock_wrlock.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/atomic.h"
 #include "libc/thread/thread.h"
 #include "third_party/nsync/mu.h"
 
@@ -25,7 +26,26 @@
  * @return 0 on success, or errno on error
  */
 errno_t pthread_rwlock_wrlock(pthread_rwlock_t *rwlock) {
-  nsync_mu_lock((nsync_mu *)rwlock);
-  rwlock->_iswrite = 1;
-  return 0;
+
+#if PTHREAD_USE_NSYNC
+  // use nsync if possible
+  if (!rwlock->_pshared) {
+    nsync_mu_lock((nsync_mu *)rwlock->_nsync);
+    rwlock->_iswrite = 1;
+    return 0;
+  }
+#endif
+
+  // naive implementation
+  uint32_t w = 0;
+  for (;;) {
+    if (atomic_compare_exchange_weak_explicit(
+            &rwlock->_word, &w, 1, memory_order_acquire, memory_order_relaxed))
+      return 0;
+    atomic_fetch_add(&rwlock->_waiters, 1);
+    for (;;)
+      if (!(w = atomic_load_explicit(&rwlock->_word, memory_order_relaxed)))
+        break;
+    atomic_fetch_sub(&rwlock->_waiters, 1);
+  }
 }
diff --git a/libc/thread/pthread_rwlockattr_getpshared.c b/libc/thread/pthread_rwlockattr_getpshared.c
index 05507dcd5..5ebfb765b 100644
--- a/libc/thread/pthread_rwlockattr_getpshared.c
+++ b/libc/thread/pthread_rwlockattr_getpshared.c
@@ -23,7 +23,7 @@
  *
  * @param pshared is set to one of the following
  *     - `PTHREAD_PROCESS_PRIVATE` (default)
- *     - `PTHREAD_PROCESS_SHARED` (unsupported)
+ *     - `PTHREAD_PROCESS_SHARED`
  * @return 0 on success, or error on failure
  */
 errno_t pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *attr,
diff --git a/libc/thread/pthread_rwlockattr_setpshared.c b/libc/thread/pthread_rwlockattr_setpshared.c
index d7378d6e8..49bf21efe 100644
--- a/libc/thread/pthread_rwlockattr_setpshared.c
+++ b/libc/thread/pthread_rwlockattr_setpshared.c
@@ -24,13 +24,14 @@
  *
  * @param pshared can be one of
  *     - `PTHREAD_PROCESS_PRIVATE` (default)
- *     - `PTHREAD_PROCESS_SHARED` (unsupported)
+ *     - `PTHREAD_PROCESS_SHARED`
  * @return 0 on success, or error on failure
  * @raises EINVAL if `pshared` is invalid
  */
 errno_t pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr, int pshared) {
   switch (pshared) {
     case PTHREAD_PROCESS_PRIVATE:
+    case PTHREAD_PROCESS_SHARED:
       *attr = pshared;
       return 0;
     default:
diff --git a/libc/thread/pthread_setaffinity_np.c b/libc/thread/pthread_setaffinity_np.c
index 131f03a4d..96aa4466b 100644
--- a/libc/thread/pthread_setaffinity_np.c
+++ b/libc/thread/pthread_setaffinity_np.c
@@ -16,14 +16,15 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/sched-sysv.internal.h"
 #include "libc/calls/struct/cpuset.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/nt/enum/threadaccess.h"
 #include "libc/nt/runtime.h"
 #include "libc/nt/thread.h"
@@ -54,6 +55,8 @@ errno_t pthread_setaffinity_np(pthread_t thread, size_t size,
   int e, rc, tid;
   cpu_set_t bs = {0};
   struct PosixThread *pt;
+  unassert(thread);
+  unassert(bitset);
   e = errno;
   if (size < sizeof(cpu_set_t)) {
     memcpy(&bs, bitset, size);
diff --git a/libc/thread/pthread_setcanceltype.c b/libc/thread/pthread_setcanceltype.c
index 48290d5cf..6aad36c6e 100644
--- a/libc/thread/pthread_setcanceltype.c
+++ b/libc/thread/pthread_setcanceltype.c
@@ -19,8 +19,8 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/mem/alloca.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
@@ -76,8 +76,10 @@ errno_t pthread_setcanceltype(int type, int *oldtype) {
       err = EINVAL;
       break;
   }
+#ifdef MODE_DBG
   STRACE("pthread_setcanceltype(%s, [%s]) → %s",
          DescribeCancelType(alloca(12), 0, &type),
          DescribeCancelType(alloca(12), err, oldtype), DescribeErrno(err));
+#endif
   return err;
 }
diff --git a/libc/thread/pthread_setname_np.c b/libc/thread/pthread_setname_np.c
index 9f2894c05..84915ac92 100644
--- a/libc/thread/pthread_setname_np.c
+++ b/libc/thread/pthread_setname_np.c
@@ -23,8 +23,8 @@
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/syslib.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/at.h"
diff --git a/libc/intrin/pthread_spin_destroy.c b/libc/thread/pthread_spin_destroy.c
similarity index 100%
rename from libc/intrin/pthread_spin_destroy.c
rename to libc/thread/pthread_spin_destroy.c
diff --git a/libc/intrin/pthread_spin_init.c b/libc/thread/pthread_spin_init.c
similarity index 100%
rename from libc/intrin/pthread_spin_init.c
rename to libc/thread/pthread_spin_init.c
diff --git a/libc/thread/pthread_spin_lock.c b/libc/thread/pthread_spin_lock.c
new file mode 100644
index 000000000..ff7175a0a
--- /dev/null
+++ b/libc/thread/pthread_spin_lock.c
@@ -0,0 +1,63 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/strace.h"
+#include "libc/thread/thread.h"
+
+/**
+ * Acquires spin lock, e.g.
+ *
+ *     pthread_spinlock_t lock;
+ *     pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE);
+ *     pthread_spin_lock(&lock);
+ *     // do work...
+ *     pthread_spin_unlock(&lock);
+ *     pthread_spin_destroy(&lock);
+ *
+ * This function has undefined behavior when `spin` wasn't intialized or
+ * was destroyed, and if the lock is already held by the calling thread.
+ *
+ * You can debug locks the acquisition of locks by building your program
+ * with `cosmocc -mdbg` and passing the `--strace` flag to your program.
+ * This will cause a line to be logged each time a mutex or spin lock is
+ * locked or unlocked. When locking, this is printed after the lock gets
+ * acquired. The entry to the lock operation will be logged too but only
+ * if the lock couldn't be immediately acquired. Lock logging works best
+ * when `mutex` refers to a static variable, in which case its name will
+ * be printed in the log.
+ *
+ * @return 0 on success, or errno on error
+ * @see pthread_spin_trylock
+ * @see pthread_spin_unlock
+ * @see pthread_spin_init
+ */
+errno_t pthread_spin_lock(pthread_spinlock_t *spin) {
+  if (atomic_exchange_explicit(&spin->_lock, 1, memory_order_acquire)) {
+    LOCKTRACE("acquiring pthread_spin_lock(%t)...", spin);
+    for (;;) {
+      for (;;)
+        if (!atomic_load_explicit(&spin->_lock, memory_order_relaxed))
+          break;
+      if (!atomic_exchange_explicit(&spin->_lock, 1, memory_order_acquire))
+        break;
+    }
+  }
+  LOCKTRACE("pthread_spin_lock(%t)", spin);
+  return 0;
+}
diff --git a/libc/intrin/pthread_spin_trylock.c b/libc/thread/pthread_spin_trylock.c
similarity index 100%
rename from libc/intrin/pthread_spin_trylock.c
rename to libc/thread/pthread_spin_trylock.c
diff --git a/libc/intrin/pthread_spin_unlock.c b/libc/thread/pthread_spin_unlock.c
similarity index 96%
rename from libc/intrin/pthread_spin_unlock.c
rename to libc/thread/pthread_spin_unlock.c
index 927de65c4..fb881ce33 100644
--- a/libc/intrin/pthread_spin_unlock.c
+++ b/libc/thread/pthread_spin_unlock.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/atomic.h"
+#include "libc/intrin/strace.h"
 #include "libc/thread/thread.h"
 
 /**
@@ -29,6 +30,7 @@
  * @see pthread_spin_lock
  */
 errno_t pthread_spin_unlock(pthread_spinlock_t *spin) {
+  LOCKTRACE("pthread_spin_unlock(%t)", spin);
   atomic_store_explicit(&spin->_lock, 0, memory_order_release);
   return 0;
 }
diff --git a/libc/thread/pthread_timedjoin_np.c b/libc/thread/pthread_timedjoin_np.c
index c79428b8d..cd1643b8d 100644
--- a/libc/thread/pthread_timedjoin_np.c
+++ b/libc/thread/pthread_timedjoin_np.c
@@ -20,16 +20,18 @@
 #include "libc/calls/cp.internal.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/sysv/consts/clock.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread2.h"
 #include "libc/thread/tls.h"
-#include "third_party/nsync/futex.internal.h"
 
 static const char *DescribeReturnValue(char buf[30], int err, void **value) {
   char *p = buf;
@@ -55,29 +57,40 @@ static const char *DescribeReturnValue(char buf[30], int err, void **value) {
  *
  * @return 0 on success, or errno on error
  * @raise ECANCELED if calling thread was cancelled in masked mode
+ * @raise EDEADLK if `ctid` refers calling thread's own ctid futex
  * @raise EBUSY if `abstime` was specified and deadline expired
  * @cancelationpoint
  */
 static errno_t _pthread_wait(atomic_int *ctid, struct timespec *abstime) {
-  int x, e, rc = 0;
-  unassert(ctid != &__get_tls()->tib_tid);
+
+  // "If an implementation detects that the value specified by the
+  //  thread argument to pthread_join() refers to the calling thread,
+  //  it is recommended that the function should fail and report an
+  //  [EDEADLK] error." ──Quoth POSIX.1-2017
+  if (ctid == &__get_tls()->tib_ctid)
+    return EDEADLK;
+
   // "If the thread calling pthread_join() is canceled, then the target
   //  thread shall not be detached."  ──Quoth POSIX.1-2017
-  if (!(rc = pthread_testcancel_np())) {
-    BEGIN_CANCELATION_POINT;
-    while ((x = atomic_load_explicit(ctid, memory_order_acquire))) {
-      e = nsync_futex_wait_(ctid, x, !IsWindows() && !IsXnu(), abstime);
-      if (e == -ECANCELED) {
-        rc = ECANCELED;
-        break;
-      } else if (e == -ETIMEDOUT) {
-        rc = EBUSY;
-        break;
-      }
+  errno_t err;
+  if ((err = pthread_testcancel_np()))
+    return err;
+
+  BEGIN_CANCELATION_POINT;
+  int x;
+  while ((x = atomic_load_explicit(ctid, memory_order_acquire))) {
+    int e = cosmo_futex_wait(ctid, x, !IsWindows() && !IsXnu(), CLOCK_REALTIME,
+                             abstime);
+    if (e == -ECANCELED) {
+      err = ECANCELED;
+      break;
+    } else if (e == -ETIMEDOUT) {
+      err = EBUSY;
+      break;
     }
-    END_CANCELATION_POINT;
   }
-  return rc;
+  END_CANCELATION_POINT;
+  return err;
 }
 
 /**
@@ -97,6 +110,7 @@ static errno_t _pthread_wait(atomic_int *ctid, struct timespec *abstime) {
  *     when we'll stop waiting; if this is null we will wait forever
  * @return 0 on success, or errno on error
  * @raise ECANCELED if calling thread was cancelled in masked mode
+ * @raise EDEADLK if `thread` refers to calling thread
  * @raise EBUSY if `abstime` deadline elapsed
  * @cancelationpoint
  * @returnserrno
@@ -108,22 +122,36 @@ errno_t pthread_timedjoin_np(pthread_t thread, void **value_ptr,
   struct PosixThread *pt;
   enum PosixThreadStatus status;
   pt = (struct PosixThread *)thread;
-  tid = _pthread_tid(pt);
-  unassert(_pthread_tid(pt));
-  status = atomic_load_explicit(&pt->pt_status, memory_order_acquire);
+  unassert(thread);
+
   // "The behavior is undefined if the value specified by the thread
   //  argument to pthread_join() does not refer to a joinable thread."
   //                                  ──Quoth POSIX.1-2017
+  unassert((tid = _pthread_tid(pt)));
+  status = atomic_load_explicit(&pt->pt_status, memory_order_acquire);
   unassert(status == kPosixThreadJoinable || status == kPosixThreadTerminated);
-  if (!(err = _pthread_wait(&pt->tib->tib_tid, abstime))) {
-    _pthread_lock();
-    dll_remove(&_pthread_list, &pt->list);
-    _pthread_unlock();
-    if (value_ptr) {
-      *value_ptr = pt->pt_rc;
+
+  // "The results of multiple simultaneous calls to pthread_join()
+  //  specifying the same target thread are undefined."
+  //                                  ──Quoth POSIX.1-2017
+  if (!(err = _pthread_wait(&pt->tib->tib_ctid, abstime))) {
+    if (value_ptr)
+      *value_ptr = pt->pt_val;
+    if (atomic_load_explicit(&pt->pt_refs, memory_order_acquire)) {
+      _pthread_lock();
+      dll_remove(&_pthread_list, &pt->list);
+      dll_make_last(&_pthread_list, &pt->list);
+      atomic_store_explicit(&pt->pt_status, kPosixThreadZombie,
+                            memory_order_release);
+      _pthread_unlock();
+    } else {
+      _pthread_lock();
+      dll_remove(&_pthread_list, &pt->list);
+      _pthread_unlock();
+      _pthread_free(pt);
     }
-    _pthread_unref(pt);
   }
+
   STRACE("pthread_timedjoin_np(%d, %s, %s) → %s", tid,
          DescribeReturnValue(alloca(30), err, value_ptr),
          DescribeTimespec(err ? -1 : 0, abstime), DescribeErrno(err));
diff --git a/libc/thread/pthread_tryjoin_np.c b/libc/thread/pthread_tryjoin_np.c
index 248b26928..39929646e 100644
--- a/libc/thread/pthread_tryjoin_np.c
+++ b/libc/thread/pthread_tryjoin_np.c
@@ -32,6 +32,7 @@
  *     if the thread called pthread_exit(), or `PTHREAD_CANCELED` if
  *     pthread_cancel() destroyed the thread instead
  * @return 0 on success, or errno on error
+ * @raise EBUSY if thread has not yet terminated
  * @raise ECANCELED if calling thread was cancelled in masked mode
  * @cancelationpoint
  * @returnserrno
diff --git a/libc/thread/sem_destroy.c b/libc/thread/sem_destroy.c
index fb0e3c356..053295c1b 100644
--- a/libc/thread/sem_destroy.c
+++ b/libc/thread/sem_destroy.c
@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/intrin/atomic.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/semaphore.h"
@@ -40,14 +41,20 @@
  * @raise EBUSY if `sem` has waiters
  */
 int sem_destroy(sem_t *sem) {
-  int waiters;
+  int rc, waiters;
   npassert(sem->sem_magic != SEM_MAGIC_NAMED);
-  if (sem->sem_magic != SEM_MAGIC_UNNAMED)
-    return einval();
-  waiters = atomic_load_explicit(&sem->sem_waiters, memory_order_relaxed);
-  unassert(waiters >= 0);
-  if (waiters)
-    return ebusy();
-  atomic_store_explicit(&sem->sem_value, INT_MIN, memory_order_relaxed);
-  return 0;
+  if (sem->sem_magic != SEM_MAGIC_UNNAMED) {
+    rc = einval();
+  } else {
+    waiters = atomic_load_explicit(&sem->sem_waiters, memory_order_relaxed);
+    unassert(waiters >= 0);
+    if (waiters) {
+      rc = ebusy();
+    } else {
+      atomic_store_explicit(&sem->sem_value, INT_MIN, memory_order_relaxed);
+      rc = 0;
+    }
+  }
+  STRACE("sem_destroy(%p) → %d% m", sem, rc);
+  return rc;
 }
diff --git a/libc/thread/sem_init.c b/libc/thread/sem_init.c
index e86f18313..da976752c 100644
--- a/libc/thread/sem_init.c
+++ b/libc/thread/sem_init.c
@@ -19,6 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
 #include "libc/intrin/atomic.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/semaphore.h"
@@ -37,12 +38,17 @@
  * @raise EINVAL if `value` exceeds `SEM_VALUE_MAX`
  */
 int sem_init(sem_t *sem, int pshared, unsigned value) {
-  if (value > SEM_VALUE_MAX)
-    return einval();
-  sem->sem_magic = SEM_MAGIC_UNNAMED;
-  atomic_store_explicit(&sem->sem_value, value, memory_order_relaxed);
-  sem->sem_pshared = !!pshared;
-  sem->sem_pid = getpid();
-  sem->sem_waiters = 0;
-  return 0;
+  int rc;
+  if (value > SEM_VALUE_MAX) {
+    rc = einval();
+  } else {
+    sem->sem_magic = SEM_MAGIC_UNNAMED;
+    atomic_store_explicit(&sem->sem_value, value, memory_order_relaxed);
+    sem->sem_pshared = !!pshared;
+    sem->sem_pid = getpid();
+    sem->sem_waiters = 0;
+    rc = 0;
+  }
+  STRACE("sem_init(%p, %hhhd, %u) → %d% m", sem, pshared, value, rc);
+  return rc;
 }
diff --git a/libc/thread/sem_open.c b/libc/thread/sem_open.c
index 41ab6615f..156bbc868 100644
--- a/libc/thread/sem_open.c
+++ b/libc/thread/sem_open.c
@@ -17,14 +17,16 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/atomic.h"
 #include "libc/calls/blockcancel.internal.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/calls/syscall-sysv.internal.h"
+#include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
@@ -35,12 +37,13 @@
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/posixthread.internal.h"
 #include "libc/thread/semaphore.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 
 static struct Semaphores {
-  pthread_once_t once;
+  atomic_uint once;
   pthread_mutex_t lock;
   struct Semaphore {
     struct Semaphore *next;
@@ -49,27 +52,28 @@ static struct Semaphores {
     bool dead;
     int refs;
   } *list;
-} g_semaphores;
+} g_semaphores = {
+    .lock = PTHREAD_MUTEX_INITIALIZER,
+};
 
 static void sem_open_lock(void) {
-  pthread_mutex_lock(&g_semaphores.lock);
+  _pthread_mutex_lock(&g_semaphores.lock);
 }
 
 static void sem_open_unlock(void) {
-  pthread_mutex_unlock(&g_semaphores.lock);
+  _pthread_mutex_unlock(&g_semaphores.lock);
 }
 
 static void sem_open_wipe(void) {
-  pthread_mutex_init(&g_semaphores.lock, 0);
+  _pthread_mutex_wipe_np(&g_semaphores.lock);
 }
 
 static void sem_open_setup(void) {
-  sem_open_wipe();
   pthread_atfork(sem_open_lock, sem_open_unlock, sem_open_wipe);
 }
 
 static void sem_open_init(void) {
-  pthread_once(&g_semaphores.once, sem_open_setup);
+  cosmo_once(&g_semaphores.once, sem_open_setup);
 }
 
 static sem_t *sem_open_impl(const char *path, int oflag, unsigned mode,
@@ -183,7 +187,8 @@ sem_t *sem_open(const char *name, int oflag, ...) {
 #if 0
   if (IsXnuSilicon()) {
     long kernel;
-    if (!(sem = calloc(1, sizeof(sem_t)))) return SEM_FAILED;
+    if (!(sem = calloc(1, sizeof(sem_t))))
+      return SEM_FAILED;
     sem->sem_magic = SEM_MAGIC_KERNEL;
     kernel = _sysret(__syslib->__sem_open(name, oflag, mode, value));
     if (kernel == -1) {
diff --git a/libc/thread/sem_post.c b/libc/thread/sem_post.c
index 83fab3409..8da481cc0 100644
--- a/libc/thread/sem_post.c
+++ b/libc/thread/sem_post.c
@@ -19,6 +19,7 @@
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall-sysv.internal.h"
+#include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
@@ -26,7 +27,6 @@
 #include "libc/runtime/syslib.internal.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/semaphore.h"
-#include "third_party/nsync/futex.internal.h"
 
 /**
  * Unlocks semaphore.
@@ -46,7 +46,7 @@ int sem_post(sem_t *sem) {
   old = atomic_fetch_add_explicit(&sem->sem_value, 1, memory_order_acq_rel);
   unassert(old > INT_MIN);
   if (old >= 0) {
-    wakeups = nsync_futex_wake_(&sem->sem_value, 1, true);
+    wakeups = cosmo_futex_wake(&sem->sem_value, 1, sem->sem_pshared);
     npassert(wakeups >= 0);
     rc = 0;
   } else {
diff --git a/libc/thread/sem_timedwait.c b/libc/thread/sem_timedwait.c
index 2ffcbf5ee..b68193fe6 100644
--- a/libc/thread/sem_timedwait.c
+++ b/libc/thread/sem_timedwait.c
@@ -22,16 +22,17 @@
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/struct/timespec.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
+#include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/weaken.h"
 #include "libc/limits.h"
 #include "libc/runtime/syslib.internal.h"
+#include "libc/sysv/consts/clock.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/thread/semaphore.h"
 #include "libc/thread/thread.h"
-#include "third_party/nsync/futex.internal.h"
 
 static void sem_delay(int n) {
   volatile int i;
@@ -58,7 +59,7 @@ static void sem_timedwait_cleanup(void *arg) {
  * @cancelationpoint
  */
 int sem_timedwait(sem_t *sem, const struct timespec *abstime) {
-  int i, v, rc, e = errno;
+  int v, rc, e = errno;
 
 #if 0
   if (IsXnuSilicon() && sem->sem_magic == SEM_MAGIC_KERNEL) {
@@ -81,13 +82,15 @@ int sem_timedwait(sem_t *sem, const struct timespec *abstime) {
         return ecanceled();
       }
       rc = _sysret(__syslib->__sem_trywait(sem->sem_kernel));
-      if (!rc) return 0;
+      if (!rc)
+        return 0;
       if (errno == EINTR &&                  //
           _weaken(pthread_testcancel_np) &&  //
           _weaken(pthread_testcancel_np)()) {
         return ecanceled();
       }
-      if (errno != EAGAIN) return -1;
+      if (errno != EAGAIN)
+        return -1;
       errno = e;
       struct timespec now = timespec_real();
       if (timespec_cmp(*abstime, now) >= 0) {
@@ -100,16 +103,13 @@ int sem_timedwait(sem_t *sem, const struct timespec *abstime) {
   }
 #endif
 
-  for (i = 0; i < 7; ++i) {
-    rc = sem_trywait(sem);
-    if (!rc) {
-      return rc;
-    } else if (errno == EAGAIN) {
-      errno = e;
-      sem_delay(i);
-    } else {
-      return rc;
-    }
+  rc = sem_trywait(sem);
+  if (!rc) {
+    return rc;
+  } else if (errno == EAGAIN) {
+    errno = e;
+  } else {
+    return rc;
   }
 
   BEGIN_CANCELATION_POINT;
@@ -119,7 +119,8 @@ int sem_timedwait(sem_t *sem, const struct timespec *abstime) {
 
   do {
     if (!(v = atomic_load_explicit(&sem->sem_value, memory_order_relaxed))) {
-      rc = nsync_futex_wait_(&sem->sem_value, v, true, abstime);
+      rc = cosmo_futex_wait(&sem->sem_value, v, sem->sem_pshared,
+                            CLOCK_REALTIME, abstime);
       if (rc == -EINTR || rc == -ECANCELED) {
         errno = -rc;
         rc = -1;
diff --git a/libc/thread/semaphore.h b/libc/thread/semaphore.h
index b5abf08ca..ee03fe926 100644
--- a/libc/thread/semaphore.h
+++ b/libc/thread/semaphore.h
@@ -3,6 +3,12 @@
 #include "libc/calls/struct/timespec.h"
 COSMOPOLITAN_C_START_
 
+#ifndef __cplusplus
+#define _SEM_ATOMIC(x) _Atomic(x)
+#else
+#define _SEM_ATOMIC(x) x
+#endif
+
 #define SEM_FAILED        ((sem_t *)0)
 #define SEM_MAGIC_NAMED   0xDEADBEEFu
 #define SEM_MAGIC_UNNAMED 0xFEEDABEEu
@@ -11,9 +17,9 @@ COSMOPOLITAN_C_START_
 typedef struct {
   union {
     struct {
-      _Atomic(int) sem_value;
-      _Atomic(int) sem_waiters;
-      _Atomic(int) sem_prefs; /* named only */
+      _SEM_ATOMIC(int) sem_value;
+      _SEM_ATOMIC(int) sem_waiters;
+      _SEM_ATOMIC(int) sem_prefs; /* named only */
       unsigned sem_magic;
       int64_t sem_dev;     /* named only */
       int64_t sem_ino;     /* named only */
@@ -28,10 +34,10 @@ typedef struct {
 
 int sem_init(sem_t *, int, unsigned) libcesque;
 int sem_destroy(sem_t *) libcesque;
-int sem_post(sem_t *) libcesque;
-int sem_wait(sem_t *) libcesque;
-int sem_trywait(sem_t *) libcesque;
-int sem_timedwait(sem_t *, const struct timespec *) libcesque;
+int sem_post(sem_t *) dontthrow;
+int sem_wait(sem_t *) dontthrow;
+int sem_trywait(sem_t *) dontthrow;
+int sem_timedwait(sem_t *, const struct timespec *) dontthrow;
 int sem_getvalue(sem_t *, int *) libcesque;
 sem_t *sem_open(const char *, int, ...) libcesque;
 int sem_close(sem_t *) libcesque;
diff --git a/libc/thread/setitimer.c b/libc/thread/setitimer.c
index 88d1c7b16..e713258f0 100644
--- a/libc/thread/setitimer.c
+++ b/libc/thread/setitimer.c
@@ -19,8 +19,8 @@
 #include "libc/calls/struct/itimerval.h"
 #include "libc/calls/struct/itimerval.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/time.h"
 
diff --git a/libc/thread/thread.h b/libc/thread/thread.h
index 374cafce5..b7ac8a119 100644
--- a/libc/thread/thread.h
+++ b/libc/thread/thread.h
@@ -1,21 +1,23 @@
 #ifndef COSMOPOLITAN_LIBC_THREAD_THREAD_H_
 #define COSMOPOLITAN_LIBC_THREAD_THREAD_H_
 
-#define PTHREAD_KEYS_MAX              48
-#define PTHREAD_STACK_MIN             65536
+#define PTHREAD_KEYS_MAX              46
+#define PTHREAD_STACK_MIN             32768
+#define PTHREAD_USE_NSYNC             1
 #define PTHREAD_DESTRUCTOR_ITERATIONS 4
 
 #define PTHREAD_BARRIER_SERIAL_THREAD 31337
 
 #define PTHREAD_MUTEX_DEFAULT    0
-#define PTHREAD_MUTEX_NORMAL     0
-#define PTHREAD_MUTEX_RECURSIVE  1
-#define PTHREAD_MUTEX_ERRORCHECK 2
-#define PTHREAD_MUTEX_STALLED    0
-#define PTHREAD_MUTEX_ROBUST     1
+#define PTHREAD_MUTEX_NORMAL     1
+#define PTHREAD_MUTEX_RECURSIVE  2
+#define PTHREAD_MUTEX_ERRORCHECK 3
+
+#define PTHREAD_MUTEX_STALLED 0
+#define PTHREAD_MUTEX_ROBUST  2048
 
 #define PTHREAD_PROCESS_PRIVATE 0
-#define PTHREAD_PROCESS_SHARED  1
+#define PTHREAD_PROCESS_SHARED  4
 
 #define PTHREAD_CREATE_JOINABLE 0
 #define PTHREAD_CREATE_DETACHED 1
@@ -40,55 +42,82 @@
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
-#define PTHREAD_ONCE_INIT          _PTHREAD_INIT
-#define PTHREAD_COND_INITIALIZER   _PTHREAD_INIT
-#define PTHREAD_RWLOCK_INITIALIZER _PTHREAD_INIT
-#define PTHREAD_MUTEX_INITIALIZER  _PTHREAD_INIT
+#define PTHREAD_ONCE_INIT          {0}
+#define PTHREAD_COND_INITIALIZER   {0}
+#define PTHREAD_RWLOCK_INITIALIZER {0}
 
-#define _PTHREAD_INIT \
-  { 0 }
+#define PTHREAD_MUTEX_INITIALIZER               {0, PTHREAD_MUTEX_DEFAULT}
+#define PTHREAD_NORMAL_MUTEX_INITIALIZER_NP     {0, PTHREAD_MUTEX_NORMAL}
+#define PTHREAD_SHARED_MUTEX_INITIALIZER_NP     {0, PTHREAD_PROCESS_SHARED}
+#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP  {0, PTHREAD_MUTEX_RECURSIVE}
+#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP {0, PTHREAD_MUTEX_ERRORCHECK}
+
+#ifndef __cplusplus
+#define _PTHREAD_ATOMIC(x) _Atomic(x)
+#else
+#define _PTHREAD_ATOMIC(x) x
+#endif
 
 typedef uintptr_t pthread_t;
 typedef int pthread_id_np_t;
-typedef char pthread_condattr_t;
 typedef char pthread_rwlockattr_t;
 typedef char pthread_barrierattr_t;
 typedef unsigned pthread_key_t;
 typedef void (*pthread_key_dtor)(void *);
 
 typedef struct pthread_once_s {
-  _Atomic(uint32_t) _lock;
+  _PTHREAD_ATOMIC(uint32_t) _lock;
 } pthread_once_t;
 
 typedef struct pthread_spinlock_s {
-  _Atomic(int) _lock;
+  _PTHREAD_ATOMIC(int) _lock;
 } pthread_spinlock_t;
 
 typedef struct pthread_mutex_s {
-  _Atomic(int32_t) _lock;
-  unsigned _type : 2;
-  unsigned _pshared : 1;
-  unsigned _depth : 6;
-  unsigned _owner : 23;
-  long _pid;
+  void *_edges;
+  _PTHREAD_ATOMIC(uint64_t) _word;
+  _PTHREAD_ATOMIC(int) _futex;
+  int _pid;
+  void *_nsync[2];
 } pthread_mutex_t;
 
 typedef struct pthread_mutexattr_s {
-  char _type;
-  char _pshared;
+  unsigned _word;
 } pthread_mutexattr_t;
 
+typedef struct pthread_condattr_s {
+  char _pshared;
+  char _clock;
+} pthread_condattr_t;
+
 typedef struct pthread_cond_s {
+  char _pshared;
+  char _clock;
+  char _footek;
+  _PTHREAD_ATOMIC(char) _waited;
+  _PTHREAD_ATOMIC(uint32_t) _sequence;
+  _PTHREAD_ATOMIC(uint32_t) _waiters;
   void *_nsync[2];
 } pthread_cond_t;
 
 typedef struct pthread_rwlock_s {
-  void *_nsync[2];
-  char _iswrite;
+  union {
+    void *_nsync[2];
+    struct {
+      uint32_t _nsync_word;
+      char _pshared;
+      char _iswrite;
+      _PTHREAD_ATOMIC(uint32_t) _word;
+      _PTHREAD_ATOMIC(uint32_t) _waiters;
+    };
+  };
 } pthread_rwlock_t;
 
 typedef struct pthread_barrier_s {
-  void *_nsync;
+  int _count;
+  char _pshared;
+  _PTHREAD_ATOMIC(int) _counter;
+  _PTHREAD_ATOMIC(int) _waiters;
 } pthread_barrier_t;
 
 typedef struct pthread_attr_s {
@@ -98,10 +127,12 @@ typedef struct pthread_attr_s {
   int __schedparam;
   int __schedpolicy;
   int __contentionscope;
-  int __guardsize;
-  size_t __stacksize;
+  int __sigaltstacksize;
   uint64_t __sigmask;
+  size_t __guardsize;
+  size_t __stacksize;
   void *__stackaddr;
+  void *__sigaltstackaddr;
 } pthread_attr_t;
 
 struct _pthread_cleanup_buffer {
@@ -120,6 +151,8 @@ int pthread_attr_getguardsize(const pthread_attr_t *, size_t *) libcesque params
 int pthread_attr_getinheritsched(const pthread_attr_t *, int *) libcesque paramsnonnull();
 int pthread_attr_getschedpolicy(const pthread_attr_t *, int *) libcesque paramsnonnull();
 int pthread_attr_getscope(const pthread_attr_t *, int *) libcesque paramsnonnull();
+int pthread_attr_getsigaltstack_np(const pthread_attr_t *, void **, size_t *) libcesque paramsnonnull();
+int pthread_attr_getsigaltstacksize_np(const pthread_attr_t *, size_t *) libcesque paramsnonnull();
 int pthread_attr_getstack(const pthread_attr_t *, void **, size_t *) libcesque paramsnonnull();
 int pthread_attr_getstacksize(const pthread_attr_t *, size_t *) libcesque paramsnonnull();
 int pthread_attr_init(pthread_attr_t *) libcesque paramsnonnull();
@@ -128,41 +161,48 @@ int pthread_attr_setguardsize(pthread_attr_t *, size_t) libcesque paramsnonnull(
 int pthread_attr_setinheritsched(pthread_attr_t *, int) libcesque paramsnonnull();
 int pthread_attr_setschedpolicy(pthread_attr_t *, int) libcesque paramsnonnull();
 int pthread_attr_setscope(pthread_attr_t *, int) libcesque paramsnonnull();
+int pthread_attr_setsigaltstack_np(pthread_attr_t *, void *, size_t) libcesque paramsnonnull((1));
+int pthread_attr_setsigaltstacksize_np(pthread_attr_t *, size_t);
 int pthread_attr_setstack(pthread_attr_t *, void *, size_t) libcesque paramsnonnull((1));
 int pthread_attr_setstacksize(pthread_attr_t *, size_t) libcesque paramsnonnull();
 int pthread_barrier_destroy(pthread_barrier_t *) libcesque paramsnonnull();
 int pthread_barrier_init(pthread_barrier_t *, const pthread_barrierattr_t *, unsigned) libcesque paramsnonnull((1));
-int pthread_barrier_wait(pthread_barrier_t *) libcesque paramsnonnull();
+int pthread_barrier_wait(pthread_barrier_t *) dontthrow paramsnonnull();
 int pthread_barrierattr_destroy(pthread_barrierattr_t *) libcesque paramsnonnull();
 int pthread_barrierattr_getpshared(const pthread_barrierattr_t *, int *) libcesque paramsnonnull();
 int pthread_barrierattr_init(pthread_barrierattr_t *) libcesque paramsnonnull();
 int pthread_barrierattr_setpshared(pthread_barrierattr_t *, int) libcesque paramsnonnull();
-int pthread_cancel(pthread_t) libcesque;
-int pthread_cond_broadcast(pthread_cond_t *) libcesque paramsnonnull();
+int pthread_cancel(pthread_t) dontthrow;
+int pthread_cond_broadcast(pthread_cond_t *) dontthrow paramsnonnull();
 int pthread_cond_destroy(pthread_cond_t *) libcesque paramsnonnull();
 int pthread_cond_init(pthread_cond_t *, const pthread_condattr_t *) libcesque paramsnonnull((1));
-int pthread_cond_signal(pthread_cond_t *) libcesque paramsnonnull();
-int pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *) libcesque paramsnonnull();
+int pthread_cond_signal(pthread_cond_t *) dontthrow paramsnonnull();
+int pthread_cond_wait(pthread_cond_t *, pthread_mutex_t *) dontthrow paramsnonnull();
 int pthread_condattr_destroy(pthread_condattr_t *) libcesque paramsnonnull();
+int pthread_condattr_getclock(const pthread_condattr_t *, int *) libcesque paramsnonnull();
 int pthread_condattr_getpshared(const pthread_condattr_t *, int *) libcesque paramsnonnull();
 int pthread_condattr_init(pthread_condattr_t *) libcesque paramsnonnull();
+int pthread_condattr_setclock(pthread_condattr_t *, int) libcesque paramsnonnull();
 int pthread_condattr_setpshared(pthread_condattr_t *, int) libcesque paramsnonnull();
 int pthread_create(pthread_t *, const pthread_attr_t *, void *(*)(void *), void *) dontthrow paramsnonnull((1));
-int pthread_detach(pthread_t) libcesque;
+int pthread_decimate_np(void) dontthrow;
+int pthread_delay_np(const void *, int) dontthrow;
+int pthread_detach(pthread_t) dontthrow;
 int pthread_equal(pthread_t, pthread_t) libcesque;
 int pthread_getattr_np(pthread_t, pthread_attr_t *) libcesque paramsnonnull();
 int pthread_getname_np(pthread_t, char *, size_t) libcesque paramsnonnull();
 int pthread_getunique_np(pthread_t, pthread_id_np_t *) libcesque paramsnonnull();
-int pthread_join(pthread_t, void **) libcesque;
+int pthread_join(pthread_t, void **) dontthrow;
 int pthread_key_create(pthread_key_t *, pthread_key_dtor) libcesque paramsnonnull((1));
 int pthread_key_delete(pthread_key_t) libcesque;
-int pthread_kill(pthread_t, int) libcesque;
-int pthread_mutex_consistent(pthread_mutex_t *) libcesque paramsnonnull();
+int pthread_kill(pthread_t, int) dontthrow;
+int pthread_mutex_consistent(pthread_mutex_t *) dontthrow paramsnonnull();
 int pthread_mutex_destroy(pthread_mutex_t *) libcesque paramsnonnull();
 int pthread_mutex_init(pthread_mutex_t *, const pthread_mutexattr_t *) libcesque paramsnonnull((1));
-int pthread_mutex_lock(pthread_mutex_t *) libcesque paramsnonnull();
-int pthread_mutex_trylock(pthread_mutex_t *) libcesque paramsnonnull();
-int pthread_mutex_unlock(pthread_mutex_t *) libcesque paramsnonnull();
+int pthread_mutex_lock(pthread_mutex_t *) dontthrow paramsnonnull();
+int pthread_mutex_trylock(pthread_mutex_t *) dontthrow paramsnonnull();
+int pthread_mutex_unlock(pthread_mutex_t *) dontthrow paramsnonnull();
+int pthread_mutex_wipe_np(pthread_mutex_t *) libcesque paramsnonnull();
 int pthread_mutexattr_destroy(pthread_mutexattr_t *) libcesque paramsnonnull();
 int pthread_mutexattr_getpshared(const pthread_mutexattr_t *, int *) libcesque paramsnonnull();
 int pthread_mutexattr_gettype(const pthread_mutexattr_t *, int *) libcesque paramsnonnull();
@@ -173,11 +213,11 @@ int pthread_once(pthread_once_t *, void (*)(void)) paramsnonnull();
 int pthread_orphan_np(void) libcesque;
 int pthread_rwlock_destroy(pthread_rwlock_t *) libcesque paramsnonnull();
 int pthread_rwlock_init(pthread_rwlock_t *, const pthread_rwlockattr_t *) libcesque paramsnonnull((1));
-int pthread_rwlock_rdlock(pthread_rwlock_t *) libcesque paramsnonnull();
-int pthread_rwlock_tryrdlock(pthread_rwlock_t *) libcesque paramsnonnull();
-int pthread_rwlock_trywrlock(pthread_rwlock_t *) libcesque paramsnonnull();
-int pthread_rwlock_unlock(pthread_rwlock_t *) libcesque paramsnonnull();
-int pthread_rwlock_wrlock(pthread_rwlock_t *) libcesque paramsnonnull();
+int pthread_rwlock_rdlock(pthread_rwlock_t *) dontthrow paramsnonnull();
+int pthread_rwlock_tryrdlock(pthread_rwlock_t *) dontthrow paramsnonnull();
+int pthread_rwlock_trywrlock(pthread_rwlock_t *) dontthrow paramsnonnull();
+int pthread_rwlock_unlock(pthread_rwlock_t *) dontthrow paramsnonnull();
+int pthread_rwlock_wrlock(pthread_rwlock_t *) dontthrow paramsnonnull();
 int pthread_rwlockattr_destroy(pthread_rwlockattr_t *) libcesque paramsnonnull();
 int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *, int *) libcesque paramsnonnull();
 int pthread_rwlockattr_init(pthread_rwlockattr_t *) libcesque paramsnonnull();
@@ -189,21 +229,21 @@ int pthread_setschedprio(pthread_t, int) libcesque;
 int pthread_setspecific(pthread_key_t, const void *) libcesque;
 int pthread_spin_destroy(pthread_spinlock_t *) libcesque paramsnonnull();
 int pthread_spin_init(pthread_spinlock_t *, int) libcesque paramsnonnull();
-int pthread_spin_lock(pthread_spinlock_t *) libcesque paramsnonnull();
-int pthread_spin_trylock(pthread_spinlock_t *) libcesque paramsnonnull();
-int pthread_spin_unlock(pthread_spinlock_t *) libcesque paramsnonnull();
-int pthread_testcancel_np(void) libcesque;
-int pthread_tryjoin_np(pthread_t, void **) libcesque;
-int pthread_yield_np(void) libcesque;
-int pthread_yield(void) libcesque;
+int pthread_spin_lock(pthread_spinlock_t *) dontthrow paramsnonnull();
+int pthread_spin_trylock(pthread_spinlock_t *) dontthrow paramsnonnull();
+int pthread_spin_unlock(pthread_spinlock_t *) dontthrow paramsnonnull();
+int pthread_testcancel_np(void) dontthrow;
+int pthread_tryjoin_np(pthread_t, void **) dontthrow;
+int pthread_yield(void) dontthrow;
+int pthread_yield_np(void) dontthrow;
 pthread_id_np_t pthread_getthreadid_np(void) libcesque;
 pthread_t pthread_self(void) libcesque pureconst;
 void *pthread_getspecific(pthread_key_t) libcesque;
-void pthread_cleanup_pop(struct _pthread_cleanup_buffer *, int) libcesque paramsnonnull();
-void pthread_cleanup_push(struct _pthread_cleanup_buffer *, void (*)(void *), void *) libcesque paramsnonnull((1));
-void pthread_exit(void *) libcesque wontreturn;
-void pthread_testcancel(void) libcesque;
-void pthread_pause_np(void) libcesque;
+void pthread_cleanup_pop(struct _pthread_cleanup_buffer *, int) dontthrow paramsnonnull();
+void pthread_cleanup_push(struct _pthread_cleanup_buffer *, void (*)(void *), void *) dontthrow paramsnonnull((1));
+void pthread_exit(void *) wontreturn;
+void pthread_pause_np(void) dontthrow;
+void pthread_testcancel(void) dontthrow;
 
 /* clang-format on */
 
diff --git a/libc/thread/thread2.h b/libc/thread/thread2.h
index db1d845ab..a51e48ce2 100644
--- a/libc/thread/thread2.h
+++ b/libc/thread/thread2.h
@@ -13,12 +13,12 @@ int pthread_attr_getschedparam(const pthread_attr_t *, struct sched_param *) lib
 int pthread_attr_getsigmask_np(const pthread_attr_t *, sigset_t *) libcesque paramsnonnull((1));
 int pthread_attr_setschedparam(pthread_attr_t *, const struct sched_param *) libcesque paramsnonnull();
 int pthread_attr_setsigmask_np(pthread_attr_t *, const sigset_t *) libcesque paramsnonnull((1));
-int pthread_cond_timedwait(pthread_cond_t *, pthread_mutex_t *, const struct timespec *) libcesque paramsnonnull((1, 2));
+int pthread_cond_timedwait(pthread_cond_t *, pthread_mutex_t *, const struct timespec *) dontthrow paramsnonnull((1, 2));
 int pthread_getaffinity_np(pthread_t, size_t, cpu_set_t *) libcesque paramsnonnull();
 int pthread_getschedparam(pthread_t, int *, struct sched_param *) libcesque paramsnonnull();
 int pthread_setaffinity_np(pthread_t, size_t, const cpu_set_t *) libcesque paramsnonnull();
 int pthread_setschedparam(pthread_t, int, const struct sched_param *) libcesque paramsnonnull();
-int pthread_timedjoin_np(pthread_t, void **, struct timespec *) libcesque;
+int pthread_timedjoin_np(pthread_t, void **, struct timespec *) dontthrow;
 
 /* clang-format off */
 COSMOPOLITAN_C_END_
diff --git a/libc/thread/threads.h b/libc/thread/threads.h
index 8fe01c89f..3446a4cea 100644
--- a/libc/thread/threads.h
+++ b/libc/thread/threads.h
@@ -27,7 +27,7 @@ enum {
 typedef uintptr_t thrd_t;
 typedef void (*tss_dtor_t)(void *);
 typedef int (*thrd_start_t)(void *);
-typedef _Atomic(uint32_t) once_flag;
+typedef uint32_t once_flag;
 
 void call_once(once_flag *, void (*)(void));
 int thrd_create(thrd_t *, thrd_start_t, void *);
diff --git a/libc/thread/tls.h b/libc/thread/tls.h
index 61952f8d1..e4c2a73b1 100644
--- a/libc/thread/tls.h
+++ b/libc/thread/tls.h
@@ -4,19 +4,17 @@
 #define TLS_ALIGNMENT 64
 
 #define TIB_FLAG_VFORKED 1
-#define TIB_FLAG_MAPLOCK 2
 
 #if !(__ASSEMBLER__ + __LINKER__ + 0)
 COSMOPOLITAN_C_START_
 
 struct CosmoFtrace {   /* 16 */
   char ft_once;        /*  0 */
-  char ft_noreentry;   /*  1 */
   int ft_skew;         /*  4 */
   int64_t ft_lastaddr; /*  8 */
 };
 
-/* cosmopolitan thread information block (512 bytes) */
+/* cosmopolitan thread information block (1024 bytes) */
 /* NOTE: update aarch64 libc/errno.h if sizeof changes */
 /* NOTE: update aarch64 libc/proc/vfork.S if sizeof changes */
 /* NOTE: update aarch64 libc/nexgen32e/gc.S if sizeof changes */
@@ -24,10 +22,10 @@ struct CosmoTib {
   struct CosmoTib *tib_self;      /* 0x00 */
   struct CosmoFtrace tib_ftracer; /* 0x08 */
   void *tib_garbages;             /* 0x18 */
-  intptr_t tib_locale;            /* 0x20 */
+  _Atomic(int32_t) tib_ptid;      /* 0x20 transitions 0 → tid */
   intptr_t tib_pthread;           /* 0x28 */
   struct CosmoTib *tib_self2;     /* 0x30 */
-  _Atomic(int32_t) tib_tid;       /* 0x38 transitions -1 → tid → 0 */
+  _Atomic(int32_t) tib_ctid;      /* 0x38 transitions -1 → tid → 0 */
   int32_t tib_errno;              /* 0x3c */
   uint64_t tib_flags;             /* 0x40 */
   int tib_ftrace;                 /* inherited */
@@ -39,10 +37,11 @@ struct CosmoTib {
   uint32_t tib_sigstack_size;
   uint32_t tib_sigstack_flags;
   void *tib_nsync;
-  void *tib_keys[48];
+  void *tib_atexit;
+  _Atomic(void *) tib_keys[46];
+  void *tib_locks[64];
 } __attribute__((__aligned__(64)));
 
-extern int __threaded;
 extern char __tls_morphed;
 extern unsigned __tls_index;
 
@@ -79,6 +78,10 @@ forceinline pureconst struct CosmoTib *__get_tls(void) {
 #endif
 }
 
+struct CosmoTib *__get_tls_privileged(void) dontthrow pureconst;
+struct CosmoTib *__get_tls_win32(void) dontthrow;
+void __set_tls_win32(void *) libcesque;
+
 #ifdef __x86_64__
 #define __adj_tls(tib) (tib)
 #elif defined(__aarch64__)
diff --git a/libc/thread/tls2.internal.h b/libc/thread/tls2.internal.h
deleted file mode 100644
index 383d79cc2..000000000
--- a/libc/thread/tls2.internal.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_THREAD_TLS2_H_
-#define COSMOPOLITAN_LIBC_THREAD_TLS2_H_
-#include "libc/dce.h"
-#include "libc/thread/tls.h"
-COSMOPOLITAN_C_START_
-#if defined(__GNUC__) && defined(__x86_64__)
-
-/**
- * Returns location of thread information block.
- *
- * This should be favored over __get_tls() for .privileged code that
- * can't be self-modified by __enable_tls().
- */
-forceinline struct CosmoTib *__get_tls_privileged(void) {
-  char *tib, *lin = (char *)0x30;
-  if (IsNetbsd() || IsOpenbsd()) {
-    __asm__("mov\t%%fs:(%1),%0" : "=a"(tib) : "r"(lin) : "memory");
-  } else {
-    __asm__("mov\t%%gs:(%1),%0" : "=a"(tib) : "r"(lin) : "memory");
-    if (IsWindows()) {
-      tib = *(char **)(tib + 0x1480 + __tls_index * 8);
-    }
-  }
-  return (struct CosmoTib *)tib;
-}
-
-forceinline struct CosmoTib *__get_tls_win32(void) {
-  char *tib, *lin = (char *)0x30;
-  __asm__("mov\t%%gs:(%1),%0" : "=a"(tib) : "r"(lin) : "memory");
-  tib = *(char **)(tib + 0x1480 + __tls_index * 8);
-  return (struct CosmoTib *)tib;
-}
-
-forceinline void __set_tls_win32(void *tls) {
-  __asm__("mov\t%1,%%gs:%0" : "=m"(*((long *)0x1480 + __tls_index)) : "r"(tls));
-}
-
-#elif defined(__aarch64__)
-#define __get_tls_privileged() __get_tls()
-#define __get_tls_win32()      ((struct CosmoTib *)0)
-#define __set_tls_win32(tls)   (void)0
-#endif /* GNU x86-64 */
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_LIBC_THREAD_TLS2_H_ */
diff --git a/libc/thread/ualarm.c b/libc/thread/ualarm.c
index 625199c8a..db23b3877 100644
--- a/libc/thread/ualarm.c
+++ b/libc/thread/ualarm.c
@@ -20,6 +20,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/itimerval.h"
 #include "libc/calls/struct/timeval.h"
+#include "libc/stdio/sysparam.h"
 #include "libc/sysv/consts/itimer.h"
 
 /**
@@ -36,5 +37,6 @@ unsigned ualarm(unsigned usecs, unsigned reload) {
   it.it_value = timeval_frommicros(usecs);
   it.it_interval = timeval_frommicros(reload);
   npassert(!setitimer(ITIMER_REAL, &it, &old));
-  return timeval_tomicros(old.it_value);
+  int64_t us = timeval_tomicros(old.it_value);
+  return MIN(us, -1u);
 }
diff --git a/libc/tinymath/LICENSE.fdlibm b/libc/tinymath/LICENSE.fdlibm
index ce235e6c8..b54cb5227 100644
--- a/libc/tinymath/LICENSE.fdlibm
+++ b/libc/tinymath/LICENSE.fdlibm
@@ -1 +1,6 @@
-Q29weXJpZ2h0IChDKSAxOTkzLTIwMDQgYnkgU3VuIE1pY3Jvc3lzdGVtcywgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgoKRGV2ZWxvcGVkIGF0IFN1blNvZnQsIGEgU3VuIE1pY3Jvc3lzdGVtcywgSW5jLiBidXNpbmVzcy4KUGVybWlzc2lvbiB0byB1c2UsIGNvcHksIG1vZGlmeSwgYW5kIGRpc3RyaWJ1dGUgdGhpcwpzb2Z0d2FyZSBpcyBmcmVlbHkgZ3JhbnRlZCwgcHJvdmlkZWQgdGhhdCB0aGlzIG5vdGljZQppcyBwcmVzZXJ2ZWQuCg==
\ No newline at end of file
+Copyright (C) 1993-2004 by Sun Microsystems, Inc. All rights reserved.
+
+Developed at SunSoft, a Sun Microsystems, Inc. business.
+Permission to use, copy, modify, and distribute this
+software is freely granted, provided that this notice
+is preserved.
diff --git a/libc/tinymath/exp10.c b/libc/tinymath/exp10.c
index f42d7d574..f58f0f3f0 100644
--- a/libc/tinymath/exp10.c
+++ b/libc/tinymath/exp10.c
@@ -43,7 +43,7 @@ special_case (uint64_t sbits, double_t tmp, uint64_t ki)
 {
   double_t scale, y;
 
-  if (ki - (1ull << 16) < 0x80000000)
+  if ((ki & 0x80000000) == 0)
     {
       /* The exponent of scale might have overflowed by 1.  */
       sbits -= 1ull << 52;
@@ -109,14 +109,14 @@ exp10 (double x)
   /* Reduce x: z = x * N / log10(2), k = round(z).  */
   double_t z = __exp_data.invlog10_2N * x;
   double_t kd;
-  int64_t ki;
+  uint64_t ki;
 #if TOINT_INTRINSICS
   kd = roundtoint (z);
   ki = converttoint (z);
 #else
   kd = eval_as_double (z + Shift);
+  ki = asuint64 (kd);
   kd -= Shift;
-  ki = kd;
 #endif
 
   /* r = x - k * log10(2), r in [-0.5, 0.5].  */
@@ -155,5 +155,6 @@ exp10 (double x)
 
 __strong_reference(exp10, pow10);
 #if LDBL_MANT_DIG == 53 && LDBL_MAX_EXP == 1024
+__weak_reference(exp10, pow10l);
 __weak_reference(exp10, exp10l);
 #endif
diff --git a/libc/tinymath/exp10l.c b/libc/tinymath/exp10l.c
index 1111bde6e..d41fd35d3 100644
--- a/libc/tinymath/exp10l.c
+++ b/libc/tinymath/exp10l.c
@@ -52,6 +52,6 @@ long double exp10l(long double x)
 	return powl(10.0, x);
 }
 
-__weak_reference(exp10l, pow10l);
+__strong_reference(exp10l, pow10l);
 
 #endif /* long double is long */
diff --git a/libc/tinymath/lgamma_r.c b/libc/tinymath/lgamma_r.c
index 4632b144c..0257db75a 100644
--- a/libc/tinymath/lgamma_r.c
+++ b/libc/tinymath/lgamma_r.c
@@ -204,7 +204,7 @@ static double sin_pi(double x)
 double lgamma_r(double x, int *signgamp)
 {
 	union {double f; uint64_t i;} u = {x};
-	double_t t,y,z,nadj,p,p1,p2,p3,q,r,w;
+	double_t t,y,z,nadj=0,p,p1,p2,p3,q,r,w;
 	uint32_t ix;
 	int sign,i;
 
diff --git a/libc/tinymath/lgammaf_r.c b/libc/tinymath/lgammaf_r.c
index ee6b7a286..d70f7d736 100644
--- a/libc/tinymath/lgammaf_r.c
+++ b/libc/tinymath/lgammaf_r.c
@@ -139,7 +139,7 @@ static float sin_pi(float x)
 float lgammaf_r(float x, int *signgamp)
 {
 	union {float f; uint32_t i;} u = {x};
-	float t,y,z,nadj,p,p1,p2,p3,q,r,w;
+	float t,y,z,nadj=0,p,p1,p2,p3,q,r,w;
 	uint32_t ix;
 	int i,sign;
 
diff --git a/libc/tinymath/lgammal.c b/libc/tinymath/lgammal.c
index ec3309acb..452335ba7 100644
--- a/libc/tinymath/lgammal.c
+++ b/libc/tinymath/lgammal.c
@@ -247,7 +247,7 @@ static long double sin_pi(long double x)
 }
 
 long double lgammal_r(long double x, int *sg) {
-	long double t, y, z, nadj, p, p1, p2, q, r, w;
+	long double t, y, z, nadj=0, p, p1, p2, q, r, w;
 	union ldshape u = {x};
 	uint32_t ix = (u.i.se & 0x7fffU)<<16 | u.i.m>>48;
 	int sign = u.i.se >> 15;
diff --git a/libc/tinymath/powl.c b/libc/tinymath/powl.c
index 3ed4cd9e4..0e015082d 100644
--- a/libc/tinymath/powl.c
+++ b/libc/tinymath/powl.c
@@ -930,7 +930,7 @@ powl(long double x, long double y)
   z = one - (r - z);
   o.value = z;
   j = o.parts32.mswhi;
-  j += (n << 16);
+  j += (int32_t)((uint32_t)n << 16); // TODO(jart): why ubsan
   if ((j >> 16) <= 0)
     z = scalbnl (z, n);	/* subnormal output */
   else
diff --git a/libc/type2str.h b/libc/type2str.h
deleted file mode 100644
index ec62d002b..000000000
--- a/libc/type2str.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef COSMOPOLITAN_LIBC_TYPE2STR_H_
-#define COSMOPOLITAN_LIBC_TYPE2STR_H_
-#if __STDC_VERSION__ + 0 >= 201112
-/* clang-format off */
-
-#define _TYPE2STR(X)                          \
-  _Generic(X,                                 \
-    _Bool:              "_Bool",              \
-    signed char:        "signed char",        \
-    unsigned char:      "unsigned char",      \
-    char:               "char",               \
-    short:              "short",              \
-    unsigned short:     "unsigned short",     \
-    int:                "int",                \
-    unsigned:           "unsigned",           \
-    long:               "long",               \
-    unsigned long:      "unsigned long",      \
-    long long:          "long long",          \
-    unsigned long long: "unsigned long long", \
-    __int128:           "__int128",           \
-    unsigned __int128:  "unsigned __int128",  \
-    float:              "float",              \
-    double:             "double",             \
-    long double:        "long double")
-
-#define _PRINTF_GENERIC(X, D, U) \
-  _Generic(X,                    \
-    _Bool:              "hhh" U, \
-    signed char:        "hh" D,  \
-    unsigned char:      "hh" U,  \
-    char:               "hh" D,  \
-    short:              "h" D,   \
-    unsigned short:     "h" U,   \
-    int:                D,       \
-    unsigned:           U,       \
-    long:               "l" D,   \
-    unsigned long:      "l" U,   \
-    long long:          "ll" D,  \
-    unsigned long long: "ll" U,  \
-    float:              "f",     \
-    double:             "f",     \
-    long double:        "Lf")
-
-/* clang-format on */
-#endif /* C11 */
-#endif /* COSMOPOLITAN_LIBC_TYPE2STR_H_ */
diff --git a/libc/vga/readv-vga.c b/libc/vga/readv-vga.c
index 3f746e729..5aaa4562a 100644
--- a/libc/vga/readv-vga.c
+++ b/libc/vga/readv-vga.c
@@ -24,7 +24,7 @@
 │ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR        │
 │ OTHER DEALINGS IN THE SOFTWARE.                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/vga/vga.internal.h"
diff --git a/libc/vga/rlinit-init-vga.S b/libc/vga/rlinit-init-vga.S
index 70ff1ccb6..6a759cb73 100644
--- a/libc/vga/rlinit-init-vga.S
+++ b/libc/vga/rlinit-init-vga.S
@@ -24,7 +24,7 @@
 │ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR        │
 │ OTHER DEALINGS IN THE SOFTWARE.                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/mman.internal.h"
 #include "libc/vga/vga.internal.h"
 
diff --git a/libc/vga/rlinit-vesa.S b/libc/vga/rlinit-vesa.S
index f1a91b1a0..dfa1922f8 100644
--- a/libc/vga/rlinit-vesa.S
+++ b/libc/vga/rlinit-vesa.S
@@ -25,7 +25,7 @@
 │ OTHER DEALINGS IN THE SOFTWARE.                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "ape/relocations.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/mman.internal.h"
 #include "libc/vga/vga.internal.h"
 
diff --git a/libc/vga/tty-graph.c b/libc/vga/tty-graph.c
index 55c4c409f..1c2ad77df 100644
--- a/libc/vga/tty-graph.c
+++ b/libc/vga/tty-graph.c
@@ -25,7 +25,7 @@
 │ OTHER DEALINGS IN THE SOFTWARE.                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/newbie.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/vga/vga.internal.h"
 
diff --git a/libc/vga/tty-graph.inc b/libc/vga/tty-graph.inc
index 392e447f0..dc646ad2d 100644
--- a/libc/vga/tty-graph.inc
+++ b/libc/vga/tty-graph.inc
@@ -25,7 +25,7 @@
 │ OTHER DEALINGS IN THE SOFTWARE.                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/newbie.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
 #include "libc/vga/vga.internal.h"
diff --git a/libc/vga/tty-klog.greg.c b/libc/vga/tty-klog.greg.c
index e841034b2..35afe5380 100644
--- a/libc/vga/tty-klog.greg.c
+++ b/libc/vga/tty-klog.greg.c
@@ -25,7 +25,7 @@
 │ OTHER DEALINGS IN THE SOFTWARE.                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/newbie.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/mman.internal.h"
 #include "libc/str/str.h"
 #include "libc/vga/vga.internal.h"
diff --git a/libc/vga/tty.greg.c b/libc/vga/tty.greg.c
index 4f84a240e..7b2738a3b 100644
--- a/libc/vga/tty.greg.c
+++ b/libc/vga/tty.greg.c
@@ -16,10 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/fmt/bing.internal.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/directmap.internal.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/directmap.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/runtime/pc.internal.h"
 #include "libc/str/str.h"
 #include "libc/str/thompike.h"
@@ -166,7 +167,6 @@ void _StartTty(struct Tty *tty, unsigned char type, unsigned short yp,
                unsigned short startx, unsigned char yc, unsigned char xc,
                void *fb, unsigned init_flags) {
   unsigned short yn, xn, xs = xp * sizeof(TtyCanvasColor);
-  struct DirectMap dm;
   bzero(tty, sizeof(struct Tty));
   SetYp(tty, yp);
   SetXp(tty, xp);
@@ -182,9 +182,9 @@ void _StartTty(struct Tty *tty, unsigned char type, unsigned short yp,
       tty->canvas = fb;
       xs = xsfb;
     } else {
-      dm = sys_mmap_metal(NULL, (size_t)yp * xs, PROT_READ | PROT_WRITE,
-                          MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-      if (dm.addr == (void *)-1) {
+      void *addr = sys_mmap_metal(NULL, (size_t)yp * xs, PROT_READ | PROT_WRITE,
+                                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+      if (addr == (void *)-1) {
         /*
          * We are a bit low on memory.  Try to go on anyway, & initialize
          * our tty as an emergency console.
@@ -193,7 +193,7 @@ void _StartTty(struct Tty *tty, unsigned char type, unsigned short yp,
         tty->canvas = fb;
         xs = xsfb;
       } else
-        tty->canvas = dm.addr;
+        tty->canvas = addr;
     }
   }
   SetYn(tty, yn);
diff --git a/libc/vga/writev-vga.c b/libc/vga/writev-vga.c
index 1c6d35e1e..f88e053c2 100644
--- a/libc/vga/writev-vga.c
+++ b/libc/vga/writev-vga.c
@@ -24,7 +24,7 @@
 │ ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR        │
 │ OTHER DEALINGS IN THE SOFTWARE.                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/struct/fd.internal.h"
+#include "libc/intrin/fds.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/iovec.internal.h"
 #include "libc/dce.h"
diff --git a/libc/wctype.h b/libc/wctype.h
new file mode 100644
index 000000000..af1c246fe
--- /dev/null
+++ b/libc/wctype.h
@@ -0,0 +1,35 @@
+#ifndef COSMOPOLITAN_WCTYPE_H_
+#define COSMOPOLITAN_WCTYPE_H_
+COSMOPOLITAN_C_START_
+
+#ifndef WEOF
+#define WEOF -1u
+#endif
+
+typedef unsigned wctype_t;
+typedef const int *wctrans_t;
+
+int iswalnum(wint_t) libcesque;
+int iswalpha(wint_t) libcesque;
+int iswblank(wint_t) libcesque;
+int iswcntrl(wint_t) libcesque;
+int iswdigit(wint_t) libcesque;
+int iswgraph(wint_t) libcesque;
+int iswlower(wint_t) libcesque;
+int iswspace(wint_t) libcesque;
+int iswupper(wint_t) libcesque;
+int iswxdigit(wint_t) libcesque;
+int iswpunct(wint_t) libcesque;
+int iswprint(wint_t) libcesque;
+int iswseparator(wint_t) libcesque;
+wint_t towlower(wint_t) libcesque;
+wint_t towupper(wint_t) libcesque;
+
+wctype_t wctype(const char *) strlenesque;
+pureconst int iswctype(wint_t, wctype_t) libcesque;
+
+wctrans_t wctrans(const char *) libcesque;
+wint_t towctrans(wint_t, wctrans_t) libcesque;
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_WCTYPE_H_ */
diff --git a/libc/x/BUILD.mk b/libc/x/BUILD.mk
index dc1de97a8..343fcb5a1 100644
--- a/libc/x/BUILD.mk
+++ b/libc/x/BUILD.mk
@@ -33,11 +33,14 @@ LIBC_X_A_DIRECTDEPS =				\
 	LIBC_PROC				\
 	LIBC_RUNTIME				\
 	LIBC_NT_KERNEL32			\
+	LIBC_NT_ADVAPI32			\
 	LIBC_STDIO				\
+	LIBC_SOCK				\
 	LIBC_STR				\
 	LIBC_SYSV				\
 	THIRD_PARTY_GDTOA			\
-	THIRD_PARTY_MUSL
+	THIRD_PARTY_MUSL			\
+	THIRD_PARTY_TZ				\
 
 LIBC_X_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(LIBC_X_A_DIRECTDEPS),$($(x))))
diff --git a/libc/x/paginate.c b/libc/x/paginate.c
index 5b86705d0..a377208bc 100644
--- a/libc/x/paginate.c
+++ b/libc/x/paginate.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/syscall_support-nt.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/mem/gc.h"
 #include "libc/runtime/runtime.h"
diff --git a/libc/sock/syslog.c b/libc/x/syslog.c
similarity index 99%
rename from libc/sock/syslog.c
rename to libc/x/syslog.c
index c0ac9caf5..9d278ed84 100644
--- a/libc/sock/syslog.c
+++ b/libc/x/syslog.c
@@ -23,9 +23,9 @@
 #include "libc/calls/weirdtypes.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/log/internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nt/events.h"
 #include "libc/nt/runtime.h"
 #include "libc/sock/sock.h"
diff --git a/libc/x/utf16to8.c b/libc/x/utf16to8.c
index 219c2e2a9..dfcd4dea3 100644
--- a/libc/x/utf16to8.c
+++ b/libc/x/utf16to8.c
@@ -17,21 +17,13 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bsr.h"
-#include "libc/intrin/packsswb.h"
-#include "libc/intrin/pandn.h"
-#include "libc/intrin/pcmpgtb.h"
-#include "libc/intrin/pcmpgtw.h"
-#include "libc/intrin/pmovmskb.h"
-#include "libc/intrin/punpckhbw.h"
-#include "libc/intrin/punpcklbw.h"
 #include "libc/mem/mem.h"
 #include "libc/serialize.h"
 #include "libc/str/str.h"
 #include "libc/str/thompike.h"
 #include "libc/str/utf16.h"
 #include "libc/x/x.h"
-
-static const int16_t kDel16[8] = {127, 127, 127, 127, 127, 127, 127, 127};
+#include "third_party/intel/emmintrin.internal.h"
 
 /**
  * Transcodes UTF-16 to UTF-8.
@@ -45,28 +37,27 @@ char *utf16to8(const char16_t *p, size_t n, size_t *z) {
   char *r, *q;
   wint_t x, y;
   const char16_t *e;
-  int16_t v1[8], v2[8], v3[8], vz[8];
   if (z)
     *z = 0;
   if (n == -1)
     n = p ? strlen16(p) : 0;
   if ((q = r = malloc(n * 4 + 8 + 1))) {
     for (e = p + n; p < e;) {
-      if (p + 8 < e) { /* 17x ascii */
-        bzero(vz, 16);
+#if defined(__x86_64__)
+      if (p + 8 < e) {
         do {
-          memcpy(v1, p, 16);
-          pcmpgtw(v2, v1, vz);
-          pcmpgtw(v3, v1, kDel16);
-          pandn((void *)v2, (void *)v3, (void *)v2);
-          if (pmovmskb((void *)v2) != 0xFFFF)
+          __m128i v1 = _mm_loadu_si128((__m128i *)p);
+          __m128i v2 = _mm_cmpgt_epi16(v1, _mm_setzero_si128());
+          __m128i v3 = _mm_cmpgt_epi16(v1, _mm_set1_epi16(127));
+          v2 = _mm_andnot_si128(v3, v2);
+          if (_mm_movemask_epi8(v2) != 0xFFFF)
             break;
-          packsswb((void *)v1, v1, v1);
-          memcpy(q, v1, 8);
+          _mm_storel_epi64((__m128i *)q, _mm_packs_epi16(v1, v1));
           p += 8;
           q += 8;
         } while (p + 8 < e);
       }
+#endif
       x = *p++ & 0xffff;
       if (!IsUcs2(x)) {
         if (p < e) {
diff --git a/libc/x/utf8to32.c b/libc/x/utf8to32.c
index f1a8568cc..15170e1a2 100644
--- a/libc/x/utf8to32.c
+++ b/libc/x/utf8to32.c
@@ -16,18 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/likely.h"
-#include "libc/intrin/pcmpgtb.h"
-#include "libc/intrin/pmovmskb.h"
-#include "libc/intrin/punpckhbw.h"
-#include "libc/intrin/punpckhwd.h"
-#include "libc/intrin/punpcklbw.h"
-#include "libc/intrin/punpcklwd.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "libc/str/thompike.h"
 #include "libc/str/utf16.h"
 #include "libc/x/x.h"
+#include "third_party/intel/emmintrin.internal.h"
 
 /**
  * Transcodes UTF-8 to UTF-32.
@@ -41,35 +35,35 @@ wchar_t *utf8to32(const char *p, size_t n, size_t *z) {
   unsigned m, j;
   wint_t x, a, b;
   wchar_t *r, *q;
-  uint8_t v1[16], v2[16], v3[16], v4[16], vz[16];
   if (z)
     *z = 0;
   if (n == -1)
     n = p ? strlen(p) : 0;
   if ((q = r = malloc(n * sizeof(wchar_t) + sizeof(wchar_t)))) {
     for (i = 0; i < n;) {
+#ifdef __x86_64__
       if (!((uintptr_t)(p + i) & 15) && i + 16 < n) {
-        /* 10x speedup for ascii */
-        bzero(vz, 16);
         do {
-          memcpy(v1, p + i, 16);
-          pcmpgtb((int8_t *)v2, (int8_t *)v1, (int8_t *)vz);
-          if (pmovmskb(v2) != 0xFFFF)
+          __m128i v1, v2, v3, v4;
+          v1 = _mm_loadu_si128((__m128i *)(p + i));
+          v2 = _mm_cmpgt_epi8(v1, _mm_setzero_si128());
+          if (_mm_movemask_epi8(v2) != 0xFFFF)
             break;
-          punpcklbw(v3, v1, vz);
-          punpckhbw(v1, v1, vz);
-          punpcklwd((void *)v4, (void *)v3, (void *)vz);
-          punpckhwd((void *)v3, (void *)v3, (void *)vz);
-          punpcklwd((void *)v2, (void *)v1, (void *)vz);
-          punpckhwd((void *)v1, (void *)v1, (void *)vz);
-          memcpy(q + 0, v4, 16);
-          memcpy(q + 4, v3, 16);
-          memcpy(q + 8, v2, 16);
-          memcpy(q + 12, v1, 16);
+          v3 = _mm_unpacklo_epi8(v1, _mm_setzero_si128());
+          v1 = _mm_unpackhi_epi8(v1, _mm_setzero_si128());
+          v4 = _mm_unpacklo_epi16(v3, _mm_setzero_si128());
+          v3 = _mm_unpackhi_epi16(v3, _mm_setzero_si128());
+          v2 = _mm_unpacklo_epi16(v1, _mm_setzero_si128());
+          v1 = _mm_unpackhi_epi16(v1, _mm_setzero_si128());
+          _mm_storeu_si128((__m128i *)(q + 0), v4);
+          _mm_storeu_si128((__m128i *)(q + 4), v3);
+          _mm_storeu_si128((__m128i *)(q + 8), v2);
+          _mm_storeu_si128((__m128i *)(q + 12), v1);
           i += 16;
           q += 16;
         } while (i + 16 < n);
       }
+#endif
       x = p[i++] & 0xff;
       if (x >= 0300) {
         a = ThomPikeByte(x);
diff --git a/libc/x/x.h b/libc/x/x.h
index dca4b877a..b35a2cb9b 100644
--- a/libc/x/x.h
+++ b/libc/x/x.h
@@ -81,7 +81,7 @@ char *utf32to8(const wchar_t *, size_t, size_t *) __wur;
 char *xhomedir(void) __wur;
 char *xstripext(const char *) __wur;
 char *xstripexts(const char *) __wur;
-void *xload(_Atomic(void *) *, const void *, size_t, size_t);
+void *xload(void *, const void *, size_t, size_t);
 int rmrf(const char *);
 char *xbasename(const char *) paramsnonnull()
     returnspointerwithnoaliases dontthrow dontcallback __wur returnsnonnull;
diff --git a/libc/x/xjoinpaths.c b/libc/x/xjoinpaths.c
index ce5281e43..4921d5404 100644
--- a/libc/x/xjoinpaths.c
+++ b/libc/x/xjoinpaths.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/str/str.h"
 #include "libc/x/x.h"
 
diff --git a/libc/x/xload.c b/libc/x/xload.c
index 334b73c95..44abda0af 100644
--- a/libc/x/xload.c
+++ b/libc/x/xload.c
@@ -40,7 +40,8 @@
  * @param m is byte length of inflated data
  * @return pointer to inflated data
  */
-void *xload(_Atomic(void *) *a, const void *p, size_t n, size_t m) {
+void *xload(void *a_, const void *p, size_t n, size_t m) {
+  _Atomic(void *) *a = (_Atomic(void *) *)a_;
   void *r, *z;
   if ((r = atomic_load_explicit(a, memory_order_acquire)))
     return r;
diff --git a/libc/zip.internal.h b/libc/zip.h
similarity index 100%
rename from libc/zip.internal.h
rename to libc/zip.h
diff --git a/net/finger/fingersyn.c b/net/finger/fingersyn.c
index eb3d24fab..e46a091e2 100644
--- a/net/finger/fingersyn.c
+++ b/net/finger/fingersyn.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bsr.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 /**
  * Fingers IP+TCP SYN packet.
diff --git a/net/http/base32.c b/net/http/base32.c
index c9a3af12f..3d8ed1160 100644
--- a/net/http/base32.c
+++ b/net/http/base32.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 
diff --git a/net/http/decodebase64.c b/net/http/decodebase64.c
index a9b19288a..a3aeaa38d 100644
--- a/net/http/decodebase64.c
+++ b/net/http/decodebase64.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "net/http/escape.h"
diff --git a/net/http/decodelatin1.c b/net/http/decodelatin1.c
index 4799d8a9d..ce9aed209 100644
--- a/net/http/decodelatin1.c
+++ b/net/http/decodelatin1.c
@@ -16,8 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pcmpgtb.h"
-#include "libc/intrin/pmovmskb.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "net/http/escape.h"
@@ -34,23 +32,12 @@ char *DecodeLatin1(const char *p, size_t n, size_t *z) {
   int c;
   size_t i;
   char *r, *q;
-  int8_t v1[16], v2[16], vz[16];
   if (z)
     *z = 0;
   if (n == -1)
     n = p ? strlen(p) : 0;
   if ((q = r = malloc(n * 2 + 1))) {
     for (i = 0; i < n;) {
-      bzero(vz, 16); /* 3x speedup for ASCII */
-      while (i + 16 < n) {
-        memcpy(v1, p + i, 16);
-        pcmpgtb(v2, v1, vz);
-        if (pmovmskb((void *)v2) != 0xFFFF)
-          break;
-        memcpy(q, v1, 16);
-        q += 16;
-        i += 16;
-      }
       c = p[i++] & 0xff;
       if (c < 0200) {
         *q++ = c;
diff --git a/net/http/encodelatin1.c b/net/http/encodelatin1.c
index 4d6798ec7..9d3bc0ed8 100644
--- a/net/http/encodelatin1.c
+++ b/net/http/encodelatin1.c
@@ -17,8 +17,6 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
-#include "libc/intrin/pcmpgtb.h"
-#include "libc/intrin/pmovmskb.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
diff --git a/net/http/encodeurl.c b/net/http/encodeurl.c
index acb7e09d3..455a2bdc3 100644
--- a/net/http/encodeurl.c
+++ b/net/http/encodeurl.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "net/http/escape.h"
 #include "net/http/url.h"
 
diff --git a/net/http/findcontenttype.c b/net/http/findcontenttype.c
index 5ad6a3a81..587a05cad 100644
--- a/net/http/findcontenttype.c
+++ b/net/http/findcontenttype.c
@@ -18,10 +18,10 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
 #include "libc/intrin/bswap.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/serialize.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "net/http/http.h"
 
 static const struct ContentTypeExtension {
diff --git a/net/http/formathttpdatetime.c b/net/http/formathttpdatetime.c
index 80089e3d0..e0b6d5c1b 100644
--- a/net/http/formathttpdatetime.c
+++ b/net/http/formathttpdatetime.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/time.h"
 #include "net/http/http.h"
diff --git a/net/http/gethttpheader.inc b/net/http/gethttpheader.inc
index 72f3b7afe..8e58c9279 100644
--- a/net/http/gethttpheader.inc
+++ b/net/http/gethttpheader.inc
@@ -33,7 +33,7 @@
 #line 1 "gethttpheader.gperf"
 
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "net/http/http.h"
 #define GPERF_DOWNCASE
 #line 12 "gethttpheader.gperf"
diff --git a/net/http/gethttpreason.c b/net/http/gethttpreason.c
index 276a75baa..e4492f914 100644
--- a/net/http/gethttpreason.c
+++ b/net/http/gethttpreason.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "net/http/http.h"
 
 static const struct thatispacked HttpReason {
diff --git a/net/http/isacceptablehost.c b/net/http/isacceptablehost.c
index f8dc7feed..1eb8ff046 100644
--- a/net/http/isacceptablehost.c
+++ b/net/http/isacceptablehost.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/str/str.h"
 #include "net/http/http.h"
 
diff --git a/net/http/ismimetype.c b/net/http/ismimetype.c
index a810a0585..17a0956d6 100644
--- a/net/http/ismimetype.c
+++ b/net/http/ismimetype.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "net/http/http.h"
 
 /**
diff --git a/net/http/isnocompressext.c b/net/http/isnocompressext.c
index 10b6b7e72..49b21be28 100644
--- a/net/http/isnocompressext.c
+++ b/net/http/isnocompressext.c
@@ -17,10 +17,10 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bswap.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/serialize.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "net/http/http.h"
 
 static const char kNoCompressExts[][8] = {
diff --git a/net/http/parsecidr.c b/net/http/parsecidr.c
index 01ede3523..5fb1f6fbb 100644
--- a/net/http/parsecidr.c
+++ b/net/http/parsecidr.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/str/str.h"
 #include "net/http/ip.h"
 
diff --git a/net/http/parsecontentlength.c b/net/http/parsecontentlength.c
index 3755e63ff..d2bf3ae85 100644
--- a/net/http/parsecontentlength.c
+++ b/net/http/parsecontentlength.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
 #include "net/http/http.h"
diff --git a/net/http/parseforwarded.c b/net/http/parseforwarded.c
index 0d3e746b3..f999f3f71 100644
--- a/net/http/parseforwarded.c
+++ b/net/http/parseforwarded.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/str/str.h"
 #include "net/http/http.h"
 
diff --git a/net/http/parsehttpmessage.c b/net/http/parsehttpmessage.c
index 91ef243b7..8a0429a41 100644
--- a/net/http/parsehttpmessage.c
+++ b/net/http/parsehttpmessage.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/ctype.h"
 #include "libc/limits.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/arraylist.internal.h"
@@ -24,7 +25,7 @@
 #include "libc/serialize.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/sysv/errfuns.h"
 #include "libc/x/x.h"
 #include "net/http/http.h"
@@ -46,6 +47,7 @@ void DestroyHttpMessage(struct HttpMessage *r) {
     free(r->xheaders.p);
     r->xheaders.p = NULL;
     r->xheaders.n = 0;
+    r->xheaders.c = 0;
   }
 }
 
diff --git a/net/http/parsehttpmethod.c b/net/http/parsehttpmethod.c
index bb71041d4..152dadc2e 100644
--- a/net/http/parsehttpmethod.c
+++ b/net/http/parsehttpmethod.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "net/http/http.h"
 
 /**
diff --git a/net/http/parsehttprange.c b/net/http/parsehttprange.c
index 80aa738b7..4974482dc 100644
--- a/net/http/parsehttprange.c
+++ b/net/http/parsehttprange.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
 #include "net/http/http.h"
diff --git a/net/http/parseip.c b/net/http/parseip.c
index 700f49044..72df550ea 100644
--- a/net/http/parseip.c
+++ b/net/http/parseip.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
 #include "net/http/ip.h"
diff --git a/net/http/parseurl.c b/net/http/parseurl.c
index c967f4543..16ffd4b58 100644
--- a/net/http/parseurl.c
+++ b/net/http/parseurl.c
@@ -20,7 +20,7 @@
 #include "libc/limits.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/x/x.h"
 #include "net/http/escape.h"
 #include "net/http/url.h"
diff --git a/net/http/unchunk.c b/net/http/unchunk.c
index d3fe94bfe..cbacd179e 100644
--- a/net/http/unchunk.c
+++ b/net/http/unchunk.c
@@ -16,9 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/sysv/errfuns.h"
 #include "net/http/escape.h"
 #include "net/http/http.h"
diff --git a/net/http/underlong.c b/net/http/underlong.c
index a48e7f48c..1d0906582 100644
--- a/net/http/underlong.c
+++ b/net/http/underlong.c
@@ -16,8 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/pcmpgtb.h"
-#include "libc/intrin/pmovmskb.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "libc/str/thompike.h"
@@ -40,23 +38,12 @@ char *Underlong(const char *p, size_t n, size_t *z) {
   char *r, *q;
   size_t i, j, m;
   wint_t x, a, b;
-  int8_t v1[16], v2[16], vz[16];
   if (z)
     *z = 0;
   if (n == -1)
     n = p ? strlen(p) : 0;
   if ((q = r = malloc(n * 2 + 1))) {
     for (i = 0; i < n;) {
-      bzero(vz, 16); /* 50x speedup for ASCII */
-      while (i + 16 < n) {
-        memcpy(v1, p + i, 16);
-        pcmpgtb(v2, v1, vz);
-        if (pmovmskb((void *)v2) != 0xFFFF)
-          break;
-        memcpy(q, v1, 16);
-        q += 16;
-        i += 16;
-      }
       x = p[i++] & 0xff;
       if (x >= 0300) {
         a = ThomPikeByte(x);
diff --git a/net/https/describesslverifyfailure.c b/net/https/describesslverifyfailure.c
index 46e0056ab..44b22a809 100644
--- a/net/https/describesslverifyfailure.c
+++ b/net/https/describesslverifyfailure.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "net/https/https.h"
diff --git a/net/https/finishcertificate.c b/net/https/finishcertificate.c
index 13aaf28b6..2d56078f1 100644
--- a/net/https/finishcertificate.c
+++ b/net/https/finishcertificate.c
@@ -27,7 +27,7 @@ struct Cert FinishCertificate(struct Cert *ca, mbedtls_x509write_cert *wcert,
   int i, n, rc;
   unsigned char *p;
   mbedtls_x509_crt *cert;
-  p = malloc((n = __granularity()));
+  p = malloc((n = getgransize()));
   i = mbedtls_x509write_crt_der(wcert, p, n, GenerateHardRandom, 0);
   if (i < 0)
     FATALF("write key (grep -0x%04x)", -i);
diff --git a/net/turfwar/BUILD.mk b/net/turfwar/BUILD.mk
index ffa291ea9..0a49ad12f 100644
--- a/net/turfwar/BUILD.mk
+++ b/net/turfwar/BUILD.mk
@@ -9,8 +9,8 @@ NET_TURFWAR_OBJS =					\
 	$(NET_TURFWAR_SRCS:%.c=o/$(MODE)/%.o)
 
 NET_TURFWAR_COMS =					\
-	$(NET_TURFWAR_SRCS:%.c=o/$(MODE)/%.com)		\
-	o/$(MODE)/net/turfwar/turfbean.com
+	$(NET_TURFWAR_SRCS:%.c=o/$(MODE)/%)		\
+	o/$(MODE)/net/turfwar/turfbean
 
 NET_TURFWAR_BINS =					\
 	$(NET_TURFWAR_COMS)				\
@@ -28,6 +28,7 @@ NET_TURFWAR_DIRECTDEPS =				\
 	LIBC_SOCK					\
 	LIBC_STDIO					\
 	LIBC_STR					\
+	LIBC_SYSTEM					\
 	LIBC_SYSV					\
 	LIBC_THREAD					\
 	LIBC_X						\
@@ -39,7 +40,7 @@ NET_TURFWAR_DIRECTDEPS =				\
 	THIRD_PARTY_SQLITE3				\
 	THIRD_PARTY_STB					\
 	THIRD_PARTY_TZ					\
-	THIRD_PARTY_ZLIB
+	THIRD_PARTY_ZLIB				\
 
 NET_TURFWAR_DEPS :=					\
 	$(call uniq,$(foreach x,$(NET_TURFWAR_DIRECTDEPS),$($(x))))
@@ -48,7 +49,7 @@ o/$(MODE)/net/turfwar/turfwar.pkg:			\
 		$(NET_TURFWAR_OBJS)			\
 		$(foreach x,$(NET_TURFWAR_DIRECTDEPS),$($(x)_A).pkg)
 
-o/$(MODE)/net/turfwar/%.com.dbg:			\
+o/$(MODE)/net/turfwar/%.dbg:				\
 		$(NET_TURFWAR_DEPS)			\
 		o/$(MODE)/net/turfwar/%.o		\
 		o/$(MODE)/net/turfwar/turfwar.pkg	\
@@ -56,7 +57,7 @@ o/$(MODE)/net/turfwar/%.com.dbg:			\
 		$(APE_NO_MODIFY_SELF)
 	@$(APELINK)
 
-o/$(MODE)/net/turfwar/turfbean.com.dbg:			\
+o/$(MODE)/net/turfwar/turfbean.dbg:			\
 		$(TOOL_NET_DEPS)			\
 		o/$(MODE)/tool/net/redbean.o		\
 		$(TOOL_NET_REDBEAN_LUA_MODULES)		\
diff --git a/net/turfwar/blackholed.c b/net/turfwar/blackholed.c
index b21bc04b4..a7175dbd7 100644
--- a/net/turfwar/blackholed.c
+++ b/net/turfwar/blackholed.c
@@ -22,12 +22,13 @@
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/calls/struct/timespec.h"
+#include "libc/ctype.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/mem.h"
 #include "libc/mem/sortedints.internal.h"
 #include "libc/runtime/runtime.h"
diff --git a/net/turfwar/turfwar.c b/net/turfwar/turfwar.c
index 5d9d2c768..f2cf5ee3f 100644
--- a/net/turfwar/turfwar.c
+++ b/net/turfwar/turfwar.c
@@ -17,79 +17,67 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/atomic.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/pledge.h"
 #include "libc/calls/struct/iovec.h"
 #include "libc/calls/struct/rusage.h"
 #include "libc/calls/struct/sigaction.h"
+#include "libc/calls/struct/siginfo.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/calls/struct/sysinfo.h"
 #include "libc/calls/struct/timespec.h"
-#include "libc/calls/struct/timeval.h"
+#include "libc/calls/struct/ucontext.internal.h"
+#include "libc/calls/ucontext.h"
+#include "libc/ctype.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/atomic.h"
-#include "libc/intrin/bsr.h"
-#include "libc/intrin/hilbert.h"
+#include "libc/intrin/iscall.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/mem/sortedints.internal.h"
-#include "libc/nexgen32e/crc32.h"
+#include "libc/nexgen32e/stackframe.h"
 #include "libc/paths.h"
-#include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
-#include "libc/runtime/stack.h"
 #include "libc/runtime/sysconf.h"
-#include "libc/serialize.h"
 #include "libc/sock/sock.h"
-#include "libc/sock/struct/pollfd.h"
 #include "libc/sock/struct/sockaddr.h"
 #include "libc/stdio/append.h"
-#include "libc/stdio/rand.h"
-#include "libc/stdio/stdio.h"
 #include "libc/str/slice.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/af.h"
 #include "libc/sysv/consts/clock.h"
+#include "libc/sysv/consts/f.h"
 #include "libc/sysv/consts/o.h"
-#include "libc/sysv/consts/poll.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/rusage.h"
+#include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/consts/so.h"
 #include "libc/sysv/consts/sock.h"
 #include "libc/sysv/consts/sol.h"
 #include "libc/sysv/consts/tcp.h"
+#include "libc/sysv/consts/timer.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/thread2.h"
 #include "libc/time.h"
 #include "libc/x/x.h"
-#include "libc/x/xasprintf.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "net/http/escape.h"
 #include "net/http/http.h"
 #include "net/http/ip.h"
 #include "net/http/tokenbucket.h"
 #include "net/http/url.h"
 #include "third_party/getopt/getopt.internal.h"
-#include "third_party/nsync/counter.h"
-#include "third_party/nsync/cv.h"
-#include "third_party/nsync/mu.h"
-#include "third_party/nsync/note.h"
-#include "third_party/nsync/time.h"
 #include "third_party/sqlite3/sqlite3.h"
-#include "third_party/stb/stb_image_write.h"
-#include "third_party/zlib/zconf.h"
 #include "third_party/zlib/zlib.h"
-#include "tool/net/lfuncs.h"
 
 /**
  * @fileoverview production webserver for turfwar online game
@@ -97,8 +85,6 @@
 
 #define PORT               8080    // default server listening port
 #define CPUS               64      // number of cpus to actually use
-#define XN                 64      // plot width in pixels
-#define YN                 64      // plot height in pixels
 #define WORKERS            500     // size of http client thread pool
 #define SUPERVISE_MS       1000    // how often to stat() asset files
 #define KEEPALIVE_MS       60000   // max time to keep idle conn open
@@ -108,7 +94,6 @@
 #define SCORE_W_UPDATE_MS  70000   // how often to regenerate /score/week
 #define SCORE_M_UPDATE_MS  100000  // how often to regenerate /score/month
 #define SCORE_UPDATE_MS    210000  // how often to regenerate /score
-#define PLOTS_UPDATE_MS    999000  // how often to regenerate /plot/xxx
 #define ACCEPT_DEADLINE_MS 100     // how long accept() can take to find worker
 #define CLAIM_DEADLINE_MS  100     // how long /claim may block if queue is full
 #define CONCERN_LOAD       .75     // avoid keepalive, upon this connection load
@@ -123,7 +108,7 @@
 #define MSG_BUF            512     // small response lookaside
 
 #define INBUF_SIZE  65536
-#define OUTBUF_SIZE 8192
+#define OUTBUF_SIZE 65536
 
 #define TB_BYTES (1u << TB_CIDR)
 #define TB_WORDS (TB_BYTES / 8)
@@ -234,9 +219,10 @@ struct Data {
 };
 
 struct Asset {
+  atomic_bool ready;
   int cash;
   char *path;
-  nsync_mu lock;
+  pthread_rwlock_t lock;
   const char *type;
   struct Data data;
   struct Data gzip;
@@ -255,18 +241,23 @@ struct Blackhole {
 // cli flags
 bool g_integrity;
 bool g_daemonize;
+int g_crash_fd;
 int g_port = PORT;
 int g_workers = WORKERS;
 int g_keepalive = KEEPALIVE_MS;
 struct SortedInts g_whitelisted;
+thread_local char last_message[INBUF_SIZE];
+sig_atomic_t is_shutting_down;
+
+// threads
+pthread_t g_listener;
+pthread_t scorer, recenter, claimer, replenisher;
+pthread_t scorer_hour, scorer_day, scorer_week, scorer_month;
 
 // lifecycle vars
-pthread_t g_listener;
-nsync_time g_started;
-nsync_counter g_ready;
+struct timespec g_started;
 atomic_int g_connections;
-nsync_note g_shutdown[3];
-int g_hilbert[YN * XN][2];
+atomic_int g_worker_threads;
 
 // whitebox metrics
 atomic_long g_banned;
@@ -307,25 +298,23 @@ union TokenBucket {
 // http worker objects
 struct Worker {
   pthread_t th;
+  atomic_bool dead;
   atomic_int msgcount;
-  atomic_int shutdown;
   atomic_int connected;
   struct timespec startread;
+  char *msgbuf;
+  char *inbuf;
+  char *outbuf;
+  struct HttpMessage *msg;
+  struct Client *client;
 } *g_worker;
 
 // recentworker wakeup
 struct Recent {
-  nsync_mu mu;
-  nsync_cv cv;
+  pthread_mutex_t mu;
+  pthread_cond_t cv;
 } g_recent;
 
-// global date header
-struct Nowish {
-  nsync_mu lock;
-  struct timespec ts;
-  struct tm tm;
-} g_nowish;
-
 // static assets
 struct Assets {
   struct Asset index;
@@ -338,16 +327,15 @@ struct Assets {
   struct Asset score_month;
   struct Asset recent;
   struct Asset favicon;
-  struct Asset plot[256];
 } g_asset;
 
 // queues ListenWorker() to HttpWorker()
 struct Clients {
   int pos;
   int count;
-  nsync_mu mu;
-  nsync_cv non_full;
-  nsync_cv non_empty;
+  pthread_mutex_t mu;
+  pthread_cond_t non_full;
+  pthread_cond_t non_empty;
   struct Client {
     int sock;
     uint32_t size;
@@ -359,9 +347,9 @@ struct Clients {
 struct Claims {
   int pos;
   int count;
-  nsync_mu mu;
-  nsync_cv non_full;
-  nsync_cv non_empty;
+  pthread_mutex_t mu;
+  pthread_cond_t non_full;
+  pthread_cond_t non_empty;
   struct Claim {
     uint32_t ip;
     int64_t created;
@@ -390,25 +378,25 @@ struct timespec WaitFor(int millis) {
 bool CheckMem(const char *file, int line, void *ptr) {
   if (ptr)
     return true;
-  kprintf("%s:%d: %P: out of memory: %s\n", file, line, strerror(errno));
+  kprintf("%s:%d: %H: out of memory: %s\n", file, line, strerror(errno));
   return false;
 }
 bool CheckSys(const char *file, int line, long rc) {
   if (rc != -1)
     return true;
-  kprintf("%s:%d: %P: %s\n", file, line, strerror(errno));
+  kprintf("%s:%d: %H: %s\n", file, line, strerror(errno));
   return false;
 }
 bool CheckSql(const char *file, int line, int rc) {
   if (rc == SQLITE_OK)
     return true;
-  kprintf("%s:%d: %P: %s\n", file, line, sqlite3_errstr(rc));
+  kprintf("%s:%d: %H: %s\n", file, line, sqlite3_errstr(rc));
   return false;
 }
 bool CheckDb(const char *file, int line, int rc, sqlite3 *db) {
   if (rc == SQLITE_OK)
     return true;
-  kprintf("%s:%d: %P: %s: %s\n", file, line, sqlite3_errstr(rc),
+  kprintf("%s:%d: %H: %s: %s\n", file, line, sqlite3_errstr(rc),
           sqlite3_errmsg(db));
   return false;
 }
@@ -500,51 +488,187 @@ bool IsValidNick(const char *s, size_t n) {
   return true;
 }
 
+struct Clock {
+  atomic_uint roll;
+  atomic_ulong time;
+  atomic_ulong date;
+};
+
+static struct Clock g_clck[2];
+static pthread_t g_time_thread;
+
+static void set_clck(struct Clock *clck, long time, long date) {
+  unsigned long roll;
+  roll = atomic_fetch_add_explicit(&clck->roll, 1, memory_order_relaxed);
+  time &= 0xffffffffffff;
+  date &= 0xffffffffffff;
+  time |= roll << 48;
+  date |= roll << 48;
+  atomic_store_explicit(&clck->time, time, memory_order_relaxed);
+  atomic_store_explicit(&clck->date, date, memory_order_relaxed);
+}
+
+static void get_clck(struct Clock *clck, long *out_time, long *out_date) {
+  long time, date;
+  do {
+    time = atomic_load_explicit(&clck->time, memory_order_relaxed);
+    date = atomic_load_explicit(&clck->date, memory_order_relaxed);
+  } while ((time >> 48) != (date >> 48));
+  *out_date = date & 0xffffffffffff;
+  *out_time = time & 0xffffffffffff;
+}
+
+static long encode_date(const struct tm *tm) {
+  long date;
+  date = tm->tm_year;
+  date <<= 4;
+  date |= tm->tm_isdst == 1;
+  date <<= 1;
+  date |= tm->tm_mon;
+  date <<= 5;
+  date |= tm->tm_mday;
+  date <<= 3;
+  date |= tm->tm_wday;
+  date <<= 5;
+  date |= tm->tm_hour;
+  date <<= 6;
+  date |= tm->tm_min;
+  date <<= 6;
+  date |= tm->tm_sec;
+  return date;
+}
+
+static void decode_date(long date, struct tm *tm) {
+  tm->tm_sec = date & 63;
+  date >>= 6;
+  tm->tm_min = date & 63;
+  date >>= 6;
+  tm->tm_hour = date & 31;
+  date >>= 5;
+  tm->tm_wday = date & 7;
+  date >>= 3;
+  tm->tm_mday = date & 31;
+  date >>= 5;
+  tm->tm_mon = date & 15;
+  date >>= 4;
+  tm->tm_isdst = date & 1;
+  date >>= 1;
+  tm->tm_year = date;
+  tm->tm_gmtoff = 0;  // unsupported
+  tm->tm_zone = 0;    // unsupported
+  tm->tm_yday = 0;    // unsupported
+}
+
+static void update_time() {
+  struct tm tm;
+  struct timespec ts;
+  clock_gettime(0, &ts);
+  gmtime_r(&ts.tv_sec, &tm);
+  set_clck(&g_clck[0], ts.tv_sec, encode_date(&tm));
+  localtime_r(&ts.tv_sec, &tm);
+  set_clck(&g_clck[1], ts.tv_sec, encode_date(&tm));
+}
+
+static void *time_worker(void *arg) {
+  sigset_t ss;
+  sigemptyset(&ss);
+  sigaddset(&ss, SIGHUP);
+  sigaddset(&ss, SIGINT);
+  sigaddset(&ss, SIGQUIT);
+  sigaddset(&ss, SIGTERM);
+  sigaddset(&ss, SIGUSR1);
+  sigaddset(&ss, SIGALRM);
+  pthread_sigmask(SIG_SETMASK, &ss, 0);
+  pthread_setname_np(pthread_self(), "localtime");
+  for (;;) {
+    sleep(10);
+    update_time();
+  }
+  return nullptr;
+}
+
+void time_init() {
+  update_time();
+  if (pthread_create(&g_time_thread, 0, time_worker, 0))
+    __builtin_trap();
+}
+
+void time_destroy() {
+  pthread_cancel(g_time_thread);
+  if (pthread_join(g_time_thread, 0))
+    __builtin_trap();
+}
+
+static const char kMonDays[2][12] = {
+    {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+    {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
+};
+
+static void time_lockless(struct Clock *clck, long now, struct tm *tm) {
+  long time, date, since;
+  get_clck(clck, &time, &date);
+  decode_date(date, tm);
+  since = now - time;
+  since = since < 60 ? since : 60;
+  for (; since > 0; --since) {
+    if (++tm->tm_sec >= 60) {
+      tm->tm_sec = 0;
+      if (++tm->tm_min >= 60) {
+        tm->tm_min = 0;
+        if (++tm->tm_hour >= 24) {
+          tm->tm_hour = 0;
+          if (++tm->tm_mday >= 7)
+            tm->tm_mday = 0;
+          if (++tm->tm_mday > kMonDays[!!tm->tm_isdst][tm->tm_mon]) {
+            tm->tm_mday = 1;
+            if (++tm->tm_mon >= 12) {
+              tm->tm_mon = 0;
+              ++tm->tm_year;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+void gmtime_lockless(long now, struct tm *tm) {
+  time_lockless(&g_clck[0], now, tm);
+}
+
+void localtime_lockless(long now, struct tm *tm) {
+  time_lockless(&g_clck[1], now, tm);
+}
+
 // turn unix timestamp into string the easy way
 char *FormatUnixHttpDateTime(char *s, int64_t t) {
   struct tm tm;
-  gmtime_r(&t, &tm);
+  gmtime_lockless(t, &tm);
   FormatHttpDateTime(s, &tm);
   return s;
 }
 
-// gmtime_r() does a shocking amount of compute
-// so we try to handle that globally right here
-void UpdateNow(void) {
-  int64_t secs;
-  struct tm tm;
-  g_nowish.ts = timespec_real();
-  secs = g_nowish.ts.tv_sec;
-  gmtime_r(&secs, &tm);
-  //!//!//!//!//!//!//!//!//!//!//!//!//!/
-  nsync_mu_lock(&g_nowish.lock);
-  g_nowish.tm = tm;
-  nsync_mu_unlock(&g_nowish.lock);
-  //!//!//!//!//!//!//!//!//!//!//!//!//!/
-}
-
 // the standard strftime() function is dismally slow
 // this function is non-generalized for just http so
 // it needs 25 cycles rather than 709 cycles so cool
 char *FormatDate(char *p) {
-  ////////////////////////////////////////
-  nsync_mu_rlock(&g_nowish.lock);
-  p = FormatHttpDateTime(p, &g_nowish.tm);
-  nsync_mu_runlock(&g_nowish.lock);
-  ////////////////////////////////////////
-  return p;
+  return FormatUnixHttpDateTime(p, timespec_real().tv_sec);
 }
 
-bool AddClient(struct Clients *q, const struct Client *v, nsync_time dead) {
+void unlock_mutex(void *arg) {
+  pthread_mutex_t *lock = arg;
+  pthread_mutex_unlock(lock);
+}
+
+bool AddClient(struct Clients *q, const struct Client *v,
+               struct timespec dead) {
   bool wake = false;
   bool added = false;
-  nsync_mu_lock(&q->mu);
-  while (q->count == ARRAYLEN(q->data)) {
-    if (nsync_cv_wait_with_deadline(&q->non_full, &q->mu, dead,
-                                    g_shutdown[0])) {
-      break;  // must be ETIMEDOUT or ECANCELED
-    }
-  }
+  pthread_mutex_lock(&q->mu);
+  pthread_cleanup_push(unlock_mutex, &q->mu);
+  while (q->count == ARRAYLEN(q->data))
+    if (pthread_cond_timedwait(&q->non_full, &q->mu, &dead))
+      break;  // must be ETIMEDOUT
   if (q->count != ARRAYLEN(q->data)) {
     int i = q->pos + q->count;
     if (ARRAYLEN(q->data) <= i)
@@ -555,52 +679,44 @@ bool AddClient(struct Clients *q, const struct Client *v, nsync_time dead) {
     q->count++;
     added = true;
   }
-  nsync_mu_unlock(&q->mu);
-  if (wake) {
-    nsync_cv_broadcast(&q->non_empty);
-  }
+  pthread_cleanup_pop(true);
+  if (wake)
+    pthread_cond_broadcast(&q->non_empty);
   return added;
 }
 
 int GetClient(struct Clients *q, struct Client *out) {
   int got = 0;
   int len = 1;
-  nsync_mu_lock(&q->mu);
-  while (!q->count) {
-    if (nsync_cv_wait_with_deadline(&q->non_empty, &q->mu,
-                                    nsync_time_no_deadline, g_shutdown[1])) {
-      break;  // must be ECANCELED
-    }
-  }
+  pthread_mutex_lock(&q->mu);
+  pthread_cleanup_push(unlock_mutex, &q->mu);
+  while (!q->count)
+    pthread_cond_timedwait(&q->non_empty, &q->mu, 0);
   while (got < len && q->count) {
     memcpy(out + got, q->data + q->pos, sizeof(*out));
-    if (q->count == ARRAYLEN(q->data)) {
-      nsync_cv_broadcast(&q->non_full);
-    }
+    if (q->count == ARRAYLEN(q->data))
+      pthread_cond_broadcast(&q->non_full);
     ++got;
     q->pos++;
     q->count--;
-    if (q->pos == ARRAYLEN(q->data)) {
+    if (q->pos == ARRAYLEN(q->data))
       q->pos = 0;
-    }
   }
-  nsync_mu_unlock(&q->mu);
+  pthread_cleanup_pop(true);
   return got;
 }
 
 // inserts ip:name claim into blocking message queue
 // may be interrupted by absolute deadline
 // may be cancelled by server shutdown
-bool AddClaim(struct Claims *q, const struct Claim *v, nsync_time dead) {
+bool AddClaim(struct Claims *q, const struct Claim *v, struct timespec dead) {
   bool wake = false;
   bool added = false;
-  nsync_mu_lock(&q->mu);
-  while (q->count == ARRAYLEN(q->data)) {
-    if (nsync_cv_wait_with_deadline(&q->non_full, &q->mu, dead,
-                                    g_shutdown[1])) {
+  pthread_mutex_lock(&q->mu);
+  pthread_cleanup_push(unlock_mutex, &q->mu);
+  while (q->count == ARRAYLEN(q->data))
+    if (pthread_cond_timedwait(&q->non_full, &q->mu, &dead))
       break;  // must be ETIMEDOUT or ECANCELED
-    }
-  }
   if (q->count != ARRAYLEN(q->data)) {
     int i = q->pos + q->count;
     if (ARRAYLEN(q->data) <= i)
@@ -611,10 +727,9 @@ bool AddClaim(struct Claims *q, const struct Claim *v, nsync_time dead) {
     q->count++;
     added = true;
   }
-  nsync_mu_unlock(&q->mu);
-  if (wake) {
-    nsync_cv_broadcast(&q->non_empty);
-  }
+  pthread_cleanup_pop(true);
+  if (wake)
+    pthread_cond_broadcast(&q->non_empty);
   return added;
 }
 
@@ -622,26 +737,25 @@ bool AddClaim(struct Claims *q, const struct Claim *v, nsync_time dead) {
 // has no deadline or cancellation; enqueued must be processed
 int GetClaims(struct Claims *q, struct Claim *out, int len) {
   int got = 0;
-  nsync_mu_lock(&q->mu);
-  while (!q->count) {
-    if (nsync_cv_wait_with_deadline(&q->non_empty, &q->mu,
-                                    nsync_time_no_deadline, g_shutdown[2])) {
+  pthread_mutex_lock(&q->mu);
+  pthread_cleanup_push(unlock_mutex, &q->mu);
+  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
+  while (!q->count)
+    if (pthread_cond_timedwait(&q->non_empty, &q->mu, 0))
       break;  // must be ECANCELED
-    }
-  }
+  pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
   while (got < len && q->count) {
     memcpy(out + got, q->data + q->pos, sizeof(*out));
     if (q->count == ARRAYLEN(q->data)) {
-      nsync_cv_broadcast(&q->non_full);
+      pthread_cond_broadcast(&q->non_full);
     }
     ++got;
     q->pos++;
     q->count--;
-    if (q->pos == ARRAYLEN(q->data)) {
+    if (q->pos == ARRAYLEN(q->data))
       q->pos = 0;
-    }
   }
-  nsync_mu_unlock(&q->mu);
+  pthread_cleanup_pop(true);
   return got;
 }
 
@@ -693,14 +807,14 @@ void FreeSafeBuffer(void *p) {
 void BlockSignals(void) {
   sigset_t mask;
   sigfillset(&mask);
-  sigprocmask(SIG_SETMASK, &mask, 0);
-}
-
-// main thread uses sigusr1 to deliver io cancellations
-void AllowSigusr1(void) {
-  sigset_t mask;
-  sigfillset(&mask);
-  sigdelset(&mask, SIGUSR1);
+  sigdelset(&mask, SIGABRT);
+  sigdelset(&mask, SIGTRAP);
+  sigdelset(&mask, SIGFPE);
+  sigdelset(&mask, SIGBUS);
+  sigdelset(&mask, SIGSEGV);
+  sigdelset(&mask, SIGILL);
+  sigdelset(&mask, SIGXCPU);
+  sigdelset(&mask, SIGXFSZ);
   sigprocmask(SIG_SETMASK, &mask, 0);
 }
 
@@ -730,6 +844,7 @@ void ServeStatusz(int client, char *outbuf) {
   p = Statusz(p, "now", now.tv_sec);
   p = Statusz(p, "messages", g_messages);
   p = Statusz(p, "connections", g_connections);
+  p = Statusz(p, "worker_threads", g_worker_threads);
   p = Statusz(p, "banned", g_banned);
   p = Statusz(p, "workers", g_workers);
   p = Statusz(p, "accepts", g_accepts);
@@ -790,9 +905,8 @@ void *ListenWorker(void *arg) {
   struct Client client;
   struct timeval timeo = {g_keepalive / 1000, g_keepalive % 1000};
   struct sockaddr_in addr = {.sin_family = AF_INET, .sin_port = htons(g_port)};
-  AllowSigusr1();
   pthread_setname_np(pthread_self(), "Listener");
-  CHECK_NE(-1, (server = socket(AF_INET, SOCK_STREAM, 0)));
+  npassert((server = socket(AF_INET, SOCK_STREAM, 0)) != -1);
   setsockopt(server, SOL_SOCKET, SO_RCVTIMEO, &timeo, sizeof(timeo));
   setsockopt(server, SOL_SOCKET, SO_SNDTIMEO, &timeo, sizeof(timeo));
   setsockopt(server, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
@@ -801,8 +915,8 @@ void *ListenWorker(void *arg) {
   setsockopt(server, SOL_TCP, TCP_CORK, &no, sizeof(no));
   setsockopt(server, SOL_TCP, TCP_NODELAY, &yes, sizeof(yes));
   bind(server, (struct sockaddr *)&addr, sizeof(addr));
-  CHECK_NE(-1, listen(server, 1));
-  while (!nsync_note_is_notified(g_shutdown[0])) {
+  npassert(!listen(server, 1));
+  for (;;) {
     client.size = sizeof(client.addr);
     client.sock = accept(server, (struct sockaddr *)&client.addr, &client.size);
     if (client.sock == -1) {
@@ -814,6 +928,7 @@ void *ListenWorker(void *arg) {
     if (!AddClient(&g_clients, &client, WaitFor(ACCEPT_DEADLINE_MS))) {
       ++g_rejected;
       LOG("503 Accept Queue Full\n");
+      fcntl(client.sock, F_SETFL, fcntl(client.sock, F_GETFL) | O_NONBLOCK);
       Write(client.sock, "HTTP/1.1 503 Accept Queue Full\r\n"
                          "Content-Type: text/plain\r\n"
                          "Connection: close\r\n"
@@ -822,9 +937,18 @@ void *ListenWorker(void *arg) {
       close(client.sock);
     }
   }
-  close(server);
-  nsync_note_notify(g_shutdown[1]);
-  return 0;
+}
+
+void OnHttpWorkerCancel(void *arg) {
+  struct Worker *w = arg;
+  if (w->client->sock != -1)
+    close(w->client->sock);
+  FreeSafeBuffer(w->outbuf);
+  FreeSafeBuffer(w->inbuf);
+  DestroyHttpMessage(w->msg);
+  free(w->msgbuf);
+  --g_worker_threads;
+  w->dead = true;
 }
 
 // make thousands of http client handler threads
@@ -832,14 +956,26 @@ void *ListenWorker(void *arg) {
 // hangup on any browser clients that lag for more than a few seconds
 void *HttpWorker(void *arg) {
   struct Client client;
+  client.sock = -1;
   int id = (intptr_t)arg;
-  char *msgbuf = gc(xmalloc(MSG_BUF));
+  char *msgbuf = malloc(MSG_BUF);
   char *inbuf = NewSafeBuffer(INBUF_SIZE);
   char *outbuf = NewSafeBuffer(OUTBUF_SIZE);
-  struct HttpMessage *msg = gc(xcalloc(1, sizeof(struct HttpMessage)));
+  struct HttpMessage msg[1];
+  InitHttpMessage(msg, kHttpRequest);
 
-  BlockSignals();
-  pthread_setname_np(pthread_self(), gc(xasprintf("HTTP%d", id)));
+  g_worker[id].msgbuf = msgbuf;
+  g_worker[id].inbuf = inbuf;
+  g_worker[id].outbuf = outbuf;
+  g_worker[id].msg = msg;
+  g_worker[id].client = &client;
+  pthread_cleanup_push(OnHttpWorkerCancel, g_worker + id);
+
+  char name[32];
+  sprintf(name, "HTTP%d", id);
+  pthread_setname_np(pthread_self(), name);
+  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
+  ++g_worker_threads;
 
   // connection loop
   while (GetClient(&g_clients, &client)) {
@@ -866,12 +1002,14 @@ void *HttpWorker(void *arg) {
       bool comp, ipv6;
 
       // wait for http message
-      // this may be cancelled by sigusr1
-      AllowSigusr1();
-      DestroyHttpMessage(msg);
-      InitHttpMessage(msg, kHttpRequest);
+      ResetHttpMessage(msg, kHttpRequest);
       g_worker[id].startread = timespec_real();
-      if ((got = read(client.sock, inbuf, INBUF_SIZE)) <= 0) {
+      got = read(client.sock, inbuf, INBUF_SIZE - 1);
+      if (got >= 0) {
+        memcpy(last_message, inbuf, got);
+        last_message[got] = 0;
+      }
+      if (got <= 0) {
         ++g_readfails;
         break;
       }
@@ -891,9 +1029,7 @@ void *HttpWorker(void *arg) {
 
       // get client address from frontend
       if (HasHeader(kHttpXForwardedFor)) {
-        if (!IsLoopbackIp(clientip) &&  //
-            !IsPrivateIp(clientip) &&   //
-            !IsCloudflareIp(clientip)) {
+        if (!IsLoopbackIp(clientip) && !IsPrivateIp(clientip)) {
           LOG("Got X-Forwarded-For from untrusted IPv4 client address "
               "%hhu.%hhu.%hhu.%hhu\n",
               clientip >> 24, clientip >> 16, clientip >> 8, clientip);
@@ -920,9 +1056,6 @@ void *HttpWorker(void *arg) {
       ksnprintf(ipbuf, sizeof(ipbuf), "%hhu.%hhu.%hhu.%hhu", ip >> 24, ip >> 16,
                 ip >> 8, ip);
 
-      if (UrlStartsWith("/plot/") && (_rand64() % 256)) {
-        goto SkipSecurity;
-      }
       if (!ipv6 && !ContainsInt(&g_whitelisted, ip) &&
           (tok = AcquireToken(g_tok.b, ip, TB_CIDR)) < 32) {
         if (tok > 4) {
@@ -939,7 +1072,6 @@ void *HttpWorker(void *arg) {
         ++g_ratelimits;
         break;
       }
-    SkipSecurity:
 
       // we don't support http/1.0 and http/0.9 right now
       if (msg->version != 11) {
@@ -990,18 +1122,15 @@ void *HttpWorker(void *arg) {
         a = &g_asset.score;
       } else if (UrlStartsWith("/recent")) {
         a = &g_asset.recent;
-      } else if (UrlStartsWith("/plot/")) {
-        int i, block = 0;
-        for (i = msg->uri.a + 6; i < msg->uri.b && isdigit(inbuf[i]); ++i) {
-          block *= 10;
-          block += inbuf[i] - '0';
-          block &= 255;
-        }
-        a = g_asset.plot + block;
       } else {
         a = 0;
       }
 
+      // wait for server initialization
+      while (a)
+        if (a->ready)
+          break;
+
       // assert serving
       if (a) {
         struct iovec iov[2];
@@ -1009,7 +1138,7 @@ void *HttpWorker(void *arg) {
         comp = a->gzip.n < a->data.n &&
                HeaderHas(msg, inbuf, kHttpAcceptEncoding, "gzip", 4);
         ////////////////////////////////////////
-        nsync_mu_rlock(&a->lock);
+        pthread_rwlock_rdlock(&a->lock);
         if (HasHeader(kHttpIfModifiedSince) &&
             a->mtim.tv_sec <=
                 ParseHttpDateTime(HeaderData(kHttpIfModifiedSince),
@@ -1056,7 +1185,7 @@ void *HttpWorker(void *arg) {
           outmsglen = iov[0].iov_len + iov[1].iov_len;
           sent = writev(client.sock, iov, 2);
         }
-        nsync_mu_runlock(&a->lock);
+        pthread_rwlock_unlock(&a->lock);
         ////////////////////////////////////////
 
       } else if (UrlStartsWith("/ip")) {
@@ -1103,7 +1232,7 @@ void *HttpWorker(void *arg) {
         ++g_claimrequests;
         if (ipv6)
           goto Ipv6Warning;
-        struct Claim v = {.ip = ip, .created = g_nowish.ts.tv_sec};
+        struct Claim v = {.ip = ip, .created = timespec_real().tv_sec};
         if (GetNick(inbuf, msg, &v)) {
           if (AddClaim(&g_claims, &v,
                        timespec_add(timespec_real(),
@@ -1239,25 +1368,22 @@ void *HttpWorker(void *arg) {
       // amount, then since we sent the content length and checked
       // that the client didn't attach a payload, we are so synced
       // thus we can safely process more messages
-    } while (got == inmsglen &&                                //
-             sent == outmsglen &&                              //
-             !HasHeader(kHttpContentLength) &&                 //
-             !HasHeader(kHttpTransferEncoding) &&              //
-             !HeaderEqualCase(kHttpConnection, "close") &&     //
-             (msg->method == kHttpGet ||                       //
-              msg->method == kHttpHead) &&                     //
-             1. / g_workers * g_connections < CONCERN_LOAD &&  //
-             !nsync_note_is_notified(g_shutdown[1]));
+    } while (got == inmsglen &&                             //
+             sent == outmsglen &&                           //
+             !HasHeader(kHttpContentLength) &&              //
+             !HasHeader(kHttpTransferEncoding) &&           //
+             !HeaderEqualCase(kHttpConnection, "close") &&  //
+             (msg->method == kHttpGet ||                    //
+              msg->method == kHttpHead) &&                  //
+             1. / g_workers * g_connections < CONCERN_LOAD);
     DestroyHttpMessage(msg);
     close(client.sock);
+    client.sock = -1;
     g_worker[id].connected = false;
     --g_connections;
   }
 
-  LOG("HttpWorker #%d exiting", id);
-  g_worker[id].shutdown = true;
-  FreeSafeBuffer(outbuf);
-  FreeSafeBuffer(inbuf);
+  pthread_cleanup_pop(true);
   return 0;
 }
 
@@ -1283,8 +1409,8 @@ struct Data Gzip(struct Data data) {
     deflateEnd(&zs);
     return (struct Data){0};
   }
-  CHECK_EQ(Z_STREAM_END, deflate(&zs, Z_FINISH));
-  CHECK_EQ(Z_OK, deflateEnd(&zs));
+  npassert(Z_STREAM_END == deflate(&zs, Z_FINISH));
+  npassert(Z_OK == deflateEnd(&zs));
   res.n = sizeof(kGzipHeader) + zs.total_out + sizeof(footer);
   if (!(p = res.p = malloc(res.n))) {
     free(tmp);
@@ -1301,14 +1427,16 @@ struct Data Gzip(struct Data data) {
 struct Asset LoadAsset(const char *path, const char *type, int cash) {
   struct stat st;
   struct Asset a = {0};
-  CHECK_EQ(0, stat(path, &st));
-  CHECK_NOTNULL((a.data.p = xslurp(path, &a.data.n)));
+  pthread_rwlock_init(&a.lock, 0);
+  npassert(!stat(path, &st));
+  npassert((a.data.p = xslurp(path, &a.data.n)));
   a.type = type;
   a.cash = cash;
-  CHECK_NOTNULL((a.path = strdup(path)));
+  unassert((a.path = strdup(path)));
   a.mtim = st.st_mtim;
-  CHECK_NOTNULL((a.gzip = Gzip(a.data)).p);
+  unassert((a.gzip = Gzip(a.data)).p);
   FormatUnixHttpDateTime(a.lastmodified, a.mtim.tv_sec);
+  a.ready = true;
   return a;
 }
 
@@ -1332,15 +1460,16 @@ bool ReloadAsset(struct Asset *a) {
       goto OnError;
     CHECK_MEM((gzip = Gzip(data)).p);
     //!//!//!//!//!//!//!//!//!//!//!//!//!/
-    nsync_mu_lock(&a->lock);
+    pthread_rwlock_wrlock(&a->lock);
     f[0] = a->data.p;
     f[1] = a->gzip.p;
     a->data = data;
     a->gzip = gzip;
     a->mtim = st.st_mtim;
     memcpy(a->lastmodified, lastmodified, 32);
-    nsync_mu_unlock(&a->lock);
+    pthread_rwlock_unlock(&a->lock);
     //!//!//!//!//!//!//!//!//!//!//!//!//!/
+    a->ready = true;
     free(f[0]);
     free(f[1]);
   }
@@ -1354,34 +1483,14 @@ OnError:
 }
 
 void FreeAsset(struct Asset *a) {
+  pthread_rwlock_destroy(&a->lock);
   free(a->path);
   free(a->data.p);
   free(a->gzip.p);
 }
 
-void IgnoreSignal(int sig) {
-  // so worker i/o routines may eintr safely
-}
-
-// asynchronous handler of sigint, sigterm, and sighup signals
-// this handler is always invoked from within the main thread,
-// because our helper and worker threads always block signals.
 void OnCtrlC(int sig) {
-  if (!nsync_note_is_notified(g_shutdown[0])) {
-    LOG("Received %s shutting down...\n", strsignal(sig));
-    nsync_note_notify(g_shutdown[0]);
-  } else {
-    // there's no way to deliver signals to workers atomically, unless
-    // we pay the cost of ppoll() which isn't necessary in this design
-    // so if a user smashes that ctrl-c then we tkill the workers more
-    LOG("Received %s again so sending another volley...\n", strsignal(sig));
-    for (int i = 0; i < g_workers; ++i) {
-      pthread_kill(g_listener, SIGUSR1);
-      if (!g_worker[i].shutdown) {
-        pthread_kill(g_worker[i].th, SIGUSR1);
-      }
-    }
-  }
+  is_shutting_down = 1;
 }
 
 // parses cli arguments
@@ -1433,9 +1542,10 @@ void Update(struct Asset *a, bool gen(struct Asset *, long, long), long x,
             long y) {
   void *f[2];
   struct Asset t;
+  pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
   if (gen(&t, x, y)) {
     //!//!//!//!//!//!//!//!//!//!//!//!//!/
-    nsync_mu_lock(&a->lock);
+    pthread_rwlock_wrlock(&a->lock);
     f[0] = a->data.p;
     f[1] = a->gzip.p;
     a->data = t.data;
@@ -1444,11 +1554,13 @@ void Update(struct Asset *a, bool gen(struct Asset *, long, long), long x,
     a->type = t.type;
     a->cash = t.cash;
     memcpy(a->lastmodified, t.lastmodified, 32);
-    nsync_mu_unlock(&a->lock);
+    pthread_rwlock_unlock(&a->lock);
     //!//!//!//!//!//!//!//!//!//!//!//!//!/
+    a->ready = true;
     free(f[0]);
     free(f[1]);
   }
+  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
 }
 
 // generator function for the big board
@@ -1529,182 +1641,74 @@ OnError:
   return false;
 }
 
-// generator function for the big board
-bool GeneratePlot(struct Asset *out, long block, long cash) {
-  _Static_assert(IS2POW(XN * YN), "area must be 2-power");
-  _Static_assert(XN == YN, "hilbert algorithm needs square");
-  int rc, out_len;
-  sqlite3 *db = 0;
-  struct Asset a = {0};
-  unsigned char *rgba;
-  sqlite3_stmt *stmt = 0;
-  unsigned x, y, i, ip, area, mask, clump;
-  DEBUG("GeneratePlot %ld\n", block);
-  a.type = "image/png";
-  a.cash = cash;
-  a.mtim = timespec_real();
-  FormatUnixHttpDateTime(a.lastmodified, a.mtim.tv_sec);
-  CHECK_MEM((rgba = calloc(4, YN * XN)));
-  for (y = 0; y < YN; ++y) {
-    for (x = 0; x < XN; ++x) {
-      rgba[y * XN * 4 + x * 4 + 0] = 255;
-      rgba[y * XN * 4 + x * 4 + 1] = 255;
-      rgba[y * XN * 4 + x * 4 + 2] = 255;
-    }
-  }
-  CHECK_SQL(DbOpen("db.sqlite3", &db));
-  CHECK_DB(DbPrepare(db, &stmt,
-                     "SELECT ip\n"
-                     " FROM land\n"
-                     "WHERE ip >= ?1\n"
-                     "  AND ip <= ?2"));
-  CHECK_DB(sqlite3_bind_int64(stmt, 1, block << 24 | 0x000000));
-  CHECK_DB(sqlite3_bind_int64(stmt, 2, block << 24 | 0xffffff));
-  CHECK_SQL(sqlite3_exec(db, "BEGIN TRANSACTION", 0, 0, 0));
-  area = XN * YN;
-  mask = area - 1;
-  clump = 32 - bsr(area) - 8;
-  while ((rc = DbStep(stmt)) != SQLITE_DONE) {
-    if (rc != SQLITE_ROW)
-      CHECK_DB(rc);
-    ip = sqlite3_column_int64(stmt, 0);
-    i = (ip >> clump) & mask;
-    y = g_hilbert[i][0];
-    x = g_hilbert[i][1];
-    if (rgba[y * XN * 4 + x * 4 + 3] < 255) {
-      ++rgba[y * XN * 4 + x * 4 + 3];
-    }
-  }
-  CHECK_SQL(sqlite3_exec(db, "END TRANSACTION", 0, 0, 0));
-  CHECK_DB(sqlite3_finalize(stmt));
-  CHECK_SQL(sqlite3_close(db));
-  a.data.p = (char *)stbi_write_png_to_mem(rgba, XN * 4, XN, YN, 4, &out_len);
-  a.data.n = out_len;
-  a.gzip = Gzip(a.data);
-  free(rgba);
-  *out = a;
-  return true;
-OnError:
-  sqlite3_finalize(stmt);
-  sqlite3_close(db);
-  free(a.data.p);
-  free(rgba);
-  return false;
-}
-
 // single thread for regenerating the user scores json
 void *ScoreWorker(void *arg) {
-  BlockSignals();
   pthread_setname_np(pthread_self(), "ScoreAll");
-  LOG("%P Score started\n");
-  long wait = SCORE_UPDATE_MS;
-  Update(&g_asset.score, GenerateScore, -1, MS2CASH(wait));
-  nsync_counter_add(g_ready, -1);  // #1
-  do {
-    Update(&g_asset.score, GenerateScore, -1, MS2CASH(wait));
-  } while (!nsync_note_wait(g_shutdown[1], WaitFor(wait)));
-  LOG("Score exiting\n");
-  return 0;
+  for (;;) {
+    LOG("%H regenerating score...\n");
+    Update(&g_asset.score, GenerateScore, -1, MS2CASH(SCORE_UPDATE_MS));
+    usleep(SCORE_UPDATE_MS * 1000);
+  }
 }
 
 // single thread for regenerating the user scores json
 void *ScoreHourWorker(void *arg) {
-  BlockSignals();
   pthread_setname_np(pthread_self(), "ScoreHour");
-  LOG("%P ScoreHour started\n");
-  long secs = 60L * 60;
-  long wait = SCORE_H_UPDATE_MS;
-  Update(&g_asset.score_hour, GenerateScore, secs, MS2CASH(wait));
-  nsync_counter_add(g_ready, -1);  // #2
-  do {
-    Update(&g_asset.score_hour, GenerateScore, secs, MS2CASH(wait));
-  } while (!nsync_note_wait(g_shutdown[1], WaitFor(wait)));
-  LOG("ScoreHour exiting\n");
-  return 0;
+  for (;;) {
+    LOG("%H regenerating hour score...\n");
+    Update(&g_asset.score_hour, GenerateScore, 60L * 60,
+           MS2CASH(SCORE_H_UPDATE_MS));
+    usleep(SCORE_H_UPDATE_MS * 1000);
+  }
 }
 
 // single thread for regenerating the user scores json
 void *ScoreDayWorker(void *arg) {
-  BlockSignals();
   pthread_setname_np(pthread_self(), "ScoreDay");
-  LOG("%P ScoreDay started\n");
-  long secs = 60L * 60 * 24;
-  long wait = SCORE_D_UPDATE_MS;
-  Update(&g_asset.score_day, GenerateScore, secs, MS2CASH(wait));
-  nsync_counter_add(g_ready, -1);  // #3
-  do {
-    Update(&g_asset.score_day, GenerateScore, secs, MS2CASH(wait));
-  } while (!nsync_note_wait(g_shutdown[1], WaitFor(wait)));
-  LOG("ScoreDay exiting\n");
-  return 0;
+  for (;;) {
+    LOG("%H regenerating day score...\n");
+    Update(&g_asset.score_day, GenerateScore, 60L * 60 * 24,
+           MS2CASH(SCORE_D_UPDATE_MS));
+    usleep(SCORE_D_UPDATE_MS * 1000);
+  }
 }
 
 // single thread for regenerating the user scores json
 void *ScoreWeekWorker(void *arg) {
-  BlockSignals();
   pthread_setname_np(pthread_self(), "ScoreWeek");
-  LOG("%P ScoreWeek started\n");
-  long secs = 60L * 60 * 24 * 7;
-  long wait = SCORE_W_UPDATE_MS;
-  Update(&g_asset.score_week, GenerateScore, secs, MS2CASH(wait));
-  nsync_counter_add(g_ready, -1);  // #4
-  do {
-    Update(&g_asset.score_week, GenerateScore, secs, MS2CASH(wait));
-  } while (!nsync_note_wait(g_shutdown[1], WaitFor(wait)));
-  LOG("ScoreWeek exiting\n");
-  return 0;
+  for (;;) {
+    LOG("%H regenerating week score...\n");
+    Update(&g_asset.score_week, GenerateScore, 60L * 60 * 24 * 7,
+           MS2CASH(SCORE_W_UPDATE_MS));
+    usleep(SCORE_W_UPDATE_MS * 1000);
+  }
 }
 
 // single thread for regenerating the user scores json
 void *ScoreMonthWorker(void *arg) {
-  BlockSignals();
   pthread_setname_np(pthread_self(), "ScoreMonth");
-  LOG("%P ScoreMonth started\n");
-  long secs = 60L * 60 * 24 * 30;
-  long wait = SCORE_M_UPDATE_MS;
-  Update(&g_asset.score_month, GenerateScore, secs, MS2CASH(wait));
-  nsync_counter_add(g_ready, -1);  // #5
-  do {
-    Update(&g_asset.score_month, GenerateScore, secs, MS2CASH(wait));
-  } while (!nsync_note_wait(g_shutdown[1], WaitFor(wait)));
-  LOG("ScoreMonth exiting\n");
-  return 0;
-}
-
-// single thread for regenerating /8 cell background image charts
-void *PlotWorker(void *arg) {
-  long i, wait;
-  BlockSignals();
-  pthread_setname_np(pthread_self(), "Plotter");
-  LOG("%P Plotter started\n");
-  wait = PLOTS_UPDATE_MS;
-  for (i = 0; i < 256; ++i) {
-    Update(g_asset.plot + i, GeneratePlot, i, MS2CASH(wait));
+  for (;;) {
+    LOG("%H regenerating month score...\n");
+    Update(&g_asset.score_month, GenerateScore, 60L * 60 * 24 * 30,
+           MS2CASH(SCORE_M_UPDATE_MS));
+    usleep(SCORE_M_UPDATE_MS * 1000);
   }
-  nsync_counter_add(g_ready, -1);  // #6
-  do {
-    for (i = 0; i < 256; ++i) {
-      Update(g_asset.plot + i, GeneratePlot, i, MS2CASH(wait));
-    }
-  } while (!nsync_note_wait(g_shutdown[1], WaitFor(wait)));
-  LOG("Plotter exiting\n");
-  return 0;
 }
 
 // thread for realtime json generation of recent successful claims
 void *RecentWorker(void *arg) {
+  int rc;
   bool once;
   void *f[2];
-  int rc, err;
   sqlite3 *db;
   char *sb = 0;
   size_t sblen = 0;
+  const char *text;
   sqlite3_stmt *stmt;
   struct Asset *a, t;
-  bool warmedup = false;
-  BlockSignals();
+  sleep(2);
   pthread_setname_np(pthread_self(), "RecentWorker");
-  LOG("%P RecentWorker started\n");
+  pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
 StartOver:
   db = 0;
   stmt = 0;
@@ -1716,7 +1720,7 @@ StartOver:
                      "WHERE created NOT NULL\n"
                      "ORDER BY created DESC\n"
                      "LIMIT 50"));
-  do {
+  for (;;) {
     // regenerate json
     t.mtim = timespec_real();
     FormatUnixHttpDateTime(t.lastmodified, t.mtim.tv_sec);
@@ -1728,13 +1732,14 @@ StartOver:
     for (once = false; (rc = DbStep(stmt)) != SQLITE_DONE; once = true) {
       if (rc != SQLITE_ROW)
         CHECK_SQL(rc);
-      if (once)
-        CHECK_SYS(appends(&t.data.p, ",\n"));
-      CHECK_SYS(
-          appendf(&t.data.p, "[%ld,\"%s\",%ld]", sqlite3_column_int64(stmt, 0),
-                  EscapeJsStringLiteral(
-                      &sb, &sblen, (void *)sqlite3_column_text(stmt, 1), -1, 0),
-                  sqlite3_column_int64(stmt, 2)));
+      if ((text = (const char *)sqlite3_column_text(stmt, 1))) {
+        if (once)
+          CHECK_SYS(appends(&t.data.p, ",\n"));
+        CHECK_SYS(appendf(&t.data.p, "[%ld,\"%s\",%ld]",
+                          sqlite3_column_int64(stmt, 0),
+                          EscapeJsStringLiteral(&sb, &sblen, text, -1, 0),
+                          sqlite3_column_int64(stmt, 2)));
+      }
     }
     CHECK_SQL(sqlite3_reset(stmt));
     CHECK_SQL(sqlite3_exec(db, "END TRANSACTION", 0, 0, 0));
@@ -1744,7 +1749,7 @@ StartOver:
     // deploy json
     a = &g_asset.recent;
     //!//!//!//!//!//!//!//!//!//!//!//!//!/
-    nsync_mu_lock(&a->lock);
+    pthread_rwlock_wrlock(&a->lock);
     f[0] = a->data.p;
     f[1] = a->gzip.p;
     a->data = t.data;
@@ -1753,25 +1758,22 @@ StartOver:
     a->type = "application/json";
     a->cash = 0;
     memcpy(a->lastmodified, t.lastmodified, 32);
-    nsync_mu_unlock(&a->lock);
+    pthread_rwlock_unlock(&a->lock);
     //!//!//!//!//!//!//!//!//!//!//!//!//!/
+    a->ready = true;
     bzero(&t, sizeof(t));
     free(f[0]);
     free(f[1]);
-    // handle startup condition
-    if (!warmedup) {
-      nsync_counter_add(g_ready, -1);  // #7
-      warmedup = true;
-    }
     // wait for wakeup or cancel
-    nsync_mu_lock(&g_recent.mu);
-    err = nsync_cv_wait_with_deadline(&g_recent.cv, &g_recent.mu,
-                                      nsync_time_no_deadline, g_shutdown[1]);
-    nsync_mu_unlock(&g_recent.mu);
-  } while (err != ECANCELED);
+    pthread_mutex_lock(&g_recent.mu);
+    pthread_cleanup_push(unlock_mutex, &g_recent.mu);
+    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
+    pthread_cond_timedwait(&g_recent.cv, &g_recent.mu, 0);
+    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
+    pthread_cleanup_pop(true);
+  }
   CHECK_DB(sqlite3_finalize(stmt));
   CHECK_SQL(sqlite3_close(db));
-  LOG("RecentWorker exiting\n");
   free(sb);
   return 0;
 OnError:
@@ -1789,11 +1791,9 @@ void *ClaimWorker(void *arg) {
   int i, n, rc;
   long processed;
   sqlite3_stmt *stmt;
-  bool warmedup = false;
-  struct Claim *v = gc(xcalloc(BATCH_MAX, sizeof(struct Claim)));
-  BlockSignals();
+  struct Claim *v = gc(calloc(BATCH_MAX, sizeof(struct Claim)));
+  pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0);
   pthread_setname_np(pthread_self(), "ClaimWorker");
-  LOG("%P ClaimWorker started\n");
 StartOver:
   db = 0;
   stmt = 0;
@@ -1806,10 +1806,6 @@ StartOver:
                      " WHERE nick != ?2\n"
                      "    OR created IS NULL\n"
                      "    OR ?3 - created > 3600"));
-  if (!warmedup) {
-    nsync_counter_add(g_ready, -1);  // #8
-    warmedup = true;
-  }
   while ((n = GetClaims(&g_claims, v, BATCH_MAX))) {
     processed = 0;
     CHECK_SQL(sqlite3_exec(db, "BEGIN TRANSACTION", 0, 0, 0));
@@ -1825,13 +1821,12 @@ StartOver:
     atomic_fetch_add(&g_claimsprocessed, processed);
     DEBUG("Committed %d claims\n", n);
     // wake up RecentWorker()
-    nsync_mu_lock(&g_recent.mu);
-    nsync_cv_signal(&g_recent.cv);
-    nsync_mu_unlock(&g_recent.mu);
+    pthread_mutex_lock(&g_recent.mu);
+    pthread_cond_signal(&g_recent.cv);
+    pthread_mutex_unlock(&g_recent.mu);
   }
   CHECK_DB(sqlite3_finalize(stmt));
   CHECK_SQL(sqlite3_close(db));
-  LOG("ClaimWorker exiting\n");
   return 0;
 OnError:
   sqlite3_finalize(stmt);
@@ -1839,40 +1834,36 @@ OnError:
   goto StartOver;
 }
 
-// single thread for computing HTTP Date header
-void *NowWorker(void *arg) {
-  BlockSignals();
-  pthread_setname_np(pthread_self(), "NowWorker");
-  LOG("%P NowWorker started\n");
-  UpdateNow();
-  nsync_counter_add(g_ready, -1);  // #9
-  for (struct timespec ts = {timespec_real().tv_sec};; ++ts.tv_sec) {
-    if (!nsync_note_wait(g_shutdown[1], ts)) {
-      UpdateNow();
-    } else {
-      break;
-    }
-  }
-  LOG("NowWorker exiting\n");
-  return 0;
-}
-
 // worker for refilling token buckets
 void *ReplenishWorker(void *arg) {
-  BlockSignals();
+  pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0);
   pthread_setname_np(pthread_self(), "Replenisher");
-  LOG("%P Replenisher started\n");
-  UpdateNow();
   for (struct timespec ts = timespec_real();;
        ts = timespec_add(ts, timespec_frommillis(TB_INTERVAL))) {
-    if (!nsync_note_wait(g_shutdown[1], ts)) {
-      ReplenishTokens(g_tok.w, TB_WORDS);
-    } else {
-      break;
-    }
+    clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &ts, 0);
+    ReplenishTokens(g_tok.w, TB_WORDS);
   }
-  LOG("Replenisher exiting\n");
-  return 0;
+}
+
+void SpawnWorker(intptr_t i) {
+  sigset_t thmask;
+  pthread_attr_t attr;
+  sigfillset(&thmask);
+  sigdelset(&thmask, SIGABRT);
+  sigdelset(&thmask, SIGTRAP);
+  sigdelset(&thmask, SIGFPE);
+  sigdelset(&thmask, SIGBUS);
+  sigdelset(&thmask, SIGSEGV);
+  sigdelset(&thmask, SIGILL);
+  sigdelset(&thmask, SIGXCPU);
+  sigdelset(&thmask, SIGXFSZ);
+  pthread_attr_init(&attr);
+  pthread_attr_setsigmask_np(&attr, &thmask);
+  pthread_attr_setstacksize(&attr, 128 * 1024);
+  pthread_attr_setguardsize(&attr, sysconf(_SC_PAGESIZE));
+  pthread_attr_setsigaltstacksize_np(&attr, sysconf(_SC_MINSIGSTKSZ) + 32768);
+  pthread_create(&g_worker[i].th, &attr, HttpWorker, (void *)i);
+  pthread_attr_destroy(&attr);
 }
 
 // we're permissive in allowing http connection keepalive until the
@@ -1883,7 +1874,7 @@ void Meltdown(void) {
   int i, marks;
   struct timespec now;
   ++g_meltdowns;
-  LOG("Panicking because %d out of %d workers is connected\n", g_connections,
+  LOG("%H panicking because %d out of %d workers is connected\n", g_connections,
       g_workers);
   now = timespec_real();
   for (marks = i = 0; i < g_workers; ++i) {
@@ -1891,7 +1882,9 @@ void Meltdown(void) {
         (g_worker[i].msgcount > PANIC_MSGS ||
          timespec_cmp(timespec_sub(now, g_worker[i].startread),
                       timespec_frommillis(MELTALIVE_MS)) >= 0)) {
-      pthread_kill(g_worker[i].th, SIGUSR1);
+      pthread_cancel(g_worker[i].th);
+      pthread_join(g_worker[i].th, 0);
+      SpawnWorker(i);
       ++marks;
     }
   }
@@ -1900,18 +1893,29 @@ void Meltdown(void) {
 
 // main thread worker
 void *Supervisor(void *arg) {
-  for (;;) {
-    if (!nsync_note_wait(g_shutdown[0], WaitFor(SUPERVISE_MS))) {
-      if (g_workers > 1 && 1. / g_workers * g_connections > PANIC_LOAD) {
-        Meltdown();
+  while (!is_shutting_down) {
+
+    // check for updates to web assets on disk
+    ReloadAsset(&g_asset.index);
+    ReloadAsset(&g_asset.about);
+    ReloadAsset(&g_asset.user);
+    ReloadAsset(&g_asset.favicon);
+
+    // check if server is about to explode
+    if (g_workers > 1 && 1. / g_workers * g_connections > PANIC_LOAD)
+      Meltdown();
+
+    // spawn replacements for crashed workers
+    for (int i = 0; i < g_workers; ++i) {
+      if (g_worker[i].dead) {
+        pthread_join(g_worker[i].th, 0);
+        SpawnWorker(i);
       }
-      ReloadAsset(&g_asset.index);
-      ReloadAsset(&g_asset.about);
-      ReloadAsset(&g_asset.user);
-      ReloadAsset(&g_asset.favicon);
-    } else {
-      break;
     }
+
+    // wait a little bit
+    if (!is_shutting_down)
+      usleep(SUPERVISE_MS * 1000);
   }
   return 0;
 }
@@ -1920,9 +1924,9 @@ void CheckDatabase(void) {
   sqlite3 *db;
   if (g_integrity) {
     CHECK_SQL(DbOpen("db.sqlite3", &db));
-    LOG("Checking database integrity...\n");
+    LOG("%H Checking database integrity...\n");
     CHECK_SQL(sqlite3_exec(db, "PRAGMA integrity_check", 0, 0, 0));
-    LOG("Vacuuming database...\n");
+    LOG("%H Vacuuming database...\n");
     CHECK_SQL(sqlite3_exec(db, "VACUUM", 0, 0, 0));
     CHECK_SQL(sqlite3_close(db));
   }
@@ -1931,8 +1935,159 @@ OnError:
   exit(1);
 }
 
+char *hexcpy(char *p, unsigned long x) {
+  int k = x ? (__builtin_clzl(x) ^ 63) + 1 : 1;
+  k = (k + 3) & -4;
+  while (k > 0)
+    *p++ = "0123456789abcdef"[(x >> (k -= 4)) & 15];
+  *p = '\0';
+  return p;
+}
+
+char *describe_backtrace(char *p, size_t len, const struct StackFrame *sf) {
+  char *pe = p + len;
+  bool gotsome = false;
+
+  // show address of each function
+  while (sf) {
+    if (kisdangerous(sf)) {
+      if (p + 1 + 9 + 1 < pe) {
+        if (gotsome)
+          *p++ = ' ';
+        p = stpcpy(p, "DANGEROUS");
+        if (p + 16 + 1 < pe) {
+          *p++ = ' ';
+          p = hexcpy(p, (long)sf);
+        }
+      }
+      break;
+    }
+    if (p + 16 + 1 < pe) {
+      unsigned char *ip = (unsigned char *)sf->addr;
+#ifdef __x86_64__
+      // x86 advances the progrem counter before an instruction
+      // begins executing. return addresses in backtraces shall
+      // point to code after the call, which means addr2line is
+      // going to print unrelated code unless we fixup the addr
+      if (!kisdangerous(ip))
+        ip -= __is_call(ip);
+#endif
+      if (gotsome)
+        *p++ = ' ';
+      else
+        gotsome = true;
+      p = hexcpy(p, (long)ip);
+    } else {
+      break;
+    }
+    sf = sf->next;
+  }
+
+  // terminate string
+  if (p < pe)
+    *p = '\0';
+  return p;
+}
+
+//                         abashed the devil stood
+//                      and felt how awful goodness is
+char *describe_crash(char *buf, size_t len, int sig, siginfo_t *si, void *arg) {
+  char *p = buf;
+
+  // check minimum length
+  if (len < 64)
+    return p;
+
+  // describe crash
+  char signame[21];
+  p = stpcpy(p, strsignal_r(sig, signame));
+  if (si &&               //
+      (sig == SIGFPE ||   //
+       sig == SIGILL ||   //
+       sig == SIGBUS ||   //
+       sig == SIGSEGV ||  //
+       sig == SIGTRAP)) {
+    p = stpcpy(p, " at ");
+    p = hexcpy(p, (long)si->si_addr);
+  }
+
+  // get stack frame daisy chain
+  struct StackFrame pc;
+  struct StackFrame *sf;
+  ucontext_t *ctx;
+  if ((ctx = (ucontext_t *)arg)) {
+    pc.addr = ctx->uc_mcontext.PC;
+    pc.next = (struct StackFrame *)ctx->uc_mcontext.BP;
+    sf = &pc;
+  } else {
+    sf = (struct StackFrame *)__builtin_frame_address(0);
+  }
+
+  // describe backtrace
+  p = stpcpy(p, " bt ");
+  p = describe_backtrace(p, len - (p - buf), sf);
+
+  return p;
+}
+
+void on_crash_signal(int sig, siginfo_t *si, void *arg) {
+  char *p;
+  char message[512];
+  write(2, "crash!\n", 7);
+  p = describe_crash(message, sizeof(message), sig, si, arg);
+  write(g_crash_fd, "crash: ", 7);
+  write(g_crash_fd, message, p - message);
+  write(g_crash_fd, "\n", 1);
+  write(g_crash_fd, last_message, strlen(last_message));
+  write(g_crash_fd, "\n", 1);
+  pthread_exit(PTHREAD_CANCELED);
+}
+
+void make_server_crash_resistant(void) {
+  const char *path = "crash.log";
+  if ((g_crash_fd = open(path, O_CREAT | O_WRONLY | O_APPEND, 0644)) == -1) {
+    fprintf(stderr, "%s: %s\n", path, strerror(errno));
+    exit(1);
+  }
+
+  struct sigaction sa;
+  sa.sa_flags = SA_SIGINFO;
+  sigemptyset(&sa.sa_mask);
+
+  sa.sa_sigaction = on_crash_signal;
+  sigaddset(&sa.sa_mask, SIGABRT);
+  sigaddset(&sa.sa_mask, SIGTRAP);
+  sigaddset(&sa.sa_mask, SIGFPE);
+  sigaddset(&sa.sa_mask, SIGBUS);
+  sigaddset(&sa.sa_mask, SIGSEGV);
+  sigaddset(&sa.sa_mask, SIGILL);
+  sigaddset(&sa.sa_mask, SIGXCPU);
+  sigaddset(&sa.sa_mask, SIGXFSZ);
+
+  sigaction(SIGABRT, &sa, 0);
+  sigaction(SIGTRAP, &sa, 0);
+  sigaction(SIGFPE, &sa, 0);
+  sigaction(SIGILL, &sa, 0);
+  sigaction(SIGXCPU, &sa, 0);
+  sigaction(SIGXFSZ, &sa, 0);
+
+  sa.sa_flags |= SA_ONSTACK;
+  sigaction(SIGBUS, &sa, 0);
+  sigaction(SIGSEGV, &sa, 0);
+}
+
 int main(int argc, char *argv[]) {
-  // ShowCrashReports();
+  make_server_crash_resistant();
+
+  if (pledge(0, 0)) {
+    fprintf(stderr, "%s: this OS doesn't support pledge() security\n", argv[0]);
+    exit(1);
+  }
+
+  if (unveil("", 0) < 2) {
+    fprintf(stderr, "%s: need OpenBSD or Landlock LSM v3+\n", argv[0]);
+    exit(1);
+  }
 
   if (IsLinux()) {
     Write(2, "Enabling TCP_FASTOPEN for server sockets...\n");
@@ -1952,7 +2107,7 @@ int main(int argc, char *argv[]) {
  __| |   |  __| | \\ \\  \\   / _` |  __|\n\
  |   |   | |    __|\\ \\  \\ / (   | |\n\
 \\__|\\__,_|_|   _|   \\_/\\_/ \\__,_|_|\n");
-  CHECK_EQ(0, chdir("/opt/turfwar"));
+  npassert(!chdir("/opt/turfwar"));
   putenv("TMPDIR=/opt/turfwar/tmp");
 
   if ((g_blackhole.fd = socket(AF_UNIX, SOCK_DGRAM, 0)) == -1) {
@@ -1980,13 +2135,6 @@ int main(int argc, char *argv[]) {
     npassert(2 == open("turfwar.log", O_CREAT | O_WRONLY | O_APPEND, 0644));
   }
 
-  LOG("Generating Hilbert Curve...\n");
-  for (int i = 0; i < YN * XN; ++i) {
-    axdx_t h = unhilbert(XN, i);
-    g_hilbert[i][0] = h.ax;
-    g_hilbert[i][1] = h.dx;
-  }
-
   // library init
   sqlite3_initialize();
   CheckDatabase();
@@ -1997,9 +2145,6 @@ int main(int argc, char *argv[]) {
 
   // server lifecycle locks
   g_started = timespec_real();
-  for (int i = 0; i < ARRAYLEN(g_shutdown); ++i) {
-    g_shutdown[i] = nsync_note_new(0, nsync_time_no_deadline);
-  }
 
   // load static assets into memory and pre-zip them
   g_asset.index = LoadAsset("index.html", "text/html; charset=utf-8", 900);
@@ -2009,11 +2154,11 @@ int main(int argc, char *argv[]) {
 
   // sandbox ourselves
   __pledge_mode = PLEDGE_PENALTY_RETURN_EPERM;
-  CHECK_EQ(0, unveil("/opt/turfwar", "rwc"));
-  CHECK_EQ(0, unveil(0, 0));
+  npassert(!unveil("/opt/turfwar", "rwc"));
+  npassert(!unveil(0, 0));
   if (!IsOpenbsd()) {
     // TODO(jart): why isn't pledge working on openbsd?
-    CHECK_EQ(0, pledge("stdio flock rpath wpath cpath inet", 0));
+    npassert(!pledge("stdio flock rpath wpath cpath inet", 0));
   }
 
   // shutdown signals
@@ -2024,83 +2169,89 @@ int main(int argc, char *argv[]) {
   sigaction(SIGHUP, &sa, 0);
   sigaction(SIGINT, &sa, 0);
   sigaction(SIGTERM, &sa, 0);
-  sa.sa_handler = IgnoreSignal;
-  sigaction(SIGUSR1, &sa, 0);
 
-  // make 9 helper threads
-  g_ready = nsync_counter_new(10);
-  pthread_t scorer, recenter, claimer, nower, replenisher, plotter;
-  pthread_t scorer_hour, scorer_day, scorer_week, scorer_month;
-  CHECK_EQ(0, pthread_create(&scorer, 0, ScoreWorker, 0));
-  CHECK_EQ(0, pthread_create(&scorer_hour, 0, ScoreHourWorker, 0));
-  CHECK_EQ(0, pthread_create(&scorer_day, 0, ScoreDayWorker, 0));
-  CHECK_EQ(0, pthread_create(&scorer_week, 0, ScoreWeekWorker, 0));
-  CHECK_EQ(0, pthread_create(&scorer_month, 0, ScoreMonthWorker, 0));
-  CHECK_EQ(0, pthread_create(&replenisher, 0, ReplenishWorker, 0));
-  CHECK_EQ(0, pthread_create(&recenter, 0, RecentWorker, 0));
-  CHECK_EQ(0, pthread_create(&claimer, 0, ClaimWorker, 0));
-  CHECK_EQ(0, pthread_create(&plotter, 0, PlotWorker, 0));
-  CHECK_EQ(0, pthread_create(&nower, 0, NowWorker, 0));
+  time_init();
 
-  // wait for helper threads to warm up creating assets
-  if (nsync_counter_add(g_ready, -1)) {  // #10
-    nsync_counter_wait(g_ready, nsync_time_no_deadline);
-  }
+  sigset_t thmask;
+  sigfillset(&thmask);
+  sigdelset(&thmask, SIGABRT);
+  sigdelset(&thmask, SIGTRAP);
+  sigdelset(&thmask, SIGFPE);
+  sigdelset(&thmask, SIGBUS);
+  sigdelset(&thmask, SIGSEGV);
+  sigdelset(&thmask, SIGILL);
+  sigdelset(&thmask, SIGXCPU);
+  sigdelset(&thmask, SIGXFSZ);
 
-  // create one thread to listen
-  CHECK_EQ(0, pthread_create(&g_listener, 0, ListenWorker, 0));
-
-  // create lots of http workers to serve those assets
-  LOG("Online\n");
-  g_worker = xcalloc(g_workers, sizeof(*g_worker));
-  for (intptr_t i = 0; i < g_workers; ++i) {
-    CHECK_EQ(0, pthread_create(&g_worker[i].th, 0, HttpWorker, (void *)i));
-  }
+  pthread_attr_t attr;
+  pthread_attr_init(&attr);
+  pthread_attr_setsigmask_np(&attr, &thmask);
+  pthread_attr_setstacksize(&attr, 128 * 1024);
+  pthread_attr_setguardsize(&attr, sysconf(_SC_PAGESIZE));
+  pthread_attr_setsigaltstacksize_np(&attr, sysconf(_SC_MINSIGSTKSZ) + 32768);
+  npassert(!pthread_create(&scorer, &attr, ScoreWorker, 0));
+  npassert(!pthread_create(&scorer_hour, &attr, ScoreHourWorker, 0));
+  npassert(!pthread_create(&scorer_day, &attr, ScoreDayWorker, 0));
+  npassert(!pthread_create(&scorer_week, &attr, ScoreWeekWorker, 0));
+  npassert(!pthread_create(&scorer_month, &attr, ScoreMonthWorker, 0));
+  npassert(!pthread_create(&replenisher, &attr, ReplenishWorker, 0));
+  npassert(!pthread_create(&recenter, &attr, RecentWorker, 0));
+  npassert(!pthread_create(&claimer, &attr, ClaimWorker, 0));
+  npassert(!pthread_create(&g_listener, &attr, ListenWorker, 0));
+  unassert((g_worker = calloc(g_workers, sizeof(*g_worker))));
+  for (intptr_t i = 0; i < g_workers; ++i)
+    npassert(!pthread_create(&g_worker[i].th, &attr, HttpWorker, (void *)i));
+  pthread_attr_destroy(&attr);
 
   // time to serve
-  LOG("Ready\n");
+  LOG("%H ready\n");
   Supervisor(0);
 
-  // cancel listen() so we stop accepting new clients
-  LOG("Interrupting listen...\n");
-  pthread_kill(g_listener, SIGUSR1);
-  pthread_join(g_listener, 0);
+  // cancel listen()
+  LOG("%H interrupting services...\n");
+  pthread_cancel(scorer);
+  pthread_cancel(recenter);
+  pthread_cancel(g_listener);
+  pthread_cancel(scorer_day);
+  pthread_cancel(scorer_hour);
+  pthread_cancel(scorer_week);
+  pthread_cancel(scorer_month);
+  pthread_cancel(replenisher);
+
+  LOG("%H joining services...\n");
+  unassert(!pthread_join(scorer, 0));
+  unassert(!pthread_join(recenter, 0));
+  unassert(!pthread_join(g_listener, 0));
+  unassert(!pthread_join(scorer_day, 0));
+  unassert(!pthread_join(scorer_hour, 0));
+  unassert(!pthread_join(scorer_week, 0));
+  unassert(!pthread_join(scorer_month, 0));
+  unassert(!pthread_join(replenisher, 0));
 
   // cancel read() so that keepalive clients finish faster
-  LOG("Interrupting workers...\n");
-  for (int i = 0; i < g_workers; ++i) {
-    pthread_kill(g_worker[i].th, SIGUSR1);
-  }
+  LOG("%H interrupting workers...\n");
+  for (int i = 0; i < g_workers; ++i)
+    if (!g_worker[i].dead)
+      pthread_cancel(g_worker[i].th);
 
   // wait for producers to finish
-  LOG("Waiting for workers to finish...\n");
-  for (int i = 0; i < g_workers; ++i) {
-    CHECK_EQ(0, pthread_join(g_worker[i].th, 0));
-  }
-  LOG("Waiting for helpers to finish...\n");
-  CHECK_EQ(0, pthread_join(nower, 0));
-  CHECK_EQ(0, pthread_join(scorer, 0));
-  CHECK_EQ(0, pthread_join(plotter, 0));
-  CHECK_EQ(0, pthread_join(recenter, 0));
-  CHECK_EQ(0, pthread_join(scorer_day, 0));
-  CHECK_EQ(0, pthread_join(scorer_hour, 0));
-  CHECK_EQ(0, pthread_join(scorer_week, 0));
-  CHECK_EQ(0, pthread_join(scorer_month, 0));
-  CHECK_EQ(0, pthread_join(replenisher, 0));
+  LOG("%H joining workers...\n");
+  for (int i = 0; i < g_workers; ++i)
+    unassert(!pthread_join(g_worker[i].th, 0));
 
   // now that all workers have terminated, the claims queue must be
   // empty, therefore, it is now safe to send a cancellation to the
   // claims worker thread which waits forever for new claims.
-  CHECK_EQ(0, g_claims.count);
-  LOG("waiting for claims worker...\n");
-  nsync_note_notify(g_shutdown[2]);
-  CHECK_EQ(0, pthread_join(claimer, 0));
+  unassert(!g_claims.count);
+  pthread_cancel(claimer);
+  LOG("%H waiting for claims worker...\n");
+  unassert(!pthread_join(claimer, 0));
 
   // perform some sanity checks
-  CHECK_EQ(g_claimsprocessed, g_claimsenqueued);
+  unassert(g_claimsprocessed == g_claimsenqueued);
 
   // free memory
-  LOG("Freeing memory...\n");
+  LOG("%H freeing memory...\n");
   FreeAsset(&g_asset.user);
   FreeAsset(&g_asset.about);
   FreeAsset(&g_asset.index);
@@ -2111,13 +2262,11 @@ int main(int argc, char *argv[]) {
   FreeAsset(&g_asset.score_month);
   FreeAsset(&g_asset.recent);
   FreeAsset(&g_asset.favicon);
-  for (int i = 0; i < ARRAYLEN(g_shutdown); ++i) {
-    nsync_note_free(g_shutdown[i]);
-  }
-  nsync_counter_free(g_ready);
   free(g_worker);
   free(g_tok.b);
 
-  LOG("Goodbye\n");
+  time_destroy();
+
+  LOG("%H goodbye\n");
   // CheckForMemoryLeaks();
 }
diff --git a/test/ctl/BUILD.mk b/test/ctl/BUILD.mk
index 0a57a98cf..a6944bbf8 100644
--- a/test/ctl/BUILD.mk
+++ b/test/ctl/BUILD.mk
@@ -13,8 +13,18 @@ TEST_CTL_TESTS = $(TEST_CTL_COMS:%=%.ok)
 
 TEST_CTL_DIRECTDEPS =				\
 	CTL					\
+	LIBC_CALLS				\
 	LIBC_INTRIN				\
+	LIBC_LOG				\
 	LIBC_MEM				\
+	LIBC_NEXGEN32E				\
+	LIBC_PROC				\
+	LIBC_STDIO				\
+	LIBC_SYSTEM				\
+	LIBC_THREAD				\
+	THIRD_PARTY_LIBCXX			\
+	THIRD_PARTY_LIBCXXABI			\
+	THIRD_PARTY_LIBUNWIND			\
 
 TEST_CTL_DEPS :=				\
 	$(call uniq,$(foreach x,$(TEST_CTL_DIRECTDEPS),$($(x))))
@@ -31,6 +41,10 @@ o/$(MODE)/test/ctl/%.dbg:			\
 		$(APE_NO_MODIFY_SELF)
 	@$(APELINK)
 
+$(TEST_CTL_OBJS): private			\
+		OVERRIDE_CXXFLAGS +=		\
+			-fexceptions		\
+
 .PHONY: o/$(MODE)/test/ctl
 o/$(MODE)/test/ctl:				\
 		$(TEST_CTL_BINS)		\
diff --git a/test/ctl/accumulate_test.cc b/test/ctl/accumulate_test.cc
new file mode 100644
index 000000000..3145e18e2
--- /dev/null
+++ b/test/ctl/accumulate_test.cc
@@ -0,0 +1,54 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/accumulate.h"
+#include "ctl/array.h"
+#include "libc/mem/leaks.h"
+
+// #include <array>
+// #include <numeric>
+// #define ctl std
+
+int
+main()
+{
+    ctl::array<int, 5> arr = { 1, 2, 3, 4, 5 };
+
+    // Test basic accumulation with addition
+    if (ctl::accumulate(arr.begin(), arr.end(), 0) != 15)
+        return 1;
+
+    // Test accumulation with initial value
+    if (ctl::accumulate(arr.begin(), arr.end(), 10) != 25)
+        return 2;
+
+    // Test accumulation with custom operation (multiplication)
+    if (ctl::accumulate(
+          arr.begin(), arr.end(), 1, [](int a, int b) { return a * b; }) != 120)
+        return 3;
+
+    // Test accumulation with empty range
+    if (ctl::accumulate(arr.end(), arr.end(), 0) != 0)
+        return 4;
+
+    // Test accumulation with single element
+    if (ctl::accumulate(arr.begin(), arr.begin() + 1, 0) != 1)
+        return 5;
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/advance_test.cc b/test/ctl/advance_test.cc
new file mode 100644
index 000000000..e0782ba35
--- /dev/null
+++ b/test/ctl/advance_test.cc
@@ -0,0 +1,59 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/advance.h"
+#include "ctl/array.h"
+#include "libc/mem/leaks.h"
+
+// #include <array>
+// #include <iterator>
+// #define ctl std
+
+int
+main()
+{
+    ctl::array<int, 5> arr = { 1, 2, 3, 4, 5 };
+
+    // Test advancing forward
+    auto it = arr.begin();
+    ctl::advance(it, 2);
+    if (*it != 3)
+        return 1;
+
+    // Test advancing to the end
+    ctl::advance(it, 2);
+    if (it != arr.end() - 1)
+        return 2;
+
+    // Test advancing backward
+    ctl::advance(it, -2);
+    if (*it != 3)
+        return 3;
+
+    // Test advancing by zero
+    ctl::advance(it, 0);
+    if (*it != 3)
+        return 4;
+
+    // Test advancing to the beginning
+    ctl::advance(it, -2);
+    if (it != arr.begin())
+        return 5;
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/all_of_test.cc b/test/ctl/all_of_test.cc
new file mode 100644
index 000000000..bf8aa4bcd
--- /dev/null
+++ b/test/ctl/all_of_test.cc
@@ -0,0 +1,55 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/all_of.h"
+#include "ctl/array.h"
+#include "libc/mem/leaks.h"
+
+// #include <algorithm>
+// #include <array>
+// #define ctl std
+
+int
+main()
+{
+    ctl::array<int, 5> arr1 = { 2, 4, 6, 8, 10 };
+    ctl::array<int, 5> arr2 = { 2, 4, 5, 8, 10 };
+
+    // Test when all elements satisfy the condition
+    if (!ctl::all_of(
+          arr1.begin(), arr1.end(), [](int n) { return n % 2 == 0; }))
+        return 1;
+
+    // Test when not all elements satisfy the condition
+    if (ctl::all_of(arr2.begin(), arr2.end(), [](int n) { return n % 2 == 0; }))
+        return 2;
+
+    // Test with empty range
+    if (!ctl::all_of(arr1.end(), arr1.end(), [](int n) { return false; }))
+        return 3;
+
+    // Test with all elements satisfying a different condition
+    if (!ctl::all_of(arr1.begin(), arr1.end(), [](int n) { return n > 0; }))
+        return 4;
+
+    // Test with no elements satisfying the condition
+    if (ctl::all_of(arr1.begin(), arr1.end(), [](int n) { return n > 10; }))
+        return 5;
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/any_of_test.cc b/test/ctl/any_of_test.cc
new file mode 100644
index 000000000..ee08afd3e
--- /dev/null
+++ b/test/ctl/any_of_test.cc
@@ -0,0 +1,54 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/any_of.h"
+#include "ctl/array.h"
+#include "libc/mem/leaks.h"
+
+// #include <algorithm>
+// #include <array>
+// #define ctl std
+
+int
+main()
+{
+    ctl::array<int, 5> arr1 = { 1, 3, 5, 7, 9 };
+    ctl::array<int, 5> arr2 = { 2, 4, 6, 8, 10 };
+
+    // Test when at least one element satisfies the condition
+    if (!ctl::any_of(arr1.begin(), arr1.end(), [](int n) { return n == 7; }))
+        return 1;
+
+    // Test when no elements satisfy the condition
+    if (ctl::any_of(arr1.begin(), arr1.end(), [](int n) { return n == 11; }))
+        return 2;
+
+    // Test with empty range
+    if (ctl::any_of(arr1.end(), arr1.end(), [](int n) { return true; }))
+        return 3;
+
+    // Test when all elements satisfy the condition
+    if (!ctl::any_of(arr2.begin(), arr2.end(), [](int n) { return true; }))
+        return 4;
+
+    // Test with a different condition
+    if (!ctl::any_of(arr1.begin(), arr1.end(), [](int n) { return n > 5; }))
+        return 5;
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/array_test.cc b/test/ctl/array_test.cc
new file mode 100644
index 000000000..40f774173
--- /dev/null
+++ b/test/ctl/array_test.cc
@@ -0,0 +1,287 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/array.h"
+#include "ctl/string.h"
+#include "libc/mem/leaks.h"
+
+// #include <array>
+// #include <string>
+// #define ctl std
+
+int
+main()
+{
+
+    // Test construction and basic properties
+    {
+        ctl::array<int, 5> arr = { 1, 2, 3, 4, 5 };
+        if (arr.size() != 5)
+            return 2;
+        if (arr.max_size() != 5)
+            return 3;
+        if (arr.empty())
+            return 4;
+    }
+
+    // Test element access
+    {
+        ctl::array<int, 3> arr = { 10, 20, 30 };
+        if (arr[0] != 10 || arr[1] != 20 || arr[2] != 30)
+            return 5;
+        if (arr.front() != 10)
+            return 6;
+        if (arr.back() != 30)
+            return 7;
+    }
+
+    // Test data() method
+    {
+        ctl::array<int, 3> arr = { 1, 2, 3 };
+        int* data = arr.data();
+        if (data[0] != 1 || data[1] != 2 || data[2] != 3)
+            return 9;
+    }
+
+    // Test iterators
+    {
+        ctl::array<int, 3> arr = { 1, 2, 3 };
+        int sum = 0;
+        for (auto it = arr.begin(); it != arr.end(); ++it) {
+            sum += *it;
+        }
+        if (sum != 6)
+            return 10;
+
+        sum = 0;
+        for (auto it = arr.rbegin(); it != arr.rend(); ++it) {
+            sum += *it;
+        }
+        if (sum != 6)
+            return 11;
+    }
+
+    // Test const iterators
+    {
+        const ctl::array<int, 3> arr = { 1, 2, 3 };
+        int sum = 0;
+        for (auto it = arr.cbegin(); it != arr.cend(); ++it) {
+            sum += *it;
+        }
+        if (sum != 6)
+            return 12;
+
+        sum = 0;
+        for (auto it = arr.crbegin(); it != arr.crend(); ++it) {
+            sum += *it;
+        }
+        if (sum != 6)
+            return 13;
+    }
+
+    // Test fill method
+    {
+        ctl::array<int, 5> arr;
+        arr.fill(42);
+        for (int i = 0; i < 5; ++i) {
+            if (arr[i] != 42)
+                return 14;
+        }
+    }
+
+    // Test swap method
+    {
+        ctl::array<int, 3> arr1 = { 1, 2, 3 };
+        ctl::array<int, 3> arr2 = { 4, 5, 6 };
+        arr1.swap(arr2);
+        if (arr1[0] != 4 || arr1[1] != 5 || arr1[2] != 6)
+            return 15;
+        if (arr2[0] != 1 || arr2[1] != 2 || arr2[2] != 3)
+            return 16;
+    }
+
+    // Test comparison operators
+    {
+        ctl::array<int, 3> arr1 = { 1, 2, 3 };
+        ctl::array<int, 3> arr2 = { 1, 2, 3 };
+        ctl::array<int, 3> arr3 = { 1, 2, 4 };
+
+        if (!(arr1 == arr2))
+            return 17;
+        if (arr1 != arr2)
+            return 18;
+        if (!(arr1 < arr3))
+            return 19;
+        if (arr3 <= arr1)
+            return 20;
+        if (!(arr3 > arr1))
+            return 21;
+        if (arr1 >= arr3)
+            return 22;
+    }
+
+    // Test non-member swap function
+    {
+        ctl::array<int, 3> arr1 = { 1, 2, 3 };
+        ctl::array<int, 3> arr2 = { 4, 5, 6 };
+        swap(arr1, arr2);
+        if (arr1[0] != 4 || arr1[1] != 5 || arr1[2] != 6)
+            return 23;
+        if (arr2[0] != 1 || arr2[1] != 2 || arr2[2] != 3)
+            return 24;
+    }
+
+    // Test with non-trivial type
+    {
+        struct NonTrivial
+        {
+            int value;
+
+            NonTrivial(int v = 0) : value(v)
+            {
+            }
+
+            bool operator==(const NonTrivial& other) const
+            {
+                return value == other.value;
+            }
+        };
+
+        ctl::array<NonTrivial, 3> arr = { 1, 2, 3 };
+        if (arr[0].value != 1 || arr[1].value != 2 || arr[2].value != 3)
+            return 25;
+    }
+
+    // Test empty array
+    {
+        ctl::array<int, 0> arr;
+        if (!arr.empty())
+            return 26;
+        if (arr.size() != 0)
+            return 27;
+        if (arr.begin() != arr.end())
+            return 28;
+    }
+
+    // Test basic array functionality
+    {
+        ctl::array<int, 5> arr = { 1, 2, 3, 4, 5 };
+        if (arr.size() != 5)
+            return 2;
+        if (arr[0] != 1 || arr[4] != 5)
+            return 3;
+    }
+
+    // Test reverse iterator basics
+    {
+        ctl::array<int, 5> arr = { 1, 2, 3, 4, 5 };
+        auto rit = arr.rbegin();
+        if (*rit != 5)
+            return 4;
+        ++rit;
+        if (*rit != 4)
+            return 5;
+        if (*(arr.rbegin() + 2) != 3)
+            return 6;
+    }
+
+    // Test reverse iterator traversal
+    {
+        ctl::array<int, 5> arr = { 1, 2, 3, 4, 5 };
+        int expected = 5;
+        for (auto rit = arr.rbegin(); rit != arr.rend(); ++rit) {
+            if (*rit != expected)
+                return 7;
+            --expected;
+        }
+    }
+
+    // Test const reverse iterator
+    {
+        const ctl::array<int, 5> arr = { 1, 2, 3, 4, 5 };
+        auto crit = arr.crbegin();
+        if (*crit != 5)
+            return 8;
+        ++crit;
+        if (*crit != 4)
+            return 9;
+    }
+
+    // Test reverse iterator arithmetic
+    {
+        ctl::array<int, 5> arr = { 1, 2, 3, 4, 5 };
+        auto rit = arr.rbegin();
+        rit += 2;
+        if (*rit != 3)
+            return 10;
+        rit -= 1;
+        if (*rit != 4)
+            return 11;
+        if (*(rit + 2) != 2)
+            return 12;
+        if (*(rit - 1) != 5)
+            return 13;
+    }
+
+    // Test reverse iterator comparison
+    {
+        ctl::array<int, 5> arr = { 1, 2, 3, 4, 5 };
+        auto rit1 = arr.rbegin();
+        auto rit2 = arr.rbegin() + 2;
+        if (rit1 >= rit2)
+            return 14;
+        if (!(rit1 < rit2))
+            return 15;
+        if (rit1 == rit2)
+            return 16;
+    }
+
+    // Test it seems legit
+    {
+        ctl::array<int, 3> arr = { 1, 2, 3 };
+        auto rit = arr.rbegin();
+        if (*rit != 3)
+            return 1;
+        ++rit;
+        if (*rit != 2)
+            return 2;
+        ++rit;
+        if (*rit != 1)
+            return 3;
+        ++rit;
+        if (rit != arr.rend())
+            return 4;
+    }
+
+    {
+        ctl::array<ctl::string, 2> A = { "hi", "theretheretheretherethere" };
+        if (A.size() != 2)
+            return 76;
+        if (A[0] != "hi")
+            return 77;
+        if (A[1] != "theretheretheretherethere")
+            return 78;
+        A = { "theretheretheretherethere", "hi" };
+        if (A[0] != "theretheretheretherethere")
+            return 79;
+        if (A[1] != "hi")
+            return 80;
+    }
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/back_inserter_test.cc b/test/ctl/back_inserter_test.cc
new file mode 100644
index 000000000..122493952
--- /dev/null
+++ b/test/ctl/back_inserter_test.cc
@@ -0,0 +1,67 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/array.h"
+#include "ctl/back_inserter.h"
+#include "ctl/copy.h"
+#include "ctl/vector.h"
+#include "libc/mem/leaks.h"
+
+// #include <array>
+// #include <iterator>
+// #include <vector>
+// #define ctl std
+
+int
+main()
+{
+
+    {
+        ctl::vector<int> vec = { 1, 2, 3 };
+        ctl::array<int, 3> arr = { 4, 5, 6 };
+
+        // Use back_inserter to append elements from arr to vec
+        ctl::copy(arr.begin(), arr.end(), ctl::back_inserter(vec));
+
+        // Check if vec now contains all elements
+        if (vec.size() != 6)
+            return 1;
+        if (vec[0] != 1 || vec[1] != 2 || vec[2] != 3 || vec[3] != 4 ||
+            vec[4] != 5 || vec[5] != 6)
+            return 2;
+
+        // Use back_inserter with a single element
+        ctl::back_inserter(vec) = 7;
+
+        // Check if the new element was added
+        if (vec.size() != 7)
+            return 3;
+        if (vec[6] != 7)
+            return 4;
+
+        // Test with an empty source range
+        ctl::array<int, 0> empty_arr;
+        ctl::copy(empty_arr.begin(), empty_arr.end(), ctl::back_inserter(vec));
+
+        // Check that no elements were added
+        if (vec.size() != 7)
+            return 5;
+    }
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/copy_test.cc b/test/ctl/copy_test.cc
new file mode 100644
index 000000000..0c73ed7c8
--- /dev/null
+++ b/test/ctl/copy_test.cc
@@ -0,0 +1,71 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/array.h"
+#include "ctl/copy.h"
+#include "libc/mem/leaks.h"
+
+// #include <algorithm>
+// #include <array>
+// #include <iterator>
+// #define ctl std
+
+int
+main()
+{
+
+    {
+        ctl::array<int, 5> src = { 1, 2, 3, 4, 5 };
+        ctl::array<int, 5> dest = { 0, 0, 0, 0, 0 };
+
+        // Test basic copy
+        ctl::copy(src.begin(), src.end(), dest.begin());
+        for (size_t i = 0; i < 5; ++i)
+            if (dest[i] != src[i])
+                return 1;
+
+        // Test partial copy
+        ctl::array<int, 5> dest2 = { 0, 0, 0, 0, 0 };
+        ctl::copy(src.begin(), src.begin() + 3, dest2.begin());
+        if (dest2[0] != 1 || dest2[1] != 2 || dest2[2] != 3 || dest2[3] != 0 ||
+            dest2[4] != 0)
+            return 2;
+
+        // Test copy to middle of destination
+        ctl::array<int, 7> dest3 = { 0, 0, 0, 0, 0, 0, 0 };
+        ctl::copy(src.begin(), src.end(), dest3.begin() + 1);
+        if (dest3[0] != 0 || dest3[1] != 1 || dest3[2] != 2 || dest3[3] != 3 ||
+            dest3[4] != 4 || dest3[5] != 5 || dest3[6] != 0)
+            return 3;
+
+        // Test copy with empty range
+        ctl::array<int, 5> dest4 = { 0, 0, 0, 0, 0 };
+        ctl::copy(src.begin(), src.begin(), dest4.begin());
+        for (size_t i = 0; i < 5; ++i)
+            if (dest4[i] != 0)
+                return 4;
+
+        // Test copy return value
+        ctl::array<int, 5> dest5 = { 0, 0, 0, 0, 0 };
+        auto result = ctl::copy(src.begin(), src.end(), dest5.begin());
+        if (result != dest5.end())
+            return 5;
+    }
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/is_base_of_test.cc b/test/ctl/is_base_of_test.cc
new file mode 100644
index 000000000..8e64a75af
--- /dev/null
+++ b/test/ctl/is_base_of_test.cc
@@ -0,0 +1,102 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/is_base_of.h"
+
+// #include <type_traits>
+// #define ctl std
+
+// Test classes
+class A
+{};
+class B : public A
+{};
+class C : public B
+{};
+class D
+{};
+
+struct Empty
+{};
+
+template<typename T>
+class TemplateClass
+{};
+
+class VirtualBase
+{};
+class VirtualDerived : virtual public VirtualBase
+{};
+
+int
+main()
+{
+    // Test basic inheritance
+    if (!ctl::is_base_of_v<A, B>)
+        return 1;
+    if (!ctl::is_base_of_v<A, C>)
+        return 2;
+    if (ctl::is_base_of_v<B, A>)
+        return 3;
+    if (ctl::is_base_of_v<C, A>)
+        return 4;
+    if (ctl::is_base_of_v<A, D>)
+        return 5;
+
+    // Test with same type
+    if (!ctl::is_base_of_v<A, A>)
+        return 6;
+    if (!ctl::is_base_of_v<B, B>)
+        return 7;
+
+    // Test with void
+    if (ctl::is_base_of_v<void, void>)
+        return 8;
+    if (ctl::is_base_of_v<A, void>)
+        return 9;
+    if (ctl::is_base_of_v<void, A>)
+        return 10;
+
+    // Test with fundamental types
+    if (ctl::is_base_of_v<int, int>)
+        return 11;
+    if (ctl::is_base_of_v<int, double>)
+        return 12;
+    if (ctl::is_base_of_v<double, int>)
+        return 13;
+
+    // Test with empty class
+    if (ctl::is_base_of_v<Empty, A>)
+        return 14;
+    if (ctl::is_base_of_v<A, Empty>)
+        return 15;
+
+    // Test with template class
+    if (ctl::is_base_of_v<TemplateClass<int>, A>)
+        return 16;
+    if (ctl::is_base_of_v<A, TemplateClass<int>>)
+        return 17;
+
+    // Test with virtual inheritance
+    if (!ctl::is_base_of_v<VirtualBase, VirtualDerived>)
+        return 18;
+    if (ctl::is_base_of_v<VirtualDerived, VirtualBase>)
+        return 19;
+
+    return 0; // All tests passed
+}
diff --git a/test/ctl/istringstream_test.cc b/test/ctl/istringstream_test.cc
new file mode 100644
index 000000000..08019c93c
--- /dev/null
+++ b/test/ctl/istringstream_test.cc
@@ -0,0 +1,163 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/istringstream.h"
+#include "libc/mem/leaks.h"
+
+// #include <sstream>
+// #define ctl std
+
+int
+main()
+{
+
+    // Test default constructor
+    {
+        ctl::istringstream iss;
+        if (iss.eof())
+            return 1;
+        if (!iss.good())
+            return 1;
+    }
+
+    // Test constructor with initial string
+    {
+        ctl::istringstream iss("Hello, world!");
+        if (iss.str() != "Hello, world!")
+            return 2;
+    }
+
+    // Test reading a char
+    {
+        ctl::istringstream iss("A");
+        char c;
+        iss >> c;
+        if (c != 'A' || !iss.good())
+            return 3;
+    }
+
+    // Test reading a string
+    {
+        ctl::istringstream iss("Hello World");
+        ctl::string s;
+        iss >> s;
+        if (s != "Hello" || !iss.good())
+            return 4;
+    }
+
+    // Test reading multiple strings
+    {
+        ctl::istringstream iss("One Two Three");
+        ctl::string s1, s2, s3;
+        iss >> s1 >> s2 >> s3;
+        if (s1 != "One" || s2 != "Two" || s3 != "Three" || iss.good() ||
+            !iss.eof())
+            return 5;
+    }
+
+    // Test reading integers
+    {
+        ctl::istringstream iss("123 -456 789");
+        int a, b, c;
+        iss >> a >> b >> c;
+        if (a != 123 || b != -456 || c != 789 || iss.good() || !iss.eof())
+            return 6;
+    }
+
+    // Test reading floating-point numbers
+    {
+        ctl::istringstream iss("3.14 -2.718");
+        float f;
+        double d;
+        iss >> f >> d;
+        if (f != 3.14f || d != -2.718 || iss.good() || !iss.eof())
+            return 7;
+    }
+
+    // Test reading past the end of the stream
+    {
+        ctl::istringstream iss("42");
+        int n;
+        iss >> n;
+        if (n != 42 || iss.good() || !iss.eof())
+            return 8;
+        iss >> n;
+        if (iss.good())
+            return 9;
+        if (!iss.eof())
+            return 10;
+    }
+
+    // Test reading invalid data
+    {
+        ctl::istringstream iss("not_a_number");
+        int n;
+        iss >> n;
+        if (iss.good() || !iss.fail())
+            return 11;
+    }
+
+    // Test str() setter
+    {
+        ctl::istringstream iss;
+        iss.str("New content");
+        if (iss.str() != "New content" || !iss.good())
+            return 12;
+    }
+
+    // Test reading after setting a new string
+    {
+        ctl::istringstream iss("Old content");
+        iss.str("New content");
+        ctl::string s;
+        iss >> s;
+        if (s != "New" || !iss.good())
+            return 13;
+    }
+
+    // Test reading a mixture of types
+    {
+        ctl::istringstream iss("42 3.14 Hello");
+        int i;
+        double d;
+        ctl::string s;
+        iss >> i >> d >> s;
+        if (i != 42 || d != 3.14 || s != "Hello" || iss.good() || !iss.eof())
+            return 14;
+    }
+
+    // Test reading with leading whitespace
+    {
+        ctl::istringstream iss("   42");
+        int n;
+        iss >> n;
+        if (n != 42 || iss.good() || !iss.eof())
+            return 15;
+    }
+
+    // Test clear() only affects error state, not content
+    {
+        ctl::istringstream iss("Test");
+        iss.setstate(ctl::ios_base::failbit);
+        iss.clear();
+        if (!iss.good() || iss.str() != "Test")
+            return 16;
+    }
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/mutex_test.cc b/test/ctl/mutex_test.cc
new file mode 100644
index 000000000..9c03d08c8
--- /dev/null
+++ b/test/ctl/mutex_test.cc
@@ -0,0 +1,114 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/mutex.h"
+#include "libc/mem/leaks.h"
+
+// #include <mutex>
+// #define ctl std
+
+ctl::mutex mtx;
+int shared_resource = 0;
+const int NUM_THREADS = 5;
+const int ITERATIONS = 100000;
+
+void*
+increment_resource(void* arg)
+{
+    for (int i = 0; i < ITERATIONS; ++i) {
+        mtx.lock();
+        ++shared_resource;
+        mtx.unlock();
+    }
+    return nullptr;
+}
+
+void*
+decrement_resource(void* arg)
+{
+    for (int i = 0; i < ITERATIONS; ++i) {
+        mtx.lock();
+        --shared_resource;
+        mtx.unlock();
+    }
+    return nullptr;
+}
+
+int
+test_basic_locking()
+{
+    shared_resource = 0;
+    pthread_t threads[NUM_THREADS];
+    for (int i = 0; i < NUM_THREADS; ++i)
+        if (pthread_create(&threads[i], 0, increment_resource, 0) != 0)
+            return 1;
+    for (int i = 0; i < NUM_THREADS; ++i)
+        if (pthread_join(threads[i], 0) != 0)
+            return 2;
+    return (shared_resource == NUM_THREADS * ITERATIONS) ? 0 : 3;
+}
+
+int
+test_lock_contention()
+{
+    shared_resource = 0;
+    pthread_t threads[NUM_THREADS * 2];
+    for (int i = 0; i < NUM_THREADS; ++i)
+        if (pthread_create(&threads[i], 0, increment_resource, 0) != 0 ||
+            pthread_create(&threads[i + NUM_THREADS],
+                           nullptr,
+                           decrement_resource,
+                           nullptr) != 0)
+            return 4;
+    for (int i = 0; i < NUM_THREADS * 2; ++i)
+        if (pthread_join(threads[i], 0) != 0)
+            return 5;
+    return (shared_resource == 0) ? 0 : 6;
+}
+
+int
+test_try_lock()
+{
+    ctl::mutex try_mtx;
+    if (!try_mtx.try_lock())
+        return 7;
+    if (try_mtx.try_lock())
+        return 8;
+    try_mtx.unlock();
+    return 0;
+}
+
+int
+main()
+{
+    int result;
+
+    result = test_basic_locking();
+    if (result != 0)
+        return result;
+
+    result = test_lock_contention();
+    if (result != 0)
+        return result;
+
+    result = test_try_lock();
+    if (result != 0)
+        return result;
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/ostringstream_test.cc b/test/ctl/ostringstream_test.cc
new file mode 100644
index 000000000..da45a6a03
--- /dev/null
+++ b/test/ctl/ostringstream_test.cc
@@ -0,0 +1,140 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/ostringstream.h"
+#include "libc/mem/leaks.h"
+
+// #include <sstream>
+// #define ctl std
+
+int
+main()
+{
+
+    // Test default constructor and basic string insertion
+    {
+        ctl::ostringstream oss;
+        oss << "Hello, world!";
+        if (oss.str() != "Hello, world!")
+            return 1;
+    }
+
+    // Test constructor with initial string (overwrite mode)
+    {
+        ctl::ostringstream oss("Initial content");
+        oss << "New";
+        if (oss.str() != "Newtial content")
+            return 2;
+    }
+
+    // Test overwrite and append behavior
+    {
+        ctl::ostringstream oss("Hello, world!");
+        oss << "Hi";
+        if (oss.str() != "Hillo, world!")
+            return 3;
+        oss << " Earth";
+        if (oss.str() != "Hi Earthorld!")
+            return 4;
+    }
+
+    // Test multiple insertions of different types
+    {
+        ctl::ostringstream oss;
+        oss << "Int: " << 42 << ", Float: " << 3.14f << ", Double: " << 2.718;
+        if (oss.str() != "Int: 42, Float: 3.14, Double: 2.718")
+            return 5;
+    }
+
+    // Test char insertion
+    {
+        ctl::ostringstream oss("ABCDEF");
+        oss << 'X' << 'Y' << 'Z';
+        if (oss.str() != "XYZDEF")
+            return 6;
+    }
+
+    // Test unsigned types
+    {
+        ctl::ostringstream oss("Numbers: ");
+        unsigned int ui = 12345;
+        unsigned long ul = 67890UL;
+        oss << ui << " " << ul;
+        if (oss.str() != "12345 67890")
+            return 7;
+    }
+
+    // Test long type
+    {
+        ctl::ostringstream oss("Long: ");
+        long l = -9876543210L;
+        oss << l;
+        if (oss.str() != "-9876543210")
+            return 8;
+    }
+
+    // Test clear() method
+    {
+        ctl::ostringstream oss("not that kind of clear");
+        oss.clear();
+        if (!oss.good() || oss.str() != "not that kind of clear")
+            return 9;
+    }
+
+    // Test str() setter method
+    {
+        ctl::ostringstream oss;
+        oss.str("New content");
+        oss << "Old";
+        if (oss.str() != "Old content")
+            return 10;
+    }
+
+    // Test chaining of insertion operators
+    {
+        ctl::ostringstream oss("Start: ");
+        oss << "Chain " << 1 << " " << 2.0 << " " << 'Z';
+        if (oss.str() != "Chain 1 2 Z")
+            return 11;
+    }
+
+    // Test insertion when stream is not in good state
+    {
+        ctl::ostringstream oss("Original");
+        oss.setstate(ctl::ios_base::failbit);
+        oss << "This should not be inserted";
+        if (oss.str() != "Original")
+            return 12;
+    }
+
+    // Test with larger amounts of data
+    {
+        ctl::ostringstream oss("Prefix: ");
+        for (int i = 0; i < 1000; ++i) {
+            oss << "Line " << i << "\n";
+        }
+        ctl::string result = oss.str();
+        if (result.substr(0, 14) != "Line 0\nLine 1\n")
+            return 13;
+        if (result.substr(result.length() - 8) != "ine 999\n")
+            return 14;
+    }
+
+    CheckForMemoryLeaks();
+    return 0;
+}
diff --git a/test/ctl/set_bench.cc b/test/ctl/set_bench.cc
new file mode 100644
index 000000000..4cc1f31e6
--- /dev/null
+++ b/test/ctl/set_bench.cc
@@ -0,0 +1,78 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/set.h"
+#include "libc/calls/struct/rusage.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/mem/leaks.h"
+#include "libc/stdio/stdio.h"
+#include "libc/sysv/consts/rusage.h"
+#include "libc/testlib/benchmark.h"
+
+// #include <set>
+// #define ctl std
+// #define check() size()
+
+int
+rand32(void)
+{
+    /* Knuth, D.E., "The Art of Computer Programming," Vol 2,
+       Seminumerical Algorithms, Third Edition, Addison-Wesley, 1998,
+       p. 106 (line 26) & p. 108 */
+    static unsigned long long lcg = 1;
+    lcg *= 6364136223846793005;
+    lcg += 1442695040888963407;
+    return lcg >> 32;
+}
+
+void
+eat(int x)
+{
+}
+
+void (*pEat)(int) = eat;
+
+int
+main()
+{
+
+    {
+        long x = 0;
+        ctl::set<long> s;
+        BENCHMARK(1000000, 1, s.insert(rand32() % 1000000));
+        // s.check();
+        BENCHMARK(1000000, 1, {
+            auto i = s.find(rand32() % 1000000);
+            if (i != s.end())
+                x += *i;
+        });
+        BENCHMARK(1000000, 1, {
+            auto i = s.lower_bound(rand32() % 1000000);
+            if (i != s.end())
+                x += *i;
+        });
+        BENCHMARK(1000000, 1, s.erase(rand32() % 1000000));
+        eat(x);
+    }
+
+    struct rusage ru;
+    getrusage(RUSAGE_SELF, &ru);
+    printf("%,10d kb peak rss\n", ru.ru_maxrss);
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/set_test.cc b/test/ctl/set_test.cc
index 5eecca5e2..2f68bb0e0 100644
--- a/test/ctl/set_test.cc
+++ b/test/ctl/set_test.cc
@@ -148,6 +148,16 @@ main()
         s.check();
     }
 
+    {
+        // Test lower_bound and upper_bound
+        ctl::set<int> s{ 1, 3, 4, 5, 7, 9 };
+        auto lower = s.lower_bound(4);
+        auto upper = s.upper_bound(4);
+        if (*lower != 4 || *upper != 5)
+            return 18;
+        s.check();
+    }
+
     {
         // Test emplace
         ctl::set<ctl::pair<int, int>> s;
diff --git a/test/ctl/shared_ptr_test.cc b/test/ctl/shared_ptr_test.cc
new file mode 100644
index 000000000..f9a8dd597
--- /dev/null
+++ b/test/ctl/shared_ptr_test.cc
@@ -0,0 +1,313 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/is_same.h"
+#include "ctl/shared_ptr.h"
+#include "ctl/vector.h"
+#include "libc/mem/leaks.h"
+
+// #include <memory>
+// #include <vector>
+// #define ctl std
+
+using ctl::bad_weak_ptr;
+using ctl::enable_shared_from_this;
+using ctl::make_shared;
+using ctl::move;
+using ctl::shared_ptr;
+using ctl::unique_ptr;
+using ctl::vector;
+using ctl::weak_ptr;
+
+#undef ctl
+
+static int g = 0;
+
+struct ConstructG
+{
+    ConstructG()
+    {
+        ++g;
+    }
+};
+
+struct DestructG
+{
+    ~DestructG()
+    {
+        ++g;
+    }
+};
+
+struct CallG
+{
+    void operator()(auto*) const noexcept
+    {
+        ++g;
+    }
+};
+
+struct Base
+{};
+
+struct Derived : Base
+{};
+
+class SharedThis : public enable_shared_from_this<SharedThis>
+{
+    struct Private
+    {
+        explicit Private() = default;
+    };
+
+  public:
+    SharedThis(Private)
+    {
+    }
+
+    static shared_ptr<SharedThis> create()
+    {
+        return make_shared<SharedThis>(Private());
+    }
+};
+
+class CanShareThis : public enable_shared_from_this<CanShareThis>
+{};
+
+// Sample class used to demonstrate the CTL shared_ptr's weak_self feature.
+struct Tree : ctl::weak_self_base
+{
+    ctl::shared_ptr<Tree> l, r;
+    ctl::weak_ptr<Tree> p;
+    Tree(ctl::weak_ptr<Tree> const& self, auto&& l2, auto&& r2)
+      : l(ctl::forward<decltype(l2)>(l2)), r(ctl::forward<decltype(r2)>(r2))
+    {
+        if (l)
+            l->p = self;
+        if (r)
+            r->p = self;
+    }
+};
+
+int
+main()
+{
+    int a, b;
+
+    {
+        // Shouldn't cause memory leaks.
+        shared_ptr<int> x(new int(5));
+    }
+
+    {
+        // Objects get destroyed when the last shared_ptr is reset.
+        shared_ptr<int> x(&a, CallG());
+        shared_ptr<int> y(x);
+        x.reset();
+        if (g)
+            return 1;
+        y.reset();
+        if (g != 1)
+            return 2;
+    }
+
+    {
+        g = 0;
+        // Weak pointers don't prevent object destruction.
+        shared_ptr<int> x(&a, CallG());
+        weak_ptr<int> y(x);
+        x.reset();
+        if (g != 1)
+            return 3;
+    }
+
+    {
+        g = 0;
+        // Weak pointers can be promoted to shared pointers.
+        shared_ptr<int> x(&a, CallG());
+        weak_ptr<int> y(x);
+        auto z = y.lock();
+        x.reset();
+        if (g)
+            return 4;
+        y.reset();
+        if (g)
+            return 5;
+        z.reset();
+        if (g != 1)
+            return 6;
+    }
+
+    {
+        // Shared null pointers are falsey.
+        shared_ptr<int> x;
+        if (x)
+            return 7;
+        x.reset(new int);
+        if (!x)
+            return 8;
+    }
+
+    {
+        // You can cast a shared pointer validly.
+        shared_ptr<Derived> x(new Derived);
+        shared_ptr<Base> y(x);
+        // But not invalidly:
+        // shared_ptr<Base> x(new Derived);
+        // shared_ptr<Derived> y(x);
+    }
+
+    {
+        // You can cast a shared pointer to void to retain a reference.
+        shared_ptr<int> x(new int);
+        shared_ptr<void> y(x);
+    }
+
+    {
+        // You can also create a shared pointer to void in the first place.
+        shared_ptr<void> x(new int);
+    }
+
+    {
+        // You can take a shared pointer to a subobject, and it will free the
+        // base object.
+        shared_ptr<vector<int>> x(new vector<int>);
+        x->push_back(5);
+        shared_ptr<int> y(x, &x->at(0));
+        x.reset();
+        if (*y != 5)
+            return 9;
+    }
+
+    {
+        g = 0;
+        // You can create a shared_ptr from a unique_ptr.
+        unique_ptr<int, CallG> x(&a, CallG());
+        shared_ptr<int> y(move(x));
+        if (x)
+            return 10;
+        y.reset();
+        if (g != 1)
+            return 11;
+    }
+
+    {
+        g = 0;
+        // You can reassign shared_ptrs.
+        shared_ptr<int> x(&a, CallG());
+        shared_ptr<int> y;
+        y = x;
+        x.reset();
+        if (g)
+            return 12;
+        y.reset();
+        if (g != 1)
+            return 13;
+    }
+
+    {
+        // owner_before shows equivalence only for equivalent objects.
+        shared_ptr<int> x(&a, CallG());
+        shared_ptr<int> y(&b, CallG());
+        shared_ptr<void> z(x, &b);
+        if (z.owner_before(x) || x.owner_before(z))
+            return 14;
+        if (!z.owner_before(y) && !y.owner_before(z))
+            return 15;
+    }
+
+    {
+        // Use counts work like you'd expect
+        shared_ptr<int> x(new int);
+        if (x.use_count() != 1)
+            return 16;
+        shared_ptr<int> y(x);
+        if (x.use_count() != 2 || y.use_count() != 2)
+            return 17;
+        x.reset();
+        if (x.use_count() != 0 || y.use_count() != 1)
+            return 18;
+    }
+
+    {
+        // There is a make_shared that will allocate an object for you safely.
+        auto x = make_shared<int>(5);
+        if (!x)
+            return 19;
+        if (*x != 5)
+            return 20;
+    }
+
+    {
+        // Expired weak pointers lock to nullptr, and throw when promoted to
+        // shared pointer by constructor.
+        auto x = make_shared<int>();
+        weak_ptr<int> y(x);
+        x.reset();
+        if (y.lock())
+            return 21;
+        int caught = 0;
+        try {
+            shared_ptr<int> z(y);
+        } catch (bad_weak_ptr& e) {
+            caught = 1;
+        }
+        if (!caught)
+            return 22;
+    }
+
+    {
+        // nullptr is always expired.
+        shared_ptr<int> x(nullptr);
+        weak_ptr<int> y(x);
+        if (!y.expired())
+            return 23;
+    }
+
+    {
+        // enable_shared_from_this allows shared pointers to self.
+        auto x = SharedThis::create();
+        auto y = x->shared_from_this();
+        if (x.use_count() != 2 || x.get() != y.get())
+            return 24;
+        auto z = new CanShareThis();
+        auto w = shared_ptr<CanShareThis>(z);
+        auto v = w->shared_from_this();
+        if (w.use_count() != 2 || w.get() != v.get())
+            return 25;
+    }
+
+    if constexpr (ctl::is_same_v<shared_ptr<Tree>, ctl::shared_ptr<Tree>>) {
+        // Exercise our off-STL make_shared with weak self support.
+        auto t = ctl::make_shared<Tree>(
+          ctl::make_shared<Tree>(ctl::make_shared<Tree>(nullptr, nullptr),
+                                 nullptr),
+          ctl::make_shared<Tree>(nullptr, nullptr));
+        auto t2 = t->l->l->p.lock()->p.lock();
+        if (t.owner_before(t2) || t2.owner_before(t))
+            return 26;
+        if (!t.owner_before(t->l) && !t->l.owner_before(t))
+            return 27;
+    }
+
+    // TODO(mrdomino): exercise threads / races. The reference count should be
+    // atomically maintained.
+
+    CheckForMemoryLeaks();
+    return 0;
+}
diff --git a/test/ctl/sort_test.cc b/test/ctl/sort_test.cc
new file mode 100644
index 000000000..2acc59917
--- /dev/null
+++ b/test/ctl/sort_test.cc
@@ -0,0 +1,130 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/is_sorted.h"
+#include "ctl/sort.h"
+#include "ctl/string.h"
+#include "ctl/vector.h"
+#include "libc/mem/leaks.h"
+#include "libc/stdio/rand.h"
+
+// #include <algorithm>
+// #include <string>
+// #include <vector>
+// #define ctl std
+
+// Test sorting integers
+int
+test_sort_integers()
+{
+    ctl::vector<int> v = { 5, 2, 8, 1, 9, 3, 7, 6, 4 };
+    ctl::sort(v.begin(), v.end());
+    if (!ctl::is_sorted(v.begin(), v.end(), ctl::less<int>()))
+        return 1;
+    return 0;
+}
+
+// Test sorting with custom comparator
+int
+test_sort_custom_compare()
+{
+    ctl::vector<int> v = { 5, 2, 8, 1, 9, 3, 7, 6, 4 };
+    ctl::sort(v.begin(), v.end(), [](int a, int b) { return a > b; });
+    if (!ctl::is_sorted(v.begin(), v.end(), [](int a, int b) { return a > b; }))
+        return 2;
+    return 0;
+}
+
+// Test sorting strings
+int
+test_sort_strings()
+{
+    ctl::vector<ctl::string> v = { "banana", "apple", "cherry", "date" };
+    ctl::sort(v.begin(), v.end());
+    if (!ctl::is_sorted(v.begin(), v.end(), ctl::less<ctl::string>()))
+        return 3;
+    return 0;
+}
+
+// Test sorting with large number of elements
+int
+test_sort_large()
+{
+    const int SIZE = 10000;
+    ctl::vector<int> v(SIZE);
+    for (int i = 0; i < SIZE; ++i)
+        v[i] = rand() % SIZE;
+    ctl::sort(v.begin(), v.end());
+    if (!is_sorted(v.begin(), v.end(), ctl::less<int>()))
+        return 4;
+    return 0;
+}
+
+// Test sorting already sorted vector
+int
+test_sort_sorted()
+{
+    ctl::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+    ctl::sort(v.begin(), v.end());
+    if (!is_sorted(v.begin(), v.end(), ctl::less<int>()))
+        return 5;
+    return 0;
+}
+
+// Test sorting reverse sorted vector
+int
+test_sort_reverse()
+{
+    ctl::vector<int> v = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
+    ctl::sort(v.begin(), v.end());
+    if (!is_sorted(v.begin(), v.end(), ctl::less<int>()))
+        return 6;
+    return 0;
+}
+
+int
+main()
+{
+    int result;
+
+    result = test_sort_integers();
+    if (result != 0)
+        return result;
+
+    result = test_sort_custom_compare();
+    if (result != 0)
+        return result;
+
+    result = test_sort_strings();
+    if (result != 0)
+        return result;
+
+    result = test_sort_large();
+    if (result != 0)
+        return result;
+
+    result = test_sort_sorted();
+    if (result != 0)
+        return result;
+
+    result = test_sort_reverse();
+    if (result != 0)
+        return result;
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/string_bench.cc b/test/ctl/string_bench.cc
new file mode 100644
index 000000000..b84aa98a4
--- /dev/null
+++ b/test/ctl/string_bench.cc
@@ -0,0 +1,139 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/string.h"
+#include "ctl/utility.h"
+#include "libc/dce.h"
+#include "libc/mem/leaks.h"
+#include "libc/testlib/benchmark.h"
+
+#include "libc/calls/struct/timespec.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+
+const char* big_c = "aaaaaaaaaaaaaaaaaaaaaaaa";
+const char* small_c = "aaaaaaaaaaaaaaaaaaaaaaa";
+
+#if IsModeDbg()
+#define ITERATIONS 1000 // because qemu in dbg mode is very slow
+#else
+#define ITERATIONS 1000000
+#endif
+
+int
+main()
+{
+    const ctl::string_view big(big_c), small(small_c);
+
+    BENCHMARK(ITERATIONS * 10, 1, {
+        ctl::string s;
+        s.append("hello ");
+        s.append("world");
+    });
+
+    BENCHMARK(ITERATIONS, 8, {
+        ctl::string s;
+        for (int i = 0; i < 8; ++i) {
+            s.append('a');
+        }
+    });
+
+    BENCHMARK(ITERATIONS, 16, {
+        ctl::string s;
+        for (int i = 0; i < 16; ++i) {
+            s.append('a');
+        }
+    });
+
+    BENCHMARK(ITERATIONS, 23, {
+        ctl::string s;
+        for (int i = 0; i < 23; ++i) {
+            s.append('a');
+        }
+    });
+
+    BENCHMARK(ITERATIONS, 24, {
+        ctl::string s;
+        for (int i = 0; i < 24; ++i) {
+            s.append('a');
+        }
+    });
+
+    BENCHMARK(ITERATIONS, 32, {
+        ctl::string s;
+        for (int i = 0; i < 32; ++i) {
+            s.append('a');
+        }
+    });
+
+    BENCHMARK(ITERATIONS, 1, { ctl::string s(small_c); });
+
+    BENCHMARK(ITERATIONS, 1, { ctl::string s(small); });
+
+    {
+        ctl::string small_copy("hello world");
+        BENCHMARK(ITERATIONS, 1, { ctl::string s2(small_copy); });
+    }
+
+    BENCHMARK(ITERATIONS, 1, {
+        ctl::string s(small);
+        ctl::string s2(ctl::move(s));
+    });
+
+    BENCHMARK(ITERATIONS, 1, {
+        ctl::string s(small);
+        ctl::string s2(s);
+    });
+
+    BENCHMARK(ITERATIONS, 1, { ctl::string s(big_c); });
+
+    BENCHMARK(ITERATIONS, 1, { ctl::string s(big); });
+
+    {
+        ctl::string big_copy(big);
+        BENCHMARK(ITERATIONS, 1, { ctl::string s2(big_copy); });
+    }
+
+    BENCHMARK(ITERATIONS, 1, {
+        ctl::string s(big);
+        ctl::string s2(ctl::move(s));
+    });
+
+    BENCHMARK(ITERATIONS, 1, {
+        ctl::string s(big);
+        ctl::string s2(s);
+    });
+
+    BENCHMARK(ITERATIONS, 1, { ctl::string s(23, 'a'); });
+
+    BENCHMARK(ITERATIONS, 1, { ctl::string s(24, 'a'); });
+
+    {
+        ctl::string s(5, 'a');
+        BENCHMARK(ITERATIONS, 1, { ctl::string_view s2(s); });
+    }
+
+    {
+        ctl::string big_trunc(48, 'a');
+        big_trunc.resize(4);
+        BENCHMARK(ITERATIONS, 1, { ctl::string s(big_trunc); });
+    }
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/string_test.cc b/test/ctl/string_test.cc
index 7e7cb3f32..6319a82da 100644
--- a/test/ctl/string_test.cc
+++ b/test/ctl/string_test.cc
@@ -16,14 +16,14 @@
 // TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 // PERFORMANCE OF THIS SOFTWARE.
 
+#include "ctl/is_same.h"
 #include "ctl/string.h"
 #include "libc/mem/leaks.h"
 
-#include <__type_traits/is_same.h>
-
 #include "libc/str/str.h"
 
 // #include <string>
+// #include <utility>
 // #define ctl std
 
 using String = ctl::string;
@@ -366,7 +366,7 @@ main()
 
     {
         String s;
-        if constexpr (std::is_same_v<ctl::string, decltype(s)>) {
+        if constexpr (ctl::is_same_v<ctl::string, decltype(s)>) {
             // tests the small-string optimization on ctl::string
             for (int i = 0; i < 23; ++i) {
                 s.append("a");
@@ -397,13 +397,76 @@ main()
         s.resize(4);
         if (s != "arst")
             return 105;
-        if constexpr (std::is_same_v<ctl::string, decltype(s)>) {
+        if constexpr (ctl::is_same_v<ctl::string, decltype(s)>) {
             String r(s);
             if (issmall(s) || !issmall(r))
                 return 106;
         }
     }
 
+    {
+        String s = "love";
+        String b;
+        b.append(s, 1, 2);
+        if (b != "ov")
+            return 107;
+    }
+
+    {
+        String s = "ee";
+        if (s.find_last_of('E') != String::npos)
+            return 108;
+        if (s.find_last_of('e') != 1)
+            return 109;
+    }
+
+    {
+        String e = "";
+        String s = "ee";
+        if (e.find_last_of("") != String::npos)
+            return 110;
+        if (s.find_last_of("") != String::npos)
+            return 111;
+        if (s.find_last_of("AE") != String::npos)
+            return 112;
+        if (s.find_last_of("ae") != 1)
+            return 113;
+        if (s.find_last_of("ae", 1) != 1)
+            return 114;
+        if (s.find_last_of("ae", 0) != 0)
+            return 115;
+        if (s.find_last_of("ae", 10) != 1)
+            return 116;
+    }
+
+    {
+        String s = "ee";
+        if (s.find_first_of('E') != String::npos)
+            return 117;
+        if (s.find_first_of('e') != 0)
+            return 118;
+        if (s.find_first_of('e', 1) != 1)
+            return 119;
+    }
+
+    {
+        String e = "";
+        String s = "ee";
+        if (e.find_first_of("") != String::npos)
+            return 120;
+        if (s.find_first_of("") != String::npos)
+            return 121;
+        if (s.find_first_of("AE") != String::npos)
+            return 122;
+        if (s.find_first_of("ae") != 0)
+            return 123;
+        if (s.find_first_of("ae", 1) != 1)
+            return 124;
+        if (s.find_first_of("ae", 0) != 0)
+            return 125;
+        if (s.find_first_of("ae", 10) != String::npos)
+            return 126;
+    }
+
     CheckForMemoryLeaks();
-    return 0;
 }
diff --git a/test/ctl/string_view_test.cc b/test/ctl/string_view_test.cc
index 8ca1f8bee..a371fdfb5 100644
--- a/test/ctl/string_view_test.cc
+++ b/test/ctl/string_view_test.cc
@@ -16,6 +16,7 @@
 // TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 // PERFORMANCE OF THIS SOFTWARE.
 
+#include "ctl/string.h"
 #include "ctl/string_view.h"
 #include "libc/mem/leaks.h"
 #include "libc/str/str.h"
@@ -172,6 +173,70 @@ main(int argc, char* argv[])
             return 32;
     }
 
+    {
+        ctl::string b;
+        const ctl::string_view s = "hi";
+        for (char c : s)
+            b += c;
+        if (b != "hi")
+            return 2;
+    }
+
+    {
+        ctl::string_view s = "ee";
+        if (s.find_last_of('E') != ctl::string_view::npos)
+            return 108;
+        if (s.find_last_of('e') != 1)
+            return 109;
+    }
+
+    {
+        ctl::string_view e = "";
+        ctl::string_view s = "ee";
+        if (e.find_last_of("") != ctl::string_view::npos)
+            return 110;
+        if (s.find_last_of("") != ctl::string_view::npos)
+            return 111;
+        if (s.find_last_of("AE") != ctl::string_view::npos)
+            return 112;
+        if (s.find_last_of("ae") != 1)
+            return 113;
+        if (s.find_last_of("ae", 1) != 1)
+            return 114;
+        if (s.find_last_of("ae", 0) != 0)
+            return 115;
+        if (s.find_last_of("ae", 10) != 1)
+            return 116;
+    }
+
+    {
+        ctl::string_view s = "ee";
+        if (s.find_first_of('E') != ctl::string_view::npos)
+            return 117;
+        if (s.find_first_of('e') != 0)
+            return 118;
+        if (s.find_first_of('e', 1) != 1)
+            return 119;
+    }
+
+    {
+        ctl::string_view e = "";
+        ctl::string_view s = "ee";
+        if (e.find_first_of("") != ctl::string_view::npos)
+            return 120;
+        if (s.find_first_of("") != ctl::string_view::npos)
+            return 121;
+        if (s.find_first_of("AE") != ctl::string_view::npos)
+            return 122;
+        if (s.find_first_of("ae") != 0)
+            return 123;
+        if (s.find_first_of("ae", 1) != 1)
+            return 124;
+        if (s.find_first_of("ae", 0) != 0)
+            return 125;
+        if (s.find_first_of("ae", 10) != ctl::string_view::npos)
+            return 126;
+    }
+
     CheckForMemoryLeaks();
-    return 0;
 }
diff --git a/test/ctl/to_string_test.cc b/test/ctl/to_string_test.cc
new file mode 100644
index 000000000..8970d0a0f
--- /dev/null
+++ b/test/ctl/to_string_test.cc
@@ -0,0 +1,128 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/string.h"
+#include "libc/limits.h"
+#include "libc/math.h"
+#include "libc/mem/leaks.h"
+
+int
+main()
+{
+
+    // test integer conversion
+    {
+        if (ctl::to_string(0) != "0")
+            return 1;
+        if (ctl::to_string(3) != "3")
+            return 1;
+        if (ctl::to_string(INT32_MAX) != "2147483647")
+            return 2;
+        if (ctl::to_string(INT32_MIN) != "-2147483648")
+            return 3;
+        if (ctl::to_string(UINT32_MAX) != "4294967295")
+            return 4;
+        if (ctl::to_string(INT64_MAX) != "9223372036854775807")
+            return 5;
+        if (ctl::to_string(INT64_MIN) != "-9223372036854775808")
+            return 6;
+        if (ctl::to_string(UINT64_MAX) != "18446744073709551615")
+            return 7;
+    }
+
+    // test float conversion
+    // we diverge from std::to_string(float) because it's garbage
+    {
+        if (ctl::to_string(0.f) != "0") // 0.000000
+            return 8;
+        if (ctl::to_string(-0.f) != "-0") // 0.000000
+            return 9;
+        if (ctl::to_string(3.f) != "3") // 3.000000
+            return 10;
+        if (ctl::to_string(3.14f) != "3.14") // 3.140000
+            return 11;
+        if (ctl::to_string(3.140001f) != "3.140001")
+            return 12;
+        if (ctl::to_string(1000000000.f) != "1000000000") // 1000000000.000000
+            return 12;
+        if (ctl::to_string(10000000000.f) != "1e+10") // 10000000000.000000
+            return 12;
+        if (ctl::to_string(NAN) != "nan")
+            return 13;
+        if (ctl::to_string(INFINITY) != "inf")
+            return 14;
+        if (ctl::to_string(-INFINITY) != "-inf")
+            return 15;
+        if (ctl::to_string(FLT_MIN) != "1.1754944e-38") // 0.000000 lool
+            return 16;
+        if (ctl::to_string(-FLT_MIN) != "-1.1754944e-38")
+            return 17;
+        if (ctl::to_string(FLT_MAX) != "3.4028235e+38")
+            return 18;
+        if (ctl::to_string(-FLT_MAX) != "-3.4028235e+38")
+            return 19;
+    }
+
+    // test double conversion
+    {
+        if (ctl::to_string(0.) != "0")
+            return 20;
+        if (ctl::to_string(-0.) != "-0")
+            return 21;
+        if (ctl::to_string(3.) != "3")
+            return 22;
+        if (ctl::to_string(2147483647.) != "2147483647")
+            return 23;
+        if (ctl::to_string(-2147483648.) != "-2147483648")
+            return 23;
+        if (ctl::to_string(10000000000.) != "1e+10")
+            return 23;
+        if (ctl::to_string(3.14) != "3.14")
+            return 23;
+        if (ctl::to_string(3.140001) != "3.140001")
+            return 24;
+        if (ctl::to_string(DBL_MIN) != "2.2250738585072014e-308")
+            return 25;
+        if (ctl::to_string(-DBL_MIN) != "-2.2250738585072014e-308")
+            return 26;
+        if (ctl::to_string(DBL_MAX) != "1.7976931348623157e+308")
+            return 27;
+        if (ctl::to_string(-DBL_MAX) != "-1.7976931348623157e+308")
+            return 28;
+    }
+
+    // test long double conversion
+    {
+        if (ctl::to_string(0.L) != "0")
+            return 29;
+        if (ctl::to_string(-0.L) != "-0")
+            return 30;
+        if (ctl::to_string(3.L) != "3")
+            return 31;
+        if (ctl::to_string(3.14L) != "3.14")
+            return 32;
+#if LDBL_MANT_DIG > 64
+        if (ctl::to_string(LDBL_MAX) != "1.189731495357232e+4932")
+            return 33;
+        if (ctl::to_string(-LDBL_MAX) != "-1.189731495357232e+4932")
+            return 34;
+#endif
+    }
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/tuple_test.cc b/test/ctl/tuple_test.cc
new file mode 100644
index 000000000..0a3da6c6f
--- /dev/null
+++ b/test/ctl/tuple_test.cc
@@ -0,0 +1,161 @@
+// -*- mode:c++; indent-tabs-mode:nil; c-basic-offset:4; coding:utf-8 -*-
+// vi: set et ft=cpp ts=4 sts=4 sw=4 fenc=utf-8 :vi
+//
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "ctl/string.h"
+#include "ctl/tuple.h"
+#include "libc/mem/leaks.h"
+
+// #include <string>
+// #include <tuple>
+// #define ctl std
+
+int
+test_tuple_creation()
+{
+    ctl::tuple<int, double, ctl::string> t(1, 2.5, "hello");
+    if (ctl::get<0>(t) != 1 || ctl::get<1>(t) != 2.5 ||
+        ctl::get<2>(t) != "hello") {
+        return 1;
+    }
+    return 0;
+}
+
+int
+test_make_tuple()
+{
+    auto t = ctl::make_tuple(1, 2.5, ctl::string("hello"));
+    if (ctl::get<0>(t) != 1 || ctl::get<1>(t) != 2.5 ||
+        ctl::get<2>(t) != "hello") {
+        return 2;
+    }
+    return 0;
+}
+
+int
+test_tuple_get()
+{
+    ctl::tuple<int, double, ctl::string> t(1, 2.5, "hello");
+    if (ctl::get<0>(t) != 1)
+        return 3;
+    if (ctl::get<1>(t) != 2.5)
+        return 4;
+    if (ctl::get<2>(t) != "hello")
+        return 5;
+    return 0;
+}
+
+int
+test_tuple_comparison()
+{
+    auto t1 = ctl::make_tuple(1, 2.5, "hello");
+    auto t2 = ctl::make_tuple(1, 2.5, "hello");
+    auto t3 = ctl::make_tuple(2, 3.5, "world");
+
+    if (!(t1 == t2))
+        return 6;
+    if (t1 != t2)
+        return 7;
+    if (t1 == t3)
+        return 8;
+    if (!(t1 != t3))
+        return 9;
+
+    return 0;
+}
+
+int
+test_tuple_assignment()
+{
+    ctl::tuple<int, double, ctl::string> t1(1, 2.5, "hello");
+    ctl::tuple<int, double, ctl::string> t2;
+    t2 = t1;
+    if (!(t1 == t2))
+        return 10;
+    return 0;
+}
+
+int
+test_tuple_move()
+{
+    ctl::tuple<int, double, ctl::string> t1(1, 2.5, "hello");
+    ctl::tuple<int, double, ctl::string> t2(ctl::move(t1));
+    if (ctl::get<0>(t2) != 1 || ctl::get<1>(t2) != 2.5 ||
+        ctl::get<2>(t2) != "hello") {
+        return 11;
+    }
+    return 0;
+}
+
+int
+test_empty_tuple()
+{
+    ctl::tuple<> t;
+    ctl::tuple<> t2;
+    if (!(t == t2))
+        return 12;
+    return 0;
+}
+
+int
+test_single_element_tuple()
+{
+    ctl::tuple<int> t(42);
+    if (ctl::get<0>(t) != 42)
+        return 13;
+    return 0;
+}
+
+int
+main()
+{
+    int result;
+
+    result = test_tuple_creation();
+    if (result != 0)
+        return result;
+
+    result = test_make_tuple();
+    if (result != 0)
+        return result;
+
+    result = test_tuple_get();
+    if (result != 0)
+        return result;
+
+    result = test_tuple_comparison();
+    if (result != 0)
+        return result;
+
+    result = test_tuple_assignment();
+    if (result != 0)
+        return result;
+
+    result = test_tuple_move();
+    if (result != 0)
+        return result;
+
+    result = test_empty_tuple();
+    if (result != 0)
+        return result;
+
+    result = test_single_element_tuple();
+    if (result != 0)
+        return result;
+
+    CheckForMemoryLeaks();
+}
diff --git a/test/ctl/unique_ptr_test.cc b/test/ctl/unique_ptr_test.cc
index 4f83de945..239902b83 100644
--- a/test/ctl/unique_ptr_test.cc
+++ b/test/ctl/unique_ptr_test.cc
@@ -16,78 +16,64 @@
 // TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 // PERFORMANCE OF THIS SOFTWARE.
 
+#include "ctl/is_same.h"
 #include "ctl/unique_ptr.h"
-
-#include <__type_traits/is_same.h>
+#include "libc/mem/leaks.h"
 
 // #include <memory>
+// #include <type_traits>
 // #define ctl std
 
-template<typename T, typename D = ctl::default_delete<T>>
-using Ptr = ctl::unique_ptr<T, D>;
-
-template<typename T, typename... Args>
-Ptr<T>
-Mk(Args&&... args)
-{
-    return ctl::make_unique<T, Args...>(ctl::forward<Args>(args)...);
-}
-
-template<typename T>
-Ptr<T>
-MkRaw()
-{
-    return ctl::make_unique_for_overwrite<T>();
-}
+using ctl::unique_ptr;
+using ctl::make_unique;
+using ctl::make_unique_for_overwrite;
 
 #undef ctl
 
+// The following few definitions are used to get observability into aspects of
+// an object's lifecycle, to make sure that e.g. constructing a unique_ptr of a
+// type does not construct an object, and that make_unique does construct an
+// object.
 static int g = 0;
 
-struct SetsGDeleter
+struct ConstructG
 {
-    void operator()(auto*) const noexcept
+    ConstructG()
     {
         ++g;
     }
 };
 
-struct StatefulDeleter
+struct DestructG
 {
-    char state;
-    void operator()(auto*) const noexcept
+    ~DestructG()
     {
+        ++g;
     }
 };
 
+struct CallG
+{
+    void operator()(auto* x) const noexcept
+    {
+        ++g;
+    }
+};
+
+// A unique_ptr with an empty deleter should be the same size as a raw pointer.
+static_assert(sizeof(unique_ptr<int, decltype([] {})>) == sizeof(int*));
+
 struct FinalDeleter final
 {
-    void operator()(auto*) const noexcept
+    void operator()(auto* x) const noexcept
     {
     }
 };
 
-static_assert(sizeof(Ptr<int, SetsGDeleter>) == sizeof(int*));
-
-// not everyone uses [[no_unique_address]]...
-static_assert(!std::is_same_v<Ptr<int>, ctl::unique_ptr<int>> ||
-              sizeof(Ptr<int, FinalDeleter>) == sizeof(int*));
-
-struct SetsGCtor
-{
-    SetsGCtor()
-    {
-        ++g;
-    }
-};
-
-struct SetsGDtor
-{
-    ~SetsGDtor()
-    {
-        ++g;
-    }
-};
+// ctl::unique_ptr does not need to inherit from its deleter for this property;
+// the STL often does, though, so we don't hold them to the following.
+static_assert(!ctl::is_same_v<unique_ptr<int>, ctl::unique_ptr<int>> ||
+              sizeof(unique_ptr<int, FinalDeleter>) == sizeof(int*));
 
 struct Base
 {};
@@ -98,12 +84,16 @@ struct Derived : Base
 int
 main()
 {
+    int a;
+
     {
-        Ptr<int> x(new int(5));
+        // Shouldn't cause any memory leaks.
+        unique_ptr<int> x(new int(5));
     }
 
     {
-        Ptr<int, SetsGDeleter> x(new int());
+        // Deleter is called if the pointer is non-null when reset.
+        unique_ptr<int, CallG> x(&a);
         x.reset();
         if (g != 1)
             return 1;
@@ -111,22 +101,45 @@ main()
 
     {
         g = 0;
-        Ptr<int, SetsGDeleter> x(new int());
-        delete x.release();
+        // Deleter is not called if the pointer is null when reset.
+        unique_ptr<int, CallG> x(&a);
+        x.release();
         x.reset();
         if (g)
             return 17;
     }
 
     {
-        Ptr<int> x(new int(5)), y(new int(6));
+        g = 0;
+        // Deleter is called when the pointer goes out of scope.
+        {
+            unique_ptr<int, CallG> x(&a);
+        }
+        if (!g)
+            return 18;
+    }
+
+    {
+        g = 0;
+        // Deleter is called if scope ends exceptionally.
+        try {
+            unique_ptr<int, CallG> x(&a);
+            throw 'a';
+        } catch (char) {
+        }
+        if (!g)
+            return 19;
+    }
+
+    {
+        unique_ptr<int> x(new int(5)), y(new int(6));
         x.swap(y);
         if (*x != 6 || *y != 5)
             return 2;
     }
 
     {
-        Ptr<int> x;
+        unique_ptr<int> x;
         if (x)
             return 3;
         x.reset(new int(5));
@@ -136,17 +149,17 @@ main()
 
     {
         g = 0;
-        Ptr<SetsGCtor> x;
+        unique_ptr<ConstructG> x;
         if (g)
             return 5;
-        x = Mk<SetsGCtor>();
+        x = make_unique<ConstructG>();
         if (g != 1)
             return 6;
     }
 
     {
         g = 0;
-        auto x = Mk<SetsGDtor>();
+        auto x = make_unique<DestructG>();
         if (g)
             return 7;
         x.reset();
@@ -158,9 +171,9 @@ main()
 
     {
         g = 0;
-        Ptr<SetsGDtor> x, y;
-        x = Mk<SetsGDtor>();
-        y = Mk<SetsGDtor>();
+        unique_ptr<DestructG> x, y;
+        x = make_unique<DestructG>();
+        y = make_unique<DestructG>();
 #if 0
         // shouldn't compile
         x = y;
@@ -175,7 +188,7 @@ main()
     {
         g = 0;
         {
-            auto x = Mk<SetsGDtor>();
+            auto x = make_unique<DestructG>();
         }
         if (g != 1)
             return 12;
@@ -184,10 +197,10 @@ main()
     {
         g = 0;
         {
-            auto x = Mk<SetsGDtor>();
-            x.release();
+            auto x = make_unique<DestructG>();
+            delete x.release();
         }
-        if (g)
+        if (g != 1)
             return 13;
     }
 
@@ -196,13 +209,13 @@ main()
     // side effects it has are illegal to detect?
     {
         g = 0;
-        auto x = MkRaw<DefaultInitialized>();
+        auto x = make_unique_for_overwrite<DefaultInitialized>();
         if (g)
             return 14;
         x.reset();
         if (g)
             return 15;
-        x = Mk<DefaultInitialized>();
+        x = make_unique<DefaultInitialized>();
         if (g != 1)
             return 16;
     }
@@ -211,22 +224,16 @@ main()
     {
         int a;
         // Should compile.
-        Ptr<int, FinalDeleter> x(&a);
-        Ptr<int, StatefulDeleter> y(&a);
+        unique_ptr<int, FinalDeleter> x(&a);
     }
 
     {
-        Ptr<Base> x(new Base);
+        unique_ptr<Base> x(new Base);
         x.reset(new Derived);
 
-        Ptr<Derived> y(new Derived);
-        Ptr<Base> z(ctl::move(y));
+        unique_ptr<Derived> y(new Derived);
+        unique_ptr<Base> z(ctl::move(y));
     }
 
-    // next is 18
-
-    // TODO(mrdomino): Fix memory leaks reported by MODE=dbg
-    // CheckForMemoryLeaks();
-
-    return 0;
+    CheckForMemoryLeaks();
 }
diff --git a/test/ctl/vector_test.cc b/test/ctl/vector_test.cc
index aa70cb21d..d114c5445 100644
--- a/test/ctl/vector_test.cc
+++ b/test/ctl/vector_test.cc
@@ -16,17 +16,54 @@
 // TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 // PERFORMANCE OF THIS SOFTWARE.
 
+#include "ctl/string.h"
 #include "ctl/vector.h"
 #include "libc/mem/leaks.h"
 
-#include <cosmo.h>
-
-#include "ctl/string.h"
-
 // #include <string>
 // #include <vector>
 // #define ctl std
 
+static int counter;
+
+// Test with non-trivial type
+struct NonTrivial
+{
+    int value;
+
+    NonTrivial(int v) : value(v)
+    {
+        ++counter;
+    }
+
+    NonTrivial(const NonTrivial& other) : value(other.value)
+    {
+        ++counter;
+    }
+
+    NonTrivial(NonTrivial&& other) noexcept : value(other.value)
+    {
+        ++counter;
+    }
+
+    ~NonTrivial()
+    {
+        --counter;
+    }
+
+    NonTrivial& operator=(const NonTrivial& other)
+    {
+        value = other.value;
+        return *this;
+    }
+
+    NonTrivial& operator=(NonTrivial&& other) noexcept
+    {
+        value = other.value;
+        return *this;
+    }
+};
+
 int
 main()
 {
@@ -315,6 +352,104 @@ main()
             return 69;
     }
 
+    {
+        ctl::vector<int> A = { 1, 2, 3 };
+        if (A[1] != 2)
+            return 70;
+        A = { 4, 5, 6 };
+        if (A[1] != 5)
+            return 71;
+    }
+
+    {
+        ctl::vector<int> arr = { 1, 2, 3 };
+        auto rit = arr.rbegin();
+        if (*rit != 3)
+            return 72;
+        ++rit;
+        if (*rit != 2)
+            return 73;
+        ++rit;
+        if (*rit != 1)
+            return 74;
+        ++rit;
+        if (rit != arr.rend())
+            return 75;
+    }
+
+    {
+        ctl::vector<ctl::string> A = { "hi", "theretheretheretherethere" };
+        if (A.size() != 2)
+            return 76;
+        if (A[0] != "hi")
+            return 77;
+        if (A[1] != "theretheretheretherethere")
+            return 78;
+        A = { "theretheretheretherethere", "hi" };
+        if (A[0] != "theretheretheretherethere")
+            return 79;
+        if (A[1] != "hi")
+            return 80;
+    }
+
+    {
+        ctl::vector<int> dog(8, 0);
+        if (dog.size() != 8)
+            return 81;
+        if (dog[0] != 0)
+            return 82;
+    }
+
+    // Test erase(const_iterator first, const_iterator last)
+    {
+        ctl::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+
+        // Test erasing from the middle
+        auto it = v.erase(v.begin() + 3, v.begin() + 7);
+        if (v.size() != 6 || v != ctl::vector<int>{ 1, 2, 3, 8, 9, 10 } ||
+            it != v.begin() + 3)
+            return 83;
+
+        // Test erasing from the beginning
+        it = v.erase(v.begin(), v.begin() + 2);
+        if (v.size() != 4 || v != ctl::vector<int>{ 3, 8, 9, 10 } ||
+            it != v.begin())
+            return 84;
+
+        // Test erasing to the end
+        it = v.erase(v.begin() + 2, v.end());
+        if (v.size() != 2 || v != ctl::vector<int>{ 3, 8 } || it != v.end())
+            return 85;
+
+        // Test erasing all elements
+        it = v.erase(v.begin(), v.end());
+        if (!v.empty() || it != v.end())
+            return 86;
+
+        // Test erasing empty range
+        v = { 1, 2, 3, 4, 5 };
+        it = v.erase(v.begin() + 2, v.begin() + 2);
+        if (v.size() != 5 || v != ctl::vector<int>{ 1, 2, 3, 4, 5 } ||
+            it != v.begin() + 2)
+            return 87;
+
+        counter = 0;
+
+        {
+            ctl::vector<NonTrivial> v2;
+            for (int i = 0; i < 10; ++i)
+                v2.emplace_back(i);
+            v2.erase(v2.begin() + 3, v2.begin() + 7);
+            if (v2.size() != 6 || counter != 6)
+                return 89;
+            for (int i = 0; i < (int)v2.size(); ++i)
+                if (v2[i].value != (i < 3 ? i : i + 4))
+                    return 90;
+        }
+
+        if (counter != 0)
+            return 91;
+    }
+
     CheckForMemoryLeaks();
-    return 0;
 }
diff --git a/test/dsp/core/alaw_test.c b/test/dsp/core/alaw_test.c
index ec434c8da..5f91bf176 100644
--- a/test/dsp/core/alaw_test.c
+++ b/test/dsp/core/alaw_test.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/core.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/testlib/ezbench.h"
diff --git a/test/dsp/core/getintegercoefficients_test.c b/test/dsp/core/getintegercoefficients_test.c
index 4fa0e3009..ec7cd03e3 100644
--- a/test/dsp/core/getintegercoefficients_test.c
+++ b/test/dsp/core/getintegercoefficients_test.c
@@ -19,7 +19,7 @@
 #include "dsp/core/core.h"
 #include "dsp/core/q.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/str/str.h"
 #include "libc/testlib/ezbench.h"
diff --git a/test/dsp/core/mulaw_test.c b/test/dsp/core/mulaw_test.c
index f19eda5c9..d2c0f2863 100644
--- a/test/dsp/core/mulaw_test.c
+++ b/test/dsp/core/mulaw_test.c
@@ -19,7 +19,7 @@
 #include "dsp/core/core.h"
 #include "dsp/core/ituround.h"
 #include "libc/assert.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
diff --git a/test/dsp/core/scalevolume_test.c b/test/dsp/core/scalevolume_test.c
index 3940a7055..a6247fc54 100644
--- a/test/dsp/core/scalevolume_test.c
+++ b/test/dsp/core/scalevolume_test.c
@@ -17,10 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/core.h"
-#include "dsp/mpeg/mpeg.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/stdio/rand.h"
 #include "libc/testlib/ezbench.h"
diff --git a/test/dsp/scale/scale_test.c b/test/dsp/scale/scale_test.c
index be2ae9d6e..b43368f43 100644
--- a/test/dsp/scale/scale_test.c
+++ b/test/dsp/scale/scale_test.c
@@ -22,7 +22,7 @@
 #include "dsp/core/core.h"
 #include "dsp/core/half.h"
 #include "libc/fmt/bing.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/stdio.h"
diff --git a/test/libc/calls/cachestat_test.c b/test/libc/calls/cachestat_test.c
index a24b6e490..8f91781f6 100644
--- a/test/libc/calls/cachestat_test.c
+++ b/test/libc/calls/cachestat_test.c
@@ -24,11 +24,12 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/sysconf.h"
 #include "libc/stdio/rand.h"
+#include "libc/stdio/stdio.h"
 #include "libc/sysv/consts/auxv.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/testlib/testlib.h"
@@ -46,10 +47,13 @@ void SetUpOnce(void) {
     exit(0);
   }
   testlib_enable_tmp_setup_teardown();
-  pagesize = (size_t)getauxval(AT_PAGESZ);
+  pagesize = (size_t)getpagesize();
   // ASSERT_SYS(0, 0, pledge("stdio rpath wpath cpath", 0));
 }
 
+// TODO(jart): fix this test
+#if 0
+
 TEST(cachestat, testCachestatOnDevices) {
   const char *const files[] = {
       "/dev/zero", "/dev/null", "/dev/urandom", "/proc/version", "/proc",
@@ -63,6 +67,8 @@ TEST(cachestat, testCachestatOnDevices) {
   }
 }
 
+#endif
+
 TEST(cachestat, testCachestatAfterWrite) {
   size_t size = 4 * pagesize;
   char *data = gc(xmalloc(size));
@@ -104,12 +110,14 @@ done:
 }
 
 TEST(cachestat, testCachestatShmem) {
+  char name[64];
+  sprintf(name, "/cachestat_test-%ld", _rand64());
   size_t filesize = 512 * 2 * pagesize;  // 2 2MB huge pages.
   size_t compute_len = 512 * pagesize;
   unsigned long num_pages = compute_len / pagesize;
   char *data = gc(xmalloc(filesize));
   ASSERT_SYS(0, filesize, getrandom(data, filesize, 0));
-  ASSERT_SYS(0, 3, shm_open("tmpshmcstat", O_CREAT | O_RDWR, 0600));
+  ASSERT_SYS(0, 3, shm_open(name, O_CREAT | O_RDWR, 0600));
   ASSERT_SYS(0, 0, ftruncate(3, filesize));
   ASSERT_SYS(0, filesize, write(3, data, filesize));
   struct cachestat_range range = {pagesize, compute_len};
@@ -117,6 +125,6 @@ TEST(cachestat, testCachestatShmem) {
   ASSERT_SYS(0, 0, cachestat(3, &range, &cs, 0));
   ASSERT_EQ(num_pages, cs.nr_cache + cs.nr_evicted,
             "total number of cached and evicted pages is off.\n");
-  ASSERT_SYS(0, 0, shm_unlink("tmpshmcstat"));
+  ASSERT_SYS(0, 0, shm_unlink(name));
   ASSERT_SYS(0, 0, close(3));
 }
diff --git a/test/libc/calls/clock_getres_test.c b/test/libc/calls/clock_getres_test.c
index ad296e319..27aa3a447 100644
--- a/test/libc/calls/clock_getres_test.c
+++ b/test/libc/calls/clock_getres_test.c
@@ -32,13 +32,6 @@ TEST(clock_getres, realtimeHasMillisecondPrecisionOrBetter) {
   EXPECT_GT(ts.tv_nsec, 0);
 }
 
-TEST(clock_getres, realtimeFastHasMillisecondPrecisionOrBetter) {
-  ASSERT_EQ(0, clock_getres(CLOCK_REALTIME_FAST, &ts));
-  EXPECT_EQ(0, ts.tv_sec);
-  EXPECT_LT(ts.tv_nsec, 1000000);
-  EXPECT_GT(ts.tv_nsec, 0);
-}
-
 TEST(clock_getres, realtimeCoarseHasMillisecondPrecisionOrBetter) {
   if (clock_getres(CLOCK_REALTIME_COARSE, &ts))
     return;
@@ -47,14 +40,6 @@ TEST(clock_getres, realtimeCoarseHasMillisecondPrecisionOrBetter) {
   EXPECT_GT(ts.tv_nsec, 0);
 }
 
-TEST(clock_getres, realtimePreciseHasMillisecondPrecisionOrBetter) {
-  if (clock_getres(CLOCK_REALTIME_PRECISE, &ts))
-    return;
-  EXPECT_EQ(0, ts.tv_sec);
-  EXPECT_LT(ts.tv_nsec, 100000000);
-  EXPECT_GT(ts.tv_nsec, 0);
-}
-
 TEST(clock_getres, monotonicHasMillisecondPrecisionOrBetter) {
   ASSERT_EQ(0, clock_getres(CLOCK_MONOTONIC, &ts));
   EXPECT_EQ(0, ts.tv_sec);
@@ -62,13 +47,6 @@ TEST(clock_getres, monotonicHasMillisecondPrecisionOrBetter) {
   EXPECT_GT(ts.tv_nsec, 0);
 }
 
-TEST(clock_getres, monotonicFastHasMillisecondPrecisionOrBetter) {
-  ASSERT_EQ(0, clock_getres(CLOCK_MONOTONIC_FAST, &ts));
-  EXPECT_EQ(0, ts.tv_sec);
-  EXPECT_LT(ts.tv_nsec, 1000000);
-  EXPECT_GT(ts.tv_nsec, 0);
-}
-
 TEST(clock_getres, monotonicCoarseHasMillisecondPrecisionOrBetter) {
   if (clock_getres(CLOCK_MONOTONIC_COARSE, &ts))
     return;
@@ -76,11 +54,3 @@ TEST(clock_getres, monotonicCoarseHasMillisecondPrecisionOrBetter) {
   EXPECT_LT(ts.tv_nsec, 100000000);
   EXPECT_GT(ts.tv_nsec, 0);
 }
-
-TEST(clock_getres, monotonicPreciseHasMillisecondPrecisionOrBetter) {
-  if (clock_getres(CLOCK_MONOTONIC_PRECISE, &ts))
-    return;
-  EXPECT_EQ(0, ts.tv_sec);
-  EXPECT_LT(ts.tv_nsec, 100000000);
-  EXPECT_GT(ts.tv_nsec, 0);
-}
diff --git a/test/libc/calls/clock_gettime_test.c b/test/libc/calls/clock_gettime_test.c
index c86a92abf..4c76c4d8a 100644
--- a/test/libc/calls/clock_gettime_test.c
+++ b/test/libc/calls/clock_gettime_test.c
@@ -16,20 +16,13 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/internal.h"
 #include "libc/calls/struct/timespec.h"
-#include "libc/calls/struct/timespec.internal.h"
 #include "libc/calls/struct/timeval.h"
-#include "libc/calls/syscall_support-sysv.internal.h"
-#include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/nexgen32e/rdtsc.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sysv/consts/auxv.h"
+#include "libc/macros.h"
 #include "libc/sysv/consts/clock.h"
-#include "libc/testlib/ezbench.h"
+#include "libc/testlib/benchmark.h"
 #include "libc/testlib/testlib.h"
-#include "libc/time.h"
 
 TEST(clock_gettime, nullResult_validatesClockParam) {
   ASSERT_SYS(EINVAL, -1, clock_gettime(666, 0));
@@ -51,26 +44,19 @@ TEST(clock_gettime, testClockRealtime) {
 }
 
 TEST(clock_gettime, bench) {
-  struct timeval tv;
   struct timespec ts;
-  gettimeofday(&tv, 0);   // trigger init
-  clock_gettime(0, &ts);  // trigger init
-  EZBENCH2("rdtsc", donothing, rdtsc());
-  EZBENCH2("clock_gettime(mono)", donothing,
-           clock_gettime(CLOCK_MONOTONIC_FAST, &ts));
-  EZBENCH2("clock_gettime(real)", donothing,
-           clock_gettime(CLOCK_REALTIME_FAST, &ts));
-  EZBENCH2("timespec_real", donothing, timespec_real());
-  EZBENCH2("gettimeofday", donothing, gettimeofday(&tv, 0));
-  if (IsWindows()) {
-    EZBENCH2("sys_clock_gettime r", donothing,
-             sys_clock_gettime_nt(CLOCK_REALTIME_FAST, &ts));
-    EZBENCH2("sys_clock_gettime m", donothing,
-             sys_clock_gettime_nt(CLOCK_MONOTONIC_FAST, &ts));
-  } else {
-    EZBENCH2("sys_clock_gettime r", donothing,
-             sys_clock_gettime(CLOCK_REALTIME_FAST, &ts));
-    EZBENCH2("sys_clock_gettime m", donothing,
-             sys_clock_gettime(CLOCK_MONOTONIC_FAST, &ts));
-  }
+  BENCHMARK(1, 1, timespec_real());
+  BENCHMARK(1000, 1, timespec_real());
+  if (!clock_gettime(CLOCK_REALTIME, 0))
+    BENCHMARK(1000, 1, clock_gettime(CLOCK_REALTIME, &ts));
+  if (!clock_gettime(CLOCK_REALTIME_COARSE, 0))
+    BENCHMARK(1000, 1, clock_gettime(CLOCK_REALTIME_COARSE, &ts));
+  if (!clock_gettime(CLOCK_MONOTONIC, 0))
+    BENCHMARK(1000, 1, clock_gettime(CLOCK_MONOTONIC, &ts));
+  if (!clock_gettime(CLOCK_MONOTONIC_COARSE, 0))
+    BENCHMARK(1000, 1, clock_gettime(CLOCK_MONOTONIC_COARSE, &ts));
+  if (!clock_gettime(CLOCK_MONOTONIC_RAW, 0))
+    BENCHMARK(1000, 1, clock_gettime(CLOCK_MONOTONIC_RAW, &ts));
+  if (!clock_gettime(CLOCK_BOOTTIME, 0))
+    BENCHMARK(1000, 1, clock_gettime(CLOCK_BOOTTIME, &ts));
 }
diff --git a/test/libc/calls/clock_nanosleep_test.c b/test/libc/calls/clock_nanosleep_test.c
index 805dfacee..02ab5cdaa 100644
--- a/test/libc/calls/clock_nanosleep_test.c
+++ b/test/libc/calls/clock_nanosleep_test.c
@@ -22,8 +22,8 @@
 #include "libc/calls/struct/timespec.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/clock.h"
 #include "libc/sysv/consts/itimer.h"
diff --git a/test/libc/calls/commandv_test.c b/test/libc/calls/commandv_test.c
index a86aaa43c..043b3164e 100644
--- a/test/libc/calls/commandv_test.c
+++ b/test/libc/calls/commandv_test.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
@@ -100,8 +100,6 @@ TEST(commandv, test_DirPaths_wontConsiderDirectoriesExecutable2) {
 }
 
 TEST(commandv, test_nonExecutableFile_willEacces) {
-  if (IsWindows())
-    return;  // TODO: fixme
   setenv("PATH", "foo", true);
   EXPECT_SYS(0, 0, mkdir("foo", 0755));
   EXPECT_SYS(0, 0, touch("foo/bar", 0400));
diff --git a/test/libc/calls/devfd_test.c b/test/libc/calls/devfd_test.c
index c5aec28a3..b2803cd61 100644
--- a/test/libc/calls/devfd_test.c
+++ b/test/libc/calls/devfd_test.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/dce.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/testlib/testlib.h"
diff --git a/test/libc/calls/dup_test.c b/test/libc/calls/dup_test.c
index cad66f18e..9421fecbb 100644
--- a/test/libc/calls/dup_test.c
+++ b/test/libc/calls/dup_test.c
@@ -94,7 +94,6 @@ TEST(dup2, zipossrc) {
   ASSERT_SYS(0, 0, close(3));
 }
 
-#ifdef __x86_64__
 TEST(dup, clearsCloexecFlag) {
   static bool once;
   int ws;
@@ -112,4 +111,3 @@ TEST(dup, clearsCloexecFlag) {
   ASSERT_EQ(72 << 8, ws);
   ASSERT_SYS(0, 0, close(3));
 }
-#endif
diff --git a/test/libc/calls/fchmod_test.c b/test/libc/calls/fchmod_test.c
deleted file mode 100644
index df8ffcc2b..000000000
--- a/test/libc/calls/fchmod_test.c
+++ /dev/null
@@ -1,41 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/stat.h"
-#include "libc/testlib/testlib.h"
-
-void SetUpOnce(void) {
-  testlib_enable_tmp_setup_teardown();
-}
-
-uint32_t GetMode(int fd) {
-  struct stat st;
-  ASSERT_SYS(0, 0, fstat(fd, &st));
-  return st.st_mode & 0777;
-}
-
-TEST(fchmod, canChangeReadOnlyBit) {
-  ASSERT_SYS(0, 3, creat("foo", 0600));
-  ASSERT_EQ(0600, GetMode(3));
-  ASSERT_SYS(0, 0, fchmod(3, 0400));
-  ASSERT_EQ(0400, GetMode(3));
-  ASSERT_SYS(0, 0, fchmod(3, 0600));
-  ASSERT_EQ(0600, GetMode(3));
-  ASSERT_SYS(0, 0, close(3));
-}
diff --git a/test/libc/calls/fchmodat_test.c b/test/libc/calls/fchmodat_test.c
index cb6d99d40..e103e3569 100644
--- a/test/libc/calls/fchmodat_test.c
+++ b/test/libc/calls/fchmodat_test.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/stat.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/at.h"
 #include "libc/sysv/consts/o.h"
diff --git a/test/libc/calls/fcntl_test.c b/test/libc/calls/fcntl_test.c
index 84675e66a..d816d27fe 100644
--- a/test/libc/calls/fcntl_test.c
+++ b/test/libc/calls/fcntl_test.c
@@ -22,7 +22,7 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/f.h"
 #include "libc/sysv/consts/fd.h"
diff --git a/test/libc/calls/ftruncate_test.c b/test/libc/calls/ftruncate_test.c
index 6d740f818..6c910df7e 100644
--- a/test/libc/calls/ftruncate_test.c
+++ b/test/libc/calls/ftruncate_test.c
@@ -21,7 +21,7 @@
 #include "libc/calls/struct/stat.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/mem/gc.h"
 #include "libc/nexgen32e/vendor.internal.h"
diff --git a/test/libc/calls/getcontext_test.c b/test/libc/calls/getcontext_test.c
index 35a9db833..c80219c7f 100644
--- a/test/libc/calls/getcontext_test.c
+++ b/test/libc/calls/getcontext_test.c
@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigset.h"
+#include "libc/calls/struct/ucontext.internal.h"
 #include "libc/calls/ucontext.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/sig.h"
@@ -60,6 +61,7 @@ TEST(getcontext, canReadAndWriteSignalMask) {
   ASSERT_EQ(0, getcontext(&context));
   if (!n) {
     n = 1;
+    context.uc_mcontext.RES0 = 0;
     ASSERT_TRUE(sigismember(&context.uc_sigmask, SIGUSR1));
     sigaddset(&context.uc_sigmask, SIGUSR2);
     setcontext(&context);
diff --git a/test/libc/calls/getcwd_test.c b/test/libc/calls/getcwd_test.c
index f9e8f22e3..f76653466 100644
--- a/test/libc/calls/getcwd_test.c
+++ b/test/libc/calls/getcwd_test.c
@@ -17,11 +17,12 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/ctype.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/libgen.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/serialize.h"
 #include "libc/str/str.h"
diff --git a/test/libc/calls/getgroups_test.c b/test/libc/calls/getgroups_test.c
index 7c221e899..e19372297 100644
--- a/test/libc/calls/getgroups_test.c
+++ b/test/libc/calls/getgroups_test.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/testlib/testlib.h"
 
 TEST(getgroups, test) {
diff --git a/test/libc/calls/getrandom_test.c b/test/libc/calls/getrandom_test.c
index 3e2386a7a..42fb33c65 100644
--- a/test/libc/calls/getrandom_test.c
+++ b/test/libc/calls/getrandom_test.c
@@ -23,7 +23,7 @@
 #include "libc/calls/struct/sigset.h"
 #include "libc/errno.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
@@ -34,7 +34,7 @@
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/sysv/consts/grnd.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/ezbench.h"
@@ -59,11 +59,9 @@ void *TortureWorker(void *arg) {
   ASSERT_SYS(0, 0, sigprocmask(SIG_SETMASK, &ss, 0));
   ready = true;
   while (!done) {
-    if (!IsWindows())
-      pthread_kill(parent, SIGUSR1);
+    pthread_kill(parent, SIGUSR1);
     usleep(1);
-    if (!IsWindows())
-      pthread_kill(parent, SIGUSR2);
+    pthread_kill(parent, SIGUSR2);
     usleep(1);
   }
   return 0;
diff --git a/test/libc/calls/lock_ofd_test.c b/test/libc/calls/lock_ofd_test.c
index 4b7081299..09c279cf2 100644
--- a/test/libc/calls/lock_ofd_test.c
+++ b/test/libc/calls/lock_ofd_test.c
@@ -23,7 +23,7 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/f.h"
 #include "libc/sysv/consts/o.h"
diff --git a/test/libc/calls/lock_test.c b/test/libc/calls/lock_test.c
index 5307228be..d05495400 100644
--- a/test/libc/calls/lock_test.c
+++ b/test/libc/calls/lock_test.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/flock.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/f.h"
 #include "libc/sysv/consts/o.h"
diff --git a/test/libc/calls/lseek_test.c b/test/libc/calls/lseek_test.c
index bff1cbdd4..72214fdb3 100644
--- a/test/libc/calls/lseek_test.c
+++ b/test/libc/calls/lseek_test.c
@@ -17,12 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/calls/internal.h"
-#include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/log/check.h"
-#include "libc/runtime/runtime.h"
 #include "libc/sock/sock.h"
 #include "libc/sysv/consts/af.h"
 #include "libc/sysv/consts/ipproto.h"
@@ -30,23 +25,22 @@
 #include "libc/sysv/consts/sock.h"
 #include "libc/testlib/subprocess.h"
 #include "libc/testlib/testlib.h"
-#include "libc/x/x.h"
 
 void SetUpOnce(void) {
   testlib_enable_tmp_setup_teardown();
   ASSERT_SYS(0, 0, pledge("stdio rpath wpath cpath fattr proc inet", 0));
 }
 
-/* TEST(lseek, ebadf) { */
-/*   ASSERT_SYS(EBADF, -1, lseek(-1, 0, SEEK_SET)); */
-/*   ASSERT_SYS(EBADF, -1, lseek(+3, 0, SEEK_SET)); */
-/* } */
+TEST(lseek, ebadf) {
+  ASSERT_SYS(EBADF, -1, lseek(-1, 0, SEEK_SET));
+  ASSERT_SYS(EBADF, -1, lseek(+3, 0, SEEK_SET));
+}
 
-/* TEST(lseek, badWhence_einval) { */
-/*   ASSERT_SYS(0, 3, creat("foo", 0644)); */
-/*   ASSERT_SYS(EINVAL, -1, lseek(3, 0, -1)); */
-/*   EXPECT_SYS(0, 0, close(3)); */
-/* } */
+TEST(lseek, badWhence_einval) {
+  ASSERT_SYS(0, 3, creat("foo", 0644));
+  ASSERT_SYS(EINVAL, -1, lseek(3, 0, -1));
+  EXPECT_SYS(0, 0, close(3));
+}
 
 TEST(lseek, negativeComputedOffset_einval) {
   ASSERT_SYS(0, 3, creat("foo", 0644));
@@ -59,68 +53,66 @@ TEST(lseek, negativeComputedOffset_einval) {
   EXPECT_SYS(0, 0, close(3));
 }
 
-/* TEST(lseek, 64bit) { */
-/*   ASSERT_SYS(0, 3, creat("foo", 0644)); */
-/*   ASSERT_SYS(0, 0x100000001, lseek(3, 0x100000001, SEEK_SET)); */
-/*   EXPECT_SYS(0, 0, close(3)); */
-/* } */
+TEST(lseek, 64bit) {
+  ASSERT_SYS(0, 3, creat("foo", 0644));
+  ASSERT_SYS(0, 0x100000001, lseek(3, 0x100000001, SEEK_SET));
+  EXPECT_SYS(0, 0, close(3));
+}
 
-/* TEST(lseek, isPipe_ESPIPE) { */
-/*   int fds[2]; */
-/*   char buf[2]; */
-/*   ASSERT_SYS(0, 0, pipe(fds)); */
-/*   ASSERT_SYS(ESPIPE, -1, lseek(3, 0, SEEK_SET)); */
-/*   ASSERT_SYS(ESPIPE, -1, pwrite(4, "hi", 2, 0)); */
-/*   ASSERT_SYS(ESPIPE, -1, pread(3, buf, 2, 0)); */
-/*   EXPECT_SYS(0, 0, close(4)); */
-/*   EXPECT_SYS(0, 0, close(3)); */
-/* } */
+TEST(lseek, isPipe_ESPIPE) {
+  int fds[2];
+  char buf[2];
+  ASSERT_SYS(0, 0, pipe(fds));
+  ASSERT_SYS(ESPIPE, -1, lseek(3, 0, SEEK_SET));
+  ASSERT_SYS(ESPIPE, -1, pwrite(4, "hi", 2, 0));
+  ASSERT_SYS(ESPIPE, -1, pread(3, buf, 2, 0));
+  EXPECT_SYS(0, 0, close(4));
+  EXPECT_SYS(0, 0, close(3));
+}
 
-/* TEST(lseek, isSocket_ESPIPE) { */
-/*   char buf[2]; */
-/*   ASSERT_SYS(0, 3, socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)); */
-/*   ASSERT_SYS(ESPIPE, -1, lseek(3, 0, SEEK_SET)); */
-/*   ASSERT_SYS(ESPIPE, -1, pwrite(3, "hi", 2, 0)); */
-/*   ASSERT_SYS(ESPIPE, -1, pread(3, buf, 2, 0)); */
-/*   EXPECT_SYS(0, 0, close(3)); */
-/* } */
+TEST(lseek, isSocket_ESPIPE) {
+  char buf[2];
+  ASSERT_SYS(0, 3, socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
+  ASSERT_SYS(ESPIPE, -1, lseek(3, 0, SEEK_SET));
+  ASSERT_SYS(ESPIPE, -1, pwrite(3, "hi", 2, 0));
+  ASSERT_SYS(ESPIPE, -1, pread(3, buf, 2, 0));
+  EXPECT_SYS(0, 0, close(3));
+}
 
-/* TEST(lseek, filePositionChanges_areObservableAcrossDup) { */
-/*   if (IsWindows()) return;  // do not want to support */
-/*   ASSERT_SYS(0, 3, creat("wut", 0644)); */
-/*   ASSERT_SYS(0, 4, dup(3)); */
-/*   ASSERT_SYS(0, 0, lseek(3, 0, SEEK_CUR)); */
-/*   ASSERT_SYS(0, 1, lseek(4, 1, SEEK_SET)); */
-/*   ASSERT_SYS(0, 1, lseek(3, 0, SEEK_CUR)); */
-/*   EXPECT_SYS(0, 0, close(4)); */
-/*   EXPECT_SYS(0, 0, close(3)); */
-/* } */
+TEST(lseek, filePositionChanges_areObservableAcrossDup) {
+  ASSERT_SYS(0, 3, creat("wut", 0644));
+  ASSERT_SYS(0, 4, dup(3));
+  ASSERT_SYS(0, 0, lseek(3, 0, SEEK_CUR));
+  ASSERT_SYS(0, 1, lseek(4, 1, SEEK_SET));
+  ASSERT_SYS(0, 1, lseek(3, 0, SEEK_CUR));
+  EXPECT_SYS(0, 0, close(4));
+  EXPECT_SYS(0, 0, close(3));
+}
 
-/* TEST(lseek, filePositionChanges_areObservableAcrossProcesses) { */
-/*   if (IsWindows()) return;  // do not want to support */
-/*   char buf[8] = {0}; */
-/*   ASSERT_SYS(0, 3, open("wut", O_RDWR | O_CREAT, 0644)); */
-/*   ASSERT_SYS(0, 3, write(3, "wut", 3)); */
-/*   ASSERT_SYS(0, 0, lseek(3, 0, SEEK_SET)); */
-/*   SPAWN(fork); */
-/*   ASSERT_SYS(0, 1, lseek(3, 1, SEEK_SET)); */
-/*   EXITS(0); */
-/*   EXPECT_SYS(0, 1, read(3, buf, 1)); */
-/*   EXPECT_EQ('u', buf[0]); */
-/*   EXPECT_SYS(0, 0, close(3)); */
-/* } */
+TEST(lseek, filePositionChanges_areObservableAcrossProcesses) {
+  char buf[8] = {0};
+  ASSERT_SYS(0, 3, open("wut", O_RDWR | O_CREAT, 0644));
+  ASSERT_SYS(0, 3, write(3, "wut", 3));
+  ASSERT_SYS(0, 0, lseek(3, 0, SEEK_SET));
+  SPAWN(fork);
+  ASSERT_SYS(0, 1, lseek(3, 1, SEEK_SET));
+  EXITS(0);
+  EXPECT_SYS(0, 1, read(3, buf, 1));
+  EXPECT_EQ('u', buf[0]);
+  EXPECT_SYS(0, 0, close(3));
+}
 
-/* TEST(lseek, beyondEndOfFile_isZeroExtendedUponSubsequentWrite) { */
-/*   char buf[8] = {1, 1}; */
-/*   ASSERT_SYS(0, 3, open("foo", O_RDWR | O_CREAT | O_TRUNC, 0644)); */
-/*   ASSERT_SYS(0, 2, lseek(3, 2, SEEK_SET)); */
-/*   ASSERT_SYS(0, 2, lseek(3, 0, SEEK_CUR)); */
-/*   ASSERT_SYS(0, 0, pread(3, buf, 8, 0));  // lseek() alone doesn't extend */
-/*   ASSERT_SYS(0, 2, write(3, buf, 2));     // does extend once i/o happens */
-/*   ASSERT_SYS(0, 4, pread(3, buf, 8, 0)); */
-/*   ASSERT_EQ(0, buf[0]); */
-/*   ASSERT_EQ(0, buf[1]); */
-/*   ASSERT_EQ(1, buf[2]); */
-/*   ASSERT_EQ(1, buf[3]); */
-/*   ASSERT_SYS(0, 0, close(3)); */
-/* } */
+TEST(lseek, beyondEndOfFile_isZeroExtendedUponSubsequentWrite) {
+  char buf[8] = {1, 1};
+  ASSERT_SYS(0, 3, open("foo", O_RDWR | O_CREAT | O_TRUNC, 0644));
+  ASSERT_SYS(0, 2, lseek(3, 2, SEEK_SET));
+  ASSERT_SYS(0, 2, lseek(3, 0, SEEK_CUR));
+  ASSERT_SYS(0, 0, pread(3, buf, 8, 0));  // lseek() alone doesn't extend
+  ASSERT_SYS(0, 2, write(3, buf, 2));     // does extend once i/o happens
+  ASSERT_SYS(0, 4, pread(3, buf, 8, 0));
+  ASSERT_EQ(0, buf[0]);
+  ASSERT_EQ(0, buf[1]);
+  ASSERT_EQ(1, buf[2]);
+  ASSERT_EQ(1, buf[3]);
+  ASSERT_SYS(0, 0, close(3));
+}
diff --git a/test/libc/calls/madvise_test.c b/test/libc/calls/madvise_test.c
index bdcdbc49a..dc595e7ae 100644
--- a/test/libc/calls/madvise_test.c
+++ b/test/libc/calls/madvise_test.c
@@ -33,63 +33,106 @@ void SetUpOnce(void) {
 
 TEST(madvise, anon) {
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, __granularity(), PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
-  ASSERT_SYS(0, 0, madvise(p, __granularity(), MADV_WILLNEED));
-  ASSERT_SYS(0, 0, munmap(p, __granularity()));
+  ASSERT_SYS(0, 0, madvise(p, getpagesize(), MADV_WILLNEED));
+  ASSERT_SYS(0, 0, munmap(p, getpagesize()));
 }
 
 TEST(madvise, file) {
   char *p;
   ASSERT_SYS(0, 3, creat("foo.dat", 0644));
-  ASSERT_SYS(0, 0, ftruncate(3, __granularity()));
+  ASSERT_SYS(0, 0, ftruncate(3, getpagesize()));
   ASSERT_SYS(0, 0, close(3));
   ASSERT_SYS(0, 3, open("foo.dat", O_RDWR));
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, __granularity(), PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                                   MAP_PRIVATE, 3, 0)));
-  ASSERT_SYS(0, 0, madvise(p, __granularity(), MADV_WILLNEED));
-  ASSERT_SYS(0, 0, munmap(p, __granularity()));
+  ASSERT_SYS(0, 0, madvise(p, getpagesize(), MADV_WILLNEED));
+  ASSERT_SYS(0, 0, munmap(p, getpagesize()));
   ASSERT_SYS(0, 0, close(3));
 }
 
 TEST(madvise, short) {
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, __granularity(), PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
-  ASSERT_SYS(0, 0, madvise(p, __granularity() - 1, MADV_WILLNEED));
-  ASSERT_SYS(0, 0, munmap(p, __granularity()));
+  ASSERT_SYS(0, 0, madvise(p, getpagesize() - 1, MADV_WILLNEED));
+  ASSERT_SYS(0, 0, munmap(p, getpagesize()));
+}
+
+TEST(madvise, zero) {
+  if (IsQemuUser())
+    return;  // doesn't validate flags
+  char *p;
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
+                                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
+  ASSERT_SYS(0, 0, madvise(p, 0, MADV_WILLNEED));
+  ASSERT_SYS(0, 0, madvise(0, 0, MADV_WILLNEED));
+  ASSERT_SYS(EINVAL, -1, madvise(p, 0, 666));
+  ASSERT_SYS(EINVAL, -1, madvise(0, 0, 666));
+  ASSERT_SYS(0, 0, munmap(p, getpagesize()));
 }
 
 TEST(madvise, subPages) {
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, __granularity(), PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, getpagesize() * 2, PROT_READ | PROT_WRITE,
                                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
-  ASSERT_SYS(0, 0,
-             madvise(p + getauxval(AT_PAGESZ),
-                     __granularity() - getauxval(AT_PAGESZ), MADV_WILLNEED));
-  ASSERT_SYS(0, 0, munmap(p, __granularity()));
+  ASSERT_SYS(0, 0, madvise(p + getpagesize(), getpagesize(), MADV_WILLNEED));
+  ASSERT_SYS(0, 0, munmap(p, getpagesize() * 2));
+}
+
+TEST(madvise, madvWillNeed_unmappedRegion) {
+  if (IsWindows())
+    return;  // needs carving
+  char *p;
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, getgransize() * 3, PROT_READ | PROT_WRITE,
+                                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
+  ASSERT_SYS(0, 0, munmap(p + getgransize(), getgransize()));
+  if (IsXnu())
+    ASSERT_SYS(EINVAL, -1, madvise(p, getgransize() * 3, MADV_WILLNEED));
+  else if (IsBsd() || IsWindows() || IsQemuUser())
+    ASSERT_SYS(0, 0, madvise(p, getgransize() * 3, MADV_WILLNEED));
+  else
+    ASSERT_SYS(ENOMEM, -1, madvise(p, getgransize() * 3, MADV_WILLNEED));
+  ASSERT_SYS(0, 0, munmap(p, getgransize() * 3));
+}
+
+TEST(madvise, madvFree_unmappedRegion) {
+  if (IsWindows())
+    return;  // needs carving
+  char *p;
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, getgransize() * 3, PROT_READ | PROT_WRITE,
+                                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
+  ASSERT_SYS(0, 0, munmap(p + getgransize(), getgransize()));
+  if (IsXnu())
+    ASSERT_SYS(EINVAL, -1, madvise(p, getgransize() * 3, MADV_FREE));
+  else if (IsNetbsd() || IsOpenbsd())
+    ASSERT_SYS(EFAULT, -1, madvise(p, getgransize() * 3, MADV_FREE));
+  else if (IsFreebsd() || IsWindows() || IsQemuUser())
+    ASSERT_SYS(0, 0, madvise(p, getgransize() * 3, MADV_FREE));
+  else
+    ASSERT_SYS(ENOMEM, -1, madvise(p, getgransize() * 3, MADV_FREE));
+  ASSERT_SYS(0, 0, munmap(p, getgransize() * 3));
 }
 
 TEST(madvise, misalign) {
   char *p;
-  if (!IsLinux())
-    return;  // most platforms don't care
-  if (IsQemuUser())
-    return;  // qemu claims to be linux but doesn't care
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, __granularity(), PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
-  ASSERT_SYS(EINVAL, -1, madvise(p + 1, __granularity() - 1, MADV_WILLNEED));
-  ASSERT_SYS(0, 0, munmap(p, __granularity()));
+  ASSERT_SYS(EINVAL, -1, madvise(p + 1, getpagesize(), MADV_WILLNEED));
+  ASSERT_SYS(0, 0, madvise(p, 1, MADV_WILLNEED));
+  ASSERT_SYS(EINVAL, -1, madvise(p, -1, MADV_WILLNEED));
+  ASSERT_SYS(0, 0, munmap(p, getpagesize()));
 }
 
 TEST(madvise, badAdvice) {
   char *p;
   if (IsAarch64() && IsQemuUser())
     return;  // qemu doesn't validate advice
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, __granularity(), PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
-  ASSERT_SYS(EINVAL, -1, madvise(p, __granularity(), 127));
-  ASSERT_SYS(0, 0, munmap(p, __granularity()));
+  ASSERT_SYS(EINVAL, -1, madvise(p, getpagesize(), 127));
+  ASSERT_SYS(0, 0, munmap(p, getpagesize()));
 }
 
 TEST(madvise, missingMemory) {
@@ -98,5 +141,5 @@ TEST(madvise, missingMemory) {
   if (IsQemuUser())
     return;  // qemu claims to be linux but doesn't care
   ASSERT_SYS(ENOMEM, -1,
-             madvise((char *)0x83483838000, __granularity(), MADV_WILLNEED));
+             madvise((char *)0x83483838000, getpagesize(), MADV_WILLNEED));
 }
diff --git a/test/libc/calls/mkdir_test.c b/test/libc/calls/mkdir_test.c
index 3711b26fa..ff2e13aff 100644
--- a/test/libc/calls/mkdir_test.c
+++ b/test/libc/calls/mkdir_test.c
@@ -55,6 +55,11 @@ TEST(mkdir, testPathIsFile_EEXIST) {
   EXPECT_SYS(EEXIST, -1, mkdir("yo/yo/yo", 0755));
 }
 
+TEST(mkdir, remove) {
+  EXPECT_SYS(0, 0, mkdir("yo", 0777));
+  EXPECT_SYS(0, 0, remove("yo"));
+}
+
 TEST(mkdir, testPathIsDirectory_EEXIST) {
   EXPECT_SYS(0, 0, mkdir("yo", 0755));
   EXPECT_SYS(0, 0, mkdir("yo/yo", 0755));
diff --git a/test/libc/calls/mkntpath_test.c b/test/libc/calls/mkntpath_test.c
index 88f538e7c..f9e249fdd 100644
--- a/test/libc/calls/mkntpath_test.c
+++ b/test/libc/calls/mkntpath_test.c
@@ -51,4 +51,34 @@ TEST(mkntpath, testRemoveDoubleSlash) {
   EXPECT_STREQ(u"C:\\Users\\jart\\.config", p);
 }
 
+TEST(mkntpath, testRelativeCurrentParent) {
+  EXPECT_EQ(3, __mkntpath("./../", p));
+  EXPECT_STREQ(u"..\\", p);
+}
+
+TEST(mkntpath, testRelativeParentParent) {
+  EXPECT_EQ(6, __mkntpath("../../", p));
+  EXPECT_STREQ(u"..\\..\\", p);
+}
+
+TEST(mkntpath, testRelativeParentParentParent) {
+  EXPECT_EQ(9, __mkntpath("../../../", p));
+  EXPECT_STREQ(u"..\\..\\..\\", p);
+}
+
+TEST(mkntpath, testRelativeDirParent) {
+  EXPECT_EQ(2, __mkntpath("abc/../", p));
+  EXPECT_STREQ(u".\\", p);
+}
+
+TEST(mkntpath, testRelativeDirCurrent) {
+  EXPECT_EQ(4, __mkntpath("abc/./", p));
+  EXPECT_STREQ(u"abc\\", p);
+}
+
+TEST(mkntpath, testRelativeDirDirParent) {
+  EXPECT_EQ(4, __mkntpath("abc/def/../", p));
+  EXPECT_STREQ(u"abc\\", p);
+}
+
 #endif /* SupportsWindows() */
diff --git a/test/libc/calls/open_test.c b/test/libc/calls/open_test.c
index 87545b603..1962e6c07 100644
--- a/test/libc/calls/open_test.c
+++ b/test/libc/calls/open_test.c
@@ -23,7 +23,7 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
@@ -326,120 +326,6 @@ TEST(open, lotsOfFds) {
   }
 }
 
-static int64_t GetInode(const char *path) {
-  struct stat st;
-  ASSERT_SYS(0, 0, stat(path, &st));
-  return st.st_ino;
-}
-
-TEST(open, drive) {
-  if (!IsWindows())
-    return;
-  ASSERT_NE(GetInode("/"), GetInode("."));
-  ASSERT_EQ(GetInode("/"), GetInode("/c"));  // sorry you have to run on c:/
-  ASSERT_EQ(GetInode("/"), GetInode("/c/"));
-  ASSERT_SYS(0, 3, open("/", O_RDONLY));
-  ASSERT_SYS(0, 0, close(3));
-}
-
-TEST(open, readOnlyCreatMode) {
-  char buf[8];
-  struct stat st;
-  ASSERT_SYS(0, 3, open("x", O_RDWR | O_CREAT | O_TRUNC, 0500));
-  ASSERT_SYS(0, 2, pwrite(3, "MZ", 2, 0));
-  ASSERT_SYS(0, 2, pread(3, buf, 8, 0));
-  ASSERT_SYS(0, 0, close(3));
-  ASSERT_SYS(0, 0, stat("x", &st));
-  ASSERT_EQ(0100500, st.st_mode);
-  if (getuid()) {
-    ASSERT_SYS(EACCES, -1, open("x", O_RDWR));
-    ASSERT_SYS(EACCES, -1, open("x", O_RDWR | O_CREAT, 0666));
-  } else {
-    // root is invulnerable to eacces
-    ASSERT_SYS(0, 3, open("x", O_RDWR));
-    ASSERT_SYS(0, 0, close(3));
-    ASSERT_SYS(0, 3, open("x", O_RDWR | O_CREAT, 0666));
-    ASSERT_SYS(0, 0, close(3));
-    SPAWN(fork);
-    setuid(1000);
-    setgid(1000);
-    ASSERT_SYS(EACCES, -1, open("x", O_RDWR));
-    ASSERT_SYS(EACCES, -1, open("x", O_RDWR | O_CREAT, 0666));
-    EXITS(0);
-  }
-}
-
-TEST(open, parentSymlink) {
-  struct stat st;
-  ASSERT_SYS(0, 0, mkdir("parent", 0755));
-  // create directory symlink
-  ASSERT_SYS(0, 0, symlink("parent", "parent-link"));
-  // test the symlink we just made is a symlink
-  ASSERT_SYS(0, 0, lstat("parent-link", &st));
-  ASSERT_TRUE(S_ISLNK(st.st_mode));
-  // create regular file when parent component is symlink dir
-  ASSERT_SYS(0, 0, touch("parent-link/regular", 0644));
-  // test stat works
-  ASSERT_SYS(0, 0, stat("parent-link/regular", &st));
-  ASSERT_TRUE(S_ISREG(st.st_mode));
-  // test open works
-  ASSERT_SYS(0, 3, open("parent-link/regular", O_RDONLY));
-  ASSERT_SYS(0, 0, fstat(3, &st));
-  ASSERT_TRUE(S_ISREG(st.st_mode));
-  ASSERT_SYS(0, 0, close(3));
-  // test O_NOFOLLOW doesn't apply to parent components
-  ASSERT_SYS(0, 3, open("parent-link/regular", O_RDONLY | O_NOFOLLOW));
-  ASSERT_SYS(0, 0, fstat(3, &st));
-  ASSERT_TRUE(S_ISREG(st.st_mode));
-  ASSERT_SYS(0, 0, close(3));
-  // create regular symlink
-  ASSERT_SYS(0, 0, symlink("regular", "parent-link/regular-link"));
-  // test stat works
-  ASSERT_SYS(0, 0, stat("parent-link/regular-link", &st));
-  ASSERT_TRUE(S_ISREG(st.st_mode));
-  ASSERT_SYS(0, 0, lstat("parent-link/regular-link", &st));
-  ASSERT_TRUE(S_ISLNK(st.st_mode));
-  // test open works
-  ASSERT_SYS(0, 3, open("parent-link/regular-link", O_RDONLY));
-  ASSERT_SYS(0, 0, fstat(3, &st));
-  ASSERT_TRUE(S_ISREG(st.st_mode));
-  ASSERT_SYS(0, 0, close(3));
-  // test O_NOFOLLOW applies to last component
-  ASSERT_SYS(ELOOP, -1,
-             open("parent-link/regular-link", O_RDONLY | O_NOFOLLOW));
-}
-
-TEST(open, readonlyCreateMode_dontChangeStatusIfExists) {
-  char buf[8];
-  struct stat st;
-  ASSERT_SYS(0, 3, creat("wut", 0700));
-  ASSERT_SYS(0, 2, pwrite(3, "MZ", 2, 0));
-  ASSERT_SYS(0, 0, close(3));
-  // since the file already exists, unix doesn't change read-only
-  ASSERT_SYS(0, 3, open("wut", O_CREAT | O_TRUNC | O_RDWR, 0500));
-  ASSERT_SYS(0, 0, pread(3, buf, 8, 0));
-  ASSERT_SYS(0, 0, fstat(3, &st));
-  ASSERT_EQ(0100600, st.st_mode & 0700666);
-  ASSERT_SYS(0, 0, close(3));
-}
-
-TEST(open, creatRdonly) {
-  char buf[8];
-  ASSERT_SYS(EINVAL, -1, open("foo", O_CREAT | O_TRUNC | O_RDONLY, 0700));
-  ASSERT_SYS(0, 3, open("foo", O_CREAT | O_RDONLY, 0700));
-  ASSERT_SYS(EBADF, -1, pwrite(3, "MZ", 2, 0));
-  ASSERT_SYS(0, 0, pread(3, buf, 8, 0));
-  ASSERT_SYS(0, 0, close(3));
-}
-
-TEST(open, sequentialRandom_EINVAL) {
-  if (!IsWindows())
-    return;
-  ASSERT_SYS(
-      EINVAL, -1,
-      open("foo", O_CREAT | O_TRUNC | O_RDWR | O_SEQUENTIAL | O_RANDOM, 0700));
-}
-
 // "If O_CREAT is set and the file did not previously exist, upon
 //  successful completion, open() shall mark for update the last data
 //  access, last data modification, and last file status change
@@ -485,31 +371,3 @@ TEST(open, trunc_touchesMtimCtim) {
   EXPECT_EQ(1, timespec_cmp(st.st_mtim, birth));
   ASSERT_SYS(0, 0, close(3));
 }
-
-TEST(open, mereOpen_doesntTouch) {
-  struct stat st;
-  struct timespec birth;
-  ASSERT_SYS(0, 0, touch("regular", 0755));
-  ASSERT_SYS(0, 0, stat("regular", &st));
-  birth = st.st_ctim;
-  sleep(2);
-  ASSERT_SYS(0, 3, open("regular", O_RDWR));
-  ASSERT_SYS(0, 0, close(3));
-  ASSERT_SYS(0, 0, stat("regular", &st));
-  EXPECT_EQ(0, timespec_cmp(st.st_ctim, birth));
-  EXPECT_EQ(0, timespec_cmp(st.st_mtim, birth));
-  EXPECT_EQ(0, timespec_cmp(st.st_atim, birth));
-}
-
-TEST(open, canTruncateExistingFile) {
-  struct stat st;
-  ASSERT_SYS(0, 0, xbarf("foo", "hello", -1));
-  ASSERT_SYS(0, 0, stat("foo", &st));
-  ASSERT_EQ(5, st.st_size);
-  ASSERT_SYS(0, 3, open("foo", O_RDWR | O_TRUNC));
-  ASSERT_SYS(0, 0, fstat(3, &st));
-  ASSERT_EQ(0, st.st_size);
-  ASSERT_SYS(0, 0, close(3));
-  ASSERT_SYS(0, 0, stat("foo", &st));
-  ASSERT_EQ(0, st.st_size);
-}
diff --git a/test/libc/calls/pledge2_test.c b/test/libc/calls/pledge2_test.c
index e5d16dbea..17777975a 100644
--- a/test/libc/calls/pledge2_test.c
+++ b/test/libc/calls/pledge2_test.c
@@ -22,7 +22,7 @@
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/promises.internal.h"
+#include "libc/intrin/promises.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sock/sock.h"
 #include "libc/stdio/stdio.h"
diff --git a/test/libc/calls/pledge_test.c b/test/libc/calls/pledge_test.c
index b0cf090aa..089d965ef 100644
--- a/test/libc/calls/pledge_test.c
+++ b/test/libc/calls/pledge_test.c
@@ -30,7 +30,7 @@
 #include "libc/calls/syscall_support-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
@@ -56,6 +56,7 @@
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/subprocess.h"
 #include "libc/testlib/testlib.h"
+#include "libc/thread/lock.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/time.h"
@@ -63,6 +64,14 @@
 
 void SetUpOnce(void) {
   testlib_enable_tmp_setup_teardown();
+  if (pledge(0, 0) == -1) {
+    fprintf(stderr, "warning: pledge() not supported on this system %m\n");
+    exit(0);
+  }
+}
+
+void SetUp(void) {
+  __pledge_mode = PLEDGE_PENALTY_RETURN_EPERM;
 }
 
 void OnSig(int sig) {
@@ -71,21 +80,11 @@ void OnSig(int sig) {
 
 int sys_memfd_secret(unsigned int);  // our ENOSYS threshold
 
-void SetUp(void) {
-  if (pledge(0, 0) == -1) {
-    fprintf(stderr, "warning: pledge() not supported on this system %m\n");
-    exit(0);
-  }
-  testlib_extract("/zip/life.elf", "life.elf", 0755);
-  testlib_extract("/zip/sock.elf", "sock.elf", 0755);
-  __pledge_mode = PLEDGE_PENALTY_RETURN_EPERM;
-}
-
 TEST(pledge, default_allowsExit) {
   int *job;
   int ws, pid;
   // create small shared memory region
-  ASSERT_NE(-1, (job = mmap(0, __granularity(), PROT_READ | PROT_WRITE,
+  ASSERT_NE(-1, (job = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                             MAP_SHARED | MAP_ANONYMOUS, -1, 0)));
   job[0] = 2;  // create workload
   job[1] = 2;
@@ -99,21 +98,25 @@ TEST(pledge, default_allowsExit) {
   EXPECT_TRUE(WIFEXITED(ws));
   EXPECT_EQ(0, WEXITSTATUS(ws));
   EXPECT_EQ(4, job[0]);  // check result
-  EXPECT_SYS(0, 0, munmap(job, __granularity()));
+  EXPECT_SYS(0, 0, munmap(job, getpagesize()));
 }
 
 TEST(pledge, execpromises_notok) {
   if (IsOpenbsd())
     return;  // b/c testing linux bpf
   int ws, pid;
+  testlib_extract("/zip/sock.elf", "sock.elf", 0755);
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
+    putenv("COMDBG=REDACTED");
     __pledge_mode = PLEDGE_PENALTY_RETURN_EPERM;
     ASSERT_SYS(0, 0, pledge("stdio rpath exec", "stdio"));
     execl("sock.elf", "sock.elf", 0);
     _Exit(127);
   }
   EXPECT_NE(-1, wait(&ws));
+  EXPECT_FALSE(WIFSIGNALED(ws));
+  EXPECT_EQ(0, WTERMSIG(ws));
   EXPECT_TRUE(WIFEXITED(ws));
   EXPECT_EQ(129, WEXITSTATUS(ws));
 }
@@ -297,7 +300,7 @@ TEST(pledge, stdioTty_sendtoRestricted_requiresNullAddr) {
     errno = 0;
     // set lower 32-bit word of pointer to zero lool
     struct sockaddr_in *sin =
-        mmap((void *)0x300000000000, __granularity(), PROT_READ | PROT_WRITE,
+        mmap((void *)0x300000000000, getpagesize(), PROT_READ | PROT_WRITE,
              MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
     sin->sin_family = AF_INET;
     ASSERT_SYS(
@@ -333,7 +336,7 @@ TEST(pledge, unix_forbidsInetSockets) {
 TEST(pledge, wpath_doesNotImplyRpath) {
   int ws, pid;
   bool *gotsome;
-  ASSERT_NE(-1, (gotsome = _mapshared(__granularity())));
+  ASSERT_NE(-1, (gotsome = _mapshared(getpagesize())));
   ASSERT_SYS(0, 0, touch("foo", 0644));
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
@@ -411,13 +414,13 @@ TEST(pledge, mmap) {
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
     ASSERT_SYS(0, 0, pledge("stdio", 0));
-    ASSERT_NE(MAP_FAILED, (p = mmap(0, __granularity(), PROT_READ | PROT_WRITE,
+    ASSERT_NE(MAP_FAILED, (p = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                                     MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
-    ASSERT_SYS(0, 0, mprotect(p, __granularity(), PROT_READ));
+    ASSERT_SYS(0, 0, mprotect(p, getpagesize(), PROT_READ));
     ASSERT_SYS(EPERM, MAP_FAILED,
-               mprotect(p, __granularity(), PROT_READ | PROT_EXEC));
+               mprotect(p, getpagesize(), PROT_READ | PROT_EXEC));
     ASSERT_SYS(EPERM, MAP_FAILED,
-               mmap(0, __granularity(), PROT_EXEC | PROT_READ,
+               mmap(0, getpagesize(), PROT_EXEC | PROT_READ,
                     MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
     _Exit(0);
   }
@@ -433,11 +436,11 @@ TEST(pledge, mmapProtExec) {
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
     ASSERT_SYS(0, 0, pledge("stdio prot_exec", 0));
-    ASSERT_NE(MAP_FAILED, (p = mmap(0, __granularity(), PROT_READ | PROT_WRITE,
+    ASSERT_NE(MAP_FAILED, (p = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                                     MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
-    ASSERT_SYS(0, 0, mprotect(p, __granularity(), PROT_READ));
-    ASSERT_SYS(0, 0, mprotect(p, __granularity(), PROT_READ | PROT_EXEC));
-    ASSERT_NE(MAP_FAILED, mmap(0, __granularity(), PROT_EXEC | PROT_READ,
+    ASSERT_SYS(0, 0, mprotect(p, getpagesize(), PROT_READ));
+    ASSERT_SYS(0, 0, mprotect(p, getpagesize(), PROT_READ | PROT_EXEC));
+    ASSERT_NE(MAP_FAILED, mmap(0, getpagesize(), PROT_EXEC | PROT_READ,
                                MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
     _Exit(0);
   }
@@ -528,9 +531,11 @@ TEST(pledge, open_cpath) {
 TEST(pledge, execpromises_ok) {
   if (IsOpenbsd())
     return;  // b/c testing linux bpf
+  testlib_extract("/zip/life.elf", "life.elf", 0755);
   int ws, pid;
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
+    putenv("COMDBG=REDACTED");
     ASSERT_SYS(0, 0, pledge("stdio exec", "stdio"));
     execl("life.elf", "life.elf", 0);
     _Exit(127);
@@ -544,8 +549,10 @@ TEST(pledge, execpromises_notok1) {
   if (IsOpenbsd())
     return;  // b/c testing linux bpf
   int ws, pid;
+  testlib_extract("/zip/sock.elf", "sock.elf", 0755);
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
+    putenv("COMDBG=REDACTED");
     ASSERT_SYS(0, 0, pledge("stdio exec", "stdio"));
     execl("sock.elf", "sock.elf", 0);
     _Exit(127);
@@ -559,8 +566,10 @@ TEST(pledge, execpromises_reducesAtExecOnLinux) {
   if (IsOpenbsd())
     return;  // b/c testing linux bpf
   int ws, pid;
+  testlib_extract("/zip/sock.elf", "sock.elf", 0755);
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
+    putenv("COMDBG=REDACTED");
     ASSERT_SYS(0, 0, pledge("stdio inet tty exec", "stdio tty"));
     execl("sock.elf", "sock.elf", 0);
     _Exit(127);
@@ -576,6 +585,7 @@ TEST(pledge_openbsd, execpromisesIsNull_letsItDoAnything) {
   if (!IsOpenbsd())
     return;
   int ws, pid;
+  testlib_extract("/zip/sock.elf", "sock.elf", 0755);
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
     ASSERT_SYS(0, 0, pledge("stdio exec", 0));
@@ -595,6 +605,7 @@ TEST(pledge_openbsd, execpromisesIsSuperset_letsItDoAnything) {
   if (!IsOpenbsd())
     return;
   int ws, pid;
+  testlib_extract("/zip/sock.elf", "sock.elf", 0755);
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
     ASSERT_SYS(0, 0, pledge("stdio rpath exec", "stdio rpath tty inet"));
@@ -616,8 +627,10 @@ TEST(pledge_openbsd, execpromises_notok) {
   if (IsOpenbsd())
     return;  // mimmutable() ugh
   int ws, pid;
+  testlib_extract("/zip/sock.elf", "sock.elf", 0755);
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
+    putenv("COMDBG=REDACTED");
     ASSERT_SYS(0, 0, pledge("stdio exec", "stdio"));
     execl("sock.elf", "sock.elf", 0);
     _Exit(127);
@@ -652,7 +665,7 @@ TEST(pledge_openbsd, bigSyscalls) {
 
 void *LockWorker(void *arg) {
   flockfile(stdout);
-  ASSERT_EQ(gettid(), stdout->lock._owner);
+  ASSERT_EQ(gettid(), MUTEX_OWNER(stdout->lock._word));
   funlockfile(stdout);
   return 0;
 }
diff --git a/test/libc/calls/poll_latency_test.c b/test/libc/calls/poll_latency_test.c
new file mode 100644
index 000000000..ab6aa5a4f
--- /dev/null
+++ b/test/libc/calls/poll_latency_test.c
@@ -0,0 +1,205 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <arpa/inet.h>
+#include <assert.h>
+#include <cosmo.h>
+#include <netinet/in.h>
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/poll.h>
+#include <sys/socket.h>
+#include <time.h>
+#include <unistd.h>
+
+#define NUM_MEASUREMENTS 10
+#define BUFFER_SIZE      sizeof(struct timespec)
+
+atomic_int global_state;
+
+typedef struct {
+  int port;
+  int client_sock;
+} listener_data;
+
+void *sender_thread(void *arg) {
+  listener_data *data = (listener_data *)arg;
+  int sockfd = socket(data->port == 0 ? AF_INET : AF_INET6, SOCK_STREAM, 0);
+  if (sockfd < 0) {
+    perror("Socket creation failed");
+    exit(EXIT_FAILURE);
+  }
+
+  void *addr;
+  struct sockaddr_in addr_v4 = {0};
+  struct sockaddr_in6 addr_v6 = {0};
+  socklen_t addr_len;
+
+  if (data->port == 0) {  // IPv4
+    addr_v4.sin_family = AF_INET;
+    addr_v4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    addr_v4.sin_port = 0;
+    addr = &addr_v4;
+    addr_len = sizeof(addr_v4);
+  } else {  // IPv6
+    addr_v6.sin6_family = AF_INET6;
+    addr_v6.sin6_addr = in6addr_loopback;
+    addr_v6.sin6_port = 0;
+    addr = &addr_v6;
+    addr_len = sizeof(addr_v6);
+  }
+
+  if (bind(sockfd, addr, addr_len) < 0) {
+    perror("Bind failed");
+    exit(EXIT_FAILURE);
+  }
+
+  if (getsockname(sockfd, addr, &addr_len) < 0) {
+    perror("getsockname failed");
+    exit(EXIT_FAILURE);
+  }
+
+  data->port = ntohs(data->port == 0 ? addr_v4.sin_port : addr_v6.sin6_port);
+
+  if (listen(sockfd, 1) < 0) {
+    perror("Listen failed");
+    exit(EXIT_FAILURE);
+  }
+
+  atomic_fetch_add(&global_state, 1);
+  data->client_sock = accept(sockfd, NULL, NULL);
+  if (data->client_sock < 0) {
+    perror("Accept failed");
+    exit(EXIT_FAILURE);
+  }
+  atomic_fetch_add(&global_state, 1);
+
+  struct timespec ts;
+  for (int i = 0; i < NUM_MEASUREMENTS; i++) {
+    while (atomic_load(&global_state)) {
+    }
+    atomic_fetch_add(&global_state, 1);
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    send(data->client_sock, &ts, sizeof(ts), 0);
+  }
+
+  close(data->client_sock);
+  close(sockfd);
+  return NULL;
+}
+
+int main() {
+  ShowCrashReports();
+
+  pthread_t ipv4_thread, ipv6_thread;
+  listener_data ipv4_data = {0},
+                ipv6_data = {1};  // Use port 0 for IPv4, 1 for IPv6
+
+  global_state = -5;
+
+  if (pthread_create(&ipv4_thread, NULL, sender_thread, &ipv4_data) != 0) {
+    perror("Failed to create IPv4 thread");
+    exit(EXIT_FAILURE);
+  }
+
+  if (pthread_create(&ipv6_thread, NULL, sender_thread, &ipv6_data) != 0) {
+    perror("Failed to create IPv6 thread");
+    exit(EXIT_FAILURE);
+  }
+
+  // Wait for both listeners to be ready
+  while (atomic_load(&global_state) < -3) {
+    // Busy wait
+  }
+
+  int ipv4_sock = socket(AF_INET, SOCK_STREAM, 0);
+  int ipv6_sock = socket(AF_INET6, SOCK_STREAM, 0);
+
+  struct sockaddr_in ipv4_addr = {0};
+  ipv4_addr.sin_family = AF_INET;
+  ipv4_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  ipv4_addr.sin_port = htons(ipv4_data.port);
+
+  struct sockaddr_in6 ipv6_addr = {0};
+  ipv6_addr.sin6_family = AF_INET6;
+  ipv6_addr.sin6_addr = in6addr_loopback;
+  ipv6_addr.sin6_port = htons(ipv6_data.port);
+
+  if (connect(ipv4_sock, (struct sockaddr *)&ipv4_addr, sizeof(ipv4_addr)) <
+      0) {
+    perror("IPv4 connect failed");
+    exit(EXIT_FAILURE);
+  }
+
+  if (connect(ipv6_sock, (struct sockaddr *)&ipv6_addr, sizeof(ipv6_addr)) <
+      0) {
+    perror("IPv6 connect failed");
+    exit(EXIT_FAILURE);
+  }
+
+  // Wait for both listeners to be ready
+  while (atomic_load(&global_state) < -1) {
+    // Busy wait
+  }
+  atomic_fetch_add(&global_state, 1);
+
+  struct pollfd fds[2];
+  fds[0].fd = ipv4_sock;
+  fds[0].events = POLLIN;
+  fds[1].fd = ipv6_sock;
+  fds[1].events = POLLIN;
+
+  struct timespec ts_sent, ts_now;
+  double total_latency = 0.0;
+  int total_measurements = 0;
+
+  while (total_measurements < 2 * NUM_MEASUREMENTS) {
+    int ready = poll(fds, 2, -1);
+    if (ready < 0) {
+      perror("Poll failed");
+      exit(EXIT_FAILURE);
+    }
+
+    clock_gettime(CLOCK_MONOTONIC, &ts_now);
+
+    for (int i = 0; i < 2; i++) {
+      if (fds[i].revents & POLLIN) {
+        ssize_t n = recv(fds[i].fd, &ts_sent, sizeof(ts_sent), 0);
+        if (n == sizeof(ts_sent)) {
+          total_latency += timespec_tonanos(timespec_sub(ts_now, ts_sent));
+          total_measurements++;
+          atomic_fetch_sub(&global_state, 1);
+        }
+      }
+    }
+  }
+
+  double mean_latency = total_latency / total_measurements;
+  printf("Mean poll() latency: %.2f ns\n", mean_latency);
+
+  unassert(!close(ipv4_sock));
+  unassert(!close(ipv6_sock));
+
+  unassert(!pthread_join(ipv4_thread, NULL));
+  unassert(!pthread_join(ipv6_thread, NULL));
+
+  CheckForMemoryLeaks();
+}
diff --git a/test/libc/calls/poll_test.c b/test/libc/calls/poll_test.c
index ee844762b..12cf78951 100644
--- a/test/libc/calls/poll_test.c
+++ b/test/libc/calls/poll_test.c
@@ -20,8 +20,10 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/pledge.h"
 #include "libc/calls/struct/sigaction.h"
+#include "libc/calls/struct/timespec.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/log/libfatal.internal.h"
 #include "libc/mem/gc.h"
 #include "libc/nexgen32e/rdtsc.h"
@@ -33,6 +35,7 @@
 #include "libc/sysv/consts/af.h"
 #include "libc/sysv/consts/inaddr.h"
 #include "libc/sysv/consts/ipproto.h"
+#include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/consts/sock.h"
 #include "libc/testlib/testlib.h"
@@ -43,8 +46,7 @@
 bool gotsig;
 
 void SetUpOnce(void) {
-  __pledge_mode = PLEDGE_PENALTY_KILL_PROCESS | PLEDGE_STDERR_LOGGING;
-  ASSERT_SYS(0, 0, pledge("stdio proc inet", 0));
+  testlib_enable_tmp_setup_teardown();
 }
 
 void SetUp(void) {
@@ -55,16 +57,16 @@ void OnSig(int sig) {
   gotsig = true;
 }
 
-__wur char *FormatPollFd(struct pollfd p[2]) {
-  return xasprintf("fd:%d revents:%s\n"
-                   "fd:%d revents:%s\n",
-                   p[0].fd, "<TODO:kPollNames>", p[1].fd, "<TODO:kPollNames>");
-}
-
 TEST(poll, allZero_doesNothingPrettyMuch) {
   EXPECT_SYS(0, 0, poll(0, 0, 0));
 }
 
+TEST(poll, allZeroWithTimeout_sleeps) {
+  struct timespec ts1 = timespec_mono();
+  EXPECT_SYS(0, 0, poll(0, 0, 100));
+  EXPECT_GE(timespec_tomillis(timespec_sub(timespec_mono(), ts1)), 100);
+}
+
 TEST(ppoll, weCanProveItChecksForSignals) {
   if (IsXnu())
     return;
@@ -94,14 +96,52 @@ TEST(poll, testNegativeOneFd_isIgnored) {
   struct sockaddr_in addr = {AF_INET, 0, {htonl(INADDR_LOOPBACK)}};
   ASSERT_SYS(0, 0, bind(3, (struct sockaddr *)&addr, sizeof(addr)));
   ASSERT_SYS(0, 0, listen(3, 10));
-  struct pollfd fds[] = {{-1}, {3}};
+  struct pollfd fds[] = {{-1, 0, -1}, {3, 0, -1}};
   EXPECT_SYS(0, 0, poll(fds, ARRAYLEN(fds), 1));
-  EXPECT_STREQ("fd:-1 revents:<TODO:kPollNames>\n"
-               "fd:3 revents:<TODO:kPollNames>\n",
-               gc(FormatPollFd(&fds[0])));
+  EXPECT_EQ(-1, fds[0].fd);
+  EXPECT_EQ(0, fds[0].revents);
+  EXPECT_EQ(3, fds[1].fd);
+  EXPECT_EQ(0, fds[1].revents);
   ASSERT_SYS(0, 0, close(3));
 }
 
+TEST(poll, testInvalidFd_POLLIN_isChecked) {
+  struct pollfd fds[] = {{77, POLLIN, -1}};
+  EXPECT_SYS(0, 1, poll(fds, ARRAYLEN(fds), 1));
+  EXPECT_EQ(77, fds[0].fd);
+  EXPECT_EQ(POLLNVAL, fds[0].revents);
+}
+
+TEST(poll, testInvalidFd_POLLOUT_isChecked) {
+  struct pollfd fds[] = {{77, POLLOUT, -1}};
+  EXPECT_SYS(0, 1, poll(fds, ARRAYLEN(fds), 1));
+  EXPECT_EQ(77, fds[0].fd);
+  EXPECT_EQ(POLLNVAL, fds[0].revents);
+}
+
+TEST(poll, testInvalidFd_POLLPRI_isChecked) {
+  struct pollfd fds[] = {{77, POLLPRI, -1}};
+  EXPECT_SYS(0, 1, poll(fds, ARRAYLEN(fds), 1));
+  EXPECT_EQ(77, fds[0].fd);
+  EXPECT_EQ(POLLNVAL, fds[0].revents);
+}
+
+TEST(poll, testInvalidFd_POLLHUP_isChecked) {
+  // this behavior has to be polyfilled on xnu
+  struct pollfd fds[] = {{77, POLLHUP, -1}};
+  EXPECT_SYS(0, 1, poll(fds, ARRAYLEN(fds), 1));
+  EXPECT_EQ(77, fds[0].fd);
+  EXPECT_EQ(POLLNVAL, fds[0].revents);
+}
+
+TEST(poll, testInvalidFd_ZERO_isChecked) {
+  // this behavior has to be polyfilled on xnu
+  struct pollfd fds[] = {{77, 0, -1}};
+  EXPECT_SYS(0, 1, poll(fds, ARRAYLEN(fds), 1));
+  EXPECT_EQ(77, fds[0].fd);
+  EXPECT_EQ(POLLNVAL, fds[0].revents);
+}
+
 TEST(poll, pipe_noInput) {
   // we can't test stdin here since
   // we can't assume it isn't /dev/null
@@ -115,6 +155,17 @@ TEST(poll, pipe_noInput) {
   EXPECT_SYS(0, 0, close(pipefds[1]));
 }
 
+TEST(poll, pipe_broken) {
+  int pipefds[2];
+  EXPECT_SYS(0, 0, pipe(pipefds));
+  EXPECT_SYS(0, 0, close(pipefds[1]));
+  struct pollfd fds[] = {{pipefds[0], POLLIN}};
+  EXPECT_SYS(0, 1, poll(fds, 1, 0));
+  // BSDs also set POLLIN here too even though that's wrong
+  EXPECT_TRUE(!!(fds[0].revents & POLLHUP));
+  EXPECT_SYS(0, 0, close(pipefds[0]));
+}
+
 TEST(poll, pipe_hasInputFromSameProcess) {
   char buf[2];
   int pipefds[2];
@@ -122,7 +173,7 @@ TEST(poll, pipe_hasInputFromSameProcess) {
   struct pollfd fds[] = {{pipefds[0], POLLIN}};
   EXPECT_SYS(0, 2, write(pipefds[1], "hi", 2));
   EXPECT_SYS(0, 1, poll(fds, 1, 1000));  // flake nt!
-  EXPECT_EQ(POLLIN, fds[0].revents);
+  EXPECT_TRUE(!!(fds[0].revents & POLLIN));
   EXPECT_SYS(0, 2, read(pipefds[0], buf, 2));
   EXPECT_SYS(0, 0, poll(fds, 1, 0));
   EXPECT_SYS(0, 0, close(pipefds[0]));
@@ -150,7 +201,7 @@ TEST(poll, pipe_hasInput) {
   EXPECT_SYS(0, 2, read(pipefds[0], buf, 2));
   struct pollfd fds[] = {{pipefds[0], POLLIN}};
   EXPECT_SYS(0, 1, poll(fds, 1, -1));
-  EXPECT_EQ(POLLIN, fds[0].revents & POLLIN);
+  EXPECT_TRUE(!!(fds[0].revents & POLLIN));
   EXPECT_SYS(0, 2, read(pipefds[0], buf, 2));
   EXPECT_SYS(0, 0, close(pipefds[0]));
   ASSERT_NE(-1, wait(&ws));
@@ -159,22 +210,174 @@ TEST(poll, pipe_hasInput) {
   EXPECT_EQ(0, sigprocmask(SIG_SETMASK, &savemask, 0));
 }
 
-#if 0
-TEST(poll, emptyFds_becomesSleep) {
-  // timing tests w/o mocks are always the hardest
-  int64_t a, b, c, p, i = 0;
-  do {
-    if (++i == 5) {
-      kprintf("too much cpu churn%n");
-      return;
-    }
-    p = TSC_AUX_CORE(rdpid());
-    a = rdtsc();
-    EXPECT_SYS(0, 0, poll(0, 0, 5));
-    b = rdtsc();
-    EXPECT_SYS(0, 0, poll(0, 0, 50));
-    c = rdtsc();
-  } while (TSC_AUX_CORE(rdpid()) != p);
-  EXPECT_LT((b - a) * 2, c - b);
+TEST(poll, file_pollin) {
+  int fd;
+  EXPECT_SYS(0, 3, (fd = open("boop", O_CREAT | O_RDWR | O_TRUNC, 0644)));
+  struct pollfd fds[] = {{fd, POLLIN}};
+  EXPECT_SYS(0, 1, poll(fds, 1, -1));
+  EXPECT_TRUE(!!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!(fds[0].revents & POLLOUT));
+  EXPECT_SYS(0, 0, close(fd));
+}
+
+TEST(poll, file_pollout) {
+  int fd;
+  EXPECT_SYS(0, 3, (fd = open("boop", O_CREAT | O_RDWR | O_TRUNC, 0644)));
+  struct pollfd fds[] = {{fd, POLLOUT}};
+  EXPECT_SYS(0, 1, poll(fds, 1, -1));
+  EXPECT_TRUE(!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!!(fds[0].revents & POLLOUT));
+  EXPECT_SYS(0, 0, close(fd));
+}
+
+TEST(poll, file_pollinout) {
+  int fd;
+  EXPECT_SYS(0, 3, (fd = open("boop", O_CREAT | O_RDWR | O_TRUNC, 0644)));
+  struct pollfd fds[] = {{fd, POLLIN | POLLOUT}};
+  EXPECT_SYS(0, 1, poll(fds, 1, -1));
+  EXPECT_TRUE(!!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!!(fds[0].revents & POLLOUT));
+  EXPECT_SYS(0, 0, close(fd));
+}
+
+TEST(poll, file_rdonly_pollinout) {
+  int fd;
+  EXPECT_SYS(0, 3, (fd = open("boop", O_CREAT | O_RDWR | O_TRUNC, 0644)));
+  EXPECT_SYS(0, 0, close(fd));
+  EXPECT_SYS(0, 3, (fd = open("boop", O_RDONLY)));
+  struct pollfd fds[] = {{fd, POLLIN | POLLOUT}};
+  EXPECT_SYS(0, 1, poll(fds, 1, -1));
+  EXPECT_TRUE(!!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!!(fds[0].revents & POLLOUT));  // counter-intuitive
+  EXPECT_SYS(0, 0, close(fd));
+}
+
+TEST(poll, file_wronly_pollin) {
+  int fd;
+  EXPECT_SYS(0, 3, (fd = creat("boop", 0644)));
+  struct pollfd fds[] = {{fd, POLLIN}};
+  EXPECT_SYS(0, 1, poll(fds, 1, -1));
+  EXPECT_TRUE(!!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!(fds[0].revents & POLLOUT));
+  EXPECT_SYS(0, 0, close(fd));
+}
+
+TEST(poll, file_wronly_pollout) {
+  int fd;
+  EXPECT_SYS(0, 3, (fd = creat("boop", 0644)));
+  struct pollfd fds[] = {{fd, POLLOUT}};
+  EXPECT_SYS(0, 1, poll(fds, 1, -1));
+  EXPECT_TRUE(!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!!(fds[0].revents & POLLOUT));
+  EXPECT_SYS(0, 0, close(fd));
+}
+
+TEST(poll, file_wronly_pollinout) {
+  int fd;
+  EXPECT_SYS(0, 3, (fd = creat("boop", 0644)));
+  struct pollfd fds[] = {{fd, POLLIN | POLLOUT}};
+  EXPECT_SYS(0, 1, poll(fds, 1, -1));
+  EXPECT_TRUE(!!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!!(fds[0].revents & POLLOUT));
+  EXPECT_SYS(0, 0, close(fd));
+}
+
+TEST(poll, file_rdwr_pollinoutpri) {
+  int fd;
+  EXPECT_SYS(0, 3, (fd = open("boop", O_CREAT | O_RDWR | O_TRUNC, 0644)));
+  struct pollfd fds[] = {{fd, POLLIN | POLLOUT | POLLPRI}};
+  EXPECT_SYS(0, 1, poll(fds, 1, -1));
+  EXPECT_TRUE(!!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!!(fds[0].revents & POLLOUT));
+  if (IsXnu())
+    EXPECT_TRUE(!!(fds[0].revents & POLLPRI));  // wut
+  else
+    EXPECT_TRUE(!(fds[0].revents & POLLPRI));
+  EXPECT_SYS(0, 0, close(fd));
+}
+
+TEST(poll, pipein_pollout_blocks) {
+  if (IsFreebsd() || IsOpenbsd())
+    return;
+  int pipefds[2];
+  EXPECT_SYS(0, 0, pipe(pipefds));
+  struct pollfd fds[] = {{pipefds[0], POLLOUT}};
+  EXPECT_SYS(0, 0, poll(fds, 1, 0));
+  struct timespec ts1 = timespec_mono();
+  EXPECT_SYS(0, 0, poll(fds, 1, 10));
+  EXPECT_GE(timespec_tomillis(timespec_sub(timespec_mono(), ts1)), 10);
+  EXPECT_SYS(0, 0, close(pipefds[1]));
+  EXPECT_SYS(0, 0, close(pipefds[0]));
+}
+
+TEST(poll, pipein_file_noblock) {
+  if (IsFreebsd() || IsOpenbsd())
+    return;
+  int pipefds[2];
+  EXPECT_SYS(0, 3, open("boop", O_CREAT | O_RDWR | O_TRUNC, 0644));
+  EXPECT_SYS(0, 0, pipe(pipefds));
+  struct pollfd fds[] = {{pipefds[0], POLLIN}, {3, POLLIN}};
+  EXPECT_SYS(0, 1, poll(fds, 2, -1u));
+  EXPECT_TRUE(!!(fds[1].revents & POLLIN));
+  EXPECT_TRUE(!(fds[1].revents & POLLOUT));
+  EXPECT_SYS(0, 0, close(pipefds[1]));
+  EXPECT_SYS(0, 0, close(pipefds[0]));
+  EXPECT_SYS(0, 0, close(3));
+}
+
+TEST(poll, pipein_file_noblock2) {
+  if (IsFreebsd() || IsOpenbsd())
+    return;
+  int pipefds[2];
+  EXPECT_SYS(0, 3, open("boop", O_CREAT | O_RDWR | O_TRUNC, 0644));
+  EXPECT_SYS(0, 0, pipe(pipefds));
+  EXPECT_SYS(0, 1, write(5, "x", 1));
+  struct pollfd fds[] = {{pipefds[0], POLLIN}, {3, POLLIN | POLLOUT}};
+  EXPECT_SYS(0, 2, poll(fds, 2, -1u));
+  EXPECT_TRUE(!!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!(fds[0].revents & POLLOUT));
+  EXPECT_TRUE(!!(fds[1].revents & POLLIN));
+  EXPECT_TRUE(!!(fds[1].revents & POLLOUT));
+  EXPECT_SYS(0, 0, close(pipefds[1]));
+  EXPECT_SYS(0, 0, close(pipefds[0]));
+  EXPECT_SYS(0, 0, close(3));
+}
+
+TEST(poll, pipeout_pollout) {
+  int pipefds[2];
+  EXPECT_SYS(0, 0, pipe(pipefds));
+  struct pollfd fds[] = {{pipefds[1], POLLOUT}};
+  EXPECT_SYS(0, 1, poll(fds, 1, 0));
+  EXPECT_TRUE(!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!!(fds[0].revents & POLLOUT));
+  EXPECT_SYS(0, 1, poll(fds, 1, 1));
+  EXPECT_TRUE(!(fds[0].revents & POLLIN));
+  EXPECT_TRUE(!!(fds[0].revents & POLLOUT));
+  EXPECT_SYS(0, 0, close(pipefds[1]));
+  EXPECT_SYS(0, 0, close(pipefds[0]));
+}
+
+TEST(poll, pipein_pollin_timeout) {
+  int pipefds[2];
+  EXPECT_SYS(0, 0, pipe(pipefds));
+  struct pollfd fds[] = {{pipefds[0], POLLIN}};
+  struct timespec ts1 = timespec_mono();
+  EXPECT_SYS(0, 0, poll(fds, 1, 10));
+  EXPECT_GE(timespec_tomillis(timespec_sub(timespec_mono(), ts1)), 10);
+  EXPECT_SYS(0, 0, close(pipefds[1]));
+  EXPECT_SYS(0, 0, close(pipefds[0]));
+}
+
+TEST(poll, pipein_pollinout_timeout) {
+  if (IsFreebsd() || IsOpenbsd())
+    return;
+  int pipefds[2];
+  EXPECT_SYS(0, 0, pipe(pipefds));
+  struct pollfd fds[] = {{pipefds[0], POLLIN | POLLOUT}};
+  EXPECT_SYS(0, 0, poll(fds, 1, 0));
+  struct timespec ts1 = timespec_mono();
+  EXPECT_SYS(0, 0, poll(fds, 1, 10));
+  EXPECT_GE(timespec_tomillis(timespec_sub(timespec_mono(), ts1)), 10);
+  EXPECT_SYS(0, 0, close(pipefds[1]));
+  EXPECT_SYS(0, 0, close(pipefds[0]));
 }
-#endif
diff --git a/test/libc/calls/raise_test.c b/test/libc/calls/raise_test.c
index 5f764fa38..481f207c3 100644
--- a/test/libc/calls/raise_test.c
+++ b/test/libc/calls/raise_test.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/siginfo.h"
 #include "libc/dce.h"
-#include "libc/intrin/kprintf.h"
+#include "libc/mem/leaks.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sicode.h"
@@ -31,6 +31,7 @@
 #include "libc/thread/thread.h"
 
 TEST(raise, trap) {
+  AssertNoLocksAreHeld();
   signal(SIGTRAP, SIG_DFL);
   SPAWN(fork);
   raise(SIGTRAP);
@@ -45,6 +46,7 @@ TEST(raise, fpe) {
 }
 
 TEST(raise, usr1) {
+  AssertNoLocksAreHeld();
   SPAWN(fork);
   raise(SIGUSR1);
   TERMS(SIGUSR1);
@@ -54,9 +56,8 @@ int threadid;
 
 void WorkerQuit(int sig, siginfo_t *si, void *ctx) {
   ASSERT_EQ(SIGILL, sig);
-  if (!IsXnu() && !IsOpenbsd()) {
+  if (!IsXnu() && !IsOpenbsd())
     ASSERT_EQ(SI_TKILL, si->si_code);
-  }
   ASSERT_EQ(threadid, gettid());
 }
 
@@ -70,6 +71,7 @@ void *Worker(void *arg) {
 
 TEST(raise, threaded) {
   SPAWN(fork);
+  AssertNoLocksAreHeld();
   signal(SIGILL, SIG_DFL);
   pthread_t worker;
   ASSERT_EQ(0, pthread_create(&worker, 0, Worker, 0));
diff --git a/test/libc/calls/reservefd_test.c b/test/libc/calls/reservefd_test.c
index b1013e019..bd8c608d3 100644
--- a/test/libc/calls/reservefd_test.c
+++ b/test/libc/calls/reservefd_test.c
@@ -23,7 +23,7 @@
 #include "libc/calls/struct/rlimit.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
diff --git a/test/libc/sock/select_test.c b/test/libc/calls/select_test.c
similarity index 100%
rename from test/libc/sock/select_test.c
rename to test/libc/calls/select_test.c
diff --git a/test/libc/calls/setrlimit_test.c b/test/libc/calls/setrlimit_test.c
deleted file mode 100644
index 2b7629ee6..000000000
--- a/test/libc/calls/setrlimit_test.c
+++ /dev/null
@@ -1,259 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/core/core.h"
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/rlimit.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/intrin/directmap.internal.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/limits.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/rand.h"
-#include "libc/stdio/stdio.h"
-#include "libc/sysv/consts/auxv.h"
-#include "libc/sysv/consts/map.h"
-#include "libc/sysv/consts/o.h"
-#include "libc/sysv/consts/prot.h"
-#include "libc/sysv/consts/rlimit.h"
-#include "libc/sysv/consts/sig.h"
-#include "libc/testlib/testlib.h"
-#include "libc/time.h"
-#include "libc/x/xsigaction.h"
-#include "libc/x/xspawn.h"
-
-#ifdef __x86_64__
-
-#define MEM (64 * 1024 * 1024)
-
-static char tmpname[PATH_MAX];
-
-void OnSigxcpu(int sig) {
-  ASSERT_EQ(SIGXCPU, sig);
-  _Exit(0);
-}
-
-void OnSigxfsz(int sig) {
-  unlink(tmpname);
-  ASSERT_EQ(SIGXFSZ, sig);
-  _Exit(0);
-}
-
-TEST(setrlimit, testCpuLimit) {
-  int wstatus;
-  struct rlimit rlim;
-  struct timespec start;
-  double matrices[3][3][3];
-  if (IsWindows())
-    return;  // of course it doesn't work on windows
-  if (IsXnu())
-    return;  // TODO(jart): it worked before
-  if (IsOpenbsd())
-    return;  // TODO(jart): fix flake
-  ASSERT_NE(-1, (wstatus = xspawn(0)));
-  if (wstatus == -2) {
-    ASSERT_EQ(0, xsigaction(SIGXCPU, OnSigxcpu, 0, 0, 0));
-    ASSERT_EQ(0, getrlimit(RLIMIT_CPU, &rlim));
-    rlim.rlim_cur = 1;  // set soft limit to one second
-    ASSERT_EQ(0, setrlimit(RLIMIT_CPU, &rlim));
-    start = timespec_real();
-    do {
-      matmul3(matrices[0], matrices[1], matrices[2]);
-      matmul3(matrices[0], matrices[1], matrices[2]);
-      matmul3(matrices[0], matrices[1], matrices[2]);
-      matmul3(matrices[0], matrices[1], matrices[2]);
-    } while (timespec_sub(timespec_real(), start).tv_sec < 5);
-    _Exit(1);
-  }
-  EXPECT_TRUE(WIFEXITED(wstatus));
-  EXPECT_FALSE(WIFSIGNALED(wstatus));
-  EXPECT_EQ(0, WEXITSTATUS(wstatus));
-  EXPECT_EQ(0, WTERMSIG(wstatus));
-}
-
-TEST(setrlimit, testFileSizeLimit) {
-  char junkdata[512];
-  int i, fd, wstatus;
-  struct rlimit rlim;
-  if (IsWindows())
-    return; /* of course it doesn't work on windows */
-  ASSERT_NE(-1, (wstatus = xspawn(0)));
-  if (wstatus == -2) {
-    ASSERT_EQ(0, xsigaction(SIGXFSZ, OnSigxfsz, 0, 0, 0));
-    ASSERT_EQ(0, getrlimit(RLIMIT_FSIZE, &rlim));
-    rlim.rlim_cur = 1024 * 1024; /* set soft limit to one megabyte */
-    ASSERT_EQ(0, setrlimit(RLIMIT_FSIZE, &rlim));
-    snprintf(tmpname, sizeof(tmpname), "%s/%s.%d",
-             firstnonnull(getenv("TMPDIR"), "/tmp"),
-             firstnonnull(program_invocation_short_name, "unknown"), getpid());
-    ASSERT_NE(-1, (fd = open(tmpname, O_RDWR | O_CREAT | O_TRUNC, 0644)));
-    rngset(junkdata, 512, _rand64, -1);
-    for (i = 0; i < 5 * 1024 * 1024 / 512; ++i) {
-      ASSERT_EQ(512, write(fd, junkdata, 512));
-    }
-    close(fd);
-    unlink(tmpname);
-    _Exit(1);
-  }
-  EXPECT_TRUE(WIFEXITED(wstatus));
-  EXPECT_FALSE(WIFSIGNALED(wstatus));
-  EXPECT_EQ(0, WEXITSTATUS(wstatus));
-  EXPECT_EQ(0, WTERMSIG(wstatus));
-}
-
-int SetKernelEnforcedMemoryLimit(size_t n) {
-  struct rlimit rlim;
-  getrlimit(RLIMIT_AS, &rlim);
-  rlim.rlim_cur = n;
-  return setrlimit(RLIMIT_AS, &rlim);
-}
-
-TEST(setrlimit, testMemoryLimit) {
-  char *p;
-  bool gotsome;
-  int i, wstatus;
-  if (IsXnu())
-    return;
-  if (IsOpenbsd())
-    return;  // simply too slow until mmap() becomes O(logn)
-  ASSERT_NE(-1, (wstatus = xspawn(0)));
-  if (wstatus == -2) {
-    ASSERT_EQ(0, SetKernelEnforcedMemoryLimit(MEM));
-    for (gotsome = false, i = 0; i < (MEM * 2) / getauxval(AT_PAGESZ); ++i) {
-      p = mmap(0, getauxval(AT_PAGESZ), PROT_READ | PROT_WRITE,
-               MAP_ANONYMOUS | MAP_PRIVATE | MAP_POPULATE, -1, 0);
-      if (p != MAP_FAILED) {
-        gotsome = true;
-      } else {
-        if (!IsNetbsd()) {
-          // TODO(jart): what's going on with NetBSD?
-          ASSERT_TRUE(gotsome);
-        }
-        ASSERT_EQ(ENOMEM, errno);
-        _Exit(0);
-      }
-      rngset(p, getauxval(AT_PAGESZ), _rand64, -1);
-    }
-    _Exit(1);
-  }
-  EXPECT_TRUE(WIFEXITED(wstatus));
-  EXPECT_FALSE(WIFSIGNALED(wstatus));
-  EXPECT_EQ(0, WEXITSTATUS(wstatus));
-  EXPECT_EQ(0, WTERMSIG(wstatus));
-}
-
-TEST(setrlimit, testVirtualMemoryLimit) {
-  char *p;
-  int i, wstatus;
-  if (IsXnu())
-    return; /* doesn't work on darwin */
-  if (IsOpenbsd())
-    return; /* unavailable on openbsd */
-  if (IsWindows())
-    return; /* of course it doesn't work on windows */
-  ASSERT_NE(-1, (wstatus = xspawn(0)));
-  if (wstatus == -2) {
-    ASSERT_EQ(0, setrlimit(RLIMIT_AS, &(struct rlimit){MEM, MEM}));
-    for (i = 0; i < (MEM * 2) / getauxval(AT_PAGESZ); ++i) {
-      p = sys_mmap(0, getauxval(AT_PAGESZ), PROT_READ | PROT_WRITE,
-                   MAP_ANONYMOUS | MAP_PRIVATE | MAP_POPULATE, -1, 0)
-              .addr;
-      if (p == MAP_FAILED) {
-        ASSERT_EQ(ENOMEM, errno);
-        _Exit(0);
-      }
-      rngset(p, getauxval(AT_PAGESZ), _rand64, -1);
-    }
-    _Exit(1);
-  }
-  EXPECT_TRUE(WIFEXITED(wstatus));
-  EXPECT_FALSE(WIFSIGNALED(wstatus));
-  EXPECT_EQ(0, WEXITSTATUS(wstatus));
-  EXPECT_EQ(0, WTERMSIG(wstatus));
-}
-
-TEST(setrlimit, testDataMemoryLimit) {
-  char *p;
-  int i, wstatus;
-  if (IsXnu())
-    return; /* doesn't work on darwin */
-  if (IsNetbsd())
-    return; /* doesn't work on netbsd */
-  if (IsFreebsd())
-    return; /* doesn't work on freebsd */
-  if (IsLinux())
-    return; /* doesn't work on gnu/systemd */
-  if (IsWindows())
-    return; /* of course it doesn't work on windows */
-  ASSERT_NE(-1, (wstatus = xspawn(0)));
-  if (wstatus == -2) {
-    ASSERT_EQ(0, setrlimit(RLIMIT_DATA, &(struct rlimit){MEM, MEM}));
-    for (i = 0; i < (MEM * 2) / getauxval(AT_PAGESZ); ++i) {
-      p = sys_mmap(0, getauxval(AT_PAGESZ), PROT_READ | PROT_WRITE,
-                   MAP_ANONYMOUS | MAP_PRIVATE | MAP_POPULATE, -1, 0)
-              .addr;
-      if (p == MAP_FAILED) {
-        ASSERT_EQ(ENOMEM, errno);
-        _Exit(0);
-      }
-      rngset(p, getauxval(AT_PAGESZ), _rand64, -1);
-    }
-    _Exit(1);
-  }
-  EXPECT_TRUE(WIFEXITED(wstatus));
-  EXPECT_FALSE(WIFSIGNALED(wstatus));
-  EXPECT_EQ(0, WEXITSTATUS(wstatus));
-  EXPECT_EQ(0, WTERMSIG(wstatus));
-}
-
-TEST(setrlimit, testPhysicalMemoryLimit) {
-  /* RLIMIT_RSS doesn't work on gnu/systemd */
-  /* RLIMIT_RSS doesn't work on darwin */
-  /* RLIMIT_RSS doesn't work on freebsd */
-  /* RLIMIT_RSS doesn't work on netbsd */
-  /* RLIMIT_RSS doesn't work on openbsd */
-  /* of course it doesn't work on windows */
-}
-
-wontreturn void OnVfork(void *ctx) {
-  struct rlimit *rlim;
-  rlim = ctx;
-  rlim->rlim_cur -= 1;
-  ASSERT_EQ(0, getrlimit(RLIMIT_CPU, rlim));
-  _Exit(0);
-}
-
-TEST(setrlimit, isVforkSafe) {
-  int ws;
-  struct rlimit rlim[2];
-  if (IsWindows())
-    return; /* of course it doesn't work on windows */
-  ASSERT_EQ(0, getrlimit(RLIMIT_CPU, rlim));
-  ASSERT_NE(-1, (ws = xvspawn(OnVfork, rlim, 0)));
-  EXPECT_TRUE(WIFEXITED(ws));
-  EXPECT_FALSE(WIFSIGNALED(ws));
-  EXPECT_EQ(0, WEXITSTATUS(ws));
-  EXPECT_EQ(0, WTERMSIG(ws));
-  ASSERT_EQ(0, getrlimit(RLIMIT_CPU, rlim + 1));
-  EXPECT_EQ(rlim[0].rlim_cur, rlim[1].rlim_cur);
-  EXPECT_EQ(rlim[0].rlim_max, rlim[1].rlim_max);
-}
-
-#endif /* __x86_64__ */
diff --git a/test/libc/calls/shm_open_test.c b/test/libc/calls/shm_open_test.c
index da7909fef..1d8f71a2b 100644
--- a/test/libc/calls/shm_open_test.c
+++ b/test/libc/calls/shm_open_test.c
@@ -5,9 +5,11 @@
 #include "libc/atomic.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
+#include "libc/ctype.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/runtime/runtime.h"
+#include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/map.h"
@@ -17,7 +19,6 @@
 #include "libc/sysv/consts/sig.h"
 #include "libc/thread/semaphore.h"
 
-#define SHM_PATH    "/fc7261622dd420d8"
 #define STRING_SEND "hello"
 #define STRING_RECV "HELLO"
 
@@ -28,13 +29,14 @@ struct shmbuf {
   char buf[256]; /* Data being transferred */
 };
 
+char shm_path[64];
 atomic_bool *ready;
 
 wontreturn void Bouncer(void) {
 
   /* Create shared memory object and set its size to the size
      of our structure. */
-  int fd = shm_open(SHM_PATH, O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR);
+  int fd = shm_open(shm_path, O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR);
   if (fd == -1) {
     perror("shm_open(bouncer)");
     exit(1);
@@ -95,7 +97,7 @@ wontreturn void Sender(void) {
 
   /* Open the existing shared memory object and map it
      into the caller's address space. */
-  int fd = shm_open(SHM_PATH, O_RDWR, 0);
+  int fd = shm_open(shm_path, O_RDWR, 0);
   if (fd == -1) {
     perror("shm_open(sender)");
     exit(1);
@@ -135,7 +137,7 @@ wontreturn void Sender(void) {
   /* Unlink the shared memory object. Even if the peer process
      is still using the object, this is okay. The object will
      be removed only after all open references are closed. */
-  if (shm_unlink(SHM_PATH)) {
+  if (shm_unlink(shm_path)) {
     if (IsWindows() && errno == EACCES) {
       // TODO(jart): Make unlink() work better on Windows.
     } else {
@@ -153,7 +155,7 @@ int pid2;
 void OnExit(void) {
   kill(pid1, SIGKILL);
   kill(pid2, SIGKILL);
-  shm_unlink(SHM_PATH);
+  shm_unlink(shm_path);
 }
 
 void OnTimeout(int sig) {
@@ -163,6 +165,9 @@ void OnTimeout(int sig) {
 
 int main(int argc, char *argv[]) {
 
+  // create random shared memory name
+  sprintf(shm_path, "/shm_open_test-%ld", _rand64());
+
   // create synchronization object
   ready = _mapshared(1);
 
diff --git a/test/libc/calls/sigaction_test.c b/test/libc/calls/sigaction_test.c
index 9206016e2..b856b7b49 100644
--- a/test/libc/calls/sigaction_test.c
+++ b/test/libc/calls/sigaction_test.c
@@ -400,15 +400,16 @@ TEST(sigaction, ignoreSigSegv_notPossible) {
   _Exit(pSegfault(0));
   TERMS(SIGSEGV);
 }
+#endif
 
+#if 0
+// TODO(jart): Use sigsuspend() to make not flaky.
 TEST(sigaction, killSigSegv_canBeIgnored) {
   int child, ws;
-  if (IsWindows()) return;  // TODO
   sighandler_t old = signal(SIGSEGV, SIG_IGN);
   ASSERT_NE(-1, (child = fork()));
-  while (!child) {
+  while (!child)
     pause();
-  }
   ASSERT_SYS(0, 0, kill(child, SIGSEGV));
   EXPECT_SYS(0, 0, kill(child, SIGTERM));
   EXPECT_SYS(0, child, wait(&ws));
diff --git a/test/libc/calls/sigaltstack_test.c b/test/libc/calls/sigaltstack_test.c
new file mode 100644
index 000000000..3c1d63bac
--- /dev/null
+++ b/test/libc/calls/sigaltstack_test.c
@@ -0,0 +1,53 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/sigaltstack.h"
+#include "libc/calls/calls.h"
+#include "libc/errno.h"
+#include "libc/mem/gc.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/sysconf.h"
+#include "libc/sysv/consts/ss.h"
+#include "libc/testlib/testlib.h"
+
+TEST(sigaltstack, badFlag) {
+  struct sigaltstack ss;
+  ss.ss_flags = -1;
+  ss.ss_size = 0;
+  ss.ss_sp = 0;
+  EXPECT_SYS(EINVAL, -1, sigaltstack(&ss, 0));
+}
+
+TEST(sigaltstack, disable) {
+  struct sigaltstack ss;
+  EXPECT_SYS(0, 0, sigaltstack(0, &ss));
+  ss.ss_flags = SS_DISABLE;
+  EXPECT_SYS(0, 0, sigaltstack(&ss, 0));
+  EXPECT_SYS(0, 0, sigaltstack(0, &ss));
+  EXPECT_EQ(SS_DISABLE, ss.ss_flags);
+}
+
+TEST(sigaltstack, size_requirement) {
+  struct sigaltstack ss;
+  EXPECT_SYS(0, 0, sigaltstack(0, &ss));
+  ss.ss_size = sysconf(_SC_MINSIGSTKSZ);
+  ss.ss_sp = gc(malloc(ss.ss_size));
+  ss.ss_flags = 0;
+  ASSERT_SYS(0, 0, sigaltstack(&ss, 0));
+  ASSERT_SYS(0, 0, sigaltstack(0, &ss));
+}
diff --git a/test/libc/calls/sigbus_test.c b/test/libc/calls/sigbus_test.c
index f67fac42e..e76983933 100644
--- a/test/libc/calls/sigbus_test.c
+++ b/test/libc/calls/sigbus_test.c
@@ -75,7 +75,7 @@ TEST(sigbus, test) {
 
   // map two pages of the file into memory
   char *map;
-  long pagesz = getauxval(AT_PAGESZ);
+  long pagesz = getpagesize();
   ASSERT_NE(MAP_FAILED,
             (map = mmap(0, pagesz * 2, PROT_READ, MAP_PRIVATE, 3, 0)));
 
diff --git a/test/libc/calls/signal_test.c b/test/libc/calls/signal_test.c
deleted file mode 100644
index 74dfad41b..000000000
--- a/test/libc/calls/signal_test.c
+++ /dev/null
@@ -1,105 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/sigaction.h"
-#include "libc/calls/struct/sigset.h"
-#include "libc/calls/ucontext.h"
-#include "libc/dce.h"
-#include "libc/log/check.h"
-#include "libc/log/log.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sysv/consts/sa.h"
-#include "libc/sysv/consts/sig.h"
-#include "libc/testlib/ezbench.h"
-#include "libc/testlib/testlib.h"
-
-void OnUsr1(int sig) {
-  _exit(0);
-}
-
-void SetUpOnce(void) {
-  sigset_t ss;
-  sigprocmask(SIG_SETMASK, 0, &ss);
-  ASSERT_SYS(0, 0, pledge("stdio proc", 0));
-}
-
-TEST(signal, test) {
-  ASSERT_NE(SIG_ERR, signal(SIGUSR1, OnUsr1));
-  ASSERT_NE(-1, raise(SIGUSR1));
-  __die();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// signal round-trip delivery takes about 1µs
-
-void OnSigTrap(int sig, siginfo_t *si, void *ctx) {
-}
-
-void TrapBench(int n) {
-  for (int i = 0; i < n; ++i) {
-    DebugBreak();
-  }
-}
-
-BENCH(signal, trapBench) {
-  struct sigaction old;
-  struct sigaction sabus = {.sa_sigaction = OnSigTrap};
-  ASSERT_SYS(0, 0, sigaction(SIGTRAP, &sabus, &old));
-  EZBENCH_N("signal trap", 16, TrapBench(16));
-  EZBENCH_N("signal trap", 256, TrapBench(256));
-  EZBENCH_N("signal trap", 1024, TrapBench(1024));
-  sigaction(SIGTRAP, &old, 0);
-}
-
-BENCH(signal, trapBenchSiginfo) {
-  struct sigaction old;
-  struct sigaction sabus = {.sa_sigaction = OnSigTrap, .sa_flags = SA_SIGINFO};
-  ASSERT_SYS(0, 0, sigaction(SIGTRAP, &sabus, &old));
-  EZBENCH_N("siginfo trap", 16, TrapBench(16));
-  EZBENCH_N("siginfo trap", 256, TrapBench(256));
-  EZBENCH_N("siginfo trap", 1024, TrapBench(1024));
-  sigaction(SIGTRAP, &old, 0);
-}
-
-#ifdef __x86_64__
-
-void OnSigHlt(int sig, siginfo_t *si, void *vctx) {
-  struct ucontext *ctx = vctx;
-  ctx->uc_mcontext.rip += 1;
-}
-
-void HltBench(int n) {
-  for (int i = 0; i < n; ++i) {
-    asm("hlt");
-  }
-}
-
-BENCH(signal, hltBenchSiginfo) {
-  struct sigaction old[2];
-  struct sigaction sabus = {.sa_sigaction = OnSigHlt, .sa_flags = SA_SIGINFO};
-  ASSERT_SYS(0, 0, sigaction(SIGSEGV, &sabus, old + 0));
-  ASSERT_SYS(0, 0, sigaction(SIGBUS, &sabus, old + 1));
-  EZBENCH_N("siginfo hlt", 16, HltBench(16));
-  EZBENCH_N("siginfo hlt", 256, HltBench(256));
-  EZBENCH_N("siginfo hlt", 1024, HltBench(1024));
-  sigaction(SIGSEGV, old + 0, 0);
-  sigaction(SIGBUS, old + 1, 0);
-}
-
-#endif /* __x86_64__ */
diff --git a/test/libc/calls/sigprocmask_test.c b/test/libc/calls/sigprocmask_test.c
index e794b2b3c..5d378bb6b 100644
--- a/test/libc/calls/sigprocmask_test.c
+++ b/test/libc/calls/sigprocmask_test.c
@@ -45,7 +45,7 @@ const char *DescribeMask(void) {
   sigset_t ss;
   _Thread_local static char buf[128];
   unassert(!sigprocmask(SIG_SETMASK, 0, &ss));
-  return (DescribeSigset)(buf, 0, &ss);
+  return _DescribeSigset(buf, 0, &ss);
 }
 
 TEST(sigprocmask, testMultipleBlockedDeliveries) {
diff --git a/test/libc/calls/sigsuspend_test.c b/test/libc/calls/sigsuspend_test.c
index 457c3ba23..8386005ac 100644
--- a/test/libc/calls/sigsuspend_test.c
+++ b/test/libc/calls/sigsuspend_test.c
@@ -76,10 +76,6 @@ TEST(sigsuspend, testSignalQueuingSelf) {
 }
 
 TEST(sigsuspend, testSignalQueuingIpc) {
-  if (IsWindows()) {
-    // xxx: probably need a signal server to do this kind of signalling
-    return;
-  }
   int pid, ws;
   sigset_t neu, old, bits;
   struct sigaction oldusr1, oldusr2;
diff --git a/test/libc/calls/sigtimedwait_test.c b/test/libc/calls/sigtimedwait_test.c
index 9103485c5..270e9e69e 100644
--- a/test/libc/calls/sigtimedwait_test.c
+++ b/test/libc/calls/sigtimedwait_test.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/sigtimedwait.h"
+#include "libc/atomic.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/siginfo.h"
 #include "libc/calls/struct/siginfo.internal.h"
@@ -28,22 +29,17 @@
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/testlib.h"
+#include "libc/thread/thread.h"
 
 void SetUp(void) {
   if (IsXnu())
     exit(0);
   if (IsMetal())
     exit(0);
-  if (IsWindows())
-    exit(0);
   if (IsOpenbsd())
     exit(0);
 }
 
-TEST(sigtimedwait, nullSet_efault) {
-  ASSERT_SYS(EFAULT, -1, sigtimedwait(0, 0, 0));
-}
-
 TEST(sigtimedwait, emptySet_timesOut) {
   sigset_t ss = {0};
   struct timespec ts = {0, 0};
@@ -56,24 +52,28 @@ TEST(sigtimedwait, badTimestamp_einval) {
   ASSERT_SYS(EINVAL, -1, sigtimedwait(&ss, 0, &ts));
 }
 
-TEST(sigtimedwait, test) {
-  int pid, ws;
+atomic_bool g_ready;
+
+void *worker(void *arg) {
+  sigset_t ss;
   siginfo_t info;
-  sigset_t ss, oldss;
-  struct timespec ts = {1, 0};
-  sigemptyset(&ss);
-  sigaddset(&ss, SIGUSR1);
-  ASSERT_SYS(0, 0, sigprocmask(SIG_BLOCK, &ss, &oldss));
-  ASSERT_NE(-1, (pid = fork()));
-  if (!pid) {
-    ASSERT_SYS(0, SIGUSR1, sigtimedwait(&ss, &info, &ts));
-    ASSERT_EQ(SIGUSR1, info.si_signo);
-    ASSERT_EQ(SI_USER, info.si_code);
-    ASSERT_EQ(getuid(), info.si_uid);
-    _Exit(0);
-  }
-  ASSERT_SYS(0, 0, kill(pid, SIGUSR1));
-  ASSERT_SYS(0, pid, wait(&ws));
-  ASSERT_EQ(0, ws);
-  ASSERT_SYS(0, 0, sigprocmask(SIG_SETMASK, &oldss, 0));
+  ASSERT_EQ(0, sigemptyset(&ss));
+  ASSERT_EQ(0, sigaddset(&ss, SIGUSR1));
+  ASSERT_SYS(0, 0, sigprocmask(SIG_BLOCK, &ss, 0));
+  g_ready = true;
+  ASSERT_SYS(0, SIGUSR1, sigtimedwait(&ss, &info, 0));
+  ASSERT_EQ(SIGUSR1, info.si_signo);
+  ASSERT_EQ(SI_TKILL, info.si_code);
+  ASSERT_EQ(getuid(), info.si_uid);
+  return 0;
+}
+
+TEST(sigtimedwait, test) {
+  pthread_t th;
+  ASSERT_EQ(0, pthread_create(&th, 0, worker, 0));
+  for (;;)
+    if (g_ready)
+      break;
+  ASSERT_EQ(0, pthread_kill(th, SIGUSR1));
+  ASSERT_EQ(0, pthread_join(th, 0));
 }
diff --git a/test/libc/calls/stackoverflow1_test.c b/test/libc/calls/stackoverflow1_test.c
index 88b6fff9d..c9397cbba 100644
--- a/test/libc/calls/stackoverflow1_test.c
+++ b/test/libc/calls/stackoverflow1_test.c
@@ -16,10 +16,14 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/atomic.h"
 #include "libc/calls/struct/rlimit.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/sigaltstack.h"
 #include "libc/calls/struct/siginfo.h"
+#include "libc/calls/struct/ucontext.internal.h"
+#include "libc/calls/ucontext.h"
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
@@ -27,12 +31,15 @@
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/sysconf.h"
+#include "libc/stdio/rand.h"
+#include "libc/stdio/stdio.h"
 #include "libc/stdio/sysparam.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/rlimit.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/consts/ss.h"
-#include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
 
 /**
@@ -42,15 +49,17 @@
  */
 
 jmp_buf recover;
-volatile bool smashed_stack;
+atomic_bool g_isdone;
+atomic_bool smashed_stack;
 
 void CrashHandler(int sig, siginfo_t *si, void *ctx) {
   struct sigaltstack ss;
-  ASSERT_SYS(0, 0, sigaltstack(0, &ss));
-  ASSERT_EQ(SS_ONSTACK, ss.ss_flags);
-  kprintf("kprintf avoids overflowing %G %p\n", si->si_signo, si->si_addr);
+  unassert(!sigaltstack(0, &ss));
+  unassert(SS_ONSTACK == ss.ss_flags);
+  kprintf("kprintf avoids overflowing %G si_addr=%lx sp=%lx\n", si->si_signo,
+          si->si_addr, ((ucontext_t *)ctx)->uc_mcontext.SP);
   smashed_stack = true;
-  ASSERT_TRUE(__is_stack_overflow(si, ctx));
+  // unassert(__is_stack_overflow(si, ctx)); // fuzzy with main thread
   longjmp(recover, 123);
 }
 
@@ -63,7 +72,7 @@ void SetUp(void) {
     struct rlimit rl;
     getrlimit(RLIMIT_STACK, &rl);
     rl.rlim_cur = MIN(rl.rlim_cur, 2 * 1024 * 1024);
-    ASSERT_SYS(0, 0, setrlimit(RLIMIT_STACK, &rl));
+    unassert(!setrlimit(RLIMIT_STACK, &rl));
   }
 
   // set up the signal handler and alternative stack
@@ -72,7 +81,7 @@ void SetUp(void) {
   ss.ss_flags = 0;
   ss.ss_size = sysconf(_SC_MINSIGSTKSZ) + 8192;
   ss.ss_sp = _mapanon(ss.ss_size);
-  ASSERT_SYS(0, 0, sigaltstack(&ss, 0));
+  unassert(!sigaltstack(&ss, 0));
   sa.sa_flags = SA_SIGINFO | SA_ONSTACK;  // <-- important
   sigemptyset(&sa.sa_mask);
   sa.sa_sigaction = CrashHandler;
@@ -80,33 +89,48 @@ void SetUp(void) {
   sigaction(SIGSEGV, &sa, 0);
 }
 
-int StackOverflow(int f(), int n) {
-  if (n < INT_MAX) {
-    return f(f, n + 1) - 1;
-  } else {
-    return INT_MAX;
-  }
+int StackOverflow(int d) {
+  char A[8];
+  for (int i = 0; i < sizeof(A); i++)
+    A[i] = d + i;
+  if (__veil("r", d))
+    return StackOverflow(d + 1) + A[d % sizeof(A)];
+  return 0;
 }
 
-int (*pStackOverflow)(int (*)(), int) = StackOverflow;
+void *innocent_thread(void *arg) {
+  atomic_long dont_clobber_me_bro = 0;
+  while (!g_isdone)
+    unassert(!dont_clobber_me_bro);
+  return 0;
+}
 
-TEST(stackoverflow, standardStack_altStack_process_longjmp) {
-  if (IsTiny())
-    return;  // TODO(jart): why?
+int main() {
+
+  // libc/intrin/stack.c is designed so that this thread's stack should
+  // be allocated right beneath the main thread's stack. our goal is to
+  // make sure overflowing the main stack won't clobber our poor thread
+  pthread_t th;
+  unassert(!pthread_create(&th, 0, innocent_thread, 0));
+
+  SetUp();
 
   int jumpcode;
-  if (!(jumpcode = setjmp(recover))) {
-    exit(pStackOverflow(pStackOverflow, 0));
-  }
-  ASSERT_EQ(123, jumpcode);
-  ASSERT_TRUE(smashed_stack);
+  if (!(jumpcode = setjmp(recover)))
+    exit(StackOverflow(1));
+  unassert(123 == jumpcode);
+  unassert(smashed_stack);
+
+  // join the thread
+  g_isdone = true;
+  unassert(!pthread_join(th, 0));
 
   // here's where longjmp() gets us into trouble
   struct sigaltstack ss;
-  ASSERT_SYS(0, 0, sigaltstack(0, &ss));
+  unassert(!sigaltstack(0, &ss));
   if (IsXnu() || IsNetbsd()) {
-    ASSERT_EQ(SS_ONSTACK, ss.ss_flags);  // wut
+    unassert(SS_ONSTACK == ss.ss_flags);  // wut
   } else {
-    ASSERT_EQ(0, ss.ss_flags);
+    unassert(0 == ss.ss_flags);
   }
 }
diff --git a/test/libc/calls/stackoverflow2_test.c b/test/libc/calls/stackoverflow2_test.c
index 6888c0ad1..520d952e8 100644
--- a/test/libc/calls/stackoverflow2_test.c
+++ b/test/libc/calls/stackoverflow2_test.c
@@ -16,20 +16,26 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/sigaltstack.h"
 #include "libc/calls/struct/siginfo.h"
+#include "libc/calls/struct/ucontext.internal.h"
+#include "libc/calls/ucontext.h"
+#include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
+#include "libc/intrin/maps.h"
 #include "libc/limits.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
+#include "libc/runtime/stack.h"
 #include "libc/runtime/sysconf.h"
+#include "libc/stdio/stdio.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/consts/ss.h"
-#include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
 
 /**
@@ -38,68 +44,81 @@
  * simple but it can upset kernels / libraries
  */
 
-jmp_buf recover;
-volatile bool smashed_stack;
+sigjmp_buf recover;
+atomic_bool is_done;
+atomic_bool smashed_stack;
+atomic_bool clobbered_other_thread;
 
 void CrashHandler(int sig, siginfo_t *si, void *ctx) {
   struct sigaltstack ss;
-  ASSERT_SYS(0, 0, sigaltstack(0, &ss));
-  ASSERT_EQ(SS_ONSTACK, ss.ss_flags);
-  kprintf("kprintf avoids overflowing %G %p\n", si->si_signo, si->si_addr);
+  unassert(!sigaltstack(0, &ss));
+  unassert(SS_ONSTACK == ss.ss_flags);
+  kprintf("kprintf avoids overflowing %G si_addr=%lx sp=%lx\n", si->si_signo,
+          si->si_addr, ((ucontext_t *)ctx)->uc_mcontext.SP);
   smashed_stack = true;
-  ASSERT_TRUE(__is_stack_overflow(si, ctx));
-  longjmp(recover, 123);
+  unassert(__is_stack_overflow(si, ctx));
+  siglongjmp(recover, 123);
 }
 
-int StackOverflow(int f(), int n) {
-  if (n < INT_MAX) {
-    return f(f, n + 1) - 1;
-  } else {
-    return INT_MAX;
-  }
+int StackOverflow(int d) {
+  char A[8];
+  for (int i = 0; i < sizeof(A); i++)
+    A[i] = d + i;
+  if (__veil("r", d))
+    return StackOverflow(d + 1) + A[d % sizeof(A)];
+  return 0;
 }
 
-int (*pStackOverflow)(int (*)(), int) = StackOverflow;
-
 void *MyPosixThread(void *arg) {
   int jumpcode;
   struct sigaction sa, o1, o2;
   struct sigaltstack ss;
   ss.ss_flags = 0;
-  ss.ss_size = sysconf(_SC_MINSIGSTKSZ) + 4096;
+  ss.ss_size = sysconf(_SC_MINSIGSTKSZ) + 2048;
   ss.ss_sp = gc(malloc(ss.ss_size));
-  ASSERT_SYS(0, 0, sigaltstack(&ss, 0));
+  unassert(!sigaltstack(&ss, 0));
   sa.sa_flags = SA_SIGINFO | SA_ONSTACK;  // <-- important
   sigemptyset(&sa.sa_mask);
   sa.sa_sigaction = CrashHandler;
   sigaction(SIGBUS, &sa, &o1);
   sigaction(SIGSEGV, &sa, &o2);
-  if (!(jumpcode = setjmp(recover))) {
-    exit(pStackOverflow(pStackOverflow, 0));
-  }
-  ASSERT_EQ(123, jumpcode);
+  if (!(jumpcode = sigsetjmp(recover, 1)))
+    exit(StackOverflow(1));
+  unassert(123 == jumpcode);
   sigaction(SIGSEGV, &o2, 0);
   sigaction(SIGBUS, &o1, 0);
   // here's where longjmp() gets us into trouble
-  ASSERT_SYS(0, 0, sigaltstack(0, &ss));
+  unassert(!sigaltstack(0, &ss));
   if (IsXnu() || IsNetbsd()) {
-    ASSERT_EQ(SS_ONSTACK, ss.ss_flags);  // wut
+    unassert(SS_ONSTACK == ss.ss_flags);  // wut
   } else {
-    ASSERT_EQ(0, ss.ss_flags);
+    unassert(!ss.ss_flags);
   }
   return 0;
 }
 
-TEST(stackoverflow, standardStack_altStack_thread_longjmp) {
-  pthread_t th;
+void *InnocentThread(void *arg) {
+  atomic_long dont_clobber_me_bro = 0;
+  while (!is_done)
+    if (dont_clobber_me_bro)
+      clobbered_other_thread = true;
+  pthread_exit(0);
+}
+
+int main() {
+  pthread_t th, in;
   struct sigaltstack ss;
   for (int i = 0; i < 2; ++i) {
+    is_done = false;
     smashed_stack = false;
-    pthread_create(&th, 0, MyPosixThread, 0);
-    pthread_join(th, 0);
-    ASSERT_TRUE(smashed_stack);
-    // this should be SS_DISABLE but ShowCrashReports() creates an alt stack
-    ASSERT_SYS(0, 0, sigaltstack(0, &ss));
-    ASSERT_EQ(0, ss.ss_flags);
+    unassert(!pthread_create(&th, 0, MyPosixThread, 0));
+    unassert(!pthread_create(&in, 0, InnocentThread, 0));
+    unassert(!pthread_join(th, 0));
+    unassert(smashed_stack);
+    unassert(!sigaltstack(0, &ss));
+    unassert(ss.ss_flags == SS_DISABLE);
+    unassert(!clobbered_other_thread);
+    is_done = true;
+    unassert(!pthread_join(in, 0));
   }
 }
diff --git a/test/libc/calls/stackoverflow3_test.c b/test/libc/calls/stackoverflow3_test.c
index d7cfe2870..b83ebcf25 100644
--- a/test/libc/calls/stackoverflow3_test.c
+++ b/test/libc/calls/stackoverflow3_test.c
@@ -85,21 +85,20 @@ void CrashHandler(int sig, siginfo_t *si, void *arg) {
 #endif
 }
 
-int StackOverflow(int f(), int n) {
-  if (n < INT_MAX) {
-    return f(f, n + 1) - 1;
-  } else {
-    return INT_MAX;
-  }
+int StackOverflow(int d) {
+  char A[8];
+  for (int i = 0; i < sizeof(A); i++)
+    A[i] = d + i;
+  if (__veil("r", d))
+    return StackOverflow(d + 1) + A[d % sizeof(A)];
+  return 0;
 }
 
-int (*pStackOverflow)(int (*)(), int) = StackOverflow;
-
 void *MyPosixThread(void *arg) {
   struct sigaction sa;
   struct sigaltstack ss;
   ss.ss_flags = 0;
-  ss.ss_size = sysconf(_SC_MINSIGSTKSZ) + 4096;
+  ss.ss_size = sysconf(_SC_MINSIGSTKSZ) + 8192;
   ss.ss_sp = gc(malloc(ss.ss_size));
   ASSERT_SYS(0, 0, sigaltstack(&ss, 0));
   sa.sa_flags = SA_SIGINFO | SA_ONSTACK;  // <-- important
@@ -107,7 +106,7 @@ void *MyPosixThread(void *arg) {
   sa.sa_sigaction = CrashHandler;
   sigaction(SIGBUS, &sa, 0);
   sigaction(SIGSEGV, &sa, 0);
-  exit(pStackOverflow(pStackOverflow, 0));
+  exit(StackOverflow(1));
   return 0;
 }
 
diff --git a/test/libc/calls/stackoverflow4_test.c b/test/libc/calls/stackoverflow4_test.c
index 8547d4b24..a9b1eab2f 100644
--- a/test/libc/calls/stackoverflow4_test.c
+++ b/test/libc/calls/stackoverflow4_test.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/sigaltstack.h"
 #include "libc/calls/struct/siginfo.h"
@@ -40,34 +41,34 @@
 
 volatile bool smashed_stack;
 
-void CrashHandler(int sig) {
+void CrashHandler(int sig, siginfo_t *si, void *ctx) {
   smashed_stack = true;
+  unassert(__is_stack_overflow(si, ctx));
   pthread_exit((void *)123L);
 }
 
-int StackOverflow(int f(), int n) {
-  if (n < INT_MAX) {
-    return f(f, n + 1) - 1;
-  } else {
-    return INT_MAX;
-  }
+int StackOverflow(int d) {
+  char A[8];
+  for (int i = 0; i < sizeof(A); i++)
+    A[i] = d + i;
+  if (__veil("r", d))
+    return StackOverflow(d + 1) + A[d % sizeof(A)];
+  return 0;
 }
 
-int (*pStackOverflow)(int (*)(), int) = StackOverflow;
-
 void *MyPosixThread(void *arg) {
   struct sigaction sa;
   struct sigaltstack ss;
   ss.ss_flags = 0;
-  ss.ss_size = sysconf(_SC_MINSIGSTKSZ) + 4096;
+  ss.ss_size = sysconf(_SC_MINSIGSTKSZ) + 1024;
   ss.ss_sp = gc(malloc(ss.ss_size));
   ASSERT_SYS(0, 0, sigaltstack(&ss, 0));
   sa.sa_flags = SA_SIGINFO | SA_ONSTACK;  // <-- important
   sigemptyset(&sa.sa_mask);
-  sa.sa_handler = CrashHandler;
+  sa.sa_sigaction = CrashHandler;
   sigaction(SIGBUS, &sa, 0);
   sigaction(SIGSEGV, &sa, 0);
-  exit(pStackOverflow(pStackOverflow, 0));
+  exit(StackOverflow(1));
   return 0;
 }
 
diff --git a/test/libc/calls/stackoverflow5_test.c b/test/libc/calls/stackoverflow5_test.c
new file mode 100644
index 000000000..29a4097d1
--- /dev/null
+++ b/test/libc/calls/stackoverflow5_test.c
@@ -0,0 +1,89 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/sigaction.h"
+#include "libc/calls/struct/siginfo.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sysv/consts/sa.h"
+#include "libc/sysv/consts/sig.h"
+#include "libc/sysv/consts/ss.h"
+#include "libc/thread/thread.h"
+#include "libc/thread/tls.h"
+
+/**
+ * stack overflow test #5
+ * - make sure fork() preserves sigaltstack()
+ * - make sure fork() preserves guard page status
+ */
+
+jmp_buf recover;
+
+void CrashHandler(int sig, siginfo_t *si, void *ctx) {
+  unassert(__is_stack_overflow(si, ctx));
+  longjmp(recover, 123);
+}
+
+int StackOverflow(int d) {
+  char A[8];
+  for (int i = 0; i < sizeof(A); i++)
+    A[i] = d + i;
+  if (__veil("r", d))
+    return StackOverflow(d + 1) + A[d % sizeof(A)];
+  return 0;
+}
+
+void *MyPosixThread(void *arg) {
+  int pid;
+  unassert(__get_tls()->tib_sigstack_addr);
+  unassert((pid = fork()) != -1);
+  if (!pid) {
+    int jumpcode;
+    if (!(jumpcode = setjmp(recover))) {
+      StackOverflow(1);
+      _Exit(1);
+    }
+    unassert(123 == jumpcode);
+  } else {
+    int ws;
+    unassert(wait(&ws) != -1);
+    unassert(!ws);
+    pthread_exit(0);
+  }
+  return 0;
+}
+
+int main() {
+
+  struct sigaction sa;
+  sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
+  sigemptyset(&sa.sa_mask);
+  sa.sa_sigaction = CrashHandler;
+  unassert(!sigaction(SIGBUS, &sa, 0));
+  unassert(!sigaction(SIGSEGV, &sa, 0));
+
+  pthread_t th;
+  pthread_attr_t attr;
+  unassert(!pthread_attr_init(&attr));
+  unassert(!pthread_attr_setguardsize(&attr, getpagesize()));
+  unassert(!pthread_attr_setsigaltstacksize_np(&attr, SIGSTKSZ));
+  unassert(!pthread_create(&th, &attr, MyPosixThread, 0));
+  unassert(!pthread_attr_destroy(&attr));
+  unassert(!pthread_join(th, 0));
+}
diff --git a/test/libc/calls/unveil_test.c b/test/libc/calls/unveil_test.c
index 2e3c97a4f..f0f361cb2 100644
--- a/test/libc/calls/unveil_test.c
+++ b/test/libc/calls/unveil_test.c
@@ -335,7 +335,7 @@ TEST(unveil, isThreadSpecificOnLinux_isProcessWideOnOpenbsd) {
 TEST(unveil, usedTwice_forbidden_worksWithPledge) {
   int ws, pid;
   bool *gotsome;
-  ASSERT_NE(-1, (gotsome = _mapshared(__granularity())));
+  ASSERT_NE(-1, (gotsome = _mapshared(getpagesize())));
   ASSERT_NE(-1, (pid = fork()));
   if (!pid) {
     __pledge_mode = PLEDGE_PENALTY_KILL_PROCESS;
@@ -359,7 +359,7 @@ TEST(unveil, usedTwice_forbidden_worksWithPledge) {
   ASSERT_TRUE(*gotsome);
   ASSERT_TRUE(WIFSIGNALED(ws));
   ASSERT_EQ(IsOpenbsd() ? SIGABRT : SIGSYS, WTERMSIG(ws));
-  EXPECT_SYS(0, 0, munmap(gotsome, __granularity()));
+  EXPECT_SYS(0, 0, munmap(gotsome, getpagesize()));
 }
 
 TEST(unveil, lotsOfPaths) {
diff --git a/test/libc/calls/writev_test.c b/test/libc/calls/writev_test.c
index c6a9a9540..834ae1a90 100644
--- a/test/libc/calls/writev_test.c
+++ b/test/libc/calls/writev_test.c
@@ -21,7 +21,7 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/test/libc/fmt/formatint64thousands_test.c b/test/libc/fmt/formatint64thousands_test.c
index c52389ebc..b0b1398b6 100644
--- a/test/libc/fmt/formatint64thousands_test.c
+++ b/test/libc/fmt/formatint64thousands_test.c
@@ -19,7 +19,7 @@
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/stdio/stdio.h"
 #include "libc/testlib/ezbench.h"
diff --git a/test/libc/intrin/BUILD.mk b/test/libc/intrin/BUILD.mk
index 5ca755af0..7a1ce1756 100644
--- a/test/libc/intrin/BUILD.mk
+++ b/test/libc/intrin/BUILD.mk
@@ -37,14 +37,16 @@ TEST_LIBC_INTRIN_DIRECTDEPS =					\
 	LIBC_STR						\
 	LIBC_SYSV						\
 	LIBC_SYSV_CALLS						\
-	LIBC_THREAD						\
 	LIBC_TESTLIB						\
+	LIBC_THREAD						\
 	LIBC_TINYMATH						\
 	LIBC_X							\
-	TOOL_VIZ_LIB						\
 	THIRD_PARTY_COMPILER_RT					\
+	THIRD_PARTY_MUSL					\
 	THIRD_PARTY_NSYNC					\
-	THIRD_PARTY_XED
+	THIRD_PARTY_OPENMP					\
+	THIRD_PARTY_XED						\
+	TOOL_VIZ_LIB						\
 
 TEST_LIBC_INTRIN_DEPS :=					\
 	$(call uniq,$(foreach x,$(TEST_LIBC_INTRIN_DIRECTDEPS),$($(x))))
@@ -57,6 +59,15 @@ o/$(MODE)/test/libc/intrin/%.dbg:				\
 		$(TEST_LIBC_INTRIN_DEPS)			\
 		o/$(MODE)/test/libc/intrin/%.o			\
 		o/$(MODE)/test/libc/intrin/intrin.pkg		\
+		$(LIBC_TESTMAIN)				\
+		$(CRT)						\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
+o/$(MODE)/test/libc/intrin/mmap_test.dbg:			\
+		$(TEST_LIBC_INTRIN_DEPS)			\
+		o/$(MODE)/test/libc/intrin/mmap_test.o		\
+		o/$(MODE)/test/libc/intrin/intrin.pkg		\
 		o/$(MODE)/test/libc/mem/prog/life.elf.zip.o	\
 		$(LIBC_TESTMAIN)				\
 		$(CRT)						\
@@ -76,6 +87,10 @@ $(TEST_LIBC_INTRIN_OBJS): private				\
 		CFLAGS +=					\
 			-fno-builtin
 
+$(TEST_LIBC_INTRIN_OBJS): private				\
+		CXXFLAGS +=					\
+			-fopenmp
+
 .PHONY: o/$(MODE)/test/libc/intrin
 o/$(MODE)/test/libc/intrin:					\
 		$(TEST_LIBC_INTRIN_BINS)			\
diff --git a/test/libc/intrin/cosmo_once_test.c b/test/libc/intrin/cosmo_once_test.c
index c0e7d54ee..aaf8cba51 100644
--- a/test/libc/intrin/cosmo_once_test.c
+++ b/test/libc/intrin/cosmo_once_test.c
@@ -50,12 +50,10 @@ TEST(cosmo_once, test) {
   pthread_t th[N];
   x = y = 0;
   ASSERT_EQ(0, pthread_barrier_init(&b, 0, N));
-  for (i = 0; i < N; ++i) {
+  for (i = 0; i < N; ++i)
     ASSERT_EQ(0, pthread_create(th + i, 0, Worker, 0));
-  }
-  for (i = 0; i < N; ++i) {
+  for (i = 0; i < N; ++i)
     ASSERT_EQ(0, pthread_join(th[i], 0));
-  }
   ASSERT_EQ(N, atomic_load(&x));
   ASSERT_EQ(1, atomic_load(&y));
   ASSERT_EQ(0, pthread_barrier_destroy(&b));
diff --git a/test/libc/intrin/demangle_test.c b/test/libc/intrin/demangle_test.c
index 3ec28860c..27fce05ae 100644
--- a/test/libc/intrin/demangle_test.c
+++ b/test/libc/intrin/demangle_test.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "demangle_cases.inc"
 #include "libc/cosmo.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdio/internal.h"
 #include "libc/str/str.h"
 
diff --git a/test/libc/intrin/describeflags_test.c b/test/libc/intrin/describeflags_test.c
index 5475cdf72..a805f5605 100644
--- a/test/libc/intrin/describeflags_test.c
+++ b/test/libc/intrin/describeflags_test.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/testlib/testlib.h"
 
 static const struct DescribeFlags kFlags[] = {
@@ -27,7 +27,7 @@ static const struct DescribeFlags kFlags[] = {
 
 const char *DescribeIt(uint32_t x) {
   static char s[64];
-  return DescribeFlags(s, ARRAYLEN(s), kFlags, ARRAYLEN(kFlags), "x", x);
+  return _DescribeFlags(s, ARRAYLEN(s), kFlags, ARRAYLEN(kFlags), "x", x);
 }
 
 TEST(describeflags, test) {
diff --git a/test/libc/intrin/describegidlist_test.c b/test/libc/intrin/describegidlist_test.c
index 98c6a3408..f85f17f0c 100644
--- a/test/libc/intrin/describegidlist_test.c
+++ b/test/libc/intrin/describegidlist_test.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/groups.internal.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/testlib/testlib.h"
 
 TEST(DescribeGidList, test) {
diff --git a/test/libc/intrin/describesigset_test.c b/test/libc/intrin/describesigset_test.c
index 10410fb53..fc65ef61d 100644
--- a/test/libc/intrin/describesigset_test.c
+++ b/test/libc/intrin/describesigset_test.c
@@ -19,7 +19,7 @@
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/sigset.internal.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/testlib.h"
 
diff --git a/test/libc/intrin/dos2errno_test.c b/test/libc/intrin/dos2errno_test.c
index 14f8a2579..fb4e27aef 100644
--- a/test/libc/intrin/dos2errno_test.c
+++ b/test/libc/intrin/dos2errno_test.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/dos2errno.internal.h"
+#include "libc/intrin/dos2errno.h"
 #include "libc/nt/errors.h"
 #include "libc/sock/internal.h"
 #include "libc/str/str.h"
diff --git a/test/libc/intrin/fmax_test.c b/test/libc/intrin/fmax_test.c
index b662a4f7e..9d37d725f 100644
--- a/test/libc/intrin/fmax_test.c
+++ b/test/libc/intrin/fmax_test.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/math.h"
 #include "libc/testlib/testlib.h"
-#include "third_party/libcxx/math.h"
 
 TEST(fmax, test) {
   EXPECT_TRUE(fmax(2., 3.) == 3.);
diff --git a/test/libc/intrin/kprintf_test.c b/test/libc/intrin/kprintf_test.c
index 0ba13e7e1..eeabf193a 100644
--- a/test/libc/intrin/kprintf_test.c
+++ b/test/libc/intrin/kprintf_test.c
@@ -23,7 +23,7 @@
 #include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
 #include "libc/log/libfatal.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/memtrack.internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
@@ -228,7 +228,7 @@ TEST(ksnprintf, fuzzTheUnbreakable) {
   char *f, b[32];
   _Alignas(65536) static const char weasel[65535];
   f = (void *)__veil("r", weasel);
-  EXPECT_SYS(0, 0, mprotect(f, __granularity(), PROT_READ | PROT_WRITE));
+  EXPECT_SYS(0, 0, mprotect(f, getpagesize(), PROT_READ | PROT_WRITE));
   strcpy(f, "hello %s\n");
   EXPECT_EQ(12, ksnprintf(b, sizeof(b), f, "world"));
   EXPECT_STREQ("hello world\n", b);
@@ -240,7 +240,7 @@ TEST(ksnprintf, fuzzTheUnbreakable) {
     f[Rando() & 15] = '%';
     ksnprintf(b, sizeof(b), f, lemur64(), lemur64(), lemur64());
   }
-  EXPECT_SYS(0, 0, mprotect(f, __granularity(), PROT_READ));
+  EXPECT_SYS(0, 0, mprotect(f, getpagesize(), PROT_READ));
 }
 
 TEST(kprintf, testFailure_wontClobberErrnoAndBypassesSystemCallSupport) {
@@ -275,9 +275,11 @@ TEST(ksnprintf, testMisalignedPointer_wontFormat) {
 }
 
 TEST(ksnprintf, testUnterminatedOverrun_truncatesAtPageBoundary) {
+  if (IsWindows())
+    return;  // needs carving
   char *m;
   char b[32];
-  int gran = __granularity();
+  int gran = getgransize();
   m = memset(_mapanon(gran * 2), 1, gran);
   EXPECT_SYS(0, 0, munmap(m + gran, gran));
   EXPECT_EQ(12, ksnprintf(b, 32, "%'s", m + gran - 3));
diff --git a/test/libc/intrin/lock_test.c b/test/libc/intrin/lock_test.c
index 491700d38..b73a94f85 100644
--- a/test/libc/intrin/lock_test.c
+++ b/test/libc/intrin/lock_test.c
@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/atomic.h"
 #include "libc/calls/calls.h"
+#include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
@@ -28,8 +29,10 @@
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
+#include "libc/runtime/symbols.internal.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/clone.h"
+#include "libc/sysv/consts/sig.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 #include "third_party/nsync/mu.h"
@@ -62,6 +65,9 @@ pthread_mutex_t mu;
       __assert_eq_fail(__FILE__, __LINE__, #WANT, #GOT, _want, _got); \
   } while (0)
 
+void ignore_signal(int sig) {
+}
+
 void __assert_eq_fail(const char *file, int line, const char *wantstr,
                       const char *gotstr, long want, long got) {
   kprintf("%s:%d: %s vs. %s was %ld vs. %ld (%s)\n", file, line, wantstr,
@@ -112,10 +118,15 @@ void TestContendedLock(const char *name, int kind) {
   char *stk;
   double ns;
   errno_t rc;
+  int x, i, n = 10000;
   struct timespec t1, t2;
   pthread_mutexattr_t attr;
-  int tid, x, i, n = 10000;
-  struct CosmoTib tib = {.tib_self = &tib, .tib_self2 = &tib, .tib_tid = -1};
+  struct CosmoTib tib = {
+      .tib_self = &tib,
+      .tib_self2 = &tib,
+      .tib_ctid = -1,
+      .tib_ptid = 0,
+  };
   pthread_mutexattr_init(&attr);
   pthread_mutexattr_settype(&attr, kind);
   pthread_mutex_init(&mu, &attr);
@@ -127,7 +138,7 @@ void TestContendedLock(const char *name, int kind) {
              CLONE_VM | CLONE_THREAD | CLONE_FS | CLONE_FILES | CLONE_SIGHAND |
                  CLONE_SYSVSEM | CLONE_PARENT_SETTID | CLONE_CHILD_SETTID |
                  CLONE_CHILD_CLEARTID | CLONE_SETTLS,
-             0, &tid, &tib, &tib.tib_tid);
+             0, &tib.tib_ptid, &tib, &tib.tib_ctid);
   if (rc) {
     kprintf("clone failed: %s\n", strerror(rc));
     _Exit(1);
@@ -143,7 +154,7 @@ void TestContendedLock(const char *name, int kind) {
     ASSERT_EQ(0, pthread_mutex_unlock(&mu));
   }
   t2 = timespec_real();
-  while (tib.tib_tid)
+  while (tib.tib_ctid)
     donothing;
   ASSERT_EQ(1, atomic_load(&success));
   ASSERT_EQ(0, atomic_load(&counter));
@@ -177,6 +188,12 @@ void TestUncontendedLock(const char *name, int kind) {
 int main(int argc, char *argv[]) {
   pthread_mutexattr_t attr;
 
+#ifdef MODE_DBG
+  GetSymbolTable();
+  signal(SIGTRAP, ignore_signal);
+  kprintf("running %s\n", argv[0]);
+#endif
+
 #ifdef __aarch64__
   // our usage of raw clone() is probably broken in aarch64
   // we should just get rid of clone()
@@ -189,10 +206,8 @@ int main(int argc, char *argv[]) {
     _Exit(1);
   }
 
-  __threaded = 1;
-
   ASSERT_EQ(0, pthread_mutexattr_init(&attr));
-  ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL));
+  ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT));
   ASSERT_EQ(0, pthread_mutex_init(&mu, &attr));
   ASSERT_EQ(0, pthread_mutexattr_destroy(&attr));
   ASSERT_EQ(0, pthread_mutex_lock(&mu));
@@ -218,28 +233,12 @@ int main(int argc, char *argv[]) {
   ASSERT_EQ(0, pthread_mutex_unlock(&mu));
   ASSERT_EQ(0, pthread_mutex_destroy(&mu));
 
-  ASSERT_EQ(1, __tls_enabled);
-
-  TestUncontendedLock("PTHREAD_MUTEX_NORMAL RAW TLS", PTHREAD_MUTEX_NORMAL);
+  TestUncontendedLock("PTHREAD_MUTEX_DEFAULT RAW TLS", PTHREAD_MUTEX_DEFAULT);
   TestUncontendedLock("PTHREAD_MUTEX_RECURSIVE RAW TLS",
                       PTHREAD_MUTEX_RECURSIVE);
-  TestUncontendedLock("PTHREAD_MUTEX_ERRORCHECK RAW TLS",
-                      PTHREAD_MUTEX_ERRORCHECK);
 
-  TestContendedLock("PTHREAD_MUTEX_NORMAL RAW TLS", PTHREAD_MUTEX_NORMAL);
+  TestContendedLock("PTHREAD_MUTEX_DEFAULT RAW TLS", PTHREAD_MUTEX_DEFAULT);
   TestContendedLock("PTHREAD_MUTEX_RECURSIVE RAW TLS", PTHREAD_MUTEX_RECURSIVE);
-  TestContendedLock("PTHREAD_MUTEX_ERRORCHECK RAW TLS",
-                    PTHREAD_MUTEX_ERRORCHECK);
-
-  __tls_enabled_set(false);
-
-  TestUncontendedLock("PTHREAD_MUTEX_NORMAL RAW", PTHREAD_MUTEX_NORMAL);
-  TestUncontendedLock("PTHREAD_MUTEX_RECURSIVE RAW", PTHREAD_MUTEX_RECURSIVE);
-  TestUncontendedLock("PTHREAD_MUTEX_ERRORCHECK RAW", PTHREAD_MUTEX_ERRORCHECK);
-
-  TestContendedLock("PTHREAD_MUTEX_NORMAL RAW", PTHREAD_MUTEX_NORMAL);
-  TestContendedLock("PTHREAD_MUTEX_RECURSIVE RAW", PTHREAD_MUTEX_RECURSIVE);
-  TestContendedLock("PTHREAD_MUTEX_ERRORCHECK RAW", PTHREAD_MUTEX_ERRORCHECK);
 
   //
 }
diff --git a/test/libc/intrin/lockipc_test.c b/test/libc/intrin/lockipc_test.c
index 1dd48d41b..30878c699 100644
--- a/test/libc/intrin/lockipc_test.c
+++ b/test/libc/intrin/lockipc_test.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
@@ -47,12 +47,12 @@ TEST(lockipc, mutex) {
   int e, rc, ws, pid;
 
   // create shared memory
-  shm = _mapshared(__granularity());
+  shm = _mapshared(getpagesize());
 
   // create shared mutex
   pthread_mutexattr_t mattr;
   pthread_mutexattr_init(&mattr);
-  pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_NORMAL);
+  pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_DEFAULT);
   pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
   pthread_mutex_init(&shm->mutex, &mattr);
   pthread_mutexattr_destroy(&mattr);
@@ -86,5 +86,5 @@ TEST(lockipc, mutex) {
 
   EXPECT_EQ(PROCESSES * ITERATIONS, shm->x);
   ASSERT_EQ(0, pthread_mutex_destroy(&shm->mutex));
-  ASSERT_SYS(0, 0, munmap(shm, __granularity()));
+  ASSERT_SYS(0, 0, munmap(shm, getpagesize()));
 }
diff --git a/test/libc/intrin/magicu_test.c b/test/libc/intrin/magicu_test.c
index 4a5753e2a..351a861bb 100644
--- a/test/libc/intrin/magicu_test.c
+++ b/test/libc/intrin/magicu_test.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/magicu.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/testlib.h"
diff --git a/test/libc/intrin/memmove_test.c b/test/libc/intrin/memmove_test.c
index 701ef044a..7a4dbeb03 100644
--- a/test/libc/intrin/memmove_test.c
+++ b/test/libc/intrin/memmove_test.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/test/libc/intrin/memset_test.c b/test/libc/intrin/memset_test.c
index 4d818845a..cd05645e9 100644
--- a/test/libc/intrin/memset_test.c
+++ b/test/libc/intrin/memset_test.c
@@ -21,7 +21,7 @@
 #include "libc/mem/mem.h"
 #include "libc/stdio/rand.h"
 #include "libc/str/str.h"
-#include "libc/testlib/ezbench.h"
+#include "libc/testlib/benchmark.h"
 #include "libc/testlib/testlib.h"
 
 static void *golden(void *p, int c, size_t n) {
@@ -64,36 +64,13 @@ TEST(bzero, hug) {
   }
 }
 
+#define N (256 * 1024 * 1024)
+
 BENCH(memset, bench) {
-  int n, max = 8 * 1024 * 1024;
-  char *volatile p = gc(malloc(max));
-
-  EZBENCH_N("memset", 0, memset(p, -1, 0));
-  for (n = 2; n <= max; n *= 2) {
-    EZBENCH_N("memset", n - 1, memset(p, -1, n - 1));
-    EZBENCH_N("memset", n, memset(p, -1, n));
-  }
-
-  EZBENCH_N("memset16", 0, memset16((char16_t *)p, -1, 0));
-  for (n = 2; n <= max; n *= 2) {
-    EZBENCH_N("memset16", n, memset16((char16_t *)p, -1, n / 2));
-  }
-
-  EZBENCH_N("bzero", 0, bzero(p, 0));
-  for (n = 2; n <= max; n *= 2) {
-    EZBENCH_N("bzero", n - 1, bzero(p, n - 1));
-    EZBENCH_N("bzero", n, bzero(p, n));
-  }
-}
-
-BENCH(strlen, bench) {
-  int n, max = 8 * 1024 * 1024;
-  char *volatile p = gc(calloc(max + 1, 1));
-  EZBENCH_N("strlen", 0, strlen(p));
-  for (n = 2; n <= max; n *= 2) {
-    memset(p, -1, n - 1);
-    EZBENCH_N("strlen", n - 1, strlen(p));
-    p[n - 1] = -1;
-    EZBENCH_N("strlen", n, strlen(p));
-  }
+  void *memset_(void *, int, size_t) asm("memset");
+  printf("\n");
+  static char A[N];
+  memset(A, 2, N);
+  for (int n = 1; n <= N; n *= 2)
+    BENCHMARK(100, n, X(memset_(V(A), 0, n)));
 }
diff --git a/test/libc/intrin/mmap_scalability_test.c b/test/libc/intrin/mmap_scalability_test.c
new file mode 100644
index 000000000..9f164a6e2
--- /dev/null
+++ b/test/libc/intrin/mmap_scalability_test.c
@@ -0,0 +1,70 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/dce.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/maps.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
+
+#define BENCH(ITERATIONS, WORK_PER_RUN, CODE)                                 \
+  do {                                                                        \
+    struct timespec start = timespec_real();                                  \
+    for (int __i = 0; __i < ITERATIONS; ++__i) {                              \
+      asm volatile("" ::: "memory");                                          \
+      CODE;                                                                   \
+    }                                                                         \
+    long long work = (WORK_PER_RUN) * (ITERATIONS);                           \
+    double nanos =                                                            \
+        (timespec_tonanos(timespec_sub(timespec_real(), start)) + work - 1) / \
+        (double)work;                                                         \
+    kprintf("%'20ld ns %2dx %s\n", (long)nanos, (ITERATIONS), #CODE);         \
+  } while (0)
+
+void map_unmap_one_page(void) {
+  void *p;
+  if ((p = mmap(__maps_randaddr(), 1, PROT_READ | PROT_WRITE,
+                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)) == MAP_FAILED)
+    __builtin_trap();
+  if (munmap(p, 1))
+    __builtin_trap();
+}
+
+int main() {
+  kprintf("\n");
+  BENCH(1000, 1, map_unmap_one_page());
+
+  // macos doesn't scale
+  if (IsXnu())
+    return 0;
+
+  // create lots of sparse mappings to put
+  // weight on __maps.maps. red-black tree
+  int n = 10000;
+  kprintf("%20s creating %d sparse maps...\n", "", n);
+  for (int i = 0; i < n; ++i) {
+    if (mmap(__maps_randaddr(), 1, PROT_READ | PROT_WRITE,
+             MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) == MAP_FAILED)
+      __builtin_trap();
+  }
+
+  BENCH(1000, 1, map_unmap_one_page());
+}
diff --git a/test/libc/intrin/mmap_test.c b/test/libc/intrin/mmap_test.c
index d28f5c80b..e44ee223e 100644
--- a/test/libc/intrin/mmap_test.c
+++ b/test/libc/intrin/mmap_test.c
@@ -17,38 +17,27 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "ape/sections.internal.h"
+#include "libc/assert.h"
 #include "libc/calls/calls.h"
-#include "libc/calls/syscall-sysv.internal.h"
-#include "libc/calls/ucontext.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/atomic.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/intrin/xchg.internal.h"
+#include "libc/intrin/maps.h"
 #include "libc/limits.h"
-#include "libc/log/log.h"
-#include "libc/macros.internal.h"
-#include "libc/mem/gc.h"
-#include "libc/mem/mem.h"
-#include "libc/runtime/memtrack.internal.h"
+#include "libc/literal.h"
 #include "libc/runtime/runtime.h"
-#include "libc/runtime/stack.h"
 #include "libc/runtime/sysconf.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
+#include "libc/stdio/sysparam.h"
 #include "libc/str/str.h"
-#include "libc/sysv/consts/auxv.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/msync.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
-#include "libc/sysv/consts/sa.h"
-#include "libc/sysv/consts/sig.h"
-#include "libc/testlib/ezbench.h"
+#include "libc/testlib/benchmark.h"
+#include "libc/testlib/subprocess.h"
 #include "libc/testlib/testlib.h"
 #include "libc/x/xspawn.h"
-#include "third_party/xed/x86.h"
 
 // this is also a good torture test for mmap
 //
@@ -60,14 +49,20 @@
 
 __static_yoink("zipos");
 
-int granularity;
+int pagesz;
+int gransz;
 
 void SetUpOnce(void) {
-  granularity = __granularity();
+  pagesz = getpagesize();
+  gransz = getgransize();
   testlib_enable_tmp_setup_teardown();
   // ASSERT_SYS(0, 0, pledge("stdio rpath wpath cpath proc", 0));
 }
 
+void TearDown(void) {
+  ASSERT_FALSE(__maps_held());
+}
+
 TEST(mmap, zeroSize) {
   ASSERT_SYS(EINVAL, MAP_FAILED,
              mmap(NULL, 0, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
@@ -84,61 +79,154 @@ TEST(mmap, overflow) {
 
 TEST(mmap, noreplaceImage) {
   ASSERT_SYS(EEXIST, MAP_FAILED,
-             mmap(__executable_start, granularity, PROT_READ,
+             mmap(__executable_start, 1, PROT_READ,
                   MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED_NOREPLACE, -1, 0));
 }
 
 TEST(mmap, noreplaceExistingMap) {
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, granularity, PROT_READ,
-                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(0, 1, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
   ASSERT_SYS(EEXIST, MAP_FAILED,
-             mmap(p, granularity, PROT_READ,
+             mmap(p, 1, PROT_READ,
                   MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED_NOREPLACE, -1, 0));
-  EXPECT_SYS(0, 0, munmap(p, granularity));
+  EXPECT_SYS(0, 0, munmap(p, 1));
+}
+
+TEST(mmap, pageBeyondGone) {
+  int pagesz = getpagesize();
+  char *p = mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
+                 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  ASSERT_EQ(0, munmap(p, pagesz * 2));
+  p = mmap(p, 1, PROT_READ | PROT_WRITE,
+           MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  ASSERT_NE(MAP_FAILED, p);
+  EXPECT_TRUE(testlib_memoryexists(p));
+  EXPECT_TRUE(testlib_memoryexists(p + 1));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz));
+  ASSERT_EQ(0, munmap(p, 1));
+}
+
+TEST(mmap, fixedTaken) {
+  char *p;
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(0, 1, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
+  ASSERT_NE(MAP_FAILED, mmap(p, 1, PROT_READ,
+                             MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
+  EXPECT_SYS(0, 0, munmap(p, 1));
+}
+
+TEST(mmap, anon_rw_to_rx) {
+  char *p;
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, 1, PROT_READ | PROT_WRITE,
+                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
+  ASSERT_SYS(0, 0, mprotect(p, 1, PROT_READ | PROT_EXEC));
+  ASSERT_SYS(0, 0, munmap(p, 1));
+}
+
+TEST(mmap, anon_rw_fork_to_rx) {
+  char *p;
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, 1, PROT_READ | PROT_WRITE,
+                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
+  SPAWN(fork);
+  ASSERT_SYS(0, 0, mprotect(p, 1, PROT_READ | PROT_EXEC));
+  EXITS(0);
+  ASSERT_SYS(0, 0, munmap(p, 1));
+}
+
+TEST(mmap, anon_r_to_rw) {
+  char *p;
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(0, 1, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
+  ASSERT_SYS(0, 0, mprotect(p, 1, PROT_READ | PROT_WRITE));
+  ASSERT_SYS(0, 0, munmap(p, 1));
+}
+
+TEST(mmap, anon_r_fork_to_rw) {
+  char *p;
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(0, 1, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
+  SPAWN(fork);
+  ASSERT_SYS(0, 0, mprotect(p, 1, PROT_READ | PROT_WRITE));
+  EXITS(0);
+  ASSERT_SYS(0, 0, munmap(p, 1));
 }
 
 TEST(mmap, hint) {
-  char *p, *q;
+  char *p;
+
+  if (IsWindows())
+    return;  // needs carving
 
   // obtain four pages
-  EXPECT_NE(MAP_FAILED, (p = mmap(NULL, granularity * 4, PROT_READ,
+  ASSERT_NE(MAP_FAILED, (p = mmap(__maps_randaddr(), pagesz * 4, PROT_READ,
                                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
 
   // unmap two of those pages
-  EXPECT_SYS(0, 0, munmap(p + granularity, granularity));
-  EXPECT_SYS(0, 0, munmap(p + granularity * 3, granularity));
+  EXPECT_SYS(0, 0, munmap(p + pagesz, pagesz));
+  EXPECT_SYS(0, 0, munmap(p + pagesz * 3, pagesz));
 
   // test AVAILABLE nonfixed nonzero addr is granted
   // - posix doesn't mandate this behavior (but should)
   // - freebsd always chooses for you (which has no acceptable workaround)
   // - netbsd manual claims it'll be like freebsd, but is actually like openbsd
   if (!IsFreebsd())
-    EXPECT_EQ(p + granularity, mmap(p + granularity, granularity, PROT_READ,
-                                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+    ASSERT_EQ(p + pagesz, mmap(p + pagesz, pagesz, PROT_READ,
+                               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
 
   // test UNAVAILABLE nonfixed nonzero addr picks something nearby
   // - posix actually does require this, but doesn't say how close
   // - xnu / linux / openbsd always choose nearest on the right
   // - freebsd goes about 16mb to the right
   // - qemu-user is off the wall
-  if (!IsQemuUser()) {
-    q = mmap(p + granularity * 2, granularity, PROT_READ,
-             MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-    EXPECT_LE(ABS(q - (p + granularity * 2)), 64 * 1024 * 1024);
-    EXPECT_SYS(0, 0, munmap(q, granularity));
-  }
+  /*if (!IsQemuUser()) {
+    q = mmap(p + pagesz * 2, pagesz, PROT_READ, MAP_PRIVATE | MAP_ANONYMOUS, -1,
+             0);
+    EXPECT_LE(ABS(q - (p + pagesz * 2)), 128 * 1024 * 1024);
+    EXPECT_SYS(0, 0, munmap(q, pagesz));
+  }*/
 
   // clean up
-  EXPECT_SYS(0, 0, munmap(p, granularity * 4));
+  EXPECT_SYS(0, 0, munmap(p, pagesz * 4));
+}
+
+TEST(mprotect, punchHoleAndFillHole) {
+  char *p;
+  int count = __maps.count;
+
+  if (IsWindows())
+    return;  // needs carving
+
+  // obtain memory
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(__maps_randaddr(), gransz * 3, PROT_READ | PROT_WRITE,
+                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
+  ASSERT_EQ((count += IsWindows() ? 3 : 1), __maps.count);
+
+  // if munmap punches a hole...
+  // the number of mappings may increase
+  // this is why it's possible for munmap() to ENOMEM lool
+  EXPECT_SYS(0, 0, munmap(p + gransz, gransz));
+  ASSERT_EQ((count += IsWindows() ? -1 : +1), __maps.count);
+
+  // now if we fill that hole
+  // the memory manager will coalesce the mappings
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(p + gransz, gransz, PROT_READ | PROT_WRITE,
+                      MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0)));
+  ASSERT_EQ((count += IsWindows() ? +1 : -1), __maps.count);
+
+  // clean up
+  EXPECT_SYS(0, 0, munmap(p, gransz * 3));
 }
 
 TEST(mmap, smallerThanPage_mapsRemainder) {
   long pagesz = sysconf(_SC_PAGESIZE);
   char *map =
-      mmap(0, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+      mmap(0, 1, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   ASSERT_NE(MAP_FAILED, map);
   EXPECT_TRUE(testlib_memoryexists(map));
+  EXPECT_TRUE(testlib_pokememory(map + (pagesz - 1)));
   EXPECT_TRUE(testlib_memoryexists(map + (pagesz - 1)));
   EXPECT_SYS(0, 0, munmap(map, 1));
   EXPECT_FALSE(testlib_memoryexists(map));
@@ -153,7 +241,7 @@ TEST(mmap, testMapFile) {
   ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
   EXPECT_EQ(5, write(fd, "hello", 5));
   EXPECT_NE(-1, fdatasync(fd));
-  EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 5, PROT_READ, MAP_PRIVATE, fd, 0)));
+  ASSERT_NE(MAP_FAILED, (p = mmap(NULL, 5, PROT_READ, MAP_PRIVATE, fd, 0)));
   EXPECT_STREQN("hello", p, 5);
   EXPECT_NE(-1, munmap(p, 5));
   EXPECT_NE(-1, close(fd));
@@ -167,12 +255,12 @@ TEST(mmap, testMapFile_fdGetsClosed_makesNoDifference) {
   ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
   EXPECT_EQ(5, write(fd, "hello", 5));
   EXPECT_NE(-1, fdatasync(fd));
-  EXPECT_NE(MAP_FAILED,
+  ASSERT_NE(MAP_FAILED,
             (p = mmap(NULL, 5, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)));
   EXPECT_NE(-1, close(fd));
   EXPECT_STREQN("hello", p, 5);
   p[1] = 'a';
-  EXPECT_NE(-1, msync(p, getauxval(AT_PAGESZ), MS_SYNC));
+  EXPECT_NE(-1, msync(p, getpagesize(), MS_SYNC));
   ASSERT_NE(-1, (fd = open(path, O_RDONLY)));
   EXPECT_EQ(5, read(fd, buf, 5));
   EXPECT_STREQN("hallo", buf, 5);
@@ -184,16 +272,17 @@ TEST(mmap, testMapFile_fdGetsClosed_makesNoDifference) {
 TEST(mmap, fileOffset) {
   int fd;
   char *map;
-  int offset_align = IsWindows() ? granularity : getauxval(AT_PAGESZ);
   ASSERT_NE(-1, (fd = open("foo", O_CREAT | O_RDWR, 0644)));
-  EXPECT_NE(-1, ftruncate(fd, offset_align * 2));
-  EXPECT_NE(-1, pwrite(fd, "hello", 5, offset_align * 0));
-  EXPECT_NE(-1, pwrite(fd, "there", 5, offset_align * 1));
+  EXPECT_NE(-1, ftruncate(fd, gransz * 2));
+  EXPECT_NE(-1, pwrite(fd, "hello", 5, gransz * 0));
+  EXPECT_NE(-1, pwrite(fd, "there", 5, gransz * 1));
   EXPECT_NE(-1, fdatasync(fd));
-  ASSERT_NE(MAP_FAILED, (map = mmap(NULL, offset_align, PROT_READ, MAP_PRIVATE,
-                                    fd, offset_align)));
+  ASSERT_SYS(EINVAL, MAP_FAILED,
+             mmap(NULL, gransz, PROT_READ, MAP_PRIVATE, fd, gransz - 1));
+  ASSERT_NE(MAP_FAILED,
+            (map = mmap(NULL, gransz, PROT_READ, MAP_PRIVATE, fd, gransz)));
   EXPECT_EQ(0, memcmp(map, "there", 5), "%#.*s", 5, map);
-  EXPECT_NE(-1, munmap(map, offset_align));
+  EXPECT_NE(-1, munmap(map, gransz));
   EXPECT_NE(-1, close(fd));
 }
 
@@ -201,13 +290,13 @@ TEST(mmap, mapPrivate_writesDontChangeFile) {
   int fd;
   char *map, buf[6];
   ASSERT_NE(-1, (fd = open("bar", O_CREAT | O_RDWR, 0644)));
-  EXPECT_NE(-1, ftruncate(fd, granularity));
+  EXPECT_NE(-1, ftruncate(fd, gransz));
   EXPECT_NE(-1, pwrite(fd, "hello", 5, 0));
-  ASSERT_NE(MAP_FAILED, (map = mmap(NULL, granularity, PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (map = mmap(NULL, gransz, PROT_READ | PROT_WRITE,
                                     MAP_PRIVATE, fd, 0)));
   memcpy(map, "there", 5);
-  EXPECT_NE(-1, msync(map, granularity, MS_SYNC));
-  EXPECT_NE(-1, munmap(map, granularity));
+  EXPECT_NE(-1, msync(map, gransz, MS_SYNC));
+  EXPECT_NE(-1, munmap(map, gransz));
   EXPECT_NE(-1, pread(fd, buf, 6, 0));
   EXPECT_EQ(0, memcmp(buf, "hello", 5), "%#.*s", 5, buf);
   EXPECT_NE(-1, close(fd));
@@ -220,10 +309,237 @@ TEST(mmap, ziposCannotBeShared) {
   void *p;
   ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
   EXPECT_SYS(EINVAL, MAP_FAILED,
-             (p = mmap(NULL, granularity, PROT_READ, MAP_SHARED, fd, 0)));
+             (p = mmap(NULL, gransz, PROT_READ, MAP_SHARED, fd, 0)));
   close(fd);
 }
 
+TEST(mmap, misalignedAddr_justIgnoresIt) {
+  char *p;
+  ASSERT_NE(MAP_FAILED, (p = mmap((void *)1, 1, PROT_READ,
+                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
+  munmap(p, 1);
+}
+
+TEST(mmap, nullFixed_isNotAllowed) {
+  ASSERT_SYS(
+      EPERM, MAP_FAILED,
+      mmap(0, 1, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0));
+  ASSERT_SYS(EPERM, MAP_FAILED,
+             mmap(0, 1, PROT_NONE,
+                  MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED_NOREPLACE, -1, 0));
+}
+
+static int GetBitsInAddressSpace(void) {
+  int i;
+  void *ptr;
+  uint64_t want;
+  for (i = 0; i < 40; ++i) {
+    want = UINT64_C(0x8123000000000000) >> i;
+    if (want > UINTPTR_MAX)
+      continue;
+    if (msync((void *)(uintptr_t)want, 1, MS_ASYNC) == 0 || errno == EBUSY)
+      return 64 - i;
+    ptr = mmap((void *)(uintptr_t)want, 1, PROT_READ,
+               MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
+    if (ptr != MAP_FAILED) {
+      munmap(ptr, 1);
+      return 64 - i;
+    }
+  }
+  abort();
+}
+
+TEST(mmap, negative_isNotAllowed) {
+  ASSERT_SYS(ENOMEM, MAP_FAILED,
+             mmap((void *)-(70 * 1024 * 1024), 1, PROT_NONE,
+                  MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0));
+}
+
+TEST(mmap, pml5t) {
+  switch (GetBitsInAddressSpace()) {
+    case 56:
+      ASSERT_EQ((void *)0x00fff2749119c000,
+                mmap((void *)0x00fff2749119c000, 1, PROT_NONE,
+                     MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0));
+      munmap((void *)0x00fff2749119c000, 1);
+      break;
+    case 48:
+      ASSERT_EQ((void *)0x0000f2749119c000,
+                mmap((void *)0x0000f2749119c000, 1, PROT_NONE,
+                     MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0));
+      munmap((void *)0x0000f2749119c000, 1);
+      break;
+    default:
+      break;
+  }
+}
+
+TEST(mmap, windows) {
+  if (!IsWindows())
+    return;
+  int count = __maps.count;
+  char *base = __maps_randaddr();
+
+  ASSERT_EQ(base, mmap(base, pagesz * 3, PROT_READ | PROT_WRITE,
+                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  ASSERT_EQ((count += 1), __maps.count);
+
+  // isn't granularity aligned
+  ASSERT_SYS(EINVAL, -1, munmap(base + pagesz, pagesz));
+
+  // doesn't overlap any maps
+  ASSERT_SYS(0, 0, munmap(base + gransz, pagesz));
+  ASSERT_EQ(count, __maps.count);
+
+  // doesn't overlap any maps
+  ASSERT_SYS(0, 0, munmap(base - gransz, gransz));
+  ASSERT_EQ(count, __maps.count);
+
+  // partially overlaps map
+  ASSERT_SYS(ENOTSUP, -1, munmap(base, pagesz));
+  ASSERT_EQ(count, __maps.count);
+
+  // envelops map
+  ASSERT_SYS(0, 0, munmap(base - gransz, gransz + pagesz * 4));
+  ASSERT_EQ((count -= 1), __maps.count);
+
+  // win32 actually unmapped map
+  ASSERT_EQ(base, mmap(base, pagesz * 3, PROT_READ | PROT_WRITE,
+                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  ASSERT_EQ((count += 1), __maps.count);
+
+  // change status of middle page results in three fragments
+  ASSERT_SYS(0, 0, mprotect(base + pagesz, pagesz, PROT_NONE));
+  ASSERT_EQ((count += 2), __maps.count);
+
+  // change status back (todo: should reunite fragments)
+  ASSERT_SYS(0, 0, mprotect(base + pagesz, pagesz, PROT_READ | PROT_WRITE));
+  ASSERT_EQ(count, __maps.count);
+
+  // clean up
+  ASSERT_SYS(0, 0, munmap(base, pagesz * 3));
+  ASSERT_EQ((count -= 3), __maps.count);
+}
+
+TEST(mmap, windows_partial_overlap_enotsup) {
+  if (!IsWindows())
+    return;
+  int count = __maps.count;
+  char *base = __maps_randaddr();
+
+  ASSERT_EQ(base, mmap(base, gransz * 3, PROT_READ | PROT_WRITE,
+                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  ASSERT_EQ((count += 1), __maps.count);
+
+  // partially overlaps on left
+  ASSERT_SYS(ENOTSUP, -1, munmap(base - gransz, gransz * 2));
+  ASSERT_SYS(ENOTSUP, -1, munmap(base, gransz * 2));
+  ASSERT_EQ(count, __maps.count);
+
+  // partially overlaps the middle
+  ASSERT_SYS(ENOTSUP, -1, munmap(base + gransz * 1, gransz));
+  ASSERT_SYS(ENOTSUP, -1, munmap(base + gransz * 1, gransz * 2));
+  ASSERT_EQ(count, __maps.count);
+
+  // partially overlaps on right
+  ASSERT_SYS(ENOTSUP, -1, munmap(base + gransz * 2, gransz * 2));
+  ASSERT_EQ(count, __maps.count);
+
+  // doesn't overlap any maps
+  ASSERT_SYS(0, 0, munmap(base - gransz, gransz));
+  ASSERT_SYS(0, 0, munmap(base + gransz * 3, gransz));
+  ASSERT_EQ(count, __maps.count);
+
+  // unmap envelops
+  ASSERT_SYS(0, 0, munmap(base - gransz, gransz * 4));
+  ASSERT_EQ((count -= 1), __maps.count);
+
+  // win32 actually removed the memory
+  ASSERT_EQ(base, mmap(base, gransz * 3, PROT_READ | PROT_WRITE,
+                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  ASSERT_EQ((count += 1), __maps.count);
+
+  // clean up
+  ASSERT_SYS(0, 0, munmap(base, gransz * 3));
+  ASSERT_EQ((count -= 1), __maps.count);
+}
+
+TEST(munmap, windows_not_all_fragments_included_enotsup) {
+  if (!IsWindows())
+    return;
+  int count = __maps.count;
+  char *base = __maps_randaddr();
+
+  ASSERT_EQ(base, mmap(base, gransz * 3, PROT_READ | PROT_WRITE,
+                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  ASSERT_EQ((count += 1), __maps.count);
+
+  // win32 memory actually exists
+  ASSERT_SYS(EEXIST, MAP_FAILED,
+             mmap(base, gransz * 3, PROT_READ | PROT_WRITE,
+                  MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  ASSERT_SYS(EEXIST, MAP_FAILED,
+             mmap(base + gransz * 0, gransz, PROT_READ | PROT_WRITE,
+                  MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  ASSERT_SYS(EEXIST, MAP_FAILED,
+             mmap(base + gransz * 1, gransz, PROT_READ | PROT_WRITE,
+                  MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  ASSERT_SYS(EEXIST, MAP_FAILED,
+             mmap(base + gransz * 2, gransz, PROT_READ | PROT_WRITE,
+                  MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+
+  // change status of middle page results in three fragments
+  ASSERT_SYS(0, 0, mprotect(base + gransz, gransz, PROT_NONE));
+  ASSERT_EQ((count += 2), __maps.count);
+
+  // partially overlaps on left
+  ASSERT_SYS(ENOTSUP, -1, munmap(base - gransz, gransz * 2));
+  ASSERT_SYS(ENOTSUP, -1, munmap(base, gransz * 2));
+  ASSERT_EQ(count, __maps.count);
+
+  // partially overlaps the middle
+  ASSERT_SYS(ENOTSUP, -1, munmap(base + gransz * 1, gransz));
+  ASSERT_SYS(ENOTSUP, -1, munmap(base + gransz * 1, gransz * 2));
+  ASSERT_EQ(count, __maps.count);
+
+  // partially overlaps on right
+  ASSERT_SYS(ENOTSUP, -1, munmap(base + gransz * 2, gransz * 2));
+  ASSERT_EQ(count, __maps.count);
+
+  // doesn't overlap any maps
+  ASSERT_SYS(0, 0, munmap(base - gransz, gransz));
+  ASSERT_SYS(0, 0, munmap(base + gransz * 3, gransz));
+  ASSERT_EQ(count, __maps.count);
+
+  // unmap envelops
+  ASSERT_SYS(0, 0, munmap(base - gransz, gransz * 4));
+  ASSERT_EQ((count -= 3), __maps.count);
+
+  // win32 actually removed the memory
+  ASSERT_EQ(base, mmap(base, gransz * 3, PROT_READ | PROT_WRITE,
+                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  ASSERT_EQ((count += 1), __maps.count);
+
+  // clean up
+  ASSERT_SYS(0, 0, munmap(base, gransz * 3));
+  ASSERT_EQ((count -= 1), __maps.count);
+}
+
+TEST(mmap, windows_private_memory_fork_uses_virtualfree) {
+  if (IsFreebsd())
+    return;  // freebsd can't take a hint
+  char *base;
+  ASSERT_NE(MAP_FAILED, (base = mmap(0, gransz * 3, PROT_READ | PROT_WRITE,
+                                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
+  SPAWN(fork);
+  ASSERT_SYS(0, 0, munmap(base, gransz * 3));
+  ASSERT_EQ(base, mmap(base, gransz * 3, PROT_READ | PROT_WRITE,
+                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+  ASSERT_SYS(0, 0, munmap(base, gransz * 3));
+  EXITS(0);
+  ASSERT_SYS(0, 0, munmap(base, gransz * 3));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // zipos NON-SHARED READ-ONLY FILE MEMORY
 
@@ -232,9 +548,9 @@ TEST(mmap, ziposCow) {
   void *p;
   ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
   EXPECT_NE(MAP_FAILED,
-            (p = mmap(NULL, granularity, PROT_READ, MAP_PRIVATE, fd, 0)));
+            (p = mmap(NULL, gransz, PROT_READ, MAP_PRIVATE, fd, 0)));
   EXPECT_STREQN("\177ELF", ((const char *)p), 4);
-  EXPECT_NE(-1, munmap(p, granularity));
+  EXPECT_NE(-1, munmap(p, gransz));
   EXPECT_NE(-1, close(fd));
 }
 
@@ -245,7 +561,7 @@ TEST(mmap, ziposCowFileMapReadonlyFork) {
   int fd, ws;
   void *p;
   ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
-  EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 4, PROT_READ, MAP_PRIVATE, fd, 0)));
+  ASSERT_NE(MAP_FAILED, (p = mmap(NULL, 4, PROT_READ, MAP_PRIVATE, fd, 0)));
   EXPECT_STREQN("ELF", ((const char *)p) + 1, 3);
   ASSERT_NE(-1, (ws = xspawn(0)));
   if (ws == -2) {
@@ -266,7 +582,7 @@ TEST(mmap, ziposCowFileMapFork) {
   void *p;
   char lol[4];
   ASSERT_NE(-1, (fd = open(ziposLifePath, O_RDONLY), "%s", ziposLifePath));
-  EXPECT_NE(MAP_FAILED,
+  ASSERT_NE(MAP_FAILED,
             (p = mmap(NULL, 6, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0)));
   memcpy(p, "parnt", 6);
   ASSERT_NE(-1, (ws = xspawn(0)));
@@ -296,7 +612,7 @@ TEST(mmap, cow) {
             path);
   EXPECT_EQ(5, write(fd, "hello", 5));
   EXPECT_NE(-1, fdatasync(fd));
-  EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 5, PROT_READ, MAP_PRIVATE, fd, 0)));
+  ASSERT_NE(MAP_FAILED, (p = mmap(NULL, 5, PROT_READ, MAP_PRIVATE, fd, 0)));
   EXPECT_STREQN("hello", p, 5);
   EXPECT_NE(-1, munmap(p, 5));
   EXPECT_NE(-1, close(fd));
@@ -315,7 +631,7 @@ TEST(mmap, cowFileMapReadonlyFork) {
   EXPECT_EQ(6, write(fd, "hello", 6));
   EXPECT_NE(-1, close(fd));
   ASSERT_NE(-1, (fd = open(path, O_RDONLY)));
-  EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 6, PROT_READ, MAP_PRIVATE, fd, 0)));
+  ASSERT_NE(MAP_FAILED, (p = mmap(NULL, 6, PROT_READ, MAP_PRIVATE, fd, 0)));
   EXPECT_STREQN("hello", p, 5);
   ASSERT_NE(-1, (ws = xspawn(0)));
   if (ws == -2) {
@@ -340,7 +656,7 @@ TEST(mmap, cowFileMapFork) {
   ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
   EXPECT_EQ(6, write(fd, "parnt", 6));
   EXPECT_NE(-1, fdatasync(fd));
-  EXPECT_NE(MAP_FAILED,
+  ASSERT_NE(MAP_FAILED,
             (p = mmap(NULL, 6, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0)));
   EXPECT_STREQN("parnt", p, 5);
   ASSERT_NE(-1, (ws = xspawn(0)));
@@ -365,7 +681,7 @@ TEST(mmap, cowFileMapFork) {
 TEST(mmap, sharedAnonMapFork) {
   int ws;
   char *p;
-  EXPECT_NE(MAP_FAILED, (p = mmap(NULL, 6, PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(NULL, 6, PROT_READ | PROT_WRITE,
                                   MAP_SHARED | MAP_ANONYMOUS, -1, 0)));
   strcpy(p, "parnt");
   EXPECT_STREQN("parnt", p, 5);
@@ -392,7 +708,7 @@ TEST(mmap, sharedFileMapFork) {
   ASSERT_NE(-1, (fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644)));
   EXPECT_EQ(6, write(fd, "parnt", 6));
   EXPECT_NE(-1, fdatasync(fd));
-  EXPECT_NE(MAP_FAILED,
+  ASSERT_NE(MAP_FAILED,
             (p = mmap(NULL, 6, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)));
   EXPECT_STREQN("parnt", p, 5);
   ASSERT_NE(-1, (ws = xspawn(0)));
@@ -417,26 +733,41 @@ TEST(mmap, sharedFileMapFork) {
 ////////////////////////////////////////////////////////////////////////////////
 // BENCHMARKS
 
-#define N (EZBENCH_COUNT * EZBENCH_TRIES)
+#define N 1000
 
 int count;
 void *ptrs[N];
+size_t sizes[N];
 
 void BenchMmapPrivate(void) {
   void *p;
-  p = mmap(0, granularity, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE,
-           -1, 0);
-  if (p == MAP_FAILED)
-    __builtin_trap();
-  ptrs[count++] = p;
+  p = mmap(0, (sizes[count] = rand() % (pagesz * 500)), PROT_READ | PROT_WRITE,
+           MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  ASSERT_NE(MAP_FAILED, p);
+  ptrs[count] = p;
+  ++count;
 }
 
 void BenchUnmap(void) {
-  if (munmap(ptrs[--count], granularity))
-    __builtin_trap();
+  --count;
+  ASSERT_SYS(0, 0, munmap(ptrs[count], sizes[count]));
 }
 
-BENCH(mmap, bench) {
-  EZBENCH2("mmap", donothing, BenchMmapPrivate());
-  EZBENCH2("munmap", donothing, BenchUnmap());
+void BenchBigMmap(void) {
+  void *p;
+  p = mmap(0, 101 * 1024 * 1024, PROT_READ | PROT_WRITE,
+           MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  ASSERT_NE(MAP_FAILED, p);
+  ptrs[count++] = p;
+}
+
+void BenchBigMunmap(void) {
+  ASSERT_SYS(0, 0, munmap(ptrs[--count], 101 * 1024 * 1024));
+}
+
+TEST(mmap, bench) {
+  BENCHMARK(N, 1, BenchMmapPrivate());
+  BENCHMARK(N, 1, BenchUnmap());
+  /* BENCHMARK(N, 1, BenchBigMmap()); */
+  /* BENCHMARK(N, 1, BenchBigMunmap()); */
 }
diff --git a/test/libc/intrin/mprotect_test.c b/test/libc/intrin/mprotect_test.c
index 2271336c1..a04af31c2 100644
--- a/test/libc/intrin/mprotect_test.c
+++ b/test/libc/intrin/mprotect_test.c
@@ -16,12 +16,13 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/ucontext.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/log/log.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
@@ -108,21 +109,21 @@ void SetUp(void) {
                             .sa_flags = SA_SIGINFO | SA_RESETHAND};
   struct sigaction sasegv = {.sa_sigaction = OnSigSegv,
                              .sa_flags = SA_SIGINFO | SA_RESETHAND};
-  sigaction(SIGBUS, &sabus, old + 0);
-  sigaction(SIGSEGV, &sasegv, old + 1);
+  unassert(!sigaction(SIGBUS, &sabus, old + 0));
+  unassert(!sigaction(SIGSEGV, &sasegv, old + 1));
   gotbusted = false;
   gotsegv = false;
 }
 
 void TearDown(void) {
-  sigaction(SIGBUS, old + 0, 0);
-  sigaction(SIGSEGV, old + 1, 0);
+  unassert(!sigaction(SIGBUS, old + 0, 0));
+  unassert(!sigaction(SIGSEGV, old + 1, 0));
 }
 
 TEST(mprotect, testOkMemory) {
-  char *p = gc(memalign(getauxval(AT_PAGESZ), getauxval(AT_PAGESZ)));
+  char *p = gc(memalign(getpagesize(), getpagesize()));
   p[0] = 0;
-  ASSERT_NE(-1, mprotect(p, getauxval(AT_PAGESZ), PROT_READ | PROT_WRITE));
+  ASSERT_NE(-1, mprotect(p, getpagesize(), PROT_READ | PROT_WRITE));
   p[0] = 1;
   EXPECT_EQ(1, p[0]);
   EXPECT_FALSE(gotsegv);
@@ -131,55 +132,53 @@ TEST(mprotect, testOkMemory) {
 
 TEST(mprotect, testSegfault_writeToReadOnlyAnonymous) {
   volatile char *p;
-  p = gc(memalign(getauxval(AT_PAGESZ), getauxval(AT_PAGESZ)));
+  p = gc(memalign(getpagesize(), getpagesize()));
   EXPECT_FALSE(gotsegv);
   p[0] = 1;
   EXPECT_FALSE(gotsegv);
   EXPECT_FALSE(gotbusted);
-  EXPECT_NE(-1, mprotect((void *)p, getauxval(AT_PAGESZ), PROT_READ));
+  EXPECT_NE(-1, mprotect((void *)p, getpagesize(), PROT_READ));
   __expropriate(p[0]);
   EXPECT_FALSE(gotsegv);
   EXPECT_FALSE(gotbusted);
   p[0] = 2;
   EXPECT_TRUE(gotsegv | gotbusted);
   EXPECT_EQ(1, p[0]);
-  EXPECT_NE(-1,
-            mprotect((void *)p, getauxval(AT_PAGESZ), PROT_READ | PROT_WRITE));
+  EXPECT_NE(-1, mprotect((void *)p, getpagesize(), PROT_READ | PROT_WRITE));
 }
 
 TEST(mprotect, testExecOnly_canExecute) {
-  char *p = _mapanon(__granularity());
+  char *p = _mapanon(getpagesize());
   void (*f)(void) = (void *)p;
   memcpy(p, kRet31337, sizeof(kRet31337));
-  ASSERT_SYS(0, 0, mprotect(p, __granularity(), PROT_EXEC | PROT_READ));
+  ASSERT_SYS(0, 0, mprotect(p, getpagesize(), PROT_EXEC | PROT_READ));
   f();
   // On all supported platforms, PROT_EXEC implies PROT_READ. There is
   // one exception to this rule: Chromebook's fork of the Linux kernel
   // which has been reported, to have the ability to prevent a program
   // from reading its own code.
-  ASSERT_SYS(0, 0, mprotect(p, __granularity(), PROT_EXEC));
+  ASSERT_SYS(0, 0, mprotect(p, getpagesize(), PROT_EXEC));
   f();
-  munmap(p, __granularity());
+  munmap(p, getpagesize());
 }
 
 TEST(mprotect, testProtNone_cantEvenRead) {
   volatile char *p;
-  p = gc(memalign(getauxval(AT_PAGESZ), getauxval(AT_PAGESZ)));
-  EXPECT_NE(-1, mprotect((void *)p, getauxval(AT_PAGESZ), PROT_NONE));
+  p = gc(memalign(getpagesize(), getpagesize()));
+  EXPECT_NE(-1, mprotect((void *)p, getpagesize(), PROT_NONE));
   __expropriate(p[0]);
   EXPECT_TRUE(gotsegv | gotbusted);
-  EXPECT_NE(-1,
-            mprotect((void *)p, getauxval(AT_PAGESZ), PROT_READ | PROT_WRITE));
+  EXPECT_NE(-1, mprotect((void *)p, getpagesize(), PROT_READ | PROT_WRITE));
 }
 
 TEST(mprotect, testExecJit_actuallyWorks) {
-  int (*p)(void) = gc(memalign(getauxval(AT_PAGESZ), getauxval(AT_PAGESZ)));
+  int (*p)(void) = gc(memalign(getpagesize(), getpagesize()));
   memcpy(p, kRet31337, sizeof(kRet31337));
-  EXPECT_NE(-1, mprotect(p, getauxval(AT_PAGESZ), PROT_EXEC));
+  EXPECT_NE(-1, mprotect(p, getpagesize(), PROT_EXEC));
   EXPECT_EQ(31337, p());
   EXPECT_FALSE(gotsegv);
   EXPECT_FALSE(gotbusted);
-  EXPECT_NE(-1, mprotect(p, getauxval(AT_PAGESZ), PROT_READ | PROT_WRITE));
+  EXPECT_NE(-1, mprotect(p, getpagesize(), PROT_READ | PROT_WRITE));
 }
 
 TEST(mprotect, testRwxMap_vonNeumannRules) {
@@ -187,14 +186,13 @@ TEST(mprotect, testRwxMap_vonNeumannRules) {
     return;  // boo
   if (IsXnuSilicon())
     return;  // boo
-  int (*p)(void) = gc(memalign(getauxval(AT_PAGESZ), getauxval(AT_PAGESZ)));
+  int (*p)(void) = gc(memalign(getpagesize(), getpagesize()));
   memcpy(p, kRet31337, sizeof(kRet31337));
-  EXPECT_NE(-1, mprotect(p, getauxval(AT_PAGESZ),
-                         PROT_READ | PROT_WRITE | PROT_EXEC));
+  EXPECT_NE(-1, mprotect(p, getpagesize(), PROT_READ | PROT_WRITE | PROT_EXEC));
   EXPECT_EQ(31337, p());
   EXPECT_FALSE(gotsegv);
   EXPECT_FALSE(gotbusted);
-  EXPECT_NE(-1, mprotect(p, getauxval(AT_PAGESZ), PROT_READ | PROT_WRITE));
+  EXPECT_NE(-1, mprotect(p, getpagesize(), PROT_READ | PROT_WRITE));
 }
 
 TEST(mprotect, testExecuteFlatFileMapOpenedAsReadonly) {
@@ -231,13 +229,13 @@ TEST(mprotect, testFileMap_canChangeToExecWhileOpenInRdwrMode) {
 }
 
 TEST(mprotect, testBadProt_failsEinval) {
-  volatile char *p = gc(memalign(getauxval(AT_PAGESZ), getauxval(AT_PAGESZ)));
+  volatile char *p = gc(memalign(getpagesize(), getpagesize()));
   EXPECT_EQ(-1, mprotect((void *)p, 9999, -1));
   EXPECT_EQ(EINVAL, errno);
 }
 
 TEST(mprotect, testZeroSize_doesNothing) {
-  volatile char *p = gc(memalign(getauxval(AT_PAGESZ), getauxval(AT_PAGESZ)));
+  volatile char *p = gc(memalign(getpagesize(), getpagesize()));
   EXPECT_NE(-1, mprotect((void *)p, 0, PROT_READ));
   p[0] = 1;
   EXPECT_FALSE(gotsegv);
@@ -252,3 +250,43 @@ TEST(mprotect, image) {
   EXPECT_SYS(0, 0, mprotect(p, 16384, PROT_READ | PROT_WRITE));
   EXPECT_EQ(2, ++p[0]);
 }
+
+TEST(mprotect, weirdSize) {
+  char *p;
+  EXPECT_NE(MAP_FAILED, (p = mmap(0, 1, PROT_READ | PROT_EXEC,
+                                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
+  EXPECT_SYS(0, 0, mprotect(p, 2, PROT_NONE));
+  EXPECT_SYS(0, 0, munmap(p, 1));
+}
+
+TEST(mprotect, outerOverlap) {
+  if (IsWindows())
+    return;  // needs carving
+  char *p;
+  int gransz = getgransize();
+  EXPECT_NE(MAP_FAILED, (p = mmap(0, gransz * 3, PROT_READ | PROT_EXEC,
+                                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p, gransz));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p + gransz * 2, gransz));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, mprotect(p, gransz * 3, PROT_NONE));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, mprotect(p + gransz, gransz, PROT_READ));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p, gransz * 3));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 2));
+}
diff --git a/test/libc/intrin/mremap_test.c b/test/libc/intrin/mremap_test.c
new file mode 100644
index 000000000..57f99d4ac
--- /dev/null
+++ b/test/libc/intrin/mremap_test.c
@@ -0,0 +1,181 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/sysv/consts/mremap.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/maps.h"
+#include "libc/runtime/runtime.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/mremap.h"
+#include "libc/sysv/consts/prot.h"
+#include "libc/testlib/testlib.h"
+
+void SetUpOnce(void) {
+  if (!IsLinux() && !IsNetbsd()) {
+    tinyprint(2, "warning: skipping mremap() tests on this os\n", NULL);
+    exit(0);
+  }
+}
+
+TEST(mremap, dontMove_hasRoom_itMoves) {
+  if (IsNetbsd())
+    return;  // NetBSD requires MREMAP_MAYMOVE
+  char *p;
+  int pagesz = getpagesize();
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(__maps_randaddr(), pagesz, PROT_READ | PROT_EXEC,
+                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
+  EXPECT_TRUE(testlib_memoryexists(p));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz));
+  ASSERT_SYS(0, p, mremap(p, pagesz, pagesz * 2, 0));
+  EXPECT_TRUE(testlib_memoryexists(p));
+  EXPECT_TRUE(testlib_memoryexists(p + pagesz));
+  ASSERT_SYS(0, 0, munmap(p, pagesz * 2));
+  EXPECT_FALSE(testlib_memoryexists(p));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz));
+}
+
+TEST(mremap, dontMove_noRoom_itFailsWithEnomem) {
+  if (IsNetbsd())
+    return;  // NetBSD requires MREMAP_MAYMOVE
+  char *p;
+  int pagesz = getpagesize();
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(__maps_randaddr(), pagesz * 2, PROT_READ | PROT_EXEC,
+                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
+  EXPECT_TRUE(testlib_memoryexists(p + pagesz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + pagesz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 2));
+  ASSERT_SYS(ENOMEM, MAP_FAILED, mremap(p, pagesz, pagesz * 3, 0));
+  EXPECT_TRUE(testlib_memoryexists(p + pagesz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + pagesz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 2));
+  ASSERT_SYS(0, 0, munmap(p, pagesz * 2));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 2));
+}
+
+TEST(mremap, mayMove_noRoom_itRelocates) {
+  char *p, *p2;
+  int pagesz = getpagesize();
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(__maps_randaddr(), pagesz * 2, PROT_READ | PROT_EXEC,
+                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
+  EXPECT_TRUE(testlib_memoryexists(p + pagesz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + pagesz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 2));
+  ASSERT_NE(MAP_FAILED, (p2 = mremap(p, pagesz, pagesz * 3, MREMAP_MAYMOVE)));
+  ASSERT_NE(p, p2);
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + pagesz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 2));
+  EXPECT_TRUE(testlib_memoryexists(p2 + pagesz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p2 + pagesz * 1));
+  EXPECT_TRUE(testlib_memoryexists(p2 + pagesz * 2));
+  ASSERT_SYS(0, 0, munmap(p + pagesz, pagesz));
+  ASSERT_SYS(0, 0, munmap(p2, pagesz * 3));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + pagesz * 2));
+  EXPECT_FALSE(testlib_memoryexists(p2 + pagesz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p2 + pagesz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p2 + pagesz * 2));
+}
+
+// demonstrate value of mremap() system call
+//
+//       mmap(1'048'576) took 1'130 ns
+//     mremap(1'048'576 -> 2'097'152) took 3'117 ns
+//     mremap(2'097'152 -> 1'048'576) took 3'596 ns
+//     mremap(1'048'576 -> 2'097'152) took 796'381 ns [simulated]
+//     munmap(2'097'152) took 50'020 ns
+//
+
+TEST(mremap, bench) {
+#define N 10
+  long size = 1024 * 1024;
+  char *rollo = __maps_randaddr();
+  char *addr[N];
+
+  // create mappings
+  struct timespec ts1 = timespec_real();
+  for (long i = 0; i < N; ++i)
+    if ((addr[i] = mmap((rollo += size), size, PROT_READ | PROT_WRITE,
+                        MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)) == MAP_FAILED) {
+      kprintf("first mmap failed: %m\n");
+      exit(1);
+    }
+  kprintf("mmap(%'zu) took %'ld ns\n", size,
+          timespec_tonanos(timespec_sub(timespec_real(), ts1)) / N);
+
+  // use mremap to grow mappings
+  ts1 = timespec_real();
+  for (long i = 0; i < N; ++i)
+    if ((addr[i] = mremap(addr[i], size, size * 2, MREMAP_MAYMOVE)) ==
+        MAP_FAILED) {
+      kprintf("grow mremap failed: %m\n");
+      exit(1);
+    }
+  kprintf("mremap(%'zu -> %'zu) took %'ld ns\n", size, size * 2,
+          timespec_tonanos(timespec_sub(timespec_real(), ts1)) / N);
+
+  // use mremap to shrink mappings
+  ts1 = timespec_real();
+  for (long i = 0; i < N; ++i)
+    if (mremap(addr[i], size * 2, size, 0) != addr[i]) {
+      kprintf("shrink mremap failed: %m\n");
+      exit(1);
+    }
+  kprintf("mremap(%'zu -> %'zu) took %'ld ns\n", size * 2, size,
+          timespec_tonanos(timespec_sub(timespec_real(), ts1)) / N);
+
+  // do the thing that mremap is trying to optimize
+  ts1 = timespec_real();
+  for (long i = 0; i < N; ++i) {
+    char *addr2;
+    if ((addr2 = mmap(0, size * 2, PROT_READ | PROT_WRITE,
+                      MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)) == MAP_FAILED) {
+      kprintf("simulated mmap failed: %m\n");
+      exit(1);
+    }
+    memmove(addr2, addr[i], size);
+    if (munmap(addr[i], size)) {
+      kprintf("simulated munmap failed: %m\n");
+      exit(1);
+    }
+    addr[i] = addr2;
+  }
+  kprintf("mremap(%'zu -> %'zu) took %'ld ns [simulated]\n", size, size * 2,
+          timespec_tonanos(timespec_sub(timespec_real(), ts1)) / N);
+
+  // unmap mappings
+  ts1 = timespec_real();
+  for (long i = 0; i < N; ++i)
+    if (munmap(addr[i], size * 2)) {
+      kprintf("munmap failed: %m\n");
+      exit(1);
+    }
+  kprintf("munmap(%'zu) took %'ld ns\n", size * 2,
+          timespec_tonanos(timespec_sub(timespec_real(), ts1)) / N);
+}
diff --git a/test/libc/intrin/munmap_test.c b/test/libc/intrin/munmap_test.c
index a420ad659..630325687 100644
--- a/test/libc/intrin/munmap_test.c
+++ b/test/libc/intrin/munmap_test.c
@@ -19,6 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
+#include "libc/intrin/maps.h"
 #include "libc/log/log.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sysv/consts/map.h"
@@ -26,116 +27,206 @@
 #include "libc/sysv/consts/prot.h"
 #include "libc/testlib/testlib.h"
 
-int granularity;
+int gransz;
 
 void SetUpOnce(void) {
-  granularity = __granularity();
+  gransz = getgransize();
   testlib_enable_tmp_setup_teardown();
 }
 
 TEST(munmap, doesntExist_doesntCare) {
-  EXPECT_SYS(0, 0, munmap(0, granularity * 8));
+  EXPECT_SYS(0, 0, munmap(0, gransz * 8));
 }
 
 TEST(munmap, invalidParams) {
   EXPECT_SYS(EINVAL, -1, munmap(0, 0));
   EXPECT_SYS(EINVAL, -1, munmap((void *)0x100080000000, 0));
-  EXPECT_SYS(EINVAL, -1, munmap((void *)0x100080000001, granularity));
+  EXPECT_SYS(EINVAL, -1, munmap((void *)0x100080000001, gransz));
 }
 
 TEST(munmap, test) {
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, granularity, PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, gransz, PROT_READ | PROT_WRITE,
                                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
   EXPECT_TRUE(testlib_memoryexists(p));
-  EXPECT_SYS(0, 0, munmap(p, granularity));
+  EXPECT_SYS(0, 0, munmap(p, gransz));
   EXPECT_FALSE(testlib_memoryexists(p));
 }
 
-TEST(munmap, punchHoleInMemory) {
+TEST(munmap, carveMemory) {
+  if (IsWindows())
+    return;  // needs carving
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, granularity * 3, PROT_READ | PROT_WRITE,
-                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 2));
-  EXPECT_SYS(0, 0, munmap(p + granularity, granularity));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 2));
-  EXPECT_SYS(0, 0, munmap(p, granularity));
-  EXPECT_SYS(0, 0, munmap(p + granularity * 2, granularity));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 2));
+  int count = __maps.count;
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(__maps_randaddr(), gransz * 3, PROT_READ | PROT_WRITE,
+                      MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
+  EXPECT_EQ(count + 1, __maps.count);
+  count = __maps.count;
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p + gransz * 0, gransz));
+  EXPECT_EQ(count + 0, __maps.count);
+  count = __maps.count;
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p + gransz * 2, gransz));
+  EXPECT_EQ(count + 0, __maps.count);
+  count = __maps.count;
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p + gransz * 1, gransz));
+  EXPECT_EQ(count - 1, __maps.count);
+  count = __maps.count;
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 2));
+}
+
+TEST(munmap, punchHoleInMemory) {
+  if (IsWindows())
+    return;  // needs carving
+  char *p;
+  int count = __maps.count;
+  ASSERT_NE(MAP_FAILED,
+            (p = mmap(__maps_randaddr(), gransz * 3, PROT_READ | PROT_WRITE,
+                      MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
+  EXPECT_EQ(count + 1, __maps.count);
+  count = __maps.count;
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p + gransz, gransz));
+  EXPECT_EQ(count + 1, __maps.count);
+  count = __maps.count;
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p, gransz));
+  EXPECT_EQ(count - 1, __maps.count);
+  count = __maps.count;
+  EXPECT_SYS(0, 0, munmap(p + gransz * 2, gransz));
+  EXPECT_EQ(count - 1, __maps.count);
+  count = __maps.count;
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 2));
+}
+
+TEST(munmap, fillHoleInMemory) {
+  if (IsWindows())
+    return;  // needs fungible memory
+  int count = __maps.count;
+  char *base = __maps_randaddr();
+  EXPECT_EQ(base + gransz * 0,
+            mmap(base + gransz * 0, gransz, PROT_READ | PROT_WRITE,
+                 MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
+  EXPECT_EQ(count + 1, __maps.count);
+  count = __maps.count;
+  EXPECT_TRUE(testlib_memoryexists(base + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(base + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(base + gransz * 2));
+  EXPECT_EQ(base + gransz * 2,
+            mmap(base + gransz * 2, gransz, PROT_READ | PROT_WRITE,
+                 MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
+  EXPECT_EQ(count + 1, __maps.count);
+  count = __maps.count;
+  EXPECT_TRUE(testlib_memoryexists(base + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(base + gransz * 1));
+  EXPECT_TRUE(testlib_memoryexists(base + gransz * 2));
+  EXPECT_EQ(base + gransz * 1,
+            mmap(base + gransz * 1, gransz, PROT_READ | PROT_WRITE,
+                 MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
+  EXPECT_EQ(count - 1, __maps.count);
+  count = __maps.count;
+  EXPECT_TRUE(testlib_memoryexists(base + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(base + gransz * 1));
+  EXPECT_TRUE(testlib_memoryexists(base + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(base, gransz * 3));
+  EXPECT_EQ(count - 1, __maps.count);
+  count = __maps.count;
+  EXPECT_FALSE(testlib_memoryexists(base + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(base + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(base + gransz * 2));
 }
 
 TEST(munmap, memoryHasHole) {
+  if (IsWindows())
+    return;  // needs carving
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, granularity * 3, PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, gransz * 3, PROT_READ | PROT_WRITE,
                                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
-  EXPECT_SYS(0, 0, munmap(p + granularity, granularity));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 2));
-  EXPECT_SYS(0, 0, munmap(p, granularity * 3));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 2));
+  EXPECT_SYS(0, 0, munmap(p + gransz, gransz));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p, gransz * 3));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 2));
 }
 
 TEST(munmap, blanketFree) {
+  if (IsWindows())
+    return;  // needs carving
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, granularity * 3, PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, gransz * 3, PROT_READ | PROT_WRITE,
                                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 2));
-  EXPECT_SYS(0, 0, munmap(p + granularity * 0, granularity));
-  EXPECT_SYS(0, 0, munmap(p + granularity * 2, granularity));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 2));
-  EXPECT_SYS(0, 0, munmap(p, granularity * 3));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 2));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p + gransz * 0, gransz));
+  EXPECT_SYS(0, 0, munmap(p + gransz * 2, gransz));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 2));
+  EXPECT_SYS(0, 0, munmap(p, gransz * 3));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 2));
 }
 
 TEST(munmap, trimLeft) {
+  if (IsWindows())
+    return;  // needs carving
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, granularity * 2, PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, gransz * 2, PROT_READ | PROT_WRITE,
                                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_SYS(0, 0, munmap(p, granularity));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_SYS(0, 0, munmap(p, granularity * 2));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 1));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_SYS(0, 0, munmap(p, gransz));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_SYS(0, 0, munmap(p, gransz * 2));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
 }
 
 TEST(munmap, trimRight) {
+  if (IsWindows())
+    return;  // needs carving
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, granularity * 2, PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, gransz * 2, PROT_READ | PROT_WRITE,
                                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_SYS(0, 0, munmap(p + granularity, granularity));
-  EXPECT_TRUE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 1));
-  EXPECT_SYS(0, 0, munmap(p, granularity * 2));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 0));
-  EXPECT_FALSE(testlib_memoryexists(p + granularity * 1));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_SYS(0, 0, munmap(p + gransz, gransz));
+  EXPECT_TRUE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
+  EXPECT_SYS(0, 0, munmap(p, gransz * 2));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 0));
+  EXPECT_FALSE(testlib_memoryexists(p + gransz * 1));
 }
 
 TEST(munmap, memoryGone) {
   char *p;
-  ASSERT_NE(MAP_FAILED, (p = mmap(0, granularity, PROT_READ | PROT_WRITE,
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, gransz, PROT_READ | PROT_WRITE,
                                   MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
-  EXPECT_SYS(0, 0, munmap(p, granularity));
-  EXPECT_SYS(0, 0, munmap(p, granularity));
+  EXPECT_SYS(0, 0, munmap(p, gransz));
+  EXPECT_SYS(0, 0, munmap(p, gransz));
 }
 
 TEST(munmap, tinyFile_roundupUnmapSize) {
@@ -147,7 +238,7 @@ TEST(munmap, tinyFile_roundupUnmapSize) {
   ASSERT_NE(MAP_FAILED, (p = mmap(0, 5, PROT_READ, MAP_PRIVATE, 3, 0)));
   ASSERT_SYS(0, 0, close(3));
   EXPECT_TRUE(testlib_memoryexists(p));
-  EXPECT_SYS(0, 0, munmap(p, granularity));
+  EXPECT_SYS(0, 0, munmap(p, gransz));
   EXPECT_FALSE(testlib_memoryexists(p));
   EXPECT_FALSE(testlib_memoryexists(p + 5));
 }
@@ -171,22 +262,24 @@ TEST(munmap, tinyFile_preciseUnmapSize) {
 }
 
 // clang-format off
-/* TEST(munmap, tinyFile_mapThriceUnmapOnce) { */
-/*   char *p = (char *)0x000063d646e20000; */
-/*   ASSERT_SYS(0, 3, open("doge", O_RDWR | O_CREAT | O_TRUNC, 0644)); */
-/*   ASSERT_SYS (0, 5, write(3, "hello", 5)); */
-/*   ASSERT_EQ(p+granularity*0, mmap(p+granularity*0, granularity, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0)); */
-/*   ASSERT_EQ(p+granularity*1, mmap(p+granularity*1, 5, PROT_READ, MAP_PRIVATE|MAP_FIXED, 3, 0)); */
-/*   ASSERT_EQ(p+granularity*3, mmap(p+granularity*3, 5, PROT_READ, MAP_PRIVATE|MAP_FIXED, 3, 0)); */
-/*   ASSERT_SYS(0, 0, close(3)); */
-/*   EXPECT_TRUE(testlib_memoryexists(p+granularity*0)); */
-/*   EXPECT_TRUE(testlib_memoryexists(p+granularity*1)); */
-/*   EXPECT_FALSE(testlib_memoryexists(p+granularity*2)); */
-/*   EXPECT_TRUE(testlib_memoryexists(p+granularity*3)); */
-/*   EXPECT_SYS(0, 0, munmap(p, granularity*5)); */
-/*   EXPECT_FALSE(testlib_memoryexists(p+granularity*0)); */
-/*   EXPECT_FALSE(testlib_memoryexists(p+granularity*1)); */
-/*   EXPECT_FALSE(testlib_memoryexists(p+granularity*2)); */
-/*   EXPECT_FALSE(testlib_memoryexists(p+granularity*3)); */
-/* } */
+TEST(munmap, tinyFile_mapThriceUnmapOnce) {
+  char *p;
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, gransz*5, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)));
+  ASSERT_SYS(0, 3, open("doge", O_RDWR | O_CREAT | O_TRUNC, 0644));
+  ASSERT_SYS(0, 0, munmap(p, gransz*5));
+  ASSERT_SYS (0, 5, write(3, "hello", 5));
+  ASSERT_EQ(p+gransz*0, mmap(p+gransz*0, gransz, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0));
+  ASSERT_EQ(p+gransz*1, mmap(p+gransz*1, 5, PROT_READ, MAP_PRIVATE|MAP_FIXED, 3, 0));
+  ASSERT_EQ(p+gransz*3, mmap(p+gransz*3, 5, PROT_READ, MAP_PRIVATE|MAP_FIXED, 3, 0));
+  ASSERT_SYS(0, 0, close(3));
+  EXPECT_TRUE(testlib_memoryexists(p+gransz*0));
+  EXPECT_TRUE(testlib_memoryexists(p+gransz*1));
+  EXPECT_FALSE(testlib_memoryexists(p+gransz*2));
+  EXPECT_TRUE(testlib_memoryexists(p+gransz*3));
+  EXPECT_SYS(0, 0, munmap(p, gransz*5));
+  EXPECT_FALSE(testlib_memoryexists(p+gransz*0));
+  EXPECT_FALSE(testlib_memoryexists(p+gransz*1));
+  EXPECT_FALSE(testlib_memoryexists(p+gransz*2));
+  EXPECT_FALSE(testlib_memoryexists(p+gransz*3));
+}
 // clang-format on
diff --git a/test/libc/intrin/pthread_mutex_lock2_test.c b/test/libc/intrin/pthread_mutex_lock2_test.c
index 93224da84..b530ac04b 100644
--- a/test/libc/intrin/pthread_mutex_lock2_test.c
+++ b/test/libc/intrin/pthread_mutex_lock2_test.c
@@ -40,7 +40,7 @@ pthread_mutexattr_t attr;
 
 FIXTURE(pthread_mutex_lock, normal) {
   ASSERT_EQ(0, pthread_mutexattr_init(&attr));
-  ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL));
+  ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT));
   ASSERT_EQ(0, pthread_mutex_init(&lock, &attr));
   ASSERT_EQ(0, pthread_mutexattr_destroy(&attr));
 }
@@ -79,7 +79,7 @@ TEST(pthread_mutex_lock, contention) {
   int i;
   pthread_t *th = gc(malloc(sizeof(pthread_t) * THREADS));
   pthread_mutexattr_init(&attr);
-  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
+  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
   pthread_mutex_init(&lock, &attr);
   pthread_mutexattr_destroy(&attr);
   count = 0;
@@ -128,7 +128,7 @@ BENCH(pthread_mutex_lock, bench_uncontended) {
     pthread_mutex_t m;
     pthread_mutexattr_t attr;
     pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
     pthread_mutex_init(&m, &attr);
     EZBENCH2("normal 1x", donothing, BenchLockUnlock(&m));
   }
@@ -226,7 +226,7 @@ BENCH(pthread_mutex_lock, bench_contended) {
     pthread_mutex_t m;
     pthread_mutexattr_t attr;
     pthread_mutexattr_init(&attr);
-    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
     pthread_mutex_init(&m, &attr);
     struct MutexContentionArgs a = {&m};
     pthread_create(&t, 0, MutexContentionWorker, &a);
diff --git a/test/libc/intrin/pthread_mutex_lock_test.c b/test/libc/intrin/pthread_mutex_lock_test.c
index b45d2a20a..0a5514a98 100644
--- a/test/libc/intrin/pthread_mutex_lock_test.c
+++ b/test/libc/intrin/pthread_mutex_lock_test.c
@@ -20,12 +20,16 @@
 #include "libc/atomic.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/state.internal.h"
+#include "libc/calls/struct/sigaction.h"
+#include "libc/cosmo.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/strace.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
+#include "libc/mem/leaks.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
@@ -34,6 +38,7 @@
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/rlimit.h"
+#include "libc/sysv/consts/sig.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
@@ -48,16 +53,38 @@
 int count;
 atomic_int started;
 atomic_int finished;
+pthread_mutex_t lock;
 pthread_mutex_t mylock;
 pthread_spinlock_t slock;
 pthread_t th[THREADS];
 
+void ignore_signal(int sig) {
+}
+
 void SetUpOnce(void) {
   ASSERT_SYS(0, 0, pledge("stdio rpath", 0));
+  kprintf("running %s\n", program_invocation_name);
+  signal(SIGTRAP, ignore_signal);
+}
+
+TEST(pthread_mutex_lock, default) {
+  pthread_mutexattr_t attr;
+  ASSERT_EQ(0, pthread_mutexattr_init(&attr));
+  ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT));
+  ASSERT_EQ(0, pthread_mutex_init(&lock, &attr));
+  ASSERT_EQ(0, pthread_mutexattr_destroy(&attr));
+  ASSERT_EQ(0, pthread_mutex_init(&lock, 0));
+  ASSERT_EQ(0, pthread_mutex_lock(&lock));
+  ASSERT_EQ(EBUSY, pthread_mutex_trylock(&lock));
+  ASSERT_EQ(0, pthread_mutex_unlock(&lock));
+  ASSERT_EQ(0, pthread_mutex_trylock(&lock));
+  ASSERT_EQ(0, pthread_mutex_unlock(&lock));
+  ASSERT_EQ(0, pthread_mutex_lock(&lock));
+  ASSERT_EQ(0, pthread_mutex_unlock(&lock));
+  ASSERT_EQ(0, pthread_mutex_destroy(&lock));
 }
 
 TEST(pthread_mutex_lock, normal) {
-  pthread_mutex_t lock;
   pthread_mutexattr_t attr;
   ASSERT_EQ(0, pthread_mutexattr_init(&attr));
   ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL));
@@ -75,7 +102,6 @@ TEST(pthread_mutex_lock, normal) {
 }
 
 TEST(pthread_mutex_lock, recursive) {
-  pthread_mutex_t lock;
   pthread_mutexattr_t attr;
   ASSERT_EQ(0, pthread_mutexattr_init(&attr));
   ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE));
@@ -95,20 +121,19 @@ TEST(pthread_mutex_lock, recursive) {
   }
   ASSERT_EQ(0, pthread_mutex_lock(&lock));
   ASSERT_EQ(0, pthread_mutex_unlock(&lock));
-  ASSERT_EQ(0, pthread_mutex_unlock(&lock));
   ASSERT_EQ(0, pthread_mutex_destroy(&lock));
 }
 
 TEST(pthread_mutex_lock, errorcheck) {
-  pthread_mutex_t lock;
   pthread_mutexattr_t attr;
   ASSERT_EQ(0, pthread_mutexattr_init(&attr));
   ASSERT_EQ(0, pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK));
   ASSERT_EQ(0, pthread_mutex_init(&lock, &attr));
   ASSERT_EQ(0, pthread_mutexattr_destroy(&attr));
   ASSERT_EQ(0, pthread_mutex_lock(&lock));
+  ASSERT_EQ(1, __deadlock_tracked(&lock));
   ASSERT_EQ(EDEADLK, pthread_mutex_lock(&lock));
-  ASSERT_EQ(EDEADLK, pthread_mutex_trylock(&lock));
+  ASSERT_EQ(EBUSY, pthread_mutex_trylock(&lock));
   ASSERT_EQ(0, pthread_mutex_unlock(&lock));
   ASSERT_EQ(0, pthread_mutex_destroy(&lock));
 }
@@ -131,7 +156,7 @@ TEST(pthread_mutex_lock, contention) {
   int i;
   pthread_mutexattr_t attr;
   pthread_mutexattr_init(&attr);
-  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
+  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
   pthread_mutex_init(&mylock, &attr);
   pthread_mutexattr_destroy(&attr);
   count = 0;
diff --git a/test/libc/intrin/rand64_test.c b/test/libc/intrin/rand64_test.c
index dc0c19a4b..0e0062656 100644
--- a/test/libc/intrin/rand64_test.c
+++ b/test/libc/intrin/rand64_test.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/internal.h"
 #include "libc/stdio/rand.h"
 #include "libc/str/str.h"
diff --git a/test/libc/intrin/stack_test.c b/test/libc/intrin/stack_test.c
new file mode 100644
index 000000000..e07a2d7fc
--- /dev/null
+++ b/test/libc/intrin/stack_test.c
@@ -0,0 +1,75 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/syscall-sysv.internal.h"
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/errno.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
+#include "libc/testlib/testlib.h"
+
+// returns true if byte at memory address is readable
+bool readable(void *addr) {
+  return testlib_pokememory(addr);
+}
+
+// returns true if page is reserved by linux memory manager
+// it can be true for addresses that aren't listed in /proc/PID/maps
+bool occupied(void *addr) {
+  int olde = errno;
+  char *want = (char *)((uintptr_t)addr & -__pagesize);
+  char *got =
+      __sys_mmap(want, __pagesize, PROT_READ | PROT_WRITE,
+                 MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED_NOREPLACE, -1, 0, 0);
+  if (got == MAP_FAILED) {
+    unassert(errno == IsFreebsd() ? EINVAL : EEXIST);
+    errno = olde;
+    return true;
+  }
+  sys_munmap(got, __pagesize);
+  return got != want;
+}
+
+TEST(stack, test) {
+  if (IsWindows())
+    return;
+
+  void *vstackaddr;
+  size_t stacksize = 65536;
+  size_t guardsize = 4096;
+  unassert(!cosmo_stack_alloc(&stacksize, &guardsize, &vstackaddr));
+  char *stackaddr = vstackaddr;
+
+  /* check memory reservation */
+  unassert(occupied(stackaddr + stacksize - 1));  // top stack
+  unassert(occupied(stackaddr));                  // bot stack
+  unassert(occupied(stackaddr - 1));              // top guard
+  unassert(occupied(stackaddr - guardsize));      // bot guard
+
+  /* check memory accessibility */
+  unassert(readable(stackaddr + stacksize - 1));  // top stack
+  unassert(readable(stackaddr));                  // bot stack
+  unassert(!readable(stackaddr - 1));             // top guard
+  unassert(!readable(stackaddr - guardsize));     // bot guard
+
+  unassert(!cosmo_stack_free(stackaddr, stacksize, guardsize));
+}
diff --git a/test/libc/intrin/strcmp_test.c b/test/libc/intrin/strcmp_test.c
index a17153f58..c2be5af6c 100644
--- a/test/libc/intrin/strcmp_test.c
+++ b/test/libc/intrin/strcmp_test.c
@@ -17,8 +17,9 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/assert.h"
+#include "libc/ctype.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/cachesize.h"
diff --git a/test/libc/intrin/strlen_test.c b/test/libc/intrin/strlen_test.c
index 87c316fa0..3d0619ee4 100644
--- a/test/libc/intrin/strlen_test.c
+++ b/test/libc/intrin/strlen_test.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
diff --git a/test/libc/intrin/tree_test.c b/test/libc/intrin/tree_test.c
new file mode 100644
index 000000000..fbddf18f7
--- /dev/null
+++ b/test/libc/intrin/tree_test.c
@@ -0,0 +1,279 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include "libc/intrin/tree.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/maps.h"
+#include "libc/intrin/tree.h"
+#include "libc/macros.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/rand.h"
+
+#define NUMBER_CONTAINER(e) TREE_CONTAINER(struct number, elem, e)
+
+void tree_checker(const struct Tree *node, const struct Tree *parent,
+                  int black_count, int *black_height, tree_cmp_f *cmp) {
+  if (!node) {
+    // Leaf nodes are considered black
+    if (*black_height == -1) {
+      *black_height = black_count;
+    } else if (black_count != *black_height) {
+      // ILLEGAL TREE: Black height mismatch
+      __builtin_trap();
+    }
+    return;
+  }
+  if (node->parent != parent)
+    // ILLEGAL TREE: Parent link is incorrect
+    __builtin_trap();
+  if (parent) {
+    if (tree_get_left(parent) == node && cmp(parent, node) < 0)
+      // ILLEGAL TREE: Binary search property violated on left child
+      __builtin_trap();
+    if (parent->right == node && cmp(node, parent) < 0)
+      // ILLEGAL TREE: Binary search property violated on right child
+      __builtin_trap();
+  }
+  if (!tree_get_red(node)) {
+    black_count++;
+  } else if (parent && tree_get_red(parent)) {
+    // ILLEGAL TREE: Red node has red child
+    __builtin_trap();
+  }
+  tree_checker(tree_get_left(node), node, black_count, black_height, cmp);
+  tree_checker(node->right, node, black_count, black_height, cmp);
+}
+
+void tree_check(struct Tree *root, tree_cmp_f *cmp) {
+  if (root) {
+    if (tree_get_red(root))
+      // ILLEGAL TREE: root node must be black
+      __builtin_trap();
+    int black_height = -1;
+    tree_checker(root, 0, 0, &black_height, cmp);
+  }
+}
+
+struct number {
+  long number;
+  struct Tree elem;
+};
+
+int number_compare(const struct Tree *ra, const struct Tree *rb) {
+  const struct number *a = NUMBER_CONTAINER(ra);
+  const struct number *b = NUMBER_CONTAINER(rb);
+  return (a->number > b->number) - (a->number < b->number);
+}
+
+struct number *number_new(int number) {
+  struct number *res;
+  if ((res = malloc(sizeof(struct number))))
+    res->number = number;
+  return res;
+}
+
+void print(struct Tree *tree) {
+  for (struct Tree *e = tree_first(tree); e; e = tree_next(e))
+    kprintf("%3d", NUMBER_CONTAINER(e)->number);
+  kprintf("\n");
+}
+
+void print_reversed(struct Tree *tree) {
+  for (struct Tree *e = tree_last(tree); e; e = tree_prev(e))
+    kprintf("%3d", NUMBER_CONTAINER(e)->number);
+  kprintf("\n");
+}
+
+int number_search(const void *ra, const struct Tree *rb) {
+  long a = (long)ra;
+  const struct number *b = NUMBER_CONTAINER(rb);
+  return (a > b->number) - (a < b->number);
+}
+
+void simple_test(void) {
+  //        0  2  2 23 30 32 34 34 46 52 53 65 70 74 90 94 95 95 96 96
+  //       96 96 95 95 94 90 74 70 65 53 52 46 34 34 32 30 23  2  2  0
+  static const long kNumba[] = {74, 53, 96, 70, 34, 95, 30, 2,  96, 46,
+                                23, 2,  52, 0,  34, 94, 90, 95, 32, 65};
+
+  // test insertion works
+  struct Tree *tree = 0;
+  for (int i = 0; i < 20; ++i) {
+    int number = kNumba[i];
+    kprintf("%3d", number);
+    tree_insert(&tree, &number_new(number)->elem, number_compare);
+    tree_check(tree, number_compare);
+  }
+  kprintf("\n");
+
+  // test iteration works
+  print(tree);
+
+  // test reverse iteration works
+  print_reversed(tree);
+
+  // test removal works
+  for (int i = 0; i < 20; ++i) {
+    tree_remove(&tree, tree_get(tree, (void *)kNumba[i], number_search));
+    tree_check(tree, number_compare);
+    print(tree);
+  }
+
+  // use up a bunch of memory
+  for (int i = 0; i < 100000; ++i)
+    tree_insert(&tree, &number_new(rand())->elem, number_compare);
+  tree_check(tree, number_compare);
+  tree_check(__maps.maps, __maps_compare);
+
+  // visually verify maps get coalesced
+  __print_maps(0);
+}
+
+void search_test(void) {
+  struct Tree *x, *tree = 0;
+  tree_insert(&tree, &number_new(1)->elem, number_compare);
+  tree_insert(&tree, &number_new(3)->elem, number_compare);
+  tree_insert(&tree, &number_new(5)->elem, number_compare);
+  tree_insert(&tree, &number_new(7)->elem, number_compare);
+
+  // Test tree_get()
+  //
+  // Returns node equal to given key.
+  //
+  //    [1 3 5 7]   [1 3 5 7]   [1 3 5 7]
+  //       NULL        ↑               NULL
+  //        4          3                8
+  //
+  x = tree_get(tree, (void *)4l, number_search);
+  if (x)
+    exit(1);
+  x = tree_get(tree, (void *)3l, number_search);
+  if (!x)
+    exit(2);
+  if (NUMBER_CONTAINER(x)->number != 3)
+    exit(3);
+  if (!tree_get(tree, (void *)7l, number_search))
+    exit(27);
+  if (tree_get(tree, (void *)8l, number_search))
+    exit(28);
+
+  // Test tree_floor()
+  //
+  // Returns last node less than or equal to given key.
+  //
+  //    [1 3 5 7]   [1 3 5 7]   [1 3 5 7]
+  //       ↑           ↑               ↑
+  //       4           3               8
+  //
+  x = tree_floor(tree, (void *)0l, number_search);
+  if (x)
+    exit(4);
+  x = tree_floor(tree, (void *)4l, number_search);
+  if (!x)
+    exit(4);
+  if (NUMBER_CONTAINER(x)->number != 3)
+    exit(5);
+  x = tree_floor(tree, (void *)3l, number_search);
+  if (!x)
+    exit(6);
+  if (NUMBER_CONTAINER(x)->number != 3)
+    exit(7);
+  if (!tree_floor(tree, (void *)7l, number_search))
+    exit(24);
+  x = tree_floor(tree, (void *)8l, number_search);
+  if (!x)
+    exit(25);
+  if (NUMBER_CONTAINER(x)->number != 7)
+    exit(30);
+  if (tree_floor(tree, (void *)0l, number_search))
+    exit(31);
+
+  // Test tree_lower()
+  //
+  // Returns first node not less than given key.
+  //
+  //    [1 3 5 7]   [1 3 5 7]   [1 3 5 7]
+  //         ↑         ↑               NULL
+  //         4         3                8
+  //
+  x = tree_lower(tree, (void *)4l, number_search);
+  if (!x)
+    exit(4);
+  if (NUMBER_CONTAINER(x)->number != 5)
+    exit(8);
+  x = tree_lower(tree, (void *)3l, number_search);
+  if (!x)
+    exit(9);
+  if (NUMBER_CONTAINER(x)->number != 3)
+    exit(10);
+  if (!tree_lower(tree, (void *)7l, number_search))
+    exit(22);
+  if (tree_lower(tree, (void *)8l, number_search))
+    exit(23);
+
+  // Test tree_ceil()
+  //
+  // Returns first node greater than than given key.
+  //
+  //    [1 3 5 7]   [1 3 5 7]   [1 3 5 7]
+  //         ↑           ↑             NULL
+  //         4           3              8
+  //
+  x = tree_ceil(tree, (void *)4l, number_search);
+  if (!x)
+    exit(11);
+  if (NUMBER_CONTAINER(x)->number != 5)
+    exit(12);
+  x = tree_ceil(tree, (void *)3l, number_search);
+  if (!x)
+    exit(13);
+  if (NUMBER_CONTAINER(x)->number != 5)
+    exit(14);
+  if (tree_ceil(tree, (void *)7l, number_search))
+    exit(21);
+
+  // Test tree_first()
+  if (tree_first(NULL))
+    exit(15);
+  x = tree_first(tree);
+  if (!x)
+    exit(16);
+  if (NUMBER_CONTAINER(x)->number != 1)
+    exit(17);
+
+  // Test tree_last()
+  if (tree_last(NULL))
+    exit(18);
+  x = tree_last(tree);
+  if (!x)
+    exit(19);
+  if (NUMBER_CONTAINER(x)->number != 7)
+    exit(20);
+}
+
+int main() {
+  ShowCrashReports();
+
+  // show memory maps at startup
+  tree_check(__maps.maps, __maps_compare);
+  kprintf("\n");
+  __print_maps(0);
+  kprintf("\n");
+
+  // run tests
+  simple_test();
+  search_test();
+}
diff --git a/test/libc/log/BUILD.mk b/test/libc/log/BUILD.mk
index 5850736bf..ee7bf2c1e 100644
--- a/test/libc/log/BUILD.mk
+++ b/test/libc/log/BUILD.mk
@@ -5,14 +5,8 @@ PKGS += TEST_LIBC_LOG
 
 TEST_LIBC_LOG_SRCS := $(wildcard test/libc/log/*.c)
 TEST_LIBC_LOG_SRCS_TEST = $(filter %_test.c,$(TEST_LIBC_LOG_SRCS))
-
-TEST_LIBC_LOG_OBJS =						\
-	$(TEST_LIBC_LOG_SRCS:%.c=o/$(MODE)/%.o)			\
-	o/$(MODE)/test/libc/log/backtrace.zip.o			\
-	o/$(MODE)/test/libc/log/backtrace.dbg.zip.o
-
-TEST_LIBC_LOG_COMS =						\
-	$(TEST_LIBC_LOG_SRCS:%.c=o/$(MODE)/%)
+TEST_LIBC_LOG_OBJS = $(TEST_LIBC_LOG_SRCS:%.c=o/$(MODE)/%.o)
+TEST_LIBC_LOG_COMS = $(TEST_LIBC_LOG_SRCS:%.c=o/$(MODE)/%)
 
 TEST_LIBC_LOG_BINS =						\
 	$(TEST_LIBC_LOG_COMS)					\
@@ -26,19 +20,17 @@ TEST_LIBC_LOG_CHECKS =						\
 
 TEST_LIBC_LOG_DIRECTDEPS =					\
 	LIBC_CALLS						\
-	LIBC_RUNTIME						\
-	NET_HTTP						\
-	LIBC_STDIO						\
-	LIBC_X							\
-	LIBC_INTRIN						\
 	LIBC_FMT						\
+	LIBC_INTRIN						\
+	LIBC_LOG						\
 	LIBC_MEM						\
 	LIBC_NEXGEN32E						\
-	LIBC_LOG						\
+	LIBC_PROC						\
+	LIBC_RUNTIME						\
+	LIBC_STDIO						\
 	LIBC_STR						\
-	LIBC_TESTLIB						\
 	LIBC_SYSV						\
-	LIBC_LOG
+	LIBC_TESTLIB						\
 
 TEST_LIBC_LOG_DEPS :=						\
 	$(call uniq,$(foreach x,$(TEST_LIBC_LOG_DIRECTDEPS),$($(x))))
@@ -56,29 +48,6 @@ o/$(MODE)/test/libc/log/%.dbg:					\
 		$(APE_NO_MODIFY_SELF)
 	@$(APELINK)
 
-o/$(MODE)/test/libc/log/backtrace_test.dbg:			\
-		$(TEST_LIBC_LOG_DEPS)				\
-		o/$(MODE)/test/libc/log/backtrace.zip.o		\
-		o/$(MODE)/test/libc/log/backtrace.dbg.zip.o	\
-		o/$(MODE)/test/libc/log/backtrace_test.o	\
-		o/$(MODE)/test/libc/log/log.pkg			\
-		$(LIBC_TESTMAIN)				\
-		$(CRT)						\
-		$(APE_NO_MODIFY_SELF)
-	@$(APELINK)
-
-o/$(MODE)/test/libc/log/backtrace.dbg:				\
-		$(TEST_LIBC_LOG_DEPS)				\
-		o/$(MODE)/test/libc/log/backtrace.o		\
-		$(CRT)						\
-		$(APE_NO_MODIFY_SELF)
-	@$(APELINK)
-
-o/$(MODE)/test/libc/log/backtrace.zip.o				\
-o/$(MODE)/test/libc/log/backtrace.dbg.zip.o: private		\
-		ZIPOBJ_FLAGS +=					\
-			-B
-
 .PHONY: o/$(MODE)/test/libc/log
 o/$(MODE)/test/libc/log:					\
 		$(TEST_LIBC_LOG_BINS)				\
diff --git a/test/libc/log/backtrace.c b/test/libc/log/backtrace.c
deleted file mode 100644
index 0d553b1ed..000000000
--- a/test/libc/log/backtrace.c
+++ /dev/null
@@ -1,142 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/fmt/conv.h"
-#include "libc/limits.h"
-#include "libc/log/log.h"
-#include "libc/mem/leaks.h"
-#include "libc/mem/mem.h"
-#include "libc/runtime/internal.h"
-#include "libc/runtime/symbols.internal.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#ifdef __x86_64__
-
-int StackOverflow(int f(), int n) {
-  if (n < INT_MAX) {
-    return f(f, n + 1) - 1;
-  } else {
-    return INT_MAX;
-  }
-}
-
-void FpuCrash(void) {
-  typedef char xmm_t __attribute__((__vector_size__(16)));
-  xmm_t v = {0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
-             0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf};
-  volatile int x = 0;
-  asm volatile("fldpi");
-  asm volatile("mov\t%0,%%r15" : /* no outputs */ : "g"(0x3133731337));
-  asm volatile("movaps\t%0,%%xmm15" : /* no outputs */ : "x"(v));
-  fputc(7 / x, stdout);
-}
-
-char bss[10];
-void BssOverrunCrash(int n) {
-  int i;
-  for (i = 0; i < n; ++i) {
-    bss[i] = i;
-  }
-}
-
-char data[10] = "abcdeabcde";
-void DataOverrunCrash(int n) {
-  int i;
-  for (i = 0; i < n; ++i) {
-    data[i] = i;
-  }
-}
-
-const char rodata[10] = "abcdeabcde";
-int RodataOverrunCrash(int i) {
-  return rodata[i];
-}
-
-char *StackOverrunCrash(int n) {
-  int i;
-  char stack[10];
-  bzero(stack, sizeof(stack));
-  for (i = 0; i < n; ++i) {
-    stack[i] = i;
-  }
-  return strdup(stack);
-}
-
-char *MemoryLeakCrash(void) {
-  char *p = strdup("doge");
-  CheckForMemoryLeaks();
-  return p;
-}
-
-int NpeCrash(char *p) {
-  asm("nop");  // xxx: due to backtrace addr-1 thing
-  return *p;
-}
-
-void (*pFpuCrash)(void) = FpuCrash;
-void (*pBssOverrunCrash)(int) = BssOverrunCrash;
-void (*pDataOverrunCrash)(int) = DataOverrunCrash;
-int (*pRodataOverrunCrash)(int) = RodataOverrunCrash;
-char *(*pStackOverrunCrash)(int) = StackOverrunCrash;
-char *(*pMemoryLeakCrash)(void) = MemoryLeakCrash;
-int (*pNpeCrash)(char *) = NpeCrash;
-int (*pStackOverflow)(int (*)(), int) = StackOverflow;
-
-int main(int argc, char *argv[]) {
-  ShowCrashReports();
-  if (argc > 1) {
-    switch (atoi(argv[1])) {
-      case 0:
-        break;
-      case 1:
-        pFpuCrash();
-        exit(0);
-      case 2:
-        pBssOverrunCrash(10 + 1);
-        exit(0);
-      case 3:
-        exit(pRodataOverrunCrash(10 + 1));
-      case 4:
-        pDataOverrunCrash(10 + 1);
-        exit(0);
-      case 5:
-        exit((intptr_t)pStackOverrunCrash(10 + 10000));
-      case 6:
-        exit((intptr_t)pMemoryLeakCrash());
-      case 7:
-        exit(pNpeCrash(0));
-      case 8:
-        exit(pNpeCrash(0));
-      case 9:
-        exit(pStackOverflow(pStackOverflow, 0));
-      default:
-        fputs("error: unrecognized argument\n", stderr);
-        exit(1);
-    }
-  } else {
-    fputs("error: too few args\n", stderr);
-    exit(1);
-  }
-}
-
-#else
-
-int main(int argc, char *argv[]) {
-}
-
-#endif /* __x86_64__ */
diff --git a/test/libc/log/backtrace_test.c b/test/libc/log/backtrace_test.c
deleted file mode 100644
index ab735e4cf..000000000
--- a/test/libc/log/backtrace_test.c
+++ /dev/null
@@ -1,402 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/calls/calls.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/fmt/conv.h"
-#include "libc/limits.h"
-#include "libc/log/libfatal.internal.h"
-#include "libc/log/log.h"
-#include "libc/mem/gc.h"
-#include "libc/mem/mem.h"
-#include "libc/runtime/internal.h"
-#include "libc/runtime/runtime.h"
-#include "libc/runtime/symbols.internal.h"
-#include "libc/stdio/append.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/o.h"
-#include "libc/sysv/consts/sig.h"
-#include "libc/testlib/testlib.h"
-#include "libc/x/xasprintf.h"
-#include "net/http/escape.h"
-#ifdef __x86_64__
-
-#if 0
-__static_yoink("backtrace");
-__static_yoink("backtrace.dbg");
-
-void SetUpOnce(void) {
-  testlib_enable_tmp_setup_teardown_once();
-  ASSERT_NE(-1, mkdir("bin", 0755));
-  testlib_extract("/zip/backtrace", "bin/backtrace", 0755);
-  testlib_extract("/zip/backtrace.dbg", "bin/backtrace.dbg", 0755);
-}
-
-static bool OutputHasSymbol(const char *output, const char *s) {
-  return strstr(output, s) || (!FindDebugBinary() && strstr(output, "NULL"));
-}
-
-// UNFREED MEMORY
-// o/dbg/test/libc/log/backtrace_test
-// max allocated space            655,360
-// total allocated space               80
-// total free space               327,600
-// releasable space                     0
-// mmaped space                    65,360
-// non-mmapped space              327,680
-//
-// 100080040020 64 bytes 5 used
-//       421871 strdup
-//       416529 MemoryLeakCrash
-//       41666d SetUp
-//       45428c testlib_runtestcases
-//
-// 00007fff0000-000080010000 rw-pa-F 2x shadow of 000000000000
-// 000080070000-0000800a0000 rw-pa-F 3x shadow of 0000003c0000
-// 02008fff0000-020090020000 rw-pa-F 3x shadow of 10007ffc0000
-// 020090060000-020090080000 rw-pa-F 2x shadow of 100080340000
-// 0e007fff0000-0e0080010000 rw-pa-F 2x shadow of 6ffffffc0000
-// 100006560000-100006580000 rw-pa-F 2x shadow of 7ffc32b40000
-// 100080000000-100080050000 rw-pa-- 5x automap w/ 50 frame hole
-// 100080370000-100080390000 rw-pa-- 2x automap w/ 1 frame hole
-// 1000803a0000-1000803b0000 rw-pa-- 1x automap
-// 6ffffffe0000-700000000000 rw-paSF 2x stack
-// # 24 frames mapped w/ 51 frames gapped
-TEST(ShowCrashReports, testMemoryLeakCrash) {
-  size_t got;
-  ssize_t rc;
-  int ws, pid, fds[2];
-  char *output, buf[512];
-  ASSERT_NE(-1, pipe2(fds, O_CLOEXEC));
-  ASSERT_NE(-1, (pid = fork()));
-  if (!pid) {
-    dup2(fds[1], 1);
-    dup2(fds[1], 2);
-    execv("bin/backtrace", (char *const[]){"bin/backtrace", "6", 0});
-    _Exit(127);
-  }
-  close(fds[1]);
-  output = 0;
-  appends(&output, "");
-  for (;;) {
-    rc = read(fds[0], buf, sizeof(buf));
-    if (rc == -1) {
-      ASSERT_EQ(EINTR, errno);
-      continue;
-    }
-    if ((got = rc)) {
-      appendd(&output, buf, got);
-    } else {
-      break;
-    }
-  }
-  close(fds[0]);
-  ASSERT_NE(-1, wait(&ws));
-  // tinyprint(2, gc(IndentLines(output, -1, 0, 4)), "\n", NULL);
-  EXPECT_EQ(78 << 8, ws);
-  ASSERT_TRUE(!!strstr(output, "UNFREED MEMORY"));
-  if (IsAsan()) {
-    ASSERT_TRUE(OutputHasSymbol(output, "strdup") &&
-                OutputHasSymbol(output, "MemoryLeakCrash"));
-  }
-  free(output);
-}
-
-// error: Uncaught SIGFPE (FPE_INTDIV) on nightmare pid 11724
-//   /home/jart/cosmo/o/dbg/test/libc/log/backtrace_test.tmp.11721
-//   ENOTTY[25]
-//   Linux nightmare SMP Thu, 12 Aug 2021 06:16:45 UTC
-//
-// 0x0000000000414659: FpuCrash at test/libc/log/backtrace_test.c:35
-// 0x000000000045003b: testlib_runtestcases at libc/testlib/testrunner.c:98
-// 0x000000000044b770: testlib_runalltests at libc/testlib/runner.c:37
-// 0x000000000040278e: main at libc/testlib/testmain.c:86
-// 0x0000000000403210: cosmo at libc/runtime/cosmo.S:65
-// 0x0000000000402247: _start at libc/crt/crt.S:67
-//
-// RAX 0000000000000007 RBX 00006fffffffff10 RDI 00007ffe0745fde1 ST(0) 0.0
-// RCX 0000000000000000 RDX 0000000000000000 RSI 0000000000489900 ST(1) 0.0
-// RBP 00006fffffffff70 RSP 00006fffffffff10 RIP 000000000041465a ST(2) 0.0
-//  R8 0000000000000001  R9 00006ffffffffcc0 R10 00006ffffffffe60 ST(3) 0.0
-// R11 000000000000000d R12 00000dffffffffe2 R13 00006fffffffff10 ST(4) 0.0
-// R14 0000000000000003 R15 000000000049b700 VF PF ZF IF
-//
-// XMM0  00000000000000000000000000000000 XMM8  00000000000000000000000000000000
-// XMM1  000000008000000400000000004160ea XMM9  00000000000000000000000000000000
-// XMM2  00000000000000000000000000000000 XMM10 00000000000000000000000000000000
-// XMM3  00000000000000000000000000000000 XMM11 00000000000000000000000000000000
-// XMM4  00000000000000000000000000000000 XMM12 00000000000000000000000000000000
-// XMM5  00000000000000000000000000000000 XMM13 00000000000000000000000000000000
-// XMM6  00000000000000000000000000000000 XMM14 00000000000000000000000000000000
-// XMM7  00000000000000000000000000000000 XMM15 00000000000000000000000000000000
-//
-// mm->i == 4;
-// mm->p[  0]=={0x00008007,0x00008008,-1,3,50}; /* 2 */
-// /* 234,881,012 */
-// mm->p[  1]=={0x0e007ffd,0x0e007fff,-1,3,50}; /* 3 */
-// /* 33,538,280 */
-// mm->p[  2]=={0x100040e8,0x100040e8,-1,3,50}; /* 1 */
-// /* 1,610,596,103 */
-// mm->p[  3]=={0x6ffffff0,0x6fffffff,12884901888,306,0}; /* 16 */
-// /* 22 frames mapped w/ 1,879,015,395 frames gapped */
-//
-// 00400000-0045b000 r-xp 00000000 08:03 4587526
-// /home/jart/cosmo/o/dbg/test/libc/log/backtrace_test.tmp.11721
-// 0045b000-00461000 rw-p 0005b000 08:03 4587526
-// /home/jart/cosmo/o/dbg/test/libc/log/backtrace_test.tmp.11721
-// 00461000-004a0000 rw-p 00000000 00:00 0
-// 80070000-80090000 rw-p 00000000 00:00 0
-// e007ffd0000-e0080000000 rw-p 00000000 00:00 0
-// 100040e80000-100040e90000 rw-p 00000000 00:00 0
-// 6ffffff00000-700000000000 rw-p 00000000 00:00 0
-// 7ffe0743f000-7ffe07460000 rw-p 00000000 00:00 0 [stack]
-// 7ffe075a8000-7ffe075ab000 r--p 00000000 00:00 0 [vvar]
-// 7ffe075ab000-7ffe075ac000 r-xp 00000000 00:00 0 [vdso]
-//
-// /home/jart/cosmo/o/dbg/test/libc/log/backtrace_test.tmp.11721 1
-TEST(ShowCrashReports, testDivideByZero) {
-  size_t got;
-  ssize_t rc;
-  int ws, pid, fds[2];
-  char *output, buf[512];
-  ASSERT_NE(-1, pipe2(fds, O_CLOEXEC));
-  ASSERT_NE(-1, (pid = fork()));
-  if (!pid) {
-    dup2(fds[1], 1);
-    dup2(fds[1], 2);
-    execv("bin/backtrace", (char *const[]){"bin/backtrace", "1", 0});
-    _Exit(127);
-  }
-  close(fds[1]);
-  output = 0;
-  appends(&output, "");
-  for (;;) {
-    rc = read(fds[0], buf, sizeof(buf));
-    if (rc == -1) {
-      ASSERT_EQ(EINTR, errno);
-      continue;
-    }
-    if ((got = rc)) {
-      appendd(&output, buf, got);
-    } else {
-      break;
-    }
-  }
-  close(fds[0]);
-  ASSERT_NE(-1, wait(&ws));
-  // tinyprint(2, gc(IndentLines(output, -1, 0, 4)), "\n", NULL);
-  if (IsModeDbg()) {
-    EXPECT_EQ(77 << 8, ws);
-  } else {
-    EXPECT_TRUE(WIFSIGNALED(ws));
-    EXPECT_EQ(SIGFPE, WTERMSIG(ws));
-  }
-  /* NULL is stopgap until we can copy symbol tables into binary */
-#ifdef __FNO_OMIT_FRAME_POINTER__
-  ASSERT_TRUE(OutputHasSymbol(output, "FpuCrash"));
-#endif
-  if (strstr(output, "divrem overflow")) {
-    // UBSAN handled it
-  } else {
-    // ShowCrashReports() handled it
-    if (!strstr(output, gc(xasprintf("%d", pid)))) {
-      fprintf(stderr, "ERROR: crash report didn't have pid\n%s\n",
-              gc(IndentLines(output, -1, 0, 4)));
-      __die();
-    }
-    if (!strstr(output, "SIGFPE")) {
-      fprintf(stderr, "ERROR: crash report didn't have signal name\n%s\n",
-              gc(IndentLines(output, -1, 0, 4)));
-      __die();
-    }
-    // XXX: WSL doesn't save and restore x87 registers to ucontext_t
-    if (!__iswsl1()) {
-      if (!strstr(output, "3.141")) {
-        fprintf(stderr, "ERROR: crash report didn't have fpu register\n%s\n",
-                gc(IndentLines(output, -1, 0, 4)));
-        __die();
-      }
-    }
-    if (!strstr(output, "0f0e0d0c0b0a09080706050403020100")) {
-      fprintf(stderr, "ERROR: crash report didn't have sse register\n%s\n",
-              gc(IndentLines(output, -1, 0, 4)));
-      __die();
-    }
-    if (!strstr(output, "3133731337")) {
-      fprintf(stderr, "ERROR: crash report didn't have general register\n%s\n",
-              gc(IndentLines(output, -1, 0, 4)));
-      __die();
-    }
-  }
-  free(output);
-}
-
-TEST(ShowCrashReports, testBssOverrunCrash) {
-  if (!IsAsan()) return;
-  size_t got;
-  ssize_t rc;
-  int ws, pid, fds[2];
-  char *output, buf[512];
-  ASSERT_NE(-1, pipe2(fds, O_CLOEXEC));
-  ASSERT_NE(-1, (pid = fork()));
-  if (!pid) {
-    dup2(fds[1], 1);
-    dup2(fds[1], 2);
-    execv("bin/backtrace", (char *const[]){"bin/backtrace", "2", 0});
-    _Exit(127);
-  }
-  close(fds[1]);
-  output = 0;
-  appends(&output, "");
-  for (;;) {
-    rc = read(fds[0], buf, sizeof(buf));
-    if (rc == -1) {
-      ASSERT_EQ(EINTR, errno);
-      continue;
-    }
-    if ((got = rc)) {
-      appendd(&output, buf, got);
-    } else {
-      break;
-    }
-  }
-  close(fds[0]);
-  ASSERT_NE(-1, wait(&ws));
-  // tinyprint(2, gc(IndentLines(output, -1, 0, 4)), "\n", NULL);
-  EXPECT_EQ(77 << 8, ws);
-  /* NULL is stopgap until we can copy symbol tablces into binary */
-#ifdef __FNO_OMIT_FRAME_POINTER__
-  ASSERT_TRUE(OutputHasSymbol(output, "BssOverrunCrash"));
-#endif
-  if (IsAsan()) {
-    ASSERT_TRUE(
-        !!strstr(output, "'int' index 10 into 'char [10]' out of bounds"));
-  } else {
-    ASSERT_TRUE(!!strstr(output, "☺☻♥♦♣♠•◘○"));
-    ASSERT_TRUE(!!strstr(output, "global redzone"));
-  }
-  free(output);
-}
-
-TEST(ShowCrashReports, testDataOverrunCrash) {
-  if (!IsAsan()) return;
-  size_t got;
-  ssize_t rc;
-  int ws, pid, fds[2];
-  char *output, buf[512];
-  ASSERT_NE(-1, pipe2(fds, O_CLOEXEC));
-  ASSERT_NE(-1, (pid = fork()));
-  if (!pid) {
-    dup2(fds[1], 1);
-    dup2(fds[1], 2);
-    execv("bin/backtrace", (char *const[]){"bin/backtrace", "4", 0});
-    _Exit(127);
-  }
-  close(fds[1]);
-  output = 0;
-  appends(&output, "");
-  for (;;) {
-    rc = read(fds[0], buf, sizeof(buf));
-    if (rc == -1) {
-      ASSERT_EQ(EINTR, errno);
-      continue;
-    }
-    if ((got = rc)) {
-      appendd(&output, buf, got);
-    } else {
-      break;
-    }
-  }
-  close(fds[0]);
-  ASSERT_NE(-1, wait(&ws));
-  // tinyprint(2, gc(IndentLines(output, -1, 0, 4)), "\n", NULL);
-  EXPECT_EQ(77 << 8, ws);
-  /* NULL is stopgap until we can copy symbol tablces into binary */
-#ifdef __FNO_OMIT_FRAME_POINTER__
-  ASSERT_TRUE(OutputHasSymbol(output, "DataOverrunCrash"));
-#endif
-  if (!strstr(output, "'int' index 10 into 'char [10]' out")) {  // ubsan
-    ASSERT_TRUE(!!strstr(output, "☺☻♥♦♣♠•◘○"));                  // asan
-    ASSERT_TRUE(!!strstr(output, "global redzone"));             // asan
-  }
-  free(output);
-}
-
-TEST(ShowCrashReports, testNpeCrashAfterFinalize) {
-  /*
-   * this test makes sure we're not doing things like depending on
-   * environment variables after __cxa_finalize is called in cases
-   * where putenv() is used
-   */
-  size_t got;
-  ssize_t rc;
-  int ws, pid, fds[2];
-  char *output, buf[512];
-  ASSERT_NE(-1, pipe2(fds, O_CLOEXEC));
-  ASSERT_NE(-1, (pid = fork()));
-  if (!pid) {
-    dup2(fds[1], 1);
-    dup2(fds[1], 2);
-    execv("bin/backtrace", (char *const[]){"bin/backtrace", "8", 0});
-    _Exit(127);
-  }
-  close(fds[1]);
-  output = 0;
-  appends(&output, "");
-  for (;;) {
-    rc = read(fds[0], buf, sizeof(buf));
-    if (rc == -1) {
-      ASSERT_EQ(EINTR, errno);
-      continue;
-    }
-    if ((got = rc)) {
-      appendd(&output, buf, got);
-    } else {
-      break;
-    }
-  }
-  close(fds[0]);
-  ASSERT_NE(-1, wait(&ws));
-  // tinyprint(2, gc(IndentLines(output, -1, 0, 4)), "\n", NULL);
-  if (IsModeDbg()) {
-    EXPECT_EQ(77 << 8, ws);
-  } else {
-    EXPECT_TRUE(WIFSIGNALED(ws));
-    EXPECT_EQ(SIGSEGV, WTERMSIG(ws));
-  }
-  /* NULL is stopgap until we can copy symbol tables into binary */
-  if (!strstr(output, IsAsan() ? "null pointer" : "Uncaught SIGSEGV (SEGV_")) {
-    fprintf(stderr, "ERROR: crash report didn't diagnose the problem\n%s\n",
-            gc(IndentLines(output, -1, 0, 4)));
-    __die();
-  }
-#ifdef __FNO_OMIT_FRAME_POINTER__
-  if (!OutputHasSymbol(output, "NpeCrash")) {
-    fprintf(stderr, "ERROR: crash report didn't have backtrace\n%s\n",
-            gc(IndentLines(output, -1, 0, 4)));
-    __die();
-  }
-#endif
-  free(output);
-}
-#endif
-
-#endif /* __x86_64__ */
diff --git a/test/libc/mem/BUILD.mk b/test/libc/mem/BUILD.mk
index 44385da00..ec48d8263 100644
--- a/test/libc/mem/BUILD.mk
+++ b/test/libc/mem/BUILD.mk
@@ -85,7 +85,7 @@ o/$(MODE)/test/libc/mem/prog/life.elf:				\
 		o/$(MODE)/tool/build/assimilate			\
 		o/$(MODE)/test/libc/mem/prog/life
 	@$(COMPILE) -wACP -T$@					\
-		build/bootstrap/cp				\
+		$(CP)						\
 		o/$(MODE)/test/libc/mem/prog/life		\
 		o/$(MODE)/test/libc/mem/prog/life.elf
 	@$(COMPILE) -wAASSIMILATE -T$@				\
@@ -116,7 +116,7 @@ o/$(MODE)/test/libc/mem/prog/sock.elf:				\
 		o/$(MODE)/tool/build/assimilate			\
 		o/$(MODE)/test/libc/mem/prog/sock
 	@$(COMPILE) -wACP -T$@					\
-		build/bootstrap/cp				\
+		$(CP)						\
 		o/$(MODE)/test/libc/mem/prog/sock		\
 		o/$(MODE)/test/libc/mem/prog/sock.elf
 	@$(COMPILE) -wAASSIMILATE -T$@				\
diff --git a/test/libc/mem/djbsort_test.c b/test/libc/mem/djbsort_test.c
index 3f1f9db9b..e4c53ff94 100644
--- a/test/libc/mem/djbsort_test.c
+++ b/test/libc/mem/djbsort_test.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/limits.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
diff --git a/test/libc/mem/malloc_test.c b/test/libc/mem/malloc_test.c
index 0fceb4649..b1b7d2609 100644
--- a/test/libc/mem/malloc_test.c
+++ b/test/libc/mem/malloc_test.c
@@ -21,10 +21,9 @@
 #include "libc/calls/struct/timespec.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/cxaatexit.internal.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/cxaatexit.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/internal.h"
@@ -162,7 +161,7 @@ void *bulk[1024];
 void BulkFreeBenchSetup(void) {
   size_t i;
   for (i = 0; i < ARRAYLEN(bulk); ++i) {
-    bulk[i] = malloc(rand() % 64);
+    bulk[i] = rand() % 64 ? malloc(rand() % 64) : 0;
   }
 }
 
@@ -179,45 +178,15 @@ void MallocFree(void) {
   free(p);
 }
 
+void eat(void *p) {
+}
+
+void (*pEat)(void *) = eat;
+
 BENCH(bulk_free, bench) {
+  /* pEat(pthread_create); */
   EZBENCH2("free() bulk", BulkFreeBenchSetup(), FreeBulk());
   EZBENCH2("bulk_free()", BulkFreeBenchSetup(),
            bulk_free(bulk, ARRAYLEN(bulk)));
-  EZBENCH2("free(malloc(16)) ST", donothing, MallocFree());
-  __enable_threads();
-  EZBENCH2("free(malloc(16)) MT", donothing, MallocFree());
-}
-
-#define ITERATIONS 10000
-
-void *Worker(void *arg) {
-  /* for (int i = 0; i < ITERATIONS; ++i) { */
-  /*   char *p; */
-  /*   ASSERT_NE(NULL, (p = malloc(lemur64() % 128))); */
-  /*   ASSERT_NE(NULL, (p = realloc(p, max(lemur64() % 128, 1)))); */
-  /*   free(p); */
-  /* } */
-  return 0;
-}
-
-BENCH(malloc, torture) {
-  int i, n = __get_cpu_count();
-  pthread_t *t = gc(malloc(sizeof(pthread_t) * n));
-  if (!n)
-    return;
-  printf("\nmalloc torture test w/ %d threads and %d iterations\n", n,
-         ITERATIONS);
-  SPAWN(fork);
-  struct timespec t1 = timespec_real();
-  for (i = 0; i < n; ++i) {
-    ASSERT_EQ(0, pthread_create(t + i, 0, Worker, 0));
-  }
-  for (i = 0; i < n; ++i) {
-    ASSERT_EQ(0, pthread_join(t[i], 0));
-  }
-  struct timespec t2 = timespec_real();
-  printf("consumed %g wall and %g cpu seconds\n",
-         timespec_tomicros(timespec_sub(t2, t1)) * 1e-6,
-         (double)clock() / CLOCKS_PER_SEC);
-  EXITS(0);
+  EZBENCH2("free(malloc(16))", donothing, MallocFree());
 }
diff --git a/test/libc/mem/malloc_torture_test.c b/test/libc/mem/malloc_torture_test.c
new file mode 100644
index 000000000..f20c1dc20
--- /dev/null
+++ b/test/libc/mem/malloc_torture_test.c
@@ -0,0 +1,63 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/mem/gc.h"
+#include "libc/mem/leaks.h"
+#include "libc/mem/mem.h"
+#include "libc/stdio/rand.h"
+#include "libc/stdio/stdio.h"
+#include "libc/testlib/subprocess.h"
+#include "libc/testlib/testlib.h"
+#include "libc/thread/thread.h"
+
+#define ITERATIONS 1000
+#define THREADS    10
+#define SIZE       1024
+
+void *Worker(void *arg) {
+  for (int i = 0; i < ITERATIONS; ++i) {
+    char *p;
+    ASSERT_NE(NULL, (p = malloc(rand() % SIZE)));
+    ASSERT_NE(NULL, (p = realloc(p, rand() % SIZE)));
+    free(p);
+  }
+  return 0;
+}
+
+TEST(malloc, torture) {
+  int i, n = THREADS;
+  pthread_t *t = gc(malloc(sizeof(pthread_t) * n));
+  if (!n)
+    return;
+  printf("\nmalloc torture test w/ %d threads and %d iterations\n", n,
+         ITERATIONS);
+  SPAWN(fork);
+  AssertNoLocksAreHeld();
+  struct timespec t1 = timespec_real();
+  for (i = 0; i < n; ++i)
+    ASSERT_EQ(0, pthread_create(t + i, 0, Worker, 0));
+  for (i = 0; i < n; ++i)
+    ASSERT_EQ(0, pthread_join(t[i], 0));
+  struct timespec t2 = timespec_real();
+  printf("consumed %g wall and %g cpu seconds\n",
+         timespec_tomicros(timespec_sub(t2, t1)) * 1e-6,
+         (double)clock() / CLOCKS_PER_SEC);
+  EXITS(0);
+}
diff --git a/test/libc/mem/qsort_test.c b/test/libc/mem/qsort_test.c
index e693da6b6..de279d59e 100644
--- a/test/libc/mem/qsort_test.c
+++ b/test/libc/mem/qsort_test.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
diff --git a/test/libc/mem/realpath_test.c b/test/libc/mem/realpath_test.c
index ac1be2cae..83dc43251 100644
--- a/test/libc/mem/realpath_test.c
+++ b/test/libc/mem/realpath_test.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
diff --git a/test/libc/nexgen32e/kbase36_test.c b/test/libc/nexgen32e/kbase36_test.c
index aea4b9959..cd23d5fd0 100644
--- a/test/libc/nexgen32e/kbase36_test.c
+++ b/test/libc/nexgen32e/kbase36_test.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/testlib/testlib.h"
 
 TEST(kBase36, test) {
diff --git a/test/libc/nexgen32e/kcp437_test.c b/test/libc/nexgen32e/kcp437_test.c
index 46ce97b07..018453744 100644
--- a/test/libc/nexgen32e/kcp437_test.c
+++ b/test/libc/nexgen32e/kcp437_test.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/str/unicode.h"
 #include "libc/testlib/testlib.h"
 
diff --git a/test/libc/nexgen32e/lz4decode_test.c b/test/libc/nexgen32e/lz4decode_test.c
index 2f6fc2ef5..6afd50878 100644
--- a/test/libc/nexgen32e/lz4decode_test.c
+++ b/test/libc/nexgen32e/lz4decode_test.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/log/check.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
@@ -85,7 +85,7 @@ TEST(lz4, zoneFileGmt) {
                 (mapsize = roundup(
                      LZ4_FRAME_BLOCKCONTENTSIZE(lz4check(dict)) +
                          (gmtsize = LZ4_FRAME_BLOCKCONTENTSIZE(lz4check(gmt))),
-                     __granularity())))),
+                     getpagesize())))),
            dict)),
       gmt);
   ASSERT_BINEQ(
diff --git a/test/libc/nexgen32e/memmove_test.c b/test/libc/nexgen32e/memmove_test.c
index 8c54d5d08..92625b768 100644
--- a/test/libc/nexgen32e/memmove_test.c
+++ b/test/libc/nexgen32e/memmove_test.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/rand.h"
 #include "libc/str/str.h"
diff --git a/test/libc/proc/BUILD.mk b/test/libc/proc/BUILD.mk
index 11f37d91d..4175234ec 100644
--- a/test/libc/proc/BUILD.mk
+++ b/test/libc/proc/BUILD.mk
@@ -29,15 +29,17 @@ TEST_LIBC_PROC_DIRECTDEPS =						\
 	LIBC_MEM							\
 	LIBC_NEXGEN32E							\
 	LIBC_NT_KERNEL32						\
-	LIBC_RUNTIME							\
 	LIBC_PROC							\
+	LIBC_RUNTIME							\
+	LIBC_LOG							\
+	LIBC_STDIO							\
 	LIBC_STR							\
 	LIBC_SYSV							\
 	LIBC_TESTLIB							\
 	LIBC_THREAD							\
 	LIBC_X								\
 	THIRD_PARTY_MUSL						\
-	THIRD_PARTY_TR
+	THIRD_PARTY_TR							\
 
 TEST_LIBC_PROC_DEPS :=							\
 	$(call uniq,$(foreach x,$(TEST_LIBC_PROC_DIRECTDEPS),$($(x))))
@@ -59,6 +61,17 @@ o/$(MODE)/test/libc/proc/%.dbg:						\
 o/$(MODE)/test/libc/proc/posix_spawn_test.runs:				\
 		private QUOTA += -M8192m
 
+o/$(MODE)/test/libc/proc/fork_test.dbg:					\
+		$(TEST_LIBC_PROC_DEPS)					\
+		o/$(MODE)/test/libc/proc/fork_test.o			\
+		o/$(MODE)/test/libc/proc/proc.pkg			\
+		o/$(MODE)/tool/hello/life-pe.ape.zip.o			\
+		o/$(MODE)/test/libc/proc/life.zip.o			\
+		$(LIBC_TESTMAIN)					\
+		$(CRT)							\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
 o/$(MODE)/test/libc/proc/posix_spawn_test.dbg:				\
 		$(TEST_LIBC_PROC_DEPS)					\
 		o/$(MODE)/test/libc/proc/posix_spawn_test.o		\
@@ -73,23 +86,12 @@ o/$(MODE)/test/libc/proc/posix_spawn_test.dbg:				\
 		$(APE_NO_MODIFY_SELF)
 	@$(APELINK)
 
-o/$(MODE)/test/libc/proc/system_test.dbg:				\
-		$(TEST_LIBC_PROC_DEPS)					\
-		o/$(MODE)/test/libc/proc/system_test.o			\
-		o/$(MODE)/test/libc/proc/proc.pkg			\
-		o/$(MODE)/tool/build/echo.zip.o				\
-		o/$(MODE)/tool/build/cocmd.zip.o			\
-		o/$(MODE)/tool/build/false.zip.o			\
-		$(LIBC_TESTMAIN)					\
-		$(CRT)							\
-		$(APE_NO_MODIFY_SELF)
-	@$(APELINK)
-
 o/$(MODE)/test/libc/proc/execve_test.dbg:				\
 		$(TEST_LIBC_PROC_DEPS)					\
 		o/$(MODE)/test/libc/proc/execve_test.o			\
 		o/$(MODE)/test/libc/calls/life-nomod.zip.o		\
 		o/$(MODE)/test/libc/proc/execve_test_prog1.zip.o	\
+		o/$(MODE)/test/libc/proc/execve_test_prog2.zip.o	\
 		o/$(MODE)/test/libc/mem/prog/life.elf.zip.o		\
 		o/$(MODE)/test/libc/mem/prog/sock.elf.zip.o		\
 		o/$(MODE)/test/libc/proc/proc.pkg			\
@@ -110,7 +112,16 @@ o/$(MODE)/test/libc/proc/fexecve_test.dbg:				\
 		$(APE_NO_MODIFY_SELF)
 	@$(APELINK)
 
+o/$(MODE)/test/libc/proc/life.dbg:					\
+		$(TEST_LIBC_PROC_DEPS)					\
+		o/$(MODE)/test/libc/proc/life.o				\
+		$(CRT)							\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
+o/$(MODE)/test/libc/proc/life.zip.o					\
 o/$(MODE)/test/libc/proc/execve_test_prog1.zip.o			\
+o/$(MODE)/test/libc/proc/execve_test_prog2.zip.o			\
 o/$(MODE)/test/libc/proc/life-pe.zip.o: private				\
 		ZIPOBJ_FLAGS +=						\
 			-B
diff --git a/test/libc/proc/execve_test.c b/test/libc/proc/execve_test.c
index 01573483e..7bfd7b102 100644
--- a/test/libc/proc/execve_test.c
+++ b/test/libc/proc/execve_test.c
@@ -53,12 +53,12 @@ TEST(execve, testArgPassing) {
   char ibuf[12], buf[8];
   const char *prog = "./execve_test_prog1";
   testlib_extract("/zip/execve_test_prog1", prog, 0755);
+  testlib_extract("/zip/execve_test_prog2", "execve_test_prog2", 0755);
   for (i = 0; i < N; ++i) {
     FormatInt32(ibuf, i);
     GenBuf(buf, i);
     SPAWN(vfork);
-    execve(prog, (char *const[]){(char *)prog, "-", ibuf, buf, 0},
-           (char *const[]){0});
+    execl(prog, prog, "-", ibuf, buf, NULL);
     kprintf("execve failed: %m\n");
     EXITS(0);
   }
diff --git a/test/libc/proc/execve_test_prog1.c b/test/libc/proc/execve_test_prog1.c
index 5a1ea77e8..901c9b6bc 100644
--- a/test/libc/proc/execve_test_prog1.c
+++ b/test/libc/proc/execve_test_prog1.c
@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/fmt/conv.h"
+#include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 
 void GenBuf(char buf[8], int x) {
@@ -40,5 +41,15 @@ int main(int argc, char *argv[]) {
     tinyprint(2, "error: buf check failed\n", NULL);
     return 10;
   }
+  const char *prog = "./execve_test_prog2";
+  if (!fork()) {
+    execl(prog, prog, NULL);
+    _Exit(127);
+  }
+  int ws;
+  if (wait(&ws) == -1)
+    return 30;
+  if (ws)
+    return 31;
   return 0;
 }
diff --git a/test/libc/proc/execve_test_prog2.c b/test/libc/proc/execve_test_prog2.c
new file mode 100644
index 000000000..2369ec9c9
--- /dev/null
+++ b/test/libc/proc/execve_test_prog2.c
@@ -0,0 +1,23 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/proc/proc.h"
+#include "libc/testlib/testlib.h"
+
+int main(int argc, char *argv[]) {
+}
diff --git a/test/libc/proc/fork_test.c b/test/libc/proc/fork_test.c
index 76c95ce98..264f226d3 100644
--- a/test/libc/proc/fork_test.c
+++ b/test/libc/proc/fork_test.c
@@ -21,22 +21,32 @@
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/timespec.h"
+#include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
+#include "libc/intrin/kprintf.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/rdtsc.h"
+#include "libc/proc/posix_spawn.h"
 #include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/msync.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/sig.h"
+#include "libc/testlib/benchmark.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/subprocess.h"
 #include "libc/testlib/testlib.h"
+#include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 
+void SetUpOnce(void) {
+  testlib_enable_tmp_setup_teardown();
+}
+
 TEST(fork, testPipes) {
   int a, b;
   int ws, pid;
@@ -63,32 +73,27 @@ TEST(fork, testSharedMemory) {
   int *sharedvar;
   int *privatevar;
   EXPECT_NE(MAP_FAILED,
-            (sharedvar = mmap(NULL, __granularity(), PROT_READ | PROT_WRITE,
+            (sharedvar = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                               MAP_SHARED | MAP_ANONYMOUS, -1, 0)));
   EXPECT_NE(MAP_FAILED,
-            (privatevar = mmap(NULL, __granularity(), PROT_READ | PROT_WRITE,
+            (privatevar = mmap(0, getpagesize(), PROT_READ | PROT_WRITE,
                                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)));
   stackvar = 1;
   *sharedvar = 1;
   *privatevar = 1;
   EXPECT_NE(-1, (pid = fork()));
   if (!pid) {
-    EXPECT_EQ(NULL, getenv("_FORK"));
     ++stackvar;
-    ++*sharedvar;
     ++*privatevar;
-    msync((void *)ROUNDDOWN((intptr_t)&stackvar, __granularity()),
-          __granularity(), MS_SYNC);
-    EXPECT_NE(-1, msync(privatevar, __granularity(), MS_SYNC));
-    EXPECT_NE(-1, msync(sharedvar, __granularity(), MS_SYNC));
+    ++*sharedvar;
     _exit(0);
   }
   EXPECT_NE(-1, waitpid(pid, &ws, 0));
   EXPECT_EQ(1, stackvar);
   EXPECT_EQ(2, *sharedvar);
   EXPECT_EQ(1, *privatevar);
-  EXPECT_NE(-1, munmap(sharedvar, __granularity()));
-  EXPECT_NE(-1, munmap(privatevar, __granularity()));
+  EXPECT_SYS(0, 0, munmap(sharedvar, getpagesize()));
+  EXPECT_SYS(0, 0, munmap(privatevar, getpagesize()));
 }
 
 static volatile bool gotsigusr1;
@@ -103,8 +108,6 @@ static void OnSigusr2(int sig) {
 }
 
 TEST(fork, childToChild) {
-  if (IsWindows())
-    return;  // :'(
   sigset_t mask, oldmask;
   int ws, parent, child1, child2;
   gotsigusr1 = false;
@@ -118,14 +121,20 @@ TEST(fork, childToChild) {
   sigprocmask(SIG_BLOCK, &mask, &oldmask);
   ASSERT_NE(-1, (child1 = fork()));
   if (!child1) {
-    kill(parent, SIGUSR2);
-    sigsuspend(0);
+    if (kill(parent, SIGUSR2)) {
+      kprintf("%s:%d: error: failed to kill parent: %m\n", __FILE__, __LINE__);
+      _Exit(1);
+    }
+    ASSERT_SYS(EINTR, -1, sigsuspend(0));
     _Exit(!gotsigusr1);
   }
-  sigsuspend(0);
+  EXPECT_SYS(EINTR, -1, sigsuspend(0));
   ASSERT_NE(-1, (child2 = fork()));
   if (!child2) {
-    kill(child1, SIGUSR1);
+    if (kill(child1, SIGUSR1)) {
+      kprintf("%s:%d: error: failed to kill child1: %m\n", __FILE__, __LINE__);
+      _Exit(1);
+    }
     _Exit(0);
   }
   ASSERT_NE(-1, wait(&ws));
@@ -142,16 +151,111 @@ TEST(fork, preservesTlsMemory) {
   EXITS(0);
 }
 
-void ForkInSerial(void) {
+TEST(fork, privateExtraPageData_getsCopiedByFork) {
+  char *p;
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, 1, PROT_WRITE | PROT_READ,
+                                  MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)));
+  p[0] = 1;
+  p[1] = 2;
+  SPAWN(fork);
+  ASSERT_EQ(1, p[0]);
+  ASSERT_EQ(2, p[1]);
+  EXITS(0);
+  ASSERT_SYS(0, 0, munmap(p, 1));
+}
+
+TEST(fork, sharedExtraPageData_getsResurrectedByFork) {
+  char *p;
+  ASSERT_NE(MAP_FAILED, (p = mmap(0, 1, PROT_WRITE | PROT_READ,
+                                  MAP_ANONYMOUS | MAP_SHARED, -1, 0)));
+  p[0] = 1;
+  p[1] = 2;
+  SPAWN(fork);
+  ASSERT_EQ(1, p[0]);
+  ASSERT_EQ(2, p[1]);
+  EXITS(0);
+  ASSERT_SYS(0, 0, munmap(p, 1));
+}
+
+#define CHECK_TERMSIG                                                    \
+  if (WIFSIGNALED(ws)) {                                                 \
+    kprintf("%s:%d: error: forked life subprocess terminated with %G\n", \
+            __FILE__, __LINE__, WTERMSIG(ws));                           \
+    exit(1);                                                             \
+  }
+
+void fork_wait_in_serial(void) {
   int pid, ws;
   ASSERT_NE(-1, (pid = fork()));
   if (!pid)
     _Exit(0);
   ASSERT_NE(-1, waitpid(pid, &ws, 0));
+  CHECK_TERMSIG;
   ASSERT_TRUE(WIFEXITED(ws));
   ASSERT_EQ(0, WEXITSTATUS(ws));
 }
 
-BENCH(fork, bench) {
-  EZBENCH2("fork a", donothing, ForkInSerial());
+void vfork_execl_wait_in_serial(void) {
+  int pid, ws;
+  ASSERT_NE(-1, (pid = vfork()));
+  if (!pid) {
+    execl("./life", "./life", NULL);
+    _Exit(127);
+  }
+  ASSERT_NE(-1, waitpid(pid, &ws, 0));
+  CHECK_TERMSIG;
+  ASSERT_TRUE(WIFEXITED(ws));
+  ASSERT_EQ(42, WEXITSTATUS(ws));
+}
+
+void vfork_wait_in_serial(void) {
+  int pid, ws;
+  ASSERT_NE(-1, (pid = vfork()));
+  if (!pid)
+    _Exit(0);
+  ASSERT_NE(-1, waitpid(pid, &ws, 0));
+  CHECK_TERMSIG;
+  ASSERT_TRUE(WIFEXITED(ws));
+  ASSERT_EQ(0, WEXITSTATUS(ws));
+}
+
+void sys_fork_wait_in_serial(void) {
+  int pid, ws;
+  ASSERT_NE(-1, (pid = sys_fork()));
+  if (!pid)
+    _Exit(0);
+  ASSERT_NE(-1, waitpid(pid, &ws, 0));
+  CHECK_TERMSIG;
+  ASSERT_TRUE(WIFEXITED(ws));
+  ASSERT_EQ(0, WEXITSTATUS(ws));
+}
+
+void posix_spawn_in_serial(void) {
+  int ws, pid;
+  char *prog = "./life";
+  char *args[] = {prog, NULL};
+  char *envs[] = {NULL};
+  ASSERT_EQ(0, posix_spawn(&pid, prog, NULL, NULL, args, envs));
+  ASSERT_NE(-1, waitpid(pid, &ws, 0));
+  CHECK_TERMSIG;
+  ASSERT_TRUE(WIFEXITED(ws));
+  ASSERT_EQ(42, WEXITSTATUS(ws));
+}
+
+TEST(fork, bench) {
+  if (IsWindows()) {
+    testlib_extract("/zip/life-pe.ape", "life", 0755);
+  } else {
+    testlib_extract("/zip/life", "life", 0755);
+  }
+  vfork_wait_in_serial();
+  vfork_execl_wait_in_serial();
+  posix_spawn_in_serial();
+  BENCHMARK(10, 1, vfork_wait_in_serial());
+  if (!IsWindows())
+    BENCHMARK(10, 1, sys_fork_wait_in_serial());
+  fork_wait_in_serial();
+  BENCHMARK(10, 1, fork_wait_in_serial());
+  BENCHMARK(10, 1, posix_spawn_in_serial());
+  BENCHMARK(10, 1, vfork_execl_wait_in_serial());
 }
diff --git a/test/libc/proc/handkill_test.c b/test/libc/proc/handkill_test.c
index 07284b4ee..a669eeb75 100644
--- a/test/libc/proc/handkill_test.c
+++ b/test/libc/proc/handkill_test.c
@@ -125,8 +125,6 @@ TEST(handkill, thread2thread_async) {
 }
 
 TEST(handkill, process_async) {
-  if (IsWindows())
-    return;
   SPAWN(fork);
   shm->ready = true;
   while (!shm->got_signal)
@@ -142,8 +140,6 @@ TEST(handkill, process_async) {
 }
 
 TEST(handkill, process_pause) {
-  if (IsWindows())
-    return;
   SPAWN(fork);
   shm->ready = true;
   pause();
diff --git a/test/libc/proc/life.c b/test/libc/proc/life.c
new file mode 100644
index 000000000..6c67c3b22
--- /dev/null
+++ b/test/libc/proc/life.c
@@ -0,0 +1,3 @@
+int main(int argc, char *argv[]) {
+  return 42;
+}
diff --git a/test/libc/proc/posix_spawn_test.c b/test/libc/proc/posix_spawn_test.c
index e83abb2a8..809fc865d 100644
--- a/test/libc/proc/posix_spawn_test.c
+++ b/test/libc/proc/posix_spawn_test.c
@@ -33,11 +33,11 @@
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
-#include "libc/proc/proc.internal.h"
+#include "libc/proc/proc.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/memtrack.internal.h"
 #include "libc/runtime/runtime.h"
@@ -262,8 +262,6 @@ void EmptySigHandler(int sig) {
 }
 
 TEST(posix_spawn, etxtbsy) {
-  if (IsWindows())
-    return;  // can't deliver signals between processes
   if (IsXnu())
     return;  // they don't appear impacted by this race condition
   if (IsNetbsd())
diff --git a/test/libc/proc/sched_getaffinity_test.c b/test/libc/proc/sched_getaffinity_test.c
index 6e2a7f65d..dad9c1b26 100644
--- a/test/libc/proc/sched_getaffinity_test.c
+++ b/test/libc/proc/sched_getaffinity_test.c
@@ -22,7 +22,7 @@
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/intrin/popcnt.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/proc/posix_spawn.h"
 #include "libc/runtime/runtime.h"
 #include "libc/testlib/subprocess.h"
@@ -30,6 +30,8 @@
 #include "libc/thread/thread.h"
 #include "libc/thread/thread2.h"
 
+int disable_limit_process_to_single_cpu;
+
 void SetUp(void) {
   if (!IsLinux() && !IsFreebsd() && !IsWindows()) {
     exit(0);
@@ -90,7 +92,6 @@ __attribute__((__constructor__)) static void init(void) {
   }
 }
 
-#ifdef __x86_64__
 TEST(sched_setaffinity, isInheritedAcrossExecve) {
   cpu_set_t x;
   CPU_ZERO(&x);
@@ -105,7 +106,6 @@ TEST(sched_setaffinity, isInheritedAcrossExecve) {
   EXPECT_TRUE(WIFEXITED(ws));
   EXPECT_EQ(42, WEXITSTATUS(ws));
 }
-#endif /* __x86_64__ */
 
 TEST(sched_getaffinity, getpid) {
   cpu_set_t x, y;
diff --git a/test/libc/runtime/exit_test.c b/test/libc/runtime/exit_test.c
index 004ecfd89..7acaef336 100644
--- a/test/libc/runtime/exit_test.c
+++ b/test/libc/runtime/exit_test.c
@@ -28,11 +28,11 @@
 int i, *p;
 
 void SetUp(void) {
-  p = _mapshared(__granularity());
+  p = _mapshared(getpagesize());
 }
 
 void TearDown(void) {
-  munmap(p, __granularity());
+  munmap(p, getpagesize());
 }
 
 void AtExit3(void) {
diff --git a/test/libc/runtime/zipos_test.c b/test/libc/runtime/zipos_test.c
index c77614a85..a5fd58742 100644
--- a/test/libc/runtime/zipos_test.c
+++ b/test/libc/runtime/zipos_test.c
@@ -54,12 +54,10 @@ void *Worker(void *arg) {
 TEST(zipos, test) {
   int i, n = 16;
   pthread_t *t = gc(malloc(sizeof(pthread_t) * n));
-  for (i = 0; i < n; ++i) {
+  for (i = 0; i < n; ++i)
     ASSERT_SYS(0, 0, pthread_create(t + i, 0, Worker, 0));
-  }
-  for (i = 0; i < n; ++i) {
+  for (i = 0; i < n; ++i)
     EXPECT_SYS(0, 0, pthread_join(t[i], 0));
-  }
 }
 
 TEST(zipos, erofs) {
@@ -144,7 +142,6 @@ static void *pthread_main(void *ptr) {
   struct State *s = ptr;
   struct State children[2];
   int fd, rc;
-
   fd = s->fd;
   if (s->id < 8) {
     for (int i = 0; i < 2; ++i) {
diff --git a/test/libc/sock/connect_test.c b/test/libc/sock/connect_test.c
index 806961eb0..c7e33f567 100644
--- a/test/libc/sock/connect_test.c
+++ b/test/libc/sock/connect_test.c
@@ -34,6 +34,61 @@
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
 
+TEST(connect, blocking) {
+  char buf[16] = {0};
+  atomic_uint *sem = _mapshared(sizeof(unsigned));
+  uint32_t addrsize = sizeof(struct sockaddr_in);
+  struct sockaddr_in addr = {
+      .sin_family = AF_INET,
+      .sin_addr.s_addr = htonl(0x7f000001),
+  };
+  ASSERT_SYS(0, 3, socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
+  ASSERT_SYS(0, 0, bind(3, (struct sockaddr *)&addr, sizeof(addr)));
+  ASSERT_SYS(0, 0, getsockname(3, (struct sockaddr *)&addr, &addrsize));
+  ASSERT_SYS(0, 0, listen(3, SOMAXCONN));
+
+  SPAWN(fork);
+
+  while (!*sem)
+    pthread_yield();
+  ASSERT_SYS(0, 4, accept(3, (struct sockaddr *)&addr, &addrsize));
+  ASSERT_SYS(0, 2, read(4, buf, 16));  // hi
+  ASSERT_SYS(0, 5, write(4, "hello", 5));
+  ASSERT_SYS(0, 3, read(4, buf, 16));  // bye
+
+  PARENT();
+
+  ASSERT_SYS(0, 0, close(3));
+  ASSERT_SYS(0, 3, socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
+  ASSERT_SYS(0, 0, connect(3, (struct sockaddr *)&addr, sizeof(addr)));
+  *sem = 1;
+  {  // wait until connected
+    struct pollfd pfd = {3, POLLOUT};
+    ASSERT_SYS(0, 1, poll(&pfd, 1, -1));
+    ASSERT_TRUE(!!(POLLOUT & pfd.revents));
+  }
+  struct sockaddr_in peer;
+  uint32_t sz = sizeof(peer);
+  ASSERT_SYS(0, 0, getsockname(3, (struct sockaddr *)&peer, &sz));
+  ASSERT_EQ(htonl(0x7f000001), peer.sin_addr.s_addr);
+  ASSERT_SYS(0, 0, getpeername(3, (struct sockaddr *)&peer, &sz));
+  ASSERT_EQ(htonl(0x7f000001), peer.sin_addr.s_addr);
+  ASSERT_SYS(0, 2, write(3, "hi", 2));
+  {  // wait for other process to send us stuff
+    struct pollfd pfd = {3, POLLIN};
+    ASSERT_SYS(0, 1, poll(&pfd, 1, -1));
+    ASSERT_TRUE(!!(POLLIN & pfd.revents));
+  }
+  ASSERT_SYS(0, 5, read(3, buf, 16));
+  ASSERT_STREQ("hello", buf);
+  ASSERT_SYS(0, 3, write(3, "bye", 3));
+  ASSERT_SYS(0, 0, close(3));
+
+  WAIT(exit, 0);
+
+  munmap(sem, sizeof(unsigned));
+}
+
 TEST(connect, nonblocking) {
   if (IsFreebsd())
     return;  // TODO(jart): why did this start flaking?
@@ -50,23 +105,22 @@ TEST(connect, nonblocking) {
   ASSERT_SYS(0, 0, bind(3, (struct sockaddr *)&addr, sizeof(addr)));
   ASSERT_SYS(0, 0, getsockname(3, (struct sockaddr *)&addr, &addrsize));
   ASSERT_SYS(0, 0, listen(3, SOMAXCONN));
+
   SPAWN(fork);
+
   while (!*sem)
     pthread_yield();
   ASSERT_SYS(0, 4, accept(3, (struct sockaddr *)&addr, &addrsize));
   ASSERT_SYS(0, 2, read(4, buf, 16));  // hi
   ASSERT_SYS(0, 5, write(4, "hello", 5));
   ASSERT_SYS(0, 3, read(4, buf, 16));  // bye
+
   PARENT();
+
   ASSERT_SYS(0, 0, close(3));
   ASSERT_SYS(0, 3, socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP));
   ASSERT_SYS(EINPROGRESS, -1,
              connect(3, (struct sockaddr *)&addr, sizeof(addr)));
-  if (!(IsLinux() || IsNetbsd())) {
-    // this doens't work on rhel7 and netbsd
-    ASSERT_SYS(EALREADY, -1,
-               connect(3, (struct sockaddr *)&addr, sizeof(addr)));
-  }
   ASSERT_SYS(EAGAIN, -1, read(3, buf, 16));
   *sem = 1;
   {  // wait until connected
@@ -74,6 +128,10 @@ TEST(connect, nonblocking) {
     ASSERT_SYS(0, 1, poll(&pfd, 1, -1));
     ASSERT_TRUE(!!(POLLOUT & pfd.revents));
   }
+  struct sockaddr_in peer;
+  uint32_t sz = sizeof(peer);
+  ASSERT_SYS(0, 0, getpeername(3, (struct sockaddr *)&peer, &sz));
+  ASSERT_EQ(htonl(0x7f000001), peer.sin_addr.s_addr);
   ASSERT_SYS(0, 2, write(3, "hi", 2));
   {  // wait for other process to send us stuff
     struct pollfd pfd = {3, POLLIN};
@@ -84,6 +142,8 @@ TEST(connect, nonblocking) {
   ASSERT_STREQ("hello", buf);
   ASSERT_SYS(0, 3, write(3, "bye", 3));
   ASSERT_SYS(0, 0, close(3));
+
   WAIT(exit, 0);
+
   munmap(sem, sizeof(unsigned));
 }
diff --git a/test/libc/sock/inet_pton_test.c b/test/libc/sock/inet_pton_test.c
index ffc44b22e..c6f1dd313 100644
--- a/test/libc/sock/inet_pton_test.c
+++ b/test/libc/sock/inet_pton_test.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/sock/sock.h"
 #include "libc/sysv/consts/af.h"
 #include "libc/sysv/consts/inaddr.h"
diff --git a/test/libc/sock/ipv4v6poll_test.c b/test/libc/sock/ipv4v6poll_test.c
new file mode 100644
index 000000000..7fc6f9ed0
--- /dev/null
+++ b/test/libc/sock/ipv4v6poll_test.c
@@ -0,0 +1,247 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <arpa/inet.h>
+#include <assert.h>
+#include <cosmo.h>
+#include <netinet/in.h>
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/poll.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#define BUFFER_SIZE 1024
+
+// States:
+// 0: Initial state
+// 1: IPv4 listener ready
+// 2: IPv6 listener ready
+// 3: Both listeners ready, main can connect
+// 4: Main connected, IPv4 can send
+// 5: IPv4 sent, IPv6 can send
+// 6: All communication complete
+atomic_int global_state = 0;
+
+typedef struct {
+  int port;
+  int client_sock;
+} listener_data;
+
+void *ipv4_listener(void *arg) {
+  listener_data *data = (listener_data *)arg;
+  int sockfd = socket(AF_INET, SOCK_STREAM, 0);
+  if (sockfd < 0) {
+    perror("IPv4 socket creation failed");
+    exit(EXIT_FAILURE);
+  }
+
+  struct sockaddr_in addr = {0};
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  addr.sin_port = 0;  // Random port
+
+  if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+    perror("IPv4 bind failed");
+    exit(EXIT_FAILURE);
+  }
+
+  socklen_t len = sizeof(addr);
+  if (getsockname(sockfd, (struct sockaddr *)&addr, &len) < 0) {
+    perror("getsockname failed");
+    exit(EXIT_FAILURE);
+  }
+
+  data->port = ntohs(addr.sin_port);
+  // printf("IPv4 listening on port %d\n", data->port);
+
+  if (listen(sockfd, 1) < 0) {
+    perror("IPv4 listen failed");
+    exit(EXIT_FAILURE);
+  }
+
+  // Signal that IPv4 listener is ready
+  atomic_fetch_add(&global_state, 1);
+
+  // Wait for IPv6 to be ready before accepting
+  while (atomic_load(&global_state) < 3) {
+    // Busy wait
+  }
+
+  data->client_sock = accept(sockfd, NULL, NULL);
+  if (data->client_sock < 0) {
+    perror("IPv4 accept failed");
+    exit(EXIT_FAILURE);
+  }
+
+  while (atomic_load(&global_state) < 4) {
+    // Wait for main to signal it's connected
+  }
+
+  const char *message = "Hello from IPv4!";
+  unassert(send(data->client_sock, message, strlen(message), 0) > 0);
+
+  unassert(!close(sockfd));
+  return NULL;
+}
+
+void *ipv6_listener(void *arg) {
+  listener_data *data = (listener_data *)arg;
+  int sockfd = socket(AF_INET6, SOCK_STREAM, 0);
+  if (sockfd < 0) {
+    perror("IPv6 socket creation failed");
+    exit(EXIT_FAILURE);
+  }
+
+  struct sockaddr_in6 addr = {0};
+  addr.sin6_family = AF_INET6;
+  addr.sin6_addr = in6addr_loopback;
+  addr.sin6_port = 0;  // Random port
+
+  if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
+    perror("IPv6 bind failed");
+    exit(EXIT_FAILURE);
+  }
+
+  socklen_t len = sizeof(addr);
+  if (getsockname(sockfd, (struct sockaddr *)&addr, &len) < 0) {
+    perror("getsockname failed");
+    exit(EXIT_FAILURE);
+  }
+
+  data->port = ntohs(addr.sin6_port);
+  // printf("IPv6 listening on port %d\n", data->port);
+
+  if (listen(sockfd, 1) < 0) {
+    perror("IPv6 listen failed");
+    exit(EXIT_FAILURE);
+  }
+
+  // Signal that IPv6 listener is ready and wait for IPv4
+  int expected = 1;
+  while (!atomic_compare_exchange_weak(&global_state, &expected, 3)) {
+    expected = 1;  // Reset expected value if CAS failed
+  }
+
+  data->client_sock = accept(sockfd, NULL, NULL);
+  if (data->client_sock < 0) {
+    perror("IPv6 accept failed");
+    exit(EXIT_FAILURE);
+  }
+
+  while (atomic_load(&global_state) < 5) {
+    // Wait for IPv4 to send its message
+  }
+
+  const char *message = "Hello from IPv6!";
+  unassert(send(data->client_sock, message, strlen(message), 0) > 0);
+
+  unassert(!close(sockfd));
+  return NULL;
+}
+
+int main() {
+  ShowCrashReports();
+
+  pthread_t ipv4_thread, ipv6_thread;
+  listener_data ipv4_data = {0}, ipv6_data = {0};
+
+  if (pthread_create(&ipv4_thread, NULL, ipv4_listener, &ipv4_data) != 0) {
+    perror("Failed to create IPv4 thread");
+    exit(EXIT_FAILURE);
+  }
+
+  if (pthread_create(&ipv6_thread, NULL, ipv6_listener, &ipv6_data) != 0) {
+    perror("Failed to create IPv6 thread");
+    exit(EXIT_FAILURE);
+  }
+
+  // Wait for both listeners to be ready
+  while (atomic_load(&global_state) < 3) {
+    // Busy wait
+  }
+
+  int ipv4_sock = socket(AF_INET, SOCK_STREAM, 0);
+  int ipv6_sock = socket(AF_INET6, SOCK_STREAM, 0);
+
+  struct sockaddr_in ipv4_addr = {0};
+  ipv4_addr.sin_family = AF_INET;
+  ipv4_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  ipv4_addr.sin_port = htons(ipv4_data.port);
+
+  struct sockaddr_in6 ipv6_addr = {0};
+  ipv6_addr.sin6_family = AF_INET6;
+  ipv6_addr.sin6_addr = in6addr_loopback;
+  ipv6_addr.sin6_port = htons(ipv6_data.port);
+
+  if (connect(ipv4_sock, (struct sockaddr *)&ipv4_addr, sizeof(ipv4_addr)) <
+      0) {
+    perror("IPv4 connect failed");
+    exit(EXIT_FAILURE);
+  }
+
+  if (connect(ipv6_sock, (struct sockaddr *)&ipv6_addr, sizeof(ipv6_addr)) <
+      0) {
+    perror("IPv6 connect failed");
+    exit(EXIT_FAILURE);
+  }
+
+  // Signal that main thread is connected
+  atomic_store(&global_state, 4);
+
+  struct pollfd fds[2];
+  fds[0].fd = ipv4_sock;
+  fds[0].events = POLLIN;
+  fds[1].fd = ipv6_sock;
+  fds[1].events = POLLIN;
+
+  char buffer[BUFFER_SIZE];
+
+  while (atomic_load(&global_state) < 6) {
+    if (poll(fds, 2, -1) > 0) {
+      if (fds[0].revents & POLLIN) {
+        ssize_t n = recv(ipv4_sock, buffer, BUFFER_SIZE - 1, 0);
+        unassert(n != -1);
+        buffer[n] = '\0';
+        // printf("Received from IPv4: %s\n", buffer);
+        unassert(atomic_load(&global_state) == 4);
+        atomic_store(&global_state, 5);
+      }
+      if (fds[1].revents & POLLIN) {
+        ssize_t n = recv(ipv6_sock, buffer, BUFFER_SIZE - 1, 0);
+        unassert(n != -1);
+        buffer[n] = '\0';
+        // printf("Received from IPv6: %s\n", buffer);
+        unassert(atomic_load(&global_state) == 5);
+        atomic_store(&global_state, 6);
+      }
+    }
+  }
+
+  unassert(!close(ipv4_sock));
+  unassert(!close(ipv6_sock));
+
+  unassert(!pthread_join(ipv4_thread, NULL));
+  unassert(!pthread_join(ipv6_thread, NULL));
+
+  CheckForMemoryLeaks();
+  return 0;
+}
diff --git a/test/libc/sock/nonblock_test.c b/test/libc/sock/nonblock_test.c
index 3d3259d47..e27281ce1 100644
--- a/test/libc/sock/nonblock_test.c
+++ b/test/libc/sock/nonblock_test.c
@@ -20,7 +20,7 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/syslib.internal.h"
 #include "libc/sock/sock.h"
@@ -37,9 +37,6 @@
 #include "libc/thread/thread.h"
 
 TEST(O_NONBLOCK, canBeSetBySocket_toMakeListenNonBlocking) {
-  // TODO(jart): this doesn't make any sense on windows
-  if (IsWindows())
-    return;
   char buf[16] = {0};
   uint32_t addrsize = sizeof(struct sockaddr_in);
   struct sockaddr_in addr = {
diff --git a/test/libc/sock/recvfrom_test.c b/test/libc/sock/recvfrom_test.c
index 4ef3c7a11..a662d914d 100644
--- a/test/libc/sock/recvfrom_test.c
+++ b/test/libc/sock/recvfrom_test.c
@@ -33,8 +33,6 @@
 // two clients send a udp packet containing their local address
 // server verifies content of packet matches the peer's address
 TEST(recvfrom, test) {
-  if (!IsWindows())
-    return;
   uint32_t addrsize = sizeof(struct sockaddr_in);
   struct sockaddr_in server = {
       .sin_family = AF_INET,
diff --git a/test/libc/sock/sendfile_test.c b/test/libc/sock/sendfile_test.c
index c63e2cb1c..2254b1529 100644
--- a/test/libc/sock/sendfile_test.c
+++ b/test/libc/sock/sendfile_test.c
@@ -41,9 +41,9 @@
 
 void SetUpOnce(void) {
   if (IsNetbsd())
-    exit(0);
+    exit(0);  // no sendfile support
   if (IsOpenbsd())
-    exit(0);
+    exit(0);  // no sendfile support
   testlib_enable_tmp_setup_teardown();
   ASSERT_SYS(0, 0, pledge("stdio rpath wpath cpath proc inet", 0));
 }
@@ -102,9 +102,6 @@ TEST(sendfile, testSeeking) {
 }
 
 TEST(sendfile, testPositioning) {
-  // TODO(jart): fix test regression on windows
-  if (IsWindows())
-    return;
   char buf[1024];
   uint32_t addrsize = sizeof(struct sockaddr_in);
   struct sockaddr_in addr = {
@@ -130,9 +127,8 @@ TEST(sendfile, testPositioning) {
     ASSERT_TRUE(errno == EINVAL || errno == EPIPE);
     errno = 0;
     // XXX: WSL1 clobbers file offset on failure!
-    if (!__iswsl1()) {
+    if (!__iswsl1())
       ASSERT_EQ(12, GetFileOffset(5));
-    }
     _Exit(0);
   }
   ASSERT_SYS(0, 0, close(3));
diff --git a/test/libc/sock/socket_test.c b/test/libc/sock/socket_test.c
index b3a5e1d32..ff161888c 100644
--- a/test/libc/sock/socket_test.c
+++ b/test/libc/sock/socket_test.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/internal.h"
-#include "libc/calls/struct/fd.internal.h"
 #include "libc/dce.h"
+#include "libc/intrin/fds.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/nt/winsock.h"
 #include "libc/runtime/runtime.h"
@@ -141,8 +141,6 @@ TEST(socket, canBeInheritedByForkedWorker) {
   WAIT(exit, 0);
 }
 
-#ifdef __x86_64__
-
 __attribute__((__constructor__)) static void StdioPro(int argc, char *argv[]) {
   if (argc >= 2 && !strcmp(argv[1], "StdioProg")) {
     ASSERT_EQ(NULL, getenv("__STDIO_SOCKETS"));
@@ -184,5 +182,3 @@ TEST(socket, canBeUsedAsExecutedStdio) {
   EXPECT_SYS(0, 0, close(3));
   WAIT(exit, 0);
 }
-
-#endif /* __x86_64__ */
diff --git a/test/libc/stdio/BUILD.mk b/test/libc/stdio/BUILD.mk
index f40be5396..3cc6f6d5f 100644
--- a/test/libc/stdio/BUILD.mk
+++ b/test/libc/stdio/BUILD.mk
@@ -28,25 +28,27 @@ TEST_LIBC_STDIO_DIRECTDEPS =					\
 	LIBC_CALLS						\
 	LIBC_FMT						\
 	LIBC_INTRIN						\
+	LIBC_LOG						\
 	LIBC_MEM						\
 	LIBC_NEXGEN32E						\
 	LIBC_PROC						\
 	LIBC_RUNTIME						\
 	LIBC_STDIO						\
 	LIBC_STR						\
+	LIBC_SYSTEM						\
 	LIBC_SYSV						\
-	LIBC_TINYMATH						\
 	LIBC_TESTLIB						\
 	LIBC_THREAD						\
-	LIBC_LOG						\
+	LIBC_TINYMATH						\
 	LIBC_X							\
+	THIRD_PARTY_COMPILER_RT					\
 	THIRD_PARTY_GDTOA					\
 	THIRD_PARTY_MBEDTLS					\
 	THIRD_PARTY_MUSL					\
 	THIRD_PARTY_NSYNC					\
+	THIRD_PARTY_TZ						\
 	THIRD_PARTY_ZLIB					\
 	THIRD_PARTY_ZLIB_GZ					\
-	THIRD_PARTY_TZ
 
 TEST_LIBC_STDIO_DEPS :=						\
 	$(call uniq,$(foreach x,$(TEST_LIBC_STDIO_DIRECTDEPS),$($(x))))
@@ -65,16 +67,6 @@ o/$(MODE)/test/libc/stdio/%.dbg:				\
 		$(APE_NO_MODIFY_SELF)
 	@$(APELINK)
 
-o/$(MODE)/test/libc/stdio/popen_test.dbg:			\
-		$(TEST_LIBC_STDIO_DEPS)				\
-		o/$(MODE)/test/libc/stdio/popen_test.o		\
-		o/$(MODE)/test/libc/stdio/stdio.pkg		\
-		o/$(MODE)/tool/build/echo.zip.o			\
-		$(LIBC_TESTMAIN)				\
-		$(CRT)						\
-		$(APE_NO_MODIFY_SELF)
-	@$(APELINK)
-
 $(TEST_LIBC_STDIO_OBJS): private				\
 		DEFAULT_CCFLAGS +=				\
 			-fno-builtin
diff --git a/test/libc/stdio/dtoa_test.c b/test/libc/stdio/dtoa_test.c
index 738dbc841..7929d3daf 100644
--- a/test/libc/stdio/dtoa_test.c
+++ b/test/libc/stdio/dtoa_test.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sched_param.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
diff --git a/test/libc/stdio/ecvt_test.c b/test/libc/stdio/ecvt_test.c
index 2813d8d3c..8806896bb 100644
--- a/test/libc/stdio/ecvt_test.c
+++ b/test/libc/stdio/ecvt_test.c
@@ -31,3 +31,38 @@ TEST(fcvt, test) {
   ASSERT_EQ(1, decpt);
   ASSERT_EQ(0, sign);
 }
+
+TEST(ecvt, minus0) {
+  int decpt = 110000000, sign = 110000000;
+
+  ASSERT_STREQ("00000", ecvt(-0.0, 5, &decpt, &sign));
+  ASSERT_LE(0, decpt);
+  ASSERT_GE(1, decpt);
+  ASSERT_EQ(1, sign);
+}
+
+TEST(ecvt, minus0ndigits0) {
+  int decpt = 110000000, sign = 110000000;
+
+  ASSERT_STREQ("", ecvt(-0.0, 0, &decpt, &sign));
+  ASSERT_LE(0, decpt);
+  ASSERT_GE(1, decpt);
+  ASSERT_EQ(1, sign);
+}
+
+TEST(fcvt, ndigits0) {
+  int decpt = 110000000, sign = 110000000;
+
+  ASSERT_STREQ("1", fcvt(0.6, 0, &decpt, &sign));
+  ASSERT_EQ(1, decpt);
+  ASSERT_EQ(0, sign);
+}
+
+TEST(fcvt, minus0ndigits0) {
+  int decpt = 110000000, sign = 110000000;
+
+  ASSERT_STREQ("", fcvt(-0.0, 0, &decpt, &sign));
+  ASSERT_LE(0, decpt);
+  ASSERT_GE(1, decpt);
+  ASSERT_EQ(1, sign);
+}
diff --git a/test/libc/stdio/fgetwc_test.c b/test/libc/stdio/fgetwc_test.c
index e7a55ceff..4f6bd7ccd 100644
--- a/test/libc/stdio/fgetwc_test.c
+++ b/test/libc/stdio/fgetwc_test.c
@@ -16,7 +16,9 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdio/stdio.h"
+#include "libc/intrin/weaken.h"
+#include "libc/mem/mem.h"
+#include "libc/stdio/internal.h"
 #include "libc/testlib/testlib.h"
 
 TEST(fgetwc, testAscii_oneChar) {
diff --git a/test/libc/stdio/fmt_test.c b/test/libc/stdio/fmt_test.c
index 026ff761d..afb317259 100644
--- a/test/libc/stdio/fmt_test.c
+++ b/test/libc/stdio/fmt_test.c
@@ -20,6 +20,7 @@
 #include "libc/log/log.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
+#include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/testlib/testlib.h"
 #include "libc/x/xasprintf.h"
@@ -431,3 +432,10 @@ TEST(fmt, regress) {
       "User-Agent: hurl/1.o (https://github.com/jart/cosmopolitan)\r\n",
       buf);
 }
+
+TEST(fmt, n) {
+  int n;
+  char buf[8];
+  snprintf(buf, 8, ".%c%c.%n", 0, 1, &n);
+  ASSERT_EQ(4, n);
+}
diff --git a/test/libc/stdio/fputc_test.c b/test/libc/stdio/fputc_test.c
index 6520e77bb..b63ecc1c3 100644
--- a/test/libc/stdio/fputc_test.c
+++ b/test/libc/stdio/fputc_test.c
@@ -33,9 +33,13 @@ void SetUpOnce(void) {
 TEST(fputc, test) {
   ASSERT_NE(NULL, (f = fopen("hog", "w+")));
   EXPECT_EQ('h', fputc('h', f));
+  EXPECT_FALSE(feof(f));
   EXPECT_EQ(0xFF, fputc(-1, f));
+  EXPECT_FALSE(feof(f));
   EXPECT_NE(-1, fseek(f, 0, SEEK_SET));
+  EXPECT_FALSE(feof(f));
   EXPECT_EQ('h', fgetc(f));
+  EXPECT_FALSE(feof(f));
   EXPECT_EQ(0, fread(NULL, 0, 0, f));
   EXPECT_FALSE(feof(f));
   EXPECT_EQ(0xFF, fgetc(f));
diff --git a/test/libc/stdio/fread_test.c b/test/libc/stdio/fread_test.c
index 8e5e690e5..2fc4f00a5 100644
--- a/test/libc/stdio/fread_test.c
+++ b/test/libc/stdio/fread_test.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/errno.h"
 #include "libc/stdio/stdio.h"
 #include "libc/testlib/testlib.h"
 
@@ -45,7 +46,7 @@ TEST(fread, eofIsSticky) {
 }
 
 TEST(fread, seekWithBuffer) {
-  FILE *f;
+  FILE* f;
   char b[8] = "hellosup";
   char c[8] = {0};
   char d[8] = {0};
@@ -60,3 +61,31 @@ TEST(fread, seekWithBuffer) {
   ASSERT_STREQ("ellos", d);
   ASSERT_EQ(0, fclose(f));
 }
+
+TEST(fread, zero) {
+  FILE* f;
+  char buf[8] = {0};
+  ASSERT_NE(NULL, (f = fopen("foo", "w")));
+  ASSERT_EQ(2, fwrite("hi", 1, 2, f));
+  ASSERT_EQ(0, fclose(f));
+  ASSERT_NE(NULL, (f = fopen("foo", "r")));
+  ASSERT_EQ(0, fread(buf, 0, 0, f));
+  ASSERT_EQ(0, ferror(stdin));
+  ASSERT_EQ(0, feof(stdin));
+  ASSERT_STREQ("", buf);
+  ASSERT_EQ(0, fclose(f));
+}
+
+TEST(fread, partial) {
+  FILE* f;
+  char buf[8] = {0};
+  ASSERT_NE(NULL, (f = fopen("foo", "w")));
+  ASSERT_EQ(2, fwrite("hi", 1, 2, f));
+  ASSERT_EQ(0, fclose(f));
+  ASSERT_NE(NULL, (f = fopen("foo", "r")));
+  ASSERT_EQ(0, fread(buf, 8, 1, f));
+  ASSERT_EQ(0, ferror(stdin));
+  ASSERT_EQ(0, feof(stdin));
+  ASSERT_EQ(0, fclose(f));
+  ASSERT_STREQ("hi", buf);
+}
diff --git a/test/libc/stdio/fscanf_test.c b/test/libc/stdio/fscanf_test.c
index accfb4bdb..74005f3f4 100644
--- a/test/libc/stdio/fscanf_test.c
+++ b/test/libc/stdio/fscanf_test.c
@@ -27,7 +27,7 @@ TEST(fscanf, test_readAfterFloat) {
   EXPECT_EQ(4, fscanf(f, "%f%x%f%x", &f1, &i1, &f2, &i2));
   EXPECT_TRUE(isinf(f1));
   EXPECT_EQ(0xDEAD, i1);
-  EXPECT_EQ(-0.125e-2f, f2);
+  EXPECT_FLOAT_EXACTLY_EQ(-0.125e-2f, f2);
   EXPECT_EQ(0xBEEF, i2);
   fclose(f);
 }
diff --git a/test/libc/stdio/getentropy_test.c b/test/libc/stdio/getentropy_test.c
index 532e6b098..f6d1acdc8 100644
--- a/test/libc/stdio/getentropy_test.c
+++ b/test/libc/stdio/getentropy_test.c
@@ -22,19 +22,17 @@
 #include "libc/calls/struct/sigset.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
 #ifndef __aarch64__
-// TODO(jart): Make this test less resource intensive.
-// TODO(jart): Why can EINTR happen on Windows?
 
 atomic_int done;
 atomic_int ready;
@@ -51,11 +49,9 @@ void *TortureWorker(void *arg) {
   ASSERT_SYS(0, 0, sigprocmask(SIG_SETMASK, &ss, 0));
   ready = true;
   while (!done) {
-    if (!IsWindows())
-      pthread_kill(parent, SIGUSR1);
+    pthread_kill(parent, SIGUSR1);
     usleep(1);
-    if (!IsWindows())
-      pthread_kill(parent, SIGUSR2);
+    pthread_kill(parent, SIGUSR2);
     usleep(1);
   }
   return 0;
@@ -100,8 +96,7 @@ TEST(getentropy, test) {
   }
   done = true;
   ASSERT_EQ(0, pthread_join(child, 0));
-  if (!IsWindows())
-    ASSERT_GT(gotsome, 0);
+  ASSERT_GT(gotsome, 0);
 }
 
 #endif /* __aarch64__ */
diff --git a/test/libc/stdio/lemur64_test.c b/test/libc/stdio/lemur64_test.c
new file mode 100644
index 000000000..f17700398
--- /dev/null
+++ b/test/libc/stdio/lemur64_test.c
@@ -0,0 +1,49 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/stdio/rand.h"
+#include "libc/testlib/benchmark.h"
+#include "libc/testlib/testlib.h"
+
+uint64_t getrandom64(void) {
+  uint64_t x;
+  unassert(getrandom(&x, 8, 0) == 8);
+  return x;
+}
+
+uint64_t getentropy64(void) {
+  uint64_t x;
+  unassert(!getentropy(&x, 8));
+  return x;
+}
+
+TEST(lemur64, test) {
+  EXPECT_EQ(1819718037028923529, lemur64());
+  EXPECT_EQ(-3120132252617434764, lemur64());
+}
+
+BENCH(lemur64, bench) {
+  BENCHMARK(10000, 8, X(lemur64()));
+  BENCHMARK(10000, 4, X(rand()));
+  BENCHMARK(10000, 8, X(_rand64()));
+  BENCHMARK(10000, 8, X(rdrand()));
+  BENCHMARK(10000, 8, X(rdseed()));
+  BENCHMARK(10000, 8, X(getrandom64()));
+  BENCHMARK(10000, 8, X(getentropy64()));
+}
diff --git a/test/libc/stdio/mt19937_test.c b/test/libc/stdio/mt19937_test.c
index 1da2588a9..17de8f5ec 100644
--- a/test/libc/stdio/mt19937_test.c
+++ b/test/libc/stdio/mt19937_test.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/test/libc/stdio/palandprintf_test.c b/test/libc/stdio/palandprintf_test.c
index 9a67f6732..a9486703e 100644
--- a/test/libc/stdio/palandprintf_test.c
+++ b/test/libc/stdio/palandprintf_test.c
@@ -26,8 +26,8 @@
 └─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/pushpop.internal.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/pushpop.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
diff --git a/test/libc/stdio/snprintf_enomem_test.c b/test/libc/stdio/snprintf_enomem_test.c
new file mode 100644
index 000000000..57e305487
--- /dev/null
+++ b/test/libc/stdio/snprintf_enomem_test.c
@@ -0,0 +1,61 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Gabriel Ravier                                                │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/rlimit.h"
+#include "libc/errno.h"
+#include "libc/stdio/stdio.h"
+#include "libc/sysv/consts/rlim.h"
+#include "libc/sysv/consts/rlimit.h"
+#include "libc/testlib/testlib.h"
+
+static void limit_memory_to_1mb() {
+  struct rlimit limit = {};
+  ASSERT_GE(getrlimit(RLIMIT_AS, &limit), 0);
+
+  if (limit.rlim_max > 1000000 || limit.rlim_max == RLIM_INFINITY) {
+    limit.rlim_max = 1000000;
+    limit.rlim_cur = limit.rlim_max;
+    ASSERT_GE(setrlimit(RLIMIT_AS, &limit), 0);
+  }
+}
+
+static void check_double_format_enomem(const char *fmt) {
+  errno = 0;
+  int result = printf(fmt, 1.0);
+  ASSERT_LE(result, 0);
+  ASSERT_EQ(errno, ENOMEM);
+}
+
+static void check_long_double_format_enomem(const char *fmt) {
+  errno = 0;
+  int result = printf(fmt, 1.0L);
+  ASSERT_LE(result, 0);
+  ASSERT_EQ(errno, ENOMEM);
+}
+
+TEST(snprintf, enomemFloat) {
+  limit_memory_to_1mb();
+
+  check_double_format_enomem("%.1000000f");
+  check_double_format_enomem("%.1000000g");
+  check_double_format_enomem("%.1000000e");
+
+  check_long_double_format_enomem("%.1000000Lf");
+  check_long_double_format_enomem("%.1000000Lg");
+  check_long_double_format_enomem("%.1000000Le");
+}
diff --git a/test/libc/stdio/snprintf_test.c b/test/libc/stdio/snprintf_test.c
index 63a702bf2..0fb38489e 100644
--- a/test/libc/stdio/snprintf_test.c
+++ b/test/libc/stdio/snprintf_test.c
@@ -16,14 +16,268 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/runtime/fenv.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/testlib/testlib.h"
 
+static void check_single_double(const char *fmt, const char *expected_str,
+                                double value) {
+  char buf[30] = {0};
+  int i = snprintf(buf, sizeof(buf), fmt, value);
+
+  ASSERT_GE(sizeof(buf), strlen(expected_str));
+  ASSERT_EQ(strlen(expected_str), i);
+  ASSERT_STREQ(expected_str, buf);
+  while (i < sizeof(buf))
+    ASSERT_EQ('\0', buf[i++]);
+}
+
+static void check_single_long_double(const char *fmt, const char *expected_str,
+                                     long double value) {
+  char buf[30] = {0};
+  int i = snprintf(buf, sizeof(buf), fmt, value);
+
+  ASSERT_GE(sizeof(buf), strlen(expected_str));
+  ASSERT_EQ(strlen(expected_str), i);
+  ASSERT_STREQ(expected_str, buf);
+  while (i < sizeof(buf))
+    ASSERT_EQ('\0', buf[i++]);
+}
+
+void check_single_long_double_arr_allowed(
+    const char *fmt, const char *allowed_strs[], long double value) {
+  char buf[30] = {0};
+  int res = snprintf(buf, sizeof(buf), fmt, value);
+
+  for (size_t i = 0; allowed_strs[i] != NULL; ++i)
+    if (strlen(allowed_strs[i]) == res && strcmp(allowed_strs[i], buf) == 0)
+      return;
+
+  printf("Failed to find matching str for %`'s, allowed strs:\n", buf);
+  for (size_t i = 0; allowed_strs[i] != NULL; ++i)
+    printf("- %`'s\n", allowed_strs[i]);
+  fflush(stdout);
+  ASSERT_EQ(false, true);
+}
+
+static void check_single_int(const char *fmt, const char *expected_str,
+                             int value) {
+  char buf[30] = {0};
+  int i = snprintf(buf, sizeof(buf), fmt, value);
+
+  ASSERT_GE(sizeof(buf), strlen(expected_str));
+  ASSERT_EQ(strlen(expected_str), i);
+  ASSERT_STREQ(expected_str, buf);
+  while (i < sizeof(buf))
+    ASSERT_EQ('\0', buf[i++]);
+}
+
+static void check_single_wint_t(const char *fmt, const char *expected_str,
+                                wint_t value) {
+  char buf[30] = {0};
+  int i = snprintf(buf, sizeof(buf), fmt, value);
+
+  ASSERT_GE(sizeof(buf), strlen(expected_str));
+  ASSERT_EQ(strlen(expected_str), i);
+  ASSERT_STREQ(expected_str, buf);
+  while (i < sizeof(buf))
+    ASSERT_EQ('\0', buf[i++]);
+}
+
 TEST(snprintf, testVeryLargePrecision) {
   char buf[512] = {};
   int i = snprintf(buf, sizeof(buf), "%.9999u", 10);
 
-  ASSERT_EQ(i, 9999);
-  ASSERT_EQ(strlen(buf), 511);
+  ASSERT_EQ(9999, i);
+  ASSERT_EQ(511, strlen(buf));
+}
+
+TEST(snprintf, testPlusFlagOnChar) {
+  check_single_int("%+c", "=", '=');
+}
+
+TEST(snprintf, testInf) {
+  check_single_double("%f", "inf", 1.0 / 0.0);
+  check_single_long_double("%Lf", "inf", 1.0L / 0.0L);
+  check_single_double("%e", "inf", 1.0 / 0.0);
+  check_single_long_double("%Le", "inf", 1.0L / 0.0L);
+  check_single_double("%g", "inf", 1.0 / 0.0);
+  check_single_long_double("%Lg", "inf", 1.0L / 0.0L);
+}
+
+TEST(snprintf, testUppercaseCConversionSpecifier) {
+  check_single_wint_t("%C", "a", L'a');
+  check_single_wint_t("%C", "☺", L'☺');
+}
+
+// Make sure we don't va_arg the wrong argument size on wide character
+// conversion specifiers
+TEST(snprintf,
+     testWideCConversionSpecifierWithLotsOfArgumentsBeforeAndOneAfter) {
+  char buf[20] = {};
+  int i = snprintf(buf, sizeof(buf), "%d%d%d%d%d%d%d%d%lc%d", 0, 0, 0, 0, 0, 0,
+                   0, 0, L'x', 1);
+
+  ASSERT_EQ(10, i);
+  ASSERT_STREQ("00000000x1", buf);
+
+  memset(buf, 0, sizeof(buf));
+  i = snprintf(buf, sizeof(buf), "%d%d%d%d%d%d%d%d%C%d", 0, 0, 0, 0, 0, 0, 0, 0,
+               L'x', 1);
+  ASSERT_EQ(10, i);
+  ASSERT_STREQ("00000000x1", buf);
+}
+
+static void check_n_buffer_contents(char buf[350]) {
+  for (int i = 0; i < 284; ++i)
+    ASSERT_EQ(' ', buf[i]);
+  ASSERT_STREQ("428463", &buf[284]);
+  for (int i = 290; i < 350; ++i)
+    ASSERT_EQ('\0', buf[i]);
+}
+
+TEST(snprintf, testNConversionSpecifier) {
+  char buf[350] = {};
+
+  int n_res_int = -1;
+  int i = snprintf(buf, sizeof(buf), "%286d%d%n%d", 42, 84, &n_res_int, 63);
+  ASSERT_EQ(290, i);
+  check_n_buffer_contents(buf);
+  ASSERT_EQ(288, n_res_int);
+
+  memset(&buf, '\0', sizeof(buf));
+  long n_res_long = -1;
+  i = snprintf(buf, sizeof(buf), "%286ld%ld%ln%ld", 42L, 84L, &n_res_long, 63L);
+  ASSERT_EQ(290, i);
+  check_n_buffer_contents(buf);
+  ASSERT_EQ(288, n_res_long);
+
+  memset(&buf, '\0', sizeof(buf));
+  long long n_res_long_long = -1;
+  i = snprintf(buf, sizeof(buf), "%286lld%lld%lln%lld", 42LL, 84LL,
+               &n_res_long_long, 63LL);
+  ASSERT_EQ(290, i);
+  check_n_buffer_contents(buf);
+  ASSERT_EQ(288, n_res_long_long);
+
+  ASSERT_EQ(sizeof(short), 2);
+  ASSERT_EQ(sizeof(int), 4);
+  memset(&buf, '\0', sizeof(buf));
+  short n_res_short = -1;
+  i = snprintf(buf, sizeof(buf), "%286hd%hd%hn%hd", (42 | 0xFFFF0000),
+               (84 | 0xFFFF0000), &n_res_short, (63 | 0xFFFF0000));
+  ASSERT_EQ(290, i);
+  check_n_buffer_contents(buf);
+  ASSERT_EQ(288, n_res_short);
+
+  ASSERT_EQ(sizeof(unsigned char), 1);
+  memset(&buf, '\0', sizeof(buf));
+  signed char n_res_char = -1;
+  i = snprintf(buf, sizeof(buf), "%286hhd%hhd%hhn%hhd", (42 | 0xFFFFFF00),
+               (84 | 0xFFFFFF00), &n_res_char, (63 | 0xFFFFFF00));
+  ASSERT_EQ(290, i);
+  check_n_buffer_contents(buf);
+  ASSERT_EQ((signed char)288, n_res_char);
+
+  memset(&buf, '\0', sizeof(buf));
+  ssize_t n_res_size_t = -1;
+  i = snprintf(buf, sizeof(buf), "%286zd%zd%zn%zd", (ssize_t)42, (ssize_t)84,
+               &n_res_size_t, (ssize_t)63);
+  ASSERT_EQ(290, i);
+  check_n_buffer_contents(buf);
+  ASSERT_EQ(288, n_res_size_t);
+
+  memset(&buf, '\0', sizeof(buf));
+  intmax_t n_res_intmax_t = -1;
+  i = snprintf(buf, sizeof(buf), "%286jd%jd%jn%jd", (intmax_t)42, (intmax_t)84,
+               &n_res_intmax_t, (intmax_t)63);
+  ASSERT_EQ(290, i);
+  check_n_buffer_contents(buf);
+  ASSERT_EQ(288, n_res_intmax_t);
+
+  memset(&buf, '\0', sizeof(buf));
+  int128_t n_res_int128_t = -1;
+  i = snprintf(buf, sizeof(buf), "%286jjd%jjd%jjn%jjd", (int128_t)42,
+               (int128_t)84, &n_res_int128_t, (int128_t)63);
+  ASSERT_EQ(290, i);
+  check_n_buffer_contents(buf);
+  ASSERT_EQ(288, n_res_int128_t);
+
+  memset(&buf, '\0', sizeof(buf));
+  ptrdiff_t n_res_ptrdiff_t = -1;
+  i = snprintf(buf, sizeof(buf), "%286td%td%tn%td", (ptrdiff_t)42,
+               (ptrdiff_t)84, &n_res_ptrdiff_t, (ptrdiff_t)63);
+  ASSERT_EQ(290, i);
+  check_n_buffer_contents(buf);
+  ASSERT_EQ(288, n_res_ptrdiff_t);
+}
+
+TEST(snprintf, testLongDoubleEConversionSpecifier) {
+  check_single_long_double("%Le", "1.234568e+06", 1234567.8L);
+}
+
+TEST(snprintf, testLongDoubleRounding) {
+  int previous_rounding = fegetround();
+  ASSERT_EQ(0, fesetround(FE_DOWNWARD));
+
+  check_single_long_double("%.3Lf", "4.437", 4.4375L);
+  check_single_long_double("%.3Lf", "-4.438", -4.4375L);
+
+  ASSERT_EQ(0, fesetround(FE_TOWARDZERO));
+
+  check_single_long_double("%.3Lf", "-4.437", -4.4375L);
+
+  ASSERT_EQ(0, fesetround(previous_rounding));
+}
+
+void check_a_conversion_specifier_double_prec_1(const char *expected_str,
+                                                double value) {
+  check_single_double("%.1a", expected_str, value);
+}
+
+TEST(snprintf, testAConversionSpecifierRounding) {
+  int previous_rounding = fegetround();
+
+  ASSERT_EQ(0, fesetround(FE_DOWNWARD));
+  check_a_conversion_specifier_double_prec_1("0x1.fp+4", 0x1.fffffp+4);
+
+  ASSERT_EQ(0, fesetround(FE_UPWARD));
+  check_a_conversion_specifier_double_prec_1("0x2.0p+4", 0x1.f8p+4);
+
+  ASSERT_EQ(0, fesetround(previous_rounding));
+}
+
+// This test specifically checks that we round to even, accordingly to IEEE
+// rules
+TEST(snprintf, testAConversionSpecifier) {
+  check_a_conversion_specifier_double_prec_1("0x1.8p+4", 0x1.7800000000001p+4);
+  check_a_conversion_specifier_double_prec_1("0x1.8p+4", 0x1.78p+4);
+  check_a_conversion_specifier_double_prec_1("0x1.8p+4", 0x1.88p+4);
+  check_a_conversion_specifier_double_prec_1("0x1.6p+4", 0x1.58p+4);
+  check_a_conversion_specifier_double_prec_1("0x1.6p+4", 0x1.68p+4);
+  check_a_conversion_specifier_double_prec_1("0x1.ap+4", 0x1.98p+4);
+  check_a_conversion_specifier_double_prec_1("0x1.ap+4", 0x1.a8p+4);
+
+  check_single_double("%#a", "0x0.p+0", 0x0.0p0);
+  check_single_double("%#A", "0X0.P+0", 0x0.0p0);
+  check_single_long_double("%#La", "0x0.p+0", 0x0.0p0L);
+  check_single_long_double("%#LA", "0X0.P+0", 0x0.0p0L);
+
+  check_single_double("%.2a", "0x1.00p-1026", 0xf.fffp-1030);
+
+  check_single_double("%.1a", "0x2.0p+0", 1.999);
+  const char *acceptable_results1[] = {"0x1.0p+1", "0x2.0p+0", NULL};
+  check_single_long_double_arr_allowed(
+      "%.1La", acceptable_results1, 1.999L);
+}
+
+TEST(snprintf, testApostropheFlag) {
+  check_single_int("%'d", "10000000", 10000000);
+}
+
+TEST(snprintf, testUppercaseBConversionSpecifier) {
+  check_single_int("%B", "0", 0);
+  check_single_int("%B", "10", 2);
+  check_single_int("%#B", "0B10011", 19);
 }
diff --git a/test/libc/stdio/sprintf_s_test.c b/test/libc/stdio/sprintf_s_test.c
index 2d38cd53f..a6a448684 100644
--- a/test/libc/stdio/sprintf_s_test.c
+++ b/test/libc/stdio/sprintf_s_test.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/gc.h"
 #include "libc/testlib/testlib.h"
 #include "libc/x/x.h"
diff --git a/test/libc/stdio/sscanf_test.c b/test/libc/stdio/sscanf_test.c
index 40e35f1c4..c134fa265 100644
--- a/test/libc/stdio/sscanf_test.c
+++ b/test/libc/stdio/sscanf_test.c
@@ -338,17 +338,17 @@ TEST(sscanf, flexdecimal_hex) {
 TEST(sscanf, floating_point_simple) {
   float x = 666.666f, y = x, z = y;
   EXPECT_EQ(3, sscanf("0.3715 .3715 3715", "%f %f %f", &x, &y, &z));
-  EXPECT_EQ(0.3715f, x);
-  EXPECT_EQ(0.3715f, y);
-  EXPECT_EQ(3715.0f, z);
+  EXPECT_FLOAT_EXACTLY_EQ(0.3715f, x);
+  EXPECT_FLOAT_EXACTLY_EQ(0.3715f, y);
+  EXPECT_FLOAT_EXACTLY_EQ(3715.0f, z);
 }
 
 TEST(sscanf, floating_point_simple_double_precision) {
   double x = 666.666, y = x, z = y;
   EXPECT_EQ(3, sscanf("0.3715 .3715 3715", "%lf %lf %lf", &x, &y, &z));
-  EXPECT_EQ(0.3715, x);
-  EXPECT_EQ(0.3715, y);
-  EXPECT_EQ(3715.0, z);
+  EXPECT_DOUBLE_EXACTLY_EQ(0.3715, x);
+  EXPECT_DOUBLE_EXACTLY_EQ(0.3715, y);
+  EXPECT_DOUBLE_EXACTLY_EQ(3715.0, z);
 }
 
 TEST(sscanf, floating_point_nan) {
@@ -426,12 +426,12 @@ TEST(sscanf, floating_point_documentation_examples) {
       2, sscanf("0X1.BC70A3D70A3D7P+6 1.18973e+4932zzz -0.0000000123junk junk",
                 "%f %f %f %f %f", &f, &g, &h, &i, &j));
 
-  EXPECT_EQ(111.11f, a);
-  EXPECT_EQ(-2.22f, b);
+  EXPECT_FLOAT_EXACTLY_EQ(111.11f, a);
+  EXPECT_FLOAT_EXACTLY_EQ(-2.22f, b);
   EXPECT_TRUE(isnan(c));
   EXPECT_TRUE(isnan(d));
   EXPECT_TRUE(isinf(e));
-  EXPECT_EQ(0X1.BC70A3D70A3D7P+6f, f);
+  EXPECT_FLOAT_EXACTLY_EQ(0X1.BC70A3D70A3D7P+6f, f);
   EXPECT_TRUE(isinf(g));
 }
 
@@ -445,12 +445,12 @@ TEST(sscanf, floating_point_documentation_examples_double_precision) {
       2, sscanf("0X1.BC70A3D70A3D7P+6 1.18973e+4932zzz -0.0000000123junk junk",
                 "%lf %lf %lf %lf %lf", &f, &g, &h, &i, &j));
 
-  EXPECT_EQ(111.11, a);
-  EXPECT_EQ(-2.22, b);
+  EXPECT_DOUBLE_EXACTLY_EQ(111.11, a);
+  EXPECT_DOUBLE_EXACTLY_EQ(-2.22, b);
   EXPECT_TRUE(isnan(c));
   EXPECT_TRUE(isnan(d));
   EXPECT_TRUE(isinf(e));
-  EXPECT_EQ(0X1.BC70A3D70A3D7P+6, f);
+  EXPECT_DOUBLE_EXACTLY_EQ(0X1.BC70A3D70A3D7P+6, f);
   EXPECT_TRUE(isinf(g));
 }
 
@@ -506,3 +506,9 @@ TEST(scanf, n) {
   ASSERT_EQ(1848, port);
   ASSERT_EQ(12, len);
 }
+
+TEST(sscanf, floating_point_hexadecimal) {
+  double a = 0;
+  ASSERT_EQ(1, sscanf("0x1.5014c3472bc2c0000000p-123", "%lf", &a));
+  ASSERT_DOUBLE_EXACTLY_EQ(0x1.5014c3472bc2c0000000p-123, a);
+}
diff --git a/test/libc/stdio/strfry_test.c b/test/libc/stdio/strfry_test.c
new file mode 100644
index 000000000..a87ee54ba
--- /dev/null
+++ b/test/libc/stdio/strfry_test.c
@@ -0,0 +1,38 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/stdio/rand.h"
+#include "libc/testlib/testlib.h"
+
+TEST(strfry, empty) {
+  char s[1] = "";
+  EXPECT_EQ(s, strfry(s));
+  EXPECT_STREQ("", s);
+}
+
+TEST(strfry, one) {
+  char s[2] = "a";
+  EXPECT_EQ(s, strfry(s));
+  EXPECT_STREQ("a", s);
+}
+
+TEST(strfry, test) {
+  char s[5] = "abcd";
+  EXPECT_EQ(s, strfry(s));
+  EXPECT_STREQ("cbda", s);
+}
diff --git a/test/libc/stdio/zipdir_test.c b/test/libc/stdio/zipdir_test.c
index 83dda5aff..141bb9ad3 100644
--- a/test/libc/stdio/zipdir_test.c
+++ b/test/libc/stdio/zipdir_test.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/dirent.h"
 #include "libc/calls/struct/stat.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/test/libc/str/BUILD.mk b/test/libc/str/BUILD.mk
index cae03bb64..7468b3f05 100644
--- a/test/libc/str/BUILD.mk
+++ b/test/libc/str/BUILD.mk
@@ -36,7 +36,6 @@ TEST_LIBC_STR_DIRECTDEPS =					\
 	LIBC_FMT						\
 	LIBC_INTRIN						\
 	LIBC_LOG						\
-	LIBC_TINYMATH						\
 	LIBC_MEM						\
 	LIBC_NEXGEN32E						\
 	LIBC_RUNTIME						\
@@ -45,14 +44,16 @@ TEST_LIBC_STR_DIRECTDEPS =					\
 	LIBC_SYSV						\
 	LIBC_SYSV_CALLS						\
 	LIBC_TESTLIB						\
+	LIBC_TINYMATH						\
 	LIBC_X							\
 	THIRD_PARTY_COMPILER_RT					\
-	THIRD_PARTY_MBEDTLS					\
-	THIRD_PARTY_REGEX					\
-	THIRD_PARTY_ZLIB					\
 	THIRD_PARTY_LIBCXX					\
+	THIRD_PARTY_MBEDTLS					\
+	THIRD_PARTY_MUSL					\
+	THIRD_PARTY_REGEX					\
 	THIRD_PARTY_SMALLZ4					\
-	THIRD_PARTY_VQSORT
+	THIRD_PARTY_VQSORT					\
+	THIRD_PARTY_ZLIB					\
 
 TEST_LIBC_STR_DEPS :=						\
 	$(call uniq,$(foreach x,$(TEST_LIBC_STR_DIRECTDEPS),$($(x))))
diff --git a/test/libc/str/blake2_test.c b/test/libc/str/blake2_test.c
index 65f2f34e0..4fe6d1427 100644
--- a/test/libc/str/blake2_test.c
+++ b/test/libc/str/blake2_test.c
@@ -18,12 +18,13 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/blake2.h"
 #include "libc/assert.h"
+#include "libc/calls/struct/timespec.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
-#include "libc/testlib/ezbench.h"
+#include "libc/str/tab.h"
+#include "libc/testlib/benchmark.h"
 #include "libc/testlib/hyperion.h"
 #include "libc/testlib/testlib.h"
 
@@ -90,17 +91,18 @@ TEST(BLAKE2B256Test, vectors) {
   free(line);
 }
 
-BENCH(blake2, bench) {
+BENCH(blake2, benchmark) {
   char fun[256];
   rngset(fun, 256, _rand64, -1);
-  EZBENCH_N("blake2b256", 0, EZBLAKE2B256(0, 0));
-  EZBENCH_N("blake2b256", 8, EZBLAKE2B256("helloooo", 8));
-  EZBENCH_N("blake2b256", 31, EZBLAKE2B256(fun, 31));
-  EZBENCH_N("blake2b256", 32, EZBLAKE2B256(fun, 32));
-  EZBENCH_N("blake2b256", 63, EZBLAKE2B256(fun, 63));
-  EZBENCH_N("blake2b256", 64, EZBLAKE2B256(fun, 64));
-  EZBENCH_N("blake2b256", 128, EZBLAKE2B256(fun, 128));
-  EZBENCH_N("blake2b256", 256, EZBLAKE2B256(fun, 256));
-  EZBENCH_N("blake2b256", kHyperionSize,
-            EZBLAKE2B256(kHyperion, kHyperionSize));
+  BENCHMARK(100, 0, __expropriate(EZBLAKE2B256(0, 0)));
+  BENCHMARK(100, 1, __expropriate(EZBLAKE2B256("h", 1)));
+  BENCHMARK(100, 8, __expropriate(EZBLAKE2B256("helloooo", 8)));
+  BENCHMARK(100, 31, __expropriate(EZBLAKE2B256(fun, 31)));
+  BENCHMARK(100, 32, __expropriate(EZBLAKE2B256(fun, 32)));
+  BENCHMARK(100, 63, __expropriate(EZBLAKE2B256(fun, 63)));
+  BENCHMARK(100, 64, __expropriate(EZBLAKE2B256(fun, 64)));
+  BENCHMARK(100, 128, __expropriate(EZBLAKE2B256(fun, 128)));
+  BENCHMARK(100, 256, __expropriate(EZBLAKE2B256(fun, 256)));
+  BENCHMARK(100, kHyperionSize,
+            __expropriate(EZBLAKE2B256(kHyperion, kHyperionSize)));
 }
diff --git a/test/libc/str/hexpcpy_test.c b/test/libc/str/hexpcpy_test.c
index 0a1c1c93d..532342d64 100644
--- a/test/libc/str/hexpcpy_test.c
+++ b/test/libc/str/hexpcpy_test.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdio/rand.h"
 #include "libc/str/str.h"
 #include "libc/testlib/testlib.h"
diff --git a/test/libc/str/highwayhash64_test.c b/test/libc/str/highwayhash64_test.c
index 6ba2f443a..2ac093389 100644
--- a/test/libc/str/highwayhash64_test.c
+++ b/test/libc/str/highwayhash64_test.c
@@ -16,13 +16,14 @@
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/highwayhash64.h"
+#include "libc/calls/struct/timespec.h"
 #include "libc/inttypes.h"
 #include "libc/nexgen32e/crc32.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/testlib/ezbench.h"
+#include "libc/testlib/benchmark.h"
 #include "libc/testlib/hyperion.h"
 #include "libc/testlib/testlib.h"
 #include "third_party/zlib/zlib.h"
@@ -100,33 +101,31 @@ TEST(highwayhash64, test) {
 BENCH(highwayhash64, newbench) {
   char fun[256];
   rngset(fun, 256, _rand64, -1);
-  EZBENCH_N("highwayhash64", 0, HighwayHash64(0, 0, kTestKey1));
-  EZBENCH_N("highwayhash64", 8, HighwayHash64("helloooo", 8, kTestKey1));
-  EZBENCH_N("highwayhash64", 31, HighwayHash64(fun, 31, kTestKey1));
-  EZBENCH_N("highwayhash64", 32, HighwayHash64(fun, 32, kTestKey1));
-  EZBENCH_N("highwayhash64", 63, HighwayHash64(fun, 63, kTestKey1));
-  EZBENCH_N("highwayhash64", 64, HighwayHash64(fun, 64, kTestKey1));
-  EZBENCH_N("highwayhash64", 128, HighwayHash64(fun, 128, kTestKey1));
-  EZBENCH_N("highwayhash64", 256, HighwayHash64(fun, 256, kTestKey1));
-  EZBENCH_N("highwayhash64", kHyperionSize,
+  BENCHMARK(10, 0, HighwayHash64(0, 0, kTestKey1));
+  BENCHMARK(10, 8, HighwayHash64("helloooo", 8, kTestKey1));
+  BENCHMARK(10, 31, HighwayHash64(fun, 31, kTestKey1));
+  BENCHMARK(10, 32, HighwayHash64(fun, 32, kTestKey1));
+  BENCHMARK(10, 63, HighwayHash64(fun, 63, kTestKey1));
+  BENCHMARK(10, 64, HighwayHash64(fun, 64, kTestKey1));
+  BENCHMARK(10, 128, HighwayHash64(fun, 128, kTestKey1));
+  BENCHMARK(10, 256, HighwayHash64(fun, 256, kTestKey1));
+  BENCHMARK(10, kHyperionSize,
             HighwayHash64(kHyperion, kHyperionSize, kTestKey1));
 }
 
 BENCH(highwayhash64, bench) {
-  EZBENCH2("knuth small", donothing,
-           __expropriate(KnuthMultiplicativeHash32(__veil("r", "hello"), 5)));
-  EZBENCH2("crc32c small", donothing, __expropriate(crc32c(0, "hello", 5)));
-  EZBENCH2("crc32 small", donothing,
-           __expropriate(crc32_z(0, __veil("r", "hello"), 5)));
-  EZBENCH2("highwayhash64 small", donothing,
-           HighwayHash64((void *)"hello", 5, kTestKey1));
-  EZBENCH2("crc32 big", donothing,
-           __expropriate(crc32_z(0, kHyperion, kHyperionSize)));
-  EZBENCH2("crc32c big", donothing,
-           __expropriate(crc32c(0, kHyperion, kHyperionSize)));
-  EZBENCH2("highwayhash64 big", donothing,
-           HighwayHash64((void *)kHyperion, kHyperionSize, kTestKey1));
-  EZBENCH2("knuth big", donothing,
-           __expropriate(KnuthMultiplicativeHash32(__veil("r", kHyperion),
-                                                   kHyperionSize)));
+  BENCHMARK(10, 5,
+            __expropriate(KnuthMultiplicativeHash32(__veil("r", "hello"), 5)));
+  BENCHMARK(10, 5, __expropriate(crc32c(0, "hello", 5)));
+  BENCHMARK(10, 5, __expropriate(crc32_z(0, __veil("r", "hello"), 5)));
+  BENCHMARK(10, 5, HighwayHash64((void *)"hello", 5, kTestKey1));
+  BENCHMARK(10, kHyperionSize,
+            __expropriate(crc32_z(0, kHyperion, kHyperionSize)));
+  BENCHMARK(10, kHyperionSize,
+            __expropriate(crc32c(0, kHyperion, kHyperionSize)));
+  BENCHMARK(10, kHyperionSize,
+            HighwayHash64((void *)kHyperion, kHyperionSize, kTestKey1));
+  BENCHMARK(10, kHyperionSize,
+            __expropriate(KnuthMultiplicativeHash32(__veil("r", kHyperion),
+                                                    kHyperionSize)));
 }
diff --git a/test/libc/str/memccpy_test.c b/test/libc/str/memccpy_test.c
index 5b54c189f..aebe301bb 100644
--- a/test/libc/str/memccpy_test.c
+++ b/test/libc/str/memccpy_test.c
@@ -16,10 +16,18 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/calls/calls.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/runtime/sysconf.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
+#include "libc/testlib/benchmark.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/testlib.h"
 
@@ -50,6 +58,40 @@ TEST(memccpy, testZeroLength_doesNothing) {
   EXPECT_EQ(NULL, memccpy(buf, "hi", '\0', 0));
 }
 
+TEST(memccpy, fuzz) {
+  int pagesz = sysconf(_SC_PAGESIZE);
+  char *map1 = (char *)mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
+                            MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  npassert(map1 != MAP_FAILED);
+  npassert(!mprotect(map1 + pagesz, pagesz, PROT_NONE));
+  char *map2 = (char *)mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
+                            MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  npassert(map2 != MAP_FAILED);
+  npassert(!mprotect(map2 + pagesz, pagesz, PROT_NONE));
+  char *map3 = (char *)mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
+                            MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  npassert(map3 != MAP_FAILED);
+  npassert(!mprotect(map3 + pagesz, pagesz, PROT_NONE));
+  for (int dsize = 1; dsize < 128; ++dsize) {
+    char *volatile dst1 = map1 + pagesz - dsize;
+    char *volatile dst2 = map1 + pagesz - dsize;
+    for (int i = 0; i < dsize; ++i)
+      dst1[i] = dst2[i] = rand();
+    for (int ssize = 1; ssize < dsize * 2; ++ssize) {
+      char *volatile src = map3 + pagesz - (ssize + 1);
+      for (int i = 0; i < ssize; ++i)
+        src[i] = max(rand() & 255, 1);
+      src[ssize] = 0;
+      ASSERT_EQ(memccpy_pure(dst1, src, 0, dsize),
+                memccpy(dst2, src, 0, dsize));
+      ASSERT_EQ(0, memcmp(dst1, dst2, dsize));
+    }
+  }
+  npassert(!munmap(map3, pagesz * 2));
+  npassert(!munmap(map2, pagesz * 2));
+  npassert(!munmap(map1, pagesz * 2));
+}
+
 TEST(memccpy, memcpy) {
   unsigned n, n1, n2;
   char *b1, *b2, *b3, *e1, *e2;
@@ -78,3 +120,26 @@ TEST(memccpy, memcpy) {
     free(b1);
   }
 }
+
+#define N 4096
+
+BENCH(memccpy, bench) {
+  char dst[N];
+  char src[N + 1];
+
+  printf("\n");
+  for (int n = 1; n <= N; n *= 2) {
+    for (int i = 0; i < n; ++i)
+      src[i] = max(rand() & 255, 1);
+    src[n] = 0;
+    BENCHMARK(100, n, X(memccpy(dst, src, 0, V(N))));
+  }
+
+  printf("\n");
+  for (int n = 1; n <= N; n *= 2) {
+    for (int i = 0; i < n; ++i)
+      src[i] = max(rand() & 255, 1);
+    src[n] = 0;
+    BENCHMARK(100, n, X(memccpy_pure(dst, src, 0, V(N))));
+  }
+}
diff --git a/test/libc/str/memcpy_test.c b/test/libc/str/memcpy_test.c
index d2fd7e294..59d63f813 100644
--- a/test/libc/str/memcpy_test.c
+++ b/test/libc/str/memcpy_test.c
@@ -169,5 +169,5 @@ BENCH(memcpy, bench) {
   BB(1023);
   BB(1024);
   BB(4096);
-  BB(__granularity());
+  BB(getpagesize());
 }
diff --git a/test/libc/str/memmem_test.c b/test/libc/str/memmem_test.c
index 413397be8..881700537 100644
--- a/test/libc/str/memmem_test.c
+++ b/test/libc/str/memmem_test.c
@@ -17,10 +17,17 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/mem/mem.h"
+#include "libc/assert.h"
+#include "libc/calls/calls.h"
 #include "libc/intrin/likely.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/alg.h"
+#include "libc/runtime/runtime.h"
+#include "libc/runtime/sysconf.h"
 #include "libc/stdio/rand.h"
 #include "libc/str/str.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/hyperion.h"
 #include "libc/testlib/testlib.h"
@@ -172,6 +179,26 @@ TEST(memmem, fuzz) {
   }
 }
 
+TEST(memmem, safety) {
+  int pagesz = sysconf(_SC_PAGESIZE);
+  char *map = (char *)mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
+                           MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  npassert(map != MAP_FAILED);
+  npassert(!mprotect(map + pagesz, pagesz, PROT_NONE));
+  for (int haylen = 1; haylen < 128; ++haylen) {
+    char *hay = map + pagesz - (haylen + 1);
+    for (int i = 0; i < haylen; ++i)
+      hay[i] = max(rand() & 255, 1);
+    hay[haylen] = 0;
+    for (int neelen = 1; neelen < haylen; ++neelen) {
+      char *nee = hay + (haylen + 1) - (neelen + 1);
+      ASSERT_EQ(memmem_naive(hay, haylen, nee, neelen),
+                memmem(hay, haylen, nee, neelen));
+    }
+  }
+  munmap(map, pagesz * 2);
+}
+
 /*
  *     memmem naive        l:    43,783c    14,142ns   m:    31,285c    10,105ns
  *     memmem              l:     2,597c       839ns   m:     2,612c       844ns
@@ -201,7 +228,12 @@ BENCH(memmem, bench) {
   EZBENCH2("memmem", donothing,
            __expropriate(memmem(kHyperion, kHyperionSize, "THE END", 7)));
   EZBENCH2("memmem", donothing,
-           __expropriate(memmem(
-               "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
-               62, "aaaaaab", 7)));
+           __expropriate(
+               memmem("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab",
+                      152,
+                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                      "aaaaaaaaaaaaaaaaaaaaaaaab",
+                      81)));
 }
diff --git a/test/libc/str/regex_test.c b/test/libc/str/regex_test.c
index f51b7f557..5c23594d3 100644
--- a/test/libc/str/regex_test.c
+++ b/test/libc/str/regex_test.c
@@ -19,10 +19,15 @@
 #include "third_party/regex/regex.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
+#include "libc/str/locale.h"
 #include "libc/str/str.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/testlib.h"
 
+void SetUpOnce(void) {
+  setlocale(LC_ALL, "C.UTF-8");
+}
+
 TEST(regex, test) {
   regex_t rx;
   EXPECT_EQ(REG_OK, regcomp(&rx, "^[A-Za-z\x7f-\uffff]{2}$", REG_EXTENDED));
diff --git a/test/libc/str/setlocale_test.c b/test/libc/str/setlocale_test.c
deleted file mode 100644
index cc2669066..000000000
--- a/test/libc/str/setlocale_test.c
+++ /dev/null
@@ -1,30 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Gavin Arthur Hayes                                            │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/locale.h"
-#include "libc/testlib/testlib.h"
-
-TEST(setlocale, test) {
-  EXPECT_STREQ("C", setlocale(LC_ALL, NULL));
-  EXPECT_STREQ("C", setlocale(LC_ALL, "C"));
-  EXPECT_STREQ("C", setlocale(LC_ALL, NULL));
-  EXPECT_STREQ("POSIX", setlocale(LC_ALL, "POSIX"));
-  EXPECT_STREQ("C", setlocale(LC_ALL, ""));
-  EXPECT_EQ(0, setlocale(LC_ALL, "ja_JP.PCK"));
-  EXPECT_STREQ("C", setlocale(LC_ALL, NULL));
-}
diff --git a/test/libc/str/strcasestr_test.c b/test/libc/str/strcasestr_test.c
index a4b29daff..cf012f866 100644
--- a/test/libc/str/strcasestr_test.c
+++ b/test/libc/str/strcasestr_test.c
@@ -17,12 +17,20 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
+#include "libc/assert.h"
+#include "libc/calls/calls.h"
 #include "libc/dce.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/x86feature.h"
-#include "libc/str/tab.internal.h"
+#include "libc/runtime/runtime.h"
+#include "libc/runtime/sysconf.h"
+#include "libc/stdio/rand.h"
+#include "libc/str/tab.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/hyperion.h"
 #include "libc/testlib/testlib.h"
@@ -49,6 +57,30 @@ char *strcasestr_naive(const char *haystack, const char *needle) {
   return 0;
 }
 
+TEST(strcasestr, tester) {
+  const char *haystack = "Windows";
+  ASSERT_STREQ(haystack, strcasestr(haystack, "win"));
+}
+
+TEST(strcasestr, safety) {
+  int pagesz = sysconf(_SC_PAGESIZE);
+  char *map = (char *)mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
+                           MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  npassert(map != MAP_FAILED);
+  npassert(!mprotect(map + pagesz, pagesz, PROT_NONE));
+  for (int haylen = 1; haylen < 128; ++haylen) {
+    char *hay = map + pagesz - (haylen + 1);
+    for (int i = 0; i < haylen; ++i)
+      hay[i] = max(rand() & 255, 1);
+    hay[haylen] = 0;
+    for (int neelen = 1; neelen < haylen; ++neelen) {
+      char *nee = hay + (haylen + 1) - (neelen + 1);
+      ASSERT_EQ(strcasestr_naive(hay, nee), strcasestr(hay, nee));
+    }
+  }
+  munmap(map, pagesz * 2);
+}
+
 TEST(strcasestr, test_emptyString_isFoundAtBeginning) {
   MAKESTRING(haystack, "abc123def");
   ASSERT_STREQ(&haystack[0], strcasestr(haystack, gc(strdup(""))));
diff --git a/test/libc/str/strlcpy_test.c b/test/libc/str/strlcpy_test.c
index e65600119..2d21841f7 100644
--- a/test/libc/str/strlcpy_test.c
+++ b/test/libc/str/strlcpy_test.c
@@ -16,12 +16,71 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/calls/calls.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/runtime/sysconf.h"
+#include "libc/stdio/rand.h"
 #include "libc/str/str.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
+#include "libc/testlib/benchmark.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/testlib.h"
 
+size_t todd(char *dst, const char *src, size_t dsize) {
+  const char *osrc = src;
+  size_t nleft = dsize;
+  if (nleft != 0)
+    while (--nleft != 0)
+      if ((*dst++ = *src++) == '\0')
+        break;
+  if (nleft == 0) {
+    if (dsize != 0)
+      *dst = '\0';
+    while (*src++)
+      ;
+  }
+  return src - osrc - 1;
+}
+
+TEST(strlcpy, fuzz) {
+  int pagesz = sysconf(_SC_PAGESIZE);
+  char *map1 = (char *)mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
+                            MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  npassert(map1 != MAP_FAILED);
+  npassert(!mprotect(map1 + pagesz, pagesz, PROT_NONE));
+  char *map2 = (char *)mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
+                            MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  npassert(map2 != MAP_FAILED);
+  npassert(!mprotect(map2 + pagesz, pagesz, PROT_NONE));
+  char *map3 = (char *)mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
+                            MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  npassert(map3 != MAP_FAILED);
+  npassert(!mprotect(map3 + pagesz, pagesz, PROT_NONE));
+  for (int dsize = 1; dsize < 128; ++dsize) {
+    char *volatile dst1 = map1 + pagesz - dsize;
+    char *volatile dst2 = map1 + pagesz - dsize;
+    for (int i = 0; i < dsize; ++i)
+      dst1[i] = dst2[i] = max(rand() & 255, 1);
+    for (int ssize = 1; ssize < dsize * 2; ++ssize) {
+      char *volatile src = map3 + pagesz - (ssize + 1);
+      for (int i = 0; i < ssize; ++i)
+        src[i] = max(rand() & 255, 1);
+      src[ssize] = 0;
+      ASSERT_EQ(todd(dst1, src, dsize), strlcpy(dst2, src, dsize));
+      ASSERT_EQ(0, memcmp(dst1, dst2, dsize));
+    }
+  }
+  npassert(!munmap(map3, pagesz * 2));
+  npassert(!munmap(map2, pagesz * 2));
+  npassert(!munmap(map1, pagesz * 2));
+}
+
 TEST(strlcpy, testEmptyBuffer_doesNothing) {
   EXPECT_EQ(5, strlcpy(NULL, "hello", 0));
 }
@@ -38,12 +97,25 @@ TEST(strlcpy, testShortBuffer_copies) {
   EXPECT_STREQ("h", buf);
 }
 
+#define N 4096
+
 BENCH(strlcpy, bench) {
-  char buf[256];
-  EZBENCH2(
-      "strlcpy", donothing,
-      __expropriate(strlcpy(__veil("r", buf), "hello there", sizeof(buf))));
-  EZBENCH2(
-      "strncpy", donothing,
-      __expropriate(strncpy(__veil("r", buf), "hello there", sizeof(buf))));
+  char dst[N];
+  char src[N + 1];
+
+  printf("\n");
+  for (int n = 1; n <= N; n *= 2) {
+    for (int i = 0; i < n; ++i)
+      src[i] = max(rand() & 255, 1);
+    src[n] = 0;
+    BENCHMARK(100, n, X(strlcpy(dst, src, V(N))));
+  }
+
+  printf("\n");
+  for (int n = 1; n <= N; n *= 2) {
+    for (int i = 0; i < n; ++i)
+      src[i] = max(rand() & 255, 1);
+    src[n] = 0;
+    BENCHMARK(100, n, X(todd(dst, src, V(N))));
+  }
 }
diff --git a/test/libc/str/strstr_test.c b/test/libc/str/strstr_test.c
index 929185e6f..086dd6e15 100644
--- a/test/libc/str/strstr_test.c
+++ b/test/libc/str/strstr_test.c
@@ -17,11 +17,23 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
+#include "libc/assert.h"
+#include "libc/calls/calls.h"
 #include "libc/dce.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/x86feature.h"
+#include "libc/runtime/runtime.h"
+#include "libc/runtime/sysconf.h"
+#include "libc/stdalign.h"
+#include "libc/stdio/rand.h"
+#include "libc/stdio/stdio.h"
+#include "libc/stdio/sysparam.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/prot.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/hyperion.h"
 #include "libc/testlib/testlib.h"
@@ -48,6 +60,13 @@ char *strstr_naive(const char *haystack, const char *needle) {
   return 0;
 }
 
+TEST(strstr, special) {
+  MAKESTRING(haystack, "abc123def");
+  ASSERT_STREQ(&haystack[0], strstr(haystack, haystack));
+  ASSERT_STREQ(&haystack[0], strstr(haystack, ""));
+  free(haystack);
+}
+
 TEST(strstr, test_emptyString_isFoundAtBeginning) {
   MAKESTRING(haystack, "abc123def");
   ASSERT_STREQ(&haystack[0], strstr(haystack, gc(strdup(""))));
@@ -67,7 +86,8 @@ TEST(strstr, test_notFound1) {
 }
 
 TEST(strstr, test_middleOfString) {
-  MAKESTRING(haystack, "abc123def");
+  alignas(16) char hog[] = "abc123def";
+  MAKESTRING(haystack, hog);
   ASSERT_STREQ(&haystack[3], strstr(haystack, gc(strdup("123"))));
   free(haystack);
 }
@@ -98,6 +118,25 @@ TEST(strstr, test) {
   ASSERT_STREQ("x", strstr("x", "x"));
 }
 
+TEST(strstr, safety) {
+  int pagesz = sysconf(_SC_PAGESIZE);
+  char *map = (char *)mmap(0, pagesz * 2, PROT_READ | PROT_WRITE,
+                           MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  npassert(map != MAP_FAILED);
+  npassert(!mprotect(map + pagesz, pagesz, PROT_NONE));
+  for (int haylen = 1; haylen < 128; ++haylen) {
+    char *hay = map + pagesz - (haylen + 1);
+    for (int i = 0; i < haylen; ++i)
+      hay[i] = max(rand() & 255, 1);
+    hay[haylen] = 0;
+    for (int neelen = 1; neelen < haylen; ++neelen) {
+      char *nee = hay + (haylen + 1) - (neelen + 1);
+      ASSERT_EQ(strstr_naive(hay, nee), strstr(hay, nee));
+    }
+  }
+  munmap(map, pagesz * 2);
+}
+
 TEST(strstr, breakit) {
   char *p;
   p = gc(calloc(1, 32));
diff --git a/test/libc/str/towupper_test.c b/test/libc/str/towupper_test.c
index 479e41c94..b5096be03 100644
--- a/test/libc/str/towupper_test.c
+++ b/test/libc/str/towupper_test.c
@@ -20,6 +20,7 @@
 #include "libc/str/str.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/testlib.h"
+#include "libc/wctype.h"
 
 TEST(iswupper, test) {
   EXPECT_TRUE(iswupper(L'𝐵'));
@@ -29,7 +30,7 @@ TEST(towupper, test) {
   EXPECT_EQ(u'!', towupper(u'!'));
   EXPECT_EQ(u'A', towupper(u'a'));
   EXPECT_EQ(u'À', towupper(u'à'));
-  EXPECT_EQ(L'𝛥', towupper(L'𝛿'));
+  /* EXPECT_EQ(L'𝛥', towupper(L'𝛿')); */
   EXPECT_EQ(L'Ｂ', towupper(L'ｂ'));
   EXPECT_EQ(u'Ꭰ', towupper(u'ꭰ'));
 }
@@ -38,7 +39,7 @@ TEST(towlower, test) {
   EXPECT_EQ(u'!', towlower(u'!'));
   EXPECT_EQ(u'a', towlower(u'A'));
   EXPECT_EQ(u'à', towlower(u'À'));
-  EXPECT_EQ(L'𝛿', towlower(L'𝛥'));
+  /* EXPECT_EQ(L'𝛿', towlower(L'𝛥')); */
   EXPECT_EQ(L'ｂ', towlower(L'Ｂ'));
   EXPECT_EQ(u'ꭰ', towlower(u'Ꭰ'));
 }
diff --git a/test/libc/str/wcwidth_test.c b/test/libc/str/wcwidth_test.c
index a57e837c9..e79ea59f4 100644
--- a/test/libc/str/wcwidth_test.c
+++ b/test/libc/str/wcwidth_test.c
@@ -16,9 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/str/strwidth.h"
 #include "libc/str/unicode.h"
+#include "libc/testlib/benchmark.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/testlib.h"
 
@@ -28,6 +30,7 @@ TEST(wcwidth, test) {
   ASSERT_EQ(-1, wcwidth(-7));
   ASSERT_EQ(1, wcwidth(0x10FFFD));
   ASSERT_EQ(-1, wcwidth(0x10FFFD + 1));
+  ASSERT_EQ(2, wcwidth(L'😀'));
 }
 
 TEST(strwidth, testCjkWidesAndCombiningLowLines_withThompsonPikeEncoding) {
@@ -74,6 +77,12 @@ TEST(strwidth, testTextDelimitingControlCodes_dontHaveSubstance) {
   EXPECT_EQ(0, strwidth("\1", 0));
 }
 
+#define WCWIDTH(x) __expropriate(wcwidth(__veil("r", x)))
+
 BENCH(wcwidth, bench) {
-  EZBENCH2("wcwidth", donothing, __expropriate(wcwidth(__veil("r", u'→'))));
+  BENCHMARK(1000, 1, WCWIDTH(u'a'));
+  BENCHMARK(1000, 1, WCWIDTH(u'a'));
+  BENCHMARK(1000, 1, WCWIDTH(u'→'));
+  BENCHMARK(1000, 1, WCWIDTH(L'😀'));
+  BENCHMARK(1000, 1, WCWIDTH(0));
 }
diff --git a/test/libc/system/BUILD.mk b/test/libc/system/BUILD.mk
new file mode 100644
index 000000000..ef1a6036d
--- /dev/null
+++ b/test/libc/system/BUILD.mk
@@ -0,0 +1,116 @@
+#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
+#── vi: set noet ft=make ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
+
+PKGS += TEST_LIBC_SYSTEM
+
+TEST_LIBC_SYSTEM_FILES := $(wildcard test/libc/system/*)
+TEST_LIBC_SYSTEM_SRCS = $(filter %.c,$(TEST_LIBC_SYSTEM_FILES))
+TEST_LIBC_SYSTEM_INCS = $(filter %.inc,$(TEST_LIBC_SYSTEM_FILES))
+TEST_LIBC_SYSTEM_SRCS_TEST = $(filter %_test.c,$(TEST_LIBC_SYSTEM_SRCS))
+
+TEST_LIBC_SYSTEM_OBJS =						\
+	$(TEST_LIBC_SYSTEM_SRCS:%.c=o/$(MODE)/%.o)
+
+TEST_LIBC_SYSTEM_COMS =						\
+	$(TEST_LIBC_SYSTEM_SRCS:%.c=o/$(MODE)/%)
+
+TEST_LIBC_SYSTEM_BINS =						\
+	$(TEST_LIBC_SYSTEM_COMS)				\
+	$(TEST_LIBC_SYSTEM_COMS:%=%.dbg)
+
+TEST_LIBC_SYSTEM_TESTS =					\
+	$(TEST_LIBC_SYSTEM_SRCS_TEST:%.c=o/$(MODE)/%.ok)
+
+TEST_LIBC_SYSTEM_CHECKS =					\
+	$(TEST_LIBC_SYSTEM_SRCS_TEST:%.c=o/$(MODE)/%.runs)
+
+TEST_LIBC_SYSTEM_DIRECTDEPS =					\
+	LIBC_CALLS						\
+	LIBC_INTRIN						\
+	LIBC_LOG						\
+	LIBC_MEM						\
+	LIBC_NEXGEN32E						\
+	LIBC_PROC						\
+	LIBC_RUNTIME						\
+	LIBC_STDIO						\
+	LIBC_STR						\
+	LIBC_SYSTEM						\
+	LIBC_SYSV						\
+	LIBC_TESTLIB						\
+	LIBC_THREAD						\
+	LIBC_X							\
+	THIRD_PARTY_MUSL					\
+	THIRD_PARTY_TR						\
+	THIRD_PARTY_TZ						\
+
+TEST_LIBC_SYSTEM_DEPS :=					\
+	$(call uniq,$(foreach x,$(TEST_LIBC_SYSTEM_DIRECTDEPS),$($(x))))
+
+o/$(MODE)/test/libc/system/system.pkg:				\
+		$(TEST_LIBC_SYSTEM_OBJS)			\
+		$(foreach x,$(TEST_LIBC_SYSTEM_DIRECTDEPS),$($(x)_A).pkg)
+
+o/$(MODE)/test/libc/system/%.dbg:				\
+		$(TEST_LIBC_SYSTEM_DEPS)			\
+		o/$(MODE)/test/libc/system/%.o			\
+		o/$(MODE)/test/libc/system/system.pkg		\
+		o/$(MODE)/tool/build/echo.zip.o			\
+		$(LIBC_TESTMAIN)				\
+		$(CRT)						\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
+o/$(MODE)/test/libc/system/popen_test.dbg:			\
+		$(TEST_LIBC_SYSTEM_DEPS)			\
+		o/$(MODE)/test/libc/system/popen_test.o		\
+		o/$(MODE)/test/libc/system/system.pkg		\
+		o/$(MODE)/tool/build/echo.zip.o			\
+		$(LIBC_TESTMAIN)				\
+		$(CRT)						\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
+o/$(MODE)/test/libc/system/system_test.dbg:			\
+		$(TEST_LIBC_SYSTEM_DEPS)			\
+		o/$(MODE)/test/libc/system/system_test.o	\
+		o/$(MODE)/test/libc/system/system.pkg		\
+		o/$(MODE)/tool/build/echo.zip.o			\
+		o/$(MODE)/tool/build/cocmd.zip.o		\
+		o/$(MODE)/tool/build/false.zip.o		\
+		$(LIBC_TESTMAIN)				\
+		$(CRT)						\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
+o/$(MODE)/test/libc/system/trace_test.dbg:			\
+		$(TEST_LIBC_SYSTEM_DEPS)			\
+		o/$(MODE)/test/libc/system/trace_test.o		\
+		o/$(MODE)/test/libc/system/system.pkg		\
+		o/$(MODE)/test/libc/system/popen_test.zip.o	\
+		o/$(MODE)/test/libc/system/popen_test.dbg.zip.o	\
+		o/$(MODE)/tool/build/echo.zip.o			\
+		$(LIBC_TESTMAIN)				\
+		$(CRT)						\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
+o/$(MODE)/test/libc/system/systemvpe_test.dbg:			\
+		$(TEST_LIBC_SYSTEM_DEPS)			\
+		o/$(MODE)/test/libc/system/systemvpe_test.o	\
+		o/$(MODE)/test/libc/system/system.pkg		\
+		o/$(MODE)/test/libc/proc/life.zip.o		\
+		$(LIBC_TESTMAIN)				\
+		$(CRT)						\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
+
+o/$(MODE)/test/libc/system/popen_test.zip.o: private ZIPOBJ_FLAGS += -B
+o/$(MODE)/test/libc/system/popen_test.dbg.zip.o: private ZIPOBJ_FLAGS += -B
+
+$(TEST_LIBC_SYSTEM_OBJS): test/libc/system/BUILD.mk
+
+.PHONY: o/$(MODE)/test/libc/system
+o/$(MODE)/test/libc/system:					\
+		$(TEST_LIBC_SYSTEM_BINS)			\
+		$(TEST_LIBC_SYSTEM_CHECKS)
diff --git a/test/libc/stdio/popen_test.c b/test/libc/system/popen_test.c
similarity index 84%
rename from test/libc/stdio/popen_test.c
rename to test/libc/system/popen_test.c
index ef4a2b973..b0099bdc7 100644
--- a/test/libc/stdio/popen_test.c
+++ b/test/libc/system/popen_test.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/calls/struct/itimerval.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
@@ -31,21 +32,59 @@
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/f.h"
+#include "libc/sysv/consts/itimer.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
-#ifdef __x86_64__
+#include "libc/time.h"
+
+// test ability of user to override pthread mutex api
+int pthread_mutex_lock(pthread_mutex_t *mutex) {
+  abort();
+}
+int pthread_mutex_unlock(pthread_mutex_t *mutex) {
+  abort();
+}
+int pthread_mutex_trylock(pthread_mutex_t *mutex) {
+  abort();
+}
+int pthread_mutex_wipe_np(pthread_mutex_t *mutex) {
+  abort();
+}
 
 FILE *f;
 char buf[32];
 
+void OnAlarm(int sig) {
+}
+
+void *LolThread(void *arg) {
+  return 0;
+}
+
 void SetUpOnce(void) {
   testlib_enable_tmp_setup_teardown();
+
+  // give deadlock detector more information
+  int64_t t = 0x5cd04d0e;
+  localtime(&t);
+  pthread_t th;
+  pthread_create(&th, 0, LolThread, 0);
+  pthread_join(th, 0);
+  char buf[32];
+  sprintf(buf, "%g", 3.14);
+  atexit((void *)LolThread);
+  FILE *f = fopen("/zip/.cosmo", "r");
+  fgetc(f);
+  fclose(f);
+  signal(SIGALRM, OnAlarm);
+  struct itimerval it = {{0, 1000}, {0, 1}};
+  setitimer(ITIMER_REAL, &it, 0);
 }
 
 void CheckForFdLeaks(void) {
   int rc, i, l = 0, e = errno;
-  for (i = 3; i < 16; ++i) {
+  for (i = 3; i < 50; ++i) {
     rc = fcntl(i, F_GETFL);
     if (rc == -1) {
       ASSERT_EQ(EBADF, errno);
@@ -120,8 +159,6 @@ void OnSig(int sig) {
 }
 
 TEST(popen, complicated) {
-  if (IsWindows())
-    return;  // windows treats sigusr1 as terminate
   char cmd[64];
   signal(SIGUSR1, OnSig);
   sprintf(cmd, "read a ; test \"x$a\" = xhello && kill -USR1 %d", getpid());
@@ -149,7 +186,11 @@ void *Worker(void *arg) {
     ASSERT_NE(NULL, (f = popen(cmd, "r")));
     EXPECT_STREQ(arg1, fgets(buf, sizeof(buf), f));
     EXPECT_STREQ(arg2, fgets(buf, sizeof(buf), f));
-    ASSERT_EQ(0, pclose(f));
+    if (IsWindows())
+      // todo(jart): why does it flake with echild?
+      pclose(f);
+    else
+      ASSERT_EQ(0, pclose(f));
     free(arg2);
     free(arg1);
     free(cmd);
@@ -158,10 +199,6 @@ void *Worker(void *arg) {
 }
 
 TEST(popen, torture) {
-  if (IsWindows()) {
-    // TODO: Why does pclose() return kNtSignalAccessViolationa?!
-    return;
-  }
   int i, n = 4;
   pthread_t *t = gc(malloc(sizeof(pthread_t) * n));
   testlib_extract("/zip/echo", "echo", 0755);
@@ -171,5 +208,3 @@ TEST(popen, torture) {
     ASSERT_EQ(0, pthread_join(t[i], 0));
   CheckForFdLeaks();
 }
-
-#endif /* __x86_64__ */
diff --git a/test/libc/proc/system_test.c b/test/libc/system/system_test.c
similarity index 94%
rename from test/libc/proc/system_test.c
rename to test/libc/system/system_test.c
index b80873320..3773a64e0 100644
--- a/test/libc/proc/system_test.c
+++ b/test/libc/system/system_test.c
@@ -27,10 +27,9 @@
 #include "libc/str/str.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/sig.h"
-#include "libc/testlib/ezbench.h"
+#include "libc/testlib/benchmark.h"
 #include "libc/testlib/testlib.h"
 #include "libc/x/x.h"
-#ifdef __x86_64__
 
 #define GETEXITSTATUS(x)                                                \
   ({                                                                    \
@@ -166,13 +165,12 @@ TEST(system, notequals) {
 }
 
 TEST(system, usleep) {
-  ASSERT_EQ(0, GETEXITSTATUS(system("usleep & kill $!")));
+  ASSERT_EQ(0, GETEXITSTATUS(system("usleep & kill $!; wait")));
 }
 
 TEST(system, kill) {
   int ws = system("kill -TERM $$; usleep");
-  if (!IsWindows())
-    ASSERT_EQ(SIGTERM, WTERMSIG(ws));
+  ASSERT_EQ(SIGTERM, WTERMSIG(ws));
 }
 
 TEST(system, exitStatusPreservedAfterSemiColon) {
@@ -277,15 +275,9 @@ TEST(system, pipelineCanOutputBackToSelf) {
   RestoreStdout();
 }
 
-int system2(const char *);
-
-BENCH(system, bench) {
+TEST(system, bench) {
   testlib_extract("/zip/echo", "echo", 0755);
-  EZBENCH2("system cmd", donothing, system("./echo hi >/dev/null"));
-  EZBENCH2("systemvpe cmd", donothing,
-           systemvpe("./echo", (char *[]){"./echo", "hi", 0}, 0));
-  EZBENCH2("cocmd echo", donothing, system("echo hi >/dev/null"));
-  EZBENCH2("cocmd exit", donothing, system("exit"));
+  BENCHMARK(10, 1, system("./echo hi >/dev/null"));
+  BENCHMARK(10, 1, system("echo hi >/dev/null"));
+  BENCHMARK(10, 1, system("exit"));
 }
-
-#endif /* __x86_64__ */
diff --git a/test/libc/system/systemvpe_test.c b/test/libc/system/systemvpe_test.c
new file mode 100644
index 000000000..bcbc5a30c
--- /dev/null
+++ b/test/libc/system/systemvpe_test.c
@@ -0,0 +1,34 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/cosmo.h"
+#include "libc/runtime/runtime.h"
+#include "libc/testlib/testlib.h"
+
+void SetUpOnce(void) {
+  testlib_enable_tmp_setup_teardown();
+}
+
+TEST(systemvpe, test) {
+  ASSERT_SYS(0, 0, mkdir("bin", 0755));
+  ASSERT_SYS(0, 0, setenv("PATH", "bin", true));
+  testlib_extract("/zip/life", "bin/life", 0755);
+  ASSERT_SYS(0, 42 << 8,
+             systemvpe("life", (char *[]){"life", 0}, (char *[]){0}));
+}
diff --git a/test/libc/system/trace_test.c b/test/libc/system/trace_test.c
new file mode 100644
index 000000000..7a661a2fc
--- /dev/null
+++ b/test/libc/system/trace_test.c
@@ -0,0 +1,74 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/assert.h"
+#include "libc/calls/calls.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/testlib/testlib.h"
+#include "libc/x/x.h"
+
+// make sure that running `popen_test --ftrace --strace` doesn't crash
+//
+// function and system call tracing are invasive runtime features that
+// can easily break if interrupting the other magical, deeply embedded
+// parts of the runtime, like mutations to the rbtree ftrace needs for
+// validating stack pointers (kisdangerous() locks the mmap lock), and
+// that's why we use dontinstrument in so many places in the codebase.
+//
+// we like popen_test because it tests the intersection of forking and
+// threads, and it activates other subsystems like the signal / itimer
+// worker threads on windows. if we can ftrace and strace it, then you
+// can be assured cosmo's tracing support works right on all platforms
+
+void SetUpOnce(void) {
+  testlib_enable_tmp_setup_teardown();
+}
+
+TEST(trace, test) {
+  unsetenv("MAKEFLAGS");  // avoid testmain.c 254 status
+  testlib_extract("/zip/popen_test", "popen_test", 0755);
+  testlib_extract("/zip/popen_test.dbg", "popen_test.dbg", 0755);
+  if (!fork()) {
+    close(1);
+    close(2);
+    open("log", O_CREAT | O_TRUNC | O_WRONLY | O_APPEND, 0644);
+    dup(1);
+    execl("./popen_test", "./popen_test", "--ftrace", "--strace", NULL);
+    _Exit(128);
+  }
+  int ws;
+  unassert(wait(&ws));
+  if (WIFSIGNALED(ws)) {
+    fprintf(stderr,
+            "%s:%d: error: trace_test got %s signal running "
+            "popen_test --strace --ftrace (see %s for output)\n",
+            __FILE__, __LINE__, strsignal(WTERMSIG(ws)), realpath("log", 0));
+    _Exit(1);
+  }
+  if (WEXITSTATUS(ws)) {
+    fprintf(stderr,
+            "%s:%d: error: trace_test got %d exit status running "
+            "popen_test --strace --ftrace (see %s for output)\n",
+            __FILE__, __LINE__, WEXITSTATUS(ws), realpath("log", 0));
+    _Exit(1);
+  }
+}
diff --git a/test/libc/thread/BUILD.mk b/test/libc/thread/BUILD.mk
index 78e185361..1ac2769be 100644
--- a/test/libc/thread/BUILD.mk
+++ b/test/libc/thread/BUILD.mk
@@ -41,6 +41,7 @@ TEST_LIBC_THREAD_DIRECTDEPS =				\
 	LIBC_SOCK					\
 	LIBC_STDIO					\
 	LIBC_STR					\
+	LIBC_SYSTEM					\
 	LIBC_SYSV					\
 	LIBC_SYSV_CALLS					\
 	LIBC_TESTLIB					\
@@ -49,7 +50,7 @@ TEST_LIBC_THREAD_DIRECTDEPS =				\
 	THIRD_PARTY_LIBCXXABI				\
 	THIRD_PARTY_NSYNC				\
 	THIRD_PARTY_NSYNC_MEM				\
-	THIRD_PARTY_TZ
+	THIRD_PARTY_TZ					\
 
 TEST_LIBC_THREAD_DEPS :=				\
 	$(call uniq,$(foreach x,$(TEST_LIBC_THREAD_DIRECTDEPS),$($(x))))
diff --git a/test/libc/thread/footek_test.c b/test/libc/thread/footek_test.c
new file mode 100644
index 000000000..b08846ae3
--- /dev/null
+++ b/test/libc/thread/footek_test.c
@@ -0,0 +1,389 @@
+#define USE        POSIX
+#define ITERATIONS 100000
+#define THREADS    30
+
+#define SPIN            1
+#define FUTEX           2
+#define FUTEX_SHARED    3
+#define POSIX           4
+#define POSIX_RECURSIVE 5
+#define RWLOCK          6
+#define RWLOCK_SHARED   7
+
+#ifdef __COSMOPOLITAN__
+#include <cosmo.h>
+#endif
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+
+#ifdef __linux__
+#include <linux/futex.h>
+#include <sys/syscall.h>
+static inline long nsync_futex_wait_(atomic_int *uaddr, int val, char pshare,
+                                     int clock,
+                                     const struct timespec *timeout) {
+  return syscall(SYS_futex, uaddr, pshare ? FUTEX_WAIT : FUTEX_WAIT_PRIVATE,
+                 val, timeout, NULL, 0);
+}
+static inline long nsync_futex_wake_(atomic_int *uaddr, int num_to_wake,
+                                     char pshare) {
+  return syscall(SYS_futex, uaddr, pshare ? FUTEX_WAKE : FUTEX_WAKE_PRIVATE,
+                 num_to_wake, NULL, NULL, 0);
+}
+#endif
+
+// x86 fleet
+// with spin lock
+// 30 threads / 100000 iterations
+//
+// footek_test on Linux 6.8 AMD Ryzen Threadripper PRO 7995WX
+//        1,570,224 us real
+//       42,690,880 us user
+//            1,999 us sys
+//
+// footek_test on rhel7.test.           423 µs    2'638 µs     912'241 µs
+//          897,815 us real
+//        1,763,705 us user
+//            9,696 us sys
+//
+// footek_test on xnu.test.          98'468 µs    5'242 µs   5'191'724 µs
+//        4,225,726 us real
+//       16,679,456 us user
+//           16,265 us sys
+//
+// footek_test on freebsd.test.         690 µs    3'011 µs   2'925'997 µs
+//        2,916,033 us real
+//       17,236,103 us user
+//                0 us sys
+//
+// footek_test on netbsd.test.        1'151 µs    2'634 µs   1'014'867 µs
+//          790,332 us real
+//        2,359,967 us user
+//                0 us sys
+//
+// footek_test on openbsd.test.         557 µs    3'020 µs   2'554'648 µs
+//        2,332,724 us real
+//        9,150,000 us user
+//           10,000 us sys
+//
+// footek_test on win10.test.           962 µs    9'698 µs   2'751'905 µs
+//        2,528,863 us real
+//       56,546,875 us user
+//        1,671,875 us sys
+
+// x86 fleet
+// with futexes
+// 30 threads / 100000 iterations
+//
+// footek_test on Linux 6.8 AMD Ryzen Threadripper PRO 7995WX
+//          100,746 us real
+//          234,451 us user
+//        2,638,333 us sys
+//
+// footek_test on rhel7.test.           376 µs    2'259 µs     153'024 µs
+//          146,015 us real
+//          169,427 us user
+//           68,939 us sys
+//
+// footek_test on xnu.test.          11'143 µs    9'159 µs     164'865 µs
+//          144,917 us real
+//          383,317 us user
+//          191,203 us sys
+//
+// footek_test on freebsd.test.         394 µs    2'165 µs     256'227 µs
+//          244,286 us real
+//          405,395 us user
+//          956,122 us sys
+//
+// footek_test on netbsd.test.          502 µs    2'020 µs     261'895 µs
+//          209,095 us real
+//          616,634 us user
+//            9,945 us sys
+//
+// footek_test on openbsd.test.         457 µs    2'737 µs     396'342 µs
+//          344,876 us real
+//           50,000 us user
+//        1,240,000 us sys
+//
+// footek_test on win10.test.           462 µs   59'528 µs   1'348'265 µs
+//        1,193,906 us real
+//       17,546,875 us user
+//        3,000,000 us sys
+
+// x86 fleet
+// with posix
+// 30 threads / 100000 iterations
+//
+// footek_test on Linux 6.8 AMD Ryzen Threadripper PRO 7995WX (glibc)
+//          111,560 us real
+//          153,985 us user
+//        2,988,121 us sys
+//
+// footek_test on Linux 6.8 AMD Ryzen Threadripper PRO 7995WX (musl)
+//          392,765 us real
+//        1,885,558 us user
+//        9,667,865 us sys
+//
+// footek_test on Linux 6.8 AMD Ryzen Threadripper PRO 7995WX (cosmo)
+//           40,965 us real
+//           47,168 us user
+//           25,398 us sys
+//
+// footek_test on rhel7.test.           683 µs    1'340 µs     105'977 µs
+//          101,934 us real
+//          104,771 us user
+//            4,068 us sys
+//
+// footek_test on xnu.test.           2'054 µs    5'352 µs     210'306 µs
+//          181,540 us real
+//          216,236 us user
+//          127,344 us sys
+//
+// footek_test on freebsd.test. (cosmo)
+//          126,803 us real
+//            3,100 us user
+//          176,744 us sys
+//
+// footek_test on freebsd.test. (freebsd libc)
+//          219,073 us real
+//          158,103 us user
+//        1,146,252 us sys
+//
+// footek_test on netbsd.test.          350 µs    3'570 µs     262'186 µs
+//          199,882 us real
+//          138,178 us user
+//          329,501 us sys
+//
+// footek_test on openbsd.test. (cosmo)
+//          138,619 us real
+//           30,000 us user
+//          110,000 us sys
+//
+// footek_test on openbsd.test. (openbsd libc)
+//          385,431 us real
+//           80,000 us user
+//        1,350,000 us sys
+//
+// footek_test on win10.test. (cosmo)
+//          156,382 us real
+//          312,500 us user
+//           31,250 us sys
+//
+// footek_test on win10.test. (cygwin)
+//        9,334,610 us real
+//        1,562,000 us user
+//        6,093,000 us sys
+
+// arm fleet
+// with spin lock
+// 30 threads / 100000 iterations
+//
+// footek_test on studio.test.          961 µs   12'907 µs   1'287'983 µs
+//        1,282,084 us real
+//       29,359,582 us user
+//           34,553 us sys
+//
+// footek_test on pi.test.              459 µs   16'376 µs   4'095'512 µs
+//        4,070,988 us real
+//       16,203,990 us user
+//            7,999 us sys
+//
+// footek_test on freebsdarm.test.      502 µs   16'446 µs   7'051'545 µs
+//        7,012,493 us real
+//       27,936,725 us user
+//            7,871 us sys
+
+// arm fleet
+// with futexes
+// 30 threads / 100000 iterations
+//
+// footek_test on studio.test.          585 µs   13'597 µs      57'473 µs
+//           46,481 us real
+//           68,745 us user
+//          586,871 us sys
+//
+// footek_test on pi5.test.             335 µs   13'034 µs     432'358 µs
+//          389,619 us real
+//          839,848 us user
+//          679,112 us sys
+//
+// footek_test on pi.test.              479 µs   16'539 µs     476'395 µs
+//          463,799 us real
+//        1,259,267 us user
+//          547,681 us sys
+//
+// footek_test on freebsdarm.test.      364 µs   16'898 µs   1'288'594 µs
+//        1,256,134 us real
+//        3,770,473 us user
+//        1,214,755 us sys
+
+// arm fleet
+// with posix
+// 30 threads / 100000 iterations
+//
+// footek_test on Apple M2 Ultra (Apple Libc)
+//           45,443 us real
+//           30,201 us user
+//          864,650 us sys
+//
+// footek_test on Apple M2 Ultra (Cosmo Libc)
+//           65,118 us real
+//           77,891 us user
+//        1,023,575 us sys
+//
+// footek_test on pi5.test.             407 µs   12'661 µs     198'133 µs
+//          152,791 us real
+//          143,678 us user
+//           14,736 us sys
+//
+// footek_test on studio.test.          463 µs   13'286 µs     234'742 µs
+//          227,916 us real
+//          294,162 us user
+//          155,062 us sys
+//
+// footek_test on pi.test.              374 µs   15'720 µs     249'245 µs
+//          233,504 us real
+//          301,072 us user
+//          187,153 us sys
+//
+// footek_test on freebsdarm.test.      328 µs   16'614 µs     918'647 µs
+//          877,124 us real
+//        1,377,338 us user
+//          798,230 us sys
+
+#define MUTEX_LOCKED(word)  ((word) & 8)
+#define MUTEX_WAITING(word) ((word) & 16)
+
+#define MUTEX_LOCK(word)        ((word) | 8)
+#define MUTEX_SET_WAITING(word) ((word) | 16)
+#define MUTEX_UNLOCK(word)      ((word) & ~(8 | 16))
+
+void lock(atomic_int *futex) {
+  int word, cs;
+  for (int i = 0; i < 4; ++i) {
+    word = 0;
+    if (atomic_compare_exchange_strong_explicit(
+            futex, &word, 1, memory_order_acquire, memory_order_acquire))
+      return;
+  }
+  if (word == 1)
+    word = atomic_exchange_explicit(futex, 2, memory_order_acquire);
+  while (word > 0) {
+    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs);
+#if USE == FUTEX || USE == FUTEX_SHARED
+    cosmo_futex_wait(
+        futex, 2,
+        USE == FUTEX_SHARED ? PTHREAD_PROCESS_SHARED : PTHREAD_PROCESS_PRIVATE,
+        0, 0);
+#else
+    pthread_yield_np();
+#endif
+    pthread_setcancelstate(cs, 0);
+    word = atomic_exchange_explicit(futex, 2, memory_order_acquire);
+  }
+}
+
+void unlock(atomic_int *futex) {
+  int word = atomic_fetch_sub_explicit(futex, 1, memory_order_release);
+  if (word == 2) {
+    atomic_store_explicit(futex, 0, memory_order_release);
+#if USE == FUTEX || USE == FUTEX_SHARED
+    cosmo_futex_wake(
+        futex, 1,
+        USE == FUTEX_SHARED ? PTHREAD_PROCESS_SHARED : PTHREAD_PROCESS_PRIVATE);
+#endif
+  }
+}
+
+int g_chores;
+atomic_int g_lock;
+pthread_mutex_t g_locker;
+pthread_rwlock_t g_rwlocker;
+
+void *worker(void *arg) {
+  for (int i = 0; i < ITERATIONS; ++i) {
+#if USE == POSIX || USE == POSIX_RECURSIVE
+    pthread_mutex_lock(&g_locker);
+    ++g_chores;
+    pthread_mutex_unlock(&g_locker);
+#elif USE == RWLOCK || USE == RWLOCK_SHARED
+    pthread_rwlock_wrlock(&g_rwlocker);
+    ++g_chores;
+    pthread_rwlock_unlock(&g_rwlocker);
+#else
+    lock(&g_lock);
+    ++g_chores;
+    unlock(&g_lock);
+#endif
+  }
+  return 0;
+}
+
+struct timeval tub(struct timeval a, struct timeval b) {
+  a.tv_sec -= b.tv_sec;
+  if (a.tv_usec < b.tv_usec) {
+    a.tv_usec += 1000000;
+    a.tv_sec--;
+  }
+  a.tv_usec -= b.tv_usec;
+  return a;
+}
+
+long tomicros(struct timeval x) {
+  return x.tv_sec * 1000000ul + x.tv_usec;
+}
+
+int main() {
+  struct timeval start;
+  gettimeofday(&start, 0);
+
+  pthread_mutexattr_t attr;
+  pthread_mutexattr_init(&attr);
+#if USE == POSIX_RECURSIVE
+  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+#else
+  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
+#endif
+  pthread_mutex_init(&g_locker, &attr);
+  pthread_mutexattr_destroy(&attr);
+
+  pthread_rwlockattr_t rwattr;
+  pthread_rwlockattr_init(&rwattr);
+#if USE == RWLOCK_SHARED
+  pthread_rwlockattr_setpshared(&rwattr, PTHREAD_PROCESS_SHARED);
+#endif
+  pthread_rwlock_init(&g_rwlocker, &rwattr);
+  pthread_rwlockattr_destroy(&rwattr);
+
+  pthread_t th[THREADS];
+  for (int i = 0; i < THREADS; ++i)
+    pthread_create(&th[i], 0, worker, 0);
+  for (int i = 0; i < THREADS; ++i)
+    pthread_join(th[i], 0);
+  assert(g_chores == THREADS * ITERATIONS);
+
+  struct rusage ru;
+  struct timeval end;
+  gettimeofday(&end, 0);
+  getrusage(RUSAGE_SELF, &ru);
+  printf("%16ld us real\n"
+         "%16ld us user\n"
+         "%16ld us sys\n",
+         tomicros(tub(end, start)),  //
+         tomicros(ru.ru_utime),      //
+         tomicros(ru.ru_stime));
+
+  pthread_rwlock_destroy(&g_rwlocker);
+  pthread_mutex_destroy(&g_locker);
+
+#ifdef __COSMOPOLITAN__
+  CheckForMemoryLeaks();
+#endif
+}
diff --git a/test/libc/thread/makecontext_test.c b/test/libc/thread/makecontext_test.c
index 629dc07b8..e7d2a69d1 100644
--- a/test/libc/thread/makecontext_test.c
+++ b/test/libc/thread/makecontext_test.c
@@ -21,6 +21,7 @@
 #include "libc/dce.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
+#include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/nt/createfile.h"
 #include "libc/nt/enum/accessmask.h"
@@ -36,7 +37,6 @@
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
 #include "libc/x/x.h"
-#include "third_party/libcxx/math.h"
 
 bool gotsome;
 ucontext_t uc, goback;
diff --git a/test/libc/thread/nsync_test.c b/test/libc/thread/nsync_test.c
index d781c5243..ac2d64514 100644
--- a/test/libc/thread/nsync_test.c
+++ b/test/libc/thread/nsync_test.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
+#include "libc/sysv/consts/clock.h"
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
 #include "third_party/nsync/cv.h"
@@ -34,7 +35,8 @@ int Put(long v, nsync_time abs_deadline) {
   int err, added = 0, wake = 0;
   nsync_mu_lock(&mu);
   while (count == limit) {
-    if ((err = nsync_cv_wait_with_deadline(&non_full, &mu, abs_deadline, 0))) {
+    if ((err = nsync_cv_wait_with_deadline(&non_full, &mu, CLOCK_REALTIME,
+                                           abs_deadline, 0))) {
       ASSERT_EQ(ETIMEDOUT, err);
       ASSERT_NE(0, nsync_time_cmp(nsync_time_no_deadline, abs_deadline));
     }
@@ -59,7 +61,8 @@ long Get(nsync_time abs_deadline) {
   long err, v = 0;
   nsync_mu_lock(&mu);
   while (!count) {
-    if ((err = nsync_cv_wait_with_deadline(&non_empty, &mu, abs_deadline, 0))) {
+    if ((err = nsync_cv_wait_with_deadline(&non_empty, &mu, CLOCK_REALTIME,
+                                           abs_deadline, 0))) {
       ASSERT_EQ(ETIMEDOUT, err);
       ASSERT_NE(0, nsync_time_cmp(nsync_time_no_deadline, abs_deadline));
     }
diff --git a/test/libc/thread/pthread_atfork_test.c b/test/libc/thread/pthread_atfork_test.c
index dc977b9aa..8a6d5d4d0 100644
--- a/test/libc/thread/pthread_atfork_test.c
+++ b/test/libc/thread/pthread_atfork_test.c
@@ -16,9 +16,13 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
+#include "libc/intrin/atomic.h"
+#include "libc/intrin/kprintf.h"
 #include "libc/mem/gc.h"
+#include "libc/mem/leaks.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
@@ -45,11 +49,9 @@ void *ForceThreadingMode(void *arg) {
 }
 
 TEST(pthread_atfork, test) {
-  __enable_threads();
   SPAWN(fork);
   ASSERT_EQ(0, pthread_atfork(prepare1, parent1, child1));
   ASSERT_EQ(0, pthread_atfork(prepare2, parent2, child2));
-  flockfile(stdout);
   SPAWN(fork);
   flockfile(stdout);
   ASSERT_STREQ("prepare2", A[0]);
@@ -58,7 +60,6 @@ TEST(pthread_atfork, test) {
   ASSERT_STREQ("child2", A[3]);
   funlockfile(stdout);
   EXITS(0);
-  funlockfile(stdout);
   ASSERT_STREQ("prepare2", A[0]);
   ASSERT_STREQ("prepare1", A[1]);
   ASSERT_STREQ("parent1", A[2]);
@@ -66,7 +67,7 @@ TEST(pthread_atfork, test) {
   EXITS(0);
 }
 
-pthread_mutex_t mu;
+pthread_mutex_t mu = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
 
 void mu_lock(void) {
   pthread_mutex_lock(&mu);
@@ -77,7 +78,7 @@ void mu_unlock(void) {
 }
 
 void mu_wipe(void) {
-  pthread_mutex_init(&mu, 0);
+  pthread_mutex_wipe_np(&mu);
 }
 
 void *Worker(void *arg) {
@@ -99,14 +100,14 @@ void *Worker(void *arg) {
 }
 
 TEST(pthread_atfork, fork_exit_torture) {
+  if (!IsFreebsd())
+    return;
   mu_wipe();
   pthread_atfork(mu_lock, mu_unlock, mu_wipe);
   int i, n = 4;
   pthread_t *t = gc(malloc(sizeof(pthread_t) * n));
-  for (i = 0; i < n; ++i) {
+  for (i = 0; i < n; ++i)
     ASSERT_EQ(0, pthread_create(t + i, 0, Worker, 0));
-  }
-  for (i = 0; i < n; ++i) {
+  for (i = 0; i < n; ++i)
     ASSERT_EQ(0, pthread_join(t[i], 0));
-  }
 }
diff --git a/test/libc/thread/pthread_cancel_deferred_cond_test.c b/test/libc/thread/pthread_cancel_deferred_cond_test.c
new file mode 100644
index 000000000..4bba81a18
--- /dev/null
+++ b/test/libc/thread/pthread_cancel_deferred_cond_test.c
@@ -0,0 +1,62 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <errno.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int got_cleanup;
+pthread_cond_t cv;
+pthread_mutex_t mu;
+
+void cleanup(void* arg) {
+  got_cleanup = 1;
+}
+
+void* worker(void* arg) {
+  pthread_cleanup_push(cleanup, 0);
+  if (pthread_mutex_lock(&mu))
+    _Exit(11);
+  pthread_cond_wait(&cv, &mu);
+  _Exit(12);
+  pthread_cleanup_pop(0);
+}
+
+int main(int argc, char* argv[]) {
+  void* rc;
+  pthread_t th;
+  pthread_mutexattr_t at;
+  pthread_mutexattr_init(&at);
+  pthread_mutexattr_settype(&at, PTHREAD_MUTEX_DEFAULT);
+  pthread_mutex_init(&mu, &at);
+  pthread_mutexattr_destroy(&at);
+  pthread_cond_init(&cv, 0);
+  if (pthread_create(&th, 0, worker, 0))
+    return 2;
+  if (pthread_cancel(th))
+    return 3;
+  if (pthread_join(th, &rc))
+    return 4;
+  if (rc != PTHREAD_CANCELED)
+    return 5;
+  if (!got_cleanup)
+    return 6;
+  if (pthread_mutex_trylock(&mu) != EBUSY)
+    return 7;
+  pthread_mutex_destroy(&mu);
+  pthread_cond_destroy(&cv);
+}
diff --git a/test/libc/thread/pthread_cancel_masked_cond_test.c b/test/libc/thread/pthread_cancel_masked_cond_test.c
new file mode 100644
index 000000000..479ebf48d
--- /dev/null
+++ b/test/libc/thread/pthread_cancel_masked_cond_test.c
@@ -0,0 +1,43 @@
+#include <errno.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int got_cleanup;
+pthread_cond_t cv = PTHREAD_COND_INITIALIZER;
+pthread_mutex_t mu = PTHREAD_MUTEX_INITIALIZER;
+
+void cleanup(void* arg) {
+  got_cleanup = 1;
+}
+
+void* worker(void* arg) {
+  if (pthread_setcancelstate(PTHREAD_CANCEL_MASKED, 0))
+    _Exit(10);
+  pthread_cleanup_push(cleanup, 0);
+  if (pthread_mutex_lock(&mu))
+    _Exit(11);
+  if (pthread_cond_wait(&cv, &mu) != ECANCELED)
+    _Exit(12);
+  if (pthread_mutex_trylock(&mu) != EBUSY)
+    _Exit(13);
+  if (pthread_mutex_unlock(&mu))
+    _Exit(14);
+  pthread_cleanup_pop(0);
+  return (void*)123;
+}
+
+int main(int argc, char* argv[]) {
+  void* rc;
+  pthread_t th;
+  if (pthread_create(&th, 0, worker, 0))
+    return 2;
+  if (pthread_cancel(th))
+    return 3;
+  if (pthread_join(th, &rc))
+    return 4;
+  if (rc != (void*)123)
+    return 5;
+  if (got_cleanup)
+    return 6;
+}
diff --git a/test/libc/thread/pthread_cancel_masked_read_test.c b/test/libc/thread/pthread_cancel_masked_read_test.c
new file mode 100644
index 000000000..1608df770
--- /dev/null
+++ b/test/libc/thread/pthread_cancel_masked_read_test.c
@@ -0,0 +1,41 @@
+#include <errno.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int pfds[2];
+int got_cleanup;
+
+void cleanup(void* arg) {
+  got_cleanup = 1;
+}
+
+void* worker(void* arg) {
+  char buf[8];
+  if (pthread_setcancelstate(PTHREAD_CANCEL_MASKED, 0))
+    _Exit(10);
+  pthread_cleanup_push(cleanup, 0);
+  if (read(pfds[0], buf, sizeof(buf)) != -1)
+    _Exit(11);
+  if (errno != ECANCELED)
+    _Exit(12);
+  pthread_cleanup_pop(0);
+  return (void*)123;
+}
+
+int main(int argc, char* argv[]) {
+  void* rc;
+  pthread_t th;
+  if (pipe(pfds))
+    return 1;
+  if (pthread_create(&th, 0, worker, 0))
+    return 2;
+  if (pthread_cancel(th))
+    return 3;
+  if (pthread_join(th, &rc))
+    return 4;
+  if (rc != (void*)123)
+    return 5;
+  if (got_cleanup)
+    return 7;
+}
diff --git a/test/libc/thread/pthread_cancel_test.c b/test/libc/thread/pthread_cancel_test.c
index c43aacc04..06fb5093e 100644
--- a/test/libc/thread/pthread_cancel_test.c
+++ b/test/libc/thread/pthread_cancel_test.c
@@ -19,6 +19,7 @@
 #include "libc/atomic.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
+#include "libc/calls/struct/sigaltstack.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
@@ -27,6 +28,7 @@
 #include "libc/nexgen32e/nexgen32e.h"
 #include "libc/runtime/internal.h"
 #include "libc/runtime/runtime.h"
+#include "libc/runtime/sysconf.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
@@ -40,6 +42,8 @@ atomic_int gotcleanup;
 
 void SetUpOnce(void) {
   testlib_enable_tmp_setup_teardown();
+  pthread_mutex_init(&mu, 0);
+  pthread_cond_init(&cv, 0);
 }
 
 void SetUp(void) {
@@ -97,8 +101,6 @@ TEST(pthread_cancel, synchronous) {
 TEST(pthread_cancel, synchronous_deferred) {
   void *rc;
   pthread_t th;
-  if (!IsWindows())
-    return;
   ASSERT_SYS(0, 0, pipe(pfds));
   ASSERT_EQ(0, pthread_create(&th, 0, Worker, 0));
   while (!ready)
@@ -190,6 +192,7 @@ TEST(pthread_cancel, condDeferredWait_reacquiresMutex) {
   ASSERT_EQ(0, pthread_join(th, &rc));
   ASSERT_EQ(PTHREAD_CANCELED, rc);
   ASSERT_EQ(EBUSY, pthread_mutex_trylock(&mu));
+  ASSERT_EQ(0, pthread_mutex_consistent(&mu));
   ASSERT_EQ(0, pthread_mutex_unlock(&mu));
 }
 
@@ -202,6 +205,7 @@ TEST(pthread_cancel, condDeferredWaitDelayed) {
   ASSERT_EQ(0, pthread_join(th, &rc));
   ASSERT_EQ(PTHREAD_CANCELED, rc);
   ASSERT_EQ(EBUSY, pthread_mutex_trylock(&mu));
+  ASSERT_EQ(0, pthread_mutex_consistent(&mu));
   ASSERT_EQ(0, pthread_mutex_unlock(&mu));
 }
 
diff --git a/test/libc/thread/pthread_cond_timedwait_test.c b/test/libc/thread/pthread_cond_timedwait_test.c
new file mode 100644
index 000000000..57ed46e38
--- /dev/null
+++ b/test/libc/thread/pthread_cond_timedwait_test.c
@@ -0,0 +1,64 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+#include "libc/errno.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/testlib/testlib.h"
+#include "libc/thread/thread.h"
+#include "libc/thread/thread2.h"
+
+TEST(pthread_cond_timedwait, real) {
+  pthread_cond_t cv;
+  pthread_mutex_t mu;
+  pthread_condattr_t ca;
+  ASSERT_EQ(0, pthread_condattr_init(&ca));
+  ASSERT_EQ(0, pthread_condattr_setclock(&ca, CLOCK_REALTIME));
+  ASSERT_EQ(0, pthread_cond_init(&cv, &ca));
+  ASSERT_EQ(0, pthread_condattr_destroy(&ca));
+  ASSERT_EQ(0, pthread_mutex_init(&mu, 0));
+  ASSERT_EQ(0, pthread_mutex_lock(&mu));
+  struct timespec start = timespec_real();
+  struct timespec deadline = timespec_add(start, timespec_frommillis(100));
+  ASSERT_EQ(ETIMEDOUT, pthread_cond_timedwait(&cv, &mu, &deadline));
+  struct timespec end = timespec_real();
+  ASSERT_GE(timespec_tomillis(timespec_sub(end, start)), 100);
+  ASSERT_EQ(0, pthread_mutex_unlock(&mu));
+  ASSERT_EQ(0, pthread_mutex_destroy(&mu));
+  ASSERT_EQ(0, pthread_cond_destroy(&cv));
+}
+
+TEST(pthread_cond_timedwait, mono) {
+  pthread_cond_t cv;
+  pthread_mutex_t mu;
+  pthread_condattr_t ca;
+  ASSERT_EQ(0, pthread_condattr_init(&ca));
+  ASSERT_EQ(0, pthread_condattr_setclock(&ca, CLOCK_MONOTONIC));
+  ASSERT_EQ(0, pthread_cond_init(&cv, &ca));
+  ASSERT_EQ(0, pthread_condattr_destroy(&ca));
+  ASSERT_EQ(0, pthread_mutex_init(&mu, 0));
+  ASSERT_EQ(0, pthread_mutex_lock(&mu));
+  struct timespec start = timespec_mono();
+  struct timespec deadline = timespec_add(start, timespec_frommillis(100));
+  ASSERT_EQ(ETIMEDOUT, pthread_cond_timedwait(&cv, &mu, &deadline));
+  struct timespec end = timespec_mono();
+  ASSERT_GE(timespec_tomillis(timespec_sub(end, start)), 100);
+  ASSERT_EQ(0, pthread_mutex_unlock(&mu));
+  ASSERT_EQ(0, pthread_mutex_destroy(&mu));
+  ASSERT_EQ(0, pthread_cond_destroy(&cv));
+}
diff --git a/test/libc/thread/pthread_create_inherit_mask_test.c b/test/libc/thread/pthread_create_inherit_mask_test.c
new file mode 100644
index 000000000..58a0460f7
--- /dev/null
+++ b/test/libc/thread/pthread_create_inherit_mask_test.c
@@ -0,0 +1,30 @@
+#include <limits.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdlib.h>
+
+sigset_t parent_mask;
+sigset_t child_mask;
+
+void* worker(void* arg) {
+  if (pthread_sigmask(SIG_SETMASK, 0, &child_mask))
+    _Exit(1);
+  return 0;
+}
+
+int main(int argc, char* argv[]) {
+  pthread_t th;
+  sigemptyset(&parent_mask);
+  sigaddset(&parent_mask, SIGSYS);
+  sigaddset(&parent_mask, SIGUSR2);
+  sigaddset(&parent_mask, SIGWINCH);
+  if (pthread_sigmask(SIG_SETMASK, &parent_mask, 0))
+    return 1;
+  if (pthread_create(&th, 0, worker, 0))
+    return 2;
+  if (pthread_join(th, 0))
+    return 3;
+  for (int i = 1; i <= _NSIG; ++i)
+    if (sigismember(&parent_mask, i) != sigismember(&child_mask, i))
+      return 4;
+}
diff --git a/test/libc/thread/pthread_create_test.c b/test/libc/thread/pthread_create_test.c
index ad680cd10..92b6c28db 100644
--- a/test/libc/thread/pthread_create_test.c
+++ b/test/libc/thread/pthread_create_test.c
@@ -21,13 +21,14 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sched_param.h"
 #include "libc/calls/struct/sigaction.h"
-#include "libc/calls/struct/sigaltstack.h"
 #include "libc/calls/struct/siginfo.h"
+#include "libc/calls/struct/sigset.h"
+#include "libc/cosmo.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/nexgen32e.h"
@@ -35,21 +36,42 @@
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
 #include "libc/runtime/sysconf.h"
+#include "libc/stdio/rand.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sched.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/consts/ss.h"
+#include "libc/testlib/benchmark.h"
 #include "libc/testlib/ezbench.h"
+#include "libc/testlib/manystack.h"
 #include "libc/testlib/subprocess.h"
 #include "libc/testlib/testlib.h"
 #include "libc/thread/posixthread.internal.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/thread2.h"
 
+// test ability of user to override pthread mutex api
+int pthread_mutex_lock(pthread_mutex_t *mutex) {
+  abort();
+}
+int pthread_mutex_unlock(pthread_mutex_t *mutex) {
+  abort();
+}
+int pthread_mutex_trylock(pthread_mutex_t *mutex) {
+  abort();
+}
+int pthread_mutex_wipe_np(pthread_mutex_t *mutex) {
+  abort();
+}
+
 void OnUsr1(int sig, siginfo_t *si, void *vctx) {
 }
 
+void SetUpOnce(void) {
+  cosmo_stack_setmaxstacks((_rand64() & 7) - 1);
+}
+
 void SetUp(void) {
   struct sigaction sig = {.sa_sigaction = OnUsr1, .sa_flags = SA_SIGINFO};
   sigaction(SIGUSR1, &sig, 0);
@@ -280,11 +302,60 @@ static void CreateDetached(void) {
   ASSERT_EQ(0, pthread_attr_destroy(&attr));
 }
 
-BENCH(pthread_create, bench) {
-  EZBENCH2("CreateJoin", donothing, CreateJoin());
-  EZBENCH2("CreateDetach", donothing, CreateDetach());
-  EZBENCH2("CreateDetached", donothing, CreateDetached());
-  while (!pthread_orphan_np()) {
-    _pthread_decimate();
+#define LAUNCHES  10
+#define LAUNCHERS 10
+
+errno_t pthread_create2(pthread_t *thread, const pthread_attr_t *attr,
+                        void *(*start_routine)(void *), void *arg) {
+  for (int i = 1;; i <<= 1) {
+    errno_t err = pthread_create(thread, attr, start_routine, arg);
+    if (err != EAGAIN)
+      return err;
+    usleep(i);
   }
 }
+
+static void *CreateDetachedParallelThreads(void *arg) {
+  for (int i = 0; i < LAUNCHES; ++i)
+    CreateDetached();
+  return 0;
+}
+
+static void CreateDetachedParallel(void) {
+  pthread_t th[LAUNCHERS];
+  for (int i = 0; i < LAUNCHERS; ++i)
+    ASSERT_EQ(0, pthread_create2(&th[i], 0, CreateDetachedParallelThreads, 0));
+  for (int i = 0; i < LAUNCHERS; ++i)
+    ASSERT_EQ(0, pthread_join(th[i], 0));
+}
+
+static void *CreateJoinParallelThreads(void *arg) {
+  for (int i = 0; i < LAUNCHES; ++i)
+    CreateJoin();
+  return 0;
+}
+
+static void CreateJoinParallel(void) {
+  pthread_t th[LAUNCHERS];
+  for (int i = 0; i < LAUNCHERS; ++i)
+    ASSERT_EQ(0, pthread_create2(&th[i], 0, CreateJoinParallelThreads, 0));
+  for (int i = 0; i < LAUNCHERS; ++i)
+    ASSERT_EQ(0, pthread_join(th[i], 0));
+}
+
+TEST(pthread_create, bench) {
+  kprintf("cosmo_stack_getmaxstacks() = %d\n", cosmo_stack_getmaxstacks());
+  pthread_t msh = manystack_start();
+  BENCHMARK(100, 1, CreateJoin());
+  BENCHMARK(100, 1, CreateDetach());
+  usleep(10000);
+  pthread_decimate_np();
+  BENCHMARK(100, 1, CreateDetached());
+  usleep(10000);
+  pthread_decimate_np();
+  BENCHMARK(1, LAUNCHERS + LAUNCHERS * LAUNCHES, CreateJoinParallel());
+  BENCHMARK(1, LAUNCHERS + LAUNCHERS * LAUNCHES, CreateDetachedParallel());
+  manystack_stop(msh);
+  while (!pthread_orphan_np())
+    pthread_decimate_np();
+}
diff --git a/test/libc/thread/pthread_detach_test.c b/test/libc/thread/pthread_detach_test.c
index bfbb9c9c5..d5f7d80a3 100644
--- a/test/libc/thread/pthread_detach_test.c
+++ b/test/libc/thread/pthread_detach_test.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/testlib/testlib.h"
@@ -50,9 +50,8 @@ TEST(pthread_detach, testCreateReturn) {
   pthread_t id;
   ASSERT_EQ(0, pthread_create(&id, 0, Increment, 0));
   ASSERT_EQ(0, pthread_detach(id));
-  while (!pthread_orphan_np()) {
-    _pthread_decimate();
-  }
+  while (!pthread_orphan_np())
+    pthread_decimate_np();
 }
 
 TEST(pthread_detach, testDetachUponCreation) {
@@ -62,7 +61,6 @@ TEST(pthread_detach, testDetachUponCreation) {
   ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED));
   ASSERT_EQ(0, pthread_create(&th, &attr, Increment, 0));
   ASSERT_EQ(0, pthread_attr_destroy(&attr));
-  while (!pthread_orphan_np()) {
-    _pthread_decimate();
-  }
+  while (!pthread_orphan_np())
+    pthread_decimate_np();
 }
diff --git a/test/libc/thread/pthread_exit_test.c b/test/libc/thread/pthread_exit_test.c
index 2855702ae..133a81cab 100644
--- a/test/libc/thread/pthread_exit_test.c
+++ b/test/libc/thread/pthread_exit_test.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/cxxabi.h"
-#include "libc/intrin/cxaatexit.internal.h"
+#include "libc/intrin/cxaatexit.h"
 #include "libc/runtime/runtime.h"
 #include "libc/testlib/subprocess.h"
 #include "libc/testlib/testlib.h"
diff --git a/test/libc/thread/pthread_getunique_np_test.c b/test/libc/thread/pthread_getunique_np_test.c
new file mode 100644
index 000000000..f41c78975
--- /dev/null
+++ b/test/libc/thread/pthread_getunique_np_test.c
@@ -0,0 +1,34 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/testlib/testlib.h"
+#include "libc/thread/thread.h"
+
+void *wut(void *arg) {
+  pthread_id_np_t tid;
+  pthread_getunique_np(pthread_self(), &tid);
+  ASSERT_EQ(gettid(), tid);
+  return 0;
+}
+
+TEST(pthread_getunique_np, test) {
+  pthread_t id;
+  ASSERT_EQ(0, pthread_create(&id, 0, wut, (void *)1));
+  ASSERT_EQ(0, pthread_join(id, 0));
+}
diff --git a/test/libc/thread/pthread_kill_test.c b/test/libc/thread/pthread_kill_test.c
index 25a8f0b3c..2ac31f4be 100644
--- a/test/libc/thread/pthread_kill_test.c
+++ b/test/libc/thread/pthread_kill_test.c
@@ -193,8 +193,6 @@ void *SocketAcceptWorker(void *arg) {
 }
 
 TEST(pthread_kill, canInterruptSocketAcceptOperation) {
-  if (IsWindows())
-    return;  // TODO(jart): BAH
   pthread_t t;
   struct sigaction oldsa;
   struct sigaction sa = {.sa_handler = OnSig};
@@ -261,7 +259,6 @@ void *CpuWorker(void *arg) {
 }
 
 TEST(pthread_kill, canAsynchronouslyRunHandlerInsideTargetThread) {
-  ASSERT_NE(0, __get_tls()->tib_tid);
   pthread_t t;
   struct sigaction oldsa;
   struct sigaction sa = {.sa_handler = OnSigAsync};
@@ -275,7 +272,6 @@ TEST(pthread_kill, canAsynchronouslyRunHandlerInsideTargetThread) {
   ASSERT_TRUE(exited_original_loop);
   ASSERT_SYS(0, 0, sigaction(SIGUSR1, &oldsa, 0));
   ASSERT_EQ(0, gotsig);
-  ASSERT_NE(0, __get_tls()->tib_tid);
 }
 
 volatile int is_having_fun;
@@ -289,7 +285,6 @@ void *FunWorker(void *arg) {
 }
 
 TEST(pthread_kill, defaultThreadSignalHandlerWillKillWholeProcess) {
-  ASSERT_NE(0, __get_tls()->tib_tid);
   SPAWN(fork);
   pthread_t t;
   ASSERT_EQ(0, pthread_create(&t, 0, FunWorker, 0));
@@ -299,7 +294,6 @@ TEST(pthread_kill, defaultThreadSignalHandlerWillKillWholeProcess) {
   for (;;)
     sched_yield();
   TERMS(SIGKILL);
-  ASSERT_NE(0, __get_tls()->tib_tid);
 }
 
 void *SuspendWorker(void *arg) {
@@ -310,7 +304,6 @@ void *SuspendWorker(void *arg) {
 }
 
 TEST(pthread_kill, canInterruptSigsuspend) {
-  ASSERT_NE(0, __get_tls()->tib_tid);
   int tid;
   void *res;
   pthread_t t;
diff --git a/test/libc/thread/pthread_rwlock_rdlock_test.c b/test/libc/thread/pthread_rwlock_rdlock_test.c
index e7ad11cc3..4fba1f503 100644
--- a/test/libc/thread/pthread_rwlock_rdlock_test.c
+++ b/test/libc/thread/pthread_rwlock_rdlock_test.c
@@ -17,26 +17,55 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/atomic.h"
+#include "libc/calls/calls.h"
+#include "libc/intrin/atomic.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
+#include "libc/stdalign.h"
+#include "libc/stdio/rand.h"
 #include "libc/testlib/testlib.h"
 #include "libc/thread/thread.h"
 
-#define ITERATIONS 50000
 #define READERS    8
 #define WRITERS    2
+#define ITERATIONS 1000
 
-atomic_int reads;
-atomic_int writes;
+atomic_bool done;
+alignas(128) int foo;
+alignas(128) int bar;
 pthread_rwlock_t lock;
+pthread_rwlockattr_t attr;
 pthread_barrier_t barrier;
 
+void delay(int k) {
+  int n = rand() % k;
+  for (volatile int i = 0; i < n; ++i) {
+  }
+}
+
+void SetUp(void) {
+  ASSERT_EQ(0, pthread_rwlockattr_init(&attr));
+  ASSERT_EQ(0, pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED));
+  ASSERT_EQ(0, pthread_rwlock_init(&lock, &attr));
+  ASSERT_EQ(0, pthread_rwlockattr_destroy(&attr));
+}
+
+void TearDown(void) {
+  ASSERT_EQ(0, pthread_rwlock_destroy(&lock));
+}
+
 void *Reader(void *arg) {
   pthread_barrier_wait(&barrier);
-  for (int i = 0; i < ITERATIONS; ++i) {
+  while (!atomic_load_explicit(&done, memory_order_relaxed)) {
     ASSERT_EQ(0, pthread_rwlock_rdlock(&lock));
-    ++reads;
+    // cosmo_trace_begin("reader");
+    int x = foo;
+    usleep(1);  // delay(100000);
+    int y = bar;
+    ASSERT_EQ(x, y);
+    // cosmo_trace_end("reader");
     ASSERT_EQ(0, pthread_rwlock_unlock(&lock));
+    usleep(1);  // delay(100000);
   }
   return 0;
 }
@@ -45,9 +74,15 @@ void *Writer(void *arg) {
   pthread_barrier_wait(&barrier);
   for (int i = 0; i < ITERATIONS; ++i) {
     ASSERT_EQ(0, pthread_rwlock_wrlock(&lock));
-    ++writes;
+    // cosmo_trace_begin("writer");
+    ++foo;
+    delay(10);
+    ++bar;
+    // cosmo_trace_end("writer");
     ASSERT_EQ(0, pthread_rwlock_unlock(&lock));
+    delay(10);
   }
+  done = true;
   return 0;
 }
 
@@ -55,14 +90,12 @@ TEST(pthread_rwlock_rdlock, test) {
   int i;
   pthread_t *t = gc(malloc(sizeof(pthread_t) * (READERS + WRITERS)));
   ASSERT_EQ(0, pthread_barrier_init(&barrier, 0, READERS + WRITERS));
-  for (i = 0; i < READERS + WRITERS; ++i) {
+  for (i = 0; i < READERS + WRITERS; ++i)
     ASSERT_SYS(0, 0,
                pthread_create(t + i, 0, i < READERS ? Reader : Writer, 0));
-  }
-  for (i = 0; i < READERS + WRITERS; ++i) {
+  for (i = 0; i < READERS + WRITERS; ++i)
     EXPECT_SYS(0, 0, pthread_join(t[i], 0));
-  }
-  EXPECT_EQ(READERS * ITERATIONS, reads);
-  EXPECT_EQ(WRITERS * ITERATIONS, writes);
+  EXPECT_EQ(WRITERS * ITERATIONS, foo);
+  EXPECT_EQ(WRITERS * ITERATIONS, bar);
   ASSERT_EQ(0, pthread_barrier_destroy(&barrier));
 }
diff --git a/test/libc/intrin/pthread_spin_lock_test.c b/test/libc/thread/pthread_spin_lock_test.c
similarity index 100%
rename from test/libc/intrin/pthread_spin_lock_test.c
rename to test/libc/thread/pthread_spin_lock_test.c
diff --git a/test/libc/thread/sem_timedwait_test.c b/test/libc/thread/sem_timedwait_test.c
index d1fedb251..8ba2393f0 100644
--- a/test/libc/thread/sem_timedwait_test.c
+++ b/test/libc/thread/sem_timedwait_test.c
@@ -129,7 +129,7 @@ TEST(sem_timedwait, threads) {
 
 TEST(sem_timedwait, processes) {
   int i, r, rc, n = 4, pshared = 1;
-  sem_t *sm = _mapshared(__granularity()), *s[2] = {sm, sm + 1};
+  sem_t *sm = _mapshared(getpagesize()), *s[2] = {sm, sm + 1};
   ASSERT_SYS(0, 0, sem_init(s[0], pshared, 0));
   ASSERT_SYS(0, 0, sem_init(s[1], pshared, 0));
   for (i = 0; i < n; ++i) {
@@ -163,5 +163,5 @@ TEST(sem_timedwait, processes) {
   ASSERT_EQ(0, r);
   ASSERT_SYS(0, 0, sem_destroy(s[1]));
   ASSERT_SYS(0, 0, sem_destroy(s[0]));
-  ASSERT_SYS(0, 0, munmap(sm, __granularity()));
+  ASSERT_SYS(0, 0, munmap(sm, getpagesize()));
 }
diff --git a/test/libc/thread/setitimer_test.c b/test/libc/thread/setitimer_test.c
index 6ab5d42d0..061faf459 100644
--- a/test/libc/thread/setitimer_test.c
+++ b/test/libc/thread/setitimer_test.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/sysv/consts/itimer.h"
 #include "libc/atomic.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/itimerval.h"
@@ -26,10 +27,8 @@
 #include "libc/calls/ucontext.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
 #include "libc/runtime/runtime.h"
-#include "libc/sysv/consts/itimer.h"
 #include "libc/sysv/consts/sa.h"
 #include "libc/sysv/consts/sicode.h"
 #include "libc/sysv/consts/sig.h"
diff --git a/test/libc/time/BUILD.mk b/test/libc/time/BUILD.mk
index 937b2d09e..092444a95 100644
--- a/test/libc/time/BUILD.mk
+++ b/test/libc/time/BUILD.mk
@@ -28,7 +28,8 @@ TEST_LIBC_TIME_DIRECTDEPS =				\
 	LIBC_SYSV					\
 	LIBC_TESTLIB					\
 	LIBC_X						\
-	THIRD_PARTY_TZ
+	THIRD_PARTY_MUSL				\
+	THIRD_PARTY_TZ					\
 
 TEST_LIBC_TIME_DEPS :=					\
 	$(call uniq,$(foreach x,$(TEST_LIBC_TIME_DIRECTDEPS),$($(x))))
diff --git a/test/libc/tinymath/BUILD.mk b/test/libc/tinymath/BUILD.mk
index ef755a29d..4b304dc67 100644
--- a/test/libc/tinymath/BUILD.mk
+++ b/test/libc/tinymath/BUILD.mk
@@ -3,14 +3,21 @@
 
 PKGS += TEST_LIBC_TINYMATH
 
-TEST_LIBC_TINYMATH_SRCS := $(wildcard test/libc/tinymath/*.c)
+TEST_LIBC_TINYMATH_SRCS_C := $(wildcard test/libc/tinymath/*.c)
+TEST_LIBC_TINYMATH_SRCS_CC := $(wildcard test/libc/tinymath/*.cc)
 TEST_LIBC_TINYMATH_SRCS_TEST = $(filter %_test.c,$(TEST_LIBC_TINYMATH_SRCS))
 
+TEST_LIBC_TINYMATH_SRCS =					\
+	$(TEST_LIBC_TINYMATH_SRCS_C)				\
+	$(TEST_LIBC_TINYMATH_SRCS_CC)
+
 TEST_LIBC_TINYMATH_OBJS =					\
-	$(TEST_LIBC_TINYMATH_SRCS:%.c=o/$(MODE)/%.o)
+	$(TEST_LIBC_TINYMATH_SRCS_C:%.c=o/$(MODE)/%.o)		\
+	$(TEST_LIBC_TINYMATH_SRCS_CC:%.cc=o/$(MODE)/%.o)
 
 TEST_LIBC_TINYMATH_COMS =					\
-	$(TEST_LIBC_TINYMATH_SRCS:%.c=o/$(MODE)/%)
+	$(TEST_LIBC_TINYMATH_SRCS_C:%.c=o/$(MODE)/%)		\
+	$(TEST_LIBC_TINYMATH_SRCS_CC:%.cc=o/$(MODE)/%)
 
 TEST_LIBC_TINYMATH_BINS =					\
 	$(TEST_LIBC_TINYMATH_COMS)				\
@@ -26,19 +33,23 @@ TEST_LIBC_TINYMATH_DIRECTDEPS =					\
 	LIBC_CALLS						\
 	LIBC_FMT						\
 	LIBC_INTRIN						\
+	LIBC_LOG						\
 	LIBC_MEM						\
 	LIBC_NEXGEN32E						\
-	LIBC_STDIO						\
 	LIBC_RUNTIME						\
+	LIBC_STDIO						\
 	LIBC_STR						\
 	LIBC_SYSV						\
 	LIBC_TESTLIB						\
 	LIBC_TINYMATH						\
 	LIBC_X							\
 	THIRD_PARTY_COMPILER_RT					\
-	THIRD_PARTY_GDTOA					\
 	THIRD_PARTY_COMPILER_RT					\
-	THIRD_PARTY_DOUBLECONVERSION
+	THIRD_PARTY_DOUBLECONVERSION				\
+	THIRD_PARTY_GDTOA					\
+	THIRD_PARTY_LIBCXX					\
+	THIRD_PARTY_LIBCXXABI					\
+	THIRD_PARTY_LIBUNWIND					\
 
 TEST_LIBC_TINYMATH_DEPS :=					\
 	$(call uniq,$(foreach x,$(TEST_LIBC_TINYMATH_DIRECTDEPS),$($(x))))
diff --git a/test/libc/tinymath/acosh_test.c b/test/libc/tinymath/acosh_test.c
index 008972047..639782c04 100644
--- a/test/libc/tinymath/acosh_test.c
+++ b/test/libc/tinymath/acosh_test.c
@@ -48,7 +48,9 @@ TEST(acoshf, test) {
 TEST(acoshl, test) {
   volatile long double x = 16;
   EXPECT_STREQ("4", gc(xdtoal(sqrtl(x))));
+#if LDBL_MANT_DIG > 64
   EXPECT_STREQ(".9624236501192069", gc(xdtoal(_acoshl(1.5))));
+#endif
   EXPECT_STREQ("0", gc(xdtoal(_acoshl(1))));
   EXPECT_TRUE(isnan(_acoshl(NAN)));
   EXPECT_TRUE(isnan(_acoshl(.5)));
diff --git a/test/libc/tinymath/asinh_test.c b/test/libc/tinymath/asinh_test.c
index 1584a1ad6..1a2599534 100644
--- a/test/libc/tinymath/asinh_test.c
+++ b/test/libc/tinymath/asinh_test.c
@@ -46,8 +46,10 @@ TEST(asinhf, test) {
 }
 
 TEST(asinhl, test) {
+#if LDBL_MANT_DIG > 64
   EXPECT_STREQ(".4812118250596034", gc(xdtoal(_asinhl(+.5))));
   EXPECT_STREQ("-.4812118250596034", gc(xdtoal(_asinhl(-.5))));
+#endif
   EXPECT_STREQ("0", gc(xdtoal(_asinhl(0))));
   EXPECT_STREQ("NAN", gc(xdtoal(_asinhl(NAN))));
   EXPECT_STREQ("INFINITY", gc(xdtoal(_asinhl(INFINITY))));
diff --git a/test/libc/tinymath/fdot_test.cc b/test/libc/tinymath/fdot_test.cc
new file mode 100644
index 000000000..9cd724926
--- /dev/null
+++ b/test/libc/tinymath/fdot_test.cc
@@ -0,0 +1,309 @@
+#include "libc/assert.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/intrin/bsr.h"
+#include "libc/macros.h"
+#include "libc/math.h"
+#include "libc/mem/gc.h"
+#include "libc/mem/leaks.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/testlib/benchmark.h"
+#include "libc/x/xasprintf.h"
+#include "third_party/aarch64/arm_neon.internal.h"
+#include "third_party/intel/immintrin.internal.h"
+
+#define EXPENSIVE_TESTS 0
+
+#define CHUNK 8
+
+#define FASTMATH __attribute__((__optimize__("-O3,-ffast-math")))
+#define PORTABLE __target_clones("avx512f,avx")
+
+int rand32(void) {
+  /* Knuth, D.E., "The Art of Computer Programming," Vol 2,
+     Seminumerical Algorithms, Third Edition, Addison-Wesley, 1998,
+     p. 106 (line 26) & p. 108 */
+  static unsigned long long lcg = 1;
+  lcg *= 6364136223846793005;
+  lcg += 1442695040888963407;
+  return lcg >> 32;
+}
+
+float float01(unsigned x) {  // (0,1)
+  return 1.f / 8388608 * ((x >> 9) + .5f);
+}
+
+float numba(void) {  // (-1,1)
+  return float01(rand32()) * 2 - 1;
+}
+
+PORTABLE float fdotf_dubble(const float *A, const float *B, size_t n) {
+  double s = 0;
+  for (size_t i = 0; i < n; ++i)
+    s = fma(A[i], B[i], s);
+  return s;
+}
+
+float fdotf_kahan(const float *A, const float *B, size_t n) {
+  size_t i;
+  float err, sum, t, y;
+  sum = err = 0;
+  for (i = 0; i < n; ++i) {
+    y = A[i] * B[i] - err;
+    t = sum + y;
+    err = (t - sum) - y;
+    sum = t;
+  }
+  return sum;
+}
+
+float fdotf_naive(const float *A, const float *B, size_t n) {
+  float s = 0;
+  for (size_t i = 0; i < n; ++i)
+    s = fmaf(A[i], B[i], s);
+  return s;
+}
+
+#define fdotf_naive_tester(A, B, n, tol)                                       \
+  do {                                                                         \
+    float err = fabsf(fdotf_naive(A, B, n) - fdotf_dubble(A, B, n));           \
+    if (err > tol) {                                                           \
+      printf("%s:%d: error: n=%zu failed %g\n", __FILE__, __LINE__, (size_t)n, \
+             err);                                                             \
+      exit(1);                                                                 \
+    }                                                                          \
+  } while (0)
+
+void test_fdotf_naive(void) {
+  float *A = new float[2 * 1024 * 1024 + 1];
+  float *B = new float[2 * 1024 * 1024 + 1];
+  for (size_t i = 0; i < 2 * 1024 * 1024 + 1; ++i) {
+    A[i] = numba();
+    B[i] = numba();
+  }
+  for (size_t n = 0; n < 1024; ++n)
+    fdotf_naive_tester(A, B, n, 1e-4);
+#if EXPENSIVE_TESTS
+  fdotf_naive_tester(A, B, 128 * 1024, 1e-2);
+  fdotf_naive_tester(A, B, 256 * 1024, 1e-2);
+  fdotf_naive_tester(A, B, 1024 * 1024, 1e-1);
+  fdotf_naive_tester(A, B, 1024 * 1024 - 1, 1e-1);
+  fdotf_naive_tester(A, B, 1024 * 1024 + 1, 1e-1);
+  fdotf_naive_tester(A, B, 2 * 1024 * 1024, 1e-1);
+  fdotf_naive_tester(A, B, 2 * 1024 * 1024 - 1, 1e-1);
+  fdotf_naive_tester(A, B, 2 * 1024 * 1024 + 1, 1e-1);
+#endif
+  delete[] B;
+  delete[] A;
+}
+
+template <int N>
+forceinline float hdot(const float *A, const float *B) {
+  return hdot<N / 2>(A, B) + hdot<N / 2>(A + N / 2, B + N / 2);
+}
+
+template <>
+forceinline float hdot<1>(const float *A, const float *B) {
+  return A[0] * B[0];
+}
+
+float fdotf_recursive(const float *A, const float *B, size_t n) {
+  if (n > 32) {
+    float x, y;
+    x = fdotf_recursive(A, B, n / 2);
+    y = fdotf_recursive(A + n / 2, B + n / 2, n - n / 2);
+    return x + y;
+  } else {
+    float s;
+    size_t i;
+    for (s = i = 0; i < n; ++i)
+      s = fmaf(A[i], B[i], s);
+    return s;
+  }
+}
+
+optimizespeed float fdotf_intrin(const float *A, const float *B, size_t n) {
+  size_t i = 0;
+#ifdef __AVX512F__
+  __m512 vec[CHUNK] = {};
+  for (; i + CHUNK * 16 <= n; i += CHUNK * 16)
+    for (int j = 0; j < CHUNK; ++j)
+      vec[j] = _mm512_fmadd_ps(_mm512_loadu_ps(A + i + j * 16),
+                               _mm512_loadu_ps(B + i + j * 16), vec[j]);
+  float res = 0;
+  for (int j = 0; j < CHUNK; ++j)
+    res += _mm512_reduce_add_ps(vec[j]);
+#elif defined(__aarch64__)
+  float32x4_t vec[CHUNK] = {};
+  for (; i + CHUNK * 4 <= n; i += CHUNK * 4)
+    for (int j = 0; j < CHUNK; ++j)
+      vec[j] =
+          vfmaq_f32(vec[j], vld1q_f32(A + i + j * 4), vld1q_f32(B + i + j * 4));
+  float res = 0;
+  for (int j = 0; j < CHUNK; ++j)
+    res += vaddvq_f32(vec[j]);
+#else
+  float res = 0;
+#endif
+  for (; i < n; ++i)
+    res += A[i] * B[i];
+  return res;
+}
+
+FASTMATH float fdotf_ruler(const float *A, const float *B, size_t n) {
+  int rule, step = 2;
+  size_t chunk, sp = 0;
+  float stack[bsr(n / CHUNK + 1) + 1];
+  for (chunk = 0; chunk + CHUNK * 4 <= n; chunk += CHUNK * 4, step += 2) {
+    float sum = 0;
+    for (size_t elem = 0; elem < CHUNK * 4; ++elem)
+      sum += A[chunk + elem] * B[chunk + elem];
+    for (rule = bsr(step & -step); --rule;)
+      sum += stack[--sp];
+    stack[sp++] = sum;
+  }
+  float res = 0;
+  while (sp)
+    res += stack[--sp];
+  for (; chunk < n; ++chunk)
+    res += A[chunk] * B[chunk];
+  return res;
+}
+
+#define fdotf_ruler_tester(A, B, n, tol)                                       \
+  do {                                                                         \
+    float err = fabsf(fdotf_ruler(A, B, n) - fdotf_dubble(A, B, n));           \
+    if (err > tol) {                                                           \
+      printf("%s:%d: error: n=%zu failed %g\n", __FILE__, __LINE__, (size_t)n, \
+             err);                                                             \
+      exit(1);                                                                 \
+    }                                                                          \
+  } while (0)
+
+void test_fdotf_ruler(void) {
+  float *A = new float[10 * 1024 * 1024 + 1];
+  float *B = new float[10 * 1024 * 1024 + 1];
+  for (size_t i = 0; i < 10 * 1024 * 1024 + 1; ++i) {
+    A[i] = numba();
+    B[i] = numba();
+  }
+  fdotf_ruler_tester(A, B, 96, 1e-6);
+  for (size_t n = 0; n < 4096; ++n)
+    fdotf_ruler_tester(A, B, n, 1e-5);
+#if EXPENSIVE_TESTS
+  fdotf_ruler_tester(A, B, 128 * 1024, 1e-4);
+  fdotf_ruler_tester(A, B, 256 * 1024, 1e-4);
+  fdotf_ruler_tester(A, B, 1024 * 1024, 1e-3);
+  fdotf_ruler_tester(A, B, 1024 * 1024 - 1, 1e-3);
+  fdotf_ruler_tester(A, B, 1024 * 1024 + 1, 1e-3);
+  fdotf_ruler_tester(A, B, 2 * 1024 * 1024, 1e-3);
+  fdotf_ruler_tester(A, B, 2 * 1024 * 1024 - 1, 1e-3);
+  fdotf_ruler_tester(A, B, 2 * 1024 * 1024 + 1, 1e-3);
+  fdotf_ruler_tester(A, B, 8 * 1024 * 1024, 1e-3);
+  fdotf_ruler_tester(A, B, 10 * 1024 * 1024, 1e-3);
+#endif
+  delete[] B;
+  delete[] A;
+}
+
+PORTABLE float fdotf_hefty(const float *A, const float *B, size_t n) {
+  if (1)
+    return 0;
+  unsigned i, par, len = 0;
+  float sum, res[n / CHUNK + 1];
+  for (res[0] = i = 0; i + CHUNK <= n; i += CHUNK)
+    res[len++] = hdot<CHUNK>(A + i, B + i);
+  if (i < n) {
+    for (sum = 0; i < n; i++)
+      sum = fmaf(A[i], B[i], sum);
+    res[len++] = sum;
+  }
+  for (par = len >> 1; par; par >>= 1, len >>= 1) {
+    for (i = 0; i < par; ++i)
+      res[i] += res[par + i];
+    if (len & 1)
+      res[par - 1] += res[len - 1];
+  }
+  return res[0];
+}
+
+#define fdotf_hefty_tester(A, B, n, tol)                                       \
+  do {                                                                         \
+    float err = fabsf(fdotf_hefty(A, B, n) - fdotf_dubble(A, B, n));           \
+    if (err > tol) {                                                           \
+      printf("%s:%d: error: n=%zu failed %g\n", __FILE__, __LINE__, (size_t)n, \
+             err);                                                             \
+      exit(1);                                                                 \
+    }                                                                          \
+  } while (0)
+
+void test_fdotf_hefty(void) {
+  float *A = new float[10 * 1024 * 1024 + 1];
+  float *B = new float[10 * 1024 * 1024 + 1];
+  for (size_t i = 0; i < 10 * 1024 * 1024 + 1; ++i) {
+    A[i] = numba();
+    B[i] = numba();
+  }
+  for (size_t n = 0; n < 1024; ++n)
+    fdotf_hefty_tester(A, B, n, 1e-5);
+#if EXPENSIVE_TESTS
+  fdotf_hefty_tester(A, B, 128 * 1024, 1e-4);
+  fdotf_hefty_tester(A, B, 256 * 1024, 1e-4);
+  fdotf_hefty_tester(A, B, 1024 * 1024, 1e-3);
+  fdotf_hefty_tester(A, B, 1024 * 1024 - 1, 1e-3);
+  fdotf_hefty_tester(A, B, 1024 * 1024 + 1, 1e-3);
+  fdotf_hefty_tester(A, B, 2 * 1024 * 1024, 1e-3);
+  fdotf_hefty_tester(A, B, 2 * 1024 * 1024 - 1, 1e-3);
+  fdotf_hefty_tester(A, B, 2 * 1024 * 1024 + 1, 1e-3);
+  fdotf_hefty_tester(A, B, 8 * 1024 * 1024, 1e-3);
+  fdotf_hefty_tester(A, B, 10 * 1024 * 1024, 1e-3);
+#endif
+  delete[] B;
+  delete[] A;
+}
+
+float nothing(float x) {
+  return x;
+}
+
+float (*barrier)(float) = nothing;
+
+int main() {
+  ShowCrashReports();
+
+#if EXPENSIVE_TESTS
+  size_t n = 512 * 1024;
+#else
+  size_t n = 4096;
+#endif
+
+  float *A = new float[n];
+  float *B = new float[n];
+  for (size_t i = 0; i < n; ++i) {
+    A[i] = numba();
+    B[i] = numba();
+  }
+  float kahan, naive, dubble, recursive, ruler, intrin;
+  test_fdotf_naive();
+  // test_fdotf_hefty();
+  test_fdotf_ruler();
+  BENCHMARK(20, 1, (kahan = barrier(fdotf_kahan(A, B, n))));
+  BENCHMARK(20, 1, (dubble = barrier(fdotf_dubble(A, B, n))));
+  BENCHMARK(20, 1, (naive = barrier(fdotf_naive(A, B, n))));
+  BENCHMARK(20, 1, (recursive = barrier(fdotf_recursive(A, B, n))));
+  BENCHMARK(20, 1, (intrin = barrier(fdotf_intrin(A, B, n))));
+  BENCHMARK(20, 1, (ruler = barrier(fdotf_ruler(A, B, n))));
+  // BENCHMARK(20, 1, (hefty = barrier(fdotf_hefty(A, B, n))));
+  printf("dubble    = %f (%g)\n", dubble, fabs(dubble - dubble));
+  printf("kahan     = %f (%g)\n", kahan, fabs(kahan - dubble));
+  printf("naive     = %f (%g)\n", naive, fabs(naive - dubble));
+  printf("recursive = %f (%g)\n", recursive, fabs(recursive - dubble));
+  printf("intrin    = %f (%g)\n", intrin, fabs(intrin - dubble));
+  printf("ruler     = %f (%g)\n", ruler, fabs(ruler - dubble));
+  // printf("hefty     = %f (%g)\n", hefty, fabs(hefty - dubble));
+  delete[] B;
+  delete[] A;
+
+  CheckForMemoryLeaks();
+}
diff --git a/test/libc/tinymath/fsum_test.c b/test/libc/tinymath/fsum_test.c
deleted file mode 100644
index 7936e440a..000000000
--- a/test/libc/tinymath/fsum_test.c
+++ /dev/null
@@ -1,54 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2021 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
-#include "libc/math.h"
-#include "libc/mem/gc.h"
-#include "libc/testlib/ezbench.h"
-#include "libc/testlib/testlib.h"
-#include "libc/x/xasprintf.h"
-
-#define N 100000
-
-float F[N];
-double D[N];
-
-void SetUp(void) {
-  int i;
-  for (i = 0; i < N / 2; ++i) {
-    D[i * 2 + 0] = 1000000000.1;
-    D[i * 2 + 1] = 1.1;
-  }
-  for (i = 0; i < N / 2; ++i) {
-    F[i * 2 + 0] = 1000.1;
-    F[i * 2 + 1] = 1.1;
-  }
-}
-
-TEST(fsum, test) {
-  EXPECT_STREQ("500000000.6", gc(xasprintf("%.15g", fsum(D, N) / N)));
-}
-
-TEST(fsumf, test) {
-  EXPECT_STREQ("500.6", gc(xasprintf("%.7g", fsumf(F, N) / N)));
-}
-
-BENCH(fsum, bench) {
-  EZBENCH2("fsum", donothing, fsum(D, N));
-  EZBENCH2("fsumf", donothing, fsumf(F, N));
-}
diff --git a/test/libc/tinymath/fsum_test.cc b/test/libc/tinymath/fsum_test.cc
new file mode 100644
index 000000000..5e51c4cc2
--- /dev/null
+++ b/test/libc/tinymath/fsum_test.cc
@@ -0,0 +1,260 @@
+#include "libc/assert.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/intrin/bsr.h"
+#include "libc/macros.h"
+#include "libc/math.h"
+#include "libc/mem/gc.h"
+#include "libc/mem/leaks.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/testlib/benchmark.h"
+#include "libc/x/xasprintf.h"
+
+#define EXPENSIVE_TESTS 0
+
+#define CHUNK 8
+
+#define FASTMATH __attribute__((__optimize__("-O3,-ffast-math")))
+#define PORTABLE __target_clones("avx512f,avx")
+
+static unsigned long long lcg = 1;
+
+int rand32(void) {
+  /* Knuth, D.E., "The Art of Computer Programming," Vol 2,
+     Seminumerical Algorithms, Third Edition, Addison-Wesley, 1998,
+     p. 106 (line 26) & p. 108 */
+  lcg *= 6364136223846793005;
+  lcg += 1442695040888963407;
+  return lcg >> 32;
+}
+
+float float01(unsigned x) {  // (0,1)
+  return 1.f / 8388608 * ((x >> 9) + .5f);
+}
+
+float numba(void) {  // (-1,1)
+  return float01(rand32()) * 2 - 1;
+}
+
+FASTMATH PORTABLE float fsumf_dubble(const float *p, size_t n) {
+  double s = 0;
+  for (size_t i = 0; i < n; ++i)
+    s += p[i];
+  return s;
+}
+
+PORTABLE float fsumf_kahan(const float *p, size_t n) {
+  size_t i;
+  float err, sum, t, y;
+  sum = err = 0;
+  for (i = 0; i < n; ++i) {
+    y = p[i] - err;
+    t = sum + y;
+    err = (t - sum) - y;
+    sum = t;
+  }
+  return sum;
+}
+
+FASTMATH PORTABLE float fsumf_naive(const float *p, size_t n) {
+  float s = 0;
+  for (size_t i = 0; i < n; ++i)
+    s += p[i];
+  return s;
+}
+
+#define fsumf_naive_tester(A, n, tol)                                          \
+  do {                                                                         \
+    float err = fabsf(fsumf_naive(A, n) - fsumf_dubble(A, n));                 \
+    if (err > tol) {                                                           \
+      printf("%s:%d: error: n=%zu failed %g\n", __FILE__, __LINE__, (size_t)n, \
+             err);                                                             \
+      exit(1);                                                                 \
+    }                                                                          \
+  } while (0)
+
+void test_fsumf_naive(void) {
+  float *A = new float[2 * 1024 * 1024 + 1];
+  for (size_t i = 0; i < 2 * 1024 * 1024 + 1; ++i)
+    A[i] = numba();
+  for (size_t n = 0; n < 1024; ++n)
+    fsumf_naive_tester(A, n, 1e-4);
+#if EXPENSIVE_TESTS
+  fsumf_naive_tester(A, 128 * 1024, 1e-2);
+  fsumf_naive_tester(A, 256 * 1024, 1e-2);
+  fsumf_naive_tester(A, 1024 * 1024, 1e-1);
+  fsumf_naive_tester(A, 1024 * 1024 - 1, 1e-1);
+  fsumf_naive_tester(A, 1024 * 1024 + 1, 1e-1);
+  fsumf_naive_tester(A, 2 * 1024 * 1024, 1e-1);
+  fsumf_naive_tester(A, 2 * 1024 * 1024 - 1, 1e-1);
+  fsumf_naive_tester(A, 2 * 1024 * 1024 + 1, 1e-1);
+#endif
+  delete[] A;
+}
+
+template <int N>
+forceinline float hsum(const float *p) {
+  return hsum<N / 2>(p) + hsum<N / 2>(p + N / 2);
+}
+
+template <>
+forceinline float hsum<1>(const float *p) {
+  return *p;
+}
+
+FASTMATH PORTABLE float fsumf_recursive(const float *p, size_t n) {
+  if (n > 32) {
+    float x, y;
+    x = fsumf_recursive(p, n / 2);
+    y = fsumf_recursive(p + n / 2, n - n / 2);
+    return x + y;
+  } else {
+    float s;
+    size_t i;
+    for (s = i = 0; i < n; ++i)
+      s += p[i];
+    return s;
+  }
+}
+
+FASTMATH PORTABLE float fsumf_ruler(const float *p, size_t n) {
+  size_t i, sp = 0;
+  int rule, step = 2;
+  float stack[bsr(n / CHUNK + 1) + 1];
+  for (i = 0; i + CHUNK * 4 <= n; i += CHUNK * 4, step += 2) {
+    float sum = 0;
+    for (size_t j = 0; j < CHUNK * 4; ++j)
+      sum += p[i + j];
+    for (rule = bsr(step & -step); --rule;)
+      sum += stack[--sp];
+    stack[sp++] = sum;
+  }
+  float res = 0;
+  while (sp)
+    res += stack[--sp];
+  while (i < n)
+    res += p[i++];
+  return res;
+}
+
+#define fsumf_ruler_tester(A, n, tol)                                          \
+  do {                                                                         \
+    float err = fabsf(fsumf_ruler(A, n) - fsumf_dubble(A, n));                 \
+    if (err > tol) {                                                           \
+      printf("%s:%d: error: n=%zu failed %g\n", __FILE__, __LINE__, (size_t)n, \
+             err);                                                             \
+      exit(1);                                                                 \
+    }                                                                          \
+  } while (0)
+
+void test_fsumf_ruler(void) {
+  float *A = new float[10 * 1024 * 1024 + 1];
+  for (size_t i = 0; i < 10 * 1024 * 1024 + 1; ++i)
+    A[i] = numba();
+  fsumf_ruler_tester(A, 96, 1e-6);
+  for (size_t n = 0; n < 1024; ++n)
+    fsumf_ruler_tester(A, n, 1e-5);
+#if EXPENSIVE_TESTS
+  fsumf_ruler_tester(A, 128 * 1024, 1e-4);
+  fsumf_ruler_tester(A, 256 * 1024, 1e-4);
+  fsumf_ruler_tester(A, 1024 * 1024, 1e-3);
+  fsumf_ruler_tester(A, 1024 * 1024 - 1, 1e-3);
+  fsumf_ruler_tester(A, 1024 * 1024 + 1, 1e-3);
+  fsumf_ruler_tester(A, 2 * 1024 * 1024, 1e-3);
+  fsumf_ruler_tester(A, 2 * 1024 * 1024 - 1, 1e-3);
+  fsumf_ruler_tester(A, 2 * 1024 * 1024 + 1, 1e-3);
+  fsumf_ruler_tester(A, 8 * 1024 * 1024, 1e-3);
+  fsumf_ruler_tester(A, 10 * 1024 * 1024, 1e-3);
+#endif
+  delete[] A;
+}
+
+FASTMATH PORTABLE float fsumf_hefty(const float *p, size_t n) {
+  unsigned i, par, len = 0;
+  float sum, res[n / CHUNK + 1];
+  for (res[0] = i = 0; i + CHUNK <= n; i += CHUNK)
+    res[len++] = hsum<CHUNK>(p + i);
+  if (i < n) {
+    for (sum = 0; i < n; i++)
+      sum += p[i];
+    res[len++] = sum;
+  }
+  for (par = len >> 1; par; par >>= 1, len >>= 1) {
+    for (i = 0; i < par; ++i)
+      res[i] += res[par + i];
+    if (len & 1)
+      res[par - 1] += res[len - 1];
+  }
+  return res[0];
+}
+
+#define fsumf_hefty_tester(A, n, tol)                                          \
+  do {                                                                         \
+    float err = fabsf(fsumf_hefty(A, n) - fsumf_dubble(A, n));                 \
+    if (err > tol) {                                                           \
+      printf("%s:%d: error: n=%zu failed %g\n", __FILE__, __LINE__, (size_t)n, \
+             err);                                                             \
+      exit(1);                                                                 \
+    }                                                                          \
+  } while (0)
+
+void test_fsumf_hefty(void) {
+  float *A = new float[10 * 1024 * 1024 + 1];
+  for (size_t i = 0; i < 10 * 1024 * 1024 + 1; ++i)
+    A[i] = numba();
+  for (size_t n = 0; n < 1024; ++n)
+    fsumf_hefty_tester(A, n, 1e-5);
+#if EXPENSIVE_TESTS
+  fsumf_hefty_tester(A, 128 * 1024, 1e-4);
+  fsumf_hefty_tester(A, 256 * 1024, 1e-4);
+  fsumf_hefty_tester(A, 1024 * 1024, 1e-3);
+  fsumf_hefty_tester(A, 1024 * 1024 - 1, 1e-3);
+  fsumf_hefty_tester(A, 1024 * 1024 + 1, 1e-3);
+  fsumf_hefty_tester(A, 2 * 1024 * 1024, 1e-3);
+  fsumf_hefty_tester(A, 2 * 1024 * 1024 - 1, 1e-3);
+  fsumf_hefty_tester(A, 2 * 1024 * 1024 + 1, 1e-3);
+  fsumf_hefty_tester(A, 8 * 1024 * 1024, 1e-3);
+  fsumf_hefty_tester(A, 10 * 1024 * 1024, 1e-3);
+#endif
+  delete[] A;
+}
+
+float nothing(float x) {
+  return x;
+}
+
+float (*barrier)(float) = nothing;
+
+int main() {
+  ShowCrashReports();
+
+#if EXPENSIVE_TESTS
+  size_t n = 4 * 1024 * 1024;
+#else
+  size_t n = 1024;
+#endif
+
+  float *p = new float[n];
+  for (size_t i = 0; i < n; ++i)
+    p[i] = numba();
+  float kahan, naive, dubble, recursive, hefty, ruler;
+  test_fsumf_naive();
+  test_fsumf_hefty();
+  test_fsumf_ruler();
+  BENCHMARK(20, 1, (kahan = barrier(fsumf_kahan(p, n))));
+  BENCHMARK(20, 1, (dubble = barrier(fsumf_dubble(p, n))));
+  BENCHMARK(20, 1, (naive = barrier(fsumf_naive(p, n))));
+  BENCHMARK(20, 1, (recursive = barrier(fsumf_recursive(p, n))));
+  BENCHMARK(20, 1, (ruler = barrier(fsumf_ruler(p, n))));
+  BENCHMARK(20, 1, (hefty = barrier(fsumf_hefty(p, n))));
+  printf("dubble    = %f (%g)\n", dubble, fabs(dubble - dubble));
+  printf("kahan     = %f (%g)\n", kahan, fabs(kahan - dubble));
+  printf("naive     = %f (%g)\n", naive, fabs(naive - dubble));
+  printf("recursive = %f (%g)\n", recursive, fabs(recursive - dubble));
+  printf("ruler     = %f (%g)\n", ruler, fabs(ruler - dubble));
+  printf("hefty     = %f (%g)\n", hefty, fabs(hefty - dubble));
+  delete[] p;
+
+  CheckForMemoryLeaks();
+}
diff --git a/test/libc/tinymath/hypot_test.c b/test/libc/tinymath/hypot_test.c
index 802d994ed..37ede41a0 100644
--- a/test/libc/tinymath/hypot_test.c
+++ b/test/libc/tinymath/hypot_test.c
@@ -99,8 +99,10 @@ TEST(hypotll, test) {
   EXPECT_STREQ("1.414213562373095", gc(xdtoal(_hypotl(-1, 1))));
   EXPECT_STREQ("1.414213626012708", gc(xdtoal(_hypotl(1.0000001, .99999999))));
   EXPECT_STREQ("1.414213626012708", gc(xdtoal(_hypotl(.99999999, 1.0000001))));
+#if LDBL_MANT_DIG > 64
   EXPECT_STREQ("1.414213562373095e+4931",
                gc(xdtoal(_hypotl(1e4931L, 1e4931L))));
+#endif
   EXPECT_STREQ("NAN", gc(xdtoal(_hypotl(0, NAN))));
   EXPECT_STREQ("NAN", gc(xdtoal(_hypotl(NAN, 0))));
   EXPECT_STREQ("NAN", gc(xdtoal(_hypotl(NAN, NAN))));
diff --git a/test/libc/tinymath/powl_test.c b/test/libc/tinymath/powl_test.c
index 0c2f3bada..8d25a7186 100644
--- a/test/libc/tinymath/powl_test.c
+++ b/test/libc/tinymath/powl_test.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/siginfo.h"
 #include "libc/calls/ucontext.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/runtime/pc.internal.h"
diff --git a/test/libc/tinymath/strtod_test.c b/test/libc/tinymath/strtod_test.c
index 05e46173e..e6a64531c 100644
--- a/test/libc/tinymath/strtod_test.c
+++ b/test/libc/tinymath/strtod_test.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/conv.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/fenv.h"
diff --git a/test/libc/tinymath/tanh_test.c b/test/libc/tinymath/tanh_test.c
index c59e5511c..bf3062602 100644
--- a/test/libc/tinymath/tanh_test.c
+++ b/test/libc/tinymath/tanh_test.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/conv.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/runtime/runtime.h"
diff --git a/test/libc/x/utf8to32_test.c b/test/libc/x/utf8to32_test.c
index cf17662bb..5f54e2d17 100644
--- a/test/libc/x/utf8to32_test.c
+++ b/test/libc/x/utf8to32_test.c
@@ -18,7 +18,6 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
-#include "libc/mem/shuffle.internal.h"
 #include "libc/stdio/rand.h"
 #include "libc/testlib/ezbench.h"
 #include "libc/testlib/hyperion.h"
@@ -82,11 +81,20 @@ TEST(utf32to8, testLargeThompsonPikeEncoded) {
           -1, 0)));
 }
 
+void shuffle(wchar_t *a, int n) {
+  for (int i = n - 1; i >= 1; --i) {
+    int r = rand() % (i + 1);
+    wchar_t t = a[r];
+    a[r] = a[i];
+    a[i] = t;
+  }
+}
+
 char *GenerateBranchyUtf8Text(size_t *out_n) {
   char *p;
   size_t n;
   wchar_t *q = gc(utf8to32(kViewables, kViewablesSize, &n));
-  shuffle(lemur64, q, n);
+  shuffle(q, n);
   p = utf32to8(q, n, &n);
   if (out_n)
     *out_n = n;
diff --git a/test/libc/xed/x86ild_lib.c b/test/libc/xed/x86ild_lib.c
index e7cc1b0e7..af8d699ae 100644
--- a/test/libc/xed/x86ild_lib.c
+++ b/test/libc/xed/x86ild_lib.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/bing.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/str/str.h"
 #include "libc/testlib/testlib.h"
diff --git a/test/libcxx/BUILD.mk b/test/libcxx/BUILD.mk
index 1bfec308e..2dd7cf5b0 100644
--- a/test/libcxx/BUILD.mk
+++ b/test/libcxx/BUILD.mk
@@ -44,7 +44,7 @@ o/$(MODE)/test/libcxx/%.dbg:				\
 
 $(TEST_LIBCXX_OBJS): private OVERRIDE_CXXFLAGS += -fexceptions -frtti
 
-o/$(MODE)/test/libcxx/openmp_test.o: private CXXFLAGS += -fopenmp
+o/$(MODE)/test/libcxx/openmp_test.o: private CXXFLAGS += -fopenmp -O3
 o/$(MODE)/test/libcxx/openmp_test.runs: private QUOTA += -C100
 
 .PHONY: o/$(MODE)/test/libcxx
diff --git a/test/libcxx/cexception_test.cc b/test/libcxx/cexception_test.cc
index 0e09c014b..28aa20d48 100644
--- a/test/libcxx/cexception_test.cc
+++ b/test/libcxx/cexception_test.cc
@@ -21,13 +21,6 @@
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 
-// this dontthrow keyword SHOULD break this test. it's probably passing
-// because we're currently using SjLj exceptions. the day we can change
-// things, remove `dontthrow` and this test will still be a useful help
-extern "C" dontthrow void qsort_(void *, size_t, size_t,
-                                 int (*)(const void *,
-                                         const void *)) asm("qsort");
-
 struct Resource {
   char *p;
   Resource() {
@@ -60,7 +53,7 @@ int A[3] = {3, 2, 1};
 int Work(void) {
   Resource r;
   pPoke(r.p);
-  qsort_(A, 3, sizeof(int), cmp);
+  qsort(A, 3, sizeof(int), cmp);
   return A[0];
 }
 int (*pWork)(void) = Work;
diff --git a/test/libcxx/errc_test.cc b/test/libcxx/errc_test.cc
new file mode 100644
index 000000000..373cdf78c
--- /dev/null
+++ b/test/libcxx/errc_test.cc
@@ -0,0 +1,22 @@
+#include <cerrno>
+#include <system_error>
+
+bool test_errc_mapping(int posix_error, std::errc expected_errc) {
+  std::error_code ec(posix_error, std::generic_category());
+  return ec.value() == posix_error &&  //
+         std::error_condition(expected_errc) == ec;
+}
+
+int main() {
+  if (!test_errc_mapping(EACCES, std::errc::permission_denied))
+    return 1;
+  if (!test_errc_mapping(ENOENT, std::errc::no_such_file_or_directory))
+    return 2;
+  if (!test_errc_mapping(EEXIST, std::errc::file_exists))
+    return 3;
+  if (!test_errc_mapping(EINVAL, std::errc::invalid_argument))
+    return 4;
+  if (!test_errc_mapping(ENOSPC, std::errc::no_space_on_device))
+    return 5;
+  return 0;
+}
diff --git a/test/libcxx/filesystem_test.cc b/test/libcxx/filesystem_test.cc
new file mode 100644
index 000000000..762e650b2
--- /dev/null
+++ b/test/libcxx/filesystem_test.cc
@@ -0,0 +1,341 @@
+#include <chrono>
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+#include <random>
+#include <string>
+#include <thread>
+
+#define ASSERT(condition)                                           \
+  if (!(condition)) {                                               \
+    fprintf(stderr, "%s:%d: test failed: %s\n", __FILE__, __LINE__, \
+            #condition);                                            \
+    return 1;                                                       \
+  }
+
+namespace fs = std::filesystem;
+
+fs::path g_temp_path;
+fs::path g_orig_path;
+std::string g_tmpdir;
+
+void setup() {
+  g_orig_path = fs::current_path();
+  fs::path temp_path = fs::temp_directory_path();
+  auto now = std::chrono::system_clock::now();
+  auto now_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);
+  auto value = now_ms.time_since_epoch();
+  long duration = value.count();
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_int_distribution<> dis(0, 999999);
+  int random_number = dis(gen);
+  std::string dir_name =
+      "temp_" + std::to_string(duration) + "_" + std::to_string(random_number);
+  g_temp_path = temp_path / dir_name;
+  fs::create_directory(g_temp_path);
+  fs::current_path(g_temp_path);
+  fs::create_directory("tmp");
+  g_tmpdir = fs::absolute("tmp");
+  setenv("TMPDIR", g_tmpdir.c_str(), true);
+}
+
+void teardown() {
+  fs::current_path(g_orig_path);
+  fs::remove_all(g_temp_path);
+}
+
+int test_create_directory() {
+  fs::path dir = "test_dir";
+  ASSERT(fs::create_directory(dir));
+  ASSERT(fs::is_directory(dir));
+  ASSERT(!fs::create_directory(dir));
+  fs::remove(dir);
+  return 0;
+}
+
+int test_create_directories() {
+  fs::path dirs = "test_dir/nested/deep";
+  ASSERT(fs::create_directories(dirs));
+  ASSERT(fs::is_directory(dirs));
+  ASSERT(!fs::create_directories(dirs));
+  fs::remove_all("test_dir");
+  return 0;
+}
+
+int test_remove() {
+  fs::path file = "test_file.txt";
+  std::ofstream(file).put('a');
+  ASSERT(fs::remove(file));
+  ASSERT(!fs::remove(file));
+  return 0;
+}
+
+int test_remove_all() {
+  fs::path dir = "test_dir/nested/deep";
+  fs::create_directories(dir);
+  ASSERT(fs::remove_all("test_dir") > 0);
+  ASSERT(fs::remove_all("test_dir") == 0);
+  return 0;
+}
+
+int test_rename() {
+  fs::path old_name = "old.txt";
+  fs::path new_name = "new.txt";
+  std::ofstream(old_name).put('a');
+  fs::rename(old_name, new_name);
+  ASSERT(!fs::exists(old_name));
+  ASSERT(fs::exists(new_name));
+  fs::remove(new_name);
+  return 0;
+}
+
+int test_copy() {
+  fs::path src = "src.txt";
+  fs::path dst = "dst.txt";
+  std::ofstream(src) << "test";
+  fs::copy(src, dst);
+  ASSERT(fs::exists(dst));
+  ASSERT(fs::file_size(src) == fs::file_size(dst));
+  fs::remove(src);
+  fs::remove(dst);
+  return 0;
+}
+
+int test_copy_file() {
+  fs::path src = "src.txt";
+  fs::path dst = "dst.txt";
+  std::ofstream(src) << "test";
+  ASSERT(fs::copy_file(src, dst));
+  ASSERT(!fs::copy_file(src, dst, fs::copy_options::skip_existing));
+  fs::remove(src);
+  fs::remove(dst);
+  return 0;
+}
+
+int test_exists() {
+  fs::path file = "test.txt";
+  ASSERT(!fs::exists(file));
+  std::ofstream(file).put('a');
+  ASSERT(fs::exists(file));
+  fs::remove(file);
+  return 0;
+}
+
+int test_is_regular_file() {
+  fs::path file = "test.txt";
+  fs::path dir = "test_dir";
+  std::ofstream(file).put('a');
+  fs::create_directory(dir);
+  ASSERT(fs::is_regular_file(file));
+  ASSERT(!fs::is_regular_file(dir));
+  fs::remove(file);
+  fs::remove(dir);
+  return 0;
+}
+
+int test_is_directory() {
+  fs::path file = "test.txt";
+  fs::path dir = "test_dir";
+  std::ofstream(file).put('a');
+  fs::create_directory(dir);
+  ASSERT(!fs::is_directory(file));
+  ASSERT(fs::is_directory(dir));
+  fs::remove(file);
+  fs::remove(dir);
+  return 0;
+}
+
+int test_is_symlink() {
+  fs::path file = "test.txt";
+  fs::path link = "test_link";
+  std::ofstream(file).put('a');
+  fs::create_symlink(file, link);
+  ASSERT(!fs::is_symlink(file));
+  ASSERT(fs::is_symlink(link));
+  fs::remove(file);
+  fs::remove(link);
+  return 0;
+}
+
+int test_file_size() {
+  fs::path file = "test.txt";
+  std::ofstream(file) << "test";
+  ASSERT(fs::file_size(file) == 4);
+  fs::remove(file);
+  return 0;
+}
+
+int test_last_write_time() {
+  fs::path file = "test.txt";
+  auto now = fs::file_time_type::clock::now();
+  std::ofstream(file).put('a');
+  fs::last_write_time(file, now);
+  ASSERT(fs::last_write_time(file) == now);
+  fs::remove(file);
+  return 0;
+}
+
+int test_permissions() {
+  fs::path file = "test.txt";
+  std::ofstream(file).put('a');
+  fs::permissions(file, fs::perms::owner_read | fs::perms::owner_write);
+  auto perms = fs::status(file).permissions();
+  ASSERT((perms & fs::perms::owner_read) != fs::perms::none);
+  ASSERT((perms & fs::perms::owner_write) != fs::perms::none);
+  ASSERT((perms & fs::perms::owner_exec) == fs::perms::none);
+  fs::remove(file);
+  return 0;
+}
+
+int test_current_path() {
+  auto original_path = fs::current_path();
+  fs::path new_path = fs::temp_directory_path();
+  fs::current_path(new_path);
+  ASSERT(fs::current_path() == new_path);
+  fs::current_path(original_path);
+  return 0;
+}
+
+int test_absolute() {
+  fs::path relative = "test.txt";
+  auto abs_path = fs::absolute(relative);
+  ASSERT(abs_path.is_absolute());
+  return 0;
+}
+
+int test_canonical() {
+  fs::path dir = "test_dir";
+  fs::path file = dir / "test.txt";
+  fs::create_directories(dir);
+  std::ofstream(file).put('a');
+  auto can_path = fs::canonical(file);
+  ASSERT(can_path.is_absolute());
+  ASSERT(!can_path.lexically_normal().string().empty());
+  fs::remove_all(dir);
+  return 0;
+}
+
+int test_read_symlink() {
+  fs::path file = "test.txt";
+  fs::path link = "test_link";
+  std::ofstream(file).put('a');
+  fs::create_symlink(file, link);
+  ASSERT(fs::read_symlink(link) == file);
+  fs::remove(file);
+  fs::remove(link);
+  return 0;
+}
+
+int test_create_symlink_and_hard_link() {
+  fs::path file = "test.txt";
+  fs::path symlink = "test_symlink";
+  fs::path hardlink = "test_hardlink";
+  std::ofstream(file).put('a');
+  fs::create_symlink(file, symlink);
+  fs::create_hard_link(file, hardlink);
+  ASSERT(fs::exists(symlink));
+  ASSERT(fs::exists(hardlink));
+  ASSERT(fs::is_symlink(symlink));
+  ASSERT(!fs::is_symlink(hardlink));
+  fs::remove(file);
+  fs::remove(symlink);
+  fs::remove(hardlink);
+  return 0;
+}
+
+int test_space() {
+  auto space_info = fs::space(".");
+  ASSERT(space_info.capacity > 0);
+  ASSERT(space_info.free > 0);
+  ASSERT(space_info.available > 0);
+  return 0;
+}
+
+int test_equivalent() {
+  fs::path file1 = "test1.txt";
+  fs::path file2 = "test2.txt";
+  std::ofstream(file1).put('a');
+  fs::create_hard_link(file1, file2);
+  ASSERT(fs::equivalent(file1, file2));
+  fs::remove(file1);
+  fs::remove(file2);
+  return 0;
+}
+
+int test_resize_file() {
+  fs::path file = "test.txt";
+  std::ofstream(file) << "test";
+  fs::resize_file(file, 10);
+  ASSERT(fs::file_size(file) == 10);
+  fs::remove(file);
+  return 0;
+}
+
+int test_status() {
+  fs::path file = "test.txt";
+  std::ofstream(file).put('a');
+  auto status = fs::status(file);
+  ASSERT(status.type() == fs::file_type::regular);
+  fs::remove(file);
+  return 0;
+}
+
+int test_copy_enoent() {
+  fs::path src = "non_existent_file.txt";
+  fs::path dst = "destination.txt";
+  try {
+    fs::copy(src, dst);
+    ASSERT(false);
+  } catch (const fs::filesystem_error& e) {
+    if (e.code() == std::errc::no_such_file_or_directory) {
+      return 0;
+    } else {
+      ASSERT(false);
+    }
+  } catch (const std::exception& e) {
+    ASSERT(false);
+  }
+}
+
+#define RUN(func)  \
+  result = func(); \
+  if (result)      \
+  return result
+
+int test() {
+  int result = 0;
+  RUN(test_copy_enoent);
+  RUN(test_create_directory);
+  RUN(test_create_directories);
+  RUN(test_remove);
+  RUN(test_remove_all);
+  RUN(test_rename);
+  RUN(test_copy);
+  RUN(test_copy_file);
+  RUN(test_exists);
+  RUN(test_is_regular_file);
+  RUN(test_is_directory);
+  RUN(test_is_symlink);
+  RUN(test_file_size);
+  RUN(test_last_write_time);
+  RUN(test_permissions);
+  RUN(test_current_path);
+  RUN(test_absolute);
+  RUN(test_canonical);
+  RUN(test_read_symlink);
+  RUN(test_create_symlink_and_hard_link);
+  RUN(test_space);
+  RUN(test_equivalent);
+  RUN(test_resize_file);
+  RUN(test_status);
+  return 0;
+}
+
+int main() {
+  int rc;
+  setup();
+  rc = test();
+  teardown();
+  return rc;
+}
diff --git a/test/libcxx/openmp_test.cc b/test/libcxx/openmp_test.cc
new file mode 100644
index 000000000..cfb4200d0
--- /dev/null
+++ b/test/libcxx/openmp_test.cc
@@ -0,0 +1,467 @@
+/*-*-mode:c++;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8-*-│
+│ vi: set et ft=cpp ts=2 sts=2 sw=2 fenc=utf-8                             :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <algorithm>
+#include <atomic>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
+#include "libc/stdio/rand.h"
+
+#define PRECISION 2e-5
+#define LV1DCACHE 49152
+#define THRESHOLD 3000000
+
+#if defined(__OPTIMIZE__) && !defined(__SANITIZE_ADDRESS__)
+#define ITERATIONS 5
+#else
+#define ITERATIONS 1
+#endif
+
+#define OPTIMIZED __attribute__((__optimize__("-O3,-ffast-math")))
+#define PORTABLE                 \
+  __target_clones("arch=znver4," \
+                  "fma,"         \
+                  "avx")
+
+static bool is_self_testing;
+
+// m×n → n×m
+template <typename TA, typename TB>
+void transpose(long m, long n, const TA *A, long lda, TB *B, long ldb) {
+#pragma omp parallel for collapse(2) if (m * n > THRESHOLD)
+  for (long i = 0; i < m; ++i)
+    for (long j = 0; j < n; ++j) {
+      B[ldb * j + i] = A[lda * i + j];
+    }
+}
+
+// m×k * k×n → m×n
+// k×m * k×n → m×n if aᵀ
+// m×k * n×k → m×n if bᵀ
+// k×m * n×k → m×n if aᵀ and bᵀ
+template <typename TC, typename TA, typename TB>
+void dgemm(bool aᵀ, bool bᵀ, long m, long n, long k, float α, const TA *A,
+           long lda, const TB *B, long ldb, float β, TC *C, long ldc) {
+#pragma omp parallel for collapse(2) if (m * n * k > THRESHOLD)
+  for (long i = 0; i < m; ++i)
+    for (long j = 0; j < n; ++j) {
+      double sum = 0;
+      for (long l = 0; l < k; ++l)
+        sum = std::fma((aᵀ ? A[lda * l + i] : A[lda * i + l]) * α,
+                       (bᵀ ? B[ldb * j + l] : B[ldb * l + j]), sum);
+      C[ldc * i + j] = C[ldc * i + j] * β + sum;
+    }
+}
+
+template <typename T, typename TC, typename TA, typename TB>
+struct Gemmlin {
+ public:
+  Gemmlin(bool aT, bool bT, float α, const TA *A, long lda, const TB *B,
+          long ldb, float β, TC *C, long ldc)
+      : aT(aT),
+        bT(bT),
+        α(α),
+        A(A),
+        lda(lda),
+        B(B),
+        ldb(ldb),
+        β(β),
+        C(C),
+        ldc(ldc) {
+  }
+
+  void gemm(long m, long n, long k) {
+    if (!m || !n)
+      return;
+    for (long i = 0; i < m; ++i)
+      for (long j = 0; j < n; ++j) {
+        C[ldc * i + j] *= β;
+      }
+    if (!k)
+      return;
+    cub = sqrt(LV1DCACHE) / sqrt(sizeof(T) * 3);
+    mnpack(0, m, 0, n, 0, k);
+  }
+
+ private:
+  void mnpack(long m0, long m,  //
+              long n0, long n,  //
+              long k0, long k) {
+    long mc = rounddown(std::min(m - m0, cub), 4);
+    long mp = m0 + (m - m0) / mc * mc;
+    long nc = rounddown(std::min(n - n0, cub), 4);
+    long np = n0 + (n - n0) / nc * nc;
+    long kc = rounddown(std::min(k - k0, cub), 4);
+    long kp = k0 + (k - k0) / kc * kc;
+    kpack(m0, mc, mp, n0, nc, np, k0, kc, k, kp);
+    if (m - mp)
+      mnpack(mp, m, n0, np, k0, k);
+    if (n - np)
+      mnpack(m0, mp, np, n, k0, k);
+    if (m - mp && n - np)
+      mnpack(mp, m, np, n, k0, k);
+  }
+
+  void kpack(long m0, long mc, long m,  //
+             long n0, long nc, long n,  //
+             long k0, long kc, long k,  //
+             long kp) {
+    rpack(m0, mc, m, n0, nc, n, k0, kc, kp);
+    if (k - kp)
+      rpack(m0, mc, m, n0, nc, n, kp, k - kp, k);
+  }
+
+  void rpack(long m0, long mc, long m,  //
+             long n0, long nc, long n,  //
+             long k0, long kc, long k) {
+    if (!(mc % 4) && !(nc % 4))
+      bgemm<4, 4>(m0, mc, m, n0, nc, n, k0, kc, k);
+    else
+      bgemm<1, 1>(m0, mc, m, n0, nc, n, k0, kc, k);
+  }
+
+  template <int mr, int nr>
+  void bgemm(long m0, long mc, long m,  //
+             long n0, long nc, long n,  //
+             long k0, long kc, long k) {
+    ops = (m - m0) * (n - n0) * (k - k0);
+    ml = (m - m0) / mc;
+    nl = (n - n0) / nc;
+    locks = new lock[ml * nl];
+    there_will_be_blocks<mr, nr>(m0, mc, m, n0, nc, n, k0, kc, k);
+    delete[] locks;
+  }
+
+  template <int mr, int nr>
+  void there_will_be_blocks(long m0, long mc, long m, long n0, long nc, long n,
+                            long k0, long kc, long k) {
+#pragma omp parallel for collapse(2) if (ops > THRESHOLD && mc * kc > 16)
+    for (long ic = m0; ic < m; ic += mc)
+      for (long pc = k0; pc < k; pc += kc)
+        gizmo<mr, nr>(m0, mc, ic, n0, nc, k0, kc, pc, n);
+  }
+
+  template <int mr, int nr>
+  PORTABLE OPTIMIZED void gizmo(long m0, long mc, long ic, long n0, long nc,
+                                long k0, long kc, long pc, long n) {
+    T Ac[mc / mr][kc][mr];
+    for (long i = 0; i < mc; ++i)
+      for (long j = 0; j < kc; ++j)
+        Ac[i / mr][j][i % mr] = α * (aT ? A[lda * (pc + j) + (ic + i)]
+                                        : A[lda * (ic + i) + (pc + j)]);
+    for (long jc = n0; jc < n; jc += nc) {
+      T Bc[nc / nr][nr][kc];
+      for (long j = 0; j < nc; ++j)
+        for (long i = 0; i < kc; ++i)
+          Bc[j / nr][j % nr][i] =
+              bT ? B[ldb * (jc + j) + (pc + i)] : B[ldb * (pc + i) + (jc + j)];
+      T Cc[nc / nr][mc / mr][nr][mr];
+      memset(Cc, 0, nc * mc * sizeof(float));
+      for (long jr = 0; jr < nc / nr; ++jr)
+        for (long ir = 0; ir < mc / mr; ++ir)
+          for (long pr = 0; pr < kc; ++pr)
+            for (long j = 0; j < nr; ++j)
+              for (long i = 0; i < mr; ++i)
+                Cc[jr][ir][j][i] += Ac[ir][pr][i] * Bc[jr][j][pr];
+      const long lk = nl * ((ic - m0) / mc) + ((jc - n0) / nc);
+      locks[lk].acquire();
+      for (long ir = 0; ir < mc; ir += mr)
+        for (long jr = 0; jr < nc; jr += nr)
+          for (long i = 0; i < mr; ++i)
+            for (long j = 0; j < nr; ++j)
+              C[ldc * (ic + ir + i) + (jc + jr + j)] +=
+                  Cc[jr / nr][ir / mr][j][i];
+      locks[lk].release();
+    }
+  }
+
+  inline long rounddown(long x, long r) {
+    if (x < r)
+      return x;
+    else
+      return x & -r;
+  }
+
+  class lock {
+   public:
+    lock() = default;
+    void acquire() {
+      while (lock_.exchange(true, std::memory_order_acquire)) {
+      }
+    }
+    void release() {
+      lock_.store(false, std::memory_order_release);
+    }
+
+   private:
+    std::atomic_bool lock_ = false;
+  };
+
+  bool aT;
+  bool bT;
+  float α;
+  const TA *A;
+  long lda;
+  const TB *B;
+  long ldb;
+  float β;
+  TC *C;
+  long ldc;
+  long ops;
+  long nl;
+  long ml;
+  lock *locks;
+  long cub;
+};
+
+template <typename TC, typename TA, typename TB>
+void sgemm(bool aT, bool bT, long m, long n, long k, float α, const TA *A,
+           long lda, const TB *B, long ldb, float β, TC *C, long ldc) {
+  Gemmlin<float, TC, TA, TB> g{aT, bT, α, A, lda, B, ldb, β, C, ldc};
+  g.gemm(m, n, k);
+}
+
+template <typename TA, typename TB>
+void show(FILE *f, long max, long m, long n, const TA *A, long lda, const TB *B,
+          long ldb) {
+  flockfile(f);
+  fprintf(f, "      ");
+  for (long j = 0; j < n; ++j) {
+    fprintf(f, "%13ld", j);
+  }
+  fprintf(f, "\n");
+  for (long i = 0; i < m; ++i) {
+    if (i == max) {
+      fprintf(f, "...\n");
+      break;
+    }
+    fprintf(f, "%5ld ", i);
+    for (long j = 0; j < n; ++j) {
+      if (j == max) {
+        fprintf(f, " ...");
+        break;
+      }
+      char ba[16], bb[16];
+      sprintf(ba, "%13.7f", static_cast<double>(A[lda * i + j]));
+      sprintf(bb, "%13.7f", static_cast<double>(B[ldb * i + j]));
+      for (long k = 0; ba[k] && bb[k]; ++k) {
+        if (ba[k] != bb[k])
+          fputs_unlocked("\33[31m", f);
+        fputc_unlocked(ba[k], f);
+        if (ba[k] != bb[k])
+          fputs_unlocked("\33[0m", f);
+      }
+    }
+    fprintf(f, "\n");
+  }
+  funlockfile(f);
+}
+
+inline unsigned long GetDoubleBits(double f) {
+  union {
+    double f;
+    unsigned long i;
+  } u;
+  u.f = f;
+  return u.i;
+}
+
+inline bool IsNan(double x) {
+  return (GetDoubleBits(x) & (-1ull >> 1)) > (0x7ffull << 52);
+}
+
+template <typename TA, typename TB>
+double diff(long m, long n, const TA *Want, long lda, const TB *Got, long ldb) {
+  double s = 0;
+  int got_nans = 0;
+  int want_nans = 0;
+  for (long i = 0; i < m; ++i)
+    for (long j = 0; j < n; ++j)
+      if (IsNan(Want[ldb * i + j]))
+        ++want_nans;
+      else if (IsNan(Got[ldb * i + j]))
+        ++got_nans;
+      else
+        s += std::fabs(Want[lda * i + j] - Got[ldb * i + j]);
+  if (got_nans)
+    printf("WARNING: got %d NaNs!\n", got_nans);
+  if (want_nans)
+    printf("WARNING: want array has %d NaNs!\n", want_nans);
+  return s / (m * n);
+}
+
+template <typename TA, typename TB>
+void show_error(FILE *f, long max, long m, long n, const TA *A, long lda,
+                const TB *B, long ldb, const char *file, int line, double sad,
+                double tol) {
+  fprintf(f, "%s:%d: sad %.17g exceeds %g\nwant\n", file, line, sad, tol);
+  show(f, max, m, n, A, lda, B, ldb);
+  fprintf(f, "got\n");
+  show(f, max, m, n, B, ldb, A, lda);
+  fprintf(f, "\n");
+}
+
+template <typename TA, typename TB>
+void check(double tol, long m, long n, const TA *A, long lda, const TB *B,
+           long ldb, const char *file, int line) {
+  double sad = diff(m, n, A, lda, B, ldb);
+  if (sad <= tol) {
+    if (!is_self_testing) {
+      printf("         %g error\n", sad);
+    }
+  } else {
+    show_error(stderr, 16, m, n, A, lda, B, ldb, file, line, sad, tol);
+    const char *path = "/tmp/openmp_test.log";
+    FILE *f = fopen(path, "w");
+    if (f) {
+      show_error(f, 10000, m, n, A, lda, B, ldb, file, line, sad, tol);
+      printf("see also %s\n", path);
+    }
+    exit(1);
+  }
+}
+
+#define check(tol, m, n, A, lda, B, ldb) \
+  check(tol, m, n, A, lda, B, ldb, __FILE__, __LINE__)
+
+long micros(void) {
+  struct timespec ts;
+  clock_gettime(CLOCK_REALTIME, &ts);
+  return ts.tv_sec * 1000000 + (ts.tv_nsec + 999) / 1000;
+}
+
+#define bench(x)                                                 \
+  do {                                                           \
+    int N = 10;                                                  \
+    long long t1 = micros();                                     \
+    for (long long i = 0; i < N; ++i) {                          \
+      asm volatile("" ::: "memory");                             \
+      x;                                                         \
+      asm volatile("" ::: "memory");                             \
+    }                                                            \
+    long long t2 = micros();                                     \
+    printf("%8lld µs %2dx n=%5d m=%5d k=%5d %s %g gigaflops\n",  \
+           (t2 - t1 + N - 1) / N, N, (int)n, (int)m, (int)k, #x, \
+           1e6 / ((t2 - t1 + N - 1) / N) * m * n * k * 1e-9);    \
+  } while (0)
+
+double real01(unsigned long x) {  // (0,1)
+  return 1. / 4503599627370496. * ((x >> 12) + .5);
+}
+
+double numba(void) {  // (-1,1)
+  return real01(lemur64()) * 2 - 1;
+}
+
+template <typename T>
+void fill(T *A, long n) {
+  for (long i = 0; i < n; ++i) {
+    A[i] = numba();
+  }
+}
+
+void test_gemm(long m, long n, long k) {
+  float *A = new float[m * k];
+  float *At = new float[k * m];
+  float *B = new float[k * n];
+  float *Bt = new float[n * k];
+  float *C = new float[m * n];
+  float *GOLD = new float[m * n];
+  float α = 1;
+  float β = 0;
+  fill(A, m * k);
+  fill(B, k * n);
+  dgemm(0, 0, m, n, k, 1, A, k, B, n, 0, GOLD, n);
+  transpose(m, k, A, k, At, m);
+  transpose(k, n, B, n, Bt, k);
+  sgemm(0, 0, m, n, k, α, A, k, B, n, β, C, n);
+  check(PRECISION, m, n, GOLD, n, C, n);
+  sgemm(1, 0, m, n, k, α, At, m, B, n, β, C, n);
+  check(PRECISION, m, n, GOLD, n, C, n);
+  sgemm(0, 1, m, n, k, α, A, k, Bt, k, β, C, n);
+  check(PRECISION, m, n, GOLD, n, C, n);
+  sgemm(1, 1, m, n, k, α, At, m, Bt, k, β, C, n);
+  check(PRECISION, m, n, GOLD, n, C, n);
+  delete[] GOLD;
+  delete[] C;
+  delete[] Bt;
+  delete[] B;
+  delete[] At;
+  delete[] A;
+}
+
+void check_gemm_works(void) {
+  static long kSizes[] = {1, 2, 3, 4, 5, 6, 7, 17, 31, 33, 63, 128, 129};
+  is_self_testing = true;
+  long c = 0;
+  long N = sizeof(kSizes) / sizeof(kSizes[0]);
+  for (long i = 0; i < N; ++i) {
+    long m = kSizes[i];
+    for (long j = 0; j < N; ++j) {
+      long n = kSizes[N - 1 - i];
+      for (long k = 0; k < N; ++k) {
+        long K = kSizes[i];
+        if (c++ % 13 == 0) {
+          printf("testing %2ld %2ld %2ld\r", m, n, K);
+        }
+        test_gemm(m, n, K);
+      }
+    }
+  }
+  printf("\r");
+  is_self_testing = false;
+}
+
+long m = 2333 / 10;
+long k = 577 / 10;
+long n = 713 / 10;
+
+void check_sgemm(void) {
+  float *A = new float[m * k];
+  float *At = new float[k * m];
+  float *B = new float[k * n];
+  float *Bt = new float[n * k];
+  float *C = new float[m * n];
+  double *GOLD = new double[m * n];
+  fill(A, m * k);
+  fill(B, k * n);
+  transpose(m, k, A, k, At, m);
+  transpose(k, n, B, n, Bt, k);
+  bench(dgemm(0, 0, m, n, k, 1, A, k, B, n, 0, GOLD, n));
+  bench(sgemm(0, 0, m, n, k, 1, A, k, B, n, 0, C, n));
+  check(PRECISION, m, n, GOLD, n, C, n);
+  bench(sgemm(1, 0, m, n, k, 1, At, m, B, n, 0, C, n));
+  check(PRECISION, m, n, GOLD, n, C, n);
+  bench(sgemm(0, 1, m, n, k, 1, A, k, Bt, k, 0, C, n));
+  check(PRECISION, m, n, GOLD, n, C, n);
+  bench(sgemm(1, 1, m, n, k, 1, At, m, Bt, k, 0, C, n));
+  check(PRECISION, m, n, GOLD, n, C, n);
+  delete[] GOLD;
+  delete[] C;
+  delete[] Bt;
+  delete[] B;
+  delete[] At;
+  delete[] A;
+}
+
+int main(int argc, char *argv[]) {
+  check_gemm_works();
+  check_sgemm();
+}
diff --git a/test/math/bf16_test.c b/test/math/bf16_test.c
new file mode 100644
index 000000000..05df1f63f
--- /dev/null
+++ b/test/math/bf16_test.c
@@ -0,0 +1,110 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <math.h>
+
+#define CHECK(x) \
+  if (!(x))      \
+  return __LINE__
+#define FALSE(x)          \
+  {                       \
+    volatile bool x_ = x; \
+    if (x_)               \
+      return __LINE__;    \
+  }
+#define TRUE(x)           \
+  {                       \
+    volatile bool x_ = x; \
+    if (!x_)              \
+      return __LINE__;    \
+  }
+
+__bf16 identity(__bf16 x) {
+  return x;
+}
+__bf16 (*half)(__bf16) = identity;
+
+unsigned toint(float f) {
+  union {
+    float f;
+    unsigned i;
+  } u = {f};
+  return u.i;
+}
+
+int main() {
+  volatile float f;
+  volatile double d;
+  volatile __bf16 pi = 3.141;
+
+  // half → float → half
+  f = pi;
+  pi = f;
+
+  // half → float
+  float __extendbfsf2(__bf16);
+  CHECK(0.f == __extendbfsf2(0));
+  CHECK(3.140625f == __extendbfsf2(pi));
+  CHECK(3.140625f == pi);
+
+  // half → double → half
+  d = pi;
+  pi = d;
+
+  // float → half
+  __bf16 __truncsfbf2(float);
+  CHECK(0 == (float)__truncsfbf2(0));
+  CHECK(pi == (float)__truncsfbf2(3.141f));
+  CHECK(3.140625f == (float)__truncsfbf2(3.141f));
+
+  // double → half
+  __bf16 __truncdfbf2(double);
+  CHECK(0 == (double)__truncdfbf2(0));
+  CHECK(3.140625 == (double)__truncdfbf2(3.141));
+
+  // specials
+  volatile __bf16 nan = NAN;
+  volatile __bf16 positive_infinity = +INFINITY;
+  volatile __bf16 negative_infinity = -INFINITY;
+  CHECK(isnan(nan));
+  CHECK(!isinf(pi));
+  CHECK(!isnan(pi));
+  CHECK(isinf(positive_infinity));
+  CHECK(isinf(negative_infinity));
+  CHECK(!isnan(positive_infinity));
+  CHECK(!isnan(negative_infinity));
+  CHECK(!signbit(pi));
+  CHECK(signbit(half(-pi)));
+  CHECK(!signbit(half(+0.)));
+  CHECK(signbit(half(-0.)));
+
+  // arithmetic
+  CHECK(half(-3) == -half(3));
+  CHECK(half(9) == half(3) * half(3));
+  CHECK(half(0) == half(pi) - half(pi));
+  CHECK(half(6.28125) == half(pi) + half(pi));
+
+  // comparisons
+  CHECK(half(3) > half(2));
+  CHECK(half(3) < half(4));
+  CHECK(half(3) <= half(3));
+  CHECK(half(3) >= half(3));
+  TRUE(half(NAN) != half(NAN));
+  FALSE(half(NAN) == half(NAN));
+  TRUE(half(3) != half(NAN));
+  FALSE(half(3) == half(NAN));
+  TRUE(half(NAN) != half(3));
+  FALSE(half(NAN) == half(3));
+}
diff --git a/test/net/http/hascontrolcodes_test.c b/test/net/http/hascontrolcodes_test.c
index 0bead7c42..291fda443 100644
--- a/test/net/http/hascontrolcodes_test.c
+++ b/test/net/http/hascontrolcodes_test.c
@@ -31,7 +31,7 @@ TEST(HasControlCodes, test) {
 }
 
 TEST(HasControlCodes, testDoesUtf8) {
-  EXPECT_EQ(-1, HasControlCodes(u8"→", -1, kControlC0 | kControlC1));
+  EXPECT_EQ(-1, HasControlCodes("→", -1, kControlC0 | kControlC1));
   EXPECT_EQ(-1, HasControlCodes("\304\200", -1, kControlC0 | kControlC1));
   EXPECT_NE(-1, HasControlCodes("\300\200", -1, kControlC0 | kControlC1));
   EXPECT_EQ(-1, HasControlCodes("\300\200", -1, kControlC1));
diff --git a/test/net/http/parsehttpmessage_test.c b/test/net/http/parsehttpmessage_test.c
index 5a8412614..9b63cd629 100644
--- a/test/net/http/parsehttpmessage_test.c
+++ b/test/net/http/parsehttpmessage_test.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
+#include "libc/intrin/kprintf.h"
 #include "libc/log/check.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
@@ -434,6 +435,24 @@ TEST(ParseHttpResponse, testHttp100) {
   EXPECT_EQ(10, req->version);
 }
 
+TEST(ParseHttpMessage, issue1315) {
+  static const char m[] = "\
+HTTP/1.1 200 OK\r\n\
+padding: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\r\n\
+Date: Sat, 12 Oct 2024 22:50:55 GMT\r\n\
+Server: redbean/3.0.0\r\n\
+Connection: close\r\n\
+Content-Type: text/html; charset=utf-8\r\n\
+Referrer-Policy: no-referrer-when-downgrade\r\n\
+Content-Length: 12\r\n\
+\r\n";
+  InitHttpMessage(req, kHttpResponse);
+  EXPECT_EQ(0, ParseHttpMessage(req, m, strlen(m) - 1, strlen(m)));
+  EXPECT_EQ(200, req->status);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 void DoTiniestHttpRequest(void) {
   static const char m[] = "\
 GET /\r\n\
diff --git a/test/net/https/mbedtls_test.c b/test/net/https/mbedtls_test.c
index 34eea7401..992ffdf02 100644
--- a/test/net/https/mbedtls_test.c
+++ b/test/net/https/mbedtls_test.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bswap.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/nexgen32e/crc32.h"
 #include "libc/nexgen32e/nexgen32e.h"
diff --git a/test/posix/BUILD.mk b/test/posix/BUILD.mk
index dafa1d9c1..aabd202d6 100644
--- a/test/posix/BUILD.mk
+++ b/test/posix/BUILD.mk
@@ -3,59 +3,76 @@
 
 PKGS += TEST_POSIX
 
-TEST_POSIX_SRCS :=				\
+TEST_POSIX_SRCS :=							\
 	$(wildcard test/posix/*.c)
 
-TEST_POSIX_SRCS_TEST =				\
+TEST_POSIX_SRCS_TEST =							\
 	$(filter %_test.c,$(TEST_POSIX_SRCS))
 
-TEST_POSIX_OBJS =				\
+TEST_POSIX_OBJS =							\
 	$(TEST_POSIX_SRCS:%.c=o/$(MODE)/%.o)
 
-TEST_POSIX_COMS =				\
-	$(TEST_POSIX_SRCS_TEST:%.c=o/$(MODE)/%)
+TEST_POSIX_COMS =							\
+	$(TEST_POSIX_SRCS_TEST:%.c=o/$(MODE)/%)				\
+	o/$(MODE)/test/posix/file_offset_exec_prog
 
-TEST_POSIX_BINS =				\
-	$(TEST_POSIX_COMS)			\
+TEST_POSIX_BINS =							\
+	$(TEST_POSIX_COMS)						\
 	$(TEST_POSIX_COMS:%=%.dbg)
 
-TEST_POSIX_TESTS =				\
+TEST_POSIX_TESTS =							\
 	$(TEST_POSIX_SRCS_TEST:%.c=o/$(MODE)/%.ok)
 
-TEST_POSIX_CHECKS =				\
+TEST_POSIX_CHECKS =							\
 	$(TEST_POSIX_SRCS_TEST:%.c=o/$(MODE)/%.runs)
 
-TEST_POSIX_DIRECTDEPS =				\
-	LIBC_CALLS				\
-	LIBC_FMT				\
-	LIBC_INTRIN				\
-	LIBC_MEM				\
-	LIBC_PROC				\
-	LIBC_RUNTIME				\
-	LIBC_STDIO				\
-	LIBC_STR				\
-	LIBC_SYSV				\
-	LIBC_THREAD
+TEST_POSIX_DIRECTDEPS =							\
+	LIBC_CALLS							\
+	LIBC_FMT							\
+	LIBC_INTRIN							\
+	LIBC_MEM							\
+	LIBC_PROC							\
+	LIBC_LOG							\
+	LIBC_RUNTIME							\
+	LIBC_SOCK							\
+	LIBC_STDIO							\
+	LIBC_STR							\
+	LIBC_SYSV							\
+	LIBC_THREAD							\
+	THIRD_PARTY_MUSL						\
 
-TEST_POSIX_DEPS :=				\
+TEST_POSIX_DEPS :=							\
 	$(call uniq,$(foreach x,$(TEST_POSIX_DIRECTDEPS),$($(x))))
 
-o/$(MODE)/test/posix/posix.pkg:			\
-		$(TEST_POSIX_OBJS)		\
+o/$(MODE)/test/posix/posix.pkg:						\
+		$(TEST_POSIX_OBJS)					\
 		$(foreach x,$(TEST_POSIX_DIRECTDEPS),$($(x)_A).pkg)
 
-o/$(MODE)/test/posix/%.dbg:			\
-		$(TEST_POSIX_DEPS)		\
-		o/$(MODE)/test/posix/%.o	\
-		o/$(MODE)/test/posix/posix.pkg	\
-		$(CRT)				\
+o/$(MODE)/test/posix/%.dbg:						\
+		$(TEST_POSIX_DEPS)					\
+		o/$(MODE)/test/posix/%.o				\
+		o/$(MODE)/test/posix/posix.pkg				\
+		$(CRT)							\
 		$(APE_NO_MODIFY_SELF)
 	@$(APELINK)
 
-o/$(MODE)/test/posix/fread3gb_test.runs:	\
+o/$(MODE)/test/posix/file_offset_exec_test.dbg:				\
+		$(TEST_POSIX_DEPS)					\
+		o/$(MODE)/test/posix/file_offset_exec_test.o		\
+		o/$(MODE)/test/posix/file_offset_exec_prog.zip.o	\
+		o/$(MODE)/test/posix/posix.pkg				\
+		$(CRT)							\
+		$(APE_NO_MODIFY_SELF)
+	@$(APELINK)
+
+o/$(MODE)/test/posix/file_offset_exec_prog.zip.o: private		\
+		ZIPOBJ_FLAGS +=						\
+			-B
+
+o/$(MODE)/test/posix/fread3gb_test.runs:				\
 		private QUOTA += -F5gb -M5gb
 
 .PHONY: o/$(MODE)/test/posix
-o/$(MODE)/test/posix:				\
-		$(TEST_POSIX_BINS)		\
+o/$(MODE)/test/posix:							\
+		$(TEST_POSIX_BINS)					\
 		$(TEST_POSIX_CHECKS)
diff --git a/test/posix/accept4_nonblock_test.c b/test/posix/accept4_nonblock_test.c
new file mode 100644
index 000000000..2033e3d76
--- /dev/null
+++ b/test/posix/accept4_nonblock_test.c
@@ -0,0 +1,71 @@
+#include <arpa/inet.h>
+#include <cosmo.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+int main() {
+
+  // Create server socket
+  int server_fd;
+  struct sockaddr_in address;
+  int addrlen = sizeof(address);
+  if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    return 1;
+  address.sin_family = AF_INET;
+  address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  address.sin_port = 0;  // let os assign random port
+  if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)))
+    return 2;
+  if (getsockname(server_fd, (struct sockaddr *)&address,
+                  (socklen_t *)&addrlen))
+    return 3;
+  if (listen(server_fd, SOMAXCONN))
+    return 4;
+
+  {
+    // poll server
+    struct pollfd fds[2] = {
+        {server_fd, POLLIN | POLLOUT},
+    };
+    int ret = poll(fds, 1, 0);
+    if (ret != 0)
+      return 5;
+  }
+
+  // create client socket
+  int client_fd;
+  if ((client_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    return 6;
+  if (connect(client_fd, (struct sockaddr *)&address, sizeof(address)))
+    return 7;
+
+  // accept client
+  int server_client_fd;
+  if ((server_client_fd = accept4(server_fd, 0, 0, SOCK_NONBLOCK)) == -1)
+    return 8;
+
+  // check that it's non-blocking
+  char buf[1];
+  if (read(server_client_fd, buf, 1) != -1)
+    return 9;
+  if (errno != EAGAIN && errno != EWOULDBLOCK)
+    return 10;
+
+  // Clean up
+  if (close(server_client_fd))
+    return 12;
+  if (close(client_fd))
+    return 13;
+  if (close(server_fd))
+    return 14;
+
+  CheckForMemoryLeaks();
+}
diff --git a/test/posix/accept_inherit_nonblock_test.c b/test/posix/accept_inherit_nonblock_test.c
new file mode 100644
index 000000000..42a938e06
--- /dev/null
+++ b/test/posix/accept_inherit_nonblock_test.c
@@ -0,0 +1,85 @@
+#include <arpa/inet.h>
+#include <cosmo.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <poll.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+void on_signal(int sig) {
+}
+
+int main() {
+
+  // Create server socket
+  int server_fd;
+  struct sockaddr_in address;
+  int addrlen = sizeof(address);
+  if ((server_fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0)) == -1)
+    return 1;
+  address.sin_family = AF_INET;
+  address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  address.sin_port = 0;  // let os assign random port
+  if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)))
+    return 2;
+  if (getsockname(server_fd, (struct sockaddr *)&address,
+                  (socklen_t *)&addrlen))
+    return 3;
+  if (listen(server_fd, SOMAXCONN))
+    return 4;
+
+  {
+    // poll server
+    struct pollfd fds[] = {{server_fd, POLLIN | POLLOUT}};
+    int ret = poll(fds, 1, 0);
+    if (ret != 0)
+      return 5;
+  }
+
+  // verify server socket is non-blocking
+  if (accept(server_fd, 0, 0) != -1)
+    return 20;
+  if (errno != EAGAIN && errno != EWOULDBLOCK)
+    return 21;
+
+  // create client socket
+  int client_fd;
+  if ((client_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    return 6;
+  if (connect(client_fd, (struct sockaddr *)&address, sizeof(address)))
+    return 7;
+
+  // prevent race condition
+  // impacts platforms like openbsd
+  fcntl(server_fd, F_SETFL, fcntl(server_fd, F_GETFL) & ~O_NONBLOCK);
+
+  // accept client
+  int server_client_fd;
+  if ((server_client_fd = accept(server_fd, 0, 0)) == -1)
+    return 8;
+
+  // check that non-blocking wasn't inherited from listener
+  char buf[1];
+  sigaction(SIGALRM, &(struct sigaction){.sa_handler = on_signal}, 0);
+  ualarm(100000, 0);
+  if (read(server_client_fd, buf, 1) != -1)
+    return 9;
+  if (errno != EINTR)
+    return 10;
+
+  // Clean up
+  if (close(server_client_fd))
+    return 12;
+  if (close(client_fd))
+    return 13;
+  if (close(server_fd))
+    return 14;
+
+  CheckForMemoryLeaks();
+}
diff --git a/test/posix/accept_poll_test.c b/test/posix/accept_poll_test.c
new file mode 100644
index 000000000..da6dfbcba
--- /dev/null
+++ b/test/posix/accept_poll_test.c
@@ -0,0 +1,94 @@
+#include <arpa/inet.h>
+#include <cosmo.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+int main() {
+
+  // Create server socket
+  int server_fd;
+  struct sockaddr_in address;
+  int addrlen = sizeof(address);
+  if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    return 1;
+  address.sin_family = AF_INET;
+  address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  address.sin_port = 0;  // let os assign random port
+  if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)))
+    return 2;
+  if (getsockname(server_fd, (struct sockaddr *)&address,
+                  (socklen_t *)&addrlen))
+    return 3;
+  if (listen(server_fd, SOMAXCONN))
+    return 4;
+
+  {
+    // poll server
+    struct pollfd fds[2] = {
+        {server_fd, POLLIN | POLLOUT},
+    };
+    int ret = poll(fds, 1, 0);
+    if (ret != 0)
+      return 5;
+  }
+
+  // create client socket
+  int client_fd;
+  if ((client_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    return 6;
+  if (connect(client_fd, (struct sockaddr *)&address, sizeof(address)))
+    return 7;
+
+  {
+    // poll server
+    struct pollfd fds[] = {{server_fd, POLLIN | POLLOUT}};
+    int ret = poll(fds, 1, -1u);
+    if (ret != 1)
+      return 8;
+    if (!(fds[0].revents & POLLIN))
+      return 9;
+    if (fds[0].revents & POLLOUT)
+      return 10;
+    if (fds[0].revents & POLLHUP)
+      return 11;
+    if (fds[0].revents & POLLERR)
+      return 12;
+  }
+
+  {
+    // poll server with invalid thing
+    struct pollfd fds[] = {
+        {server_fd, POLLIN | POLLOUT},
+        {666, POLLIN | POLLOUT},
+    };
+    int ret = poll(fds, 2, -1u);
+    if (ret != 2)
+      return 18;
+    if (!(fds[0].revents & POLLIN))
+      return 19;
+    if (fds[0].revents & POLLOUT)
+      return 20;
+    if (fds[1].revents & POLLIN)
+      return 21;
+    if (fds[1].revents & POLLOUT)
+      return 22;
+    if (!(fds[1].revents & POLLNVAL))
+      return 23;
+  }
+
+  // Clean up
+  if (close(client_fd))
+    return 13;
+  if (close(server_fd))
+    return 14;
+
+  CheckForMemoryLeaks();
+}
diff --git a/test/posix/connect_nonblock_test.c b/test/posix/connect_nonblock_test.c
new file mode 100644
index 000000000..7655ef1a0
--- /dev/null
+++ b/test/posix/connect_nonblock_test.c
@@ -0,0 +1,260 @@
+#include <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main() {
+  char buffer[1024];
+  fd_set wset;
+  int listenfd, connfd, sockfd;
+  int s, error;
+  pid_t pid;
+  socklen_t len;
+  struct sockaddr_in serv_addr, cli_addr;
+  uint16_t port;
+
+  printf("\n");
+
+  /* Create listening socket */
+  listenfd = socket(AF_INET, SOCK_STREAM, 0);
+  if (listenfd < 0) {
+    perror("socket() failed");
+    exit(1);
+  }
+
+  /* Initialize server address */
+  memset(&serv_addr, 0, sizeof(serv_addr));
+  serv_addr.sin_family = AF_INET;
+  serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  serv_addr.sin_port = htons(0);
+
+  /* Bind socket */
+  if (bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
+    perror("bind");
+    exit(2);
+  }
+
+  /* Get the assigned port number */
+  len = sizeof(serv_addr);
+  if (getsockname(listenfd, (struct sockaddr *)&serv_addr, &len) < 0) {
+    perror("getsockname");
+    exit(3);
+  }
+  port = ntohs(serv_addr.sin_port);
+
+  /* Listen on the socket */
+  if (listen(listenfd, 1) < 0) {
+    perror("listen");
+    exit(4);
+  }
+
+  /* Fork a child process */
+  pid = fork();
+  if (pid < 0) {
+    perror("fork");
+    exit(5);
+  } else if (pid == 0) {
+    /* Child process: acts as the client */
+    close(listenfd); /* Close the listening socket in the child */
+
+    /* Create socket */
+    sockfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
+    if (sockfd < 0) {
+      perror("socket");
+      exit(6);
+    }
+
+    /* Initialize server address */
+    memset(&serv_addr, 0, sizeof(serv_addr));
+    serv_addr.sin_family = AF_INET;
+    serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); /* 127.0.0.1 */
+    serv_addr.sin_port = htons(port);                   /* Assigned port */
+
+    /* Try calling read() before connection is established */
+    s = read(sockfd, buffer, sizeof(buffer));
+    if (s < 0) {
+      if (errno == ENOTCONN) {
+        printf("read #1 enotconn\n");
+        /* good */
+      } else {
+        perror("read #1");
+        exit(6);
+      }
+    } else {
+      printf("read #1 succeeded\n");
+      exit(6);
+    }
+
+#if 0
+    /* Try calling read() before connection is established */
+    s = write(sockfd, buffer, sizeof(buffer));
+    if (s < 0) {
+      if (errno == ENOTCONN) {
+        /* good */
+      } else {
+        perror("write");
+      }
+    } else {
+      printf("Wrote %d bytes: %.*s\n", s, s, buffer);
+    }
+#endif
+
+    /* Attempt to connect */
+    s = connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
+    if (s == 0) {
+      printf("connect #1 success\n");
+    } else if (s < 0 && errno == EINPROGRESS) {
+      printf("connect #1 einprogress\n");
+    } else {
+      perror("connect #1");
+      exit(10);
+    }
+
+    /* Try calling read() before connection is established */
+    s = read(sockfd, buffer, sizeof(buffer));
+    if (s < 0) {
+      if (errno == EAGAIN) {
+        printf("read #2 eagain\n");
+      } else {
+        perror("read #2");
+        exit(10);
+      }
+    } else {
+      printf("read #2 succeeded\n");
+      exit(10);
+    }
+
+    /* Try calling connect() again to trigger EALREADY */
+    s = connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
+    if (!s) {
+      printf("connect #2 succeeded\n");
+    } else if (s < 0 && errno == EALREADY) {
+      printf("connect #2 ealready\n");
+    } else if (s < 0 && errno == EISCONN) {
+      printf("connect #2 eisconn\n");
+    } else if (s < 0) {
+      perror("connect #2");
+      exit(11);
+    }
+
+    /* Try calling connect() again to trigger EALREADY */
+    s = connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
+    if (!s) {
+      printf("connect #3 succeeded\n");
+    } else if (errno == EALREADY) {
+      printf("connect #3 ealready\n");
+    } else if (errno == EISCONN) {
+      printf("connect #3 eisconn\n");
+    } else {
+      perror("connect");
+      exit(11);
+    }
+
+    /* Try calling read() before connection is established */
+    s = read(sockfd, buffer, sizeof(buffer));
+    if (s < 0) {
+      if (errno == EAGAIN) {
+        /* good */
+      } else {
+        perror("read");
+      }
+    } else {
+      printf("Read %d bytes: %.*s\n", s, s, buffer);
+    }
+
+    /* Use select() to wait for the socket to be writable */
+    FD_ZERO(&wset);
+    FD_SET(sockfd, &wset);
+
+    s = select(sockfd + 1, NULL, &wset, NULL, 0);
+    if (s == 0) {
+      printf("not possible\n");
+      exit(11);
+    } else if (s < 0) {
+      perror("select");
+      exit(12);
+    }
+
+    /* Check if socket is writable */
+    if (FD_ISSET(sockfd, &wset)) {
+      /* Check for error */
+      len = sizeof(error);
+      if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
+        exit(13);
+      if (error) {
+        printf("connection failed after select(): %s\n", strerror(error));
+        exit(14);
+      }
+    } else {
+      exit(16);
+    }
+
+    /* Try calling connect() again to trigger EISCONN */
+    s = connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
+    if (!s) {
+      printf("connect #4 succeeded\n");
+    } else if (s < 0 && errno == EISCONN) {
+      printf("connect #4 eisconn\n");
+    } else if (s < 0) {
+      exit(17);
+    }
+
+    if (close(sockfd))
+      exit(15);
+    exit(0);
+  } else {
+    /* Accept connection */
+    len = sizeof(cli_addr);
+    connfd = accept(listenfd, (struct sockaddr *)&cli_addr, &len);
+    if (connfd < 0) {
+      close(listenfd);
+      wait(NULL);
+      exit(18);
+    }
+
+    /* Read data from client */
+    s = read(connfd, buffer, sizeof(buffer));
+    if (s < 0) {
+      exit(51);
+    } else if (!s) {
+      /* got close */
+    } else {
+      exit(50);
+    }
+
+    /* Close connected socket */
+    if (close(connfd)) {
+      close(listenfd);
+      wait(NULL);
+      exit(19);
+    }
+
+    /* Close listening socket */
+    if (close(listenfd)) {
+      wait(NULL);
+      exit(20);
+    }
+
+    /* Wait for child process to finish */
+    int status;
+    if (waitpid(pid, &status, 0) < 0)
+      exit(21);
+
+    printf("\n");
+    if (WIFEXITED(status)) {
+      exit(WEXITSTATUS(status)); /* Return child's exit status */
+    } else {
+      exit(22);
+    }
+  }
+
+  exit(23);
+}
diff --git a/test/posix/cyclic_mutex_test.c b/test/posix/cyclic_mutex_test.c
new file mode 100644
index 000000000..28c733751
--- /dev/null
+++ b/test/posix/cyclic_mutex_test.c
@@ -0,0 +1,71 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <cosmo.h>
+#include <errno.h>
+#include <pthread.h>
+#include <signal.h>
+
+pthread_mutex_t x;
+pthread_mutex_t y;
+
+void ignore_signal(int sig) {
+}
+
+int main(int argc, char *argv[]) {
+
+#ifdef MODE_DBG
+  GetSymbolTable();
+  signal(SIGTRAP, ignore_signal);
+  kprintf("running %s\n", argv[0]);
+#endif
+
+  pthread_mutexattr_t attr;
+  if (pthread_mutexattr_init(&attr))
+    return 1;
+  if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK))
+    return 2;
+  if (pthread_mutex_init(&x, &attr))
+    return 3;
+  if (pthread_mutex_init(&y, &attr))
+    return 4;
+  if (pthread_mutexattr_destroy(&attr))
+    return 5;
+
+  if (pthread_mutex_lock(&x))
+    return 6;
+  if (pthread_mutex_lock(&y))
+    return 7;
+  if (pthread_mutex_unlock(&y))
+    return 8;
+  if (pthread_mutex_unlock(&x))
+    return 9;
+
+  if (pthread_mutex_lock(&y))
+    return 10;
+  if (pthread_mutex_lock(&y) != EDEADLK)
+    return 11;
+  if (pthread_mutex_lock(&x) != EDEADLK)
+    return 12;
+  if (pthread_mutex_unlock(&x) != EPERM)
+    return 13;
+  if (pthread_mutex_unlock(&y))
+    return 14;
+
+  if (pthread_mutex_destroy(&y))
+    return 15;
+  if (pthread_mutex_destroy(&x))
+    return 16;
+}
diff --git a/test/posix/exit_async_signal_safety_test.c b/test/posix/exit_async_signal_safety_test.c
new file mode 100644
index 000000000..2eaa65192
--- /dev/null
+++ b/test/posix/exit_async_signal_safety_test.c
@@ -0,0 +1,30 @@
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+atomic_bool ready;
+
+void* work(void* arg) {
+  pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0);
+  ready = true;
+  pthread_exit(0);
+}
+
+int main() {
+
+  for (int i = 0; i < 1000; ++i) {
+    pthread_t th;
+    if (pthread_create(&th, 0, work, 0))
+      _Exit(1);
+    for (;;)
+      if (ready)
+        break;
+    pthread_cancel(th);
+    if (pthread_join(th, 0))
+      _Exit(3);
+  }
+
+  while (!pthread_orphan_np())
+    pthread_decimate_np();
+}
diff --git a/test/posix/file_offset_exec_prog.c b/test/posix/file_offset_exec_prog.c
new file mode 100644
index 000000000..31f19560b
--- /dev/null
+++ b/test/posix/file_offset_exec_prog.c
@@ -0,0 +1,63 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <stdatomic.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+// subprogram for testing that lseek() is shared across execve()
+
+atomic_int *phase;
+
+int main(int argc, char *argv[]) {
+
+  if (argc != 3)
+    return 101;
+
+  int fd = atoi(argv[1]);
+  int mapfd = atoi(argv[2]);
+
+  if ((phase = mmap(0, sizeof(atomic_int), PROT_READ | PROT_WRITE, MAP_SHARED,
+                    mapfd, 0)) == MAP_FAILED)
+    return 102;
+
+  if (write(fd, "1", 1) != 1)
+    return 103;
+  if (lseek(fd, 0, SEEK_CUR) != 2)
+    return 104;
+
+  *phase = 1;
+  for (;;)
+    if (*phase == 2)
+      break;
+
+  if (write(fd, "3", 1) != 1)
+    return 105;
+  if (lseek(fd, 0, SEEK_CUR) != 4)
+    return 106;
+
+  *phase = 3;
+  for (;;)
+    if (*phase == 4)
+      break;
+
+  if (munmap(phase, sizeof(atomic_int)))
+    return 107;
+  if (close(mapfd))
+    return 108;
+  if (close(fd))
+    return 109;
+}
diff --git a/test/posix/file_offset_exec_test.c b/test/posix/file_offset_exec_test.c
new file mode 100644
index 000000000..e9b9e94ba
--- /dev/null
+++ b/test/posix/file_offset_exec_test.c
@@ -0,0 +1,164 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <cosmo.h>
+#include <signal.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+// test that lseek() is shared across execve()
+
+__static_yoink("zipos");
+
+void on_unexpected_death(int sig) {
+  int ws;
+  if (wait(&ws) == -1)
+    _Exit(33);
+  if (!WIFEXITED(ws))
+    _Exit(34);
+  if (!(WEXITSTATUS(ws) & 255))
+    _Exit(35);
+  _Exit(WEXITSTATUS(ws));
+}
+
+int main() {
+
+  signal(SIGCHLD, on_unexpected_death);
+
+  // extract test program
+  int exefd;
+  int zipfd;
+  ssize_t got;
+  char exepath[] = "/tmp/file_offset_exec_prog.XXXXXX";
+  if ((exefd = mkstemp(exepath)) == -1)
+    return 2;
+  if (fchmod(exefd, 0755))
+    return 3;
+  if ((zipfd = open("/zip/file_offset_exec_prog", O_RDONLY)) == -1)
+    return 4;
+  for (;;) {
+    char chunk[512];
+    if ((got = read(zipfd, chunk, sizeof(chunk))) == -1)
+      return 5;
+    if (!got)
+      break;
+    if (write(exefd, chunk, got) != got)
+      return 6;
+  }
+  if (close(zipfd))
+    return 7;
+  if (close(exefd))
+    return 8;
+
+  // create file shared memory mapping for synchronization
+  int mapfd;
+  atomic_int *phase;
+  char mappath[] = "/tmp/file_offset_exec_phase.XXXXXX";
+  if ((mapfd = mkstemp(mappath)) == -1)
+    return 9;
+  if (ftruncate(mapfd, sizeof(atomic_int)))
+    return 10;
+  if ((phase = mmap(0, sizeof(atomic_int), PROT_READ | PROT_WRITE, MAP_SHARED,
+                    mapfd, 0)) == MAP_FAILED)
+    return 11;
+
+  // create test file to which both processes shall be writing
+  int fd;
+  char path[] = "/tmp/file_offset_exec_file.XXXXXX";
+  if ((fd = mkstemp(path)) == -1)
+    return 12;
+  if (lseek(fd, 0, SEEK_CUR) != 0)
+    return 13;
+
+  // start writing to file
+  if (write(fd, "0", 1) != 1)
+    return 14;
+  if (lseek(fd, 0, SEEK_CUR) != 1)
+    return 15;
+
+  // spawn program
+  int pid;
+  if ((pid = fork()) == -1)
+    return 16;
+  if (!pid) {
+    char str[2][12];
+    char *envs[] = {0};
+    char *args[] = {exepath, str[0], str[1], 0};
+    sprintf(str[0], "%d", fd);
+    sprintf(str[1], "%d", mapfd);
+    execve(exepath, args, envs);
+    _Exit(17);
+  }
+
+  for (;;)
+    if (*phase == 1)
+      break;
+
+  if (write(fd, "2", 1) != 1)
+    return 18;
+  if (lseek(fd, 0, SEEK_CUR) != 3)
+    return 19;
+
+  *phase = 2;
+  for (;;)
+    if (*phase == 3)
+      break;
+
+  if (write(fd, "4", 1) != 1)
+    return 20;
+  if (lseek(fd, 0, SEEK_CUR) != 5)
+    return 21;
+
+  signal(SIGCHLD, SIG_DFL);
+  *phase = 4;
+
+  int ws;
+  if (wait(&ws) == -1)
+    return 22;
+  if (!WIFEXITED(ws))
+    return 23;
+  if (WEXITSTATUS(ws))
+    return WEXITSTATUS(ws);
+
+  char buf[16] = {0};
+  if (pread(fd, buf, 15, 0) != 5)
+    return 24;
+  if (lseek(fd, 0, SEEK_CUR) != 5)
+    return 25;
+
+  if (close(fd))
+    return 26;
+
+  if (unlink(path))
+    return 27;
+
+  if (unlink(exepath))
+    return 28;
+
+  if (munmap(phase, sizeof(atomic_int)))
+    return 29;
+
+  if (close(mapfd))
+    return 30;
+
+  if (unlink(mappath))
+    return 31;
+
+  if (strcmp(buf, "01234"))
+    return 32;
+}
diff --git a/test/posix/file_offset_fork_test.c b/test/posix/file_offset_fork_test.c
new file mode 100644
index 000000000..72a02014b
--- /dev/null
+++ b/test/posix/file_offset_fork_test.c
@@ -0,0 +1,130 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <signal.h>
+#include <stdatomic.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+// test that lseek() is shared across fork()
+
+void on_unexpected_death(int sig) {
+  int ws;
+  if (wait(&ws) == -1)
+    _Exit(33);
+  if (!WIFEXITED(ws))
+    _Exit(34);
+  if (!(WEXITSTATUS(ws) & 255))
+    _Exit(35);
+  _Exit(WEXITSTATUS(ws));
+}
+
+int main() {
+  signal(SIGCHLD, on_unexpected_death);
+
+  atomic_int *phase;
+  if ((phase = mmap(0, sizeof(atomic_int), PROT_READ | PROT_WRITE,
+                    MAP_SHARED | MAP_ANONYMOUS, -1, 0)) == MAP_FAILED)
+    return 2;
+
+  int fd;
+  char path[] = "/tmp/file_offset_fork_test.XXXXXX";
+  if ((fd = mkstemp(path)) == -1)
+    return 3;
+  if (lseek(fd, 0, SEEK_CUR) != 0)
+    return 4;
+
+  if (write(fd, "0", 1) != 1)
+    return 5;
+  if (lseek(fd, 0, SEEK_CUR) != 1)
+    return 6;
+
+  int pid;
+  if ((pid = fork()) == -1)
+    return 7;
+
+  if (!pid) {
+    if (write(fd, "1", 1) != 1)
+      _Exit(8);
+    if (lseek(fd, 0, SEEK_CUR) != 2)
+      _Exit(9);
+
+    *phase = 1;
+    for (;;)
+      if (*phase == 2)
+        break;
+
+    if (write(fd, "3", 1) != 1)
+      _Exit(10);
+    if (lseek(fd, 0, SEEK_CUR) != 4)
+      _Exit(11);
+
+    *phase = 3;
+    for (;;)
+      if (*phase == 4)
+        break;
+
+    _Exit(0);
+  }
+
+  for (;;)
+    if (*phase == 1)
+      break;
+
+  if (write(fd, "2", 1) != 1)
+    return 12;
+  if (lseek(fd, 0, SEEK_CUR) != 3)
+    return 13;
+
+  *phase = 2;
+  for (;;)
+    if (*phase == 3)
+      break;
+
+  if (write(fd, "4", 1) != 1)
+    return 14;
+  if (lseek(fd, 0, SEEK_CUR) != 5)
+    return 15;
+
+  signal(SIGCHLD, SIG_DFL);
+  *phase = 4;
+
+  int ws;
+  if (wait(&ws) == -1)
+    return 16;
+  if (!WIFEXITED(ws))
+    return 17;
+  if (WEXITSTATUS(ws))
+    return WEXITSTATUS(ws);
+
+  char buf[16] = {0};
+  if (pread(fd, buf, 15, 0) != 5)
+    return 18;
+  if (lseek(fd, 0, SEEK_CUR) != 5)
+    return 19;
+
+  if (close(fd))
+    return 20;
+
+  if (munmap(phase, sizeof(atomic_int)))
+    return 21;
+
+  if (unlink(path))
+    return 22;
+
+  if (strcmp(buf, "01234"))
+    return 23;
+}
diff --git a/test/posix/forjustine_test.c b/test/posix/forjustine_test.c
new file mode 100644
index 000000000..58663a2a3
--- /dev/null
+++ b/test/posix/forjustine_test.c
@@ -0,0 +1,49 @@
+// for justine with love 2025-01-02
+#include <poll.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdatomic.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+static bool altstack_installed;
+
+static void* chump(void* v) {
+  stack_t* s = v;
+  if (sigaltstack(s, NULL)) {
+    pthread_mutex_lock(&lock);
+    altstack_installed = true;
+    pthread_mutex_unlock(&lock);
+    pthread_cond_signal(&cond);
+    return NULL;
+  }
+  pthread_mutex_lock(&lock);
+  altstack_installed = true;
+  pthread_cond_signal(&cond);
+  pthread_mutex_unlock(&lock);
+  while (1)
+    poll(NULL, 0, -1);
+  return NULL;
+}
+
+int main(void) {
+  void* v;
+  stack_t s = {.ss_size = sysconf(_SC_SIGSTKSZ)};
+  s.ss_sp = malloc(s.ss_size);
+  if (s.ss_sp == NULL)
+    return EXIT_FAILURE;
+  pthread_t tid;
+  if (pthread_create(&tid, NULL, chump, &s))
+    return EXIT_FAILURE;
+  pthread_mutex_lock(&lock);
+  while (!altstack_installed)
+    pthread_cond_wait(&cond, &lock);
+  pthread_mutex_unlock(&lock);
+  free(s.ss_sp);
+  if (pthread_cancel(tid) || pthread_join(tid, &v))
+    return EXIT_FAILURE;
+  return v == PTHREAD_CANCELED ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/test/posix/fork_bench_test.c b/test/posix/fork_bench_test.c
new file mode 100644
index 000000000..6f962f89c
--- /dev/null
+++ b/test/posix/fork_bench_test.c
@@ -0,0 +1,29 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <stdlib.h>
+#include <unistd.h>
+#include "libc/testlib/benchmark.h"
+
+void TestFork(void) {
+  int pid;
+  if (!(pid = fork()))
+    _Exit(0);
+  wait(0);
+}
+
+int main(int argc, char *argv[]) {
+  BENCHMARK(100, 1, TestFork());
+}
diff --git a/test/posix/iconv_utf8_utf16_test.c b/test/posix/iconv_utf8_utf16_test.c
new file mode 100644
index 000000000..f582749b9
--- /dev/null
+++ b/test/posix/iconv_utf8_utf16_test.c
@@ -0,0 +1,173 @@
+#include <errno.h>
+#include <iconv.h>
+#include <stdlib.h>
+#include <string.h>
+#include <uchar.h>
+
+#define INBUF_SIZE  1024
+#define OUTBUF_SIZE 2048
+
+int g_count;
+
+int check_conversion(const char* input, size_t input_len,
+                     const char16_t* expected_output, size_t expected_len) {
+  iconv_t cd;
+  char inbuf[INBUF_SIZE];
+  char outbuf[OUTBUF_SIZE];
+  char* inptr = inbuf;
+  char* outptr = outbuf;
+  size_t inbytesleft = input_len;
+  size_t outbytesleft = OUTBUF_SIZE;
+  size_t result;
+
+  ++g_count;
+
+  memcpy(inbuf, input, input_len);
+
+  cd = iconv_open("UTF-16LE", "UTF-8");
+  if (cd == (iconv_t)-1) {
+    return 10 + g_count;  // iconv_open failed
+  }
+
+  result = iconv(cd, &inptr, &inbytesleft, &outptr, &outbytesleft);
+  if (result == (size_t)-1) {
+    iconv_close(cd);
+    return 20 + g_count;  // iconv failed, return 20 + specific errno
+  }
+
+  if (inbytesleft != 0) {
+    iconv_close(cd);
+    return 40 + g_count;  // Not all input was converted
+  }
+
+  size_t output_len = OUTBUF_SIZE - outbytesleft;
+  if (output_len != expected_len) {
+    iconv_close(cd);
+    return 50 + g_count;  // Output length mismatch
+  }
+
+  if (memcmp(outbuf, expected_output, output_len) != 0) {
+    iconv_close(cd);
+    return 60 + g_count;  // Output content mismatch
+  }
+
+  if (iconv_close(cd) == -1)
+    return 70 + g_count;  // iconv_close failed
+
+  // Reverse direction check: UTF-16LE back to UTF-8
+  cd = iconv_open("UTF-8", "UTF-16LE");
+  if (cd == (iconv_t)-1) {
+    return 80 + g_count;  // iconv_open failed for reverse direction
+  }
+
+  char reverse_inbuf[OUTBUF_SIZE];
+  char reverse_outbuf[INBUF_SIZE];
+  char* reverse_inptr = reverse_inbuf;
+  char* reverse_outptr = reverse_outbuf;
+  size_t reverse_inbytesleft = output_len;
+  size_t reverse_outbytesleft = INBUF_SIZE;
+
+  memcpy(reverse_inbuf, outbuf, output_len);
+
+  result = iconv(cd, &reverse_inptr, &reverse_inbytesleft, &reverse_outptr,
+                 &reverse_outbytesleft);
+  if (result == (size_t)-1) {
+    iconv_close(cd);
+    return 90 + g_count;  // iconv failed for reverse direction
+  }
+
+  if (reverse_inbytesleft != 0) {
+    iconv_close(cd);
+    return 100 + g_count;  // Not all input was converted in reverse direction
+  }
+
+  size_t reverse_output_len = INBUF_SIZE - reverse_outbytesleft;
+  if (reverse_output_len != input_len) {
+    iconv_close(cd);
+    return 110 + g_count;  // Reverse output length mismatch
+  }
+
+  if (memcmp(reverse_outbuf, input, input_len) != 0) {
+    iconv_close(cd);
+    return 120 + g_count;  // Reverse output content mismatch
+  }
+
+  if (iconv_close(cd) == -1)
+    return 130 + g_count;  // iconv_close failed for reverse direction
+
+  return 0;  // Success
+}
+
+int main() {
+  // Test case 1: Basic ASCII
+  const char input1[] = "Hello, world!";
+  const char16_t expected1[] = u"Hello, world!";
+  int result = check_conversion(input1, sizeof(input1) - 1, expected1,
+                                sizeof(expected1) - 2);
+  if (result != 0)
+    return result;
+
+  // Test case 2: Non-ASCII characters and newline
+  const char input2[] = "こんにちは\nWorld! ☺";
+  const char16_t expected2[] = u"こんにちは\nWorld! ☺";
+  result = check_conversion(input2, sizeof(input2) - 1, expected2,
+                            sizeof(expected2) - 2);
+  if (result != 0)
+    return result;
+
+  // Test case 3: Empty string
+  const char input3[] = "";
+  const char16_t expected3[] = u"";
+  result = check_conversion(input3, 0, expected3, 0);
+  if (result != 0)
+    return result;
+
+  // Test case 4: String with null characters
+  const char input4[] = "Hello\0World";
+  const char16_t expected4[] = u"Hello\0World";
+  result = check_conversion(input4, sizeof(input4) - 1, expected4,
+                            sizeof(expected4) - 2);
+  if (result != 0)
+    return result;
+
+  // Test case 5: Long string to test buffer handling
+  char input5[INBUF_SIZE];
+  char16_t expected5[INBUF_SIZE];
+  memset(input5, 'A', INBUF_SIZE - 1);
+  input5[INBUF_SIZE - 1] = '\0';
+  for (int i = 0; i < INBUF_SIZE - 1; i++) {
+    expected5[i] = u'A';
+  }
+  result =
+      check_conversion(input5, INBUF_SIZE - 1, expected5, (INBUF_SIZE - 1) * 2);
+  if (result != 0)
+    return result;
+
+  // Test case 6: Invalid UTF-8 sequence
+  const char input6[] = {0xC0, 0x80};
+  result = check_conversion(input6, sizeof(input6), NULL, 0);
+  if (result != 26) {
+    if (errno != EILSEQ)
+      return 201;
+    return 200;
+  }
+
+  // Test case 7: Mixing ASCII and non-ASCII
+  const char input7[] = "Hello, 世界!";
+  const char16_t expected7[] = u"Hello, 世界!";
+  result = check_conversion(input7, sizeof(input7) - 1, expected7,
+                            sizeof(expected7) - 2);
+  if (result != 0)
+    return result;
+
+  // Test case 8: Surrogate pairs
+  const char input8[] = "𐐷";  // U+10437
+  const char16_t expected8[] =
+      u"𐐷";  // This will be encoded as a surrogate pair
+  result = check_conversion(input8, sizeof(input8) - 1, expected8,
+                            sizeof(expected8) - 2);
+  if (result != 0)
+    return result;
+
+  return 0;  // All tests passed
+}
diff --git a/test/posix/iconv_utf8_utf32_test.c b/test/posix/iconv_utf8_utf32_test.c
new file mode 100644
index 000000000..2486bdb22
--- /dev/null
+++ b/test/posix/iconv_utf8_utf32_test.c
@@ -0,0 +1,172 @@
+#include <errno.h>
+#include <iconv.h>
+#include <stdlib.h>
+#include <string.h>
+#include <uchar.h>
+
+#define INBUF_SIZE  1024
+#define OUTBUF_SIZE 4096
+
+int g_count;
+
+int check_conversion(const char* input, size_t input_len,
+                     const wchar_t* expected_output, size_t expected_len) {
+  iconv_t cd;
+  char inbuf[INBUF_SIZE];
+  char outbuf[OUTBUF_SIZE];
+  char* inptr = inbuf;
+  char* outptr = outbuf;
+  size_t inbytesleft = input_len;
+  size_t outbytesleft = OUTBUF_SIZE;
+  size_t result;
+
+  ++g_count;
+
+  memcpy(inbuf, input, input_len);
+
+  cd = iconv_open("UTF-32LE", "UTF-8");
+  if (cd == (iconv_t)-1) {
+    return 10 + g_count;  // iconv_open failed
+  }
+
+  result = iconv(cd, &inptr, &inbytesleft, &outptr, &outbytesleft);
+  if (result == (size_t)-1) {
+    iconv_close(cd);
+    return 20 + g_count;  // iconv failed, return 20 + specific errno
+  }
+
+  if (inbytesleft != 0) {
+    iconv_close(cd);
+    return 40 + g_count;  // Not all input was converted
+  }
+
+  size_t output_len = OUTBUF_SIZE - outbytesleft;
+  if (output_len != expected_len) {
+    iconv_close(cd);
+    return 50 + g_count;  // Output length mismatch
+  }
+
+  if (memcmp(outbuf, expected_output, output_len) != 0) {
+    iconv_close(cd);
+    return 60 + g_count;  // Output content mismatch
+  }
+
+  if (iconv_close(cd) == -1)
+    return 70 + g_count;  // iconv_close failed
+
+  // Reverse direction check: UTF-32LE back to UTF-8
+  cd = iconv_open("UTF-8", "UTF-32LE");
+  if (cd == (iconv_t)-1) {
+    return 80 + g_count;  // iconv_open failed for reverse direction
+  }
+
+  char reverse_inbuf[OUTBUF_SIZE];
+  char reverse_outbuf[INBUF_SIZE];
+  char* reverse_inptr = reverse_inbuf;
+  char* reverse_outptr = reverse_outbuf;
+  size_t reverse_inbytesleft = output_len;
+  size_t reverse_outbytesleft = INBUF_SIZE;
+
+  memcpy(reverse_inbuf, outbuf, output_len);
+
+  result = iconv(cd, &reverse_inptr, &reverse_inbytesleft, &reverse_outptr,
+                 &reverse_outbytesleft);
+  if (result == (size_t)-1) {
+    iconv_close(cd);
+    return 90 + g_count;  // iconv failed for reverse direction
+  }
+
+  if (reverse_inbytesleft != 0) {
+    iconv_close(cd);
+    return 100 + g_count;  // Not all input was converted in reverse direction
+  }
+
+  size_t reverse_output_len = INBUF_SIZE - reverse_outbytesleft;
+  if (reverse_output_len != input_len) {
+    iconv_close(cd);
+    return 110 + g_count;  // Reverse output length mismatch
+  }
+
+  if (memcmp(reverse_outbuf, input, input_len) != 0) {
+    iconv_close(cd);
+    return 120 + g_count;  // Reverse output content mismatch
+  }
+
+  if (iconv_close(cd) == -1)
+    return 130 + g_count;  // iconv_close failed for reverse direction
+
+  return 0;  // Success
+}
+
+int main() {
+  // Test case 1: Basic ASCII
+  const char input1[] = "Hello, world!";
+  const wchar_t expected1[] = L"Hello, world!";
+  int result = check_conversion(input1, sizeof(input1) - 1, expected1,
+                                sizeof(expected1) - 4);
+  if (result != 0)
+    return result;
+
+  // Test case 2: Non-ASCII characters and newline
+  const char input2[] = "こんにちは\nWorld! ☺";
+  const wchar_t expected2[] = L"こんにちは\nWorld! ☺";
+  result = check_conversion(input2, sizeof(input2) - 1, expected2,
+                            sizeof(expected2) - 4);
+  if (result != 0)
+    return result;
+
+  // Test case 3: Empty string
+  const char input3[] = "";
+  const wchar_t expected3[] = L"";
+  result = check_conversion(input3, 0, expected3, 0);
+  if (result != 0)
+    return result;
+
+  // Test case 4: String with null characters
+  const char input4[] = "Hello\0World";
+  const wchar_t expected4[] = L"Hello\0World";
+  result = check_conversion(input4, sizeof(input4) - 1, expected4,
+                            sizeof(expected4) - 4);
+  if (result != 0)
+    return result;
+
+  // Test case 5: Long string to test buffer handling
+  char input5[INBUF_SIZE];
+  wchar_t expected5[INBUF_SIZE];
+  memset(input5, 'A', INBUF_SIZE - 1);
+  input5[INBUF_SIZE - 1] = '\0';
+  for (int i = 0; i < INBUF_SIZE - 1; i++) {
+    expected5[i] = u'A';
+  }
+  result =
+      check_conversion(input5, INBUF_SIZE - 1, expected5, (INBUF_SIZE - 1) * 4);
+  if (result != 0)
+    return result;
+
+  // Test case 6: Invalid UTF-8 sequence
+  const char input6[] = {0xC0, 0x80};
+  result = check_conversion(input6, sizeof(input6), NULL, 0);
+  if (result != 26) {
+    if (errno != EILSEQ)
+      return 201;
+    return 200;
+  }
+
+  // Test case 7: Mixing ASCII and non-ASCII
+  const char input7[] = "Hello, 世界!";
+  const wchar_t expected7[] = L"Hello, 世界!";
+  result = check_conversion(input7, sizeof(input7) - 1, expected7,
+                            sizeof(expected7) - 4);
+  if (result != 0)
+    return result;
+
+  // Test case 8: Surrogate pairs
+  const char input8[] = "𐐷";         // U+10437
+  const wchar_t expected8[] = L"𐐷";  // This will be encoded as a surrogate pair
+  result = check_conversion(input8, sizeof(input8) - 1, expected8,
+                            sizeof(expected8) - 4);
+  if (result != 0)
+    return result;
+
+  return 0;  // All tests passed
+}
diff --git a/test/posix/interprocess_signaling_test.c b/test/posix/interprocess_signaling_test.c
new file mode 100644
index 000000000..d6372492e
--- /dev/null
+++ b/test/posix/interprocess_signaling_test.c
@@ -0,0 +1,67 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <signal.h>
+#include <stdatomic.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+atomic_int *got;
+
+void onsig(int sig) {
+  *got = sig;
+}
+
+int main(int argc, char *argv[]) {
+
+  // create process shared memory
+  got = mmap(0, 4, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
+  if (got == MAP_FAILED)
+    return 5;
+
+  // listen for signal
+  if (signal(SIGUSR1, onsig))
+    return 6;
+
+  // block signals
+  sigset_t full;
+  if (sigfillset(&full))
+    return 7;
+  if (sigprocmask(SIG_BLOCK, &full, 0))
+    return 8;
+
+  // create child process
+  int pid;
+  if (!(pid = fork())) {
+    sigset_t empty;
+    sigemptyset(&empty);
+    sigsuspend(&empty);
+    *got |= 128;
+    _exit(0);
+  }
+
+  // send signal
+  if (kill(pid, SIGUSR1))
+    return 9;
+
+  // wait for child to die
+  int ws;
+  if (wait(&ws) != pid)
+    return 10;
+  if (ws)
+    return 11;
+  if (*got != (128 | SIGUSR1))
+    return 12;
+}
diff --git a/test/posix/listen_timeout_test.c b/test/posix/listen_timeout_test.c
new file mode 100644
index 000000000..952c8a83a
--- /dev/null
+++ b/test/posix/listen_timeout_test.c
@@ -0,0 +1,79 @@
+#include <arpa/inet.h>
+#include <cosmo.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+int main() {
+  int listenfd, connfd;
+  struct sockaddr_in serv_addr;
+  struct timeval timeout;
+  socklen_t len;
+  struct sockaddr_in cli_addr;
+
+  // only linux really does this
+  if (!IsLinux())
+    return 0;
+
+  // create listening socket
+  listenfd = socket(AF_INET, SOCK_STREAM, 0);
+  if (listenfd < 0) {
+    perror("socket");
+    exit(1);
+  }
+
+  // initialize server address
+  memset(&serv_addr, 0, sizeof(serv_addr));
+  serv_addr.sin_family = AF_INET;
+  serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  serv_addr.sin_port = htons(0);
+
+  // bind socket
+  if (bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
+    perror("bind");
+    close(listenfd);
+    exit(2);
+  }
+
+  // listen on the socket
+  if (listen(listenfd, 5) < 0) {
+    perror("listen");
+    close(listenfd);
+    exit(3);
+  }
+
+  // accept for 200ms
+  timeout.tv_sec = 0;
+  timeout.tv_usec = 200e3;
+  if (setsockopt(listenfd, SOL_SOCKET, SO_RCVTIMEO, &timeout,
+                 sizeof(timeout))) {
+    perror("setsockopt");
+    close(listenfd);
+    exit(4);
+  }
+
+  // Accept connection
+  len = sizeof(cli_addr);
+  connfd = accept(listenfd, (struct sockaddr *)&cli_addr, &len);
+  if (connfd < 0) {
+    if (errno == EAGAIN || errno == EWOULDBLOCK) {
+      /* printf("accept() timed out\n"); */
+    } else {
+      perror("accept");
+    }
+  } else {
+    printf("Connection accepted from client.\n");
+    // Close connected socket
+    close(connfd);
+  }
+
+  // Close listening socket
+  close(listenfd);
+}
diff --git a/test/posix/lowest_fd_test.c b/test/posix/lowest_fd_test.c
new file mode 100644
index 000000000..661212f83
--- /dev/null
+++ b/test/posix/lowest_fd_test.c
@@ -0,0 +1,45 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <fcntl.h>
+#include <unistd.h>
+
+int main(int argc, char *argv[]) {
+
+  // ensure most file descriptors are closed
+  for (int fildes = 3; fildes < 80; ++fildes)
+    close(fildes);
+
+  // create new file descriptor
+  if (open("/dev/urandom", O_RDONLY) != 3)
+    return 2;
+
+  // copy file descriptor to higher number
+  if (fcntl(3, F_DUPFD, 70) != 70)
+    return 3;
+
+  // new file descriptor should go for lowest number
+  int fd;
+  if ((fd = open("/dev/urandom", O_RDONLY)) != 4)
+    return 4;
+
+  // move file descriptor to higher number
+  if (close(3))
+    return 5;
+
+  // new file descriptor should go for lowest number
+  if (open("/dev/urandom", O_RDONLY) != 3)
+    return 6;
+}
diff --git a/test/posix/msg_nosignal_test.c b/test/posix/msg_nosignal_test.c
new file mode 100644
index 000000000..c164a4b9b
--- /dev/null
+++ b/test/posix/msg_nosignal_test.c
@@ -0,0 +1,196 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <arpa/inet.h>
+#include <cosmo.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+/**
+ * @fileoverview send(MSG_NOSIGNAL) test
+ *
+ * It's possible when writing to a socket for SIGPIPE to be raised. It
+ * can happen for a variety of reasons. The one reason that has broad
+ * consensus across OSes and is officially documented, is if shutdown()
+ * is used on the local end.
+ */
+
+struct sockaddr_in serv_addr;
+atomic_bool g_ready_for_conn;
+atomic_bool g_ready_for_data;
+atomic_bool g_ready_for_more;
+atomic_bool g_ready_for_exit;
+volatile sig_atomic_t g_got_signal;
+
+void onsig(int sig) {
+  g_got_signal = sig;
+}
+
+void *server_thread(void *arg) {
+  socklen_t len;
+  int server, client;
+  struct sockaddr_in cli_addr;
+
+  // create listening socket
+  server = socket(AF_INET, SOCK_STREAM, 0);
+  if (server == -1) {
+    perror("socket");
+    exit(10);
+  }
+
+  // initialize server address
+  memset(&serv_addr, 0, sizeof(serv_addr));
+  serv_addr.sin_family = AF_INET;
+  serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  serv_addr.sin_port = htons(0);
+
+  // bind socket
+  if (bind(server, (struct sockaddr *)&serv_addr, sizeof(serv_addr))) {
+    perror("bind");
+    exit(11);
+  }
+
+  // get assigned port
+  len = sizeof(serv_addr);
+  if (getsockname(server, (struct sockaddr *)&serv_addr, &len)) {
+    perror("getsockname");
+    exit(12);
+  }
+
+  // listen on the socket
+  if (listen(server, SOMAXCONN)) {
+    perror("listen");
+    exit(13);
+  }
+
+  // wake main thread
+  g_ready_for_conn = true;
+
+  // accept connection
+  len = sizeof(cli_addr);
+  client = accept(server, (struct sockaddr *)&cli_addr, &len);
+  if (client == -1) {
+    perror("accept");
+    exit(14);
+  }
+
+  // wake main thread
+  g_ready_for_data = true;
+
+  // wait for thread
+  for (;;)
+    if (g_ready_for_exit)
+      break;
+
+  // close sockets
+  if (close(client))
+    exit(29);
+  if (close(server))
+    exit(28);
+
+  return 0;
+}
+
+int main() {
+
+  // create server thread
+  pthread_t th;
+  if (pthread_create(&th, 0, server_thread, 0))
+    return 1;
+
+  // wait for thread
+  for (;;)
+    if (g_ready_for_conn)
+      break;
+
+  // create socket
+  int client = socket(AF_INET, SOCK_STREAM, 0);
+  if (client == -1) {
+    perror("socket");
+    return 2;
+  }
+
+  // connect to server
+  if (connect(client, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
+    perror("connect");
+    return 3;
+  }
+
+  // wait for thread
+  for (;;)
+    if (g_ready_for_data)
+      break;
+
+  // handle signals
+  struct sigaction sa;
+  sa.sa_flags = 0;
+  sa.sa_handler = onsig;
+  sigemptyset(&sa.sa_mask);
+  sigaction(SIGPIPE, &sa, 0);
+
+  // half close socket
+  if (shutdown(client, SHUT_WR))
+    return 15;
+
+  // send first transmission
+  int rc;
+  for (;;) {
+    rc = write(client, "x", 1);
+    if (rc == 1)
+      continue;
+    if (rc != -1)
+      return 4;
+    if (errno != EPIPE) {
+      perror("write");
+      return 5;
+    }
+    // NetBSD is oddly lazy about sending SIGPIPE
+    if (IsNetbsd())
+      for (;;)
+        if (g_got_signal)
+          break;
+    if (g_got_signal != SIGPIPE) {
+      fprintf(stderr, "expected SIGPIPE but got %s\n", strsignal(g_got_signal));
+      return 6;
+    }
+    g_got_signal = 0;
+    break;
+  }
+
+  // send first transmission
+  rc = send(client, "x", 1, MSG_NOSIGNAL);
+  if (rc != -1)
+    return 7;
+  if (errno != EPIPE)
+    return 8;
+  if (g_got_signal)
+    return 9;
+
+  g_ready_for_exit = true;
+
+  if (pthread_join(th, 0))
+    return 6;
+}
diff --git a/test/posix/msg_waitall_test.c b/test/posix/msg_waitall_test.c
new file mode 100644
index 000000000..99942383d
--- /dev/null
+++ b/test/posix/msg_waitall_test.c
@@ -0,0 +1,207 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <arpa/inet.h>
+#include <cosmo.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+/**
+ * @fileoverview recv(MSG_WAITALL) test
+ */
+
+struct sockaddr_in serv_addr;
+atomic_bool g_ready_for_conn;
+atomic_bool g_ready_for_data;
+atomic_bool g_ready_for_more;
+atomic_bool g_ready_for_exit;
+
+void *server_thread(void *arg) {
+  socklen_t len;
+  int server, client;
+  struct sockaddr_in cli_addr;
+
+  // create listening socket
+  server = socket(AF_INET, SOCK_STREAM, 0);
+  if (server == -1) {
+    perror("socket");
+    exit(10);
+  }
+
+  // initialize server address
+  memset(&serv_addr, 0, sizeof(serv_addr));
+  serv_addr.sin_family = AF_INET;
+  serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  serv_addr.sin_port = htons(0);
+
+  // bind socket
+  if (bind(server, (struct sockaddr *)&serv_addr, sizeof(serv_addr))) {
+    perror("bind");
+    exit(11);
+  }
+
+  // get assigned port
+  len = sizeof(serv_addr);
+  if (getsockname(server, (struct sockaddr *)&serv_addr, &len)) {
+    perror("getsockname");
+    exit(12);
+  }
+
+  // listen on the socket
+  if (listen(server, SOMAXCONN)) {
+    perror("listen");
+    exit(13);
+  }
+
+  // wake main thread
+  g_ready_for_conn = true;
+
+  // accept connection
+  len = sizeof(cli_addr);
+  client = accept(server, (struct sockaddr *)&cli_addr, &len);
+  if (client == -1) {
+    perror("accept");
+    exit(14);
+  }
+
+  // check waitall + dontwait
+  char buf[2];
+  int rc = recv(client, buf, 2, MSG_WAITALL | MSG_DONTWAIT);
+  if (rc != -1)
+    exit(15);
+  if (errno != EAGAIN)
+    exit(16);
+
+  // wake main thread
+  g_ready_for_data = true;
+
+  // check peek
+  rc = recv(client, buf, 2, MSG_PEEK);
+  if (rc == -1) {
+    perror("recv1");
+    exit(17);
+  }
+  if (rc != 1)
+    exit(18);
+  if (buf[0] != 'x')
+    exit(19);
+
+  // check read() has @restartable behavior
+  rc = recv(client, buf, 2, MSG_WAITALL);
+  if (rc == -1) {
+    perror("recv2");
+    exit(21);
+  }
+  if (rc != 2)
+    exit(22);
+  if (buf[0] != 'x')
+    exit(23);
+  if (buf[1] != 'y')
+    exit(24);
+
+  // wake main thread
+  g_ready_for_more = true;
+
+  // check normal recv won't wait
+  rc = read(client, buf, 2);
+  if (rc == -1) {
+    perror("recv3");
+    exit(25);
+  }
+  if (rc != 1)
+    exit(26);
+  if (buf[0] != 'x')
+    exit(27);
+
+  // wait for main thread
+  for (;;)
+    if (g_ready_for_exit)
+      break;
+
+  // close listening socket
+  if (close(server))
+    exit(28);
+  if (close(client))
+    exit(29);
+  return 0;
+}
+
+int main() {
+
+  // create server thread
+  pthread_t th;
+  if (pthread_create(&th, 0, server_thread, 0))
+    return 1;
+
+  // wait for thread
+  for (;;)
+    if (g_ready_for_conn)
+      break;
+
+  // create socket
+  int client = socket(AF_INET, SOCK_STREAM, 0);
+  if (client == -1) {
+    perror("socket");
+    return 2;
+  }
+
+  // connect to server
+  if (connect(client, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
+    perror("connect");
+    return 3;
+  }
+
+  // wait for thread
+  for (;;)
+    if (g_ready_for_data)
+      break;
+
+  // send first transmission
+  usleep(100e3);
+  if (write(client, "x", 1) != 1)
+    return 4;
+  usleep(100e3);
+  if (write(client, "y", 1) != 1)
+    return 5;
+
+  // wait for thread
+  for (;;)
+    if (g_ready_for_more)
+      break;
+
+  // send second transmission
+  usleep(100e3);
+  if (write(client, "x", 1) != 1)
+    return 4;
+  usleep(100e3);
+  if (write(client, "y", 1) != 1)
+    return 5;
+
+  g_ready_for_exit = true;
+
+  if (pthread_join(th, 0))
+    return 6;
+}
diff --git a/test/posix/nonblock_pipe2_test.c b/test/posix/nonblock_pipe2_test.c
new file mode 100644
index 000000000..3049cb804
--- /dev/null
+++ b/test/posix/nonblock_pipe2_test.c
@@ -0,0 +1,75 @@
+#include <cosmo.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+int main() {
+  int pipefd[2];
+  char buf[PIPE_BUF];
+  char buf2[PIPE_BUF];
+  ssize_t bytes_read;
+  ssize_t bytes_written;
+
+  // Create a pipe
+  if (pipe2(pipefd, O_NONBLOCK) == -1)
+    exit(1);
+
+  // Test 1: Reading from an empty pipe should fail with EAGAIN
+  bytes_read = read(pipefd[0], buf, PIPE_BUF);
+  if (bytes_read != -1 || errno != EAGAIN)
+    exit(4);
+
+  // Test 2: Writing to the pipe
+  bytes_written = write(pipefd[1], buf, PIPE_BUF);
+  if (bytes_written != PIPE_BUF)
+    exit(5);
+
+  // Test 3: Reading from the pipe after writing
+  bytes_read = read(pipefd[0], buf2, PIPE_BUF);
+  if (bytes_read != PIPE_BUF || memcmp(buf, buf2, PIPE_BUF))
+    exit(6);
+
+  // Test 4: Fill the pipe buffer
+  int ch = 10;
+  size_t total_written = 0;
+  for (;;) {
+    memset(buf, ch, PIPE_BUF);
+    bytes_written = write(pipefd[1], buf, PIPE_BUF);
+    if (bytes_written == -1) {
+      if (errno == EAGAIN || errno == EWOULDBLOCK) {
+        break;  // Pipe is full
+      } else {
+        exit(7);  // Unexpected error
+      }
+    }
+    total_written += bytes_written;
+  }
+
+  // Test 5: Verify that we can read all the data we wrote
+  ch = 10;
+  size_t total_read = 0;
+  while (total_read < total_written) {
+    bytes_read = read(pipefd[0], buf2, PIPE_BUF);
+    if (bytes_read == -1)
+      exit(8);
+    memset(buf, ch, PIPE_BUF);
+    if (memcmp(buf, buf2, PIPE_BUF))
+      exit(9);
+    total_read += bytes_read;
+  }
+  if (total_read != total_written)
+    exit(10);
+
+  // Clean up
+  if (close(pipefd[0]))
+    exit(11);
+  if (close(pipefd[1]))
+    exit(12);
+
+  CheckForMemoryLeaks();
+}
diff --git a/test/posix/nonblock_pipe_test.c b/test/posix/nonblock_pipe_test.c
new file mode 100644
index 000000000..c9d21e5f8
--- /dev/null
+++ b/test/posix/nonblock_pipe_test.c
@@ -0,0 +1,84 @@
+#include <cosmo.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+int main() {
+  int pipefd[2];
+  char buf[PIPE_BUF];
+  char buf2[PIPE_BUF];
+  ssize_t bytes_read;
+  ssize_t bytes_written;
+
+  // Create a pipe
+  if (pipe(pipefd) == -1)
+    exit(1);
+
+  // Set O_NONBLOCK flag on the pipe
+  for (int i = 0; i < 2; ++i) {
+    int flags;
+    if ((flags = fcntl(pipefd[i], F_GETFL, 0)) == -1)
+      exit(2);
+    if (fcntl(pipefd[i], F_SETFL, flags | O_NONBLOCK) == -1)
+      exit(3);
+  }
+
+  // Test 1: Reading from an empty pipe should fail with EAGAIN
+  bytes_read = read(pipefd[0], buf, PIPE_BUF);
+  if (bytes_read != -1 || errno != EAGAIN)
+    exit(4);
+
+  // Test 2: Writing to the pipe
+  bytes_written = write(pipefd[1], buf, PIPE_BUF);
+  if (bytes_written != PIPE_BUF)
+    exit(5);
+
+  // Test 3: Reading from the pipe after writing
+  bytes_read = read(pipefd[0], buf2, PIPE_BUF);
+  if (bytes_read != PIPE_BUF || memcmp(buf, buf2, PIPE_BUF))
+    exit(6);
+
+  // Test 4: Fill the pipe buffer
+  int ch = 10;
+  size_t total_written = 0;
+  for (;;) {
+    memset(buf, ch, PIPE_BUF);
+    bytes_written = write(pipefd[1], buf, PIPE_BUF);
+    if (bytes_written == -1) {
+      if (errno == EAGAIN || errno == EWOULDBLOCK) {
+        break;  // Pipe is full
+      } else {
+        exit(7);  // Unexpected error
+      }
+    }
+    total_written += bytes_written;
+  }
+
+  // Test 5: Verify that we can read all the data we wrote
+  ch = 10;
+  size_t total_read = 0;
+  while (total_read < total_written) {
+    bytes_read = read(pipefd[0], buf2, PIPE_BUF);
+    if (bytes_read == -1)
+      exit(8);
+    memset(buf, ch, PIPE_BUF);
+    if (memcmp(buf, buf2, PIPE_BUF))
+      exit(9);
+    total_read += bytes_read;
+  }
+  if (total_read != total_written)
+    exit(10);
+
+  // Clean up
+  if (close(pipefd[0]))
+    exit(11);
+  if (close(pipefd[1]))
+    exit(12);
+
+  CheckForMemoryLeaks();
+}
diff --git a/test/posix/pending_signal_execve_test.c b/test/posix/pending_signal_execve_test.c
new file mode 100644
index 000000000..0b97b794b
--- /dev/null
+++ b/test/posix/pending_signal_execve_test.c
@@ -0,0 +1,59 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <cosmo.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+sig_atomic_t gotsig;
+
+void onsig(int sig) {
+  gotsig = sig;
+}
+
+int main(int argc, char* argv[]) {
+  sigset_t ss;
+  sigfillset(&ss);
+  sigprocmask(SIG_BLOCK, &ss, 0);
+  if (argc >= 2 && !strcmp(argv[1], "childe")) {
+    signal(SIGUSR1, onsig);
+    sigemptyset(&ss);
+    sigsuspend(&ss);
+    if (gotsig != SIGUSR1)
+      return 2;
+  } else {
+    int child;
+    if ((child = fork()) == -1)
+      return 2;
+    if (!child) {
+      execlp(argv[0], argv[0], "childe", NULL);
+      _Exit(127);
+    }
+    if (IsNetbsd() || IsOpenbsd()) {
+      // NetBSD has a bug where pending signals don't inherit across
+      // execve, even though POSIX.1 literally says you must do this
+      sleep(1);
+    }
+    if (kill(child, SIGUSR1))
+      return 3;
+    int ws;
+    if (wait(&ws) != child)
+      return 4;
+    if (ws)
+      return 5;
+  }
+}
diff --git a/test/posix/pipe_write_eagain_test.c b/test/posix/pipe_write_eagain_test.c
new file mode 100644
index 000000000..66a1c42ea
--- /dev/null
+++ b/test/posix/pipe_write_eagain_test.c
@@ -0,0 +1,107 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <errno.h>
+#include <poll.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+/**
+ * @fileoverview Tests that EAGAIN won't corrupt pipe.
+ *
+ * This is a real bug when using CancelIoEx() on winsock writes, so we
+ * need to make sure it doesn't happen on pipes too.
+ */
+
+#define ITERATIONS 100000
+#define ASYMMETRY  3
+
+int fds[2];
+int got_read_eagains;
+int got_write_eagains;
+
+void *worker(void *arg) {
+  for (int expect = 0; expect < ITERATIONS;) {
+    int number;
+    ssize_t rc = read(fds[0], &number, sizeof(number));
+    if (rc == -1) {
+      if (errno == EAGAIN) {
+        ++got_read_eagains;
+        if (poll(&(struct pollfd){fds[0], POLLIN}, 1, -1) == -1)
+          exit(11);
+        continue;
+      }
+      perror("read");
+      exit(8);
+    }
+    size_t got = rc;
+    if (got != sizeof(int))
+      exit(9);
+    if (expect != number)
+      exit(10);
+    ++expect;
+  }
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+
+  if (pipe2(fds, O_NONBLOCK))
+    return 1;
+
+  pthread_t th;
+  if (pthread_create(&th, 0, worker, 0))
+    return 2;
+
+  int number = 0;
+  for (;;) {
+    int chunk = 0;
+    int numbers[ASYMMETRY];
+    for (;;) {
+      numbers[chunk] = number + chunk;
+      if (++chunk == ASYMMETRY)
+        break;
+      if (number + chunk == ITERATIONS)
+        break;
+    }
+    for (;;) {
+      ssize_t rc = write(fds[1], numbers, chunk * sizeof(int));
+      if (rc == -1) {
+        if (errno == EAGAIN) {
+          ++got_write_eagains;
+          if (poll(&(struct pollfd){fds[1], POLLOUT}, 1, -1) == -1)
+            return 10;
+          continue;
+        }
+        return 3;
+      }
+      if (rc % sizeof(int))
+        return 4;
+      chunk = rc / sizeof(int);
+      number += chunk;
+      break;
+    }
+    if (number == ITERATIONS)
+      break;
+  }
+
+  if (pthread_join(th, 0))
+    return 5;
+
+  if (!got_read_eagains && !got_write_eagains)
+    return 7;
+}
diff --git a/test/posix/printf_return_test.c b/test/posix/printf_return_test.c
new file mode 100644
index 000000000..377bb9c7f
--- /dev/null
+++ b/test/posix/printf_return_test.c
@@ -0,0 +1,43 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <unistd.h>
+
+int main() {
+
+  if (close(1))
+    return 1;
+  if (open("/dev/null", O_WRONLY) != 1)
+    return 2;
+
+  if (printf("a") != 1)
+    return 4;
+  if (printf("%s", "") != 0)
+    return 5;
+  if (printf("%s", "a") != 1)
+    return 6;
+  if (printf("%10s", "a") != 10)
+    return 6;
+  if (printf("%-10s", "a") != 10)
+    return 6;
+  if (printf("%-10s%-40s %9s %8s  %8s %8s\n", "Benchmark", "prog", "ops",
+             "time", "ops/sec", "time/op") != 89)
+    return 7;
+  if (fprintf(stdout, "%-10s%-40s %9s %8s  %8s %8s\n", "Benchmark", "prog",
+              "ops", "time", "ops/sec", "time/op") != 89)
+    return 8;
+}
diff --git a/test/posix/pthread_process_shared_test.c b/test/posix/pthread_process_shared_test.c
new file mode 100644
index 000000000..449f54198
--- /dev/null
+++ b/test/posix/pthread_process_shared_test.c
@@ -0,0 +1,93 @@
+#include <pthread.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main() {
+  int ws;
+  FILE *f;
+  pid_t pid;
+  pthread_condattr_t ca;
+  pthread_mutexattr_t ma;
+  struct Shared {
+    atomic_int state;
+    pthread_cond_t cond;
+    pthread_mutex_t lock;
+  } *s;
+  if (!(f = tmpfile()))
+    return 0;
+  if (ftruncate(fileno(f), 512))
+    return 1;
+  if ((s = (struct Shared *)mmap(0, 512, PROT_READ | PROT_WRITE,
+                                 MAP_SHARED | MAP_ANONYMOUS, -1, 0)) ==
+      MAP_FAILED)
+    return 2;
+  if (pthread_condattr_init(&ca))
+    return 3;
+  if (pthread_mutexattr_init(&ma))
+    return 4;
+  if (pthread_condattr_setpshared(&ca, PTHREAD_PROCESS_SHARED))
+    return 5;
+  if (pthread_mutexattr_setpshared(&ma, PTHREAD_PROCESS_SHARED))
+    return 6;
+  if (pthread_cond_init(&s->cond, &ca))
+    return 7;
+  if (pthread_mutex_init(&s->lock, &ma))
+    return 8;
+  if (pthread_mutexattr_destroy(&ma))
+    return 9;
+  if (pthread_condattr_destroy(&ca))
+    return 10;
+  if ((pid = fork()) == -1)
+    return 11;
+  if (!pid) {
+    alarm(2);
+    if (pthread_mutex_lock(&s->lock))
+      return 12;
+    s->state = 1;
+    if (pthread_cond_wait(&s->cond, &s->lock))
+      return 13;
+    if (pthread_mutex_unlock(&s->lock))
+      return 14;
+    for (;;)
+      if (s->state == 2)
+        break;
+    if (pthread_mutex_lock(&s->lock))
+      return 15;
+    if (pthread_cond_signal(&s->cond))
+      return 16;
+    if (pthread_mutex_unlock(&s->lock))
+      return 17;
+    _exit(0);
+  }
+  alarm(2);
+  for (;;)
+    if (s->state == 1)
+      break;
+  if (pthread_mutex_lock(&s->lock))
+    return 18;
+  if (pthread_cond_signal(&s->cond))
+    return 19;
+  if (pthread_mutex_unlock(&s->lock))
+    return 20;
+  if (pthread_mutex_lock(&s->lock))
+    return 21;
+  s->state = 2;
+  if (pthread_cond_wait(&s->cond, &s->lock))
+    return 22;
+  if (pthread_mutex_unlock(&s->lock))
+    return 23;
+  if (wait(&ws) != pid)
+    return 24;
+  if (!WIFEXITED(ws))
+    return 25;
+  if (WEXITSTATUS(ws))
+    return 26;
+  if (pthread_mutex_destroy(&s->lock))
+    return 27;
+  if (pthread_cond_destroy(&s->cond))
+    return 28;
+  return 0;
+}
diff --git a/test/posix/sa_resethand2_test.c b/test/posix/sa_resethand2_test.c
index c66f8cb8d..3a6dc34da 100644
--- a/test/posix/sa_resethand2_test.c
+++ b/test/posix/sa_resethand2_test.c
@@ -1,27 +1,20 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/sigaction.h"
-#include "libc/calls/struct/sigset.h"
-#include "libc/dce.h"
-#include "libc/sysv/consts/sa.h"
-#include "libc/sysv/consts/sig.h"
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <signal.h>
+#include <unistd.h>
 
 volatile int handler_invoked;
 
@@ -33,24 +26,17 @@ int main() {
   sigset_t mask, oldmask;
   struct sigaction sa, current_sa;
 
-  if (IsWindows()) {
-    // TODO(jart): support non-fatal signals between processes
-    return 0;
-  }
-
   sa.sa_handler = signal_handler;
   sa.sa_flags = SA_RESETHAND;
   sigemptyset(&sa.sa_mask);
 
-  if (sigaction(SIGINT, &sa, 0) == -1) {
+  if (sigaction(SIGINT, &sa, 0) == -1)
     return 1;
-  }
 
   sigemptyset(&mask);
   sigaddset(&mask, SIGINT);
-  if (sigprocmask(SIG_BLOCK, &mask, &oldmask) == -1) {
+  if (sigprocmask(SIG_BLOCK, &mask, &oldmask) == -1)
     return 2;
-  }
 
   int pid = fork();
   if (pid == -1) {
@@ -60,15 +46,12 @@ int main() {
     return 0;
   } else {
     sigsuspend(&oldmask);
-    if (!handler_invoked) {
+    if (!handler_invoked)
       return 4;
-    }
-    if (sigaction(SIGINT, 0, &current_sa) == -1) {
+    if (sigaction(SIGINT, 0, &current_sa) == -1)
       return 5;
-    }
-    if (current_sa.sa_handler != SIG_DFL) {
+    if (current_sa.sa_handler != SIG_DFL)
       return 6;
-    }
     return 0;
   }
 }
diff --git a/test/posix/sa_resethand_test.c b/test/posix/sa_resethand_test.c
index c582d90fe..eed501bf6 100644
--- a/test/posix/sa_resethand_test.c
+++ b/test/posix/sa_resethand_test.c
@@ -1,22 +1,21 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2023 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <errno.h>
 #include <signal.h>
+#include <stdlib.h>
 
 volatile int gotsig;
 
@@ -24,23 +23,68 @@ void OnSig(int sig) {
   gotsig = sig;
 }
 
-int main() {
+void test_sa_resethand_raise(void) {
   struct sigaction sa;
   sa.sa_handler = OnSig;
   sa.sa_flags = SA_RESETHAND;
   sigemptyset(&sa.sa_mask);
   if (sigaction(SIGUSR1, &sa, 0))
-    return 1;
+    exit(1);
   if (sigaction(SIGUSR1, 0, &sa))
-    return 2;
+    exit(2);
   if (sa.sa_handler != OnSig)
-    return 3;
+    exit(3);
   if (raise(SIGUSR1))
-    return 4;
+    exit(4);
   if (gotsig != SIGUSR1)
-    return 5;
+    exit(5);
   if (sigaction(SIGUSR1, 0, &sa))
-    return 6;
+    exit(6);
   if (sa.sa_handler != SIG_DFL)
-    return 7;
+    exit(7);
+}
+
+void test_sa_resethand_pause(void) {
+  struct sigaction sa;
+  sa.sa_handler = OnSig;
+  sa.sa_flags = SA_RESETHAND;
+  sigemptyset(&sa.sa_mask);
+  if (sigaction(SIGALRM, &sa, 0))
+    exit(10);
+  ualarm(10000, 0);
+  if (pause() != -1 || errno != EINTR)
+    exit(11);
+  if (gotsig != SIGALRM)
+    exit(12);
+  if (sigaction(SIGALRM, 0, &sa))
+    exit(13);
+  if (sa.sa_handler != SIG_DFL)
+    exit(14);
+}
+
+void test_sa_resethand_read(void) {
+  struct sigaction sa;
+  sa.sa_handler = OnSig;
+  sa.sa_flags = SA_RESETHAND;
+  sigemptyset(&sa.sa_mask);
+  if (sigaction(SIGALRM, &sa, 0))
+    exit(20);
+  int fds[2];
+  if (pipe(fds))
+    exit(21);
+  ualarm(10000, 0);
+  if (read(fds[0], (char[]){0}, 1) != -1 || errno != EINTR)
+    exit(22);
+  if (gotsig != SIGALRM)
+    exit(23);
+  if (sigaction(SIGALRM, 0, &sa))
+    exit(24);
+  if (sa.sa_handler != SIG_DFL)
+    exit(25);
+}
+
+int main() {
+  test_sa_resethand_raise();
+  test_sa_resethand_pause();
+  test_sa_resethand_read();
 }
diff --git a/test/posix/sigchld_test.c b/test/posix/sigchld_test.c
index 36cf1f032..6915f7cf2 100644
--- a/test/posix/sigchld_test.c
+++ b/test/posix/sigchld_test.c
@@ -32,7 +32,7 @@
 #include <unistd.h>
 
 // clang-format off
-// sh -c 'build/bootstrap/make -j8 V=1 o//test/posix/sigchld_test.runs'
+// sh -c '.cosmocc/current/bin/make -j8 V=1 o//test/posix/sigchld_test.runs'
 // clang-format on
 
 void Assert(const char *file, int line, bool ok) {
diff --git a/test/posix/signal_fight_test.c b/test/posix/signal_fight_test.c
new file mode 100644
index 000000000..910a7e04a
--- /dev/null
+++ b/test/posix/signal_fight_test.c
@@ -0,0 +1,105 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <pthread.h>
+#include <signal.h>
+#include <stdlib.h>
+
+/**
+ * @fileoverview Tests two threads killing each other won't deadlock.
+ *
+ * Our Windows implementation of signals has surprisingly high
+ * throughput on this test. About 10x more signals get delivered than
+ * any other OS and in the same amount of time. The only exception was
+ * OpenBSD, which delivered a similar number of signals, but it took 10x
+ * longer for the process to execute.
+ */
+
+#define ITERATIONS 10000
+
+int gotsigs[2];
+pthread_t threads[2];
+pthread_t thread_ids[2];
+pthread_barrier_t barrier;
+pthread_barrier_t barrier2;
+
+void sig_handler(int signo) {
+  if (pthread_equal(pthread_self(), threads[0]))
+    ++gotsigs[0];
+  if (pthread_equal(pthread_self(), threads[1]))
+    ++gotsigs[1];
+}
+
+void *thread_func(void *arg) {
+  int idx = *(int *)arg;
+  int other_idx = 1 - idx;
+
+  thread_ids[idx] = pthread_self();
+
+  int s = pthread_barrier_wait(&barrier);
+  if (s != 0 && s != PTHREAD_BARRIER_SERIAL_THREAD)
+    exit(1);
+
+  pthread_t other_thread = thread_ids[other_idx];
+
+  for (int i = 0; i < ITERATIONS; ++i)
+    if (pthread_kill(other_thread, SIGUSR1))
+      exit(2);
+
+  s = pthread_barrier_wait(&barrier2);
+  if (s != 0 && s != PTHREAD_BARRIER_SERIAL_THREAD)
+    exit(1);
+
+  return 0;
+}
+
+int main() {
+  struct sigaction sa;
+  sa.sa_handler = sig_handler;
+  sa.sa_flags = 0;
+  sigemptyset(&sa.sa_mask);
+
+  if (sigaction(SIGUSR1, &sa, 0) == -1)
+    exit(3);
+
+  if (pthread_barrier_init(&barrier, 0, 2))
+    exit(4);
+  if (pthread_barrier_init(&barrier2, 0, 2))
+    exit(4);
+
+  int idx0 = 0, idx1 = 1;
+
+  if (pthread_create(&threads[0], 0, thread_func, &idx0))
+    exit(5);
+  if (pthread_create(&threads[1], 0, thread_func, &idx1))
+    exit(6);
+
+  if (pthread_join(threads[0], 0))
+    exit(7);
+  if (pthread_join(threads[1], 0))
+    exit(8);
+
+  if (pthread_barrier_destroy(&barrier2))
+    exit(9);
+  if (pthread_barrier_destroy(&barrier))
+    exit(9);
+
+  if (!gotsigs[0])
+    exit(10);
+  if (!gotsigs[1])
+    exit(11);
+
+  return 0;
+}
diff --git a/test/posix/signal_latency_async_test.c b/test/posix/signal_latency_async_test.c
new file mode 100644
index 000000000..d507d8b1a
--- /dev/null
+++ b/test/posix/signal_latency_async_test.c
@@ -0,0 +1,145 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <cosmo.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+
+#define ITERATIONS 10000
+
+pthread_t sender_thread;
+pthread_t receiver_thread;
+struct timespec send_time;
+atomic_int sender_got_signal;
+atomic_int receiver_got_signal;
+double latencies[ITERATIONS];
+
+void sender_signal_handler(int signo) {
+  sender_got_signal = 1;
+}
+
+void receiver_signal_handler(int signo) {
+  receiver_got_signal = 1;
+}
+
+void *sender_func(void *arg) {
+  for (int i = 0; i < ITERATIONS; i++) {
+
+    // Wait a bit sometimes
+    if (rand() % 2) {
+      volatile unsigned v = 0;
+      for (;;)
+        if (++v == 4000)
+          break;
+    }
+
+    // Ping receiver
+    clock_gettime(CLOCK_MONOTONIC, &send_time);
+    if (pthread_kill(receiver_thread, SIGUSR1))
+      exit(6);
+
+    // Wait for pong
+    for (;;)
+      if (atomic_load_explicit(&sender_got_signal, memory_order_relaxed))
+        break;
+    sender_got_signal = 0;
+  }
+
+  return 0;
+}
+
+void *receiver_func(void *arg) {
+  static int iteration = 0;
+  do {
+    // wait for signal handler to be called
+    if (atomic_exchange_explicit(&receiver_got_signal, 0,
+                                 memory_order_acq_rel)) {
+
+      // record received time
+      struct timespec receive_time;
+      clock_gettime(CLOCK_MONOTONIC, &receive_time);
+      long sec_diff = receive_time.tv_sec - send_time.tv_sec;
+      long nsec_diff = receive_time.tv_nsec - send_time.tv_nsec;
+      double latency_ns = sec_diff * 1e9 + nsec_diff;
+      latencies[iteration++] = latency_ns;
+
+      // pong sender
+      if (pthread_kill(sender_thread, SIGUSR2))
+        exit(2);
+    }
+  } while (iteration < ITERATIONS);
+  return 0;
+}
+
+int compare(const void *a, const void *b) {
+  const double *x = a, *y = b;
+  if (*x < *y)
+    return -1;
+  else if (*x > *y)
+    return 1;
+  else
+    return 0;
+}
+
+int main() {
+
+  // install handlers
+  struct sigaction sa;
+  sa.sa_handler = receiver_signal_handler;
+  sa.sa_flags = 0;
+  sigemptyset(&sa.sa_mask);
+  sigaction(SIGUSR1, &sa, 0);
+  sa.sa_handler = sender_signal_handler;
+  sigaction(SIGUSR2, &sa, 0);
+
+  // create receiver thread first
+  if (pthread_create(&receiver_thread, 0, receiver_func, 0))
+    exit(11);
+
+  // create sender thread
+  if (pthread_create(&sender_thread, 0, sender_func, 0))
+    exit(12);
+
+  // wait for threads to finish
+  if (pthread_join(sender_thread, 0))
+    exit(13);
+  if (pthread_join(receiver_thread, 0))
+    exit(14);
+
+  // compute mean latency
+  double total_latency = 0;
+  for (int i = 0; i < ITERATIONS; i++)
+    total_latency += latencies[i];
+  double mean_latency = total_latency / ITERATIONS;
+
+  // sort latencies to compute percentiles
+  qsort(latencies, ITERATIONS, sizeof(double), compare);
+
+  double p50 = latencies[(int)(0.50 * ITERATIONS)];
+  double p90 = latencies[(int)(0.90 * ITERATIONS)];
+  double p95 = latencies[(int)(0.95 * ITERATIONS)];
+  double p99 = latencies[(int)(0.99 * ITERATIONS)];
+
+  printf("Mean latency: %.2f ns\n", mean_latency);
+  printf("50th percentile latency: %.2f ns\n", p50);
+  printf("90th percentile latency: %.2f ns\n", p90);
+  printf("95th percentile latency: %.2f ns\n", p95);
+  printf("99th percentile latency: %.2f ns\n", p99);
+}
diff --git a/test/posix/signal_latency_test.c b/test/posix/signal_latency_test.c
new file mode 100644
index 000000000..aa73cb771
--- /dev/null
+++ b/test/posix/signal_latency_test.c
@@ -0,0 +1,177 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <assert.h>
+#include <cosmo.h>
+#include <errno.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <unistd.h>
+
+#define ITERATIONS 10000
+
+atomic_bool got_sigusr2;
+pthread_t sender_thread;
+pthread_t receiver_thread;
+struct timespec send_time;
+double latencies[ITERATIONS];
+
+void sender_signal_handler(int signo) {
+  got_sigusr2 = true;
+}
+
+void receiver_signal_handler(int signo) {
+  struct timespec receive_time;
+  if (clock_gettime(CLOCK_MONOTONIC, &receive_time) == -1)
+    exit(1);
+
+  long sec_diff = receive_time.tv_sec - send_time.tv_sec;
+  long nsec_diff = receive_time.tv_nsec - send_time.tv_nsec;
+  double latency_ns = sec_diff * 1e9 + nsec_diff;
+
+  static int iteration = 0;
+  if (iteration < ITERATIONS)
+    latencies[iteration++] = latency_ns;
+
+  // Send SIGUSR2 back to sender_thread
+  if (pthread_kill(sender_thread, SIGUSR2))
+    exit(2);
+
+  // Exit if we're done.
+  if (iteration >= ITERATIONS)
+    pthread_exit(0);
+}
+
+void *sender_func(void *arg) {
+  // Block SIGUSR2
+  sigset_t block_set;
+  sigemptyset(&block_set);
+  sigaddset(&block_set, SIGUSR2);
+  if (pthread_sigmask(SIG_BLOCK, &block_set, 0))
+    exit(3);
+
+  // Install signal handler for SIGUSR2
+  struct sigaction sa;
+  sa.sa_handler = sender_signal_handler;
+  sa.sa_flags = 0;
+  sigemptyset(&sa.sa_mask);
+  if (sigaction(SIGUSR2, &sa, 0))
+    exit(4);
+
+  for (int i = 0; i < ITERATIONS; i++) {
+    if (clock_gettime(CLOCK_MONOTONIC, &send_time))
+      exit(5);
+
+    // Send SIGUSR1 to receiver_thread
+    got_sigusr2 = false;
+    if (pthread_kill(receiver_thread, SIGUSR1))
+      exit(6);
+
+    // Unblock SIGUSR2 and wait for it
+    sigset_t wait_set;
+    sigemptyset(&wait_set);
+    while (!got_sigusr2)
+      if (sigsuspend(&wait_set) && errno != EINTR)
+        exit(7);
+  }
+
+  return 0;
+}
+
+void *receiver_func(void *arg) {
+  // Install signal handler for SIGUSR1
+  struct sigaction sa;
+  sa.sa_handler = receiver_signal_handler;
+  sa.sa_flags = 0;
+  sigemptyset(&sa.sa_mask);
+  if (sigaction(SIGUSR1, &sa, 0))
+    exit(8);
+
+  // Block all signals except SIGUSR1
+  sigset_t block_set;
+  sigfillset(&block_set);
+  sigdelset(&block_set, SIGUSR1);
+  if (pthread_sigmask(SIG_SETMASK, &block_set, 0))
+    exit(9);
+
+  // Wait indefinitely for signals
+  while (1)
+    pause();
+
+  return 0;
+}
+
+int compare(const void *a, const void *b) {
+  const double *x = a, *y = b;
+  if (*x < *y)
+    return -1;
+  else if (*x > *y)
+    return 1;
+  else
+    return 0;
+}
+
+int main() {
+
+  // this test probably exposes a bug in openbsd
+  if (IsOpenbsd())
+    return 0;
+
+  // Block SIGUSR1 and SIGUSR2 in main thread
+  sigset_t block_set;
+  sigemptyset(&block_set);
+  sigaddset(&block_set, SIGUSR1);
+  sigaddset(&block_set, SIGUSR2);
+  if (pthread_sigmask(SIG_BLOCK, &block_set, 0))
+    exit(10);
+
+  // Create receiver thread first
+  if (pthread_create(&receiver_thread, 0, receiver_func, 0))
+    exit(11);
+
+  // Create sender thread
+  if (pthread_create(&sender_thread, 0, sender_func, 0))
+    exit(12);
+
+  // Wait for threads to finish
+  if (pthread_join(sender_thread, 0))
+    exit(13);
+  if (pthread_join(receiver_thread, 0))
+    exit(14);
+
+  // Compute mean latency
+  double total_latency = 0;
+  for (int i = 0; i < ITERATIONS; i++)
+    total_latency += latencies[i];
+  double mean_latency = total_latency / ITERATIONS;
+
+  // Sort latencies to compute percentiles
+  qsort(latencies, ITERATIONS, sizeof(double), compare);
+
+  double p50 = latencies[(int)(0.50 * ITERATIONS)];
+  double p90 = latencies[(int)(0.90 * ITERATIONS)];
+  double p95 = latencies[(int)(0.95 * ITERATIONS)];
+  double p99 = latencies[(int)(0.99 * ITERATIONS)];
+
+  printf("Mean latency: %.2f ns\n", mean_latency);
+  printf("50th percentile latency: %.2f ns\n", p50);
+  printf("90th percentile latency: %.2f ns\n", p90);
+  printf("95th percentile latency: %.2f ns\n", p95);
+  printf("99th percentile latency: %.2f ns\n", p99);
+}
diff --git a/test/posix/signal_torture_read_test.c b/test/posix/signal_torture_read_test.c
new file mode 100644
index 000000000..51af76521
--- /dev/null
+++ b/test/posix/signal_torture_read_test.c
@@ -0,0 +1,209 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <cosmo.h>
+#include <errno.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/**
+ * @fileoverview i/o signal handling torture test
+ *
+ * This test tries to trigger race conditions in the kernel's read()
+ * implementation, by sending a massive amount of SA_RESTART signals
+ * which cause churn in its internal code, and finally an interrupt.
+ * This should reveal if the kernel code that checks for any pending
+ * signals before blocking on i/o happens non-atomically. Expect the
+ * test to hang indefinitely in such cases.
+ *
+ * "This flag affects the behavior of interruptible functions; that is,
+ *  those specified to fail with errno set to EINTR. If set, and a
+ *  function specified as interruptible is interrupted by this signal,
+ *  the function shall restart and shall not fail with EINTR unless
+ *  otherwise specified. If an interruptible function which uses a
+ *  timeout is restarted, the duration of the timeout following the
+ *  restart is set to an unspecified value that does not exceed the
+ *  original timeout value. If the flag is not set, interruptible
+ *  functions interrupted by this signal shall fail with errno set to
+ *  EINTR." —Quoth IEEE Std 1003.1-2017 (POSIX.1) on SA_RESTART
+ *
+ * Every OS except Windows fails this test.
+ *
+ * @see sys_readwrite_nt()
+ */
+
+#define COUNT 1000
+
+volatile sig_atomic_t got_sigusr1;
+volatile sig_atomic_t got_sigusr2;
+volatile sig_atomic_t thread_ready;
+volatile sig_atomic_t read_interrupted;
+
+void sigusr1_handler(int signo) {
+  ++got_sigusr1;
+  // printf("got %d sigusr1\n", got_sigusr1);
+}
+
+void sigusr2_handler(int signo) {
+  ++got_sigusr2;
+  // printf("got %d sigusr2\n", got_sigusr2);
+}
+
+void setup_signal_handlers() {
+  struct sigaction sa;
+
+  // Set up SIGUSR1 handler with SA_RESTART
+  sa.sa_handler = sigusr1_handler;
+  sa.sa_flags = SA_RESTART;  // Signal handler with SA_RESTART
+  sigemptyset(&sa.sa_mask);
+  if (sigaction(SIGUSR1, &sa, NULL) == -1)
+    exit(97);
+
+  // Set up SIGUSR2 handler without SA_RESTART
+  sa.sa_handler = sigusr2_handler;
+  sa.sa_flags = 0;  // Signal handler without SA_RESTART
+  sigemptyset(&sa.sa_mask);
+  if (sigaction(SIGUSR2, &sa, NULL) == -1)
+    exit(98);
+}
+
+void block_signals() {
+  sigset_t set;
+  sigemptyset(&set);
+  sigaddset(&set, SIGUSR1);
+  sigaddset(&set, SIGUSR2);
+  if (pthread_sigmask(SIG_BLOCK, &set, 0))
+    exit(99);
+}
+
+void *thread_func(void *arg) {
+  int *pipefd = (int *)arg;
+  char buf[1];
+  ssize_t ret;
+
+  // Unblock SIGUSR1 and SIGUSR2 in this thread
+  sigset_t set;
+  sigemptyset(&set);
+  sigaddset(&set, SIGUSR1);
+  sigaddset(&set, SIGUSR2);
+  if (pthread_sigmask(SIG_UNBLOCK, &set, 0))
+    exit(100);
+
+  // Indicate that the thread is ready
+  thread_ready = 1;
+
+  // Call read() on the pipe
+  ret = read(pipefd[0], buf, 1);
+  if (ret == -1) {
+    if (errno == EINTR) {
+      read_interrupted = 1;
+      // printf("read interrupted\n");
+    } else {
+      perror("read");
+      exit(78);
+    }
+  } else {
+    exit(77);
+  }
+
+  return NULL;
+}
+
+int main() {
+  int pipefd[2];
+  pthread_t thread;
+
+  // this test exposes bugs in macos
+  if (IsXnu())
+    return 0;
+
+  // this test exposes bugs in linux
+  if (IsLinux())
+    return 0;
+
+  // this test exposes bugs in netbsd
+  if (IsNetbsd())
+    return 0;
+
+  // this test exposes bugs in freebsd
+  if (IsFreebsd())
+    return 0;
+
+  // this test exposes bugs in openbsd
+  if (IsOpenbsd())
+    return 0;
+
+  ShowCrashReports();
+
+  // Block SIGUSR1 and SIGUSR2 in the main thread
+  block_signals();
+
+  // Set up signal handlers
+  setup_signal_handlers();
+
+  // Create a pipe
+  if (pipe(pipefd) == -1)
+    exit(95);
+
+  // Create a thread
+  if (pthread_create(&thread, NULL, thread_func, pipefd) != 0)
+    exit(90);
+
+  // Wait until the thread is ready
+  while (!thread_ready)
+    if (pthread_yield_np())
+      exit(101);
+
+  // Send SIGUSR1 signals
+  // This will cause read() to restart internally
+  for (int i = 0; i < COUNT; i++) {
+    if (pthread_kill(thread, SIGUSR1) != 0)
+      exit(91);
+    if (i % (COUNT / 10) == 0)
+      usleep(1);
+  }
+
+  // Send SIGUSR2 to the thread
+  // This will trigger an EINTR
+  fflush(stdout);
+  if (pthread_kill(thread, SIGUSR2))
+    exit(92);
+
+  // Join the thread
+  if (pthread_join(thread, NULL))
+    exit(93);
+
+  // Close the pipe
+  close(pipefd[0]);
+  close(pipefd[1]);
+
+  // Check if read() was interrupted by EINTR
+  if (!read_interrupted)
+    exit(94);
+
+  if (!got_sigusr1)
+    exit(60);
+  if (!got_sigusr2)
+    exit(61);
+
+  // printf("got %d got_sigusr1\n", got_sigusr1);
+
+  CheckForMemoryLeaks();
+  return 0;
+}
diff --git a/test/posix/socket_fionread_test.c b/test/posix/socket_fionread_test.c
new file mode 100644
index 000000000..c6fd81413
--- /dev/null
+++ b/test/posix/socket_fionread_test.c
@@ -0,0 +1,69 @@
+#include <arpa/inet.h>
+#include <cosmo.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+int main() {
+
+  // create server socket
+  int server_fd;
+  struct sockaddr_in address;
+  int addrlen = sizeof(address);
+  if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    return 1;
+  address.sin_family = AF_INET;
+  address.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  address.sin_port = 0;  // let os assign random port
+  if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)))
+    return 2;
+  if (getsockname(server_fd, (struct sockaddr *)&address,
+                  (socklen_t *)&addrlen))
+    return 3;
+  if (listen(server_fd, SOMAXCONN))
+    return 4;
+
+  // create client socket
+  int client_fd;
+  if ((client_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
+    return 6;
+  if (connect(client_fd, (struct sockaddr *)&address, sizeof(address)))
+    return 7;
+
+  // accept client and send data
+  int server_client_fd;
+  if ((server_client_fd = accept(server_fd, 0, 0)) == -1)
+    return 8;
+  if (write(server_client_fd, "hi", 2) != 2)
+    return 9;
+
+  // poll to be safe (important for mac/bsd)
+  struct pollfd fds[] = {{client_fd, POLLIN}};
+  if (poll(fds, 1, -1u) != 1)
+    return 10;
+
+  // ask how many bytes we can read
+  uint32_t bytes_available;
+  if (ioctl(client_fd, FIONREAD, &bytes_available))
+    return 11;
+  if (bytes_available != 2) {
+    printf("wut %d\n", bytes_available);
+    return 12;
+  }
+
+  // clean up
+  if (close(client_fd))
+    return 13;
+  if (close(server_fd))
+    return 14;
+
+  CheckForMemoryLeaks();
+}
diff --git a/test/posix/socket_timeout_signal_test.c b/test/posix/socket_timeout_signal_test.c
new file mode 100644
index 000000000..376f86fa6
--- /dev/null
+++ b/test/posix/socket_timeout_signal_test.c
@@ -0,0 +1,214 @@
+#include <arpa/inet.h>
+#include <cosmo.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+/**
+ * @fileoverview SO_RCVTIMEO + SA_RESTART interaction test
+ *
+ * This code tests that setting a read timeout on a socket will cause
+ * read() to change its signal handling behavior from @restartable to
+ * @norestart. This is currently the case on GNU/Systemd and Windows.
+ */
+
+struct sockaddr_in serv_addr;
+atomic_bool g_ready_for_conn;
+atomic_bool g_ready_for_data;
+atomic_bool g_ready_for_more;
+atomic_bool g_ready_for_exit;
+atomic_bool got_sigusr1;
+atomic_bool got_sigusr2;
+
+void on_sigusr1(int sig) {
+  got_sigusr1 = true;
+}
+
+void on_sigusr2(int sig) {
+  got_sigusr2 = true;
+}
+
+void *server_thread(void *arg) {
+  int server, client;
+  struct timeval timeout;
+  socklen_t len;
+  struct sockaddr_in cli_addr;
+
+  // create listening socket
+  server = socket(AF_INET, SOCK_STREAM, 0);
+  if (server == -1) {
+    perror("socket");
+    exit(31);
+  }
+
+  // initialize server address
+  memset(&serv_addr, 0, sizeof(serv_addr));
+  serv_addr.sin_family = AF_INET;
+  serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  serv_addr.sin_port = htons(0);
+
+  // bind socket
+  if (bind(server, (struct sockaddr *)&serv_addr, sizeof(serv_addr))) {
+    perror("bind");
+    exit(32);
+  }
+
+  // get assigned port
+  len = sizeof(serv_addr);
+  if (getsockname(server, (struct sockaddr *)&serv_addr, &len)) {
+    perror("getsockname");
+    exit(30);
+  }
+
+  // listen on the socket
+  if (listen(server, SOMAXCONN)) {
+    perror("listen");
+    exit(33);
+  }
+
+  // wake main thread
+  g_ready_for_conn = true;
+
+  // accept connection
+  len = sizeof(cli_addr);
+  client = accept(server, (struct sockaddr *)&cli_addr, &len);
+  if (client == -1) {
+    perror("accept");
+    exit(35);
+  }
+
+  // wake main thread
+  g_ready_for_data = true;
+
+  // check read() has @restartable behavior
+  char buf[1];
+  int rc = read(client, buf, 1);
+  if (rc != -1)
+    exit(35);
+  if (errno != EINTR)
+    exit(36);
+  if (!got_sigusr1)
+    exit(37);
+  if (!got_sigusr2)
+    exit(38);
+  got_sigusr1 = false;
+  got_sigusr2 = false;
+
+  // install a socket receive timeout
+  timeout.tv_sec = 5000000;
+  timeout.tv_usec = 0;
+  if (setsockopt(client, SOL_SOCKET, SO_RCVTIMEO, &timeout,
+                 sizeof(timeout) + (!IsNetbsd() && !IsQemuUser()))) {
+    perror("setsockopt");
+    exit(34);
+  }
+
+  // wake main thread
+  g_ready_for_more = true;
+
+  // check read() has @norestart behavior
+  rc = read(client, buf, 1);
+  if (rc != -1)
+    exit(35);
+  if (errno != EINTR)
+    exit(36);
+  if (!got_sigusr1)
+    exit(37);
+
+  // here's the whammy
+  if (IsLinux() || IsWindows()) {
+    if (got_sigusr2)
+      exit(38);
+  } else {
+    if (!got_sigusr2)
+      exit(38);
+  }
+
+  // wait for main thread
+  for (;;)
+    if (g_ready_for_exit)
+      break;
+
+  // close listening socket
+  if (close(server))
+    exit(40);
+  if (close(client))
+    exit(39);
+  return 0;
+}
+
+int main() {
+
+  // handle signals
+  struct sigaction sa = {0};
+  sa.sa_handler = on_sigusr1;
+  sa.sa_flags = SA_RESTART;
+  sigaction(SIGUSR1, &sa, 0);
+  sa.sa_handler = on_sigusr2;
+  sa.sa_flags = 0;
+  sigaction(SIGUSR2, &sa, 0);
+
+  // create server thread
+  pthread_t th;
+  if (pthread_create(&th, 0, server_thread, 0))
+    return 1;
+
+  // wait for thread
+  for (;;)
+    if (g_ready_for_conn)
+      break;
+
+  // create socket
+  int client = socket(AF_INET, SOCK_STREAM, 0);
+  if (client == -1) {
+    perror("socket");
+    return 2;
+  }
+
+  // connect to server
+  if (connect(client, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
+    perror("connect");
+    return 3;
+  }
+
+  // wait for thread
+  for (;;)
+    if (g_ready_for_data)
+      break;
+
+  usleep(100e3);
+  if (pthread_kill(th, SIGUSR1))
+    return 4;
+
+  usleep(100e3);
+  if (pthread_kill(th, SIGUSR2))
+    return 5;
+
+  // wait for thread
+  for (;;)
+    if (g_ready_for_more)
+      break;
+
+  usleep(100e3);
+  if (pthread_kill(th, SIGUSR1))
+    return 4;
+
+  usleep(400e3);
+  if (pthread_kill(th, SIGUSR2))
+    return 5;
+
+  g_ready_for_exit = true;
+
+  if (pthread_join(th, 0))
+    return 20;
+}
diff --git a/test/posix/unnamed_semaphore_test.c b/test/posix/unnamed_semaphore_test.c
new file mode 100644
index 000000000..f406f82b3
--- /dev/null
+++ b/test/posix/unnamed_semaphore_test.c
@@ -0,0 +1,35 @@
+#include <pthread.h>
+#include <semaphore.h>
+
+#define THREADS    10
+#define ITERATIONS 100000
+
+int g_count;
+sem_t g_sem;
+
+void *worker(void *arg) {
+  for (int i = 0; i < ITERATIONS; ++i) {
+    if (sem_wait(&g_sem))
+      exit(6);
+    ++g_count;
+    if (sem_post(&g_sem))
+      exit(7);
+  }
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+  pthread_t th[THREADS];
+  if (sem_init(&g_sem, 0, 1))
+    return 1;
+  for (int i = 0; i < THREADS; ++i)
+    if (pthread_create(&th[i], 0, worker, 0))
+      return 2;
+  for (int i = 0; i < THREADS; ++i)
+    if (pthread_join(th[i], 0))
+      return 3;
+  if (g_count != THREADS * ITERATIONS)
+    return 4;
+  if (sem_destroy(&g_sem))
+    return 5;
+}
diff --git a/test/posix/wait2x_test.c b/test/posix/wait2x_test.c
new file mode 100644
index 000000000..06c900ec4
--- /dev/null
+++ b/test/posix/wait2x_test.c
@@ -0,0 +1,70 @@
+// Copyright 2024 Justine Alexandra Roberts Tunney
+//
+// Permission to use, copy, modify, and/or distribute this software for
+// any purpose with or without fee is hereby granted, provided that the
+// above copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+// WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+// DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+// PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+#include <errno.h>
+#include <stdatomic.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main(int argc, char *argv[]) {
+  int ws, rc;
+
+  // create shared memory for synchronization
+  atomic_int *ready =
+      mmap(0, 4, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
+
+  if ((rc = waitpid(-1, &ws, WNOHANG)) != -1)
+    return 1;
+  if (errno != ECHILD)
+    return 2;
+
+  // create process
+  int pid = fork();
+  if (pid == -1)
+    return 3;
+  if (!pid) {
+    for (;;)
+      if (*ready)
+        break;
+    _Exit(0);
+  }
+
+  // wait on process
+  if ((rc = waitpid(pid, &ws, WNOHANG)) == -1)
+    return 4;
+  if (rc != 0)
+    return 5;
+  if (ws)
+    return 6;
+
+  // signal subprocess
+  *ready = 1;
+
+  if ((rc = waitpid(pid, &ws, 0)) == -1)
+    return 7;
+  if (rc != pid)
+    return 8;
+  if (ws)
+    return 9;
+
+  // wait again
+  if ((rc = waitpid(pid, &ws, WNOHANG)) != -1)
+    return 10;
+  if (errno != ECHILD)
+    return 11;
+}
diff --git a/test/posix/writev_test.c b/test/posix/writev_test.c
new file mode 100644
index 000000000..400233397
--- /dev/null
+++ b/test/posix/writev_test.c
@@ -0,0 +1,122 @@
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <unistd.h>
+
+int main() {
+  int sockfd, newsockfd, clientfd;
+  struct sockaddr_in serv_addr, cli_addr;
+  socklen_t clilen;
+  struct iovec iov[2];
+  char buffer[256];
+  ssize_t n;
+  const char *str1 = "";
+  const char *str2 = "Hello from server!\n";
+  const char *str3 = "Hello from client!\n";
+
+  // Create server socket
+  sockfd = socket(AF_INET, SOCK_STREAM, 0);
+  if (sockfd < 0) {
+    perror("socket");
+    return 18;
+  }
+
+  // Bind server socket to localhost:PORT
+  memset(&serv_addr, 0, sizeof(serv_addr));
+  serv_addr.sin_family = AF_INET;
+  serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);  // localhost
+  serv_addr.sin_port = 0;
+  if (bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
+    perror("bind");
+    close(sockfd);
+    return 19;
+  }
+  uint32_t addrsize = sizeof(serv_addr);
+  if (getsockname(sockfd, (struct sockaddr *)&serv_addr, &addrsize)) {
+    perror("getsockname");
+    return 20;
+  }
+
+  // Listen for incoming connections
+  if (listen(sockfd, 1) < 0) {
+    perror("listen");
+    close(sockfd);
+    return 21;
+  }
+
+  // Create client socket
+  clientfd = socket(AF_INET, SOCK_STREAM, 0);
+  if (clientfd < 0) {
+    perror("socket");
+    close(sockfd);
+    return 22;
+  }
+
+  // Connect client socket to server
+  if (connect(clientfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
+    perror("connect");
+    close(sockfd);
+    close(clientfd);
+    return 23;
+  }
+
+  // Accept connection on server side
+  clilen = sizeof(cli_addr);
+  newsockfd = accept(sockfd, (struct sockaddr *)&cli_addr, &clilen);
+  if (newsockfd < 0) {
+    perror("accept");
+    close(sockfd);
+    close(clientfd);
+    return 34;
+  }
+
+  // Server writes to client using writev with zero-length iovec
+  iov[0].iov_base = (void *)str1;
+  iov[0].iov_len = 0;  // Zero-length iovec
+  iov[1].iov_base = (void *)str2;
+  iov[1].iov_len = strlen(str2);
+
+  n = writev(newsockfd, iov, 2);
+  if (n != 19)
+    return 13;
+
+  // Client reads data from server
+  memset(buffer, 0, sizeof(buffer));
+  n = read(clientfd, buffer, sizeof(buffer) - 1);
+  if (n < 0) {
+    perror("read");
+    return 14;
+  } else {
+    if (n != 19)
+      return 8;
+  }
+
+  // Client writes to server using writev with zero-length iovec
+  iov[0].iov_base = (void *)str1;
+  iov[0].iov_len = 0;  // Zero-length iovec
+  iov[1].iov_base = (void *)str3;
+  iov[1].iov_len = strlen(str3);
+
+  n = writev(clientfd, iov, 2);
+  if (n != 19)
+    return 9;
+
+  // Server reads data from client
+  memset(buffer, 0, sizeof(buffer));
+  n = read(newsockfd, buffer, sizeof(buffer) - 1);
+  if (n < 0) {
+    perror("ERROR reading from client");
+    return 10;
+  } else if (n != 19) {
+    return 11;
+  }
+
+  // Close all sockets
+  close(newsockfd);
+  close(clientfd);
+  close(sockfd);
+}
diff --git a/test/tool/args/args2_test.c b/test/tool/args/args2_test.c
new file mode 100644
index 000000000..8f208aa63
--- /dev/null
+++ b/test/tool/args/args2_test.c
@@ -0,0 +1,195 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/cosmo.h"
+#include "libc/dce.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/rand.h"
+#include "libc/testlib/testlib.h"
+#include "libc/x/x.h"
+
+void SetUpOnce(void) {
+  testlib_enable_tmp_setup_teardown();
+}
+
+TEST(cosmo_args, normalize) {
+  char *args[] = {0};
+  char **argv = args;
+  ASSERT_EQ(1, cosmo_args(0, &argv));
+  ASSERT_STREQ(GetProgramExecutableName(), argv[0]);
+}
+
+TEST(cosmo_args, test) {
+  xbarf(".args", "a b c", -1);
+  char *args[] = {"prog", "arg", 0};
+  char **argv = args;
+  ASSERT_EQ(5, cosmo_args(".args", &argv));
+  ASSERT_STREQ("prog", argv[0]);
+  ASSERT_STREQ("a", argv[1]);
+  ASSERT_STREQ("b", argv[2]);
+  ASSERT_STREQ("c", argv[3]);
+  ASSERT_STREQ("arg", argv[4]);
+}
+
+TEST(cosmo_args, perline) {
+  xbarf(".args", "a\nb\nc\n", -1);
+  char *args[] = {"prog", "arg", 0};
+  char **argv = args;
+  ASSERT_EQ(5, cosmo_args(".args", &argv));
+  ASSERT_STREQ("prog", argv[0]);
+  ASSERT_STREQ("a", argv[1]);
+  ASSERT_STREQ("b", argv[2]);
+  ASSERT_STREQ("c", argv[3]);
+  ASSERT_STREQ("arg", argv[4]);
+}
+
+TEST(cosmo_args, dots_end) {
+  xbarf(".args", "a b c ...", -1);
+  char *args[] = {"prog", "arg", 0};
+  char **argv = args;
+  ASSERT_EQ(5, cosmo_args(".args", &argv));
+  ASSERT_STREQ("prog", argv[0]);
+  ASSERT_STREQ("a", argv[1]);
+  ASSERT_STREQ("b", argv[2]);
+  ASSERT_STREQ("c", argv[3]);
+  ASSERT_STREQ("arg", argv[4]);
+}
+
+TEST(cosmo_args, dots_middle) {
+  xbarf(".args", "a ... b c", -1);
+  char *args[] = {"prog", "arg", 0};
+  char **argv = args;
+  ASSERT_EQ(5, cosmo_args(".args", &argv));
+  ASSERT_STREQ("prog", argv[0]);
+  ASSERT_STREQ("a", argv[1]);
+  ASSERT_STREQ("arg", argv[2]);
+  ASSERT_STREQ("b", argv[3]);
+  ASSERT_STREQ("c", argv[4]);
+}
+
+TEST(cosmo_args, quote) {
+  xbarf(".args", " 'hi \\n there'# ", -1);
+  char *args[] = {0};
+  char **argv = args;
+  ASSERT_EQ(2, cosmo_args(".args", &argv));
+  ASSERT_STREQ("hi \\n there#", argv[1]);
+}
+
+TEST(cosmo_args, dquote) {
+  xbarf(".args", " \"hi \\a\\b\\t\\n\\v\\f\\r\\e\\0\\11 \\111 \xab there\"# ",
+        -1);
+  char *args[] = {0};
+  char **argv = args;
+  ASSERT_EQ(2, cosmo_args(".args", &argv));
+  ASSERT_STREQ("hi \a\b\t\n\v\f\r\e\0\11 \111 \xab there#", argv[1]);
+}
+
+TEST(cosmo_args, comment) {
+  xbarf(".args",
+        "# comment\n"
+        "a # hello there\n"
+        "b # yup\n",
+        -1);
+  char *args[] = {0};
+  char **argv = args;
+  ASSERT_EQ(3, cosmo_args(".args", &argv));
+  ASSERT_STREQ("a", argv[1]);
+  ASSERT_STREQ("b", argv[2]);
+}
+
+TEST(cosmo_args, backslash_newline) {
+  xbarf(".args",
+        "a\\\n"
+        "b\n",
+        -1);
+  char *args[] = {0};
+  char **argv = args;
+  ASSERT_EQ(2, cosmo_args(".args", &argv));
+  ASSERT_STREQ("ab", argv[1]);
+}
+
+TEST(cosmo_args, dotz) {
+  xbarf(".args", ". .. ...x", -1);
+  char *args[] = {0};
+  char **argv = args;
+  ASSERT_EQ(4, cosmo_args(".args", &argv));
+  ASSERT_STREQ(".", argv[1]);
+  ASSERT_STREQ("..", argv[2]);
+  ASSERT_STREQ("...x", argv[3]);
+}
+
+TEST(cosmo_args, env) {
+  setenv("foo", "bar", true);
+  xbarf(".args", "$foo x${foo}x \"$foo\" \"${foo}\" $foo", -1);
+  char *args[] = {0};
+  char **argv = args;
+  ASSERT_EQ(6, cosmo_args(".args", &argv));
+  ASSERT_STREQ("bar", argv[1]);
+  ASSERT_STREQ("xbarx", argv[2]);
+  ASSERT_STREQ("bar", argv[3]);
+  ASSERT_STREQ("bar", argv[4]);
+  ASSERT_STREQ("bar", argv[5]);
+}
+
+TEST(cosmo_args, dquote_backslash_newline) {
+  setenv("foo", "bar", true);
+  xbarf(".args",
+        "-p \"\\\n"
+        "hello\"\n",
+        -1);
+  char *args[] = {0};
+  char **argv = args;
+  ASSERT_EQ(3, cosmo_args(".args", &argv));
+  ASSERT_STREQ("-p", argv[1]);
+  ASSERT_STREQ("hello", argv[2]);
+}
+
+TEST(cosmo_args, dquote_plain_old_newline) {
+  setenv("foo", "bar", true);
+  xbarf(".args",
+        "-p \"\n"
+        "hello\"\n",
+        -1);
+  char *args[] = {0};
+  char **argv = args;
+  ASSERT_EQ(3, cosmo_args(".args", &argv));
+  ASSERT_STREQ("-p", argv[1]);
+  ASSERT_STREQ("\nhello", argv[2]);
+}
+
+#define LENGTH     128
+#define ITERATIONS 5000
+#define CHARSET    "abc#'\"$.\\{} \r\n"
+
+TEST(cosmo_args, fuzz) {
+  if (IsWindows())
+    return;  // not worth it fs too slow
+  char s[LENGTH + 1] = {0};
+  for (int i = 0; i < ITERATIONS; ++i) {
+    for (int j = 0; j < LENGTH; ++j)
+      s[j] = CHARSET[rand() % (sizeof(CHARSET) - 1)];
+    xbarf(".args", s, -1);
+    char *args[] = {0};
+    char **argv = args;
+    cosmo_args(".args", &argv);
+    for (int j = 0; argv[j]; ++j)
+      free(argv[j]);
+    argv[0] = 0;
+  }
+}
diff --git a/test/tool/args/args_test.c b/test/tool/args/args_test.c
index ec57b1044..0f7f6c47d 100644
--- a/test/tool/args/args_test.c
+++ b/test/tool/args/args_test.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "tool/args/args.h"
+#include "libc/cosmo.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/testlib/testlib.h"
diff --git a/test/tool/build/lib/asmdown_test.c b/test/tool/build/lib/asmdown_test.c
index 0d3b2259f..3524c2599 100644
--- a/test/tool/build/lib/asmdown_test.c
+++ b/test/tool/build/lib/asmdown_test.c
@@ -23,7 +23,7 @@
 TEST(ParseAsmdown, test) {
   struct Asmdown *ad;
   const char *s = "\
-#include \"libc/macros.internal.h\"\n\
+#include \"libc/macros.h\"\n\
 .source	__FILE__\n\
 \n\
 /	Returns absolute value of double.\n\
@@ -87,7 +87,7 @@ tinymath_acos:\n\
 TEST(ParseAsmdown, testAlias) {
   struct Asmdown *ad;
   const char *s = "\
-#include \"libc/macros.internal.h\"\n\
+#include \"libc/macros.h\"\n\
 .source	__FILE__\n\
 \n\
 /	Returns arc cosine of 𝑥.\n\
@@ -137,7 +137,7 @@ tinymath_acos:\n\
 TEST(ParseAsmdown, testClangIsEvil) {
   struct Asmdown *ad;
   const char *s = "\
-#include \"libc/macros.internal.h\"\n\
+#include \"libc/macros.h\"\n\
 .source	__FILE__\n\
 \n\
 //	Returns arc cosine of 𝑥.\n\
diff --git a/test/tool/build/lib/interner_test.c b/test/tool/build/lib/interner_test.c
index b26709ae7..ece510d30 100644
--- a/test/tool/build/lib/interner_test.c
+++ b/test/tool/build/lib/interner_test.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "tool/build/lib/interner.h"
+#include "libc/ctype.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/stdio.h"
diff --git a/test/tool/net/redbean_test.c b/test/tool/net/redbean_test.c
index 685db685f..e13c3cfdd 100644
--- a/test/tool/net/redbean_test.c
+++ b/test/tool/net/redbean_test.c
@@ -39,7 +39,6 @@
 #include "libc/testlib/testlib.h"
 #include "libc/x/x.h"
 #include "third_party/regex/regex.h"
-#ifdef __x86_64__
 
 __static_yoink("zipos");
 __static_yoink("o/" MODE "/test/tool/net/redbean-tester");
@@ -263,7 +262,7 @@ Last-Modified: .*\r\n\
 Accept-Ranges: bytes\r\n\
 X-Content-Type-Options: nosniff\r\n\
 Date: .*\r\n\
-Server: redbean/2.2.0\r\n\
+Server: redbean/.*\r\n\
 Content-Length: 34\r\n\
 \r\n\
 J\n\
@@ -292,5 +291,3 @@ Z\n",
   EXPECT_NE(-1, wait(0));
   EXPECT_NE(-1, sigprocmask(SIG_SETMASK, &savemask, 0));
 }
-
-#endif /* __x86_64__ */
diff --git a/test/tool/net/sqlite_test.c b/test/tool/net/sqlite_test.c
index 96c5bacc3..5df4ff716 100644
--- a/test/tool/net/sqlite_test.c
+++ b/test/tool/net/sqlite_test.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/test/tool/net/uuidv7_test.lua b/test/tool/net/uuidv7_test.lua
new file mode 100644
index 000000000..063a9da94
--- /dev/null
+++ b/test/tool/net/uuidv7_test.lua
@@ -0,0 +1,25 @@
+-- Copyright 2024 Justine Alexandra Roberts Tunney
+--
+-- Permission to use, copy, modify, and/or distribute this software for
+-- any purpose with or without fee is hereby granted, provided that the
+-- above copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+-- WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+-- WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+-- AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
+-- DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+-- PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+-- TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+-- PERFORMANCE OF THIS SOFTWARE.
+for _ = 1, 1000 do
+  local uuid = UuidV7()
+  assert(#uuid == 36)
+  assert(string.sub(uuid, 9, 9) == "-")
+  assert(string.sub(uuid, 14, 14) == "-")
+  assert(string.sub(uuid, 15, 15) == "7")
+  assert(string.sub(uuid, 19, 19) == "-")
+  local y = string.sub(uuid, 20, 20)
+  assert(y == "8" or y == "9" or y == "a" or y == "b")
+  assert(string.sub(uuid, 24, 24) == "-")
+end
diff --git a/test/tool/plinko/plinko_test.c b/test/tool/plinko/plinko_test.c
index 087663223..aa260d554 100644
--- a/test/tool/plinko/plinko_test.c
+++ b/test/tool/plinko/plinko_test.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/sigaction.h"
 #include "libc/errno.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
diff --git a/test/tool/viz/lib/fun_test.c b/test/tool/viz/lib/fun_test.c
index dc5340631..a158d8e82 100644
--- a/test/tool/viz/lib/fun_test.c
+++ b/test/tool/viz/lib/fun_test.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/stdio/rand.h"
 #include "libc/str/str.h"
@@ -212,7 +212,7 @@ void ExpandLuminosityRange(unsigned n, unsigned char *Y) {
 }
 
 TEST(ExpandLuminosityRange, test) {
-  unsigned char Y[32];
+  _Alignas(16) unsigned char Y[32];
   Y[0] = 0;
   ExpandLuminosityRange(16, Y);
   EXPECT_EQ(0, Y[0]);
diff --git a/test/tool/viz/lib/ycbcr2rgb2_test.c b/test/tool/viz/lib/ycbcr2rgb2_test.c
index 1e0f9e0e6..bb2d6e90b 100644
--- a/test/tool/viz/lib/ycbcr2rgb2_test.c
+++ b/test/tool/viz/lib/ycbcr2rgb2_test.c
@@ -16,8 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "dsp/mpeg/mpeg.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
diff --git a/third_party/BUILD.mk b/third_party/BUILD.mk
index f785620d3..5117534ca 100644
--- a/third_party/BUILD.mk
+++ b/third_party/BUILD.mk
@@ -5,7 +5,6 @@
 o/$(MODE)/third_party:				\
 	o/$(MODE)/third_party/argon2		\
 	o/$(MODE)/third_party/awk		\
-	o/$(MODE)/third_party/bash		\
 	o/$(MODE)/third_party/bzip2		\
 	o/$(MODE)/third_party/chibicc		\
 	o/$(MODE)/third_party/compiler_rt	\
diff --git a/third_party/aarch64/BUILD.mk b/third_party/aarch64/BUILD.mk
index 7ed5ff404..ffff966a9 100644
--- a/third_party/aarch64/BUILD.mk
+++ b/third_party/aarch64/BUILD.mk
@@ -3,4 +3,4 @@
 
 PKGS += THIRD_PARTY_AARCH64
 THIRD_PARTY_AARCH64_HDRS = $(filter %.h,$(THIRD_PARTY_AARCH64_FILES))
-THIRD_PARTY_AARCH64_FILES := $(wildcard third_party/aarch64/*)
+THIRD_PARTY_AARCH64_FILES := $(wildcard third_party/aarch64/*) $(wildcard third_party/aarch64/clang/*)
diff --git a/third_party/aarch64/acc_prof.internal.h b/third_party/aarch64/acc_prof.internal.h
deleted file mode 100644
index fbe73440a..000000000
--- a/third_party/aarch64/acc_prof.internal.h
+++ /dev/null
@@ -1,164 +0,0 @@
-#if defined(__aarch64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
-#ifndef _ACC_PROF_H
-#define _ACC_PROF_H 1
-#include "third_party/aarch64/openacc.internal.h"
-#ifdef __cplusplus
-extern "C" {
-#endif
-typedef enum acc_event_t
-{
-  acc_ev_none = 0,
-  acc_ev_device_init_start,
-  acc_ev_device_init_end,
-  acc_ev_device_shutdown_start,
-  acc_ev_device_shutdown_end,
-  acc_ev_runtime_shutdown,
-  acc_ev_create,
-  acc_ev_delete,
-  acc_ev_alloc,
-  acc_ev_free,
-  acc_ev_enter_data_start,
-  acc_ev_enter_data_end,
-  acc_ev_exit_data_start,
-  acc_ev_exit_data_end,
-  acc_ev_update_start,
-  acc_ev_update_end,
-  acc_ev_compute_construct_start,
-  acc_ev_compute_construct_end,
-  acc_ev_enqueue_launch_start,
-  acc_ev_enqueue_launch_end,
-  acc_ev_enqueue_upload_start,
-  acc_ev_enqueue_upload_end,
-  acc_ev_enqueue_download_start,
-  acc_ev_enqueue_download_end,
-  acc_ev_wait_start,
-  acc_ev_wait_end,
-  acc_ev_last
-} acc_event_t;
-typedef signed long int _acc_prof_ssize_t;
-typedef unsigned long int _acc_prof_size_t;
-typedef int _acc_prof_int_t;
-#define _ACC_PROF_VALID_BYTES_STRUCT(_struct, _lastfield, _valid_bytes_lastfield) offsetof (_struct, _lastfield) + (_valid_bytes_lastfield)
-#if 0
-#define _ACC_PROF_VALID_BYTES_TYPE_N(_type, _n, _valid_bytes_type) ((_n - 1) * sizeof (_type) + (_valid_bytes_type))
-#endif
-#define _ACC_PROF_VALID_BYTES_BASICTYPE(_basictype) (sizeof (_basictype))
-typedef struct acc_prof_info
-{
-  acc_event_t event_type;
-  _acc_prof_int_t valid_bytes;
-  _acc_prof_int_t version;
-  acc_device_t device_type;
-  _acc_prof_int_t device_number;
-  _acc_prof_int_t thread_id;
-  _acc_prof_ssize_t async;
-  _acc_prof_ssize_t async_queue;
-  const char *src_file;
-  const char *func_name;
-  _acc_prof_int_t line_no, end_line_no;
-  _acc_prof_int_t func_line_no, func_end_line_no;
-#define _ACC_PROF_INFO_VALID_BYTES _ACC_PROF_VALID_BYTES_STRUCT (acc_prof_info, func_end_line_no, _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_int_t))
-} acc_prof_info;
-#define _ACC_PROF_INFO_VERSION 201711
-typedef enum acc_construct_t
-{
-  acc_construct_parallel = 0,
-  acc_construct_kernels,
-  acc_construct_loop,
-  acc_construct_data,
-  acc_construct_enter_data,
-  acc_construct_exit_data,
-  acc_construct_host_data,
-  acc_construct_atomic,
-  acc_construct_declare,
-  acc_construct_init,
-  acc_construct_shutdown,
-  acc_construct_set,
-  acc_construct_update,
-  acc_construct_routine,
-  acc_construct_wait,
-  acc_construct_runtime_api,
-  acc_construct_serial
-} acc_construct_t;
-typedef struct acc_data_event_info
-{
-  acc_event_t event_type;
-  _acc_prof_int_t valid_bytes;
-  acc_construct_t parent_construct;
-  _acc_prof_int_t implicit;
-  void *tool_info;
-  const char *var_name;
-  _acc_prof_size_t bytes;
-  const void *host_ptr;
-  const void *device_ptr;
-#define _ACC_DATA_EVENT_INFO_VALID_BYTES _ACC_PROF_VALID_BYTES_STRUCT (acc_data_event_info, device_ptr, _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
-} acc_data_event_info;
-typedef struct acc_launch_event_info
-{
-  acc_event_t event_type;
-  _acc_prof_int_t valid_bytes;
-  acc_construct_t parent_construct;
-  _acc_prof_int_t implicit;
-  void *tool_info;
-  const char *kernel_name;
-  _acc_prof_size_t num_gangs, num_workers, vector_length;
-#define _ACC_LAUNCH_EVENT_INFO_VALID_BYTES _ACC_PROF_VALID_BYTES_STRUCT (acc_launch_event_info, vector_length, _ACC_PROF_VALID_BYTES_BASICTYPE (_acc_prof_size_t))
-} acc_launch_event_info;
-typedef struct acc_other_event_info
-{
-  acc_event_t event_type;
-  _acc_prof_int_t valid_bytes;
-  acc_construct_t parent_construct;
-  _acc_prof_int_t implicit;
-  void *tool_info;
-#define _ACC_OTHER_EVENT_INFO_VALID_BYTES _ACC_PROF_VALID_BYTES_STRUCT (acc_other_event_info, tool_info, _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
-} acc_other_event_info;
-typedef union acc_event_info
-{
-  acc_event_t event_type;
-  acc_data_event_info data_event;
-  acc_launch_event_info launch_event;
-  acc_other_event_info other_event;
-} acc_event_info;
-typedef enum acc_device_api
-{
-  acc_device_api_none = 0,
-  acc_device_api_cuda,
-  acc_device_api_opencl,
-  acc_device_api_coi,
-  acc_device_api_other
-} acc_device_api;
-typedef struct acc_api_info
-{
-  acc_device_api device_api;
-  _acc_prof_int_t valid_bytes;
-  acc_device_t device_type;
-  _acc_prof_int_t vendor;
-  const void *device_handle;
-  const void *context_handle;
-  const void *async_handle;
-#define _ACC_API_INFO_VALID_BYTES _ACC_PROF_VALID_BYTES_STRUCT (acc_api_info, async_handle, _ACC_PROF_VALID_BYTES_BASICTYPE (void *))
-} acc_api_info;
-typedef void (*acc_prof_callback) (acc_prof_info *, acc_event_info *,
-       acc_api_info *);
-typedef enum acc_register_t
-{
-  acc_reg = 0,
-  acc_toggle = 1,
-  acc_toggle_per_thread = 2
-} acc_register_t;
-typedef void (*acc_prof_reg) (acc_event_t, acc_prof_callback, acc_register_t);
-extern void acc_prof_register (acc_event_t, acc_prof_callback,
-          acc_register_t) __GOACC_NOTHROW;
-extern void acc_prof_unregister (acc_event_t, acc_prof_callback,
-     acc_register_t) __GOACC_NOTHROW;
-typedef void (*acc_query_fn) ();
-typedef acc_query_fn (*acc_prof_lookup_func) (const char *);
-extern acc_query_fn acc_prof_lookup (const char *) __GOACC_NOTHROW;
-extern void acc_register_library (acc_prof_reg, acc_prof_reg,
-      acc_prof_lookup_func);
-#ifdef __cplusplus
-}
-#endif
-#endif
-#endif
diff --git a/third_party/aarch64/arm_acle.internal.h b/third_party/aarch64/arm_acle.internal.h
index 687b133d2..dd2a40da4 100644
--- a/third_party/aarch64/arm_acle.internal.h
+++ b/third_party/aarch64/arm_acle.internal.h
@@ -27,6 +27,32 @@ _GCC_ARM_ACLE_DATA_FN (revsh, bswap16, int16_t, int16_t)
 _GCC_ARM_ACLE_DATA_FN (rev, bswap32, uint32_t, uint32_t)
 _GCC_ARM_ACLE_DATA_FN (revll, bswap64, uint64_t, uint64_t)
 #undef _GCC_ARM_ACLE_DATA_FN
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+__pld (void const volatile *__addr)
+{
+  return __builtin_aarch64_pld (__addr);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+__pli (void const volatile *__addr)
+{
+  return __builtin_aarch64_pli (__addr);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+__plix (unsigned int __cache, unsigned int __rettn,
+ void const volatile *__addr)
+{
+  return __builtin_aarch64_plix (__cache, __rettn, __addr);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+__pldx (unsigned int __access, unsigned int __cache, unsigned int __rettn,
+ void const volatile *__addr)
+{
+  return __builtin_aarch64_pldx (__access, __cache, __rettn, __addr);
+}
 __extension__ extern __inline unsigned long
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 __revl (unsigned long __value)
@@ -188,34 +214,7 @@ __ttest (void)
 #pragma GCC pop_options
 #endif
 #ifdef __ARM_FEATURE_LS64
-#pragma GCC push_options
-#pragma GCC target ("+nothing+ls64")
 typedef __arm_data512_t data512_t;
-__extension__ extern __inline data512_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-__arm_ld64b (const void *__addr)
-{
-  return __builtin_aarch64_ld64b (__addr);
-}
-__extension__ extern __inline void
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-__arm_st64b (void *__addr, data512_t __value)
-{
-  __builtin_aarch64_st64b (__addr, __value);
-}
-__extension__ extern __inline uint64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-__arm_st64bv (void *__addr, data512_t __value)
-{
-  return __builtin_aarch64_st64bv (__addr, __value);
-}
-__extension__ extern __inline uint64_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-__arm_st64bv0 (void *__addr, data512_t __value)
-{
-  return __builtin_aarch64_st64bv0 (__addr, __value);
-}
-#pragma GCC pop_options
 #endif
 #pragma GCC push_options
 #pragma GCC target ("+nothing+rng")
@@ -233,7 +232,7 @@ __rndrrs (uint64_t *__res)
 }
 #pragma GCC pop_options
 #pragma GCC push_options
-#pragma GCC target ("arch=armv8.5-a+memtag")
+#pragma GCC target ("+nothing+memtag")
 #define __arm_mte_create_random_tag(__ptr, __u64_mask) __builtin_aarch64_memtag_irg(__ptr, __u64_mask)
 #define __arm_mte_exclude_tag(__ptr, __u64_excluded) __builtin_aarch64_memtag_gmi(__ptr, __u64_excluded)
 #define __arm_mte_ptrdiff(__ptr_a, __ptr_b) __builtin_aarch64_memtag_subp(__ptr_a, __ptr_b)
@@ -241,6 +240,21 @@ __rndrrs (uint64_t *__res)
 #define __arm_mte_set_tag(__tagged_address) __builtin_aarch64_memtag_set_tag(__tagged_address)
 #define __arm_mte_get_tag(__address) __builtin_aarch64_memtag_get_tag(__address)
 #pragma GCC pop_options
+#define __arm_rsr(__regname) __builtin_aarch64_rsr (__regname)
+#define __arm_rsrp(__regname) __builtin_aarch64_rsrp (__regname)
+#define __arm_rsr64(__regname) __builtin_aarch64_rsr64 (__regname)
+#define __arm_rsrf(__regname) __builtin_aarch64_rsrf (__regname)
+#define __arm_rsrf64(__regname) __builtin_aarch64_rsrf64 (__regname)
+#define __arm_wsr(__regname, __value) __builtin_aarch64_wsr (__regname, __value)
+#define __arm_wsrp(__regname, __value) __builtin_aarch64_wsrp (__regname, __value)
+#define __arm_wsr64(__regname, __value) __builtin_aarch64_wsr64 (__regname, __value)
+#define __arm_wsrf(__regname, __value) __builtin_aarch64_wsrf (__regname, __value)
+#define __arm_wsrf64(__regname, __value) __builtin_aarch64_wsrf64 (__regname, __value)
+#pragma GCC push_options
+#pragma GCC target ("+nothing+d128")
+#define __arm_rsr128(__regname) __builtin_aarch64_rsr128 (__regname)
+#define __arm_wsr128(__regname, __value) __builtin_aarch64_wsr128 (__regname, __value)
+#pragma GCC pop_options
 #ifdef __cplusplus
 }
 #endif
diff --git a/third_party/aarch64/arm_fp16.internal.h b/third_party/aarch64/arm_fp16.internal.h
index 84185a620..090fe6fab 100644
--- a/third_party/aarch64/arm_fp16.internal.h
+++ b/third_party/aarch64/arm_fp16.internal.h
@@ -2,7 +2,7 @@
 #ifndef _AARCH64_FP16_H_
 #define _AARCH64_FP16_H_
 #pragma GCC push_options
-#pragma GCC target ("arch=armv8.2-a+fp16")
+#pragma GCC target ("+nothing+fp16")
 typedef __fp16 float16_t;
 __extension__ extern __inline float16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
@@ -260,7 +260,7 @@ __extension__ extern __inline float16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vnegh_f16 (float16_t __a)
 {
-  return __builtin_aarch64_neghf (__a);
+  return -__a;
 }
 __extension__ extern __inline float16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
diff --git a/third_party/aarch64/arm_neon.internal.h b/third_party/aarch64/arm_neon.internal.h
index 1cbe2db72..ed99f55bf 100644
--- a/third_party/aarch64/arm_neon.internal.h
+++ b/third_party/aarch64/arm_neon.internal.h
@@ -2330,2358 +2330,6 @@ vgetq_lane_u64 (uint64x2_t __a, const int __b)
 {
   return __aarch64_vget_lane_any (__a, __b);
 }
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_f16 (float16x4_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_f64 (float64x1_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_s8 (int8x8_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_s16 (int16x4_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_s32 (int32x2_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_s64 (int64x1_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_f32 (float32x2_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_u8 (uint8x8_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_u16 (uint16x4_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_u32 (uint32x2_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_u64 (uint64x1_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_p16 (poly16x4_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_p64 (poly64x1_t __a)
-{
-  return (poly8x8_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_f64 (float64x2_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_s8 (int8x16_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_s16 (int16x8_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_s32 (int32x4_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_s64 (int64x2_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_f16 (float16x8_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_f32 (float32x4_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_u8 (uint8x16_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_u16 (uint16x8_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_u32 (uint32x4_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_u64 (uint64x2_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_p16 (poly16x8_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_p64 (poly64x2_t __a)
-{
-  return (poly8x16_t) __a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_p128 (poly128_t __a)
-{
-  return (poly8x16_t)__a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_f16 (float16x4_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_f64 (float64x1_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_s8 (int8x8_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_s16 (int16x4_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_s32 (int32x2_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_s64 (int64x1_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_f32 (float32x2_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_u8 (uint8x8_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_u16 (uint16x4_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_u32 (uint32x2_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_u64 (uint64x1_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_p8 (poly8x8_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_p64 (poly64x1_t __a)
-{
-  return (poly16x4_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_f64 (float64x2_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_s8 (int8x16_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_s16 (int16x8_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_s32 (int32x4_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_s64 (int64x2_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_f16 (float16x8_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_f32 (float32x4_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_u8 (uint8x16_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_u16 (uint16x8_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_u32 (uint32x4_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_u64 (uint64x2_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_p8 (poly8x16_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_p64 (poly64x2_t __a)
-{
-  return (poly16x8_t) __a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_p128 (poly128_t __a)
-{
-  return (poly16x8_t)__a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_f16 (float16x4_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_f64 (float64x1_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_s8 (int8x8_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_s16 (int16x4_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_s32 (int32x2_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_s64 (int64x1_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_f32 (float32x2_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_u8 (uint8x8_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_u16 (uint16x4_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_u32 (uint32x2_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_u64 (uint64x1_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_p8 (poly8x8_t __a)
-{
-  return (poly64x1_t) __a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_p16 (poly16x4_t __a)
-{
-  return (poly64x1_t)__a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_f64 (float64x2_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_s8 (int8x16_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_s16 (int16x8_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_s32 (int32x4_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_s64 (int64x2_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_f16 (float16x8_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_f32 (float32x4_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_p128 (poly128_t __a)
-{
-  return (poly64x2_t)__a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_u8 (uint8x16_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_u16 (uint16x8_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_p16 (poly16x8_t __a)
-{
-  return (poly64x2_t)__a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_u32 (uint32x4_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_u64 (uint64x2_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_p8 (poly8x16_t __a)
-{
-  return (poly64x2_t) __a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_p8 (poly8x16_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_p16 (poly16x8_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_f16 (float16x8_t __a)
-{
-  return (poly128_t) __a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_f32 (float32x4_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_p64 (poly64x2_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_s64 (int64x2_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_u64 (uint64x2_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_s8 (int8x16_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_s16 (int16x8_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_s32 (int32x4_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_u8 (uint8x16_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_u16 (uint16x8_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_u32 (uint32x4_t __a)
-{
-  return (poly128_t)__a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_f64 (float64x1_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_s8 (int8x8_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_s16 (int16x4_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_s32 (int32x2_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_s64 (int64x1_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_f32 (float32x2_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_u8 (uint8x8_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_u16 (uint16x4_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_u32 (uint32x2_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_u64 (uint64x1_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_p8 (poly8x8_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_p16 (poly16x4_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_p64 (poly64x1_t __a)
-{
-  return (float16x4_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_f64 (float64x2_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_s8 (int8x16_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_s16 (int16x8_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_s32 (int32x4_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_s64 (int64x2_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_f32 (float32x4_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_u8 (uint8x16_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_u16 (uint16x8_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_u32 (uint32x4_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_u64 (uint64x2_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_p8 (poly8x16_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_p128 (poly128_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_p16 (poly16x8_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_p64 (poly64x2_t __a)
-{
-  return (float16x8_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_f16 (float16x4_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_f64 (float64x1_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_s8 (int8x8_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_s16 (int16x4_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_s32 (int32x2_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_s64 (int64x1_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_u8 (uint8x8_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_u16 (uint16x4_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_u32 (uint32x2_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_u64 (uint64x1_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_p8 (poly8x8_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_p16 (poly16x4_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_p64 (poly64x1_t __a)
-{
-  return (float32x2_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_f16 (float16x8_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_f64 (float64x2_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_s8 (int8x16_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_s16 (int16x8_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_s32 (int32x4_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_s64 (int64x2_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_u8 (uint8x16_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_u16 (uint16x8_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_u32 (uint32x4_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_u64 (uint64x2_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_p8 (poly8x16_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_p16 (poly16x8_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_p64 (poly64x2_t __a)
-{
-  return (float32x4_t) __a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_p128 (poly128_t __a)
-{
-  return (float32x4_t)__a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_f16 (float16x4_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_f32 (float32x2_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_p8 (poly8x8_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_p16 (poly16x4_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_p64 (poly64x1_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_s8 (int8x8_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_s16 (int16x4_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_s32 (int32x2_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_s64 (int64x1_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_u8 (uint8x8_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_u16 (uint16x4_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_u32 (uint32x2_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_u64 (uint64x1_t __a)
-{
-  return (float64x1_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_f16 (float16x8_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_f32 (float32x4_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_p8 (poly8x16_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_p16 (poly16x8_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_p64 (poly64x2_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_s8 (int8x16_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_s16 (int16x8_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_s32 (int32x4_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_s64 (int64x2_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_u8 (uint8x16_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_u16 (uint16x8_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_u32 (uint32x4_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_u64 (uint64x2_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_f16 (float16x4_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_f64 (float64x1_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_s8 (int8x8_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_s16 (int16x4_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_s32 (int32x2_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_f32 (float32x2_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_u8 (uint8x8_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_u16 (uint16x4_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_u32 (uint32x2_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_u64 (uint64x1_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_p8 (poly8x8_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_p16 (poly16x4_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_p64 (poly64x1_t __a)
-{
-  return (int64x1_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_f64 (float64x2_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_s8 (int8x16_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_s16 (int16x8_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_s32 (int32x4_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_f16 (float16x8_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_f32 (float32x4_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_u8 (uint8x16_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_u16 (uint16x8_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_u32 (uint32x4_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_u64 (uint64x2_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_p8 (poly8x16_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_p16 (poly16x8_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_p64 (poly64x2_t __a)
-{
-  return (int64x2_t) __a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_p128 (poly128_t __a)
-{
-  return (int64x2_t)__a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_f16 (float16x4_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_f64 (float64x1_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_s8 (int8x8_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_s16 (int16x4_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_s32 (int32x2_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_s64 (int64x1_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_f32 (float32x2_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_u8 (uint8x8_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_u16 (uint16x4_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_u32 (uint32x2_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_p8 (poly8x8_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_p16 (poly16x4_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_p64 (poly64x1_t __a)
-{
-  return (uint64x1_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_f64 (float64x2_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_s8 (int8x16_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_s16 (int16x8_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_s32 (int32x4_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_s64 (int64x2_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_f16 (float16x8_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_f32 (float32x4_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_u8 (uint8x16_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_u16 (uint16x8_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_u32 (uint32x4_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_p8 (poly8x16_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_p16 (poly16x8_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_p64 (poly64x2_t __a)
-{
-  return (uint64x2_t) __a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_p128 (poly128_t __a)
-{
-  return (uint64x2_t)__a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_f16 (float16x4_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_f64 (float64x1_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_s16 (int16x4_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_s32 (int32x2_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_s64 (int64x1_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_f32 (float32x2_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_u8 (uint8x8_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_u16 (uint16x4_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_u32 (uint32x2_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_u64 (uint64x1_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_p8 (poly8x8_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_p16 (poly16x4_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_p64 (poly64x1_t __a)
-{
-  return (int8x8_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_f64 (float64x2_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_s16 (int16x8_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_s32 (int32x4_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_s64 (int64x2_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_f16 (float16x8_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_f32 (float32x4_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_u8 (uint8x16_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_u16 (uint16x8_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_u32 (uint32x4_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_u64 (uint64x2_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_p8 (poly8x16_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_p16 (poly16x8_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_p64 (poly64x2_t __a)
-{
-  return (int8x16_t) __a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_p128 (poly128_t __a)
-{
-  return (int8x16_t)__a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_f16 (float16x4_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_f64 (float64x1_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_s8 (int8x8_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_s32 (int32x2_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_s64 (int64x1_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_f32 (float32x2_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_u8 (uint8x8_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_u16 (uint16x4_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_u32 (uint32x2_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_u64 (uint64x1_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_p8 (poly8x8_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_p16 (poly16x4_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_p64 (poly64x1_t __a)
-{
-  return (int16x4_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_f64 (float64x2_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_s8 (int8x16_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_s32 (int32x4_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_s64 (int64x2_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_f16 (float16x8_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_f32 (float32x4_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_u8 (uint8x16_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_u16 (uint16x8_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_u32 (uint32x4_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_u64 (uint64x2_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_p8 (poly8x16_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_p16 (poly16x8_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_p64 (poly64x2_t __a)
-{
-  return (int16x8_t) __a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_p128 (poly128_t __a)
-{
-  return (int16x8_t)__a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_f16 (float16x4_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_f64 (float64x1_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_s8 (int8x8_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_s16 (int16x4_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_s64 (int64x1_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_f32 (float32x2_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_u8 (uint8x8_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_u16 (uint16x4_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_u32 (uint32x2_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_u64 (uint64x1_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_p8 (poly8x8_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_p16 (poly16x4_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_p64 (poly64x1_t __a)
-{
-  return (int32x2_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_f64 (float64x2_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_s8 (int8x16_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_s16 (int16x8_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_s64 (int64x2_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_f16 (float16x8_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_f32 (float32x4_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_u8 (uint8x16_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_u16 (uint16x8_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_u32 (uint32x4_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_u64 (uint64x2_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_p8 (poly8x16_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_p16 (poly16x8_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_p64 (poly64x2_t __a)
-{
-  return (int32x4_t) __a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_p128 (poly128_t __a)
-{
-  return (int32x4_t)__a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_f16 (float16x4_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_f64 (float64x1_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_s8 (int8x8_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_s16 (int16x4_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_s32 (int32x2_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_s64 (int64x1_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_f32 (float32x2_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_u16 (uint16x4_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_u32 (uint32x2_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_u64 (uint64x1_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_p8 (poly8x8_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_p16 (poly16x4_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_p64 (poly64x1_t __a)
-{
-  return (uint8x8_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_f64 (float64x2_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_s8 (int8x16_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_s16 (int16x8_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_s32 (int32x4_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_s64 (int64x2_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_f16 (float16x8_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_f32 (float32x4_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_u16 (uint16x8_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_u32 (uint32x4_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_u64 (uint64x2_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_p8 (poly8x16_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_p16 (poly16x8_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_p64 (poly64x2_t __a)
-{
-  return (uint8x16_t) __a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_p128 (poly128_t __a)
-{
-  return (uint8x16_t)__a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_f16 (float16x4_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_f64 (float64x1_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_s8 (int8x8_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_s16 (int16x4_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_s32 (int32x2_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_s64 (int64x1_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_f32 (float32x2_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_u8 (uint8x8_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_u32 (uint32x2_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_u64 (uint64x1_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_p8 (poly8x8_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_p16 (poly16x4_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_p64 (poly64x1_t __a)
-{
-  return (uint16x4_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_f64 (float64x2_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_s8 (int8x16_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_s16 (int16x8_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_s32 (int32x4_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_s64 (int64x2_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_f16 (float16x8_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_f32 (float32x4_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_u8 (uint8x16_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_u32 (uint32x4_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_u64 (uint64x2_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_p8 (poly8x16_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_p16 (poly16x8_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_p64 (poly64x2_t __a)
-{
-  return (uint16x8_t) __a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_p128 (poly128_t __a)
-{
-  return (uint16x8_t)__a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_f16 (float16x4_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_f64 (float64x1_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_s8 (int8x8_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_s16 (int16x4_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_s32 (int32x2_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_s64 (int64x1_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_f32 (float32x2_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_u8 (uint8x8_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_u16 (uint16x4_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_u64 (uint64x1_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_p8 (poly8x8_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_p16 (poly16x4_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_p64 (poly64x1_t __a)
-{
-  return (uint32x2_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_f64 (float64x2_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_s8 (int8x16_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_s16 (int16x8_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_s32 (int32x4_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_s64 (int64x2_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_f16 (float16x8_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_f32 (float32x4_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_u8 (uint8x16_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_u16 (uint16x8_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_u64 (uint64x2_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_p8 (poly8x16_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_p16 (poly16x8_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_p64 (poly64x2_t __a)
-{
-  return (uint32x4_t) __a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_p128 (poly128_t __a)
-{
-  return (uint32x4_t)__a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_p128 (poly128_t __a)
-{
-  return (float64x2_t) __a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_f64 (float64x2_t __a)
-{
-  return (poly128_t) __a;
-}
 __extension__ extern __inline float16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vset_lane_f16 (float16_t __elem, float16x4_t __vec, const int __index)
@@ -6332,37 +3980,37 @@ __extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_n_s16 (int16x8_t __a, const int __b)
 {
-  return __builtin_aarch64_shrnv8hi (__a, __b);
+  return __builtin_aarch64_shrn_nv8hi (__a, __b);
 }
 __extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_n_s32 (int32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_shrnv4si (__a, __b);
+  return __builtin_aarch64_shrn_nv4si (__a, __b);
 }
 __extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_n_s64 (int64x2_t __a, const int __b)
 {
-  return __builtin_aarch64_shrnv2di (__a, __b);
+  return __builtin_aarch64_shrn_nv2di (__a, __b);
 }
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_n_u16 (uint16x8_t __a, const int __b)
 {
-  return __builtin_aarch64_shrnv8hi_uus (__a, __b);
+  return __builtin_aarch64_shrn_nv8hi_uus (__a, __b);
 }
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_n_u32 (uint32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_shrnv4si_uus (__a, __b);
+  return __builtin_aarch64_shrn_nv4si_uus (__a, __b);
 }
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_n_u64 (uint64x2_t __a, const int __b)
 {
-  return __builtin_aarch64_shrnv2di_uus (__a, __b);
+  return __builtin_aarch64_shrn_nv2di_uus (__a, __b);
 }
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
@@ -6944,37 +4592,37 @@ __extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vqshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_sqshrn2_nv8hi (__a, __b, __c);
+  return __builtin_aarch64_sqsshrn2_nv8hi (__a, __b, __c);
 }
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vqshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_sqshrn2_nv4si (__a, __b, __c);
+  return __builtin_aarch64_sqsshrn2_nv4si (__a, __b, __c);
 }
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vqshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_sqshrn2_nv2di (__a, __b, __c);
+  return __builtin_aarch64_sqsshrn2_nv2di (__a, __b, __c);
 }
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vqshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_uqshrn2_nv8hi_uuus (__a, __b, __c);
+  return __builtin_aarch64_uqushrn2_nv8hi_uuus (__a, __b, __c);
 }
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vqshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_uqshrn2_nv4si_uuus (__a, __b, __c);
+  return __builtin_aarch64_uqushrn2_nv4si_uuus (__a, __b, __c);
 }
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vqshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_uqshrn2_nv2di_uuus (__a, __b, __c);
+  return __builtin_aarch64_uqushrn2_nv2di_uuus (__a, __b, __c);
 }
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
@@ -6998,73 +4646,73 @@ __extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_rshrn2v8hi (__a, __b, __c);
+  return __builtin_aarch64_rshrn2_nv8hi (__a, __b, __c);
 }
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_rshrn2v4si (__a, __b, __c);
+  return __builtin_aarch64_rshrn2_nv4si (__a, __b, __c);
 }
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_rshrn2v2di (__a, __b, __c);
+  return __builtin_aarch64_rshrn2_nv2di (__a, __b, __c);
 }
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_rshrn2v8hi_uuus (__a, __b, __c);
+  return __builtin_aarch64_rshrn2_nv8hi_uuus (__a, __b, __c);
 }
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_rshrn2v4si_uuus (__a, __b, __c);
+  return __builtin_aarch64_rshrn2_nv4si_uuus (__a, __b, __c);
 }
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_rshrn2v2di_uuus (__a, __b, __c);
+  return __builtin_aarch64_rshrn2_nv2di_uuus (__a, __b, __c);
 }
 __extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_n_s16 (int16x8_t __a, const int __b)
 {
-  return __builtin_aarch64_rshrnv8hi (__a, __b);
+  return __builtin_aarch64_rshrn_nv8hi (__a, __b);
 }
 __extension__ extern __inline int16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_n_s32 (int32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_rshrnv4si (__a, __b);
+  return __builtin_aarch64_rshrn_nv4si (__a, __b);
 }
 __extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_n_s64 (int64x2_t __a, const int __b)
 {
-  return __builtin_aarch64_rshrnv2di (__a, __b);
+  return __builtin_aarch64_rshrn_nv2di (__a, __b);
 }
 __extension__ extern __inline uint8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_n_u16 (uint16x8_t __a, const int __b)
 {
-  return __builtin_aarch64_rshrnv8hi_uus (__a, __b);
+  return __builtin_aarch64_rshrn_nv8hi_uus (__a, __b);
 }
 __extension__ extern __inline uint16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_n_u32 (uint32x4_t __a, const int __b)
 {
-  return __builtin_aarch64_rshrnv4si_uus (__a, __b);
+  return __builtin_aarch64_rshrn_nv4si_uus (__a, __b);
 }
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vrshrn_n_u64 (uint64x2_t __a, const int __b)
 {
-  return __builtin_aarch64_rshrnv2di_uus (__a, __b);
+  return __builtin_aarch64_rshrn_nv2di_uus (__a, __b);
 }
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
@@ -7082,37 +4730,37 @@ __extension__ extern __inline int8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_high_n_s16 (int8x8_t __a, int16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_shrn2v8hi (__a, __b, __c);
+  return __builtin_aarch64_ushrn2_nv8hi (__a, __b, __c);
 }
 __extension__ extern __inline int16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_high_n_s32 (int16x4_t __a, int32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_shrn2v4si (__a, __b, __c);
+  return __builtin_aarch64_ushrn2_nv4si (__a, __b, __c);
 }
 __extension__ extern __inline int32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_high_n_s64 (int32x2_t __a, int64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_shrn2v2di (__a, __b, __c);
+  return __builtin_aarch64_ushrn2_nv2di (__a, __b, __c);
 }
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_high_n_u16 (uint8x8_t __a, uint16x8_t __b, const int __c)
 {
-  return __builtin_aarch64_shrn2v8hi_uuus (__a, __b, __c);
+  return __builtin_aarch64_ushrn2_nv8hi_uuus (__a, __b, __c);
 }
 __extension__ extern __inline uint16x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_high_n_u32 (uint16x4_t __a, uint32x4_t __b, const int __c)
 {
-  return __builtin_aarch64_shrn2v4si_uuus (__a, __b, __c);
+  return __builtin_aarch64_ushrn2_nv4si_uuus (__a, __b, __c);
 }
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vshrn_high_n_u64 (uint32x2_t __a, uint64x2_t __b, const int __c)
 {
-  return __builtin_aarch64_shrn2v2di_uuus (__a, __b, __c);
+  return __builtin_aarch64_ushrn2_nv2di_uuus (__a, __b, __c);
 }
 __extension__ extern __inline poly8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
@@ -8679,7 +6327,7 @@ vqrdmlshs_laneq_s32 (int32_t __a, int32_t __b, int32x4_t __c, const int __d)
 }
 #pragma GCC pop_options
 #pragma GCC push_options
-#pragma GCC target ("+nothing+crypto")
+#pragma GCC target ("+nothing+aes")
 __extension__ extern __inline uint8x16_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vaeseq_u8 (uint8x16_t data, uint8x16_t key)
@@ -8704,150 +6352,163 @@ vaesimcq_u8 (uint8x16_t data)
 {
   return __builtin_aarch64_crypto_aesimcv16qi_uu (data);
 }
+__extension__ extern __inline poly128_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmull_p64 (poly64_t __a, poly64_t __b)
+{
+  return
+    __builtin_aarch64_crypto_pmulldi_ppp (__a, __b);
+}
+__extension__ extern __inline poly128_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vmull_high_p64 (poly64x2_t __a, poly64x2_t __b)
+{
+  return __builtin_aarch64_crypto_pmullv2di_ppp (__a, __b);
+}
 #pragma GCC pop_options
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcage_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return vabs_f64 (__a) >= vabs_f64 (__b);
+  return vcreate_u64 (__builtin_aarch64_facgedf_uss (__a[0], __b[0]));
 }
 __extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcages_f32 (float32_t __a, float32_t __b)
 {
-  return __builtin_fabsf (__a) >= __builtin_fabsf (__b) ? -1 : 0;
+  return __builtin_aarch64_facgesf_uss (__a, __b);
 }
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcage_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return vabs_f32 (__a) >= vabs_f32 (__b);
+  return __builtin_aarch64_facgev2sf_uss (__a, __b);
 }
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcageq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return vabsq_f32 (__a) >= vabsq_f32 (__b);
+  return __builtin_aarch64_facgev4sf_uss (__a, __b);
 }
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcaged_f64 (float64_t __a, float64_t __b)
 {
-  return __builtin_fabs (__a) >= __builtin_fabs (__b) ? -1 : 0;
+  return __builtin_aarch64_facgedf_uss (__a, __b);
 }
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcageq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return vabsq_f64 (__a) >= vabsq_f64 (__b);
+  return __builtin_aarch64_facgev2df_uss (__a, __b);
 }
 __extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcagts_f32 (float32_t __a, float32_t __b)
 {
-  return __builtin_fabsf (__a) > __builtin_fabsf (__b) ? -1 : 0;
+  return __builtin_aarch64_facgtsf_uss (__a, __b);
 }
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcagt_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return vabs_f32 (__a) > vabs_f32 (__b);
+  return __builtin_aarch64_facgtv2sf_uss (__a, __b);
 }
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcagt_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return vabs_f64 (__a) > vabs_f64 (__b);
+  return vcreate_u64 (__builtin_aarch64_facgtdf_uss (__a[0], __b[0]));
 }
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcagtq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return vabsq_f32 (__a) > vabsq_f32 (__b);
+  return __builtin_aarch64_facgtv4sf_uss (__a, __b);
 }
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcagtd_f64 (float64_t __a, float64_t __b)
 {
-  return __builtin_fabs (__a) > __builtin_fabs (__b) ? -1 : 0;
+  return __builtin_aarch64_facgtdf_uss (__a, __b);
 }
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcagtq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return vabsq_f64 (__a) > vabsq_f64 (__b);
+  return __builtin_aarch64_facgtv2df_uss (__a, __b);
 }
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcale_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return vabs_f32 (__a) <= vabs_f32 (__b);
+  return __builtin_aarch64_faclev2sf_uss (__a, __b);
 }
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcale_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return vabs_f64 (__a) <= vabs_f64 (__b);
+  return vcreate_u64 (__builtin_aarch64_facledf_uss (__a[0], __b[0]));
 }
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcaled_f64 (float64_t __a, float64_t __b)
 {
-  return __builtin_fabs (__a) <= __builtin_fabs (__b) ? -1 : 0;
+  return __builtin_aarch64_facledf_uss (__a, __b);
 }
 __extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcales_f32 (float32_t __a, float32_t __b)
 {
-  return __builtin_fabsf (__a) <= __builtin_fabsf (__b) ? -1 : 0;
+  return __builtin_aarch64_faclesf_uss (__a, __b);
 }
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcaleq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return vabsq_f32 (__a) <= vabsq_f32 (__b);
+  return __builtin_aarch64_faclev4sf_uss (__a, __b);
 }
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcaleq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return vabsq_f64 (__a) <= vabsq_f64 (__b);
+  return __builtin_aarch64_faclev2df_uss (__a, __b);
 }
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcalt_f32 (float32x2_t __a, float32x2_t __b)
 {
-  return vabs_f32 (__a) < vabs_f32 (__b);
+  return __builtin_aarch64_facltv2sf_uss (__a, __b);
 }
 __extension__ extern __inline uint64x1_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcalt_f64 (float64x1_t __a, float64x1_t __b)
 {
-  return vabs_f64 (__a) < vabs_f64 (__b);
+  return vcreate_u64 (__builtin_aarch64_facltdf_uss (__a[0], __b[0]));
 }
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcaltd_f64 (float64_t __a, float64_t __b)
 {
-  return __builtin_fabs (__a) < __builtin_fabs (__b) ? -1 : 0;
+  return __builtin_aarch64_facltdf_uss (__a, __b);
 }
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcaltq_f32 (float32x4_t __a, float32x4_t __b)
 {
-  return vabsq_f32 (__a) < vabsq_f32 (__b);
+  return __builtin_aarch64_facltv4sf_uss (__a, __b);
 }
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcaltq_f64 (float64x2_t __a, float64x2_t __b)
 {
-  return vabsq_f64 (__a) < vabsq_f64 (__b);
+  return __builtin_aarch64_facltv2df_uss (__a, __b);
 }
 __extension__ extern __inline uint32_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vcalts_f32 (float32_t __a, float32_t __b)
 {
-  return __builtin_fabsf (__a) < __builtin_fabsf (__b) ? -1 : 0;
+  return __builtin_aarch64_facltsf_uss (__a, __b);
 }
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
@@ -13691,6 +11352,121 @@ vld1q_lane_u64 (const uint64_t *__src, uint64x2_t __vec, const int __lane)
 {
   return __aarch64_vset_lane_any (*__src, __vec, __lane);
 }
+#pragma GCC push_options
+#pragma GCC target ("+nothing+rcpc3+simd")
+__extension__ extern __inline uint64x1_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vldap1_lane_u64 (const uint64_t *__src, uint64x1_t __vec, const int __lane)
+{
+  return __builtin_aarch64_vec_ldap1_lanev1di_usus (
+   (const __builtin_aarch64_simd_di *) __src, __vec, __lane);
+}
+__extension__ extern __inline uint64x2_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vldap1q_lane_u64 (const uint64_t *__src, uint64x2_t __vec, const int __lane)
+{
+  return __builtin_aarch64_vec_ldap1_lanev2di_usus (
+   (const __builtin_aarch64_simd_di *) __src, __vec, __lane);
+}
+__extension__ extern __inline int64x1_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vldap1_lane_s64 (const int64_t *__src, int64x1_t __vec, const int __lane)
+{
+  return __builtin_aarch64_vec_ldap1_lanev1di (
+   (const __builtin_aarch64_simd_di *) __src, __vec, __lane);
+}
+__extension__ extern __inline int64x2_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vldap1q_lane_s64 (const int64_t *__src, int64x2_t __vec, const int __lane)
+{
+  return __builtin_aarch64_vec_ldap1_lanev2di (
+   (const __builtin_aarch64_simd_di *) __src, __vec, __lane);
+}
+__extension__ extern __inline float64x1_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vldap1_lane_f64 (const float64_t *__src, float64x1_t __vec, const int __lane)
+{
+  return __builtin_aarch64_vec_ldap1_lanev1df (
+   (const __builtin_aarch64_simd_df *) __src, __vec, __lane);
+}
+__extension__ extern __inline float64x2_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vldap1q_lane_f64 (const float64_t *__src, float64x2_t __vec, const int __lane)
+{
+  return __builtin_aarch64_vec_ldap1_lanev2df (
+   (const __builtin_aarch64_simd_df *) __src, __vec, __lane);
+}
+__extension__ extern __inline poly64x1_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vldap1_lane_p64 (const poly64_t *__src, poly64x1_t __vec, const int __lane)
+{
+  return __builtin_aarch64_vec_ldap1_lanev1di_psps (
+   (const __builtin_aarch64_simd_di *) __src, __vec, __lane);
+}
+__extension__ extern __inline poly64x2_t
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vldap1q_lane_p64 (const poly64_t *__src, poly64x2_t __vec, const int __lane)
+{
+  return __builtin_aarch64_vec_ldap1_lanev2di_psps (
+   (const __builtin_aarch64_simd_di *) __src, __vec, __lane);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vstl1_lane_u64 (uint64_t *__src, uint64x1_t __vec, const int __lane)
+{
+  __builtin_aarch64_vec_stl1_lanev1di_sus ((__builtin_aarch64_simd_di *) __src,
+        __vec, __lane);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vstl1q_lane_u64 (uint64_t *__src, uint64x2_t __vec, const int __lane)
+{
+  __builtin_aarch64_vec_stl1_lanev2di_sus ((__builtin_aarch64_simd_di *) __src,
+        __vec, __lane);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vstl1_lane_s64 (int64_t *__src, int64x1_t __vec, const int __lane)
+{
+  __builtin_aarch64_vec_stl1_lanev1di ((__builtin_aarch64_simd_di *) __src,
+           __vec, __lane);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vstl1q_lane_s64 (int64_t *__src, int64x2_t __vec, const int __lane)
+{
+  __builtin_aarch64_vec_stl1_lanev2di ((__builtin_aarch64_simd_di *) __src,
+           __vec, __lane);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vstl1_lane_f64 (float64_t *__src, float64x1_t __vec, const int __lane)
+{
+  __builtin_aarch64_vec_stl1_lanev1df ((__builtin_aarch64_simd_df *) __src,
+           __vec, __lane);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vstl1q_lane_f64 (float64_t *__src, float64x2_t __vec, const int __lane)
+{
+  __builtin_aarch64_vec_stl1_lanev2df ((__builtin_aarch64_simd_df *) __src,
+           __vec, __lane);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vstl1_lane_p64 (poly64_t *__src, poly64x1_t __vec, const int __lane)
+{
+  __builtin_aarch64_vec_stl1_lanev1di_sps ((__builtin_aarch64_simd_di *) __src,
+        __vec, __lane);
+}
+__extension__ extern __inline void
+__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
+vstl1q_lane_p64 (poly64_t *__src, poly64x2_t __vec, const int __lane)
+{
+  __builtin_aarch64_vec_stl1_lanev2di_sps ((__builtin_aarch64_simd_di *) __src,
+        __vec, __lane);
+}
+#pragma GCC pop_options
 __extension__ extern __inline int64x1x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vld2_s64 (const int64_t * __a)
@@ -17192,13 +14968,13 @@ __extension__ extern __inline int64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vpaddd_s64 (int64x2_t __a)
 {
-  return __builtin_aarch64_addpdi (__a);
+  return __builtin_aarch64_reduc_plus_scal_v2di (__a);
 }
 __extension__ extern __inline uint64_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vpaddd_u64 (uint64x2_t __a)
 {
-  return __builtin_aarch64_addpdi_uu (__a);
+  return __builtin_aarch64_reduc_plus_scal_v2di_uu (__a);
 }
 __extension__ extern __inline int64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
@@ -19866,7 +17642,7 @@ vrsrad_n_u64 (uint64_t __a, uint64_t __b, const int __c)
   return __builtin_aarch64_ursra_ndi_uuus (__a, __b, __c);
 }
 #pragma GCC push_options
-#pragma GCC target ("+nothing+crypto")
+#pragma GCC target ("+nothing+sha2")
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vsha1cq_u32 (uint32x4_t __hash_abcd, uint32_t __hash_e, uint32x4_t __wk)
@@ -19930,19 +17706,6 @@ vsha256su1q_u32 (uint32x4_t __tw0_3, uint32x4_t __w8_11, uint32x4_t __w12_15)
   return __builtin_aarch64_crypto_sha256su1v4si_uuuu (__tw0_3, __w8_11,
              __w12_15);
 }
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_p64 (poly64_t __a, poly64_t __b)
-{
-  return
-    __builtin_aarch64_crypto_pmulldi_ppp (__a, __b);
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vmull_high_p64 (poly64x2_t __a, poly64x2_t __b)
-{
-  return __builtin_aarch64_crypto_pmullv2di_ppp (__a, __b);
-}
 #pragma GCC pop_options
 __extension__ extern __inline int8x8_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
@@ -24007,7 +21770,7 @@ __INTERLEAVE_LIST (zip)
 #pragma GCC pop_options
 #include "third_party/aarch64/arm_fp16.internal.h"
 #pragma GCC push_options
-#pragma GCC target ("arch=armv8.2-a+fp16")
+#pragma GCC target ("+nothing+simd+fp16")
 __extension__ extern __inline float16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vabs_f16 (float16x4_t __a)
@@ -24994,7 +22757,7 @@ vminnmvq_f16 (float16x8_t __a)
 }
 #pragma GCC pop_options
 #pragma GCC push_options
-#pragma GCC target ("arch=armv8.2-a+dotprod")
+#pragma GCC target ("+nothing+dotprod")
 __extension__ extern __inline uint32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vdot_u32 (uint32x2_t __r, uint8x8_t __a, uint8x8_t __b)
@@ -25072,7 +22835,7 @@ vdotq_laneq_s32 (int32x4_t __r, int8x16_t __a, int8x16_t __b, const int __index)
 }
 #pragma GCC pop_options
 #pragma GCC push_options
-#pragma GCC target ("arch=armv8.2-a+sm4")
+#pragma GCC target ("+nothing+sm4")
 __extension__ extern __inline uint32x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vsm3ss1q_u32 (uint32x4_t __a, uint32x4_t __b, uint32x4_t __c)
@@ -25129,7 +22892,7 @@ vsm4ekeyq_u32 (uint32x4_t __a, uint32x4_t __b)
 }
 #pragma GCC pop_options
 #pragma GCC push_options
-#pragma GCC target ("arch=armv8.2-a+sha3")
+#pragma GCC target ("+nothing+sha3")
 __extension__ extern __inline uint64x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vsha512hq_u64 (uint64x2_t __a, uint64x2_t __b, uint64x2_t __c)
@@ -25674,7 +23437,7 @@ vcmlaq_rot270_laneq_f32 (float32x4_t __r, float32x4_t __a, float32x4_t __b,
 }
 #pragma GCC pop_options
 #pragma GCC push_options
-#pragma GCC target ("arch=armv8.2-a+fp16fml")
+#pragma GCC target ("+nothing+fp16fml")
 __extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vfmlal_low_f16 (float32x2_t __r, float16x4_t __a, float16x4_t __b)
@@ -25938,7 +23701,7 @@ vrnd64xq_f64 (float64x2_t __a)
 #pragma GCC pop_options
 #include "third_party/aarch64/arm_bf16.internal.h"
 #pragma GCC push_options
-#pragma GCC target ("arch=armv8.2-a+bf16")
+#pragma GCC target ("+nothing+bf16")
 __extension__ extern __inline bfloat16x4_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vset_lane_bf16 (bfloat16_t __elem, bfloat16x4_t __vec, const int __index)
@@ -26264,354 +24027,6 @@ vst4q_bf16 (bfloat16_t * __a, bfloat16x8x4_t __val)
 {
   __builtin_aarch64_st4v8bf ((__builtin_aarch64_simd_bf *) __a, __val);
 }
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_u8 (uint8x8_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_u16 (uint16x4_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_u32 (uint32x2_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_u64 (uint64x1_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_s8 (int8x8_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_s16 (int16x4_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_s32 (int32x2_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_s64 (int64x1_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_p8 (poly8x8_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_p16 (poly16x4_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_p64 (poly64x1_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_f16 (float16x4_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_f32 (float32x2_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_bf16_f64 (float64x1_t __a)
-{
-  return (bfloat16x4_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_u8 (uint8x16_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_u16 (uint16x8_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_u32 (uint32x4_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_u64 (uint64x2_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_s8 (int8x16_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_s16 (int16x8_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_s32 (int32x4_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_s64 (int64x2_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_p8 (poly8x16_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_p16 (poly16x8_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_p64 (poly64x2_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_p128 (poly128_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_f16 (float16x8_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_f32 (float32x4_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline bfloat16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_bf16_f64 (float64x2_t __a)
-{
-  return (bfloat16x8_t)__a;
-}
-__extension__ extern __inline int8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s8_bf16 (bfloat16x4_t __a)
-{
-  return (int8x8_t)__a;
-}
-__extension__ extern __inline int16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s16_bf16 (bfloat16x4_t __a)
-{
-  return (int16x4_t)__a;
-}
-__extension__ extern __inline int32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s32_bf16 (bfloat16x4_t __a)
-{
-  return (int32x2_t)__a;
-}
-__extension__ extern __inline int64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_s64_bf16 (bfloat16x4_t __a)
-{
-  return (int64x1_t)__a;
-}
-__extension__ extern __inline uint8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u8_bf16 (bfloat16x4_t __a)
-{
-  return (uint8x8_t)__a;
-}
-__extension__ extern __inline uint16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u16_bf16 (bfloat16x4_t __a)
-{
-  return (uint16x4_t)__a;
-}
-__extension__ extern __inline uint32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u32_bf16 (bfloat16x4_t __a)
-{
-  return (uint32x2_t)__a;
-}
-__extension__ extern __inline uint64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_u64_bf16 (bfloat16x4_t __a)
-{
-  return (uint64x1_t)__a;
-}
-__extension__ extern __inline float16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f16_bf16 (bfloat16x4_t __a)
-{
-  return (float16x4_t)__a;
-}
-__extension__ extern __inline float32x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f32_bf16 (bfloat16x4_t __a)
-{
-  return (float32x2_t)__a;
-}
-__extension__ extern __inline float64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_f64_bf16 (bfloat16x4_t __a)
-{
-  return (float64x1_t)__a;
-}
-__extension__ extern __inline poly8x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p8_bf16 (bfloat16x4_t __a)
-{
-  return (poly8x8_t)__a;
-}
-__extension__ extern __inline poly16x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p16_bf16 (bfloat16x4_t __a)
-{
-  return (poly16x4_t)__a;
-}
-__extension__ extern __inline poly64x1_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpret_p64_bf16 (bfloat16x4_t __a)
-{
-  return (poly64x1_t)__a;
-}
-__extension__ extern __inline int8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s8_bf16 (bfloat16x8_t __a)
-{
-  return (int8x16_t)__a;
-}
-__extension__ extern __inline int16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s16_bf16 (bfloat16x8_t __a)
-{
-  return (int16x8_t)__a;
-}
-__extension__ extern __inline int32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s32_bf16 (bfloat16x8_t __a)
-{
-  return (int32x4_t)__a;
-}
-__extension__ extern __inline int64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_s64_bf16 (bfloat16x8_t __a)
-{
-  return (int64x2_t)__a;
-}
-__extension__ extern __inline uint8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u8_bf16 (bfloat16x8_t __a)
-{
-  return (uint8x16_t)__a;
-}
-__extension__ extern __inline uint16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u16_bf16 (bfloat16x8_t __a)
-{
-  return (uint16x8_t)__a;
-}
-__extension__ extern __inline uint32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u32_bf16 (bfloat16x8_t __a)
-{
-  return (uint32x4_t)__a;
-}
-__extension__ extern __inline uint64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_u64_bf16 (bfloat16x8_t __a)
-{
-  return (uint64x2_t)__a;
-}
-__extension__ extern __inline float16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f16_bf16 (bfloat16x8_t __a)
-{
-  return (float16x8_t)__a;
-}
-__extension__ extern __inline float32x4_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f32_bf16 (bfloat16x8_t __a)
-{
-  return (float32x4_t)__a;
-}
-__extension__ extern __inline float64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_f64_bf16 (bfloat16x8_t __a)
-{
-  return (float64x2_t)__a;
-}
-__extension__ extern __inline poly8x16_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p8_bf16 (bfloat16x8_t __a)
-{
-  return (poly8x16_t)__a;
-}
-__extension__ extern __inline poly16x8_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p16_bf16 (bfloat16x8_t __a)
-{
-  return (poly16x8_t)__a;
-}
-__extension__ extern __inline poly64x2_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p64_bf16 (bfloat16x8_t __a)
-{
-  return (poly64x2_t)__a;
-}
-__extension__ extern __inline poly128_t
-__attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
-vreinterpretq_p128_bf16 (bfloat16x8_t __a)
-{
-  return (poly128_t)__a;
-}
 __extension__ extern __inline float32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vbfdot_f32 (float32x2_t __r, bfloat16x4_t __a, bfloat16x4_t __b)
@@ -26864,7 +24279,7 @@ vst4q_lane_bf16 (bfloat16_t *__ptr, bfloat16x8x4_t __val, const int __lane)
 }
 #pragma GCC pop_options
 #pragma GCC push_options
-#pragma GCC target ("arch=armv8.2-a+i8mm")
+#pragma GCC target ("+nothing+i8mm")
 __extension__ extern __inline int32x2_t
 __attribute__ ((__always_inline__, __gnu_inline__, __artificial__))
 vusdot_s32 (int32x2_t __r, uint8x8_t __a, int8x8_t __b)
diff --git a/third_party/aarch64/clang/arm64intr.h b/third_party/aarch64/clang/arm64intr.h
new file mode 100644
index 000000000..4943b2db6
--- /dev/null
+++ b/third_party/aarch64/clang/arm64intr.h
@@ -0,0 +1,35 @@
+/*===---- arm64intr.h - ARM64 Windows intrinsics -------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+/* Only include this if we're compiling for the windows platform. */
+#ifndef _MSC_VER
+#include_next <arm64intr.h>
+#else
+
+#ifndef __ARM64INTR_H
+#define __ARM64INTR_H
+
+typedef enum
+{
+  _ARM64_BARRIER_SY    = 0xF,
+  _ARM64_BARRIER_ST    = 0xE,
+  _ARM64_BARRIER_LD    = 0xD,
+  _ARM64_BARRIER_ISH   = 0xB,
+  _ARM64_BARRIER_ISHST = 0xA,
+  _ARM64_BARRIER_ISHLD = 0x9,
+  _ARM64_BARRIER_NSH   = 0x7,
+  _ARM64_BARRIER_NSHST = 0x6,
+  _ARM64_BARRIER_NSHLD = 0x5,
+  _ARM64_BARRIER_OSH   = 0x3,
+  _ARM64_BARRIER_OSHST = 0x2,
+  _ARM64_BARRIER_OSHLD = 0x1
+} _ARM64INTR_BARRIER_TYPE;
+
+#endif /* __ARM64INTR_H */
+#endif /* _MSC_VER */
diff --git a/third_party/aarch64/clang/arm_acle.h b/third_party/aarch64/clang/arm_acle.h
new file mode 100644
index 000000000..1518b0c4c
--- /dev/null
+++ b/third_party/aarch64/clang/arm_acle.h
@@ -0,0 +1,888 @@
+/*===---- arm_acle.h - ARM Non-Neon intrinsics -----------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ * The Arm C Language Extensions specifications can be found in the following
+ * link: https://github.com/ARM-software/acle/releases
+ *
+ * The ACLE section numbers are subject to change. When consulting the
+ * specifications, it is recommended to search using section titles if
+ * the section numbers look outdated.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ARM_ACLE_H
+#define __ARM_ACLE_H
+
+#ifndef __ARM_ACLE
+#error "ACLE intrinsics support not enabled."
+#endif
+
+#include <stdint.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* 7 SYNCHRONIZATION, BARRIER AND HINT INTRINSICS */
+/* 7.3 Memory barriers */
+#if !__has_builtin(__dmb)
+#define __dmb(i) __builtin_arm_dmb(i)
+#endif
+#if !__has_builtin(__dsb)
+#define __dsb(i) __builtin_arm_dsb(i)
+#endif
+#if !__has_builtin(__isb)
+#define __isb(i) __builtin_arm_isb(i)
+#endif
+
+/* 7.4 Hints */
+
+#if !__has_builtin(__wfi)
+static __inline__ void __attribute__((__always_inline__, __nodebug__)) __wfi(void) {
+  __builtin_arm_wfi();
+}
+#endif
+
+#if !__has_builtin(__wfe)
+static __inline__ void __attribute__((__always_inline__, __nodebug__)) __wfe(void) {
+  __builtin_arm_wfe();
+}
+#endif
+
+#if !__has_builtin(__sev)
+static __inline__ void __attribute__((__always_inline__, __nodebug__)) __sev(void) {
+  __builtin_arm_sev();
+}
+#endif
+
+#if !__has_builtin(__sevl)
+static __inline__ void __attribute__((__always_inline__, __nodebug__)) __sevl(void) {
+  __builtin_arm_sevl();
+}
+#endif
+
+#if !__has_builtin(__yield)
+static __inline__ void __attribute__((__always_inline__, __nodebug__)) __yield(void) {
+  __builtin_arm_yield();
+}
+#endif
+
+#if defined(__ARM_32BIT_STATE) && __ARM_32BIT_STATE
+#define __dbg(t) __builtin_arm_dbg(t)
+#endif
+
+#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
+#define _CHKFEAT_GCS 1
+static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
+__chkfeat(uint64_t __features) {
+  return __builtin_arm_chkfeat(__features) ^ __features;
+}
+#endif
+
+/* 7.5 Swap */
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
+__swp(uint32_t __x, volatile uint32_t *__p) {
+  uint32_t v;
+  do
+    v = __builtin_arm_ldrex(__p);
+  while (__builtin_arm_strex(__x, __p));
+  return v;
+}
+
+/* 7.6 Memory prefetch intrinsics */
+/* 7.6.1 Data prefetch */
+#define __pld(addr) __pldx(0, 0, 0, addr)
+
+#if defined(__ARM_32BIT_STATE) && __ARM_32BIT_STATE
+#define __pldx(access_kind, cache_level, retention_policy, addr) \
+  __builtin_arm_prefetch(addr, access_kind, 1)
+#else
+#define __pldx(access_kind, cache_level, retention_policy, addr) \
+  __builtin_arm_prefetch(addr, access_kind, cache_level, retention_policy, 1)
+#endif
+
+/* 7.6.2 Instruction prefetch */
+#define __pli(addr) __plix(0, 0, addr)
+
+#if defined(__ARM_32BIT_STATE) && __ARM_32BIT_STATE
+#define __plix(cache_level, retention_policy, addr) \
+  __builtin_arm_prefetch(addr, 0, 0)
+#else
+#define __plix(cache_level, retention_policy, addr) \
+  __builtin_arm_prefetch(addr, 0, cache_level, retention_policy, 0)
+#endif
+
+/* 7.7 NOP */
+#if !defined(_MSC_VER) || (!defined(__aarch64__) && !defined(__arm64ec__))
+static __inline__ void __attribute__((__always_inline__, __nodebug__)) __nop(void) {
+  __builtin_arm_nop();
+}
+#endif
+
+/* 8 DATA-PROCESSING INTRINSICS */
+/* 8.2 Miscellaneous data-processing intrinsics */
+/* ROR */
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
+__ror(uint32_t __x, uint32_t __y) {
+  __y %= 32;
+  if (__y == 0)
+    return __x;
+  return (__x >> __y) | (__x << (32 - __y));
+}
+
+static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
+__rorll(uint64_t __x, uint32_t __y) {
+  __y %= 64;
+  if (__y == 0)
+    return __x;
+  return (__x >> __y) | (__x << (64 - __y));
+}
+
+static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
+__rorl(unsigned long __x, uint32_t __y) {
+#if __SIZEOF_LONG__ == 4
+  return __ror(__x, __y);
+#else
+  return __rorll(__x, __y);
+#endif
+}
+
+
+/* CLZ */
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
+__clz(uint32_t __t) {
+  return __builtin_arm_clz(__t);
+}
+
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
+__clzl(unsigned long __t) {
+#if __SIZEOF_LONG__ == 4
+  return __builtin_arm_clz(__t);
+#else
+  return __builtin_arm_clz64(__t);
+#endif
+}
+
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
+__clzll(uint64_t __t) {
+  return __builtin_arm_clz64(__t);
+}
+
+/* CLS */
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
+__cls(uint32_t __t) {
+  return __builtin_arm_cls(__t);
+}
+
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
+__clsl(unsigned long __t) {
+#if __SIZEOF_LONG__ == 4
+  return __builtin_arm_cls(__t);
+#else
+  return __builtin_arm_cls64(__t);
+#endif
+}
+
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__))
+__clsll(uint64_t __t) {
+  return __builtin_arm_cls64(__t);
+}
+
+/* REV */
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
+__rev(uint32_t __t) {
+  return __builtin_bswap32(__t);
+}
+
+static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
+__revl(unsigned long __t) {
+#if __SIZEOF_LONG__ == 4
+  return __builtin_bswap32(__t);
+#else
+  return __builtin_bswap64(__t);
+#endif
+}
+
+static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
+__revll(uint64_t __t) {
+  return __builtin_bswap64(__t);
+}
+
+/* REV16 */
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
+__rev16(uint32_t __t) {
+  return __ror(__rev(__t), 16);
+}
+
+static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
+__rev16ll(uint64_t __t) {
+  return (((uint64_t)__rev16(__t >> 32)) << 32) | (uint64_t)__rev16((uint32_t)__t);
+}
+
+static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
+__rev16l(unsigned long __t) {
+#if __SIZEOF_LONG__ == 4
+    return __rev16(__t);
+#else
+    return __rev16ll(__t);
+#endif
+}
+
+/* REVSH */
+static __inline__ int16_t __attribute__((__always_inline__, __nodebug__))
+__revsh(int16_t __t) {
+  return (int16_t)__builtin_bswap16((uint16_t)__t);
+}
+
+/* RBIT */
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
+__rbit(uint32_t __t) {
+  return __builtin_arm_rbit(__t);
+}
+
+static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__))
+__rbitll(uint64_t __t) {
+#if defined(__ARM_32BIT_STATE) && __ARM_32BIT_STATE
+  return (((uint64_t)__builtin_arm_rbit(__t)) << 32) |
+         __builtin_arm_rbit(__t >> 32);
+#else
+  return __builtin_arm_rbit64(__t);
+#endif
+}
+
+static __inline__ unsigned long __attribute__((__always_inline__, __nodebug__))
+__rbitl(unsigned long __t) {
+#if __SIZEOF_LONG__ == 4
+  return __rbit(__t);
+#else
+  return __rbitll(__t);
+#endif
+}
+
+/* 8.3 16-bit multiplications */
+#if defined(__ARM_FEATURE_DSP) && __ARM_FEATURE_DSP
+static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
+__smulbb(int32_t __a, int32_t __b) {
+  return __builtin_arm_smulbb(__a, __b);
+}
+static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
+__smulbt(int32_t __a, int32_t __b) {
+  return __builtin_arm_smulbt(__a, __b);
+}
+static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
+__smultb(int32_t __a, int32_t __b) {
+  return __builtin_arm_smultb(__a, __b);
+}
+static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
+__smultt(int32_t __a, int32_t __b) {
+  return __builtin_arm_smultt(__a, __b);
+}
+static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
+__smulwb(int32_t __a, int32_t __b) {
+  return __builtin_arm_smulwb(__a, __b);
+}
+static __inline__ int32_t __attribute__((__always_inline__,__nodebug__))
+__smulwt(int32_t __a, int32_t __b) {
+  return __builtin_arm_smulwt(__a, __b);
+}
+#endif
+
+/*
+ * 8.4 Saturating intrinsics
+ *
+ * FIXME: Change guard to their corresponding __ARM_FEATURE flag when Q flag
+ * intrinsics are implemented and the flag is enabled.
+ */
+/* 8.4.1 Width-specified saturation intrinsics */
+#if defined(__ARM_FEATURE_SAT) && __ARM_FEATURE_SAT
+#define __ssat(x, y) __builtin_arm_ssat(x, y)
+#define __usat(x, y) __builtin_arm_usat(x, y)
+#endif
+
+/* 8.4.2 Saturating addition and subtraction intrinsics */
+#if defined(__ARM_FEATURE_DSP) && __ARM_FEATURE_DSP
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__qadd(int32_t __t, int32_t __v) {
+  return __builtin_arm_qadd(__t, __v);
+}
+
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__qsub(int32_t __t, int32_t __v) {
+  return __builtin_arm_qsub(__t, __v);
+}
+
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__qdbl(int32_t __t) {
+  return __builtin_arm_qadd(__t, __t);
+}
+#endif
+
+/* 8.4.3 Accumulating multiplications */
+#if defined(__ARM_FEATURE_DSP) && __ARM_FEATURE_DSP
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smlabb(int32_t __a, int32_t __b, int32_t __c) {
+  return __builtin_arm_smlabb(__a, __b, __c);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smlabt(int32_t __a, int32_t __b, int32_t __c) {
+  return __builtin_arm_smlabt(__a, __b, __c);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smlatb(int32_t __a, int32_t __b, int32_t __c) {
+  return __builtin_arm_smlatb(__a, __b, __c);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smlatt(int32_t __a, int32_t __b, int32_t __c) {
+  return __builtin_arm_smlatt(__a, __b, __c);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smlawb(int32_t __a, int32_t __b, int32_t __c) {
+  return __builtin_arm_smlawb(__a, __b, __c);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smlawt(int32_t __a, int32_t __b, int32_t __c) {
+  return __builtin_arm_smlawt(__a, __b, __c);
+}
+#endif
+
+
+/* 8.5.4 Parallel 16-bit saturation */
+#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
+#define __ssat16(x, y) __builtin_arm_ssat16(x, y)
+#define __usat16(x, y) __builtin_arm_usat16(x, y)
+#endif
+
+/* 8.5.5 Packing and unpacking */
+#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
+typedef int32_t int8x4_t;
+typedef int32_t int16x2_t;
+typedef uint32_t uint8x4_t;
+typedef uint32_t uint16x2_t;
+
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__sxtab16(int16x2_t __a, int8x4_t __b) {
+  return __builtin_arm_sxtab16(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__sxtb16(int8x4_t __a) {
+  return __builtin_arm_sxtb16(__a);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__uxtab16(int16x2_t __a, int8x4_t __b) {
+  return __builtin_arm_uxtab16(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__uxtb16(int8x4_t __a) {
+  return __builtin_arm_uxtb16(__a);
+}
+#endif
+
+/* 8.5.6 Parallel selection */
+#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
+static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
+__sel(uint8x4_t __a, uint8x4_t __b) {
+  return __builtin_arm_sel(__a, __b);
+}
+#endif
+
+/* 8.5.7 Parallel 8-bit addition and subtraction */
+#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
+static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
+__qadd8(int8x4_t __a, int8x4_t __b) {
+  return __builtin_arm_qadd8(__a, __b);
+}
+static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
+__qsub8(int8x4_t __a, int8x4_t __b) {
+  return __builtin_arm_qsub8(__a, __b);
+}
+static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
+__sadd8(int8x4_t __a, int8x4_t __b) {
+  return __builtin_arm_sadd8(__a, __b);
+}
+static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
+__shadd8(int8x4_t __a, int8x4_t __b) {
+  return __builtin_arm_shadd8(__a, __b);
+}
+static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
+__shsub8(int8x4_t __a, int8x4_t __b) {
+  return __builtin_arm_shsub8(__a, __b);
+}
+static __inline__ int8x4_t __attribute__((__always_inline__, __nodebug__))
+__ssub8(int8x4_t __a, int8x4_t __b) {
+  return __builtin_arm_ssub8(__a, __b);
+}
+static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
+__uadd8(uint8x4_t __a, uint8x4_t __b) {
+  return __builtin_arm_uadd8(__a, __b);
+}
+static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
+__uhadd8(uint8x4_t __a, uint8x4_t __b) {
+  return __builtin_arm_uhadd8(__a, __b);
+}
+static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
+__uhsub8(uint8x4_t __a, uint8x4_t __b) {
+  return __builtin_arm_uhsub8(__a, __b);
+}
+static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
+__uqadd8(uint8x4_t __a, uint8x4_t __b) {
+  return __builtin_arm_uqadd8(__a, __b);
+}
+static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
+__uqsub8(uint8x4_t __a, uint8x4_t __b) {
+  return __builtin_arm_uqsub8(__a, __b);
+}
+static __inline__ uint8x4_t __attribute__((__always_inline__, __nodebug__))
+__usub8(uint8x4_t __a, uint8x4_t __b) {
+  return __builtin_arm_usub8(__a, __b);
+}
+#endif
+
+/* 8.5.8 Sum of 8-bit absolute differences */
+#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
+__usad8(uint8x4_t __a, uint8x4_t __b) {
+  return __builtin_arm_usad8(__a, __b);
+}
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__))
+__usada8(uint8x4_t __a, uint8x4_t __b, uint32_t __c) {
+  return __builtin_arm_usada8(__a, __b, __c);
+}
+#endif
+
+/* 8.5.9 Parallel 16-bit addition and subtraction */
+#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__qadd16(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_qadd16(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__qasx(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_qasx(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__qsax(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_qsax(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__qsub16(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_qsub16(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__sadd16(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_sadd16(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__sasx(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_sasx(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__shadd16(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_shadd16(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__shasx(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_shasx(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__shsax(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_shsax(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__shsub16(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_shsub16(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__ssax(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_ssax(__a, __b);
+}
+static __inline__ int16x2_t __attribute__((__always_inline__, __nodebug__))
+__ssub16(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_ssub16(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__uadd16(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_uadd16(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__uasx(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_uasx(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__uhadd16(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_uhadd16(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__uhasx(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_uhasx(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__uhsax(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_uhsax(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__uhsub16(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_uhsub16(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__uqadd16(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_uqadd16(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__uqasx(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_uqasx(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__uqsax(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_uqsax(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__uqsub16(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_uqsub16(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__usax(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_usax(__a, __b);
+}
+static __inline__ uint16x2_t __attribute__((__always_inline__, __nodebug__))
+__usub16(uint16x2_t __a, uint16x2_t __b) {
+  return __builtin_arm_usub16(__a, __b);
+}
+#endif
+
+/* 8.5.10 Parallel 16-bit multiplication */
+#if defined(__ARM_FEATURE_SIMD32) && __ARM_FEATURE_SIMD32
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smlad(int16x2_t __a, int16x2_t __b, int32_t __c) {
+  return __builtin_arm_smlad(__a, __b, __c);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smladx(int16x2_t __a, int16x2_t __b, int32_t __c) {
+  return __builtin_arm_smladx(__a, __b, __c);
+}
+static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
+__smlald(int16x2_t __a, int16x2_t __b, int64_t __c) {
+  return __builtin_arm_smlald(__a, __b, __c);
+}
+static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
+__smlaldx(int16x2_t __a, int16x2_t __b, int64_t __c) {
+  return __builtin_arm_smlaldx(__a, __b, __c);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smlsd(int16x2_t __a, int16x2_t __b, int32_t __c) {
+  return __builtin_arm_smlsd(__a, __b, __c);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smlsdx(int16x2_t __a, int16x2_t __b, int32_t __c) {
+  return __builtin_arm_smlsdx(__a, __b, __c);
+}
+static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
+__smlsld(int16x2_t __a, int16x2_t __b, int64_t __c) {
+  return __builtin_arm_smlsld(__a, __b, __c);
+}
+static __inline__ int64_t __attribute__((__always_inline__, __nodebug__))
+__smlsldx(int16x2_t __a, int16x2_t __b, int64_t __c) {
+  return __builtin_arm_smlsldx(__a, __b, __c);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smuad(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_smuad(__a, __b);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smuadx(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_smuadx(__a, __b);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smusd(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_smusd(__a, __b);
+}
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__))
+__smusdx(int16x2_t __a, int16x2_t __b) {
+  return __builtin_arm_smusdx(__a, __b);
+}
+#endif
+
+/* 8.6 Floating-point data-processing intrinsics */
+#if (defined(__ARM_FEATURE_DIRECTED_ROUNDING)    &&                         \
+  (__ARM_FEATURE_DIRECTED_ROUNDING))             &&                         \
+  (defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE)
+static __inline__ double __attribute__((__always_inline__, __nodebug__))
+__rintn(double __a) {
+  return __builtin_roundeven(__a);
+}
+
+static __inline__ float __attribute__((__always_inline__, __nodebug__))
+__rintnf(float __a) {
+  return __builtin_roundevenf(__a);
+}
+#endif
+
+/* 8.8 CRC32 intrinsics */
+#if (defined(__ARM_FEATURE_CRC32) && __ARM_FEATURE_CRC32) ||                   \
+    (defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE)
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
+__crc32b(uint32_t __a, uint8_t __b) {
+  return __builtin_arm_crc32b(__a, __b);
+}
+
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
+__crc32h(uint32_t __a, uint16_t __b) {
+  return __builtin_arm_crc32h(__a, __b);
+}
+
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
+__crc32w(uint32_t __a, uint32_t __b) {
+  return __builtin_arm_crc32w(__a, __b);
+}
+
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
+__crc32d(uint32_t __a, uint64_t __b) {
+  return __builtin_arm_crc32d(__a, __b);
+}
+
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
+__crc32cb(uint32_t __a, uint8_t __b) {
+  return __builtin_arm_crc32cb(__a, __b);
+}
+
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
+__crc32ch(uint32_t __a, uint16_t __b) {
+  return __builtin_arm_crc32ch(__a, __b);
+}
+
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
+__crc32cw(uint32_t __a, uint32_t __b) {
+  return __builtin_arm_crc32cw(__a, __b);
+}
+
+static __inline__ uint32_t __attribute__((__always_inline__, __nodebug__, target("crc")))
+__crc32cd(uint32_t __a, uint64_t __b) {
+  return __builtin_arm_crc32cd(__a, __b);
+}
+#endif
+
+/* 8.6 Floating-point data-processing intrinsics */
+/* Armv8.3-A Javascript conversion intrinsic */
+#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
+static __inline__ int32_t __attribute__((__always_inline__, __nodebug__, target("v8.3a")))
+__jcvt(double __a) {
+  return __builtin_arm_jcvt(__a);
+}
+#endif
+
+/* Armv8.5-A FP rounding intrinsics */
+#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
+static __inline__ float __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
+__rint32zf(float __a) {
+  return __builtin_arm_rint32zf(__a);
+}
+
+static __inline__ double __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
+__rint32z(double __a) {
+  return __builtin_arm_rint32z(__a);
+}
+
+static __inline__ float __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
+__rint64zf(float __a) {
+  return __builtin_arm_rint64zf(__a);
+}
+
+static __inline__ double __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
+__rint64z(double __a) {
+  return __builtin_arm_rint64z(__a);
+}
+
+static __inline__ float __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
+__rint32xf(float __a) {
+  return __builtin_arm_rint32xf(__a);
+}
+
+static __inline__ double __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
+__rint32x(double __a) {
+  return __builtin_arm_rint32x(__a);
+}
+
+static __inline__ float __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
+__rint64xf(float __a) {
+  return __builtin_arm_rint64xf(__a);
+}
+
+static __inline__ double __attribute__((__always_inline__, __nodebug__, target("v8.5a")))
+__rint64x(double __a) {
+  return __builtin_arm_rint64x(__a);
+}
+#endif
+
+/* 8.9 Armv8.7-A load/store 64-byte intrinsics */
+#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
+typedef struct {
+    uint64_t val[8];
+} data512_t;
+
+static __inline__ data512_t __attribute__((__always_inline__, __nodebug__, target("ls64")))
+__arm_ld64b(const void *__addr) {
+  data512_t __value;
+  __builtin_arm_ld64b(__addr, __value.val);
+  return __value;
+}
+static __inline__ void __attribute__((__always_inline__, __nodebug__, target("ls64")))
+__arm_st64b(void *__addr, data512_t __value) {
+  __builtin_arm_st64b(__addr, __value.val);
+}
+static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__, target("ls64")))
+__arm_st64bv(void *__addr, data512_t __value) {
+  return __builtin_arm_st64bv(__addr, __value.val);
+}
+static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__, target("ls64")))
+__arm_st64bv0(void *__addr, data512_t __value) {
+  return __builtin_arm_st64bv0(__addr, __value.val);
+}
+#endif
+
+/* 11.1 Special register intrinsics */
+#define __arm_rsr(sysreg) __builtin_arm_rsr(sysreg)
+#define __arm_rsr64(sysreg) __builtin_arm_rsr64(sysreg)
+#define __arm_rsr128(sysreg) __builtin_arm_rsr128(sysreg)
+#define __arm_rsrp(sysreg) __builtin_arm_rsrp(sysreg)
+#define __arm_rsrf(sysreg) __builtin_bit_cast(float, __arm_rsr(sysreg))
+#define __arm_rsrf64(sysreg) __builtin_bit_cast(double, __arm_rsr64(sysreg))
+#define __arm_wsr(sysreg, v) __builtin_arm_wsr(sysreg, v)
+#define __arm_wsr64(sysreg, v) __builtin_arm_wsr64(sysreg, v)
+#define __arm_wsr128(sysreg, v) __builtin_arm_wsr128(sysreg, v)
+#define __arm_wsrp(sysreg, v) __builtin_arm_wsrp(sysreg, v)
+#define __arm_wsrf(sysreg, v) __arm_wsr(sysreg, __builtin_bit_cast(uint32_t, v))
+#define __arm_wsrf64(sysreg, v) __arm_wsr64(sysreg, __builtin_bit_cast(uint64_t, v))
+
+/* 10.3 MTE intrinsics */
+#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
+#define __arm_mte_create_random_tag(__ptr, __mask)  __builtin_arm_irg(__ptr, __mask)
+#define __arm_mte_increment_tag(__ptr, __tag_offset)  __builtin_arm_addg(__ptr, __tag_offset)
+#define __arm_mte_exclude_tag(__ptr, __excluded)  __builtin_arm_gmi(__ptr, __excluded)
+#define __arm_mte_get_tag(__ptr) __builtin_arm_ldg(__ptr)
+#define __arm_mte_set_tag(__ptr) __builtin_arm_stg(__ptr)
+#define __arm_mte_ptrdiff(__ptra, __ptrb) __builtin_arm_subp(__ptra, __ptrb)
+
+/* 18 memcpy family of operations intrinsics - MOPS */
+#define __arm_mops_memset_tag(__tagged_address, __value, __size)    \
+  __builtin_arm_mops_memset_tag(__tagged_address, __value, __size)
+#endif
+
+/* 11.3 Coprocessor Intrinsics */
+#if defined(__ARM_FEATURE_COPROC)
+
+#if (__ARM_FEATURE_COPROC & 0x1)
+
+#if (__ARM_ARCH < 8)
+#define __arm_cdp(coproc, opc1, CRd, CRn, CRm, opc2)                           \
+  __builtin_arm_cdp(coproc, opc1, CRd, CRn, CRm, opc2)
+#endif /* __ARM_ARCH < 8 */
+
+#define __arm_ldc(coproc, CRd, p) __builtin_arm_ldc(coproc, CRd, p)
+#define __arm_stc(coproc, CRd, p) __builtin_arm_stc(coproc, CRd, p)
+
+#define __arm_mcr(coproc, opc1, value, CRn, CRm, opc2)                         \
+  __builtin_arm_mcr(coproc, opc1, value, CRn, CRm, opc2)
+#define __arm_mrc(coproc, opc1, CRn, CRm, opc2)                                \
+  __builtin_arm_mrc(coproc, opc1, CRn, CRm, opc2)
+
+#if (__ARM_ARCH != 4) && (__ARM_ARCH < 8)
+#define __arm_ldcl(coproc, CRd, p) __builtin_arm_ldcl(coproc, CRd, p)
+#define __arm_stcl(coproc, CRd, p) __builtin_arm_stcl(coproc, CRd, p)
+#endif /* (__ARM_ARCH != 4) && (__ARM_ARCH != 8) */
+
+#if (__ARM_ARCH_8M_MAIN__) || (__ARM_ARCH_8_1M_MAIN__)
+#define __arm_cdp(coproc, opc1, CRd, CRn, CRm, opc2)                           \
+  __builtin_arm_cdp(coproc, opc1, CRd, CRn, CRm, opc2)
+#define __arm_ldcl(coproc, CRd, p) __builtin_arm_ldcl(coproc, CRd, p)
+#define __arm_stcl(coproc, CRd, p) __builtin_arm_stcl(coproc, CRd, p)
+#endif /* ___ARM_ARCH_8M_MAIN__ */
+
+#endif /* __ARM_FEATURE_COPROC & 0x1 */
+
+#if (__ARM_FEATURE_COPROC & 0x2)
+#define __arm_cdp2(coproc, opc1, CRd, CRn, CRm, opc2)                          \
+  __builtin_arm_cdp2(coproc, opc1, CRd, CRn, CRm, opc2)
+#define __arm_ldc2(coproc, CRd, p) __builtin_arm_ldc2(coproc, CRd, p)
+#define __arm_stc2(coproc, CRd, p) __builtin_arm_stc2(coproc, CRd, p)
+#define __arm_ldc2l(coproc, CRd, p) __builtin_arm_ldc2l(coproc, CRd, p)
+#define __arm_stc2l(coproc, CRd, p) __builtin_arm_stc2l(coproc, CRd, p)
+#define __arm_mcr2(coproc, opc1, value, CRn, CRm, opc2)                        \
+  __builtin_arm_mcr2(coproc, opc1, value, CRn, CRm, opc2)
+#define __arm_mrc2(coproc, opc1, CRn, CRm, opc2)                               \
+  __builtin_arm_mrc2(coproc, opc1, CRn, CRm, opc2)
+#endif
+
+#if (__ARM_FEATURE_COPROC & 0x4)
+#define __arm_mcrr(coproc, opc1, value, CRm)                                   \
+  __builtin_arm_mcrr(coproc, opc1, value, CRm)
+#define __arm_mrrc(coproc, opc1, CRm) __builtin_arm_mrrc(coproc, opc1, CRm)
+#endif
+
+#if (__ARM_FEATURE_COPROC & 0x8)
+#define __arm_mcrr2(coproc, opc1, value, CRm)                                  \
+  __builtin_arm_mcrr2(coproc, opc1, value, CRm)
+#define __arm_mrrc2(coproc, opc1, CRm) __builtin_arm_mrrc2(coproc, opc1, CRm)
+#endif
+
+#endif // __ARM_FEATURE_COPROC
+
+/* 17 Transactional Memory Extension (TME) Intrinsics */
+#if defined(__ARM_FEATURE_TME) && __ARM_FEATURE_TME
+
+#define _TMFAILURE_REASON  0x00007fffu
+#define _TMFAILURE_RTRY    0x00008000u
+#define _TMFAILURE_CNCL    0x00010000u
+#define _TMFAILURE_MEM     0x00020000u
+#define _TMFAILURE_IMP     0x00040000u
+#define _TMFAILURE_ERR     0x00080000u
+#define _TMFAILURE_SIZE    0x00100000u
+#define _TMFAILURE_NEST    0x00200000u
+#define _TMFAILURE_DBG     0x00400000u
+#define _TMFAILURE_INT     0x00800000u
+#define _TMFAILURE_TRIVIAL 0x01000000u
+
+#define __tstart()        __builtin_arm_tstart()
+#define __tcommit()       __builtin_arm_tcommit()
+#define __tcancel(__arg)  __builtin_arm_tcancel(__arg)
+#define __ttest()         __builtin_arm_ttest()
+
+#endif /* __ARM_FEATURE_TME */
+
+/* 8.7 Armv8.5-A Random number generation intrinsics */
+#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
+static __inline__ int __attribute__((__always_inline__, __nodebug__, target("rand")))
+__rndr(uint64_t *__p) {
+  return __builtin_arm_rndr(__p);
+}
+static __inline__ int __attribute__((__always_inline__, __nodebug__, target("rand")))
+__rndrrs(uint64_t *__p) {
+  return __builtin_arm_rndrrs(__p);
+}
+#endif
+
+/* 11.2 Guarded Control Stack intrinsics */
+#if defined(__ARM_64BIT_STATE) && __ARM_64BIT_STATE
+static __inline__ void * __attribute__((__always_inline__, __nodebug__))
+__gcspr() {
+  return (void *)__builtin_arm_rsr64("gcspr_el0");
+}
+
+static __inline__ uint64_t __attribute__((__always_inline__, __nodebug__, target("gcs")))
+__gcspopm() {
+  return __builtin_arm_gcspopm(0);
+}
+
+static __inline__ const void * __attribute__((__always_inline__, __nodebug__, target("gcs")))
+__gcsss(const void *__stack) {
+  return __builtin_arm_gcsss(__stack);
+}
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* __ARM_ACLE_H */
diff --git a/third_party/aarch64/clang/arm_bf16.h b/third_party/aarch64/clang/arm_bf16.h
new file mode 100644
index 000000000..329ae39e6
--- /dev/null
+++ b/third_party/aarch64/clang/arm_bf16.h
@@ -0,0 +1,20 @@
+/*===---- arm_bf16.h - ARM BF16 intrinsics -----------------------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ARM_BF16_H
+#define __ARM_BF16_H
+
+typedef __bf16 bfloat16_t;
+#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
+
+
+#undef __ai
+
+#endif
diff --git a/third_party/aarch64/clang/arm_cde.h b/third_party/aarch64/clang/arm_cde.h
new file mode 100644
index 000000000..4ad5d825d
--- /dev/null
+++ b/third_party/aarch64/clang/arm_cde.h
@@ -0,0 +1,410 @@
+/*===---- arm_cde.h - ARM CDE intrinsics -----------------------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ARM_CDE_H
+#define __ARM_CDE_H
+
+#if !__ARM_FEATURE_CDE
+#error "CDE support not enabled"
+#endif
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx1)))
+uint32_t __arm_cx1(int, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx1a)))
+uint32_t __arm_cx1a(int, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx1d)))
+uint64_t __arm_cx1d(int, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx1da)))
+uint64_t __arm_cx1da(int, uint64_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx2)))
+uint32_t __arm_cx2(int, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx2a)))
+uint32_t __arm_cx2a(int, uint32_t, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx2d)))
+uint64_t __arm_cx2d(int, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx2da)))
+uint64_t __arm_cx2da(int, uint64_t, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx3)))
+uint32_t __arm_cx3(int, uint32_t, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx3a)))
+uint32_t __arm_cx3a(int, uint32_t, uint32_t, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx3d)))
+uint64_t __arm_cx3d(int, uint32_t, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_cx3da)))
+uint64_t __arm_cx3da(int, uint64_t, uint32_t, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx1_u32)))
+uint32_t __arm_vcx1_u32(int, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx1a_u32)))
+uint32_t __arm_vcx1a_u32(int, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx1d_u64)))
+uint64_t __arm_vcx1d_u64(int, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx1da_u64)))
+uint64_t __arm_vcx1da_u64(int, uint64_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx2_u32)))
+uint32_t __arm_vcx2_u32(int, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx2a_u32)))
+uint32_t __arm_vcx2a_u32(int, uint32_t, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx2d_u64)))
+uint64_t __arm_vcx2d_u64(int, uint64_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx2da_u64)))
+uint64_t __arm_vcx2da_u64(int, uint64_t, uint64_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx3_u32)))
+uint32_t __arm_vcx3_u32(int, uint32_t, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx3a_u32)))
+uint32_t __arm_vcx3a_u32(int, uint32_t, uint32_t, uint32_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx3d_u64)))
+uint64_t __arm_vcx3d_u64(int, uint64_t, uint64_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx3da_u64)))
+uint64_t __arm_vcx3da_u64(int, uint64_t, uint64_t, uint64_t, uint32_t);
+
+#if __ARM_FEATURE_MVE
+
+typedef uint16_t mve_pred16_t;
+typedef __attribute__((__neon_vector_type__(8), __clang_arm_mve_strict_polymorphism)) int16_t int16x8_t;
+typedef __attribute__((__neon_vector_type__(4), __clang_arm_mve_strict_polymorphism)) int32_t int32x4_t;
+typedef __attribute__((__neon_vector_type__(2), __clang_arm_mve_strict_polymorphism)) int64_t int64x2_t;
+typedef __attribute__((__neon_vector_type__(16), __clang_arm_mve_strict_polymorphism)) int8_t int8x16_t;
+typedef __attribute__((__neon_vector_type__(8), __clang_arm_mve_strict_polymorphism)) uint16_t uint16x8_t;
+typedef __attribute__((__neon_vector_type__(4), __clang_arm_mve_strict_polymorphism)) uint32_t uint32x4_t;
+typedef __attribute__((__neon_vector_type__(2), __clang_arm_mve_strict_polymorphism)) uint64_t uint64x2_t;
+typedef __attribute__((__neon_vector_type__(16), __clang_arm_mve_strict_polymorphism)) uint8_t uint8x16_t;
+
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_s16)))
+int16x8_t __arm_vcx1q_m(int, int16x8_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_s32)))
+int32x4_t __arm_vcx1q_m(int, int32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_s64)))
+int64x2_t __arm_vcx1q_m(int, int64x2_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_s8)))
+int8x16_t __arm_vcx1q_m(int, int8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_u16)))
+uint16x8_t __arm_vcx1q_m(int, uint16x8_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_u32)))
+uint32x4_t __arm_vcx1q_m(int, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_u64)))
+uint64x2_t __arm_vcx1q_m(int, uint64x2_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_u8)))
+uint8x16_t __arm_vcx1q_m(int, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_u8)))
+uint8x16_t __arm_vcx1q_u8(int, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_s16)))
+int16x8_t __arm_vcx1qa_m(int, int16x8_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_s32)))
+int32x4_t __arm_vcx1qa_m(int, int32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_s64)))
+int64x2_t __arm_vcx1qa_m(int, int64x2_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_s8)))
+int8x16_t __arm_vcx1qa_m(int, int8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_u16)))
+uint16x8_t __arm_vcx1qa_m(int, uint16x8_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_u32)))
+uint32x4_t __arm_vcx1qa_m(int, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_u64)))
+uint64x2_t __arm_vcx1qa_m(int, uint64x2_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_u8)))
+uint8x16_t __arm_vcx1qa_m(int, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_s16)))
+int16x8_t __arm_vcx1qa(int, int16x8_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_s32)))
+int32x4_t __arm_vcx1qa(int, int32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_s64)))
+int64x2_t __arm_vcx1qa(int, int64x2_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_s8)))
+int8x16_t __arm_vcx1qa(int, int8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_u16)))
+uint16x8_t __arm_vcx1qa(int, uint16x8_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_u32)))
+uint32x4_t __arm_vcx1qa(int, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_u64)))
+uint64x2_t __arm_vcx1qa(int, uint64x2_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_u8)))
+uint8x16_t __arm_vcx1qa(int, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_s16)))
+int16x8_t __arm_vcx2q_m_impl(int, int16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_s32)))
+int32x4_t __arm_vcx2q_m_impl(int, int32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_s64)))
+int64x2_t __arm_vcx2q_m_impl(int, int64x2_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_s8)))
+int8x16_t __arm_vcx2q_m_impl(int, int8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_u16)))
+uint16x8_t __arm_vcx2q_m_impl(int, uint16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_u32)))
+uint32x4_t __arm_vcx2q_m_impl(int, uint32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_u64)))
+uint64x2_t __arm_vcx2q_m_impl(int, uint64x2_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_u8)))
+uint8x16_t __arm_vcx2q_m_impl(int, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_s16)))
+int16x8_t __arm_vcx2q(int, int16x8_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_s32)))
+int32x4_t __arm_vcx2q(int, int32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_s64)))
+int64x2_t __arm_vcx2q(int, int64x2_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_s8)))
+int8x16_t __arm_vcx2q(int, int8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u16)))
+uint16x8_t __arm_vcx2q(int, uint16x8_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u32)))
+uint32x4_t __arm_vcx2q(int, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u64)))
+uint64x2_t __arm_vcx2q(int, uint64x2_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8)))
+uint8x16_t __arm_vcx2q(int, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_s16)))
+uint8x16_t __arm_vcx2q_u8(int, int16x8_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_s32)))
+uint8x16_t __arm_vcx2q_u8(int, int32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_s64)))
+uint8x16_t __arm_vcx2q_u8(int, int64x2_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_s8)))
+uint8x16_t __arm_vcx2q_u8(int, int8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_u16)))
+uint8x16_t __arm_vcx2q_u8(int, uint16x8_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_u32)))
+uint8x16_t __arm_vcx2q_u8(int, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_u64)))
+uint8x16_t __arm_vcx2q_u8(int, uint64x2_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_u8)))
+uint8x16_t __arm_vcx2q_u8(int, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_s16)))
+int16x8_t __arm_vcx2qa_impl(int, int16x8_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_s32)))
+int32x4_t __arm_vcx2qa_impl(int, int32x4_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_s64)))
+int64x2_t __arm_vcx2qa_impl(int, int64x2_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_s8)))
+int8x16_t __arm_vcx2qa_impl(int, int8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_u16)))
+uint16x8_t __arm_vcx2qa_impl(int, uint16x8_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_u32)))
+uint32x4_t __arm_vcx2qa_impl(int, uint32x4_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_u64)))
+uint64x2_t __arm_vcx2qa_impl(int, uint64x2_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_u8)))
+uint8x16_t __arm_vcx2qa_impl(int, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_s16)))
+int16x8_t __arm_vcx2qa_m_impl(int, int16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_s32)))
+int32x4_t __arm_vcx2qa_m_impl(int, int32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_s64)))
+int64x2_t __arm_vcx2qa_m_impl(int, int64x2_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_s8)))
+int8x16_t __arm_vcx2qa_m_impl(int, int8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_u16)))
+uint16x8_t __arm_vcx2qa_m_impl(int, uint16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_u32)))
+uint32x4_t __arm_vcx2qa_m_impl(int, uint32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_u64)))
+uint64x2_t __arm_vcx2qa_m_impl(int, uint64x2_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_u8)))
+uint8x16_t __arm_vcx2qa_m_impl(int, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_s16)))
+int16x8_t __arm_vcx3q_impl(int, int16x8_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_s32)))
+int32x4_t __arm_vcx3q_impl(int, int32x4_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_s64)))
+int64x2_t __arm_vcx3q_impl(int, int64x2_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_s8)))
+int8x16_t __arm_vcx3q_impl(int, int8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_u16)))
+uint16x8_t __arm_vcx3q_impl(int, uint16x8_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_u32)))
+uint32x4_t __arm_vcx3q_impl(int, uint32x4_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_u64)))
+uint64x2_t __arm_vcx3q_impl(int, uint64x2_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_u8)))
+uint8x16_t __arm_vcx3q_impl(int, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_s16)))
+int16x8_t __arm_vcx3q_m_impl(int, int16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_s32)))
+int32x4_t __arm_vcx3q_m_impl(int, int32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_s64)))
+int64x2_t __arm_vcx3q_m_impl(int, int64x2_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_s8)))
+int8x16_t __arm_vcx3q_m_impl(int, int8x16_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_u16)))
+uint16x8_t __arm_vcx3q_m_impl(int, uint16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_u32)))
+uint32x4_t __arm_vcx3q_m_impl(int, uint32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_u64)))
+uint64x2_t __arm_vcx3q_m_impl(int, uint64x2_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_u8)))
+uint8x16_t __arm_vcx3q_m_impl(int, uint8x16_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_s16)))
+uint8x16_t __arm_vcx3q_u8_impl(int, int16x8_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_s32)))
+uint8x16_t __arm_vcx3q_u8_impl(int, int32x4_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_s64)))
+uint8x16_t __arm_vcx3q_u8_impl(int, int64x2_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_s8)))
+uint8x16_t __arm_vcx3q_u8_impl(int, int8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_u16)))
+uint8x16_t __arm_vcx3q_u8_impl(int, uint16x8_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_u32)))
+uint8x16_t __arm_vcx3q_u8_impl(int, uint32x4_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_u64)))
+uint8x16_t __arm_vcx3q_u8_impl(int, uint64x2_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_u8)))
+uint8x16_t __arm_vcx3q_u8_impl(int, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_s16)))
+int16x8_t __arm_vcx3qa_impl(int, int16x8_t, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_s32)))
+int32x4_t __arm_vcx3qa_impl(int, int32x4_t, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_s64)))
+int64x2_t __arm_vcx3qa_impl(int, int64x2_t, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_s8)))
+int8x16_t __arm_vcx3qa_impl(int, int8x16_t, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_u16)))
+uint16x8_t __arm_vcx3qa_impl(int, uint16x8_t, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_u32)))
+uint32x4_t __arm_vcx3qa_impl(int, uint32x4_t, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_u64)))
+uint64x2_t __arm_vcx3qa_impl(int, uint64x2_t, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_u8)))
+uint8x16_t __arm_vcx3qa_impl(int, uint8x16_t, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_s16)))
+int16x8_t __arm_vcx3qa_m_impl(int, int16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_s32)))
+int32x4_t __arm_vcx3qa_m_impl(int, int32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_s64)))
+int64x2_t __arm_vcx3qa_m_impl(int, int64x2_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_s8)))
+int8x16_t __arm_vcx3qa_m_impl(int, int8x16_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_u16)))
+uint16x8_t __arm_vcx3qa_m_impl(int, uint16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_u32)))
+uint32x4_t __arm_vcx3qa_m_impl(int, uint32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_u64)))
+uint64x2_t __arm_vcx3qa_m_impl(int, uint64x2_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_u8)))
+uint8x16_t __arm_vcx3qa_m_impl(int, uint8x16_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u8)))
+int16x8_t __arm_vreinterpretq_s16_u8(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u8)))
+int32x4_t __arm_vreinterpretq_s32_u8(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u8)))
+int64x2_t __arm_vreinterpretq_s64_u8(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u8)))
+int8x16_t __arm_vreinterpretq_s8_u8(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u8)))
+uint16x8_t __arm_vreinterpretq_u16_u8(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u8)))
+uint32x4_t __arm_vreinterpretq_u32_u8(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u8)))
+uint64x2_t __arm_vreinterpretq_u64_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s16)))
+uint8x16_t __arm_vreinterpretq_u8(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s32)))
+uint8x16_t __arm_vreinterpretq_u8(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s64)))
+uint8x16_t __arm_vreinterpretq_u8(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s8)))
+uint8x16_t __arm_vreinterpretq_u8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u16)))
+uint8x16_t __arm_vreinterpretq_u8(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u32)))
+uint8x16_t __arm_vreinterpretq_u8(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u64)))
+uint8x16_t __arm_vreinterpretq_u8(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vreinterpretq_u8_u8)))
+uint8x16_t __arm_vreinterpretq_u8(uint8x16_t);
+#define __arm_vcx2q_m(cp, inactive, n, imm, pred) __arm_vcx2q_m_impl((cp), (inactive), __arm_vreinterpretq_u8(n), (imm), (pred))
+#define __arm_vcx2qa(cp, acc, n, imm) __arm_vcx2qa_impl((cp), (acc), __arm_vreinterpretq_u8(n), (imm))
+#define __arm_vcx2qa_m(cp, acc, n, imm, pred) __arm_vcx2qa_m_impl((cp), (acc), __arm_vreinterpretq_u8(n), (imm), (pred))
+#define __arm_vcx3q(cp, n, m, imm) __arm_vcx3q_impl((cp), (n), __arm_vreinterpretq_u8(m), (imm))
+#define __arm_vcx3q_m(cp, inactive, n, m, imm, pred) __arm_vcx3q_m_impl((cp), (inactive), __arm_vreinterpretq_u8(n), __arm_vreinterpretq_u8(m), (imm), (pred))
+#define __arm_vcx3q_u8(cp, n, m, imm) __arm_vcx3q_u8_impl((cp), (n), __arm_vreinterpretq_u8(m), (imm))
+#define __arm_vcx3qa(cp, acc, n, m, imm) __arm_vcx3qa_impl((cp), (acc), __arm_vreinterpretq_u8(n), __arm_vreinterpretq_u8(m), (imm))
+#define __arm_vcx3qa_m(cp, acc, n, m, imm, pred) __arm_vcx3qa_m_impl((cp), (acc), __arm_vreinterpretq_u8(n), __arm_vreinterpretq_u8(m), (imm), (pred))
+
+#endif /* __ARM_FEATURE_MVE */
+
+#if __ARM_FEATURE_MVE & 2
+
+typedef __fp16 float16_t;
+typedef float float32_t;
+typedef __attribute__((__neon_vector_type__(8), __clang_arm_mve_strict_polymorphism)) float16_t float16x8_t;
+typedef __attribute__((__neon_vector_type__(4), __clang_arm_mve_strict_polymorphism)) float32_t float32x4_t;
+
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_f16)))
+float16x8_t __arm_vcx1q_m(int, float16x8_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1q_m_f32)))
+float32x4_t __arm_vcx1q_m(int, float32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_f16)))
+float16x8_t __arm_vcx1qa(int, float16x8_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_f32)))
+float32x4_t __arm_vcx1qa(int, float32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_f16)))
+float16x8_t __arm_vcx1qa_m(int, float16x8_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx1qa_m_f32)))
+float32x4_t __arm_vcx1qa_m(int, float32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_f16)))
+float16x8_t __arm_vcx2q(int, float16x8_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_f32)))
+float32x4_t __arm_vcx2q(int, float32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_f16)))
+float16x8_t __arm_vcx2q_m_impl(int, float16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_m_impl_f32)))
+float32x4_t __arm_vcx2q_m_impl(int, float32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_f16)))
+uint8x16_t __arm_vcx2q_u8(int, float16x8_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2q_u8_f32)))
+uint8x16_t __arm_vcx2q_u8(int, float32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_f16)))
+float16x8_t __arm_vcx2qa_impl(int, float16x8_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_impl_f32)))
+float32x4_t __arm_vcx2qa_impl(int, float32x4_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_f16)))
+float16x8_t __arm_vcx2qa_m_impl(int, float16x8_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx2qa_m_impl_f32)))
+float32x4_t __arm_vcx2qa_m_impl(int, float32x4_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_f16)))
+float16x8_t __arm_vcx3q_impl(int, float16x8_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_impl_f32)))
+float32x4_t __arm_vcx3q_impl(int, float32x4_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_f16)))
+float16x8_t __arm_vcx3q_m_impl(int, float16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_m_impl_f32)))
+float32x4_t __arm_vcx3q_m_impl(int, float32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_f16)))
+uint8x16_t __arm_vcx3q_u8_impl(int, float16x8_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3q_u8_impl_f32)))
+uint8x16_t __arm_vcx3q_u8_impl(int, float32x4_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_f16)))
+float16x8_t __arm_vcx3qa_impl(int, float16x8_t, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_impl_f32)))
+float32x4_t __arm_vcx3qa_impl(int, float32x4_t, uint8x16_t, uint8x16_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_f16)))
+float16x8_t __arm_vcx3qa_m_impl(int, float16x8_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_cde_vcx3qa_m_impl_f32)))
+float32x4_t __arm_vcx3qa_m_impl(int, float32x4_t, uint8x16_t, uint8x16_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u8)))
+float16x8_t __arm_vreinterpretq_f16_u8(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u8)))
+float32x4_t __arm_vreinterpretq_f32_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f16)))
+uint8x16_t __arm_vreinterpretq_u8(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f32)))
+uint8x16_t __arm_vreinterpretq_u8(float32x4_t);
+
+#endif /* __ARM_FEATURE_MVE & 2 */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* __ARM_CDE_H */
diff --git a/third_party/aarch64/clang/arm_cmse.h b/third_party/aarch64/clang/arm_cmse.h
new file mode 100644
index 000000000..ecf50ecc5
--- /dev/null
+++ b/third_party/aarch64/clang/arm_cmse.h
@@ -0,0 +1,217 @@
+//===---- arm_cmse.h - Arm CMSE support -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __ARM_CMSE_H
+#define __ARM_CMSE_H
+
+#if (__ARM_FEATURE_CMSE & 0x1)
+#include <stddef.h>
+#include <stdint.h>
+
+#define __ARM_CMSE_SECURE_MODE (__ARM_FEATURE_CMSE & 0x2)
+#define CMSE_MPU_READWRITE 1 /* checks if readwrite_ok field is set */
+#define CMSE_AU_NONSECURE  2 /* checks if permissions have secure field unset */
+#define CMSE_MPU_UNPRIV    4 /* sets T flag on TT insrtuction */
+#define CMSE_MPU_READ      8 /* checks if read_ok field is set */
+#define CMSE_MPU_NONSECURE 16 /* sets A flag, checks if secure field unset */
+#define CMSE_NONSECURE (CMSE_AU_NONSECURE | CMSE_MPU_NONSECURE)
+
+#define cmse_check_pointed_object(p, f) \
+  cmse_check_address_range((p), sizeof(*(p)), (f))
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+typedef union {
+  struct cmse_address_info {
+#ifdef __ARM_BIG_ENDIAN
+    /* __ARM_BIG_ENDIAN */
+#if (__ARM_CMSE_SECURE_MODE)
+    unsigned idau_region : 8;
+    unsigned idau_region_valid : 1;
+    unsigned secure : 1;
+    unsigned nonsecure_readwrite_ok : 1;
+    unsigned nonsecure_read_ok : 1;
+#else
+    unsigned : 12;
+#endif
+    unsigned readwrite_ok : 1;
+    unsigned read_ok : 1;
+#if (__ARM_CMSE_SECURE_MODE)
+    unsigned sau_region_valid : 1;
+#else
+    unsigned : 1;
+#endif
+    unsigned mpu_region_valid : 1;
+#if (__ARM_CMSE_SECURE_MODE)
+    unsigned sau_region : 8;
+#else
+    unsigned : 8;
+#endif
+    unsigned mpu_region : 8;
+
+#else /* __ARM_LITTLE_ENDIAN */
+    unsigned mpu_region : 8;
+#if (__ARM_CMSE_SECURE_MODE)
+    unsigned sau_region : 8;
+#else
+    unsigned : 8;
+#endif
+    unsigned mpu_region_valid : 1;
+#if (__ARM_CMSE_SECURE_MODE)
+    unsigned sau_region_valid : 1;
+#else
+    unsigned : 1;
+#endif
+    unsigned read_ok : 1;
+    unsigned readwrite_ok : 1;
+#if (__ARM_CMSE_SECURE_MODE)
+    unsigned nonsecure_read_ok : 1;
+    unsigned nonsecure_readwrite_ok : 1;
+    unsigned secure : 1;
+    unsigned idau_region_valid : 1;
+    unsigned idau_region : 8;
+#else
+    unsigned : 12;
+#endif
+#endif /*__ARM_LITTLE_ENDIAN */
+  } flags;
+  unsigned value;
+} cmse_address_info_t;
+
+static cmse_address_info_t __attribute__((__always_inline__, __nodebug__))
+cmse_TT(void *__p) {
+  cmse_address_info_t __u;
+  __u.value = __builtin_arm_cmse_TT(__p);
+  return __u;
+}
+static cmse_address_info_t __attribute__((__always_inline__, __nodebug__))
+cmse_TTT(void *__p) {
+  cmse_address_info_t __u;
+  __u.value = __builtin_arm_cmse_TTT(__p);
+  return __u;
+}
+
+#if __ARM_CMSE_SECURE_MODE
+static cmse_address_info_t __attribute__((__always_inline__, __nodebug__))
+cmse_TTA(void *__p) {
+  cmse_address_info_t __u;
+  __u.value = __builtin_arm_cmse_TTA(__p);
+  return __u;
+}
+static cmse_address_info_t __attribute__((__always_inline__, __nodebug__))
+cmse_TTAT(void *__p) {
+  cmse_address_info_t __u;
+  __u.value = __builtin_arm_cmse_TTAT(__p);
+  return __u;
+}
+#endif
+
+#define cmse_TT_fptr(p) cmse_TT(__builtin_bit_cast(void *, (p)))
+#define cmse_TTT_fptr(p) cmse_TTT(__builtin_bit_cast(void *, (p)))
+
+#if __ARM_CMSE_SECURE_MODE
+#define cmse_TTA_fptr(p) cmse_TTA(__builtin_bit_cast(void *, (p)))
+#define cmse_TTAT_fptr(p) cmse_TTAT(__builtin_bit_cast(void *, (p)))
+#endif
+
+static void *__attribute__((__always_inline__))
+cmse_check_address_range(void *__pb, size_t __s, int __flags) {
+  uintptr_t __begin = (uintptr_t)__pb;
+  uintptr_t __end = __begin + __s - 1;
+
+  if (__end < __begin)
+    return NULL; /* wrap around check */
+
+  /* Check whether the range crosses a 32-bytes aligned address */
+  const int __single_check = (__begin ^ __end) < 0x20u;
+
+  /* execute the right variant of the TT instructions */
+  void *__pe = (void *)__end;
+  cmse_address_info_t __permb, __perme;
+  switch (__flags & (CMSE_MPU_UNPRIV | CMSE_MPU_NONSECURE)) {
+  case 0:
+    __permb = cmse_TT(__pb);
+    __perme = __single_check ? __permb : cmse_TT(__pe);
+    break;
+  case CMSE_MPU_UNPRIV:
+    __permb = cmse_TTT(__pb);
+    __perme = __single_check ? __permb : cmse_TTT(__pe);
+    break;
+#if __ARM_CMSE_SECURE_MODE
+  case CMSE_MPU_NONSECURE:
+    __permb = cmse_TTA(__pb);
+    __perme = __single_check ? __permb : cmse_TTA(__pe);
+    break;
+  case CMSE_MPU_UNPRIV | CMSE_MPU_NONSECURE:
+    __permb = cmse_TTAT(__pb);
+    __perme = __single_check ? __permb : cmse_TTAT(__pe);
+    break;
+#endif
+  /* if CMSE_NONSECURE is specified w/o __ARM_CMSE_SECURE_MODE */
+  default:
+    return NULL;
+  }
+
+  /* check that the range does not cross MPU, SAU, or IDAU region boundaries */
+  if (__permb.value != __perme.value)
+    return NULL;
+#if !(__ARM_CMSE_SECURE_MODE)
+  /* CMSE_AU_NONSECURE is only supported when __ARM_FEATURE_CMSE & 0x2 */
+  if (__flags & CMSE_AU_NONSECURE)
+    return NULL;
+#endif
+
+  /* check the permission on the range */
+  switch (__flags & ~(CMSE_MPU_UNPRIV | CMSE_MPU_NONSECURE)) {
+#if (__ARM_CMSE_SECURE_MODE)
+  case CMSE_MPU_READ | CMSE_MPU_READWRITE | CMSE_AU_NONSECURE:
+  case CMSE_MPU_READWRITE | CMSE_AU_NONSECURE:
+    return __permb.flags.nonsecure_readwrite_ok ? __pb : NULL;
+
+  case CMSE_MPU_READ | CMSE_AU_NONSECURE:
+    return __permb.flags.nonsecure_read_ok ? __pb : NULL;
+
+  case CMSE_AU_NONSECURE:
+    return __permb.flags.secure ? NULL : __pb;
+#endif
+  case CMSE_MPU_READ | CMSE_MPU_READWRITE:
+  case CMSE_MPU_READWRITE:
+    return __permb.flags.readwrite_ok ? __pb : NULL;
+
+  case CMSE_MPU_READ:
+    return __permb.flags.read_ok ? __pb : NULL;
+
+  default:
+    return NULL;
+  }
+}
+
+#if __ARM_CMSE_SECURE_MODE
+static int __attribute__((__always_inline__, __nodebug__))
+cmse_nonsecure_caller(void) {
+  return !((uintptr_t)__builtin_return_address(0) & 1);
+}
+
+#define cmse_nsfptr_create(p)                                                  \
+  __builtin_bit_cast(__typeof__(p),                                            \
+                     (__builtin_bit_cast(uintptr_t, p) & ~(uintptr_t)1))
+
+#define cmse_is_nsfptr(p) ((__builtin_bit_cast(uintptr_t, p) & 1) == 0)
+
+#endif /* __ARM_CMSE_SECURE_MODE */
+
+void __attribute__((__noreturn__)) cmse_abort(void);
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* (__ARM_FEATURE_CMSE & 0x1) */
+
+#endif /* __ARM_CMSE_H */
diff --git a/third_party/aarch64/clang/arm_fp16.h b/third_party/aarch64/clang/arm_fp16.h
new file mode 100644
index 000000000..2dd0653ab
--- /dev/null
+++ b/third_party/aarch64/clang/arm_fp16.h
@@ -0,0 +1,596 @@
+/*===---- arm_fp16.h - ARM FP16 intrinsics ---------------------------------===
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ARM_FP16_H
+#define __ARM_FP16_H
+
+#include <stdint.h>
+
+typedef __fp16 float16_t;
+#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
+
+#if defined(__aarch64__) || defined(__arm64ec__)
+#define vabdh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vabdh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vabsh_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vabsh_f16(__s0); \
+  __ret; \
+})
+#define vaddh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vaddh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vcageh_f16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (uint16_t) __builtin_neon_vcageh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vcagth_f16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (uint16_t) __builtin_neon_vcagth_f16(__s0, __s1); \
+  __ret; \
+})
+#define vcaleh_f16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (uint16_t) __builtin_neon_vcaleh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vcalth_f16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (uint16_t) __builtin_neon_vcalth_f16(__s0, __s1); \
+  __ret; \
+})
+#define vceqh_f16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (uint16_t) __builtin_neon_vceqh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vceqzh_f16(__p0) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vceqzh_f16(__s0); \
+  __ret; \
+})
+#define vcgeh_f16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (uint16_t) __builtin_neon_vcgeh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vcgezh_f16(__p0) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vcgezh_f16(__s0); \
+  __ret; \
+})
+#define vcgth_f16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (uint16_t) __builtin_neon_vcgth_f16(__s0, __s1); \
+  __ret; \
+})
+#define vcgtzh_f16(__p0) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vcgtzh_f16(__s0); \
+  __ret; \
+})
+#define vcleh_f16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (uint16_t) __builtin_neon_vcleh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vclezh_f16(__p0) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vclezh_f16(__s0); \
+  __ret; \
+})
+#define vclth_f16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (uint16_t) __builtin_neon_vclth_f16(__s0, __s1); \
+  __ret; \
+})
+#define vcltzh_f16(__p0) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vcltzh_f16(__s0); \
+  __ret; \
+})
+#define vcvth_n_s16_f16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vcvth_n_s16_f16(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_n_s32_f16(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vcvth_n_s32_f16(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_n_s64_f16(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vcvth_n_s64_f16(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_n_u16_f16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vcvth_n_u16_f16(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_n_u32_f16(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vcvth_n_u32_f16(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_n_u64_f16(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vcvth_n_u64_f16(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_s16_f16(__p0) __extension__ ({ \
+  int16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vcvth_s16_f16(__s0); \
+  __ret; \
+})
+#define vcvth_s32_f16(__p0) __extension__ ({ \
+  int32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vcvth_s32_f16(__s0); \
+  __ret; \
+})
+#define vcvth_s64_f16(__p0) __extension__ ({ \
+  int64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vcvth_s64_f16(__s0); \
+  __ret; \
+})
+#define vcvth_u16_f16(__p0) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vcvth_u16_f16(__s0); \
+  __ret; \
+})
+#define vcvth_u32_f16(__p0) __extension__ ({ \
+  uint32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vcvth_u32_f16(__s0); \
+  __ret; \
+})
+#define vcvth_u64_f16(__p0) __extension__ ({ \
+  uint64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vcvth_u64_f16(__s0); \
+  __ret; \
+})
+#define vcvtah_s16_f16(__p0) __extension__ ({ \
+  int16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vcvtah_s16_f16(__s0); \
+  __ret; \
+})
+#define vcvtah_s32_f16(__p0) __extension__ ({ \
+  int32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vcvtah_s32_f16(__s0); \
+  __ret; \
+})
+#define vcvtah_s64_f16(__p0) __extension__ ({ \
+  int64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vcvtah_s64_f16(__s0); \
+  __ret; \
+})
+#define vcvtah_u16_f16(__p0) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vcvtah_u16_f16(__s0); \
+  __ret; \
+})
+#define vcvtah_u32_f16(__p0) __extension__ ({ \
+  uint32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vcvtah_u32_f16(__s0); \
+  __ret; \
+})
+#define vcvtah_u64_f16(__p0) __extension__ ({ \
+  uint64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vcvtah_u64_f16(__s0); \
+  __ret; \
+})
+#define vcvth_f16_u16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  uint16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_f16_u16(__s0); \
+  __ret; \
+})
+#define vcvth_f16_s16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  int16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_f16_s16(__s0); \
+  __ret; \
+})
+#define vcvth_f16_u32(__p0) __extension__ ({ \
+  float16_t __ret; \
+  uint32_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_f16_u32(__s0); \
+  __ret; \
+})
+#define vcvth_f16_s32(__p0) __extension__ ({ \
+  float16_t __ret; \
+  int32_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_f16_s32(__s0); \
+  __ret; \
+})
+#define vcvth_f16_u64(__p0) __extension__ ({ \
+  float16_t __ret; \
+  uint64_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_f16_u64(__s0); \
+  __ret; \
+})
+#define vcvth_f16_s64(__p0) __extension__ ({ \
+  float16_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_f16_s64(__s0); \
+  __ret; \
+})
+#define vcvth_n_f16_u32(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  uint32_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_n_f16_u32(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_n_f16_s32(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  int32_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_n_f16_s32(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_n_f16_u64(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  uint64_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_n_f16_u64(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_n_f16_s64(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_n_f16_s64(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_n_f16_u16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  uint16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_n_f16_u16(__s0, __p1); \
+  __ret; \
+})
+#define vcvth_n_f16_s16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  int16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vcvth_n_f16_s16(__s0, __p1); \
+  __ret; \
+})
+#define vcvtmh_s16_f16(__p0) __extension__ ({ \
+  int16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vcvtmh_s16_f16(__s0); \
+  __ret; \
+})
+#define vcvtmh_s32_f16(__p0) __extension__ ({ \
+  int32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vcvtmh_s32_f16(__s0); \
+  __ret; \
+})
+#define vcvtmh_s64_f16(__p0) __extension__ ({ \
+  int64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vcvtmh_s64_f16(__s0); \
+  __ret; \
+})
+#define vcvtmh_u16_f16(__p0) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vcvtmh_u16_f16(__s0); \
+  __ret; \
+})
+#define vcvtmh_u32_f16(__p0) __extension__ ({ \
+  uint32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vcvtmh_u32_f16(__s0); \
+  __ret; \
+})
+#define vcvtmh_u64_f16(__p0) __extension__ ({ \
+  uint64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vcvtmh_u64_f16(__s0); \
+  __ret; \
+})
+#define vcvtnh_s16_f16(__p0) __extension__ ({ \
+  int16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vcvtnh_s16_f16(__s0); \
+  __ret; \
+})
+#define vcvtnh_s32_f16(__p0) __extension__ ({ \
+  int32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vcvtnh_s32_f16(__s0); \
+  __ret; \
+})
+#define vcvtnh_s64_f16(__p0) __extension__ ({ \
+  int64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vcvtnh_s64_f16(__s0); \
+  __ret; \
+})
+#define vcvtnh_u16_f16(__p0) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vcvtnh_u16_f16(__s0); \
+  __ret; \
+})
+#define vcvtnh_u32_f16(__p0) __extension__ ({ \
+  uint32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vcvtnh_u32_f16(__s0); \
+  __ret; \
+})
+#define vcvtnh_u64_f16(__p0) __extension__ ({ \
+  uint64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vcvtnh_u64_f16(__s0); \
+  __ret; \
+})
+#define vcvtph_s16_f16(__p0) __extension__ ({ \
+  int16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vcvtph_s16_f16(__s0); \
+  __ret; \
+})
+#define vcvtph_s32_f16(__p0) __extension__ ({ \
+  int32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vcvtph_s32_f16(__s0); \
+  __ret; \
+})
+#define vcvtph_s64_f16(__p0) __extension__ ({ \
+  int64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vcvtph_s64_f16(__s0); \
+  __ret; \
+})
+#define vcvtph_u16_f16(__p0) __extension__ ({ \
+  uint16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vcvtph_u16_f16(__s0); \
+  __ret; \
+})
+#define vcvtph_u32_f16(__p0) __extension__ ({ \
+  uint32_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vcvtph_u32_f16(__s0); \
+  __ret; \
+})
+#define vcvtph_u64_f16(__p0) __extension__ ({ \
+  uint64_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vcvtph_u64_f16(__s0); \
+  __ret; \
+})
+#define vdivh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vdivh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vfmah_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16_t __s2 = __p2; \
+  __ret = (float16_t) __builtin_neon_vfmah_f16(__s0, __s1, __s2); \
+  __ret; \
+})
+#define vfmsh_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16_t __s2 = __p2; \
+  __ret = (float16_t) __builtin_neon_vfmsh_f16(__s0, __s1, __s2); \
+  __ret; \
+})
+#define vmaxh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vmaxh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vmaxnmh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vmaxnmh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vminh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vminh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vminnmh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vminnmh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vmulh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vmulh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vmulxh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vmulxh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vnegh_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vnegh_f16(__s0); \
+  __ret; \
+})
+#define vrecpeh_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vrecpeh_f16(__s0); \
+  __ret; \
+})
+#define vrecpsh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vrecpsh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vrecpxh_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vrecpxh_f16(__s0); \
+  __ret; \
+})
+#define vrndh_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vrndh_f16(__s0); \
+  __ret; \
+})
+#define vrndah_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vrndah_f16(__s0); \
+  __ret; \
+})
+#define vrndih_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vrndih_f16(__s0); \
+  __ret; \
+})
+#define vrndmh_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vrndmh_f16(__s0); \
+  __ret; \
+})
+#define vrndnh_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vrndnh_f16(__s0); \
+  __ret; \
+})
+#define vrndph_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vrndph_f16(__s0); \
+  __ret; \
+})
+#define vrndxh_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vrndxh_f16(__s0); \
+  __ret; \
+})
+#define vrsqrteh_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vrsqrteh_f16(__s0); \
+  __ret; \
+})
+#define vrsqrtsh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vrsqrtsh_f16(__s0, __s1); \
+  __ret; \
+})
+#define vsqrth_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vsqrth_f16(__s0); \
+  __ret; \
+})
+#define vsubh_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vsubh_f16(__s0, __s1); \
+  __ret; \
+})
+#endif
+
+#undef __ai
+
+#endif /* __ARM_FP16_H */
diff --git a/third_party/aarch64/clang/arm_mve.h b/third_party/aarch64/clang/arm_mve.h
new file mode 100644
index 000000000..4da41dc3c
--- /dev/null
+++ b/third_party/aarch64/clang/arm_mve.h
@@ -0,0 +1,19187 @@
+/*===---- arm_mve.h - ARM MVE intrinsics -----------------------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ARM_MVE_H
+#define __ARM_MVE_H
+
+#if !__ARM_FEATURE_MVE
+#error "MVE support not enabled"
+#endif
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef uint16_t mve_pred16_t;
+typedef __attribute__((__neon_vector_type__(8), __clang_arm_mve_strict_polymorphism)) int16_t int16x8_t;
+typedef struct { int16x8_t val[2]; } int16x8x2_t;
+typedef struct { int16x8_t val[4]; } int16x8x4_t;
+typedef __attribute__((__neon_vector_type__(4), __clang_arm_mve_strict_polymorphism)) int32_t int32x4_t;
+typedef struct { int32x4_t val[2]; } int32x4x2_t;
+typedef struct { int32x4_t val[4]; } int32x4x4_t;
+typedef __attribute__((__neon_vector_type__(2), __clang_arm_mve_strict_polymorphism)) int64_t int64x2_t;
+typedef struct { int64x2_t val[2]; } int64x2x2_t;
+typedef struct { int64x2_t val[4]; } int64x2x4_t;
+typedef __attribute__((__neon_vector_type__(16), __clang_arm_mve_strict_polymorphism)) int8_t int8x16_t;
+typedef struct { int8x16_t val[2]; } int8x16x2_t;
+typedef struct { int8x16_t val[4]; } int8x16x4_t;
+typedef __attribute__((__neon_vector_type__(8), __clang_arm_mve_strict_polymorphism)) uint16_t uint16x8_t;
+typedef struct { uint16x8_t val[2]; } uint16x8x2_t;
+typedef struct { uint16x8_t val[4]; } uint16x8x4_t;
+typedef __attribute__((__neon_vector_type__(4), __clang_arm_mve_strict_polymorphism)) uint32_t uint32x4_t;
+typedef struct { uint32x4_t val[2]; } uint32x4x2_t;
+typedef struct { uint32x4_t val[4]; } uint32x4x4_t;
+typedef __attribute__((__neon_vector_type__(2), __clang_arm_mve_strict_polymorphism)) uint64_t uint64x2_t;
+typedef struct { uint64x2_t val[2]; } uint64x2x2_t;
+typedef struct { uint64x2_t val[4]; } uint64x2x4_t;
+typedef __attribute__((__neon_vector_type__(16), __clang_arm_mve_strict_polymorphism)) uint8_t uint8x16_t;
+typedef struct { uint8x16_t val[2]; } uint8x16x2_t;
+typedef struct { uint8x16_t val[4]; } uint8x16x4_t;
+
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_asrl)))
+int64_t __arm_asrl(int64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_lsll)))
+uint64_t __arm_lsll(uint64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_sqrshr)))
+int32_t __arm_sqrshr(int32_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_sqrshrl)))
+int64_t __arm_sqrshrl(int64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_sqrshrl_sat48)))
+int64_t __arm_sqrshrl_sat48(int64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_sqshl)))
+int32_t __arm_sqshl(int32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_sqshll)))
+int64_t __arm_sqshll(int64_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_srshr)))
+int32_t __arm_srshr(int32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_srshrl)))
+int64_t __arm_srshrl(int64_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_uqrshl)))
+uint32_t __arm_uqrshl(uint32_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_uqrshll)))
+uint64_t __arm_uqrshll(uint64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_uqrshll_sat48)))
+uint64_t __arm_uqrshll_sat48(uint64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_uqshl)))
+uint32_t __arm_uqshl(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_uqshll)))
+uint64_t __arm_uqshll(uint64_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_urshr)))
+uint32_t __arm_urshr(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_urshrl)))
+uint64_t __arm_urshrl(uint64_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s16)))
+uint32_t __arm_vabavq_p_s16(uint32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s16)))
+uint32_t __arm_vabavq_p(uint32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s32)))
+uint32_t __arm_vabavq_p_s32(uint32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s32)))
+uint32_t __arm_vabavq_p(uint32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s8)))
+uint32_t __arm_vabavq_p_s8(uint32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s8)))
+uint32_t __arm_vabavq_p(uint32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u16)))
+uint32_t __arm_vabavq_p_u16(uint32_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u16)))
+uint32_t __arm_vabavq_p(uint32_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u32)))
+uint32_t __arm_vabavq_p_u32(uint32_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u32)))
+uint32_t __arm_vabavq_p(uint32_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u8)))
+uint32_t __arm_vabavq_p_u8(uint32_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u8)))
+uint32_t __arm_vabavq_p(uint32_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s16)))
+uint32_t __arm_vabavq_s16(uint32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s16)))
+uint32_t __arm_vabavq(uint32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s32)))
+uint32_t __arm_vabavq_s32(uint32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s32)))
+uint32_t __arm_vabavq(uint32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s8)))
+uint32_t __arm_vabavq_s8(uint32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s8)))
+uint32_t __arm_vabavq(uint32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u16)))
+uint32_t __arm_vabavq_u16(uint32_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u16)))
+uint32_t __arm_vabavq(uint32_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u32)))
+uint32_t __arm_vabavq_u32(uint32_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u32)))
+uint32_t __arm_vabavq(uint32_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u8)))
+uint32_t __arm_vabavq_u8(uint32_t, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u8)))
+uint32_t __arm_vabavq(uint32_t, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s16)))
+int16x8_t __arm_vabdq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s16)))
+int16x8_t __arm_vabdq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s32)))
+int32x4_t __arm_vabdq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s32)))
+int32x4_t __arm_vabdq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s8)))
+int8x16_t __arm_vabdq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s8)))
+int8x16_t __arm_vabdq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u16)))
+uint16x8_t __arm_vabdq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u16)))
+uint16x8_t __arm_vabdq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u32)))
+uint32x4_t __arm_vabdq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u32)))
+uint32x4_t __arm_vabdq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u8)))
+uint8x16_t __arm_vabdq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u8)))
+uint8x16_t __arm_vabdq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s16)))
+int16x8_t __arm_vabdq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s16)))
+int16x8_t __arm_vabdq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s32)))
+int32x4_t __arm_vabdq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s32)))
+int32x4_t __arm_vabdq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s8)))
+int8x16_t __arm_vabdq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s8)))
+int8x16_t __arm_vabdq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u16)))
+uint16x8_t __arm_vabdq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u16)))
+uint16x8_t __arm_vabdq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u32)))
+uint32x4_t __arm_vabdq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u32)))
+uint32x4_t __arm_vabdq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u8)))
+uint8x16_t __arm_vabdq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u8)))
+uint8x16_t __arm_vabdq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s16)))
+int16x8_t __arm_vabdq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s16)))
+int16x8_t __arm_vabdq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s32)))
+int32x4_t __arm_vabdq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s32)))
+int32x4_t __arm_vabdq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s8)))
+int8x16_t __arm_vabdq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s8)))
+int8x16_t __arm_vabdq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u16)))
+uint16x8_t __arm_vabdq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u16)))
+uint16x8_t __arm_vabdq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u32)))
+uint32x4_t __arm_vabdq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u32)))
+uint32x4_t __arm_vabdq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u8)))
+uint8x16_t __arm_vabdq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u8)))
+uint8x16_t __arm_vabdq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s16)))
+int16x8_t __arm_vabsq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s16)))
+int16x8_t __arm_vabsq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s32)))
+int32x4_t __arm_vabsq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s32)))
+int32x4_t __arm_vabsq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s8)))
+int8x16_t __arm_vabsq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s8)))
+int8x16_t __arm_vabsq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s16)))
+int16x8_t __arm_vabsq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s16)))
+int16x8_t __arm_vabsq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s32)))
+int32x4_t __arm_vabsq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s32)))
+int32x4_t __arm_vabsq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s8)))
+int8x16_t __arm_vabsq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s8)))
+int8x16_t __arm_vabsq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s16)))
+int16x8_t __arm_vabsq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s16)))
+int16x8_t __arm_vabsq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s32)))
+int32x4_t __arm_vabsq_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s32)))
+int32x4_t __arm_vabsq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s8)))
+int8x16_t __arm_vabsq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s8)))
+int8x16_t __arm_vabsq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadciq_m_s32)))
+int32x4_t __arm_vadciq_m_s32(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadciq_m_s32)))
+int32x4_t __arm_vadciq_m(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadciq_m_u32)))
+uint32x4_t __arm_vadciq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadciq_m_u32)))
+uint32x4_t __arm_vadciq_m(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadciq_s32)))
+int32x4_t __arm_vadciq_s32(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadciq_s32)))
+int32x4_t __arm_vadciq(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadciq_u32)))
+uint32x4_t __arm_vadciq_u32(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadciq_u32)))
+uint32x4_t __arm_vadciq(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadcq_m_s32)))
+int32x4_t __arm_vadcq_m_s32(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadcq_m_s32)))
+int32x4_t __arm_vadcq_m(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadcq_m_u32)))
+uint32x4_t __arm_vadcq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadcq_m_u32)))
+uint32x4_t __arm_vadcq_m(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadcq_s32)))
+int32x4_t __arm_vadcq_s32(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadcq_s32)))
+int32x4_t __arm_vadcq(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadcq_u32)))
+uint32x4_t __arm_vadcq_u32(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadcq_u32)))
+uint32x4_t __arm_vadcq(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_p_s32)))
+int64_t __arm_vaddlvaq_p_s32(int64_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_p_s32)))
+int64_t __arm_vaddlvaq_p(int64_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_p_u32)))
+uint64_t __arm_vaddlvaq_p_u32(uint64_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_p_u32)))
+uint64_t __arm_vaddlvaq_p(uint64_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_s32)))
+int64_t __arm_vaddlvaq_s32(int64_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_s32)))
+int64_t __arm_vaddlvaq(int64_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_u32)))
+uint64_t __arm_vaddlvaq_u32(uint64_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_u32)))
+uint64_t __arm_vaddlvaq(uint64_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_p_s32)))
+int64_t __arm_vaddlvq_p_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_p_s32)))
+int64_t __arm_vaddlvq_p(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_p_u32)))
+uint64_t __arm_vaddlvq_p_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_p_u32)))
+uint64_t __arm_vaddlvq_p(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_s32)))
+int64_t __arm_vaddlvq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_s32)))
+int64_t __arm_vaddlvq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_u32)))
+uint64_t __arm_vaddlvq_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_u32)))
+uint64_t __arm_vaddlvq(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s16)))
+int16x8_t __arm_vaddq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s16)))
+int16x8_t __arm_vaddq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s32)))
+int32x4_t __arm_vaddq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s32)))
+int32x4_t __arm_vaddq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s8)))
+int8x16_t __arm_vaddq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s8)))
+int8x16_t __arm_vaddq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u16)))
+uint16x8_t __arm_vaddq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u16)))
+uint16x8_t __arm_vaddq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u32)))
+uint32x4_t __arm_vaddq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u32)))
+uint32x4_t __arm_vaddq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u8)))
+uint8x16_t __arm_vaddq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u8)))
+uint8x16_t __arm_vaddq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s16)))
+int16x8_t __arm_vaddq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s16)))
+int16x8_t __arm_vaddq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s32)))
+int32x4_t __arm_vaddq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s32)))
+int32x4_t __arm_vaddq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s8)))
+int8x16_t __arm_vaddq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s8)))
+int8x16_t __arm_vaddq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u16)))
+uint16x8_t __arm_vaddq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u16)))
+uint16x8_t __arm_vaddq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u32)))
+uint32x4_t __arm_vaddq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u32)))
+uint32x4_t __arm_vaddq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u8)))
+uint8x16_t __arm_vaddq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u8)))
+uint8x16_t __arm_vaddq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s16)))
+int16x8_t __arm_vaddq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s16)))
+int16x8_t __arm_vaddq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s32)))
+int32x4_t __arm_vaddq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s32)))
+int32x4_t __arm_vaddq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s8)))
+int8x16_t __arm_vaddq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s8)))
+int8x16_t __arm_vaddq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u16)))
+uint16x8_t __arm_vaddq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u16)))
+uint16x8_t __arm_vaddq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u32)))
+uint32x4_t __arm_vaddq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u32)))
+uint32x4_t __arm_vaddq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u8)))
+uint8x16_t __arm_vaddq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u8)))
+uint8x16_t __arm_vaddq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s16)))
+int16x8_t __arm_vaddq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s16)))
+int16x8_t __arm_vaddq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s32)))
+int32x4_t __arm_vaddq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s32)))
+int32x4_t __arm_vaddq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s8)))
+int8x16_t __arm_vaddq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s8)))
+int8x16_t __arm_vaddq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u16)))
+uint16x8_t __arm_vaddq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u16)))
+uint16x8_t __arm_vaddq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u32)))
+uint32x4_t __arm_vaddq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u32)))
+uint32x4_t __arm_vaddq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u8)))
+uint8x16_t __arm_vaddq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u8)))
+uint8x16_t __arm_vaddq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s16)))
+int16x8_t __arm_vaddq_x_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s16)))
+int16x8_t __arm_vaddq_x(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s32)))
+int32x4_t __arm_vaddq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s32)))
+int32x4_t __arm_vaddq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s8)))
+int8x16_t __arm_vaddq_x_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s8)))
+int8x16_t __arm_vaddq_x(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u16)))
+uint16x8_t __arm_vaddq_x_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u16)))
+uint16x8_t __arm_vaddq_x(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u32)))
+uint32x4_t __arm_vaddq_x_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u32)))
+uint32x4_t __arm_vaddq_x(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u8)))
+uint8x16_t __arm_vaddq_x_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u8)))
+uint8x16_t __arm_vaddq_x(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s16)))
+int16x8_t __arm_vaddq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s16)))
+int16x8_t __arm_vaddq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s32)))
+int32x4_t __arm_vaddq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s32)))
+int32x4_t __arm_vaddq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s8)))
+int8x16_t __arm_vaddq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s8)))
+int8x16_t __arm_vaddq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u16)))
+uint16x8_t __arm_vaddq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u16)))
+uint16x8_t __arm_vaddq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u32)))
+uint32x4_t __arm_vaddq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u32)))
+uint32x4_t __arm_vaddq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u8)))
+uint8x16_t __arm_vaddq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u8)))
+uint8x16_t __arm_vaddq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s16)))
+int32_t __arm_vaddvaq_p_s16(int32_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s16)))
+int32_t __arm_vaddvaq_p(int32_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s32)))
+int32_t __arm_vaddvaq_p_s32(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s32)))
+int32_t __arm_vaddvaq_p(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s8)))
+int32_t __arm_vaddvaq_p_s8(int32_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s8)))
+int32_t __arm_vaddvaq_p(int32_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u16)))
+uint32_t __arm_vaddvaq_p_u16(uint32_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u16)))
+uint32_t __arm_vaddvaq_p(uint32_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u32)))
+uint32_t __arm_vaddvaq_p_u32(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u32)))
+uint32_t __arm_vaddvaq_p(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u8)))
+uint32_t __arm_vaddvaq_p_u8(uint32_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u8)))
+uint32_t __arm_vaddvaq_p(uint32_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s16)))
+int32_t __arm_vaddvaq_s16(int32_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s16)))
+int32_t __arm_vaddvaq(int32_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s32)))
+int32_t __arm_vaddvaq_s32(int32_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s32)))
+int32_t __arm_vaddvaq(int32_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s8)))
+int32_t __arm_vaddvaq_s8(int32_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s8)))
+int32_t __arm_vaddvaq(int32_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u16)))
+uint32_t __arm_vaddvaq_u16(uint32_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u16)))
+uint32_t __arm_vaddvaq(uint32_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u32)))
+uint32_t __arm_vaddvaq_u32(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u32)))
+uint32_t __arm_vaddvaq(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u8)))
+uint32_t __arm_vaddvaq_u8(uint32_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u8)))
+uint32_t __arm_vaddvaq(uint32_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s16)))
+int32_t __arm_vaddvq_p_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s16)))
+int32_t __arm_vaddvq_p(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s32)))
+int32_t __arm_vaddvq_p_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s32)))
+int32_t __arm_vaddvq_p(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s8)))
+int32_t __arm_vaddvq_p_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s8)))
+int32_t __arm_vaddvq_p(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u16)))
+uint32_t __arm_vaddvq_p_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u16)))
+uint32_t __arm_vaddvq_p(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u32)))
+uint32_t __arm_vaddvq_p_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u32)))
+uint32_t __arm_vaddvq_p(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u8)))
+uint32_t __arm_vaddvq_p_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u8)))
+uint32_t __arm_vaddvq_p(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s16)))
+int32_t __arm_vaddvq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s16)))
+int32_t __arm_vaddvq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s32)))
+int32_t __arm_vaddvq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s32)))
+int32_t __arm_vaddvq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s8)))
+int32_t __arm_vaddvq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s8)))
+int32_t __arm_vaddvq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u16)))
+uint32_t __arm_vaddvq_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u16)))
+uint32_t __arm_vaddvq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u32)))
+uint32_t __arm_vaddvq_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u32)))
+uint32_t __arm_vaddvq(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u8)))
+uint32_t __arm_vaddvq_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u8)))
+uint32_t __arm_vaddvq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s16)))
+int16x8_t __arm_vandq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s16)))
+int16x8_t __arm_vandq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s32)))
+int32x4_t __arm_vandq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s32)))
+int32x4_t __arm_vandq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s8)))
+int8x16_t __arm_vandq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s8)))
+int8x16_t __arm_vandq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u16)))
+uint16x8_t __arm_vandq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u16)))
+uint16x8_t __arm_vandq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u32)))
+uint32x4_t __arm_vandq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u32)))
+uint32x4_t __arm_vandq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u8)))
+uint8x16_t __arm_vandq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u8)))
+uint8x16_t __arm_vandq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_s16)))
+int16x8_t __arm_vandq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_s16)))
+int16x8_t __arm_vandq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_s32)))
+int32x4_t __arm_vandq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_s32)))
+int32x4_t __arm_vandq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_s8)))
+int8x16_t __arm_vandq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_s8)))
+int8x16_t __arm_vandq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_u16)))
+uint16x8_t __arm_vandq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_u16)))
+uint16x8_t __arm_vandq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_u32)))
+uint32x4_t __arm_vandq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_u32)))
+uint32x4_t __arm_vandq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_u8)))
+uint8x16_t __arm_vandq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_u8)))
+uint8x16_t __arm_vandq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s16)))
+int16x8_t __arm_vandq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s16)))
+int16x8_t __arm_vandq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s32)))
+int32x4_t __arm_vandq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s32)))
+int32x4_t __arm_vandq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s8)))
+int8x16_t __arm_vandq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s8)))
+int8x16_t __arm_vandq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u16)))
+uint16x8_t __arm_vandq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u16)))
+uint16x8_t __arm_vandq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u32)))
+uint32x4_t __arm_vandq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u32)))
+uint32x4_t __arm_vandq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u8)))
+uint8x16_t __arm_vandq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u8)))
+uint8x16_t __arm_vandq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_s16)))
+int16x8_t __arm_vbicq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_s16)))
+int16x8_t __arm_vbicq_m_n(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_s32)))
+int32x4_t __arm_vbicq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_s32)))
+int32x4_t __arm_vbicq_m_n(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_u16)))
+uint16x8_t __arm_vbicq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_u16)))
+uint16x8_t __arm_vbicq_m_n(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_u32)))
+uint32x4_t __arm_vbicq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_u32)))
+uint32x4_t __arm_vbicq_m_n(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s16)))
+int16x8_t __arm_vbicq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s16)))
+int16x8_t __arm_vbicq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s32)))
+int32x4_t __arm_vbicq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s32)))
+int32x4_t __arm_vbicq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s8)))
+int8x16_t __arm_vbicq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s8)))
+int8x16_t __arm_vbicq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u16)))
+uint16x8_t __arm_vbicq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u16)))
+uint16x8_t __arm_vbicq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u32)))
+uint32x4_t __arm_vbicq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u32)))
+uint32x4_t __arm_vbicq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u8)))
+uint8x16_t __arm_vbicq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u8)))
+uint8x16_t __arm_vbicq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_s16)))
+int16x8_t __arm_vbicq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_s16)))
+int16x8_t __arm_vbicq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_s32)))
+int32x4_t __arm_vbicq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_s32)))
+int32x4_t __arm_vbicq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_u16)))
+uint16x8_t __arm_vbicq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_u16)))
+uint16x8_t __arm_vbicq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_u32)))
+uint32x4_t __arm_vbicq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_u32)))
+uint32x4_t __arm_vbicq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s16)))
+int16x8_t __arm_vbicq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s16)))
+int16x8_t __arm_vbicq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s32)))
+int32x4_t __arm_vbicq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s32)))
+int32x4_t __arm_vbicq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s8)))
+int8x16_t __arm_vbicq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s8)))
+int8x16_t __arm_vbicq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u16)))
+uint16x8_t __arm_vbicq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u16)))
+uint16x8_t __arm_vbicq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u32)))
+uint32x4_t __arm_vbicq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u32)))
+uint32x4_t __arm_vbicq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u8)))
+uint8x16_t __arm_vbicq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u8)))
+uint8x16_t __arm_vbicq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s16)))
+int16x8_t __arm_vbicq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s16)))
+int16x8_t __arm_vbicq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s32)))
+int32x4_t __arm_vbicq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s32)))
+int32x4_t __arm_vbicq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s8)))
+int8x16_t __arm_vbicq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s8)))
+int8x16_t __arm_vbicq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u16)))
+uint16x8_t __arm_vbicq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u16)))
+uint16x8_t __arm_vbicq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u32)))
+uint32x4_t __arm_vbicq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u32)))
+uint32x4_t __arm_vbicq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u8)))
+uint8x16_t __arm_vbicq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u8)))
+uint8x16_t __arm_vbicq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s16)))
+int16x8_t __arm_vbrsrq_m_n_s16(int16x8_t, int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s16)))
+int16x8_t __arm_vbrsrq_m(int16x8_t, int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s32)))
+int32x4_t __arm_vbrsrq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s32)))
+int32x4_t __arm_vbrsrq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s8)))
+int8x16_t __arm_vbrsrq_m_n_s8(int8x16_t, int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s8)))
+int8x16_t __arm_vbrsrq_m(int8x16_t, int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u16)))
+uint16x8_t __arm_vbrsrq_m_n_u16(uint16x8_t, uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u16)))
+uint16x8_t __arm_vbrsrq_m(uint16x8_t, uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u32)))
+uint32x4_t __arm_vbrsrq_m_n_u32(uint32x4_t, uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u32)))
+uint32x4_t __arm_vbrsrq_m(uint32x4_t, uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u8)))
+uint8x16_t __arm_vbrsrq_m_n_u8(uint8x16_t, uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u8)))
+uint8x16_t __arm_vbrsrq_m(uint8x16_t, uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s16)))
+int16x8_t __arm_vbrsrq_n_s16(int16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s16)))
+int16x8_t __arm_vbrsrq(int16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s32)))
+int32x4_t __arm_vbrsrq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s32)))
+int32x4_t __arm_vbrsrq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s8)))
+int8x16_t __arm_vbrsrq_n_s8(int8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s8)))
+int8x16_t __arm_vbrsrq(int8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u16)))
+uint16x8_t __arm_vbrsrq_n_u16(uint16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u16)))
+uint16x8_t __arm_vbrsrq(uint16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u32)))
+uint32x4_t __arm_vbrsrq_n_u32(uint32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u32)))
+uint32x4_t __arm_vbrsrq(uint32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u8)))
+uint8x16_t __arm_vbrsrq_n_u8(uint8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u8)))
+uint8x16_t __arm_vbrsrq(uint8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s16)))
+int16x8_t __arm_vbrsrq_x_n_s16(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s16)))
+int16x8_t __arm_vbrsrq_x(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s32)))
+int32x4_t __arm_vbrsrq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s32)))
+int32x4_t __arm_vbrsrq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s8)))
+int8x16_t __arm_vbrsrq_x_n_s8(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s8)))
+int8x16_t __arm_vbrsrq_x(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u16)))
+uint16x8_t __arm_vbrsrq_x_n_u16(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u16)))
+uint16x8_t __arm_vbrsrq_x(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u32)))
+uint32x4_t __arm_vbrsrq_x_n_u32(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u32)))
+uint32x4_t __arm_vbrsrq_x(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u8)))
+uint8x16_t __arm_vbrsrq_x_n_u8(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u8)))
+uint8x16_t __arm_vbrsrq_x(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s16)))
+int16x8_t __arm_vcaddq_rot270_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s16)))
+int16x8_t __arm_vcaddq_rot270_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s32)))
+int32x4_t __arm_vcaddq_rot270_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s32)))
+int32x4_t __arm_vcaddq_rot270_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s8)))
+int8x16_t __arm_vcaddq_rot270_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s8)))
+int8x16_t __arm_vcaddq_rot270_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u16)))
+uint16x8_t __arm_vcaddq_rot270_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u16)))
+uint16x8_t __arm_vcaddq_rot270_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u32)))
+uint32x4_t __arm_vcaddq_rot270_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u32)))
+uint32x4_t __arm_vcaddq_rot270_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u8)))
+uint8x16_t __arm_vcaddq_rot270_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u8)))
+uint8x16_t __arm_vcaddq_rot270_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s16)))
+int16x8_t __arm_vcaddq_rot270_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s16)))
+int16x8_t __arm_vcaddq_rot270(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s32)))
+int32x4_t __arm_vcaddq_rot270_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s32)))
+int32x4_t __arm_vcaddq_rot270(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s8)))
+int8x16_t __arm_vcaddq_rot270_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s8)))
+int8x16_t __arm_vcaddq_rot270(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u16)))
+uint16x8_t __arm_vcaddq_rot270_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u16)))
+uint16x8_t __arm_vcaddq_rot270(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u32)))
+uint32x4_t __arm_vcaddq_rot270_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u32)))
+uint32x4_t __arm_vcaddq_rot270(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u8)))
+uint8x16_t __arm_vcaddq_rot270_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u8)))
+uint8x16_t __arm_vcaddq_rot270(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s16)))
+int16x8_t __arm_vcaddq_rot270_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s16)))
+int16x8_t __arm_vcaddq_rot270_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s32)))
+int32x4_t __arm_vcaddq_rot270_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s32)))
+int32x4_t __arm_vcaddq_rot270_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s8)))
+int8x16_t __arm_vcaddq_rot270_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s8)))
+int8x16_t __arm_vcaddq_rot270_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u16)))
+uint16x8_t __arm_vcaddq_rot270_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u16)))
+uint16x8_t __arm_vcaddq_rot270_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u32)))
+uint32x4_t __arm_vcaddq_rot270_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u32)))
+uint32x4_t __arm_vcaddq_rot270_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u8)))
+uint8x16_t __arm_vcaddq_rot270_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u8)))
+uint8x16_t __arm_vcaddq_rot270_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s16)))
+int16x8_t __arm_vcaddq_rot90_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s16)))
+int16x8_t __arm_vcaddq_rot90_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s32)))
+int32x4_t __arm_vcaddq_rot90_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s32)))
+int32x4_t __arm_vcaddq_rot90_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s8)))
+int8x16_t __arm_vcaddq_rot90_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s8)))
+int8x16_t __arm_vcaddq_rot90_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u16)))
+uint16x8_t __arm_vcaddq_rot90_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u16)))
+uint16x8_t __arm_vcaddq_rot90_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u32)))
+uint32x4_t __arm_vcaddq_rot90_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u32)))
+uint32x4_t __arm_vcaddq_rot90_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u8)))
+uint8x16_t __arm_vcaddq_rot90_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u8)))
+uint8x16_t __arm_vcaddq_rot90_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s16)))
+int16x8_t __arm_vcaddq_rot90_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s16)))
+int16x8_t __arm_vcaddq_rot90(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s32)))
+int32x4_t __arm_vcaddq_rot90_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s32)))
+int32x4_t __arm_vcaddq_rot90(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s8)))
+int8x16_t __arm_vcaddq_rot90_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s8)))
+int8x16_t __arm_vcaddq_rot90(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u16)))
+uint16x8_t __arm_vcaddq_rot90_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u16)))
+uint16x8_t __arm_vcaddq_rot90(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u32)))
+uint32x4_t __arm_vcaddq_rot90_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u32)))
+uint32x4_t __arm_vcaddq_rot90(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u8)))
+uint8x16_t __arm_vcaddq_rot90_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u8)))
+uint8x16_t __arm_vcaddq_rot90(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s16)))
+int16x8_t __arm_vcaddq_rot90_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s16)))
+int16x8_t __arm_vcaddq_rot90_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s32)))
+int32x4_t __arm_vcaddq_rot90_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s32)))
+int32x4_t __arm_vcaddq_rot90_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s8)))
+int8x16_t __arm_vcaddq_rot90_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s8)))
+int8x16_t __arm_vcaddq_rot90_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u16)))
+uint16x8_t __arm_vcaddq_rot90_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u16)))
+uint16x8_t __arm_vcaddq_rot90_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u32)))
+uint32x4_t __arm_vcaddq_rot90_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u32)))
+uint32x4_t __arm_vcaddq_rot90_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u8)))
+uint8x16_t __arm_vcaddq_rot90_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u8)))
+uint8x16_t __arm_vcaddq_rot90_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s16)))
+int16x8_t __arm_vclsq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s16)))
+int16x8_t __arm_vclsq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s32)))
+int32x4_t __arm_vclsq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s32)))
+int32x4_t __arm_vclsq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s8)))
+int8x16_t __arm_vclsq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s8)))
+int8x16_t __arm_vclsq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s16)))
+int16x8_t __arm_vclsq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s16)))
+int16x8_t __arm_vclsq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s32)))
+int32x4_t __arm_vclsq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s32)))
+int32x4_t __arm_vclsq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s8)))
+int8x16_t __arm_vclsq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s8)))
+int8x16_t __arm_vclsq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s16)))
+int16x8_t __arm_vclsq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s16)))
+int16x8_t __arm_vclsq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s32)))
+int32x4_t __arm_vclsq_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s32)))
+int32x4_t __arm_vclsq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s8)))
+int8x16_t __arm_vclsq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s8)))
+int8x16_t __arm_vclsq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s16)))
+int16x8_t __arm_vclzq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s16)))
+int16x8_t __arm_vclzq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s32)))
+int32x4_t __arm_vclzq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s32)))
+int32x4_t __arm_vclzq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s8)))
+int8x16_t __arm_vclzq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s8)))
+int8x16_t __arm_vclzq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u16)))
+uint16x8_t __arm_vclzq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u16)))
+uint16x8_t __arm_vclzq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u32)))
+uint32x4_t __arm_vclzq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u32)))
+uint32x4_t __arm_vclzq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u8)))
+uint8x16_t __arm_vclzq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u8)))
+uint8x16_t __arm_vclzq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s16)))
+int16x8_t __arm_vclzq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s16)))
+int16x8_t __arm_vclzq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s32)))
+int32x4_t __arm_vclzq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s32)))
+int32x4_t __arm_vclzq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s8)))
+int8x16_t __arm_vclzq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s8)))
+int8x16_t __arm_vclzq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u16)))
+uint16x8_t __arm_vclzq_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u16)))
+uint16x8_t __arm_vclzq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u32)))
+uint32x4_t __arm_vclzq_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u32)))
+uint32x4_t __arm_vclzq(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u8)))
+uint8x16_t __arm_vclzq_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u8)))
+uint8x16_t __arm_vclzq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s16)))
+int16x8_t __arm_vclzq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s16)))
+int16x8_t __arm_vclzq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s32)))
+int32x4_t __arm_vclzq_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s32)))
+int32x4_t __arm_vclzq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s8)))
+int8x16_t __arm_vclzq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s8)))
+int8x16_t __arm_vclzq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u16)))
+uint16x8_t __arm_vclzq_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u16)))
+uint16x8_t __arm_vclzq_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u32)))
+uint32x4_t __arm_vclzq_x_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u32)))
+uint32x4_t __arm_vclzq_x(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u8)))
+uint8x16_t __arm_vclzq_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u8)))
+uint8x16_t __arm_vclzq_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u16)))
+mve_pred16_t __arm_vcmpcsq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u16)))
+mve_pred16_t __arm_vcmpcsq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u32)))
+mve_pred16_t __arm_vcmpcsq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u32)))
+mve_pred16_t __arm_vcmpcsq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u8)))
+mve_pred16_t __arm_vcmpcsq_m_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u8)))
+mve_pred16_t __arm_vcmpcsq_m(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u16)))
+mve_pred16_t __arm_vcmpcsq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u16)))
+mve_pred16_t __arm_vcmpcsq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u32)))
+mve_pred16_t __arm_vcmpcsq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u32)))
+mve_pred16_t __arm_vcmpcsq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u8)))
+mve_pred16_t __arm_vcmpcsq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u8)))
+mve_pred16_t __arm_vcmpcsq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u16)))
+mve_pred16_t __arm_vcmpcsq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u16)))
+mve_pred16_t __arm_vcmpcsq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u32)))
+mve_pred16_t __arm_vcmpcsq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u32)))
+mve_pred16_t __arm_vcmpcsq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u8)))
+mve_pred16_t __arm_vcmpcsq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u8)))
+mve_pred16_t __arm_vcmpcsq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u16)))
+mve_pred16_t __arm_vcmpcsq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u16)))
+mve_pred16_t __arm_vcmpcsq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u32)))
+mve_pred16_t __arm_vcmpcsq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u32)))
+mve_pred16_t __arm_vcmpcsq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u8)))
+mve_pred16_t __arm_vcmpcsq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u8)))
+mve_pred16_t __arm_vcmpcsq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s16)))
+mve_pred16_t __arm_vcmpeqq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s16)))
+mve_pred16_t __arm_vcmpeqq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s32)))
+mve_pred16_t __arm_vcmpeqq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s32)))
+mve_pred16_t __arm_vcmpeqq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s8)))
+mve_pred16_t __arm_vcmpeqq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s8)))
+mve_pred16_t __arm_vcmpeqq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u16)))
+mve_pred16_t __arm_vcmpeqq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u16)))
+mve_pred16_t __arm_vcmpeqq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u32)))
+mve_pred16_t __arm_vcmpeqq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u32)))
+mve_pred16_t __arm_vcmpeqq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u8)))
+mve_pred16_t __arm_vcmpeqq_m_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u8)))
+mve_pred16_t __arm_vcmpeqq_m(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s16)))
+mve_pred16_t __arm_vcmpeqq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s16)))
+mve_pred16_t __arm_vcmpeqq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s32)))
+mve_pred16_t __arm_vcmpeqq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s32)))
+mve_pred16_t __arm_vcmpeqq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s8)))
+mve_pred16_t __arm_vcmpeqq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s8)))
+mve_pred16_t __arm_vcmpeqq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u16)))
+mve_pred16_t __arm_vcmpeqq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u16)))
+mve_pred16_t __arm_vcmpeqq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u32)))
+mve_pred16_t __arm_vcmpeqq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u32)))
+mve_pred16_t __arm_vcmpeqq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u8)))
+mve_pred16_t __arm_vcmpeqq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u8)))
+mve_pred16_t __arm_vcmpeqq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s16)))
+mve_pred16_t __arm_vcmpeqq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s16)))
+mve_pred16_t __arm_vcmpeqq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s32)))
+mve_pred16_t __arm_vcmpeqq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s32)))
+mve_pred16_t __arm_vcmpeqq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s8)))
+mve_pred16_t __arm_vcmpeqq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s8)))
+mve_pred16_t __arm_vcmpeqq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u16)))
+mve_pred16_t __arm_vcmpeqq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u16)))
+mve_pred16_t __arm_vcmpeqq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u32)))
+mve_pred16_t __arm_vcmpeqq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u32)))
+mve_pred16_t __arm_vcmpeqq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u8)))
+mve_pred16_t __arm_vcmpeqq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u8)))
+mve_pred16_t __arm_vcmpeqq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s16)))
+mve_pred16_t __arm_vcmpeqq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s16)))
+mve_pred16_t __arm_vcmpeqq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s32)))
+mve_pred16_t __arm_vcmpeqq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s32)))
+mve_pred16_t __arm_vcmpeqq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s8)))
+mve_pred16_t __arm_vcmpeqq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s8)))
+mve_pred16_t __arm_vcmpeqq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u16)))
+mve_pred16_t __arm_vcmpeqq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u16)))
+mve_pred16_t __arm_vcmpeqq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u32)))
+mve_pred16_t __arm_vcmpeqq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u32)))
+mve_pred16_t __arm_vcmpeqq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u8)))
+mve_pred16_t __arm_vcmpeqq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u8)))
+mve_pred16_t __arm_vcmpeqq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s16)))
+mve_pred16_t __arm_vcmpgeq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s16)))
+mve_pred16_t __arm_vcmpgeq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s32)))
+mve_pred16_t __arm_vcmpgeq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s32)))
+mve_pred16_t __arm_vcmpgeq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s8)))
+mve_pred16_t __arm_vcmpgeq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s8)))
+mve_pred16_t __arm_vcmpgeq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s16)))
+mve_pred16_t __arm_vcmpgeq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s16)))
+mve_pred16_t __arm_vcmpgeq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s32)))
+mve_pred16_t __arm_vcmpgeq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s32)))
+mve_pred16_t __arm_vcmpgeq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s8)))
+mve_pred16_t __arm_vcmpgeq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s8)))
+mve_pred16_t __arm_vcmpgeq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s16)))
+mve_pred16_t __arm_vcmpgeq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s16)))
+mve_pred16_t __arm_vcmpgeq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s32)))
+mve_pred16_t __arm_vcmpgeq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s32)))
+mve_pred16_t __arm_vcmpgeq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s8)))
+mve_pred16_t __arm_vcmpgeq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s8)))
+mve_pred16_t __arm_vcmpgeq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s16)))
+mve_pred16_t __arm_vcmpgeq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s16)))
+mve_pred16_t __arm_vcmpgeq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s32)))
+mve_pred16_t __arm_vcmpgeq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s32)))
+mve_pred16_t __arm_vcmpgeq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s8)))
+mve_pred16_t __arm_vcmpgeq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s8)))
+mve_pred16_t __arm_vcmpgeq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s16)))
+mve_pred16_t __arm_vcmpgtq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s16)))
+mve_pred16_t __arm_vcmpgtq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s32)))
+mve_pred16_t __arm_vcmpgtq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s32)))
+mve_pred16_t __arm_vcmpgtq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s8)))
+mve_pred16_t __arm_vcmpgtq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s8)))
+mve_pred16_t __arm_vcmpgtq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s16)))
+mve_pred16_t __arm_vcmpgtq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s16)))
+mve_pred16_t __arm_vcmpgtq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s32)))
+mve_pred16_t __arm_vcmpgtq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s32)))
+mve_pred16_t __arm_vcmpgtq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s8)))
+mve_pred16_t __arm_vcmpgtq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s8)))
+mve_pred16_t __arm_vcmpgtq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s16)))
+mve_pred16_t __arm_vcmpgtq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s16)))
+mve_pred16_t __arm_vcmpgtq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s32)))
+mve_pred16_t __arm_vcmpgtq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s32)))
+mve_pred16_t __arm_vcmpgtq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s8)))
+mve_pred16_t __arm_vcmpgtq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s8)))
+mve_pred16_t __arm_vcmpgtq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s16)))
+mve_pred16_t __arm_vcmpgtq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s16)))
+mve_pred16_t __arm_vcmpgtq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s32)))
+mve_pred16_t __arm_vcmpgtq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s32)))
+mve_pred16_t __arm_vcmpgtq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s8)))
+mve_pred16_t __arm_vcmpgtq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s8)))
+mve_pred16_t __arm_vcmpgtq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u16)))
+mve_pred16_t __arm_vcmphiq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u16)))
+mve_pred16_t __arm_vcmphiq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u32)))
+mve_pred16_t __arm_vcmphiq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u32)))
+mve_pred16_t __arm_vcmphiq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u8)))
+mve_pred16_t __arm_vcmphiq_m_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u8)))
+mve_pred16_t __arm_vcmphiq_m(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u16)))
+mve_pred16_t __arm_vcmphiq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u16)))
+mve_pred16_t __arm_vcmphiq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u32)))
+mve_pred16_t __arm_vcmphiq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u32)))
+mve_pred16_t __arm_vcmphiq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u8)))
+mve_pred16_t __arm_vcmphiq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u8)))
+mve_pred16_t __arm_vcmphiq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u16)))
+mve_pred16_t __arm_vcmphiq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u16)))
+mve_pred16_t __arm_vcmphiq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u32)))
+mve_pred16_t __arm_vcmphiq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u32)))
+mve_pred16_t __arm_vcmphiq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u8)))
+mve_pred16_t __arm_vcmphiq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u8)))
+mve_pred16_t __arm_vcmphiq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u16)))
+mve_pred16_t __arm_vcmphiq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u16)))
+mve_pred16_t __arm_vcmphiq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u32)))
+mve_pred16_t __arm_vcmphiq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u32)))
+mve_pred16_t __arm_vcmphiq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u8)))
+mve_pred16_t __arm_vcmphiq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u8)))
+mve_pred16_t __arm_vcmphiq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s16)))
+mve_pred16_t __arm_vcmpleq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s16)))
+mve_pred16_t __arm_vcmpleq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s32)))
+mve_pred16_t __arm_vcmpleq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s32)))
+mve_pred16_t __arm_vcmpleq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s8)))
+mve_pred16_t __arm_vcmpleq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s8)))
+mve_pred16_t __arm_vcmpleq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s16)))
+mve_pred16_t __arm_vcmpleq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s16)))
+mve_pred16_t __arm_vcmpleq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s32)))
+mve_pred16_t __arm_vcmpleq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s32)))
+mve_pred16_t __arm_vcmpleq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s8)))
+mve_pred16_t __arm_vcmpleq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s8)))
+mve_pred16_t __arm_vcmpleq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s16)))
+mve_pred16_t __arm_vcmpleq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s16)))
+mve_pred16_t __arm_vcmpleq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s32)))
+mve_pred16_t __arm_vcmpleq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s32)))
+mve_pred16_t __arm_vcmpleq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s8)))
+mve_pred16_t __arm_vcmpleq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s8)))
+mve_pred16_t __arm_vcmpleq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s16)))
+mve_pred16_t __arm_vcmpleq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s16)))
+mve_pred16_t __arm_vcmpleq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s32)))
+mve_pred16_t __arm_vcmpleq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s32)))
+mve_pred16_t __arm_vcmpleq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s8)))
+mve_pred16_t __arm_vcmpleq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s8)))
+mve_pred16_t __arm_vcmpleq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s16)))
+mve_pred16_t __arm_vcmpltq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s16)))
+mve_pred16_t __arm_vcmpltq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s32)))
+mve_pred16_t __arm_vcmpltq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s32)))
+mve_pred16_t __arm_vcmpltq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s8)))
+mve_pred16_t __arm_vcmpltq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s8)))
+mve_pred16_t __arm_vcmpltq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s16)))
+mve_pred16_t __arm_vcmpltq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s16)))
+mve_pred16_t __arm_vcmpltq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s32)))
+mve_pred16_t __arm_vcmpltq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s32)))
+mve_pred16_t __arm_vcmpltq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s8)))
+mve_pred16_t __arm_vcmpltq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s8)))
+mve_pred16_t __arm_vcmpltq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s16)))
+mve_pred16_t __arm_vcmpltq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s16)))
+mve_pred16_t __arm_vcmpltq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s32)))
+mve_pred16_t __arm_vcmpltq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s32)))
+mve_pred16_t __arm_vcmpltq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s8)))
+mve_pred16_t __arm_vcmpltq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s8)))
+mve_pred16_t __arm_vcmpltq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s16)))
+mve_pred16_t __arm_vcmpltq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s16)))
+mve_pred16_t __arm_vcmpltq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s32)))
+mve_pred16_t __arm_vcmpltq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s32)))
+mve_pred16_t __arm_vcmpltq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s8)))
+mve_pred16_t __arm_vcmpltq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s8)))
+mve_pred16_t __arm_vcmpltq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s16)))
+mve_pred16_t __arm_vcmpneq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s16)))
+mve_pred16_t __arm_vcmpneq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s32)))
+mve_pred16_t __arm_vcmpneq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s32)))
+mve_pred16_t __arm_vcmpneq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s8)))
+mve_pred16_t __arm_vcmpneq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s8)))
+mve_pred16_t __arm_vcmpneq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u16)))
+mve_pred16_t __arm_vcmpneq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u16)))
+mve_pred16_t __arm_vcmpneq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u32)))
+mve_pred16_t __arm_vcmpneq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u32)))
+mve_pred16_t __arm_vcmpneq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u8)))
+mve_pred16_t __arm_vcmpneq_m_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u8)))
+mve_pred16_t __arm_vcmpneq_m(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s16)))
+mve_pred16_t __arm_vcmpneq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s16)))
+mve_pred16_t __arm_vcmpneq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s32)))
+mve_pred16_t __arm_vcmpneq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s32)))
+mve_pred16_t __arm_vcmpneq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s8)))
+mve_pred16_t __arm_vcmpneq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s8)))
+mve_pred16_t __arm_vcmpneq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u16)))
+mve_pred16_t __arm_vcmpneq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u16)))
+mve_pred16_t __arm_vcmpneq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u32)))
+mve_pred16_t __arm_vcmpneq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u32)))
+mve_pred16_t __arm_vcmpneq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u8)))
+mve_pred16_t __arm_vcmpneq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u8)))
+mve_pred16_t __arm_vcmpneq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s16)))
+mve_pred16_t __arm_vcmpneq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s16)))
+mve_pred16_t __arm_vcmpneq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s32)))
+mve_pred16_t __arm_vcmpneq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s32)))
+mve_pred16_t __arm_vcmpneq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s8)))
+mve_pred16_t __arm_vcmpneq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s8)))
+mve_pred16_t __arm_vcmpneq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u16)))
+mve_pred16_t __arm_vcmpneq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u16)))
+mve_pred16_t __arm_vcmpneq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u32)))
+mve_pred16_t __arm_vcmpneq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u32)))
+mve_pred16_t __arm_vcmpneq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u8)))
+mve_pred16_t __arm_vcmpneq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u8)))
+mve_pred16_t __arm_vcmpneq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s16)))
+mve_pred16_t __arm_vcmpneq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s16)))
+mve_pred16_t __arm_vcmpneq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s32)))
+mve_pred16_t __arm_vcmpneq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s32)))
+mve_pred16_t __arm_vcmpneq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s8)))
+mve_pred16_t __arm_vcmpneq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s8)))
+mve_pred16_t __arm_vcmpneq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u16)))
+mve_pred16_t __arm_vcmpneq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u16)))
+mve_pred16_t __arm_vcmpneq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u32)))
+mve_pred16_t __arm_vcmpneq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u32)))
+mve_pred16_t __arm_vcmpneq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u8)))
+mve_pred16_t __arm_vcmpneq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u8)))
+mve_pred16_t __arm_vcmpneq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_s16)))
+int16x8_t __arm_vcreateq_s16(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_s32)))
+int32x4_t __arm_vcreateq_s32(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_s64)))
+int64x2_t __arm_vcreateq_s64(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_s8)))
+int8x16_t __arm_vcreateq_s8(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_u16)))
+uint16x8_t __arm_vcreateq_u16(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_u32)))
+uint32x4_t __arm_vcreateq_u32(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_u64)))
+uint64x2_t __arm_vcreateq_u64(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_u8)))
+uint8x16_t __arm_vcreateq_u8(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp16q)))
+mve_pred16_t __arm_vctp16q(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp16q_m)))
+mve_pred16_t __arm_vctp16q_m(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp32q)))
+mve_pred16_t __arm_vctp32q(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp32q_m)))
+mve_pred16_t __arm_vctp32q_m(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp64q)))
+mve_pred16_t __arm_vctp64q(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp64q_m)))
+mve_pred16_t __arm_vctp64q_m(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp8q)))
+mve_pred16_t __arm_vctp8q(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp8q_m)))
+mve_pred16_t __arm_vctp8q_m(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u16)))
+uint16x8_t __arm_vddupq_m_n_u16(uint16x8_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u16)))
+uint16x8_t __arm_vddupq_m(uint16x8_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u32)))
+uint32x4_t __arm_vddupq_m_n_u32(uint32x4_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u32)))
+uint32x4_t __arm_vddupq_m(uint32x4_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u8)))
+uint8x16_t __arm_vddupq_m_n_u8(uint8x16_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u8)))
+uint8x16_t __arm_vddupq_m(uint8x16_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u16)))
+uint16x8_t __arm_vddupq_m_wb_u16(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u16)))
+uint16x8_t __arm_vddupq_m(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u32)))
+uint32x4_t __arm_vddupq_m_wb_u32(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u32)))
+uint32x4_t __arm_vddupq_m(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u8)))
+uint8x16_t __arm_vddupq_m_wb_u8(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u8)))
+uint8x16_t __arm_vddupq_m(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u16)))
+uint16x8_t __arm_vddupq_n_u16(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u16)))
+uint16x8_t __arm_vddupq_u16(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u32)))
+uint32x4_t __arm_vddupq_n_u32(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u32)))
+uint32x4_t __arm_vddupq_u32(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u8)))
+uint8x16_t __arm_vddupq_n_u8(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u8)))
+uint8x16_t __arm_vddupq_u8(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u16)))
+uint16x8_t __arm_vddupq_wb_u16(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u16)))
+uint16x8_t __arm_vddupq_u16(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u32)))
+uint32x4_t __arm_vddupq_wb_u32(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u32)))
+uint32x4_t __arm_vddupq_u32(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u8)))
+uint8x16_t __arm_vddupq_wb_u8(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u8)))
+uint8x16_t __arm_vddupq_u8(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u16)))
+uint16x8_t __arm_vddupq_x_n_u16(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u16)))
+uint16x8_t __arm_vddupq_x_u16(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u32)))
+uint32x4_t __arm_vddupq_x_n_u32(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u32)))
+uint32x4_t __arm_vddupq_x_u32(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u8)))
+uint8x16_t __arm_vddupq_x_n_u8(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u8)))
+uint8x16_t __arm_vddupq_x_u8(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u16)))
+uint16x8_t __arm_vddupq_x_wb_u16(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u16)))
+uint16x8_t __arm_vddupq_x_u16(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u32)))
+uint32x4_t __arm_vddupq_x_wb_u32(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u32)))
+uint32x4_t __arm_vddupq_x_u32(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u8)))
+uint8x16_t __arm_vddupq_x_wb_u8(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u8)))
+uint8x16_t __arm_vddupq_x_u8(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s16)))
+int16x8_t __arm_vdupq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s16)))
+int16x8_t __arm_vdupq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s32)))
+int32x4_t __arm_vdupq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s32)))
+int32x4_t __arm_vdupq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s8)))
+int8x16_t __arm_vdupq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s8)))
+int8x16_t __arm_vdupq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u16)))
+uint16x8_t __arm_vdupq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u16)))
+uint16x8_t __arm_vdupq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u32)))
+uint32x4_t __arm_vdupq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u32)))
+uint32x4_t __arm_vdupq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u8)))
+uint8x16_t __arm_vdupq_m_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u8)))
+uint8x16_t __arm_vdupq_m(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_s16)))
+int16x8_t __arm_vdupq_n_s16(int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_s32)))
+int32x4_t __arm_vdupq_n_s32(int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_s8)))
+int8x16_t __arm_vdupq_n_s8(int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_u16)))
+uint16x8_t __arm_vdupq_n_u16(uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_u32)))
+uint32x4_t __arm_vdupq_n_u32(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_u8)))
+uint8x16_t __arm_vdupq_n_u8(uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_s16)))
+int16x8_t __arm_vdupq_x_n_s16(int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_s32)))
+int32x4_t __arm_vdupq_x_n_s32(int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_s8)))
+int8x16_t __arm_vdupq_x_n_s8(int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_u16)))
+uint16x8_t __arm_vdupq_x_n_u16(uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_u32)))
+uint32x4_t __arm_vdupq_x_n_u32(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_u8)))
+uint8x16_t __arm_vdupq_x_n_u8(uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u16)))
+uint16x8_t __arm_vdwdupq_m_n_u16(uint16x8_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u16)))
+uint16x8_t __arm_vdwdupq_m(uint16x8_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u32)))
+uint32x4_t __arm_vdwdupq_m_n_u32(uint32x4_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u32)))
+uint32x4_t __arm_vdwdupq_m(uint32x4_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u8)))
+uint8x16_t __arm_vdwdupq_m_n_u8(uint8x16_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u8)))
+uint8x16_t __arm_vdwdupq_m(uint8x16_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u16)))
+uint16x8_t __arm_vdwdupq_m_wb_u16(uint16x8_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u16)))
+uint16x8_t __arm_vdwdupq_m(uint16x8_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u32)))
+uint32x4_t __arm_vdwdupq_m_wb_u32(uint32x4_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u32)))
+uint32x4_t __arm_vdwdupq_m(uint32x4_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u8)))
+uint8x16_t __arm_vdwdupq_m_wb_u8(uint8x16_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u8)))
+uint8x16_t __arm_vdwdupq_m(uint8x16_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u16)))
+uint16x8_t __arm_vdwdupq_n_u16(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u16)))
+uint16x8_t __arm_vdwdupq_u16(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u32)))
+uint32x4_t __arm_vdwdupq_n_u32(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u32)))
+uint32x4_t __arm_vdwdupq_u32(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u8)))
+uint8x16_t __arm_vdwdupq_n_u8(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u8)))
+uint8x16_t __arm_vdwdupq_u8(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u16)))
+uint16x8_t __arm_vdwdupq_wb_u16(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u16)))
+uint16x8_t __arm_vdwdupq_u16(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u32)))
+uint32x4_t __arm_vdwdupq_wb_u32(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u32)))
+uint32x4_t __arm_vdwdupq_u32(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u8)))
+uint8x16_t __arm_vdwdupq_wb_u8(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u8)))
+uint8x16_t __arm_vdwdupq_u8(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u16)))
+uint16x8_t __arm_vdwdupq_x_n_u16(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u16)))
+uint16x8_t __arm_vdwdupq_x_u16(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u32)))
+uint32x4_t __arm_vdwdupq_x_n_u32(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u32)))
+uint32x4_t __arm_vdwdupq_x_u32(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u8)))
+uint8x16_t __arm_vdwdupq_x_n_u8(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u8)))
+uint8x16_t __arm_vdwdupq_x_u8(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u16)))
+uint16x8_t __arm_vdwdupq_x_wb_u16(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u16)))
+uint16x8_t __arm_vdwdupq_x_u16(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u32)))
+uint32x4_t __arm_vdwdupq_x_wb_u32(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u32)))
+uint32x4_t __arm_vdwdupq_x_u32(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u8)))
+uint8x16_t __arm_vdwdupq_x_wb_u8(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u8)))
+uint8x16_t __arm_vdwdupq_x_u8(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s16)))
+int16x8_t __arm_veorq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s16)))
+int16x8_t __arm_veorq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s32)))
+int32x4_t __arm_veorq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s32)))
+int32x4_t __arm_veorq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s8)))
+int8x16_t __arm_veorq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s8)))
+int8x16_t __arm_veorq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u16)))
+uint16x8_t __arm_veorq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u16)))
+uint16x8_t __arm_veorq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u32)))
+uint32x4_t __arm_veorq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u32)))
+uint32x4_t __arm_veorq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u8)))
+uint8x16_t __arm_veorq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u8)))
+uint8x16_t __arm_veorq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_s16)))
+int16x8_t __arm_veorq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_s16)))
+int16x8_t __arm_veorq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_s32)))
+int32x4_t __arm_veorq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_s32)))
+int32x4_t __arm_veorq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_s8)))
+int8x16_t __arm_veorq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_s8)))
+int8x16_t __arm_veorq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_u16)))
+uint16x8_t __arm_veorq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_u16)))
+uint16x8_t __arm_veorq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_u32)))
+uint32x4_t __arm_veorq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_u32)))
+uint32x4_t __arm_veorq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_u8)))
+uint8x16_t __arm_veorq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_u8)))
+uint8x16_t __arm_veorq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s16)))
+int16x8_t __arm_veorq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s16)))
+int16x8_t __arm_veorq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s32)))
+int32x4_t __arm_veorq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s32)))
+int32x4_t __arm_veorq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s8)))
+int8x16_t __arm_veorq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s8)))
+int8x16_t __arm_veorq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u16)))
+uint16x8_t __arm_veorq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u16)))
+uint16x8_t __arm_veorq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u32)))
+uint32x4_t __arm_veorq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u32)))
+uint32x4_t __arm_veorq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u8)))
+uint8x16_t __arm_veorq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u8)))
+uint8x16_t __arm_veorq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s16)))
+int16_t __arm_vgetq_lane_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s16)))
+int16_t __arm_vgetq_lane(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s32)))
+int32_t __arm_vgetq_lane_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s32)))
+int32_t __arm_vgetq_lane(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s64)))
+int64_t __arm_vgetq_lane_s64(int64x2_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s64)))
+int64_t __arm_vgetq_lane(int64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s8)))
+int8_t __arm_vgetq_lane_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s8)))
+int8_t __arm_vgetq_lane(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u16)))
+uint16_t __arm_vgetq_lane_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u16)))
+uint16_t __arm_vgetq_lane(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u32)))
+uint32_t __arm_vgetq_lane_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u32)))
+uint32_t __arm_vgetq_lane(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u64)))
+uint64_t __arm_vgetq_lane_u64(uint64x2_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u64)))
+uint64_t __arm_vgetq_lane(uint64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u8)))
+uint8_t __arm_vgetq_lane_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u8)))
+uint8_t __arm_vgetq_lane(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s16)))
+int16x8_t __arm_vhaddq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s16)))
+int16x8_t __arm_vhaddq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s32)))
+int32x4_t __arm_vhaddq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s32)))
+int32x4_t __arm_vhaddq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s8)))
+int8x16_t __arm_vhaddq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s8)))
+int8x16_t __arm_vhaddq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u16)))
+uint16x8_t __arm_vhaddq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u16)))
+uint16x8_t __arm_vhaddq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u32)))
+uint32x4_t __arm_vhaddq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u32)))
+uint32x4_t __arm_vhaddq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u8)))
+uint8x16_t __arm_vhaddq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u8)))
+uint8x16_t __arm_vhaddq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s16)))
+int16x8_t __arm_vhaddq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s16)))
+int16x8_t __arm_vhaddq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s32)))
+int32x4_t __arm_vhaddq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s32)))
+int32x4_t __arm_vhaddq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s8)))
+int8x16_t __arm_vhaddq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s8)))
+int8x16_t __arm_vhaddq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u16)))
+uint16x8_t __arm_vhaddq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u16)))
+uint16x8_t __arm_vhaddq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u32)))
+uint32x4_t __arm_vhaddq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u32)))
+uint32x4_t __arm_vhaddq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u8)))
+uint8x16_t __arm_vhaddq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u8)))
+uint8x16_t __arm_vhaddq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s16)))
+int16x8_t __arm_vhaddq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s16)))
+int16x8_t __arm_vhaddq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s32)))
+int32x4_t __arm_vhaddq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s32)))
+int32x4_t __arm_vhaddq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s8)))
+int8x16_t __arm_vhaddq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s8)))
+int8x16_t __arm_vhaddq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u16)))
+uint16x8_t __arm_vhaddq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u16)))
+uint16x8_t __arm_vhaddq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u32)))
+uint32x4_t __arm_vhaddq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u32)))
+uint32x4_t __arm_vhaddq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u8)))
+uint8x16_t __arm_vhaddq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u8)))
+uint8x16_t __arm_vhaddq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s16)))
+int16x8_t __arm_vhaddq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s16)))
+int16x8_t __arm_vhaddq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s32)))
+int32x4_t __arm_vhaddq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s32)))
+int32x4_t __arm_vhaddq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s8)))
+int8x16_t __arm_vhaddq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s8)))
+int8x16_t __arm_vhaddq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u16)))
+uint16x8_t __arm_vhaddq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u16)))
+uint16x8_t __arm_vhaddq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u32)))
+uint32x4_t __arm_vhaddq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u32)))
+uint32x4_t __arm_vhaddq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u8)))
+uint8x16_t __arm_vhaddq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u8)))
+uint8x16_t __arm_vhaddq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s16)))
+int16x8_t __arm_vhaddq_x_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s16)))
+int16x8_t __arm_vhaddq_x(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s32)))
+int32x4_t __arm_vhaddq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s32)))
+int32x4_t __arm_vhaddq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s8)))
+int8x16_t __arm_vhaddq_x_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s8)))
+int8x16_t __arm_vhaddq_x(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u16)))
+uint16x8_t __arm_vhaddq_x_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u16)))
+uint16x8_t __arm_vhaddq_x(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u32)))
+uint32x4_t __arm_vhaddq_x_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u32)))
+uint32x4_t __arm_vhaddq_x(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u8)))
+uint8x16_t __arm_vhaddq_x_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u8)))
+uint8x16_t __arm_vhaddq_x(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s16)))
+int16x8_t __arm_vhaddq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s16)))
+int16x8_t __arm_vhaddq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s32)))
+int32x4_t __arm_vhaddq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s32)))
+int32x4_t __arm_vhaddq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s8)))
+int8x16_t __arm_vhaddq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s8)))
+int8x16_t __arm_vhaddq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u16)))
+uint16x8_t __arm_vhaddq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u16)))
+uint16x8_t __arm_vhaddq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u32)))
+uint32x4_t __arm_vhaddq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u32)))
+uint32x4_t __arm_vhaddq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u8)))
+uint8x16_t __arm_vhaddq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u8)))
+uint8x16_t __arm_vhaddq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s16)))
+int16x8_t __arm_vhcaddq_rot270_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s16)))
+int16x8_t __arm_vhcaddq_rot270_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s32)))
+int32x4_t __arm_vhcaddq_rot270_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s32)))
+int32x4_t __arm_vhcaddq_rot270_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s8)))
+int8x16_t __arm_vhcaddq_rot270_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s8)))
+int8x16_t __arm_vhcaddq_rot270_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s16)))
+int16x8_t __arm_vhcaddq_rot270_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s16)))
+int16x8_t __arm_vhcaddq_rot270(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s32)))
+int32x4_t __arm_vhcaddq_rot270_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s32)))
+int32x4_t __arm_vhcaddq_rot270(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s8)))
+int8x16_t __arm_vhcaddq_rot270_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s8)))
+int8x16_t __arm_vhcaddq_rot270(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s16)))
+int16x8_t __arm_vhcaddq_rot270_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s16)))
+int16x8_t __arm_vhcaddq_rot270_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s32)))
+int32x4_t __arm_vhcaddq_rot270_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s32)))
+int32x4_t __arm_vhcaddq_rot270_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s8)))
+int8x16_t __arm_vhcaddq_rot270_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s8)))
+int8x16_t __arm_vhcaddq_rot270_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s16)))
+int16x8_t __arm_vhcaddq_rot90_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s16)))
+int16x8_t __arm_vhcaddq_rot90_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s32)))
+int32x4_t __arm_vhcaddq_rot90_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s32)))
+int32x4_t __arm_vhcaddq_rot90_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s8)))
+int8x16_t __arm_vhcaddq_rot90_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s8)))
+int8x16_t __arm_vhcaddq_rot90_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s16)))
+int16x8_t __arm_vhcaddq_rot90_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s16)))
+int16x8_t __arm_vhcaddq_rot90(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s32)))
+int32x4_t __arm_vhcaddq_rot90_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s32)))
+int32x4_t __arm_vhcaddq_rot90(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s8)))
+int8x16_t __arm_vhcaddq_rot90_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s8)))
+int8x16_t __arm_vhcaddq_rot90(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s16)))
+int16x8_t __arm_vhcaddq_rot90_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s16)))
+int16x8_t __arm_vhcaddq_rot90_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s32)))
+int32x4_t __arm_vhcaddq_rot90_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s32)))
+int32x4_t __arm_vhcaddq_rot90_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s8)))
+int8x16_t __arm_vhcaddq_rot90_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s8)))
+int8x16_t __arm_vhcaddq_rot90_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s16)))
+int16x8_t __arm_vhsubq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s16)))
+int16x8_t __arm_vhsubq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s32)))
+int32x4_t __arm_vhsubq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s32)))
+int32x4_t __arm_vhsubq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s8)))
+int8x16_t __arm_vhsubq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s8)))
+int8x16_t __arm_vhsubq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u16)))
+uint16x8_t __arm_vhsubq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u16)))
+uint16x8_t __arm_vhsubq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u32)))
+uint32x4_t __arm_vhsubq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u32)))
+uint32x4_t __arm_vhsubq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u8)))
+uint8x16_t __arm_vhsubq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u8)))
+uint8x16_t __arm_vhsubq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s16)))
+int16x8_t __arm_vhsubq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s16)))
+int16x8_t __arm_vhsubq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s32)))
+int32x4_t __arm_vhsubq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s32)))
+int32x4_t __arm_vhsubq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s8)))
+int8x16_t __arm_vhsubq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s8)))
+int8x16_t __arm_vhsubq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u16)))
+uint16x8_t __arm_vhsubq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u16)))
+uint16x8_t __arm_vhsubq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u32)))
+uint32x4_t __arm_vhsubq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u32)))
+uint32x4_t __arm_vhsubq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u8)))
+uint8x16_t __arm_vhsubq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u8)))
+uint8x16_t __arm_vhsubq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s16)))
+int16x8_t __arm_vhsubq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s16)))
+int16x8_t __arm_vhsubq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s32)))
+int32x4_t __arm_vhsubq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s32)))
+int32x4_t __arm_vhsubq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s8)))
+int8x16_t __arm_vhsubq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s8)))
+int8x16_t __arm_vhsubq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u16)))
+uint16x8_t __arm_vhsubq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u16)))
+uint16x8_t __arm_vhsubq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u32)))
+uint32x4_t __arm_vhsubq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u32)))
+uint32x4_t __arm_vhsubq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u8)))
+uint8x16_t __arm_vhsubq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u8)))
+uint8x16_t __arm_vhsubq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s16)))
+int16x8_t __arm_vhsubq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s16)))
+int16x8_t __arm_vhsubq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s32)))
+int32x4_t __arm_vhsubq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s32)))
+int32x4_t __arm_vhsubq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s8)))
+int8x16_t __arm_vhsubq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s8)))
+int8x16_t __arm_vhsubq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u16)))
+uint16x8_t __arm_vhsubq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u16)))
+uint16x8_t __arm_vhsubq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u32)))
+uint32x4_t __arm_vhsubq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u32)))
+uint32x4_t __arm_vhsubq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u8)))
+uint8x16_t __arm_vhsubq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u8)))
+uint8x16_t __arm_vhsubq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s16)))
+int16x8_t __arm_vhsubq_x_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s16)))
+int16x8_t __arm_vhsubq_x(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s32)))
+int32x4_t __arm_vhsubq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s32)))
+int32x4_t __arm_vhsubq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s8)))
+int8x16_t __arm_vhsubq_x_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s8)))
+int8x16_t __arm_vhsubq_x(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u16)))
+uint16x8_t __arm_vhsubq_x_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u16)))
+uint16x8_t __arm_vhsubq_x(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u32)))
+uint32x4_t __arm_vhsubq_x_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u32)))
+uint32x4_t __arm_vhsubq_x(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u8)))
+uint8x16_t __arm_vhsubq_x_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u8)))
+uint8x16_t __arm_vhsubq_x(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s16)))
+int16x8_t __arm_vhsubq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s16)))
+int16x8_t __arm_vhsubq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s32)))
+int32x4_t __arm_vhsubq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s32)))
+int32x4_t __arm_vhsubq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s8)))
+int8x16_t __arm_vhsubq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s8)))
+int8x16_t __arm_vhsubq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u16)))
+uint16x8_t __arm_vhsubq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u16)))
+uint16x8_t __arm_vhsubq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u32)))
+uint32x4_t __arm_vhsubq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u32)))
+uint32x4_t __arm_vhsubq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u8)))
+uint8x16_t __arm_vhsubq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u8)))
+uint8x16_t __arm_vhsubq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u16)))
+uint16x8_t __arm_vidupq_m_n_u16(uint16x8_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u16)))
+uint16x8_t __arm_vidupq_m(uint16x8_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u32)))
+uint32x4_t __arm_vidupq_m_n_u32(uint32x4_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u32)))
+uint32x4_t __arm_vidupq_m(uint32x4_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u8)))
+uint8x16_t __arm_vidupq_m_n_u8(uint8x16_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u8)))
+uint8x16_t __arm_vidupq_m(uint8x16_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u16)))
+uint16x8_t __arm_vidupq_m_wb_u16(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u16)))
+uint16x8_t __arm_vidupq_m(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u32)))
+uint32x4_t __arm_vidupq_m_wb_u32(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u32)))
+uint32x4_t __arm_vidupq_m(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u8)))
+uint8x16_t __arm_vidupq_m_wb_u8(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u8)))
+uint8x16_t __arm_vidupq_m(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u16)))
+uint16x8_t __arm_vidupq_n_u16(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u16)))
+uint16x8_t __arm_vidupq_u16(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u32)))
+uint32x4_t __arm_vidupq_n_u32(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u32)))
+uint32x4_t __arm_vidupq_u32(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u8)))
+uint8x16_t __arm_vidupq_n_u8(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u8)))
+uint8x16_t __arm_vidupq_u8(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u16)))
+uint16x8_t __arm_vidupq_wb_u16(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u16)))
+uint16x8_t __arm_vidupq_u16(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u32)))
+uint32x4_t __arm_vidupq_wb_u32(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u32)))
+uint32x4_t __arm_vidupq_u32(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u8)))
+uint8x16_t __arm_vidupq_wb_u8(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u8)))
+uint8x16_t __arm_vidupq_u8(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u16)))
+uint16x8_t __arm_vidupq_x_n_u16(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u16)))
+uint16x8_t __arm_vidupq_x_u16(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u32)))
+uint32x4_t __arm_vidupq_x_n_u32(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u32)))
+uint32x4_t __arm_vidupq_x_u32(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u8)))
+uint8x16_t __arm_vidupq_x_n_u8(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u8)))
+uint8x16_t __arm_vidupq_x_u8(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u16)))
+uint16x8_t __arm_vidupq_x_wb_u16(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u16)))
+uint16x8_t __arm_vidupq_x_u16(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u32)))
+uint32x4_t __arm_vidupq_x_wb_u32(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u32)))
+uint32x4_t __arm_vidupq_x_u32(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u8)))
+uint8x16_t __arm_vidupq_x_wb_u8(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u8)))
+uint8x16_t __arm_vidupq_x_u8(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u16)))
+uint16x8_t __arm_viwdupq_m_n_u16(uint16x8_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u16)))
+uint16x8_t __arm_viwdupq_m(uint16x8_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u32)))
+uint32x4_t __arm_viwdupq_m_n_u32(uint32x4_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u32)))
+uint32x4_t __arm_viwdupq_m(uint32x4_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u8)))
+uint8x16_t __arm_viwdupq_m_n_u8(uint8x16_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u8)))
+uint8x16_t __arm_viwdupq_m(uint8x16_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u16)))
+uint16x8_t __arm_viwdupq_m_wb_u16(uint16x8_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u16)))
+uint16x8_t __arm_viwdupq_m(uint16x8_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u32)))
+uint32x4_t __arm_viwdupq_m_wb_u32(uint32x4_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u32)))
+uint32x4_t __arm_viwdupq_m(uint32x4_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u8)))
+uint8x16_t __arm_viwdupq_m_wb_u8(uint8x16_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u8)))
+uint8x16_t __arm_viwdupq_m(uint8x16_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u16)))
+uint16x8_t __arm_viwdupq_n_u16(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u16)))
+uint16x8_t __arm_viwdupq_u16(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u32)))
+uint32x4_t __arm_viwdupq_n_u32(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u32)))
+uint32x4_t __arm_viwdupq_u32(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u8)))
+uint8x16_t __arm_viwdupq_n_u8(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u8)))
+uint8x16_t __arm_viwdupq_u8(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u16)))
+uint16x8_t __arm_viwdupq_wb_u16(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u16)))
+uint16x8_t __arm_viwdupq_u16(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u32)))
+uint32x4_t __arm_viwdupq_wb_u32(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u32)))
+uint32x4_t __arm_viwdupq_u32(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u8)))
+uint8x16_t __arm_viwdupq_wb_u8(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u8)))
+uint8x16_t __arm_viwdupq_u8(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u16)))
+uint16x8_t __arm_viwdupq_x_n_u16(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u16)))
+uint16x8_t __arm_viwdupq_x_u16(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u32)))
+uint32x4_t __arm_viwdupq_x_n_u32(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u32)))
+uint32x4_t __arm_viwdupq_x_u32(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u8)))
+uint8x16_t __arm_viwdupq_x_n_u8(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u8)))
+uint8x16_t __arm_viwdupq_x_u8(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u16)))
+uint16x8_t __arm_viwdupq_x_wb_u16(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u16)))
+uint16x8_t __arm_viwdupq_x_u16(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u32)))
+uint32x4_t __arm_viwdupq_x_wb_u32(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u32)))
+uint32x4_t __arm_viwdupq_x_u32(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u8)))
+uint8x16_t __arm_viwdupq_x_wb_u8(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u8)))
+uint8x16_t __arm_viwdupq_x_u8(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s16)))
+int16x8_t __arm_vld1q_s16(const int16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s16)))
+int16x8_t __arm_vld1q(const int16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s32)))
+int32x4_t __arm_vld1q_s32(const int32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s32)))
+int32x4_t __arm_vld1q(const int32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s8)))
+int8x16_t __arm_vld1q_s8(const int8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s8)))
+int8x16_t __arm_vld1q(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u16)))
+uint16x8_t __arm_vld1q_u16(const uint16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u16)))
+uint16x8_t __arm_vld1q(const uint16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u32)))
+uint32x4_t __arm_vld1q_u32(const uint32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u32)))
+uint32x4_t __arm_vld1q(const uint32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u8)))
+uint8x16_t __arm_vld1q_u8(const uint8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u8)))
+uint8x16_t __arm_vld1q(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s16)))
+int16x8_t __arm_vld1q_z_s16(const int16_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s16)))
+int16x8_t __arm_vld1q_z(const int16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s32)))
+int32x4_t __arm_vld1q_z_s32(const int32_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s32)))
+int32x4_t __arm_vld1q_z(const int32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s8)))
+int8x16_t __arm_vld1q_z_s8(const int8_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s8)))
+int8x16_t __arm_vld1q_z(const int8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u16)))
+uint16x8_t __arm_vld1q_z_u16(const uint16_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u16)))
+uint16x8_t __arm_vld1q_z(const uint16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u32)))
+uint32x4_t __arm_vld1q_z_u32(const uint32_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u32)))
+uint32x4_t __arm_vld1q_z(const uint32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u8)))
+uint8x16_t __arm_vld1q_z_u8(const uint8_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u8)))
+uint8x16_t __arm_vld1q_z(const uint8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s16)))
+int16x8x2_t __arm_vld2q_s16(const int16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s16)))
+int16x8x2_t __arm_vld2q(const int16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s32)))
+int32x4x2_t __arm_vld2q_s32(const int32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s32)))
+int32x4x2_t __arm_vld2q(const int32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s8)))
+int8x16x2_t __arm_vld2q_s8(const int8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s8)))
+int8x16x2_t __arm_vld2q(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u16)))
+uint16x8x2_t __arm_vld2q_u16(const uint16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u16)))
+uint16x8x2_t __arm_vld2q(const uint16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u32)))
+uint32x4x2_t __arm_vld2q_u32(const uint32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u32)))
+uint32x4x2_t __arm_vld2q(const uint32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u8)))
+uint8x16x2_t __arm_vld2q_u8(const uint8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u8)))
+uint8x16x2_t __arm_vld2q(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s16)))
+int16x8x4_t __arm_vld4q_s16(const int16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s16)))
+int16x8x4_t __arm_vld4q(const int16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s32)))
+int32x4x4_t __arm_vld4q_s32(const int32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s32)))
+int32x4x4_t __arm_vld4q(const int32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s8)))
+int8x16x4_t __arm_vld4q_s8(const int8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s8)))
+int8x16x4_t __arm_vld4q(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u16)))
+uint16x8x4_t __arm_vld4q_u16(const uint16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u16)))
+uint16x8x4_t __arm_vld4q(const uint16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u32)))
+uint32x4x4_t __arm_vld4q_u32(const uint32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u32)))
+uint32x4x4_t __arm_vld4q(const uint32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u8)))
+uint8x16x4_t __arm_vld4q_u8(const uint8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u8)))
+uint8x16x4_t __arm_vld4q(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s16)))
+int16x8_t __arm_vldrbq_gather_offset_s16(const int8_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s16)))
+int16x8_t __arm_vldrbq_gather_offset(const int8_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s32)))
+int32x4_t __arm_vldrbq_gather_offset_s32(const int8_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s32)))
+int32x4_t __arm_vldrbq_gather_offset(const int8_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s8)))
+int8x16_t __arm_vldrbq_gather_offset_s8(const int8_t *, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s8)))
+int8x16_t __arm_vldrbq_gather_offset(const int8_t *, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u16)))
+uint16x8_t __arm_vldrbq_gather_offset_u16(const uint8_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u16)))
+uint16x8_t __arm_vldrbq_gather_offset(const uint8_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u32)))
+uint32x4_t __arm_vldrbq_gather_offset_u32(const uint8_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u32)))
+uint32x4_t __arm_vldrbq_gather_offset(const uint8_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u8)))
+uint8x16_t __arm_vldrbq_gather_offset_u8(const uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u8)))
+uint8x16_t __arm_vldrbq_gather_offset(const uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s16)))
+int16x8_t __arm_vldrbq_gather_offset_z_s16(const int8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s16)))
+int16x8_t __arm_vldrbq_gather_offset_z(const int8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s32)))
+int32x4_t __arm_vldrbq_gather_offset_z_s32(const int8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s32)))
+int32x4_t __arm_vldrbq_gather_offset_z(const int8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s8)))
+int8x16_t __arm_vldrbq_gather_offset_z_s8(const int8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s8)))
+int8x16_t __arm_vldrbq_gather_offset_z(const int8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u16)))
+uint16x8_t __arm_vldrbq_gather_offset_z_u16(const uint8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u16)))
+uint16x8_t __arm_vldrbq_gather_offset_z(const uint8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u32)))
+uint32x4_t __arm_vldrbq_gather_offset_z_u32(const uint8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u32)))
+uint32x4_t __arm_vldrbq_gather_offset_z(const uint8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u8)))
+uint8x16_t __arm_vldrbq_gather_offset_z_u8(const uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u8)))
+uint8x16_t __arm_vldrbq_gather_offset_z(const uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_s16)))
+int16x8_t __arm_vldrbq_s16(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_s32)))
+int32x4_t __arm_vldrbq_s32(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_s8)))
+int8x16_t __arm_vldrbq_s8(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_u16)))
+uint16x8_t __arm_vldrbq_u16(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_u32)))
+uint32x4_t __arm_vldrbq_u32(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_u8)))
+uint8x16_t __arm_vldrbq_u8(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_s16)))
+int16x8_t __arm_vldrbq_z_s16(const int8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_s32)))
+int32x4_t __arm_vldrbq_z_s32(const int8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_s8)))
+int8x16_t __arm_vldrbq_z_s8(const int8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_u16)))
+uint16x8_t __arm_vldrbq_z_u16(const uint8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_u32)))
+uint32x4_t __arm_vldrbq_z_u32(const uint8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_u8)))
+uint8x16_t __arm_vldrbq_z_u8(const uint8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_s64)))
+int64x2_t __arm_vldrdq_gather_base_s64(uint64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_u64)))
+uint64x2_t __arm_vldrdq_gather_base_u64(uint64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_wb_s64)))
+int64x2_t __arm_vldrdq_gather_base_wb_s64(uint64x2_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_wb_u64)))
+uint64x2_t __arm_vldrdq_gather_base_wb_u64(uint64x2_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_wb_z_s64)))
+int64x2_t __arm_vldrdq_gather_base_wb_z_s64(uint64x2_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_wb_z_u64)))
+uint64x2_t __arm_vldrdq_gather_base_wb_z_u64(uint64x2_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_z_s64)))
+int64x2_t __arm_vldrdq_gather_base_z_s64(uint64x2_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_z_u64)))
+uint64x2_t __arm_vldrdq_gather_base_z_u64(uint64x2_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_s64)))
+int64x2_t __arm_vldrdq_gather_offset_s64(const int64_t *, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_s64)))
+int64x2_t __arm_vldrdq_gather_offset(const int64_t *, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_u64)))
+uint64x2_t __arm_vldrdq_gather_offset_u64(const uint64_t *, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_u64)))
+uint64x2_t __arm_vldrdq_gather_offset(const uint64_t *, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_z_s64)))
+int64x2_t __arm_vldrdq_gather_offset_z_s64(const int64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_z_s64)))
+int64x2_t __arm_vldrdq_gather_offset_z(const int64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_z_u64)))
+uint64x2_t __arm_vldrdq_gather_offset_z_u64(const uint64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_z_u64)))
+uint64x2_t __arm_vldrdq_gather_offset_z(const uint64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_s64)))
+int64x2_t __arm_vldrdq_gather_shifted_offset_s64(const int64_t *, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_s64)))
+int64x2_t __arm_vldrdq_gather_shifted_offset(const int64_t *, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_u64)))
+uint64x2_t __arm_vldrdq_gather_shifted_offset_u64(const uint64_t *, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_u64)))
+uint64x2_t __arm_vldrdq_gather_shifted_offset(const uint64_t *, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_z_s64)))
+int64x2_t __arm_vldrdq_gather_shifted_offset_z_s64(const int64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_z_s64)))
+int64x2_t __arm_vldrdq_gather_shifted_offset_z(const int64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_z_u64)))
+uint64x2_t __arm_vldrdq_gather_shifted_offset_z_u64(const uint64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_z_u64)))
+uint64x2_t __arm_vldrdq_gather_shifted_offset_z(const uint64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_s16)))
+int16x8_t __arm_vldrhq_gather_offset_s16(const int16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_s16)))
+int16x8_t __arm_vldrhq_gather_offset(const int16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_s32)))
+int32x4_t __arm_vldrhq_gather_offset_s32(const int16_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_s32)))
+int32x4_t __arm_vldrhq_gather_offset(const int16_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_u16)))
+uint16x8_t __arm_vldrhq_gather_offset_u16(const uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_u16)))
+uint16x8_t __arm_vldrhq_gather_offset(const uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_u32)))
+uint32x4_t __arm_vldrhq_gather_offset_u32(const uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_u32)))
+uint32x4_t __arm_vldrhq_gather_offset(const uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_s16)))
+int16x8_t __arm_vldrhq_gather_offset_z_s16(const int16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_s16)))
+int16x8_t __arm_vldrhq_gather_offset_z(const int16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_s32)))
+int32x4_t __arm_vldrhq_gather_offset_z_s32(const int16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_s32)))
+int32x4_t __arm_vldrhq_gather_offset_z(const int16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_u16)))
+uint16x8_t __arm_vldrhq_gather_offset_z_u16(const uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_u16)))
+uint16x8_t __arm_vldrhq_gather_offset_z(const uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_u32)))
+uint32x4_t __arm_vldrhq_gather_offset_z_u32(const uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_u32)))
+uint32x4_t __arm_vldrhq_gather_offset_z(const uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_s16)))
+int16x8_t __arm_vldrhq_gather_shifted_offset_s16(const int16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_s16)))
+int16x8_t __arm_vldrhq_gather_shifted_offset(const int16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_s32)))
+int32x4_t __arm_vldrhq_gather_shifted_offset_s32(const int16_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_s32)))
+int32x4_t __arm_vldrhq_gather_shifted_offset(const int16_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_u16)))
+uint16x8_t __arm_vldrhq_gather_shifted_offset_u16(const uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_u16)))
+uint16x8_t __arm_vldrhq_gather_shifted_offset(const uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_u32)))
+uint32x4_t __arm_vldrhq_gather_shifted_offset_u32(const uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_u32)))
+uint32x4_t __arm_vldrhq_gather_shifted_offset(const uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_s16)))
+int16x8_t __arm_vldrhq_gather_shifted_offset_z_s16(const int16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_s16)))
+int16x8_t __arm_vldrhq_gather_shifted_offset_z(const int16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_s32)))
+int32x4_t __arm_vldrhq_gather_shifted_offset_z_s32(const int16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_s32)))
+int32x4_t __arm_vldrhq_gather_shifted_offset_z(const int16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_u16)))
+uint16x8_t __arm_vldrhq_gather_shifted_offset_z_u16(const uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_u16)))
+uint16x8_t __arm_vldrhq_gather_shifted_offset_z(const uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_u32)))
+uint32x4_t __arm_vldrhq_gather_shifted_offset_z_u32(const uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_u32)))
+uint32x4_t __arm_vldrhq_gather_shifted_offset_z(const uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_s16)))
+int16x8_t __arm_vldrhq_s16(const int16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_s32)))
+int32x4_t __arm_vldrhq_s32(const int16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_u16)))
+uint16x8_t __arm_vldrhq_u16(const uint16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_u32)))
+uint32x4_t __arm_vldrhq_u32(const uint16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_z_s16)))
+int16x8_t __arm_vldrhq_z_s16(const int16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_z_s32)))
+int32x4_t __arm_vldrhq_z_s32(const int16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_z_u16)))
+uint16x8_t __arm_vldrhq_z_u16(const uint16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_z_u32)))
+uint32x4_t __arm_vldrhq_z_u32(const uint16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_s32)))
+int32x4_t __arm_vldrwq_gather_base_s32(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_u32)))
+uint32x4_t __arm_vldrwq_gather_base_u32(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_s32)))
+int32x4_t __arm_vldrwq_gather_base_wb_s32(uint32x4_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_u32)))
+uint32x4_t __arm_vldrwq_gather_base_wb_u32(uint32x4_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_z_s32)))
+int32x4_t __arm_vldrwq_gather_base_wb_z_s32(uint32x4_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_z_u32)))
+uint32x4_t __arm_vldrwq_gather_base_wb_z_u32(uint32x4_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_z_s32)))
+int32x4_t __arm_vldrwq_gather_base_z_s32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_z_u32)))
+uint32x4_t __arm_vldrwq_gather_base_z_u32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_s32)))
+int32x4_t __arm_vldrwq_gather_offset_s32(const int32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_s32)))
+int32x4_t __arm_vldrwq_gather_offset(const int32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_u32)))
+uint32x4_t __arm_vldrwq_gather_offset_u32(const uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_u32)))
+uint32x4_t __arm_vldrwq_gather_offset(const uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_s32)))
+int32x4_t __arm_vldrwq_gather_offset_z_s32(const int32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_s32)))
+int32x4_t __arm_vldrwq_gather_offset_z(const int32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_u32)))
+uint32x4_t __arm_vldrwq_gather_offset_z_u32(const uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_u32)))
+uint32x4_t __arm_vldrwq_gather_offset_z(const uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_s32)))
+int32x4_t __arm_vldrwq_gather_shifted_offset_s32(const int32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_s32)))
+int32x4_t __arm_vldrwq_gather_shifted_offset(const int32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_u32)))
+uint32x4_t __arm_vldrwq_gather_shifted_offset_u32(const uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_u32)))
+uint32x4_t __arm_vldrwq_gather_shifted_offset(const uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_s32)))
+int32x4_t __arm_vldrwq_gather_shifted_offset_z_s32(const int32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_s32)))
+int32x4_t __arm_vldrwq_gather_shifted_offset_z(const int32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_u32)))
+uint32x4_t __arm_vldrwq_gather_shifted_offset_z_u32(const uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_u32)))
+uint32x4_t __arm_vldrwq_gather_shifted_offset_z(const uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_s32)))
+int32x4_t __arm_vldrwq_s32(const int32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_u32)))
+uint32x4_t __arm_vldrwq_u32(const uint32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_z_s32)))
+int32x4_t __arm_vldrwq_z_s32(const int32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_z_u32)))
+uint32x4_t __arm_vldrwq_z_u32(const uint32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s16)))
+uint16x8_t __arm_vmaxaq_m_s16(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s16)))
+uint16x8_t __arm_vmaxaq_m(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s32)))
+uint32x4_t __arm_vmaxaq_m_s32(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s32)))
+uint32x4_t __arm_vmaxaq_m(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s8)))
+uint8x16_t __arm_vmaxaq_m_s8(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s8)))
+uint8x16_t __arm_vmaxaq_m(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s16)))
+uint16x8_t __arm_vmaxaq_s16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s16)))
+uint16x8_t __arm_vmaxaq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s32)))
+uint32x4_t __arm_vmaxaq_s32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s32)))
+uint32x4_t __arm_vmaxaq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s8)))
+uint8x16_t __arm_vmaxaq_s8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s8)))
+uint8x16_t __arm_vmaxaq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s16)))
+uint16_t __arm_vmaxavq_p_s16(uint16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s16)))
+uint16_t __arm_vmaxavq_p(uint16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s32)))
+uint32_t __arm_vmaxavq_p_s32(uint32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s32)))
+uint32_t __arm_vmaxavq_p(uint32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s8)))
+uint8_t __arm_vmaxavq_p_s8(uint8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s8)))
+uint8_t __arm_vmaxavq_p(uint8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s16)))
+uint16_t __arm_vmaxavq_s16(uint16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s16)))
+uint16_t __arm_vmaxavq(uint16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s32)))
+uint32_t __arm_vmaxavq_s32(uint32_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s32)))
+uint32_t __arm_vmaxavq(uint32_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s8)))
+uint8_t __arm_vmaxavq_s8(uint8_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s8)))
+uint8_t __arm_vmaxavq(uint8_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s16)))
+int16x8_t __arm_vmaxq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s16)))
+int16x8_t __arm_vmaxq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s32)))
+int32x4_t __arm_vmaxq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s32)))
+int32x4_t __arm_vmaxq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s8)))
+int8x16_t __arm_vmaxq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s8)))
+int8x16_t __arm_vmaxq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u16)))
+uint16x8_t __arm_vmaxq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u16)))
+uint16x8_t __arm_vmaxq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u32)))
+uint32x4_t __arm_vmaxq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u32)))
+uint32x4_t __arm_vmaxq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u8)))
+uint8x16_t __arm_vmaxq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u8)))
+uint8x16_t __arm_vmaxq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s16)))
+int16x8_t __arm_vmaxq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s16)))
+int16x8_t __arm_vmaxq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s32)))
+int32x4_t __arm_vmaxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s32)))
+int32x4_t __arm_vmaxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s8)))
+int8x16_t __arm_vmaxq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s8)))
+int8x16_t __arm_vmaxq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u16)))
+uint16x8_t __arm_vmaxq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u16)))
+uint16x8_t __arm_vmaxq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u32)))
+uint32x4_t __arm_vmaxq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u32)))
+uint32x4_t __arm_vmaxq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u8)))
+uint8x16_t __arm_vmaxq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u8)))
+uint8x16_t __arm_vmaxq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s16)))
+int16x8_t __arm_vmaxq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s16)))
+int16x8_t __arm_vmaxq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s32)))
+int32x4_t __arm_vmaxq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s32)))
+int32x4_t __arm_vmaxq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s8)))
+int8x16_t __arm_vmaxq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s8)))
+int8x16_t __arm_vmaxq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u16)))
+uint16x8_t __arm_vmaxq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u16)))
+uint16x8_t __arm_vmaxq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u32)))
+uint32x4_t __arm_vmaxq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u32)))
+uint32x4_t __arm_vmaxq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u8)))
+uint8x16_t __arm_vmaxq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u8)))
+uint8x16_t __arm_vmaxq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s16)))
+int16_t __arm_vmaxvq_p_s16(int16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s16)))
+int16_t __arm_vmaxvq_p(int16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s32)))
+int32_t __arm_vmaxvq_p_s32(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s32)))
+int32_t __arm_vmaxvq_p(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s8)))
+int8_t __arm_vmaxvq_p_s8(int8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s8)))
+int8_t __arm_vmaxvq_p(int8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u16)))
+uint16_t __arm_vmaxvq_p_u16(uint16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u16)))
+uint16_t __arm_vmaxvq_p(uint16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u32)))
+uint32_t __arm_vmaxvq_p_u32(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u32)))
+uint32_t __arm_vmaxvq_p(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u8)))
+uint8_t __arm_vmaxvq_p_u8(uint8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u8)))
+uint8_t __arm_vmaxvq_p(uint8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s16)))
+int16_t __arm_vmaxvq_s16(int16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s16)))
+int16_t __arm_vmaxvq(int16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s32)))
+int32_t __arm_vmaxvq_s32(int32_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s32)))
+int32_t __arm_vmaxvq(int32_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s8)))
+int8_t __arm_vmaxvq_s8(int8_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s8)))
+int8_t __arm_vmaxvq(int8_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u16)))
+uint16_t __arm_vmaxvq_u16(uint16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u16)))
+uint16_t __arm_vmaxvq(uint16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u32)))
+uint32_t __arm_vmaxvq_u32(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u32)))
+uint32_t __arm_vmaxvq(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u8)))
+uint8_t __arm_vmaxvq_u8(uint8_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u8)))
+uint8_t __arm_vmaxvq(uint8_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s16)))
+uint16x8_t __arm_vminaq_m_s16(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s16)))
+uint16x8_t __arm_vminaq_m(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s32)))
+uint32x4_t __arm_vminaq_m_s32(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s32)))
+uint32x4_t __arm_vminaq_m(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s8)))
+uint8x16_t __arm_vminaq_m_s8(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s8)))
+uint8x16_t __arm_vminaq_m(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s16)))
+uint16x8_t __arm_vminaq_s16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s16)))
+uint16x8_t __arm_vminaq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s32)))
+uint32x4_t __arm_vminaq_s32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s32)))
+uint32x4_t __arm_vminaq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s8)))
+uint8x16_t __arm_vminaq_s8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s8)))
+uint8x16_t __arm_vminaq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s16)))
+uint16_t __arm_vminavq_p_s16(uint16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s16)))
+uint16_t __arm_vminavq_p(uint16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s32)))
+uint32_t __arm_vminavq_p_s32(uint32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s32)))
+uint32_t __arm_vminavq_p(uint32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s8)))
+uint8_t __arm_vminavq_p_s8(uint8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s8)))
+uint8_t __arm_vminavq_p(uint8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s16)))
+uint16_t __arm_vminavq_s16(uint16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s16)))
+uint16_t __arm_vminavq(uint16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s32)))
+uint32_t __arm_vminavq_s32(uint32_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s32)))
+uint32_t __arm_vminavq(uint32_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s8)))
+uint8_t __arm_vminavq_s8(uint8_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s8)))
+uint8_t __arm_vminavq(uint8_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s16)))
+int16x8_t __arm_vminq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s16)))
+int16x8_t __arm_vminq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s32)))
+int32x4_t __arm_vminq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s32)))
+int32x4_t __arm_vminq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s8)))
+int8x16_t __arm_vminq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s8)))
+int8x16_t __arm_vminq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u16)))
+uint16x8_t __arm_vminq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u16)))
+uint16x8_t __arm_vminq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u32)))
+uint32x4_t __arm_vminq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u32)))
+uint32x4_t __arm_vminq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u8)))
+uint8x16_t __arm_vminq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u8)))
+uint8x16_t __arm_vminq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_s16)))
+int16x8_t __arm_vminq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_s16)))
+int16x8_t __arm_vminq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_s32)))
+int32x4_t __arm_vminq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_s32)))
+int32x4_t __arm_vminq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_s8)))
+int8x16_t __arm_vminq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_s8)))
+int8x16_t __arm_vminq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_u16)))
+uint16x8_t __arm_vminq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_u16)))
+uint16x8_t __arm_vminq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_u32)))
+uint32x4_t __arm_vminq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_u32)))
+uint32x4_t __arm_vminq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_u8)))
+uint8x16_t __arm_vminq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_u8)))
+uint8x16_t __arm_vminq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s16)))
+int16x8_t __arm_vminq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s16)))
+int16x8_t __arm_vminq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s32)))
+int32x4_t __arm_vminq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s32)))
+int32x4_t __arm_vminq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s8)))
+int8x16_t __arm_vminq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s8)))
+int8x16_t __arm_vminq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u16)))
+uint16x8_t __arm_vminq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u16)))
+uint16x8_t __arm_vminq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u32)))
+uint32x4_t __arm_vminq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u32)))
+uint32x4_t __arm_vminq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u8)))
+uint8x16_t __arm_vminq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u8)))
+uint8x16_t __arm_vminq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s16)))
+int16_t __arm_vminvq_p_s16(int16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s16)))
+int16_t __arm_vminvq_p(int16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s32)))
+int32_t __arm_vminvq_p_s32(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s32)))
+int32_t __arm_vminvq_p(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s8)))
+int8_t __arm_vminvq_p_s8(int8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s8)))
+int8_t __arm_vminvq_p(int8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u16)))
+uint16_t __arm_vminvq_p_u16(uint16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u16)))
+uint16_t __arm_vminvq_p(uint16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u32)))
+uint32_t __arm_vminvq_p_u32(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u32)))
+uint32_t __arm_vminvq_p(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u8)))
+uint8_t __arm_vminvq_p_u8(uint8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u8)))
+uint8_t __arm_vminvq_p(uint8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s16)))
+int16_t __arm_vminvq_s16(int16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s16)))
+int16_t __arm_vminvq(int16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s32)))
+int32_t __arm_vminvq_s32(int32_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s32)))
+int32_t __arm_vminvq(int32_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s8)))
+int8_t __arm_vminvq_s8(int8_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s8)))
+int8_t __arm_vminvq(int8_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u16)))
+uint16_t __arm_vminvq_u16(uint16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u16)))
+uint16_t __arm_vminvq(uint16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u32)))
+uint32_t __arm_vminvq_u32(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u32)))
+uint32_t __arm_vminvq(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u8)))
+uint8_t __arm_vminvq_u8(uint8_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u8)))
+uint8_t __arm_vminvq(uint8_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s16)))
+int32_t __arm_vmladavaq_p_s16(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s16)))
+int32_t __arm_vmladavaq_p(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s32)))
+int32_t __arm_vmladavaq_p_s32(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s32)))
+int32_t __arm_vmladavaq_p(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s8)))
+int32_t __arm_vmladavaq_p_s8(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s8)))
+int32_t __arm_vmladavaq_p(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u16)))
+uint32_t __arm_vmladavaq_p_u16(uint32_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u16)))
+uint32_t __arm_vmladavaq_p(uint32_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u32)))
+uint32_t __arm_vmladavaq_p_u32(uint32_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u32)))
+uint32_t __arm_vmladavaq_p(uint32_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u8)))
+uint32_t __arm_vmladavaq_p_u8(uint32_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u8)))
+uint32_t __arm_vmladavaq_p(uint32_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s16)))
+int32_t __arm_vmladavaq_s16(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s16)))
+int32_t __arm_vmladavaq(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s32)))
+int32_t __arm_vmladavaq_s32(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s32)))
+int32_t __arm_vmladavaq(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s8)))
+int32_t __arm_vmladavaq_s8(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s8)))
+int32_t __arm_vmladavaq(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u16)))
+uint32_t __arm_vmladavaq_u16(uint32_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u16)))
+uint32_t __arm_vmladavaq(uint32_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u32)))
+uint32_t __arm_vmladavaq_u32(uint32_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u32)))
+uint32_t __arm_vmladavaq(uint32_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u8)))
+uint32_t __arm_vmladavaq_u8(uint32_t, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u8)))
+uint32_t __arm_vmladavaq(uint32_t, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s16)))
+int32_t __arm_vmladavaxq_p_s16(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s16)))
+int32_t __arm_vmladavaxq_p(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s32)))
+int32_t __arm_vmladavaxq_p_s32(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s32)))
+int32_t __arm_vmladavaxq_p(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s8)))
+int32_t __arm_vmladavaxq_p_s8(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s8)))
+int32_t __arm_vmladavaxq_p(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s16)))
+int32_t __arm_vmladavaxq_s16(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s16)))
+int32_t __arm_vmladavaxq(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s32)))
+int32_t __arm_vmladavaxq_s32(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s32)))
+int32_t __arm_vmladavaxq(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s8)))
+int32_t __arm_vmladavaxq_s8(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s8)))
+int32_t __arm_vmladavaxq(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s16)))
+int32_t __arm_vmladavq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s16)))
+int32_t __arm_vmladavq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s32)))
+int32_t __arm_vmladavq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s32)))
+int32_t __arm_vmladavq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s8)))
+int32_t __arm_vmladavq_p_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s8)))
+int32_t __arm_vmladavq_p(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u16)))
+uint32_t __arm_vmladavq_p_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u16)))
+uint32_t __arm_vmladavq_p(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u32)))
+uint32_t __arm_vmladavq_p_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u32)))
+uint32_t __arm_vmladavq_p(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u8)))
+uint32_t __arm_vmladavq_p_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u8)))
+uint32_t __arm_vmladavq_p(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s16)))
+int32_t __arm_vmladavq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s16)))
+int32_t __arm_vmladavq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s32)))
+int32_t __arm_vmladavq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s32)))
+int32_t __arm_vmladavq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s8)))
+int32_t __arm_vmladavq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s8)))
+int32_t __arm_vmladavq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u16)))
+uint32_t __arm_vmladavq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u16)))
+uint32_t __arm_vmladavq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u32)))
+uint32_t __arm_vmladavq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u32)))
+uint32_t __arm_vmladavq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u8)))
+uint32_t __arm_vmladavq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u8)))
+uint32_t __arm_vmladavq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s16)))
+int32_t __arm_vmladavxq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s16)))
+int32_t __arm_vmladavxq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s32)))
+int32_t __arm_vmladavxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s32)))
+int32_t __arm_vmladavxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s8)))
+int32_t __arm_vmladavxq_p_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s8)))
+int32_t __arm_vmladavxq_p(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s16)))
+int32_t __arm_vmladavxq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s16)))
+int32_t __arm_vmladavxq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s32)))
+int32_t __arm_vmladavxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s32)))
+int32_t __arm_vmladavxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s8)))
+int32_t __arm_vmladavxq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s8)))
+int32_t __arm_vmladavxq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_s16)))
+int64_t __arm_vmlaldavaq_p_s16(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_s16)))
+int64_t __arm_vmlaldavaq_p(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_s32)))
+int64_t __arm_vmlaldavaq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_s32)))
+int64_t __arm_vmlaldavaq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_u16)))
+uint64_t __arm_vmlaldavaq_p_u16(uint64_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_u16)))
+uint64_t __arm_vmlaldavaq_p(uint64_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_u32)))
+uint64_t __arm_vmlaldavaq_p_u32(uint64_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_u32)))
+uint64_t __arm_vmlaldavaq_p(uint64_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_s16)))
+int64_t __arm_vmlaldavaq_s16(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_s16)))
+int64_t __arm_vmlaldavaq(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_s32)))
+int64_t __arm_vmlaldavaq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_s32)))
+int64_t __arm_vmlaldavaq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_u16)))
+uint64_t __arm_vmlaldavaq_u16(uint64_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_u16)))
+uint64_t __arm_vmlaldavaq(uint64_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_u32)))
+uint64_t __arm_vmlaldavaq_u32(uint64_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_u32)))
+uint64_t __arm_vmlaldavaq(uint64_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_p_s16)))
+int64_t __arm_vmlaldavaxq_p_s16(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_p_s16)))
+int64_t __arm_vmlaldavaxq_p(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_p_s32)))
+int64_t __arm_vmlaldavaxq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_p_s32)))
+int64_t __arm_vmlaldavaxq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_s16)))
+int64_t __arm_vmlaldavaxq_s16(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_s16)))
+int64_t __arm_vmlaldavaxq(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_s32)))
+int64_t __arm_vmlaldavaxq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_s32)))
+int64_t __arm_vmlaldavaxq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_s16)))
+int64_t __arm_vmlaldavq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_s16)))
+int64_t __arm_vmlaldavq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_s32)))
+int64_t __arm_vmlaldavq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_s32)))
+int64_t __arm_vmlaldavq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_u16)))
+uint64_t __arm_vmlaldavq_p_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_u16)))
+uint64_t __arm_vmlaldavq_p(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_u32)))
+uint64_t __arm_vmlaldavq_p_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_u32)))
+uint64_t __arm_vmlaldavq_p(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_s16)))
+int64_t __arm_vmlaldavq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_s16)))
+int64_t __arm_vmlaldavq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_s32)))
+int64_t __arm_vmlaldavq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_s32)))
+int64_t __arm_vmlaldavq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_u16)))
+uint64_t __arm_vmlaldavq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_u16)))
+uint64_t __arm_vmlaldavq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_u32)))
+uint64_t __arm_vmlaldavq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_u32)))
+uint64_t __arm_vmlaldavq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_p_s16)))
+int64_t __arm_vmlaldavxq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_p_s16)))
+int64_t __arm_vmlaldavxq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_p_s32)))
+int64_t __arm_vmlaldavxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_p_s32)))
+int64_t __arm_vmlaldavxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_s16)))
+int64_t __arm_vmlaldavxq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_s16)))
+int64_t __arm_vmlaldavxq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_s32)))
+int64_t __arm_vmlaldavxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_s32)))
+int64_t __arm_vmlaldavxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s16)))
+int16x8_t __arm_vmlaq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s16)))
+int16x8_t __arm_vmlaq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s32)))
+int32x4_t __arm_vmlaq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s32)))
+int32x4_t __arm_vmlaq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s8)))
+int8x16_t __arm_vmlaq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s8)))
+int8x16_t __arm_vmlaq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u16)))
+uint16x8_t __arm_vmlaq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u16)))
+uint16x8_t __arm_vmlaq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u32)))
+uint32x4_t __arm_vmlaq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u32)))
+uint32x4_t __arm_vmlaq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u8)))
+uint8x16_t __arm_vmlaq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u8)))
+uint8x16_t __arm_vmlaq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s16)))
+int16x8_t __arm_vmlaq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s16)))
+int16x8_t __arm_vmlaq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s32)))
+int32x4_t __arm_vmlaq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s32)))
+int32x4_t __arm_vmlaq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s8)))
+int8x16_t __arm_vmlaq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s8)))
+int8x16_t __arm_vmlaq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u16)))
+uint16x8_t __arm_vmlaq_n_u16(uint16x8_t, uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u16)))
+uint16x8_t __arm_vmlaq(uint16x8_t, uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u32)))
+uint32x4_t __arm_vmlaq_n_u32(uint32x4_t, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u32)))
+uint32x4_t __arm_vmlaq(uint32x4_t, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u8)))
+uint8x16_t __arm_vmlaq_n_u8(uint8x16_t, uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u8)))
+uint8x16_t __arm_vmlaq(uint8x16_t, uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s16)))
+int16x8_t __arm_vmlasq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s16)))
+int16x8_t __arm_vmlasq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s32)))
+int32x4_t __arm_vmlasq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s32)))
+int32x4_t __arm_vmlasq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s8)))
+int8x16_t __arm_vmlasq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s8)))
+int8x16_t __arm_vmlasq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u16)))
+uint16x8_t __arm_vmlasq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u16)))
+uint16x8_t __arm_vmlasq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u32)))
+uint32x4_t __arm_vmlasq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u32)))
+uint32x4_t __arm_vmlasq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u8)))
+uint8x16_t __arm_vmlasq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u8)))
+uint8x16_t __arm_vmlasq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s16)))
+int16x8_t __arm_vmlasq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s16)))
+int16x8_t __arm_vmlasq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s32)))
+int32x4_t __arm_vmlasq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s32)))
+int32x4_t __arm_vmlasq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s8)))
+int8x16_t __arm_vmlasq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s8)))
+int8x16_t __arm_vmlasq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u16)))
+uint16x8_t __arm_vmlasq_n_u16(uint16x8_t, uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u16)))
+uint16x8_t __arm_vmlasq(uint16x8_t, uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u32)))
+uint32x4_t __arm_vmlasq_n_u32(uint32x4_t, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u32)))
+uint32x4_t __arm_vmlasq(uint32x4_t, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u8)))
+uint8x16_t __arm_vmlasq_n_u8(uint8x16_t, uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u8)))
+uint8x16_t __arm_vmlasq(uint8x16_t, uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s16)))
+int32_t __arm_vmlsdavaq_p_s16(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s16)))
+int32_t __arm_vmlsdavaq_p(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s32)))
+int32_t __arm_vmlsdavaq_p_s32(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s32)))
+int32_t __arm_vmlsdavaq_p(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s8)))
+int32_t __arm_vmlsdavaq_p_s8(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s8)))
+int32_t __arm_vmlsdavaq_p(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s16)))
+int32_t __arm_vmlsdavaq_s16(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s16)))
+int32_t __arm_vmlsdavaq(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s32)))
+int32_t __arm_vmlsdavaq_s32(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s32)))
+int32_t __arm_vmlsdavaq(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s8)))
+int32_t __arm_vmlsdavaq_s8(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s8)))
+int32_t __arm_vmlsdavaq(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s16)))
+int32_t __arm_vmlsdavaxq_p_s16(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s16)))
+int32_t __arm_vmlsdavaxq_p(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s32)))
+int32_t __arm_vmlsdavaxq_p_s32(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s32)))
+int32_t __arm_vmlsdavaxq_p(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s8)))
+int32_t __arm_vmlsdavaxq_p_s8(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s8)))
+int32_t __arm_vmlsdavaxq_p(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s16)))
+int32_t __arm_vmlsdavaxq_s16(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s16)))
+int32_t __arm_vmlsdavaxq(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s32)))
+int32_t __arm_vmlsdavaxq_s32(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s32)))
+int32_t __arm_vmlsdavaxq(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s8)))
+int32_t __arm_vmlsdavaxq_s8(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s8)))
+int32_t __arm_vmlsdavaxq(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s16)))
+int32_t __arm_vmlsdavq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s16)))
+int32_t __arm_vmlsdavq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s32)))
+int32_t __arm_vmlsdavq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s32)))
+int32_t __arm_vmlsdavq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s8)))
+int32_t __arm_vmlsdavq_p_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s8)))
+int32_t __arm_vmlsdavq_p(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s16)))
+int32_t __arm_vmlsdavq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s16)))
+int32_t __arm_vmlsdavq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s32)))
+int32_t __arm_vmlsdavq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s32)))
+int32_t __arm_vmlsdavq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s8)))
+int32_t __arm_vmlsdavq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s8)))
+int32_t __arm_vmlsdavq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s16)))
+int32_t __arm_vmlsdavxq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s16)))
+int32_t __arm_vmlsdavxq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s32)))
+int32_t __arm_vmlsdavxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s32)))
+int32_t __arm_vmlsdavxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s8)))
+int32_t __arm_vmlsdavxq_p_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s8)))
+int32_t __arm_vmlsdavxq_p(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s16)))
+int32_t __arm_vmlsdavxq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s16)))
+int32_t __arm_vmlsdavxq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s32)))
+int32_t __arm_vmlsdavxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s32)))
+int32_t __arm_vmlsdavxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s8)))
+int32_t __arm_vmlsdavxq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s8)))
+int32_t __arm_vmlsdavxq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_p_s16)))
+int64_t __arm_vmlsldavaq_p_s16(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_p_s16)))
+int64_t __arm_vmlsldavaq_p(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_p_s32)))
+int64_t __arm_vmlsldavaq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_p_s32)))
+int64_t __arm_vmlsldavaq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_s16)))
+int64_t __arm_vmlsldavaq_s16(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_s16)))
+int64_t __arm_vmlsldavaq(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_s32)))
+int64_t __arm_vmlsldavaq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_s32)))
+int64_t __arm_vmlsldavaq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_p_s16)))
+int64_t __arm_vmlsldavaxq_p_s16(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_p_s16)))
+int64_t __arm_vmlsldavaxq_p(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_p_s32)))
+int64_t __arm_vmlsldavaxq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_p_s32)))
+int64_t __arm_vmlsldavaxq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_s16)))
+int64_t __arm_vmlsldavaxq_s16(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_s16)))
+int64_t __arm_vmlsldavaxq(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_s32)))
+int64_t __arm_vmlsldavaxq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_s32)))
+int64_t __arm_vmlsldavaxq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_p_s16)))
+int64_t __arm_vmlsldavq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_p_s16)))
+int64_t __arm_vmlsldavq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_p_s32)))
+int64_t __arm_vmlsldavq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_p_s32)))
+int64_t __arm_vmlsldavq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_s16)))
+int64_t __arm_vmlsldavq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_s16)))
+int64_t __arm_vmlsldavq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_s32)))
+int64_t __arm_vmlsldavq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_s32)))
+int64_t __arm_vmlsldavq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_p_s16)))
+int64_t __arm_vmlsldavxq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_p_s16)))
+int64_t __arm_vmlsldavxq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_p_s32)))
+int64_t __arm_vmlsldavxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_p_s32)))
+int64_t __arm_vmlsldavxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_s16)))
+int64_t __arm_vmlsldavxq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_s16)))
+int64_t __arm_vmlsldavxq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_s32)))
+int64_t __arm_vmlsldavxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_s32)))
+int64_t __arm_vmlsldavxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_s16)))
+int32x4_t __arm_vmovlbq_m_s16(int32x4_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_s16)))
+int32x4_t __arm_vmovlbq_m(int32x4_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_s8)))
+int16x8_t __arm_vmovlbq_m_s8(int16x8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_s8)))
+int16x8_t __arm_vmovlbq_m(int16x8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_u16)))
+uint32x4_t __arm_vmovlbq_m_u16(uint32x4_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_u16)))
+uint32x4_t __arm_vmovlbq_m(uint32x4_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_u8)))
+uint16x8_t __arm_vmovlbq_m_u8(uint16x8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_u8)))
+uint16x8_t __arm_vmovlbq_m(uint16x8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_s16)))
+int32x4_t __arm_vmovlbq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_s16)))
+int32x4_t __arm_vmovlbq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_s8)))
+int16x8_t __arm_vmovlbq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_s8)))
+int16x8_t __arm_vmovlbq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_u16)))
+uint32x4_t __arm_vmovlbq_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_u16)))
+uint32x4_t __arm_vmovlbq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_u8)))
+uint16x8_t __arm_vmovlbq_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_u8)))
+uint16x8_t __arm_vmovlbq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_s16)))
+int32x4_t __arm_vmovlbq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_s16)))
+int32x4_t __arm_vmovlbq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_s8)))
+int16x8_t __arm_vmovlbq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_s8)))
+int16x8_t __arm_vmovlbq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_u16)))
+uint32x4_t __arm_vmovlbq_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_u16)))
+uint32x4_t __arm_vmovlbq_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_u8)))
+uint16x8_t __arm_vmovlbq_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_u8)))
+uint16x8_t __arm_vmovlbq_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_s16)))
+int32x4_t __arm_vmovltq_m_s16(int32x4_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_s16)))
+int32x4_t __arm_vmovltq_m(int32x4_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_s8)))
+int16x8_t __arm_vmovltq_m_s8(int16x8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_s8)))
+int16x8_t __arm_vmovltq_m(int16x8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_u16)))
+uint32x4_t __arm_vmovltq_m_u16(uint32x4_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_u16)))
+uint32x4_t __arm_vmovltq_m(uint32x4_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_u8)))
+uint16x8_t __arm_vmovltq_m_u8(uint16x8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_u8)))
+uint16x8_t __arm_vmovltq_m(uint16x8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_s16)))
+int32x4_t __arm_vmovltq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_s16)))
+int32x4_t __arm_vmovltq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_s8)))
+int16x8_t __arm_vmovltq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_s8)))
+int16x8_t __arm_vmovltq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_u16)))
+uint32x4_t __arm_vmovltq_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_u16)))
+uint32x4_t __arm_vmovltq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_u8)))
+uint16x8_t __arm_vmovltq_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_u8)))
+uint16x8_t __arm_vmovltq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_s16)))
+int32x4_t __arm_vmovltq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_s16)))
+int32x4_t __arm_vmovltq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_s8)))
+int16x8_t __arm_vmovltq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_s8)))
+int16x8_t __arm_vmovltq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_u16)))
+uint32x4_t __arm_vmovltq_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_u16)))
+uint32x4_t __arm_vmovltq_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_u8)))
+uint16x8_t __arm_vmovltq_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_u8)))
+uint16x8_t __arm_vmovltq_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_s16)))
+int8x16_t __arm_vmovnbq_m_s16(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_s16)))
+int8x16_t __arm_vmovnbq_m(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_s32)))
+int16x8_t __arm_vmovnbq_m_s32(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_s32)))
+int16x8_t __arm_vmovnbq_m(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_u16)))
+uint8x16_t __arm_vmovnbq_m_u16(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_u16)))
+uint8x16_t __arm_vmovnbq_m(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_u32)))
+uint16x8_t __arm_vmovnbq_m_u32(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_u32)))
+uint16x8_t __arm_vmovnbq_m(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_s16)))
+int8x16_t __arm_vmovnbq_s16(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_s16)))
+int8x16_t __arm_vmovnbq(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_s32)))
+int16x8_t __arm_vmovnbq_s32(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_s32)))
+int16x8_t __arm_vmovnbq(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_u16)))
+uint8x16_t __arm_vmovnbq_u16(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_u16)))
+uint8x16_t __arm_vmovnbq(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_u32)))
+uint16x8_t __arm_vmovnbq_u32(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_u32)))
+uint16x8_t __arm_vmovnbq(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_s16)))
+int8x16_t __arm_vmovntq_m_s16(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_s16)))
+int8x16_t __arm_vmovntq_m(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_s32)))
+int16x8_t __arm_vmovntq_m_s32(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_s32)))
+int16x8_t __arm_vmovntq_m(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_u16)))
+uint8x16_t __arm_vmovntq_m_u16(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_u16)))
+uint8x16_t __arm_vmovntq_m(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_u32)))
+uint16x8_t __arm_vmovntq_m_u32(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_u32)))
+uint16x8_t __arm_vmovntq_m(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_s16)))
+int8x16_t __arm_vmovntq_s16(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_s16)))
+int8x16_t __arm_vmovntq(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_s32)))
+int16x8_t __arm_vmovntq_s32(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_s32)))
+int16x8_t __arm_vmovntq(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_u16)))
+uint8x16_t __arm_vmovntq_u16(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_u16)))
+uint8x16_t __arm_vmovntq(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_u32)))
+uint16x8_t __arm_vmovntq_u32(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_u32)))
+uint16x8_t __arm_vmovntq(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s16)))
+int16x8_t __arm_vmulhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s16)))
+int16x8_t __arm_vmulhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s32)))
+int32x4_t __arm_vmulhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s32)))
+int32x4_t __arm_vmulhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s8)))
+int8x16_t __arm_vmulhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s8)))
+int8x16_t __arm_vmulhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u16)))
+uint16x8_t __arm_vmulhq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u16)))
+uint16x8_t __arm_vmulhq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u32)))
+uint32x4_t __arm_vmulhq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u32)))
+uint32x4_t __arm_vmulhq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u8)))
+uint8x16_t __arm_vmulhq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u8)))
+uint8x16_t __arm_vmulhq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s16)))
+int16x8_t __arm_vmulhq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s16)))
+int16x8_t __arm_vmulhq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s32)))
+int32x4_t __arm_vmulhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s32)))
+int32x4_t __arm_vmulhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s8)))
+int8x16_t __arm_vmulhq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s8)))
+int8x16_t __arm_vmulhq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u16)))
+uint16x8_t __arm_vmulhq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u16)))
+uint16x8_t __arm_vmulhq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u32)))
+uint32x4_t __arm_vmulhq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u32)))
+uint32x4_t __arm_vmulhq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u8)))
+uint8x16_t __arm_vmulhq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u8)))
+uint8x16_t __arm_vmulhq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s16)))
+int16x8_t __arm_vmulhq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s16)))
+int16x8_t __arm_vmulhq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s32)))
+int32x4_t __arm_vmulhq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s32)))
+int32x4_t __arm_vmulhq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s8)))
+int8x16_t __arm_vmulhq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s8)))
+int8x16_t __arm_vmulhq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u16)))
+uint16x8_t __arm_vmulhq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u16)))
+uint16x8_t __arm_vmulhq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u32)))
+uint32x4_t __arm_vmulhq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u32)))
+uint32x4_t __arm_vmulhq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u8)))
+uint8x16_t __arm_vmulhq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u8)))
+uint8x16_t __arm_vmulhq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s16)))
+int32x4_t __arm_vmullbq_int_m_s16(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s16)))
+int32x4_t __arm_vmullbq_int_m(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s32)))
+int64x2_t __arm_vmullbq_int_m_s32(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s32)))
+int64x2_t __arm_vmullbq_int_m(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s8)))
+int16x8_t __arm_vmullbq_int_m_s8(int16x8_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s8)))
+int16x8_t __arm_vmullbq_int_m(int16x8_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u16)))
+uint32x4_t __arm_vmullbq_int_m_u16(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u16)))
+uint32x4_t __arm_vmullbq_int_m(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u32)))
+uint64x2_t __arm_vmullbq_int_m_u32(uint64x2_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u32)))
+uint64x2_t __arm_vmullbq_int_m(uint64x2_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u8)))
+uint16x8_t __arm_vmullbq_int_m_u8(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u8)))
+uint16x8_t __arm_vmullbq_int_m(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s16)))
+int32x4_t __arm_vmullbq_int_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s16)))
+int32x4_t __arm_vmullbq_int(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s32)))
+int64x2_t __arm_vmullbq_int_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s32)))
+int64x2_t __arm_vmullbq_int(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s8)))
+int16x8_t __arm_vmullbq_int_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s8)))
+int16x8_t __arm_vmullbq_int(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u16)))
+uint32x4_t __arm_vmullbq_int_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u16)))
+uint32x4_t __arm_vmullbq_int(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u32)))
+uint64x2_t __arm_vmullbq_int_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u32)))
+uint64x2_t __arm_vmullbq_int(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u8)))
+uint16x8_t __arm_vmullbq_int_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u8)))
+uint16x8_t __arm_vmullbq_int(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s16)))
+int32x4_t __arm_vmullbq_int_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s16)))
+int32x4_t __arm_vmullbq_int_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s32)))
+int64x2_t __arm_vmullbq_int_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s32)))
+int64x2_t __arm_vmullbq_int_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s8)))
+int16x8_t __arm_vmullbq_int_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s8)))
+int16x8_t __arm_vmullbq_int_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u16)))
+uint32x4_t __arm_vmullbq_int_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u16)))
+uint32x4_t __arm_vmullbq_int_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u32)))
+uint64x2_t __arm_vmullbq_int_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u32)))
+uint64x2_t __arm_vmullbq_int_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u8)))
+uint16x8_t __arm_vmullbq_int_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u8)))
+uint16x8_t __arm_vmullbq_int_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_m_p16)))
+uint32x4_t __arm_vmullbq_poly_m_p16(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_m_p16)))
+uint32x4_t __arm_vmullbq_poly_m(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_m_p8)))
+uint16x8_t __arm_vmullbq_poly_m_p8(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_m_p8)))
+uint16x8_t __arm_vmullbq_poly_m(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_p16)))
+uint32x4_t __arm_vmullbq_poly_p16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_p16)))
+uint32x4_t __arm_vmullbq_poly(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_p8)))
+uint16x8_t __arm_vmullbq_poly_p8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_p8)))
+uint16x8_t __arm_vmullbq_poly(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_x_p16)))
+uint32x4_t __arm_vmullbq_poly_x_p16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_x_p16)))
+uint32x4_t __arm_vmullbq_poly_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_x_p8)))
+uint16x8_t __arm_vmullbq_poly_x_p8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_x_p8)))
+uint16x8_t __arm_vmullbq_poly_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s16)))
+int32x4_t __arm_vmulltq_int_m_s16(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s16)))
+int32x4_t __arm_vmulltq_int_m(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s32)))
+int64x2_t __arm_vmulltq_int_m_s32(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s32)))
+int64x2_t __arm_vmulltq_int_m(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s8)))
+int16x8_t __arm_vmulltq_int_m_s8(int16x8_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s8)))
+int16x8_t __arm_vmulltq_int_m(int16x8_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u16)))
+uint32x4_t __arm_vmulltq_int_m_u16(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u16)))
+uint32x4_t __arm_vmulltq_int_m(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u32)))
+uint64x2_t __arm_vmulltq_int_m_u32(uint64x2_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u32)))
+uint64x2_t __arm_vmulltq_int_m(uint64x2_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u8)))
+uint16x8_t __arm_vmulltq_int_m_u8(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u8)))
+uint16x8_t __arm_vmulltq_int_m(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s16)))
+int32x4_t __arm_vmulltq_int_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s16)))
+int32x4_t __arm_vmulltq_int(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s32)))
+int64x2_t __arm_vmulltq_int_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s32)))
+int64x2_t __arm_vmulltq_int(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s8)))
+int16x8_t __arm_vmulltq_int_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s8)))
+int16x8_t __arm_vmulltq_int(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u16)))
+uint32x4_t __arm_vmulltq_int_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u16)))
+uint32x4_t __arm_vmulltq_int(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u32)))
+uint64x2_t __arm_vmulltq_int_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u32)))
+uint64x2_t __arm_vmulltq_int(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u8)))
+uint16x8_t __arm_vmulltq_int_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u8)))
+uint16x8_t __arm_vmulltq_int(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s16)))
+int32x4_t __arm_vmulltq_int_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s16)))
+int32x4_t __arm_vmulltq_int_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s32)))
+int64x2_t __arm_vmulltq_int_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s32)))
+int64x2_t __arm_vmulltq_int_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s8)))
+int16x8_t __arm_vmulltq_int_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s8)))
+int16x8_t __arm_vmulltq_int_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u16)))
+uint32x4_t __arm_vmulltq_int_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u16)))
+uint32x4_t __arm_vmulltq_int_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u32)))
+uint64x2_t __arm_vmulltq_int_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u32)))
+uint64x2_t __arm_vmulltq_int_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u8)))
+uint16x8_t __arm_vmulltq_int_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u8)))
+uint16x8_t __arm_vmulltq_int_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_m_p16)))
+uint32x4_t __arm_vmulltq_poly_m_p16(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_m_p16)))
+uint32x4_t __arm_vmulltq_poly_m(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_m_p8)))
+uint16x8_t __arm_vmulltq_poly_m_p8(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_m_p8)))
+uint16x8_t __arm_vmulltq_poly_m(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_p16)))
+uint32x4_t __arm_vmulltq_poly_p16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_p16)))
+uint32x4_t __arm_vmulltq_poly(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_p8)))
+uint16x8_t __arm_vmulltq_poly_p8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_p8)))
+uint16x8_t __arm_vmulltq_poly(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_x_p16)))
+uint32x4_t __arm_vmulltq_poly_x_p16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_x_p16)))
+uint32x4_t __arm_vmulltq_poly_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_x_p8)))
+uint16x8_t __arm_vmulltq_poly_x_p8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_x_p8)))
+uint16x8_t __arm_vmulltq_poly_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s16)))
+int16x8_t __arm_vmulq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s16)))
+int16x8_t __arm_vmulq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s32)))
+int32x4_t __arm_vmulq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s32)))
+int32x4_t __arm_vmulq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s8)))
+int8x16_t __arm_vmulq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s8)))
+int8x16_t __arm_vmulq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u16)))
+uint16x8_t __arm_vmulq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u16)))
+uint16x8_t __arm_vmulq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u32)))
+uint32x4_t __arm_vmulq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u32)))
+uint32x4_t __arm_vmulq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u8)))
+uint8x16_t __arm_vmulq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u8)))
+uint8x16_t __arm_vmulq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s16)))
+int16x8_t __arm_vmulq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s16)))
+int16x8_t __arm_vmulq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s32)))
+int32x4_t __arm_vmulq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s32)))
+int32x4_t __arm_vmulq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s8)))
+int8x16_t __arm_vmulq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s8)))
+int8x16_t __arm_vmulq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u16)))
+uint16x8_t __arm_vmulq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u16)))
+uint16x8_t __arm_vmulq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u32)))
+uint32x4_t __arm_vmulq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u32)))
+uint32x4_t __arm_vmulq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u8)))
+uint8x16_t __arm_vmulq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u8)))
+uint8x16_t __arm_vmulq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s16)))
+int16x8_t __arm_vmulq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s16)))
+int16x8_t __arm_vmulq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s32)))
+int32x4_t __arm_vmulq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s32)))
+int32x4_t __arm_vmulq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s8)))
+int8x16_t __arm_vmulq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s8)))
+int8x16_t __arm_vmulq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u16)))
+uint16x8_t __arm_vmulq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u16)))
+uint16x8_t __arm_vmulq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u32)))
+uint32x4_t __arm_vmulq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u32)))
+uint32x4_t __arm_vmulq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u8)))
+uint8x16_t __arm_vmulq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u8)))
+uint8x16_t __arm_vmulq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s16)))
+int16x8_t __arm_vmulq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s16)))
+int16x8_t __arm_vmulq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s32)))
+int32x4_t __arm_vmulq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s32)))
+int32x4_t __arm_vmulq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s8)))
+int8x16_t __arm_vmulq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s8)))
+int8x16_t __arm_vmulq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u16)))
+uint16x8_t __arm_vmulq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u16)))
+uint16x8_t __arm_vmulq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u32)))
+uint32x4_t __arm_vmulq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u32)))
+uint32x4_t __arm_vmulq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u8)))
+uint8x16_t __arm_vmulq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u8)))
+uint8x16_t __arm_vmulq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s16)))
+int16x8_t __arm_vmulq_x_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s16)))
+int16x8_t __arm_vmulq_x(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s32)))
+int32x4_t __arm_vmulq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s32)))
+int32x4_t __arm_vmulq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s8)))
+int8x16_t __arm_vmulq_x_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s8)))
+int8x16_t __arm_vmulq_x(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u16)))
+uint16x8_t __arm_vmulq_x_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u16)))
+uint16x8_t __arm_vmulq_x(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u32)))
+uint32x4_t __arm_vmulq_x_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u32)))
+uint32x4_t __arm_vmulq_x(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u8)))
+uint8x16_t __arm_vmulq_x_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u8)))
+uint8x16_t __arm_vmulq_x(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s16)))
+int16x8_t __arm_vmulq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s16)))
+int16x8_t __arm_vmulq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s32)))
+int32x4_t __arm_vmulq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s32)))
+int32x4_t __arm_vmulq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s8)))
+int8x16_t __arm_vmulq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s8)))
+int8x16_t __arm_vmulq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u16)))
+uint16x8_t __arm_vmulq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u16)))
+uint16x8_t __arm_vmulq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u32)))
+uint32x4_t __arm_vmulq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u32)))
+uint32x4_t __arm_vmulq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u8)))
+uint8x16_t __arm_vmulq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u8)))
+uint8x16_t __arm_vmulq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_s16)))
+int16x8_t __arm_vmvnq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_s16)))
+int16x8_t __arm_vmvnq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_s32)))
+int32x4_t __arm_vmvnq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_s32)))
+int32x4_t __arm_vmvnq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_u16)))
+uint16x8_t __arm_vmvnq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_u16)))
+uint16x8_t __arm_vmvnq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_u32)))
+uint32x4_t __arm_vmvnq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_u32)))
+uint32x4_t __arm_vmvnq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s16)))
+int16x8_t __arm_vmvnq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s16)))
+int16x8_t __arm_vmvnq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s32)))
+int32x4_t __arm_vmvnq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s32)))
+int32x4_t __arm_vmvnq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s8)))
+int8x16_t __arm_vmvnq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s8)))
+int8x16_t __arm_vmvnq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u16)))
+uint16x8_t __arm_vmvnq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u16)))
+uint16x8_t __arm_vmvnq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u32)))
+uint32x4_t __arm_vmvnq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u32)))
+uint32x4_t __arm_vmvnq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u8)))
+uint8x16_t __arm_vmvnq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u8)))
+uint8x16_t __arm_vmvnq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_n_s16)))
+int16x8_t __arm_vmvnq_n_s16(int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_n_s32)))
+int32x4_t __arm_vmvnq_n_s32(int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_n_u16)))
+uint16x8_t __arm_vmvnq_n_u16(uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_n_u32)))
+uint32x4_t __arm_vmvnq_n_u32(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s16)))
+int16x8_t __arm_vmvnq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s16)))
+int16x8_t __arm_vmvnq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s32)))
+int32x4_t __arm_vmvnq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s32)))
+int32x4_t __arm_vmvnq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s8)))
+int8x16_t __arm_vmvnq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s8)))
+int8x16_t __arm_vmvnq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u16)))
+uint16x8_t __arm_vmvnq_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u16)))
+uint16x8_t __arm_vmvnq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u32)))
+uint32x4_t __arm_vmvnq_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u32)))
+uint32x4_t __arm_vmvnq(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u8)))
+uint8x16_t __arm_vmvnq_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u8)))
+uint8x16_t __arm_vmvnq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_n_s16)))
+int16x8_t __arm_vmvnq_x_n_s16(int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_n_s32)))
+int32x4_t __arm_vmvnq_x_n_s32(int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_n_u16)))
+uint16x8_t __arm_vmvnq_x_n_u16(uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_n_u32)))
+uint32x4_t __arm_vmvnq_x_n_u32(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s16)))
+int16x8_t __arm_vmvnq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s16)))
+int16x8_t __arm_vmvnq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s32)))
+int32x4_t __arm_vmvnq_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s32)))
+int32x4_t __arm_vmvnq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s8)))
+int8x16_t __arm_vmvnq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s8)))
+int8x16_t __arm_vmvnq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u16)))
+uint16x8_t __arm_vmvnq_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u16)))
+uint16x8_t __arm_vmvnq_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u32)))
+uint32x4_t __arm_vmvnq_x_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u32)))
+uint32x4_t __arm_vmvnq_x(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u8)))
+uint8x16_t __arm_vmvnq_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u8)))
+uint8x16_t __arm_vmvnq_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s16)))
+int16x8_t __arm_vnegq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s16)))
+int16x8_t __arm_vnegq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s32)))
+int32x4_t __arm_vnegq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s32)))
+int32x4_t __arm_vnegq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s8)))
+int8x16_t __arm_vnegq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s8)))
+int8x16_t __arm_vnegq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s16)))
+int16x8_t __arm_vnegq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s16)))
+int16x8_t __arm_vnegq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s32)))
+int32x4_t __arm_vnegq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s32)))
+int32x4_t __arm_vnegq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s8)))
+int8x16_t __arm_vnegq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s8)))
+int8x16_t __arm_vnegq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s16)))
+int16x8_t __arm_vnegq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s16)))
+int16x8_t __arm_vnegq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s32)))
+int32x4_t __arm_vnegq_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s32)))
+int32x4_t __arm_vnegq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s8)))
+int8x16_t __arm_vnegq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s8)))
+int8x16_t __arm_vnegq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s16)))
+int16x8_t __arm_vornq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s16)))
+int16x8_t __arm_vornq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s32)))
+int32x4_t __arm_vornq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s32)))
+int32x4_t __arm_vornq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s8)))
+int8x16_t __arm_vornq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s8)))
+int8x16_t __arm_vornq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u16)))
+uint16x8_t __arm_vornq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u16)))
+uint16x8_t __arm_vornq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u32)))
+uint32x4_t __arm_vornq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u32)))
+uint32x4_t __arm_vornq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u8)))
+uint8x16_t __arm_vornq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u8)))
+uint8x16_t __arm_vornq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_s16)))
+int16x8_t __arm_vornq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_s16)))
+int16x8_t __arm_vornq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_s32)))
+int32x4_t __arm_vornq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_s32)))
+int32x4_t __arm_vornq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_s8)))
+int8x16_t __arm_vornq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_s8)))
+int8x16_t __arm_vornq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_u16)))
+uint16x8_t __arm_vornq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_u16)))
+uint16x8_t __arm_vornq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_u32)))
+uint32x4_t __arm_vornq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_u32)))
+uint32x4_t __arm_vornq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_u8)))
+uint8x16_t __arm_vornq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_u8)))
+uint8x16_t __arm_vornq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s16)))
+int16x8_t __arm_vornq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s16)))
+int16x8_t __arm_vornq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s32)))
+int32x4_t __arm_vornq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s32)))
+int32x4_t __arm_vornq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s8)))
+int8x16_t __arm_vornq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s8)))
+int8x16_t __arm_vornq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u16)))
+uint16x8_t __arm_vornq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u16)))
+uint16x8_t __arm_vornq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u32)))
+uint32x4_t __arm_vornq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u32)))
+uint32x4_t __arm_vornq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u8)))
+uint8x16_t __arm_vornq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u8)))
+uint8x16_t __arm_vornq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_s16)))
+int16x8_t __arm_vorrq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_s16)))
+int16x8_t __arm_vorrq_m_n(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_s32)))
+int32x4_t __arm_vorrq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_s32)))
+int32x4_t __arm_vorrq_m_n(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_u16)))
+uint16x8_t __arm_vorrq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_u16)))
+uint16x8_t __arm_vorrq_m_n(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_u32)))
+uint32x4_t __arm_vorrq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_u32)))
+uint32x4_t __arm_vorrq_m_n(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s16)))
+int16x8_t __arm_vorrq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s16)))
+int16x8_t __arm_vorrq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s32)))
+int32x4_t __arm_vorrq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s32)))
+int32x4_t __arm_vorrq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s8)))
+int8x16_t __arm_vorrq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s8)))
+int8x16_t __arm_vorrq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u16)))
+uint16x8_t __arm_vorrq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u16)))
+uint16x8_t __arm_vorrq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u32)))
+uint32x4_t __arm_vorrq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u32)))
+uint32x4_t __arm_vorrq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u8)))
+uint8x16_t __arm_vorrq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u8)))
+uint8x16_t __arm_vorrq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_s16)))
+int16x8_t __arm_vorrq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_s16)))
+int16x8_t __arm_vorrq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_s32)))
+int32x4_t __arm_vorrq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_s32)))
+int32x4_t __arm_vorrq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_u16)))
+uint16x8_t __arm_vorrq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_u16)))
+uint16x8_t __arm_vorrq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_u32)))
+uint32x4_t __arm_vorrq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_u32)))
+uint32x4_t __arm_vorrq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s16)))
+int16x8_t __arm_vorrq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s16)))
+int16x8_t __arm_vorrq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s32)))
+int32x4_t __arm_vorrq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s32)))
+int32x4_t __arm_vorrq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s8)))
+int8x16_t __arm_vorrq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s8)))
+int8x16_t __arm_vorrq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u16)))
+uint16x8_t __arm_vorrq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u16)))
+uint16x8_t __arm_vorrq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u32)))
+uint32x4_t __arm_vorrq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u32)))
+uint32x4_t __arm_vorrq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u8)))
+uint8x16_t __arm_vorrq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u8)))
+uint8x16_t __arm_vorrq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s16)))
+int16x8_t __arm_vorrq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s16)))
+int16x8_t __arm_vorrq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s32)))
+int32x4_t __arm_vorrq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s32)))
+int32x4_t __arm_vorrq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s8)))
+int8x16_t __arm_vorrq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s8)))
+int8x16_t __arm_vorrq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u16)))
+uint16x8_t __arm_vorrq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u16)))
+uint16x8_t __arm_vorrq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u32)))
+uint32x4_t __arm_vorrq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u32)))
+uint32x4_t __arm_vorrq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u8)))
+uint8x16_t __arm_vorrq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u8)))
+uint8x16_t __arm_vorrq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpnot)))
+mve_pred16_t __arm_vpnot(mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s16)))
+int16x8_t __arm_vpselq_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s16)))
+int16x8_t __arm_vpselq(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s32)))
+int32x4_t __arm_vpselq_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s32)))
+int32x4_t __arm_vpselq(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s64)))
+int64x2_t __arm_vpselq_s64(int64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s64)))
+int64x2_t __arm_vpselq(int64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s8)))
+int8x16_t __arm_vpselq_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s8)))
+int8x16_t __arm_vpselq(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u16)))
+uint16x8_t __arm_vpselq_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u16)))
+uint16x8_t __arm_vpselq(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u32)))
+uint32x4_t __arm_vpselq_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u32)))
+uint32x4_t __arm_vpselq(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u64)))
+uint64x2_t __arm_vpselq_u64(uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u64)))
+uint64x2_t __arm_vpselq(uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u8)))
+uint8x16_t __arm_vpselq_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u8)))
+uint8x16_t __arm_vpselq(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s16)))
+int16x8_t __arm_vqabsq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s16)))
+int16x8_t __arm_vqabsq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s32)))
+int32x4_t __arm_vqabsq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s32)))
+int32x4_t __arm_vqabsq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s8)))
+int8x16_t __arm_vqabsq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s8)))
+int8x16_t __arm_vqabsq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s16)))
+int16x8_t __arm_vqabsq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s16)))
+int16x8_t __arm_vqabsq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s32)))
+int32x4_t __arm_vqabsq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s32)))
+int32x4_t __arm_vqabsq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s8)))
+int8x16_t __arm_vqabsq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s8)))
+int8x16_t __arm_vqabsq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s16)))
+int16x8_t __arm_vqaddq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s16)))
+int16x8_t __arm_vqaddq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s32)))
+int32x4_t __arm_vqaddq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s32)))
+int32x4_t __arm_vqaddq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s8)))
+int8x16_t __arm_vqaddq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s8)))
+int8x16_t __arm_vqaddq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u16)))
+uint16x8_t __arm_vqaddq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u16)))
+uint16x8_t __arm_vqaddq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u32)))
+uint32x4_t __arm_vqaddq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u32)))
+uint32x4_t __arm_vqaddq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u8)))
+uint8x16_t __arm_vqaddq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u8)))
+uint8x16_t __arm_vqaddq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s16)))
+int16x8_t __arm_vqaddq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s16)))
+int16x8_t __arm_vqaddq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s32)))
+int32x4_t __arm_vqaddq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s32)))
+int32x4_t __arm_vqaddq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s8)))
+int8x16_t __arm_vqaddq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s8)))
+int8x16_t __arm_vqaddq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u16)))
+uint16x8_t __arm_vqaddq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u16)))
+uint16x8_t __arm_vqaddq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u32)))
+uint32x4_t __arm_vqaddq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u32)))
+uint32x4_t __arm_vqaddq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u8)))
+uint8x16_t __arm_vqaddq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u8)))
+uint8x16_t __arm_vqaddq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s16)))
+int16x8_t __arm_vqaddq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s16)))
+int16x8_t __arm_vqaddq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s32)))
+int32x4_t __arm_vqaddq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s32)))
+int32x4_t __arm_vqaddq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s8)))
+int8x16_t __arm_vqaddq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s8)))
+int8x16_t __arm_vqaddq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u16)))
+uint16x8_t __arm_vqaddq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u16)))
+uint16x8_t __arm_vqaddq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u32)))
+uint32x4_t __arm_vqaddq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u32)))
+uint32x4_t __arm_vqaddq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u8)))
+uint8x16_t __arm_vqaddq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u8)))
+uint8x16_t __arm_vqaddq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s16)))
+int16x8_t __arm_vqaddq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s16)))
+int16x8_t __arm_vqaddq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s32)))
+int32x4_t __arm_vqaddq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s32)))
+int32x4_t __arm_vqaddq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s8)))
+int8x16_t __arm_vqaddq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s8)))
+int8x16_t __arm_vqaddq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u16)))
+uint16x8_t __arm_vqaddq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u16)))
+uint16x8_t __arm_vqaddq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u32)))
+uint32x4_t __arm_vqaddq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u32)))
+uint32x4_t __arm_vqaddq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u8)))
+uint8x16_t __arm_vqaddq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u8)))
+uint8x16_t __arm_vqaddq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s16)))
+int16x8_t __arm_vqdmladhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s16)))
+int16x8_t __arm_vqdmladhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s32)))
+int32x4_t __arm_vqdmladhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s32)))
+int32x4_t __arm_vqdmladhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s8)))
+int8x16_t __arm_vqdmladhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s8)))
+int8x16_t __arm_vqdmladhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s16)))
+int16x8_t __arm_vqdmladhq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s16)))
+int16x8_t __arm_vqdmladhq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s32)))
+int32x4_t __arm_vqdmladhq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s32)))
+int32x4_t __arm_vqdmladhq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s8)))
+int8x16_t __arm_vqdmladhq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s8)))
+int8x16_t __arm_vqdmladhq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s16)))
+int16x8_t __arm_vqdmladhxq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s16)))
+int16x8_t __arm_vqdmladhxq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s32)))
+int32x4_t __arm_vqdmladhxq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s32)))
+int32x4_t __arm_vqdmladhxq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s8)))
+int8x16_t __arm_vqdmladhxq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s8)))
+int8x16_t __arm_vqdmladhxq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s16)))
+int16x8_t __arm_vqdmladhxq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s16)))
+int16x8_t __arm_vqdmladhxq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s32)))
+int32x4_t __arm_vqdmladhxq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s32)))
+int32x4_t __arm_vqdmladhxq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s8)))
+int8x16_t __arm_vqdmladhxq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s8)))
+int8x16_t __arm_vqdmladhxq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s16)))
+int16x8_t __arm_vqdmlahq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s16)))
+int16x8_t __arm_vqdmlahq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s32)))
+int32x4_t __arm_vqdmlahq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s32)))
+int32x4_t __arm_vqdmlahq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s8)))
+int8x16_t __arm_vqdmlahq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s8)))
+int8x16_t __arm_vqdmlahq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s16)))
+int16x8_t __arm_vqdmlahq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s16)))
+int16x8_t __arm_vqdmlahq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s32)))
+int32x4_t __arm_vqdmlahq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s32)))
+int32x4_t __arm_vqdmlahq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s8)))
+int8x16_t __arm_vqdmlahq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s8)))
+int8x16_t __arm_vqdmlahq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s16)))
+int16x8_t __arm_vqdmlashq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s16)))
+int16x8_t __arm_vqdmlashq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s32)))
+int32x4_t __arm_vqdmlashq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s32)))
+int32x4_t __arm_vqdmlashq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s8)))
+int8x16_t __arm_vqdmlashq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s8)))
+int8x16_t __arm_vqdmlashq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s16)))
+int16x8_t __arm_vqdmlashq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s16)))
+int16x8_t __arm_vqdmlashq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s32)))
+int32x4_t __arm_vqdmlashq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s32)))
+int32x4_t __arm_vqdmlashq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s8)))
+int8x16_t __arm_vqdmlashq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s8)))
+int8x16_t __arm_vqdmlashq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s16)))
+int16x8_t __arm_vqdmlsdhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s16)))
+int16x8_t __arm_vqdmlsdhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s32)))
+int32x4_t __arm_vqdmlsdhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s32)))
+int32x4_t __arm_vqdmlsdhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s8)))
+int8x16_t __arm_vqdmlsdhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s8)))
+int8x16_t __arm_vqdmlsdhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s16)))
+int16x8_t __arm_vqdmlsdhq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s16)))
+int16x8_t __arm_vqdmlsdhq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s32)))
+int32x4_t __arm_vqdmlsdhq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s32)))
+int32x4_t __arm_vqdmlsdhq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s8)))
+int8x16_t __arm_vqdmlsdhq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s8)))
+int8x16_t __arm_vqdmlsdhq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s16)))
+int16x8_t __arm_vqdmlsdhxq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s16)))
+int16x8_t __arm_vqdmlsdhxq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s32)))
+int32x4_t __arm_vqdmlsdhxq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s32)))
+int32x4_t __arm_vqdmlsdhxq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s8)))
+int8x16_t __arm_vqdmlsdhxq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s8)))
+int8x16_t __arm_vqdmlsdhxq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s16)))
+int16x8_t __arm_vqdmlsdhxq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s16)))
+int16x8_t __arm_vqdmlsdhxq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s32)))
+int32x4_t __arm_vqdmlsdhxq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s32)))
+int32x4_t __arm_vqdmlsdhxq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s8)))
+int8x16_t __arm_vqdmlsdhxq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s8)))
+int8x16_t __arm_vqdmlsdhxq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s16)))
+int16x8_t __arm_vqdmulhq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s16)))
+int16x8_t __arm_vqdmulhq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s32)))
+int32x4_t __arm_vqdmulhq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s32)))
+int32x4_t __arm_vqdmulhq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s8)))
+int8x16_t __arm_vqdmulhq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s8)))
+int8x16_t __arm_vqdmulhq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s16)))
+int16x8_t __arm_vqdmulhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s16)))
+int16x8_t __arm_vqdmulhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s32)))
+int32x4_t __arm_vqdmulhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s32)))
+int32x4_t __arm_vqdmulhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s8)))
+int8x16_t __arm_vqdmulhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s8)))
+int8x16_t __arm_vqdmulhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s16)))
+int16x8_t __arm_vqdmulhq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s16)))
+int16x8_t __arm_vqdmulhq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s32)))
+int32x4_t __arm_vqdmulhq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s32)))
+int32x4_t __arm_vqdmulhq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s8)))
+int8x16_t __arm_vqdmulhq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s8)))
+int8x16_t __arm_vqdmulhq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s16)))
+int16x8_t __arm_vqdmulhq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s16)))
+int16x8_t __arm_vqdmulhq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s32)))
+int32x4_t __arm_vqdmulhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s32)))
+int32x4_t __arm_vqdmulhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s8)))
+int8x16_t __arm_vqdmulhq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s8)))
+int8x16_t __arm_vqdmulhq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_n_s16)))
+int32x4_t __arm_vqdmullbq_m_n_s16(int32x4_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_n_s16)))
+int32x4_t __arm_vqdmullbq_m(int32x4_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_n_s32)))
+int64x2_t __arm_vqdmullbq_m_n_s32(int64x2_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_n_s32)))
+int64x2_t __arm_vqdmullbq_m(int64x2_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_s16)))
+int32x4_t __arm_vqdmullbq_m_s16(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_s16)))
+int32x4_t __arm_vqdmullbq_m(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_s32)))
+int64x2_t __arm_vqdmullbq_m_s32(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_s32)))
+int64x2_t __arm_vqdmullbq_m(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_n_s16)))
+int32x4_t __arm_vqdmullbq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_n_s16)))
+int32x4_t __arm_vqdmullbq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_n_s32)))
+int64x2_t __arm_vqdmullbq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_n_s32)))
+int64x2_t __arm_vqdmullbq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_s16)))
+int32x4_t __arm_vqdmullbq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_s16)))
+int32x4_t __arm_vqdmullbq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_s32)))
+int64x2_t __arm_vqdmullbq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_s32)))
+int64x2_t __arm_vqdmullbq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_n_s16)))
+int32x4_t __arm_vqdmulltq_m_n_s16(int32x4_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_n_s16)))
+int32x4_t __arm_vqdmulltq_m(int32x4_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_n_s32)))
+int64x2_t __arm_vqdmulltq_m_n_s32(int64x2_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_n_s32)))
+int64x2_t __arm_vqdmulltq_m(int64x2_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_s16)))
+int32x4_t __arm_vqdmulltq_m_s16(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_s16)))
+int32x4_t __arm_vqdmulltq_m(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_s32)))
+int64x2_t __arm_vqdmulltq_m_s32(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_s32)))
+int64x2_t __arm_vqdmulltq_m(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_n_s16)))
+int32x4_t __arm_vqdmulltq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_n_s16)))
+int32x4_t __arm_vqdmulltq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_n_s32)))
+int64x2_t __arm_vqdmulltq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_n_s32)))
+int64x2_t __arm_vqdmulltq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_s16)))
+int32x4_t __arm_vqdmulltq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_s16)))
+int32x4_t __arm_vqdmulltq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_s32)))
+int64x2_t __arm_vqdmulltq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_s32)))
+int64x2_t __arm_vqdmulltq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_s16)))
+int8x16_t __arm_vqmovnbq_m_s16(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_s16)))
+int8x16_t __arm_vqmovnbq_m(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_s32)))
+int16x8_t __arm_vqmovnbq_m_s32(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_s32)))
+int16x8_t __arm_vqmovnbq_m(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_u16)))
+uint8x16_t __arm_vqmovnbq_m_u16(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_u16)))
+uint8x16_t __arm_vqmovnbq_m(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_u32)))
+uint16x8_t __arm_vqmovnbq_m_u32(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_u32)))
+uint16x8_t __arm_vqmovnbq_m(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_s16)))
+int8x16_t __arm_vqmovnbq_s16(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_s16)))
+int8x16_t __arm_vqmovnbq(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_s32)))
+int16x8_t __arm_vqmovnbq_s32(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_s32)))
+int16x8_t __arm_vqmovnbq(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_u16)))
+uint8x16_t __arm_vqmovnbq_u16(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_u16)))
+uint8x16_t __arm_vqmovnbq(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_u32)))
+uint16x8_t __arm_vqmovnbq_u32(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_u32)))
+uint16x8_t __arm_vqmovnbq(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_s16)))
+int8x16_t __arm_vqmovntq_m_s16(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_s16)))
+int8x16_t __arm_vqmovntq_m(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_s32)))
+int16x8_t __arm_vqmovntq_m_s32(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_s32)))
+int16x8_t __arm_vqmovntq_m(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_u16)))
+uint8x16_t __arm_vqmovntq_m_u16(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_u16)))
+uint8x16_t __arm_vqmovntq_m(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_u32)))
+uint16x8_t __arm_vqmovntq_m_u32(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_u32)))
+uint16x8_t __arm_vqmovntq_m(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_s16)))
+int8x16_t __arm_vqmovntq_s16(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_s16)))
+int8x16_t __arm_vqmovntq(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_s32)))
+int16x8_t __arm_vqmovntq_s32(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_s32)))
+int16x8_t __arm_vqmovntq(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_u16)))
+uint8x16_t __arm_vqmovntq_u16(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_u16)))
+uint8x16_t __arm_vqmovntq(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_u32)))
+uint16x8_t __arm_vqmovntq_u32(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_u32)))
+uint16x8_t __arm_vqmovntq(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_m_s16)))
+uint8x16_t __arm_vqmovunbq_m_s16(uint8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_m_s16)))
+uint8x16_t __arm_vqmovunbq_m(uint8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_m_s32)))
+uint16x8_t __arm_vqmovunbq_m_s32(uint16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_m_s32)))
+uint16x8_t __arm_vqmovunbq_m(uint16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_s16)))
+uint8x16_t __arm_vqmovunbq_s16(uint8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_s16)))
+uint8x16_t __arm_vqmovunbq(uint8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_s32)))
+uint16x8_t __arm_vqmovunbq_s32(uint16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_s32)))
+uint16x8_t __arm_vqmovunbq(uint16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_m_s16)))
+uint8x16_t __arm_vqmovuntq_m_s16(uint8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_m_s16)))
+uint8x16_t __arm_vqmovuntq_m(uint8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_m_s32)))
+uint16x8_t __arm_vqmovuntq_m_s32(uint16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_m_s32)))
+uint16x8_t __arm_vqmovuntq_m(uint16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_s16)))
+uint8x16_t __arm_vqmovuntq_s16(uint8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_s16)))
+uint8x16_t __arm_vqmovuntq(uint8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_s32)))
+uint16x8_t __arm_vqmovuntq_s32(uint16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_s32)))
+uint16x8_t __arm_vqmovuntq(uint16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s16)))
+int16x8_t __arm_vqnegq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s16)))
+int16x8_t __arm_vqnegq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s32)))
+int32x4_t __arm_vqnegq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s32)))
+int32x4_t __arm_vqnegq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s8)))
+int8x16_t __arm_vqnegq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s8)))
+int8x16_t __arm_vqnegq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s16)))
+int16x8_t __arm_vqnegq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s16)))
+int16x8_t __arm_vqnegq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s32)))
+int32x4_t __arm_vqnegq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s32)))
+int32x4_t __arm_vqnegq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s8)))
+int8x16_t __arm_vqnegq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s8)))
+int8x16_t __arm_vqnegq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s16)))
+int16x8_t __arm_vqrdmladhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s16)))
+int16x8_t __arm_vqrdmladhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s32)))
+int32x4_t __arm_vqrdmladhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s32)))
+int32x4_t __arm_vqrdmladhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s8)))
+int8x16_t __arm_vqrdmladhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s8)))
+int8x16_t __arm_vqrdmladhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s16)))
+int16x8_t __arm_vqrdmladhq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s16)))
+int16x8_t __arm_vqrdmladhq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s32)))
+int32x4_t __arm_vqrdmladhq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s32)))
+int32x4_t __arm_vqrdmladhq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s8)))
+int8x16_t __arm_vqrdmladhq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s8)))
+int8x16_t __arm_vqrdmladhq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s16)))
+int16x8_t __arm_vqrdmladhxq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s16)))
+int16x8_t __arm_vqrdmladhxq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s32)))
+int32x4_t __arm_vqrdmladhxq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s32)))
+int32x4_t __arm_vqrdmladhxq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s8)))
+int8x16_t __arm_vqrdmladhxq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s8)))
+int8x16_t __arm_vqrdmladhxq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s16)))
+int16x8_t __arm_vqrdmladhxq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s16)))
+int16x8_t __arm_vqrdmladhxq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s32)))
+int32x4_t __arm_vqrdmladhxq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s32)))
+int32x4_t __arm_vqrdmladhxq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s8)))
+int8x16_t __arm_vqrdmladhxq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s8)))
+int8x16_t __arm_vqrdmladhxq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s16)))
+int16x8_t __arm_vqrdmlahq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s16)))
+int16x8_t __arm_vqrdmlahq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s32)))
+int32x4_t __arm_vqrdmlahq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s32)))
+int32x4_t __arm_vqrdmlahq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s8)))
+int8x16_t __arm_vqrdmlahq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s8)))
+int8x16_t __arm_vqrdmlahq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s16)))
+int16x8_t __arm_vqrdmlahq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s16)))
+int16x8_t __arm_vqrdmlahq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s32)))
+int32x4_t __arm_vqrdmlahq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s32)))
+int32x4_t __arm_vqrdmlahq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s8)))
+int8x16_t __arm_vqrdmlahq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s8)))
+int8x16_t __arm_vqrdmlahq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s16)))
+int16x8_t __arm_vqrdmlashq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s16)))
+int16x8_t __arm_vqrdmlashq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s32)))
+int32x4_t __arm_vqrdmlashq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s32)))
+int32x4_t __arm_vqrdmlashq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s8)))
+int8x16_t __arm_vqrdmlashq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s8)))
+int8x16_t __arm_vqrdmlashq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s16)))
+int16x8_t __arm_vqrdmlashq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s16)))
+int16x8_t __arm_vqrdmlashq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s32)))
+int32x4_t __arm_vqrdmlashq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s32)))
+int32x4_t __arm_vqrdmlashq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s8)))
+int8x16_t __arm_vqrdmlashq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s8)))
+int8x16_t __arm_vqrdmlashq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s16)))
+int16x8_t __arm_vqrdmlsdhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s16)))
+int16x8_t __arm_vqrdmlsdhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s32)))
+int32x4_t __arm_vqrdmlsdhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s32)))
+int32x4_t __arm_vqrdmlsdhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s8)))
+int8x16_t __arm_vqrdmlsdhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s8)))
+int8x16_t __arm_vqrdmlsdhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s16)))
+int16x8_t __arm_vqrdmlsdhq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s16)))
+int16x8_t __arm_vqrdmlsdhq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s32)))
+int32x4_t __arm_vqrdmlsdhq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s32)))
+int32x4_t __arm_vqrdmlsdhq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s8)))
+int8x16_t __arm_vqrdmlsdhq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s8)))
+int8x16_t __arm_vqrdmlsdhq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s16)))
+int16x8_t __arm_vqrdmlsdhxq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s16)))
+int16x8_t __arm_vqrdmlsdhxq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s32)))
+int32x4_t __arm_vqrdmlsdhxq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s32)))
+int32x4_t __arm_vqrdmlsdhxq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s8)))
+int8x16_t __arm_vqrdmlsdhxq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s8)))
+int8x16_t __arm_vqrdmlsdhxq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s16)))
+int16x8_t __arm_vqrdmlsdhxq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s16)))
+int16x8_t __arm_vqrdmlsdhxq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s32)))
+int32x4_t __arm_vqrdmlsdhxq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s32)))
+int32x4_t __arm_vqrdmlsdhxq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s8)))
+int8x16_t __arm_vqrdmlsdhxq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s8)))
+int8x16_t __arm_vqrdmlsdhxq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s16)))
+int16x8_t __arm_vqrdmulhq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s16)))
+int16x8_t __arm_vqrdmulhq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s32)))
+int32x4_t __arm_vqrdmulhq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s32)))
+int32x4_t __arm_vqrdmulhq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s8)))
+int8x16_t __arm_vqrdmulhq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s8)))
+int8x16_t __arm_vqrdmulhq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s16)))
+int16x8_t __arm_vqrdmulhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s16)))
+int16x8_t __arm_vqrdmulhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s32)))
+int32x4_t __arm_vqrdmulhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s32)))
+int32x4_t __arm_vqrdmulhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s8)))
+int8x16_t __arm_vqrdmulhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s8)))
+int8x16_t __arm_vqrdmulhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s16)))
+int16x8_t __arm_vqrdmulhq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s16)))
+int16x8_t __arm_vqrdmulhq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s32)))
+int32x4_t __arm_vqrdmulhq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s32)))
+int32x4_t __arm_vqrdmulhq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s8)))
+int8x16_t __arm_vqrdmulhq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s8)))
+int8x16_t __arm_vqrdmulhq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s16)))
+int16x8_t __arm_vqrdmulhq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s16)))
+int16x8_t __arm_vqrdmulhq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s32)))
+int32x4_t __arm_vqrdmulhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s32)))
+int32x4_t __arm_vqrdmulhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s8)))
+int8x16_t __arm_vqrdmulhq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s8)))
+int8x16_t __arm_vqrdmulhq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s16)))
+int16x8_t __arm_vqrshlq_m_n_s16(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s16)))
+int16x8_t __arm_vqrshlq_m_n(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s32)))
+int32x4_t __arm_vqrshlq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s32)))
+int32x4_t __arm_vqrshlq_m_n(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s8)))
+int8x16_t __arm_vqrshlq_m_n_s8(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s8)))
+int8x16_t __arm_vqrshlq_m_n(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u16)))
+uint16x8_t __arm_vqrshlq_m_n_u16(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u16)))
+uint16x8_t __arm_vqrshlq_m_n(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u32)))
+uint32x4_t __arm_vqrshlq_m_n_u32(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u32)))
+uint32x4_t __arm_vqrshlq_m_n(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u8)))
+uint8x16_t __arm_vqrshlq_m_n_u8(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u8)))
+uint8x16_t __arm_vqrshlq_m_n(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s16)))
+int16x8_t __arm_vqrshlq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s16)))
+int16x8_t __arm_vqrshlq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s32)))
+int32x4_t __arm_vqrshlq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s32)))
+int32x4_t __arm_vqrshlq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s8)))
+int8x16_t __arm_vqrshlq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s8)))
+int8x16_t __arm_vqrshlq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u16)))
+uint16x8_t __arm_vqrshlq_m_u16(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u16)))
+uint16x8_t __arm_vqrshlq_m(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u32)))
+uint32x4_t __arm_vqrshlq_m_u32(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u32)))
+uint32x4_t __arm_vqrshlq_m(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u8)))
+uint8x16_t __arm_vqrshlq_m_u8(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u8)))
+uint8x16_t __arm_vqrshlq_m(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s16)))
+int16x8_t __arm_vqrshlq_n_s16(int16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s16)))
+int16x8_t __arm_vqrshlq(int16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s32)))
+int32x4_t __arm_vqrshlq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s32)))
+int32x4_t __arm_vqrshlq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s8)))
+int8x16_t __arm_vqrshlq_n_s8(int8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s8)))
+int8x16_t __arm_vqrshlq(int8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u16)))
+uint16x8_t __arm_vqrshlq_n_u16(uint16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u16)))
+uint16x8_t __arm_vqrshlq(uint16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u32)))
+uint32x4_t __arm_vqrshlq_n_u32(uint32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u32)))
+uint32x4_t __arm_vqrshlq(uint32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u8)))
+uint8x16_t __arm_vqrshlq_n_u8(uint8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u8)))
+uint8x16_t __arm_vqrshlq(uint8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s16)))
+int16x8_t __arm_vqrshlq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s16)))
+int16x8_t __arm_vqrshlq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s32)))
+int32x4_t __arm_vqrshlq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s32)))
+int32x4_t __arm_vqrshlq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s8)))
+int8x16_t __arm_vqrshlq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s8)))
+int8x16_t __arm_vqrshlq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u16)))
+uint16x8_t __arm_vqrshlq_u16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u16)))
+uint16x8_t __arm_vqrshlq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u32)))
+uint32x4_t __arm_vqrshlq_u32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u32)))
+uint32x4_t __arm_vqrshlq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u8)))
+uint8x16_t __arm_vqrshlq_u8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u8)))
+uint8x16_t __arm_vqrshlq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_s16)))
+int8x16_t __arm_vqrshrnbq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_s16)))
+int8x16_t __arm_vqrshrnbq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_s32)))
+int16x8_t __arm_vqrshrnbq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_s32)))
+int16x8_t __arm_vqrshrnbq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_u16)))
+uint8x16_t __arm_vqrshrnbq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_u16)))
+uint8x16_t __arm_vqrshrnbq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_u32)))
+uint16x8_t __arm_vqrshrnbq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_u32)))
+uint16x8_t __arm_vqrshrnbq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_s16)))
+int8x16_t __arm_vqrshrnbq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_s16)))
+int8x16_t __arm_vqrshrnbq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_s32)))
+int16x8_t __arm_vqrshrnbq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_s32)))
+int16x8_t __arm_vqrshrnbq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_u16)))
+uint8x16_t __arm_vqrshrnbq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_u16)))
+uint8x16_t __arm_vqrshrnbq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_u32)))
+uint16x8_t __arm_vqrshrnbq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_u32)))
+uint16x8_t __arm_vqrshrnbq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_s16)))
+int8x16_t __arm_vqrshrntq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_s16)))
+int8x16_t __arm_vqrshrntq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_s32)))
+int16x8_t __arm_vqrshrntq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_s32)))
+int16x8_t __arm_vqrshrntq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_u16)))
+uint8x16_t __arm_vqrshrntq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_u16)))
+uint8x16_t __arm_vqrshrntq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_u32)))
+uint16x8_t __arm_vqrshrntq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_u32)))
+uint16x8_t __arm_vqrshrntq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_s16)))
+int8x16_t __arm_vqrshrntq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_s16)))
+int8x16_t __arm_vqrshrntq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_s32)))
+int16x8_t __arm_vqrshrntq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_s32)))
+int16x8_t __arm_vqrshrntq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_u16)))
+uint8x16_t __arm_vqrshrntq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_u16)))
+uint8x16_t __arm_vqrshrntq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_u32)))
+uint16x8_t __arm_vqrshrntq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_u32)))
+uint16x8_t __arm_vqrshrntq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_m_n_s16)))
+uint8x16_t __arm_vqrshrunbq_m_n_s16(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_m_n_s16)))
+uint8x16_t __arm_vqrshrunbq_m(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_m_n_s32)))
+uint16x8_t __arm_vqrshrunbq_m_n_s32(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_m_n_s32)))
+uint16x8_t __arm_vqrshrunbq_m(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_n_s16)))
+uint8x16_t __arm_vqrshrunbq_n_s16(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_n_s16)))
+uint8x16_t __arm_vqrshrunbq(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_n_s32)))
+uint16x8_t __arm_vqrshrunbq_n_s32(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_n_s32)))
+uint16x8_t __arm_vqrshrunbq(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_m_n_s16)))
+uint8x16_t __arm_vqrshruntq_m_n_s16(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_m_n_s16)))
+uint8x16_t __arm_vqrshruntq_m(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_m_n_s32)))
+uint16x8_t __arm_vqrshruntq_m_n_s32(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_m_n_s32)))
+uint16x8_t __arm_vqrshruntq_m(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_n_s16)))
+uint8x16_t __arm_vqrshruntq_n_s16(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_n_s16)))
+uint8x16_t __arm_vqrshruntq(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_n_s32)))
+uint16x8_t __arm_vqrshruntq_n_s32(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_n_s32)))
+uint16x8_t __arm_vqrshruntq(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s16)))
+int16x8_t __arm_vqshlq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s16)))
+int16x8_t __arm_vqshlq_m_n(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s32)))
+int32x4_t __arm_vqshlq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s32)))
+int32x4_t __arm_vqshlq_m_n(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s8)))
+int8x16_t __arm_vqshlq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s8)))
+int8x16_t __arm_vqshlq_m_n(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u16)))
+uint16x8_t __arm_vqshlq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u16)))
+uint16x8_t __arm_vqshlq_m_n(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u32)))
+uint32x4_t __arm_vqshlq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u32)))
+uint32x4_t __arm_vqshlq_m_n(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u8)))
+uint8x16_t __arm_vqshlq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u8)))
+uint8x16_t __arm_vqshlq_m_n(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s16)))
+int16x8_t __arm_vqshlq_m_r_s16(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s16)))
+int16x8_t __arm_vqshlq_m_r(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s32)))
+int32x4_t __arm_vqshlq_m_r_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s32)))
+int32x4_t __arm_vqshlq_m_r(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s8)))
+int8x16_t __arm_vqshlq_m_r_s8(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s8)))
+int8x16_t __arm_vqshlq_m_r(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u16)))
+uint16x8_t __arm_vqshlq_m_r_u16(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u16)))
+uint16x8_t __arm_vqshlq_m_r(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u32)))
+uint32x4_t __arm_vqshlq_m_r_u32(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u32)))
+uint32x4_t __arm_vqshlq_m_r(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u8)))
+uint8x16_t __arm_vqshlq_m_r_u8(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u8)))
+uint8x16_t __arm_vqshlq_m_r(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s16)))
+int16x8_t __arm_vqshlq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s16)))
+int16x8_t __arm_vqshlq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s32)))
+int32x4_t __arm_vqshlq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s32)))
+int32x4_t __arm_vqshlq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s8)))
+int8x16_t __arm_vqshlq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s8)))
+int8x16_t __arm_vqshlq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u16)))
+uint16x8_t __arm_vqshlq_m_u16(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u16)))
+uint16x8_t __arm_vqshlq_m(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u32)))
+uint32x4_t __arm_vqshlq_m_u32(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u32)))
+uint32x4_t __arm_vqshlq_m(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u8)))
+uint8x16_t __arm_vqshlq_m_u8(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u8)))
+uint8x16_t __arm_vqshlq_m(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s16)))
+int16x8_t __arm_vqshlq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s16)))
+int16x8_t __arm_vqshlq_n(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s32)))
+int32x4_t __arm_vqshlq_n_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s32)))
+int32x4_t __arm_vqshlq_n(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s8)))
+int8x16_t __arm_vqshlq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s8)))
+int8x16_t __arm_vqshlq_n(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u16)))
+uint16x8_t __arm_vqshlq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u16)))
+uint16x8_t __arm_vqshlq_n(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u32)))
+uint32x4_t __arm_vqshlq_n_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u32)))
+uint32x4_t __arm_vqshlq_n(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u8)))
+uint8x16_t __arm_vqshlq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u8)))
+uint8x16_t __arm_vqshlq_n(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s16)))
+int16x8_t __arm_vqshlq_r_s16(int16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s16)))
+int16x8_t __arm_vqshlq_r(int16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s32)))
+int32x4_t __arm_vqshlq_r_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s32)))
+int32x4_t __arm_vqshlq_r(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s8)))
+int8x16_t __arm_vqshlq_r_s8(int8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s8)))
+int8x16_t __arm_vqshlq_r(int8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u16)))
+uint16x8_t __arm_vqshlq_r_u16(uint16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u16)))
+uint16x8_t __arm_vqshlq_r(uint16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u32)))
+uint32x4_t __arm_vqshlq_r_u32(uint32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u32)))
+uint32x4_t __arm_vqshlq_r(uint32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u8)))
+uint8x16_t __arm_vqshlq_r_u8(uint8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u8)))
+uint8x16_t __arm_vqshlq_r(uint8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s16)))
+int16x8_t __arm_vqshlq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s16)))
+int16x8_t __arm_vqshlq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s32)))
+int32x4_t __arm_vqshlq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s32)))
+int32x4_t __arm_vqshlq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s8)))
+int8x16_t __arm_vqshlq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s8)))
+int8x16_t __arm_vqshlq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u16)))
+uint16x8_t __arm_vqshlq_u16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u16)))
+uint16x8_t __arm_vqshlq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u32)))
+uint32x4_t __arm_vqshlq_u32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u32)))
+uint32x4_t __arm_vqshlq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u8)))
+uint8x16_t __arm_vqshlq_u8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u8)))
+uint8x16_t __arm_vqshlq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s16)))
+uint16x8_t __arm_vqshluq_m_n_s16(uint16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s16)))
+uint16x8_t __arm_vqshluq_m(uint16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s32)))
+uint32x4_t __arm_vqshluq_m_n_s32(uint32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s32)))
+uint32x4_t __arm_vqshluq_m(uint32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s8)))
+uint8x16_t __arm_vqshluq_m_n_s8(uint8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s8)))
+uint8x16_t __arm_vqshluq_m(uint8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s16)))
+uint16x8_t __arm_vqshluq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s16)))
+uint16x8_t __arm_vqshluq(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s32)))
+uint32x4_t __arm_vqshluq_n_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s32)))
+uint32x4_t __arm_vqshluq(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s8)))
+uint8x16_t __arm_vqshluq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s8)))
+uint8x16_t __arm_vqshluq(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_s16)))
+int8x16_t __arm_vqshrnbq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_s16)))
+int8x16_t __arm_vqshrnbq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_s32)))
+int16x8_t __arm_vqshrnbq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_s32)))
+int16x8_t __arm_vqshrnbq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_u16)))
+uint8x16_t __arm_vqshrnbq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_u16)))
+uint8x16_t __arm_vqshrnbq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_u32)))
+uint16x8_t __arm_vqshrnbq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_u32)))
+uint16x8_t __arm_vqshrnbq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_s16)))
+int8x16_t __arm_vqshrnbq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_s16)))
+int8x16_t __arm_vqshrnbq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_s32)))
+int16x8_t __arm_vqshrnbq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_s32)))
+int16x8_t __arm_vqshrnbq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_u16)))
+uint8x16_t __arm_vqshrnbq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_u16)))
+uint8x16_t __arm_vqshrnbq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_u32)))
+uint16x8_t __arm_vqshrnbq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_u32)))
+uint16x8_t __arm_vqshrnbq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_s16)))
+int8x16_t __arm_vqshrntq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_s16)))
+int8x16_t __arm_vqshrntq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_s32)))
+int16x8_t __arm_vqshrntq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_s32)))
+int16x8_t __arm_vqshrntq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_u16)))
+uint8x16_t __arm_vqshrntq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_u16)))
+uint8x16_t __arm_vqshrntq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_u32)))
+uint16x8_t __arm_vqshrntq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_u32)))
+uint16x8_t __arm_vqshrntq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_s16)))
+int8x16_t __arm_vqshrntq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_s16)))
+int8x16_t __arm_vqshrntq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_s32)))
+int16x8_t __arm_vqshrntq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_s32)))
+int16x8_t __arm_vqshrntq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_u16)))
+uint8x16_t __arm_vqshrntq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_u16)))
+uint8x16_t __arm_vqshrntq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_u32)))
+uint16x8_t __arm_vqshrntq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_u32)))
+uint16x8_t __arm_vqshrntq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_m_n_s16)))
+uint8x16_t __arm_vqshrunbq_m_n_s16(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_m_n_s16)))
+uint8x16_t __arm_vqshrunbq_m(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_m_n_s32)))
+uint16x8_t __arm_vqshrunbq_m_n_s32(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_m_n_s32)))
+uint16x8_t __arm_vqshrunbq_m(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_n_s16)))
+uint8x16_t __arm_vqshrunbq_n_s16(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_n_s16)))
+uint8x16_t __arm_vqshrunbq(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_n_s32)))
+uint16x8_t __arm_vqshrunbq_n_s32(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_n_s32)))
+uint16x8_t __arm_vqshrunbq(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_m_n_s16)))
+uint8x16_t __arm_vqshruntq_m_n_s16(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_m_n_s16)))
+uint8x16_t __arm_vqshruntq_m(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_m_n_s32)))
+uint16x8_t __arm_vqshruntq_m_n_s32(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_m_n_s32)))
+uint16x8_t __arm_vqshruntq_m(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_n_s16)))
+uint8x16_t __arm_vqshruntq_n_s16(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_n_s16)))
+uint8x16_t __arm_vqshruntq(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_n_s32)))
+uint16x8_t __arm_vqshruntq_n_s32(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_n_s32)))
+uint16x8_t __arm_vqshruntq(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s16)))
+int16x8_t __arm_vqsubq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s16)))
+int16x8_t __arm_vqsubq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s32)))
+int32x4_t __arm_vqsubq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s32)))
+int32x4_t __arm_vqsubq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s8)))
+int8x16_t __arm_vqsubq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s8)))
+int8x16_t __arm_vqsubq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u16)))
+uint16x8_t __arm_vqsubq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u16)))
+uint16x8_t __arm_vqsubq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u32)))
+uint32x4_t __arm_vqsubq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u32)))
+uint32x4_t __arm_vqsubq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u8)))
+uint8x16_t __arm_vqsubq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u8)))
+uint8x16_t __arm_vqsubq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s16)))
+int16x8_t __arm_vqsubq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s16)))
+int16x8_t __arm_vqsubq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s32)))
+int32x4_t __arm_vqsubq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s32)))
+int32x4_t __arm_vqsubq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s8)))
+int8x16_t __arm_vqsubq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s8)))
+int8x16_t __arm_vqsubq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u16)))
+uint16x8_t __arm_vqsubq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u16)))
+uint16x8_t __arm_vqsubq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u32)))
+uint32x4_t __arm_vqsubq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u32)))
+uint32x4_t __arm_vqsubq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u8)))
+uint8x16_t __arm_vqsubq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u8)))
+uint8x16_t __arm_vqsubq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s16)))
+int16x8_t __arm_vqsubq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s16)))
+int16x8_t __arm_vqsubq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s32)))
+int32x4_t __arm_vqsubq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s32)))
+int32x4_t __arm_vqsubq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s8)))
+int8x16_t __arm_vqsubq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s8)))
+int8x16_t __arm_vqsubq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u16)))
+uint16x8_t __arm_vqsubq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u16)))
+uint16x8_t __arm_vqsubq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u32)))
+uint32x4_t __arm_vqsubq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u32)))
+uint32x4_t __arm_vqsubq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u8)))
+uint8x16_t __arm_vqsubq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u8)))
+uint8x16_t __arm_vqsubq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s16)))
+int16x8_t __arm_vqsubq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s16)))
+int16x8_t __arm_vqsubq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s32)))
+int32x4_t __arm_vqsubq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s32)))
+int32x4_t __arm_vqsubq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s8)))
+int8x16_t __arm_vqsubq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s8)))
+int8x16_t __arm_vqsubq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u16)))
+uint16x8_t __arm_vqsubq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u16)))
+uint16x8_t __arm_vqsubq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u32)))
+uint32x4_t __arm_vqsubq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u32)))
+uint32x4_t __arm_vqsubq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u8)))
+uint8x16_t __arm_vqsubq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u8)))
+uint8x16_t __arm_vqsubq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s32)))
+int16x8_t __arm_vreinterpretq_s16_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s32)))
+int16x8_t __arm_vreinterpretq_s16(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s64)))
+int16x8_t __arm_vreinterpretq_s16_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s64)))
+int16x8_t __arm_vreinterpretq_s16(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s8)))
+int16x8_t __arm_vreinterpretq_s16_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s8)))
+int16x8_t __arm_vreinterpretq_s16(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u16)))
+int16x8_t __arm_vreinterpretq_s16_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u16)))
+int16x8_t __arm_vreinterpretq_s16(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u32)))
+int16x8_t __arm_vreinterpretq_s16_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u32)))
+int16x8_t __arm_vreinterpretq_s16(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u64)))
+int16x8_t __arm_vreinterpretq_s16_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u64)))
+int16x8_t __arm_vreinterpretq_s16(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u8)))
+int16x8_t __arm_vreinterpretq_s16_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u8)))
+int16x8_t __arm_vreinterpretq_s16(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s16)))
+int32x4_t __arm_vreinterpretq_s32_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s16)))
+int32x4_t __arm_vreinterpretq_s32(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s64)))
+int32x4_t __arm_vreinterpretq_s32_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s64)))
+int32x4_t __arm_vreinterpretq_s32(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s8)))
+int32x4_t __arm_vreinterpretq_s32_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s8)))
+int32x4_t __arm_vreinterpretq_s32(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u16)))
+int32x4_t __arm_vreinterpretq_s32_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u16)))
+int32x4_t __arm_vreinterpretq_s32(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u32)))
+int32x4_t __arm_vreinterpretq_s32_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u32)))
+int32x4_t __arm_vreinterpretq_s32(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u64)))
+int32x4_t __arm_vreinterpretq_s32_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u64)))
+int32x4_t __arm_vreinterpretq_s32(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u8)))
+int32x4_t __arm_vreinterpretq_s32_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u8)))
+int32x4_t __arm_vreinterpretq_s32(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s16)))
+int64x2_t __arm_vreinterpretq_s64_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s16)))
+int64x2_t __arm_vreinterpretq_s64(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s32)))
+int64x2_t __arm_vreinterpretq_s64_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s32)))
+int64x2_t __arm_vreinterpretq_s64(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s8)))
+int64x2_t __arm_vreinterpretq_s64_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s8)))
+int64x2_t __arm_vreinterpretq_s64(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u16)))
+int64x2_t __arm_vreinterpretq_s64_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u16)))
+int64x2_t __arm_vreinterpretq_s64(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u32)))
+int64x2_t __arm_vreinterpretq_s64_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u32)))
+int64x2_t __arm_vreinterpretq_s64(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u64)))
+int64x2_t __arm_vreinterpretq_s64_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u64)))
+int64x2_t __arm_vreinterpretq_s64(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u8)))
+int64x2_t __arm_vreinterpretq_s64_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u8)))
+int64x2_t __arm_vreinterpretq_s64(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s16)))
+int8x16_t __arm_vreinterpretq_s8_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s16)))
+int8x16_t __arm_vreinterpretq_s8(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s32)))
+int8x16_t __arm_vreinterpretq_s8_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s32)))
+int8x16_t __arm_vreinterpretq_s8(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s64)))
+int8x16_t __arm_vreinterpretq_s8_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s64)))
+int8x16_t __arm_vreinterpretq_s8(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u16)))
+int8x16_t __arm_vreinterpretq_s8_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u16)))
+int8x16_t __arm_vreinterpretq_s8(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u32)))
+int8x16_t __arm_vreinterpretq_s8_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u32)))
+int8x16_t __arm_vreinterpretq_s8(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u64)))
+int8x16_t __arm_vreinterpretq_s8_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u64)))
+int8x16_t __arm_vreinterpretq_s8(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u8)))
+int8x16_t __arm_vreinterpretq_s8_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u8)))
+int8x16_t __arm_vreinterpretq_s8(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s16)))
+uint16x8_t __arm_vreinterpretq_u16_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s16)))
+uint16x8_t __arm_vreinterpretq_u16(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s32)))
+uint16x8_t __arm_vreinterpretq_u16_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s32)))
+uint16x8_t __arm_vreinterpretq_u16(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s64)))
+uint16x8_t __arm_vreinterpretq_u16_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s64)))
+uint16x8_t __arm_vreinterpretq_u16(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s8)))
+uint16x8_t __arm_vreinterpretq_u16_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s8)))
+uint16x8_t __arm_vreinterpretq_u16(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u32)))
+uint16x8_t __arm_vreinterpretq_u16_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u32)))
+uint16x8_t __arm_vreinterpretq_u16(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u64)))
+uint16x8_t __arm_vreinterpretq_u16_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u64)))
+uint16x8_t __arm_vreinterpretq_u16(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u8)))
+uint16x8_t __arm_vreinterpretq_u16_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u8)))
+uint16x8_t __arm_vreinterpretq_u16(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s16)))
+uint32x4_t __arm_vreinterpretq_u32_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s16)))
+uint32x4_t __arm_vreinterpretq_u32(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s32)))
+uint32x4_t __arm_vreinterpretq_u32_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s32)))
+uint32x4_t __arm_vreinterpretq_u32(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s64)))
+uint32x4_t __arm_vreinterpretq_u32_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s64)))
+uint32x4_t __arm_vreinterpretq_u32(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s8)))
+uint32x4_t __arm_vreinterpretq_u32_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s8)))
+uint32x4_t __arm_vreinterpretq_u32(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u16)))
+uint32x4_t __arm_vreinterpretq_u32_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u16)))
+uint32x4_t __arm_vreinterpretq_u32(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u64)))
+uint32x4_t __arm_vreinterpretq_u32_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u64)))
+uint32x4_t __arm_vreinterpretq_u32(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u8)))
+uint32x4_t __arm_vreinterpretq_u32_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u8)))
+uint32x4_t __arm_vreinterpretq_u32(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s16)))
+uint64x2_t __arm_vreinterpretq_u64_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s16)))
+uint64x2_t __arm_vreinterpretq_u64(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s32)))
+uint64x2_t __arm_vreinterpretq_u64_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s32)))
+uint64x2_t __arm_vreinterpretq_u64(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s64)))
+uint64x2_t __arm_vreinterpretq_u64_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s64)))
+uint64x2_t __arm_vreinterpretq_u64(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s8)))
+uint64x2_t __arm_vreinterpretq_u64_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s8)))
+uint64x2_t __arm_vreinterpretq_u64(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u16)))
+uint64x2_t __arm_vreinterpretq_u64_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u16)))
+uint64x2_t __arm_vreinterpretq_u64(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u32)))
+uint64x2_t __arm_vreinterpretq_u64_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u32)))
+uint64x2_t __arm_vreinterpretq_u64(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u8)))
+uint64x2_t __arm_vreinterpretq_u64_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u8)))
+uint64x2_t __arm_vreinterpretq_u64(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s16)))
+uint8x16_t __arm_vreinterpretq_u8_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s16)))
+uint8x16_t __arm_vreinterpretq_u8(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s32)))
+uint8x16_t __arm_vreinterpretq_u8_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s32)))
+uint8x16_t __arm_vreinterpretq_u8(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s64)))
+uint8x16_t __arm_vreinterpretq_u8_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s64)))
+uint8x16_t __arm_vreinterpretq_u8(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s8)))
+uint8x16_t __arm_vreinterpretq_u8_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s8)))
+uint8x16_t __arm_vreinterpretq_u8(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u16)))
+uint8x16_t __arm_vreinterpretq_u8_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u16)))
+uint8x16_t __arm_vreinterpretq_u8(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u32)))
+uint8x16_t __arm_vreinterpretq_u8_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u32)))
+uint8x16_t __arm_vreinterpretq_u8(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u64)))
+uint8x16_t __arm_vreinterpretq_u8_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u64)))
+uint8x16_t __arm_vreinterpretq_u8(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_m_s8)))
+int8x16_t __arm_vrev16q_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_m_s8)))
+int8x16_t __arm_vrev16q_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_m_u8)))
+uint8x16_t __arm_vrev16q_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_m_u8)))
+uint8x16_t __arm_vrev16q_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_s8)))
+int8x16_t __arm_vrev16q_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_s8)))
+int8x16_t __arm_vrev16q(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_u8)))
+uint8x16_t __arm_vrev16q_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_u8)))
+uint8x16_t __arm_vrev16q(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_x_s8)))
+int8x16_t __arm_vrev16q_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_x_s8)))
+int8x16_t __arm_vrev16q_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_x_u8)))
+uint8x16_t __arm_vrev16q_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_x_u8)))
+uint8x16_t __arm_vrev16q_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_s16)))
+int16x8_t __arm_vrev32q_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_s16)))
+int16x8_t __arm_vrev32q_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_s8)))
+int8x16_t __arm_vrev32q_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_s8)))
+int8x16_t __arm_vrev32q_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_u16)))
+uint16x8_t __arm_vrev32q_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_u16)))
+uint16x8_t __arm_vrev32q_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_u8)))
+uint8x16_t __arm_vrev32q_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_u8)))
+uint8x16_t __arm_vrev32q_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_s16)))
+int16x8_t __arm_vrev32q_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_s16)))
+int16x8_t __arm_vrev32q(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_s8)))
+int8x16_t __arm_vrev32q_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_s8)))
+int8x16_t __arm_vrev32q(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_u16)))
+uint16x8_t __arm_vrev32q_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_u16)))
+uint16x8_t __arm_vrev32q(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_u8)))
+uint8x16_t __arm_vrev32q_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_u8)))
+uint8x16_t __arm_vrev32q(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_s16)))
+int16x8_t __arm_vrev32q_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_s16)))
+int16x8_t __arm_vrev32q_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_s8)))
+int8x16_t __arm_vrev32q_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_s8)))
+int8x16_t __arm_vrev32q_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_u16)))
+uint16x8_t __arm_vrev32q_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_u16)))
+uint16x8_t __arm_vrev32q_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_u8)))
+uint8x16_t __arm_vrev32q_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_u8)))
+uint8x16_t __arm_vrev32q_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s16)))
+int16x8_t __arm_vrev64q_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s16)))
+int16x8_t __arm_vrev64q_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s32)))
+int32x4_t __arm_vrev64q_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s32)))
+int32x4_t __arm_vrev64q_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s8)))
+int8x16_t __arm_vrev64q_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s8)))
+int8x16_t __arm_vrev64q_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u16)))
+uint16x8_t __arm_vrev64q_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u16)))
+uint16x8_t __arm_vrev64q_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u32)))
+uint32x4_t __arm_vrev64q_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u32)))
+uint32x4_t __arm_vrev64q_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u8)))
+uint8x16_t __arm_vrev64q_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u8)))
+uint8x16_t __arm_vrev64q_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s16)))
+int16x8_t __arm_vrev64q_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s16)))
+int16x8_t __arm_vrev64q(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s32)))
+int32x4_t __arm_vrev64q_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s32)))
+int32x4_t __arm_vrev64q(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s8)))
+int8x16_t __arm_vrev64q_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s8)))
+int8x16_t __arm_vrev64q(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u16)))
+uint16x8_t __arm_vrev64q_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u16)))
+uint16x8_t __arm_vrev64q(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u32)))
+uint32x4_t __arm_vrev64q_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u32)))
+uint32x4_t __arm_vrev64q(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u8)))
+uint8x16_t __arm_vrev64q_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u8)))
+uint8x16_t __arm_vrev64q(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s16)))
+int16x8_t __arm_vrev64q_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s16)))
+int16x8_t __arm_vrev64q_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s32)))
+int32x4_t __arm_vrev64q_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s32)))
+int32x4_t __arm_vrev64q_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s8)))
+int8x16_t __arm_vrev64q_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s8)))
+int8x16_t __arm_vrev64q_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u16)))
+uint16x8_t __arm_vrev64q_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u16)))
+uint16x8_t __arm_vrev64q_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u32)))
+uint32x4_t __arm_vrev64q_x_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u32)))
+uint32x4_t __arm_vrev64q_x(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u8)))
+uint8x16_t __arm_vrev64q_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u8)))
+uint8x16_t __arm_vrev64q_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s16)))
+int16x8_t __arm_vrhaddq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s16)))
+int16x8_t __arm_vrhaddq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s32)))
+int32x4_t __arm_vrhaddq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s32)))
+int32x4_t __arm_vrhaddq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s8)))
+int8x16_t __arm_vrhaddq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s8)))
+int8x16_t __arm_vrhaddq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u16)))
+uint16x8_t __arm_vrhaddq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u16)))
+uint16x8_t __arm_vrhaddq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u32)))
+uint32x4_t __arm_vrhaddq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u32)))
+uint32x4_t __arm_vrhaddq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u8)))
+uint8x16_t __arm_vrhaddq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u8)))
+uint8x16_t __arm_vrhaddq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s16)))
+int16x8_t __arm_vrhaddq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s16)))
+int16x8_t __arm_vrhaddq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s32)))
+int32x4_t __arm_vrhaddq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s32)))
+int32x4_t __arm_vrhaddq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s8)))
+int8x16_t __arm_vrhaddq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s8)))
+int8x16_t __arm_vrhaddq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u16)))
+uint16x8_t __arm_vrhaddq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u16)))
+uint16x8_t __arm_vrhaddq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u32)))
+uint32x4_t __arm_vrhaddq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u32)))
+uint32x4_t __arm_vrhaddq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u8)))
+uint8x16_t __arm_vrhaddq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u8)))
+uint8x16_t __arm_vrhaddq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s16)))
+int16x8_t __arm_vrhaddq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s16)))
+int16x8_t __arm_vrhaddq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s32)))
+int32x4_t __arm_vrhaddq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s32)))
+int32x4_t __arm_vrhaddq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s8)))
+int8x16_t __arm_vrhaddq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s8)))
+int8x16_t __arm_vrhaddq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u16)))
+uint16x8_t __arm_vrhaddq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u16)))
+uint16x8_t __arm_vrhaddq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u32)))
+uint32x4_t __arm_vrhaddq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u32)))
+uint32x4_t __arm_vrhaddq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u8)))
+uint8x16_t __arm_vrhaddq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u8)))
+uint8x16_t __arm_vrhaddq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_p_s32)))
+int64_t __arm_vrmlaldavhaq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_p_s32)))
+int64_t __arm_vrmlaldavhaq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_p_u32)))
+uint64_t __arm_vrmlaldavhaq_p_u32(uint64_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_p_u32)))
+uint64_t __arm_vrmlaldavhaq_p(uint64_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_s32)))
+int64_t __arm_vrmlaldavhaq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_s32)))
+int64_t __arm_vrmlaldavhaq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_u32)))
+uint64_t __arm_vrmlaldavhaq_u32(uint64_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_u32)))
+uint64_t __arm_vrmlaldavhaq(uint64_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaxq_p_s32)))
+int64_t __arm_vrmlaldavhaxq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaxq_p_s32)))
+int64_t __arm_vrmlaldavhaxq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaxq_s32)))
+int64_t __arm_vrmlaldavhaxq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaxq_s32)))
+int64_t __arm_vrmlaldavhaxq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_p_s32)))
+int64_t __arm_vrmlaldavhq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_p_s32)))
+int64_t __arm_vrmlaldavhq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_p_u32)))
+uint64_t __arm_vrmlaldavhq_p_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_p_u32)))
+uint64_t __arm_vrmlaldavhq_p(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_s32)))
+int64_t __arm_vrmlaldavhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_s32)))
+int64_t __arm_vrmlaldavhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_u32)))
+uint64_t __arm_vrmlaldavhq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_u32)))
+uint64_t __arm_vrmlaldavhq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhxq_p_s32)))
+int64_t __arm_vrmlaldavhxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhxq_p_s32)))
+int64_t __arm_vrmlaldavhxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhxq_s32)))
+int64_t __arm_vrmlaldavhxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhxq_s32)))
+int64_t __arm_vrmlaldavhxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaq_p_s32)))
+int64_t __arm_vrmlsldavhaq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaq_p_s32)))
+int64_t __arm_vrmlsldavhaq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaq_s32)))
+int64_t __arm_vrmlsldavhaq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaq_s32)))
+int64_t __arm_vrmlsldavhaq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaxq_p_s32)))
+int64_t __arm_vrmlsldavhaxq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaxq_p_s32)))
+int64_t __arm_vrmlsldavhaxq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaxq_s32)))
+int64_t __arm_vrmlsldavhaxq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaxq_s32)))
+int64_t __arm_vrmlsldavhaxq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhq_p_s32)))
+int64_t __arm_vrmlsldavhq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhq_p_s32)))
+int64_t __arm_vrmlsldavhq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhq_s32)))
+int64_t __arm_vrmlsldavhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhq_s32)))
+int64_t __arm_vrmlsldavhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhxq_p_s32)))
+int64_t __arm_vrmlsldavhxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhxq_p_s32)))
+int64_t __arm_vrmlsldavhxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhxq_s32)))
+int64_t __arm_vrmlsldavhxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhxq_s32)))
+int64_t __arm_vrmlsldavhxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s16)))
+int16x8_t __arm_vrmulhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s16)))
+int16x8_t __arm_vrmulhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s32)))
+int32x4_t __arm_vrmulhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s32)))
+int32x4_t __arm_vrmulhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s8)))
+int8x16_t __arm_vrmulhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s8)))
+int8x16_t __arm_vrmulhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u16)))
+uint16x8_t __arm_vrmulhq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u16)))
+uint16x8_t __arm_vrmulhq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u32)))
+uint32x4_t __arm_vrmulhq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u32)))
+uint32x4_t __arm_vrmulhq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u8)))
+uint8x16_t __arm_vrmulhq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u8)))
+uint8x16_t __arm_vrmulhq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s16)))
+int16x8_t __arm_vrmulhq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s16)))
+int16x8_t __arm_vrmulhq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s32)))
+int32x4_t __arm_vrmulhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s32)))
+int32x4_t __arm_vrmulhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s8)))
+int8x16_t __arm_vrmulhq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s8)))
+int8x16_t __arm_vrmulhq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u16)))
+uint16x8_t __arm_vrmulhq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u16)))
+uint16x8_t __arm_vrmulhq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u32)))
+uint32x4_t __arm_vrmulhq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u32)))
+uint32x4_t __arm_vrmulhq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u8)))
+uint8x16_t __arm_vrmulhq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u8)))
+uint8x16_t __arm_vrmulhq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s16)))
+int16x8_t __arm_vrmulhq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s16)))
+int16x8_t __arm_vrmulhq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s32)))
+int32x4_t __arm_vrmulhq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s32)))
+int32x4_t __arm_vrmulhq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s8)))
+int8x16_t __arm_vrmulhq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s8)))
+int8x16_t __arm_vrmulhq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u16)))
+uint16x8_t __arm_vrmulhq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u16)))
+uint16x8_t __arm_vrmulhq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u32)))
+uint32x4_t __arm_vrmulhq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u32)))
+uint32x4_t __arm_vrmulhq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u8)))
+uint8x16_t __arm_vrmulhq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u8)))
+uint8x16_t __arm_vrmulhq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s16)))
+int16x8_t __arm_vrshlq_m_n_s16(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s16)))
+int16x8_t __arm_vrshlq_m_n(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s32)))
+int32x4_t __arm_vrshlq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s32)))
+int32x4_t __arm_vrshlq_m_n(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s8)))
+int8x16_t __arm_vrshlq_m_n_s8(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s8)))
+int8x16_t __arm_vrshlq_m_n(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u16)))
+uint16x8_t __arm_vrshlq_m_n_u16(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u16)))
+uint16x8_t __arm_vrshlq_m_n(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u32)))
+uint32x4_t __arm_vrshlq_m_n_u32(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u32)))
+uint32x4_t __arm_vrshlq_m_n(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u8)))
+uint8x16_t __arm_vrshlq_m_n_u8(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u8)))
+uint8x16_t __arm_vrshlq_m_n(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s16)))
+int16x8_t __arm_vrshlq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s16)))
+int16x8_t __arm_vrshlq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s32)))
+int32x4_t __arm_vrshlq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s32)))
+int32x4_t __arm_vrshlq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s8)))
+int8x16_t __arm_vrshlq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s8)))
+int8x16_t __arm_vrshlq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u16)))
+uint16x8_t __arm_vrshlq_m_u16(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u16)))
+uint16x8_t __arm_vrshlq_m(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u32)))
+uint32x4_t __arm_vrshlq_m_u32(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u32)))
+uint32x4_t __arm_vrshlq_m(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u8)))
+uint8x16_t __arm_vrshlq_m_u8(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u8)))
+uint8x16_t __arm_vrshlq_m(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s16)))
+int16x8_t __arm_vrshlq_n_s16(int16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s16)))
+int16x8_t __arm_vrshlq(int16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s32)))
+int32x4_t __arm_vrshlq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s32)))
+int32x4_t __arm_vrshlq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s8)))
+int8x16_t __arm_vrshlq_n_s8(int8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s8)))
+int8x16_t __arm_vrshlq(int8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u16)))
+uint16x8_t __arm_vrshlq_n_u16(uint16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u16)))
+uint16x8_t __arm_vrshlq(uint16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u32)))
+uint32x4_t __arm_vrshlq_n_u32(uint32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u32)))
+uint32x4_t __arm_vrshlq(uint32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u8)))
+uint8x16_t __arm_vrshlq_n_u8(uint8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u8)))
+uint8x16_t __arm_vrshlq(uint8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s16)))
+int16x8_t __arm_vrshlq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s16)))
+int16x8_t __arm_vrshlq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s32)))
+int32x4_t __arm_vrshlq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s32)))
+int32x4_t __arm_vrshlq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s8)))
+int8x16_t __arm_vrshlq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s8)))
+int8x16_t __arm_vrshlq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u16)))
+uint16x8_t __arm_vrshlq_u16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u16)))
+uint16x8_t __arm_vrshlq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u32)))
+uint32x4_t __arm_vrshlq_u32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u32)))
+uint32x4_t __arm_vrshlq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u8)))
+uint8x16_t __arm_vrshlq_u8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u8)))
+uint8x16_t __arm_vrshlq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s16)))
+int16x8_t __arm_vrshlq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s16)))
+int16x8_t __arm_vrshlq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s32)))
+int32x4_t __arm_vrshlq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s32)))
+int32x4_t __arm_vrshlq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s8)))
+int8x16_t __arm_vrshlq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s8)))
+int8x16_t __arm_vrshlq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u16)))
+uint16x8_t __arm_vrshlq_x_u16(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u16)))
+uint16x8_t __arm_vrshlq_x(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u32)))
+uint32x4_t __arm_vrshlq_x_u32(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u32)))
+uint32x4_t __arm_vrshlq_x(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u8)))
+uint8x16_t __arm_vrshlq_x_u8(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u8)))
+uint8x16_t __arm_vrshlq_x(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_s16)))
+int8x16_t __arm_vrshrnbq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_s16)))
+int8x16_t __arm_vrshrnbq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_s32)))
+int16x8_t __arm_vrshrnbq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_s32)))
+int16x8_t __arm_vrshrnbq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_u16)))
+uint8x16_t __arm_vrshrnbq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_u16)))
+uint8x16_t __arm_vrshrnbq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_u32)))
+uint16x8_t __arm_vrshrnbq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_u32)))
+uint16x8_t __arm_vrshrnbq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_s16)))
+int8x16_t __arm_vrshrnbq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_s16)))
+int8x16_t __arm_vrshrnbq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_s32)))
+int16x8_t __arm_vrshrnbq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_s32)))
+int16x8_t __arm_vrshrnbq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_u16)))
+uint8x16_t __arm_vrshrnbq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_u16)))
+uint8x16_t __arm_vrshrnbq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_u32)))
+uint16x8_t __arm_vrshrnbq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_u32)))
+uint16x8_t __arm_vrshrnbq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_s16)))
+int8x16_t __arm_vrshrntq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_s16)))
+int8x16_t __arm_vrshrntq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_s32)))
+int16x8_t __arm_vrshrntq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_s32)))
+int16x8_t __arm_vrshrntq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_u16)))
+uint8x16_t __arm_vrshrntq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_u16)))
+uint8x16_t __arm_vrshrntq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_u32)))
+uint16x8_t __arm_vrshrntq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_u32)))
+uint16x8_t __arm_vrshrntq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_s16)))
+int8x16_t __arm_vrshrntq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_s16)))
+int8x16_t __arm_vrshrntq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_s32)))
+int16x8_t __arm_vrshrntq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_s32)))
+int16x8_t __arm_vrshrntq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_u16)))
+uint8x16_t __arm_vrshrntq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_u16)))
+uint8x16_t __arm_vrshrntq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_u32)))
+uint16x8_t __arm_vrshrntq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_u32)))
+uint16x8_t __arm_vrshrntq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s16)))
+int16x8_t __arm_vrshrq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s16)))
+int16x8_t __arm_vrshrq_m(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s32)))
+int32x4_t __arm_vrshrq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s32)))
+int32x4_t __arm_vrshrq_m(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s8)))
+int8x16_t __arm_vrshrq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s8)))
+int8x16_t __arm_vrshrq_m(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u16)))
+uint16x8_t __arm_vrshrq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u16)))
+uint16x8_t __arm_vrshrq_m(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u32)))
+uint32x4_t __arm_vrshrq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u32)))
+uint32x4_t __arm_vrshrq_m(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u8)))
+uint8x16_t __arm_vrshrq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u8)))
+uint8x16_t __arm_vrshrq_m(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s16)))
+int16x8_t __arm_vrshrq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s16)))
+int16x8_t __arm_vrshrq(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s32)))
+int32x4_t __arm_vrshrq_n_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s32)))
+int32x4_t __arm_vrshrq(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s8)))
+int8x16_t __arm_vrshrq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s8)))
+int8x16_t __arm_vrshrq(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u16)))
+uint16x8_t __arm_vrshrq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u16)))
+uint16x8_t __arm_vrshrq(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u32)))
+uint32x4_t __arm_vrshrq_n_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u32)))
+uint32x4_t __arm_vrshrq(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u8)))
+uint8x16_t __arm_vrshrq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u8)))
+uint8x16_t __arm_vrshrq(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s16)))
+int16x8_t __arm_vrshrq_x_n_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s16)))
+int16x8_t __arm_vrshrq_x(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s32)))
+int32x4_t __arm_vrshrq_x_n_s32(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s32)))
+int32x4_t __arm_vrshrq_x(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s8)))
+int8x16_t __arm_vrshrq_x_n_s8(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s8)))
+int8x16_t __arm_vrshrq_x(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u16)))
+uint16x8_t __arm_vrshrq_x_n_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u16)))
+uint16x8_t __arm_vrshrq_x(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u32)))
+uint32x4_t __arm_vrshrq_x_n_u32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u32)))
+uint32x4_t __arm_vrshrq_x(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u8)))
+uint8x16_t __arm_vrshrq_x_n_u8(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u8)))
+uint8x16_t __arm_vrshrq_x(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_m_s32)))
+int32x4_t __arm_vsbciq_m_s32(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_m_s32)))
+int32x4_t __arm_vsbciq_m(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_m_u32)))
+uint32x4_t __arm_vsbciq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_m_u32)))
+uint32x4_t __arm_vsbciq_m(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_s32)))
+int32x4_t __arm_vsbciq_s32(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_s32)))
+int32x4_t __arm_vsbciq(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_u32)))
+uint32x4_t __arm_vsbciq_u32(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_u32)))
+uint32x4_t __arm_vsbciq(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_m_s32)))
+int32x4_t __arm_vsbcq_m_s32(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_m_s32)))
+int32x4_t __arm_vsbcq_m(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_m_u32)))
+uint32x4_t __arm_vsbcq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_m_u32)))
+uint32x4_t __arm_vsbcq_m(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_s32)))
+int32x4_t __arm_vsbcq_s32(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_s32)))
+int32x4_t __arm_vsbcq(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_u32)))
+uint32x4_t __arm_vsbcq_u32(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_u32)))
+uint32x4_t __arm_vsbcq(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s16)))
+int16x8_t __arm_vsetq_lane_s16(int16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s16)))
+int16x8_t __arm_vsetq_lane(int16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s32)))
+int32x4_t __arm_vsetq_lane_s32(int32_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s32)))
+int32x4_t __arm_vsetq_lane(int32_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s64)))
+int64x2_t __arm_vsetq_lane_s64(int64_t, int64x2_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s64)))
+int64x2_t __arm_vsetq_lane(int64_t, int64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s8)))
+int8x16_t __arm_vsetq_lane_s8(int8_t, int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s8)))
+int8x16_t __arm_vsetq_lane(int8_t, int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u16)))
+uint16x8_t __arm_vsetq_lane_u16(uint16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u16)))
+uint16x8_t __arm_vsetq_lane(uint16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u32)))
+uint32x4_t __arm_vsetq_lane_u32(uint32_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u32)))
+uint32x4_t __arm_vsetq_lane(uint32_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u64)))
+uint64x2_t __arm_vsetq_lane_u64(uint64_t, uint64x2_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u64)))
+uint64x2_t __arm_vsetq_lane(uint64_t, uint64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u8)))
+uint8x16_t __arm_vsetq_lane_u8(uint8_t, uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u8)))
+uint8x16_t __arm_vsetq_lane(uint8_t, uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s16)))
+int16x8_t __arm_vshlcq_m_s16(int16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s16)))
+int16x8_t __arm_vshlcq_m(int16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s32)))
+int32x4_t __arm_vshlcq_m_s32(int32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s32)))
+int32x4_t __arm_vshlcq_m(int32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s8)))
+int8x16_t __arm_vshlcq_m_s8(int8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s8)))
+int8x16_t __arm_vshlcq_m(int8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u16)))
+uint16x8_t __arm_vshlcq_m_u16(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u16)))
+uint16x8_t __arm_vshlcq_m(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u32)))
+uint32x4_t __arm_vshlcq_m_u32(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u32)))
+uint32x4_t __arm_vshlcq_m(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u8)))
+uint8x16_t __arm_vshlcq_m_u8(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u8)))
+uint8x16_t __arm_vshlcq_m(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s16)))
+int16x8_t __arm_vshlcq_s16(int16x8_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s16)))
+int16x8_t __arm_vshlcq(int16x8_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s32)))
+int32x4_t __arm_vshlcq_s32(int32x4_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s32)))
+int32x4_t __arm_vshlcq(int32x4_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s8)))
+int8x16_t __arm_vshlcq_s8(int8x16_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s8)))
+int8x16_t __arm_vshlcq(int8x16_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u16)))
+uint16x8_t __arm_vshlcq_u16(uint16x8_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u16)))
+uint16x8_t __arm_vshlcq(uint16x8_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u32)))
+uint32x4_t __arm_vshlcq_u32(uint32x4_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u32)))
+uint32x4_t __arm_vshlcq(uint32x4_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u8)))
+uint8x16_t __arm_vshlcq_u8(uint8x16_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u8)))
+uint8x16_t __arm_vshlcq(uint8x16_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_s16)))
+int32x4_t __arm_vshllbq_m_n_s16(int32x4_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_s16)))
+int32x4_t __arm_vshllbq_m(int32x4_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_s8)))
+int16x8_t __arm_vshllbq_m_n_s8(int16x8_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_s8)))
+int16x8_t __arm_vshllbq_m(int16x8_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_u16)))
+uint32x4_t __arm_vshllbq_m_n_u16(uint32x4_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_u16)))
+uint32x4_t __arm_vshllbq_m(uint32x4_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_u8)))
+uint16x8_t __arm_vshllbq_m_n_u8(uint16x8_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_u8)))
+uint16x8_t __arm_vshllbq_m(uint16x8_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_s16)))
+int32x4_t __arm_vshllbq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_s16)))
+int32x4_t __arm_vshllbq(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_s8)))
+int16x8_t __arm_vshllbq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_s8)))
+int16x8_t __arm_vshllbq(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_u16)))
+uint32x4_t __arm_vshllbq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_u16)))
+uint32x4_t __arm_vshllbq(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_u8)))
+uint16x8_t __arm_vshllbq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_u8)))
+uint16x8_t __arm_vshllbq(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_s16)))
+int32x4_t __arm_vshllbq_x_n_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_s16)))
+int32x4_t __arm_vshllbq_x(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_s8)))
+int16x8_t __arm_vshllbq_x_n_s8(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_s8)))
+int16x8_t __arm_vshllbq_x(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_u16)))
+uint32x4_t __arm_vshllbq_x_n_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_u16)))
+uint32x4_t __arm_vshllbq_x(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_u8)))
+uint16x8_t __arm_vshllbq_x_n_u8(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_u8)))
+uint16x8_t __arm_vshllbq_x(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_s16)))
+int32x4_t __arm_vshlltq_m_n_s16(int32x4_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_s16)))
+int32x4_t __arm_vshlltq_m(int32x4_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_s8)))
+int16x8_t __arm_vshlltq_m_n_s8(int16x8_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_s8)))
+int16x8_t __arm_vshlltq_m(int16x8_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_u16)))
+uint32x4_t __arm_vshlltq_m_n_u16(uint32x4_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_u16)))
+uint32x4_t __arm_vshlltq_m(uint32x4_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_u8)))
+uint16x8_t __arm_vshlltq_m_n_u8(uint16x8_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_u8)))
+uint16x8_t __arm_vshlltq_m(uint16x8_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_s16)))
+int32x4_t __arm_vshlltq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_s16)))
+int32x4_t __arm_vshlltq(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_s8)))
+int16x8_t __arm_vshlltq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_s8)))
+int16x8_t __arm_vshlltq(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_u16)))
+uint32x4_t __arm_vshlltq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_u16)))
+uint32x4_t __arm_vshlltq(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_u8)))
+uint16x8_t __arm_vshlltq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_u8)))
+uint16x8_t __arm_vshlltq(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_s16)))
+int32x4_t __arm_vshlltq_x_n_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_s16)))
+int32x4_t __arm_vshlltq_x(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_s8)))
+int16x8_t __arm_vshlltq_x_n_s8(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_s8)))
+int16x8_t __arm_vshlltq_x(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_u16)))
+uint32x4_t __arm_vshlltq_x_n_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_u16)))
+uint32x4_t __arm_vshlltq_x(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_u8)))
+uint16x8_t __arm_vshlltq_x_n_u8(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_u8)))
+uint16x8_t __arm_vshlltq_x(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s16)))
+int16x8_t __arm_vshlq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s16)))
+int16x8_t __arm_vshlq_m_n(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s32)))
+int32x4_t __arm_vshlq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s32)))
+int32x4_t __arm_vshlq_m_n(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s8)))
+int8x16_t __arm_vshlq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s8)))
+int8x16_t __arm_vshlq_m_n(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u16)))
+uint16x8_t __arm_vshlq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u16)))
+uint16x8_t __arm_vshlq_m_n(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u32)))
+uint32x4_t __arm_vshlq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u32)))
+uint32x4_t __arm_vshlq_m_n(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u8)))
+uint8x16_t __arm_vshlq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u8)))
+uint8x16_t __arm_vshlq_m_n(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s16)))
+int16x8_t __arm_vshlq_m_r_s16(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s16)))
+int16x8_t __arm_vshlq_m_r(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s32)))
+int32x4_t __arm_vshlq_m_r_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s32)))
+int32x4_t __arm_vshlq_m_r(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s8)))
+int8x16_t __arm_vshlq_m_r_s8(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s8)))
+int8x16_t __arm_vshlq_m_r(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u16)))
+uint16x8_t __arm_vshlq_m_r_u16(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u16)))
+uint16x8_t __arm_vshlq_m_r(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u32)))
+uint32x4_t __arm_vshlq_m_r_u32(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u32)))
+uint32x4_t __arm_vshlq_m_r(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u8)))
+uint8x16_t __arm_vshlq_m_r_u8(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u8)))
+uint8x16_t __arm_vshlq_m_r(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s16)))
+int16x8_t __arm_vshlq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s16)))
+int16x8_t __arm_vshlq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s32)))
+int32x4_t __arm_vshlq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s32)))
+int32x4_t __arm_vshlq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s8)))
+int8x16_t __arm_vshlq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s8)))
+int8x16_t __arm_vshlq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u16)))
+uint16x8_t __arm_vshlq_m_u16(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u16)))
+uint16x8_t __arm_vshlq_m(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u32)))
+uint32x4_t __arm_vshlq_m_u32(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u32)))
+uint32x4_t __arm_vshlq_m(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u8)))
+uint8x16_t __arm_vshlq_m_u8(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u8)))
+uint8x16_t __arm_vshlq_m(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s16)))
+int16x8_t __arm_vshlq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s16)))
+int16x8_t __arm_vshlq_n(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s32)))
+int32x4_t __arm_vshlq_n_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s32)))
+int32x4_t __arm_vshlq_n(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s8)))
+int8x16_t __arm_vshlq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s8)))
+int8x16_t __arm_vshlq_n(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u16)))
+uint16x8_t __arm_vshlq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u16)))
+uint16x8_t __arm_vshlq_n(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u32)))
+uint32x4_t __arm_vshlq_n_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u32)))
+uint32x4_t __arm_vshlq_n(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u8)))
+uint8x16_t __arm_vshlq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u8)))
+uint8x16_t __arm_vshlq_n(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s16)))
+int16x8_t __arm_vshlq_r_s16(int16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s16)))
+int16x8_t __arm_vshlq_r(int16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s32)))
+int32x4_t __arm_vshlq_r_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s32)))
+int32x4_t __arm_vshlq_r(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s8)))
+int8x16_t __arm_vshlq_r_s8(int8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s8)))
+int8x16_t __arm_vshlq_r(int8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u16)))
+uint16x8_t __arm_vshlq_r_u16(uint16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u16)))
+uint16x8_t __arm_vshlq_r(uint16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u32)))
+uint32x4_t __arm_vshlq_r_u32(uint32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u32)))
+uint32x4_t __arm_vshlq_r(uint32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u8)))
+uint8x16_t __arm_vshlq_r_u8(uint8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u8)))
+uint8x16_t __arm_vshlq_r(uint8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s16)))
+int16x8_t __arm_vshlq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s16)))
+int16x8_t __arm_vshlq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s32)))
+int32x4_t __arm_vshlq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s32)))
+int32x4_t __arm_vshlq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s8)))
+int8x16_t __arm_vshlq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s8)))
+int8x16_t __arm_vshlq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u16)))
+uint16x8_t __arm_vshlq_u16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u16)))
+uint16x8_t __arm_vshlq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u32)))
+uint32x4_t __arm_vshlq_u32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u32)))
+uint32x4_t __arm_vshlq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u8)))
+uint8x16_t __arm_vshlq_u8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u8)))
+uint8x16_t __arm_vshlq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s16)))
+int16x8_t __arm_vshlq_x_n_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s16)))
+int16x8_t __arm_vshlq_x_n(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s32)))
+int32x4_t __arm_vshlq_x_n_s32(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s32)))
+int32x4_t __arm_vshlq_x_n(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s8)))
+int8x16_t __arm_vshlq_x_n_s8(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s8)))
+int8x16_t __arm_vshlq_x_n(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u16)))
+uint16x8_t __arm_vshlq_x_n_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u16)))
+uint16x8_t __arm_vshlq_x_n(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u32)))
+uint32x4_t __arm_vshlq_x_n_u32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u32)))
+uint32x4_t __arm_vshlq_x_n(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u8)))
+uint8x16_t __arm_vshlq_x_n_u8(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u8)))
+uint8x16_t __arm_vshlq_x_n(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s16)))
+int16x8_t __arm_vshlq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s16)))
+int16x8_t __arm_vshlq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s32)))
+int32x4_t __arm_vshlq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s32)))
+int32x4_t __arm_vshlq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s8)))
+int8x16_t __arm_vshlq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s8)))
+int8x16_t __arm_vshlq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u16)))
+uint16x8_t __arm_vshlq_x_u16(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u16)))
+uint16x8_t __arm_vshlq_x(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u32)))
+uint32x4_t __arm_vshlq_x_u32(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u32)))
+uint32x4_t __arm_vshlq_x(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u8)))
+uint8x16_t __arm_vshlq_x_u8(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u8)))
+uint8x16_t __arm_vshlq_x(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_s16)))
+int8x16_t __arm_vshrnbq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_s16)))
+int8x16_t __arm_vshrnbq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_s32)))
+int16x8_t __arm_vshrnbq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_s32)))
+int16x8_t __arm_vshrnbq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_u16)))
+uint8x16_t __arm_vshrnbq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_u16)))
+uint8x16_t __arm_vshrnbq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_u32)))
+uint16x8_t __arm_vshrnbq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_u32)))
+uint16x8_t __arm_vshrnbq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_s16)))
+int8x16_t __arm_vshrnbq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_s16)))
+int8x16_t __arm_vshrnbq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_s32)))
+int16x8_t __arm_vshrnbq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_s32)))
+int16x8_t __arm_vshrnbq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_u16)))
+uint8x16_t __arm_vshrnbq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_u16)))
+uint8x16_t __arm_vshrnbq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_u32)))
+uint16x8_t __arm_vshrnbq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_u32)))
+uint16x8_t __arm_vshrnbq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_s16)))
+int8x16_t __arm_vshrntq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_s16)))
+int8x16_t __arm_vshrntq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_s32)))
+int16x8_t __arm_vshrntq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_s32)))
+int16x8_t __arm_vshrntq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_u16)))
+uint8x16_t __arm_vshrntq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_u16)))
+uint8x16_t __arm_vshrntq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_u32)))
+uint16x8_t __arm_vshrntq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_u32)))
+uint16x8_t __arm_vshrntq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_s16)))
+int8x16_t __arm_vshrntq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_s16)))
+int8x16_t __arm_vshrntq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_s32)))
+int16x8_t __arm_vshrntq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_s32)))
+int16x8_t __arm_vshrntq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_u16)))
+uint8x16_t __arm_vshrntq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_u16)))
+uint8x16_t __arm_vshrntq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_u32)))
+uint16x8_t __arm_vshrntq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_u32)))
+uint16x8_t __arm_vshrntq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s16)))
+int16x8_t __arm_vshrq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s16)))
+int16x8_t __arm_vshrq_m(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s32)))
+int32x4_t __arm_vshrq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s32)))
+int32x4_t __arm_vshrq_m(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s8)))
+int8x16_t __arm_vshrq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s8)))
+int8x16_t __arm_vshrq_m(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u16)))
+uint16x8_t __arm_vshrq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u16)))
+uint16x8_t __arm_vshrq_m(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u32)))
+uint32x4_t __arm_vshrq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u32)))
+uint32x4_t __arm_vshrq_m(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u8)))
+uint8x16_t __arm_vshrq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u8)))
+uint8x16_t __arm_vshrq_m(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s16)))
+int16x8_t __arm_vshrq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s16)))
+int16x8_t __arm_vshrq(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s32)))
+int32x4_t __arm_vshrq_n_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s32)))
+int32x4_t __arm_vshrq(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s8)))
+int8x16_t __arm_vshrq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s8)))
+int8x16_t __arm_vshrq(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u16)))
+uint16x8_t __arm_vshrq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u16)))
+uint16x8_t __arm_vshrq(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u32)))
+uint32x4_t __arm_vshrq_n_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u32)))
+uint32x4_t __arm_vshrq(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u8)))
+uint8x16_t __arm_vshrq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u8)))
+uint8x16_t __arm_vshrq(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s16)))
+int16x8_t __arm_vshrq_x_n_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s16)))
+int16x8_t __arm_vshrq_x(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s32)))
+int32x4_t __arm_vshrq_x_n_s32(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s32)))
+int32x4_t __arm_vshrq_x(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s8)))
+int8x16_t __arm_vshrq_x_n_s8(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s8)))
+int8x16_t __arm_vshrq_x(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u16)))
+uint16x8_t __arm_vshrq_x_n_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u16)))
+uint16x8_t __arm_vshrq_x(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u32)))
+uint32x4_t __arm_vshrq_x_n_u32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u32)))
+uint32x4_t __arm_vshrq_x(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u8)))
+uint8x16_t __arm_vshrq_x_n_u8(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u8)))
+uint8x16_t __arm_vshrq_x(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s16)))
+int16x8_t __arm_vsliq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s16)))
+int16x8_t __arm_vsliq_m(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s32)))
+int32x4_t __arm_vsliq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s32)))
+int32x4_t __arm_vsliq_m(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s8)))
+int8x16_t __arm_vsliq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s8)))
+int8x16_t __arm_vsliq_m(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u16)))
+uint16x8_t __arm_vsliq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u16)))
+uint16x8_t __arm_vsliq_m(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u32)))
+uint32x4_t __arm_vsliq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u32)))
+uint32x4_t __arm_vsliq_m(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u8)))
+uint8x16_t __arm_vsliq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u8)))
+uint8x16_t __arm_vsliq_m(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s16)))
+int16x8_t __arm_vsliq_n_s16(int16x8_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s16)))
+int16x8_t __arm_vsliq(int16x8_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s32)))
+int32x4_t __arm_vsliq_n_s32(int32x4_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s32)))
+int32x4_t __arm_vsliq(int32x4_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s8)))
+int8x16_t __arm_vsliq_n_s8(int8x16_t, int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s8)))
+int8x16_t __arm_vsliq(int8x16_t, int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u16)))
+uint16x8_t __arm_vsliq_n_u16(uint16x8_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u16)))
+uint16x8_t __arm_vsliq(uint16x8_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u32)))
+uint32x4_t __arm_vsliq_n_u32(uint32x4_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u32)))
+uint32x4_t __arm_vsliq(uint32x4_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u8)))
+uint8x16_t __arm_vsliq_n_u8(uint8x16_t, uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u8)))
+uint8x16_t __arm_vsliq(uint8x16_t, uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s16)))
+int16x8_t __arm_vsriq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s16)))
+int16x8_t __arm_vsriq_m(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s32)))
+int32x4_t __arm_vsriq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s32)))
+int32x4_t __arm_vsriq_m(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s8)))
+int8x16_t __arm_vsriq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s8)))
+int8x16_t __arm_vsriq_m(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u16)))
+uint16x8_t __arm_vsriq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u16)))
+uint16x8_t __arm_vsriq_m(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u32)))
+uint32x4_t __arm_vsriq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u32)))
+uint32x4_t __arm_vsriq_m(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u8)))
+uint8x16_t __arm_vsriq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u8)))
+uint8x16_t __arm_vsriq_m(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s16)))
+int16x8_t __arm_vsriq_n_s16(int16x8_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s16)))
+int16x8_t __arm_vsriq(int16x8_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s32)))
+int32x4_t __arm_vsriq_n_s32(int32x4_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s32)))
+int32x4_t __arm_vsriq(int32x4_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s8)))
+int8x16_t __arm_vsriq_n_s8(int8x16_t, int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s8)))
+int8x16_t __arm_vsriq(int8x16_t, int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u16)))
+uint16x8_t __arm_vsriq_n_u16(uint16x8_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u16)))
+uint16x8_t __arm_vsriq(uint16x8_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u32)))
+uint32x4_t __arm_vsriq_n_u32(uint32x4_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u32)))
+uint32x4_t __arm_vsriq(uint32x4_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u8)))
+uint8x16_t __arm_vsriq_n_u8(uint8x16_t, uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u8)))
+uint8x16_t __arm_vsriq(uint8x16_t, uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s16)))
+void __arm_vst1q_p_s16(int16_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s16)))
+void __arm_vst1q_p(int16_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s32)))
+void __arm_vst1q_p_s32(int32_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s32)))
+void __arm_vst1q_p(int32_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s8)))
+void __arm_vst1q_p_s8(int8_t *, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s8)))
+void __arm_vst1q_p(int8_t *, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u16)))
+void __arm_vst1q_p_u16(uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u16)))
+void __arm_vst1q_p(uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u32)))
+void __arm_vst1q_p_u32(uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u32)))
+void __arm_vst1q_p(uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u8)))
+void __arm_vst1q_p_u8(uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u8)))
+void __arm_vst1q_p(uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s16)))
+void __arm_vst1q_s16(int16_t *, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s16)))
+void __arm_vst1q(int16_t *, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s32)))
+void __arm_vst1q_s32(int32_t *, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s32)))
+void __arm_vst1q(int32_t *, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s8)))
+void __arm_vst1q_s8(int8_t *, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s8)))
+void __arm_vst1q(int8_t *, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u16)))
+void __arm_vst1q_u16(uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u16)))
+void __arm_vst1q(uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u32)))
+void __arm_vst1q_u32(uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u32)))
+void __arm_vst1q(uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u8)))
+void __arm_vst1q_u8(uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u8)))
+void __arm_vst1q(uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s16)))
+void __arm_vst2q_s16(int16_t *, int16x8x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s16)))
+void __arm_vst2q(int16_t *, int16x8x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s32)))
+void __arm_vst2q_s32(int32_t *, int32x4x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s32)))
+void __arm_vst2q(int32_t *, int32x4x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s8)))
+void __arm_vst2q_s8(int8_t *, int8x16x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s8)))
+void __arm_vst2q(int8_t *, int8x16x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u16)))
+void __arm_vst2q_u16(uint16_t *, uint16x8x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u16)))
+void __arm_vst2q(uint16_t *, uint16x8x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u32)))
+void __arm_vst2q_u32(uint32_t *, uint32x4x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u32)))
+void __arm_vst2q(uint32_t *, uint32x4x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u8)))
+void __arm_vst2q_u8(uint8_t *, uint8x16x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u8)))
+void __arm_vst2q(uint8_t *, uint8x16x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s16)))
+void __arm_vst4q_s16(int16_t *, int16x8x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s16)))
+void __arm_vst4q(int16_t *, int16x8x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s32)))
+void __arm_vst4q_s32(int32_t *, int32x4x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s32)))
+void __arm_vst4q(int32_t *, int32x4x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s8)))
+void __arm_vst4q_s8(int8_t *, int8x16x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s8)))
+void __arm_vst4q(int8_t *, int8x16x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u16)))
+void __arm_vst4q_u16(uint16_t *, uint16x8x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u16)))
+void __arm_vst4q(uint16_t *, uint16x8x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u32)))
+void __arm_vst4q_u32(uint32_t *, uint32x4x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u32)))
+void __arm_vst4q(uint32_t *, uint32x4x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u8)))
+void __arm_vst4q_u8(uint8_t *, uint8x16x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u8)))
+void __arm_vst4q(uint8_t *, uint8x16x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s16)))
+void __arm_vstrbq_p_s16(int8_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s16)))
+void __arm_vstrbq_p(int8_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s32)))
+void __arm_vstrbq_p_s32(int8_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s32)))
+void __arm_vstrbq_p(int8_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s8)))
+void __arm_vstrbq_p_s8(int8_t *, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s8)))
+void __arm_vstrbq_p(int8_t *, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u16)))
+void __arm_vstrbq_p_u16(uint8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u16)))
+void __arm_vstrbq_p(uint8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u32)))
+void __arm_vstrbq_p_u32(uint8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u32)))
+void __arm_vstrbq_p(uint8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u8)))
+void __arm_vstrbq_p_u8(uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u8)))
+void __arm_vstrbq_p(uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s16)))
+void __arm_vstrbq_s16(int8_t *, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s16)))
+void __arm_vstrbq(int8_t *, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s32)))
+void __arm_vstrbq_s32(int8_t *, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s32)))
+void __arm_vstrbq(int8_t *, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s8)))
+void __arm_vstrbq_s8(int8_t *, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s8)))
+void __arm_vstrbq(int8_t *, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s16)))
+void __arm_vstrbq_scatter_offset_p_s16(int8_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s16)))
+void __arm_vstrbq_scatter_offset_p(int8_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s32)))
+void __arm_vstrbq_scatter_offset_p_s32(int8_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s32)))
+void __arm_vstrbq_scatter_offset_p(int8_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s8)))
+void __arm_vstrbq_scatter_offset_p_s8(int8_t *, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s8)))
+void __arm_vstrbq_scatter_offset_p(int8_t *, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u16)))
+void __arm_vstrbq_scatter_offset_p_u16(uint8_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u16)))
+void __arm_vstrbq_scatter_offset_p(uint8_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u32)))
+void __arm_vstrbq_scatter_offset_p_u32(uint8_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u32)))
+void __arm_vstrbq_scatter_offset_p(uint8_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u8)))
+void __arm_vstrbq_scatter_offset_p_u8(uint8_t *, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u8)))
+void __arm_vstrbq_scatter_offset_p(uint8_t *, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s16)))
+void __arm_vstrbq_scatter_offset_s16(int8_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s16)))
+void __arm_vstrbq_scatter_offset(int8_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s32)))
+void __arm_vstrbq_scatter_offset_s32(int8_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s32)))
+void __arm_vstrbq_scatter_offset(int8_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s8)))
+void __arm_vstrbq_scatter_offset_s8(int8_t *, uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s8)))
+void __arm_vstrbq_scatter_offset(int8_t *, uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u16)))
+void __arm_vstrbq_scatter_offset_u16(uint8_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u16)))
+void __arm_vstrbq_scatter_offset(uint8_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u32)))
+void __arm_vstrbq_scatter_offset_u32(uint8_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u32)))
+void __arm_vstrbq_scatter_offset(uint8_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u8)))
+void __arm_vstrbq_scatter_offset_u8(uint8_t *, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u8)))
+void __arm_vstrbq_scatter_offset(uint8_t *, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u16)))
+void __arm_vstrbq_u16(uint8_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u16)))
+void __arm_vstrbq(uint8_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u32)))
+void __arm_vstrbq_u32(uint8_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u32)))
+void __arm_vstrbq(uint8_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u8)))
+void __arm_vstrbq_u8(uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u8)))
+void __arm_vstrbq(uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_p_s64)))
+void __arm_vstrdq_scatter_base_p_s64(uint64x2_t, int, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_p_s64)))
+void __arm_vstrdq_scatter_base_p(uint64x2_t, int, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_p_u64)))
+void __arm_vstrdq_scatter_base_p_u64(uint64x2_t, int, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_p_u64)))
+void __arm_vstrdq_scatter_base_p(uint64x2_t, int, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_s64)))
+void __arm_vstrdq_scatter_base_s64(uint64x2_t, int, int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_s64)))
+void __arm_vstrdq_scatter_base(uint64x2_t, int, int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_u64)))
+void __arm_vstrdq_scatter_base_u64(uint64x2_t, int, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_u64)))
+void __arm_vstrdq_scatter_base(uint64x2_t, int, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_p_s64)))
+void __arm_vstrdq_scatter_base_wb_p_s64(uint64x2_t *, int, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_p_s64)))
+void __arm_vstrdq_scatter_base_wb_p(uint64x2_t *, int, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_p_u64)))
+void __arm_vstrdq_scatter_base_wb_p_u64(uint64x2_t *, int, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_p_u64)))
+void __arm_vstrdq_scatter_base_wb_p(uint64x2_t *, int, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_s64)))
+void __arm_vstrdq_scatter_base_wb_s64(uint64x2_t *, int, int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_s64)))
+void __arm_vstrdq_scatter_base_wb(uint64x2_t *, int, int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_u64)))
+void __arm_vstrdq_scatter_base_wb_u64(uint64x2_t *, int, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_u64)))
+void __arm_vstrdq_scatter_base_wb(uint64x2_t *, int, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_p_s64)))
+void __arm_vstrdq_scatter_offset_p_s64(int64_t *, uint64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_p_s64)))
+void __arm_vstrdq_scatter_offset_p(int64_t *, uint64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_p_u64)))
+void __arm_vstrdq_scatter_offset_p_u64(uint64_t *, uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_p_u64)))
+void __arm_vstrdq_scatter_offset_p(uint64_t *, uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_s64)))
+void __arm_vstrdq_scatter_offset_s64(int64_t *, uint64x2_t, int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_s64)))
+void __arm_vstrdq_scatter_offset(int64_t *, uint64x2_t, int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_u64)))
+void __arm_vstrdq_scatter_offset_u64(uint64_t *, uint64x2_t, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_u64)))
+void __arm_vstrdq_scatter_offset(uint64_t *, uint64x2_t, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_p_s64)))
+void __arm_vstrdq_scatter_shifted_offset_p_s64(int64_t *, uint64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_p_s64)))
+void __arm_vstrdq_scatter_shifted_offset_p(int64_t *, uint64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_p_u64)))
+void __arm_vstrdq_scatter_shifted_offset_p_u64(uint64_t *, uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_p_u64)))
+void __arm_vstrdq_scatter_shifted_offset_p(uint64_t *, uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_s64)))
+void __arm_vstrdq_scatter_shifted_offset_s64(int64_t *, uint64x2_t, int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_s64)))
+void __arm_vstrdq_scatter_shifted_offset(int64_t *, uint64x2_t, int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_u64)))
+void __arm_vstrdq_scatter_shifted_offset_u64(uint64_t *, uint64x2_t, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_u64)))
+void __arm_vstrdq_scatter_shifted_offset(uint64_t *, uint64x2_t, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_s16)))
+void __arm_vstrhq_p_s16(int16_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_s16)))
+void __arm_vstrhq_p(int16_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_s32)))
+void __arm_vstrhq_p_s32(int16_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_s32)))
+void __arm_vstrhq_p(int16_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_u16)))
+void __arm_vstrhq_p_u16(uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_u16)))
+void __arm_vstrhq_p(uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_u32)))
+void __arm_vstrhq_p_u32(uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_u32)))
+void __arm_vstrhq_p(uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_s16)))
+void __arm_vstrhq_s16(int16_t *, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_s16)))
+void __arm_vstrhq(int16_t *, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_s32)))
+void __arm_vstrhq_s32(int16_t *, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_s32)))
+void __arm_vstrhq(int16_t *, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_s16)))
+void __arm_vstrhq_scatter_offset_p_s16(int16_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_s16)))
+void __arm_vstrhq_scatter_offset_p(int16_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_s32)))
+void __arm_vstrhq_scatter_offset_p_s32(int16_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_s32)))
+void __arm_vstrhq_scatter_offset_p(int16_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_u16)))
+void __arm_vstrhq_scatter_offset_p_u16(uint16_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_u16)))
+void __arm_vstrhq_scatter_offset_p(uint16_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_u32)))
+void __arm_vstrhq_scatter_offset_p_u32(uint16_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_u32)))
+void __arm_vstrhq_scatter_offset_p(uint16_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_s16)))
+void __arm_vstrhq_scatter_offset_s16(int16_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_s16)))
+void __arm_vstrhq_scatter_offset(int16_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_s32)))
+void __arm_vstrhq_scatter_offset_s32(int16_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_s32)))
+void __arm_vstrhq_scatter_offset(int16_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_u16)))
+void __arm_vstrhq_scatter_offset_u16(uint16_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_u16)))
+void __arm_vstrhq_scatter_offset(uint16_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_u32)))
+void __arm_vstrhq_scatter_offset_u32(uint16_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_u32)))
+void __arm_vstrhq_scatter_offset(uint16_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_s16)))
+void __arm_vstrhq_scatter_shifted_offset_p_s16(int16_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_s16)))
+void __arm_vstrhq_scatter_shifted_offset_p(int16_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_s32)))
+void __arm_vstrhq_scatter_shifted_offset_p_s32(int16_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_s32)))
+void __arm_vstrhq_scatter_shifted_offset_p(int16_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_u16)))
+void __arm_vstrhq_scatter_shifted_offset_p_u16(uint16_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_u16)))
+void __arm_vstrhq_scatter_shifted_offset_p(uint16_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_u32)))
+void __arm_vstrhq_scatter_shifted_offset_p_u32(uint16_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_u32)))
+void __arm_vstrhq_scatter_shifted_offset_p(uint16_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_s16)))
+void __arm_vstrhq_scatter_shifted_offset_s16(int16_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_s16)))
+void __arm_vstrhq_scatter_shifted_offset(int16_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_s32)))
+void __arm_vstrhq_scatter_shifted_offset_s32(int16_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_s32)))
+void __arm_vstrhq_scatter_shifted_offset(int16_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_u16)))
+void __arm_vstrhq_scatter_shifted_offset_u16(uint16_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_u16)))
+void __arm_vstrhq_scatter_shifted_offset(uint16_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_u32)))
+void __arm_vstrhq_scatter_shifted_offset_u32(uint16_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_u32)))
+void __arm_vstrhq_scatter_shifted_offset(uint16_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_u16)))
+void __arm_vstrhq_u16(uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_u16)))
+void __arm_vstrhq(uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_u32)))
+void __arm_vstrhq_u32(uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_u32)))
+void __arm_vstrhq(uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_s32)))
+void __arm_vstrwq_p_s32(int32_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_s32)))
+void __arm_vstrwq_p(int32_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_u32)))
+void __arm_vstrwq_p_u32(uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_u32)))
+void __arm_vstrwq_p(uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_s32)))
+void __arm_vstrwq_s32(int32_t *, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_s32)))
+void __arm_vstrwq(int32_t *, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_s32)))
+void __arm_vstrwq_scatter_base_p_s32(uint32x4_t, int, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_s32)))
+void __arm_vstrwq_scatter_base_p(uint32x4_t, int, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_u32)))
+void __arm_vstrwq_scatter_base_p_u32(uint32x4_t, int, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_u32)))
+void __arm_vstrwq_scatter_base_p(uint32x4_t, int, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_s32)))
+void __arm_vstrwq_scatter_base_s32(uint32x4_t, int, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_s32)))
+void __arm_vstrwq_scatter_base(uint32x4_t, int, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_u32)))
+void __arm_vstrwq_scatter_base_u32(uint32x4_t, int, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_u32)))
+void __arm_vstrwq_scatter_base(uint32x4_t, int, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_s32)))
+void __arm_vstrwq_scatter_base_wb_p_s32(uint32x4_t *, int, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_s32)))
+void __arm_vstrwq_scatter_base_wb_p(uint32x4_t *, int, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_u32)))
+void __arm_vstrwq_scatter_base_wb_p_u32(uint32x4_t *, int, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_u32)))
+void __arm_vstrwq_scatter_base_wb_p(uint32x4_t *, int, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_s32)))
+void __arm_vstrwq_scatter_base_wb_s32(uint32x4_t *, int, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_s32)))
+void __arm_vstrwq_scatter_base_wb(uint32x4_t *, int, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_u32)))
+void __arm_vstrwq_scatter_base_wb_u32(uint32x4_t *, int, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_u32)))
+void __arm_vstrwq_scatter_base_wb(uint32x4_t *, int, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_s32)))
+void __arm_vstrwq_scatter_offset_p_s32(int32_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_s32)))
+void __arm_vstrwq_scatter_offset_p(int32_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_u32)))
+void __arm_vstrwq_scatter_offset_p_u32(uint32_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_u32)))
+void __arm_vstrwq_scatter_offset_p(uint32_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_s32)))
+void __arm_vstrwq_scatter_offset_s32(int32_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_s32)))
+void __arm_vstrwq_scatter_offset(int32_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_u32)))
+void __arm_vstrwq_scatter_offset_u32(uint32_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_u32)))
+void __arm_vstrwq_scatter_offset(uint32_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_s32)))
+void __arm_vstrwq_scatter_shifted_offset_p_s32(int32_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_s32)))
+void __arm_vstrwq_scatter_shifted_offset_p(int32_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_u32)))
+void __arm_vstrwq_scatter_shifted_offset_p_u32(uint32_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_u32)))
+void __arm_vstrwq_scatter_shifted_offset_p(uint32_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_s32)))
+void __arm_vstrwq_scatter_shifted_offset_s32(int32_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_s32)))
+void __arm_vstrwq_scatter_shifted_offset(int32_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_u32)))
+void __arm_vstrwq_scatter_shifted_offset_u32(uint32_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_u32)))
+void __arm_vstrwq_scatter_shifted_offset(uint32_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_u32)))
+void __arm_vstrwq_u32(uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_u32)))
+void __arm_vstrwq(uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s16)))
+int16x8_t __arm_vsubq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s16)))
+int16x8_t __arm_vsubq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s32)))
+int32x4_t __arm_vsubq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s32)))
+int32x4_t __arm_vsubq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s8)))
+int8x16_t __arm_vsubq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s8)))
+int8x16_t __arm_vsubq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u16)))
+uint16x8_t __arm_vsubq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u16)))
+uint16x8_t __arm_vsubq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u32)))
+uint32x4_t __arm_vsubq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u32)))
+uint32x4_t __arm_vsubq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u8)))
+uint8x16_t __arm_vsubq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u8)))
+uint8x16_t __arm_vsubq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s16)))
+int16x8_t __arm_vsubq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s16)))
+int16x8_t __arm_vsubq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s32)))
+int32x4_t __arm_vsubq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s32)))
+int32x4_t __arm_vsubq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s8)))
+int8x16_t __arm_vsubq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s8)))
+int8x16_t __arm_vsubq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u16)))
+uint16x8_t __arm_vsubq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u16)))
+uint16x8_t __arm_vsubq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u32)))
+uint32x4_t __arm_vsubq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u32)))
+uint32x4_t __arm_vsubq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u8)))
+uint8x16_t __arm_vsubq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u8)))
+uint8x16_t __arm_vsubq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s16)))
+int16x8_t __arm_vsubq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s16)))
+int16x8_t __arm_vsubq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s32)))
+int32x4_t __arm_vsubq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s32)))
+int32x4_t __arm_vsubq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s8)))
+int8x16_t __arm_vsubq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s8)))
+int8x16_t __arm_vsubq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u16)))
+uint16x8_t __arm_vsubq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u16)))
+uint16x8_t __arm_vsubq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u32)))
+uint32x4_t __arm_vsubq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u32)))
+uint32x4_t __arm_vsubq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u8)))
+uint8x16_t __arm_vsubq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u8)))
+uint8x16_t __arm_vsubq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s16)))
+int16x8_t __arm_vsubq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s16)))
+int16x8_t __arm_vsubq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s32)))
+int32x4_t __arm_vsubq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s32)))
+int32x4_t __arm_vsubq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s8)))
+int8x16_t __arm_vsubq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s8)))
+int8x16_t __arm_vsubq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u16)))
+uint16x8_t __arm_vsubq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u16)))
+uint16x8_t __arm_vsubq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u32)))
+uint32x4_t __arm_vsubq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u32)))
+uint32x4_t __arm_vsubq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u8)))
+uint8x16_t __arm_vsubq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u8)))
+uint8x16_t __arm_vsubq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s16)))
+int16x8_t __arm_vsubq_x_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s16)))
+int16x8_t __arm_vsubq_x(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s32)))
+int32x4_t __arm_vsubq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s32)))
+int32x4_t __arm_vsubq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s8)))
+int8x16_t __arm_vsubq_x_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s8)))
+int8x16_t __arm_vsubq_x(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u16)))
+uint16x8_t __arm_vsubq_x_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u16)))
+uint16x8_t __arm_vsubq_x(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u32)))
+uint32x4_t __arm_vsubq_x_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u32)))
+uint32x4_t __arm_vsubq_x(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u8)))
+uint8x16_t __arm_vsubq_x_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u8)))
+uint8x16_t __arm_vsubq_x(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s16)))
+int16x8_t __arm_vsubq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s16)))
+int16x8_t __arm_vsubq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s32)))
+int32x4_t __arm_vsubq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s32)))
+int32x4_t __arm_vsubq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s8)))
+int8x16_t __arm_vsubq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s8)))
+int8x16_t __arm_vsubq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u16)))
+uint16x8_t __arm_vsubq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u16)))
+uint16x8_t __arm_vsubq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u32)))
+uint32x4_t __arm_vsubq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u32)))
+uint32x4_t __arm_vsubq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u8)))
+uint8x16_t __arm_vsubq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u8)))
+uint8x16_t __arm_vsubq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_s16)))
+int16x8_t __arm_vuninitializedq(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_s32)))
+int32x4_t __arm_vuninitializedq(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_s64)))
+int64x2_t __arm_vuninitializedq(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_s8)))
+int8x16_t __arm_vuninitializedq(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_u16)))
+uint16x8_t __arm_vuninitializedq(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_u32)))
+uint32x4_t __arm_vuninitializedq(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_u64)))
+uint64x2_t __arm_vuninitializedq(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_u8)))
+uint8x16_t __arm_vuninitializedq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_s16)))
+int16x8_t __arm_vuninitializedq_s16();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_s32)))
+int32x4_t __arm_vuninitializedq_s32();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_s64)))
+int64x2_t __arm_vuninitializedq_s64();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_s8)))
+int8x16_t __arm_vuninitializedq_s8();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_u16)))
+uint16x8_t __arm_vuninitializedq_u16();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_u32)))
+uint32x4_t __arm_vuninitializedq_u32();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_u64)))
+uint64x2_t __arm_vuninitializedq_u64();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_u8)))
+uint8x16_t __arm_vuninitializedq_u8();
+
+#if (__ARM_FEATURE_MVE & 2)
+
+typedef __fp16 float16_t;
+typedef float float32_t;
+typedef __attribute__((__neon_vector_type__(8), __clang_arm_mve_strict_polymorphism)) float16_t float16x8_t;
+typedef struct { float16x8_t val[2]; } float16x8x2_t;
+typedef struct { float16x8_t val[4]; } float16x8x4_t;
+typedef __attribute__((__neon_vector_type__(4), __clang_arm_mve_strict_polymorphism)) float32_t float32x4_t;
+typedef struct { float32x4_t val[2]; } float32x4x2_t;
+typedef struct { float32x4_t val[4]; } float32x4x4_t;
+
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_f16)))
+float16x8_t __arm_vabdq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_f16)))
+float16x8_t __arm_vabdq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_f32)))
+float32x4_t __arm_vabdq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_f32)))
+float32x4_t __arm_vabdq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_f16)))
+float16x8_t __arm_vabdq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_f16)))
+float16x8_t __arm_vabdq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_f32)))
+float32x4_t __arm_vabdq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_f32)))
+float32x4_t __arm_vabdq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_f16)))
+float16x8_t __arm_vabdq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_f16)))
+float16x8_t __arm_vabdq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_f32)))
+float32x4_t __arm_vabdq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_f32)))
+float32x4_t __arm_vabdq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_f16)))
+float16x8_t __arm_vabsq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_f16)))
+float16x8_t __arm_vabsq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_f32)))
+float32x4_t __arm_vabsq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_f32)))
+float32x4_t __arm_vabsq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_f16)))
+float16x8_t __arm_vabsq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_f16)))
+float16x8_t __arm_vabsq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_f32)))
+float32x4_t __arm_vabsq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_f32)))
+float32x4_t __arm_vabsq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_f16)))
+float16x8_t __arm_vabsq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_f16)))
+float16x8_t __arm_vabsq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_f32)))
+float32x4_t __arm_vabsq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_f32)))
+float32x4_t __arm_vabsq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_f16)))
+float16x8_t __arm_vaddq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_f16)))
+float16x8_t __arm_vaddq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_f32)))
+float32x4_t __arm_vaddq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_f32)))
+float32x4_t __arm_vaddq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_f16)))
+float16x8_t __arm_vaddq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_f16)))
+float16x8_t __arm_vaddq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_f32)))
+float32x4_t __arm_vaddq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_f32)))
+float32x4_t __arm_vaddq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_f16)))
+float16x8_t __arm_vaddq_m_n_f16(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_f16)))
+float16x8_t __arm_vaddq_m(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_f32)))
+float32x4_t __arm_vaddq_m_n_f32(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_f32)))
+float32x4_t __arm_vaddq_m(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_f16)))
+float16x8_t __arm_vaddq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_f16)))
+float16x8_t __arm_vaddq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_f32)))
+float32x4_t __arm_vaddq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_f32)))
+float32x4_t __arm_vaddq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_f16)))
+float16x8_t __arm_vaddq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_f16)))
+float16x8_t __arm_vaddq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_f32)))
+float32x4_t __arm_vaddq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_f32)))
+float32x4_t __arm_vaddq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_f16)))
+float16x8_t __arm_vaddq_x_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_f16)))
+float16x8_t __arm_vaddq_x(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_f32)))
+float32x4_t __arm_vaddq_x_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_f32)))
+float32x4_t __arm_vaddq_x(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_f16)))
+float16x8_t __arm_vandq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_f16)))
+float16x8_t __arm_vandq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_f32)))
+float32x4_t __arm_vandq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_f32)))
+float32x4_t __arm_vandq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_f16)))
+float16x8_t __arm_vandq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_f16)))
+float16x8_t __arm_vandq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_f32)))
+float32x4_t __arm_vandq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_f32)))
+float32x4_t __arm_vandq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_f16)))
+float16x8_t __arm_vandq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_f16)))
+float16x8_t __arm_vandq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_f32)))
+float32x4_t __arm_vandq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_f32)))
+float32x4_t __arm_vandq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_f16)))
+float16x8_t __arm_vbicq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_f16)))
+float16x8_t __arm_vbicq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_f32)))
+float32x4_t __arm_vbicq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_f32)))
+float32x4_t __arm_vbicq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_f16)))
+float16x8_t __arm_vbicq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_f16)))
+float16x8_t __arm_vbicq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_f32)))
+float32x4_t __arm_vbicq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_f32)))
+float32x4_t __arm_vbicq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_f16)))
+float16x8_t __arm_vbicq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_f16)))
+float16x8_t __arm_vbicq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_f32)))
+float32x4_t __arm_vbicq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_f32)))
+float32x4_t __arm_vbicq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_f16)))
+float16x8_t __arm_vbrsrq_m_n_f16(float16x8_t, float16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_f16)))
+float16x8_t __arm_vbrsrq_m(float16x8_t, float16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_f32)))
+float32x4_t __arm_vbrsrq_m_n_f32(float32x4_t, float32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_f32)))
+float32x4_t __arm_vbrsrq_m(float32x4_t, float32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_f16)))
+float16x8_t __arm_vbrsrq_n_f16(float16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_f16)))
+float16x8_t __arm_vbrsrq(float16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_f32)))
+float32x4_t __arm_vbrsrq_n_f32(float32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_f32)))
+float32x4_t __arm_vbrsrq(float32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_f16)))
+float16x8_t __arm_vbrsrq_x_n_f16(float16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_f16)))
+float16x8_t __arm_vbrsrq_x(float16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_f32)))
+float32x4_t __arm_vbrsrq_x_n_f32(float32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_f32)))
+float32x4_t __arm_vbrsrq_x(float32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_f16)))
+float16x8_t __arm_vcaddq_rot270_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_f16)))
+float16x8_t __arm_vcaddq_rot270(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_f32)))
+float32x4_t __arm_vcaddq_rot270_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_f32)))
+float32x4_t __arm_vcaddq_rot270(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_f16)))
+float16x8_t __arm_vcaddq_rot270_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_f16)))
+float16x8_t __arm_vcaddq_rot270_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_f32)))
+float32x4_t __arm_vcaddq_rot270_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_f32)))
+float32x4_t __arm_vcaddq_rot270_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_f16)))
+float16x8_t __arm_vcaddq_rot270_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_f16)))
+float16x8_t __arm_vcaddq_rot270_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_f32)))
+float32x4_t __arm_vcaddq_rot270_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_f32)))
+float32x4_t __arm_vcaddq_rot270_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_f16)))
+float16x8_t __arm_vcaddq_rot90_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_f16)))
+float16x8_t __arm_vcaddq_rot90(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_f32)))
+float32x4_t __arm_vcaddq_rot90_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_f32)))
+float32x4_t __arm_vcaddq_rot90(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_f16)))
+float16x8_t __arm_vcaddq_rot90_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_f16)))
+float16x8_t __arm_vcaddq_rot90_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_f32)))
+float32x4_t __arm_vcaddq_rot90_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_f32)))
+float32x4_t __arm_vcaddq_rot90_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_f16)))
+float16x8_t __arm_vcaddq_rot90_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_f16)))
+float16x8_t __arm_vcaddq_rot90_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_f32)))
+float32x4_t __arm_vcaddq_rot90_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_f32)))
+float32x4_t __arm_vcaddq_rot90_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_f16)))
+float16x8_t __arm_vcmlaq_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_f16)))
+float16x8_t __arm_vcmlaq(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_f32)))
+float32x4_t __arm_vcmlaq_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_f32)))
+float32x4_t __arm_vcmlaq(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_m_f16)))
+float16x8_t __arm_vcmlaq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_m_f16)))
+float16x8_t __arm_vcmlaq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_m_f32)))
+float32x4_t __arm_vcmlaq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_m_f32)))
+float32x4_t __arm_vcmlaq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_f16)))
+float16x8_t __arm_vcmlaq_rot180_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_f16)))
+float16x8_t __arm_vcmlaq_rot180(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_f32)))
+float32x4_t __arm_vcmlaq_rot180_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_f32)))
+float32x4_t __arm_vcmlaq_rot180(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_m_f16)))
+float16x8_t __arm_vcmlaq_rot180_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_m_f16)))
+float16x8_t __arm_vcmlaq_rot180_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_m_f32)))
+float32x4_t __arm_vcmlaq_rot180_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_m_f32)))
+float32x4_t __arm_vcmlaq_rot180_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_f16)))
+float16x8_t __arm_vcmlaq_rot270_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_f16)))
+float16x8_t __arm_vcmlaq_rot270(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_f32)))
+float32x4_t __arm_vcmlaq_rot270_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_f32)))
+float32x4_t __arm_vcmlaq_rot270(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_m_f16)))
+float16x8_t __arm_vcmlaq_rot270_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_m_f16)))
+float16x8_t __arm_vcmlaq_rot270_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_m_f32)))
+float32x4_t __arm_vcmlaq_rot270_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_m_f32)))
+float32x4_t __arm_vcmlaq_rot270_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_f16)))
+float16x8_t __arm_vcmlaq_rot90_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_f16)))
+float16x8_t __arm_vcmlaq_rot90(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_f32)))
+float32x4_t __arm_vcmlaq_rot90_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_f32)))
+float32x4_t __arm_vcmlaq_rot90(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_m_f16)))
+float16x8_t __arm_vcmlaq_rot90_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_m_f16)))
+float16x8_t __arm_vcmlaq_rot90_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_m_f32)))
+float32x4_t __arm_vcmlaq_rot90_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_m_f32)))
+float32x4_t __arm_vcmlaq_rot90_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_f16)))
+mve_pred16_t __arm_vcmpeqq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_f16)))
+mve_pred16_t __arm_vcmpeqq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_f32)))
+mve_pred16_t __arm_vcmpeqq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_f32)))
+mve_pred16_t __arm_vcmpeqq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_f16)))
+mve_pred16_t __arm_vcmpeqq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_f16)))
+mve_pred16_t __arm_vcmpeqq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_f32)))
+mve_pred16_t __arm_vcmpeqq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_f32)))
+mve_pred16_t __arm_vcmpeqq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_f16)))
+mve_pred16_t __arm_vcmpeqq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_f16)))
+mve_pred16_t __arm_vcmpeqq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_f32)))
+mve_pred16_t __arm_vcmpeqq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_f32)))
+mve_pred16_t __arm_vcmpeqq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_f16)))
+mve_pred16_t __arm_vcmpeqq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_f16)))
+mve_pred16_t __arm_vcmpeqq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_f32)))
+mve_pred16_t __arm_vcmpeqq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_f32)))
+mve_pred16_t __arm_vcmpeqq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_f16)))
+mve_pred16_t __arm_vcmpgeq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_f16)))
+mve_pred16_t __arm_vcmpgeq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_f32)))
+mve_pred16_t __arm_vcmpgeq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_f32)))
+mve_pred16_t __arm_vcmpgeq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_f16)))
+mve_pred16_t __arm_vcmpgeq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_f16)))
+mve_pred16_t __arm_vcmpgeq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_f32)))
+mve_pred16_t __arm_vcmpgeq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_f32)))
+mve_pred16_t __arm_vcmpgeq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_f16)))
+mve_pred16_t __arm_vcmpgeq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_f16)))
+mve_pred16_t __arm_vcmpgeq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_f32)))
+mve_pred16_t __arm_vcmpgeq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_f32)))
+mve_pred16_t __arm_vcmpgeq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_f16)))
+mve_pred16_t __arm_vcmpgeq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_f16)))
+mve_pred16_t __arm_vcmpgeq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_f32)))
+mve_pred16_t __arm_vcmpgeq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_f32)))
+mve_pred16_t __arm_vcmpgeq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_f16)))
+mve_pred16_t __arm_vcmpgtq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_f16)))
+mve_pred16_t __arm_vcmpgtq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_f32)))
+mve_pred16_t __arm_vcmpgtq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_f32)))
+mve_pred16_t __arm_vcmpgtq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_f16)))
+mve_pred16_t __arm_vcmpgtq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_f16)))
+mve_pred16_t __arm_vcmpgtq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_f32)))
+mve_pred16_t __arm_vcmpgtq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_f32)))
+mve_pred16_t __arm_vcmpgtq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_f16)))
+mve_pred16_t __arm_vcmpgtq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_f16)))
+mve_pred16_t __arm_vcmpgtq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_f32)))
+mve_pred16_t __arm_vcmpgtq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_f32)))
+mve_pred16_t __arm_vcmpgtq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_f16)))
+mve_pred16_t __arm_vcmpgtq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_f16)))
+mve_pred16_t __arm_vcmpgtq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_f32)))
+mve_pred16_t __arm_vcmpgtq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_f32)))
+mve_pred16_t __arm_vcmpgtq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_f16)))
+mve_pred16_t __arm_vcmpleq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_f16)))
+mve_pred16_t __arm_vcmpleq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_f32)))
+mve_pred16_t __arm_vcmpleq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_f32)))
+mve_pred16_t __arm_vcmpleq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_f16)))
+mve_pred16_t __arm_vcmpleq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_f16)))
+mve_pred16_t __arm_vcmpleq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_f32)))
+mve_pred16_t __arm_vcmpleq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_f32)))
+mve_pred16_t __arm_vcmpleq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_f16)))
+mve_pred16_t __arm_vcmpleq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_f16)))
+mve_pred16_t __arm_vcmpleq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_f32)))
+mve_pred16_t __arm_vcmpleq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_f32)))
+mve_pred16_t __arm_vcmpleq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_f16)))
+mve_pred16_t __arm_vcmpleq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_f16)))
+mve_pred16_t __arm_vcmpleq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_f32)))
+mve_pred16_t __arm_vcmpleq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_f32)))
+mve_pred16_t __arm_vcmpleq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_f16)))
+mve_pred16_t __arm_vcmpltq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_f16)))
+mve_pred16_t __arm_vcmpltq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_f32)))
+mve_pred16_t __arm_vcmpltq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_f32)))
+mve_pred16_t __arm_vcmpltq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_f16)))
+mve_pred16_t __arm_vcmpltq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_f16)))
+mve_pred16_t __arm_vcmpltq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_f32)))
+mve_pred16_t __arm_vcmpltq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_f32)))
+mve_pred16_t __arm_vcmpltq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_f16)))
+mve_pred16_t __arm_vcmpltq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_f16)))
+mve_pred16_t __arm_vcmpltq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_f32)))
+mve_pred16_t __arm_vcmpltq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_f32)))
+mve_pred16_t __arm_vcmpltq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_f16)))
+mve_pred16_t __arm_vcmpltq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_f16)))
+mve_pred16_t __arm_vcmpltq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_f32)))
+mve_pred16_t __arm_vcmpltq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_f32)))
+mve_pred16_t __arm_vcmpltq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_f16)))
+mve_pred16_t __arm_vcmpneq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_f16)))
+mve_pred16_t __arm_vcmpneq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_f32)))
+mve_pred16_t __arm_vcmpneq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_f32)))
+mve_pred16_t __arm_vcmpneq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_f16)))
+mve_pred16_t __arm_vcmpneq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_f16)))
+mve_pred16_t __arm_vcmpneq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_f32)))
+mve_pred16_t __arm_vcmpneq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_f32)))
+mve_pred16_t __arm_vcmpneq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_f16)))
+mve_pred16_t __arm_vcmpneq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_f16)))
+mve_pred16_t __arm_vcmpneq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_f32)))
+mve_pred16_t __arm_vcmpneq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_f32)))
+mve_pred16_t __arm_vcmpneq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_f16)))
+mve_pred16_t __arm_vcmpneq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_f16)))
+mve_pred16_t __arm_vcmpneq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_f32)))
+mve_pred16_t __arm_vcmpneq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_f32)))
+mve_pred16_t __arm_vcmpneq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_f16)))
+float16x8_t __arm_vcmulq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_f16)))
+float16x8_t __arm_vcmulq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_f32)))
+float32x4_t __arm_vcmulq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_f32)))
+float32x4_t __arm_vcmulq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_m_f16)))
+float16x8_t __arm_vcmulq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_m_f16)))
+float16x8_t __arm_vcmulq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_m_f32)))
+float32x4_t __arm_vcmulq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_m_f32)))
+float32x4_t __arm_vcmulq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_f16)))
+float16x8_t __arm_vcmulq_rot180_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_f16)))
+float16x8_t __arm_vcmulq_rot180(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_f32)))
+float32x4_t __arm_vcmulq_rot180_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_f32)))
+float32x4_t __arm_vcmulq_rot180(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_m_f16)))
+float16x8_t __arm_vcmulq_rot180_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_m_f16)))
+float16x8_t __arm_vcmulq_rot180_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_m_f32)))
+float32x4_t __arm_vcmulq_rot180_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_m_f32)))
+float32x4_t __arm_vcmulq_rot180_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_x_f16)))
+float16x8_t __arm_vcmulq_rot180_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_x_f16)))
+float16x8_t __arm_vcmulq_rot180_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_x_f32)))
+float32x4_t __arm_vcmulq_rot180_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_x_f32)))
+float32x4_t __arm_vcmulq_rot180_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_f16)))
+float16x8_t __arm_vcmulq_rot270_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_f16)))
+float16x8_t __arm_vcmulq_rot270(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_f32)))
+float32x4_t __arm_vcmulq_rot270_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_f32)))
+float32x4_t __arm_vcmulq_rot270(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_m_f16)))
+float16x8_t __arm_vcmulq_rot270_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_m_f16)))
+float16x8_t __arm_vcmulq_rot270_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_m_f32)))
+float32x4_t __arm_vcmulq_rot270_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_m_f32)))
+float32x4_t __arm_vcmulq_rot270_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_x_f16)))
+float16x8_t __arm_vcmulq_rot270_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_x_f16)))
+float16x8_t __arm_vcmulq_rot270_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_x_f32)))
+float32x4_t __arm_vcmulq_rot270_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_x_f32)))
+float32x4_t __arm_vcmulq_rot270_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_f16)))
+float16x8_t __arm_vcmulq_rot90_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_f16)))
+float16x8_t __arm_vcmulq_rot90(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_f32)))
+float32x4_t __arm_vcmulq_rot90_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_f32)))
+float32x4_t __arm_vcmulq_rot90(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_m_f16)))
+float16x8_t __arm_vcmulq_rot90_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_m_f16)))
+float16x8_t __arm_vcmulq_rot90_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_m_f32)))
+float32x4_t __arm_vcmulq_rot90_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_m_f32)))
+float32x4_t __arm_vcmulq_rot90_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_x_f16)))
+float16x8_t __arm_vcmulq_rot90_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_x_f16)))
+float16x8_t __arm_vcmulq_rot90_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_x_f32)))
+float32x4_t __arm_vcmulq_rot90_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_x_f32)))
+float32x4_t __arm_vcmulq_rot90_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_x_f16)))
+float16x8_t __arm_vcmulq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_x_f16)))
+float16x8_t __arm_vcmulq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_x_f32)))
+float32x4_t __arm_vcmulq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_x_f32)))
+float32x4_t __arm_vcmulq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_f16)))
+float16x8_t __arm_vcreateq_f16(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_f32)))
+float32x4_t __arm_vcreateq_f32(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_s16_f16)))
+int16x8_t __arm_vcvtaq_m_s16_f16(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_s16_f16)))
+int16x8_t __arm_vcvtaq_m(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_s32_f32)))
+int32x4_t __arm_vcvtaq_m_s32_f32(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_s32_f32)))
+int32x4_t __arm_vcvtaq_m(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_u16_f16)))
+uint16x8_t __arm_vcvtaq_m_u16_f16(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_u16_f16)))
+uint16x8_t __arm_vcvtaq_m(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_u32_f32)))
+uint32x4_t __arm_vcvtaq_m_u32_f32(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_u32_f32)))
+uint32x4_t __arm_vcvtaq_m(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_s16_f16)))
+int16x8_t __arm_vcvtaq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_s32_f32)))
+int32x4_t __arm_vcvtaq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_u16_f16)))
+uint16x8_t __arm_vcvtaq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_u32_f32)))
+uint32x4_t __arm_vcvtaq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_x_s16_f16)))
+int16x8_t __arm_vcvtaq_x_s16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_x_s32_f32)))
+int32x4_t __arm_vcvtaq_x_s32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_x_u16_f16)))
+uint16x8_t __arm_vcvtaq_x_u16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_x_u32_f32)))
+uint32x4_t __arm_vcvtaq_x_u32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtbq_f16_f32)))
+float16x8_t __arm_vcvtbq_f16_f32(float16x8_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtbq_f32_f16)))
+float32x4_t __arm_vcvtbq_f32_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtbq_m_f16_f32)))
+float16x8_t __arm_vcvtbq_m_f16_f32(float16x8_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtbq_m_f32_f16)))
+float32x4_t __arm_vcvtbq_m_f32_f16(float32x4_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtbq_x_f32_f16)))
+float32x4_t __arm_vcvtbq_x_f32_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_s16_f16)))
+int16x8_t __arm_vcvtmq_m_s16_f16(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_s16_f16)))
+int16x8_t __arm_vcvtmq_m(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_s32_f32)))
+int32x4_t __arm_vcvtmq_m_s32_f32(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_s32_f32)))
+int32x4_t __arm_vcvtmq_m(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_u16_f16)))
+uint16x8_t __arm_vcvtmq_m_u16_f16(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_u16_f16)))
+uint16x8_t __arm_vcvtmq_m(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_u32_f32)))
+uint32x4_t __arm_vcvtmq_m_u32_f32(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_u32_f32)))
+uint32x4_t __arm_vcvtmq_m(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_s16_f16)))
+int16x8_t __arm_vcvtmq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_s32_f32)))
+int32x4_t __arm_vcvtmq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_u16_f16)))
+uint16x8_t __arm_vcvtmq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_u32_f32)))
+uint32x4_t __arm_vcvtmq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_x_s16_f16)))
+int16x8_t __arm_vcvtmq_x_s16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_x_s32_f32)))
+int32x4_t __arm_vcvtmq_x_s32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_x_u16_f16)))
+uint16x8_t __arm_vcvtmq_x_u16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_x_u32_f32)))
+uint32x4_t __arm_vcvtmq_x_u32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_s16_f16)))
+int16x8_t __arm_vcvtnq_m_s16_f16(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_s16_f16)))
+int16x8_t __arm_vcvtnq_m(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_s32_f32)))
+int32x4_t __arm_vcvtnq_m_s32_f32(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_s32_f32)))
+int32x4_t __arm_vcvtnq_m(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_u16_f16)))
+uint16x8_t __arm_vcvtnq_m_u16_f16(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_u16_f16)))
+uint16x8_t __arm_vcvtnq_m(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_u32_f32)))
+uint32x4_t __arm_vcvtnq_m_u32_f32(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_u32_f32)))
+uint32x4_t __arm_vcvtnq_m(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_s16_f16)))
+int16x8_t __arm_vcvtnq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_s32_f32)))
+int32x4_t __arm_vcvtnq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_u16_f16)))
+uint16x8_t __arm_vcvtnq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_u32_f32)))
+uint32x4_t __arm_vcvtnq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_x_s16_f16)))
+int16x8_t __arm_vcvtnq_x_s16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_x_s32_f32)))
+int32x4_t __arm_vcvtnq_x_s32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_x_u16_f16)))
+uint16x8_t __arm_vcvtnq_x_u16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_x_u32_f32)))
+uint32x4_t __arm_vcvtnq_x_u32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_s16_f16)))
+int16x8_t __arm_vcvtpq_m_s16_f16(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_s16_f16)))
+int16x8_t __arm_vcvtpq_m(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_s32_f32)))
+int32x4_t __arm_vcvtpq_m_s32_f32(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_s32_f32)))
+int32x4_t __arm_vcvtpq_m(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_u16_f16)))
+uint16x8_t __arm_vcvtpq_m_u16_f16(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_u16_f16)))
+uint16x8_t __arm_vcvtpq_m(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_u32_f32)))
+uint32x4_t __arm_vcvtpq_m_u32_f32(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_u32_f32)))
+uint32x4_t __arm_vcvtpq_m(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_s16_f16)))
+int16x8_t __arm_vcvtpq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_s32_f32)))
+int32x4_t __arm_vcvtpq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_u16_f16)))
+uint16x8_t __arm_vcvtpq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_u32_f32)))
+uint32x4_t __arm_vcvtpq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_x_s16_f16)))
+int16x8_t __arm_vcvtpq_x_s16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_x_s32_f32)))
+int32x4_t __arm_vcvtpq_x_s32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_x_u16_f16)))
+uint16x8_t __arm_vcvtpq_x_u16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_x_u32_f32)))
+uint32x4_t __arm_vcvtpq_x_u32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f16_s16)))
+float16x8_t __arm_vcvtq_f16_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f16_s16)))
+float16x8_t __arm_vcvtq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f16_u16)))
+float16x8_t __arm_vcvtq_f16_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f16_u16)))
+float16x8_t __arm_vcvtq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f32_s32)))
+float32x4_t __arm_vcvtq_f32_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f32_s32)))
+float32x4_t __arm_vcvtq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f32_u32)))
+float32x4_t __arm_vcvtq_f32_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f32_u32)))
+float32x4_t __arm_vcvtq(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f16_s16)))
+float16x8_t __arm_vcvtq_m_f16_s16(float16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f16_s16)))
+float16x8_t __arm_vcvtq_m(float16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f16_u16)))
+float16x8_t __arm_vcvtq_m_f16_u16(float16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f16_u16)))
+float16x8_t __arm_vcvtq_m(float16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f32_s32)))
+float32x4_t __arm_vcvtq_m_f32_s32(float32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f32_s32)))
+float32x4_t __arm_vcvtq_m(float32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f32_u32)))
+float32x4_t __arm_vcvtq_m_f32_u32(float32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f32_u32)))
+float32x4_t __arm_vcvtq_m(float32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f16_s16)))
+float16x8_t __arm_vcvtq_m_n_f16_s16(float16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f16_s16)))
+float16x8_t __arm_vcvtq_m_n(float16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f16_u16)))
+float16x8_t __arm_vcvtq_m_n_f16_u16(float16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f16_u16)))
+float16x8_t __arm_vcvtq_m_n(float16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f32_s32)))
+float32x4_t __arm_vcvtq_m_n_f32_s32(float32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f32_s32)))
+float32x4_t __arm_vcvtq_m_n(float32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f32_u32)))
+float32x4_t __arm_vcvtq_m_n_f32_u32(float32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f32_u32)))
+float32x4_t __arm_vcvtq_m_n(float32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_s16_f16)))
+int16x8_t __arm_vcvtq_m_n_s16_f16(int16x8_t, float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_s16_f16)))
+int16x8_t __arm_vcvtq_m_n(int16x8_t, float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_s32_f32)))
+int32x4_t __arm_vcvtq_m_n_s32_f32(int32x4_t, float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_s32_f32)))
+int32x4_t __arm_vcvtq_m_n(int32x4_t, float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_u16_f16)))
+uint16x8_t __arm_vcvtq_m_n_u16_f16(uint16x8_t, float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_u16_f16)))
+uint16x8_t __arm_vcvtq_m_n(uint16x8_t, float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_u32_f32)))
+uint32x4_t __arm_vcvtq_m_n_u32_f32(uint32x4_t, float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_u32_f32)))
+uint32x4_t __arm_vcvtq_m_n(uint32x4_t, float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_s16_f16)))
+int16x8_t __arm_vcvtq_m_s16_f16(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_s16_f16)))
+int16x8_t __arm_vcvtq_m(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_s32_f32)))
+int32x4_t __arm_vcvtq_m_s32_f32(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_s32_f32)))
+int32x4_t __arm_vcvtq_m(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_u16_f16)))
+uint16x8_t __arm_vcvtq_m_u16_f16(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_u16_f16)))
+uint16x8_t __arm_vcvtq_m(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_u32_f32)))
+uint32x4_t __arm_vcvtq_m_u32_f32(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_u32_f32)))
+uint32x4_t __arm_vcvtq_m(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f16_s16)))
+float16x8_t __arm_vcvtq_n_f16_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f16_s16)))
+float16x8_t __arm_vcvtq_n(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f16_u16)))
+float16x8_t __arm_vcvtq_n_f16_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f16_u16)))
+float16x8_t __arm_vcvtq_n(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f32_s32)))
+float32x4_t __arm_vcvtq_n_f32_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f32_s32)))
+float32x4_t __arm_vcvtq_n(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f32_u32)))
+float32x4_t __arm_vcvtq_n_f32_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f32_u32)))
+float32x4_t __arm_vcvtq_n(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_s16_f16)))
+int16x8_t __arm_vcvtq_n_s16_f16(float16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_s32_f32)))
+int32x4_t __arm_vcvtq_n_s32_f32(float32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_u16_f16)))
+uint16x8_t __arm_vcvtq_n_u16_f16(float16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_u32_f32)))
+uint32x4_t __arm_vcvtq_n_u32_f32(float32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_s16_f16)))
+int16x8_t __arm_vcvtq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_s32_f32)))
+int32x4_t __arm_vcvtq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_u16_f16)))
+uint16x8_t __arm_vcvtq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_u32_f32)))
+uint32x4_t __arm_vcvtq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f16_s16)))
+float16x8_t __arm_vcvtq_x_f16_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f16_s16)))
+float16x8_t __arm_vcvtq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f16_u16)))
+float16x8_t __arm_vcvtq_x_f16_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f16_u16)))
+float16x8_t __arm_vcvtq_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f32_s32)))
+float32x4_t __arm_vcvtq_x_f32_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f32_s32)))
+float32x4_t __arm_vcvtq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f32_u32)))
+float32x4_t __arm_vcvtq_x_f32_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f32_u32)))
+float32x4_t __arm_vcvtq_x(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f16_s16)))
+float16x8_t __arm_vcvtq_x_n_f16_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f16_s16)))
+float16x8_t __arm_vcvtq_x_n(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f16_u16)))
+float16x8_t __arm_vcvtq_x_n_f16_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f16_u16)))
+float16x8_t __arm_vcvtq_x_n(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f32_s32)))
+float32x4_t __arm_vcvtq_x_n_f32_s32(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f32_s32)))
+float32x4_t __arm_vcvtq_x_n(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f32_u32)))
+float32x4_t __arm_vcvtq_x_n_f32_u32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f32_u32)))
+float32x4_t __arm_vcvtq_x_n(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_s16_f16)))
+int16x8_t __arm_vcvtq_x_n_s16_f16(float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_s32_f32)))
+int32x4_t __arm_vcvtq_x_n_s32_f32(float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_u16_f16)))
+uint16x8_t __arm_vcvtq_x_n_u16_f16(float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_u32_f32)))
+uint32x4_t __arm_vcvtq_x_n_u32_f32(float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_s16_f16)))
+int16x8_t __arm_vcvtq_x_s16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_s32_f32)))
+int32x4_t __arm_vcvtq_x_s32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_u16_f16)))
+uint16x8_t __arm_vcvtq_x_u16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_u32_f32)))
+uint32x4_t __arm_vcvtq_x_u32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvttq_f16_f32)))
+float16x8_t __arm_vcvttq_f16_f32(float16x8_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvttq_f32_f16)))
+float32x4_t __arm_vcvttq_f32_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvttq_m_f16_f32)))
+float16x8_t __arm_vcvttq_m_f16_f32(float16x8_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvttq_m_f32_f16)))
+float32x4_t __arm_vcvttq_m_f32_f16(float32x4_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvttq_x_f32_f16)))
+float32x4_t __arm_vcvttq_x_f32_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_f16)))
+float16x8_t __arm_vdupq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_f16)))
+float16x8_t __arm_vdupq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_f32)))
+float32x4_t __arm_vdupq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_f32)))
+float32x4_t __arm_vdupq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_f16)))
+float16x8_t __arm_vdupq_n_f16(float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_f32)))
+float32x4_t __arm_vdupq_n_f32(float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_f16)))
+float16x8_t __arm_vdupq_x_n_f16(float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_f32)))
+float32x4_t __arm_vdupq_x_n_f32(float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_f16)))
+float16x8_t __arm_veorq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_f16)))
+float16x8_t __arm_veorq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_f32)))
+float32x4_t __arm_veorq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_f32)))
+float32x4_t __arm_veorq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_f16)))
+float16x8_t __arm_veorq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_f16)))
+float16x8_t __arm_veorq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_f32)))
+float32x4_t __arm_veorq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_f32)))
+float32x4_t __arm_veorq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_f16)))
+float16x8_t __arm_veorq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_f16)))
+float16x8_t __arm_veorq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_f32)))
+float32x4_t __arm_veorq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_f32)))
+float32x4_t __arm_veorq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_f16)))
+float16x8_t __arm_vfmaq_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_f16)))
+float16x8_t __arm_vfmaq(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_f32)))
+float32x4_t __arm_vfmaq_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_f32)))
+float32x4_t __arm_vfmaq(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_f16)))
+float16x8_t __arm_vfmaq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_f16)))
+float16x8_t __arm_vfmaq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_f32)))
+float32x4_t __arm_vfmaq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_f32)))
+float32x4_t __arm_vfmaq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_n_f16)))
+float16x8_t __arm_vfmaq_m_n_f16(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_n_f16)))
+float16x8_t __arm_vfmaq_m(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_n_f32)))
+float32x4_t __arm_vfmaq_m_n_f32(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_n_f32)))
+float32x4_t __arm_vfmaq_m(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_n_f16)))
+float16x8_t __arm_vfmaq_n_f16(float16x8_t, float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_n_f16)))
+float16x8_t __arm_vfmaq(float16x8_t, float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_n_f32)))
+float32x4_t __arm_vfmaq_n_f32(float32x4_t, float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_n_f32)))
+float32x4_t __arm_vfmaq(float32x4_t, float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_m_n_f16)))
+float16x8_t __arm_vfmasq_m_n_f16(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_m_n_f16)))
+float16x8_t __arm_vfmasq_m(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_m_n_f32)))
+float32x4_t __arm_vfmasq_m_n_f32(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_m_n_f32)))
+float32x4_t __arm_vfmasq_m(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_n_f16)))
+float16x8_t __arm_vfmasq_n_f16(float16x8_t, float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_n_f16)))
+float16x8_t __arm_vfmasq(float16x8_t, float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_n_f32)))
+float32x4_t __arm_vfmasq_n_f32(float32x4_t, float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_n_f32)))
+float32x4_t __arm_vfmasq(float32x4_t, float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_f16)))
+float16x8_t __arm_vfmsq_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_f16)))
+float16x8_t __arm_vfmsq(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_f32)))
+float32x4_t __arm_vfmsq_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_f32)))
+float32x4_t __arm_vfmsq(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_m_f16)))
+float16x8_t __arm_vfmsq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_m_f16)))
+float16x8_t __arm_vfmsq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_m_f32)))
+float32x4_t __arm_vfmsq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_m_f32)))
+float32x4_t __arm_vfmsq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_f16)))
+float16_t __arm_vgetq_lane_f16(float16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_f16)))
+float16_t __arm_vgetq_lane(float16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_f32)))
+float32_t __arm_vgetq_lane_f32(float32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_f32)))
+float32_t __arm_vgetq_lane(float32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_f16)))
+float16x8_t __arm_vld1q_f16(const float16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_f16)))
+float16x8_t __arm_vld1q(const float16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_f32)))
+float32x4_t __arm_vld1q_f32(const float32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_f32)))
+float32x4_t __arm_vld1q(const float32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_f16)))
+float16x8_t __arm_vld1q_z_f16(const float16_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_f16)))
+float16x8_t __arm_vld1q_z(const float16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_f32)))
+float32x4_t __arm_vld1q_z_f32(const float32_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_f32)))
+float32x4_t __arm_vld1q_z(const float32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_f16)))
+float16x8x2_t __arm_vld2q_f16(const float16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_f16)))
+float16x8x2_t __arm_vld2q(const float16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_f32)))
+float32x4x2_t __arm_vld2q_f32(const float32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_f32)))
+float32x4x2_t __arm_vld2q(const float32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_f16)))
+float16x8x4_t __arm_vld4q_f16(const float16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_f16)))
+float16x8x4_t __arm_vld4q(const float16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_f32)))
+float32x4x4_t __arm_vld4q_f32(const float32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_f32)))
+float32x4x4_t __arm_vld4q(const float32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_f16)))
+float16x8_t __arm_vldrhq_f16(const float16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_f16)))
+float16x8_t __arm_vldrhq_gather_offset_f16(const float16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_f16)))
+float16x8_t __arm_vldrhq_gather_offset(const float16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_f16)))
+float16x8_t __arm_vldrhq_gather_offset_z_f16(const float16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_f16)))
+float16x8_t __arm_vldrhq_gather_offset_z(const float16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_f16)))
+float16x8_t __arm_vldrhq_gather_shifted_offset_f16(const float16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_f16)))
+float16x8_t __arm_vldrhq_gather_shifted_offset(const float16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_f16)))
+float16x8_t __arm_vldrhq_gather_shifted_offset_z_f16(const float16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_f16)))
+float16x8_t __arm_vldrhq_gather_shifted_offset_z(const float16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_z_f16)))
+float16x8_t __arm_vldrhq_z_f16(const float16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_f32)))
+float32x4_t __arm_vldrwq_f32(const float32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_f32)))
+float32x4_t __arm_vldrwq_gather_base_f32(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_f32)))
+float32x4_t __arm_vldrwq_gather_base_wb_f32(uint32x4_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_z_f32)))
+float32x4_t __arm_vldrwq_gather_base_wb_z_f32(uint32x4_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_z_f32)))
+float32x4_t __arm_vldrwq_gather_base_z_f32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_f32)))
+float32x4_t __arm_vldrwq_gather_offset_f32(const float32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_f32)))
+float32x4_t __arm_vldrwq_gather_offset(const float32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_f32)))
+float32x4_t __arm_vldrwq_gather_offset_z_f32(const float32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_f32)))
+float32x4_t __arm_vldrwq_gather_offset_z(const float32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_f32)))
+float32x4_t __arm_vldrwq_gather_shifted_offset_f32(const float32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_f32)))
+float32x4_t __arm_vldrwq_gather_shifted_offset(const float32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_f32)))
+float32x4_t __arm_vldrwq_gather_shifted_offset_z_f32(const float32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_f32)))
+float32x4_t __arm_vldrwq_gather_shifted_offset_z(const float32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_z_f32)))
+float32x4_t __arm_vldrwq_z_f32(const float32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_f16)))
+float16x8_t __arm_vmaxnmaq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_f16)))
+float16x8_t __arm_vmaxnmaq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_f32)))
+float32x4_t __arm_vmaxnmaq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_f32)))
+float32x4_t __arm_vmaxnmaq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_m_f16)))
+float16x8_t __arm_vmaxnmaq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_m_f16)))
+float16x8_t __arm_vmaxnmaq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_m_f32)))
+float32x4_t __arm_vmaxnmaq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_m_f32)))
+float32x4_t __arm_vmaxnmaq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_f16)))
+float16_t __arm_vmaxnmavq_f16(float16_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_f16)))
+float16_t __arm_vmaxnmavq(float16_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_f32)))
+float32_t __arm_vmaxnmavq_f32(float32_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_f32)))
+float32_t __arm_vmaxnmavq(float32_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_p_f16)))
+float16_t __arm_vmaxnmavq_p_f16(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_p_f16)))
+float16_t __arm_vmaxnmavq_p(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_p_f32)))
+float32_t __arm_vmaxnmavq_p_f32(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_p_f32)))
+float32_t __arm_vmaxnmavq_p(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_f16)))
+float16x8_t __arm_vmaxnmq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_f16)))
+float16x8_t __arm_vmaxnmq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_f32)))
+float32x4_t __arm_vmaxnmq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_f32)))
+float32x4_t __arm_vmaxnmq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_m_f16)))
+float16x8_t __arm_vmaxnmq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_m_f16)))
+float16x8_t __arm_vmaxnmq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_m_f32)))
+float32x4_t __arm_vmaxnmq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_m_f32)))
+float32x4_t __arm_vmaxnmq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_x_f16)))
+float16x8_t __arm_vmaxnmq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_x_f16)))
+float16x8_t __arm_vmaxnmq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_x_f32)))
+float32x4_t __arm_vmaxnmq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_x_f32)))
+float32x4_t __arm_vmaxnmq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_f16)))
+float16_t __arm_vmaxnmvq_f16(float16_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_f16)))
+float16_t __arm_vmaxnmvq(float16_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_f32)))
+float32_t __arm_vmaxnmvq_f32(float32_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_f32)))
+float32_t __arm_vmaxnmvq(float32_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_p_f16)))
+float16_t __arm_vmaxnmvq_p_f16(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_p_f16)))
+float16_t __arm_vmaxnmvq_p(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_p_f32)))
+float32_t __arm_vmaxnmvq_p_f32(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_p_f32)))
+float32_t __arm_vmaxnmvq_p(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_f16)))
+float16x8_t __arm_vminnmaq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_f16)))
+float16x8_t __arm_vminnmaq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_f32)))
+float32x4_t __arm_vminnmaq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_f32)))
+float32x4_t __arm_vminnmaq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_m_f16)))
+float16x8_t __arm_vminnmaq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_m_f16)))
+float16x8_t __arm_vminnmaq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_m_f32)))
+float32x4_t __arm_vminnmaq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_m_f32)))
+float32x4_t __arm_vminnmaq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_f16)))
+float16_t __arm_vminnmavq_f16(float16_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_f16)))
+float16_t __arm_vminnmavq(float16_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_f32)))
+float32_t __arm_vminnmavq_f32(float32_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_f32)))
+float32_t __arm_vminnmavq(float32_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_p_f16)))
+float16_t __arm_vminnmavq_p_f16(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_p_f16)))
+float16_t __arm_vminnmavq_p(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_p_f32)))
+float32_t __arm_vminnmavq_p_f32(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_p_f32)))
+float32_t __arm_vminnmavq_p(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_f16)))
+float16x8_t __arm_vminnmq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_f16)))
+float16x8_t __arm_vminnmq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_f32)))
+float32x4_t __arm_vminnmq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_f32)))
+float32x4_t __arm_vminnmq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_m_f16)))
+float16x8_t __arm_vminnmq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_m_f16)))
+float16x8_t __arm_vminnmq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_m_f32)))
+float32x4_t __arm_vminnmq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_m_f32)))
+float32x4_t __arm_vminnmq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_x_f16)))
+float16x8_t __arm_vminnmq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_x_f16)))
+float16x8_t __arm_vminnmq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_x_f32)))
+float32x4_t __arm_vminnmq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_x_f32)))
+float32x4_t __arm_vminnmq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_f16)))
+float16_t __arm_vminnmvq_f16(float16_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_f16)))
+float16_t __arm_vminnmvq(float16_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_f32)))
+float32_t __arm_vminnmvq_f32(float32_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_f32)))
+float32_t __arm_vminnmvq(float32_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_p_f16)))
+float16_t __arm_vminnmvq_p_f16(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_p_f16)))
+float16_t __arm_vminnmvq_p(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_p_f32)))
+float32_t __arm_vminnmvq_p_f32(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_p_f32)))
+float32_t __arm_vminnmvq_p(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_f16)))
+float16x8_t __arm_vmulq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_f16)))
+float16x8_t __arm_vmulq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_f32)))
+float32x4_t __arm_vmulq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_f32)))
+float32x4_t __arm_vmulq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_f16)))
+float16x8_t __arm_vmulq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_f16)))
+float16x8_t __arm_vmulq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_f32)))
+float32x4_t __arm_vmulq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_f32)))
+float32x4_t __arm_vmulq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_f16)))
+float16x8_t __arm_vmulq_m_n_f16(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_f16)))
+float16x8_t __arm_vmulq_m(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_f32)))
+float32x4_t __arm_vmulq_m_n_f32(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_f32)))
+float32x4_t __arm_vmulq_m(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_f16)))
+float16x8_t __arm_vmulq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_f16)))
+float16x8_t __arm_vmulq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_f32)))
+float32x4_t __arm_vmulq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_f32)))
+float32x4_t __arm_vmulq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_f16)))
+float16x8_t __arm_vmulq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_f16)))
+float16x8_t __arm_vmulq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_f32)))
+float32x4_t __arm_vmulq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_f32)))
+float32x4_t __arm_vmulq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_f16)))
+float16x8_t __arm_vmulq_x_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_f16)))
+float16x8_t __arm_vmulq_x(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_f32)))
+float32x4_t __arm_vmulq_x_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_f32)))
+float32x4_t __arm_vmulq_x(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_f16)))
+float16x8_t __arm_vnegq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_f16)))
+float16x8_t __arm_vnegq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_f32)))
+float32x4_t __arm_vnegq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_f32)))
+float32x4_t __arm_vnegq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_f16)))
+float16x8_t __arm_vnegq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_f16)))
+float16x8_t __arm_vnegq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_f32)))
+float32x4_t __arm_vnegq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_f32)))
+float32x4_t __arm_vnegq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_f16)))
+float16x8_t __arm_vnegq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_f16)))
+float16x8_t __arm_vnegq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_f32)))
+float32x4_t __arm_vnegq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_f32)))
+float32x4_t __arm_vnegq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_f16)))
+float16x8_t __arm_vornq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_f16)))
+float16x8_t __arm_vornq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_f32)))
+float32x4_t __arm_vornq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_f32)))
+float32x4_t __arm_vornq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_f16)))
+float16x8_t __arm_vornq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_f16)))
+float16x8_t __arm_vornq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_f32)))
+float32x4_t __arm_vornq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_f32)))
+float32x4_t __arm_vornq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_f16)))
+float16x8_t __arm_vornq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_f16)))
+float16x8_t __arm_vornq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_f32)))
+float32x4_t __arm_vornq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_f32)))
+float32x4_t __arm_vornq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_f16)))
+float16x8_t __arm_vorrq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_f16)))
+float16x8_t __arm_vorrq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_f32)))
+float32x4_t __arm_vorrq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_f32)))
+float32x4_t __arm_vorrq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_f16)))
+float16x8_t __arm_vorrq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_f16)))
+float16x8_t __arm_vorrq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_f32)))
+float32x4_t __arm_vorrq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_f32)))
+float32x4_t __arm_vorrq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_f16)))
+float16x8_t __arm_vorrq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_f16)))
+float16x8_t __arm_vorrq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_f32)))
+float32x4_t __arm_vorrq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_f32)))
+float32x4_t __arm_vorrq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_f16)))
+float16x8_t __arm_vpselq_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_f16)))
+float16x8_t __arm_vpselq(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_f32)))
+float32x4_t __arm_vpselq_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_f32)))
+float32x4_t __arm_vpselq(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_f32)))
+float16x8_t __arm_vreinterpretq_f16_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_f32)))
+float16x8_t __arm_vreinterpretq_f16(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s16)))
+float16x8_t __arm_vreinterpretq_f16_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s16)))
+float16x8_t __arm_vreinterpretq_f16(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s32)))
+float16x8_t __arm_vreinterpretq_f16_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s32)))
+float16x8_t __arm_vreinterpretq_f16(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s64)))
+float16x8_t __arm_vreinterpretq_f16_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s64)))
+float16x8_t __arm_vreinterpretq_f16(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s8)))
+float16x8_t __arm_vreinterpretq_f16_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s8)))
+float16x8_t __arm_vreinterpretq_f16(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u16)))
+float16x8_t __arm_vreinterpretq_f16_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u16)))
+float16x8_t __arm_vreinterpretq_f16(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u32)))
+float16x8_t __arm_vreinterpretq_f16_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u32)))
+float16x8_t __arm_vreinterpretq_f16(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u64)))
+float16x8_t __arm_vreinterpretq_f16_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u64)))
+float16x8_t __arm_vreinterpretq_f16(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u8)))
+float16x8_t __arm_vreinterpretq_f16_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u8)))
+float16x8_t __arm_vreinterpretq_f16(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_f16)))
+float32x4_t __arm_vreinterpretq_f32_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_f16)))
+float32x4_t __arm_vreinterpretq_f32(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s16)))
+float32x4_t __arm_vreinterpretq_f32_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s16)))
+float32x4_t __arm_vreinterpretq_f32(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s32)))
+float32x4_t __arm_vreinterpretq_f32_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s32)))
+float32x4_t __arm_vreinterpretq_f32(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s64)))
+float32x4_t __arm_vreinterpretq_f32_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s64)))
+float32x4_t __arm_vreinterpretq_f32(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s8)))
+float32x4_t __arm_vreinterpretq_f32_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s8)))
+float32x4_t __arm_vreinterpretq_f32(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u16)))
+float32x4_t __arm_vreinterpretq_f32_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u16)))
+float32x4_t __arm_vreinterpretq_f32(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u32)))
+float32x4_t __arm_vreinterpretq_f32_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u32)))
+float32x4_t __arm_vreinterpretq_f32(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u64)))
+float32x4_t __arm_vreinterpretq_f32_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u64)))
+float32x4_t __arm_vreinterpretq_f32(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u8)))
+float32x4_t __arm_vreinterpretq_f32_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u8)))
+float32x4_t __arm_vreinterpretq_f32(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_f16)))
+int16x8_t __arm_vreinterpretq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_f16)))
+int16x8_t __arm_vreinterpretq_s16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_f32)))
+int16x8_t __arm_vreinterpretq_s16_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_f32)))
+int16x8_t __arm_vreinterpretq_s16(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_f16)))
+int32x4_t __arm_vreinterpretq_s32_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_f16)))
+int32x4_t __arm_vreinterpretq_s32(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_f32)))
+int32x4_t __arm_vreinterpretq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_f32)))
+int32x4_t __arm_vreinterpretq_s32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_f16)))
+int64x2_t __arm_vreinterpretq_s64_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_f16)))
+int64x2_t __arm_vreinterpretq_s64(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_f32)))
+int64x2_t __arm_vreinterpretq_s64_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_f32)))
+int64x2_t __arm_vreinterpretq_s64(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_f16)))
+int8x16_t __arm_vreinterpretq_s8_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_f16)))
+int8x16_t __arm_vreinterpretq_s8(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_f32)))
+int8x16_t __arm_vreinterpretq_s8_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_f32)))
+int8x16_t __arm_vreinterpretq_s8(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_f16)))
+uint16x8_t __arm_vreinterpretq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_f16)))
+uint16x8_t __arm_vreinterpretq_u16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_f32)))
+uint16x8_t __arm_vreinterpretq_u16_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_f32)))
+uint16x8_t __arm_vreinterpretq_u16(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_f16)))
+uint32x4_t __arm_vreinterpretq_u32_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_f16)))
+uint32x4_t __arm_vreinterpretq_u32(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_f32)))
+uint32x4_t __arm_vreinterpretq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_f32)))
+uint32x4_t __arm_vreinterpretq_u32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_f16)))
+uint64x2_t __arm_vreinterpretq_u64_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_f16)))
+uint64x2_t __arm_vreinterpretq_u64(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_f32)))
+uint64x2_t __arm_vreinterpretq_u64_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_f32)))
+uint64x2_t __arm_vreinterpretq_u64(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f16)))
+uint8x16_t __arm_vreinterpretq_u8_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f16)))
+uint8x16_t __arm_vreinterpretq_u8(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f32)))
+uint8x16_t __arm_vreinterpretq_u8_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f32)))
+uint8x16_t __arm_vreinterpretq_u8(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_f16)))
+float16x8_t __arm_vrev32q_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_f16)))
+float16x8_t __arm_vrev32q(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_f16)))
+float16x8_t __arm_vrev32q_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_f16)))
+float16x8_t __arm_vrev32q_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_f16)))
+float16x8_t __arm_vrev32q_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_f16)))
+float16x8_t __arm_vrev32q_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_f16)))
+float16x8_t __arm_vrev64q_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_f16)))
+float16x8_t __arm_vrev64q(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_f32)))
+float32x4_t __arm_vrev64q_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_f32)))
+float32x4_t __arm_vrev64q(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_f16)))
+float16x8_t __arm_vrev64q_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_f16)))
+float16x8_t __arm_vrev64q_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_f32)))
+float32x4_t __arm_vrev64q_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_f32)))
+float32x4_t __arm_vrev64q_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_f16)))
+float16x8_t __arm_vrev64q_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_f16)))
+float16x8_t __arm_vrev64q_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_f32)))
+float32x4_t __arm_vrev64q_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_f32)))
+float32x4_t __arm_vrev64q_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_f16)))
+float16x8_t __arm_vrndaq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_f16)))
+float16x8_t __arm_vrndaq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_f32)))
+float32x4_t __arm_vrndaq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_f32)))
+float32x4_t __arm_vrndaq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_m_f16)))
+float16x8_t __arm_vrndaq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_m_f16)))
+float16x8_t __arm_vrndaq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_m_f32)))
+float32x4_t __arm_vrndaq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_m_f32)))
+float32x4_t __arm_vrndaq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_x_f16)))
+float16x8_t __arm_vrndaq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_x_f16)))
+float16x8_t __arm_vrndaq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_x_f32)))
+float32x4_t __arm_vrndaq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_x_f32)))
+float32x4_t __arm_vrndaq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_f16)))
+float16x8_t __arm_vrndmq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_f16)))
+float16x8_t __arm_vrndmq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_f32)))
+float32x4_t __arm_vrndmq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_f32)))
+float32x4_t __arm_vrndmq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_m_f16)))
+float16x8_t __arm_vrndmq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_m_f16)))
+float16x8_t __arm_vrndmq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_m_f32)))
+float32x4_t __arm_vrndmq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_m_f32)))
+float32x4_t __arm_vrndmq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_x_f16)))
+float16x8_t __arm_vrndmq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_x_f16)))
+float16x8_t __arm_vrndmq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_x_f32)))
+float32x4_t __arm_vrndmq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_x_f32)))
+float32x4_t __arm_vrndmq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_f16)))
+float16x8_t __arm_vrndnq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_f16)))
+float16x8_t __arm_vrndnq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_f32)))
+float32x4_t __arm_vrndnq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_f32)))
+float32x4_t __arm_vrndnq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_m_f16)))
+float16x8_t __arm_vrndnq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_m_f16)))
+float16x8_t __arm_vrndnq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_m_f32)))
+float32x4_t __arm_vrndnq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_m_f32)))
+float32x4_t __arm_vrndnq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_x_f16)))
+float16x8_t __arm_vrndnq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_x_f16)))
+float16x8_t __arm_vrndnq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_x_f32)))
+float32x4_t __arm_vrndnq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_x_f32)))
+float32x4_t __arm_vrndnq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_f16)))
+float16x8_t __arm_vrndpq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_f16)))
+float16x8_t __arm_vrndpq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_f32)))
+float32x4_t __arm_vrndpq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_f32)))
+float32x4_t __arm_vrndpq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_m_f16)))
+float16x8_t __arm_vrndpq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_m_f16)))
+float16x8_t __arm_vrndpq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_m_f32)))
+float32x4_t __arm_vrndpq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_m_f32)))
+float32x4_t __arm_vrndpq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_x_f16)))
+float16x8_t __arm_vrndpq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_x_f16)))
+float16x8_t __arm_vrndpq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_x_f32)))
+float32x4_t __arm_vrndpq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_x_f32)))
+float32x4_t __arm_vrndpq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_f16)))
+float16x8_t __arm_vrndq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_f16)))
+float16x8_t __arm_vrndq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_f32)))
+float32x4_t __arm_vrndq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_f32)))
+float32x4_t __arm_vrndq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_m_f16)))
+float16x8_t __arm_vrndq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_m_f16)))
+float16x8_t __arm_vrndq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_m_f32)))
+float32x4_t __arm_vrndq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_m_f32)))
+float32x4_t __arm_vrndq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_x_f16)))
+float16x8_t __arm_vrndq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_x_f16)))
+float16x8_t __arm_vrndq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_x_f32)))
+float32x4_t __arm_vrndq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_x_f32)))
+float32x4_t __arm_vrndq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_f16)))
+float16x8_t __arm_vrndxq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_f16)))
+float16x8_t __arm_vrndxq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_f32)))
+float32x4_t __arm_vrndxq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_f32)))
+float32x4_t __arm_vrndxq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_m_f16)))
+float16x8_t __arm_vrndxq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_m_f16)))
+float16x8_t __arm_vrndxq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_m_f32)))
+float32x4_t __arm_vrndxq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_m_f32)))
+float32x4_t __arm_vrndxq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_x_f16)))
+float16x8_t __arm_vrndxq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_x_f16)))
+float16x8_t __arm_vrndxq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_x_f32)))
+float32x4_t __arm_vrndxq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_x_f32)))
+float32x4_t __arm_vrndxq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_f16)))
+float16x8_t __arm_vsetq_lane_f16(float16_t, float16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_f16)))
+float16x8_t __arm_vsetq_lane(float16_t, float16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_f32)))
+float32x4_t __arm_vsetq_lane_f32(float32_t, float32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_f32)))
+float32x4_t __arm_vsetq_lane(float32_t, float32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_f16)))
+void __arm_vst1q_f16(float16_t *, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_f16)))
+void __arm_vst1q(float16_t *, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_f32)))
+void __arm_vst1q_f32(float32_t *, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_f32)))
+void __arm_vst1q(float32_t *, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_f16)))
+void __arm_vst1q_p_f16(float16_t *, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_f16)))
+void __arm_vst1q_p(float16_t *, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_f32)))
+void __arm_vst1q_p_f32(float32_t *, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_f32)))
+void __arm_vst1q_p(float32_t *, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_f16)))
+void __arm_vst2q_f16(float16_t *, float16x8x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_f16)))
+void __arm_vst2q(float16_t *, float16x8x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_f32)))
+void __arm_vst2q_f32(float32_t *, float32x4x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_f32)))
+void __arm_vst2q(float32_t *, float32x4x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_f16)))
+void __arm_vst4q_f16(float16_t *, float16x8x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_f16)))
+void __arm_vst4q(float16_t *, float16x8x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_f32)))
+void __arm_vst4q_f32(float32_t *, float32x4x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_f32)))
+void __arm_vst4q(float32_t *, float32x4x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_f16)))
+void __arm_vstrhq_f16(float16_t *, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_f16)))
+void __arm_vstrhq(float16_t *, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_f16)))
+void __arm_vstrhq_p_f16(float16_t *, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_f16)))
+void __arm_vstrhq_p(float16_t *, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_f16)))
+void __arm_vstrhq_scatter_offset_f16(float16_t *, uint16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_f16)))
+void __arm_vstrhq_scatter_offset(float16_t *, uint16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_f16)))
+void __arm_vstrhq_scatter_offset_p_f16(float16_t *, uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_f16)))
+void __arm_vstrhq_scatter_offset_p(float16_t *, uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_f16)))
+void __arm_vstrhq_scatter_shifted_offset_f16(float16_t *, uint16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_f16)))
+void __arm_vstrhq_scatter_shifted_offset(float16_t *, uint16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_f16)))
+void __arm_vstrhq_scatter_shifted_offset_p_f16(float16_t *, uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_f16)))
+void __arm_vstrhq_scatter_shifted_offset_p(float16_t *, uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_f32)))
+void __arm_vstrwq_f32(float32_t *, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_f32)))
+void __arm_vstrwq(float32_t *, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_f32)))
+void __arm_vstrwq_p_f32(float32_t *, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_f32)))
+void __arm_vstrwq_p(float32_t *, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_f32)))
+void __arm_vstrwq_scatter_base_f32(uint32x4_t, int, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_f32)))
+void __arm_vstrwq_scatter_base(uint32x4_t, int, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_f32)))
+void __arm_vstrwq_scatter_base_p_f32(uint32x4_t, int, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_f32)))
+void __arm_vstrwq_scatter_base_p(uint32x4_t, int, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_f32)))
+void __arm_vstrwq_scatter_base_wb_f32(uint32x4_t *, int, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_f32)))
+void __arm_vstrwq_scatter_base_wb(uint32x4_t *, int, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_f32)))
+void __arm_vstrwq_scatter_base_wb_p_f32(uint32x4_t *, int, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_f32)))
+void __arm_vstrwq_scatter_base_wb_p(uint32x4_t *, int, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_f32)))
+void __arm_vstrwq_scatter_offset_f32(float32_t *, uint32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_f32)))
+void __arm_vstrwq_scatter_offset(float32_t *, uint32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_f32)))
+void __arm_vstrwq_scatter_offset_p_f32(float32_t *, uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_f32)))
+void __arm_vstrwq_scatter_offset_p(float32_t *, uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_f32)))
+void __arm_vstrwq_scatter_shifted_offset_f32(float32_t *, uint32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_f32)))
+void __arm_vstrwq_scatter_shifted_offset(float32_t *, uint32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_f32)))
+void __arm_vstrwq_scatter_shifted_offset_p_f32(float32_t *, uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_f32)))
+void __arm_vstrwq_scatter_shifted_offset_p(float32_t *, uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_f16)))
+float16x8_t __arm_vsubq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_f16)))
+float16x8_t __arm_vsubq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_f32)))
+float32x4_t __arm_vsubq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_f32)))
+float32x4_t __arm_vsubq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_f16)))
+float16x8_t __arm_vsubq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_f16)))
+float16x8_t __arm_vsubq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_f32)))
+float32x4_t __arm_vsubq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_f32)))
+float32x4_t __arm_vsubq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_f16)))
+float16x8_t __arm_vsubq_m_n_f16(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_f16)))
+float16x8_t __arm_vsubq_m(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_f32)))
+float32x4_t __arm_vsubq_m_n_f32(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_f32)))
+float32x4_t __arm_vsubq_m(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_f16)))
+float16x8_t __arm_vsubq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_f16)))
+float16x8_t __arm_vsubq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_f32)))
+float32x4_t __arm_vsubq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_f32)))
+float32x4_t __arm_vsubq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_f16)))
+float16x8_t __arm_vsubq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_f16)))
+float16x8_t __arm_vsubq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_f32)))
+float32x4_t __arm_vsubq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_f32)))
+float32x4_t __arm_vsubq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_f16)))
+float16x8_t __arm_vsubq_x_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_f16)))
+float16x8_t __arm_vsubq_x(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_f32)))
+float32x4_t __arm_vsubq_x_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_f32)))
+float32x4_t __arm_vsubq_x(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_f16)))
+float16x8_t __arm_vuninitializedq_f16();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_f32)))
+float32x4_t __arm_vuninitializedq_f32();
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_f16)))
+float16x8_t __arm_vuninitializedq(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_f32)))
+float32x4_t __arm_vuninitializedq(float32x4_t);
+
+#endif /* (__ARM_FEATURE_MVE & 2) */
+
+#if (!defined __ARM_MVE_PRESERVE_USER_NAMESPACE)
+
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_asrl)))
+int64_t asrl(int64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_lsll)))
+uint64_t lsll(uint64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_sqrshr)))
+int32_t sqrshr(int32_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_sqrshrl)))
+int64_t sqrshrl(int64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_sqrshrl_sat48)))
+int64_t sqrshrl_sat48(int64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_sqshl)))
+int32_t sqshl(int32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_sqshll)))
+int64_t sqshll(int64_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_srshr)))
+int32_t srshr(int32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_srshrl)))
+int64_t srshrl(int64_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_uqrshl)))
+uint32_t uqrshl(uint32_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_uqrshll)))
+uint64_t uqrshll(uint64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_uqrshll_sat48)))
+uint64_t uqrshll_sat48(uint64_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_uqshl)))
+uint32_t uqshl(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_uqshll)))
+uint64_t uqshll(uint64_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_urshr)))
+uint32_t urshr(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_urshrl)))
+uint64_t urshrl(uint64_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s16)))
+uint32_t vabavq_p_s16(uint32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s16)))
+uint32_t vabavq_p(uint32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s32)))
+uint32_t vabavq_p_s32(uint32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s32)))
+uint32_t vabavq_p(uint32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s8)))
+uint32_t vabavq_p_s8(uint32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_s8)))
+uint32_t vabavq_p(uint32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u16)))
+uint32_t vabavq_p_u16(uint32_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u16)))
+uint32_t vabavq_p(uint32_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u32)))
+uint32_t vabavq_p_u32(uint32_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u32)))
+uint32_t vabavq_p(uint32_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u8)))
+uint32_t vabavq_p_u8(uint32_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_p_u8)))
+uint32_t vabavq_p(uint32_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s16)))
+uint32_t vabavq_s16(uint32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s16)))
+uint32_t vabavq(uint32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s32)))
+uint32_t vabavq_s32(uint32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s32)))
+uint32_t vabavq(uint32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s8)))
+uint32_t vabavq_s8(uint32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_s8)))
+uint32_t vabavq(uint32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u16)))
+uint32_t vabavq_u16(uint32_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u16)))
+uint32_t vabavq(uint32_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u32)))
+uint32_t vabavq_u32(uint32_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u32)))
+uint32_t vabavq(uint32_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u8)))
+uint32_t vabavq_u8(uint32_t, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabavq_u8)))
+uint32_t vabavq(uint32_t, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s16)))
+int16x8_t vabdq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s16)))
+int16x8_t vabdq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s32)))
+int32x4_t vabdq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s32)))
+int32x4_t vabdq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s8)))
+int8x16_t vabdq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_s8)))
+int8x16_t vabdq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u16)))
+uint16x8_t vabdq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u16)))
+uint16x8_t vabdq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u32)))
+uint32x4_t vabdq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u32)))
+uint32x4_t vabdq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u8)))
+uint8x16_t vabdq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_u8)))
+uint8x16_t vabdq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s16)))
+int16x8_t vabdq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s16)))
+int16x8_t vabdq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s32)))
+int32x4_t vabdq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s32)))
+int32x4_t vabdq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s8)))
+int8x16_t vabdq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_s8)))
+int8x16_t vabdq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u16)))
+uint16x8_t vabdq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u16)))
+uint16x8_t vabdq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u32)))
+uint32x4_t vabdq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u32)))
+uint32x4_t vabdq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u8)))
+uint8x16_t vabdq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_u8)))
+uint8x16_t vabdq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s16)))
+int16x8_t vabdq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s16)))
+int16x8_t vabdq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s32)))
+int32x4_t vabdq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s32)))
+int32x4_t vabdq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s8)))
+int8x16_t vabdq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_s8)))
+int8x16_t vabdq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u16)))
+uint16x8_t vabdq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u16)))
+uint16x8_t vabdq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u32)))
+uint32x4_t vabdq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u32)))
+uint32x4_t vabdq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u8)))
+uint8x16_t vabdq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_u8)))
+uint8x16_t vabdq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s16)))
+int16x8_t vabsq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s16)))
+int16x8_t vabsq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s32)))
+int32x4_t vabsq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s32)))
+int32x4_t vabsq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s8)))
+int8x16_t vabsq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_s8)))
+int8x16_t vabsq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s16)))
+int16x8_t vabsq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s16)))
+int16x8_t vabsq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s32)))
+int32x4_t vabsq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s32)))
+int32x4_t vabsq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s8)))
+int8x16_t vabsq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_s8)))
+int8x16_t vabsq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s16)))
+int16x8_t vabsq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s16)))
+int16x8_t vabsq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s32)))
+int32x4_t vabsq_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s32)))
+int32x4_t vabsq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s8)))
+int8x16_t vabsq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_s8)))
+int8x16_t vabsq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadciq_m_s32)))
+int32x4_t vadciq_m_s32(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadciq_m_s32)))
+int32x4_t vadciq_m(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadciq_m_u32)))
+uint32x4_t vadciq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadciq_m_u32)))
+uint32x4_t vadciq_m(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadciq_s32)))
+int32x4_t vadciq_s32(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadciq_s32)))
+int32x4_t vadciq(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadciq_u32)))
+uint32x4_t vadciq_u32(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadciq_u32)))
+uint32x4_t vadciq(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadcq_m_s32)))
+int32x4_t vadcq_m_s32(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadcq_m_s32)))
+int32x4_t vadcq_m(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadcq_m_u32)))
+uint32x4_t vadcq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadcq_m_u32)))
+uint32x4_t vadcq_m(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadcq_s32)))
+int32x4_t vadcq_s32(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadcq_s32)))
+int32x4_t vadcq(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vadcq_u32)))
+uint32x4_t vadcq_u32(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vadcq_u32)))
+uint32x4_t vadcq(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_p_s32)))
+int64_t vaddlvaq_p_s32(int64_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_p_s32)))
+int64_t vaddlvaq_p(int64_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_p_u32)))
+uint64_t vaddlvaq_p_u32(uint64_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_p_u32)))
+uint64_t vaddlvaq_p(uint64_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_s32)))
+int64_t vaddlvaq_s32(int64_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_s32)))
+int64_t vaddlvaq(int64_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_u32)))
+uint64_t vaddlvaq_u32(uint64_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvaq_u32)))
+uint64_t vaddlvaq(uint64_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_p_s32)))
+int64_t vaddlvq_p_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_p_s32)))
+int64_t vaddlvq_p(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_p_u32)))
+uint64_t vaddlvq_p_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_p_u32)))
+uint64_t vaddlvq_p(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_s32)))
+int64_t vaddlvq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_s32)))
+int64_t vaddlvq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_u32)))
+uint64_t vaddlvq_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddlvq_u32)))
+uint64_t vaddlvq(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s16)))
+int16x8_t vaddq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s16)))
+int16x8_t vaddq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s32)))
+int32x4_t vaddq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s32)))
+int32x4_t vaddq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s8)))
+int8x16_t vaddq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_s8)))
+int8x16_t vaddq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u16)))
+uint16x8_t vaddq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u16)))
+uint16x8_t vaddq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u32)))
+uint32x4_t vaddq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u32)))
+uint32x4_t vaddq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u8)))
+uint8x16_t vaddq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_u8)))
+uint8x16_t vaddq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s16)))
+int16x8_t vaddq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s16)))
+int16x8_t vaddq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s32)))
+int32x4_t vaddq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s32)))
+int32x4_t vaddq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s8)))
+int8x16_t vaddq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_s8)))
+int8x16_t vaddq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u16)))
+uint16x8_t vaddq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u16)))
+uint16x8_t vaddq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u32)))
+uint32x4_t vaddq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u32)))
+uint32x4_t vaddq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u8)))
+uint8x16_t vaddq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_u8)))
+uint8x16_t vaddq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s16)))
+int16x8_t vaddq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s16)))
+int16x8_t vaddq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s32)))
+int32x4_t vaddq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s32)))
+int32x4_t vaddq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s8)))
+int8x16_t vaddq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_s8)))
+int8x16_t vaddq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u16)))
+uint16x8_t vaddq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u16)))
+uint16x8_t vaddq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u32)))
+uint32x4_t vaddq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u32)))
+uint32x4_t vaddq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u8)))
+uint8x16_t vaddq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_u8)))
+uint8x16_t vaddq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s16)))
+int16x8_t vaddq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s16)))
+int16x8_t vaddq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s32)))
+int32x4_t vaddq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s32)))
+int32x4_t vaddq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s8)))
+int8x16_t vaddq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_s8)))
+int8x16_t vaddq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u16)))
+uint16x8_t vaddq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u16)))
+uint16x8_t vaddq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u32)))
+uint32x4_t vaddq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u32)))
+uint32x4_t vaddq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u8)))
+uint8x16_t vaddq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_u8)))
+uint8x16_t vaddq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s16)))
+int16x8_t vaddq_x_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s16)))
+int16x8_t vaddq_x(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s32)))
+int32x4_t vaddq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s32)))
+int32x4_t vaddq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s8)))
+int8x16_t vaddq_x_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_s8)))
+int8x16_t vaddq_x(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u16)))
+uint16x8_t vaddq_x_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u16)))
+uint16x8_t vaddq_x(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u32)))
+uint32x4_t vaddq_x_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u32)))
+uint32x4_t vaddq_x(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u8)))
+uint8x16_t vaddq_x_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_u8)))
+uint8x16_t vaddq_x(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s16)))
+int16x8_t vaddq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s16)))
+int16x8_t vaddq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s32)))
+int32x4_t vaddq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s32)))
+int32x4_t vaddq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s8)))
+int8x16_t vaddq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_s8)))
+int8x16_t vaddq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u16)))
+uint16x8_t vaddq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u16)))
+uint16x8_t vaddq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u32)))
+uint32x4_t vaddq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u32)))
+uint32x4_t vaddq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u8)))
+uint8x16_t vaddq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_u8)))
+uint8x16_t vaddq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s16)))
+int32_t vaddvaq_p_s16(int32_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s16)))
+int32_t vaddvaq_p(int32_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s32)))
+int32_t vaddvaq_p_s32(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s32)))
+int32_t vaddvaq_p(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s8)))
+int32_t vaddvaq_p_s8(int32_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_s8)))
+int32_t vaddvaq_p(int32_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u16)))
+uint32_t vaddvaq_p_u16(uint32_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u16)))
+uint32_t vaddvaq_p(uint32_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u32)))
+uint32_t vaddvaq_p_u32(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u32)))
+uint32_t vaddvaq_p(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u8)))
+uint32_t vaddvaq_p_u8(uint32_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_p_u8)))
+uint32_t vaddvaq_p(uint32_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s16)))
+int32_t vaddvaq_s16(int32_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s16)))
+int32_t vaddvaq(int32_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s32)))
+int32_t vaddvaq_s32(int32_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s32)))
+int32_t vaddvaq(int32_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s8)))
+int32_t vaddvaq_s8(int32_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_s8)))
+int32_t vaddvaq(int32_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u16)))
+uint32_t vaddvaq_u16(uint32_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u16)))
+uint32_t vaddvaq(uint32_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u32)))
+uint32_t vaddvaq_u32(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u32)))
+uint32_t vaddvaq(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u8)))
+uint32_t vaddvaq_u8(uint32_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvaq_u8)))
+uint32_t vaddvaq(uint32_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s16)))
+int32_t vaddvq_p_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s16)))
+int32_t vaddvq_p(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s32)))
+int32_t vaddvq_p_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s32)))
+int32_t vaddvq_p(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s8)))
+int32_t vaddvq_p_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_s8)))
+int32_t vaddvq_p(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u16)))
+uint32_t vaddvq_p_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u16)))
+uint32_t vaddvq_p(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u32)))
+uint32_t vaddvq_p_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u32)))
+uint32_t vaddvq_p(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u8)))
+uint32_t vaddvq_p_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_p_u8)))
+uint32_t vaddvq_p(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s16)))
+int32_t vaddvq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s16)))
+int32_t vaddvq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s32)))
+int32_t vaddvq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s32)))
+int32_t vaddvq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s8)))
+int32_t vaddvq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_s8)))
+int32_t vaddvq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u16)))
+uint32_t vaddvq_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u16)))
+uint32_t vaddvq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u32)))
+uint32_t vaddvq_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u32)))
+uint32_t vaddvq(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u8)))
+uint32_t vaddvq_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddvq_u8)))
+uint32_t vaddvq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s16)))
+int16x8_t vandq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s16)))
+int16x8_t vandq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s32)))
+int32x4_t vandq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s32)))
+int32x4_t vandq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s8)))
+int8x16_t vandq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_s8)))
+int8x16_t vandq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u16)))
+uint16x8_t vandq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u16)))
+uint16x8_t vandq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u32)))
+uint32x4_t vandq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u32)))
+uint32x4_t vandq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u8)))
+uint8x16_t vandq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_u8)))
+uint8x16_t vandq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_s16)))
+int16x8_t vandq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_s16)))
+int16x8_t vandq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_s32)))
+int32x4_t vandq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_s32)))
+int32x4_t vandq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_s8)))
+int8x16_t vandq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_s8)))
+int8x16_t vandq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_u16)))
+uint16x8_t vandq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_u16)))
+uint16x8_t vandq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_u32)))
+uint32x4_t vandq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_u32)))
+uint32x4_t vandq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_u8)))
+uint8x16_t vandq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_u8)))
+uint8x16_t vandq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s16)))
+int16x8_t vandq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s16)))
+int16x8_t vandq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s32)))
+int32x4_t vandq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s32)))
+int32x4_t vandq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s8)))
+int8x16_t vandq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_s8)))
+int8x16_t vandq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u16)))
+uint16x8_t vandq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u16)))
+uint16x8_t vandq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u32)))
+uint32x4_t vandq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u32)))
+uint32x4_t vandq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u8)))
+uint8x16_t vandq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_u8)))
+uint8x16_t vandq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_s16)))
+int16x8_t vbicq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_s16)))
+int16x8_t vbicq_m_n(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_s32)))
+int32x4_t vbicq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_s32)))
+int32x4_t vbicq_m_n(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_u16)))
+uint16x8_t vbicq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_u16)))
+uint16x8_t vbicq_m_n(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_u32)))
+uint32x4_t vbicq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_n_u32)))
+uint32x4_t vbicq_m_n(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s16)))
+int16x8_t vbicq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s16)))
+int16x8_t vbicq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s32)))
+int32x4_t vbicq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s32)))
+int32x4_t vbicq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s8)))
+int8x16_t vbicq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_s8)))
+int8x16_t vbicq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u16)))
+uint16x8_t vbicq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u16)))
+uint16x8_t vbicq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u32)))
+uint32x4_t vbicq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u32)))
+uint32x4_t vbicq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u8)))
+uint8x16_t vbicq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_u8)))
+uint8x16_t vbicq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_s16)))
+int16x8_t vbicq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_s16)))
+int16x8_t vbicq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_s32)))
+int32x4_t vbicq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_s32)))
+int32x4_t vbicq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_u16)))
+uint16x8_t vbicq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_u16)))
+uint16x8_t vbicq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_u32)))
+uint32x4_t vbicq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_n_u32)))
+uint32x4_t vbicq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s16)))
+int16x8_t vbicq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s16)))
+int16x8_t vbicq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s32)))
+int32x4_t vbicq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s32)))
+int32x4_t vbicq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s8)))
+int8x16_t vbicq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_s8)))
+int8x16_t vbicq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u16)))
+uint16x8_t vbicq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u16)))
+uint16x8_t vbicq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u32)))
+uint32x4_t vbicq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u32)))
+uint32x4_t vbicq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u8)))
+uint8x16_t vbicq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_u8)))
+uint8x16_t vbicq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s16)))
+int16x8_t vbicq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s16)))
+int16x8_t vbicq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s32)))
+int32x4_t vbicq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s32)))
+int32x4_t vbicq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s8)))
+int8x16_t vbicq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_s8)))
+int8x16_t vbicq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u16)))
+uint16x8_t vbicq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u16)))
+uint16x8_t vbicq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u32)))
+uint32x4_t vbicq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u32)))
+uint32x4_t vbicq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u8)))
+uint8x16_t vbicq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_u8)))
+uint8x16_t vbicq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s16)))
+int16x8_t vbrsrq_m_n_s16(int16x8_t, int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s16)))
+int16x8_t vbrsrq_m(int16x8_t, int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s32)))
+int32x4_t vbrsrq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s32)))
+int32x4_t vbrsrq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s8)))
+int8x16_t vbrsrq_m_n_s8(int8x16_t, int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_s8)))
+int8x16_t vbrsrq_m(int8x16_t, int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u16)))
+uint16x8_t vbrsrq_m_n_u16(uint16x8_t, uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u16)))
+uint16x8_t vbrsrq_m(uint16x8_t, uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u32)))
+uint32x4_t vbrsrq_m_n_u32(uint32x4_t, uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u32)))
+uint32x4_t vbrsrq_m(uint32x4_t, uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u8)))
+uint8x16_t vbrsrq_m_n_u8(uint8x16_t, uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_u8)))
+uint8x16_t vbrsrq_m(uint8x16_t, uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s16)))
+int16x8_t vbrsrq_n_s16(int16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s16)))
+int16x8_t vbrsrq(int16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s32)))
+int32x4_t vbrsrq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s32)))
+int32x4_t vbrsrq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s8)))
+int8x16_t vbrsrq_n_s8(int8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_s8)))
+int8x16_t vbrsrq(int8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u16)))
+uint16x8_t vbrsrq_n_u16(uint16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u16)))
+uint16x8_t vbrsrq(uint16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u32)))
+uint32x4_t vbrsrq_n_u32(uint32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u32)))
+uint32x4_t vbrsrq(uint32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u8)))
+uint8x16_t vbrsrq_n_u8(uint8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_u8)))
+uint8x16_t vbrsrq(uint8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s16)))
+int16x8_t vbrsrq_x_n_s16(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s16)))
+int16x8_t vbrsrq_x(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s32)))
+int32x4_t vbrsrq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s32)))
+int32x4_t vbrsrq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s8)))
+int8x16_t vbrsrq_x_n_s8(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_s8)))
+int8x16_t vbrsrq_x(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u16)))
+uint16x8_t vbrsrq_x_n_u16(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u16)))
+uint16x8_t vbrsrq_x(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u32)))
+uint32x4_t vbrsrq_x_n_u32(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u32)))
+uint32x4_t vbrsrq_x(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u8)))
+uint8x16_t vbrsrq_x_n_u8(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_u8)))
+uint8x16_t vbrsrq_x(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s16)))
+int16x8_t vcaddq_rot270_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s16)))
+int16x8_t vcaddq_rot270_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s32)))
+int32x4_t vcaddq_rot270_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s32)))
+int32x4_t vcaddq_rot270_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s8)))
+int8x16_t vcaddq_rot270_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_s8)))
+int8x16_t vcaddq_rot270_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u16)))
+uint16x8_t vcaddq_rot270_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u16)))
+uint16x8_t vcaddq_rot270_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u32)))
+uint32x4_t vcaddq_rot270_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u32)))
+uint32x4_t vcaddq_rot270_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u8)))
+uint8x16_t vcaddq_rot270_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_u8)))
+uint8x16_t vcaddq_rot270_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s16)))
+int16x8_t vcaddq_rot270_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s16)))
+int16x8_t vcaddq_rot270(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s32)))
+int32x4_t vcaddq_rot270_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s32)))
+int32x4_t vcaddq_rot270(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s8)))
+int8x16_t vcaddq_rot270_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_s8)))
+int8x16_t vcaddq_rot270(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u16)))
+uint16x8_t vcaddq_rot270_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u16)))
+uint16x8_t vcaddq_rot270(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u32)))
+uint32x4_t vcaddq_rot270_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u32)))
+uint32x4_t vcaddq_rot270(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u8)))
+uint8x16_t vcaddq_rot270_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_u8)))
+uint8x16_t vcaddq_rot270(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s16)))
+int16x8_t vcaddq_rot270_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s16)))
+int16x8_t vcaddq_rot270_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s32)))
+int32x4_t vcaddq_rot270_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s32)))
+int32x4_t vcaddq_rot270_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s8)))
+int8x16_t vcaddq_rot270_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_s8)))
+int8x16_t vcaddq_rot270_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u16)))
+uint16x8_t vcaddq_rot270_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u16)))
+uint16x8_t vcaddq_rot270_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u32)))
+uint32x4_t vcaddq_rot270_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u32)))
+uint32x4_t vcaddq_rot270_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u8)))
+uint8x16_t vcaddq_rot270_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_u8)))
+uint8x16_t vcaddq_rot270_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s16)))
+int16x8_t vcaddq_rot90_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s16)))
+int16x8_t vcaddq_rot90_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s32)))
+int32x4_t vcaddq_rot90_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s32)))
+int32x4_t vcaddq_rot90_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s8)))
+int8x16_t vcaddq_rot90_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_s8)))
+int8x16_t vcaddq_rot90_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u16)))
+uint16x8_t vcaddq_rot90_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u16)))
+uint16x8_t vcaddq_rot90_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u32)))
+uint32x4_t vcaddq_rot90_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u32)))
+uint32x4_t vcaddq_rot90_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u8)))
+uint8x16_t vcaddq_rot90_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_u8)))
+uint8x16_t vcaddq_rot90_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s16)))
+int16x8_t vcaddq_rot90_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s16)))
+int16x8_t vcaddq_rot90(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s32)))
+int32x4_t vcaddq_rot90_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s32)))
+int32x4_t vcaddq_rot90(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s8)))
+int8x16_t vcaddq_rot90_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_s8)))
+int8x16_t vcaddq_rot90(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u16)))
+uint16x8_t vcaddq_rot90_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u16)))
+uint16x8_t vcaddq_rot90(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u32)))
+uint32x4_t vcaddq_rot90_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u32)))
+uint32x4_t vcaddq_rot90(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u8)))
+uint8x16_t vcaddq_rot90_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_u8)))
+uint8x16_t vcaddq_rot90(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s16)))
+int16x8_t vcaddq_rot90_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s16)))
+int16x8_t vcaddq_rot90_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s32)))
+int32x4_t vcaddq_rot90_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s32)))
+int32x4_t vcaddq_rot90_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s8)))
+int8x16_t vcaddq_rot90_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_s8)))
+int8x16_t vcaddq_rot90_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u16)))
+uint16x8_t vcaddq_rot90_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u16)))
+uint16x8_t vcaddq_rot90_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u32)))
+uint32x4_t vcaddq_rot90_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u32)))
+uint32x4_t vcaddq_rot90_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u8)))
+uint8x16_t vcaddq_rot90_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_u8)))
+uint8x16_t vcaddq_rot90_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s16)))
+int16x8_t vclsq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s16)))
+int16x8_t vclsq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s32)))
+int32x4_t vclsq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s32)))
+int32x4_t vclsq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s8)))
+int8x16_t vclsq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_m_s8)))
+int8x16_t vclsq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s16)))
+int16x8_t vclsq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s16)))
+int16x8_t vclsq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s32)))
+int32x4_t vclsq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s32)))
+int32x4_t vclsq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s8)))
+int8x16_t vclsq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_s8)))
+int8x16_t vclsq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s16)))
+int16x8_t vclsq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s16)))
+int16x8_t vclsq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s32)))
+int32x4_t vclsq_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s32)))
+int32x4_t vclsq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s8)))
+int8x16_t vclsq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclsq_x_s8)))
+int8x16_t vclsq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s16)))
+int16x8_t vclzq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s16)))
+int16x8_t vclzq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s32)))
+int32x4_t vclzq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s32)))
+int32x4_t vclzq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s8)))
+int8x16_t vclzq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_s8)))
+int8x16_t vclzq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u16)))
+uint16x8_t vclzq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u16)))
+uint16x8_t vclzq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u32)))
+uint32x4_t vclzq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u32)))
+uint32x4_t vclzq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u8)))
+uint8x16_t vclzq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_m_u8)))
+uint8x16_t vclzq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s16)))
+int16x8_t vclzq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s16)))
+int16x8_t vclzq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s32)))
+int32x4_t vclzq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s32)))
+int32x4_t vclzq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s8)))
+int8x16_t vclzq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_s8)))
+int8x16_t vclzq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u16)))
+uint16x8_t vclzq_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u16)))
+uint16x8_t vclzq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u32)))
+uint32x4_t vclzq_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u32)))
+uint32x4_t vclzq(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u8)))
+uint8x16_t vclzq_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_u8)))
+uint8x16_t vclzq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s16)))
+int16x8_t vclzq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s16)))
+int16x8_t vclzq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s32)))
+int32x4_t vclzq_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s32)))
+int32x4_t vclzq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s8)))
+int8x16_t vclzq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_s8)))
+int8x16_t vclzq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u16)))
+uint16x8_t vclzq_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u16)))
+uint16x8_t vclzq_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u32)))
+uint32x4_t vclzq_x_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u32)))
+uint32x4_t vclzq_x(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u8)))
+uint8x16_t vclzq_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vclzq_x_u8)))
+uint8x16_t vclzq_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u16)))
+mve_pred16_t vcmpcsq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u16)))
+mve_pred16_t vcmpcsq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u32)))
+mve_pred16_t vcmpcsq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u32)))
+mve_pred16_t vcmpcsq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u8)))
+mve_pred16_t vcmpcsq_m_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_n_u8)))
+mve_pred16_t vcmpcsq_m(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u16)))
+mve_pred16_t vcmpcsq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u16)))
+mve_pred16_t vcmpcsq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u32)))
+mve_pred16_t vcmpcsq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u32)))
+mve_pred16_t vcmpcsq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u8)))
+mve_pred16_t vcmpcsq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_m_u8)))
+mve_pred16_t vcmpcsq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u16)))
+mve_pred16_t vcmpcsq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u16)))
+mve_pred16_t vcmpcsq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u32)))
+mve_pred16_t vcmpcsq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u32)))
+mve_pred16_t vcmpcsq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u8)))
+mve_pred16_t vcmpcsq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_n_u8)))
+mve_pred16_t vcmpcsq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u16)))
+mve_pred16_t vcmpcsq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u16)))
+mve_pred16_t vcmpcsq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u32)))
+mve_pred16_t vcmpcsq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u32)))
+mve_pred16_t vcmpcsq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u8)))
+mve_pred16_t vcmpcsq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpcsq_u8)))
+mve_pred16_t vcmpcsq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s16)))
+mve_pred16_t vcmpeqq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s16)))
+mve_pred16_t vcmpeqq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s32)))
+mve_pred16_t vcmpeqq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s32)))
+mve_pred16_t vcmpeqq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s8)))
+mve_pred16_t vcmpeqq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_s8)))
+mve_pred16_t vcmpeqq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u16)))
+mve_pred16_t vcmpeqq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u16)))
+mve_pred16_t vcmpeqq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u32)))
+mve_pred16_t vcmpeqq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u32)))
+mve_pred16_t vcmpeqq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u8)))
+mve_pred16_t vcmpeqq_m_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_u8)))
+mve_pred16_t vcmpeqq_m(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s16)))
+mve_pred16_t vcmpeqq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s16)))
+mve_pred16_t vcmpeqq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s32)))
+mve_pred16_t vcmpeqq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s32)))
+mve_pred16_t vcmpeqq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s8)))
+mve_pred16_t vcmpeqq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_s8)))
+mve_pred16_t vcmpeqq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u16)))
+mve_pred16_t vcmpeqq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u16)))
+mve_pred16_t vcmpeqq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u32)))
+mve_pred16_t vcmpeqq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u32)))
+mve_pred16_t vcmpeqq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u8)))
+mve_pred16_t vcmpeqq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_u8)))
+mve_pred16_t vcmpeqq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s16)))
+mve_pred16_t vcmpeqq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s16)))
+mve_pred16_t vcmpeqq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s32)))
+mve_pred16_t vcmpeqq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s32)))
+mve_pred16_t vcmpeqq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s8)))
+mve_pred16_t vcmpeqq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_s8)))
+mve_pred16_t vcmpeqq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u16)))
+mve_pred16_t vcmpeqq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u16)))
+mve_pred16_t vcmpeqq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u32)))
+mve_pred16_t vcmpeqq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u32)))
+mve_pred16_t vcmpeqq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u8)))
+mve_pred16_t vcmpeqq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_u8)))
+mve_pred16_t vcmpeqq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s16)))
+mve_pred16_t vcmpeqq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s16)))
+mve_pred16_t vcmpeqq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s32)))
+mve_pred16_t vcmpeqq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s32)))
+mve_pred16_t vcmpeqq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s8)))
+mve_pred16_t vcmpeqq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_s8)))
+mve_pred16_t vcmpeqq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u16)))
+mve_pred16_t vcmpeqq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u16)))
+mve_pred16_t vcmpeqq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u32)))
+mve_pred16_t vcmpeqq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u32)))
+mve_pred16_t vcmpeqq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u8)))
+mve_pred16_t vcmpeqq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_u8)))
+mve_pred16_t vcmpeqq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s16)))
+mve_pred16_t vcmpgeq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s16)))
+mve_pred16_t vcmpgeq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s32)))
+mve_pred16_t vcmpgeq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s32)))
+mve_pred16_t vcmpgeq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s8)))
+mve_pred16_t vcmpgeq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_s8)))
+mve_pred16_t vcmpgeq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s16)))
+mve_pred16_t vcmpgeq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s16)))
+mve_pred16_t vcmpgeq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s32)))
+mve_pred16_t vcmpgeq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s32)))
+mve_pred16_t vcmpgeq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s8)))
+mve_pred16_t vcmpgeq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_s8)))
+mve_pred16_t vcmpgeq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s16)))
+mve_pred16_t vcmpgeq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s16)))
+mve_pred16_t vcmpgeq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s32)))
+mve_pred16_t vcmpgeq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s32)))
+mve_pred16_t vcmpgeq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s8)))
+mve_pred16_t vcmpgeq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_s8)))
+mve_pred16_t vcmpgeq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s16)))
+mve_pred16_t vcmpgeq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s16)))
+mve_pred16_t vcmpgeq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s32)))
+mve_pred16_t vcmpgeq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s32)))
+mve_pred16_t vcmpgeq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s8)))
+mve_pred16_t vcmpgeq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_s8)))
+mve_pred16_t vcmpgeq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s16)))
+mve_pred16_t vcmpgtq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s16)))
+mve_pred16_t vcmpgtq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s32)))
+mve_pred16_t vcmpgtq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s32)))
+mve_pred16_t vcmpgtq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s8)))
+mve_pred16_t vcmpgtq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_s8)))
+mve_pred16_t vcmpgtq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s16)))
+mve_pred16_t vcmpgtq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s16)))
+mve_pred16_t vcmpgtq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s32)))
+mve_pred16_t vcmpgtq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s32)))
+mve_pred16_t vcmpgtq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s8)))
+mve_pred16_t vcmpgtq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_s8)))
+mve_pred16_t vcmpgtq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s16)))
+mve_pred16_t vcmpgtq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s16)))
+mve_pred16_t vcmpgtq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s32)))
+mve_pred16_t vcmpgtq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s32)))
+mve_pred16_t vcmpgtq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s8)))
+mve_pred16_t vcmpgtq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_s8)))
+mve_pred16_t vcmpgtq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s16)))
+mve_pred16_t vcmpgtq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s16)))
+mve_pred16_t vcmpgtq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s32)))
+mve_pred16_t vcmpgtq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s32)))
+mve_pred16_t vcmpgtq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s8)))
+mve_pred16_t vcmpgtq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_s8)))
+mve_pred16_t vcmpgtq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u16)))
+mve_pred16_t vcmphiq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u16)))
+mve_pred16_t vcmphiq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u32)))
+mve_pred16_t vcmphiq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u32)))
+mve_pred16_t vcmphiq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u8)))
+mve_pred16_t vcmphiq_m_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_n_u8)))
+mve_pred16_t vcmphiq_m(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u16)))
+mve_pred16_t vcmphiq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u16)))
+mve_pred16_t vcmphiq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u32)))
+mve_pred16_t vcmphiq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u32)))
+mve_pred16_t vcmphiq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u8)))
+mve_pred16_t vcmphiq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_m_u8)))
+mve_pred16_t vcmphiq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u16)))
+mve_pred16_t vcmphiq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u16)))
+mve_pred16_t vcmphiq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u32)))
+mve_pred16_t vcmphiq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u32)))
+mve_pred16_t vcmphiq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u8)))
+mve_pred16_t vcmphiq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_n_u8)))
+mve_pred16_t vcmphiq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u16)))
+mve_pred16_t vcmphiq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u16)))
+mve_pred16_t vcmphiq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u32)))
+mve_pred16_t vcmphiq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u32)))
+mve_pred16_t vcmphiq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u8)))
+mve_pred16_t vcmphiq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmphiq_u8)))
+mve_pred16_t vcmphiq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s16)))
+mve_pred16_t vcmpleq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s16)))
+mve_pred16_t vcmpleq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s32)))
+mve_pred16_t vcmpleq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s32)))
+mve_pred16_t vcmpleq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s8)))
+mve_pred16_t vcmpleq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_s8)))
+mve_pred16_t vcmpleq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s16)))
+mve_pred16_t vcmpleq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s16)))
+mve_pred16_t vcmpleq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s32)))
+mve_pred16_t vcmpleq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s32)))
+mve_pred16_t vcmpleq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s8)))
+mve_pred16_t vcmpleq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_s8)))
+mve_pred16_t vcmpleq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s16)))
+mve_pred16_t vcmpleq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s16)))
+mve_pred16_t vcmpleq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s32)))
+mve_pred16_t vcmpleq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s32)))
+mve_pred16_t vcmpleq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s8)))
+mve_pred16_t vcmpleq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_s8)))
+mve_pred16_t vcmpleq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s16)))
+mve_pred16_t vcmpleq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s16)))
+mve_pred16_t vcmpleq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s32)))
+mve_pred16_t vcmpleq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s32)))
+mve_pred16_t vcmpleq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s8)))
+mve_pred16_t vcmpleq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_s8)))
+mve_pred16_t vcmpleq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s16)))
+mve_pred16_t vcmpltq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s16)))
+mve_pred16_t vcmpltq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s32)))
+mve_pred16_t vcmpltq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s32)))
+mve_pred16_t vcmpltq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s8)))
+mve_pred16_t vcmpltq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_s8)))
+mve_pred16_t vcmpltq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s16)))
+mve_pred16_t vcmpltq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s16)))
+mve_pred16_t vcmpltq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s32)))
+mve_pred16_t vcmpltq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s32)))
+mve_pred16_t vcmpltq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s8)))
+mve_pred16_t vcmpltq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_s8)))
+mve_pred16_t vcmpltq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s16)))
+mve_pred16_t vcmpltq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s16)))
+mve_pred16_t vcmpltq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s32)))
+mve_pred16_t vcmpltq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s32)))
+mve_pred16_t vcmpltq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s8)))
+mve_pred16_t vcmpltq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_s8)))
+mve_pred16_t vcmpltq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s16)))
+mve_pred16_t vcmpltq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s16)))
+mve_pred16_t vcmpltq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s32)))
+mve_pred16_t vcmpltq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s32)))
+mve_pred16_t vcmpltq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s8)))
+mve_pred16_t vcmpltq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_s8)))
+mve_pred16_t vcmpltq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s16)))
+mve_pred16_t vcmpneq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s16)))
+mve_pred16_t vcmpneq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s32)))
+mve_pred16_t vcmpneq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s32)))
+mve_pred16_t vcmpneq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s8)))
+mve_pred16_t vcmpneq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_s8)))
+mve_pred16_t vcmpneq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u16)))
+mve_pred16_t vcmpneq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u16)))
+mve_pred16_t vcmpneq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u32)))
+mve_pred16_t vcmpneq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u32)))
+mve_pred16_t vcmpneq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u8)))
+mve_pred16_t vcmpneq_m_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_u8)))
+mve_pred16_t vcmpneq_m(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s16)))
+mve_pred16_t vcmpneq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s16)))
+mve_pred16_t vcmpneq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s32)))
+mve_pred16_t vcmpneq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s32)))
+mve_pred16_t vcmpneq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s8)))
+mve_pred16_t vcmpneq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_s8)))
+mve_pred16_t vcmpneq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u16)))
+mve_pred16_t vcmpneq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u16)))
+mve_pred16_t vcmpneq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u32)))
+mve_pred16_t vcmpneq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u32)))
+mve_pred16_t vcmpneq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u8)))
+mve_pred16_t vcmpneq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_u8)))
+mve_pred16_t vcmpneq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s16)))
+mve_pred16_t vcmpneq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s16)))
+mve_pred16_t vcmpneq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s32)))
+mve_pred16_t vcmpneq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s32)))
+mve_pred16_t vcmpneq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s8)))
+mve_pred16_t vcmpneq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_s8)))
+mve_pred16_t vcmpneq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u16)))
+mve_pred16_t vcmpneq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u16)))
+mve_pred16_t vcmpneq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u32)))
+mve_pred16_t vcmpneq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u32)))
+mve_pred16_t vcmpneq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u8)))
+mve_pred16_t vcmpneq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_u8)))
+mve_pred16_t vcmpneq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s16)))
+mve_pred16_t vcmpneq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s16)))
+mve_pred16_t vcmpneq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s32)))
+mve_pred16_t vcmpneq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s32)))
+mve_pred16_t vcmpneq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s8)))
+mve_pred16_t vcmpneq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_s8)))
+mve_pred16_t vcmpneq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u16)))
+mve_pred16_t vcmpneq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u16)))
+mve_pred16_t vcmpneq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u32)))
+mve_pred16_t vcmpneq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u32)))
+mve_pred16_t vcmpneq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u8)))
+mve_pred16_t vcmpneq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_u8)))
+mve_pred16_t vcmpneq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_s16)))
+int16x8_t vcreateq_s16(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_s32)))
+int32x4_t vcreateq_s32(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_s64)))
+int64x2_t vcreateq_s64(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_s8)))
+int8x16_t vcreateq_s8(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_u16)))
+uint16x8_t vcreateq_u16(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_u32)))
+uint32x4_t vcreateq_u32(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_u64)))
+uint64x2_t vcreateq_u64(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_u8)))
+uint8x16_t vcreateq_u8(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp16q)))
+mve_pred16_t vctp16q(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp16q_m)))
+mve_pred16_t vctp16q_m(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp32q)))
+mve_pred16_t vctp32q(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp32q_m)))
+mve_pred16_t vctp32q_m(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp64q)))
+mve_pred16_t vctp64q(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp64q_m)))
+mve_pred16_t vctp64q_m(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp8q)))
+mve_pred16_t vctp8q(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vctp8q_m)))
+mve_pred16_t vctp8q_m(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u16)))
+uint16x8_t vddupq_m_n_u16(uint16x8_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u16)))
+uint16x8_t vddupq_m(uint16x8_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u32)))
+uint32x4_t vddupq_m_n_u32(uint32x4_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u32)))
+uint32x4_t vddupq_m(uint32x4_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u8)))
+uint8x16_t vddupq_m_n_u8(uint8x16_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_n_u8)))
+uint8x16_t vddupq_m(uint8x16_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u16)))
+uint16x8_t vddupq_m_wb_u16(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u16)))
+uint16x8_t vddupq_m(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u32)))
+uint32x4_t vddupq_m_wb_u32(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u32)))
+uint32x4_t vddupq_m(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u8)))
+uint8x16_t vddupq_m_wb_u8(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_m_wb_u8)))
+uint8x16_t vddupq_m(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u16)))
+uint16x8_t vddupq_n_u16(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u16)))
+uint16x8_t vddupq_u16(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u32)))
+uint32x4_t vddupq_n_u32(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u32)))
+uint32x4_t vddupq_u32(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u8)))
+uint8x16_t vddupq_n_u8(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_n_u8)))
+uint8x16_t vddupq_u8(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u16)))
+uint16x8_t vddupq_wb_u16(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u16)))
+uint16x8_t vddupq_u16(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u32)))
+uint32x4_t vddupq_wb_u32(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u32)))
+uint32x4_t vddupq_u32(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u8)))
+uint8x16_t vddupq_wb_u8(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_wb_u8)))
+uint8x16_t vddupq_u8(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u16)))
+uint16x8_t vddupq_x_n_u16(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u16)))
+uint16x8_t vddupq_x_u16(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u32)))
+uint32x4_t vddupq_x_n_u32(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u32)))
+uint32x4_t vddupq_x_u32(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u8)))
+uint8x16_t vddupq_x_n_u8(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_n_u8)))
+uint8x16_t vddupq_x_u8(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u16)))
+uint16x8_t vddupq_x_wb_u16(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u16)))
+uint16x8_t vddupq_x_u16(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u32)))
+uint32x4_t vddupq_x_wb_u32(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u32)))
+uint32x4_t vddupq_x_u32(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u8)))
+uint8x16_t vddupq_x_wb_u8(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vddupq_x_wb_u8)))
+uint8x16_t vddupq_x_u8(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s16)))
+int16x8_t vdupq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s16)))
+int16x8_t vdupq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s32)))
+int32x4_t vdupq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s32)))
+int32x4_t vdupq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s8)))
+int8x16_t vdupq_m_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_s8)))
+int8x16_t vdupq_m(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u16)))
+uint16x8_t vdupq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u16)))
+uint16x8_t vdupq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u32)))
+uint32x4_t vdupq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u32)))
+uint32x4_t vdupq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u8)))
+uint8x16_t vdupq_m_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_u8)))
+uint8x16_t vdupq_m(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_s16)))
+int16x8_t vdupq_n_s16(int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_s32)))
+int32x4_t vdupq_n_s32(int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_s8)))
+int8x16_t vdupq_n_s8(int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_u16)))
+uint16x8_t vdupq_n_u16(uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_u32)))
+uint32x4_t vdupq_n_u32(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_u8)))
+uint8x16_t vdupq_n_u8(uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_s16)))
+int16x8_t vdupq_x_n_s16(int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_s32)))
+int32x4_t vdupq_x_n_s32(int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_s8)))
+int8x16_t vdupq_x_n_s8(int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_u16)))
+uint16x8_t vdupq_x_n_u16(uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_u32)))
+uint32x4_t vdupq_x_n_u32(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_u8)))
+uint8x16_t vdupq_x_n_u8(uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u16)))
+uint16x8_t vdwdupq_m_n_u16(uint16x8_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u16)))
+uint16x8_t vdwdupq_m(uint16x8_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u32)))
+uint32x4_t vdwdupq_m_n_u32(uint32x4_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u32)))
+uint32x4_t vdwdupq_m(uint32x4_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u8)))
+uint8x16_t vdwdupq_m_n_u8(uint8x16_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_n_u8)))
+uint8x16_t vdwdupq_m(uint8x16_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u16)))
+uint16x8_t vdwdupq_m_wb_u16(uint16x8_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u16)))
+uint16x8_t vdwdupq_m(uint16x8_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u32)))
+uint32x4_t vdwdupq_m_wb_u32(uint32x4_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u32)))
+uint32x4_t vdwdupq_m(uint32x4_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u8)))
+uint8x16_t vdwdupq_m_wb_u8(uint8x16_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_m_wb_u8)))
+uint8x16_t vdwdupq_m(uint8x16_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u16)))
+uint16x8_t vdwdupq_n_u16(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u16)))
+uint16x8_t vdwdupq_u16(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u32)))
+uint32x4_t vdwdupq_n_u32(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u32)))
+uint32x4_t vdwdupq_u32(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u8)))
+uint8x16_t vdwdupq_n_u8(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_n_u8)))
+uint8x16_t vdwdupq_u8(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u16)))
+uint16x8_t vdwdupq_wb_u16(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u16)))
+uint16x8_t vdwdupq_u16(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u32)))
+uint32x4_t vdwdupq_wb_u32(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u32)))
+uint32x4_t vdwdupq_u32(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u8)))
+uint8x16_t vdwdupq_wb_u8(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_wb_u8)))
+uint8x16_t vdwdupq_u8(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u16)))
+uint16x8_t vdwdupq_x_n_u16(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u16)))
+uint16x8_t vdwdupq_x_u16(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u32)))
+uint32x4_t vdwdupq_x_n_u32(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u32)))
+uint32x4_t vdwdupq_x_u32(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u8)))
+uint8x16_t vdwdupq_x_n_u8(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_n_u8)))
+uint8x16_t vdwdupq_x_u8(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u16)))
+uint16x8_t vdwdupq_x_wb_u16(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u16)))
+uint16x8_t vdwdupq_x_u16(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u32)))
+uint32x4_t vdwdupq_x_wb_u32(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u32)))
+uint32x4_t vdwdupq_x_u32(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u8)))
+uint8x16_t vdwdupq_x_wb_u8(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdwdupq_x_wb_u8)))
+uint8x16_t vdwdupq_x_u8(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s16)))
+int16x8_t veorq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s16)))
+int16x8_t veorq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s32)))
+int32x4_t veorq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s32)))
+int32x4_t veorq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s8)))
+int8x16_t veorq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_s8)))
+int8x16_t veorq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u16)))
+uint16x8_t veorq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u16)))
+uint16x8_t veorq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u32)))
+uint32x4_t veorq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u32)))
+uint32x4_t veorq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u8)))
+uint8x16_t veorq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_u8)))
+uint8x16_t veorq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_s16)))
+int16x8_t veorq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_s16)))
+int16x8_t veorq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_s32)))
+int32x4_t veorq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_s32)))
+int32x4_t veorq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_s8)))
+int8x16_t veorq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_s8)))
+int8x16_t veorq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_u16)))
+uint16x8_t veorq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_u16)))
+uint16x8_t veorq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_u32)))
+uint32x4_t veorq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_u32)))
+uint32x4_t veorq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_u8)))
+uint8x16_t veorq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_u8)))
+uint8x16_t veorq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s16)))
+int16x8_t veorq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s16)))
+int16x8_t veorq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s32)))
+int32x4_t veorq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s32)))
+int32x4_t veorq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s8)))
+int8x16_t veorq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_s8)))
+int8x16_t veorq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u16)))
+uint16x8_t veorq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u16)))
+uint16x8_t veorq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u32)))
+uint32x4_t veorq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u32)))
+uint32x4_t veorq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u8)))
+uint8x16_t veorq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_u8)))
+uint8x16_t veorq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s16)))
+int16_t vgetq_lane_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s16)))
+int16_t vgetq_lane(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s32)))
+int32_t vgetq_lane_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s32)))
+int32_t vgetq_lane(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s64)))
+int64_t vgetq_lane_s64(int64x2_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s64)))
+int64_t vgetq_lane(int64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s8)))
+int8_t vgetq_lane_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_s8)))
+int8_t vgetq_lane(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u16)))
+uint16_t vgetq_lane_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u16)))
+uint16_t vgetq_lane(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u32)))
+uint32_t vgetq_lane_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u32)))
+uint32_t vgetq_lane(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u64)))
+uint64_t vgetq_lane_u64(uint64x2_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u64)))
+uint64_t vgetq_lane(uint64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u8)))
+uint8_t vgetq_lane_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_u8)))
+uint8_t vgetq_lane(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s16)))
+int16x8_t vhaddq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s16)))
+int16x8_t vhaddq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s32)))
+int32x4_t vhaddq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s32)))
+int32x4_t vhaddq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s8)))
+int8x16_t vhaddq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_s8)))
+int8x16_t vhaddq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u16)))
+uint16x8_t vhaddq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u16)))
+uint16x8_t vhaddq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u32)))
+uint32x4_t vhaddq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u32)))
+uint32x4_t vhaddq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u8)))
+uint8x16_t vhaddq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_n_u8)))
+uint8x16_t vhaddq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s16)))
+int16x8_t vhaddq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s16)))
+int16x8_t vhaddq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s32)))
+int32x4_t vhaddq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s32)))
+int32x4_t vhaddq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s8)))
+int8x16_t vhaddq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_s8)))
+int8x16_t vhaddq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u16)))
+uint16x8_t vhaddq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u16)))
+uint16x8_t vhaddq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u32)))
+uint32x4_t vhaddq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u32)))
+uint32x4_t vhaddq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u8)))
+uint8x16_t vhaddq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_m_u8)))
+uint8x16_t vhaddq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s16)))
+int16x8_t vhaddq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s16)))
+int16x8_t vhaddq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s32)))
+int32x4_t vhaddq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s32)))
+int32x4_t vhaddq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s8)))
+int8x16_t vhaddq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_s8)))
+int8x16_t vhaddq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u16)))
+uint16x8_t vhaddq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u16)))
+uint16x8_t vhaddq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u32)))
+uint32x4_t vhaddq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u32)))
+uint32x4_t vhaddq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u8)))
+uint8x16_t vhaddq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_n_u8)))
+uint8x16_t vhaddq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s16)))
+int16x8_t vhaddq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s16)))
+int16x8_t vhaddq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s32)))
+int32x4_t vhaddq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s32)))
+int32x4_t vhaddq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s8)))
+int8x16_t vhaddq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_s8)))
+int8x16_t vhaddq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u16)))
+uint16x8_t vhaddq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u16)))
+uint16x8_t vhaddq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u32)))
+uint32x4_t vhaddq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u32)))
+uint32x4_t vhaddq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u8)))
+uint8x16_t vhaddq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_u8)))
+uint8x16_t vhaddq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s16)))
+int16x8_t vhaddq_x_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s16)))
+int16x8_t vhaddq_x(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s32)))
+int32x4_t vhaddq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s32)))
+int32x4_t vhaddq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s8)))
+int8x16_t vhaddq_x_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_s8)))
+int8x16_t vhaddq_x(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u16)))
+uint16x8_t vhaddq_x_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u16)))
+uint16x8_t vhaddq_x(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u32)))
+uint32x4_t vhaddq_x_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u32)))
+uint32x4_t vhaddq_x(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u8)))
+uint8x16_t vhaddq_x_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_n_u8)))
+uint8x16_t vhaddq_x(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s16)))
+int16x8_t vhaddq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s16)))
+int16x8_t vhaddq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s32)))
+int32x4_t vhaddq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s32)))
+int32x4_t vhaddq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s8)))
+int8x16_t vhaddq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_s8)))
+int8x16_t vhaddq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u16)))
+uint16x8_t vhaddq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u16)))
+uint16x8_t vhaddq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u32)))
+uint32x4_t vhaddq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u32)))
+uint32x4_t vhaddq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u8)))
+uint8x16_t vhaddq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhaddq_x_u8)))
+uint8x16_t vhaddq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s16)))
+int16x8_t vhcaddq_rot270_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s16)))
+int16x8_t vhcaddq_rot270_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s32)))
+int32x4_t vhcaddq_rot270_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s32)))
+int32x4_t vhcaddq_rot270_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s8)))
+int8x16_t vhcaddq_rot270_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_m_s8)))
+int8x16_t vhcaddq_rot270_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s16)))
+int16x8_t vhcaddq_rot270_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s16)))
+int16x8_t vhcaddq_rot270(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s32)))
+int32x4_t vhcaddq_rot270_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s32)))
+int32x4_t vhcaddq_rot270(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s8)))
+int8x16_t vhcaddq_rot270_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_s8)))
+int8x16_t vhcaddq_rot270(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s16)))
+int16x8_t vhcaddq_rot270_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s16)))
+int16x8_t vhcaddq_rot270_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s32)))
+int32x4_t vhcaddq_rot270_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s32)))
+int32x4_t vhcaddq_rot270_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s8)))
+int8x16_t vhcaddq_rot270_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot270_x_s8)))
+int8x16_t vhcaddq_rot270_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s16)))
+int16x8_t vhcaddq_rot90_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s16)))
+int16x8_t vhcaddq_rot90_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s32)))
+int32x4_t vhcaddq_rot90_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s32)))
+int32x4_t vhcaddq_rot90_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s8)))
+int8x16_t vhcaddq_rot90_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_m_s8)))
+int8x16_t vhcaddq_rot90_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s16)))
+int16x8_t vhcaddq_rot90_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s16)))
+int16x8_t vhcaddq_rot90(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s32)))
+int32x4_t vhcaddq_rot90_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s32)))
+int32x4_t vhcaddq_rot90(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s8)))
+int8x16_t vhcaddq_rot90_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_s8)))
+int8x16_t vhcaddq_rot90(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s16)))
+int16x8_t vhcaddq_rot90_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s16)))
+int16x8_t vhcaddq_rot90_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s32)))
+int32x4_t vhcaddq_rot90_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s32)))
+int32x4_t vhcaddq_rot90_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s8)))
+int8x16_t vhcaddq_rot90_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhcaddq_rot90_x_s8)))
+int8x16_t vhcaddq_rot90_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s16)))
+int16x8_t vhsubq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s16)))
+int16x8_t vhsubq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s32)))
+int32x4_t vhsubq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s32)))
+int32x4_t vhsubq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s8)))
+int8x16_t vhsubq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_s8)))
+int8x16_t vhsubq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u16)))
+uint16x8_t vhsubq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u16)))
+uint16x8_t vhsubq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u32)))
+uint32x4_t vhsubq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u32)))
+uint32x4_t vhsubq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u8)))
+uint8x16_t vhsubq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_n_u8)))
+uint8x16_t vhsubq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s16)))
+int16x8_t vhsubq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s16)))
+int16x8_t vhsubq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s32)))
+int32x4_t vhsubq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s32)))
+int32x4_t vhsubq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s8)))
+int8x16_t vhsubq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_s8)))
+int8x16_t vhsubq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u16)))
+uint16x8_t vhsubq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u16)))
+uint16x8_t vhsubq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u32)))
+uint32x4_t vhsubq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u32)))
+uint32x4_t vhsubq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u8)))
+uint8x16_t vhsubq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_m_u8)))
+uint8x16_t vhsubq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s16)))
+int16x8_t vhsubq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s16)))
+int16x8_t vhsubq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s32)))
+int32x4_t vhsubq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s32)))
+int32x4_t vhsubq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s8)))
+int8x16_t vhsubq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_s8)))
+int8x16_t vhsubq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u16)))
+uint16x8_t vhsubq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u16)))
+uint16x8_t vhsubq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u32)))
+uint32x4_t vhsubq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u32)))
+uint32x4_t vhsubq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u8)))
+uint8x16_t vhsubq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_n_u8)))
+uint8x16_t vhsubq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s16)))
+int16x8_t vhsubq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s16)))
+int16x8_t vhsubq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s32)))
+int32x4_t vhsubq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s32)))
+int32x4_t vhsubq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s8)))
+int8x16_t vhsubq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_s8)))
+int8x16_t vhsubq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u16)))
+uint16x8_t vhsubq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u16)))
+uint16x8_t vhsubq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u32)))
+uint32x4_t vhsubq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u32)))
+uint32x4_t vhsubq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u8)))
+uint8x16_t vhsubq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_u8)))
+uint8x16_t vhsubq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s16)))
+int16x8_t vhsubq_x_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s16)))
+int16x8_t vhsubq_x(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s32)))
+int32x4_t vhsubq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s32)))
+int32x4_t vhsubq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s8)))
+int8x16_t vhsubq_x_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_s8)))
+int8x16_t vhsubq_x(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u16)))
+uint16x8_t vhsubq_x_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u16)))
+uint16x8_t vhsubq_x(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u32)))
+uint32x4_t vhsubq_x_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u32)))
+uint32x4_t vhsubq_x(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u8)))
+uint8x16_t vhsubq_x_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_n_u8)))
+uint8x16_t vhsubq_x(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s16)))
+int16x8_t vhsubq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s16)))
+int16x8_t vhsubq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s32)))
+int32x4_t vhsubq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s32)))
+int32x4_t vhsubq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s8)))
+int8x16_t vhsubq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_s8)))
+int8x16_t vhsubq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u16)))
+uint16x8_t vhsubq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u16)))
+uint16x8_t vhsubq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u32)))
+uint32x4_t vhsubq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u32)))
+uint32x4_t vhsubq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u8)))
+uint8x16_t vhsubq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vhsubq_x_u8)))
+uint8x16_t vhsubq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u16)))
+uint16x8_t vidupq_m_n_u16(uint16x8_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u16)))
+uint16x8_t vidupq_m(uint16x8_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u32)))
+uint32x4_t vidupq_m_n_u32(uint32x4_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u32)))
+uint32x4_t vidupq_m(uint32x4_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u8)))
+uint8x16_t vidupq_m_n_u8(uint8x16_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_n_u8)))
+uint8x16_t vidupq_m(uint8x16_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u16)))
+uint16x8_t vidupq_m_wb_u16(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u16)))
+uint16x8_t vidupq_m(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u32)))
+uint32x4_t vidupq_m_wb_u32(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u32)))
+uint32x4_t vidupq_m(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u8)))
+uint8x16_t vidupq_m_wb_u8(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_m_wb_u8)))
+uint8x16_t vidupq_m(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u16)))
+uint16x8_t vidupq_n_u16(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u16)))
+uint16x8_t vidupq_u16(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u32)))
+uint32x4_t vidupq_n_u32(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u32)))
+uint32x4_t vidupq_u32(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u8)))
+uint8x16_t vidupq_n_u8(uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_n_u8)))
+uint8x16_t vidupq_u8(uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u16)))
+uint16x8_t vidupq_wb_u16(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u16)))
+uint16x8_t vidupq_u16(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u32)))
+uint32x4_t vidupq_wb_u32(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u32)))
+uint32x4_t vidupq_u32(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u8)))
+uint8x16_t vidupq_wb_u8(uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_wb_u8)))
+uint8x16_t vidupq_u8(uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u16)))
+uint16x8_t vidupq_x_n_u16(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u16)))
+uint16x8_t vidupq_x_u16(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u32)))
+uint32x4_t vidupq_x_n_u32(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u32)))
+uint32x4_t vidupq_x_u32(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u8)))
+uint8x16_t vidupq_x_n_u8(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_n_u8)))
+uint8x16_t vidupq_x_u8(uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u16)))
+uint16x8_t vidupq_x_wb_u16(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u16)))
+uint16x8_t vidupq_x_u16(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u32)))
+uint32x4_t vidupq_x_wb_u32(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u32)))
+uint32x4_t vidupq_x_u32(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u8)))
+uint8x16_t vidupq_x_wb_u8(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vidupq_x_wb_u8)))
+uint8x16_t vidupq_x_u8(uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u16)))
+uint16x8_t viwdupq_m_n_u16(uint16x8_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u16)))
+uint16x8_t viwdupq_m(uint16x8_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u32)))
+uint32x4_t viwdupq_m_n_u32(uint32x4_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u32)))
+uint32x4_t viwdupq_m(uint32x4_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u8)))
+uint8x16_t viwdupq_m_n_u8(uint8x16_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_n_u8)))
+uint8x16_t viwdupq_m(uint8x16_t, uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u16)))
+uint16x8_t viwdupq_m_wb_u16(uint16x8_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u16)))
+uint16x8_t viwdupq_m(uint16x8_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u32)))
+uint32x4_t viwdupq_m_wb_u32(uint32x4_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u32)))
+uint32x4_t viwdupq_m(uint32x4_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u8)))
+uint8x16_t viwdupq_m_wb_u8(uint8x16_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_m_wb_u8)))
+uint8x16_t viwdupq_m(uint8x16_t, uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u16)))
+uint16x8_t viwdupq_n_u16(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u16)))
+uint16x8_t viwdupq_u16(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u32)))
+uint32x4_t viwdupq_n_u32(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u32)))
+uint32x4_t viwdupq_u32(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u8)))
+uint8x16_t viwdupq_n_u8(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_n_u8)))
+uint8x16_t viwdupq_u8(uint32_t, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u16)))
+uint16x8_t viwdupq_wb_u16(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u16)))
+uint16x8_t viwdupq_u16(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u32)))
+uint32x4_t viwdupq_wb_u32(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u32)))
+uint32x4_t viwdupq_u32(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u8)))
+uint8x16_t viwdupq_wb_u8(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_wb_u8)))
+uint8x16_t viwdupq_u8(uint32_t *, uint32_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u16)))
+uint16x8_t viwdupq_x_n_u16(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u16)))
+uint16x8_t viwdupq_x_u16(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u32)))
+uint32x4_t viwdupq_x_n_u32(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u32)))
+uint32x4_t viwdupq_x_u32(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u8)))
+uint8x16_t viwdupq_x_n_u8(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_n_u8)))
+uint8x16_t viwdupq_x_u8(uint32_t, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u16)))
+uint16x8_t viwdupq_x_wb_u16(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u16)))
+uint16x8_t viwdupq_x_u16(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u32)))
+uint32x4_t viwdupq_x_wb_u32(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u32)))
+uint32x4_t viwdupq_x_u32(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u8)))
+uint8x16_t viwdupq_x_wb_u8(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_viwdupq_x_wb_u8)))
+uint8x16_t viwdupq_x_u8(uint32_t *, uint32_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s16)))
+int16x8_t vld1q_s16(const int16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s16)))
+int16x8_t vld1q(const int16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s32)))
+int32x4_t vld1q_s32(const int32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s32)))
+int32x4_t vld1q(const int32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s8)))
+int8x16_t vld1q_s8(const int8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_s8)))
+int8x16_t vld1q(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u16)))
+uint16x8_t vld1q_u16(const uint16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u16)))
+uint16x8_t vld1q(const uint16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u32)))
+uint32x4_t vld1q_u32(const uint32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u32)))
+uint32x4_t vld1q(const uint32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u8)))
+uint8x16_t vld1q_u8(const uint8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_u8)))
+uint8x16_t vld1q(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s16)))
+int16x8_t vld1q_z_s16(const int16_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s16)))
+int16x8_t vld1q_z(const int16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s32)))
+int32x4_t vld1q_z_s32(const int32_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s32)))
+int32x4_t vld1q_z(const int32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s8)))
+int8x16_t vld1q_z_s8(const int8_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_s8)))
+int8x16_t vld1q_z(const int8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u16)))
+uint16x8_t vld1q_z_u16(const uint16_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u16)))
+uint16x8_t vld1q_z(const uint16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u32)))
+uint32x4_t vld1q_z_u32(const uint32_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u32)))
+uint32x4_t vld1q_z(const uint32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u8)))
+uint8x16_t vld1q_z_u8(const uint8_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_u8)))
+uint8x16_t vld1q_z(const uint8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s16)))
+int16x8x2_t vld2q_s16(const int16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s16)))
+int16x8x2_t vld2q(const int16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s32)))
+int32x4x2_t vld2q_s32(const int32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s32)))
+int32x4x2_t vld2q(const int32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s8)))
+int8x16x2_t vld2q_s8(const int8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_s8)))
+int8x16x2_t vld2q(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u16)))
+uint16x8x2_t vld2q_u16(const uint16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u16)))
+uint16x8x2_t vld2q(const uint16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u32)))
+uint32x4x2_t vld2q_u32(const uint32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u32)))
+uint32x4x2_t vld2q(const uint32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u8)))
+uint8x16x2_t vld2q_u8(const uint8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_u8)))
+uint8x16x2_t vld2q(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s16)))
+int16x8x4_t vld4q_s16(const int16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s16)))
+int16x8x4_t vld4q(const int16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s32)))
+int32x4x4_t vld4q_s32(const int32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s32)))
+int32x4x4_t vld4q(const int32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s8)))
+int8x16x4_t vld4q_s8(const int8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_s8)))
+int8x16x4_t vld4q(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u16)))
+uint16x8x4_t vld4q_u16(const uint16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u16)))
+uint16x8x4_t vld4q(const uint16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u32)))
+uint32x4x4_t vld4q_u32(const uint32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u32)))
+uint32x4x4_t vld4q(const uint32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u8)))
+uint8x16x4_t vld4q_u8(const uint8_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_u8)))
+uint8x16x4_t vld4q(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s16)))
+int16x8_t vldrbq_gather_offset_s16(const int8_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s16)))
+int16x8_t vldrbq_gather_offset(const int8_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s32)))
+int32x4_t vldrbq_gather_offset_s32(const int8_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s32)))
+int32x4_t vldrbq_gather_offset(const int8_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s8)))
+int8x16_t vldrbq_gather_offset_s8(const int8_t *, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_s8)))
+int8x16_t vldrbq_gather_offset(const int8_t *, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u16)))
+uint16x8_t vldrbq_gather_offset_u16(const uint8_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u16)))
+uint16x8_t vldrbq_gather_offset(const uint8_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u32)))
+uint32x4_t vldrbq_gather_offset_u32(const uint8_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u32)))
+uint32x4_t vldrbq_gather_offset(const uint8_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u8)))
+uint8x16_t vldrbq_gather_offset_u8(const uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_u8)))
+uint8x16_t vldrbq_gather_offset(const uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s16)))
+int16x8_t vldrbq_gather_offset_z_s16(const int8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s16)))
+int16x8_t vldrbq_gather_offset_z(const int8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s32)))
+int32x4_t vldrbq_gather_offset_z_s32(const int8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s32)))
+int32x4_t vldrbq_gather_offset_z(const int8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s8)))
+int8x16_t vldrbq_gather_offset_z_s8(const int8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_s8)))
+int8x16_t vldrbq_gather_offset_z(const int8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u16)))
+uint16x8_t vldrbq_gather_offset_z_u16(const uint8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u16)))
+uint16x8_t vldrbq_gather_offset_z(const uint8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u32)))
+uint32x4_t vldrbq_gather_offset_z_u32(const uint8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u32)))
+uint32x4_t vldrbq_gather_offset_z(const uint8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u8)))
+uint8x16_t vldrbq_gather_offset_z_u8(const uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_gather_offset_z_u8)))
+uint8x16_t vldrbq_gather_offset_z(const uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_s16)))
+int16x8_t vldrbq_s16(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_s32)))
+int32x4_t vldrbq_s32(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_s8)))
+int8x16_t vldrbq_s8(const int8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_u16)))
+uint16x8_t vldrbq_u16(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_u32)))
+uint32x4_t vldrbq_u32(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_u8)))
+uint8x16_t vldrbq_u8(const uint8_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_s16)))
+int16x8_t vldrbq_z_s16(const int8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_s32)))
+int32x4_t vldrbq_z_s32(const int8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_s8)))
+int8x16_t vldrbq_z_s8(const int8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_u16)))
+uint16x8_t vldrbq_z_u16(const uint8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_u32)))
+uint32x4_t vldrbq_z_u32(const uint8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrbq_z_u8)))
+uint8x16_t vldrbq_z_u8(const uint8_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_s64)))
+int64x2_t vldrdq_gather_base_s64(uint64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_u64)))
+uint64x2_t vldrdq_gather_base_u64(uint64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_wb_s64)))
+int64x2_t vldrdq_gather_base_wb_s64(uint64x2_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_wb_u64)))
+uint64x2_t vldrdq_gather_base_wb_u64(uint64x2_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_wb_z_s64)))
+int64x2_t vldrdq_gather_base_wb_z_s64(uint64x2_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_wb_z_u64)))
+uint64x2_t vldrdq_gather_base_wb_z_u64(uint64x2_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_z_s64)))
+int64x2_t vldrdq_gather_base_z_s64(uint64x2_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_base_z_u64)))
+uint64x2_t vldrdq_gather_base_z_u64(uint64x2_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_s64)))
+int64x2_t vldrdq_gather_offset_s64(const int64_t *, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_s64)))
+int64x2_t vldrdq_gather_offset(const int64_t *, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_u64)))
+uint64x2_t vldrdq_gather_offset_u64(const uint64_t *, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_u64)))
+uint64x2_t vldrdq_gather_offset(const uint64_t *, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_z_s64)))
+int64x2_t vldrdq_gather_offset_z_s64(const int64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_z_s64)))
+int64x2_t vldrdq_gather_offset_z(const int64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_z_u64)))
+uint64x2_t vldrdq_gather_offset_z_u64(const uint64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_offset_z_u64)))
+uint64x2_t vldrdq_gather_offset_z(const uint64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_s64)))
+int64x2_t vldrdq_gather_shifted_offset_s64(const int64_t *, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_s64)))
+int64x2_t vldrdq_gather_shifted_offset(const int64_t *, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_u64)))
+uint64x2_t vldrdq_gather_shifted_offset_u64(const uint64_t *, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_u64)))
+uint64x2_t vldrdq_gather_shifted_offset(const uint64_t *, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_z_s64)))
+int64x2_t vldrdq_gather_shifted_offset_z_s64(const int64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_z_s64)))
+int64x2_t vldrdq_gather_shifted_offset_z(const int64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_z_u64)))
+uint64x2_t vldrdq_gather_shifted_offset_z_u64(const uint64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrdq_gather_shifted_offset_z_u64)))
+uint64x2_t vldrdq_gather_shifted_offset_z(const uint64_t *, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_s16)))
+int16x8_t vldrhq_gather_offset_s16(const int16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_s16)))
+int16x8_t vldrhq_gather_offset(const int16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_s32)))
+int32x4_t vldrhq_gather_offset_s32(const int16_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_s32)))
+int32x4_t vldrhq_gather_offset(const int16_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_u16)))
+uint16x8_t vldrhq_gather_offset_u16(const uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_u16)))
+uint16x8_t vldrhq_gather_offset(const uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_u32)))
+uint32x4_t vldrhq_gather_offset_u32(const uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_u32)))
+uint32x4_t vldrhq_gather_offset(const uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_s16)))
+int16x8_t vldrhq_gather_offset_z_s16(const int16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_s16)))
+int16x8_t vldrhq_gather_offset_z(const int16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_s32)))
+int32x4_t vldrhq_gather_offset_z_s32(const int16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_s32)))
+int32x4_t vldrhq_gather_offset_z(const int16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_u16)))
+uint16x8_t vldrhq_gather_offset_z_u16(const uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_u16)))
+uint16x8_t vldrhq_gather_offset_z(const uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_u32)))
+uint32x4_t vldrhq_gather_offset_z_u32(const uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_u32)))
+uint32x4_t vldrhq_gather_offset_z(const uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_s16)))
+int16x8_t vldrhq_gather_shifted_offset_s16(const int16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_s16)))
+int16x8_t vldrhq_gather_shifted_offset(const int16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_s32)))
+int32x4_t vldrhq_gather_shifted_offset_s32(const int16_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_s32)))
+int32x4_t vldrhq_gather_shifted_offset(const int16_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_u16)))
+uint16x8_t vldrhq_gather_shifted_offset_u16(const uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_u16)))
+uint16x8_t vldrhq_gather_shifted_offset(const uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_u32)))
+uint32x4_t vldrhq_gather_shifted_offset_u32(const uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_u32)))
+uint32x4_t vldrhq_gather_shifted_offset(const uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_s16)))
+int16x8_t vldrhq_gather_shifted_offset_z_s16(const int16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_s16)))
+int16x8_t vldrhq_gather_shifted_offset_z(const int16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_s32)))
+int32x4_t vldrhq_gather_shifted_offset_z_s32(const int16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_s32)))
+int32x4_t vldrhq_gather_shifted_offset_z(const int16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_u16)))
+uint16x8_t vldrhq_gather_shifted_offset_z_u16(const uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_u16)))
+uint16x8_t vldrhq_gather_shifted_offset_z(const uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_u32)))
+uint32x4_t vldrhq_gather_shifted_offset_z_u32(const uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_u32)))
+uint32x4_t vldrhq_gather_shifted_offset_z(const uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_s16)))
+int16x8_t vldrhq_s16(const int16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_s32)))
+int32x4_t vldrhq_s32(const int16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_u16)))
+uint16x8_t vldrhq_u16(const uint16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_u32)))
+uint32x4_t vldrhq_u32(const uint16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_z_s16)))
+int16x8_t vldrhq_z_s16(const int16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_z_s32)))
+int32x4_t vldrhq_z_s32(const int16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_z_u16)))
+uint16x8_t vldrhq_z_u16(const uint16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_z_u32)))
+uint32x4_t vldrhq_z_u32(const uint16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_s32)))
+int32x4_t vldrwq_gather_base_s32(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_u32)))
+uint32x4_t vldrwq_gather_base_u32(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_s32)))
+int32x4_t vldrwq_gather_base_wb_s32(uint32x4_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_u32)))
+uint32x4_t vldrwq_gather_base_wb_u32(uint32x4_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_z_s32)))
+int32x4_t vldrwq_gather_base_wb_z_s32(uint32x4_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_z_u32)))
+uint32x4_t vldrwq_gather_base_wb_z_u32(uint32x4_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_z_s32)))
+int32x4_t vldrwq_gather_base_z_s32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_z_u32)))
+uint32x4_t vldrwq_gather_base_z_u32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_s32)))
+int32x4_t vldrwq_gather_offset_s32(const int32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_s32)))
+int32x4_t vldrwq_gather_offset(const int32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_u32)))
+uint32x4_t vldrwq_gather_offset_u32(const uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_u32)))
+uint32x4_t vldrwq_gather_offset(const uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_s32)))
+int32x4_t vldrwq_gather_offset_z_s32(const int32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_s32)))
+int32x4_t vldrwq_gather_offset_z(const int32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_u32)))
+uint32x4_t vldrwq_gather_offset_z_u32(const uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_u32)))
+uint32x4_t vldrwq_gather_offset_z(const uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_s32)))
+int32x4_t vldrwq_gather_shifted_offset_s32(const int32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_s32)))
+int32x4_t vldrwq_gather_shifted_offset(const int32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_u32)))
+uint32x4_t vldrwq_gather_shifted_offset_u32(const uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_u32)))
+uint32x4_t vldrwq_gather_shifted_offset(const uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_s32)))
+int32x4_t vldrwq_gather_shifted_offset_z_s32(const int32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_s32)))
+int32x4_t vldrwq_gather_shifted_offset_z(const int32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_u32)))
+uint32x4_t vldrwq_gather_shifted_offset_z_u32(const uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_u32)))
+uint32x4_t vldrwq_gather_shifted_offset_z(const uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_s32)))
+int32x4_t vldrwq_s32(const int32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_u32)))
+uint32x4_t vldrwq_u32(const uint32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_z_s32)))
+int32x4_t vldrwq_z_s32(const int32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_z_u32)))
+uint32x4_t vldrwq_z_u32(const uint32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s16)))
+uint16x8_t vmaxaq_m_s16(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s16)))
+uint16x8_t vmaxaq_m(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s32)))
+uint32x4_t vmaxaq_m_s32(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s32)))
+uint32x4_t vmaxaq_m(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s8)))
+uint8x16_t vmaxaq_m_s8(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_m_s8)))
+uint8x16_t vmaxaq_m(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s16)))
+uint16x8_t vmaxaq_s16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s16)))
+uint16x8_t vmaxaq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s32)))
+uint32x4_t vmaxaq_s32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s32)))
+uint32x4_t vmaxaq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s8)))
+uint8x16_t vmaxaq_s8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxaq_s8)))
+uint8x16_t vmaxaq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s16)))
+uint16_t vmaxavq_p_s16(uint16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s16)))
+uint16_t vmaxavq_p(uint16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s32)))
+uint32_t vmaxavq_p_s32(uint32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s32)))
+uint32_t vmaxavq_p(uint32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s8)))
+uint8_t vmaxavq_p_s8(uint8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_p_s8)))
+uint8_t vmaxavq_p(uint8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s16)))
+uint16_t vmaxavq_s16(uint16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s16)))
+uint16_t vmaxavq(uint16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s32)))
+uint32_t vmaxavq_s32(uint32_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s32)))
+uint32_t vmaxavq(uint32_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s8)))
+uint8_t vmaxavq_s8(uint8_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxavq_s8)))
+uint8_t vmaxavq(uint8_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s16)))
+int16x8_t vmaxq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s16)))
+int16x8_t vmaxq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s32)))
+int32x4_t vmaxq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s32)))
+int32x4_t vmaxq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s8)))
+int8x16_t vmaxq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_s8)))
+int8x16_t vmaxq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u16)))
+uint16x8_t vmaxq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u16)))
+uint16x8_t vmaxq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u32)))
+uint32x4_t vmaxq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u32)))
+uint32x4_t vmaxq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u8)))
+uint8x16_t vmaxq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_m_u8)))
+uint8x16_t vmaxq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s16)))
+int16x8_t vmaxq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s16)))
+int16x8_t vmaxq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s32)))
+int32x4_t vmaxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s32)))
+int32x4_t vmaxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s8)))
+int8x16_t vmaxq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_s8)))
+int8x16_t vmaxq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u16)))
+uint16x8_t vmaxq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u16)))
+uint16x8_t vmaxq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u32)))
+uint32x4_t vmaxq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u32)))
+uint32x4_t vmaxq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u8)))
+uint8x16_t vmaxq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_u8)))
+uint8x16_t vmaxq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s16)))
+int16x8_t vmaxq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s16)))
+int16x8_t vmaxq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s32)))
+int32x4_t vmaxq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s32)))
+int32x4_t vmaxq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s8)))
+int8x16_t vmaxq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_s8)))
+int8x16_t vmaxq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u16)))
+uint16x8_t vmaxq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u16)))
+uint16x8_t vmaxq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u32)))
+uint32x4_t vmaxq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u32)))
+uint32x4_t vmaxq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u8)))
+uint8x16_t vmaxq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxq_x_u8)))
+uint8x16_t vmaxq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s16)))
+int16_t vmaxvq_p_s16(int16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s16)))
+int16_t vmaxvq_p(int16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s32)))
+int32_t vmaxvq_p_s32(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s32)))
+int32_t vmaxvq_p(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s8)))
+int8_t vmaxvq_p_s8(int8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_s8)))
+int8_t vmaxvq_p(int8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u16)))
+uint16_t vmaxvq_p_u16(uint16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u16)))
+uint16_t vmaxvq_p(uint16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u32)))
+uint32_t vmaxvq_p_u32(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u32)))
+uint32_t vmaxvq_p(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u8)))
+uint8_t vmaxvq_p_u8(uint8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_p_u8)))
+uint8_t vmaxvq_p(uint8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s16)))
+int16_t vmaxvq_s16(int16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s16)))
+int16_t vmaxvq(int16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s32)))
+int32_t vmaxvq_s32(int32_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s32)))
+int32_t vmaxvq(int32_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s8)))
+int8_t vmaxvq_s8(int8_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_s8)))
+int8_t vmaxvq(int8_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u16)))
+uint16_t vmaxvq_u16(uint16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u16)))
+uint16_t vmaxvq(uint16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u32)))
+uint32_t vmaxvq_u32(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u32)))
+uint32_t vmaxvq(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u8)))
+uint8_t vmaxvq_u8(uint8_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxvq_u8)))
+uint8_t vmaxvq(uint8_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s16)))
+uint16x8_t vminaq_m_s16(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s16)))
+uint16x8_t vminaq_m(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s32)))
+uint32x4_t vminaq_m_s32(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s32)))
+uint32x4_t vminaq_m(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s8)))
+uint8x16_t vminaq_m_s8(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_m_s8)))
+uint8x16_t vminaq_m(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s16)))
+uint16x8_t vminaq_s16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s16)))
+uint16x8_t vminaq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s32)))
+uint32x4_t vminaq_s32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s32)))
+uint32x4_t vminaq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s8)))
+uint8x16_t vminaq_s8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminaq_s8)))
+uint8x16_t vminaq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s16)))
+uint16_t vminavq_p_s16(uint16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s16)))
+uint16_t vminavq_p(uint16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s32)))
+uint32_t vminavq_p_s32(uint32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s32)))
+uint32_t vminavq_p(uint32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s8)))
+uint8_t vminavq_p_s8(uint8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_p_s8)))
+uint8_t vminavq_p(uint8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s16)))
+uint16_t vminavq_s16(uint16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s16)))
+uint16_t vminavq(uint16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s32)))
+uint32_t vminavq_s32(uint32_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s32)))
+uint32_t vminavq(uint32_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s8)))
+uint8_t vminavq_s8(uint8_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminavq_s8)))
+uint8_t vminavq(uint8_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s16)))
+int16x8_t vminq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s16)))
+int16x8_t vminq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s32)))
+int32x4_t vminq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s32)))
+int32x4_t vminq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s8)))
+int8x16_t vminq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_s8)))
+int8x16_t vminq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u16)))
+uint16x8_t vminq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u16)))
+uint16x8_t vminq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u32)))
+uint32x4_t vminq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u32)))
+uint32x4_t vminq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u8)))
+uint8x16_t vminq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_m_u8)))
+uint8x16_t vminq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_s16)))
+int16x8_t vminq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_s16)))
+int16x8_t vminq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_s32)))
+int32x4_t vminq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_s32)))
+int32x4_t vminq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_s8)))
+int8x16_t vminq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_s8)))
+int8x16_t vminq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_u16)))
+uint16x8_t vminq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_u16)))
+uint16x8_t vminq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_u32)))
+uint32x4_t vminq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_u32)))
+uint32x4_t vminq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_u8)))
+uint8x16_t vminq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_u8)))
+uint8x16_t vminq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s16)))
+int16x8_t vminq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s16)))
+int16x8_t vminq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s32)))
+int32x4_t vminq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s32)))
+int32x4_t vminq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s8)))
+int8x16_t vminq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_s8)))
+int8x16_t vminq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u16)))
+uint16x8_t vminq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u16)))
+uint16x8_t vminq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u32)))
+uint32x4_t vminq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u32)))
+uint32x4_t vminq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u8)))
+uint8x16_t vminq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminq_x_u8)))
+uint8x16_t vminq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s16)))
+int16_t vminvq_p_s16(int16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s16)))
+int16_t vminvq_p(int16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s32)))
+int32_t vminvq_p_s32(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s32)))
+int32_t vminvq_p(int32_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s8)))
+int8_t vminvq_p_s8(int8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_s8)))
+int8_t vminvq_p(int8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u16)))
+uint16_t vminvq_p_u16(uint16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u16)))
+uint16_t vminvq_p(uint16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u32)))
+uint32_t vminvq_p_u32(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u32)))
+uint32_t vminvq_p(uint32_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u8)))
+uint8_t vminvq_p_u8(uint8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_p_u8)))
+uint8_t vminvq_p(uint8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s16)))
+int16_t vminvq_s16(int16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s16)))
+int16_t vminvq(int16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s32)))
+int32_t vminvq_s32(int32_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s32)))
+int32_t vminvq(int32_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s8)))
+int8_t vminvq_s8(int8_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_s8)))
+int8_t vminvq(int8_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u16)))
+uint16_t vminvq_u16(uint16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u16)))
+uint16_t vminvq(uint16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u32)))
+uint32_t vminvq_u32(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u32)))
+uint32_t vminvq(uint32_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u8)))
+uint8_t vminvq_u8(uint8_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminvq_u8)))
+uint8_t vminvq(uint8_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s16)))
+int32_t vmladavaq_p_s16(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s16)))
+int32_t vmladavaq_p(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s32)))
+int32_t vmladavaq_p_s32(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s32)))
+int32_t vmladavaq_p(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s8)))
+int32_t vmladavaq_p_s8(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_s8)))
+int32_t vmladavaq_p(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u16)))
+uint32_t vmladavaq_p_u16(uint32_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u16)))
+uint32_t vmladavaq_p(uint32_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u32)))
+uint32_t vmladavaq_p_u32(uint32_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u32)))
+uint32_t vmladavaq_p(uint32_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u8)))
+uint32_t vmladavaq_p_u8(uint32_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_p_u8)))
+uint32_t vmladavaq_p(uint32_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s16)))
+int32_t vmladavaq_s16(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s16)))
+int32_t vmladavaq(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s32)))
+int32_t vmladavaq_s32(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s32)))
+int32_t vmladavaq(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s8)))
+int32_t vmladavaq_s8(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_s8)))
+int32_t vmladavaq(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u16)))
+uint32_t vmladavaq_u16(uint32_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u16)))
+uint32_t vmladavaq(uint32_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u32)))
+uint32_t vmladavaq_u32(uint32_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u32)))
+uint32_t vmladavaq(uint32_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u8)))
+uint32_t vmladavaq_u8(uint32_t, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaq_u8)))
+uint32_t vmladavaq(uint32_t, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s16)))
+int32_t vmladavaxq_p_s16(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s16)))
+int32_t vmladavaxq_p(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s32)))
+int32_t vmladavaxq_p_s32(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s32)))
+int32_t vmladavaxq_p(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s8)))
+int32_t vmladavaxq_p_s8(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_p_s8)))
+int32_t vmladavaxq_p(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s16)))
+int32_t vmladavaxq_s16(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s16)))
+int32_t vmladavaxq(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s32)))
+int32_t vmladavaxq_s32(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s32)))
+int32_t vmladavaxq(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s8)))
+int32_t vmladavaxq_s8(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavaxq_s8)))
+int32_t vmladavaxq(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s16)))
+int32_t vmladavq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s16)))
+int32_t vmladavq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s32)))
+int32_t vmladavq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s32)))
+int32_t vmladavq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s8)))
+int32_t vmladavq_p_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_s8)))
+int32_t vmladavq_p(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u16)))
+uint32_t vmladavq_p_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u16)))
+uint32_t vmladavq_p(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u32)))
+uint32_t vmladavq_p_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u32)))
+uint32_t vmladavq_p(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u8)))
+uint32_t vmladavq_p_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_p_u8)))
+uint32_t vmladavq_p(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s16)))
+int32_t vmladavq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s16)))
+int32_t vmladavq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s32)))
+int32_t vmladavq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s32)))
+int32_t vmladavq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s8)))
+int32_t vmladavq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_s8)))
+int32_t vmladavq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u16)))
+uint32_t vmladavq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u16)))
+uint32_t vmladavq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u32)))
+uint32_t vmladavq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u32)))
+uint32_t vmladavq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u8)))
+uint32_t vmladavq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavq_u8)))
+uint32_t vmladavq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s16)))
+int32_t vmladavxq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s16)))
+int32_t vmladavxq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s32)))
+int32_t vmladavxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s32)))
+int32_t vmladavxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s8)))
+int32_t vmladavxq_p_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_p_s8)))
+int32_t vmladavxq_p(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s16)))
+int32_t vmladavxq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s16)))
+int32_t vmladavxq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s32)))
+int32_t vmladavxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s32)))
+int32_t vmladavxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s8)))
+int32_t vmladavxq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmladavxq_s8)))
+int32_t vmladavxq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_s16)))
+int64_t vmlaldavaq_p_s16(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_s16)))
+int64_t vmlaldavaq_p(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_s32)))
+int64_t vmlaldavaq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_s32)))
+int64_t vmlaldavaq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_u16)))
+uint64_t vmlaldavaq_p_u16(uint64_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_u16)))
+uint64_t vmlaldavaq_p(uint64_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_u32)))
+uint64_t vmlaldavaq_p_u32(uint64_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_p_u32)))
+uint64_t vmlaldavaq_p(uint64_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_s16)))
+int64_t vmlaldavaq_s16(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_s16)))
+int64_t vmlaldavaq(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_s32)))
+int64_t vmlaldavaq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_s32)))
+int64_t vmlaldavaq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_u16)))
+uint64_t vmlaldavaq_u16(uint64_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_u16)))
+uint64_t vmlaldavaq(uint64_t, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_u32)))
+uint64_t vmlaldavaq_u32(uint64_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaq_u32)))
+uint64_t vmlaldavaq(uint64_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_p_s16)))
+int64_t vmlaldavaxq_p_s16(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_p_s16)))
+int64_t vmlaldavaxq_p(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_p_s32)))
+int64_t vmlaldavaxq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_p_s32)))
+int64_t vmlaldavaxq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_s16)))
+int64_t vmlaldavaxq_s16(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_s16)))
+int64_t vmlaldavaxq(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_s32)))
+int64_t vmlaldavaxq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavaxq_s32)))
+int64_t vmlaldavaxq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_s16)))
+int64_t vmlaldavq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_s16)))
+int64_t vmlaldavq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_s32)))
+int64_t vmlaldavq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_s32)))
+int64_t vmlaldavq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_u16)))
+uint64_t vmlaldavq_p_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_u16)))
+uint64_t vmlaldavq_p(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_u32)))
+uint64_t vmlaldavq_p_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_p_u32)))
+uint64_t vmlaldavq_p(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_s16)))
+int64_t vmlaldavq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_s16)))
+int64_t vmlaldavq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_s32)))
+int64_t vmlaldavq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_s32)))
+int64_t vmlaldavq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_u16)))
+uint64_t vmlaldavq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_u16)))
+uint64_t vmlaldavq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_u32)))
+uint64_t vmlaldavq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavq_u32)))
+uint64_t vmlaldavq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_p_s16)))
+int64_t vmlaldavxq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_p_s16)))
+int64_t vmlaldavxq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_p_s32)))
+int64_t vmlaldavxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_p_s32)))
+int64_t vmlaldavxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_s16)))
+int64_t vmlaldavxq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_s16)))
+int64_t vmlaldavxq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_s32)))
+int64_t vmlaldavxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaldavxq_s32)))
+int64_t vmlaldavxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s16)))
+int16x8_t vmlaq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s16)))
+int16x8_t vmlaq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s32)))
+int32x4_t vmlaq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s32)))
+int32x4_t vmlaq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s8)))
+int8x16_t vmlaq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_s8)))
+int8x16_t vmlaq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u16)))
+uint16x8_t vmlaq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u16)))
+uint16x8_t vmlaq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u32)))
+uint32x4_t vmlaq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u32)))
+uint32x4_t vmlaq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u8)))
+uint8x16_t vmlaq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_m_n_u8)))
+uint8x16_t vmlaq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s16)))
+int16x8_t vmlaq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s16)))
+int16x8_t vmlaq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s32)))
+int32x4_t vmlaq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s32)))
+int32x4_t vmlaq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s8)))
+int8x16_t vmlaq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_s8)))
+int8x16_t vmlaq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u16)))
+uint16x8_t vmlaq_n_u16(uint16x8_t, uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u16)))
+uint16x8_t vmlaq(uint16x8_t, uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u32)))
+uint32x4_t vmlaq_n_u32(uint32x4_t, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u32)))
+uint32x4_t vmlaq(uint32x4_t, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u8)))
+uint8x16_t vmlaq_n_u8(uint8x16_t, uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlaq_n_u8)))
+uint8x16_t vmlaq(uint8x16_t, uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s16)))
+int16x8_t vmlasq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s16)))
+int16x8_t vmlasq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s32)))
+int32x4_t vmlasq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s32)))
+int32x4_t vmlasq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s8)))
+int8x16_t vmlasq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_s8)))
+int8x16_t vmlasq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u16)))
+uint16x8_t vmlasq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u16)))
+uint16x8_t vmlasq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u32)))
+uint32x4_t vmlasq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u32)))
+uint32x4_t vmlasq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u8)))
+uint8x16_t vmlasq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_m_n_u8)))
+uint8x16_t vmlasq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s16)))
+int16x8_t vmlasq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s16)))
+int16x8_t vmlasq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s32)))
+int32x4_t vmlasq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s32)))
+int32x4_t vmlasq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s8)))
+int8x16_t vmlasq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_s8)))
+int8x16_t vmlasq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u16)))
+uint16x8_t vmlasq_n_u16(uint16x8_t, uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u16)))
+uint16x8_t vmlasq(uint16x8_t, uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u32)))
+uint32x4_t vmlasq_n_u32(uint32x4_t, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u32)))
+uint32x4_t vmlasq(uint32x4_t, uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u8)))
+uint8x16_t vmlasq_n_u8(uint8x16_t, uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlasq_n_u8)))
+uint8x16_t vmlasq(uint8x16_t, uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s16)))
+int32_t vmlsdavaq_p_s16(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s16)))
+int32_t vmlsdavaq_p(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s32)))
+int32_t vmlsdavaq_p_s32(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s32)))
+int32_t vmlsdavaq_p(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s8)))
+int32_t vmlsdavaq_p_s8(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_p_s8)))
+int32_t vmlsdavaq_p(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s16)))
+int32_t vmlsdavaq_s16(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s16)))
+int32_t vmlsdavaq(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s32)))
+int32_t vmlsdavaq_s32(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s32)))
+int32_t vmlsdavaq(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s8)))
+int32_t vmlsdavaq_s8(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaq_s8)))
+int32_t vmlsdavaq(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s16)))
+int32_t vmlsdavaxq_p_s16(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s16)))
+int32_t vmlsdavaxq_p(int32_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s32)))
+int32_t vmlsdavaxq_p_s32(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s32)))
+int32_t vmlsdavaxq_p(int32_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s8)))
+int32_t vmlsdavaxq_p_s8(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_p_s8)))
+int32_t vmlsdavaxq_p(int32_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s16)))
+int32_t vmlsdavaxq_s16(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s16)))
+int32_t vmlsdavaxq(int32_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s32)))
+int32_t vmlsdavaxq_s32(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s32)))
+int32_t vmlsdavaxq(int32_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s8)))
+int32_t vmlsdavaxq_s8(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavaxq_s8)))
+int32_t vmlsdavaxq(int32_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s16)))
+int32_t vmlsdavq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s16)))
+int32_t vmlsdavq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s32)))
+int32_t vmlsdavq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s32)))
+int32_t vmlsdavq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s8)))
+int32_t vmlsdavq_p_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_p_s8)))
+int32_t vmlsdavq_p(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s16)))
+int32_t vmlsdavq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s16)))
+int32_t vmlsdavq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s32)))
+int32_t vmlsdavq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s32)))
+int32_t vmlsdavq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s8)))
+int32_t vmlsdavq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavq_s8)))
+int32_t vmlsdavq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s16)))
+int32_t vmlsdavxq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s16)))
+int32_t vmlsdavxq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s32)))
+int32_t vmlsdavxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s32)))
+int32_t vmlsdavxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s8)))
+int32_t vmlsdavxq_p_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_p_s8)))
+int32_t vmlsdavxq_p(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s16)))
+int32_t vmlsdavxq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s16)))
+int32_t vmlsdavxq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s32)))
+int32_t vmlsdavxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s32)))
+int32_t vmlsdavxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s8)))
+int32_t vmlsdavxq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsdavxq_s8)))
+int32_t vmlsdavxq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_p_s16)))
+int64_t vmlsldavaq_p_s16(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_p_s16)))
+int64_t vmlsldavaq_p(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_p_s32)))
+int64_t vmlsldavaq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_p_s32)))
+int64_t vmlsldavaq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_s16)))
+int64_t vmlsldavaq_s16(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_s16)))
+int64_t vmlsldavaq(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_s32)))
+int64_t vmlsldavaq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaq_s32)))
+int64_t vmlsldavaq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_p_s16)))
+int64_t vmlsldavaxq_p_s16(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_p_s16)))
+int64_t vmlsldavaxq_p(int64_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_p_s32)))
+int64_t vmlsldavaxq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_p_s32)))
+int64_t vmlsldavaxq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_s16)))
+int64_t vmlsldavaxq_s16(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_s16)))
+int64_t vmlsldavaxq(int64_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_s32)))
+int64_t vmlsldavaxq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavaxq_s32)))
+int64_t vmlsldavaxq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_p_s16)))
+int64_t vmlsldavq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_p_s16)))
+int64_t vmlsldavq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_p_s32)))
+int64_t vmlsldavq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_p_s32)))
+int64_t vmlsldavq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_s16)))
+int64_t vmlsldavq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_s16)))
+int64_t vmlsldavq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_s32)))
+int64_t vmlsldavq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavq_s32)))
+int64_t vmlsldavq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_p_s16)))
+int64_t vmlsldavxq_p_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_p_s16)))
+int64_t vmlsldavxq_p(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_p_s32)))
+int64_t vmlsldavxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_p_s32)))
+int64_t vmlsldavxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_s16)))
+int64_t vmlsldavxq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_s16)))
+int64_t vmlsldavxq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_s32)))
+int64_t vmlsldavxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmlsldavxq_s32)))
+int64_t vmlsldavxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_s16)))
+int32x4_t vmovlbq_m_s16(int32x4_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_s16)))
+int32x4_t vmovlbq_m(int32x4_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_s8)))
+int16x8_t vmovlbq_m_s8(int16x8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_s8)))
+int16x8_t vmovlbq_m(int16x8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_u16)))
+uint32x4_t vmovlbq_m_u16(uint32x4_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_u16)))
+uint32x4_t vmovlbq_m(uint32x4_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_u8)))
+uint16x8_t vmovlbq_m_u8(uint16x8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_m_u8)))
+uint16x8_t vmovlbq_m(uint16x8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_s16)))
+int32x4_t vmovlbq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_s16)))
+int32x4_t vmovlbq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_s8)))
+int16x8_t vmovlbq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_s8)))
+int16x8_t vmovlbq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_u16)))
+uint32x4_t vmovlbq_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_u16)))
+uint32x4_t vmovlbq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_u8)))
+uint16x8_t vmovlbq_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_u8)))
+uint16x8_t vmovlbq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_s16)))
+int32x4_t vmovlbq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_s16)))
+int32x4_t vmovlbq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_s8)))
+int16x8_t vmovlbq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_s8)))
+int16x8_t vmovlbq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_u16)))
+uint32x4_t vmovlbq_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_u16)))
+uint32x4_t vmovlbq_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_u8)))
+uint16x8_t vmovlbq_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovlbq_x_u8)))
+uint16x8_t vmovlbq_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_s16)))
+int32x4_t vmovltq_m_s16(int32x4_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_s16)))
+int32x4_t vmovltq_m(int32x4_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_s8)))
+int16x8_t vmovltq_m_s8(int16x8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_s8)))
+int16x8_t vmovltq_m(int16x8_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_u16)))
+uint32x4_t vmovltq_m_u16(uint32x4_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_u16)))
+uint32x4_t vmovltq_m(uint32x4_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_u8)))
+uint16x8_t vmovltq_m_u8(uint16x8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_m_u8)))
+uint16x8_t vmovltq_m(uint16x8_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_s16)))
+int32x4_t vmovltq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_s16)))
+int32x4_t vmovltq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_s8)))
+int16x8_t vmovltq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_s8)))
+int16x8_t vmovltq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_u16)))
+uint32x4_t vmovltq_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_u16)))
+uint32x4_t vmovltq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_u8)))
+uint16x8_t vmovltq_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_u8)))
+uint16x8_t vmovltq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_s16)))
+int32x4_t vmovltq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_s16)))
+int32x4_t vmovltq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_s8)))
+int16x8_t vmovltq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_s8)))
+int16x8_t vmovltq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_u16)))
+uint32x4_t vmovltq_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_u16)))
+uint32x4_t vmovltq_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_u8)))
+uint16x8_t vmovltq_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovltq_x_u8)))
+uint16x8_t vmovltq_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_s16)))
+int8x16_t vmovnbq_m_s16(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_s16)))
+int8x16_t vmovnbq_m(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_s32)))
+int16x8_t vmovnbq_m_s32(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_s32)))
+int16x8_t vmovnbq_m(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_u16)))
+uint8x16_t vmovnbq_m_u16(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_u16)))
+uint8x16_t vmovnbq_m(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_u32)))
+uint16x8_t vmovnbq_m_u32(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_m_u32)))
+uint16x8_t vmovnbq_m(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_s16)))
+int8x16_t vmovnbq_s16(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_s16)))
+int8x16_t vmovnbq(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_s32)))
+int16x8_t vmovnbq_s32(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_s32)))
+int16x8_t vmovnbq(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_u16)))
+uint8x16_t vmovnbq_u16(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_u16)))
+uint8x16_t vmovnbq(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_u32)))
+uint16x8_t vmovnbq_u32(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovnbq_u32)))
+uint16x8_t vmovnbq(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_s16)))
+int8x16_t vmovntq_m_s16(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_s16)))
+int8x16_t vmovntq_m(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_s32)))
+int16x8_t vmovntq_m_s32(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_s32)))
+int16x8_t vmovntq_m(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_u16)))
+uint8x16_t vmovntq_m_u16(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_u16)))
+uint8x16_t vmovntq_m(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_u32)))
+uint16x8_t vmovntq_m_u32(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_m_u32)))
+uint16x8_t vmovntq_m(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_s16)))
+int8x16_t vmovntq_s16(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_s16)))
+int8x16_t vmovntq(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_s32)))
+int16x8_t vmovntq_s32(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_s32)))
+int16x8_t vmovntq(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_u16)))
+uint8x16_t vmovntq_u16(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_u16)))
+uint8x16_t vmovntq(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_u32)))
+uint16x8_t vmovntq_u32(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmovntq_u32)))
+uint16x8_t vmovntq(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s16)))
+int16x8_t vmulhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s16)))
+int16x8_t vmulhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s32)))
+int32x4_t vmulhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s32)))
+int32x4_t vmulhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s8)))
+int8x16_t vmulhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_s8)))
+int8x16_t vmulhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u16)))
+uint16x8_t vmulhq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u16)))
+uint16x8_t vmulhq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u32)))
+uint32x4_t vmulhq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u32)))
+uint32x4_t vmulhq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u8)))
+uint8x16_t vmulhq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_m_u8)))
+uint8x16_t vmulhq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s16)))
+int16x8_t vmulhq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s16)))
+int16x8_t vmulhq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s32)))
+int32x4_t vmulhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s32)))
+int32x4_t vmulhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s8)))
+int8x16_t vmulhq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_s8)))
+int8x16_t vmulhq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u16)))
+uint16x8_t vmulhq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u16)))
+uint16x8_t vmulhq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u32)))
+uint32x4_t vmulhq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u32)))
+uint32x4_t vmulhq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u8)))
+uint8x16_t vmulhq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_u8)))
+uint8x16_t vmulhq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s16)))
+int16x8_t vmulhq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s16)))
+int16x8_t vmulhq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s32)))
+int32x4_t vmulhq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s32)))
+int32x4_t vmulhq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s8)))
+int8x16_t vmulhq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_s8)))
+int8x16_t vmulhq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u16)))
+uint16x8_t vmulhq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u16)))
+uint16x8_t vmulhq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u32)))
+uint32x4_t vmulhq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u32)))
+uint32x4_t vmulhq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u8)))
+uint8x16_t vmulhq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulhq_x_u8)))
+uint8x16_t vmulhq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s16)))
+int32x4_t vmullbq_int_m_s16(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s16)))
+int32x4_t vmullbq_int_m(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s32)))
+int64x2_t vmullbq_int_m_s32(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s32)))
+int64x2_t vmullbq_int_m(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s8)))
+int16x8_t vmullbq_int_m_s8(int16x8_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_s8)))
+int16x8_t vmullbq_int_m(int16x8_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u16)))
+uint32x4_t vmullbq_int_m_u16(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u16)))
+uint32x4_t vmullbq_int_m(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u32)))
+uint64x2_t vmullbq_int_m_u32(uint64x2_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u32)))
+uint64x2_t vmullbq_int_m(uint64x2_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u8)))
+uint16x8_t vmullbq_int_m_u8(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_m_u8)))
+uint16x8_t vmullbq_int_m(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s16)))
+int32x4_t vmullbq_int_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s16)))
+int32x4_t vmullbq_int(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s32)))
+int64x2_t vmullbq_int_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s32)))
+int64x2_t vmullbq_int(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s8)))
+int16x8_t vmullbq_int_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_s8)))
+int16x8_t vmullbq_int(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u16)))
+uint32x4_t vmullbq_int_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u16)))
+uint32x4_t vmullbq_int(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u32)))
+uint64x2_t vmullbq_int_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u32)))
+uint64x2_t vmullbq_int(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u8)))
+uint16x8_t vmullbq_int_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_u8)))
+uint16x8_t vmullbq_int(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s16)))
+int32x4_t vmullbq_int_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s16)))
+int32x4_t vmullbq_int_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s32)))
+int64x2_t vmullbq_int_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s32)))
+int64x2_t vmullbq_int_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s8)))
+int16x8_t vmullbq_int_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_s8)))
+int16x8_t vmullbq_int_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u16)))
+uint32x4_t vmullbq_int_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u16)))
+uint32x4_t vmullbq_int_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u32)))
+uint64x2_t vmullbq_int_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u32)))
+uint64x2_t vmullbq_int_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u8)))
+uint16x8_t vmullbq_int_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_int_x_u8)))
+uint16x8_t vmullbq_int_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_m_p16)))
+uint32x4_t vmullbq_poly_m_p16(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_m_p16)))
+uint32x4_t vmullbq_poly_m(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_m_p8)))
+uint16x8_t vmullbq_poly_m_p8(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_m_p8)))
+uint16x8_t vmullbq_poly_m(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_p16)))
+uint32x4_t vmullbq_poly_p16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_p16)))
+uint32x4_t vmullbq_poly(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_p8)))
+uint16x8_t vmullbq_poly_p8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_p8)))
+uint16x8_t vmullbq_poly(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_x_p16)))
+uint32x4_t vmullbq_poly_x_p16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_x_p16)))
+uint32x4_t vmullbq_poly_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_x_p8)))
+uint16x8_t vmullbq_poly_x_p8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmullbq_poly_x_p8)))
+uint16x8_t vmullbq_poly_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s16)))
+int32x4_t vmulltq_int_m_s16(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s16)))
+int32x4_t vmulltq_int_m(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s32)))
+int64x2_t vmulltq_int_m_s32(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s32)))
+int64x2_t vmulltq_int_m(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s8)))
+int16x8_t vmulltq_int_m_s8(int16x8_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_s8)))
+int16x8_t vmulltq_int_m(int16x8_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u16)))
+uint32x4_t vmulltq_int_m_u16(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u16)))
+uint32x4_t vmulltq_int_m(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u32)))
+uint64x2_t vmulltq_int_m_u32(uint64x2_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u32)))
+uint64x2_t vmulltq_int_m(uint64x2_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u8)))
+uint16x8_t vmulltq_int_m_u8(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_m_u8)))
+uint16x8_t vmulltq_int_m(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s16)))
+int32x4_t vmulltq_int_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s16)))
+int32x4_t vmulltq_int(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s32)))
+int64x2_t vmulltq_int_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s32)))
+int64x2_t vmulltq_int(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s8)))
+int16x8_t vmulltq_int_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_s8)))
+int16x8_t vmulltq_int(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u16)))
+uint32x4_t vmulltq_int_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u16)))
+uint32x4_t vmulltq_int(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u32)))
+uint64x2_t vmulltq_int_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u32)))
+uint64x2_t vmulltq_int(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u8)))
+uint16x8_t vmulltq_int_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_u8)))
+uint16x8_t vmulltq_int(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s16)))
+int32x4_t vmulltq_int_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s16)))
+int32x4_t vmulltq_int_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s32)))
+int64x2_t vmulltq_int_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s32)))
+int64x2_t vmulltq_int_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s8)))
+int16x8_t vmulltq_int_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_s8)))
+int16x8_t vmulltq_int_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u16)))
+uint32x4_t vmulltq_int_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u16)))
+uint32x4_t vmulltq_int_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u32)))
+uint64x2_t vmulltq_int_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u32)))
+uint64x2_t vmulltq_int_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u8)))
+uint16x8_t vmulltq_int_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_int_x_u8)))
+uint16x8_t vmulltq_int_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_m_p16)))
+uint32x4_t vmulltq_poly_m_p16(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_m_p16)))
+uint32x4_t vmulltq_poly_m(uint32x4_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_m_p8)))
+uint16x8_t vmulltq_poly_m_p8(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_m_p8)))
+uint16x8_t vmulltq_poly_m(uint16x8_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_p16)))
+uint32x4_t vmulltq_poly_p16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_p16)))
+uint32x4_t vmulltq_poly(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_p8)))
+uint16x8_t vmulltq_poly_p8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_p8)))
+uint16x8_t vmulltq_poly(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_x_p16)))
+uint32x4_t vmulltq_poly_x_p16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_x_p16)))
+uint32x4_t vmulltq_poly_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_x_p8)))
+uint16x8_t vmulltq_poly_x_p8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulltq_poly_x_p8)))
+uint16x8_t vmulltq_poly_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s16)))
+int16x8_t vmulq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s16)))
+int16x8_t vmulq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s32)))
+int32x4_t vmulq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s32)))
+int32x4_t vmulq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s8)))
+int8x16_t vmulq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_s8)))
+int8x16_t vmulq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u16)))
+uint16x8_t vmulq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u16)))
+uint16x8_t vmulq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u32)))
+uint32x4_t vmulq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u32)))
+uint32x4_t vmulq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u8)))
+uint8x16_t vmulq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_u8)))
+uint8x16_t vmulq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s16)))
+int16x8_t vmulq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s16)))
+int16x8_t vmulq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s32)))
+int32x4_t vmulq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s32)))
+int32x4_t vmulq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s8)))
+int8x16_t vmulq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_s8)))
+int8x16_t vmulq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u16)))
+uint16x8_t vmulq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u16)))
+uint16x8_t vmulq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u32)))
+uint32x4_t vmulq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u32)))
+uint32x4_t vmulq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u8)))
+uint8x16_t vmulq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_u8)))
+uint8x16_t vmulq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s16)))
+int16x8_t vmulq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s16)))
+int16x8_t vmulq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s32)))
+int32x4_t vmulq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s32)))
+int32x4_t vmulq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s8)))
+int8x16_t vmulq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_s8)))
+int8x16_t vmulq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u16)))
+uint16x8_t vmulq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u16)))
+uint16x8_t vmulq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u32)))
+uint32x4_t vmulq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u32)))
+uint32x4_t vmulq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u8)))
+uint8x16_t vmulq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_u8)))
+uint8x16_t vmulq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s16)))
+int16x8_t vmulq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s16)))
+int16x8_t vmulq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s32)))
+int32x4_t vmulq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s32)))
+int32x4_t vmulq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s8)))
+int8x16_t vmulq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_s8)))
+int8x16_t vmulq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u16)))
+uint16x8_t vmulq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u16)))
+uint16x8_t vmulq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u32)))
+uint32x4_t vmulq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u32)))
+uint32x4_t vmulq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u8)))
+uint8x16_t vmulq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_u8)))
+uint8x16_t vmulq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s16)))
+int16x8_t vmulq_x_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s16)))
+int16x8_t vmulq_x(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s32)))
+int32x4_t vmulq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s32)))
+int32x4_t vmulq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s8)))
+int8x16_t vmulq_x_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_s8)))
+int8x16_t vmulq_x(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u16)))
+uint16x8_t vmulq_x_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u16)))
+uint16x8_t vmulq_x(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u32)))
+uint32x4_t vmulq_x_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u32)))
+uint32x4_t vmulq_x(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u8)))
+uint8x16_t vmulq_x_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_u8)))
+uint8x16_t vmulq_x(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s16)))
+int16x8_t vmulq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s16)))
+int16x8_t vmulq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s32)))
+int32x4_t vmulq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s32)))
+int32x4_t vmulq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s8)))
+int8x16_t vmulq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_s8)))
+int8x16_t vmulq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u16)))
+uint16x8_t vmulq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u16)))
+uint16x8_t vmulq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u32)))
+uint32x4_t vmulq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u32)))
+uint32x4_t vmulq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u8)))
+uint8x16_t vmulq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_u8)))
+uint8x16_t vmulq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_s16)))
+int16x8_t vmvnq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_s16)))
+int16x8_t vmvnq_m(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_s32)))
+int32x4_t vmvnq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_s32)))
+int32x4_t vmvnq_m(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_u16)))
+uint16x8_t vmvnq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_u16)))
+uint16x8_t vmvnq_m(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_u32)))
+uint32x4_t vmvnq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_n_u32)))
+uint32x4_t vmvnq_m(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s16)))
+int16x8_t vmvnq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s16)))
+int16x8_t vmvnq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s32)))
+int32x4_t vmvnq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s32)))
+int32x4_t vmvnq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s8)))
+int8x16_t vmvnq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_s8)))
+int8x16_t vmvnq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u16)))
+uint16x8_t vmvnq_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u16)))
+uint16x8_t vmvnq_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u32)))
+uint32x4_t vmvnq_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u32)))
+uint32x4_t vmvnq_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u8)))
+uint8x16_t vmvnq_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_m_u8)))
+uint8x16_t vmvnq_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_n_s16)))
+int16x8_t vmvnq_n_s16(int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_n_s32)))
+int32x4_t vmvnq_n_s32(int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_n_u16)))
+uint16x8_t vmvnq_n_u16(uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_n_u32)))
+uint32x4_t vmvnq_n_u32(uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s16)))
+int16x8_t vmvnq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s16)))
+int16x8_t vmvnq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s32)))
+int32x4_t vmvnq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s32)))
+int32x4_t vmvnq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s8)))
+int8x16_t vmvnq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_s8)))
+int8x16_t vmvnq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u16)))
+uint16x8_t vmvnq_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u16)))
+uint16x8_t vmvnq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u32)))
+uint32x4_t vmvnq_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u32)))
+uint32x4_t vmvnq(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u8)))
+uint8x16_t vmvnq_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_u8)))
+uint8x16_t vmvnq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_n_s16)))
+int16x8_t vmvnq_x_n_s16(int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_n_s32)))
+int32x4_t vmvnq_x_n_s32(int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_n_u16)))
+uint16x8_t vmvnq_x_n_u16(uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_n_u32)))
+uint32x4_t vmvnq_x_n_u32(uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s16)))
+int16x8_t vmvnq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s16)))
+int16x8_t vmvnq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s32)))
+int32x4_t vmvnq_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s32)))
+int32x4_t vmvnq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s8)))
+int8x16_t vmvnq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_s8)))
+int8x16_t vmvnq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u16)))
+uint16x8_t vmvnq_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u16)))
+uint16x8_t vmvnq_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u32)))
+uint32x4_t vmvnq_x_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u32)))
+uint32x4_t vmvnq_x(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u8)))
+uint8x16_t vmvnq_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmvnq_x_u8)))
+uint8x16_t vmvnq_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s16)))
+int16x8_t vnegq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s16)))
+int16x8_t vnegq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s32)))
+int32x4_t vnegq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s32)))
+int32x4_t vnegq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s8)))
+int8x16_t vnegq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_s8)))
+int8x16_t vnegq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s16)))
+int16x8_t vnegq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s16)))
+int16x8_t vnegq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s32)))
+int32x4_t vnegq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s32)))
+int32x4_t vnegq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s8)))
+int8x16_t vnegq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_s8)))
+int8x16_t vnegq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s16)))
+int16x8_t vnegq_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s16)))
+int16x8_t vnegq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s32)))
+int32x4_t vnegq_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s32)))
+int32x4_t vnegq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s8)))
+int8x16_t vnegq_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_s8)))
+int8x16_t vnegq_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s16)))
+int16x8_t vornq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s16)))
+int16x8_t vornq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s32)))
+int32x4_t vornq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s32)))
+int32x4_t vornq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s8)))
+int8x16_t vornq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_s8)))
+int8x16_t vornq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u16)))
+uint16x8_t vornq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u16)))
+uint16x8_t vornq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u32)))
+uint32x4_t vornq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u32)))
+uint32x4_t vornq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u8)))
+uint8x16_t vornq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_u8)))
+uint8x16_t vornq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_s16)))
+int16x8_t vornq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_s16)))
+int16x8_t vornq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_s32)))
+int32x4_t vornq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_s32)))
+int32x4_t vornq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_s8)))
+int8x16_t vornq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_s8)))
+int8x16_t vornq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_u16)))
+uint16x8_t vornq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_u16)))
+uint16x8_t vornq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_u32)))
+uint32x4_t vornq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_u32)))
+uint32x4_t vornq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_u8)))
+uint8x16_t vornq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_u8)))
+uint8x16_t vornq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s16)))
+int16x8_t vornq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s16)))
+int16x8_t vornq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s32)))
+int32x4_t vornq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s32)))
+int32x4_t vornq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s8)))
+int8x16_t vornq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_s8)))
+int8x16_t vornq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u16)))
+uint16x8_t vornq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u16)))
+uint16x8_t vornq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u32)))
+uint32x4_t vornq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u32)))
+uint32x4_t vornq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u8)))
+uint8x16_t vornq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_u8)))
+uint8x16_t vornq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_s16)))
+int16x8_t vorrq_m_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_s16)))
+int16x8_t vorrq_m_n(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_s32)))
+int32x4_t vorrq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_s32)))
+int32x4_t vorrq_m_n(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_u16)))
+uint16x8_t vorrq_m_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_u16)))
+uint16x8_t vorrq_m_n(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_u32)))
+uint32x4_t vorrq_m_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_n_u32)))
+uint32x4_t vorrq_m_n(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s16)))
+int16x8_t vorrq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s16)))
+int16x8_t vorrq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s32)))
+int32x4_t vorrq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s32)))
+int32x4_t vorrq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s8)))
+int8x16_t vorrq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_s8)))
+int8x16_t vorrq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u16)))
+uint16x8_t vorrq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u16)))
+uint16x8_t vorrq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u32)))
+uint32x4_t vorrq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u32)))
+uint32x4_t vorrq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u8)))
+uint8x16_t vorrq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_u8)))
+uint8x16_t vorrq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_s16)))
+int16x8_t vorrq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_s16)))
+int16x8_t vorrq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_s32)))
+int32x4_t vorrq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_s32)))
+int32x4_t vorrq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_u16)))
+uint16x8_t vorrq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_u16)))
+uint16x8_t vorrq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_u32)))
+uint32x4_t vorrq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_n_u32)))
+uint32x4_t vorrq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s16)))
+int16x8_t vorrq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s16)))
+int16x8_t vorrq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s32)))
+int32x4_t vorrq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s32)))
+int32x4_t vorrq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s8)))
+int8x16_t vorrq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_s8)))
+int8x16_t vorrq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u16)))
+uint16x8_t vorrq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u16)))
+uint16x8_t vorrq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u32)))
+uint32x4_t vorrq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u32)))
+uint32x4_t vorrq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u8)))
+uint8x16_t vorrq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_u8)))
+uint8x16_t vorrq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s16)))
+int16x8_t vorrq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s16)))
+int16x8_t vorrq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s32)))
+int32x4_t vorrq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s32)))
+int32x4_t vorrq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s8)))
+int8x16_t vorrq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_s8)))
+int8x16_t vorrq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u16)))
+uint16x8_t vorrq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u16)))
+uint16x8_t vorrq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u32)))
+uint32x4_t vorrq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u32)))
+uint32x4_t vorrq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u8)))
+uint8x16_t vorrq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_u8)))
+uint8x16_t vorrq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpnot)))
+mve_pred16_t vpnot(mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s16)))
+int16x8_t vpselq_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s16)))
+int16x8_t vpselq(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s32)))
+int32x4_t vpselq_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s32)))
+int32x4_t vpselq(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s64)))
+int64x2_t vpselq_s64(int64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s64)))
+int64x2_t vpselq(int64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s8)))
+int8x16_t vpselq_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_s8)))
+int8x16_t vpselq(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u16)))
+uint16x8_t vpselq_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u16)))
+uint16x8_t vpselq(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u32)))
+uint32x4_t vpselq_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u32)))
+uint32x4_t vpselq(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u64)))
+uint64x2_t vpselq_u64(uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u64)))
+uint64x2_t vpselq(uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u8)))
+uint8x16_t vpselq_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_u8)))
+uint8x16_t vpselq(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s16)))
+int16x8_t vqabsq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s16)))
+int16x8_t vqabsq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s32)))
+int32x4_t vqabsq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s32)))
+int32x4_t vqabsq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s8)))
+int8x16_t vqabsq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_m_s8)))
+int8x16_t vqabsq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s16)))
+int16x8_t vqabsq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s16)))
+int16x8_t vqabsq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s32)))
+int32x4_t vqabsq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s32)))
+int32x4_t vqabsq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s8)))
+int8x16_t vqabsq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqabsq_s8)))
+int8x16_t vqabsq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s16)))
+int16x8_t vqaddq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s16)))
+int16x8_t vqaddq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s32)))
+int32x4_t vqaddq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s32)))
+int32x4_t vqaddq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s8)))
+int8x16_t vqaddq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_s8)))
+int8x16_t vqaddq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u16)))
+uint16x8_t vqaddq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u16)))
+uint16x8_t vqaddq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u32)))
+uint32x4_t vqaddq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u32)))
+uint32x4_t vqaddq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u8)))
+uint8x16_t vqaddq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_n_u8)))
+uint8x16_t vqaddq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s16)))
+int16x8_t vqaddq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s16)))
+int16x8_t vqaddq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s32)))
+int32x4_t vqaddq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s32)))
+int32x4_t vqaddq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s8)))
+int8x16_t vqaddq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_s8)))
+int8x16_t vqaddq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u16)))
+uint16x8_t vqaddq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u16)))
+uint16x8_t vqaddq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u32)))
+uint32x4_t vqaddq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u32)))
+uint32x4_t vqaddq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u8)))
+uint8x16_t vqaddq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_m_u8)))
+uint8x16_t vqaddq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s16)))
+int16x8_t vqaddq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s16)))
+int16x8_t vqaddq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s32)))
+int32x4_t vqaddq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s32)))
+int32x4_t vqaddq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s8)))
+int8x16_t vqaddq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_s8)))
+int8x16_t vqaddq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u16)))
+uint16x8_t vqaddq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u16)))
+uint16x8_t vqaddq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u32)))
+uint32x4_t vqaddq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u32)))
+uint32x4_t vqaddq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u8)))
+uint8x16_t vqaddq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_n_u8)))
+uint8x16_t vqaddq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s16)))
+int16x8_t vqaddq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s16)))
+int16x8_t vqaddq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s32)))
+int32x4_t vqaddq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s32)))
+int32x4_t vqaddq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s8)))
+int8x16_t vqaddq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_s8)))
+int8x16_t vqaddq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u16)))
+uint16x8_t vqaddq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u16)))
+uint16x8_t vqaddq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u32)))
+uint32x4_t vqaddq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u32)))
+uint32x4_t vqaddq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u8)))
+uint8x16_t vqaddq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqaddq_u8)))
+uint8x16_t vqaddq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s16)))
+int16x8_t vqdmladhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s16)))
+int16x8_t vqdmladhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s32)))
+int32x4_t vqdmladhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s32)))
+int32x4_t vqdmladhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s8)))
+int8x16_t vqdmladhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_m_s8)))
+int8x16_t vqdmladhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s16)))
+int16x8_t vqdmladhq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s16)))
+int16x8_t vqdmladhq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s32)))
+int32x4_t vqdmladhq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s32)))
+int32x4_t vqdmladhq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s8)))
+int8x16_t vqdmladhq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhq_s8)))
+int8x16_t vqdmladhq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s16)))
+int16x8_t vqdmladhxq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s16)))
+int16x8_t vqdmladhxq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s32)))
+int32x4_t vqdmladhxq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s32)))
+int32x4_t vqdmladhxq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s8)))
+int8x16_t vqdmladhxq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_m_s8)))
+int8x16_t vqdmladhxq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s16)))
+int16x8_t vqdmladhxq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s16)))
+int16x8_t vqdmladhxq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s32)))
+int32x4_t vqdmladhxq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s32)))
+int32x4_t vqdmladhxq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s8)))
+int8x16_t vqdmladhxq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmladhxq_s8)))
+int8x16_t vqdmladhxq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s16)))
+int16x8_t vqdmlahq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s16)))
+int16x8_t vqdmlahq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s32)))
+int32x4_t vqdmlahq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s32)))
+int32x4_t vqdmlahq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s8)))
+int8x16_t vqdmlahq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_m_n_s8)))
+int8x16_t vqdmlahq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s16)))
+int16x8_t vqdmlahq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s16)))
+int16x8_t vqdmlahq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s32)))
+int32x4_t vqdmlahq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s32)))
+int32x4_t vqdmlahq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s8)))
+int8x16_t vqdmlahq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlahq_n_s8)))
+int8x16_t vqdmlahq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s16)))
+int16x8_t vqdmlashq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s16)))
+int16x8_t vqdmlashq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s32)))
+int32x4_t vqdmlashq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s32)))
+int32x4_t vqdmlashq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s8)))
+int8x16_t vqdmlashq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_m_n_s8)))
+int8x16_t vqdmlashq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s16)))
+int16x8_t vqdmlashq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s16)))
+int16x8_t vqdmlashq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s32)))
+int32x4_t vqdmlashq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s32)))
+int32x4_t vqdmlashq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s8)))
+int8x16_t vqdmlashq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlashq_n_s8)))
+int8x16_t vqdmlashq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s16)))
+int16x8_t vqdmlsdhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s16)))
+int16x8_t vqdmlsdhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s32)))
+int32x4_t vqdmlsdhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s32)))
+int32x4_t vqdmlsdhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s8)))
+int8x16_t vqdmlsdhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_m_s8)))
+int8x16_t vqdmlsdhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s16)))
+int16x8_t vqdmlsdhq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s16)))
+int16x8_t vqdmlsdhq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s32)))
+int32x4_t vqdmlsdhq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s32)))
+int32x4_t vqdmlsdhq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s8)))
+int8x16_t vqdmlsdhq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhq_s8)))
+int8x16_t vqdmlsdhq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s16)))
+int16x8_t vqdmlsdhxq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s16)))
+int16x8_t vqdmlsdhxq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s32)))
+int32x4_t vqdmlsdhxq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s32)))
+int32x4_t vqdmlsdhxq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s8)))
+int8x16_t vqdmlsdhxq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_m_s8)))
+int8x16_t vqdmlsdhxq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s16)))
+int16x8_t vqdmlsdhxq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s16)))
+int16x8_t vqdmlsdhxq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s32)))
+int32x4_t vqdmlsdhxq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s32)))
+int32x4_t vqdmlsdhxq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s8)))
+int8x16_t vqdmlsdhxq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmlsdhxq_s8)))
+int8x16_t vqdmlsdhxq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s16)))
+int16x8_t vqdmulhq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s16)))
+int16x8_t vqdmulhq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s32)))
+int32x4_t vqdmulhq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s32)))
+int32x4_t vqdmulhq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s8)))
+int8x16_t vqdmulhq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_n_s8)))
+int8x16_t vqdmulhq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s16)))
+int16x8_t vqdmulhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s16)))
+int16x8_t vqdmulhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s32)))
+int32x4_t vqdmulhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s32)))
+int32x4_t vqdmulhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s8)))
+int8x16_t vqdmulhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_m_s8)))
+int8x16_t vqdmulhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s16)))
+int16x8_t vqdmulhq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s16)))
+int16x8_t vqdmulhq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s32)))
+int32x4_t vqdmulhq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s32)))
+int32x4_t vqdmulhq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s8)))
+int8x16_t vqdmulhq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_n_s8)))
+int8x16_t vqdmulhq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s16)))
+int16x8_t vqdmulhq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s16)))
+int16x8_t vqdmulhq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s32)))
+int32x4_t vqdmulhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s32)))
+int32x4_t vqdmulhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s8)))
+int8x16_t vqdmulhq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulhq_s8)))
+int8x16_t vqdmulhq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_n_s16)))
+int32x4_t vqdmullbq_m_n_s16(int32x4_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_n_s16)))
+int32x4_t vqdmullbq_m(int32x4_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_n_s32)))
+int64x2_t vqdmullbq_m_n_s32(int64x2_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_n_s32)))
+int64x2_t vqdmullbq_m(int64x2_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_s16)))
+int32x4_t vqdmullbq_m_s16(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_s16)))
+int32x4_t vqdmullbq_m(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_s32)))
+int64x2_t vqdmullbq_m_s32(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_m_s32)))
+int64x2_t vqdmullbq_m(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_n_s16)))
+int32x4_t vqdmullbq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_n_s16)))
+int32x4_t vqdmullbq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_n_s32)))
+int64x2_t vqdmullbq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_n_s32)))
+int64x2_t vqdmullbq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_s16)))
+int32x4_t vqdmullbq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_s16)))
+int32x4_t vqdmullbq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_s32)))
+int64x2_t vqdmullbq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmullbq_s32)))
+int64x2_t vqdmullbq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_n_s16)))
+int32x4_t vqdmulltq_m_n_s16(int32x4_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_n_s16)))
+int32x4_t vqdmulltq_m(int32x4_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_n_s32)))
+int64x2_t vqdmulltq_m_n_s32(int64x2_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_n_s32)))
+int64x2_t vqdmulltq_m(int64x2_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_s16)))
+int32x4_t vqdmulltq_m_s16(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_s16)))
+int32x4_t vqdmulltq_m(int32x4_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_s32)))
+int64x2_t vqdmulltq_m_s32(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_m_s32)))
+int64x2_t vqdmulltq_m(int64x2_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_n_s16)))
+int32x4_t vqdmulltq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_n_s16)))
+int32x4_t vqdmulltq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_n_s32)))
+int64x2_t vqdmulltq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_n_s32)))
+int64x2_t vqdmulltq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_s16)))
+int32x4_t vqdmulltq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_s16)))
+int32x4_t vqdmulltq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_s32)))
+int64x2_t vqdmulltq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqdmulltq_s32)))
+int64x2_t vqdmulltq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_s16)))
+int8x16_t vqmovnbq_m_s16(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_s16)))
+int8x16_t vqmovnbq_m(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_s32)))
+int16x8_t vqmovnbq_m_s32(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_s32)))
+int16x8_t vqmovnbq_m(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_u16)))
+uint8x16_t vqmovnbq_m_u16(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_u16)))
+uint8x16_t vqmovnbq_m(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_u32)))
+uint16x8_t vqmovnbq_m_u32(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_m_u32)))
+uint16x8_t vqmovnbq_m(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_s16)))
+int8x16_t vqmovnbq_s16(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_s16)))
+int8x16_t vqmovnbq(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_s32)))
+int16x8_t vqmovnbq_s32(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_s32)))
+int16x8_t vqmovnbq(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_u16)))
+uint8x16_t vqmovnbq_u16(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_u16)))
+uint8x16_t vqmovnbq(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_u32)))
+uint16x8_t vqmovnbq_u32(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovnbq_u32)))
+uint16x8_t vqmovnbq(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_s16)))
+int8x16_t vqmovntq_m_s16(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_s16)))
+int8x16_t vqmovntq_m(int8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_s32)))
+int16x8_t vqmovntq_m_s32(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_s32)))
+int16x8_t vqmovntq_m(int16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_u16)))
+uint8x16_t vqmovntq_m_u16(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_u16)))
+uint8x16_t vqmovntq_m(uint8x16_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_u32)))
+uint16x8_t vqmovntq_m_u32(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_m_u32)))
+uint16x8_t vqmovntq_m(uint16x8_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_s16)))
+int8x16_t vqmovntq_s16(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_s16)))
+int8x16_t vqmovntq(int8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_s32)))
+int16x8_t vqmovntq_s32(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_s32)))
+int16x8_t vqmovntq(int16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_u16)))
+uint8x16_t vqmovntq_u16(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_u16)))
+uint8x16_t vqmovntq(uint8x16_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_u32)))
+uint16x8_t vqmovntq_u32(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovntq_u32)))
+uint16x8_t vqmovntq(uint16x8_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_m_s16)))
+uint8x16_t vqmovunbq_m_s16(uint8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_m_s16)))
+uint8x16_t vqmovunbq_m(uint8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_m_s32)))
+uint16x8_t vqmovunbq_m_s32(uint16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_m_s32)))
+uint16x8_t vqmovunbq_m(uint16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_s16)))
+uint8x16_t vqmovunbq_s16(uint8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_s16)))
+uint8x16_t vqmovunbq(uint8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_s32)))
+uint16x8_t vqmovunbq_s32(uint16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovunbq_s32)))
+uint16x8_t vqmovunbq(uint16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_m_s16)))
+uint8x16_t vqmovuntq_m_s16(uint8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_m_s16)))
+uint8x16_t vqmovuntq_m(uint8x16_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_m_s32)))
+uint16x8_t vqmovuntq_m_s32(uint16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_m_s32)))
+uint16x8_t vqmovuntq_m(uint16x8_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_s16)))
+uint8x16_t vqmovuntq_s16(uint8x16_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_s16)))
+uint8x16_t vqmovuntq(uint8x16_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_s32)))
+uint16x8_t vqmovuntq_s32(uint16x8_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqmovuntq_s32)))
+uint16x8_t vqmovuntq(uint16x8_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s16)))
+int16x8_t vqnegq_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s16)))
+int16x8_t vqnegq_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s32)))
+int32x4_t vqnegq_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s32)))
+int32x4_t vqnegq_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s8)))
+int8x16_t vqnegq_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_m_s8)))
+int8x16_t vqnegq_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s16)))
+int16x8_t vqnegq_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s16)))
+int16x8_t vqnegq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s32)))
+int32x4_t vqnegq_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s32)))
+int32x4_t vqnegq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s8)))
+int8x16_t vqnegq_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqnegq_s8)))
+int8x16_t vqnegq(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s16)))
+int16x8_t vqrdmladhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s16)))
+int16x8_t vqrdmladhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s32)))
+int32x4_t vqrdmladhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s32)))
+int32x4_t vqrdmladhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s8)))
+int8x16_t vqrdmladhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_m_s8)))
+int8x16_t vqrdmladhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s16)))
+int16x8_t vqrdmladhq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s16)))
+int16x8_t vqrdmladhq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s32)))
+int32x4_t vqrdmladhq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s32)))
+int32x4_t vqrdmladhq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s8)))
+int8x16_t vqrdmladhq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhq_s8)))
+int8x16_t vqrdmladhq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s16)))
+int16x8_t vqrdmladhxq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s16)))
+int16x8_t vqrdmladhxq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s32)))
+int32x4_t vqrdmladhxq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s32)))
+int32x4_t vqrdmladhxq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s8)))
+int8x16_t vqrdmladhxq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_m_s8)))
+int8x16_t vqrdmladhxq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s16)))
+int16x8_t vqrdmladhxq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s16)))
+int16x8_t vqrdmladhxq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s32)))
+int32x4_t vqrdmladhxq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s32)))
+int32x4_t vqrdmladhxq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s8)))
+int8x16_t vqrdmladhxq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmladhxq_s8)))
+int8x16_t vqrdmladhxq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s16)))
+int16x8_t vqrdmlahq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s16)))
+int16x8_t vqrdmlahq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s32)))
+int32x4_t vqrdmlahq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s32)))
+int32x4_t vqrdmlahq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s8)))
+int8x16_t vqrdmlahq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_m_n_s8)))
+int8x16_t vqrdmlahq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s16)))
+int16x8_t vqrdmlahq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s16)))
+int16x8_t vqrdmlahq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s32)))
+int32x4_t vqrdmlahq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s32)))
+int32x4_t vqrdmlahq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s8)))
+int8x16_t vqrdmlahq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlahq_n_s8)))
+int8x16_t vqrdmlahq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s16)))
+int16x8_t vqrdmlashq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s16)))
+int16x8_t vqrdmlashq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s32)))
+int32x4_t vqrdmlashq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s32)))
+int32x4_t vqrdmlashq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s8)))
+int8x16_t vqrdmlashq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_m_n_s8)))
+int8x16_t vqrdmlashq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s16)))
+int16x8_t vqrdmlashq_n_s16(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s16)))
+int16x8_t vqrdmlashq(int16x8_t, int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s32)))
+int32x4_t vqrdmlashq_n_s32(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s32)))
+int32x4_t vqrdmlashq(int32x4_t, int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s8)))
+int8x16_t vqrdmlashq_n_s8(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlashq_n_s8)))
+int8x16_t vqrdmlashq(int8x16_t, int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s16)))
+int16x8_t vqrdmlsdhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s16)))
+int16x8_t vqrdmlsdhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s32)))
+int32x4_t vqrdmlsdhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s32)))
+int32x4_t vqrdmlsdhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s8)))
+int8x16_t vqrdmlsdhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_m_s8)))
+int8x16_t vqrdmlsdhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s16)))
+int16x8_t vqrdmlsdhq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s16)))
+int16x8_t vqrdmlsdhq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s32)))
+int32x4_t vqrdmlsdhq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s32)))
+int32x4_t vqrdmlsdhq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s8)))
+int8x16_t vqrdmlsdhq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhq_s8)))
+int8x16_t vqrdmlsdhq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s16)))
+int16x8_t vqrdmlsdhxq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s16)))
+int16x8_t vqrdmlsdhxq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s32)))
+int32x4_t vqrdmlsdhxq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s32)))
+int32x4_t vqrdmlsdhxq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s8)))
+int8x16_t vqrdmlsdhxq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_m_s8)))
+int8x16_t vqrdmlsdhxq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s16)))
+int16x8_t vqrdmlsdhxq_s16(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s16)))
+int16x8_t vqrdmlsdhxq(int16x8_t, int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s32)))
+int32x4_t vqrdmlsdhxq_s32(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s32)))
+int32x4_t vqrdmlsdhxq(int32x4_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s8)))
+int8x16_t vqrdmlsdhxq_s8(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmlsdhxq_s8)))
+int8x16_t vqrdmlsdhxq(int8x16_t, int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s16)))
+int16x8_t vqrdmulhq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s16)))
+int16x8_t vqrdmulhq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s32)))
+int32x4_t vqrdmulhq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s32)))
+int32x4_t vqrdmulhq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s8)))
+int8x16_t vqrdmulhq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_n_s8)))
+int8x16_t vqrdmulhq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s16)))
+int16x8_t vqrdmulhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s16)))
+int16x8_t vqrdmulhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s32)))
+int32x4_t vqrdmulhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s32)))
+int32x4_t vqrdmulhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s8)))
+int8x16_t vqrdmulhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_m_s8)))
+int8x16_t vqrdmulhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s16)))
+int16x8_t vqrdmulhq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s16)))
+int16x8_t vqrdmulhq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s32)))
+int32x4_t vqrdmulhq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s32)))
+int32x4_t vqrdmulhq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s8)))
+int8x16_t vqrdmulhq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_n_s8)))
+int8x16_t vqrdmulhq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s16)))
+int16x8_t vqrdmulhq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s16)))
+int16x8_t vqrdmulhq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s32)))
+int32x4_t vqrdmulhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s32)))
+int32x4_t vqrdmulhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s8)))
+int8x16_t vqrdmulhq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrdmulhq_s8)))
+int8x16_t vqrdmulhq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s16)))
+int16x8_t vqrshlq_m_n_s16(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s16)))
+int16x8_t vqrshlq_m_n(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s32)))
+int32x4_t vqrshlq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s32)))
+int32x4_t vqrshlq_m_n(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s8)))
+int8x16_t vqrshlq_m_n_s8(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_s8)))
+int8x16_t vqrshlq_m_n(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u16)))
+uint16x8_t vqrshlq_m_n_u16(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u16)))
+uint16x8_t vqrshlq_m_n(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u32)))
+uint32x4_t vqrshlq_m_n_u32(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u32)))
+uint32x4_t vqrshlq_m_n(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u8)))
+uint8x16_t vqrshlq_m_n_u8(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_n_u8)))
+uint8x16_t vqrshlq_m_n(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s16)))
+int16x8_t vqrshlq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s16)))
+int16x8_t vqrshlq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s32)))
+int32x4_t vqrshlq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s32)))
+int32x4_t vqrshlq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s8)))
+int8x16_t vqrshlq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_s8)))
+int8x16_t vqrshlq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u16)))
+uint16x8_t vqrshlq_m_u16(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u16)))
+uint16x8_t vqrshlq_m(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u32)))
+uint32x4_t vqrshlq_m_u32(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u32)))
+uint32x4_t vqrshlq_m(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u8)))
+uint8x16_t vqrshlq_m_u8(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_m_u8)))
+uint8x16_t vqrshlq_m(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s16)))
+int16x8_t vqrshlq_n_s16(int16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s16)))
+int16x8_t vqrshlq(int16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s32)))
+int32x4_t vqrshlq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s32)))
+int32x4_t vqrshlq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s8)))
+int8x16_t vqrshlq_n_s8(int8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_s8)))
+int8x16_t vqrshlq(int8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u16)))
+uint16x8_t vqrshlq_n_u16(uint16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u16)))
+uint16x8_t vqrshlq(uint16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u32)))
+uint32x4_t vqrshlq_n_u32(uint32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u32)))
+uint32x4_t vqrshlq(uint32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u8)))
+uint8x16_t vqrshlq_n_u8(uint8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_n_u8)))
+uint8x16_t vqrshlq(uint8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s16)))
+int16x8_t vqrshlq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s16)))
+int16x8_t vqrshlq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s32)))
+int32x4_t vqrshlq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s32)))
+int32x4_t vqrshlq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s8)))
+int8x16_t vqrshlq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_s8)))
+int8x16_t vqrshlq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u16)))
+uint16x8_t vqrshlq_u16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u16)))
+uint16x8_t vqrshlq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u32)))
+uint32x4_t vqrshlq_u32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u32)))
+uint32x4_t vqrshlq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u8)))
+uint8x16_t vqrshlq_u8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshlq_u8)))
+uint8x16_t vqrshlq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_s16)))
+int8x16_t vqrshrnbq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_s16)))
+int8x16_t vqrshrnbq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_s32)))
+int16x8_t vqrshrnbq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_s32)))
+int16x8_t vqrshrnbq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_u16)))
+uint8x16_t vqrshrnbq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_u16)))
+uint8x16_t vqrshrnbq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_u32)))
+uint16x8_t vqrshrnbq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_m_n_u32)))
+uint16x8_t vqrshrnbq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_s16)))
+int8x16_t vqrshrnbq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_s16)))
+int8x16_t vqrshrnbq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_s32)))
+int16x8_t vqrshrnbq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_s32)))
+int16x8_t vqrshrnbq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_u16)))
+uint8x16_t vqrshrnbq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_u16)))
+uint8x16_t vqrshrnbq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_u32)))
+uint16x8_t vqrshrnbq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrnbq_n_u32)))
+uint16x8_t vqrshrnbq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_s16)))
+int8x16_t vqrshrntq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_s16)))
+int8x16_t vqrshrntq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_s32)))
+int16x8_t vqrshrntq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_s32)))
+int16x8_t vqrshrntq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_u16)))
+uint8x16_t vqrshrntq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_u16)))
+uint8x16_t vqrshrntq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_u32)))
+uint16x8_t vqrshrntq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_m_n_u32)))
+uint16x8_t vqrshrntq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_s16)))
+int8x16_t vqrshrntq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_s16)))
+int8x16_t vqrshrntq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_s32)))
+int16x8_t vqrshrntq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_s32)))
+int16x8_t vqrshrntq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_u16)))
+uint8x16_t vqrshrntq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_u16)))
+uint8x16_t vqrshrntq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_u32)))
+uint16x8_t vqrshrntq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrntq_n_u32)))
+uint16x8_t vqrshrntq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_m_n_s16)))
+uint8x16_t vqrshrunbq_m_n_s16(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_m_n_s16)))
+uint8x16_t vqrshrunbq_m(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_m_n_s32)))
+uint16x8_t vqrshrunbq_m_n_s32(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_m_n_s32)))
+uint16x8_t vqrshrunbq_m(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_n_s16)))
+uint8x16_t vqrshrunbq_n_s16(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_n_s16)))
+uint8x16_t vqrshrunbq(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_n_s32)))
+uint16x8_t vqrshrunbq_n_s32(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshrunbq_n_s32)))
+uint16x8_t vqrshrunbq(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_m_n_s16)))
+uint8x16_t vqrshruntq_m_n_s16(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_m_n_s16)))
+uint8x16_t vqrshruntq_m(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_m_n_s32)))
+uint16x8_t vqrshruntq_m_n_s32(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_m_n_s32)))
+uint16x8_t vqrshruntq_m(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_n_s16)))
+uint8x16_t vqrshruntq_n_s16(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_n_s16)))
+uint8x16_t vqrshruntq(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_n_s32)))
+uint16x8_t vqrshruntq_n_s32(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqrshruntq_n_s32)))
+uint16x8_t vqrshruntq(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s16)))
+int16x8_t vqshlq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s16)))
+int16x8_t vqshlq_m_n(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s32)))
+int32x4_t vqshlq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s32)))
+int32x4_t vqshlq_m_n(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s8)))
+int8x16_t vqshlq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_s8)))
+int8x16_t vqshlq_m_n(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u16)))
+uint16x8_t vqshlq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u16)))
+uint16x8_t vqshlq_m_n(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u32)))
+uint32x4_t vqshlq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u32)))
+uint32x4_t vqshlq_m_n(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u8)))
+uint8x16_t vqshlq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_n_u8)))
+uint8x16_t vqshlq_m_n(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s16)))
+int16x8_t vqshlq_m_r_s16(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s16)))
+int16x8_t vqshlq_m_r(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s32)))
+int32x4_t vqshlq_m_r_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s32)))
+int32x4_t vqshlq_m_r(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s8)))
+int8x16_t vqshlq_m_r_s8(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_s8)))
+int8x16_t vqshlq_m_r(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u16)))
+uint16x8_t vqshlq_m_r_u16(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u16)))
+uint16x8_t vqshlq_m_r(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u32)))
+uint32x4_t vqshlq_m_r_u32(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u32)))
+uint32x4_t vqshlq_m_r(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u8)))
+uint8x16_t vqshlq_m_r_u8(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_r_u8)))
+uint8x16_t vqshlq_m_r(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s16)))
+int16x8_t vqshlq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s16)))
+int16x8_t vqshlq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s32)))
+int32x4_t vqshlq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s32)))
+int32x4_t vqshlq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s8)))
+int8x16_t vqshlq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_s8)))
+int8x16_t vqshlq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u16)))
+uint16x8_t vqshlq_m_u16(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u16)))
+uint16x8_t vqshlq_m(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u32)))
+uint32x4_t vqshlq_m_u32(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u32)))
+uint32x4_t vqshlq_m(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u8)))
+uint8x16_t vqshlq_m_u8(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_m_u8)))
+uint8x16_t vqshlq_m(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s16)))
+int16x8_t vqshlq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s16)))
+int16x8_t vqshlq_n(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s32)))
+int32x4_t vqshlq_n_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s32)))
+int32x4_t vqshlq_n(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s8)))
+int8x16_t vqshlq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_s8)))
+int8x16_t vqshlq_n(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u16)))
+uint16x8_t vqshlq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u16)))
+uint16x8_t vqshlq_n(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u32)))
+uint32x4_t vqshlq_n_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u32)))
+uint32x4_t vqshlq_n(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u8)))
+uint8x16_t vqshlq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_n_u8)))
+uint8x16_t vqshlq_n(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s16)))
+int16x8_t vqshlq_r_s16(int16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s16)))
+int16x8_t vqshlq_r(int16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s32)))
+int32x4_t vqshlq_r_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s32)))
+int32x4_t vqshlq_r(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s8)))
+int8x16_t vqshlq_r_s8(int8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_s8)))
+int8x16_t vqshlq_r(int8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u16)))
+uint16x8_t vqshlq_r_u16(uint16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u16)))
+uint16x8_t vqshlq_r(uint16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u32)))
+uint32x4_t vqshlq_r_u32(uint32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u32)))
+uint32x4_t vqshlq_r(uint32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u8)))
+uint8x16_t vqshlq_r_u8(uint8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_r_u8)))
+uint8x16_t vqshlq_r(uint8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s16)))
+int16x8_t vqshlq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s16)))
+int16x8_t vqshlq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s32)))
+int32x4_t vqshlq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s32)))
+int32x4_t vqshlq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s8)))
+int8x16_t vqshlq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_s8)))
+int8x16_t vqshlq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u16)))
+uint16x8_t vqshlq_u16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u16)))
+uint16x8_t vqshlq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u32)))
+uint32x4_t vqshlq_u32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u32)))
+uint32x4_t vqshlq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u8)))
+uint8x16_t vqshlq_u8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshlq_u8)))
+uint8x16_t vqshlq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s16)))
+uint16x8_t vqshluq_m_n_s16(uint16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s16)))
+uint16x8_t vqshluq_m(uint16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s32)))
+uint32x4_t vqshluq_m_n_s32(uint32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s32)))
+uint32x4_t vqshluq_m(uint32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s8)))
+uint8x16_t vqshluq_m_n_s8(uint8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_m_n_s8)))
+uint8x16_t vqshluq_m(uint8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s16)))
+uint16x8_t vqshluq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s16)))
+uint16x8_t vqshluq(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s32)))
+uint32x4_t vqshluq_n_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s32)))
+uint32x4_t vqshluq(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s8)))
+uint8x16_t vqshluq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshluq_n_s8)))
+uint8x16_t vqshluq(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_s16)))
+int8x16_t vqshrnbq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_s16)))
+int8x16_t vqshrnbq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_s32)))
+int16x8_t vqshrnbq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_s32)))
+int16x8_t vqshrnbq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_u16)))
+uint8x16_t vqshrnbq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_u16)))
+uint8x16_t vqshrnbq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_u32)))
+uint16x8_t vqshrnbq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_m_n_u32)))
+uint16x8_t vqshrnbq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_s16)))
+int8x16_t vqshrnbq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_s16)))
+int8x16_t vqshrnbq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_s32)))
+int16x8_t vqshrnbq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_s32)))
+int16x8_t vqshrnbq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_u16)))
+uint8x16_t vqshrnbq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_u16)))
+uint8x16_t vqshrnbq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_u32)))
+uint16x8_t vqshrnbq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrnbq_n_u32)))
+uint16x8_t vqshrnbq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_s16)))
+int8x16_t vqshrntq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_s16)))
+int8x16_t vqshrntq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_s32)))
+int16x8_t vqshrntq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_s32)))
+int16x8_t vqshrntq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_u16)))
+uint8x16_t vqshrntq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_u16)))
+uint8x16_t vqshrntq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_u32)))
+uint16x8_t vqshrntq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_m_n_u32)))
+uint16x8_t vqshrntq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_s16)))
+int8x16_t vqshrntq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_s16)))
+int8x16_t vqshrntq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_s32)))
+int16x8_t vqshrntq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_s32)))
+int16x8_t vqshrntq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_u16)))
+uint8x16_t vqshrntq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_u16)))
+uint8x16_t vqshrntq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_u32)))
+uint16x8_t vqshrntq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrntq_n_u32)))
+uint16x8_t vqshrntq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_m_n_s16)))
+uint8x16_t vqshrunbq_m_n_s16(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_m_n_s16)))
+uint8x16_t vqshrunbq_m(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_m_n_s32)))
+uint16x8_t vqshrunbq_m_n_s32(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_m_n_s32)))
+uint16x8_t vqshrunbq_m(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_n_s16)))
+uint8x16_t vqshrunbq_n_s16(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_n_s16)))
+uint8x16_t vqshrunbq(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_n_s32)))
+uint16x8_t vqshrunbq_n_s32(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshrunbq_n_s32)))
+uint16x8_t vqshrunbq(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_m_n_s16)))
+uint8x16_t vqshruntq_m_n_s16(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_m_n_s16)))
+uint8x16_t vqshruntq_m(uint8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_m_n_s32)))
+uint16x8_t vqshruntq_m_n_s32(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_m_n_s32)))
+uint16x8_t vqshruntq_m(uint16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_n_s16)))
+uint8x16_t vqshruntq_n_s16(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_n_s16)))
+uint8x16_t vqshruntq(uint8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_n_s32)))
+uint16x8_t vqshruntq_n_s32(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqshruntq_n_s32)))
+uint16x8_t vqshruntq(uint16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s16)))
+int16x8_t vqsubq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s16)))
+int16x8_t vqsubq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s32)))
+int32x4_t vqsubq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s32)))
+int32x4_t vqsubq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s8)))
+int8x16_t vqsubq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_s8)))
+int8x16_t vqsubq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u16)))
+uint16x8_t vqsubq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u16)))
+uint16x8_t vqsubq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u32)))
+uint32x4_t vqsubq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u32)))
+uint32x4_t vqsubq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u8)))
+uint8x16_t vqsubq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_n_u8)))
+uint8x16_t vqsubq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s16)))
+int16x8_t vqsubq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s16)))
+int16x8_t vqsubq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s32)))
+int32x4_t vqsubq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s32)))
+int32x4_t vqsubq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s8)))
+int8x16_t vqsubq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_s8)))
+int8x16_t vqsubq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u16)))
+uint16x8_t vqsubq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u16)))
+uint16x8_t vqsubq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u32)))
+uint32x4_t vqsubq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u32)))
+uint32x4_t vqsubq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u8)))
+uint8x16_t vqsubq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_m_u8)))
+uint8x16_t vqsubq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s16)))
+int16x8_t vqsubq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s16)))
+int16x8_t vqsubq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s32)))
+int32x4_t vqsubq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s32)))
+int32x4_t vqsubq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s8)))
+int8x16_t vqsubq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_s8)))
+int8x16_t vqsubq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u16)))
+uint16x8_t vqsubq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u16)))
+uint16x8_t vqsubq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u32)))
+uint32x4_t vqsubq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u32)))
+uint32x4_t vqsubq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u8)))
+uint8x16_t vqsubq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_n_u8)))
+uint8x16_t vqsubq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s16)))
+int16x8_t vqsubq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s16)))
+int16x8_t vqsubq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s32)))
+int32x4_t vqsubq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s32)))
+int32x4_t vqsubq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s8)))
+int8x16_t vqsubq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_s8)))
+int8x16_t vqsubq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u16)))
+uint16x8_t vqsubq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u16)))
+uint16x8_t vqsubq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u32)))
+uint32x4_t vqsubq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u32)))
+uint32x4_t vqsubq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u8)))
+uint8x16_t vqsubq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vqsubq_u8)))
+uint8x16_t vqsubq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s32)))
+int16x8_t vreinterpretq_s16_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s32)))
+int16x8_t vreinterpretq_s16(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s64)))
+int16x8_t vreinterpretq_s16_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s64)))
+int16x8_t vreinterpretq_s16(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s8)))
+int16x8_t vreinterpretq_s16_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_s8)))
+int16x8_t vreinterpretq_s16(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u16)))
+int16x8_t vreinterpretq_s16_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u16)))
+int16x8_t vreinterpretq_s16(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u32)))
+int16x8_t vreinterpretq_s16_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u32)))
+int16x8_t vreinterpretq_s16(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u64)))
+int16x8_t vreinterpretq_s16_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u64)))
+int16x8_t vreinterpretq_s16(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u8)))
+int16x8_t vreinterpretq_s16_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_u8)))
+int16x8_t vreinterpretq_s16(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s16)))
+int32x4_t vreinterpretq_s32_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s16)))
+int32x4_t vreinterpretq_s32(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s64)))
+int32x4_t vreinterpretq_s32_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s64)))
+int32x4_t vreinterpretq_s32(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s8)))
+int32x4_t vreinterpretq_s32_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_s8)))
+int32x4_t vreinterpretq_s32(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u16)))
+int32x4_t vreinterpretq_s32_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u16)))
+int32x4_t vreinterpretq_s32(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u32)))
+int32x4_t vreinterpretq_s32_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u32)))
+int32x4_t vreinterpretq_s32(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u64)))
+int32x4_t vreinterpretq_s32_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u64)))
+int32x4_t vreinterpretq_s32(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u8)))
+int32x4_t vreinterpretq_s32_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_u8)))
+int32x4_t vreinterpretq_s32(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s16)))
+int64x2_t vreinterpretq_s64_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s16)))
+int64x2_t vreinterpretq_s64(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s32)))
+int64x2_t vreinterpretq_s64_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s32)))
+int64x2_t vreinterpretq_s64(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s8)))
+int64x2_t vreinterpretq_s64_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_s8)))
+int64x2_t vreinterpretq_s64(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u16)))
+int64x2_t vreinterpretq_s64_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u16)))
+int64x2_t vreinterpretq_s64(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u32)))
+int64x2_t vreinterpretq_s64_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u32)))
+int64x2_t vreinterpretq_s64(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u64)))
+int64x2_t vreinterpretq_s64_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u64)))
+int64x2_t vreinterpretq_s64(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u8)))
+int64x2_t vreinterpretq_s64_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_u8)))
+int64x2_t vreinterpretq_s64(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s16)))
+int8x16_t vreinterpretq_s8_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s16)))
+int8x16_t vreinterpretq_s8(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s32)))
+int8x16_t vreinterpretq_s8_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s32)))
+int8x16_t vreinterpretq_s8(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s64)))
+int8x16_t vreinterpretq_s8_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_s64)))
+int8x16_t vreinterpretq_s8(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u16)))
+int8x16_t vreinterpretq_s8_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u16)))
+int8x16_t vreinterpretq_s8(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u32)))
+int8x16_t vreinterpretq_s8_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u32)))
+int8x16_t vreinterpretq_s8(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u64)))
+int8x16_t vreinterpretq_s8_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u64)))
+int8x16_t vreinterpretq_s8(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u8)))
+int8x16_t vreinterpretq_s8_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_u8)))
+int8x16_t vreinterpretq_s8(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s16)))
+uint16x8_t vreinterpretq_u16_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s16)))
+uint16x8_t vreinterpretq_u16(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s32)))
+uint16x8_t vreinterpretq_u16_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s32)))
+uint16x8_t vreinterpretq_u16(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s64)))
+uint16x8_t vreinterpretq_u16_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s64)))
+uint16x8_t vreinterpretq_u16(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s8)))
+uint16x8_t vreinterpretq_u16_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_s8)))
+uint16x8_t vreinterpretq_u16(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u32)))
+uint16x8_t vreinterpretq_u16_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u32)))
+uint16x8_t vreinterpretq_u16(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u64)))
+uint16x8_t vreinterpretq_u16_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u64)))
+uint16x8_t vreinterpretq_u16(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u8)))
+uint16x8_t vreinterpretq_u16_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_u8)))
+uint16x8_t vreinterpretq_u16(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s16)))
+uint32x4_t vreinterpretq_u32_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s16)))
+uint32x4_t vreinterpretq_u32(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s32)))
+uint32x4_t vreinterpretq_u32_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s32)))
+uint32x4_t vreinterpretq_u32(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s64)))
+uint32x4_t vreinterpretq_u32_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s64)))
+uint32x4_t vreinterpretq_u32(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s8)))
+uint32x4_t vreinterpretq_u32_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_s8)))
+uint32x4_t vreinterpretq_u32(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u16)))
+uint32x4_t vreinterpretq_u32_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u16)))
+uint32x4_t vreinterpretq_u32(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u64)))
+uint32x4_t vreinterpretq_u32_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u64)))
+uint32x4_t vreinterpretq_u32(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u8)))
+uint32x4_t vreinterpretq_u32_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_u8)))
+uint32x4_t vreinterpretq_u32(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s16)))
+uint64x2_t vreinterpretq_u64_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s16)))
+uint64x2_t vreinterpretq_u64(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s32)))
+uint64x2_t vreinterpretq_u64_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s32)))
+uint64x2_t vreinterpretq_u64(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s64)))
+uint64x2_t vreinterpretq_u64_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s64)))
+uint64x2_t vreinterpretq_u64(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s8)))
+uint64x2_t vreinterpretq_u64_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_s8)))
+uint64x2_t vreinterpretq_u64(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u16)))
+uint64x2_t vreinterpretq_u64_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u16)))
+uint64x2_t vreinterpretq_u64(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u32)))
+uint64x2_t vreinterpretq_u64_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u32)))
+uint64x2_t vreinterpretq_u64(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u8)))
+uint64x2_t vreinterpretq_u64_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_u8)))
+uint64x2_t vreinterpretq_u64(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s16)))
+uint8x16_t vreinterpretq_u8_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s16)))
+uint8x16_t vreinterpretq_u8(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s32)))
+uint8x16_t vreinterpretq_u8_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s32)))
+uint8x16_t vreinterpretq_u8(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s64)))
+uint8x16_t vreinterpretq_u8_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s64)))
+uint8x16_t vreinterpretq_u8(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s8)))
+uint8x16_t vreinterpretq_u8_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_s8)))
+uint8x16_t vreinterpretq_u8(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u16)))
+uint8x16_t vreinterpretq_u8_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u16)))
+uint8x16_t vreinterpretq_u8(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u32)))
+uint8x16_t vreinterpretq_u8_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u32)))
+uint8x16_t vreinterpretq_u8(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u64)))
+uint8x16_t vreinterpretq_u8_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_u64)))
+uint8x16_t vreinterpretq_u8(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_m_s8)))
+int8x16_t vrev16q_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_m_s8)))
+int8x16_t vrev16q_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_m_u8)))
+uint8x16_t vrev16q_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_m_u8)))
+uint8x16_t vrev16q_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_s8)))
+int8x16_t vrev16q_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_s8)))
+int8x16_t vrev16q(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_u8)))
+uint8x16_t vrev16q_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_u8)))
+uint8x16_t vrev16q(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_x_s8)))
+int8x16_t vrev16q_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_x_s8)))
+int8x16_t vrev16q_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_x_u8)))
+uint8x16_t vrev16q_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev16q_x_u8)))
+uint8x16_t vrev16q_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_s16)))
+int16x8_t vrev32q_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_s16)))
+int16x8_t vrev32q_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_s8)))
+int8x16_t vrev32q_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_s8)))
+int8x16_t vrev32q_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_u16)))
+uint16x8_t vrev32q_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_u16)))
+uint16x8_t vrev32q_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_u8)))
+uint8x16_t vrev32q_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_u8)))
+uint8x16_t vrev32q_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_s16)))
+int16x8_t vrev32q_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_s16)))
+int16x8_t vrev32q(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_s8)))
+int8x16_t vrev32q_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_s8)))
+int8x16_t vrev32q(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_u16)))
+uint16x8_t vrev32q_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_u16)))
+uint16x8_t vrev32q(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_u8)))
+uint8x16_t vrev32q_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_u8)))
+uint8x16_t vrev32q(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_s16)))
+int16x8_t vrev32q_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_s16)))
+int16x8_t vrev32q_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_s8)))
+int8x16_t vrev32q_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_s8)))
+int8x16_t vrev32q_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_u16)))
+uint16x8_t vrev32q_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_u16)))
+uint16x8_t vrev32q_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_u8)))
+uint8x16_t vrev32q_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_u8)))
+uint8x16_t vrev32q_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s16)))
+int16x8_t vrev64q_m_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s16)))
+int16x8_t vrev64q_m(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s32)))
+int32x4_t vrev64q_m_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s32)))
+int32x4_t vrev64q_m(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s8)))
+int8x16_t vrev64q_m_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_s8)))
+int8x16_t vrev64q_m(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u16)))
+uint16x8_t vrev64q_m_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u16)))
+uint16x8_t vrev64q_m(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u32)))
+uint32x4_t vrev64q_m_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u32)))
+uint32x4_t vrev64q_m(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u8)))
+uint8x16_t vrev64q_m_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_u8)))
+uint8x16_t vrev64q_m(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s16)))
+int16x8_t vrev64q_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s16)))
+int16x8_t vrev64q(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s32)))
+int32x4_t vrev64q_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s32)))
+int32x4_t vrev64q(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s8)))
+int8x16_t vrev64q_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_s8)))
+int8x16_t vrev64q(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u16)))
+uint16x8_t vrev64q_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u16)))
+uint16x8_t vrev64q(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u32)))
+uint32x4_t vrev64q_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u32)))
+uint32x4_t vrev64q(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u8)))
+uint8x16_t vrev64q_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_u8)))
+uint8x16_t vrev64q(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s16)))
+int16x8_t vrev64q_x_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s16)))
+int16x8_t vrev64q_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s32)))
+int32x4_t vrev64q_x_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s32)))
+int32x4_t vrev64q_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s8)))
+int8x16_t vrev64q_x_s8(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_s8)))
+int8x16_t vrev64q_x(int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u16)))
+uint16x8_t vrev64q_x_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u16)))
+uint16x8_t vrev64q_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u32)))
+uint32x4_t vrev64q_x_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u32)))
+uint32x4_t vrev64q_x(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u8)))
+uint8x16_t vrev64q_x_u8(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_u8)))
+uint8x16_t vrev64q_x(uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s16)))
+int16x8_t vrhaddq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s16)))
+int16x8_t vrhaddq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s32)))
+int32x4_t vrhaddq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s32)))
+int32x4_t vrhaddq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s8)))
+int8x16_t vrhaddq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_s8)))
+int8x16_t vrhaddq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u16)))
+uint16x8_t vrhaddq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u16)))
+uint16x8_t vrhaddq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u32)))
+uint32x4_t vrhaddq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u32)))
+uint32x4_t vrhaddq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u8)))
+uint8x16_t vrhaddq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_m_u8)))
+uint8x16_t vrhaddq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s16)))
+int16x8_t vrhaddq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s16)))
+int16x8_t vrhaddq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s32)))
+int32x4_t vrhaddq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s32)))
+int32x4_t vrhaddq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s8)))
+int8x16_t vrhaddq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_s8)))
+int8x16_t vrhaddq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u16)))
+uint16x8_t vrhaddq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u16)))
+uint16x8_t vrhaddq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u32)))
+uint32x4_t vrhaddq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u32)))
+uint32x4_t vrhaddq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u8)))
+uint8x16_t vrhaddq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_u8)))
+uint8x16_t vrhaddq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s16)))
+int16x8_t vrhaddq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s16)))
+int16x8_t vrhaddq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s32)))
+int32x4_t vrhaddq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s32)))
+int32x4_t vrhaddq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s8)))
+int8x16_t vrhaddq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_s8)))
+int8x16_t vrhaddq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u16)))
+uint16x8_t vrhaddq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u16)))
+uint16x8_t vrhaddq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u32)))
+uint32x4_t vrhaddq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u32)))
+uint32x4_t vrhaddq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u8)))
+uint8x16_t vrhaddq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrhaddq_x_u8)))
+uint8x16_t vrhaddq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_p_s32)))
+int64_t vrmlaldavhaq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_p_s32)))
+int64_t vrmlaldavhaq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_p_u32)))
+uint64_t vrmlaldavhaq_p_u32(uint64_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_p_u32)))
+uint64_t vrmlaldavhaq_p(uint64_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_s32)))
+int64_t vrmlaldavhaq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_s32)))
+int64_t vrmlaldavhaq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_u32)))
+uint64_t vrmlaldavhaq_u32(uint64_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaq_u32)))
+uint64_t vrmlaldavhaq(uint64_t, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaxq_p_s32)))
+int64_t vrmlaldavhaxq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaxq_p_s32)))
+int64_t vrmlaldavhaxq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaxq_s32)))
+int64_t vrmlaldavhaxq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhaxq_s32)))
+int64_t vrmlaldavhaxq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_p_s32)))
+int64_t vrmlaldavhq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_p_s32)))
+int64_t vrmlaldavhq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_p_u32)))
+uint64_t vrmlaldavhq_p_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_p_u32)))
+uint64_t vrmlaldavhq_p(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_s32)))
+int64_t vrmlaldavhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_s32)))
+int64_t vrmlaldavhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_u32)))
+uint64_t vrmlaldavhq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhq_u32)))
+uint64_t vrmlaldavhq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhxq_p_s32)))
+int64_t vrmlaldavhxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhxq_p_s32)))
+int64_t vrmlaldavhxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhxq_s32)))
+int64_t vrmlaldavhxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlaldavhxq_s32)))
+int64_t vrmlaldavhxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaq_p_s32)))
+int64_t vrmlsldavhaq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaq_p_s32)))
+int64_t vrmlsldavhaq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaq_s32)))
+int64_t vrmlsldavhaq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaq_s32)))
+int64_t vrmlsldavhaq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaxq_p_s32)))
+int64_t vrmlsldavhaxq_p_s32(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaxq_p_s32)))
+int64_t vrmlsldavhaxq_p(int64_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaxq_s32)))
+int64_t vrmlsldavhaxq_s32(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhaxq_s32)))
+int64_t vrmlsldavhaxq(int64_t, int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhq_p_s32)))
+int64_t vrmlsldavhq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhq_p_s32)))
+int64_t vrmlsldavhq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhq_s32)))
+int64_t vrmlsldavhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhq_s32)))
+int64_t vrmlsldavhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhxq_p_s32)))
+int64_t vrmlsldavhxq_p_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhxq_p_s32)))
+int64_t vrmlsldavhxq_p(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhxq_s32)))
+int64_t vrmlsldavhxq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmlsldavhxq_s32)))
+int64_t vrmlsldavhxq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s16)))
+int16x8_t vrmulhq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s16)))
+int16x8_t vrmulhq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s32)))
+int32x4_t vrmulhq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s32)))
+int32x4_t vrmulhq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s8)))
+int8x16_t vrmulhq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_s8)))
+int8x16_t vrmulhq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u16)))
+uint16x8_t vrmulhq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u16)))
+uint16x8_t vrmulhq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u32)))
+uint32x4_t vrmulhq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u32)))
+uint32x4_t vrmulhq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u8)))
+uint8x16_t vrmulhq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_m_u8)))
+uint8x16_t vrmulhq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s16)))
+int16x8_t vrmulhq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s16)))
+int16x8_t vrmulhq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s32)))
+int32x4_t vrmulhq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s32)))
+int32x4_t vrmulhq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s8)))
+int8x16_t vrmulhq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_s8)))
+int8x16_t vrmulhq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u16)))
+uint16x8_t vrmulhq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u16)))
+uint16x8_t vrmulhq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u32)))
+uint32x4_t vrmulhq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u32)))
+uint32x4_t vrmulhq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u8)))
+uint8x16_t vrmulhq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_u8)))
+uint8x16_t vrmulhq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s16)))
+int16x8_t vrmulhq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s16)))
+int16x8_t vrmulhq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s32)))
+int32x4_t vrmulhq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s32)))
+int32x4_t vrmulhq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s8)))
+int8x16_t vrmulhq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_s8)))
+int8x16_t vrmulhq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u16)))
+uint16x8_t vrmulhq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u16)))
+uint16x8_t vrmulhq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u32)))
+uint32x4_t vrmulhq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u32)))
+uint32x4_t vrmulhq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u8)))
+uint8x16_t vrmulhq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrmulhq_x_u8)))
+uint8x16_t vrmulhq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s16)))
+int16x8_t vrshlq_m_n_s16(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s16)))
+int16x8_t vrshlq_m_n(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s32)))
+int32x4_t vrshlq_m_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s32)))
+int32x4_t vrshlq_m_n(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s8)))
+int8x16_t vrshlq_m_n_s8(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_s8)))
+int8x16_t vrshlq_m_n(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u16)))
+uint16x8_t vrshlq_m_n_u16(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u16)))
+uint16x8_t vrshlq_m_n(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u32)))
+uint32x4_t vrshlq_m_n_u32(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u32)))
+uint32x4_t vrshlq_m_n(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u8)))
+uint8x16_t vrshlq_m_n_u8(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_n_u8)))
+uint8x16_t vrshlq_m_n(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s16)))
+int16x8_t vrshlq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s16)))
+int16x8_t vrshlq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s32)))
+int32x4_t vrshlq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s32)))
+int32x4_t vrshlq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s8)))
+int8x16_t vrshlq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_s8)))
+int8x16_t vrshlq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u16)))
+uint16x8_t vrshlq_m_u16(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u16)))
+uint16x8_t vrshlq_m(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u32)))
+uint32x4_t vrshlq_m_u32(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u32)))
+uint32x4_t vrshlq_m(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u8)))
+uint8x16_t vrshlq_m_u8(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_m_u8)))
+uint8x16_t vrshlq_m(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s16)))
+int16x8_t vrshlq_n_s16(int16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s16)))
+int16x8_t vrshlq(int16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s32)))
+int32x4_t vrshlq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s32)))
+int32x4_t vrshlq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s8)))
+int8x16_t vrshlq_n_s8(int8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_s8)))
+int8x16_t vrshlq(int8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u16)))
+uint16x8_t vrshlq_n_u16(uint16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u16)))
+uint16x8_t vrshlq(uint16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u32)))
+uint32x4_t vrshlq_n_u32(uint32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u32)))
+uint32x4_t vrshlq(uint32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u8)))
+uint8x16_t vrshlq_n_u8(uint8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_n_u8)))
+uint8x16_t vrshlq(uint8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s16)))
+int16x8_t vrshlq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s16)))
+int16x8_t vrshlq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s32)))
+int32x4_t vrshlq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s32)))
+int32x4_t vrshlq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s8)))
+int8x16_t vrshlq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_s8)))
+int8x16_t vrshlq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u16)))
+uint16x8_t vrshlq_u16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u16)))
+uint16x8_t vrshlq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u32)))
+uint32x4_t vrshlq_u32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u32)))
+uint32x4_t vrshlq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u8)))
+uint8x16_t vrshlq_u8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_u8)))
+uint8x16_t vrshlq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s16)))
+int16x8_t vrshlq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s16)))
+int16x8_t vrshlq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s32)))
+int32x4_t vrshlq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s32)))
+int32x4_t vrshlq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s8)))
+int8x16_t vrshlq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_s8)))
+int8x16_t vrshlq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u16)))
+uint16x8_t vrshlq_x_u16(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u16)))
+uint16x8_t vrshlq_x(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u32)))
+uint32x4_t vrshlq_x_u32(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u32)))
+uint32x4_t vrshlq_x(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u8)))
+uint8x16_t vrshlq_x_u8(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshlq_x_u8)))
+uint8x16_t vrshlq_x(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_s16)))
+int8x16_t vrshrnbq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_s16)))
+int8x16_t vrshrnbq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_s32)))
+int16x8_t vrshrnbq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_s32)))
+int16x8_t vrshrnbq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_u16)))
+uint8x16_t vrshrnbq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_u16)))
+uint8x16_t vrshrnbq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_u32)))
+uint16x8_t vrshrnbq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_m_n_u32)))
+uint16x8_t vrshrnbq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_s16)))
+int8x16_t vrshrnbq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_s16)))
+int8x16_t vrshrnbq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_s32)))
+int16x8_t vrshrnbq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_s32)))
+int16x8_t vrshrnbq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_u16)))
+uint8x16_t vrshrnbq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_u16)))
+uint8x16_t vrshrnbq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_u32)))
+uint16x8_t vrshrnbq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrnbq_n_u32)))
+uint16x8_t vrshrnbq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_s16)))
+int8x16_t vrshrntq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_s16)))
+int8x16_t vrshrntq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_s32)))
+int16x8_t vrshrntq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_s32)))
+int16x8_t vrshrntq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_u16)))
+uint8x16_t vrshrntq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_u16)))
+uint8x16_t vrshrntq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_u32)))
+uint16x8_t vrshrntq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_m_n_u32)))
+uint16x8_t vrshrntq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_s16)))
+int8x16_t vrshrntq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_s16)))
+int8x16_t vrshrntq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_s32)))
+int16x8_t vrshrntq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_s32)))
+int16x8_t vrshrntq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_u16)))
+uint8x16_t vrshrntq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_u16)))
+uint8x16_t vrshrntq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_u32)))
+uint16x8_t vrshrntq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrntq_n_u32)))
+uint16x8_t vrshrntq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s16)))
+int16x8_t vrshrq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s16)))
+int16x8_t vrshrq_m(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s32)))
+int32x4_t vrshrq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s32)))
+int32x4_t vrshrq_m(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s8)))
+int8x16_t vrshrq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_s8)))
+int8x16_t vrshrq_m(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u16)))
+uint16x8_t vrshrq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u16)))
+uint16x8_t vrshrq_m(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u32)))
+uint32x4_t vrshrq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u32)))
+uint32x4_t vrshrq_m(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u8)))
+uint8x16_t vrshrq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_m_n_u8)))
+uint8x16_t vrshrq_m(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s16)))
+int16x8_t vrshrq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s16)))
+int16x8_t vrshrq(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s32)))
+int32x4_t vrshrq_n_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s32)))
+int32x4_t vrshrq(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s8)))
+int8x16_t vrshrq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_s8)))
+int8x16_t vrshrq(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u16)))
+uint16x8_t vrshrq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u16)))
+uint16x8_t vrshrq(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u32)))
+uint32x4_t vrshrq_n_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u32)))
+uint32x4_t vrshrq(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u8)))
+uint8x16_t vrshrq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_n_u8)))
+uint8x16_t vrshrq(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s16)))
+int16x8_t vrshrq_x_n_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s16)))
+int16x8_t vrshrq_x(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s32)))
+int32x4_t vrshrq_x_n_s32(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s32)))
+int32x4_t vrshrq_x(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s8)))
+int8x16_t vrshrq_x_n_s8(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_s8)))
+int8x16_t vrshrq_x(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u16)))
+uint16x8_t vrshrq_x_n_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u16)))
+uint16x8_t vrshrq_x(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u32)))
+uint32x4_t vrshrq_x_n_u32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u32)))
+uint32x4_t vrshrq_x(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u8)))
+uint8x16_t vrshrq_x_n_u8(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrshrq_x_n_u8)))
+uint8x16_t vrshrq_x(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_m_s32)))
+int32x4_t vsbciq_m_s32(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_m_s32)))
+int32x4_t vsbciq_m(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_m_u32)))
+uint32x4_t vsbciq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_m_u32)))
+uint32x4_t vsbciq_m(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_s32)))
+int32x4_t vsbciq_s32(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_s32)))
+int32x4_t vsbciq(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_u32)))
+uint32x4_t vsbciq_u32(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbciq_u32)))
+uint32x4_t vsbciq(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_m_s32)))
+int32x4_t vsbcq_m_s32(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_m_s32)))
+int32x4_t vsbcq_m(int32x4_t, int32x4_t, int32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_m_u32)))
+uint32x4_t vsbcq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_m_u32)))
+uint32x4_t vsbcq_m(uint32x4_t, uint32x4_t, uint32x4_t, unsigned *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_s32)))
+int32x4_t vsbcq_s32(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_s32)))
+int32x4_t vsbcq(int32x4_t, int32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_u32)))
+uint32x4_t vsbcq_u32(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsbcq_u32)))
+uint32x4_t vsbcq(uint32x4_t, uint32x4_t, unsigned *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s16)))
+int16x8_t vsetq_lane_s16(int16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s16)))
+int16x8_t vsetq_lane(int16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s32)))
+int32x4_t vsetq_lane_s32(int32_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s32)))
+int32x4_t vsetq_lane(int32_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s64)))
+int64x2_t vsetq_lane_s64(int64_t, int64x2_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s64)))
+int64x2_t vsetq_lane(int64_t, int64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s8)))
+int8x16_t vsetq_lane_s8(int8_t, int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_s8)))
+int8x16_t vsetq_lane(int8_t, int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u16)))
+uint16x8_t vsetq_lane_u16(uint16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u16)))
+uint16x8_t vsetq_lane(uint16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u32)))
+uint32x4_t vsetq_lane_u32(uint32_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u32)))
+uint32x4_t vsetq_lane(uint32_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u64)))
+uint64x2_t vsetq_lane_u64(uint64_t, uint64x2_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u64)))
+uint64x2_t vsetq_lane(uint64_t, uint64x2_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u8)))
+uint8x16_t vsetq_lane_u8(uint8_t, uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_u8)))
+uint8x16_t vsetq_lane(uint8_t, uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s16)))
+int16x8_t vshlcq_m_s16(int16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s16)))
+int16x8_t vshlcq_m(int16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s32)))
+int32x4_t vshlcq_m_s32(int32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s32)))
+int32x4_t vshlcq_m(int32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s8)))
+int8x16_t vshlcq_m_s8(int8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_s8)))
+int8x16_t vshlcq_m(int8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u16)))
+uint16x8_t vshlcq_m_u16(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u16)))
+uint16x8_t vshlcq_m(uint16x8_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u32)))
+uint32x4_t vshlcq_m_u32(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u32)))
+uint32x4_t vshlcq_m(uint32x4_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u8)))
+uint8x16_t vshlcq_m_u8(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_m_u8)))
+uint8x16_t vshlcq_m(uint8x16_t, uint32_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s16)))
+int16x8_t vshlcq_s16(int16x8_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s16)))
+int16x8_t vshlcq(int16x8_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s32)))
+int32x4_t vshlcq_s32(int32x4_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s32)))
+int32x4_t vshlcq(int32x4_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s8)))
+int8x16_t vshlcq_s8(int8x16_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_s8)))
+int8x16_t vshlcq(int8x16_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u16)))
+uint16x8_t vshlcq_u16(uint16x8_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u16)))
+uint16x8_t vshlcq(uint16x8_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u32)))
+uint32x4_t vshlcq_u32(uint32x4_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u32)))
+uint32x4_t vshlcq(uint32x4_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u8)))
+uint8x16_t vshlcq_u8(uint8x16_t, uint32_t *, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlcq_u8)))
+uint8x16_t vshlcq(uint8x16_t, uint32_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_s16)))
+int32x4_t vshllbq_m_n_s16(int32x4_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_s16)))
+int32x4_t vshllbq_m(int32x4_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_s8)))
+int16x8_t vshllbq_m_n_s8(int16x8_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_s8)))
+int16x8_t vshllbq_m(int16x8_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_u16)))
+uint32x4_t vshllbq_m_n_u16(uint32x4_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_u16)))
+uint32x4_t vshllbq_m(uint32x4_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_u8)))
+uint16x8_t vshllbq_m_n_u8(uint16x8_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_m_n_u8)))
+uint16x8_t vshllbq_m(uint16x8_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_s16)))
+int32x4_t vshllbq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_s16)))
+int32x4_t vshllbq(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_s8)))
+int16x8_t vshllbq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_s8)))
+int16x8_t vshllbq(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_u16)))
+uint32x4_t vshllbq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_u16)))
+uint32x4_t vshllbq(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_u8)))
+uint16x8_t vshllbq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_n_u8)))
+uint16x8_t vshllbq(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_s16)))
+int32x4_t vshllbq_x_n_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_s16)))
+int32x4_t vshllbq_x(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_s8)))
+int16x8_t vshllbq_x_n_s8(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_s8)))
+int16x8_t vshllbq_x(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_u16)))
+uint32x4_t vshllbq_x_n_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_u16)))
+uint32x4_t vshllbq_x(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_u8)))
+uint16x8_t vshllbq_x_n_u8(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshllbq_x_n_u8)))
+uint16x8_t vshllbq_x(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_s16)))
+int32x4_t vshlltq_m_n_s16(int32x4_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_s16)))
+int32x4_t vshlltq_m(int32x4_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_s8)))
+int16x8_t vshlltq_m_n_s8(int16x8_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_s8)))
+int16x8_t vshlltq_m(int16x8_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_u16)))
+uint32x4_t vshlltq_m_n_u16(uint32x4_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_u16)))
+uint32x4_t vshlltq_m(uint32x4_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_u8)))
+uint16x8_t vshlltq_m_n_u8(uint16x8_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_m_n_u8)))
+uint16x8_t vshlltq_m(uint16x8_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_s16)))
+int32x4_t vshlltq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_s16)))
+int32x4_t vshlltq(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_s8)))
+int16x8_t vshlltq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_s8)))
+int16x8_t vshlltq(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_u16)))
+uint32x4_t vshlltq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_u16)))
+uint32x4_t vshlltq(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_u8)))
+uint16x8_t vshlltq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_n_u8)))
+uint16x8_t vshlltq(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_s16)))
+int32x4_t vshlltq_x_n_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_s16)))
+int32x4_t vshlltq_x(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_s8)))
+int16x8_t vshlltq_x_n_s8(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_s8)))
+int16x8_t vshlltq_x(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_u16)))
+uint32x4_t vshlltq_x_n_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_u16)))
+uint32x4_t vshlltq_x(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_u8)))
+uint16x8_t vshlltq_x_n_u8(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlltq_x_n_u8)))
+uint16x8_t vshlltq_x(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s16)))
+int16x8_t vshlq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s16)))
+int16x8_t vshlq_m_n(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s32)))
+int32x4_t vshlq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s32)))
+int32x4_t vshlq_m_n(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s8)))
+int8x16_t vshlq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_s8)))
+int8x16_t vshlq_m_n(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u16)))
+uint16x8_t vshlq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u16)))
+uint16x8_t vshlq_m_n(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u32)))
+uint32x4_t vshlq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u32)))
+uint32x4_t vshlq_m_n(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u8)))
+uint8x16_t vshlq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_n_u8)))
+uint8x16_t vshlq_m_n(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s16)))
+int16x8_t vshlq_m_r_s16(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s16)))
+int16x8_t vshlq_m_r(int16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s32)))
+int32x4_t vshlq_m_r_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s32)))
+int32x4_t vshlq_m_r(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s8)))
+int8x16_t vshlq_m_r_s8(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_s8)))
+int8x16_t vshlq_m_r(int8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u16)))
+uint16x8_t vshlq_m_r_u16(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u16)))
+uint16x8_t vshlq_m_r(uint16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u32)))
+uint32x4_t vshlq_m_r_u32(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u32)))
+uint32x4_t vshlq_m_r(uint32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u8)))
+uint8x16_t vshlq_m_r_u8(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_r_u8)))
+uint8x16_t vshlq_m_r(uint8x16_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s16)))
+int16x8_t vshlq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s16)))
+int16x8_t vshlq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s32)))
+int32x4_t vshlq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s32)))
+int32x4_t vshlq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s8)))
+int8x16_t vshlq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_s8)))
+int8x16_t vshlq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u16)))
+uint16x8_t vshlq_m_u16(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u16)))
+uint16x8_t vshlq_m(uint16x8_t, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u32)))
+uint32x4_t vshlq_m_u32(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u32)))
+uint32x4_t vshlq_m(uint32x4_t, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u8)))
+uint8x16_t vshlq_m_u8(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_m_u8)))
+uint8x16_t vshlq_m(uint8x16_t, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s16)))
+int16x8_t vshlq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s16)))
+int16x8_t vshlq_n(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s32)))
+int32x4_t vshlq_n_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s32)))
+int32x4_t vshlq_n(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s8)))
+int8x16_t vshlq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_s8)))
+int8x16_t vshlq_n(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u16)))
+uint16x8_t vshlq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u16)))
+uint16x8_t vshlq_n(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u32)))
+uint32x4_t vshlq_n_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u32)))
+uint32x4_t vshlq_n(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u8)))
+uint8x16_t vshlq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_n_u8)))
+uint8x16_t vshlq_n(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s16)))
+int16x8_t vshlq_r_s16(int16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s16)))
+int16x8_t vshlq_r(int16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s32)))
+int32x4_t vshlq_r_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s32)))
+int32x4_t vshlq_r(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s8)))
+int8x16_t vshlq_r_s8(int8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_s8)))
+int8x16_t vshlq_r(int8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u16)))
+uint16x8_t vshlq_r_u16(uint16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u16)))
+uint16x8_t vshlq_r(uint16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u32)))
+uint32x4_t vshlq_r_u32(uint32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u32)))
+uint32x4_t vshlq_r(uint32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u8)))
+uint8x16_t vshlq_r_u8(uint8x16_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_r_u8)))
+uint8x16_t vshlq_r(uint8x16_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s16)))
+int16x8_t vshlq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s16)))
+int16x8_t vshlq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s32)))
+int32x4_t vshlq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s32)))
+int32x4_t vshlq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s8)))
+int8x16_t vshlq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_s8)))
+int8x16_t vshlq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u16)))
+uint16x8_t vshlq_u16(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u16)))
+uint16x8_t vshlq(uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u32)))
+uint32x4_t vshlq_u32(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u32)))
+uint32x4_t vshlq(uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u8)))
+uint8x16_t vshlq_u8(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_u8)))
+uint8x16_t vshlq(uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s16)))
+int16x8_t vshlq_x_n_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s16)))
+int16x8_t vshlq_x_n(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s32)))
+int32x4_t vshlq_x_n_s32(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s32)))
+int32x4_t vshlq_x_n(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s8)))
+int8x16_t vshlq_x_n_s8(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_s8)))
+int8x16_t vshlq_x_n(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u16)))
+uint16x8_t vshlq_x_n_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u16)))
+uint16x8_t vshlq_x_n(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u32)))
+uint32x4_t vshlq_x_n_u32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u32)))
+uint32x4_t vshlq_x_n(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u8)))
+uint8x16_t vshlq_x_n_u8(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_n_u8)))
+uint8x16_t vshlq_x_n(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s16)))
+int16x8_t vshlq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s16)))
+int16x8_t vshlq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s32)))
+int32x4_t vshlq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s32)))
+int32x4_t vshlq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s8)))
+int8x16_t vshlq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_s8)))
+int8x16_t vshlq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u16)))
+uint16x8_t vshlq_x_u16(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u16)))
+uint16x8_t vshlq_x(uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u32)))
+uint32x4_t vshlq_x_u32(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u32)))
+uint32x4_t vshlq_x(uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u8)))
+uint8x16_t vshlq_x_u8(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshlq_x_u8)))
+uint8x16_t vshlq_x(uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_s16)))
+int8x16_t vshrnbq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_s16)))
+int8x16_t vshrnbq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_s32)))
+int16x8_t vshrnbq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_s32)))
+int16x8_t vshrnbq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_u16)))
+uint8x16_t vshrnbq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_u16)))
+uint8x16_t vshrnbq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_u32)))
+uint16x8_t vshrnbq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_m_n_u32)))
+uint16x8_t vshrnbq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_s16)))
+int8x16_t vshrnbq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_s16)))
+int8x16_t vshrnbq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_s32)))
+int16x8_t vshrnbq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_s32)))
+int16x8_t vshrnbq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_u16)))
+uint8x16_t vshrnbq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_u16)))
+uint8x16_t vshrnbq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_u32)))
+uint16x8_t vshrnbq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrnbq_n_u32)))
+uint16x8_t vshrnbq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_s16)))
+int8x16_t vshrntq_m_n_s16(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_s16)))
+int8x16_t vshrntq_m(int8x16_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_s32)))
+int16x8_t vshrntq_m_n_s32(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_s32)))
+int16x8_t vshrntq_m(int16x8_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_u16)))
+uint8x16_t vshrntq_m_n_u16(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_u16)))
+uint8x16_t vshrntq_m(uint8x16_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_u32)))
+uint16x8_t vshrntq_m_n_u32(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_m_n_u32)))
+uint16x8_t vshrntq_m(uint16x8_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_s16)))
+int8x16_t vshrntq_n_s16(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_s16)))
+int8x16_t vshrntq(int8x16_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_s32)))
+int16x8_t vshrntq_n_s32(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_s32)))
+int16x8_t vshrntq(int16x8_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_u16)))
+uint8x16_t vshrntq_n_u16(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_u16)))
+uint8x16_t vshrntq(uint8x16_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_u32)))
+uint16x8_t vshrntq_n_u32(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrntq_n_u32)))
+uint16x8_t vshrntq(uint16x8_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s16)))
+int16x8_t vshrq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s16)))
+int16x8_t vshrq_m(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s32)))
+int32x4_t vshrq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s32)))
+int32x4_t vshrq_m(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s8)))
+int8x16_t vshrq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_s8)))
+int8x16_t vshrq_m(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u16)))
+uint16x8_t vshrq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u16)))
+uint16x8_t vshrq_m(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u32)))
+uint32x4_t vshrq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u32)))
+uint32x4_t vshrq_m(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u8)))
+uint8x16_t vshrq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_m_n_u8)))
+uint8x16_t vshrq_m(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s16)))
+int16x8_t vshrq_n_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s16)))
+int16x8_t vshrq(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s32)))
+int32x4_t vshrq_n_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s32)))
+int32x4_t vshrq(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s8)))
+int8x16_t vshrq_n_s8(int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_s8)))
+int8x16_t vshrq(int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u16)))
+uint16x8_t vshrq_n_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u16)))
+uint16x8_t vshrq(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u32)))
+uint32x4_t vshrq_n_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u32)))
+uint32x4_t vshrq(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u8)))
+uint8x16_t vshrq_n_u8(uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_n_u8)))
+uint8x16_t vshrq(uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s16)))
+int16x8_t vshrq_x_n_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s16)))
+int16x8_t vshrq_x(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s32)))
+int32x4_t vshrq_x_n_s32(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s32)))
+int32x4_t vshrq_x(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s8)))
+int8x16_t vshrq_x_n_s8(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_s8)))
+int8x16_t vshrq_x(int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u16)))
+uint16x8_t vshrq_x_n_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u16)))
+uint16x8_t vshrq_x(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u32)))
+uint32x4_t vshrq_x_n_u32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u32)))
+uint32x4_t vshrq_x(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u8)))
+uint8x16_t vshrq_x_n_u8(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vshrq_x_n_u8)))
+uint8x16_t vshrq_x(uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s16)))
+int16x8_t vsliq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s16)))
+int16x8_t vsliq_m(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s32)))
+int32x4_t vsliq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s32)))
+int32x4_t vsliq_m(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s8)))
+int8x16_t vsliq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_s8)))
+int8x16_t vsliq_m(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u16)))
+uint16x8_t vsliq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u16)))
+uint16x8_t vsliq_m(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u32)))
+uint32x4_t vsliq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u32)))
+uint32x4_t vsliq_m(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u8)))
+uint8x16_t vsliq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_m_n_u8)))
+uint8x16_t vsliq_m(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s16)))
+int16x8_t vsliq_n_s16(int16x8_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s16)))
+int16x8_t vsliq(int16x8_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s32)))
+int32x4_t vsliq_n_s32(int32x4_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s32)))
+int32x4_t vsliq(int32x4_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s8)))
+int8x16_t vsliq_n_s8(int8x16_t, int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_s8)))
+int8x16_t vsliq(int8x16_t, int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u16)))
+uint16x8_t vsliq_n_u16(uint16x8_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u16)))
+uint16x8_t vsliq(uint16x8_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u32)))
+uint32x4_t vsliq_n_u32(uint32x4_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u32)))
+uint32x4_t vsliq(uint32x4_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u8)))
+uint8x16_t vsliq_n_u8(uint8x16_t, uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsliq_n_u8)))
+uint8x16_t vsliq(uint8x16_t, uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s16)))
+int16x8_t vsriq_m_n_s16(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s16)))
+int16x8_t vsriq_m(int16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s32)))
+int32x4_t vsriq_m_n_s32(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s32)))
+int32x4_t vsriq_m(int32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s8)))
+int8x16_t vsriq_m_n_s8(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_s8)))
+int8x16_t vsriq_m(int8x16_t, int8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u16)))
+uint16x8_t vsriq_m_n_u16(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u16)))
+uint16x8_t vsriq_m(uint16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u32)))
+uint32x4_t vsriq_m_n_u32(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u32)))
+uint32x4_t vsriq_m(uint32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u8)))
+uint8x16_t vsriq_m_n_u8(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_m_n_u8)))
+uint8x16_t vsriq_m(uint8x16_t, uint8x16_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s16)))
+int16x8_t vsriq_n_s16(int16x8_t, int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s16)))
+int16x8_t vsriq(int16x8_t, int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s32)))
+int32x4_t vsriq_n_s32(int32x4_t, int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s32)))
+int32x4_t vsriq(int32x4_t, int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s8)))
+int8x16_t vsriq_n_s8(int8x16_t, int8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_s8)))
+int8x16_t vsriq(int8x16_t, int8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u16)))
+uint16x8_t vsriq_n_u16(uint16x8_t, uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u16)))
+uint16x8_t vsriq(uint16x8_t, uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u32)))
+uint32x4_t vsriq_n_u32(uint32x4_t, uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u32)))
+uint32x4_t vsriq(uint32x4_t, uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u8)))
+uint8x16_t vsriq_n_u8(uint8x16_t, uint8x16_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsriq_n_u8)))
+uint8x16_t vsriq(uint8x16_t, uint8x16_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s16)))
+void vst1q_p_s16(int16_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s16)))
+void vst1q_p(int16_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s32)))
+void vst1q_p_s32(int32_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s32)))
+void vst1q_p(int32_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s8)))
+void vst1q_p_s8(int8_t *, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_s8)))
+void vst1q_p(int8_t *, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u16)))
+void vst1q_p_u16(uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u16)))
+void vst1q_p(uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u32)))
+void vst1q_p_u32(uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u32)))
+void vst1q_p(uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u8)))
+void vst1q_p_u8(uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_u8)))
+void vst1q_p(uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s16)))
+void vst1q_s16(int16_t *, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s16)))
+void vst1q(int16_t *, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s32)))
+void vst1q_s32(int32_t *, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s32)))
+void vst1q(int32_t *, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s8)))
+void vst1q_s8(int8_t *, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_s8)))
+void vst1q(int8_t *, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u16)))
+void vst1q_u16(uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u16)))
+void vst1q(uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u32)))
+void vst1q_u32(uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u32)))
+void vst1q(uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u8)))
+void vst1q_u8(uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_u8)))
+void vst1q(uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s16)))
+void vst2q_s16(int16_t *, int16x8x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s16)))
+void vst2q(int16_t *, int16x8x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s32)))
+void vst2q_s32(int32_t *, int32x4x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s32)))
+void vst2q(int32_t *, int32x4x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s8)))
+void vst2q_s8(int8_t *, int8x16x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_s8)))
+void vst2q(int8_t *, int8x16x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u16)))
+void vst2q_u16(uint16_t *, uint16x8x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u16)))
+void vst2q(uint16_t *, uint16x8x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u32)))
+void vst2q_u32(uint32_t *, uint32x4x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u32)))
+void vst2q(uint32_t *, uint32x4x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u8)))
+void vst2q_u8(uint8_t *, uint8x16x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_u8)))
+void vst2q(uint8_t *, uint8x16x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s16)))
+void vst4q_s16(int16_t *, int16x8x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s16)))
+void vst4q(int16_t *, int16x8x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s32)))
+void vst4q_s32(int32_t *, int32x4x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s32)))
+void vst4q(int32_t *, int32x4x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s8)))
+void vst4q_s8(int8_t *, int8x16x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_s8)))
+void vst4q(int8_t *, int8x16x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u16)))
+void vst4q_u16(uint16_t *, uint16x8x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u16)))
+void vst4q(uint16_t *, uint16x8x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u32)))
+void vst4q_u32(uint32_t *, uint32x4x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u32)))
+void vst4q(uint32_t *, uint32x4x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u8)))
+void vst4q_u8(uint8_t *, uint8x16x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_u8)))
+void vst4q(uint8_t *, uint8x16x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s16)))
+void vstrbq_p_s16(int8_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s16)))
+void vstrbq_p(int8_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s32)))
+void vstrbq_p_s32(int8_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s32)))
+void vstrbq_p(int8_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s8)))
+void vstrbq_p_s8(int8_t *, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_s8)))
+void vstrbq_p(int8_t *, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u16)))
+void vstrbq_p_u16(uint8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u16)))
+void vstrbq_p(uint8_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u32)))
+void vstrbq_p_u32(uint8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u32)))
+void vstrbq_p(uint8_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u8)))
+void vstrbq_p_u8(uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_p_u8)))
+void vstrbq_p(uint8_t *, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s16)))
+void vstrbq_s16(int8_t *, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s16)))
+void vstrbq(int8_t *, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s32)))
+void vstrbq_s32(int8_t *, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s32)))
+void vstrbq(int8_t *, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s8)))
+void vstrbq_s8(int8_t *, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_s8)))
+void vstrbq(int8_t *, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s16)))
+void vstrbq_scatter_offset_p_s16(int8_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s16)))
+void vstrbq_scatter_offset_p(int8_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s32)))
+void vstrbq_scatter_offset_p_s32(int8_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s32)))
+void vstrbq_scatter_offset_p(int8_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s8)))
+void vstrbq_scatter_offset_p_s8(int8_t *, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_s8)))
+void vstrbq_scatter_offset_p(int8_t *, uint8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u16)))
+void vstrbq_scatter_offset_p_u16(uint8_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u16)))
+void vstrbq_scatter_offset_p(uint8_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u32)))
+void vstrbq_scatter_offset_p_u32(uint8_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u32)))
+void vstrbq_scatter_offset_p(uint8_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u8)))
+void vstrbq_scatter_offset_p_u8(uint8_t *, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_p_u8)))
+void vstrbq_scatter_offset_p(uint8_t *, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s16)))
+void vstrbq_scatter_offset_s16(int8_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s16)))
+void vstrbq_scatter_offset(int8_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s32)))
+void vstrbq_scatter_offset_s32(int8_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s32)))
+void vstrbq_scatter_offset(int8_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s8)))
+void vstrbq_scatter_offset_s8(int8_t *, uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_s8)))
+void vstrbq_scatter_offset(int8_t *, uint8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u16)))
+void vstrbq_scatter_offset_u16(uint8_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u16)))
+void vstrbq_scatter_offset(uint8_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u32)))
+void vstrbq_scatter_offset_u32(uint8_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u32)))
+void vstrbq_scatter_offset(uint8_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u8)))
+void vstrbq_scatter_offset_u8(uint8_t *, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_scatter_offset_u8)))
+void vstrbq_scatter_offset(uint8_t *, uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u16)))
+void vstrbq_u16(uint8_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u16)))
+void vstrbq(uint8_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u32)))
+void vstrbq_u32(uint8_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u32)))
+void vstrbq(uint8_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u8)))
+void vstrbq_u8(uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrbq_u8)))
+void vstrbq(uint8_t *, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_p_s64)))
+void vstrdq_scatter_base_p_s64(uint64x2_t, int, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_p_s64)))
+void vstrdq_scatter_base_p(uint64x2_t, int, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_p_u64)))
+void vstrdq_scatter_base_p_u64(uint64x2_t, int, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_p_u64)))
+void vstrdq_scatter_base_p(uint64x2_t, int, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_s64)))
+void vstrdq_scatter_base_s64(uint64x2_t, int, int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_s64)))
+void vstrdq_scatter_base(uint64x2_t, int, int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_u64)))
+void vstrdq_scatter_base_u64(uint64x2_t, int, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_u64)))
+void vstrdq_scatter_base(uint64x2_t, int, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_p_s64)))
+void vstrdq_scatter_base_wb_p_s64(uint64x2_t *, int, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_p_s64)))
+void vstrdq_scatter_base_wb_p(uint64x2_t *, int, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_p_u64)))
+void vstrdq_scatter_base_wb_p_u64(uint64x2_t *, int, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_p_u64)))
+void vstrdq_scatter_base_wb_p(uint64x2_t *, int, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_s64)))
+void vstrdq_scatter_base_wb_s64(uint64x2_t *, int, int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_s64)))
+void vstrdq_scatter_base_wb(uint64x2_t *, int, int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_u64)))
+void vstrdq_scatter_base_wb_u64(uint64x2_t *, int, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_base_wb_u64)))
+void vstrdq_scatter_base_wb(uint64x2_t *, int, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_p_s64)))
+void vstrdq_scatter_offset_p_s64(int64_t *, uint64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_p_s64)))
+void vstrdq_scatter_offset_p(int64_t *, uint64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_p_u64)))
+void vstrdq_scatter_offset_p_u64(uint64_t *, uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_p_u64)))
+void vstrdq_scatter_offset_p(uint64_t *, uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_s64)))
+void vstrdq_scatter_offset_s64(int64_t *, uint64x2_t, int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_s64)))
+void vstrdq_scatter_offset(int64_t *, uint64x2_t, int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_u64)))
+void vstrdq_scatter_offset_u64(uint64_t *, uint64x2_t, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_offset_u64)))
+void vstrdq_scatter_offset(uint64_t *, uint64x2_t, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_p_s64)))
+void vstrdq_scatter_shifted_offset_p_s64(int64_t *, uint64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_p_s64)))
+void vstrdq_scatter_shifted_offset_p(int64_t *, uint64x2_t, int64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_p_u64)))
+void vstrdq_scatter_shifted_offset_p_u64(uint64_t *, uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_p_u64)))
+void vstrdq_scatter_shifted_offset_p(uint64_t *, uint64x2_t, uint64x2_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_s64)))
+void vstrdq_scatter_shifted_offset_s64(int64_t *, uint64x2_t, int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_s64)))
+void vstrdq_scatter_shifted_offset(int64_t *, uint64x2_t, int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_u64)))
+void vstrdq_scatter_shifted_offset_u64(uint64_t *, uint64x2_t, uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrdq_scatter_shifted_offset_u64)))
+void vstrdq_scatter_shifted_offset(uint64_t *, uint64x2_t, uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_s16)))
+void vstrhq_p_s16(int16_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_s16)))
+void vstrhq_p(int16_t *, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_s32)))
+void vstrhq_p_s32(int16_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_s32)))
+void vstrhq_p(int16_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_u16)))
+void vstrhq_p_u16(uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_u16)))
+void vstrhq_p(uint16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_u32)))
+void vstrhq_p_u32(uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_u32)))
+void vstrhq_p(uint16_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_s16)))
+void vstrhq_s16(int16_t *, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_s16)))
+void vstrhq(int16_t *, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_s32)))
+void vstrhq_s32(int16_t *, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_s32)))
+void vstrhq(int16_t *, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_s16)))
+void vstrhq_scatter_offset_p_s16(int16_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_s16)))
+void vstrhq_scatter_offset_p(int16_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_s32)))
+void vstrhq_scatter_offset_p_s32(int16_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_s32)))
+void vstrhq_scatter_offset_p(int16_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_u16)))
+void vstrhq_scatter_offset_p_u16(uint16_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_u16)))
+void vstrhq_scatter_offset_p(uint16_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_u32)))
+void vstrhq_scatter_offset_p_u32(uint16_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_u32)))
+void vstrhq_scatter_offset_p(uint16_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_s16)))
+void vstrhq_scatter_offset_s16(int16_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_s16)))
+void vstrhq_scatter_offset(int16_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_s32)))
+void vstrhq_scatter_offset_s32(int16_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_s32)))
+void vstrhq_scatter_offset(int16_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_u16)))
+void vstrhq_scatter_offset_u16(uint16_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_u16)))
+void vstrhq_scatter_offset(uint16_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_u32)))
+void vstrhq_scatter_offset_u32(uint16_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_u32)))
+void vstrhq_scatter_offset(uint16_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_s16)))
+void vstrhq_scatter_shifted_offset_p_s16(int16_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_s16)))
+void vstrhq_scatter_shifted_offset_p(int16_t *, uint16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_s32)))
+void vstrhq_scatter_shifted_offset_p_s32(int16_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_s32)))
+void vstrhq_scatter_shifted_offset_p(int16_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_u16)))
+void vstrhq_scatter_shifted_offset_p_u16(uint16_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_u16)))
+void vstrhq_scatter_shifted_offset_p(uint16_t *, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_u32)))
+void vstrhq_scatter_shifted_offset_p_u32(uint16_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_u32)))
+void vstrhq_scatter_shifted_offset_p(uint16_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_s16)))
+void vstrhq_scatter_shifted_offset_s16(int16_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_s16)))
+void vstrhq_scatter_shifted_offset(int16_t *, uint16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_s32)))
+void vstrhq_scatter_shifted_offset_s32(int16_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_s32)))
+void vstrhq_scatter_shifted_offset(int16_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_u16)))
+void vstrhq_scatter_shifted_offset_u16(uint16_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_u16)))
+void vstrhq_scatter_shifted_offset(uint16_t *, uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_u32)))
+void vstrhq_scatter_shifted_offset_u32(uint16_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_u32)))
+void vstrhq_scatter_shifted_offset(uint16_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_u16)))
+void vstrhq_u16(uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_u16)))
+void vstrhq(uint16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_u32)))
+void vstrhq_u32(uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_u32)))
+void vstrhq(uint16_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_s32)))
+void vstrwq_p_s32(int32_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_s32)))
+void vstrwq_p(int32_t *, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_u32)))
+void vstrwq_p_u32(uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_u32)))
+void vstrwq_p(uint32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_s32)))
+void vstrwq_s32(int32_t *, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_s32)))
+void vstrwq(int32_t *, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_s32)))
+void vstrwq_scatter_base_p_s32(uint32x4_t, int, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_s32)))
+void vstrwq_scatter_base_p(uint32x4_t, int, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_u32)))
+void vstrwq_scatter_base_p_u32(uint32x4_t, int, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_u32)))
+void vstrwq_scatter_base_p(uint32x4_t, int, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_s32)))
+void vstrwq_scatter_base_s32(uint32x4_t, int, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_s32)))
+void vstrwq_scatter_base(uint32x4_t, int, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_u32)))
+void vstrwq_scatter_base_u32(uint32x4_t, int, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_u32)))
+void vstrwq_scatter_base(uint32x4_t, int, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_s32)))
+void vstrwq_scatter_base_wb_p_s32(uint32x4_t *, int, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_s32)))
+void vstrwq_scatter_base_wb_p(uint32x4_t *, int, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_u32)))
+void vstrwq_scatter_base_wb_p_u32(uint32x4_t *, int, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_u32)))
+void vstrwq_scatter_base_wb_p(uint32x4_t *, int, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_s32)))
+void vstrwq_scatter_base_wb_s32(uint32x4_t *, int, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_s32)))
+void vstrwq_scatter_base_wb(uint32x4_t *, int, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_u32)))
+void vstrwq_scatter_base_wb_u32(uint32x4_t *, int, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_u32)))
+void vstrwq_scatter_base_wb(uint32x4_t *, int, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_s32)))
+void vstrwq_scatter_offset_p_s32(int32_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_s32)))
+void vstrwq_scatter_offset_p(int32_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_u32)))
+void vstrwq_scatter_offset_p_u32(uint32_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_u32)))
+void vstrwq_scatter_offset_p(uint32_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_s32)))
+void vstrwq_scatter_offset_s32(int32_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_s32)))
+void vstrwq_scatter_offset(int32_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_u32)))
+void vstrwq_scatter_offset_u32(uint32_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_u32)))
+void vstrwq_scatter_offset(uint32_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_s32)))
+void vstrwq_scatter_shifted_offset_p_s32(int32_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_s32)))
+void vstrwq_scatter_shifted_offset_p(int32_t *, uint32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_u32)))
+void vstrwq_scatter_shifted_offset_p_u32(uint32_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_u32)))
+void vstrwq_scatter_shifted_offset_p(uint32_t *, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_s32)))
+void vstrwq_scatter_shifted_offset_s32(int32_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_s32)))
+void vstrwq_scatter_shifted_offset(int32_t *, uint32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_u32)))
+void vstrwq_scatter_shifted_offset_u32(uint32_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_u32)))
+void vstrwq_scatter_shifted_offset(uint32_t *, uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_u32)))
+void vstrwq_u32(uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_u32)))
+void vstrwq(uint32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s16)))
+int16x8_t vsubq_m_n_s16(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s16)))
+int16x8_t vsubq_m(int16x8_t, int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s32)))
+int32x4_t vsubq_m_n_s32(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s32)))
+int32x4_t vsubq_m(int32x4_t, int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s8)))
+int8x16_t vsubq_m_n_s8(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_s8)))
+int8x16_t vsubq_m(int8x16_t, int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u16)))
+uint16x8_t vsubq_m_n_u16(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u16)))
+uint16x8_t vsubq_m(uint16x8_t, uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u32)))
+uint32x4_t vsubq_m_n_u32(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u32)))
+uint32x4_t vsubq_m(uint32x4_t, uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u8)))
+uint8x16_t vsubq_m_n_u8(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_u8)))
+uint8x16_t vsubq_m(uint8x16_t, uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s16)))
+int16x8_t vsubq_m_s16(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s16)))
+int16x8_t vsubq_m(int16x8_t, int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s32)))
+int32x4_t vsubq_m_s32(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s32)))
+int32x4_t vsubq_m(int32x4_t, int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s8)))
+int8x16_t vsubq_m_s8(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_s8)))
+int8x16_t vsubq_m(int8x16_t, int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u16)))
+uint16x8_t vsubq_m_u16(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u16)))
+uint16x8_t vsubq_m(uint16x8_t, uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u32)))
+uint32x4_t vsubq_m_u32(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u32)))
+uint32x4_t vsubq_m(uint32x4_t, uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u8)))
+uint8x16_t vsubq_m_u8(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_u8)))
+uint8x16_t vsubq_m(uint8x16_t, uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s16)))
+int16x8_t vsubq_n_s16(int16x8_t, int16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s16)))
+int16x8_t vsubq(int16x8_t, int16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s32)))
+int32x4_t vsubq_n_s32(int32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s32)))
+int32x4_t vsubq(int32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s8)))
+int8x16_t vsubq_n_s8(int8x16_t, int8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_s8)))
+int8x16_t vsubq(int8x16_t, int8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u16)))
+uint16x8_t vsubq_n_u16(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u16)))
+uint16x8_t vsubq(uint16x8_t, uint16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u32)))
+uint32x4_t vsubq_n_u32(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u32)))
+uint32x4_t vsubq(uint32x4_t, uint32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u8)))
+uint8x16_t vsubq_n_u8(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_u8)))
+uint8x16_t vsubq(uint8x16_t, uint8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s16)))
+int16x8_t vsubq_s16(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s16)))
+int16x8_t vsubq(int16x8_t, int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s32)))
+int32x4_t vsubq_s32(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s32)))
+int32x4_t vsubq(int32x4_t, int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s8)))
+int8x16_t vsubq_s8(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_s8)))
+int8x16_t vsubq(int8x16_t, int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u16)))
+uint16x8_t vsubq_u16(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u16)))
+uint16x8_t vsubq(uint16x8_t, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u32)))
+uint32x4_t vsubq_u32(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u32)))
+uint32x4_t vsubq(uint32x4_t, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u8)))
+uint8x16_t vsubq_u8(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_u8)))
+uint8x16_t vsubq(uint8x16_t, uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s16)))
+int16x8_t vsubq_x_n_s16(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s16)))
+int16x8_t vsubq_x(int16x8_t, int16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s32)))
+int32x4_t vsubq_x_n_s32(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s32)))
+int32x4_t vsubq_x(int32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s8)))
+int8x16_t vsubq_x_n_s8(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_s8)))
+int8x16_t vsubq_x(int8x16_t, int8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u16)))
+uint16x8_t vsubq_x_n_u16(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u16)))
+uint16x8_t vsubq_x(uint16x8_t, uint16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u32)))
+uint32x4_t vsubq_x_n_u32(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u32)))
+uint32x4_t vsubq_x(uint32x4_t, uint32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u8)))
+uint8x16_t vsubq_x_n_u8(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_u8)))
+uint8x16_t vsubq_x(uint8x16_t, uint8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s16)))
+int16x8_t vsubq_x_s16(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s16)))
+int16x8_t vsubq_x(int16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s32)))
+int32x4_t vsubq_x_s32(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s32)))
+int32x4_t vsubq_x(int32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s8)))
+int8x16_t vsubq_x_s8(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_s8)))
+int8x16_t vsubq_x(int8x16_t, int8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u16)))
+uint16x8_t vsubq_x_u16(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u16)))
+uint16x8_t vsubq_x(uint16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u32)))
+uint32x4_t vsubq_x_u32(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u32)))
+uint32x4_t vsubq_x(uint32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u8)))
+uint8x16_t vsubq_x_u8(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_u8)))
+uint8x16_t vsubq_x(uint8x16_t, uint8x16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_s16)))
+int16x8_t vuninitializedq(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_s32)))
+int32x4_t vuninitializedq(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_s64)))
+int64x2_t vuninitializedq(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_s8)))
+int8x16_t vuninitializedq(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_u16)))
+uint16x8_t vuninitializedq(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_u32)))
+uint32x4_t vuninitializedq(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_u64)))
+uint64x2_t vuninitializedq(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_u8)))
+uint8x16_t vuninitializedq(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_s16)))
+int16x8_t vuninitializedq_s16();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_s32)))
+int32x4_t vuninitializedq_s32();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_s64)))
+int64x2_t vuninitializedq_s64();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_s8)))
+int8x16_t vuninitializedq_s8();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_u16)))
+uint16x8_t vuninitializedq_u16();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_u32)))
+uint32x4_t vuninitializedq_u32();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_u64)))
+uint64x2_t vuninitializedq_u64();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_u8)))
+uint8x16_t vuninitializedq_u8();
+
+#endif /* (!defined __ARM_MVE_PRESERVE_USER_NAMESPACE) */
+
+#if (__ARM_FEATURE_MVE & 2) && (!defined __ARM_MVE_PRESERVE_USER_NAMESPACE)
+
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_f16)))
+float16x8_t vabdq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_f16)))
+float16x8_t vabdq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_f32)))
+float32x4_t vabdq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_f32)))
+float32x4_t vabdq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_f16)))
+float16x8_t vabdq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_f16)))
+float16x8_t vabdq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_f32)))
+float32x4_t vabdq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_m_f32)))
+float32x4_t vabdq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_f16)))
+float16x8_t vabdq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_f16)))
+float16x8_t vabdq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_f32)))
+float32x4_t vabdq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabdq_x_f32)))
+float32x4_t vabdq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_f16)))
+float16x8_t vabsq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_f16)))
+float16x8_t vabsq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_f32)))
+float32x4_t vabsq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_f32)))
+float32x4_t vabsq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_f16)))
+float16x8_t vabsq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_f16)))
+float16x8_t vabsq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_f32)))
+float32x4_t vabsq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_m_f32)))
+float32x4_t vabsq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_f16)))
+float16x8_t vabsq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_f16)))
+float16x8_t vabsq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_f32)))
+float32x4_t vabsq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vabsq_x_f32)))
+float32x4_t vabsq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_f16)))
+float16x8_t vaddq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_f16)))
+float16x8_t vaddq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_f32)))
+float32x4_t vaddq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_f32)))
+float32x4_t vaddq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_f16)))
+float16x8_t vaddq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_f16)))
+float16x8_t vaddq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_f32)))
+float32x4_t vaddq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_f32)))
+float32x4_t vaddq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_f16)))
+float16x8_t vaddq_m_n_f16(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_f16)))
+float16x8_t vaddq_m(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_f32)))
+float32x4_t vaddq_m_n_f32(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_m_n_f32)))
+float32x4_t vaddq_m(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_f16)))
+float16x8_t vaddq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_f16)))
+float16x8_t vaddq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_f32)))
+float32x4_t vaddq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_n_f32)))
+float32x4_t vaddq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_f16)))
+float16x8_t vaddq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_f16)))
+float16x8_t vaddq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_f32)))
+float32x4_t vaddq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_f32)))
+float32x4_t vaddq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_f16)))
+float16x8_t vaddq_x_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_f16)))
+float16x8_t vaddq_x(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_f32)))
+float32x4_t vaddq_x_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vaddq_x_n_f32)))
+float32x4_t vaddq_x(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_f16)))
+float16x8_t vandq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_f16)))
+float16x8_t vandq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_f32)))
+float32x4_t vandq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_f32)))
+float32x4_t vandq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_f16)))
+float16x8_t vandq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_f16)))
+float16x8_t vandq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_f32)))
+float32x4_t vandq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_m_f32)))
+float32x4_t vandq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_f16)))
+float16x8_t vandq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_f16)))
+float16x8_t vandq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_f32)))
+float32x4_t vandq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vandq_x_f32)))
+float32x4_t vandq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_f16)))
+float16x8_t vbicq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_f16)))
+float16x8_t vbicq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_f32)))
+float32x4_t vbicq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_f32)))
+float32x4_t vbicq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_f16)))
+float16x8_t vbicq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_f16)))
+float16x8_t vbicq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_f32)))
+float32x4_t vbicq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_m_f32)))
+float32x4_t vbicq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_f16)))
+float16x8_t vbicq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_f16)))
+float16x8_t vbicq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_f32)))
+float32x4_t vbicq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbicq_x_f32)))
+float32x4_t vbicq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_f16)))
+float16x8_t vbrsrq_m_n_f16(float16x8_t, float16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_f16)))
+float16x8_t vbrsrq_m(float16x8_t, float16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_f32)))
+float32x4_t vbrsrq_m_n_f32(float32x4_t, float32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_m_n_f32)))
+float32x4_t vbrsrq_m(float32x4_t, float32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_f16)))
+float16x8_t vbrsrq_n_f16(float16x8_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_f16)))
+float16x8_t vbrsrq(float16x8_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_f32)))
+float32x4_t vbrsrq_n_f32(float32x4_t, int32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_n_f32)))
+float32x4_t vbrsrq(float32x4_t, int32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_f16)))
+float16x8_t vbrsrq_x_n_f16(float16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_f16)))
+float16x8_t vbrsrq_x(float16x8_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_f32)))
+float32x4_t vbrsrq_x_n_f32(float32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vbrsrq_x_n_f32)))
+float32x4_t vbrsrq_x(float32x4_t, int32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_f16)))
+float16x8_t vcaddq_rot270_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_f16)))
+float16x8_t vcaddq_rot270(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_f32)))
+float32x4_t vcaddq_rot270_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_f32)))
+float32x4_t vcaddq_rot270(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_f16)))
+float16x8_t vcaddq_rot270_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_f16)))
+float16x8_t vcaddq_rot270_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_f32)))
+float32x4_t vcaddq_rot270_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_m_f32)))
+float32x4_t vcaddq_rot270_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_f16)))
+float16x8_t vcaddq_rot270_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_f16)))
+float16x8_t vcaddq_rot270_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_f32)))
+float32x4_t vcaddq_rot270_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot270_x_f32)))
+float32x4_t vcaddq_rot270_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_f16)))
+float16x8_t vcaddq_rot90_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_f16)))
+float16x8_t vcaddq_rot90(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_f32)))
+float32x4_t vcaddq_rot90_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_f32)))
+float32x4_t vcaddq_rot90(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_f16)))
+float16x8_t vcaddq_rot90_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_f16)))
+float16x8_t vcaddq_rot90_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_f32)))
+float32x4_t vcaddq_rot90_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_m_f32)))
+float32x4_t vcaddq_rot90_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_f16)))
+float16x8_t vcaddq_rot90_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_f16)))
+float16x8_t vcaddq_rot90_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_f32)))
+float32x4_t vcaddq_rot90_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcaddq_rot90_x_f32)))
+float32x4_t vcaddq_rot90_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_f16)))
+float16x8_t vcmlaq_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_f16)))
+float16x8_t vcmlaq(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_f32)))
+float32x4_t vcmlaq_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_f32)))
+float32x4_t vcmlaq(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_m_f16)))
+float16x8_t vcmlaq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_m_f16)))
+float16x8_t vcmlaq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_m_f32)))
+float32x4_t vcmlaq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_m_f32)))
+float32x4_t vcmlaq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_f16)))
+float16x8_t vcmlaq_rot180_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_f16)))
+float16x8_t vcmlaq_rot180(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_f32)))
+float32x4_t vcmlaq_rot180_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_f32)))
+float32x4_t vcmlaq_rot180(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_m_f16)))
+float16x8_t vcmlaq_rot180_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_m_f16)))
+float16x8_t vcmlaq_rot180_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_m_f32)))
+float32x4_t vcmlaq_rot180_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot180_m_f32)))
+float32x4_t vcmlaq_rot180_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_f16)))
+float16x8_t vcmlaq_rot270_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_f16)))
+float16x8_t vcmlaq_rot270(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_f32)))
+float32x4_t vcmlaq_rot270_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_f32)))
+float32x4_t vcmlaq_rot270(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_m_f16)))
+float16x8_t vcmlaq_rot270_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_m_f16)))
+float16x8_t vcmlaq_rot270_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_m_f32)))
+float32x4_t vcmlaq_rot270_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot270_m_f32)))
+float32x4_t vcmlaq_rot270_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_f16)))
+float16x8_t vcmlaq_rot90_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_f16)))
+float16x8_t vcmlaq_rot90(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_f32)))
+float32x4_t vcmlaq_rot90_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_f32)))
+float32x4_t vcmlaq_rot90(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_m_f16)))
+float16x8_t vcmlaq_rot90_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_m_f16)))
+float16x8_t vcmlaq_rot90_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_m_f32)))
+float32x4_t vcmlaq_rot90_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmlaq_rot90_m_f32)))
+float32x4_t vcmlaq_rot90_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_f16)))
+mve_pred16_t vcmpeqq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_f16)))
+mve_pred16_t vcmpeqq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_f32)))
+mve_pred16_t vcmpeqq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_f32)))
+mve_pred16_t vcmpeqq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_f16)))
+mve_pred16_t vcmpeqq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_f16)))
+mve_pred16_t vcmpeqq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_f32)))
+mve_pred16_t vcmpeqq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_f32)))
+mve_pred16_t vcmpeqq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_f16)))
+mve_pred16_t vcmpeqq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_f16)))
+mve_pred16_t vcmpeqq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_f32)))
+mve_pred16_t vcmpeqq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_m_n_f32)))
+mve_pred16_t vcmpeqq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_f16)))
+mve_pred16_t vcmpeqq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_f16)))
+mve_pred16_t vcmpeqq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_f32)))
+mve_pred16_t vcmpeqq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpeqq_n_f32)))
+mve_pred16_t vcmpeqq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_f16)))
+mve_pred16_t vcmpgeq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_f16)))
+mve_pred16_t vcmpgeq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_f32)))
+mve_pred16_t vcmpgeq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_f32)))
+mve_pred16_t vcmpgeq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_f16)))
+mve_pred16_t vcmpgeq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_f16)))
+mve_pred16_t vcmpgeq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_f32)))
+mve_pred16_t vcmpgeq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_f32)))
+mve_pred16_t vcmpgeq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_f16)))
+mve_pred16_t vcmpgeq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_f16)))
+mve_pred16_t vcmpgeq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_f32)))
+mve_pred16_t vcmpgeq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_m_n_f32)))
+mve_pred16_t vcmpgeq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_f16)))
+mve_pred16_t vcmpgeq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_f16)))
+mve_pred16_t vcmpgeq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_f32)))
+mve_pred16_t vcmpgeq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgeq_n_f32)))
+mve_pred16_t vcmpgeq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_f16)))
+mve_pred16_t vcmpgtq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_f16)))
+mve_pred16_t vcmpgtq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_f32)))
+mve_pred16_t vcmpgtq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_f32)))
+mve_pred16_t vcmpgtq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_f16)))
+mve_pred16_t vcmpgtq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_f16)))
+mve_pred16_t vcmpgtq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_f32)))
+mve_pred16_t vcmpgtq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_f32)))
+mve_pred16_t vcmpgtq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_f16)))
+mve_pred16_t vcmpgtq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_f16)))
+mve_pred16_t vcmpgtq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_f32)))
+mve_pred16_t vcmpgtq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_m_n_f32)))
+mve_pred16_t vcmpgtq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_f16)))
+mve_pred16_t vcmpgtq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_f16)))
+mve_pred16_t vcmpgtq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_f32)))
+mve_pred16_t vcmpgtq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpgtq_n_f32)))
+mve_pred16_t vcmpgtq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_f16)))
+mve_pred16_t vcmpleq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_f16)))
+mve_pred16_t vcmpleq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_f32)))
+mve_pred16_t vcmpleq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_f32)))
+mve_pred16_t vcmpleq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_f16)))
+mve_pred16_t vcmpleq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_f16)))
+mve_pred16_t vcmpleq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_f32)))
+mve_pred16_t vcmpleq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_f32)))
+mve_pred16_t vcmpleq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_f16)))
+mve_pred16_t vcmpleq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_f16)))
+mve_pred16_t vcmpleq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_f32)))
+mve_pred16_t vcmpleq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_m_n_f32)))
+mve_pred16_t vcmpleq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_f16)))
+mve_pred16_t vcmpleq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_f16)))
+mve_pred16_t vcmpleq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_f32)))
+mve_pred16_t vcmpleq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpleq_n_f32)))
+mve_pred16_t vcmpleq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_f16)))
+mve_pred16_t vcmpltq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_f16)))
+mve_pred16_t vcmpltq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_f32)))
+mve_pred16_t vcmpltq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_f32)))
+mve_pred16_t vcmpltq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_f16)))
+mve_pred16_t vcmpltq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_f16)))
+mve_pred16_t vcmpltq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_f32)))
+mve_pred16_t vcmpltq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_f32)))
+mve_pred16_t vcmpltq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_f16)))
+mve_pred16_t vcmpltq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_f16)))
+mve_pred16_t vcmpltq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_f32)))
+mve_pred16_t vcmpltq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_m_n_f32)))
+mve_pred16_t vcmpltq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_f16)))
+mve_pred16_t vcmpltq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_f16)))
+mve_pred16_t vcmpltq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_f32)))
+mve_pred16_t vcmpltq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpltq_n_f32)))
+mve_pred16_t vcmpltq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_f16)))
+mve_pred16_t vcmpneq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_f16)))
+mve_pred16_t vcmpneq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_f32)))
+mve_pred16_t vcmpneq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_f32)))
+mve_pred16_t vcmpneq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_f16)))
+mve_pred16_t vcmpneq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_f16)))
+mve_pred16_t vcmpneq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_f32)))
+mve_pred16_t vcmpneq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_f32)))
+mve_pred16_t vcmpneq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_f16)))
+mve_pred16_t vcmpneq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_f16)))
+mve_pred16_t vcmpneq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_f32)))
+mve_pred16_t vcmpneq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_m_n_f32)))
+mve_pred16_t vcmpneq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_f16)))
+mve_pred16_t vcmpneq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_f16)))
+mve_pred16_t vcmpneq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_f32)))
+mve_pred16_t vcmpneq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmpneq_n_f32)))
+mve_pred16_t vcmpneq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_f16)))
+float16x8_t vcmulq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_f16)))
+float16x8_t vcmulq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_f32)))
+float32x4_t vcmulq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_f32)))
+float32x4_t vcmulq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_m_f16)))
+float16x8_t vcmulq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_m_f16)))
+float16x8_t vcmulq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_m_f32)))
+float32x4_t vcmulq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_m_f32)))
+float32x4_t vcmulq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_f16)))
+float16x8_t vcmulq_rot180_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_f16)))
+float16x8_t vcmulq_rot180(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_f32)))
+float32x4_t vcmulq_rot180_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_f32)))
+float32x4_t vcmulq_rot180(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_m_f16)))
+float16x8_t vcmulq_rot180_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_m_f16)))
+float16x8_t vcmulq_rot180_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_m_f32)))
+float32x4_t vcmulq_rot180_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_m_f32)))
+float32x4_t vcmulq_rot180_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_x_f16)))
+float16x8_t vcmulq_rot180_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_x_f16)))
+float16x8_t vcmulq_rot180_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_x_f32)))
+float32x4_t vcmulq_rot180_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot180_x_f32)))
+float32x4_t vcmulq_rot180_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_f16)))
+float16x8_t vcmulq_rot270_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_f16)))
+float16x8_t vcmulq_rot270(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_f32)))
+float32x4_t vcmulq_rot270_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_f32)))
+float32x4_t vcmulq_rot270(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_m_f16)))
+float16x8_t vcmulq_rot270_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_m_f16)))
+float16x8_t vcmulq_rot270_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_m_f32)))
+float32x4_t vcmulq_rot270_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_m_f32)))
+float32x4_t vcmulq_rot270_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_x_f16)))
+float16x8_t vcmulq_rot270_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_x_f16)))
+float16x8_t vcmulq_rot270_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_x_f32)))
+float32x4_t vcmulq_rot270_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot270_x_f32)))
+float32x4_t vcmulq_rot270_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_f16)))
+float16x8_t vcmulq_rot90_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_f16)))
+float16x8_t vcmulq_rot90(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_f32)))
+float32x4_t vcmulq_rot90_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_f32)))
+float32x4_t vcmulq_rot90(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_m_f16)))
+float16x8_t vcmulq_rot90_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_m_f16)))
+float16x8_t vcmulq_rot90_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_m_f32)))
+float32x4_t vcmulq_rot90_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_m_f32)))
+float32x4_t vcmulq_rot90_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_x_f16)))
+float16x8_t vcmulq_rot90_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_x_f16)))
+float16x8_t vcmulq_rot90_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_x_f32)))
+float32x4_t vcmulq_rot90_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_rot90_x_f32)))
+float32x4_t vcmulq_rot90_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_x_f16)))
+float16x8_t vcmulq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_x_f16)))
+float16x8_t vcmulq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_x_f32)))
+float32x4_t vcmulq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcmulq_x_f32)))
+float32x4_t vcmulq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_f16)))
+float16x8_t vcreateq_f16(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcreateq_f32)))
+float32x4_t vcreateq_f32(uint64_t, uint64_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_s16_f16)))
+int16x8_t vcvtaq_m_s16_f16(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_s16_f16)))
+int16x8_t vcvtaq_m(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_s32_f32)))
+int32x4_t vcvtaq_m_s32_f32(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_s32_f32)))
+int32x4_t vcvtaq_m(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_u16_f16)))
+uint16x8_t vcvtaq_m_u16_f16(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_u16_f16)))
+uint16x8_t vcvtaq_m(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_u32_f32)))
+uint32x4_t vcvtaq_m_u32_f32(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_m_u32_f32)))
+uint32x4_t vcvtaq_m(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_s16_f16)))
+int16x8_t vcvtaq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_s32_f32)))
+int32x4_t vcvtaq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_u16_f16)))
+uint16x8_t vcvtaq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_u32_f32)))
+uint32x4_t vcvtaq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_x_s16_f16)))
+int16x8_t vcvtaq_x_s16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_x_s32_f32)))
+int32x4_t vcvtaq_x_s32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_x_u16_f16)))
+uint16x8_t vcvtaq_x_u16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtaq_x_u32_f32)))
+uint32x4_t vcvtaq_x_u32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtbq_f16_f32)))
+float16x8_t vcvtbq_f16_f32(float16x8_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtbq_f32_f16)))
+float32x4_t vcvtbq_f32_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtbq_m_f16_f32)))
+float16x8_t vcvtbq_m_f16_f32(float16x8_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtbq_m_f32_f16)))
+float32x4_t vcvtbq_m_f32_f16(float32x4_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtbq_x_f32_f16)))
+float32x4_t vcvtbq_x_f32_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_s16_f16)))
+int16x8_t vcvtmq_m_s16_f16(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_s16_f16)))
+int16x8_t vcvtmq_m(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_s32_f32)))
+int32x4_t vcvtmq_m_s32_f32(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_s32_f32)))
+int32x4_t vcvtmq_m(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_u16_f16)))
+uint16x8_t vcvtmq_m_u16_f16(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_u16_f16)))
+uint16x8_t vcvtmq_m(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_u32_f32)))
+uint32x4_t vcvtmq_m_u32_f32(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_m_u32_f32)))
+uint32x4_t vcvtmq_m(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_s16_f16)))
+int16x8_t vcvtmq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_s32_f32)))
+int32x4_t vcvtmq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_u16_f16)))
+uint16x8_t vcvtmq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_u32_f32)))
+uint32x4_t vcvtmq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_x_s16_f16)))
+int16x8_t vcvtmq_x_s16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_x_s32_f32)))
+int32x4_t vcvtmq_x_s32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_x_u16_f16)))
+uint16x8_t vcvtmq_x_u16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtmq_x_u32_f32)))
+uint32x4_t vcvtmq_x_u32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_s16_f16)))
+int16x8_t vcvtnq_m_s16_f16(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_s16_f16)))
+int16x8_t vcvtnq_m(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_s32_f32)))
+int32x4_t vcvtnq_m_s32_f32(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_s32_f32)))
+int32x4_t vcvtnq_m(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_u16_f16)))
+uint16x8_t vcvtnq_m_u16_f16(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_u16_f16)))
+uint16x8_t vcvtnq_m(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_u32_f32)))
+uint32x4_t vcvtnq_m_u32_f32(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_m_u32_f32)))
+uint32x4_t vcvtnq_m(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_s16_f16)))
+int16x8_t vcvtnq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_s32_f32)))
+int32x4_t vcvtnq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_u16_f16)))
+uint16x8_t vcvtnq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_u32_f32)))
+uint32x4_t vcvtnq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_x_s16_f16)))
+int16x8_t vcvtnq_x_s16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_x_s32_f32)))
+int32x4_t vcvtnq_x_s32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_x_u16_f16)))
+uint16x8_t vcvtnq_x_u16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtnq_x_u32_f32)))
+uint32x4_t vcvtnq_x_u32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_s16_f16)))
+int16x8_t vcvtpq_m_s16_f16(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_s16_f16)))
+int16x8_t vcvtpq_m(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_s32_f32)))
+int32x4_t vcvtpq_m_s32_f32(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_s32_f32)))
+int32x4_t vcvtpq_m(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_u16_f16)))
+uint16x8_t vcvtpq_m_u16_f16(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_u16_f16)))
+uint16x8_t vcvtpq_m(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_u32_f32)))
+uint32x4_t vcvtpq_m_u32_f32(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_m_u32_f32)))
+uint32x4_t vcvtpq_m(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_s16_f16)))
+int16x8_t vcvtpq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_s32_f32)))
+int32x4_t vcvtpq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_u16_f16)))
+uint16x8_t vcvtpq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_u32_f32)))
+uint32x4_t vcvtpq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_x_s16_f16)))
+int16x8_t vcvtpq_x_s16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_x_s32_f32)))
+int32x4_t vcvtpq_x_s32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_x_u16_f16)))
+uint16x8_t vcvtpq_x_u16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtpq_x_u32_f32)))
+uint32x4_t vcvtpq_x_u32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f16_s16)))
+float16x8_t vcvtq_f16_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f16_s16)))
+float16x8_t vcvtq(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f16_u16)))
+float16x8_t vcvtq_f16_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f16_u16)))
+float16x8_t vcvtq(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f32_s32)))
+float32x4_t vcvtq_f32_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f32_s32)))
+float32x4_t vcvtq(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f32_u32)))
+float32x4_t vcvtq_f32_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_f32_u32)))
+float32x4_t vcvtq(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f16_s16)))
+float16x8_t vcvtq_m_f16_s16(float16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f16_s16)))
+float16x8_t vcvtq_m(float16x8_t, int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f16_u16)))
+float16x8_t vcvtq_m_f16_u16(float16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f16_u16)))
+float16x8_t vcvtq_m(float16x8_t, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f32_s32)))
+float32x4_t vcvtq_m_f32_s32(float32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f32_s32)))
+float32x4_t vcvtq_m(float32x4_t, int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f32_u32)))
+float32x4_t vcvtq_m_f32_u32(float32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_f32_u32)))
+float32x4_t vcvtq_m(float32x4_t, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f16_s16)))
+float16x8_t vcvtq_m_n_f16_s16(float16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f16_s16)))
+float16x8_t vcvtq_m_n(float16x8_t, int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f16_u16)))
+float16x8_t vcvtq_m_n_f16_u16(float16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f16_u16)))
+float16x8_t vcvtq_m_n(float16x8_t, uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f32_s32)))
+float32x4_t vcvtq_m_n_f32_s32(float32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f32_s32)))
+float32x4_t vcvtq_m_n(float32x4_t, int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f32_u32)))
+float32x4_t vcvtq_m_n_f32_u32(float32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_f32_u32)))
+float32x4_t vcvtq_m_n(float32x4_t, uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_s16_f16)))
+int16x8_t vcvtq_m_n_s16_f16(int16x8_t, float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_s16_f16)))
+int16x8_t vcvtq_m_n(int16x8_t, float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_s32_f32)))
+int32x4_t vcvtq_m_n_s32_f32(int32x4_t, float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_s32_f32)))
+int32x4_t vcvtq_m_n(int32x4_t, float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_u16_f16)))
+uint16x8_t vcvtq_m_n_u16_f16(uint16x8_t, float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_u16_f16)))
+uint16x8_t vcvtq_m_n(uint16x8_t, float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_u32_f32)))
+uint32x4_t vcvtq_m_n_u32_f32(uint32x4_t, float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_n_u32_f32)))
+uint32x4_t vcvtq_m_n(uint32x4_t, float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_s16_f16)))
+int16x8_t vcvtq_m_s16_f16(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_s16_f16)))
+int16x8_t vcvtq_m(int16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_s32_f32)))
+int32x4_t vcvtq_m_s32_f32(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_s32_f32)))
+int32x4_t vcvtq_m(int32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_u16_f16)))
+uint16x8_t vcvtq_m_u16_f16(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_u16_f16)))
+uint16x8_t vcvtq_m(uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_u32_f32)))
+uint32x4_t vcvtq_m_u32_f32(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_m_u32_f32)))
+uint32x4_t vcvtq_m(uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f16_s16)))
+float16x8_t vcvtq_n_f16_s16(int16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f16_s16)))
+float16x8_t vcvtq_n(int16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f16_u16)))
+float16x8_t vcvtq_n_f16_u16(uint16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f16_u16)))
+float16x8_t vcvtq_n(uint16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f32_s32)))
+float32x4_t vcvtq_n_f32_s32(int32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f32_s32)))
+float32x4_t vcvtq_n(int32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f32_u32)))
+float32x4_t vcvtq_n_f32_u32(uint32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_f32_u32)))
+float32x4_t vcvtq_n(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_s16_f16)))
+int16x8_t vcvtq_n_s16_f16(float16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_s32_f32)))
+int32x4_t vcvtq_n_s32_f32(float32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_u16_f16)))
+uint16x8_t vcvtq_n_u16_f16(float16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_n_u32_f32)))
+uint32x4_t vcvtq_n_u32_f32(float32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_s16_f16)))
+int16x8_t vcvtq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_s32_f32)))
+int32x4_t vcvtq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_u16_f16)))
+uint16x8_t vcvtq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_u32_f32)))
+uint32x4_t vcvtq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f16_s16)))
+float16x8_t vcvtq_x_f16_s16(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f16_s16)))
+float16x8_t vcvtq_x(int16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f16_u16)))
+float16x8_t vcvtq_x_f16_u16(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f16_u16)))
+float16x8_t vcvtq_x(uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f32_s32)))
+float32x4_t vcvtq_x_f32_s32(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f32_s32)))
+float32x4_t vcvtq_x(int32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f32_u32)))
+float32x4_t vcvtq_x_f32_u32(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_f32_u32)))
+float32x4_t vcvtq_x(uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f16_s16)))
+float16x8_t vcvtq_x_n_f16_s16(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f16_s16)))
+float16x8_t vcvtq_x_n(int16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f16_u16)))
+float16x8_t vcvtq_x_n_f16_u16(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f16_u16)))
+float16x8_t vcvtq_x_n(uint16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f32_s32)))
+float32x4_t vcvtq_x_n_f32_s32(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f32_s32)))
+float32x4_t vcvtq_x_n(int32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f32_u32)))
+float32x4_t vcvtq_x_n_f32_u32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_f32_u32)))
+float32x4_t vcvtq_x_n(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_s16_f16)))
+int16x8_t vcvtq_x_n_s16_f16(float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_s32_f32)))
+int32x4_t vcvtq_x_n_s32_f32(float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_u16_f16)))
+uint16x8_t vcvtq_x_n_u16_f16(float16x8_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_n_u32_f32)))
+uint32x4_t vcvtq_x_n_u32_f32(float32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_s16_f16)))
+int16x8_t vcvtq_x_s16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_s32_f32)))
+int32x4_t vcvtq_x_s32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_u16_f16)))
+uint16x8_t vcvtq_x_u16_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvtq_x_u32_f32)))
+uint32x4_t vcvtq_x_u32_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvttq_f16_f32)))
+float16x8_t vcvttq_f16_f32(float16x8_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvttq_f32_f16)))
+float32x4_t vcvttq_f32_f16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvttq_m_f16_f32)))
+float16x8_t vcvttq_m_f16_f32(float16x8_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvttq_m_f32_f16)))
+float32x4_t vcvttq_m_f32_f16(float32x4_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vcvttq_x_f32_f16)))
+float32x4_t vcvttq_x_f32_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_f16)))
+float16x8_t vdupq_m_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_f16)))
+float16x8_t vdupq_m(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_f32)))
+float32x4_t vdupq_m_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vdupq_m_n_f32)))
+float32x4_t vdupq_m(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_f16)))
+float16x8_t vdupq_n_f16(float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_n_f32)))
+float32x4_t vdupq_n_f32(float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_f16)))
+float16x8_t vdupq_x_n_f16(float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vdupq_x_n_f32)))
+float32x4_t vdupq_x_n_f32(float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_f16)))
+float16x8_t veorq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_f16)))
+float16x8_t veorq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_f32)))
+float32x4_t veorq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_f32)))
+float32x4_t veorq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_f16)))
+float16x8_t veorq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_f16)))
+float16x8_t veorq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_f32)))
+float32x4_t veorq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_m_f32)))
+float32x4_t veorq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_f16)))
+float16x8_t veorq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_f16)))
+float16x8_t veorq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_f32)))
+float32x4_t veorq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_veorq_x_f32)))
+float32x4_t veorq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_f16)))
+float16x8_t vfmaq_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_f16)))
+float16x8_t vfmaq(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_f32)))
+float32x4_t vfmaq_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_f32)))
+float32x4_t vfmaq(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_f16)))
+float16x8_t vfmaq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_f16)))
+float16x8_t vfmaq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_f32)))
+float32x4_t vfmaq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_f32)))
+float32x4_t vfmaq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_n_f16)))
+float16x8_t vfmaq_m_n_f16(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_n_f16)))
+float16x8_t vfmaq_m(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_n_f32)))
+float32x4_t vfmaq_m_n_f32(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_m_n_f32)))
+float32x4_t vfmaq_m(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_n_f16)))
+float16x8_t vfmaq_n_f16(float16x8_t, float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_n_f16)))
+float16x8_t vfmaq(float16x8_t, float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_n_f32)))
+float32x4_t vfmaq_n_f32(float32x4_t, float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmaq_n_f32)))
+float32x4_t vfmaq(float32x4_t, float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_m_n_f16)))
+float16x8_t vfmasq_m_n_f16(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_m_n_f16)))
+float16x8_t vfmasq_m(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_m_n_f32)))
+float32x4_t vfmasq_m_n_f32(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_m_n_f32)))
+float32x4_t vfmasq_m(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_n_f16)))
+float16x8_t vfmasq_n_f16(float16x8_t, float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_n_f16)))
+float16x8_t vfmasq(float16x8_t, float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_n_f32)))
+float32x4_t vfmasq_n_f32(float32x4_t, float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmasq_n_f32)))
+float32x4_t vfmasq(float32x4_t, float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_f16)))
+float16x8_t vfmsq_f16(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_f16)))
+float16x8_t vfmsq(float16x8_t, float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_f32)))
+float32x4_t vfmsq_f32(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_f32)))
+float32x4_t vfmsq(float32x4_t, float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_m_f16)))
+float16x8_t vfmsq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_m_f16)))
+float16x8_t vfmsq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_m_f32)))
+float32x4_t vfmsq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vfmsq_m_f32)))
+float32x4_t vfmsq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_f16)))
+float16_t vgetq_lane_f16(float16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_f16)))
+float16_t vgetq_lane(float16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_f32)))
+float32_t vgetq_lane_f32(float32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vgetq_lane_f32)))
+float32_t vgetq_lane(float32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_f16)))
+float16x8_t vld1q_f16(const float16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_f16)))
+float16x8_t vld1q(const float16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_f32)))
+float32x4_t vld1q_f32(const float32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_f32)))
+float32x4_t vld1q(const float32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_f16)))
+float16x8_t vld1q_z_f16(const float16_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_f16)))
+float16x8_t vld1q_z(const float16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_f32)))
+float32x4_t vld1q_z_f32(const float32_t *, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld1q_z_f32)))
+float32x4_t vld1q_z(const float32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_f16)))
+float16x8x2_t vld2q_f16(const float16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_f16)))
+float16x8x2_t vld2q(const float16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld2q_f32)))
+float32x4x2_t vld2q_f32(const float32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld2q_f32)))
+float32x4x2_t vld2q(const float32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_f16)))
+float16x8x4_t vld4q_f16(const float16_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_f16)))
+float16x8x4_t vld4q(const float16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vld4q_f32)))
+float32x4x4_t vld4q_f32(const float32_t *);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vld4q_f32)))
+float32x4x4_t vld4q(const float32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_f16)))
+float16x8_t vldrhq_f16(const float16_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_f16)))
+float16x8_t vldrhq_gather_offset_f16(const float16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_f16)))
+float16x8_t vldrhq_gather_offset(const float16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_f16)))
+float16x8_t vldrhq_gather_offset_z_f16(const float16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_offset_z_f16)))
+float16x8_t vldrhq_gather_offset_z(const float16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_f16)))
+float16x8_t vldrhq_gather_shifted_offset_f16(const float16_t *, uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_f16)))
+float16x8_t vldrhq_gather_shifted_offset(const float16_t *, uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_f16)))
+float16x8_t vldrhq_gather_shifted_offset_z_f16(const float16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_gather_shifted_offset_z_f16)))
+float16x8_t vldrhq_gather_shifted_offset_z(const float16_t *, uint16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrhq_z_f16)))
+float16x8_t vldrhq_z_f16(const float16_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_f32)))
+float32x4_t vldrwq_f32(const float32_t *);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_f32)))
+float32x4_t vldrwq_gather_base_f32(uint32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_f32)))
+float32x4_t vldrwq_gather_base_wb_f32(uint32x4_t *, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_wb_z_f32)))
+float32x4_t vldrwq_gather_base_wb_z_f32(uint32x4_t *, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_base_z_f32)))
+float32x4_t vldrwq_gather_base_z_f32(uint32x4_t, int, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_f32)))
+float32x4_t vldrwq_gather_offset_f32(const float32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_f32)))
+float32x4_t vldrwq_gather_offset(const float32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_f32)))
+float32x4_t vldrwq_gather_offset_z_f32(const float32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_offset_z_f32)))
+float32x4_t vldrwq_gather_offset_z(const float32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_f32)))
+float32x4_t vldrwq_gather_shifted_offset_f32(const float32_t *, uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_f32)))
+float32x4_t vldrwq_gather_shifted_offset(const float32_t *, uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_f32)))
+float32x4_t vldrwq_gather_shifted_offset_z_f32(const float32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_gather_shifted_offset_z_f32)))
+float32x4_t vldrwq_gather_shifted_offset_z(const float32_t *, uint32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vldrwq_z_f32)))
+float32x4_t vldrwq_z_f32(const float32_t *, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_f16)))
+float16x8_t vmaxnmaq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_f16)))
+float16x8_t vmaxnmaq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_f32)))
+float32x4_t vmaxnmaq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_f32)))
+float32x4_t vmaxnmaq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_m_f16)))
+float16x8_t vmaxnmaq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_m_f16)))
+float16x8_t vmaxnmaq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_m_f32)))
+float32x4_t vmaxnmaq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmaq_m_f32)))
+float32x4_t vmaxnmaq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_f16)))
+float16_t vmaxnmavq_f16(float16_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_f16)))
+float16_t vmaxnmavq(float16_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_f32)))
+float32_t vmaxnmavq_f32(float32_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_f32)))
+float32_t vmaxnmavq(float32_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_p_f16)))
+float16_t vmaxnmavq_p_f16(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_p_f16)))
+float16_t vmaxnmavq_p(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_p_f32)))
+float32_t vmaxnmavq_p_f32(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmavq_p_f32)))
+float32_t vmaxnmavq_p(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_f16)))
+float16x8_t vmaxnmq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_f16)))
+float16x8_t vmaxnmq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_f32)))
+float32x4_t vmaxnmq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_f32)))
+float32x4_t vmaxnmq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_m_f16)))
+float16x8_t vmaxnmq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_m_f16)))
+float16x8_t vmaxnmq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_m_f32)))
+float32x4_t vmaxnmq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_m_f32)))
+float32x4_t vmaxnmq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_x_f16)))
+float16x8_t vmaxnmq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_x_f16)))
+float16x8_t vmaxnmq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_x_f32)))
+float32x4_t vmaxnmq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmq_x_f32)))
+float32x4_t vmaxnmq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_f16)))
+float16_t vmaxnmvq_f16(float16_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_f16)))
+float16_t vmaxnmvq(float16_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_f32)))
+float32_t vmaxnmvq_f32(float32_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_f32)))
+float32_t vmaxnmvq(float32_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_p_f16)))
+float16_t vmaxnmvq_p_f16(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_p_f16)))
+float16_t vmaxnmvq_p(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_p_f32)))
+float32_t vmaxnmvq_p_f32(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmaxnmvq_p_f32)))
+float32_t vmaxnmvq_p(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_f16)))
+float16x8_t vminnmaq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_f16)))
+float16x8_t vminnmaq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_f32)))
+float32x4_t vminnmaq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_f32)))
+float32x4_t vminnmaq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_m_f16)))
+float16x8_t vminnmaq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_m_f16)))
+float16x8_t vminnmaq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_m_f32)))
+float32x4_t vminnmaq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmaq_m_f32)))
+float32x4_t vminnmaq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_f16)))
+float16_t vminnmavq_f16(float16_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_f16)))
+float16_t vminnmavq(float16_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_f32)))
+float32_t vminnmavq_f32(float32_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_f32)))
+float32_t vminnmavq(float32_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_p_f16)))
+float16_t vminnmavq_p_f16(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_p_f16)))
+float16_t vminnmavq_p(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_p_f32)))
+float32_t vminnmavq_p_f32(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmavq_p_f32)))
+float32_t vminnmavq_p(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_f16)))
+float16x8_t vminnmq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_f16)))
+float16x8_t vminnmq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_f32)))
+float32x4_t vminnmq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_f32)))
+float32x4_t vminnmq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_m_f16)))
+float16x8_t vminnmq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_m_f16)))
+float16x8_t vminnmq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_m_f32)))
+float32x4_t vminnmq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_m_f32)))
+float32x4_t vminnmq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_x_f16)))
+float16x8_t vminnmq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_x_f16)))
+float16x8_t vminnmq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_x_f32)))
+float32x4_t vminnmq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmq_x_f32)))
+float32x4_t vminnmq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_f16)))
+float16_t vminnmvq_f16(float16_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_f16)))
+float16_t vminnmvq(float16_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_f32)))
+float32_t vminnmvq_f32(float32_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_f32)))
+float32_t vminnmvq(float32_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_p_f16)))
+float16_t vminnmvq_p_f16(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_p_f16)))
+float16_t vminnmvq_p(float16_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_p_f32)))
+float32_t vminnmvq_p_f32(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vminnmvq_p_f32)))
+float32_t vminnmvq_p(float32_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_f16)))
+float16x8_t vmulq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_f16)))
+float16x8_t vmulq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_f32)))
+float32x4_t vmulq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_f32)))
+float32x4_t vmulq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_f16)))
+float16x8_t vmulq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_f16)))
+float16x8_t vmulq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_f32)))
+float32x4_t vmulq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_f32)))
+float32x4_t vmulq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_f16)))
+float16x8_t vmulq_m_n_f16(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_f16)))
+float16x8_t vmulq_m(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_f32)))
+float32x4_t vmulq_m_n_f32(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_m_n_f32)))
+float32x4_t vmulq_m(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_f16)))
+float16x8_t vmulq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_f16)))
+float16x8_t vmulq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_f32)))
+float32x4_t vmulq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_n_f32)))
+float32x4_t vmulq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_f16)))
+float16x8_t vmulq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_f16)))
+float16x8_t vmulq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_f32)))
+float32x4_t vmulq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_f32)))
+float32x4_t vmulq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_f16)))
+float16x8_t vmulq_x_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_f16)))
+float16x8_t vmulq_x(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_f32)))
+float32x4_t vmulq_x_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vmulq_x_n_f32)))
+float32x4_t vmulq_x(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_f16)))
+float16x8_t vnegq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_f16)))
+float16x8_t vnegq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_f32)))
+float32x4_t vnegq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_f32)))
+float32x4_t vnegq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_f16)))
+float16x8_t vnegq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_f16)))
+float16x8_t vnegq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_f32)))
+float32x4_t vnegq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_m_f32)))
+float32x4_t vnegq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_f16)))
+float16x8_t vnegq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_f16)))
+float16x8_t vnegq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_f32)))
+float32x4_t vnegq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vnegq_x_f32)))
+float32x4_t vnegq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_f16)))
+float16x8_t vornq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_f16)))
+float16x8_t vornq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_f32)))
+float32x4_t vornq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_f32)))
+float32x4_t vornq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_f16)))
+float16x8_t vornq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_f16)))
+float16x8_t vornq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_f32)))
+float32x4_t vornq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_m_f32)))
+float32x4_t vornq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_f16)))
+float16x8_t vornq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_f16)))
+float16x8_t vornq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_f32)))
+float32x4_t vornq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vornq_x_f32)))
+float32x4_t vornq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_f16)))
+float16x8_t vorrq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_f16)))
+float16x8_t vorrq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_f32)))
+float32x4_t vorrq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_f32)))
+float32x4_t vorrq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_f16)))
+float16x8_t vorrq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_f16)))
+float16x8_t vorrq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_f32)))
+float32x4_t vorrq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_m_f32)))
+float32x4_t vorrq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_f16)))
+float16x8_t vorrq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_f16)))
+float16x8_t vorrq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_f32)))
+float32x4_t vorrq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vorrq_x_f32)))
+float32x4_t vorrq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_f16)))
+float16x8_t vpselq_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_f16)))
+float16x8_t vpselq(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vpselq_f32)))
+float32x4_t vpselq_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vpselq_f32)))
+float32x4_t vpselq(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_f32)))
+float16x8_t vreinterpretq_f16_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_f32)))
+float16x8_t vreinterpretq_f16(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s16)))
+float16x8_t vreinterpretq_f16_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s16)))
+float16x8_t vreinterpretq_f16(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s32)))
+float16x8_t vreinterpretq_f16_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s32)))
+float16x8_t vreinterpretq_f16(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s64)))
+float16x8_t vreinterpretq_f16_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s64)))
+float16x8_t vreinterpretq_f16(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s8)))
+float16x8_t vreinterpretq_f16_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_s8)))
+float16x8_t vreinterpretq_f16(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u16)))
+float16x8_t vreinterpretq_f16_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u16)))
+float16x8_t vreinterpretq_f16(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u32)))
+float16x8_t vreinterpretq_f16_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u32)))
+float16x8_t vreinterpretq_f16(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u64)))
+float16x8_t vreinterpretq_f16_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u64)))
+float16x8_t vreinterpretq_f16(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u8)))
+float16x8_t vreinterpretq_f16_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f16_u8)))
+float16x8_t vreinterpretq_f16(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_f16)))
+float32x4_t vreinterpretq_f32_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_f16)))
+float32x4_t vreinterpretq_f32(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s16)))
+float32x4_t vreinterpretq_f32_s16(int16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s16)))
+float32x4_t vreinterpretq_f32(int16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s32)))
+float32x4_t vreinterpretq_f32_s32(int32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s32)))
+float32x4_t vreinterpretq_f32(int32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s64)))
+float32x4_t vreinterpretq_f32_s64(int64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s64)))
+float32x4_t vreinterpretq_f32(int64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s8)))
+float32x4_t vreinterpretq_f32_s8(int8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_s8)))
+float32x4_t vreinterpretq_f32(int8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u16)))
+float32x4_t vreinterpretq_f32_u16(uint16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u16)))
+float32x4_t vreinterpretq_f32(uint16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u32)))
+float32x4_t vreinterpretq_f32_u32(uint32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u32)))
+float32x4_t vreinterpretq_f32(uint32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u64)))
+float32x4_t vreinterpretq_f32_u64(uint64x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u64)))
+float32x4_t vreinterpretq_f32(uint64x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u8)))
+float32x4_t vreinterpretq_f32_u8(uint8x16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_f32_u8)))
+float32x4_t vreinterpretq_f32(uint8x16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_f16)))
+int16x8_t vreinterpretq_s16_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_f16)))
+int16x8_t vreinterpretq_s16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_f32)))
+int16x8_t vreinterpretq_s16_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s16_f32)))
+int16x8_t vreinterpretq_s16(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_f16)))
+int32x4_t vreinterpretq_s32_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_f16)))
+int32x4_t vreinterpretq_s32(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_f32)))
+int32x4_t vreinterpretq_s32_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s32_f32)))
+int32x4_t vreinterpretq_s32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_f16)))
+int64x2_t vreinterpretq_s64_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_f16)))
+int64x2_t vreinterpretq_s64(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_f32)))
+int64x2_t vreinterpretq_s64_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s64_f32)))
+int64x2_t vreinterpretq_s64(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_f16)))
+int8x16_t vreinterpretq_s8_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_f16)))
+int8x16_t vreinterpretq_s8(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_f32)))
+int8x16_t vreinterpretq_s8_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_s8_f32)))
+int8x16_t vreinterpretq_s8(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_f16)))
+uint16x8_t vreinterpretq_u16_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_f16)))
+uint16x8_t vreinterpretq_u16(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_f32)))
+uint16x8_t vreinterpretq_u16_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u16_f32)))
+uint16x8_t vreinterpretq_u16(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_f16)))
+uint32x4_t vreinterpretq_u32_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_f16)))
+uint32x4_t vreinterpretq_u32(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_f32)))
+uint32x4_t vreinterpretq_u32_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u32_f32)))
+uint32x4_t vreinterpretq_u32(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_f16)))
+uint64x2_t vreinterpretq_u64_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_f16)))
+uint64x2_t vreinterpretq_u64(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_f32)))
+uint64x2_t vreinterpretq_u64_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u64_f32)))
+uint64x2_t vreinterpretq_u64(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f16)))
+uint8x16_t vreinterpretq_u8_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f16)))
+uint8x16_t vreinterpretq_u8(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f32)))
+uint8x16_t vreinterpretq_u8_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vreinterpretq_u8_f32)))
+uint8x16_t vreinterpretq_u8(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_f16)))
+float16x8_t vrev32q_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_f16)))
+float16x8_t vrev32q(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_f16)))
+float16x8_t vrev32q_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_m_f16)))
+float16x8_t vrev32q_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_f16)))
+float16x8_t vrev32q_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev32q_x_f16)))
+float16x8_t vrev32q_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_f16)))
+float16x8_t vrev64q_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_f16)))
+float16x8_t vrev64q(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_f32)))
+float32x4_t vrev64q_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_f32)))
+float32x4_t vrev64q(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_f16)))
+float16x8_t vrev64q_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_f16)))
+float16x8_t vrev64q_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_f32)))
+float32x4_t vrev64q_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_m_f32)))
+float32x4_t vrev64q_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_f16)))
+float16x8_t vrev64q_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_f16)))
+float16x8_t vrev64q_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_f32)))
+float32x4_t vrev64q_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrev64q_x_f32)))
+float32x4_t vrev64q_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_f16)))
+float16x8_t vrndaq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_f16)))
+float16x8_t vrndaq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_f32)))
+float32x4_t vrndaq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_f32)))
+float32x4_t vrndaq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_m_f16)))
+float16x8_t vrndaq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_m_f16)))
+float16x8_t vrndaq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_m_f32)))
+float32x4_t vrndaq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_m_f32)))
+float32x4_t vrndaq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_x_f16)))
+float16x8_t vrndaq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_x_f16)))
+float16x8_t vrndaq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_x_f32)))
+float32x4_t vrndaq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndaq_x_f32)))
+float32x4_t vrndaq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_f16)))
+float16x8_t vrndmq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_f16)))
+float16x8_t vrndmq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_f32)))
+float32x4_t vrndmq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_f32)))
+float32x4_t vrndmq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_m_f16)))
+float16x8_t vrndmq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_m_f16)))
+float16x8_t vrndmq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_m_f32)))
+float32x4_t vrndmq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_m_f32)))
+float32x4_t vrndmq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_x_f16)))
+float16x8_t vrndmq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_x_f16)))
+float16x8_t vrndmq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_x_f32)))
+float32x4_t vrndmq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndmq_x_f32)))
+float32x4_t vrndmq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_f16)))
+float16x8_t vrndnq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_f16)))
+float16x8_t vrndnq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_f32)))
+float32x4_t vrndnq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_f32)))
+float32x4_t vrndnq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_m_f16)))
+float16x8_t vrndnq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_m_f16)))
+float16x8_t vrndnq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_m_f32)))
+float32x4_t vrndnq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_m_f32)))
+float32x4_t vrndnq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_x_f16)))
+float16x8_t vrndnq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_x_f16)))
+float16x8_t vrndnq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_x_f32)))
+float32x4_t vrndnq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndnq_x_f32)))
+float32x4_t vrndnq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_f16)))
+float16x8_t vrndpq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_f16)))
+float16x8_t vrndpq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_f32)))
+float32x4_t vrndpq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_f32)))
+float32x4_t vrndpq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_m_f16)))
+float16x8_t vrndpq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_m_f16)))
+float16x8_t vrndpq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_m_f32)))
+float32x4_t vrndpq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_m_f32)))
+float32x4_t vrndpq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_x_f16)))
+float16x8_t vrndpq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_x_f16)))
+float16x8_t vrndpq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_x_f32)))
+float32x4_t vrndpq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndpq_x_f32)))
+float32x4_t vrndpq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_f16)))
+float16x8_t vrndq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_f16)))
+float16x8_t vrndq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_f32)))
+float32x4_t vrndq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_f32)))
+float32x4_t vrndq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_m_f16)))
+float16x8_t vrndq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_m_f16)))
+float16x8_t vrndq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_m_f32)))
+float32x4_t vrndq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_m_f32)))
+float32x4_t vrndq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_x_f16)))
+float16x8_t vrndq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_x_f16)))
+float16x8_t vrndq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndq_x_f32)))
+float32x4_t vrndq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndq_x_f32)))
+float32x4_t vrndq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_f16)))
+float16x8_t vrndxq_f16(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_f16)))
+float16x8_t vrndxq(float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_f32)))
+float32x4_t vrndxq_f32(float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_f32)))
+float32x4_t vrndxq(float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_m_f16)))
+float16x8_t vrndxq_m_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_m_f16)))
+float16x8_t vrndxq_m(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_m_f32)))
+float32x4_t vrndxq_m_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_m_f32)))
+float32x4_t vrndxq_m(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_x_f16)))
+float16x8_t vrndxq_x_f16(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_x_f16)))
+float16x8_t vrndxq_x(float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_x_f32)))
+float32x4_t vrndxq_x_f32(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vrndxq_x_f32)))
+float32x4_t vrndxq_x(float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_f16)))
+float16x8_t vsetq_lane_f16(float16_t, float16x8_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_f16)))
+float16x8_t vsetq_lane(float16_t, float16x8_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_f32)))
+float32x4_t vsetq_lane_f32(float32_t, float32x4_t, int);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsetq_lane_f32)))
+float32x4_t vsetq_lane(float32_t, float32x4_t, int);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_f16)))
+void vst1q_f16(float16_t *, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_f16)))
+void vst1q(float16_t *, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_f32)))
+void vst1q_f32(float32_t *, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_f32)))
+void vst1q(float32_t *, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_f16)))
+void vst1q_p_f16(float16_t *, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_f16)))
+void vst1q_p(float16_t *, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_f32)))
+void vst1q_p_f32(float32_t *, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst1q_p_f32)))
+void vst1q_p(float32_t *, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_f16)))
+void vst2q_f16(float16_t *, float16x8x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_f16)))
+void vst2q(float16_t *, float16x8x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst2q_f32)))
+void vst2q_f32(float32_t *, float32x4x2_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst2q_f32)))
+void vst2q(float32_t *, float32x4x2_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_f16)))
+void vst4q_f16(float16_t *, float16x8x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_f16)))
+void vst4q(float16_t *, float16x8x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vst4q_f32)))
+void vst4q_f32(float32_t *, float32x4x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vst4q_f32)))
+void vst4q(float32_t *, float32x4x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_f16)))
+void vstrhq_f16(float16_t *, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_f16)))
+void vstrhq(float16_t *, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_f16)))
+void vstrhq_p_f16(float16_t *, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_p_f16)))
+void vstrhq_p(float16_t *, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_f16)))
+void vstrhq_scatter_offset_f16(float16_t *, uint16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_f16)))
+void vstrhq_scatter_offset(float16_t *, uint16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_f16)))
+void vstrhq_scatter_offset_p_f16(float16_t *, uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_offset_p_f16)))
+void vstrhq_scatter_offset_p(float16_t *, uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_f16)))
+void vstrhq_scatter_shifted_offset_f16(float16_t *, uint16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_f16)))
+void vstrhq_scatter_shifted_offset(float16_t *, uint16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_f16)))
+void vstrhq_scatter_shifted_offset_p_f16(float16_t *, uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrhq_scatter_shifted_offset_p_f16)))
+void vstrhq_scatter_shifted_offset_p(float16_t *, uint16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_f32)))
+void vstrwq_f32(float32_t *, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_f32)))
+void vstrwq(float32_t *, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_f32)))
+void vstrwq_p_f32(float32_t *, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_p_f32)))
+void vstrwq_p(float32_t *, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_f32)))
+void vstrwq_scatter_base_f32(uint32x4_t, int, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_f32)))
+void vstrwq_scatter_base(uint32x4_t, int, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_f32)))
+void vstrwq_scatter_base_p_f32(uint32x4_t, int, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_p_f32)))
+void vstrwq_scatter_base_p(uint32x4_t, int, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_f32)))
+void vstrwq_scatter_base_wb_f32(uint32x4_t *, int, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_f32)))
+void vstrwq_scatter_base_wb(uint32x4_t *, int, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_f32)))
+void vstrwq_scatter_base_wb_p_f32(uint32x4_t *, int, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_base_wb_p_f32)))
+void vstrwq_scatter_base_wb_p(uint32x4_t *, int, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_f32)))
+void vstrwq_scatter_offset_f32(float32_t *, uint32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_f32)))
+void vstrwq_scatter_offset(float32_t *, uint32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_f32)))
+void vstrwq_scatter_offset_p_f32(float32_t *, uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_offset_p_f32)))
+void vstrwq_scatter_offset_p(float32_t *, uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_f32)))
+void vstrwq_scatter_shifted_offset_f32(float32_t *, uint32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_f32)))
+void vstrwq_scatter_shifted_offset(float32_t *, uint32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_f32)))
+void vstrwq_scatter_shifted_offset_p_f32(float32_t *, uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vstrwq_scatter_shifted_offset_p_f32)))
+void vstrwq_scatter_shifted_offset_p(float32_t *, uint32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_f16)))
+float16x8_t vsubq_f16(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_f16)))
+float16x8_t vsubq(float16x8_t, float16x8_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_f32)))
+float32x4_t vsubq_f32(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_f32)))
+float32x4_t vsubq(float32x4_t, float32x4_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_f16)))
+float16x8_t vsubq_m_f16(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_f16)))
+float16x8_t vsubq_m(float16x8_t, float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_f32)))
+float32x4_t vsubq_m_f32(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_f32)))
+float32x4_t vsubq_m(float32x4_t, float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_f16)))
+float16x8_t vsubq_m_n_f16(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_f16)))
+float16x8_t vsubq_m(float16x8_t, float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_f32)))
+float32x4_t vsubq_m_n_f32(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_m_n_f32)))
+float32x4_t vsubq_m(float32x4_t, float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_f16)))
+float16x8_t vsubq_n_f16(float16x8_t, float16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_f16)))
+float16x8_t vsubq(float16x8_t, float16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_f32)))
+float32x4_t vsubq_n_f32(float32x4_t, float32_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_n_f32)))
+float32x4_t vsubq(float32x4_t, float32_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_f16)))
+float16x8_t vsubq_x_f16(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_f16)))
+float16x8_t vsubq_x(float16x8_t, float16x8_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_f32)))
+float32x4_t vsubq_x_f32(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_f32)))
+float32x4_t vsubq_x(float32x4_t, float32x4_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_f16)))
+float16x8_t vsubq_x_n_f16(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_f16)))
+float16x8_t vsubq_x(float16x8_t, float16_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_f32)))
+float32x4_t vsubq_x_n_f32(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vsubq_x_n_f32)))
+float32x4_t vsubq_x(float32x4_t, float32_t, mve_pred16_t);
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_f16)))
+float16x8_t vuninitializedq_f16();
+static __inline__ __attribute__((__clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_f32)))
+float32x4_t vuninitializedq_f32();
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_f16)))
+float16x8_t vuninitializedq(float16x8_t);
+static __inline__ __attribute__((__overloadable__, __clang_arm_builtin_alias(__builtin_arm_mve_vuninitializedq_polymorphic_f32)))
+float32x4_t vuninitializedq(float32x4_t);
+
+#endif /* (__ARM_FEATURE_MVE & 2) && (!defined __ARM_MVE_PRESERVE_USER_NAMESPACE) */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* __ARM_MVE_H */
diff --git a/third_party/aarch64/clang/arm_neon.h b/third_party/aarch64/clang/arm_neon.h
new file mode 100644
index 000000000..b67616134
--- /dev/null
+++ b/third_party/aarch64/clang/arm_neon.h
@@ -0,0 +1,69638 @@
+/*===---- arm_neon.h - ARM Neon intrinsics ---------------------------------===
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ARM_NEON_H
+#define __ARM_NEON_H
+
+#ifndef __ARM_FP
+#error "NEON intrinsics not available with the soft-float ABI. Please use -mfloat-abi=softfp or -mfloat-abi=hard"
+#else
+
+#include <stdint.h>
+
+#include <arm_bf16.h>
+#include <arm_vector_types.h>
+#if defined(__aarch64__) || defined(__arm64ec__)
+typedef uint8_t poly8_t;
+typedef uint16_t poly16_t;
+typedef uint64_t poly64_t;
+typedef __uint128_t poly128_t;
+#else
+typedef int8_t poly8_t;
+typedef int16_t poly16_t;
+typedef int64_t poly64_t;
+#endif
+typedef __attribute__((neon_polyvector_type(8))) poly8_t poly8x8_t;
+typedef __attribute__((neon_polyvector_type(16))) poly8_t poly8x16_t;
+typedef __attribute__((neon_polyvector_type(4))) poly16_t poly16x4_t;
+typedef __attribute__((neon_polyvector_type(8))) poly16_t poly16x8_t;
+typedef __attribute__((neon_polyvector_type(1))) poly64_t poly64x1_t;
+typedef __attribute__((neon_polyvector_type(2))) poly64_t poly64x2_t;
+
+typedef struct poly8x8x2_t {
+  poly8x8_t val[2];
+} poly8x8x2_t;
+
+typedef struct poly8x16x2_t {
+  poly8x16_t val[2];
+} poly8x16x2_t;
+
+typedef struct poly16x4x2_t {
+  poly16x4_t val[2];
+} poly16x4x2_t;
+
+typedef struct poly16x8x2_t {
+  poly16x8_t val[2];
+} poly16x8x2_t;
+
+typedef struct poly64x1x2_t {
+  poly64x1_t val[2];
+} poly64x1x2_t;
+
+typedef struct poly64x2x2_t {
+  poly64x2_t val[2];
+} poly64x2x2_t;
+
+typedef struct poly8x8x3_t {
+  poly8x8_t val[3];
+} poly8x8x3_t;
+
+typedef struct poly8x16x3_t {
+  poly8x16_t val[3];
+} poly8x16x3_t;
+
+typedef struct poly16x4x3_t {
+  poly16x4_t val[3];
+} poly16x4x3_t;
+
+typedef struct poly16x8x3_t {
+  poly16x8_t val[3];
+} poly16x8x3_t;
+
+typedef struct poly64x1x3_t {
+  poly64x1_t val[3];
+} poly64x1x3_t;
+
+typedef struct poly64x2x3_t {
+  poly64x2_t val[3];
+} poly64x2x3_t;
+
+typedef struct poly8x8x4_t {
+  poly8x8_t val[4];
+} poly8x8x4_t;
+
+typedef struct poly8x16x4_t {
+  poly8x16_t val[4];
+} poly8x16x4_t;
+
+typedef struct poly16x4x4_t {
+  poly16x4_t val[4];
+} poly16x4x4_t;
+
+typedef struct poly16x8x4_t {
+  poly16x8_t val[4];
+} poly16x8x4_t;
+
+typedef struct poly64x1x4_t {
+  poly64x1_t val[4];
+} poly64x1x4_t;
+
+typedef struct poly64x2x4_t {
+  poly64x2_t val[4];
+} poly64x2x4_t;
+
+#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  __ret = (bfloat16x8_t) __builtin_neon_splatq_lane_bf16((int8x8_t)__s0, __p1, 11); \
+  __ret; \
+})
+#else
+#define splatq_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  bfloat16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (bfloat16x8_t) __builtin_neon_splatq_lane_bf16((int8x8_t)__rev0, __p1, 11); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  __ret = (bfloat16x8_t) __builtin_neon_splatq_lane_bf16((int8x8_t)__s0, __p1, 11); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  __ret = (bfloat16x4_t) __builtin_neon_splat_lane_bf16((int8x8_t)__s0, __p1, 11); \
+  __ret; \
+})
+#else
+#define splat_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  bfloat16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (bfloat16x4_t) __builtin_neon_splat_lane_bf16((int8x8_t)__rev0, __p1, 11); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  __ret = (bfloat16x4_t) __builtin_neon_splat_lane_bf16((int8x8_t)__s0, __p1, 11); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  __ret = (bfloat16x8_t) __builtin_neon_splatq_laneq_bf16((int8x16_t)__s0, __p1, 43); \
+  __ret; \
+})
+#else
+#define splatq_laneq_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  bfloat16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (bfloat16x8_t) __builtin_neon_splatq_laneq_bf16((int8x16_t)__rev0, __p1, 43); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  __ret = (bfloat16x8_t) __builtin_neon_splatq_laneq_bf16((int8x16_t)__s0, __p1, 43); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  __ret = (bfloat16x4_t) __builtin_neon_splat_laneq_bf16((int8x16_t)__s0, __p1, 43); \
+  __ret; \
+})
+#else
+#define splat_laneq_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  bfloat16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (bfloat16x4_t) __builtin_neon_splat_laneq_bf16((int8x16_t)__rev0, __p1, 43); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  __ret = (bfloat16x4_t) __builtin_neon_splat_laneq_bf16((int8x16_t)__s0, __p1, 43); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfdotq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vbfdotq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfdotq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  bfloat16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  bfloat16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vbfdotq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x4_t __noswap_vbfdotq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vbfdotq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x2_t vbfdot_f32(float32x2_t __p0, bfloat16x4_t __p1, bfloat16x4_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vbfdot_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x2_t vbfdot_f32(float32x2_t __p0, bfloat16x4_t __p1, bfloat16x4_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  bfloat16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  bfloat16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vbfdot_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x2_t __noswap_vbfdot_f32(float32x2_t __p0, bfloat16x4_t __p1, bfloat16x4_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vbfdot_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmlalbq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vbfmlalbq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmlalbq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  bfloat16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  bfloat16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vbfmlalbq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x4_t __noswap_vbfmlalbq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vbfmlalbq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmlaltq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vbfmlaltq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmlaltq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  bfloat16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  bfloat16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vbfmlaltq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x4_t __noswap_vbfmlaltq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vbfmlaltq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmmlaq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vbfmmlaq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vbfmmlaq_f32(float32x4_t __p0, bfloat16x8_t __p1, bfloat16x8_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  bfloat16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  bfloat16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vbfmmlaq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcombine_bf16(bfloat16x4_t __p0, bfloat16x4_t __p1) {
+  bfloat16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcombine_bf16(bfloat16x4_t __p0, bfloat16x4_t __p1) {
+  bfloat16x8_t __ret;
+  bfloat16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  bfloat16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t __noswap_vcombine_bf16(bfloat16x4_t __p0, bfloat16x4_t __p1) {
+  bfloat16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#endif
+
+#define vcreate_bf16(__p0) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (bfloat16x4_t)(__promote); \
+  __ret; \
+})
+__ai __attribute__((target("bf16,neon"))) float32_t vcvtah_f32_bf16(bfloat16_t __p0) {
+  float32_t __ret;
+bfloat16_t __reint = __p0;
+int32_t __reint1 = (int32_t)(*(int16_t *) &__reint) << 16;
+  __ret = *(float32_t *) &__reint1;
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16_t vcvth_bf16_f32(float32_t __p0) {
+  bfloat16_t __ret;
+  __ret = (bfloat16_t) __builtin_neon_vcvth_bf16_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vduph_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  __ret = (bfloat16_t) __builtin_neon_vduph_lane_bf16((bfloat16x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vduph_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  bfloat16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (bfloat16_t) __builtin_neon_vduph_lane_bf16((bfloat16x4_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_bf16(__p0_0, __p1_0) __extension__ ({ \
+  bfloat16x8_t __ret_0; \
+  bfloat16x4_t __s0_0 = __p0_0; \
+  __ret_0 = splatq_lane_bf16(__s0_0, __p1_0); \
+  __ret_0; \
+})
+#else
+#define vdupq_lane_bf16(__p0_1, __p1_1) __extension__ ({ \
+  bfloat16x8_t __ret_1; \
+  bfloat16x4_t __s0_1 = __p0_1; \
+  bfloat16x4_t __rev0_1;  __rev0_1 = __builtin_shufflevector(__s0_1, __s0_1, 3, 2, 1, 0); \
+  __ret_1 = __noswap_splatq_lane_bf16(__rev0_1, __p1_1); \
+  __ret_1 = __builtin_shufflevector(__ret_1, __ret_1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_1; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_bf16(__p0_2, __p1_2) __extension__ ({ \
+  bfloat16x4_t __ret_2; \
+  bfloat16x4_t __s0_2 = __p0_2; \
+  __ret_2 = splat_lane_bf16(__s0_2, __p1_2); \
+  __ret_2; \
+})
+#else
+#define vdup_lane_bf16(__p0_3, __p1_3) __extension__ ({ \
+  bfloat16x4_t __ret_3; \
+  bfloat16x4_t __s0_3 = __p0_3; \
+  bfloat16x4_t __rev0_3;  __rev0_3 = __builtin_shufflevector(__s0_3, __s0_3, 3, 2, 1, 0); \
+  __ret_3 = __noswap_splat_lane_bf16(__rev0_3, __p1_3); \
+  __ret_3 = __builtin_shufflevector(__ret_3, __ret_3, 3, 2, 1, 0); \
+  __ret_3; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vduph_laneq_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  __ret = (bfloat16_t) __builtin_neon_vduph_laneq_bf16((bfloat16x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vduph_laneq_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  bfloat16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (bfloat16_t) __builtin_neon_vduph_laneq_bf16((bfloat16x8_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_bf16(__p0_4, __p1_4) __extension__ ({ \
+  bfloat16x8_t __ret_4; \
+  bfloat16x8_t __s0_4 = __p0_4; \
+  __ret_4 = splatq_laneq_bf16(__s0_4, __p1_4); \
+  __ret_4; \
+})
+#else
+#define vdupq_laneq_bf16(__p0_5, __p1_5) __extension__ ({ \
+  bfloat16x8_t __ret_5; \
+  bfloat16x8_t __s0_5 = __p0_5; \
+  bfloat16x8_t __rev0_5;  __rev0_5 = __builtin_shufflevector(__s0_5, __s0_5, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_5 = __noswap_splatq_laneq_bf16(__rev0_5, __p1_5); \
+  __ret_5 = __builtin_shufflevector(__ret_5, __ret_5, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_5; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_bf16(__p0_6, __p1_6) __extension__ ({ \
+  bfloat16x4_t __ret_6; \
+  bfloat16x8_t __s0_6 = __p0_6; \
+  __ret_6 = splat_laneq_bf16(__s0_6, __p1_6); \
+  __ret_6; \
+})
+#else
+#define vdup_laneq_bf16(__p0_7, __p1_7) __extension__ ({ \
+  bfloat16x4_t __ret_7; \
+  bfloat16x8_t __s0_7 = __p0_7; \
+  bfloat16x8_t __rev0_7;  __rev0_7 = __builtin_shufflevector(__s0_7, __s0_7, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_7 = __noswap_splat_laneq_bf16(__rev0_7, __p1_7); \
+  __ret_7 = __builtin_shufflevector(__ret_7, __ret_7, 3, 2, 1, 0); \
+  __ret_7; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vdupq_n_bf16(bfloat16_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vdupq_n_bf16(bfloat16_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vdup_n_bf16(bfloat16_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vdup_n_bf16(bfloat16_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vget_high_bf16(bfloat16x8_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vget_high_bf16(bfloat16x8_t __p0) {
+  bfloat16x4_t __ret;
+  bfloat16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t __noswap_vget_high_bf16(bfloat16x8_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  __ret = (bfloat16_t) __builtin_neon_vgetq_lane_bf16((bfloat16x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  bfloat16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (bfloat16_t) __builtin_neon_vgetq_lane_bf16((bfloat16x8_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16_t __ret; \
+  bfloat16x8_t __s0 = __p0; \
+  __ret = (bfloat16_t) __builtin_neon_vgetq_lane_bf16((bfloat16x8_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  __ret = (bfloat16_t) __builtin_neon_vget_lane_bf16((bfloat16x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vget_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  bfloat16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (bfloat16_t) __builtin_neon_vget_lane_bf16((bfloat16x4_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vget_lane_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16_t __ret; \
+  bfloat16x4_t __s0 = __p0; \
+  __ret = (bfloat16_t) __builtin_neon_vget_lane_bf16((bfloat16x4_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vget_low_bf16(bfloat16x8_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vget_low_bf16(bfloat16x8_t __p0) {
+  bfloat16x4_t __ret;
+  bfloat16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t __noswap_vget_low_bf16(bfloat16x8_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_bf16(__p0) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  __ret = (bfloat16x8_t) __builtin_neon_vld1q_bf16(__p0, 43); \
+  __ret; \
+})
+#else
+#define vld1q_bf16(__p0) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  __ret = (bfloat16x8_t) __builtin_neon_vld1q_bf16(__p0, 43); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_bf16(__p0) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  __ret = (bfloat16x4_t) __builtin_neon_vld1_bf16(__p0, 11); \
+  __ret; \
+})
+#else
+#define vld1_bf16(__p0) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  __ret = (bfloat16x4_t) __builtin_neon_vld1_bf16(__p0, 11); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  __ret = (bfloat16x8_t) __builtin_neon_vld1q_dup_bf16(__p0, 43); \
+  __ret; \
+})
+#else
+#define vld1q_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  __ret = (bfloat16x8_t) __builtin_neon_vld1q_dup_bf16(__p0, 43); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  __ret = (bfloat16x4_t) __builtin_neon_vld1_dup_bf16(__p0, 11); \
+  __ret; \
+})
+#else
+#define vld1_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  __ret = (bfloat16x4_t) __builtin_neon_vld1_dup_bf16(__p0, 11); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16x8_t __s1 = __p1; \
+  __ret = (bfloat16x8_t) __builtin_neon_vld1q_lane_bf16(__p0, (int8x16_t)__s1, __p2, 43); \
+  __ret; \
+})
+#else
+#define vld1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16x8_t __s1 = __p1; \
+  bfloat16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (bfloat16x8_t) __builtin_neon_vld1q_lane_bf16(__p0, (int8x16_t)__rev1, __p2, 43); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16x4_t __s1 = __p1; \
+  __ret = (bfloat16x4_t) __builtin_neon_vld1_lane_bf16(__p0, (int8x8_t)__s1, __p2, 11); \
+  __ret; \
+})
+#else
+#define vld1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16x4_t __s1 = __p1; \
+  bfloat16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (bfloat16x4_t) __builtin_neon_vld1_lane_bf16(__p0, (int8x8_t)__rev1, __p2, 11); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_bf16_x2(__p0) __extension__ ({ \
+  bfloat16x8x2_t __ret; \
+  __builtin_neon_vld1q_bf16_x2(&__ret, __p0, 43); \
+  __ret; \
+})
+#else
+#define vld1q_bf16_x2(__p0) __extension__ ({ \
+  bfloat16x8x2_t __ret; \
+  __builtin_neon_vld1q_bf16_x2(&__ret, __p0, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_bf16_x2(__p0) __extension__ ({ \
+  bfloat16x4x2_t __ret; \
+  __builtin_neon_vld1_bf16_x2(&__ret, __p0, 11); \
+  __ret; \
+})
+#else
+#define vld1_bf16_x2(__p0) __extension__ ({ \
+  bfloat16x4x2_t __ret; \
+  __builtin_neon_vld1_bf16_x2(&__ret, __p0, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_bf16_x3(__p0) __extension__ ({ \
+  bfloat16x8x3_t __ret; \
+  __builtin_neon_vld1q_bf16_x3(&__ret, __p0, 43); \
+  __ret; \
+})
+#else
+#define vld1q_bf16_x3(__p0) __extension__ ({ \
+  bfloat16x8x3_t __ret; \
+  __builtin_neon_vld1q_bf16_x3(&__ret, __p0, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_bf16_x3(__p0) __extension__ ({ \
+  bfloat16x4x3_t __ret; \
+  __builtin_neon_vld1_bf16_x3(&__ret, __p0, 11); \
+  __ret; \
+})
+#else
+#define vld1_bf16_x3(__p0) __extension__ ({ \
+  bfloat16x4x3_t __ret; \
+  __builtin_neon_vld1_bf16_x3(&__ret, __p0, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_bf16_x4(__p0) __extension__ ({ \
+  bfloat16x8x4_t __ret; \
+  __builtin_neon_vld1q_bf16_x4(&__ret, __p0, 43); \
+  __ret; \
+})
+#else
+#define vld1q_bf16_x4(__p0) __extension__ ({ \
+  bfloat16x8x4_t __ret; \
+  __builtin_neon_vld1q_bf16_x4(&__ret, __p0, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_bf16_x4(__p0) __extension__ ({ \
+  bfloat16x4x4_t __ret; \
+  __builtin_neon_vld1_bf16_x4(&__ret, __p0, 11); \
+  __ret; \
+})
+#else
+#define vld1_bf16_x4(__p0) __extension__ ({ \
+  bfloat16x4x4_t __ret; \
+  __builtin_neon_vld1_bf16_x4(&__ret, __p0, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_bf16(__p0) __extension__ ({ \
+  bfloat16x8x2_t __ret; \
+  __builtin_neon_vld2q_bf16(&__ret, __p0, 43); \
+  __ret; \
+})
+#else
+#define vld2q_bf16(__p0) __extension__ ({ \
+  bfloat16x8x2_t __ret; \
+  __builtin_neon_vld2q_bf16(&__ret, __p0, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_bf16(__p0) __extension__ ({ \
+  bfloat16x4x2_t __ret; \
+  __builtin_neon_vld2_bf16(&__ret, __p0, 11); \
+  __ret; \
+})
+#else
+#define vld2_bf16(__p0) __extension__ ({ \
+  bfloat16x4x2_t __ret; \
+  __builtin_neon_vld2_bf16(&__ret, __p0, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x8x2_t __ret; \
+  __builtin_neon_vld2q_dup_bf16(&__ret, __p0, 43); \
+  __ret; \
+})
+#else
+#define vld2q_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x8x2_t __ret; \
+  __builtin_neon_vld2q_dup_bf16(&__ret, __p0, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x4x2_t __ret; \
+  __builtin_neon_vld2_dup_bf16(&__ret, __p0, 11); \
+  __ret; \
+})
+#else
+#define vld2_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x4x2_t __ret; \
+  __builtin_neon_vld2_dup_bf16(&__ret, __p0, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x2_t __ret; \
+  bfloat16x8x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_bf16(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 43); \
+  __ret; \
+})
+#else
+#define vld2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x2_t __ret; \
+  bfloat16x8x2_t __s1 = __p1; \
+  bfloat16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_bf16(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x2_t __ret; \
+  bfloat16x4x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_bf16(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 11); \
+  __ret; \
+})
+#else
+#define vld2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x2_t __ret; \
+  bfloat16x4x2_t __s1 = __p1; \
+  bfloat16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vld2_lane_bf16(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_bf16(__p0) __extension__ ({ \
+  bfloat16x8x3_t __ret; \
+  __builtin_neon_vld3q_bf16(&__ret, __p0, 43); \
+  __ret; \
+})
+#else
+#define vld3q_bf16(__p0) __extension__ ({ \
+  bfloat16x8x3_t __ret; \
+  __builtin_neon_vld3q_bf16(&__ret, __p0, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_bf16(__p0) __extension__ ({ \
+  bfloat16x4x3_t __ret; \
+  __builtin_neon_vld3_bf16(&__ret, __p0, 11); \
+  __ret; \
+})
+#else
+#define vld3_bf16(__p0) __extension__ ({ \
+  bfloat16x4x3_t __ret; \
+  __builtin_neon_vld3_bf16(&__ret, __p0, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x8x3_t __ret; \
+  __builtin_neon_vld3q_dup_bf16(&__ret, __p0, 43); \
+  __ret; \
+})
+#else
+#define vld3q_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x8x3_t __ret; \
+  __builtin_neon_vld3q_dup_bf16(&__ret, __p0, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x4x3_t __ret; \
+  __builtin_neon_vld3_dup_bf16(&__ret, __p0, 11); \
+  __ret; \
+})
+#else
+#define vld3_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x4x3_t __ret; \
+  __builtin_neon_vld3_dup_bf16(&__ret, __p0, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x3_t __ret; \
+  bfloat16x8x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_bf16(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 43); \
+  __ret; \
+})
+#else
+#define vld3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x3_t __ret; \
+  bfloat16x8x3_t __s1 = __p1; \
+  bfloat16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_bf16(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x3_t __ret; \
+  bfloat16x4x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_bf16(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 11); \
+  __ret; \
+})
+#else
+#define vld3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x3_t __ret; \
+  bfloat16x4x3_t __s1 = __p1; \
+  bfloat16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vld3_lane_bf16(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_bf16(__p0) __extension__ ({ \
+  bfloat16x8x4_t __ret; \
+  __builtin_neon_vld4q_bf16(&__ret, __p0, 43); \
+  __ret; \
+})
+#else
+#define vld4q_bf16(__p0) __extension__ ({ \
+  bfloat16x8x4_t __ret; \
+  __builtin_neon_vld4q_bf16(&__ret, __p0, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_bf16(__p0) __extension__ ({ \
+  bfloat16x4x4_t __ret; \
+  __builtin_neon_vld4_bf16(&__ret, __p0, 11); \
+  __ret; \
+})
+#else
+#define vld4_bf16(__p0) __extension__ ({ \
+  bfloat16x4x4_t __ret; \
+  __builtin_neon_vld4_bf16(&__ret, __p0, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x8x4_t __ret; \
+  __builtin_neon_vld4q_dup_bf16(&__ret, __p0, 43); \
+  __ret; \
+})
+#else
+#define vld4q_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x8x4_t __ret; \
+  __builtin_neon_vld4q_dup_bf16(&__ret, __p0, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x4x4_t __ret; \
+  __builtin_neon_vld4_dup_bf16(&__ret, __p0, 11); \
+  __ret; \
+})
+#else
+#define vld4_dup_bf16(__p0) __extension__ ({ \
+  bfloat16x4x4_t __ret; \
+  __builtin_neon_vld4_dup_bf16(&__ret, __p0, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x4_t __ret; \
+  bfloat16x8x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_bf16(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 43); \
+  __ret; \
+})
+#else
+#define vld4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x4_t __ret; \
+  bfloat16x8x4_t __s1 = __p1; \
+  bfloat16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_bf16(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 43); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x4_t __ret; \
+  bfloat16x4x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_bf16(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 11); \
+  __ret; \
+})
+#else
+#define vld4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x4_t __ret; \
+  bfloat16x4x4_t __s1 = __p1; \
+  bfloat16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vld4_lane_bf16(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 11); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16_t __s0 = __p0; \
+  bfloat16x8_t __s1 = __p1; \
+  __ret = (bfloat16x8_t) __builtin_neon_vsetq_lane_bf16(__s0, (bfloat16x8_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16_t __s0 = __p0; \
+  bfloat16x8_t __s1 = __p1; \
+  bfloat16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (bfloat16x8_t) __builtin_neon_vsetq_lane_bf16(__s0, (bfloat16x8_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8_t __ret; \
+  bfloat16_t __s0 = __p0; \
+  bfloat16x8_t __s1 = __p1; \
+  __ret = (bfloat16x8_t) __builtin_neon_vsetq_lane_bf16(__s0, (bfloat16x8_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16_t __s0 = __p0; \
+  bfloat16x4_t __s1 = __p1; \
+  __ret = (bfloat16x4_t) __builtin_neon_vset_lane_bf16(__s0, (bfloat16x4_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vset_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16_t __s0 = __p0; \
+  bfloat16x4_t __s1 = __p1; \
+  bfloat16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (bfloat16x4_t) __builtin_neon_vset_lane_bf16(__s0, (bfloat16x4_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vset_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4_t __ret; \
+  bfloat16_t __s0 = __p0; \
+  bfloat16x4_t __s1 = __p1; \
+  __ret = (bfloat16x4_t) __builtin_neon_vset_lane_bf16(__s0, (bfloat16x4_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8_t __s1 = __p1; \
+  __builtin_neon_vst1q_bf16(__p0, (int8x16_t)__s1, 43); \
+})
+#else
+#define vst1q_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8_t __s1 = __p1; \
+  bfloat16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_bf16(__p0, (int8x16_t)__rev1, 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4_t __s1 = __p1; \
+  __builtin_neon_vst1_bf16(__p0, (int8x8_t)__s1, 11); \
+})
+#else
+#define vst1_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4_t __s1 = __p1; \
+  bfloat16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1_bf16(__p0, (int8x8_t)__rev1, 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_bf16(__p0, (int8x16_t)__s1, __p2, 43); \
+})
+#else
+#define vst1q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8_t __s1 = __p1; \
+  bfloat16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_bf16(__p0, (int8x16_t)__rev1, __p2, 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_bf16(__p0, (int8x8_t)__s1, __p2, 11); \
+})
+#else
+#define vst1_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4_t __s1 = __p1; \
+  bfloat16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1_lane_bf16(__p0, (int8x8_t)__rev1, __p2, 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_bf16_x2(__p0, __p1) __extension__ ({ \
+  bfloat16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_bf16_x2(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 43); \
+})
+#else
+#define vst1q_bf16_x2(__p0, __p1) __extension__ ({ \
+  bfloat16x8x2_t __s1 = __p1; \
+  bfloat16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_bf16_x2(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_bf16_x2(__p0, __p1) __extension__ ({ \
+  bfloat16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst1_bf16_x2(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 11); \
+})
+#else
+#define vst1_bf16_x2(__p0, __p1) __extension__ ({ \
+  bfloat16x4x2_t __s1 = __p1; \
+  bfloat16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst1_bf16_x2(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_bf16_x3(__p0, __p1) __extension__ ({ \
+  bfloat16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_bf16_x3(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 43); \
+})
+#else
+#define vst1q_bf16_x3(__p0, __p1) __extension__ ({ \
+  bfloat16x8x3_t __s1 = __p1; \
+  bfloat16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_bf16_x3(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_bf16_x3(__p0, __p1) __extension__ ({ \
+  bfloat16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst1_bf16_x3(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 11); \
+})
+#else
+#define vst1_bf16_x3(__p0, __p1) __extension__ ({ \
+  bfloat16x4x3_t __s1 = __p1; \
+  bfloat16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst1_bf16_x3(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_bf16_x4(__p0, __p1) __extension__ ({ \
+  bfloat16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_bf16_x4(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 43); \
+})
+#else
+#define vst1q_bf16_x4(__p0, __p1) __extension__ ({ \
+  bfloat16x8x4_t __s1 = __p1; \
+  bfloat16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_bf16_x4(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_bf16_x4(__p0, __p1) __extension__ ({ \
+  bfloat16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst1_bf16_x4(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 11); \
+})
+#else
+#define vst1_bf16_x4(__p0, __p1) __extension__ ({ \
+  bfloat16x4x4_t __s1 = __p1; \
+  bfloat16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst1_bf16_x4(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 43); \
+})
+#else
+#define vst2q_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8x2_t __s1 = __p1; \
+  bfloat16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 11); \
+})
+#else
+#define vst2_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4x2_t __s1 = __p1; \
+  bfloat16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 43); \
+})
+#else
+#define vst2q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x2_t __s1 = __p1; \
+  bfloat16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 11); \
+})
+#else
+#define vst2_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x2_t __s1 = __p1; \
+  bfloat16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2_lane_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 43); \
+})
+#else
+#define vst3q_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8x3_t __s1 = __p1; \
+  bfloat16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 11); \
+})
+#else
+#define vst3_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4x3_t __s1 = __p1; \
+  bfloat16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 43); \
+})
+#else
+#define vst3q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x3_t __s1 = __p1; \
+  bfloat16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 11); \
+})
+#else
+#define vst3_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x3_t __s1 = __p1; \
+  bfloat16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3_lane_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 43); \
+})
+#else
+#define vst4q_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x8x4_t __s1 = __p1; \
+  bfloat16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 11); \
+})
+#else
+#define vst4_bf16(__p0, __p1) __extension__ ({ \
+  bfloat16x4x4_t __s1 = __p1; \
+  bfloat16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_bf16(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 43); \
+})
+#else
+#define vst4q_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x8x4_t __s1 = __p1; \
+  bfloat16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_bf16(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 43); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_bf16(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 11); \
+})
+#else
+#define vst4_lane_bf16(__p0, __p1, __p2) __extension__ ({ \
+  bfloat16x4x4_t __s1 = __p1; \
+  bfloat16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4_lane_bf16(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 11); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("dotprod,neon"))) uint32x4_t vdotq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vdotq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("dotprod,neon"))) uint32x4_t vdotq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vdotq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("dotprod,neon"))) uint32x4_t __noswap_vdotq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vdotq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("dotprod,neon"))) int32x4_t vdotq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("dotprod,neon"))) int32x4_t vdotq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vdotq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("dotprod,neon"))) int32x4_t __noswap_vdotq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("dotprod,neon"))) uint32x2_t vdot_u32(uint32x2_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vdot_u32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("dotprod,neon"))) uint32x2_t vdot_u32(uint32x2_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vdot_u32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("dotprod,neon"))) uint32x2_t __noswap_vdot_u32(uint32x2_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vdot_u32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 18);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("dotprod,neon"))) int32x2_t vdot_s32(int32x2_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("dotprod,neon"))) int32x2_t vdot_s32(int32x2_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vdot_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("dotprod,neon"))) int32x2_t __noswap_vdot_s32(int32x2_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vabdq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vabdq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vabdq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vabdq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vabd_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vabd_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vabd_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vabd_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vabsq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vabsq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vabsq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vabsq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vabs_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vabs_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vabs_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vabs_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vaddq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vaddq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vadd_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vadd_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcageq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcageq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcageq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcageq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcage_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcage_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcage_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcage_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcagtq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcagtq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcagtq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcagtq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcagt_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcagt_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcagt_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcagt_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcaleq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcaleq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcaleq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcaleq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcale_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcale_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcale_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcale_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcaltq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcaltq_f16((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcaltq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcaltq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcalt_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcalt_f16((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcalt_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcalt_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vceqq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vceqq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vceq_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vceq_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vceqzq_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vceqzq_f16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vceqzq_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vceqzq_f16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vceqz_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vceqz_f16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vceqz_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vceqz_f16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgeq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgeq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcge_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcge_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgezq_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcgezq_f16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgezq_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcgezq_f16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgez_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcgez_f16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgez_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcgez_f16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgtq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgtq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgt_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgt_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgtzq_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcgtzq_f16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcgtzq_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcgtzq_f16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgtz_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcgtz_f16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcgtz_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcgtz_f16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcleq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcleq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcle_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcle_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vclezq_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vclezq_f16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vclezq_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vclezq_f16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vclez_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vclez_f16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vclez_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vclez_f16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcltq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcltq_f16(float16x8_t __p0, float16x8_t __p1) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vclt_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vclt_f16(float16x4_t __p0, float16x4_t __p1) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcltzq_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcltzq_f16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcltzq_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcltzq_f16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcltz_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcltz_f16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcltz_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcltz_f16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vcvtq_f16_u16(uint16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcvtq_f16_u16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vcvtq_f16_u16(uint16x8_t __p0) {
+  float16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vcvtq_f16_u16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vcvtq_f16_s16(int16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcvtq_f16_s16((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vcvtq_f16_s16(int16x8_t __p0) {
+  float16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vcvtq_f16_s16((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vcvt_f16_u16(uint16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcvt_f16_u16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vcvt_f16_u16(uint16x4_t __p0) {
+  float16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vcvt_f16_u16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vcvt_f16_s16(int16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcvt_f16_s16((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vcvt_f16_s16(int16x4_t __p0) {
+  float16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vcvt_f16_s16((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_f16_u16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_u16((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#else
+#define vcvtq_n_f16_u16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_u16((int8x16_t)__rev0, __p1, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_f16_s16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_s16((int8x16_t)__s0, __p1, 33); \
+  __ret; \
+})
+#else
+#define vcvtq_n_f16_s16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16x8_t) __builtin_neon_vcvtq_n_f16_s16((int8x16_t)__rev0, __p1, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvt_n_f16_u16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_u16((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vcvt_n_f16_u16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_u16((int8x8_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvt_n_f16_s16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_s16((int8x8_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define vcvt_n_f16_s16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float16x4_t) __builtin_neon_vcvt_n_f16_s16((int8x8_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_s16_f16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_vcvtq_n_s16_f16((int8x16_t)__s0, __p1, 33); \
+  __ret; \
+})
+#else
+#define vcvtq_n_s16_f16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vcvtq_n_s16_f16((int8x16_t)__rev0, __p1, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvt_n_s16_f16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vcvt_n_s16_f16((int8x8_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define vcvt_n_s16_f16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vcvt_n_s16_f16((int8x8_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_u16_f16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_vcvtq_n_u16_f16((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#else
+#define vcvtq_n_u16_f16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vcvtq_n_u16_f16((int8x16_t)__rev0, __p1, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvt_n_u16_f16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vcvt_n_u16_f16((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vcvt_n_u16_f16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vcvt_n_u16_f16((int8x8_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vcvtq_s16_f16((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vcvtq_s16_f16((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvt_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vcvt_s16_f16((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvt_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vcvt_s16_f16((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcvtq_u16_f16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcvtq_u16_f16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvt_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcvt_u16_f16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvt_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcvt_u16_f16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtaq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vcvtaq_s16_f16((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtaq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vcvtaq_s16_f16((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvta_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vcvta_s16_f16((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvta_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vcvta_s16_f16((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtaq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcvtaq_u16_f16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtaq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcvtaq_u16_f16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvta_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcvta_u16_f16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvta_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcvta_u16_f16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtmq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vcvtmq_s16_f16((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtmq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vcvtmq_s16_f16((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtm_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vcvtm_s16_f16((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtm_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vcvtm_s16_f16((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtmq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcvtmq_u16_f16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtmq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcvtmq_u16_f16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtm_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcvtm_u16_f16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtm_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcvtm_u16_f16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtnq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vcvtnq_s16_f16((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtnq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vcvtnq_s16_f16((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtn_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vcvtn_s16_f16((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtn_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vcvtn_s16_f16((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtnq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcvtnq_u16_f16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtnq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcvtnq_u16_f16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtn_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcvtn_u16_f16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtn_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcvtn_u16_f16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtpq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vcvtpq_s16_f16((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) int16x8_t vcvtpq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vcvtpq_s16_f16((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtp_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vcvtp_s16_f16((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) int16x4_t vcvtp_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vcvtp_s16_f16((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtpq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcvtpq_u16_f16((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x8_t vcvtpq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcvtpq_u16_f16((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtp_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcvtp_u16_f16((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) uint16x4_t vcvtp_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcvtp_u16_f16((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vfmaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vfmaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vfmaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vfmaq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t __noswap_vfmaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vfmaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vfma_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vfma_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vfma_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vfma_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t __noswap_vfma_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vfma_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vfmsq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = vfmaq_f16(__p0, -__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vfmsq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vfmaq_f16(__rev0, -__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vfms_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = vfma_f16(__p0, -__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vfms_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vfma_f16(__rev0, -__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vmaxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vmaxq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmax_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vmax_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmax_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vmax_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vminq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vminq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vminq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vminq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmin_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vmin_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmin_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vmin_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmulq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmulq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmul_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmul_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_n_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = __s0 * (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}; \
+  __ret; \
+})
+#else
+#define vmulq_n_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = __rev0 * (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}; \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_n_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = __s0 * (float16x4_t) {__s1, __s1, __s1, __s1}; \
+  __ret; \
+})
+#else
+#define vmul_n_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = __rev0 * (float16x4_t) {__s1, __s1, __s1, __s1}; \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vnegq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vnegq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vneg_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vneg_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpadd_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vpadd_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpadd_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vpadd_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmax_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vpmax_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmax_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vpmax_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmin_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vpmin_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmin_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vpmin_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrecpeq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrecpeq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrecpeq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrecpeq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrecpe_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrecpe_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrecpe_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrecpe_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrecpsq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrecpsq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrecpsq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrecpsq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrecps_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrecps_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrecps_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrecps_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrsqrteq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrsqrteq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrsqrteq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrsqrteq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrsqrte_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrsqrte_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrsqrte_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrsqrte_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrsqrtsq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrsqrtsq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrsqrtsq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrsqrtsq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrsqrts_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrsqrts_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrsqrts_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrsqrts_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vsubq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vsubq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vsub_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vsub_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("i8mm,neon"))) uint32x4_t vmmlaq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vmmlaq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("i8mm,neon"))) uint32x4_t vmmlaq_u32(uint32x4_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vmmlaq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vmmlaq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vmmlaq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vmmlaq_s32(int32x4_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vmmlaq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vusdotq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vusdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vusdotq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vusdotq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("i8mm,neon"))) int32x4_t __noswap_vusdotq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vusdotq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("i8mm,neon"))) int32x2_t vusdot_s32(int32x2_t __p0, uint8x8_t __p1, int8x8_t __p2) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vusdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("i8mm,neon"))) int32x2_t vusdot_s32(int32x2_t __p0, uint8x8_t __p1, int8x8_t __p2) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vusdot_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("i8mm,neon"))) int32x2_t __noswap_vusdot_s32(int32x2_t __p0, uint8x8_t __p1, int8x8_t __p2) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vusdot_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vusmmlaq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vusmmlaq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("i8mm,neon"))) int32x4_t vusmmlaq_s32(int32x4_t __p0, uint8x16_t __p1, int8x16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vusmmlaq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  __ret = (poly8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 4); \
+  __ret; \
+})
+#else
+#define splat_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 4); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  __ret = (poly8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 4); \
+  __ret; \
+})
+#endif
+
+#define splat_lane_p64(__p0, __p1) __extension__ ({ \
+  poly64x1_t __ret; \
+  poly64x1_t __s0 = __p0; \
+  __ret = (poly64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  __ret = (poly16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 5); \
+  __ret; \
+})
+#else
+#define splat_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (poly16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 5); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  __ret = (poly16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 5); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  __ret = (poly8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 4); \
+  __ret; \
+})
+#else
+#define splatq_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 4); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  __ret = (poly8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 4); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_p64(__p0, __p1) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x1_t __s0 = __p0; \
+  __ret = (poly64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 6); \
+  __ret; \
+})
+#else
+#define splatq_lane_p64(__p0, __p1) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x1_t __s0 = __p0; \
+  __ret = (poly64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 6); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_p64(__p0, __p1) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x1_t __s0 = __p0; \
+  __ret = (poly64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 6); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  __ret = (poly16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 5); \
+  __ret; \
+})
+#else
+#define splatq_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (poly16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 5); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  __ret = (poly16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 5); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define splatq_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 16); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define splatq_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 19); \
+  __ret; \
+})
+#else
+#define splatq_lane_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 19); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 19); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define splatq_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 0); \
+  __ret; \
+})
+#else
+#define splatq_lane_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8x16_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_f64(__p0, __p1) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x1_t __s0 = __p0; \
+  __ret = (float64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 10); \
+  __ret; \
+})
+#else
+#define splatq_lane_f64(__p0, __p1) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x1_t __s0 = __p0; \
+  __ret = (float64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 10); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_f64(__p0, __p1) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x1_t __s0 = __p0; \
+  __ret = (float64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 10); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_f32(__p0, __p1) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x2_t __s0 = __p0; \
+  __ret = (float32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 9); \
+  __ret; \
+})
+#else
+#define splatq_lane_f32(__p0, __p1) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 9); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_f32(__p0, __p1) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x2_t __s0 = __p0; \
+  __ret = (float32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 9); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (float16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 8); \
+  __ret; \
+})
+#else
+#define splatq_lane_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 8); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (float16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 8); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define splatq_lane_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 3); \
+  __ret; \
+})
+#else
+#define splatq_lane_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 3); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_lane_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define splatq_lane_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_lane_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_splatq_lane_v((int8x8_t)__s0, __p1, 1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define splat_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 16); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define splat_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#endif
+
+#define splat_lane_u64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (uint64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define splat_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 0); \
+  __ret; \
+})
+#else
+#define splat_lane_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 0); \
+  __ret; \
+})
+#endif
+
+#define splat_lane_f64(__p0, __p1) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  __ret = (float64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 10); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_f32(__p0, __p1) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  __ret = (float32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 9); \
+  __ret; \
+})
+#else
+#define splat_lane_f32(__p0, __p1) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 9); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_f32(__p0, __p1) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  __ret = (float32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 9); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (float16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 8); \
+  __ret; \
+})
+#else
+#define splat_lane_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 8); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (float16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 8); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define splat_lane_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 2); \
+  __ret; \
+})
+#endif
+
+#define splat_lane_s64(__p0, __p1) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (int64x1_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define splat_lane_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define splat_lane_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_lane_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_splat_lane_v((int8x8_t)__s0, __p1, 1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_p8(__p0, __p1) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  __ret = (poly8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 36); \
+  __ret; \
+})
+#else
+#define splat_laneq_p8(__p0, __p1) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 36); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_p8(__p0, __p1) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  __ret = (poly8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 36); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_p64(__p0, __p1) __extension__ ({ \
+  poly64x1_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  __ret = (poly64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 38); \
+  __ret; \
+})
+#else
+#define splat_laneq_p64(__p0, __p1) __extension__ ({ \
+  poly64x1_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (poly64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 38); \
+  __ret; \
+})
+#define __noswap_splat_laneq_p64(__p0, __p1) __extension__ ({ \
+  poly64x1_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  __ret = (poly64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 38); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_p16(__p0, __p1) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  __ret = (poly16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 37); \
+  __ret; \
+})
+#else
+#define splat_laneq_p16(__p0, __p1) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 37); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_p16(__p0, __p1) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  __ret = (poly16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 37); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_p8(__p0, __p1) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  __ret = (poly8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 36); \
+  __ret; \
+})
+#else
+#define splatq_laneq_p8(__p0, __p1) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 36); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_p8(__p0, __p1) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  __ret = (poly8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 36); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_p64(__p0, __p1) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  __ret = (poly64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 38); \
+  __ret; \
+})
+#else
+#define splatq_laneq_p64(__p0, __p1) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (poly64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 38); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_p64(__p0, __p1) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  __ret = (poly64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 38); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_p16(__p0, __p1) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  __ret = (poly16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 37); \
+  __ret; \
+})
+#else
+#define splatq_laneq_p16(__p0, __p1) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 37); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_p16(__p0, __p1) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  __ret = (poly16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 37); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 48); \
+  __ret; \
+})
+#else
+#define splatq_laneq_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 48); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#else
+#define splatq_laneq_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#else
+#define splatq_laneq_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#else
+#define splatq_laneq_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 32); \
+  __ret; \
+})
+#else
+#define splatq_laneq_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8x16_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 32); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_f64(__p0, __p1) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  __ret = (float64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 42); \
+  __ret; \
+})
+#else
+#define splatq_laneq_f64(__p0, __p1) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 42); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_f64(__p0, __p1) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  __ret = (float64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 42); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_f32(__p0, __p1) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  __ret = (float32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 41); \
+  __ret; \
+})
+#else
+#define splatq_laneq_f32(__p0, __p1) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 41); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_f32(__p0, __p1) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  __ret = (float32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 41); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (float16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 40); \
+  __ret; \
+})
+#else
+#define splatq_laneq_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 40); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (float16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 40); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 34); \
+  __ret; \
+})
+#else
+#define splatq_laneq_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 34); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 35); \
+  __ret; \
+})
+#else
+#define splatq_laneq_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 35); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splatq_laneq_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 33); \
+  __ret; \
+})
+#else
+#define splatq_laneq_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__rev0, __p1, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splatq_laneq_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_splatq_laneq_v((int8x16_t)__s0, __p1, 33); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 48); \
+  __ret; \
+})
+#else
+#define splat_laneq_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 48); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#else
+#define splat_laneq_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_u64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#else
+#define splat_laneq_u64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 51); \
+  __ret; \
+})
+#define __noswap_splat_laneq_u64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#else
+#define splat_laneq_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 32); \
+  __ret; \
+})
+#else
+#define splat_laneq_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 32); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_f64(__p0, __p1) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x2_t __s0 = __p0; \
+  __ret = (float64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 42); \
+  __ret; \
+})
+#else
+#define splat_laneq_f64(__p0, __p1) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 42); \
+  __ret; \
+})
+#define __noswap_splat_laneq_f64(__p0, __p1) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x2_t __s0 = __p0; \
+  __ret = (float64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 42); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_f32(__p0, __p1) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x4_t __s0 = __p0; \
+  __ret = (float32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 41); \
+  __ret; \
+})
+#else
+#define splat_laneq_f32(__p0, __p1) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 41); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_f32(__p0, __p1) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x4_t __s0 = __p0; \
+  __ret = (float32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 41); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (float16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 40); \
+  __ret; \
+})
+#else
+#define splat_laneq_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 40); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (float16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 40); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 34); \
+  __ret; \
+})
+#else
+#define splat_laneq_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 34); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_s64(__p0, __p1) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 35); \
+  __ret; \
+})
+#else
+#define splat_laneq_s64(__p0, __p1) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 35); \
+  __ret; \
+})
+#define __noswap_splat_laneq_s64(__p0, __p1) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64x1_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 35); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define splat_laneq_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 33); \
+  __ret; \
+})
+#else
+#define splat_laneq_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__rev0, __p1, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_splat_laneq_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_splat_laneq_v((int8x16_t)__s0, __p1, 33); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vabdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vabdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t __noswap_vabdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vabdq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vabdq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vabdq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vabdq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vabdq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vabdq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vabdq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vabdq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t __noswap_vabdq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vabdq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vabdq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vabdq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vabdq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vabdq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vabdq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vabdq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vabdq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vabd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vabd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vabd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vabd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vabd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vabd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vabd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vabd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vabd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vabd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vabd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vabd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vabd_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vabd_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vabd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vabd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vabd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vabd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vabd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vabd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vabd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vabsq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vabsq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vabsq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vabsq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vabsq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vabsq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vabsq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vabsq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vabs_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vabs_v((int8x8_t)__p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vabs_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vabs_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vabs_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vabs_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vabs_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vabs_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vabs_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vabs_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vabs_v((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vabs_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vabs_v((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vaddq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vaddq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vadd_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vadd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vadd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vadd_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vadd_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vadd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vadd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vadd_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vadd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vadd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vadd_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vadd_v((int8x8_t)__p0, (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vadd_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) poly64x1_t vadd_p64(poly64x1_t __p0, poly64x1_t __p1) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t) __builtin_neon_vadd_v((int8x8_t)__p0, (int8x8_t)__p1, 6);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vadd_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t) __builtin_neon_vadd_v((int8x8_t)__p0, (int8x8_t)__p1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vadd_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (poly16x4_t) __builtin_neon_vadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 5);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vaddq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vaddq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vaddq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t) __builtin_neon_vaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 38);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vaddq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (poly64x2_t) __builtin_neon_vaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 38);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vaddq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t) __builtin_neon_vaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 37);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vaddq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly16x8_t) __builtin_neon_vaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 37);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vaddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vaddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vaddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vaddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vaddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vaddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vaddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vaddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vaddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vaddhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vaddhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vaddhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vaddhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vaddhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vaddhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vaddhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vaddhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vaddhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vaddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vandq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vandq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vandq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vandq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vandq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vandq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vandq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vandq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vandq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vandq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vandq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vandq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vandq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vandq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vandq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vandq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vand_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vand_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vand_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vand_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vand_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vand_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vand_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vand_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vand_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vand_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vand_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vand_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vand_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __p0 & __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vand_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 & __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vbicq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vbicq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vbicq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vbicq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vbicq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vbicq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vbicq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vbicq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vbicq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vbicq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vbicq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vbicq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vbicq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vbicq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vbicq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vbicq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vbic_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vbic_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vbic_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vbic_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vbic_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vbic_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vbic_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vbic_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vbic_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vbic_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vbic_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vbic_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vbic_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __p0 & ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vbic_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 & ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vbsl_p8(uint8x8_t __p0, poly8x8_t __p1, poly8x8_t __p2) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vbsl_p8(uint8x8_t __p0, poly8x8_t __p1, poly8x8_t __p2) {
+  poly8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vbsl_p16(uint16x4_t __p0, poly16x4_t __p1, poly16x4_t __p2) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vbsl_p16(uint16x4_t __p0, poly16x4_t __p1, poly16x4_t __p2) {
+  poly16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  poly16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (poly16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 5);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vbslq_p8(uint8x16_t __p0, poly8x16_t __p1, poly8x16_t __p2) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vbslq_p8(uint8x16_t __p0, poly8x16_t __p1, poly8x16_t __p2) {
+  poly8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vbslq_p16(uint16x8_t __p0, poly16x8_t __p1, poly16x8_t __p2) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 37);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vbslq_p16(uint16x8_t __p0, poly16x8_t __p1, poly16x8_t __p2) {
+  poly16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 37);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vbslq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vbslq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vbslq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vbslq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vbslq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vbslq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vbslq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vbslq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vbslq_s8(uint8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vbslq_s8(uint8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vbslq_f32(uint32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vbslq_f32(uint32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vbslq_s32(uint32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vbslq_s32(uint32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vbslq_s64(uint64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vbslq_s64(uint64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vbslq_s16(uint16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vbslq_s16(uint16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vbsl_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vbsl_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vbsl_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vbsl_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vbsl_u64(uint64x1_t __p0, uint64x1_t __p1, uint64x1_t __p2) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vbsl_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vbsl_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vbsl_s8(uint8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vbsl_s8(uint8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vbsl_f32(uint32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vbsl_f32(uint32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vbsl_s32(uint32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vbsl_s32(uint32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vbsl_s64(uint64x1_t __p0, int64x1_t __p1, int64x1_t __p2) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 3);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vbsl_s16(uint16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vbsl_s16(uint16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vbslq_f16(uint16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vbslq_f16(uint16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vbsl_f16(uint16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vbsl_f16(uint16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vbsl_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcageq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcageq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcageq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcageq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcage_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcage_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcage_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcage_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcagtq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcagtq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcagtq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcagtq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcagt_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcagt_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcagt_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcagt_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcaleq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcaleq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcaleq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcaleq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcale_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcale_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcale_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcale_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcaltq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcaltq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcaltq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcaltq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcalt_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcalt_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcalt_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcalt_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vceq_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vceq_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  uint8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  uint8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vceqq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vceqq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vceqq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vceqq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vceqq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vceqq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vceq_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vceq_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vceq_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vceq_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vceq_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vceq_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vceq_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vceq_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vceq_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vceq_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vceq_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vceq_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vceq_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vceq_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcgeq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcgeq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcgeq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcgeq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcgeq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcgeq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcgeq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcgeq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcgeq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcge_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcge_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcge_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcge_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vcge_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vcge_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcge_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcge_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcge_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcge_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcge_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcge_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vcge_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vcge_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcgtq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcgtq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcgtq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcgtq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcgtq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcgtq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcgtq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcgtq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcgtq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcgt_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcgt_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vcgt_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vcgt_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcgt_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcgt_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcgt_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vcgt_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vcgt_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcleq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcleq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcleq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcleq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcleq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcleq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcleq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcleq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcleq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcle_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcle_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcle_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcle_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vcle_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vcle_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcle_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcle_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcle_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcle_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcle_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcle_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vcle_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vcle_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vclsq_u8(uint8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vclsq_u8(uint8x16_t __p0) {
+  int8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vclsq_u32(uint32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vclsq_u32(uint32x4_t __p0) {
+  int32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vclsq_u16(uint16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vclsq_u16(uint16x8_t __p0) {
+  int16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vclsq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vclsq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vclsq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vclsq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vclsq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vclsq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vclsq_v((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vcls_u8(uint8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vcls_u8(uint8x8_t __p0) {
+  int8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vcls_u32(uint32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vcls_u32(uint32x2_t __p0) {
+  int32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vcls_u16(uint16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vcls_u16(uint16x4_t __p0) {
+  int16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vcls_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vcls_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vcls_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vcls_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vcls_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vcls_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vcls_v((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcltq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcltq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcltq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcltq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcltq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcltq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_f32(float32x4_t __p0, float32x4_t __p1) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcltq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcltq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcltq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vclt_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vclt_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vclt_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vclt_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vclt_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vclt_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vclt_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vclt_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vclt_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vclt_f32(float32x2_t __p0, float32x2_t __p1) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vclt_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vclt_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vclt_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vclt_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vclzq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vclzq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vclzq_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vclzq_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vclzq_u16(uint16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vclzq_u16(uint16x8_t __p0) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vclzq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vclzq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vclzq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vclzq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vclzq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vclzq_v((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vclzq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vclzq_v((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vclz_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vclz_v((int8x8_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vclz_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vclz_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vclz_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vclz_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vclz_u16(uint16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vclz_v((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vclz_u16(uint16x4_t __p0) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vclz_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vclz_v((int8x8_t)__p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vclz_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vclz_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vclz_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vclz_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vclz_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vclz_v((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vclz_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vclz_v((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vcnt_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vcnt_v((int8x8_t)__p0, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vcnt_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vcnt_v((int8x8_t)__rev0, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vcntq_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vcntq_v((int8x16_t)__p0, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vcntq_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vcntq_v((int8x16_t)__rev0, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcntq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vcntq_v((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcntq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vcntq_v((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vcntq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vcntq_v((int8x16_t)__p0, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vcntq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vcntq_v((int8x16_t)__rev0, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcnt_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vcnt_v((int8x8_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcnt_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vcnt_v((int8x8_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vcnt_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vcnt_v((int8x8_t)__p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vcnt_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vcnt_v((int8x8_t)__rev0, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vcombine_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vcombine_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x16_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vcombine_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vcombine_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x8_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcombine_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcombine_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x16_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t __noswap_vcombine_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcombine_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcombine_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x4_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vcombine_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcombine_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcombine_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcombine_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcombine_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x8_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vcombine_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vcombine_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vcombine_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x16_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t __noswap_vcombine_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vcombine_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcombine_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x4_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t __noswap_vcombine_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vcombine_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vcombine_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x8_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t __noswap_vcombine_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vcombine_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vcombine_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x4_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vcombine_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vcombine_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vcombine_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vcombine_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vcombine_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x8_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 1, 2, 3, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vcombine_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#endif
+
+#define vcreate_p8(__p0) __extension__ ({ \
+  poly8x8_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (poly8x8_t)(__promote); \
+  __ret; \
+})
+#define vcreate_p16(__p0) __extension__ ({ \
+  poly16x4_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (poly16x4_t)(__promote); \
+  __ret; \
+})
+#define vcreate_u8(__p0) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (uint8x8_t)(__promote); \
+  __ret; \
+})
+#define vcreate_u32(__p0) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (uint32x2_t)(__promote); \
+  __ret; \
+})
+#define vcreate_u64(__p0) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (uint64x1_t)(__promote); \
+  __ret; \
+})
+#define vcreate_u16(__p0) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (uint16x4_t)(__promote); \
+  __ret; \
+})
+#define vcreate_s8(__p0) __extension__ ({ \
+  int8x8_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (int8x8_t)(__promote); \
+  __ret; \
+})
+#define vcreate_f32(__p0) __extension__ ({ \
+  float32x2_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (float32x2_t)(__promote); \
+  __ret; \
+})
+#define vcreate_f16(__p0) __extension__ ({ \
+  float16x4_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (float16x4_t)(__promote); \
+  __ret; \
+})
+#define vcreate_s32(__p0) __extension__ ({ \
+  int32x2_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (int32x2_t)(__promote); \
+  __ret; \
+})
+#define vcreate_s64(__p0) __extension__ ({ \
+  int64x1_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (int64x1_t)(__promote); \
+  __ret; \
+})
+#define vcreate_s16(__p0) __extension__ ({ \
+  int16x4_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (int16x4_t)(__promote); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vcvtq_f32_u32(uint32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcvtq_f32_u32(uint32x4_t __p0) {
+  float32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vcvtq_f32_s32(int32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcvtq_f32_s32(int32x4_t __p0) {
+  float32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vcvtq_f32_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_u32(uint32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_u32(uint32x2_t __p0) {
+  float32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_s32(int32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_s32(int32x2_t __p0) {
+  float32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vcvt_f32_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_f32_u32(__p0, __p1) __extension__ ({ \
+  float32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#else
+#define vcvtq_n_f32_u32(__p0, __p1) __extension__ ({ \
+  float32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__rev0, __p1, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_f32_s32(__p0, __p1) __extension__ ({ \
+  float32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__s0, __p1, 34); \
+  __ret; \
+})
+#else
+#define vcvtq_n_f32_s32(__p0, __p1) __extension__ ({ \
+  float32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float32x4_t) __builtin_neon_vcvtq_n_f32_v((int8x16_t)__rev0, __p1, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvt_n_f32_u32(__p0, __p1) __extension__ ({ \
+  float32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vcvt_n_f32_u32(__p0, __p1) __extension__ ({ \
+  float32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvt_n_f32_s32(__p0, __p1) __extension__ ({ \
+  float32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define vcvt_n_f32_s32(__p0, __p1) __extension__ ({ \
+  float32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float32x2_t) __builtin_neon_vcvt_n_f32_v((int8x8_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_s32_f32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_vcvtq_n_s32_v((int8x16_t)__s0, __p1, 34); \
+  __ret; \
+})
+#else
+#define vcvtq_n_s32_f32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vcvtq_n_s32_v((int8x16_t)__rev0, __p1, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvt_n_s32_f32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vcvt_n_s32_v((int8x8_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define vcvt_n_s32_f32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vcvt_n_s32_v((int8x8_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_u32_f32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_vcvtq_n_u32_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#else
+#define vcvtq_n_u32_f32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vcvtq_n_u32_v((int8x16_t)__rev0, __p1, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvt_n_u32_f32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vcvt_n_u32_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vcvt_n_u32_f32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vcvt_n_u32_v((int8x8_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vcvtq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vcvtq_s32_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vcvtq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vcvtq_s32_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vcvt_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vcvt_s32_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vcvt_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vcvt_s32_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcvtq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcvtq_u32_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcvtq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcvtq_u32_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcvt_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcvt_u32_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcvt_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcvt_u32_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_p8(__p0_8, __p1_8) __extension__ ({ \
+  poly8x8_t __ret_8; \
+  poly8x8_t __s0_8 = __p0_8; \
+  __ret_8 = splat_lane_p8(__s0_8, __p1_8); \
+  __ret_8; \
+})
+#else
+#define vdup_lane_p8(__p0_9, __p1_9) __extension__ ({ \
+  poly8x8_t __ret_9; \
+  poly8x8_t __s0_9 = __p0_9; \
+  poly8x8_t __rev0_9;  __rev0_9 = __builtin_shufflevector(__s0_9, __s0_9, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_9 = __noswap_splat_lane_p8(__rev0_9, __p1_9); \
+  __ret_9 = __builtin_shufflevector(__ret_9, __ret_9, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_9; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_p16(__p0_10, __p1_10) __extension__ ({ \
+  poly16x4_t __ret_10; \
+  poly16x4_t __s0_10 = __p0_10; \
+  __ret_10 = splat_lane_p16(__s0_10, __p1_10); \
+  __ret_10; \
+})
+#else
+#define vdup_lane_p16(__p0_11, __p1_11) __extension__ ({ \
+  poly16x4_t __ret_11; \
+  poly16x4_t __s0_11 = __p0_11; \
+  poly16x4_t __rev0_11;  __rev0_11 = __builtin_shufflevector(__s0_11, __s0_11, 3, 2, 1, 0); \
+  __ret_11 = __noswap_splat_lane_p16(__rev0_11, __p1_11); \
+  __ret_11 = __builtin_shufflevector(__ret_11, __ret_11, 3, 2, 1, 0); \
+  __ret_11; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_p8(__p0_12, __p1_12) __extension__ ({ \
+  poly8x16_t __ret_12; \
+  poly8x8_t __s0_12 = __p0_12; \
+  __ret_12 = splatq_lane_p8(__s0_12, __p1_12); \
+  __ret_12; \
+})
+#else
+#define vdupq_lane_p8(__p0_13, __p1_13) __extension__ ({ \
+  poly8x16_t __ret_13; \
+  poly8x8_t __s0_13 = __p0_13; \
+  poly8x8_t __rev0_13;  __rev0_13 = __builtin_shufflevector(__s0_13, __s0_13, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_13 = __noswap_splatq_lane_p8(__rev0_13, __p1_13); \
+  __ret_13 = __builtin_shufflevector(__ret_13, __ret_13, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_13; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_p16(__p0_14, __p1_14) __extension__ ({ \
+  poly16x8_t __ret_14; \
+  poly16x4_t __s0_14 = __p0_14; \
+  __ret_14 = splatq_lane_p16(__s0_14, __p1_14); \
+  __ret_14; \
+})
+#else
+#define vdupq_lane_p16(__p0_15, __p1_15) __extension__ ({ \
+  poly16x8_t __ret_15; \
+  poly16x4_t __s0_15 = __p0_15; \
+  poly16x4_t __rev0_15;  __rev0_15 = __builtin_shufflevector(__s0_15, __s0_15, 3, 2, 1, 0); \
+  __ret_15 = __noswap_splatq_lane_p16(__rev0_15, __p1_15); \
+  __ret_15 = __builtin_shufflevector(__ret_15, __ret_15, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_15; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_u8(__p0_16, __p1_16) __extension__ ({ \
+  uint8x16_t __ret_16; \
+  uint8x8_t __s0_16 = __p0_16; \
+  __ret_16 = splatq_lane_u8(__s0_16, __p1_16); \
+  __ret_16; \
+})
+#else
+#define vdupq_lane_u8(__p0_17, __p1_17) __extension__ ({ \
+  uint8x16_t __ret_17; \
+  uint8x8_t __s0_17 = __p0_17; \
+  uint8x8_t __rev0_17;  __rev0_17 = __builtin_shufflevector(__s0_17, __s0_17, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_17 = __noswap_splatq_lane_u8(__rev0_17, __p1_17); \
+  __ret_17 = __builtin_shufflevector(__ret_17, __ret_17, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_17; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_u32(__p0_18, __p1_18) __extension__ ({ \
+  uint32x4_t __ret_18; \
+  uint32x2_t __s0_18 = __p0_18; \
+  __ret_18 = splatq_lane_u32(__s0_18, __p1_18); \
+  __ret_18; \
+})
+#else
+#define vdupq_lane_u32(__p0_19, __p1_19) __extension__ ({ \
+  uint32x4_t __ret_19; \
+  uint32x2_t __s0_19 = __p0_19; \
+  uint32x2_t __rev0_19;  __rev0_19 = __builtin_shufflevector(__s0_19, __s0_19, 1, 0); \
+  __ret_19 = __noswap_splatq_lane_u32(__rev0_19, __p1_19); \
+  __ret_19 = __builtin_shufflevector(__ret_19, __ret_19, 3, 2, 1, 0); \
+  __ret_19; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_u64(__p0_20, __p1_20) __extension__ ({ \
+  uint64x2_t __ret_20; \
+  uint64x1_t __s0_20 = __p0_20; \
+  __ret_20 = splatq_lane_u64(__s0_20, __p1_20); \
+  __ret_20; \
+})
+#else
+#define vdupq_lane_u64(__p0_21, __p1_21) __extension__ ({ \
+  uint64x2_t __ret_21; \
+  uint64x1_t __s0_21 = __p0_21; \
+  __ret_21 = __noswap_splatq_lane_u64(__s0_21, __p1_21); \
+  __ret_21 = __builtin_shufflevector(__ret_21, __ret_21, 1, 0); \
+  __ret_21; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_u16(__p0_22, __p1_22) __extension__ ({ \
+  uint16x8_t __ret_22; \
+  uint16x4_t __s0_22 = __p0_22; \
+  __ret_22 = splatq_lane_u16(__s0_22, __p1_22); \
+  __ret_22; \
+})
+#else
+#define vdupq_lane_u16(__p0_23, __p1_23) __extension__ ({ \
+  uint16x8_t __ret_23; \
+  uint16x4_t __s0_23 = __p0_23; \
+  uint16x4_t __rev0_23;  __rev0_23 = __builtin_shufflevector(__s0_23, __s0_23, 3, 2, 1, 0); \
+  __ret_23 = __noswap_splatq_lane_u16(__rev0_23, __p1_23); \
+  __ret_23 = __builtin_shufflevector(__ret_23, __ret_23, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_23; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_s8(__p0_24, __p1_24) __extension__ ({ \
+  int8x16_t __ret_24; \
+  int8x8_t __s0_24 = __p0_24; \
+  __ret_24 = splatq_lane_s8(__s0_24, __p1_24); \
+  __ret_24; \
+})
+#else
+#define vdupq_lane_s8(__p0_25, __p1_25) __extension__ ({ \
+  int8x16_t __ret_25; \
+  int8x8_t __s0_25 = __p0_25; \
+  int8x8_t __rev0_25;  __rev0_25 = __builtin_shufflevector(__s0_25, __s0_25, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_25 = __noswap_splatq_lane_s8(__rev0_25, __p1_25); \
+  __ret_25 = __builtin_shufflevector(__ret_25, __ret_25, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_25; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_f32(__p0_26, __p1_26) __extension__ ({ \
+  float32x4_t __ret_26; \
+  float32x2_t __s0_26 = __p0_26; \
+  __ret_26 = splatq_lane_f32(__s0_26, __p1_26); \
+  __ret_26; \
+})
+#else
+#define vdupq_lane_f32(__p0_27, __p1_27) __extension__ ({ \
+  float32x4_t __ret_27; \
+  float32x2_t __s0_27 = __p0_27; \
+  float32x2_t __rev0_27;  __rev0_27 = __builtin_shufflevector(__s0_27, __s0_27, 1, 0); \
+  __ret_27 = __noswap_splatq_lane_f32(__rev0_27, __p1_27); \
+  __ret_27 = __builtin_shufflevector(__ret_27, __ret_27, 3, 2, 1, 0); \
+  __ret_27; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_f16(__p0_28, __p1_28) __extension__ ({ \
+  float16x8_t __ret_28; \
+  float16x4_t __s0_28 = __p0_28; \
+  __ret_28 = splatq_lane_f16(__s0_28, __p1_28); \
+  __ret_28; \
+})
+#else
+#define vdupq_lane_f16(__p0_29, __p1_29) __extension__ ({ \
+  float16x8_t __ret_29; \
+  float16x4_t __s0_29 = __p0_29; \
+  float16x4_t __rev0_29;  __rev0_29 = __builtin_shufflevector(__s0_29, __s0_29, 3, 2, 1, 0); \
+  __ret_29 = __noswap_splatq_lane_f16(__rev0_29, __p1_29); \
+  __ret_29 = __builtin_shufflevector(__ret_29, __ret_29, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_29; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_s32(__p0_30, __p1_30) __extension__ ({ \
+  int32x4_t __ret_30; \
+  int32x2_t __s0_30 = __p0_30; \
+  __ret_30 = splatq_lane_s32(__s0_30, __p1_30); \
+  __ret_30; \
+})
+#else
+#define vdupq_lane_s32(__p0_31, __p1_31) __extension__ ({ \
+  int32x4_t __ret_31; \
+  int32x2_t __s0_31 = __p0_31; \
+  int32x2_t __rev0_31;  __rev0_31 = __builtin_shufflevector(__s0_31, __s0_31, 1, 0); \
+  __ret_31 = __noswap_splatq_lane_s32(__rev0_31, __p1_31); \
+  __ret_31 = __builtin_shufflevector(__ret_31, __ret_31, 3, 2, 1, 0); \
+  __ret_31; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_s64(__p0_32, __p1_32) __extension__ ({ \
+  int64x2_t __ret_32; \
+  int64x1_t __s0_32 = __p0_32; \
+  __ret_32 = splatq_lane_s64(__s0_32, __p1_32); \
+  __ret_32; \
+})
+#else
+#define vdupq_lane_s64(__p0_33, __p1_33) __extension__ ({ \
+  int64x2_t __ret_33; \
+  int64x1_t __s0_33 = __p0_33; \
+  __ret_33 = __noswap_splatq_lane_s64(__s0_33, __p1_33); \
+  __ret_33 = __builtin_shufflevector(__ret_33, __ret_33, 1, 0); \
+  __ret_33; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_s16(__p0_34, __p1_34) __extension__ ({ \
+  int16x8_t __ret_34; \
+  int16x4_t __s0_34 = __p0_34; \
+  __ret_34 = splatq_lane_s16(__s0_34, __p1_34); \
+  __ret_34; \
+})
+#else
+#define vdupq_lane_s16(__p0_35, __p1_35) __extension__ ({ \
+  int16x8_t __ret_35; \
+  int16x4_t __s0_35 = __p0_35; \
+  int16x4_t __rev0_35;  __rev0_35 = __builtin_shufflevector(__s0_35, __s0_35, 3, 2, 1, 0); \
+  __ret_35 = __noswap_splatq_lane_s16(__rev0_35, __p1_35); \
+  __ret_35 = __builtin_shufflevector(__ret_35, __ret_35, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_35; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_u8(__p0_36, __p1_36) __extension__ ({ \
+  uint8x8_t __ret_36; \
+  uint8x8_t __s0_36 = __p0_36; \
+  __ret_36 = splat_lane_u8(__s0_36, __p1_36); \
+  __ret_36; \
+})
+#else
+#define vdup_lane_u8(__p0_37, __p1_37) __extension__ ({ \
+  uint8x8_t __ret_37; \
+  uint8x8_t __s0_37 = __p0_37; \
+  uint8x8_t __rev0_37;  __rev0_37 = __builtin_shufflevector(__s0_37, __s0_37, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_37 = __noswap_splat_lane_u8(__rev0_37, __p1_37); \
+  __ret_37 = __builtin_shufflevector(__ret_37, __ret_37, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_37; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_u32(__p0_38, __p1_38) __extension__ ({ \
+  uint32x2_t __ret_38; \
+  uint32x2_t __s0_38 = __p0_38; \
+  __ret_38 = splat_lane_u32(__s0_38, __p1_38); \
+  __ret_38; \
+})
+#else
+#define vdup_lane_u32(__p0_39, __p1_39) __extension__ ({ \
+  uint32x2_t __ret_39; \
+  uint32x2_t __s0_39 = __p0_39; \
+  uint32x2_t __rev0_39;  __rev0_39 = __builtin_shufflevector(__s0_39, __s0_39, 1, 0); \
+  __ret_39 = __noswap_splat_lane_u32(__rev0_39, __p1_39); \
+  __ret_39 = __builtin_shufflevector(__ret_39, __ret_39, 1, 0); \
+  __ret_39; \
+})
+#endif
+
+#define vdup_lane_u64(__p0_40, __p1_40) __extension__ ({ \
+  uint64x1_t __ret_40; \
+  uint64x1_t __s0_40 = __p0_40; \
+  __ret_40 = splat_lane_u64(__s0_40, __p1_40); \
+  __ret_40; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_u16(__p0_41, __p1_41) __extension__ ({ \
+  uint16x4_t __ret_41; \
+  uint16x4_t __s0_41 = __p0_41; \
+  __ret_41 = splat_lane_u16(__s0_41, __p1_41); \
+  __ret_41; \
+})
+#else
+#define vdup_lane_u16(__p0_42, __p1_42) __extension__ ({ \
+  uint16x4_t __ret_42; \
+  uint16x4_t __s0_42 = __p0_42; \
+  uint16x4_t __rev0_42;  __rev0_42 = __builtin_shufflevector(__s0_42, __s0_42, 3, 2, 1, 0); \
+  __ret_42 = __noswap_splat_lane_u16(__rev0_42, __p1_42); \
+  __ret_42 = __builtin_shufflevector(__ret_42, __ret_42, 3, 2, 1, 0); \
+  __ret_42; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_s8(__p0_43, __p1_43) __extension__ ({ \
+  int8x8_t __ret_43; \
+  int8x8_t __s0_43 = __p0_43; \
+  __ret_43 = splat_lane_s8(__s0_43, __p1_43); \
+  __ret_43; \
+})
+#else
+#define vdup_lane_s8(__p0_44, __p1_44) __extension__ ({ \
+  int8x8_t __ret_44; \
+  int8x8_t __s0_44 = __p0_44; \
+  int8x8_t __rev0_44;  __rev0_44 = __builtin_shufflevector(__s0_44, __s0_44, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_44 = __noswap_splat_lane_s8(__rev0_44, __p1_44); \
+  __ret_44 = __builtin_shufflevector(__ret_44, __ret_44, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_44; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_f32(__p0_45, __p1_45) __extension__ ({ \
+  float32x2_t __ret_45; \
+  float32x2_t __s0_45 = __p0_45; \
+  __ret_45 = splat_lane_f32(__s0_45, __p1_45); \
+  __ret_45; \
+})
+#else
+#define vdup_lane_f32(__p0_46, __p1_46) __extension__ ({ \
+  float32x2_t __ret_46; \
+  float32x2_t __s0_46 = __p0_46; \
+  float32x2_t __rev0_46;  __rev0_46 = __builtin_shufflevector(__s0_46, __s0_46, 1, 0); \
+  __ret_46 = __noswap_splat_lane_f32(__rev0_46, __p1_46); \
+  __ret_46 = __builtin_shufflevector(__ret_46, __ret_46, 1, 0); \
+  __ret_46; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_f16(__p0_47, __p1_47) __extension__ ({ \
+  float16x4_t __ret_47; \
+  float16x4_t __s0_47 = __p0_47; \
+  __ret_47 = splat_lane_f16(__s0_47, __p1_47); \
+  __ret_47; \
+})
+#else
+#define vdup_lane_f16(__p0_48, __p1_48) __extension__ ({ \
+  float16x4_t __ret_48; \
+  float16x4_t __s0_48 = __p0_48; \
+  float16x4_t __rev0_48;  __rev0_48 = __builtin_shufflevector(__s0_48, __s0_48, 3, 2, 1, 0); \
+  __ret_48 = __noswap_splat_lane_f16(__rev0_48, __p1_48); \
+  __ret_48 = __builtin_shufflevector(__ret_48, __ret_48, 3, 2, 1, 0); \
+  __ret_48; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_s32(__p0_49, __p1_49) __extension__ ({ \
+  int32x2_t __ret_49; \
+  int32x2_t __s0_49 = __p0_49; \
+  __ret_49 = splat_lane_s32(__s0_49, __p1_49); \
+  __ret_49; \
+})
+#else
+#define vdup_lane_s32(__p0_50, __p1_50) __extension__ ({ \
+  int32x2_t __ret_50; \
+  int32x2_t __s0_50 = __p0_50; \
+  int32x2_t __rev0_50;  __rev0_50 = __builtin_shufflevector(__s0_50, __s0_50, 1, 0); \
+  __ret_50 = __noswap_splat_lane_s32(__rev0_50, __p1_50); \
+  __ret_50 = __builtin_shufflevector(__ret_50, __ret_50, 1, 0); \
+  __ret_50; \
+})
+#endif
+
+#define vdup_lane_s64(__p0_51, __p1_51) __extension__ ({ \
+  int64x1_t __ret_51; \
+  int64x1_t __s0_51 = __p0_51; \
+  __ret_51 = splat_lane_s64(__s0_51, __p1_51); \
+  __ret_51; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vdup_lane_s16(__p0_52, __p1_52) __extension__ ({ \
+  int16x4_t __ret_52; \
+  int16x4_t __s0_52 = __p0_52; \
+  __ret_52 = splat_lane_s16(__s0_52, __p1_52); \
+  __ret_52; \
+})
+#else
+#define vdup_lane_s16(__p0_53, __p1_53) __extension__ ({ \
+  int16x4_t __ret_53; \
+  int16x4_t __s0_53 = __p0_53; \
+  int16x4_t __rev0_53;  __rev0_53 = __builtin_shufflevector(__s0_53, __s0_53, 3, 2, 1, 0); \
+  __ret_53 = __noswap_splat_lane_s16(__rev0_53, __p1_53); \
+  __ret_53 = __builtin_shufflevector(__ret_53, __ret_53, 3, 2, 1, 0); \
+  __ret_53; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vdup_n_p8(poly8_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vdup_n_p8(poly8_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vdup_n_p16(poly16_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vdup_n_p16(poly16_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vdupq_n_p8(poly8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vdupq_n_p8(poly8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vdupq_n_p16(poly16_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vdupq_n_p16(poly16_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vdupq_n_u8(uint8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vdupq_n_u8(uint8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vdupq_n_u32(uint32_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vdupq_n_u32(uint32_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vdupq_n_u64(uint64_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vdupq_n_u64(uint64_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vdupq_n_u16(uint16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vdupq_n_u16(uint16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vdupq_n_s8(int8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vdupq_n_s8(int8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vdupq_n_f32(float32_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vdupq_n_f32(float32_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_n_f16(__p0) __extension__ ({ \
+  float16x8_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
+  __ret; \
+})
+#else
+#define vdupq_n_f16(__p0) __extension__ ({ \
+  float16x8_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vdupq_n_s32(int32_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vdupq_n_s32(int32_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vdupq_n_s64(int64_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vdupq_n_s64(int64_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vdupq_n_s16(int16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vdupq_n_s16(int16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vdup_n_u8(uint8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vdup_n_u8(uint8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vdup_n_u32(uint32_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vdup_n_u32(uint32_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vdup_n_u64(uint64_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) {__p0};
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vdup_n_u16(uint16_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vdup_n_u16(uint16_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vdup_n_s8(int8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vdup_n_s8(int8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vdup_n_f32(float32_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vdup_n_f32(float32_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_n_f16(__p0) __extension__ ({ \
+  float16x4_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
+  __ret; \
+})
+#else
+#define vdup_n_f16(__p0) __extension__ ({ \
+  float16x4_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vdup_n_s32(int32_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vdup_n_s32(int32_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vdup_n_s64(int64_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) {__p0};
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vdup_n_s16(int16_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vdup_n_s16(int16_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t veorq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t veorq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t veorq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t veorq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t veorq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t veorq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t veorq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t veorq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t veorq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t veorq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t veorq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t veorq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t veorq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t veorq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t veorq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t veorq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t veor_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t veor_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t veor_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t veor_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t veor_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t veor_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t veor_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t veor_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t veor_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t veor_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t veor_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t veor_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t veor_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __p0 ^ __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t veor_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 ^ __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vext_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  poly8x8_t __s1 = __p1; \
+  __ret = (poly8x8_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 4); \
+  __ret; \
+})
+#else
+#define vext_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  poly8x8_t __s1 = __p1; \
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x8_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 4); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vext_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  poly16x4_t __s1 = __p1; \
+  __ret = (poly16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 5); \
+  __ret; \
+})
+#else
+#define vext_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  poly16x4_t __s1 = __p1; \
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (poly16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 5); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  poly8x16_t __s1 = __p1; \
+  __ret = (poly8x16_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 36); \
+  __ret; \
+})
+#else
+#define vextq_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  poly8x16_t __s1 = __p1; \
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x16_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 36); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  poly16x8_t __s1 = __p1; \
+  __ret = (poly16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 37); \
+  __ret; \
+})
+#else
+#define vextq_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  poly16x8_t __s1 = __p1; \
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 37); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  __ret = (uint8x16_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
+  __ret; \
+})
+#else
+#define vextq_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  __ret = (uint32x4_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
+  __ret; \
+})
+#else
+#define vextq_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  __ret = (uint64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+  __ret; \
+})
+#else
+#define vextq_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  __ret = (uint16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
+  __ret; \
+})
+#else
+#define vextq_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  __ret = (int8x16_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
+  __ret; \
+})
+#else
+#define vextq_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  __ret = (float32x4_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 41); \
+  __ret; \
+})
+#else
+#define vextq_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (float32x4_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 41); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+  __ret; \
+})
+#else
+#define vextq_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  __ret = (int64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
+  __ret; \
+})
+#else
+#define vextq_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+  __ret; \
+})
+#else
+#define vextq_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vext_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  __ret = (uint8x8_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
+  __ret; \
+})
+#else
+#define vext_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vext_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  __ret = (uint32x2_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
+  __ret; \
+})
+#else
+#define vext_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vext_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  uint64x1_t __s1 = __p1; \
+  __ret = (uint64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vext_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  __ret = (uint16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
+  __ret; \
+})
+#else
+#define vext_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vext_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  __ret = (int8x8_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
+  __ret; \
+})
+#else
+#define vext_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vext_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  __ret = (float32x2_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 9); \
+  __ret; \
+})
+#else
+#define vext_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (float32x2_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 9); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vext_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vext_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vext_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  int64x1_t __s1 = __p1; \
+  __ret = (int64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vext_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vext_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  __ret = (float16x8_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 40); \
+  __ret; \
+})
+#else
+#define vextq_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16x8_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 40); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vext_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  __ret = (float16x4_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 8); \
+  __ret; \
+})
+#else
+#define vext_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (float16x4_t) __builtin_neon_vext_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 8); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vget_high_p8(poly8x16_t __p0) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vget_high_p8(poly8x16_t __p0) {
+  poly8x8_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 8, 9, 10, 11, 12, 13, 14, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t __noswap_vget_high_p8(poly8x16_t __p0) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vget_high_p16(poly16x8_t __p0) {
+  poly16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vget_high_p16(poly16x8_t __p0) {
+  poly16x4_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vget_high_u8(uint8x16_t __p0) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vget_high_u8(uint8x16_t __p0) {
+  uint8x8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 8, 9, 10, 11, 12, 13, 14, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vget_high_u8(uint8x16_t __p0) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vget_high_u32(uint32x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vget_high_u32(uint32x4_t __p0) {
+  uint32x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vget_high_u32(uint32x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x1_t vget_high_u64(uint64x2_t __p0) {
+  uint64x1_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x1_t vget_high_u64(uint64x2_t __p0) {
+  uint64x1_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vget_high_u16(uint16x8_t __p0) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vget_high_u16(uint16x8_t __p0) {
+  uint16x4_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vget_high_u16(uint16x8_t __p0) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vget_high_s8(int8x16_t __p0) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vget_high_s8(int8x16_t __p0) {
+  int8x8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 8, 9, 10, 11, 12, 13, 14, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vget_high_s8(int8x16_t __p0) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 8, 9, 10, 11, 12, 13, 14, 15);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vget_high_f32(float32x4_t __p0) {
+  float32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vget_high_f32(float32x4_t __p0) {
+  float32x2_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t __noswap_vget_high_f32(float32x4_t __p0) {
+  float32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vget_high_f16(float16x8_t __p0) {
+  float16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vget_high_f16(float16x8_t __p0) {
+  float16x4_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t __noswap_vget_high_f16(float16x8_t __p0) {
+  float16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vget_high_s32(int32x4_t __p0) {
+  int32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vget_high_s32(int32x4_t __p0) {
+  int32x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vget_high_s32(int32x4_t __p0) {
+  int32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 2, 3);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x1_t vget_high_s64(int64x2_t __p0) {
+  int64x1_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x1_t vget_high_s64(int64x2_t __p0) {
+  int64x1_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vget_high_s16(int16x8_t __p0) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vget_high_s16(int16x8_t __p0) {
+  int16x4_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vget_high_s16(int16x8_t __p0) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 4, 5, 6, 7);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  __ret = (poly8_t) __builtin_neon_vget_lane_i8((poly8x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vget_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8_t) __builtin_neon_vget_lane_i8((poly8x8_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vget_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  __ret = (poly8_t) __builtin_neon_vget_lane_i8((poly8x8_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  __ret = (poly16_t) __builtin_neon_vget_lane_i16((poly16x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vget_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (poly16_t) __builtin_neon_vget_lane_i16((poly16x4_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vget_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  __ret = (poly16_t) __builtin_neon_vget_lane_i16((poly16x4_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  __ret = (poly8_t) __builtin_neon_vgetq_lane_i8((poly8x16_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8_t) __builtin_neon_vgetq_lane_i8((poly8x16_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  __ret = (poly8_t) __builtin_neon_vgetq_lane_i8((poly8x16_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  __ret = (poly16_t) __builtin_neon_vgetq_lane_i16((poly16x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly16_t) __builtin_neon_vgetq_lane_i16((poly16x8_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  __ret = (poly16_t) __builtin_neon_vgetq_lane_i16((poly16x8_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8_t) __builtin_neon_vgetq_lane_i8((int8x16_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_f32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  float32x4_t __s0 = __p0; \
+  __ret = (float32_t) __builtin_neon_vgetq_lane_f32((float32x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_f32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float32_t) __builtin_neon_vgetq_lane_f32((float32x4_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_f32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  float32x4_t __s0 = __p0; \
+  __ret = (float32_t) __builtin_neon_vgetq_lane_f32((float32x4_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vgetq_lane_i32((int32x4_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vgetq_lane_i64((int64x2_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vgetq_lane_i16((int16x8_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vget_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8_t) __builtin_neon_vget_lane_i8((int8x8_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vget_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vget_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32_t) __builtin_neon_vget_lane_i32((int32x2_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vget_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#define vget_lane_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vget_lane_i64((int64x1_t)__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vget_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16_t) __builtin_neon_vget_lane_i16((int16x4_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vget_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vget_lane_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8_t) __builtin_neon_vget_lane_i8((int8x8_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vget_lane_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8_t) __builtin_neon_vget_lane_i8((int8x8_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_f32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  float32x2_t __s0 = __p0; \
+  __ret = (float32_t) __builtin_neon_vget_lane_f32((float32x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vget_lane_f32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float32_t) __builtin_neon_vget_lane_f32((float32x2_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vget_lane_f32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  float32x2_t __s0 = __p0; \
+  __ret = (float32_t) __builtin_neon_vget_lane_f32((float32x2_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vget_lane_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32_t) __builtin_neon_vget_lane_i32((int32x2_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vget_lane_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vget_lane_i32((int32x2_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#define vget_lane_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vget_lane_i64((int64x1_t)__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vget_lane_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16_t) __builtin_neon_vget_lane_i16((int16x4_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vget_lane_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vget_lane_i16((int16x4_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vget_low_p8(poly8x16_t __p0) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vget_low_p8(poly8x16_t __p0) {
+  poly8x8_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vget_low_p16(poly16x8_t __p0) {
+  poly16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vget_low_p16(poly16x8_t __p0) {
+  poly16x4_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vget_low_u8(uint8x16_t __p0) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vget_low_u8(uint8x16_t __p0) {
+  uint8x8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vget_low_u32(uint32x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vget_low_u32(uint32x4_t __p0) {
+  uint32x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x1_t vget_low_u64(uint64x2_t __p0) {
+  uint64x1_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x1_t vget_low_u64(uint64x2_t __p0) {
+  uint64x1_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vget_low_u16(uint16x8_t __p0) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vget_low_u16(uint16x8_t __p0) {
+  uint16x4_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vget_low_s8(int8x16_t __p0) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3, 4, 5, 6, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vget_low_s8(int8x16_t __p0) {
+  int8x8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3, 4, 5, 6, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vget_low_f32(float32x4_t __p0) {
+  float32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vget_low_f32(float32x4_t __p0) {
+  float32x2_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vget_low_f16(float16x8_t __p0) {
+  float16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vget_low_f16(float16x8_t __p0) {
+  float16x4_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vget_low_s32(int32x4_t __p0) {
+  int32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vget_low_s32(int32x4_t __p0) {
+  int32x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x1_t vget_low_s64(int64x2_t __p0) {
+  int64x1_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x1_t vget_low_s64(int64x2_t __p0) {
+  int64x1_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vget_low_s16(int16x8_t __p0) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0, 1, 2, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vget_low_s16(int16x8_t __p0) {
+  int16x4_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0, 1, 2, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vhadd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vhadd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vhadd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vhadd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vhadd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vhadd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vhsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vhsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vhsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vhsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vhsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vhsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vhsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vhsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vhsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vhsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vhsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vhsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vhsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vhsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vhsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vhsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vhsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vhsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vhsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vhsub_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vhsub_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vhsub_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vhsub_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vhsub_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vhsub_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vhsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_p8(__p0) __extension__ ({ \
+  poly8x8_t __ret; \
+  __ret = (poly8x8_t) __builtin_neon_vld1_v(__p0, 4); \
+  __ret; \
+})
+#else
+#define vld1_p8(__p0) __extension__ ({ \
+  poly8x8_t __ret; \
+  __ret = (poly8x8_t) __builtin_neon_vld1_v(__p0, 4); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_p16(__p0) __extension__ ({ \
+  poly16x4_t __ret; \
+  __ret = (poly16x4_t) __builtin_neon_vld1_v(__p0, 5); \
+  __ret; \
+})
+#else
+#define vld1_p16(__p0) __extension__ ({ \
+  poly16x4_t __ret; \
+  __ret = (poly16x4_t) __builtin_neon_vld1_v(__p0, 5); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p8(__p0) __extension__ ({ \
+  poly8x16_t __ret; \
+  __ret = (poly8x16_t) __builtin_neon_vld1q_v(__p0, 36); \
+  __ret; \
+})
+#else
+#define vld1q_p8(__p0) __extension__ ({ \
+  poly8x16_t __ret; \
+  __ret = (poly8x16_t) __builtin_neon_vld1q_v(__p0, 36); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p16(__p0) __extension__ ({ \
+  poly16x8_t __ret; \
+  __ret = (poly16x8_t) __builtin_neon_vld1q_v(__p0, 37); \
+  __ret; \
+})
+#else
+#define vld1q_p16(__p0) __extension__ ({ \
+  poly16x8_t __ret; \
+  __ret = (poly16x8_t) __builtin_neon_vld1q_v(__p0, 37); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u8(__p0) __extension__ ({ \
+  uint8x16_t __ret; \
+  __ret = (uint8x16_t) __builtin_neon_vld1q_v(__p0, 48); \
+  __ret; \
+})
+#else
+#define vld1q_u8(__p0) __extension__ ({ \
+  uint8x16_t __ret; \
+  __ret = (uint8x16_t) __builtin_neon_vld1q_v(__p0, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u32(__p0) __extension__ ({ \
+  uint32x4_t __ret; \
+  __ret = (uint32x4_t) __builtin_neon_vld1q_v(__p0, 50); \
+  __ret; \
+})
+#else
+#define vld1q_u32(__p0) __extension__ ({ \
+  uint32x4_t __ret; \
+  __ret = (uint32x4_t) __builtin_neon_vld1q_v(__p0, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u64(__p0) __extension__ ({ \
+  uint64x2_t __ret; \
+  __ret = (uint64x2_t) __builtin_neon_vld1q_v(__p0, 51); \
+  __ret; \
+})
+#else
+#define vld1q_u64(__p0) __extension__ ({ \
+  uint64x2_t __ret; \
+  __ret = (uint64x2_t) __builtin_neon_vld1q_v(__p0, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u16(__p0) __extension__ ({ \
+  uint16x8_t __ret; \
+  __ret = (uint16x8_t) __builtin_neon_vld1q_v(__p0, 49); \
+  __ret; \
+})
+#else
+#define vld1q_u16(__p0) __extension__ ({ \
+  uint16x8_t __ret; \
+  __ret = (uint16x8_t) __builtin_neon_vld1q_v(__p0, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s8(__p0) __extension__ ({ \
+  int8x16_t __ret; \
+  __ret = (int8x16_t) __builtin_neon_vld1q_v(__p0, 32); \
+  __ret; \
+})
+#else
+#define vld1q_s8(__p0) __extension__ ({ \
+  int8x16_t __ret; \
+  __ret = (int8x16_t) __builtin_neon_vld1q_v(__p0, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f32(__p0) __extension__ ({ \
+  float32x4_t __ret; \
+  __ret = (float32x4_t) __builtin_neon_vld1q_v(__p0, 41); \
+  __ret; \
+})
+#else
+#define vld1q_f32(__p0) __extension__ ({ \
+  float32x4_t __ret; \
+  __ret = (float32x4_t) __builtin_neon_vld1q_v(__p0, 41); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s32(__p0) __extension__ ({ \
+  int32x4_t __ret; \
+  __ret = (int32x4_t) __builtin_neon_vld1q_v(__p0, 34); \
+  __ret; \
+})
+#else
+#define vld1q_s32(__p0) __extension__ ({ \
+  int32x4_t __ret; \
+  __ret = (int32x4_t) __builtin_neon_vld1q_v(__p0, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s64(__p0) __extension__ ({ \
+  int64x2_t __ret; \
+  __ret = (int64x2_t) __builtin_neon_vld1q_v(__p0, 35); \
+  __ret; \
+})
+#else
+#define vld1q_s64(__p0) __extension__ ({ \
+  int64x2_t __ret; \
+  __ret = (int64x2_t) __builtin_neon_vld1q_v(__p0, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s16(__p0) __extension__ ({ \
+  int16x8_t __ret; \
+  __ret = (int16x8_t) __builtin_neon_vld1q_v(__p0, 33); \
+  __ret; \
+})
+#else
+#define vld1q_s16(__p0) __extension__ ({ \
+  int16x8_t __ret; \
+  __ret = (int16x8_t) __builtin_neon_vld1q_v(__p0, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u8(__p0) __extension__ ({ \
+  uint8x8_t __ret; \
+  __ret = (uint8x8_t) __builtin_neon_vld1_v(__p0, 16); \
+  __ret; \
+})
+#else
+#define vld1_u8(__p0) __extension__ ({ \
+  uint8x8_t __ret; \
+  __ret = (uint8x8_t) __builtin_neon_vld1_v(__p0, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u32(__p0) __extension__ ({ \
+  uint32x2_t __ret; \
+  __ret = (uint32x2_t) __builtin_neon_vld1_v(__p0, 18); \
+  __ret; \
+})
+#else
+#define vld1_u32(__p0) __extension__ ({ \
+  uint32x2_t __ret; \
+  __ret = (uint32x2_t) __builtin_neon_vld1_v(__p0, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_u64(__p0) __extension__ ({ \
+  uint64x1_t __ret; \
+  __ret = (uint64x1_t) __builtin_neon_vld1_v(__p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u16(__p0) __extension__ ({ \
+  uint16x4_t __ret; \
+  __ret = (uint16x4_t) __builtin_neon_vld1_v(__p0, 17); \
+  __ret; \
+})
+#else
+#define vld1_u16(__p0) __extension__ ({ \
+  uint16x4_t __ret; \
+  __ret = (uint16x4_t) __builtin_neon_vld1_v(__p0, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s8(__p0) __extension__ ({ \
+  int8x8_t __ret; \
+  __ret = (int8x8_t) __builtin_neon_vld1_v(__p0, 0); \
+  __ret; \
+})
+#else
+#define vld1_s8(__p0) __extension__ ({ \
+  int8x8_t __ret; \
+  __ret = (int8x8_t) __builtin_neon_vld1_v(__p0, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_f32(__p0) __extension__ ({ \
+  float32x2_t __ret; \
+  __ret = (float32x2_t) __builtin_neon_vld1_v(__p0, 9); \
+  __ret; \
+})
+#else
+#define vld1_f32(__p0) __extension__ ({ \
+  float32x2_t __ret; \
+  __ret = (float32x2_t) __builtin_neon_vld1_v(__p0, 9); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s32(__p0) __extension__ ({ \
+  int32x2_t __ret; \
+  __ret = (int32x2_t) __builtin_neon_vld1_v(__p0, 2); \
+  __ret; \
+})
+#else
+#define vld1_s32(__p0) __extension__ ({ \
+  int32x2_t __ret; \
+  __ret = (int32x2_t) __builtin_neon_vld1_v(__p0, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_s64(__p0) __extension__ ({ \
+  int64x1_t __ret; \
+  __ret = (int64x1_t) __builtin_neon_vld1_v(__p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s16(__p0) __extension__ ({ \
+  int16x4_t __ret; \
+  __ret = (int16x4_t) __builtin_neon_vld1_v(__p0, 1); \
+  __ret; \
+})
+#else
+#define vld1_s16(__p0) __extension__ ({ \
+  int16x4_t __ret; \
+  __ret = (int16x4_t) __builtin_neon_vld1_v(__p0, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_p8(__p0) __extension__ ({ \
+  poly8x8_t __ret; \
+  __ret = (poly8x8_t) __builtin_neon_vld1_dup_v(__p0, 4); \
+  __ret; \
+})
+#else
+#define vld1_dup_p8(__p0) __extension__ ({ \
+  poly8x8_t __ret; \
+  __ret = (poly8x8_t) __builtin_neon_vld1_dup_v(__p0, 4); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_p16(__p0) __extension__ ({ \
+  poly16x4_t __ret; \
+  __ret = (poly16x4_t) __builtin_neon_vld1_dup_v(__p0, 5); \
+  __ret; \
+})
+#else
+#define vld1_dup_p16(__p0) __extension__ ({ \
+  poly16x4_t __ret; \
+  __ret = (poly16x4_t) __builtin_neon_vld1_dup_v(__p0, 5); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_p8(__p0) __extension__ ({ \
+  poly8x16_t __ret; \
+  __ret = (poly8x16_t) __builtin_neon_vld1q_dup_v(__p0, 36); \
+  __ret; \
+})
+#else
+#define vld1q_dup_p8(__p0) __extension__ ({ \
+  poly8x16_t __ret; \
+  __ret = (poly8x16_t) __builtin_neon_vld1q_dup_v(__p0, 36); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_p16(__p0) __extension__ ({ \
+  poly16x8_t __ret; \
+  __ret = (poly16x8_t) __builtin_neon_vld1q_dup_v(__p0, 37); \
+  __ret; \
+})
+#else
+#define vld1q_dup_p16(__p0) __extension__ ({ \
+  poly16x8_t __ret; \
+  __ret = (poly16x8_t) __builtin_neon_vld1q_dup_v(__p0, 37); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_u8(__p0) __extension__ ({ \
+  uint8x16_t __ret; \
+  __ret = (uint8x16_t) __builtin_neon_vld1q_dup_v(__p0, 48); \
+  __ret; \
+})
+#else
+#define vld1q_dup_u8(__p0) __extension__ ({ \
+  uint8x16_t __ret; \
+  __ret = (uint8x16_t) __builtin_neon_vld1q_dup_v(__p0, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_u32(__p0) __extension__ ({ \
+  uint32x4_t __ret; \
+  __ret = (uint32x4_t) __builtin_neon_vld1q_dup_v(__p0, 50); \
+  __ret; \
+})
+#else
+#define vld1q_dup_u32(__p0) __extension__ ({ \
+  uint32x4_t __ret; \
+  __ret = (uint32x4_t) __builtin_neon_vld1q_dup_v(__p0, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_u64(__p0) __extension__ ({ \
+  uint64x2_t __ret; \
+  __ret = (uint64x2_t) __builtin_neon_vld1q_dup_v(__p0, 51); \
+  __ret; \
+})
+#else
+#define vld1q_dup_u64(__p0) __extension__ ({ \
+  uint64x2_t __ret; \
+  __ret = (uint64x2_t) __builtin_neon_vld1q_dup_v(__p0, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_u16(__p0) __extension__ ({ \
+  uint16x8_t __ret; \
+  __ret = (uint16x8_t) __builtin_neon_vld1q_dup_v(__p0, 49); \
+  __ret; \
+})
+#else
+#define vld1q_dup_u16(__p0) __extension__ ({ \
+  uint16x8_t __ret; \
+  __ret = (uint16x8_t) __builtin_neon_vld1q_dup_v(__p0, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_s8(__p0) __extension__ ({ \
+  int8x16_t __ret; \
+  __ret = (int8x16_t) __builtin_neon_vld1q_dup_v(__p0, 32); \
+  __ret; \
+})
+#else
+#define vld1q_dup_s8(__p0) __extension__ ({ \
+  int8x16_t __ret; \
+  __ret = (int8x16_t) __builtin_neon_vld1q_dup_v(__p0, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_f32(__p0) __extension__ ({ \
+  float32x4_t __ret; \
+  __ret = (float32x4_t) __builtin_neon_vld1q_dup_v(__p0, 41); \
+  __ret; \
+})
+#else
+#define vld1q_dup_f32(__p0) __extension__ ({ \
+  float32x4_t __ret; \
+  __ret = (float32x4_t) __builtin_neon_vld1q_dup_v(__p0, 41); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_s32(__p0) __extension__ ({ \
+  int32x4_t __ret; \
+  __ret = (int32x4_t) __builtin_neon_vld1q_dup_v(__p0, 34); \
+  __ret; \
+})
+#else
+#define vld1q_dup_s32(__p0) __extension__ ({ \
+  int32x4_t __ret; \
+  __ret = (int32x4_t) __builtin_neon_vld1q_dup_v(__p0, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_s64(__p0) __extension__ ({ \
+  int64x2_t __ret; \
+  __ret = (int64x2_t) __builtin_neon_vld1q_dup_v(__p0, 35); \
+  __ret; \
+})
+#else
+#define vld1q_dup_s64(__p0) __extension__ ({ \
+  int64x2_t __ret; \
+  __ret = (int64x2_t) __builtin_neon_vld1q_dup_v(__p0, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_s16(__p0) __extension__ ({ \
+  int16x8_t __ret; \
+  __ret = (int16x8_t) __builtin_neon_vld1q_dup_v(__p0, 33); \
+  __ret; \
+})
+#else
+#define vld1q_dup_s16(__p0) __extension__ ({ \
+  int16x8_t __ret; \
+  __ret = (int16x8_t) __builtin_neon_vld1q_dup_v(__p0, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_u8(__p0) __extension__ ({ \
+  uint8x8_t __ret; \
+  __ret = (uint8x8_t) __builtin_neon_vld1_dup_v(__p0, 16); \
+  __ret; \
+})
+#else
+#define vld1_dup_u8(__p0) __extension__ ({ \
+  uint8x8_t __ret; \
+  __ret = (uint8x8_t) __builtin_neon_vld1_dup_v(__p0, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_u32(__p0) __extension__ ({ \
+  uint32x2_t __ret; \
+  __ret = (uint32x2_t) __builtin_neon_vld1_dup_v(__p0, 18); \
+  __ret; \
+})
+#else
+#define vld1_dup_u32(__p0) __extension__ ({ \
+  uint32x2_t __ret; \
+  __ret = (uint32x2_t) __builtin_neon_vld1_dup_v(__p0, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_dup_u64(__p0) __extension__ ({ \
+  uint64x1_t __ret; \
+  __ret = (uint64x1_t) __builtin_neon_vld1_dup_v(__p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_u16(__p0) __extension__ ({ \
+  uint16x4_t __ret; \
+  __ret = (uint16x4_t) __builtin_neon_vld1_dup_v(__p0, 17); \
+  __ret; \
+})
+#else
+#define vld1_dup_u16(__p0) __extension__ ({ \
+  uint16x4_t __ret; \
+  __ret = (uint16x4_t) __builtin_neon_vld1_dup_v(__p0, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_s8(__p0) __extension__ ({ \
+  int8x8_t __ret; \
+  __ret = (int8x8_t) __builtin_neon_vld1_dup_v(__p0, 0); \
+  __ret; \
+})
+#else
+#define vld1_dup_s8(__p0) __extension__ ({ \
+  int8x8_t __ret; \
+  __ret = (int8x8_t) __builtin_neon_vld1_dup_v(__p0, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_f32(__p0) __extension__ ({ \
+  float32x2_t __ret; \
+  __ret = (float32x2_t) __builtin_neon_vld1_dup_v(__p0, 9); \
+  __ret; \
+})
+#else
+#define vld1_dup_f32(__p0) __extension__ ({ \
+  float32x2_t __ret; \
+  __ret = (float32x2_t) __builtin_neon_vld1_dup_v(__p0, 9); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_s32(__p0) __extension__ ({ \
+  int32x2_t __ret; \
+  __ret = (int32x2_t) __builtin_neon_vld1_dup_v(__p0, 2); \
+  __ret; \
+})
+#else
+#define vld1_dup_s32(__p0) __extension__ ({ \
+  int32x2_t __ret; \
+  __ret = (int32x2_t) __builtin_neon_vld1_dup_v(__p0, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_dup_s64(__p0) __extension__ ({ \
+  int64x1_t __ret; \
+  __ret = (int64x1_t) __builtin_neon_vld1_dup_v(__p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_s16(__p0) __extension__ ({ \
+  int16x4_t __ret; \
+  __ret = (int16x4_t) __builtin_neon_vld1_dup_v(__p0, 1); \
+  __ret; \
+})
+#else
+#define vld1_dup_s16(__p0) __extension__ ({ \
+  int16x4_t __ret; \
+  __ret = (int16x4_t) __builtin_neon_vld1_dup_v(__p0, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s1 = __p1; \
+  __ret = (poly8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 4); \
+  __ret; \
+})
+#else
+#define vld1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s1 = __p1; \
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 4); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s1 = __p1; \
+  __ret = (poly16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 5); \
+  __ret; \
+})
+#else
+#define vld1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s1 = __p1; \
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (poly16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 5); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s1 = __p1; \
+  __ret = (poly8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 36); \
+  __ret; \
+})
+#else
+#define vld1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s1 = __p1; \
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 36); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s1 = __p1; \
+  __ret = (poly16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 37); \
+  __ret; \
+})
+#else
+#define vld1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s1 = __p1; \
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 37); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s1 = __p1; \
+  __ret = (uint8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 48); \
+  __ret; \
+})
+#else
+#define vld1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s1 = __p1; \
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s1 = __p1; \
+  __ret = (uint32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 50); \
+  __ret; \
+})
+#else
+#define vld1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s1 = __p1; \
+  __ret = (uint64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 51); \
+  __ret; \
+})
+#else
+#define vld1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s1 = __p1; \
+  __ret = (uint16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 49); \
+  __ret; \
+})
+#else
+#define vld1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s1 = __p1; \
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s1 = __p1; \
+  __ret = (int8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 32); \
+  __ret; \
+})
+#else
+#define vld1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s1 = __p1; \
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s1 = __p1; \
+  __ret = (float32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 41); \
+  __ret; \
+})
+#else
+#define vld1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s1 = __p1; \
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (float32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 41); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 34); \
+  __ret; \
+})
+#else
+#define vld1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s1 = __p1; \
+  __ret = (int64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 35); \
+  __ret; \
+})
+#else
+#define vld1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 33); \
+  __ret; \
+})
+#else
+#define vld1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s1 = __p1; \
+  __ret = (uint8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 16); \
+  __ret; \
+})
+#else
+#define vld1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s1 = __p1; \
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s1 = __p1; \
+  __ret = (uint32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 18); \
+  __ret; \
+})
+#else
+#define vld1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s1 = __p1; \
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s1 = __p1; \
+  __ret = (uint64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s1 = __p1; \
+  __ret = (uint16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 17); \
+  __ret; \
+})
+#else
+#define vld1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s1 = __p1; \
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s1 = __p1; \
+  __ret = (int8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 0); \
+  __ret; \
+})
+#else
+#define vld1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s1 = __p1; \
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s1 = __p1; \
+  __ret = (float32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 9); \
+  __ret; \
+})
+#else
+#define vld1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s1 = __p1; \
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (float32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 9); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vld1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s1 = __p1; \
+  __ret = (int64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vld1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_p8_x2(__p0) __extension__ ({ \
+  poly8x8x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 4); \
+  __ret; \
+})
+#else
+#define vld1_p8_x2(__p0) __extension__ ({ \
+  poly8x8x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_p16_x2(__p0) __extension__ ({ \
+  poly16x4x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 5); \
+  __ret; \
+})
+#else
+#define vld1_p16_x2(__p0) __extension__ ({ \
+  poly16x4x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p8_x2(__p0) __extension__ ({ \
+  poly8x16x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 36); \
+  __ret; \
+})
+#else
+#define vld1q_p8_x2(__p0) __extension__ ({ \
+  poly8x16x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p16_x2(__p0) __extension__ ({ \
+  poly16x8x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 37); \
+  __ret; \
+})
+#else
+#define vld1q_p16_x2(__p0) __extension__ ({ \
+  poly16x8x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u8_x2(__p0) __extension__ ({ \
+  uint8x16x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 48); \
+  __ret; \
+})
+#else
+#define vld1q_u8_x2(__p0) __extension__ ({ \
+  uint8x16x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u32_x2(__p0) __extension__ ({ \
+  uint32x4x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 50); \
+  __ret; \
+})
+#else
+#define vld1q_u32_x2(__p0) __extension__ ({ \
+  uint32x4x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u64_x2(__p0) __extension__ ({ \
+  uint64x2x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 51); \
+  __ret; \
+})
+#else
+#define vld1q_u64_x2(__p0) __extension__ ({ \
+  uint64x2x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u16_x2(__p0) __extension__ ({ \
+  uint16x8x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 49); \
+  __ret; \
+})
+#else
+#define vld1q_u16_x2(__p0) __extension__ ({ \
+  uint16x8x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s8_x2(__p0) __extension__ ({ \
+  int8x16x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 32); \
+  __ret; \
+})
+#else
+#define vld1q_s8_x2(__p0) __extension__ ({ \
+  int8x16x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f32_x2(__p0) __extension__ ({ \
+  float32x4x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 41); \
+  __ret; \
+})
+#else
+#define vld1q_f32_x2(__p0) __extension__ ({ \
+  float32x4x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s32_x2(__p0) __extension__ ({ \
+  int32x4x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 34); \
+  __ret; \
+})
+#else
+#define vld1q_s32_x2(__p0) __extension__ ({ \
+  int32x4x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s64_x2(__p0) __extension__ ({ \
+  int64x2x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 35); \
+  __ret; \
+})
+#else
+#define vld1q_s64_x2(__p0) __extension__ ({ \
+  int64x2x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s16_x2(__p0) __extension__ ({ \
+  int16x8x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 33); \
+  __ret; \
+})
+#else
+#define vld1q_s16_x2(__p0) __extension__ ({ \
+  int16x8x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u8_x2(__p0) __extension__ ({ \
+  uint8x8x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 16); \
+  __ret; \
+})
+#else
+#define vld1_u8_x2(__p0) __extension__ ({ \
+  uint8x8x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u32_x2(__p0) __extension__ ({ \
+  uint32x2x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 18); \
+  __ret; \
+})
+#else
+#define vld1_u32_x2(__p0) __extension__ ({ \
+  uint32x2x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_u64_x2(__p0) __extension__ ({ \
+  uint64x1x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u16_x2(__p0) __extension__ ({ \
+  uint16x4x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 17); \
+  __ret; \
+})
+#else
+#define vld1_u16_x2(__p0) __extension__ ({ \
+  uint16x4x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s8_x2(__p0) __extension__ ({ \
+  int8x8x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 0); \
+  __ret; \
+})
+#else
+#define vld1_s8_x2(__p0) __extension__ ({ \
+  int8x8x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_f32_x2(__p0) __extension__ ({ \
+  float32x2x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 9); \
+  __ret; \
+})
+#else
+#define vld1_f32_x2(__p0) __extension__ ({ \
+  float32x2x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s32_x2(__p0) __extension__ ({ \
+  int32x2x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 2); \
+  __ret; \
+})
+#else
+#define vld1_s32_x2(__p0) __extension__ ({ \
+  int32x2x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_s64_x2(__p0) __extension__ ({ \
+  int64x1x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s16_x2(__p0) __extension__ ({ \
+  int16x4x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 1); \
+  __ret; \
+})
+#else
+#define vld1_s16_x2(__p0) __extension__ ({ \
+  int16x4x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_p8_x3(__p0) __extension__ ({ \
+  poly8x8x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 4); \
+  __ret; \
+})
+#else
+#define vld1_p8_x3(__p0) __extension__ ({ \
+  poly8x8x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_p16_x3(__p0) __extension__ ({ \
+  poly16x4x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 5); \
+  __ret; \
+})
+#else
+#define vld1_p16_x3(__p0) __extension__ ({ \
+  poly16x4x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p8_x3(__p0) __extension__ ({ \
+  poly8x16x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 36); \
+  __ret; \
+})
+#else
+#define vld1q_p8_x3(__p0) __extension__ ({ \
+  poly8x16x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p16_x3(__p0) __extension__ ({ \
+  poly16x8x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 37); \
+  __ret; \
+})
+#else
+#define vld1q_p16_x3(__p0) __extension__ ({ \
+  poly16x8x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u8_x3(__p0) __extension__ ({ \
+  uint8x16x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 48); \
+  __ret; \
+})
+#else
+#define vld1q_u8_x3(__p0) __extension__ ({ \
+  uint8x16x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u32_x3(__p0) __extension__ ({ \
+  uint32x4x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 50); \
+  __ret; \
+})
+#else
+#define vld1q_u32_x3(__p0) __extension__ ({ \
+  uint32x4x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u64_x3(__p0) __extension__ ({ \
+  uint64x2x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 51); \
+  __ret; \
+})
+#else
+#define vld1q_u64_x3(__p0) __extension__ ({ \
+  uint64x2x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u16_x3(__p0) __extension__ ({ \
+  uint16x8x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 49); \
+  __ret; \
+})
+#else
+#define vld1q_u16_x3(__p0) __extension__ ({ \
+  uint16x8x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s8_x3(__p0) __extension__ ({ \
+  int8x16x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 32); \
+  __ret; \
+})
+#else
+#define vld1q_s8_x3(__p0) __extension__ ({ \
+  int8x16x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f32_x3(__p0) __extension__ ({ \
+  float32x4x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 41); \
+  __ret; \
+})
+#else
+#define vld1q_f32_x3(__p0) __extension__ ({ \
+  float32x4x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s32_x3(__p0) __extension__ ({ \
+  int32x4x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 34); \
+  __ret; \
+})
+#else
+#define vld1q_s32_x3(__p0) __extension__ ({ \
+  int32x4x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s64_x3(__p0) __extension__ ({ \
+  int64x2x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 35); \
+  __ret; \
+})
+#else
+#define vld1q_s64_x3(__p0) __extension__ ({ \
+  int64x2x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s16_x3(__p0) __extension__ ({ \
+  int16x8x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 33); \
+  __ret; \
+})
+#else
+#define vld1q_s16_x3(__p0) __extension__ ({ \
+  int16x8x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u8_x3(__p0) __extension__ ({ \
+  uint8x8x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 16); \
+  __ret; \
+})
+#else
+#define vld1_u8_x3(__p0) __extension__ ({ \
+  uint8x8x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u32_x3(__p0) __extension__ ({ \
+  uint32x2x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 18); \
+  __ret; \
+})
+#else
+#define vld1_u32_x3(__p0) __extension__ ({ \
+  uint32x2x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_u64_x3(__p0) __extension__ ({ \
+  uint64x1x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u16_x3(__p0) __extension__ ({ \
+  uint16x4x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 17); \
+  __ret; \
+})
+#else
+#define vld1_u16_x3(__p0) __extension__ ({ \
+  uint16x4x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s8_x3(__p0) __extension__ ({ \
+  int8x8x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 0); \
+  __ret; \
+})
+#else
+#define vld1_s8_x3(__p0) __extension__ ({ \
+  int8x8x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_f32_x3(__p0) __extension__ ({ \
+  float32x2x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 9); \
+  __ret; \
+})
+#else
+#define vld1_f32_x3(__p0) __extension__ ({ \
+  float32x2x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s32_x3(__p0) __extension__ ({ \
+  int32x2x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 2); \
+  __ret; \
+})
+#else
+#define vld1_s32_x3(__p0) __extension__ ({ \
+  int32x2x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_s64_x3(__p0) __extension__ ({ \
+  int64x1x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s16_x3(__p0) __extension__ ({ \
+  int16x4x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 1); \
+  __ret; \
+})
+#else
+#define vld1_s16_x3(__p0) __extension__ ({ \
+  int16x4x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_p8_x4(__p0) __extension__ ({ \
+  poly8x8x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 4); \
+  __ret; \
+})
+#else
+#define vld1_p8_x4(__p0) __extension__ ({ \
+  poly8x8x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_p16_x4(__p0) __extension__ ({ \
+  poly16x4x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 5); \
+  __ret; \
+})
+#else
+#define vld1_p16_x4(__p0) __extension__ ({ \
+  poly16x4x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p8_x4(__p0) __extension__ ({ \
+  poly8x16x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 36); \
+  __ret; \
+})
+#else
+#define vld1q_p8_x4(__p0) __extension__ ({ \
+  poly8x16x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p16_x4(__p0) __extension__ ({ \
+  poly16x8x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 37); \
+  __ret; \
+})
+#else
+#define vld1q_p16_x4(__p0) __extension__ ({ \
+  poly16x8x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u8_x4(__p0) __extension__ ({ \
+  uint8x16x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 48); \
+  __ret; \
+})
+#else
+#define vld1q_u8_x4(__p0) __extension__ ({ \
+  uint8x16x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u32_x4(__p0) __extension__ ({ \
+  uint32x4x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 50); \
+  __ret; \
+})
+#else
+#define vld1q_u32_x4(__p0) __extension__ ({ \
+  uint32x4x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u64_x4(__p0) __extension__ ({ \
+  uint64x2x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 51); \
+  __ret; \
+})
+#else
+#define vld1q_u64_x4(__p0) __extension__ ({ \
+  uint64x2x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_u16_x4(__p0) __extension__ ({ \
+  uint16x8x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 49); \
+  __ret; \
+})
+#else
+#define vld1q_u16_x4(__p0) __extension__ ({ \
+  uint16x8x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s8_x4(__p0) __extension__ ({ \
+  int8x16x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 32); \
+  __ret; \
+})
+#else
+#define vld1q_s8_x4(__p0) __extension__ ({ \
+  int8x16x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f32_x4(__p0) __extension__ ({ \
+  float32x4x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 41); \
+  __ret; \
+})
+#else
+#define vld1q_f32_x4(__p0) __extension__ ({ \
+  float32x4x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s32_x4(__p0) __extension__ ({ \
+  int32x4x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 34); \
+  __ret; \
+})
+#else
+#define vld1q_s32_x4(__p0) __extension__ ({ \
+  int32x4x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s64_x4(__p0) __extension__ ({ \
+  int64x2x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 35); \
+  __ret; \
+})
+#else
+#define vld1q_s64_x4(__p0) __extension__ ({ \
+  int64x2x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_s16_x4(__p0) __extension__ ({ \
+  int16x8x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 33); \
+  __ret; \
+})
+#else
+#define vld1q_s16_x4(__p0) __extension__ ({ \
+  int16x8x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u8_x4(__p0) __extension__ ({ \
+  uint8x8x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 16); \
+  __ret; \
+})
+#else
+#define vld1_u8_x4(__p0) __extension__ ({ \
+  uint8x8x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u32_x4(__p0) __extension__ ({ \
+  uint32x2x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 18); \
+  __ret; \
+})
+#else
+#define vld1_u32_x4(__p0) __extension__ ({ \
+  uint32x2x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_u64_x4(__p0) __extension__ ({ \
+  uint64x1x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_u16_x4(__p0) __extension__ ({ \
+  uint16x4x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 17); \
+  __ret; \
+})
+#else
+#define vld1_u16_x4(__p0) __extension__ ({ \
+  uint16x4x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s8_x4(__p0) __extension__ ({ \
+  int8x8x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 0); \
+  __ret; \
+})
+#else
+#define vld1_s8_x4(__p0) __extension__ ({ \
+  int8x8x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_f32_x4(__p0) __extension__ ({ \
+  float32x2x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 9); \
+  __ret; \
+})
+#else
+#define vld1_f32_x4(__p0) __extension__ ({ \
+  float32x2x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s32_x4(__p0) __extension__ ({ \
+  int32x2x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 2); \
+  __ret; \
+})
+#else
+#define vld1_s32_x4(__p0) __extension__ ({ \
+  int32x2x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_s64_x4(__p0) __extension__ ({ \
+  int64x1x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1_s16_x4(__p0) __extension__ ({ \
+  int16x4x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 1); \
+  __ret; \
+})
+#else
+#define vld1_s16_x4(__p0) __extension__ ({ \
+  int16x4x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_p8(__p0) __extension__ ({ \
+  poly8x8x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 4); \
+  __ret; \
+})
+#else
+#define vld2_p8(__p0) __extension__ ({ \
+  poly8x8x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_p16(__p0) __extension__ ({ \
+  poly16x4x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 5); \
+  __ret; \
+})
+#else
+#define vld2_p16(__p0) __extension__ ({ \
+  poly16x4x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_p8(__p0) __extension__ ({ \
+  poly8x16x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 36); \
+  __ret; \
+})
+#else
+#define vld2q_p8(__p0) __extension__ ({ \
+  poly8x16x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_p16(__p0) __extension__ ({ \
+  poly16x8x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 37); \
+  __ret; \
+})
+#else
+#define vld2q_p16(__p0) __extension__ ({ \
+  poly16x8x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_u8(__p0) __extension__ ({ \
+  uint8x16x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 48); \
+  __ret; \
+})
+#else
+#define vld2q_u8(__p0) __extension__ ({ \
+  uint8x16x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_u32(__p0) __extension__ ({ \
+  uint32x4x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 50); \
+  __ret; \
+})
+#else
+#define vld2q_u32(__p0) __extension__ ({ \
+  uint32x4x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_u16(__p0) __extension__ ({ \
+  uint16x8x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 49); \
+  __ret; \
+})
+#else
+#define vld2q_u16(__p0) __extension__ ({ \
+  uint16x8x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_s8(__p0) __extension__ ({ \
+  int8x16x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 32); \
+  __ret; \
+})
+#else
+#define vld2q_s8(__p0) __extension__ ({ \
+  int8x16x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_f32(__p0) __extension__ ({ \
+  float32x4x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 41); \
+  __ret; \
+})
+#else
+#define vld2q_f32(__p0) __extension__ ({ \
+  float32x4x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_s32(__p0) __extension__ ({ \
+  int32x4x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 34); \
+  __ret; \
+})
+#else
+#define vld2q_s32(__p0) __extension__ ({ \
+  int32x4x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_s16(__p0) __extension__ ({ \
+  int16x8x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 33); \
+  __ret; \
+})
+#else
+#define vld2q_s16(__p0) __extension__ ({ \
+  int16x8x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_u8(__p0) __extension__ ({ \
+  uint8x8x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 16); \
+  __ret; \
+})
+#else
+#define vld2_u8(__p0) __extension__ ({ \
+  uint8x8x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_u32(__p0) __extension__ ({ \
+  uint32x2x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 18); \
+  __ret; \
+})
+#else
+#define vld2_u32(__p0) __extension__ ({ \
+  uint32x2x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld2_u64(__p0) __extension__ ({ \
+  uint64x1x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld2_u16(__p0) __extension__ ({ \
+  uint16x4x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 17); \
+  __ret; \
+})
+#else
+#define vld2_u16(__p0) __extension__ ({ \
+  uint16x4x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_s8(__p0) __extension__ ({ \
+  int8x8x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 0); \
+  __ret; \
+})
+#else
+#define vld2_s8(__p0) __extension__ ({ \
+  int8x8x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_f32(__p0) __extension__ ({ \
+  float32x2x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 9); \
+  __ret; \
+})
+#else
+#define vld2_f32(__p0) __extension__ ({ \
+  float32x2x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_s32(__p0) __extension__ ({ \
+  int32x2x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 2); \
+  __ret; \
+})
+#else
+#define vld2_s32(__p0) __extension__ ({ \
+  int32x2x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld2_s64(__p0) __extension__ ({ \
+  int64x1x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld2_s16(__p0) __extension__ ({ \
+  int16x4x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 1); \
+  __ret; \
+})
+#else
+#define vld2_s16(__p0) __extension__ ({ \
+  int16x4x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_p8(__p0) __extension__ ({ \
+  poly8x8x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 4); \
+  __ret; \
+})
+#else
+#define vld2_dup_p8(__p0) __extension__ ({ \
+  poly8x8x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_p16(__p0) __extension__ ({ \
+  poly16x4x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 5); \
+  __ret; \
+})
+#else
+#define vld2_dup_p16(__p0) __extension__ ({ \
+  poly16x4x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_p8(__p0) __extension__ ({ \
+  poly8x16x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 36); \
+  __ret; \
+})
+#else
+#define vld2q_dup_p8(__p0) __extension__ ({ \
+  poly8x16x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_p16(__p0) __extension__ ({ \
+  poly16x8x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 37); \
+  __ret; \
+})
+#else
+#define vld2q_dup_p16(__p0) __extension__ ({ \
+  poly16x8x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_u8(__p0) __extension__ ({ \
+  uint8x16x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 48); \
+  __ret; \
+})
+#else
+#define vld2q_dup_u8(__p0) __extension__ ({ \
+  uint8x16x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_u32(__p0) __extension__ ({ \
+  uint32x4x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 50); \
+  __ret; \
+})
+#else
+#define vld2q_dup_u32(__p0) __extension__ ({ \
+  uint32x4x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_u64(__p0) __extension__ ({ \
+  uint64x2x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 51); \
+  __ret; \
+})
+#else
+#define vld2q_dup_u64(__p0) __extension__ ({ \
+  uint64x2x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_u16(__p0) __extension__ ({ \
+  uint16x8x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 49); \
+  __ret; \
+})
+#else
+#define vld2q_dup_u16(__p0) __extension__ ({ \
+  uint16x8x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_s8(__p0) __extension__ ({ \
+  int8x16x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 32); \
+  __ret; \
+})
+#else
+#define vld2q_dup_s8(__p0) __extension__ ({ \
+  int8x16x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_f32(__p0) __extension__ ({ \
+  float32x4x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 41); \
+  __ret; \
+})
+#else
+#define vld2q_dup_f32(__p0) __extension__ ({ \
+  float32x4x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_s32(__p0) __extension__ ({ \
+  int32x4x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 34); \
+  __ret; \
+})
+#else
+#define vld2q_dup_s32(__p0) __extension__ ({ \
+  int32x4x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_s64(__p0) __extension__ ({ \
+  int64x2x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 35); \
+  __ret; \
+})
+#else
+#define vld2q_dup_s64(__p0) __extension__ ({ \
+  int64x2x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_s16(__p0) __extension__ ({ \
+  int16x8x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 33); \
+  __ret; \
+})
+#else
+#define vld2q_dup_s16(__p0) __extension__ ({ \
+  int16x8x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_u8(__p0) __extension__ ({ \
+  uint8x8x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 16); \
+  __ret; \
+})
+#else
+#define vld2_dup_u8(__p0) __extension__ ({ \
+  uint8x8x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_u32(__p0) __extension__ ({ \
+  uint32x2x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 18); \
+  __ret; \
+})
+#else
+#define vld2_dup_u32(__p0) __extension__ ({ \
+  uint32x2x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld2_dup_u64(__p0) __extension__ ({ \
+  uint64x1x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_u16(__p0) __extension__ ({ \
+  uint16x4x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 17); \
+  __ret; \
+})
+#else
+#define vld2_dup_u16(__p0) __extension__ ({ \
+  uint16x4x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_s8(__p0) __extension__ ({ \
+  int8x8x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 0); \
+  __ret; \
+})
+#else
+#define vld2_dup_s8(__p0) __extension__ ({ \
+  int8x8x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_f32(__p0) __extension__ ({ \
+  float32x2x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 9); \
+  __ret; \
+})
+#else
+#define vld2_dup_f32(__p0) __extension__ ({ \
+  float32x2x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_s32(__p0) __extension__ ({ \
+  int32x2x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 2); \
+  __ret; \
+})
+#else
+#define vld2_dup_s32(__p0) __extension__ ({ \
+  int32x2x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld2_dup_s64(__p0) __extension__ ({ \
+  int64x1x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_s16(__p0) __extension__ ({ \
+  int16x4x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 1); \
+  __ret; \
+})
+#else
+#define vld2_dup_s16(__p0) __extension__ ({ \
+  int16x4x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x2_t __ret; \
+  poly8x8x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 4); \
+  __ret; \
+})
+#else
+#define vld2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x2_t __ret; \
+  poly8x8x2_t __s1 = __p1; \
+  poly8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x2_t __ret; \
+  poly16x4x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 5); \
+  __ret; \
+})
+#else
+#define vld2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x2_t __ret; \
+  poly16x4x2_t __s1 = __p1; \
+  poly16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x2_t __ret; \
+  poly16x8x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 37); \
+  __ret; \
+})
+#else
+#define vld2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x2_t __ret; \
+  poly16x8x2_t __s1 = __p1; \
+  poly16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x2_t __ret; \
+  uint32x4x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 50); \
+  __ret; \
+})
+#else
+#define vld2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x2_t __ret; \
+  uint32x4x2_t __s1 = __p1; \
+  uint32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x2_t __ret; \
+  uint16x8x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 49); \
+  __ret; \
+})
+#else
+#define vld2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x2_t __ret; \
+  uint16x8x2_t __s1 = __p1; \
+  uint16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x2_t __ret; \
+  float32x4x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 41); \
+  __ret; \
+})
+#else
+#define vld2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x2_t __ret; \
+  float32x4x2_t __s1 = __p1; \
+  float32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x2_t __ret; \
+  int32x4x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 34); \
+  __ret; \
+})
+#else
+#define vld2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x2_t __ret; \
+  int32x4x2_t __s1 = __p1; \
+  int32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x2_t __ret; \
+  int16x8x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 33); \
+  __ret; \
+})
+#else
+#define vld2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x2_t __ret; \
+  int16x8x2_t __s1 = __p1; \
+  int16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x2_t __ret; \
+  uint8x8x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 16); \
+  __ret; \
+})
+#else
+#define vld2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x2_t __ret; \
+  uint8x8x2_t __s1 = __p1; \
+  uint8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x2_t __ret; \
+  uint32x2x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 18); \
+  __ret; \
+})
+#else
+#define vld2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x2_t __ret; \
+  uint32x2x2_t __s1 = __p1; \
+  uint32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x2_t __ret; \
+  uint16x4x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 17); \
+  __ret; \
+})
+#else
+#define vld2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x2_t __ret; \
+  uint16x4x2_t __s1 = __p1; \
+  uint16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x2_t __ret; \
+  int8x8x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 0); \
+  __ret; \
+})
+#else
+#define vld2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x2_t __ret; \
+  int8x8x2_t __s1 = __p1; \
+  int8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x2_t __ret; \
+  float32x2x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 9); \
+  __ret; \
+})
+#else
+#define vld2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x2_t __ret; \
+  float32x2x2_t __s1 = __p1; \
+  float32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x2_t __ret; \
+  int32x2x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 2); \
+  __ret; \
+})
+#else
+#define vld2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x2_t __ret; \
+  int32x2x2_t __s1 = __p1; \
+  int32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x2_t __ret; \
+  int16x4x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 1); \
+  __ret; \
+})
+#else
+#define vld2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x2_t __ret; \
+  int16x4x2_t __s1 = __p1; \
+  int16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_p8(__p0) __extension__ ({ \
+  poly8x8x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 4); \
+  __ret; \
+})
+#else
+#define vld3_p8(__p0) __extension__ ({ \
+  poly8x8x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_p16(__p0) __extension__ ({ \
+  poly16x4x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 5); \
+  __ret; \
+})
+#else
+#define vld3_p16(__p0) __extension__ ({ \
+  poly16x4x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_p8(__p0) __extension__ ({ \
+  poly8x16x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 36); \
+  __ret; \
+})
+#else
+#define vld3q_p8(__p0) __extension__ ({ \
+  poly8x16x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_p16(__p0) __extension__ ({ \
+  poly16x8x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 37); \
+  __ret; \
+})
+#else
+#define vld3q_p16(__p0) __extension__ ({ \
+  poly16x8x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_u8(__p0) __extension__ ({ \
+  uint8x16x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 48); \
+  __ret; \
+})
+#else
+#define vld3q_u8(__p0) __extension__ ({ \
+  uint8x16x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_u32(__p0) __extension__ ({ \
+  uint32x4x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 50); \
+  __ret; \
+})
+#else
+#define vld3q_u32(__p0) __extension__ ({ \
+  uint32x4x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_u16(__p0) __extension__ ({ \
+  uint16x8x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 49); \
+  __ret; \
+})
+#else
+#define vld3q_u16(__p0) __extension__ ({ \
+  uint16x8x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_s8(__p0) __extension__ ({ \
+  int8x16x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 32); \
+  __ret; \
+})
+#else
+#define vld3q_s8(__p0) __extension__ ({ \
+  int8x16x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_f32(__p0) __extension__ ({ \
+  float32x4x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 41); \
+  __ret; \
+})
+#else
+#define vld3q_f32(__p0) __extension__ ({ \
+  float32x4x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_s32(__p0) __extension__ ({ \
+  int32x4x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 34); \
+  __ret; \
+})
+#else
+#define vld3q_s32(__p0) __extension__ ({ \
+  int32x4x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_s16(__p0) __extension__ ({ \
+  int16x8x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 33); \
+  __ret; \
+})
+#else
+#define vld3q_s16(__p0) __extension__ ({ \
+  int16x8x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_u8(__p0) __extension__ ({ \
+  uint8x8x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 16); \
+  __ret; \
+})
+#else
+#define vld3_u8(__p0) __extension__ ({ \
+  uint8x8x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_u32(__p0) __extension__ ({ \
+  uint32x2x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 18); \
+  __ret; \
+})
+#else
+#define vld3_u32(__p0) __extension__ ({ \
+  uint32x2x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld3_u64(__p0) __extension__ ({ \
+  uint64x1x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld3_u16(__p0) __extension__ ({ \
+  uint16x4x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 17); \
+  __ret; \
+})
+#else
+#define vld3_u16(__p0) __extension__ ({ \
+  uint16x4x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_s8(__p0) __extension__ ({ \
+  int8x8x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 0); \
+  __ret; \
+})
+#else
+#define vld3_s8(__p0) __extension__ ({ \
+  int8x8x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_f32(__p0) __extension__ ({ \
+  float32x2x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 9); \
+  __ret; \
+})
+#else
+#define vld3_f32(__p0) __extension__ ({ \
+  float32x2x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_s32(__p0) __extension__ ({ \
+  int32x2x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 2); \
+  __ret; \
+})
+#else
+#define vld3_s32(__p0) __extension__ ({ \
+  int32x2x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld3_s64(__p0) __extension__ ({ \
+  int64x1x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld3_s16(__p0) __extension__ ({ \
+  int16x4x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 1); \
+  __ret; \
+})
+#else
+#define vld3_s16(__p0) __extension__ ({ \
+  int16x4x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_p8(__p0) __extension__ ({ \
+  poly8x8x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 4); \
+  __ret; \
+})
+#else
+#define vld3_dup_p8(__p0) __extension__ ({ \
+  poly8x8x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_p16(__p0) __extension__ ({ \
+  poly16x4x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 5); \
+  __ret; \
+})
+#else
+#define vld3_dup_p16(__p0) __extension__ ({ \
+  poly16x4x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_p8(__p0) __extension__ ({ \
+  poly8x16x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 36); \
+  __ret; \
+})
+#else
+#define vld3q_dup_p8(__p0) __extension__ ({ \
+  poly8x16x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_p16(__p0) __extension__ ({ \
+  poly16x8x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 37); \
+  __ret; \
+})
+#else
+#define vld3q_dup_p16(__p0) __extension__ ({ \
+  poly16x8x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_u8(__p0) __extension__ ({ \
+  uint8x16x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 48); \
+  __ret; \
+})
+#else
+#define vld3q_dup_u8(__p0) __extension__ ({ \
+  uint8x16x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_u32(__p0) __extension__ ({ \
+  uint32x4x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 50); \
+  __ret; \
+})
+#else
+#define vld3q_dup_u32(__p0) __extension__ ({ \
+  uint32x4x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_u64(__p0) __extension__ ({ \
+  uint64x2x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 51); \
+  __ret; \
+})
+#else
+#define vld3q_dup_u64(__p0) __extension__ ({ \
+  uint64x2x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_u16(__p0) __extension__ ({ \
+  uint16x8x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 49); \
+  __ret; \
+})
+#else
+#define vld3q_dup_u16(__p0) __extension__ ({ \
+  uint16x8x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_s8(__p0) __extension__ ({ \
+  int8x16x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 32); \
+  __ret; \
+})
+#else
+#define vld3q_dup_s8(__p0) __extension__ ({ \
+  int8x16x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_f32(__p0) __extension__ ({ \
+  float32x4x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 41); \
+  __ret; \
+})
+#else
+#define vld3q_dup_f32(__p0) __extension__ ({ \
+  float32x4x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_s32(__p0) __extension__ ({ \
+  int32x4x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 34); \
+  __ret; \
+})
+#else
+#define vld3q_dup_s32(__p0) __extension__ ({ \
+  int32x4x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_s64(__p0) __extension__ ({ \
+  int64x2x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 35); \
+  __ret; \
+})
+#else
+#define vld3q_dup_s64(__p0) __extension__ ({ \
+  int64x2x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_s16(__p0) __extension__ ({ \
+  int16x8x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 33); \
+  __ret; \
+})
+#else
+#define vld3q_dup_s16(__p0) __extension__ ({ \
+  int16x8x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_u8(__p0) __extension__ ({ \
+  uint8x8x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 16); \
+  __ret; \
+})
+#else
+#define vld3_dup_u8(__p0) __extension__ ({ \
+  uint8x8x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_u32(__p0) __extension__ ({ \
+  uint32x2x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 18); \
+  __ret; \
+})
+#else
+#define vld3_dup_u32(__p0) __extension__ ({ \
+  uint32x2x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld3_dup_u64(__p0) __extension__ ({ \
+  uint64x1x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_u16(__p0) __extension__ ({ \
+  uint16x4x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 17); \
+  __ret; \
+})
+#else
+#define vld3_dup_u16(__p0) __extension__ ({ \
+  uint16x4x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_s8(__p0) __extension__ ({ \
+  int8x8x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 0); \
+  __ret; \
+})
+#else
+#define vld3_dup_s8(__p0) __extension__ ({ \
+  int8x8x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_f32(__p0) __extension__ ({ \
+  float32x2x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 9); \
+  __ret; \
+})
+#else
+#define vld3_dup_f32(__p0) __extension__ ({ \
+  float32x2x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_s32(__p0) __extension__ ({ \
+  int32x2x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 2); \
+  __ret; \
+})
+#else
+#define vld3_dup_s32(__p0) __extension__ ({ \
+  int32x2x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld3_dup_s64(__p0) __extension__ ({ \
+  int64x1x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_s16(__p0) __extension__ ({ \
+  int16x4x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 1); \
+  __ret; \
+})
+#else
+#define vld3_dup_s16(__p0) __extension__ ({ \
+  int16x4x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x3_t __ret; \
+  poly8x8x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 4); \
+  __ret; \
+})
+#else
+#define vld3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x3_t __ret; \
+  poly8x8x3_t __s1 = __p1; \
+  poly8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x3_t __ret; \
+  poly16x4x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 5); \
+  __ret; \
+})
+#else
+#define vld3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x3_t __ret; \
+  poly16x4x3_t __s1 = __p1; \
+  poly16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x3_t __ret; \
+  poly16x8x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 37); \
+  __ret; \
+})
+#else
+#define vld3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x3_t __ret; \
+  poly16x8x3_t __s1 = __p1; \
+  poly16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x3_t __ret; \
+  uint32x4x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 50); \
+  __ret; \
+})
+#else
+#define vld3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x3_t __ret; \
+  uint32x4x3_t __s1 = __p1; \
+  uint32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x3_t __ret; \
+  uint16x8x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 49); \
+  __ret; \
+})
+#else
+#define vld3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x3_t __ret; \
+  uint16x8x3_t __s1 = __p1; \
+  uint16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x3_t __ret; \
+  float32x4x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 41); \
+  __ret; \
+})
+#else
+#define vld3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x3_t __ret; \
+  float32x4x3_t __s1 = __p1; \
+  float32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x3_t __ret; \
+  int32x4x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 34); \
+  __ret; \
+})
+#else
+#define vld3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x3_t __ret; \
+  int32x4x3_t __s1 = __p1; \
+  int32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x3_t __ret; \
+  int16x8x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 33); \
+  __ret; \
+})
+#else
+#define vld3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x3_t __ret; \
+  int16x8x3_t __s1 = __p1; \
+  int16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x3_t __ret; \
+  uint8x8x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 16); \
+  __ret; \
+})
+#else
+#define vld3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x3_t __ret; \
+  uint8x8x3_t __s1 = __p1; \
+  uint8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x3_t __ret; \
+  uint32x2x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 18); \
+  __ret; \
+})
+#else
+#define vld3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x3_t __ret; \
+  uint32x2x3_t __s1 = __p1; \
+  uint32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x3_t __ret; \
+  uint16x4x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 17); \
+  __ret; \
+})
+#else
+#define vld3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x3_t __ret; \
+  uint16x4x3_t __s1 = __p1; \
+  uint16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x3_t __ret; \
+  int8x8x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 0); \
+  __ret; \
+})
+#else
+#define vld3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x3_t __ret; \
+  int8x8x3_t __s1 = __p1; \
+  int8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x3_t __ret; \
+  float32x2x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 9); \
+  __ret; \
+})
+#else
+#define vld3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x3_t __ret; \
+  float32x2x3_t __s1 = __p1; \
+  float32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x3_t __ret; \
+  int32x2x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 2); \
+  __ret; \
+})
+#else
+#define vld3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x3_t __ret; \
+  int32x2x3_t __s1 = __p1; \
+  int32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x3_t __ret; \
+  int16x4x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 1); \
+  __ret; \
+})
+#else
+#define vld3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x3_t __ret; \
+  int16x4x3_t __s1 = __p1; \
+  int16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_p8(__p0) __extension__ ({ \
+  poly8x8x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 4); \
+  __ret; \
+})
+#else
+#define vld4_p8(__p0) __extension__ ({ \
+  poly8x8x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_p16(__p0) __extension__ ({ \
+  poly16x4x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 5); \
+  __ret; \
+})
+#else
+#define vld4_p16(__p0) __extension__ ({ \
+  poly16x4x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_p8(__p0) __extension__ ({ \
+  poly8x16x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 36); \
+  __ret; \
+})
+#else
+#define vld4q_p8(__p0) __extension__ ({ \
+  poly8x16x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_p16(__p0) __extension__ ({ \
+  poly16x8x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 37); \
+  __ret; \
+})
+#else
+#define vld4q_p16(__p0) __extension__ ({ \
+  poly16x8x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_u8(__p0) __extension__ ({ \
+  uint8x16x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 48); \
+  __ret; \
+})
+#else
+#define vld4q_u8(__p0) __extension__ ({ \
+  uint8x16x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_u32(__p0) __extension__ ({ \
+  uint32x4x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 50); \
+  __ret; \
+})
+#else
+#define vld4q_u32(__p0) __extension__ ({ \
+  uint32x4x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_u16(__p0) __extension__ ({ \
+  uint16x8x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 49); \
+  __ret; \
+})
+#else
+#define vld4q_u16(__p0) __extension__ ({ \
+  uint16x8x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_s8(__p0) __extension__ ({ \
+  int8x16x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 32); \
+  __ret; \
+})
+#else
+#define vld4q_s8(__p0) __extension__ ({ \
+  int8x16x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_f32(__p0) __extension__ ({ \
+  float32x4x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 41); \
+  __ret; \
+})
+#else
+#define vld4q_f32(__p0) __extension__ ({ \
+  float32x4x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_s32(__p0) __extension__ ({ \
+  int32x4x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 34); \
+  __ret; \
+})
+#else
+#define vld4q_s32(__p0) __extension__ ({ \
+  int32x4x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_s16(__p0) __extension__ ({ \
+  int16x8x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 33); \
+  __ret; \
+})
+#else
+#define vld4q_s16(__p0) __extension__ ({ \
+  int16x8x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_u8(__p0) __extension__ ({ \
+  uint8x8x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 16); \
+  __ret; \
+})
+#else
+#define vld4_u8(__p0) __extension__ ({ \
+  uint8x8x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_u32(__p0) __extension__ ({ \
+  uint32x2x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 18); \
+  __ret; \
+})
+#else
+#define vld4_u32(__p0) __extension__ ({ \
+  uint32x2x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld4_u64(__p0) __extension__ ({ \
+  uint64x1x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld4_u16(__p0) __extension__ ({ \
+  uint16x4x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 17); \
+  __ret; \
+})
+#else
+#define vld4_u16(__p0) __extension__ ({ \
+  uint16x4x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_s8(__p0) __extension__ ({ \
+  int8x8x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 0); \
+  __ret; \
+})
+#else
+#define vld4_s8(__p0) __extension__ ({ \
+  int8x8x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_f32(__p0) __extension__ ({ \
+  float32x2x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 9); \
+  __ret; \
+})
+#else
+#define vld4_f32(__p0) __extension__ ({ \
+  float32x2x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_s32(__p0) __extension__ ({ \
+  int32x2x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 2); \
+  __ret; \
+})
+#else
+#define vld4_s32(__p0) __extension__ ({ \
+  int32x2x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld4_s64(__p0) __extension__ ({ \
+  int64x1x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld4_s16(__p0) __extension__ ({ \
+  int16x4x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 1); \
+  __ret; \
+})
+#else
+#define vld4_s16(__p0) __extension__ ({ \
+  int16x4x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_p8(__p0) __extension__ ({ \
+  poly8x8x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 4); \
+  __ret; \
+})
+#else
+#define vld4_dup_p8(__p0) __extension__ ({ \
+  poly8x8x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_p16(__p0) __extension__ ({ \
+  poly16x4x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 5); \
+  __ret; \
+})
+#else
+#define vld4_dup_p16(__p0) __extension__ ({ \
+  poly16x4x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_p8(__p0) __extension__ ({ \
+  poly8x16x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 36); \
+  __ret; \
+})
+#else
+#define vld4q_dup_p8(__p0) __extension__ ({ \
+  poly8x16x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_p16(__p0) __extension__ ({ \
+  poly16x8x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 37); \
+  __ret; \
+})
+#else
+#define vld4q_dup_p16(__p0) __extension__ ({ \
+  poly16x8x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_u8(__p0) __extension__ ({ \
+  uint8x16x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 48); \
+  __ret; \
+})
+#else
+#define vld4q_dup_u8(__p0) __extension__ ({ \
+  uint8x16x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_u32(__p0) __extension__ ({ \
+  uint32x4x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 50); \
+  __ret; \
+})
+#else
+#define vld4q_dup_u32(__p0) __extension__ ({ \
+  uint32x4x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_u64(__p0) __extension__ ({ \
+  uint64x2x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 51); \
+  __ret; \
+})
+#else
+#define vld4q_dup_u64(__p0) __extension__ ({ \
+  uint64x2x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_u16(__p0) __extension__ ({ \
+  uint16x8x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 49); \
+  __ret; \
+})
+#else
+#define vld4q_dup_u16(__p0) __extension__ ({ \
+  uint16x8x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_s8(__p0) __extension__ ({ \
+  int8x16x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 32); \
+  __ret; \
+})
+#else
+#define vld4q_dup_s8(__p0) __extension__ ({ \
+  int8x16x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_f32(__p0) __extension__ ({ \
+  float32x4x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 41); \
+  __ret; \
+})
+#else
+#define vld4q_dup_f32(__p0) __extension__ ({ \
+  float32x4x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_s32(__p0) __extension__ ({ \
+  int32x4x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 34); \
+  __ret; \
+})
+#else
+#define vld4q_dup_s32(__p0) __extension__ ({ \
+  int32x4x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_s64(__p0) __extension__ ({ \
+  int64x2x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 35); \
+  __ret; \
+})
+#else
+#define vld4q_dup_s64(__p0) __extension__ ({ \
+  int64x2x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_s16(__p0) __extension__ ({ \
+  int16x8x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 33); \
+  __ret; \
+})
+#else
+#define vld4q_dup_s16(__p0) __extension__ ({ \
+  int16x8x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_u8(__p0) __extension__ ({ \
+  uint8x8x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 16); \
+  __ret; \
+})
+#else
+#define vld4_dup_u8(__p0) __extension__ ({ \
+  uint8x8x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_u32(__p0) __extension__ ({ \
+  uint32x2x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 18); \
+  __ret; \
+})
+#else
+#define vld4_dup_u32(__p0) __extension__ ({ \
+  uint32x2x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld4_dup_u64(__p0) __extension__ ({ \
+  uint64x1x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_u16(__p0) __extension__ ({ \
+  uint16x4x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 17); \
+  __ret; \
+})
+#else
+#define vld4_dup_u16(__p0) __extension__ ({ \
+  uint16x4x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_s8(__p0) __extension__ ({ \
+  int8x8x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 0); \
+  __ret; \
+})
+#else
+#define vld4_dup_s8(__p0) __extension__ ({ \
+  int8x8x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_f32(__p0) __extension__ ({ \
+  float32x2x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 9); \
+  __ret; \
+})
+#else
+#define vld4_dup_f32(__p0) __extension__ ({ \
+  float32x2x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_s32(__p0) __extension__ ({ \
+  int32x2x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 2); \
+  __ret; \
+})
+#else
+#define vld4_dup_s32(__p0) __extension__ ({ \
+  int32x2x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld4_dup_s64(__p0) __extension__ ({ \
+  int64x1x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_s16(__p0) __extension__ ({ \
+  int16x4x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 1); \
+  __ret; \
+})
+#else
+#define vld4_dup_s16(__p0) __extension__ ({ \
+  int16x4x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x4_t __ret; \
+  poly8x8x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 4); \
+  __ret; \
+})
+#else
+#define vld4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x4_t __ret; \
+  poly8x8x4_t __s1 = __p1; \
+  poly8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 4); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x4_t __ret; \
+  poly16x4x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 5); \
+  __ret; \
+})
+#else
+#define vld4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x4_t __ret; \
+  poly16x4x4_t __s1 = __p1; \
+  poly16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 5); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x4_t __ret; \
+  poly16x8x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 37); \
+  __ret; \
+})
+#else
+#define vld4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x4_t __ret; \
+  poly16x8x4_t __s1 = __p1; \
+  poly16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 37); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x4_t __ret; \
+  uint32x4x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 50); \
+  __ret; \
+})
+#else
+#define vld4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x4_t __ret; \
+  uint32x4x4_t __s1 = __p1; \
+  uint32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 50); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x4_t __ret; \
+  uint16x8x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 49); \
+  __ret; \
+})
+#else
+#define vld4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x4_t __ret; \
+  uint16x8x4_t __s1 = __p1; \
+  uint16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 49); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x4_t __ret; \
+  float32x4x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 41); \
+  __ret; \
+})
+#else
+#define vld4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x4_t __ret; \
+  float32x4x4_t __s1 = __p1; \
+  float32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 41); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x4_t __ret; \
+  int32x4x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 34); \
+  __ret; \
+})
+#else
+#define vld4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x4_t __ret; \
+  int32x4x4_t __s1 = __p1; \
+  int32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 34); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x4_t __ret; \
+  int16x8x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 33); \
+  __ret; \
+})
+#else
+#define vld4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x4_t __ret; \
+  int16x8x4_t __s1 = __p1; \
+  int16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 33); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x4_t __ret; \
+  uint8x8x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 16); \
+  __ret; \
+})
+#else
+#define vld4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x4_t __ret; \
+  uint8x8x4_t __s1 = __p1; \
+  uint8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 16); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x4_t __ret; \
+  uint32x2x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 18); \
+  __ret; \
+})
+#else
+#define vld4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x4_t __ret; \
+  uint32x2x4_t __s1 = __p1; \
+  uint32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 18); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x4_t __ret; \
+  uint16x4x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 17); \
+  __ret; \
+})
+#else
+#define vld4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x4_t __ret; \
+  uint16x4x4_t __s1 = __p1; \
+  uint16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 17); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x4_t __ret; \
+  int8x8x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 0); \
+  __ret; \
+})
+#else
+#define vld4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x4_t __ret; \
+  int8x8x4_t __s1 = __p1; \
+  int8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 0); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x4_t __ret; \
+  float32x2x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 9); \
+  __ret; \
+})
+#else
+#define vld4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x4_t __ret; \
+  float32x2x4_t __s1 = __p1; \
+  float32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 9); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x4_t __ret; \
+  int32x2x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 2); \
+  __ret; \
+})
+#else
+#define vld4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x4_t __ret; \
+  int32x2x4_t __s1 = __p1; \
+  int32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 2); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x4_t __ret; \
+  int16x4x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 1); \
+  __ret; \
+})
+#else
+#define vld4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x4_t __ret; \
+  int16x4x4_t __s1 = __p1; \
+  int16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 1); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vmax_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vmax_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmax_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmax_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmax_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmax_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmax_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmax_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vminq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vminq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vminq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vminq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vminq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vminq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vminq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vminq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vmin_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vmin_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmin_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmin_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmin_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmin_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmin_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmin_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vmlaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vmlaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmlaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmlaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vmlaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vmlaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmlaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmlaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmla_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vmla_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmla_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint32x2_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmla_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmla_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint16x4_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmla_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vmla_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vmla_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmla_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmla_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmla_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmla_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_lane_u32(__p0_54, __p1_54, __p2_54, __p3_54) __extension__ ({ \
+  uint32x4_t __ret_54; \
+  uint32x4_t __s0_54 = __p0_54; \
+  uint32x4_t __s1_54 = __p1_54; \
+  uint32x2_t __s2_54 = __p2_54; \
+  __ret_54 = __s0_54 + __s1_54 * splatq_lane_u32(__s2_54, __p3_54); \
+  __ret_54; \
+})
+#else
+#define vmlaq_lane_u32(__p0_55, __p1_55, __p2_55, __p3_55) __extension__ ({ \
+  uint32x4_t __ret_55; \
+  uint32x4_t __s0_55 = __p0_55; \
+  uint32x4_t __s1_55 = __p1_55; \
+  uint32x2_t __s2_55 = __p2_55; \
+  uint32x4_t __rev0_55;  __rev0_55 = __builtin_shufflevector(__s0_55, __s0_55, 3, 2, 1, 0); \
+  uint32x4_t __rev1_55;  __rev1_55 = __builtin_shufflevector(__s1_55, __s1_55, 3, 2, 1, 0); \
+  uint32x2_t __rev2_55;  __rev2_55 = __builtin_shufflevector(__s2_55, __s2_55, 1, 0); \
+  __ret_55 = __rev0_55 + __rev1_55 * __noswap_splatq_lane_u32(__rev2_55, __p3_55); \
+  __ret_55 = __builtin_shufflevector(__ret_55, __ret_55, 3, 2, 1, 0); \
+  __ret_55; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_lane_u16(__p0_56, __p1_56, __p2_56, __p3_56) __extension__ ({ \
+  uint16x8_t __ret_56; \
+  uint16x8_t __s0_56 = __p0_56; \
+  uint16x8_t __s1_56 = __p1_56; \
+  uint16x4_t __s2_56 = __p2_56; \
+  __ret_56 = __s0_56 + __s1_56 * splatq_lane_u16(__s2_56, __p3_56); \
+  __ret_56; \
+})
+#else
+#define vmlaq_lane_u16(__p0_57, __p1_57, __p2_57, __p3_57) __extension__ ({ \
+  uint16x8_t __ret_57; \
+  uint16x8_t __s0_57 = __p0_57; \
+  uint16x8_t __s1_57 = __p1_57; \
+  uint16x4_t __s2_57 = __p2_57; \
+  uint16x8_t __rev0_57;  __rev0_57 = __builtin_shufflevector(__s0_57, __s0_57, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1_57;  __rev1_57 = __builtin_shufflevector(__s1_57, __s1_57, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x4_t __rev2_57;  __rev2_57 = __builtin_shufflevector(__s2_57, __s2_57, 3, 2, 1, 0); \
+  __ret_57 = __rev0_57 + __rev1_57 * __noswap_splatq_lane_u16(__rev2_57, __p3_57); \
+  __ret_57 = __builtin_shufflevector(__ret_57, __ret_57, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_57; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_lane_f32(__p0_58, __p1_58, __p2_58, __p3_58) __extension__ ({ \
+  float32x4_t __ret_58; \
+  float32x4_t __s0_58 = __p0_58; \
+  float32x4_t __s1_58 = __p1_58; \
+  float32x2_t __s2_58 = __p2_58; \
+  __ret_58 = __s0_58 + __s1_58 * splatq_lane_f32(__s2_58, __p3_58); \
+  __ret_58; \
+})
+#else
+#define vmlaq_lane_f32(__p0_59, __p1_59, __p2_59, __p3_59) __extension__ ({ \
+  float32x4_t __ret_59; \
+  float32x4_t __s0_59 = __p0_59; \
+  float32x4_t __s1_59 = __p1_59; \
+  float32x2_t __s2_59 = __p2_59; \
+  float32x4_t __rev0_59;  __rev0_59 = __builtin_shufflevector(__s0_59, __s0_59, 3, 2, 1, 0); \
+  float32x4_t __rev1_59;  __rev1_59 = __builtin_shufflevector(__s1_59, __s1_59, 3, 2, 1, 0); \
+  float32x2_t __rev2_59;  __rev2_59 = __builtin_shufflevector(__s2_59, __s2_59, 1, 0); \
+  __ret_59 = __rev0_59 + __rev1_59 * __noswap_splatq_lane_f32(__rev2_59, __p3_59); \
+  __ret_59 = __builtin_shufflevector(__ret_59, __ret_59, 3, 2, 1, 0); \
+  __ret_59; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_lane_s32(__p0_60, __p1_60, __p2_60, __p3_60) __extension__ ({ \
+  int32x4_t __ret_60; \
+  int32x4_t __s0_60 = __p0_60; \
+  int32x4_t __s1_60 = __p1_60; \
+  int32x2_t __s2_60 = __p2_60; \
+  __ret_60 = __s0_60 + __s1_60 * splatq_lane_s32(__s2_60, __p3_60); \
+  __ret_60; \
+})
+#else
+#define vmlaq_lane_s32(__p0_61, __p1_61, __p2_61, __p3_61) __extension__ ({ \
+  int32x4_t __ret_61; \
+  int32x4_t __s0_61 = __p0_61; \
+  int32x4_t __s1_61 = __p1_61; \
+  int32x2_t __s2_61 = __p2_61; \
+  int32x4_t __rev0_61;  __rev0_61 = __builtin_shufflevector(__s0_61, __s0_61, 3, 2, 1, 0); \
+  int32x4_t __rev1_61;  __rev1_61 = __builtin_shufflevector(__s1_61, __s1_61, 3, 2, 1, 0); \
+  int32x2_t __rev2_61;  __rev2_61 = __builtin_shufflevector(__s2_61, __s2_61, 1, 0); \
+  __ret_61 = __rev0_61 + __rev1_61 * __noswap_splatq_lane_s32(__rev2_61, __p3_61); \
+  __ret_61 = __builtin_shufflevector(__ret_61, __ret_61, 3, 2, 1, 0); \
+  __ret_61; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_lane_s16(__p0_62, __p1_62, __p2_62, __p3_62) __extension__ ({ \
+  int16x8_t __ret_62; \
+  int16x8_t __s0_62 = __p0_62; \
+  int16x8_t __s1_62 = __p1_62; \
+  int16x4_t __s2_62 = __p2_62; \
+  __ret_62 = __s0_62 + __s1_62 * splatq_lane_s16(__s2_62, __p3_62); \
+  __ret_62; \
+})
+#else
+#define vmlaq_lane_s16(__p0_63, __p1_63, __p2_63, __p3_63) __extension__ ({ \
+  int16x8_t __ret_63; \
+  int16x8_t __s0_63 = __p0_63; \
+  int16x8_t __s1_63 = __p1_63; \
+  int16x4_t __s2_63 = __p2_63; \
+  int16x8_t __rev0_63;  __rev0_63 = __builtin_shufflevector(__s0_63, __s0_63, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_63;  __rev1_63 = __builtin_shufflevector(__s1_63, __s1_63, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev2_63;  __rev2_63 = __builtin_shufflevector(__s2_63, __s2_63, 3, 2, 1, 0); \
+  __ret_63 = __rev0_63 + __rev1_63 * __noswap_splatq_lane_s16(__rev2_63, __p3_63); \
+  __ret_63 = __builtin_shufflevector(__ret_63, __ret_63, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_63; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_lane_u32(__p0_64, __p1_64, __p2_64, __p3_64) __extension__ ({ \
+  uint32x2_t __ret_64; \
+  uint32x2_t __s0_64 = __p0_64; \
+  uint32x2_t __s1_64 = __p1_64; \
+  uint32x2_t __s2_64 = __p2_64; \
+  __ret_64 = __s0_64 + __s1_64 * splat_lane_u32(__s2_64, __p3_64); \
+  __ret_64; \
+})
+#else
+#define vmla_lane_u32(__p0_65, __p1_65, __p2_65, __p3_65) __extension__ ({ \
+  uint32x2_t __ret_65; \
+  uint32x2_t __s0_65 = __p0_65; \
+  uint32x2_t __s1_65 = __p1_65; \
+  uint32x2_t __s2_65 = __p2_65; \
+  uint32x2_t __rev0_65;  __rev0_65 = __builtin_shufflevector(__s0_65, __s0_65, 1, 0); \
+  uint32x2_t __rev1_65;  __rev1_65 = __builtin_shufflevector(__s1_65, __s1_65, 1, 0); \
+  uint32x2_t __rev2_65;  __rev2_65 = __builtin_shufflevector(__s2_65, __s2_65, 1, 0); \
+  __ret_65 = __rev0_65 + __rev1_65 * __noswap_splat_lane_u32(__rev2_65, __p3_65); \
+  __ret_65 = __builtin_shufflevector(__ret_65, __ret_65, 1, 0); \
+  __ret_65; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_lane_u16(__p0_66, __p1_66, __p2_66, __p3_66) __extension__ ({ \
+  uint16x4_t __ret_66; \
+  uint16x4_t __s0_66 = __p0_66; \
+  uint16x4_t __s1_66 = __p1_66; \
+  uint16x4_t __s2_66 = __p2_66; \
+  __ret_66 = __s0_66 + __s1_66 * splat_lane_u16(__s2_66, __p3_66); \
+  __ret_66; \
+})
+#else
+#define vmla_lane_u16(__p0_67, __p1_67, __p2_67, __p3_67) __extension__ ({ \
+  uint16x4_t __ret_67; \
+  uint16x4_t __s0_67 = __p0_67; \
+  uint16x4_t __s1_67 = __p1_67; \
+  uint16x4_t __s2_67 = __p2_67; \
+  uint16x4_t __rev0_67;  __rev0_67 = __builtin_shufflevector(__s0_67, __s0_67, 3, 2, 1, 0); \
+  uint16x4_t __rev1_67;  __rev1_67 = __builtin_shufflevector(__s1_67, __s1_67, 3, 2, 1, 0); \
+  uint16x4_t __rev2_67;  __rev2_67 = __builtin_shufflevector(__s2_67, __s2_67, 3, 2, 1, 0); \
+  __ret_67 = __rev0_67 + __rev1_67 * __noswap_splat_lane_u16(__rev2_67, __p3_67); \
+  __ret_67 = __builtin_shufflevector(__ret_67, __ret_67, 3, 2, 1, 0); \
+  __ret_67; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_lane_f32(__p0_68, __p1_68, __p2_68, __p3_68) __extension__ ({ \
+  float32x2_t __ret_68; \
+  float32x2_t __s0_68 = __p0_68; \
+  float32x2_t __s1_68 = __p1_68; \
+  float32x2_t __s2_68 = __p2_68; \
+  __ret_68 = __s0_68 + __s1_68 * splat_lane_f32(__s2_68, __p3_68); \
+  __ret_68; \
+})
+#else
+#define vmla_lane_f32(__p0_69, __p1_69, __p2_69, __p3_69) __extension__ ({ \
+  float32x2_t __ret_69; \
+  float32x2_t __s0_69 = __p0_69; \
+  float32x2_t __s1_69 = __p1_69; \
+  float32x2_t __s2_69 = __p2_69; \
+  float32x2_t __rev0_69;  __rev0_69 = __builtin_shufflevector(__s0_69, __s0_69, 1, 0); \
+  float32x2_t __rev1_69;  __rev1_69 = __builtin_shufflevector(__s1_69, __s1_69, 1, 0); \
+  float32x2_t __rev2_69;  __rev2_69 = __builtin_shufflevector(__s2_69, __s2_69, 1, 0); \
+  __ret_69 = __rev0_69 + __rev1_69 * __noswap_splat_lane_f32(__rev2_69, __p3_69); \
+  __ret_69 = __builtin_shufflevector(__ret_69, __ret_69, 1, 0); \
+  __ret_69; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_lane_s32(__p0_70, __p1_70, __p2_70, __p3_70) __extension__ ({ \
+  int32x2_t __ret_70; \
+  int32x2_t __s0_70 = __p0_70; \
+  int32x2_t __s1_70 = __p1_70; \
+  int32x2_t __s2_70 = __p2_70; \
+  __ret_70 = __s0_70 + __s1_70 * splat_lane_s32(__s2_70, __p3_70); \
+  __ret_70; \
+})
+#else
+#define vmla_lane_s32(__p0_71, __p1_71, __p2_71, __p3_71) __extension__ ({ \
+  int32x2_t __ret_71; \
+  int32x2_t __s0_71 = __p0_71; \
+  int32x2_t __s1_71 = __p1_71; \
+  int32x2_t __s2_71 = __p2_71; \
+  int32x2_t __rev0_71;  __rev0_71 = __builtin_shufflevector(__s0_71, __s0_71, 1, 0); \
+  int32x2_t __rev1_71;  __rev1_71 = __builtin_shufflevector(__s1_71, __s1_71, 1, 0); \
+  int32x2_t __rev2_71;  __rev2_71 = __builtin_shufflevector(__s2_71, __s2_71, 1, 0); \
+  __ret_71 = __rev0_71 + __rev1_71 * __noswap_splat_lane_s32(__rev2_71, __p3_71); \
+  __ret_71 = __builtin_shufflevector(__ret_71, __ret_71, 1, 0); \
+  __ret_71; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_lane_s16(__p0_72, __p1_72, __p2_72, __p3_72) __extension__ ({ \
+  int16x4_t __ret_72; \
+  int16x4_t __s0_72 = __p0_72; \
+  int16x4_t __s1_72 = __p1_72; \
+  int16x4_t __s2_72 = __p2_72; \
+  __ret_72 = __s0_72 + __s1_72 * splat_lane_s16(__s2_72, __p3_72); \
+  __ret_72; \
+})
+#else
+#define vmla_lane_s16(__p0_73, __p1_73, __p2_73, __p3_73) __extension__ ({ \
+  int16x4_t __ret_73; \
+  int16x4_t __s0_73 = __p0_73; \
+  int16x4_t __s1_73 = __p1_73; \
+  int16x4_t __s2_73 = __p2_73; \
+  int16x4_t __rev0_73;  __rev0_73 = __builtin_shufflevector(__s0_73, __s0_73, 3, 2, 1, 0); \
+  int16x4_t __rev1_73;  __rev1_73 = __builtin_shufflevector(__s1_73, __s1_73, 3, 2, 1, 0); \
+  int16x4_t __rev2_73;  __rev2_73 = __builtin_shufflevector(__s2_73, __s2_73, 3, 2, 1, 0); \
+  __ret_73 = __rev0_73 + __rev1_73 * __noswap_splat_lane_s16(__rev2_73, __p3_73); \
+  __ret_73 = __builtin_shufflevector(__ret_73, __ret_73, 3, 2, 1, 0); \
+  __ret_73; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlaq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 + __p1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlaq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmlaq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 + __p1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmlaq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmlaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+  float32x4_t __ret;
+  __ret = __p0 + __p1 * (float32x4_t) {__p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmlaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * (float32x4_t) {__p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlaq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 + __p1 * (int32x4_t) {__p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlaq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * (int32x4_t) {__p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmlaq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 + __p1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmlaq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmla_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+  uint32x2_t __ret;
+  __ret = __p0 + __p1 * (uint32x2_t) {__p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmla_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __rev1 * (uint32x2_t) {__p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmla_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+  uint16x4_t __ret;
+  __ret = __p0 + __p1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmla_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmla_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+  float32x2_t __ret;
+  __ret = __p0 + __p1 * (float32x2_t) {__p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmla_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __rev1 * (float32x2_t) {__p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmla_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int32x2_t __ret;
+  __ret = __p0 + __p1 * (int32x2_t) {__p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmla_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __rev1 * (int32x2_t) {__p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmla_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int16x4_t __ret;
+  __ret = __p0 + __p1 * (int16x4_t) {__p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmla_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __rev1 * (int16x4_t) {__p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vmlsq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vmlsq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlsq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlsq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmlsq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmlsq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vmlsq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vmlsq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmlsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmlsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlsq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlsq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmlsq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmlsq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmls_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vmls_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmls_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint32x2_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmls_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmls_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint16x4_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmls_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vmls_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vmls_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmls_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmls_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmls_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmls_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmls_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmls_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_lane_u32(__p0_74, __p1_74, __p2_74, __p3_74) __extension__ ({ \
+  uint32x4_t __ret_74; \
+  uint32x4_t __s0_74 = __p0_74; \
+  uint32x4_t __s1_74 = __p1_74; \
+  uint32x2_t __s2_74 = __p2_74; \
+  __ret_74 = __s0_74 - __s1_74 * splatq_lane_u32(__s2_74, __p3_74); \
+  __ret_74; \
+})
+#else
+#define vmlsq_lane_u32(__p0_75, __p1_75, __p2_75, __p3_75) __extension__ ({ \
+  uint32x4_t __ret_75; \
+  uint32x4_t __s0_75 = __p0_75; \
+  uint32x4_t __s1_75 = __p1_75; \
+  uint32x2_t __s2_75 = __p2_75; \
+  uint32x4_t __rev0_75;  __rev0_75 = __builtin_shufflevector(__s0_75, __s0_75, 3, 2, 1, 0); \
+  uint32x4_t __rev1_75;  __rev1_75 = __builtin_shufflevector(__s1_75, __s1_75, 3, 2, 1, 0); \
+  uint32x2_t __rev2_75;  __rev2_75 = __builtin_shufflevector(__s2_75, __s2_75, 1, 0); \
+  __ret_75 = __rev0_75 - __rev1_75 * __noswap_splatq_lane_u32(__rev2_75, __p3_75); \
+  __ret_75 = __builtin_shufflevector(__ret_75, __ret_75, 3, 2, 1, 0); \
+  __ret_75; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_lane_u16(__p0_76, __p1_76, __p2_76, __p3_76) __extension__ ({ \
+  uint16x8_t __ret_76; \
+  uint16x8_t __s0_76 = __p0_76; \
+  uint16x8_t __s1_76 = __p1_76; \
+  uint16x4_t __s2_76 = __p2_76; \
+  __ret_76 = __s0_76 - __s1_76 * splatq_lane_u16(__s2_76, __p3_76); \
+  __ret_76; \
+})
+#else
+#define vmlsq_lane_u16(__p0_77, __p1_77, __p2_77, __p3_77) __extension__ ({ \
+  uint16x8_t __ret_77; \
+  uint16x8_t __s0_77 = __p0_77; \
+  uint16x8_t __s1_77 = __p1_77; \
+  uint16x4_t __s2_77 = __p2_77; \
+  uint16x8_t __rev0_77;  __rev0_77 = __builtin_shufflevector(__s0_77, __s0_77, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1_77;  __rev1_77 = __builtin_shufflevector(__s1_77, __s1_77, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x4_t __rev2_77;  __rev2_77 = __builtin_shufflevector(__s2_77, __s2_77, 3, 2, 1, 0); \
+  __ret_77 = __rev0_77 - __rev1_77 * __noswap_splatq_lane_u16(__rev2_77, __p3_77); \
+  __ret_77 = __builtin_shufflevector(__ret_77, __ret_77, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_77; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_lane_f32(__p0_78, __p1_78, __p2_78, __p3_78) __extension__ ({ \
+  float32x4_t __ret_78; \
+  float32x4_t __s0_78 = __p0_78; \
+  float32x4_t __s1_78 = __p1_78; \
+  float32x2_t __s2_78 = __p2_78; \
+  __ret_78 = __s0_78 - __s1_78 * splatq_lane_f32(__s2_78, __p3_78); \
+  __ret_78; \
+})
+#else
+#define vmlsq_lane_f32(__p0_79, __p1_79, __p2_79, __p3_79) __extension__ ({ \
+  float32x4_t __ret_79; \
+  float32x4_t __s0_79 = __p0_79; \
+  float32x4_t __s1_79 = __p1_79; \
+  float32x2_t __s2_79 = __p2_79; \
+  float32x4_t __rev0_79;  __rev0_79 = __builtin_shufflevector(__s0_79, __s0_79, 3, 2, 1, 0); \
+  float32x4_t __rev1_79;  __rev1_79 = __builtin_shufflevector(__s1_79, __s1_79, 3, 2, 1, 0); \
+  float32x2_t __rev2_79;  __rev2_79 = __builtin_shufflevector(__s2_79, __s2_79, 1, 0); \
+  __ret_79 = __rev0_79 - __rev1_79 * __noswap_splatq_lane_f32(__rev2_79, __p3_79); \
+  __ret_79 = __builtin_shufflevector(__ret_79, __ret_79, 3, 2, 1, 0); \
+  __ret_79; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_lane_s32(__p0_80, __p1_80, __p2_80, __p3_80) __extension__ ({ \
+  int32x4_t __ret_80; \
+  int32x4_t __s0_80 = __p0_80; \
+  int32x4_t __s1_80 = __p1_80; \
+  int32x2_t __s2_80 = __p2_80; \
+  __ret_80 = __s0_80 - __s1_80 * splatq_lane_s32(__s2_80, __p3_80); \
+  __ret_80; \
+})
+#else
+#define vmlsq_lane_s32(__p0_81, __p1_81, __p2_81, __p3_81) __extension__ ({ \
+  int32x4_t __ret_81; \
+  int32x4_t __s0_81 = __p0_81; \
+  int32x4_t __s1_81 = __p1_81; \
+  int32x2_t __s2_81 = __p2_81; \
+  int32x4_t __rev0_81;  __rev0_81 = __builtin_shufflevector(__s0_81, __s0_81, 3, 2, 1, 0); \
+  int32x4_t __rev1_81;  __rev1_81 = __builtin_shufflevector(__s1_81, __s1_81, 3, 2, 1, 0); \
+  int32x2_t __rev2_81;  __rev2_81 = __builtin_shufflevector(__s2_81, __s2_81, 1, 0); \
+  __ret_81 = __rev0_81 - __rev1_81 * __noswap_splatq_lane_s32(__rev2_81, __p3_81); \
+  __ret_81 = __builtin_shufflevector(__ret_81, __ret_81, 3, 2, 1, 0); \
+  __ret_81; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_lane_s16(__p0_82, __p1_82, __p2_82, __p3_82) __extension__ ({ \
+  int16x8_t __ret_82; \
+  int16x8_t __s0_82 = __p0_82; \
+  int16x8_t __s1_82 = __p1_82; \
+  int16x4_t __s2_82 = __p2_82; \
+  __ret_82 = __s0_82 - __s1_82 * splatq_lane_s16(__s2_82, __p3_82); \
+  __ret_82; \
+})
+#else
+#define vmlsq_lane_s16(__p0_83, __p1_83, __p2_83, __p3_83) __extension__ ({ \
+  int16x8_t __ret_83; \
+  int16x8_t __s0_83 = __p0_83; \
+  int16x8_t __s1_83 = __p1_83; \
+  int16x4_t __s2_83 = __p2_83; \
+  int16x8_t __rev0_83;  __rev0_83 = __builtin_shufflevector(__s0_83, __s0_83, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_83;  __rev1_83 = __builtin_shufflevector(__s1_83, __s1_83, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev2_83;  __rev2_83 = __builtin_shufflevector(__s2_83, __s2_83, 3, 2, 1, 0); \
+  __ret_83 = __rev0_83 - __rev1_83 * __noswap_splatq_lane_s16(__rev2_83, __p3_83); \
+  __ret_83 = __builtin_shufflevector(__ret_83, __ret_83, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_83; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_lane_u32(__p0_84, __p1_84, __p2_84, __p3_84) __extension__ ({ \
+  uint32x2_t __ret_84; \
+  uint32x2_t __s0_84 = __p0_84; \
+  uint32x2_t __s1_84 = __p1_84; \
+  uint32x2_t __s2_84 = __p2_84; \
+  __ret_84 = __s0_84 - __s1_84 * splat_lane_u32(__s2_84, __p3_84); \
+  __ret_84; \
+})
+#else
+#define vmls_lane_u32(__p0_85, __p1_85, __p2_85, __p3_85) __extension__ ({ \
+  uint32x2_t __ret_85; \
+  uint32x2_t __s0_85 = __p0_85; \
+  uint32x2_t __s1_85 = __p1_85; \
+  uint32x2_t __s2_85 = __p2_85; \
+  uint32x2_t __rev0_85;  __rev0_85 = __builtin_shufflevector(__s0_85, __s0_85, 1, 0); \
+  uint32x2_t __rev1_85;  __rev1_85 = __builtin_shufflevector(__s1_85, __s1_85, 1, 0); \
+  uint32x2_t __rev2_85;  __rev2_85 = __builtin_shufflevector(__s2_85, __s2_85, 1, 0); \
+  __ret_85 = __rev0_85 - __rev1_85 * __noswap_splat_lane_u32(__rev2_85, __p3_85); \
+  __ret_85 = __builtin_shufflevector(__ret_85, __ret_85, 1, 0); \
+  __ret_85; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_lane_u16(__p0_86, __p1_86, __p2_86, __p3_86) __extension__ ({ \
+  uint16x4_t __ret_86; \
+  uint16x4_t __s0_86 = __p0_86; \
+  uint16x4_t __s1_86 = __p1_86; \
+  uint16x4_t __s2_86 = __p2_86; \
+  __ret_86 = __s0_86 - __s1_86 * splat_lane_u16(__s2_86, __p3_86); \
+  __ret_86; \
+})
+#else
+#define vmls_lane_u16(__p0_87, __p1_87, __p2_87, __p3_87) __extension__ ({ \
+  uint16x4_t __ret_87; \
+  uint16x4_t __s0_87 = __p0_87; \
+  uint16x4_t __s1_87 = __p1_87; \
+  uint16x4_t __s2_87 = __p2_87; \
+  uint16x4_t __rev0_87;  __rev0_87 = __builtin_shufflevector(__s0_87, __s0_87, 3, 2, 1, 0); \
+  uint16x4_t __rev1_87;  __rev1_87 = __builtin_shufflevector(__s1_87, __s1_87, 3, 2, 1, 0); \
+  uint16x4_t __rev2_87;  __rev2_87 = __builtin_shufflevector(__s2_87, __s2_87, 3, 2, 1, 0); \
+  __ret_87 = __rev0_87 - __rev1_87 * __noswap_splat_lane_u16(__rev2_87, __p3_87); \
+  __ret_87 = __builtin_shufflevector(__ret_87, __ret_87, 3, 2, 1, 0); \
+  __ret_87; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_lane_f32(__p0_88, __p1_88, __p2_88, __p3_88) __extension__ ({ \
+  float32x2_t __ret_88; \
+  float32x2_t __s0_88 = __p0_88; \
+  float32x2_t __s1_88 = __p1_88; \
+  float32x2_t __s2_88 = __p2_88; \
+  __ret_88 = __s0_88 - __s1_88 * splat_lane_f32(__s2_88, __p3_88); \
+  __ret_88; \
+})
+#else
+#define vmls_lane_f32(__p0_89, __p1_89, __p2_89, __p3_89) __extension__ ({ \
+  float32x2_t __ret_89; \
+  float32x2_t __s0_89 = __p0_89; \
+  float32x2_t __s1_89 = __p1_89; \
+  float32x2_t __s2_89 = __p2_89; \
+  float32x2_t __rev0_89;  __rev0_89 = __builtin_shufflevector(__s0_89, __s0_89, 1, 0); \
+  float32x2_t __rev1_89;  __rev1_89 = __builtin_shufflevector(__s1_89, __s1_89, 1, 0); \
+  float32x2_t __rev2_89;  __rev2_89 = __builtin_shufflevector(__s2_89, __s2_89, 1, 0); \
+  __ret_89 = __rev0_89 - __rev1_89 * __noswap_splat_lane_f32(__rev2_89, __p3_89); \
+  __ret_89 = __builtin_shufflevector(__ret_89, __ret_89, 1, 0); \
+  __ret_89; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_lane_s32(__p0_90, __p1_90, __p2_90, __p3_90) __extension__ ({ \
+  int32x2_t __ret_90; \
+  int32x2_t __s0_90 = __p0_90; \
+  int32x2_t __s1_90 = __p1_90; \
+  int32x2_t __s2_90 = __p2_90; \
+  __ret_90 = __s0_90 - __s1_90 * splat_lane_s32(__s2_90, __p3_90); \
+  __ret_90; \
+})
+#else
+#define vmls_lane_s32(__p0_91, __p1_91, __p2_91, __p3_91) __extension__ ({ \
+  int32x2_t __ret_91; \
+  int32x2_t __s0_91 = __p0_91; \
+  int32x2_t __s1_91 = __p1_91; \
+  int32x2_t __s2_91 = __p2_91; \
+  int32x2_t __rev0_91;  __rev0_91 = __builtin_shufflevector(__s0_91, __s0_91, 1, 0); \
+  int32x2_t __rev1_91;  __rev1_91 = __builtin_shufflevector(__s1_91, __s1_91, 1, 0); \
+  int32x2_t __rev2_91;  __rev2_91 = __builtin_shufflevector(__s2_91, __s2_91, 1, 0); \
+  __ret_91 = __rev0_91 - __rev1_91 * __noswap_splat_lane_s32(__rev2_91, __p3_91); \
+  __ret_91 = __builtin_shufflevector(__ret_91, __ret_91, 1, 0); \
+  __ret_91; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_lane_s16(__p0_92, __p1_92, __p2_92, __p3_92) __extension__ ({ \
+  int16x4_t __ret_92; \
+  int16x4_t __s0_92 = __p0_92; \
+  int16x4_t __s1_92 = __p1_92; \
+  int16x4_t __s2_92 = __p2_92; \
+  __ret_92 = __s0_92 - __s1_92 * splat_lane_s16(__s2_92, __p3_92); \
+  __ret_92; \
+})
+#else
+#define vmls_lane_s16(__p0_93, __p1_93, __p2_93, __p3_93) __extension__ ({ \
+  int16x4_t __ret_93; \
+  int16x4_t __s0_93 = __p0_93; \
+  int16x4_t __s1_93 = __p1_93; \
+  int16x4_t __s2_93 = __p2_93; \
+  int16x4_t __rev0_93;  __rev0_93 = __builtin_shufflevector(__s0_93, __s0_93, 3, 2, 1, 0); \
+  int16x4_t __rev1_93;  __rev1_93 = __builtin_shufflevector(__s1_93, __s1_93, 3, 2, 1, 0); \
+  int16x4_t __rev2_93;  __rev2_93 = __builtin_shufflevector(__s2_93, __s2_93, 3, 2, 1, 0); \
+  __ret_93 = __rev0_93 - __rev1_93 * __noswap_splat_lane_s16(__rev2_93, __p3_93); \
+  __ret_93 = __builtin_shufflevector(__ret_93, __ret_93, 3, 2, 1, 0); \
+  __ret_93; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlsq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 - __p1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlsq_n_u32(uint32x4_t __p0, uint32x4_t __p1, uint32_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * (uint32x4_t) {__p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmlsq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 - __p1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmlsq_n_u16(uint16x8_t __p0, uint16x8_t __p1, uint16_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * (uint16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmlsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+  float32x4_t __ret;
+  __ret = __p0 - __p1 * (float32x4_t) {__p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmlsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * (float32x4_t) {__p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlsq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 - __p1 * (int32x4_t) {__p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlsq_n_s32(int32x4_t __p0, int32x4_t __p1, int32_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * (int32x4_t) {__p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmlsq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 - __p1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmlsq_n_s16(int16x8_t __p0, int16x8_t __p1, int16_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * (int16x8_t) {__p2, __p2, __p2, __p2, __p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmls_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+  uint32x2_t __ret;
+  __ret = __p0 - __p1 * (uint32x2_t) {__p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmls_n_u32(uint32x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __rev1 * (uint32x2_t) {__p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmls_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+  uint16x4_t __ret;
+  __ret = __p0 - __p1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmls_n_u16(uint16x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * (uint16x4_t) {__p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmls_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+  float32x2_t __ret;
+  __ret = __p0 - __p1 * (float32x2_t) {__p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmls_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __rev1 * (float32x2_t) {__p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmls_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int32x2_t __ret;
+  __ret = __p0 - __p1 * (int32x2_t) {__p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmls_n_s32(int32x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __rev1 * (int32x2_t) {__p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmls_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int16x4_t __ret;
+  __ret = __p0 - __p1 * (int16x4_t) {__p2, __p2, __p2, __p2};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmls_n_s16(int16x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1 * (int16x4_t) {__p2, __p2, __p2, __p2};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vmov_n_p8(poly8_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vmov_n_p8(poly8_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vmov_n_p16(poly16_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vmov_n_p16(poly16_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vmovq_n_p8(poly8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vmovq_n_p8(poly8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vmovq_n_p16(poly16_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vmovq_n_p16(poly16_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vmovq_n_u8(uint8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vmovq_n_u8(uint8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmovq_n_u32(uint32_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmovq_n_u32(uint32_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmovq_n_u64(uint64_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmovq_n_u64(uint64_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmovq_n_u16(uint16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmovq_n_u16(uint16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vmovq_n_s8(int8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vmovq_n_s8(int8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmovq_n_f32(float32_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmovq_n_f32(float32_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmovq_n_f16(__p0) __extension__ ({ \
+  float16x8_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
+  __ret; \
+})
+#else
+#define vmovq_n_f16(__p0) __extension__ ({ \
+  float16x8_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16x8_t) {__s0, __s0, __s0, __s0, __s0, __s0, __s0, __s0}; \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmovq_n_s32(int32_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmovq_n_s32(int32_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmovq_n_s64(int64_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmovq_n_s64(int64_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmovq_n_s16(int16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmovq_n_s16(int16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmov_n_u8(uint8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vmov_n_u8(uint8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmov_n_u32(uint32_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmov_n_u32(uint32_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vmov_n_u64(uint64_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) {__p0};
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmov_n_u16(uint16_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmov_n_u16(uint16_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vmov_n_s8(int8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vmov_n_s8(int8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) {__p0, __p0, __p0, __p0, __p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmov_n_f32(float32_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmov_n_f32(float32_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmov_n_f16(__p0) __extension__ ({ \
+  float16x4_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
+  __ret; \
+})
+#else
+#define vmov_n_f16(__p0) __extension__ ({ \
+  float16x4_t __ret; \
+  float16_t __s0 = __p0; \
+  __ret = (float16x4_t) {__s0, __s0, __s0, __s0}; \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmov_n_s32(int32_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmov_n_s32(int32_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vmov_n_s64(int64_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) {__p0};
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmov_n_s16(int16_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmov_n_s16(int16_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) {__p0, __p0, __p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmovl_u8(uint8x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmovl_u8(uint8x8_t __p0) {
+  uint16x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vmovl_u8(uint8x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 49);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmovl_u32(uint32x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmovl_u32(uint32x2_t __p0) {
+  uint64x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmovl_u32(uint32x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 51);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmovl_u16(uint16x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmovl_u16(uint16x4_t __p0) {
+  uint32x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmovl_u16(uint16x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 50);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmovl_s8(int8x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmovl_s8(int8x8_t __p0) {
+  int16x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vmovl_s8(int8x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 33);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmovl_s32(int32x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmovl_s32(int32x2_t __p0) {
+  int64x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmovl_s32(int32x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 35);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmovl_s16(int16x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmovl_s16(int16x4_t __p0) {
+  int32x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vmovl_v((int8x8_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmovl_s16(int16x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vmovl_v((int8x8_t)__p0, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmovn_u32(uint32x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmovn_u32(uint32x4_t __p0) {
+  uint16x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vmovn_u32(uint32x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 17);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmovn_u64(uint64x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmovn_u64(uint64x2_t __p0) {
+  uint32x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vmovn_u64(uint64x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 18);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmovn_u16(uint16x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vmovn_u16(uint16x8_t __p0) {
+  uint8x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vmovn_u16(uint16x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 16);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmovn_s32(int32x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmovn_s32(int32x4_t __p0) {
+  int16x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vmovn_s32(int32x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmovn_s64(int64x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmovn_s64(int64x2_t __p0) {
+  int32x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vmovn_s64(int64x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vmovn_s16(int16x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vmovn_s16(int16x8_t __p0) {
+  int8x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vmovn_v((int8x16_t)__rev0, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vmovn_s16(int16x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vmovn_v((int8x16_t)__p0, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vmulq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vmulq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmulq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmulq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmulq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmulq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vmulq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vmulq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmulq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmulq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmulq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmulq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmulq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmulq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmul_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vmul_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmul_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmul_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmul_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmul_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vmul_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vmul_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmul_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmul_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmul_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmul_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmul_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmul_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vmul_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vmul_v((int8x8_t)__p0, (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vmul_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vmul_v((int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vmulq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vmulq_v((int8x16_t)__p0, (int8x16_t)__p1, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vmulq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vmulq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_lane_u32(__p0_94, __p1_94, __p2_94) __extension__ ({ \
+  uint32x4_t __ret_94; \
+  uint32x4_t __s0_94 = __p0_94; \
+  uint32x2_t __s1_94 = __p1_94; \
+  __ret_94 = __s0_94 * splatq_lane_u32(__s1_94, __p2_94); \
+  __ret_94; \
+})
+#else
+#define vmulq_lane_u32(__p0_95, __p1_95, __p2_95) __extension__ ({ \
+  uint32x4_t __ret_95; \
+  uint32x4_t __s0_95 = __p0_95; \
+  uint32x2_t __s1_95 = __p1_95; \
+  uint32x4_t __rev0_95;  __rev0_95 = __builtin_shufflevector(__s0_95, __s0_95, 3, 2, 1, 0); \
+  uint32x2_t __rev1_95;  __rev1_95 = __builtin_shufflevector(__s1_95, __s1_95, 1, 0); \
+  __ret_95 = __rev0_95 * __noswap_splatq_lane_u32(__rev1_95, __p2_95); \
+  __ret_95 = __builtin_shufflevector(__ret_95, __ret_95, 3, 2, 1, 0); \
+  __ret_95; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_lane_u16(__p0_96, __p1_96, __p2_96) __extension__ ({ \
+  uint16x8_t __ret_96; \
+  uint16x8_t __s0_96 = __p0_96; \
+  uint16x4_t __s1_96 = __p1_96; \
+  __ret_96 = __s0_96 * splatq_lane_u16(__s1_96, __p2_96); \
+  __ret_96; \
+})
+#else
+#define vmulq_lane_u16(__p0_97, __p1_97, __p2_97) __extension__ ({ \
+  uint16x8_t __ret_97; \
+  uint16x8_t __s0_97 = __p0_97; \
+  uint16x4_t __s1_97 = __p1_97; \
+  uint16x8_t __rev0_97;  __rev0_97 = __builtin_shufflevector(__s0_97, __s0_97, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x4_t __rev1_97;  __rev1_97 = __builtin_shufflevector(__s1_97, __s1_97, 3, 2, 1, 0); \
+  __ret_97 = __rev0_97 * __noswap_splatq_lane_u16(__rev1_97, __p2_97); \
+  __ret_97 = __builtin_shufflevector(__ret_97, __ret_97, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_97; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_lane_f32(__p0_98, __p1_98, __p2_98) __extension__ ({ \
+  float32x4_t __ret_98; \
+  float32x4_t __s0_98 = __p0_98; \
+  float32x2_t __s1_98 = __p1_98; \
+  __ret_98 = __s0_98 * splatq_lane_f32(__s1_98, __p2_98); \
+  __ret_98; \
+})
+#else
+#define vmulq_lane_f32(__p0_99, __p1_99, __p2_99) __extension__ ({ \
+  float32x4_t __ret_99; \
+  float32x4_t __s0_99 = __p0_99; \
+  float32x2_t __s1_99 = __p1_99; \
+  float32x4_t __rev0_99;  __rev0_99 = __builtin_shufflevector(__s0_99, __s0_99, 3, 2, 1, 0); \
+  float32x2_t __rev1_99;  __rev1_99 = __builtin_shufflevector(__s1_99, __s1_99, 1, 0); \
+  __ret_99 = __rev0_99 * __noswap_splatq_lane_f32(__rev1_99, __p2_99); \
+  __ret_99 = __builtin_shufflevector(__ret_99, __ret_99, 3, 2, 1, 0); \
+  __ret_99; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_lane_s32(__p0_100, __p1_100, __p2_100) __extension__ ({ \
+  int32x4_t __ret_100; \
+  int32x4_t __s0_100 = __p0_100; \
+  int32x2_t __s1_100 = __p1_100; \
+  __ret_100 = __s0_100 * splatq_lane_s32(__s1_100, __p2_100); \
+  __ret_100; \
+})
+#else
+#define vmulq_lane_s32(__p0_101, __p1_101, __p2_101) __extension__ ({ \
+  int32x4_t __ret_101; \
+  int32x4_t __s0_101 = __p0_101; \
+  int32x2_t __s1_101 = __p1_101; \
+  int32x4_t __rev0_101;  __rev0_101 = __builtin_shufflevector(__s0_101, __s0_101, 3, 2, 1, 0); \
+  int32x2_t __rev1_101;  __rev1_101 = __builtin_shufflevector(__s1_101, __s1_101, 1, 0); \
+  __ret_101 = __rev0_101 * __noswap_splatq_lane_s32(__rev1_101, __p2_101); \
+  __ret_101 = __builtin_shufflevector(__ret_101, __ret_101, 3, 2, 1, 0); \
+  __ret_101; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_lane_s16(__p0_102, __p1_102, __p2_102) __extension__ ({ \
+  int16x8_t __ret_102; \
+  int16x8_t __s0_102 = __p0_102; \
+  int16x4_t __s1_102 = __p1_102; \
+  __ret_102 = __s0_102 * splatq_lane_s16(__s1_102, __p2_102); \
+  __ret_102; \
+})
+#else
+#define vmulq_lane_s16(__p0_103, __p1_103, __p2_103) __extension__ ({ \
+  int16x8_t __ret_103; \
+  int16x8_t __s0_103 = __p0_103; \
+  int16x4_t __s1_103 = __p1_103; \
+  int16x8_t __rev0_103;  __rev0_103 = __builtin_shufflevector(__s0_103, __s0_103, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev1_103;  __rev1_103 = __builtin_shufflevector(__s1_103, __s1_103, 3, 2, 1, 0); \
+  __ret_103 = __rev0_103 * __noswap_splatq_lane_s16(__rev1_103, __p2_103); \
+  __ret_103 = __builtin_shufflevector(__ret_103, __ret_103, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_103; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_lane_u32(__p0_104, __p1_104, __p2_104) __extension__ ({ \
+  uint32x2_t __ret_104; \
+  uint32x2_t __s0_104 = __p0_104; \
+  uint32x2_t __s1_104 = __p1_104; \
+  __ret_104 = __s0_104 * splat_lane_u32(__s1_104, __p2_104); \
+  __ret_104; \
+})
+#else
+#define vmul_lane_u32(__p0_105, __p1_105, __p2_105) __extension__ ({ \
+  uint32x2_t __ret_105; \
+  uint32x2_t __s0_105 = __p0_105; \
+  uint32x2_t __s1_105 = __p1_105; \
+  uint32x2_t __rev0_105;  __rev0_105 = __builtin_shufflevector(__s0_105, __s0_105, 1, 0); \
+  uint32x2_t __rev1_105;  __rev1_105 = __builtin_shufflevector(__s1_105, __s1_105, 1, 0); \
+  __ret_105 = __rev0_105 * __noswap_splat_lane_u32(__rev1_105, __p2_105); \
+  __ret_105 = __builtin_shufflevector(__ret_105, __ret_105, 1, 0); \
+  __ret_105; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_lane_u16(__p0_106, __p1_106, __p2_106) __extension__ ({ \
+  uint16x4_t __ret_106; \
+  uint16x4_t __s0_106 = __p0_106; \
+  uint16x4_t __s1_106 = __p1_106; \
+  __ret_106 = __s0_106 * splat_lane_u16(__s1_106, __p2_106); \
+  __ret_106; \
+})
+#else
+#define vmul_lane_u16(__p0_107, __p1_107, __p2_107) __extension__ ({ \
+  uint16x4_t __ret_107; \
+  uint16x4_t __s0_107 = __p0_107; \
+  uint16x4_t __s1_107 = __p1_107; \
+  uint16x4_t __rev0_107;  __rev0_107 = __builtin_shufflevector(__s0_107, __s0_107, 3, 2, 1, 0); \
+  uint16x4_t __rev1_107;  __rev1_107 = __builtin_shufflevector(__s1_107, __s1_107, 3, 2, 1, 0); \
+  __ret_107 = __rev0_107 * __noswap_splat_lane_u16(__rev1_107, __p2_107); \
+  __ret_107 = __builtin_shufflevector(__ret_107, __ret_107, 3, 2, 1, 0); \
+  __ret_107; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_lane_f32(__p0_108, __p1_108, __p2_108) __extension__ ({ \
+  float32x2_t __ret_108; \
+  float32x2_t __s0_108 = __p0_108; \
+  float32x2_t __s1_108 = __p1_108; \
+  __ret_108 = __s0_108 * splat_lane_f32(__s1_108, __p2_108); \
+  __ret_108; \
+})
+#else
+#define vmul_lane_f32(__p0_109, __p1_109, __p2_109) __extension__ ({ \
+  float32x2_t __ret_109; \
+  float32x2_t __s0_109 = __p0_109; \
+  float32x2_t __s1_109 = __p1_109; \
+  float32x2_t __rev0_109;  __rev0_109 = __builtin_shufflevector(__s0_109, __s0_109, 1, 0); \
+  float32x2_t __rev1_109;  __rev1_109 = __builtin_shufflevector(__s1_109, __s1_109, 1, 0); \
+  __ret_109 = __rev0_109 * __noswap_splat_lane_f32(__rev1_109, __p2_109); \
+  __ret_109 = __builtin_shufflevector(__ret_109, __ret_109, 1, 0); \
+  __ret_109; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_lane_s32(__p0_110, __p1_110, __p2_110) __extension__ ({ \
+  int32x2_t __ret_110; \
+  int32x2_t __s0_110 = __p0_110; \
+  int32x2_t __s1_110 = __p1_110; \
+  __ret_110 = __s0_110 * splat_lane_s32(__s1_110, __p2_110); \
+  __ret_110; \
+})
+#else
+#define vmul_lane_s32(__p0_111, __p1_111, __p2_111) __extension__ ({ \
+  int32x2_t __ret_111; \
+  int32x2_t __s0_111 = __p0_111; \
+  int32x2_t __s1_111 = __p1_111; \
+  int32x2_t __rev0_111;  __rev0_111 = __builtin_shufflevector(__s0_111, __s0_111, 1, 0); \
+  int32x2_t __rev1_111;  __rev1_111 = __builtin_shufflevector(__s1_111, __s1_111, 1, 0); \
+  __ret_111 = __rev0_111 * __noswap_splat_lane_s32(__rev1_111, __p2_111); \
+  __ret_111 = __builtin_shufflevector(__ret_111, __ret_111, 1, 0); \
+  __ret_111; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_lane_s16(__p0_112, __p1_112, __p2_112) __extension__ ({ \
+  int16x4_t __ret_112; \
+  int16x4_t __s0_112 = __p0_112; \
+  int16x4_t __s1_112 = __p1_112; \
+  __ret_112 = __s0_112 * splat_lane_s16(__s1_112, __p2_112); \
+  __ret_112; \
+})
+#else
+#define vmul_lane_s16(__p0_113, __p1_113, __p2_113) __extension__ ({ \
+  int16x4_t __ret_113; \
+  int16x4_t __s0_113 = __p0_113; \
+  int16x4_t __s1_113 = __p1_113; \
+  int16x4_t __rev0_113;  __rev0_113 = __builtin_shufflevector(__s0_113, __s0_113, 3, 2, 1, 0); \
+  int16x4_t __rev1_113;  __rev1_113 = __builtin_shufflevector(__s1_113, __s1_113, 3, 2, 1, 0); \
+  __ret_113 = __rev0_113 * __noswap_splat_lane_s16(__rev1_113, __p2_113); \
+  __ret_113 = __builtin_shufflevector(__ret_113, __ret_113, 3, 2, 1, 0); \
+  __ret_113; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmulq_n_u32(uint32x4_t __p0, uint32_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 * (uint32x4_t) {__p1, __p1, __p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmulq_n_u32(uint32x4_t __p0, uint32_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __rev0 * (uint32x4_t) {__p1, __p1, __p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmulq_n_u16(uint16x8_t __p0, uint16_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 * (uint16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmulq_n_u16(uint16x8_t __p0, uint16_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 * (uint16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmulq_n_f32(float32x4_t __p0, float32_t __p1) {
+  float32x4_t __ret;
+  __ret = __p0 * (float32x4_t) {__p1, __p1, __p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmulq_n_f32(float32x4_t __p0, float32_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __rev0 * (float32x4_t) {__p1, __p1, __p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmulq_n_s32(int32x4_t __p0, int32_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 * (int32x4_t) {__p1, __p1, __p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmulq_n_s32(int32x4_t __p0, int32_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __rev0 * (int32x4_t) {__p1, __p1, __p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmulq_n_s16(int16x8_t __p0, int16_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 * (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmulq_n_s16(int16x8_t __p0, int16_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 * (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmul_n_u32(uint32x2_t __p0, uint32_t __p1) {
+  uint32x2_t __ret;
+  __ret = __p0 * (uint32x2_t) {__p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmul_n_u32(uint32x2_t __p0, uint32_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __rev0 * (uint32x2_t) {__p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmul_n_u16(uint16x4_t __p0, uint16_t __p1) {
+  uint16x4_t __ret;
+  __ret = __p0 * (uint16x4_t) {__p1, __p1, __p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmul_n_u16(uint16x4_t __p0, uint16_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __rev0 * (uint16x4_t) {__p1, __p1, __p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmul_n_f32(float32x2_t __p0, float32_t __p1) {
+  float32x2_t __ret;
+  __ret = __p0 * (float32x2_t) {__p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmul_n_f32(float32x2_t __p0, float32_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __rev0 * (float32x2_t) {__p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmul_n_s32(int32x2_t __p0, int32_t __p1) {
+  int32x2_t __ret;
+  __ret = __p0 * (int32x2_t) {__p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmul_n_s32(int32x2_t __p0, int32_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __rev0 * (int32x2_t) {__p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmul_n_s16(int16x4_t __p0, int16_t __p1) {
+  int16x4_t __ret;
+  __ret = __p0 * (int16x4_t) {__p1, __p1, __p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmul_n_s16(int16x4_t __p0, int16_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __rev0 * (int16x4_t) {__p1, __p1, __p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vmull_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 37);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vmull_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly16x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly16x8_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 37);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t __noswap_vmull_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 37);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmull_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmull_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vmull_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 49);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmull_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmull_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmull_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 51);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmull_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmull_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmull_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 50);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmull_s8(int8x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmull_s8(int8x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vmull_s8(int8x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 33);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmull_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmull_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmull_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmull_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmull_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmull_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_lane_u32(__p0_114, __p1_114, __p2_114) __extension__ ({ \
+  uint64x2_t __ret_114; \
+  uint32x2_t __s0_114 = __p0_114; \
+  uint32x2_t __s1_114 = __p1_114; \
+  __ret_114 = vmull_u32(__s0_114, splat_lane_u32(__s1_114, __p2_114)); \
+  __ret_114; \
+})
+#else
+#define vmull_lane_u32(__p0_115, __p1_115, __p2_115) __extension__ ({ \
+  uint64x2_t __ret_115; \
+  uint32x2_t __s0_115 = __p0_115; \
+  uint32x2_t __s1_115 = __p1_115; \
+  uint32x2_t __rev0_115;  __rev0_115 = __builtin_shufflevector(__s0_115, __s0_115, 1, 0); \
+  uint32x2_t __rev1_115;  __rev1_115 = __builtin_shufflevector(__s1_115, __s1_115, 1, 0); \
+  __ret_115 = __noswap_vmull_u32(__rev0_115, __noswap_splat_lane_u32(__rev1_115, __p2_115)); \
+  __ret_115 = __builtin_shufflevector(__ret_115, __ret_115, 1, 0); \
+  __ret_115; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_lane_u16(__p0_116, __p1_116, __p2_116) __extension__ ({ \
+  uint32x4_t __ret_116; \
+  uint16x4_t __s0_116 = __p0_116; \
+  uint16x4_t __s1_116 = __p1_116; \
+  __ret_116 = vmull_u16(__s0_116, splat_lane_u16(__s1_116, __p2_116)); \
+  __ret_116; \
+})
+#else
+#define vmull_lane_u16(__p0_117, __p1_117, __p2_117) __extension__ ({ \
+  uint32x4_t __ret_117; \
+  uint16x4_t __s0_117 = __p0_117; \
+  uint16x4_t __s1_117 = __p1_117; \
+  uint16x4_t __rev0_117;  __rev0_117 = __builtin_shufflevector(__s0_117, __s0_117, 3, 2, 1, 0); \
+  uint16x4_t __rev1_117;  __rev1_117 = __builtin_shufflevector(__s1_117, __s1_117, 3, 2, 1, 0); \
+  __ret_117 = __noswap_vmull_u16(__rev0_117, __noswap_splat_lane_u16(__rev1_117, __p2_117)); \
+  __ret_117 = __builtin_shufflevector(__ret_117, __ret_117, 3, 2, 1, 0); \
+  __ret_117; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_lane_s32(__p0_118, __p1_118, __p2_118) __extension__ ({ \
+  int64x2_t __ret_118; \
+  int32x2_t __s0_118 = __p0_118; \
+  int32x2_t __s1_118 = __p1_118; \
+  __ret_118 = vmull_s32(__s0_118, splat_lane_s32(__s1_118, __p2_118)); \
+  __ret_118; \
+})
+#else
+#define vmull_lane_s32(__p0_119, __p1_119, __p2_119) __extension__ ({ \
+  int64x2_t __ret_119; \
+  int32x2_t __s0_119 = __p0_119; \
+  int32x2_t __s1_119 = __p1_119; \
+  int32x2_t __rev0_119;  __rev0_119 = __builtin_shufflevector(__s0_119, __s0_119, 1, 0); \
+  int32x2_t __rev1_119;  __rev1_119 = __builtin_shufflevector(__s1_119, __s1_119, 1, 0); \
+  __ret_119 = __noswap_vmull_s32(__rev0_119, __noswap_splat_lane_s32(__rev1_119, __p2_119)); \
+  __ret_119 = __builtin_shufflevector(__ret_119, __ret_119, 1, 0); \
+  __ret_119; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_lane_s16(__p0_120, __p1_120, __p2_120) __extension__ ({ \
+  int32x4_t __ret_120; \
+  int16x4_t __s0_120 = __p0_120; \
+  int16x4_t __s1_120 = __p1_120; \
+  __ret_120 = vmull_s16(__s0_120, splat_lane_s16(__s1_120, __p2_120)); \
+  __ret_120; \
+})
+#else
+#define vmull_lane_s16(__p0_121, __p1_121, __p2_121) __extension__ ({ \
+  int32x4_t __ret_121; \
+  int16x4_t __s0_121 = __p0_121; \
+  int16x4_t __s1_121 = __p1_121; \
+  int16x4_t __rev0_121;  __rev0_121 = __builtin_shufflevector(__s0_121, __s0_121, 3, 2, 1, 0); \
+  int16x4_t __rev1_121;  __rev1_121 = __builtin_shufflevector(__s1_121, __s1_121, 3, 2, 1, 0); \
+  __ret_121 = __noswap_vmull_s16(__rev0_121, __noswap_splat_lane_s16(__rev1_121, __p2_121)); \
+  __ret_121 = __builtin_shufflevector(__ret_121, __ret_121, 3, 2, 1, 0); \
+  __ret_121; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmull_n_u32(uint32x2_t __p0, uint32_t __p1) {
+  uint64x2_t __ret;
+  __ret = vmull_u32(__p0, (uint32x2_t) {__p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmull_n_u32(uint32x2_t __p0, uint32_t __p1) {
+  uint64x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __noswap_vmull_u32(__rev0, (uint32x2_t) {__p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmull_n_u32(uint32x2_t __p0, uint32_t __p1) {
+  uint64x2_t __ret;
+  __ret = __noswap_vmull_u32(__p0, (uint32x2_t) {__p1, __p1});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmull_n_u16(uint16x4_t __p0, uint16_t __p1) {
+  uint32x4_t __ret;
+  __ret = vmull_u16(__p0, (uint16x4_t) {__p1, __p1, __p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmull_n_u16(uint16x4_t __p0, uint16_t __p1) {
+  uint32x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vmull_u16(__rev0, (uint16x4_t) {__p1, __p1, __p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmull_n_u16(uint16x4_t __p0, uint16_t __p1) {
+  uint32x4_t __ret;
+  __ret = __noswap_vmull_u16(__p0, (uint16x4_t) {__p1, __p1, __p1, __p1});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmull_n_s32(int32x2_t __p0, int32_t __p1) {
+  int64x2_t __ret;
+  __ret = vmull_s32(__p0, (int32x2_t) {__p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmull_n_s32(int32x2_t __p0, int32_t __p1) {
+  int64x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __noswap_vmull_s32(__rev0, (int32x2_t) {__p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmull_n_s32(int32x2_t __p0, int32_t __p1) {
+  int64x2_t __ret;
+  __ret = __noswap_vmull_s32(__p0, (int32x2_t) {__p1, __p1});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmull_n_s16(int16x4_t __p0, int16_t __p1) {
+  int32x4_t __ret;
+  __ret = vmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmull_n_s16(int16x4_t __p0, int16_t __p1) {
+  int32x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vmull_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmull_n_s16(int16x4_t __p0, int16_t __p1) {
+  int32x4_t __ret;
+  __ret = __noswap_vmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vmvn_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vmvn_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vmvnq_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vmvnq_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vmvnq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vmvnq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmvnq_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmvnq_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmvnq_u16(uint16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmvnq_u16(uint16x8_t __p0) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vmvnq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vmvnq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmvnq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmvnq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmvnq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmvnq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vmvn_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vmvn_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vmvn_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vmvn_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vmvn_u16(uint16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vmvn_u16(uint16x4_t __p0) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vmvn_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vmvn_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vmvn_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vmvn_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vmvn_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = ~__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vmvn_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = ~__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vnegq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vnegq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vnegq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vnegq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vnegq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vnegq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vnegq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vnegq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vneg_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vneg_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vneg_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vneg_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vneg_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vneg_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vneg_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vneg_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vornq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vornq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vornq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vornq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vornq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vornq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vornq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vornq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vornq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vornq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vornq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vornq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vornq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vornq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vornq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vornq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vorn_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vorn_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vorn_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vorn_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vorn_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vorn_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vorn_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vorn_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vorn_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vorn_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vorn_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vorn_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vorn_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __p0 | ~__p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vorn_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 | ~__rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vorrq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vorrq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vorrq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vorrq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vorrq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vorrq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vorrq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vorrq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vorrq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vorrq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vorrq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vorrq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vorrq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vorrq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vorrq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vorrq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vorr_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vorr_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vorr_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vorr_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vorr_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vorr_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vorr_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vorr_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vorr_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vorr_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vorr_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vorr_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vorr_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __p0 | __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vorr_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 | __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vpadalq_u8(uint16x8_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vpadalq_u8(uint16x8_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vpadalq_u32(uint64x2_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vpadalq_u32(uint64x2_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vpadalq_u16(uint32x4_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vpadalq_u16(uint32x4_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vpadalq_s8(int16x8_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vpadalq_s8(int16x8_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vpadalq_s32(int64x2_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vpadalq_s32(int64x2_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vpadalq_s16(int32x4_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vpadalq_s16(int32x4_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vpadalq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vpadal_u8(uint16x4_t __p0, uint8x8_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vpadal_u8(uint16x4_t __p0, uint8x8_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x1_t vpadal_u32(uint64x1_t __p0, uint32x2_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x1_t vpadal_u32(uint64x1_t __p0, uint32x2_t __p1) {
+  uint64x1_t __ret;
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__rev1, 19);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vpadal_u16(uint32x2_t __p0, uint16x4_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vpadal_u16(uint32x2_t __p0, uint16x4_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vpadal_s8(int16x4_t __p0, int8x8_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vpadal_s8(int16x4_t __p0, int8x8_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x1_t vpadal_s32(int64x1_t __p0, int32x2_t __p1) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x1_t vpadal_s32(int64x1_t __p0, int32x2_t __p1) {
+  int64x1_t __ret;
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x1_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__rev1, 3);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vpadal_s16(int32x2_t __p0, int16x4_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vpadal_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vpadal_s16(int32x2_t __p0, int16x4_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vpadal_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vpadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vpadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vpadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vpadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vpadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vpadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vpadd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vpadd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vpadd_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vpadd_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vpadd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vpadd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vpadd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vpadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vpadd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vpadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vpaddlq_u8(uint8x16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vpaddlq_u8(uint8x16_t __p0) {
+  uint16x8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vpaddlq_u32(uint32x4_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vpaddlq_u32(uint32x4_t __p0) {
+  uint64x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vpaddlq_u16(uint16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vpaddlq_u16(uint16x8_t __p0) {
+  uint32x4_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vpaddlq_s8(int8x16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vpaddlq_s8(int8x16_t __p0) {
+  int16x8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vpaddlq_s32(int32x4_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vpaddlq_s32(int32x4_t __p0) {
+  int64x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vpaddlq_s16(int16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vpaddlq_s16(int16x8_t __p0) {
+  int32x4_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vpaddlq_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vpaddl_u8(uint8x8_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vpaddl_u8(uint8x8_t __p0) {
+  uint16x4_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x1_t vpaddl_u32(uint32x2_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x1_t vpaddl_u32(uint32x2_t __p0) {
+  uint64x1_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 19);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vpaddl_u16(uint16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vpaddl_u16(uint16x4_t __p0) {
+  uint32x2_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vpaddl_s8(int8x8_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vpaddl_s8(int8x8_t __p0) {
+  int16x4_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x1_t vpaddl_s32(int32x2_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x1_t vpaddl_s32(int32x2_t __p0) {
+  int64x1_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64x1_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 3);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vpaddl_s16(int16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vpaddl_s16(int16x4_t __p0) {
+  int32x2_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vpaddl_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vpmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vpmax_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vpmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vpmax_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vpmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vpmax_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vpmax_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vpmax_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vpmax_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vpmax_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vpmax_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vpmax_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vpmax_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vpmax_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vpmax_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vpmax_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vpmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vpmin_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vpmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vpmin_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vpmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vpmin_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vpmin_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vpmin_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vpmin_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vpmin_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vpmin_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vpmin_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vpmin_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vpmin_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vpmin_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vpmin_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqabsq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqabsq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqabsq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqabsq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqabsq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqabsq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqabs_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqabs_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqabs_v((int8x8_t)__rev0, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqabs_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqabs_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqabs_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqabs_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqabs_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqabs_v((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vqaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vqaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vqaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vqaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vqaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vqaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vqadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vqadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vqadd_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vqadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vqadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqadd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqadd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqadd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqadd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vqadd_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqadd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqadd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vqdmlal_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqdmlal_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqdmlal_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlal_lane_s32(__p0_122, __p1_122, __p2_122, __p3_122) __extension__ ({ \
+  int64x2_t __ret_122; \
+  int64x2_t __s0_122 = __p0_122; \
+  int32x2_t __s1_122 = __p1_122; \
+  int32x2_t __s2_122 = __p2_122; \
+  __ret_122 = vqdmlal_s32(__s0_122, __s1_122, splat_lane_s32(__s2_122, __p3_122)); \
+  __ret_122; \
+})
+#else
+#define vqdmlal_lane_s32(__p0_123, __p1_123, __p2_123, __p3_123) __extension__ ({ \
+  int64x2_t __ret_123; \
+  int64x2_t __s0_123 = __p0_123; \
+  int32x2_t __s1_123 = __p1_123; \
+  int32x2_t __s2_123 = __p2_123; \
+  int64x2_t __rev0_123;  __rev0_123 = __builtin_shufflevector(__s0_123, __s0_123, 1, 0); \
+  int32x2_t __rev1_123;  __rev1_123 = __builtin_shufflevector(__s1_123, __s1_123, 1, 0); \
+  int32x2_t __rev2_123;  __rev2_123 = __builtin_shufflevector(__s2_123, __s2_123, 1, 0); \
+  __ret_123 = __noswap_vqdmlal_s32(__rev0_123, __rev1_123, __noswap_splat_lane_s32(__rev2_123, __p3_123)); \
+  __ret_123 = __builtin_shufflevector(__ret_123, __ret_123, 1, 0); \
+  __ret_123; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlal_lane_s16(__p0_124, __p1_124, __p2_124, __p3_124) __extension__ ({ \
+  int32x4_t __ret_124; \
+  int32x4_t __s0_124 = __p0_124; \
+  int16x4_t __s1_124 = __p1_124; \
+  int16x4_t __s2_124 = __p2_124; \
+  __ret_124 = vqdmlal_s16(__s0_124, __s1_124, splat_lane_s16(__s2_124, __p3_124)); \
+  __ret_124; \
+})
+#else
+#define vqdmlal_lane_s16(__p0_125, __p1_125, __p2_125, __p3_125) __extension__ ({ \
+  int32x4_t __ret_125; \
+  int32x4_t __s0_125 = __p0_125; \
+  int16x4_t __s1_125 = __p1_125; \
+  int16x4_t __s2_125 = __p2_125; \
+  int32x4_t __rev0_125;  __rev0_125 = __builtin_shufflevector(__s0_125, __s0_125, 3, 2, 1, 0); \
+  int16x4_t __rev1_125;  __rev1_125 = __builtin_shufflevector(__s1_125, __s1_125, 3, 2, 1, 0); \
+  int16x4_t __rev2_125;  __rev2_125 = __builtin_shufflevector(__s2_125, __s2_125, 3, 2, 1, 0); \
+  __ret_125 = __noswap_vqdmlal_s16(__rev0_125, __rev1_125, __noswap_splat_lane_s16(__rev2_125, __p3_125)); \
+  __ret_125 = __builtin_shufflevector(__ret_125, __ret_125, 3, 2, 1, 0); \
+  __ret_125; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = vqdmlal_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vqdmlal_s32(__rev0, __rev1, (int32x2_t) {__p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = __noswap_vqdmlal_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = vqdmlal_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vqdmlal_s16(__rev0, __rev1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = __noswap_vqdmlal_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vqdmlsl_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 35);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqdmlsl_v((int8x16_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqdmlsl_v((int8x16_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_lane_s32(__p0_126, __p1_126, __p2_126, __p3_126) __extension__ ({ \
+  int64x2_t __ret_126; \
+  int64x2_t __s0_126 = __p0_126; \
+  int32x2_t __s1_126 = __p1_126; \
+  int32x2_t __s2_126 = __p2_126; \
+  __ret_126 = vqdmlsl_s32(__s0_126, __s1_126, splat_lane_s32(__s2_126, __p3_126)); \
+  __ret_126; \
+})
+#else
+#define vqdmlsl_lane_s32(__p0_127, __p1_127, __p2_127, __p3_127) __extension__ ({ \
+  int64x2_t __ret_127; \
+  int64x2_t __s0_127 = __p0_127; \
+  int32x2_t __s1_127 = __p1_127; \
+  int32x2_t __s2_127 = __p2_127; \
+  int64x2_t __rev0_127;  __rev0_127 = __builtin_shufflevector(__s0_127, __s0_127, 1, 0); \
+  int32x2_t __rev1_127;  __rev1_127 = __builtin_shufflevector(__s1_127, __s1_127, 1, 0); \
+  int32x2_t __rev2_127;  __rev2_127 = __builtin_shufflevector(__s2_127, __s2_127, 1, 0); \
+  __ret_127 = __noswap_vqdmlsl_s32(__rev0_127, __rev1_127, __noswap_splat_lane_s32(__rev2_127, __p3_127)); \
+  __ret_127 = __builtin_shufflevector(__ret_127, __ret_127, 1, 0); \
+  __ret_127; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_lane_s16(__p0_128, __p1_128, __p2_128, __p3_128) __extension__ ({ \
+  int32x4_t __ret_128; \
+  int32x4_t __s0_128 = __p0_128; \
+  int16x4_t __s1_128 = __p1_128; \
+  int16x4_t __s2_128 = __p2_128; \
+  __ret_128 = vqdmlsl_s16(__s0_128, __s1_128, splat_lane_s16(__s2_128, __p3_128)); \
+  __ret_128; \
+})
+#else
+#define vqdmlsl_lane_s16(__p0_129, __p1_129, __p2_129, __p3_129) __extension__ ({ \
+  int32x4_t __ret_129; \
+  int32x4_t __s0_129 = __p0_129; \
+  int16x4_t __s1_129 = __p1_129; \
+  int16x4_t __s2_129 = __p2_129; \
+  int32x4_t __rev0_129;  __rev0_129 = __builtin_shufflevector(__s0_129, __s0_129, 3, 2, 1, 0); \
+  int16x4_t __rev1_129;  __rev1_129 = __builtin_shufflevector(__s1_129, __s1_129, 3, 2, 1, 0); \
+  int16x4_t __rev2_129;  __rev2_129 = __builtin_shufflevector(__s2_129, __s2_129, 3, 2, 1, 0); \
+  __ret_129 = __noswap_vqdmlsl_s16(__rev0_129, __rev1_129, __noswap_splat_lane_s16(__rev2_129, __p3_129)); \
+  __ret_129 = __builtin_shufflevector(__ret_129, __ret_129, 3, 2, 1, 0); \
+  __ret_129; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = vqdmlsl_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vqdmlsl_s32(__rev0, __rev1, (int32x2_t) {__p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = __noswap_vqdmlsl_s32(__p0, __p1, (int32x2_t) {__p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = vqdmlsl_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vqdmlsl_s16(__rev0, __rev1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = __noswap_vqdmlsl_s16(__p0, __p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vqdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vqdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vqdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vqdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
+  int32x4_t __ret;
+  __ret = vqdmulhq_s32(__p0, (int32x4_t) {__p1, __p1, __p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vqdmulhq_s32(__rev0, (int32x4_t) {__p1, __p1, __p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
+  int16x8_t __ret;
+  __ret = vqdmulhq_s16(__p0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vqdmulhq_s16(__rev0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
+  int32x2_t __ret;
+  __ret = vqdmulh_s32(__p0, (int32x2_t) {__p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __noswap_vqdmulh_s32(__rev0, (int32x2_t) {__p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
+  int16x4_t __ret;
+  __ret = vqdmulh_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vqdmulh_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vqdmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmull_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 35);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqdmull_v((int8x8_t)__rev0, (int8x8_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmull_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqdmull_v((int8x8_t)__p0, (int8x8_t)__p1, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmull_lane_s32(__p0_130, __p1_130, __p2_130) __extension__ ({ \
+  int64x2_t __ret_130; \
+  int32x2_t __s0_130 = __p0_130; \
+  int32x2_t __s1_130 = __p1_130; \
+  __ret_130 = vqdmull_s32(__s0_130, splat_lane_s32(__s1_130, __p2_130)); \
+  __ret_130; \
+})
+#else
+#define vqdmull_lane_s32(__p0_131, __p1_131, __p2_131) __extension__ ({ \
+  int64x2_t __ret_131; \
+  int32x2_t __s0_131 = __p0_131; \
+  int32x2_t __s1_131 = __p1_131; \
+  int32x2_t __rev0_131;  __rev0_131 = __builtin_shufflevector(__s0_131, __s0_131, 1, 0); \
+  int32x2_t __rev1_131;  __rev1_131 = __builtin_shufflevector(__s1_131, __s1_131, 1, 0); \
+  __ret_131 = __noswap_vqdmull_s32(__rev0_131, __noswap_splat_lane_s32(__rev1_131, __p2_131)); \
+  __ret_131 = __builtin_shufflevector(__ret_131, __ret_131, 1, 0); \
+  __ret_131; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmull_lane_s16(__p0_132, __p1_132, __p2_132) __extension__ ({ \
+  int32x4_t __ret_132; \
+  int16x4_t __s0_132 = __p0_132; \
+  int16x4_t __s1_132 = __p1_132; \
+  __ret_132 = vqdmull_s16(__s0_132, splat_lane_s16(__s1_132, __p2_132)); \
+  __ret_132; \
+})
+#else
+#define vqdmull_lane_s16(__p0_133, __p1_133, __p2_133) __extension__ ({ \
+  int32x4_t __ret_133; \
+  int16x4_t __s0_133 = __p0_133; \
+  int16x4_t __s1_133 = __p1_133; \
+  int16x4_t __rev0_133;  __rev0_133 = __builtin_shufflevector(__s0_133, __s0_133, 3, 2, 1, 0); \
+  int16x4_t __rev1_133;  __rev1_133 = __builtin_shufflevector(__s1_133, __s1_133, 3, 2, 1, 0); \
+  __ret_133 = __noswap_vqdmull_s16(__rev0_133, __noswap_splat_lane_s16(__rev1_133, __p2_133)); \
+  __ret_133 = __builtin_shufflevector(__ret_133, __ret_133, 3, 2, 1, 0); \
+  __ret_133; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_n_s32(int32x2_t __p0, int32_t __p1) {
+  int64x2_t __ret;
+  __ret = vqdmull_s32(__p0, (int32x2_t) {__p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_n_s32(int32x2_t __p0, int32_t __p1) {
+  int64x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __noswap_vqdmull_s32(__rev0, (int32x2_t) {__p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vqdmull_n_s32(int32x2_t __p0, int32_t __p1) {
+  int64x2_t __ret;
+  __ret = __noswap_vqdmull_s32(__p0, (int32x2_t) {__p1, __p1});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_n_s16(int16x4_t __p0, int16_t __p1) {
+  int32x4_t __ret;
+  __ret = vqdmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_n_s16(int16x4_t __p0, int16_t __p1) {
+  int32x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vqdmull_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqdmull_n_s16(int16x4_t __p0, int16_t __p1) {
+  int32x4_t __ret;
+  __ret = __noswap_vqdmull_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vqmovn_u32(uint32x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vqmovn_u32(uint32x4_t __p0) {
+  uint16x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vqmovn_u32(uint32x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 17);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vqmovn_u64(uint64x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vqmovn_u64(uint64x2_t __p0) {
+  uint32x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vqmovn_u64(uint64x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 18);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqmovn_u16(uint16x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqmovn_u16(uint16x8_t __p0) {
+  uint8x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vqmovn_u16(uint16x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 16);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqmovn_s32(int32x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqmovn_s32(int32x4_t __p0) {
+  int16x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vqmovn_s32(int32x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqmovn_s64(int64x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqmovn_s64(int64x2_t __p0) {
+  int32x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vqmovn_s64(int64x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqmovn_s16(int16x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqmovn_s16(int16x8_t __p0) {
+  int8x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__rev0, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vqmovn_s16(int16x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqmovn_v((int8x16_t)__p0, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vqmovun_s32(int32x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vqmovun_s32(int32x4_t __p0) {
+  uint16x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vqmovun_v((int8x16_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vqmovun_s32(int32x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 17);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vqmovun_s64(int64x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vqmovun_s64(int64x2_t __p0) {
+  uint32x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vqmovun_v((int8x16_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vqmovun_s64(int64x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 18);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqmovun_s16(int16x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqmovun_s16(int16x8_t __p0) {
+  uint8x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqmovun_v((int8x16_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vqmovun_s16(int16x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqmovun_v((int8x16_t)__p0, 16);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqnegq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqnegq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqnegq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqnegq_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqnegq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqnegq_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqneg_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqneg_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqneg_v((int8x8_t)__rev0, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqneg_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqneg_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqneg_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqneg_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqneg_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqneg_v((int8x8_t)__rev0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqrdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqrdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vqrdmulhq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqrdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqrdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vqrdmulhq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqrdmulhq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqrdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqrdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqrdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vqrdmulh_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqrdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqrdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqrdmulh_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vqrdmulh_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqrdmulh_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqrdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
+  int32x4_t __ret;
+  __ret = vqrdmulhq_s32(__p0, (int32x4_t) {__p1, __p1, __p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqrdmulhq_n_s32(int32x4_t __p0, int32_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vqrdmulhq_s32(__rev0, (int32x4_t) {__p1, __p1, __p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqrdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
+  int16x8_t __ret;
+  __ret = vqrdmulhq_s16(__p0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqrdmulhq_n_s16(int16x8_t __p0, int16_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vqrdmulhq_s16(__rev0, (int16x8_t) {__p1, __p1, __p1, __p1, __p1, __p1, __p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqrdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
+  int32x2_t __ret;
+  __ret = vqrdmulh_s32(__p0, (int32x2_t) {__p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqrdmulh_n_s32(int32x2_t __p0, int32_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __noswap_vqrdmulh_s32(__rev0, (int32x2_t) {__p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqrdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
+  int16x4_t __ret;
+  __ret = vqrdmulh_s16(__p0, (int16x4_t) {__p1, __p1, __p1, __p1});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqrdmulh_n_s16(int16x4_t __p0, int16_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vqrdmulh_s16(__rev0, (int16x4_t) {__p1, __p1, __p1, __p1});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vqrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vqrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vqrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vqrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vqrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vqrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vqrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vqrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vqrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vqrshl_u64(uint64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vqrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vqrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqrshl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqrshl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqrshl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqrshl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vqrshl_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqrshl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqrshl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vqrshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqrshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vqrshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqrshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vqrshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqrshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define vqrshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqrshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define vqrshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqrshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 0); \
+  __ret; \
+})
+#else
+#define vqrshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__rev0, __p1, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqrshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vqrshrn_n_v((int8x16_t)__s0, __p1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrun_n_s32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vqrshrun_n_s32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqrshrun_n_s32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrun_n_s64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vqrshrun_n_s64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqrshrun_n_s64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrun_n_s16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vqrshrun_n_s16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqrshrun_n_s16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vqrshrun_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vqshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vqshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vqshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vqshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vqshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vqshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vqshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vqshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vqshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vqshl_u64(uint64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vqshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vqshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqshl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqshl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqshl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqshl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vqshl_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqshl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqshl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlq_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 48); \
+  __ret; \
+})
+#else
+#define vqshlq_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlq_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#else
+#define vqshlq_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlq_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#else
+#define vqshlq_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlq_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#else
+#define vqshlq_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlq_n_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 32); \
+  __ret; \
+})
+#else
+#define vqshlq_n_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlq_n_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 34); \
+  __ret; \
+})
+#else
+#define vqshlq_n_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlq_n_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 35); \
+  __ret; \
+})
+#else
+#define vqshlq_n_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlq_n_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__s0, __p1, 33); \
+  __ret; \
+})
+#else
+#define vqshlq_n_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vqshlq_n_v((int8x16_t)__rev0, __p1, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshl_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vqshl_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshl_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vqshl_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vqshl_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (uint64x1_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vqshl_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vqshl_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshl_n_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 0); \
+  __ret; \
+})
+#else
+#define vqshl_n_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshl_n_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define vqshl_n_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vqshl_n_s64(__p0, __p1) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (int64x1_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vqshl_n_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define vqshl_n_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vqshl_n_v((int8x8_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshluq_n_s8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (uint8x16_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 48); \
+  __ret; \
+})
+#else
+#define vqshluq_n_s8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshluq_n_s32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#else
+#define vqshluq_n_s32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshluq_n_s64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#else
+#define vqshluq_n_s64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshluq_n_s16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_vqshluq_n_v((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#else
+#define vqshluq_n_s16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vqshluq_n_v((int8x16_t)__rev0, __p1, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlu_n_s8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vqshlu_n_s8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vqshlu_n_v((int8x8_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshlu_n_s32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vqshlu_n_s32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vqshlu_n_v((int8x8_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vqshlu_n_s64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (uint64x1_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vqshlu_n_s16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vqshlu_n_v((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vqshlu_n_s16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vqshlu_n_v((int8x8_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vqshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vqshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vqshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define vqshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define vqshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 0); \
+  __ret; \
+})
+#else
+#define vqshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__rev0, __p1, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vqshrn_n_v((int8x16_t)__s0, __p1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_n_s32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vqshrun_n_s32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vqshrun_n_v((int8x16_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqshrun_n_s32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_n_s64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vqshrun_n_s64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vqshrun_n_v((int8x16_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqshrun_n_s64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_n_s16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vqshrun_n_s16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vqshrun_n_v((int8x16_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vqshrun_n_s16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vqshrun_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vqsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vqsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vqsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vqsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vqsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vqsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqsubq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqsubq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vqsubq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vqsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vqsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vqsub_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vqsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vqsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqsub_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqsub_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vqsub_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vqsub_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vqsub_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vqsub_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqsub_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vqsub_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqsub_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vraddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vraddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vraddhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vraddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vraddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vraddhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vraddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vraddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vraddhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vraddhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vraddhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vraddhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vraddhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vraddhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vraddhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vraddhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vraddhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vraddhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vraddhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vrecpeq_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vrecpeq_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrecpeq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrecpeq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrecpeq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vrecpe_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vrecpe_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrecpe_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrecpe_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrecpe_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrecpsq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrecpsq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrecpsq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrecpsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrecps_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrecps_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrecps_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrecps_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vrev16_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vrev16_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vrev16q_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vrev16q_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vrev16q_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vrev16q_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vrev16q_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vrev16q_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6, 9, 8, 11, 10, 13, 12, 15, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vrev16_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vrev16_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vrev16_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vrev16_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vrev32_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vrev32_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vrev32_p16(poly16x4_t __p0) {
+  poly16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vrev32_p16(poly16x4_t __p0) {
+  poly16x4_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vrev32q_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vrev32q_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vrev32q_p16(poly16x8_t __p0) {
+  poly16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vrev32q_p16(poly16x8_t __p0) {
+  poly16x8_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vrev32q_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vrev32q_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vrev32q_u16(uint16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vrev32q_u16(uint16x8_t __p0) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vrev32q_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vrev32q_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vrev32q_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2, 5, 4, 7, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vrev32q_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2, 5, 4, 7, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vrev32_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vrev32_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vrev32_u16(uint16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vrev32_u16(uint16x4_t __p0) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vrev32_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vrev32_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vrev32_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vrev32_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vrev64_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vrev64_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vrev64_p16(poly16x4_t __p0) {
+  poly16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vrev64_p16(poly16x4_t __p0) {
+  poly16x4_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vrev64q_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vrev64q_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vrev64q_p16(poly16x8_t __p0) {
+  poly16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vrev64q_p16(poly16x8_t __p0) {
+  poly16x8_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vrev64q_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vrev64q_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vrev64q_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vrev64q_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vrev64q_u16(uint16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vrev64q_u16(uint16x8_t __p0) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vrev64q_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vrev64q_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrev64q_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrev64q_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vrev64q_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0, 3, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vrev64q_s32(int32x4_t __p0) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0, 3, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vrev64q_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vrev64q_s16(int16x8_t __p0) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vrev64_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vrev64_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vrev64_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vrev64_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vrev64_u16(uint16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vrev64_u16(uint16x4_t __p0) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vrev64_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vrev64_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrev64_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrev64_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vrev64_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vrev64_s32(int32x2_t __p0) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vrev64_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vrev64_s16(int16x4_t __p0) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vrev64q_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0, 7, 6, 5, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vrev64q_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0, 7, 6, 5, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vrev64_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vrev64_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vrhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vrhaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vrhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vrhaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vrhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vrhaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vrhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vrhaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vrhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vrhaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vrhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vrhaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vrhaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vrhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vrhadd_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vrhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vrhadd_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vrhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vrhadd_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vrhadd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vrhadd_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vrhadd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vrhadd_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vrhadd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vrhadd_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vrhadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vrshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vrshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vrshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vrshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vrshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vrshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vrshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vrshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vrshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vrshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vrshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vrshl_u64(uint64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vrshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vrshl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vrshl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vrshl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vrshl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vrshl_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vrshl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vrshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vrshl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vrshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrq_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 48); \
+  __ret; \
+})
+#else
+#define vrshrq_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrq_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#else
+#define vrshrq_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrq_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#else
+#define vrshrq_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrq_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#else
+#define vrshrq_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrq_n_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 32); \
+  __ret; \
+})
+#else
+#define vrshrq_n_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrq_n_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 34); \
+  __ret; \
+})
+#else
+#define vrshrq_n_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrq_n_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 35); \
+  __ret; \
+})
+#else
+#define vrshrq_n_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrq_n_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__s0, __p1, 33); \
+  __ret; \
+})
+#else
+#define vrshrq_n_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vrshrq_n_v((int8x16_t)__rev0, __p1, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshr_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vrshr_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshr_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vrshr_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vrshr_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (uint64x1_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vrshr_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vrshr_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshr_n_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 0); \
+  __ret; \
+})
+#else
+#define vrshr_n_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshr_n_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define vrshr_n_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vrshr_n_s64(__p0, __p1) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (int64x1_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vrshr_n_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define vrshr_n_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vrshr_n_v((int8x8_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vrshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vrshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vrshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vrshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vrshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vrshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define vrshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vrshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define vrshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vrshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 0); \
+  __ret; \
+})
+#else
+#define vrshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__rev0, __p1, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vrshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vrshrn_n_v((int8x16_t)__s0, __p1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vrsqrteq_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vrsqrteq_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrsqrteq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrsqrteq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrsqrteq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vrsqrte_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vrsqrte_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrsqrte_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrsqrte_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrsqrte_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrsqrtsq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrsqrtsq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrsqrts_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrsqrts_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrsqrts_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrsqrts_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  __ret = (uint8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
+  __ret; \
+})
+#else
+#define vrsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  __ret = (uint32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
+  __ret; \
+})
+#else
+#define vrsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  __ret = (uint64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+  __ret; \
+})
+#else
+#define vrsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  __ret = (uint16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
+  __ret; \
+})
+#else
+#define vrsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  __ret = (int8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
+  __ret; \
+})
+#else
+#define vrsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+  __ret; \
+})
+#else
+#define vrsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  __ret = (int64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
+  __ret; \
+})
+#else
+#define vrsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+  __ret; \
+})
+#else
+#define vrsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vrsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  __ret = (uint8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
+  __ret; \
+})
+#else
+#define vrsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  __ret = (uint32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
+  __ret; \
+})
+#else
+#define vrsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vrsra_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  uint64x1_t __s1 = __p1; \
+  __ret = (uint64x1_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vrsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  __ret = (uint16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
+  __ret; \
+})
+#else
+#define vrsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  __ret = (int8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
+  __ret; \
+})
+#else
+#define vrsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vrsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vrsra_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  int64x1_t __s1 = __p1; \
+  __ret = (int64x1_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vrsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vrsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vrsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vrsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vrsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vrsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vrsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vrsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vrsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vrsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vrsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vrsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vrsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vrsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vrsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vrsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vrsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vrsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vrsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vrsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vrsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vrsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8_t __s0 = __p0; \
+  poly8x8_t __s1 = __p1; \
+  __ret = (poly8x8_t) __builtin_neon_vset_lane_i8(__s0, (poly8x8_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vset_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8_t __s0 = __p0; \
+  poly8x8_t __s1 = __p1; \
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x8_t) __builtin_neon_vset_lane_i8(__s0, (poly8x8_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vset_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8_t __s0 = __p0; \
+  poly8x8_t __s1 = __p1; \
+  __ret = (poly8x8_t) __builtin_neon_vset_lane_i8(__s0, (poly8x8_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16_t __s0 = __p0; \
+  poly16x4_t __s1 = __p1; \
+  __ret = (poly16x4_t) __builtin_neon_vset_lane_i16(__s0, (poly16x4_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vset_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16_t __s0 = __p0; \
+  poly16x4_t __s1 = __p1; \
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (poly16x4_t) __builtin_neon_vset_lane_i16(__s0, (poly16x4_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vset_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16_t __s0 = __p0; \
+  poly16x4_t __s1 = __p1; \
+  __ret = (poly16x4_t) __builtin_neon_vset_lane_i16(__s0, (poly16x4_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8_t __s0 = __p0; \
+  poly8x16_t __s1 = __p1; \
+  __ret = (poly8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (poly8x16_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8_t __s0 = __p0; \
+  poly8x16_t __s1 = __p1; \
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (poly8x16_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8_t __s0 = __p0; \
+  poly8x16_t __s1 = __p1; \
+  __ret = (poly8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (poly8x16_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16_t __s0 = __p0; \
+  poly16x8_t __s1 = __p1; \
+  __ret = (poly16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (poly16x8_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16_t __s0 = __p0; \
+  poly16x8_t __s1 = __p1; \
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (poly16x8_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16_t __s0 = __p0; \
+  poly16x8_t __s1 = __p1; \
+  __ret = (poly16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (poly16x8_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  __ret = (uint8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  __ret = (uint8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  __ret = (uint32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  __ret = (uint32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  __ret = (uint64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  __ret = (uint64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  __ret = (uint16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  __ret = (uint16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  __ret = (int8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  __ret = (int8x16_t) __builtin_neon_vsetq_lane_i8(__s0, (int8x16_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4_t __ret; \
+  float32_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  __ret = (float32x4_t) __builtin_neon_vsetq_lane_f32(__s0, (float32x4_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4_t __ret; \
+  float32_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (float32x4_t) __builtin_neon_vsetq_lane_f32(__s0, (float32x4_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4_t __ret; \
+  float32_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  __ret = (float32x4_t) __builtin_neon_vsetq_lane_f32(__s0, (float32x4_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vsetq_lane_i32(__s0, (int32x4_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  __ret = (int64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  __ret = (int64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (int64x2_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vsetq_lane_i16(__s0, (int16x8_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  __ret = (uint8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vset_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vset_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  __ret = (uint8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  __ret = (uint32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vset_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vset_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  __ret = (uint32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#define vset_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64_t __s0 = __p0; \
+  uint64x1_t __s1 = __p1; \
+  __ret = (uint64x1_t) __builtin_neon_vset_lane_i64(__s0, (int64x1_t)__s1, __p2); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  __ret = (uint16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vset_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vset_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  __ret = (uint16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  __ret = (int8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vset_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vset_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  __ret = (int8x8_t) __builtin_neon_vset_lane_i8(__s0, (int8x8_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2_t __ret; \
+  float32_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  __ret = (float32x2_t) __builtin_neon_vset_lane_f32(__s0, (float32x2_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vset_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2_t __ret; \
+  float32_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (float32x2_t) __builtin_neon_vset_lane_f32(__s0, (float32x2_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vset_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2_t __ret; \
+  float32_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  __ret = (float32x2_t) __builtin_neon_vset_lane_f32(__s0, (float32x2_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vset_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vset_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vset_lane_i32(__s0, (int32x2_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#define vset_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1_t __ret; \
+  int64_t __s0 = __p0; \
+  int64x1_t __s1 = __p1; \
+  __ret = (int64x1_t) __builtin_neon_vset_lane_i64(__s0, (int64x1_t)__s1, __p2); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vset_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vset_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vset_lane_i16(__s0, (int16x4_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vshlq_u8(uint8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vshlq_u32(uint32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vshlq_u64(uint64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vshlq_u16(uint16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vshlq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vshlq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vshlq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vshlq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vshlq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vshlq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vshl_u8(uint8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vshl_u32(uint32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vshl_u64(uint64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vshl_u16(uint16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vshl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vshl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vshl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vshl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vshl_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vshl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vshl_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vshl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vshl_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshlq_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 48); \
+  __ret; \
+})
+#else
+#define vshlq_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshlq_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#else
+#define vshlq_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshlq_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#else
+#define vshlq_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshlq_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#else
+#define vshlq_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshlq_n_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 32); \
+  __ret; \
+})
+#else
+#define vshlq_n_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshlq_n_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 34); \
+  __ret; \
+})
+#else
+#define vshlq_n_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshlq_n_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 35); \
+  __ret; \
+})
+#else
+#define vshlq_n_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshlq_n_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__s0, __p1, 33); \
+  __ret; \
+})
+#else
+#define vshlq_n_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vshlq_n_v((int8x16_t)__rev0, __p1, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshl_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vshl_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshl_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vshl_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vshl_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (uint64x1_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vshl_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vshl_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshl_n_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 0); \
+  __ret; \
+})
+#else
+#define vshl_n_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshl_n_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define vshl_n_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vshl_n_s64(__p0, __p1) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (int64x1_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vshl_n_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define vshl_n_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vshl_n_v((int8x8_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_n_u8(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 49); \
+  __ret; \
+})
+#else
+#define vshll_n_u8(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshll_n_u8(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 49); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_n_u32(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 51); \
+  __ret; \
+})
+#else
+#define vshll_n_u32(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshll_n_u32(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 51); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_n_u16(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 50); \
+  __ret; \
+})
+#else
+#define vshll_n_u16(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshll_n_u16(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 50); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_n_s8(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 33); \
+  __ret; \
+})
+#else
+#define vshll_n_s8(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshll_n_s8(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 33); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_n_s32(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 35); \
+  __ret; \
+})
+#else
+#define vshll_n_s32(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshll_n_s32(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 35); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_n_s16(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 34); \
+  __ret; \
+})
+#else
+#define vshll_n_s16(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__rev0, __p1, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshll_n_s16(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_vshll_n_v((int8x8_t)__s0, __p1, 34); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrq_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 48); \
+  __ret; \
+})
+#else
+#define vshrq_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrq_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 50); \
+  __ret; \
+})
+#else
+#define vshrq_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrq_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#else
+#define vshrq_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrq_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 49); \
+  __ret; \
+})
+#else
+#define vshrq_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrq_n_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 32); \
+  __ret; \
+})
+#else
+#define vshrq_n_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrq_n_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 34); \
+  __ret; \
+})
+#else
+#define vshrq_n_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrq_n_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 35); \
+  __ret; \
+})
+#else
+#define vshrq_n_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrq_n_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__s0, __p1, 33); \
+  __ret; \
+})
+#else
+#define vshrq_n_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vshrq_n_v((int8x16_t)__rev0, __p1, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshr_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vshr_n_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshr_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vshr_n_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vshr_n_u64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (uint64x1_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vshr_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vshr_n_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshr_n_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 0); \
+  __ret; \
+})
+#else
+#define vshr_n_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshr_n_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define vshr_n_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vshr_n_s64(__p0, __p1) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (int64x1_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vshr_n_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define vshr_n_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vshr_n_v((int8x8_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#else
+#define vshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshrn_n_u32(__p0, __p1) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 17); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#else
+#define vshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshrn_n_u64(__p0, __p1) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 18); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#else
+#define vshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshrn_n_u16(__p0, __p1) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 16); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 1); \
+  __ret; \
+})
+#else
+#define vshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshrn_n_s32(__p0, __p1) __extension__ ({ \
+  int16x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int16x4_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 2); \
+  __ret; \
+})
+#else
+#define vshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshrn_n_s64(__p0, __p1) __extension__ ({ \
+  int32x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int32x2_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 0); \
+  __ret; \
+})
+#else
+#define vshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__rev0, __p1, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vshrn_n_s16(__p0, __p1) __extension__ ({ \
+  int8x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int8x8_t) __builtin_neon_vshrn_n_v((int8x16_t)__s0, __p1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsli_n_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  poly8x8_t __s1 = __p1; \
+  __ret = (poly8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 4); \
+  __ret; \
+})
+#else
+#define vsli_n_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  poly8x8_t __s1 = __p1; \
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 4); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsli_n_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  poly16x4_t __s1 = __p1; \
+  __ret = (poly16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 5); \
+  __ret; \
+})
+#else
+#define vsli_n_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  poly16x4_t __s1 = __p1; \
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (poly16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 5); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  poly8x16_t __s1 = __p1; \
+  __ret = (poly8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 36); \
+  __ret; \
+})
+#else
+#define vsliq_n_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  poly8x16_t __s1 = __p1; \
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 36); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  poly16x8_t __s1 = __p1; \
+  __ret = (poly16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 37); \
+  __ret; \
+})
+#else
+#define vsliq_n_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  poly16x8_t __s1 = __p1; \
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 37); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  __ret = (uint8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
+  __ret; \
+})
+#else
+#define vsliq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  __ret = (uint32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
+  __ret; \
+})
+#else
+#define vsliq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  __ret = (uint64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+  __ret; \
+})
+#else
+#define vsliq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  __ret = (uint16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
+  __ret; \
+})
+#else
+#define vsliq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  __ret = (int8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
+  __ret; \
+})
+#else
+#define vsliq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+  __ret; \
+})
+#else
+#define vsliq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  __ret = (int64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
+  __ret; \
+})
+#else
+#define vsliq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+  __ret; \
+})
+#else
+#define vsliq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsli_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  __ret = (uint8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
+  __ret; \
+})
+#else
+#define vsli_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsli_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  __ret = (uint32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
+  __ret; \
+})
+#else
+#define vsli_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vsli_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  uint64x1_t __s1 = __p1; \
+  __ret = (uint64x1_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vsli_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  __ret = (uint16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
+  __ret; \
+})
+#else
+#define vsli_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsli_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  __ret = (int8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
+  __ret; \
+})
+#else
+#define vsli_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsli_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vsli_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vsli_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  int64x1_t __s1 = __p1; \
+  __ret = (int64x1_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vsli_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vsli_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vsli_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  __ret = (uint8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
+  __ret; \
+})
+#else
+#define vsraq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  __ret = (uint32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
+  __ret; \
+})
+#else
+#define vsraq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  __ret = (uint64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+  __ret; \
+})
+#else
+#define vsraq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  __ret = (uint16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
+  __ret; \
+})
+#else
+#define vsraq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  __ret = (int8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
+  __ret; \
+})
+#else
+#define vsraq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+  __ret; \
+})
+#else
+#define vsraq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  __ret = (int64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
+  __ret; \
+})
+#else
+#define vsraq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+  __ret; \
+})
+#else
+#define vsraq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vsraq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  __ret = (uint8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
+  __ret; \
+})
+#else
+#define vsra_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  __ret = (uint32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
+  __ret; \
+})
+#else
+#define vsra_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vsra_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  uint64x1_t __s1 = __p1; \
+  __ret = (uint64x1_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  __ret = (uint16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
+  __ret; \
+})
+#else
+#define vsra_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  __ret = (int8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
+  __ret; \
+})
+#else
+#define vsra_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vsra_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vsra_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  int64x1_t __s1 = __p1; \
+  __ret = (int64x1_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vsra_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vsra_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsri_n_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  poly8x8_t __s1 = __p1; \
+  __ret = (poly8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 4); \
+  __ret; \
+})
+#else
+#define vsri_n_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  poly8x8_t __s1 = __p1; \
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 4); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsri_n_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  poly16x4_t __s1 = __p1; \
+  __ret = (poly16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 5); \
+  __ret; \
+})
+#else
+#define vsri_n_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  poly16x4_t __s1 = __p1; \
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (poly16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 5); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  poly8x16_t __s1 = __p1; \
+  __ret = (poly8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 36); \
+  __ret; \
+})
+#else
+#define vsriq_n_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  poly8x16_t __s1 = __p1; \
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 36); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  poly16x8_t __s1 = __p1; \
+  __ret = (poly16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 37); \
+  __ret; \
+})
+#else
+#define vsriq_n_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  poly16x8_t __s1 = __p1; \
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 37); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  __ret = (uint8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 48); \
+  __ret; \
+})
+#else
+#define vsriq_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __s1 = __p1; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 48); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  __ret = (uint32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 50); \
+  __ret; \
+})
+#else
+#define vsriq_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  __ret = (uint64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+  __ret; \
+})
+#else
+#define vsriq_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  __ret = (uint16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 49); \
+  __ret; \
+})
+#else
+#define vsriq_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __s1 = __p1; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 49); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  __ret = (int8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 32); \
+  __ret; \
+})
+#else
+#define vsriq_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __s1 = __p1; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x16_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 32); \
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+  __ret; \
+})
+#else
+#define vsriq_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  __ret = (int64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 35); \
+  __ret; \
+})
+#else
+#define vsriq_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+  __ret; \
+})
+#else
+#define vsriq_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsri_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  __ret = (uint8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 16); \
+  __ret; \
+})
+#else
+#define vsri_n_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __s1 = __p1; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 16); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsri_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  __ret = (uint32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 18); \
+  __ret; \
+})
+#else
+#define vsri_n_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __s1 = __p1; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 18); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vsri_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  uint64x1_t __s1 = __p1; \
+  __ret = (uint64x1_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 19); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vsri_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  __ret = (uint16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 17); \
+  __ret; \
+})
+#else
+#define vsri_n_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __s1 = __p1; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (uint16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 17); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsri_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  __ret = (int8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 0); \
+  __ret; \
+})
+#else
+#define vsri_n_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __s1 = __p1; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8x8_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 0); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsri_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vsri_n_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vsri_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  int64x1_t __s1 = __p1; \
+  __ret = (int64x1_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vsri_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vsri_n_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vsri_n_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_p8(__p0, __p1) __extension__ ({ \
+  poly8x8_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 4); \
+})
+#else
+#define vst1_p8(__p0, __p1) __extension__ ({ \
+  poly8x8_t __s1 = __p1; \
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_p16(__p0, __p1) __extension__ ({ \
+  poly16x4_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 5); \
+})
+#else
+#define vst1_p16(__p0, __p1) __extension__ ({ \
+  poly16x4_t __s1 = __p1; \
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p8(__p0, __p1) __extension__ ({ \
+  poly8x16_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 36); \
+})
+#else
+#define vst1q_p8(__p0, __p1) __extension__ ({ \
+  poly8x16_t __s1 = __p1; \
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p16(__p0, __p1) __extension__ ({ \
+  poly16x8_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 37); \
+})
+#else
+#define vst1q_p16(__p0, __p1) __extension__ ({ \
+  poly16x8_t __s1 = __p1; \
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 48); \
+})
+#else
+#define vst1q_u8(__p0, __p1) __extension__ ({ \
+  uint8x16_t __s1 = __p1; \
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 50); \
+})
+#else
+#define vst1q_u32(__p0, __p1) __extension__ ({ \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 51); \
+})
+#else
+#define vst1q_u64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 49); \
+})
+#else
+#define vst1q_u16(__p0, __p1) __extension__ ({ \
+  uint16x8_t __s1 = __p1; \
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 32); \
+})
+#else
+#define vst1q_s8(__p0, __p1) __extension__ ({ \
+  int8x16_t __s1 = __p1; \
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f32(__p0, __p1) __extension__ ({ \
+  float32x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 41); \
+})
+#else
+#define vst1q_f32(__p0, __p1) __extension__ ({ \
+  float32x4_t __s1 = __p1; \
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 34); \
+})
+#else
+#define vst1q_s32(__p0, __p1) __extension__ ({ \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 35); \
+})
+#else
+#define vst1q_s64(__p0, __p1) __extension__ ({ \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 35); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 33); \
+})
+#else
+#define vst1q_s16(__p0, __p1) __extension__ ({ \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 16); \
+})
+#else
+#define vst1_u8(__p0, __p1) __extension__ ({ \
+  uint8x8_t __s1 = __p1; \
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 18); \
+})
+#else
+#define vst1_u32(__p0, __p1) __extension__ ({ \
+  uint32x2_t __s1 = __p1; \
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 18); \
+})
+#endif
+
+#define vst1_u64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 19); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 17); \
+})
+#else
+#define vst1_u16(__p0, __p1) __extension__ ({ \
+  uint16x4_t __s1 = __p1; \
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 0); \
+})
+#else
+#define vst1_s8(__p0, __p1) __extension__ ({ \
+  int8x8_t __s1 = __p1; \
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_f32(__p0, __p1) __extension__ ({ \
+  float32x2_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 9); \
+})
+#else
+#define vst1_f32(__p0, __p1) __extension__ ({ \
+  float32x2_t __s1 = __p1; \
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 2); \
+})
+#else
+#define vst1_s32(__p0, __p1) __extension__ ({ \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 2); \
+})
+#endif
+
+#define vst1_s64(__p0, __p1) __extension__ ({ \
+  int64x1_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 3); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 1); \
+})
+#else
+#define vst1_s16(__p0, __p1) __extension__ ({ \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 4); \
+})
+#else
+#define vst1_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8_t __s1 = __p1; \
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 5); \
+})
+#else
+#define vst1_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4_t __s1 = __p1; \
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 36); \
+})
+#else
+#define vst1q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16_t __s1 = __p1; \
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 37); \
+})
+#else
+#define vst1q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8_t __s1 = __p1; \
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 48); \
+})
+#else
+#define vst1q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16_t __s1 = __p1; \
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 50); \
+})
+#else
+#define vst1q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 51); \
+})
+#else
+#define vst1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 49); \
+})
+#else
+#define vst1q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8_t __s1 = __p1; \
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 32); \
+})
+#else
+#define vst1q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16_t __s1 = __p1; \
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 41); \
+})
+#else
+#define vst1q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4_t __s1 = __p1; \
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 34); \
+})
+#else
+#define vst1q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 35); \
+})
+#else
+#define vst1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 35); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 33); \
+})
+#else
+#define vst1q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 16); \
+})
+#else
+#define vst1_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8_t __s1 = __p1; \
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 18); \
+})
+#else
+#define vst1_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2_t __s1 = __p1; \
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 18); \
+})
+#endif
+
+#define vst1_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 19); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 17); \
+})
+#else
+#define vst1_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4_t __s1 = __p1; \
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 0); \
+})
+#else
+#define vst1_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8_t __s1 = __p1; \
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 9); \
+})
+#else
+#define vst1_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2_t __s1 = __p1; \
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 2); \
+})
+#else
+#define vst1_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 2); \
+})
+#endif
+
+#define vst1_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 3); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 1); \
+})
+#else
+#define vst1_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_p8_x2(__p0, __p1) __extension__ ({ \
+  poly8x8x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 4); \
+})
+#else
+#define vst1_p8_x2(__p0, __p1) __extension__ ({ \
+  poly8x8x2_t __s1 = __p1; \
+  poly8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_p16_x2(__p0, __p1) __extension__ ({ \
+  poly16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 5); \
+})
+#else
+#define vst1_p16_x2(__p0, __p1) __extension__ ({ \
+  poly16x4x2_t __s1 = __p1; \
+  poly16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p8_x2(__p0, __p1) __extension__ ({ \
+  poly8x16x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 36); \
+})
+#else
+#define vst1q_p8_x2(__p0, __p1) __extension__ ({ \
+  poly8x16x2_t __s1 = __p1; \
+  poly8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p16_x2(__p0, __p1) __extension__ ({ \
+  poly16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 37); \
+})
+#else
+#define vst1q_p16_x2(__p0, __p1) __extension__ ({ \
+  poly16x8x2_t __s1 = __p1; \
+  poly16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u8_x2(__p0, __p1) __extension__ ({ \
+  uint8x16x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 48); \
+})
+#else
+#define vst1q_u8_x2(__p0, __p1) __extension__ ({ \
+  uint8x16x2_t __s1 = __p1; \
+  uint8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u32_x2(__p0, __p1) __extension__ ({ \
+  uint32x4x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 50); \
+})
+#else
+#define vst1q_u32_x2(__p0, __p1) __extension__ ({ \
+  uint32x4x2_t __s1 = __p1; \
+  uint32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u64_x2(__p0, __p1) __extension__ ({ \
+  uint64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 51); \
+})
+#else
+#define vst1q_u64_x2(__p0, __p1) __extension__ ({ \
+  uint64x2x2_t __s1 = __p1; \
+  uint64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u16_x2(__p0, __p1) __extension__ ({ \
+  uint16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 49); \
+})
+#else
+#define vst1q_u16_x2(__p0, __p1) __extension__ ({ \
+  uint16x8x2_t __s1 = __p1; \
+  uint16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s8_x2(__p0, __p1) __extension__ ({ \
+  int8x16x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 32); \
+})
+#else
+#define vst1q_s8_x2(__p0, __p1) __extension__ ({ \
+  int8x16x2_t __s1 = __p1; \
+  int8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f32_x2(__p0, __p1) __extension__ ({ \
+  float32x4x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 41); \
+})
+#else
+#define vst1q_f32_x2(__p0, __p1) __extension__ ({ \
+  float32x4x2_t __s1 = __p1; \
+  float32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s32_x2(__p0, __p1) __extension__ ({ \
+  int32x4x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 34); \
+})
+#else
+#define vst1q_s32_x2(__p0, __p1) __extension__ ({ \
+  int32x4x2_t __s1 = __p1; \
+  int32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s64_x2(__p0, __p1) __extension__ ({ \
+  int64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 35); \
+})
+#else
+#define vst1q_s64_x2(__p0, __p1) __extension__ ({ \
+  int64x2x2_t __s1 = __p1; \
+  int64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 35); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s16_x2(__p0, __p1) __extension__ ({ \
+  int16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 33); \
+})
+#else
+#define vst1q_s16_x2(__p0, __p1) __extension__ ({ \
+  int16x8x2_t __s1 = __p1; \
+  int16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u8_x2(__p0, __p1) __extension__ ({ \
+  uint8x8x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 16); \
+})
+#else
+#define vst1_u8_x2(__p0, __p1) __extension__ ({ \
+  uint8x8x2_t __s1 = __p1; \
+  uint8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u32_x2(__p0, __p1) __extension__ ({ \
+  uint32x2x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 18); \
+})
+#else
+#define vst1_u32_x2(__p0, __p1) __extension__ ({ \
+  uint32x2x2_t __s1 = __p1; \
+  uint32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 18); \
+})
+#endif
+
+#define vst1_u64_x2(__p0, __p1) __extension__ ({ \
+  uint64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 19); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u16_x2(__p0, __p1) __extension__ ({ \
+  uint16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 17); \
+})
+#else
+#define vst1_u16_x2(__p0, __p1) __extension__ ({ \
+  uint16x4x2_t __s1 = __p1; \
+  uint16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s8_x2(__p0, __p1) __extension__ ({ \
+  int8x8x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 0); \
+})
+#else
+#define vst1_s8_x2(__p0, __p1) __extension__ ({ \
+  int8x8x2_t __s1 = __p1; \
+  int8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_f32_x2(__p0, __p1) __extension__ ({ \
+  float32x2x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 9); \
+})
+#else
+#define vst1_f32_x2(__p0, __p1) __extension__ ({ \
+  float32x2x2_t __s1 = __p1; \
+  float32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s32_x2(__p0, __p1) __extension__ ({ \
+  int32x2x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 2); \
+})
+#else
+#define vst1_s32_x2(__p0, __p1) __extension__ ({ \
+  int32x2x2_t __s1 = __p1; \
+  int32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 2); \
+})
+#endif
+
+#define vst1_s64_x2(__p0, __p1) __extension__ ({ \
+  int64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 3); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s16_x2(__p0, __p1) __extension__ ({ \
+  int16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 1); \
+})
+#else
+#define vst1_s16_x2(__p0, __p1) __extension__ ({ \
+  int16x4x2_t __s1 = __p1; \
+  int16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_p8_x3(__p0, __p1) __extension__ ({ \
+  poly8x8x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 4); \
+})
+#else
+#define vst1_p8_x3(__p0, __p1) __extension__ ({ \
+  poly8x8x3_t __s1 = __p1; \
+  poly8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_p16_x3(__p0, __p1) __extension__ ({ \
+  poly16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 5); \
+})
+#else
+#define vst1_p16_x3(__p0, __p1) __extension__ ({ \
+  poly16x4x3_t __s1 = __p1; \
+  poly16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p8_x3(__p0, __p1) __extension__ ({ \
+  poly8x16x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 36); \
+})
+#else
+#define vst1q_p8_x3(__p0, __p1) __extension__ ({ \
+  poly8x16x3_t __s1 = __p1; \
+  poly8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p16_x3(__p0, __p1) __extension__ ({ \
+  poly16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 37); \
+})
+#else
+#define vst1q_p16_x3(__p0, __p1) __extension__ ({ \
+  poly16x8x3_t __s1 = __p1; \
+  poly16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u8_x3(__p0, __p1) __extension__ ({ \
+  uint8x16x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 48); \
+})
+#else
+#define vst1q_u8_x3(__p0, __p1) __extension__ ({ \
+  uint8x16x3_t __s1 = __p1; \
+  uint8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u32_x3(__p0, __p1) __extension__ ({ \
+  uint32x4x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 50); \
+})
+#else
+#define vst1q_u32_x3(__p0, __p1) __extension__ ({ \
+  uint32x4x3_t __s1 = __p1; \
+  uint32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u64_x3(__p0, __p1) __extension__ ({ \
+  uint64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 51); \
+})
+#else
+#define vst1q_u64_x3(__p0, __p1) __extension__ ({ \
+  uint64x2x3_t __s1 = __p1; \
+  uint64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u16_x3(__p0, __p1) __extension__ ({ \
+  uint16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 49); \
+})
+#else
+#define vst1q_u16_x3(__p0, __p1) __extension__ ({ \
+  uint16x8x3_t __s1 = __p1; \
+  uint16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s8_x3(__p0, __p1) __extension__ ({ \
+  int8x16x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 32); \
+})
+#else
+#define vst1q_s8_x3(__p0, __p1) __extension__ ({ \
+  int8x16x3_t __s1 = __p1; \
+  int8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f32_x3(__p0, __p1) __extension__ ({ \
+  float32x4x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 41); \
+})
+#else
+#define vst1q_f32_x3(__p0, __p1) __extension__ ({ \
+  float32x4x3_t __s1 = __p1; \
+  float32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s32_x3(__p0, __p1) __extension__ ({ \
+  int32x4x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 34); \
+})
+#else
+#define vst1q_s32_x3(__p0, __p1) __extension__ ({ \
+  int32x4x3_t __s1 = __p1; \
+  int32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s64_x3(__p0, __p1) __extension__ ({ \
+  int64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 35); \
+})
+#else
+#define vst1q_s64_x3(__p0, __p1) __extension__ ({ \
+  int64x2x3_t __s1 = __p1; \
+  int64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 35); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s16_x3(__p0, __p1) __extension__ ({ \
+  int16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 33); \
+})
+#else
+#define vst1q_s16_x3(__p0, __p1) __extension__ ({ \
+  int16x8x3_t __s1 = __p1; \
+  int16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u8_x3(__p0, __p1) __extension__ ({ \
+  uint8x8x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 16); \
+})
+#else
+#define vst1_u8_x3(__p0, __p1) __extension__ ({ \
+  uint8x8x3_t __s1 = __p1; \
+  uint8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u32_x3(__p0, __p1) __extension__ ({ \
+  uint32x2x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 18); \
+})
+#else
+#define vst1_u32_x3(__p0, __p1) __extension__ ({ \
+  uint32x2x3_t __s1 = __p1; \
+  uint32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 18); \
+})
+#endif
+
+#define vst1_u64_x3(__p0, __p1) __extension__ ({ \
+  uint64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 19); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u16_x3(__p0, __p1) __extension__ ({ \
+  uint16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 17); \
+})
+#else
+#define vst1_u16_x3(__p0, __p1) __extension__ ({ \
+  uint16x4x3_t __s1 = __p1; \
+  uint16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s8_x3(__p0, __p1) __extension__ ({ \
+  int8x8x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 0); \
+})
+#else
+#define vst1_s8_x3(__p0, __p1) __extension__ ({ \
+  int8x8x3_t __s1 = __p1; \
+  int8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_f32_x3(__p0, __p1) __extension__ ({ \
+  float32x2x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 9); \
+})
+#else
+#define vst1_f32_x3(__p0, __p1) __extension__ ({ \
+  float32x2x3_t __s1 = __p1; \
+  float32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s32_x3(__p0, __p1) __extension__ ({ \
+  int32x2x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 2); \
+})
+#else
+#define vst1_s32_x3(__p0, __p1) __extension__ ({ \
+  int32x2x3_t __s1 = __p1; \
+  int32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 2); \
+})
+#endif
+
+#define vst1_s64_x3(__p0, __p1) __extension__ ({ \
+  int64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 3); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s16_x3(__p0, __p1) __extension__ ({ \
+  int16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 1); \
+})
+#else
+#define vst1_s16_x3(__p0, __p1) __extension__ ({ \
+  int16x4x3_t __s1 = __p1; \
+  int16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_p8_x4(__p0, __p1) __extension__ ({ \
+  poly8x8x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 4); \
+})
+#else
+#define vst1_p8_x4(__p0, __p1) __extension__ ({ \
+  poly8x8x4_t __s1 = __p1; \
+  poly8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_p16_x4(__p0, __p1) __extension__ ({ \
+  poly16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 5); \
+})
+#else
+#define vst1_p16_x4(__p0, __p1) __extension__ ({ \
+  poly16x4x4_t __s1 = __p1; \
+  poly16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p8_x4(__p0, __p1) __extension__ ({ \
+  poly8x16x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 36); \
+})
+#else
+#define vst1q_p8_x4(__p0, __p1) __extension__ ({ \
+  poly8x16x4_t __s1 = __p1; \
+  poly8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p16_x4(__p0, __p1) __extension__ ({ \
+  poly16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 37); \
+})
+#else
+#define vst1q_p16_x4(__p0, __p1) __extension__ ({ \
+  poly16x8x4_t __s1 = __p1; \
+  poly16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u8_x4(__p0, __p1) __extension__ ({ \
+  uint8x16x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 48); \
+})
+#else
+#define vst1q_u8_x4(__p0, __p1) __extension__ ({ \
+  uint8x16x4_t __s1 = __p1; \
+  uint8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u32_x4(__p0, __p1) __extension__ ({ \
+  uint32x4x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 50); \
+})
+#else
+#define vst1q_u32_x4(__p0, __p1) __extension__ ({ \
+  uint32x4x4_t __s1 = __p1; \
+  uint32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u64_x4(__p0, __p1) __extension__ ({ \
+  uint64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 51); \
+})
+#else
+#define vst1q_u64_x4(__p0, __p1) __extension__ ({ \
+  uint64x2x4_t __s1 = __p1; \
+  uint64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_u16_x4(__p0, __p1) __extension__ ({ \
+  uint16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 49); \
+})
+#else
+#define vst1q_u16_x4(__p0, __p1) __extension__ ({ \
+  uint16x8x4_t __s1 = __p1; \
+  uint16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s8_x4(__p0, __p1) __extension__ ({ \
+  int8x16x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 32); \
+})
+#else
+#define vst1q_s8_x4(__p0, __p1) __extension__ ({ \
+  int8x16x4_t __s1 = __p1; \
+  int8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f32_x4(__p0, __p1) __extension__ ({ \
+  float32x4x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 41); \
+})
+#else
+#define vst1q_f32_x4(__p0, __p1) __extension__ ({ \
+  float32x4x4_t __s1 = __p1; \
+  float32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s32_x4(__p0, __p1) __extension__ ({ \
+  int32x4x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 34); \
+})
+#else
+#define vst1q_s32_x4(__p0, __p1) __extension__ ({ \
+  int32x4x4_t __s1 = __p1; \
+  int32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s64_x4(__p0, __p1) __extension__ ({ \
+  int64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 35); \
+})
+#else
+#define vst1q_s64_x4(__p0, __p1) __extension__ ({ \
+  int64x2x4_t __s1 = __p1; \
+  int64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 35); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_s16_x4(__p0, __p1) __extension__ ({ \
+  int16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 33); \
+})
+#else
+#define vst1q_s16_x4(__p0, __p1) __extension__ ({ \
+  int16x8x4_t __s1 = __p1; \
+  int16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u8_x4(__p0, __p1) __extension__ ({ \
+  uint8x8x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 16); \
+})
+#else
+#define vst1_u8_x4(__p0, __p1) __extension__ ({ \
+  uint8x8x4_t __s1 = __p1; \
+  uint8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u32_x4(__p0, __p1) __extension__ ({ \
+  uint32x2x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 18); \
+})
+#else
+#define vst1_u32_x4(__p0, __p1) __extension__ ({ \
+  uint32x2x4_t __s1 = __p1; \
+  uint32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 18); \
+})
+#endif
+
+#define vst1_u64_x4(__p0, __p1) __extension__ ({ \
+  uint64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 19); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1_u16_x4(__p0, __p1) __extension__ ({ \
+  uint16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 17); \
+})
+#else
+#define vst1_u16_x4(__p0, __p1) __extension__ ({ \
+  uint16x4x4_t __s1 = __p1; \
+  uint16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s8_x4(__p0, __p1) __extension__ ({ \
+  int8x8x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 0); \
+})
+#else
+#define vst1_s8_x4(__p0, __p1) __extension__ ({ \
+  int8x8x4_t __s1 = __p1; \
+  int8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_f32_x4(__p0, __p1) __extension__ ({ \
+  float32x2x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 9); \
+})
+#else
+#define vst1_f32_x4(__p0, __p1) __extension__ ({ \
+  float32x2x4_t __s1 = __p1; \
+  float32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s32_x4(__p0, __p1) __extension__ ({ \
+  int32x2x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 2); \
+})
+#else
+#define vst1_s32_x4(__p0, __p1) __extension__ ({ \
+  int32x2x4_t __s1 = __p1; \
+  int32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 2); \
+})
+#endif
+
+#define vst1_s64_x4(__p0, __p1) __extension__ ({ \
+  int64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 3); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1_s16_x4(__p0, __p1) __extension__ ({ \
+  int16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 1); \
+})
+#else
+#define vst1_s16_x4(__p0, __p1) __extension__ ({ \
+  int16x4x4_t __s1 = __p1; \
+  int16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_p8(__p0, __p1) __extension__ ({ \
+  poly8x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 4); \
+})
+#else
+#define vst2_p8(__p0, __p1) __extension__ ({ \
+  poly8x8x2_t __s1 = __p1; \
+  poly8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_p16(__p0, __p1) __extension__ ({ \
+  poly16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 5); \
+})
+#else
+#define vst2_p16(__p0, __p1) __extension__ ({ \
+  poly16x4x2_t __s1 = __p1; \
+  poly16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_p8(__p0, __p1) __extension__ ({ \
+  poly8x16x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 36); \
+})
+#else
+#define vst2q_p8(__p0, __p1) __extension__ ({ \
+  poly8x16x2_t __s1 = __p1; \
+  poly8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_p16(__p0, __p1) __extension__ ({ \
+  poly16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 37); \
+})
+#else
+#define vst2q_p16(__p0, __p1) __extension__ ({ \
+  poly16x8x2_t __s1 = __p1; \
+  poly16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_u8(__p0, __p1) __extension__ ({ \
+  uint8x16x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 48); \
+})
+#else
+#define vst2q_u8(__p0, __p1) __extension__ ({ \
+  uint8x16x2_t __s1 = __p1; \
+  uint8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_u32(__p0, __p1) __extension__ ({ \
+  uint32x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 50); \
+})
+#else
+#define vst2q_u32(__p0, __p1) __extension__ ({ \
+  uint32x4x2_t __s1 = __p1; \
+  uint32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_u16(__p0, __p1) __extension__ ({ \
+  uint16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 49); \
+})
+#else
+#define vst2q_u16(__p0, __p1) __extension__ ({ \
+  uint16x8x2_t __s1 = __p1; \
+  uint16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_s8(__p0, __p1) __extension__ ({ \
+  int8x16x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 32); \
+})
+#else
+#define vst2q_s8(__p0, __p1) __extension__ ({ \
+  int8x16x2_t __s1 = __p1; \
+  int8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_f32(__p0, __p1) __extension__ ({ \
+  float32x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 41); \
+})
+#else
+#define vst2q_f32(__p0, __p1) __extension__ ({ \
+  float32x4x2_t __s1 = __p1; \
+  float32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_s32(__p0, __p1) __extension__ ({ \
+  int32x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 34); \
+})
+#else
+#define vst2q_s32(__p0, __p1) __extension__ ({ \
+  int32x4x2_t __s1 = __p1; \
+  int32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_s16(__p0, __p1) __extension__ ({ \
+  int16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 33); \
+})
+#else
+#define vst2q_s16(__p0, __p1) __extension__ ({ \
+  int16x8x2_t __s1 = __p1; \
+  int16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_u8(__p0, __p1) __extension__ ({ \
+  uint8x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 16); \
+})
+#else
+#define vst2_u8(__p0, __p1) __extension__ ({ \
+  uint8x8x2_t __s1 = __p1; \
+  uint8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_u32(__p0, __p1) __extension__ ({ \
+  uint32x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 18); \
+})
+#else
+#define vst2_u32(__p0, __p1) __extension__ ({ \
+  uint32x2x2_t __s1 = __p1; \
+  uint32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 18); \
+})
+#endif
+
+#define vst2_u64(__p0, __p1) __extension__ ({ \
+  uint64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 19); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst2_u16(__p0, __p1) __extension__ ({ \
+  uint16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 17); \
+})
+#else
+#define vst2_u16(__p0, __p1) __extension__ ({ \
+  uint16x4x2_t __s1 = __p1; \
+  uint16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_s8(__p0, __p1) __extension__ ({ \
+  int8x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 0); \
+})
+#else
+#define vst2_s8(__p0, __p1) __extension__ ({ \
+  int8x8x2_t __s1 = __p1; \
+  int8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_f32(__p0, __p1) __extension__ ({ \
+  float32x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 9); \
+})
+#else
+#define vst2_f32(__p0, __p1) __extension__ ({ \
+  float32x2x2_t __s1 = __p1; \
+  float32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_s32(__p0, __p1) __extension__ ({ \
+  int32x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 2); \
+})
+#else
+#define vst2_s32(__p0, __p1) __extension__ ({ \
+  int32x2x2_t __s1 = __p1; \
+  int32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 2); \
+})
+#endif
+
+#define vst2_s64(__p0, __p1) __extension__ ({ \
+  int64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 3); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst2_s16(__p0, __p1) __extension__ ({ \
+  int16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 1); \
+})
+#else
+#define vst2_s16(__p0, __p1) __extension__ ({ \
+  int16x4x2_t __s1 = __p1; \
+  int16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 4); \
+})
+#else
+#define vst2_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x2_t __s1 = __p1; \
+  poly8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 5); \
+})
+#else
+#define vst2_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x2_t __s1 = __p1; \
+  poly16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 37); \
+})
+#else
+#define vst2q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x2_t __s1 = __p1; \
+  poly16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 50); \
+})
+#else
+#define vst2q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x2_t __s1 = __p1; \
+  uint32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 49); \
+})
+#else
+#define vst2q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x2_t __s1 = __p1; \
+  uint16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 41); \
+})
+#else
+#define vst2q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x2_t __s1 = __p1; \
+  float32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 34); \
+})
+#else
+#define vst2q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x2_t __s1 = __p1; \
+  int32x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 33); \
+})
+#else
+#define vst2q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x2_t __s1 = __p1; \
+  int16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 16); \
+})
+#else
+#define vst2_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x2_t __s1 = __p1; \
+  uint8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 18); \
+})
+#else
+#define vst2_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x2_t __s1 = __p1; \
+  uint32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 18); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 17); \
+})
+#else
+#define vst2_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x2_t __s1 = __p1; \
+  uint16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 0); \
+})
+#else
+#define vst2_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x2_t __s1 = __p1; \
+  int8x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 9); \
+})
+#else
+#define vst2_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x2_t __s1 = __p1; \
+  float32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 2); \
+})
+#else
+#define vst2_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x2_t __s1 = __p1; \
+  int32x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 2); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 1); \
+})
+#else
+#define vst2_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x2_t __s1 = __p1; \
+  int16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_p8(__p0, __p1) __extension__ ({ \
+  poly8x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 4); \
+})
+#else
+#define vst3_p8(__p0, __p1) __extension__ ({ \
+  poly8x8x3_t __s1 = __p1; \
+  poly8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_p16(__p0, __p1) __extension__ ({ \
+  poly16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 5); \
+})
+#else
+#define vst3_p16(__p0, __p1) __extension__ ({ \
+  poly16x4x3_t __s1 = __p1; \
+  poly16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_p8(__p0, __p1) __extension__ ({ \
+  poly8x16x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 36); \
+})
+#else
+#define vst3q_p8(__p0, __p1) __extension__ ({ \
+  poly8x16x3_t __s1 = __p1; \
+  poly8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_p16(__p0, __p1) __extension__ ({ \
+  poly16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 37); \
+})
+#else
+#define vst3q_p16(__p0, __p1) __extension__ ({ \
+  poly16x8x3_t __s1 = __p1; \
+  poly16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_u8(__p0, __p1) __extension__ ({ \
+  uint8x16x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 48); \
+})
+#else
+#define vst3q_u8(__p0, __p1) __extension__ ({ \
+  uint8x16x3_t __s1 = __p1; \
+  uint8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_u32(__p0, __p1) __extension__ ({ \
+  uint32x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 50); \
+})
+#else
+#define vst3q_u32(__p0, __p1) __extension__ ({ \
+  uint32x4x3_t __s1 = __p1; \
+  uint32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_u16(__p0, __p1) __extension__ ({ \
+  uint16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 49); \
+})
+#else
+#define vst3q_u16(__p0, __p1) __extension__ ({ \
+  uint16x8x3_t __s1 = __p1; \
+  uint16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_s8(__p0, __p1) __extension__ ({ \
+  int8x16x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 32); \
+})
+#else
+#define vst3q_s8(__p0, __p1) __extension__ ({ \
+  int8x16x3_t __s1 = __p1; \
+  int8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_f32(__p0, __p1) __extension__ ({ \
+  float32x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 41); \
+})
+#else
+#define vst3q_f32(__p0, __p1) __extension__ ({ \
+  float32x4x3_t __s1 = __p1; \
+  float32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_s32(__p0, __p1) __extension__ ({ \
+  int32x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 34); \
+})
+#else
+#define vst3q_s32(__p0, __p1) __extension__ ({ \
+  int32x4x3_t __s1 = __p1; \
+  int32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_s16(__p0, __p1) __extension__ ({ \
+  int16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 33); \
+})
+#else
+#define vst3q_s16(__p0, __p1) __extension__ ({ \
+  int16x8x3_t __s1 = __p1; \
+  int16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_u8(__p0, __p1) __extension__ ({ \
+  uint8x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 16); \
+})
+#else
+#define vst3_u8(__p0, __p1) __extension__ ({ \
+  uint8x8x3_t __s1 = __p1; \
+  uint8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_u32(__p0, __p1) __extension__ ({ \
+  uint32x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 18); \
+})
+#else
+#define vst3_u32(__p0, __p1) __extension__ ({ \
+  uint32x2x3_t __s1 = __p1; \
+  uint32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 18); \
+})
+#endif
+
+#define vst3_u64(__p0, __p1) __extension__ ({ \
+  uint64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 19); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst3_u16(__p0, __p1) __extension__ ({ \
+  uint16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 17); \
+})
+#else
+#define vst3_u16(__p0, __p1) __extension__ ({ \
+  uint16x4x3_t __s1 = __p1; \
+  uint16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_s8(__p0, __p1) __extension__ ({ \
+  int8x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 0); \
+})
+#else
+#define vst3_s8(__p0, __p1) __extension__ ({ \
+  int8x8x3_t __s1 = __p1; \
+  int8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_f32(__p0, __p1) __extension__ ({ \
+  float32x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 9); \
+})
+#else
+#define vst3_f32(__p0, __p1) __extension__ ({ \
+  float32x2x3_t __s1 = __p1; \
+  float32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_s32(__p0, __p1) __extension__ ({ \
+  int32x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 2); \
+})
+#else
+#define vst3_s32(__p0, __p1) __extension__ ({ \
+  int32x2x3_t __s1 = __p1; \
+  int32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 2); \
+})
+#endif
+
+#define vst3_s64(__p0, __p1) __extension__ ({ \
+  int64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 3); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst3_s16(__p0, __p1) __extension__ ({ \
+  int16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 1); \
+})
+#else
+#define vst3_s16(__p0, __p1) __extension__ ({ \
+  int16x4x3_t __s1 = __p1; \
+  int16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 4); \
+})
+#else
+#define vst3_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x3_t __s1 = __p1; \
+  poly8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 5); \
+})
+#else
+#define vst3_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x3_t __s1 = __p1; \
+  poly16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 37); \
+})
+#else
+#define vst3q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x3_t __s1 = __p1; \
+  poly16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 50); \
+})
+#else
+#define vst3q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x3_t __s1 = __p1; \
+  uint32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 49); \
+})
+#else
+#define vst3q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x3_t __s1 = __p1; \
+  uint16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 41); \
+})
+#else
+#define vst3q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x3_t __s1 = __p1; \
+  float32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 34); \
+})
+#else
+#define vst3q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x3_t __s1 = __p1; \
+  int32x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 33); \
+})
+#else
+#define vst3q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x3_t __s1 = __p1; \
+  int16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 16); \
+})
+#else
+#define vst3_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x3_t __s1 = __p1; \
+  uint8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 18); \
+})
+#else
+#define vst3_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x3_t __s1 = __p1; \
+  uint32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 18); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 17); \
+})
+#else
+#define vst3_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x3_t __s1 = __p1; \
+  uint16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 0); \
+})
+#else
+#define vst3_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x3_t __s1 = __p1; \
+  int8x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 9); \
+})
+#else
+#define vst3_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x3_t __s1 = __p1; \
+  float32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 2); \
+})
+#else
+#define vst3_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x3_t __s1 = __p1; \
+  int32x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 2); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 1); \
+})
+#else
+#define vst3_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x3_t __s1 = __p1; \
+  int16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_p8(__p0, __p1) __extension__ ({ \
+  poly8x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 4); \
+})
+#else
+#define vst4_p8(__p0, __p1) __extension__ ({ \
+  poly8x8x4_t __s1 = __p1; \
+  poly8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_p16(__p0, __p1) __extension__ ({ \
+  poly16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 5); \
+})
+#else
+#define vst4_p16(__p0, __p1) __extension__ ({ \
+  poly16x4x4_t __s1 = __p1; \
+  poly16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_p8(__p0, __p1) __extension__ ({ \
+  poly8x16x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 36); \
+})
+#else
+#define vst4q_p8(__p0, __p1) __extension__ ({ \
+  poly8x16x4_t __s1 = __p1; \
+  poly8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_p16(__p0, __p1) __extension__ ({ \
+  poly16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 37); \
+})
+#else
+#define vst4q_p16(__p0, __p1) __extension__ ({ \
+  poly16x8x4_t __s1 = __p1; \
+  poly16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_u8(__p0, __p1) __extension__ ({ \
+  uint8x16x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 48); \
+})
+#else
+#define vst4q_u8(__p0, __p1) __extension__ ({ \
+  uint8x16x4_t __s1 = __p1; \
+  uint8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_u32(__p0, __p1) __extension__ ({ \
+  uint32x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 50); \
+})
+#else
+#define vst4q_u32(__p0, __p1) __extension__ ({ \
+  uint32x4x4_t __s1 = __p1; \
+  uint32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_u16(__p0, __p1) __extension__ ({ \
+  uint16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 49); \
+})
+#else
+#define vst4q_u16(__p0, __p1) __extension__ ({ \
+  uint16x8x4_t __s1 = __p1; \
+  uint16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_s8(__p0, __p1) __extension__ ({ \
+  int8x16x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 32); \
+})
+#else
+#define vst4q_s8(__p0, __p1) __extension__ ({ \
+  int8x16x4_t __s1 = __p1; \
+  int8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_f32(__p0, __p1) __extension__ ({ \
+  float32x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 41); \
+})
+#else
+#define vst4q_f32(__p0, __p1) __extension__ ({ \
+  float32x4x4_t __s1 = __p1; \
+  float32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_s32(__p0, __p1) __extension__ ({ \
+  int32x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 34); \
+})
+#else
+#define vst4q_s32(__p0, __p1) __extension__ ({ \
+  int32x4x4_t __s1 = __p1; \
+  int32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_s16(__p0, __p1) __extension__ ({ \
+  int16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 33); \
+})
+#else
+#define vst4q_s16(__p0, __p1) __extension__ ({ \
+  int16x8x4_t __s1 = __p1; \
+  int16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_u8(__p0, __p1) __extension__ ({ \
+  uint8x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 16); \
+})
+#else
+#define vst4_u8(__p0, __p1) __extension__ ({ \
+  uint8x8x4_t __s1 = __p1; \
+  uint8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_u32(__p0, __p1) __extension__ ({ \
+  uint32x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 18); \
+})
+#else
+#define vst4_u32(__p0, __p1) __extension__ ({ \
+  uint32x2x4_t __s1 = __p1; \
+  uint32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 18); \
+})
+#endif
+
+#define vst4_u64(__p0, __p1) __extension__ ({ \
+  uint64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 19); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst4_u16(__p0, __p1) __extension__ ({ \
+  uint16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 17); \
+})
+#else
+#define vst4_u16(__p0, __p1) __extension__ ({ \
+  uint16x4x4_t __s1 = __p1; \
+  uint16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_s8(__p0, __p1) __extension__ ({ \
+  int8x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 0); \
+})
+#else
+#define vst4_s8(__p0, __p1) __extension__ ({ \
+  int8x8x4_t __s1 = __p1; \
+  int8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_f32(__p0, __p1) __extension__ ({ \
+  float32x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 9); \
+})
+#else
+#define vst4_f32(__p0, __p1) __extension__ ({ \
+  float32x2x4_t __s1 = __p1; \
+  float32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_s32(__p0, __p1) __extension__ ({ \
+  int32x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 2); \
+})
+#else
+#define vst4_s32(__p0, __p1) __extension__ ({ \
+  int32x2x4_t __s1 = __p1; \
+  int32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 2); \
+})
+#endif
+
+#define vst4_s64(__p0, __p1) __extension__ ({ \
+  int64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 3); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst4_s16(__p0, __p1) __extension__ ({ \
+  int16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 1); \
+})
+#else
+#define vst4_s16(__p0, __p1) __extension__ ({ \
+  int16x4x4_t __s1 = __p1; \
+  int16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 4); \
+})
+#else
+#define vst4_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x8x4_t __s1 = __p1; \
+  poly8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 4); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 5); \
+})
+#else
+#define vst4_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x4x4_t __s1 = __p1; \
+  poly16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 5); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 37); \
+})
+#else
+#define vst4q_lane_p16(__p0, __p1, __p2) __extension__ ({ \
+  poly16x8x4_t __s1 = __p1; \
+  poly16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 37); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 50); \
+})
+#else
+#define vst4q_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x4x4_t __s1 = __p1; \
+  uint32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 50); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 49); \
+})
+#else
+#define vst4q_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x8x4_t __s1 = __p1; \
+  uint16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 49); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 41); \
+})
+#else
+#define vst4q_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x4x4_t __s1 = __p1; \
+  float32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 41); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 34); \
+})
+#else
+#define vst4q_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4x4_t __s1 = __p1; \
+  int32x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 34); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 33); \
+})
+#else
+#define vst4q_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8x4_t __s1 = __p1; \
+  int16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 33); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 16); \
+})
+#else
+#define vst4_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x8x4_t __s1 = __p1; \
+  uint8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 16); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 18); \
+})
+#else
+#define vst4_lane_u32(__p0, __p1, __p2) __extension__ ({ \
+  uint32x2x4_t __s1 = __p1; \
+  uint32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 18); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 17); \
+})
+#else
+#define vst4_lane_u16(__p0, __p1, __p2) __extension__ ({ \
+  uint16x4x4_t __s1 = __p1; \
+  uint16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 17); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 0); \
+})
+#else
+#define vst4_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x8x4_t __s1 = __p1; \
+  int8x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 0); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 9); \
+})
+#else
+#define vst4_lane_f32(__p0, __p1, __p2) __extension__ ({ \
+  float32x2x4_t __s1 = __p1; \
+  float32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 9); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 2); \
+})
+#else
+#define vst4_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2x4_t __s1 = __p1; \
+  int32x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 2); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 1); \
+})
+#else
+#define vst4_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4x4_t __s1 = __p1; \
+  int16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 1); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vsubq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vsubq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vsubq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vsubq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vsubq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vsubq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vsubq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vsubq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vsubq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vsubq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vsubq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vsub_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vsub_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vsub_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vsub_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vsub_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vsub_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vsub_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vsub_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vsub_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vsub_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vsub_s64(int64x1_t __p0, int64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vsub_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vsub_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t __noswap_vsubhn_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 17);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t __noswap_vsubhn_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 18);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t __noswap_vsubhn_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 16);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t __noswap_vsubhn_s32(int32x4_t __p0, int32x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t __noswap_vsubhn_s64(int64x2_t __p0, int64x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__rev0, (int8x16_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t __noswap_vsubhn_s16(int16x8_t __p0, int16x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vsubhn_v((int8x16_t)__p0, (int8x16_t)__p1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vsubl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = vmovl_u8(__p0) - vmovl_u8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vsubl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_u8(__rev0) - __noswap_vmovl_u8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vsubl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = vmovl_u32(__p0) - vmovl_u32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vsubl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vmovl_u32(__rev0) - __noswap_vmovl_u32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vsubl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = vmovl_u16(__p0) - vmovl_u16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vsubl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_u16(__rev0) - __noswap_vmovl_u16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vsubl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  __ret = vmovl_s8(__p0) - vmovl_s8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vsubl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_s8(__rev0) - __noswap_vmovl_s8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vsubl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  __ret = vmovl_s32(__p0) - vmovl_s32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vsubl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vmovl_s32(__rev0) - __noswap_vmovl_s32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vsubl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  __ret = vmovl_s16(__p0) - vmovl_s16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vsubl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_s16(__rev0) - __noswap_vmovl_s16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vsubw_u8(uint16x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 - vmovl_u8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vsubw_u8(uint16x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_u8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vsubw_u32(uint64x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 - vmovl_u32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vsubw_u32(uint64x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_u32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vsubw_u16(uint32x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 - vmovl_u16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vsubw_u16(uint32x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_u16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vsubw_s8(int16x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 - vmovl_s8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vsubw_s8(int16x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_s8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vsubw_s32(int64x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 - vmovl_s32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vsubw_s32(int64x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_s32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vsubw_s16(int32x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 - vmovl_s16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vsubw_s16(int32x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_s16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vtbl1_p8(poly8x8_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__p0, (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vtbl1_p8(poly8x8_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtbl1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtbl1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vtbl1_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vtbl1_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vtbl1_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vtbl2_p8(poly8x8x2_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vtbl2_p8(poly8x8x2_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8x2_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev1, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtbl2_u8(uint8x8x2_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtbl2_u8(uint8x8x2_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8x2_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vtbl2_s8(int8x8x2_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vtbl2_s8(int8x8x2_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8x2_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vtbl2_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vtbl3_p8(poly8x8x3_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vtbl3_p8(poly8x8x3_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8x3_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev1, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtbl3_u8(uint8x8x3_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtbl3_u8(uint8x8x3_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8x3_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vtbl3_s8(int8x8x3_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vtbl3_s8(int8x8x3_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8x3_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vtbl3_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vtbl4_p8(poly8x8x4_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p0.val[3], (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vtbl4_p8(poly8x8x4_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8x4_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev0.val[3], (int8x8_t)__rev1, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtbl4_u8(uint8x8x4_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p0.val[3], (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtbl4_u8(uint8x8x4_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8x4_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev0.val[3], (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vtbl4_s8(int8x8x4_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__p0.val[0], (int8x8_t)__p0.val[1], (int8x8_t)__p0.val[2], (int8x8_t)__p0.val[3], (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vtbl4_s8(int8x8x4_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8x4_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vtbl4_v((int8x8_t)__rev0.val[0], (int8x8_t)__rev0.val[1], (int8x8_t)__rev0.val[2], (int8x8_t)__rev0.val[3], (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vtbx1_p8(poly8x8_t __p0, poly8x8_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vtbx1_p8(poly8x8_t __p0, poly8x8_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtbx1_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtbx1_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vtbx1_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vtbx1_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vtbx1_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vtbx2_p8(poly8x8_t __p0, poly8x8x2_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p2, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vtbx2_p8(poly8x8_t __p0, poly8x8x2_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8x2_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev2, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtbx2_u8(uint8x8_t __p0, uint8x8x2_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p2, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtbx2_u8(uint8x8_t __p0, uint8x8x2_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8x2_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev2, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vtbx2_s8(int8x8_t __p0, int8x8x2_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p2, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vtbx2_s8(int8x8_t __p0, int8x8x2_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8x2_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vtbx2_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev2, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vtbx3_p8(poly8x8_t __p0, poly8x8x3_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p2, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vtbx3_p8(poly8x8_t __p0, poly8x8x3_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8x3_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev2, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtbx3_u8(uint8x8_t __p0, uint8x8x3_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p2, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtbx3_u8(uint8x8_t __p0, uint8x8x3_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8x3_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev2, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vtbx3_s8(int8x8_t __p0, int8x8x3_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p2, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vtbx3_s8(int8x8_t __p0, int8x8x3_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8x3_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vtbx3_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev2, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vtbx4_p8(poly8x8_t __p0, poly8x8x4_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p1.val[3], (int8x8_t)__p2, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vtbx4_p8(poly8x8_t __p0, poly8x8x4_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8x4_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], (int8x8_t)__rev2, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtbx4_u8(uint8x8_t __p0, uint8x8x4_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p1.val[3], (int8x8_t)__p2, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtbx4_u8(uint8x8_t __p0, uint8x8x4_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8x4_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], (int8x8_t)__rev2, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vtbx4_s8(int8x8_t __p0, int8x8x4_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__p0, (int8x8_t)__p1.val[0], (int8x8_t)__p1.val[1], (int8x8_t)__p1.val[2], (int8x8_t)__p1.val[3], (int8x8_t)__p2, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vtbx4_s8(int8x8_t __p0, int8x8x4_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8x4_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vtbx4_v((int8x8_t)__rev0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], (int8x8_t)__rev2, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8x2_t vtrn_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8x2_t __ret;
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8x2_t vtrn_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8x2_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4x2_t vtrn_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4x2_t __ret;
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4x2_t vtrn_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4x2_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 5);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16x2_t vtrnq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16x2_t __ret;
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16x2_t vtrnq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16x2_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 36);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8x2_t vtrnq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8x2_t __ret;
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 37);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8x2_t vtrnq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8x2_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 37);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16x2_t vtrnq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16x2_t __ret;
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16x2_t vtrnq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16x2_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4x2_t vtrnq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4x2_t __ret;
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4x2_t vtrnq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8x2_t vtrnq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8x2_t __ret;
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8x2_t vtrnq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8x2_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16x2_t vtrnq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16x2_t __ret;
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16x2_t vtrnq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16x2_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4x2_t vtrnq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4x2_t __ret;
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4x2_t vtrnq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4x2_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4x2_t vtrnq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4x2_t __ret;
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4x2_t vtrnq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8x2_t vtrnq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8x2_t __ret;
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8x2_t vtrnq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8x2_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8x2_t vtrn_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8x2_t __ret;
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8x2_t vtrn_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8x2_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2x2_t vtrn_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2x2_t __ret;
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2x2_t vtrn_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4x2_t vtrn_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4x2_t __ret;
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4x2_t vtrn_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4x2_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8x2_t vtrn_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8x2_t __ret;
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8x2_t vtrn_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8x2_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2x2_t vtrn_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2x2_t __ret;
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2x2_t vtrn_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2x2_t vtrn_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2x2_t __ret;
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2x2_t vtrn_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4x2_t vtrn_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4x2_t __ret;
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4x2_t vtrn_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4x2_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8x2_t vtrnq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8x2_t __ret;
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8x2_t vtrnq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8x2_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vtrnq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4x2_t vtrn_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4x2_t __ret;
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4x2_t vtrn_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4x2_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vtrn_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtst_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtst_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  uint8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vtst_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vtst_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  uint16x4_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  uint8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  uint16x8_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vtstq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vtstq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vtstq_s8(int8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vtstq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vtstq_s32(int32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vtstq_s16(int16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtst_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtst_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vtst_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vtst_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vtst_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vtst_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtst_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtst_s8(int8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vtst_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vtst_s32(int32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vtst_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vtst_s16(int16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vtst_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8x2_t vuzp_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8x2_t __ret;
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8x2_t vuzp_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8x2_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4x2_t vuzp_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4x2_t __ret;
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4x2_t vuzp_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4x2_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 5);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16x2_t vuzpq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16x2_t __ret;
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16x2_t vuzpq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16x2_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 36);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8x2_t vuzpq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8x2_t __ret;
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 37);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8x2_t vuzpq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8x2_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 37);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16x2_t vuzpq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16x2_t __ret;
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16x2_t vuzpq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16x2_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4x2_t vuzpq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4x2_t __ret;
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4x2_t vuzpq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8x2_t vuzpq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8x2_t __ret;
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8x2_t vuzpq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8x2_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16x2_t vuzpq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16x2_t __ret;
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16x2_t vuzpq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16x2_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4x2_t vuzpq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4x2_t __ret;
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4x2_t vuzpq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4x2_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4x2_t vuzpq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4x2_t __ret;
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4x2_t vuzpq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8x2_t vuzpq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8x2_t __ret;
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8x2_t vuzpq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8x2_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8x2_t vuzp_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8x2_t __ret;
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8x2_t vuzp_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8x2_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2x2_t vuzp_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2x2_t __ret;
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2x2_t vuzp_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4x2_t vuzp_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4x2_t __ret;
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4x2_t vuzp_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4x2_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8x2_t vuzp_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8x2_t __ret;
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8x2_t vuzp_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8x2_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2x2_t vuzp_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2x2_t __ret;
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2x2_t vuzp_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2x2_t vuzp_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2x2_t __ret;
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2x2_t vuzp_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4x2_t vuzp_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4x2_t __ret;
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4x2_t vuzp_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4x2_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8x2_t vuzpq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8x2_t __ret;
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8x2_t vuzpq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8x2_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vuzpq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4x2_t vuzp_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4x2_t __ret;
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4x2_t vuzp_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4x2_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vuzp_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8x2_t vzip_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8x2_t __ret;
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8x2_t vzip_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8x2_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 4);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4x2_t vzip_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4x2_t __ret;
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4x2_t vzip_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4x2_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 5);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16x2_t vzipq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16x2_t __ret;
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16x2_t vzipq_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16x2_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 36);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8x2_t vzipq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8x2_t __ret;
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 37);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8x2_t vzipq_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8x2_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 37);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16x2_t vzipq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16x2_t __ret;
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16x2_t vzipq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16x2_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4x2_t vzipq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4x2_t __ret;
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4x2_t vzipq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8x2_t vzipq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8x2_t __ret;
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8x2_t vzipq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8x2_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16x2_t vzipq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16x2_t __ret;
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16x2_t vzipq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16x2_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4x2_t vzipq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4x2_t __ret;
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4x2_t vzipq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4x2_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4x2_t vzipq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4x2_t __ret;
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4x2_t vzipq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8x2_t vzipq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8x2_t __ret;
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8x2_t vzipq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8x2_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8x2_t vzip_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8x2_t __ret;
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8x2_t vzip_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8x2_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2x2_t vzip_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2x2_t __ret;
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2x2_t vzip_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4x2_t vzip_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4x2_t __ret;
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4x2_t vzip_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4x2_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8x2_t vzip_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8x2_t __ret;
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8x2_t vzip_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8x2_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2x2_t vzip_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2x2_t __ret;
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2x2_t vzip_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2x2_t vzip_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2x2_t __ret;
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2x2_t vzip_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4x2_t vzip_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4x2_t __ret;
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4x2_t vzip_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4x2_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8x2_t vzipq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8x2_t __ret;
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8x2_t vzipq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8x2_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __builtin_neon_vzipq_v(&__ret, (int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4x2_t vzip_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4x2_t __ret;
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4x2_t vzip_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4x2_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __builtin_neon_vzip_v(&__ret, (int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0);
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t vqrdmlahq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqrdmlahq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t vqrdmlahq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqrdmlahq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t __noswap_vqrdmlahq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqrdmlahq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t vqrdmlahq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqrdmlahq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t vqrdmlahq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vqrdmlahq_s16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t __noswap_vqrdmlahq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqrdmlahq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t vqrdmlah_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqrdmlah_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t vqrdmlah_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqrdmlah_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t __noswap_vqrdmlah_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqrdmlah_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t vqrdmlah_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqrdmlah_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t vqrdmlah_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqrdmlah_s16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t __noswap_vqrdmlah_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqrdmlah_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlahq_lane_s32(__p0_134, __p1_134, __p2_134, __p3_134) __extension__ ({ \
+  int32x4_t __ret_134; \
+  int32x4_t __s0_134 = __p0_134; \
+  int32x4_t __s1_134 = __p1_134; \
+  int32x2_t __s2_134 = __p2_134; \
+  __ret_134 = vqrdmlahq_s32(__s0_134, __s1_134, splatq_lane_s32(__s2_134, __p3_134)); \
+  __ret_134; \
+})
+#else
+#define vqrdmlahq_lane_s32(__p0_135, __p1_135, __p2_135, __p3_135) __extension__ ({ \
+  int32x4_t __ret_135; \
+  int32x4_t __s0_135 = __p0_135; \
+  int32x4_t __s1_135 = __p1_135; \
+  int32x2_t __s2_135 = __p2_135; \
+  int32x4_t __rev0_135;  __rev0_135 = __builtin_shufflevector(__s0_135, __s0_135, 3, 2, 1, 0); \
+  int32x4_t __rev1_135;  __rev1_135 = __builtin_shufflevector(__s1_135, __s1_135, 3, 2, 1, 0); \
+  int32x2_t __rev2_135;  __rev2_135 = __builtin_shufflevector(__s2_135, __s2_135, 1, 0); \
+  __ret_135 = __noswap_vqrdmlahq_s32(__rev0_135, __rev1_135, __noswap_splatq_lane_s32(__rev2_135, __p3_135)); \
+  __ret_135 = __builtin_shufflevector(__ret_135, __ret_135, 3, 2, 1, 0); \
+  __ret_135; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlahq_lane_s16(__p0_136, __p1_136, __p2_136, __p3_136) __extension__ ({ \
+  int16x8_t __ret_136; \
+  int16x8_t __s0_136 = __p0_136; \
+  int16x8_t __s1_136 = __p1_136; \
+  int16x4_t __s2_136 = __p2_136; \
+  __ret_136 = vqrdmlahq_s16(__s0_136, __s1_136, splatq_lane_s16(__s2_136, __p3_136)); \
+  __ret_136; \
+})
+#else
+#define vqrdmlahq_lane_s16(__p0_137, __p1_137, __p2_137, __p3_137) __extension__ ({ \
+  int16x8_t __ret_137; \
+  int16x8_t __s0_137 = __p0_137; \
+  int16x8_t __s1_137 = __p1_137; \
+  int16x4_t __s2_137 = __p2_137; \
+  int16x8_t __rev0_137;  __rev0_137 = __builtin_shufflevector(__s0_137, __s0_137, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_137;  __rev1_137 = __builtin_shufflevector(__s1_137, __s1_137, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev2_137;  __rev2_137 = __builtin_shufflevector(__s2_137, __s2_137, 3, 2, 1, 0); \
+  __ret_137 = __noswap_vqrdmlahq_s16(__rev0_137, __rev1_137, __noswap_splatq_lane_s16(__rev2_137, __p3_137)); \
+  __ret_137 = __builtin_shufflevector(__ret_137, __ret_137, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_137; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlah_lane_s32(__p0_138, __p1_138, __p2_138, __p3_138) __extension__ ({ \
+  int32x2_t __ret_138; \
+  int32x2_t __s0_138 = __p0_138; \
+  int32x2_t __s1_138 = __p1_138; \
+  int32x2_t __s2_138 = __p2_138; \
+  __ret_138 = vqrdmlah_s32(__s0_138, __s1_138, splat_lane_s32(__s2_138, __p3_138)); \
+  __ret_138; \
+})
+#else
+#define vqrdmlah_lane_s32(__p0_139, __p1_139, __p2_139, __p3_139) __extension__ ({ \
+  int32x2_t __ret_139; \
+  int32x2_t __s0_139 = __p0_139; \
+  int32x2_t __s1_139 = __p1_139; \
+  int32x2_t __s2_139 = __p2_139; \
+  int32x2_t __rev0_139;  __rev0_139 = __builtin_shufflevector(__s0_139, __s0_139, 1, 0); \
+  int32x2_t __rev1_139;  __rev1_139 = __builtin_shufflevector(__s1_139, __s1_139, 1, 0); \
+  int32x2_t __rev2_139;  __rev2_139 = __builtin_shufflevector(__s2_139, __s2_139, 1, 0); \
+  __ret_139 = __noswap_vqrdmlah_s32(__rev0_139, __rev1_139, __noswap_splat_lane_s32(__rev2_139, __p3_139)); \
+  __ret_139 = __builtin_shufflevector(__ret_139, __ret_139, 1, 0); \
+  __ret_139; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlah_lane_s16(__p0_140, __p1_140, __p2_140, __p3_140) __extension__ ({ \
+  int16x4_t __ret_140; \
+  int16x4_t __s0_140 = __p0_140; \
+  int16x4_t __s1_140 = __p1_140; \
+  int16x4_t __s2_140 = __p2_140; \
+  __ret_140 = vqrdmlah_s16(__s0_140, __s1_140, splat_lane_s16(__s2_140, __p3_140)); \
+  __ret_140; \
+})
+#else
+#define vqrdmlah_lane_s16(__p0_141, __p1_141, __p2_141, __p3_141) __extension__ ({ \
+  int16x4_t __ret_141; \
+  int16x4_t __s0_141 = __p0_141; \
+  int16x4_t __s1_141 = __p1_141; \
+  int16x4_t __s2_141 = __p2_141; \
+  int16x4_t __rev0_141;  __rev0_141 = __builtin_shufflevector(__s0_141, __s0_141, 3, 2, 1, 0); \
+  int16x4_t __rev1_141;  __rev1_141 = __builtin_shufflevector(__s1_141, __s1_141, 3, 2, 1, 0); \
+  int16x4_t __rev2_141;  __rev2_141 = __builtin_shufflevector(__s2_141, __s2_141, 3, 2, 1, 0); \
+  __ret_141 = __noswap_vqrdmlah_s16(__rev0_141, __rev1_141, __noswap_splat_lane_s16(__rev2_141, __p3_141)); \
+  __ret_141 = __builtin_shufflevector(__ret_141, __ret_141, 3, 2, 1, 0); \
+  __ret_141; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t vqrdmlshq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqrdmlshq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t vqrdmlshq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vqrdmlshq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int32x4_t __noswap_vqrdmlshq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vqrdmlshq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t vqrdmlshq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqrdmlshq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t vqrdmlshq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vqrdmlshq_s16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int16x8_t __noswap_vqrdmlshq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vqrdmlshq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t vqrdmlsh_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqrdmlsh_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t vqrdmlsh_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vqrdmlsh_s32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int32x2_t __noswap_vqrdmlsh_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vqrdmlsh_s32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t vqrdmlsh_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqrdmlsh_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t vqrdmlsh_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vqrdmlsh_s16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int16x4_t __noswap_vqrdmlsh_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vqrdmlsh_s16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlshq_lane_s32(__p0_142, __p1_142, __p2_142, __p3_142) __extension__ ({ \
+  int32x4_t __ret_142; \
+  int32x4_t __s0_142 = __p0_142; \
+  int32x4_t __s1_142 = __p1_142; \
+  int32x2_t __s2_142 = __p2_142; \
+  __ret_142 = vqrdmlshq_s32(__s0_142, __s1_142, splatq_lane_s32(__s2_142, __p3_142)); \
+  __ret_142; \
+})
+#else
+#define vqrdmlshq_lane_s32(__p0_143, __p1_143, __p2_143, __p3_143) __extension__ ({ \
+  int32x4_t __ret_143; \
+  int32x4_t __s0_143 = __p0_143; \
+  int32x4_t __s1_143 = __p1_143; \
+  int32x2_t __s2_143 = __p2_143; \
+  int32x4_t __rev0_143;  __rev0_143 = __builtin_shufflevector(__s0_143, __s0_143, 3, 2, 1, 0); \
+  int32x4_t __rev1_143;  __rev1_143 = __builtin_shufflevector(__s1_143, __s1_143, 3, 2, 1, 0); \
+  int32x2_t __rev2_143;  __rev2_143 = __builtin_shufflevector(__s2_143, __s2_143, 1, 0); \
+  __ret_143 = __noswap_vqrdmlshq_s32(__rev0_143, __rev1_143, __noswap_splatq_lane_s32(__rev2_143, __p3_143)); \
+  __ret_143 = __builtin_shufflevector(__ret_143, __ret_143, 3, 2, 1, 0); \
+  __ret_143; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlshq_lane_s16(__p0_144, __p1_144, __p2_144, __p3_144) __extension__ ({ \
+  int16x8_t __ret_144; \
+  int16x8_t __s0_144 = __p0_144; \
+  int16x8_t __s1_144 = __p1_144; \
+  int16x4_t __s2_144 = __p2_144; \
+  __ret_144 = vqrdmlshq_s16(__s0_144, __s1_144, splatq_lane_s16(__s2_144, __p3_144)); \
+  __ret_144; \
+})
+#else
+#define vqrdmlshq_lane_s16(__p0_145, __p1_145, __p2_145, __p3_145) __extension__ ({ \
+  int16x8_t __ret_145; \
+  int16x8_t __s0_145 = __p0_145; \
+  int16x8_t __s1_145 = __p1_145; \
+  int16x4_t __s2_145 = __p2_145; \
+  int16x8_t __rev0_145;  __rev0_145 = __builtin_shufflevector(__s0_145, __s0_145, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_145;  __rev1_145 = __builtin_shufflevector(__s1_145, __s1_145, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev2_145;  __rev2_145 = __builtin_shufflevector(__s2_145, __s2_145, 3, 2, 1, 0); \
+  __ret_145 = __noswap_vqrdmlshq_s16(__rev0_145, __rev1_145, __noswap_splatq_lane_s16(__rev2_145, __p3_145)); \
+  __ret_145 = __builtin_shufflevector(__ret_145, __ret_145, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_145; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlsh_lane_s32(__p0_146, __p1_146, __p2_146, __p3_146) __extension__ ({ \
+  int32x2_t __ret_146; \
+  int32x2_t __s0_146 = __p0_146; \
+  int32x2_t __s1_146 = __p1_146; \
+  int32x2_t __s2_146 = __p2_146; \
+  __ret_146 = vqrdmlsh_s32(__s0_146, __s1_146, splat_lane_s32(__s2_146, __p3_146)); \
+  __ret_146; \
+})
+#else
+#define vqrdmlsh_lane_s32(__p0_147, __p1_147, __p2_147, __p3_147) __extension__ ({ \
+  int32x2_t __ret_147; \
+  int32x2_t __s0_147 = __p0_147; \
+  int32x2_t __s1_147 = __p1_147; \
+  int32x2_t __s2_147 = __p2_147; \
+  int32x2_t __rev0_147;  __rev0_147 = __builtin_shufflevector(__s0_147, __s0_147, 1, 0); \
+  int32x2_t __rev1_147;  __rev1_147 = __builtin_shufflevector(__s1_147, __s1_147, 1, 0); \
+  int32x2_t __rev2_147;  __rev2_147 = __builtin_shufflevector(__s2_147, __s2_147, 1, 0); \
+  __ret_147 = __noswap_vqrdmlsh_s32(__rev0_147, __rev1_147, __noswap_splat_lane_s32(__rev2_147, __p3_147)); \
+  __ret_147 = __builtin_shufflevector(__ret_147, __ret_147, 1, 0); \
+  __ret_147; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlsh_lane_s16(__p0_148, __p1_148, __p2_148, __p3_148) __extension__ ({ \
+  int16x4_t __ret_148; \
+  int16x4_t __s0_148 = __p0_148; \
+  int16x4_t __s1_148 = __p1_148; \
+  int16x4_t __s2_148 = __p2_148; \
+  __ret_148 = vqrdmlsh_s16(__s0_148, __s1_148, splat_lane_s16(__s2_148, __p3_148)); \
+  __ret_148; \
+})
+#else
+#define vqrdmlsh_lane_s16(__p0_149, __p1_149, __p2_149, __p3_149) __extension__ ({ \
+  int16x4_t __ret_149; \
+  int16x4_t __s0_149 = __p0_149; \
+  int16x4_t __s1_149 = __p1_149; \
+  int16x4_t __s2_149 = __p2_149; \
+  int16x4_t __rev0_149;  __rev0_149 = __builtin_shufflevector(__s0_149, __s0_149, 3, 2, 1, 0); \
+  int16x4_t __rev1_149;  __rev1_149 = __builtin_shufflevector(__s1_149, __s1_149, 3, 2, 1, 0); \
+  int16x4_t __rev2_149;  __rev2_149 = __builtin_shufflevector(__s2_149, __s2_149, 3, 2, 1, 0); \
+  __ret_149 = __noswap_vqrdmlsh_s16(__rev0_149, __rev1_149, __noswap_splat_lane_s16(__rev2_149, __p3_149)); \
+  __ret_149 = __builtin_shufflevector(__ret_149, __ret_149, 3, 2, 1, 0); \
+  __ret_149; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcadd_rot270_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcadd_rot270_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcadd_rot270_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vcadd_rot270_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcadd_rot90_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcadd_rot90_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcadd_rot90_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vcadd_rot90_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcaddq_rot270_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcaddq_rot270_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcaddq_rot270_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vcaddq_rot270_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcaddq_rot90_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcaddq_rot90_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcaddq_rot90_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vcaddq_rot90_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t __noswap_vcmlaq_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcmla_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vcmla_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t __noswap_vcmla_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcmla_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_lane_f16(__p0_150, __p1_150, __p2_150, __p3_150) __extension__ ({ \
+  float16x4_t __ret_150; \
+  float16x4_t __s0_150 = __p0_150; \
+  float16x4_t __s1_150 = __p1_150; \
+  float16x4_t __s2_150 = __p2_150; \
+float16x4_t __reint_150 = __s2_150; \
+uint32x2_t __reint1_150 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_150, __p3_150), vget_lane_u32(*(uint32x2_t *) &__reint_150, __p3_150)}; \
+  __ret_150 = vcmla_f16(__s0_150, __s1_150, *(float16x4_t *) &__reint1_150); \
+  __ret_150; \
+})
+#else
+#define vcmla_lane_f16(__p0_151, __p1_151, __p2_151, __p3_151) __extension__ ({ \
+  float16x4_t __ret_151; \
+  float16x4_t __s0_151 = __p0_151; \
+  float16x4_t __s1_151 = __p1_151; \
+  float16x4_t __s2_151 = __p2_151; \
+  float16x4_t __rev0_151;  __rev0_151 = __builtin_shufflevector(__s0_151, __s0_151, 3, 2, 1, 0); \
+  float16x4_t __rev1_151;  __rev1_151 = __builtin_shufflevector(__s1_151, __s1_151, 3, 2, 1, 0); \
+  float16x4_t __rev2_151;  __rev2_151 = __builtin_shufflevector(__s2_151, __s2_151, 3, 2, 1, 0); \
+float16x4_t __reint_151 = __rev2_151; \
+uint32x2_t __reint1_151 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_151, __p3_151), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_151, __p3_151)}; \
+  __ret_151 = __noswap_vcmla_f16(__rev0_151, __rev1_151, *(float16x4_t *) &__reint1_151); \
+  __ret_151 = __builtin_shufflevector(__ret_151, __ret_151, 3, 2, 1, 0); \
+  __ret_151; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_lane_f16(__p0_152, __p1_152, __p2_152, __p3_152) __extension__ ({ \
+  float16x8_t __ret_152; \
+  float16x8_t __s0_152 = __p0_152; \
+  float16x8_t __s1_152 = __p1_152; \
+  float16x4_t __s2_152 = __p2_152; \
+float16x4_t __reint_152 = __s2_152; \
+uint32x4_t __reint1_152 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_152, __p3_152), vget_lane_u32(*(uint32x2_t *) &__reint_152, __p3_152), vget_lane_u32(*(uint32x2_t *) &__reint_152, __p3_152), vget_lane_u32(*(uint32x2_t *) &__reint_152, __p3_152)}; \
+  __ret_152 = vcmlaq_f16(__s0_152, __s1_152, *(float16x8_t *) &__reint1_152); \
+  __ret_152; \
+})
+#else
+#define vcmlaq_lane_f16(__p0_153, __p1_153, __p2_153, __p3_153) __extension__ ({ \
+  float16x8_t __ret_153; \
+  float16x8_t __s0_153 = __p0_153; \
+  float16x8_t __s1_153 = __p1_153; \
+  float16x4_t __s2_153 = __p2_153; \
+  float16x8_t __rev0_153;  __rev0_153 = __builtin_shufflevector(__s0_153, __s0_153, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_153;  __rev1_153 = __builtin_shufflevector(__s1_153, __s1_153, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev2_153;  __rev2_153 = __builtin_shufflevector(__s2_153, __s2_153, 3, 2, 1, 0); \
+float16x4_t __reint_153 = __rev2_153; \
+uint32x4_t __reint1_153 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_153, __p3_153), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_153, __p3_153), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_153, __p3_153), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_153, __p3_153)}; \
+  __ret_153 = __noswap_vcmlaq_f16(__rev0_153, __rev1_153, *(float16x8_t *) &__reint1_153); \
+  __ret_153 = __builtin_shufflevector(__ret_153, __ret_153, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_153; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_laneq_f16(__p0_154, __p1_154, __p2_154, __p3_154) __extension__ ({ \
+  float16x4_t __ret_154; \
+  float16x4_t __s0_154 = __p0_154; \
+  float16x4_t __s1_154 = __p1_154; \
+  float16x8_t __s2_154 = __p2_154; \
+float16x8_t __reint_154 = __s2_154; \
+uint32x2_t __reint1_154 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_154, __p3_154), vgetq_lane_u32(*(uint32x4_t *) &__reint_154, __p3_154)}; \
+  __ret_154 = vcmla_f16(__s0_154, __s1_154, *(float16x4_t *) &__reint1_154); \
+  __ret_154; \
+})
+#else
+#define vcmla_laneq_f16(__p0_155, __p1_155, __p2_155, __p3_155) __extension__ ({ \
+  float16x4_t __ret_155; \
+  float16x4_t __s0_155 = __p0_155; \
+  float16x4_t __s1_155 = __p1_155; \
+  float16x8_t __s2_155 = __p2_155; \
+  float16x4_t __rev0_155;  __rev0_155 = __builtin_shufflevector(__s0_155, __s0_155, 3, 2, 1, 0); \
+  float16x4_t __rev1_155;  __rev1_155 = __builtin_shufflevector(__s1_155, __s1_155, 3, 2, 1, 0); \
+  float16x8_t __rev2_155;  __rev2_155 = __builtin_shufflevector(__s2_155, __s2_155, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_155 = __rev2_155; \
+uint32x2_t __reint1_155 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_155, __p3_155), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_155, __p3_155)}; \
+  __ret_155 = __noswap_vcmla_f16(__rev0_155, __rev1_155, *(float16x4_t *) &__reint1_155); \
+  __ret_155 = __builtin_shufflevector(__ret_155, __ret_155, 3, 2, 1, 0); \
+  __ret_155; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_laneq_f16(__p0_156, __p1_156, __p2_156, __p3_156) __extension__ ({ \
+  float16x8_t __ret_156; \
+  float16x8_t __s0_156 = __p0_156; \
+  float16x8_t __s1_156 = __p1_156; \
+  float16x8_t __s2_156 = __p2_156; \
+float16x8_t __reint_156 = __s2_156; \
+uint32x4_t __reint1_156 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_156, __p3_156), vgetq_lane_u32(*(uint32x4_t *) &__reint_156, __p3_156), vgetq_lane_u32(*(uint32x4_t *) &__reint_156, __p3_156), vgetq_lane_u32(*(uint32x4_t *) &__reint_156, __p3_156)}; \
+  __ret_156 = vcmlaq_f16(__s0_156, __s1_156, *(float16x8_t *) &__reint1_156); \
+  __ret_156; \
+})
+#else
+#define vcmlaq_laneq_f16(__p0_157, __p1_157, __p2_157, __p3_157) __extension__ ({ \
+  float16x8_t __ret_157; \
+  float16x8_t __s0_157 = __p0_157; \
+  float16x8_t __s1_157 = __p1_157; \
+  float16x8_t __s2_157 = __p2_157; \
+  float16x8_t __rev0_157;  __rev0_157 = __builtin_shufflevector(__s0_157, __s0_157, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_157;  __rev1_157 = __builtin_shufflevector(__s1_157, __s1_157, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev2_157;  __rev2_157 = __builtin_shufflevector(__s2_157, __s2_157, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_157 = __rev2_157; \
+uint32x4_t __reint1_157 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_157, __p3_157), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_157, __p3_157), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_157, __p3_157), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_157, __p3_157)}; \
+  __ret_157 = __noswap_vcmlaq_f16(__rev0_157, __rev1_157, *(float16x8_t *) &__reint1_157); \
+  __ret_157 = __builtin_shufflevector(__ret_157, __ret_157, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_157; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot180_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_rot180_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot180_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_rot180_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t __noswap_vcmlaq_rot180_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_rot180_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot180_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcmla_rot180_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot180_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vcmla_rot180_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t __noswap_vcmla_rot180_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcmla_rot180_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot180_lane_f16(__p0_158, __p1_158, __p2_158, __p3_158) __extension__ ({ \
+  float16x4_t __ret_158; \
+  float16x4_t __s0_158 = __p0_158; \
+  float16x4_t __s1_158 = __p1_158; \
+  float16x4_t __s2_158 = __p2_158; \
+float16x4_t __reint_158 = __s2_158; \
+uint32x2_t __reint1_158 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_158, __p3_158), vget_lane_u32(*(uint32x2_t *) &__reint_158, __p3_158)}; \
+  __ret_158 = vcmla_rot180_f16(__s0_158, __s1_158, *(float16x4_t *) &__reint1_158); \
+  __ret_158; \
+})
+#else
+#define vcmla_rot180_lane_f16(__p0_159, __p1_159, __p2_159, __p3_159) __extension__ ({ \
+  float16x4_t __ret_159; \
+  float16x4_t __s0_159 = __p0_159; \
+  float16x4_t __s1_159 = __p1_159; \
+  float16x4_t __s2_159 = __p2_159; \
+  float16x4_t __rev0_159;  __rev0_159 = __builtin_shufflevector(__s0_159, __s0_159, 3, 2, 1, 0); \
+  float16x4_t __rev1_159;  __rev1_159 = __builtin_shufflevector(__s1_159, __s1_159, 3, 2, 1, 0); \
+  float16x4_t __rev2_159;  __rev2_159 = __builtin_shufflevector(__s2_159, __s2_159, 3, 2, 1, 0); \
+float16x4_t __reint_159 = __rev2_159; \
+uint32x2_t __reint1_159 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_159, __p3_159), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_159, __p3_159)}; \
+  __ret_159 = __noswap_vcmla_rot180_f16(__rev0_159, __rev1_159, *(float16x4_t *) &__reint1_159); \
+  __ret_159 = __builtin_shufflevector(__ret_159, __ret_159, 3, 2, 1, 0); \
+  __ret_159; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot180_lane_f16(__p0_160, __p1_160, __p2_160, __p3_160) __extension__ ({ \
+  float16x8_t __ret_160; \
+  float16x8_t __s0_160 = __p0_160; \
+  float16x8_t __s1_160 = __p1_160; \
+  float16x4_t __s2_160 = __p2_160; \
+float16x4_t __reint_160 = __s2_160; \
+uint32x4_t __reint1_160 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_160, __p3_160), vget_lane_u32(*(uint32x2_t *) &__reint_160, __p3_160), vget_lane_u32(*(uint32x2_t *) &__reint_160, __p3_160), vget_lane_u32(*(uint32x2_t *) &__reint_160, __p3_160)}; \
+  __ret_160 = vcmlaq_rot180_f16(__s0_160, __s1_160, *(float16x8_t *) &__reint1_160); \
+  __ret_160; \
+})
+#else
+#define vcmlaq_rot180_lane_f16(__p0_161, __p1_161, __p2_161, __p3_161) __extension__ ({ \
+  float16x8_t __ret_161; \
+  float16x8_t __s0_161 = __p0_161; \
+  float16x8_t __s1_161 = __p1_161; \
+  float16x4_t __s2_161 = __p2_161; \
+  float16x8_t __rev0_161;  __rev0_161 = __builtin_shufflevector(__s0_161, __s0_161, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_161;  __rev1_161 = __builtin_shufflevector(__s1_161, __s1_161, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev2_161;  __rev2_161 = __builtin_shufflevector(__s2_161, __s2_161, 3, 2, 1, 0); \
+float16x4_t __reint_161 = __rev2_161; \
+uint32x4_t __reint1_161 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_161, __p3_161), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_161, __p3_161), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_161, __p3_161), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_161, __p3_161)}; \
+  __ret_161 = __noswap_vcmlaq_rot180_f16(__rev0_161, __rev1_161, *(float16x8_t *) &__reint1_161); \
+  __ret_161 = __builtin_shufflevector(__ret_161, __ret_161, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_161; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot180_laneq_f16(__p0_162, __p1_162, __p2_162, __p3_162) __extension__ ({ \
+  float16x4_t __ret_162; \
+  float16x4_t __s0_162 = __p0_162; \
+  float16x4_t __s1_162 = __p1_162; \
+  float16x8_t __s2_162 = __p2_162; \
+float16x8_t __reint_162 = __s2_162; \
+uint32x2_t __reint1_162 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_162, __p3_162), vgetq_lane_u32(*(uint32x4_t *) &__reint_162, __p3_162)}; \
+  __ret_162 = vcmla_rot180_f16(__s0_162, __s1_162, *(float16x4_t *) &__reint1_162); \
+  __ret_162; \
+})
+#else
+#define vcmla_rot180_laneq_f16(__p0_163, __p1_163, __p2_163, __p3_163) __extension__ ({ \
+  float16x4_t __ret_163; \
+  float16x4_t __s0_163 = __p0_163; \
+  float16x4_t __s1_163 = __p1_163; \
+  float16x8_t __s2_163 = __p2_163; \
+  float16x4_t __rev0_163;  __rev0_163 = __builtin_shufflevector(__s0_163, __s0_163, 3, 2, 1, 0); \
+  float16x4_t __rev1_163;  __rev1_163 = __builtin_shufflevector(__s1_163, __s1_163, 3, 2, 1, 0); \
+  float16x8_t __rev2_163;  __rev2_163 = __builtin_shufflevector(__s2_163, __s2_163, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_163 = __rev2_163; \
+uint32x2_t __reint1_163 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_163, __p3_163), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_163, __p3_163)}; \
+  __ret_163 = __noswap_vcmla_rot180_f16(__rev0_163, __rev1_163, *(float16x4_t *) &__reint1_163); \
+  __ret_163 = __builtin_shufflevector(__ret_163, __ret_163, 3, 2, 1, 0); \
+  __ret_163; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot180_laneq_f16(__p0_164, __p1_164, __p2_164, __p3_164) __extension__ ({ \
+  float16x8_t __ret_164; \
+  float16x8_t __s0_164 = __p0_164; \
+  float16x8_t __s1_164 = __p1_164; \
+  float16x8_t __s2_164 = __p2_164; \
+float16x8_t __reint_164 = __s2_164; \
+uint32x4_t __reint1_164 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_164, __p3_164), vgetq_lane_u32(*(uint32x4_t *) &__reint_164, __p3_164), vgetq_lane_u32(*(uint32x4_t *) &__reint_164, __p3_164), vgetq_lane_u32(*(uint32x4_t *) &__reint_164, __p3_164)}; \
+  __ret_164 = vcmlaq_rot180_f16(__s0_164, __s1_164, *(float16x8_t *) &__reint1_164); \
+  __ret_164; \
+})
+#else
+#define vcmlaq_rot180_laneq_f16(__p0_165, __p1_165, __p2_165, __p3_165) __extension__ ({ \
+  float16x8_t __ret_165; \
+  float16x8_t __s0_165 = __p0_165; \
+  float16x8_t __s1_165 = __p1_165; \
+  float16x8_t __s2_165 = __p2_165; \
+  float16x8_t __rev0_165;  __rev0_165 = __builtin_shufflevector(__s0_165, __s0_165, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_165;  __rev1_165 = __builtin_shufflevector(__s1_165, __s1_165, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev2_165;  __rev2_165 = __builtin_shufflevector(__s2_165, __s2_165, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_165 = __rev2_165; \
+uint32x4_t __reint1_165 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_165, __p3_165), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_165, __p3_165), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_165, __p3_165), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_165, __p3_165)}; \
+  __ret_165 = __noswap_vcmlaq_rot180_f16(__rev0_165, __rev1_165, *(float16x8_t *) &__reint1_165); \
+  __ret_165 = __builtin_shufflevector(__ret_165, __ret_165, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_165; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot270_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_rot270_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot270_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_rot270_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t __noswap_vcmlaq_rot270_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_rot270_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot270_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcmla_rot270_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot270_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vcmla_rot270_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t __noswap_vcmla_rot270_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcmla_rot270_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot270_lane_f16(__p0_166, __p1_166, __p2_166, __p3_166) __extension__ ({ \
+  float16x4_t __ret_166; \
+  float16x4_t __s0_166 = __p0_166; \
+  float16x4_t __s1_166 = __p1_166; \
+  float16x4_t __s2_166 = __p2_166; \
+float16x4_t __reint_166 = __s2_166; \
+uint32x2_t __reint1_166 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_166, __p3_166), vget_lane_u32(*(uint32x2_t *) &__reint_166, __p3_166)}; \
+  __ret_166 = vcmla_rot270_f16(__s0_166, __s1_166, *(float16x4_t *) &__reint1_166); \
+  __ret_166; \
+})
+#else
+#define vcmla_rot270_lane_f16(__p0_167, __p1_167, __p2_167, __p3_167) __extension__ ({ \
+  float16x4_t __ret_167; \
+  float16x4_t __s0_167 = __p0_167; \
+  float16x4_t __s1_167 = __p1_167; \
+  float16x4_t __s2_167 = __p2_167; \
+  float16x4_t __rev0_167;  __rev0_167 = __builtin_shufflevector(__s0_167, __s0_167, 3, 2, 1, 0); \
+  float16x4_t __rev1_167;  __rev1_167 = __builtin_shufflevector(__s1_167, __s1_167, 3, 2, 1, 0); \
+  float16x4_t __rev2_167;  __rev2_167 = __builtin_shufflevector(__s2_167, __s2_167, 3, 2, 1, 0); \
+float16x4_t __reint_167 = __rev2_167; \
+uint32x2_t __reint1_167 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_167, __p3_167), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_167, __p3_167)}; \
+  __ret_167 = __noswap_vcmla_rot270_f16(__rev0_167, __rev1_167, *(float16x4_t *) &__reint1_167); \
+  __ret_167 = __builtin_shufflevector(__ret_167, __ret_167, 3, 2, 1, 0); \
+  __ret_167; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot270_lane_f16(__p0_168, __p1_168, __p2_168, __p3_168) __extension__ ({ \
+  float16x8_t __ret_168; \
+  float16x8_t __s0_168 = __p0_168; \
+  float16x8_t __s1_168 = __p1_168; \
+  float16x4_t __s2_168 = __p2_168; \
+float16x4_t __reint_168 = __s2_168; \
+uint32x4_t __reint1_168 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_168, __p3_168), vget_lane_u32(*(uint32x2_t *) &__reint_168, __p3_168), vget_lane_u32(*(uint32x2_t *) &__reint_168, __p3_168), vget_lane_u32(*(uint32x2_t *) &__reint_168, __p3_168)}; \
+  __ret_168 = vcmlaq_rot270_f16(__s0_168, __s1_168, *(float16x8_t *) &__reint1_168); \
+  __ret_168; \
+})
+#else
+#define vcmlaq_rot270_lane_f16(__p0_169, __p1_169, __p2_169, __p3_169) __extension__ ({ \
+  float16x8_t __ret_169; \
+  float16x8_t __s0_169 = __p0_169; \
+  float16x8_t __s1_169 = __p1_169; \
+  float16x4_t __s2_169 = __p2_169; \
+  float16x8_t __rev0_169;  __rev0_169 = __builtin_shufflevector(__s0_169, __s0_169, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_169;  __rev1_169 = __builtin_shufflevector(__s1_169, __s1_169, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev2_169;  __rev2_169 = __builtin_shufflevector(__s2_169, __s2_169, 3, 2, 1, 0); \
+float16x4_t __reint_169 = __rev2_169; \
+uint32x4_t __reint1_169 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_169, __p3_169), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_169, __p3_169), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_169, __p3_169), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_169, __p3_169)}; \
+  __ret_169 = __noswap_vcmlaq_rot270_f16(__rev0_169, __rev1_169, *(float16x8_t *) &__reint1_169); \
+  __ret_169 = __builtin_shufflevector(__ret_169, __ret_169, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_169; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot270_laneq_f16(__p0_170, __p1_170, __p2_170, __p3_170) __extension__ ({ \
+  float16x4_t __ret_170; \
+  float16x4_t __s0_170 = __p0_170; \
+  float16x4_t __s1_170 = __p1_170; \
+  float16x8_t __s2_170 = __p2_170; \
+float16x8_t __reint_170 = __s2_170; \
+uint32x2_t __reint1_170 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_170, __p3_170), vgetq_lane_u32(*(uint32x4_t *) &__reint_170, __p3_170)}; \
+  __ret_170 = vcmla_rot270_f16(__s0_170, __s1_170, *(float16x4_t *) &__reint1_170); \
+  __ret_170; \
+})
+#else
+#define vcmla_rot270_laneq_f16(__p0_171, __p1_171, __p2_171, __p3_171) __extension__ ({ \
+  float16x4_t __ret_171; \
+  float16x4_t __s0_171 = __p0_171; \
+  float16x4_t __s1_171 = __p1_171; \
+  float16x8_t __s2_171 = __p2_171; \
+  float16x4_t __rev0_171;  __rev0_171 = __builtin_shufflevector(__s0_171, __s0_171, 3, 2, 1, 0); \
+  float16x4_t __rev1_171;  __rev1_171 = __builtin_shufflevector(__s1_171, __s1_171, 3, 2, 1, 0); \
+  float16x8_t __rev2_171;  __rev2_171 = __builtin_shufflevector(__s2_171, __s2_171, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_171 = __rev2_171; \
+uint32x2_t __reint1_171 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_171, __p3_171), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_171, __p3_171)}; \
+  __ret_171 = __noswap_vcmla_rot270_f16(__rev0_171, __rev1_171, *(float16x4_t *) &__reint1_171); \
+  __ret_171 = __builtin_shufflevector(__ret_171, __ret_171, 3, 2, 1, 0); \
+  __ret_171; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot270_laneq_f16(__p0_172, __p1_172, __p2_172, __p3_172) __extension__ ({ \
+  float16x8_t __ret_172; \
+  float16x8_t __s0_172 = __p0_172; \
+  float16x8_t __s1_172 = __p1_172; \
+  float16x8_t __s2_172 = __p2_172; \
+float16x8_t __reint_172 = __s2_172; \
+uint32x4_t __reint1_172 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_172, __p3_172), vgetq_lane_u32(*(uint32x4_t *) &__reint_172, __p3_172), vgetq_lane_u32(*(uint32x4_t *) &__reint_172, __p3_172), vgetq_lane_u32(*(uint32x4_t *) &__reint_172, __p3_172)}; \
+  __ret_172 = vcmlaq_rot270_f16(__s0_172, __s1_172, *(float16x8_t *) &__reint1_172); \
+  __ret_172; \
+})
+#else
+#define vcmlaq_rot270_laneq_f16(__p0_173, __p1_173, __p2_173, __p3_173) __extension__ ({ \
+  float16x8_t __ret_173; \
+  float16x8_t __s0_173 = __p0_173; \
+  float16x8_t __s1_173 = __p1_173; \
+  float16x8_t __s2_173 = __p2_173; \
+  float16x8_t __rev0_173;  __rev0_173 = __builtin_shufflevector(__s0_173, __s0_173, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_173;  __rev1_173 = __builtin_shufflevector(__s1_173, __s1_173, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev2_173;  __rev2_173 = __builtin_shufflevector(__s2_173, __s2_173, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_173 = __rev2_173; \
+uint32x4_t __reint1_173 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_173, __p3_173), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_173, __p3_173), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_173, __p3_173), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_173, __p3_173)}; \
+  __ret_173 = __noswap_vcmlaq_rot270_f16(__rev0_173, __rev1_173, *(float16x8_t *) &__reint1_173); \
+  __ret_173 = __builtin_shufflevector(__ret_173, __ret_173, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_173; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot90_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_rot90_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t vcmlaq_rot90_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_rot90_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x8_t __noswap_vcmlaq_rot90_f16(float16x8_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vcmlaq_rot90_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 40);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot90_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcmla_rot90_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t vcmla_rot90_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vcmla_rot90_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,fullfp16,neon"))) float16x4_t __noswap_vcmla_rot90_f16(float16x4_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcmla_rot90_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 8);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot90_lane_f16(__p0_174, __p1_174, __p2_174, __p3_174) __extension__ ({ \
+  float16x4_t __ret_174; \
+  float16x4_t __s0_174 = __p0_174; \
+  float16x4_t __s1_174 = __p1_174; \
+  float16x4_t __s2_174 = __p2_174; \
+float16x4_t __reint_174 = __s2_174; \
+uint32x2_t __reint1_174 = (uint32x2_t) {vget_lane_u32(*(uint32x2_t *) &__reint_174, __p3_174), vget_lane_u32(*(uint32x2_t *) &__reint_174, __p3_174)}; \
+  __ret_174 = vcmla_rot90_f16(__s0_174, __s1_174, *(float16x4_t *) &__reint1_174); \
+  __ret_174; \
+})
+#else
+#define vcmla_rot90_lane_f16(__p0_175, __p1_175, __p2_175, __p3_175) __extension__ ({ \
+  float16x4_t __ret_175; \
+  float16x4_t __s0_175 = __p0_175; \
+  float16x4_t __s1_175 = __p1_175; \
+  float16x4_t __s2_175 = __p2_175; \
+  float16x4_t __rev0_175;  __rev0_175 = __builtin_shufflevector(__s0_175, __s0_175, 3, 2, 1, 0); \
+  float16x4_t __rev1_175;  __rev1_175 = __builtin_shufflevector(__s1_175, __s1_175, 3, 2, 1, 0); \
+  float16x4_t __rev2_175;  __rev2_175 = __builtin_shufflevector(__s2_175, __s2_175, 3, 2, 1, 0); \
+float16x4_t __reint_175 = __rev2_175; \
+uint32x2_t __reint1_175 = (uint32x2_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_175, __p3_175), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_175, __p3_175)}; \
+  __ret_175 = __noswap_vcmla_rot90_f16(__rev0_175, __rev1_175, *(float16x4_t *) &__reint1_175); \
+  __ret_175 = __builtin_shufflevector(__ret_175, __ret_175, 3, 2, 1, 0); \
+  __ret_175; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot90_lane_f16(__p0_176, __p1_176, __p2_176, __p3_176) __extension__ ({ \
+  float16x8_t __ret_176; \
+  float16x8_t __s0_176 = __p0_176; \
+  float16x8_t __s1_176 = __p1_176; \
+  float16x4_t __s2_176 = __p2_176; \
+float16x4_t __reint_176 = __s2_176; \
+uint32x4_t __reint1_176 = (uint32x4_t) {vget_lane_u32(*(uint32x2_t *) &__reint_176, __p3_176), vget_lane_u32(*(uint32x2_t *) &__reint_176, __p3_176), vget_lane_u32(*(uint32x2_t *) &__reint_176, __p3_176), vget_lane_u32(*(uint32x2_t *) &__reint_176, __p3_176)}; \
+  __ret_176 = vcmlaq_rot90_f16(__s0_176, __s1_176, *(float16x8_t *) &__reint1_176); \
+  __ret_176; \
+})
+#else
+#define vcmlaq_rot90_lane_f16(__p0_177, __p1_177, __p2_177, __p3_177) __extension__ ({ \
+  float16x8_t __ret_177; \
+  float16x8_t __s0_177 = __p0_177; \
+  float16x8_t __s1_177 = __p1_177; \
+  float16x4_t __s2_177 = __p2_177; \
+  float16x8_t __rev0_177;  __rev0_177 = __builtin_shufflevector(__s0_177, __s0_177, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_177;  __rev1_177 = __builtin_shufflevector(__s1_177, __s1_177, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev2_177;  __rev2_177 = __builtin_shufflevector(__s2_177, __s2_177, 3, 2, 1, 0); \
+float16x4_t __reint_177 = __rev2_177; \
+uint32x4_t __reint1_177 = (uint32x4_t) {__noswap_vget_lane_u32(*(uint32x2_t *) &__reint_177, __p3_177), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_177, __p3_177), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_177, __p3_177), __noswap_vget_lane_u32(*(uint32x2_t *) &__reint_177, __p3_177)}; \
+  __ret_177 = __noswap_vcmlaq_rot90_f16(__rev0_177, __rev1_177, *(float16x8_t *) &__reint1_177); \
+  __ret_177 = __builtin_shufflevector(__ret_177, __ret_177, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_177; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot90_laneq_f16(__p0_178, __p1_178, __p2_178, __p3_178) __extension__ ({ \
+  float16x4_t __ret_178; \
+  float16x4_t __s0_178 = __p0_178; \
+  float16x4_t __s1_178 = __p1_178; \
+  float16x8_t __s2_178 = __p2_178; \
+float16x8_t __reint_178 = __s2_178; \
+uint32x2_t __reint1_178 = (uint32x2_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_178, __p3_178), vgetq_lane_u32(*(uint32x4_t *) &__reint_178, __p3_178)}; \
+  __ret_178 = vcmla_rot90_f16(__s0_178, __s1_178, *(float16x4_t *) &__reint1_178); \
+  __ret_178; \
+})
+#else
+#define vcmla_rot90_laneq_f16(__p0_179, __p1_179, __p2_179, __p3_179) __extension__ ({ \
+  float16x4_t __ret_179; \
+  float16x4_t __s0_179 = __p0_179; \
+  float16x4_t __s1_179 = __p1_179; \
+  float16x8_t __s2_179 = __p2_179; \
+  float16x4_t __rev0_179;  __rev0_179 = __builtin_shufflevector(__s0_179, __s0_179, 3, 2, 1, 0); \
+  float16x4_t __rev1_179;  __rev1_179 = __builtin_shufflevector(__s1_179, __s1_179, 3, 2, 1, 0); \
+  float16x8_t __rev2_179;  __rev2_179 = __builtin_shufflevector(__s2_179, __s2_179, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_179 = __rev2_179; \
+uint32x2_t __reint1_179 = (uint32x2_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_179, __p3_179), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_179, __p3_179)}; \
+  __ret_179 = __noswap_vcmla_rot90_f16(__rev0_179, __rev1_179, *(float16x4_t *) &__reint1_179); \
+  __ret_179 = __builtin_shufflevector(__ret_179, __ret_179, 3, 2, 1, 0); \
+  __ret_179; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot90_laneq_f16(__p0_180, __p1_180, __p2_180, __p3_180) __extension__ ({ \
+  float16x8_t __ret_180; \
+  float16x8_t __s0_180 = __p0_180; \
+  float16x8_t __s1_180 = __p1_180; \
+  float16x8_t __s2_180 = __p2_180; \
+float16x8_t __reint_180 = __s2_180; \
+uint32x4_t __reint1_180 = (uint32x4_t) {vgetq_lane_u32(*(uint32x4_t *) &__reint_180, __p3_180), vgetq_lane_u32(*(uint32x4_t *) &__reint_180, __p3_180), vgetq_lane_u32(*(uint32x4_t *) &__reint_180, __p3_180), vgetq_lane_u32(*(uint32x4_t *) &__reint_180, __p3_180)}; \
+  __ret_180 = vcmlaq_rot90_f16(__s0_180, __s1_180, *(float16x8_t *) &__reint1_180); \
+  __ret_180; \
+})
+#else
+#define vcmlaq_rot90_laneq_f16(__p0_181, __p1_181, __p2_181, __p3_181) __extension__ ({ \
+  float16x8_t __ret_181; \
+  float16x8_t __s0_181 = __p0_181; \
+  float16x8_t __s1_181 = __p1_181; \
+  float16x8_t __s2_181 = __p2_181; \
+  float16x8_t __rev0_181;  __rev0_181 = __builtin_shufflevector(__s0_181, __s0_181, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_181;  __rev1_181 = __builtin_shufflevector(__s1_181, __s1_181, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev2_181;  __rev2_181 = __builtin_shufflevector(__s2_181, __s2_181, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_181 = __rev2_181; \
+uint32x4_t __reint1_181 = (uint32x4_t) {__noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_181, __p3_181), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_181, __p3_181), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_181, __p3_181), __noswap_vgetq_lane_u32(*(uint32x4_t *) &__reint_181, __p3_181)}; \
+  __ret_181 = __noswap_vcmlaq_rot90_f16(__rev0_181, __rev1_181, *(float16x8_t *) &__reint1_181); \
+  __ret_181 = __builtin_shufflevector(__ret_181, __ret_181, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_181; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcadd_rot270_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcadd_rot270_f32((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcadd_rot270_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vcadd_rot270_f32((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcadd_rot90_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcadd_rot90_f32((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcadd_rot90_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vcadd_rot90_f32((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcaddq_rot270_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcaddq_rot270_f32((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcaddq_rot270_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vcaddq_rot270_f32((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcaddq_rot90_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcaddq_rot90_f32((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcaddq_rot90_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vcaddq_rot90_f32((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t __noswap_vcmlaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcmla_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vcmla_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t __noswap_vcmla_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcmla_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_lane_f32(__p0_182, __p1_182, __p2_182, __p3_182) __extension__ ({ \
+  float32x2_t __ret_182; \
+  float32x2_t __s0_182 = __p0_182; \
+  float32x2_t __s1_182 = __p1_182; \
+  float32x2_t __s2_182 = __p2_182; \
+float32x2_t __reint_182 = __s2_182; \
+uint64x1_t __reint1_182 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_182, __p3_182)}; \
+  __ret_182 = vcmla_f32(__s0_182, __s1_182, *(float32x2_t *) &__reint1_182); \
+  __ret_182; \
+})
+#else
+#define vcmla_lane_f32(__p0_183, __p1_183, __p2_183, __p3_183) __extension__ ({ \
+  float32x2_t __ret_183; \
+  float32x2_t __s0_183 = __p0_183; \
+  float32x2_t __s1_183 = __p1_183; \
+  float32x2_t __s2_183 = __p2_183; \
+  float32x2_t __rev0_183;  __rev0_183 = __builtin_shufflevector(__s0_183, __s0_183, 1, 0); \
+  float32x2_t __rev1_183;  __rev1_183 = __builtin_shufflevector(__s1_183, __s1_183, 1, 0); \
+  float32x2_t __rev2_183;  __rev2_183 = __builtin_shufflevector(__s2_183, __s2_183, 1, 0); \
+float32x2_t __reint_183 = __rev2_183; \
+uint64x1_t __reint1_183 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_183, __p3_183)}; \
+  __ret_183 = __noswap_vcmla_f32(__rev0_183, __rev1_183, *(float32x2_t *) &__reint1_183); \
+  __ret_183 = __builtin_shufflevector(__ret_183, __ret_183, 1, 0); \
+  __ret_183; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_lane_f32(__p0_184, __p1_184, __p2_184, __p3_184) __extension__ ({ \
+  float32x4_t __ret_184; \
+  float32x4_t __s0_184 = __p0_184; \
+  float32x4_t __s1_184 = __p1_184; \
+  float32x2_t __s2_184 = __p2_184; \
+float32x2_t __reint_184 = __s2_184; \
+uint64x2_t __reint1_184 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_184, __p3_184), vget_lane_u64(*(uint64x1_t *) &__reint_184, __p3_184)}; \
+  __ret_184 = vcmlaq_f32(__s0_184, __s1_184, *(float32x4_t *) &__reint1_184); \
+  __ret_184; \
+})
+#else
+#define vcmlaq_lane_f32(__p0_185, __p1_185, __p2_185, __p3_185) __extension__ ({ \
+  float32x4_t __ret_185; \
+  float32x4_t __s0_185 = __p0_185; \
+  float32x4_t __s1_185 = __p1_185; \
+  float32x2_t __s2_185 = __p2_185; \
+  float32x4_t __rev0_185;  __rev0_185 = __builtin_shufflevector(__s0_185, __s0_185, 3, 2, 1, 0); \
+  float32x4_t __rev1_185;  __rev1_185 = __builtin_shufflevector(__s1_185, __s1_185, 3, 2, 1, 0); \
+  float32x2_t __rev2_185;  __rev2_185 = __builtin_shufflevector(__s2_185, __s2_185, 1, 0); \
+float32x2_t __reint_185 = __rev2_185; \
+uint64x2_t __reint1_185 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_185, __p3_185), vget_lane_u64(*(uint64x1_t *) &__reint_185, __p3_185)}; \
+  __ret_185 = __noswap_vcmlaq_f32(__rev0_185, __rev1_185, *(float32x4_t *) &__reint1_185); \
+  __ret_185 = __builtin_shufflevector(__ret_185, __ret_185, 3, 2, 1, 0); \
+  __ret_185; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_laneq_f32(__p0_186, __p1_186, __p2_186, __p3_186) __extension__ ({ \
+  float32x2_t __ret_186; \
+  float32x2_t __s0_186 = __p0_186; \
+  float32x2_t __s1_186 = __p1_186; \
+  float32x4_t __s2_186 = __p2_186; \
+float32x4_t __reint_186 = __s2_186; \
+uint64x1_t __reint1_186 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_186, __p3_186)}; \
+  __ret_186 = vcmla_f32(__s0_186, __s1_186, *(float32x2_t *) &__reint1_186); \
+  __ret_186; \
+})
+#else
+#define vcmla_laneq_f32(__p0_187, __p1_187, __p2_187, __p3_187) __extension__ ({ \
+  float32x2_t __ret_187; \
+  float32x2_t __s0_187 = __p0_187; \
+  float32x2_t __s1_187 = __p1_187; \
+  float32x4_t __s2_187 = __p2_187; \
+  float32x2_t __rev0_187;  __rev0_187 = __builtin_shufflevector(__s0_187, __s0_187, 1, 0); \
+  float32x2_t __rev1_187;  __rev1_187 = __builtin_shufflevector(__s1_187, __s1_187, 1, 0); \
+  float32x4_t __rev2_187;  __rev2_187 = __builtin_shufflevector(__s2_187, __s2_187, 3, 2, 1, 0); \
+float32x4_t __reint_187 = __rev2_187; \
+uint64x1_t __reint1_187 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_187, __p3_187)}; \
+  __ret_187 = __noswap_vcmla_f32(__rev0_187, __rev1_187, *(float32x2_t *) &__reint1_187); \
+  __ret_187 = __builtin_shufflevector(__ret_187, __ret_187, 1, 0); \
+  __ret_187; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_laneq_f32(__p0_188, __p1_188, __p2_188, __p3_188) __extension__ ({ \
+  float32x4_t __ret_188; \
+  float32x4_t __s0_188 = __p0_188; \
+  float32x4_t __s1_188 = __p1_188; \
+  float32x4_t __s2_188 = __p2_188; \
+float32x4_t __reint_188 = __s2_188; \
+uint64x2_t __reint1_188 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_188, __p3_188), vgetq_lane_u64(*(uint64x2_t *) &__reint_188, __p3_188)}; \
+  __ret_188 = vcmlaq_f32(__s0_188, __s1_188, *(float32x4_t *) &__reint1_188); \
+  __ret_188; \
+})
+#else
+#define vcmlaq_laneq_f32(__p0_189, __p1_189, __p2_189, __p3_189) __extension__ ({ \
+  float32x4_t __ret_189; \
+  float32x4_t __s0_189 = __p0_189; \
+  float32x4_t __s1_189 = __p1_189; \
+  float32x4_t __s2_189 = __p2_189; \
+  float32x4_t __rev0_189;  __rev0_189 = __builtin_shufflevector(__s0_189, __s0_189, 3, 2, 1, 0); \
+  float32x4_t __rev1_189;  __rev1_189 = __builtin_shufflevector(__s1_189, __s1_189, 3, 2, 1, 0); \
+  float32x4_t __rev2_189;  __rev2_189 = __builtin_shufflevector(__s2_189, __s2_189, 3, 2, 1, 0); \
+float32x4_t __reint_189 = __rev2_189; \
+uint64x2_t __reint1_189 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_189, __p3_189), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_189, __p3_189)}; \
+  __ret_189 = __noswap_vcmlaq_f32(__rev0_189, __rev1_189, *(float32x4_t *) &__reint1_189); \
+  __ret_189 = __builtin_shufflevector(__ret_189, __ret_189, 3, 2, 1, 0); \
+  __ret_189; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot180_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_rot180_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot180_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_rot180_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t __noswap_vcmlaq_rot180_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_rot180_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot180_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcmla_rot180_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot180_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vcmla_rot180_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t __noswap_vcmla_rot180_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcmla_rot180_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot180_lane_f32(__p0_190, __p1_190, __p2_190, __p3_190) __extension__ ({ \
+  float32x2_t __ret_190; \
+  float32x2_t __s0_190 = __p0_190; \
+  float32x2_t __s1_190 = __p1_190; \
+  float32x2_t __s2_190 = __p2_190; \
+float32x2_t __reint_190 = __s2_190; \
+uint64x1_t __reint1_190 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_190, __p3_190)}; \
+  __ret_190 = vcmla_rot180_f32(__s0_190, __s1_190, *(float32x2_t *) &__reint1_190); \
+  __ret_190; \
+})
+#else
+#define vcmla_rot180_lane_f32(__p0_191, __p1_191, __p2_191, __p3_191) __extension__ ({ \
+  float32x2_t __ret_191; \
+  float32x2_t __s0_191 = __p0_191; \
+  float32x2_t __s1_191 = __p1_191; \
+  float32x2_t __s2_191 = __p2_191; \
+  float32x2_t __rev0_191;  __rev0_191 = __builtin_shufflevector(__s0_191, __s0_191, 1, 0); \
+  float32x2_t __rev1_191;  __rev1_191 = __builtin_shufflevector(__s1_191, __s1_191, 1, 0); \
+  float32x2_t __rev2_191;  __rev2_191 = __builtin_shufflevector(__s2_191, __s2_191, 1, 0); \
+float32x2_t __reint_191 = __rev2_191; \
+uint64x1_t __reint1_191 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_191, __p3_191)}; \
+  __ret_191 = __noswap_vcmla_rot180_f32(__rev0_191, __rev1_191, *(float32x2_t *) &__reint1_191); \
+  __ret_191 = __builtin_shufflevector(__ret_191, __ret_191, 1, 0); \
+  __ret_191; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot180_lane_f32(__p0_192, __p1_192, __p2_192, __p3_192) __extension__ ({ \
+  float32x4_t __ret_192; \
+  float32x4_t __s0_192 = __p0_192; \
+  float32x4_t __s1_192 = __p1_192; \
+  float32x2_t __s2_192 = __p2_192; \
+float32x2_t __reint_192 = __s2_192; \
+uint64x2_t __reint1_192 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_192, __p3_192), vget_lane_u64(*(uint64x1_t *) &__reint_192, __p3_192)}; \
+  __ret_192 = vcmlaq_rot180_f32(__s0_192, __s1_192, *(float32x4_t *) &__reint1_192); \
+  __ret_192; \
+})
+#else
+#define vcmlaq_rot180_lane_f32(__p0_193, __p1_193, __p2_193, __p3_193) __extension__ ({ \
+  float32x4_t __ret_193; \
+  float32x4_t __s0_193 = __p0_193; \
+  float32x4_t __s1_193 = __p1_193; \
+  float32x2_t __s2_193 = __p2_193; \
+  float32x4_t __rev0_193;  __rev0_193 = __builtin_shufflevector(__s0_193, __s0_193, 3, 2, 1, 0); \
+  float32x4_t __rev1_193;  __rev1_193 = __builtin_shufflevector(__s1_193, __s1_193, 3, 2, 1, 0); \
+  float32x2_t __rev2_193;  __rev2_193 = __builtin_shufflevector(__s2_193, __s2_193, 1, 0); \
+float32x2_t __reint_193 = __rev2_193; \
+uint64x2_t __reint1_193 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_193, __p3_193), vget_lane_u64(*(uint64x1_t *) &__reint_193, __p3_193)}; \
+  __ret_193 = __noswap_vcmlaq_rot180_f32(__rev0_193, __rev1_193, *(float32x4_t *) &__reint1_193); \
+  __ret_193 = __builtin_shufflevector(__ret_193, __ret_193, 3, 2, 1, 0); \
+  __ret_193; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot180_laneq_f32(__p0_194, __p1_194, __p2_194, __p3_194) __extension__ ({ \
+  float32x2_t __ret_194; \
+  float32x2_t __s0_194 = __p0_194; \
+  float32x2_t __s1_194 = __p1_194; \
+  float32x4_t __s2_194 = __p2_194; \
+float32x4_t __reint_194 = __s2_194; \
+uint64x1_t __reint1_194 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_194, __p3_194)}; \
+  __ret_194 = vcmla_rot180_f32(__s0_194, __s1_194, *(float32x2_t *) &__reint1_194); \
+  __ret_194; \
+})
+#else
+#define vcmla_rot180_laneq_f32(__p0_195, __p1_195, __p2_195, __p3_195) __extension__ ({ \
+  float32x2_t __ret_195; \
+  float32x2_t __s0_195 = __p0_195; \
+  float32x2_t __s1_195 = __p1_195; \
+  float32x4_t __s2_195 = __p2_195; \
+  float32x2_t __rev0_195;  __rev0_195 = __builtin_shufflevector(__s0_195, __s0_195, 1, 0); \
+  float32x2_t __rev1_195;  __rev1_195 = __builtin_shufflevector(__s1_195, __s1_195, 1, 0); \
+  float32x4_t __rev2_195;  __rev2_195 = __builtin_shufflevector(__s2_195, __s2_195, 3, 2, 1, 0); \
+float32x4_t __reint_195 = __rev2_195; \
+uint64x1_t __reint1_195 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_195, __p3_195)}; \
+  __ret_195 = __noswap_vcmla_rot180_f32(__rev0_195, __rev1_195, *(float32x2_t *) &__reint1_195); \
+  __ret_195 = __builtin_shufflevector(__ret_195, __ret_195, 1, 0); \
+  __ret_195; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot180_laneq_f32(__p0_196, __p1_196, __p2_196, __p3_196) __extension__ ({ \
+  float32x4_t __ret_196; \
+  float32x4_t __s0_196 = __p0_196; \
+  float32x4_t __s1_196 = __p1_196; \
+  float32x4_t __s2_196 = __p2_196; \
+float32x4_t __reint_196 = __s2_196; \
+uint64x2_t __reint1_196 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_196, __p3_196), vgetq_lane_u64(*(uint64x2_t *) &__reint_196, __p3_196)}; \
+  __ret_196 = vcmlaq_rot180_f32(__s0_196, __s1_196, *(float32x4_t *) &__reint1_196); \
+  __ret_196; \
+})
+#else
+#define vcmlaq_rot180_laneq_f32(__p0_197, __p1_197, __p2_197, __p3_197) __extension__ ({ \
+  float32x4_t __ret_197; \
+  float32x4_t __s0_197 = __p0_197; \
+  float32x4_t __s1_197 = __p1_197; \
+  float32x4_t __s2_197 = __p2_197; \
+  float32x4_t __rev0_197;  __rev0_197 = __builtin_shufflevector(__s0_197, __s0_197, 3, 2, 1, 0); \
+  float32x4_t __rev1_197;  __rev1_197 = __builtin_shufflevector(__s1_197, __s1_197, 3, 2, 1, 0); \
+  float32x4_t __rev2_197;  __rev2_197 = __builtin_shufflevector(__s2_197, __s2_197, 3, 2, 1, 0); \
+float32x4_t __reint_197 = __rev2_197; \
+uint64x2_t __reint1_197 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_197, __p3_197), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_197, __p3_197)}; \
+  __ret_197 = __noswap_vcmlaq_rot180_f32(__rev0_197, __rev1_197, *(float32x4_t *) &__reint1_197); \
+  __ret_197 = __builtin_shufflevector(__ret_197, __ret_197, 3, 2, 1, 0); \
+  __ret_197; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot270_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_rot270_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot270_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_rot270_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t __noswap_vcmlaq_rot270_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_rot270_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot270_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcmla_rot270_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot270_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vcmla_rot270_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t __noswap_vcmla_rot270_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcmla_rot270_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot270_lane_f32(__p0_198, __p1_198, __p2_198, __p3_198) __extension__ ({ \
+  float32x2_t __ret_198; \
+  float32x2_t __s0_198 = __p0_198; \
+  float32x2_t __s1_198 = __p1_198; \
+  float32x2_t __s2_198 = __p2_198; \
+float32x2_t __reint_198 = __s2_198; \
+uint64x1_t __reint1_198 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_198, __p3_198)}; \
+  __ret_198 = vcmla_rot270_f32(__s0_198, __s1_198, *(float32x2_t *) &__reint1_198); \
+  __ret_198; \
+})
+#else
+#define vcmla_rot270_lane_f32(__p0_199, __p1_199, __p2_199, __p3_199) __extension__ ({ \
+  float32x2_t __ret_199; \
+  float32x2_t __s0_199 = __p0_199; \
+  float32x2_t __s1_199 = __p1_199; \
+  float32x2_t __s2_199 = __p2_199; \
+  float32x2_t __rev0_199;  __rev0_199 = __builtin_shufflevector(__s0_199, __s0_199, 1, 0); \
+  float32x2_t __rev1_199;  __rev1_199 = __builtin_shufflevector(__s1_199, __s1_199, 1, 0); \
+  float32x2_t __rev2_199;  __rev2_199 = __builtin_shufflevector(__s2_199, __s2_199, 1, 0); \
+float32x2_t __reint_199 = __rev2_199; \
+uint64x1_t __reint1_199 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_199, __p3_199)}; \
+  __ret_199 = __noswap_vcmla_rot270_f32(__rev0_199, __rev1_199, *(float32x2_t *) &__reint1_199); \
+  __ret_199 = __builtin_shufflevector(__ret_199, __ret_199, 1, 0); \
+  __ret_199; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot270_lane_f32(__p0_200, __p1_200, __p2_200, __p3_200) __extension__ ({ \
+  float32x4_t __ret_200; \
+  float32x4_t __s0_200 = __p0_200; \
+  float32x4_t __s1_200 = __p1_200; \
+  float32x2_t __s2_200 = __p2_200; \
+float32x2_t __reint_200 = __s2_200; \
+uint64x2_t __reint1_200 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_200, __p3_200), vget_lane_u64(*(uint64x1_t *) &__reint_200, __p3_200)}; \
+  __ret_200 = vcmlaq_rot270_f32(__s0_200, __s1_200, *(float32x4_t *) &__reint1_200); \
+  __ret_200; \
+})
+#else
+#define vcmlaq_rot270_lane_f32(__p0_201, __p1_201, __p2_201, __p3_201) __extension__ ({ \
+  float32x4_t __ret_201; \
+  float32x4_t __s0_201 = __p0_201; \
+  float32x4_t __s1_201 = __p1_201; \
+  float32x2_t __s2_201 = __p2_201; \
+  float32x4_t __rev0_201;  __rev0_201 = __builtin_shufflevector(__s0_201, __s0_201, 3, 2, 1, 0); \
+  float32x4_t __rev1_201;  __rev1_201 = __builtin_shufflevector(__s1_201, __s1_201, 3, 2, 1, 0); \
+  float32x2_t __rev2_201;  __rev2_201 = __builtin_shufflevector(__s2_201, __s2_201, 1, 0); \
+float32x2_t __reint_201 = __rev2_201; \
+uint64x2_t __reint1_201 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_201, __p3_201), vget_lane_u64(*(uint64x1_t *) &__reint_201, __p3_201)}; \
+  __ret_201 = __noswap_vcmlaq_rot270_f32(__rev0_201, __rev1_201, *(float32x4_t *) &__reint1_201); \
+  __ret_201 = __builtin_shufflevector(__ret_201, __ret_201, 3, 2, 1, 0); \
+  __ret_201; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot270_laneq_f32(__p0_202, __p1_202, __p2_202, __p3_202) __extension__ ({ \
+  float32x2_t __ret_202; \
+  float32x2_t __s0_202 = __p0_202; \
+  float32x2_t __s1_202 = __p1_202; \
+  float32x4_t __s2_202 = __p2_202; \
+float32x4_t __reint_202 = __s2_202; \
+uint64x1_t __reint1_202 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_202, __p3_202)}; \
+  __ret_202 = vcmla_rot270_f32(__s0_202, __s1_202, *(float32x2_t *) &__reint1_202); \
+  __ret_202; \
+})
+#else
+#define vcmla_rot270_laneq_f32(__p0_203, __p1_203, __p2_203, __p3_203) __extension__ ({ \
+  float32x2_t __ret_203; \
+  float32x2_t __s0_203 = __p0_203; \
+  float32x2_t __s1_203 = __p1_203; \
+  float32x4_t __s2_203 = __p2_203; \
+  float32x2_t __rev0_203;  __rev0_203 = __builtin_shufflevector(__s0_203, __s0_203, 1, 0); \
+  float32x2_t __rev1_203;  __rev1_203 = __builtin_shufflevector(__s1_203, __s1_203, 1, 0); \
+  float32x4_t __rev2_203;  __rev2_203 = __builtin_shufflevector(__s2_203, __s2_203, 3, 2, 1, 0); \
+float32x4_t __reint_203 = __rev2_203; \
+uint64x1_t __reint1_203 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_203, __p3_203)}; \
+  __ret_203 = __noswap_vcmla_rot270_f32(__rev0_203, __rev1_203, *(float32x2_t *) &__reint1_203); \
+  __ret_203 = __builtin_shufflevector(__ret_203, __ret_203, 1, 0); \
+  __ret_203; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot270_laneq_f32(__p0_204, __p1_204, __p2_204, __p3_204) __extension__ ({ \
+  float32x4_t __ret_204; \
+  float32x4_t __s0_204 = __p0_204; \
+  float32x4_t __s1_204 = __p1_204; \
+  float32x4_t __s2_204 = __p2_204; \
+float32x4_t __reint_204 = __s2_204; \
+uint64x2_t __reint1_204 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_204, __p3_204), vgetq_lane_u64(*(uint64x2_t *) &__reint_204, __p3_204)}; \
+  __ret_204 = vcmlaq_rot270_f32(__s0_204, __s1_204, *(float32x4_t *) &__reint1_204); \
+  __ret_204; \
+})
+#else
+#define vcmlaq_rot270_laneq_f32(__p0_205, __p1_205, __p2_205, __p3_205) __extension__ ({ \
+  float32x4_t __ret_205; \
+  float32x4_t __s0_205 = __p0_205; \
+  float32x4_t __s1_205 = __p1_205; \
+  float32x4_t __s2_205 = __p2_205; \
+  float32x4_t __rev0_205;  __rev0_205 = __builtin_shufflevector(__s0_205, __s0_205, 3, 2, 1, 0); \
+  float32x4_t __rev1_205;  __rev1_205 = __builtin_shufflevector(__s1_205, __s1_205, 3, 2, 1, 0); \
+  float32x4_t __rev2_205;  __rev2_205 = __builtin_shufflevector(__s2_205, __s2_205, 3, 2, 1, 0); \
+float32x4_t __reint_205 = __rev2_205; \
+uint64x2_t __reint1_205 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_205, __p3_205), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_205, __p3_205)}; \
+  __ret_205 = __noswap_vcmlaq_rot270_f32(__rev0_205, __rev1_205, *(float32x4_t *) &__reint1_205); \
+  __ret_205 = __builtin_shufflevector(__ret_205, __ret_205, 3, 2, 1, 0); \
+  __ret_205; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot90_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_rot90_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t vcmlaq_rot90_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_rot90_f32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x4_t __noswap_vcmlaq_rot90_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcmlaq_rot90_f32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot90_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcmla_rot90_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t vcmla_rot90_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vcmla_rot90_f32((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float32x2_t __noswap_vcmla_rot90_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcmla_rot90_f32((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot90_lane_f32(__p0_206, __p1_206, __p2_206, __p3_206) __extension__ ({ \
+  float32x2_t __ret_206; \
+  float32x2_t __s0_206 = __p0_206; \
+  float32x2_t __s1_206 = __p1_206; \
+  float32x2_t __s2_206 = __p2_206; \
+float32x2_t __reint_206 = __s2_206; \
+uint64x1_t __reint1_206 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_206, __p3_206)}; \
+  __ret_206 = vcmla_rot90_f32(__s0_206, __s1_206, *(float32x2_t *) &__reint1_206); \
+  __ret_206; \
+})
+#else
+#define vcmla_rot90_lane_f32(__p0_207, __p1_207, __p2_207, __p3_207) __extension__ ({ \
+  float32x2_t __ret_207; \
+  float32x2_t __s0_207 = __p0_207; \
+  float32x2_t __s1_207 = __p1_207; \
+  float32x2_t __s2_207 = __p2_207; \
+  float32x2_t __rev0_207;  __rev0_207 = __builtin_shufflevector(__s0_207, __s0_207, 1, 0); \
+  float32x2_t __rev1_207;  __rev1_207 = __builtin_shufflevector(__s1_207, __s1_207, 1, 0); \
+  float32x2_t __rev2_207;  __rev2_207 = __builtin_shufflevector(__s2_207, __s2_207, 1, 0); \
+float32x2_t __reint_207 = __rev2_207; \
+uint64x1_t __reint1_207 = (uint64x1_t) {vget_lane_u64(*(uint64x1_t *) &__reint_207, __p3_207)}; \
+  __ret_207 = __noswap_vcmla_rot90_f32(__rev0_207, __rev1_207, *(float32x2_t *) &__reint1_207); \
+  __ret_207 = __builtin_shufflevector(__ret_207, __ret_207, 1, 0); \
+  __ret_207; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot90_lane_f32(__p0_208, __p1_208, __p2_208, __p3_208) __extension__ ({ \
+  float32x4_t __ret_208; \
+  float32x4_t __s0_208 = __p0_208; \
+  float32x4_t __s1_208 = __p1_208; \
+  float32x2_t __s2_208 = __p2_208; \
+float32x2_t __reint_208 = __s2_208; \
+uint64x2_t __reint1_208 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_208, __p3_208), vget_lane_u64(*(uint64x1_t *) &__reint_208, __p3_208)}; \
+  __ret_208 = vcmlaq_rot90_f32(__s0_208, __s1_208, *(float32x4_t *) &__reint1_208); \
+  __ret_208; \
+})
+#else
+#define vcmlaq_rot90_lane_f32(__p0_209, __p1_209, __p2_209, __p3_209) __extension__ ({ \
+  float32x4_t __ret_209; \
+  float32x4_t __s0_209 = __p0_209; \
+  float32x4_t __s1_209 = __p1_209; \
+  float32x2_t __s2_209 = __p2_209; \
+  float32x4_t __rev0_209;  __rev0_209 = __builtin_shufflevector(__s0_209, __s0_209, 3, 2, 1, 0); \
+  float32x4_t __rev1_209;  __rev1_209 = __builtin_shufflevector(__s1_209, __s1_209, 3, 2, 1, 0); \
+  float32x2_t __rev2_209;  __rev2_209 = __builtin_shufflevector(__s2_209, __s2_209, 1, 0); \
+float32x2_t __reint_209 = __rev2_209; \
+uint64x2_t __reint1_209 = (uint64x2_t) {vget_lane_u64(*(uint64x1_t *) &__reint_209, __p3_209), vget_lane_u64(*(uint64x1_t *) &__reint_209, __p3_209)}; \
+  __ret_209 = __noswap_vcmlaq_rot90_f32(__rev0_209, __rev1_209, *(float32x4_t *) &__reint1_209); \
+  __ret_209 = __builtin_shufflevector(__ret_209, __ret_209, 3, 2, 1, 0); \
+  __ret_209; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot90_laneq_f32(__p0_210, __p1_210, __p2_210, __p3_210) __extension__ ({ \
+  float32x2_t __ret_210; \
+  float32x2_t __s0_210 = __p0_210; \
+  float32x2_t __s1_210 = __p1_210; \
+  float32x4_t __s2_210 = __p2_210; \
+float32x4_t __reint_210 = __s2_210; \
+uint64x1_t __reint1_210 = (uint64x1_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_210, __p3_210)}; \
+  __ret_210 = vcmla_rot90_f32(__s0_210, __s1_210, *(float32x2_t *) &__reint1_210); \
+  __ret_210; \
+})
+#else
+#define vcmla_rot90_laneq_f32(__p0_211, __p1_211, __p2_211, __p3_211) __extension__ ({ \
+  float32x2_t __ret_211; \
+  float32x2_t __s0_211 = __p0_211; \
+  float32x2_t __s1_211 = __p1_211; \
+  float32x4_t __s2_211 = __p2_211; \
+  float32x2_t __rev0_211;  __rev0_211 = __builtin_shufflevector(__s0_211, __s0_211, 1, 0); \
+  float32x2_t __rev1_211;  __rev1_211 = __builtin_shufflevector(__s1_211, __s1_211, 1, 0); \
+  float32x4_t __rev2_211;  __rev2_211 = __builtin_shufflevector(__s2_211, __s2_211, 3, 2, 1, 0); \
+float32x4_t __reint_211 = __rev2_211; \
+uint64x1_t __reint1_211 = (uint64x1_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_211, __p3_211)}; \
+  __ret_211 = __noswap_vcmla_rot90_f32(__rev0_211, __rev1_211, *(float32x2_t *) &__reint1_211); \
+  __ret_211 = __builtin_shufflevector(__ret_211, __ret_211, 1, 0); \
+  __ret_211; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot90_laneq_f32(__p0_212, __p1_212, __p2_212, __p3_212) __extension__ ({ \
+  float32x4_t __ret_212; \
+  float32x4_t __s0_212 = __p0_212; \
+  float32x4_t __s1_212 = __p1_212; \
+  float32x4_t __s2_212 = __p2_212; \
+float32x4_t __reint_212 = __s2_212; \
+uint64x2_t __reint1_212 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_212, __p3_212), vgetq_lane_u64(*(uint64x2_t *) &__reint_212, __p3_212)}; \
+  __ret_212 = vcmlaq_rot90_f32(__s0_212, __s1_212, *(float32x4_t *) &__reint1_212); \
+  __ret_212; \
+})
+#else
+#define vcmlaq_rot90_laneq_f32(__p0_213, __p1_213, __p2_213, __p3_213) __extension__ ({ \
+  float32x4_t __ret_213; \
+  float32x4_t __s0_213 = __p0_213; \
+  float32x4_t __s1_213 = __p1_213; \
+  float32x4_t __s2_213 = __p2_213; \
+  float32x4_t __rev0_213;  __rev0_213 = __builtin_shufflevector(__s0_213, __s0_213, 3, 2, 1, 0); \
+  float32x4_t __rev1_213;  __rev1_213 = __builtin_shufflevector(__s1_213, __s1_213, 3, 2, 1, 0); \
+  float32x4_t __rev2_213;  __rev2_213 = __builtin_shufflevector(__s2_213, __s2_213, 3, 2, 1, 0); \
+float32x4_t __reint_213 = __rev2_213; \
+uint64x2_t __reint1_213 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_213, __p3_213), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_213, __p3_213)}; \
+  __ret_213 = __noswap_vcmlaq_rot90_f32(__rev0_213, __rev1_213, *(float32x4_t *) &__reint1_213); \
+  __ret_213 = __builtin_shufflevector(__ret_213, __ret_213, 3, 2, 1, 0); \
+  __ret_213; \
+})
+#endif
+
+#if !defined(__aarch64__) && !defined(__arm64ec__)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t __a32_vcvt_bf16_f32(float32x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t) __builtin_neon___a32_vcvt_bf16_f32((int8x16_t)__p0, 11);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t __a32_vcvt_bf16_f32(float32x4_t __p0) {
+  bfloat16x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (bfloat16x4_t) __builtin_neon___a32_vcvt_bf16_f32((int8x16_t)__rev0, 11);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t __noswap___a32_vcvt_bf16_f32(float32x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t) __builtin_neon___a32_vcvt_bf16_f32((int8x16_t)__p0, 11);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = __a32_vcvt_bf16_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
+  bfloat16x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap___a32_vcvt_bf16_f32(__rev0);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
+  bfloat16x8_t __ret;
+  __ret = vcombine_bf16(__a32_vcvt_bf16_f32(__p1), vget_low_bf16(__p0));
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
+  bfloat16x8_t __ret;
+  bfloat16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_bf16(__noswap___a32_vcvt_bf16_f32(__rev1), __noswap_vget_low_bf16(__rev0));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = vcombine_bf16((bfloat16x4_t)(0ULL), __a32_vcvt_bf16_f32(__p0));
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
+  bfloat16x8_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_bf16((bfloat16x4_t)(0ULL), __noswap___a32_vcvt_bf16_f32(__rev0));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("bf16,neon"))) poly8x8_t vreinterpret_p8_bf16(bfloat16x4_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly64x1_t vreinterpret_p64_bf16(bfloat16x4_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly16x4_t vreinterpret_p16_bf16(bfloat16x4_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly8x16_t vreinterpretq_p8_bf16(bfloat16x8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly64x2_t vreinterpretq_p64_bf16(bfloat16x8_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly16x8_t vreinterpretq_p16_bf16(bfloat16x8_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint8x16_t vreinterpretq_u8_bf16(bfloat16x8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint32x4_t vreinterpretq_u32_bf16(bfloat16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint64x2_t vreinterpretq_u64_bf16(bfloat16x8_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint16x8_t vreinterpretq_u16_bf16(bfloat16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int8x16_t vreinterpretq_s8_bf16(bfloat16x8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x4_t vreinterpretq_f32_bf16(bfloat16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float16x8_t vreinterpretq_f16_bf16(bfloat16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int32x4_t vreinterpretq_s32_bf16(bfloat16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int64x2_t vreinterpretq_s64_bf16(bfloat16x8_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int16x8_t vreinterpretq_s16_bf16(bfloat16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint8x8_t vreinterpret_u8_bf16(bfloat16x4_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint32x2_t vreinterpret_u32_bf16(bfloat16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint64x1_t vreinterpret_u64_bf16(bfloat16x4_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint16x4_t vreinterpret_u16_bf16(bfloat16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int8x8_t vreinterpret_s8_bf16(bfloat16x4_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x2_t vreinterpret_f32_bf16(bfloat16x4_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float16x4_t vreinterpret_f16_bf16(bfloat16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int32x2_t vreinterpret_s32_bf16(bfloat16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int64x1_t vreinterpret_s64_bf16(bfloat16x4_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int16x4_t vreinterpret_s16_bf16(bfloat16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p8(poly8x16_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p64(poly64x2_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p16(poly16x8_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u8(uint8x16_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u32(uint32x4_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u64(uint64x2_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u16(uint16x8_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s8(int8x16_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_f32(float32x4_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_f16(float16x8_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s32(int32x4_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s64(int64x2_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s16(int16x8_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p8(poly8x8_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p64(poly64x1_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p16(poly16x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u8(uint8x8_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u32(uint32x2_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u64(uint64x1_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u16(uint16x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s8(int8x8_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_f32(float32x2_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_f16(float16x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s32(int32x2_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s64(int64x1_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s16(int16x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhq_lane_s32(__p0_214, __p1_214, __p2_214) __extension__ ({ \
+  int32x4_t __ret_214; \
+  int32x4_t __s0_214 = __p0_214; \
+  int32x2_t __s1_214 = __p1_214; \
+  __ret_214 = vqdmulhq_s32(__s0_214, splatq_lane_s32(__s1_214, __p2_214)); \
+  __ret_214; \
+})
+#else
+#define vqdmulhq_lane_s32(__p0_215, __p1_215, __p2_215) __extension__ ({ \
+  int32x4_t __ret_215; \
+  int32x4_t __s0_215 = __p0_215; \
+  int32x2_t __s1_215 = __p1_215; \
+  int32x4_t __rev0_215;  __rev0_215 = __builtin_shufflevector(__s0_215, __s0_215, 3, 2, 1, 0); \
+  int32x2_t __rev1_215;  __rev1_215 = __builtin_shufflevector(__s1_215, __s1_215, 1, 0); \
+  __ret_215 = __noswap_vqdmulhq_s32(__rev0_215, __noswap_splatq_lane_s32(__rev1_215, __p2_215)); \
+  __ret_215 = __builtin_shufflevector(__ret_215, __ret_215, 3, 2, 1, 0); \
+  __ret_215; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhq_lane_s16(__p0_216, __p1_216, __p2_216) __extension__ ({ \
+  int16x8_t __ret_216; \
+  int16x8_t __s0_216 = __p0_216; \
+  int16x4_t __s1_216 = __p1_216; \
+  __ret_216 = vqdmulhq_s16(__s0_216, splatq_lane_s16(__s1_216, __p2_216)); \
+  __ret_216; \
+})
+#else
+#define vqdmulhq_lane_s16(__p0_217, __p1_217, __p2_217) __extension__ ({ \
+  int16x8_t __ret_217; \
+  int16x8_t __s0_217 = __p0_217; \
+  int16x4_t __s1_217 = __p1_217; \
+  int16x8_t __rev0_217;  __rev0_217 = __builtin_shufflevector(__s0_217, __s0_217, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev1_217;  __rev1_217 = __builtin_shufflevector(__s1_217, __s1_217, 3, 2, 1, 0); \
+  __ret_217 = __noswap_vqdmulhq_s16(__rev0_217, __noswap_splatq_lane_s16(__rev1_217, __p2_217)); \
+  __ret_217 = __builtin_shufflevector(__ret_217, __ret_217, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_217; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulh_lane_s32(__p0_218, __p1_218, __p2_218) __extension__ ({ \
+  int32x2_t __ret_218; \
+  int32x2_t __s0_218 = __p0_218; \
+  int32x2_t __s1_218 = __p1_218; \
+  __ret_218 = vqdmulh_s32(__s0_218, splat_lane_s32(__s1_218, __p2_218)); \
+  __ret_218; \
+})
+#else
+#define vqdmulh_lane_s32(__p0_219, __p1_219, __p2_219) __extension__ ({ \
+  int32x2_t __ret_219; \
+  int32x2_t __s0_219 = __p0_219; \
+  int32x2_t __s1_219 = __p1_219; \
+  int32x2_t __rev0_219;  __rev0_219 = __builtin_shufflevector(__s0_219, __s0_219, 1, 0); \
+  int32x2_t __rev1_219;  __rev1_219 = __builtin_shufflevector(__s1_219, __s1_219, 1, 0); \
+  __ret_219 = __noswap_vqdmulh_s32(__rev0_219, __noswap_splat_lane_s32(__rev1_219, __p2_219)); \
+  __ret_219 = __builtin_shufflevector(__ret_219, __ret_219, 1, 0); \
+  __ret_219; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulh_lane_s16(__p0_220, __p1_220, __p2_220) __extension__ ({ \
+  int16x4_t __ret_220; \
+  int16x4_t __s0_220 = __p0_220; \
+  int16x4_t __s1_220 = __p1_220; \
+  __ret_220 = vqdmulh_s16(__s0_220, splat_lane_s16(__s1_220, __p2_220)); \
+  __ret_220; \
+})
+#else
+#define vqdmulh_lane_s16(__p0_221, __p1_221, __p2_221) __extension__ ({ \
+  int16x4_t __ret_221; \
+  int16x4_t __s0_221 = __p0_221; \
+  int16x4_t __s1_221 = __p1_221; \
+  int16x4_t __rev0_221;  __rev0_221 = __builtin_shufflevector(__s0_221, __s0_221, 3, 2, 1, 0); \
+  int16x4_t __rev1_221;  __rev1_221 = __builtin_shufflevector(__s1_221, __s1_221, 3, 2, 1, 0); \
+  __ret_221 = __noswap_vqdmulh_s16(__rev0_221, __noswap_splat_lane_s16(__rev1_221, __p2_221)); \
+  __ret_221 = __builtin_shufflevector(__ret_221, __ret_221, 3, 2, 1, 0); \
+  __ret_221; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulhq_lane_s32(__p0_222, __p1_222, __p2_222) __extension__ ({ \
+  int32x4_t __ret_222; \
+  int32x4_t __s0_222 = __p0_222; \
+  int32x2_t __s1_222 = __p1_222; \
+  __ret_222 = vqrdmulhq_s32(__s0_222, splatq_lane_s32(__s1_222, __p2_222)); \
+  __ret_222; \
+})
+#else
+#define vqrdmulhq_lane_s32(__p0_223, __p1_223, __p2_223) __extension__ ({ \
+  int32x4_t __ret_223; \
+  int32x4_t __s0_223 = __p0_223; \
+  int32x2_t __s1_223 = __p1_223; \
+  int32x4_t __rev0_223;  __rev0_223 = __builtin_shufflevector(__s0_223, __s0_223, 3, 2, 1, 0); \
+  int32x2_t __rev1_223;  __rev1_223 = __builtin_shufflevector(__s1_223, __s1_223, 1, 0); \
+  __ret_223 = __noswap_vqrdmulhq_s32(__rev0_223, __noswap_splatq_lane_s32(__rev1_223, __p2_223)); \
+  __ret_223 = __builtin_shufflevector(__ret_223, __ret_223, 3, 2, 1, 0); \
+  __ret_223; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulhq_lane_s16(__p0_224, __p1_224, __p2_224) __extension__ ({ \
+  int16x8_t __ret_224; \
+  int16x8_t __s0_224 = __p0_224; \
+  int16x4_t __s1_224 = __p1_224; \
+  __ret_224 = vqrdmulhq_s16(__s0_224, splatq_lane_s16(__s1_224, __p2_224)); \
+  __ret_224; \
+})
+#else
+#define vqrdmulhq_lane_s16(__p0_225, __p1_225, __p2_225) __extension__ ({ \
+  int16x8_t __ret_225; \
+  int16x8_t __s0_225 = __p0_225; \
+  int16x4_t __s1_225 = __p1_225; \
+  int16x8_t __rev0_225;  __rev0_225 = __builtin_shufflevector(__s0_225, __s0_225, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev1_225;  __rev1_225 = __builtin_shufflevector(__s1_225, __s1_225, 3, 2, 1, 0); \
+  __ret_225 = __noswap_vqrdmulhq_s16(__rev0_225, __noswap_splatq_lane_s16(__rev1_225, __p2_225)); \
+  __ret_225 = __builtin_shufflevector(__ret_225, __ret_225, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_225; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulh_lane_s32(__p0_226, __p1_226, __p2_226) __extension__ ({ \
+  int32x2_t __ret_226; \
+  int32x2_t __s0_226 = __p0_226; \
+  int32x2_t __s1_226 = __p1_226; \
+  __ret_226 = vqrdmulh_s32(__s0_226, splat_lane_s32(__s1_226, __p2_226)); \
+  __ret_226; \
+})
+#else
+#define vqrdmulh_lane_s32(__p0_227, __p1_227, __p2_227) __extension__ ({ \
+  int32x2_t __ret_227; \
+  int32x2_t __s0_227 = __p0_227; \
+  int32x2_t __s1_227 = __p1_227; \
+  int32x2_t __rev0_227;  __rev0_227 = __builtin_shufflevector(__s0_227, __s0_227, 1, 0); \
+  int32x2_t __rev1_227;  __rev1_227 = __builtin_shufflevector(__s1_227, __s1_227, 1, 0); \
+  __ret_227 = __noswap_vqrdmulh_s32(__rev0_227, __noswap_splat_lane_s32(__rev1_227, __p2_227)); \
+  __ret_227 = __builtin_shufflevector(__ret_227, __ret_227, 1, 0); \
+  __ret_227; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulh_lane_s16(__p0_228, __p1_228, __p2_228) __extension__ ({ \
+  int16x4_t __ret_228; \
+  int16x4_t __s0_228 = __p0_228; \
+  int16x4_t __s1_228 = __p1_228; \
+  __ret_228 = vqrdmulh_s16(__s0_228, splat_lane_s16(__s1_228, __p2_228)); \
+  __ret_228; \
+})
+#else
+#define vqrdmulh_lane_s16(__p0_229, __p1_229, __p2_229) __extension__ ({ \
+  int16x4_t __ret_229; \
+  int16x4_t __s0_229 = __p0_229; \
+  int16x4_t __s1_229 = __p1_229; \
+  int16x4_t __rev0_229;  __rev0_229 = __builtin_shufflevector(__s0_229, __s0_229, 3, 2, 1, 0); \
+  int16x4_t __rev1_229;  __rev1_229 = __builtin_shufflevector(__s1_229, __s1_229, 3, 2, 1, 0); \
+  __ret_229 = __noswap_vqrdmulh_s16(__rev0_229, __noswap_splat_lane_s16(__rev1_229, __p2_229)); \
+  __ret_229 = __builtin_shufflevector(__ret_229, __ret_229, 3, 2, 1, 0); \
+  __ret_229; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_p16(poly16x4_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u8(uint8x8_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u32(uint32x2_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u64(uint64x1_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u16(uint16x4_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s8(int8x8_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_f32(float32x2_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_f16(float16x4_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s32(int32x2_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s64(int64x1_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s16(int16x4_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_p8(poly8x8_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u8(uint8x8_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u32(uint32x2_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u64(uint64x1_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u16(uint16x4_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s8(int8x8_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_f32(float32x2_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_f16(float16x4_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s32(int32x2_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s64(int64x1_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s16(int16x4_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_p16(poly16x8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u8(uint8x16_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u32(uint32x4_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u64(uint64x2_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u16(uint16x8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s8(int8x16_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_f32(float32x4_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_f16(float16x8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s32(int32x4_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s64(int64x2_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s16(int16x8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_p8(poly8x16_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u8(uint8x16_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u32(uint32x4_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u64(uint64x2_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u16(uint16x8_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s8(int8x16_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_f32(float32x4_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_f16(float16x8_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s32(int32x4_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s64(int64x2_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s16(int16x8_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p8(poly8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p16(poly16x8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u32(uint32x4_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u64(uint64x2_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u16(uint16x8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_f32(float32x4_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_f16(float16x8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s32(int32x4_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s64(int64x2_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s16(int16x8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p8(poly8x16_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p16(poly16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u8(uint8x16_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u64(uint64x2_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u16(uint16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s8(int8x16_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_f16(float16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s64(int64x2_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s16(int16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p8(poly8x16_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p16(poly16x8_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u8(uint8x16_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u32(uint32x4_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u16(uint16x8_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s8(int8x16_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_f32(float32x4_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_f16(float16x8_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s32(int32x4_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s16(int16x8_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p8(poly8x16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p16(poly16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u8(uint8x16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u32(uint32x4_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u64(uint64x2_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s8(int8x16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_f32(float32x4_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s32(int32x4_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s64(int64x2_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p8(poly8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p16(poly16x8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u8(uint8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u32(uint32x4_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u64(uint64x2_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u16(uint16x8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_f32(float32x4_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_f16(float16x8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s32(int32x4_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s64(int64x2_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s16(int16x8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p8(poly8x16_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p16(poly16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u8(uint8x16_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u32(uint32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u64(uint64x2_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u16(uint16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s8(int8x16_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_f16(float16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s32(int32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s64(int64x2_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s16(int16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p8(poly8x16_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p16(poly16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u8(uint8x16_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u32(uint32x4_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u64(uint64x2_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u16(uint16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s8(int8x16_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_f32(float32x4_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s32(int32x4_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s64(int64x2_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s16(int16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p8(poly8x16_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p16(poly16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u8(uint8x16_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u32(uint32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u64(uint64x2_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u16(uint16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s8(int8x16_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_f16(float16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s64(int64x2_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s16(int16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p8(poly8x16_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p16(poly16x8_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u8(uint8x16_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u32(uint32x4_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u64(uint64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u16(uint16x8_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s8(int8x16_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_f32(float32x4_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_f16(float16x8_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s32(int32x4_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s16(int16x8_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p8(poly8x16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p16(poly16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u8(uint8x16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u32(uint32x4_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u64(uint64x2_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u16(uint16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s8(int8x16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_f32(float32x4_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s32(int32x4_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s64(int64x2_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_p8(poly8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_p16(poly16x4_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u32(uint32x2_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u64(uint64x1_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u16(uint16x4_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_f32(float32x2_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_f16(float16x4_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s32(int32x2_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s64(int64x1_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s16(int16x4_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_p8(poly8x8_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_p16(poly16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u8(uint8x8_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u64(uint64x1_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u16(uint16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s8(int8x8_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_f16(float16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s64(int64x1_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s16(int16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_p8(poly8x8_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_p16(poly16x4_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u8(uint8x8_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u32(uint32x2_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u16(uint16x4_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s8(int8x8_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_f32(float32x2_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_f16(float16x4_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s32(int32x2_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s64(int64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s16(int16x4_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_p8(poly8x8_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_p16(poly16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u8(uint8x8_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u32(uint32x2_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u64(uint64x1_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s8(int8x8_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_f32(float32x2_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s32(int32x2_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s64(int64x1_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_p8(poly8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_p16(poly16x4_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u8(uint8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u32(uint32x2_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u64(uint64x1_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u16(uint16x4_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_f32(float32x2_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_f16(float16x4_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s32(int32x2_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s64(int64x1_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s16(int16x4_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_p8(poly8x8_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_p16(poly16x4_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u8(uint8x8_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u32(uint32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u64(uint64x1_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u16(uint16x4_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s8(int8x8_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_f16(float16x4_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s32(int32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s64(int64x1_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s16(int16x4_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_p8(poly8x8_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_p16(poly16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u8(uint8x8_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u32(uint32x2_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u64(uint64x1_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u16(uint16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s8(int8x8_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_f32(float32x2_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s32(int32x2_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s64(int64x1_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s16(int16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_p8(poly8x8_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_p16(poly16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u8(uint8x8_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u32(uint32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u64(uint64x1_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u16(uint16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s8(int8x8_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_f16(float16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s64(int64x1_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s16(int16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_p8(poly8x8_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_p16(poly16x4_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u8(uint8x8_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u32(uint32x2_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u64(uint64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u16(uint16x4_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s8(int8x8_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_f32(float32x2_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_f16(float16x4_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s32(int32x2_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s16(int16x4_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_p8(poly8x8_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_p16(poly16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u8(uint8x8_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u32(uint32x2_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u64(uint64x1_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u16(uint16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s8(int8x8_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_f32(float32x2_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s32(int32x2_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s64(int64x1_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+#endif
+#if (__ARM_FP & 2)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vcvt_f16_f32(float32x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcvt_f16_f32((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vcvt_f16_f32(float32x4_t __p0) {
+  float16x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vcvt_f16_f32((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t __noswap_vcvt_f16_f32(float32x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vcvt_f16_f32((int8x16_t)__p0, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vcvt_f32_f16(float16x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcvt_f32_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcvt_f32_f16(float16x4_t __p0) {
+  float32x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vcvt_f32_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t __noswap_vcvt_f32_f16(float16x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vcvt_f32_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f16(__p0) __extension__ ({ \
+  float16x8_t __ret; \
+  __ret = (float16x8_t) __builtin_neon_vld1q_v(__p0, 40); \
+  __ret; \
+})
+#else
+#define vld1q_f16(__p0) __extension__ ({ \
+  float16x8_t __ret; \
+  __ret = (float16x8_t) __builtin_neon_vld1q_v(__p0, 40); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_f16(__p0) __extension__ ({ \
+  float16x4_t __ret; \
+  __ret = (float16x4_t) __builtin_neon_vld1_v(__p0, 8); \
+  __ret; \
+})
+#else
+#define vld1_f16(__p0) __extension__ ({ \
+  float16x4_t __ret; \
+  __ret = (float16x4_t) __builtin_neon_vld1_v(__p0, 8); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_f16(__p0) __extension__ ({ \
+  float16x8_t __ret; \
+  __ret = (float16x8_t) __builtin_neon_vld1q_dup_v(__p0, 40); \
+  __ret; \
+})
+#else
+#define vld1q_dup_f16(__p0) __extension__ ({ \
+  float16x8_t __ret; \
+  __ret = (float16x8_t) __builtin_neon_vld1q_dup_v(__p0, 40); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_dup_f16(__p0) __extension__ ({ \
+  float16x4_t __ret; \
+  __ret = (float16x4_t) __builtin_neon_vld1_dup_v(__p0, 8); \
+  __ret; \
+})
+#else
+#define vld1_dup_f16(__p0) __extension__ ({ \
+  float16x4_t __ret; \
+  __ret = (float16x4_t) __builtin_neon_vld1_dup_v(__p0, 8); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s1 = __p1; \
+  __ret = (float16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 40); \
+  __ret; \
+})
+#else
+#define vld1q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s1 = __p1; \
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16x8_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 40); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s1 = __p1; \
+  __ret = (float16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 8); \
+  __ret; \
+})
+#else
+#define vld1_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s1 = __p1; \
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (float16x4_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__rev1, __p2, 8); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f16_x2(__p0) __extension__ ({ \
+  float16x8x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 40); \
+  __ret; \
+})
+#else
+#define vld1q_f16_x2(__p0) __extension__ ({ \
+  float16x8x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_f16_x2(__p0) __extension__ ({ \
+  float16x4x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 8); \
+  __ret; \
+})
+#else
+#define vld1_f16_x2(__p0) __extension__ ({ \
+  float16x4x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f16_x3(__p0) __extension__ ({ \
+  float16x8x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 40); \
+  __ret; \
+})
+#else
+#define vld1q_f16_x3(__p0) __extension__ ({ \
+  float16x8x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_f16_x3(__p0) __extension__ ({ \
+  float16x4x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 8); \
+  __ret; \
+})
+#else
+#define vld1_f16_x3(__p0) __extension__ ({ \
+  float16x4x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f16_x4(__p0) __extension__ ({ \
+  float16x8x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 40); \
+  __ret; \
+})
+#else
+#define vld1q_f16_x4(__p0) __extension__ ({ \
+  float16x8x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1_f16_x4(__p0) __extension__ ({ \
+  float16x4x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 8); \
+  __ret; \
+})
+#else
+#define vld1_f16_x4(__p0) __extension__ ({ \
+  float16x4x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_f16(__p0) __extension__ ({ \
+  float16x8x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 40); \
+  __ret; \
+})
+#else
+#define vld2q_f16(__p0) __extension__ ({ \
+  float16x8x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_f16(__p0) __extension__ ({ \
+  float16x4x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 8); \
+  __ret; \
+})
+#else
+#define vld2_f16(__p0) __extension__ ({ \
+  float16x4x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_f16(__p0) __extension__ ({ \
+  float16x8x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 40); \
+  __ret; \
+})
+#else
+#define vld2q_dup_f16(__p0) __extension__ ({ \
+  float16x8x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_dup_f16(__p0) __extension__ ({ \
+  float16x4x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 8); \
+  __ret; \
+})
+#else
+#define vld2_dup_f16(__p0) __extension__ ({ \
+  float16x4x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x2_t __ret; \
+  float16x8x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 40); \
+  __ret; \
+})
+#else
+#define vld2q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x2_t __ret; \
+  float16x8x2_t __s1 = __p1; \
+  float16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x2_t __ret; \
+  float16x4x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 8); \
+  __ret; \
+})
+#else
+#define vld2_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x2_t __ret; \
+  float16x4x2_t __s1 = __p1; \
+  float16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_f16(__p0) __extension__ ({ \
+  float16x8x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 40); \
+  __ret; \
+})
+#else
+#define vld3q_f16(__p0) __extension__ ({ \
+  float16x8x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_f16(__p0) __extension__ ({ \
+  float16x4x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 8); \
+  __ret; \
+})
+#else
+#define vld3_f16(__p0) __extension__ ({ \
+  float16x4x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_f16(__p0) __extension__ ({ \
+  float16x8x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 40); \
+  __ret; \
+})
+#else
+#define vld3q_dup_f16(__p0) __extension__ ({ \
+  float16x8x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_dup_f16(__p0) __extension__ ({ \
+  float16x4x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 8); \
+  __ret; \
+})
+#else
+#define vld3_dup_f16(__p0) __extension__ ({ \
+  float16x4x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x3_t __ret; \
+  float16x8x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 40); \
+  __ret; \
+})
+#else
+#define vld3q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x3_t __ret; \
+  float16x8x3_t __s1 = __p1; \
+  float16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x3_t __ret; \
+  float16x4x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 8); \
+  __ret; \
+})
+#else
+#define vld3_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x3_t __ret; \
+  float16x4x3_t __s1 = __p1; \
+  float16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_f16(__p0) __extension__ ({ \
+  float16x8x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 40); \
+  __ret; \
+})
+#else
+#define vld4q_f16(__p0) __extension__ ({ \
+  float16x8x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_f16(__p0) __extension__ ({ \
+  float16x4x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 8); \
+  __ret; \
+})
+#else
+#define vld4_f16(__p0) __extension__ ({ \
+  float16x4x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_f16(__p0) __extension__ ({ \
+  float16x8x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 40); \
+  __ret; \
+})
+#else
+#define vld4q_dup_f16(__p0) __extension__ ({ \
+  float16x8x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_dup_f16(__p0) __extension__ ({ \
+  float16x4x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 8); \
+  __ret; \
+})
+#else
+#define vld4_dup_f16(__p0) __extension__ ({ \
+  float16x4x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x4_t __ret; \
+  float16x8x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 40); \
+  __ret; \
+})
+#else
+#define vld4q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x4_t __ret; \
+  float16x8x4_t __s1 = __p1; \
+  float16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 40); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x4_t __ret; \
+  float16x4x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 8); \
+  __ret; \
+})
+#else
+#define vld4_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x4_t __ret; \
+  float16x4x4_t __s1 = __p1; \
+  float16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 8); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 40); \
+})
+#else
+#define vst1q_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __s1 = __p1; \
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 8); \
+})
+#else
+#define vst1_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __s1 = __p1; \
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__rev1, 8); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 40); \
+})
+#else
+#define vst1q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8_t __s1 = __p1; \
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 8); \
+})
+#else
+#define vst1_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4_t __s1 = __p1; \
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__rev1, __p2, 8); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f16_x2(__p0, __p1) __extension__ ({ \
+  float16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 40); \
+})
+#else
+#define vst1q_f16_x2(__p0, __p1) __extension__ ({ \
+  float16x8x2_t __s1 = __p1; \
+  float16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_f16_x2(__p0, __p1) __extension__ ({ \
+  float16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 8); \
+})
+#else
+#define vst1_f16_x2(__p0, __p1) __extension__ ({ \
+  float16x4x2_t __s1 = __p1; \
+  float16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 8); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f16_x3(__p0, __p1) __extension__ ({ \
+  float16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 40); \
+})
+#else
+#define vst1q_f16_x3(__p0, __p1) __extension__ ({ \
+  float16x8x3_t __s1 = __p1; \
+  float16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_f16_x3(__p0, __p1) __extension__ ({ \
+  float16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 8); \
+})
+#else
+#define vst1_f16_x3(__p0, __p1) __extension__ ({ \
+  float16x4x3_t __s1 = __p1; \
+  float16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 8); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f16_x4(__p0, __p1) __extension__ ({ \
+  float16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 40); \
+})
+#else
+#define vst1q_f16_x4(__p0, __p1) __extension__ ({ \
+  float16x8x4_t __s1 = __p1; \
+  float16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1_f16_x4(__p0, __p1) __extension__ ({ \
+  float16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 8); \
+})
+#else
+#define vst1_f16_x4(__p0, __p1) __extension__ ({ \
+  float16x4x4_t __s1 = __p1; \
+  float16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 8); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_f16(__p0, __p1) __extension__ ({ \
+  float16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 40); \
+})
+#else
+#define vst2q_f16(__p0, __p1) __extension__ ({ \
+  float16x8x2_t __s1 = __p1; \
+  float16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_f16(__p0, __p1) __extension__ ({ \
+  float16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 8); \
+})
+#else
+#define vst2_f16(__p0, __p1) __extension__ ({ \
+  float16x4x2_t __s1 = __p1; \
+  float16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], 8); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 40); \
+})
+#else
+#define vst2q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x2_t __s1 = __p1; \
+  float16x8x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 8); \
+})
+#else
+#define vst2_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x2_t __s1 = __p1; \
+  float16x4x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], __p2, 8); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_f16(__p0, __p1) __extension__ ({ \
+  float16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 40); \
+})
+#else
+#define vst3q_f16(__p0, __p1) __extension__ ({ \
+  float16x8x3_t __s1 = __p1; \
+  float16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_f16(__p0, __p1) __extension__ ({ \
+  float16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 8); \
+})
+#else
+#define vst3_f16(__p0, __p1) __extension__ ({ \
+  float16x4x3_t __s1 = __p1; \
+  float16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], 8); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 40); \
+})
+#else
+#define vst3q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x3_t __s1 = __p1; \
+  float16x8x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 8); \
+})
+#else
+#define vst3_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x3_t __s1 = __p1; \
+  float16x4x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], __p2, 8); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_f16(__p0, __p1) __extension__ ({ \
+  float16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 40); \
+})
+#else
+#define vst4q_f16(__p0, __p1) __extension__ ({ \
+  float16x8x4_t __s1 = __p1; \
+  float16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_f16(__p0, __p1) __extension__ ({ \
+  float16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 8); \
+})
+#else
+#define vst4_f16(__p0, __p1) __extension__ ({ \
+  float16x4x4_t __s1 = __p1; \
+  float16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], 8); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 40); \
+})
+#else
+#define vst4q_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8x4_t __s1 = __p1; \
+  float16x8x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 40); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 8); \
+})
+#else
+#define vst4_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4x4_t __s1 = __p1; \
+  float16x4x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 3, 2, 1, 0); \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__rev1.val[0], (int8x8_t)__rev1.val[1], (int8x8_t)__rev1.val[2], (int8x8_t)__rev1.val[3], __p2, 8); \
+})
+#endif
+
+#endif
+#if (defined(__aarch64__)  || defined(__arm64ec__)) && defined(__ARM_FEATURE_NUMERIC_MAXMIN)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vmaxnm_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vmaxnm_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vminnm_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vminnm_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+  return __ret;
+}
+#endif
+#if (defined(__aarch64__) || defined(__arm64ec__)) && defined(__ARM_FEATURE_DIRECTED_ROUNDING)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrndq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrndq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrnd_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrnd_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndaq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrndaq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndaq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrndaq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrnda_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrnda_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndiq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrndiq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndiq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrndiq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrndi_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrndi_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndmq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrndmq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndmq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrndmq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrndm_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrndm_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndnq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrndnq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndnq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrndnq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrndn_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrndn_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndpq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrndpq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndpq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrndpq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrndp_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrndp_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrndxq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrndxq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrndxq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrndxq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrndx_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrndx_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+#endif
+#if __ARM_ARCH >= 8
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vaesdq_u8((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesdq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vaesdq_u8((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaeseq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vaeseq_u8((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaeseq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vaeseq_u8((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesimcq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vaesimcq_u8((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesimcq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vaesimcq_u8((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesmcq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vaesmcq_u8((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("aes,neon"))) uint8x16_t vaesmcq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vaesmcq_u8((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vcvtaq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vcvtaq_s32_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vcvtaq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vcvtaq_s32_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vcvta_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vcvta_s32_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vcvta_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vcvta_s32_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcvtaq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcvtaq_u32_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcvtaq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcvtaq_u32_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcvta_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcvta_u32_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcvta_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcvta_u32_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vcvtmq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vcvtmq_s32_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vcvtmq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vcvtmq_s32_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vcvtm_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vcvtm_s32_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vcvtm_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vcvtm_s32_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcvtmq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcvtmq_u32_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcvtmq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcvtmq_u32_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcvtm_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcvtm_u32_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcvtm_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcvtm_u32_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vcvtnq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vcvtnq_s32_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vcvtnq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vcvtnq_s32_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vcvtn_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vcvtn_s32_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vcvtn_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vcvtn_s32_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcvtnq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcvtnq_u32_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcvtnq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcvtnq_u32_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcvtn_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcvtn_u32_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcvtn_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcvtn_u32_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vcvtpq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vcvtpq_s32_v((int8x16_t)__p0, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vcvtpq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vcvtpq_s32_v((int8x16_t)__rev0, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vcvtp_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vcvtp_s32_v((int8x8_t)__p0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vcvtp_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vcvtp_s32_v((int8x8_t)__rev0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcvtpq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcvtpq_u32_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcvtpq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcvtpq_u32_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcvtp_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcvtp_u32_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcvtp_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcvtp_u32_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1cq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsha1cq_u32(__p0, __p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1cq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsha1cq_u32(__rev0, __p1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("sha2,neon"))) uint32_t vsha1h_u32(uint32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vsha1h_u32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1mq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsha1mq_u32(__p0, __p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1mq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsha1mq_u32(__rev0, __p1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1pq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsha1pq_u32(__p0, __p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1pq_u32(uint32x4_t __p0, uint32_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsha1pq_u32(__rev0, __p1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1su0q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsha1su0q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1su0q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsha1su0q_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1su1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsha1su1q_u32((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha1su1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsha1su1q_u32((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256hq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsha256hq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256hq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsha256hq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256h2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsha256h2q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256h2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsha256h2q_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256su0q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsha256su0q_u32((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256su0q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsha256su0q_u32((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256su1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsha256su1q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha2,neon"))) uint32x4_t vsha256su1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsha256su1q_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#endif
+#if __ARM_ARCH >= 8 && defined(__ARM_FEATURE_DIRECTED_ROUNDING)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrndq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrndq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrnd_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrnd_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrnd_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrnd_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndaq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrndaq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndaq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrndaq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrnda_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrnda_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrnda_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrnda_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndmq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrndmq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndmq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrndmq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndm_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrndm_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndm_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrndm_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndnq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrndnq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndnq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrndnq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndn_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrndn_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndn_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrndn_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndpq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrndpq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndpq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrndpq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndp_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrndp_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndp_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrndp_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndxq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrndxq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndxq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrndxq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndx_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrndx_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndx_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrndx_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrndq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrndq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrndq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrndq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrnd_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrnd_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrnd_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrnd_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrndaq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrndaq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrndaq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrndaq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrnda_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrnda_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrnda_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrnda_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrndiq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrndiq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrndiq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrndiq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrndi_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrndi_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrndi_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrndi_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrndmq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrndmq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrndmq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrndmq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrndm_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrndm_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrndm_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrndm_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrndnq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrndnq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrndnq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrndnq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrndn_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrndn_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrndn_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrndn_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float32_t vrndns_f32(float32_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vrndns_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrndpq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrndpq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrndpq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrndpq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrndp_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrndp_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrndp_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrndp_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vrndxq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrndxq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vrndxq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrndxq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vrndx_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrndx_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vrndx_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrndx_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#endif
+#if __ARM_ARCH >= 8 && defined(__ARM_FEATURE_NUMERIC_MAXMIN)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vmaxnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vmaxnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vmaxnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vmaxnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vminnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vminnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vminnm_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vminnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vminnm_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vminnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vmaxnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vmaxnm_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vminnm_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vminnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vminnm_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vminnm_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#endif
+#if defined(__ARM_FEATURE_FMA)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vfmaq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vfmaq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t __noswap_vfmaq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vfmaq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vfma_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vfma_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t __noswap_vfma_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vfma_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vfmaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+  float32x4_t __ret;
+  __ret = vfmaq_f32(__p0, __p1, (float32x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vfmaq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vfmaq_f32(__rev0, __rev1, (float32x4_t) {__p2, __p2, __p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vfma_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+  float32x2_t __ret;
+  __ret = vfma_f32(__p0, __p1, (float32x2_t) {__p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vfma_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vfma_f32(__rev0, __rev1, (float32x2_t) {__p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vfmsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  __ret = vfmaq_f32(__p0, -__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vfmsq_f32(float32x4_t __p0, float32x4_t __p1, float32x4_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vfmaq_f32(__rev0, -__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vfms_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  __ret = vfma_f32(__p0, -__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vfms_f32(float32x2_t __p0, float32x2_t __p1, float32x2_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __noswap_vfma_f32(__rev0, -__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#endif
+#if defined(__aarch64__) || defined(__arm64ec__)
+__ai __attribute__((target("aes,neon"))) poly128_t vmull_p64(poly64_t __p0, poly64_t __p1) {
+  poly128_t __ret;
+  __ret = (poly128_t) __builtin_neon_vmull_p64(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t __a64_vcvtq_low_bf16_f32(float32x4_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t) __builtin_neon___a64_vcvtq_low_bf16_f32((int8x16_t)__p0, 43);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t __a64_vcvtq_low_bf16_f32(float32x4_t __p0) {
+  bfloat16x8_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (bfloat16x8_t) __builtin_neon___a64_vcvtq_low_bf16_f32((int8x16_t)__rev0, 43);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t __noswap___a64_vcvtq_low_bf16_f32(float32x4_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t) __builtin_neon___a64_vcvtq_low_bf16_f32((int8x16_t)__p0, 43);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_bf16(__p0_230, __p1_230, __p2_230, __p3_230) __extension__ ({ \
+  bfloat16x8_t __ret_230; \
+  bfloat16x8_t __s0_230 = __p0_230; \
+  bfloat16x4_t __s2_230 = __p2_230; \
+  __ret_230 = vsetq_lane_bf16(vget_lane_bf16(__s2_230, __p3_230), __s0_230, __p1_230); \
+  __ret_230; \
+})
+#else
+#define vcopyq_lane_bf16(__p0_231, __p1_231, __p2_231, __p3_231) __extension__ ({ \
+  bfloat16x8_t __ret_231; \
+  bfloat16x8_t __s0_231 = __p0_231; \
+  bfloat16x4_t __s2_231 = __p2_231; \
+  bfloat16x8_t __rev0_231;  __rev0_231 = __builtin_shufflevector(__s0_231, __s0_231, 7, 6, 5, 4, 3, 2, 1, 0); \
+  bfloat16x4_t __rev2_231;  __rev2_231 = __builtin_shufflevector(__s2_231, __s2_231, 3, 2, 1, 0); \
+  __ret_231 = __noswap_vsetq_lane_bf16(__noswap_vget_lane_bf16(__rev2_231, __p3_231), __rev0_231, __p1_231); \
+  __ret_231 = __builtin_shufflevector(__ret_231, __ret_231, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_231; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_bf16(__p0_232, __p1_232, __p2_232, __p3_232) __extension__ ({ \
+  bfloat16x4_t __ret_232; \
+  bfloat16x4_t __s0_232 = __p0_232; \
+  bfloat16x4_t __s2_232 = __p2_232; \
+  __ret_232 = vset_lane_bf16(vget_lane_bf16(__s2_232, __p3_232), __s0_232, __p1_232); \
+  __ret_232; \
+})
+#else
+#define vcopy_lane_bf16(__p0_233, __p1_233, __p2_233, __p3_233) __extension__ ({ \
+  bfloat16x4_t __ret_233; \
+  bfloat16x4_t __s0_233 = __p0_233; \
+  bfloat16x4_t __s2_233 = __p2_233; \
+  bfloat16x4_t __rev0_233;  __rev0_233 = __builtin_shufflevector(__s0_233, __s0_233, 3, 2, 1, 0); \
+  bfloat16x4_t __rev2_233;  __rev2_233 = __builtin_shufflevector(__s2_233, __s2_233, 3, 2, 1, 0); \
+  __ret_233 = __noswap_vset_lane_bf16(__noswap_vget_lane_bf16(__rev2_233, __p3_233), __rev0_233, __p1_233); \
+  __ret_233 = __builtin_shufflevector(__ret_233, __ret_233, 3, 2, 1, 0); \
+  __ret_233; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_bf16(__p0_234, __p1_234, __p2_234, __p3_234) __extension__ ({ \
+  bfloat16x8_t __ret_234; \
+  bfloat16x8_t __s0_234 = __p0_234; \
+  bfloat16x8_t __s2_234 = __p2_234; \
+  __ret_234 = vsetq_lane_bf16(vgetq_lane_bf16(__s2_234, __p3_234), __s0_234, __p1_234); \
+  __ret_234; \
+})
+#else
+#define vcopyq_laneq_bf16(__p0_235, __p1_235, __p2_235, __p3_235) __extension__ ({ \
+  bfloat16x8_t __ret_235; \
+  bfloat16x8_t __s0_235 = __p0_235; \
+  bfloat16x8_t __s2_235 = __p2_235; \
+  bfloat16x8_t __rev0_235;  __rev0_235 = __builtin_shufflevector(__s0_235, __s0_235, 7, 6, 5, 4, 3, 2, 1, 0); \
+  bfloat16x8_t __rev2_235;  __rev2_235 = __builtin_shufflevector(__s2_235, __s2_235, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_235 = __noswap_vsetq_lane_bf16(__noswap_vgetq_lane_bf16(__rev2_235, __p3_235), __rev0_235, __p1_235); \
+  __ret_235 = __builtin_shufflevector(__ret_235, __ret_235, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_235; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_bf16(__p0_236, __p1_236, __p2_236, __p3_236) __extension__ ({ \
+  bfloat16x4_t __ret_236; \
+  bfloat16x4_t __s0_236 = __p0_236; \
+  bfloat16x8_t __s2_236 = __p2_236; \
+  __ret_236 = vset_lane_bf16(vgetq_lane_bf16(__s2_236, __p3_236), __s0_236, __p1_236); \
+  __ret_236; \
+})
+#else
+#define vcopy_laneq_bf16(__p0_237, __p1_237, __p2_237, __p3_237) __extension__ ({ \
+  bfloat16x4_t __ret_237; \
+  bfloat16x4_t __s0_237 = __p0_237; \
+  bfloat16x8_t __s2_237 = __p2_237; \
+  bfloat16x4_t __rev0_237;  __rev0_237 = __builtin_shufflevector(__s0_237, __s0_237, 3, 2, 1, 0); \
+  bfloat16x8_t __rev2_237;  __rev2_237 = __builtin_shufflevector(__s2_237, __s2_237, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_237 = __noswap_vset_lane_bf16(__noswap_vgetq_lane_bf16(__rev2_237, __p3_237), __rev0_237, __p1_237); \
+  __ret_237 = __builtin_shufflevector(__ret_237, __ret_237, 3, 2, 1, 0); \
+  __ret_237; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = vget_low_bf16(__a64_vcvtq_low_bf16_f32(__p0));
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vcvt_bf16_f32(float32x4_t __p0) {
+  bfloat16x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vget_low_bf16(__noswap___a64_vcvtq_low_bf16_f32(__rev0));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t) __builtin_neon_vcvtq_high_bf16_f32((int8x16_t)__p0, (int8x16_t)__p1, 43);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_high_bf16_f32(bfloat16x8_t __p0, float32x4_t __p1) {
+  bfloat16x8_t __ret;
+  bfloat16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (bfloat16x8_t) __builtin_neon_vcvtq_high_bf16_f32((int8x16_t)__rev0, (int8x16_t)__rev1, 43);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = __a64_vcvtq_low_bf16_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vcvtq_low_bf16_f32(float32x4_t __p0) {
+  bfloat16x8_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap___a64_vcvtq_low_bf16_f32(__rev0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("bf16,neon"))) poly8x8_t vreinterpret_p8_bf16(bfloat16x4_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly64x1_t vreinterpret_p64_bf16(bfloat16x4_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly16x4_t vreinterpret_p16_bf16(bfloat16x4_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly8x16_t vreinterpretq_p8_bf16(bfloat16x8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly128_t vreinterpretq_p128_bf16(bfloat16x8_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly64x2_t vreinterpretq_p64_bf16(bfloat16x8_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) poly16x8_t vreinterpretq_p16_bf16(bfloat16x8_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint8x16_t vreinterpretq_u8_bf16(bfloat16x8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint32x4_t vreinterpretq_u32_bf16(bfloat16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint64x2_t vreinterpretq_u64_bf16(bfloat16x8_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint16x8_t vreinterpretq_u16_bf16(bfloat16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int8x16_t vreinterpretq_s8_bf16(bfloat16x8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float64x2_t vreinterpretq_f64_bf16(bfloat16x8_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x4_t vreinterpretq_f32_bf16(bfloat16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float16x8_t vreinterpretq_f16_bf16(bfloat16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int32x4_t vreinterpretq_s32_bf16(bfloat16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int64x2_t vreinterpretq_s64_bf16(bfloat16x8_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int16x8_t vreinterpretq_s16_bf16(bfloat16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint8x8_t vreinterpret_u8_bf16(bfloat16x4_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint32x2_t vreinterpret_u32_bf16(bfloat16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint64x1_t vreinterpret_u64_bf16(bfloat16x4_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) uint16x4_t vreinterpret_u16_bf16(bfloat16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int8x8_t vreinterpret_s8_bf16(bfloat16x4_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float64x1_t vreinterpret_f64_bf16(bfloat16x4_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float32x2_t vreinterpret_f32_bf16(bfloat16x4_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) float16x4_t vreinterpret_f16_bf16(bfloat16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int32x2_t vreinterpret_s32_bf16(bfloat16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int64x1_t vreinterpret_s64_bf16(bfloat16x4_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) int16x4_t vreinterpret_s16_bf16(bfloat16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p8(poly8x16_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p128(poly128_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p64(poly64x2_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_p16(poly16x8_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u8(uint8x16_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u32(uint32x4_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u64(uint64x2_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_u16(uint16x8_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s8(int8x16_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_f64(float64x2_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_f32(float32x4_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_f16(float16x8_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s32(int32x4_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s64(int64x2_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x8_t vreinterpretq_bf16_s16(int16x8_t __p0) {
+  bfloat16x8_t __ret;
+  __ret = (bfloat16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p8(poly8x8_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p64(poly64x1_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_p16(poly16x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u8(uint8x8_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u32(uint32x2_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u64(uint64x1_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_u16(uint16x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s8(int8x8_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_f64(float64x1_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_f32(float32x2_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_f16(float16x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s32(int32x2_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s64(int64x1_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("bf16,neon"))) bfloat16x4_t vreinterpret_bf16_s16(int16x4_t __p0) {
+  bfloat16x4_t __ret;
+  __ret = (bfloat16x4_t)(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vdotq_laneq_u32(__p0_238, __p1_238, __p2_238, __p3_238) __extension__ ({ \
+  uint32x4_t __ret_238; \
+  uint32x4_t __s0_238 = __p0_238; \
+  uint8x16_t __s1_238 = __p1_238; \
+  uint8x16_t __s2_238 = __p2_238; \
+uint8x16_t __reint_238 = __s2_238; \
+uint32x4_t __reint1_238 = splatq_laneq_u32(*(uint32x4_t *) &__reint_238, __p3_238); \
+  __ret_238 = vdotq_u32(__s0_238, __s1_238, *(uint8x16_t *) &__reint1_238); \
+  __ret_238; \
+})
+#else
+#define vdotq_laneq_u32(__p0_239, __p1_239, __p2_239, __p3_239) __extension__ ({ \
+  uint32x4_t __ret_239; \
+  uint32x4_t __s0_239 = __p0_239; \
+  uint8x16_t __s1_239 = __p1_239; \
+  uint8x16_t __s2_239 = __p2_239; \
+  uint32x4_t __rev0_239;  __rev0_239 = __builtin_shufflevector(__s0_239, __s0_239, 3, 2, 1, 0); \
+  uint8x16_t __rev1_239;  __rev1_239 = __builtin_shufflevector(__s1_239, __s1_239, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev2_239;  __rev2_239 = __builtin_shufflevector(__s2_239, __s2_239, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x16_t __reint_239 = __rev2_239; \
+uint32x4_t __reint1_239 = __noswap_splatq_laneq_u32(*(uint32x4_t *) &__reint_239, __p3_239); \
+  __ret_239 = __noswap_vdotq_u32(__rev0_239, __rev1_239, *(uint8x16_t *) &__reint1_239); \
+  __ret_239 = __builtin_shufflevector(__ret_239, __ret_239, 3, 2, 1, 0); \
+  __ret_239; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdotq_laneq_s32(__p0_240, __p1_240, __p2_240, __p3_240) __extension__ ({ \
+  int32x4_t __ret_240; \
+  int32x4_t __s0_240 = __p0_240; \
+  int8x16_t __s1_240 = __p1_240; \
+  int8x16_t __s2_240 = __p2_240; \
+int8x16_t __reint_240 = __s2_240; \
+int32x4_t __reint1_240 = splatq_laneq_s32(*(int32x4_t *) &__reint_240, __p3_240); \
+  __ret_240 = vdotq_s32(__s0_240, __s1_240, *(int8x16_t *) &__reint1_240); \
+  __ret_240; \
+})
+#else
+#define vdotq_laneq_s32(__p0_241, __p1_241, __p2_241, __p3_241) __extension__ ({ \
+  int32x4_t __ret_241; \
+  int32x4_t __s0_241 = __p0_241; \
+  int8x16_t __s1_241 = __p1_241; \
+  int8x16_t __s2_241 = __p2_241; \
+  int32x4_t __rev0_241;  __rev0_241 = __builtin_shufflevector(__s0_241, __s0_241, 3, 2, 1, 0); \
+  int8x16_t __rev1_241;  __rev1_241 = __builtin_shufflevector(__s1_241, __s1_241, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev2_241;  __rev2_241 = __builtin_shufflevector(__s2_241, __s2_241, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x16_t __reint_241 = __rev2_241; \
+int32x4_t __reint1_241 = __noswap_splatq_laneq_s32(*(int32x4_t *) &__reint_241, __p3_241); \
+  __ret_241 = __noswap_vdotq_s32(__rev0_241, __rev1_241, *(int8x16_t *) &__reint1_241); \
+  __ret_241 = __builtin_shufflevector(__ret_241, __ret_241, 3, 2, 1, 0); \
+  __ret_241; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdot_laneq_u32(__p0_242, __p1_242, __p2_242, __p3_242) __extension__ ({ \
+  uint32x2_t __ret_242; \
+  uint32x2_t __s0_242 = __p0_242; \
+  uint8x8_t __s1_242 = __p1_242; \
+  uint8x16_t __s2_242 = __p2_242; \
+uint8x16_t __reint_242 = __s2_242; \
+uint32x2_t __reint1_242 = splat_laneq_u32(*(uint32x4_t *) &__reint_242, __p3_242); \
+  __ret_242 = vdot_u32(__s0_242, __s1_242, *(uint8x8_t *) &__reint1_242); \
+  __ret_242; \
+})
+#else
+#define vdot_laneq_u32(__p0_243, __p1_243, __p2_243, __p3_243) __extension__ ({ \
+  uint32x2_t __ret_243; \
+  uint32x2_t __s0_243 = __p0_243; \
+  uint8x8_t __s1_243 = __p1_243; \
+  uint8x16_t __s2_243 = __p2_243; \
+  uint32x2_t __rev0_243;  __rev0_243 = __builtin_shufflevector(__s0_243, __s0_243, 1, 0); \
+  uint8x8_t __rev1_243;  __rev1_243 = __builtin_shufflevector(__s1_243, __s1_243, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev2_243;  __rev2_243 = __builtin_shufflevector(__s2_243, __s2_243, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x16_t __reint_243 = __rev2_243; \
+uint32x2_t __reint1_243 = __noswap_splat_laneq_u32(*(uint32x4_t *) &__reint_243, __p3_243); \
+  __ret_243 = __noswap_vdot_u32(__rev0_243, __rev1_243, *(uint8x8_t *) &__reint1_243); \
+  __ret_243 = __builtin_shufflevector(__ret_243, __ret_243, 1, 0); \
+  __ret_243; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdot_laneq_s32(__p0_244, __p1_244, __p2_244, __p3_244) __extension__ ({ \
+  int32x2_t __ret_244; \
+  int32x2_t __s0_244 = __p0_244; \
+  int8x8_t __s1_244 = __p1_244; \
+  int8x16_t __s2_244 = __p2_244; \
+int8x16_t __reint_244 = __s2_244; \
+int32x2_t __reint1_244 = splat_laneq_s32(*(int32x4_t *) &__reint_244, __p3_244); \
+  __ret_244 = vdot_s32(__s0_244, __s1_244, *(int8x8_t *) &__reint1_244); \
+  __ret_244; \
+})
+#else
+#define vdot_laneq_s32(__p0_245, __p1_245, __p2_245, __p3_245) __extension__ ({ \
+  int32x2_t __ret_245; \
+  int32x2_t __s0_245 = __p0_245; \
+  int8x8_t __s1_245 = __p1_245; \
+  int8x16_t __s2_245 = __p2_245; \
+  int32x2_t __rev0_245;  __rev0_245 = __builtin_shufflevector(__s0_245, __s0_245, 1, 0); \
+  int8x8_t __rev1_245;  __rev1_245 = __builtin_shufflevector(__s1_245, __s1_245, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev2_245;  __rev2_245 = __builtin_shufflevector(__s2_245, __s2_245, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x16_t __reint_245 = __rev2_245; \
+int32x2_t __reint1_245 = __noswap_splat_laneq_s32(*(int32x4_t *) &__reint_245, __p3_245); \
+  __ret_245 = __noswap_vdot_s32(__rev0_245, __rev1_245, *(int8x8_t *) &__reint1_245); \
+  __ret_245 = __builtin_shufflevector(__ret_245, __ret_245, 1, 0); \
+  __ret_245; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlalq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vfmlalq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlalq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vfmlalq_high_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t __noswap_vfmlalq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vfmlalq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlal_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vfmlal_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlal_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vfmlal_high_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t __noswap_vfmlal_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vfmlal_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlalq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vfmlalq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlalq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vfmlalq_low_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t __noswap_vfmlalq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vfmlalq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlal_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vfmlal_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlal_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vfmlal_low_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t __noswap_vfmlal_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vfmlal_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlslq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vfmlslq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlslq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vfmlslq_high_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t __noswap_vfmlslq_high_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vfmlslq_high_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlsl_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vfmlsl_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlsl_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vfmlsl_high_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t __noswap_vfmlsl_high_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vfmlsl_high_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlslq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vfmlslq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t vfmlslq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vfmlslq_low_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fp16fml,neon"))) float32x4_t __noswap_vfmlslq_low_f16(float32x4_t __p0, float16x8_t __p1, float16x8_t __p2) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vfmlslq_low_f16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 41);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlsl_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vfmlsl_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t vfmlsl_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vfmlsl_low_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fp16fml,neon"))) float32x2_t __noswap_vfmlsl_low_f16(float32x2_t __p0, float16x4_t __p1, float16x4_t __p2) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vfmlsl_low_f16((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 9);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vdivq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = __p0 / __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vdivq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 / __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vdiv_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = __p0 / __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vdiv_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 / __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmah_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16x4_t __s2 = __p2; \
+  __ret = (float16_t) __builtin_neon_vfmah_lane_f16(__s0, __s1, (float16x4_t)__s2, __p3); \
+  __ret; \
+})
+#else
+#define vfmah_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16x4_t __s2 = __p2; \
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vfmah_lane_f16(__s0, __s1, (float16x4_t)__rev2, __p3); \
+  __ret; \
+})
+#define __noswap_vfmah_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16x4_t __s2 = __p2; \
+  __ret = (float16_t) __builtin_neon_vfmah_lane_f16(__s0, __s1, (float16x4_t)__s2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmaq_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16x4_t __s2 = __p2; \
+  __ret = (float16x8_t) __builtin_neon_vfmaq_lane_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 40); \
+  __ret; \
+})
+#else
+#define vfmaq_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16x4_t __s2 = __p2; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (float16x8_t) __builtin_neon_vfmaq_lane_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, __p3, 40); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vfmaq_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16x4_t __s2 = __p2; \
+  __ret = (float16x8_t) __builtin_neon_vfmaq_lane_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 40); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfma_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16x4_t __s2 = __p2; \
+  __ret = (float16x4_t) __builtin_neon_vfma_lane_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 8); \
+  __ret; \
+})
+#else
+#define vfma_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16x4_t __s2 = __p2; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  float16x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (float16x4_t) __builtin_neon_vfma_lane_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, __p3, 8); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vfma_lane_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16x4_t __s2 = __p2; \
+  __ret = (float16x4_t) __builtin_neon_vfma_lane_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 8); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmah_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16x8_t __s2 = __p2; \
+  __ret = (float16_t) __builtin_neon_vfmah_laneq_f16(__s0, __s1, (float16x8_t)__s2, __p3); \
+  __ret; \
+})
+#else
+#define vfmah_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16x8_t __s2 = __p2; \
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vfmah_laneq_f16(__s0, __s1, (float16x8_t)__rev2, __p3); \
+  __ret; \
+})
+#define __noswap_vfmah_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16x8_t __s2 = __p2; \
+  __ret = (float16_t) __builtin_neon_vfmah_laneq_f16(__s0, __s1, (float16x8_t)__s2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmaq_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16x8_t __s2 = __p2; \
+  __ret = (float16x8_t) __builtin_neon_vfmaq_laneq_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 40); \
+  __ret; \
+})
+#else
+#define vfmaq_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16x8_t __s2 = __p2; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16x8_t) __builtin_neon_vfmaq_laneq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 40); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vfmaq_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16x8_t __s2 = __p2; \
+  __ret = (float16x8_t) __builtin_neon_vfmaq_laneq_f16((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 40); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfma_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16x8_t __s2 = __p2; \
+  __ret = (float16x4_t) __builtin_neon_vfma_laneq_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 8); \
+  __ret; \
+})
+#else
+#define vfma_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16x8_t __s2 = __p2; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  float16x8_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16x4_t) __builtin_neon_vfma_laneq_f16((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x16_t)__rev2, __p3, 8); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vfma_laneq_f16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16x8_t __s2 = __p2; \
+  __ret = (float16x4_t) __builtin_neon_vfma_laneq_f16((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 8); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmaq_n_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16_t __s2 = __p2; \
+  __ret = vfmaq_f16(__s0, __s1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
+  __ret; \
+})
+#else
+#define vfmaq_n_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16_t __s2 = __p2; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = __noswap_vfmaq_f16(__rev0, __rev1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfma_n_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16_t __s2 = __p2; \
+  __ret = vfma_f16(__s0, __s1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
+  __ret; \
+})
+#else
+#define vfma_n_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16_t __s2 = __p2; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = __noswap_vfma_f16(__rev0, __rev1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmsh_lane_f16(__p0_246, __p1_246, __p2_246, __p3_246) __extension__ ({ \
+  float16_t __ret_246; \
+  float16_t __s0_246 = __p0_246; \
+  float16_t __s1_246 = __p1_246; \
+  float16x4_t __s2_246 = __p2_246; \
+  __ret_246 = vfmah_lane_f16(__s0_246, -__s1_246, __s2_246, __p3_246); \
+  __ret_246; \
+})
+#else
+#define vfmsh_lane_f16(__p0_247, __p1_247, __p2_247, __p3_247) __extension__ ({ \
+  float16_t __ret_247; \
+  float16_t __s0_247 = __p0_247; \
+  float16_t __s1_247 = __p1_247; \
+  float16x4_t __s2_247 = __p2_247; \
+  float16x4_t __rev2_247;  __rev2_247 = __builtin_shufflevector(__s2_247, __s2_247, 3, 2, 1, 0); \
+  __ret_247 = __noswap_vfmah_lane_f16(__s0_247, -__s1_247, __rev2_247, __p3_247); \
+  __ret_247; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmsq_lane_f16(__p0_248, __p1_248, __p2_248, __p3_248) __extension__ ({ \
+  float16x8_t __ret_248; \
+  float16x8_t __s0_248 = __p0_248; \
+  float16x8_t __s1_248 = __p1_248; \
+  float16x4_t __s2_248 = __p2_248; \
+  __ret_248 = vfmaq_lane_f16(__s0_248, -__s1_248, __s2_248, __p3_248); \
+  __ret_248; \
+})
+#else
+#define vfmsq_lane_f16(__p0_249, __p1_249, __p2_249, __p3_249) __extension__ ({ \
+  float16x8_t __ret_249; \
+  float16x8_t __s0_249 = __p0_249; \
+  float16x8_t __s1_249 = __p1_249; \
+  float16x4_t __s2_249 = __p2_249; \
+  float16x8_t __rev0_249;  __rev0_249 = __builtin_shufflevector(__s0_249, __s0_249, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_249;  __rev1_249 = __builtin_shufflevector(__s1_249, __s1_249, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev2_249;  __rev2_249 = __builtin_shufflevector(__s2_249, __s2_249, 3, 2, 1, 0); \
+  __ret_249 = __noswap_vfmaq_lane_f16(__rev0_249, -__rev1_249, __rev2_249, __p3_249); \
+  __ret_249 = __builtin_shufflevector(__ret_249, __ret_249, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_249; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfms_lane_f16(__p0_250, __p1_250, __p2_250, __p3_250) __extension__ ({ \
+  float16x4_t __ret_250; \
+  float16x4_t __s0_250 = __p0_250; \
+  float16x4_t __s1_250 = __p1_250; \
+  float16x4_t __s2_250 = __p2_250; \
+  __ret_250 = vfma_lane_f16(__s0_250, -__s1_250, __s2_250, __p3_250); \
+  __ret_250; \
+})
+#else
+#define vfms_lane_f16(__p0_251, __p1_251, __p2_251, __p3_251) __extension__ ({ \
+  float16x4_t __ret_251; \
+  float16x4_t __s0_251 = __p0_251; \
+  float16x4_t __s1_251 = __p1_251; \
+  float16x4_t __s2_251 = __p2_251; \
+  float16x4_t __rev0_251;  __rev0_251 = __builtin_shufflevector(__s0_251, __s0_251, 3, 2, 1, 0); \
+  float16x4_t __rev1_251;  __rev1_251 = __builtin_shufflevector(__s1_251, __s1_251, 3, 2, 1, 0); \
+  float16x4_t __rev2_251;  __rev2_251 = __builtin_shufflevector(__s2_251, __s2_251, 3, 2, 1, 0); \
+  __ret_251 = __noswap_vfma_lane_f16(__rev0_251, -__rev1_251, __rev2_251, __p3_251); \
+  __ret_251 = __builtin_shufflevector(__ret_251, __ret_251, 3, 2, 1, 0); \
+  __ret_251; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmsh_laneq_f16(__p0_252, __p1_252, __p2_252, __p3_252) __extension__ ({ \
+  float16_t __ret_252; \
+  float16_t __s0_252 = __p0_252; \
+  float16_t __s1_252 = __p1_252; \
+  float16x8_t __s2_252 = __p2_252; \
+  __ret_252 = vfmah_laneq_f16(__s0_252, -__s1_252, __s2_252, __p3_252); \
+  __ret_252; \
+})
+#else
+#define vfmsh_laneq_f16(__p0_253, __p1_253, __p2_253, __p3_253) __extension__ ({ \
+  float16_t __ret_253; \
+  float16_t __s0_253 = __p0_253; \
+  float16_t __s1_253 = __p1_253; \
+  float16x8_t __s2_253 = __p2_253; \
+  float16x8_t __rev2_253;  __rev2_253 = __builtin_shufflevector(__s2_253, __s2_253, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_253 = __noswap_vfmah_laneq_f16(__s0_253, -__s1_253, __rev2_253, __p3_253); \
+  __ret_253; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmsq_laneq_f16(__p0_254, __p1_254, __p2_254, __p3_254) __extension__ ({ \
+  float16x8_t __ret_254; \
+  float16x8_t __s0_254 = __p0_254; \
+  float16x8_t __s1_254 = __p1_254; \
+  float16x8_t __s2_254 = __p2_254; \
+  __ret_254 = vfmaq_laneq_f16(__s0_254, -__s1_254, __s2_254, __p3_254); \
+  __ret_254; \
+})
+#else
+#define vfmsq_laneq_f16(__p0_255, __p1_255, __p2_255, __p3_255) __extension__ ({ \
+  float16x8_t __ret_255; \
+  float16x8_t __s0_255 = __p0_255; \
+  float16x8_t __s1_255 = __p1_255; \
+  float16x8_t __s2_255 = __p2_255; \
+  float16x8_t __rev0_255;  __rev0_255 = __builtin_shufflevector(__s0_255, __s0_255, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_255;  __rev1_255 = __builtin_shufflevector(__s1_255, __s1_255, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev2_255;  __rev2_255 = __builtin_shufflevector(__s2_255, __s2_255, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_255 = __noswap_vfmaq_laneq_f16(__rev0_255, -__rev1_255, __rev2_255, __p3_255); \
+  __ret_255 = __builtin_shufflevector(__ret_255, __ret_255, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_255; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfms_laneq_f16(__p0_256, __p1_256, __p2_256, __p3_256) __extension__ ({ \
+  float16x4_t __ret_256; \
+  float16x4_t __s0_256 = __p0_256; \
+  float16x4_t __s1_256 = __p1_256; \
+  float16x8_t __s2_256 = __p2_256; \
+  __ret_256 = vfma_laneq_f16(__s0_256, -__s1_256, __s2_256, __p3_256); \
+  __ret_256; \
+})
+#else
+#define vfms_laneq_f16(__p0_257, __p1_257, __p2_257, __p3_257) __extension__ ({ \
+  float16x4_t __ret_257; \
+  float16x4_t __s0_257 = __p0_257; \
+  float16x4_t __s1_257 = __p1_257; \
+  float16x8_t __s2_257 = __p2_257; \
+  float16x4_t __rev0_257;  __rev0_257 = __builtin_shufflevector(__s0_257, __s0_257, 3, 2, 1, 0); \
+  float16x4_t __rev1_257;  __rev1_257 = __builtin_shufflevector(__s1_257, __s1_257, 3, 2, 1, 0); \
+  float16x8_t __rev2_257;  __rev2_257 = __builtin_shufflevector(__s2_257, __s2_257, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_257 = __noswap_vfma_laneq_f16(__rev0_257, -__rev1_257, __rev2_257, __p3_257); \
+  __ret_257 = __builtin_shufflevector(__ret_257, __ret_257, 3, 2, 1, 0); \
+  __ret_257; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmsq_n_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16_t __s2 = __p2; \
+  __ret = vfmaq_f16(__s0, -__s1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
+  __ret; \
+})
+#else
+#define vfmsq_n_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16_t __s2 = __p2; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = __noswap_vfmaq_f16(__rev0, -__rev1, (float16x8_t) {__s2, __s2, __s2, __s2, __s2, __s2, __s2, __s2}); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfms_n_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16_t __s2 = __p2; \
+  __ret = vfma_f16(__s0, -__s1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
+  __ret; \
+})
+#else
+#define vfms_n_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16_t __s2 = __p2; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = __noswap_vfma_f16(__rev0, -__rev1, (float16x4_t) {__s2, __s2, __s2, __s2}); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmaxnmvq_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vmaxnmvq_f16((int8x16_t)__s0); \
+  __ret; \
+})
+#else
+#define vmaxnmvq_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vmaxnmvq_f16((int8x16_t)__rev0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmaxnmv_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vmaxnmv_f16((int8x8_t)__s0); \
+  __ret; \
+})
+#else
+#define vmaxnmv_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vmaxnmv_f16((int8x8_t)__rev0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmaxvq_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vmaxvq_f16((int8x16_t)__s0); \
+  __ret; \
+})
+#else
+#define vmaxvq_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vmaxvq_f16((int8x16_t)__rev0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmaxv_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vmaxv_f16((int8x8_t)__s0); \
+  __ret; \
+})
+#else
+#define vmaxv_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vmaxv_f16((int8x8_t)__rev0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vminnmvq_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vminnmvq_f16((int8x16_t)__s0); \
+  __ret; \
+})
+#else
+#define vminnmvq_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vminnmvq_f16((int8x16_t)__rev0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vminnmv_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vminnmv_f16((int8x8_t)__s0); \
+  __ret; \
+})
+#else
+#define vminnmv_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vminnmv_f16((int8x8_t)__rev0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vminvq_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vminvq_f16((int8x16_t)__s0); \
+  __ret; \
+})
+#else
+#define vminvq_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vminvq_f16((int8x16_t)__rev0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vminv_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vminv_f16((int8x8_t)__s0); \
+  __ret; \
+})
+#else
+#define vminv_f16(__p0) __extension__ ({ \
+  float16_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vminv_f16((int8x8_t)__rev0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_laneq_f16(__p0_258, __p1_258, __p2_258) __extension__ ({ \
+  float16x8_t __ret_258; \
+  float16x8_t __s0_258 = __p0_258; \
+  float16x8_t __s1_258 = __p1_258; \
+  __ret_258 = __s0_258 * splatq_laneq_f16(__s1_258, __p2_258); \
+  __ret_258; \
+})
+#else
+#define vmulq_laneq_f16(__p0_259, __p1_259, __p2_259) __extension__ ({ \
+  float16x8_t __ret_259; \
+  float16x8_t __s0_259 = __p0_259; \
+  float16x8_t __s1_259 = __p1_259; \
+  float16x8_t __rev0_259;  __rev0_259 = __builtin_shufflevector(__s0_259, __s0_259, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_259;  __rev1_259 = __builtin_shufflevector(__s1_259, __s1_259, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_259 = __rev0_259 * __noswap_splatq_laneq_f16(__rev1_259, __p2_259); \
+  __ret_259 = __builtin_shufflevector(__ret_259, __ret_259, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_259; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_laneq_f16(__p0_260, __p1_260, __p2_260) __extension__ ({ \
+  float16x4_t __ret_260; \
+  float16x4_t __s0_260 = __p0_260; \
+  float16x8_t __s1_260 = __p1_260; \
+  __ret_260 = __s0_260 * splat_laneq_f16(__s1_260, __p2_260); \
+  __ret_260; \
+})
+#else
+#define vmul_laneq_f16(__p0_261, __p1_261, __p2_261) __extension__ ({ \
+  float16x4_t __ret_261; \
+  float16x4_t __s0_261 = __p0_261; \
+  float16x8_t __s1_261 = __p1_261; \
+  float16x4_t __rev0_261;  __rev0_261 = __builtin_shufflevector(__s0_261, __s0_261, 3, 2, 1, 0); \
+  float16x8_t __rev1_261;  __rev1_261 = __builtin_shufflevector(__s1_261, __s1_261, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_261 = __rev0_261 * __noswap_splat_laneq_f16(__rev1_261, __p2_261); \
+  __ret_261 = __builtin_shufflevector(__ret_261, __ret_261, 3, 2, 1, 0); \
+  __ret_261; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmulxq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vmulxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vmulxq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vmulxq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t __noswap_vmulxq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vmulxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmulx_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vmulx_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vmulx_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vmulx_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t __noswap_vmulx_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vmulx_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxh_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vmulxh_lane_f16(__s0, (float16x4_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vmulxh_lane_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16x4_t __s1 = __p1; \
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vmulxh_lane_f16(__s0, (float16x4_t)__rev1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxq_lane_f16(__p0_262, __p1_262, __p2_262) __extension__ ({ \
+  float16x8_t __ret_262; \
+  float16x8_t __s0_262 = __p0_262; \
+  float16x4_t __s1_262 = __p1_262; \
+  __ret_262 = vmulxq_f16(__s0_262, splatq_lane_f16(__s1_262, __p2_262)); \
+  __ret_262; \
+})
+#else
+#define vmulxq_lane_f16(__p0_263, __p1_263, __p2_263) __extension__ ({ \
+  float16x8_t __ret_263; \
+  float16x8_t __s0_263 = __p0_263; \
+  float16x4_t __s1_263 = __p1_263; \
+  float16x8_t __rev0_263;  __rev0_263 = __builtin_shufflevector(__s0_263, __s0_263, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev1_263;  __rev1_263 = __builtin_shufflevector(__s1_263, __s1_263, 3, 2, 1, 0); \
+  __ret_263 = __noswap_vmulxq_f16(__rev0_263, __noswap_splatq_lane_f16(__rev1_263, __p2_263)); \
+  __ret_263 = __builtin_shufflevector(__ret_263, __ret_263, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_263; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulx_lane_f16(__p0_264, __p1_264, __p2_264) __extension__ ({ \
+  float16x4_t __ret_264; \
+  float16x4_t __s0_264 = __p0_264; \
+  float16x4_t __s1_264 = __p1_264; \
+  __ret_264 = vmulx_f16(__s0_264, splat_lane_f16(__s1_264, __p2_264)); \
+  __ret_264; \
+})
+#else
+#define vmulx_lane_f16(__p0_265, __p1_265, __p2_265) __extension__ ({ \
+  float16x4_t __ret_265; \
+  float16x4_t __s0_265 = __p0_265; \
+  float16x4_t __s1_265 = __p1_265; \
+  float16x4_t __rev0_265;  __rev0_265 = __builtin_shufflevector(__s0_265, __s0_265, 3, 2, 1, 0); \
+  float16x4_t __rev1_265;  __rev1_265 = __builtin_shufflevector(__s1_265, __s1_265, 3, 2, 1, 0); \
+  __ret_265 = __noswap_vmulx_f16(__rev0_265, __noswap_splat_lane_f16(__rev1_265, __p2_265)); \
+  __ret_265 = __builtin_shufflevector(__ret_265, __ret_265, 3, 2, 1, 0); \
+  __ret_265; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxh_laneq_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  __ret = (float16_t) __builtin_neon_vmulxh_laneq_f16(__s0, (float16x8_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vmulxh_laneq_f16(__p0, __p1, __p2) __extension__ ({ \
+  float16_t __ret; \
+  float16_t __s0 = __p0; \
+  float16x8_t __s1 = __p1; \
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vmulxh_laneq_f16(__s0, (float16x8_t)__rev1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxq_laneq_f16(__p0_266, __p1_266, __p2_266) __extension__ ({ \
+  float16x8_t __ret_266; \
+  float16x8_t __s0_266 = __p0_266; \
+  float16x8_t __s1_266 = __p1_266; \
+  __ret_266 = vmulxq_f16(__s0_266, splatq_laneq_f16(__s1_266, __p2_266)); \
+  __ret_266; \
+})
+#else
+#define vmulxq_laneq_f16(__p0_267, __p1_267, __p2_267) __extension__ ({ \
+  float16x8_t __ret_267; \
+  float16x8_t __s0_267 = __p0_267; \
+  float16x8_t __s1_267 = __p1_267; \
+  float16x8_t __rev0_267;  __rev0_267 = __builtin_shufflevector(__s0_267, __s0_267, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev1_267;  __rev1_267 = __builtin_shufflevector(__s1_267, __s1_267, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_267 = __noswap_vmulxq_f16(__rev0_267, __noswap_splatq_laneq_f16(__rev1_267, __p2_267)); \
+  __ret_267 = __builtin_shufflevector(__ret_267, __ret_267, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_267; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulx_laneq_f16(__p0_268, __p1_268, __p2_268) __extension__ ({ \
+  float16x4_t __ret_268; \
+  float16x4_t __s0_268 = __p0_268; \
+  float16x8_t __s1_268 = __p1_268; \
+  __ret_268 = vmulx_f16(__s0_268, splat_laneq_f16(__s1_268, __p2_268)); \
+  __ret_268; \
+})
+#else
+#define vmulx_laneq_f16(__p0_269, __p1_269, __p2_269) __extension__ ({ \
+  float16x4_t __ret_269; \
+  float16x4_t __s0_269 = __p0_269; \
+  float16x8_t __s1_269 = __p1_269; \
+  float16x4_t __rev0_269;  __rev0_269 = __builtin_shufflevector(__s0_269, __s0_269, 3, 2, 1, 0); \
+  float16x8_t __rev1_269;  __rev1_269 = __builtin_shufflevector(__s1_269, __s1_269, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_269 = __noswap_vmulx_f16(__rev0_269, __noswap_splat_laneq_f16(__rev1_269, __p2_269)); \
+  __ret_269 = __builtin_shufflevector(__ret_269, __ret_269, 3, 2, 1, 0); \
+  __ret_269; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxq_n_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = vmulxq_f16(__s0, (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}); \
+  __ret; \
+})
+#else
+#define vmulxq_n_f16(__p0, __p1) __extension__ ({ \
+  float16x8_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = __noswap_vmulxq_f16(__rev0, (float16x8_t) {__s1, __s1, __s1, __s1, __s1, __s1, __s1, __s1}); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulx_n_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  __ret = vmulx_f16(__s0, (float16x4_t) {__s1, __s1, __s1, __s1}); \
+  __ret; \
+})
+#else
+#define vmulx_n_f16(__p0, __p1) __extension__ ({ \
+  float16x4_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16_t __s1 = __p1; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = __noswap_vmulx_f16(__rev0, (float16x4_t) {__s1, __s1, __s1, __s1}); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpaddq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vpaddq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpaddq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vpaddq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vpmaxq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpmaxq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vpmaxq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vpmaxnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpmaxnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vpmaxnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vpmaxnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpmaxnm_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vpmaxnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpminq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vpminq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpminq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vpminq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vpminnmq_f16((int8x16_t)__p0, (int8x16_t)__p1, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vpminnmq_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vpminnmq_f16((int8x16_t)__rev0, (int8x16_t)__rev1, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpminnm_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vpminnm_f16((int8x8_t)__p0, (int8x8_t)__p1, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vpminnm_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vpminnm_f16((int8x8_t)__rev0, (int8x8_t)__rev1, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndiq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vrndiq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vrndiq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vrndiq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndi_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vrndi_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vrndi_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vrndi_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vsqrtq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t) __builtin_neon_vsqrtq_f16((int8x16_t)__p0, 40);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x8_t vsqrtq_f16(float16x8_t __p0) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (float16x8_t) __builtin_neon_vsqrtq_f16((int8x16_t)__rev0, 40);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vsqrt_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t) __builtin_neon_vsqrt_f16((int8x8_t)__p0, 8);
+  return __ret;
+}
+#else
+__ai __attribute__((target("fullfp16,neon"))) float16x4_t vsqrt_f16(float16x4_t __p0) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float16x4_t) __builtin_neon_vsqrt_f16((int8x8_t)__rev0, 8);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsudotq_laneq_s32(__p0_270, __p1_270, __p2_270, __p3_270) __extension__ ({ \
+  int32x4_t __ret_270; \
+  int32x4_t __s0_270 = __p0_270; \
+  int8x16_t __s1_270 = __p1_270; \
+  uint8x16_t __s2_270 = __p2_270; \
+uint8x16_t __reint_270 = __s2_270; \
+  __ret_270 = vusdotq_s32(__s0_270, (uint8x16_t)(splatq_laneq_s32(*(int32x4_t *) &__reint_270, __p3_270)), __s1_270); \
+  __ret_270; \
+})
+#else
+#define vsudotq_laneq_s32(__p0_271, __p1_271, __p2_271, __p3_271) __extension__ ({ \
+  int32x4_t __ret_271; \
+  int32x4_t __s0_271 = __p0_271; \
+  int8x16_t __s1_271 = __p1_271; \
+  uint8x16_t __s2_271 = __p2_271; \
+  int32x4_t __rev0_271;  __rev0_271 = __builtin_shufflevector(__s0_271, __s0_271, 3, 2, 1, 0); \
+  int8x16_t __rev1_271;  __rev1_271 = __builtin_shufflevector(__s1_271, __s1_271, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev2_271;  __rev2_271 = __builtin_shufflevector(__s2_271, __s2_271, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x16_t __reint_271 = __rev2_271; \
+  __ret_271 = __noswap_vusdotq_s32(__rev0_271, (uint8x16_t)(__noswap_splatq_laneq_s32(*(int32x4_t *) &__reint_271, __p3_271)), __rev1_271); \
+  __ret_271 = __builtin_shufflevector(__ret_271, __ret_271, 3, 2, 1, 0); \
+  __ret_271; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsudot_laneq_s32(__p0_272, __p1_272, __p2_272, __p3_272) __extension__ ({ \
+  int32x2_t __ret_272; \
+  int32x2_t __s0_272 = __p0_272; \
+  int8x8_t __s1_272 = __p1_272; \
+  uint8x16_t __s2_272 = __p2_272; \
+uint8x16_t __reint_272 = __s2_272; \
+  __ret_272 = vusdot_s32(__s0_272, (uint8x8_t)(splat_laneq_s32(*(int32x4_t *) &__reint_272, __p3_272)), __s1_272); \
+  __ret_272; \
+})
+#else
+#define vsudot_laneq_s32(__p0_273, __p1_273, __p2_273, __p3_273) __extension__ ({ \
+  int32x2_t __ret_273; \
+  int32x2_t __s0_273 = __p0_273; \
+  int8x8_t __s1_273 = __p1_273; \
+  uint8x16_t __s2_273 = __p2_273; \
+  int32x2_t __rev0_273;  __rev0_273 = __builtin_shufflevector(__s0_273, __s0_273, 1, 0); \
+  int8x8_t __rev1_273;  __rev1_273 = __builtin_shufflevector(__s1_273, __s1_273, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev2_273;  __rev2_273 = __builtin_shufflevector(__s2_273, __s2_273, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x16_t __reint_273 = __rev2_273; \
+  __ret_273 = __noswap_vusdot_s32(__rev0_273, (uint8x8_t)(__noswap_splat_laneq_s32(*(int32x4_t *) &__reint_273, __p3_273)), __rev1_273); \
+  __ret_273 = __builtin_shufflevector(__ret_273, __ret_273, 1, 0); \
+  __ret_273; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vusdotq_laneq_s32(__p0_274, __p1_274, __p2_274, __p3_274) __extension__ ({ \
+  int32x4_t __ret_274; \
+  int32x4_t __s0_274 = __p0_274; \
+  uint8x16_t __s1_274 = __p1_274; \
+  int8x16_t __s2_274 = __p2_274; \
+int8x16_t __reint_274 = __s2_274; \
+  __ret_274 = vusdotq_s32(__s0_274, __s1_274, (int8x16_t)(splatq_laneq_s32(*(int32x4_t *) &__reint_274, __p3_274))); \
+  __ret_274; \
+})
+#else
+#define vusdotq_laneq_s32(__p0_275, __p1_275, __p2_275, __p3_275) __extension__ ({ \
+  int32x4_t __ret_275; \
+  int32x4_t __s0_275 = __p0_275; \
+  uint8x16_t __s1_275 = __p1_275; \
+  int8x16_t __s2_275 = __p2_275; \
+  int32x4_t __rev0_275;  __rev0_275 = __builtin_shufflevector(__s0_275, __s0_275, 3, 2, 1, 0); \
+  uint8x16_t __rev1_275;  __rev1_275 = __builtin_shufflevector(__s1_275, __s1_275, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev2_275;  __rev2_275 = __builtin_shufflevector(__s2_275, __s2_275, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x16_t __reint_275 = __rev2_275; \
+  __ret_275 = __noswap_vusdotq_s32(__rev0_275, __rev1_275, (int8x16_t)(__noswap_splatq_laneq_s32(*(int32x4_t *) &__reint_275, __p3_275))); \
+  __ret_275 = __builtin_shufflevector(__ret_275, __ret_275, 3, 2, 1, 0); \
+  __ret_275; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vusdot_laneq_s32(__p0_276, __p1_276, __p2_276, __p3_276) __extension__ ({ \
+  int32x2_t __ret_276; \
+  int32x2_t __s0_276 = __p0_276; \
+  uint8x8_t __s1_276 = __p1_276; \
+  int8x16_t __s2_276 = __p2_276; \
+int8x16_t __reint_276 = __s2_276; \
+  __ret_276 = vusdot_s32(__s0_276, __s1_276, (int8x8_t)(splat_laneq_s32(*(int32x4_t *) &__reint_276, __p3_276))); \
+  __ret_276; \
+})
+#else
+#define vusdot_laneq_s32(__p0_277, __p1_277, __p2_277, __p3_277) __extension__ ({ \
+  int32x2_t __ret_277; \
+  int32x2_t __s0_277 = __p0_277; \
+  uint8x8_t __s1_277 = __p1_277; \
+  int8x16_t __s2_277 = __p2_277; \
+  int32x2_t __rev0_277;  __rev0_277 = __builtin_shufflevector(__s0_277, __s0_277, 1, 0); \
+  uint8x8_t __rev1_277;  __rev1_277 = __builtin_shufflevector(__s1_277, __s1_277, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev2_277;  __rev2_277 = __builtin_shufflevector(__s2_277, __s2_277, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x16_t __reint_277 = __rev2_277; \
+  __ret_277 = __noswap_vusdot_s32(__rev0_277, __rev1_277, (int8x8_t)(__noswap_splat_laneq_s32(*(int32x4_t *) &__reint_277, __p3_277))); \
+  __ret_277 = __builtin_shufflevector(__ret_277, __ret_277, 1, 0); \
+  __ret_277; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vabdq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vabdq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vabdq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vabdq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vabd_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vabd_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64_t vabdd_f64(float64_t __p0, float64_t __p1) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vabdd_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vabds_f32(float32_t __p0, float32_t __p1) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vabds_f32(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vabsq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vabsq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vabsq_s64(int64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vabsq_v((int8x16_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vabsq_s64(int64x2_t __p0) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vabsq_v((int8x16_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vabs_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vabs_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vabs_s64(int64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vabs_v((int8x8_t)__p0, 3);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vabsd_s64(int64_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vabsd_s64(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vaddq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vaddq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vadd_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = __p0 + __p1;
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vaddd_u64(uint64_t __p0, uint64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vaddd_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vaddd_s64(int64_t __p0, int64_t __p1) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vaddd_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vaddq_p128(poly128_t __p0, poly128_t __p1) {
+  poly128_t __ret;
+  __ret = (poly128_t) __builtin_neon_vaddq_p128(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vaddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint16x8_t __ret;
+  __ret = vcombine_u16(__p0, vaddhn_u32(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vaddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint16x8_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u16(__rev0, __noswap_vaddhn_u32(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vaddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint32x4_t __ret;
+  __ret = vcombine_u32(__p0, vaddhn_u64(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vaddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint32x4_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __noswap_vcombine_u32(__rev0, __noswap_vaddhn_u64(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vaddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint8x16_t __ret;
+  __ret = vcombine_u8(__p0, vaddhn_u16(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vaddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint8x16_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u8(__rev0, __noswap_vaddhn_u16(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vaddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int16x8_t __ret;
+  __ret = vcombine_s16(__p0, vaddhn_s32(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vaddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int16x8_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s16(__rev0, __noswap_vaddhn_s32(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vaddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int32x4_t __ret;
+  __ret = vcombine_s32(__p0, vaddhn_s64(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vaddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int32x4_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __noswap_vcombine_s32(__rev0, __noswap_vaddhn_s64(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vaddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int8x16_t __ret;
+  __ret = vcombine_s8(__p0, vaddhn_s16(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vaddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int8x16_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s8(__rev0, __noswap_vaddhn_s16(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16_t vaddlvq_u8(uint8x16_t __p0) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vaddlvq_u8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16_t vaddlvq_u8(uint8x16_t __p0) {
+  uint16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16_t) __builtin_neon_vaddlvq_u8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64_t vaddlvq_u32(uint32x4_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vaddlvq_u32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64_t vaddlvq_u32(uint32x4_t __p0) {
+  uint64_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint64_t) __builtin_neon_vaddlvq_u32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32_t vaddlvq_u16(uint16x8_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vaddlvq_u16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32_t vaddlvq_u16(uint16x8_t __p0) {
+  uint32_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint32_t) __builtin_neon_vaddlvq_u16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16_t vaddlvq_s8(int8x16_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vaddlvq_s8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16_t vaddlvq_s8(int8x16_t __p0) {
+  int16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16_t) __builtin_neon_vaddlvq_s8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64_t vaddlvq_s32(int32x4_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vaddlvq_s32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64_t vaddlvq_s32(int32x4_t __p0) {
+  int64_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int64_t) __builtin_neon_vaddlvq_s32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32_t vaddlvq_s16(int16x8_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vaddlvq_s16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32_t vaddlvq_s16(int16x8_t __p0) {
+  int32_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int32_t) __builtin_neon_vaddlvq_s16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16_t vaddlv_u8(uint8x8_t __p0) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vaddlv_u8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16_t vaddlv_u8(uint8x8_t __p0) {
+  uint16_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16_t) __builtin_neon_vaddlv_u8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64_t vaddlv_u32(uint32x2_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vaddlv_u32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64_t vaddlv_u32(uint32x2_t __p0) {
+  uint64_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64_t) __builtin_neon_vaddlv_u32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32_t vaddlv_u16(uint16x4_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vaddlv_u16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32_t vaddlv_u16(uint16x4_t __p0) {
+  uint32_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32_t) __builtin_neon_vaddlv_u16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16_t vaddlv_s8(int8x8_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vaddlv_s8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16_t vaddlv_s8(int8x8_t __p0) {
+  int16_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16_t) __builtin_neon_vaddlv_s8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64_t vaddlv_s32(int32x2_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vaddlv_s32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64_t vaddlv_s32(int32x2_t __p0) {
+  int64_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64_t) __builtin_neon_vaddlv_s32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32_t vaddlv_s16(int16x4_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vaddlv_s16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32_t vaddlv_s16(int16x4_t __p0) {
+  int32_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32_t) __builtin_neon_vaddlv_s16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8_t vaddvq_u8(uint8x16_t __p0) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vaddvq_u8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8_t vaddvq_u8(uint8x16_t __p0) {
+  uint8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8_t) __builtin_neon_vaddvq_u8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32_t vaddvq_u32(uint32x4_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vaddvq_u32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32_t vaddvq_u32(uint32x4_t __p0) {
+  uint32_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32_t) __builtin_neon_vaddvq_u32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64_t vaddvq_u64(uint64x2_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vaddvq_u64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64_t vaddvq_u64(uint64x2_t __p0) {
+  uint64_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64_t) __builtin_neon_vaddvq_u64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16_t vaddvq_u16(uint16x8_t __p0) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vaddvq_u16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16_t vaddvq_u16(uint16x8_t __p0) {
+  uint16_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16_t) __builtin_neon_vaddvq_u16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8_t vaddvq_s8(int8x16_t __p0) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vaddvq_s8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8_t vaddvq_s8(int8x16_t __p0) {
+  int8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8_t) __builtin_neon_vaddvq_s8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vaddvq_f64(float64x2_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vaddvq_f64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vaddvq_f64(float64x2_t __p0) {
+  float64_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64_t) __builtin_neon_vaddvq_f64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vaddvq_f32(float32x4_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vaddvq_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vaddvq_f32(float32x4_t __p0) {
+  float32_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32_t) __builtin_neon_vaddvq_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32_t vaddvq_s32(int32x4_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vaddvq_s32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32_t vaddvq_s32(int32x4_t __p0) {
+  int32_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32_t) __builtin_neon_vaddvq_s32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64_t vaddvq_s64(int64x2_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vaddvq_s64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64_t vaddvq_s64(int64x2_t __p0) {
+  int64_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64_t) __builtin_neon_vaddvq_s64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16_t vaddvq_s16(int16x8_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vaddvq_s16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16_t vaddvq_s16(int16x8_t __p0) {
+  int16_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16_t) __builtin_neon_vaddvq_s16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8_t vaddv_u8(uint8x8_t __p0) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vaddv_u8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8_t vaddv_u8(uint8x8_t __p0) {
+  uint8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8_t) __builtin_neon_vaddv_u8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32_t vaddv_u32(uint32x2_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vaddv_u32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32_t vaddv_u32(uint32x2_t __p0) {
+  uint32_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32_t) __builtin_neon_vaddv_u32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16_t vaddv_u16(uint16x4_t __p0) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vaddv_u16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16_t vaddv_u16(uint16x4_t __p0) {
+  uint16_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16_t) __builtin_neon_vaddv_u16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8_t vaddv_s8(int8x8_t __p0) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vaddv_s8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8_t vaddv_s8(int8x8_t __p0) {
+  int8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8_t) __builtin_neon_vaddv_s8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vaddv_f32(float32x2_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vaddv_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vaddv_f32(float32x2_t __p0) {
+  float32_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32_t) __builtin_neon_vaddv_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32_t vaddv_s32(int32x2_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vaddv_s32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32_t vaddv_s32(int32x2_t __p0) {
+  int32_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32_t) __builtin_neon_vaddv_s32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16_t vaddv_s16(int16x4_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vaddv_s16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16_t vaddv_s16(int16x4_t __p0) {
+  int16_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16_t) __builtin_neon_vaddv_s16(__rev0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) poly64x1_t vbsl_p64(uint64x1_t __p0, poly64x1_t __p1, poly64x1_t __p2) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 6);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vbslq_p64(uint64x2_t __p0, poly64x2_t __p1, poly64x2_t __p2) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 38);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vbslq_p64(uint64x2_t __p0, poly64x2_t __p1, poly64x2_t __p2) {
+  poly64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  poly64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (poly64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 38);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vbslq_f64(uint64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vbslq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vbslq_f64(uint64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vbslq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vbsl_f64(uint64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vbsl_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcageq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcageq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcageq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcageq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcage_f64(float64x1_t __p0, float64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcage_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcaged_f64(float64_t __p0, float64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcaged_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcages_f32(float32_t __p0, float32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcages_f32(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcagtq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcagtq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcagtq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcagtq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcagt_f64(float64x1_t __p0, float64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcagt_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcagtd_f64(float64_t __p0, float64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcagtd_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcagts_f32(float32_t __p0, float32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcagts_f32(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcaleq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcaleq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcaleq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcaleq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcale_f64(float64x1_t __p0, float64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcale_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcaled_f64(float64_t __p0, float64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcaled_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcales_f32(float32_t __p0, float32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcales_f32(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcaltq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcaltq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcaltq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcaltq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcalt_f64(float64x1_t __p0, float64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcalt_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcaltd_f64(float64_t __p0, float64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcaltd_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcalts_f32(float32_t __p0, float32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcalts_f32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vceq_p64(poly64x1_t __p0, poly64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 == __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  uint64x2_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 == __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vceqq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 == __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vceq_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 == __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vceq_f64(float64x1_t __p0, float64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 == __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vceq_s64(int64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 == __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vceqd_u64(uint64_t __p0, uint64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vceqd_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vceqd_s64(int64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vceqd_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vceqd_f64(float64_t __p0, float64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vceqd_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vceqs_f32(float32_t __p0, float32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vceqs_f32(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_p8(poly8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_p8(poly8x8_t __p0) {
+  uint8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vceqz_p64(poly64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_p8(poly8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_p8(poly8x16_t __p0) {
+  uint8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_p64(poly64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_p64(poly64x2_t __p0) {
+  uint64x2_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_u32(uint32x4_t __p0) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_u64(uint64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_u64(uint64x2_t __p0) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vceqzq_u16(uint16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vceqzq_u16(uint16x8_t __p0) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vceqzq_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vceqzq_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vceqzq_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vceqzq_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vceqzq_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vceqzq_v((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_u32(uint32x2_t __p0) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vceqz_u64(uint64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vceqz_u16(uint16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vceqz_u16(uint16x4_t __p0) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vceqz_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vceqz_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vceqz_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vceqz_s64(int64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vceqz_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vceqz_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vceqz_v((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64_t vceqzd_u64(uint64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vceqzd_u64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vceqzd_s64(int64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vceqzd_s64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vceqzd_f64(float64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vceqzd_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vceqzs_f32(float32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vceqzs_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 >= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcgeq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 >= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcge_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 >= __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vcge_f64(float64x1_t __p0, float64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 >= __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vcge_s64(int64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 >= __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcged_s64(int64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcged_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcged_u64(uint64_t __p0, uint64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcged_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcged_f64(float64_t __p0, float64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcged_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcges_f32(float32_t __p0, float32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcges_f32(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcgezq_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcgezq_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcgezq_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcgezq_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcgezq_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcgezq_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcgezq_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcgezq_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcgezq_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcgezq_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcgezq_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcgezq_v((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcgezq_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcgezq_v((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcgez_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcgez_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcgez_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcgez_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcgez_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcgez_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcgez_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcgez_s64(int64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vcgez_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcgez_v((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vcgez_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcgez_v((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64_t vcgezd_s64(int64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcgezd_s64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcgezd_f64(float64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcgezd_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcgezs_f32(float32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcgezs_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 > __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcgtq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 > __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcgt_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 > __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vcgt_f64(float64x1_t __p0, float64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 > __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vcgt_s64(int64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 > __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcgtd_s64(int64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcgtd_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcgtd_u64(uint64_t __p0, uint64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcgtd_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcgtd_f64(float64_t __p0, float64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcgtd_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcgts_f32(float32_t __p0, float32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcgts_f32(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcgtzq_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcgtzq_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcgtzq_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcgtzq_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcgtzq_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcgtzq_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcgtzq_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcgtzq_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcgtzq_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcgtzq_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcgtzq_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcgtzq_v((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcgtzq_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcgtzq_v((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcgtz_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcgtz_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcgtz_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcgtz_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcgtz_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcgtz_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcgtz_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcgtz_s64(int64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vcgtz_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcgtz_v((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vcgtz_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcgtz_v((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64_t vcgtzd_s64(int64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcgtzd_s64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcgtzd_f64(float64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcgtzd_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcgtzs_f32(float32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcgtzs_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 <= __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcleq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 <= __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcle_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 <= __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vcle_f64(float64x1_t __p0, float64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 <= __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vcle_s64(int64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 <= __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcled_u64(uint64_t __p0, uint64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcled_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcled_s64(int64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcled_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcled_f64(float64_t __p0, float64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcled_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcles_f32(float32_t __p0, float32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcles_f32(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vclezq_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vclezq_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vclezq_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vclezq_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vclezq_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vclezq_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vclezq_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vclezq_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vclezq_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vclezq_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vclezq_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vclezq_v((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vclezq_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vclezq_v((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vclez_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vclez_v((int8x8_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vclez_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vclez_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vclez_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vclez_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vclez_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vclez_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vclez_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vclez_s64(int64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vclez_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vclez_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vclez_v((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vclez_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vclez_v((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64_t vclezd_s64(int64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vclezd_s64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vclezd_f64(float64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vclezd_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vclezs_f32(float32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vclezs_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_f64(float64x2_t __p0, float64x2_t __p1) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0 < __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcltq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__rev0 < __rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vclt_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 < __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vclt_f64(float64x1_t __p0, float64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 < __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vclt_s64(int64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0 < __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcltd_u64(uint64_t __p0, uint64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcltd_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcltd_s64(int64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcltd_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcltd_f64(float64_t __p0, float64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcltd_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vclts_f32(float32_t __p0, float32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vclts_f32(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vcltzq_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vcltzq_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcltzq_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcltzq_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcltzq_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcltzq_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vcltzq_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vcltzq_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcltzq_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcltzq_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vcltzq_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vcltzq_v((int8x16_t)__p0, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vcltzq_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vcltzq_v((int8x16_t)__rev0, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vcltz_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vcltz_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcltz_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcltz_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcltz_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vcltz_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vcltz_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcltz_s64(int64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vcltz_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vcltz_v((int8x8_t)__p0, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vcltz_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vcltz_v((int8x8_t)__rev0, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64_t vcltzd_s64(int64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcltzd_s64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcltzd_f64(float64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcltzd_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcltzs_f32(float32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcltzs_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vcombine_p64(poly64x1_t __p0, poly64x1_t __p1) {
+  poly64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vcombine_p64(poly64x1_t __p0, poly64x1_t __p1) {
+  poly64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vcombine_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vcombine_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_p8(__p0_278, __p1_278, __p2_278, __p3_278) __extension__ ({ \
+  poly8x16_t __ret_278; \
+  poly8x16_t __s0_278 = __p0_278; \
+  poly8x8_t __s2_278 = __p2_278; \
+  __ret_278 = vsetq_lane_p8(vget_lane_p8(__s2_278, __p3_278), __s0_278, __p1_278); \
+  __ret_278; \
+})
+#else
+#define vcopyq_lane_p8(__p0_279, __p1_279, __p2_279, __p3_279) __extension__ ({ \
+  poly8x16_t __ret_279; \
+  poly8x16_t __s0_279 = __p0_279; \
+  poly8x8_t __s2_279 = __p2_279; \
+  poly8x16_t __rev0_279;  __rev0_279 = __builtin_shufflevector(__s0_279, __s0_279, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly8x8_t __rev2_279;  __rev2_279 = __builtin_shufflevector(__s2_279, __s2_279, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_279 = __noswap_vsetq_lane_p8(__noswap_vget_lane_p8(__rev2_279, __p3_279), __rev0_279, __p1_279); \
+  __ret_279 = __builtin_shufflevector(__ret_279, __ret_279, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_279; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_p16(__p0_280, __p1_280, __p2_280, __p3_280) __extension__ ({ \
+  poly16x8_t __ret_280; \
+  poly16x8_t __s0_280 = __p0_280; \
+  poly16x4_t __s2_280 = __p2_280; \
+  __ret_280 = vsetq_lane_p16(vget_lane_p16(__s2_280, __p3_280), __s0_280, __p1_280); \
+  __ret_280; \
+})
+#else
+#define vcopyq_lane_p16(__p0_281, __p1_281, __p2_281, __p3_281) __extension__ ({ \
+  poly16x8_t __ret_281; \
+  poly16x8_t __s0_281 = __p0_281; \
+  poly16x4_t __s2_281 = __p2_281; \
+  poly16x8_t __rev0_281;  __rev0_281 = __builtin_shufflevector(__s0_281, __s0_281, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly16x4_t __rev2_281;  __rev2_281 = __builtin_shufflevector(__s2_281, __s2_281, 3, 2, 1, 0); \
+  __ret_281 = __noswap_vsetq_lane_p16(__noswap_vget_lane_p16(__rev2_281, __p3_281), __rev0_281, __p1_281); \
+  __ret_281 = __builtin_shufflevector(__ret_281, __ret_281, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_281; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_u8(__p0_282, __p1_282, __p2_282, __p3_282) __extension__ ({ \
+  uint8x16_t __ret_282; \
+  uint8x16_t __s0_282 = __p0_282; \
+  uint8x8_t __s2_282 = __p2_282; \
+  __ret_282 = vsetq_lane_u8(vget_lane_u8(__s2_282, __p3_282), __s0_282, __p1_282); \
+  __ret_282; \
+})
+#else
+#define vcopyq_lane_u8(__p0_283, __p1_283, __p2_283, __p3_283) __extension__ ({ \
+  uint8x16_t __ret_283; \
+  uint8x16_t __s0_283 = __p0_283; \
+  uint8x8_t __s2_283 = __p2_283; \
+  uint8x16_t __rev0_283;  __rev0_283 = __builtin_shufflevector(__s0_283, __s0_283, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev2_283;  __rev2_283 = __builtin_shufflevector(__s2_283, __s2_283, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_283 = __noswap_vsetq_lane_u8(__noswap_vget_lane_u8(__rev2_283, __p3_283), __rev0_283, __p1_283); \
+  __ret_283 = __builtin_shufflevector(__ret_283, __ret_283, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_283; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_u32(__p0_284, __p1_284, __p2_284, __p3_284) __extension__ ({ \
+  uint32x4_t __ret_284; \
+  uint32x4_t __s0_284 = __p0_284; \
+  uint32x2_t __s2_284 = __p2_284; \
+  __ret_284 = vsetq_lane_u32(vget_lane_u32(__s2_284, __p3_284), __s0_284, __p1_284); \
+  __ret_284; \
+})
+#else
+#define vcopyq_lane_u32(__p0_285, __p1_285, __p2_285, __p3_285) __extension__ ({ \
+  uint32x4_t __ret_285; \
+  uint32x4_t __s0_285 = __p0_285; \
+  uint32x2_t __s2_285 = __p2_285; \
+  uint32x4_t __rev0_285;  __rev0_285 = __builtin_shufflevector(__s0_285, __s0_285, 3, 2, 1, 0); \
+  uint32x2_t __rev2_285;  __rev2_285 = __builtin_shufflevector(__s2_285, __s2_285, 1, 0); \
+  __ret_285 = __noswap_vsetq_lane_u32(__noswap_vget_lane_u32(__rev2_285, __p3_285), __rev0_285, __p1_285); \
+  __ret_285 = __builtin_shufflevector(__ret_285, __ret_285, 3, 2, 1, 0); \
+  __ret_285; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_u64(__p0_286, __p1_286, __p2_286, __p3_286) __extension__ ({ \
+  uint64x2_t __ret_286; \
+  uint64x2_t __s0_286 = __p0_286; \
+  uint64x1_t __s2_286 = __p2_286; \
+  __ret_286 = vsetq_lane_u64(vget_lane_u64(__s2_286, __p3_286), __s0_286, __p1_286); \
+  __ret_286; \
+})
+#else
+#define vcopyq_lane_u64(__p0_287, __p1_287, __p2_287, __p3_287) __extension__ ({ \
+  uint64x2_t __ret_287; \
+  uint64x2_t __s0_287 = __p0_287; \
+  uint64x1_t __s2_287 = __p2_287; \
+  uint64x2_t __rev0_287;  __rev0_287 = __builtin_shufflevector(__s0_287, __s0_287, 1, 0); \
+  __ret_287 = __noswap_vsetq_lane_u64(vget_lane_u64(__s2_287, __p3_287), __rev0_287, __p1_287); \
+  __ret_287 = __builtin_shufflevector(__ret_287, __ret_287, 1, 0); \
+  __ret_287; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_u16(__p0_288, __p1_288, __p2_288, __p3_288) __extension__ ({ \
+  uint16x8_t __ret_288; \
+  uint16x8_t __s0_288 = __p0_288; \
+  uint16x4_t __s2_288 = __p2_288; \
+  __ret_288 = vsetq_lane_u16(vget_lane_u16(__s2_288, __p3_288), __s0_288, __p1_288); \
+  __ret_288; \
+})
+#else
+#define vcopyq_lane_u16(__p0_289, __p1_289, __p2_289, __p3_289) __extension__ ({ \
+  uint16x8_t __ret_289; \
+  uint16x8_t __s0_289 = __p0_289; \
+  uint16x4_t __s2_289 = __p2_289; \
+  uint16x8_t __rev0_289;  __rev0_289 = __builtin_shufflevector(__s0_289, __s0_289, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x4_t __rev2_289;  __rev2_289 = __builtin_shufflevector(__s2_289, __s2_289, 3, 2, 1, 0); \
+  __ret_289 = __noswap_vsetq_lane_u16(__noswap_vget_lane_u16(__rev2_289, __p3_289), __rev0_289, __p1_289); \
+  __ret_289 = __builtin_shufflevector(__ret_289, __ret_289, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_289; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_s8(__p0_290, __p1_290, __p2_290, __p3_290) __extension__ ({ \
+  int8x16_t __ret_290; \
+  int8x16_t __s0_290 = __p0_290; \
+  int8x8_t __s2_290 = __p2_290; \
+  __ret_290 = vsetq_lane_s8(vget_lane_s8(__s2_290, __p3_290), __s0_290, __p1_290); \
+  __ret_290; \
+})
+#else
+#define vcopyq_lane_s8(__p0_291, __p1_291, __p2_291, __p3_291) __extension__ ({ \
+  int8x16_t __ret_291; \
+  int8x16_t __s0_291 = __p0_291; \
+  int8x8_t __s2_291 = __p2_291; \
+  int8x16_t __rev0_291;  __rev0_291 = __builtin_shufflevector(__s0_291, __s0_291, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev2_291;  __rev2_291 = __builtin_shufflevector(__s2_291, __s2_291, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_291 = __noswap_vsetq_lane_s8(__noswap_vget_lane_s8(__rev2_291, __p3_291), __rev0_291, __p1_291); \
+  __ret_291 = __builtin_shufflevector(__ret_291, __ret_291, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_291; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_f32(__p0_292, __p1_292, __p2_292, __p3_292) __extension__ ({ \
+  float32x4_t __ret_292; \
+  float32x4_t __s0_292 = __p0_292; \
+  float32x2_t __s2_292 = __p2_292; \
+  __ret_292 = vsetq_lane_f32(vget_lane_f32(__s2_292, __p3_292), __s0_292, __p1_292); \
+  __ret_292; \
+})
+#else
+#define vcopyq_lane_f32(__p0_293, __p1_293, __p2_293, __p3_293) __extension__ ({ \
+  float32x4_t __ret_293; \
+  float32x4_t __s0_293 = __p0_293; \
+  float32x2_t __s2_293 = __p2_293; \
+  float32x4_t __rev0_293;  __rev0_293 = __builtin_shufflevector(__s0_293, __s0_293, 3, 2, 1, 0); \
+  float32x2_t __rev2_293;  __rev2_293 = __builtin_shufflevector(__s2_293, __s2_293, 1, 0); \
+  __ret_293 = __noswap_vsetq_lane_f32(__noswap_vget_lane_f32(__rev2_293, __p3_293), __rev0_293, __p1_293); \
+  __ret_293 = __builtin_shufflevector(__ret_293, __ret_293, 3, 2, 1, 0); \
+  __ret_293; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_s32(__p0_294, __p1_294, __p2_294, __p3_294) __extension__ ({ \
+  int32x4_t __ret_294; \
+  int32x4_t __s0_294 = __p0_294; \
+  int32x2_t __s2_294 = __p2_294; \
+  __ret_294 = vsetq_lane_s32(vget_lane_s32(__s2_294, __p3_294), __s0_294, __p1_294); \
+  __ret_294; \
+})
+#else
+#define vcopyq_lane_s32(__p0_295, __p1_295, __p2_295, __p3_295) __extension__ ({ \
+  int32x4_t __ret_295; \
+  int32x4_t __s0_295 = __p0_295; \
+  int32x2_t __s2_295 = __p2_295; \
+  int32x4_t __rev0_295;  __rev0_295 = __builtin_shufflevector(__s0_295, __s0_295, 3, 2, 1, 0); \
+  int32x2_t __rev2_295;  __rev2_295 = __builtin_shufflevector(__s2_295, __s2_295, 1, 0); \
+  __ret_295 = __noswap_vsetq_lane_s32(__noswap_vget_lane_s32(__rev2_295, __p3_295), __rev0_295, __p1_295); \
+  __ret_295 = __builtin_shufflevector(__ret_295, __ret_295, 3, 2, 1, 0); \
+  __ret_295; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_s64(__p0_296, __p1_296, __p2_296, __p3_296) __extension__ ({ \
+  int64x2_t __ret_296; \
+  int64x2_t __s0_296 = __p0_296; \
+  int64x1_t __s2_296 = __p2_296; \
+  __ret_296 = vsetq_lane_s64(vget_lane_s64(__s2_296, __p3_296), __s0_296, __p1_296); \
+  __ret_296; \
+})
+#else
+#define vcopyq_lane_s64(__p0_297, __p1_297, __p2_297, __p3_297) __extension__ ({ \
+  int64x2_t __ret_297; \
+  int64x2_t __s0_297 = __p0_297; \
+  int64x1_t __s2_297 = __p2_297; \
+  int64x2_t __rev0_297;  __rev0_297 = __builtin_shufflevector(__s0_297, __s0_297, 1, 0); \
+  __ret_297 = __noswap_vsetq_lane_s64(vget_lane_s64(__s2_297, __p3_297), __rev0_297, __p1_297); \
+  __ret_297 = __builtin_shufflevector(__ret_297, __ret_297, 1, 0); \
+  __ret_297; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_s16(__p0_298, __p1_298, __p2_298, __p3_298) __extension__ ({ \
+  int16x8_t __ret_298; \
+  int16x8_t __s0_298 = __p0_298; \
+  int16x4_t __s2_298 = __p2_298; \
+  __ret_298 = vsetq_lane_s16(vget_lane_s16(__s2_298, __p3_298), __s0_298, __p1_298); \
+  __ret_298; \
+})
+#else
+#define vcopyq_lane_s16(__p0_299, __p1_299, __p2_299, __p3_299) __extension__ ({ \
+  int16x8_t __ret_299; \
+  int16x8_t __s0_299 = __p0_299; \
+  int16x4_t __s2_299 = __p2_299; \
+  int16x8_t __rev0_299;  __rev0_299 = __builtin_shufflevector(__s0_299, __s0_299, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev2_299;  __rev2_299 = __builtin_shufflevector(__s2_299, __s2_299, 3, 2, 1, 0); \
+  __ret_299 = __noswap_vsetq_lane_s16(__noswap_vget_lane_s16(__rev2_299, __p3_299), __rev0_299, __p1_299); \
+  __ret_299 = __builtin_shufflevector(__ret_299, __ret_299, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_299; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_p8(__p0_300, __p1_300, __p2_300, __p3_300) __extension__ ({ \
+  poly8x8_t __ret_300; \
+  poly8x8_t __s0_300 = __p0_300; \
+  poly8x8_t __s2_300 = __p2_300; \
+  __ret_300 = vset_lane_p8(vget_lane_p8(__s2_300, __p3_300), __s0_300, __p1_300); \
+  __ret_300; \
+})
+#else
+#define vcopy_lane_p8(__p0_301, __p1_301, __p2_301, __p3_301) __extension__ ({ \
+  poly8x8_t __ret_301; \
+  poly8x8_t __s0_301 = __p0_301; \
+  poly8x8_t __s2_301 = __p2_301; \
+  poly8x8_t __rev0_301;  __rev0_301 = __builtin_shufflevector(__s0_301, __s0_301, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly8x8_t __rev2_301;  __rev2_301 = __builtin_shufflevector(__s2_301, __s2_301, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_301 = __noswap_vset_lane_p8(__noswap_vget_lane_p8(__rev2_301, __p3_301), __rev0_301, __p1_301); \
+  __ret_301 = __builtin_shufflevector(__ret_301, __ret_301, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_301; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_p16(__p0_302, __p1_302, __p2_302, __p3_302) __extension__ ({ \
+  poly16x4_t __ret_302; \
+  poly16x4_t __s0_302 = __p0_302; \
+  poly16x4_t __s2_302 = __p2_302; \
+  __ret_302 = vset_lane_p16(vget_lane_p16(__s2_302, __p3_302), __s0_302, __p1_302); \
+  __ret_302; \
+})
+#else
+#define vcopy_lane_p16(__p0_303, __p1_303, __p2_303, __p3_303) __extension__ ({ \
+  poly16x4_t __ret_303; \
+  poly16x4_t __s0_303 = __p0_303; \
+  poly16x4_t __s2_303 = __p2_303; \
+  poly16x4_t __rev0_303;  __rev0_303 = __builtin_shufflevector(__s0_303, __s0_303, 3, 2, 1, 0); \
+  poly16x4_t __rev2_303;  __rev2_303 = __builtin_shufflevector(__s2_303, __s2_303, 3, 2, 1, 0); \
+  __ret_303 = __noswap_vset_lane_p16(__noswap_vget_lane_p16(__rev2_303, __p3_303), __rev0_303, __p1_303); \
+  __ret_303 = __builtin_shufflevector(__ret_303, __ret_303, 3, 2, 1, 0); \
+  __ret_303; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_u8(__p0_304, __p1_304, __p2_304, __p3_304) __extension__ ({ \
+  uint8x8_t __ret_304; \
+  uint8x8_t __s0_304 = __p0_304; \
+  uint8x8_t __s2_304 = __p2_304; \
+  __ret_304 = vset_lane_u8(vget_lane_u8(__s2_304, __p3_304), __s0_304, __p1_304); \
+  __ret_304; \
+})
+#else
+#define vcopy_lane_u8(__p0_305, __p1_305, __p2_305, __p3_305) __extension__ ({ \
+  uint8x8_t __ret_305; \
+  uint8x8_t __s0_305 = __p0_305; \
+  uint8x8_t __s2_305 = __p2_305; \
+  uint8x8_t __rev0_305;  __rev0_305 = __builtin_shufflevector(__s0_305, __s0_305, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev2_305;  __rev2_305 = __builtin_shufflevector(__s2_305, __s2_305, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_305 = __noswap_vset_lane_u8(__noswap_vget_lane_u8(__rev2_305, __p3_305), __rev0_305, __p1_305); \
+  __ret_305 = __builtin_shufflevector(__ret_305, __ret_305, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_305; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_u32(__p0_306, __p1_306, __p2_306, __p3_306) __extension__ ({ \
+  uint32x2_t __ret_306; \
+  uint32x2_t __s0_306 = __p0_306; \
+  uint32x2_t __s2_306 = __p2_306; \
+  __ret_306 = vset_lane_u32(vget_lane_u32(__s2_306, __p3_306), __s0_306, __p1_306); \
+  __ret_306; \
+})
+#else
+#define vcopy_lane_u32(__p0_307, __p1_307, __p2_307, __p3_307) __extension__ ({ \
+  uint32x2_t __ret_307; \
+  uint32x2_t __s0_307 = __p0_307; \
+  uint32x2_t __s2_307 = __p2_307; \
+  uint32x2_t __rev0_307;  __rev0_307 = __builtin_shufflevector(__s0_307, __s0_307, 1, 0); \
+  uint32x2_t __rev2_307;  __rev2_307 = __builtin_shufflevector(__s2_307, __s2_307, 1, 0); \
+  __ret_307 = __noswap_vset_lane_u32(__noswap_vget_lane_u32(__rev2_307, __p3_307), __rev0_307, __p1_307); \
+  __ret_307 = __builtin_shufflevector(__ret_307, __ret_307, 1, 0); \
+  __ret_307; \
+})
+#endif
+
+#define vcopy_lane_u64(__p0_308, __p1_308, __p2_308, __p3_308) __extension__ ({ \
+  uint64x1_t __ret_308; \
+  uint64x1_t __s0_308 = __p0_308; \
+  uint64x1_t __s2_308 = __p2_308; \
+  __ret_308 = vset_lane_u64(vget_lane_u64(__s2_308, __p3_308), __s0_308, __p1_308); \
+  __ret_308; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_u16(__p0_309, __p1_309, __p2_309, __p3_309) __extension__ ({ \
+  uint16x4_t __ret_309; \
+  uint16x4_t __s0_309 = __p0_309; \
+  uint16x4_t __s2_309 = __p2_309; \
+  __ret_309 = vset_lane_u16(vget_lane_u16(__s2_309, __p3_309), __s0_309, __p1_309); \
+  __ret_309; \
+})
+#else
+#define vcopy_lane_u16(__p0_310, __p1_310, __p2_310, __p3_310) __extension__ ({ \
+  uint16x4_t __ret_310; \
+  uint16x4_t __s0_310 = __p0_310; \
+  uint16x4_t __s2_310 = __p2_310; \
+  uint16x4_t __rev0_310;  __rev0_310 = __builtin_shufflevector(__s0_310, __s0_310, 3, 2, 1, 0); \
+  uint16x4_t __rev2_310;  __rev2_310 = __builtin_shufflevector(__s2_310, __s2_310, 3, 2, 1, 0); \
+  __ret_310 = __noswap_vset_lane_u16(__noswap_vget_lane_u16(__rev2_310, __p3_310), __rev0_310, __p1_310); \
+  __ret_310 = __builtin_shufflevector(__ret_310, __ret_310, 3, 2, 1, 0); \
+  __ret_310; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_s8(__p0_311, __p1_311, __p2_311, __p3_311) __extension__ ({ \
+  int8x8_t __ret_311; \
+  int8x8_t __s0_311 = __p0_311; \
+  int8x8_t __s2_311 = __p2_311; \
+  __ret_311 = vset_lane_s8(vget_lane_s8(__s2_311, __p3_311), __s0_311, __p1_311); \
+  __ret_311; \
+})
+#else
+#define vcopy_lane_s8(__p0_312, __p1_312, __p2_312, __p3_312) __extension__ ({ \
+  int8x8_t __ret_312; \
+  int8x8_t __s0_312 = __p0_312; \
+  int8x8_t __s2_312 = __p2_312; \
+  int8x8_t __rev0_312;  __rev0_312 = __builtin_shufflevector(__s0_312, __s0_312, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev2_312;  __rev2_312 = __builtin_shufflevector(__s2_312, __s2_312, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_312 = __noswap_vset_lane_s8(__noswap_vget_lane_s8(__rev2_312, __p3_312), __rev0_312, __p1_312); \
+  __ret_312 = __builtin_shufflevector(__ret_312, __ret_312, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_312; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_f32(__p0_313, __p1_313, __p2_313, __p3_313) __extension__ ({ \
+  float32x2_t __ret_313; \
+  float32x2_t __s0_313 = __p0_313; \
+  float32x2_t __s2_313 = __p2_313; \
+  __ret_313 = vset_lane_f32(vget_lane_f32(__s2_313, __p3_313), __s0_313, __p1_313); \
+  __ret_313; \
+})
+#else
+#define vcopy_lane_f32(__p0_314, __p1_314, __p2_314, __p3_314) __extension__ ({ \
+  float32x2_t __ret_314; \
+  float32x2_t __s0_314 = __p0_314; \
+  float32x2_t __s2_314 = __p2_314; \
+  float32x2_t __rev0_314;  __rev0_314 = __builtin_shufflevector(__s0_314, __s0_314, 1, 0); \
+  float32x2_t __rev2_314;  __rev2_314 = __builtin_shufflevector(__s2_314, __s2_314, 1, 0); \
+  __ret_314 = __noswap_vset_lane_f32(__noswap_vget_lane_f32(__rev2_314, __p3_314), __rev0_314, __p1_314); \
+  __ret_314 = __builtin_shufflevector(__ret_314, __ret_314, 1, 0); \
+  __ret_314; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_s32(__p0_315, __p1_315, __p2_315, __p3_315) __extension__ ({ \
+  int32x2_t __ret_315; \
+  int32x2_t __s0_315 = __p0_315; \
+  int32x2_t __s2_315 = __p2_315; \
+  __ret_315 = vset_lane_s32(vget_lane_s32(__s2_315, __p3_315), __s0_315, __p1_315); \
+  __ret_315; \
+})
+#else
+#define vcopy_lane_s32(__p0_316, __p1_316, __p2_316, __p3_316) __extension__ ({ \
+  int32x2_t __ret_316; \
+  int32x2_t __s0_316 = __p0_316; \
+  int32x2_t __s2_316 = __p2_316; \
+  int32x2_t __rev0_316;  __rev0_316 = __builtin_shufflevector(__s0_316, __s0_316, 1, 0); \
+  int32x2_t __rev2_316;  __rev2_316 = __builtin_shufflevector(__s2_316, __s2_316, 1, 0); \
+  __ret_316 = __noswap_vset_lane_s32(__noswap_vget_lane_s32(__rev2_316, __p3_316), __rev0_316, __p1_316); \
+  __ret_316 = __builtin_shufflevector(__ret_316, __ret_316, 1, 0); \
+  __ret_316; \
+})
+#endif
+
+#define vcopy_lane_s64(__p0_317, __p1_317, __p2_317, __p3_317) __extension__ ({ \
+  int64x1_t __ret_317; \
+  int64x1_t __s0_317 = __p0_317; \
+  int64x1_t __s2_317 = __p2_317; \
+  __ret_317 = vset_lane_s64(vget_lane_s64(__s2_317, __p3_317), __s0_317, __p1_317); \
+  __ret_317; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_lane_s16(__p0_318, __p1_318, __p2_318, __p3_318) __extension__ ({ \
+  int16x4_t __ret_318; \
+  int16x4_t __s0_318 = __p0_318; \
+  int16x4_t __s2_318 = __p2_318; \
+  __ret_318 = vset_lane_s16(vget_lane_s16(__s2_318, __p3_318), __s0_318, __p1_318); \
+  __ret_318; \
+})
+#else
+#define vcopy_lane_s16(__p0_319, __p1_319, __p2_319, __p3_319) __extension__ ({ \
+  int16x4_t __ret_319; \
+  int16x4_t __s0_319 = __p0_319; \
+  int16x4_t __s2_319 = __p2_319; \
+  int16x4_t __rev0_319;  __rev0_319 = __builtin_shufflevector(__s0_319, __s0_319, 3, 2, 1, 0); \
+  int16x4_t __rev2_319;  __rev2_319 = __builtin_shufflevector(__s2_319, __s2_319, 3, 2, 1, 0); \
+  __ret_319 = __noswap_vset_lane_s16(__noswap_vget_lane_s16(__rev2_319, __p3_319), __rev0_319, __p1_319); \
+  __ret_319 = __builtin_shufflevector(__ret_319, __ret_319, 3, 2, 1, 0); \
+  __ret_319; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_p8(__p0_320, __p1_320, __p2_320, __p3_320) __extension__ ({ \
+  poly8x16_t __ret_320; \
+  poly8x16_t __s0_320 = __p0_320; \
+  poly8x16_t __s2_320 = __p2_320; \
+  __ret_320 = vsetq_lane_p8(vgetq_lane_p8(__s2_320, __p3_320), __s0_320, __p1_320); \
+  __ret_320; \
+})
+#else
+#define vcopyq_laneq_p8(__p0_321, __p1_321, __p2_321, __p3_321) __extension__ ({ \
+  poly8x16_t __ret_321; \
+  poly8x16_t __s0_321 = __p0_321; \
+  poly8x16_t __s2_321 = __p2_321; \
+  poly8x16_t __rev0_321;  __rev0_321 = __builtin_shufflevector(__s0_321, __s0_321, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly8x16_t __rev2_321;  __rev2_321 = __builtin_shufflevector(__s2_321, __s2_321, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_321 = __noswap_vsetq_lane_p8(__noswap_vgetq_lane_p8(__rev2_321, __p3_321), __rev0_321, __p1_321); \
+  __ret_321 = __builtin_shufflevector(__ret_321, __ret_321, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_321; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_p16(__p0_322, __p1_322, __p2_322, __p3_322) __extension__ ({ \
+  poly16x8_t __ret_322; \
+  poly16x8_t __s0_322 = __p0_322; \
+  poly16x8_t __s2_322 = __p2_322; \
+  __ret_322 = vsetq_lane_p16(vgetq_lane_p16(__s2_322, __p3_322), __s0_322, __p1_322); \
+  __ret_322; \
+})
+#else
+#define vcopyq_laneq_p16(__p0_323, __p1_323, __p2_323, __p3_323) __extension__ ({ \
+  poly16x8_t __ret_323; \
+  poly16x8_t __s0_323 = __p0_323; \
+  poly16x8_t __s2_323 = __p2_323; \
+  poly16x8_t __rev0_323;  __rev0_323 = __builtin_shufflevector(__s0_323, __s0_323, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly16x8_t __rev2_323;  __rev2_323 = __builtin_shufflevector(__s2_323, __s2_323, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_323 = __noswap_vsetq_lane_p16(__noswap_vgetq_lane_p16(__rev2_323, __p3_323), __rev0_323, __p1_323); \
+  __ret_323 = __builtin_shufflevector(__ret_323, __ret_323, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_323; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_u8(__p0_324, __p1_324, __p2_324, __p3_324) __extension__ ({ \
+  uint8x16_t __ret_324; \
+  uint8x16_t __s0_324 = __p0_324; \
+  uint8x16_t __s2_324 = __p2_324; \
+  __ret_324 = vsetq_lane_u8(vgetq_lane_u8(__s2_324, __p3_324), __s0_324, __p1_324); \
+  __ret_324; \
+})
+#else
+#define vcopyq_laneq_u8(__p0_325, __p1_325, __p2_325, __p3_325) __extension__ ({ \
+  uint8x16_t __ret_325; \
+  uint8x16_t __s0_325 = __p0_325; \
+  uint8x16_t __s2_325 = __p2_325; \
+  uint8x16_t __rev0_325;  __rev0_325 = __builtin_shufflevector(__s0_325, __s0_325, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev2_325;  __rev2_325 = __builtin_shufflevector(__s2_325, __s2_325, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_325 = __noswap_vsetq_lane_u8(__noswap_vgetq_lane_u8(__rev2_325, __p3_325), __rev0_325, __p1_325); \
+  __ret_325 = __builtin_shufflevector(__ret_325, __ret_325, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_325; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_u32(__p0_326, __p1_326, __p2_326, __p3_326) __extension__ ({ \
+  uint32x4_t __ret_326; \
+  uint32x4_t __s0_326 = __p0_326; \
+  uint32x4_t __s2_326 = __p2_326; \
+  __ret_326 = vsetq_lane_u32(vgetq_lane_u32(__s2_326, __p3_326), __s0_326, __p1_326); \
+  __ret_326; \
+})
+#else
+#define vcopyq_laneq_u32(__p0_327, __p1_327, __p2_327, __p3_327) __extension__ ({ \
+  uint32x4_t __ret_327; \
+  uint32x4_t __s0_327 = __p0_327; \
+  uint32x4_t __s2_327 = __p2_327; \
+  uint32x4_t __rev0_327;  __rev0_327 = __builtin_shufflevector(__s0_327, __s0_327, 3, 2, 1, 0); \
+  uint32x4_t __rev2_327;  __rev2_327 = __builtin_shufflevector(__s2_327, __s2_327, 3, 2, 1, 0); \
+  __ret_327 = __noswap_vsetq_lane_u32(__noswap_vgetq_lane_u32(__rev2_327, __p3_327), __rev0_327, __p1_327); \
+  __ret_327 = __builtin_shufflevector(__ret_327, __ret_327, 3, 2, 1, 0); \
+  __ret_327; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_u64(__p0_328, __p1_328, __p2_328, __p3_328) __extension__ ({ \
+  uint64x2_t __ret_328; \
+  uint64x2_t __s0_328 = __p0_328; \
+  uint64x2_t __s2_328 = __p2_328; \
+  __ret_328 = vsetq_lane_u64(vgetq_lane_u64(__s2_328, __p3_328), __s0_328, __p1_328); \
+  __ret_328; \
+})
+#else
+#define vcopyq_laneq_u64(__p0_329, __p1_329, __p2_329, __p3_329) __extension__ ({ \
+  uint64x2_t __ret_329; \
+  uint64x2_t __s0_329 = __p0_329; \
+  uint64x2_t __s2_329 = __p2_329; \
+  uint64x2_t __rev0_329;  __rev0_329 = __builtin_shufflevector(__s0_329, __s0_329, 1, 0); \
+  uint64x2_t __rev2_329;  __rev2_329 = __builtin_shufflevector(__s2_329, __s2_329, 1, 0); \
+  __ret_329 = __noswap_vsetq_lane_u64(__noswap_vgetq_lane_u64(__rev2_329, __p3_329), __rev0_329, __p1_329); \
+  __ret_329 = __builtin_shufflevector(__ret_329, __ret_329, 1, 0); \
+  __ret_329; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_u16(__p0_330, __p1_330, __p2_330, __p3_330) __extension__ ({ \
+  uint16x8_t __ret_330; \
+  uint16x8_t __s0_330 = __p0_330; \
+  uint16x8_t __s2_330 = __p2_330; \
+  __ret_330 = vsetq_lane_u16(vgetq_lane_u16(__s2_330, __p3_330), __s0_330, __p1_330); \
+  __ret_330; \
+})
+#else
+#define vcopyq_laneq_u16(__p0_331, __p1_331, __p2_331, __p3_331) __extension__ ({ \
+  uint16x8_t __ret_331; \
+  uint16x8_t __s0_331 = __p0_331; \
+  uint16x8_t __s2_331 = __p2_331; \
+  uint16x8_t __rev0_331;  __rev0_331 = __builtin_shufflevector(__s0_331, __s0_331, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev2_331;  __rev2_331 = __builtin_shufflevector(__s2_331, __s2_331, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_331 = __noswap_vsetq_lane_u16(__noswap_vgetq_lane_u16(__rev2_331, __p3_331), __rev0_331, __p1_331); \
+  __ret_331 = __builtin_shufflevector(__ret_331, __ret_331, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_331; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_s8(__p0_332, __p1_332, __p2_332, __p3_332) __extension__ ({ \
+  int8x16_t __ret_332; \
+  int8x16_t __s0_332 = __p0_332; \
+  int8x16_t __s2_332 = __p2_332; \
+  __ret_332 = vsetq_lane_s8(vgetq_lane_s8(__s2_332, __p3_332), __s0_332, __p1_332); \
+  __ret_332; \
+})
+#else
+#define vcopyq_laneq_s8(__p0_333, __p1_333, __p2_333, __p3_333) __extension__ ({ \
+  int8x16_t __ret_333; \
+  int8x16_t __s0_333 = __p0_333; \
+  int8x16_t __s2_333 = __p2_333; \
+  int8x16_t __rev0_333;  __rev0_333 = __builtin_shufflevector(__s0_333, __s0_333, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev2_333;  __rev2_333 = __builtin_shufflevector(__s2_333, __s2_333, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_333 = __noswap_vsetq_lane_s8(__noswap_vgetq_lane_s8(__rev2_333, __p3_333), __rev0_333, __p1_333); \
+  __ret_333 = __builtin_shufflevector(__ret_333, __ret_333, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_333; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_f32(__p0_334, __p1_334, __p2_334, __p3_334) __extension__ ({ \
+  float32x4_t __ret_334; \
+  float32x4_t __s0_334 = __p0_334; \
+  float32x4_t __s2_334 = __p2_334; \
+  __ret_334 = vsetq_lane_f32(vgetq_lane_f32(__s2_334, __p3_334), __s0_334, __p1_334); \
+  __ret_334; \
+})
+#else
+#define vcopyq_laneq_f32(__p0_335, __p1_335, __p2_335, __p3_335) __extension__ ({ \
+  float32x4_t __ret_335; \
+  float32x4_t __s0_335 = __p0_335; \
+  float32x4_t __s2_335 = __p2_335; \
+  float32x4_t __rev0_335;  __rev0_335 = __builtin_shufflevector(__s0_335, __s0_335, 3, 2, 1, 0); \
+  float32x4_t __rev2_335;  __rev2_335 = __builtin_shufflevector(__s2_335, __s2_335, 3, 2, 1, 0); \
+  __ret_335 = __noswap_vsetq_lane_f32(__noswap_vgetq_lane_f32(__rev2_335, __p3_335), __rev0_335, __p1_335); \
+  __ret_335 = __builtin_shufflevector(__ret_335, __ret_335, 3, 2, 1, 0); \
+  __ret_335; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_s32(__p0_336, __p1_336, __p2_336, __p3_336) __extension__ ({ \
+  int32x4_t __ret_336; \
+  int32x4_t __s0_336 = __p0_336; \
+  int32x4_t __s2_336 = __p2_336; \
+  __ret_336 = vsetq_lane_s32(vgetq_lane_s32(__s2_336, __p3_336), __s0_336, __p1_336); \
+  __ret_336; \
+})
+#else
+#define vcopyq_laneq_s32(__p0_337, __p1_337, __p2_337, __p3_337) __extension__ ({ \
+  int32x4_t __ret_337; \
+  int32x4_t __s0_337 = __p0_337; \
+  int32x4_t __s2_337 = __p2_337; \
+  int32x4_t __rev0_337;  __rev0_337 = __builtin_shufflevector(__s0_337, __s0_337, 3, 2, 1, 0); \
+  int32x4_t __rev2_337;  __rev2_337 = __builtin_shufflevector(__s2_337, __s2_337, 3, 2, 1, 0); \
+  __ret_337 = __noswap_vsetq_lane_s32(__noswap_vgetq_lane_s32(__rev2_337, __p3_337), __rev0_337, __p1_337); \
+  __ret_337 = __builtin_shufflevector(__ret_337, __ret_337, 3, 2, 1, 0); \
+  __ret_337; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_s64(__p0_338, __p1_338, __p2_338, __p3_338) __extension__ ({ \
+  int64x2_t __ret_338; \
+  int64x2_t __s0_338 = __p0_338; \
+  int64x2_t __s2_338 = __p2_338; \
+  __ret_338 = vsetq_lane_s64(vgetq_lane_s64(__s2_338, __p3_338), __s0_338, __p1_338); \
+  __ret_338; \
+})
+#else
+#define vcopyq_laneq_s64(__p0_339, __p1_339, __p2_339, __p3_339) __extension__ ({ \
+  int64x2_t __ret_339; \
+  int64x2_t __s0_339 = __p0_339; \
+  int64x2_t __s2_339 = __p2_339; \
+  int64x2_t __rev0_339;  __rev0_339 = __builtin_shufflevector(__s0_339, __s0_339, 1, 0); \
+  int64x2_t __rev2_339;  __rev2_339 = __builtin_shufflevector(__s2_339, __s2_339, 1, 0); \
+  __ret_339 = __noswap_vsetq_lane_s64(__noswap_vgetq_lane_s64(__rev2_339, __p3_339), __rev0_339, __p1_339); \
+  __ret_339 = __builtin_shufflevector(__ret_339, __ret_339, 1, 0); \
+  __ret_339; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_s16(__p0_340, __p1_340, __p2_340, __p3_340) __extension__ ({ \
+  int16x8_t __ret_340; \
+  int16x8_t __s0_340 = __p0_340; \
+  int16x8_t __s2_340 = __p2_340; \
+  __ret_340 = vsetq_lane_s16(vgetq_lane_s16(__s2_340, __p3_340), __s0_340, __p1_340); \
+  __ret_340; \
+})
+#else
+#define vcopyq_laneq_s16(__p0_341, __p1_341, __p2_341, __p3_341) __extension__ ({ \
+  int16x8_t __ret_341; \
+  int16x8_t __s0_341 = __p0_341; \
+  int16x8_t __s2_341 = __p2_341; \
+  int16x8_t __rev0_341;  __rev0_341 = __builtin_shufflevector(__s0_341, __s0_341, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev2_341;  __rev2_341 = __builtin_shufflevector(__s2_341, __s2_341, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_341 = __noswap_vsetq_lane_s16(__noswap_vgetq_lane_s16(__rev2_341, __p3_341), __rev0_341, __p1_341); \
+  __ret_341 = __builtin_shufflevector(__ret_341, __ret_341, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_341; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_p8(__p0_342, __p1_342, __p2_342, __p3_342) __extension__ ({ \
+  poly8x8_t __ret_342; \
+  poly8x8_t __s0_342 = __p0_342; \
+  poly8x16_t __s2_342 = __p2_342; \
+  __ret_342 = vset_lane_p8(vgetq_lane_p8(__s2_342, __p3_342), __s0_342, __p1_342); \
+  __ret_342; \
+})
+#else
+#define vcopy_laneq_p8(__p0_343, __p1_343, __p2_343, __p3_343) __extension__ ({ \
+  poly8x8_t __ret_343; \
+  poly8x8_t __s0_343 = __p0_343; \
+  poly8x16_t __s2_343 = __p2_343; \
+  poly8x8_t __rev0_343;  __rev0_343 = __builtin_shufflevector(__s0_343, __s0_343, 7, 6, 5, 4, 3, 2, 1, 0); \
+  poly8x16_t __rev2_343;  __rev2_343 = __builtin_shufflevector(__s2_343, __s2_343, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_343 = __noswap_vset_lane_p8(__noswap_vgetq_lane_p8(__rev2_343, __p3_343), __rev0_343, __p1_343); \
+  __ret_343 = __builtin_shufflevector(__ret_343, __ret_343, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_343; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_p16(__p0_344, __p1_344, __p2_344, __p3_344) __extension__ ({ \
+  poly16x4_t __ret_344; \
+  poly16x4_t __s0_344 = __p0_344; \
+  poly16x8_t __s2_344 = __p2_344; \
+  __ret_344 = vset_lane_p16(vgetq_lane_p16(__s2_344, __p3_344), __s0_344, __p1_344); \
+  __ret_344; \
+})
+#else
+#define vcopy_laneq_p16(__p0_345, __p1_345, __p2_345, __p3_345) __extension__ ({ \
+  poly16x4_t __ret_345; \
+  poly16x4_t __s0_345 = __p0_345; \
+  poly16x8_t __s2_345 = __p2_345; \
+  poly16x4_t __rev0_345;  __rev0_345 = __builtin_shufflevector(__s0_345, __s0_345, 3, 2, 1, 0); \
+  poly16x8_t __rev2_345;  __rev2_345 = __builtin_shufflevector(__s2_345, __s2_345, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_345 = __noswap_vset_lane_p16(__noswap_vgetq_lane_p16(__rev2_345, __p3_345), __rev0_345, __p1_345); \
+  __ret_345 = __builtin_shufflevector(__ret_345, __ret_345, 3, 2, 1, 0); \
+  __ret_345; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_u8(__p0_346, __p1_346, __p2_346, __p3_346) __extension__ ({ \
+  uint8x8_t __ret_346; \
+  uint8x8_t __s0_346 = __p0_346; \
+  uint8x16_t __s2_346 = __p2_346; \
+  __ret_346 = vset_lane_u8(vgetq_lane_u8(__s2_346, __p3_346), __s0_346, __p1_346); \
+  __ret_346; \
+})
+#else
+#define vcopy_laneq_u8(__p0_347, __p1_347, __p2_347, __p3_347) __extension__ ({ \
+  uint8x8_t __ret_347; \
+  uint8x8_t __s0_347 = __p0_347; \
+  uint8x16_t __s2_347 = __p2_347; \
+  uint8x8_t __rev0_347;  __rev0_347 = __builtin_shufflevector(__s0_347, __s0_347, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x16_t __rev2_347;  __rev2_347 = __builtin_shufflevector(__s2_347, __s2_347, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_347 = __noswap_vset_lane_u8(__noswap_vgetq_lane_u8(__rev2_347, __p3_347), __rev0_347, __p1_347); \
+  __ret_347 = __builtin_shufflevector(__ret_347, __ret_347, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_347; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_u32(__p0_348, __p1_348, __p2_348, __p3_348) __extension__ ({ \
+  uint32x2_t __ret_348; \
+  uint32x2_t __s0_348 = __p0_348; \
+  uint32x4_t __s2_348 = __p2_348; \
+  __ret_348 = vset_lane_u32(vgetq_lane_u32(__s2_348, __p3_348), __s0_348, __p1_348); \
+  __ret_348; \
+})
+#else
+#define vcopy_laneq_u32(__p0_349, __p1_349, __p2_349, __p3_349) __extension__ ({ \
+  uint32x2_t __ret_349; \
+  uint32x2_t __s0_349 = __p0_349; \
+  uint32x4_t __s2_349 = __p2_349; \
+  uint32x2_t __rev0_349;  __rev0_349 = __builtin_shufflevector(__s0_349, __s0_349, 1, 0); \
+  uint32x4_t __rev2_349;  __rev2_349 = __builtin_shufflevector(__s2_349, __s2_349, 3, 2, 1, 0); \
+  __ret_349 = __noswap_vset_lane_u32(__noswap_vgetq_lane_u32(__rev2_349, __p3_349), __rev0_349, __p1_349); \
+  __ret_349 = __builtin_shufflevector(__ret_349, __ret_349, 1, 0); \
+  __ret_349; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_u64(__p0_350, __p1_350, __p2_350, __p3_350) __extension__ ({ \
+  uint64x1_t __ret_350; \
+  uint64x1_t __s0_350 = __p0_350; \
+  uint64x2_t __s2_350 = __p2_350; \
+  __ret_350 = vset_lane_u64(vgetq_lane_u64(__s2_350, __p3_350), __s0_350, __p1_350); \
+  __ret_350; \
+})
+#else
+#define vcopy_laneq_u64(__p0_351, __p1_351, __p2_351, __p3_351) __extension__ ({ \
+  uint64x1_t __ret_351; \
+  uint64x1_t __s0_351 = __p0_351; \
+  uint64x2_t __s2_351 = __p2_351; \
+  uint64x2_t __rev2_351;  __rev2_351 = __builtin_shufflevector(__s2_351, __s2_351, 1, 0); \
+  __ret_351 = vset_lane_u64(__noswap_vgetq_lane_u64(__rev2_351, __p3_351), __s0_351, __p1_351); \
+  __ret_351; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_u16(__p0_352, __p1_352, __p2_352, __p3_352) __extension__ ({ \
+  uint16x4_t __ret_352; \
+  uint16x4_t __s0_352 = __p0_352; \
+  uint16x8_t __s2_352 = __p2_352; \
+  __ret_352 = vset_lane_u16(vgetq_lane_u16(__s2_352, __p3_352), __s0_352, __p1_352); \
+  __ret_352; \
+})
+#else
+#define vcopy_laneq_u16(__p0_353, __p1_353, __p2_353, __p3_353) __extension__ ({ \
+  uint16x4_t __ret_353; \
+  uint16x4_t __s0_353 = __p0_353; \
+  uint16x8_t __s2_353 = __p2_353; \
+  uint16x4_t __rev0_353;  __rev0_353 = __builtin_shufflevector(__s0_353, __s0_353, 3, 2, 1, 0); \
+  uint16x8_t __rev2_353;  __rev2_353 = __builtin_shufflevector(__s2_353, __s2_353, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_353 = __noswap_vset_lane_u16(__noswap_vgetq_lane_u16(__rev2_353, __p3_353), __rev0_353, __p1_353); \
+  __ret_353 = __builtin_shufflevector(__ret_353, __ret_353, 3, 2, 1, 0); \
+  __ret_353; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_s8(__p0_354, __p1_354, __p2_354, __p3_354) __extension__ ({ \
+  int8x8_t __ret_354; \
+  int8x8_t __s0_354 = __p0_354; \
+  int8x16_t __s2_354 = __p2_354; \
+  __ret_354 = vset_lane_s8(vgetq_lane_s8(__s2_354, __p3_354), __s0_354, __p1_354); \
+  __ret_354; \
+})
+#else
+#define vcopy_laneq_s8(__p0_355, __p1_355, __p2_355, __p3_355) __extension__ ({ \
+  int8x8_t __ret_355; \
+  int8x8_t __s0_355 = __p0_355; \
+  int8x16_t __s2_355 = __p2_355; \
+  int8x8_t __rev0_355;  __rev0_355 = __builtin_shufflevector(__s0_355, __s0_355, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x16_t __rev2_355;  __rev2_355 = __builtin_shufflevector(__s2_355, __s2_355, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_355 = __noswap_vset_lane_s8(__noswap_vgetq_lane_s8(__rev2_355, __p3_355), __rev0_355, __p1_355); \
+  __ret_355 = __builtin_shufflevector(__ret_355, __ret_355, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_355; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_f32(__p0_356, __p1_356, __p2_356, __p3_356) __extension__ ({ \
+  float32x2_t __ret_356; \
+  float32x2_t __s0_356 = __p0_356; \
+  float32x4_t __s2_356 = __p2_356; \
+  __ret_356 = vset_lane_f32(vgetq_lane_f32(__s2_356, __p3_356), __s0_356, __p1_356); \
+  __ret_356; \
+})
+#else
+#define vcopy_laneq_f32(__p0_357, __p1_357, __p2_357, __p3_357) __extension__ ({ \
+  float32x2_t __ret_357; \
+  float32x2_t __s0_357 = __p0_357; \
+  float32x4_t __s2_357 = __p2_357; \
+  float32x2_t __rev0_357;  __rev0_357 = __builtin_shufflevector(__s0_357, __s0_357, 1, 0); \
+  float32x4_t __rev2_357;  __rev2_357 = __builtin_shufflevector(__s2_357, __s2_357, 3, 2, 1, 0); \
+  __ret_357 = __noswap_vset_lane_f32(__noswap_vgetq_lane_f32(__rev2_357, __p3_357), __rev0_357, __p1_357); \
+  __ret_357 = __builtin_shufflevector(__ret_357, __ret_357, 1, 0); \
+  __ret_357; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_s32(__p0_358, __p1_358, __p2_358, __p3_358) __extension__ ({ \
+  int32x2_t __ret_358; \
+  int32x2_t __s0_358 = __p0_358; \
+  int32x4_t __s2_358 = __p2_358; \
+  __ret_358 = vset_lane_s32(vgetq_lane_s32(__s2_358, __p3_358), __s0_358, __p1_358); \
+  __ret_358; \
+})
+#else
+#define vcopy_laneq_s32(__p0_359, __p1_359, __p2_359, __p3_359) __extension__ ({ \
+  int32x2_t __ret_359; \
+  int32x2_t __s0_359 = __p0_359; \
+  int32x4_t __s2_359 = __p2_359; \
+  int32x2_t __rev0_359;  __rev0_359 = __builtin_shufflevector(__s0_359, __s0_359, 1, 0); \
+  int32x4_t __rev2_359;  __rev2_359 = __builtin_shufflevector(__s2_359, __s2_359, 3, 2, 1, 0); \
+  __ret_359 = __noswap_vset_lane_s32(__noswap_vgetq_lane_s32(__rev2_359, __p3_359), __rev0_359, __p1_359); \
+  __ret_359 = __builtin_shufflevector(__ret_359, __ret_359, 1, 0); \
+  __ret_359; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_s64(__p0_360, __p1_360, __p2_360, __p3_360) __extension__ ({ \
+  int64x1_t __ret_360; \
+  int64x1_t __s0_360 = __p0_360; \
+  int64x2_t __s2_360 = __p2_360; \
+  __ret_360 = vset_lane_s64(vgetq_lane_s64(__s2_360, __p3_360), __s0_360, __p1_360); \
+  __ret_360; \
+})
+#else
+#define vcopy_laneq_s64(__p0_361, __p1_361, __p2_361, __p3_361) __extension__ ({ \
+  int64x1_t __ret_361; \
+  int64x1_t __s0_361 = __p0_361; \
+  int64x2_t __s2_361 = __p2_361; \
+  int64x2_t __rev2_361;  __rev2_361 = __builtin_shufflevector(__s2_361, __s2_361, 1, 0); \
+  __ret_361 = vset_lane_s64(__noswap_vgetq_lane_s64(__rev2_361, __p3_361), __s0_361, __p1_361); \
+  __ret_361; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_s16(__p0_362, __p1_362, __p2_362, __p3_362) __extension__ ({ \
+  int16x4_t __ret_362; \
+  int16x4_t __s0_362 = __p0_362; \
+  int16x8_t __s2_362 = __p2_362; \
+  __ret_362 = vset_lane_s16(vgetq_lane_s16(__s2_362, __p3_362), __s0_362, __p1_362); \
+  __ret_362; \
+})
+#else
+#define vcopy_laneq_s16(__p0_363, __p1_363, __p2_363, __p3_363) __extension__ ({ \
+  int16x4_t __ret_363; \
+  int16x4_t __s0_363 = __p0_363; \
+  int16x8_t __s2_363 = __p2_363; \
+  int16x4_t __rev0_363;  __rev0_363 = __builtin_shufflevector(__s0_363, __s0_363, 3, 2, 1, 0); \
+  int16x8_t __rev2_363;  __rev2_363 = __builtin_shufflevector(__s2_363, __s2_363, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_363 = __noswap_vset_lane_s16(__noswap_vgetq_lane_s16(__rev2_363, __p3_363), __rev0_363, __p1_363); \
+  __ret_363 = __builtin_shufflevector(__ret_363, __ret_363, 3, 2, 1, 0); \
+  __ret_363; \
+})
+#endif
+
+#define vcreate_p64(__p0) __extension__ ({ \
+  poly64x1_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (poly64x1_t)(__promote); \
+  __ret; \
+})
+#define vcreate_f64(__p0) __extension__ ({ \
+  float64x1_t __ret; \
+  uint64_t __promote = __p0; \
+  __ret = (float64x1_t)(__promote); \
+  __ret; \
+})
+__ai __attribute__((target("neon"))) float32_t vcvts_f32_s32(int32_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vcvts_f32_s32(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vcvts_f32_u32(uint32_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vcvts_f32_u32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_f64(float64x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcvt_f32_f64((int8x16_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vcvt_f32_f64(float64x2_t __p0) {
+  float32x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vcvt_f32_f64((int8x16_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t __noswap_vcvt_f32_f64(float64x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcvt_f32_f64((int8x16_t)__p0, 9);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64_t vcvtd_f64_s64(int64_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vcvtd_f64_s64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64_t vcvtd_f64_u64(uint64_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vcvtd_f64_u64(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vcvtq_f64_u64(uint64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vcvtq_f64_u64(uint64x2_t __p0) {
+  float64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vcvtq_f64_s64(int64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vcvtq_f64_s64(int64x2_t __p0) {
+  float64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vcvtq_f64_v((int8x16_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vcvt_f64_u64(uint64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vcvt_f64_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vcvt_f64_s64(int64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vcvt_f64_v((int8x8_t)__p0, 3);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vcvt_f64_f32(float32x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcvt_f64_f32((int8x8_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vcvt_f64_f32(float32x2_t __p0) {
+  float64x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vcvt_f64_f32((int8x8_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t __noswap_vcvt_f64_f32(float32x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcvt_f64_f32((int8x8_t)__p0, 42);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vcvt_high_f16_f32(float16x4_t __p0, float32x4_t __p1) {
+  float16x8_t __ret;
+  __ret = vcombine_f16(__p0, vcvt_f16_f32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vcvt_high_f16_f32(float16x4_t __p0, float32x4_t __p1) {
+  float16x8_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_f16(__rev0, __noswap_vcvt_f16_f32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vcvt_high_f32_f16(float16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = vcvt_f32_f16(vget_high_f16(__p0));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcvt_high_f32_f16(float16x8_t __p0) {
+  float32x4_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcvt_f32_f16(__noswap_vget_high_f16(__rev0));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vcvt_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
+  float32x4_t __ret;
+  __ret = vcombine_f32(__p0, vcvt_f32_f64(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcvt_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
+  float32x4_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vcombine_f32(__rev0, __noswap_vcvt_f32_f64(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vcvt_high_f64_f32(float32x4_t __p0) {
+  float64x2_t __ret;
+  __ret = vcvt_f64_f32(vget_high_f32(__p0));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vcvt_high_f64_f32(float32x4_t __p0) {
+  float64x2_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vcvt_f64_f32(__noswap_vget_high_f32(__rev0));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#define vcvts_n_f32_u32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  uint32_t __s0 = __p0; \
+  __ret = (float32_t) __builtin_neon_vcvts_n_f32_u32(__s0, __p1); \
+  __ret; \
+})
+#define vcvts_n_f32_s32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  int32_t __s0 = __p0; \
+  __ret = (float32_t) __builtin_neon_vcvts_n_f32_s32(__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_f64_u64(__p0, __p1) __extension__ ({ \
+  float64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#else
+#define vcvtq_n_f64_u64(__p0, __p1) __extension__ ({ \
+  float64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__rev0, __p1, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_f64_s64(__p0, __p1) __extension__ ({ \
+  float64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__s0, __p1, 35); \
+  __ret; \
+})
+#else
+#define vcvtq_n_f64_s64(__p0, __p1) __extension__ ({ \
+  float64x2_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float64x2_t) __builtin_neon_vcvtq_n_f64_v((int8x16_t)__rev0, __p1, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vcvt_n_f64_u64(__p0, __p1) __extension__ ({ \
+  float64x1_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (float64x1_t) __builtin_neon_vcvt_n_f64_v((int8x8_t)__s0, __p1, 19); \
+  __ret; \
+})
+#define vcvt_n_f64_s64(__p0, __p1) __extension__ ({ \
+  float64x1_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (float64x1_t) __builtin_neon_vcvt_n_f64_v((int8x8_t)__s0, __p1, 3); \
+  __ret; \
+})
+#define vcvtd_n_f64_u64(__p0, __p1) __extension__ ({ \
+  float64_t __ret; \
+  uint64_t __s0 = __p0; \
+  __ret = (float64_t) __builtin_neon_vcvtd_n_f64_u64(__s0, __p1); \
+  __ret; \
+})
+#define vcvtd_n_f64_s64(__p0, __p1) __extension__ ({ \
+  float64_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (float64_t) __builtin_neon_vcvtd_n_f64_s64(__s0, __p1); \
+  __ret; \
+})
+#define vcvts_n_s32_f32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  float32_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vcvts_n_s32_f32(__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_s64_f64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  __ret = (int64x2_t) __builtin_neon_vcvtq_n_s64_v((int8x16_t)__s0, __p1, 35); \
+  __ret; \
+})
+#else
+#define vcvtq_n_s64_f64(__p0, __p1) __extension__ ({ \
+  int64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vcvtq_n_s64_v((int8x16_t)__rev0, __p1, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vcvt_n_s64_f64(__p0, __p1) __extension__ ({ \
+  int64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  __ret = (int64x1_t) __builtin_neon_vcvt_n_s64_v((int8x8_t)__s0, __p1, 3); \
+  __ret; \
+})
+#define vcvtd_n_s64_f64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  float64_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vcvtd_n_s64_f64(__s0, __p1); \
+  __ret; \
+})
+#define vcvts_n_u32_f32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  float32_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vcvts_n_u32_f32(__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vcvtq_n_u64_f64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  __ret = (uint64x2_t) __builtin_neon_vcvtq_n_u64_v((int8x16_t)__s0, __p1, 51); \
+  __ret; \
+})
+#else
+#define vcvtq_n_u64_f64(__p0, __p1) __extension__ ({ \
+  uint64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vcvtq_n_u64_v((int8x16_t)__rev0, __p1, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vcvt_n_u64_f64(__p0, __p1) __extension__ ({ \
+  uint64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  __ret = (uint64x1_t) __builtin_neon_vcvt_n_u64_v((int8x8_t)__s0, __p1, 19); \
+  __ret; \
+})
+#define vcvtd_n_u64_f64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  float64_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vcvtd_n_u64_f64(__s0, __p1); \
+  __ret; \
+})
+__ai __attribute__((target("neon"))) int32_t vcvts_s32_f32(float32_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vcvts_s32_f32(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vcvtd_s64_f64(float64_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vcvtd_s64_f64(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vcvtq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vcvtq_s64_v((int8x16_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vcvtq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vcvtq_s64_v((int8x16_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vcvt_s64_f64(float64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vcvt_s64_v((int8x8_t)__p0, 3);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcvts_u32_f32(float32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcvts_u32_f32(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcvtd_u64_f64(float64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcvtd_u64_f64(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcvtq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcvtq_u64_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcvtq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcvtq_u64_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcvt_u64_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcvt_u64_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vcvtas_s32_f32(float32_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vcvtas_s32_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vcvtaq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vcvtaq_s64_v((int8x16_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vcvtaq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vcvtaq_s64_v((int8x16_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vcvta_s64_f64(float64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vcvta_s64_v((int8x8_t)__p0, 3);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vcvtad_s64_f64(float64_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vcvtad_s64_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcvtas_u32_f32(float32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcvtas_u32_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcvtaq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcvtaq_u64_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcvtaq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcvtaq_u64_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcvta_u64_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcvta_u64_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcvtad_u64_f64(float64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcvtad_u64_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vcvtms_s32_f32(float32_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vcvtms_s32_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vcvtmq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vcvtmq_s64_v((int8x16_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vcvtmq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vcvtmq_s64_v((int8x16_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vcvtm_s64_f64(float64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vcvtm_s64_v((int8x8_t)__p0, 3);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vcvtmd_s64_f64(float64_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vcvtmd_s64_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcvtms_u32_f32(float32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcvtms_u32_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcvtmq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcvtmq_u64_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcvtmq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcvtmq_u64_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcvtm_u64_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcvtm_u64_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcvtmd_u64_f64(float64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcvtmd_u64_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vcvtns_s32_f32(float32_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vcvtns_s32_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vcvtnq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vcvtnq_s64_v((int8x16_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vcvtnq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vcvtnq_s64_v((int8x16_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vcvtn_s64_f64(float64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vcvtn_s64_v((int8x8_t)__p0, 3);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vcvtnd_s64_f64(float64_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vcvtnd_s64_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcvtns_u32_f32(float32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcvtns_u32_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcvtnq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcvtnq_u64_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcvtnq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcvtnq_u64_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcvtn_u64_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcvtn_u64_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcvtnd_u64_f64(float64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcvtnd_u64_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vcvtps_s32_f32(float32_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vcvtps_s32_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vcvtpq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vcvtpq_s64_v((int8x16_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vcvtpq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vcvtpq_s64_v((int8x16_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vcvtp_s64_f64(float64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vcvtp_s64_v((int8x8_t)__p0, 3);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vcvtpd_s64_f64(float64_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vcvtpd_s64_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vcvtps_u32_f32(float32_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vcvtps_u32_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vcvtpq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vcvtpq_u64_v((int8x16_t)__p0, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vcvtpq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vcvtpq_u64_v((int8x16_t)__rev0, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vcvtp_u64_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vcvtp_u64_v((int8x8_t)__p0, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vcvtpd_u64_f64(float64_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vcvtpd_u64_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vcvtxd_f32_f64(float64_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vcvtxd_f32_f64(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vcvtx_f32_f64(float64x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcvtx_f32_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vcvtx_f32_f64(float64x2_t __p0) {
+  float32x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vcvtx_f32_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t __noswap_vcvtx_f32_f64(float64x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vcvtx_f32_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vcvtx_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
+  float32x4_t __ret;
+  __ret = vcombine_f32(__p0, vcvtx_f32_f64(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vcvtx_high_f32_f64(float32x2_t __p0, float64x2_t __p1) {
+  float32x4_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vcombine_f32(__rev0, __noswap_vcvtx_f32_f64(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vdivq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = __p0 / __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vdivq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 / __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vdivq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = __p0 / __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vdivq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 / __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vdiv_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = __p0 / __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vdiv_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = __p0 / __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vdiv_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 / __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupb_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  __ret = (poly8_t) __builtin_neon_vdupb_lane_i8((poly8x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdupb_lane_p8(__p0, __p1) __extension__ ({ \
+  poly8_t __ret; \
+  poly8x8_t __s0 = __p0; \
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8_t) __builtin_neon_vdupb_lane_i8((poly8x8_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vduph_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  __ret = (poly16_t) __builtin_neon_vduph_lane_i16((poly16x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vduph_lane_p16(__p0, __p1) __extension__ ({ \
+  poly16_t __ret; \
+  poly16x4_t __s0 = __p0; \
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (poly16_t) __builtin_neon_vduph_lane_i16((poly16x4_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupb_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdupb_lane_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8x8_t __s0 = __p0; \
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdups_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdups_lane_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32x2_t __s0 = __p0; \
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#define vdupd_lane_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64x1_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vdupd_lane_i64((int64x1_t)__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vduph_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vduph_lane_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16x4_t __s0 = __p0; \
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupb_lane_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  __ret = (int8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdupb_lane_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8x8_t __s0 = __p0; \
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8_t) __builtin_neon_vdupb_lane_i8((int8x8_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#define vdupd_lane_f64(__p0, __p1) __extension__ ({ \
+  float64_t __ret; \
+  float64x1_t __s0 = __p0; \
+  __ret = (float64_t) __builtin_neon_vdupd_lane_f64((float64x1_t)__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vdups_lane_f32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  float32x2_t __s0 = __p0; \
+  __ret = (float32_t) __builtin_neon_vdups_lane_f32((float32x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdups_lane_f32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float32_t) __builtin_neon_vdups_lane_f32((float32x2_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdups_lane_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32x2_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdups_lane_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int32_t) __builtin_neon_vdups_lane_i32((int32x2_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#define vdupd_lane_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64x1_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vdupd_lane_i64((int64x1_t)__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vduph_lane_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16x4_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vduph_lane_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int16_t) __builtin_neon_vduph_lane_i16((int16x4_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vduph_lane_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16x4_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vduph_lane_f16((float16x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vduph_lane_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16x4_t __s0 = __p0; \
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vduph_lane_f16((float16x4_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#define vdup_lane_p64(__p0_364, __p1_364) __extension__ ({ \
+  poly64x1_t __ret_364; \
+  poly64x1_t __s0_364 = __p0_364; \
+  __ret_364 = splat_lane_p64(__s0_364, __p1_364); \
+  __ret_364; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_p64(__p0_365, __p1_365) __extension__ ({ \
+  poly64x2_t __ret_365; \
+  poly64x1_t __s0_365 = __p0_365; \
+  __ret_365 = splatq_lane_p64(__s0_365, __p1_365); \
+  __ret_365; \
+})
+#else
+#define vdupq_lane_p64(__p0_366, __p1_366) __extension__ ({ \
+  poly64x2_t __ret_366; \
+  poly64x1_t __s0_366 = __p0_366; \
+  __ret_366 = __noswap_splatq_lane_p64(__s0_366, __p1_366); \
+  __ret_366 = __builtin_shufflevector(__ret_366, __ret_366, 1, 0); \
+  __ret_366; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_lane_f64(__p0_367, __p1_367) __extension__ ({ \
+  float64x2_t __ret_367; \
+  float64x1_t __s0_367 = __p0_367; \
+  __ret_367 = splatq_lane_f64(__s0_367, __p1_367); \
+  __ret_367; \
+})
+#else
+#define vdupq_lane_f64(__p0_368, __p1_368) __extension__ ({ \
+  float64x2_t __ret_368; \
+  float64x1_t __s0_368 = __p0_368; \
+  __ret_368 = __noswap_splatq_lane_f64(__s0_368, __p1_368); \
+  __ret_368 = __builtin_shufflevector(__ret_368, __ret_368, 1, 0); \
+  __ret_368; \
+})
+#endif
+
+#define vdup_lane_f64(__p0_369, __p1_369) __extension__ ({ \
+  float64x1_t __ret_369; \
+  float64x1_t __s0_369 = __p0_369; \
+  __ret_369 = splat_lane_f64(__s0_369, __p1_369); \
+  __ret_369; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vdupb_laneq_p8(__p0, __p1) __extension__ ({ \
+  poly8_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  __ret = (poly8_t) __builtin_neon_vdupb_laneq_i8((poly8x16_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdupb_laneq_p8(__p0, __p1) __extension__ ({ \
+  poly8_t __ret; \
+  poly8x16_t __s0 = __p0; \
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly8_t) __builtin_neon_vdupb_laneq_i8((poly8x16_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vduph_laneq_p16(__p0, __p1) __extension__ ({ \
+  poly16_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  __ret = (poly16_t) __builtin_neon_vduph_laneq_i16((poly16x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vduph_laneq_p16(__p0, __p1) __extension__ ({ \
+  poly16_t __ret; \
+  poly16x8_t __s0 = __p0; \
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (poly16_t) __builtin_neon_vduph_laneq_i16((poly16x8_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupb_laneq_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdupb_laneq_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8x16_t __s0 = __p0; \
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdups_laneq_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdups_laneq_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (uint32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupd_laneq_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdupd_laneq_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (uint64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vduph_laneq_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vduph_laneq_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16x8_t __s0 = __p0; \
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (uint16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupb_laneq_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8x16_t __s0 = __p0; \
+  __ret = (int8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdupb_laneq_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8x16_t __s0 = __p0; \
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int8_t) __builtin_neon_vdupb_laneq_i8((int8x16_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupd_laneq_f64(__p0, __p1) __extension__ ({ \
+  float64_t __ret; \
+  float64x2_t __s0 = __p0; \
+  __ret = (float64_t) __builtin_neon_vdupd_laneq_f64((float64x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdupd_laneq_f64(__p0, __p1) __extension__ ({ \
+  float64_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float64_t) __builtin_neon_vdupd_laneq_f64((float64x2_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdups_laneq_f32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  float32x4_t __s0 = __p0; \
+  __ret = (float32_t) __builtin_neon_vdups_laneq_f32((float32x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdups_laneq_f32(__p0, __p1) __extension__ ({ \
+  float32_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (float32_t) __builtin_neon_vdups_laneq_f32((float32x4_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdups_laneq_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32x4_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdups_laneq_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  __ret = (int32_t) __builtin_neon_vdups_laneq_i32((int32x4_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupd_laneq_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64x2_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vdupd_laneq_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64x2_t __s0 = __p0; \
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (int64_t) __builtin_neon_vdupd_laneq_i64((int64x2_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vduph_laneq_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16x8_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vduph_laneq_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16_t) __builtin_neon_vduph_laneq_i16((int16x8_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vduph_laneq_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16x8_t __s0 = __p0; \
+  __ret = (float16_t) __builtin_neon_vduph_laneq_f16((float16x8_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vduph_laneq_f16(__p0, __p1) __extension__ ({ \
+  float16_t __ret; \
+  float16x8_t __s0 = __p0; \
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (float16_t) __builtin_neon_vduph_laneq_f16((float16x8_t)__rev0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_p8(__p0_370, __p1_370) __extension__ ({ \
+  poly8x8_t __ret_370; \
+  poly8x16_t __s0_370 = __p0_370; \
+  __ret_370 = splat_laneq_p8(__s0_370, __p1_370); \
+  __ret_370; \
+})
+#else
+#define vdup_laneq_p8(__p0_371, __p1_371) __extension__ ({ \
+  poly8x8_t __ret_371; \
+  poly8x16_t __s0_371 = __p0_371; \
+  poly8x16_t __rev0_371;  __rev0_371 = __builtin_shufflevector(__s0_371, __s0_371, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_371 = __noswap_splat_laneq_p8(__rev0_371, __p1_371); \
+  __ret_371 = __builtin_shufflevector(__ret_371, __ret_371, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_371; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_p64(__p0_372, __p1_372) __extension__ ({ \
+  poly64x1_t __ret_372; \
+  poly64x2_t __s0_372 = __p0_372; \
+  __ret_372 = splat_laneq_p64(__s0_372, __p1_372); \
+  __ret_372; \
+})
+#else
+#define vdup_laneq_p64(__p0_373, __p1_373) __extension__ ({ \
+  poly64x1_t __ret_373; \
+  poly64x2_t __s0_373 = __p0_373; \
+  poly64x2_t __rev0_373;  __rev0_373 = __builtin_shufflevector(__s0_373, __s0_373, 1, 0); \
+  __ret_373 = __noswap_splat_laneq_p64(__rev0_373, __p1_373); \
+  __ret_373; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_p16(__p0_374, __p1_374) __extension__ ({ \
+  poly16x4_t __ret_374; \
+  poly16x8_t __s0_374 = __p0_374; \
+  __ret_374 = splat_laneq_p16(__s0_374, __p1_374); \
+  __ret_374; \
+})
+#else
+#define vdup_laneq_p16(__p0_375, __p1_375) __extension__ ({ \
+  poly16x4_t __ret_375; \
+  poly16x8_t __s0_375 = __p0_375; \
+  poly16x8_t __rev0_375;  __rev0_375 = __builtin_shufflevector(__s0_375, __s0_375, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_375 = __noswap_splat_laneq_p16(__rev0_375, __p1_375); \
+  __ret_375 = __builtin_shufflevector(__ret_375, __ret_375, 3, 2, 1, 0); \
+  __ret_375; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_p8(__p0_376, __p1_376) __extension__ ({ \
+  poly8x16_t __ret_376; \
+  poly8x16_t __s0_376 = __p0_376; \
+  __ret_376 = splatq_laneq_p8(__s0_376, __p1_376); \
+  __ret_376; \
+})
+#else
+#define vdupq_laneq_p8(__p0_377, __p1_377) __extension__ ({ \
+  poly8x16_t __ret_377; \
+  poly8x16_t __s0_377 = __p0_377; \
+  poly8x16_t __rev0_377;  __rev0_377 = __builtin_shufflevector(__s0_377, __s0_377, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_377 = __noswap_splatq_laneq_p8(__rev0_377, __p1_377); \
+  __ret_377 = __builtin_shufflevector(__ret_377, __ret_377, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_377; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_p64(__p0_378, __p1_378) __extension__ ({ \
+  poly64x2_t __ret_378; \
+  poly64x2_t __s0_378 = __p0_378; \
+  __ret_378 = splatq_laneq_p64(__s0_378, __p1_378); \
+  __ret_378; \
+})
+#else
+#define vdupq_laneq_p64(__p0_379, __p1_379) __extension__ ({ \
+  poly64x2_t __ret_379; \
+  poly64x2_t __s0_379 = __p0_379; \
+  poly64x2_t __rev0_379;  __rev0_379 = __builtin_shufflevector(__s0_379, __s0_379, 1, 0); \
+  __ret_379 = __noswap_splatq_laneq_p64(__rev0_379, __p1_379); \
+  __ret_379 = __builtin_shufflevector(__ret_379, __ret_379, 1, 0); \
+  __ret_379; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_p16(__p0_380, __p1_380) __extension__ ({ \
+  poly16x8_t __ret_380; \
+  poly16x8_t __s0_380 = __p0_380; \
+  __ret_380 = splatq_laneq_p16(__s0_380, __p1_380); \
+  __ret_380; \
+})
+#else
+#define vdupq_laneq_p16(__p0_381, __p1_381) __extension__ ({ \
+  poly16x8_t __ret_381; \
+  poly16x8_t __s0_381 = __p0_381; \
+  poly16x8_t __rev0_381;  __rev0_381 = __builtin_shufflevector(__s0_381, __s0_381, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_381 = __noswap_splatq_laneq_p16(__rev0_381, __p1_381); \
+  __ret_381 = __builtin_shufflevector(__ret_381, __ret_381, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_381; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_u8(__p0_382, __p1_382) __extension__ ({ \
+  uint8x16_t __ret_382; \
+  uint8x16_t __s0_382 = __p0_382; \
+  __ret_382 = splatq_laneq_u8(__s0_382, __p1_382); \
+  __ret_382; \
+})
+#else
+#define vdupq_laneq_u8(__p0_383, __p1_383) __extension__ ({ \
+  uint8x16_t __ret_383; \
+  uint8x16_t __s0_383 = __p0_383; \
+  uint8x16_t __rev0_383;  __rev0_383 = __builtin_shufflevector(__s0_383, __s0_383, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_383 = __noswap_splatq_laneq_u8(__rev0_383, __p1_383); \
+  __ret_383 = __builtin_shufflevector(__ret_383, __ret_383, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_383; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_u32(__p0_384, __p1_384) __extension__ ({ \
+  uint32x4_t __ret_384; \
+  uint32x4_t __s0_384 = __p0_384; \
+  __ret_384 = splatq_laneq_u32(__s0_384, __p1_384); \
+  __ret_384; \
+})
+#else
+#define vdupq_laneq_u32(__p0_385, __p1_385) __extension__ ({ \
+  uint32x4_t __ret_385; \
+  uint32x4_t __s0_385 = __p0_385; \
+  uint32x4_t __rev0_385;  __rev0_385 = __builtin_shufflevector(__s0_385, __s0_385, 3, 2, 1, 0); \
+  __ret_385 = __noswap_splatq_laneq_u32(__rev0_385, __p1_385); \
+  __ret_385 = __builtin_shufflevector(__ret_385, __ret_385, 3, 2, 1, 0); \
+  __ret_385; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_u64(__p0_386, __p1_386) __extension__ ({ \
+  uint64x2_t __ret_386; \
+  uint64x2_t __s0_386 = __p0_386; \
+  __ret_386 = splatq_laneq_u64(__s0_386, __p1_386); \
+  __ret_386; \
+})
+#else
+#define vdupq_laneq_u64(__p0_387, __p1_387) __extension__ ({ \
+  uint64x2_t __ret_387; \
+  uint64x2_t __s0_387 = __p0_387; \
+  uint64x2_t __rev0_387;  __rev0_387 = __builtin_shufflevector(__s0_387, __s0_387, 1, 0); \
+  __ret_387 = __noswap_splatq_laneq_u64(__rev0_387, __p1_387); \
+  __ret_387 = __builtin_shufflevector(__ret_387, __ret_387, 1, 0); \
+  __ret_387; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_u16(__p0_388, __p1_388) __extension__ ({ \
+  uint16x8_t __ret_388; \
+  uint16x8_t __s0_388 = __p0_388; \
+  __ret_388 = splatq_laneq_u16(__s0_388, __p1_388); \
+  __ret_388; \
+})
+#else
+#define vdupq_laneq_u16(__p0_389, __p1_389) __extension__ ({ \
+  uint16x8_t __ret_389; \
+  uint16x8_t __s0_389 = __p0_389; \
+  uint16x8_t __rev0_389;  __rev0_389 = __builtin_shufflevector(__s0_389, __s0_389, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_389 = __noswap_splatq_laneq_u16(__rev0_389, __p1_389); \
+  __ret_389 = __builtin_shufflevector(__ret_389, __ret_389, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_389; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_s8(__p0_390, __p1_390) __extension__ ({ \
+  int8x16_t __ret_390; \
+  int8x16_t __s0_390 = __p0_390; \
+  __ret_390 = splatq_laneq_s8(__s0_390, __p1_390); \
+  __ret_390; \
+})
+#else
+#define vdupq_laneq_s8(__p0_391, __p1_391) __extension__ ({ \
+  int8x16_t __ret_391; \
+  int8x16_t __s0_391 = __p0_391; \
+  int8x16_t __rev0_391;  __rev0_391 = __builtin_shufflevector(__s0_391, __s0_391, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_391 = __noswap_splatq_laneq_s8(__rev0_391, __p1_391); \
+  __ret_391 = __builtin_shufflevector(__ret_391, __ret_391, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_391; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_f64(__p0_392, __p1_392) __extension__ ({ \
+  float64x2_t __ret_392; \
+  float64x2_t __s0_392 = __p0_392; \
+  __ret_392 = splatq_laneq_f64(__s0_392, __p1_392); \
+  __ret_392; \
+})
+#else
+#define vdupq_laneq_f64(__p0_393, __p1_393) __extension__ ({ \
+  float64x2_t __ret_393; \
+  float64x2_t __s0_393 = __p0_393; \
+  float64x2_t __rev0_393;  __rev0_393 = __builtin_shufflevector(__s0_393, __s0_393, 1, 0); \
+  __ret_393 = __noswap_splatq_laneq_f64(__rev0_393, __p1_393); \
+  __ret_393 = __builtin_shufflevector(__ret_393, __ret_393, 1, 0); \
+  __ret_393; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_f32(__p0_394, __p1_394) __extension__ ({ \
+  float32x4_t __ret_394; \
+  float32x4_t __s0_394 = __p0_394; \
+  __ret_394 = splatq_laneq_f32(__s0_394, __p1_394); \
+  __ret_394; \
+})
+#else
+#define vdupq_laneq_f32(__p0_395, __p1_395) __extension__ ({ \
+  float32x4_t __ret_395; \
+  float32x4_t __s0_395 = __p0_395; \
+  float32x4_t __rev0_395;  __rev0_395 = __builtin_shufflevector(__s0_395, __s0_395, 3, 2, 1, 0); \
+  __ret_395 = __noswap_splatq_laneq_f32(__rev0_395, __p1_395); \
+  __ret_395 = __builtin_shufflevector(__ret_395, __ret_395, 3, 2, 1, 0); \
+  __ret_395; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_f16(__p0_396, __p1_396) __extension__ ({ \
+  float16x8_t __ret_396; \
+  float16x8_t __s0_396 = __p0_396; \
+  __ret_396 = splatq_laneq_f16(__s0_396, __p1_396); \
+  __ret_396; \
+})
+#else
+#define vdupq_laneq_f16(__p0_397, __p1_397) __extension__ ({ \
+  float16x8_t __ret_397; \
+  float16x8_t __s0_397 = __p0_397; \
+  float16x8_t __rev0_397;  __rev0_397 = __builtin_shufflevector(__s0_397, __s0_397, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_397 = __noswap_splatq_laneq_f16(__rev0_397, __p1_397); \
+  __ret_397 = __builtin_shufflevector(__ret_397, __ret_397, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_397; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_s32(__p0_398, __p1_398) __extension__ ({ \
+  int32x4_t __ret_398; \
+  int32x4_t __s0_398 = __p0_398; \
+  __ret_398 = splatq_laneq_s32(__s0_398, __p1_398); \
+  __ret_398; \
+})
+#else
+#define vdupq_laneq_s32(__p0_399, __p1_399) __extension__ ({ \
+  int32x4_t __ret_399; \
+  int32x4_t __s0_399 = __p0_399; \
+  int32x4_t __rev0_399;  __rev0_399 = __builtin_shufflevector(__s0_399, __s0_399, 3, 2, 1, 0); \
+  __ret_399 = __noswap_splatq_laneq_s32(__rev0_399, __p1_399); \
+  __ret_399 = __builtin_shufflevector(__ret_399, __ret_399, 3, 2, 1, 0); \
+  __ret_399; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_s64(__p0_400, __p1_400) __extension__ ({ \
+  int64x2_t __ret_400; \
+  int64x2_t __s0_400 = __p0_400; \
+  __ret_400 = splatq_laneq_s64(__s0_400, __p1_400); \
+  __ret_400; \
+})
+#else
+#define vdupq_laneq_s64(__p0_401, __p1_401) __extension__ ({ \
+  int64x2_t __ret_401; \
+  int64x2_t __s0_401 = __p0_401; \
+  int64x2_t __rev0_401;  __rev0_401 = __builtin_shufflevector(__s0_401, __s0_401, 1, 0); \
+  __ret_401 = __noswap_splatq_laneq_s64(__rev0_401, __p1_401); \
+  __ret_401 = __builtin_shufflevector(__ret_401, __ret_401, 1, 0); \
+  __ret_401; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdupq_laneq_s16(__p0_402, __p1_402) __extension__ ({ \
+  int16x8_t __ret_402; \
+  int16x8_t __s0_402 = __p0_402; \
+  __ret_402 = splatq_laneq_s16(__s0_402, __p1_402); \
+  __ret_402; \
+})
+#else
+#define vdupq_laneq_s16(__p0_403, __p1_403) __extension__ ({ \
+  int16x8_t __ret_403; \
+  int16x8_t __s0_403 = __p0_403; \
+  int16x8_t __rev0_403;  __rev0_403 = __builtin_shufflevector(__s0_403, __s0_403, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_403 = __noswap_splatq_laneq_s16(__rev0_403, __p1_403); \
+  __ret_403 = __builtin_shufflevector(__ret_403, __ret_403, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_403; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_u8(__p0_404, __p1_404) __extension__ ({ \
+  uint8x8_t __ret_404; \
+  uint8x16_t __s0_404 = __p0_404; \
+  __ret_404 = splat_laneq_u8(__s0_404, __p1_404); \
+  __ret_404; \
+})
+#else
+#define vdup_laneq_u8(__p0_405, __p1_405) __extension__ ({ \
+  uint8x8_t __ret_405; \
+  uint8x16_t __s0_405 = __p0_405; \
+  uint8x16_t __rev0_405;  __rev0_405 = __builtin_shufflevector(__s0_405, __s0_405, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_405 = __noswap_splat_laneq_u8(__rev0_405, __p1_405); \
+  __ret_405 = __builtin_shufflevector(__ret_405, __ret_405, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_405; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_u32(__p0_406, __p1_406) __extension__ ({ \
+  uint32x2_t __ret_406; \
+  uint32x4_t __s0_406 = __p0_406; \
+  __ret_406 = splat_laneq_u32(__s0_406, __p1_406); \
+  __ret_406; \
+})
+#else
+#define vdup_laneq_u32(__p0_407, __p1_407) __extension__ ({ \
+  uint32x2_t __ret_407; \
+  uint32x4_t __s0_407 = __p0_407; \
+  uint32x4_t __rev0_407;  __rev0_407 = __builtin_shufflevector(__s0_407, __s0_407, 3, 2, 1, 0); \
+  __ret_407 = __noswap_splat_laneq_u32(__rev0_407, __p1_407); \
+  __ret_407 = __builtin_shufflevector(__ret_407, __ret_407, 1, 0); \
+  __ret_407; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_u64(__p0_408, __p1_408) __extension__ ({ \
+  uint64x1_t __ret_408; \
+  uint64x2_t __s0_408 = __p0_408; \
+  __ret_408 = splat_laneq_u64(__s0_408, __p1_408); \
+  __ret_408; \
+})
+#else
+#define vdup_laneq_u64(__p0_409, __p1_409) __extension__ ({ \
+  uint64x1_t __ret_409; \
+  uint64x2_t __s0_409 = __p0_409; \
+  uint64x2_t __rev0_409;  __rev0_409 = __builtin_shufflevector(__s0_409, __s0_409, 1, 0); \
+  __ret_409 = __noswap_splat_laneq_u64(__rev0_409, __p1_409); \
+  __ret_409; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_u16(__p0_410, __p1_410) __extension__ ({ \
+  uint16x4_t __ret_410; \
+  uint16x8_t __s0_410 = __p0_410; \
+  __ret_410 = splat_laneq_u16(__s0_410, __p1_410); \
+  __ret_410; \
+})
+#else
+#define vdup_laneq_u16(__p0_411, __p1_411) __extension__ ({ \
+  uint16x4_t __ret_411; \
+  uint16x8_t __s0_411 = __p0_411; \
+  uint16x8_t __rev0_411;  __rev0_411 = __builtin_shufflevector(__s0_411, __s0_411, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_411 = __noswap_splat_laneq_u16(__rev0_411, __p1_411); \
+  __ret_411 = __builtin_shufflevector(__ret_411, __ret_411, 3, 2, 1, 0); \
+  __ret_411; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_s8(__p0_412, __p1_412) __extension__ ({ \
+  int8x8_t __ret_412; \
+  int8x16_t __s0_412 = __p0_412; \
+  __ret_412 = splat_laneq_s8(__s0_412, __p1_412); \
+  __ret_412; \
+})
+#else
+#define vdup_laneq_s8(__p0_413, __p1_413) __extension__ ({ \
+  int8x8_t __ret_413; \
+  int8x16_t __s0_413 = __p0_413; \
+  int8x16_t __rev0_413;  __rev0_413 = __builtin_shufflevector(__s0_413, __s0_413, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_413 = __noswap_splat_laneq_s8(__rev0_413, __p1_413); \
+  __ret_413 = __builtin_shufflevector(__ret_413, __ret_413, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_413; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_f64(__p0_414, __p1_414) __extension__ ({ \
+  float64x1_t __ret_414; \
+  float64x2_t __s0_414 = __p0_414; \
+  __ret_414 = splat_laneq_f64(__s0_414, __p1_414); \
+  __ret_414; \
+})
+#else
+#define vdup_laneq_f64(__p0_415, __p1_415) __extension__ ({ \
+  float64x1_t __ret_415; \
+  float64x2_t __s0_415 = __p0_415; \
+  float64x2_t __rev0_415;  __rev0_415 = __builtin_shufflevector(__s0_415, __s0_415, 1, 0); \
+  __ret_415 = __noswap_splat_laneq_f64(__rev0_415, __p1_415); \
+  __ret_415; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_f32(__p0_416, __p1_416) __extension__ ({ \
+  float32x2_t __ret_416; \
+  float32x4_t __s0_416 = __p0_416; \
+  __ret_416 = splat_laneq_f32(__s0_416, __p1_416); \
+  __ret_416; \
+})
+#else
+#define vdup_laneq_f32(__p0_417, __p1_417) __extension__ ({ \
+  float32x2_t __ret_417; \
+  float32x4_t __s0_417 = __p0_417; \
+  float32x4_t __rev0_417;  __rev0_417 = __builtin_shufflevector(__s0_417, __s0_417, 3, 2, 1, 0); \
+  __ret_417 = __noswap_splat_laneq_f32(__rev0_417, __p1_417); \
+  __ret_417 = __builtin_shufflevector(__ret_417, __ret_417, 1, 0); \
+  __ret_417; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_f16(__p0_418, __p1_418) __extension__ ({ \
+  float16x4_t __ret_418; \
+  float16x8_t __s0_418 = __p0_418; \
+  __ret_418 = splat_laneq_f16(__s0_418, __p1_418); \
+  __ret_418; \
+})
+#else
+#define vdup_laneq_f16(__p0_419, __p1_419) __extension__ ({ \
+  float16x4_t __ret_419; \
+  float16x8_t __s0_419 = __p0_419; \
+  float16x8_t __rev0_419;  __rev0_419 = __builtin_shufflevector(__s0_419, __s0_419, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_419 = __noswap_splat_laneq_f16(__rev0_419, __p1_419); \
+  __ret_419 = __builtin_shufflevector(__ret_419, __ret_419, 3, 2, 1, 0); \
+  __ret_419; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_s32(__p0_420, __p1_420) __extension__ ({ \
+  int32x2_t __ret_420; \
+  int32x4_t __s0_420 = __p0_420; \
+  __ret_420 = splat_laneq_s32(__s0_420, __p1_420); \
+  __ret_420; \
+})
+#else
+#define vdup_laneq_s32(__p0_421, __p1_421) __extension__ ({ \
+  int32x2_t __ret_421; \
+  int32x4_t __s0_421 = __p0_421; \
+  int32x4_t __rev0_421;  __rev0_421 = __builtin_shufflevector(__s0_421, __s0_421, 3, 2, 1, 0); \
+  __ret_421 = __noswap_splat_laneq_s32(__rev0_421, __p1_421); \
+  __ret_421 = __builtin_shufflevector(__ret_421, __ret_421, 1, 0); \
+  __ret_421; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_s64(__p0_422, __p1_422) __extension__ ({ \
+  int64x1_t __ret_422; \
+  int64x2_t __s0_422 = __p0_422; \
+  __ret_422 = splat_laneq_s64(__s0_422, __p1_422); \
+  __ret_422; \
+})
+#else
+#define vdup_laneq_s64(__p0_423, __p1_423) __extension__ ({ \
+  int64x1_t __ret_423; \
+  int64x2_t __s0_423 = __p0_423; \
+  int64x2_t __rev0_423;  __rev0_423 = __builtin_shufflevector(__s0_423, __s0_423, 1, 0); \
+  __ret_423 = __noswap_splat_laneq_s64(__rev0_423, __p1_423); \
+  __ret_423; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdup_laneq_s16(__p0_424, __p1_424) __extension__ ({ \
+  int16x4_t __ret_424; \
+  int16x8_t __s0_424 = __p0_424; \
+  __ret_424 = splat_laneq_s16(__s0_424, __p1_424); \
+  __ret_424; \
+})
+#else
+#define vdup_laneq_s16(__p0_425, __p1_425) __extension__ ({ \
+  int16x4_t __ret_425; \
+  int16x8_t __s0_425 = __p0_425; \
+  int16x8_t __rev0_425;  __rev0_425 = __builtin_shufflevector(__s0_425, __s0_425, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_425 = __noswap_splat_laneq_s16(__rev0_425, __p1_425); \
+  __ret_425 = __builtin_shufflevector(__ret_425, __ret_425, 3, 2, 1, 0); \
+  __ret_425; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) poly64x1_t vdup_n_p64(poly64_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t) {__p0};
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vdupq_n_p64(poly64_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vdupq_n_p64(poly64_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vdupq_n_f64(float64_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vdupq_n_f64(float64_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vdup_n_f64(float64_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) {__p0};
+  return __ret;
+}
+#define vext_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1_t __ret; \
+  poly64x1_t __s0 = __p0; \
+  poly64x1_t __s1 = __p1; \
+  __ret = (poly64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vextq_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  poly64x2_t __s1 = __p1; \
+  __ret = (poly64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 38); \
+  __ret; \
+})
+#else
+#define vextq_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  poly64x2_t __s1 = __p1; \
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (poly64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 38); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vextq_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  __ret = (float64x2_t) __builtin_neon_vextq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 42); \
+  __ret; \
+})
+#else
+#define vextq_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (float64x2_t) __builtin_neon_vextq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 42); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vext_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  float64x1_t __s1 = __p1; \
+  __ret = (float64x1_t) __builtin_neon_vext_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 10); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vfmaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vfmaq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vfmaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vfmaq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t __noswap_vfmaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vfmaq_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vfma_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vfma_v((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
+  return __ret;
+}
+#define vfmad_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64_t __ret; \
+  float64_t __s0 = __p0; \
+  float64_t __s1 = __p1; \
+  float64x1_t __s2 = __p2; \
+  __ret = (float64_t) __builtin_neon_vfmad_lane_f64(__s0, __s1, (float64x1_t)__s2, __p3); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vfmas_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32_t __ret; \
+  float32_t __s0 = __p0; \
+  float32_t __s1 = __p1; \
+  float32x2_t __s2 = __p2; \
+  __ret = (float32_t) __builtin_neon_vfmas_lane_f32(__s0, __s1, (float32x2_t)__s2, __p3); \
+  __ret; \
+})
+#else
+#define vfmas_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32_t __ret; \
+  float32_t __s0 = __p0; \
+  float32_t __s1 = __p1; \
+  float32x2_t __s2 = __p2; \
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+  __ret = (float32_t) __builtin_neon_vfmas_lane_f32(__s0, __s1, (float32x2_t)__rev2, __p3); \
+  __ret; \
+})
+#define __noswap_vfmas_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32_t __ret; \
+  float32_t __s0 = __p0; \
+  float32_t __s1 = __p1; \
+  float32x2_t __s2 = __p2; \
+  __ret = (float32_t) __builtin_neon_vfmas_lane_f32(__s0, __s1, (float32x2_t)__s2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmaq_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  float64x1_t __s2 = __p2; \
+  __ret = (float64x2_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 42); \
+  __ret; \
+})
+#else
+#define vfmaq_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  float64x1_t __s2 = __p2; \
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (float64x2_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__s2, __p3, 42); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vfmaq_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  float64x1_t __s2 = __p2; \
+  __ret = (float64x2_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 42); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmaq_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  float32x2_t __s2 = __p2; \
+  __ret = (float32x4_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 41); \
+  __ret; \
+})
+#else
+#define vfmaq_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  float32x2_t __s2 = __p2; \
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+  __ret = (float32x4_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, __p3, 41); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vfmaq_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  float32x2_t __s2 = __p2; \
+  __ret = (float32x4_t) __builtin_neon_vfmaq_lane_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x8_t)__s2, __p3, 41); \
+  __ret; \
+})
+#endif
+
+#define vfma_lane_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  float64x1_t __s1 = __p1; \
+  float64x1_t __s2 = __p2; \
+  __ret = (float64x1_t) __builtin_neon_vfma_lane_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 10); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vfma_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  float32x2_t __s2 = __p2; \
+  __ret = (float32x2_t) __builtin_neon_vfma_lane_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 9); \
+  __ret; \
+})
+#else
+#define vfma_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  float32x2_t __s2 = __p2; \
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  float32x2_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+  __ret = (float32x2_t) __builtin_neon_vfma_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x8_t)__rev2, __p3, 9); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vfma_lane_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  float32x2_t __s2 = __p2; \
+  __ret = (float32x2_t) __builtin_neon_vfma_lane_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x8_t)__s2, __p3, 9); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmad_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64_t __ret; \
+  float64_t __s0 = __p0; \
+  float64_t __s1 = __p1; \
+  float64x2_t __s2 = __p2; \
+  __ret = (float64_t) __builtin_neon_vfmad_laneq_f64(__s0, __s1, (float64x2_t)__s2, __p3); \
+  __ret; \
+})
+#else
+#define vfmad_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64_t __ret; \
+  float64_t __s0 = __p0; \
+  float64_t __s1 = __p1; \
+  float64x2_t __s2 = __p2; \
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+  __ret = (float64_t) __builtin_neon_vfmad_laneq_f64(__s0, __s1, (float64x2_t)__rev2, __p3); \
+  __ret; \
+})
+#define __noswap_vfmad_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64_t __ret; \
+  float64_t __s0 = __p0; \
+  float64_t __s1 = __p1; \
+  float64x2_t __s2 = __p2; \
+  __ret = (float64_t) __builtin_neon_vfmad_laneq_f64(__s0, __s1, (float64x2_t)__s2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmas_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32_t __ret; \
+  float32_t __s0 = __p0; \
+  float32_t __s1 = __p1; \
+  float32x4_t __s2 = __p2; \
+  __ret = (float32_t) __builtin_neon_vfmas_laneq_f32(__s0, __s1, (float32x4_t)__s2, __p3); \
+  __ret; \
+})
+#else
+#define vfmas_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32_t __ret; \
+  float32_t __s0 = __p0; \
+  float32_t __s1 = __p1; \
+  float32x4_t __s2 = __p2; \
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (float32_t) __builtin_neon_vfmas_laneq_f32(__s0, __s1, (float32x4_t)__rev2, __p3); \
+  __ret; \
+})
+#define __noswap_vfmas_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32_t __ret; \
+  float32_t __s0 = __p0; \
+  float32_t __s1 = __p1; \
+  float32x4_t __s2 = __p2; \
+  __ret = (float32_t) __builtin_neon_vfmas_laneq_f32(__s0, __s1, (float32x4_t)__s2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmaq_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __s2 = __p2; \
+  __ret = (float64x2_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 42); \
+  __ret; \
+})
+#else
+#define vfmaq_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __s2 = __p2; \
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+  __ret = (float64x2_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 42); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vfmaq_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __s2 = __p2; \
+  __ret = (float64x2_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 42); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmaq_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  float32x4_t __s2 = __p2; \
+  __ret = (float32x4_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 41); \
+  __ret; \
+})
+#else
+#define vfmaq_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  float32x4_t __s2 = __p2; \
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (float32x4_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 41); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#define __noswap_vfmaq_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x4_t __ret; \
+  float32x4_t __s0 = __p0; \
+  float32x4_t __s1 = __p1; \
+  float32x4_t __s2 = __p2; \
+  __ret = (float32x4_t) __builtin_neon_vfmaq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 41); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfma_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  float64x1_t __s1 = __p1; \
+  float64x2_t __s2 = __p2; \
+  __ret = (float64x1_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 10); \
+  __ret; \
+})
+#else
+#define vfma_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  float64x1_t __s1 = __p1; \
+  float64x2_t __s2 = __p2; \
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+  __ret = (float64x1_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__rev2, __p3, 10); \
+  __ret; \
+})
+#define __noswap_vfma_laneq_f64(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  float64x1_t __s1 = __p1; \
+  float64x2_t __s2 = __p2; \
+  __ret = (float64x1_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 10); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfma_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  float32x4_t __s2 = __p2; \
+  __ret = (float32x2_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 9); \
+  __ret; \
+})
+#else
+#define vfma_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  float32x4_t __s2 = __p2; \
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  float32x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (float32x2_t) __builtin_neon_vfma_laneq_v((int8x8_t)__rev0, (int8x8_t)__rev1, (int8x16_t)__rev2, __p3, 9); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vfma_laneq_f32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  float32x2_t __ret; \
+  float32x2_t __s0 = __p0; \
+  float32x2_t __s1 = __p1; \
+  float32x4_t __s2 = __p2; \
+  __ret = (float32x2_t) __builtin_neon_vfma_laneq_v((int8x8_t)__s0, (int8x8_t)__s1, (int8x16_t)__s2, __p3, 9); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vfmaq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
+  float64x2_t __ret;
+  __ret = vfmaq_f64(__p0, __p1, (float64x2_t) {__p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vfmaq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vfmaq_f64(__rev0, __rev1, (float64x2_t) {__p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vfma_n_f64(float64x1_t __p0, float64x1_t __p1, float64_t __p2) {
+  float64x1_t __ret;
+  __ret = vfma_f64(__p0, __p1, (float64x1_t) {__p2});
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vfmsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = vfmaq_f64(__p0, -__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vfmsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __noswap_vfmaq_f64(__rev0, -__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vfms_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+  float64x1_t __ret;
+  __ret = vfma_f64(__p0, -__p1, __p2);
+  return __ret;
+}
+#define vfmsd_lane_f64(__p0_426, __p1_426, __p2_426, __p3_426) __extension__ ({ \
+  float64_t __ret_426; \
+  float64_t __s0_426 = __p0_426; \
+  float64_t __s1_426 = __p1_426; \
+  float64x1_t __s2_426 = __p2_426; \
+  __ret_426 = vfmad_lane_f64(__s0_426, -__s1_426, __s2_426, __p3_426); \
+  __ret_426; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vfmss_lane_f32(__p0_427, __p1_427, __p2_427, __p3_427) __extension__ ({ \
+  float32_t __ret_427; \
+  float32_t __s0_427 = __p0_427; \
+  float32_t __s1_427 = __p1_427; \
+  float32x2_t __s2_427 = __p2_427; \
+  __ret_427 = vfmas_lane_f32(__s0_427, -__s1_427, __s2_427, __p3_427); \
+  __ret_427; \
+})
+#else
+#define vfmss_lane_f32(__p0_428, __p1_428, __p2_428, __p3_428) __extension__ ({ \
+  float32_t __ret_428; \
+  float32_t __s0_428 = __p0_428; \
+  float32_t __s1_428 = __p1_428; \
+  float32x2_t __s2_428 = __p2_428; \
+  float32x2_t __rev2_428;  __rev2_428 = __builtin_shufflevector(__s2_428, __s2_428, 1, 0); \
+  __ret_428 = __noswap_vfmas_lane_f32(__s0_428, -__s1_428, __rev2_428, __p3_428); \
+  __ret_428; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmsq_lane_f64(__p0_429, __p1_429, __p2_429, __p3_429) __extension__ ({ \
+  float64x2_t __ret_429; \
+  float64x2_t __s0_429 = __p0_429; \
+  float64x2_t __s1_429 = __p1_429; \
+  float64x1_t __s2_429 = __p2_429; \
+  __ret_429 = vfmaq_lane_f64(__s0_429, -__s1_429, __s2_429, __p3_429); \
+  __ret_429; \
+})
+#else
+#define vfmsq_lane_f64(__p0_430, __p1_430, __p2_430, __p3_430) __extension__ ({ \
+  float64x2_t __ret_430; \
+  float64x2_t __s0_430 = __p0_430; \
+  float64x2_t __s1_430 = __p1_430; \
+  float64x1_t __s2_430 = __p2_430; \
+  float64x2_t __rev0_430;  __rev0_430 = __builtin_shufflevector(__s0_430, __s0_430, 1, 0); \
+  float64x2_t __rev1_430;  __rev1_430 = __builtin_shufflevector(__s1_430, __s1_430, 1, 0); \
+  __ret_430 = __noswap_vfmaq_lane_f64(__rev0_430, -__rev1_430, __s2_430, __p3_430); \
+  __ret_430 = __builtin_shufflevector(__ret_430, __ret_430, 1, 0); \
+  __ret_430; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmsq_lane_f32(__p0_431, __p1_431, __p2_431, __p3_431) __extension__ ({ \
+  float32x4_t __ret_431; \
+  float32x4_t __s0_431 = __p0_431; \
+  float32x4_t __s1_431 = __p1_431; \
+  float32x2_t __s2_431 = __p2_431; \
+  __ret_431 = vfmaq_lane_f32(__s0_431, -__s1_431, __s2_431, __p3_431); \
+  __ret_431; \
+})
+#else
+#define vfmsq_lane_f32(__p0_432, __p1_432, __p2_432, __p3_432) __extension__ ({ \
+  float32x4_t __ret_432; \
+  float32x4_t __s0_432 = __p0_432; \
+  float32x4_t __s1_432 = __p1_432; \
+  float32x2_t __s2_432 = __p2_432; \
+  float32x4_t __rev0_432;  __rev0_432 = __builtin_shufflevector(__s0_432, __s0_432, 3, 2, 1, 0); \
+  float32x4_t __rev1_432;  __rev1_432 = __builtin_shufflevector(__s1_432, __s1_432, 3, 2, 1, 0); \
+  float32x2_t __rev2_432;  __rev2_432 = __builtin_shufflevector(__s2_432, __s2_432, 1, 0); \
+  __ret_432 = __noswap_vfmaq_lane_f32(__rev0_432, -__rev1_432, __rev2_432, __p3_432); \
+  __ret_432 = __builtin_shufflevector(__ret_432, __ret_432, 3, 2, 1, 0); \
+  __ret_432; \
+})
+#endif
+
+#define vfms_lane_f64(__p0_433, __p1_433, __p2_433, __p3_433) __extension__ ({ \
+  float64x1_t __ret_433; \
+  float64x1_t __s0_433 = __p0_433; \
+  float64x1_t __s1_433 = __p1_433; \
+  float64x1_t __s2_433 = __p2_433; \
+  __ret_433 = vfma_lane_f64(__s0_433, -__s1_433, __s2_433, __p3_433); \
+  __ret_433; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vfms_lane_f32(__p0_434, __p1_434, __p2_434, __p3_434) __extension__ ({ \
+  float32x2_t __ret_434; \
+  float32x2_t __s0_434 = __p0_434; \
+  float32x2_t __s1_434 = __p1_434; \
+  float32x2_t __s2_434 = __p2_434; \
+  __ret_434 = vfma_lane_f32(__s0_434, -__s1_434, __s2_434, __p3_434); \
+  __ret_434; \
+})
+#else
+#define vfms_lane_f32(__p0_435, __p1_435, __p2_435, __p3_435) __extension__ ({ \
+  float32x2_t __ret_435; \
+  float32x2_t __s0_435 = __p0_435; \
+  float32x2_t __s1_435 = __p1_435; \
+  float32x2_t __s2_435 = __p2_435; \
+  float32x2_t __rev0_435;  __rev0_435 = __builtin_shufflevector(__s0_435, __s0_435, 1, 0); \
+  float32x2_t __rev1_435;  __rev1_435 = __builtin_shufflevector(__s1_435, __s1_435, 1, 0); \
+  float32x2_t __rev2_435;  __rev2_435 = __builtin_shufflevector(__s2_435, __s2_435, 1, 0); \
+  __ret_435 = __noswap_vfma_lane_f32(__rev0_435, -__rev1_435, __rev2_435, __p3_435); \
+  __ret_435 = __builtin_shufflevector(__ret_435, __ret_435, 1, 0); \
+  __ret_435; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmsd_laneq_f64(__p0_436, __p1_436, __p2_436, __p3_436) __extension__ ({ \
+  float64_t __ret_436; \
+  float64_t __s0_436 = __p0_436; \
+  float64_t __s1_436 = __p1_436; \
+  float64x2_t __s2_436 = __p2_436; \
+  __ret_436 = vfmad_laneq_f64(__s0_436, -__s1_436, __s2_436, __p3_436); \
+  __ret_436; \
+})
+#else
+#define vfmsd_laneq_f64(__p0_437, __p1_437, __p2_437, __p3_437) __extension__ ({ \
+  float64_t __ret_437; \
+  float64_t __s0_437 = __p0_437; \
+  float64_t __s1_437 = __p1_437; \
+  float64x2_t __s2_437 = __p2_437; \
+  float64x2_t __rev2_437;  __rev2_437 = __builtin_shufflevector(__s2_437, __s2_437, 1, 0); \
+  __ret_437 = __noswap_vfmad_laneq_f64(__s0_437, -__s1_437, __rev2_437, __p3_437); \
+  __ret_437; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmss_laneq_f32(__p0_438, __p1_438, __p2_438, __p3_438) __extension__ ({ \
+  float32_t __ret_438; \
+  float32_t __s0_438 = __p0_438; \
+  float32_t __s1_438 = __p1_438; \
+  float32x4_t __s2_438 = __p2_438; \
+  __ret_438 = vfmas_laneq_f32(__s0_438, -__s1_438, __s2_438, __p3_438); \
+  __ret_438; \
+})
+#else
+#define vfmss_laneq_f32(__p0_439, __p1_439, __p2_439, __p3_439) __extension__ ({ \
+  float32_t __ret_439; \
+  float32_t __s0_439 = __p0_439; \
+  float32_t __s1_439 = __p1_439; \
+  float32x4_t __s2_439 = __p2_439; \
+  float32x4_t __rev2_439;  __rev2_439 = __builtin_shufflevector(__s2_439, __s2_439, 3, 2, 1, 0); \
+  __ret_439 = __noswap_vfmas_laneq_f32(__s0_439, -__s1_439, __rev2_439, __p3_439); \
+  __ret_439; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmsq_laneq_f64(__p0_440, __p1_440, __p2_440, __p3_440) __extension__ ({ \
+  float64x2_t __ret_440; \
+  float64x2_t __s0_440 = __p0_440; \
+  float64x2_t __s1_440 = __p1_440; \
+  float64x2_t __s2_440 = __p2_440; \
+  __ret_440 = vfmaq_laneq_f64(__s0_440, -__s1_440, __s2_440, __p3_440); \
+  __ret_440; \
+})
+#else
+#define vfmsq_laneq_f64(__p0_441, __p1_441, __p2_441, __p3_441) __extension__ ({ \
+  float64x2_t __ret_441; \
+  float64x2_t __s0_441 = __p0_441; \
+  float64x2_t __s1_441 = __p1_441; \
+  float64x2_t __s2_441 = __p2_441; \
+  float64x2_t __rev0_441;  __rev0_441 = __builtin_shufflevector(__s0_441, __s0_441, 1, 0); \
+  float64x2_t __rev1_441;  __rev1_441 = __builtin_shufflevector(__s1_441, __s1_441, 1, 0); \
+  float64x2_t __rev2_441;  __rev2_441 = __builtin_shufflevector(__s2_441, __s2_441, 1, 0); \
+  __ret_441 = __noswap_vfmaq_laneq_f64(__rev0_441, -__rev1_441, __rev2_441, __p3_441); \
+  __ret_441 = __builtin_shufflevector(__ret_441, __ret_441, 1, 0); \
+  __ret_441; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmsq_laneq_f32(__p0_442, __p1_442, __p2_442, __p3_442) __extension__ ({ \
+  float32x4_t __ret_442; \
+  float32x4_t __s0_442 = __p0_442; \
+  float32x4_t __s1_442 = __p1_442; \
+  float32x4_t __s2_442 = __p2_442; \
+  __ret_442 = vfmaq_laneq_f32(__s0_442, -__s1_442, __s2_442, __p3_442); \
+  __ret_442; \
+})
+#else
+#define vfmsq_laneq_f32(__p0_443, __p1_443, __p2_443, __p3_443) __extension__ ({ \
+  float32x4_t __ret_443; \
+  float32x4_t __s0_443 = __p0_443; \
+  float32x4_t __s1_443 = __p1_443; \
+  float32x4_t __s2_443 = __p2_443; \
+  float32x4_t __rev0_443;  __rev0_443 = __builtin_shufflevector(__s0_443, __s0_443, 3, 2, 1, 0); \
+  float32x4_t __rev1_443;  __rev1_443 = __builtin_shufflevector(__s1_443, __s1_443, 3, 2, 1, 0); \
+  float32x4_t __rev2_443;  __rev2_443 = __builtin_shufflevector(__s2_443, __s2_443, 3, 2, 1, 0); \
+  __ret_443 = __noswap_vfmaq_laneq_f32(__rev0_443, -__rev1_443, __rev2_443, __p3_443); \
+  __ret_443 = __builtin_shufflevector(__ret_443, __ret_443, 3, 2, 1, 0); \
+  __ret_443; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfms_laneq_f64(__p0_444, __p1_444, __p2_444, __p3_444) __extension__ ({ \
+  float64x1_t __ret_444; \
+  float64x1_t __s0_444 = __p0_444; \
+  float64x1_t __s1_444 = __p1_444; \
+  float64x2_t __s2_444 = __p2_444; \
+  __ret_444 = vfma_laneq_f64(__s0_444, -__s1_444, __s2_444, __p3_444); \
+  __ret_444; \
+})
+#else
+#define vfms_laneq_f64(__p0_445, __p1_445, __p2_445, __p3_445) __extension__ ({ \
+  float64x1_t __ret_445; \
+  float64x1_t __s0_445 = __p0_445; \
+  float64x1_t __s1_445 = __p1_445; \
+  float64x2_t __s2_445 = __p2_445; \
+  float64x2_t __rev2_445;  __rev2_445 = __builtin_shufflevector(__s2_445, __s2_445, 1, 0); \
+  __ret_445 = __noswap_vfma_laneq_f64(__s0_445, -__s1_445, __rev2_445, __p3_445); \
+  __ret_445; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfms_laneq_f32(__p0_446, __p1_446, __p2_446, __p3_446) __extension__ ({ \
+  float32x2_t __ret_446; \
+  float32x2_t __s0_446 = __p0_446; \
+  float32x2_t __s1_446 = __p1_446; \
+  float32x4_t __s2_446 = __p2_446; \
+  __ret_446 = vfma_laneq_f32(__s0_446, -__s1_446, __s2_446, __p3_446); \
+  __ret_446; \
+})
+#else
+#define vfms_laneq_f32(__p0_447, __p1_447, __p2_447, __p3_447) __extension__ ({ \
+  float32x2_t __ret_447; \
+  float32x2_t __s0_447 = __p0_447; \
+  float32x2_t __s1_447 = __p1_447; \
+  float32x4_t __s2_447 = __p2_447; \
+  float32x2_t __rev0_447;  __rev0_447 = __builtin_shufflevector(__s0_447, __s0_447, 1, 0); \
+  float32x2_t __rev1_447;  __rev1_447 = __builtin_shufflevector(__s1_447, __s1_447, 1, 0); \
+  float32x4_t __rev2_447;  __rev2_447 = __builtin_shufflevector(__s2_447, __s2_447, 3, 2, 1, 0); \
+  __ret_447 = __noswap_vfma_laneq_f32(__rev0_447, -__rev1_447, __rev2_447, __p3_447); \
+  __ret_447 = __builtin_shufflevector(__ret_447, __ret_447, 1, 0); \
+  __ret_447; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vfmsq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
+  float64x2_t __ret;
+  __ret = vfmaq_f64(__p0, -__p1, (float64x2_t) {__p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vfmsq_n_f64(float64x2_t __p0, float64x2_t __p1, float64_t __p2) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vfmaq_f64(__rev0, -__rev1, (float64x2_t) {__p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vfmsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+  float32x4_t __ret;
+  __ret = vfmaq_f32(__p0, -__p1, (float32x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vfmsq_n_f32(float32x4_t __p0, float32x4_t __p1, float32_t __p2) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vfmaq_f32(__rev0, -__rev1, (float32x4_t) {__p2, __p2, __p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vfms_n_f64(float64x1_t __p0, float64x1_t __p1, float64_t __p2) {
+  float64x1_t __ret;
+  __ret = vfma_f64(__p0, -__p1, (float64x1_t) {__p2});
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vfms_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+  float32x2_t __ret;
+  __ret = vfma_f32(__p0, -__p1, (float32x2_t) {__p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vfms_n_f32(float32x2_t __p0, float32x2_t __p1, float32_t __p2) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vfma_f32(__rev0, -__rev1, (float32x2_t) {__p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x1_t vget_high_p64(poly64x2_t __p0) {
+  poly64x1_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x1_t vget_high_p64(poly64x2_t __p0) {
+  poly64x1_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t __noswap_vget_high_p64(poly64x2_t __p0) {
+  poly64x1_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x1_t vget_high_f64(float64x2_t __p0) {
+  float64x1_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x1_t vget_high_f64(float64x2_t __p0) {
+  float64x1_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 1);
+  return __ret;
+}
+#endif
+
+#define vget_lane_p64(__p0, __p1) __extension__ ({ \
+  poly64_t __ret; \
+  poly64x1_t __s0 = __p0; \
+  __ret = (poly64_t) __builtin_neon_vget_lane_i64((poly64x1_t)__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_p64(__p0, __p1) __extension__ ({ \
+  poly64_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  __ret = (poly64_t) __builtin_neon_vgetq_lane_i64((poly64x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_p64(__p0, __p1) __extension__ ({ \
+  poly64_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (poly64_t) __builtin_neon_vgetq_lane_i64((poly64x2_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_p64(__p0, __p1) __extension__ ({ \
+  poly64_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  __ret = (poly64_t) __builtin_neon_vgetq_lane_i64((poly64x2_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_f64(__p0, __p1) __extension__ ({ \
+  float64_t __ret; \
+  float64x2_t __s0 = __p0; \
+  __ret = (float64_t) __builtin_neon_vgetq_lane_f64((float64x2_t)__s0, __p1); \
+  __ret; \
+})
+#else
+#define vgetq_lane_f64(__p0, __p1) __extension__ ({ \
+  float64_t __ret; \
+  float64x2_t __s0 = __p0; \
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  __ret = (float64_t) __builtin_neon_vgetq_lane_f64((float64x2_t)__rev0, __p1); \
+  __ret; \
+})
+#define __noswap_vgetq_lane_f64(__p0, __p1) __extension__ ({ \
+  float64_t __ret; \
+  float64x2_t __s0 = __p0; \
+  __ret = (float64_t) __builtin_neon_vgetq_lane_f64((float64x2_t)__s0, __p1); \
+  __ret; \
+})
+#endif
+
+#define vget_lane_f64(__p0, __p1) __extension__ ({ \
+  float64_t __ret; \
+  float64x1_t __s0 = __p0; \
+  __ret = (float64_t) __builtin_neon_vget_lane_f64((float64x1_t)__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x1_t vget_low_p64(poly64x2_t __p0) {
+  poly64x1_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x1_t vget_low_p64(poly64x2_t __p0) {
+  poly64x1_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x1_t vget_low_f64(float64x2_t __p0) {
+  float64x1_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x1_t vget_low_f64(float64x2_t __p0) {
+  float64x1_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev0, 0);
+  return __ret;
+}
+#endif
+
+#define vld1_p64(__p0) __extension__ ({ \
+  poly64x1_t __ret; \
+  __ret = (poly64x1_t) __builtin_neon_vld1_v(__p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p64(__p0) __extension__ ({ \
+  poly64x2_t __ret; \
+  __ret = (poly64x2_t) __builtin_neon_vld1q_v(__p0, 38); \
+  __ret; \
+})
+#else
+#define vld1q_p64(__p0) __extension__ ({ \
+  poly64x2_t __ret; \
+  __ret = (poly64x2_t) __builtin_neon_vld1q_v(__p0, 38); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f64(__p0) __extension__ ({ \
+  float64x2_t __ret; \
+  __ret = (float64x2_t) __builtin_neon_vld1q_v(__p0, 42); \
+  __ret; \
+})
+#else
+#define vld1q_f64(__p0) __extension__ ({ \
+  float64x2_t __ret; \
+  __ret = (float64x2_t) __builtin_neon_vld1q_v(__p0, 42); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_f64(__p0) __extension__ ({ \
+  float64x1_t __ret; \
+  __ret = (float64x1_t) __builtin_neon_vld1_v(__p0, 10); \
+  __ret; \
+})
+#define vld1_dup_p64(__p0) __extension__ ({ \
+  poly64x1_t __ret; \
+  __ret = (poly64x1_t) __builtin_neon_vld1_dup_v(__p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_p64(__p0) __extension__ ({ \
+  poly64x2_t __ret; \
+  __ret = (poly64x2_t) __builtin_neon_vld1q_dup_v(__p0, 38); \
+  __ret; \
+})
+#else
+#define vld1q_dup_p64(__p0) __extension__ ({ \
+  poly64x2_t __ret; \
+  __ret = (poly64x2_t) __builtin_neon_vld1q_dup_v(__p0, 38); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_dup_f64(__p0) __extension__ ({ \
+  float64x2_t __ret; \
+  __ret = (float64x2_t) __builtin_neon_vld1q_dup_v(__p0, 42); \
+  __ret; \
+})
+#else
+#define vld1q_dup_f64(__p0) __extension__ ({ \
+  float64x2_t __ret; \
+  __ret = (float64x2_t) __builtin_neon_vld1q_dup_v(__p0, 42); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_dup_f64(__p0) __extension__ ({ \
+  float64x1_t __ret; \
+  __ret = (float64x1_t) __builtin_neon_vld1_dup_v(__p0, 10); \
+  __ret; \
+})
+#define vld1_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1_t __ret; \
+  poly64x1_t __s1 = __p1; \
+  __ret = (poly64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s1 = __p1; \
+  __ret = (poly64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 38); \
+  __ret; \
+})
+#else
+#define vld1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s1 = __p1; \
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (poly64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 38); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s1 = __p1; \
+  __ret = (float64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__s1, __p2, 42); \
+  __ret; \
+})
+#else
+#define vld1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (float64x2_t) __builtin_neon_vld1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 42); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s1 = __p1; \
+  __ret = (float64x1_t) __builtin_neon_vld1_lane_v(__p0, (int8x8_t)__s1, __p2, 10); \
+  __ret; \
+})
+#define vld1_p64_x2(__p0) __extension__ ({ \
+  poly64x1x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p64_x2(__p0) __extension__ ({ \
+  poly64x2x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 38); \
+  __ret; \
+})
+#else
+#define vld1q_p64_x2(__p0) __extension__ ({ \
+  poly64x2x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f64_x2(__p0) __extension__ ({ \
+  float64x2x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 42); \
+  __ret; \
+})
+#else
+#define vld1q_f64_x2(__p0) __extension__ ({ \
+  float64x2x2_t __ret; \
+  __builtin_neon_vld1q_x2_v(&__ret, __p0, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_f64_x2(__p0) __extension__ ({ \
+  float64x1x2_t __ret; \
+  __builtin_neon_vld1_x2_v(&__ret, __p0, 10); \
+  __ret; \
+})
+#define vld1_p64_x3(__p0) __extension__ ({ \
+  poly64x1x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p64_x3(__p0) __extension__ ({ \
+  poly64x2x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 38); \
+  __ret; \
+})
+#else
+#define vld1q_p64_x3(__p0) __extension__ ({ \
+  poly64x2x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f64_x3(__p0) __extension__ ({ \
+  float64x2x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 42); \
+  __ret; \
+})
+#else
+#define vld1q_f64_x3(__p0) __extension__ ({ \
+  float64x2x3_t __ret; \
+  __builtin_neon_vld1q_x3_v(&__ret, __p0, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_f64_x3(__p0) __extension__ ({ \
+  float64x1x3_t __ret; \
+  __builtin_neon_vld1_x3_v(&__ret, __p0, 10); \
+  __ret; \
+})
+#define vld1_p64_x4(__p0) __extension__ ({ \
+  poly64x1x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_p64_x4(__p0) __extension__ ({ \
+  poly64x2x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 38); \
+  __ret; \
+})
+#else
+#define vld1q_p64_x4(__p0) __extension__ ({ \
+  poly64x2x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld1q_f64_x4(__p0) __extension__ ({ \
+  float64x2x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 42); \
+  __ret; \
+})
+#else
+#define vld1q_f64_x4(__p0) __extension__ ({ \
+  float64x2x4_t __ret; \
+  __builtin_neon_vld1q_x4_v(&__ret, __p0, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld1_f64_x4(__p0) __extension__ ({ \
+  float64x1x4_t __ret; \
+  __builtin_neon_vld1_x4_v(&__ret, __p0, 10); \
+  __ret; \
+})
+#define vld2_p64(__p0) __extension__ ({ \
+  poly64x1x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_p64(__p0) __extension__ ({ \
+  poly64x2x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 38); \
+  __ret; \
+})
+#else
+#define vld2q_p64(__p0) __extension__ ({ \
+  poly64x2x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_u64(__p0) __extension__ ({ \
+  uint64x2x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 51); \
+  __ret; \
+})
+#else
+#define vld2q_u64(__p0) __extension__ ({ \
+  uint64x2x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_f64(__p0) __extension__ ({ \
+  float64x2x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 42); \
+  __ret; \
+})
+#else
+#define vld2q_f64(__p0) __extension__ ({ \
+  float64x2x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_s64(__p0) __extension__ ({ \
+  int64x2x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 35); \
+  __ret; \
+})
+#else
+#define vld2q_s64(__p0) __extension__ ({ \
+  int64x2x2_t __ret; \
+  __builtin_neon_vld2q_v(&__ret, __p0, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld2_f64(__p0) __extension__ ({ \
+  float64x1x2_t __ret; \
+  __builtin_neon_vld2_v(&__ret, __p0, 10); \
+  __ret; \
+})
+#define vld2_dup_p64(__p0) __extension__ ({ \
+  poly64x1x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_p64(__p0) __extension__ ({ \
+  poly64x2x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 38); \
+  __ret; \
+})
+#else
+#define vld2q_dup_p64(__p0) __extension__ ({ \
+  poly64x2x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_dup_f64(__p0) __extension__ ({ \
+  float64x2x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 42); \
+  __ret; \
+})
+#else
+#define vld2q_dup_f64(__p0) __extension__ ({ \
+  float64x2x2_t __ret; \
+  __builtin_neon_vld2q_dup_v(&__ret, __p0, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld2_dup_f64(__p0) __extension__ ({ \
+  float64x1x2_t __ret; \
+  __builtin_neon_vld2_dup_v(&__ret, __p0, 10); \
+  __ret; \
+})
+#define vld2_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1x2_t __ret; \
+  poly64x1x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x2_t __ret; \
+  poly8x16x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 36); \
+  __ret; \
+})
+#else
+#define vld2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x2_t __ret; \
+  poly8x16x2_t __s1 = __p1; \
+  poly8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x2_t __ret; \
+  poly64x2x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 38); \
+  __ret; \
+})
+#else
+#define vld2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x2_t __ret; \
+  poly64x2x2_t __s1 = __p1; \
+  poly64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x2_t __ret; \
+  uint8x16x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 48); \
+  __ret; \
+})
+#else
+#define vld2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x2_t __ret; \
+  uint8x16x2_t __s1 = __p1; \
+  uint8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x2_t __ret; \
+  uint64x2x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 51); \
+  __ret; \
+})
+#else
+#define vld2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x2_t __ret; \
+  uint64x2x2_t __s1 = __p1; \
+  uint64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x2_t __ret; \
+  int8x16x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 32); \
+  __ret; \
+})
+#else
+#define vld2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x2_t __ret; \
+  int8x16x2_t __s1 = __p1; \
+  int8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x2_t __ret; \
+  float64x2x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 42); \
+  __ret; \
+})
+#else
+#define vld2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x2_t __ret; \
+  float64x2x2_t __s1 = __p1; \
+  float64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x2_t __ret; \
+  int64x2x2_t __s1 = __p1; \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 35); \
+  __ret; \
+})
+#else
+#define vld2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x2_t __ret; \
+  int64x2x2_t __s1 = __p1; \
+  int64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vld2q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld2_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1x2_t __ret; \
+  uint64x1x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 19); \
+  __ret; \
+})
+#define vld2_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1x2_t __ret; \
+  float64x1x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 10); \
+  __ret; \
+})
+#define vld2_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1x2_t __ret; \
+  int64x1x2_t __s1 = __p1; \
+  __builtin_neon_vld2_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 3); \
+  __ret; \
+})
+#define vld3_p64(__p0) __extension__ ({ \
+  poly64x1x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_p64(__p0) __extension__ ({ \
+  poly64x2x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 38); \
+  __ret; \
+})
+#else
+#define vld3q_p64(__p0) __extension__ ({ \
+  poly64x2x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_u64(__p0) __extension__ ({ \
+  uint64x2x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 51); \
+  __ret; \
+})
+#else
+#define vld3q_u64(__p0) __extension__ ({ \
+  uint64x2x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_f64(__p0) __extension__ ({ \
+  float64x2x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 42); \
+  __ret; \
+})
+#else
+#define vld3q_f64(__p0) __extension__ ({ \
+  float64x2x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_s64(__p0) __extension__ ({ \
+  int64x2x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 35); \
+  __ret; \
+})
+#else
+#define vld3q_s64(__p0) __extension__ ({ \
+  int64x2x3_t __ret; \
+  __builtin_neon_vld3q_v(&__ret, __p0, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld3_f64(__p0) __extension__ ({ \
+  float64x1x3_t __ret; \
+  __builtin_neon_vld3_v(&__ret, __p0, 10); \
+  __ret; \
+})
+#define vld3_dup_p64(__p0) __extension__ ({ \
+  poly64x1x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_p64(__p0) __extension__ ({ \
+  poly64x2x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 38); \
+  __ret; \
+})
+#else
+#define vld3q_dup_p64(__p0) __extension__ ({ \
+  poly64x2x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_dup_f64(__p0) __extension__ ({ \
+  float64x2x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 42); \
+  __ret; \
+})
+#else
+#define vld3q_dup_f64(__p0) __extension__ ({ \
+  float64x2x3_t __ret; \
+  __builtin_neon_vld3q_dup_v(&__ret, __p0, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld3_dup_f64(__p0) __extension__ ({ \
+  float64x1x3_t __ret; \
+  __builtin_neon_vld3_dup_v(&__ret, __p0, 10); \
+  __ret; \
+})
+#define vld3_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1x3_t __ret; \
+  poly64x1x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x3_t __ret; \
+  poly8x16x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 36); \
+  __ret; \
+})
+#else
+#define vld3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x3_t __ret; \
+  poly8x16x3_t __s1 = __p1; \
+  poly8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x3_t __ret; \
+  poly64x2x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 38); \
+  __ret; \
+})
+#else
+#define vld3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x3_t __ret; \
+  poly64x2x3_t __s1 = __p1; \
+  poly64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x3_t __ret; \
+  uint8x16x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 48); \
+  __ret; \
+})
+#else
+#define vld3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x3_t __ret; \
+  uint8x16x3_t __s1 = __p1; \
+  uint8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x3_t __ret; \
+  uint64x2x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 51); \
+  __ret; \
+})
+#else
+#define vld3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x3_t __ret; \
+  uint64x2x3_t __s1 = __p1; \
+  uint64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x3_t __ret; \
+  int8x16x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 32); \
+  __ret; \
+})
+#else
+#define vld3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x3_t __ret; \
+  int8x16x3_t __s1 = __p1; \
+  int8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x3_t __ret; \
+  float64x2x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 42); \
+  __ret; \
+})
+#else
+#define vld3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x3_t __ret; \
+  float64x2x3_t __s1 = __p1; \
+  float64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x3_t __ret; \
+  int64x2x3_t __s1 = __p1; \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 35); \
+  __ret; \
+})
+#else
+#define vld3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x3_t __ret; \
+  int64x2x3_t __s1 = __p1; \
+  int64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vld3q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld3_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1x3_t __ret; \
+  uint64x1x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 19); \
+  __ret; \
+})
+#define vld3_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1x3_t __ret; \
+  float64x1x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 10); \
+  __ret; \
+})
+#define vld3_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1x3_t __ret; \
+  int64x1x3_t __s1 = __p1; \
+  __builtin_neon_vld3_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 3); \
+  __ret; \
+})
+#define vld4_p64(__p0) __extension__ ({ \
+  poly64x1x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_p64(__p0) __extension__ ({ \
+  poly64x2x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 38); \
+  __ret; \
+})
+#else
+#define vld4q_p64(__p0) __extension__ ({ \
+  poly64x2x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_u64(__p0) __extension__ ({ \
+  uint64x2x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 51); \
+  __ret; \
+})
+#else
+#define vld4q_u64(__p0) __extension__ ({ \
+  uint64x2x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_f64(__p0) __extension__ ({ \
+  float64x2x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 42); \
+  __ret; \
+})
+#else
+#define vld4q_f64(__p0) __extension__ ({ \
+  float64x2x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_s64(__p0) __extension__ ({ \
+  int64x2x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 35); \
+  __ret; \
+})
+#else
+#define vld4q_s64(__p0) __extension__ ({ \
+  int64x2x4_t __ret; \
+  __builtin_neon_vld4q_v(&__ret, __p0, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld4_f64(__p0) __extension__ ({ \
+  float64x1x4_t __ret; \
+  __builtin_neon_vld4_v(&__ret, __p0, 10); \
+  __ret; \
+})
+#define vld4_dup_p64(__p0) __extension__ ({ \
+  poly64x1x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_p64(__p0) __extension__ ({ \
+  poly64x2x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 38); \
+  __ret; \
+})
+#else
+#define vld4q_dup_p64(__p0) __extension__ ({ \
+  poly64x2x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_dup_f64(__p0) __extension__ ({ \
+  float64x2x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 42); \
+  __ret; \
+})
+#else
+#define vld4q_dup_f64(__p0) __extension__ ({ \
+  float64x2x4_t __ret; \
+  __builtin_neon_vld4q_dup_v(&__ret, __p0, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld4_dup_f64(__p0) __extension__ ({ \
+  float64x1x4_t __ret; \
+  __builtin_neon_vld4_dup_v(&__ret, __p0, 10); \
+  __ret; \
+})
+#define vld4_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1x4_t __ret; \
+  poly64x1x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x4_t __ret; \
+  poly8x16x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 36); \
+  __ret; \
+})
+#else
+#define vld4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x4_t __ret; \
+  poly8x16x4_t __s1 = __p1; \
+  poly8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 36); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x4_t __ret; \
+  poly64x2x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 38); \
+  __ret; \
+})
+#else
+#define vld4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x4_t __ret; \
+  poly64x2x4_t __s1 = __p1; \
+  poly64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 38); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x4_t __ret; \
+  uint8x16x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 48); \
+  __ret; \
+})
+#else
+#define vld4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x4_t __ret; \
+  uint8x16x4_t __s1 = __p1; \
+  uint8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 48); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x4_t __ret; \
+  uint64x2x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 51); \
+  __ret; \
+})
+#else
+#define vld4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x4_t __ret; \
+  uint64x2x4_t __s1 = __p1; \
+  uint64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 51); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x4_t __ret; \
+  int8x16x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 32); \
+  __ret; \
+})
+#else
+#define vld4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x4_t __ret; \
+  int8x16x4_t __s1 = __p1; \
+  int8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 32); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x4_t __ret; \
+  float64x2x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 42); \
+  __ret; \
+})
+#else
+#define vld4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x4_t __ret; \
+  float64x2x4_t __s1 = __p1; \
+  float64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 42); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vld4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x4_t __ret; \
+  int64x2x4_t __s1 = __p1; \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 35); \
+  __ret; \
+})
+#else
+#define vld4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x4_t __ret; \
+  int64x2x4_t __s1 = __p1; \
+  int64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vld4q_lane_v(&__ret, __p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 35); \
+ \
+  __ret.val[0] = __builtin_shufflevector(__ret.val[0], __ret.val[0], 1, 0); \
+  __ret.val[1] = __builtin_shufflevector(__ret.val[1], __ret.val[1], 1, 0); \
+  __ret.val[2] = __builtin_shufflevector(__ret.val[2], __ret.val[2], 1, 0); \
+  __ret.val[3] = __builtin_shufflevector(__ret.val[3], __ret.val[3], 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vld4_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1x4_t __ret; \
+  uint64x1x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 19); \
+  __ret; \
+})
+#define vld4_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1x4_t __ret; \
+  float64x1x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 10); \
+  __ret; \
+})
+#define vld4_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1x4_t __ret; \
+  int64x1x4_t __s1 = __p1; \
+  __builtin_neon_vld4_lane_v(&__ret, __p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 3); \
+  __ret; \
+})
+#define vldrq_p128(__p0) __extension__ ({ \
+  poly128_t __ret; \
+  __ret = (poly128_t) __builtin_neon_vldrq_p128(__p0); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vmax_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vmax_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vmaxnmvq_f64(float64x2_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vmaxnmvq_f64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vmaxnmvq_f64(float64x2_t __p0) {
+  float64_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64_t) __builtin_neon_vmaxnmvq_f64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vmaxnmvq_f32(float32x4_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vmaxnmvq_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vmaxnmvq_f32(float32x4_t __p0) {
+  float32_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32_t) __builtin_neon_vmaxnmvq_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vmaxnmv_f32(float32x2_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vmaxnmv_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vmaxnmv_f32(float32x2_t __p0) {
+  float32_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32_t) __builtin_neon_vmaxnmv_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8_t vmaxvq_u8(uint8x16_t __p0) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vmaxvq_u8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8_t vmaxvq_u8(uint8x16_t __p0) {
+  uint8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8_t) __builtin_neon_vmaxvq_u8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32_t vmaxvq_u32(uint32x4_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vmaxvq_u32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32_t vmaxvq_u32(uint32x4_t __p0) {
+  uint32_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32_t) __builtin_neon_vmaxvq_u32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16_t vmaxvq_u16(uint16x8_t __p0) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vmaxvq_u16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16_t vmaxvq_u16(uint16x8_t __p0) {
+  uint16_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16_t) __builtin_neon_vmaxvq_u16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8_t vmaxvq_s8(int8x16_t __p0) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vmaxvq_s8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8_t vmaxvq_s8(int8x16_t __p0) {
+  int8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8_t) __builtin_neon_vmaxvq_s8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vmaxvq_f64(float64x2_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vmaxvq_f64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vmaxvq_f64(float64x2_t __p0) {
+  float64_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64_t) __builtin_neon_vmaxvq_f64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vmaxvq_f32(float32x4_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vmaxvq_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vmaxvq_f32(float32x4_t __p0) {
+  float32_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32_t) __builtin_neon_vmaxvq_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32_t vmaxvq_s32(int32x4_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vmaxvq_s32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32_t vmaxvq_s32(int32x4_t __p0) {
+  int32_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32_t) __builtin_neon_vmaxvq_s32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16_t vmaxvq_s16(int16x8_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vmaxvq_s16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16_t vmaxvq_s16(int16x8_t __p0) {
+  int16_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16_t) __builtin_neon_vmaxvq_s16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8_t vmaxv_u8(uint8x8_t __p0) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vmaxv_u8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8_t vmaxv_u8(uint8x8_t __p0) {
+  uint8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8_t) __builtin_neon_vmaxv_u8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32_t vmaxv_u32(uint32x2_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vmaxv_u32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32_t vmaxv_u32(uint32x2_t __p0) {
+  uint32_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32_t) __builtin_neon_vmaxv_u32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16_t vmaxv_u16(uint16x4_t __p0) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vmaxv_u16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16_t vmaxv_u16(uint16x4_t __p0) {
+  uint16_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16_t) __builtin_neon_vmaxv_u16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8_t vmaxv_s8(int8x8_t __p0) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vmaxv_s8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8_t vmaxv_s8(int8x8_t __p0) {
+  int8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8_t) __builtin_neon_vmaxv_s8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vmaxv_f32(float32x2_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vmaxv_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vmaxv_f32(float32x2_t __p0) {
+  float32_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32_t) __builtin_neon_vmaxv_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32_t vmaxv_s32(int32x2_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vmaxv_s32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32_t vmaxv_s32(int32x2_t __p0) {
+  int32_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32_t) __builtin_neon_vmaxv_s32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16_t vmaxv_s16(int16x4_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vmaxv_s16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16_t vmaxv_s16(int16x4_t __p0) {
+  int16_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16_t) __builtin_neon_vmaxv_s16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vminq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vminq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vminq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vmin_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vmin_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vminnmvq_f64(float64x2_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vminnmvq_f64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vminnmvq_f64(float64x2_t __p0) {
+  float64_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64_t) __builtin_neon_vminnmvq_f64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vminnmvq_f32(float32x4_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vminnmvq_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vminnmvq_f32(float32x4_t __p0) {
+  float32_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32_t) __builtin_neon_vminnmvq_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vminnmv_f32(float32x2_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vminnmv_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vminnmv_f32(float32x2_t __p0) {
+  float32_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32_t) __builtin_neon_vminnmv_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8_t vminvq_u8(uint8x16_t __p0) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vminvq_u8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8_t vminvq_u8(uint8x16_t __p0) {
+  uint8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8_t) __builtin_neon_vminvq_u8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32_t vminvq_u32(uint32x4_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vminvq_u32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32_t vminvq_u32(uint32x4_t __p0) {
+  uint32_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint32_t) __builtin_neon_vminvq_u32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16_t vminvq_u16(uint16x8_t __p0) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vminvq_u16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16_t vminvq_u16(uint16x8_t __p0) {
+  uint16_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16_t) __builtin_neon_vminvq_u16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8_t vminvq_s8(int8x16_t __p0) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vminvq_s8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8_t vminvq_s8(int8x16_t __p0) {
+  int8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8_t) __builtin_neon_vminvq_s8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vminvq_f64(float64x2_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vminvq_f64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vminvq_f64(float64x2_t __p0) {
+  float64_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64_t) __builtin_neon_vminvq_f64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vminvq_f32(float32x4_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vminvq_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vminvq_f32(float32x4_t __p0) {
+  float32_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32_t) __builtin_neon_vminvq_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32_t vminvq_s32(int32x4_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vminvq_s32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32_t vminvq_s32(int32x4_t __p0) {
+  int32_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int32_t) __builtin_neon_vminvq_s32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16_t vminvq_s16(int16x8_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vminvq_s16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16_t vminvq_s16(int16x8_t __p0) {
+  int16_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16_t) __builtin_neon_vminvq_s16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8_t vminv_u8(uint8x8_t __p0) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vminv_u8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8_t vminv_u8(uint8x8_t __p0) {
+  uint8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8_t) __builtin_neon_vminv_u8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32_t vminv_u32(uint32x2_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vminv_u32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32_t vminv_u32(uint32x2_t __p0) {
+  uint32_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint32_t) __builtin_neon_vminv_u32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16_t vminv_u16(uint16x4_t __p0) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vminv_u16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16_t vminv_u16(uint16x4_t __p0) {
+  uint16_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (uint16_t) __builtin_neon_vminv_u16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8_t vminv_s8(int8x8_t __p0) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vminv_s8(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8_t vminv_s8(int8x8_t __p0) {
+  int8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8_t) __builtin_neon_vminv_s8(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vminv_f32(float32x2_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vminv_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vminv_f32(float32x2_t __p0) {
+  float32_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32_t) __builtin_neon_vminv_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32_t vminv_s32(int32x2_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vminv_s32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32_t vminv_s32(int32x2_t __p0) {
+  int32_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int32_t) __builtin_neon_vminv_s32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16_t vminv_s16(int16x4_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vminv_s16(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16_t vminv_s16(int16x4_t __p0) {
+  int16_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (int16_t) __builtin_neon_vminv_s16(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 + __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vmla_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+  float64x1_t __ret;
+  __ret = __p0 + __p1 * __p2;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_laneq_u32(__p0_448, __p1_448, __p2_448, __p3_448) __extension__ ({ \
+  uint32x4_t __ret_448; \
+  uint32x4_t __s0_448 = __p0_448; \
+  uint32x4_t __s1_448 = __p1_448; \
+  uint32x4_t __s2_448 = __p2_448; \
+  __ret_448 = __s0_448 + __s1_448 * splatq_laneq_u32(__s2_448, __p3_448); \
+  __ret_448; \
+})
+#else
+#define vmlaq_laneq_u32(__p0_449, __p1_449, __p2_449, __p3_449) __extension__ ({ \
+  uint32x4_t __ret_449; \
+  uint32x4_t __s0_449 = __p0_449; \
+  uint32x4_t __s1_449 = __p1_449; \
+  uint32x4_t __s2_449 = __p2_449; \
+  uint32x4_t __rev0_449;  __rev0_449 = __builtin_shufflevector(__s0_449, __s0_449, 3, 2, 1, 0); \
+  uint32x4_t __rev1_449;  __rev1_449 = __builtin_shufflevector(__s1_449, __s1_449, 3, 2, 1, 0); \
+  uint32x4_t __rev2_449;  __rev2_449 = __builtin_shufflevector(__s2_449, __s2_449, 3, 2, 1, 0); \
+  __ret_449 = __rev0_449 + __rev1_449 * __noswap_splatq_laneq_u32(__rev2_449, __p3_449); \
+  __ret_449 = __builtin_shufflevector(__ret_449, __ret_449, 3, 2, 1, 0); \
+  __ret_449; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_laneq_u16(__p0_450, __p1_450, __p2_450, __p3_450) __extension__ ({ \
+  uint16x8_t __ret_450; \
+  uint16x8_t __s0_450 = __p0_450; \
+  uint16x8_t __s1_450 = __p1_450; \
+  uint16x8_t __s2_450 = __p2_450; \
+  __ret_450 = __s0_450 + __s1_450 * splatq_laneq_u16(__s2_450, __p3_450); \
+  __ret_450; \
+})
+#else
+#define vmlaq_laneq_u16(__p0_451, __p1_451, __p2_451, __p3_451) __extension__ ({ \
+  uint16x8_t __ret_451; \
+  uint16x8_t __s0_451 = __p0_451; \
+  uint16x8_t __s1_451 = __p1_451; \
+  uint16x8_t __s2_451 = __p2_451; \
+  uint16x8_t __rev0_451;  __rev0_451 = __builtin_shufflevector(__s0_451, __s0_451, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1_451;  __rev1_451 = __builtin_shufflevector(__s1_451, __s1_451, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev2_451;  __rev2_451 = __builtin_shufflevector(__s2_451, __s2_451, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_451 = __rev0_451 + __rev1_451 * __noswap_splatq_laneq_u16(__rev2_451, __p3_451); \
+  __ret_451 = __builtin_shufflevector(__ret_451, __ret_451, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_451; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_laneq_f32(__p0_452, __p1_452, __p2_452, __p3_452) __extension__ ({ \
+  float32x4_t __ret_452; \
+  float32x4_t __s0_452 = __p0_452; \
+  float32x4_t __s1_452 = __p1_452; \
+  float32x4_t __s2_452 = __p2_452; \
+  __ret_452 = __s0_452 + __s1_452 * splatq_laneq_f32(__s2_452, __p3_452); \
+  __ret_452; \
+})
+#else
+#define vmlaq_laneq_f32(__p0_453, __p1_453, __p2_453, __p3_453) __extension__ ({ \
+  float32x4_t __ret_453; \
+  float32x4_t __s0_453 = __p0_453; \
+  float32x4_t __s1_453 = __p1_453; \
+  float32x4_t __s2_453 = __p2_453; \
+  float32x4_t __rev0_453;  __rev0_453 = __builtin_shufflevector(__s0_453, __s0_453, 3, 2, 1, 0); \
+  float32x4_t __rev1_453;  __rev1_453 = __builtin_shufflevector(__s1_453, __s1_453, 3, 2, 1, 0); \
+  float32x4_t __rev2_453;  __rev2_453 = __builtin_shufflevector(__s2_453, __s2_453, 3, 2, 1, 0); \
+  __ret_453 = __rev0_453 + __rev1_453 * __noswap_splatq_laneq_f32(__rev2_453, __p3_453); \
+  __ret_453 = __builtin_shufflevector(__ret_453, __ret_453, 3, 2, 1, 0); \
+  __ret_453; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_laneq_s32(__p0_454, __p1_454, __p2_454, __p3_454) __extension__ ({ \
+  int32x4_t __ret_454; \
+  int32x4_t __s0_454 = __p0_454; \
+  int32x4_t __s1_454 = __p1_454; \
+  int32x4_t __s2_454 = __p2_454; \
+  __ret_454 = __s0_454 + __s1_454 * splatq_laneq_s32(__s2_454, __p3_454); \
+  __ret_454; \
+})
+#else
+#define vmlaq_laneq_s32(__p0_455, __p1_455, __p2_455, __p3_455) __extension__ ({ \
+  int32x4_t __ret_455; \
+  int32x4_t __s0_455 = __p0_455; \
+  int32x4_t __s1_455 = __p1_455; \
+  int32x4_t __s2_455 = __p2_455; \
+  int32x4_t __rev0_455;  __rev0_455 = __builtin_shufflevector(__s0_455, __s0_455, 3, 2, 1, 0); \
+  int32x4_t __rev1_455;  __rev1_455 = __builtin_shufflevector(__s1_455, __s1_455, 3, 2, 1, 0); \
+  int32x4_t __rev2_455;  __rev2_455 = __builtin_shufflevector(__s2_455, __s2_455, 3, 2, 1, 0); \
+  __ret_455 = __rev0_455 + __rev1_455 * __noswap_splatq_laneq_s32(__rev2_455, __p3_455); \
+  __ret_455 = __builtin_shufflevector(__ret_455, __ret_455, 3, 2, 1, 0); \
+  __ret_455; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlaq_laneq_s16(__p0_456, __p1_456, __p2_456, __p3_456) __extension__ ({ \
+  int16x8_t __ret_456; \
+  int16x8_t __s0_456 = __p0_456; \
+  int16x8_t __s1_456 = __p1_456; \
+  int16x8_t __s2_456 = __p2_456; \
+  __ret_456 = __s0_456 + __s1_456 * splatq_laneq_s16(__s2_456, __p3_456); \
+  __ret_456; \
+})
+#else
+#define vmlaq_laneq_s16(__p0_457, __p1_457, __p2_457, __p3_457) __extension__ ({ \
+  int16x8_t __ret_457; \
+  int16x8_t __s0_457 = __p0_457; \
+  int16x8_t __s1_457 = __p1_457; \
+  int16x8_t __s2_457 = __p2_457; \
+  int16x8_t __rev0_457;  __rev0_457 = __builtin_shufflevector(__s0_457, __s0_457, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_457;  __rev1_457 = __builtin_shufflevector(__s1_457, __s1_457, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev2_457;  __rev2_457 = __builtin_shufflevector(__s2_457, __s2_457, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_457 = __rev0_457 + __rev1_457 * __noswap_splatq_laneq_s16(__rev2_457, __p3_457); \
+  __ret_457 = __builtin_shufflevector(__ret_457, __ret_457, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_457; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_laneq_u32(__p0_458, __p1_458, __p2_458, __p3_458) __extension__ ({ \
+  uint32x2_t __ret_458; \
+  uint32x2_t __s0_458 = __p0_458; \
+  uint32x2_t __s1_458 = __p1_458; \
+  uint32x4_t __s2_458 = __p2_458; \
+  __ret_458 = __s0_458 + __s1_458 * splat_laneq_u32(__s2_458, __p3_458); \
+  __ret_458; \
+})
+#else
+#define vmla_laneq_u32(__p0_459, __p1_459, __p2_459, __p3_459) __extension__ ({ \
+  uint32x2_t __ret_459; \
+  uint32x2_t __s0_459 = __p0_459; \
+  uint32x2_t __s1_459 = __p1_459; \
+  uint32x4_t __s2_459 = __p2_459; \
+  uint32x2_t __rev0_459;  __rev0_459 = __builtin_shufflevector(__s0_459, __s0_459, 1, 0); \
+  uint32x2_t __rev1_459;  __rev1_459 = __builtin_shufflevector(__s1_459, __s1_459, 1, 0); \
+  uint32x4_t __rev2_459;  __rev2_459 = __builtin_shufflevector(__s2_459, __s2_459, 3, 2, 1, 0); \
+  __ret_459 = __rev0_459 + __rev1_459 * __noswap_splat_laneq_u32(__rev2_459, __p3_459); \
+  __ret_459 = __builtin_shufflevector(__ret_459, __ret_459, 1, 0); \
+  __ret_459; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_laneq_u16(__p0_460, __p1_460, __p2_460, __p3_460) __extension__ ({ \
+  uint16x4_t __ret_460; \
+  uint16x4_t __s0_460 = __p0_460; \
+  uint16x4_t __s1_460 = __p1_460; \
+  uint16x8_t __s2_460 = __p2_460; \
+  __ret_460 = __s0_460 + __s1_460 * splat_laneq_u16(__s2_460, __p3_460); \
+  __ret_460; \
+})
+#else
+#define vmla_laneq_u16(__p0_461, __p1_461, __p2_461, __p3_461) __extension__ ({ \
+  uint16x4_t __ret_461; \
+  uint16x4_t __s0_461 = __p0_461; \
+  uint16x4_t __s1_461 = __p1_461; \
+  uint16x8_t __s2_461 = __p2_461; \
+  uint16x4_t __rev0_461;  __rev0_461 = __builtin_shufflevector(__s0_461, __s0_461, 3, 2, 1, 0); \
+  uint16x4_t __rev1_461;  __rev1_461 = __builtin_shufflevector(__s1_461, __s1_461, 3, 2, 1, 0); \
+  uint16x8_t __rev2_461;  __rev2_461 = __builtin_shufflevector(__s2_461, __s2_461, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_461 = __rev0_461 + __rev1_461 * __noswap_splat_laneq_u16(__rev2_461, __p3_461); \
+  __ret_461 = __builtin_shufflevector(__ret_461, __ret_461, 3, 2, 1, 0); \
+  __ret_461; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_laneq_f32(__p0_462, __p1_462, __p2_462, __p3_462) __extension__ ({ \
+  float32x2_t __ret_462; \
+  float32x2_t __s0_462 = __p0_462; \
+  float32x2_t __s1_462 = __p1_462; \
+  float32x4_t __s2_462 = __p2_462; \
+  __ret_462 = __s0_462 + __s1_462 * splat_laneq_f32(__s2_462, __p3_462); \
+  __ret_462; \
+})
+#else
+#define vmla_laneq_f32(__p0_463, __p1_463, __p2_463, __p3_463) __extension__ ({ \
+  float32x2_t __ret_463; \
+  float32x2_t __s0_463 = __p0_463; \
+  float32x2_t __s1_463 = __p1_463; \
+  float32x4_t __s2_463 = __p2_463; \
+  float32x2_t __rev0_463;  __rev0_463 = __builtin_shufflevector(__s0_463, __s0_463, 1, 0); \
+  float32x2_t __rev1_463;  __rev1_463 = __builtin_shufflevector(__s1_463, __s1_463, 1, 0); \
+  float32x4_t __rev2_463;  __rev2_463 = __builtin_shufflevector(__s2_463, __s2_463, 3, 2, 1, 0); \
+  __ret_463 = __rev0_463 + __rev1_463 * __noswap_splat_laneq_f32(__rev2_463, __p3_463); \
+  __ret_463 = __builtin_shufflevector(__ret_463, __ret_463, 1, 0); \
+  __ret_463; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_laneq_s32(__p0_464, __p1_464, __p2_464, __p3_464) __extension__ ({ \
+  int32x2_t __ret_464; \
+  int32x2_t __s0_464 = __p0_464; \
+  int32x2_t __s1_464 = __p1_464; \
+  int32x4_t __s2_464 = __p2_464; \
+  __ret_464 = __s0_464 + __s1_464 * splat_laneq_s32(__s2_464, __p3_464); \
+  __ret_464; \
+})
+#else
+#define vmla_laneq_s32(__p0_465, __p1_465, __p2_465, __p3_465) __extension__ ({ \
+  int32x2_t __ret_465; \
+  int32x2_t __s0_465 = __p0_465; \
+  int32x2_t __s1_465 = __p1_465; \
+  int32x4_t __s2_465 = __p2_465; \
+  int32x2_t __rev0_465;  __rev0_465 = __builtin_shufflevector(__s0_465, __s0_465, 1, 0); \
+  int32x2_t __rev1_465;  __rev1_465 = __builtin_shufflevector(__s1_465, __s1_465, 1, 0); \
+  int32x4_t __rev2_465;  __rev2_465 = __builtin_shufflevector(__s2_465, __s2_465, 3, 2, 1, 0); \
+  __ret_465 = __rev0_465 + __rev1_465 * __noswap_splat_laneq_s32(__rev2_465, __p3_465); \
+  __ret_465 = __builtin_shufflevector(__ret_465, __ret_465, 1, 0); \
+  __ret_465; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmla_laneq_s16(__p0_466, __p1_466, __p2_466, __p3_466) __extension__ ({ \
+  int16x4_t __ret_466; \
+  int16x4_t __s0_466 = __p0_466; \
+  int16x4_t __s1_466 = __p1_466; \
+  int16x8_t __s2_466 = __p2_466; \
+  __ret_466 = __s0_466 + __s1_466 * splat_laneq_s16(__s2_466, __p3_466); \
+  __ret_466; \
+})
+#else
+#define vmla_laneq_s16(__p0_467, __p1_467, __p2_467, __p3_467) __extension__ ({ \
+  int16x4_t __ret_467; \
+  int16x4_t __s0_467 = __p0_467; \
+  int16x4_t __s1_467 = __p1_467; \
+  int16x8_t __s2_467 = __p2_467; \
+  int16x4_t __rev0_467;  __rev0_467 = __builtin_shufflevector(__s0_467, __s0_467, 3, 2, 1, 0); \
+  int16x4_t __rev1_467;  __rev1_467 = __builtin_shufflevector(__s1_467, __s1_467, 3, 2, 1, 0); \
+  int16x8_t __rev2_467;  __rev2_467 = __builtin_shufflevector(__s2_467, __s2_467, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_467 = __rev0_467 + __rev1_467 * __noswap_splat_laneq_s16(__rev2_467, __p3_467); \
+  __ret_467 = __builtin_shufflevector(__ret_467, __ret_467, 3, 2, 1, 0); \
+  __ret_467; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_high_lane_u32(__p0_468, __p1_468, __p2_468, __p3_468) __extension__ ({ \
+  uint64x2_t __ret_468; \
+  uint64x2_t __s0_468 = __p0_468; \
+  uint32x4_t __s1_468 = __p1_468; \
+  uint32x2_t __s2_468 = __p2_468; \
+  __ret_468 = __s0_468 + vmull_u32(vget_high_u32(__s1_468), splat_lane_u32(__s2_468, __p3_468)); \
+  __ret_468; \
+})
+#else
+#define vmlal_high_lane_u32(__p0_469, __p1_469, __p2_469, __p3_469) __extension__ ({ \
+  uint64x2_t __ret_469; \
+  uint64x2_t __s0_469 = __p0_469; \
+  uint32x4_t __s1_469 = __p1_469; \
+  uint32x2_t __s2_469 = __p2_469; \
+  uint64x2_t __rev0_469;  __rev0_469 = __builtin_shufflevector(__s0_469, __s0_469, 1, 0); \
+  uint32x4_t __rev1_469;  __rev1_469 = __builtin_shufflevector(__s1_469, __s1_469, 3, 2, 1, 0); \
+  uint32x2_t __rev2_469;  __rev2_469 = __builtin_shufflevector(__s2_469, __s2_469, 1, 0); \
+  __ret_469 = __rev0_469 + __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_469), __noswap_splat_lane_u32(__rev2_469, __p3_469)); \
+  __ret_469 = __builtin_shufflevector(__ret_469, __ret_469, 1, 0); \
+  __ret_469; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_high_lane_u16(__p0_470, __p1_470, __p2_470, __p3_470) __extension__ ({ \
+  uint32x4_t __ret_470; \
+  uint32x4_t __s0_470 = __p0_470; \
+  uint16x8_t __s1_470 = __p1_470; \
+  uint16x4_t __s2_470 = __p2_470; \
+  __ret_470 = __s0_470 + vmull_u16(vget_high_u16(__s1_470), splat_lane_u16(__s2_470, __p3_470)); \
+  __ret_470; \
+})
+#else
+#define vmlal_high_lane_u16(__p0_471, __p1_471, __p2_471, __p3_471) __extension__ ({ \
+  uint32x4_t __ret_471; \
+  uint32x4_t __s0_471 = __p0_471; \
+  uint16x8_t __s1_471 = __p1_471; \
+  uint16x4_t __s2_471 = __p2_471; \
+  uint32x4_t __rev0_471;  __rev0_471 = __builtin_shufflevector(__s0_471, __s0_471, 3, 2, 1, 0); \
+  uint16x8_t __rev1_471;  __rev1_471 = __builtin_shufflevector(__s1_471, __s1_471, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x4_t __rev2_471;  __rev2_471 = __builtin_shufflevector(__s2_471, __s2_471, 3, 2, 1, 0); \
+  __ret_471 = __rev0_471 + __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_471), __noswap_splat_lane_u16(__rev2_471, __p3_471)); \
+  __ret_471 = __builtin_shufflevector(__ret_471, __ret_471, 3, 2, 1, 0); \
+  __ret_471; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_high_lane_s32(__p0_472, __p1_472, __p2_472, __p3_472) __extension__ ({ \
+  int64x2_t __ret_472; \
+  int64x2_t __s0_472 = __p0_472; \
+  int32x4_t __s1_472 = __p1_472; \
+  int32x2_t __s2_472 = __p2_472; \
+  __ret_472 = __s0_472 + vmull_s32(vget_high_s32(__s1_472), splat_lane_s32(__s2_472, __p3_472)); \
+  __ret_472; \
+})
+#else
+#define vmlal_high_lane_s32(__p0_473, __p1_473, __p2_473, __p3_473) __extension__ ({ \
+  int64x2_t __ret_473; \
+  int64x2_t __s0_473 = __p0_473; \
+  int32x4_t __s1_473 = __p1_473; \
+  int32x2_t __s2_473 = __p2_473; \
+  int64x2_t __rev0_473;  __rev0_473 = __builtin_shufflevector(__s0_473, __s0_473, 1, 0); \
+  int32x4_t __rev1_473;  __rev1_473 = __builtin_shufflevector(__s1_473, __s1_473, 3, 2, 1, 0); \
+  int32x2_t __rev2_473;  __rev2_473 = __builtin_shufflevector(__s2_473, __s2_473, 1, 0); \
+  __ret_473 = __rev0_473 + __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_473), __noswap_splat_lane_s32(__rev2_473, __p3_473)); \
+  __ret_473 = __builtin_shufflevector(__ret_473, __ret_473, 1, 0); \
+  __ret_473; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_high_lane_s16(__p0_474, __p1_474, __p2_474, __p3_474) __extension__ ({ \
+  int32x4_t __ret_474; \
+  int32x4_t __s0_474 = __p0_474; \
+  int16x8_t __s1_474 = __p1_474; \
+  int16x4_t __s2_474 = __p2_474; \
+  __ret_474 = __s0_474 + vmull_s16(vget_high_s16(__s1_474), splat_lane_s16(__s2_474, __p3_474)); \
+  __ret_474; \
+})
+#else
+#define vmlal_high_lane_s16(__p0_475, __p1_475, __p2_475, __p3_475) __extension__ ({ \
+  int32x4_t __ret_475; \
+  int32x4_t __s0_475 = __p0_475; \
+  int16x8_t __s1_475 = __p1_475; \
+  int16x4_t __s2_475 = __p2_475; \
+  int32x4_t __rev0_475;  __rev0_475 = __builtin_shufflevector(__s0_475, __s0_475, 3, 2, 1, 0); \
+  int16x8_t __rev1_475;  __rev1_475 = __builtin_shufflevector(__s1_475, __s1_475, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev2_475;  __rev2_475 = __builtin_shufflevector(__s2_475, __s2_475, 3, 2, 1, 0); \
+  __ret_475 = __rev0_475 + __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_475), __noswap_splat_lane_s16(__rev2_475, __p3_475)); \
+  __ret_475 = __builtin_shufflevector(__ret_475, __ret_475, 3, 2, 1, 0); \
+  __ret_475; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_high_laneq_u32(__p0_476, __p1_476, __p2_476, __p3_476) __extension__ ({ \
+  uint64x2_t __ret_476; \
+  uint64x2_t __s0_476 = __p0_476; \
+  uint32x4_t __s1_476 = __p1_476; \
+  uint32x4_t __s2_476 = __p2_476; \
+  __ret_476 = __s0_476 + vmull_u32(vget_high_u32(__s1_476), splat_laneq_u32(__s2_476, __p3_476)); \
+  __ret_476; \
+})
+#else
+#define vmlal_high_laneq_u32(__p0_477, __p1_477, __p2_477, __p3_477) __extension__ ({ \
+  uint64x2_t __ret_477; \
+  uint64x2_t __s0_477 = __p0_477; \
+  uint32x4_t __s1_477 = __p1_477; \
+  uint32x4_t __s2_477 = __p2_477; \
+  uint64x2_t __rev0_477;  __rev0_477 = __builtin_shufflevector(__s0_477, __s0_477, 1, 0); \
+  uint32x4_t __rev1_477;  __rev1_477 = __builtin_shufflevector(__s1_477, __s1_477, 3, 2, 1, 0); \
+  uint32x4_t __rev2_477;  __rev2_477 = __builtin_shufflevector(__s2_477, __s2_477, 3, 2, 1, 0); \
+  __ret_477 = __rev0_477 + __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_477), __noswap_splat_laneq_u32(__rev2_477, __p3_477)); \
+  __ret_477 = __builtin_shufflevector(__ret_477, __ret_477, 1, 0); \
+  __ret_477; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_high_laneq_u16(__p0_478, __p1_478, __p2_478, __p3_478) __extension__ ({ \
+  uint32x4_t __ret_478; \
+  uint32x4_t __s0_478 = __p0_478; \
+  uint16x8_t __s1_478 = __p1_478; \
+  uint16x8_t __s2_478 = __p2_478; \
+  __ret_478 = __s0_478 + vmull_u16(vget_high_u16(__s1_478), splat_laneq_u16(__s2_478, __p3_478)); \
+  __ret_478; \
+})
+#else
+#define vmlal_high_laneq_u16(__p0_479, __p1_479, __p2_479, __p3_479) __extension__ ({ \
+  uint32x4_t __ret_479; \
+  uint32x4_t __s0_479 = __p0_479; \
+  uint16x8_t __s1_479 = __p1_479; \
+  uint16x8_t __s2_479 = __p2_479; \
+  uint32x4_t __rev0_479;  __rev0_479 = __builtin_shufflevector(__s0_479, __s0_479, 3, 2, 1, 0); \
+  uint16x8_t __rev1_479;  __rev1_479 = __builtin_shufflevector(__s1_479, __s1_479, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev2_479;  __rev2_479 = __builtin_shufflevector(__s2_479, __s2_479, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_479 = __rev0_479 + __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_479), __noswap_splat_laneq_u16(__rev2_479, __p3_479)); \
+  __ret_479 = __builtin_shufflevector(__ret_479, __ret_479, 3, 2, 1, 0); \
+  __ret_479; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_high_laneq_s32(__p0_480, __p1_480, __p2_480, __p3_480) __extension__ ({ \
+  int64x2_t __ret_480; \
+  int64x2_t __s0_480 = __p0_480; \
+  int32x4_t __s1_480 = __p1_480; \
+  int32x4_t __s2_480 = __p2_480; \
+  __ret_480 = __s0_480 + vmull_s32(vget_high_s32(__s1_480), splat_laneq_s32(__s2_480, __p3_480)); \
+  __ret_480; \
+})
+#else
+#define vmlal_high_laneq_s32(__p0_481, __p1_481, __p2_481, __p3_481) __extension__ ({ \
+  int64x2_t __ret_481; \
+  int64x2_t __s0_481 = __p0_481; \
+  int32x4_t __s1_481 = __p1_481; \
+  int32x4_t __s2_481 = __p2_481; \
+  int64x2_t __rev0_481;  __rev0_481 = __builtin_shufflevector(__s0_481, __s0_481, 1, 0); \
+  int32x4_t __rev1_481;  __rev1_481 = __builtin_shufflevector(__s1_481, __s1_481, 3, 2, 1, 0); \
+  int32x4_t __rev2_481;  __rev2_481 = __builtin_shufflevector(__s2_481, __s2_481, 3, 2, 1, 0); \
+  __ret_481 = __rev0_481 + __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_481), __noswap_splat_laneq_s32(__rev2_481, __p3_481)); \
+  __ret_481 = __builtin_shufflevector(__ret_481, __ret_481, 1, 0); \
+  __ret_481; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_high_laneq_s16(__p0_482, __p1_482, __p2_482, __p3_482) __extension__ ({ \
+  int32x4_t __ret_482; \
+  int32x4_t __s0_482 = __p0_482; \
+  int16x8_t __s1_482 = __p1_482; \
+  int16x8_t __s2_482 = __p2_482; \
+  __ret_482 = __s0_482 + vmull_s16(vget_high_s16(__s1_482), splat_laneq_s16(__s2_482, __p3_482)); \
+  __ret_482; \
+})
+#else
+#define vmlal_high_laneq_s16(__p0_483, __p1_483, __p2_483, __p3_483) __extension__ ({ \
+  int32x4_t __ret_483; \
+  int32x4_t __s0_483 = __p0_483; \
+  int16x8_t __s1_483 = __p1_483; \
+  int16x8_t __s2_483 = __p2_483; \
+  int32x4_t __rev0_483;  __rev0_483 = __builtin_shufflevector(__s0_483, __s0_483, 3, 2, 1, 0); \
+  int16x8_t __rev1_483;  __rev1_483 = __builtin_shufflevector(__s1_483, __s1_483, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev2_483;  __rev2_483 = __builtin_shufflevector(__s2_483, __s2_483, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_483 = __rev0_483 + __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_483), __noswap_splat_laneq_s16(__rev2_483, __p3_483)); \
+  __ret_483 = __builtin_shufflevector(__ret_483, __ret_483, 3, 2, 1, 0); \
+  __ret_483; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_laneq_u32(__p0_484, __p1_484, __p2_484, __p3_484) __extension__ ({ \
+  uint64x2_t __ret_484; \
+  uint64x2_t __s0_484 = __p0_484; \
+  uint32x2_t __s1_484 = __p1_484; \
+  uint32x4_t __s2_484 = __p2_484; \
+  __ret_484 = __s0_484 + vmull_u32(__s1_484, splat_laneq_u32(__s2_484, __p3_484)); \
+  __ret_484; \
+})
+#else
+#define vmlal_laneq_u32(__p0_485, __p1_485, __p2_485, __p3_485) __extension__ ({ \
+  uint64x2_t __ret_485; \
+  uint64x2_t __s0_485 = __p0_485; \
+  uint32x2_t __s1_485 = __p1_485; \
+  uint32x4_t __s2_485 = __p2_485; \
+  uint64x2_t __rev0_485;  __rev0_485 = __builtin_shufflevector(__s0_485, __s0_485, 1, 0); \
+  uint32x2_t __rev1_485;  __rev1_485 = __builtin_shufflevector(__s1_485, __s1_485, 1, 0); \
+  uint32x4_t __rev2_485;  __rev2_485 = __builtin_shufflevector(__s2_485, __s2_485, 3, 2, 1, 0); \
+  __ret_485 = __rev0_485 + __noswap_vmull_u32(__rev1_485, __noswap_splat_laneq_u32(__rev2_485, __p3_485)); \
+  __ret_485 = __builtin_shufflevector(__ret_485, __ret_485, 1, 0); \
+  __ret_485; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_laneq_u16(__p0_486, __p1_486, __p2_486, __p3_486) __extension__ ({ \
+  uint32x4_t __ret_486; \
+  uint32x4_t __s0_486 = __p0_486; \
+  uint16x4_t __s1_486 = __p1_486; \
+  uint16x8_t __s2_486 = __p2_486; \
+  __ret_486 = __s0_486 + vmull_u16(__s1_486, splat_laneq_u16(__s2_486, __p3_486)); \
+  __ret_486; \
+})
+#else
+#define vmlal_laneq_u16(__p0_487, __p1_487, __p2_487, __p3_487) __extension__ ({ \
+  uint32x4_t __ret_487; \
+  uint32x4_t __s0_487 = __p0_487; \
+  uint16x4_t __s1_487 = __p1_487; \
+  uint16x8_t __s2_487 = __p2_487; \
+  uint32x4_t __rev0_487;  __rev0_487 = __builtin_shufflevector(__s0_487, __s0_487, 3, 2, 1, 0); \
+  uint16x4_t __rev1_487;  __rev1_487 = __builtin_shufflevector(__s1_487, __s1_487, 3, 2, 1, 0); \
+  uint16x8_t __rev2_487;  __rev2_487 = __builtin_shufflevector(__s2_487, __s2_487, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_487 = __rev0_487 + __noswap_vmull_u16(__rev1_487, __noswap_splat_laneq_u16(__rev2_487, __p3_487)); \
+  __ret_487 = __builtin_shufflevector(__ret_487, __ret_487, 3, 2, 1, 0); \
+  __ret_487; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_laneq_s32(__p0_488, __p1_488, __p2_488, __p3_488) __extension__ ({ \
+  int64x2_t __ret_488; \
+  int64x2_t __s0_488 = __p0_488; \
+  int32x2_t __s1_488 = __p1_488; \
+  int32x4_t __s2_488 = __p2_488; \
+  __ret_488 = __s0_488 + vmull_s32(__s1_488, splat_laneq_s32(__s2_488, __p3_488)); \
+  __ret_488; \
+})
+#else
+#define vmlal_laneq_s32(__p0_489, __p1_489, __p2_489, __p3_489) __extension__ ({ \
+  int64x2_t __ret_489; \
+  int64x2_t __s0_489 = __p0_489; \
+  int32x2_t __s1_489 = __p1_489; \
+  int32x4_t __s2_489 = __p2_489; \
+  int64x2_t __rev0_489;  __rev0_489 = __builtin_shufflevector(__s0_489, __s0_489, 1, 0); \
+  int32x2_t __rev1_489;  __rev1_489 = __builtin_shufflevector(__s1_489, __s1_489, 1, 0); \
+  int32x4_t __rev2_489;  __rev2_489 = __builtin_shufflevector(__s2_489, __s2_489, 3, 2, 1, 0); \
+  __ret_489 = __rev0_489 + __noswap_vmull_s32(__rev1_489, __noswap_splat_laneq_s32(__rev2_489, __p3_489)); \
+  __ret_489 = __builtin_shufflevector(__ret_489, __ret_489, 1, 0); \
+  __ret_489; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_laneq_s16(__p0_490, __p1_490, __p2_490, __p3_490) __extension__ ({ \
+  int32x4_t __ret_490; \
+  int32x4_t __s0_490 = __p0_490; \
+  int16x4_t __s1_490 = __p1_490; \
+  int16x8_t __s2_490 = __p2_490; \
+  __ret_490 = __s0_490 + vmull_s16(__s1_490, splat_laneq_s16(__s2_490, __p3_490)); \
+  __ret_490; \
+})
+#else
+#define vmlal_laneq_s16(__p0_491, __p1_491, __p2_491, __p3_491) __extension__ ({ \
+  int32x4_t __ret_491; \
+  int32x4_t __s0_491 = __p0_491; \
+  int16x4_t __s1_491 = __p1_491; \
+  int16x8_t __s2_491 = __p2_491; \
+  int32x4_t __rev0_491;  __rev0_491 = __builtin_shufflevector(__s0_491, __s0_491, 3, 2, 1, 0); \
+  int16x4_t __rev1_491;  __rev1_491 = __builtin_shufflevector(__s1_491, __s1_491, 3, 2, 1, 0); \
+  int16x8_t __rev2_491;  __rev2_491 = __builtin_shufflevector(__s2_491, __s2_491, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_491 = __rev0_491 + __noswap_vmull_s16(__rev1_491, __noswap_splat_laneq_s16(__rev2_491, __p3_491)); \
+  __ret_491 = __builtin_shufflevector(__ret_491, __ret_491, 3, 2, 1, 0); \
+  __ret_491; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vmlsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vmlsq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 - __rev1 * __rev2;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vmls_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+  float64x1_t __ret;
+  __ret = __p0 - __p1 * __p2;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_laneq_u32(__p0_492, __p1_492, __p2_492, __p3_492) __extension__ ({ \
+  uint32x4_t __ret_492; \
+  uint32x4_t __s0_492 = __p0_492; \
+  uint32x4_t __s1_492 = __p1_492; \
+  uint32x4_t __s2_492 = __p2_492; \
+  __ret_492 = __s0_492 - __s1_492 * splatq_laneq_u32(__s2_492, __p3_492); \
+  __ret_492; \
+})
+#else
+#define vmlsq_laneq_u32(__p0_493, __p1_493, __p2_493, __p3_493) __extension__ ({ \
+  uint32x4_t __ret_493; \
+  uint32x4_t __s0_493 = __p0_493; \
+  uint32x4_t __s1_493 = __p1_493; \
+  uint32x4_t __s2_493 = __p2_493; \
+  uint32x4_t __rev0_493;  __rev0_493 = __builtin_shufflevector(__s0_493, __s0_493, 3, 2, 1, 0); \
+  uint32x4_t __rev1_493;  __rev1_493 = __builtin_shufflevector(__s1_493, __s1_493, 3, 2, 1, 0); \
+  uint32x4_t __rev2_493;  __rev2_493 = __builtin_shufflevector(__s2_493, __s2_493, 3, 2, 1, 0); \
+  __ret_493 = __rev0_493 - __rev1_493 * __noswap_splatq_laneq_u32(__rev2_493, __p3_493); \
+  __ret_493 = __builtin_shufflevector(__ret_493, __ret_493, 3, 2, 1, 0); \
+  __ret_493; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_laneq_u16(__p0_494, __p1_494, __p2_494, __p3_494) __extension__ ({ \
+  uint16x8_t __ret_494; \
+  uint16x8_t __s0_494 = __p0_494; \
+  uint16x8_t __s1_494 = __p1_494; \
+  uint16x8_t __s2_494 = __p2_494; \
+  __ret_494 = __s0_494 - __s1_494 * splatq_laneq_u16(__s2_494, __p3_494); \
+  __ret_494; \
+})
+#else
+#define vmlsq_laneq_u16(__p0_495, __p1_495, __p2_495, __p3_495) __extension__ ({ \
+  uint16x8_t __ret_495; \
+  uint16x8_t __s0_495 = __p0_495; \
+  uint16x8_t __s1_495 = __p1_495; \
+  uint16x8_t __s2_495 = __p2_495; \
+  uint16x8_t __rev0_495;  __rev0_495 = __builtin_shufflevector(__s0_495, __s0_495, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1_495;  __rev1_495 = __builtin_shufflevector(__s1_495, __s1_495, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev2_495;  __rev2_495 = __builtin_shufflevector(__s2_495, __s2_495, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_495 = __rev0_495 - __rev1_495 * __noswap_splatq_laneq_u16(__rev2_495, __p3_495); \
+  __ret_495 = __builtin_shufflevector(__ret_495, __ret_495, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_495; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_laneq_f32(__p0_496, __p1_496, __p2_496, __p3_496) __extension__ ({ \
+  float32x4_t __ret_496; \
+  float32x4_t __s0_496 = __p0_496; \
+  float32x4_t __s1_496 = __p1_496; \
+  float32x4_t __s2_496 = __p2_496; \
+  __ret_496 = __s0_496 - __s1_496 * splatq_laneq_f32(__s2_496, __p3_496); \
+  __ret_496; \
+})
+#else
+#define vmlsq_laneq_f32(__p0_497, __p1_497, __p2_497, __p3_497) __extension__ ({ \
+  float32x4_t __ret_497; \
+  float32x4_t __s0_497 = __p0_497; \
+  float32x4_t __s1_497 = __p1_497; \
+  float32x4_t __s2_497 = __p2_497; \
+  float32x4_t __rev0_497;  __rev0_497 = __builtin_shufflevector(__s0_497, __s0_497, 3, 2, 1, 0); \
+  float32x4_t __rev1_497;  __rev1_497 = __builtin_shufflevector(__s1_497, __s1_497, 3, 2, 1, 0); \
+  float32x4_t __rev2_497;  __rev2_497 = __builtin_shufflevector(__s2_497, __s2_497, 3, 2, 1, 0); \
+  __ret_497 = __rev0_497 - __rev1_497 * __noswap_splatq_laneq_f32(__rev2_497, __p3_497); \
+  __ret_497 = __builtin_shufflevector(__ret_497, __ret_497, 3, 2, 1, 0); \
+  __ret_497; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_laneq_s32(__p0_498, __p1_498, __p2_498, __p3_498) __extension__ ({ \
+  int32x4_t __ret_498; \
+  int32x4_t __s0_498 = __p0_498; \
+  int32x4_t __s1_498 = __p1_498; \
+  int32x4_t __s2_498 = __p2_498; \
+  __ret_498 = __s0_498 - __s1_498 * splatq_laneq_s32(__s2_498, __p3_498); \
+  __ret_498; \
+})
+#else
+#define vmlsq_laneq_s32(__p0_499, __p1_499, __p2_499, __p3_499) __extension__ ({ \
+  int32x4_t __ret_499; \
+  int32x4_t __s0_499 = __p0_499; \
+  int32x4_t __s1_499 = __p1_499; \
+  int32x4_t __s2_499 = __p2_499; \
+  int32x4_t __rev0_499;  __rev0_499 = __builtin_shufflevector(__s0_499, __s0_499, 3, 2, 1, 0); \
+  int32x4_t __rev1_499;  __rev1_499 = __builtin_shufflevector(__s1_499, __s1_499, 3, 2, 1, 0); \
+  int32x4_t __rev2_499;  __rev2_499 = __builtin_shufflevector(__s2_499, __s2_499, 3, 2, 1, 0); \
+  __ret_499 = __rev0_499 - __rev1_499 * __noswap_splatq_laneq_s32(__rev2_499, __p3_499); \
+  __ret_499 = __builtin_shufflevector(__ret_499, __ret_499, 3, 2, 1, 0); \
+  __ret_499; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsq_laneq_s16(__p0_500, __p1_500, __p2_500, __p3_500) __extension__ ({ \
+  int16x8_t __ret_500; \
+  int16x8_t __s0_500 = __p0_500; \
+  int16x8_t __s1_500 = __p1_500; \
+  int16x8_t __s2_500 = __p2_500; \
+  __ret_500 = __s0_500 - __s1_500 * splatq_laneq_s16(__s2_500, __p3_500); \
+  __ret_500; \
+})
+#else
+#define vmlsq_laneq_s16(__p0_501, __p1_501, __p2_501, __p3_501) __extension__ ({ \
+  int16x8_t __ret_501; \
+  int16x8_t __s0_501 = __p0_501; \
+  int16x8_t __s1_501 = __p1_501; \
+  int16x8_t __s2_501 = __p2_501; \
+  int16x8_t __rev0_501;  __rev0_501 = __builtin_shufflevector(__s0_501, __s0_501, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_501;  __rev1_501 = __builtin_shufflevector(__s1_501, __s1_501, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev2_501;  __rev2_501 = __builtin_shufflevector(__s2_501, __s2_501, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_501 = __rev0_501 - __rev1_501 * __noswap_splatq_laneq_s16(__rev2_501, __p3_501); \
+  __ret_501 = __builtin_shufflevector(__ret_501, __ret_501, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_501; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_laneq_u32(__p0_502, __p1_502, __p2_502, __p3_502) __extension__ ({ \
+  uint32x2_t __ret_502; \
+  uint32x2_t __s0_502 = __p0_502; \
+  uint32x2_t __s1_502 = __p1_502; \
+  uint32x4_t __s2_502 = __p2_502; \
+  __ret_502 = __s0_502 - __s1_502 * splat_laneq_u32(__s2_502, __p3_502); \
+  __ret_502; \
+})
+#else
+#define vmls_laneq_u32(__p0_503, __p1_503, __p2_503, __p3_503) __extension__ ({ \
+  uint32x2_t __ret_503; \
+  uint32x2_t __s0_503 = __p0_503; \
+  uint32x2_t __s1_503 = __p1_503; \
+  uint32x4_t __s2_503 = __p2_503; \
+  uint32x2_t __rev0_503;  __rev0_503 = __builtin_shufflevector(__s0_503, __s0_503, 1, 0); \
+  uint32x2_t __rev1_503;  __rev1_503 = __builtin_shufflevector(__s1_503, __s1_503, 1, 0); \
+  uint32x4_t __rev2_503;  __rev2_503 = __builtin_shufflevector(__s2_503, __s2_503, 3, 2, 1, 0); \
+  __ret_503 = __rev0_503 - __rev1_503 * __noswap_splat_laneq_u32(__rev2_503, __p3_503); \
+  __ret_503 = __builtin_shufflevector(__ret_503, __ret_503, 1, 0); \
+  __ret_503; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_laneq_u16(__p0_504, __p1_504, __p2_504, __p3_504) __extension__ ({ \
+  uint16x4_t __ret_504; \
+  uint16x4_t __s0_504 = __p0_504; \
+  uint16x4_t __s1_504 = __p1_504; \
+  uint16x8_t __s2_504 = __p2_504; \
+  __ret_504 = __s0_504 - __s1_504 * splat_laneq_u16(__s2_504, __p3_504); \
+  __ret_504; \
+})
+#else
+#define vmls_laneq_u16(__p0_505, __p1_505, __p2_505, __p3_505) __extension__ ({ \
+  uint16x4_t __ret_505; \
+  uint16x4_t __s0_505 = __p0_505; \
+  uint16x4_t __s1_505 = __p1_505; \
+  uint16x8_t __s2_505 = __p2_505; \
+  uint16x4_t __rev0_505;  __rev0_505 = __builtin_shufflevector(__s0_505, __s0_505, 3, 2, 1, 0); \
+  uint16x4_t __rev1_505;  __rev1_505 = __builtin_shufflevector(__s1_505, __s1_505, 3, 2, 1, 0); \
+  uint16x8_t __rev2_505;  __rev2_505 = __builtin_shufflevector(__s2_505, __s2_505, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_505 = __rev0_505 - __rev1_505 * __noswap_splat_laneq_u16(__rev2_505, __p3_505); \
+  __ret_505 = __builtin_shufflevector(__ret_505, __ret_505, 3, 2, 1, 0); \
+  __ret_505; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_laneq_f32(__p0_506, __p1_506, __p2_506, __p3_506) __extension__ ({ \
+  float32x2_t __ret_506; \
+  float32x2_t __s0_506 = __p0_506; \
+  float32x2_t __s1_506 = __p1_506; \
+  float32x4_t __s2_506 = __p2_506; \
+  __ret_506 = __s0_506 - __s1_506 * splat_laneq_f32(__s2_506, __p3_506); \
+  __ret_506; \
+})
+#else
+#define vmls_laneq_f32(__p0_507, __p1_507, __p2_507, __p3_507) __extension__ ({ \
+  float32x2_t __ret_507; \
+  float32x2_t __s0_507 = __p0_507; \
+  float32x2_t __s1_507 = __p1_507; \
+  float32x4_t __s2_507 = __p2_507; \
+  float32x2_t __rev0_507;  __rev0_507 = __builtin_shufflevector(__s0_507, __s0_507, 1, 0); \
+  float32x2_t __rev1_507;  __rev1_507 = __builtin_shufflevector(__s1_507, __s1_507, 1, 0); \
+  float32x4_t __rev2_507;  __rev2_507 = __builtin_shufflevector(__s2_507, __s2_507, 3, 2, 1, 0); \
+  __ret_507 = __rev0_507 - __rev1_507 * __noswap_splat_laneq_f32(__rev2_507, __p3_507); \
+  __ret_507 = __builtin_shufflevector(__ret_507, __ret_507, 1, 0); \
+  __ret_507; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_laneq_s32(__p0_508, __p1_508, __p2_508, __p3_508) __extension__ ({ \
+  int32x2_t __ret_508; \
+  int32x2_t __s0_508 = __p0_508; \
+  int32x2_t __s1_508 = __p1_508; \
+  int32x4_t __s2_508 = __p2_508; \
+  __ret_508 = __s0_508 - __s1_508 * splat_laneq_s32(__s2_508, __p3_508); \
+  __ret_508; \
+})
+#else
+#define vmls_laneq_s32(__p0_509, __p1_509, __p2_509, __p3_509) __extension__ ({ \
+  int32x2_t __ret_509; \
+  int32x2_t __s0_509 = __p0_509; \
+  int32x2_t __s1_509 = __p1_509; \
+  int32x4_t __s2_509 = __p2_509; \
+  int32x2_t __rev0_509;  __rev0_509 = __builtin_shufflevector(__s0_509, __s0_509, 1, 0); \
+  int32x2_t __rev1_509;  __rev1_509 = __builtin_shufflevector(__s1_509, __s1_509, 1, 0); \
+  int32x4_t __rev2_509;  __rev2_509 = __builtin_shufflevector(__s2_509, __s2_509, 3, 2, 1, 0); \
+  __ret_509 = __rev0_509 - __rev1_509 * __noswap_splat_laneq_s32(__rev2_509, __p3_509); \
+  __ret_509 = __builtin_shufflevector(__ret_509, __ret_509, 1, 0); \
+  __ret_509; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmls_laneq_s16(__p0_510, __p1_510, __p2_510, __p3_510) __extension__ ({ \
+  int16x4_t __ret_510; \
+  int16x4_t __s0_510 = __p0_510; \
+  int16x4_t __s1_510 = __p1_510; \
+  int16x8_t __s2_510 = __p2_510; \
+  __ret_510 = __s0_510 - __s1_510 * splat_laneq_s16(__s2_510, __p3_510); \
+  __ret_510; \
+})
+#else
+#define vmls_laneq_s16(__p0_511, __p1_511, __p2_511, __p3_511) __extension__ ({ \
+  int16x4_t __ret_511; \
+  int16x4_t __s0_511 = __p0_511; \
+  int16x4_t __s1_511 = __p1_511; \
+  int16x8_t __s2_511 = __p2_511; \
+  int16x4_t __rev0_511;  __rev0_511 = __builtin_shufflevector(__s0_511, __s0_511, 3, 2, 1, 0); \
+  int16x4_t __rev1_511;  __rev1_511 = __builtin_shufflevector(__s1_511, __s1_511, 3, 2, 1, 0); \
+  int16x8_t __rev2_511;  __rev2_511 = __builtin_shufflevector(__s2_511, __s2_511, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_511 = __rev0_511 - __rev1_511 * __noswap_splat_laneq_s16(__rev2_511, __p3_511); \
+  __ret_511 = __builtin_shufflevector(__ret_511, __ret_511, 3, 2, 1, 0); \
+  __ret_511; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_high_lane_u32(__p0_512, __p1_512, __p2_512, __p3_512) __extension__ ({ \
+  uint64x2_t __ret_512; \
+  uint64x2_t __s0_512 = __p0_512; \
+  uint32x4_t __s1_512 = __p1_512; \
+  uint32x2_t __s2_512 = __p2_512; \
+  __ret_512 = __s0_512 - vmull_u32(vget_high_u32(__s1_512), splat_lane_u32(__s2_512, __p3_512)); \
+  __ret_512; \
+})
+#else
+#define vmlsl_high_lane_u32(__p0_513, __p1_513, __p2_513, __p3_513) __extension__ ({ \
+  uint64x2_t __ret_513; \
+  uint64x2_t __s0_513 = __p0_513; \
+  uint32x4_t __s1_513 = __p1_513; \
+  uint32x2_t __s2_513 = __p2_513; \
+  uint64x2_t __rev0_513;  __rev0_513 = __builtin_shufflevector(__s0_513, __s0_513, 1, 0); \
+  uint32x4_t __rev1_513;  __rev1_513 = __builtin_shufflevector(__s1_513, __s1_513, 3, 2, 1, 0); \
+  uint32x2_t __rev2_513;  __rev2_513 = __builtin_shufflevector(__s2_513, __s2_513, 1, 0); \
+  __ret_513 = __rev0_513 - __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_513), __noswap_splat_lane_u32(__rev2_513, __p3_513)); \
+  __ret_513 = __builtin_shufflevector(__ret_513, __ret_513, 1, 0); \
+  __ret_513; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_high_lane_u16(__p0_514, __p1_514, __p2_514, __p3_514) __extension__ ({ \
+  uint32x4_t __ret_514; \
+  uint32x4_t __s0_514 = __p0_514; \
+  uint16x8_t __s1_514 = __p1_514; \
+  uint16x4_t __s2_514 = __p2_514; \
+  __ret_514 = __s0_514 - vmull_u16(vget_high_u16(__s1_514), splat_lane_u16(__s2_514, __p3_514)); \
+  __ret_514; \
+})
+#else
+#define vmlsl_high_lane_u16(__p0_515, __p1_515, __p2_515, __p3_515) __extension__ ({ \
+  uint32x4_t __ret_515; \
+  uint32x4_t __s0_515 = __p0_515; \
+  uint16x8_t __s1_515 = __p1_515; \
+  uint16x4_t __s2_515 = __p2_515; \
+  uint32x4_t __rev0_515;  __rev0_515 = __builtin_shufflevector(__s0_515, __s0_515, 3, 2, 1, 0); \
+  uint16x8_t __rev1_515;  __rev1_515 = __builtin_shufflevector(__s1_515, __s1_515, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x4_t __rev2_515;  __rev2_515 = __builtin_shufflevector(__s2_515, __s2_515, 3, 2, 1, 0); \
+  __ret_515 = __rev0_515 - __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_515), __noswap_splat_lane_u16(__rev2_515, __p3_515)); \
+  __ret_515 = __builtin_shufflevector(__ret_515, __ret_515, 3, 2, 1, 0); \
+  __ret_515; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_high_lane_s32(__p0_516, __p1_516, __p2_516, __p3_516) __extension__ ({ \
+  int64x2_t __ret_516; \
+  int64x2_t __s0_516 = __p0_516; \
+  int32x4_t __s1_516 = __p1_516; \
+  int32x2_t __s2_516 = __p2_516; \
+  __ret_516 = __s0_516 - vmull_s32(vget_high_s32(__s1_516), splat_lane_s32(__s2_516, __p3_516)); \
+  __ret_516; \
+})
+#else
+#define vmlsl_high_lane_s32(__p0_517, __p1_517, __p2_517, __p3_517) __extension__ ({ \
+  int64x2_t __ret_517; \
+  int64x2_t __s0_517 = __p0_517; \
+  int32x4_t __s1_517 = __p1_517; \
+  int32x2_t __s2_517 = __p2_517; \
+  int64x2_t __rev0_517;  __rev0_517 = __builtin_shufflevector(__s0_517, __s0_517, 1, 0); \
+  int32x4_t __rev1_517;  __rev1_517 = __builtin_shufflevector(__s1_517, __s1_517, 3, 2, 1, 0); \
+  int32x2_t __rev2_517;  __rev2_517 = __builtin_shufflevector(__s2_517, __s2_517, 1, 0); \
+  __ret_517 = __rev0_517 - __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_517), __noswap_splat_lane_s32(__rev2_517, __p3_517)); \
+  __ret_517 = __builtin_shufflevector(__ret_517, __ret_517, 1, 0); \
+  __ret_517; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_high_lane_s16(__p0_518, __p1_518, __p2_518, __p3_518) __extension__ ({ \
+  int32x4_t __ret_518; \
+  int32x4_t __s0_518 = __p0_518; \
+  int16x8_t __s1_518 = __p1_518; \
+  int16x4_t __s2_518 = __p2_518; \
+  __ret_518 = __s0_518 - vmull_s16(vget_high_s16(__s1_518), splat_lane_s16(__s2_518, __p3_518)); \
+  __ret_518; \
+})
+#else
+#define vmlsl_high_lane_s16(__p0_519, __p1_519, __p2_519, __p3_519) __extension__ ({ \
+  int32x4_t __ret_519; \
+  int32x4_t __s0_519 = __p0_519; \
+  int16x8_t __s1_519 = __p1_519; \
+  int16x4_t __s2_519 = __p2_519; \
+  int32x4_t __rev0_519;  __rev0_519 = __builtin_shufflevector(__s0_519, __s0_519, 3, 2, 1, 0); \
+  int16x8_t __rev1_519;  __rev1_519 = __builtin_shufflevector(__s1_519, __s1_519, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev2_519;  __rev2_519 = __builtin_shufflevector(__s2_519, __s2_519, 3, 2, 1, 0); \
+  __ret_519 = __rev0_519 - __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_519), __noswap_splat_lane_s16(__rev2_519, __p3_519)); \
+  __ret_519 = __builtin_shufflevector(__ret_519, __ret_519, 3, 2, 1, 0); \
+  __ret_519; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_high_laneq_u32(__p0_520, __p1_520, __p2_520, __p3_520) __extension__ ({ \
+  uint64x2_t __ret_520; \
+  uint64x2_t __s0_520 = __p0_520; \
+  uint32x4_t __s1_520 = __p1_520; \
+  uint32x4_t __s2_520 = __p2_520; \
+  __ret_520 = __s0_520 - vmull_u32(vget_high_u32(__s1_520), splat_laneq_u32(__s2_520, __p3_520)); \
+  __ret_520; \
+})
+#else
+#define vmlsl_high_laneq_u32(__p0_521, __p1_521, __p2_521, __p3_521) __extension__ ({ \
+  uint64x2_t __ret_521; \
+  uint64x2_t __s0_521 = __p0_521; \
+  uint32x4_t __s1_521 = __p1_521; \
+  uint32x4_t __s2_521 = __p2_521; \
+  uint64x2_t __rev0_521;  __rev0_521 = __builtin_shufflevector(__s0_521, __s0_521, 1, 0); \
+  uint32x4_t __rev1_521;  __rev1_521 = __builtin_shufflevector(__s1_521, __s1_521, 3, 2, 1, 0); \
+  uint32x4_t __rev2_521;  __rev2_521 = __builtin_shufflevector(__s2_521, __s2_521, 3, 2, 1, 0); \
+  __ret_521 = __rev0_521 - __noswap_vmull_u32(__noswap_vget_high_u32(__rev1_521), __noswap_splat_laneq_u32(__rev2_521, __p3_521)); \
+  __ret_521 = __builtin_shufflevector(__ret_521, __ret_521, 1, 0); \
+  __ret_521; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_high_laneq_u16(__p0_522, __p1_522, __p2_522, __p3_522) __extension__ ({ \
+  uint32x4_t __ret_522; \
+  uint32x4_t __s0_522 = __p0_522; \
+  uint16x8_t __s1_522 = __p1_522; \
+  uint16x8_t __s2_522 = __p2_522; \
+  __ret_522 = __s0_522 - vmull_u16(vget_high_u16(__s1_522), splat_laneq_u16(__s2_522, __p3_522)); \
+  __ret_522; \
+})
+#else
+#define vmlsl_high_laneq_u16(__p0_523, __p1_523, __p2_523, __p3_523) __extension__ ({ \
+  uint32x4_t __ret_523; \
+  uint32x4_t __s0_523 = __p0_523; \
+  uint16x8_t __s1_523 = __p1_523; \
+  uint16x8_t __s2_523 = __p2_523; \
+  uint32x4_t __rev0_523;  __rev0_523 = __builtin_shufflevector(__s0_523, __s0_523, 3, 2, 1, 0); \
+  uint16x8_t __rev1_523;  __rev1_523 = __builtin_shufflevector(__s1_523, __s1_523, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev2_523;  __rev2_523 = __builtin_shufflevector(__s2_523, __s2_523, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_523 = __rev0_523 - __noswap_vmull_u16(__noswap_vget_high_u16(__rev1_523), __noswap_splat_laneq_u16(__rev2_523, __p3_523)); \
+  __ret_523 = __builtin_shufflevector(__ret_523, __ret_523, 3, 2, 1, 0); \
+  __ret_523; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_high_laneq_s32(__p0_524, __p1_524, __p2_524, __p3_524) __extension__ ({ \
+  int64x2_t __ret_524; \
+  int64x2_t __s0_524 = __p0_524; \
+  int32x4_t __s1_524 = __p1_524; \
+  int32x4_t __s2_524 = __p2_524; \
+  __ret_524 = __s0_524 - vmull_s32(vget_high_s32(__s1_524), splat_laneq_s32(__s2_524, __p3_524)); \
+  __ret_524; \
+})
+#else
+#define vmlsl_high_laneq_s32(__p0_525, __p1_525, __p2_525, __p3_525) __extension__ ({ \
+  int64x2_t __ret_525; \
+  int64x2_t __s0_525 = __p0_525; \
+  int32x4_t __s1_525 = __p1_525; \
+  int32x4_t __s2_525 = __p2_525; \
+  int64x2_t __rev0_525;  __rev0_525 = __builtin_shufflevector(__s0_525, __s0_525, 1, 0); \
+  int32x4_t __rev1_525;  __rev1_525 = __builtin_shufflevector(__s1_525, __s1_525, 3, 2, 1, 0); \
+  int32x4_t __rev2_525;  __rev2_525 = __builtin_shufflevector(__s2_525, __s2_525, 3, 2, 1, 0); \
+  __ret_525 = __rev0_525 - __noswap_vmull_s32(__noswap_vget_high_s32(__rev1_525), __noswap_splat_laneq_s32(__rev2_525, __p3_525)); \
+  __ret_525 = __builtin_shufflevector(__ret_525, __ret_525, 1, 0); \
+  __ret_525; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_high_laneq_s16(__p0_526, __p1_526, __p2_526, __p3_526) __extension__ ({ \
+  int32x4_t __ret_526; \
+  int32x4_t __s0_526 = __p0_526; \
+  int16x8_t __s1_526 = __p1_526; \
+  int16x8_t __s2_526 = __p2_526; \
+  __ret_526 = __s0_526 - vmull_s16(vget_high_s16(__s1_526), splat_laneq_s16(__s2_526, __p3_526)); \
+  __ret_526; \
+})
+#else
+#define vmlsl_high_laneq_s16(__p0_527, __p1_527, __p2_527, __p3_527) __extension__ ({ \
+  int32x4_t __ret_527; \
+  int32x4_t __s0_527 = __p0_527; \
+  int16x8_t __s1_527 = __p1_527; \
+  int16x8_t __s2_527 = __p2_527; \
+  int32x4_t __rev0_527;  __rev0_527 = __builtin_shufflevector(__s0_527, __s0_527, 3, 2, 1, 0); \
+  int16x8_t __rev1_527;  __rev1_527 = __builtin_shufflevector(__s1_527, __s1_527, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev2_527;  __rev2_527 = __builtin_shufflevector(__s2_527, __s2_527, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_527 = __rev0_527 - __noswap_vmull_s16(__noswap_vget_high_s16(__rev1_527), __noswap_splat_laneq_s16(__rev2_527, __p3_527)); \
+  __ret_527 = __builtin_shufflevector(__ret_527, __ret_527, 3, 2, 1, 0); \
+  __ret_527; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_laneq_u32(__p0_528, __p1_528, __p2_528, __p3_528) __extension__ ({ \
+  uint64x2_t __ret_528; \
+  uint64x2_t __s0_528 = __p0_528; \
+  uint32x2_t __s1_528 = __p1_528; \
+  uint32x4_t __s2_528 = __p2_528; \
+  __ret_528 = __s0_528 - vmull_u32(__s1_528, splat_laneq_u32(__s2_528, __p3_528)); \
+  __ret_528; \
+})
+#else
+#define vmlsl_laneq_u32(__p0_529, __p1_529, __p2_529, __p3_529) __extension__ ({ \
+  uint64x2_t __ret_529; \
+  uint64x2_t __s0_529 = __p0_529; \
+  uint32x2_t __s1_529 = __p1_529; \
+  uint32x4_t __s2_529 = __p2_529; \
+  uint64x2_t __rev0_529;  __rev0_529 = __builtin_shufflevector(__s0_529, __s0_529, 1, 0); \
+  uint32x2_t __rev1_529;  __rev1_529 = __builtin_shufflevector(__s1_529, __s1_529, 1, 0); \
+  uint32x4_t __rev2_529;  __rev2_529 = __builtin_shufflevector(__s2_529, __s2_529, 3, 2, 1, 0); \
+  __ret_529 = __rev0_529 - __noswap_vmull_u32(__rev1_529, __noswap_splat_laneq_u32(__rev2_529, __p3_529)); \
+  __ret_529 = __builtin_shufflevector(__ret_529, __ret_529, 1, 0); \
+  __ret_529; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_laneq_u16(__p0_530, __p1_530, __p2_530, __p3_530) __extension__ ({ \
+  uint32x4_t __ret_530; \
+  uint32x4_t __s0_530 = __p0_530; \
+  uint16x4_t __s1_530 = __p1_530; \
+  uint16x8_t __s2_530 = __p2_530; \
+  __ret_530 = __s0_530 - vmull_u16(__s1_530, splat_laneq_u16(__s2_530, __p3_530)); \
+  __ret_530; \
+})
+#else
+#define vmlsl_laneq_u16(__p0_531, __p1_531, __p2_531, __p3_531) __extension__ ({ \
+  uint32x4_t __ret_531; \
+  uint32x4_t __s0_531 = __p0_531; \
+  uint16x4_t __s1_531 = __p1_531; \
+  uint16x8_t __s2_531 = __p2_531; \
+  uint32x4_t __rev0_531;  __rev0_531 = __builtin_shufflevector(__s0_531, __s0_531, 3, 2, 1, 0); \
+  uint16x4_t __rev1_531;  __rev1_531 = __builtin_shufflevector(__s1_531, __s1_531, 3, 2, 1, 0); \
+  uint16x8_t __rev2_531;  __rev2_531 = __builtin_shufflevector(__s2_531, __s2_531, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_531 = __rev0_531 - __noswap_vmull_u16(__rev1_531, __noswap_splat_laneq_u16(__rev2_531, __p3_531)); \
+  __ret_531 = __builtin_shufflevector(__ret_531, __ret_531, 3, 2, 1, 0); \
+  __ret_531; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_laneq_s32(__p0_532, __p1_532, __p2_532, __p3_532) __extension__ ({ \
+  int64x2_t __ret_532; \
+  int64x2_t __s0_532 = __p0_532; \
+  int32x2_t __s1_532 = __p1_532; \
+  int32x4_t __s2_532 = __p2_532; \
+  __ret_532 = __s0_532 - vmull_s32(__s1_532, splat_laneq_s32(__s2_532, __p3_532)); \
+  __ret_532; \
+})
+#else
+#define vmlsl_laneq_s32(__p0_533, __p1_533, __p2_533, __p3_533) __extension__ ({ \
+  int64x2_t __ret_533; \
+  int64x2_t __s0_533 = __p0_533; \
+  int32x2_t __s1_533 = __p1_533; \
+  int32x4_t __s2_533 = __p2_533; \
+  int64x2_t __rev0_533;  __rev0_533 = __builtin_shufflevector(__s0_533, __s0_533, 1, 0); \
+  int32x2_t __rev1_533;  __rev1_533 = __builtin_shufflevector(__s1_533, __s1_533, 1, 0); \
+  int32x4_t __rev2_533;  __rev2_533 = __builtin_shufflevector(__s2_533, __s2_533, 3, 2, 1, 0); \
+  __ret_533 = __rev0_533 - __noswap_vmull_s32(__rev1_533, __noswap_splat_laneq_s32(__rev2_533, __p3_533)); \
+  __ret_533 = __builtin_shufflevector(__ret_533, __ret_533, 1, 0); \
+  __ret_533; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_laneq_s16(__p0_534, __p1_534, __p2_534, __p3_534) __extension__ ({ \
+  int32x4_t __ret_534; \
+  int32x4_t __s0_534 = __p0_534; \
+  int16x4_t __s1_534 = __p1_534; \
+  int16x8_t __s2_534 = __p2_534; \
+  __ret_534 = __s0_534 - vmull_s16(__s1_534, splat_laneq_s16(__s2_534, __p3_534)); \
+  __ret_534; \
+})
+#else
+#define vmlsl_laneq_s16(__p0_535, __p1_535, __p2_535, __p3_535) __extension__ ({ \
+  int32x4_t __ret_535; \
+  int32x4_t __s0_535 = __p0_535; \
+  int16x4_t __s1_535 = __p1_535; \
+  int16x8_t __s2_535 = __p2_535; \
+  int32x4_t __rev0_535;  __rev0_535 = __builtin_shufflevector(__s0_535, __s0_535, 3, 2, 1, 0); \
+  int16x4_t __rev1_535;  __rev1_535 = __builtin_shufflevector(__s1_535, __s1_535, 3, 2, 1, 0); \
+  int16x8_t __rev2_535;  __rev2_535 = __builtin_shufflevector(__s2_535, __s2_535, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_535 = __rev0_535 - __noswap_vmull_s16(__rev1_535, __noswap_splat_laneq_s16(__rev2_535, __p3_535)); \
+  __ret_535 = __builtin_shufflevector(__ret_535, __ret_535, 3, 2, 1, 0); \
+  __ret_535; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) poly64x1_t vmov_n_p64(poly64_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t) {__p0};
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vmovq_n_p64(poly64_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vmovq_n_p64(poly64_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vmovq_n_f64(float64_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) {__p0, __p0};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vmovq_n_f64(float64_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) {__p0, __p0};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vmov_n_f64(float64_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) {__p0};
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmovl_high_u8(uint8x16_t __p0_536) {
+  uint16x8_t __ret_536;
+  uint8x8_t __a1_536 = vget_high_u8(__p0_536);
+  __ret_536 = (uint16x8_t)(vshll_n_u8(__a1_536, 0));
+  return __ret_536;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmovl_high_u8(uint8x16_t __p0_537) {
+  uint16x8_t __ret_537;
+  uint8x16_t __rev0_537;  __rev0_537 = __builtin_shufflevector(__p0_537, __p0_537, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __a1_537 = __noswap_vget_high_u8(__rev0_537);
+  __ret_537 = (uint16x8_t)(__noswap_vshll_n_u8(__a1_537, 0));
+  __ret_537 = __builtin_shufflevector(__ret_537, __ret_537, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret_537;
+}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vmovl_high_u8(uint8x16_t __p0_538) {
+  uint16x8_t __ret_538;
+  uint8x8_t __a1_538 = __noswap_vget_high_u8(__p0_538);
+  __ret_538 = (uint16x8_t)(__noswap_vshll_n_u8(__a1_538, 0));
+  return __ret_538;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmovl_high_u32(uint32x4_t __p0_539) {
+  uint64x2_t __ret_539;
+  uint32x2_t __a1_539 = vget_high_u32(__p0_539);
+  __ret_539 = (uint64x2_t)(vshll_n_u32(__a1_539, 0));
+  return __ret_539;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmovl_high_u32(uint32x4_t __p0_540) {
+  uint64x2_t __ret_540;
+  uint32x4_t __rev0_540;  __rev0_540 = __builtin_shufflevector(__p0_540, __p0_540, 3, 2, 1, 0);
+  uint32x2_t __a1_540 = __noswap_vget_high_u32(__rev0_540);
+  __ret_540 = (uint64x2_t)(__noswap_vshll_n_u32(__a1_540, 0));
+  __ret_540 = __builtin_shufflevector(__ret_540, __ret_540, 1, 0);
+  return __ret_540;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmovl_high_u32(uint32x4_t __p0_541) {
+  uint64x2_t __ret_541;
+  uint32x2_t __a1_541 = __noswap_vget_high_u32(__p0_541);
+  __ret_541 = (uint64x2_t)(__noswap_vshll_n_u32(__a1_541, 0));
+  return __ret_541;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmovl_high_u16(uint16x8_t __p0_542) {
+  uint32x4_t __ret_542;
+  uint16x4_t __a1_542 = vget_high_u16(__p0_542);
+  __ret_542 = (uint32x4_t)(vshll_n_u16(__a1_542, 0));
+  return __ret_542;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmovl_high_u16(uint16x8_t __p0_543) {
+  uint32x4_t __ret_543;
+  uint16x8_t __rev0_543;  __rev0_543 = __builtin_shufflevector(__p0_543, __p0_543, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x4_t __a1_543 = __noswap_vget_high_u16(__rev0_543);
+  __ret_543 = (uint32x4_t)(__noswap_vshll_n_u16(__a1_543, 0));
+  __ret_543 = __builtin_shufflevector(__ret_543, __ret_543, 3, 2, 1, 0);
+  return __ret_543;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmovl_high_u16(uint16x8_t __p0_544) {
+  uint32x4_t __ret_544;
+  uint16x4_t __a1_544 = __noswap_vget_high_u16(__p0_544);
+  __ret_544 = (uint32x4_t)(__noswap_vshll_n_u16(__a1_544, 0));
+  return __ret_544;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmovl_high_s8(int8x16_t __p0_545) {
+  int16x8_t __ret_545;
+  int8x8_t __a1_545 = vget_high_s8(__p0_545);
+  __ret_545 = (int16x8_t)(vshll_n_s8(__a1_545, 0));
+  return __ret_545;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmovl_high_s8(int8x16_t __p0_546) {
+  int16x8_t __ret_546;
+  int8x16_t __rev0_546;  __rev0_546 = __builtin_shufflevector(__p0_546, __p0_546, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __a1_546 = __noswap_vget_high_s8(__rev0_546);
+  __ret_546 = (int16x8_t)(__noswap_vshll_n_s8(__a1_546, 0));
+  __ret_546 = __builtin_shufflevector(__ret_546, __ret_546, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret_546;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vmovl_high_s8(int8x16_t __p0_547) {
+  int16x8_t __ret_547;
+  int8x8_t __a1_547 = __noswap_vget_high_s8(__p0_547);
+  __ret_547 = (int16x8_t)(__noswap_vshll_n_s8(__a1_547, 0));
+  return __ret_547;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmovl_high_s32(int32x4_t __p0_548) {
+  int64x2_t __ret_548;
+  int32x2_t __a1_548 = vget_high_s32(__p0_548);
+  __ret_548 = (int64x2_t)(vshll_n_s32(__a1_548, 0));
+  return __ret_548;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmovl_high_s32(int32x4_t __p0_549) {
+  int64x2_t __ret_549;
+  int32x4_t __rev0_549;  __rev0_549 = __builtin_shufflevector(__p0_549, __p0_549, 3, 2, 1, 0);
+  int32x2_t __a1_549 = __noswap_vget_high_s32(__rev0_549);
+  __ret_549 = (int64x2_t)(__noswap_vshll_n_s32(__a1_549, 0));
+  __ret_549 = __builtin_shufflevector(__ret_549, __ret_549, 1, 0);
+  return __ret_549;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmovl_high_s32(int32x4_t __p0_550) {
+  int64x2_t __ret_550;
+  int32x2_t __a1_550 = __noswap_vget_high_s32(__p0_550);
+  __ret_550 = (int64x2_t)(__noswap_vshll_n_s32(__a1_550, 0));
+  return __ret_550;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmovl_high_s16(int16x8_t __p0_551) {
+  int32x4_t __ret_551;
+  int16x4_t __a1_551 = vget_high_s16(__p0_551);
+  __ret_551 = (int32x4_t)(vshll_n_s16(__a1_551, 0));
+  return __ret_551;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmovl_high_s16(int16x8_t __p0_552) {
+  int32x4_t __ret_552;
+  int16x8_t __rev0_552;  __rev0_552 = __builtin_shufflevector(__p0_552, __p0_552, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x4_t __a1_552 = __noswap_vget_high_s16(__rev0_552);
+  __ret_552 = (int32x4_t)(__noswap_vshll_n_s16(__a1_552, 0));
+  __ret_552 = __builtin_shufflevector(__ret_552, __ret_552, 3, 2, 1, 0);
+  return __ret_552;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmovl_high_s16(int16x8_t __p0_553) {
+  int32x4_t __ret_553;
+  int16x4_t __a1_553 = __noswap_vget_high_s16(__p0_553);
+  __ret_553 = (int32x4_t)(__noswap_vshll_n_s16(__a1_553, 0));
+  return __ret_553;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
+  uint16x8_t __ret;
+  __ret = vcombine_u16(__p0, vmovn_u32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
+  uint16x8_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u16(__rev0, __noswap_vmovn_u32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
+  uint32x4_t __ret;
+  __ret = vcombine_u32(__p0, vmovn_u64(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
+  uint32x4_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vcombine_u32(__rev0, __noswap_vmovn_u64(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
+  uint8x16_t __ret;
+  __ret = vcombine_u8(__p0, vmovn_u16(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
+  uint8x16_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u8(__rev0, __noswap_vmovn_u16(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
+  int16x8_t __ret;
+  __ret = vcombine_s16(__p0, vmovn_s32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
+  int16x8_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s16(__rev0, __noswap_vmovn_s32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
+  int32x4_t __ret;
+  __ret = vcombine_s32(__p0, vmovn_s64(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
+  int32x4_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vcombine_s32(__rev0, __noswap_vmovn_s64(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
+  int8x16_t __ret;
+  __ret = vcombine_s8(__p0, vmovn_s16(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
+  int8x16_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s8(__rev0, __noswap_vmovn_s16(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vmulq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vmulq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 * __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vmul_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = __p0 * __p1;
+  return __ret;
+}
+#define vmuld_lane_f64(__p0_554, __p1_554, __p2_554) __extension__ ({ \
+  float64_t __ret_554; \
+  float64_t __s0_554 = __p0_554; \
+  float64x1_t __s1_554 = __p1_554; \
+  __ret_554 = __s0_554 * vget_lane_f64(__s1_554, __p2_554); \
+  __ret_554; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vmuls_lane_f32(__p0_555, __p1_555, __p2_555) __extension__ ({ \
+  float32_t __ret_555; \
+  float32_t __s0_555 = __p0_555; \
+  float32x2_t __s1_555 = __p1_555; \
+  __ret_555 = __s0_555 * vget_lane_f32(__s1_555, __p2_555); \
+  __ret_555; \
+})
+#else
+#define vmuls_lane_f32(__p0_556, __p1_556, __p2_556) __extension__ ({ \
+  float32_t __ret_556; \
+  float32_t __s0_556 = __p0_556; \
+  float32x2_t __s1_556 = __p1_556; \
+  float32x2_t __rev1_556;  __rev1_556 = __builtin_shufflevector(__s1_556, __s1_556, 1, 0); \
+  __ret_556 = __s0_556 * __noswap_vget_lane_f32(__rev1_556, __p2_556); \
+  __ret_556; \
+})
+#endif
+
+#define vmul_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  float64x1_t __s1 = __p1; \
+  __ret = (float64x1_t) __builtin_neon_vmul_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 10); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_lane_f64(__p0_557, __p1_557, __p2_557) __extension__ ({ \
+  float64x2_t __ret_557; \
+  float64x2_t __s0_557 = __p0_557; \
+  float64x1_t __s1_557 = __p1_557; \
+  __ret_557 = __s0_557 * splatq_lane_f64(__s1_557, __p2_557); \
+  __ret_557; \
+})
+#else
+#define vmulq_lane_f64(__p0_558, __p1_558, __p2_558) __extension__ ({ \
+  float64x2_t __ret_558; \
+  float64x2_t __s0_558 = __p0_558; \
+  float64x1_t __s1_558 = __p1_558; \
+  float64x2_t __rev0_558;  __rev0_558 = __builtin_shufflevector(__s0_558, __s0_558, 1, 0); \
+  __ret_558 = __rev0_558 * __noswap_splatq_lane_f64(__s1_558, __p2_558); \
+  __ret_558 = __builtin_shufflevector(__ret_558, __ret_558, 1, 0); \
+  __ret_558; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmuld_laneq_f64(__p0_559, __p1_559, __p2_559) __extension__ ({ \
+  float64_t __ret_559; \
+  float64_t __s0_559 = __p0_559; \
+  float64x2_t __s1_559 = __p1_559; \
+  __ret_559 = __s0_559 * vgetq_lane_f64(__s1_559, __p2_559); \
+  __ret_559; \
+})
+#else
+#define vmuld_laneq_f64(__p0_560, __p1_560, __p2_560) __extension__ ({ \
+  float64_t __ret_560; \
+  float64_t __s0_560 = __p0_560; \
+  float64x2_t __s1_560 = __p1_560; \
+  float64x2_t __rev1_560;  __rev1_560 = __builtin_shufflevector(__s1_560, __s1_560, 1, 0); \
+  __ret_560 = __s0_560 * __noswap_vgetq_lane_f64(__rev1_560, __p2_560); \
+  __ret_560; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmuls_laneq_f32(__p0_561, __p1_561, __p2_561) __extension__ ({ \
+  float32_t __ret_561; \
+  float32_t __s0_561 = __p0_561; \
+  float32x4_t __s1_561 = __p1_561; \
+  __ret_561 = __s0_561 * vgetq_lane_f32(__s1_561, __p2_561); \
+  __ret_561; \
+})
+#else
+#define vmuls_laneq_f32(__p0_562, __p1_562, __p2_562) __extension__ ({ \
+  float32_t __ret_562; \
+  float32_t __s0_562 = __p0_562; \
+  float32x4_t __s1_562 = __p1_562; \
+  float32x4_t __rev1_562;  __rev1_562 = __builtin_shufflevector(__s1_562, __s1_562, 3, 2, 1, 0); \
+  __ret_562 = __s0_562 * __noswap_vgetq_lane_f32(__rev1_562, __p2_562); \
+  __ret_562; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_laneq_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  __ret = (float64x1_t) __builtin_neon_vmul_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 10); \
+  __ret; \
+})
+#else
+#define vmul_laneq_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (float64x1_t) __builtin_neon_vmul_laneq_v((int8x8_t)__s0, (int8x16_t)__rev1, __p2, 10); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_laneq_u32(__p0_563, __p1_563, __p2_563) __extension__ ({ \
+  uint32x4_t __ret_563; \
+  uint32x4_t __s0_563 = __p0_563; \
+  uint32x4_t __s1_563 = __p1_563; \
+  __ret_563 = __s0_563 * splatq_laneq_u32(__s1_563, __p2_563); \
+  __ret_563; \
+})
+#else
+#define vmulq_laneq_u32(__p0_564, __p1_564, __p2_564) __extension__ ({ \
+  uint32x4_t __ret_564; \
+  uint32x4_t __s0_564 = __p0_564; \
+  uint32x4_t __s1_564 = __p1_564; \
+  uint32x4_t __rev0_564;  __rev0_564 = __builtin_shufflevector(__s0_564, __s0_564, 3, 2, 1, 0); \
+  uint32x4_t __rev1_564;  __rev1_564 = __builtin_shufflevector(__s1_564, __s1_564, 3, 2, 1, 0); \
+  __ret_564 = __rev0_564 * __noswap_splatq_laneq_u32(__rev1_564, __p2_564); \
+  __ret_564 = __builtin_shufflevector(__ret_564, __ret_564, 3, 2, 1, 0); \
+  __ret_564; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_laneq_u16(__p0_565, __p1_565, __p2_565) __extension__ ({ \
+  uint16x8_t __ret_565; \
+  uint16x8_t __s0_565 = __p0_565; \
+  uint16x8_t __s1_565 = __p1_565; \
+  __ret_565 = __s0_565 * splatq_laneq_u16(__s1_565, __p2_565); \
+  __ret_565; \
+})
+#else
+#define vmulq_laneq_u16(__p0_566, __p1_566, __p2_566) __extension__ ({ \
+  uint16x8_t __ret_566; \
+  uint16x8_t __s0_566 = __p0_566; \
+  uint16x8_t __s1_566 = __p1_566; \
+  uint16x8_t __rev0_566;  __rev0_566 = __builtin_shufflevector(__s0_566, __s0_566, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1_566;  __rev1_566 = __builtin_shufflevector(__s1_566, __s1_566, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_566 = __rev0_566 * __noswap_splatq_laneq_u16(__rev1_566, __p2_566); \
+  __ret_566 = __builtin_shufflevector(__ret_566, __ret_566, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_566; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_laneq_f64(__p0_567, __p1_567, __p2_567) __extension__ ({ \
+  float64x2_t __ret_567; \
+  float64x2_t __s0_567 = __p0_567; \
+  float64x2_t __s1_567 = __p1_567; \
+  __ret_567 = __s0_567 * splatq_laneq_f64(__s1_567, __p2_567); \
+  __ret_567; \
+})
+#else
+#define vmulq_laneq_f64(__p0_568, __p1_568, __p2_568) __extension__ ({ \
+  float64x2_t __ret_568; \
+  float64x2_t __s0_568 = __p0_568; \
+  float64x2_t __s1_568 = __p1_568; \
+  float64x2_t __rev0_568;  __rev0_568 = __builtin_shufflevector(__s0_568, __s0_568, 1, 0); \
+  float64x2_t __rev1_568;  __rev1_568 = __builtin_shufflevector(__s1_568, __s1_568, 1, 0); \
+  __ret_568 = __rev0_568 * __noswap_splatq_laneq_f64(__rev1_568, __p2_568); \
+  __ret_568 = __builtin_shufflevector(__ret_568, __ret_568, 1, 0); \
+  __ret_568; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_laneq_f32(__p0_569, __p1_569, __p2_569) __extension__ ({ \
+  float32x4_t __ret_569; \
+  float32x4_t __s0_569 = __p0_569; \
+  float32x4_t __s1_569 = __p1_569; \
+  __ret_569 = __s0_569 * splatq_laneq_f32(__s1_569, __p2_569); \
+  __ret_569; \
+})
+#else
+#define vmulq_laneq_f32(__p0_570, __p1_570, __p2_570) __extension__ ({ \
+  float32x4_t __ret_570; \
+  float32x4_t __s0_570 = __p0_570; \
+  float32x4_t __s1_570 = __p1_570; \
+  float32x4_t __rev0_570;  __rev0_570 = __builtin_shufflevector(__s0_570, __s0_570, 3, 2, 1, 0); \
+  float32x4_t __rev1_570;  __rev1_570 = __builtin_shufflevector(__s1_570, __s1_570, 3, 2, 1, 0); \
+  __ret_570 = __rev0_570 * __noswap_splatq_laneq_f32(__rev1_570, __p2_570); \
+  __ret_570 = __builtin_shufflevector(__ret_570, __ret_570, 3, 2, 1, 0); \
+  __ret_570; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_laneq_s32(__p0_571, __p1_571, __p2_571) __extension__ ({ \
+  int32x4_t __ret_571; \
+  int32x4_t __s0_571 = __p0_571; \
+  int32x4_t __s1_571 = __p1_571; \
+  __ret_571 = __s0_571 * splatq_laneq_s32(__s1_571, __p2_571); \
+  __ret_571; \
+})
+#else
+#define vmulq_laneq_s32(__p0_572, __p1_572, __p2_572) __extension__ ({ \
+  int32x4_t __ret_572; \
+  int32x4_t __s0_572 = __p0_572; \
+  int32x4_t __s1_572 = __p1_572; \
+  int32x4_t __rev0_572;  __rev0_572 = __builtin_shufflevector(__s0_572, __s0_572, 3, 2, 1, 0); \
+  int32x4_t __rev1_572;  __rev1_572 = __builtin_shufflevector(__s1_572, __s1_572, 3, 2, 1, 0); \
+  __ret_572 = __rev0_572 * __noswap_splatq_laneq_s32(__rev1_572, __p2_572); \
+  __ret_572 = __builtin_shufflevector(__ret_572, __ret_572, 3, 2, 1, 0); \
+  __ret_572; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_laneq_s16(__p0_573, __p1_573, __p2_573) __extension__ ({ \
+  int16x8_t __ret_573; \
+  int16x8_t __s0_573 = __p0_573; \
+  int16x8_t __s1_573 = __p1_573; \
+  __ret_573 = __s0_573 * splatq_laneq_s16(__s1_573, __p2_573); \
+  __ret_573; \
+})
+#else
+#define vmulq_laneq_s16(__p0_574, __p1_574, __p2_574) __extension__ ({ \
+  int16x8_t __ret_574; \
+  int16x8_t __s0_574 = __p0_574; \
+  int16x8_t __s1_574 = __p1_574; \
+  int16x8_t __rev0_574;  __rev0_574 = __builtin_shufflevector(__s0_574, __s0_574, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_574;  __rev1_574 = __builtin_shufflevector(__s1_574, __s1_574, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_574 = __rev0_574 * __noswap_splatq_laneq_s16(__rev1_574, __p2_574); \
+  __ret_574 = __builtin_shufflevector(__ret_574, __ret_574, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_574; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_laneq_u32(__p0_575, __p1_575, __p2_575) __extension__ ({ \
+  uint32x2_t __ret_575; \
+  uint32x2_t __s0_575 = __p0_575; \
+  uint32x4_t __s1_575 = __p1_575; \
+  __ret_575 = __s0_575 * splat_laneq_u32(__s1_575, __p2_575); \
+  __ret_575; \
+})
+#else
+#define vmul_laneq_u32(__p0_576, __p1_576, __p2_576) __extension__ ({ \
+  uint32x2_t __ret_576; \
+  uint32x2_t __s0_576 = __p0_576; \
+  uint32x4_t __s1_576 = __p1_576; \
+  uint32x2_t __rev0_576;  __rev0_576 = __builtin_shufflevector(__s0_576, __s0_576, 1, 0); \
+  uint32x4_t __rev1_576;  __rev1_576 = __builtin_shufflevector(__s1_576, __s1_576, 3, 2, 1, 0); \
+  __ret_576 = __rev0_576 * __noswap_splat_laneq_u32(__rev1_576, __p2_576); \
+  __ret_576 = __builtin_shufflevector(__ret_576, __ret_576, 1, 0); \
+  __ret_576; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_laneq_u16(__p0_577, __p1_577, __p2_577) __extension__ ({ \
+  uint16x4_t __ret_577; \
+  uint16x4_t __s0_577 = __p0_577; \
+  uint16x8_t __s1_577 = __p1_577; \
+  __ret_577 = __s0_577 * splat_laneq_u16(__s1_577, __p2_577); \
+  __ret_577; \
+})
+#else
+#define vmul_laneq_u16(__p0_578, __p1_578, __p2_578) __extension__ ({ \
+  uint16x4_t __ret_578; \
+  uint16x4_t __s0_578 = __p0_578; \
+  uint16x8_t __s1_578 = __p1_578; \
+  uint16x4_t __rev0_578;  __rev0_578 = __builtin_shufflevector(__s0_578, __s0_578, 3, 2, 1, 0); \
+  uint16x8_t __rev1_578;  __rev1_578 = __builtin_shufflevector(__s1_578, __s1_578, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_578 = __rev0_578 * __noswap_splat_laneq_u16(__rev1_578, __p2_578); \
+  __ret_578 = __builtin_shufflevector(__ret_578, __ret_578, 3, 2, 1, 0); \
+  __ret_578; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_laneq_f32(__p0_579, __p1_579, __p2_579) __extension__ ({ \
+  float32x2_t __ret_579; \
+  float32x2_t __s0_579 = __p0_579; \
+  float32x4_t __s1_579 = __p1_579; \
+  __ret_579 = __s0_579 * splat_laneq_f32(__s1_579, __p2_579); \
+  __ret_579; \
+})
+#else
+#define vmul_laneq_f32(__p0_580, __p1_580, __p2_580) __extension__ ({ \
+  float32x2_t __ret_580; \
+  float32x2_t __s0_580 = __p0_580; \
+  float32x4_t __s1_580 = __p1_580; \
+  float32x2_t __rev0_580;  __rev0_580 = __builtin_shufflevector(__s0_580, __s0_580, 1, 0); \
+  float32x4_t __rev1_580;  __rev1_580 = __builtin_shufflevector(__s1_580, __s1_580, 3, 2, 1, 0); \
+  __ret_580 = __rev0_580 * __noswap_splat_laneq_f32(__rev1_580, __p2_580); \
+  __ret_580 = __builtin_shufflevector(__ret_580, __ret_580, 1, 0); \
+  __ret_580; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_laneq_s32(__p0_581, __p1_581, __p2_581) __extension__ ({ \
+  int32x2_t __ret_581; \
+  int32x2_t __s0_581 = __p0_581; \
+  int32x4_t __s1_581 = __p1_581; \
+  __ret_581 = __s0_581 * splat_laneq_s32(__s1_581, __p2_581); \
+  __ret_581; \
+})
+#else
+#define vmul_laneq_s32(__p0_582, __p1_582, __p2_582) __extension__ ({ \
+  int32x2_t __ret_582; \
+  int32x2_t __s0_582 = __p0_582; \
+  int32x4_t __s1_582 = __p1_582; \
+  int32x2_t __rev0_582;  __rev0_582 = __builtin_shufflevector(__s0_582, __s0_582, 1, 0); \
+  int32x4_t __rev1_582;  __rev1_582 = __builtin_shufflevector(__s1_582, __s1_582, 3, 2, 1, 0); \
+  __ret_582 = __rev0_582 * __noswap_splat_laneq_s32(__rev1_582, __p2_582); \
+  __ret_582 = __builtin_shufflevector(__ret_582, __ret_582, 1, 0); \
+  __ret_582; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_laneq_s16(__p0_583, __p1_583, __p2_583) __extension__ ({ \
+  int16x4_t __ret_583; \
+  int16x4_t __s0_583 = __p0_583; \
+  int16x8_t __s1_583 = __p1_583; \
+  __ret_583 = __s0_583 * splat_laneq_s16(__s1_583, __p2_583); \
+  __ret_583; \
+})
+#else
+#define vmul_laneq_s16(__p0_584, __p1_584, __p2_584) __extension__ ({ \
+  int16x4_t __ret_584; \
+  int16x4_t __s0_584 = __p0_584; \
+  int16x8_t __s1_584 = __p1_584; \
+  int16x4_t __rev0_584;  __rev0_584 = __builtin_shufflevector(__s0_584, __s0_584, 3, 2, 1, 0); \
+  int16x8_t __rev1_584;  __rev1_584 = __builtin_shufflevector(__s1_584, __s1_584, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_584 = __rev0_584 * __noswap_splat_laneq_s16(__rev1_584, __p2_584); \
+  __ret_584 = __builtin_shufflevector(__ret_584, __ret_584, 3, 2, 1, 0); \
+  __ret_584; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vmul_n_f64(float64x1_t __p0, float64_t __p1) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vmul_n_f64((float64x1_t)__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vmulq_n_f64(float64x2_t __p0, float64_t __p1) {
+  float64x2_t __ret;
+  __ret = __p0 * (float64x2_t) {__p1, __p1};
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vmulq_n_f64(float64x2_t __p0, float64_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = __rev0 * (float64x2_t) {__p1, __p1};
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vmull_high_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly16x8_t __ret;
+  __ret = vmull_p8(vget_high_p8(__p0), vget_high_p8(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vmull_high_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly16x8_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmull_p8(__noswap_vget_high_p8(__rev0), __noswap_vget_high_p8(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmull_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  __ret = vmull_u8(vget_high_u8(__p0), vget_high_u8(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmull_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmull_u8(__noswap_vget_high_u8(__rev0), __noswap_vget_high_u8(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmull_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  __ret = vmull_u32(vget_high_u32(__p0), vget_high_u32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmull_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmull_u32(__noswap_vget_high_u32(__rev0), __noswap_vget_high_u32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmull_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  __ret = vmull_u16(vget_high_u16(__p0), vget_high_u16(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmull_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmull_u16(__noswap_vget_high_u16(__rev0), __noswap_vget_high_u16(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmull_high_s8(int8x16_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  __ret = vmull_s8(vget_high_s8(__p0), vget_high_s8(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmull_high_s8(int8x16_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmull_s8(__noswap_vget_high_s8(__rev0), __noswap_vget_high_s8(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  __ret = vmull_s32(vget_high_s32(__p0), vget_high_s32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmull_s32(__noswap_vget_high_s32(__rev0), __noswap_vget_high_s32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  __ret = vmull_s16(vget_high_s16(__p0), vget_high_s16(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmull_s16(__noswap_vget_high_s16(__rev0), __noswap_vget_high_s16(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_lane_u32(__p0_585, __p1_585, __p2_585) __extension__ ({ \
+  uint64x2_t __ret_585; \
+  uint32x4_t __s0_585 = __p0_585; \
+  uint32x2_t __s1_585 = __p1_585; \
+  __ret_585 = vmull_u32(vget_high_u32(__s0_585), splat_lane_u32(__s1_585, __p2_585)); \
+  __ret_585; \
+})
+#else
+#define vmull_high_lane_u32(__p0_586, __p1_586, __p2_586) __extension__ ({ \
+  uint64x2_t __ret_586; \
+  uint32x4_t __s0_586 = __p0_586; \
+  uint32x2_t __s1_586 = __p1_586; \
+  uint32x4_t __rev0_586;  __rev0_586 = __builtin_shufflevector(__s0_586, __s0_586, 3, 2, 1, 0); \
+  uint32x2_t __rev1_586;  __rev1_586 = __builtin_shufflevector(__s1_586, __s1_586, 1, 0); \
+  __ret_586 = __noswap_vmull_u32(__noswap_vget_high_u32(__rev0_586), __noswap_splat_lane_u32(__rev1_586, __p2_586)); \
+  __ret_586 = __builtin_shufflevector(__ret_586, __ret_586, 1, 0); \
+  __ret_586; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_lane_u16(__p0_587, __p1_587, __p2_587) __extension__ ({ \
+  uint32x4_t __ret_587; \
+  uint16x8_t __s0_587 = __p0_587; \
+  uint16x4_t __s1_587 = __p1_587; \
+  __ret_587 = vmull_u16(vget_high_u16(__s0_587), splat_lane_u16(__s1_587, __p2_587)); \
+  __ret_587; \
+})
+#else
+#define vmull_high_lane_u16(__p0_588, __p1_588, __p2_588) __extension__ ({ \
+  uint32x4_t __ret_588; \
+  uint16x8_t __s0_588 = __p0_588; \
+  uint16x4_t __s1_588 = __p1_588; \
+  uint16x8_t __rev0_588;  __rev0_588 = __builtin_shufflevector(__s0_588, __s0_588, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x4_t __rev1_588;  __rev1_588 = __builtin_shufflevector(__s1_588, __s1_588, 3, 2, 1, 0); \
+  __ret_588 = __noswap_vmull_u16(__noswap_vget_high_u16(__rev0_588), __noswap_splat_lane_u16(__rev1_588, __p2_588)); \
+  __ret_588 = __builtin_shufflevector(__ret_588, __ret_588, 3, 2, 1, 0); \
+  __ret_588; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_lane_s32(__p0_589, __p1_589, __p2_589) __extension__ ({ \
+  int64x2_t __ret_589; \
+  int32x4_t __s0_589 = __p0_589; \
+  int32x2_t __s1_589 = __p1_589; \
+  __ret_589 = vmull_s32(vget_high_s32(__s0_589), splat_lane_s32(__s1_589, __p2_589)); \
+  __ret_589; \
+})
+#else
+#define vmull_high_lane_s32(__p0_590, __p1_590, __p2_590) __extension__ ({ \
+  int64x2_t __ret_590; \
+  int32x4_t __s0_590 = __p0_590; \
+  int32x2_t __s1_590 = __p1_590; \
+  int32x4_t __rev0_590;  __rev0_590 = __builtin_shufflevector(__s0_590, __s0_590, 3, 2, 1, 0); \
+  int32x2_t __rev1_590;  __rev1_590 = __builtin_shufflevector(__s1_590, __s1_590, 1, 0); \
+  __ret_590 = __noswap_vmull_s32(__noswap_vget_high_s32(__rev0_590), __noswap_splat_lane_s32(__rev1_590, __p2_590)); \
+  __ret_590 = __builtin_shufflevector(__ret_590, __ret_590, 1, 0); \
+  __ret_590; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_lane_s16(__p0_591, __p1_591, __p2_591) __extension__ ({ \
+  int32x4_t __ret_591; \
+  int16x8_t __s0_591 = __p0_591; \
+  int16x4_t __s1_591 = __p1_591; \
+  __ret_591 = vmull_s16(vget_high_s16(__s0_591), splat_lane_s16(__s1_591, __p2_591)); \
+  __ret_591; \
+})
+#else
+#define vmull_high_lane_s16(__p0_592, __p1_592, __p2_592) __extension__ ({ \
+  int32x4_t __ret_592; \
+  int16x8_t __s0_592 = __p0_592; \
+  int16x4_t __s1_592 = __p1_592; \
+  int16x8_t __rev0_592;  __rev0_592 = __builtin_shufflevector(__s0_592, __s0_592, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev1_592;  __rev1_592 = __builtin_shufflevector(__s1_592, __s1_592, 3, 2, 1, 0); \
+  __ret_592 = __noswap_vmull_s16(__noswap_vget_high_s16(__rev0_592), __noswap_splat_lane_s16(__rev1_592, __p2_592)); \
+  __ret_592 = __builtin_shufflevector(__ret_592, __ret_592, 3, 2, 1, 0); \
+  __ret_592; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_laneq_u32(__p0_593, __p1_593, __p2_593) __extension__ ({ \
+  uint64x2_t __ret_593; \
+  uint32x4_t __s0_593 = __p0_593; \
+  uint32x4_t __s1_593 = __p1_593; \
+  __ret_593 = vmull_u32(vget_high_u32(__s0_593), splat_laneq_u32(__s1_593, __p2_593)); \
+  __ret_593; \
+})
+#else
+#define vmull_high_laneq_u32(__p0_594, __p1_594, __p2_594) __extension__ ({ \
+  uint64x2_t __ret_594; \
+  uint32x4_t __s0_594 = __p0_594; \
+  uint32x4_t __s1_594 = __p1_594; \
+  uint32x4_t __rev0_594;  __rev0_594 = __builtin_shufflevector(__s0_594, __s0_594, 3, 2, 1, 0); \
+  uint32x4_t __rev1_594;  __rev1_594 = __builtin_shufflevector(__s1_594, __s1_594, 3, 2, 1, 0); \
+  __ret_594 = __noswap_vmull_u32(__noswap_vget_high_u32(__rev0_594), __noswap_splat_laneq_u32(__rev1_594, __p2_594)); \
+  __ret_594 = __builtin_shufflevector(__ret_594, __ret_594, 1, 0); \
+  __ret_594; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_laneq_u16(__p0_595, __p1_595, __p2_595) __extension__ ({ \
+  uint32x4_t __ret_595; \
+  uint16x8_t __s0_595 = __p0_595; \
+  uint16x8_t __s1_595 = __p1_595; \
+  __ret_595 = vmull_u16(vget_high_u16(__s0_595), splat_laneq_u16(__s1_595, __p2_595)); \
+  __ret_595; \
+})
+#else
+#define vmull_high_laneq_u16(__p0_596, __p1_596, __p2_596) __extension__ ({ \
+  uint32x4_t __ret_596; \
+  uint16x8_t __s0_596 = __p0_596; \
+  uint16x8_t __s1_596 = __p1_596; \
+  uint16x8_t __rev0_596;  __rev0_596 = __builtin_shufflevector(__s0_596, __s0_596, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1_596;  __rev1_596 = __builtin_shufflevector(__s1_596, __s1_596, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_596 = __noswap_vmull_u16(__noswap_vget_high_u16(__rev0_596), __noswap_splat_laneq_u16(__rev1_596, __p2_596)); \
+  __ret_596 = __builtin_shufflevector(__ret_596, __ret_596, 3, 2, 1, 0); \
+  __ret_596; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_laneq_s32(__p0_597, __p1_597, __p2_597) __extension__ ({ \
+  int64x2_t __ret_597; \
+  int32x4_t __s0_597 = __p0_597; \
+  int32x4_t __s1_597 = __p1_597; \
+  __ret_597 = vmull_s32(vget_high_s32(__s0_597), splat_laneq_s32(__s1_597, __p2_597)); \
+  __ret_597; \
+})
+#else
+#define vmull_high_laneq_s32(__p0_598, __p1_598, __p2_598) __extension__ ({ \
+  int64x2_t __ret_598; \
+  int32x4_t __s0_598 = __p0_598; \
+  int32x4_t __s1_598 = __p1_598; \
+  int32x4_t __rev0_598;  __rev0_598 = __builtin_shufflevector(__s0_598, __s0_598, 3, 2, 1, 0); \
+  int32x4_t __rev1_598;  __rev1_598 = __builtin_shufflevector(__s1_598, __s1_598, 3, 2, 1, 0); \
+  __ret_598 = __noswap_vmull_s32(__noswap_vget_high_s32(__rev0_598), __noswap_splat_laneq_s32(__rev1_598, __p2_598)); \
+  __ret_598 = __builtin_shufflevector(__ret_598, __ret_598, 1, 0); \
+  __ret_598; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_high_laneq_s16(__p0_599, __p1_599, __p2_599) __extension__ ({ \
+  int32x4_t __ret_599; \
+  int16x8_t __s0_599 = __p0_599; \
+  int16x8_t __s1_599 = __p1_599; \
+  __ret_599 = vmull_s16(vget_high_s16(__s0_599), splat_laneq_s16(__s1_599, __p2_599)); \
+  __ret_599; \
+})
+#else
+#define vmull_high_laneq_s16(__p0_600, __p1_600, __p2_600) __extension__ ({ \
+  int32x4_t __ret_600; \
+  int16x8_t __s0_600 = __p0_600; \
+  int16x8_t __s1_600 = __p1_600; \
+  int16x8_t __rev0_600;  __rev0_600 = __builtin_shufflevector(__s0_600, __s0_600, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_600;  __rev1_600 = __builtin_shufflevector(__s1_600, __s1_600, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_600 = __noswap_vmull_s16(__noswap_vget_high_s16(__rev0_600), __noswap_splat_laneq_s16(__rev1_600, __p2_600)); \
+  __ret_600 = __builtin_shufflevector(__ret_600, __ret_600, 3, 2, 1, 0); \
+  __ret_600; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmull_high_n_u32(uint32x4_t __p0, uint32_t __p1) {
+  uint64x2_t __ret;
+  __ret = vmull_n_u32(vget_high_u32(__p0), __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmull_high_n_u32(uint32x4_t __p0, uint32_t __p1) {
+  uint64x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vmull_n_u32(__noswap_vget_high_u32(__rev0), __p1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmull_high_n_u16(uint16x8_t __p0, uint16_t __p1) {
+  uint32x4_t __ret;
+  __ret = vmull_n_u16(vget_high_u16(__p0), __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmull_high_n_u16(uint16x8_t __p0, uint16_t __p1) {
+  uint32x4_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmull_n_u16(__noswap_vget_high_u16(__rev0), __p1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
+  int64x2_t __ret;
+  __ret = vmull_n_s32(vget_high_s32(__p0), __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
+  int64x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vmull_n_s32(__noswap_vget_high_s32(__rev0), __p1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
+  int32x4_t __ret;
+  __ret = vmull_n_s16(vget_high_s16(__p0), __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
+  int32x4_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmull_n_s16(__noswap_vget_high_s16(__rev0), __p1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_laneq_u32(__p0_601, __p1_601, __p2_601) __extension__ ({ \
+  uint64x2_t __ret_601; \
+  uint32x2_t __s0_601 = __p0_601; \
+  uint32x4_t __s1_601 = __p1_601; \
+  __ret_601 = vmull_u32(__s0_601, splat_laneq_u32(__s1_601, __p2_601)); \
+  __ret_601; \
+})
+#else
+#define vmull_laneq_u32(__p0_602, __p1_602, __p2_602) __extension__ ({ \
+  uint64x2_t __ret_602; \
+  uint32x2_t __s0_602 = __p0_602; \
+  uint32x4_t __s1_602 = __p1_602; \
+  uint32x2_t __rev0_602;  __rev0_602 = __builtin_shufflevector(__s0_602, __s0_602, 1, 0); \
+  uint32x4_t __rev1_602;  __rev1_602 = __builtin_shufflevector(__s1_602, __s1_602, 3, 2, 1, 0); \
+  __ret_602 = __noswap_vmull_u32(__rev0_602, __noswap_splat_laneq_u32(__rev1_602, __p2_602)); \
+  __ret_602 = __builtin_shufflevector(__ret_602, __ret_602, 1, 0); \
+  __ret_602; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_laneq_u16(__p0_603, __p1_603, __p2_603) __extension__ ({ \
+  uint32x4_t __ret_603; \
+  uint16x4_t __s0_603 = __p0_603; \
+  uint16x8_t __s1_603 = __p1_603; \
+  __ret_603 = vmull_u16(__s0_603, splat_laneq_u16(__s1_603, __p2_603)); \
+  __ret_603; \
+})
+#else
+#define vmull_laneq_u16(__p0_604, __p1_604, __p2_604) __extension__ ({ \
+  uint32x4_t __ret_604; \
+  uint16x4_t __s0_604 = __p0_604; \
+  uint16x8_t __s1_604 = __p1_604; \
+  uint16x4_t __rev0_604;  __rev0_604 = __builtin_shufflevector(__s0_604, __s0_604, 3, 2, 1, 0); \
+  uint16x8_t __rev1_604;  __rev1_604 = __builtin_shufflevector(__s1_604, __s1_604, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_604 = __noswap_vmull_u16(__rev0_604, __noswap_splat_laneq_u16(__rev1_604, __p2_604)); \
+  __ret_604 = __builtin_shufflevector(__ret_604, __ret_604, 3, 2, 1, 0); \
+  __ret_604; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_laneq_s32(__p0_605, __p1_605, __p2_605) __extension__ ({ \
+  int64x2_t __ret_605; \
+  int32x2_t __s0_605 = __p0_605; \
+  int32x4_t __s1_605 = __p1_605; \
+  __ret_605 = vmull_s32(__s0_605, splat_laneq_s32(__s1_605, __p2_605)); \
+  __ret_605; \
+})
+#else
+#define vmull_laneq_s32(__p0_606, __p1_606, __p2_606) __extension__ ({ \
+  int64x2_t __ret_606; \
+  int32x2_t __s0_606 = __p0_606; \
+  int32x4_t __s1_606 = __p1_606; \
+  int32x2_t __rev0_606;  __rev0_606 = __builtin_shufflevector(__s0_606, __s0_606, 1, 0); \
+  int32x4_t __rev1_606;  __rev1_606 = __builtin_shufflevector(__s1_606, __s1_606, 3, 2, 1, 0); \
+  __ret_606 = __noswap_vmull_s32(__rev0_606, __noswap_splat_laneq_s32(__rev1_606, __p2_606)); \
+  __ret_606 = __builtin_shufflevector(__ret_606, __ret_606, 1, 0); \
+  __ret_606; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmull_laneq_s16(__p0_607, __p1_607, __p2_607) __extension__ ({ \
+  int32x4_t __ret_607; \
+  int16x4_t __s0_607 = __p0_607; \
+  int16x8_t __s1_607 = __p1_607; \
+  __ret_607 = vmull_s16(__s0_607, splat_laneq_s16(__s1_607, __p2_607)); \
+  __ret_607; \
+})
+#else
+#define vmull_laneq_s16(__p0_608, __p1_608, __p2_608) __extension__ ({ \
+  int32x4_t __ret_608; \
+  int16x4_t __s0_608 = __p0_608; \
+  int16x8_t __s1_608 = __p1_608; \
+  int16x4_t __rev0_608;  __rev0_608 = __builtin_shufflevector(__s0_608, __s0_608, 3, 2, 1, 0); \
+  int16x8_t __rev1_608;  __rev1_608 = __builtin_shufflevector(__s1_608, __s1_608, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_608 = __noswap_vmull_s16(__rev0_608, __noswap_splat_laneq_s16(__rev1_608, __p2_608)); \
+  __ret_608 = __builtin_shufflevector(__ret_608, __ret_608, 3, 2, 1, 0); \
+  __ret_608; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vmulxq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vmulxq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vmulxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t __noswap_vmulxq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vmulxq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vmulxq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vmulxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t __noswap_vmulxq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vmulxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vmulx_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vmulx_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vmulx_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vmulx_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vmulx_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vmulx_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t __noswap_vmulx_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vmulx_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64_t vmulxd_f64(float64_t __p0, float64_t __p1) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vmulxd_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vmulxs_f32(float32_t __p0, float32_t __p1) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vmulxs_f32(__p0, __p1);
+  return __ret;
+}
+#define vmulxd_lane_f64(__p0_609, __p1_609, __p2_609) __extension__ ({ \
+  float64_t __ret_609; \
+  float64_t __s0_609 = __p0_609; \
+  float64x1_t __s1_609 = __p1_609; \
+  __ret_609 = vmulxd_f64(__s0_609, vget_lane_f64(__s1_609, __p2_609)); \
+  __ret_609; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vmulxs_lane_f32(__p0_610, __p1_610, __p2_610) __extension__ ({ \
+  float32_t __ret_610; \
+  float32_t __s0_610 = __p0_610; \
+  float32x2_t __s1_610 = __p1_610; \
+  __ret_610 = vmulxs_f32(__s0_610, vget_lane_f32(__s1_610, __p2_610)); \
+  __ret_610; \
+})
+#else
+#define vmulxs_lane_f32(__p0_611, __p1_611, __p2_611) __extension__ ({ \
+  float32_t __ret_611; \
+  float32_t __s0_611 = __p0_611; \
+  float32x2_t __s1_611 = __p1_611; \
+  float32x2_t __rev1_611;  __rev1_611 = __builtin_shufflevector(__s1_611, __s1_611, 1, 0); \
+  __ret_611 = vmulxs_f32(__s0_611, __noswap_vget_lane_f32(__rev1_611, __p2_611)); \
+  __ret_611; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxq_lane_f64(__p0_612, __p1_612, __p2_612) __extension__ ({ \
+  float64x2_t __ret_612; \
+  float64x2_t __s0_612 = __p0_612; \
+  float64x1_t __s1_612 = __p1_612; \
+  __ret_612 = vmulxq_f64(__s0_612, splatq_lane_f64(__s1_612, __p2_612)); \
+  __ret_612; \
+})
+#else
+#define vmulxq_lane_f64(__p0_613, __p1_613, __p2_613) __extension__ ({ \
+  float64x2_t __ret_613; \
+  float64x2_t __s0_613 = __p0_613; \
+  float64x1_t __s1_613 = __p1_613; \
+  float64x2_t __rev0_613;  __rev0_613 = __builtin_shufflevector(__s0_613, __s0_613, 1, 0); \
+  __ret_613 = __noswap_vmulxq_f64(__rev0_613, __noswap_splatq_lane_f64(__s1_613, __p2_613)); \
+  __ret_613 = __builtin_shufflevector(__ret_613, __ret_613, 1, 0); \
+  __ret_613; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxq_lane_f32(__p0_614, __p1_614, __p2_614) __extension__ ({ \
+  float32x4_t __ret_614; \
+  float32x4_t __s0_614 = __p0_614; \
+  float32x2_t __s1_614 = __p1_614; \
+  __ret_614 = vmulxq_f32(__s0_614, splatq_lane_f32(__s1_614, __p2_614)); \
+  __ret_614; \
+})
+#else
+#define vmulxq_lane_f32(__p0_615, __p1_615, __p2_615) __extension__ ({ \
+  float32x4_t __ret_615; \
+  float32x4_t __s0_615 = __p0_615; \
+  float32x2_t __s1_615 = __p1_615; \
+  float32x4_t __rev0_615;  __rev0_615 = __builtin_shufflevector(__s0_615, __s0_615, 3, 2, 1, 0); \
+  float32x2_t __rev1_615;  __rev1_615 = __builtin_shufflevector(__s1_615, __s1_615, 1, 0); \
+  __ret_615 = __noswap_vmulxq_f32(__rev0_615, __noswap_splatq_lane_f32(__rev1_615, __p2_615)); \
+  __ret_615 = __builtin_shufflevector(__ret_615, __ret_615, 3, 2, 1, 0); \
+  __ret_615; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulx_lane_f32(__p0_616, __p1_616, __p2_616) __extension__ ({ \
+  float32x2_t __ret_616; \
+  float32x2_t __s0_616 = __p0_616; \
+  float32x2_t __s1_616 = __p1_616; \
+  __ret_616 = vmulx_f32(__s0_616, splat_lane_f32(__s1_616, __p2_616)); \
+  __ret_616; \
+})
+#else
+#define vmulx_lane_f32(__p0_617, __p1_617, __p2_617) __extension__ ({ \
+  float32x2_t __ret_617; \
+  float32x2_t __s0_617 = __p0_617; \
+  float32x2_t __s1_617 = __p1_617; \
+  float32x2_t __rev0_617;  __rev0_617 = __builtin_shufflevector(__s0_617, __s0_617, 1, 0); \
+  float32x2_t __rev1_617;  __rev1_617 = __builtin_shufflevector(__s1_617, __s1_617, 1, 0); \
+  __ret_617 = __noswap_vmulx_f32(__rev0_617, __noswap_splat_lane_f32(__rev1_617, __p2_617)); \
+  __ret_617 = __builtin_shufflevector(__ret_617, __ret_617, 1, 0); \
+  __ret_617; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxd_laneq_f64(__p0_618, __p1_618, __p2_618) __extension__ ({ \
+  float64_t __ret_618; \
+  float64_t __s0_618 = __p0_618; \
+  float64x2_t __s1_618 = __p1_618; \
+  __ret_618 = vmulxd_f64(__s0_618, vgetq_lane_f64(__s1_618, __p2_618)); \
+  __ret_618; \
+})
+#else
+#define vmulxd_laneq_f64(__p0_619, __p1_619, __p2_619) __extension__ ({ \
+  float64_t __ret_619; \
+  float64_t __s0_619 = __p0_619; \
+  float64x2_t __s1_619 = __p1_619; \
+  float64x2_t __rev1_619;  __rev1_619 = __builtin_shufflevector(__s1_619, __s1_619, 1, 0); \
+  __ret_619 = vmulxd_f64(__s0_619, __noswap_vgetq_lane_f64(__rev1_619, __p2_619)); \
+  __ret_619; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxs_laneq_f32(__p0_620, __p1_620, __p2_620) __extension__ ({ \
+  float32_t __ret_620; \
+  float32_t __s0_620 = __p0_620; \
+  float32x4_t __s1_620 = __p1_620; \
+  __ret_620 = vmulxs_f32(__s0_620, vgetq_lane_f32(__s1_620, __p2_620)); \
+  __ret_620; \
+})
+#else
+#define vmulxs_laneq_f32(__p0_621, __p1_621, __p2_621) __extension__ ({ \
+  float32_t __ret_621; \
+  float32_t __s0_621 = __p0_621; \
+  float32x4_t __s1_621 = __p1_621; \
+  float32x4_t __rev1_621;  __rev1_621 = __builtin_shufflevector(__s1_621, __s1_621, 3, 2, 1, 0); \
+  __ret_621 = vmulxs_f32(__s0_621, __noswap_vgetq_lane_f32(__rev1_621, __p2_621)); \
+  __ret_621; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxq_laneq_f64(__p0_622, __p1_622, __p2_622) __extension__ ({ \
+  float64x2_t __ret_622; \
+  float64x2_t __s0_622 = __p0_622; \
+  float64x2_t __s1_622 = __p1_622; \
+  __ret_622 = vmulxq_f64(__s0_622, splatq_laneq_f64(__s1_622, __p2_622)); \
+  __ret_622; \
+})
+#else
+#define vmulxq_laneq_f64(__p0_623, __p1_623, __p2_623) __extension__ ({ \
+  float64x2_t __ret_623; \
+  float64x2_t __s0_623 = __p0_623; \
+  float64x2_t __s1_623 = __p1_623; \
+  float64x2_t __rev0_623;  __rev0_623 = __builtin_shufflevector(__s0_623, __s0_623, 1, 0); \
+  float64x2_t __rev1_623;  __rev1_623 = __builtin_shufflevector(__s1_623, __s1_623, 1, 0); \
+  __ret_623 = __noswap_vmulxq_f64(__rev0_623, __noswap_splatq_laneq_f64(__rev1_623, __p2_623)); \
+  __ret_623 = __builtin_shufflevector(__ret_623, __ret_623, 1, 0); \
+  __ret_623; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulxq_laneq_f32(__p0_624, __p1_624, __p2_624) __extension__ ({ \
+  float32x4_t __ret_624; \
+  float32x4_t __s0_624 = __p0_624; \
+  float32x4_t __s1_624 = __p1_624; \
+  __ret_624 = vmulxq_f32(__s0_624, splatq_laneq_f32(__s1_624, __p2_624)); \
+  __ret_624; \
+})
+#else
+#define vmulxq_laneq_f32(__p0_625, __p1_625, __p2_625) __extension__ ({ \
+  float32x4_t __ret_625; \
+  float32x4_t __s0_625 = __p0_625; \
+  float32x4_t __s1_625 = __p1_625; \
+  float32x4_t __rev0_625;  __rev0_625 = __builtin_shufflevector(__s0_625, __s0_625, 3, 2, 1, 0); \
+  float32x4_t __rev1_625;  __rev1_625 = __builtin_shufflevector(__s1_625, __s1_625, 3, 2, 1, 0); \
+  __ret_625 = __noswap_vmulxq_f32(__rev0_625, __noswap_splatq_laneq_f32(__rev1_625, __p2_625)); \
+  __ret_625 = __builtin_shufflevector(__ret_625, __ret_625, 3, 2, 1, 0); \
+  __ret_625; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulx_laneq_f32(__p0_626, __p1_626, __p2_626) __extension__ ({ \
+  float32x2_t __ret_626; \
+  float32x2_t __s0_626 = __p0_626; \
+  float32x4_t __s1_626 = __p1_626; \
+  __ret_626 = vmulx_f32(__s0_626, splat_laneq_f32(__s1_626, __p2_626)); \
+  __ret_626; \
+})
+#else
+#define vmulx_laneq_f32(__p0_627, __p1_627, __p2_627) __extension__ ({ \
+  float32x2_t __ret_627; \
+  float32x2_t __s0_627 = __p0_627; \
+  float32x4_t __s1_627 = __p1_627; \
+  float32x2_t __rev0_627;  __rev0_627 = __builtin_shufflevector(__s0_627, __s0_627, 1, 0); \
+  float32x4_t __rev1_627;  __rev1_627 = __builtin_shufflevector(__s1_627, __s1_627, 3, 2, 1, 0); \
+  __ret_627 = __noswap_vmulx_f32(__rev0_627, __noswap_splat_laneq_f32(__rev1_627, __p2_627)); \
+  __ret_627 = __builtin_shufflevector(__ret_627, __ret_627, 1, 0); \
+  __ret_627; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vnegq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vnegq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vnegq_s64(int64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vnegq_s64(int64x2_t __p0) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = -__rev0;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vneg_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vneg_s64(int64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = -__p0;
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vnegd_s64(int64_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vnegd_s64(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vpaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vpaddq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vpaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vpaddq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vpaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vpaddq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vpaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vpaddq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vpaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vpaddq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vpaddq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vpaddq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vpaddq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vpaddq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vpaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vpaddq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vpaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vpaddq_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vpaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vpaddq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vpaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64_t vpaddd_u64(uint64x2_t __p0) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vpaddd_u64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64_t vpaddd_u64(uint64x2_t __p0) {
+  uint64_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (uint64_t) __builtin_neon_vpaddd_u64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vpaddd_f64(float64x2_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vpaddd_f64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vpaddd_f64(float64x2_t __p0) {
+  float64_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64_t) __builtin_neon_vpaddd_f64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64_t vpaddd_s64(int64x2_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vpaddd_s64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64_t vpaddd_s64(int64x2_t __p0) {
+  int64_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64_t) __builtin_neon_vpaddd_s64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vpadds_f32(float32x2_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vpadds_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vpadds_f32(float32x2_t __p0) {
+  float32_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32_t) __builtin_neon_vpadds_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vpmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vpmaxq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vpmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vpmaxq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vpmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vpmaxq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vpmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vpmaxq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vpmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vpmaxq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vpmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vpmaxq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vpmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vpmaxq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vpmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vpmaxq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vpmaxq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vpmaxqd_f64(float64x2_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vpmaxqd_f64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vpmaxqd_f64(float64x2_t __p0) {
+  float64_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64_t) __builtin_neon_vpmaxqd_f64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vpmaxs_f32(float32x2_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vpmaxs_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vpmaxs_f32(float32x2_t __p0) {
+  float32_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32_t) __builtin_neon_vpmaxs_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vpmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vpmaxnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vpmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vpmaxnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vpmaxnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vpmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vpmaxnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vpmaxnm_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vpmaxnm_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vpmaxnmqd_f64(float64x2_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vpmaxnmqd_f64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vpmaxnmqd_f64(float64x2_t __p0) {
+  float64_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64_t) __builtin_neon_vpmaxnmqd_f64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vpmaxnms_f32(float32x2_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vpmaxnms_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vpmaxnms_f32(float32x2_t __p0) {
+  float32_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32_t) __builtin_neon_vpmaxnms_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vpminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vpminq_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vpminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vpminq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vpminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vpminq_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vpminq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vpminq_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vpminq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vpminq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vpminq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vpminq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vpminq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vpminq_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vpminq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vpminq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vpminq_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vpminq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vpminqd_f64(float64x2_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vpminqd_f64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vpminqd_f64(float64x2_t __p0) {
+  float64_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64_t) __builtin_neon_vpminqd_f64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vpmins_f32(float32x2_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vpmins_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vpmins_f32(float32x2_t __p0) {
+  float32_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32_t) __builtin_neon_vpmins_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vpminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vpminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vpminnmq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vpminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vpminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vpminnmq_v((int8x16_t)__p0, (int8x16_t)__p1, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vpminnmq_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vpminnmq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vpminnm_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vpminnm_v((int8x8_t)__p0, (int8x8_t)__p1, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vpminnm_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vpminnm_v((int8x8_t)__rev0, (int8x8_t)__rev1, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64_t vpminnmqd_f64(float64x2_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vpminnmqd_f64(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64_t vpminnmqd_f64(float64x2_t __p0) {
+  float64_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64_t) __builtin_neon_vpminnmqd_f64(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32_t vpminnms_f32(float32x2_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vpminnms_f32(__p0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32_t vpminnms_f32(float32x2_t __p0) {
+  float32_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32_t) __builtin_neon_vpminnms_f32(__rev0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqabsq_s64(int64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqabsq_v((int8x16_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqabsq_s64(int64x2_t __p0) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vqabsq_v((int8x16_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vqabs_s64(int64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vqabs_v((int8x8_t)__p0, 3);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vqabsb_s8(int8_t __p0) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vqabsb_s8(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqabss_s32(int32_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqabss_s32(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqabsd_s64(int64_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vqabsd_s64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqabsh_s16(int16_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqabsh_s16(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8_t vqaddb_u8(uint8_t __p0, uint8_t __p1) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vqaddb_u8(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vqadds_u32(uint32_t __p0, uint32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vqadds_u32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vqaddd_u64(uint64_t __p0, uint64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vqaddd_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16_t vqaddh_u16(uint16_t __p0, uint16_t __p1) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vqaddh_u16(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vqaddb_s8(int8_t __p0, int8_t __p1) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vqaddb_s8(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqadds_s32(int32_t __p0, int32_t __p1) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqadds_s32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqaddd_s64(int64_t __p0, int64_t __p1) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vqaddd_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqaddh_s16(int16_t __p0, int16_t __p1) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqaddh_s16(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqdmlals_s32(int64_t __p0, int32_t __p1, int32_t __p2) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vqdmlals_s32(__p0, __p1, __p2);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqdmlalh_s16(int32_t __p0, int16_t __p1, int16_t __p2) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqdmlalh_s16(__p0, __p1, __p2);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int64x2_t __ret;
+  __ret = vqdmlal_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vqdmlal_s32(__rev0, __noswap_vget_high_s32(__rev1), __noswap_vget_high_s32(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int32x4_t __ret;
+  __ret = vqdmlal_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vqdmlal_s16(__rev0, __noswap_vget_high_s16(__rev1), __noswap_vget_high_s16(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlal_high_lane_s32(__p0_628, __p1_628, __p2_628, __p3_628) __extension__ ({ \
+  int64x2_t __ret_628; \
+  int64x2_t __s0_628 = __p0_628; \
+  int32x4_t __s1_628 = __p1_628; \
+  int32x2_t __s2_628 = __p2_628; \
+  __ret_628 = vqdmlal_s32(__s0_628, vget_high_s32(__s1_628), splat_lane_s32(__s2_628, __p3_628)); \
+  __ret_628; \
+})
+#else
+#define vqdmlal_high_lane_s32(__p0_629, __p1_629, __p2_629, __p3_629) __extension__ ({ \
+  int64x2_t __ret_629; \
+  int64x2_t __s0_629 = __p0_629; \
+  int32x4_t __s1_629 = __p1_629; \
+  int32x2_t __s2_629 = __p2_629; \
+  int64x2_t __rev0_629;  __rev0_629 = __builtin_shufflevector(__s0_629, __s0_629, 1, 0); \
+  int32x4_t __rev1_629;  __rev1_629 = __builtin_shufflevector(__s1_629, __s1_629, 3, 2, 1, 0); \
+  int32x2_t __rev2_629;  __rev2_629 = __builtin_shufflevector(__s2_629, __s2_629, 1, 0); \
+  __ret_629 = __noswap_vqdmlal_s32(__rev0_629, __noswap_vget_high_s32(__rev1_629), __noswap_splat_lane_s32(__rev2_629, __p3_629)); \
+  __ret_629 = __builtin_shufflevector(__ret_629, __ret_629, 1, 0); \
+  __ret_629; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlal_high_lane_s16(__p0_630, __p1_630, __p2_630, __p3_630) __extension__ ({ \
+  int32x4_t __ret_630; \
+  int32x4_t __s0_630 = __p0_630; \
+  int16x8_t __s1_630 = __p1_630; \
+  int16x4_t __s2_630 = __p2_630; \
+  __ret_630 = vqdmlal_s16(__s0_630, vget_high_s16(__s1_630), splat_lane_s16(__s2_630, __p3_630)); \
+  __ret_630; \
+})
+#else
+#define vqdmlal_high_lane_s16(__p0_631, __p1_631, __p2_631, __p3_631) __extension__ ({ \
+  int32x4_t __ret_631; \
+  int32x4_t __s0_631 = __p0_631; \
+  int16x8_t __s1_631 = __p1_631; \
+  int16x4_t __s2_631 = __p2_631; \
+  int32x4_t __rev0_631;  __rev0_631 = __builtin_shufflevector(__s0_631, __s0_631, 3, 2, 1, 0); \
+  int16x8_t __rev1_631;  __rev1_631 = __builtin_shufflevector(__s1_631, __s1_631, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev2_631;  __rev2_631 = __builtin_shufflevector(__s2_631, __s2_631, 3, 2, 1, 0); \
+  __ret_631 = __noswap_vqdmlal_s16(__rev0_631, __noswap_vget_high_s16(__rev1_631), __noswap_splat_lane_s16(__rev2_631, __p3_631)); \
+  __ret_631 = __builtin_shufflevector(__ret_631, __ret_631, 3, 2, 1, 0); \
+  __ret_631; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlal_high_laneq_s32(__p0_632, __p1_632, __p2_632, __p3_632) __extension__ ({ \
+  int64x2_t __ret_632; \
+  int64x2_t __s0_632 = __p0_632; \
+  int32x4_t __s1_632 = __p1_632; \
+  int32x4_t __s2_632 = __p2_632; \
+  __ret_632 = vqdmlal_s32(__s0_632, vget_high_s32(__s1_632), splat_laneq_s32(__s2_632, __p3_632)); \
+  __ret_632; \
+})
+#else
+#define vqdmlal_high_laneq_s32(__p0_633, __p1_633, __p2_633, __p3_633) __extension__ ({ \
+  int64x2_t __ret_633; \
+  int64x2_t __s0_633 = __p0_633; \
+  int32x4_t __s1_633 = __p1_633; \
+  int32x4_t __s2_633 = __p2_633; \
+  int64x2_t __rev0_633;  __rev0_633 = __builtin_shufflevector(__s0_633, __s0_633, 1, 0); \
+  int32x4_t __rev1_633;  __rev1_633 = __builtin_shufflevector(__s1_633, __s1_633, 3, 2, 1, 0); \
+  int32x4_t __rev2_633;  __rev2_633 = __builtin_shufflevector(__s2_633, __s2_633, 3, 2, 1, 0); \
+  __ret_633 = __noswap_vqdmlal_s32(__rev0_633, __noswap_vget_high_s32(__rev1_633), __noswap_splat_laneq_s32(__rev2_633, __p3_633)); \
+  __ret_633 = __builtin_shufflevector(__ret_633, __ret_633, 1, 0); \
+  __ret_633; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlal_high_laneq_s16(__p0_634, __p1_634, __p2_634, __p3_634) __extension__ ({ \
+  int32x4_t __ret_634; \
+  int32x4_t __s0_634 = __p0_634; \
+  int16x8_t __s1_634 = __p1_634; \
+  int16x8_t __s2_634 = __p2_634; \
+  __ret_634 = vqdmlal_s16(__s0_634, vget_high_s16(__s1_634), splat_laneq_s16(__s2_634, __p3_634)); \
+  __ret_634; \
+})
+#else
+#define vqdmlal_high_laneq_s16(__p0_635, __p1_635, __p2_635, __p3_635) __extension__ ({ \
+  int32x4_t __ret_635; \
+  int32x4_t __s0_635 = __p0_635; \
+  int16x8_t __s1_635 = __p1_635; \
+  int16x8_t __s2_635 = __p2_635; \
+  int32x4_t __rev0_635;  __rev0_635 = __builtin_shufflevector(__s0_635, __s0_635, 3, 2, 1, 0); \
+  int16x8_t __rev1_635;  __rev1_635 = __builtin_shufflevector(__s1_635, __s1_635, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev2_635;  __rev2_635 = __builtin_shufflevector(__s2_635, __s2_635, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_635 = __noswap_vqdmlal_s16(__rev0_635, __noswap_vget_high_s16(__rev1_635), __noswap_splat_laneq_s16(__rev2_635, __p3_635)); \
+  __ret_635 = __builtin_shufflevector(__ret_635, __ret_635, 3, 2, 1, 0); \
+  __ret_635; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = vqdmlal_n_s32(__p0, vget_high_s32(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vqdmlal_n_s32(__rev0, __noswap_vget_high_s32(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = vqdmlal_n_s16(__p0, vget_high_s16(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vqdmlal_n_s16(__rev0, __noswap_vget_high_s16(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlals_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int32_t __s1 = __p1; \
+  int32x2_t __s2 = __p2; \
+  __ret = (int64_t) __builtin_neon_vqdmlals_lane_s32(__s0, __s1, __s2, __p3); \
+  __ret; \
+})
+#else
+#define vqdmlals_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int32_t __s1 = __p1; \
+  int32x2_t __s2 = __p2; \
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+  __ret = (int64_t) __builtin_neon_vqdmlals_lane_s32(__s0, __s1, __rev2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlalh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int32_t __ret; \
+  int32_t __s0 = __p0; \
+  int16_t __s1 = __p1; \
+  int16x4_t __s2 = __p2; \
+  __ret = (int32_t) __builtin_neon_vqdmlalh_lane_s16(__s0, __s1, __s2, __p3); \
+  __ret; \
+})
+#else
+#define vqdmlalh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int32_t __ret; \
+  int32_t __s0 = __p0; \
+  int16_t __s1 = __p1; \
+  int16x4_t __s2 = __p2; \
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (int32_t) __builtin_neon_vqdmlalh_lane_s16(__s0, __s1, __rev2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlals_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int32_t __s1 = __p1; \
+  int32x4_t __s2 = __p2; \
+  __ret = (int64_t) __builtin_neon_vqdmlals_laneq_s32(__s0, __s1, __s2, __p3); \
+  __ret; \
+})
+#else
+#define vqdmlals_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int32_t __s1 = __p1; \
+  int32x4_t __s2 = __p2; \
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (int64_t) __builtin_neon_vqdmlals_laneq_s32(__s0, __s1, __rev2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlalh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int32_t __ret; \
+  int32_t __s0 = __p0; \
+  int16_t __s1 = __p1; \
+  int16x8_t __s2 = __p2; \
+  __ret = (int32_t) __builtin_neon_vqdmlalh_laneq_s16(__s0, __s1, __s2, __p3); \
+  __ret; \
+})
+#else
+#define vqdmlalh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int32_t __ret; \
+  int32_t __s0 = __p0; \
+  int16_t __s1 = __p1; \
+  int16x8_t __s2 = __p2; \
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int32_t) __builtin_neon_vqdmlalh_laneq_s16(__s0, __s1, __rev2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlal_laneq_s32(__p0_636, __p1_636, __p2_636, __p3_636) __extension__ ({ \
+  int64x2_t __ret_636; \
+  int64x2_t __s0_636 = __p0_636; \
+  int32x2_t __s1_636 = __p1_636; \
+  int32x4_t __s2_636 = __p2_636; \
+  __ret_636 = vqdmlal_s32(__s0_636, __s1_636, splat_laneq_s32(__s2_636, __p3_636)); \
+  __ret_636; \
+})
+#else
+#define vqdmlal_laneq_s32(__p0_637, __p1_637, __p2_637, __p3_637) __extension__ ({ \
+  int64x2_t __ret_637; \
+  int64x2_t __s0_637 = __p0_637; \
+  int32x2_t __s1_637 = __p1_637; \
+  int32x4_t __s2_637 = __p2_637; \
+  int64x2_t __rev0_637;  __rev0_637 = __builtin_shufflevector(__s0_637, __s0_637, 1, 0); \
+  int32x2_t __rev1_637;  __rev1_637 = __builtin_shufflevector(__s1_637, __s1_637, 1, 0); \
+  int32x4_t __rev2_637;  __rev2_637 = __builtin_shufflevector(__s2_637, __s2_637, 3, 2, 1, 0); \
+  __ret_637 = __noswap_vqdmlal_s32(__rev0_637, __rev1_637, __noswap_splat_laneq_s32(__rev2_637, __p3_637)); \
+  __ret_637 = __builtin_shufflevector(__ret_637, __ret_637, 1, 0); \
+  __ret_637; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlal_laneq_s16(__p0_638, __p1_638, __p2_638, __p3_638) __extension__ ({ \
+  int32x4_t __ret_638; \
+  int32x4_t __s0_638 = __p0_638; \
+  int16x4_t __s1_638 = __p1_638; \
+  int16x8_t __s2_638 = __p2_638; \
+  __ret_638 = vqdmlal_s16(__s0_638, __s1_638, splat_laneq_s16(__s2_638, __p3_638)); \
+  __ret_638; \
+})
+#else
+#define vqdmlal_laneq_s16(__p0_639, __p1_639, __p2_639, __p3_639) __extension__ ({ \
+  int32x4_t __ret_639; \
+  int32x4_t __s0_639 = __p0_639; \
+  int16x4_t __s1_639 = __p1_639; \
+  int16x8_t __s2_639 = __p2_639; \
+  int32x4_t __rev0_639;  __rev0_639 = __builtin_shufflevector(__s0_639, __s0_639, 3, 2, 1, 0); \
+  int16x4_t __rev1_639;  __rev1_639 = __builtin_shufflevector(__s1_639, __s1_639, 3, 2, 1, 0); \
+  int16x8_t __rev2_639;  __rev2_639 = __builtin_shufflevector(__s2_639, __s2_639, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_639 = __noswap_vqdmlal_s16(__rev0_639, __rev1_639, __noswap_splat_laneq_s16(__rev2_639, __p3_639)); \
+  __ret_639 = __builtin_shufflevector(__ret_639, __ret_639, 3, 2, 1, 0); \
+  __ret_639; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) int64_t vqdmlsls_s32(int64_t __p0, int32_t __p1, int32_t __p2) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vqdmlsls_s32(__p0, __p1, __p2);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqdmlslh_s16(int32_t __p0, int16_t __p1, int16_t __p2) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqdmlslh_s16(__p0, __p1, __p2);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int64x2_t __ret;
+  __ret = vqdmlsl_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vqdmlsl_s32(__rev0, __noswap_vget_high_s32(__rev1), __noswap_vget_high_s32(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int32x4_t __ret;
+  __ret = vqdmlsl_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vqdmlsl_s16(__rev0, __noswap_vget_high_s16(__rev1), __noswap_vget_high_s16(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_high_lane_s32(__p0_640, __p1_640, __p2_640, __p3_640) __extension__ ({ \
+  int64x2_t __ret_640; \
+  int64x2_t __s0_640 = __p0_640; \
+  int32x4_t __s1_640 = __p1_640; \
+  int32x2_t __s2_640 = __p2_640; \
+  __ret_640 = vqdmlsl_s32(__s0_640, vget_high_s32(__s1_640), splat_lane_s32(__s2_640, __p3_640)); \
+  __ret_640; \
+})
+#else
+#define vqdmlsl_high_lane_s32(__p0_641, __p1_641, __p2_641, __p3_641) __extension__ ({ \
+  int64x2_t __ret_641; \
+  int64x2_t __s0_641 = __p0_641; \
+  int32x4_t __s1_641 = __p1_641; \
+  int32x2_t __s2_641 = __p2_641; \
+  int64x2_t __rev0_641;  __rev0_641 = __builtin_shufflevector(__s0_641, __s0_641, 1, 0); \
+  int32x4_t __rev1_641;  __rev1_641 = __builtin_shufflevector(__s1_641, __s1_641, 3, 2, 1, 0); \
+  int32x2_t __rev2_641;  __rev2_641 = __builtin_shufflevector(__s2_641, __s2_641, 1, 0); \
+  __ret_641 = __noswap_vqdmlsl_s32(__rev0_641, __noswap_vget_high_s32(__rev1_641), __noswap_splat_lane_s32(__rev2_641, __p3_641)); \
+  __ret_641 = __builtin_shufflevector(__ret_641, __ret_641, 1, 0); \
+  __ret_641; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_high_lane_s16(__p0_642, __p1_642, __p2_642, __p3_642) __extension__ ({ \
+  int32x4_t __ret_642; \
+  int32x4_t __s0_642 = __p0_642; \
+  int16x8_t __s1_642 = __p1_642; \
+  int16x4_t __s2_642 = __p2_642; \
+  __ret_642 = vqdmlsl_s16(__s0_642, vget_high_s16(__s1_642), splat_lane_s16(__s2_642, __p3_642)); \
+  __ret_642; \
+})
+#else
+#define vqdmlsl_high_lane_s16(__p0_643, __p1_643, __p2_643, __p3_643) __extension__ ({ \
+  int32x4_t __ret_643; \
+  int32x4_t __s0_643 = __p0_643; \
+  int16x8_t __s1_643 = __p1_643; \
+  int16x4_t __s2_643 = __p2_643; \
+  int32x4_t __rev0_643;  __rev0_643 = __builtin_shufflevector(__s0_643, __s0_643, 3, 2, 1, 0); \
+  int16x8_t __rev1_643;  __rev1_643 = __builtin_shufflevector(__s1_643, __s1_643, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev2_643;  __rev2_643 = __builtin_shufflevector(__s2_643, __s2_643, 3, 2, 1, 0); \
+  __ret_643 = __noswap_vqdmlsl_s16(__rev0_643, __noswap_vget_high_s16(__rev1_643), __noswap_splat_lane_s16(__rev2_643, __p3_643)); \
+  __ret_643 = __builtin_shufflevector(__ret_643, __ret_643, 3, 2, 1, 0); \
+  __ret_643; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_high_laneq_s32(__p0_644, __p1_644, __p2_644, __p3_644) __extension__ ({ \
+  int64x2_t __ret_644; \
+  int64x2_t __s0_644 = __p0_644; \
+  int32x4_t __s1_644 = __p1_644; \
+  int32x4_t __s2_644 = __p2_644; \
+  __ret_644 = vqdmlsl_s32(__s0_644, vget_high_s32(__s1_644), splat_laneq_s32(__s2_644, __p3_644)); \
+  __ret_644; \
+})
+#else
+#define vqdmlsl_high_laneq_s32(__p0_645, __p1_645, __p2_645, __p3_645) __extension__ ({ \
+  int64x2_t __ret_645; \
+  int64x2_t __s0_645 = __p0_645; \
+  int32x4_t __s1_645 = __p1_645; \
+  int32x4_t __s2_645 = __p2_645; \
+  int64x2_t __rev0_645;  __rev0_645 = __builtin_shufflevector(__s0_645, __s0_645, 1, 0); \
+  int32x4_t __rev1_645;  __rev1_645 = __builtin_shufflevector(__s1_645, __s1_645, 3, 2, 1, 0); \
+  int32x4_t __rev2_645;  __rev2_645 = __builtin_shufflevector(__s2_645, __s2_645, 3, 2, 1, 0); \
+  __ret_645 = __noswap_vqdmlsl_s32(__rev0_645, __noswap_vget_high_s32(__rev1_645), __noswap_splat_laneq_s32(__rev2_645, __p3_645)); \
+  __ret_645 = __builtin_shufflevector(__ret_645, __ret_645, 1, 0); \
+  __ret_645; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_high_laneq_s16(__p0_646, __p1_646, __p2_646, __p3_646) __extension__ ({ \
+  int32x4_t __ret_646; \
+  int32x4_t __s0_646 = __p0_646; \
+  int16x8_t __s1_646 = __p1_646; \
+  int16x8_t __s2_646 = __p2_646; \
+  __ret_646 = vqdmlsl_s16(__s0_646, vget_high_s16(__s1_646), splat_laneq_s16(__s2_646, __p3_646)); \
+  __ret_646; \
+})
+#else
+#define vqdmlsl_high_laneq_s16(__p0_647, __p1_647, __p2_647, __p3_647) __extension__ ({ \
+  int32x4_t __ret_647; \
+  int32x4_t __s0_647 = __p0_647; \
+  int16x8_t __s1_647 = __p1_647; \
+  int16x8_t __s2_647 = __p2_647; \
+  int32x4_t __rev0_647;  __rev0_647 = __builtin_shufflevector(__s0_647, __s0_647, 3, 2, 1, 0); \
+  int16x8_t __rev1_647;  __rev1_647 = __builtin_shufflevector(__s1_647, __s1_647, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev2_647;  __rev2_647 = __builtin_shufflevector(__s2_647, __s2_647, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_647 = __noswap_vqdmlsl_s16(__rev0_647, __noswap_vget_high_s16(__rev1_647), __noswap_splat_laneq_s16(__rev2_647, __p3_647)); \
+  __ret_647 = __builtin_shufflevector(__ret_647, __ret_647, 3, 2, 1, 0); \
+  __ret_647; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = vqdmlsl_n_s32(__p0, vget_high_s32(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vqdmlsl_n_s32(__rev0, __noswap_vget_high_s32(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = vqdmlsl_n_s16(__p0, vget_high_s16(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vqdmlsl_n_s16(__rev0, __noswap_vget_high_s16(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsls_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int32_t __s1 = __p1; \
+  int32x2_t __s2 = __p2; \
+  __ret = (int64_t) __builtin_neon_vqdmlsls_lane_s32(__s0, __s1, __s2, __p3); \
+  __ret; \
+})
+#else
+#define vqdmlsls_lane_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int32_t __s1 = __p1; \
+  int32x2_t __s2 = __p2; \
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 1, 0); \
+  __ret = (int64_t) __builtin_neon_vqdmlsls_lane_s32(__s0, __s1, __rev2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlslh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int32_t __ret; \
+  int32_t __s0 = __p0; \
+  int16_t __s1 = __p1; \
+  int16x4_t __s2 = __p2; \
+  __ret = (int32_t) __builtin_neon_vqdmlslh_lane_s16(__s0, __s1, __s2, __p3); \
+  __ret; \
+})
+#else
+#define vqdmlslh_lane_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int32_t __ret; \
+  int32_t __s0 = __p0; \
+  int16_t __s1 = __p1; \
+  int16x4_t __s2 = __p2; \
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (int32_t) __builtin_neon_vqdmlslh_lane_s16(__s0, __s1, __rev2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsls_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int32_t __s1 = __p1; \
+  int32x4_t __s2 = __p2; \
+  __ret = (int64_t) __builtin_neon_vqdmlsls_laneq_s32(__s0, __s1, __s2, __p3); \
+  __ret; \
+})
+#else
+#define vqdmlsls_laneq_s32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int32_t __s1 = __p1; \
+  int32x4_t __s2 = __p2; \
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (int64_t) __builtin_neon_vqdmlsls_laneq_s32(__s0, __s1, __rev2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlslh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int32_t __ret; \
+  int32_t __s0 = __p0; \
+  int16_t __s1 = __p1; \
+  int16x8_t __s2 = __p2; \
+  __ret = (int32_t) __builtin_neon_vqdmlslh_laneq_s16(__s0, __s1, __s2, __p3); \
+  __ret; \
+})
+#else
+#define vqdmlslh_laneq_s16(__p0, __p1, __p2, __p3) __extension__ ({ \
+  int32_t __ret; \
+  int32_t __s0 = __p0; \
+  int16_t __s1 = __p1; \
+  int16x8_t __s2 = __p2; \
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int32_t) __builtin_neon_vqdmlslh_laneq_s16(__s0, __s1, __rev2, __p3); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_laneq_s32(__p0_648, __p1_648, __p2_648, __p3_648) __extension__ ({ \
+  int64x2_t __ret_648; \
+  int64x2_t __s0_648 = __p0_648; \
+  int32x2_t __s1_648 = __p1_648; \
+  int32x4_t __s2_648 = __p2_648; \
+  __ret_648 = vqdmlsl_s32(__s0_648, __s1_648, splat_laneq_s32(__s2_648, __p3_648)); \
+  __ret_648; \
+})
+#else
+#define vqdmlsl_laneq_s32(__p0_649, __p1_649, __p2_649, __p3_649) __extension__ ({ \
+  int64x2_t __ret_649; \
+  int64x2_t __s0_649 = __p0_649; \
+  int32x2_t __s1_649 = __p1_649; \
+  int32x4_t __s2_649 = __p2_649; \
+  int64x2_t __rev0_649;  __rev0_649 = __builtin_shufflevector(__s0_649, __s0_649, 1, 0); \
+  int32x2_t __rev1_649;  __rev1_649 = __builtin_shufflevector(__s1_649, __s1_649, 1, 0); \
+  int32x4_t __rev2_649;  __rev2_649 = __builtin_shufflevector(__s2_649, __s2_649, 3, 2, 1, 0); \
+  __ret_649 = __noswap_vqdmlsl_s32(__rev0_649, __rev1_649, __noswap_splat_laneq_s32(__rev2_649, __p3_649)); \
+  __ret_649 = __builtin_shufflevector(__ret_649, __ret_649, 1, 0); \
+  __ret_649; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmlsl_laneq_s16(__p0_650, __p1_650, __p2_650, __p3_650) __extension__ ({ \
+  int32x4_t __ret_650; \
+  int32x4_t __s0_650 = __p0_650; \
+  int16x4_t __s1_650 = __p1_650; \
+  int16x8_t __s2_650 = __p2_650; \
+  __ret_650 = vqdmlsl_s16(__s0_650, __s1_650, splat_laneq_s16(__s2_650, __p3_650)); \
+  __ret_650; \
+})
+#else
+#define vqdmlsl_laneq_s16(__p0_651, __p1_651, __p2_651, __p3_651) __extension__ ({ \
+  int32x4_t __ret_651; \
+  int32x4_t __s0_651 = __p0_651; \
+  int16x4_t __s1_651 = __p1_651; \
+  int16x8_t __s2_651 = __p2_651; \
+  int32x4_t __rev0_651;  __rev0_651 = __builtin_shufflevector(__s0_651, __s0_651, 3, 2, 1, 0); \
+  int16x4_t __rev1_651;  __rev1_651 = __builtin_shufflevector(__s1_651, __s1_651, 3, 2, 1, 0); \
+  int16x8_t __rev2_651;  __rev2_651 = __builtin_shufflevector(__s2_651, __s2_651, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_651 = __noswap_vqdmlsl_s16(__rev0_651, __rev1_651, __noswap_splat_laneq_s16(__rev2_651, __p3_651)); \
+  __ret_651 = __builtin_shufflevector(__ret_651, __ret_651, 3, 2, 1, 0); \
+  __ret_651; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) int32_t vqdmulhs_s32(int32_t __p0, int32_t __p1) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqdmulhs_s32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqdmulhh_s16(int16_t __p0, int16_t __p1) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqdmulhh_s16(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vqdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vqdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vqdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vqdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vqdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vqdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhs_lane_s32(__p0_652, __p1_652, __p2_652) __extension__ ({ \
+  int32_t __ret_652; \
+  int32_t __s0_652 = __p0_652; \
+  int32x2_t __s1_652 = __p1_652; \
+  __ret_652 = vqdmulhs_s32(__s0_652, vget_lane_s32(__s1_652, __p2_652)); \
+  __ret_652; \
+})
+#else
+#define vqdmulhs_lane_s32(__p0_653, __p1_653, __p2_653) __extension__ ({ \
+  int32_t __ret_653; \
+  int32_t __s0_653 = __p0_653; \
+  int32x2_t __s1_653 = __p1_653; \
+  int32x2_t __rev1_653;  __rev1_653 = __builtin_shufflevector(__s1_653, __s1_653, 1, 0); \
+  __ret_653 = vqdmulhs_s32(__s0_653, __noswap_vget_lane_s32(__rev1_653, __p2_653)); \
+  __ret_653; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhh_lane_s16(__p0_654, __p1_654, __p2_654) __extension__ ({ \
+  int16_t __ret_654; \
+  int16_t __s0_654 = __p0_654; \
+  int16x4_t __s1_654 = __p1_654; \
+  __ret_654 = vqdmulhh_s16(__s0_654, vget_lane_s16(__s1_654, __p2_654)); \
+  __ret_654; \
+})
+#else
+#define vqdmulhh_lane_s16(__p0_655, __p1_655, __p2_655) __extension__ ({ \
+  int16_t __ret_655; \
+  int16_t __s0_655 = __p0_655; \
+  int16x4_t __s1_655 = __p1_655; \
+  int16x4_t __rev1_655;  __rev1_655 = __builtin_shufflevector(__s1_655, __s1_655, 3, 2, 1, 0); \
+  __ret_655 = vqdmulhh_s16(__s0_655, __noswap_vget_lane_s16(__rev1_655, __p2_655)); \
+  __ret_655; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhs_laneq_s32(__p0_656, __p1_656, __p2_656) __extension__ ({ \
+  int32_t __ret_656; \
+  int32_t __s0_656 = __p0_656; \
+  int32x4_t __s1_656 = __p1_656; \
+  __ret_656 = vqdmulhs_s32(__s0_656, vgetq_lane_s32(__s1_656, __p2_656)); \
+  __ret_656; \
+})
+#else
+#define vqdmulhs_laneq_s32(__p0_657, __p1_657, __p2_657) __extension__ ({ \
+  int32_t __ret_657; \
+  int32_t __s0_657 = __p0_657; \
+  int32x4_t __s1_657 = __p1_657; \
+  int32x4_t __rev1_657;  __rev1_657 = __builtin_shufflevector(__s1_657, __s1_657, 3, 2, 1, 0); \
+  __ret_657 = vqdmulhs_s32(__s0_657, __noswap_vgetq_lane_s32(__rev1_657, __p2_657)); \
+  __ret_657; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhh_laneq_s16(__p0_658, __p1_658, __p2_658) __extension__ ({ \
+  int16_t __ret_658; \
+  int16_t __s0_658 = __p0_658; \
+  int16x8_t __s1_658 = __p1_658; \
+  __ret_658 = vqdmulhh_s16(__s0_658, vgetq_lane_s16(__s1_658, __p2_658)); \
+  __ret_658; \
+})
+#else
+#define vqdmulhh_laneq_s16(__p0_659, __p1_659, __p2_659) __extension__ ({ \
+  int16_t __ret_659; \
+  int16_t __s0_659 = __p0_659; \
+  int16x8_t __s1_659 = __p1_659; \
+  int16x8_t __rev1_659;  __rev1_659 = __builtin_shufflevector(__s1_659, __s1_659, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_659 = vqdmulhh_s16(__s0_659, __noswap_vgetq_lane_s16(__rev1_659, __p2_659)); \
+  __ret_659; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+  __ret; \
+})
+#else
+#define vqdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+  __ret; \
+})
+#else
+#define vqdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vqdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vqdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vqdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vqdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) int64_t vqdmulls_s32(int32_t __p0, int32_t __p1) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vqdmulls_s32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqdmullh_s16(int16_t __p0, int16_t __p1) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqdmullh_s16(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  __ret = vqdmull_s32(vget_high_s32(__p0), vget_high_s32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_high_s32(int32x4_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vqdmull_s32(__noswap_vget_high_s32(__rev0), __noswap_vget_high_s32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  __ret = vqdmull_s16(vget_high_s16(__p0), vget_high_s16(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_high_s16(int16x8_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vqdmull_s16(__noswap_vget_high_s16(__rev0), __noswap_vget_high_s16(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmull_high_lane_s32(__p0_660, __p1_660, __p2_660) __extension__ ({ \
+  int64x2_t __ret_660; \
+  int32x4_t __s0_660 = __p0_660; \
+  int32x2_t __s1_660 = __p1_660; \
+  __ret_660 = vqdmull_s32(vget_high_s32(__s0_660), splat_lane_s32(__s1_660, __p2_660)); \
+  __ret_660; \
+})
+#else
+#define vqdmull_high_lane_s32(__p0_661, __p1_661, __p2_661) __extension__ ({ \
+  int64x2_t __ret_661; \
+  int32x4_t __s0_661 = __p0_661; \
+  int32x2_t __s1_661 = __p1_661; \
+  int32x4_t __rev0_661;  __rev0_661 = __builtin_shufflevector(__s0_661, __s0_661, 3, 2, 1, 0); \
+  int32x2_t __rev1_661;  __rev1_661 = __builtin_shufflevector(__s1_661, __s1_661, 1, 0); \
+  __ret_661 = __noswap_vqdmull_s32(__noswap_vget_high_s32(__rev0_661), __noswap_splat_lane_s32(__rev1_661, __p2_661)); \
+  __ret_661 = __builtin_shufflevector(__ret_661, __ret_661, 1, 0); \
+  __ret_661; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmull_high_lane_s16(__p0_662, __p1_662, __p2_662) __extension__ ({ \
+  int32x4_t __ret_662; \
+  int16x8_t __s0_662 = __p0_662; \
+  int16x4_t __s1_662 = __p1_662; \
+  __ret_662 = vqdmull_s16(vget_high_s16(__s0_662), splat_lane_s16(__s1_662, __p2_662)); \
+  __ret_662; \
+})
+#else
+#define vqdmull_high_lane_s16(__p0_663, __p1_663, __p2_663) __extension__ ({ \
+  int32x4_t __ret_663; \
+  int16x8_t __s0_663 = __p0_663; \
+  int16x4_t __s1_663 = __p1_663; \
+  int16x8_t __rev0_663;  __rev0_663 = __builtin_shufflevector(__s0_663, __s0_663, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev1_663;  __rev1_663 = __builtin_shufflevector(__s1_663, __s1_663, 3, 2, 1, 0); \
+  __ret_663 = __noswap_vqdmull_s16(__noswap_vget_high_s16(__rev0_663), __noswap_splat_lane_s16(__rev1_663, __p2_663)); \
+  __ret_663 = __builtin_shufflevector(__ret_663, __ret_663, 3, 2, 1, 0); \
+  __ret_663; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmull_high_laneq_s32(__p0_664, __p1_664, __p2_664) __extension__ ({ \
+  int64x2_t __ret_664; \
+  int32x4_t __s0_664 = __p0_664; \
+  int32x4_t __s1_664 = __p1_664; \
+  __ret_664 = vqdmull_s32(vget_high_s32(__s0_664), splat_laneq_s32(__s1_664, __p2_664)); \
+  __ret_664; \
+})
+#else
+#define vqdmull_high_laneq_s32(__p0_665, __p1_665, __p2_665) __extension__ ({ \
+  int64x2_t __ret_665; \
+  int32x4_t __s0_665 = __p0_665; \
+  int32x4_t __s1_665 = __p1_665; \
+  int32x4_t __rev0_665;  __rev0_665 = __builtin_shufflevector(__s0_665, __s0_665, 3, 2, 1, 0); \
+  int32x4_t __rev1_665;  __rev1_665 = __builtin_shufflevector(__s1_665, __s1_665, 3, 2, 1, 0); \
+  __ret_665 = __noswap_vqdmull_s32(__noswap_vget_high_s32(__rev0_665), __noswap_splat_laneq_s32(__rev1_665, __p2_665)); \
+  __ret_665 = __builtin_shufflevector(__ret_665, __ret_665, 1, 0); \
+  __ret_665; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmull_high_laneq_s16(__p0_666, __p1_666, __p2_666) __extension__ ({ \
+  int32x4_t __ret_666; \
+  int16x8_t __s0_666 = __p0_666; \
+  int16x8_t __s1_666 = __p1_666; \
+  __ret_666 = vqdmull_s16(vget_high_s16(__s0_666), splat_laneq_s16(__s1_666, __p2_666)); \
+  __ret_666; \
+})
+#else
+#define vqdmull_high_laneq_s16(__p0_667, __p1_667, __p2_667) __extension__ ({ \
+  int32x4_t __ret_667; \
+  int16x8_t __s0_667 = __p0_667; \
+  int16x8_t __s1_667 = __p1_667; \
+  int16x8_t __rev0_667;  __rev0_667 = __builtin_shufflevector(__s0_667, __s0_667, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_667;  __rev1_667 = __builtin_shufflevector(__s1_667, __s1_667, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_667 = __noswap_vqdmull_s16(__noswap_vget_high_s16(__rev0_667), __noswap_splat_laneq_s16(__rev1_667, __p2_667)); \
+  __ret_667 = __builtin_shufflevector(__ret_667, __ret_667, 3, 2, 1, 0); \
+  __ret_667; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
+  int64x2_t __ret;
+  __ret = vqdmull_n_s32(vget_high_s32(__p0), __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqdmull_high_n_s32(int32x4_t __p0, int32_t __p1) {
+  int64x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = __noswap_vqdmull_n_s32(__noswap_vget_high_s32(__rev0), __p1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
+  int32x4_t __ret;
+  __ret = vqdmull_n_s16(vget_high_s16(__p0), __p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqdmull_high_n_s16(int16x8_t __p0, int16_t __p1) {
+  int32x4_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vqdmull_n_s16(__noswap_vget_high_s16(__rev0), __p1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulls_lane_s32(__p0_668, __p1_668, __p2_668) __extension__ ({ \
+  int64_t __ret_668; \
+  int32_t __s0_668 = __p0_668; \
+  int32x2_t __s1_668 = __p1_668; \
+  __ret_668 = vqdmulls_s32(__s0_668, vget_lane_s32(__s1_668, __p2_668)); \
+  __ret_668; \
+})
+#else
+#define vqdmulls_lane_s32(__p0_669, __p1_669, __p2_669) __extension__ ({ \
+  int64_t __ret_669; \
+  int32_t __s0_669 = __p0_669; \
+  int32x2_t __s1_669 = __p1_669; \
+  int32x2_t __rev1_669;  __rev1_669 = __builtin_shufflevector(__s1_669, __s1_669, 1, 0); \
+  __ret_669 = vqdmulls_s32(__s0_669, __noswap_vget_lane_s32(__rev1_669, __p2_669)); \
+  __ret_669; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmullh_lane_s16(__p0_670, __p1_670, __p2_670) __extension__ ({ \
+  int32_t __ret_670; \
+  int16_t __s0_670 = __p0_670; \
+  int16x4_t __s1_670 = __p1_670; \
+  __ret_670 = vqdmullh_s16(__s0_670, vget_lane_s16(__s1_670, __p2_670)); \
+  __ret_670; \
+})
+#else
+#define vqdmullh_lane_s16(__p0_671, __p1_671, __p2_671) __extension__ ({ \
+  int32_t __ret_671; \
+  int16_t __s0_671 = __p0_671; \
+  int16x4_t __s1_671 = __p1_671; \
+  int16x4_t __rev1_671;  __rev1_671 = __builtin_shufflevector(__s1_671, __s1_671, 3, 2, 1, 0); \
+  __ret_671 = vqdmullh_s16(__s0_671, __noswap_vget_lane_s16(__rev1_671, __p2_671)); \
+  __ret_671; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmulls_laneq_s32(__p0_672, __p1_672, __p2_672) __extension__ ({ \
+  int64_t __ret_672; \
+  int32_t __s0_672 = __p0_672; \
+  int32x4_t __s1_672 = __p1_672; \
+  __ret_672 = vqdmulls_s32(__s0_672, vgetq_lane_s32(__s1_672, __p2_672)); \
+  __ret_672; \
+})
+#else
+#define vqdmulls_laneq_s32(__p0_673, __p1_673, __p2_673) __extension__ ({ \
+  int64_t __ret_673; \
+  int32_t __s0_673 = __p0_673; \
+  int32x4_t __s1_673 = __p1_673; \
+  int32x4_t __rev1_673;  __rev1_673 = __builtin_shufflevector(__s1_673, __s1_673, 3, 2, 1, 0); \
+  __ret_673 = vqdmulls_s32(__s0_673, __noswap_vgetq_lane_s32(__rev1_673, __p2_673)); \
+  __ret_673; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmullh_laneq_s16(__p0_674, __p1_674, __p2_674) __extension__ ({ \
+  int32_t __ret_674; \
+  int16_t __s0_674 = __p0_674; \
+  int16x8_t __s1_674 = __p1_674; \
+  __ret_674 = vqdmullh_s16(__s0_674, vgetq_lane_s16(__s1_674, __p2_674)); \
+  __ret_674; \
+})
+#else
+#define vqdmullh_laneq_s16(__p0_675, __p1_675, __p2_675) __extension__ ({ \
+  int32_t __ret_675; \
+  int16_t __s0_675 = __p0_675; \
+  int16x8_t __s1_675 = __p1_675; \
+  int16x8_t __rev1_675;  __rev1_675 = __builtin_shufflevector(__s1_675, __s1_675, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_675 = vqdmullh_s16(__s0_675, __noswap_vgetq_lane_s16(__rev1_675, __p2_675)); \
+  __ret_675; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmull_laneq_s32(__p0_676, __p1_676, __p2_676) __extension__ ({ \
+  int64x2_t __ret_676; \
+  int32x2_t __s0_676 = __p0_676; \
+  int32x4_t __s1_676 = __p1_676; \
+  __ret_676 = vqdmull_s32(__s0_676, splat_laneq_s32(__s1_676, __p2_676)); \
+  __ret_676; \
+})
+#else
+#define vqdmull_laneq_s32(__p0_677, __p1_677, __p2_677) __extension__ ({ \
+  int64x2_t __ret_677; \
+  int32x2_t __s0_677 = __p0_677; \
+  int32x4_t __s1_677 = __p1_677; \
+  int32x2_t __rev0_677;  __rev0_677 = __builtin_shufflevector(__s0_677, __s0_677, 1, 0); \
+  int32x4_t __rev1_677;  __rev1_677 = __builtin_shufflevector(__s1_677, __s1_677, 3, 2, 1, 0); \
+  __ret_677 = __noswap_vqdmull_s32(__rev0_677, __noswap_splat_laneq_s32(__rev1_677, __p2_677)); \
+  __ret_677 = __builtin_shufflevector(__ret_677, __ret_677, 1, 0); \
+  __ret_677; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqdmull_laneq_s16(__p0_678, __p1_678, __p2_678) __extension__ ({ \
+  int32x4_t __ret_678; \
+  int16x4_t __s0_678 = __p0_678; \
+  int16x8_t __s1_678 = __p1_678; \
+  __ret_678 = vqdmull_s16(__s0_678, splat_laneq_s16(__s1_678, __p2_678)); \
+  __ret_678; \
+})
+#else
+#define vqdmull_laneq_s16(__p0_679, __p1_679, __p2_679) __extension__ ({ \
+  int32x4_t __ret_679; \
+  int16x4_t __s0_679 = __p0_679; \
+  int16x8_t __s1_679 = __p1_679; \
+  int16x4_t __rev0_679;  __rev0_679 = __builtin_shufflevector(__s0_679, __s0_679, 3, 2, 1, 0); \
+  int16x8_t __rev1_679;  __rev1_679 = __builtin_shufflevector(__s1_679, __s1_679, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_679 = __noswap_vqdmull_s16(__rev0_679, __noswap_splat_laneq_s16(__rev1_679, __p2_679)); \
+  __ret_679 = __builtin_shufflevector(__ret_679, __ret_679, 3, 2, 1, 0); \
+  __ret_679; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) int16_t vqmovns_s32(int32_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqmovns_s32(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqmovnd_s64(int64_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqmovnd_s64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vqmovnh_s16(int16_t __p0) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vqmovnh_s16(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16_t vqmovns_u32(uint32_t __p0) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vqmovns_u32(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vqmovnd_u64(uint64_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vqmovnd_u64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8_t vqmovnh_u16(uint16_t __p0) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vqmovnh_u16(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vqmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
+  uint16x8_t __ret;
+  __ret = vcombine_u16(__p0, vqmovn_u32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vqmovn_high_u32(uint16x4_t __p0, uint32x4_t __p1) {
+  uint16x8_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u16(__rev0, __noswap_vqmovn_u32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vqmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
+  uint32x4_t __ret;
+  __ret = vcombine_u32(__p0, vqmovn_u64(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vqmovn_high_u64(uint32x2_t __p0, uint64x2_t __p1) {
+  uint32x4_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vcombine_u32(__rev0, __noswap_vqmovn_u64(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
+  uint8x16_t __ret;
+  __ret = vcombine_u8(__p0, vqmovn_u16(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqmovn_high_u16(uint8x8_t __p0, uint16x8_t __p1) {
+  uint8x16_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u8(__rev0, __noswap_vqmovn_u16(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vqmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
+  int16x8_t __ret;
+  __ret = vcombine_s16(__p0, vqmovn_s32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vqmovn_high_s32(int16x4_t __p0, int32x4_t __p1) {
+  int16x8_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s16(__rev0, __noswap_vqmovn_s32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vqmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
+  int32x4_t __ret;
+  __ret = vcombine_s32(__p0, vqmovn_s64(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vqmovn_high_s64(int32x2_t __p0, int64x2_t __p1) {
+  int32x4_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vcombine_s32(__rev0, __noswap_vqmovn_s64(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
+  int8x16_t __ret;
+  __ret = vcombine_s8(__p0, vqmovn_s16(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqmovn_high_s16(int8x8_t __p0, int16x8_t __p1) {
+  int8x16_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s8(__rev0, __noswap_vqmovn_s16(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint16_t vqmovuns_s32(int32_t __p0) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vqmovuns_s32(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vqmovund_s64(int64_t __p0) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vqmovund_s64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8_t vqmovunh_s16(int16_t __p0) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vqmovunh_s16(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vqmovun_high_s32(uint16x4_t __p0, int32x4_t __p1) {
+  uint16x8_t __ret;
+  __ret = vcombine_u16((uint16x4_t)(__p0), vqmovun_s32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vqmovun_high_s32(uint16x4_t __p0, int32x4_t __p1) {
+  uint16x8_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u16((uint16x4_t)(__rev0), __noswap_vqmovun_s32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vqmovun_high_s64(uint32x2_t __p0, int64x2_t __p1) {
+  uint32x4_t __ret;
+  __ret = vcombine_u32((uint32x2_t)(__p0), vqmovun_s64(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vqmovun_high_s64(uint32x2_t __p0, int64x2_t __p1) {
+  uint32x4_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vcombine_u32((uint32x2_t)(__rev0), __noswap_vqmovun_s64(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqmovun_high_s16(uint8x8_t __p0, int16x8_t __p1) {
+  uint8x16_t __ret;
+  __ret = vcombine_u8((uint8x8_t)(__p0), vqmovun_s16(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqmovun_high_s16(uint8x8_t __p0, int16x8_t __p1) {
+  uint8x16_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u8((uint8x8_t)(__rev0), __noswap_vqmovun_s16(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vqnegq_s64(int64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vqnegq_v((int8x16_t)__p0, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vqnegq_s64(int64x2_t __p0) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vqnegq_v((int8x16_t)__rev0, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vqneg_s64(int64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vqneg_v((int8x8_t)__p0, 3);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vqnegb_s8(int8_t __p0) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vqnegb_s8(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqnegs_s32(int32_t __p0) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqnegs_s32(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqnegd_s64(int64_t __p0) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vqnegd_s64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqnegh_s16(int16_t __p0) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqnegh_s16(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqrdmulhs_s32(int32_t __p0, int32_t __p1) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqrdmulhs_s32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqrdmulhh_s16(int16_t __p0, int16_t __p1) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqrdmulhh_s16(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vqrdmulhq_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__s0, (int8x8_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vqrdmulhq_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vqrdmulhq_lane_v((int8x16_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vqrdmulh_lane_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x2_t __s1 = __p1; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vqrdmulh_lane_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x4_t __s1 = __p1; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vqrdmulh_lane_v((int8x8_t)__rev0, (int8x8_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulhs_lane_s32(__p0_680, __p1_680, __p2_680) __extension__ ({ \
+  int32_t __ret_680; \
+  int32_t __s0_680 = __p0_680; \
+  int32x2_t __s1_680 = __p1_680; \
+  __ret_680 = vqrdmulhs_s32(__s0_680, vget_lane_s32(__s1_680, __p2_680)); \
+  __ret_680; \
+})
+#else
+#define vqrdmulhs_lane_s32(__p0_681, __p1_681, __p2_681) __extension__ ({ \
+  int32_t __ret_681; \
+  int32_t __s0_681 = __p0_681; \
+  int32x2_t __s1_681 = __p1_681; \
+  int32x2_t __rev1_681;  __rev1_681 = __builtin_shufflevector(__s1_681, __s1_681, 1, 0); \
+  __ret_681 = vqrdmulhs_s32(__s0_681, __noswap_vget_lane_s32(__rev1_681, __p2_681)); \
+  __ret_681; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulhh_lane_s16(__p0_682, __p1_682, __p2_682) __extension__ ({ \
+  int16_t __ret_682; \
+  int16_t __s0_682 = __p0_682; \
+  int16x4_t __s1_682 = __p1_682; \
+  __ret_682 = vqrdmulhh_s16(__s0_682, vget_lane_s16(__s1_682, __p2_682)); \
+  __ret_682; \
+})
+#else
+#define vqrdmulhh_lane_s16(__p0_683, __p1_683, __p2_683) __extension__ ({ \
+  int16_t __ret_683; \
+  int16_t __s0_683 = __p0_683; \
+  int16x4_t __s1_683 = __p1_683; \
+  int16x4_t __rev1_683;  __rev1_683 = __builtin_shufflevector(__s1_683, __s1_683, 3, 2, 1, 0); \
+  __ret_683 = vqrdmulhh_s16(__s0_683, __noswap_vget_lane_s16(__rev1_683, __p2_683)); \
+  __ret_683; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulhs_laneq_s32(__p0_684, __p1_684, __p2_684) __extension__ ({ \
+  int32_t __ret_684; \
+  int32_t __s0_684 = __p0_684; \
+  int32x4_t __s1_684 = __p1_684; \
+  __ret_684 = vqrdmulhs_s32(__s0_684, vgetq_lane_s32(__s1_684, __p2_684)); \
+  __ret_684; \
+})
+#else
+#define vqrdmulhs_laneq_s32(__p0_685, __p1_685, __p2_685) __extension__ ({ \
+  int32_t __ret_685; \
+  int32_t __s0_685 = __p0_685; \
+  int32x4_t __s1_685 = __p1_685; \
+  int32x4_t __rev1_685;  __rev1_685 = __builtin_shufflevector(__s1_685, __s1_685, 3, 2, 1, 0); \
+  __ret_685 = vqrdmulhs_s32(__s0_685, __noswap_vgetq_lane_s32(__rev1_685, __p2_685)); \
+  __ret_685; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulhh_laneq_s16(__p0_686, __p1_686, __p2_686) __extension__ ({ \
+  int16_t __ret_686; \
+  int16_t __s0_686 = __p0_686; \
+  int16x8_t __s1_686 = __p1_686; \
+  __ret_686 = vqrdmulhh_s16(__s0_686, vgetq_lane_s16(__s1_686, __p2_686)); \
+  __ret_686; \
+})
+#else
+#define vqrdmulhh_laneq_s16(__p0_687, __p1_687, __p2_687) __extension__ ({ \
+  int16_t __ret_687; \
+  int16_t __s0_687 = __p0_687; \
+  int16x8_t __s1_687 = __p1_687; \
+  int16x8_t __rev1_687;  __rev1_687 = __builtin_shufflevector(__s1_687, __s1_687, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_687 = vqrdmulhh_s16(__s0_687, __noswap_vgetq_lane_s16(__rev1_687, __p2_687)); \
+  __ret_687; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x4_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 34); \
+  __ret; \
+})
+#else
+#define vqrdmulhq_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x4_t __ret; \
+  int32x4_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x4_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 34); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x8_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 33); \
+  __ret; \
+})
+#else
+#define vqrdmulhq_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x8_t __ret; \
+  int16x8_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x8_t) __builtin_neon_vqrdmulhq_laneq_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 33); \
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  __ret = (int32x2_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 2); \
+  __ret; \
+})
+#else
+#define vqrdmulh_laneq_s32(__p0, __p1, __p2) __extension__ ({ \
+  int32x2_t __ret; \
+  int32x2_t __s0 = __p0; \
+  int32x4_t __s1 = __p1; \
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  __ret = (int32x2_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  __ret = (int16x4_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__s0, (int8x16_t)__s1, __p2, 1); \
+  __ret; \
+})
+#else
+#define vqrdmulh_laneq_s16(__p0, __p1, __p2) __extension__ ({ \
+  int16x4_t __ret; \
+  int16x4_t __s0 = __p0; \
+  int16x8_t __s1 = __p1; \
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret = (int16x4_t) __builtin_neon_vqrdmulh_laneq_v((int8x8_t)__rev0, (int8x16_t)__rev1, __p2, 1); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) uint8_t vqrshlb_u8(uint8_t __p0, int8_t __p1) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vqrshlb_u8(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vqrshls_u32(uint32_t __p0, int32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vqrshls_u32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vqrshld_u64(uint64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vqrshld_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16_t vqrshlh_u16(uint16_t __p0, int16_t __p1) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vqrshlh_u16(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vqrshlb_s8(int8_t __p0, int8_t __p1) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vqrshlb_s8(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqrshls_s32(int32_t __p0, int32_t __p1) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqrshls_s32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqrshld_s64(int64_t __p0, int64_t __p1) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vqrshld_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqrshlh_s16(int16_t __p0, int16_t __p1) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqrshlh_s16(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_high_n_u32(__p0_688, __p1_688, __p2_688) __extension__ ({ \
+  uint16x8_t __ret_688; \
+  uint16x4_t __s0_688 = __p0_688; \
+  uint32x4_t __s1_688 = __p1_688; \
+  __ret_688 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_688), (uint16x4_t)(vqrshrn_n_u32(__s1_688, __p2_688)))); \
+  __ret_688; \
+})
+#else
+#define vqrshrn_high_n_u32(__p0_689, __p1_689, __p2_689) __extension__ ({ \
+  uint16x8_t __ret_689; \
+  uint16x4_t __s0_689 = __p0_689; \
+  uint32x4_t __s1_689 = __p1_689; \
+  uint16x4_t __rev0_689;  __rev0_689 = __builtin_shufflevector(__s0_689, __s0_689, 3, 2, 1, 0); \
+  uint32x4_t __rev1_689;  __rev1_689 = __builtin_shufflevector(__s1_689, __s1_689, 3, 2, 1, 0); \
+  __ret_689 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_689), (uint16x4_t)(__noswap_vqrshrn_n_u32(__rev1_689, __p2_689)))); \
+  __ret_689 = __builtin_shufflevector(__ret_689, __ret_689, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_689; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_high_n_u64(__p0_690, __p1_690, __p2_690) __extension__ ({ \
+  uint32x4_t __ret_690; \
+  uint32x2_t __s0_690 = __p0_690; \
+  uint64x2_t __s1_690 = __p1_690; \
+  __ret_690 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_690), (uint32x2_t)(vqrshrn_n_u64(__s1_690, __p2_690)))); \
+  __ret_690; \
+})
+#else
+#define vqrshrn_high_n_u64(__p0_691, __p1_691, __p2_691) __extension__ ({ \
+  uint32x4_t __ret_691; \
+  uint32x2_t __s0_691 = __p0_691; \
+  uint64x2_t __s1_691 = __p1_691; \
+  uint32x2_t __rev0_691;  __rev0_691 = __builtin_shufflevector(__s0_691, __s0_691, 1, 0); \
+  uint64x2_t __rev1_691;  __rev1_691 = __builtin_shufflevector(__s1_691, __s1_691, 1, 0); \
+  __ret_691 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_691), (uint32x2_t)(__noswap_vqrshrn_n_u64(__rev1_691, __p2_691)))); \
+  __ret_691 = __builtin_shufflevector(__ret_691, __ret_691, 3, 2, 1, 0); \
+  __ret_691; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_high_n_u16(__p0_692, __p1_692, __p2_692) __extension__ ({ \
+  uint8x16_t __ret_692; \
+  uint8x8_t __s0_692 = __p0_692; \
+  uint16x8_t __s1_692 = __p1_692; \
+  __ret_692 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_692), (uint8x8_t)(vqrshrn_n_u16(__s1_692, __p2_692)))); \
+  __ret_692; \
+})
+#else
+#define vqrshrn_high_n_u16(__p0_693, __p1_693, __p2_693) __extension__ ({ \
+  uint8x16_t __ret_693; \
+  uint8x8_t __s0_693 = __p0_693; \
+  uint16x8_t __s1_693 = __p1_693; \
+  uint8x8_t __rev0_693;  __rev0_693 = __builtin_shufflevector(__s0_693, __s0_693, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1_693;  __rev1_693 = __builtin_shufflevector(__s1_693, __s1_693, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_693 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_693), (uint8x8_t)(__noswap_vqrshrn_n_u16(__rev1_693, __p2_693)))); \
+  __ret_693 = __builtin_shufflevector(__ret_693, __ret_693, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_693; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_high_n_s32(__p0_694, __p1_694, __p2_694) __extension__ ({ \
+  int16x8_t __ret_694; \
+  int16x4_t __s0_694 = __p0_694; \
+  int32x4_t __s1_694 = __p1_694; \
+  __ret_694 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_694), (int16x4_t)(vqrshrn_n_s32(__s1_694, __p2_694)))); \
+  __ret_694; \
+})
+#else
+#define vqrshrn_high_n_s32(__p0_695, __p1_695, __p2_695) __extension__ ({ \
+  int16x8_t __ret_695; \
+  int16x4_t __s0_695 = __p0_695; \
+  int32x4_t __s1_695 = __p1_695; \
+  int16x4_t __rev0_695;  __rev0_695 = __builtin_shufflevector(__s0_695, __s0_695, 3, 2, 1, 0); \
+  int32x4_t __rev1_695;  __rev1_695 = __builtin_shufflevector(__s1_695, __s1_695, 3, 2, 1, 0); \
+  __ret_695 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_695), (int16x4_t)(__noswap_vqrshrn_n_s32(__rev1_695, __p2_695)))); \
+  __ret_695 = __builtin_shufflevector(__ret_695, __ret_695, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_695; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_high_n_s64(__p0_696, __p1_696, __p2_696) __extension__ ({ \
+  int32x4_t __ret_696; \
+  int32x2_t __s0_696 = __p0_696; \
+  int64x2_t __s1_696 = __p1_696; \
+  __ret_696 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_696), (int32x2_t)(vqrshrn_n_s64(__s1_696, __p2_696)))); \
+  __ret_696; \
+})
+#else
+#define vqrshrn_high_n_s64(__p0_697, __p1_697, __p2_697) __extension__ ({ \
+  int32x4_t __ret_697; \
+  int32x2_t __s0_697 = __p0_697; \
+  int64x2_t __s1_697 = __p1_697; \
+  int32x2_t __rev0_697;  __rev0_697 = __builtin_shufflevector(__s0_697, __s0_697, 1, 0); \
+  int64x2_t __rev1_697;  __rev1_697 = __builtin_shufflevector(__s1_697, __s1_697, 1, 0); \
+  __ret_697 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_697), (int32x2_t)(__noswap_vqrshrn_n_s64(__rev1_697, __p2_697)))); \
+  __ret_697 = __builtin_shufflevector(__ret_697, __ret_697, 3, 2, 1, 0); \
+  __ret_697; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrn_high_n_s16(__p0_698, __p1_698, __p2_698) __extension__ ({ \
+  int8x16_t __ret_698; \
+  int8x8_t __s0_698 = __p0_698; \
+  int16x8_t __s1_698 = __p1_698; \
+  __ret_698 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_698), (int8x8_t)(vqrshrn_n_s16(__s1_698, __p2_698)))); \
+  __ret_698; \
+})
+#else
+#define vqrshrn_high_n_s16(__p0_699, __p1_699, __p2_699) __extension__ ({ \
+  int8x16_t __ret_699; \
+  int8x8_t __s0_699 = __p0_699; \
+  int16x8_t __s1_699 = __p1_699; \
+  int8x8_t __rev0_699;  __rev0_699 = __builtin_shufflevector(__s0_699, __s0_699, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_699;  __rev1_699 = __builtin_shufflevector(__s1_699, __s1_699, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_699 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_699), (int8x8_t)(__noswap_vqrshrn_n_s16(__rev1_699, __p2_699)))); \
+  __ret_699 = __builtin_shufflevector(__ret_699, __ret_699, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_699; \
+})
+#endif
+
+#define vqrshrns_n_u32(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint32_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vqrshrns_n_u32(__s0, __p1); \
+  __ret; \
+})
+#define vqrshrnd_n_u64(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint64_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vqrshrnd_n_u64(__s0, __p1); \
+  __ret; \
+})
+#define vqrshrnh_n_u16(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint16_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vqrshrnh_n_u16(__s0, __p1); \
+  __ret; \
+})
+#define vqrshrns_n_s32(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int32_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vqrshrns_n_s32(__s0, __p1); \
+  __ret; \
+})
+#define vqrshrnd_n_s64(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vqrshrnd_n_s64(__s0, __p1); \
+  __ret; \
+})
+#define vqrshrnh_n_s16(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int16_t __s0 = __p0; \
+  __ret = (int8_t) __builtin_neon_vqrshrnh_n_s16(__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrun_high_n_s32(__p0_700, __p1_700, __p2_700) __extension__ ({ \
+  int16x8_t __ret_700; \
+  int16x4_t __s0_700 = __p0_700; \
+  int32x4_t __s1_700 = __p1_700; \
+  __ret_700 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_700), (int16x4_t)(vqrshrun_n_s32(__s1_700, __p2_700)))); \
+  __ret_700; \
+})
+#else
+#define vqrshrun_high_n_s32(__p0_701, __p1_701, __p2_701) __extension__ ({ \
+  int16x8_t __ret_701; \
+  int16x4_t __s0_701 = __p0_701; \
+  int32x4_t __s1_701 = __p1_701; \
+  int16x4_t __rev0_701;  __rev0_701 = __builtin_shufflevector(__s0_701, __s0_701, 3, 2, 1, 0); \
+  int32x4_t __rev1_701;  __rev1_701 = __builtin_shufflevector(__s1_701, __s1_701, 3, 2, 1, 0); \
+  __ret_701 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_701), (int16x4_t)(__noswap_vqrshrun_n_s32(__rev1_701, __p2_701)))); \
+  __ret_701 = __builtin_shufflevector(__ret_701, __ret_701, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_701; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrun_high_n_s64(__p0_702, __p1_702, __p2_702) __extension__ ({ \
+  int32x4_t __ret_702; \
+  int32x2_t __s0_702 = __p0_702; \
+  int64x2_t __s1_702 = __p1_702; \
+  __ret_702 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_702), (int32x2_t)(vqrshrun_n_s64(__s1_702, __p2_702)))); \
+  __ret_702; \
+})
+#else
+#define vqrshrun_high_n_s64(__p0_703, __p1_703, __p2_703) __extension__ ({ \
+  int32x4_t __ret_703; \
+  int32x2_t __s0_703 = __p0_703; \
+  int64x2_t __s1_703 = __p1_703; \
+  int32x2_t __rev0_703;  __rev0_703 = __builtin_shufflevector(__s0_703, __s0_703, 1, 0); \
+  int64x2_t __rev1_703;  __rev1_703 = __builtin_shufflevector(__s1_703, __s1_703, 1, 0); \
+  __ret_703 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_703), (int32x2_t)(__noswap_vqrshrun_n_s64(__rev1_703, __p2_703)))); \
+  __ret_703 = __builtin_shufflevector(__ret_703, __ret_703, 3, 2, 1, 0); \
+  __ret_703; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrshrun_high_n_s16(__p0_704, __p1_704, __p2_704) __extension__ ({ \
+  int8x16_t __ret_704; \
+  int8x8_t __s0_704 = __p0_704; \
+  int16x8_t __s1_704 = __p1_704; \
+  __ret_704 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_704), (int8x8_t)(vqrshrun_n_s16(__s1_704, __p2_704)))); \
+  __ret_704; \
+})
+#else
+#define vqrshrun_high_n_s16(__p0_705, __p1_705, __p2_705) __extension__ ({ \
+  int8x16_t __ret_705; \
+  int8x8_t __s0_705 = __p0_705; \
+  int16x8_t __s1_705 = __p1_705; \
+  int8x8_t __rev0_705;  __rev0_705 = __builtin_shufflevector(__s0_705, __s0_705, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_705;  __rev1_705 = __builtin_shufflevector(__s1_705, __s1_705, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_705 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_705), (int8x8_t)(__noswap_vqrshrun_n_s16(__rev1_705, __p2_705)))); \
+  __ret_705 = __builtin_shufflevector(__ret_705, __ret_705, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_705; \
+})
+#endif
+
+#define vqrshruns_n_s32(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  int32_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vqrshruns_n_s32(__s0, __p1); \
+  __ret; \
+})
+#define vqrshrund_n_s64(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vqrshrund_n_s64(__s0, __p1); \
+  __ret; \
+})
+#define vqrshrunh_n_s16(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  int16_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vqrshrunh_n_s16(__s0, __p1); \
+  __ret; \
+})
+__ai __attribute__((target("neon"))) uint8_t vqshlb_u8(uint8_t __p0, int8_t __p1) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vqshlb_u8(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vqshls_u32(uint32_t __p0, int32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vqshls_u32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vqshld_u64(uint64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vqshld_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16_t vqshlh_u16(uint16_t __p0, int16_t __p1) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vqshlh_u16(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vqshlb_s8(int8_t __p0, int8_t __p1) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vqshlb_s8(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqshls_s32(int32_t __p0, int32_t __p1) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqshls_s32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqshld_s64(int64_t __p0, int64_t __p1) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vqshld_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqshlh_s16(int16_t __p0, int16_t __p1) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqshlh_s16(__p0, __p1);
+  return __ret;
+}
+#define vqshlb_n_u8(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint8_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vqshlb_n_u8(__s0, __p1); \
+  __ret; \
+})
+#define vqshls_n_u32(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint32_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vqshls_n_u32(__s0, __p1); \
+  __ret; \
+})
+#define vqshld_n_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vqshld_n_u64(__s0, __p1); \
+  __ret; \
+})
+#define vqshlh_n_u16(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint16_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vqshlh_n_u16(__s0, __p1); \
+  __ret; \
+})
+#define vqshlb_n_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8_t __s0 = __p0; \
+  __ret = (int8_t) __builtin_neon_vqshlb_n_s8(__s0, __p1); \
+  __ret; \
+})
+#define vqshls_n_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vqshls_n_s32(__s0, __p1); \
+  __ret; \
+})
+#define vqshld_n_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vqshld_n_s64(__s0, __p1); \
+  __ret; \
+})
+#define vqshlh_n_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vqshlh_n_s16(__s0, __p1); \
+  __ret; \
+})
+#define vqshlub_n_s8(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int8_t __s0 = __p0; \
+  __ret = (int8_t) __builtin_neon_vqshlub_n_s8(__s0, __p1); \
+  __ret; \
+})
+#define vqshlus_n_s32(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int32_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vqshlus_n_s32(__s0, __p1); \
+  __ret; \
+})
+#define vqshlud_n_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vqshlud_n_s64(__s0, __p1); \
+  __ret; \
+})
+#define vqshluh_n_s16(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int16_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vqshluh_n_s16(__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_u32(__p0_706, __p1_706, __p2_706) __extension__ ({ \
+  uint16x8_t __ret_706; \
+  uint16x4_t __s0_706 = __p0_706; \
+  uint32x4_t __s1_706 = __p1_706; \
+  __ret_706 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_706), (uint16x4_t)(vqshrn_n_u32(__s1_706, __p2_706)))); \
+  __ret_706; \
+})
+#else
+#define vqshrn_high_n_u32(__p0_707, __p1_707, __p2_707) __extension__ ({ \
+  uint16x8_t __ret_707; \
+  uint16x4_t __s0_707 = __p0_707; \
+  uint32x4_t __s1_707 = __p1_707; \
+  uint16x4_t __rev0_707;  __rev0_707 = __builtin_shufflevector(__s0_707, __s0_707, 3, 2, 1, 0); \
+  uint32x4_t __rev1_707;  __rev1_707 = __builtin_shufflevector(__s1_707, __s1_707, 3, 2, 1, 0); \
+  __ret_707 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_707), (uint16x4_t)(__noswap_vqshrn_n_u32(__rev1_707, __p2_707)))); \
+  __ret_707 = __builtin_shufflevector(__ret_707, __ret_707, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_707; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_u64(__p0_708, __p1_708, __p2_708) __extension__ ({ \
+  uint32x4_t __ret_708; \
+  uint32x2_t __s0_708 = __p0_708; \
+  uint64x2_t __s1_708 = __p1_708; \
+  __ret_708 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_708), (uint32x2_t)(vqshrn_n_u64(__s1_708, __p2_708)))); \
+  __ret_708; \
+})
+#else
+#define vqshrn_high_n_u64(__p0_709, __p1_709, __p2_709) __extension__ ({ \
+  uint32x4_t __ret_709; \
+  uint32x2_t __s0_709 = __p0_709; \
+  uint64x2_t __s1_709 = __p1_709; \
+  uint32x2_t __rev0_709;  __rev0_709 = __builtin_shufflevector(__s0_709, __s0_709, 1, 0); \
+  uint64x2_t __rev1_709;  __rev1_709 = __builtin_shufflevector(__s1_709, __s1_709, 1, 0); \
+  __ret_709 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_709), (uint32x2_t)(__noswap_vqshrn_n_u64(__rev1_709, __p2_709)))); \
+  __ret_709 = __builtin_shufflevector(__ret_709, __ret_709, 3, 2, 1, 0); \
+  __ret_709; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_u16(__p0_710, __p1_710, __p2_710) __extension__ ({ \
+  uint8x16_t __ret_710; \
+  uint8x8_t __s0_710 = __p0_710; \
+  uint16x8_t __s1_710 = __p1_710; \
+  __ret_710 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_710), (uint8x8_t)(vqshrn_n_u16(__s1_710, __p2_710)))); \
+  __ret_710; \
+})
+#else
+#define vqshrn_high_n_u16(__p0_711, __p1_711, __p2_711) __extension__ ({ \
+  uint8x16_t __ret_711; \
+  uint8x8_t __s0_711 = __p0_711; \
+  uint16x8_t __s1_711 = __p1_711; \
+  uint8x8_t __rev0_711;  __rev0_711 = __builtin_shufflevector(__s0_711, __s0_711, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1_711;  __rev1_711 = __builtin_shufflevector(__s1_711, __s1_711, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_711 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_711), (uint8x8_t)(__noswap_vqshrn_n_u16(__rev1_711, __p2_711)))); \
+  __ret_711 = __builtin_shufflevector(__ret_711, __ret_711, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_711; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_s32(__p0_712, __p1_712, __p2_712) __extension__ ({ \
+  int16x8_t __ret_712; \
+  int16x4_t __s0_712 = __p0_712; \
+  int32x4_t __s1_712 = __p1_712; \
+  __ret_712 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_712), (int16x4_t)(vqshrn_n_s32(__s1_712, __p2_712)))); \
+  __ret_712; \
+})
+#else
+#define vqshrn_high_n_s32(__p0_713, __p1_713, __p2_713) __extension__ ({ \
+  int16x8_t __ret_713; \
+  int16x4_t __s0_713 = __p0_713; \
+  int32x4_t __s1_713 = __p1_713; \
+  int16x4_t __rev0_713;  __rev0_713 = __builtin_shufflevector(__s0_713, __s0_713, 3, 2, 1, 0); \
+  int32x4_t __rev1_713;  __rev1_713 = __builtin_shufflevector(__s1_713, __s1_713, 3, 2, 1, 0); \
+  __ret_713 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_713), (int16x4_t)(__noswap_vqshrn_n_s32(__rev1_713, __p2_713)))); \
+  __ret_713 = __builtin_shufflevector(__ret_713, __ret_713, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_713; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_s64(__p0_714, __p1_714, __p2_714) __extension__ ({ \
+  int32x4_t __ret_714; \
+  int32x2_t __s0_714 = __p0_714; \
+  int64x2_t __s1_714 = __p1_714; \
+  __ret_714 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_714), (int32x2_t)(vqshrn_n_s64(__s1_714, __p2_714)))); \
+  __ret_714; \
+})
+#else
+#define vqshrn_high_n_s64(__p0_715, __p1_715, __p2_715) __extension__ ({ \
+  int32x4_t __ret_715; \
+  int32x2_t __s0_715 = __p0_715; \
+  int64x2_t __s1_715 = __p1_715; \
+  int32x2_t __rev0_715;  __rev0_715 = __builtin_shufflevector(__s0_715, __s0_715, 1, 0); \
+  int64x2_t __rev1_715;  __rev1_715 = __builtin_shufflevector(__s1_715, __s1_715, 1, 0); \
+  __ret_715 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_715), (int32x2_t)(__noswap_vqshrn_n_s64(__rev1_715, __p2_715)))); \
+  __ret_715 = __builtin_shufflevector(__ret_715, __ret_715, 3, 2, 1, 0); \
+  __ret_715; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrn_high_n_s16(__p0_716, __p1_716, __p2_716) __extension__ ({ \
+  int8x16_t __ret_716; \
+  int8x8_t __s0_716 = __p0_716; \
+  int16x8_t __s1_716 = __p1_716; \
+  __ret_716 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_716), (int8x8_t)(vqshrn_n_s16(__s1_716, __p2_716)))); \
+  __ret_716; \
+})
+#else
+#define vqshrn_high_n_s16(__p0_717, __p1_717, __p2_717) __extension__ ({ \
+  int8x16_t __ret_717; \
+  int8x8_t __s0_717 = __p0_717; \
+  int16x8_t __s1_717 = __p1_717; \
+  int8x8_t __rev0_717;  __rev0_717 = __builtin_shufflevector(__s0_717, __s0_717, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_717;  __rev1_717 = __builtin_shufflevector(__s1_717, __s1_717, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_717 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_717), (int8x8_t)(__noswap_vqshrn_n_s16(__rev1_717, __p2_717)))); \
+  __ret_717 = __builtin_shufflevector(__ret_717, __ret_717, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_717; \
+})
+#endif
+
+#define vqshrns_n_u32(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  uint32_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vqshrns_n_u32(__s0, __p1); \
+  __ret; \
+})
+#define vqshrnd_n_u64(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  uint64_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vqshrnd_n_u64(__s0, __p1); \
+  __ret; \
+})
+#define vqshrnh_n_u16(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  uint16_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vqshrnh_n_u16(__s0, __p1); \
+  __ret; \
+})
+#define vqshrns_n_s32(__p0, __p1) __extension__ ({ \
+  int16_t __ret; \
+  int32_t __s0 = __p0; \
+  __ret = (int16_t) __builtin_neon_vqshrns_n_s32(__s0, __p1); \
+  __ret; \
+})
+#define vqshrnd_n_s64(__p0, __p1) __extension__ ({ \
+  int32_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (int32_t) __builtin_neon_vqshrnd_n_s64(__s0, __p1); \
+  __ret; \
+})
+#define vqshrnh_n_s16(__p0, __p1) __extension__ ({ \
+  int8_t __ret; \
+  int16_t __s0 = __p0; \
+  __ret = (int8_t) __builtin_neon_vqshrnh_n_s16(__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_high_n_s32(__p0_718, __p1_718, __p2_718) __extension__ ({ \
+  int16x8_t __ret_718; \
+  int16x4_t __s0_718 = __p0_718; \
+  int32x4_t __s1_718 = __p1_718; \
+  __ret_718 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_718), (int16x4_t)(vqshrun_n_s32(__s1_718, __p2_718)))); \
+  __ret_718; \
+})
+#else
+#define vqshrun_high_n_s32(__p0_719, __p1_719, __p2_719) __extension__ ({ \
+  int16x8_t __ret_719; \
+  int16x4_t __s0_719 = __p0_719; \
+  int32x4_t __s1_719 = __p1_719; \
+  int16x4_t __rev0_719;  __rev0_719 = __builtin_shufflevector(__s0_719, __s0_719, 3, 2, 1, 0); \
+  int32x4_t __rev1_719;  __rev1_719 = __builtin_shufflevector(__s1_719, __s1_719, 3, 2, 1, 0); \
+  __ret_719 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_719), (int16x4_t)(__noswap_vqshrun_n_s32(__rev1_719, __p2_719)))); \
+  __ret_719 = __builtin_shufflevector(__ret_719, __ret_719, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_719; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_high_n_s64(__p0_720, __p1_720, __p2_720) __extension__ ({ \
+  int32x4_t __ret_720; \
+  int32x2_t __s0_720 = __p0_720; \
+  int64x2_t __s1_720 = __p1_720; \
+  __ret_720 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_720), (int32x2_t)(vqshrun_n_s64(__s1_720, __p2_720)))); \
+  __ret_720; \
+})
+#else
+#define vqshrun_high_n_s64(__p0_721, __p1_721, __p2_721) __extension__ ({ \
+  int32x4_t __ret_721; \
+  int32x2_t __s0_721 = __p0_721; \
+  int64x2_t __s1_721 = __p1_721; \
+  int32x2_t __rev0_721;  __rev0_721 = __builtin_shufflevector(__s0_721, __s0_721, 1, 0); \
+  int64x2_t __rev1_721;  __rev1_721 = __builtin_shufflevector(__s1_721, __s1_721, 1, 0); \
+  __ret_721 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_721), (int32x2_t)(__noswap_vqshrun_n_s64(__rev1_721, __p2_721)))); \
+  __ret_721 = __builtin_shufflevector(__ret_721, __ret_721, 3, 2, 1, 0); \
+  __ret_721; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqshrun_high_n_s16(__p0_722, __p1_722, __p2_722) __extension__ ({ \
+  int8x16_t __ret_722; \
+  int8x8_t __s0_722 = __p0_722; \
+  int16x8_t __s1_722 = __p1_722; \
+  __ret_722 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_722), (int8x8_t)(vqshrun_n_s16(__s1_722, __p2_722)))); \
+  __ret_722; \
+})
+#else
+#define vqshrun_high_n_s16(__p0_723, __p1_723, __p2_723) __extension__ ({ \
+  int8x16_t __ret_723; \
+  int8x8_t __s0_723 = __p0_723; \
+  int16x8_t __s1_723 = __p1_723; \
+  int8x8_t __rev0_723;  __rev0_723 = __builtin_shufflevector(__s0_723, __s0_723, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_723;  __rev1_723 = __builtin_shufflevector(__s1_723, __s1_723, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_723 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_723), (int8x8_t)(__noswap_vqshrun_n_s16(__rev1_723, __p2_723)))); \
+  __ret_723 = __builtin_shufflevector(__ret_723, __ret_723, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_723; \
+})
+#endif
+
+#define vqshruns_n_s32(__p0, __p1) __extension__ ({ \
+  uint16_t __ret; \
+  int32_t __s0 = __p0; \
+  __ret = (uint16_t) __builtin_neon_vqshruns_n_s32(__s0, __p1); \
+  __ret; \
+})
+#define vqshrund_n_s64(__p0, __p1) __extension__ ({ \
+  uint32_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (uint32_t) __builtin_neon_vqshrund_n_s64(__s0, __p1); \
+  __ret; \
+})
+#define vqshrunh_n_s16(__p0, __p1) __extension__ ({ \
+  uint8_t __ret; \
+  int16_t __s0 = __p0; \
+  __ret = (uint8_t) __builtin_neon_vqshrunh_n_s16(__s0, __p1); \
+  __ret; \
+})
+__ai __attribute__((target("neon"))) uint8_t vqsubb_u8(uint8_t __p0, uint8_t __p1) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vqsubb_u8(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vqsubs_u32(uint32_t __p0, uint32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vqsubs_u32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vqsubd_u64(uint64_t __p0, uint64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vqsubd_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16_t vqsubh_u16(uint16_t __p0, uint16_t __p1) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vqsubh_u16(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vqsubb_s8(int8_t __p0, int8_t __p1) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vqsubb_s8(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vqsubs_s32(int32_t __p0, int32_t __p1) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqsubs_s32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vqsubd_s64(int64_t __p0, int64_t __p1) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vqsubd_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vqsubh_s16(int16_t __p0, int16_t __p1) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqsubh_s16(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl1_p8(poly8x16_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__p0, (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl1_p8(poly8x16_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__rev0, (int8x8_t)__rev1, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl1q_p8(poly8x16_t __p0, uint8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__p0, (int8x16_t)__p1, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl1q_p8(poly8x16_t __p0, uint8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbl1q_s8(int8x16_t __p0, uint8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbl1q_s8(int8x16_t __p0, uint8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqtbl1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl1_u8(uint8x16_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl1_u8(uint8x16_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbl1_s8(int8x16_t __p0, uint8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbl1_s8(int8x16_t __p0, uint8x8_t __p1) {
+  int8x8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqtbl1_v((int8x16_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl2_p8(poly8x16x2_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl2_p8(poly8x16x2_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x16x2_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x8_t)__rev1, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl2q_p8(poly8x16x2_t __p0, uint8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p1, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl2q_p8(poly8x16x2_t __p0, uint8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16x2_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev1, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl2q_u8(uint8x16x2_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl2q_u8(uint8x16x2_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16x2_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbl2q_s8(int8x16x2_t __p0, uint8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbl2q_s8(int8x16x2_t __p0, uint8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16x2_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqtbl2q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl2_u8(uint8x16x2_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl2_u8(uint8x16x2_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x16x2_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbl2_s8(int8x16x2_t __p0, uint8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbl2_s8(int8x16x2_t __p0, uint8x8_t __p1) {
+  int8x8_t __ret;
+  int8x16x2_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqtbl2_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl3_p8(poly8x16x3_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl3_p8(poly8x16x3_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x16x3_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x8_t)__rev1, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl3q_p8(poly8x16x3_t __p0, uint8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p1, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl3q_p8(poly8x16x3_t __p0, uint8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16x3_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev1, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl3q_u8(uint8x16x3_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl3q_u8(uint8x16x3_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16x3_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbl3q_s8(int8x16x3_t __p0, uint8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbl3q_s8(int8x16x3_t __p0, uint8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16x3_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqtbl3q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl3_u8(uint8x16x3_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl3_u8(uint8x16x3_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x16x3_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbl3_s8(int8x16x3_t __p0, uint8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbl3_s8(int8x16x3_t __p0, uint8x8_t __p1) {
+  int8x8_t __ret;
+  int8x16x3_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqtbl3_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl4_p8(poly8x16x4_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x8_t)__p1, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbl4_p8(poly8x16x4_t __p0, uint8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x16x4_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x8_t)__rev1, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl4q_p8(poly8x16x4_t __p0, uint8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x16_t)__p1, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbl4q_p8(poly8x16x4_t __p0, uint8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16x4_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x16_t)__rev1, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl4q_u8(uint8x16x4_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbl4q_u8(uint8x16x4_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16x4_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbl4q_s8(int8x16x4_t __p0, uint8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbl4q_s8(int8x16x4_t __p0, uint8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16x4_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqtbl4q_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl4_u8(uint8x16x4_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbl4_u8(uint8x16x4_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x16x4_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbl4_s8(int8x16x4_t __p0, uint8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__p0.val[0], (int8x16_t)__p0.val[1], (int8x16_t)__p0.val[2], (int8x16_t)__p0.val[3], (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbl4_s8(int8x16x4_t __p0, uint8x8_t __p1) {
+  int8x8_t __ret;
+  int8x16x4_t __rev0;
+  __rev0.val[0] = __builtin_shufflevector(__p0.val[0], __p0.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[1] = __builtin_shufflevector(__p0.val[1], __p0.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[2] = __builtin_shufflevector(__p0.val[2], __p0.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev0.val[3] = __builtin_shufflevector(__p0.val[3], __p0.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqtbl4_v((int8x16_t)__rev0.val[0], (int8x16_t)__rev0.val[1], (int8x16_t)__rev0.val[2], (int8x16_t)__rev0.val[3], (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx1_p8(poly8x8_t __p0, poly8x16_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__p0, (int8x16_t)__p1, (int8x8_t)__p2, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx1_p8(poly8x8_t __p0, poly8x16_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx1q_p8(poly8x16_t __p0, poly8x16_t __p1, uint8x16_t __p2) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx1q_p8(poly8x16_t __p0, poly8x16_t __p1, uint8x16_t __p2) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx1q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx1q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbx1q_s8(int8x16_t __p0, int8x16_t __p1, uint8x16_t __p2) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbx1q_s8(int8x16_t __p0, int8x16_t __p1, uint8x16_t __p2) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqtbx1q_v((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx1_u8(uint8x8_t __p0, uint8x16_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__p0, (int8x16_t)__p1, (int8x8_t)__p2, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx1_u8(uint8x8_t __p0, uint8x16_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbx1_s8(int8x8_t __p0, int8x16_t __p1, uint8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__p0, (int8x16_t)__p1, (int8x8_t)__p2, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbx1_s8(int8x8_t __p0, int8x16_t __p1, uint8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqtbx1_v((int8x8_t)__rev0, (int8x16_t)__rev1, (int8x8_t)__rev2, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx2_p8(poly8x8_t __p0, poly8x16x2_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x8_t)__p2, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx2_p8(poly8x8_t __p0, poly8x16x2_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16x2_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x8_t)__rev2, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx2q_p8(poly8x16_t __p0, poly8x16x2_t __p1, uint8x16_t __p2) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p2, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx2q_p8(poly8x16_t __p0, poly8x16x2_t __p1, uint8x16_t __p2) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16x2_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev2, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx2q_u8(uint8x16_t __p0, uint8x16x2_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p2, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx2q_u8(uint8x16_t __p0, uint8x16x2_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16x2_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev2, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbx2q_s8(int8x16_t __p0, int8x16x2_t __p1, uint8x16_t __p2) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p2, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbx2q_s8(int8x16_t __p0, int8x16x2_t __p1, uint8x16_t __p2) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16x2_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqtbx2q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev2, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx2_u8(uint8x8_t __p0, uint8x16x2_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x8_t)__p2, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx2_u8(uint8x8_t __p0, uint8x16x2_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16x2_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x8_t)__rev2, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbx2_s8(int8x8_t __p0, int8x16x2_t __p1, uint8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x8_t)__p2, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbx2_s8(int8x8_t __p0, int8x16x2_t __p1, uint8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16x2_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqtbx2_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x8_t)__rev2, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx3_p8(poly8x8_t __p0, poly8x16x3_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x8_t)__p2, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx3_p8(poly8x8_t __p0, poly8x16x3_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16x3_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x8_t)__rev2, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx3q_p8(poly8x16_t __p0, poly8x16x3_t __p1, uint8x16_t __p2) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p2, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx3q_p8(poly8x16_t __p0, poly8x16x3_t __p1, uint8x16_t __p2) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16x3_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev2, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx3q_u8(uint8x16_t __p0, uint8x16x3_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p2, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx3q_u8(uint8x16_t __p0, uint8x16x3_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16x3_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev2, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbx3q_s8(int8x16_t __p0, int8x16x3_t __p1, uint8x16_t __p2) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p2, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbx3q_s8(int8x16_t __p0, int8x16x3_t __p1, uint8x16_t __p2) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16x3_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqtbx3q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev2, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx3_u8(uint8x8_t __p0, uint8x16x3_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x8_t)__p2, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx3_u8(uint8x8_t __p0, uint8x16x3_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16x3_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x8_t)__rev2, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbx3_s8(int8x8_t __p0, int8x16x3_t __p1, uint8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x8_t)__p2, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbx3_s8(int8x8_t __p0, int8x16x3_t __p1, uint8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16x3_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqtbx3_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x8_t)__rev2, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx4_p8(poly8x8_t __p0, poly8x16x4_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x8_t)__p2, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vqtbx4_p8(poly8x8_t __p0, poly8x16x4_t __p1, uint8x8_t __p2) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16x4_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x8_t)__rev2, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx4q_p8(poly8x16_t __p0, poly8x16x4_t __p1, uint8x16_t __p2) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x16_t)__p2, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vqtbx4q_p8(poly8x16_t __p0, poly8x16x4_t __p1, uint8x16_t __p2) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16x4_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x16_t)__rev2, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx4q_u8(uint8x16_t __p0, uint8x16x4_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x16_t)__p2, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vqtbx4q_u8(uint8x16_t __p0, uint8x16x4_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16x4_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x16_t)__rev2, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vqtbx4q_s8(int8x16_t __p0, int8x16x4_t __p1, uint8x16_t __p2) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x16_t)__p2, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vqtbx4q_s8(int8x16_t __p0, int8x16x4_t __p1, uint8x16_t __p2) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16x4_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vqtbx4q_v((int8x16_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x16_t)__rev2, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx4_u8(uint8x8_t __p0, uint8x16x4_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x8_t)__p2, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vqtbx4_u8(uint8x8_t __p0, uint8x16x4_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16x4_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x8_t)__rev2, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vqtbx4_s8(int8x8_t __p0, int8x16x4_t __p1, uint8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__p0, (int8x16_t)__p1.val[0], (int8x16_t)__p1.val[1], (int8x16_t)__p1.val[2], (int8x16_t)__p1.val[3], (int8x8_t)__p2, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vqtbx4_s8(int8x8_t __p0, int8x16x4_t __p1, uint8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16x4_t __rev1;
+  __rev1.val[0] = __builtin_shufflevector(__p1.val[0], __p1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[1] = __builtin_shufflevector(__p1.val[1], __p1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[2] = __builtin_shufflevector(__p1.val[2], __p1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __rev1.val[3] = __builtin_shufflevector(__p1.val[3], __p1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vqtbx4_v((int8x8_t)__rev0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], (int8x8_t)__rev2, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vraddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint16x8_t __ret;
+  __ret = vcombine_u16(__p0, vraddhn_u32(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vraddhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint16x8_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u16(__rev0, __noswap_vraddhn_u32(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vraddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint32x4_t __ret;
+  __ret = vcombine_u32(__p0, vraddhn_u64(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vraddhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint32x4_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __noswap_vcombine_u32(__rev0, __noswap_vraddhn_u64(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vraddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint8x16_t __ret;
+  __ret = vcombine_u8(__p0, vraddhn_u16(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vraddhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint8x16_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u8(__rev0, __noswap_vraddhn_u16(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vraddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int16x8_t __ret;
+  __ret = vcombine_s16(__p0, vraddhn_s32(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vraddhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int16x8_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s16(__rev0, __noswap_vraddhn_s32(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vraddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int32x4_t __ret;
+  __ret = vcombine_s32(__p0, vraddhn_s64(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vraddhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int32x4_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __noswap_vcombine_s32(__rev0, __noswap_vraddhn_s64(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vraddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int8x16_t __ret;
+  __ret = vcombine_s8(__p0, vraddhn_s16(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vraddhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int8x16_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s8(__rev0, __noswap_vraddhn_s16(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vrbit_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t) __builtin_neon_vrbit_v((int8x8_t)__p0, 4);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vrbit_p8(poly8x8_t __p0) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x8_t) __builtin_neon_vrbit_v((int8x8_t)__rev0, 4);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vrbitq_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__p0, 36);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vrbitq_p8(poly8x16_t __p0) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (poly8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__rev0, 36);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vrbitq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__p0, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vrbitq_u8(uint8x16_t __p0) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__rev0, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vrbitq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__p0, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vrbitq_s8(int8x16_t __p0) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vrbitq_v((int8x16_t)__rev0, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vrbit_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vrbit_v((int8x8_t)__p0, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vrbit_u8(uint8x8_t __p0) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vrbit_v((int8x8_t)__rev0, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vrbit_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vrbit_v((int8x8_t)__p0, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vrbit_s8(int8x8_t __p0) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vrbit_v((int8x8_t)__rev0, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrecpeq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrecpeq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrecpeq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrecpeq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrecpe_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrecpe_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64_t vrecped_f64(float64_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vrecped_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vrecpes_f32(float32_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vrecpes_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrecpsq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrecpsq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrecpsq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrecpsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrecps_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrecps_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64_t vrecpsd_f64(float64_t __p0, float64_t __p1) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vrecpsd_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vrecpss_f32(float32_t __p0, float32_t __p1) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vrecpss_f32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64_t vrecpxd_f64(float64_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vrecpxd_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vrecpxs_f32(float32_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vrecpxs_f32(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_p64(poly64x1_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_p16(poly16x4_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u8(uint8x8_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u32(uint32x2_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u64(uint64x1_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_u16(uint16x4_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s8(int8x8_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_f64(float64x1_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_f32(float32x2_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_f16(float16x4_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s32(int32x2_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s64(int64x1_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x8_t vreinterpret_p8_s16(int16x4_t __p0) {
+  poly8x8_t __ret;
+  __ret = (poly8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_p8(poly8x8_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_p16(poly16x4_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_u8(uint8x8_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_u32(uint32x2_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_u64(uint64x1_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_u16(uint16x4_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_s8(int8x8_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_f64(float64x1_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_f32(float32x2_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_f16(float16x4_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_s32(int32x2_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_s64(int64x1_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x1_t vreinterpret_p64_s16(int16x4_t __p0) {
+  poly64x1_t __ret;
+  __ret = (poly64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_p8(poly8x8_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_p64(poly64x1_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u8(uint8x8_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u32(uint32x2_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u64(uint64x1_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_u16(uint16x4_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s8(int8x8_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_f64(float64x1_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_f32(float32x2_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_f16(float16x4_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s32(int32x2_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s64(int64x1_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x4_t vreinterpret_p16_s16(int16x4_t __p0) {
+  poly16x4_t __ret;
+  __ret = (poly16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_p128(poly128_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_p64(poly64x2_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_p16(poly16x8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u8(uint8x16_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u32(uint32x4_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u64(uint64x2_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_u16(uint16x8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s8(int8x16_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_f64(float64x2_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_f32(float32x4_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_f16(float16x8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s32(int32x4_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s64(int64x2_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly8x16_t vreinterpretq_p8_s16(int16x8_t __p0) {
+  poly8x16_t __ret;
+  __ret = (poly8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_p8(poly8x16_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_p64(poly64x2_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_p16(poly16x8_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_u8(uint8x16_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_u32(uint32x4_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_u64(uint64x2_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_u16(uint16x8_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_s8(int8x16_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_f64(float64x2_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_f32(float32x4_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_f16(float16x8_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_s32(int32x4_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_s64(int64x2_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly128_t vreinterpretq_p128_s16(int16x8_t __p0) {
+  poly128_t __ret;
+  __ret = (poly128_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_p8(poly8x16_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_p128(poly128_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_p16(poly16x8_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_u8(uint8x16_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_u32(uint32x4_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_u64(uint64x2_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_u16(uint16x8_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_s8(int8x16_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_f64(float64x2_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_f32(float32x4_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_f16(float16x8_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_s32(int32x4_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_s64(int64x2_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly64x2_t vreinterpretq_p64_s16(int16x8_t __p0) {
+  poly64x2_t __ret;
+  __ret = (poly64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_p8(poly8x16_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_p128(poly128_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_p64(poly64x2_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u8(uint8x16_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u32(uint32x4_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u64(uint64x2_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_u16(uint16x8_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s8(int8x16_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_f64(float64x2_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_f32(float32x4_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_f16(float16x8_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s32(int32x4_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s64(int64x2_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) poly16x8_t vreinterpretq_p16_s16(int16x8_t __p0) {
+  poly16x8_t __ret;
+  __ret = (poly16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p8(poly8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p128(poly128_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p64(poly64x2_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_p16(poly16x8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u32(uint32x4_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u64(uint64x2_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_u16(uint16x8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s8(int8x16_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_f64(float64x2_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_f32(float32x4_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_f16(float16x8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s32(int32x4_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s64(int64x2_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x16_t vreinterpretq_u8_s16(int16x8_t __p0) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p8(poly8x16_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p128(poly128_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p64(poly64x2_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_p16(poly16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u8(uint8x16_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u64(uint64x2_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_u16(uint16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s8(int8x16_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_f64(float64x2_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_f32(float32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_f16(float16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s32(int32x4_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s64(int64x2_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t vreinterpretq_u32_s16(int16x8_t __p0) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p8(poly8x16_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p128(poly128_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p64(poly64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_p16(poly16x8_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u8(uint8x16_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u32(uint32x4_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_u16(uint16x8_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s8(int8x16_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_f64(float64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_f32(float32x4_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_f16(float16x8_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s32(int32x4_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s64(int64x2_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t vreinterpretq_u64_s16(int16x8_t __p0) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p8(poly8x16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p128(poly128_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p64(poly64x2_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_p16(poly16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u8(uint8x16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u32(uint32x4_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_u64(uint64x2_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s8(int8x16_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_f64(float64x2_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_f32(float32x4_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_f16(float16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s32(int32x4_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s64(int64x2_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t vreinterpretq_u16_s16(int16x8_t __p0) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p8(poly8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p128(poly128_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p64(poly64x2_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_p16(poly16x8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u8(uint8x16_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u32(uint32x4_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u64(uint64x2_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_u16(uint16x8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_f64(float64x2_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_f32(float32x4_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_f16(float16x8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s32(int32x4_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s64(int64x2_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x16_t vreinterpretq_s8_s16(int16x8_t __p0) {
+  int8x16_t __ret;
+  __ret = (int8x16_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_p8(poly8x16_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_p128(poly128_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_p64(poly64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_p16(poly16x8_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_u8(uint8x16_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_u32(uint32x4_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_u64(uint64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_u16(uint16x8_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_s8(int8x16_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_f32(float32x4_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_f16(float16x8_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_s32(int32x4_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_s64(int64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x2_t vreinterpretq_f64_s16(int16x8_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p8(poly8x16_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p128(poly128_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p64(poly64x2_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_p16(poly16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u8(uint8x16_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u32(uint32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u64(uint64x2_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_u16(uint16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s8(int8x16_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_f64(float64x2_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_f16(float16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s32(int32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s64(int64x2_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x4_t vreinterpretq_f32_s16(int16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p8(poly8x16_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p128(poly128_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p64(poly64x2_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_p16(poly16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u8(uint8x16_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u32(uint32x4_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u64(uint64x2_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_u16(uint16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s8(int8x16_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_f64(float64x2_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_f32(float32x4_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s32(int32x4_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s64(int64x2_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x8_t vreinterpretq_f16_s16(int16x8_t __p0) {
+  float16x8_t __ret;
+  __ret = (float16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p8(poly8x16_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p128(poly128_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p64(poly64x2_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_p16(poly16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u8(uint8x16_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u32(uint32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u64(uint64x2_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_u16(uint16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s8(int8x16_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_f64(float64x2_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_f32(float32x4_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_f16(float16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s64(int64x2_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t vreinterpretq_s32_s16(int16x8_t __p0) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p8(poly8x16_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p128(poly128_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p64(poly64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_p16(poly16x8_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u8(uint8x16_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u32(uint32x4_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u64(uint64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_u16(uint16x8_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s8(int8x16_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_f64(float64x2_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_f32(float32x4_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_f16(float16x8_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s32(int32x4_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t vreinterpretq_s64_s16(int16x8_t __p0) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p8(poly8x16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p128(poly128_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p64(poly64x2_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_p16(poly16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u8(uint8x16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u32(uint32x4_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u64(uint64x2_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_u16(uint16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s8(int8x16_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_f64(float64x2_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_f32(float32x4_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_f16(float16x8_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s32(int32x4_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t vreinterpretq_s16_s64(int64x2_t __p0) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_p8(poly8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_p64(poly64x1_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_p16(poly16x4_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u32(uint32x2_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u64(uint64x1_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_u16(uint16x4_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s8(int8x8_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_f64(float64x1_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_f32(float32x2_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_f16(float16x4_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s32(int32x2_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s64(int64x1_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint8x8_t vreinterpret_u8_s16(int16x4_t __p0) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_p8(poly8x8_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_p64(poly64x1_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_p16(poly16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u8(uint8x8_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u64(uint64x1_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_u16(uint16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s8(int8x8_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_f64(float64x1_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_f32(float32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_f16(float16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s32(int32x2_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s64(int64x1_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x2_t vreinterpret_u32_s16(int16x4_t __p0) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_p8(poly8x8_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_p64(poly64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_p16(poly16x4_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u8(uint8x8_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u32(uint32x2_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_u16(uint16x4_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s8(int8x8_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_f64(float64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_f32(float32x2_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_f16(float16x4_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s32(int32x2_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s64(int64x1_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vreinterpret_u64_s16(int16x4_t __p0) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_p8(poly8x8_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_p64(poly64x1_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_p16(poly16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u8(uint8x8_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u32(uint32x2_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_u64(uint64x1_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s8(int8x8_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_f64(float64x1_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_f32(float32x2_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_f16(float16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s32(int32x2_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s64(int64x1_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x4_t vreinterpret_u16_s16(int16x4_t __p0) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_p8(poly8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_p64(poly64x1_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_p16(poly16x4_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u8(uint8x8_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u32(uint32x2_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u64(uint64x1_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_u16(uint16x4_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_f64(float64x1_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_f32(float32x2_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_f16(float16x4_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s32(int32x2_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s64(int64x1_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8x8_t vreinterpret_s8_s16(int16x4_t __p0) {
+  int8x8_t __ret;
+  __ret = (int8x8_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_p8(poly8x8_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_p64(poly64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_p16(poly16x4_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_u8(uint8x8_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_u32(uint32x2_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_u64(uint64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_u16(uint16x4_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_s8(int8x8_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_f32(float32x2_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_f16(float16x4_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_s32(int32x2_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_s64(int64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64x1_t vreinterpret_f64_s16(int16x4_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_p8(poly8x8_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_p64(poly64x1_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_p16(poly16x4_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u8(uint8x8_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u32(uint32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u64(uint64x1_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_u16(uint16x4_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s8(int8x8_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_f64(float64x1_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_f16(float16x4_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s32(int32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s64(int64x1_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32x2_t vreinterpret_f32_s16(int16x4_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_p8(poly8x8_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_p64(poly64x1_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_p16(poly16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u8(uint8x8_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u32(uint32x2_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u64(uint64x1_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_u16(uint16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s8(int8x8_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_f64(float64x1_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_f32(float32x2_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s32(int32x2_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s64(int64x1_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float16x4_t vreinterpret_f16_s16(int16x4_t __p0) {
+  float16x4_t __ret;
+  __ret = (float16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_p8(poly8x8_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_p64(poly64x1_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_p16(poly16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u8(uint8x8_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u32(uint32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u64(uint64x1_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_u16(uint16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s8(int8x8_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_f64(float64x1_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_f32(float32x2_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_f16(float16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s64(int64x1_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x2_t vreinterpret_s32_s16(int16x4_t __p0) {
+  int32x2_t __ret;
+  __ret = (int32x2_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_p8(poly8x8_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_p64(poly64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_p16(poly16x4_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u8(uint8x8_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u32(uint32x2_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u64(uint64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_u16(uint16x4_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s8(int8x8_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_f64(float64x1_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_f32(float32x2_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_f16(float16x4_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s32(int32x2_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x1_t vreinterpret_s64_s16(int16x4_t __p0) {
+  int64x1_t __ret;
+  __ret = (int64x1_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_p8(poly8x8_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_p64(poly64x1_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_p16(poly16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u8(uint8x8_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u32(uint32x2_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u64(uint64x1_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_u16(uint16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s8(int8x8_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_f64(float64x1_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_f32(float32x2_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_f16(float16x4_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s32(int32x2_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x4_t vreinterpret_s16_s64(int64x1_t __p0) {
+  int16x4_t __ret;
+  __ret = (int16x4_t)(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vrshld_u64(uint64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vrshld_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vrshld_s64(int64_t __p0, int64_t __p1) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vrshld_s64(__p0, __p1);
+  return __ret;
+}
+#define vrshrd_n_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vrshrd_n_u64(__s0, __p1); \
+  __ret; \
+})
+#define vrshrd_n_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vrshrd_n_s64(__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_high_n_u32(__p0_724, __p1_724, __p2_724) __extension__ ({ \
+  uint16x8_t __ret_724; \
+  uint16x4_t __s0_724 = __p0_724; \
+  uint32x4_t __s1_724 = __p1_724; \
+  __ret_724 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_724), (uint16x4_t)(vrshrn_n_u32(__s1_724, __p2_724)))); \
+  __ret_724; \
+})
+#else
+#define vrshrn_high_n_u32(__p0_725, __p1_725, __p2_725) __extension__ ({ \
+  uint16x8_t __ret_725; \
+  uint16x4_t __s0_725 = __p0_725; \
+  uint32x4_t __s1_725 = __p1_725; \
+  uint16x4_t __rev0_725;  __rev0_725 = __builtin_shufflevector(__s0_725, __s0_725, 3, 2, 1, 0); \
+  uint32x4_t __rev1_725;  __rev1_725 = __builtin_shufflevector(__s1_725, __s1_725, 3, 2, 1, 0); \
+  __ret_725 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_725), (uint16x4_t)(__noswap_vrshrn_n_u32(__rev1_725, __p2_725)))); \
+  __ret_725 = __builtin_shufflevector(__ret_725, __ret_725, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_725; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_high_n_u64(__p0_726, __p1_726, __p2_726) __extension__ ({ \
+  uint32x4_t __ret_726; \
+  uint32x2_t __s0_726 = __p0_726; \
+  uint64x2_t __s1_726 = __p1_726; \
+  __ret_726 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_726), (uint32x2_t)(vrshrn_n_u64(__s1_726, __p2_726)))); \
+  __ret_726; \
+})
+#else
+#define vrshrn_high_n_u64(__p0_727, __p1_727, __p2_727) __extension__ ({ \
+  uint32x4_t __ret_727; \
+  uint32x2_t __s0_727 = __p0_727; \
+  uint64x2_t __s1_727 = __p1_727; \
+  uint32x2_t __rev0_727;  __rev0_727 = __builtin_shufflevector(__s0_727, __s0_727, 1, 0); \
+  uint64x2_t __rev1_727;  __rev1_727 = __builtin_shufflevector(__s1_727, __s1_727, 1, 0); \
+  __ret_727 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_727), (uint32x2_t)(__noswap_vrshrn_n_u64(__rev1_727, __p2_727)))); \
+  __ret_727 = __builtin_shufflevector(__ret_727, __ret_727, 3, 2, 1, 0); \
+  __ret_727; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_high_n_u16(__p0_728, __p1_728, __p2_728) __extension__ ({ \
+  uint8x16_t __ret_728; \
+  uint8x8_t __s0_728 = __p0_728; \
+  uint16x8_t __s1_728 = __p1_728; \
+  __ret_728 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_728), (uint8x8_t)(vrshrn_n_u16(__s1_728, __p2_728)))); \
+  __ret_728; \
+})
+#else
+#define vrshrn_high_n_u16(__p0_729, __p1_729, __p2_729) __extension__ ({ \
+  uint8x16_t __ret_729; \
+  uint8x8_t __s0_729 = __p0_729; \
+  uint16x8_t __s1_729 = __p1_729; \
+  uint8x8_t __rev0_729;  __rev0_729 = __builtin_shufflevector(__s0_729, __s0_729, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1_729;  __rev1_729 = __builtin_shufflevector(__s1_729, __s1_729, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_729 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_729), (uint8x8_t)(__noswap_vrshrn_n_u16(__rev1_729, __p2_729)))); \
+  __ret_729 = __builtin_shufflevector(__ret_729, __ret_729, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_729; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_high_n_s32(__p0_730, __p1_730, __p2_730) __extension__ ({ \
+  int16x8_t __ret_730; \
+  int16x4_t __s0_730 = __p0_730; \
+  int32x4_t __s1_730 = __p1_730; \
+  __ret_730 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_730), (int16x4_t)(vrshrn_n_s32(__s1_730, __p2_730)))); \
+  __ret_730; \
+})
+#else
+#define vrshrn_high_n_s32(__p0_731, __p1_731, __p2_731) __extension__ ({ \
+  int16x8_t __ret_731; \
+  int16x4_t __s0_731 = __p0_731; \
+  int32x4_t __s1_731 = __p1_731; \
+  int16x4_t __rev0_731;  __rev0_731 = __builtin_shufflevector(__s0_731, __s0_731, 3, 2, 1, 0); \
+  int32x4_t __rev1_731;  __rev1_731 = __builtin_shufflevector(__s1_731, __s1_731, 3, 2, 1, 0); \
+  __ret_731 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_731), (int16x4_t)(__noswap_vrshrn_n_s32(__rev1_731, __p2_731)))); \
+  __ret_731 = __builtin_shufflevector(__ret_731, __ret_731, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_731; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_high_n_s64(__p0_732, __p1_732, __p2_732) __extension__ ({ \
+  int32x4_t __ret_732; \
+  int32x2_t __s0_732 = __p0_732; \
+  int64x2_t __s1_732 = __p1_732; \
+  __ret_732 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_732), (int32x2_t)(vrshrn_n_s64(__s1_732, __p2_732)))); \
+  __ret_732; \
+})
+#else
+#define vrshrn_high_n_s64(__p0_733, __p1_733, __p2_733) __extension__ ({ \
+  int32x4_t __ret_733; \
+  int32x2_t __s0_733 = __p0_733; \
+  int64x2_t __s1_733 = __p1_733; \
+  int32x2_t __rev0_733;  __rev0_733 = __builtin_shufflevector(__s0_733, __s0_733, 1, 0); \
+  int64x2_t __rev1_733;  __rev1_733 = __builtin_shufflevector(__s1_733, __s1_733, 1, 0); \
+  __ret_733 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_733), (int32x2_t)(__noswap_vrshrn_n_s64(__rev1_733, __p2_733)))); \
+  __ret_733 = __builtin_shufflevector(__ret_733, __ret_733, 3, 2, 1, 0); \
+  __ret_733; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vrshrn_high_n_s16(__p0_734, __p1_734, __p2_734) __extension__ ({ \
+  int8x16_t __ret_734; \
+  int8x8_t __s0_734 = __p0_734; \
+  int16x8_t __s1_734 = __p1_734; \
+  __ret_734 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_734), (int8x8_t)(vrshrn_n_s16(__s1_734, __p2_734)))); \
+  __ret_734; \
+})
+#else
+#define vrshrn_high_n_s16(__p0_735, __p1_735, __p2_735) __extension__ ({ \
+  int8x16_t __ret_735; \
+  int8x8_t __s0_735 = __p0_735; \
+  int16x8_t __s1_735 = __p1_735; \
+  int8x8_t __rev0_735;  __rev0_735 = __builtin_shufflevector(__s0_735, __s0_735, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_735;  __rev1_735 = __builtin_shufflevector(__s1_735, __s1_735, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_735 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_735), (int8x8_t)(__noswap_vrshrn_n_s16(__rev1_735, __p2_735)))); \
+  __ret_735 = __builtin_shufflevector(__ret_735, __ret_735, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_735; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrsqrteq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrsqrteq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrsqrteq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrsqrteq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrsqrte_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrsqrte_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64_t vrsqrted_f64(float64_t __p0) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vrsqrted_f64(__p0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vrsqrtes_f32(float32_t __p0) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vrsqrtes_f32(__p0);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vrsqrtsq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vrsqrtsq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrsqrtsq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vrsqrts_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrsqrts_v((int8x8_t)__p0, (int8x8_t)__p1, 10);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float64_t vrsqrtsd_f64(float64_t __p0, float64_t __p1) {
+  float64_t __ret;
+  __ret = (float64_t) __builtin_neon_vrsqrtsd_f64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) float32_t vrsqrtss_f32(float32_t __p0, float32_t __p1) {
+  float32_t __ret;
+  __ret = (float32_t) __builtin_neon_vrsqrtss_f32(__p0, __p1);
+  return __ret;
+}
+#define vrsrad_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64_t __ret; \
+  uint64_t __s0 = __p0; \
+  uint64_t __s1 = __p1; \
+  __ret = (uint64_t) __builtin_neon_vrsrad_n_u64(__s0, __s1, __p2); \
+  __ret; \
+})
+#define vrsrad_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int64_t __s1 = __p1; \
+  __ret = (int64_t) __builtin_neon_vrsrad_n_s64(__s0, __s1, __p2); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vrsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint16x8_t __ret;
+  __ret = vcombine_u16(__p0, vrsubhn_u32(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vrsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint16x8_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u16(__rev0, __noswap_vrsubhn_u32(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vrsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint32x4_t __ret;
+  __ret = vcombine_u32(__p0, vrsubhn_u64(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vrsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint32x4_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __noswap_vcombine_u32(__rev0, __noswap_vrsubhn_u64(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vrsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint8x16_t __ret;
+  __ret = vcombine_u8(__p0, vrsubhn_u16(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vrsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint8x16_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u8(__rev0, __noswap_vrsubhn_u16(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vrsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int16x8_t __ret;
+  __ret = vcombine_s16(__p0, vrsubhn_s32(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vrsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int16x8_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s16(__rev0, __noswap_vrsubhn_s32(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vrsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int32x4_t __ret;
+  __ret = vcombine_s32(__p0, vrsubhn_s64(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vrsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int32x4_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __noswap_vcombine_s32(__rev0, __noswap_vrsubhn_s64(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vrsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int8x16_t __ret;
+  __ret = vcombine_s8(__p0, vrsubhn_s16(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vrsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int8x16_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s8(__rev0, __noswap_vrsubhn_s16(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#define vset_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1_t __ret; \
+  poly64_t __s0 = __p0; \
+  poly64x1_t __s1 = __p1; \
+  __ret = (poly64x1_t) __builtin_neon_vset_lane_i64(__s0, (poly64x1_t)__s1, __p2); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64_t __s0 = __p0; \
+  poly64x2_t __s1 = __p1; \
+  __ret = (poly64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (poly64x2_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64_t __s0 = __p0; \
+  poly64x2_t __s1 = __p1; \
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (poly64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (poly64x2_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64_t __s0 = __p0; \
+  poly64x2_t __s1 = __p1; \
+  __ret = (poly64x2_t) __builtin_neon_vsetq_lane_i64(__s0, (poly64x2_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __ret; \
+  float64_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  __ret = (float64x2_t) __builtin_neon_vsetq_lane_f64(__s0, (float64x2_t)__s1, __p2); \
+  __ret; \
+})
+#else
+#define vsetq_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __ret; \
+  float64_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (float64x2_t) __builtin_neon_vsetq_lane_f64(__s0, (float64x2_t)__rev1, __p2); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#define __noswap_vsetq_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __ret; \
+  float64_t __s0 = __p0; \
+  float64x2_t __s1 = __p1; \
+  __ret = (float64x2_t) __builtin_neon_vsetq_lane_f64(__s0, (float64x2_t)__s1, __p2); \
+  __ret; \
+})
+#endif
+
+#define vset_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1_t __ret; \
+  float64_t __s0 = __p0; \
+  float64x1_t __s1 = __p1; \
+  __ret = (float64x1_t) __builtin_neon_vset_lane_f64(__s0, (float64x1_t)__s1, __p2); \
+  __ret; \
+})
+__ai __attribute__((target("neon"))) uint64_t vshld_u64(uint64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vshld_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vshld_s64(int64_t __p0, int64_t __p1) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vshld_s64(__p0, __p1);
+  return __ret;
+}
+#define vshld_n_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vshld_n_u64(__s0, __p1); \
+  __ret; \
+})
+#define vshld_n_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vshld_n_s64(__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vshll_high_n_u8(__p0_736, __p1_736) __extension__ ({ \
+  uint16x8_t __ret_736; \
+  uint8x16_t __s0_736 = __p0_736; \
+  __ret_736 = (uint16x8_t)(vshll_n_u8(vget_high_u8(__s0_736), __p1_736)); \
+  __ret_736; \
+})
+#else
+#define vshll_high_n_u8(__p0_737, __p1_737) __extension__ ({ \
+  uint16x8_t __ret_737; \
+  uint8x16_t __s0_737 = __p0_737; \
+  uint8x16_t __rev0_737;  __rev0_737 = __builtin_shufflevector(__s0_737, __s0_737, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_737 = (uint16x8_t)(__noswap_vshll_n_u8(__noswap_vget_high_u8(__rev0_737), __p1_737)); \
+  __ret_737 = __builtin_shufflevector(__ret_737, __ret_737, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_737; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_high_n_u32(__p0_738, __p1_738) __extension__ ({ \
+  uint64x2_t __ret_738; \
+  uint32x4_t __s0_738 = __p0_738; \
+  __ret_738 = (uint64x2_t)(vshll_n_u32(vget_high_u32(__s0_738), __p1_738)); \
+  __ret_738; \
+})
+#else
+#define vshll_high_n_u32(__p0_739, __p1_739) __extension__ ({ \
+  uint64x2_t __ret_739; \
+  uint32x4_t __s0_739 = __p0_739; \
+  uint32x4_t __rev0_739;  __rev0_739 = __builtin_shufflevector(__s0_739, __s0_739, 3, 2, 1, 0); \
+  __ret_739 = (uint64x2_t)(__noswap_vshll_n_u32(__noswap_vget_high_u32(__rev0_739), __p1_739)); \
+  __ret_739 = __builtin_shufflevector(__ret_739, __ret_739, 1, 0); \
+  __ret_739; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_high_n_u16(__p0_740, __p1_740) __extension__ ({ \
+  uint32x4_t __ret_740; \
+  uint16x8_t __s0_740 = __p0_740; \
+  __ret_740 = (uint32x4_t)(vshll_n_u16(vget_high_u16(__s0_740), __p1_740)); \
+  __ret_740; \
+})
+#else
+#define vshll_high_n_u16(__p0_741, __p1_741) __extension__ ({ \
+  uint32x4_t __ret_741; \
+  uint16x8_t __s0_741 = __p0_741; \
+  uint16x8_t __rev0_741;  __rev0_741 = __builtin_shufflevector(__s0_741, __s0_741, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_741 = (uint32x4_t)(__noswap_vshll_n_u16(__noswap_vget_high_u16(__rev0_741), __p1_741)); \
+  __ret_741 = __builtin_shufflevector(__ret_741, __ret_741, 3, 2, 1, 0); \
+  __ret_741; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_high_n_s8(__p0_742, __p1_742) __extension__ ({ \
+  int16x8_t __ret_742; \
+  int8x16_t __s0_742 = __p0_742; \
+  __ret_742 = (int16x8_t)(vshll_n_s8(vget_high_s8(__s0_742), __p1_742)); \
+  __ret_742; \
+})
+#else
+#define vshll_high_n_s8(__p0_743, __p1_743) __extension__ ({ \
+  int16x8_t __ret_743; \
+  int8x16_t __s0_743 = __p0_743; \
+  int8x16_t __rev0_743;  __rev0_743 = __builtin_shufflevector(__s0_743, __s0_743, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_743 = (int16x8_t)(__noswap_vshll_n_s8(__noswap_vget_high_s8(__rev0_743), __p1_743)); \
+  __ret_743 = __builtin_shufflevector(__ret_743, __ret_743, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_743; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_high_n_s32(__p0_744, __p1_744) __extension__ ({ \
+  int64x2_t __ret_744; \
+  int32x4_t __s0_744 = __p0_744; \
+  __ret_744 = (int64x2_t)(vshll_n_s32(vget_high_s32(__s0_744), __p1_744)); \
+  __ret_744; \
+})
+#else
+#define vshll_high_n_s32(__p0_745, __p1_745) __extension__ ({ \
+  int64x2_t __ret_745; \
+  int32x4_t __s0_745 = __p0_745; \
+  int32x4_t __rev0_745;  __rev0_745 = __builtin_shufflevector(__s0_745, __s0_745, 3, 2, 1, 0); \
+  __ret_745 = (int64x2_t)(__noswap_vshll_n_s32(__noswap_vget_high_s32(__rev0_745), __p1_745)); \
+  __ret_745 = __builtin_shufflevector(__ret_745, __ret_745, 1, 0); \
+  __ret_745; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshll_high_n_s16(__p0_746, __p1_746) __extension__ ({ \
+  int32x4_t __ret_746; \
+  int16x8_t __s0_746 = __p0_746; \
+  __ret_746 = (int32x4_t)(vshll_n_s16(vget_high_s16(__s0_746), __p1_746)); \
+  __ret_746; \
+})
+#else
+#define vshll_high_n_s16(__p0_747, __p1_747) __extension__ ({ \
+  int32x4_t __ret_747; \
+  int16x8_t __s0_747 = __p0_747; \
+  int16x8_t __rev0_747;  __rev0_747 = __builtin_shufflevector(__s0_747, __s0_747, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_747 = (int32x4_t)(__noswap_vshll_n_s16(__noswap_vget_high_s16(__rev0_747), __p1_747)); \
+  __ret_747 = __builtin_shufflevector(__ret_747, __ret_747, 3, 2, 1, 0); \
+  __ret_747; \
+})
+#endif
+
+#define vshrd_n_u64(__p0, __p1) __extension__ ({ \
+  uint64_t __ret; \
+  uint64_t __s0 = __p0; \
+  __ret = (uint64_t) __builtin_neon_vshrd_n_u64(__s0, __p1); \
+  __ret; \
+})
+#define vshrd_n_s64(__p0, __p1) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  __ret = (int64_t) __builtin_neon_vshrd_n_s64(__s0, __p1); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_high_n_u32(__p0_748, __p1_748, __p2_748) __extension__ ({ \
+  uint16x8_t __ret_748; \
+  uint16x4_t __s0_748 = __p0_748; \
+  uint32x4_t __s1_748 = __p1_748; \
+  __ret_748 = (uint16x8_t)(vcombine_u16((uint16x4_t)(__s0_748), (uint16x4_t)(vshrn_n_u32(__s1_748, __p2_748)))); \
+  __ret_748; \
+})
+#else
+#define vshrn_high_n_u32(__p0_749, __p1_749, __p2_749) __extension__ ({ \
+  uint16x8_t __ret_749; \
+  uint16x4_t __s0_749 = __p0_749; \
+  uint32x4_t __s1_749 = __p1_749; \
+  uint16x4_t __rev0_749;  __rev0_749 = __builtin_shufflevector(__s0_749, __s0_749, 3, 2, 1, 0); \
+  uint32x4_t __rev1_749;  __rev1_749 = __builtin_shufflevector(__s1_749, __s1_749, 3, 2, 1, 0); \
+  __ret_749 = (uint16x8_t)(__noswap_vcombine_u16((uint16x4_t)(__rev0_749), (uint16x4_t)(__noswap_vshrn_n_u32(__rev1_749, __p2_749)))); \
+  __ret_749 = __builtin_shufflevector(__ret_749, __ret_749, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_749; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_high_n_u64(__p0_750, __p1_750, __p2_750) __extension__ ({ \
+  uint32x4_t __ret_750; \
+  uint32x2_t __s0_750 = __p0_750; \
+  uint64x2_t __s1_750 = __p1_750; \
+  __ret_750 = (uint32x4_t)(vcombine_u32((uint32x2_t)(__s0_750), (uint32x2_t)(vshrn_n_u64(__s1_750, __p2_750)))); \
+  __ret_750; \
+})
+#else
+#define vshrn_high_n_u64(__p0_751, __p1_751, __p2_751) __extension__ ({ \
+  uint32x4_t __ret_751; \
+  uint32x2_t __s0_751 = __p0_751; \
+  uint64x2_t __s1_751 = __p1_751; \
+  uint32x2_t __rev0_751;  __rev0_751 = __builtin_shufflevector(__s0_751, __s0_751, 1, 0); \
+  uint64x2_t __rev1_751;  __rev1_751 = __builtin_shufflevector(__s1_751, __s1_751, 1, 0); \
+  __ret_751 = (uint32x4_t)(__noswap_vcombine_u32((uint32x2_t)(__rev0_751), (uint32x2_t)(__noswap_vshrn_n_u64(__rev1_751, __p2_751)))); \
+  __ret_751 = __builtin_shufflevector(__ret_751, __ret_751, 3, 2, 1, 0); \
+  __ret_751; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_high_n_u16(__p0_752, __p1_752, __p2_752) __extension__ ({ \
+  uint8x16_t __ret_752; \
+  uint8x8_t __s0_752 = __p0_752; \
+  uint16x8_t __s1_752 = __p1_752; \
+  __ret_752 = (uint8x16_t)(vcombine_u8((uint8x8_t)(__s0_752), (uint8x8_t)(vshrn_n_u16(__s1_752, __p2_752)))); \
+  __ret_752; \
+})
+#else
+#define vshrn_high_n_u16(__p0_753, __p1_753, __p2_753) __extension__ ({ \
+  uint8x16_t __ret_753; \
+  uint8x8_t __s0_753 = __p0_753; \
+  uint16x8_t __s1_753 = __p1_753; \
+  uint8x8_t __rev0_753;  __rev0_753 = __builtin_shufflevector(__s0_753, __s0_753, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint16x8_t __rev1_753;  __rev1_753 = __builtin_shufflevector(__s1_753, __s1_753, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_753 = (uint8x16_t)(__noswap_vcombine_u8((uint8x8_t)(__rev0_753), (uint8x8_t)(__noswap_vshrn_n_u16(__rev1_753, __p2_753)))); \
+  __ret_753 = __builtin_shufflevector(__ret_753, __ret_753, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_753; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_high_n_s32(__p0_754, __p1_754, __p2_754) __extension__ ({ \
+  int16x8_t __ret_754; \
+  int16x4_t __s0_754 = __p0_754; \
+  int32x4_t __s1_754 = __p1_754; \
+  __ret_754 = (int16x8_t)(vcombine_s16((int16x4_t)(__s0_754), (int16x4_t)(vshrn_n_s32(__s1_754, __p2_754)))); \
+  __ret_754; \
+})
+#else
+#define vshrn_high_n_s32(__p0_755, __p1_755, __p2_755) __extension__ ({ \
+  int16x8_t __ret_755; \
+  int16x4_t __s0_755 = __p0_755; \
+  int32x4_t __s1_755 = __p1_755; \
+  int16x4_t __rev0_755;  __rev0_755 = __builtin_shufflevector(__s0_755, __s0_755, 3, 2, 1, 0); \
+  int32x4_t __rev1_755;  __rev1_755 = __builtin_shufflevector(__s1_755, __s1_755, 3, 2, 1, 0); \
+  __ret_755 = (int16x8_t)(__noswap_vcombine_s16((int16x4_t)(__rev0_755), (int16x4_t)(__noswap_vshrn_n_s32(__rev1_755, __p2_755)))); \
+  __ret_755 = __builtin_shufflevector(__ret_755, __ret_755, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_755; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_high_n_s64(__p0_756, __p1_756, __p2_756) __extension__ ({ \
+  int32x4_t __ret_756; \
+  int32x2_t __s0_756 = __p0_756; \
+  int64x2_t __s1_756 = __p1_756; \
+  __ret_756 = (int32x4_t)(vcombine_s32((int32x2_t)(__s0_756), (int32x2_t)(vshrn_n_s64(__s1_756, __p2_756)))); \
+  __ret_756; \
+})
+#else
+#define vshrn_high_n_s64(__p0_757, __p1_757, __p2_757) __extension__ ({ \
+  int32x4_t __ret_757; \
+  int32x2_t __s0_757 = __p0_757; \
+  int64x2_t __s1_757 = __p1_757; \
+  int32x2_t __rev0_757;  __rev0_757 = __builtin_shufflevector(__s0_757, __s0_757, 1, 0); \
+  int64x2_t __rev1_757;  __rev1_757 = __builtin_shufflevector(__s1_757, __s1_757, 1, 0); \
+  __ret_757 = (int32x4_t)(__noswap_vcombine_s32((int32x2_t)(__rev0_757), (int32x2_t)(__noswap_vshrn_n_s64(__rev1_757, __p2_757)))); \
+  __ret_757 = __builtin_shufflevector(__ret_757, __ret_757, 3, 2, 1, 0); \
+  __ret_757; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vshrn_high_n_s16(__p0_758, __p1_758, __p2_758) __extension__ ({ \
+  int8x16_t __ret_758; \
+  int8x8_t __s0_758 = __p0_758; \
+  int16x8_t __s1_758 = __p1_758; \
+  __ret_758 = (int8x16_t)(vcombine_s8((int8x8_t)(__s0_758), (int8x8_t)(vshrn_n_s16(__s1_758, __p2_758)))); \
+  __ret_758; \
+})
+#else
+#define vshrn_high_n_s16(__p0_759, __p1_759, __p2_759) __extension__ ({ \
+  int8x16_t __ret_759; \
+  int8x8_t __s0_759 = __p0_759; \
+  int16x8_t __s1_759 = __p1_759; \
+  int8x8_t __rev0_759;  __rev0_759 = __builtin_shufflevector(__s0_759, __s0_759, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_759;  __rev1_759 = __builtin_shufflevector(__s1_759, __s1_759, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_759 = (int8x16_t)(__noswap_vcombine_s8((int8x8_t)(__rev0_759), (int8x8_t)(__noswap_vshrn_n_s16(__rev1_759, __p2_759)))); \
+  __ret_759 = __builtin_shufflevector(__ret_759, __ret_759, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_759; \
+})
+#endif
+
+#define vslid_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64_t __ret; \
+  uint64_t __s0 = __p0; \
+  uint64_t __s1 = __p1; \
+  __ret = (uint64_t) __builtin_neon_vslid_n_u64(__s0, __s1, __p2); \
+  __ret; \
+})
+#define vslid_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int64_t __s1 = __p1; \
+  __ret = (int64_t) __builtin_neon_vslid_n_s64(__s0, __s1, __p2); \
+  __ret; \
+})
+#define vsli_n_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1_t __ret; \
+  poly64x1_t __s0 = __p0; \
+  poly64x1_t __s1 = __p1; \
+  __ret = (poly64x1_t) __builtin_neon_vsli_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vsliq_n_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  poly64x2_t __s1 = __p1; \
+  __ret = (poly64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 38); \
+  __ret; \
+})
+#else
+#define vsliq_n_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  poly64x2_t __s1 = __p1; \
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (poly64x2_t) __builtin_neon_vsliq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 38); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+__ai __attribute__((target("neon"))) uint8_t vsqaddb_u8(uint8_t __p0, int8_t __p1) {
+  uint8_t __ret;
+  __ret = (uint8_t) __builtin_neon_vsqaddb_u8(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32_t vsqadds_u32(uint32_t __p0, int32_t __p1) {
+  uint32_t __ret;
+  __ret = (uint32_t) __builtin_neon_vsqadds_u32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vsqaddd_u64(uint64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vsqaddd_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16_t vsqaddh_u16(uint16_t __p0, int16_t __p1) {
+  uint16_t __ret;
+  __ret = (uint16_t) __builtin_neon_vsqaddh_u16(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vsqaddq_u8(uint8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vsqaddq_u8(uint8x16_t __p0, int8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vsqaddq_u32(uint32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vsqaddq_u32(uint32x4_t __p0, int32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vsqaddq_u64(uint64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vsqaddq_u64(uint64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vsqaddq_u16(uint16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vsqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vsqaddq_u16(uint16x8_t __p0, int16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vsqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vsqadd_u8(uint8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = (uint8x8_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 16);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vsqadd_u8(uint8x8_t __p0, int8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x8_t) __builtin_neon_vsqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 16);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vsqadd_u32(uint32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = (uint32x2_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 18);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vsqadd_u32(uint32x2_t __p0, int32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint32x2_t) __builtin_neon_vsqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 18);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vsqadd_u64(uint64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vsqadd_u16(uint16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = (uint16x4_t) __builtin_neon_vsqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 17);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vsqadd_u16(uint16x4_t __p0, int16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint16x4_t) __builtin_neon_vsqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 17);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vsqrtq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vsqrtq_v((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vsqrtq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vsqrtq_v((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vsqrtq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vsqrtq_v((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vsqrtq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vsqrtq_v((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vsqrt_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vsqrt_v((int8x8_t)__p0, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vsqrt_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vsqrt_v((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vsqrt_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vsqrt_v((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#define vsrad_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64_t __ret; \
+  uint64_t __s0 = __p0; \
+  uint64_t __s1 = __p1; \
+  __ret = (uint64_t) __builtin_neon_vsrad_n_u64(__s0, __s1, __p2); \
+  __ret; \
+})
+#define vsrad_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int64_t __s1 = __p1; \
+  __ret = (int64_t) __builtin_neon_vsrad_n_s64(__s0, __s1, __p2); \
+  __ret; \
+})
+#define vsrid_n_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64_t __ret; \
+  uint64_t __s0 = __p0; \
+  uint64_t __s1 = __p1; \
+  __ret = (uint64_t) __builtin_neon_vsrid_n_u64(__s0, __s1, __p2); \
+  __ret; \
+})
+#define vsrid_n_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64_t __ret; \
+  int64_t __s0 = __p0; \
+  int64_t __s1 = __p1; \
+  __ret = (int64_t) __builtin_neon_vsrid_n_s64(__s0, __s1, __p2); \
+  __ret; \
+})
+#define vsri_n_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1_t __ret; \
+  poly64x1_t __s0 = __p0; \
+  poly64x1_t __s1 = __p1; \
+  __ret = (poly64x1_t) __builtin_neon_vsri_n_v((int8x8_t)__s0, (int8x8_t)__s1, __p2, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vsriq_n_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  poly64x2_t __s1 = __p1; \
+  __ret = (poly64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__s0, (int8x16_t)__s1, __p2, 38); \
+  __ret; \
+})
+#else
+#define vsriq_n_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s0 = __p0; \
+  poly64x2_t __s1 = __p1; \
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (poly64x2_t) __builtin_neon_vsriq_n_v((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 38); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vst1_p64(__p0, __p1) __extension__ ({ \
+  poly64x1_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p64(__p0, __p1) __extension__ ({ \
+  poly64x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 38); \
+})
+#else
+#define vst1q_p64(__p0, __p1) __extension__ ({ \
+  poly64x2_t __s1 = __p1; \
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f64(__p0, __p1) __extension__ ({ \
+  float64x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__s1, 42); \
+})
+#else
+#define vst1q_f64(__p0, __p1) __extension__ ({ \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1q_v(__p0, (int8x16_t)__rev1, 42); \
+})
+#endif
+
+#define vst1_f64(__p0, __p1) __extension__ ({ \
+  float64x1_t __s1 = __p1; \
+  __builtin_neon_vst1_v(__p0, (int8x8_t)__s1, 10); \
+})
+#define vst1_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 38); \
+})
+#else
+#define vst1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __s1 = __p1; \
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__s1, __p2, 42); \
+})
+#else
+#define vst1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vst1q_lane_v(__p0, (int8x16_t)__rev1, __p2, 42); \
+})
+#endif
+
+#define vst1_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1_t __s1 = __p1; \
+  __builtin_neon_vst1_lane_v(__p0, (int8x8_t)__s1, __p2, 10); \
+})
+#define vst1_p64_x2(__p0, __p1) __extension__ ({ \
+  poly64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p64_x2(__p0, __p1) __extension__ ({ \
+  poly64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 38); \
+})
+#else
+#define vst1q_p64_x2(__p0, __p1) __extension__ ({ \
+  poly64x2x2_t __s1 = __p1; \
+  poly64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f64_x2(__p0, __p1) __extension__ ({ \
+  float64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 42); \
+})
+#else
+#define vst1q_f64_x2(__p0, __p1) __extension__ ({ \
+  float64x2x2_t __s1 = __p1; \
+  float64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst1q_x2_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 42); \
+})
+#endif
+
+#define vst1_f64_x2(__p0, __p1) __extension__ ({ \
+  float64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst1_x2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 10); \
+})
+#define vst1_p64_x3(__p0, __p1) __extension__ ({ \
+  poly64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p64_x3(__p0, __p1) __extension__ ({ \
+  poly64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 38); \
+})
+#else
+#define vst1q_p64_x3(__p0, __p1) __extension__ ({ \
+  poly64x2x3_t __s1 = __p1; \
+  poly64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f64_x3(__p0, __p1) __extension__ ({ \
+  float64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 42); \
+})
+#else
+#define vst1q_f64_x3(__p0, __p1) __extension__ ({ \
+  float64x2x3_t __s1 = __p1; \
+  float64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst1q_x3_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 42); \
+})
+#endif
+
+#define vst1_f64_x3(__p0, __p1) __extension__ ({ \
+  float64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst1_x3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 10); \
+})
+#define vst1_p64_x4(__p0, __p1) __extension__ ({ \
+  poly64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_p64_x4(__p0, __p1) __extension__ ({ \
+  poly64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 38); \
+})
+#else
+#define vst1q_p64_x4(__p0, __p1) __extension__ ({ \
+  poly64x2x4_t __s1 = __p1; \
+  poly64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst1q_f64_x4(__p0, __p1) __extension__ ({ \
+  float64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 42); \
+})
+#else
+#define vst1q_f64_x4(__p0, __p1) __extension__ ({ \
+  float64x2x4_t __s1 = __p1; \
+  float64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst1q_x4_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 42); \
+})
+#endif
+
+#define vst1_f64_x4(__p0, __p1) __extension__ ({ \
+  float64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst1_x4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 10); \
+})
+#define vst2_p64(__p0, __p1) __extension__ ({ \
+  poly64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_p64(__p0, __p1) __extension__ ({ \
+  poly64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 38); \
+})
+#else
+#define vst2q_p64(__p0, __p1) __extension__ ({ \
+  poly64x2x2_t __s1 = __p1; \
+  poly64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_u64(__p0, __p1) __extension__ ({ \
+  uint64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 51); \
+})
+#else
+#define vst2q_u64(__p0, __p1) __extension__ ({ \
+  uint64x2x2_t __s1 = __p1; \
+  uint64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_f64(__p0, __p1) __extension__ ({ \
+  float64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 42); \
+})
+#else
+#define vst2q_f64(__p0, __p1) __extension__ ({ \
+  float64x2x2_t __s1 = __p1; \
+  float64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 42); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_s64(__p0, __p1) __extension__ ({ \
+  int64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], 35); \
+})
+#else
+#define vst2q_s64(__p0, __p1) __extension__ ({ \
+  int64x2x2_t __s1 = __p1; \
+  int64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], 35); \
+})
+#endif
+
+#define vst2_f64(__p0, __p1) __extension__ ({ \
+  float64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst2_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], 10); \
+})
+#define vst2_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 36); \
+})
+#else
+#define vst2q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x2_t __s1 = __p1; \
+  poly8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 38); \
+})
+#else
+#define vst2q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x2_t __s1 = __p1; \
+  poly64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 48); \
+})
+#else
+#define vst2q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x2_t __s1 = __p1; \
+  uint8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 51); \
+})
+#else
+#define vst2q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x2_t __s1 = __p1; \
+  uint64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 32); \
+})
+#else
+#define vst2q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x2_t __s1 = __p1; \
+  int8x16x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 42); \
+})
+#else
+#define vst2q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x2_t __s1 = __p1; \
+  float64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 42); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x2_t __s1 = __p1; \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], __p2, 35); \
+})
+#else
+#define vst2q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x2_t __s1 = __p1; \
+  int64x2x2_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __builtin_neon_vst2q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], __p2, 35); \
+})
+#endif
+
+#define vst2_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 19); \
+})
+#define vst2_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 10); \
+})
+#define vst2_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1x2_t __s1 = __p1; \
+  __builtin_neon_vst2_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], __p2, 3); \
+})
+#define vst3_p64(__p0, __p1) __extension__ ({ \
+  poly64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_p64(__p0, __p1) __extension__ ({ \
+  poly64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 38); \
+})
+#else
+#define vst3q_p64(__p0, __p1) __extension__ ({ \
+  poly64x2x3_t __s1 = __p1; \
+  poly64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_u64(__p0, __p1) __extension__ ({ \
+  uint64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 51); \
+})
+#else
+#define vst3q_u64(__p0, __p1) __extension__ ({ \
+  uint64x2x3_t __s1 = __p1; \
+  uint64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_f64(__p0, __p1) __extension__ ({ \
+  float64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 42); \
+})
+#else
+#define vst3q_f64(__p0, __p1) __extension__ ({ \
+  float64x2x3_t __s1 = __p1; \
+  float64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 42); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_s64(__p0, __p1) __extension__ ({ \
+  int64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], 35); \
+})
+#else
+#define vst3q_s64(__p0, __p1) __extension__ ({ \
+  int64x2x3_t __s1 = __p1; \
+  int64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], 35); \
+})
+#endif
+
+#define vst3_f64(__p0, __p1) __extension__ ({ \
+  float64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst3_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], 10); \
+})
+#define vst3_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 36); \
+})
+#else
+#define vst3q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x3_t __s1 = __p1; \
+  poly8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 38); \
+})
+#else
+#define vst3q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x3_t __s1 = __p1; \
+  poly64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 48); \
+})
+#else
+#define vst3q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x3_t __s1 = __p1; \
+  uint8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 51); \
+})
+#else
+#define vst3q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x3_t __s1 = __p1; \
+  uint64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 32); \
+})
+#else
+#define vst3q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x3_t __s1 = __p1; \
+  int8x16x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 42); \
+})
+#else
+#define vst3q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x3_t __s1 = __p1; \
+  float64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 42); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x3_t __s1 = __p1; \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], __p2, 35); \
+})
+#else
+#define vst3q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x3_t __s1 = __p1; \
+  int64x2x3_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __builtin_neon_vst3q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], __p2, 35); \
+})
+#endif
+
+#define vst3_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 19); \
+})
+#define vst3_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 10); \
+})
+#define vst3_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1x3_t __s1 = __p1; \
+  __builtin_neon_vst3_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], __p2, 3); \
+})
+#define vst4_p64(__p0, __p1) __extension__ ({ \
+  poly64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_p64(__p0, __p1) __extension__ ({ \
+  poly64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 38); \
+})
+#else
+#define vst4q_p64(__p0, __p1) __extension__ ({ \
+  poly64x2x4_t __s1 = __p1; \
+  poly64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_u64(__p0, __p1) __extension__ ({ \
+  uint64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 51); \
+})
+#else
+#define vst4q_u64(__p0, __p1) __extension__ ({ \
+  uint64x2x4_t __s1 = __p1; \
+  uint64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_f64(__p0, __p1) __extension__ ({ \
+  float64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 42); \
+})
+#else
+#define vst4q_f64(__p0, __p1) __extension__ ({ \
+  float64x2x4_t __s1 = __p1; \
+  float64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 42); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_s64(__p0, __p1) __extension__ ({ \
+  int64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], 35); \
+})
+#else
+#define vst4q_s64(__p0, __p1) __extension__ ({ \
+  int64x2x4_t __s1 = __p1; \
+  int64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4q_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], 35); \
+})
+#endif
+
+#define vst4_f64(__p0, __p1) __extension__ ({ \
+  float64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst4_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], 10); \
+})
+#define vst4_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 36); \
+})
+#else
+#define vst4q_lane_p8(__p0, __p1, __p2) __extension__ ({ \
+  poly8x16x4_t __s1 = __p1; \
+  poly8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 36); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 38); \
+})
+#else
+#define vst4q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2x4_t __s1 = __p1; \
+  poly64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 48); \
+})
+#else
+#define vst4q_lane_u8(__p0, __p1, __p2) __extension__ ({ \
+  uint8x16x4_t __s1 = __p1; \
+  uint8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 48); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 51); \
+})
+#else
+#define vst4q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2x4_t __s1 = __p1; \
+  uint64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 32); \
+})
+#else
+#define vst4q_lane_s8(__p0, __p1, __p2) __extension__ ({ \
+  int8x16x4_t __s1 = __p1; \
+  int8x16x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 32); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 42); \
+})
+#else
+#define vst4q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2x4_t __s1 = __p1; \
+  float64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 42); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vst4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x4_t __s1 = __p1; \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__s1.val[0], (int8x16_t)__s1.val[1], (int8x16_t)__s1.val[2], (int8x16_t)__s1.val[3], __p2, 35); \
+})
+#else
+#define vst4q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2x4_t __s1 = __p1; \
+  int64x2x4_t __rev1; \
+  __rev1.val[0] = __builtin_shufflevector(__s1.val[0], __s1.val[0], 1, 0); \
+  __rev1.val[1] = __builtin_shufflevector(__s1.val[1], __s1.val[1], 1, 0); \
+  __rev1.val[2] = __builtin_shufflevector(__s1.val[2], __s1.val[2], 1, 0); \
+  __rev1.val[3] = __builtin_shufflevector(__s1.val[3], __s1.val[3], 1, 0); \
+  __builtin_neon_vst4q_lane_v(__p0, (int8x16_t)__rev1.val[0], (int8x16_t)__rev1.val[1], (int8x16_t)__rev1.val[2], (int8x16_t)__rev1.val[3], __p2, 35); \
+})
+#endif
+
+#define vst4_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 19); \
+})
+#define vst4_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 10); \
+})
+#define vst4_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1x4_t __s1 = __p1; \
+  __builtin_neon_vst4_lane_v(__p0, (int8x8_t)__s1.val[0], (int8x8_t)__s1.val[1], (int8x8_t)__s1.val[2], (int8x8_t)__s1.val[3], __p2, 3); \
+})
+#define vstrq_p128(__p0, __p1) __extension__ ({ \
+  poly128_t __s1 = __p1; \
+  __builtin_neon_vstrq_p128(__p0, __s1); \
+})
+__ai __attribute__((target("neon"))) uint64_t vsubd_u64(uint64_t __p0, uint64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vsubd_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vsubd_s64(int64_t __p0, int64_t __p1) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vsubd_s64(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vsubq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vsubq_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __rev1;
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) float64x1_t vsub_f64(float64x1_t __p0, float64x1_t __p1) {
+  float64x1_t __ret;
+  __ret = __p0 - __p1;
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint16x8_t __ret;
+  __ret = vcombine_u16(__p0, vsubhn_u32(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vsubhn_high_u32(uint16x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint16x8_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u16(__rev0, __noswap_vsubhn_u32(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint32x4_t __ret;
+  __ret = vcombine_u32(__p0, vsubhn_u64(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vsubhn_high_u64(uint32x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint32x4_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __noswap_vcombine_u32(__rev0, __noswap_vsubhn_u64(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint8x16_t __ret;
+  __ret = vcombine_u8(__p0, vsubhn_u16(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vsubhn_high_u16(uint8x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint8x16_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_u8(__rev0, __noswap_vsubhn_u16(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int16x8_t __ret;
+  __ret = vcombine_s16(__p0, vsubhn_s32(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vsubhn_high_s32(int16x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int16x8_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s16(__rev0, __noswap_vsubhn_s32(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int32x4_t __ret;
+  __ret = vcombine_s32(__p0, vsubhn_s64(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vsubhn_high_s64(int32x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int32x4_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __noswap_vcombine_s32(__rev0, __noswap_vsubhn_s64(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int8x16_t __ret;
+  __ret = vcombine_s8(__p0, vsubhn_s16(__p1, __p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vsubhn_high_s16(int8x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int8x16_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcombine_s8(__rev0, __noswap_vsubhn_s16(__rev1, __rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vsubl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  __ret = vmovl_high_u8(__p0) - vmovl_high_u8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vsubl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_u8(__rev0) - __noswap_vmovl_high_u8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vsubl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  __ret = vmovl_high_u32(__p0) - vmovl_high_u32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vsubl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_u32(__rev0) - __noswap_vmovl_high_u32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vsubl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  __ret = vmovl_high_u16(__p0) - vmovl_high_u16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vsubl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_u16(__rev0) - __noswap_vmovl_high_u16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vsubl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  __ret = vmovl_high_s8(__p0) - vmovl_high_s8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vsubl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_s8(__rev0) - __noswap_vmovl_high_s8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vsubl_high_s32(int32x4_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  __ret = vmovl_high_s32(__p0) - vmovl_high_s32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vsubl_high_s32(int32x4_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_s32(__rev0) - __noswap_vmovl_high_s32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vsubl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  __ret = vmovl_high_s16(__p0) - vmovl_high_s16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vsubl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_s16(__rev0) - __noswap_vmovl_high_s16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vsubw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 - vmovl_high_u8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vsubw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_high_u8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vsubw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 - vmovl_high_u32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vsubw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_high_u32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vsubw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 - vmovl_high_u16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vsubw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_high_u16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vsubw_high_s8(int16x8_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 - vmovl_high_s8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vsubw_high_s8(int16x8_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_high_s8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vsubw_high_s32(int64x2_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 - vmovl_high_s32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vsubw_high_s32(int64x2_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_high_s32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vsubw_high_s16(int32x4_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 - vmovl_high_s16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vsubw_high_s16(int32x4_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmovl_high_s16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vtrn1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vtrn1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vtrn1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vtrn1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vtrn1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vtrn1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vtrn1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vtrn1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vtrn1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vtrn1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vtrn1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vtrn1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vtrn1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vtrn1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vtrn1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vtrn1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vtrn1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vtrn1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vtrn1q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vtrn1q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 2, 18, 4, 20, 6, 22, 8, 24, 10, 26, 12, 28, 14, 30);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vtrn1q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vtrn1q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vtrn1q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vtrn1q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vtrn1q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vtrn1q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vtrn1q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vtrn1q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vtrn1q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vtrn1q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtrn1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtrn1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vtrn1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vtrn1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vtrn1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vtrn1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vtrn1_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vtrn1_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vtrn1_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vtrn1_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vtrn1_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vtrn1_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vtrn1_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vtrn1_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vtrn1q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 2, 10, 4, 12, 6, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vtrn1q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 2, 10, 4, 12, 6, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vtrn1_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 2, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vtrn1_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 2, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vtrn2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vtrn2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vtrn2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vtrn2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vtrn2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vtrn2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vtrn2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vtrn2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vtrn2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vtrn2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vtrn2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vtrn2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vtrn2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vtrn2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vtrn2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vtrn2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vtrn2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vtrn2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vtrn2q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vtrn2q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 17, 3, 19, 5, 21, 7, 23, 9, 25, 11, 27, 13, 29, 15, 31);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vtrn2q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vtrn2q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vtrn2q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vtrn2q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vtrn2q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vtrn2q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vtrn2q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vtrn2q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vtrn2q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vtrn2q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vtrn2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vtrn2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vtrn2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vtrn2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vtrn2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vtrn2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vtrn2_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vtrn2_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vtrn2_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vtrn2_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vtrn2_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vtrn2_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vtrn2_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vtrn2_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vtrn2q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 9, 3, 11, 5, 13, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vtrn2q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 9, 3, 11, 5, 13, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vtrn2_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 5, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vtrn2_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 5, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vtst_p64(poly64x1_t __p0, poly64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  uint64x2_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vtstq_s64(int64x2_t __p0, int64x2_t __p1) {
+  uint64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vtstq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) uint64x1_t vtst_u64(uint64x1_t __p0, uint64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x1_t vtst_s64(int64x1_t __p0, int64x1_t __p1) {
+  uint64x1_t __ret;
+  __ret = (uint64x1_t) __builtin_neon_vtst_v((int8x8_t)__p0, (int8x8_t)__p1, 19);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vtstd_u64(uint64_t __p0, uint64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vtstd_u64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64_t vtstd_s64(int64_t __p0, int64_t __p1) {
+  uint64_t __ret;
+  __ret = (uint64_t) __builtin_neon_vtstd_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int8_t vuqaddb_s8(int8_t __p0, uint8_t __p1) {
+  int8_t __ret;
+  __ret = (int8_t) __builtin_neon_vuqaddb_s8(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32_t vuqadds_s32(int32_t __p0, uint32_t __p1) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vuqadds_s32(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64_t vuqaddd_s64(int64_t __p0, uint64_t __p1) {
+  int64_t __ret;
+  __ret = (int64_t) __builtin_neon_vuqaddd_s64(__p0, __p1);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16_t vuqaddh_s16(int16_t __p0, uint16_t __p1) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vuqaddh_s16(__p0, __p1);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vuqaddq_s8(int8x16_t __p0, uint8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vuqaddq_s8(int8x16_t __p0, uint8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vuqaddq_s32(int32x4_t __p0, uint32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vuqaddq_s32(int32x4_t __p0, uint32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vuqaddq_s64(int64x2_t __p0, uint64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vuqaddq_s64(int64x2_t __p0, uint64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vuqaddq_s16(int16x8_t __p0, uint16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vuqaddq_v((int8x16_t)__p0, (int8x16_t)__p1, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vuqaddq_s16(int16x8_t __p0, uint16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vuqaddq_v((int8x16_t)__rev0, (int8x16_t)__rev1, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vuqadd_s8(int8x8_t __p0, uint8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = (int8x8_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 0);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vuqadd_s8(int8x8_t __p0, uint8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x8_t) __builtin_neon_vuqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 0);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vuqadd_s32(int32x2_t __p0, uint32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = (int32x2_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vuqadd_s32(int32x2_t __p0, uint32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int32x2_t) __builtin_neon_vuqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("neon"))) int64x1_t vuqadd_s64(int64x1_t __p0, uint64x1_t __p1) {
+  int64x1_t __ret;
+  __ret = (int64x1_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 3);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vuqadd_s16(int16x4_t __p0, uint16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = (int16x4_t) __builtin_neon_vuqadd_v((int8x8_t)__p0, (int8x8_t)__p1, 1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vuqadd_s16(int16x4_t __p0, uint16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int16x4_t) __builtin_neon_vuqadd_v((int8x8_t)__rev0, (int8x8_t)__rev1, 1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vuzp1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vuzp1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vuzp1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vuzp1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vuzp1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vuzp1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vuzp1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vuzp1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vuzp1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vuzp1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vuzp1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vuzp1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vuzp1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vuzp1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vuzp1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vuzp1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vuzp1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vuzp1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vuzp1q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vuzp1q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vuzp1q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vuzp1q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vuzp1q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vuzp1q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vuzp1q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vuzp1q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vuzp1q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vuzp1q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vuzp1q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vuzp1q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vuzp1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vuzp1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vuzp1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vuzp1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vuzp1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vuzp1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vuzp1_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vuzp1_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vuzp1_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vuzp1_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vuzp1_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vuzp1_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vuzp1_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vuzp1_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vuzp1q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6, 8, 10, 12, 14);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vuzp1q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6, 8, 10, 12, 14);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vuzp1_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2, 4, 6);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vuzp1_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2, 4, 6);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vuzp2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vuzp2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vuzp2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vuzp2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vuzp2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vuzp2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vuzp2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vuzp2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vuzp2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vuzp2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vuzp2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vuzp2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vuzp2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vuzp2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vuzp2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vuzp2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vuzp2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vuzp2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vuzp2q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vuzp2q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vuzp2q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vuzp2q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vuzp2q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vuzp2q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vuzp2q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vuzp2q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vuzp2q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vuzp2q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vuzp2q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vuzp2q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vuzp2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vuzp2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vuzp2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vuzp2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vuzp2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vuzp2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vuzp2_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vuzp2_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vuzp2_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vuzp2_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vuzp2_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vuzp2_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vuzp2_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vuzp2_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vuzp2q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7, 9, 11, 13, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vuzp2q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7, 9, 11, 13, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vuzp2_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3, 5, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vuzp2_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3, 5, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vzip1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vzip1_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vzip1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vzip1_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vzip1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vzip1q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vzip1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vzip1q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vzip1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vzip1q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vzip1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vzip1q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vzip1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vzip1q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vzip1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vzip1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vzip1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vzip1q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vzip1q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vzip1q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vzip1q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vzip1q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vzip1q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vzip1q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vzip1q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vzip1q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vzip1q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vzip1q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vzip1q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vzip1q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vzip1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vzip1_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vzip1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vzip1_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vzip1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vzip1_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vzip1_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vzip1_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vzip1_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vzip1_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vzip1_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vzip1_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vzip1_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vzip1_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vzip1q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 8, 1, 9, 2, 10, 3, 11);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vzip1q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 8, 1, 9, 2, 10, 3, 11);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vzip1_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 0, 4, 1, 5);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vzip1_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 0, 4, 1, 5);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x8_t vzip2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x8_t vzip2_p8(poly8x8_t __p0, poly8x8_t __p1) {
+  poly8x8_t __ret;
+  poly8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x4_t vzip2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x4_t vzip2_p16(poly16x4_t __p0, poly16x4_t __p1) {
+  poly16x4_t __ret;
+  poly16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  poly16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly8x16_t vzip2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly8x16_t vzip2q_p8(poly8x16_t __p0, poly8x16_t __p1) {
+  poly8x16_t __ret;
+  poly8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly64x2_t vzip2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly64x2_t vzip2q_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly64x2_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) poly16x8_t vzip2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) poly16x8_t vzip2q_p16(poly16x8_t __p0, poly16x8_t __p1) {
+  poly16x8_t __ret;
+  poly16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  poly16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vzip2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vzip2q_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vzip2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vzip2q_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vzip2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vzip2q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vzip2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vzip2q_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vzip2q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vzip2q_s8(int8x16_t __p0, int8x16_t __p1) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float64x2_t vzip2q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float64x2_t vzip2q_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x4_t vzip2q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x4_t vzip2q_f32(float32x4_t __p0, float32x4_t __p1) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vzip2q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vzip2q_s32(int32x4_t __p0, int32x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vzip2q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vzip2q_s64(int64x2_t __p0, int64x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vzip2q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vzip2q_s16(int16x8_t __p0, int16x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vzip2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vzip2_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vzip2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vzip2_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vzip2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vzip2_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vzip2_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vzip2_s8(int8x8_t __p0, int8x8_t __p1) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float32x2_t vzip2_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float32x2_t vzip2_f32(float32x2_t __p0, float32x2_t __p1) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vzip2_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 1, 3);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vzip2_s32(int32x2_t __p0, int32x2_t __p1) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 1, 3);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vzip2_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vzip2_s16(int16x4_t __p0, int16x4_t __p1) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x8_t vzip2q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 4, 12, 5, 13, 6, 14, 7, 15);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x8_t vzip2q_f16(float16x8_t __p0, float16x8_t __p1) {
+  float16x8_t __ret;
+  float16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  float16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 4, 12, 5, 13, 6, 14, 7, 15);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) float16x4_t vzip2_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  __ret = __builtin_shufflevector(__p0, __p1, 2, 6, 3, 7);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) float16x4_t vzip2_f16(float16x4_t __p0, float16x4_t __p1) {
+  float16x4_t __ret;
+  float16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  float16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __builtin_shufflevector(__rev0, __rev1, 2, 6, 3, 7);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#define vldap1_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1_t __ret; \
+  poly64x1_t __s1 = __p1; \
+  __ret = (poly64x1_t) __builtin_neon_vldap1_lane_p64(__p0, (int8x8_t)__s1, __p2, 6); \
+  __ret; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vldap1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s1 = __p1; \
+  __ret = (poly64x2_t) __builtin_neon_vldap1q_lane_p64(__p0, (int8x16_t)__s1, __p2, 38); \
+  __ret; \
+})
+#else
+#define vldap1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __ret; \
+  poly64x2_t __s1 = __p1; \
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (poly64x2_t) __builtin_neon_vldap1q_lane_p64(__p0, (int8x16_t)__rev1, __p2, 38); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vldap1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s1 = __p1; \
+  __ret = (uint64x2_t) __builtin_neon_vldap1q_lane_u64(__p0, (int8x16_t)__s1, __p2, 51); \
+  __ret; \
+})
+#else
+#define vldap1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vldap1q_lane_u64(__p0, (int8x16_t)__rev1, __p2, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vldap1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s1 = __p1; \
+  __ret = (float64x2_t) __builtin_neon_vldap1q_lane_f64(__p0, (int8x16_t)__s1, __p2, 42); \
+  __ret; \
+})
+#else
+#define vldap1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __ret; \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (float64x2_t) __builtin_neon_vldap1q_lane_f64(__p0, (int8x16_t)__rev1, __p2, 42); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vldap1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s1 = __p1; \
+  __ret = (int64x2_t) __builtin_neon_vldap1q_lane_s64(__p0, (int8x16_t)__s1, __p2, 35); \
+  __ret; \
+})
+#else
+#define vldap1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __ret; \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (int64x2_t) __builtin_neon_vldap1q_lane_s64(__p0, (int8x16_t)__rev1, __p2, 35); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#define vldap1_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1_t __ret; \
+  uint64x1_t __s1 = __p1; \
+  __ret = (uint64x1_t) __builtin_neon_vldap1_lane_u64(__p0, (int8x8_t)__s1, __p2, 19); \
+  __ret; \
+})
+#define vldap1_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1_t __ret; \
+  float64x1_t __s1 = __p1; \
+  __ret = (float64x1_t) __builtin_neon_vldap1_lane_f64(__p0, (int8x8_t)__s1, __p2, 10); \
+  __ret; \
+})
+#define vldap1_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1_t __ret; \
+  int64x1_t __s1 = __p1; \
+  __ret = (int64x1_t) __builtin_neon_vldap1_lane_s64(__p0, (int8x8_t)__s1, __p2, 3); \
+  __ret; \
+})
+#define vstl1_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x1_t __s1 = __p1; \
+  __builtin_neon_vstl1_lane_p64(__p0, (int8x8_t)__s1, __p2, 6); \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vstl1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __s1 = __p1; \
+  __builtin_neon_vstl1q_lane_p64(__p0, (int8x16_t)__s1, __p2, 38); \
+})
+#else
+#define vstl1q_lane_p64(__p0, __p1, __p2) __extension__ ({ \
+  poly64x2_t __s1 = __p1; \
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vstl1q_lane_p64(__p0, (int8x16_t)__rev1, __p2, 38); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vstl1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __s1 = __p1; \
+  __builtin_neon_vstl1q_lane_u64(__p0, (int8x16_t)__s1, __p2, 51); \
+})
+#else
+#define vstl1q_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vstl1q_lane_u64(__p0, (int8x16_t)__rev1, __p2, 51); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vstl1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __s1 = __p1; \
+  __builtin_neon_vstl1q_lane_f64(__p0, (int8x16_t)__s1, __p2, 42); \
+})
+#else
+#define vstl1q_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x2_t __s1 = __p1; \
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vstl1q_lane_f64(__p0, (int8x16_t)__rev1, __p2, 42); \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vstl1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __s1 = __p1; \
+  __builtin_neon_vstl1q_lane_s64(__p0, (int8x16_t)__s1, __p2, 35); \
+})
+#else
+#define vstl1q_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x2_t __s1 = __p1; \
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __builtin_neon_vstl1q_lane_s64(__p0, (int8x16_t)__rev1, __p2, 35); \
+})
+#endif
+
+#define vstl1_lane_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x1_t __s1 = __p1; \
+  __builtin_neon_vstl1_lane_u64(__p0, (int8x8_t)__s1, __p2, 19); \
+})
+#define vstl1_lane_f64(__p0, __p1, __p2) __extension__ ({ \
+  float64x1_t __s1 = __p1; \
+  __builtin_neon_vstl1_lane_f64(__p0, (int8x8_t)__s1, __p2, 10); \
+})
+#define vstl1_lane_s64(__p0, __p1, __p2) __extension__ ({ \
+  int64x1_t __s1 = __p1; \
+  __builtin_neon_vstl1_lane_s64(__p0, (int8x8_t)__s1, __p2, 3); \
+})
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint8x16_t vbcaxq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_vbcaxq_u8((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint8x16_t vbcaxq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_vbcaxq_u8((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint32x4_t vbcaxq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vbcaxq_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint32x4_t vbcaxq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vbcaxq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vbcaxq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vbcaxq_u64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vbcaxq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vbcaxq_u64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint16x8_t vbcaxq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_vbcaxq_u16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint16x8_t vbcaxq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_vbcaxq_u16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) int8x16_t vbcaxq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_vbcaxq_s8((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) int8x16_t vbcaxq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_vbcaxq_s8((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) int32x4_t vbcaxq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_vbcaxq_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) int32x4_t vbcaxq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_vbcaxq_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) int64x2_t vbcaxq_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_vbcaxq_s64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) int64x2_t vbcaxq_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_vbcaxq_s64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) int16x8_t vbcaxq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_vbcaxq_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) int16x8_t vbcaxq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_vbcaxq_s16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint8x16_t veor3q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  __ret = (uint8x16_t) __builtin_neon_veor3q_u8((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 48);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint8x16_t veor3q_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint8x16_t) __builtin_neon_veor3q_u8((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 48);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint32x4_t veor3q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_veor3q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint32x4_t veor3q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_veor3q_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint64x2_t veor3q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_veor3q_u64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint64x2_t veor3q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_veor3q_u64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint16x8_t veor3q_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t) __builtin_neon_veor3q_u16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 49);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint16x8_t veor3q_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t) __builtin_neon_veor3q_u16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 49);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) int8x16_t veor3q_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  __ret = (int8x16_t) __builtin_neon_veor3q_s8((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 32);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) int8x16_t veor3q_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int8x16_t) __builtin_neon_veor3q_s8((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 32);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) int32x4_t veor3q_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  __ret = (int32x4_t) __builtin_neon_veor3q_s32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 34);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) int32x4_t veor3q_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (int32x4_t) __builtin_neon_veor3q_s32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 34);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) int64x2_t veor3q_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int64x2_t __ret;
+  __ret = (int64x2_t) __builtin_neon_veor3q_s64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 35);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) int64x2_t veor3q_s64(int64x2_t __p0, int64x2_t __p1, int64x2_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (int64x2_t) __builtin_neon_veor3q_s64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 35);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) int16x8_t veor3q_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  __ret = (int16x8_t) __builtin_neon_veor3q_s16((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 33);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) int16x8_t veor3q_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t) __builtin_neon_veor3q_s16((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 33);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vrax1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vrax1q_u64((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vrax1q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vrax1q_u64((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512hq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vsha512hq_u64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512hq_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vsha512hq_u64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512h2q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vsha512h2q_u64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512h2q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vsha512h2q_u64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512su0q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vsha512su0q_u64((int8x16_t)__p0, (int8x16_t)__p1, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512su0q_u64(uint64x2_t __p0, uint64x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vsha512su0q_u64((int8x16_t)__rev0, (int8x16_t)__rev1, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512su1q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t) __builtin_neon_vsha512su1q_u64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 51);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sha3,neon"))) uint64x2_t vsha512su1q_u64(uint64x2_t __p0, uint64x2_t __p1, uint64x2_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (uint64x2_t) __builtin_neon_vsha512su1q_u64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 51);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vxarq_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  __ret = (uint64x2_t) __builtin_neon_vxarq_u64((int8x16_t)__s0, (int8x16_t)__s1, __p2, 51); \
+  __ret; \
+})
+#else
+#define vxarq_u64(__p0, __p1, __p2) __extension__ ({ \
+  uint64x2_t __ret; \
+  uint64x2_t __s0 = __p0; \
+  uint64x2_t __s1 = __p1; \
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 1, 0); \
+  uint64x2_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 1, 0); \
+  __ret = (uint64x2_t) __builtin_neon_vxarq_u64((int8x16_t)__rev0, (int8x16_t)__rev1, __p2, 51); \
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3partw1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsm3partw1q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3partw1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsm3partw1q_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3partw2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsm3partw2q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3partw2q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsm3partw2q_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3ss1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsm3ss1q_u32((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm3ss1q_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsm3ss1q_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsm3tt1aq_u32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __s2 = __p2; \
+  __ret = (uint32x4_t) __builtin_neon_vsm3tt1aq_u32((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 50); \
+  __ret; \
+})
+#else
+#define vsm3tt1aq_u32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __s2 = __p2; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vsm3tt1aq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsm3tt1bq_u32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __s2 = __p2; \
+  __ret = (uint32x4_t) __builtin_neon_vsm3tt1bq_u32((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 50); \
+  __ret; \
+})
+#else
+#define vsm3tt1bq_u32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __s2 = __p2; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vsm3tt1bq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsm3tt2aq_u32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __s2 = __p2; \
+  __ret = (uint32x4_t) __builtin_neon_vsm3tt2aq_u32((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 50); \
+  __ret; \
+})
+#else
+#define vsm3tt2aq_u32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __s2 = __p2; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vsm3tt2aq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsm3tt2bq_u32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __s2 = __p2; \
+  __ret = (uint32x4_t) __builtin_neon_vsm3tt2bq_u32((int8x16_t)__s0, (int8x16_t)__s1, (int8x16_t)__s2, __p3, 50); \
+  __ret; \
+})
+#else
+#define vsm3tt2bq_u32(__p0, __p1, __p2, __p3) __extension__ ({ \
+  uint32x4_t __ret; \
+  uint32x4_t __s0 = __p0; \
+  uint32x4_t __s1 = __p1; \
+  uint32x4_t __s2 = __p2; \
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__s0, __s0, 3, 2, 1, 0); \
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__s1, __s1, 3, 2, 1, 0); \
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__s2, __s2, 3, 2, 1, 0); \
+  __ret = (uint32x4_t) __builtin_neon_vsm3tt2bq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, __p3, 50); \
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0); \
+  __ret; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm4eq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsm4eq_u32((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm4eq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsm4eq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm4ekeyq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t) __builtin_neon_vsm4ekeyq_u32((int8x16_t)__p0, (int8x16_t)__p1, 50);
+  return __ret;
+}
+#else
+__ai __attribute__((target("sm4,neon"))) uint32x4_t vsm4ekeyq_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t) __builtin_neon_vsm4ekeyq_u32((int8x16_t)__rev0, (int8x16_t)__rev1, 50);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("v8.1a,neon"))) int32_t vqrdmlahs_s32(int32_t __p0, int32_t __p1, int32_t __p2) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqrdmlahs_s32(__p0, __p1, __p2);
+  return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int16_t vqrdmlahh_s16(int16_t __p0, int16_t __p1, int16_t __p2) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqrdmlahh_s16(__p0, __p1, __p2);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlahs_lane_s32(__p0_760, __p1_760, __p2_760, __p3_760) __extension__ ({ \
+  int32_t __ret_760; \
+  int32_t __s0_760 = __p0_760; \
+  int32_t __s1_760 = __p1_760; \
+  int32x2_t __s2_760 = __p2_760; \
+  __ret_760 = vqrdmlahs_s32(__s0_760, __s1_760, vget_lane_s32(__s2_760, __p3_760)); \
+  __ret_760; \
+})
+#else
+#define vqrdmlahs_lane_s32(__p0_761, __p1_761, __p2_761, __p3_761) __extension__ ({ \
+  int32_t __ret_761; \
+  int32_t __s0_761 = __p0_761; \
+  int32_t __s1_761 = __p1_761; \
+  int32x2_t __s2_761 = __p2_761; \
+  int32x2_t __rev2_761;  __rev2_761 = __builtin_shufflevector(__s2_761, __s2_761, 1, 0); \
+  __ret_761 = vqrdmlahs_s32(__s0_761, __s1_761, __noswap_vget_lane_s32(__rev2_761, __p3_761)); \
+  __ret_761; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlahh_lane_s16(__p0_762, __p1_762, __p2_762, __p3_762) __extension__ ({ \
+  int16_t __ret_762; \
+  int16_t __s0_762 = __p0_762; \
+  int16_t __s1_762 = __p1_762; \
+  int16x4_t __s2_762 = __p2_762; \
+  __ret_762 = vqrdmlahh_s16(__s0_762, __s1_762, vget_lane_s16(__s2_762, __p3_762)); \
+  __ret_762; \
+})
+#else
+#define vqrdmlahh_lane_s16(__p0_763, __p1_763, __p2_763, __p3_763) __extension__ ({ \
+  int16_t __ret_763; \
+  int16_t __s0_763 = __p0_763; \
+  int16_t __s1_763 = __p1_763; \
+  int16x4_t __s2_763 = __p2_763; \
+  int16x4_t __rev2_763;  __rev2_763 = __builtin_shufflevector(__s2_763, __s2_763, 3, 2, 1, 0); \
+  __ret_763 = vqrdmlahh_s16(__s0_763, __s1_763, __noswap_vget_lane_s16(__rev2_763, __p3_763)); \
+  __ret_763; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlahs_laneq_s32(__p0_764, __p1_764, __p2_764, __p3_764) __extension__ ({ \
+  int32_t __ret_764; \
+  int32_t __s0_764 = __p0_764; \
+  int32_t __s1_764 = __p1_764; \
+  int32x4_t __s2_764 = __p2_764; \
+  __ret_764 = vqrdmlahs_s32(__s0_764, __s1_764, vgetq_lane_s32(__s2_764, __p3_764)); \
+  __ret_764; \
+})
+#else
+#define vqrdmlahs_laneq_s32(__p0_765, __p1_765, __p2_765, __p3_765) __extension__ ({ \
+  int32_t __ret_765; \
+  int32_t __s0_765 = __p0_765; \
+  int32_t __s1_765 = __p1_765; \
+  int32x4_t __s2_765 = __p2_765; \
+  int32x4_t __rev2_765;  __rev2_765 = __builtin_shufflevector(__s2_765, __s2_765, 3, 2, 1, 0); \
+  __ret_765 = vqrdmlahs_s32(__s0_765, __s1_765, __noswap_vgetq_lane_s32(__rev2_765, __p3_765)); \
+  __ret_765; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlahh_laneq_s16(__p0_766, __p1_766, __p2_766, __p3_766) __extension__ ({ \
+  int16_t __ret_766; \
+  int16_t __s0_766 = __p0_766; \
+  int16_t __s1_766 = __p1_766; \
+  int16x8_t __s2_766 = __p2_766; \
+  __ret_766 = vqrdmlahh_s16(__s0_766, __s1_766, vgetq_lane_s16(__s2_766, __p3_766)); \
+  __ret_766; \
+})
+#else
+#define vqrdmlahh_laneq_s16(__p0_767, __p1_767, __p2_767, __p3_767) __extension__ ({ \
+  int16_t __ret_767; \
+  int16_t __s0_767 = __p0_767; \
+  int16_t __s1_767 = __p1_767; \
+  int16x8_t __s2_767 = __p2_767; \
+  int16x8_t __rev2_767;  __rev2_767 = __builtin_shufflevector(__s2_767, __s2_767, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_767 = vqrdmlahh_s16(__s0_767, __s1_767, __noswap_vgetq_lane_s16(__rev2_767, __p3_767)); \
+  __ret_767; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlahq_laneq_s32(__p0_768, __p1_768, __p2_768, __p3_768) __extension__ ({ \
+  int32x4_t __ret_768; \
+  int32x4_t __s0_768 = __p0_768; \
+  int32x4_t __s1_768 = __p1_768; \
+  int32x4_t __s2_768 = __p2_768; \
+  __ret_768 = vqrdmlahq_s32(__s0_768, __s1_768, splatq_laneq_s32(__s2_768, __p3_768)); \
+  __ret_768; \
+})
+#else
+#define vqrdmlahq_laneq_s32(__p0_769, __p1_769, __p2_769, __p3_769) __extension__ ({ \
+  int32x4_t __ret_769; \
+  int32x4_t __s0_769 = __p0_769; \
+  int32x4_t __s1_769 = __p1_769; \
+  int32x4_t __s2_769 = __p2_769; \
+  int32x4_t __rev0_769;  __rev0_769 = __builtin_shufflevector(__s0_769, __s0_769, 3, 2, 1, 0); \
+  int32x4_t __rev1_769;  __rev1_769 = __builtin_shufflevector(__s1_769, __s1_769, 3, 2, 1, 0); \
+  int32x4_t __rev2_769;  __rev2_769 = __builtin_shufflevector(__s2_769, __s2_769, 3, 2, 1, 0); \
+  __ret_769 = __noswap_vqrdmlahq_s32(__rev0_769, __rev1_769, __noswap_splatq_laneq_s32(__rev2_769, __p3_769)); \
+  __ret_769 = __builtin_shufflevector(__ret_769, __ret_769, 3, 2, 1, 0); \
+  __ret_769; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlahq_laneq_s16(__p0_770, __p1_770, __p2_770, __p3_770) __extension__ ({ \
+  int16x8_t __ret_770; \
+  int16x8_t __s0_770 = __p0_770; \
+  int16x8_t __s1_770 = __p1_770; \
+  int16x8_t __s2_770 = __p2_770; \
+  __ret_770 = vqrdmlahq_s16(__s0_770, __s1_770, splatq_laneq_s16(__s2_770, __p3_770)); \
+  __ret_770; \
+})
+#else
+#define vqrdmlahq_laneq_s16(__p0_771, __p1_771, __p2_771, __p3_771) __extension__ ({ \
+  int16x8_t __ret_771; \
+  int16x8_t __s0_771 = __p0_771; \
+  int16x8_t __s1_771 = __p1_771; \
+  int16x8_t __s2_771 = __p2_771; \
+  int16x8_t __rev0_771;  __rev0_771 = __builtin_shufflevector(__s0_771, __s0_771, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_771;  __rev1_771 = __builtin_shufflevector(__s1_771, __s1_771, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev2_771;  __rev2_771 = __builtin_shufflevector(__s2_771, __s2_771, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_771 = __noswap_vqrdmlahq_s16(__rev0_771, __rev1_771, __noswap_splatq_laneq_s16(__rev2_771, __p3_771)); \
+  __ret_771 = __builtin_shufflevector(__ret_771, __ret_771, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_771; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlah_laneq_s32(__p0_772, __p1_772, __p2_772, __p3_772) __extension__ ({ \
+  int32x2_t __ret_772; \
+  int32x2_t __s0_772 = __p0_772; \
+  int32x2_t __s1_772 = __p1_772; \
+  int32x4_t __s2_772 = __p2_772; \
+  __ret_772 = vqrdmlah_s32(__s0_772, __s1_772, splat_laneq_s32(__s2_772, __p3_772)); \
+  __ret_772; \
+})
+#else
+#define vqrdmlah_laneq_s32(__p0_773, __p1_773, __p2_773, __p3_773) __extension__ ({ \
+  int32x2_t __ret_773; \
+  int32x2_t __s0_773 = __p0_773; \
+  int32x2_t __s1_773 = __p1_773; \
+  int32x4_t __s2_773 = __p2_773; \
+  int32x2_t __rev0_773;  __rev0_773 = __builtin_shufflevector(__s0_773, __s0_773, 1, 0); \
+  int32x2_t __rev1_773;  __rev1_773 = __builtin_shufflevector(__s1_773, __s1_773, 1, 0); \
+  int32x4_t __rev2_773;  __rev2_773 = __builtin_shufflevector(__s2_773, __s2_773, 3, 2, 1, 0); \
+  __ret_773 = __noswap_vqrdmlah_s32(__rev0_773, __rev1_773, __noswap_splat_laneq_s32(__rev2_773, __p3_773)); \
+  __ret_773 = __builtin_shufflevector(__ret_773, __ret_773, 1, 0); \
+  __ret_773; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlah_laneq_s16(__p0_774, __p1_774, __p2_774, __p3_774) __extension__ ({ \
+  int16x4_t __ret_774; \
+  int16x4_t __s0_774 = __p0_774; \
+  int16x4_t __s1_774 = __p1_774; \
+  int16x8_t __s2_774 = __p2_774; \
+  __ret_774 = vqrdmlah_s16(__s0_774, __s1_774, splat_laneq_s16(__s2_774, __p3_774)); \
+  __ret_774; \
+})
+#else
+#define vqrdmlah_laneq_s16(__p0_775, __p1_775, __p2_775, __p3_775) __extension__ ({ \
+  int16x4_t __ret_775; \
+  int16x4_t __s0_775 = __p0_775; \
+  int16x4_t __s1_775 = __p1_775; \
+  int16x8_t __s2_775 = __p2_775; \
+  int16x4_t __rev0_775;  __rev0_775 = __builtin_shufflevector(__s0_775, __s0_775, 3, 2, 1, 0); \
+  int16x4_t __rev1_775;  __rev1_775 = __builtin_shufflevector(__s1_775, __s1_775, 3, 2, 1, 0); \
+  int16x8_t __rev2_775;  __rev2_775 = __builtin_shufflevector(__s2_775, __s2_775, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_775 = __noswap_vqrdmlah_s16(__rev0_775, __rev1_775, __noswap_splat_laneq_s16(__rev2_775, __p3_775)); \
+  __ret_775 = __builtin_shufflevector(__ret_775, __ret_775, 3, 2, 1, 0); \
+  __ret_775; \
+})
+#endif
+
+__ai __attribute__((target("v8.1a,neon"))) int32_t vqrdmlshs_s32(int32_t __p0, int32_t __p1, int32_t __p2) {
+  int32_t __ret;
+  __ret = (int32_t) __builtin_neon_vqrdmlshs_s32(__p0, __p1, __p2);
+  return __ret;
+}
+__ai __attribute__((target("v8.1a,neon"))) int16_t vqrdmlshh_s16(int16_t __p0, int16_t __p1, int16_t __p2) {
+  int16_t __ret;
+  __ret = (int16_t) __builtin_neon_vqrdmlshh_s16(__p0, __p1, __p2);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlshs_lane_s32(__p0_776, __p1_776, __p2_776, __p3_776) __extension__ ({ \
+  int32_t __ret_776; \
+  int32_t __s0_776 = __p0_776; \
+  int32_t __s1_776 = __p1_776; \
+  int32x2_t __s2_776 = __p2_776; \
+  __ret_776 = vqrdmlshs_s32(__s0_776, __s1_776, vget_lane_s32(__s2_776, __p3_776)); \
+  __ret_776; \
+})
+#else
+#define vqrdmlshs_lane_s32(__p0_777, __p1_777, __p2_777, __p3_777) __extension__ ({ \
+  int32_t __ret_777; \
+  int32_t __s0_777 = __p0_777; \
+  int32_t __s1_777 = __p1_777; \
+  int32x2_t __s2_777 = __p2_777; \
+  int32x2_t __rev2_777;  __rev2_777 = __builtin_shufflevector(__s2_777, __s2_777, 1, 0); \
+  __ret_777 = vqrdmlshs_s32(__s0_777, __s1_777, __noswap_vget_lane_s32(__rev2_777, __p3_777)); \
+  __ret_777; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlshh_lane_s16(__p0_778, __p1_778, __p2_778, __p3_778) __extension__ ({ \
+  int16_t __ret_778; \
+  int16_t __s0_778 = __p0_778; \
+  int16_t __s1_778 = __p1_778; \
+  int16x4_t __s2_778 = __p2_778; \
+  __ret_778 = vqrdmlshh_s16(__s0_778, __s1_778, vget_lane_s16(__s2_778, __p3_778)); \
+  __ret_778; \
+})
+#else
+#define vqrdmlshh_lane_s16(__p0_779, __p1_779, __p2_779, __p3_779) __extension__ ({ \
+  int16_t __ret_779; \
+  int16_t __s0_779 = __p0_779; \
+  int16_t __s1_779 = __p1_779; \
+  int16x4_t __s2_779 = __p2_779; \
+  int16x4_t __rev2_779;  __rev2_779 = __builtin_shufflevector(__s2_779, __s2_779, 3, 2, 1, 0); \
+  __ret_779 = vqrdmlshh_s16(__s0_779, __s1_779, __noswap_vget_lane_s16(__rev2_779, __p3_779)); \
+  __ret_779; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlshs_laneq_s32(__p0_780, __p1_780, __p2_780, __p3_780) __extension__ ({ \
+  int32_t __ret_780; \
+  int32_t __s0_780 = __p0_780; \
+  int32_t __s1_780 = __p1_780; \
+  int32x4_t __s2_780 = __p2_780; \
+  __ret_780 = vqrdmlshs_s32(__s0_780, __s1_780, vgetq_lane_s32(__s2_780, __p3_780)); \
+  __ret_780; \
+})
+#else
+#define vqrdmlshs_laneq_s32(__p0_781, __p1_781, __p2_781, __p3_781) __extension__ ({ \
+  int32_t __ret_781; \
+  int32_t __s0_781 = __p0_781; \
+  int32_t __s1_781 = __p1_781; \
+  int32x4_t __s2_781 = __p2_781; \
+  int32x4_t __rev2_781;  __rev2_781 = __builtin_shufflevector(__s2_781, __s2_781, 3, 2, 1, 0); \
+  __ret_781 = vqrdmlshs_s32(__s0_781, __s1_781, __noswap_vgetq_lane_s32(__rev2_781, __p3_781)); \
+  __ret_781; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlshh_laneq_s16(__p0_782, __p1_782, __p2_782, __p3_782) __extension__ ({ \
+  int16_t __ret_782; \
+  int16_t __s0_782 = __p0_782; \
+  int16_t __s1_782 = __p1_782; \
+  int16x8_t __s2_782 = __p2_782; \
+  __ret_782 = vqrdmlshh_s16(__s0_782, __s1_782, vgetq_lane_s16(__s2_782, __p3_782)); \
+  __ret_782; \
+})
+#else
+#define vqrdmlshh_laneq_s16(__p0_783, __p1_783, __p2_783, __p3_783) __extension__ ({ \
+  int16_t __ret_783; \
+  int16_t __s0_783 = __p0_783; \
+  int16_t __s1_783 = __p1_783; \
+  int16x8_t __s2_783 = __p2_783; \
+  int16x8_t __rev2_783;  __rev2_783 = __builtin_shufflevector(__s2_783, __s2_783, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_783 = vqrdmlshh_s16(__s0_783, __s1_783, __noswap_vgetq_lane_s16(__rev2_783, __p3_783)); \
+  __ret_783; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlshq_laneq_s32(__p0_784, __p1_784, __p2_784, __p3_784) __extension__ ({ \
+  int32x4_t __ret_784; \
+  int32x4_t __s0_784 = __p0_784; \
+  int32x4_t __s1_784 = __p1_784; \
+  int32x4_t __s2_784 = __p2_784; \
+  __ret_784 = vqrdmlshq_s32(__s0_784, __s1_784, splatq_laneq_s32(__s2_784, __p3_784)); \
+  __ret_784; \
+})
+#else
+#define vqrdmlshq_laneq_s32(__p0_785, __p1_785, __p2_785, __p3_785) __extension__ ({ \
+  int32x4_t __ret_785; \
+  int32x4_t __s0_785 = __p0_785; \
+  int32x4_t __s1_785 = __p1_785; \
+  int32x4_t __s2_785 = __p2_785; \
+  int32x4_t __rev0_785;  __rev0_785 = __builtin_shufflevector(__s0_785, __s0_785, 3, 2, 1, 0); \
+  int32x4_t __rev1_785;  __rev1_785 = __builtin_shufflevector(__s1_785, __s1_785, 3, 2, 1, 0); \
+  int32x4_t __rev2_785;  __rev2_785 = __builtin_shufflevector(__s2_785, __s2_785, 3, 2, 1, 0); \
+  __ret_785 = __noswap_vqrdmlshq_s32(__rev0_785, __rev1_785, __noswap_splatq_laneq_s32(__rev2_785, __p3_785)); \
+  __ret_785 = __builtin_shufflevector(__ret_785, __ret_785, 3, 2, 1, 0); \
+  __ret_785; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlshq_laneq_s16(__p0_786, __p1_786, __p2_786, __p3_786) __extension__ ({ \
+  int16x8_t __ret_786; \
+  int16x8_t __s0_786 = __p0_786; \
+  int16x8_t __s1_786 = __p1_786; \
+  int16x8_t __s2_786 = __p2_786; \
+  __ret_786 = vqrdmlshq_s16(__s0_786, __s1_786, splatq_laneq_s16(__s2_786, __p3_786)); \
+  __ret_786; \
+})
+#else
+#define vqrdmlshq_laneq_s16(__p0_787, __p1_787, __p2_787, __p3_787) __extension__ ({ \
+  int16x8_t __ret_787; \
+  int16x8_t __s0_787 = __p0_787; \
+  int16x8_t __s1_787 = __p1_787; \
+  int16x8_t __s2_787 = __p2_787; \
+  int16x8_t __rev0_787;  __rev0_787 = __builtin_shufflevector(__s0_787, __s0_787, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev1_787;  __rev1_787 = __builtin_shufflevector(__s1_787, __s1_787, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int16x8_t __rev2_787;  __rev2_787 = __builtin_shufflevector(__s2_787, __s2_787, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_787 = __noswap_vqrdmlshq_s16(__rev0_787, __rev1_787, __noswap_splatq_laneq_s16(__rev2_787, __p3_787)); \
+  __ret_787 = __builtin_shufflevector(__ret_787, __ret_787, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_787; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlsh_laneq_s32(__p0_788, __p1_788, __p2_788, __p3_788) __extension__ ({ \
+  int32x2_t __ret_788; \
+  int32x2_t __s0_788 = __p0_788; \
+  int32x2_t __s1_788 = __p1_788; \
+  int32x4_t __s2_788 = __p2_788; \
+  __ret_788 = vqrdmlsh_s32(__s0_788, __s1_788, splat_laneq_s32(__s2_788, __p3_788)); \
+  __ret_788; \
+})
+#else
+#define vqrdmlsh_laneq_s32(__p0_789, __p1_789, __p2_789, __p3_789) __extension__ ({ \
+  int32x2_t __ret_789; \
+  int32x2_t __s0_789 = __p0_789; \
+  int32x2_t __s1_789 = __p1_789; \
+  int32x4_t __s2_789 = __p2_789; \
+  int32x2_t __rev0_789;  __rev0_789 = __builtin_shufflevector(__s0_789, __s0_789, 1, 0); \
+  int32x2_t __rev1_789;  __rev1_789 = __builtin_shufflevector(__s1_789, __s1_789, 1, 0); \
+  int32x4_t __rev2_789;  __rev2_789 = __builtin_shufflevector(__s2_789, __s2_789, 3, 2, 1, 0); \
+  __ret_789 = __noswap_vqrdmlsh_s32(__rev0_789, __rev1_789, __noswap_splat_laneq_s32(__rev2_789, __p3_789)); \
+  __ret_789 = __builtin_shufflevector(__ret_789, __ret_789, 1, 0); \
+  __ret_789; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vqrdmlsh_laneq_s16(__p0_790, __p1_790, __p2_790, __p3_790) __extension__ ({ \
+  int16x4_t __ret_790; \
+  int16x4_t __s0_790 = __p0_790; \
+  int16x4_t __s1_790 = __p1_790; \
+  int16x8_t __s2_790 = __p2_790; \
+  __ret_790 = vqrdmlsh_s16(__s0_790, __s1_790, splat_laneq_s16(__s2_790, __p3_790)); \
+  __ret_790; \
+})
+#else
+#define vqrdmlsh_laneq_s16(__p0_791, __p1_791, __p2_791, __p3_791) __extension__ ({ \
+  int16x4_t __ret_791; \
+  int16x4_t __s0_791 = __p0_791; \
+  int16x4_t __s1_791 = __p1_791; \
+  int16x8_t __s2_791 = __p2_791; \
+  int16x4_t __rev0_791;  __rev0_791 = __builtin_shufflevector(__s0_791, __s0_791, 3, 2, 1, 0); \
+  int16x4_t __rev1_791;  __rev1_791 = __builtin_shufflevector(__s1_791, __s1_791, 3, 2, 1, 0); \
+  int16x8_t __rev2_791;  __rev2_791 = __builtin_shufflevector(__s2_791, __s2_791, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_791 = __noswap_vqrdmlsh_s16(__rev0_791, __rev1_791, __noswap_splat_laneq_s16(__rev2_791, __p3_791)); \
+  __ret_791 = __builtin_shufflevector(__ret_791, __ret_791, 3, 2, 1, 0); \
+  __ret_791; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcaddq_rot270_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcaddq_rot270_f64((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcaddq_rot270_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vcaddq_rot270_f64((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcaddq_rot90_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcaddq_rot90_f64((int8x16_t)__p0, (int8x16_t)__p1, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcaddq_rot90_f64(float64x2_t __p0, float64x2_t __p1) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vcaddq_rot90_f64((int8x16_t)__rev0, (int8x16_t)__rev1, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_f64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t __noswap_vcmlaq_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("v8.3a,neon"))) float64x1_t vcmla_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vcmla_f64((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
+  return __ret;
+}
+#define vcmla_lane_f64(__p0_792, __p1_792, __p2_792, __p3_792) __extension__ ({ \
+  float64x1_t __ret_792; \
+  float64x1_t __s0_792 = __p0_792; \
+  float64x1_t __s1_792 = __p1_792; \
+  float64x1_t __s2_792 = __p2_792; \
+float64x1_t __reint_792 = __s2_792; \
+uint64x2_t __reint1_792 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_792, __p3_792), vgetq_lane_u64(*(uint64x2_t *) &__reint_792, __p3_792)}; \
+  __ret_792 = vcmla_f64(__s0_792, __s1_792, *(float64x1_t *) &__reint1_792); \
+  __ret_792; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_lane_f64(__p0_793, __p1_793, __p2_793, __p3_793) __extension__ ({ \
+  float64x2_t __ret_793; \
+  float64x2_t __s0_793 = __p0_793; \
+  float64x2_t __s1_793 = __p1_793; \
+  float64x1_t __s2_793 = __p2_793; \
+float64x1_t __reint_793 = __s2_793; \
+uint64x2_t __reint1_793 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_793, __p3_793), vgetq_lane_u64(*(uint64x2_t *) &__reint_793, __p3_793)}; \
+  __ret_793 = vcmlaq_f64(__s0_793, __s1_793, *(float64x2_t *) &__reint1_793); \
+  __ret_793; \
+})
+#else
+#define vcmlaq_lane_f64(__p0_794, __p1_794, __p2_794, __p3_794) __extension__ ({ \
+  float64x2_t __ret_794; \
+  float64x2_t __s0_794 = __p0_794; \
+  float64x2_t __s1_794 = __p1_794; \
+  float64x1_t __s2_794 = __p2_794; \
+  float64x2_t __rev0_794;  __rev0_794 = __builtin_shufflevector(__s0_794, __s0_794, 1, 0); \
+  float64x2_t __rev1_794;  __rev1_794 = __builtin_shufflevector(__s1_794, __s1_794, 1, 0); \
+float64x1_t __reint_794 = __s2_794; \
+uint64x2_t __reint1_794 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_794, __p3_794), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_794, __p3_794)}; \
+  __ret_794 = __noswap_vcmlaq_f64(__rev0_794, __rev1_794, *(float64x2_t *) &__reint1_794); \
+  __ret_794 = __builtin_shufflevector(__ret_794, __ret_794, 1, 0); \
+  __ret_794; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_laneq_f64(__p0_795, __p1_795, __p2_795, __p3_795) __extension__ ({ \
+  float64x1_t __ret_795; \
+  float64x1_t __s0_795 = __p0_795; \
+  float64x1_t __s1_795 = __p1_795; \
+  float64x2_t __s2_795 = __p2_795; \
+float64x2_t __reint_795 = __s2_795; \
+uint64x2_t __reint1_795 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_795, __p3_795), vgetq_lane_u64(*(uint64x2_t *) &__reint_795, __p3_795)}; \
+  __ret_795 = vcmla_f64(__s0_795, __s1_795, *(float64x1_t *) &__reint1_795); \
+  __ret_795; \
+})
+#else
+#define vcmla_laneq_f64(__p0_796, __p1_796, __p2_796, __p3_796) __extension__ ({ \
+  float64x1_t __ret_796; \
+  float64x1_t __s0_796 = __p0_796; \
+  float64x1_t __s1_796 = __p1_796; \
+  float64x2_t __s2_796 = __p2_796; \
+  float64x2_t __rev2_796;  __rev2_796 = __builtin_shufflevector(__s2_796, __s2_796, 1, 0); \
+float64x2_t __reint_796 = __rev2_796; \
+uint64x2_t __reint1_796 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_796, __p3_796), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_796, __p3_796)}; \
+  __ret_796 = vcmla_f64(__s0_796, __s1_796, *(float64x1_t *) &__reint1_796); \
+  __ret_796; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_laneq_f64(__p0_797, __p1_797, __p2_797, __p3_797) __extension__ ({ \
+  float64x2_t __ret_797; \
+  float64x2_t __s0_797 = __p0_797; \
+  float64x2_t __s1_797 = __p1_797; \
+  float64x2_t __s2_797 = __p2_797; \
+float64x2_t __reint_797 = __s2_797; \
+uint64x2_t __reint1_797 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_797, __p3_797), vgetq_lane_u64(*(uint64x2_t *) &__reint_797, __p3_797)}; \
+  __ret_797 = vcmlaq_f64(__s0_797, __s1_797, *(float64x2_t *) &__reint1_797); \
+  __ret_797; \
+})
+#else
+#define vcmlaq_laneq_f64(__p0_798, __p1_798, __p2_798, __p3_798) __extension__ ({ \
+  float64x2_t __ret_798; \
+  float64x2_t __s0_798 = __p0_798; \
+  float64x2_t __s1_798 = __p1_798; \
+  float64x2_t __s2_798 = __p2_798; \
+  float64x2_t __rev0_798;  __rev0_798 = __builtin_shufflevector(__s0_798, __s0_798, 1, 0); \
+  float64x2_t __rev1_798;  __rev1_798 = __builtin_shufflevector(__s1_798, __s1_798, 1, 0); \
+  float64x2_t __rev2_798;  __rev2_798 = __builtin_shufflevector(__s2_798, __s2_798, 1, 0); \
+float64x2_t __reint_798 = __rev2_798; \
+uint64x2_t __reint1_798 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_798, __p3_798), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_798, __p3_798)}; \
+  __ret_798 = __noswap_vcmlaq_f64(__rev0_798, __rev1_798, *(float64x2_t *) &__reint1_798); \
+  __ret_798 = __builtin_shufflevector(__ret_798, __ret_798, 1, 0); \
+  __ret_798; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot180_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_rot180_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot180_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_rot180_f64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t __noswap_vcmlaq_rot180_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_rot180_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("v8.3a,neon"))) float64x1_t vcmla_rot180_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vcmla_rot180_f64((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
+  return __ret;
+}
+#define vcmla_rot180_lane_f64(__p0_799, __p1_799, __p2_799, __p3_799) __extension__ ({ \
+  float64x1_t __ret_799; \
+  float64x1_t __s0_799 = __p0_799; \
+  float64x1_t __s1_799 = __p1_799; \
+  float64x1_t __s2_799 = __p2_799; \
+float64x1_t __reint_799 = __s2_799; \
+uint64x2_t __reint1_799 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_799, __p3_799), vgetq_lane_u64(*(uint64x2_t *) &__reint_799, __p3_799)}; \
+  __ret_799 = vcmla_rot180_f64(__s0_799, __s1_799, *(float64x1_t *) &__reint1_799); \
+  __ret_799; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot180_lane_f64(__p0_800, __p1_800, __p2_800, __p3_800) __extension__ ({ \
+  float64x2_t __ret_800; \
+  float64x2_t __s0_800 = __p0_800; \
+  float64x2_t __s1_800 = __p1_800; \
+  float64x1_t __s2_800 = __p2_800; \
+float64x1_t __reint_800 = __s2_800; \
+uint64x2_t __reint1_800 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_800, __p3_800), vgetq_lane_u64(*(uint64x2_t *) &__reint_800, __p3_800)}; \
+  __ret_800 = vcmlaq_rot180_f64(__s0_800, __s1_800, *(float64x2_t *) &__reint1_800); \
+  __ret_800; \
+})
+#else
+#define vcmlaq_rot180_lane_f64(__p0_801, __p1_801, __p2_801, __p3_801) __extension__ ({ \
+  float64x2_t __ret_801; \
+  float64x2_t __s0_801 = __p0_801; \
+  float64x2_t __s1_801 = __p1_801; \
+  float64x1_t __s2_801 = __p2_801; \
+  float64x2_t __rev0_801;  __rev0_801 = __builtin_shufflevector(__s0_801, __s0_801, 1, 0); \
+  float64x2_t __rev1_801;  __rev1_801 = __builtin_shufflevector(__s1_801, __s1_801, 1, 0); \
+float64x1_t __reint_801 = __s2_801; \
+uint64x2_t __reint1_801 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_801, __p3_801), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_801, __p3_801)}; \
+  __ret_801 = __noswap_vcmlaq_rot180_f64(__rev0_801, __rev1_801, *(float64x2_t *) &__reint1_801); \
+  __ret_801 = __builtin_shufflevector(__ret_801, __ret_801, 1, 0); \
+  __ret_801; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot180_laneq_f64(__p0_802, __p1_802, __p2_802, __p3_802) __extension__ ({ \
+  float64x1_t __ret_802; \
+  float64x1_t __s0_802 = __p0_802; \
+  float64x1_t __s1_802 = __p1_802; \
+  float64x2_t __s2_802 = __p2_802; \
+float64x2_t __reint_802 = __s2_802; \
+uint64x2_t __reint1_802 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_802, __p3_802), vgetq_lane_u64(*(uint64x2_t *) &__reint_802, __p3_802)}; \
+  __ret_802 = vcmla_rot180_f64(__s0_802, __s1_802, *(float64x1_t *) &__reint1_802); \
+  __ret_802; \
+})
+#else
+#define vcmla_rot180_laneq_f64(__p0_803, __p1_803, __p2_803, __p3_803) __extension__ ({ \
+  float64x1_t __ret_803; \
+  float64x1_t __s0_803 = __p0_803; \
+  float64x1_t __s1_803 = __p1_803; \
+  float64x2_t __s2_803 = __p2_803; \
+  float64x2_t __rev2_803;  __rev2_803 = __builtin_shufflevector(__s2_803, __s2_803, 1, 0); \
+float64x2_t __reint_803 = __rev2_803; \
+uint64x2_t __reint1_803 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_803, __p3_803), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_803, __p3_803)}; \
+  __ret_803 = vcmla_rot180_f64(__s0_803, __s1_803, *(float64x1_t *) &__reint1_803); \
+  __ret_803; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot180_laneq_f64(__p0_804, __p1_804, __p2_804, __p3_804) __extension__ ({ \
+  float64x2_t __ret_804; \
+  float64x2_t __s0_804 = __p0_804; \
+  float64x2_t __s1_804 = __p1_804; \
+  float64x2_t __s2_804 = __p2_804; \
+float64x2_t __reint_804 = __s2_804; \
+uint64x2_t __reint1_804 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_804, __p3_804), vgetq_lane_u64(*(uint64x2_t *) &__reint_804, __p3_804)}; \
+  __ret_804 = vcmlaq_rot180_f64(__s0_804, __s1_804, *(float64x2_t *) &__reint1_804); \
+  __ret_804; \
+})
+#else
+#define vcmlaq_rot180_laneq_f64(__p0_805, __p1_805, __p2_805, __p3_805) __extension__ ({ \
+  float64x2_t __ret_805; \
+  float64x2_t __s0_805 = __p0_805; \
+  float64x2_t __s1_805 = __p1_805; \
+  float64x2_t __s2_805 = __p2_805; \
+  float64x2_t __rev0_805;  __rev0_805 = __builtin_shufflevector(__s0_805, __s0_805, 1, 0); \
+  float64x2_t __rev1_805;  __rev1_805 = __builtin_shufflevector(__s1_805, __s1_805, 1, 0); \
+  float64x2_t __rev2_805;  __rev2_805 = __builtin_shufflevector(__s2_805, __s2_805, 1, 0); \
+float64x2_t __reint_805 = __rev2_805; \
+uint64x2_t __reint1_805 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_805, __p3_805), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_805, __p3_805)}; \
+  __ret_805 = __noswap_vcmlaq_rot180_f64(__rev0_805, __rev1_805, *(float64x2_t *) &__reint1_805); \
+  __ret_805 = __builtin_shufflevector(__ret_805, __ret_805, 1, 0); \
+  __ret_805; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot270_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_rot270_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot270_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_rot270_f64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t __noswap_vcmlaq_rot270_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_rot270_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("v8.3a,neon"))) float64x1_t vcmla_rot270_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vcmla_rot270_f64((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
+  return __ret;
+}
+#define vcmla_rot270_lane_f64(__p0_806, __p1_806, __p2_806, __p3_806) __extension__ ({ \
+  float64x1_t __ret_806; \
+  float64x1_t __s0_806 = __p0_806; \
+  float64x1_t __s1_806 = __p1_806; \
+  float64x1_t __s2_806 = __p2_806; \
+float64x1_t __reint_806 = __s2_806; \
+uint64x2_t __reint1_806 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_806, __p3_806), vgetq_lane_u64(*(uint64x2_t *) &__reint_806, __p3_806)}; \
+  __ret_806 = vcmla_rot270_f64(__s0_806, __s1_806, *(float64x1_t *) &__reint1_806); \
+  __ret_806; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot270_lane_f64(__p0_807, __p1_807, __p2_807, __p3_807) __extension__ ({ \
+  float64x2_t __ret_807; \
+  float64x2_t __s0_807 = __p0_807; \
+  float64x2_t __s1_807 = __p1_807; \
+  float64x1_t __s2_807 = __p2_807; \
+float64x1_t __reint_807 = __s2_807; \
+uint64x2_t __reint1_807 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_807, __p3_807), vgetq_lane_u64(*(uint64x2_t *) &__reint_807, __p3_807)}; \
+  __ret_807 = vcmlaq_rot270_f64(__s0_807, __s1_807, *(float64x2_t *) &__reint1_807); \
+  __ret_807; \
+})
+#else
+#define vcmlaq_rot270_lane_f64(__p0_808, __p1_808, __p2_808, __p3_808) __extension__ ({ \
+  float64x2_t __ret_808; \
+  float64x2_t __s0_808 = __p0_808; \
+  float64x2_t __s1_808 = __p1_808; \
+  float64x1_t __s2_808 = __p2_808; \
+  float64x2_t __rev0_808;  __rev0_808 = __builtin_shufflevector(__s0_808, __s0_808, 1, 0); \
+  float64x2_t __rev1_808;  __rev1_808 = __builtin_shufflevector(__s1_808, __s1_808, 1, 0); \
+float64x1_t __reint_808 = __s2_808; \
+uint64x2_t __reint1_808 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_808, __p3_808), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_808, __p3_808)}; \
+  __ret_808 = __noswap_vcmlaq_rot270_f64(__rev0_808, __rev1_808, *(float64x2_t *) &__reint1_808); \
+  __ret_808 = __builtin_shufflevector(__ret_808, __ret_808, 1, 0); \
+  __ret_808; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot270_laneq_f64(__p0_809, __p1_809, __p2_809, __p3_809) __extension__ ({ \
+  float64x1_t __ret_809; \
+  float64x1_t __s0_809 = __p0_809; \
+  float64x1_t __s1_809 = __p1_809; \
+  float64x2_t __s2_809 = __p2_809; \
+float64x2_t __reint_809 = __s2_809; \
+uint64x2_t __reint1_809 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_809, __p3_809), vgetq_lane_u64(*(uint64x2_t *) &__reint_809, __p3_809)}; \
+  __ret_809 = vcmla_rot270_f64(__s0_809, __s1_809, *(float64x1_t *) &__reint1_809); \
+  __ret_809; \
+})
+#else
+#define vcmla_rot270_laneq_f64(__p0_810, __p1_810, __p2_810, __p3_810) __extension__ ({ \
+  float64x1_t __ret_810; \
+  float64x1_t __s0_810 = __p0_810; \
+  float64x1_t __s1_810 = __p1_810; \
+  float64x2_t __s2_810 = __p2_810; \
+  float64x2_t __rev2_810;  __rev2_810 = __builtin_shufflevector(__s2_810, __s2_810, 1, 0); \
+float64x2_t __reint_810 = __rev2_810; \
+uint64x2_t __reint1_810 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_810, __p3_810), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_810, __p3_810)}; \
+  __ret_810 = vcmla_rot270_f64(__s0_810, __s1_810, *(float64x1_t *) &__reint1_810); \
+  __ret_810; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot270_laneq_f64(__p0_811, __p1_811, __p2_811, __p3_811) __extension__ ({ \
+  float64x2_t __ret_811; \
+  float64x2_t __s0_811 = __p0_811; \
+  float64x2_t __s1_811 = __p1_811; \
+  float64x2_t __s2_811 = __p2_811; \
+float64x2_t __reint_811 = __s2_811; \
+uint64x2_t __reint1_811 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_811, __p3_811), vgetq_lane_u64(*(uint64x2_t *) &__reint_811, __p3_811)}; \
+  __ret_811 = vcmlaq_rot270_f64(__s0_811, __s1_811, *(float64x2_t *) &__reint1_811); \
+  __ret_811; \
+})
+#else
+#define vcmlaq_rot270_laneq_f64(__p0_812, __p1_812, __p2_812, __p3_812) __extension__ ({ \
+  float64x2_t __ret_812; \
+  float64x2_t __s0_812 = __p0_812; \
+  float64x2_t __s1_812 = __p1_812; \
+  float64x2_t __s2_812 = __p2_812; \
+  float64x2_t __rev0_812;  __rev0_812 = __builtin_shufflevector(__s0_812, __s0_812, 1, 0); \
+  float64x2_t __rev1_812;  __rev1_812 = __builtin_shufflevector(__s1_812, __s1_812, 1, 0); \
+  float64x2_t __rev2_812;  __rev2_812 = __builtin_shufflevector(__s2_812, __s2_812, 1, 0); \
+float64x2_t __reint_812 = __rev2_812; \
+uint64x2_t __reint1_812 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_812, __p3_812), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_812, __p3_812)}; \
+  __ret_812 = __noswap_vcmlaq_rot270_f64(__rev0_812, __rev1_812, *(float64x2_t *) &__reint1_812); \
+  __ret_812 = __builtin_shufflevector(__ret_812, __ret_812, 1, 0); \
+  __ret_812; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot90_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_rot90_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t vcmlaq_rot90_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  float64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  float64x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_rot90_f64((int8x16_t)__rev0, (int8x16_t)__rev1, (int8x16_t)__rev2, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("v8.3a,neon"))) float64x2_t __noswap_vcmlaq_rot90_f64(float64x2_t __p0, float64x2_t __p1, float64x2_t __p2) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vcmlaq_rot90_f64((int8x16_t)__p0, (int8x16_t)__p1, (int8x16_t)__p2, 42);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("v8.3a,neon"))) float64x1_t vcmla_rot90_f64(float64x1_t __p0, float64x1_t __p1, float64x1_t __p2) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vcmla_rot90_f64((int8x8_t)__p0, (int8x8_t)__p1, (int8x8_t)__p2, 10);
+  return __ret;
+}
+#define vcmla_rot90_lane_f64(__p0_813, __p1_813, __p2_813, __p3_813) __extension__ ({ \
+  float64x1_t __ret_813; \
+  float64x1_t __s0_813 = __p0_813; \
+  float64x1_t __s1_813 = __p1_813; \
+  float64x1_t __s2_813 = __p2_813; \
+float64x1_t __reint_813 = __s2_813; \
+uint64x2_t __reint1_813 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_813, __p3_813), vgetq_lane_u64(*(uint64x2_t *) &__reint_813, __p3_813)}; \
+  __ret_813 = vcmla_rot90_f64(__s0_813, __s1_813, *(float64x1_t *) &__reint1_813); \
+  __ret_813; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot90_lane_f64(__p0_814, __p1_814, __p2_814, __p3_814) __extension__ ({ \
+  float64x2_t __ret_814; \
+  float64x2_t __s0_814 = __p0_814; \
+  float64x2_t __s1_814 = __p1_814; \
+  float64x1_t __s2_814 = __p2_814; \
+float64x1_t __reint_814 = __s2_814; \
+uint64x2_t __reint1_814 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_814, __p3_814), vgetq_lane_u64(*(uint64x2_t *) &__reint_814, __p3_814)}; \
+  __ret_814 = vcmlaq_rot90_f64(__s0_814, __s1_814, *(float64x2_t *) &__reint1_814); \
+  __ret_814; \
+})
+#else
+#define vcmlaq_rot90_lane_f64(__p0_815, __p1_815, __p2_815, __p3_815) __extension__ ({ \
+  float64x2_t __ret_815; \
+  float64x2_t __s0_815 = __p0_815; \
+  float64x2_t __s1_815 = __p1_815; \
+  float64x1_t __s2_815 = __p2_815; \
+  float64x2_t __rev0_815;  __rev0_815 = __builtin_shufflevector(__s0_815, __s0_815, 1, 0); \
+  float64x2_t __rev1_815;  __rev1_815 = __builtin_shufflevector(__s1_815, __s1_815, 1, 0); \
+float64x1_t __reint_815 = __s2_815; \
+uint64x2_t __reint1_815 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_815, __p3_815), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_815, __p3_815)}; \
+  __ret_815 = __noswap_vcmlaq_rot90_f64(__rev0_815, __rev1_815, *(float64x2_t *) &__reint1_815); \
+  __ret_815 = __builtin_shufflevector(__ret_815, __ret_815, 1, 0); \
+  __ret_815; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmla_rot90_laneq_f64(__p0_816, __p1_816, __p2_816, __p3_816) __extension__ ({ \
+  float64x1_t __ret_816; \
+  float64x1_t __s0_816 = __p0_816; \
+  float64x1_t __s1_816 = __p1_816; \
+  float64x2_t __s2_816 = __p2_816; \
+float64x2_t __reint_816 = __s2_816; \
+uint64x2_t __reint1_816 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_816, __p3_816), vgetq_lane_u64(*(uint64x2_t *) &__reint_816, __p3_816)}; \
+  __ret_816 = vcmla_rot90_f64(__s0_816, __s1_816, *(float64x1_t *) &__reint1_816); \
+  __ret_816; \
+})
+#else
+#define vcmla_rot90_laneq_f64(__p0_817, __p1_817, __p2_817, __p3_817) __extension__ ({ \
+  float64x1_t __ret_817; \
+  float64x1_t __s0_817 = __p0_817; \
+  float64x1_t __s1_817 = __p1_817; \
+  float64x2_t __s2_817 = __p2_817; \
+  float64x2_t __rev2_817;  __rev2_817 = __builtin_shufflevector(__s2_817, __s2_817, 1, 0); \
+float64x2_t __reint_817 = __rev2_817; \
+uint64x2_t __reint1_817 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_817, __p3_817), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_817, __p3_817)}; \
+  __ret_817 = vcmla_rot90_f64(__s0_817, __s1_817, *(float64x1_t *) &__reint1_817); \
+  __ret_817; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcmlaq_rot90_laneq_f64(__p0_818, __p1_818, __p2_818, __p3_818) __extension__ ({ \
+  float64x2_t __ret_818; \
+  float64x2_t __s0_818 = __p0_818; \
+  float64x2_t __s1_818 = __p1_818; \
+  float64x2_t __s2_818 = __p2_818; \
+float64x2_t __reint_818 = __s2_818; \
+uint64x2_t __reint1_818 = (uint64x2_t) {vgetq_lane_u64(*(uint64x2_t *) &__reint_818, __p3_818), vgetq_lane_u64(*(uint64x2_t *) &__reint_818, __p3_818)}; \
+  __ret_818 = vcmlaq_rot90_f64(__s0_818, __s1_818, *(float64x2_t *) &__reint1_818); \
+  __ret_818; \
+})
+#else
+#define vcmlaq_rot90_laneq_f64(__p0_819, __p1_819, __p2_819, __p3_819) __extension__ ({ \
+  float64x2_t __ret_819; \
+  float64x2_t __s0_819 = __p0_819; \
+  float64x2_t __s1_819 = __p1_819; \
+  float64x2_t __s2_819 = __p2_819; \
+  float64x2_t __rev0_819;  __rev0_819 = __builtin_shufflevector(__s0_819, __s0_819, 1, 0); \
+  float64x2_t __rev1_819;  __rev1_819 = __builtin_shufflevector(__s1_819, __s1_819, 1, 0); \
+  float64x2_t __rev2_819;  __rev2_819 = __builtin_shufflevector(__s2_819, __s2_819, 1, 0); \
+float64x2_t __reint_819 = __rev2_819; \
+uint64x2_t __reint1_819 = (uint64x2_t) {__noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_819, __p3_819), __noswap_vgetq_lane_u64(*(uint64x2_t *) &__reint_819, __p3_819)}; \
+  __ret_819 = __noswap_vcmlaq_rot90_f64(__rev0_819, __rev1_819, *(float64x2_t *) &__reint1_819); \
+  __ret_819 = __builtin_shufflevector(__ret_819, __ret_819, 1, 0); \
+  __ret_819; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd32xq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrnd32xq_f32((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd32xq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrnd32xq_f32((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd32x_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrnd32x_f32((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd32x_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrnd32x_f32((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd32xq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrnd32xq_f64((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd32xq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrnd32xq_f64((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("v8.5a,neon"))) float64x1_t vrnd32x_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrnd32x_f64((int8x8_t)__p0, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd32zq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrnd32zq_f32((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd32zq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrnd32zq_f32((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd32z_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrnd32z_f32((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd32z_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrnd32z_f32((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd32zq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrnd32zq_f64((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd32zq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrnd32zq_f64((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("v8.5a,neon"))) float64x1_t vrnd32z_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrnd32z_f64((int8x8_t)__p0, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd64xq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrnd64xq_f32((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd64xq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrnd64xq_f32((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd64x_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrnd64x_f32((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd64x_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrnd64x_f32((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd64xq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrnd64xq_f64((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd64xq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrnd64xq_f64((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("v8.5a,neon"))) float64x1_t vrnd64x_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrnd64x_f64((int8x8_t)__p0, 10);
+  return __ret;
+}
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd64zq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  __ret = (float32x4_t) __builtin_neon_vrnd64zq_f32((int8x16_t)__p0, 41);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float32x4_t vrnd64zq_f32(float32x4_t __p0) {
+  float32x4_t __ret;
+  float32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  __ret = (float32x4_t) __builtin_neon_vrnd64zq_f32((int8x16_t)__rev0, 41);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd64z_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  __ret = (float32x2_t) __builtin_neon_vrnd64z_f32((int8x8_t)__p0, 9);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float32x2_t vrnd64z_f32(float32x2_t __p0) {
+  float32x2_t __ret;
+  float32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float32x2_t) __builtin_neon_vrnd64z_f32((int8x8_t)__rev0, 9);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd64zq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  __ret = (float64x2_t) __builtin_neon_vrnd64zq_f64((int8x16_t)__p0, 42);
+  return __ret;
+}
+#else
+__ai __attribute__((target("v8.5a,neon"))) float64x2_t vrnd64zq_f64(float64x2_t __p0) {
+  float64x2_t __ret;
+  float64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  __ret = (float64x2_t) __builtin_neon_vrnd64zq_f64((int8x16_t)__rev0, 42);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+__ai __attribute__((target("v8.5a,neon"))) float64x1_t vrnd64z_f64(float64x1_t __p0) {
+  float64x1_t __ret;
+  __ret = (float64x1_t) __builtin_neon_vrnd64z_f64((int8x8_t)__p0, 10);
+  return __ret;
+}
+#endif
+#ifdef __LITTLE_ENDIAN__
+#define vbfdotq_lane_f32(__p0_820, __p1_820, __p2_820, __p3_820) __extension__ ({ \
+  float32x4_t __ret_820; \
+  float32x4_t __s0_820 = __p0_820; \
+  bfloat16x8_t __s1_820 = __p1_820; \
+  bfloat16x4_t __s2_820 = __p2_820; \
+bfloat16x4_t __reint_820 = __s2_820; \
+float32x4_t __reint1_820 = splatq_lane_f32(*(float32x2_t *) &__reint_820, __p3_820); \
+  __ret_820 = vbfdotq_f32(__s0_820, __s1_820, *(bfloat16x8_t *) &__reint1_820); \
+  __ret_820; \
+})
+#else
+#define vbfdotq_lane_f32(__p0_821, __p1_821, __p2_821, __p3_821) __extension__ ({ \
+  float32x4_t __ret_821; \
+  float32x4_t __s0_821 = __p0_821; \
+  bfloat16x8_t __s1_821 = __p1_821; \
+  bfloat16x4_t __s2_821 = __p2_821; \
+  float32x4_t __rev0_821;  __rev0_821 = __builtin_shufflevector(__s0_821, __s0_821, 3, 2, 1, 0); \
+  bfloat16x8_t __rev1_821;  __rev1_821 = __builtin_shufflevector(__s1_821, __s1_821, 7, 6, 5, 4, 3, 2, 1, 0); \
+  bfloat16x4_t __rev2_821;  __rev2_821 = __builtin_shufflevector(__s2_821, __s2_821, 3, 2, 1, 0); \
+bfloat16x4_t __reint_821 = __rev2_821; \
+float32x4_t __reint1_821 = __noswap_splatq_lane_f32(*(float32x2_t *) &__reint_821, __p3_821); \
+  __ret_821 = __noswap_vbfdotq_f32(__rev0_821, __rev1_821, *(bfloat16x8_t *) &__reint1_821); \
+  __ret_821 = __builtin_shufflevector(__ret_821, __ret_821, 3, 2, 1, 0); \
+  __ret_821; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vbfdot_lane_f32(__p0_822, __p1_822, __p2_822, __p3_822) __extension__ ({ \
+  float32x2_t __ret_822; \
+  float32x2_t __s0_822 = __p0_822; \
+  bfloat16x4_t __s1_822 = __p1_822; \
+  bfloat16x4_t __s2_822 = __p2_822; \
+bfloat16x4_t __reint_822 = __s2_822; \
+float32x2_t __reint1_822 = splat_lane_f32(*(float32x2_t *) &__reint_822, __p3_822); \
+  __ret_822 = vbfdot_f32(__s0_822, __s1_822, *(bfloat16x4_t *) &__reint1_822); \
+  __ret_822; \
+})
+#else
+#define vbfdot_lane_f32(__p0_823, __p1_823, __p2_823, __p3_823) __extension__ ({ \
+  float32x2_t __ret_823; \
+  float32x2_t __s0_823 = __p0_823; \
+  bfloat16x4_t __s1_823 = __p1_823; \
+  bfloat16x4_t __s2_823 = __p2_823; \
+  float32x2_t __rev0_823;  __rev0_823 = __builtin_shufflevector(__s0_823, __s0_823, 1, 0); \
+  bfloat16x4_t __rev1_823;  __rev1_823 = __builtin_shufflevector(__s1_823, __s1_823, 3, 2, 1, 0); \
+  bfloat16x4_t __rev2_823;  __rev2_823 = __builtin_shufflevector(__s2_823, __s2_823, 3, 2, 1, 0); \
+bfloat16x4_t __reint_823 = __rev2_823; \
+float32x2_t __reint1_823 = __noswap_splat_lane_f32(*(float32x2_t *) &__reint_823, __p3_823); \
+  __ret_823 = __noswap_vbfdot_f32(__rev0_823, __rev1_823, *(bfloat16x4_t *) &__reint1_823); \
+  __ret_823 = __builtin_shufflevector(__ret_823, __ret_823, 1, 0); \
+  __ret_823; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vbfdotq_laneq_f32(__p0_824, __p1_824, __p2_824, __p3_824) __extension__ ({ \
+  float32x4_t __ret_824; \
+  float32x4_t __s0_824 = __p0_824; \
+  bfloat16x8_t __s1_824 = __p1_824; \
+  bfloat16x8_t __s2_824 = __p2_824; \
+bfloat16x8_t __reint_824 = __s2_824; \
+float32x4_t __reint1_824 = splatq_laneq_f32(*(float32x4_t *) &__reint_824, __p3_824); \
+  __ret_824 = vbfdotq_f32(__s0_824, __s1_824, *(bfloat16x8_t *) &__reint1_824); \
+  __ret_824; \
+})
+#else
+#define vbfdotq_laneq_f32(__p0_825, __p1_825, __p2_825, __p3_825) __extension__ ({ \
+  float32x4_t __ret_825; \
+  float32x4_t __s0_825 = __p0_825; \
+  bfloat16x8_t __s1_825 = __p1_825; \
+  bfloat16x8_t __s2_825 = __p2_825; \
+  float32x4_t __rev0_825;  __rev0_825 = __builtin_shufflevector(__s0_825, __s0_825, 3, 2, 1, 0); \
+  bfloat16x8_t __rev1_825;  __rev1_825 = __builtin_shufflevector(__s1_825, __s1_825, 7, 6, 5, 4, 3, 2, 1, 0); \
+  bfloat16x8_t __rev2_825;  __rev2_825 = __builtin_shufflevector(__s2_825, __s2_825, 7, 6, 5, 4, 3, 2, 1, 0); \
+bfloat16x8_t __reint_825 = __rev2_825; \
+float32x4_t __reint1_825 = __noswap_splatq_laneq_f32(*(float32x4_t *) &__reint_825, __p3_825); \
+  __ret_825 = __noswap_vbfdotq_f32(__rev0_825, __rev1_825, *(bfloat16x8_t *) &__reint1_825); \
+  __ret_825 = __builtin_shufflevector(__ret_825, __ret_825, 3, 2, 1, 0); \
+  __ret_825; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vbfdot_laneq_f32(__p0_826, __p1_826, __p2_826, __p3_826) __extension__ ({ \
+  float32x2_t __ret_826; \
+  float32x2_t __s0_826 = __p0_826; \
+  bfloat16x4_t __s1_826 = __p1_826; \
+  bfloat16x8_t __s2_826 = __p2_826; \
+bfloat16x8_t __reint_826 = __s2_826; \
+float32x2_t __reint1_826 = splat_laneq_f32(*(float32x4_t *) &__reint_826, __p3_826); \
+  __ret_826 = vbfdot_f32(__s0_826, __s1_826, *(bfloat16x4_t *) &__reint1_826); \
+  __ret_826; \
+})
+#else
+#define vbfdot_laneq_f32(__p0_827, __p1_827, __p2_827, __p3_827) __extension__ ({ \
+  float32x2_t __ret_827; \
+  float32x2_t __s0_827 = __p0_827; \
+  bfloat16x4_t __s1_827 = __p1_827; \
+  bfloat16x8_t __s2_827 = __p2_827; \
+  float32x2_t __rev0_827;  __rev0_827 = __builtin_shufflevector(__s0_827, __s0_827, 1, 0); \
+  bfloat16x4_t __rev1_827;  __rev1_827 = __builtin_shufflevector(__s1_827, __s1_827, 3, 2, 1, 0); \
+  bfloat16x8_t __rev2_827;  __rev2_827 = __builtin_shufflevector(__s2_827, __s2_827, 7, 6, 5, 4, 3, 2, 1, 0); \
+bfloat16x8_t __reint_827 = __rev2_827; \
+float32x2_t __reint1_827 = __noswap_splat_laneq_f32(*(float32x4_t *) &__reint_827, __p3_827); \
+  __ret_827 = __noswap_vbfdot_f32(__rev0_827, __rev1_827, *(bfloat16x4_t *) &__reint1_827); \
+  __ret_827 = __builtin_shufflevector(__ret_827, __ret_827, 1, 0); \
+  __ret_827; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vbfmlalbq_lane_f32(__p0_828, __p1_828, __p2_828, __p3_828) __extension__ ({ \
+  float32x4_t __ret_828; \
+  float32x4_t __s0_828 = __p0_828; \
+  bfloat16x8_t __s1_828 = __p1_828; \
+  bfloat16x4_t __s2_828 = __p2_828; \
+  __ret_828 = vbfmlalbq_f32(__s0_828, __s1_828, (bfloat16x8_t) {vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828), vget_lane_bf16(__s2_828, __p3_828)}); \
+  __ret_828; \
+})
+#else
+#define vbfmlalbq_lane_f32(__p0_829, __p1_829, __p2_829, __p3_829) __extension__ ({ \
+  float32x4_t __ret_829; \
+  float32x4_t __s0_829 = __p0_829; \
+  bfloat16x8_t __s1_829 = __p1_829; \
+  bfloat16x4_t __s2_829 = __p2_829; \
+  float32x4_t __rev0_829;  __rev0_829 = __builtin_shufflevector(__s0_829, __s0_829, 3, 2, 1, 0); \
+  bfloat16x8_t __rev1_829;  __rev1_829 = __builtin_shufflevector(__s1_829, __s1_829, 7, 6, 5, 4, 3, 2, 1, 0); \
+  bfloat16x4_t __rev2_829;  __rev2_829 = __builtin_shufflevector(__s2_829, __s2_829, 3, 2, 1, 0); \
+  __ret_829 = __noswap_vbfmlalbq_f32(__rev0_829, __rev1_829, (bfloat16x8_t) {__noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829), __noswap_vget_lane_bf16(__rev2_829, __p3_829)}); \
+  __ret_829 = __builtin_shufflevector(__ret_829, __ret_829, 3, 2, 1, 0); \
+  __ret_829; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vbfmlalbq_laneq_f32(__p0_830, __p1_830, __p2_830, __p3_830) __extension__ ({ \
+  float32x4_t __ret_830; \
+  float32x4_t __s0_830 = __p0_830; \
+  bfloat16x8_t __s1_830 = __p1_830; \
+  bfloat16x8_t __s2_830 = __p2_830; \
+  __ret_830 = vbfmlalbq_f32(__s0_830, __s1_830, (bfloat16x8_t) {vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830), vgetq_lane_bf16(__s2_830, __p3_830)}); \
+  __ret_830; \
+})
+#else
+#define vbfmlalbq_laneq_f32(__p0_831, __p1_831, __p2_831, __p3_831) __extension__ ({ \
+  float32x4_t __ret_831; \
+  float32x4_t __s0_831 = __p0_831; \
+  bfloat16x8_t __s1_831 = __p1_831; \
+  bfloat16x8_t __s2_831 = __p2_831; \
+  float32x4_t __rev0_831;  __rev0_831 = __builtin_shufflevector(__s0_831, __s0_831, 3, 2, 1, 0); \
+  bfloat16x8_t __rev1_831;  __rev1_831 = __builtin_shufflevector(__s1_831, __s1_831, 7, 6, 5, 4, 3, 2, 1, 0); \
+  bfloat16x8_t __rev2_831;  __rev2_831 = __builtin_shufflevector(__s2_831, __s2_831, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_831 = __noswap_vbfmlalbq_f32(__rev0_831, __rev1_831, (bfloat16x8_t) {__noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831), __noswap_vgetq_lane_bf16(__rev2_831, __p3_831)}); \
+  __ret_831 = __builtin_shufflevector(__ret_831, __ret_831, 3, 2, 1, 0); \
+  __ret_831; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vbfmlaltq_lane_f32(__p0_832, __p1_832, __p2_832, __p3_832) __extension__ ({ \
+  float32x4_t __ret_832; \
+  float32x4_t __s0_832 = __p0_832; \
+  bfloat16x8_t __s1_832 = __p1_832; \
+  bfloat16x4_t __s2_832 = __p2_832; \
+  __ret_832 = vbfmlaltq_f32(__s0_832, __s1_832, (bfloat16x8_t) {vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832), vget_lane_bf16(__s2_832, __p3_832)}); \
+  __ret_832; \
+})
+#else
+#define vbfmlaltq_lane_f32(__p0_833, __p1_833, __p2_833, __p3_833) __extension__ ({ \
+  float32x4_t __ret_833; \
+  float32x4_t __s0_833 = __p0_833; \
+  bfloat16x8_t __s1_833 = __p1_833; \
+  bfloat16x4_t __s2_833 = __p2_833; \
+  float32x4_t __rev0_833;  __rev0_833 = __builtin_shufflevector(__s0_833, __s0_833, 3, 2, 1, 0); \
+  bfloat16x8_t __rev1_833;  __rev1_833 = __builtin_shufflevector(__s1_833, __s1_833, 7, 6, 5, 4, 3, 2, 1, 0); \
+  bfloat16x4_t __rev2_833;  __rev2_833 = __builtin_shufflevector(__s2_833, __s2_833, 3, 2, 1, 0); \
+  __ret_833 = __noswap_vbfmlaltq_f32(__rev0_833, __rev1_833, (bfloat16x8_t) {__noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833), __noswap_vget_lane_bf16(__rev2_833, __p3_833)}); \
+  __ret_833 = __builtin_shufflevector(__ret_833, __ret_833, 3, 2, 1, 0); \
+  __ret_833; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vbfmlaltq_laneq_f32(__p0_834, __p1_834, __p2_834, __p3_834) __extension__ ({ \
+  float32x4_t __ret_834; \
+  float32x4_t __s0_834 = __p0_834; \
+  bfloat16x8_t __s1_834 = __p1_834; \
+  bfloat16x8_t __s2_834 = __p2_834; \
+  __ret_834 = vbfmlaltq_f32(__s0_834, __s1_834, (bfloat16x8_t) {vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834), vgetq_lane_bf16(__s2_834, __p3_834)}); \
+  __ret_834; \
+})
+#else
+#define vbfmlaltq_laneq_f32(__p0_835, __p1_835, __p2_835, __p3_835) __extension__ ({ \
+  float32x4_t __ret_835; \
+  float32x4_t __s0_835 = __p0_835; \
+  bfloat16x8_t __s1_835 = __p1_835; \
+  bfloat16x8_t __s2_835 = __p2_835; \
+  float32x4_t __rev0_835;  __rev0_835 = __builtin_shufflevector(__s0_835, __s0_835, 3, 2, 1, 0); \
+  bfloat16x8_t __rev1_835;  __rev1_835 = __builtin_shufflevector(__s1_835, __s1_835, 7, 6, 5, 4, 3, 2, 1, 0); \
+  bfloat16x8_t __rev2_835;  __rev2_835 = __builtin_shufflevector(__s2_835, __s2_835, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_835 = __noswap_vbfmlaltq_f32(__rev0_835, __rev1_835, (bfloat16x8_t) {__noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835), __noswap_vgetq_lane_bf16(__rev2_835, __p3_835)}); \
+  __ret_835 = __builtin_shufflevector(__ret_835, __ret_835, 3, 2, 1, 0); \
+  __ret_835; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvt_f32_bf16(bfloat16x4_t __p0_836) {
+  float32x4_t __ret_836;
+bfloat16x4_t __reint_836 = __p0_836;
+int32x4_t __reint1_836 = vshll_n_s16(*(int16x4_t *) &__reint_836, 16);
+  __ret_836 = *(float32x4_t *) &__reint1_836;
+  return __ret_836;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvt_f32_bf16(bfloat16x4_t __p0_837) {
+  float32x4_t __ret_837;
+  bfloat16x4_t __rev0_837;  __rev0_837 = __builtin_shufflevector(__p0_837, __p0_837, 3, 2, 1, 0);
+bfloat16x4_t __reint_837 = __rev0_837;
+int32x4_t __reint1_837 = __noswap_vshll_n_s16(*(int16x4_t *) &__reint_837, 16);
+  __ret_837 = *(float32x4_t *) &__reint1_837;
+  __ret_837 = __builtin_shufflevector(__ret_837, __ret_837, 3, 2, 1, 0);
+  return __ret_837;
+}
+__ai __attribute__((target("bf16,neon"))) float32x4_t __noswap_vcvt_f32_bf16(bfloat16x4_t __p0_838) {
+  float32x4_t __ret_838;
+bfloat16x4_t __reint_838 = __p0_838;
+int32x4_t __reint1_838 = __noswap_vshll_n_s16(*(int16x4_t *) &__reint_838, 16);
+  __ret_838 = *(float32x4_t *) &__reint1_838;
+  return __ret_838;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvtq_high_f32_bf16(bfloat16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = vcvt_f32_bf16(vget_high_bf16(__p0));
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvtq_high_f32_bf16(bfloat16x8_t __p0) {
+  float32x4_t __ret;
+  bfloat16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcvt_f32_bf16(__noswap_vget_high_bf16(__rev0));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvtq_low_f32_bf16(bfloat16x8_t __p0) {
+  float32x4_t __ret;
+  __ret = vcvt_f32_bf16(vget_low_bf16(__p0));
+  return __ret;
+}
+#else
+__ai __attribute__((target("bf16,neon"))) float32x4_t vcvtq_low_f32_bf16(bfloat16x8_t __p0) {
+  float32x4_t __ret;
+  bfloat16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vcvt_f32_bf16(__noswap_vget_low_bf16(__rev0));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdotq_lane_u32(__p0_839, __p1_839, __p2_839, __p3_839) __extension__ ({ \
+  uint32x4_t __ret_839; \
+  uint32x4_t __s0_839 = __p0_839; \
+  uint8x16_t __s1_839 = __p1_839; \
+  uint8x8_t __s2_839 = __p2_839; \
+uint8x8_t __reint_839 = __s2_839; \
+uint32x4_t __reint1_839 = splatq_lane_u32(*(uint32x2_t *) &__reint_839, __p3_839); \
+  __ret_839 = vdotq_u32(__s0_839, __s1_839, *(uint8x16_t *) &__reint1_839); \
+  __ret_839; \
+})
+#else
+#define vdotq_lane_u32(__p0_840, __p1_840, __p2_840, __p3_840) __extension__ ({ \
+  uint32x4_t __ret_840; \
+  uint32x4_t __s0_840 = __p0_840; \
+  uint8x16_t __s1_840 = __p1_840; \
+  uint8x8_t __s2_840 = __p2_840; \
+  uint32x4_t __rev0_840;  __rev0_840 = __builtin_shufflevector(__s0_840, __s0_840, 3, 2, 1, 0); \
+  uint8x16_t __rev1_840;  __rev1_840 = __builtin_shufflevector(__s1_840, __s1_840, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev2_840;  __rev2_840 = __builtin_shufflevector(__s2_840, __s2_840, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x8_t __reint_840 = __rev2_840; \
+uint32x4_t __reint1_840 = __noswap_splatq_lane_u32(*(uint32x2_t *) &__reint_840, __p3_840); \
+  __ret_840 = __noswap_vdotq_u32(__rev0_840, __rev1_840, *(uint8x16_t *) &__reint1_840); \
+  __ret_840 = __builtin_shufflevector(__ret_840, __ret_840, 3, 2, 1, 0); \
+  __ret_840; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdotq_lane_s32(__p0_841, __p1_841, __p2_841, __p3_841) __extension__ ({ \
+  int32x4_t __ret_841; \
+  int32x4_t __s0_841 = __p0_841; \
+  int8x16_t __s1_841 = __p1_841; \
+  int8x8_t __s2_841 = __p2_841; \
+int8x8_t __reint_841 = __s2_841; \
+int32x4_t __reint1_841 = splatq_lane_s32(*(int32x2_t *) &__reint_841, __p3_841); \
+  __ret_841 = vdotq_s32(__s0_841, __s1_841, *(int8x16_t *) &__reint1_841); \
+  __ret_841; \
+})
+#else
+#define vdotq_lane_s32(__p0_842, __p1_842, __p2_842, __p3_842) __extension__ ({ \
+  int32x4_t __ret_842; \
+  int32x4_t __s0_842 = __p0_842; \
+  int8x16_t __s1_842 = __p1_842; \
+  int8x8_t __s2_842 = __p2_842; \
+  int32x4_t __rev0_842;  __rev0_842 = __builtin_shufflevector(__s0_842, __s0_842, 3, 2, 1, 0); \
+  int8x16_t __rev1_842;  __rev1_842 = __builtin_shufflevector(__s1_842, __s1_842, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev2_842;  __rev2_842 = __builtin_shufflevector(__s2_842, __s2_842, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x8_t __reint_842 = __rev2_842; \
+int32x4_t __reint1_842 = __noswap_splatq_lane_s32(*(int32x2_t *) &__reint_842, __p3_842); \
+  __ret_842 = __noswap_vdotq_s32(__rev0_842, __rev1_842, *(int8x16_t *) &__reint1_842); \
+  __ret_842 = __builtin_shufflevector(__ret_842, __ret_842, 3, 2, 1, 0); \
+  __ret_842; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdot_lane_u32(__p0_843, __p1_843, __p2_843, __p3_843) __extension__ ({ \
+  uint32x2_t __ret_843; \
+  uint32x2_t __s0_843 = __p0_843; \
+  uint8x8_t __s1_843 = __p1_843; \
+  uint8x8_t __s2_843 = __p2_843; \
+uint8x8_t __reint_843 = __s2_843; \
+uint32x2_t __reint1_843 = splat_lane_u32(*(uint32x2_t *) &__reint_843, __p3_843); \
+  __ret_843 = vdot_u32(__s0_843, __s1_843, *(uint8x8_t *) &__reint1_843); \
+  __ret_843; \
+})
+#else
+#define vdot_lane_u32(__p0_844, __p1_844, __p2_844, __p3_844) __extension__ ({ \
+  uint32x2_t __ret_844; \
+  uint32x2_t __s0_844 = __p0_844; \
+  uint8x8_t __s1_844 = __p1_844; \
+  uint8x8_t __s2_844 = __p2_844; \
+  uint32x2_t __rev0_844;  __rev0_844 = __builtin_shufflevector(__s0_844, __s0_844, 1, 0); \
+  uint8x8_t __rev1_844;  __rev1_844 = __builtin_shufflevector(__s1_844, __s1_844, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev2_844;  __rev2_844 = __builtin_shufflevector(__s2_844, __s2_844, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x8_t __reint_844 = __rev2_844; \
+uint32x2_t __reint1_844 = __noswap_splat_lane_u32(*(uint32x2_t *) &__reint_844, __p3_844); \
+  __ret_844 = __noswap_vdot_u32(__rev0_844, __rev1_844, *(uint8x8_t *) &__reint1_844); \
+  __ret_844 = __builtin_shufflevector(__ret_844, __ret_844, 1, 0); \
+  __ret_844; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vdot_lane_s32(__p0_845, __p1_845, __p2_845, __p3_845) __extension__ ({ \
+  int32x2_t __ret_845; \
+  int32x2_t __s0_845 = __p0_845; \
+  int8x8_t __s1_845 = __p1_845; \
+  int8x8_t __s2_845 = __p2_845; \
+int8x8_t __reint_845 = __s2_845; \
+int32x2_t __reint1_845 = splat_lane_s32(*(int32x2_t *) &__reint_845, __p3_845); \
+  __ret_845 = vdot_s32(__s0_845, __s1_845, *(int8x8_t *) &__reint1_845); \
+  __ret_845; \
+})
+#else
+#define vdot_lane_s32(__p0_846, __p1_846, __p2_846, __p3_846) __extension__ ({ \
+  int32x2_t __ret_846; \
+  int32x2_t __s0_846 = __p0_846; \
+  int8x8_t __s1_846 = __p1_846; \
+  int8x8_t __s2_846 = __p2_846; \
+  int32x2_t __rev0_846;  __rev0_846 = __builtin_shufflevector(__s0_846, __s0_846, 1, 0); \
+  int8x8_t __rev1_846;  __rev1_846 = __builtin_shufflevector(__s1_846, __s1_846, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev2_846;  __rev2_846 = __builtin_shufflevector(__s2_846, __s2_846, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x8_t __reint_846 = __rev2_846; \
+int32x2_t __reint1_846 = __noswap_splat_lane_s32(*(int32x2_t *) &__reint_846, __p3_846); \
+  __ret_846 = __noswap_vdot_s32(__rev0_846, __rev1_846, *(int8x8_t *) &__reint1_846); \
+  __ret_846 = __builtin_shufflevector(__ret_846, __ret_846, 1, 0); \
+  __ret_846; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulq_lane_f16(__p0_847, __p1_847, __p2_847) __extension__ ({ \
+  float16x8_t __ret_847; \
+  float16x8_t __s0_847 = __p0_847; \
+  float16x4_t __s1_847 = __p1_847; \
+  __ret_847 = __s0_847 * splatq_lane_f16(__s1_847, __p2_847); \
+  __ret_847; \
+})
+#else
+#define vmulq_lane_f16(__p0_848, __p1_848, __p2_848) __extension__ ({ \
+  float16x8_t __ret_848; \
+  float16x8_t __s0_848 = __p0_848; \
+  float16x4_t __s1_848 = __p1_848; \
+  float16x8_t __rev0_848;  __rev0_848 = __builtin_shufflevector(__s0_848, __s0_848, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev1_848;  __rev1_848 = __builtin_shufflevector(__s1_848, __s1_848, 3, 2, 1, 0); \
+  __ret_848 = __rev0_848 * __noswap_splatq_lane_f16(__rev1_848, __p2_848); \
+  __ret_848 = __builtin_shufflevector(__ret_848, __ret_848, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_848; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmul_lane_f16(__p0_849, __p1_849, __p2_849) __extension__ ({ \
+  float16x4_t __ret_849; \
+  float16x4_t __s0_849 = __p0_849; \
+  float16x4_t __s1_849 = __p1_849; \
+  __ret_849 = __s0_849 * splat_lane_f16(__s1_849, __p2_849); \
+  __ret_849; \
+})
+#else
+#define vmul_lane_f16(__p0_850, __p1_850, __p2_850) __extension__ ({ \
+  float16x4_t __ret_850; \
+  float16x4_t __s0_850 = __p0_850; \
+  float16x4_t __s1_850 = __p1_850; \
+  float16x4_t __rev0_850;  __rev0_850 = __builtin_shufflevector(__s0_850, __s0_850, 3, 2, 1, 0); \
+  float16x4_t __rev1_850;  __rev1_850 = __builtin_shufflevector(__s1_850, __s1_850, 3, 2, 1, 0); \
+  __ret_850 = __rev0_850 * __noswap_splat_lane_f16(__rev1_850, __p2_850); \
+  __ret_850 = __builtin_shufflevector(__ret_850, __ret_850, 3, 2, 1, 0); \
+  __ret_850; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsudotq_lane_s32(__p0_851, __p1_851, __p2_851, __p3_851) __extension__ ({ \
+  int32x4_t __ret_851; \
+  int32x4_t __s0_851 = __p0_851; \
+  int8x16_t __s1_851 = __p1_851; \
+  uint8x8_t __s2_851 = __p2_851; \
+uint8x8_t __reint_851 = __s2_851; \
+  __ret_851 = vusdotq_s32(__s0_851, (uint8x16_t)(splatq_lane_s32(*(int32x2_t *) &__reint_851, __p3_851)), __s1_851); \
+  __ret_851; \
+})
+#else
+#define vsudotq_lane_s32(__p0_852, __p1_852, __p2_852, __p3_852) __extension__ ({ \
+  int32x4_t __ret_852; \
+  int32x4_t __s0_852 = __p0_852; \
+  int8x16_t __s1_852 = __p1_852; \
+  uint8x8_t __s2_852 = __p2_852; \
+  int32x4_t __rev0_852;  __rev0_852 = __builtin_shufflevector(__s0_852, __s0_852, 3, 2, 1, 0); \
+  int8x16_t __rev1_852;  __rev1_852 = __builtin_shufflevector(__s1_852, __s1_852, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev2_852;  __rev2_852 = __builtin_shufflevector(__s2_852, __s2_852, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x8_t __reint_852 = __rev2_852; \
+  __ret_852 = __noswap_vusdotq_s32(__rev0_852, (uint8x16_t)(__noswap_splatq_lane_s32(*(int32x2_t *) &__reint_852, __p3_852)), __rev1_852); \
+  __ret_852 = __builtin_shufflevector(__ret_852, __ret_852, 3, 2, 1, 0); \
+  __ret_852; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsudot_lane_s32(__p0_853, __p1_853, __p2_853, __p3_853) __extension__ ({ \
+  int32x2_t __ret_853; \
+  int32x2_t __s0_853 = __p0_853; \
+  int8x8_t __s1_853 = __p1_853; \
+  uint8x8_t __s2_853 = __p2_853; \
+uint8x8_t __reint_853 = __s2_853; \
+  __ret_853 = vusdot_s32(__s0_853, (uint8x8_t)(splat_lane_s32(*(int32x2_t *) &__reint_853, __p3_853)), __s1_853); \
+  __ret_853; \
+})
+#else
+#define vsudot_lane_s32(__p0_854, __p1_854, __p2_854, __p3_854) __extension__ ({ \
+  int32x2_t __ret_854; \
+  int32x2_t __s0_854 = __p0_854; \
+  int8x8_t __s1_854 = __p1_854; \
+  uint8x8_t __s2_854 = __p2_854; \
+  int32x2_t __rev0_854;  __rev0_854 = __builtin_shufflevector(__s0_854, __s0_854, 1, 0); \
+  int8x8_t __rev1_854;  __rev1_854 = __builtin_shufflevector(__s1_854, __s1_854, 7, 6, 5, 4, 3, 2, 1, 0); \
+  uint8x8_t __rev2_854;  __rev2_854 = __builtin_shufflevector(__s2_854, __s2_854, 7, 6, 5, 4, 3, 2, 1, 0); \
+uint8x8_t __reint_854 = __rev2_854; \
+  __ret_854 = __noswap_vusdot_s32(__rev0_854, (uint8x8_t)(__noswap_splat_lane_s32(*(int32x2_t *) &__reint_854, __p3_854)), __rev1_854); \
+  __ret_854 = __builtin_shufflevector(__ret_854, __ret_854, 1, 0); \
+  __ret_854; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vusdotq_lane_s32(__p0_855, __p1_855, __p2_855, __p3_855) __extension__ ({ \
+  int32x4_t __ret_855; \
+  int32x4_t __s0_855 = __p0_855; \
+  uint8x16_t __s1_855 = __p1_855; \
+  int8x8_t __s2_855 = __p2_855; \
+int8x8_t __reint_855 = __s2_855; \
+  __ret_855 = vusdotq_s32(__s0_855, __s1_855, (int8x16_t)(splatq_lane_s32(*(int32x2_t *) &__reint_855, __p3_855))); \
+  __ret_855; \
+})
+#else
+#define vusdotq_lane_s32(__p0_856, __p1_856, __p2_856, __p3_856) __extension__ ({ \
+  int32x4_t __ret_856; \
+  int32x4_t __s0_856 = __p0_856; \
+  uint8x16_t __s1_856 = __p1_856; \
+  int8x8_t __s2_856 = __p2_856; \
+  int32x4_t __rev0_856;  __rev0_856 = __builtin_shufflevector(__s0_856, __s0_856, 3, 2, 1, 0); \
+  uint8x16_t __rev1_856;  __rev1_856 = __builtin_shufflevector(__s1_856, __s1_856, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev2_856;  __rev2_856 = __builtin_shufflevector(__s2_856, __s2_856, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x8_t __reint_856 = __rev2_856; \
+  __ret_856 = __noswap_vusdotq_s32(__rev0_856, __rev1_856, (int8x16_t)(__noswap_splatq_lane_s32(*(int32x2_t *) &__reint_856, __p3_856))); \
+  __ret_856 = __builtin_shufflevector(__ret_856, __ret_856, 3, 2, 1, 0); \
+  __ret_856; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vusdot_lane_s32(__p0_857, __p1_857, __p2_857, __p3_857) __extension__ ({ \
+  int32x2_t __ret_857; \
+  int32x2_t __s0_857 = __p0_857; \
+  uint8x8_t __s1_857 = __p1_857; \
+  int8x8_t __s2_857 = __p2_857; \
+int8x8_t __reint_857 = __s2_857; \
+  __ret_857 = vusdot_s32(__s0_857, __s1_857, (int8x8_t)(splat_lane_s32(*(int32x2_t *) &__reint_857, __p3_857))); \
+  __ret_857; \
+})
+#else
+#define vusdot_lane_s32(__p0_858, __p1_858, __p2_858, __p3_858) __extension__ ({ \
+  int32x2_t __ret_858; \
+  int32x2_t __s0_858 = __p0_858; \
+  uint8x8_t __s1_858 = __p1_858; \
+  int8x8_t __s2_858 = __p2_858; \
+  int32x2_t __rev0_858;  __rev0_858 = __builtin_shufflevector(__s0_858, __s0_858, 1, 0); \
+  uint8x8_t __rev1_858;  __rev1_858 = __builtin_shufflevector(__s1_858, __s1_858, 7, 6, 5, 4, 3, 2, 1, 0); \
+  int8x8_t __rev2_858;  __rev2_858 = __builtin_shufflevector(__s2_858, __s2_858, 7, 6, 5, 4, 3, 2, 1, 0); \
+int8x8_t __reint_858 = __rev2_858; \
+  __ret_858 = __noswap_vusdot_s32(__rev0_858, __rev1_858, (int8x8_t)(__noswap_splat_lane_s32(*(int32x2_t *) &__reint_858, __p3_858))); \
+  __ret_858 = __builtin_shufflevector(__ret_858, __ret_858, 1, 0); \
+  __ret_858; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x16_t vabaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  __ret = __p0 + vabdq_u8(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x16_t vabaq_u8(uint8x16_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint8x16_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabdq_u8(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vabaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 + vabdq_u32(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vabaq_u32(uint32x4_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabdq_u32(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vabaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 + vabdq_u16(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vabaq_u16(uint16x8_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabdq_u16(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x16_t vabaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  __ret = __p0 + vabdq_s8(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x16_t vabaq_s8(int8x16_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int8x16_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabdq_s8(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vabaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 + vabdq_s32(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vabaq_s32(int32x4_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabdq_s32(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vabaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 + vabdq_s16(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vabaq_s16(int16x8_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabdq_s16(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint8x8_t vaba_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  __ret = __p0 + vabd_u8(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint8x8_t vaba_u8(uint8x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint8x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabd_u8(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x2_t vaba_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint32x2_t __ret;
+  __ret = __p0 + vabd_u32(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x2_t vaba_u32(uint32x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint32x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 + __noswap_vabd_u32(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x4_t vaba_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint16x4_t __ret;
+  __ret = __p0 + vabd_u16(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x4_t vaba_u16(uint16x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint16x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabd_u16(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int8x8_t vaba_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  __ret = __p0 + vabd_s8(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int8x8_t vaba_s8(int8x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int8x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabd_s8(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x2_t vaba_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  __ret = __p0 + vabd_s32(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x2_t vaba_s32(int32x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int32x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 + __noswap_vabd_s32(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x4_t vaba_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  __ret = __p0 + vabd_s16(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x4_t vaba_s16(int16x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int16x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabd_s16(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(vmovl_u8((uint8x8_t)(vabd_u8(__p0, __p1))));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (uint16x8_t)(__noswap_vmovl_u8((uint8x8_t)(__noswap_vabd_u8(__rev0, __rev1))));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vabdl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = (uint16x8_t)(__noswap_vmovl_u8((uint8x8_t)(__noswap_vabd_u8(__p0, __p1))));
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(vmovl_u32((uint32x2_t)(vabd_u32(__p0, __p1))));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (uint64x2_t)(__noswap_vmovl_u32((uint32x2_t)(__noswap_vabd_u32(__rev0, __rev1))));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vabdl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = (uint64x2_t)(__noswap_vmovl_u32((uint32x2_t)(__noswap_vabd_u32(__p0, __p1))));
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(vmovl_u16((uint16x4_t)(vabd_u16(__p0, __p1))));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (uint32x4_t)(__noswap_vmovl_u16((uint16x4_t)(__noswap_vabd_u16(__rev0, __rev1))));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vabdl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = (uint32x4_t)(__noswap_vmovl_u16((uint16x4_t)(__noswap_vabd_u16(__p0, __p1))));
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(vmovl_u8((uint8x8_t)(vabd_s8(__p0, __p1))));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = (int16x8_t)(__noswap_vmovl_u8((uint8x8_t)(__noswap_vabd_s8(__rev0, __rev1))));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vabdl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  __ret = (int16x8_t)(__noswap_vmovl_u8((uint8x8_t)(__noswap_vabd_s8(__p0, __p1))));
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(vmovl_u32((uint32x2_t)(vabd_s32(__p0, __p1))));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = (int64x2_t)(__noswap_vmovl_u32((uint32x2_t)(__noswap_vabd_s32(__rev0, __rev1))));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vabdl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  __ret = (int64x2_t)(__noswap_vmovl_u32((uint32x2_t)(__noswap_vabd_s32(__p0, __p1))));
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(vmovl_u16((uint16x4_t)(vabd_s16(__p0, __p1))));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = (int32x4_t)(__noswap_vmovl_u16((uint16x4_t)(__noswap_vabd_s16(__rev0, __rev1))));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vabdl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  __ret = (int32x4_t)(__noswap_vmovl_u16((uint16x4_t)(__noswap_vabd_s16(__p0, __p1))));
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vaddl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = vmovl_u8(__p0) + vmovl_u8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vaddl_u8(uint8x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  uint8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_u8(__rev0) + __noswap_vmovl_u8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vaddl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = vmovl_u32(__p0) + vmovl_u32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vaddl_u32(uint32x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  uint32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vmovl_u32(__rev0) + __noswap_vmovl_u32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vaddl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = vmovl_u16(__p0) + vmovl_u16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vaddl_u16(uint16x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  uint16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_u16(__rev0) + __noswap_vmovl_u16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vaddl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  __ret = vmovl_s8(__p0) + vmovl_s8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vaddl_s8(int8x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  int8x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_s8(__rev0) + __noswap_vmovl_s8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vaddl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  __ret = vmovl_s32(__p0) + vmovl_s32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vaddl_s32(int32x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  int32x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __noswap_vmovl_s32(__rev0) + __noswap_vmovl_s32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vaddl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  __ret = vmovl_s16(__p0) + vmovl_s16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vaddl_s16(int16x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  int16x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_s16(__rev0) + __noswap_vmovl_s16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vaddw_u8(uint16x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 + vmovl_u8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vaddw_u8(uint16x8_t __p0, uint8x8_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_u8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vaddw_u32(uint64x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 + vmovl_u32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vaddw_u32(uint64x2_t __p0, uint32x2_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_u32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vaddw_u16(uint32x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 + vmovl_u16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vaddw_u16(uint32x4_t __p0, uint16x4_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_u16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vaddw_s8(int16x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 + vmovl_s8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vaddw_s8(int16x8_t __p0, int8x8_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_s8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vaddw_s32(int64x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 + vmovl_s32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vaddw_s32(int64x2_t __p0, int32x2_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_s32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vaddw_s16(int32x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 + vmovl_s16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vaddw_s16(int32x4_t __p0, int16x4_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_s16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vget_lane_f16(__p0_859, __p1_859) __extension__ ({ \
+  float16_t __ret_859; \
+  float16x4_t __s0_859 = __p0_859; \
+float16x4_t __reint_859 = __s0_859; \
+int16_t __reint1_859 = vget_lane_s16(*(int16x4_t *) &__reint_859, __p1_859); \
+  __ret_859 = *(float16_t *) &__reint1_859; \
+  __ret_859; \
+})
+#else
+#define vget_lane_f16(__p0_860, __p1_860) __extension__ ({ \
+  float16_t __ret_860; \
+  float16x4_t __s0_860 = __p0_860; \
+  float16x4_t __rev0_860;  __rev0_860 = __builtin_shufflevector(__s0_860, __s0_860, 3, 2, 1, 0); \
+float16x4_t __reint_860 = __rev0_860; \
+int16_t __reint1_860 = __noswap_vget_lane_s16(*(int16x4_t *) &__reint_860, __p1_860); \
+  __ret_860 = *(float16_t *) &__reint1_860; \
+  __ret_860; \
+})
+#define __noswap_vget_lane_f16(__p0_861, __p1_861) __extension__ ({ \
+  float16_t __ret_861; \
+  float16x4_t __s0_861 = __p0_861; \
+float16x4_t __reint_861 = __s0_861; \
+int16_t __reint1_861 = __noswap_vget_lane_s16(*(int16x4_t *) &__reint_861, __p1_861); \
+  __ret_861 = *(float16_t *) &__reint1_861; \
+  __ret_861; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vgetq_lane_f16(__p0_862, __p1_862) __extension__ ({ \
+  float16_t __ret_862; \
+  float16x8_t __s0_862 = __p0_862; \
+float16x8_t __reint_862 = __s0_862; \
+int16_t __reint1_862 = vgetq_lane_s16(*(int16x8_t *) &__reint_862, __p1_862); \
+  __ret_862 = *(float16_t *) &__reint1_862; \
+  __ret_862; \
+})
+#else
+#define vgetq_lane_f16(__p0_863, __p1_863) __extension__ ({ \
+  float16_t __ret_863; \
+  float16x8_t __s0_863 = __p0_863; \
+  float16x8_t __rev0_863;  __rev0_863 = __builtin_shufflevector(__s0_863, __s0_863, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16x8_t __reint_863 = __rev0_863; \
+int16_t __reint1_863 = __noswap_vgetq_lane_s16(*(int16x8_t *) &__reint_863, __p1_863); \
+  __ret_863 = *(float16_t *) &__reint1_863; \
+  __ret_863; \
+})
+#define __noswap_vgetq_lane_f16(__p0_864, __p1_864) __extension__ ({ \
+  float16_t __ret_864; \
+  float16x8_t __s0_864 = __p0_864; \
+float16x8_t __reint_864 = __s0_864; \
+int16_t __reint1_864 = __noswap_vgetq_lane_s16(*(int16x8_t *) &__reint_864, __p1_864); \
+  __ret_864 = *(float16_t *) &__reint1_864; \
+  __ret_864; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 + vmull_u8(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmull_u8(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vmlal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 + __noswap_vmull_u8(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = __p0 + vmull_u32(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 + __noswap_vmull_u32(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmlal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = __p0 + __noswap_vmull_u32(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 + vmull_u16(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmull_u16(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmlal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 + __noswap_vmull_u16(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 + vmull_s8(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmull_s8(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vmlal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 + __noswap_vmull_s8(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  __ret = __p0 + vmull_s32(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 + __noswap_vmull_s32(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmlal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  __ret = __p0 + __noswap_vmull_s32(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 + vmull_s16(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmull_s16(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmlal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 + __noswap_vmull_s16(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_lane_u32(__p0_865, __p1_865, __p2_865, __p3_865) __extension__ ({ \
+  uint64x2_t __ret_865; \
+  uint64x2_t __s0_865 = __p0_865; \
+  uint32x2_t __s1_865 = __p1_865; \
+  uint32x2_t __s2_865 = __p2_865; \
+  __ret_865 = __s0_865 + vmull_u32(__s1_865, splat_lane_u32(__s2_865, __p3_865)); \
+  __ret_865; \
+})
+#else
+#define vmlal_lane_u32(__p0_866, __p1_866, __p2_866, __p3_866) __extension__ ({ \
+  uint64x2_t __ret_866; \
+  uint64x2_t __s0_866 = __p0_866; \
+  uint32x2_t __s1_866 = __p1_866; \
+  uint32x2_t __s2_866 = __p2_866; \
+  uint64x2_t __rev0_866;  __rev0_866 = __builtin_shufflevector(__s0_866, __s0_866, 1, 0); \
+  uint32x2_t __rev1_866;  __rev1_866 = __builtin_shufflevector(__s1_866, __s1_866, 1, 0); \
+  uint32x2_t __rev2_866;  __rev2_866 = __builtin_shufflevector(__s2_866, __s2_866, 1, 0); \
+  __ret_866 = __rev0_866 + __noswap_vmull_u32(__rev1_866, __noswap_splat_lane_u32(__rev2_866, __p3_866)); \
+  __ret_866 = __builtin_shufflevector(__ret_866, __ret_866, 1, 0); \
+  __ret_866; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_lane_u16(__p0_867, __p1_867, __p2_867, __p3_867) __extension__ ({ \
+  uint32x4_t __ret_867; \
+  uint32x4_t __s0_867 = __p0_867; \
+  uint16x4_t __s1_867 = __p1_867; \
+  uint16x4_t __s2_867 = __p2_867; \
+  __ret_867 = __s0_867 + vmull_u16(__s1_867, splat_lane_u16(__s2_867, __p3_867)); \
+  __ret_867; \
+})
+#else
+#define vmlal_lane_u16(__p0_868, __p1_868, __p2_868, __p3_868) __extension__ ({ \
+  uint32x4_t __ret_868; \
+  uint32x4_t __s0_868 = __p0_868; \
+  uint16x4_t __s1_868 = __p1_868; \
+  uint16x4_t __s2_868 = __p2_868; \
+  uint32x4_t __rev0_868;  __rev0_868 = __builtin_shufflevector(__s0_868, __s0_868, 3, 2, 1, 0); \
+  uint16x4_t __rev1_868;  __rev1_868 = __builtin_shufflevector(__s1_868, __s1_868, 3, 2, 1, 0); \
+  uint16x4_t __rev2_868;  __rev2_868 = __builtin_shufflevector(__s2_868, __s2_868, 3, 2, 1, 0); \
+  __ret_868 = __rev0_868 + __noswap_vmull_u16(__rev1_868, __noswap_splat_lane_u16(__rev2_868, __p3_868)); \
+  __ret_868 = __builtin_shufflevector(__ret_868, __ret_868, 3, 2, 1, 0); \
+  __ret_868; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_lane_s32(__p0_869, __p1_869, __p2_869, __p3_869) __extension__ ({ \
+  int64x2_t __ret_869; \
+  int64x2_t __s0_869 = __p0_869; \
+  int32x2_t __s1_869 = __p1_869; \
+  int32x2_t __s2_869 = __p2_869; \
+  __ret_869 = __s0_869 + vmull_s32(__s1_869, splat_lane_s32(__s2_869, __p3_869)); \
+  __ret_869; \
+})
+#else
+#define vmlal_lane_s32(__p0_870, __p1_870, __p2_870, __p3_870) __extension__ ({ \
+  int64x2_t __ret_870; \
+  int64x2_t __s0_870 = __p0_870; \
+  int32x2_t __s1_870 = __p1_870; \
+  int32x2_t __s2_870 = __p2_870; \
+  int64x2_t __rev0_870;  __rev0_870 = __builtin_shufflevector(__s0_870, __s0_870, 1, 0); \
+  int32x2_t __rev1_870;  __rev1_870 = __builtin_shufflevector(__s1_870, __s1_870, 1, 0); \
+  int32x2_t __rev2_870;  __rev2_870 = __builtin_shufflevector(__s2_870, __s2_870, 1, 0); \
+  __ret_870 = __rev0_870 + __noswap_vmull_s32(__rev1_870, __noswap_splat_lane_s32(__rev2_870, __p3_870)); \
+  __ret_870 = __builtin_shufflevector(__ret_870, __ret_870, 1, 0); \
+  __ret_870; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlal_lane_s16(__p0_871, __p1_871, __p2_871, __p3_871) __extension__ ({ \
+  int32x4_t __ret_871; \
+  int32x4_t __s0_871 = __p0_871; \
+  int16x4_t __s1_871 = __p1_871; \
+  int16x4_t __s2_871 = __p2_871; \
+  __ret_871 = __s0_871 + vmull_s16(__s1_871, splat_lane_s16(__s2_871, __p3_871)); \
+  __ret_871; \
+})
+#else
+#define vmlal_lane_s16(__p0_872, __p1_872, __p2_872, __p3_872) __extension__ ({ \
+  int32x4_t __ret_872; \
+  int32x4_t __s0_872 = __p0_872; \
+  int16x4_t __s1_872 = __p1_872; \
+  int16x4_t __s2_872 = __p2_872; \
+  int32x4_t __rev0_872;  __rev0_872 = __builtin_shufflevector(__s0_872, __s0_872, 3, 2, 1, 0); \
+  int16x4_t __rev1_872;  __rev1_872 = __builtin_shufflevector(__s1_872, __s1_872, 3, 2, 1, 0); \
+  int16x4_t __rev2_872;  __rev2_872 = __builtin_shufflevector(__s2_872, __s2_872, 3, 2, 1, 0); \
+  __ret_872 = __rev0_872 + __noswap_vmull_s16(__rev1_872, __noswap_splat_lane_s16(__rev2_872, __p3_872)); \
+  __ret_872 = __builtin_shufflevector(__ret_872, __ret_872, 3, 2, 1, 0); \
+  __ret_872; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+  uint64x2_t __ret;
+  __ret = __p0 + vmull_u32(__p1, (uint32x2_t) {__p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __noswap_vmull_u32(__rev1, (uint32x2_t) {__p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmlal_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+  uint64x2_t __ret;
+  __ret = __p0 + __noswap_vmull_u32(__p1, (uint32x2_t) {__p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 + vmull_u16(__p1, (uint16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmull_u16(__rev1, (uint16x4_t) {__p2, __p2, __p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmlal_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 + __noswap_vmull_u16(__p1, (uint16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = __p0 + vmull_s32(__p1, (int32x2_t) {__p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 + __noswap_vmull_s32(__rev1, (int32x2_t) {__p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmlal_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = __p0 + __noswap_vmull_s32(__p1, (int32x2_t) {__p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 + vmull_s16(__p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmull_s16(__rev1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmlal_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 + __noswap_vmull_s16(__p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 - vmull_u8(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmull_u8(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vmlsl_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 - __noswap_vmull_u8(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = __p0 - vmull_u32(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 - __noswap_vmull_u32(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmlsl_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = __p0 - __noswap_vmull_u32(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 - vmull_u16(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmull_u16(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmlsl_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 - __noswap_vmull_u16(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 - vmull_s8(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmull_s8(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vmlsl_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 - __noswap_vmull_s8(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  __ret = __p0 - vmull_s32(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 - __noswap_vmull_s32(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmlsl_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  __ret = __p0 - __noswap_vmull_s32(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 - vmull_s16(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmull_s16(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmlsl_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 - __noswap_vmull_s16(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_lane_u32(__p0_873, __p1_873, __p2_873, __p3_873) __extension__ ({ \
+  uint64x2_t __ret_873; \
+  uint64x2_t __s0_873 = __p0_873; \
+  uint32x2_t __s1_873 = __p1_873; \
+  uint32x2_t __s2_873 = __p2_873; \
+  __ret_873 = __s0_873 - vmull_u32(__s1_873, splat_lane_u32(__s2_873, __p3_873)); \
+  __ret_873; \
+})
+#else
+#define vmlsl_lane_u32(__p0_874, __p1_874, __p2_874, __p3_874) __extension__ ({ \
+  uint64x2_t __ret_874; \
+  uint64x2_t __s0_874 = __p0_874; \
+  uint32x2_t __s1_874 = __p1_874; \
+  uint32x2_t __s2_874 = __p2_874; \
+  uint64x2_t __rev0_874;  __rev0_874 = __builtin_shufflevector(__s0_874, __s0_874, 1, 0); \
+  uint32x2_t __rev1_874;  __rev1_874 = __builtin_shufflevector(__s1_874, __s1_874, 1, 0); \
+  uint32x2_t __rev2_874;  __rev2_874 = __builtin_shufflevector(__s2_874, __s2_874, 1, 0); \
+  __ret_874 = __rev0_874 - __noswap_vmull_u32(__rev1_874, __noswap_splat_lane_u32(__rev2_874, __p3_874)); \
+  __ret_874 = __builtin_shufflevector(__ret_874, __ret_874, 1, 0); \
+  __ret_874; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_lane_u16(__p0_875, __p1_875, __p2_875, __p3_875) __extension__ ({ \
+  uint32x4_t __ret_875; \
+  uint32x4_t __s0_875 = __p0_875; \
+  uint16x4_t __s1_875 = __p1_875; \
+  uint16x4_t __s2_875 = __p2_875; \
+  __ret_875 = __s0_875 - vmull_u16(__s1_875, splat_lane_u16(__s2_875, __p3_875)); \
+  __ret_875; \
+})
+#else
+#define vmlsl_lane_u16(__p0_876, __p1_876, __p2_876, __p3_876) __extension__ ({ \
+  uint32x4_t __ret_876; \
+  uint32x4_t __s0_876 = __p0_876; \
+  uint16x4_t __s1_876 = __p1_876; \
+  uint16x4_t __s2_876 = __p2_876; \
+  uint32x4_t __rev0_876;  __rev0_876 = __builtin_shufflevector(__s0_876, __s0_876, 3, 2, 1, 0); \
+  uint16x4_t __rev1_876;  __rev1_876 = __builtin_shufflevector(__s1_876, __s1_876, 3, 2, 1, 0); \
+  uint16x4_t __rev2_876;  __rev2_876 = __builtin_shufflevector(__s2_876, __s2_876, 3, 2, 1, 0); \
+  __ret_876 = __rev0_876 - __noswap_vmull_u16(__rev1_876, __noswap_splat_lane_u16(__rev2_876, __p3_876)); \
+  __ret_876 = __builtin_shufflevector(__ret_876, __ret_876, 3, 2, 1, 0); \
+  __ret_876; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_lane_s32(__p0_877, __p1_877, __p2_877, __p3_877) __extension__ ({ \
+  int64x2_t __ret_877; \
+  int64x2_t __s0_877 = __p0_877; \
+  int32x2_t __s1_877 = __p1_877; \
+  int32x2_t __s2_877 = __p2_877; \
+  __ret_877 = __s0_877 - vmull_s32(__s1_877, splat_lane_s32(__s2_877, __p3_877)); \
+  __ret_877; \
+})
+#else
+#define vmlsl_lane_s32(__p0_878, __p1_878, __p2_878, __p3_878) __extension__ ({ \
+  int64x2_t __ret_878; \
+  int64x2_t __s0_878 = __p0_878; \
+  int32x2_t __s1_878 = __p1_878; \
+  int32x2_t __s2_878 = __p2_878; \
+  int64x2_t __rev0_878;  __rev0_878 = __builtin_shufflevector(__s0_878, __s0_878, 1, 0); \
+  int32x2_t __rev1_878;  __rev1_878 = __builtin_shufflevector(__s1_878, __s1_878, 1, 0); \
+  int32x2_t __rev2_878;  __rev2_878 = __builtin_shufflevector(__s2_878, __s2_878, 1, 0); \
+  __ret_878 = __rev0_878 - __noswap_vmull_s32(__rev1_878, __noswap_splat_lane_s32(__rev2_878, __p3_878)); \
+  __ret_878 = __builtin_shufflevector(__ret_878, __ret_878, 1, 0); \
+  __ret_878; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmlsl_lane_s16(__p0_879, __p1_879, __p2_879, __p3_879) __extension__ ({ \
+  int32x4_t __ret_879; \
+  int32x4_t __s0_879 = __p0_879; \
+  int16x4_t __s1_879 = __p1_879; \
+  int16x4_t __s2_879 = __p2_879; \
+  __ret_879 = __s0_879 - vmull_s16(__s1_879, splat_lane_s16(__s2_879, __p3_879)); \
+  __ret_879; \
+})
+#else
+#define vmlsl_lane_s16(__p0_880, __p1_880, __p2_880, __p3_880) __extension__ ({ \
+  int32x4_t __ret_880; \
+  int32x4_t __s0_880 = __p0_880; \
+  int16x4_t __s1_880 = __p1_880; \
+  int16x4_t __s2_880 = __p2_880; \
+  int32x4_t __rev0_880;  __rev0_880 = __builtin_shufflevector(__s0_880, __s0_880, 3, 2, 1, 0); \
+  int16x4_t __rev1_880;  __rev1_880 = __builtin_shufflevector(__s1_880, __s1_880, 3, 2, 1, 0); \
+  int16x4_t __rev2_880;  __rev2_880 = __builtin_shufflevector(__s2_880, __s2_880, 3, 2, 1, 0); \
+  __ret_880 = __rev0_880 - __noswap_vmull_s16(__rev1_880, __noswap_splat_lane_s16(__rev2_880, __p3_880)); \
+  __ret_880 = __builtin_shufflevector(__ret_880, __ret_880, 3, 2, 1, 0); \
+  __ret_880; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+  uint64x2_t __ret;
+  __ret = __p0 - vmull_u32(__p1, (uint32x2_t) {__p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __noswap_vmull_u32(__rev1, (uint32x2_t) {__p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vmlsl_n_u32(uint64x2_t __p0, uint32x2_t __p1, uint32_t __p2) {
+  uint64x2_t __ret;
+  __ret = __p0 - __noswap_vmull_u32(__p1, (uint32x2_t) {__p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 - vmull_u16(__p1, (uint16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmull_u16(__rev1, (uint16x4_t) {__p2, __p2, __p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vmlsl_n_u16(uint32x4_t __p0, uint16x4_t __p1, uint16_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 - __noswap_vmull_u16(__p1, (uint16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = __p0 - vmull_s32(__p1, (int32x2_t) {__p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = __rev0 - __noswap_vmull_s32(__rev1, (int32x2_t) {__p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vmlsl_n_s32(int64x2_t __p0, int32x2_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = __p0 - __noswap_vmull_s32(__p1, (int32x2_t) {__p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 - vmull_s16(__p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 - __noswap_vmull_s16(__rev1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vmlsl_n_s16(int32x4_t __p0, int16x4_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 - __noswap_vmull_s16(__p1, (int16x4_t) {__p2, __p2, __p2, __p2});
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vset_lane_f16(__p0_881, __p1_881, __p2_881) __extension__ ({ \
+  float16x4_t __ret_881; \
+  float16_t __s0_881 = __p0_881; \
+  float16x4_t __s1_881 = __p1_881; \
+float16_t __reint_881 = __s0_881; \
+float16x4_t __reint1_881 = __s1_881; \
+int16x4_t __reint2_881 = vset_lane_s16(*(int16_t *) &__reint_881, *(int16x4_t *) &__reint1_881, __p2_881); \
+  __ret_881 = *(float16x4_t *) &__reint2_881; \
+  __ret_881; \
+})
+#else
+#define vset_lane_f16(__p0_882, __p1_882, __p2_882) __extension__ ({ \
+  float16x4_t __ret_882; \
+  float16_t __s0_882 = __p0_882; \
+  float16x4_t __s1_882 = __p1_882; \
+  float16x4_t __rev1_882;  __rev1_882 = __builtin_shufflevector(__s1_882, __s1_882, 3, 2, 1, 0); \
+float16_t __reint_882 = __s0_882; \
+float16x4_t __reint1_882 = __rev1_882; \
+int16x4_t __reint2_882 = __noswap_vset_lane_s16(*(int16_t *) &__reint_882, *(int16x4_t *) &__reint1_882, __p2_882); \
+  __ret_882 = *(float16x4_t *) &__reint2_882; \
+  __ret_882 = __builtin_shufflevector(__ret_882, __ret_882, 3, 2, 1, 0); \
+  __ret_882; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vsetq_lane_f16(__p0_883, __p1_883, __p2_883) __extension__ ({ \
+  float16x8_t __ret_883; \
+  float16_t __s0_883 = __p0_883; \
+  float16x8_t __s1_883 = __p1_883; \
+float16_t __reint_883 = __s0_883; \
+float16x8_t __reint1_883 = __s1_883; \
+int16x8_t __reint2_883 = vsetq_lane_s16(*(int16_t *) &__reint_883, *(int16x8_t *) &__reint1_883, __p2_883); \
+  __ret_883 = *(float16x8_t *) &__reint2_883; \
+  __ret_883; \
+})
+#else
+#define vsetq_lane_f16(__p0_884, __p1_884, __p2_884) __extension__ ({ \
+  float16x8_t __ret_884; \
+  float16_t __s0_884 = __p0_884; \
+  float16x8_t __s1_884 = __p1_884; \
+  float16x8_t __rev1_884;  __rev1_884 = __builtin_shufflevector(__s1_884, __s1_884, 7, 6, 5, 4, 3, 2, 1, 0); \
+float16_t __reint_884 = __s0_884; \
+float16x8_t __reint1_884 = __rev1_884; \
+int16x8_t __reint2_884 = __noswap_vsetq_lane_s16(*(int16_t *) &__reint_884, *(int16x8_t *) &__reint1_884, __p2_884); \
+  __ret_884 = *(float16x8_t *) &__reint2_884; \
+  __ret_884 = __builtin_shufflevector(__ret_884, __ret_884, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_884; \
+})
+#endif
+
+#if defined(__aarch64__) || defined(__arm64ec__)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("aes,neon"))) poly128_t vmull_high_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly128_t __ret;
+  __ret = vmull_p64((poly64_t)(vget_high_p64(__p0)), (poly64_t)(vget_high_p64(__p1)));
+  return __ret;
+}
+#else
+__ai __attribute__((target("aes,neon"))) poly128_t vmull_high_p64(poly64x2_t __p0, poly64x2_t __p1) {
+  poly128_t __ret;
+  poly64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  poly64x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  __ret = vmull_p64((poly64_t)(__noswap_vget_high_p64(__rev0)), (poly64_t)(__noswap_vget_high_p64(__rev1)));
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlalq_lane_high_f16(__p0_885, __p1_885, __p2_885, __p3_885) __extension__ ({ \
+  float32x4_t __ret_885; \
+  float32x4_t __s0_885 = __p0_885; \
+  float16x8_t __s1_885 = __p1_885; \
+  float16x4_t __s2_885 = __p2_885; \
+  __ret_885 = vfmlalq_high_f16(__s0_885, __s1_885, (float16x8_t) {vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885), vget_lane_f16(__s2_885, __p3_885)}); \
+  __ret_885; \
+})
+#else
+#define vfmlalq_lane_high_f16(__p0_886, __p1_886, __p2_886, __p3_886) __extension__ ({ \
+  float32x4_t __ret_886; \
+  float32x4_t __s0_886 = __p0_886; \
+  float16x8_t __s1_886 = __p1_886; \
+  float16x4_t __s2_886 = __p2_886; \
+  float32x4_t __rev0_886;  __rev0_886 = __builtin_shufflevector(__s0_886, __s0_886, 3, 2, 1, 0); \
+  float16x8_t __rev1_886;  __rev1_886 = __builtin_shufflevector(__s1_886, __s1_886, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev2_886;  __rev2_886 = __builtin_shufflevector(__s2_886, __s2_886, 3, 2, 1, 0); \
+  __ret_886 = __noswap_vfmlalq_high_f16(__rev0_886, __rev1_886, (float16x8_t) {__noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886), __noswap_vget_lane_f16(__rev2_886, __p3_886)}); \
+  __ret_886 = __builtin_shufflevector(__ret_886, __ret_886, 3, 2, 1, 0); \
+  __ret_886; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlal_lane_high_f16(__p0_887, __p1_887, __p2_887, __p3_887) __extension__ ({ \
+  float32x2_t __ret_887; \
+  float32x2_t __s0_887 = __p0_887; \
+  float16x4_t __s1_887 = __p1_887; \
+  float16x4_t __s2_887 = __p2_887; \
+  __ret_887 = vfmlal_high_f16(__s0_887, __s1_887, (float16x4_t) {vget_lane_f16(__s2_887, __p3_887), vget_lane_f16(__s2_887, __p3_887), vget_lane_f16(__s2_887, __p3_887), vget_lane_f16(__s2_887, __p3_887)}); \
+  __ret_887; \
+})
+#else
+#define vfmlal_lane_high_f16(__p0_888, __p1_888, __p2_888, __p3_888) __extension__ ({ \
+  float32x2_t __ret_888; \
+  float32x2_t __s0_888 = __p0_888; \
+  float16x4_t __s1_888 = __p1_888; \
+  float16x4_t __s2_888 = __p2_888; \
+  float32x2_t __rev0_888;  __rev0_888 = __builtin_shufflevector(__s0_888, __s0_888, 1, 0); \
+  float16x4_t __rev1_888;  __rev1_888 = __builtin_shufflevector(__s1_888, __s1_888, 3, 2, 1, 0); \
+  float16x4_t __rev2_888;  __rev2_888 = __builtin_shufflevector(__s2_888, __s2_888, 3, 2, 1, 0); \
+  __ret_888 = __noswap_vfmlal_high_f16(__rev0_888, __rev1_888, (float16x4_t) {__noswap_vget_lane_f16(__rev2_888, __p3_888), __noswap_vget_lane_f16(__rev2_888, __p3_888), __noswap_vget_lane_f16(__rev2_888, __p3_888), __noswap_vget_lane_f16(__rev2_888, __p3_888)}); \
+  __ret_888 = __builtin_shufflevector(__ret_888, __ret_888, 1, 0); \
+  __ret_888; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlalq_lane_low_f16(__p0_889, __p1_889, __p2_889, __p3_889) __extension__ ({ \
+  float32x4_t __ret_889; \
+  float32x4_t __s0_889 = __p0_889; \
+  float16x8_t __s1_889 = __p1_889; \
+  float16x4_t __s2_889 = __p2_889; \
+  __ret_889 = vfmlalq_low_f16(__s0_889, __s1_889, (float16x8_t) {vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889), vget_lane_f16(__s2_889, __p3_889)}); \
+  __ret_889; \
+})
+#else
+#define vfmlalq_lane_low_f16(__p0_890, __p1_890, __p2_890, __p3_890) __extension__ ({ \
+  float32x4_t __ret_890; \
+  float32x4_t __s0_890 = __p0_890; \
+  float16x8_t __s1_890 = __p1_890; \
+  float16x4_t __s2_890 = __p2_890; \
+  float32x4_t __rev0_890;  __rev0_890 = __builtin_shufflevector(__s0_890, __s0_890, 3, 2, 1, 0); \
+  float16x8_t __rev1_890;  __rev1_890 = __builtin_shufflevector(__s1_890, __s1_890, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev2_890;  __rev2_890 = __builtin_shufflevector(__s2_890, __s2_890, 3, 2, 1, 0); \
+  __ret_890 = __noswap_vfmlalq_low_f16(__rev0_890, __rev1_890, (float16x8_t) {__noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890), __noswap_vget_lane_f16(__rev2_890, __p3_890)}); \
+  __ret_890 = __builtin_shufflevector(__ret_890, __ret_890, 3, 2, 1, 0); \
+  __ret_890; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlal_lane_low_f16(__p0_891, __p1_891, __p2_891, __p3_891) __extension__ ({ \
+  float32x2_t __ret_891; \
+  float32x2_t __s0_891 = __p0_891; \
+  float16x4_t __s1_891 = __p1_891; \
+  float16x4_t __s2_891 = __p2_891; \
+  __ret_891 = vfmlal_low_f16(__s0_891, __s1_891, (float16x4_t) {vget_lane_f16(__s2_891, __p3_891), vget_lane_f16(__s2_891, __p3_891), vget_lane_f16(__s2_891, __p3_891), vget_lane_f16(__s2_891, __p3_891)}); \
+  __ret_891; \
+})
+#else
+#define vfmlal_lane_low_f16(__p0_892, __p1_892, __p2_892, __p3_892) __extension__ ({ \
+  float32x2_t __ret_892; \
+  float32x2_t __s0_892 = __p0_892; \
+  float16x4_t __s1_892 = __p1_892; \
+  float16x4_t __s2_892 = __p2_892; \
+  float32x2_t __rev0_892;  __rev0_892 = __builtin_shufflevector(__s0_892, __s0_892, 1, 0); \
+  float16x4_t __rev1_892;  __rev1_892 = __builtin_shufflevector(__s1_892, __s1_892, 3, 2, 1, 0); \
+  float16x4_t __rev2_892;  __rev2_892 = __builtin_shufflevector(__s2_892, __s2_892, 3, 2, 1, 0); \
+  __ret_892 = __noswap_vfmlal_low_f16(__rev0_892, __rev1_892, (float16x4_t) {__noswap_vget_lane_f16(__rev2_892, __p3_892), __noswap_vget_lane_f16(__rev2_892, __p3_892), __noswap_vget_lane_f16(__rev2_892, __p3_892), __noswap_vget_lane_f16(__rev2_892, __p3_892)}); \
+  __ret_892 = __builtin_shufflevector(__ret_892, __ret_892, 1, 0); \
+  __ret_892; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlalq_laneq_high_f16(__p0_893, __p1_893, __p2_893, __p3_893) __extension__ ({ \
+  float32x4_t __ret_893; \
+  float32x4_t __s0_893 = __p0_893; \
+  float16x8_t __s1_893 = __p1_893; \
+  float16x8_t __s2_893 = __p2_893; \
+  __ret_893 = vfmlalq_high_f16(__s0_893, __s1_893, (float16x8_t) {vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893), vgetq_lane_f16(__s2_893, __p3_893)}); \
+  __ret_893; \
+})
+#else
+#define vfmlalq_laneq_high_f16(__p0_894, __p1_894, __p2_894, __p3_894) __extension__ ({ \
+  float32x4_t __ret_894; \
+  float32x4_t __s0_894 = __p0_894; \
+  float16x8_t __s1_894 = __p1_894; \
+  float16x8_t __s2_894 = __p2_894; \
+  float32x4_t __rev0_894;  __rev0_894 = __builtin_shufflevector(__s0_894, __s0_894, 3, 2, 1, 0); \
+  float16x8_t __rev1_894;  __rev1_894 = __builtin_shufflevector(__s1_894, __s1_894, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev2_894;  __rev2_894 = __builtin_shufflevector(__s2_894, __s2_894, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_894 = __noswap_vfmlalq_high_f16(__rev0_894, __rev1_894, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894), __noswap_vgetq_lane_f16(__rev2_894, __p3_894)}); \
+  __ret_894 = __builtin_shufflevector(__ret_894, __ret_894, 3, 2, 1, 0); \
+  __ret_894; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlal_laneq_high_f16(__p0_895, __p1_895, __p2_895, __p3_895) __extension__ ({ \
+  float32x2_t __ret_895; \
+  float32x2_t __s0_895 = __p0_895; \
+  float16x4_t __s1_895 = __p1_895; \
+  float16x8_t __s2_895 = __p2_895; \
+  __ret_895 = vfmlal_high_f16(__s0_895, __s1_895, (float16x4_t) {vgetq_lane_f16(__s2_895, __p3_895), vgetq_lane_f16(__s2_895, __p3_895), vgetq_lane_f16(__s2_895, __p3_895), vgetq_lane_f16(__s2_895, __p3_895)}); \
+  __ret_895; \
+})
+#else
+#define vfmlal_laneq_high_f16(__p0_896, __p1_896, __p2_896, __p3_896) __extension__ ({ \
+  float32x2_t __ret_896; \
+  float32x2_t __s0_896 = __p0_896; \
+  float16x4_t __s1_896 = __p1_896; \
+  float16x8_t __s2_896 = __p2_896; \
+  float32x2_t __rev0_896;  __rev0_896 = __builtin_shufflevector(__s0_896, __s0_896, 1, 0); \
+  float16x4_t __rev1_896;  __rev1_896 = __builtin_shufflevector(__s1_896, __s1_896, 3, 2, 1, 0); \
+  float16x8_t __rev2_896;  __rev2_896 = __builtin_shufflevector(__s2_896, __s2_896, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_896 = __noswap_vfmlal_high_f16(__rev0_896, __rev1_896, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_896, __p3_896), __noswap_vgetq_lane_f16(__rev2_896, __p3_896), __noswap_vgetq_lane_f16(__rev2_896, __p3_896), __noswap_vgetq_lane_f16(__rev2_896, __p3_896)}); \
+  __ret_896 = __builtin_shufflevector(__ret_896, __ret_896, 1, 0); \
+  __ret_896; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlalq_laneq_low_f16(__p0_897, __p1_897, __p2_897, __p3_897) __extension__ ({ \
+  float32x4_t __ret_897; \
+  float32x4_t __s0_897 = __p0_897; \
+  float16x8_t __s1_897 = __p1_897; \
+  float16x8_t __s2_897 = __p2_897; \
+  __ret_897 = vfmlalq_low_f16(__s0_897, __s1_897, (float16x8_t) {vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897), vgetq_lane_f16(__s2_897, __p3_897)}); \
+  __ret_897; \
+})
+#else
+#define vfmlalq_laneq_low_f16(__p0_898, __p1_898, __p2_898, __p3_898) __extension__ ({ \
+  float32x4_t __ret_898; \
+  float32x4_t __s0_898 = __p0_898; \
+  float16x8_t __s1_898 = __p1_898; \
+  float16x8_t __s2_898 = __p2_898; \
+  float32x4_t __rev0_898;  __rev0_898 = __builtin_shufflevector(__s0_898, __s0_898, 3, 2, 1, 0); \
+  float16x8_t __rev1_898;  __rev1_898 = __builtin_shufflevector(__s1_898, __s1_898, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev2_898;  __rev2_898 = __builtin_shufflevector(__s2_898, __s2_898, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_898 = __noswap_vfmlalq_low_f16(__rev0_898, __rev1_898, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898), __noswap_vgetq_lane_f16(__rev2_898, __p3_898)}); \
+  __ret_898 = __builtin_shufflevector(__ret_898, __ret_898, 3, 2, 1, 0); \
+  __ret_898; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlal_laneq_low_f16(__p0_899, __p1_899, __p2_899, __p3_899) __extension__ ({ \
+  float32x2_t __ret_899; \
+  float32x2_t __s0_899 = __p0_899; \
+  float16x4_t __s1_899 = __p1_899; \
+  float16x8_t __s2_899 = __p2_899; \
+  __ret_899 = vfmlal_low_f16(__s0_899, __s1_899, (float16x4_t) {vgetq_lane_f16(__s2_899, __p3_899), vgetq_lane_f16(__s2_899, __p3_899), vgetq_lane_f16(__s2_899, __p3_899), vgetq_lane_f16(__s2_899, __p3_899)}); \
+  __ret_899; \
+})
+#else
+#define vfmlal_laneq_low_f16(__p0_900, __p1_900, __p2_900, __p3_900) __extension__ ({ \
+  float32x2_t __ret_900; \
+  float32x2_t __s0_900 = __p0_900; \
+  float16x4_t __s1_900 = __p1_900; \
+  float16x8_t __s2_900 = __p2_900; \
+  float32x2_t __rev0_900;  __rev0_900 = __builtin_shufflevector(__s0_900, __s0_900, 1, 0); \
+  float16x4_t __rev1_900;  __rev1_900 = __builtin_shufflevector(__s1_900, __s1_900, 3, 2, 1, 0); \
+  float16x8_t __rev2_900;  __rev2_900 = __builtin_shufflevector(__s2_900, __s2_900, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_900 = __noswap_vfmlal_low_f16(__rev0_900, __rev1_900, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_900, __p3_900), __noswap_vgetq_lane_f16(__rev2_900, __p3_900), __noswap_vgetq_lane_f16(__rev2_900, __p3_900), __noswap_vgetq_lane_f16(__rev2_900, __p3_900)}); \
+  __ret_900 = __builtin_shufflevector(__ret_900, __ret_900, 1, 0); \
+  __ret_900; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlslq_lane_high_f16(__p0_901, __p1_901, __p2_901, __p3_901) __extension__ ({ \
+  float32x4_t __ret_901; \
+  float32x4_t __s0_901 = __p0_901; \
+  float16x8_t __s1_901 = __p1_901; \
+  float16x4_t __s2_901 = __p2_901; \
+  __ret_901 = vfmlslq_high_f16(__s0_901, __s1_901, (float16x8_t) {vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901), vget_lane_f16(__s2_901, __p3_901)}); \
+  __ret_901; \
+})
+#else
+#define vfmlslq_lane_high_f16(__p0_902, __p1_902, __p2_902, __p3_902) __extension__ ({ \
+  float32x4_t __ret_902; \
+  float32x4_t __s0_902 = __p0_902; \
+  float16x8_t __s1_902 = __p1_902; \
+  float16x4_t __s2_902 = __p2_902; \
+  float32x4_t __rev0_902;  __rev0_902 = __builtin_shufflevector(__s0_902, __s0_902, 3, 2, 1, 0); \
+  float16x8_t __rev1_902;  __rev1_902 = __builtin_shufflevector(__s1_902, __s1_902, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev2_902;  __rev2_902 = __builtin_shufflevector(__s2_902, __s2_902, 3, 2, 1, 0); \
+  __ret_902 = __noswap_vfmlslq_high_f16(__rev0_902, __rev1_902, (float16x8_t) {__noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902), __noswap_vget_lane_f16(__rev2_902, __p3_902)}); \
+  __ret_902 = __builtin_shufflevector(__ret_902, __ret_902, 3, 2, 1, 0); \
+  __ret_902; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlsl_lane_high_f16(__p0_903, __p1_903, __p2_903, __p3_903) __extension__ ({ \
+  float32x2_t __ret_903; \
+  float32x2_t __s0_903 = __p0_903; \
+  float16x4_t __s1_903 = __p1_903; \
+  float16x4_t __s2_903 = __p2_903; \
+  __ret_903 = vfmlsl_high_f16(__s0_903, __s1_903, (float16x4_t) {vget_lane_f16(__s2_903, __p3_903), vget_lane_f16(__s2_903, __p3_903), vget_lane_f16(__s2_903, __p3_903), vget_lane_f16(__s2_903, __p3_903)}); \
+  __ret_903; \
+})
+#else
+#define vfmlsl_lane_high_f16(__p0_904, __p1_904, __p2_904, __p3_904) __extension__ ({ \
+  float32x2_t __ret_904; \
+  float32x2_t __s0_904 = __p0_904; \
+  float16x4_t __s1_904 = __p1_904; \
+  float16x4_t __s2_904 = __p2_904; \
+  float32x2_t __rev0_904;  __rev0_904 = __builtin_shufflevector(__s0_904, __s0_904, 1, 0); \
+  float16x4_t __rev1_904;  __rev1_904 = __builtin_shufflevector(__s1_904, __s1_904, 3, 2, 1, 0); \
+  float16x4_t __rev2_904;  __rev2_904 = __builtin_shufflevector(__s2_904, __s2_904, 3, 2, 1, 0); \
+  __ret_904 = __noswap_vfmlsl_high_f16(__rev0_904, __rev1_904, (float16x4_t) {__noswap_vget_lane_f16(__rev2_904, __p3_904), __noswap_vget_lane_f16(__rev2_904, __p3_904), __noswap_vget_lane_f16(__rev2_904, __p3_904), __noswap_vget_lane_f16(__rev2_904, __p3_904)}); \
+  __ret_904 = __builtin_shufflevector(__ret_904, __ret_904, 1, 0); \
+  __ret_904; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlslq_lane_low_f16(__p0_905, __p1_905, __p2_905, __p3_905) __extension__ ({ \
+  float32x4_t __ret_905; \
+  float32x4_t __s0_905 = __p0_905; \
+  float16x8_t __s1_905 = __p1_905; \
+  float16x4_t __s2_905 = __p2_905; \
+  __ret_905 = vfmlslq_low_f16(__s0_905, __s1_905, (float16x8_t) {vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905), vget_lane_f16(__s2_905, __p3_905)}); \
+  __ret_905; \
+})
+#else
+#define vfmlslq_lane_low_f16(__p0_906, __p1_906, __p2_906, __p3_906) __extension__ ({ \
+  float32x4_t __ret_906; \
+  float32x4_t __s0_906 = __p0_906; \
+  float16x8_t __s1_906 = __p1_906; \
+  float16x4_t __s2_906 = __p2_906; \
+  float32x4_t __rev0_906;  __rev0_906 = __builtin_shufflevector(__s0_906, __s0_906, 3, 2, 1, 0); \
+  float16x8_t __rev1_906;  __rev1_906 = __builtin_shufflevector(__s1_906, __s1_906, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x4_t __rev2_906;  __rev2_906 = __builtin_shufflevector(__s2_906, __s2_906, 3, 2, 1, 0); \
+  __ret_906 = __noswap_vfmlslq_low_f16(__rev0_906, __rev1_906, (float16x8_t) {__noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906), __noswap_vget_lane_f16(__rev2_906, __p3_906)}); \
+  __ret_906 = __builtin_shufflevector(__ret_906, __ret_906, 3, 2, 1, 0); \
+  __ret_906; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlsl_lane_low_f16(__p0_907, __p1_907, __p2_907, __p3_907) __extension__ ({ \
+  float32x2_t __ret_907; \
+  float32x2_t __s0_907 = __p0_907; \
+  float16x4_t __s1_907 = __p1_907; \
+  float16x4_t __s2_907 = __p2_907; \
+  __ret_907 = vfmlsl_low_f16(__s0_907, __s1_907, (float16x4_t) {vget_lane_f16(__s2_907, __p3_907), vget_lane_f16(__s2_907, __p3_907), vget_lane_f16(__s2_907, __p3_907), vget_lane_f16(__s2_907, __p3_907)}); \
+  __ret_907; \
+})
+#else
+#define vfmlsl_lane_low_f16(__p0_908, __p1_908, __p2_908, __p3_908) __extension__ ({ \
+  float32x2_t __ret_908; \
+  float32x2_t __s0_908 = __p0_908; \
+  float16x4_t __s1_908 = __p1_908; \
+  float16x4_t __s2_908 = __p2_908; \
+  float32x2_t __rev0_908;  __rev0_908 = __builtin_shufflevector(__s0_908, __s0_908, 1, 0); \
+  float16x4_t __rev1_908;  __rev1_908 = __builtin_shufflevector(__s1_908, __s1_908, 3, 2, 1, 0); \
+  float16x4_t __rev2_908;  __rev2_908 = __builtin_shufflevector(__s2_908, __s2_908, 3, 2, 1, 0); \
+  __ret_908 = __noswap_vfmlsl_low_f16(__rev0_908, __rev1_908, (float16x4_t) {__noswap_vget_lane_f16(__rev2_908, __p3_908), __noswap_vget_lane_f16(__rev2_908, __p3_908), __noswap_vget_lane_f16(__rev2_908, __p3_908), __noswap_vget_lane_f16(__rev2_908, __p3_908)}); \
+  __ret_908 = __builtin_shufflevector(__ret_908, __ret_908, 1, 0); \
+  __ret_908; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlslq_laneq_high_f16(__p0_909, __p1_909, __p2_909, __p3_909) __extension__ ({ \
+  float32x4_t __ret_909; \
+  float32x4_t __s0_909 = __p0_909; \
+  float16x8_t __s1_909 = __p1_909; \
+  float16x8_t __s2_909 = __p2_909; \
+  __ret_909 = vfmlslq_high_f16(__s0_909, __s1_909, (float16x8_t) {vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909), vgetq_lane_f16(__s2_909, __p3_909)}); \
+  __ret_909; \
+})
+#else
+#define vfmlslq_laneq_high_f16(__p0_910, __p1_910, __p2_910, __p3_910) __extension__ ({ \
+  float32x4_t __ret_910; \
+  float32x4_t __s0_910 = __p0_910; \
+  float16x8_t __s1_910 = __p1_910; \
+  float16x8_t __s2_910 = __p2_910; \
+  float32x4_t __rev0_910;  __rev0_910 = __builtin_shufflevector(__s0_910, __s0_910, 3, 2, 1, 0); \
+  float16x8_t __rev1_910;  __rev1_910 = __builtin_shufflevector(__s1_910, __s1_910, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev2_910;  __rev2_910 = __builtin_shufflevector(__s2_910, __s2_910, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_910 = __noswap_vfmlslq_high_f16(__rev0_910, __rev1_910, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910), __noswap_vgetq_lane_f16(__rev2_910, __p3_910)}); \
+  __ret_910 = __builtin_shufflevector(__ret_910, __ret_910, 3, 2, 1, 0); \
+  __ret_910; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlsl_laneq_high_f16(__p0_911, __p1_911, __p2_911, __p3_911) __extension__ ({ \
+  float32x2_t __ret_911; \
+  float32x2_t __s0_911 = __p0_911; \
+  float16x4_t __s1_911 = __p1_911; \
+  float16x8_t __s2_911 = __p2_911; \
+  __ret_911 = vfmlsl_high_f16(__s0_911, __s1_911, (float16x4_t) {vgetq_lane_f16(__s2_911, __p3_911), vgetq_lane_f16(__s2_911, __p3_911), vgetq_lane_f16(__s2_911, __p3_911), vgetq_lane_f16(__s2_911, __p3_911)}); \
+  __ret_911; \
+})
+#else
+#define vfmlsl_laneq_high_f16(__p0_912, __p1_912, __p2_912, __p3_912) __extension__ ({ \
+  float32x2_t __ret_912; \
+  float32x2_t __s0_912 = __p0_912; \
+  float16x4_t __s1_912 = __p1_912; \
+  float16x8_t __s2_912 = __p2_912; \
+  float32x2_t __rev0_912;  __rev0_912 = __builtin_shufflevector(__s0_912, __s0_912, 1, 0); \
+  float16x4_t __rev1_912;  __rev1_912 = __builtin_shufflevector(__s1_912, __s1_912, 3, 2, 1, 0); \
+  float16x8_t __rev2_912;  __rev2_912 = __builtin_shufflevector(__s2_912, __s2_912, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_912 = __noswap_vfmlsl_high_f16(__rev0_912, __rev1_912, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_912, __p3_912), __noswap_vgetq_lane_f16(__rev2_912, __p3_912), __noswap_vgetq_lane_f16(__rev2_912, __p3_912), __noswap_vgetq_lane_f16(__rev2_912, __p3_912)}); \
+  __ret_912 = __builtin_shufflevector(__ret_912, __ret_912, 1, 0); \
+  __ret_912; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlslq_laneq_low_f16(__p0_913, __p1_913, __p2_913, __p3_913) __extension__ ({ \
+  float32x4_t __ret_913; \
+  float32x4_t __s0_913 = __p0_913; \
+  float16x8_t __s1_913 = __p1_913; \
+  float16x8_t __s2_913 = __p2_913; \
+  __ret_913 = vfmlslq_low_f16(__s0_913, __s1_913, (float16x8_t) {vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913), vgetq_lane_f16(__s2_913, __p3_913)}); \
+  __ret_913; \
+})
+#else
+#define vfmlslq_laneq_low_f16(__p0_914, __p1_914, __p2_914, __p3_914) __extension__ ({ \
+  float32x4_t __ret_914; \
+  float32x4_t __s0_914 = __p0_914; \
+  float16x8_t __s1_914 = __p1_914; \
+  float16x8_t __s2_914 = __p2_914; \
+  float32x4_t __rev0_914;  __rev0_914 = __builtin_shufflevector(__s0_914, __s0_914, 3, 2, 1, 0); \
+  float16x8_t __rev1_914;  __rev1_914 = __builtin_shufflevector(__s1_914, __s1_914, 7, 6, 5, 4, 3, 2, 1, 0); \
+  float16x8_t __rev2_914;  __rev2_914 = __builtin_shufflevector(__s2_914, __s2_914, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_914 = __noswap_vfmlslq_low_f16(__rev0_914, __rev1_914, (float16x8_t) {__noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914), __noswap_vgetq_lane_f16(__rev2_914, __p3_914)}); \
+  __ret_914 = __builtin_shufflevector(__ret_914, __ret_914, 3, 2, 1, 0); \
+  __ret_914; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vfmlsl_laneq_low_f16(__p0_915, __p1_915, __p2_915, __p3_915) __extension__ ({ \
+  float32x2_t __ret_915; \
+  float32x2_t __s0_915 = __p0_915; \
+  float16x4_t __s1_915 = __p1_915; \
+  float16x8_t __s2_915 = __p2_915; \
+  __ret_915 = vfmlsl_low_f16(__s0_915, __s1_915, (float16x4_t) {vgetq_lane_f16(__s2_915, __p3_915), vgetq_lane_f16(__s2_915, __p3_915), vgetq_lane_f16(__s2_915, __p3_915), vgetq_lane_f16(__s2_915, __p3_915)}); \
+  __ret_915; \
+})
+#else
+#define vfmlsl_laneq_low_f16(__p0_916, __p1_916, __p2_916, __p3_916) __extension__ ({ \
+  float32x2_t __ret_916; \
+  float32x2_t __s0_916 = __p0_916; \
+  float16x4_t __s1_916 = __p1_916; \
+  float16x8_t __s2_916 = __p2_916; \
+  float32x2_t __rev0_916;  __rev0_916 = __builtin_shufflevector(__s0_916, __s0_916, 1, 0); \
+  float16x4_t __rev1_916;  __rev1_916 = __builtin_shufflevector(__s1_916, __s1_916, 3, 2, 1, 0); \
+  float16x8_t __rev2_916;  __rev2_916 = __builtin_shufflevector(__s2_916, __s2_916, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_916 = __noswap_vfmlsl_low_f16(__rev0_916, __rev1_916, (float16x4_t) {__noswap_vgetq_lane_f16(__rev2_916, __p3_916), __noswap_vgetq_lane_f16(__rev2_916, __p3_916), __noswap_vgetq_lane_f16(__rev2_916, __p3_916), __noswap_vgetq_lane_f16(__rev2_916, __p3_916)}); \
+  __ret_916 = __builtin_shufflevector(__ret_916, __ret_916, 1, 0); \
+  __ret_916; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulh_lane_f16(__p0_917, __p1_917, __p2_917) __extension__ ({ \
+  float16_t __ret_917; \
+  float16_t __s0_917 = __p0_917; \
+  float16x4_t __s1_917 = __p1_917; \
+  __ret_917 = __s0_917 * vget_lane_f16(__s1_917, __p2_917); \
+  __ret_917; \
+})
+#else
+#define vmulh_lane_f16(__p0_918, __p1_918, __p2_918) __extension__ ({ \
+  float16_t __ret_918; \
+  float16_t __s0_918 = __p0_918; \
+  float16x4_t __s1_918 = __p1_918; \
+  float16x4_t __rev1_918;  __rev1_918 = __builtin_shufflevector(__s1_918, __s1_918, 3, 2, 1, 0); \
+  __ret_918 = __s0_918 * __noswap_vget_lane_f16(__rev1_918, __p2_918); \
+  __ret_918; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vmulh_laneq_f16(__p0_919, __p1_919, __p2_919) __extension__ ({ \
+  float16_t __ret_919; \
+  float16_t __s0_919 = __p0_919; \
+  float16x8_t __s1_919 = __p1_919; \
+  __ret_919 = __s0_919 * vgetq_lane_f16(__s1_919, __p2_919); \
+  __ret_919; \
+})
+#else
+#define vmulh_laneq_f16(__p0_920, __p1_920, __p2_920) __extension__ ({ \
+  float16_t __ret_920; \
+  float16_t __s0_920 = __p0_920; \
+  float16x8_t __s1_920 = __p1_920; \
+  float16x8_t __rev1_920;  __rev1_920 = __builtin_shufflevector(__s1_920, __s1_920, 7, 6, 5, 4, 3, 2, 1, 0); \
+  __ret_920 = __s0_920 * __noswap_vgetq_lane_f16(__rev1_920, __p2_920); \
+  __ret_920; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vabdl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  __ret = vabdl_u8(vget_high_u8(__p0), vget_high_u8(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vabdl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vabdl_u8(__noswap_vget_high_u8(__rev0), __noswap_vget_high_u8(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vabdl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  __ret = vabdl_u32(vget_high_u32(__p0), vget_high_u32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vabdl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vabdl_u32(__noswap_vget_high_u32(__rev0), __noswap_vget_high_u32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vabdl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  __ret = vabdl_u16(vget_high_u16(__p0), vget_high_u16(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vabdl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vabdl_u16(__noswap_vget_high_u16(__rev0), __noswap_vget_high_u16(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vabdl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  __ret = vabdl_s8(vget_high_s8(__p0), vget_high_s8(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vabdl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vabdl_s8(__noswap_vget_high_s8(__rev0), __noswap_vget_high_s8(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vabdl_high_s32(int32x4_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  __ret = vabdl_s32(vget_high_s32(__p0), vget_high_s32(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vabdl_high_s32(int32x4_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vabdl_s32(__noswap_vget_high_s32(__rev0), __noswap_vget_high_s32(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vabdl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  __ret = vabdl_s16(vget_high_s16(__p0), vget_high_s16(__p1));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vabdl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vabdl_s16(__noswap_vget_high_s16(__rev0), __noswap_vget_high_s16(__rev1));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vaddl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  __ret = vmovl_high_u8(__p0) + vmovl_high_u8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vaddl_high_u8(uint8x16_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  uint8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_u8(__rev0) + __noswap_vmovl_high_u8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vaddl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  __ret = vmovl_high_u32(__p0) + vmovl_high_u32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vaddl_high_u32(uint32x4_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_u32(__rev0) + __noswap_vmovl_high_u32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vaddl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  __ret = vmovl_high_u16(__p0) + vmovl_high_u16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vaddl_high_u16(uint16x8_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_u16(__rev0) + __noswap_vmovl_high_u16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vaddl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  __ret = vmovl_high_s8(__p0) + vmovl_high_s8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vaddl_high_s8(int8x16_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  int8x16_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_s8(__rev0) + __noswap_vmovl_high_s8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vaddl_high_s32(int32x4_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  __ret = vmovl_high_s32(__p0) + vmovl_high_s32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vaddl_high_s32(int32x4_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_s32(__rev0) + __noswap_vmovl_high_s32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vaddl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  __ret = vmovl_high_s16(__p0) + vmovl_high_s16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vaddl_high_s16(int16x8_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmovl_high_s16(__rev0) + __noswap_vmovl_high_s16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vaddw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  __ret = __p0 + vmovl_high_u8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vaddw_high_u8(uint16x8_t __p0, uint8x16_t __p1) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_high_u8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vaddw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  __ret = __p0 + vmovl_high_u32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vaddw_high_u32(uint64x2_t __p0, uint32x4_t __p1) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_high_u32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vaddw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  __ret = __p0 + vmovl_high_u16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vaddw_high_u16(uint32x4_t __p0, uint16x8_t __p1) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_high_u16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vaddw_high_s8(int16x8_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  __ret = __p0 + vmovl_high_s8(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vaddw_high_s8(int16x8_t __p0, int8x16_t __p1) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_high_s8(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vaddw_high_s32(int64x2_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  __ret = __p0 + vmovl_high_s32(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vaddw_high_s32(int64x2_t __p0, int32x4_t __p1) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_high_s32(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vaddw_high_s16(int32x4_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  __ret = __p0 + vmovl_high_s16(__p1);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vaddw_high_s16(int32x4_t __p0, int16x8_t __p1) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vmovl_high_s16(__rev1);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_p64(__p0_921, __p1_921, __p2_921, __p3_921) __extension__ ({ \
+  poly64x2_t __ret_921; \
+  poly64x2_t __s0_921 = __p0_921; \
+  poly64x1_t __s2_921 = __p2_921; \
+  __ret_921 = vsetq_lane_p64(vget_lane_p64(__s2_921, __p3_921), __s0_921, __p1_921); \
+  __ret_921; \
+})
+#else
+#define vcopyq_lane_p64(__p0_922, __p1_922, __p2_922, __p3_922) __extension__ ({ \
+  poly64x2_t __ret_922; \
+  poly64x2_t __s0_922 = __p0_922; \
+  poly64x1_t __s2_922 = __p2_922; \
+  poly64x2_t __rev0_922;  __rev0_922 = __builtin_shufflevector(__s0_922, __s0_922, 1, 0); \
+  __ret_922 = __noswap_vsetq_lane_p64(vget_lane_p64(__s2_922, __p3_922), __rev0_922, __p1_922); \
+  __ret_922 = __builtin_shufflevector(__ret_922, __ret_922, 1, 0); \
+  __ret_922; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_lane_f64(__p0_923, __p1_923, __p2_923, __p3_923) __extension__ ({ \
+  float64x2_t __ret_923; \
+  float64x2_t __s0_923 = __p0_923; \
+  float64x1_t __s2_923 = __p2_923; \
+  __ret_923 = vsetq_lane_f64(vget_lane_f64(__s2_923, __p3_923), __s0_923, __p1_923); \
+  __ret_923; \
+})
+#else
+#define vcopyq_lane_f64(__p0_924, __p1_924, __p2_924, __p3_924) __extension__ ({ \
+  float64x2_t __ret_924; \
+  float64x2_t __s0_924 = __p0_924; \
+  float64x1_t __s2_924 = __p2_924; \
+  float64x2_t __rev0_924;  __rev0_924 = __builtin_shufflevector(__s0_924, __s0_924, 1, 0); \
+  __ret_924 = __noswap_vsetq_lane_f64(vget_lane_f64(__s2_924, __p3_924), __rev0_924, __p1_924); \
+  __ret_924 = __builtin_shufflevector(__ret_924, __ret_924, 1, 0); \
+  __ret_924; \
+})
+#endif
+
+#define vcopy_lane_p64(__p0_925, __p1_925, __p2_925, __p3_925) __extension__ ({ \
+  poly64x1_t __ret_925; \
+  poly64x1_t __s0_925 = __p0_925; \
+  poly64x1_t __s2_925 = __p2_925; \
+  __ret_925 = vset_lane_p64(vget_lane_p64(__s2_925, __p3_925), __s0_925, __p1_925); \
+  __ret_925; \
+})
+#define vcopy_lane_f64(__p0_926, __p1_926, __p2_926, __p3_926) __extension__ ({ \
+  float64x1_t __ret_926; \
+  float64x1_t __s0_926 = __p0_926; \
+  float64x1_t __s2_926 = __p2_926; \
+  __ret_926 = vset_lane_f64(vget_lane_f64(__s2_926, __p3_926), __s0_926, __p1_926); \
+  __ret_926; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_p64(__p0_927, __p1_927, __p2_927, __p3_927) __extension__ ({ \
+  poly64x2_t __ret_927; \
+  poly64x2_t __s0_927 = __p0_927; \
+  poly64x2_t __s2_927 = __p2_927; \
+  __ret_927 = vsetq_lane_p64(vgetq_lane_p64(__s2_927, __p3_927), __s0_927, __p1_927); \
+  __ret_927; \
+})
+#else
+#define vcopyq_laneq_p64(__p0_928, __p1_928, __p2_928, __p3_928) __extension__ ({ \
+  poly64x2_t __ret_928; \
+  poly64x2_t __s0_928 = __p0_928; \
+  poly64x2_t __s2_928 = __p2_928; \
+  poly64x2_t __rev0_928;  __rev0_928 = __builtin_shufflevector(__s0_928, __s0_928, 1, 0); \
+  poly64x2_t __rev2_928;  __rev2_928 = __builtin_shufflevector(__s2_928, __s2_928, 1, 0); \
+  __ret_928 = __noswap_vsetq_lane_p64(__noswap_vgetq_lane_p64(__rev2_928, __p3_928), __rev0_928, __p1_928); \
+  __ret_928 = __builtin_shufflevector(__ret_928, __ret_928, 1, 0); \
+  __ret_928; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopyq_laneq_f64(__p0_929, __p1_929, __p2_929, __p3_929) __extension__ ({ \
+  float64x2_t __ret_929; \
+  float64x2_t __s0_929 = __p0_929; \
+  float64x2_t __s2_929 = __p2_929; \
+  __ret_929 = vsetq_lane_f64(vgetq_lane_f64(__s2_929, __p3_929), __s0_929, __p1_929); \
+  __ret_929; \
+})
+#else
+#define vcopyq_laneq_f64(__p0_930, __p1_930, __p2_930, __p3_930) __extension__ ({ \
+  float64x2_t __ret_930; \
+  float64x2_t __s0_930 = __p0_930; \
+  float64x2_t __s2_930 = __p2_930; \
+  float64x2_t __rev0_930;  __rev0_930 = __builtin_shufflevector(__s0_930, __s0_930, 1, 0); \
+  float64x2_t __rev2_930;  __rev2_930 = __builtin_shufflevector(__s2_930, __s2_930, 1, 0); \
+  __ret_930 = __noswap_vsetq_lane_f64(__noswap_vgetq_lane_f64(__rev2_930, __p3_930), __rev0_930, __p1_930); \
+  __ret_930 = __builtin_shufflevector(__ret_930, __ret_930, 1, 0); \
+  __ret_930; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_p64(__p0_931, __p1_931, __p2_931, __p3_931) __extension__ ({ \
+  poly64x1_t __ret_931; \
+  poly64x1_t __s0_931 = __p0_931; \
+  poly64x2_t __s2_931 = __p2_931; \
+  __ret_931 = vset_lane_p64(vgetq_lane_p64(__s2_931, __p3_931), __s0_931, __p1_931); \
+  __ret_931; \
+})
+#else
+#define vcopy_laneq_p64(__p0_932, __p1_932, __p2_932, __p3_932) __extension__ ({ \
+  poly64x1_t __ret_932; \
+  poly64x1_t __s0_932 = __p0_932; \
+  poly64x2_t __s2_932 = __p2_932; \
+  poly64x2_t __rev2_932;  __rev2_932 = __builtin_shufflevector(__s2_932, __s2_932, 1, 0); \
+  __ret_932 = vset_lane_p64(__noswap_vgetq_lane_p64(__rev2_932, __p3_932), __s0_932, __p1_932); \
+  __ret_932; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+#define vcopy_laneq_f64(__p0_933, __p1_933, __p2_933, __p3_933) __extension__ ({ \
+  float64x1_t __ret_933; \
+  float64x1_t __s0_933 = __p0_933; \
+  float64x2_t __s2_933 = __p2_933; \
+  __ret_933 = vset_lane_f64(vgetq_lane_f64(__s2_933, __p3_933), __s0_933, __p1_933); \
+  __ret_933; \
+})
+#else
+#define vcopy_laneq_f64(__p0_934, __p1_934, __p2_934, __p3_934) __extension__ ({ \
+  float64x1_t __ret_934; \
+  float64x1_t __s0_934 = __p0_934; \
+  float64x2_t __s2_934 = __p2_934; \
+  float64x2_t __rev2_934;  __rev2_934 = __builtin_shufflevector(__s2_934, __s2_934, 1, 0); \
+  __ret_934 = vset_lane_f64(__noswap_vgetq_lane_f64(__rev2_934, __p3_934), __s0_934, __p1_934); \
+  __ret_934; \
+})
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmlal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint16x8_t __ret;
+  __ret = vmlal_u8(__p0, vget_high_u8(__p1), vget_high_u8(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmlal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlal_u8(__rev0, __noswap_vget_high_u8(__rev1), __noswap_vget_high_u8(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint64x2_t __ret;
+  __ret = vmlal_u32(__p0, vget_high_u32(__p1), vget_high_u32(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vmlal_u32(__rev0, __noswap_vget_high_u32(__rev1), __noswap_vget_high_u32(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint32x4_t __ret;
+  __ret = vmlal_u16(__p0, vget_high_u16(__p1), vget_high_u16(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlal_u16(__rev0, __noswap_vget_high_u16(__rev1), __noswap_vget_high_u16(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmlal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int16x8_t __ret;
+  __ret = vmlal_s8(__p0, vget_high_s8(__p1), vget_high_s8(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmlal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlal_s8(__rev0, __noswap_vget_high_s8(__rev1), __noswap_vget_high_s8(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int64x2_t __ret;
+  __ret = vmlal_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmlal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vmlal_s32(__rev0, __noswap_vget_high_s32(__rev1), __noswap_vget_high_s32(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int32x4_t __ret;
+  __ret = vmlal_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlal_s16(__rev0, __noswap_vget_high_s16(__rev1), __noswap_vget_high_s16(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
+  uint64x2_t __ret;
+  __ret = vmlal_n_u32(__p0, vget_high_u32(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmlal_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmlal_n_u32(__rev0, __noswap_vget_high_u32(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
+  uint32x4_t __ret;
+  __ret = vmlal_n_u16(__p0, vget_high_u16(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlal_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlal_n_u16(__rev0, __noswap_vget_high_u16(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = vmlal_n_s32(__p0, vget_high_s32(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmlal_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmlal_n_s32(__rev0, __noswap_vget_high_s32(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = vmlal_n_s16(__p0, vget_high_s16(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlal_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlal_n_s16(__rev0, __noswap_vget_high_s16(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vmlsl_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint16x8_t __ret;
+  __ret = vmlsl_u8(__p0, vget_high_u8(__p1), vget_high_u8(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vmlsl_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlsl_u8(__rev0, __noswap_vget_high_u8(__rev1), __noswap_vget_high_u8(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint64x2_t __ret;
+  __ret = vmlsl_u32(__p0, vget_high_u32(__p1), vget_high_u32(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vmlsl_u32(__rev0, __noswap_vget_high_u32(__rev1), __noswap_vget_high_u32(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint32x4_t __ret;
+  __ret = vmlsl_u16(__p0, vget_high_u16(__p1), vget_high_u16(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlsl_u16(__rev0, __noswap_vget_high_u16(__rev1), __noswap_vget_high_u16(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vmlsl_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int16x8_t __ret;
+  __ret = vmlsl_s8(__p0, vget_high_s8(__p1), vget_high_s8(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vmlsl_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlsl_s8(__rev0, __noswap_vget_high_s8(__rev1), __noswap_vget_high_s8(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int64x2_t __ret;
+  __ret = vmlsl_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vmlsl_s32(__rev0, __noswap_vget_high_s32(__rev1), __noswap_vget_high_s32(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int32x4_t __ret;
+  __ret = vmlsl_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlsl_s16(__rev0, __noswap_vget_high_s16(__rev1), __noswap_vget_high_s16(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
+  uint64x2_t __ret;
+  __ret = vmlsl_n_u32(__p0, vget_high_u32(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vmlsl_high_n_u32(uint64x2_t __p0, uint32x4_t __p1, uint32_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmlsl_n_u32(__rev0, __noswap_vget_high_u32(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
+  uint32x4_t __ret;
+  __ret = vmlsl_n_u16(__p0, vget_high_u16(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vmlsl_high_n_u16(uint32x4_t __p0, uint16x8_t __p1, uint16_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlsl_n_u16(__rev0, __noswap_vget_high_u16(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  __ret = vmlsl_n_s32(__p0, vget_high_s32(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vmlsl_high_n_s32(int64x2_t __p0, int32x4_t __p1, int32_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  __ret = __noswap_vmlsl_n_s32(__rev0, __noswap_vget_high_s32(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  __ret = vmlsl_n_s16(__p0, vget_high_s16(__p1), __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vmlsl_high_n_s16(int32x4_t __p0, int16x8_t __p1, int16_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vmlsl_n_s16(__rev0, __noswap_vget_high_s16(__rev1), __p2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#define vmulx_lane_f64(__p0_935, __p1_935, __p2_935) __extension__ ({ \
+  float64x1_t __ret_935; \
+  float64x1_t __s0_935 = __p0_935; \
+  float64x1_t __s1_935 = __p1_935; \
+  float64_t __x_935 = vget_lane_f64(__s0_935, 0); \
+  float64_t __y_935 = vget_lane_f64(__s1_935, __p2_935); \
+  float64_t __z_935 = vmulxd_f64(__x_935, __y_935); \
+  __ret_935 = vset_lane_f64(__z_935, __s0_935, __p2_935); \
+  __ret_935; \
+})
+#ifdef __LITTLE_ENDIAN__
+#define vmulx_laneq_f64(__p0_936, __p1_936, __p2_936) __extension__ ({ \
+  float64x1_t __ret_936; \
+  float64x1_t __s0_936 = __p0_936; \
+  float64x2_t __s1_936 = __p1_936; \
+  float64_t __x_936 = vget_lane_f64(__s0_936, 0); \
+  float64_t __y_936 = vgetq_lane_f64(__s1_936, __p2_936); \
+  float64_t __z_936 = vmulxd_f64(__x_936, __y_936); \
+  __ret_936 = vset_lane_f64(__z_936, __s0_936, 0); \
+  __ret_936; \
+})
+#else
+#define vmulx_laneq_f64(__p0_937, __p1_937, __p2_937) __extension__ ({ \
+  float64x1_t __ret_937; \
+  float64x1_t __s0_937 = __p0_937; \
+  float64x2_t __s1_937 = __p1_937; \
+  float64x2_t __rev1_937;  __rev1_937 = __builtin_shufflevector(__s1_937, __s1_937, 1, 0); \
+  float64_t __x_937 = vget_lane_f64(__s0_937, 0); \
+  float64_t __y_937 = __noswap_vgetq_lane_f64(__rev1_937, __p2_937); \
+  float64_t __z_937 = vmulxd_f64(__x_937, __y_937); \
+  __ret_937 = vset_lane_f64(__z_937, __s0_937, 0); \
+  __ret_937; \
+})
+#endif
+
+#endif
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 + vabdl_u8(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabdl_u8(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint16x8_t __noswap_vabal_u8(uint16x8_t __p0, uint8x8_t __p1, uint8x8_t __p2) {
+  uint16x8_t __ret;
+  __ret = __p0 + __noswap_vabdl_u8(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = __p0 + vabdl_u32(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  uint32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 + __noswap_vabdl_u32(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint64x2_t __noswap_vabal_u32(uint64x2_t __p0, uint32x2_t __p1, uint32x2_t __p2) {
+  uint64x2_t __ret;
+  __ret = __p0 + __noswap_vabdl_u32(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 + vabdl_u16(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabdl_u16(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) uint32x4_t __noswap_vabal_u16(uint32x4_t __p0, uint16x4_t __p1, uint16x4_t __p2) {
+  uint32x4_t __ret;
+  __ret = __p0 + __noswap_vabdl_u16(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 + vabdl_s8(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabdl_s8(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int16x8_t __noswap_vabal_s8(int16x8_t __p0, int8x8_t __p1, int8x8_t __p2) {
+  int16x8_t __ret;
+  __ret = __p0 + __noswap_vabdl_s8(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  __ret = __p0 + vabdl_s32(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x2_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 1, 0);
+  int32x2_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 1, 0);
+  __ret = __rev0 + __noswap_vabdl_s32(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int64x2_t __noswap_vabal_s32(int64x2_t __p0, int32x2_t __p1, int32x2_t __p2) {
+  int64x2_t __ret;
+  __ret = __p0 + __noswap_vabdl_s32(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vabal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 + vabdl_s16(__p1, __p2);
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vabal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int16x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __rev0 + __noswap_vabdl_s16(__rev1, __rev2);
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+__ai __attribute__((target("neon"))) int32x4_t __noswap_vabal_s16(int32x4_t __p0, int16x4_t __p1, int16x4_t __p2) {
+  int32x4_t __ret;
+  __ret = __p0 + __noswap_vabdl_s16(__p1, __p2);
+  return __ret;
+}
+#endif
+
+#if defined(__aarch64__) || defined(__arm64ec__)
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint16x8_t vabal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint16x8_t __ret;
+  __ret = vabal_u8(__p0, vget_high_u8(__p1), vget_high_u8(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint16x8_t vabal_high_u8(uint16x8_t __p0, uint8x16_t __p1, uint8x16_t __p2) {
+  uint16x8_t __ret;
+  uint16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vabal_u8(__rev0, __noswap_vget_high_u8(__rev1), __noswap_vget_high_u8(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint64x2_t vabal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint64x2_t __ret;
+  __ret = vabal_u32(__p0, vget_high_u32(__p1), vget_high_u32(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint64x2_t vabal_high_u32(uint64x2_t __p0, uint32x4_t __p1, uint32x4_t __p2) {
+  uint64x2_t __ret;
+  uint64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  uint32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  uint32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vabal_u32(__rev0, __noswap_vget_high_u32(__rev1), __noswap_vget_high_u32(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) uint32x4_t vabal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint32x4_t __ret;
+  __ret = vabal_u16(__p0, vget_high_u16(__p1), vget_high_u16(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) uint32x4_t vabal_high_u16(uint32x4_t __p0, uint16x8_t __p1, uint16x8_t __p2) {
+  uint32x4_t __ret;
+  uint32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  uint16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  uint16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vabal_u16(__rev0, __noswap_vget_high_u16(__rev1), __noswap_vget_high_u16(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int16x8_t vabal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int16x8_t __ret;
+  __ret = vabal_s8(__p0, vget_high_s8(__p1), vget_high_s8(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int16x8_t vabal_high_s8(int16x8_t __p0, int8x16_t __p1, int8x16_t __p2) {
+  int16x8_t __ret;
+  int16x8_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  int8x16_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vabal_s8(__rev0, __noswap_vget_high_s8(__rev1), __noswap_vget_high_s8(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 7, 6, 5, 4, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int64x2_t vabal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int64x2_t __ret;
+  __ret = vabal_s32(__p0, vget_high_s32(__p1), vget_high_s32(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int64x2_t vabal_high_s32(int64x2_t __p0, int32x4_t __p1, int32x4_t __p2) {
+  int64x2_t __ret;
+  int64x2_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 1, 0);
+  int32x4_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 3, 2, 1, 0);
+  int32x4_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 3, 2, 1, 0);
+  __ret = __noswap_vabal_s32(__rev0, __noswap_vget_high_s32(__rev1), __noswap_vget_high_s32(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 1, 0);
+  return __ret;
+}
+#endif
+
+#ifdef __LITTLE_ENDIAN__
+__ai __attribute__((target("neon"))) int32x4_t vabal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int32x4_t __ret;
+  __ret = vabal_s16(__p0, vget_high_s16(__p1), vget_high_s16(__p2));
+  return __ret;
+}
+#else
+__ai __attribute__((target("neon"))) int32x4_t vabal_high_s16(int32x4_t __p0, int16x8_t __p1, int16x8_t __p2) {
+  int32x4_t __ret;
+  int32x4_t __rev0;  __rev0 = __builtin_shufflevector(__p0, __p0, 3, 2, 1, 0);
+  int16x8_t __rev1;  __rev1 = __builtin_shufflevector(__p1, __p1, 7, 6, 5, 4, 3, 2, 1, 0);
+  int16x8_t __rev2;  __rev2 = __builtin_shufflevector(__p2, __p2, 7, 6, 5, 4, 3, 2, 1, 0);
+  __ret = __noswap_vabal_s16(__rev0, __noswap_vget_high_s16(__rev1), __noswap_vget_high_s16(__rev2));
+  __ret = __builtin_shufflevector(__ret, __ret, 3, 2, 1, 0);
+  return __ret;
+}
+#endif
+
+#endif
+
+#undef __ai
+
+#endif /* if !defined(__ARM_NEON) */
+#endif /* ifndef __ARM_FP */
diff --git a/third_party/aarch64/clang/arm_neon_sve_bridge.h b/third_party/aarch64/clang/arm_neon_sve_bridge.h
new file mode 100644
index 000000000..a9fbdbaf4
--- /dev/null
+++ b/third_party/aarch64/clang/arm_neon_sve_bridge.h
@@ -0,0 +1,182 @@
+/*===---- arm_neon_sve_bridge.h - ARM NEON SVE Bridge intrinsics -----------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ARM_NEON_SVE_BRIDGE_H
+#define __ARM_NEON_SVE_BRIDGE_H
+
+#include <arm_neon.h>
+#include <arm_sve.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Function attributes */
+#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
+#define __aio                                                                  \
+  static __inline__                                                            \
+      __attribute__((__always_inline__, __nodebug__, __overloadable__))
+
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s8)))
+svint8_t svset_neonq(svint8_t, int8x16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s16)))
+svint16_t svset_neonq(svint16_t, int16x8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s32)))
+svint32_t svset_neonq(svint32_t, int32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s64)))
+svint64_t svset_neonq(svint64_t, int64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u8)))
+svuint8_t svset_neonq(svuint8_t, uint8x16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u16)))
+svuint16_t svset_neonq(svuint16_t, uint16x8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u32)))
+svuint32_t svset_neonq(svuint32_t, uint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u64)))
+svuint64_t svset_neonq(svuint64_t, uint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f16)))
+svfloat16_t svset_neonq(svfloat16_t, float16x8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f32)))
+svfloat32_t svset_neonq(svfloat32_t, float32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f64)))
+svfloat64_t svset_neonq(svfloat64_t, float64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s8)))
+svint8_t svset_neonq_s8(svint8_t, int8x16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s16)))
+svint16_t svset_neonq_s16(svint16_t, int16x8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s32)))
+svint32_t svset_neonq_s32(svint32_t, int32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_s64)))
+svint64_t svset_neonq_s64(svint64_t, int64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u8)))
+svuint8_t svset_neonq_u8(svuint8_t, uint8x16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u16)))
+svuint16_t svset_neonq_u16(svuint16_t, uint16x8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u32)))
+svuint32_t svset_neonq_u32(svuint32_t, uint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_u64)))
+svuint64_t svset_neonq_u64(svuint64_t, uint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f16)))
+svfloat16_t svset_neonq_f16(svfloat16_t, float16x8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f32)))
+svfloat32_t svset_neonq_f32(svfloat32_t, float32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_f64)))
+svfloat64_t svset_neonq_f64(svfloat64_t, float64x2_t);
+
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s8)))
+int8x16_t svget_neonq(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s16)))
+int16x8_t svget_neonq(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s32)))
+int32x4_t svget_neonq(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s64)))
+int64x2_t svget_neonq(svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u8)))
+uint8x16_t svget_neonq(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u16)))
+uint16x8_t svget_neonq(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u32)))
+uint32x4_t svget_neonq(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u64)))
+uint64x2_t svget_neonq(svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f16)))
+float16x8_t svget_neonq(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f32)))
+float32x4_t svget_neonq(svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f64)))
+float64x2_t svget_neonq(svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s8)))
+int8x16_t svget_neonq_s8(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s16)))
+int16x8_t svget_neonq_s16(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s32)))
+int32x4_t svget_neonq_s32(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_s64)))
+int64x2_t svget_neonq_s64(svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u8)))
+uint8x16_t svget_neonq_u8(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u16)))
+uint16x8_t svget_neonq_u16(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u32)))
+uint32x4_t svget_neonq_u32(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_u64)))
+uint64x2_t svget_neonq_u64(svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f16)))
+float16x8_t svget_neonq_f16(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f32)))
+float32x4_t svget_neonq_f32(svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_f64)))
+float64x2_t svget_neonq_f64(svfloat64_t);
+
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s8)))
+svint8_t svdup_neonq(int8x16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s16)))
+svint16_t svdup_neonq(int16x8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s32)))
+svint32_t svdup_neonq(int32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s64)))
+svint64_t svdup_neonq(int64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u8)))
+svuint8_t svdup_neonq(uint8x16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u16)))
+svuint16_t svdup_neonq(uint16x8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u32)))
+svuint32_t svdup_neonq(uint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u64)))
+svuint64_t svdup_neonq(uint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f16)))
+svfloat16_t svdup_neonq(float16x8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f32)))
+svfloat32_t svdup_neonq(float32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f64)))
+svfloat64_t svdup_neonq(float64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s8)))
+svint8_t svdup_neonq_s8(int8x16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s16)))
+svint16_t svdup_neonq_s16(int16x8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s32)))
+svint32_t svdup_neonq_s32(int32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_s64)))
+svint64_t svdup_neonq_s64(int64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u8)))
+svuint8_t svdup_neonq_u8(uint8x16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u16)))
+svuint16_t svdup_neonq_u16(uint16x8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u32)))
+svuint32_t svdup_neonq_u32(uint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_u64)))
+svuint64_t svdup_neonq_u64(uint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f16)))
+svfloat16_t svdup_neonq_f16(float16x8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f32)))
+svfloat32_t svdup_neonq_f32(float32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_f64)))
+svfloat64_t svdup_neonq_f64(float64x2_t);
+
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_bf16)))
+svbfloat16_t svset_neonq(svbfloat16_t, bfloat16x8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset_neonq_bf16)))
+svbfloat16_t svset_neonq_bf16(svbfloat16_t, bfloat16x8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_bf16)))
+bfloat16x8_t svget_neonq(svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget_neonq_bf16)))
+bfloat16x8_t svget_neonq_bf16(svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_bf16)))
+svbfloat16_t svdup_neonq(bfloat16x8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_neonq_bf16)))
+svbfloat16_t svdup_neonq_bf16(bfloat16x8_t);
+
+#undef __ai
+#undef __aio
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif //__ARM_NEON_SVE_BRIDGE_H
diff --git a/third_party/aarch64/clang/arm_sme.h b/third_party/aarch64/clang/arm_sme.h
new file mode 100644
index 000000000..cbfea38fe
--- /dev/null
+++ b/third_party/aarch64/clang/arm_sme.h
@@ -0,0 +1,2819 @@
+/*===---- arm_sme.h - ARM SME intrinsics ------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ARM_SME_H
+#define __ARM_SME_H
+
+#if !defined(__LITTLE_ENDIAN__)
+#error "Big endian is currently not supported for arm_sme.h"
+#endif
+#include <arm_sve.h>
+
+#include <stddef.h>
+
+/* Function attributes */
+#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
+
+#define __aio static __inline__ __attribute__((__always_inline__, __nodebug__, __overloadable__))
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+void __arm_za_disable(void) __arm_streaming_compatible;
+
+__ai bool __arm_has_sme(void) __arm_streaming_compatible {
+  uint64_t x0, x1;
+  __builtin_arm_get_sme_state(&x0, &x1);
+  return x0 & (1ULL << 63);
+}
+
+__ai bool __arm_in_streaming_mode(void) __arm_streaming_compatible {
+  uint64_t x0, x1;
+  __builtin_arm_get_sme_state(&x0, &x1);
+  return x0 & 1;
+}
+
+void *__arm_sc_memcpy(void *dest, const void *src, size_t n) __arm_streaming_compatible;
+void *__arm_sc_memmove(void *dest, const void *src, size_t n) __arm_streaming_compatible;
+void *__arm_sc_memset(void *s, int c, size_t n) __arm_streaming_compatible;
+void *__arm_sc_memchr(void *s, int c, size_t n) __arm_streaming_compatible;
+
+__ai __attribute__((target("sme"))) void svundef_za(void) __arm_streaming_compatible __arm_out("za") { }
+
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za32_u32_m)))
+void svaddha_za32_u32_m(uint64_t, svbool_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za32_s32_m)))
+void svaddha_za32_s32_m(uint64_t, svbool_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddva_za32_u32_m)))
+void svaddva_za32_u32_m(uint64_t, svbool_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddva_za32_s32_m)))
+void svaddva_za32_s32_m(uint64_t, svbool_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svcntsb)))
+uint64_t svcntsb(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svcntsd)))
+uint64_t svcntsd(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svcntsh)))
+uint64_t svcntsh(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svcntsw)))
+uint64_t svcntsw(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_hor_vnum_za128)))
+void svld1_hor_vnum_za128(uint64_t, uint32_t, svbool_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_hor_vnum_za16)))
+void svld1_hor_vnum_za16(uint64_t, uint32_t, svbool_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_hor_vnum_za32)))
+void svld1_hor_vnum_za32(uint64_t, uint32_t, svbool_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_hor_vnum_za64)))
+void svld1_hor_vnum_za64(uint64_t, uint32_t, svbool_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_hor_vnum_za8)))
+void svld1_hor_vnum_za8(uint64_t, uint32_t, svbool_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_hor_za128)))
+void svld1_hor_za128(uint64_t, uint32_t, svbool_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_hor_za16)))
+void svld1_hor_za16(uint64_t, uint32_t, svbool_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_hor_za32)))
+void svld1_hor_za32(uint64_t, uint32_t, svbool_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_hor_za64)))
+void svld1_hor_za64(uint64_t, uint32_t, svbool_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_hor_za8)))
+void svld1_hor_za8(uint64_t, uint32_t, svbool_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_ver_vnum_za128)))
+void svld1_ver_vnum_za128(uint64_t, uint32_t, svbool_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_ver_vnum_za16)))
+void svld1_ver_vnum_za16(uint64_t, uint32_t, svbool_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_ver_vnum_za32)))
+void svld1_ver_vnum_za32(uint64_t, uint32_t, svbool_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_ver_vnum_za64)))
+void svld1_ver_vnum_za64(uint64_t, uint32_t, svbool_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_ver_vnum_za8)))
+void svld1_ver_vnum_za8(uint64_t, uint32_t, svbool_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_ver_za128)))
+void svld1_ver_za128(uint64_t, uint32_t, svbool_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_ver_za16)))
+void svld1_ver_za16(uint64_t, uint32_t, svbool_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_ver_za32)))
+void svld1_ver_za32(uint64_t, uint32_t, svbool_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_ver_za64)))
+void svld1_ver_za64(uint64_t, uint32_t, svbool_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svld1_ver_za8)))
+void svld1_ver_za8(uint64_t, uint32_t, svbool_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svldr_vnum_za)))
+void svldr_vnum_za(uint32_t, void const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svldr_za)))
+void svldr_za(uint32_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_f16_m)))
+void svmopa_za32_f16_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_bf16_m)))
+void svmopa_za32_bf16_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_f32_m)))
+void svmopa_za32_f32_m(uint64_t, svbool_t, svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_s8_m)))
+void svmopa_za32_s8_m(uint64_t, svbool_t, svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_u8_m)))
+void svmopa_za32_u8_m(uint64_t, svbool_t, svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_f16_m)))
+void svmops_za32_f16_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_bf16_m)))
+void svmops_za32_bf16_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_f32_m)))
+void svmops_za32_f32_m(uint64_t, svbool_t, svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_s8_m)))
+void svmops_za32_s8_m(uint64_t, svbool_t, svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_u8_m)))
+void svmops_za32_u8_m(uint64_t, svbool_t, svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_u8_m)))
+svuint8_t svread_hor_za128_u8_m(svuint8_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_u32_m)))
+svuint32_t svread_hor_za128_u32_m(svuint32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_u64_m)))
+svuint64_t svread_hor_za128_u64_m(svuint64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_u16_m)))
+svuint16_t svread_hor_za128_u16_m(svuint16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_bf16_m)))
+svbfloat16_t svread_hor_za128_bf16_m(svbfloat16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_s8_m)))
+svint8_t svread_hor_za128_s8_m(svint8_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_f64_m)))
+svfloat64_t svread_hor_za128_f64_m(svfloat64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_f32_m)))
+svfloat32_t svread_hor_za128_f32_m(svfloat32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_f16_m)))
+svfloat16_t svread_hor_za128_f16_m(svfloat16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_s32_m)))
+svint32_t svread_hor_za128_s32_m(svint32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_s64_m)))
+svint64_t svread_hor_za128_s64_m(svint64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_s16_m)))
+svint16_t svread_hor_za128_s16_m(svint16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_u16_m)))
+svuint16_t svread_hor_za16_u16_m(svuint16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_bf16_m)))
+svbfloat16_t svread_hor_za16_bf16_m(svbfloat16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_f16_m)))
+svfloat16_t svread_hor_za16_f16_m(svfloat16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_s16_m)))
+svint16_t svread_hor_za16_s16_m(svint16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_u32_m)))
+svuint32_t svread_hor_za32_u32_m(svuint32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_f32_m)))
+svfloat32_t svread_hor_za32_f32_m(svfloat32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_s32_m)))
+svint32_t svread_hor_za32_s32_m(svint32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_u64_m)))
+svuint64_t svread_hor_za64_u64_m(svuint64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_f64_m)))
+svfloat64_t svread_hor_za64_f64_m(svfloat64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_s64_m)))
+svint64_t svread_hor_za64_s64_m(svint64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za8_u8_m)))
+svuint8_t svread_hor_za8_u8_m(svuint8_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za8_s8_m)))
+svint8_t svread_hor_za8_s8_m(svint8_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_u8_m)))
+svuint8_t svread_ver_za128_u8_m(svuint8_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_u32_m)))
+svuint32_t svread_ver_za128_u32_m(svuint32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_u64_m)))
+svuint64_t svread_ver_za128_u64_m(svuint64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_u16_m)))
+svuint16_t svread_ver_za128_u16_m(svuint16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_bf16_m)))
+svbfloat16_t svread_ver_za128_bf16_m(svbfloat16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_s8_m)))
+svint8_t svread_ver_za128_s8_m(svint8_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_f64_m)))
+svfloat64_t svread_ver_za128_f64_m(svfloat64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_f32_m)))
+svfloat32_t svread_ver_za128_f32_m(svfloat32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_f16_m)))
+svfloat16_t svread_ver_za128_f16_m(svfloat16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_s32_m)))
+svint32_t svread_ver_za128_s32_m(svint32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_s64_m)))
+svint64_t svread_ver_za128_s64_m(svint64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_s16_m)))
+svint16_t svread_ver_za128_s16_m(svint16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_u16_m)))
+svuint16_t svread_ver_za16_u16_m(svuint16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_bf16_m)))
+svbfloat16_t svread_ver_za16_bf16_m(svbfloat16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_f16_m)))
+svfloat16_t svread_ver_za16_f16_m(svfloat16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_s16_m)))
+svint16_t svread_ver_za16_s16_m(svint16_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_u32_m)))
+svuint32_t svread_ver_za32_u32_m(svuint32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_f32_m)))
+svfloat32_t svread_ver_za32_f32_m(svfloat32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_s32_m)))
+svint32_t svread_ver_za32_s32_m(svint32_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_u64_m)))
+svuint64_t svread_ver_za64_u64_m(svuint64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_f64_m)))
+svfloat64_t svread_ver_za64_f64_m(svfloat64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_s64_m)))
+svint64_t svread_ver_za64_s64_m(svint64_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za8_u8_m)))
+svuint8_t svread_ver_za8_u8_m(svuint8_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za8_s8_m)))
+svint8_t svread_ver_za8_s8_m(svint8_t, svbool_t, uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_hor_vnum_za128)))
+void svst1_hor_vnum_za128(uint64_t, uint32_t, svbool_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_hor_vnum_za16)))
+void svst1_hor_vnum_za16(uint64_t, uint32_t, svbool_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_hor_vnum_za32)))
+void svst1_hor_vnum_za32(uint64_t, uint32_t, svbool_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_hor_vnum_za64)))
+void svst1_hor_vnum_za64(uint64_t, uint32_t, svbool_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_hor_vnum_za8)))
+void svst1_hor_vnum_za8(uint64_t, uint32_t, svbool_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_hor_za128)))
+void svst1_hor_za128(uint64_t, uint32_t, svbool_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_hor_za16)))
+void svst1_hor_za16(uint64_t, uint32_t, svbool_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_hor_za32)))
+void svst1_hor_za32(uint64_t, uint32_t, svbool_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_hor_za64)))
+void svst1_hor_za64(uint64_t, uint32_t, svbool_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_hor_za8)))
+void svst1_hor_za8(uint64_t, uint32_t, svbool_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_ver_vnum_za128)))
+void svst1_ver_vnum_za128(uint64_t, uint32_t, svbool_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_ver_vnum_za16)))
+void svst1_ver_vnum_za16(uint64_t, uint32_t, svbool_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_ver_vnum_za32)))
+void svst1_ver_vnum_za32(uint64_t, uint32_t, svbool_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_ver_vnum_za64)))
+void svst1_ver_vnum_za64(uint64_t, uint32_t, svbool_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_ver_vnum_za8)))
+void svst1_ver_vnum_za8(uint64_t, uint32_t, svbool_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_ver_za128)))
+void svst1_ver_za128(uint64_t, uint32_t, svbool_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_ver_za16)))
+void svst1_ver_za16(uint64_t, uint32_t, svbool_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_ver_za32)))
+void svst1_ver_za32(uint64_t, uint32_t, svbool_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_ver_za64)))
+void svst1_ver_za64(uint64_t, uint32_t, svbool_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svst1_ver_za8)))
+void svst1_ver_za8(uint64_t, uint32_t, svbool_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svstr_vnum_za)))
+void svstr_vnum_za(uint32_t, void *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svstr_za)))
+void svstr_za(uint32_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumopa_za32_s8_m)))
+void svsumopa_za32_s8_m(uint64_t, svbool_t, svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumops_za32_s8_m)))
+void svsumops_za32_s8_m(uint64_t, svbool_t, svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmopa_za32_u8_m)))
+void svusmopa_za32_u8_m(uint64_t, svbool_t, svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmops_za32_u8_m)))
+void svusmops_za32_u8_m(uint64_t, svbool_t, svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_u8_m)))
+void svwrite_hor_za128_u8_m(uint64_t, uint32_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_u32_m)))
+void svwrite_hor_za128_u32_m(uint64_t, uint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_u64_m)))
+void svwrite_hor_za128_u64_m(uint64_t, uint32_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_u16_m)))
+void svwrite_hor_za128_u16_m(uint64_t, uint32_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_bf16_m)))
+void svwrite_hor_za128_bf16_m(uint64_t, uint32_t, svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_s8_m)))
+void svwrite_hor_za128_s8_m(uint64_t, uint32_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_f64_m)))
+void svwrite_hor_za128_f64_m(uint64_t, uint32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_f32_m)))
+void svwrite_hor_za128_f32_m(uint64_t, uint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_f16_m)))
+void svwrite_hor_za128_f16_m(uint64_t, uint32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_s32_m)))
+void svwrite_hor_za128_s32_m(uint64_t, uint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_s64_m)))
+void svwrite_hor_za128_s64_m(uint64_t, uint32_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_s16_m)))
+void svwrite_hor_za128_s16_m(uint64_t, uint32_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_u16_m)))
+void svwrite_hor_za16_u16_m(uint64_t, uint32_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_bf16_m)))
+void svwrite_hor_za16_bf16_m(uint64_t, uint32_t, svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_f16_m)))
+void svwrite_hor_za16_f16_m(uint64_t, uint32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_s16_m)))
+void svwrite_hor_za16_s16_m(uint64_t, uint32_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_u32_m)))
+void svwrite_hor_za32_u32_m(uint64_t, uint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_f32_m)))
+void svwrite_hor_za32_f32_m(uint64_t, uint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_s32_m)))
+void svwrite_hor_za32_s32_m(uint64_t, uint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_u64_m)))
+void svwrite_hor_za64_u64_m(uint64_t, uint32_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_f64_m)))
+void svwrite_hor_za64_f64_m(uint64_t, uint32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_s64_m)))
+void svwrite_hor_za64_s64_m(uint64_t, uint32_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_u8_m)))
+void svwrite_hor_za8_u8_m(uint64_t, uint32_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_s8_m)))
+void svwrite_hor_za8_s8_m(uint64_t, uint32_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_u8_m)))
+void svwrite_ver_za128_u8_m(uint64_t, uint32_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_u32_m)))
+void svwrite_ver_za128_u32_m(uint64_t, uint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_u64_m)))
+void svwrite_ver_za128_u64_m(uint64_t, uint32_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_u16_m)))
+void svwrite_ver_za128_u16_m(uint64_t, uint32_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_bf16_m)))
+void svwrite_ver_za128_bf16_m(uint64_t, uint32_t, svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_s8_m)))
+void svwrite_ver_za128_s8_m(uint64_t, uint32_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_f64_m)))
+void svwrite_ver_za128_f64_m(uint64_t, uint32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_f32_m)))
+void svwrite_ver_za128_f32_m(uint64_t, uint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_f16_m)))
+void svwrite_ver_za128_f16_m(uint64_t, uint32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_s32_m)))
+void svwrite_ver_za128_s32_m(uint64_t, uint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_s64_m)))
+void svwrite_ver_za128_s64_m(uint64_t, uint32_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_s16_m)))
+void svwrite_ver_za128_s16_m(uint64_t, uint32_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_u16_m)))
+void svwrite_ver_za16_u16_m(uint64_t, uint32_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_bf16_m)))
+void svwrite_ver_za16_bf16_m(uint64_t, uint32_t, svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_f16_m)))
+void svwrite_ver_za16_f16_m(uint64_t, uint32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_s16_m)))
+void svwrite_ver_za16_s16_m(uint64_t, uint32_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_u32_m)))
+void svwrite_ver_za32_u32_m(uint64_t, uint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_f32_m)))
+void svwrite_ver_za32_f32_m(uint64_t, uint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_s32_m)))
+void svwrite_ver_za32_s32_m(uint64_t, uint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_u64_m)))
+void svwrite_ver_za64_u64_m(uint64_t, uint32_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_f64_m)))
+void svwrite_ver_za64_f64_m(uint64_t, uint32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_s64_m)))
+void svwrite_ver_za64_s64_m(uint64_t, uint32_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_u8_m)))
+void svwrite_ver_za8_u8_m(uint64_t, uint32_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_s8_m)))
+void svwrite_ver_za8_s8_m(uint64_t, uint32_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_mask_za)))
+void svzero_mask_za(uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za)))
+void svzero_za(void);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za32_u32_m)))
+void svaddha_za32_m(uint64_t, svbool_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za32_s32_m)))
+void svaddha_za32_m(uint64_t, svbool_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddva_za32_u32_m)))
+void svaddva_za32_m(uint64_t, svbool_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddva_za32_s32_m)))
+void svaddva_za32_m(uint64_t, svbool_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_f16_m)))
+void svmopa_za32_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_bf16_m)))
+void svmopa_za32_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_f32_m)))
+void svmopa_za32_m(uint64_t, svbool_t, svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_s8_m)))
+void svmopa_za32_m(uint64_t, svbool_t, svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_u8_m)))
+void svmopa_za32_m(uint64_t, svbool_t, svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_f16_m)))
+void svmops_za32_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_bf16_m)))
+void svmops_za32_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_f32_m)))
+void svmops_za32_m(uint64_t, svbool_t, svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_s8_m)))
+void svmops_za32_m(uint64_t, svbool_t, svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_u8_m)))
+void svmops_za32_m(uint64_t, svbool_t, svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_u8_m)))
+svuint8_t svread_hor_za128_m(svuint8_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_u32_m)))
+svuint32_t svread_hor_za128_m(svuint32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_u64_m)))
+svuint64_t svread_hor_za128_m(svuint64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_u16_m)))
+svuint16_t svread_hor_za128_m(svuint16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_bf16_m)))
+svbfloat16_t svread_hor_za128_m(svbfloat16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_s8_m)))
+svint8_t svread_hor_za128_m(svint8_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_f64_m)))
+svfloat64_t svread_hor_za128_m(svfloat64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_f32_m)))
+svfloat32_t svread_hor_za128_m(svfloat32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_f16_m)))
+svfloat16_t svread_hor_za128_m(svfloat16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_s32_m)))
+svint32_t svread_hor_za128_m(svint32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_s64_m)))
+svint64_t svread_hor_za128_m(svint64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za128_s16_m)))
+svint16_t svread_hor_za128_m(svint16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_u16_m)))
+svuint16_t svread_hor_za16_m(svuint16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_bf16_m)))
+svbfloat16_t svread_hor_za16_m(svbfloat16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_f16_m)))
+svfloat16_t svread_hor_za16_m(svfloat16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_s16_m)))
+svint16_t svread_hor_za16_m(svint16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_u32_m)))
+svuint32_t svread_hor_za32_m(svuint32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_f32_m)))
+svfloat32_t svread_hor_za32_m(svfloat32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_s32_m)))
+svint32_t svread_hor_za32_m(svint32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_u64_m)))
+svuint64_t svread_hor_za64_m(svuint64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_f64_m)))
+svfloat64_t svread_hor_za64_m(svfloat64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_s64_m)))
+svint64_t svread_hor_za64_m(svint64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za8_u8_m)))
+svuint8_t svread_hor_za8_m(svuint8_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za8_s8_m)))
+svint8_t svread_hor_za8_m(svint8_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_u8_m)))
+svuint8_t svread_ver_za128_m(svuint8_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_u32_m)))
+svuint32_t svread_ver_za128_m(svuint32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_u64_m)))
+svuint64_t svread_ver_za128_m(svuint64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_u16_m)))
+svuint16_t svread_ver_za128_m(svuint16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_bf16_m)))
+svbfloat16_t svread_ver_za128_m(svbfloat16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_s8_m)))
+svint8_t svread_ver_za128_m(svint8_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_f64_m)))
+svfloat64_t svread_ver_za128_m(svfloat64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_f32_m)))
+svfloat32_t svread_ver_za128_m(svfloat32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_f16_m)))
+svfloat16_t svread_ver_za128_m(svfloat16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_s32_m)))
+svint32_t svread_ver_za128_m(svint32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_s64_m)))
+svint64_t svread_ver_za128_m(svint64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za128_s16_m)))
+svint16_t svread_ver_za128_m(svint16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_u16_m)))
+svuint16_t svread_ver_za16_m(svuint16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_bf16_m)))
+svbfloat16_t svread_ver_za16_m(svbfloat16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_f16_m)))
+svfloat16_t svread_ver_za16_m(svfloat16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_s16_m)))
+svint16_t svread_ver_za16_m(svint16_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_u32_m)))
+svuint32_t svread_ver_za32_m(svuint32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_f32_m)))
+svfloat32_t svread_ver_za32_m(svfloat32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_s32_m)))
+svint32_t svread_ver_za32_m(svint32_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_u64_m)))
+svuint64_t svread_ver_za64_m(svuint64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_f64_m)))
+svfloat64_t svread_ver_za64_m(svfloat64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_s64_m)))
+svint64_t svread_ver_za64_m(svint64_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za8_u8_m)))
+svuint8_t svread_ver_za8_m(svuint8_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za8_s8_m)))
+svint8_t svread_ver_za8_m(svint8_t, svbool_t, uint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumopa_za32_s8_m)))
+void svsumopa_za32_m(uint64_t, svbool_t, svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumops_za32_s8_m)))
+void svsumops_za32_m(uint64_t, svbool_t, svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmopa_za32_u8_m)))
+void svusmopa_za32_m(uint64_t, svbool_t, svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmops_za32_u8_m)))
+void svusmops_za32_m(uint64_t, svbool_t, svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_u8_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_u32_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_u64_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_u16_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_bf16_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_s8_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_f64_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_f32_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_f16_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_s32_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_s64_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za128_s16_m)))
+void svwrite_hor_za128_m(uint64_t, uint32_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_u16_m)))
+void svwrite_hor_za16_m(uint64_t, uint32_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_bf16_m)))
+void svwrite_hor_za16_m(uint64_t, uint32_t, svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_f16_m)))
+void svwrite_hor_za16_m(uint64_t, uint32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_s16_m)))
+void svwrite_hor_za16_m(uint64_t, uint32_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_u32_m)))
+void svwrite_hor_za32_m(uint64_t, uint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_f32_m)))
+void svwrite_hor_za32_m(uint64_t, uint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_s32_m)))
+void svwrite_hor_za32_m(uint64_t, uint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_u64_m)))
+void svwrite_hor_za64_m(uint64_t, uint32_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_f64_m)))
+void svwrite_hor_za64_m(uint64_t, uint32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_s64_m)))
+void svwrite_hor_za64_m(uint64_t, uint32_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_u8_m)))
+void svwrite_hor_za8_m(uint64_t, uint32_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_s8_m)))
+void svwrite_hor_za8_m(uint64_t, uint32_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_u8_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_u32_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_u64_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_u16_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_bf16_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_s8_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_f64_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_f32_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_f16_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_s32_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_s64_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za128_s16_m)))
+void svwrite_ver_za128_m(uint64_t, uint32_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_u16_m)))
+void svwrite_ver_za16_m(uint64_t, uint32_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_bf16_m)))
+void svwrite_ver_za16_m(uint64_t, uint32_t, svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_f16_m)))
+void svwrite_ver_za16_m(uint64_t, uint32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_s16_m)))
+void svwrite_ver_za16_m(uint64_t, uint32_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_u32_m)))
+void svwrite_ver_za32_m(uint64_t, uint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_f32_m)))
+void svwrite_ver_za32_m(uint64_t, uint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_s32_m)))
+void svwrite_ver_za32_m(uint64_t, uint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_u64_m)))
+void svwrite_ver_za64_m(uint64_t, uint32_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_f64_m)))
+void svwrite_ver_za64_m(uint64_t, uint32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_s64_m)))
+void svwrite_ver_za64_m(uint64_t, uint32_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_u8_m)))
+void svwrite_ver_za8_m(uint64_t, uint32_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_s8_m)))
+void svwrite_ver_za8_m(uint64_t, uint32_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_f16_vg1x2)))
+void svmla_single_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_f16_vg1x4)))
+void svmla_single_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_f16_vg1x2)))
+void svmla_lane_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_f16_vg1x4)))
+void svmla_lane_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_f16_vg1x2)))
+void svmla_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_f16_vg1x4)))
+void svmla_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_f16_vg1x2)))
+void svmls_single_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_f16_vg1x4)))
+void svmls_single_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_f16_vg1x2)))
+void svmls_lane_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_f16_vg1x4)))
+void svmls_lane_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_f16_vg1x2)))
+void svmls_za16_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_f16_vg1x4)))
+void svmls_za16_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za16_f16_m)))
+void svmopa_za16_f16_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za16_f16_m)))
+void svmops_za16_f16_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_f16_vg1x2)))
+void svmla_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_f16_vg1x4)))
+void svmla_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_f16_vg1x2)))
+void svmla_lane_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_f16_vg1x4)))
+void svmla_lane_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_f16_vg1x2)))
+void svmla_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_f16_vg1x4)))
+void svmla_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_f16_vg1x2)))
+void svmls_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_f16_vg1x4)))
+void svmls_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_f16_vg1x2)))
+void svmls_lane_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_f16_vg1x4)))
+void svmls_lane_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_f16_vg1x2)))
+void svmls_za16_vg1x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_f16_vg1x4)))
+void svmls_za16_vg1x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za16_f16_m)))
+void svmopa_za16_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za16_f16_m)))
+void svmops_za16_m(uint64_t, svbool_t, svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_f16_vg1x2)))
+void svadd_za16_f16_vg1x2(uint32_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_f16_vg1x4)))
+void svadd_za16_f16_vg1x4(uint32_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_f16_vg1x2)))
+void svsub_za16_f16_vg1x2(uint32_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_f16_vg1x4)))
+void svsub_za16_f16_vg1x4(uint32_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_f16_vg1x2)))
+void svadd_za16_vg1x2(uint32_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_f16_vg1x4)))
+void svadd_za16_vg1x4(uint32_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_f16_vg1x2)))
+void svsub_za16_vg1x2(uint32_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_f16_vg1x4)))
+void svsub_za16_vg1x4(uint32_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za64_f64_m)))
+void svmopa_za64_f64_m(uint64_t, svbool_t, svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za64_f64_m)))
+void svmops_za64_f64_m(uint64_t, svbool_t, svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za64_f64_m)))
+void svmopa_za64_m(uint64_t, svbool_t, svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za64_f64_m)))
+void svmops_za64_m(uint64_t, svbool_t, svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za64_u64_m)))
+void svaddha_za64_u64_m(uint64_t, svbool_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za64_s64_m)))
+void svaddha_za64_s64_m(uint64_t, svbool_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddva_za64_u64_m)))
+void svaddva_za64_u64_m(uint64_t, svbool_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddva_za64_s64_m)))
+void svaddva_za64_s64_m(uint64_t, svbool_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za64_s16_m)))
+void svmopa_za64_s16_m(uint64_t, svbool_t, svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za64_u16_m)))
+void svmopa_za64_u16_m(uint64_t, svbool_t, svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za64_s16_m)))
+void svmops_za64_s16_m(uint64_t, svbool_t, svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za64_u16_m)))
+void svmops_za64_u16_m(uint64_t, svbool_t, svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumopa_za64_s16_m)))
+void svsumopa_za64_s16_m(uint64_t, svbool_t, svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumops_za64_s16_m)))
+void svsumops_za64_s16_m(uint64_t, svbool_t, svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmopa_za64_u16_m)))
+void svusmopa_za64_u16_m(uint64_t, svbool_t, svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmops_za64_u16_m)))
+void svusmops_za64_u16_m(uint64_t, svbool_t, svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za64_u64_m)))
+void svaddha_za64_m(uint64_t, svbool_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddha_za64_s64_m)))
+void svaddha_za64_m(uint64_t, svbool_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddva_za64_u64_m)))
+void svaddva_za64_m(uint64_t, svbool_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svaddva_za64_s64_m)))
+void svaddva_za64_m(uint64_t, svbool_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za64_s16_m)))
+void svmopa_za64_m(uint64_t, svbool_t, svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za64_u16_m)))
+void svmopa_za64_m(uint64_t, svbool_t, svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za64_s16_m)))
+void svmops_za64_m(uint64_t, svbool_t, svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za64_u16_m)))
+void svmops_za64_m(uint64_t, svbool_t, svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumopa_za64_s16_m)))
+void svsumopa_za64_m(uint64_t, svbool_t, svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumops_za64_s16_m)))
+void svsumops_za64_m(uint64_t, svbool_t, svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmopa_za64_u16_m)))
+void svusmopa_za64_m(uint64_t, svbool_t, svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmops_za64_u16_m)))
+void svusmops_za64_m(uint64_t, svbool_t, svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za32_u32_vg1x2)))
+void svadd_write_single_za32_u32_vg1x2(uint32_t, svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za32_s32_vg1x2)))
+void svadd_write_single_za32_s32_vg1x2(uint32_t, svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za32_u32_vg1x4)))
+void svadd_write_single_za32_u32_vg1x4(uint32_t, svuint32x4_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za32_s32_vg1x4)))
+void svadd_write_single_za32_s32_vg1x4(uint32_t, svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za32_u32_vg1x2)))
+void svadd_write_za32_u32_vg1x2(uint32_t, svuint32x2_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za32_s32_vg1x2)))
+void svadd_write_za32_s32_vg1x2(uint32_t, svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za32_u32_vg1x4)))
+void svadd_write_za32_u32_vg1x4(uint32_t, svuint32x4_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za32_s32_vg1x4)))
+void svadd_write_za32_s32_vg1x4(uint32_t, svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_u32_vg1x2)))
+void svadd_za32_u32_vg1x2(uint32_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_f32_vg1x2)))
+void svadd_za32_f32_vg1x2(uint32_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_s32_vg1x2)))
+void svadd_za32_s32_vg1x2(uint32_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_u32_vg1x4)))
+void svadd_za32_u32_vg1x4(uint32_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_f32_vg1x4)))
+void svadd_za32_f32_vg1x4(uint32_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_s32_vg1x4)))
+void svadd_za32_s32_vg1x4(uint32_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svbmopa_za32_u32_m)))
+void svbmopa_za32_u32_m(uint64_t, svbool_t, svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svbmopa_za32_s32_m)))
+void svbmopa_za32_s32_m(uint64_t, svbool_t, svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svbmops_za32_u32_m)))
+void svbmops_za32_u32_m(uint64_t, svbool_t, svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svbmops_za32_s32_m)))
+void svbmops_za32_s32_m(uint64_t, svbool_t, svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_bf16_vg1x2)))
+void svdot_single_za32_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_f16_vg1x2)))
+void svdot_single_za32_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_s8_vg1x2)))
+void svdot_single_za32_s8_vg1x2(uint32_t, svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_s16_vg1x2)))
+void svdot_single_za32_s16_vg1x2(uint32_t, svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_u8_vg1x2)))
+void svdot_single_za32_u8_vg1x2(uint32_t, svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_u16_vg1x2)))
+void svdot_single_za32_u16_vg1x2(uint32_t, svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_bf16_vg1x4)))
+void svdot_single_za32_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_f16_vg1x4)))
+void svdot_single_za32_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_s8_vg1x4)))
+void svdot_single_za32_s8_vg1x4(uint32_t, svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_s16_vg1x4)))
+void svdot_single_za32_s16_vg1x4(uint32_t, svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_u8_vg1x4)))
+void svdot_single_za32_u8_vg1x4(uint32_t, svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_u16_vg1x4)))
+void svdot_single_za32_u16_vg1x4(uint32_t, svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_bf16_vg1x2)))
+void svdot_lane_za32_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_f16_vg1x2)))
+void svdot_lane_za32_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_s8_vg1x2)))
+void svdot_lane_za32_s8_vg1x2(uint32_t, svint8x2_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_s16_vg1x2)))
+void svdot_lane_za32_s16_vg1x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_u8_vg1x2)))
+void svdot_lane_za32_u8_vg1x2(uint32_t, svuint8x2_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_u16_vg1x2)))
+void svdot_lane_za32_u16_vg1x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_bf16_vg1x4)))
+void svdot_lane_za32_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_f16_vg1x4)))
+void svdot_lane_za32_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_s8_vg1x4)))
+void svdot_lane_za32_s8_vg1x4(uint32_t, svint8x4_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_s16_vg1x4)))
+void svdot_lane_za32_s16_vg1x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_u8_vg1x4)))
+void svdot_lane_za32_u8_vg1x4(uint32_t, svuint8x4_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_u16_vg1x4)))
+void svdot_lane_za32_u16_vg1x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_bf16_vg1x2)))
+void svdot_za32_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_f16_vg1x2)))
+void svdot_za32_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_s8_vg1x2)))
+void svdot_za32_s8_vg1x2(uint32_t, svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_s16_vg1x2)))
+void svdot_za32_s16_vg1x2(uint32_t, svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_u8_vg1x2)))
+void svdot_za32_u8_vg1x2(uint32_t, svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_u16_vg1x2)))
+void svdot_za32_u16_vg1x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_bf16_vg1x4)))
+void svdot_za32_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_f16_vg1x4)))
+void svdot_za32_f16_vg1x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_s8_vg1x4)))
+void svdot_za32_s8_vg1x4(uint32_t, svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_s16_vg1x4)))
+void svdot_za32_s16_vg1x4(uint32_t, svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_u8_vg1x4)))
+void svdot_za32_u8_vg1x4(uint32_t, svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_u16_vg1x4)))
+void svdot_za32_u16_vg1x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svldr_zt)))
+void svldr_zt(uint64_t, void const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_u8)))
+svuint8_t svluti2_lane_zt_u8(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_u32)))
+svuint32_t svluti2_lane_zt_u32(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_u16)))
+svuint16_t svluti2_lane_zt_u16(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_bf16)))
+svbfloat16_t svluti2_lane_zt_bf16(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_s8)))
+svint8_t svluti2_lane_zt_s8(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_f32)))
+svfloat32_t svluti2_lane_zt_f32(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_f16)))
+svfloat16_t svluti2_lane_zt_f16(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_s32)))
+svint32_t svluti2_lane_zt_s32(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_s16)))
+svint16_t svluti2_lane_zt_s16(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_u8_x2)))
+svuint8x2_t svluti2_lane_zt_u8_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_u32_x2)))
+svuint32x2_t svluti2_lane_zt_u32_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_u16_x2)))
+svuint16x2_t svluti2_lane_zt_u16_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_bf16_x2)))
+svbfloat16x2_t svluti2_lane_zt_bf16_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_s8_x2)))
+svint8x2_t svluti2_lane_zt_s8_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_f32_x2)))
+svfloat32x2_t svluti2_lane_zt_f32_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_f16_x2)))
+svfloat16x2_t svluti2_lane_zt_f16_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_s32_x2)))
+svint32x2_t svluti2_lane_zt_s32_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_s16_x2)))
+svint16x2_t svluti2_lane_zt_s16_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_u8_x4)))
+svuint8x4_t svluti2_lane_zt_u8_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_u32_x4)))
+svuint32x4_t svluti2_lane_zt_u32_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_u16_x4)))
+svuint16x4_t svluti2_lane_zt_u16_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_bf16_x4)))
+svbfloat16x4_t svluti2_lane_zt_bf16_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_s8_x4)))
+svint8x4_t svluti2_lane_zt_s8_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_f32_x4)))
+svfloat32x4_t svluti2_lane_zt_f32_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_f16_x4)))
+svfloat16x4_t svluti2_lane_zt_f16_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_s32_x4)))
+svint32x4_t svluti2_lane_zt_s32_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti2_lane_zt_s16_x4)))
+svint16x4_t svluti2_lane_zt_s16_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_u8)))
+svuint8_t svluti4_lane_zt_u8(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_u32)))
+svuint32_t svluti4_lane_zt_u32(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_u16)))
+svuint16_t svluti4_lane_zt_u16(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_bf16)))
+svbfloat16_t svluti4_lane_zt_bf16(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_s8)))
+svint8_t svluti4_lane_zt_s8(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_f32)))
+svfloat32_t svluti4_lane_zt_f32(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_f16)))
+svfloat16_t svluti4_lane_zt_f16(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_s32)))
+svint32_t svluti4_lane_zt_s32(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_s16)))
+svint16_t svluti4_lane_zt_s16(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_u8_x2)))
+svuint8x2_t svluti4_lane_zt_u8_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_u32_x2)))
+svuint32x2_t svluti4_lane_zt_u32_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_u16_x2)))
+svuint16x2_t svluti4_lane_zt_u16_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_bf16_x2)))
+svbfloat16x2_t svluti4_lane_zt_bf16_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_s8_x2)))
+svint8x2_t svluti4_lane_zt_s8_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_f32_x2)))
+svfloat32x2_t svluti4_lane_zt_f32_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_f16_x2)))
+svfloat16x2_t svluti4_lane_zt_f16_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_s32_x2)))
+svint32x2_t svluti4_lane_zt_s32_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_s16_x2)))
+svint16x2_t svluti4_lane_zt_s16_x2(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_u32_x4)))
+svuint32x4_t svluti4_lane_zt_u32_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_u16_x4)))
+svuint16x4_t svluti4_lane_zt_u16_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_bf16_x4)))
+svbfloat16x4_t svluti4_lane_zt_bf16_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_f32_x4)))
+svfloat32x4_t svluti4_lane_zt_f32_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_f16_x4)))
+svfloat16x4_t svluti4_lane_zt_f16_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_s32_x4)))
+svint32x4_t svluti4_lane_zt_s32_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svluti4_lane_zt_s16_x4)))
+svint16x4_t svluti4_lane_zt_s16_x4(uint64_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_f32_vg1x2)))
+void svmla_single_za32_f32_vg1x2(uint32_t, svfloat32x2_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_f32_vg1x4)))
+void svmla_single_za32_f32_vg1x4(uint32_t, svfloat32x4_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_bf16_vg2x2)))
+void svmla_single_za32_bf16_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_f16_vg2x2)))
+void svmla_single_za32_f16_vg2x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_s16_vg2x2)))
+void svmla_single_za32_s16_vg2x2(uint32_t, svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_u16_vg2x2)))
+void svmla_single_za32_u16_vg2x2(uint32_t, svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_bf16_vg2x4)))
+void svmla_single_za32_bf16_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_f16_vg2x4)))
+void svmla_single_za32_f16_vg2x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_s16_vg2x4)))
+void svmla_single_za32_s16_vg2x4(uint32_t, svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_u16_vg2x4)))
+void svmla_single_za32_u16_vg2x4(uint32_t, svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_s8_vg4x2)))
+void svmla_single_za32_s8_vg4x2(uint32_t, svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_u8_vg4x2)))
+void svmla_single_za32_u8_vg4x2(uint32_t, svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_s8_vg4x4)))
+void svmla_single_za32_s8_vg4x4(uint32_t, svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_u8_vg4x4)))
+void svmla_single_za32_u8_vg4x4(uint32_t, svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_f32_vg1x2)))
+void svmla_lane_za32_f32_vg1x2(uint32_t, svfloat32x2_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_f32_vg1x4)))
+void svmla_lane_za32_f32_vg1x4(uint32_t, svfloat32x4_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_bf16_vg2x1)))
+void svmla_lane_za32_bf16_vg2x1(uint32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_f16_vg2x1)))
+void svmla_lane_za32_f16_vg2x1(uint32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s16_vg2x1)))
+void svmla_lane_za32_s16_vg2x1(uint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u16_vg2x1)))
+void svmla_lane_za32_u16_vg2x1(uint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_bf16_vg2x2)))
+void svmla_lane_za32_bf16_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_f16_vg2x2)))
+void svmla_lane_za32_f16_vg2x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s16_vg2x2)))
+void svmla_lane_za32_s16_vg2x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u16_vg2x2)))
+void svmla_lane_za32_u16_vg2x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_bf16_vg2x4)))
+void svmla_lane_za32_bf16_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_f16_vg2x4)))
+void svmla_lane_za32_f16_vg2x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s16_vg2x4)))
+void svmla_lane_za32_s16_vg2x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u16_vg2x4)))
+void svmla_lane_za32_u16_vg2x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s8_vg4x1)))
+void svmla_lane_za32_s8_vg4x1(uint32_t, svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u8_vg4x1)))
+void svmla_lane_za32_u8_vg4x1(uint32_t, svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s8_vg4x2)))
+void svmla_lane_za32_s8_vg4x2(uint32_t, svint8x2_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u8_vg4x2)))
+void svmla_lane_za32_u8_vg4x2(uint32_t, svuint8x2_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s8_vg4x4)))
+void svmla_lane_za32_s8_vg4x4(uint32_t, svint8x4_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u8_vg4x4)))
+void svmla_lane_za32_u8_vg4x4(uint32_t, svuint8x4_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_f32_vg1x2)))
+void svmla_za32_f32_vg1x2(uint32_t, svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_f32_vg1x4)))
+void svmla_za32_f32_vg1x4(uint32_t, svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_bf16_vg2x1)))
+void svmla_za32_bf16_vg2x1(uint32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_f16_vg2x1)))
+void svmla_za32_f16_vg2x1(uint32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s16_vg2x1)))
+void svmla_za32_s16_vg2x1(uint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u16_vg2x1)))
+void svmla_za32_u16_vg2x1(uint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_bf16_vg2x2)))
+void svmla_za32_bf16_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_f16_vg2x2)))
+void svmla_za32_f16_vg2x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s16_vg2x2)))
+void svmla_za32_s16_vg2x2(uint32_t, svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u16_vg2x2)))
+void svmla_za32_u16_vg2x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_bf16_vg2x4)))
+void svmla_za32_bf16_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_f16_vg2x4)))
+void svmla_za32_f16_vg2x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s16_vg2x4)))
+void svmla_za32_s16_vg2x4(uint32_t, svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u16_vg2x4)))
+void svmla_za32_u16_vg2x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s8_vg4x1)))
+void svmla_za32_s8_vg4x1(uint32_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u8_vg4x1)))
+void svmla_za32_u8_vg4x1(uint32_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s8_vg4x2)))
+void svmla_za32_s8_vg4x2(uint32_t, svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u8_vg4x2)))
+void svmla_za32_u8_vg4x2(uint32_t, svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s8_vg4x4)))
+void svmla_za32_s8_vg4x4(uint32_t, svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u8_vg4x4)))
+void svmla_za32_u8_vg4x4(uint32_t, svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_f32_vg1x2)))
+void svmls_single_za32_f32_vg1x2(uint32_t, svfloat32x2_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_f32_vg1x4)))
+void svmls_single_za32_f32_vg1x4(uint32_t, svfloat32x4_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_bf16_vg2x2)))
+void svmls_single_za32_bf16_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_f16_vg2x2)))
+void svmls_single_za32_f16_vg2x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_s16_vg2x2)))
+void svmls_single_za32_s16_vg2x2(uint32_t, svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_u16_vg2x2)))
+void svmls_single_za32_u16_vg2x2(uint32_t, svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_bf16_vg2x4)))
+void svmls_single_za32_bf16_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_f16_vg2x4)))
+void svmls_single_za32_f16_vg2x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_s16_vg2x4)))
+void svmls_single_za32_s16_vg2x4(uint32_t, svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_u16_vg2x4)))
+void svmls_single_za32_u16_vg2x4(uint32_t, svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_s8_vg4x2)))
+void svmls_single_za32_s8_vg4x2(uint32_t, svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_u8_vg4x2)))
+void svmls_single_za32_u8_vg4x2(uint32_t, svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_s8_vg4x4)))
+void svmls_single_za32_s8_vg4x4(uint32_t, svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_u8_vg4x4)))
+void svmls_single_za32_u8_vg4x4(uint32_t, svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_f32_vg1x2)))
+void svmls_lane_za32_f32_vg1x2(uint32_t, svfloat32x2_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_f32_vg1x4)))
+void svmls_lane_za32_f32_vg1x4(uint32_t, svfloat32x4_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_bf16_vg2x1)))
+void svmls_lane_za32_bf16_vg2x1(uint32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_f16_vg2x1)))
+void svmls_lane_za32_f16_vg2x1(uint32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s16_vg2x1)))
+void svmls_lane_za32_s16_vg2x1(uint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u16_vg2x1)))
+void svmls_lane_za32_u16_vg2x1(uint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_bf16_vg2x2)))
+void svmls_lane_za32_bf16_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_f16_vg2x2)))
+void svmls_lane_za32_f16_vg2x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s16_vg2x2)))
+void svmls_lane_za32_s16_vg2x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u16_vg2x2)))
+void svmls_lane_za32_u16_vg2x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_bf16_vg2x4)))
+void svmls_lane_za32_bf16_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_f16_vg2x4)))
+void svmls_lane_za32_f16_vg2x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s16_vg2x4)))
+void svmls_lane_za32_s16_vg2x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u16_vg2x4)))
+void svmls_lane_za32_u16_vg2x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s8_vg4x1)))
+void svmls_lane_za32_s8_vg4x1(uint32_t, svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u8_vg4x1)))
+void svmls_lane_za32_u8_vg4x1(uint32_t, svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s8_vg4x2)))
+void svmls_lane_za32_s8_vg4x2(uint32_t, svint8x2_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u8_vg4x2)))
+void svmls_lane_za32_u8_vg4x2(uint32_t, svuint8x2_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s8_vg4x4)))
+void svmls_lane_za32_s8_vg4x4(uint32_t, svint8x4_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u8_vg4x4)))
+void svmls_lane_za32_u8_vg4x4(uint32_t, svuint8x4_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_f32_vg1x2)))
+void svmls_za32_f32_vg1x2(uint32_t, svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_f32_vg1x4)))
+void svmls_za32_f32_vg1x4(uint32_t, svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_bf16_vg2x1)))
+void svmls_za32_bf16_vg2x1(uint32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_f16_vg2x1)))
+void svmls_za32_f16_vg2x1(uint32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s16_vg2x1)))
+void svmls_za32_s16_vg2x1(uint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u16_vg2x1)))
+void svmls_za32_u16_vg2x1(uint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_bf16_vg2x2)))
+void svmls_za32_bf16_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_f16_vg2x2)))
+void svmls_za32_f16_vg2x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s16_vg2x2)))
+void svmls_za32_s16_vg2x2(uint32_t, svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u16_vg2x2)))
+void svmls_za32_u16_vg2x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_bf16_vg2x4)))
+void svmls_za32_bf16_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_f16_vg2x4)))
+void svmls_za32_f16_vg2x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s16_vg2x4)))
+void svmls_za32_s16_vg2x4(uint32_t, svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u16_vg2x4)))
+void svmls_za32_u16_vg2x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s8_vg4x1)))
+void svmls_za32_s8_vg4x1(uint32_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u8_vg4x1)))
+void svmls_za32_u8_vg4x1(uint32_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s8_vg4x2)))
+void svmls_za32_s8_vg4x2(uint32_t, svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u8_vg4x2)))
+void svmls_za32_u8_vg4x2(uint32_t, svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s8_vg4x4)))
+void svmls_za32_s8_vg4x4(uint32_t, svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u8_vg4x4)))
+void svmls_za32_u8_vg4x4(uint32_t, svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_s16_m)))
+void svmopa_za32_s16_m(uint64_t, svbool_t, svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_u16_m)))
+void svmopa_za32_u16_m(uint64_t, svbool_t, svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_s16_m)))
+void svmops_za32_s16_m(uint64_t, svbool_t, svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_u16_m)))
+void svmops_za32_u16_m(uint64_t, svbool_t, svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_u16_vg2)))
+svuint16x2_t svread_hor_za16_u16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_bf16_vg2)))
+svbfloat16x2_t svread_hor_za16_bf16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_f16_vg2)))
+svfloat16x2_t svread_hor_za16_f16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_s16_vg2)))
+svint16x2_t svread_hor_za16_s16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_u16_vg4)))
+svuint16x4_t svread_hor_za16_u16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_bf16_vg4)))
+svbfloat16x4_t svread_hor_za16_bf16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_f16_vg4)))
+svfloat16x4_t svread_hor_za16_f16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za16_s16_vg4)))
+svint16x4_t svread_hor_za16_s16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_u32_vg2)))
+svuint32x2_t svread_hor_za32_u32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_f32_vg2)))
+svfloat32x2_t svread_hor_za32_f32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_s32_vg2)))
+svint32x2_t svread_hor_za32_s32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_u32_vg4)))
+svuint32x4_t svread_hor_za32_u32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_f32_vg4)))
+svfloat32x4_t svread_hor_za32_f32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za32_s32_vg4)))
+svint32x4_t svread_hor_za32_s32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_u64_vg2)))
+svuint64x2_t svread_hor_za64_u64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_f64_vg2)))
+svfloat64x2_t svread_hor_za64_f64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_s64_vg2)))
+svint64x2_t svread_hor_za64_s64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_u64_vg4)))
+svuint64x4_t svread_hor_za64_u64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_f64_vg4)))
+svfloat64x4_t svread_hor_za64_f64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za64_s64_vg4)))
+svint64x4_t svread_hor_za64_s64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za8_u8_vg2)))
+svuint8x2_t svread_hor_za8_u8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za8_s8_vg2)))
+svint8x2_t svread_hor_za8_s8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za8_u8_vg4)))
+svuint8x4_t svread_hor_za8_u8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_hor_za8_s8_vg4)))
+svint8x4_t svread_hor_za8_s8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_u16_vg2)))
+svuint16x2_t svread_ver_za16_u16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_bf16_vg2)))
+svbfloat16x2_t svread_ver_za16_bf16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_f16_vg2)))
+svfloat16x2_t svread_ver_za16_f16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_s16_vg2)))
+svint16x2_t svread_ver_za16_s16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_u16_vg4)))
+svuint16x4_t svread_ver_za16_u16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_bf16_vg4)))
+svbfloat16x4_t svread_ver_za16_bf16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_f16_vg4)))
+svfloat16x4_t svread_ver_za16_f16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za16_s16_vg4)))
+svint16x4_t svread_ver_za16_s16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_u32_vg2)))
+svuint32x2_t svread_ver_za32_u32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_f32_vg2)))
+svfloat32x2_t svread_ver_za32_f32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_s32_vg2)))
+svint32x2_t svread_ver_za32_s32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_u32_vg4)))
+svuint32x4_t svread_ver_za32_u32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_f32_vg4)))
+svfloat32x4_t svread_ver_za32_f32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za32_s32_vg4)))
+svint32x4_t svread_ver_za32_s32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_u64_vg2)))
+svuint64x2_t svread_ver_za64_u64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_f64_vg2)))
+svfloat64x2_t svread_ver_za64_f64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_s64_vg2)))
+svint64x2_t svread_ver_za64_s64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_u64_vg4)))
+svuint64x4_t svread_ver_za64_u64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_f64_vg4)))
+svfloat64x4_t svread_ver_za64_f64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za64_s64_vg4)))
+svint64x4_t svread_ver_za64_s64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za8_u8_vg2)))
+svuint8x2_t svread_ver_za8_u8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za8_s8_vg2)))
+svint8x2_t svread_ver_za8_s8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za8_u8_vg4)))
+svuint8x4_t svread_ver_za8_u8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_ver_za8_s8_vg4)))
+svint8x4_t svread_ver_za8_s8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za16_u16_vg1x2)))
+svuint16x2_t svread_za16_u16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za16_bf16_vg1x2)))
+svbfloat16x2_t svread_za16_bf16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za16_f16_vg1x2)))
+svfloat16x2_t svread_za16_f16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za16_s16_vg1x2)))
+svint16x2_t svread_za16_s16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za16_u16_vg1x4)))
+svuint16x4_t svread_za16_u16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za16_bf16_vg1x4)))
+svbfloat16x4_t svread_za16_bf16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za16_f16_vg1x4)))
+svfloat16x4_t svread_za16_f16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za16_s16_vg1x4)))
+svint16x4_t svread_za16_s16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za32_u32_vg1x2)))
+svuint32x2_t svread_za32_u32_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za32_f32_vg1x2)))
+svfloat32x2_t svread_za32_f32_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za32_s32_vg1x2)))
+svint32x2_t svread_za32_s32_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za32_u32_vg1x4)))
+svuint32x4_t svread_za32_u32_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za32_f32_vg1x4)))
+svfloat32x4_t svread_za32_f32_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za32_s32_vg1x4)))
+svint32x4_t svread_za32_s32_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za64_u64_vg1x2)))
+svuint64x2_t svread_za64_u64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za64_f64_vg1x2)))
+svfloat64x2_t svread_za64_f64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za64_s64_vg1x2)))
+svint64x2_t svread_za64_s64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za64_u64_vg1x4)))
+svuint64x4_t svread_za64_u64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za64_f64_vg1x4)))
+svfloat64x4_t svread_za64_f64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za64_s64_vg1x4)))
+svint64x4_t svread_za64_s64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za8_u8_vg1x2)))
+svuint8x2_t svread_za8_u8_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za8_s8_vg1x2)))
+svint8x2_t svread_za8_s8_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za8_u8_vg1x4)))
+svuint8x4_t svread_za8_u8_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svread_za8_s8_vg1x4)))
+svint8x4_t svread_za8_s8_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svstr_zt)))
+void svstr_zt(uint64_t, void *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za32_u32_vg1x2)))
+void svsub_write_single_za32_u32_vg1x2(uint32_t, svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za32_s32_vg1x2)))
+void svsub_write_single_za32_s32_vg1x2(uint32_t, svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za32_u32_vg1x4)))
+void svsub_write_single_za32_u32_vg1x4(uint32_t, svuint32x4_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za32_s32_vg1x4)))
+void svsub_write_single_za32_s32_vg1x4(uint32_t, svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za32_u32_vg1x2)))
+void svsub_write_za32_u32_vg1x2(uint32_t, svuint32x2_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za32_s32_vg1x2)))
+void svsub_write_za32_s32_vg1x2(uint32_t, svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za32_u32_vg1x4)))
+void svsub_write_za32_u32_vg1x4(uint32_t, svuint32x4_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za32_s32_vg1x4)))
+void svsub_write_za32_s32_vg1x4(uint32_t, svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_u32_vg1x2)))
+void svsub_za32_u32_vg1x2(uint32_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_f32_vg1x2)))
+void svsub_za32_f32_vg1x2(uint32_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_s32_vg1x2)))
+void svsub_za32_s32_vg1x2(uint32_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_u32_vg1x4)))
+void svsub_za32_u32_vg1x4(uint32_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_f32_vg1x4)))
+void svsub_za32_f32_vg1x4(uint32_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_s32_vg1x4)))
+void svsub_za32_s32_vg1x4(uint32_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_single_za32_s8_vg1x2)))
+void svsudot_single_za32_s8_vg1x2(uint32_t, svint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_single_za32_s8_vg1x4)))
+void svsudot_single_za32_s8_vg1x4(uint32_t, svint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_lane_za32_s8_vg1x2)))
+void svsudot_lane_za32_s8_vg1x2(uint32_t, svint8x2_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_lane_za32_s8_vg1x4)))
+void svsudot_lane_za32_s8_vg1x4(uint32_t, svint8x4_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_za32_s8_vg1x2)))
+void svsudot_za32_s8_vg1x2(uint32_t, svint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_za32_s8_vg1x4)))
+void svsudot_za32_s8_vg1x4(uint32_t, svint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_single_za32_s8_vg4x2)))
+void svsumla_single_za32_s8_vg4x2(uint32_t, svint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_single_za32_s8_vg4x4)))
+void svsumla_single_za32_s8_vg4x4(uint32_t, svint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_lane_za32_s8_vg4x1)))
+void svsumla_lane_za32_s8_vg4x1(uint32_t, svint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_lane_za32_s8_vg4x2)))
+void svsumla_lane_za32_s8_vg4x2(uint32_t, svint8x2_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_lane_za32_s8_vg4x4)))
+void svsumla_lane_za32_s8_vg4x4(uint32_t, svint8x4_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_za32_s8_vg4x1)))
+void svsumla_za32_s8_vg4x1(uint32_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_za32_s8_vg4x2)))
+void svsumla_za32_s8_vg4x2(uint32_t, svint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_za32_s8_vg4x4)))
+void svsumla_za32_s8_vg4x4(uint32_t, svint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsuvdot_lane_za32_s8_vg1x4)))
+void svsuvdot_lane_za32_s8_vg1x4(uint32_t, svint8x4_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_single_za32_u8_vg1x2)))
+void svusdot_single_za32_u8_vg1x2(uint32_t, svuint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_single_za32_u8_vg1x4)))
+void svusdot_single_za32_u8_vg1x4(uint32_t, svuint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_lane_za32_u8_vg1x2)))
+void svusdot_lane_za32_u8_vg1x2(uint32_t, svuint8x2_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_lane_za32_u8_vg1x4)))
+void svusdot_lane_za32_u8_vg1x4(uint32_t, svuint8x4_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_za32_u8_vg1x2)))
+void svusdot_za32_u8_vg1x2(uint32_t, svuint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_za32_u8_vg1x4)))
+void svusdot_za32_u8_vg1x4(uint32_t, svuint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_single_za32_u8_vg4x2)))
+void svusmla_single_za32_u8_vg4x2(uint32_t, svuint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_single_za32_u8_vg4x4)))
+void svusmla_single_za32_u8_vg4x4(uint32_t, svuint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_lane_za32_u8_vg4x1)))
+void svusmla_lane_za32_u8_vg4x1(uint32_t, svuint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_lane_za32_u8_vg4x2)))
+void svusmla_lane_za32_u8_vg4x2(uint32_t, svuint8x2_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_lane_za32_u8_vg4x4)))
+void svusmla_lane_za32_u8_vg4x4(uint32_t, svuint8x4_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_za32_u8_vg4x1)))
+void svusmla_za32_u8_vg4x1(uint32_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_za32_u8_vg4x2)))
+void svusmla_za32_u8_vg4x2(uint32_t, svuint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_za32_u8_vg4x4)))
+void svusmla_za32_u8_vg4x4(uint32_t, svuint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusvdot_lane_za32_u8_vg1x4)))
+void svusvdot_lane_za32_u8_vg1x4(uint32_t, svuint8x4_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_bf16_vg1x2)))
+void svvdot_lane_za32_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_f16_vg1x2)))
+void svvdot_lane_za32_f16_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_s16_vg1x2)))
+void svvdot_lane_za32_s16_vg1x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_u16_vg1x2)))
+void svvdot_lane_za32_u16_vg1x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_s8_vg1x4)))
+void svvdot_lane_za32_s8_vg1x4(uint32_t, svint8x4_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_u8_vg1x4)))
+void svvdot_lane_za32_u8_vg1x4(uint32_t, svuint8x4_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_u16_vg2)))
+void svwrite_hor_za16_u16_vg2(uint64_t, uint32_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_bf16_vg2)))
+void svwrite_hor_za16_bf16_vg2(uint64_t, uint32_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_f16_vg2)))
+void svwrite_hor_za16_f16_vg2(uint64_t, uint32_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_s16_vg2)))
+void svwrite_hor_za16_s16_vg2(uint64_t, uint32_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_u16_vg4)))
+void svwrite_hor_za16_u16_vg4(uint64_t, uint32_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_bf16_vg4)))
+void svwrite_hor_za16_bf16_vg4(uint64_t, uint32_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_f16_vg4)))
+void svwrite_hor_za16_f16_vg4(uint64_t, uint32_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_s16_vg4)))
+void svwrite_hor_za16_s16_vg4(uint64_t, uint32_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_u32_vg2)))
+void svwrite_hor_za32_u32_vg2(uint64_t, uint32_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_f32_vg2)))
+void svwrite_hor_za32_f32_vg2(uint64_t, uint32_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_s32_vg2)))
+void svwrite_hor_za32_s32_vg2(uint64_t, uint32_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_u32_vg4)))
+void svwrite_hor_za32_u32_vg4(uint64_t, uint32_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_f32_vg4)))
+void svwrite_hor_za32_f32_vg4(uint64_t, uint32_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_s32_vg4)))
+void svwrite_hor_za32_s32_vg4(uint64_t, uint32_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_u64_vg2)))
+void svwrite_hor_za64_u64_vg2(uint64_t, uint32_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_f64_vg2)))
+void svwrite_hor_za64_f64_vg2(uint64_t, uint32_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_s64_vg2)))
+void svwrite_hor_za64_s64_vg2(uint64_t, uint32_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_u64_vg4)))
+void svwrite_hor_za64_u64_vg4(uint64_t, uint32_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_f64_vg4)))
+void svwrite_hor_za64_f64_vg4(uint64_t, uint32_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_s64_vg4)))
+void svwrite_hor_za64_s64_vg4(uint64_t, uint32_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_u8_vg2)))
+void svwrite_hor_za8_u8_vg2(uint64_t, uint32_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_s8_vg2)))
+void svwrite_hor_za8_s8_vg2(uint64_t, uint32_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_u8_vg4)))
+void svwrite_hor_za8_u8_vg4(uint64_t, uint32_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_s8_vg4)))
+void svwrite_hor_za8_s8_vg4(uint64_t, uint32_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_u16_vg2)))
+void svwrite_ver_za16_u16_vg2(uint64_t, uint32_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_bf16_vg2)))
+void svwrite_ver_za16_bf16_vg2(uint64_t, uint32_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_f16_vg2)))
+void svwrite_ver_za16_f16_vg2(uint64_t, uint32_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_s16_vg2)))
+void svwrite_ver_za16_s16_vg2(uint64_t, uint32_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_u16_vg4)))
+void svwrite_ver_za16_u16_vg4(uint64_t, uint32_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_bf16_vg4)))
+void svwrite_ver_za16_bf16_vg4(uint64_t, uint32_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_f16_vg4)))
+void svwrite_ver_za16_f16_vg4(uint64_t, uint32_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_s16_vg4)))
+void svwrite_ver_za16_s16_vg4(uint64_t, uint32_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_u32_vg2)))
+void svwrite_ver_za32_u32_vg2(uint64_t, uint32_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_f32_vg2)))
+void svwrite_ver_za32_f32_vg2(uint64_t, uint32_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_s32_vg2)))
+void svwrite_ver_za32_s32_vg2(uint64_t, uint32_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_u32_vg4)))
+void svwrite_ver_za32_u32_vg4(uint64_t, uint32_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_f32_vg4)))
+void svwrite_ver_za32_f32_vg4(uint64_t, uint32_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_s32_vg4)))
+void svwrite_ver_za32_s32_vg4(uint64_t, uint32_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_u64_vg2)))
+void svwrite_ver_za64_u64_vg2(uint64_t, uint32_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_f64_vg2)))
+void svwrite_ver_za64_f64_vg2(uint64_t, uint32_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_s64_vg2)))
+void svwrite_ver_za64_s64_vg2(uint64_t, uint32_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_u64_vg4)))
+void svwrite_ver_za64_u64_vg4(uint64_t, uint32_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_f64_vg4)))
+void svwrite_ver_za64_f64_vg4(uint64_t, uint32_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_s64_vg4)))
+void svwrite_ver_za64_s64_vg4(uint64_t, uint32_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_u8_vg2)))
+void svwrite_ver_za8_u8_vg2(uint64_t, uint32_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_s8_vg2)))
+void svwrite_ver_za8_s8_vg2(uint64_t, uint32_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_u8_vg4)))
+void svwrite_ver_za8_u8_vg4(uint64_t, uint32_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_s8_vg4)))
+void svwrite_ver_za8_s8_vg4(uint64_t, uint32_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_u16_vg1x2)))
+void svwrite_za16_u16_vg1x2(uint32_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_bf16_vg1x2)))
+void svwrite_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_f16_vg1x2)))
+void svwrite_za16_f16_vg1x2(uint32_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_s16_vg1x2)))
+void svwrite_za16_s16_vg1x2(uint32_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_u16_vg1x4)))
+void svwrite_za16_u16_vg1x4(uint32_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_bf16_vg1x4)))
+void svwrite_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_f16_vg1x4)))
+void svwrite_za16_f16_vg1x4(uint32_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_s16_vg1x4)))
+void svwrite_za16_s16_vg1x4(uint32_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_u32_vg1x2)))
+void svwrite_za32_u32_vg1x2(uint32_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_f32_vg1x2)))
+void svwrite_za32_f32_vg1x2(uint32_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_s32_vg1x2)))
+void svwrite_za32_s32_vg1x2(uint32_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_u32_vg1x4)))
+void svwrite_za32_u32_vg1x4(uint32_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_f32_vg1x4)))
+void svwrite_za32_f32_vg1x4(uint32_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_s32_vg1x4)))
+void svwrite_za32_s32_vg1x4(uint32_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_u64_vg1x2)))
+void svwrite_za64_u64_vg1x2(uint32_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_f64_vg1x2)))
+void svwrite_za64_f64_vg1x2(uint32_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_s64_vg1x2)))
+void svwrite_za64_s64_vg1x2(uint32_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_u64_vg1x4)))
+void svwrite_za64_u64_vg1x4(uint32_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_f64_vg1x4)))
+void svwrite_za64_f64_vg1x4(uint32_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_s64_vg1x4)))
+void svwrite_za64_s64_vg1x4(uint32_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za8_u8_vg1x2)))
+void svwrite_za8_u8_vg1x2(uint32_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za8_s8_vg1x2)))
+void svwrite_za8_s8_vg1x2(uint32_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za8_u8_vg1x4)))
+void svwrite_za8_u8_vg1x4(uint32_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za8_s8_vg1x4)))
+void svwrite_za8_s8_vg1x4(uint32_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_zt)))
+void svzero_zt(uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za32_u32_vg1x2)))
+void svadd_write_za32_vg1x2(uint32_t, svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za32_s32_vg1x2)))
+void svadd_write_za32_vg1x2(uint32_t, svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za32_u32_vg1x4)))
+void svadd_write_za32_vg1x4(uint32_t, svuint32x4_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za32_s32_vg1x4)))
+void svadd_write_za32_vg1x4(uint32_t, svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za32_u32_vg1x2)))
+void svadd_write_za32_vg1x2(uint32_t, svuint32x2_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za32_s32_vg1x2)))
+void svadd_write_za32_vg1x2(uint32_t, svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za32_u32_vg1x4)))
+void svadd_write_za32_vg1x4(uint32_t, svuint32x4_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za32_s32_vg1x4)))
+void svadd_write_za32_vg1x4(uint32_t, svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_u32_vg1x2)))
+void svadd_za32_vg1x2(uint32_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_f32_vg1x2)))
+void svadd_za32_vg1x2(uint32_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_s32_vg1x2)))
+void svadd_za32_vg1x2(uint32_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_u32_vg1x4)))
+void svadd_za32_vg1x4(uint32_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_f32_vg1x4)))
+void svadd_za32_vg1x4(uint32_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za32_s32_vg1x4)))
+void svadd_za32_vg1x4(uint32_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svbmopa_za32_u32_m)))
+void svbmopa_za32_m(uint64_t, svbool_t, svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svbmopa_za32_s32_m)))
+void svbmopa_za32_m(uint64_t, svbool_t, svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svbmops_za32_u32_m)))
+void svbmops_za32_m(uint64_t, svbool_t, svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svbmops_za32_s32_m)))
+void svbmops_za32_m(uint64_t, svbool_t, svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_bf16_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_f16_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_s8_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_s16_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_u8_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_u16_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_bf16_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_f16_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_s8_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_s16_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_u8_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za32_u16_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_bf16_vg1x2)))
+void svdot_lane_za32_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_f16_vg1x2)))
+void svdot_lane_za32_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_s8_vg1x2)))
+void svdot_lane_za32_vg1x2(uint32_t, svint8x2_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_s16_vg1x2)))
+void svdot_lane_za32_vg1x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_u8_vg1x2)))
+void svdot_lane_za32_vg1x2(uint32_t, svuint8x2_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_u16_vg1x2)))
+void svdot_lane_za32_vg1x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_bf16_vg1x4)))
+void svdot_lane_za32_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_f16_vg1x4)))
+void svdot_lane_za32_vg1x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_s8_vg1x4)))
+void svdot_lane_za32_vg1x4(uint32_t, svint8x4_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_s16_vg1x4)))
+void svdot_lane_za32_vg1x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_u8_vg1x4)))
+void svdot_lane_za32_vg1x4(uint32_t, svuint8x4_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za32_u16_vg1x4)))
+void svdot_lane_za32_vg1x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_bf16_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_f16_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_s8_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_s16_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_u8_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_u16_vg1x2)))
+void svdot_za32_vg1x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_bf16_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_f16_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_s8_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_s16_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_u8_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za32_u16_vg1x4)))
+void svdot_za32_vg1x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_f32_vg1x2)))
+void svmla_za32_vg1x2(uint32_t, svfloat32x2_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_f32_vg1x4)))
+void svmla_za32_vg1x4(uint32_t, svfloat32x4_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_bf16_vg2x2)))
+void svmla_za32_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_f16_vg2x2)))
+void svmla_za32_vg2x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_s16_vg2x2)))
+void svmla_za32_vg2x2(uint32_t, svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_u16_vg2x2)))
+void svmla_za32_vg2x2(uint32_t, svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_bf16_vg2x4)))
+void svmla_za32_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_f16_vg2x4)))
+void svmla_za32_vg2x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_s16_vg2x4)))
+void svmla_za32_vg2x4(uint32_t, svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_u16_vg2x4)))
+void svmla_za32_vg2x4(uint32_t, svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_s8_vg4x2)))
+void svmla_za32_vg4x2(uint32_t, svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_u8_vg4x2)))
+void svmla_za32_vg4x2(uint32_t, svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_s8_vg4x4)))
+void svmla_za32_vg4x4(uint32_t, svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za32_u8_vg4x4)))
+void svmla_za32_vg4x4(uint32_t, svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_f32_vg1x2)))
+void svmla_lane_za32_vg1x2(uint32_t, svfloat32x2_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_f32_vg1x4)))
+void svmla_lane_za32_vg1x4(uint32_t, svfloat32x4_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_bf16_vg2x1)))
+void svmla_lane_za32_vg2x1(uint32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_f16_vg2x1)))
+void svmla_lane_za32_vg2x1(uint32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s16_vg2x1)))
+void svmla_lane_za32_vg2x1(uint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u16_vg2x1)))
+void svmla_lane_za32_vg2x1(uint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_bf16_vg2x2)))
+void svmla_lane_za32_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_f16_vg2x2)))
+void svmla_lane_za32_vg2x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s16_vg2x2)))
+void svmla_lane_za32_vg2x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u16_vg2x2)))
+void svmla_lane_za32_vg2x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_bf16_vg2x4)))
+void svmla_lane_za32_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_f16_vg2x4)))
+void svmla_lane_za32_vg2x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s16_vg2x4)))
+void svmla_lane_za32_vg2x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u16_vg2x4)))
+void svmla_lane_za32_vg2x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s8_vg4x1)))
+void svmla_lane_za32_vg4x1(uint32_t, svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u8_vg4x1)))
+void svmla_lane_za32_vg4x1(uint32_t, svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s8_vg4x2)))
+void svmla_lane_za32_vg4x2(uint32_t, svint8x2_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u8_vg4x2)))
+void svmla_lane_za32_vg4x2(uint32_t, svuint8x2_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_s8_vg4x4)))
+void svmla_lane_za32_vg4x4(uint32_t, svint8x4_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za32_u8_vg4x4)))
+void svmla_lane_za32_vg4x4(uint32_t, svuint8x4_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_f32_vg1x2)))
+void svmla_za32_vg1x2(uint32_t, svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_f32_vg1x4)))
+void svmla_za32_vg1x4(uint32_t, svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_bf16_vg2x1)))
+void svmla_za32_vg2x1(uint32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_f16_vg2x1)))
+void svmla_za32_vg2x1(uint32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s16_vg2x1)))
+void svmla_za32_vg2x1(uint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u16_vg2x1)))
+void svmla_za32_vg2x1(uint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_bf16_vg2x2)))
+void svmla_za32_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_f16_vg2x2)))
+void svmla_za32_vg2x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s16_vg2x2)))
+void svmla_za32_vg2x2(uint32_t, svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u16_vg2x2)))
+void svmla_za32_vg2x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_bf16_vg2x4)))
+void svmla_za32_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_f16_vg2x4)))
+void svmla_za32_vg2x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s16_vg2x4)))
+void svmla_za32_vg2x4(uint32_t, svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u16_vg2x4)))
+void svmla_za32_vg2x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s8_vg4x1)))
+void svmla_za32_vg4x1(uint32_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u8_vg4x1)))
+void svmla_za32_vg4x1(uint32_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s8_vg4x2)))
+void svmla_za32_vg4x2(uint32_t, svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u8_vg4x2)))
+void svmla_za32_vg4x2(uint32_t, svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_s8_vg4x4)))
+void svmla_za32_vg4x4(uint32_t, svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za32_u8_vg4x4)))
+void svmla_za32_vg4x4(uint32_t, svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_f32_vg1x2)))
+void svmls_za32_vg1x2(uint32_t, svfloat32x2_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_f32_vg1x4)))
+void svmls_za32_vg1x4(uint32_t, svfloat32x4_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_bf16_vg2x2)))
+void svmls_za32_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_f16_vg2x2)))
+void svmls_za32_vg2x2(uint32_t, svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_s16_vg2x2)))
+void svmls_za32_vg2x2(uint32_t, svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_u16_vg2x2)))
+void svmls_za32_vg2x2(uint32_t, svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_bf16_vg2x4)))
+void svmls_za32_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_f16_vg2x4)))
+void svmls_za32_vg2x4(uint32_t, svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_s16_vg2x4)))
+void svmls_za32_vg2x4(uint32_t, svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_u16_vg2x4)))
+void svmls_za32_vg2x4(uint32_t, svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_s8_vg4x2)))
+void svmls_za32_vg4x2(uint32_t, svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_u8_vg4x2)))
+void svmls_za32_vg4x2(uint32_t, svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_s8_vg4x4)))
+void svmls_za32_vg4x4(uint32_t, svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za32_u8_vg4x4)))
+void svmls_za32_vg4x4(uint32_t, svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_f32_vg1x2)))
+void svmls_lane_za32_vg1x2(uint32_t, svfloat32x2_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_f32_vg1x4)))
+void svmls_lane_za32_vg1x4(uint32_t, svfloat32x4_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_bf16_vg2x1)))
+void svmls_lane_za32_vg2x1(uint32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_f16_vg2x1)))
+void svmls_lane_za32_vg2x1(uint32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s16_vg2x1)))
+void svmls_lane_za32_vg2x1(uint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u16_vg2x1)))
+void svmls_lane_za32_vg2x1(uint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_bf16_vg2x2)))
+void svmls_lane_za32_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_f16_vg2x2)))
+void svmls_lane_za32_vg2x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s16_vg2x2)))
+void svmls_lane_za32_vg2x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u16_vg2x2)))
+void svmls_lane_za32_vg2x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_bf16_vg2x4)))
+void svmls_lane_za32_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_f16_vg2x4)))
+void svmls_lane_za32_vg2x4(uint32_t, svfloat16x4_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s16_vg2x4)))
+void svmls_lane_za32_vg2x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u16_vg2x4)))
+void svmls_lane_za32_vg2x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s8_vg4x1)))
+void svmls_lane_za32_vg4x1(uint32_t, svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u8_vg4x1)))
+void svmls_lane_za32_vg4x1(uint32_t, svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s8_vg4x2)))
+void svmls_lane_za32_vg4x2(uint32_t, svint8x2_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u8_vg4x2)))
+void svmls_lane_za32_vg4x2(uint32_t, svuint8x2_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_s8_vg4x4)))
+void svmls_lane_za32_vg4x4(uint32_t, svint8x4_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za32_u8_vg4x4)))
+void svmls_lane_za32_vg4x4(uint32_t, svuint8x4_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_f32_vg1x2)))
+void svmls_za32_vg1x2(uint32_t, svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_f32_vg1x4)))
+void svmls_za32_vg1x4(uint32_t, svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_bf16_vg2x1)))
+void svmls_za32_vg2x1(uint32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_f16_vg2x1)))
+void svmls_za32_vg2x1(uint32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s16_vg2x1)))
+void svmls_za32_vg2x1(uint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u16_vg2x1)))
+void svmls_za32_vg2x1(uint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_bf16_vg2x2)))
+void svmls_za32_vg2x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_f16_vg2x2)))
+void svmls_za32_vg2x2(uint32_t, svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s16_vg2x2)))
+void svmls_za32_vg2x2(uint32_t, svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u16_vg2x2)))
+void svmls_za32_vg2x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_bf16_vg2x4)))
+void svmls_za32_vg2x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_f16_vg2x4)))
+void svmls_za32_vg2x4(uint32_t, svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s16_vg2x4)))
+void svmls_za32_vg2x4(uint32_t, svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u16_vg2x4)))
+void svmls_za32_vg2x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s8_vg4x1)))
+void svmls_za32_vg4x1(uint32_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u8_vg4x1)))
+void svmls_za32_vg4x1(uint32_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s8_vg4x2)))
+void svmls_za32_vg4x2(uint32_t, svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u8_vg4x2)))
+void svmls_za32_vg4x2(uint32_t, svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_s8_vg4x4)))
+void svmls_za32_vg4x4(uint32_t, svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za32_u8_vg4x4)))
+void svmls_za32_vg4x4(uint32_t, svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_s16_m)))
+void svmopa_za32_m(uint64_t, svbool_t, svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za32_u16_m)))
+void svmopa_za32_m(uint64_t, svbool_t, svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_s16_m)))
+void svmops_za32_m(uint64_t, svbool_t, svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za32_u16_m)))
+void svmops_za32_m(uint64_t, svbool_t, svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za32_u32_vg1x2)))
+void svsub_write_za32_vg1x2(uint32_t, svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za32_s32_vg1x2)))
+void svsub_write_za32_vg1x2(uint32_t, svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za32_u32_vg1x4)))
+void svsub_write_za32_vg1x4(uint32_t, svuint32x4_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za32_s32_vg1x4)))
+void svsub_write_za32_vg1x4(uint32_t, svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za32_u32_vg1x2)))
+void svsub_write_za32_vg1x2(uint32_t, svuint32x2_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za32_s32_vg1x2)))
+void svsub_write_za32_vg1x2(uint32_t, svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za32_u32_vg1x4)))
+void svsub_write_za32_vg1x4(uint32_t, svuint32x4_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za32_s32_vg1x4)))
+void svsub_write_za32_vg1x4(uint32_t, svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_u32_vg1x2)))
+void svsub_za32_vg1x2(uint32_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_f32_vg1x2)))
+void svsub_za32_vg1x2(uint32_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_s32_vg1x2)))
+void svsub_za32_vg1x2(uint32_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_u32_vg1x4)))
+void svsub_za32_vg1x4(uint32_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_f32_vg1x4)))
+void svsub_za32_vg1x4(uint32_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za32_s32_vg1x4)))
+void svsub_za32_vg1x4(uint32_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_single_za32_s8_vg1x2)))
+void svsudot_za32_vg1x2(uint32_t, svint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_single_za32_s8_vg1x4)))
+void svsudot_za32_vg1x4(uint32_t, svint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_lane_za32_s8_vg1x2)))
+void svsudot_lane_za32_vg1x2(uint32_t, svint8x2_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_lane_za32_s8_vg1x4)))
+void svsudot_lane_za32_vg1x4(uint32_t, svint8x4_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_za32_s8_vg1x2)))
+void svsudot_za32_vg1x2(uint32_t, svint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsudot_za32_s8_vg1x4)))
+void svsudot_za32_vg1x4(uint32_t, svint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_single_za32_s8_vg4x2)))
+void svsumla_za32_vg4x2(uint32_t, svint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_single_za32_s8_vg4x4)))
+void svsumla_za32_vg4x4(uint32_t, svint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_lane_za32_s8_vg4x1)))
+void svsumla_lane_za32_vg4x1(uint32_t, svint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_lane_za32_s8_vg4x2)))
+void svsumla_lane_za32_vg4x2(uint32_t, svint8x2_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_lane_za32_s8_vg4x4)))
+void svsumla_lane_za32_vg4x4(uint32_t, svint8x4_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_za32_s8_vg4x1)))
+void svsumla_za32_vg4x1(uint32_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_za32_s8_vg4x2)))
+void svsumla_za32_vg4x2(uint32_t, svint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsumla_za32_s8_vg4x4)))
+void svsumla_za32_vg4x4(uint32_t, svint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsuvdot_lane_za32_s8_vg1x4)))
+void svsuvdot_lane_za32_vg1x4(uint32_t, svint8x4_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_single_za32_u8_vg1x2)))
+void svusdot_za32_vg1x2(uint32_t, svuint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_single_za32_u8_vg1x4)))
+void svusdot_za32_vg1x4(uint32_t, svuint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_lane_za32_u8_vg1x2)))
+void svusdot_lane_za32_vg1x2(uint32_t, svuint8x2_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_lane_za32_u8_vg1x4)))
+void svusdot_lane_za32_vg1x4(uint32_t, svuint8x4_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_za32_u8_vg1x2)))
+void svusdot_za32_vg1x2(uint32_t, svuint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusdot_za32_u8_vg1x4)))
+void svusdot_za32_vg1x4(uint32_t, svuint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_single_za32_u8_vg4x2)))
+void svusmla_za32_vg4x2(uint32_t, svuint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_single_za32_u8_vg4x4)))
+void svusmla_za32_vg4x4(uint32_t, svuint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_lane_za32_u8_vg4x1)))
+void svusmla_lane_za32_vg4x1(uint32_t, svuint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_lane_za32_u8_vg4x2)))
+void svusmla_lane_za32_vg4x2(uint32_t, svuint8x2_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_lane_za32_u8_vg4x4)))
+void svusmla_lane_za32_vg4x4(uint32_t, svuint8x4_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_za32_u8_vg4x1)))
+void svusmla_za32_vg4x1(uint32_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_za32_u8_vg4x2)))
+void svusmla_za32_vg4x2(uint32_t, svuint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusmla_za32_u8_vg4x4)))
+void svusmla_za32_vg4x4(uint32_t, svuint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svusvdot_lane_za32_u8_vg1x4)))
+void svusvdot_lane_za32_vg1x4(uint32_t, svuint8x4_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_bf16_vg1x2)))
+void svvdot_lane_za32_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_f16_vg1x2)))
+void svvdot_lane_za32_vg1x2(uint32_t, svfloat16x2_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_s16_vg1x2)))
+void svvdot_lane_za32_vg1x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_u16_vg1x2)))
+void svvdot_lane_za32_vg1x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_s8_vg1x4)))
+void svvdot_lane_za32_vg1x4(uint32_t, svint8x4_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za32_u8_vg1x4)))
+void svvdot_lane_za32_vg1x4(uint32_t, svuint8x4_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_u16_vg2)))
+void svwrite_hor_za16_vg2(uint64_t, uint32_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_bf16_vg2)))
+void svwrite_hor_za16_vg2(uint64_t, uint32_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_f16_vg2)))
+void svwrite_hor_za16_vg2(uint64_t, uint32_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_s16_vg2)))
+void svwrite_hor_za16_vg2(uint64_t, uint32_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_u16_vg4)))
+void svwrite_hor_za16_vg4(uint64_t, uint32_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_bf16_vg4)))
+void svwrite_hor_za16_vg4(uint64_t, uint32_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_f16_vg4)))
+void svwrite_hor_za16_vg4(uint64_t, uint32_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za16_s16_vg4)))
+void svwrite_hor_za16_vg4(uint64_t, uint32_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_u32_vg2)))
+void svwrite_hor_za32_vg2(uint64_t, uint32_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_f32_vg2)))
+void svwrite_hor_za32_vg2(uint64_t, uint32_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_s32_vg2)))
+void svwrite_hor_za32_vg2(uint64_t, uint32_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_u32_vg4)))
+void svwrite_hor_za32_vg4(uint64_t, uint32_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_f32_vg4)))
+void svwrite_hor_za32_vg4(uint64_t, uint32_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za32_s32_vg4)))
+void svwrite_hor_za32_vg4(uint64_t, uint32_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_u64_vg2)))
+void svwrite_hor_za64_vg2(uint64_t, uint32_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_f64_vg2)))
+void svwrite_hor_za64_vg2(uint64_t, uint32_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_s64_vg2)))
+void svwrite_hor_za64_vg2(uint64_t, uint32_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_u64_vg4)))
+void svwrite_hor_za64_vg4(uint64_t, uint32_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_f64_vg4)))
+void svwrite_hor_za64_vg4(uint64_t, uint32_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za64_s64_vg4)))
+void svwrite_hor_za64_vg4(uint64_t, uint32_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_u8_vg2)))
+void svwrite_hor_za8_vg2(uint64_t, uint32_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_s8_vg2)))
+void svwrite_hor_za8_vg2(uint64_t, uint32_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_u8_vg4)))
+void svwrite_hor_za8_vg4(uint64_t, uint32_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_hor_za8_s8_vg4)))
+void svwrite_hor_za8_vg4(uint64_t, uint32_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_u16_vg2)))
+void svwrite_ver_za16_vg2(uint64_t, uint32_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_bf16_vg2)))
+void svwrite_ver_za16_vg2(uint64_t, uint32_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_f16_vg2)))
+void svwrite_ver_za16_vg2(uint64_t, uint32_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_s16_vg2)))
+void svwrite_ver_za16_vg2(uint64_t, uint32_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_u16_vg4)))
+void svwrite_ver_za16_vg4(uint64_t, uint32_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_bf16_vg4)))
+void svwrite_ver_za16_vg4(uint64_t, uint32_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_f16_vg4)))
+void svwrite_ver_za16_vg4(uint64_t, uint32_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za16_s16_vg4)))
+void svwrite_ver_za16_vg4(uint64_t, uint32_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_u32_vg2)))
+void svwrite_ver_za32_vg2(uint64_t, uint32_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_f32_vg2)))
+void svwrite_ver_za32_vg2(uint64_t, uint32_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_s32_vg2)))
+void svwrite_ver_za32_vg2(uint64_t, uint32_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_u32_vg4)))
+void svwrite_ver_za32_vg4(uint64_t, uint32_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_f32_vg4)))
+void svwrite_ver_za32_vg4(uint64_t, uint32_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za32_s32_vg4)))
+void svwrite_ver_za32_vg4(uint64_t, uint32_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_u64_vg2)))
+void svwrite_ver_za64_vg2(uint64_t, uint32_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_f64_vg2)))
+void svwrite_ver_za64_vg2(uint64_t, uint32_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_s64_vg2)))
+void svwrite_ver_za64_vg2(uint64_t, uint32_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_u64_vg4)))
+void svwrite_ver_za64_vg4(uint64_t, uint32_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_f64_vg4)))
+void svwrite_ver_za64_vg4(uint64_t, uint32_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za64_s64_vg4)))
+void svwrite_ver_za64_vg4(uint64_t, uint32_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_u8_vg2)))
+void svwrite_ver_za8_vg2(uint64_t, uint32_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_s8_vg2)))
+void svwrite_ver_za8_vg2(uint64_t, uint32_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_u8_vg4)))
+void svwrite_ver_za8_vg4(uint64_t, uint32_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_ver_za8_s8_vg4)))
+void svwrite_ver_za8_vg4(uint64_t, uint32_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_u16_vg1x2)))
+void svwrite_za16_vg1x2(uint32_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_bf16_vg1x2)))
+void svwrite_za16_vg1x2(uint32_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_f16_vg1x2)))
+void svwrite_za16_vg1x2(uint32_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_s16_vg1x2)))
+void svwrite_za16_vg1x2(uint32_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_u16_vg1x4)))
+void svwrite_za16_vg1x4(uint32_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_bf16_vg1x4)))
+void svwrite_za16_vg1x4(uint32_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_f16_vg1x4)))
+void svwrite_za16_vg1x4(uint32_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za16_s16_vg1x4)))
+void svwrite_za16_vg1x4(uint32_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_u32_vg1x2)))
+void svwrite_za32_vg1x2(uint32_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_f32_vg1x2)))
+void svwrite_za32_vg1x2(uint32_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_s32_vg1x2)))
+void svwrite_za32_vg1x2(uint32_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_u32_vg1x4)))
+void svwrite_za32_vg1x4(uint32_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_f32_vg1x4)))
+void svwrite_za32_vg1x4(uint32_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za32_s32_vg1x4)))
+void svwrite_za32_vg1x4(uint32_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_u64_vg1x2)))
+void svwrite_za64_vg1x2(uint32_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_f64_vg1x2)))
+void svwrite_za64_vg1x2(uint32_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_s64_vg1x2)))
+void svwrite_za64_vg1x2(uint32_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_u64_vg1x4)))
+void svwrite_za64_vg1x4(uint32_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_f64_vg1x4)))
+void svwrite_za64_vg1x4(uint32_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za64_s64_vg1x4)))
+void svwrite_za64_vg1x4(uint32_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za8_u8_vg1x2)))
+void svwrite_za8_vg1x2(uint32_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za8_s8_vg1x2)))
+void svwrite_za8_vg1x2(uint32_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za8_u8_vg1x4)))
+void svwrite_za8_vg1x4(uint32_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svwrite_za8_s8_vg1x4)))
+void svwrite_za8_vg1x4(uint32_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_bf16_vg1x2)))
+void svadd_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_bf16_vg1x4)))
+void svadd_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_bf16_vg1x2)))
+void svmla_single_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_bf16_vg1x4)))
+void svmla_single_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_bf16_vg1x2)))
+void svmla_lane_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_bf16_vg1x4)))
+void svmla_lane_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_bf16_vg1x2)))
+void svmla_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_bf16_vg1x4)))
+void svmla_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_bf16_vg1x2)))
+void svmls_single_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_bf16_vg1x4)))
+void svmls_single_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_bf16_vg1x2)))
+void svmls_lane_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_bf16_vg1x4)))
+void svmls_lane_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_bf16_vg1x2)))
+void svmls_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_bf16_vg1x4)))
+void svmls_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za16_bf16_m)))
+void svmopa_za16_bf16_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za16_bf16_m)))
+void svmops_za16_bf16_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_bf16_vg1x2)))
+void svsub_za16_bf16_vg1x2(uint32_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_bf16_vg1x4)))
+void svsub_za16_bf16_vg1x4(uint32_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_bf16_vg1x2)))
+void svadd_za16_vg1x2(uint32_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za16_bf16_vg1x4)))
+void svadd_za16_vg1x4(uint32_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_bf16_vg1x2)))
+void svmla_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za16_bf16_vg1x4)))
+void svmla_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_bf16_vg1x2)))
+void svmla_lane_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za16_bf16_vg1x4)))
+void svmla_lane_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_bf16_vg1x2)))
+void svmla_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za16_bf16_vg1x4)))
+void svmla_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_bf16_vg1x2)))
+void svmls_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za16_bf16_vg1x4)))
+void svmls_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_bf16_vg1x2)))
+void svmls_lane_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za16_bf16_vg1x4)))
+void svmls_lane_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_bf16_vg1x2)))
+void svmls_za16_vg1x2(uint32_t, svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za16_bf16_vg1x4)))
+void svmls_za16_vg1x4(uint32_t, svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmopa_za16_bf16_m)))
+void svmopa_za16_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmops_za16_bf16_m)))
+void svmops_za16_m(uint64_t, svbool_t, svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_bf16_vg1x2)))
+void svsub_za16_vg1x2(uint32_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za16_bf16_vg1x4)))
+void svsub_za16_vg1x4(uint32_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_f64_vg1x2)))
+void svadd_za64_f64_vg1x2(uint32_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_f64_vg1x4)))
+void svadd_za64_f64_vg1x4(uint32_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_f64_vg1x2)))
+void svmla_single_za64_f64_vg1x2(uint32_t, svfloat64x2_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_f64_vg1x4)))
+void svmla_single_za64_f64_vg1x4(uint32_t, svfloat64x4_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_f64_vg1x2)))
+void svmla_lane_za64_f64_vg1x2(uint32_t, svfloat64x2_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_f64_vg1x4)))
+void svmla_lane_za64_f64_vg1x4(uint32_t, svfloat64x4_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_f64_vg1x2)))
+void svmla_za64_f64_vg1x2(uint32_t, svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_f64_vg1x4)))
+void svmla_za64_f64_vg1x4(uint32_t, svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_f64_vg1x2)))
+void svmls_single_za64_f64_vg1x2(uint32_t, svfloat64x2_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_f64_vg1x4)))
+void svmls_single_za64_f64_vg1x4(uint32_t, svfloat64x4_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_f64_vg1x2)))
+void svmls_lane_za64_f64_vg1x2(uint32_t, svfloat64x2_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_f64_vg1x4)))
+void svmls_lane_za64_f64_vg1x4(uint32_t, svfloat64x4_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_f64_vg1x2)))
+void svmls_za64_f64_vg1x2(uint32_t, svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_f64_vg1x4)))
+void svmls_za64_f64_vg1x4(uint32_t, svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_f64_vg1x2)))
+void svsub_za64_f64_vg1x2(uint32_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_f64_vg1x4)))
+void svsub_za64_f64_vg1x4(uint32_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_f64_vg1x2)))
+void svadd_za64_vg1x2(uint32_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_f64_vg1x4)))
+void svadd_za64_vg1x4(uint32_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_f64_vg1x2)))
+void svmla_za64_vg1x2(uint32_t, svfloat64x2_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_f64_vg1x4)))
+void svmla_za64_vg1x4(uint32_t, svfloat64x4_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_f64_vg1x2)))
+void svmla_lane_za64_vg1x2(uint32_t, svfloat64x2_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_f64_vg1x4)))
+void svmla_lane_za64_vg1x4(uint32_t, svfloat64x4_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_f64_vg1x2)))
+void svmla_za64_vg1x2(uint32_t, svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_f64_vg1x4)))
+void svmla_za64_vg1x4(uint32_t, svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_f64_vg1x2)))
+void svmls_za64_vg1x2(uint32_t, svfloat64x2_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_f64_vg1x4)))
+void svmls_za64_vg1x4(uint32_t, svfloat64x4_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_f64_vg1x2)))
+void svmls_lane_za64_vg1x2(uint32_t, svfloat64x2_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_f64_vg1x4)))
+void svmls_lane_za64_vg1x4(uint32_t, svfloat64x4_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_f64_vg1x2)))
+void svmls_za64_vg1x2(uint32_t, svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_f64_vg1x4)))
+void svmls_za64_vg1x4(uint32_t, svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_f64_vg1x2)))
+void svsub_za64_vg1x2(uint32_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_f64_vg1x4)))
+void svsub_za64_vg1x4(uint32_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za64_u64_vg1x2)))
+void svadd_write_single_za64_u64_vg1x2(uint32_t, svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za64_s64_vg1x2)))
+void svadd_write_single_za64_s64_vg1x2(uint32_t, svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za64_u64_vg1x4)))
+void svadd_write_single_za64_u64_vg1x4(uint32_t, svuint64x4_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za64_s64_vg1x4)))
+void svadd_write_single_za64_s64_vg1x4(uint32_t, svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za64_u64_vg1x2)))
+void svadd_write_za64_u64_vg1x2(uint32_t, svuint64x2_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za64_s64_vg1x2)))
+void svadd_write_za64_s64_vg1x2(uint32_t, svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za64_u64_vg1x4)))
+void svadd_write_za64_u64_vg1x4(uint32_t, svuint64x4_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za64_s64_vg1x4)))
+void svadd_write_za64_s64_vg1x4(uint32_t, svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_u64_vg1x2)))
+void svadd_za64_u64_vg1x2(uint32_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_s64_vg1x2)))
+void svadd_za64_s64_vg1x2(uint32_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_u64_vg1x4)))
+void svadd_za64_u64_vg1x4(uint32_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_s64_vg1x4)))
+void svadd_za64_s64_vg1x4(uint32_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za64_s16_vg1x2)))
+void svdot_single_za64_s16_vg1x2(uint32_t, svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za64_u16_vg1x2)))
+void svdot_single_za64_u16_vg1x2(uint32_t, svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za64_s16_vg1x4)))
+void svdot_single_za64_s16_vg1x4(uint32_t, svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za64_u16_vg1x4)))
+void svdot_single_za64_u16_vg1x4(uint32_t, svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za64_s16_vg1x2)))
+void svdot_lane_za64_s16_vg1x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za64_u16_vg1x2)))
+void svdot_lane_za64_u16_vg1x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za64_s16_vg1x4)))
+void svdot_lane_za64_s16_vg1x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za64_u16_vg1x4)))
+void svdot_lane_za64_u16_vg1x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za64_s16_vg1x2)))
+void svdot_za64_s16_vg1x2(uint32_t, svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za64_u16_vg1x2)))
+void svdot_za64_u16_vg1x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za64_s16_vg1x4)))
+void svdot_za64_s16_vg1x4(uint32_t, svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za64_u16_vg1x4)))
+void svdot_za64_u16_vg1x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_s16_vg4x2)))
+void svmla_single_za64_s16_vg4x2(uint32_t, svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_u16_vg4x2)))
+void svmla_single_za64_u16_vg4x2(uint32_t, svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_s16_vg4x4)))
+void svmla_single_za64_s16_vg4x4(uint32_t, svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_u16_vg4x4)))
+void svmla_single_za64_u16_vg4x4(uint32_t, svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_s16_vg4x1)))
+void svmla_lane_za64_s16_vg4x1(uint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_u16_vg4x1)))
+void svmla_lane_za64_u16_vg4x1(uint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_s16_vg4x2)))
+void svmla_lane_za64_s16_vg4x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_u16_vg4x2)))
+void svmla_lane_za64_u16_vg4x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_s16_vg4x4)))
+void svmla_lane_za64_s16_vg4x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_u16_vg4x4)))
+void svmla_lane_za64_u16_vg4x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_s16_vg4x1)))
+void svmla_za64_s16_vg4x1(uint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_u16_vg4x1)))
+void svmla_za64_u16_vg4x1(uint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_s16_vg4x2)))
+void svmla_za64_s16_vg4x2(uint32_t, svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_u16_vg4x2)))
+void svmla_za64_u16_vg4x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_s16_vg4x4)))
+void svmla_za64_s16_vg4x4(uint32_t, svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_u16_vg4x4)))
+void svmla_za64_u16_vg4x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_s16_vg4x2)))
+void svmls_single_za64_s16_vg4x2(uint32_t, svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_u16_vg4x2)))
+void svmls_single_za64_u16_vg4x2(uint32_t, svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_s16_vg4x4)))
+void svmls_single_za64_s16_vg4x4(uint32_t, svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_u16_vg4x4)))
+void svmls_single_za64_u16_vg4x4(uint32_t, svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_s16_vg4x1)))
+void svmls_lane_za64_s16_vg4x1(uint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_u16_vg4x1)))
+void svmls_lane_za64_u16_vg4x1(uint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_s16_vg4x2)))
+void svmls_lane_za64_s16_vg4x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_u16_vg4x2)))
+void svmls_lane_za64_u16_vg4x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_s16_vg4x4)))
+void svmls_lane_za64_s16_vg4x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_u16_vg4x4)))
+void svmls_lane_za64_u16_vg4x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_s16_vg4x1)))
+void svmls_za64_s16_vg4x1(uint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_u16_vg4x1)))
+void svmls_za64_u16_vg4x1(uint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_s16_vg4x2)))
+void svmls_za64_s16_vg4x2(uint32_t, svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_u16_vg4x2)))
+void svmls_za64_u16_vg4x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_s16_vg4x4)))
+void svmls_za64_s16_vg4x4(uint32_t, svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_u16_vg4x4)))
+void svmls_za64_u16_vg4x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za64_u64_vg1x2)))
+void svsub_write_single_za64_u64_vg1x2(uint32_t, svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za64_s64_vg1x2)))
+void svsub_write_single_za64_s64_vg1x2(uint32_t, svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za64_u64_vg1x4)))
+void svsub_write_single_za64_u64_vg1x4(uint32_t, svuint64x4_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za64_s64_vg1x4)))
+void svsub_write_single_za64_s64_vg1x4(uint32_t, svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za64_u64_vg1x2)))
+void svsub_write_za64_u64_vg1x2(uint32_t, svuint64x2_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za64_s64_vg1x2)))
+void svsub_write_za64_s64_vg1x2(uint32_t, svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za64_u64_vg1x4)))
+void svsub_write_za64_u64_vg1x4(uint32_t, svuint64x4_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za64_s64_vg1x4)))
+void svsub_write_za64_s64_vg1x4(uint32_t, svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_u64_vg1x2)))
+void svsub_za64_u64_vg1x2(uint32_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_s64_vg1x2)))
+void svsub_za64_s64_vg1x2(uint32_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_u64_vg1x4)))
+void svsub_za64_u64_vg1x4(uint32_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_s64_vg1x4)))
+void svsub_za64_s64_vg1x4(uint32_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za64_s16_vg1x4)))
+void svvdot_lane_za64_s16_vg1x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za64_u16_vg1x4)))
+void svvdot_lane_za64_u16_vg1x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za64_u64_vg1x2)))
+void svadd_write_za64_vg1x2(uint32_t, svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za64_s64_vg1x2)))
+void svadd_write_za64_vg1x2(uint32_t, svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za64_u64_vg1x4)))
+void svadd_write_za64_vg1x4(uint32_t, svuint64x4_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_single_za64_s64_vg1x4)))
+void svadd_write_za64_vg1x4(uint32_t, svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za64_u64_vg1x2)))
+void svadd_write_za64_vg1x2(uint32_t, svuint64x2_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za64_s64_vg1x2)))
+void svadd_write_za64_vg1x2(uint32_t, svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za64_u64_vg1x4)))
+void svadd_write_za64_vg1x4(uint32_t, svuint64x4_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_write_za64_s64_vg1x4)))
+void svadd_write_za64_vg1x4(uint32_t, svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_u64_vg1x2)))
+void svadd_za64_vg1x2(uint32_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_s64_vg1x2)))
+void svadd_za64_vg1x2(uint32_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_u64_vg1x4)))
+void svadd_za64_vg1x4(uint32_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svadd_za64_s64_vg1x4)))
+void svadd_za64_vg1x4(uint32_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za64_s16_vg1x2)))
+void svdot_za64_vg1x2(uint32_t, svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za64_u16_vg1x2)))
+void svdot_za64_vg1x2(uint32_t, svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za64_s16_vg1x4)))
+void svdot_za64_vg1x4(uint32_t, svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_single_za64_u16_vg1x4)))
+void svdot_za64_vg1x4(uint32_t, svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za64_s16_vg1x2)))
+void svdot_lane_za64_vg1x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za64_u16_vg1x2)))
+void svdot_lane_za64_vg1x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za64_s16_vg1x4)))
+void svdot_lane_za64_vg1x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_lane_za64_u16_vg1x4)))
+void svdot_lane_za64_vg1x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za64_s16_vg1x2)))
+void svdot_za64_vg1x2(uint32_t, svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za64_u16_vg1x2)))
+void svdot_za64_vg1x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za64_s16_vg1x4)))
+void svdot_za64_vg1x4(uint32_t, svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svdot_za64_u16_vg1x4)))
+void svdot_za64_vg1x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_s16_vg4x2)))
+void svmla_za64_vg4x2(uint32_t, svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_u16_vg4x2)))
+void svmla_za64_vg4x2(uint32_t, svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_s16_vg4x4)))
+void svmla_za64_vg4x4(uint32_t, svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_single_za64_u16_vg4x4)))
+void svmla_za64_vg4x4(uint32_t, svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_s16_vg4x1)))
+void svmla_lane_za64_vg4x1(uint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_u16_vg4x1)))
+void svmla_lane_za64_vg4x1(uint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_s16_vg4x2)))
+void svmla_lane_za64_vg4x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_u16_vg4x2)))
+void svmla_lane_za64_vg4x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_s16_vg4x4)))
+void svmla_lane_za64_vg4x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_lane_za64_u16_vg4x4)))
+void svmla_lane_za64_vg4x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_s16_vg4x1)))
+void svmla_za64_vg4x1(uint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_u16_vg4x1)))
+void svmla_za64_vg4x1(uint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_s16_vg4x2)))
+void svmla_za64_vg4x2(uint32_t, svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_u16_vg4x2)))
+void svmla_za64_vg4x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_s16_vg4x4)))
+void svmla_za64_vg4x4(uint32_t, svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmla_za64_u16_vg4x4)))
+void svmla_za64_vg4x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_s16_vg4x2)))
+void svmls_za64_vg4x2(uint32_t, svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_u16_vg4x2)))
+void svmls_za64_vg4x2(uint32_t, svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_s16_vg4x4)))
+void svmls_za64_vg4x4(uint32_t, svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_single_za64_u16_vg4x4)))
+void svmls_za64_vg4x4(uint32_t, svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_s16_vg4x1)))
+void svmls_lane_za64_vg4x1(uint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_u16_vg4x1)))
+void svmls_lane_za64_vg4x1(uint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_s16_vg4x2)))
+void svmls_lane_za64_vg4x2(uint32_t, svint16x2_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_u16_vg4x2)))
+void svmls_lane_za64_vg4x2(uint32_t, svuint16x2_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_s16_vg4x4)))
+void svmls_lane_za64_vg4x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_lane_za64_u16_vg4x4)))
+void svmls_lane_za64_vg4x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_s16_vg4x1)))
+void svmls_za64_vg4x1(uint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_u16_vg4x1)))
+void svmls_za64_vg4x1(uint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_s16_vg4x2)))
+void svmls_za64_vg4x2(uint32_t, svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_u16_vg4x2)))
+void svmls_za64_vg4x2(uint32_t, svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_s16_vg4x4)))
+void svmls_za64_vg4x4(uint32_t, svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svmls_za64_u16_vg4x4)))
+void svmls_za64_vg4x4(uint32_t, svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za64_u64_vg1x2)))
+void svsub_write_za64_vg1x2(uint32_t, svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za64_s64_vg1x2)))
+void svsub_write_za64_vg1x2(uint32_t, svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za64_u64_vg1x4)))
+void svsub_write_za64_vg1x4(uint32_t, svuint64x4_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_single_za64_s64_vg1x4)))
+void svsub_write_za64_vg1x4(uint32_t, svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za64_u64_vg1x2)))
+void svsub_write_za64_vg1x2(uint32_t, svuint64x2_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za64_s64_vg1x2)))
+void svsub_write_za64_vg1x2(uint32_t, svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za64_u64_vg1x4)))
+void svsub_write_za64_vg1x4(uint32_t, svuint64x4_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_write_za64_s64_vg1x4)))
+void svsub_write_za64_vg1x4(uint32_t, svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_u64_vg1x2)))
+void svsub_za64_vg1x2(uint32_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_s64_vg1x2)))
+void svsub_za64_vg1x2(uint32_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_u64_vg1x4)))
+void svsub_za64_vg1x4(uint32_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svsub_za64_s64_vg1x4)))
+void svsub_za64_vg1x4(uint32_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za64_s16_vg1x4)))
+void svvdot_lane_za64_vg1x4(uint32_t, svint16x4_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sme_svvdot_lane_za64_u16_vg1x4)))
+void svvdot_lane_za64_vg1x4(uint32_t, svuint16x4_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_u8)))
+svuint8_t svreadz_hor_za128_u8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_u32)))
+svuint32_t svreadz_hor_za128_u32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_u64)))
+svuint64_t svreadz_hor_za128_u64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_u16)))
+svuint16_t svreadz_hor_za128_u16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_bf16)))
+svbfloat16_t svreadz_hor_za128_bf16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_s8)))
+svint8_t svreadz_hor_za128_s8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_f64)))
+svfloat64_t svreadz_hor_za128_f64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_f32)))
+svfloat32_t svreadz_hor_za128_f32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_f16)))
+svfloat16_t svreadz_hor_za128_f16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_s32)))
+svint32_t svreadz_hor_za128_s32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_s64)))
+svint64_t svreadz_hor_za128_s64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za128_s16)))
+svint16_t svreadz_hor_za128_s16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_u16)))
+svuint16_t svreadz_hor_za16_u16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_bf16)))
+svbfloat16_t svreadz_hor_za16_bf16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_f16)))
+svfloat16_t svreadz_hor_za16_f16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_s16)))
+svint16_t svreadz_hor_za16_s16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_u16_vg2)))
+svuint16x2_t svreadz_hor_za16_u16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_bf16_vg2)))
+svbfloat16x2_t svreadz_hor_za16_bf16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_f16_vg2)))
+svfloat16x2_t svreadz_hor_za16_f16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_s16_vg2)))
+svint16x2_t svreadz_hor_za16_s16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_u16_vg4)))
+svuint16x4_t svreadz_hor_za16_u16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_bf16_vg4)))
+svbfloat16x4_t svreadz_hor_za16_bf16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_f16_vg4)))
+svfloat16x4_t svreadz_hor_za16_f16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za16_s16_vg4)))
+svint16x4_t svreadz_hor_za16_s16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_u32)))
+svuint32_t svreadz_hor_za32_u32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_f32)))
+svfloat32_t svreadz_hor_za32_f32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_s32)))
+svint32_t svreadz_hor_za32_s32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_u32_vg2)))
+svuint32x2_t svreadz_hor_za32_u32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_f32_vg2)))
+svfloat32x2_t svreadz_hor_za32_f32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_s32_vg2)))
+svint32x2_t svreadz_hor_za32_s32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_u32_vg4)))
+svuint32x4_t svreadz_hor_za32_u32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_f32_vg4)))
+svfloat32x4_t svreadz_hor_za32_f32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za32_s32_vg4)))
+svint32x4_t svreadz_hor_za32_s32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_u64)))
+svuint64_t svreadz_hor_za64_u64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_f64)))
+svfloat64_t svreadz_hor_za64_f64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_s64)))
+svint64_t svreadz_hor_za64_s64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_u64_vg2)))
+svuint64x2_t svreadz_hor_za64_u64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_f64_vg2)))
+svfloat64x2_t svreadz_hor_za64_f64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_s64_vg2)))
+svint64x2_t svreadz_hor_za64_s64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_u64_vg4)))
+svuint64x4_t svreadz_hor_za64_u64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_f64_vg4)))
+svfloat64x4_t svreadz_hor_za64_f64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za64_s64_vg4)))
+svint64x4_t svreadz_hor_za64_s64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_u8)))
+svuint8_t svreadz_hor_za8_u8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_s8)))
+svint8_t svreadz_hor_za8_s8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_u8_vg2)))
+svuint8x2_t svreadz_hor_za8_u8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_s8_vg2)))
+svint8x2_t svreadz_hor_za8_s8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_u8_vg4)))
+svuint8x4_t svreadz_hor_za8_u8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_hor_za8_s8_vg4)))
+svint8x4_t svreadz_hor_za8_s8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_u8)))
+svuint8_t svreadz_ver_za128_u8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_u32)))
+svuint32_t svreadz_ver_za128_u32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_u64)))
+svuint64_t svreadz_ver_za128_u64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_u16)))
+svuint16_t svreadz_ver_za128_u16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_bf16)))
+svbfloat16_t svreadz_ver_za128_bf16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_s8)))
+svint8_t svreadz_ver_za128_s8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_f64)))
+svfloat64_t svreadz_ver_za128_f64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_f32)))
+svfloat32_t svreadz_ver_za128_f32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_f16)))
+svfloat16_t svreadz_ver_za128_f16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_s32)))
+svint32_t svreadz_ver_za128_s32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_s64)))
+svint64_t svreadz_ver_za128_s64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za128_s16)))
+svint16_t svreadz_ver_za128_s16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_u16)))
+svuint16_t svreadz_ver_za16_u16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_bf16)))
+svbfloat16_t svreadz_ver_za16_bf16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_f16)))
+svfloat16_t svreadz_ver_za16_f16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_s16)))
+svint16_t svreadz_ver_za16_s16(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_u16_vg2)))
+svuint16x2_t svreadz_ver_za16_u16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_bf16_vg2)))
+svbfloat16x2_t svreadz_ver_za16_bf16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_f16_vg2)))
+svfloat16x2_t svreadz_ver_za16_f16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_s16_vg2)))
+svint16x2_t svreadz_ver_za16_s16_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_u16_vg4)))
+svuint16x4_t svreadz_ver_za16_u16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_bf16_vg4)))
+svbfloat16x4_t svreadz_ver_za16_bf16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_f16_vg4)))
+svfloat16x4_t svreadz_ver_za16_f16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za16_s16_vg4)))
+svint16x4_t svreadz_ver_za16_s16_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_u32)))
+svuint32_t svreadz_ver_za32_u32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_f32)))
+svfloat32_t svreadz_ver_za32_f32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_s32)))
+svint32_t svreadz_ver_za32_s32(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_u32_vg2)))
+svuint32x2_t svreadz_ver_za32_u32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_f32_vg2)))
+svfloat32x2_t svreadz_ver_za32_f32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_s32_vg2)))
+svint32x2_t svreadz_ver_za32_s32_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_u32_vg4)))
+svuint32x4_t svreadz_ver_za32_u32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_f32_vg4)))
+svfloat32x4_t svreadz_ver_za32_f32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za32_s32_vg4)))
+svint32x4_t svreadz_ver_za32_s32_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_u64)))
+svuint64_t svreadz_ver_za64_u64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_f64)))
+svfloat64_t svreadz_ver_za64_f64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_s64)))
+svint64_t svreadz_ver_za64_s64(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_u64_vg2)))
+svuint64x2_t svreadz_ver_za64_u64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_f64_vg2)))
+svfloat64x2_t svreadz_ver_za64_f64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_s64_vg2)))
+svint64x2_t svreadz_ver_za64_s64_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_u64_vg4)))
+svuint64x4_t svreadz_ver_za64_u64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_f64_vg4)))
+svfloat64x4_t svreadz_ver_za64_f64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za64_s64_vg4)))
+svint64x4_t svreadz_ver_za64_s64_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_u8)))
+svuint8_t svreadz_ver_za8_u8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_s8)))
+svint8_t svreadz_ver_za8_s8(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_u8_vg2)))
+svuint8x2_t svreadz_ver_za8_u8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_s8_vg2)))
+svint8x2_t svreadz_ver_za8_s8_vg2(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_u8_vg4)))
+svuint8x4_t svreadz_ver_za8_u8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_ver_za8_s8_vg4)))
+svint8x4_t svreadz_ver_za8_s8_vg4(uint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_u16_vg1x2)))
+svuint16x2_t svreadz_za16_u16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_bf16_vg1x2)))
+svbfloat16x2_t svreadz_za16_bf16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_f16_vg1x2)))
+svfloat16x2_t svreadz_za16_f16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_s16_vg1x2)))
+svint16x2_t svreadz_za16_s16_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_u16_vg1x4)))
+svuint16x4_t svreadz_za16_u16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_bf16_vg1x4)))
+svbfloat16x4_t svreadz_za16_bf16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_f16_vg1x4)))
+svfloat16x4_t svreadz_za16_f16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za16_s16_vg1x4)))
+svint16x4_t svreadz_za16_s16_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_u32_vg1x2)))
+svuint32x2_t svreadz_za32_u32_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_f32_vg1x2)))
+svfloat32x2_t svreadz_za32_f32_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_s32_vg1x2)))
+svint32x2_t svreadz_za32_s32_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_u32_vg1x4)))
+svuint32x4_t svreadz_za32_u32_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_f32_vg1x4)))
+svfloat32x4_t svreadz_za32_f32_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za32_s32_vg1x4)))
+svint32x4_t svreadz_za32_s32_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_u64_vg1x2)))
+svuint64x2_t svreadz_za64_u64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_f64_vg1x2)))
+svfloat64x2_t svreadz_za64_f64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_s64_vg1x2)))
+svint64x2_t svreadz_za64_s64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_u64_vg1x4)))
+svuint64x4_t svreadz_za64_u64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_f64_vg1x4)))
+svfloat64x4_t svreadz_za64_f64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za64_s64_vg1x4)))
+svint64x4_t svreadz_za64_s64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za8_u8_vg1x2)))
+svuint8x2_t svreadz_za8_u8_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za8_s8_vg1x2)))
+svint8x2_t svreadz_za8_s8_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za8_u8_vg1x4)))
+svuint8x4_t svreadz_za8_u8_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svreadz_za8_s8_vg1x4)))
+svint8x4_t svreadz_za8_s8_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg1x2)))
+void svzero_za64_vg1x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg1x4)))
+void svzero_za64_vg1x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg2x1)))
+void svzero_za64_vg2x1(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg2x2)))
+void svzero_za64_vg2x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg2x4)))
+void svzero_za64_vg2x4(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg4x1)))
+void svzero_za64_vg4x1(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg4x2)))
+void svzero_za64_vg4x2(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sme_svzero_za64_vg4x4)))
+void svzero_za64_vg4x4(uint32_t);
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#undef __ai
+
+#endif /* __ARM_SME_H */
diff --git a/third_party/aarch64/clang/arm_sve.h b/third_party/aarch64/clang/arm_sve.h
new file mode 100644
index 000000000..f9aa68374
--- /dev/null
+++ b/third_party/aarch64/clang/arm_sve.h
@@ -0,0 +1,30537 @@
+/*===---- arm_sve.h - ARM SVE intrinsics -----------------------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ARM_SVE_H
+#define __ARM_SVE_H
+
+#if !defined(__LITTLE_ENDIAN__)
+#error "Big endian is currently not supported for arm_sve.h"
+#endif
+#include <stdint.h>
+
+#ifdef  __cplusplus
+extern "C" {
+#else
+#include <stdbool.h>
+#endif
+
+typedef __fp16 float16_t;
+typedef float float32_t;
+typedef double float64_t;
+typedef __SVInt8_t svint8_t;
+typedef __SVInt16_t svint16_t;
+typedef __SVInt32_t svint32_t;
+typedef __SVInt64_t svint64_t;
+typedef __SVUint8_t svuint8_t;
+typedef __SVUint16_t svuint16_t;
+typedef __SVUint32_t svuint32_t;
+typedef __SVUint64_t svuint64_t;
+typedef __SVFloat16_t svfloat16_t;
+
+typedef __SVBfloat16_t svbfloat16_t;
+#include <arm_bf16.h>
+#include <arm_vector_types.h>
+typedef __SVFloat32_t svfloat32_t;
+typedef __SVFloat64_t svfloat64_t;
+typedef __clang_svint8x2_t svint8x2_t;
+typedef __clang_svint16x2_t svint16x2_t;
+typedef __clang_svint32x2_t svint32x2_t;
+typedef __clang_svint64x2_t svint64x2_t;
+typedef __clang_svuint8x2_t svuint8x2_t;
+typedef __clang_svuint16x2_t svuint16x2_t;
+typedef __clang_svuint32x2_t svuint32x2_t;
+typedef __clang_svuint64x2_t svuint64x2_t;
+typedef __clang_svfloat16x2_t svfloat16x2_t;
+typedef __clang_svfloat32x2_t svfloat32x2_t;
+typedef __clang_svfloat64x2_t svfloat64x2_t;
+typedef __clang_svint8x3_t svint8x3_t;
+typedef __clang_svint16x3_t svint16x3_t;
+typedef __clang_svint32x3_t svint32x3_t;
+typedef __clang_svint64x3_t svint64x3_t;
+typedef __clang_svuint8x3_t svuint8x3_t;
+typedef __clang_svuint16x3_t svuint16x3_t;
+typedef __clang_svuint32x3_t svuint32x3_t;
+typedef __clang_svuint64x3_t svuint64x3_t;
+typedef __clang_svfloat16x3_t svfloat16x3_t;
+typedef __clang_svfloat32x3_t svfloat32x3_t;
+typedef __clang_svfloat64x3_t svfloat64x3_t;
+typedef __clang_svint8x4_t svint8x4_t;
+typedef __clang_svint16x4_t svint16x4_t;
+typedef __clang_svint32x4_t svint32x4_t;
+typedef __clang_svint64x4_t svint64x4_t;
+typedef __clang_svuint8x4_t svuint8x4_t;
+typedef __clang_svuint16x4_t svuint16x4_t;
+typedef __clang_svuint32x4_t svuint32x4_t;
+typedef __clang_svuint64x4_t svuint64x4_t;
+typedef __clang_svfloat16x4_t svfloat16x4_t;
+typedef __clang_svfloat32x4_t svfloat32x4_t;
+typedef __clang_svfloat64x4_t svfloat64x4_t;
+typedef __SVBool_t  svbool_t;
+typedef __clang_svboolx2_t  svboolx2_t;
+typedef __clang_svboolx4_t  svboolx4_t;
+
+typedef __clang_svbfloat16x2_t svbfloat16x2_t;
+typedef __clang_svbfloat16x3_t svbfloat16x3_t;
+typedef __clang_svbfloat16x4_t svbfloat16x4_t;
+typedef __SVCount_t svcount_t;
+
+enum svpattern
+{
+  SV_POW2 = 0,
+  SV_VL1 = 1,
+  SV_VL2 = 2,
+  SV_VL3 = 3,
+  SV_VL4 = 4,
+  SV_VL5 = 5,
+  SV_VL6 = 6,
+  SV_VL7 = 7,
+  SV_VL8 = 8,
+  SV_VL16 = 9,
+  SV_VL32 = 10,
+  SV_VL64 = 11,
+  SV_VL128 = 12,
+  SV_VL256 = 13,
+  SV_MUL4 = 29,
+  SV_MUL3 = 30,
+  SV_ALL = 31
+};
+
+enum svprfop
+{
+  SV_PLDL1KEEP = 0,
+  SV_PLDL1STRM = 1,
+  SV_PLDL2KEEP = 2,
+  SV_PLDL2STRM = 3,
+  SV_PLDL3KEEP = 4,
+  SV_PLDL3STRM = 5,
+  SV_PSTL1KEEP = 8,
+  SV_PSTL1STRM = 9,
+  SV_PSTL2KEEP = 10,
+  SV_PSTL2STRM = 11,
+  SV_PSTL3KEEP = 12,
+  SV_PSTL3STRM = 13
+};
+
+/* Function attributes */
+#define __ai static __inline__ __attribute__((__always_inline__, __nodebug__))
+
+#define __aio static __inline__ __attribute__((__always_inline__, __nodebug__, __overloadable__))
+
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8)))
+svint8_t svreinterpret_s8_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8)))
+svint8_t svreinterpret_s8_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16)))
+svint8_t svreinterpret_s8_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16)))
+svint8_t svreinterpret_s8_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32)))
+svint8_t svreinterpret_s8_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32)))
+svint8_t svreinterpret_s8_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64)))
+svint8_t svreinterpret_s8_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64)))
+svint8_t svreinterpret_s8_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16)))
+svint8_t svreinterpret_s8_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16)))
+svint8_t svreinterpret_s8_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32)))
+svint8_t svreinterpret_s8_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64)))
+svint8_t svreinterpret_s8_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8)))
+svuint8_t svreinterpret_u8_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8)))
+svuint8_t svreinterpret_u8_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16)))
+svuint8_t svreinterpret_u8_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16)))
+svuint8_t svreinterpret_u8_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32)))
+svuint8_t svreinterpret_u8_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32)))
+svuint8_t svreinterpret_u8_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64)))
+svuint8_t svreinterpret_u8_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64)))
+svuint8_t svreinterpret_u8_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16)))
+svuint8_t svreinterpret_u8_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16)))
+svuint8_t svreinterpret_u8_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32)))
+svuint8_t svreinterpret_u8_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64)))
+svuint8_t svreinterpret_u8_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8)))
+svint16_t svreinterpret_s16_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8)))
+svint16_t svreinterpret_s16_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16)))
+svint16_t svreinterpret_s16_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16)))
+svint16_t svreinterpret_s16_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32)))
+svint16_t svreinterpret_s16_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32)))
+svint16_t svreinterpret_s16_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64)))
+svint16_t svreinterpret_s16_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64)))
+svint16_t svreinterpret_s16_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16)))
+svint16_t svreinterpret_s16_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16)))
+svint16_t svreinterpret_s16_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32)))
+svint16_t svreinterpret_s16_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64)))
+svint16_t svreinterpret_s16_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8)))
+svuint16_t svreinterpret_u16_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8)))
+svuint16_t svreinterpret_u16_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16)))
+svuint16_t svreinterpret_u16_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16)))
+svuint16_t svreinterpret_u16_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32)))
+svuint16_t svreinterpret_u16_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32)))
+svuint16_t svreinterpret_u16_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64)))
+svuint16_t svreinterpret_u16_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64)))
+svuint16_t svreinterpret_u16_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16)))
+svuint16_t svreinterpret_u16_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16)))
+svuint16_t svreinterpret_u16_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32)))
+svuint16_t svreinterpret_u16_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64)))
+svuint16_t svreinterpret_u16_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8)))
+svint32_t svreinterpret_s32_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8)))
+svint32_t svreinterpret_s32_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16)))
+svint32_t svreinterpret_s32_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16)))
+svint32_t svreinterpret_s32_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32)))
+svint32_t svreinterpret_s32_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32)))
+svint32_t svreinterpret_s32_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64)))
+svint32_t svreinterpret_s32_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64)))
+svint32_t svreinterpret_s32_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16)))
+svint32_t svreinterpret_s32_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16)))
+svint32_t svreinterpret_s32_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32)))
+svint32_t svreinterpret_s32_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64)))
+svint32_t svreinterpret_s32_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8)))
+svuint32_t svreinterpret_u32_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8)))
+svuint32_t svreinterpret_u32_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16)))
+svuint32_t svreinterpret_u32_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16)))
+svuint32_t svreinterpret_u32_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32)))
+svuint32_t svreinterpret_u32_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32)))
+svuint32_t svreinterpret_u32_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64)))
+svuint32_t svreinterpret_u32_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64)))
+svuint32_t svreinterpret_u32_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16)))
+svuint32_t svreinterpret_u32_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16)))
+svuint32_t svreinterpret_u32_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32)))
+svuint32_t svreinterpret_u32_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64)))
+svuint32_t svreinterpret_u32_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8)))
+svint64_t svreinterpret_s64_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8)))
+svint64_t svreinterpret_s64_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16)))
+svint64_t svreinterpret_s64_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16)))
+svint64_t svreinterpret_s64_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32)))
+svint64_t svreinterpret_s64_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32)))
+svint64_t svreinterpret_s64_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64)))
+svint64_t svreinterpret_s64_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64)))
+svint64_t svreinterpret_s64_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16)))
+svint64_t svreinterpret_s64_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16)))
+svint64_t svreinterpret_s64_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32)))
+svint64_t svreinterpret_s64_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64)))
+svint64_t svreinterpret_s64_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8)))
+svuint64_t svreinterpret_u64_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8)))
+svuint64_t svreinterpret_u64_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16)))
+svuint64_t svreinterpret_u64_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16)))
+svuint64_t svreinterpret_u64_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32)))
+svuint64_t svreinterpret_u64_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32)))
+svuint64_t svreinterpret_u64_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64)))
+svuint64_t svreinterpret_u64_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64)))
+svuint64_t svreinterpret_u64_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16)))
+svuint64_t svreinterpret_u64_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16)))
+svuint64_t svreinterpret_u64_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32)))
+svuint64_t svreinterpret_u64_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64)))
+svuint64_t svreinterpret_u64_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8)))
+svfloat16_t svreinterpret_f16_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8)))
+svfloat16_t svreinterpret_f16_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16)))
+svfloat16_t svreinterpret_f16_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16)))
+svfloat16_t svreinterpret_f16_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32)))
+svfloat16_t svreinterpret_f16_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32)))
+svfloat16_t svreinterpret_f16_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64)))
+svfloat16_t svreinterpret_f16_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64)))
+svfloat16_t svreinterpret_f16_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16)))
+svfloat16_t svreinterpret_f16_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16)))
+svfloat16_t svreinterpret_f16_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32)))
+svfloat16_t svreinterpret_f16_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64)))
+svfloat16_t svreinterpret_f16_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8)))
+svbfloat16_t svreinterpret_bf16_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8)))
+svbfloat16_t svreinterpret_bf16_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16)))
+svbfloat16_t svreinterpret_bf16_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16)))
+svbfloat16_t svreinterpret_bf16_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32)))
+svbfloat16_t svreinterpret_bf16_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32)))
+svbfloat16_t svreinterpret_bf16_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64)))
+svbfloat16_t svreinterpret_bf16_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64)))
+svbfloat16_t svreinterpret_bf16_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16)))
+svbfloat16_t svreinterpret_bf16_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16)))
+svbfloat16_t svreinterpret_bf16_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32)))
+svbfloat16_t svreinterpret_bf16_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64)))
+svbfloat16_t svreinterpret_bf16_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8)))
+svfloat32_t svreinterpret_f32_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8)))
+svfloat32_t svreinterpret_f32_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16)))
+svfloat32_t svreinterpret_f32_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16)))
+svfloat32_t svreinterpret_f32_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32)))
+svfloat32_t svreinterpret_f32_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32)))
+svfloat32_t svreinterpret_f32_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64)))
+svfloat32_t svreinterpret_f32_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64)))
+svfloat32_t svreinterpret_f32_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16)))
+svfloat32_t svreinterpret_f32_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16)))
+svfloat32_t svreinterpret_f32_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32)))
+svfloat32_t svreinterpret_f32_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64)))
+svfloat32_t svreinterpret_f32_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8)))
+svfloat64_t svreinterpret_f64_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8)))
+svfloat64_t svreinterpret_f64_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16)))
+svfloat64_t svreinterpret_f64_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16)))
+svfloat64_t svreinterpret_f64_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32)))
+svfloat64_t svreinterpret_f64_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32)))
+svfloat64_t svreinterpret_f64_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64)))
+svfloat64_t svreinterpret_f64_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64)))
+svfloat64_t svreinterpret_f64_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16)))
+svfloat64_t svreinterpret_f64_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16)))
+svfloat64_t svreinterpret_f64_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32)))
+svfloat64_t svreinterpret_f64_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64)))
+svfloat64_t svreinterpret_f64_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8)))
+svint8_t svreinterpret_s8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8)))
+svint8_t svreinterpret_s8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16)))
+svint8_t svreinterpret_s8(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16)))
+svint8_t svreinterpret_s8(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32)))
+svint8_t svreinterpret_s8(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32)))
+svint8_t svreinterpret_s8(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64)))
+svint8_t svreinterpret_s8(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64)))
+svint8_t svreinterpret_s8(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16)))
+svint8_t svreinterpret_s8(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16)))
+svint8_t svreinterpret_s8(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32)))
+svint8_t svreinterpret_s8(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64)))
+svint8_t svreinterpret_s8(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8)))
+svuint8_t svreinterpret_u8(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8)))
+svuint8_t svreinterpret_u8(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16)))
+svuint8_t svreinterpret_u8(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16)))
+svuint8_t svreinterpret_u8(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32)))
+svuint8_t svreinterpret_u8(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32)))
+svuint8_t svreinterpret_u8(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64)))
+svuint8_t svreinterpret_u8(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64)))
+svuint8_t svreinterpret_u8(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16)))
+svuint8_t svreinterpret_u8(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16)))
+svuint8_t svreinterpret_u8(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32)))
+svuint8_t svreinterpret_u8(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64)))
+svuint8_t svreinterpret_u8(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8)))
+svint16_t svreinterpret_s16(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8)))
+svint16_t svreinterpret_s16(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16)))
+svint16_t svreinterpret_s16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16)))
+svint16_t svreinterpret_s16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32)))
+svint16_t svreinterpret_s16(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32)))
+svint16_t svreinterpret_s16(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64)))
+svint16_t svreinterpret_s16(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64)))
+svint16_t svreinterpret_s16(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16)))
+svint16_t svreinterpret_s16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16)))
+svint16_t svreinterpret_s16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32)))
+svint16_t svreinterpret_s16(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64)))
+svint16_t svreinterpret_s16(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8)))
+svuint16_t svreinterpret_u16(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8)))
+svuint16_t svreinterpret_u16(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16)))
+svuint16_t svreinterpret_u16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16)))
+svuint16_t svreinterpret_u16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32)))
+svuint16_t svreinterpret_u16(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32)))
+svuint16_t svreinterpret_u16(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64)))
+svuint16_t svreinterpret_u16(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64)))
+svuint16_t svreinterpret_u16(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16)))
+svuint16_t svreinterpret_u16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16)))
+svuint16_t svreinterpret_u16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32)))
+svuint16_t svreinterpret_u16(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64)))
+svuint16_t svreinterpret_u16(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8)))
+svint32_t svreinterpret_s32(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8)))
+svint32_t svreinterpret_s32(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16)))
+svint32_t svreinterpret_s32(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16)))
+svint32_t svreinterpret_s32(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32)))
+svint32_t svreinterpret_s32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32)))
+svint32_t svreinterpret_s32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64)))
+svint32_t svreinterpret_s32(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64)))
+svint32_t svreinterpret_s32(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16)))
+svint32_t svreinterpret_s32(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16)))
+svint32_t svreinterpret_s32(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32)))
+svint32_t svreinterpret_s32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64)))
+svint32_t svreinterpret_s32(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8)))
+svuint32_t svreinterpret_u32(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8)))
+svuint32_t svreinterpret_u32(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16)))
+svuint32_t svreinterpret_u32(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16)))
+svuint32_t svreinterpret_u32(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32)))
+svuint32_t svreinterpret_u32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32)))
+svuint32_t svreinterpret_u32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64)))
+svuint32_t svreinterpret_u32(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64)))
+svuint32_t svreinterpret_u32(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16)))
+svuint32_t svreinterpret_u32(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16)))
+svuint32_t svreinterpret_u32(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32)))
+svuint32_t svreinterpret_u32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64)))
+svuint32_t svreinterpret_u32(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8)))
+svint64_t svreinterpret_s64(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8)))
+svint64_t svreinterpret_s64(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16)))
+svint64_t svreinterpret_s64(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16)))
+svint64_t svreinterpret_s64(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32)))
+svint64_t svreinterpret_s64(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32)))
+svint64_t svreinterpret_s64(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64)))
+svint64_t svreinterpret_s64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64)))
+svint64_t svreinterpret_s64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16)))
+svint64_t svreinterpret_s64(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16)))
+svint64_t svreinterpret_s64(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32)))
+svint64_t svreinterpret_s64(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64)))
+svint64_t svreinterpret_s64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8)))
+svuint64_t svreinterpret_u64(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8)))
+svuint64_t svreinterpret_u64(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16)))
+svuint64_t svreinterpret_u64(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16)))
+svuint64_t svreinterpret_u64(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32)))
+svuint64_t svreinterpret_u64(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32)))
+svuint64_t svreinterpret_u64(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64)))
+svuint64_t svreinterpret_u64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64)))
+svuint64_t svreinterpret_u64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16)))
+svuint64_t svreinterpret_u64(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16)))
+svuint64_t svreinterpret_u64(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32)))
+svuint64_t svreinterpret_u64(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64)))
+svuint64_t svreinterpret_u64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8)))
+svfloat16_t svreinterpret_f16(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8)))
+svfloat16_t svreinterpret_f16(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16)))
+svfloat16_t svreinterpret_f16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16)))
+svfloat16_t svreinterpret_f16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32)))
+svfloat16_t svreinterpret_f16(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32)))
+svfloat16_t svreinterpret_f16(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64)))
+svfloat16_t svreinterpret_f16(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64)))
+svfloat16_t svreinterpret_f16(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16)))
+svfloat16_t svreinterpret_f16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16)))
+svfloat16_t svreinterpret_f16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32)))
+svfloat16_t svreinterpret_f16(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64)))
+svfloat16_t svreinterpret_f16(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8)))
+svbfloat16_t svreinterpret_bf16(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8)))
+svbfloat16_t svreinterpret_bf16(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16)))
+svbfloat16_t svreinterpret_bf16(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16)))
+svbfloat16_t svreinterpret_bf16(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32)))
+svbfloat16_t svreinterpret_bf16(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32)))
+svbfloat16_t svreinterpret_bf16(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64)))
+svbfloat16_t svreinterpret_bf16(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64)))
+svbfloat16_t svreinterpret_bf16(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16)))
+svbfloat16_t svreinterpret_bf16(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16)))
+svbfloat16_t svreinterpret_bf16(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32)))
+svbfloat16_t svreinterpret_bf16(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64)))
+svbfloat16_t svreinterpret_bf16(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8)))
+svfloat32_t svreinterpret_f32(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8)))
+svfloat32_t svreinterpret_f32(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16)))
+svfloat32_t svreinterpret_f32(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16)))
+svfloat32_t svreinterpret_f32(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32)))
+svfloat32_t svreinterpret_f32(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32)))
+svfloat32_t svreinterpret_f32(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64)))
+svfloat32_t svreinterpret_f32(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64)))
+svfloat32_t svreinterpret_f32(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16)))
+svfloat32_t svreinterpret_f32(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16)))
+svfloat32_t svreinterpret_f32(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32)))
+svfloat32_t svreinterpret_f32(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64)))
+svfloat32_t svreinterpret_f32(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8)))
+svfloat64_t svreinterpret_f64(svint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8)))
+svfloat64_t svreinterpret_f64(svuint8_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16)))
+svfloat64_t svreinterpret_f64(svint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16)))
+svfloat64_t svreinterpret_f64(svuint16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32)))
+svfloat64_t svreinterpret_f64(svint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32)))
+svfloat64_t svreinterpret_f64(svuint32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64)))
+svfloat64_t svreinterpret_f64(svint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64)))
+svfloat64_t svreinterpret_f64(svuint64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16)))
+svfloat64_t svreinterpret_f64(svfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16)))
+svfloat64_t svreinterpret_f64(svbfloat16_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32)))
+svfloat64_t svreinterpret_f64(svfloat32_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64)))
+svfloat64_t svreinterpret_f64(svfloat64_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x2)))
+svint8x2_t svreinterpret_s8_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x2)))
+svint8x2_t svreinterpret_s8_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x2)))
+svint8x2_t svreinterpret_s8_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x2)))
+svint8x2_t svreinterpret_s8_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x2)))
+svint8x2_t svreinterpret_s8_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x2)))
+svint8x2_t svreinterpret_s8_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x2)))
+svint8x2_t svreinterpret_s8_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x2)))
+svint8x2_t svreinterpret_s8_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x2)))
+svint8x2_t svreinterpret_s8_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x2)))
+svint8x2_t svreinterpret_s8_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x2)))
+svint8x2_t svreinterpret_s8_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x2)))
+svint8x2_t svreinterpret_s8_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x2)))
+svuint8x2_t svreinterpret_u8_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x2)))
+svuint8x2_t svreinterpret_u8_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x2)))
+svuint8x2_t svreinterpret_u8_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x2)))
+svuint8x2_t svreinterpret_u8_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x2)))
+svuint8x2_t svreinterpret_u8_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x2)))
+svuint8x2_t svreinterpret_u8_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x2)))
+svuint8x2_t svreinterpret_u8_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x2)))
+svuint8x2_t svreinterpret_u8_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x2)))
+svuint8x2_t svreinterpret_u8_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x2)))
+svuint8x2_t svreinterpret_u8_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x2)))
+svuint8x2_t svreinterpret_u8_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x2)))
+svuint8x2_t svreinterpret_u8_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x2)))
+svint16x2_t svreinterpret_s16_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x2)))
+svint16x2_t svreinterpret_s16_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x2)))
+svint16x2_t svreinterpret_s16_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x2)))
+svint16x2_t svreinterpret_s16_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x2)))
+svint16x2_t svreinterpret_s16_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x2)))
+svint16x2_t svreinterpret_s16_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x2)))
+svint16x2_t svreinterpret_s16_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x2)))
+svint16x2_t svreinterpret_s16_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x2)))
+svint16x2_t svreinterpret_s16_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x2)))
+svint16x2_t svreinterpret_s16_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x2)))
+svint16x2_t svreinterpret_s16_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x2)))
+svint16x2_t svreinterpret_s16_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x2)))
+svuint16x2_t svreinterpret_u16_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x2)))
+svuint16x2_t svreinterpret_u16_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x2)))
+svuint16x2_t svreinterpret_u16_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x2)))
+svuint16x2_t svreinterpret_u16_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x2)))
+svuint16x2_t svreinterpret_u16_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x2)))
+svuint16x2_t svreinterpret_u16_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x2)))
+svuint16x2_t svreinterpret_u16_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x2)))
+svuint16x2_t svreinterpret_u16_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x2)))
+svuint16x2_t svreinterpret_u16_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x2)))
+svuint16x2_t svreinterpret_u16_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x2)))
+svuint16x2_t svreinterpret_u16_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x2)))
+svuint16x2_t svreinterpret_u16_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x2)))
+svint32x2_t svreinterpret_s32_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x2)))
+svint32x2_t svreinterpret_s32_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x2)))
+svint32x2_t svreinterpret_s32_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x2)))
+svint32x2_t svreinterpret_s32_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x2)))
+svint32x2_t svreinterpret_s32_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x2)))
+svint32x2_t svreinterpret_s32_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x2)))
+svint32x2_t svreinterpret_s32_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x2)))
+svint32x2_t svreinterpret_s32_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x2)))
+svint32x2_t svreinterpret_s32_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x2)))
+svint32x2_t svreinterpret_s32_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x2)))
+svint32x2_t svreinterpret_s32_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x2)))
+svint32x2_t svreinterpret_s32_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x2)))
+svuint32x2_t svreinterpret_u32_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x2)))
+svuint32x2_t svreinterpret_u32_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x2)))
+svuint32x2_t svreinterpret_u32_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x2)))
+svuint32x2_t svreinterpret_u32_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x2)))
+svuint32x2_t svreinterpret_u32_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x2)))
+svuint32x2_t svreinterpret_u32_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x2)))
+svuint32x2_t svreinterpret_u32_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x2)))
+svuint32x2_t svreinterpret_u32_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x2)))
+svuint32x2_t svreinterpret_u32_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x2)))
+svuint32x2_t svreinterpret_u32_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x2)))
+svuint32x2_t svreinterpret_u32_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x2)))
+svuint32x2_t svreinterpret_u32_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x2)))
+svint64x2_t svreinterpret_s64_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x2)))
+svint64x2_t svreinterpret_s64_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x2)))
+svint64x2_t svreinterpret_s64_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x2)))
+svint64x2_t svreinterpret_s64_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x2)))
+svint64x2_t svreinterpret_s64_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x2)))
+svint64x2_t svreinterpret_s64_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x2)))
+svint64x2_t svreinterpret_s64_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x2)))
+svint64x2_t svreinterpret_s64_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x2)))
+svint64x2_t svreinterpret_s64_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x2)))
+svint64x2_t svreinterpret_s64_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x2)))
+svint64x2_t svreinterpret_s64_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x2)))
+svint64x2_t svreinterpret_s64_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x2)))
+svuint64x2_t svreinterpret_u64_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x2)))
+svuint64x2_t svreinterpret_u64_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x2)))
+svuint64x2_t svreinterpret_u64_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x2)))
+svuint64x2_t svreinterpret_u64_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x2)))
+svuint64x2_t svreinterpret_u64_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x2)))
+svuint64x2_t svreinterpret_u64_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x2)))
+svuint64x2_t svreinterpret_u64_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x2)))
+svuint64x2_t svreinterpret_u64_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x2)))
+svuint64x2_t svreinterpret_u64_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x2)))
+svuint64x2_t svreinterpret_u64_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x2)))
+svuint64x2_t svreinterpret_u64_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x2)))
+svuint64x2_t svreinterpret_u64_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x2)))
+svfloat16x2_t svreinterpret_f16_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x2)))
+svfloat16x2_t svreinterpret_f16_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x2)))
+svfloat16x2_t svreinterpret_f16_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x2)))
+svfloat16x2_t svreinterpret_f16_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x2)))
+svfloat16x2_t svreinterpret_f16_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x2)))
+svfloat16x2_t svreinterpret_f16_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x2)))
+svfloat16x2_t svreinterpret_f16_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x2)))
+svfloat16x2_t svreinterpret_f16_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x2)))
+svfloat16x2_t svreinterpret_f16_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x2)))
+svfloat16x2_t svreinterpret_f16_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x2)))
+svfloat16x2_t svreinterpret_f16_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x2)))
+svfloat16x2_t svreinterpret_f16_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x2)))
+svbfloat16x2_t svreinterpret_bf16_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x2)))
+svbfloat16x2_t svreinterpret_bf16_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x2)))
+svbfloat16x2_t svreinterpret_bf16_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x2)))
+svbfloat16x2_t svreinterpret_bf16_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x2)))
+svbfloat16x2_t svreinterpret_bf16_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x2)))
+svbfloat16x2_t svreinterpret_bf16_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x2)))
+svbfloat16x2_t svreinterpret_bf16_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x2)))
+svbfloat16x2_t svreinterpret_bf16_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x2)))
+svbfloat16x2_t svreinterpret_bf16_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x2)))
+svbfloat16x2_t svreinterpret_bf16_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x2)))
+svbfloat16x2_t svreinterpret_bf16_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x2)))
+svbfloat16x2_t svreinterpret_bf16_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x2)))
+svfloat32x2_t svreinterpret_f32_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x2)))
+svfloat32x2_t svreinterpret_f32_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x2)))
+svfloat32x2_t svreinterpret_f32_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x2)))
+svfloat32x2_t svreinterpret_f32_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x2)))
+svfloat32x2_t svreinterpret_f32_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x2)))
+svfloat32x2_t svreinterpret_f32_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x2)))
+svfloat32x2_t svreinterpret_f32_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x2)))
+svfloat32x2_t svreinterpret_f32_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x2)))
+svfloat32x2_t svreinterpret_f32_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x2)))
+svfloat32x2_t svreinterpret_f32_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x2)))
+svfloat32x2_t svreinterpret_f32_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x2)))
+svfloat32x2_t svreinterpret_f32_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x2)))
+svfloat64x2_t svreinterpret_f64_s8_x2(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x2)))
+svfloat64x2_t svreinterpret_f64_u8_x2(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x2)))
+svfloat64x2_t svreinterpret_f64_s16_x2(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x2)))
+svfloat64x2_t svreinterpret_f64_u16_x2(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x2)))
+svfloat64x2_t svreinterpret_f64_s32_x2(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x2)))
+svfloat64x2_t svreinterpret_f64_u32_x2(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x2)))
+svfloat64x2_t svreinterpret_f64_s64_x2(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x2)))
+svfloat64x2_t svreinterpret_f64_u64_x2(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x2)))
+svfloat64x2_t svreinterpret_f64_f16_x2(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x2)))
+svfloat64x2_t svreinterpret_f64_bf16_x2(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x2)))
+svfloat64x2_t svreinterpret_f64_f32_x2(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x2)))
+svfloat64x2_t svreinterpret_f64_f64_x2(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x2)))
+svint8x2_t svreinterpret_s8(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x2)))
+svint8x2_t svreinterpret_s8(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x2)))
+svint8x2_t svreinterpret_s8(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x2)))
+svint8x2_t svreinterpret_s8(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x2)))
+svint8x2_t svreinterpret_s8(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x2)))
+svint8x2_t svreinterpret_s8(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x2)))
+svint8x2_t svreinterpret_s8(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x2)))
+svint8x2_t svreinterpret_s8(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x2)))
+svint8x2_t svreinterpret_s8(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x2)))
+svint8x2_t svreinterpret_s8(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x2)))
+svint8x2_t svreinterpret_s8(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x2)))
+svint8x2_t svreinterpret_s8(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x2)))
+svuint8x2_t svreinterpret_u8(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x2)))
+svuint8x2_t svreinterpret_u8(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x2)))
+svuint8x2_t svreinterpret_u8(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x2)))
+svuint8x2_t svreinterpret_u8(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x2)))
+svuint8x2_t svreinterpret_u8(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x2)))
+svuint8x2_t svreinterpret_u8(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x2)))
+svuint8x2_t svreinterpret_u8(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x2)))
+svuint8x2_t svreinterpret_u8(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x2)))
+svuint8x2_t svreinterpret_u8(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x2)))
+svuint8x2_t svreinterpret_u8(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x2)))
+svuint8x2_t svreinterpret_u8(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x2)))
+svuint8x2_t svreinterpret_u8(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x2)))
+svint16x2_t svreinterpret_s16(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x2)))
+svint16x2_t svreinterpret_s16(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x2)))
+svint16x2_t svreinterpret_s16(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x2)))
+svint16x2_t svreinterpret_s16(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x2)))
+svint16x2_t svreinterpret_s16(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x2)))
+svint16x2_t svreinterpret_s16(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x2)))
+svint16x2_t svreinterpret_s16(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x2)))
+svint16x2_t svreinterpret_s16(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x2)))
+svint16x2_t svreinterpret_s16(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x2)))
+svint16x2_t svreinterpret_s16(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x2)))
+svint16x2_t svreinterpret_s16(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x2)))
+svint16x2_t svreinterpret_s16(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x2)))
+svuint16x2_t svreinterpret_u16(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x2)))
+svuint16x2_t svreinterpret_u16(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x2)))
+svuint16x2_t svreinterpret_u16(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x2)))
+svuint16x2_t svreinterpret_u16(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x2)))
+svuint16x2_t svreinterpret_u16(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x2)))
+svuint16x2_t svreinterpret_u16(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x2)))
+svuint16x2_t svreinterpret_u16(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x2)))
+svuint16x2_t svreinterpret_u16(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x2)))
+svuint16x2_t svreinterpret_u16(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x2)))
+svuint16x2_t svreinterpret_u16(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x2)))
+svuint16x2_t svreinterpret_u16(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x2)))
+svuint16x2_t svreinterpret_u16(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x2)))
+svint32x2_t svreinterpret_s32(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x2)))
+svint32x2_t svreinterpret_s32(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x2)))
+svint32x2_t svreinterpret_s32(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x2)))
+svint32x2_t svreinterpret_s32(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x2)))
+svint32x2_t svreinterpret_s32(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x2)))
+svint32x2_t svreinterpret_s32(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x2)))
+svint32x2_t svreinterpret_s32(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x2)))
+svint32x2_t svreinterpret_s32(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x2)))
+svint32x2_t svreinterpret_s32(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x2)))
+svint32x2_t svreinterpret_s32(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x2)))
+svint32x2_t svreinterpret_s32(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x2)))
+svint32x2_t svreinterpret_s32(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x2)))
+svuint32x2_t svreinterpret_u32(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x2)))
+svuint32x2_t svreinterpret_u32(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x2)))
+svuint32x2_t svreinterpret_u32(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x2)))
+svuint32x2_t svreinterpret_u32(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x2)))
+svuint32x2_t svreinterpret_u32(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x2)))
+svuint32x2_t svreinterpret_u32(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x2)))
+svuint32x2_t svreinterpret_u32(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x2)))
+svuint32x2_t svreinterpret_u32(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x2)))
+svuint32x2_t svreinterpret_u32(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x2)))
+svuint32x2_t svreinterpret_u32(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x2)))
+svuint32x2_t svreinterpret_u32(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x2)))
+svuint32x2_t svreinterpret_u32(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x2)))
+svint64x2_t svreinterpret_s64(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x2)))
+svint64x2_t svreinterpret_s64(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x2)))
+svint64x2_t svreinterpret_s64(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x2)))
+svint64x2_t svreinterpret_s64(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x2)))
+svint64x2_t svreinterpret_s64(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x2)))
+svint64x2_t svreinterpret_s64(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x2)))
+svint64x2_t svreinterpret_s64(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x2)))
+svint64x2_t svreinterpret_s64(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x2)))
+svint64x2_t svreinterpret_s64(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x2)))
+svint64x2_t svreinterpret_s64(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x2)))
+svint64x2_t svreinterpret_s64(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x2)))
+svint64x2_t svreinterpret_s64(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x2)))
+svuint64x2_t svreinterpret_u64(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x2)))
+svuint64x2_t svreinterpret_u64(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x2)))
+svuint64x2_t svreinterpret_u64(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x2)))
+svuint64x2_t svreinterpret_u64(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x2)))
+svuint64x2_t svreinterpret_u64(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x2)))
+svuint64x2_t svreinterpret_u64(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x2)))
+svuint64x2_t svreinterpret_u64(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x2)))
+svuint64x2_t svreinterpret_u64(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x2)))
+svuint64x2_t svreinterpret_u64(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x2)))
+svuint64x2_t svreinterpret_u64(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x2)))
+svuint64x2_t svreinterpret_u64(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x2)))
+svuint64x2_t svreinterpret_u64(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x2)))
+svfloat16x2_t svreinterpret_f16(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x2)))
+svfloat16x2_t svreinterpret_f16(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x2)))
+svfloat16x2_t svreinterpret_f16(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x2)))
+svfloat16x2_t svreinterpret_f16(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x2)))
+svfloat16x2_t svreinterpret_f16(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x2)))
+svfloat16x2_t svreinterpret_f16(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x2)))
+svfloat16x2_t svreinterpret_f16(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x2)))
+svfloat16x2_t svreinterpret_f16(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x2)))
+svfloat16x2_t svreinterpret_f16(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x2)))
+svfloat16x2_t svreinterpret_f16(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x2)))
+svfloat16x2_t svreinterpret_f16(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x2)))
+svfloat16x2_t svreinterpret_f16(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x2)))
+svbfloat16x2_t svreinterpret_bf16(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x2)))
+svbfloat16x2_t svreinterpret_bf16(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x2)))
+svbfloat16x2_t svreinterpret_bf16(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x2)))
+svbfloat16x2_t svreinterpret_bf16(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x2)))
+svbfloat16x2_t svreinterpret_bf16(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x2)))
+svbfloat16x2_t svreinterpret_bf16(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x2)))
+svbfloat16x2_t svreinterpret_bf16(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x2)))
+svbfloat16x2_t svreinterpret_bf16(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x2)))
+svbfloat16x2_t svreinterpret_bf16(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x2)))
+svbfloat16x2_t svreinterpret_bf16(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x2)))
+svbfloat16x2_t svreinterpret_bf16(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x2)))
+svbfloat16x2_t svreinterpret_bf16(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x2)))
+svfloat32x2_t svreinterpret_f32(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x2)))
+svfloat32x2_t svreinterpret_f32(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x2)))
+svfloat32x2_t svreinterpret_f32(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x2)))
+svfloat32x2_t svreinterpret_f32(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x2)))
+svfloat32x2_t svreinterpret_f32(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x2)))
+svfloat32x2_t svreinterpret_f32(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x2)))
+svfloat32x2_t svreinterpret_f32(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x2)))
+svfloat32x2_t svreinterpret_f32(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x2)))
+svfloat32x2_t svreinterpret_f32(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x2)))
+svfloat32x2_t svreinterpret_f32(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x2)))
+svfloat32x2_t svreinterpret_f32(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x2)))
+svfloat32x2_t svreinterpret_f32(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x2)))
+svfloat64x2_t svreinterpret_f64(svint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x2)))
+svfloat64x2_t svreinterpret_f64(svuint8x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x2)))
+svfloat64x2_t svreinterpret_f64(svint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x2)))
+svfloat64x2_t svreinterpret_f64(svuint16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x2)))
+svfloat64x2_t svreinterpret_f64(svint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x2)))
+svfloat64x2_t svreinterpret_f64(svuint32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x2)))
+svfloat64x2_t svreinterpret_f64(svint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x2)))
+svfloat64x2_t svreinterpret_f64(svuint64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x2)))
+svfloat64x2_t svreinterpret_f64(svfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x2)))
+svfloat64x2_t svreinterpret_f64(svbfloat16x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x2)))
+svfloat64x2_t svreinterpret_f64(svfloat32x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x2)))
+svfloat64x2_t svreinterpret_f64(svfloat64x2_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x3)))
+svint8x3_t svreinterpret_s8_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x3)))
+svint8x3_t svreinterpret_s8_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x3)))
+svint8x3_t svreinterpret_s8_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x3)))
+svint8x3_t svreinterpret_s8_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x3)))
+svint8x3_t svreinterpret_s8_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x3)))
+svint8x3_t svreinterpret_s8_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x3)))
+svint8x3_t svreinterpret_s8_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x3)))
+svint8x3_t svreinterpret_s8_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x3)))
+svint8x3_t svreinterpret_s8_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x3)))
+svint8x3_t svreinterpret_s8_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x3)))
+svint8x3_t svreinterpret_s8_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x3)))
+svint8x3_t svreinterpret_s8_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x3)))
+svuint8x3_t svreinterpret_u8_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x3)))
+svuint8x3_t svreinterpret_u8_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x3)))
+svuint8x3_t svreinterpret_u8_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x3)))
+svuint8x3_t svreinterpret_u8_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x3)))
+svuint8x3_t svreinterpret_u8_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x3)))
+svuint8x3_t svreinterpret_u8_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x3)))
+svuint8x3_t svreinterpret_u8_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x3)))
+svuint8x3_t svreinterpret_u8_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x3)))
+svuint8x3_t svreinterpret_u8_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x3)))
+svuint8x3_t svreinterpret_u8_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x3)))
+svuint8x3_t svreinterpret_u8_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x3)))
+svuint8x3_t svreinterpret_u8_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x3)))
+svint16x3_t svreinterpret_s16_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x3)))
+svint16x3_t svreinterpret_s16_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x3)))
+svint16x3_t svreinterpret_s16_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x3)))
+svint16x3_t svreinterpret_s16_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x3)))
+svint16x3_t svreinterpret_s16_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x3)))
+svint16x3_t svreinterpret_s16_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x3)))
+svint16x3_t svreinterpret_s16_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x3)))
+svint16x3_t svreinterpret_s16_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x3)))
+svint16x3_t svreinterpret_s16_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x3)))
+svint16x3_t svreinterpret_s16_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x3)))
+svint16x3_t svreinterpret_s16_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x3)))
+svint16x3_t svreinterpret_s16_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x3)))
+svuint16x3_t svreinterpret_u16_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x3)))
+svuint16x3_t svreinterpret_u16_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x3)))
+svuint16x3_t svreinterpret_u16_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x3)))
+svuint16x3_t svreinterpret_u16_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x3)))
+svuint16x3_t svreinterpret_u16_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x3)))
+svuint16x3_t svreinterpret_u16_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x3)))
+svuint16x3_t svreinterpret_u16_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x3)))
+svuint16x3_t svreinterpret_u16_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x3)))
+svuint16x3_t svreinterpret_u16_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x3)))
+svuint16x3_t svreinterpret_u16_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x3)))
+svuint16x3_t svreinterpret_u16_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x3)))
+svuint16x3_t svreinterpret_u16_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x3)))
+svint32x3_t svreinterpret_s32_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x3)))
+svint32x3_t svreinterpret_s32_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x3)))
+svint32x3_t svreinterpret_s32_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x3)))
+svint32x3_t svreinterpret_s32_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x3)))
+svint32x3_t svreinterpret_s32_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x3)))
+svint32x3_t svreinterpret_s32_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x3)))
+svint32x3_t svreinterpret_s32_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x3)))
+svint32x3_t svreinterpret_s32_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x3)))
+svint32x3_t svreinterpret_s32_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x3)))
+svint32x3_t svreinterpret_s32_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x3)))
+svint32x3_t svreinterpret_s32_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x3)))
+svint32x3_t svreinterpret_s32_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x3)))
+svuint32x3_t svreinterpret_u32_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x3)))
+svuint32x3_t svreinterpret_u32_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x3)))
+svuint32x3_t svreinterpret_u32_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x3)))
+svuint32x3_t svreinterpret_u32_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x3)))
+svuint32x3_t svreinterpret_u32_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x3)))
+svuint32x3_t svreinterpret_u32_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x3)))
+svuint32x3_t svreinterpret_u32_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x3)))
+svuint32x3_t svreinterpret_u32_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x3)))
+svuint32x3_t svreinterpret_u32_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x3)))
+svuint32x3_t svreinterpret_u32_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x3)))
+svuint32x3_t svreinterpret_u32_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x3)))
+svuint32x3_t svreinterpret_u32_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x3)))
+svint64x3_t svreinterpret_s64_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x3)))
+svint64x3_t svreinterpret_s64_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x3)))
+svint64x3_t svreinterpret_s64_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x3)))
+svint64x3_t svreinterpret_s64_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x3)))
+svint64x3_t svreinterpret_s64_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x3)))
+svint64x3_t svreinterpret_s64_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x3)))
+svint64x3_t svreinterpret_s64_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x3)))
+svint64x3_t svreinterpret_s64_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x3)))
+svint64x3_t svreinterpret_s64_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x3)))
+svint64x3_t svreinterpret_s64_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x3)))
+svint64x3_t svreinterpret_s64_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x3)))
+svint64x3_t svreinterpret_s64_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x3)))
+svuint64x3_t svreinterpret_u64_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x3)))
+svuint64x3_t svreinterpret_u64_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x3)))
+svuint64x3_t svreinterpret_u64_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x3)))
+svuint64x3_t svreinterpret_u64_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x3)))
+svuint64x3_t svreinterpret_u64_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x3)))
+svuint64x3_t svreinterpret_u64_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x3)))
+svuint64x3_t svreinterpret_u64_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x3)))
+svuint64x3_t svreinterpret_u64_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x3)))
+svuint64x3_t svreinterpret_u64_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x3)))
+svuint64x3_t svreinterpret_u64_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x3)))
+svuint64x3_t svreinterpret_u64_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x3)))
+svuint64x3_t svreinterpret_u64_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x3)))
+svfloat16x3_t svreinterpret_f16_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x3)))
+svfloat16x3_t svreinterpret_f16_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x3)))
+svfloat16x3_t svreinterpret_f16_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x3)))
+svfloat16x3_t svreinterpret_f16_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x3)))
+svfloat16x3_t svreinterpret_f16_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x3)))
+svfloat16x3_t svreinterpret_f16_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x3)))
+svfloat16x3_t svreinterpret_f16_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x3)))
+svfloat16x3_t svreinterpret_f16_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x3)))
+svfloat16x3_t svreinterpret_f16_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x3)))
+svfloat16x3_t svreinterpret_f16_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x3)))
+svfloat16x3_t svreinterpret_f16_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x3)))
+svfloat16x3_t svreinterpret_f16_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x3)))
+svbfloat16x3_t svreinterpret_bf16_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x3)))
+svbfloat16x3_t svreinterpret_bf16_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x3)))
+svbfloat16x3_t svreinterpret_bf16_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x3)))
+svbfloat16x3_t svreinterpret_bf16_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x3)))
+svbfloat16x3_t svreinterpret_bf16_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x3)))
+svbfloat16x3_t svreinterpret_bf16_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x3)))
+svbfloat16x3_t svreinterpret_bf16_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x3)))
+svbfloat16x3_t svreinterpret_bf16_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x3)))
+svbfloat16x3_t svreinterpret_bf16_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x3)))
+svbfloat16x3_t svreinterpret_bf16_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x3)))
+svbfloat16x3_t svreinterpret_bf16_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x3)))
+svbfloat16x3_t svreinterpret_bf16_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x3)))
+svfloat32x3_t svreinterpret_f32_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x3)))
+svfloat32x3_t svreinterpret_f32_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x3)))
+svfloat32x3_t svreinterpret_f32_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x3)))
+svfloat32x3_t svreinterpret_f32_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x3)))
+svfloat32x3_t svreinterpret_f32_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x3)))
+svfloat32x3_t svreinterpret_f32_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x3)))
+svfloat32x3_t svreinterpret_f32_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x3)))
+svfloat32x3_t svreinterpret_f32_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x3)))
+svfloat32x3_t svreinterpret_f32_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x3)))
+svfloat32x3_t svreinterpret_f32_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x3)))
+svfloat32x3_t svreinterpret_f32_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x3)))
+svfloat32x3_t svreinterpret_f32_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x3)))
+svfloat64x3_t svreinterpret_f64_s8_x3(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x3)))
+svfloat64x3_t svreinterpret_f64_u8_x3(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x3)))
+svfloat64x3_t svreinterpret_f64_s16_x3(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x3)))
+svfloat64x3_t svreinterpret_f64_u16_x3(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x3)))
+svfloat64x3_t svreinterpret_f64_s32_x3(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x3)))
+svfloat64x3_t svreinterpret_f64_u32_x3(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x3)))
+svfloat64x3_t svreinterpret_f64_s64_x3(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x3)))
+svfloat64x3_t svreinterpret_f64_u64_x3(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x3)))
+svfloat64x3_t svreinterpret_f64_f16_x3(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x3)))
+svfloat64x3_t svreinterpret_f64_bf16_x3(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x3)))
+svfloat64x3_t svreinterpret_f64_f32_x3(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x3)))
+svfloat64x3_t svreinterpret_f64_f64_x3(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x3)))
+svint8x3_t svreinterpret_s8(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x3)))
+svint8x3_t svreinterpret_s8(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x3)))
+svint8x3_t svreinterpret_s8(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x3)))
+svint8x3_t svreinterpret_s8(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x3)))
+svint8x3_t svreinterpret_s8(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x3)))
+svint8x3_t svreinterpret_s8(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x3)))
+svint8x3_t svreinterpret_s8(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x3)))
+svint8x3_t svreinterpret_s8(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x3)))
+svint8x3_t svreinterpret_s8(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x3)))
+svint8x3_t svreinterpret_s8(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x3)))
+svint8x3_t svreinterpret_s8(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x3)))
+svint8x3_t svreinterpret_s8(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x3)))
+svuint8x3_t svreinterpret_u8(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x3)))
+svuint8x3_t svreinterpret_u8(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x3)))
+svuint8x3_t svreinterpret_u8(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x3)))
+svuint8x3_t svreinterpret_u8(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x3)))
+svuint8x3_t svreinterpret_u8(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x3)))
+svuint8x3_t svreinterpret_u8(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x3)))
+svuint8x3_t svreinterpret_u8(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x3)))
+svuint8x3_t svreinterpret_u8(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x3)))
+svuint8x3_t svreinterpret_u8(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x3)))
+svuint8x3_t svreinterpret_u8(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x3)))
+svuint8x3_t svreinterpret_u8(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x3)))
+svuint8x3_t svreinterpret_u8(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x3)))
+svint16x3_t svreinterpret_s16(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x3)))
+svint16x3_t svreinterpret_s16(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x3)))
+svint16x3_t svreinterpret_s16(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x3)))
+svint16x3_t svreinterpret_s16(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x3)))
+svint16x3_t svreinterpret_s16(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x3)))
+svint16x3_t svreinterpret_s16(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x3)))
+svint16x3_t svreinterpret_s16(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x3)))
+svint16x3_t svreinterpret_s16(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x3)))
+svint16x3_t svreinterpret_s16(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x3)))
+svint16x3_t svreinterpret_s16(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x3)))
+svint16x3_t svreinterpret_s16(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x3)))
+svint16x3_t svreinterpret_s16(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x3)))
+svuint16x3_t svreinterpret_u16(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x3)))
+svuint16x3_t svreinterpret_u16(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x3)))
+svuint16x3_t svreinterpret_u16(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x3)))
+svuint16x3_t svreinterpret_u16(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x3)))
+svuint16x3_t svreinterpret_u16(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x3)))
+svuint16x3_t svreinterpret_u16(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x3)))
+svuint16x3_t svreinterpret_u16(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x3)))
+svuint16x3_t svreinterpret_u16(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x3)))
+svuint16x3_t svreinterpret_u16(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x3)))
+svuint16x3_t svreinterpret_u16(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x3)))
+svuint16x3_t svreinterpret_u16(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x3)))
+svuint16x3_t svreinterpret_u16(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x3)))
+svint32x3_t svreinterpret_s32(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x3)))
+svint32x3_t svreinterpret_s32(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x3)))
+svint32x3_t svreinterpret_s32(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x3)))
+svint32x3_t svreinterpret_s32(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x3)))
+svint32x3_t svreinterpret_s32(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x3)))
+svint32x3_t svreinterpret_s32(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x3)))
+svint32x3_t svreinterpret_s32(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x3)))
+svint32x3_t svreinterpret_s32(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x3)))
+svint32x3_t svreinterpret_s32(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x3)))
+svint32x3_t svreinterpret_s32(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x3)))
+svint32x3_t svreinterpret_s32(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x3)))
+svint32x3_t svreinterpret_s32(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x3)))
+svuint32x3_t svreinterpret_u32(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x3)))
+svuint32x3_t svreinterpret_u32(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x3)))
+svuint32x3_t svreinterpret_u32(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x3)))
+svuint32x3_t svreinterpret_u32(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x3)))
+svuint32x3_t svreinterpret_u32(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x3)))
+svuint32x3_t svreinterpret_u32(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x3)))
+svuint32x3_t svreinterpret_u32(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x3)))
+svuint32x3_t svreinterpret_u32(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x3)))
+svuint32x3_t svreinterpret_u32(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x3)))
+svuint32x3_t svreinterpret_u32(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x3)))
+svuint32x3_t svreinterpret_u32(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x3)))
+svuint32x3_t svreinterpret_u32(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x3)))
+svint64x3_t svreinterpret_s64(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x3)))
+svint64x3_t svreinterpret_s64(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x3)))
+svint64x3_t svreinterpret_s64(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x3)))
+svint64x3_t svreinterpret_s64(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x3)))
+svint64x3_t svreinterpret_s64(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x3)))
+svint64x3_t svreinterpret_s64(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x3)))
+svint64x3_t svreinterpret_s64(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x3)))
+svint64x3_t svreinterpret_s64(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x3)))
+svint64x3_t svreinterpret_s64(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x3)))
+svint64x3_t svreinterpret_s64(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x3)))
+svint64x3_t svreinterpret_s64(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x3)))
+svint64x3_t svreinterpret_s64(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x3)))
+svuint64x3_t svreinterpret_u64(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x3)))
+svuint64x3_t svreinterpret_u64(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x3)))
+svuint64x3_t svreinterpret_u64(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x3)))
+svuint64x3_t svreinterpret_u64(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x3)))
+svuint64x3_t svreinterpret_u64(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x3)))
+svuint64x3_t svreinterpret_u64(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x3)))
+svuint64x3_t svreinterpret_u64(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x3)))
+svuint64x3_t svreinterpret_u64(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x3)))
+svuint64x3_t svreinterpret_u64(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x3)))
+svuint64x3_t svreinterpret_u64(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x3)))
+svuint64x3_t svreinterpret_u64(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x3)))
+svuint64x3_t svreinterpret_u64(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x3)))
+svfloat16x3_t svreinterpret_f16(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x3)))
+svfloat16x3_t svreinterpret_f16(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x3)))
+svfloat16x3_t svreinterpret_f16(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x3)))
+svfloat16x3_t svreinterpret_f16(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x3)))
+svfloat16x3_t svreinterpret_f16(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x3)))
+svfloat16x3_t svreinterpret_f16(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x3)))
+svfloat16x3_t svreinterpret_f16(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x3)))
+svfloat16x3_t svreinterpret_f16(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x3)))
+svfloat16x3_t svreinterpret_f16(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x3)))
+svfloat16x3_t svreinterpret_f16(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x3)))
+svfloat16x3_t svreinterpret_f16(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x3)))
+svfloat16x3_t svreinterpret_f16(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x3)))
+svbfloat16x3_t svreinterpret_bf16(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x3)))
+svbfloat16x3_t svreinterpret_bf16(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x3)))
+svbfloat16x3_t svreinterpret_bf16(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x3)))
+svbfloat16x3_t svreinterpret_bf16(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x3)))
+svbfloat16x3_t svreinterpret_bf16(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x3)))
+svbfloat16x3_t svreinterpret_bf16(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x3)))
+svbfloat16x3_t svreinterpret_bf16(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x3)))
+svbfloat16x3_t svreinterpret_bf16(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x3)))
+svbfloat16x3_t svreinterpret_bf16(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x3)))
+svbfloat16x3_t svreinterpret_bf16(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x3)))
+svbfloat16x3_t svreinterpret_bf16(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x3)))
+svbfloat16x3_t svreinterpret_bf16(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x3)))
+svfloat32x3_t svreinterpret_f32(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x3)))
+svfloat32x3_t svreinterpret_f32(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x3)))
+svfloat32x3_t svreinterpret_f32(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x3)))
+svfloat32x3_t svreinterpret_f32(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x3)))
+svfloat32x3_t svreinterpret_f32(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x3)))
+svfloat32x3_t svreinterpret_f32(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x3)))
+svfloat32x3_t svreinterpret_f32(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x3)))
+svfloat32x3_t svreinterpret_f32(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x3)))
+svfloat32x3_t svreinterpret_f32(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x3)))
+svfloat32x3_t svreinterpret_f32(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x3)))
+svfloat32x3_t svreinterpret_f32(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x3)))
+svfloat32x3_t svreinterpret_f32(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x3)))
+svfloat64x3_t svreinterpret_f64(svint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x3)))
+svfloat64x3_t svreinterpret_f64(svuint8x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x3)))
+svfloat64x3_t svreinterpret_f64(svint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x3)))
+svfloat64x3_t svreinterpret_f64(svuint16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x3)))
+svfloat64x3_t svreinterpret_f64(svint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x3)))
+svfloat64x3_t svreinterpret_f64(svuint32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x3)))
+svfloat64x3_t svreinterpret_f64(svint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x3)))
+svfloat64x3_t svreinterpret_f64(svuint64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x3)))
+svfloat64x3_t svreinterpret_f64(svfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x3)))
+svfloat64x3_t svreinterpret_f64(svbfloat16x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x3)))
+svfloat64x3_t svreinterpret_f64(svfloat32x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x3)))
+svfloat64x3_t svreinterpret_f64(svfloat64x3_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x4)))
+svint8x4_t svreinterpret_s8_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x4)))
+svint8x4_t svreinterpret_s8_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x4)))
+svint8x4_t svreinterpret_s8_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x4)))
+svint8x4_t svreinterpret_s8_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x4)))
+svint8x4_t svreinterpret_s8_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x4)))
+svint8x4_t svreinterpret_s8_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x4)))
+svint8x4_t svreinterpret_s8_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x4)))
+svint8x4_t svreinterpret_s8_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x4)))
+svint8x4_t svreinterpret_s8_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x4)))
+svint8x4_t svreinterpret_s8_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x4)))
+svint8x4_t svreinterpret_s8_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x4)))
+svint8x4_t svreinterpret_s8_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x4)))
+svuint8x4_t svreinterpret_u8_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x4)))
+svuint8x4_t svreinterpret_u8_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x4)))
+svuint8x4_t svreinterpret_u8_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x4)))
+svuint8x4_t svreinterpret_u8_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x4)))
+svuint8x4_t svreinterpret_u8_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x4)))
+svuint8x4_t svreinterpret_u8_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x4)))
+svuint8x4_t svreinterpret_u8_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x4)))
+svuint8x4_t svreinterpret_u8_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x4)))
+svuint8x4_t svreinterpret_u8_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x4)))
+svuint8x4_t svreinterpret_u8_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x4)))
+svuint8x4_t svreinterpret_u8_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x4)))
+svuint8x4_t svreinterpret_u8_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x4)))
+svint16x4_t svreinterpret_s16_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x4)))
+svint16x4_t svreinterpret_s16_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x4)))
+svint16x4_t svreinterpret_s16_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x4)))
+svint16x4_t svreinterpret_s16_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x4)))
+svint16x4_t svreinterpret_s16_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x4)))
+svint16x4_t svreinterpret_s16_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x4)))
+svint16x4_t svreinterpret_s16_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x4)))
+svint16x4_t svreinterpret_s16_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x4)))
+svint16x4_t svreinterpret_s16_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x4)))
+svint16x4_t svreinterpret_s16_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x4)))
+svint16x4_t svreinterpret_s16_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x4)))
+svint16x4_t svreinterpret_s16_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x4)))
+svuint16x4_t svreinterpret_u16_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x4)))
+svuint16x4_t svreinterpret_u16_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x4)))
+svuint16x4_t svreinterpret_u16_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x4)))
+svuint16x4_t svreinterpret_u16_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x4)))
+svuint16x4_t svreinterpret_u16_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x4)))
+svuint16x4_t svreinterpret_u16_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x4)))
+svuint16x4_t svreinterpret_u16_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x4)))
+svuint16x4_t svreinterpret_u16_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x4)))
+svuint16x4_t svreinterpret_u16_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x4)))
+svuint16x4_t svreinterpret_u16_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x4)))
+svuint16x4_t svreinterpret_u16_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x4)))
+svuint16x4_t svreinterpret_u16_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x4)))
+svint32x4_t svreinterpret_s32_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x4)))
+svint32x4_t svreinterpret_s32_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x4)))
+svint32x4_t svreinterpret_s32_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x4)))
+svint32x4_t svreinterpret_s32_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x4)))
+svint32x4_t svreinterpret_s32_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x4)))
+svint32x4_t svreinterpret_s32_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x4)))
+svint32x4_t svreinterpret_s32_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x4)))
+svint32x4_t svreinterpret_s32_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x4)))
+svint32x4_t svreinterpret_s32_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x4)))
+svint32x4_t svreinterpret_s32_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x4)))
+svint32x4_t svreinterpret_s32_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x4)))
+svint32x4_t svreinterpret_s32_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x4)))
+svuint32x4_t svreinterpret_u32_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x4)))
+svuint32x4_t svreinterpret_u32_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x4)))
+svuint32x4_t svreinterpret_u32_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x4)))
+svuint32x4_t svreinterpret_u32_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x4)))
+svuint32x4_t svreinterpret_u32_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x4)))
+svuint32x4_t svreinterpret_u32_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x4)))
+svuint32x4_t svreinterpret_u32_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x4)))
+svuint32x4_t svreinterpret_u32_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x4)))
+svuint32x4_t svreinterpret_u32_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x4)))
+svuint32x4_t svreinterpret_u32_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x4)))
+svuint32x4_t svreinterpret_u32_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x4)))
+svuint32x4_t svreinterpret_u32_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x4)))
+svint64x4_t svreinterpret_s64_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x4)))
+svint64x4_t svreinterpret_s64_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x4)))
+svint64x4_t svreinterpret_s64_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x4)))
+svint64x4_t svreinterpret_s64_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x4)))
+svint64x4_t svreinterpret_s64_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x4)))
+svint64x4_t svreinterpret_s64_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x4)))
+svint64x4_t svreinterpret_s64_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x4)))
+svint64x4_t svreinterpret_s64_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x4)))
+svint64x4_t svreinterpret_s64_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x4)))
+svint64x4_t svreinterpret_s64_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x4)))
+svint64x4_t svreinterpret_s64_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x4)))
+svint64x4_t svreinterpret_s64_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x4)))
+svuint64x4_t svreinterpret_u64_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x4)))
+svuint64x4_t svreinterpret_u64_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x4)))
+svuint64x4_t svreinterpret_u64_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x4)))
+svuint64x4_t svreinterpret_u64_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x4)))
+svuint64x4_t svreinterpret_u64_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x4)))
+svuint64x4_t svreinterpret_u64_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x4)))
+svuint64x4_t svreinterpret_u64_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x4)))
+svuint64x4_t svreinterpret_u64_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x4)))
+svuint64x4_t svreinterpret_u64_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x4)))
+svuint64x4_t svreinterpret_u64_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x4)))
+svuint64x4_t svreinterpret_u64_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x4)))
+svuint64x4_t svreinterpret_u64_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x4)))
+svfloat16x4_t svreinterpret_f16_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x4)))
+svfloat16x4_t svreinterpret_f16_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x4)))
+svfloat16x4_t svreinterpret_f16_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x4)))
+svfloat16x4_t svreinterpret_f16_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x4)))
+svfloat16x4_t svreinterpret_f16_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x4)))
+svfloat16x4_t svreinterpret_f16_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x4)))
+svfloat16x4_t svreinterpret_f16_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x4)))
+svfloat16x4_t svreinterpret_f16_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x4)))
+svfloat16x4_t svreinterpret_f16_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x4)))
+svfloat16x4_t svreinterpret_f16_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x4)))
+svfloat16x4_t svreinterpret_f16_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x4)))
+svfloat16x4_t svreinterpret_f16_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x4)))
+svbfloat16x4_t svreinterpret_bf16_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x4)))
+svbfloat16x4_t svreinterpret_bf16_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x4)))
+svbfloat16x4_t svreinterpret_bf16_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x4)))
+svbfloat16x4_t svreinterpret_bf16_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x4)))
+svbfloat16x4_t svreinterpret_bf16_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x4)))
+svbfloat16x4_t svreinterpret_bf16_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x4)))
+svbfloat16x4_t svreinterpret_bf16_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x4)))
+svbfloat16x4_t svreinterpret_bf16_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x4)))
+svbfloat16x4_t svreinterpret_bf16_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x4)))
+svbfloat16x4_t svreinterpret_bf16_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x4)))
+svbfloat16x4_t svreinterpret_bf16_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x4)))
+svbfloat16x4_t svreinterpret_bf16_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x4)))
+svfloat32x4_t svreinterpret_f32_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x4)))
+svfloat32x4_t svreinterpret_f32_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x4)))
+svfloat32x4_t svreinterpret_f32_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x4)))
+svfloat32x4_t svreinterpret_f32_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x4)))
+svfloat32x4_t svreinterpret_f32_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x4)))
+svfloat32x4_t svreinterpret_f32_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x4)))
+svfloat32x4_t svreinterpret_f32_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x4)))
+svfloat32x4_t svreinterpret_f32_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x4)))
+svfloat32x4_t svreinterpret_f32_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x4)))
+svfloat32x4_t svreinterpret_f32_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x4)))
+svfloat32x4_t svreinterpret_f32_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x4)))
+svfloat32x4_t svreinterpret_f32_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x4)))
+svfloat64x4_t svreinterpret_f64_s8_x4(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x4)))
+svfloat64x4_t svreinterpret_f64_u8_x4(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x4)))
+svfloat64x4_t svreinterpret_f64_s16_x4(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x4)))
+svfloat64x4_t svreinterpret_f64_u16_x4(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x4)))
+svfloat64x4_t svreinterpret_f64_s32_x4(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x4)))
+svfloat64x4_t svreinterpret_f64_u32_x4(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x4)))
+svfloat64x4_t svreinterpret_f64_s64_x4(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x4)))
+svfloat64x4_t svreinterpret_f64_u64_x4(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x4)))
+svfloat64x4_t svreinterpret_f64_f16_x4(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x4)))
+svfloat64x4_t svreinterpret_f64_bf16_x4(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x4)))
+svfloat64x4_t svreinterpret_f64_f32_x4(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x4)))
+svfloat64x4_t svreinterpret_f64_f64_x4(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s8_x4)))
+svint8x4_t svreinterpret_s8(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u8_x4)))
+svint8x4_t svreinterpret_s8(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s16_x4)))
+svint8x4_t svreinterpret_s8(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u16_x4)))
+svint8x4_t svreinterpret_s8(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s32_x4)))
+svint8x4_t svreinterpret_s8(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u32_x4)))
+svint8x4_t svreinterpret_s8(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_s64_x4)))
+svint8x4_t svreinterpret_s8(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_u64_x4)))
+svint8x4_t svreinterpret_s8(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f16_x4)))
+svint8x4_t svreinterpret_s8(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_bf16_x4)))
+svint8x4_t svreinterpret_s8(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f32_x4)))
+svint8x4_t svreinterpret_s8(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s8_f64_x4)))
+svint8x4_t svreinterpret_s8(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s8_x4)))
+svuint8x4_t svreinterpret_u8(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u8_x4)))
+svuint8x4_t svreinterpret_u8(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s16_x4)))
+svuint8x4_t svreinterpret_u8(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u16_x4)))
+svuint8x4_t svreinterpret_u8(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s32_x4)))
+svuint8x4_t svreinterpret_u8(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u32_x4)))
+svuint8x4_t svreinterpret_u8(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_s64_x4)))
+svuint8x4_t svreinterpret_u8(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_u64_x4)))
+svuint8x4_t svreinterpret_u8(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f16_x4)))
+svuint8x4_t svreinterpret_u8(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_bf16_x4)))
+svuint8x4_t svreinterpret_u8(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f32_x4)))
+svuint8x4_t svreinterpret_u8(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u8_f64_x4)))
+svuint8x4_t svreinterpret_u8(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s8_x4)))
+svint16x4_t svreinterpret_s16(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u8_x4)))
+svint16x4_t svreinterpret_s16(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s16_x4)))
+svint16x4_t svreinterpret_s16(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u16_x4)))
+svint16x4_t svreinterpret_s16(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s32_x4)))
+svint16x4_t svreinterpret_s16(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u32_x4)))
+svint16x4_t svreinterpret_s16(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_s64_x4)))
+svint16x4_t svreinterpret_s16(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_u64_x4)))
+svint16x4_t svreinterpret_s16(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f16_x4)))
+svint16x4_t svreinterpret_s16(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_bf16_x4)))
+svint16x4_t svreinterpret_s16(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f32_x4)))
+svint16x4_t svreinterpret_s16(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s16_f64_x4)))
+svint16x4_t svreinterpret_s16(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s8_x4)))
+svuint16x4_t svreinterpret_u16(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u8_x4)))
+svuint16x4_t svreinterpret_u16(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s16_x4)))
+svuint16x4_t svreinterpret_u16(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u16_x4)))
+svuint16x4_t svreinterpret_u16(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s32_x4)))
+svuint16x4_t svreinterpret_u16(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u32_x4)))
+svuint16x4_t svreinterpret_u16(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_s64_x4)))
+svuint16x4_t svreinterpret_u16(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_u64_x4)))
+svuint16x4_t svreinterpret_u16(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f16_x4)))
+svuint16x4_t svreinterpret_u16(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_bf16_x4)))
+svuint16x4_t svreinterpret_u16(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f32_x4)))
+svuint16x4_t svreinterpret_u16(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u16_f64_x4)))
+svuint16x4_t svreinterpret_u16(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s8_x4)))
+svint32x4_t svreinterpret_s32(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u8_x4)))
+svint32x4_t svreinterpret_s32(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s16_x4)))
+svint32x4_t svreinterpret_s32(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u16_x4)))
+svint32x4_t svreinterpret_s32(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s32_x4)))
+svint32x4_t svreinterpret_s32(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u32_x4)))
+svint32x4_t svreinterpret_s32(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_s64_x4)))
+svint32x4_t svreinterpret_s32(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_u64_x4)))
+svint32x4_t svreinterpret_s32(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f16_x4)))
+svint32x4_t svreinterpret_s32(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_bf16_x4)))
+svint32x4_t svreinterpret_s32(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f32_x4)))
+svint32x4_t svreinterpret_s32(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s32_f64_x4)))
+svint32x4_t svreinterpret_s32(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s8_x4)))
+svuint32x4_t svreinterpret_u32(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u8_x4)))
+svuint32x4_t svreinterpret_u32(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s16_x4)))
+svuint32x4_t svreinterpret_u32(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u16_x4)))
+svuint32x4_t svreinterpret_u32(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s32_x4)))
+svuint32x4_t svreinterpret_u32(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u32_x4)))
+svuint32x4_t svreinterpret_u32(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_s64_x4)))
+svuint32x4_t svreinterpret_u32(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_u64_x4)))
+svuint32x4_t svreinterpret_u32(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f16_x4)))
+svuint32x4_t svreinterpret_u32(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_bf16_x4)))
+svuint32x4_t svreinterpret_u32(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f32_x4)))
+svuint32x4_t svreinterpret_u32(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u32_f64_x4)))
+svuint32x4_t svreinterpret_u32(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s8_x4)))
+svint64x4_t svreinterpret_s64(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u8_x4)))
+svint64x4_t svreinterpret_s64(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s16_x4)))
+svint64x4_t svreinterpret_s64(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u16_x4)))
+svint64x4_t svreinterpret_s64(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s32_x4)))
+svint64x4_t svreinterpret_s64(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u32_x4)))
+svint64x4_t svreinterpret_s64(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_s64_x4)))
+svint64x4_t svreinterpret_s64(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_u64_x4)))
+svint64x4_t svreinterpret_s64(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f16_x4)))
+svint64x4_t svreinterpret_s64(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_bf16_x4)))
+svint64x4_t svreinterpret_s64(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f32_x4)))
+svint64x4_t svreinterpret_s64(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_s64_f64_x4)))
+svint64x4_t svreinterpret_s64(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s8_x4)))
+svuint64x4_t svreinterpret_u64(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u8_x4)))
+svuint64x4_t svreinterpret_u64(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s16_x4)))
+svuint64x4_t svreinterpret_u64(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u16_x4)))
+svuint64x4_t svreinterpret_u64(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s32_x4)))
+svuint64x4_t svreinterpret_u64(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u32_x4)))
+svuint64x4_t svreinterpret_u64(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_s64_x4)))
+svuint64x4_t svreinterpret_u64(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_u64_x4)))
+svuint64x4_t svreinterpret_u64(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f16_x4)))
+svuint64x4_t svreinterpret_u64(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_bf16_x4)))
+svuint64x4_t svreinterpret_u64(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f32_x4)))
+svuint64x4_t svreinterpret_u64(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_u64_f64_x4)))
+svuint64x4_t svreinterpret_u64(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s8_x4)))
+svfloat16x4_t svreinterpret_f16(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u8_x4)))
+svfloat16x4_t svreinterpret_f16(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s16_x4)))
+svfloat16x4_t svreinterpret_f16(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u16_x4)))
+svfloat16x4_t svreinterpret_f16(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s32_x4)))
+svfloat16x4_t svreinterpret_f16(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u32_x4)))
+svfloat16x4_t svreinterpret_f16(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_s64_x4)))
+svfloat16x4_t svreinterpret_f16(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_u64_x4)))
+svfloat16x4_t svreinterpret_f16(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f16_x4)))
+svfloat16x4_t svreinterpret_f16(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_bf16_x4)))
+svfloat16x4_t svreinterpret_f16(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f32_x4)))
+svfloat16x4_t svreinterpret_f16(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f16_f64_x4)))
+svfloat16x4_t svreinterpret_f16(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s8_x4)))
+svbfloat16x4_t svreinterpret_bf16(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u8_x4)))
+svbfloat16x4_t svreinterpret_bf16(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s16_x4)))
+svbfloat16x4_t svreinterpret_bf16(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u16_x4)))
+svbfloat16x4_t svreinterpret_bf16(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s32_x4)))
+svbfloat16x4_t svreinterpret_bf16(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u32_x4)))
+svbfloat16x4_t svreinterpret_bf16(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_s64_x4)))
+svbfloat16x4_t svreinterpret_bf16(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_u64_x4)))
+svbfloat16x4_t svreinterpret_bf16(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f16_x4)))
+svbfloat16x4_t svreinterpret_bf16(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_bf16_x4)))
+svbfloat16x4_t svreinterpret_bf16(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f32_x4)))
+svbfloat16x4_t svreinterpret_bf16(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_bf16_f64_x4)))
+svbfloat16x4_t svreinterpret_bf16(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s8_x4)))
+svfloat32x4_t svreinterpret_f32(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u8_x4)))
+svfloat32x4_t svreinterpret_f32(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s16_x4)))
+svfloat32x4_t svreinterpret_f32(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u16_x4)))
+svfloat32x4_t svreinterpret_f32(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s32_x4)))
+svfloat32x4_t svreinterpret_f32(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u32_x4)))
+svfloat32x4_t svreinterpret_f32(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_s64_x4)))
+svfloat32x4_t svreinterpret_f32(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_u64_x4)))
+svfloat32x4_t svreinterpret_f32(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f16_x4)))
+svfloat32x4_t svreinterpret_f32(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_bf16_x4)))
+svfloat32x4_t svreinterpret_f32(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f32_x4)))
+svfloat32x4_t svreinterpret_f32(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f32_f64_x4)))
+svfloat32x4_t svreinterpret_f32(svfloat64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s8_x4)))
+svfloat64x4_t svreinterpret_f64(svint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u8_x4)))
+svfloat64x4_t svreinterpret_f64(svuint8x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s16_x4)))
+svfloat64x4_t svreinterpret_f64(svint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u16_x4)))
+svfloat64x4_t svreinterpret_f64(svuint16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s32_x4)))
+svfloat64x4_t svreinterpret_f64(svint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u32_x4)))
+svfloat64x4_t svreinterpret_f64(svuint32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_s64_x4)))
+svfloat64x4_t svreinterpret_f64(svint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_u64_x4)))
+svfloat64x4_t svreinterpret_f64(svuint64x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f16_x4)))
+svfloat64x4_t svreinterpret_f64(svfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_bf16_x4)))
+svfloat64x4_t svreinterpret_f64(svbfloat16x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f32_x4)))
+svfloat64x4_t svreinterpret_f64(svfloat32x4_t op);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_reinterpret_f64_f64_x4)))
+svfloat64x4_t svreinterpret_f64(svfloat64x4_t op);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_x2)))
+svfloat32x2_t svcvt_f32_f16_x2(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtl_f32_f16_x2)))
+svfloat32x2_t svcvtl_f32_f16_x2(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_x2)))
+svfloat32x2_t svcvt_f32(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtl_f32_f16_x2)))
+svfloat32x2_t svcvtl_f32(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x2)))
+svuint8x2_t svadd_single_u8_x2(svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x2)))
+svuint32x2_t svadd_single_u32_x2(svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x2)))
+svuint64x2_t svadd_single_u64_x2(svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x2)))
+svuint16x2_t svadd_single_u16_x2(svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x2)))
+svint8x2_t svadd_single_s8_x2(svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x2)))
+svint32x2_t svadd_single_s32_x2(svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x2)))
+svint64x2_t svadd_single_s64_x2(svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x2)))
+svint16x2_t svadd_single_s16_x2(svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x4)))
+svuint8x4_t svadd_single_u8_x4(svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x4)))
+svuint32x4_t svadd_single_u32_x4(svuint32x4_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x4)))
+svuint64x4_t svadd_single_u64_x4(svuint64x4_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x4)))
+svuint16x4_t svadd_single_u16_x4(svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x4)))
+svint8x4_t svadd_single_s8_x4(svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x4)))
+svint32x4_t svadd_single_s32_x4(svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x4)))
+svint64x4_t svadd_single_s64_x4(svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x4)))
+svint16x4_t svadd_single_s16_x4(svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x2)))
+svfloat64x2_t svclamp_single_f64_x2(svfloat64x2_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x2)))
+svfloat32x2_t svclamp_single_f32_x2(svfloat32x2_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x2)))
+svfloat16x2_t svclamp_single_f16_x2(svfloat16x2_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x2)))
+svint8x2_t svclamp_single_s8_x2(svint8x2_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x2)))
+svint32x2_t svclamp_single_s32_x2(svint32x2_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x2)))
+svint64x2_t svclamp_single_s64_x2(svint64x2_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x2)))
+svint16x2_t svclamp_single_s16_x2(svint16x2_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x2)))
+svuint8x2_t svclamp_single_u8_x2(svuint8x2_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x2)))
+svuint32x2_t svclamp_single_u32_x2(svuint32x2_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x2)))
+svuint64x2_t svclamp_single_u64_x2(svuint64x2_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x2)))
+svuint16x2_t svclamp_single_u16_x2(svuint16x2_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x4)))
+svfloat64x4_t svclamp_single_f64_x4(svfloat64x4_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x4)))
+svfloat32x4_t svclamp_single_f32_x4(svfloat32x4_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x4)))
+svfloat16x4_t svclamp_single_f16_x4(svfloat16x4_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x4)))
+svint8x4_t svclamp_single_s8_x4(svint8x4_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x4)))
+svint32x4_t svclamp_single_s32_x4(svint32x4_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x4)))
+svint64x4_t svclamp_single_s64_x4(svint64x4_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x4)))
+svint16x4_t svclamp_single_s16_x4(svint16x4_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x4)))
+svuint8x4_t svclamp_single_u8_x4(svuint8x4_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x4)))
+svuint32x4_t svclamp_single_u32_x4(svuint32x4_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x4)))
+svuint64x4_t svclamp_single_u64_x4(svuint64x4_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x4)))
+svuint16x4_t svclamp_single_u16_x4(svuint16x4_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x2)))
+svbfloat16_t svcvt_bf16_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x2)))
+svfloat16_t svcvt_f16_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x2)))
+svint32x2_t svcvt_s32_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x2)))
+svuint32x2_t svcvt_u32_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x4)))
+svint32x4_t svcvt_s32_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x4)))
+svuint32x4_t svcvt_u32_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x2)))
+svfloat32x2_t svcvt_f32_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x4)))
+svfloat32x4_t svcvt_f32_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x2)))
+svfloat32x2_t svcvt_f32_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x4)))
+svfloat32x4_t svcvt_f32_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_bf16_f32_x2)))
+svbfloat16_t svcvtn_bf16_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_f16_f32_x2)))
+svfloat16_t svcvtn_f16_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_bf16_x2)))
+svbfloat16x2_t svmax_single_bf16_x2(svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x2)))
+svfloat64x2_t svmax_single_f64_x2(svfloat64x2_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x2)))
+svfloat32x2_t svmax_single_f32_x2(svfloat32x2_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x2)))
+svfloat16x2_t svmax_single_f16_x2(svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x2)))
+svint8x2_t svmax_single_s8_x2(svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x2)))
+svint32x2_t svmax_single_s32_x2(svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x2)))
+svint64x2_t svmax_single_s64_x2(svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x2)))
+svint16x2_t svmax_single_s16_x2(svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x2)))
+svuint8x2_t svmax_single_u8_x2(svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x2)))
+svuint32x2_t svmax_single_u32_x2(svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x2)))
+svuint64x2_t svmax_single_u64_x2(svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x2)))
+svuint16x2_t svmax_single_u16_x2(svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_bf16_x4)))
+svbfloat16x4_t svmax_single_bf16_x4(svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x4)))
+svfloat64x4_t svmax_single_f64_x4(svfloat64x4_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x4)))
+svfloat32x4_t svmax_single_f32_x4(svfloat32x4_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x4)))
+svfloat16x4_t svmax_single_f16_x4(svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x4)))
+svint8x4_t svmax_single_s8_x4(svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x4)))
+svint32x4_t svmax_single_s32_x4(svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x4)))
+svint64x4_t svmax_single_s64_x4(svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x4)))
+svint16x4_t svmax_single_s16_x4(svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x4)))
+svuint8x4_t svmax_single_u8_x4(svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x4)))
+svuint32x4_t svmax_single_u32_x4(svuint32x4_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x4)))
+svuint64x4_t svmax_single_u64_x4(svuint64x4_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x4)))
+svuint16x4_t svmax_single_u16_x4(svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x2)))
+svbfloat16x2_t svmax_bf16_x2(svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x2)))
+svfloat64x2_t svmax_f64_x2(svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x2)))
+svfloat32x2_t svmax_f32_x2(svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x2)))
+svfloat16x2_t svmax_f16_x2(svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x2)))
+svint8x2_t svmax_s8_x2(svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x2)))
+svint32x2_t svmax_s32_x2(svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x2)))
+svint64x2_t svmax_s64_x2(svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x2)))
+svint16x2_t svmax_s16_x2(svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x2)))
+svuint8x2_t svmax_u8_x2(svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x2)))
+svuint32x2_t svmax_u32_x2(svuint32x2_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x2)))
+svuint64x2_t svmax_u64_x2(svuint64x2_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x2)))
+svuint16x2_t svmax_u16_x2(svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x4)))
+svbfloat16x4_t svmax_bf16_x4(svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x4)))
+svfloat64x4_t svmax_f64_x4(svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x4)))
+svfloat32x4_t svmax_f32_x4(svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x4)))
+svfloat16x4_t svmax_f16_x4(svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x4)))
+svint8x4_t svmax_s8_x4(svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x4)))
+svint32x4_t svmax_s32_x4(svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x4)))
+svint64x4_t svmax_s64_x4(svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x4)))
+svint16x4_t svmax_s16_x4(svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x4)))
+svuint8x4_t svmax_u8_x4(svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x4)))
+svuint32x4_t svmax_u32_x4(svuint32x4_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x4)))
+svuint64x4_t svmax_u64_x4(svuint64x4_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x4)))
+svuint16x4_t svmax_u16_x4(svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_bf16_x2)))
+svbfloat16x2_t svmaxnm_single_bf16_x2(svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x2)))
+svfloat64x2_t svmaxnm_single_f64_x2(svfloat64x2_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x2)))
+svfloat32x2_t svmaxnm_single_f32_x2(svfloat32x2_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x2)))
+svfloat16x2_t svmaxnm_single_f16_x2(svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_bf16_x4)))
+svbfloat16x4_t svmaxnm_single_bf16_x4(svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x4)))
+svfloat64x4_t svmaxnm_single_f64_x4(svfloat64x4_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x4)))
+svfloat32x4_t svmaxnm_single_f32_x4(svfloat32x4_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x4)))
+svfloat16x4_t svmaxnm_single_f16_x4(svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x2)))
+svbfloat16x2_t svmaxnm_bf16_x2(svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x2)))
+svfloat64x2_t svmaxnm_f64_x2(svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x2)))
+svfloat32x2_t svmaxnm_f32_x2(svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x2)))
+svfloat16x2_t svmaxnm_f16_x2(svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x4)))
+svbfloat16x4_t svmaxnm_bf16_x4(svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x4)))
+svfloat64x4_t svmaxnm_f64_x4(svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x4)))
+svfloat32x4_t svmaxnm_f32_x4(svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x4)))
+svfloat16x4_t svmaxnm_f16_x4(svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_bf16_x2)))
+svbfloat16x2_t svmin_single_bf16_x2(svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x2)))
+svfloat64x2_t svmin_single_f64_x2(svfloat64x2_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x2)))
+svfloat32x2_t svmin_single_f32_x2(svfloat32x2_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x2)))
+svfloat16x2_t svmin_single_f16_x2(svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x2)))
+svint8x2_t svmin_single_s8_x2(svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x2)))
+svint32x2_t svmin_single_s32_x2(svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x2)))
+svint64x2_t svmin_single_s64_x2(svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x2)))
+svint16x2_t svmin_single_s16_x2(svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x2)))
+svuint8x2_t svmin_single_u8_x2(svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x2)))
+svuint32x2_t svmin_single_u32_x2(svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x2)))
+svuint64x2_t svmin_single_u64_x2(svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x2)))
+svuint16x2_t svmin_single_u16_x2(svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_bf16_x4)))
+svbfloat16x4_t svmin_single_bf16_x4(svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x4)))
+svfloat64x4_t svmin_single_f64_x4(svfloat64x4_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x4)))
+svfloat32x4_t svmin_single_f32_x4(svfloat32x4_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x4)))
+svfloat16x4_t svmin_single_f16_x4(svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x4)))
+svint8x4_t svmin_single_s8_x4(svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x4)))
+svint32x4_t svmin_single_s32_x4(svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x4)))
+svint64x4_t svmin_single_s64_x4(svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x4)))
+svint16x4_t svmin_single_s16_x4(svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x4)))
+svuint8x4_t svmin_single_u8_x4(svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x4)))
+svuint32x4_t svmin_single_u32_x4(svuint32x4_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x4)))
+svuint64x4_t svmin_single_u64_x4(svuint64x4_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x4)))
+svuint16x4_t svmin_single_u16_x4(svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x2)))
+svbfloat16x2_t svmin_bf16_x2(svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x2)))
+svfloat64x2_t svmin_f64_x2(svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x2)))
+svfloat32x2_t svmin_f32_x2(svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x2)))
+svfloat16x2_t svmin_f16_x2(svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x2)))
+svint8x2_t svmin_s8_x2(svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x2)))
+svint32x2_t svmin_s32_x2(svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x2)))
+svint64x2_t svmin_s64_x2(svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x2)))
+svint16x2_t svmin_s16_x2(svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x2)))
+svuint8x2_t svmin_u8_x2(svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x2)))
+svuint32x2_t svmin_u32_x2(svuint32x2_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x2)))
+svuint64x2_t svmin_u64_x2(svuint64x2_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x2)))
+svuint16x2_t svmin_u16_x2(svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x4)))
+svbfloat16x4_t svmin_bf16_x4(svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x4)))
+svfloat64x4_t svmin_f64_x4(svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x4)))
+svfloat32x4_t svmin_f32_x4(svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x4)))
+svfloat16x4_t svmin_f16_x4(svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x4)))
+svint8x4_t svmin_s8_x4(svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x4)))
+svint32x4_t svmin_s32_x4(svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x4)))
+svint64x4_t svmin_s64_x4(svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x4)))
+svint16x4_t svmin_s16_x4(svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x4)))
+svuint8x4_t svmin_u8_x4(svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x4)))
+svuint32x4_t svmin_u32_x4(svuint32x4_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x4)))
+svuint64x4_t svmin_u64_x4(svuint64x4_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x4)))
+svuint16x4_t svmin_u16_x4(svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_bf16_x2)))
+svbfloat16x2_t svminnm_single_bf16_x2(svbfloat16x2_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x2)))
+svfloat64x2_t svminnm_single_f64_x2(svfloat64x2_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x2)))
+svfloat32x2_t svminnm_single_f32_x2(svfloat32x2_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x2)))
+svfloat16x2_t svminnm_single_f16_x2(svfloat16x2_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_bf16_x4)))
+svbfloat16x4_t svminnm_single_bf16_x4(svbfloat16x4_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x4)))
+svfloat64x4_t svminnm_single_f64_x4(svfloat64x4_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x4)))
+svfloat32x4_t svminnm_single_f32_x4(svfloat32x4_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x4)))
+svfloat16x4_t svminnm_single_f16_x4(svfloat16x4_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x2)))
+svbfloat16x2_t svminnm_bf16_x2(svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x2)))
+svfloat64x2_t svminnm_f64_x2(svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x2)))
+svfloat32x2_t svminnm_f32_x2(svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x2)))
+svfloat16x2_t svminnm_f16_x2(svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x4)))
+svbfloat16x4_t svminnm_bf16_x4(svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x4)))
+svfloat64x4_t svminnm_f64_x4(svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x4)))
+svfloat32x4_t svminnm_f32_x4(svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x4)))
+svfloat16x4_t svminnm_f16_x4(svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s32_x2)))
+svint16_t svqcvt_s16_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s64_x4)))
+svint16_t svqcvt_s16_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s8_s32_x4)))
+svint8_t svqcvt_s8_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s32_x2)))
+svuint16_t svqcvt_u16_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u32_x2)))
+svuint16_t svqcvt_u16_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s64_x4)))
+svuint16_t svqcvt_u16_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u64_x4)))
+svuint16_t svqcvt_u16_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_s32_x4)))
+svuint8_t svqcvt_u8_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_u32_x4)))
+svuint8_t svqcvt_u8_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s64_x4)))
+svint16_t svqcvtn_s16_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s8_s32_x4)))
+svint8_t svqcvtn_s8_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s64_x4)))
+svuint16_t svqcvtn_u16_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u64_x4)))
+svuint16_t svqcvtn_u16_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_s32_x4)))
+svuint8_t svqcvtn_u8_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_u32_x4)))
+svuint8_t svqcvtn_u8_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x2)))
+svint8x2_t svqdmulh_single_s8_x2(svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x2)))
+svint32x2_t svqdmulh_single_s32_x2(svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x2)))
+svint64x2_t svqdmulh_single_s64_x2(svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x2)))
+svint16x2_t svqdmulh_single_s16_x2(svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x4)))
+svint8x4_t svqdmulh_single_s8_x4(svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x4)))
+svint32x4_t svqdmulh_single_s32_x4(svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x4)))
+svint64x4_t svqdmulh_single_s64_x4(svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x4)))
+svint16x4_t svqdmulh_single_s16_x4(svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x2)))
+svint8x2_t svqdmulh_s8_x2(svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x2)))
+svint32x2_t svqdmulh_s32_x2(svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x2)))
+svint64x2_t svqdmulh_s64_x2(svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x2)))
+svint16x2_t svqdmulh_s16_x2(svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x4)))
+svint8x4_t svqdmulh_s8_x4(svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x4)))
+svint32x4_t svqdmulh_s32_x4(svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x4)))
+svint64x4_t svqdmulh_s64_x4(svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x4)))
+svint16x4_t svqdmulh_s16_x4(svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s32_x2)))
+svint16_t svqrshr_n_s16_s32_x2(svint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u32_x2)))
+svuint16_t svqrshr_n_u16_u32_x2(svuint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s8_s32_x4)))
+svint8_t svqrshr_n_s8_s32_x4(svint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s64_x4)))
+svint16_t svqrshr_n_s16_s64_x4(svint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u8_u32_x4)))
+svuint8_t svqrshr_n_u8_u32_x4(svuint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u64_x4)))
+svuint16_t svqrshr_n_u16_u64_x4(svuint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s8_s32_x4)))
+svint8_t svqrshrn_n_s8_s32_x4(svint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s16_s64_x4)))
+svint16_t svqrshrn_n_s16_s64_x4(svint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u8_u32_x4)))
+svuint8_t svqrshrn_n_u8_u32_x4(svuint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u16_u64_x4)))
+svuint16_t svqrshrn_n_u16_u64_x4(svuint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s32_x2)))
+svuint16_t svqrshru_n_u16_s32_x2(svint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u8_s32_x4)))
+svuint8_t svqrshru_n_u8_s32_x4(svint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s64_x4)))
+svuint16_t svqrshru_n_u16_s64_x4(svint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u8_s32_x4)))
+svuint8_t svqrshrun_n_u8_s32_x4(svint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u16_s64_x4)))
+svuint16_t svqrshrun_n_u16_s64_x4(svint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x2)))
+svfloat32x2_t svrinta_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x4)))
+svfloat32x4_t svrinta_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x2)))
+svfloat32x2_t svrintm_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x4)))
+svfloat32x4_t svrintm_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x2)))
+svfloat32x2_t svrintn_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x4)))
+svfloat32x4_t svrintn_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x2)))
+svfloat32x2_t svrintp_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x4)))
+svfloat32x4_t svrintp_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x2)))
+svint8x2_t svrshl_single_s8_x2(svint8x2_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x2)))
+svint32x2_t svrshl_single_s32_x2(svint32x2_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x2)))
+svint64x2_t svrshl_single_s64_x2(svint64x2_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x2)))
+svint16x2_t svrshl_single_s16_x2(svint16x2_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x2)))
+svuint8x2_t svrshl_single_u8_x2(svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x2)))
+svuint32x2_t svrshl_single_u32_x2(svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x2)))
+svuint64x2_t svrshl_single_u64_x2(svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x2)))
+svuint16x2_t svrshl_single_u16_x2(svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x4)))
+svint8x4_t svrshl_single_s8_x4(svint8x4_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x4)))
+svint32x4_t svrshl_single_s32_x4(svint32x4_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x4)))
+svint64x4_t svrshl_single_s64_x4(svint64x4_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x4)))
+svint16x4_t svrshl_single_s16_x4(svint16x4_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x4)))
+svuint8x4_t svrshl_single_u8_x4(svuint8x4_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x4)))
+svuint32x4_t svrshl_single_u32_x4(svuint32x4_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x4)))
+svuint64x4_t svrshl_single_u64_x4(svuint64x4_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x4)))
+svuint16x4_t svrshl_single_u16_x4(svuint16x4_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x2)))
+svint8x2_t svrshl_s8_x2(svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x2)))
+svint32x2_t svrshl_s32_x2(svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x2)))
+svint64x2_t svrshl_s64_x2(svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x2)))
+svint16x2_t svrshl_s16_x2(svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x2)))
+svuint8x2_t svrshl_u8_x2(svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x2)))
+svuint32x2_t svrshl_u32_x2(svuint32x2_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x2)))
+svuint64x2_t svrshl_u64_x2(svuint64x2_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x2)))
+svuint16x2_t svrshl_u16_x2(svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x4)))
+svint8x4_t svrshl_s8_x4(svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x4)))
+svint32x4_t svrshl_s32_x4(svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x4)))
+svint64x4_t svrshl_s64_x4(svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x4)))
+svint16x4_t svrshl_s16_x4(svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x4)))
+svuint8x4_t svrshl_u8_x4(svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x4)))
+svuint32x4_t svrshl_u32_x4(svuint32x4_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x4)))
+svuint64x4_t svrshl_u64_x4(svuint64x4_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x4)))
+svuint16x4_t svrshl_u16_x4(svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x2)))
+svuint8x2_t svsel_u8_x2(svcount_t, svuint8x2_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x2)))
+svuint32x2_t svsel_u32_x2(svcount_t, svuint32x2_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x2)))
+svuint64x2_t svsel_u64_x2(svcount_t, svuint64x2_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x2)))
+svuint16x2_t svsel_u16_x2(svcount_t, svuint16x2_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x2)))
+svbfloat16x2_t svsel_bf16_x2(svcount_t, svbfloat16x2_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x2)))
+svint8x2_t svsel_s8_x2(svcount_t, svint8x2_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x2)))
+svfloat64x2_t svsel_f64_x2(svcount_t, svfloat64x2_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x2)))
+svfloat32x2_t svsel_f32_x2(svcount_t, svfloat32x2_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x2)))
+svfloat16x2_t svsel_f16_x2(svcount_t, svfloat16x2_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x2)))
+svint32x2_t svsel_s32_x2(svcount_t, svint32x2_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x2)))
+svint64x2_t svsel_s64_x2(svcount_t, svint64x2_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x2)))
+svint16x2_t svsel_s16_x2(svcount_t, svint16x2_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x4)))
+svuint8x4_t svsel_u8_x4(svcount_t, svuint8x4_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x4)))
+svuint32x4_t svsel_u32_x4(svcount_t, svuint32x4_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x4)))
+svuint64x4_t svsel_u64_x4(svcount_t, svuint64x4_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x4)))
+svuint16x4_t svsel_u16_x4(svcount_t, svuint16x4_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x4)))
+svbfloat16x4_t svsel_bf16_x4(svcount_t, svbfloat16x4_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x4)))
+svint8x4_t svsel_s8_x4(svcount_t, svint8x4_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x4)))
+svfloat64x4_t svsel_f64_x4(svcount_t, svfloat64x4_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x4)))
+svfloat32x4_t svsel_f32_x4(svcount_t, svfloat32x4_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x4)))
+svfloat16x4_t svsel_f16_x4(svcount_t, svfloat16x4_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x4)))
+svint32x4_t svsel_s32_x4(svcount_t, svint32x4_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x4)))
+svint64x4_t svsel_s64_x4(svcount_t, svint64x4_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x4)))
+svint16x4_t svsel_s16_x4(svcount_t, svint16x4_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x2)))
+svint32x2_t svunpk_s32_s16_x2(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x2)))
+svint64x2_t svunpk_s64_s32_x2(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x2)))
+svint16x2_t svunpk_s16_s8_x2(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x2)))
+svuint32x2_t svunpk_u32_u16_x2(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x2)))
+svuint64x2_t svunpk_u64_u32_x2(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x2)))
+svuint16x2_t svunpk_u16_u8_x2(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x4)))
+svint32x4_t svunpk_s32_s16_x4(svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x4)))
+svint64x4_t svunpk_s64_s32_x4(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x4)))
+svint16x4_t svunpk_s16_s8_x4(svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x4)))
+svuint32x4_t svunpk_u32_u16_x4(svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x4)))
+svuint64x4_t svunpk_u64_u32_x4(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x4)))
+svuint16x4_t svunpk_u16_u8_x4(svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x2)))
+svuint8x2_t svuzp_u8_x2(svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x2)))
+svuint32x2_t svuzp_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x2)))
+svuint64x2_t svuzp_u64_x2(svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x2)))
+svuint16x2_t svuzp_u16_x2(svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x2)))
+svbfloat16x2_t svuzp_bf16_x2(svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x2)))
+svint8x2_t svuzp_s8_x2(svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x2)))
+svfloat64x2_t svuzp_f64_x2(svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x2)))
+svfloat32x2_t svuzp_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x2)))
+svfloat16x2_t svuzp_f16_x2(svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x2)))
+svint32x2_t svuzp_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x2)))
+svint64x2_t svuzp_s64_x2(svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x2)))
+svint16x2_t svuzp_s16_x2(svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x4)))
+svuint8x4_t svuzp_u8_x4(svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x4)))
+svuint32x4_t svuzp_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x4)))
+svuint64x4_t svuzp_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x4)))
+svuint16x4_t svuzp_u16_x4(svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x4)))
+svbfloat16x4_t svuzp_bf16_x4(svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x4)))
+svint8x4_t svuzp_s8_x4(svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x4)))
+svfloat64x4_t svuzp_f64_x4(svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x4)))
+svfloat32x4_t svuzp_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x4)))
+svfloat16x4_t svuzp_f16_x4(svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x4)))
+svint32x4_t svuzp_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x4)))
+svint64x4_t svuzp_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x4)))
+svint16x4_t svuzp_s16_x4(svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x2)))
+svuint8x2_t svuzpq_u8_x2(svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x2)))
+svuint32x2_t svuzpq_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x2)))
+svuint64x2_t svuzpq_u64_x2(svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x2)))
+svuint16x2_t svuzpq_u16_x2(svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x2)))
+svbfloat16x2_t svuzpq_bf16_x2(svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x2)))
+svint8x2_t svuzpq_s8_x2(svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x2)))
+svfloat64x2_t svuzpq_f64_x2(svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x2)))
+svfloat32x2_t svuzpq_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x2)))
+svfloat16x2_t svuzpq_f16_x2(svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x2)))
+svint32x2_t svuzpq_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x2)))
+svint64x2_t svuzpq_s64_x2(svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x2)))
+svint16x2_t svuzpq_s16_x2(svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x4)))
+svuint8x4_t svuzpq_u8_x4(svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x4)))
+svuint32x4_t svuzpq_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x4)))
+svuint64x4_t svuzpq_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x4)))
+svuint16x4_t svuzpq_u16_x4(svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x4)))
+svbfloat16x4_t svuzpq_bf16_x4(svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x4)))
+svint8x4_t svuzpq_s8_x4(svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x4)))
+svfloat64x4_t svuzpq_f64_x4(svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x4)))
+svfloat32x4_t svuzpq_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x4)))
+svfloat16x4_t svuzpq_f16_x4(svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x4)))
+svint32x4_t svuzpq_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x4)))
+svint64x4_t svuzpq_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x4)))
+svint16x4_t svuzpq_s16_x4(svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x2)))
+svuint8x2_t svzip_u8_x2(svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x2)))
+svuint32x2_t svzip_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x2)))
+svuint64x2_t svzip_u64_x2(svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x2)))
+svuint16x2_t svzip_u16_x2(svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x2)))
+svbfloat16x2_t svzip_bf16_x2(svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x2)))
+svint8x2_t svzip_s8_x2(svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x2)))
+svfloat64x2_t svzip_f64_x2(svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x2)))
+svfloat32x2_t svzip_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x2)))
+svfloat16x2_t svzip_f16_x2(svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x2)))
+svint32x2_t svzip_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x2)))
+svint64x2_t svzip_s64_x2(svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x2)))
+svint16x2_t svzip_s16_x2(svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x4)))
+svuint8x4_t svzip_u8_x4(svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x4)))
+svuint32x4_t svzip_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x4)))
+svuint64x4_t svzip_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x4)))
+svuint16x4_t svzip_u16_x4(svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x4)))
+svbfloat16x4_t svzip_bf16_x4(svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x4)))
+svint8x4_t svzip_s8_x4(svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x4)))
+svfloat64x4_t svzip_f64_x4(svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x4)))
+svfloat32x4_t svzip_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x4)))
+svfloat16x4_t svzip_f16_x4(svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x4)))
+svint32x4_t svzip_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x4)))
+svint64x4_t svzip_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x4)))
+svint16x4_t svzip_s16_x4(svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x2)))
+svuint8x2_t svzipq_u8_x2(svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x2)))
+svuint32x2_t svzipq_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x2)))
+svuint64x2_t svzipq_u64_x2(svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x2)))
+svuint16x2_t svzipq_u16_x2(svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x2)))
+svbfloat16x2_t svzipq_bf16_x2(svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x2)))
+svint8x2_t svzipq_s8_x2(svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x2)))
+svfloat64x2_t svzipq_f64_x2(svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x2)))
+svfloat32x2_t svzipq_f32_x2(svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x2)))
+svfloat16x2_t svzipq_f16_x2(svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x2)))
+svint32x2_t svzipq_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x2)))
+svint64x2_t svzipq_s64_x2(svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x2)))
+svint16x2_t svzipq_s16_x2(svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x4)))
+svuint8x4_t svzipq_u8_x4(svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x4)))
+svuint32x4_t svzipq_u32_x4(svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x4)))
+svuint64x4_t svzipq_u64_x4(svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x4)))
+svuint16x4_t svzipq_u16_x4(svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x4)))
+svbfloat16x4_t svzipq_bf16_x4(svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x4)))
+svint8x4_t svzipq_s8_x4(svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x4)))
+svfloat64x4_t svzipq_f64_x4(svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x4)))
+svfloat32x4_t svzipq_f32_x4(svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x4)))
+svfloat16x4_t svzipq_f16_x4(svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x4)))
+svint32x4_t svzipq_s32_x4(svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x4)))
+svint64x4_t svzipq_s64_x4(svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x4)))
+svint16x4_t svzipq_s16_x4(svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x2)))
+svuint8x2_t svadd(svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x2)))
+svuint32x2_t svadd(svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x2)))
+svuint64x2_t svadd(svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x2)))
+svuint16x2_t svadd(svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x2)))
+svint8x2_t svadd(svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x2)))
+svint32x2_t svadd(svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x2)))
+svint64x2_t svadd(svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x2)))
+svint16x2_t svadd(svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u8_x4)))
+svuint8x4_t svadd(svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u32_x4)))
+svuint32x4_t svadd(svuint32x4_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u64_x4)))
+svuint64x4_t svadd(svuint64x4_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_u16_x4)))
+svuint16x4_t svadd(svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s8_x4)))
+svint8x4_t svadd(svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s32_x4)))
+svint32x4_t svadd(svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s64_x4)))
+svint64x4_t svadd(svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_single_s16_x4)))
+svint16x4_t svadd(svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x2)))
+svfloat64x2_t svclamp(svfloat64x2_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x2)))
+svfloat32x2_t svclamp(svfloat32x2_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x2)))
+svfloat16x2_t svclamp(svfloat16x2_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x2)))
+svint8x2_t svclamp(svint8x2_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x2)))
+svint32x2_t svclamp(svint32x2_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x2)))
+svint64x2_t svclamp(svint64x2_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x2)))
+svint16x2_t svclamp(svint16x2_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x2)))
+svuint8x2_t svclamp(svuint8x2_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x2)))
+svuint32x2_t svclamp(svuint32x2_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x2)))
+svuint64x2_t svclamp(svuint64x2_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x2)))
+svuint16x2_t svclamp(svuint16x2_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f64_x4)))
+svfloat64x4_t svclamp(svfloat64x4_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f32_x4)))
+svfloat32x4_t svclamp(svfloat32x4_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_f16_x4)))
+svfloat16x4_t svclamp(svfloat16x4_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s8_x4)))
+svint8x4_t svclamp(svint8x4_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s32_x4)))
+svint32x4_t svclamp(svint32x4_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s64_x4)))
+svint64x4_t svclamp(svint64x4_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_s16_x4)))
+svint16x4_t svclamp(svint16x4_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u8_x4)))
+svuint8x4_t svclamp(svuint8x4_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u32_x4)))
+svuint32x4_t svclamp(svuint32x4_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u64_x4)))
+svuint64x4_t svclamp(svuint64x4_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_u16_x4)))
+svuint16x4_t svclamp(svuint16x4_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x2)))
+svbfloat16_t svcvt_bf16(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x2)))
+svfloat16_t svcvt_f16(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x2)))
+svint32x2_t svcvt_s32(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x2)))
+svuint32x2_t svcvt_u32(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x4)))
+svint32x4_t svcvt_s32(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x4)))
+svuint32x4_t svcvt_u32(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x2)))
+svfloat32x2_t svcvt_f32(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x4)))
+svfloat32x4_t svcvt_f32(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x2)))
+svfloat32x2_t svcvt_f32(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x4)))
+svfloat32x4_t svcvt_f32(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_bf16_f32_x2)))
+svbfloat16_t svcvtn_bf16(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtn_f16_f32_x2)))
+svfloat16_t svcvtn_f16(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_bf16_x2)))
+svbfloat16x2_t svmax(svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x2)))
+svfloat64x2_t svmax(svfloat64x2_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x2)))
+svfloat32x2_t svmax(svfloat32x2_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x2)))
+svfloat16x2_t svmax(svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x2)))
+svint8x2_t svmax(svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x2)))
+svint32x2_t svmax(svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x2)))
+svint64x2_t svmax(svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x2)))
+svint16x2_t svmax(svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x2)))
+svuint8x2_t svmax(svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x2)))
+svuint32x2_t svmax(svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x2)))
+svuint64x2_t svmax(svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x2)))
+svuint16x2_t svmax(svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_bf16_x4)))
+svbfloat16x4_t svmax(svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f64_x4)))
+svfloat64x4_t svmax(svfloat64x4_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f32_x4)))
+svfloat32x4_t svmax(svfloat32x4_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_f16_x4)))
+svfloat16x4_t svmax(svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s8_x4)))
+svint8x4_t svmax(svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s32_x4)))
+svint32x4_t svmax(svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s64_x4)))
+svint64x4_t svmax(svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_s16_x4)))
+svint16x4_t svmax(svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u8_x4)))
+svuint8x4_t svmax(svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u32_x4)))
+svuint32x4_t svmax(svuint32x4_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u64_x4)))
+svuint64x4_t svmax(svuint64x4_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_single_u16_x4)))
+svuint16x4_t svmax(svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x2)))
+svbfloat16x2_t svmax(svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x2)))
+svfloat64x2_t svmax(svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x2)))
+svfloat32x2_t svmax(svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x2)))
+svfloat16x2_t svmax(svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x2)))
+svint8x2_t svmax(svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x2)))
+svint32x2_t svmax(svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x2)))
+svint64x2_t svmax(svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x2)))
+svint16x2_t svmax(svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x2)))
+svuint8x2_t svmax(svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x2)))
+svuint32x2_t svmax(svuint32x2_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x2)))
+svuint64x2_t svmax(svuint64x2_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x2)))
+svuint16x2_t svmax(svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x4)))
+svbfloat16x4_t svmax(svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x4)))
+svfloat64x4_t svmax(svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x4)))
+svfloat32x4_t svmax(svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x4)))
+svfloat16x4_t svmax(svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x4)))
+svint8x4_t svmax(svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x4)))
+svint32x4_t svmax(svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x4)))
+svint64x4_t svmax(svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x4)))
+svint16x4_t svmax(svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x4)))
+svuint8x4_t svmax(svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x4)))
+svuint32x4_t svmax(svuint32x4_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x4)))
+svuint64x4_t svmax(svuint64x4_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x4)))
+svuint16x4_t svmax(svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_bf16_x2)))
+svbfloat16x2_t svmaxnm(svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x2)))
+svfloat64x2_t svmaxnm(svfloat64x2_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x2)))
+svfloat32x2_t svmaxnm(svfloat32x2_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x2)))
+svfloat16x2_t svmaxnm(svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_bf16_x4)))
+svbfloat16x4_t svmaxnm(svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f64_x4)))
+svfloat64x4_t svmaxnm(svfloat64x4_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f32_x4)))
+svfloat32x4_t svmaxnm(svfloat32x4_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_single_f16_x4)))
+svfloat16x4_t svmaxnm(svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x2)))
+svbfloat16x2_t svmaxnm(svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x2)))
+svfloat64x2_t svmaxnm(svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x2)))
+svfloat32x2_t svmaxnm(svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x2)))
+svfloat16x2_t svmaxnm(svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x4)))
+svbfloat16x4_t svmaxnm(svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x4)))
+svfloat64x4_t svmaxnm(svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x4)))
+svfloat32x4_t svmaxnm(svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x4)))
+svfloat16x4_t svmaxnm(svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_bf16_x2)))
+svbfloat16x2_t svmin(svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x2)))
+svfloat64x2_t svmin(svfloat64x2_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x2)))
+svfloat32x2_t svmin(svfloat32x2_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x2)))
+svfloat16x2_t svmin(svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x2)))
+svint8x2_t svmin(svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x2)))
+svint32x2_t svmin(svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x2)))
+svint64x2_t svmin(svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x2)))
+svint16x2_t svmin(svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x2)))
+svuint8x2_t svmin(svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x2)))
+svuint32x2_t svmin(svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x2)))
+svuint64x2_t svmin(svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x2)))
+svuint16x2_t svmin(svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_bf16_x4)))
+svbfloat16x4_t svmin(svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f64_x4)))
+svfloat64x4_t svmin(svfloat64x4_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f32_x4)))
+svfloat32x4_t svmin(svfloat32x4_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_f16_x4)))
+svfloat16x4_t svmin(svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s8_x4)))
+svint8x4_t svmin(svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s32_x4)))
+svint32x4_t svmin(svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s64_x4)))
+svint64x4_t svmin(svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_s16_x4)))
+svint16x4_t svmin(svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u8_x4)))
+svuint8x4_t svmin(svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u32_x4)))
+svuint32x4_t svmin(svuint32x4_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u64_x4)))
+svuint64x4_t svmin(svuint64x4_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_single_u16_x4)))
+svuint16x4_t svmin(svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x2)))
+svbfloat16x2_t svmin(svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x2)))
+svfloat64x2_t svmin(svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x2)))
+svfloat32x2_t svmin(svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x2)))
+svfloat16x2_t svmin(svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x2)))
+svint8x2_t svmin(svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x2)))
+svint32x2_t svmin(svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x2)))
+svint64x2_t svmin(svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x2)))
+svint16x2_t svmin(svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x2)))
+svuint8x2_t svmin(svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x2)))
+svuint32x2_t svmin(svuint32x2_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x2)))
+svuint64x2_t svmin(svuint64x2_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x2)))
+svuint16x2_t svmin(svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x4)))
+svbfloat16x4_t svmin(svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x4)))
+svfloat64x4_t svmin(svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x4)))
+svfloat32x4_t svmin(svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x4)))
+svfloat16x4_t svmin(svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x4)))
+svint8x4_t svmin(svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x4)))
+svint32x4_t svmin(svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x4)))
+svint64x4_t svmin(svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x4)))
+svint16x4_t svmin(svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x4)))
+svuint8x4_t svmin(svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x4)))
+svuint32x4_t svmin(svuint32x4_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x4)))
+svuint64x4_t svmin(svuint64x4_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x4)))
+svuint16x4_t svmin(svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_bf16_x2)))
+svbfloat16x2_t svminnm(svbfloat16x2_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x2)))
+svfloat64x2_t svminnm(svfloat64x2_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x2)))
+svfloat32x2_t svminnm(svfloat32x2_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x2)))
+svfloat16x2_t svminnm(svfloat16x2_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_bf16_x4)))
+svbfloat16x4_t svminnm(svbfloat16x4_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f64_x4)))
+svfloat64x4_t svminnm(svfloat64x4_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f32_x4)))
+svfloat32x4_t svminnm(svfloat32x4_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_single_f16_x4)))
+svfloat16x4_t svminnm(svfloat16x4_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x2)))
+svbfloat16x2_t svminnm(svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x2)))
+svfloat64x2_t svminnm(svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x2)))
+svfloat32x2_t svminnm(svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x2)))
+svfloat16x2_t svminnm(svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x4)))
+svbfloat16x4_t svminnm(svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x4)))
+svfloat64x4_t svminnm(svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x4)))
+svfloat32x4_t svminnm(svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x4)))
+svfloat16x4_t svminnm(svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s32_x2)))
+svint16_t svqcvt_s16(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s16_s64_x4)))
+svint16_t svqcvt_s16(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_s8_s32_x4)))
+svint8_t svqcvt_s8(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s32_x2)))
+svuint16_t svqcvt_u16(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u32_x2)))
+svuint16_t svqcvt_u16(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_s64_x4)))
+svuint16_t svqcvt_u16(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u16_u64_x4)))
+svuint16_t svqcvt_u16(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_s32_x4)))
+svuint8_t svqcvt_u8(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvt_u8_u32_x4)))
+svuint8_t svqcvt_u8(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s64_x4)))
+svint16_t svqcvtn_s16(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s8_s32_x4)))
+svint8_t svqcvtn_s8(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s64_x4)))
+svuint16_t svqcvtn_u16(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u64_x4)))
+svuint16_t svqcvtn_u16(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_s32_x4)))
+svuint8_t svqcvtn_u8(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u8_u32_x4)))
+svuint8_t svqcvtn_u8(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x2)))
+svint8x2_t svqdmulh(svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x2)))
+svint32x2_t svqdmulh(svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x2)))
+svint64x2_t svqdmulh(svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x2)))
+svint16x2_t svqdmulh(svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s8_x4)))
+svint8x4_t svqdmulh(svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s32_x4)))
+svint32x4_t svqdmulh(svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s64_x4)))
+svint64x4_t svqdmulh(svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_single_s16_x4)))
+svint16x4_t svqdmulh(svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x2)))
+svint8x2_t svqdmulh(svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x2)))
+svint32x2_t svqdmulh(svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x2)))
+svint64x2_t svqdmulh(svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x2)))
+svint16x2_t svqdmulh(svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8_x4)))
+svint8x4_t svqdmulh(svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32_x4)))
+svint32x4_t svqdmulh(svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64_x4)))
+svint64x4_t svqdmulh(svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16_x4)))
+svint16x4_t svqdmulh(svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s32_x2)))
+svint16_t svqrshr_s16(svint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u32_x2)))
+svuint16_t svqrshr_u16(svuint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s8_s32_x4)))
+svint8_t svqrshr_s8(svint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_s16_s64_x4)))
+svint16_t svqrshr_s16(svint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u8_u32_x4)))
+svuint8_t svqrshr_u8(svuint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshr_n_u16_u64_x4)))
+svuint16_t svqrshr_u16(svuint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s8_s32_x4)))
+svint8_t svqrshrn_s8(svint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s16_s64_x4)))
+svint16_t svqrshrn_s16(svint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u8_u32_x4)))
+svuint8_t svqrshrn_u8(svuint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u16_u64_x4)))
+svuint16_t svqrshrn_u16(svuint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s32_x2)))
+svuint16_t svqrshru_u16(svint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u8_s32_x4)))
+svuint8_t svqrshru_u8(svint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshru_n_u16_s64_x4)))
+svuint16_t svqrshru_u16(svint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u8_s32_x4)))
+svuint8_t svqrshrun_u8(svint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u16_s64_x4)))
+svuint16_t svqrshrun_u16(svint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x2)))
+svfloat32x2_t svrinta(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x4)))
+svfloat32x4_t svrinta(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x2)))
+svfloat32x2_t svrintm(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x4)))
+svfloat32x4_t svrintm(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x2)))
+svfloat32x2_t svrintn(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x4)))
+svfloat32x4_t svrintn(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x2)))
+svfloat32x2_t svrintp(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x4)))
+svfloat32x4_t svrintp(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x2)))
+svint8x2_t svrshl(svint8x2_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x2)))
+svint32x2_t svrshl(svint32x2_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x2)))
+svint64x2_t svrshl(svint64x2_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x2)))
+svint16x2_t svrshl(svint16x2_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x2)))
+svuint8x2_t svrshl(svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x2)))
+svuint32x2_t svrshl(svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x2)))
+svuint64x2_t svrshl(svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x2)))
+svuint16x2_t svrshl(svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s8_x4)))
+svint8x4_t svrshl(svint8x4_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s32_x4)))
+svint32x4_t svrshl(svint32x4_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s64_x4)))
+svint64x4_t svrshl(svint64x4_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_s16_x4)))
+svint16x4_t svrshl(svint16x4_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u8_x4)))
+svuint8x4_t svrshl(svuint8x4_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u32_x4)))
+svuint32x4_t svrshl(svuint32x4_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u64_x4)))
+svuint64x4_t svrshl(svuint64x4_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_single_u16_x4)))
+svuint16x4_t svrshl(svuint16x4_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x2)))
+svint8x2_t svrshl(svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x2)))
+svint32x2_t svrshl(svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x2)))
+svint64x2_t svrshl(svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x2)))
+svint16x2_t svrshl(svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x2)))
+svuint8x2_t svrshl(svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x2)))
+svuint32x2_t svrshl(svuint32x2_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x2)))
+svuint64x2_t svrshl(svuint64x2_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x2)))
+svuint16x2_t svrshl(svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x4)))
+svint8x4_t svrshl(svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x4)))
+svint32x4_t svrshl(svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x4)))
+svint64x4_t svrshl(svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x4)))
+svint16x4_t svrshl(svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x4)))
+svuint8x4_t svrshl(svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x4)))
+svuint32x4_t svrshl(svuint32x4_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x4)))
+svuint64x4_t svrshl(svuint64x4_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x4)))
+svuint16x4_t svrshl(svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x2)))
+svuint8x2_t svsel(svcount_t, svuint8x2_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x2)))
+svuint32x2_t svsel(svcount_t, svuint32x2_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x2)))
+svuint64x2_t svsel(svcount_t, svuint64x2_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x2)))
+svuint16x2_t svsel(svcount_t, svuint16x2_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x2)))
+svbfloat16x2_t svsel(svcount_t, svbfloat16x2_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x2)))
+svint8x2_t svsel(svcount_t, svint8x2_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x2)))
+svfloat64x2_t svsel(svcount_t, svfloat64x2_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x2)))
+svfloat32x2_t svsel(svcount_t, svfloat32x2_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x2)))
+svfloat16x2_t svsel(svcount_t, svfloat16x2_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x2)))
+svint32x2_t svsel(svcount_t, svint32x2_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x2)))
+svint64x2_t svsel(svcount_t, svint64x2_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x2)))
+svint16x2_t svsel(svcount_t, svint16x2_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8_x4)))
+svuint8x4_t svsel(svcount_t, svuint8x4_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32_x4)))
+svuint32x4_t svsel(svcount_t, svuint32x4_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64_x4)))
+svuint64x4_t svsel(svcount_t, svuint64x4_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16_x4)))
+svuint16x4_t svsel(svcount_t, svuint16x4_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16_x4)))
+svbfloat16x4_t svsel(svcount_t, svbfloat16x4_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8_x4)))
+svint8x4_t svsel(svcount_t, svint8x4_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64_x4)))
+svfloat64x4_t svsel(svcount_t, svfloat64x4_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32_x4)))
+svfloat32x4_t svsel(svcount_t, svfloat32x4_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16_x4)))
+svfloat16x4_t svsel(svcount_t, svfloat16x4_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32_x4)))
+svint32x4_t svsel(svcount_t, svint32x4_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64_x4)))
+svint64x4_t svsel(svcount_t, svint64x4_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16_x4)))
+svint16x4_t svsel(svcount_t, svint16x4_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x2)))
+svint32x2_t svunpk_s32(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x2)))
+svint64x2_t svunpk_s64(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x2)))
+svint16x2_t svunpk_s16(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x2)))
+svuint32x2_t svunpk_u32(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x2)))
+svuint64x2_t svunpk_u64(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x2)))
+svuint16x2_t svunpk_u16(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s32_s16_x4)))
+svint32x4_t svunpk_s32(svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s64_s32_x4)))
+svint64x4_t svunpk_s64(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_s16_s8_x4)))
+svint16x4_t svunpk_s16(svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u32_u16_x4)))
+svuint32x4_t svunpk_u32(svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u64_u32_x4)))
+svuint64x4_t svunpk_u64(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpk_u16_u8_x4)))
+svuint16x4_t svunpk_u16(svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x2)))
+svuint8x2_t svuzp(svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x2)))
+svuint32x2_t svuzp(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x2)))
+svuint64x2_t svuzp(svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x2)))
+svuint16x2_t svuzp(svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x2)))
+svbfloat16x2_t svuzp(svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x2)))
+svint8x2_t svuzp(svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x2)))
+svfloat64x2_t svuzp(svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x2)))
+svfloat32x2_t svuzp(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x2)))
+svfloat16x2_t svuzp(svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x2)))
+svint32x2_t svuzp(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x2)))
+svint64x2_t svuzp(svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x2)))
+svint16x2_t svuzp(svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u8_x4)))
+svuint8x4_t svuzp(svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u32_x4)))
+svuint32x4_t svuzp(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u64_x4)))
+svuint64x4_t svuzp(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_u16_x4)))
+svuint16x4_t svuzp(svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_bf16_x4)))
+svbfloat16x4_t svuzp(svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s8_x4)))
+svint8x4_t svuzp(svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f64_x4)))
+svfloat64x4_t svuzp(svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f32_x4)))
+svfloat32x4_t svuzp(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_f16_x4)))
+svfloat16x4_t svuzp(svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s32_x4)))
+svint32x4_t svuzp(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s64_x4)))
+svint64x4_t svuzp(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp_s16_x4)))
+svint16x4_t svuzp(svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x2)))
+svuint8x2_t svuzpq(svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x2)))
+svuint32x2_t svuzpq(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x2)))
+svuint64x2_t svuzpq(svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x2)))
+svuint16x2_t svuzpq(svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x2)))
+svbfloat16x2_t svuzpq(svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x2)))
+svint8x2_t svuzpq(svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x2)))
+svfloat64x2_t svuzpq(svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x2)))
+svfloat32x2_t svuzpq(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x2)))
+svfloat16x2_t svuzpq(svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x2)))
+svint32x2_t svuzpq(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x2)))
+svint64x2_t svuzpq(svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x2)))
+svint16x2_t svuzpq(svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u8_x4)))
+svuint8x4_t svuzpq(svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u32_x4)))
+svuint32x4_t svuzpq(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u64_x4)))
+svuint64x4_t svuzpq(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_u16_x4)))
+svuint16x4_t svuzpq(svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_bf16_x4)))
+svbfloat16x4_t svuzpq(svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s8_x4)))
+svint8x4_t svuzpq(svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f64_x4)))
+svfloat64x4_t svuzpq(svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f32_x4)))
+svfloat32x4_t svuzpq(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_f16_x4)))
+svfloat16x4_t svuzpq(svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s32_x4)))
+svint32x4_t svuzpq(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s64_x4)))
+svint64x4_t svuzpq(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq_s16_x4)))
+svint16x4_t svuzpq(svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x2)))
+svuint8x2_t svzip(svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x2)))
+svuint32x2_t svzip(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x2)))
+svuint64x2_t svzip(svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x2)))
+svuint16x2_t svzip(svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x2)))
+svbfloat16x2_t svzip(svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x2)))
+svint8x2_t svzip(svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x2)))
+svfloat64x2_t svzip(svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x2)))
+svfloat32x2_t svzip(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x2)))
+svfloat16x2_t svzip(svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x2)))
+svint32x2_t svzip(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x2)))
+svint64x2_t svzip(svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x2)))
+svint16x2_t svzip(svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u8_x4)))
+svuint8x4_t svzip(svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u32_x4)))
+svuint32x4_t svzip(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u64_x4)))
+svuint64x4_t svzip(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_u16_x4)))
+svuint16x4_t svzip(svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_bf16_x4)))
+svbfloat16x4_t svzip(svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s8_x4)))
+svint8x4_t svzip(svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f64_x4)))
+svfloat64x4_t svzip(svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f32_x4)))
+svfloat32x4_t svzip(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_f16_x4)))
+svfloat16x4_t svzip(svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s32_x4)))
+svint32x4_t svzip(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s64_x4)))
+svint64x4_t svzip(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip_s16_x4)))
+svint16x4_t svzip(svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x2)))
+svuint8x2_t svzipq(svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x2)))
+svuint32x2_t svzipq(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x2)))
+svuint64x2_t svzipq(svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x2)))
+svuint16x2_t svzipq(svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x2)))
+svbfloat16x2_t svzipq(svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x2)))
+svint8x2_t svzipq(svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x2)))
+svfloat64x2_t svzipq(svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x2)))
+svfloat32x2_t svzipq(svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x2)))
+svfloat16x2_t svzipq(svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x2)))
+svint32x2_t svzipq(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x2)))
+svint64x2_t svzipq(svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x2)))
+svint16x2_t svzipq(svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u8_x4)))
+svuint8x4_t svzipq(svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u32_x4)))
+svuint32x4_t svzipq(svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u64_x4)))
+svuint64x4_t svzipq(svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_u16_x4)))
+svuint16x4_t svzipq(svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_bf16_x4)))
+svbfloat16x4_t svzipq(svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s8_x4)))
+svint8x4_t svzipq(svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f64_x4)))
+svfloat64x4_t svzipq(svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f32_x4)))
+svfloat32x4_t svzipq(svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_f16_x4)))
+svfloat16x4_t svzipq(svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s32_x4)))
+svint32x4_t svzipq(svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s64_x4)))
+svint64x4_t svzipq(svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq_s16_x4)))
+svint16x4_t svzipq(svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_bf16_x2)))
+svbfloat16x2_t svclamp_single_bf16_x2(svbfloat16x2_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_bf16_x4)))
+svbfloat16x4_t svclamp_single_bf16_x4(svbfloat16x4_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_bf16_x2)))
+svbfloat16x2_t svclamp(svbfloat16x2_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_single_bf16_x4)))
+svbfloat16x4_t svclamp(svbfloat16x4_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_u32offset)))
+svuint32_t svadrb_u32base_u32offset(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_u64offset)))
+svuint64_t svadrb_u64base_u64offset(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_s32offset)))
+svuint32_t svadrb_u32base_s32offset(svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_s64offset)))
+svuint64_t svadrb_u64base_s64offset(svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_u32index)))
+svuint32_t svadrd_u32base_u32index(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_u64index)))
+svuint64_t svadrd_u64base_u64index(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_s32index)))
+svuint32_t svadrd_u32base_s32index(svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_s64index)))
+svuint64_t svadrd_u64base_s64index(svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_u32index)))
+svuint32_t svadrh_u32base_u32index(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_u64index)))
+svuint64_t svadrh_u64base_u64index(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_s32index)))
+svuint32_t svadrh_u32base_s32index(svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_s64index)))
+svuint64_t svadrh_u64base_s64index(svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_u32index)))
+svuint32_t svadrw_u32base_u32index(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_u64index)))
+svuint64_t svadrw_u64base_u64index(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_s32index)))
+svuint32_t svadrw_u32base_s32index(svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_s64index)))
+svuint64_t svadrw_u64base_s64index(svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u32)))
+svuint32_t svcompact_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u64)))
+svuint64_t svcompact_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f64)))
+svfloat64_t svcompact_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f32)))
+svfloat32_t svcompact_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s32)))
+svint32_t svcompact_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s64)))
+svint64_t svcompact_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f64)))
+svfloat64_t svexpa_f64(svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f32)))
+svfloat32_t svexpa_f32(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f16)))
+svfloat16_t svexpa_f16(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_u32)))
+svuint32_t svld1_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_u64)))
+svuint64_t svld1_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_f64)))
+svfloat64_t svld1_gather_u64base_index_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_f32)))
+svfloat32_t svld1_gather_u32base_index_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_s32)))
+svint32_t svld1_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_s64)))
+svint64_t svld1_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_u32)))
+svuint32_t svld1_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_u64)))
+svuint64_t svld1_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_f64)))
+svfloat64_t svld1_gather_u64base_offset_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_f32)))
+svfloat32_t svld1_gather_u32base_offset_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_s32)))
+svint32_t svld1_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_s64)))
+svint64_t svld1_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_u32)))
+svuint32_t svld1_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_u64)))
+svuint64_t svld1_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_f64)))
+svfloat64_t svld1_gather_u64base_f64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_f32)))
+svfloat32_t svld1_gather_u32base_f32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_s32)))
+svint32_t svld1_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_s64)))
+svint64_t svld1_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_u32)))
+svuint32_t svld1_gather_s32index_u32(svbool_t, uint32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_f32)))
+svfloat32_t svld1_gather_s32index_f32(svbool_t, float32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_s32)))
+svint32_t svld1_gather_s32index_s32(svbool_t, int32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_u32)))
+svuint32_t svld1_gather_u32index_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_f32)))
+svfloat32_t svld1_gather_u32index_f32(svbool_t, float32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_s32)))
+svint32_t svld1_gather_u32index_s32(svbool_t, int32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_u64)))
+svuint64_t svld1_gather_s64index_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_f64)))
+svfloat64_t svld1_gather_s64index_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_s64)))
+svint64_t svld1_gather_s64index_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_u64)))
+svuint64_t svld1_gather_u64index_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_f64)))
+svfloat64_t svld1_gather_u64index_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_s64)))
+svint64_t svld1_gather_u64index_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_u32)))
+svuint32_t svld1_gather_s32offset_u32(svbool_t, uint32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_f32)))
+svfloat32_t svld1_gather_s32offset_f32(svbool_t, float32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_s32)))
+svint32_t svld1_gather_s32offset_s32(svbool_t, int32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_u32)))
+svuint32_t svld1_gather_u32offset_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_f32)))
+svfloat32_t svld1_gather_u32offset_f32(svbool_t, float32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_s32)))
+svint32_t svld1_gather_u32offset_s32(svbool_t, int32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_u64)))
+svuint64_t svld1_gather_s64offset_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_f64)))
+svfloat64_t svld1_gather_s64offset_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_s64)))
+svint64_t svld1_gather_s64offset_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_u64)))
+svuint64_t svld1_gather_u64offset_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_f64)))
+svfloat64_t svld1_gather_u64offset_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_s64)))
+svint64_t svld1_gather_u64offset_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_u32)))
+svuint32_t svld1sb_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_u64)))
+svuint64_t svld1sb_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_s32)))
+svint32_t svld1sb_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_s64)))
+svint64_t svld1sb_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_u32)))
+svuint32_t svld1sb_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_u64)))
+svuint64_t svld1sb_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_s32)))
+svint32_t svld1sb_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_s64)))
+svint64_t svld1sb_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_u32)))
+svuint32_t svld1sb_gather_s32offset_u32(svbool_t, int8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_s32)))
+svint32_t svld1sb_gather_s32offset_s32(svbool_t, int8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_u32)))
+svuint32_t svld1sb_gather_u32offset_u32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_s32)))
+svint32_t svld1sb_gather_u32offset_s32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_u64)))
+svuint64_t svld1sb_gather_s64offset_u64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_s64)))
+svint64_t svld1sb_gather_s64offset_s64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_u64)))
+svuint64_t svld1sb_gather_u64offset_u64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_s64)))
+svint64_t svld1sb_gather_u64offset_s64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_u32)))
+svuint32_t svld1sh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_u64)))
+svuint64_t svld1sh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_s32)))
+svint32_t svld1sh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_s64)))
+svint64_t svld1sh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_u32)))
+svuint32_t svld1sh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_u64)))
+svuint64_t svld1sh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_s32)))
+svint32_t svld1sh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_s64)))
+svint64_t svld1sh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_u32)))
+svuint32_t svld1sh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_u64)))
+svuint64_t svld1sh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_s32)))
+svint32_t svld1sh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_s64)))
+svint64_t svld1sh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_u32)))
+svuint32_t svld1sh_gather_s32index_u32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_s32)))
+svint32_t svld1sh_gather_s32index_s32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_u32)))
+svuint32_t svld1sh_gather_u32index_u32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_s32)))
+svint32_t svld1sh_gather_u32index_s32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_u64)))
+svuint64_t svld1sh_gather_s64index_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_s64)))
+svint64_t svld1sh_gather_s64index_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_u64)))
+svuint64_t svld1sh_gather_u64index_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_s64)))
+svint64_t svld1sh_gather_u64index_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_u32)))
+svuint32_t svld1sh_gather_s32offset_u32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_s32)))
+svint32_t svld1sh_gather_s32offset_s32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_u32)))
+svuint32_t svld1sh_gather_u32offset_u32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_s32)))
+svint32_t svld1sh_gather_u32offset_s32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_u64)))
+svuint64_t svld1sh_gather_s64offset_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_s64)))
+svint64_t svld1sh_gather_s64offset_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_u64)))
+svuint64_t svld1sh_gather_u64offset_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_s64)))
+svint64_t svld1sh_gather_u64offset_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_u64)))
+svuint64_t svld1sw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_s64)))
+svint64_t svld1sw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_u64)))
+svuint64_t svld1sw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_s64)))
+svint64_t svld1sw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_u64)))
+svuint64_t svld1sw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_s64)))
+svint64_t svld1sw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_u64)))
+svuint64_t svld1sw_gather_s64index_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_s64)))
+svint64_t svld1sw_gather_s64index_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_u64)))
+svuint64_t svld1sw_gather_u64index_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_s64)))
+svint64_t svld1sw_gather_u64index_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_u64)))
+svuint64_t svld1sw_gather_s64offset_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_s64)))
+svint64_t svld1sw_gather_s64offset_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_u64)))
+svuint64_t svld1sw_gather_u64offset_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_s64)))
+svint64_t svld1sw_gather_u64offset_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_u32)))
+svuint32_t svld1ub_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_u64)))
+svuint64_t svld1ub_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_s32)))
+svint32_t svld1ub_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_s64)))
+svint64_t svld1ub_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_u32)))
+svuint32_t svld1ub_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_u64)))
+svuint64_t svld1ub_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_s32)))
+svint32_t svld1ub_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_s64)))
+svint64_t svld1ub_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_u32)))
+svuint32_t svld1ub_gather_s32offset_u32(svbool_t, uint8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_s32)))
+svint32_t svld1ub_gather_s32offset_s32(svbool_t, uint8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_u32)))
+svuint32_t svld1ub_gather_u32offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_s32)))
+svint32_t svld1ub_gather_u32offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_u64)))
+svuint64_t svld1ub_gather_s64offset_u64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_s64)))
+svint64_t svld1ub_gather_s64offset_s64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_u64)))
+svuint64_t svld1ub_gather_u64offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_s64)))
+svint64_t svld1ub_gather_u64offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_u32)))
+svuint32_t svld1uh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_u64)))
+svuint64_t svld1uh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_s32)))
+svint32_t svld1uh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_s64)))
+svint64_t svld1uh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_u32)))
+svuint32_t svld1uh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_u64)))
+svuint64_t svld1uh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_s32)))
+svint32_t svld1uh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_s64)))
+svint64_t svld1uh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_u32)))
+svuint32_t svld1uh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_u64)))
+svuint64_t svld1uh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_s32)))
+svint32_t svld1uh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_s64)))
+svint64_t svld1uh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_u32)))
+svuint32_t svld1uh_gather_s32index_u32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_s32)))
+svint32_t svld1uh_gather_s32index_s32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_u32)))
+svuint32_t svld1uh_gather_u32index_u32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_s32)))
+svint32_t svld1uh_gather_u32index_s32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_u64)))
+svuint64_t svld1uh_gather_s64index_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_s64)))
+svint64_t svld1uh_gather_s64index_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_u64)))
+svuint64_t svld1uh_gather_u64index_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_s64)))
+svint64_t svld1uh_gather_u64index_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_u32)))
+svuint32_t svld1uh_gather_s32offset_u32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_s32)))
+svint32_t svld1uh_gather_s32offset_s32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_u32)))
+svuint32_t svld1uh_gather_u32offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_s32)))
+svint32_t svld1uh_gather_u32offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_u64)))
+svuint64_t svld1uh_gather_s64offset_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_s64)))
+svint64_t svld1uh_gather_s64offset_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_u64)))
+svuint64_t svld1uh_gather_u64offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_s64)))
+svint64_t svld1uh_gather_u64offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_u64)))
+svuint64_t svld1uw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_s64)))
+svint64_t svld1uw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_u64)))
+svuint64_t svld1uw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_s64)))
+svint64_t svld1uw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_u64)))
+svuint64_t svld1uw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_s64)))
+svint64_t svld1uw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_u64)))
+svuint64_t svld1uw_gather_s64index_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_s64)))
+svint64_t svld1uw_gather_s64index_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_u64)))
+svuint64_t svld1uw_gather_u64index_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_s64)))
+svint64_t svld1uw_gather_u64index_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_u64)))
+svuint64_t svld1uw_gather_s64offset_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_s64)))
+svint64_t svld1uw_gather_s64offset_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_u64)))
+svuint64_t svld1uw_gather_u64offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_s64)))
+svint64_t svld1uw_gather_u64offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u8)))
+svuint8_t svldff1_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u32)))
+svuint32_t svldff1_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u64)))
+svuint64_t svldff1_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u16)))
+svuint16_t svldff1_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s8)))
+svint8_t svldff1_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f64)))
+svfloat64_t svldff1_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f32)))
+svfloat32_t svldff1_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f16)))
+svfloat16_t svldff1_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s32)))
+svint32_t svldff1_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s64)))
+svint64_t svldff1_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s16)))
+svint16_t svldff1_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_u32)))
+svuint32_t svldff1_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_u64)))
+svuint64_t svldff1_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_f64)))
+svfloat64_t svldff1_gather_u64base_index_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_f32)))
+svfloat32_t svldff1_gather_u32base_index_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_s32)))
+svint32_t svldff1_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_s64)))
+svint64_t svldff1_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_u32)))
+svuint32_t svldff1_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_u64)))
+svuint64_t svldff1_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_f64)))
+svfloat64_t svldff1_gather_u64base_offset_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_f32)))
+svfloat32_t svldff1_gather_u32base_offset_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_s32)))
+svint32_t svldff1_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_s64)))
+svint64_t svldff1_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_u32)))
+svuint32_t svldff1_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_u64)))
+svuint64_t svldff1_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_f64)))
+svfloat64_t svldff1_gather_u64base_f64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_f32)))
+svfloat32_t svldff1_gather_u32base_f32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_s32)))
+svint32_t svldff1_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_s64)))
+svint64_t svldff1_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_u32)))
+svuint32_t svldff1_gather_s32index_u32(svbool_t, uint32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_f32)))
+svfloat32_t svldff1_gather_s32index_f32(svbool_t, float32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_s32)))
+svint32_t svldff1_gather_s32index_s32(svbool_t, int32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_u32)))
+svuint32_t svldff1_gather_u32index_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_f32)))
+svfloat32_t svldff1_gather_u32index_f32(svbool_t, float32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_s32)))
+svint32_t svldff1_gather_u32index_s32(svbool_t, int32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_u64)))
+svuint64_t svldff1_gather_s64index_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_f64)))
+svfloat64_t svldff1_gather_s64index_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_s64)))
+svint64_t svldff1_gather_s64index_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_u64)))
+svuint64_t svldff1_gather_u64index_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_f64)))
+svfloat64_t svldff1_gather_u64index_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_s64)))
+svint64_t svldff1_gather_u64index_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_u32)))
+svuint32_t svldff1_gather_s32offset_u32(svbool_t, uint32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_f32)))
+svfloat32_t svldff1_gather_s32offset_f32(svbool_t, float32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_s32)))
+svint32_t svldff1_gather_s32offset_s32(svbool_t, int32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_u32)))
+svuint32_t svldff1_gather_u32offset_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_f32)))
+svfloat32_t svldff1_gather_u32offset_f32(svbool_t, float32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_s32)))
+svint32_t svldff1_gather_u32offset_s32(svbool_t, int32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_u64)))
+svuint64_t svldff1_gather_s64offset_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_f64)))
+svfloat64_t svldff1_gather_s64offset_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_s64)))
+svint64_t svldff1_gather_s64offset_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_u64)))
+svuint64_t svldff1_gather_u64offset_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_f64)))
+svfloat64_t svldff1_gather_u64offset_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_s64)))
+svint64_t svldff1_gather_u64offset_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u8)))
+svuint8_t svldff1_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u32)))
+svuint32_t svldff1_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u64)))
+svuint64_t svldff1_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u16)))
+svuint16_t svldff1_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s8)))
+svint8_t svldff1_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f64)))
+svfloat64_t svldff1_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f32)))
+svfloat32_t svldff1_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f16)))
+svfloat16_t svldff1_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s32)))
+svint32_t svldff1_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s64)))
+svint64_t svldff1_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s16)))
+svint16_t svldff1_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_u32)))
+svuint32_t svldff1sb_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_u64)))
+svuint64_t svldff1sb_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_s32)))
+svint32_t svldff1sb_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_s64)))
+svint64_t svldff1sb_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_u32)))
+svuint32_t svldff1sb_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_u64)))
+svuint64_t svldff1sb_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_s32)))
+svint32_t svldff1sb_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_s64)))
+svint64_t svldff1sb_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_u32)))
+svuint32_t svldff1sb_gather_s32offset_u32(svbool_t, int8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_s32)))
+svint32_t svldff1sb_gather_s32offset_s32(svbool_t, int8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_u32)))
+svuint32_t svldff1sb_gather_u32offset_u32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_s32)))
+svint32_t svldff1sb_gather_u32offset_s32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_u64)))
+svuint64_t svldff1sb_gather_s64offset_u64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_s64)))
+svint64_t svldff1sb_gather_s64offset_s64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_u64)))
+svuint64_t svldff1sb_gather_u64offset_u64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_s64)))
+svint64_t svldff1sb_gather_u64offset_s64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_u32)))
+svuint32_t svldff1sb_vnum_u32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_u64)))
+svuint64_t svldff1sb_vnum_u64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_u16)))
+svuint16_t svldff1sb_vnum_u16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_s32)))
+svint32_t svldff1sb_vnum_s32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_s64)))
+svint64_t svldff1sb_vnum_s64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_vnum_s16)))
+svint16_t svldff1sb_vnum_s16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_u32)))
+svuint32_t svldff1sb_u32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_u64)))
+svuint64_t svldff1sb_u64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_u16)))
+svuint16_t svldff1sb_u16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_s32)))
+svint32_t svldff1sb_s32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_s64)))
+svint64_t svldff1sb_s64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_s16)))
+svint16_t svldff1sb_s16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_u32)))
+svuint32_t svldff1sh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_u64)))
+svuint64_t svldff1sh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_s32)))
+svint32_t svldff1sh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_s64)))
+svint64_t svldff1sh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_u32)))
+svuint32_t svldff1sh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_u64)))
+svuint64_t svldff1sh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_s32)))
+svint32_t svldff1sh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_s64)))
+svint64_t svldff1sh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_u32)))
+svuint32_t svldff1sh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_u64)))
+svuint64_t svldff1sh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_s32)))
+svint32_t svldff1sh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_s64)))
+svint64_t svldff1sh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_u32)))
+svuint32_t svldff1sh_gather_s32index_u32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_s32)))
+svint32_t svldff1sh_gather_s32index_s32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_u32)))
+svuint32_t svldff1sh_gather_u32index_u32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_s32)))
+svint32_t svldff1sh_gather_u32index_s32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_u64)))
+svuint64_t svldff1sh_gather_s64index_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_s64)))
+svint64_t svldff1sh_gather_s64index_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_u64)))
+svuint64_t svldff1sh_gather_u64index_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_s64)))
+svint64_t svldff1sh_gather_u64index_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_u32)))
+svuint32_t svldff1sh_gather_s32offset_u32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_s32)))
+svint32_t svldff1sh_gather_s32offset_s32(svbool_t, int16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_u32)))
+svuint32_t svldff1sh_gather_u32offset_u32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_s32)))
+svint32_t svldff1sh_gather_u32offset_s32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_u64)))
+svuint64_t svldff1sh_gather_s64offset_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_s64)))
+svint64_t svldff1sh_gather_s64offset_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_u64)))
+svuint64_t svldff1sh_gather_u64offset_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_s64)))
+svint64_t svldff1sh_gather_u64offset_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_u32)))
+svuint32_t svldff1sh_vnum_u32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_u64)))
+svuint64_t svldff1sh_vnum_u64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_s32)))
+svint32_t svldff1sh_vnum_s32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_vnum_s64)))
+svint64_t svldff1sh_vnum_s64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_u32)))
+svuint32_t svldff1sh_u32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_u64)))
+svuint64_t svldff1sh_u64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_s32)))
+svint32_t svldff1sh_s32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_s64)))
+svint64_t svldff1sh_s64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_u64)))
+svuint64_t svldff1sw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_s64)))
+svint64_t svldff1sw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_u64)))
+svuint64_t svldff1sw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_s64)))
+svint64_t svldff1sw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_u64)))
+svuint64_t svldff1sw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_s64)))
+svint64_t svldff1sw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_u64)))
+svuint64_t svldff1sw_gather_s64index_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_s64)))
+svint64_t svldff1sw_gather_s64index_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_u64)))
+svuint64_t svldff1sw_gather_u64index_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_s64)))
+svint64_t svldff1sw_gather_u64index_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_u64)))
+svuint64_t svldff1sw_gather_s64offset_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_s64)))
+svint64_t svldff1sw_gather_s64offset_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_u64)))
+svuint64_t svldff1sw_gather_u64offset_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_s64)))
+svint64_t svldff1sw_gather_u64offset_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_vnum_u64)))
+svuint64_t svldff1sw_vnum_u64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_vnum_s64)))
+svint64_t svldff1sw_vnum_s64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_u64)))
+svuint64_t svldff1sw_u64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_s64)))
+svint64_t svldff1sw_s64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_u32)))
+svuint32_t svldff1ub_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_u64)))
+svuint64_t svldff1ub_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_s32)))
+svint32_t svldff1ub_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_s64)))
+svint64_t svldff1ub_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_u32)))
+svuint32_t svldff1ub_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_u64)))
+svuint64_t svldff1ub_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_s32)))
+svint32_t svldff1ub_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_s64)))
+svint64_t svldff1ub_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_u32)))
+svuint32_t svldff1ub_gather_s32offset_u32(svbool_t, uint8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_s32)))
+svint32_t svldff1ub_gather_s32offset_s32(svbool_t, uint8_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_u32)))
+svuint32_t svldff1ub_gather_u32offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_s32)))
+svint32_t svldff1ub_gather_u32offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_u64)))
+svuint64_t svldff1ub_gather_s64offset_u64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_s64)))
+svint64_t svldff1ub_gather_s64offset_s64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_u64)))
+svuint64_t svldff1ub_gather_u64offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_s64)))
+svint64_t svldff1ub_gather_u64offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_u32)))
+svuint32_t svldff1ub_vnum_u32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_u64)))
+svuint64_t svldff1ub_vnum_u64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_u16)))
+svuint16_t svldff1ub_vnum_u16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_s32)))
+svint32_t svldff1ub_vnum_s32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_s64)))
+svint64_t svldff1ub_vnum_s64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_vnum_s16)))
+svint16_t svldff1ub_vnum_s16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_u32)))
+svuint32_t svldff1ub_u32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_u64)))
+svuint64_t svldff1ub_u64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_u16)))
+svuint16_t svldff1ub_u16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_s32)))
+svint32_t svldff1ub_s32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_s64)))
+svint64_t svldff1ub_s64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_s16)))
+svint16_t svldff1ub_s16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_u32)))
+svuint32_t svldff1uh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_u64)))
+svuint64_t svldff1uh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_s32)))
+svint32_t svldff1uh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_s64)))
+svint64_t svldff1uh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_u32)))
+svuint32_t svldff1uh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_u64)))
+svuint64_t svldff1uh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_s32)))
+svint32_t svldff1uh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_s64)))
+svint64_t svldff1uh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_u32)))
+svuint32_t svldff1uh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_u64)))
+svuint64_t svldff1uh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_s32)))
+svint32_t svldff1uh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_s64)))
+svint64_t svldff1uh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_u32)))
+svuint32_t svldff1uh_gather_s32index_u32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_s32)))
+svint32_t svldff1uh_gather_s32index_s32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_u32)))
+svuint32_t svldff1uh_gather_u32index_u32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_s32)))
+svint32_t svldff1uh_gather_u32index_s32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_u64)))
+svuint64_t svldff1uh_gather_s64index_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_s64)))
+svint64_t svldff1uh_gather_s64index_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_u64)))
+svuint64_t svldff1uh_gather_u64index_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_s64)))
+svint64_t svldff1uh_gather_u64index_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_u32)))
+svuint32_t svldff1uh_gather_s32offset_u32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_s32)))
+svint32_t svldff1uh_gather_s32offset_s32(svbool_t, uint16_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_u32)))
+svuint32_t svldff1uh_gather_u32offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_s32)))
+svint32_t svldff1uh_gather_u32offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_u64)))
+svuint64_t svldff1uh_gather_s64offset_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_s64)))
+svint64_t svldff1uh_gather_s64offset_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_u64)))
+svuint64_t svldff1uh_gather_u64offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_s64)))
+svint64_t svldff1uh_gather_u64offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_u32)))
+svuint32_t svldff1uh_vnum_u32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_u64)))
+svuint64_t svldff1uh_vnum_u64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_s32)))
+svint32_t svldff1uh_vnum_s32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_vnum_s64)))
+svint64_t svldff1uh_vnum_s64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_u32)))
+svuint32_t svldff1uh_u32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_u64)))
+svuint64_t svldff1uh_u64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_s32)))
+svint32_t svldff1uh_s32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_s64)))
+svint64_t svldff1uh_s64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_u64)))
+svuint64_t svldff1uw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_s64)))
+svint64_t svldff1uw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_u64)))
+svuint64_t svldff1uw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_s64)))
+svint64_t svldff1uw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_u64)))
+svuint64_t svldff1uw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_s64)))
+svint64_t svldff1uw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_u64)))
+svuint64_t svldff1uw_gather_s64index_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_s64)))
+svint64_t svldff1uw_gather_s64index_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_u64)))
+svuint64_t svldff1uw_gather_u64index_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_s64)))
+svint64_t svldff1uw_gather_u64index_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_u64)))
+svuint64_t svldff1uw_gather_s64offset_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_s64)))
+svint64_t svldff1uw_gather_s64offset_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_u64)))
+svuint64_t svldff1uw_gather_u64offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_s64)))
+svint64_t svldff1uw_gather_u64offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_vnum_u64)))
+svuint64_t svldff1uw_vnum_u64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_vnum_s64)))
+svint64_t svldff1uw_vnum_s64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_u64)))
+svuint64_t svldff1uw_u64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_s64)))
+svint64_t svldff1uw_s64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u8)))
+svuint8_t svldnf1_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u32)))
+svuint32_t svldnf1_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u64)))
+svuint64_t svldnf1_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u16)))
+svuint16_t svldnf1_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s8)))
+svint8_t svldnf1_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f64)))
+svfloat64_t svldnf1_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f32)))
+svfloat32_t svldnf1_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f16)))
+svfloat16_t svldnf1_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s32)))
+svint32_t svldnf1_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s64)))
+svint64_t svldnf1_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s16)))
+svint16_t svldnf1_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u8)))
+svuint8_t svldnf1_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u32)))
+svuint32_t svldnf1_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u64)))
+svuint64_t svldnf1_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u16)))
+svuint16_t svldnf1_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s8)))
+svint8_t svldnf1_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f64)))
+svfloat64_t svldnf1_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f32)))
+svfloat32_t svldnf1_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f16)))
+svfloat16_t svldnf1_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s32)))
+svint32_t svldnf1_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s64)))
+svint64_t svldnf1_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s16)))
+svint16_t svldnf1_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_u32)))
+svuint32_t svldnf1sb_vnum_u32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_u64)))
+svuint64_t svldnf1sb_vnum_u64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_u16)))
+svuint16_t svldnf1sb_vnum_u16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_s32)))
+svint32_t svldnf1sb_vnum_s32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_s64)))
+svint64_t svldnf1sb_vnum_s64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_vnum_s16)))
+svint16_t svldnf1sb_vnum_s16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_u32)))
+svuint32_t svldnf1sb_u32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_u64)))
+svuint64_t svldnf1sb_u64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_u16)))
+svuint16_t svldnf1sb_u16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_s32)))
+svint32_t svldnf1sb_s32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_s64)))
+svint64_t svldnf1sb_s64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sb_s16)))
+svint16_t svldnf1sb_s16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_u32)))
+svuint32_t svldnf1sh_vnum_u32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_u64)))
+svuint64_t svldnf1sh_vnum_u64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_s32)))
+svint32_t svldnf1sh_vnum_s32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_vnum_s64)))
+svint64_t svldnf1sh_vnum_s64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_u32)))
+svuint32_t svldnf1sh_u32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_u64)))
+svuint64_t svldnf1sh_u64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_s32)))
+svint32_t svldnf1sh_s32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sh_s64)))
+svint64_t svldnf1sh_s64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_vnum_u64)))
+svuint64_t svldnf1sw_vnum_u64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_vnum_s64)))
+svint64_t svldnf1sw_vnum_s64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_u64)))
+svuint64_t svldnf1sw_u64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1sw_s64)))
+svint64_t svldnf1sw_s64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_u32)))
+svuint32_t svldnf1ub_vnum_u32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_u64)))
+svuint64_t svldnf1ub_vnum_u64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_u16)))
+svuint16_t svldnf1ub_vnum_u16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_s32)))
+svint32_t svldnf1ub_vnum_s32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_s64)))
+svint64_t svldnf1ub_vnum_s64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_vnum_s16)))
+svint16_t svldnf1ub_vnum_s16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_u32)))
+svuint32_t svldnf1ub_u32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_u64)))
+svuint64_t svldnf1ub_u64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_u16)))
+svuint16_t svldnf1ub_u16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_s32)))
+svint32_t svldnf1ub_s32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_s64)))
+svint64_t svldnf1ub_s64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1ub_s16)))
+svint16_t svldnf1ub_s16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_u32)))
+svuint32_t svldnf1uh_vnum_u32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_u64)))
+svuint64_t svldnf1uh_vnum_u64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_s32)))
+svint32_t svldnf1uh_vnum_s32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_vnum_s64)))
+svint64_t svldnf1uh_vnum_s64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_u32)))
+svuint32_t svldnf1uh_u32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_u64)))
+svuint64_t svldnf1uh_u64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_s32)))
+svint32_t svldnf1uh_s32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uh_s64)))
+svint64_t svldnf1uh_s64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_vnum_u64)))
+svuint64_t svldnf1uw_vnum_u64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_vnum_s64)))
+svint64_t svldnf1uw_vnum_s64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_u64)))
+svuint64_t svldnf1uw_u64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1uw_s64)))
+svint64_t svldnf1uw_s64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base)))
+void svprfb_gather_u32base(svbool_t, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base)))
+void svprfb_gather_u64base(svbool_t, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base_offset)))
+void svprfb_gather_u32base_offset(svbool_t, svuint32_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base_offset)))
+void svprfb_gather_u64base_offset(svbool_t, svuint64_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s32offset)))
+void svprfb_gather_s32offset(svbool_t, void const *, svint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32offset)))
+void svprfb_gather_u32offset(svbool_t, void const *, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s64offset)))
+void svprfb_gather_s64offset(svbool_t, void const *, svint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64offset)))
+void svprfb_gather_u64offset(svbool_t, void const *, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base)))
+void svprfd_gather_u32base(svbool_t, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base)))
+void svprfd_gather_u64base(svbool_t, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base_index)))
+void svprfd_gather_u32base_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base_index)))
+void svprfd_gather_u64base_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s32index)))
+void svprfd_gather_s32index(svbool_t, void const *, svint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32index)))
+void svprfd_gather_u32index(svbool_t, void const *, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s64index)))
+void svprfd_gather_s64index(svbool_t, void const *, svint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64index)))
+void svprfd_gather_u64index(svbool_t, void const *, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base)))
+void svprfh_gather_u32base(svbool_t, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base)))
+void svprfh_gather_u64base(svbool_t, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base_index)))
+void svprfh_gather_u32base_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base_index)))
+void svprfh_gather_u64base_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s32index)))
+void svprfh_gather_s32index(svbool_t, void const *, svint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32index)))
+void svprfh_gather_u32index(svbool_t, void const *, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s64index)))
+void svprfh_gather_s64index(svbool_t, void const *, svint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64index)))
+void svprfh_gather_u64index(svbool_t, void const *, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base)))
+void svprfw_gather_u32base(svbool_t, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base)))
+void svprfw_gather_u64base(svbool_t, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base_index)))
+void svprfw_gather_u32base_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base_index)))
+void svprfw_gather_u64base_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s32index)))
+void svprfw_gather_s32index(svbool_t, void const *, svint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32index)))
+void svprfw_gather_u32index(svbool_t, void const *, svuint32_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s64index)))
+void svprfw_gather_s64index(svbool_t, void const *, svint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64index)))
+void svprfw_gather_u64index(svbool_t, void const *, svuint64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrdffr)))
+svbool_t svrdffr(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrdffr_z)))
+svbool_t svrdffr_z(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsetffr)))
+void svsetffr(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_u32)))
+void svst1_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_u64)))
+void svst1_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_f64)))
+void svst1_scatter_u64base_index_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_f32)))
+void svst1_scatter_u32base_index_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_s32)))
+void svst1_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_s64)))
+void svst1_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_u32)))
+void svst1_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_u64)))
+void svst1_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_f64)))
+void svst1_scatter_u64base_offset_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_f32)))
+void svst1_scatter_u32base_offset_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_s32)))
+void svst1_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_s64)))
+void svst1_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_u32)))
+void svst1_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_u64)))
+void svst1_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_f64)))
+void svst1_scatter_u64base_f64(svbool_t, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_f32)))
+void svst1_scatter_u32base_f32(svbool_t, svuint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_s32)))
+void svst1_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_s64)))
+void svst1_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_u32)))
+void svst1_scatter_s32index_u32(svbool_t, uint32_t *, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_f32)))
+void svst1_scatter_s32index_f32(svbool_t, float32_t *, svint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_s32)))
+void svst1_scatter_s32index_s32(svbool_t, int32_t *, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_u32)))
+void svst1_scatter_u32index_u32(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_f32)))
+void svst1_scatter_u32index_f32(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_s32)))
+void svst1_scatter_u32index_s32(svbool_t, int32_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_u64)))
+void svst1_scatter_s64index_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_f64)))
+void svst1_scatter_s64index_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_s64)))
+void svst1_scatter_s64index_s64(svbool_t, int64_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_u64)))
+void svst1_scatter_u64index_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_f64)))
+void svst1_scatter_u64index_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_s64)))
+void svst1_scatter_u64index_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_u32)))
+void svst1_scatter_s32offset_u32(svbool_t, uint32_t *, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_f32)))
+void svst1_scatter_s32offset_f32(svbool_t, float32_t *, svint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_s32)))
+void svst1_scatter_s32offset_s32(svbool_t, int32_t *, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_u32)))
+void svst1_scatter_u32offset_u32(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_f32)))
+void svst1_scatter_u32offset_f32(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_s32)))
+void svst1_scatter_u32offset_s32(svbool_t, int32_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_u64)))
+void svst1_scatter_s64offset_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_f64)))
+void svst1_scatter_s64offset_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_s64)))
+void svst1_scatter_s64offset_s64(svbool_t, int64_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_u64)))
+void svst1_scatter_u64offset_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_f64)))
+void svst1_scatter_u64offset_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_s64)))
+void svst1_scatter_u64offset_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_u32)))
+void svst1b_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_u64)))
+void svst1b_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_s32)))
+void svst1b_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_s64)))
+void svst1b_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_u32)))
+void svst1b_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_u64)))
+void svst1b_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_s32)))
+void svst1b_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_s64)))
+void svst1b_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_s32)))
+void svst1b_scatter_s32offset_s32(svbool_t, int8_t *, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_u32)))
+void svst1b_scatter_s32offset_u32(svbool_t, uint8_t *, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_s32)))
+void svst1b_scatter_u32offset_s32(svbool_t, int8_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_u32)))
+void svst1b_scatter_u32offset_u32(svbool_t, uint8_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_s64)))
+void svst1b_scatter_s64offset_s64(svbool_t, int8_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_u64)))
+void svst1b_scatter_s64offset_u64(svbool_t, uint8_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_s64)))
+void svst1b_scatter_u64offset_s64(svbool_t, int8_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_u64)))
+void svst1b_scatter_u64offset_u64(svbool_t, uint8_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_u32)))
+void svst1h_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_u64)))
+void svst1h_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_s32)))
+void svst1h_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_s64)))
+void svst1h_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_u32)))
+void svst1h_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_u64)))
+void svst1h_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_s32)))
+void svst1h_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_s64)))
+void svst1h_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_u32)))
+void svst1h_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_u64)))
+void svst1h_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_s32)))
+void svst1h_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_s64)))
+void svst1h_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_s32)))
+void svst1h_scatter_s32index_s32(svbool_t, int16_t *, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_u32)))
+void svst1h_scatter_s32index_u32(svbool_t, uint16_t *, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_s32)))
+void svst1h_scatter_u32index_s32(svbool_t, int16_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_u32)))
+void svst1h_scatter_u32index_u32(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_s64)))
+void svst1h_scatter_s64index_s64(svbool_t, int16_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_u64)))
+void svst1h_scatter_s64index_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_s64)))
+void svst1h_scatter_u64index_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_u64)))
+void svst1h_scatter_u64index_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_s32)))
+void svst1h_scatter_s32offset_s32(svbool_t, int16_t *, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_u32)))
+void svst1h_scatter_s32offset_u32(svbool_t, uint16_t *, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_s32)))
+void svst1h_scatter_u32offset_s32(svbool_t, int16_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_u32)))
+void svst1h_scatter_u32offset_u32(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_s64)))
+void svst1h_scatter_s64offset_s64(svbool_t, int16_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_u64)))
+void svst1h_scatter_s64offset_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_s64)))
+void svst1h_scatter_u64offset_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_u64)))
+void svst1h_scatter_u64offset_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_u64)))
+void svst1w_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_s64)))
+void svst1w_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_u64)))
+void svst1w_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_s64)))
+void svst1w_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_u64)))
+void svst1w_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_s64)))
+void svst1w_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_s64)))
+void svst1w_scatter_s64index_s64(svbool_t, int32_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_u64)))
+void svst1w_scatter_s64index_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_s64)))
+void svst1w_scatter_u64index_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_u64)))
+void svst1w_scatter_u64index_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_s64)))
+void svst1w_scatter_s64offset_s64(svbool_t, int32_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_u64)))
+void svst1w_scatter_s64offset_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_s64)))
+void svst1w_scatter_u64offset_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_u64)))
+void svst1w_scatter_u64offset_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f64)))
+svfloat64_t svtmad_f64(svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f32)))
+svfloat32_t svtmad_f32(svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f16)))
+svfloat16_t svtmad_f16(svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f64)))
+svfloat64_t svtsmul_f64(svfloat64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f32)))
+svfloat32_t svtsmul_f32(svfloat32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f16)))
+svfloat16_t svtsmul_f16(svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f64)))
+svfloat64_t svtssel_f64(svfloat64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f32)))
+svfloat32_t svtssel_f32(svfloat32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f16)))
+svfloat16_t svtssel_f16(svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwrffr)))
+void svwrffr(svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_u32offset)))
+svuint32_t svadrb_offset(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_u64offset)))
+svuint64_t svadrb_offset(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u32base_s32offset)))
+svuint32_t svadrb_offset(svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrb_u64base_s64offset)))
+svuint64_t svadrb_offset(svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_u32index)))
+svuint32_t svadrd_index(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_u64index)))
+svuint64_t svadrd_index(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u32base_s32index)))
+svuint32_t svadrd_index(svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrd_u64base_s64index)))
+svuint64_t svadrd_index(svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_u32index)))
+svuint32_t svadrh_index(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_u64index)))
+svuint64_t svadrh_index(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u32base_s32index)))
+svuint32_t svadrh_index(svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrh_u64base_s64index)))
+svuint64_t svadrh_index(svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_u32index)))
+svuint32_t svadrw_index(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_u64index)))
+svuint64_t svadrw_index(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u32base_s32index)))
+svuint32_t svadrw_index(svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadrw_u64base_s64index)))
+svuint64_t svadrw_index(svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u32)))
+svuint32_t svcompact(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_u64)))
+svuint64_t svcompact(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f64)))
+svfloat64_t svcompact(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_f32)))
+svfloat32_t svcompact(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s32)))
+svint32_t svcompact(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcompact_s64)))
+svint64_t svcompact(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f64)))
+svfloat64_t svexpa(svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f32)))
+svfloat32_t svexpa(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexpa_f16)))
+svfloat16_t svexpa(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_u32)))
+svuint32_t svld1_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_u64)))
+svuint64_t svld1_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_f64)))
+svfloat64_t svld1_gather_index_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_f32)))
+svfloat32_t svld1_gather_index_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_index_s32)))
+svint32_t svld1_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_index_s64)))
+svint64_t svld1_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_u32)))
+svuint32_t svld1_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_u64)))
+svuint64_t svld1_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_f64)))
+svfloat64_t svld1_gather_offset_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_f32)))
+svfloat32_t svld1_gather_offset_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_offset_s32)))
+svint32_t svld1_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_offset_s64)))
+svint64_t svld1_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_u32)))
+svuint32_t svld1_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_u64)))
+svuint64_t svld1_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_f64)))
+svfloat64_t svld1_gather_f64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_f32)))
+svfloat32_t svld1_gather_f32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32base_s32)))
+svint32_t svld1_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64base_s64)))
+svint64_t svld1_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_u32)))
+svuint32_t svld1_gather_index(svbool_t, uint32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_f32)))
+svfloat32_t svld1_gather_index(svbool_t, float32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32index_s32)))
+svint32_t svld1_gather_index(svbool_t, int32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_u32)))
+svuint32_t svld1_gather_index(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_f32)))
+svfloat32_t svld1_gather_index(svbool_t, float32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32index_s32)))
+svint32_t svld1_gather_index(svbool_t, int32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_u64)))
+svuint64_t svld1_gather_index(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_f64)))
+svfloat64_t svld1_gather_index(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64index_s64)))
+svint64_t svld1_gather_index(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_u64)))
+svuint64_t svld1_gather_index(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_f64)))
+svfloat64_t svld1_gather_index(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64index_s64)))
+svint64_t svld1_gather_index(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_u32)))
+svuint32_t svld1_gather_offset(svbool_t, uint32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_f32)))
+svfloat32_t svld1_gather_offset(svbool_t, float32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s32offset_s32)))
+svint32_t svld1_gather_offset(svbool_t, int32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_u32)))
+svuint32_t svld1_gather_offset(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_f32)))
+svfloat32_t svld1_gather_offset(svbool_t, float32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u32offset_s32)))
+svint32_t svld1_gather_offset(svbool_t, int32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_u64)))
+svuint64_t svld1_gather_offset(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_f64)))
+svfloat64_t svld1_gather_offset(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_s64offset_s64)))
+svint64_t svld1_gather_offset(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_u64)))
+svuint64_t svld1_gather_offset(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_f64)))
+svfloat64_t svld1_gather_offset(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_gather_u64offset_s64)))
+svint64_t svld1_gather_offset(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_u32)))
+svuint32_t svld1sb_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_u64)))
+svuint64_t svld1sb_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_offset_s32)))
+svint32_t svld1sb_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_offset_s64)))
+svint64_t svld1sb_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_u32)))
+svuint32_t svld1sb_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_u64)))
+svuint64_t svld1sb_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32base_s32)))
+svint32_t svld1sb_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64base_s64)))
+svint64_t svld1sb_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_u32)))
+svuint32_t svld1sb_gather_offset_u32(svbool_t, int8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s32offset_s32)))
+svint32_t svld1sb_gather_offset_s32(svbool_t, int8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_u32)))
+svuint32_t svld1sb_gather_offset_u32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u32offset_s32)))
+svint32_t svld1sb_gather_offset_s32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_u64)))
+svuint64_t svld1sb_gather_offset_u64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_s64offset_s64)))
+svint64_t svld1sb_gather_offset_s64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_u64)))
+svuint64_t svld1sb_gather_offset_u64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_gather_u64offset_s64)))
+svint64_t svld1sb_gather_offset_s64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_u32)))
+svuint32_t svld1sh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_u64)))
+svuint64_t svld1sh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_index_s32)))
+svint32_t svld1sh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_index_s64)))
+svint64_t svld1sh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_u32)))
+svuint32_t svld1sh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_u64)))
+svuint64_t svld1sh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_offset_s32)))
+svint32_t svld1sh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_offset_s64)))
+svint64_t svld1sh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_u32)))
+svuint32_t svld1sh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_u64)))
+svuint64_t svld1sh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32base_s32)))
+svint32_t svld1sh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64base_s64)))
+svint64_t svld1sh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_u32)))
+svuint32_t svld1sh_gather_index_u32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32index_s32)))
+svint32_t svld1sh_gather_index_s32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_u32)))
+svuint32_t svld1sh_gather_index_u32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32index_s32)))
+svint32_t svld1sh_gather_index_s32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_u64)))
+svuint64_t svld1sh_gather_index_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64index_s64)))
+svint64_t svld1sh_gather_index_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_u64)))
+svuint64_t svld1sh_gather_index_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64index_s64)))
+svint64_t svld1sh_gather_index_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_u32)))
+svuint32_t svld1sh_gather_offset_u32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s32offset_s32)))
+svint32_t svld1sh_gather_offset_s32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_u32)))
+svuint32_t svld1sh_gather_offset_u32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u32offset_s32)))
+svint32_t svld1sh_gather_offset_s32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_u64)))
+svuint64_t svld1sh_gather_offset_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_s64offset_s64)))
+svint64_t svld1sh_gather_offset_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_u64)))
+svuint64_t svld1sh_gather_offset_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_gather_u64offset_s64)))
+svint64_t svld1sh_gather_offset_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_u64)))
+svuint64_t svld1sw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_index_s64)))
+svint64_t svld1sw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_u64)))
+svuint64_t svld1sw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_offset_s64)))
+svint64_t svld1sw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_u64)))
+svuint64_t svld1sw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64base_s64)))
+svint64_t svld1sw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_u64)))
+svuint64_t svld1sw_gather_index_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64index_s64)))
+svint64_t svld1sw_gather_index_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_u64)))
+svuint64_t svld1sw_gather_index_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64index_s64)))
+svint64_t svld1sw_gather_index_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_u64)))
+svuint64_t svld1sw_gather_offset_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_s64offset_s64)))
+svint64_t svld1sw_gather_offset_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_u64)))
+svuint64_t svld1sw_gather_offset_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_gather_u64offset_s64)))
+svint64_t svld1sw_gather_offset_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_u32)))
+svuint32_t svld1ub_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_u64)))
+svuint64_t svld1ub_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_offset_s32)))
+svint32_t svld1ub_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_offset_s64)))
+svint64_t svld1ub_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_u32)))
+svuint32_t svld1ub_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_u64)))
+svuint64_t svld1ub_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32base_s32)))
+svint32_t svld1ub_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64base_s64)))
+svint64_t svld1ub_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_u32)))
+svuint32_t svld1ub_gather_offset_u32(svbool_t, uint8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s32offset_s32)))
+svint32_t svld1ub_gather_offset_s32(svbool_t, uint8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_u32)))
+svuint32_t svld1ub_gather_offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u32offset_s32)))
+svint32_t svld1ub_gather_offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_u64)))
+svuint64_t svld1ub_gather_offset_u64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_s64offset_s64)))
+svint64_t svld1ub_gather_offset_s64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_u64)))
+svuint64_t svld1ub_gather_offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_gather_u64offset_s64)))
+svint64_t svld1ub_gather_offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_u32)))
+svuint32_t svld1uh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_u64)))
+svuint64_t svld1uh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_index_s32)))
+svint32_t svld1uh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_index_s64)))
+svint64_t svld1uh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_u32)))
+svuint32_t svld1uh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_u64)))
+svuint64_t svld1uh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_offset_s32)))
+svint32_t svld1uh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_offset_s64)))
+svint64_t svld1uh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_u32)))
+svuint32_t svld1uh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_u64)))
+svuint64_t svld1uh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32base_s32)))
+svint32_t svld1uh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64base_s64)))
+svint64_t svld1uh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_u32)))
+svuint32_t svld1uh_gather_index_u32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32index_s32)))
+svint32_t svld1uh_gather_index_s32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_u32)))
+svuint32_t svld1uh_gather_index_u32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32index_s32)))
+svint32_t svld1uh_gather_index_s32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_u64)))
+svuint64_t svld1uh_gather_index_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64index_s64)))
+svint64_t svld1uh_gather_index_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_u64)))
+svuint64_t svld1uh_gather_index_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64index_s64)))
+svint64_t svld1uh_gather_index_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_u32)))
+svuint32_t svld1uh_gather_offset_u32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s32offset_s32)))
+svint32_t svld1uh_gather_offset_s32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_u32)))
+svuint32_t svld1uh_gather_offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u32offset_s32)))
+svint32_t svld1uh_gather_offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_u64)))
+svuint64_t svld1uh_gather_offset_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_s64offset_s64)))
+svint64_t svld1uh_gather_offset_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_u64)))
+svuint64_t svld1uh_gather_offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_gather_u64offset_s64)))
+svint64_t svld1uh_gather_offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_u64)))
+svuint64_t svld1uw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_index_s64)))
+svint64_t svld1uw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_u64)))
+svuint64_t svld1uw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_offset_s64)))
+svint64_t svld1uw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_u64)))
+svuint64_t svld1uw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64base_s64)))
+svint64_t svld1uw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_u64)))
+svuint64_t svld1uw_gather_index_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64index_s64)))
+svint64_t svld1uw_gather_index_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_u64)))
+svuint64_t svld1uw_gather_index_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64index_s64)))
+svint64_t svld1uw_gather_index_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_u64)))
+svuint64_t svld1uw_gather_offset_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_s64offset_s64)))
+svint64_t svld1uw_gather_offset_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_u64)))
+svuint64_t svld1uw_gather_offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_gather_u64offset_s64)))
+svint64_t svld1uw_gather_offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u8)))
+svuint8_t svldff1(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u32)))
+svuint32_t svldff1(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u64)))
+svuint64_t svldff1(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_u16)))
+svuint16_t svldff1(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s8)))
+svint8_t svldff1(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f64)))
+svfloat64_t svldff1(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f32)))
+svfloat32_t svldff1(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_f16)))
+svfloat16_t svldff1(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s32)))
+svint32_t svldff1(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s64)))
+svint64_t svldff1(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_s16)))
+svint16_t svldff1(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_u32)))
+svuint32_t svldff1_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_u64)))
+svuint64_t svldff1_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_f64)))
+svfloat64_t svldff1_gather_index_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_f32)))
+svfloat32_t svldff1_gather_index_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_index_s32)))
+svint32_t svldff1_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_index_s64)))
+svint64_t svldff1_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_u32)))
+svuint32_t svldff1_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_u64)))
+svuint64_t svldff1_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_f64)))
+svfloat64_t svldff1_gather_offset_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_f32)))
+svfloat32_t svldff1_gather_offset_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_offset_s32)))
+svint32_t svldff1_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_offset_s64)))
+svint64_t svldff1_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_u32)))
+svuint32_t svldff1_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_u64)))
+svuint64_t svldff1_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_f64)))
+svfloat64_t svldff1_gather_f64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_f32)))
+svfloat32_t svldff1_gather_f32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32base_s32)))
+svint32_t svldff1_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64base_s64)))
+svint64_t svldff1_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_u32)))
+svuint32_t svldff1_gather_index(svbool_t, uint32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_f32)))
+svfloat32_t svldff1_gather_index(svbool_t, float32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32index_s32)))
+svint32_t svldff1_gather_index(svbool_t, int32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_u32)))
+svuint32_t svldff1_gather_index(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_f32)))
+svfloat32_t svldff1_gather_index(svbool_t, float32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32index_s32)))
+svint32_t svldff1_gather_index(svbool_t, int32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_u64)))
+svuint64_t svldff1_gather_index(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_f64)))
+svfloat64_t svldff1_gather_index(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64index_s64)))
+svint64_t svldff1_gather_index(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_u64)))
+svuint64_t svldff1_gather_index(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_f64)))
+svfloat64_t svldff1_gather_index(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64index_s64)))
+svint64_t svldff1_gather_index(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_u32)))
+svuint32_t svldff1_gather_offset(svbool_t, uint32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_f32)))
+svfloat32_t svldff1_gather_offset(svbool_t, float32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s32offset_s32)))
+svint32_t svldff1_gather_offset(svbool_t, int32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_u32)))
+svuint32_t svldff1_gather_offset(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_f32)))
+svfloat32_t svldff1_gather_offset(svbool_t, float32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u32offset_s32)))
+svint32_t svldff1_gather_offset(svbool_t, int32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_u64)))
+svuint64_t svldff1_gather_offset(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_f64)))
+svfloat64_t svldff1_gather_offset(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_s64offset_s64)))
+svint64_t svldff1_gather_offset(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_u64)))
+svuint64_t svldff1_gather_offset(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_f64)))
+svfloat64_t svldff1_gather_offset(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_gather_u64offset_s64)))
+svint64_t svldff1_gather_offset(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u8)))
+svuint8_t svldff1_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u32)))
+svuint32_t svldff1_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u64)))
+svuint64_t svldff1_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_u16)))
+svuint16_t svldff1_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s8)))
+svint8_t svldff1_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f64)))
+svfloat64_t svldff1_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f32)))
+svfloat32_t svldff1_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_f16)))
+svfloat16_t svldff1_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s32)))
+svint32_t svldff1_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s64)))
+svint64_t svldff1_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_s16)))
+svint16_t svldff1_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_u32)))
+svuint32_t svldff1sb_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_u64)))
+svuint64_t svldff1sb_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_offset_s32)))
+svint32_t svldff1sb_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_offset_s64)))
+svint64_t svldff1sb_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_u32)))
+svuint32_t svldff1sb_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_u64)))
+svuint64_t svldff1sb_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32base_s32)))
+svint32_t svldff1sb_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64base_s64)))
+svint64_t svldff1sb_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_u32)))
+svuint32_t svldff1sb_gather_offset_u32(svbool_t, int8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s32offset_s32)))
+svint32_t svldff1sb_gather_offset_s32(svbool_t, int8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_u32)))
+svuint32_t svldff1sb_gather_offset_u32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u32offset_s32)))
+svint32_t svldff1sb_gather_offset_s32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_u64)))
+svuint64_t svldff1sb_gather_offset_u64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_s64offset_s64)))
+svint64_t svldff1sb_gather_offset_s64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_u64)))
+svuint64_t svldff1sb_gather_offset_u64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sb_gather_u64offset_s64)))
+svint64_t svldff1sb_gather_offset_s64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_u32)))
+svuint32_t svldff1sh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_u64)))
+svuint64_t svldff1sh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_index_s32)))
+svint32_t svldff1sh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_index_s64)))
+svint64_t svldff1sh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_u32)))
+svuint32_t svldff1sh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_u64)))
+svuint64_t svldff1sh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_offset_s32)))
+svint32_t svldff1sh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_offset_s64)))
+svint64_t svldff1sh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_u32)))
+svuint32_t svldff1sh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_u64)))
+svuint64_t svldff1sh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32base_s32)))
+svint32_t svldff1sh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64base_s64)))
+svint64_t svldff1sh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_u32)))
+svuint32_t svldff1sh_gather_index_u32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32index_s32)))
+svint32_t svldff1sh_gather_index_s32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_u32)))
+svuint32_t svldff1sh_gather_index_u32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32index_s32)))
+svint32_t svldff1sh_gather_index_s32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_u64)))
+svuint64_t svldff1sh_gather_index_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64index_s64)))
+svint64_t svldff1sh_gather_index_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_u64)))
+svuint64_t svldff1sh_gather_index_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64index_s64)))
+svint64_t svldff1sh_gather_index_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_u32)))
+svuint32_t svldff1sh_gather_offset_u32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s32offset_s32)))
+svint32_t svldff1sh_gather_offset_s32(svbool_t, int16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_u32)))
+svuint32_t svldff1sh_gather_offset_u32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u32offset_s32)))
+svint32_t svldff1sh_gather_offset_s32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_u64)))
+svuint64_t svldff1sh_gather_offset_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_s64offset_s64)))
+svint64_t svldff1sh_gather_offset_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_u64)))
+svuint64_t svldff1sh_gather_offset_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sh_gather_u64offset_s64)))
+svint64_t svldff1sh_gather_offset_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_u64)))
+svuint64_t svldff1sw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_index_s64)))
+svint64_t svldff1sw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_u64)))
+svuint64_t svldff1sw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_offset_s64)))
+svint64_t svldff1sw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_u64)))
+svuint64_t svldff1sw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64base_s64)))
+svint64_t svldff1sw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_u64)))
+svuint64_t svldff1sw_gather_index_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64index_s64)))
+svint64_t svldff1sw_gather_index_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_u64)))
+svuint64_t svldff1sw_gather_index_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64index_s64)))
+svint64_t svldff1sw_gather_index_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_u64)))
+svuint64_t svldff1sw_gather_offset_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_s64offset_s64)))
+svint64_t svldff1sw_gather_offset_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_u64)))
+svuint64_t svldff1sw_gather_offset_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1sw_gather_u64offset_s64)))
+svint64_t svldff1sw_gather_offset_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_u32)))
+svuint32_t svldff1ub_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_u64)))
+svuint64_t svldff1ub_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_offset_s32)))
+svint32_t svldff1ub_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_offset_s64)))
+svint64_t svldff1ub_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_u32)))
+svuint32_t svldff1ub_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_u64)))
+svuint64_t svldff1ub_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32base_s32)))
+svint32_t svldff1ub_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64base_s64)))
+svint64_t svldff1ub_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_u32)))
+svuint32_t svldff1ub_gather_offset_u32(svbool_t, uint8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s32offset_s32)))
+svint32_t svldff1ub_gather_offset_s32(svbool_t, uint8_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_u32)))
+svuint32_t svldff1ub_gather_offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u32offset_s32)))
+svint32_t svldff1ub_gather_offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_u64)))
+svuint64_t svldff1ub_gather_offset_u64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_s64offset_s64)))
+svint64_t svldff1ub_gather_offset_s64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_u64)))
+svuint64_t svldff1ub_gather_offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1ub_gather_u64offset_s64)))
+svint64_t svldff1ub_gather_offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_u32)))
+svuint32_t svldff1uh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_u64)))
+svuint64_t svldff1uh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_index_s32)))
+svint32_t svldff1uh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_index_s64)))
+svint64_t svldff1uh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_u32)))
+svuint32_t svldff1uh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_u64)))
+svuint64_t svldff1uh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_offset_s32)))
+svint32_t svldff1uh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_offset_s64)))
+svint64_t svldff1uh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_u32)))
+svuint32_t svldff1uh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_u64)))
+svuint64_t svldff1uh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32base_s32)))
+svint32_t svldff1uh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64base_s64)))
+svint64_t svldff1uh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_u32)))
+svuint32_t svldff1uh_gather_index_u32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32index_s32)))
+svint32_t svldff1uh_gather_index_s32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_u32)))
+svuint32_t svldff1uh_gather_index_u32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32index_s32)))
+svint32_t svldff1uh_gather_index_s32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_u64)))
+svuint64_t svldff1uh_gather_index_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64index_s64)))
+svint64_t svldff1uh_gather_index_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_u64)))
+svuint64_t svldff1uh_gather_index_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64index_s64)))
+svint64_t svldff1uh_gather_index_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_u32)))
+svuint32_t svldff1uh_gather_offset_u32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s32offset_s32)))
+svint32_t svldff1uh_gather_offset_s32(svbool_t, uint16_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_u32)))
+svuint32_t svldff1uh_gather_offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u32offset_s32)))
+svint32_t svldff1uh_gather_offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_u64)))
+svuint64_t svldff1uh_gather_offset_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_s64offset_s64)))
+svint64_t svldff1uh_gather_offset_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_u64)))
+svuint64_t svldff1uh_gather_offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uh_gather_u64offset_s64)))
+svint64_t svldff1uh_gather_offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_u64)))
+svuint64_t svldff1uw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_index_s64)))
+svint64_t svldff1uw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_u64)))
+svuint64_t svldff1uw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_offset_s64)))
+svint64_t svldff1uw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_u64)))
+svuint64_t svldff1uw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64base_s64)))
+svint64_t svldff1uw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_u64)))
+svuint64_t svldff1uw_gather_index_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64index_s64)))
+svint64_t svldff1uw_gather_index_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_u64)))
+svuint64_t svldff1uw_gather_index_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64index_s64)))
+svint64_t svldff1uw_gather_index_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_u64)))
+svuint64_t svldff1uw_gather_offset_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_s64offset_s64)))
+svint64_t svldff1uw_gather_offset_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_u64)))
+svuint64_t svldff1uw_gather_offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1uw_gather_u64offset_s64)))
+svint64_t svldff1uw_gather_offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u8)))
+svuint8_t svldnf1(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u32)))
+svuint32_t svldnf1(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u64)))
+svuint64_t svldnf1(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_u16)))
+svuint16_t svldnf1(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s8)))
+svint8_t svldnf1(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f64)))
+svfloat64_t svldnf1(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f32)))
+svfloat32_t svldnf1(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_f16)))
+svfloat16_t svldnf1(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s32)))
+svint32_t svldnf1(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s64)))
+svint64_t svldnf1(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_s16)))
+svint16_t svldnf1(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u8)))
+svuint8_t svldnf1_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u32)))
+svuint32_t svldnf1_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u64)))
+svuint64_t svldnf1_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_u16)))
+svuint16_t svldnf1_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s8)))
+svint8_t svldnf1_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f64)))
+svfloat64_t svldnf1_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f32)))
+svfloat32_t svldnf1_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_f16)))
+svfloat16_t svldnf1_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s32)))
+svint32_t svldnf1_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s64)))
+svint64_t svldnf1_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_s16)))
+svint16_t svldnf1_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base)))
+void svprfb_gather(svbool_t, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base)))
+void svprfb_gather(svbool_t, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32base_offset)))
+void svprfb_gather_offset(svbool_t, svuint32_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64base_offset)))
+void svprfb_gather_offset(svbool_t, svuint64_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s32offset)))
+void svprfb_gather_offset(svbool_t, void const *, svint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u32offset)))
+void svprfb_gather_offset(svbool_t, void const *, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_s64offset)))
+void svprfb_gather_offset(svbool_t, void const *, svint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_gather_u64offset)))
+void svprfb_gather_offset(svbool_t, void const *, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base)))
+void svprfd_gather(svbool_t, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base)))
+void svprfd_gather(svbool_t, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32base_index)))
+void svprfd_gather_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64base_index)))
+void svprfd_gather_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s32index)))
+void svprfd_gather_index(svbool_t, void const *, svint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u32index)))
+void svprfd_gather_index(svbool_t, void const *, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_s64index)))
+void svprfd_gather_index(svbool_t, void const *, svint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_gather_u64index)))
+void svprfd_gather_index(svbool_t, void const *, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base)))
+void svprfh_gather(svbool_t, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base)))
+void svprfh_gather(svbool_t, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32base_index)))
+void svprfh_gather_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64base_index)))
+void svprfh_gather_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s32index)))
+void svprfh_gather_index(svbool_t, void const *, svint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u32index)))
+void svprfh_gather_index(svbool_t, void const *, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_s64index)))
+void svprfh_gather_index(svbool_t, void const *, svint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_gather_u64index)))
+void svprfh_gather_index(svbool_t, void const *, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base)))
+void svprfw_gather(svbool_t, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base)))
+void svprfw_gather(svbool_t, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32base_index)))
+void svprfw_gather_index(svbool_t, svuint32_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64base_index)))
+void svprfw_gather_index(svbool_t, svuint64_t, int64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s32index)))
+void svprfw_gather_index(svbool_t, void const *, svint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u32index)))
+void svprfw_gather_index(svbool_t, void const *, svuint32_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_s64index)))
+void svprfw_gather_index(svbool_t, void const *, svint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_gather_u64index)))
+void svprfw_gather_index(svbool_t, void const *, svuint64_t, enum svprfop);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_u32)))
+void svst1_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_u64)))
+void svst1_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_f64)))
+void svst1_scatter_index(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_f32)))
+void svst1_scatter_index(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_index_s32)))
+void svst1_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_index_s64)))
+void svst1_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_u32)))
+void svst1_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_u64)))
+void svst1_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_f64)))
+void svst1_scatter_offset(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_f32)))
+void svst1_scatter_offset(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_offset_s32)))
+void svst1_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_offset_s64)))
+void svst1_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_u32)))
+void svst1_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_u64)))
+void svst1_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_f64)))
+void svst1_scatter(svbool_t, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_f32)))
+void svst1_scatter(svbool_t, svuint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32base_s32)))
+void svst1_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64base_s64)))
+void svst1_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_u32)))
+void svst1_scatter_index(svbool_t, uint32_t *, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_f32)))
+void svst1_scatter_index(svbool_t, float32_t *, svint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32index_s32)))
+void svst1_scatter_index(svbool_t, int32_t *, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_u32)))
+void svst1_scatter_index(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_f32)))
+void svst1_scatter_index(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32index_s32)))
+void svst1_scatter_index(svbool_t, int32_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_u64)))
+void svst1_scatter_index(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_f64)))
+void svst1_scatter_index(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64index_s64)))
+void svst1_scatter_index(svbool_t, int64_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_u64)))
+void svst1_scatter_index(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_f64)))
+void svst1_scatter_index(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64index_s64)))
+void svst1_scatter_index(svbool_t, int64_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_u32)))
+void svst1_scatter_offset(svbool_t, uint32_t *, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_f32)))
+void svst1_scatter_offset(svbool_t, float32_t *, svint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s32offset_s32)))
+void svst1_scatter_offset(svbool_t, int32_t *, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_u32)))
+void svst1_scatter_offset(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_f32)))
+void svst1_scatter_offset(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u32offset_s32)))
+void svst1_scatter_offset(svbool_t, int32_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_u64)))
+void svst1_scatter_offset(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_f64)))
+void svst1_scatter_offset(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_s64offset_s64)))
+void svst1_scatter_offset(svbool_t, int64_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_u64)))
+void svst1_scatter_offset(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_f64)))
+void svst1_scatter_offset(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_scatter_u64offset_s64)))
+void svst1_scatter_offset(svbool_t, int64_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_u32)))
+void svst1b_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_u64)))
+void svst1b_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_offset_s32)))
+void svst1b_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_offset_s64)))
+void svst1b_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_u32)))
+void svst1b_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_u64)))
+void svst1b_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32base_s32)))
+void svst1b_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64base_s64)))
+void svst1b_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_s32)))
+void svst1b_scatter_offset(svbool_t, int8_t *, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s32offset_u32)))
+void svst1b_scatter_offset(svbool_t, uint8_t *, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_s32)))
+void svst1b_scatter_offset(svbool_t, int8_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u32offset_u32)))
+void svst1b_scatter_offset(svbool_t, uint8_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_s64)))
+void svst1b_scatter_offset(svbool_t, int8_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_s64offset_u64)))
+void svst1b_scatter_offset(svbool_t, uint8_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_s64)))
+void svst1b_scatter_offset(svbool_t, int8_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_scatter_u64offset_u64)))
+void svst1b_scatter_offset(svbool_t, uint8_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_u32)))
+void svst1h_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_u64)))
+void svst1h_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_index_s32)))
+void svst1h_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_index_s64)))
+void svst1h_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_u32)))
+void svst1h_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_u64)))
+void svst1h_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_offset_s32)))
+void svst1h_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_offset_s64)))
+void svst1h_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_u32)))
+void svst1h_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_u64)))
+void svst1h_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32base_s32)))
+void svst1h_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64base_s64)))
+void svst1h_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_s32)))
+void svst1h_scatter_index(svbool_t, int16_t *, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32index_u32)))
+void svst1h_scatter_index(svbool_t, uint16_t *, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_s32)))
+void svst1h_scatter_index(svbool_t, int16_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32index_u32)))
+void svst1h_scatter_index(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_s64)))
+void svst1h_scatter_index(svbool_t, int16_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64index_u64)))
+void svst1h_scatter_index(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_s64)))
+void svst1h_scatter_index(svbool_t, int16_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64index_u64)))
+void svst1h_scatter_index(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_s32)))
+void svst1h_scatter_offset(svbool_t, int16_t *, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s32offset_u32)))
+void svst1h_scatter_offset(svbool_t, uint16_t *, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_s32)))
+void svst1h_scatter_offset(svbool_t, int16_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u32offset_u32)))
+void svst1h_scatter_offset(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_s64)))
+void svst1h_scatter_offset(svbool_t, int16_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_s64offset_u64)))
+void svst1h_scatter_offset(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_s64)))
+void svst1h_scatter_offset(svbool_t, int16_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_scatter_u64offset_u64)))
+void svst1h_scatter_offset(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_u64)))
+void svst1w_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_index_s64)))
+void svst1w_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_u64)))
+void svst1w_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_offset_s64)))
+void svst1w_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_u64)))
+void svst1w_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64base_s64)))
+void svst1w_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_s64)))
+void svst1w_scatter_index(svbool_t, int32_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64index_u64)))
+void svst1w_scatter_index(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_s64)))
+void svst1w_scatter_index(svbool_t, int32_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64index_u64)))
+void svst1w_scatter_index(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_s64)))
+void svst1w_scatter_offset(svbool_t, int32_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_s64offset_u64)))
+void svst1w_scatter_offset(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_s64)))
+void svst1w_scatter_offset(svbool_t, int32_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_scatter_u64offset_u64)))
+void svst1w_scatter_offset(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f64)))
+svfloat64_t svtmad(svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f32)))
+svfloat32_t svtmad(svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtmad_f16)))
+svfloat16_t svtmad(svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f64)))
+svfloat64_t svtsmul(svfloat64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f32)))
+svfloat32_t svtsmul(svfloat32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtsmul_f16)))
+svfloat16_t svtsmul(svfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f64)))
+svfloat64_t svtssel(svfloat64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f32)))
+svfloat32_t svtssel(svfloat32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtssel_f16)))
+svfloat16_t svtssel(svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmmla_f32)))
+svfloat32_t svbfmmla_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_bf16)))
+svbfloat16_t svldff1_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_bf16)))
+svbfloat16_t svldff1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_bf16)))
+svbfloat16_t svldnf1_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_bf16)))
+svbfloat16_t svldnf1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmmla_f32)))
+svfloat32_t svbfmmla(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_bf16)))
+svbfloat16_t svldff1(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldff1_vnum_bf16)))
+svbfloat16_t svldff1_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_bf16)))
+svbfloat16_t svldnf1(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnf1_vnum_bf16)))
+svbfloat16_t svldnf1_vnum(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_bf16)))
+svbfloat16_t svtrn1q_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_bf16)))
+svbfloat16_t svtrn2q_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_bf16)))
+svbfloat16_t svuzp1q_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_bf16)))
+svbfloat16_t svuzp2q_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_bf16)))
+svbfloat16_t svzip1q_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_bf16)))
+svbfloat16_t svzip2q_bf16(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_bf16)))
+svbfloat16_t svtrn1q(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_bf16)))
+svbfloat16_t svtrn2q(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_bf16)))
+svbfloat16_t svuzp1q(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_bf16)))
+svbfloat16_t svuzp2q(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_bf16)))
+svbfloat16_t svzip1q(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_bf16)))
+svbfloat16_t svzip2q(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_n_f32)))
+svfloat32_t svbfdot_n_f32(svfloat32_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_f32)))
+svfloat32_t svbfdot_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_lane_f32)))
+svfloat32_t svbfdot_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_n_f32)))
+svfloat32_t svbfmlalb_n_f32(svfloat32_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_f32)))
+svfloat32_t svbfmlalb_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_lane_f32)))
+svfloat32_t svbfmlalb_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_n_f32)))
+svfloat32_t svbfmlalt_n_f32(svfloat32_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_f32)))
+svfloat32_t svbfmlalt_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_lane_f32)))
+svfloat32_t svbfmlalt_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_bf16)))
+bfloat16_t svclasta_n_bf16(svbool_t, bfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_bf16)))
+svbfloat16_t svclasta_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_bf16)))
+bfloat16_t svclastb_n_bf16(svbool_t, bfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_bf16)))
+svbfloat16_t svclastb_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_m)))
+svuint16_t svcnt_bf16_m(svuint16_t, svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_x)))
+svuint16_t svcnt_bf16_x(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_z)))
+svuint16_t svcnt_bf16_z(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_bf16)))
+svbfloat16x2_t svcreate2_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_bf16)))
+svbfloat16x3_t svcreate3_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_bf16)))
+svbfloat16x4_t svcreate4_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_m)))
+svbfloat16_t svcvt_bf16_f32_m(svbfloat16_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x)))
+svbfloat16_t svcvt_bf16_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_z)))
+svbfloat16_t svcvt_bf16_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_bf16_f32_m)))
+svbfloat16_t svcvtnt_bf16_f32_m(svbfloat16_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16)))
+svbfloat16_t svdup_n_bf16(bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_m)))
+svbfloat16_t svdup_n_bf16_m(svbfloat16_t, svbool_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_x)))
+svbfloat16_t svdup_n_bf16_x(svbool_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_z)))
+svbfloat16_t svdup_n_bf16_z(svbool_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_bf16)))
+svbfloat16_t svdup_lane_bf16(svbfloat16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_bf16)))
+svbfloat16_t svdupq_n_bf16(bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_bf16)))
+svbfloat16_t svdupq_lane_bf16(svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_bf16)))
+svbfloat16_t svext_bf16(svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_bf16)))
+svbfloat16_t svget2_bf16(svbfloat16x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_bf16)))
+svbfloat16_t svget3_bf16(svbfloat16x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_bf16)))
+svbfloat16_t svget4_bf16(svbfloat16x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_bf16)))
+svbfloat16_t svinsr_n_bf16(svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_bf16)))
+bfloat16_t svlasta_bf16(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_bf16)))
+bfloat16_t svlastb_bf16(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_bf16)))
+svbfloat16_t svld1_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_bf16)))
+svbfloat16_t svld1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_bf16)))
+svbfloat16_t svld1rq_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_bf16)))
+svbfloat16x2_t svld2_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_bf16)))
+svbfloat16x2_t svld2_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_bf16)))
+svbfloat16x3_t svld3_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_bf16)))
+svbfloat16x3_t svld3_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_bf16)))
+svbfloat16x4_t svld4_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_bf16)))
+svbfloat16x4_t svld4_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_bf16)))
+svbfloat16_t svldnt1_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_bf16)))
+svbfloat16_t svldnt1_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_bf16)))
+uint64_t svlen_bf16(svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_bf16)))
+svbfloat16_t svrev_bf16(svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16)))
+svbfloat16_t svsel_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_bf16)))
+svbfloat16x2_t svset2_bf16(svbfloat16x2_t, uint64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_bf16)))
+svbfloat16x3_t svset3_bf16(svbfloat16x3_t, uint64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_bf16)))
+svbfloat16x4_t svset4_bf16(svbfloat16x4_t, uint64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_bf16)))
+svbfloat16_t svsplice_bf16(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_bf16)))
+void svst1_bf16(svbool_t, bfloat16_t *, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_bf16)))
+void svst1_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_bf16)))
+void svst2_bf16(svbool_t, bfloat16_t *, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_bf16)))
+void svst2_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_bf16)))
+void svst3_bf16(svbool_t, bfloat16_t *, svbfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_bf16)))
+void svst3_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_bf16)))
+void svst4_bf16(svbool_t, bfloat16_t *, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_bf16)))
+void svst4_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_bf16)))
+void svstnt1_bf16(svbool_t, bfloat16_t *, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_bf16)))
+void svstnt1_vnum_bf16(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_bf16)))
+svbfloat16_t svtbl_bf16(svbfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_bf16)))
+svbfloat16_t svtrn1_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_bf16)))
+svbfloat16_t svtrn2_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_bf16)))
+svbfloat16x2_t svundef2_bf16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_bf16)))
+svbfloat16x3_t svundef3_bf16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_bf16)))
+svbfloat16x4_t svundef4_bf16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_bf16)))
+svbfloat16_t svundef_bf16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_bf16)))
+svbfloat16_t svuzp1_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_bf16)))
+svbfloat16_t svuzp2_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_bf16)))
+svbfloat16_t svzip1_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_bf16)))
+svbfloat16_t svzip2_bf16(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_n_f32)))
+svfloat32_t svbfdot(svfloat32_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_f32)))
+svfloat32_t svbfdot(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfdot_lane_f32)))
+svfloat32_t svbfdot_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_n_f32)))
+svfloat32_t svbfmlalb(svfloat32_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_f32)))
+svfloat32_t svbfmlalb(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalb_lane_f32)))
+svfloat32_t svbfmlalb_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_n_f32)))
+svfloat32_t svbfmlalt(svfloat32_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_f32)))
+svfloat32_t svbfmlalt(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlalt_lane_f32)))
+svfloat32_t svbfmlalt_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_bf16)))
+bfloat16_t svclasta(svbool_t, bfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_bf16)))
+svbfloat16_t svclasta(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_bf16)))
+bfloat16_t svclastb(svbool_t, bfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_bf16)))
+svbfloat16_t svclastb(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_m)))
+svuint16_t svcnt_m(svuint16_t, svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_x)))
+svuint16_t svcnt_x(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_bf16_z)))
+svuint16_t svcnt_z(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_bf16)))
+svbfloat16x2_t svcreate2(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_bf16)))
+svbfloat16x3_t svcreate3(svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_bf16)))
+svbfloat16x4_t svcreate4(svbfloat16_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_m)))
+svbfloat16_t svcvt_bf16_m(svbfloat16_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_x)))
+svbfloat16_t svcvt_bf16_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_bf16_f32_z)))
+svbfloat16_t svcvt_bf16_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_bf16_f32_m)))
+svbfloat16_t svcvtnt_bf16_m(svbfloat16_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16)))
+svbfloat16_t svdup_bf16(bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_m)))
+svbfloat16_t svdup_bf16_m(svbfloat16_t, svbool_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_x)))
+svbfloat16_t svdup_bf16_x(svbool_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_bf16_z)))
+svbfloat16_t svdup_bf16_z(svbool_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_bf16)))
+svbfloat16_t svdup_lane(svbfloat16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_bf16)))
+svbfloat16_t svdupq_bf16(bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_bf16)))
+svbfloat16_t svdupq_lane(svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_bf16)))
+svbfloat16_t svext(svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_bf16)))
+svbfloat16_t svget2(svbfloat16x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_bf16)))
+svbfloat16_t svget3(svbfloat16x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_bf16)))
+svbfloat16_t svget4(svbfloat16x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_bf16)))
+svbfloat16_t svinsr(svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_bf16)))
+bfloat16_t svlasta(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_bf16)))
+bfloat16_t svlastb(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_bf16)))
+svbfloat16_t svld1(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_bf16)))
+svbfloat16_t svld1_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_bf16)))
+svbfloat16_t svld1rq(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_bf16)))
+svbfloat16x2_t svld2(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_bf16)))
+svbfloat16x2_t svld2_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_bf16)))
+svbfloat16x3_t svld3(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_bf16)))
+svbfloat16x3_t svld3_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_bf16)))
+svbfloat16x4_t svld4(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_bf16)))
+svbfloat16x4_t svld4_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_bf16)))
+svbfloat16_t svldnt1(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_bf16)))
+svbfloat16_t svldnt1_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_bf16)))
+uint64_t svlen(svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_bf16)))
+svbfloat16_t svrev(svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_bf16)))
+svbfloat16_t svsel(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_bf16)))
+svbfloat16x2_t svset2(svbfloat16x2_t, uint64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_bf16)))
+svbfloat16x3_t svset3(svbfloat16x3_t, uint64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_bf16)))
+svbfloat16x4_t svset4(svbfloat16x4_t, uint64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_bf16)))
+svbfloat16_t svsplice(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_bf16)))
+void svst1(svbool_t, bfloat16_t *, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_bf16)))
+void svst1_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_bf16)))
+void svst2(svbool_t, bfloat16_t *, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_bf16)))
+void svst2_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_bf16)))
+void svst3(svbool_t, bfloat16_t *, svbfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_bf16)))
+void svst3_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_bf16)))
+void svst4(svbool_t, bfloat16_t *, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_bf16)))
+void svst4_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_bf16)))
+void svstnt1(svbool_t, bfloat16_t *, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_bf16)))
+void svstnt1_vnum(svbool_t, bfloat16_t *, int64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_bf16)))
+svbfloat16_t svtbl(svbfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_bf16)))
+svbfloat16_t svtrn1(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_bf16)))
+svbfloat16_t svtrn2(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_bf16)))
+svbfloat16_t svuzp1(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_bf16)))
+svbfloat16_t svuzp2(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_bf16)))
+svbfloat16_t svzip1(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_bf16)))
+svbfloat16_t svzip2(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f32)))
+svfloat32_t svmmla_f32(svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f32)))
+svfloat32_t svmmla(svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u8)))
+svuint8_t svld1ro_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u32)))
+svuint32_t svld1ro_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u64)))
+svuint64_t svld1ro_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u16)))
+svuint16_t svld1ro_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s8)))
+svint8_t svld1ro_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f64)))
+svfloat64_t svld1ro_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f32)))
+svfloat32_t svld1ro_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f16)))
+svfloat16_t svld1ro_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s32)))
+svint32_t svld1ro_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s64)))
+svint64_t svld1ro_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s16)))
+svint16_t svld1ro_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f64)))
+svfloat64_t svmmla_f64(svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u8)))
+svuint8_t svtrn1q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u32)))
+svuint32_t svtrn1q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u64)))
+svuint64_t svtrn1q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u16)))
+svuint16_t svtrn1q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s8)))
+svint8_t svtrn1q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f64)))
+svfloat64_t svtrn1q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f32)))
+svfloat32_t svtrn1q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f16)))
+svfloat16_t svtrn1q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s32)))
+svint32_t svtrn1q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s64)))
+svint64_t svtrn1q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s16)))
+svint16_t svtrn1q_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u8)))
+svuint8_t svtrn2q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u32)))
+svuint32_t svtrn2q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u64)))
+svuint64_t svtrn2q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u16)))
+svuint16_t svtrn2q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s8)))
+svint8_t svtrn2q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f64)))
+svfloat64_t svtrn2q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f32)))
+svfloat32_t svtrn2q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f16)))
+svfloat16_t svtrn2q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s32)))
+svint32_t svtrn2q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s64)))
+svint64_t svtrn2q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s16)))
+svint16_t svtrn2q_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u8)))
+svuint8_t svuzp1q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u32)))
+svuint32_t svuzp1q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u64)))
+svuint64_t svuzp1q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u16)))
+svuint16_t svuzp1q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s8)))
+svint8_t svuzp1q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f64)))
+svfloat64_t svuzp1q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f32)))
+svfloat32_t svuzp1q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f16)))
+svfloat16_t svuzp1q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s32)))
+svint32_t svuzp1q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s64)))
+svint64_t svuzp1q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s16)))
+svint16_t svuzp1q_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u8)))
+svuint8_t svuzp2q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u32)))
+svuint32_t svuzp2q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u64)))
+svuint64_t svuzp2q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u16)))
+svuint16_t svuzp2q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s8)))
+svint8_t svuzp2q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f64)))
+svfloat64_t svuzp2q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f32)))
+svfloat32_t svuzp2q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f16)))
+svfloat16_t svuzp2q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s32)))
+svint32_t svuzp2q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s64)))
+svint64_t svuzp2q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s16)))
+svint16_t svuzp2q_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u8)))
+svuint8_t svzip1q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u32)))
+svuint32_t svzip1q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u64)))
+svuint64_t svzip1q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u16)))
+svuint16_t svzip1q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s8)))
+svint8_t svzip1q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f64)))
+svfloat64_t svzip1q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f32)))
+svfloat32_t svzip1q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f16)))
+svfloat16_t svzip1q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s32)))
+svint32_t svzip1q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s64)))
+svint64_t svzip1q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s16)))
+svint16_t svzip1q_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u8)))
+svuint8_t svzip2q_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u32)))
+svuint32_t svzip2q_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u64)))
+svuint64_t svzip2q_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u16)))
+svuint16_t svzip2q_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s8)))
+svint8_t svzip2q_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f64)))
+svfloat64_t svzip2q_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f32)))
+svfloat32_t svzip2q_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f16)))
+svfloat16_t svzip2q_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s32)))
+svint32_t svzip2q_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s64)))
+svint64_t svzip2q_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s16)))
+svint16_t svzip2q_s16(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u8)))
+svuint8_t svld1ro(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u32)))
+svuint32_t svld1ro(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u64)))
+svuint64_t svld1ro(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_u16)))
+svuint16_t svld1ro(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s8)))
+svint8_t svld1ro(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f64)))
+svfloat64_t svld1ro(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f32)))
+svfloat32_t svld1ro(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_f16)))
+svfloat16_t svld1ro(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s32)))
+svint32_t svld1ro(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s64)))
+svint64_t svld1ro(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_s16)))
+svint16_t svld1ro(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_f64)))
+svfloat64_t svmmla(svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u8)))
+svuint8_t svtrn1q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u32)))
+svuint32_t svtrn1q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u64)))
+svuint64_t svtrn1q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_u16)))
+svuint16_t svtrn1q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s8)))
+svint8_t svtrn1q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f64)))
+svfloat64_t svtrn1q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f32)))
+svfloat32_t svtrn1q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_f16)))
+svfloat16_t svtrn1q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s32)))
+svint32_t svtrn1q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s64)))
+svint64_t svtrn1q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1q_s16)))
+svint16_t svtrn1q(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u8)))
+svuint8_t svtrn2q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u32)))
+svuint32_t svtrn2q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u64)))
+svuint64_t svtrn2q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_u16)))
+svuint16_t svtrn2q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s8)))
+svint8_t svtrn2q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f64)))
+svfloat64_t svtrn2q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f32)))
+svfloat32_t svtrn2q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_f16)))
+svfloat16_t svtrn2q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s32)))
+svint32_t svtrn2q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s64)))
+svint64_t svtrn2q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2q_s16)))
+svint16_t svtrn2q(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u8)))
+svuint8_t svuzp1q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u32)))
+svuint32_t svuzp1q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u64)))
+svuint64_t svuzp1q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_u16)))
+svuint16_t svuzp1q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s8)))
+svint8_t svuzp1q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f64)))
+svfloat64_t svuzp1q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f32)))
+svfloat32_t svuzp1q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_f16)))
+svfloat16_t svuzp1q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s32)))
+svint32_t svuzp1q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s64)))
+svint64_t svuzp1q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1q_s16)))
+svint16_t svuzp1q(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u8)))
+svuint8_t svuzp2q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u32)))
+svuint32_t svuzp2q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u64)))
+svuint64_t svuzp2q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_u16)))
+svuint16_t svuzp2q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s8)))
+svint8_t svuzp2q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f64)))
+svfloat64_t svuzp2q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f32)))
+svfloat32_t svuzp2q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_f16)))
+svfloat16_t svuzp2q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s32)))
+svint32_t svuzp2q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s64)))
+svint64_t svuzp2q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2q_s16)))
+svint16_t svuzp2q(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u8)))
+svuint8_t svzip1q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u32)))
+svuint32_t svzip1q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u64)))
+svuint64_t svzip1q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_u16)))
+svuint16_t svzip1q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s8)))
+svint8_t svzip1q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f64)))
+svfloat64_t svzip1q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f32)))
+svfloat32_t svzip1q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_f16)))
+svfloat16_t svzip1q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s32)))
+svint32_t svzip1q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s64)))
+svint64_t svzip1q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1q_s16)))
+svint16_t svzip1q(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u8)))
+svuint8_t svzip2q(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u32)))
+svuint32_t svzip2q(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u64)))
+svuint64_t svzip2q(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_u16)))
+svuint16_t svzip2q(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s8)))
+svint8_t svzip2q(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f64)))
+svfloat64_t svzip2q(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f32)))
+svfloat32_t svzip2q(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_f16)))
+svfloat16_t svzip2q(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s32)))
+svint32_t svzip2q(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s64)))
+svint64_t svzip2q(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2q_s16)))
+svint16_t svzip2q(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_bf16)))
+svbfloat16_t svld1ro_bf16(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ro_bf16)))
+svbfloat16_t svld1ro(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_s32)))
+svint32_t svmmla_s32(svint32_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_u32)))
+svuint32_t svmmla_u32(svuint32_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusmmla_s32)))
+svint32_t svusmmla_s32(svint32_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_s32)))
+svint32_t svmmla(svint32_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmmla_u32)))
+svuint32_t svmmla(svuint32_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusmmla_s32)))
+svint32_t svusmmla(svint32_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_n_s32)))
+svint32_t svsudot_n_s32(svint32_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_s32)))
+svint32_t svsudot_s32(svint32_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_lane_s32)))
+svint32_t svsudot_lane_s32(svint32_t, svint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_n_s32)))
+svint32_t svusdot_n_s32(svint32_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_s32)))
+svint32_t svusdot_s32(svint32_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_lane_s32)))
+svint32_t svusdot_lane_s32(svint32_t, svuint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_n_s32)))
+svint32_t svsudot(svint32_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_s32)))
+svint32_t svsudot(svint32_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsudot_lane_s32)))
+svint32_t svsudot_lane(svint32_t, svint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_n_s32)))
+svint32_t svusdot(svint32_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_s32)))
+svint32_t svusdot(svint32_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svusdot_lane_s32)))
+svint32_t svusdot_lane(svint32_t, svuint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u32_z)))
+svuint32_t svhistcnt_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u64_z)))
+svuint64_t svhistcnt_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s32_z)))
+svuint32_t svhistcnt_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s64_z)))
+svuint64_t svhistcnt_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_u8)))
+svuint8_t svhistseg_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_s8)))
+svuint8_t svhistseg_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_u32)))
+svuint32_t svldnt1_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_u64)))
+svuint64_t svldnt1_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_f64)))
+svfloat64_t svldnt1_gather_u64base_index_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_f32)))
+svfloat32_t svldnt1_gather_u32base_index_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_s32)))
+svint32_t svldnt1_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_s64)))
+svint64_t svldnt1_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_u32)))
+svuint32_t svldnt1_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_u64)))
+svuint64_t svldnt1_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_f64)))
+svfloat64_t svldnt1_gather_u64base_offset_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_f32)))
+svfloat32_t svldnt1_gather_u32base_offset_f32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_s32)))
+svint32_t svldnt1_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_s64)))
+svint64_t svldnt1_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_u32)))
+svuint32_t svldnt1_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_u64)))
+svuint64_t svldnt1_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_f64)))
+svfloat64_t svldnt1_gather_u64base_f64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_f32)))
+svfloat32_t svldnt1_gather_u32base_f32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_s32)))
+svint32_t svldnt1_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_s64)))
+svint64_t svldnt1_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_u64)))
+svuint64_t svldnt1_gather_s64index_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_f64)))
+svfloat64_t svldnt1_gather_s64index_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_s64)))
+svint64_t svldnt1_gather_s64index_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_u64)))
+svuint64_t svldnt1_gather_u64index_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_f64)))
+svfloat64_t svldnt1_gather_u64index_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_s64)))
+svint64_t svldnt1_gather_u64index_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_u32)))
+svuint32_t svldnt1_gather_u32offset_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_f32)))
+svfloat32_t svldnt1_gather_u32offset_f32(svbool_t, float32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_s32)))
+svint32_t svldnt1_gather_u32offset_s32(svbool_t, int32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_u64)))
+svuint64_t svldnt1_gather_s64offset_u64(svbool_t, uint64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_f64)))
+svfloat64_t svldnt1_gather_s64offset_f64(svbool_t, float64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_s64)))
+svint64_t svldnt1_gather_s64offset_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_u64)))
+svuint64_t svldnt1_gather_u64offset_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_f64)))
+svfloat64_t svldnt1_gather_u64offset_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_s64)))
+svint64_t svldnt1_gather_u64offset_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_u32)))
+svuint32_t svldnt1sb_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_u64)))
+svuint64_t svldnt1sb_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_s32)))
+svint32_t svldnt1sb_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_s64)))
+svint64_t svldnt1sb_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_u32)))
+svuint32_t svldnt1sb_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_u64)))
+svuint64_t svldnt1sb_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_s32)))
+svint32_t svldnt1sb_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_s64)))
+svint64_t svldnt1sb_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_u32)))
+svuint32_t svldnt1sb_gather_u32offset_u32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_s32)))
+svint32_t svldnt1sb_gather_u32offset_s32(svbool_t, int8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_u64)))
+svuint64_t svldnt1sb_gather_s64offset_u64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_s64)))
+svint64_t svldnt1sb_gather_s64offset_s64(svbool_t, int8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_u64)))
+svuint64_t svldnt1sb_gather_u64offset_u64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_s64)))
+svint64_t svldnt1sb_gather_u64offset_s64(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_u32)))
+svuint32_t svldnt1sh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_u64)))
+svuint64_t svldnt1sh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_s32)))
+svint32_t svldnt1sh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_s64)))
+svint64_t svldnt1sh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_u32)))
+svuint32_t svldnt1sh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_u64)))
+svuint64_t svldnt1sh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_s32)))
+svint32_t svldnt1sh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_s64)))
+svint64_t svldnt1sh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_u32)))
+svuint32_t svldnt1sh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_u64)))
+svuint64_t svldnt1sh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_s32)))
+svint32_t svldnt1sh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_s64)))
+svint64_t svldnt1sh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_u64)))
+svuint64_t svldnt1sh_gather_s64index_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_s64)))
+svint64_t svldnt1sh_gather_s64index_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_u64)))
+svuint64_t svldnt1sh_gather_u64index_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_s64)))
+svint64_t svldnt1sh_gather_u64index_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_u32)))
+svuint32_t svldnt1sh_gather_u32offset_u32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_s32)))
+svint32_t svldnt1sh_gather_u32offset_s32(svbool_t, int16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_u64)))
+svuint64_t svldnt1sh_gather_s64offset_u64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_s64)))
+svint64_t svldnt1sh_gather_s64offset_s64(svbool_t, int16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_u64)))
+svuint64_t svldnt1sh_gather_u64offset_u64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_s64)))
+svint64_t svldnt1sh_gather_u64offset_s64(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_u64)))
+svuint64_t svldnt1sw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_s64)))
+svint64_t svldnt1sw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_u64)))
+svuint64_t svldnt1sw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_s64)))
+svint64_t svldnt1sw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_u64)))
+svuint64_t svldnt1sw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_s64)))
+svint64_t svldnt1sw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_u64)))
+svuint64_t svldnt1sw_gather_s64index_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_s64)))
+svint64_t svldnt1sw_gather_s64index_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_u64)))
+svuint64_t svldnt1sw_gather_u64index_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_s64)))
+svint64_t svldnt1sw_gather_u64index_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_u64)))
+svuint64_t svldnt1sw_gather_s64offset_u64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_s64)))
+svint64_t svldnt1sw_gather_s64offset_s64(svbool_t, int32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_u64)))
+svuint64_t svldnt1sw_gather_u64offset_u64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_s64)))
+svint64_t svldnt1sw_gather_u64offset_s64(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_u32)))
+svuint32_t svldnt1ub_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_u64)))
+svuint64_t svldnt1ub_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_s32)))
+svint32_t svldnt1ub_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_s64)))
+svint64_t svldnt1ub_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_u32)))
+svuint32_t svldnt1ub_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_u64)))
+svuint64_t svldnt1ub_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_s32)))
+svint32_t svldnt1ub_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_s64)))
+svint64_t svldnt1ub_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_u32)))
+svuint32_t svldnt1ub_gather_u32offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_s32)))
+svint32_t svldnt1ub_gather_u32offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_u64)))
+svuint64_t svldnt1ub_gather_s64offset_u64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_s64)))
+svint64_t svldnt1ub_gather_s64offset_s64(svbool_t, uint8_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_u64)))
+svuint64_t svldnt1ub_gather_u64offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_s64)))
+svint64_t svldnt1ub_gather_u64offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_u32)))
+svuint32_t svldnt1uh_gather_u32base_index_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_u64)))
+svuint64_t svldnt1uh_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_s32)))
+svint32_t svldnt1uh_gather_u32base_index_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_s64)))
+svint64_t svldnt1uh_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_u32)))
+svuint32_t svldnt1uh_gather_u32base_offset_u32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_u64)))
+svuint64_t svldnt1uh_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_s32)))
+svint32_t svldnt1uh_gather_u32base_offset_s32(svbool_t, svuint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_s64)))
+svint64_t svldnt1uh_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_u32)))
+svuint32_t svldnt1uh_gather_u32base_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_u64)))
+svuint64_t svldnt1uh_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_s32)))
+svint32_t svldnt1uh_gather_u32base_s32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_s64)))
+svint64_t svldnt1uh_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_u64)))
+svuint64_t svldnt1uh_gather_s64index_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_s64)))
+svint64_t svldnt1uh_gather_s64index_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_u64)))
+svuint64_t svldnt1uh_gather_u64index_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_s64)))
+svint64_t svldnt1uh_gather_u64index_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_u32)))
+svuint32_t svldnt1uh_gather_u32offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_s32)))
+svint32_t svldnt1uh_gather_u32offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_u64)))
+svuint64_t svldnt1uh_gather_s64offset_u64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_s64)))
+svint64_t svldnt1uh_gather_s64offset_s64(svbool_t, uint16_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_u64)))
+svuint64_t svldnt1uh_gather_u64offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_s64)))
+svint64_t svldnt1uh_gather_u64offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_u64)))
+svuint64_t svldnt1uw_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_s64)))
+svint64_t svldnt1uw_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_u64)))
+svuint64_t svldnt1uw_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_s64)))
+svint64_t svldnt1uw_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_u64)))
+svuint64_t svldnt1uw_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_s64)))
+svint64_t svldnt1uw_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_u64)))
+svuint64_t svldnt1uw_gather_s64index_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_s64)))
+svint64_t svldnt1uw_gather_s64index_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_u64)))
+svuint64_t svldnt1uw_gather_u64index_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_s64)))
+svint64_t svldnt1uw_gather_u64index_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_u64)))
+svuint64_t svldnt1uw_gather_s64offset_u64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_s64)))
+svint64_t svldnt1uw_gather_s64offset_s64(svbool_t, uint32_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_u64)))
+svuint64_t svldnt1uw_gather_u64offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_s64)))
+svint64_t svldnt1uw_gather_u64offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u8)))
+svbool_t svmatch_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u16)))
+svbool_t svmatch_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s8)))
+svbool_t svmatch_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s16)))
+svbool_t svmatch_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u8)))
+svbool_t svnmatch_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u16)))
+svbool_t svnmatch_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s8)))
+svbool_t svnmatch_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s16)))
+svbool_t svnmatch_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_u32)))
+void svstnt1_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_u64)))
+void svstnt1_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_f64)))
+void svstnt1_scatter_u64base_index_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_f32)))
+void svstnt1_scatter_u32base_index_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_s32)))
+void svstnt1_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_s64)))
+void svstnt1_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_u32)))
+void svstnt1_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_u64)))
+void svstnt1_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_f64)))
+void svstnt1_scatter_u64base_offset_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_f32)))
+void svstnt1_scatter_u32base_offset_f32(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_s32)))
+void svstnt1_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_s64)))
+void svstnt1_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_u32)))
+void svstnt1_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_u64)))
+void svstnt1_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_f64)))
+void svstnt1_scatter_u64base_f64(svbool_t, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_f32)))
+void svstnt1_scatter_u32base_f32(svbool_t, svuint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_s32)))
+void svstnt1_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_s64)))
+void svstnt1_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_u64)))
+void svstnt1_scatter_s64index_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_f64)))
+void svstnt1_scatter_s64index_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_s64)))
+void svstnt1_scatter_s64index_s64(svbool_t, int64_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_u64)))
+void svstnt1_scatter_u64index_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_f64)))
+void svstnt1_scatter_u64index_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_s64)))
+void svstnt1_scatter_u64index_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_u32)))
+void svstnt1_scatter_u32offset_u32(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_f32)))
+void svstnt1_scatter_u32offset_f32(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_s32)))
+void svstnt1_scatter_u32offset_s32(svbool_t, int32_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_u64)))
+void svstnt1_scatter_s64offset_u64(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_f64)))
+void svstnt1_scatter_s64offset_f64(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_s64)))
+void svstnt1_scatter_s64offset_s64(svbool_t, int64_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_u64)))
+void svstnt1_scatter_u64offset_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_f64)))
+void svstnt1_scatter_u64offset_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_s64)))
+void svstnt1_scatter_u64offset_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_u32)))
+void svstnt1b_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_u64)))
+void svstnt1b_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_s32)))
+void svstnt1b_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_s64)))
+void svstnt1b_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_u32)))
+void svstnt1b_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_u64)))
+void svstnt1b_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_s32)))
+void svstnt1b_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_s64)))
+void svstnt1b_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_s32)))
+void svstnt1b_scatter_u32offset_s32(svbool_t, int8_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_u32)))
+void svstnt1b_scatter_u32offset_u32(svbool_t, uint8_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_s64)))
+void svstnt1b_scatter_s64offset_s64(svbool_t, int8_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_u64)))
+void svstnt1b_scatter_s64offset_u64(svbool_t, uint8_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_s64)))
+void svstnt1b_scatter_u64offset_s64(svbool_t, int8_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_u64)))
+void svstnt1b_scatter_u64offset_u64(svbool_t, uint8_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_u32)))
+void svstnt1h_scatter_u32base_index_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_u64)))
+void svstnt1h_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_s32)))
+void svstnt1h_scatter_u32base_index_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_s64)))
+void svstnt1h_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_u32)))
+void svstnt1h_scatter_u32base_offset_u32(svbool_t, svuint32_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_u64)))
+void svstnt1h_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_s32)))
+void svstnt1h_scatter_u32base_offset_s32(svbool_t, svuint32_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_s64)))
+void svstnt1h_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_u32)))
+void svstnt1h_scatter_u32base_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_u64)))
+void svstnt1h_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_s32)))
+void svstnt1h_scatter_u32base_s32(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_s64)))
+void svstnt1h_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_s64)))
+void svstnt1h_scatter_s64index_s64(svbool_t, int16_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_u64)))
+void svstnt1h_scatter_s64index_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_s64)))
+void svstnt1h_scatter_u64index_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_u64)))
+void svstnt1h_scatter_u64index_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_s32)))
+void svstnt1h_scatter_u32offset_s32(svbool_t, int16_t *, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_u32)))
+void svstnt1h_scatter_u32offset_u32(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_s64)))
+void svstnt1h_scatter_s64offset_s64(svbool_t, int16_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_u64)))
+void svstnt1h_scatter_s64offset_u64(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_s64)))
+void svstnt1h_scatter_u64offset_s64(svbool_t, int16_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_u64)))
+void svstnt1h_scatter_u64offset_u64(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_u64)))
+void svstnt1w_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_s64)))
+void svstnt1w_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_u64)))
+void svstnt1w_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_s64)))
+void svstnt1w_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_u64)))
+void svstnt1w_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_s64)))
+void svstnt1w_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_s64)))
+void svstnt1w_scatter_s64index_s64(svbool_t, int32_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_u64)))
+void svstnt1w_scatter_s64index_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_s64)))
+void svstnt1w_scatter_u64index_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_u64)))
+void svstnt1w_scatter_u64index_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_s64)))
+void svstnt1w_scatter_s64offset_s64(svbool_t, int32_t *, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_u64)))
+void svstnt1w_scatter_s64offset_u64(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_s64)))
+void svstnt1w_scatter_u64offset_s64(svbool_t, int32_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_u64)))
+void svstnt1w_scatter_u64offset_u64(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u32_z)))
+svuint32_t svhistcnt_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_u64_z)))
+svuint64_t svhistcnt_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s32_z)))
+svuint32_t svhistcnt_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistcnt_s64_z)))
+svuint64_t svhistcnt_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_u8)))
+svuint8_t svhistseg(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhistseg_s8)))
+svuint8_t svhistseg(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_u32)))
+svuint32_t svldnt1_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_u64)))
+svuint64_t svldnt1_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_f64)))
+svfloat64_t svldnt1_gather_index_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_f32)))
+svfloat32_t svldnt1_gather_index_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_index_s32)))
+svint32_t svldnt1_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_index_s64)))
+svint64_t svldnt1_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_u32)))
+svuint32_t svldnt1_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_u64)))
+svuint64_t svldnt1_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_f64)))
+svfloat64_t svldnt1_gather_offset_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_f32)))
+svfloat32_t svldnt1_gather_offset_f32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_offset_s32)))
+svint32_t svldnt1_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_offset_s64)))
+svint64_t svldnt1_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_u32)))
+svuint32_t svldnt1_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_u64)))
+svuint64_t svldnt1_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_f64)))
+svfloat64_t svldnt1_gather_f64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_f32)))
+svfloat32_t svldnt1_gather_f32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32base_s32)))
+svint32_t svldnt1_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64base_s64)))
+svint64_t svldnt1_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_u64)))
+svuint64_t svldnt1_gather_index(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_f64)))
+svfloat64_t svldnt1_gather_index(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64index_s64)))
+svint64_t svldnt1_gather_index(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_u64)))
+svuint64_t svldnt1_gather_index(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_f64)))
+svfloat64_t svldnt1_gather_index(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64index_s64)))
+svint64_t svldnt1_gather_index(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_u32)))
+svuint32_t svldnt1_gather_offset(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_f32)))
+svfloat32_t svldnt1_gather_offset(svbool_t, float32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u32offset_s32)))
+svint32_t svldnt1_gather_offset(svbool_t, int32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_u64)))
+svuint64_t svldnt1_gather_offset(svbool_t, uint64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_f64)))
+svfloat64_t svldnt1_gather_offset(svbool_t, float64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_s64offset_s64)))
+svint64_t svldnt1_gather_offset(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_u64)))
+svuint64_t svldnt1_gather_offset(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_f64)))
+svfloat64_t svldnt1_gather_offset(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_gather_u64offset_s64)))
+svint64_t svldnt1_gather_offset(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_u32)))
+svuint32_t svldnt1sb_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_u64)))
+svuint64_t svldnt1sb_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_offset_s32)))
+svint32_t svldnt1sb_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_offset_s64)))
+svint64_t svldnt1sb_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_u32)))
+svuint32_t svldnt1sb_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_u64)))
+svuint64_t svldnt1sb_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32base_s32)))
+svint32_t svldnt1sb_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64base_s64)))
+svint64_t svldnt1sb_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_u32)))
+svuint32_t svldnt1sb_gather_offset_u32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u32offset_s32)))
+svint32_t svldnt1sb_gather_offset_s32(svbool_t, int8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_u64)))
+svuint64_t svldnt1sb_gather_offset_u64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_s64offset_s64)))
+svint64_t svldnt1sb_gather_offset_s64(svbool_t, int8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_u64)))
+svuint64_t svldnt1sb_gather_offset_u64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sb_gather_u64offset_s64)))
+svint64_t svldnt1sb_gather_offset_s64(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_u32)))
+svuint32_t svldnt1sh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_u64)))
+svuint64_t svldnt1sh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_index_s32)))
+svint32_t svldnt1sh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_index_s64)))
+svint64_t svldnt1sh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_u32)))
+svuint32_t svldnt1sh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_u64)))
+svuint64_t svldnt1sh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_offset_s32)))
+svint32_t svldnt1sh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_offset_s64)))
+svint64_t svldnt1sh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_u32)))
+svuint32_t svldnt1sh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_u64)))
+svuint64_t svldnt1sh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32base_s32)))
+svint32_t svldnt1sh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64base_s64)))
+svint64_t svldnt1sh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_u64)))
+svuint64_t svldnt1sh_gather_index_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64index_s64)))
+svint64_t svldnt1sh_gather_index_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_u64)))
+svuint64_t svldnt1sh_gather_index_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64index_s64)))
+svint64_t svldnt1sh_gather_index_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_u32)))
+svuint32_t svldnt1sh_gather_offset_u32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u32offset_s32)))
+svint32_t svldnt1sh_gather_offset_s32(svbool_t, int16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_u64)))
+svuint64_t svldnt1sh_gather_offset_u64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_s64offset_s64)))
+svint64_t svldnt1sh_gather_offset_s64(svbool_t, int16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_u64)))
+svuint64_t svldnt1sh_gather_offset_u64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sh_gather_u64offset_s64)))
+svint64_t svldnt1sh_gather_offset_s64(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_u64)))
+svuint64_t svldnt1sw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_index_s64)))
+svint64_t svldnt1sw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_u64)))
+svuint64_t svldnt1sw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_offset_s64)))
+svint64_t svldnt1sw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_u64)))
+svuint64_t svldnt1sw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64base_s64)))
+svint64_t svldnt1sw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_u64)))
+svuint64_t svldnt1sw_gather_index_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64index_s64)))
+svint64_t svldnt1sw_gather_index_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_u64)))
+svuint64_t svldnt1sw_gather_index_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64index_s64)))
+svint64_t svldnt1sw_gather_index_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_u64)))
+svuint64_t svldnt1sw_gather_offset_u64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_s64offset_s64)))
+svint64_t svldnt1sw_gather_offset_s64(svbool_t, int32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_u64)))
+svuint64_t svldnt1sw_gather_offset_u64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1sw_gather_u64offset_s64)))
+svint64_t svldnt1sw_gather_offset_s64(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_u32)))
+svuint32_t svldnt1ub_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_u64)))
+svuint64_t svldnt1ub_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_offset_s32)))
+svint32_t svldnt1ub_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_offset_s64)))
+svint64_t svldnt1ub_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_u32)))
+svuint32_t svldnt1ub_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_u64)))
+svuint64_t svldnt1ub_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32base_s32)))
+svint32_t svldnt1ub_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64base_s64)))
+svint64_t svldnt1ub_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_u32)))
+svuint32_t svldnt1ub_gather_offset_u32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u32offset_s32)))
+svint32_t svldnt1ub_gather_offset_s32(svbool_t, uint8_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_u64)))
+svuint64_t svldnt1ub_gather_offset_u64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_s64offset_s64)))
+svint64_t svldnt1ub_gather_offset_s64(svbool_t, uint8_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_u64)))
+svuint64_t svldnt1ub_gather_offset_u64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1ub_gather_u64offset_s64)))
+svint64_t svldnt1ub_gather_offset_s64(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_u32)))
+svuint32_t svldnt1uh_gather_index_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_u64)))
+svuint64_t svldnt1uh_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_index_s32)))
+svint32_t svldnt1uh_gather_index_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_index_s64)))
+svint64_t svldnt1uh_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_u32)))
+svuint32_t svldnt1uh_gather_offset_u32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_u64)))
+svuint64_t svldnt1uh_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_offset_s32)))
+svint32_t svldnt1uh_gather_offset_s32(svbool_t, svuint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_offset_s64)))
+svint64_t svldnt1uh_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_u32)))
+svuint32_t svldnt1uh_gather_u32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_u64)))
+svuint64_t svldnt1uh_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32base_s32)))
+svint32_t svldnt1uh_gather_s32(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64base_s64)))
+svint64_t svldnt1uh_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_u64)))
+svuint64_t svldnt1uh_gather_index_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64index_s64)))
+svint64_t svldnt1uh_gather_index_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_u64)))
+svuint64_t svldnt1uh_gather_index_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64index_s64)))
+svint64_t svldnt1uh_gather_index_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_u32)))
+svuint32_t svldnt1uh_gather_offset_u32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u32offset_s32)))
+svint32_t svldnt1uh_gather_offset_s32(svbool_t, uint16_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_u64)))
+svuint64_t svldnt1uh_gather_offset_u64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_s64offset_s64)))
+svint64_t svldnt1uh_gather_offset_s64(svbool_t, uint16_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_u64)))
+svuint64_t svldnt1uh_gather_offset_u64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uh_gather_u64offset_s64)))
+svint64_t svldnt1uh_gather_offset_s64(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_u64)))
+svuint64_t svldnt1uw_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_index_s64)))
+svint64_t svldnt1uw_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_u64)))
+svuint64_t svldnt1uw_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_offset_s64)))
+svint64_t svldnt1uw_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_u64)))
+svuint64_t svldnt1uw_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64base_s64)))
+svint64_t svldnt1uw_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_u64)))
+svuint64_t svldnt1uw_gather_index_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64index_s64)))
+svint64_t svldnt1uw_gather_index_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_u64)))
+svuint64_t svldnt1uw_gather_index_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64index_s64)))
+svint64_t svldnt1uw_gather_index_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_u64)))
+svuint64_t svldnt1uw_gather_offset_u64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_s64offset_s64)))
+svint64_t svldnt1uw_gather_offset_s64(svbool_t, uint32_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_u64)))
+svuint64_t svldnt1uw_gather_offset_u64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1uw_gather_u64offset_s64)))
+svint64_t svldnt1uw_gather_offset_s64(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u8)))
+svbool_t svmatch(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_u16)))
+svbool_t svmatch(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s8)))
+svbool_t svmatch(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmatch_s16)))
+svbool_t svmatch(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u8)))
+svbool_t svnmatch(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_u16)))
+svbool_t svnmatch(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s8)))
+svbool_t svnmatch(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmatch_s16)))
+svbool_t svnmatch(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_u32)))
+void svstnt1_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_u64)))
+void svstnt1_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_f64)))
+void svstnt1_scatter_index(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_f32)))
+void svstnt1_scatter_index(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_index_s32)))
+void svstnt1_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_index_s64)))
+void svstnt1_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_u32)))
+void svstnt1_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_u64)))
+void svstnt1_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_f64)))
+void svstnt1_scatter_offset(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_f32)))
+void svstnt1_scatter_offset(svbool_t, svuint32_t, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_offset_s32)))
+void svstnt1_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_offset_s64)))
+void svstnt1_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_u32)))
+void svstnt1_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_u64)))
+void svstnt1_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_f64)))
+void svstnt1_scatter(svbool_t, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_f32)))
+void svstnt1_scatter(svbool_t, svuint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32base_s32)))
+void svstnt1_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64base_s64)))
+void svstnt1_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_u64)))
+void svstnt1_scatter_index(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_f64)))
+void svstnt1_scatter_index(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64index_s64)))
+void svstnt1_scatter_index(svbool_t, int64_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_u64)))
+void svstnt1_scatter_index(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_f64)))
+void svstnt1_scatter_index(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64index_s64)))
+void svstnt1_scatter_index(svbool_t, int64_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_u32)))
+void svstnt1_scatter_offset(svbool_t, uint32_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_f32)))
+void svstnt1_scatter_offset(svbool_t, float32_t *, svuint32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u32offset_s32)))
+void svstnt1_scatter_offset(svbool_t, int32_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_u64)))
+void svstnt1_scatter_offset(svbool_t, uint64_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_f64)))
+void svstnt1_scatter_offset(svbool_t, float64_t *, svint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_s64offset_s64)))
+void svstnt1_scatter_offset(svbool_t, int64_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_u64)))
+void svstnt1_scatter_offset(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_f64)))
+void svstnt1_scatter_offset(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_scatter_u64offset_s64)))
+void svstnt1_scatter_offset(svbool_t, int64_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_u32)))
+void svstnt1b_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_u64)))
+void svstnt1b_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_offset_s32)))
+void svstnt1b_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_offset_s64)))
+void svstnt1b_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_u32)))
+void svstnt1b_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_u64)))
+void svstnt1b_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32base_s32)))
+void svstnt1b_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64base_s64)))
+void svstnt1b_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_s32)))
+void svstnt1b_scatter_offset(svbool_t, int8_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u32offset_u32)))
+void svstnt1b_scatter_offset(svbool_t, uint8_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_s64)))
+void svstnt1b_scatter_offset(svbool_t, int8_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_s64offset_u64)))
+void svstnt1b_scatter_offset(svbool_t, uint8_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_s64)))
+void svstnt1b_scatter_offset(svbool_t, int8_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1b_scatter_u64offset_u64)))
+void svstnt1b_scatter_offset(svbool_t, uint8_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_u32)))
+void svstnt1h_scatter_index(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_u64)))
+void svstnt1h_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_index_s32)))
+void svstnt1h_scatter_index(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_index_s64)))
+void svstnt1h_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_u32)))
+void svstnt1h_scatter_offset(svbool_t, svuint32_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_u64)))
+void svstnt1h_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_offset_s32)))
+void svstnt1h_scatter_offset(svbool_t, svuint32_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_offset_s64)))
+void svstnt1h_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_u32)))
+void svstnt1h_scatter(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_u64)))
+void svstnt1h_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32base_s32)))
+void svstnt1h_scatter(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64base_s64)))
+void svstnt1h_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_s64)))
+void svstnt1h_scatter_index(svbool_t, int16_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64index_u64)))
+void svstnt1h_scatter_index(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_s64)))
+void svstnt1h_scatter_index(svbool_t, int16_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64index_u64)))
+void svstnt1h_scatter_index(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_s32)))
+void svstnt1h_scatter_offset(svbool_t, int16_t *, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u32offset_u32)))
+void svstnt1h_scatter_offset(svbool_t, uint16_t *, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_s64)))
+void svstnt1h_scatter_offset(svbool_t, int16_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_s64offset_u64)))
+void svstnt1h_scatter_offset(svbool_t, uint16_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_s64)))
+void svstnt1h_scatter_offset(svbool_t, int16_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1h_scatter_u64offset_u64)))
+void svstnt1h_scatter_offset(svbool_t, uint16_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_u64)))
+void svstnt1w_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_index_s64)))
+void svstnt1w_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_u64)))
+void svstnt1w_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_offset_s64)))
+void svstnt1w_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_u64)))
+void svstnt1w_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64base_s64)))
+void svstnt1w_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_s64)))
+void svstnt1w_scatter_index(svbool_t, int32_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64index_u64)))
+void svstnt1w_scatter_index(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_s64)))
+void svstnt1w_scatter_index(svbool_t, int32_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64index_u64)))
+void svstnt1w_scatter_index(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_s64)))
+void svstnt1w_scatter_offset(svbool_t, int32_t *, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_s64offset_u64)))
+void svstnt1w_scatter_offset(svbool_t, uint32_t *, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_s64)))
+void svstnt1w_scatter_offset(svbool_t, int32_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1w_scatter_u64offset_u64)))
+void svstnt1w_scatter_offset(svbool_t, uint32_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_m)))
+svbfloat16_t svadd_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_x)))
+svbfloat16_t svadd_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_z)))
+svbfloat16_t svadd_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_m)))
+svbfloat16_t svadd_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_x)))
+svbfloat16_t svadd_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_z)))
+svbfloat16_t svadd_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_bf16)))
+svbfloat16_t svclamp_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_m)))
+svbfloat16_t svmax_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_x)))
+svbfloat16_t svmax_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_z)))
+svbfloat16_t svmax_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_m)))
+svbfloat16_t svmax_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x)))
+svbfloat16_t svmax_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_z)))
+svbfloat16_t svmax_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_m)))
+svbfloat16_t svmaxnm_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_x)))
+svbfloat16_t svmaxnm_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_z)))
+svbfloat16_t svmaxnm_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_m)))
+svbfloat16_t svmaxnm_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x)))
+svbfloat16_t svmaxnm_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_z)))
+svbfloat16_t svmaxnm_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_m)))
+svbfloat16_t svmin_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_x)))
+svbfloat16_t svmin_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_z)))
+svbfloat16_t svmin_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_m)))
+svbfloat16_t svmin_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x)))
+svbfloat16_t svmin_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_z)))
+svbfloat16_t svmin_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_m)))
+svbfloat16_t svminnm_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_x)))
+svbfloat16_t svminnm_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_z)))
+svbfloat16_t svminnm_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_m)))
+svbfloat16_t svminnm_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x)))
+svbfloat16_t svminnm_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_z)))
+svbfloat16_t svminnm_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_m)))
+svbfloat16_t svmla_n_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_x)))
+svbfloat16_t svmla_n_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_z)))
+svbfloat16_t svmla_n_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_m)))
+svbfloat16_t svmla_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_x)))
+svbfloat16_t svmla_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_z)))
+svbfloat16_t svmla_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_bf16)))
+svbfloat16_t svmla_lane_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_m)))
+svbfloat16_t svmls_n_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_x)))
+svbfloat16_t svmls_n_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_z)))
+svbfloat16_t svmls_n_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_m)))
+svbfloat16_t svmls_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_x)))
+svbfloat16_t svmls_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_z)))
+svbfloat16_t svmls_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_bf16)))
+svbfloat16_t svmls_lane_bf16(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_m)))
+svbfloat16_t svmul_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_x)))
+svbfloat16_t svmul_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_z)))
+svbfloat16_t svmul_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_m)))
+svbfloat16_t svmul_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_x)))
+svbfloat16_t svmul_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_z)))
+svbfloat16_t svmul_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_bf16)))
+svbfloat16_t svmul_lane_bf16(svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_m)))
+svbfloat16_t svsub_n_bf16_m(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_x)))
+svbfloat16_t svsub_n_bf16_x(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_z)))
+svbfloat16_t svsub_n_bf16_z(svbool_t, svbfloat16_t, bfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_m)))
+svbfloat16_t svsub_bf16_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_x)))
+svbfloat16_t svsub_bf16_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_z)))
+svbfloat16_t svsub_bf16_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_m)))
+svbfloat16_t svadd_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_x)))
+svbfloat16_t svadd_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_bf16_z)))
+svbfloat16_t svadd_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_m)))
+svbfloat16_t svadd_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_x)))
+svbfloat16_t svadd_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_bf16_z)))
+svbfloat16_t svadd_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_bf16)))
+svbfloat16_t svclamp(svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_m)))
+svbfloat16_t svmax_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_x)))
+svbfloat16_t svmax_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_bf16_z)))
+svbfloat16_t svmax_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_m)))
+svbfloat16_t svmax_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_x)))
+svbfloat16_t svmax_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_bf16_z)))
+svbfloat16_t svmax_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_m)))
+svbfloat16_t svmaxnm_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_x)))
+svbfloat16_t svmaxnm_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_bf16_z)))
+svbfloat16_t svmaxnm_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_m)))
+svbfloat16_t svmaxnm_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_x)))
+svbfloat16_t svmaxnm_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_bf16_z)))
+svbfloat16_t svmaxnm_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_m)))
+svbfloat16_t svmin_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_x)))
+svbfloat16_t svmin_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_bf16_z)))
+svbfloat16_t svmin_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_m)))
+svbfloat16_t svmin_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_x)))
+svbfloat16_t svmin_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_bf16_z)))
+svbfloat16_t svmin_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_m)))
+svbfloat16_t svminnm_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_x)))
+svbfloat16_t svminnm_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_bf16_z)))
+svbfloat16_t svminnm_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_m)))
+svbfloat16_t svminnm_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_x)))
+svbfloat16_t svminnm_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_bf16_z)))
+svbfloat16_t svminnm_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_m)))
+svbfloat16_t svmla_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_x)))
+svbfloat16_t svmla_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_bf16_z)))
+svbfloat16_t svmla_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_m)))
+svbfloat16_t svmla_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_x)))
+svbfloat16_t svmla_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_bf16_z)))
+svbfloat16_t svmla_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_bf16)))
+svbfloat16_t svmla_lane(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_m)))
+svbfloat16_t svmls_m(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_x)))
+svbfloat16_t svmls_x(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_bf16_z)))
+svbfloat16_t svmls_z(svbool_t, svbfloat16_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_m)))
+svbfloat16_t svmls_m(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_x)))
+svbfloat16_t svmls_x(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_bf16_z)))
+svbfloat16_t svmls_z(svbool_t, svbfloat16_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_bf16)))
+svbfloat16_t svmls_lane(svbfloat16_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_m)))
+svbfloat16_t svmul_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_x)))
+svbfloat16_t svmul_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_bf16_z)))
+svbfloat16_t svmul_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_m)))
+svbfloat16_t svmul_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_x)))
+svbfloat16_t svmul_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_bf16_z)))
+svbfloat16_t svmul_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_bf16)))
+svbfloat16_t svmul_lane(svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_m)))
+svbfloat16_t svsub_m(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_x)))
+svbfloat16_t svsub_x(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_bf16_z)))
+svbfloat16_t svsub_z(svbool_t, svbfloat16_t, bfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_m)))
+svbfloat16_t svsub_m(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_x)))
+svbfloat16_t svsub_x(svbool_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_bf16_z)))
+svbfloat16_t svsub_z(svbool_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_bf16)))
+svbfloat16_t svtbl2_bf16(svbfloat16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_bf16)))
+svbfloat16_t svtbx_bf16(svbfloat16_t, svbfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_bf16)))
+svbool_t svwhilerw_bf16(bfloat16_t const *, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_bf16)))
+svbool_t svwhilewr_bf16(bfloat16_t const *, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_bf16)))
+svbfloat16_t svtbl2(svbfloat16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_bf16)))
+svbfloat16_t svtbx(svbfloat16_t, svbfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_bf16)))
+svbool_t svwhilerw(bfloat16_t const *, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_bf16)))
+svbool_t svwhilewr(bfloat16_t const *, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaesd_u8)))
+svuint8_t svaesd_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaese_u8)))
+svuint8_t svaese_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaesimc_u8)))
+svuint8_t svaesimc_u8(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaesmc_u8)))
+svuint8_t svaesmc_u8(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u64)))
+svuint64_t svpmullb_pair_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u64)))
+svuint64_t svpmullb_pair_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u64)))
+svuint64_t svpmullt_pair_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u64)))
+svuint64_t svpmullt_pair_u64(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaesd_u8)))
+svuint8_t svaesd(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaese_u8)))
+svuint8_t svaese(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaesimc_u8)))
+svuint8_t svaesimc(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaesmc_u8)))
+svuint8_t svaesmc(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u64)))
+svuint64_t svpmullb_pair(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u64)))
+svuint64_t svpmullb_pair(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u64)))
+svuint64_t svpmullt_pair(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u64)))
+svuint64_t svpmullt_pair(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_n_u8)))
+svuint8_t svbdep_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_n_u32)))
+svuint32_t svbdep_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_n_u64)))
+svuint64_t svbdep_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_n_u16)))
+svuint16_t svbdep_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_u8)))
+svuint8_t svbdep_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_u32)))
+svuint32_t svbdep_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_u64)))
+svuint64_t svbdep_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_u16)))
+svuint16_t svbdep_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_n_u8)))
+svuint8_t svbext_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_n_u32)))
+svuint32_t svbext_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_n_u64)))
+svuint64_t svbext_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_n_u16)))
+svuint16_t svbext_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_u8)))
+svuint8_t svbext_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_u32)))
+svuint32_t svbext_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_u64)))
+svuint64_t svbext_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_u16)))
+svuint16_t svbext_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_n_u8)))
+svuint8_t svbgrp_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_n_u32)))
+svuint32_t svbgrp_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_n_u64)))
+svuint64_t svbgrp_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_n_u16)))
+svuint16_t svbgrp_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_u8)))
+svuint8_t svbgrp_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_u32)))
+svuint32_t svbgrp_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_u64)))
+svuint64_t svbgrp_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_u16)))
+svuint16_t svbgrp_u16(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_n_u8)))
+svuint8_t svbdep(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_n_u32)))
+svuint32_t svbdep(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_n_u64)))
+svuint64_t svbdep(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_n_u16)))
+svuint16_t svbdep(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_u8)))
+svuint8_t svbdep(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_u32)))
+svuint32_t svbdep(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_u64)))
+svuint64_t svbdep(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbdep_u16)))
+svuint16_t svbdep(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_n_u8)))
+svuint8_t svbext(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_n_u32)))
+svuint32_t svbext(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_n_u64)))
+svuint64_t svbext(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_n_u16)))
+svuint16_t svbext(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_u8)))
+svuint8_t svbext(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_u32)))
+svuint32_t svbext(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_u64)))
+svuint64_t svbext(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbext_u16)))
+svuint16_t svbext(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_n_u8)))
+svuint8_t svbgrp(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_n_u32)))
+svuint32_t svbgrp(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_n_u64)))
+svuint64_t svbgrp(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_n_u16)))
+svuint16_t svbgrp(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_u8)))
+svuint8_t svbgrp(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_u32)))
+svuint32_t svbgrp(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_u64)))
+svuint64_t svbgrp(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbgrp_u16)))
+svuint16_t svbgrp(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrax1_u64)))
+svuint64_t svrax1_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrax1_s64)))
+svint64_t svrax1_s64(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrax1_u64)))
+svuint64_t svrax1(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrax1_s64)))
+svint64_t svrax1(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsm4e_u32)))
+svuint32_t svsm4e_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsm4ekey_u32)))
+svuint32_t svsm4ekey_u32(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsm4e_u32)))
+svuint32_t svsm4e(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsm4ekey_u32)))
+svuint32_t svsm4ekey(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_u8)))
+uint8x16_t svaddqv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_u32)))
+uint32x4_t svaddqv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_u64)))
+uint64x2_t svaddqv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_u16)))
+uint16x8_t svaddqv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s8)))
+int8x16_t svaddqv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s32)))
+int32x4_t svaddqv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s64)))
+int64x2_t svaddqv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s16)))
+int16x8_t svaddqv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f64)))
+float64x2_t svaddqv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f32)))
+float32x4_t svaddqv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f16)))
+float16x8_t svaddqv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u8)))
+uint8x16_t svandqv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u32)))
+uint32x4_t svandqv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u64)))
+uint64x2_t svandqv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u16)))
+uint16x8_t svandqv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_s8)))
+int8x16_t svandqv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_s32)))
+int32x4_t svandqv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_s64)))
+int64x2_t svandqv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_s16)))
+int16x8_t svandqv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_u8)))
+uint8x16_t sveorqv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_u32)))
+uint32x4_t sveorqv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_u64)))
+uint64x2_t sveorqv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_u16)))
+uint16x8_t sveorqv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_s8)))
+int8x16_t sveorqv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_s32)))
+int32x4_t sveorqv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_s64)))
+int64x2_t sveorqv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_s16)))
+int16x8_t sveorqv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_u8)))
+svuint8_t svextq_u8(svuint8_t, svuint8_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_u32)))
+svuint32_t svextq_u32(svuint32_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_u64)))
+svuint64_t svextq_u64(svuint64_t, svuint64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_u16)))
+svuint16_t svextq_u16(svuint16_t, svuint16_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_bf16)))
+svbfloat16_t svextq_bf16(svbfloat16_t, svbfloat16_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_s8)))
+svint8_t svextq_s8(svint8_t, svint8_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_f64)))
+svfloat64_t svextq_f64(svfloat64_t, svfloat64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_f32)))
+svfloat32_t svextq_f32(svfloat32_t, svfloat32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_f16)))
+svfloat16_t svextq_f16(svfloat16_t, svfloat16_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_s32)))
+svint32_t svextq_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_s64)))
+svint64_t svextq_s64(svint64_t, svint64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_s16)))
+svint16_t svextq_s16(svint16_t, svint16_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_u32)))
+svuint32_t svld1q_gather_u64base_index_u32(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_u64)))
+svuint64_t svld1q_gather_u64base_index_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_u16)))
+svuint16_t svld1q_gather_u64base_index_u16(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_bf16)))
+svbfloat16_t svld1q_gather_u64base_index_bf16(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_f64)))
+svfloat64_t svld1q_gather_u64base_index_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_f32)))
+svfloat32_t svld1q_gather_u64base_index_f32(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_f16)))
+svfloat16_t svld1q_gather_u64base_index_f16(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_s32)))
+svint32_t svld1q_gather_u64base_index_s32(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_s64)))
+svint64_t svld1q_gather_u64base_index_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_s16)))
+svint16_t svld1q_gather_u64base_index_s16(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_u8)))
+svuint8_t svld1q_gather_u64base_offset_u8(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_u32)))
+svuint32_t svld1q_gather_u64base_offset_u32(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_u64)))
+svuint64_t svld1q_gather_u64base_offset_u64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_u16)))
+svuint16_t svld1q_gather_u64base_offset_u16(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_bf16)))
+svbfloat16_t svld1q_gather_u64base_offset_bf16(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_s8)))
+svint8_t svld1q_gather_u64base_offset_s8(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_f64)))
+svfloat64_t svld1q_gather_u64base_offset_f64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_f32)))
+svfloat32_t svld1q_gather_u64base_offset_f32(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_f16)))
+svfloat16_t svld1q_gather_u64base_offset_f16(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_s32)))
+svint32_t svld1q_gather_u64base_offset_s32(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_s64)))
+svint64_t svld1q_gather_u64base_offset_s64(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_s16)))
+svint16_t svld1q_gather_u64base_offset_s16(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_u8)))
+svuint8_t svld1q_gather_u64base_u8(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_u32)))
+svuint32_t svld1q_gather_u64base_u32(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_u64)))
+svuint64_t svld1q_gather_u64base_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_u16)))
+svuint16_t svld1q_gather_u64base_u16(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_bf16)))
+svbfloat16_t svld1q_gather_u64base_bf16(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_s8)))
+svint8_t svld1q_gather_u64base_s8(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_f64)))
+svfloat64_t svld1q_gather_u64base_f64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_f32)))
+svfloat32_t svld1q_gather_u64base_f32(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_f16)))
+svfloat16_t svld1q_gather_u64base_f16(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_s32)))
+svint32_t svld1q_gather_u64base_s32(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_s64)))
+svint64_t svld1q_gather_u64base_s64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_s16)))
+svint16_t svld1q_gather_u64base_s16(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_u32)))
+svuint32_t svld1q_gather_u64index_u32(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_u64)))
+svuint64_t svld1q_gather_u64index_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_u16)))
+svuint16_t svld1q_gather_u64index_u16(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_bf16)))
+svbfloat16_t svld1q_gather_u64index_bf16(svbool_t, bfloat16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_f64)))
+svfloat64_t svld1q_gather_u64index_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_f32)))
+svfloat32_t svld1q_gather_u64index_f32(svbool_t, float32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_f16)))
+svfloat16_t svld1q_gather_u64index_f16(svbool_t, float16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_s32)))
+svint32_t svld1q_gather_u64index_s32(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_s64)))
+svint64_t svld1q_gather_u64index_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_s16)))
+svint16_t svld1q_gather_u64index_s16(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_u8)))
+svuint8_t svld1q_gather_u64offset_u8(svbool_t, uint8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_u32)))
+svuint32_t svld1q_gather_u64offset_u32(svbool_t, uint32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_u64)))
+svuint64_t svld1q_gather_u64offset_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_u16)))
+svuint16_t svld1q_gather_u64offset_u16(svbool_t, uint16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_bf16)))
+svbfloat16_t svld1q_gather_u64offset_bf16(svbool_t, bfloat16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_s8)))
+svint8_t svld1q_gather_u64offset_s8(svbool_t, int8_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_f64)))
+svfloat64_t svld1q_gather_u64offset_f64(svbool_t, float64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_f32)))
+svfloat32_t svld1q_gather_u64offset_f32(svbool_t, float32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_f16)))
+svfloat16_t svld1q_gather_u64offset_f16(svbool_t, float16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_s32)))
+svint32_t svld1q_gather_u64offset_s32(svbool_t, int32_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_s64)))
+svint64_t svld1q_gather_u64offset_s64(svbool_t, int64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_s16)))
+svint16_t svld1q_gather_u64offset_s16(svbool_t, int16_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_u64)))
+svuint64_t svld1udq_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_f64)))
+svfloat64_t svld1udq_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_s64)))
+svint64_t svld1udq_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_vnum_u64)))
+svuint64_t svld1udq_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_vnum_f64)))
+svfloat64_t svld1udq_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_vnum_s64)))
+svint64_t svld1udq_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_u32)))
+svuint32_t svld1uwq_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_f32)))
+svfloat32_t svld1uwq_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_s32)))
+svint32_t svld1uwq_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_vnum_u32)))
+svuint32_t svld1uwq_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_vnum_f32)))
+svfloat32_t svld1uwq_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_vnum_s32)))
+svint32_t svld1uwq_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_u8)))
+svuint8x2_t svld2q_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_u32)))
+svuint32x2_t svld2q_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_u64)))
+svuint64x2_t svld2q_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_u16)))
+svuint16x2_t svld2q_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_s8)))
+svint8x2_t svld2q_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_f64)))
+svfloat64x2_t svld2q_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_f32)))
+svfloat32x2_t svld2q_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_f16)))
+svfloat16x2_t svld2q_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_s32)))
+svint32x2_t svld2q_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_s64)))
+svint64x2_t svld2q_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_s16)))
+svint16x2_t svld2q_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_bf16)))
+svbfloat16x2_t svld2q_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_u8)))
+svuint8x2_t svld2q_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_u32)))
+svuint32x2_t svld2q_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_u64)))
+svuint64x2_t svld2q_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_u16)))
+svuint16x2_t svld2q_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_s8)))
+svint8x2_t svld2q_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_f64)))
+svfloat64x2_t svld2q_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_f32)))
+svfloat32x2_t svld2q_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_f16)))
+svfloat16x2_t svld2q_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_s32)))
+svint32x2_t svld2q_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_s64)))
+svint64x2_t svld2q_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_s16)))
+svint16x2_t svld2q_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_bf16)))
+svbfloat16x2_t svld2q_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_u8)))
+svuint8x3_t svld3q_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_u32)))
+svuint32x3_t svld3q_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_u64)))
+svuint64x3_t svld3q_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_u16)))
+svuint16x3_t svld3q_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_s8)))
+svint8x3_t svld3q_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_f64)))
+svfloat64x3_t svld3q_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_f32)))
+svfloat32x3_t svld3q_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_f16)))
+svfloat16x3_t svld3q_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_s32)))
+svint32x3_t svld3q_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_s64)))
+svint64x3_t svld3q_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_s16)))
+svint16x3_t svld3q_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_bf16)))
+svbfloat16x3_t svld3q_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_u8)))
+svuint8x3_t svld3q_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_u32)))
+svuint32x3_t svld3q_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_u64)))
+svuint64x3_t svld3q_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_u16)))
+svuint16x3_t svld3q_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_s8)))
+svint8x3_t svld3q_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_f64)))
+svfloat64x3_t svld3q_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_f32)))
+svfloat32x3_t svld3q_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_f16)))
+svfloat16x3_t svld3q_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_s32)))
+svint32x3_t svld3q_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_s64)))
+svint64x3_t svld3q_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_s16)))
+svint16x3_t svld3q_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_bf16)))
+svbfloat16x3_t svld3q_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_u8)))
+svuint8x4_t svld4q_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_u32)))
+svuint32x4_t svld4q_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_u64)))
+svuint64x4_t svld4q_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_u16)))
+svuint16x4_t svld4q_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_s8)))
+svint8x4_t svld4q_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_f64)))
+svfloat64x4_t svld4q_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_f32)))
+svfloat32x4_t svld4q_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_f16)))
+svfloat16x4_t svld4q_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_s32)))
+svint32x4_t svld4q_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_s64)))
+svint64x4_t svld4q_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_s16)))
+svint16x4_t svld4q_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_bf16)))
+svbfloat16x4_t svld4q_bf16(svbool_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_u8)))
+svuint8x4_t svld4q_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_u32)))
+svuint32x4_t svld4q_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_u64)))
+svuint64x4_t svld4q_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_u16)))
+svuint16x4_t svld4q_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_s8)))
+svint8x4_t svld4q_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_f64)))
+svfloat64x4_t svld4q_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_f32)))
+svfloat32x4_t svld4q_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_f16)))
+svfloat16x4_t svld4q_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_s32)))
+svint32x4_t svld4q_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_s64)))
+svint64x4_t svld4q_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_s16)))
+svint16x4_t svld4q_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_bf16)))
+svbfloat16x4_t svld4q_vnum_bf16(svbool_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmqv_f64)))
+float64x2_t svmaxnmqv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmqv_f32)))
+float32x4_t svmaxnmqv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmqv_f16)))
+float16x8_t svmaxnmqv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_f64)))
+float64x2_t svmaxqv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_f32)))
+float32x4_t svmaxqv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_f16)))
+float16x8_t svmaxqv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_s8)))
+int8x16_t svmaxqv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_s32)))
+int32x4_t svmaxqv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_s64)))
+int64x2_t svmaxqv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_s16)))
+int16x8_t svmaxqv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_u8)))
+uint8x16_t svmaxqv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_u32)))
+uint32x4_t svmaxqv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_u64)))
+uint64x2_t svmaxqv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_u16)))
+uint16x8_t svmaxqv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmqv_f64)))
+float64x2_t svminnmqv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmqv_f32)))
+float32x4_t svminnmqv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmqv_f16)))
+float16x8_t svminnmqv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_f64)))
+float64x2_t svminqv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_f32)))
+float32x4_t svminqv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_f16)))
+float16x8_t svminqv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_s8)))
+int8x16_t svminqv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_s32)))
+int32x4_t svminqv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_s64)))
+int64x2_t svminqv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_s16)))
+int16x8_t svminqv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_u8)))
+uint8x16_t svminqv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_u32)))
+uint32x4_t svminqv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_u64)))
+uint64x2_t svminqv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_u16)))
+uint16x8_t svminqv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_u8)))
+uint8x16_t svorqv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_u32)))
+uint32x4_t svorqv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_u64)))
+uint64x2_t svorqv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_u16)))
+uint16x8_t svorqv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_s8)))
+int8x16_t svorqv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_s32)))
+int32x4_t svorqv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_s64)))
+int64x2_t svorqv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_s16)))
+int16x8_t svorqv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u8)))
+svbool_t svpmov_u8(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s8)))
+svbool_t svpmov_s8(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u64)))
+svbool_t svpmov_u64(svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s64)))
+svbool_t svpmov_s64(svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u16)))
+svbool_t svpmov_u16(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s16)))
+svbool_t svpmov_s16(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u32)))
+svbool_t svpmov_u32(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s32)))
+svbool_t svpmov_s32(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u8)))
+svbool_t svpmov_lane_u8(svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s8)))
+svbool_t svpmov_lane_s8(svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u64)))
+svbool_t svpmov_lane_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s64)))
+svbool_t svpmov_lane_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u16)))
+svbool_t svpmov_lane_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s16)))
+svbool_t svpmov_lane_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u32)))
+svbool_t svpmov_lane_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s32)))
+svbool_t svpmov_lane_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u64_m)))
+svuint64_t svpmov_lane_u64_m(svuint64_t, svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s64_m)))
+svint64_t svpmov_lane_s64_m(svint64_t, svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u16_m)))
+svuint16_t svpmov_lane_u16_m(svuint16_t, svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s16_m)))
+svint16_t svpmov_lane_s16_m(svint16_t, svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u32_m)))
+svuint32_t svpmov_lane_u32_m(svuint32_t, svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s32_m)))
+svint32_t svpmov_lane_s32_m(svint32_t, svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u8_z)))
+svuint8_t svpmov_u8_z(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s8_z)))
+svint8_t svpmov_s8_z(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u64_z)))
+svuint64_t svpmov_u64_z(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s64_z)))
+svint64_t svpmov_s64_z(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u16_z)))
+svuint16_t svpmov_u16_z(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s16_z)))
+svint16_t svpmov_s16_z(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u32_z)))
+svuint32_t svpmov_u32_z(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s32_z)))
+svint32_t svpmov_s32_z(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_u64)))
+void svst1dq_u64(svbool_t, uint64_t const *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_f64)))
+void svst1dq_f64(svbool_t, float64_t const *, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_s64)))
+void svst1dq_s64(svbool_t, int64_t const *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_vnum_u64)))
+void svst1dq_vnum_u64(svbool_t, uint64_t const *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_vnum_f64)))
+void svst1dq_vnum_f64(svbool_t, float64_t const *, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_vnum_s64)))
+void svst1dq_vnum_s64(svbool_t, int64_t const *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_u8)))
+void svst1q_scatter_u64base_u8(svbool_t, svuint64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_u32)))
+void svst1q_scatter_u64base_u32(svbool_t, svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_u64)))
+void svst1q_scatter_u64base_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_u16)))
+void svst1q_scatter_u64base_u16(svbool_t, svuint64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_bf16)))
+void svst1q_scatter_u64base_bf16(svbool_t, svuint64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_s8)))
+void svst1q_scatter_u64base_s8(svbool_t, svuint64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_f64)))
+void svst1q_scatter_u64base_f64(svbool_t, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_f32)))
+void svst1q_scatter_u64base_f32(svbool_t, svuint64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_f16)))
+void svst1q_scatter_u64base_f16(svbool_t, svuint64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_s32)))
+void svst1q_scatter_u64base_s32(svbool_t, svuint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_s64)))
+void svst1q_scatter_u64base_s64(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_s16)))
+void svst1q_scatter_u64base_s16(svbool_t, svuint64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_u32)))
+void svst1q_scatter_u64base_index_u32(svbool_t, svuint64_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_u64)))
+void svst1q_scatter_u64base_index_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_u16)))
+void svst1q_scatter_u64base_index_u16(svbool_t, svuint64_t, int64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_bf16)))
+void svst1q_scatter_u64base_index_bf16(svbool_t, svuint64_t, int64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_f64)))
+void svst1q_scatter_u64base_index_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_f32)))
+void svst1q_scatter_u64base_index_f32(svbool_t, svuint64_t, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_f16)))
+void svst1q_scatter_u64base_index_f16(svbool_t, svuint64_t, int64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_s32)))
+void svst1q_scatter_u64base_index_s32(svbool_t, svuint64_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_s64)))
+void svst1q_scatter_u64base_index_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_s16)))
+void svst1q_scatter_u64base_index_s16(svbool_t, svuint64_t, int64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_u8)))
+void svst1q_scatter_u64base_offset_u8(svbool_t, svuint64_t, int64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_u32)))
+void svst1q_scatter_u64base_offset_u32(svbool_t, svuint64_t, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_u64)))
+void svst1q_scatter_u64base_offset_u64(svbool_t, svuint64_t, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_u16)))
+void svst1q_scatter_u64base_offset_u16(svbool_t, svuint64_t, int64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_bf16)))
+void svst1q_scatter_u64base_offset_bf16(svbool_t, svuint64_t, int64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_s8)))
+void svst1q_scatter_u64base_offset_s8(svbool_t, svuint64_t, int64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_f64)))
+void svst1q_scatter_u64base_offset_f64(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_f32)))
+void svst1q_scatter_u64base_offset_f32(svbool_t, svuint64_t, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_f16)))
+void svst1q_scatter_u64base_offset_f16(svbool_t, svuint64_t, int64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_s32)))
+void svst1q_scatter_u64base_offset_s32(svbool_t, svuint64_t, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_s64)))
+void svst1q_scatter_u64base_offset_s64(svbool_t, svuint64_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_s16)))
+void svst1q_scatter_u64base_offset_s16(svbool_t, svuint64_t, int64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_u32)))
+void svst1q_scatter_u64index_u32(svbool_t, uint32_t *, svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_u64)))
+void svst1q_scatter_u64index_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_u16)))
+void svst1q_scatter_u64index_u16(svbool_t, uint16_t *, svuint64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_bf16)))
+void svst1q_scatter_u64index_bf16(svbool_t, bfloat16_t *, svuint64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_f64)))
+void svst1q_scatter_u64index_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_f32)))
+void svst1q_scatter_u64index_f32(svbool_t, float32_t *, svuint64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_f16)))
+void svst1q_scatter_u64index_f16(svbool_t, float16_t *, svuint64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_s32)))
+void svst1q_scatter_u64index_s32(svbool_t, int32_t *, svuint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_s64)))
+void svst1q_scatter_u64index_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_s16)))
+void svst1q_scatter_u64index_s16(svbool_t, int16_t *, svuint64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_u8)))
+void svst1q_scatter_u64offset_u8(svbool_t, uint8_t *, svuint64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_u32)))
+void svst1q_scatter_u64offset_u32(svbool_t, uint32_t *, svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_u64)))
+void svst1q_scatter_u64offset_u64(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_u16)))
+void svst1q_scatter_u64offset_u16(svbool_t, uint16_t *, svuint64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_bf16)))
+void svst1q_scatter_u64offset_bf16(svbool_t, bfloat16_t *, svuint64_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_s8)))
+void svst1q_scatter_u64offset_s8(svbool_t, int8_t *, svuint64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_f64)))
+void svst1q_scatter_u64offset_f64(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_f32)))
+void svst1q_scatter_u64offset_f32(svbool_t, float32_t *, svuint64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_f16)))
+void svst1q_scatter_u64offset_f16(svbool_t, float16_t *, svuint64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_s32)))
+void svst1q_scatter_u64offset_s32(svbool_t, int32_t *, svuint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_s64)))
+void svst1q_scatter_u64offset_s64(svbool_t, int64_t *, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_s16)))
+void svst1q_scatter_u64offset_s16(svbool_t, int16_t *, svuint64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_u32)))
+void svst1wq_u32(svbool_t, uint32_t const *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_f32)))
+void svst1wq_f32(svbool_t, float32_t const *, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_s32)))
+void svst1wq_s32(svbool_t, int32_t const *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_vnum_u32)))
+void svst1wq_vnum_u32(svbool_t, uint32_t const *, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_vnum_f32)))
+void svst1wq_vnum_f32(svbool_t, float32_t const *, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_vnum_s32)))
+void svst1wq_vnum_s32(svbool_t, int32_t const *, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_u8)))
+void svst2q_u8(svbool_t, uint8_t const *, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_u32)))
+void svst2q_u32(svbool_t, uint32_t const *, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_u64)))
+void svst2q_u64(svbool_t, uint64_t const *, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_u16)))
+void svst2q_u16(svbool_t, uint16_t const *, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_s8)))
+void svst2q_s8(svbool_t, int8_t const *, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_f64)))
+void svst2q_f64(svbool_t, float64_t const *, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_f32)))
+void svst2q_f32(svbool_t, float32_t const *, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_f16)))
+void svst2q_f16(svbool_t, float16_t const *, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_s32)))
+void svst2q_s32(svbool_t, int32_t const *, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_s64)))
+void svst2q_s64(svbool_t, int64_t const *, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_s16)))
+void svst2q_s16(svbool_t, int16_t const *, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_bf16)))
+void svst2q_bf16(svbool_t, bfloat16_t const *, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_u8)))
+void svst2q_vnum_u8(svbool_t, uint8_t const *, int64_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_u32)))
+void svst2q_vnum_u32(svbool_t, uint32_t const *, int64_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_u64)))
+void svst2q_vnum_u64(svbool_t, uint64_t const *, int64_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_u16)))
+void svst2q_vnum_u16(svbool_t, uint16_t const *, int64_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_s8)))
+void svst2q_vnum_s8(svbool_t, int8_t const *, int64_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_f64)))
+void svst2q_vnum_f64(svbool_t, float64_t const *, int64_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_f32)))
+void svst2q_vnum_f32(svbool_t, float32_t const *, int64_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_f16)))
+void svst2q_vnum_f16(svbool_t, float16_t const *, int64_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_s32)))
+void svst2q_vnum_s32(svbool_t, int32_t const *, int64_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_s64)))
+void svst2q_vnum_s64(svbool_t, int64_t const *, int64_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_s16)))
+void svst2q_vnum_s16(svbool_t, int16_t const *, int64_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_bf16)))
+void svst2q_vnum_bf16(svbool_t, bfloat16_t const *, int64_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_u8)))
+void svst3q_u8(svbool_t, uint8_t const *, svuint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_u32)))
+void svst3q_u32(svbool_t, uint32_t const *, svuint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_u64)))
+void svst3q_u64(svbool_t, uint64_t const *, svuint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_u16)))
+void svst3q_u16(svbool_t, uint16_t const *, svuint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_s8)))
+void svst3q_s8(svbool_t, int8_t const *, svint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_f64)))
+void svst3q_f64(svbool_t, float64_t const *, svfloat64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_f32)))
+void svst3q_f32(svbool_t, float32_t const *, svfloat32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_f16)))
+void svst3q_f16(svbool_t, float16_t const *, svfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_s32)))
+void svst3q_s32(svbool_t, int32_t const *, svint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_s64)))
+void svst3q_s64(svbool_t, int64_t const *, svint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_s16)))
+void svst3q_s16(svbool_t, int16_t const *, svint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_bf16)))
+void svst3q_bf16(svbool_t, bfloat16_t const *, svbfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_u8)))
+void svst3q_vnum_u8(svbool_t, uint8_t const *, int64_t, svuint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_u32)))
+void svst3q_vnum_u32(svbool_t, uint32_t const *, int64_t, svuint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_u64)))
+void svst3q_vnum_u64(svbool_t, uint64_t const *, int64_t, svuint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_u16)))
+void svst3q_vnum_u16(svbool_t, uint16_t const *, int64_t, svuint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_s8)))
+void svst3q_vnum_s8(svbool_t, int8_t const *, int64_t, svint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_f64)))
+void svst3q_vnum_f64(svbool_t, float64_t const *, int64_t, svfloat64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_f32)))
+void svst3q_vnum_f32(svbool_t, float32_t const *, int64_t, svfloat32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_f16)))
+void svst3q_vnum_f16(svbool_t, float16_t const *, int64_t, svfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_s32)))
+void svst3q_vnum_s32(svbool_t, int32_t const *, int64_t, svint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_s64)))
+void svst3q_vnum_s64(svbool_t, int64_t const *, int64_t, svint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_s16)))
+void svst3q_vnum_s16(svbool_t, int16_t const *, int64_t, svint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_bf16)))
+void svst3q_vnum_bf16(svbool_t, bfloat16_t const *, int64_t, svbfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_u8)))
+void svst4q_u8(svbool_t, uint8_t const *, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_u32)))
+void svst4q_u32(svbool_t, uint32_t const *, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_u64)))
+void svst4q_u64(svbool_t, uint64_t const *, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_u16)))
+void svst4q_u16(svbool_t, uint16_t const *, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_s8)))
+void svst4q_s8(svbool_t, int8_t const *, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_f64)))
+void svst4q_f64(svbool_t, float64_t const *, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_f32)))
+void svst4q_f32(svbool_t, float32_t const *, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_f16)))
+void svst4q_f16(svbool_t, float16_t const *, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_s32)))
+void svst4q_s32(svbool_t, int32_t const *, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_s64)))
+void svst4q_s64(svbool_t, int64_t const *, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_s16)))
+void svst4q_s16(svbool_t, int16_t const *, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_bf16)))
+void svst4q_bf16(svbool_t, bfloat16_t const *, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_u8)))
+void svst4q_vnum_u8(svbool_t, uint8_t const *, int64_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_u32)))
+void svst4q_vnum_u32(svbool_t, uint32_t const *, int64_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_u64)))
+void svst4q_vnum_u64(svbool_t, uint64_t const *, int64_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_u16)))
+void svst4q_vnum_u16(svbool_t, uint16_t const *, int64_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_s8)))
+void svst4q_vnum_s8(svbool_t, int8_t const *, int64_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_f64)))
+void svst4q_vnum_f64(svbool_t, float64_t const *, int64_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_f32)))
+void svst4q_vnum_f32(svbool_t, float32_t const *, int64_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_f16)))
+void svst4q_vnum_f16(svbool_t, float16_t const *, int64_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_s32)))
+void svst4q_vnum_s32(svbool_t, int32_t const *, int64_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_s64)))
+void svst4q_vnum_s64(svbool_t, int64_t const *, int64_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_s16)))
+void svst4q_vnum_s16(svbool_t, int16_t const *, int64_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_bf16)))
+void svst4q_vnum_bf16(svbool_t, bfloat16_t const *, int64_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_u8)))
+svuint8_t svtblq_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_u32)))
+svuint32_t svtblq_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_u64)))
+svuint64_t svtblq_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_u16)))
+svuint16_t svtblq_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_bf16)))
+svbfloat16_t svtblq_bf16(svbfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_s8)))
+svint8_t svtblq_s8(svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_f64)))
+svfloat64_t svtblq_f64(svfloat64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_f32)))
+svfloat32_t svtblq_f32(svfloat32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_f16)))
+svfloat16_t svtblq_f16(svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_s32)))
+svint32_t svtblq_s32(svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_s64)))
+svint64_t svtblq_s64(svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_s16)))
+svint16_t svtblq_s16(svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_u8)))
+svuint8_t svtbxq_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_u32)))
+svuint32_t svtbxq_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_u64)))
+svuint64_t svtbxq_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_u16)))
+svuint16_t svtbxq_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_bf16)))
+svbfloat16_t svtbxq_bf16(svbfloat16_t, svbfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_s8)))
+svint8_t svtbxq_s8(svint8_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_f64)))
+svfloat64_t svtbxq_f64(svfloat64_t, svfloat64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_f32)))
+svfloat32_t svtbxq_f32(svfloat32_t, svfloat32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_f16)))
+svfloat16_t svtbxq_f16(svfloat16_t, svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_s32)))
+svint32_t svtbxq_s32(svint32_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_s64)))
+svint64_t svtbxq_s64(svint64_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_s16)))
+svint16_t svtbxq_s16(svint16_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_u8)))
+svuint8_t svuzpq1_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_u32)))
+svuint32_t svuzpq1_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_u64)))
+svuint64_t svuzpq1_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_u16)))
+svuint16_t svuzpq1_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_bf16)))
+svbfloat16_t svuzpq1_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_s8)))
+svint8_t svuzpq1_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_f64)))
+svfloat64_t svuzpq1_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_f32)))
+svfloat32_t svuzpq1_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_f16)))
+svfloat16_t svuzpq1_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_s32)))
+svint32_t svuzpq1_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_s64)))
+svint64_t svuzpq1_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_s16)))
+svint16_t svuzpq1_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_u8)))
+svuint8_t svuzpq2_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_u32)))
+svuint32_t svuzpq2_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_u64)))
+svuint64_t svuzpq2_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_u16)))
+svuint16_t svuzpq2_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_bf16)))
+svbfloat16_t svuzpq2_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_s8)))
+svint8_t svuzpq2_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_f64)))
+svfloat64_t svuzpq2_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_f32)))
+svfloat32_t svuzpq2_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_f16)))
+svfloat16_t svuzpq2_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_s32)))
+svint32_t svuzpq2_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_s64)))
+svint64_t svuzpq2_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_s16)))
+svint16_t svuzpq2_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_u8)))
+svuint8_t svzipq1_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_u32)))
+svuint32_t svzipq1_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_u64)))
+svuint64_t svzipq1_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_u16)))
+svuint16_t svzipq1_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_bf16)))
+svbfloat16_t svzipq1_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_s8)))
+svint8_t svzipq1_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_f64)))
+svfloat64_t svzipq1_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_f32)))
+svfloat32_t svzipq1_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_f16)))
+svfloat16_t svzipq1_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_s32)))
+svint32_t svzipq1_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_s64)))
+svint64_t svzipq1_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_s16)))
+svint16_t svzipq1_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_u8)))
+svuint8_t svzipq2_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_u32)))
+svuint32_t svzipq2_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_u64)))
+svuint64_t svzipq2_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_u16)))
+svuint16_t svzipq2_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_bf16)))
+svbfloat16_t svzipq2_bf16(svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_s8)))
+svint8_t svzipq2_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_f64)))
+svfloat64_t svzipq2_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_f32)))
+svfloat32_t svzipq2_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_f16)))
+svfloat16_t svzipq2_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_s32)))
+svint32_t svzipq2_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_s64)))
+svint64_t svzipq2_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_s16)))
+svint16_t svzipq2_s16(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_u8)))
+uint8x16_t svaddqv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_u32)))
+uint32x4_t svaddqv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_u64)))
+uint64x2_t svaddqv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_u16)))
+uint16x8_t svaddqv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s8)))
+int8x16_t svaddqv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s32)))
+int32x4_t svaddqv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s64)))
+int64x2_t svaddqv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_s16)))
+int16x8_t svaddqv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f64)))
+float64x2_t svaddqv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f32)))
+float32x4_t svaddqv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddqv_f16)))
+float16x8_t svaddqv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u8)))
+uint8x16_t svandqv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u32)))
+uint32x4_t svandqv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u64)))
+uint64x2_t svandqv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_u16)))
+uint16x8_t svandqv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_s8)))
+int8x16_t svandqv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_s32)))
+int32x4_t svandqv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_s64)))
+int64x2_t svandqv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandqv_s16)))
+int16x8_t svandqv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_u8)))
+uint8x16_t sveorqv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_u32)))
+uint32x4_t sveorqv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_u64)))
+uint64x2_t sveorqv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_u16)))
+uint16x8_t sveorqv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_s8)))
+int8x16_t sveorqv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_s32)))
+int32x4_t sveorqv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_s64)))
+int64x2_t sveorqv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorqv_s16)))
+int16x8_t sveorqv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_u8)))
+svuint8_t svextq(svuint8_t, svuint8_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_u32)))
+svuint32_t svextq(svuint32_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_u64)))
+svuint64_t svextq(svuint64_t, svuint64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_u16)))
+svuint16_t svextq(svuint16_t, svuint16_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_bf16)))
+svbfloat16_t svextq(svbfloat16_t, svbfloat16_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_s8)))
+svint8_t svextq(svint8_t, svint8_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_f64)))
+svfloat64_t svextq(svfloat64_t, svfloat64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_f32)))
+svfloat32_t svextq(svfloat32_t, svfloat32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_f16)))
+svfloat16_t svextq(svfloat16_t, svfloat16_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_s32)))
+svint32_t svextq(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_s64)))
+svint64_t svextq(svint64_t, svint64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextq_s16)))
+svint16_t svextq(svint16_t, svint16_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_u32)))
+svuint32_t svld1q_gather_index_u32(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_u64)))
+svuint64_t svld1q_gather_index_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_u16)))
+svuint16_t svld1q_gather_index_u16(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_bf16)))
+svbfloat16_t svld1q_gather_index_bf16(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_f64)))
+svfloat64_t svld1q_gather_index_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_f32)))
+svfloat32_t svld1q_gather_index_f32(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_f16)))
+svfloat16_t svld1q_gather_index_f16(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_s32)))
+svint32_t svld1q_gather_index_s32(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_s64)))
+svint64_t svld1q_gather_index_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_index_s16)))
+svint16_t svld1q_gather_index_s16(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_u8)))
+svuint8_t svld1q_gather_offset_u8(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_u32)))
+svuint32_t svld1q_gather_offset_u32(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_u64)))
+svuint64_t svld1q_gather_offset_u64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_u16)))
+svuint16_t svld1q_gather_offset_u16(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_bf16)))
+svbfloat16_t svld1q_gather_offset_bf16(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_s8)))
+svint8_t svld1q_gather_offset_s8(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_f64)))
+svfloat64_t svld1q_gather_offset_f64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_f32)))
+svfloat32_t svld1q_gather_offset_f32(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_f16)))
+svfloat16_t svld1q_gather_offset_f16(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_s32)))
+svint32_t svld1q_gather_offset_s32(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_s64)))
+svint64_t svld1q_gather_offset_s64(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_offset_s16)))
+svint16_t svld1q_gather_offset_s16(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_u8)))
+svuint8_t svld1q_gather_u8(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_u32)))
+svuint32_t svld1q_gather_u32(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_u64)))
+svuint64_t svld1q_gather_u64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_u16)))
+svuint16_t svld1q_gather_u16(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_bf16)))
+svbfloat16_t svld1q_gather_bf16(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_s8)))
+svint8_t svld1q_gather_s8(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_f64)))
+svfloat64_t svld1q_gather_f64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_f32)))
+svfloat32_t svld1q_gather_f32(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_f16)))
+svfloat16_t svld1q_gather_f16(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_s32)))
+svint32_t svld1q_gather_s32(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_s64)))
+svint64_t svld1q_gather_s64(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64base_s16)))
+svint16_t svld1q_gather_s16(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_u32)))
+svuint32_t svld1q_gather_index(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_u64)))
+svuint64_t svld1q_gather_index(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_u16)))
+svuint16_t svld1q_gather_index(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_bf16)))
+svbfloat16_t svld1q_gather_index(svbool_t, bfloat16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_f64)))
+svfloat64_t svld1q_gather_index(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_f32)))
+svfloat32_t svld1q_gather_index(svbool_t, float32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_f16)))
+svfloat16_t svld1q_gather_index(svbool_t, float16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_s32)))
+svint32_t svld1q_gather_index(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_s64)))
+svint64_t svld1q_gather_index(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64index_s16)))
+svint16_t svld1q_gather_index(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_u8)))
+svuint8_t svld1q_gather_offset(svbool_t, uint8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_u32)))
+svuint32_t svld1q_gather_offset(svbool_t, uint32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_u64)))
+svuint64_t svld1q_gather_offset(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_u16)))
+svuint16_t svld1q_gather_offset(svbool_t, uint16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_bf16)))
+svbfloat16_t svld1q_gather_offset(svbool_t, bfloat16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_s8)))
+svint8_t svld1q_gather_offset(svbool_t, int8_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_f64)))
+svfloat64_t svld1q_gather_offset(svbool_t, float64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_f32)))
+svfloat32_t svld1q_gather_offset(svbool_t, float32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_f16)))
+svfloat16_t svld1q_gather_offset(svbool_t, float16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_s32)))
+svint32_t svld1q_gather_offset(svbool_t, int32_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_s64)))
+svint64_t svld1q_gather_offset(svbool_t, int64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1q_gather_u64offset_s16)))
+svint16_t svld1q_gather_offset(svbool_t, int16_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_u64)))
+svuint64_t svld1udq(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_f64)))
+svfloat64_t svld1udq(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_s64)))
+svint64_t svld1udq(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_vnum_u64)))
+svuint64_t svld1udq_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_vnum_f64)))
+svfloat64_t svld1udq_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1udq_vnum_s64)))
+svint64_t svld1udq_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_u32)))
+svuint32_t svld1uwq(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_f32)))
+svfloat32_t svld1uwq(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_s32)))
+svint32_t svld1uwq(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_vnum_u32)))
+svuint32_t svld1uwq_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_vnum_f32)))
+svfloat32_t svld1uwq_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uwq_vnum_s32)))
+svint32_t svld1uwq_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_u8)))
+svuint8x2_t svld2q(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_u32)))
+svuint32x2_t svld2q(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_u64)))
+svuint64x2_t svld2q(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_u16)))
+svuint16x2_t svld2q(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_s8)))
+svint8x2_t svld2q(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_f64)))
+svfloat64x2_t svld2q(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_f32)))
+svfloat32x2_t svld2q(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_f16)))
+svfloat16x2_t svld2q(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_s32)))
+svint32x2_t svld2q(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_s64)))
+svint64x2_t svld2q(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_s16)))
+svint16x2_t svld2q(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_bf16)))
+svbfloat16x2_t svld2q(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_u8)))
+svuint8x2_t svld2q_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_u32)))
+svuint32x2_t svld2q_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_u64)))
+svuint64x2_t svld2q_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_u16)))
+svuint16x2_t svld2q_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_s8)))
+svint8x2_t svld2q_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_f64)))
+svfloat64x2_t svld2q_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_f32)))
+svfloat32x2_t svld2q_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_f16)))
+svfloat16x2_t svld2q_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_s32)))
+svint32x2_t svld2q_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_s64)))
+svint64x2_t svld2q_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_s16)))
+svint16x2_t svld2q_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2q_vnum_bf16)))
+svbfloat16x2_t svld2q_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_u8)))
+svuint8x3_t svld3q(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_u32)))
+svuint32x3_t svld3q(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_u64)))
+svuint64x3_t svld3q(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_u16)))
+svuint16x3_t svld3q(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_s8)))
+svint8x3_t svld3q(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_f64)))
+svfloat64x3_t svld3q(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_f32)))
+svfloat32x3_t svld3q(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_f16)))
+svfloat16x3_t svld3q(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_s32)))
+svint32x3_t svld3q(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_s64)))
+svint64x3_t svld3q(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_s16)))
+svint16x3_t svld3q(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_bf16)))
+svbfloat16x3_t svld3q(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_u8)))
+svuint8x3_t svld3q_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_u32)))
+svuint32x3_t svld3q_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_u64)))
+svuint64x3_t svld3q_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_u16)))
+svuint16x3_t svld3q_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_s8)))
+svint8x3_t svld3q_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_f64)))
+svfloat64x3_t svld3q_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_f32)))
+svfloat32x3_t svld3q_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_f16)))
+svfloat16x3_t svld3q_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_s32)))
+svint32x3_t svld3q_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_s64)))
+svint64x3_t svld3q_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_s16)))
+svint16x3_t svld3q_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3q_vnum_bf16)))
+svbfloat16x3_t svld3q_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_u8)))
+svuint8x4_t svld4q(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_u32)))
+svuint32x4_t svld4q(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_u64)))
+svuint64x4_t svld4q(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_u16)))
+svuint16x4_t svld4q(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_s8)))
+svint8x4_t svld4q(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_f64)))
+svfloat64x4_t svld4q(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_f32)))
+svfloat32x4_t svld4q(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_f16)))
+svfloat16x4_t svld4q(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_s32)))
+svint32x4_t svld4q(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_s64)))
+svint64x4_t svld4q(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_s16)))
+svint16x4_t svld4q(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_bf16)))
+svbfloat16x4_t svld4q(svbool_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_u8)))
+svuint8x4_t svld4q_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_u32)))
+svuint32x4_t svld4q_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_u64)))
+svuint64x4_t svld4q_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_u16)))
+svuint16x4_t svld4q_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_s8)))
+svint8x4_t svld4q_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_f64)))
+svfloat64x4_t svld4q_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_f32)))
+svfloat32x4_t svld4q_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_f16)))
+svfloat16x4_t svld4q_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_s32)))
+svint32x4_t svld4q_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_s64)))
+svint64x4_t svld4q_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_s16)))
+svint16x4_t svld4q_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4q_vnum_bf16)))
+svbfloat16x4_t svld4q_vnum(svbool_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmqv_f64)))
+float64x2_t svmaxnmqv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmqv_f32)))
+float32x4_t svmaxnmqv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmqv_f16)))
+float16x8_t svmaxnmqv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_f64)))
+float64x2_t svmaxqv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_f32)))
+float32x4_t svmaxqv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_f16)))
+float16x8_t svmaxqv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_s8)))
+int8x16_t svmaxqv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_s32)))
+int32x4_t svmaxqv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_s64)))
+int64x2_t svmaxqv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_s16)))
+int16x8_t svmaxqv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_u8)))
+uint8x16_t svmaxqv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_u32)))
+uint32x4_t svmaxqv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_u64)))
+uint64x2_t svmaxqv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxqv_u16)))
+uint16x8_t svmaxqv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmqv_f64)))
+float64x2_t svminnmqv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmqv_f32)))
+float32x4_t svminnmqv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmqv_f16)))
+float16x8_t svminnmqv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_f64)))
+float64x2_t svminqv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_f32)))
+float32x4_t svminqv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_f16)))
+float16x8_t svminqv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_s8)))
+int8x16_t svminqv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_s32)))
+int32x4_t svminqv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_s64)))
+int64x2_t svminqv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_s16)))
+int16x8_t svminqv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_u8)))
+uint8x16_t svminqv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_u32)))
+uint32x4_t svminqv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_u64)))
+uint64x2_t svminqv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminqv_u16)))
+uint16x8_t svminqv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_u8)))
+uint8x16_t svorqv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_u32)))
+uint32x4_t svorqv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_u64)))
+uint64x2_t svorqv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_u16)))
+uint16x8_t svorqv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_s8)))
+int8x16_t svorqv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_s32)))
+int32x4_t svorqv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_s64)))
+int64x2_t svorqv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorqv_s16)))
+int16x8_t svorqv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u8)))
+svbool_t svpmov(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s8)))
+svbool_t svpmov(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u64)))
+svbool_t svpmov(svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s64)))
+svbool_t svpmov(svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u16)))
+svbool_t svpmov(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s16)))
+svbool_t svpmov(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_u32)))
+svbool_t svpmov(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_s32)))
+svbool_t svpmov(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u8)))
+svbool_t svpmov_lane(svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s8)))
+svbool_t svpmov_lane(svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u64)))
+svbool_t svpmov_lane(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s64)))
+svbool_t svpmov_lane(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u16)))
+svbool_t svpmov_lane(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s16)))
+svbool_t svpmov_lane(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u32)))
+svbool_t svpmov_lane(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s32)))
+svbool_t svpmov_lane(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u64_m)))
+svuint64_t svpmov_lane_m(svuint64_t, svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s64_m)))
+svint64_t svpmov_lane_m(svint64_t, svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u16_m)))
+svuint16_t svpmov_lane_m(svuint16_t, svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s16_m)))
+svint16_t svpmov_lane_m(svint16_t, svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_u32_m)))
+svuint32_t svpmov_lane_m(svuint32_t, svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmov_lane_s32_m)))
+svint32_t svpmov_lane_m(svint32_t, svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_u64)))
+void svst1dq(svbool_t, uint64_t const *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_f64)))
+void svst1dq(svbool_t, float64_t const *, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_s64)))
+void svst1dq(svbool_t, int64_t const *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_vnum_u64)))
+void svst1dq_vnum(svbool_t, uint64_t const *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_vnum_f64)))
+void svst1dq_vnum(svbool_t, float64_t const *, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1dq_vnum_s64)))
+void svst1dq_vnum(svbool_t, int64_t const *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_u8)))
+void svst1q_scatter(svbool_t, svuint64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_u32)))
+void svst1q_scatter(svbool_t, svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_u64)))
+void svst1q_scatter(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_u16)))
+void svst1q_scatter(svbool_t, svuint64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_bf16)))
+void svst1q_scatter(svbool_t, svuint64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_s8)))
+void svst1q_scatter(svbool_t, svuint64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_f64)))
+void svst1q_scatter(svbool_t, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_f32)))
+void svst1q_scatter(svbool_t, svuint64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_f16)))
+void svst1q_scatter(svbool_t, svuint64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_s32)))
+void svst1q_scatter(svbool_t, svuint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_s64)))
+void svst1q_scatter(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_s16)))
+void svst1q_scatter(svbool_t, svuint64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_u32)))
+void svst1q_scatter_index(svbool_t, svuint64_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_u64)))
+void svst1q_scatter_index(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_u16)))
+void svst1q_scatter_index(svbool_t, svuint64_t, int64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_bf16)))
+void svst1q_scatter_index(svbool_t, svuint64_t, int64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_f64)))
+void svst1q_scatter_index(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_f32)))
+void svst1q_scatter_index(svbool_t, svuint64_t, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_f16)))
+void svst1q_scatter_index(svbool_t, svuint64_t, int64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_s32)))
+void svst1q_scatter_index(svbool_t, svuint64_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_s64)))
+void svst1q_scatter_index(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_index_s16)))
+void svst1q_scatter_index(svbool_t, svuint64_t, int64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_u8)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_u32)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_u64)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_u16)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_bf16)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_s8)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_f64)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_f32)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_f16)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_s32)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_s64)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64base_offset_s16)))
+void svst1q_scatter_offset(svbool_t, svuint64_t, int64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_u32)))
+void svst1q_scatter_index(svbool_t, uint32_t *, svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_u64)))
+void svst1q_scatter_index(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_u16)))
+void svst1q_scatter_index(svbool_t, uint16_t *, svuint64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_bf16)))
+void svst1q_scatter_index(svbool_t, bfloat16_t *, svuint64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_f64)))
+void svst1q_scatter_index(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_f32)))
+void svst1q_scatter_index(svbool_t, float32_t *, svuint64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_f16)))
+void svst1q_scatter_index(svbool_t, float16_t *, svuint64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_s32)))
+void svst1q_scatter_index(svbool_t, int32_t *, svuint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_s64)))
+void svst1q_scatter_index(svbool_t, int64_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64index_s16)))
+void svst1q_scatter_index(svbool_t, int16_t *, svuint64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_u8)))
+void svst1q_scatter_offset(svbool_t, uint8_t *, svuint64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_u32)))
+void svst1q_scatter_offset(svbool_t, uint32_t *, svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_u64)))
+void svst1q_scatter_offset(svbool_t, uint64_t *, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_u16)))
+void svst1q_scatter_offset(svbool_t, uint16_t *, svuint64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_bf16)))
+void svst1q_scatter_offset(svbool_t, bfloat16_t *, svuint64_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_s8)))
+void svst1q_scatter_offset(svbool_t, int8_t *, svuint64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_f64)))
+void svst1q_scatter_offset(svbool_t, float64_t *, svuint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_f32)))
+void svst1q_scatter_offset(svbool_t, float32_t *, svuint64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_f16)))
+void svst1q_scatter_offset(svbool_t, float16_t *, svuint64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_s32)))
+void svst1q_scatter_offset(svbool_t, int32_t *, svuint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_s64)))
+void svst1q_scatter_offset(svbool_t, int64_t *, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1q_scatter_u64offset_s16)))
+void svst1q_scatter_offset(svbool_t, int16_t *, svuint64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_u32)))
+void svst1wq(svbool_t, uint32_t const *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_f32)))
+void svst1wq(svbool_t, float32_t const *, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_s32)))
+void svst1wq(svbool_t, int32_t const *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_vnum_u32)))
+void svst1wq_vnum(svbool_t, uint32_t const *, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_vnum_f32)))
+void svst1wq_vnum(svbool_t, float32_t const *, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1wq_vnum_s32)))
+void svst1wq_vnum(svbool_t, int32_t const *, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_u8)))
+void svst2q(svbool_t, uint8_t const *, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_u32)))
+void svst2q(svbool_t, uint32_t const *, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_u64)))
+void svst2q(svbool_t, uint64_t const *, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_u16)))
+void svst2q(svbool_t, uint16_t const *, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_s8)))
+void svst2q(svbool_t, int8_t const *, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_f64)))
+void svst2q(svbool_t, float64_t const *, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_f32)))
+void svst2q(svbool_t, float32_t const *, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_f16)))
+void svst2q(svbool_t, float16_t const *, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_s32)))
+void svst2q(svbool_t, int32_t const *, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_s64)))
+void svst2q(svbool_t, int64_t const *, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_s16)))
+void svst2q(svbool_t, int16_t const *, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_bf16)))
+void svst2q(svbool_t, bfloat16_t const *, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_u8)))
+void svst2q_vnum(svbool_t, uint8_t const *, int64_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_u32)))
+void svst2q_vnum(svbool_t, uint32_t const *, int64_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_u64)))
+void svst2q_vnum(svbool_t, uint64_t const *, int64_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_u16)))
+void svst2q_vnum(svbool_t, uint16_t const *, int64_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_s8)))
+void svst2q_vnum(svbool_t, int8_t const *, int64_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_f64)))
+void svst2q_vnum(svbool_t, float64_t const *, int64_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_f32)))
+void svst2q_vnum(svbool_t, float32_t const *, int64_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_f16)))
+void svst2q_vnum(svbool_t, float16_t const *, int64_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_s32)))
+void svst2q_vnum(svbool_t, int32_t const *, int64_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_s64)))
+void svst2q_vnum(svbool_t, int64_t const *, int64_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_s16)))
+void svst2q_vnum(svbool_t, int16_t const *, int64_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2q_vnum_bf16)))
+void svst2q_vnum(svbool_t, bfloat16_t const *, int64_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_u8)))
+void svst3q(svbool_t, uint8_t const *, svuint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_u32)))
+void svst3q(svbool_t, uint32_t const *, svuint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_u64)))
+void svst3q(svbool_t, uint64_t const *, svuint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_u16)))
+void svst3q(svbool_t, uint16_t const *, svuint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_s8)))
+void svst3q(svbool_t, int8_t const *, svint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_f64)))
+void svst3q(svbool_t, float64_t const *, svfloat64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_f32)))
+void svst3q(svbool_t, float32_t const *, svfloat32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_f16)))
+void svst3q(svbool_t, float16_t const *, svfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_s32)))
+void svst3q(svbool_t, int32_t const *, svint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_s64)))
+void svst3q(svbool_t, int64_t const *, svint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_s16)))
+void svst3q(svbool_t, int16_t const *, svint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_bf16)))
+void svst3q(svbool_t, bfloat16_t const *, svbfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_u8)))
+void svst3q_vnum(svbool_t, uint8_t const *, int64_t, svuint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_u32)))
+void svst3q_vnum(svbool_t, uint32_t const *, int64_t, svuint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_u64)))
+void svst3q_vnum(svbool_t, uint64_t const *, int64_t, svuint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_u16)))
+void svst3q_vnum(svbool_t, uint16_t const *, int64_t, svuint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_s8)))
+void svst3q_vnum(svbool_t, int8_t const *, int64_t, svint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_f64)))
+void svst3q_vnum(svbool_t, float64_t const *, int64_t, svfloat64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_f32)))
+void svst3q_vnum(svbool_t, float32_t const *, int64_t, svfloat32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_f16)))
+void svst3q_vnum(svbool_t, float16_t const *, int64_t, svfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_s32)))
+void svst3q_vnum(svbool_t, int32_t const *, int64_t, svint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_s64)))
+void svst3q_vnum(svbool_t, int64_t const *, int64_t, svint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_s16)))
+void svst3q_vnum(svbool_t, int16_t const *, int64_t, svint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3q_vnum_bf16)))
+void svst3q_vnum(svbool_t, bfloat16_t const *, int64_t, svbfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_u8)))
+void svst4q(svbool_t, uint8_t const *, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_u32)))
+void svst4q(svbool_t, uint32_t const *, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_u64)))
+void svst4q(svbool_t, uint64_t const *, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_u16)))
+void svst4q(svbool_t, uint16_t const *, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_s8)))
+void svst4q(svbool_t, int8_t const *, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_f64)))
+void svst4q(svbool_t, float64_t const *, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_f32)))
+void svst4q(svbool_t, float32_t const *, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_f16)))
+void svst4q(svbool_t, float16_t const *, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_s32)))
+void svst4q(svbool_t, int32_t const *, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_s64)))
+void svst4q(svbool_t, int64_t const *, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_s16)))
+void svst4q(svbool_t, int16_t const *, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_bf16)))
+void svst4q(svbool_t, bfloat16_t const *, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_u8)))
+void svst4q_vnum(svbool_t, uint8_t const *, int64_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_u32)))
+void svst4q_vnum(svbool_t, uint32_t const *, int64_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_u64)))
+void svst4q_vnum(svbool_t, uint64_t const *, int64_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_u16)))
+void svst4q_vnum(svbool_t, uint16_t const *, int64_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_s8)))
+void svst4q_vnum(svbool_t, int8_t const *, int64_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_f64)))
+void svst4q_vnum(svbool_t, float64_t const *, int64_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_f32)))
+void svst4q_vnum(svbool_t, float32_t const *, int64_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_f16)))
+void svst4q_vnum(svbool_t, float16_t const *, int64_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_s32)))
+void svst4q_vnum(svbool_t, int32_t const *, int64_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_s64)))
+void svst4q_vnum(svbool_t, int64_t const *, int64_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_s16)))
+void svst4q_vnum(svbool_t, int16_t const *, int64_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4q_vnum_bf16)))
+void svst4q_vnum(svbool_t, bfloat16_t const *, int64_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_u8)))
+svuint8_t svtblq(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_u32)))
+svuint32_t svtblq(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_u64)))
+svuint64_t svtblq(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_u16)))
+svuint16_t svtblq(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_bf16)))
+svbfloat16_t svtblq(svbfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_s8)))
+svint8_t svtblq(svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_f64)))
+svfloat64_t svtblq(svfloat64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_f32)))
+svfloat32_t svtblq(svfloat32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_f16)))
+svfloat16_t svtblq(svfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_s32)))
+svint32_t svtblq(svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_s64)))
+svint64_t svtblq(svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtblq_s16)))
+svint16_t svtblq(svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_u8)))
+svuint8_t svtbxq(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_u32)))
+svuint32_t svtbxq(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_u64)))
+svuint64_t svtbxq(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_u16)))
+svuint16_t svtbxq(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_bf16)))
+svbfloat16_t svtbxq(svbfloat16_t, svbfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_s8)))
+svint8_t svtbxq(svint8_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_f64)))
+svfloat64_t svtbxq(svfloat64_t, svfloat64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_f32)))
+svfloat32_t svtbxq(svfloat32_t, svfloat32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_f16)))
+svfloat16_t svtbxq(svfloat16_t, svfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_s32)))
+svint32_t svtbxq(svint32_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_s64)))
+svint64_t svtbxq(svint64_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbxq_s16)))
+svint16_t svtbxq(svint16_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_u8)))
+svuint8_t svuzpq1(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_u32)))
+svuint32_t svuzpq1(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_u64)))
+svuint64_t svuzpq1(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_u16)))
+svuint16_t svuzpq1(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_bf16)))
+svbfloat16_t svuzpq1(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_s8)))
+svint8_t svuzpq1(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_f64)))
+svfloat64_t svuzpq1(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_f32)))
+svfloat32_t svuzpq1(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_f16)))
+svfloat16_t svuzpq1(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_s32)))
+svint32_t svuzpq1(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_s64)))
+svint64_t svuzpq1(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq1_s16)))
+svint16_t svuzpq1(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_u8)))
+svuint8_t svuzpq2(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_u32)))
+svuint32_t svuzpq2(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_u64)))
+svuint64_t svuzpq2(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_u16)))
+svuint16_t svuzpq2(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_bf16)))
+svbfloat16_t svuzpq2(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_s8)))
+svint8_t svuzpq2(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_f64)))
+svfloat64_t svuzpq2(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_f32)))
+svfloat32_t svuzpq2(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_f16)))
+svfloat16_t svuzpq2(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_s32)))
+svint32_t svuzpq2(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_s64)))
+svint64_t svuzpq2(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzpq2_s16)))
+svint16_t svuzpq2(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_u8)))
+svuint8_t svzipq1(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_u32)))
+svuint32_t svzipq1(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_u64)))
+svuint64_t svzipq1(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_u16)))
+svuint16_t svzipq1(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_bf16)))
+svbfloat16_t svzipq1(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_s8)))
+svint8_t svzipq1(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_f64)))
+svfloat64_t svzipq1(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_f32)))
+svfloat32_t svzipq1(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_f16)))
+svfloat16_t svzipq1(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_s32)))
+svint32_t svzipq1(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_s64)))
+svint64_t svzipq1(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq1_s16)))
+svint16_t svzipq1(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_u8)))
+svuint8_t svzipq2(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_u32)))
+svuint32_t svzipq2(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_u64)))
+svuint64_t svzipq2(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_u16)))
+svuint16_t svzipq2(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_bf16)))
+svbfloat16_t svzipq2(svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_s8)))
+svint8_t svzipq2(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_f64)))
+svfloat64_t svzipq2(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_f32)))
+svfloat32_t svzipq2(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_f16)))
+svfloat16_t svzipq2(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_s32)))
+svint32_t svzipq2(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_s64)))
+svint64_t svzipq2(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzipq2_s16)))
+svint16_t svzipq2(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_bf16)))
+svbfloat16_t svdup_laneq_bf16(svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_bf16)))
+svbfloat16_t svdup_laneq(svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s8)))
+svint8_t svclamp_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s32)))
+svint32_t svclamp_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s64)))
+svint64_t svclamp_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s16)))
+svint16_t svclamp_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u8)))
+svuint8_t svclamp_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u32)))
+svuint32_t svclamp_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u64)))
+svuint64_t svclamp_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u16)))
+svuint16_t svclamp_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_b16)))
+svbool_t svpsel_lane_b16(svbool_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_b32)))
+svbool_t svpsel_lane_b32(svbool_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_b64)))
+svbool_t svpsel_lane_b64(svbool_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_b8)))
+svbool_t svpsel_lane_b8(svbool_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_m)))
+svuint8_t svrevd_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_m)))
+svuint32_t svrevd_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_m)))
+svuint64_t svrevd_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_m)))
+svuint16_t svrevd_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_m)))
+svbfloat16_t svrevd_bf16_m(svbfloat16_t, svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_m)))
+svint8_t svrevd_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_m)))
+svfloat64_t svrevd_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_m)))
+svfloat32_t svrevd_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_m)))
+svfloat16_t svrevd_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_m)))
+svint32_t svrevd_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_m)))
+svint64_t svrevd_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_m)))
+svint16_t svrevd_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_x)))
+svuint8_t svrevd_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_x)))
+svuint32_t svrevd_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_x)))
+svuint64_t svrevd_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_x)))
+svuint16_t svrevd_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_x)))
+svbfloat16_t svrevd_bf16_x(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_x)))
+svint8_t svrevd_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_x)))
+svfloat64_t svrevd_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_x)))
+svfloat32_t svrevd_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_x)))
+svfloat16_t svrevd_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_x)))
+svint32_t svrevd_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_x)))
+svint64_t svrevd_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_x)))
+svint16_t svrevd_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_z)))
+svuint8_t svrevd_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_z)))
+svuint32_t svrevd_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_z)))
+svuint64_t svrevd_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_z)))
+svuint16_t svrevd_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_z)))
+svbfloat16_t svrevd_bf16_z(svbool_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_z)))
+svint8_t svrevd_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_z)))
+svfloat64_t svrevd_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_z)))
+svfloat32_t svrevd_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_z)))
+svfloat16_t svrevd_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_z)))
+svint32_t svrevd_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_z)))
+svint64_t svrevd_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_z)))
+svint16_t svrevd_s16_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s8)))
+svint8_t svclamp(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s32)))
+svint32_t svclamp(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s64)))
+svint64_t svclamp(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_s16)))
+svint16_t svclamp(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u8)))
+svuint8_t svclamp(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u32)))
+svuint32_t svclamp(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u64)))
+svuint64_t svclamp(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_u16)))
+svuint16_t svclamp(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_m)))
+svuint8_t svrevd_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_m)))
+svuint32_t svrevd_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_m)))
+svuint64_t svrevd_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_m)))
+svuint16_t svrevd_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_m)))
+svbfloat16_t svrevd_m(svbfloat16_t, svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_m)))
+svint8_t svrevd_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_m)))
+svfloat64_t svrevd_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_m)))
+svfloat32_t svrevd_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_m)))
+svfloat16_t svrevd_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_m)))
+svint32_t svrevd_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_m)))
+svint64_t svrevd_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_m)))
+svint16_t svrevd_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_x)))
+svuint8_t svrevd_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_x)))
+svuint32_t svrevd_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_x)))
+svuint64_t svrevd_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_x)))
+svuint16_t svrevd_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_x)))
+svbfloat16_t svrevd_x(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_x)))
+svint8_t svrevd_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_x)))
+svfloat64_t svrevd_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_x)))
+svfloat32_t svrevd_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_x)))
+svfloat16_t svrevd_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_x)))
+svint32_t svrevd_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_x)))
+svint64_t svrevd_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_x)))
+svint16_t svrevd_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u8_z)))
+svuint8_t svrevd_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u32_z)))
+svuint32_t svrevd_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u64_z)))
+svuint64_t svrevd_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_u16_z)))
+svuint16_t svrevd_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_bf16_z)))
+svbfloat16_t svrevd_z(svbool_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s8_z)))
+svint8_t svrevd_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f64_z)))
+svfloat64_t svrevd_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f32_z)))
+svfloat32_t svrevd_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_f16_z)))
+svfloat16_t svrevd_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s32_z)))
+svint32_t svrevd_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s64_z)))
+svint64_t svrevd_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevd_s16_z)))
+svint16_t svrevd_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlslb_f32)))
+svfloat32_t svbfmlslb_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlslb_lane_f32)))
+svfloat32_t svbfmlslb_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlslt_f32)))
+svfloat32_t svbfmlslt_f32(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlslt_lane_f32)))
+svfloat32_t svbfmlslt_lane_f32(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_f64)))
+svfloat64_t svclamp_f64(svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_f32)))
+svfloat32_t svclamp_f32(svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_f16)))
+svfloat16_t svclamp_f16(svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_c8)))
+uint64_t svcntp_c8(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_c32)))
+uint64_t svcntp_c32(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_c64)))
+uint64_t svcntp_c64(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_c16)))
+uint64_t svcntp_c16(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_b)))
+svboolx2_t svcreate2_b(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_b)))
+svboolx4_t svcreate4_b(svbool_t, svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_f32_f16)))
+svfloat32_t svdot_f32_f16(svfloat32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s32_s16)))
+svint32_t svdot_s32_s16(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u32_u16)))
+svuint32_t svdot_u32_u16(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_f32_f16)))
+svfloat32_t svdot_lane_f32_f16(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s32_s16)))
+svint32_t svdot_lane_s32_s16(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u32_u16)))
+svuint32_t svdot_lane_u32_u16(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_b)))
+svbool_t svget2_b(svboolx2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_b)))
+svbool_t svget4_b(svboolx4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u8_x2)))
+svuint8x2_t svld1_u8_x2(svcount_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s8_x2)))
+svint8x2_t svld1_s8_x2(svcount_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u64_x2)))
+svuint64x2_t svld1_u64_x2(svcount_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f64_x2)))
+svfloat64x2_t svld1_f64_x2(svcount_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s64_x2)))
+svint64x2_t svld1_s64_x2(svcount_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u16_x2)))
+svuint16x2_t svld1_u16_x2(svcount_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_bf16_x2)))
+svbfloat16x2_t svld1_bf16_x2(svcount_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f16_x2)))
+svfloat16x2_t svld1_f16_x2(svcount_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s16_x2)))
+svint16x2_t svld1_s16_x2(svcount_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u32_x2)))
+svuint32x2_t svld1_u32_x2(svcount_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f32_x2)))
+svfloat32x2_t svld1_f32_x2(svcount_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s32_x2)))
+svint32x2_t svld1_s32_x2(svcount_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u8_x4)))
+svuint8x4_t svld1_u8_x4(svcount_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s8_x4)))
+svint8x4_t svld1_s8_x4(svcount_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u64_x4)))
+svuint64x4_t svld1_u64_x4(svcount_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f64_x4)))
+svfloat64x4_t svld1_f64_x4(svcount_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s64_x4)))
+svint64x4_t svld1_s64_x4(svcount_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u16_x4)))
+svuint16x4_t svld1_u16_x4(svcount_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_bf16_x4)))
+svbfloat16x4_t svld1_bf16_x4(svcount_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f16_x4)))
+svfloat16x4_t svld1_f16_x4(svcount_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s16_x4)))
+svint16x4_t svld1_s16_x4(svcount_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u32_x4)))
+svuint32x4_t svld1_u32_x4(svcount_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f32_x4)))
+svfloat32x4_t svld1_f32_x4(svcount_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s32_x4)))
+svint32x4_t svld1_s32_x4(svcount_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u8_x2)))
+svuint8x2_t svld1_vnum_u8_x2(svcount_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s8_x2)))
+svint8x2_t svld1_vnum_s8_x2(svcount_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u64_x2)))
+svuint64x2_t svld1_vnum_u64_x2(svcount_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f64_x2)))
+svfloat64x2_t svld1_vnum_f64_x2(svcount_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s64_x2)))
+svint64x2_t svld1_vnum_s64_x2(svcount_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u16_x2)))
+svuint16x2_t svld1_vnum_u16_x2(svcount_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_bf16_x2)))
+svbfloat16x2_t svld1_vnum_bf16_x2(svcount_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f16_x2)))
+svfloat16x2_t svld1_vnum_f16_x2(svcount_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s16_x2)))
+svint16x2_t svld1_vnum_s16_x2(svcount_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u32_x2)))
+svuint32x2_t svld1_vnum_u32_x2(svcount_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f32_x2)))
+svfloat32x2_t svld1_vnum_f32_x2(svcount_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s32_x2)))
+svint32x2_t svld1_vnum_s32_x2(svcount_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u8_x4)))
+svuint8x4_t svld1_vnum_u8_x4(svcount_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s8_x4)))
+svint8x4_t svld1_vnum_s8_x4(svcount_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u64_x4)))
+svuint64x4_t svld1_vnum_u64_x4(svcount_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f64_x4)))
+svfloat64x4_t svld1_vnum_f64_x4(svcount_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s64_x4)))
+svint64x4_t svld1_vnum_s64_x4(svcount_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u16_x4)))
+svuint16x4_t svld1_vnum_u16_x4(svcount_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_bf16_x4)))
+svbfloat16x4_t svld1_vnum_bf16_x4(svcount_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f16_x4)))
+svfloat16x4_t svld1_vnum_f16_x4(svcount_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s16_x4)))
+svint16x4_t svld1_vnum_s16_x4(svcount_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u32_x4)))
+svuint32x4_t svld1_vnum_u32_x4(svcount_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f32_x4)))
+svfloat32x4_t svld1_vnum_f32_x4(svcount_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s32_x4)))
+svint32x4_t svld1_vnum_s32_x4(svcount_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u8_x2)))
+svuint8x2_t svldnt1_u8_x2(svcount_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s8_x2)))
+svint8x2_t svldnt1_s8_x2(svcount_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u64_x2)))
+svuint64x2_t svldnt1_u64_x2(svcount_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f64_x2)))
+svfloat64x2_t svldnt1_f64_x2(svcount_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s64_x2)))
+svint64x2_t svldnt1_s64_x2(svcount_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u16_x2)))
+svuint16x2_t svldnt1_u16_x2(svcount_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_bf16_x2)))
+svbfloat16x2_t svldnt1_bf16_x2(svcount_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f16_x2)))
+svfloat16x2_t svldnt1_f16_x2(svcount_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s16_x2)))
+svint16x2_t svldnt1_s16_x2(svcount_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u32_x2)))
+svuint32x2_t svldnt1_u32_x2(svcount_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f32_x2)))
+svfloat32x2_t svldnt1_f32_x2(svcount_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s32_x2)))
+svint32x2_t svldnt1_s32_x2(svcount_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u8_x4)))
+svuint8x4_t svldnt1_u8_x4(svcount_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s8_x4)))
+svint8x4_t svldnt1_s8_x4(svcount_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u64_x4)))
+svuint64x4_t svldnt1_u64_x4(svcount_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f64_x4)))
+svfloat64x4_t svldnt1_f64_x4(svcount_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s64_x4)))
+svint64x4_t svldnt1_s64_x4(svcount_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u16_x4)))
+svuint16x4_t svldnt1_u16_x4(svcount_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_bf16_x4)))
+svbfloat16x4_t svldnt1_bf16_x4(svcount_t, bfloat16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f16_x4)))
+svfloat16x4_t svldnt1_f16_x4(svcount_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s16_x4)))
+svint16x4_t svldnt1_s16_x4(svcount_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u32_x4)))
+svuint32x4_t svldnt1_u32_x4(svcount_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f32_x4)))
+svfloat32x4_t svldnt1_f32_x4(svcount_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s32_x4)))
+svint32x4_t svldnt1_s32_x4(svcount_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u8_x2)))
+svuint8x2_t svldnt1_vnum_u8_x2(svcount_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s8_x2)))
+svint8x2_t svldnt1_vnum_s8_x2(svcount_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u64_x2)))
+svuint64x2_t svldnt1_vnum_u64_x2(svcount_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f64_x2)))
+svfloat64x2_t svldnt1_vnum_f64_x2(svcount_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s64_x2)))
+svint64x2_t svldnt1_vnum_s64_x2(svcount_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u16_x2)))
+svuint16x2_t svldnt1_vnum_u16_x2(svcount_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_bf16_x2)))
+svbfloat16x2_t svldnt1_vnum_bf16_x2(svcount_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f16_x2)))
+svfloat16x2_t svldnt1_vnum_f16_x2(svcount_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s16_x2)))
+svint16x2_t svldnt1_vnum_s16_x2(svcount_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u32_x2)))
+svuint32x2_t svldnt1_vnum_u32_x2(svcount_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32_x2)))
+svfloat32x2_t svldnt1_vnum_f32_x2(svcount_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32_x2)))
+svint32x2_t svldnt1_vnum_s32_x2(svcount_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u8_x4)))
+svuint8x4_t svldnt1_vnum_u8_x4(svcount_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s8_x4)))
+svint8x4_t svldnt1_vnum_s8_x4(svcount_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u64_x4)))
+svuint64x4_t svldnt1_vnum_u64_x4(svcount_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f64_x4)))
+svfloat64x4_t svldnt1_vnum_f64_x4(svcount_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s64_x4)))
+svint64x4_t svldnt1_vnum_s64_x4(svcount_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u16_x4)))
+svuint16x4_t svldnt1_vnum_u16_x4(svcount_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_bf16_x4)))
+svbfloat16x4_t svldnt1_vnum_bf16_x4(svcount_t, bfloat16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f16_x4)))
+svfloat16x4_t svldnt1_vnum_f16_x4(svcount_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s16_x4)))
+svint16x4_t svldnt1_vnum_s16_x4(svcount_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u32_x4)))
+svuint32x4_t svldnt1_vnum_u32_x4(svcount_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32_x4)))
+svfloat32x4_t svldnt1_vnum_f32_x4(svcount_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32_x4)))
+svint32x4_t svldnt1_vnum_s32_x4(svcount_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpext_lane_c8)))
+svbool_t svpext_lane_c8(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpext_lane_c32)))
+svbool_t svpext_lane_c32(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpext_lane_c64)))
+svbool_t svpext_lane_c64(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpext_lane_c16)))
+svbool_t svpext_lane_c16(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpext_lane_c8_x2)))
+svboolx2_t svpext_lane_c8_x2(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpext_lane_c32_x2)))
+svboolx2_t svpext_lane_c32_x2(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpext_lane_c64_x2)))
+svboolx2_t svpext_lane_c64_x2(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpext_lane_c16_x2)))
+svboolx2_t svpext_lane_c16_x2(svcount_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfalse_c)))
+svcount_t svpfalse_c(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_c16)))
+svcount_t svpsel_lane_c16(svcount_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_c32)))
+svcount_t svpsel_lane_c32(svcount_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_c64)))
+svcount_t svpsel_lane_c64(svcount_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpsel_lane_c8)))
+svcount_t svpsel_lane_c8(svcount_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_c8)))
+svcount_t svptrue_c8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_c32)))
+svcount_t svptrue_c32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_c64)))
+svcount_t svptrue_c64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_c16)))
+svcount_t svptrue_c16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s32_x2)))
+svint16_t svqcvtn_s16_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s32_x2)))
+svuint16_t svqcvtn_u16_s32_x2(svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u32_x2)))
+svuint16_t svqcvtn_u16_u32_x2(svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s16_s32_x2)))
+svint16_t svqrshrn_n_s16_s32_x2(svint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u16_u32_x2)))
+svuint16_t svqrshrn_n_u16_u32_x2(svuint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u16_s32_x2)))
+svuint16_t svqrshrun_n_u16_s32_x2(svint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_b)))
+svbool_t svreinterpret_b(svcount_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_c)))
+svcount_t svreinterpret_c(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_b)))
+svboolx2_t svset2_b(svboolx2_t, uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_b)))
+svboolx4_t svset4_b(svboolx4_t, uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u8_x2)))
+void svst1_u8_x2(svcount_t, uint8_t *, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s8_x2)))
+void svst1_s8_x2(svcount_t, int8_t *, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u64_x2)))
+void svst1_u64_x2(svcount_t, uint64_t *, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f64_x2)))
+void svst1_f64_x2(svcount_t, float64_t *, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s64_x2)))
+void svst1_s64_x2(svcount_t, int64_t *, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u16_x2)))
+void svst1_u16_x2(svcount_t, uint16_t *, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_bf16_x2)))
+void svst1_bf16_x2(svcount_t, bfloat16_t *, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16_x2)))
+void svst1_f16_x2(svcount_t, float16_t *, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s16_x2)))
+void svst1_s16_x2(svcount_t, int16_t *, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u32_x2)))
+void svst1_u32_x2(svcount_t, uint32_t *, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f32_x2)))
+void svst1_f32_x2(svcount_t, float32_t *, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s32_x2)))
+void svst1_s32_x2(svcount_t, int32_t *, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u8_x4)))
+void svst1_u8_x4(svcount_t, uint8_t *, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s8_x4)))
+void svst1_s8_x4(svcount_t, int8_t *, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u64_x4)))
+void svst1_u64_x4(svcount_t, uint64_t *, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f64_x4)))
+void svst1_f64_x4(svcount_t, float64_t *, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s64_x4)))
+void svst1_s64_x4(svcount_t, int64_t *, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u16_x4)))
+void svst1_u16_x4(svcount_t, uint16_t *, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_bf16_x4)))
+void svst1_bf16_x4(svcount_t, bfloat16_t *, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16_x4)))
+void svst1_f16_x4(svcount_t, float16_t *, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s16_x4)))
+void svst1_s16_x4(svcount_t, int16_t *, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u32_x4)))
+void svst1_u32_x4(svcount_t, uint32_t *, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f32_x4)))
+void svst1_f32_x4(svcount_t, float32_t *, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s32_x4)))
+void svst1_s32_x4(svcount_t, int32_t *, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u8_x2)))
+void svst1_vnum_u8_x2(svcount_t, uint8_t *, int64_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s8_x2)))
+void svst1_vnum_s8_x2(svcount_t, int8_t *, int64_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u64_x2)))
+void svst1_vnum_u64_x2(svcount_t, uint64_t *, int64_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f64_x2)))
+void svst1_vnum_f64_x2(svcount_t, float64_t *, int64_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s64_x2)))
+void svst1_vnum_s64_x2(svcount_t, int64_t *, int64_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u16_x2)))
+void svst1_vnum_u16_x2(svcount_t, uint16_t *, int64_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_bf16_x2)))
+void svst1_vnum_bf16_x2(svcount_t, bfloat16_t *, int64_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f16_x2)))
+void svst1_vnum_f16_x2(svcount_t, float16_t *, int64_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s16_x2)))
+void svst1_vnum_s16_x2(svcount_t, int16_t *, int64_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u32_x2)))
+void svst1_vnum_u32_x2(svcount_t, uint32_t *, int64_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f32_x2)))
+void svst1_vnum_f32_x2(svcount_t, float32_t *, int64_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s32_x2)))
+void svst1_vnum_s32_x2(svcount_t, int32_t *, int64_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u8_x4)))
+void svst1_vnum_u8_x4(svcount_t, uint8_t *, int64_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s8_x4)))
+void svst1_vnum_s8_x4(svcount_t, int8_t *, int64_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u64_x4)))
+void svst1_vnum_u64_x4(svcount_t, uint64_t *, int64_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f64_x4)))
+void svst1_vnum_f64_x4(svcount_t, float64_t *, int64_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s64_x4)))
+void svst1_vnum_s64_x4(svcount_t, int64_t *, int64_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u16_x4)))
+void svst1_vnum_u16_x4(svcount_t, uint16_t *, int64_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_bf16_x4)))
+void svst1_vnum_bf16_x4(svcount_t, bfloat16_t *, int64_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f16_x4)))
+void svst1_vnum_f16_x4(svcount_t, float16_t *, int64_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s16_x4)))
+void svst1_vnum_s16_x4(svcount_t, int16_t *, int64_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u32_x4)))
+void svst1_vnum_u32_x4(svcount_t, uint32_t *, int64_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f32_x4)))
+void svst1_vnum_f32_x4(svcount_t, float32_t *, int64_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s32_x4)))
+void svst1_vnum_s32_x4(svcount_t, int32_t *, int64_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u8_x2)))
+void svstnt1_u8_x2(svcount_t, uint8_t *, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s8_x2)))
+void svstnt1_s8_x2(svcount_t, int8_t *, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u64_x2)))
+void svstnt1_u64_x2(svcount_t, uint64_t *, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f64_x2)))
+void svstnt1_f64_x2(svcount_t, float64_t *, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s64_x2)))
+void svstnt1_s64_x2(svcount_t, int64_t *, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u16_x2)))
+void svstnt1_u16_x2(svcount_t, uint16_t *, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_bf16_x2)))
+void svstnt1_bf16_x2(svcount_t, bfloat16_t *, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f16_x2)))
+void svstnt1_f16_x2(svcount_t, float16_t *, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s16_x2)))
+void svstnt1_s16_x2(svcount_t, int16_t *, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u32_x2)))
+void svstnt1_u32_x2(svcount_t, uint32_t *, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f32_x2)))
+void svstnt1_f32_x2(svcount_t, float32_t *, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s32_x2)))
+void svstnt1_s32_x2(svcount_t, int32_t *, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u8_x4)))
+void svstnt1_u8_x4(svcount_t, uint8_t *, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s8_x4)))
+void svstnt1_s8_x4(svcount_t, int8_t *, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u64_x4)))
+void svstnt1_u64_x4(svcount_t, uint64_t *, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f64_x4)))
+void svstnt1_f64_x4(svcount_t, float64_t *, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s64_x4)))
+void svstnt1_s64_x4(svcount_t, int64_t *, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u16_x4)))
+void svstnt1_u16_x4(svcount_t, uint16_t *, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_bf16_x4)))
+void svstnt1_bf16_x4(svcount_t, bfloat16_t *, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f16_x4)))
+void svstnt1_f16_x4(svcount_t, float16_t *, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s16_x4)))
+void svstnt1_s16_x4(svcount_t, int16_t *, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u32_x4)))
+void svstnt1_u32_x4(svcount_t, uint32_t *, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f32_x4)))
+void svstnt1_f32_x4(svcount_t, float32_t *, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s32_x4)))
+void svstnt1_s32_x4(svcount_t, int32_t *, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u8_x2)))
+void svstnt1_vnum_u8_x2(svcount_t, uint8_t *, int64_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s8_x2)))
+void svstnt1_vnum_s8_x2(svcount_t, int8_t *, int64_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u64_x2)))
+void svstnt1_vnum_u64_x2(svcount_t, uint64_t *, int64_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f64_x2)))
+void svstnt1_vnum_f64_x2(svcount_t, float64_t *, int64_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s64_x2)))
+void svstnt1_vnum_s64_x2(svcount_t, int64_t *, int64_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u16_x2)))
+void svstnt1_vnum_u16_x2(svcount_t, uint16_t *, int64_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_bf16_x2)))
+void svstnt1_vnum_bf16_x2(svcount_t, bfloat16_t *, int64_t, svbfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f16_x2)))
+void svstnt1_vnum_f16_x2(svcount_t, float16_t *, int64_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s16_x2)))
+void svstnt1_vnum_s16_x2(svcount_t, int16_t *, int64_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u32_x2)))
+void svstnt1_vnum_u32_x2(svcount_t, uint32_t *, int64_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f32_x2)))
+void svstnt1_vnum_f32_x2(svcount_t, float32_t *, int64_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s32_x2)))
+void svstnt1_vnum_s32_x2(svcount_t, int32_t *, int64_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u8_x4)))
+void svstnt1_vnum_u8_x4(svcount_t, uint8_t *, int64_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s8_x4)))
+void svstnt1_vnum_s8_x4(svcount_t, int8_t *, int64_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u64_x4)))
+void svstnt1_vnum_u64_x4(svcount_t, uint64_t *, int64_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f64_x4)))
+void svstnt1_vnum_f64_x4(svcount_t, float64_t *, int64_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s64_x4)))
+void svstnt1_vnum_s64_x4(svcount_t, int64_t *, int64_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u16_x4)))
+void svstnt1_vnum_u16_x4(svcount_t, uint16_t *, int64_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_bf16_x4)))
+void svstnt1_vnum_bf16_x4(svcount_t, bfloat16_t *, int64_t, svbfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f16_x4)))
+void svstnt1_vnum_f16_x4(svcount_t, float16_t *, int64_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s16_x4)))
+void svstnt1_vnum_s16_x4(svcount_t, int16_t *, int64_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u32_x4)))
+void svstnt1_vnum_u32_x4(svcount_t, uint32_t *, int64_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f32_x4)))
+void svstnt1_vnum_f32_x4(svcount_t, float32_t *, int64_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s32_x4)))
+void svstnt1_vnum_s32_x4(svcount_t, int32_t *, int64_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_b)))
+svboolx2_t svundef2_b();
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_b)))
+svboolx4_t svundef4_b();
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c8_s64)))
+svcount_t svwhilege_c8_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c32_s64)))
+svcount_t svwhilege_c32_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c64_s64)))
+svcount_t svwhilege_c64_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c16_s64)))
+svcount_t svwhilege_c16_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c8_u64)))
+svcount_t svwhilege_c8_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c32_u64)))
+svcount_t svwhilege_c32_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c64_u64)))
+svcount_t svwhilege_c64_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c16_u64)))
+svcount_t svwhilege_c16_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s64_x2)))
+svboolx2_t svwhilege_b8_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s64_x2)))
+svboolx2_t svwhilege_b32_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s64_x2)))
+svboolx2_t svwhilege_b64_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s64_x2)))
+svboolx2_t svwhilege_b16_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u64_x2)))
+svboolx2_t svwhilege_b8_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u64_x2)))
+svboolx2_t svwhilege_b32_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u64_x2)))
+svboolx2_t svwhilege_b64_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u64_x2)))
+svboolx2_t svwhilege_b16_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c8_s64)))
+svcount_t svwhilegt_c8_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c32_s64)))
+svcount_t svwhilegt_c32_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c64_s64)))
+svcount_t svwhilegt_c64_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c16_s64)))
+svcount_t svwhilegt_c16_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c8_u64)))
+svcount_t svwhilegt_c8_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c32_u64)))
+svcount_t svwhilegt_c32_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c64_u64)))
+svcount_t svwhilegt_c64_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c16_u64)))
+svcount_t svwhilegt_c16_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s64_x2)))
+svboolx2_t svwhilegt_b8_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s64_x2)))
+svboolx2_t svwhilegt_b32_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s64_x2)))
+svboolx2_t svwhilegt_b64_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s64_x2)))
+svboolx2_t svwhilegt_b16_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u64_x2)))
+svboolx2_t svwhilegt_b8_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u64_x2)))
+svboolx2_t svwhilegt_b32_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u64_x2)))
+svboolx2_t svwhilegt_b64_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u64_x2)))
+svboolx2_t svwhilegt_b16_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c8_s64)))
+svcount_t svwhilele_c8_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c32_s64)))
+svcount_t svwhilele_c32_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c64_s64)))
+svcount_t svwhilele_c64_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c16_s64)))
+svcount_t svwhilele_c16_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c8_u64)))
+svcount_t svwhilele_c8_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c32_u64)))
+svcount_t svwhilele_c32_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c64_u64)))
+svcount_t svwhilele_c64_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c16_u64)))
+svcount_t svwhilele_c16_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s64_x2)))
+svboolx2_t svwhilele_b8_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s64_x2)))
+svboolx2_t svwhilele_b32_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s64_x2)))
+svboolx2_t svwhilele_b64_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s64_x2)))
+svboolx2_t svwhilele_b16_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u64_x2)))
+svboolx2_t svwhilele_b8_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u64_x2)))
+svboolx2_t svwhilele_b32_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u64_x2)))
+svboolx2_t svwhilele_b64_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u64_x2)))
+svboolx2_t svwhilele_b16_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c8_u64)))
+svcount_t svwhilelt_c8_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c32_u64)))
+svcount_t svwhilelt_c32_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c64_u64)))
+svcount_t svwhilelt_c64_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c16_u64)))
+svcount_t svwhilelt_c16_u64(uint64_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c8_s64)))
+svcount_t svwhilelt_c8_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c32_s64)))
+svcount_t svwhilelt_c32_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c64_s64)))
+svcount_t svwhilelt_c64_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c16_s64)))
+svcount_t svwhilelt_c16_s64(int64_t, int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u64_x2)))
+svboolx2_t svwhilelt_b8_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u64_x2)))
+svboolx2_t svwhilelt_b32_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u64_x2)))
+svboolx2_t svwhilelt_b64_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u64_x2)))
+svboolx2_t svwhilelt_b16_u64_x2(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s64_x2)))
+svboolx2_t svwhilelt_b8_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s64_x2)))
+svboolx2_t svwhilelt_b32_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s64_x2)))
+svboolx2_t svwhilelt_b64_s64_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s64_x2)))
+svboolx2_t svwhilelt_b16_s64_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlslb_f32)))
+svfloat32_t svbfmlslb(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlslb_lane_f32)))
+svfloat32_t svbfmlslb_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlslt_f32)))
+svfloat32_t svbfmlslt(svfloat32_t, svbfloat16_t, svbfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbfmlslt_lane_f32)))
+svfloat32_t svbfmlslt_lane(svfloat32_t, svbfloat16_t, svbfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_f64)))
+svfloat64_t svclamp(svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_f32)))
+svfloat32_t svclamp(svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclamp_f16)))
+svfloat16_t svclamp(svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_b)))
+svboolx2_t svcreate2(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_b)))
+svboolx4_t svcreate4(svbool_t, svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_f32_f16)))
+svfloat32_t svdot(svfloat32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s32_s16)))
+svint32_t svdot(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u32_u16)))
+svuint32_t svdot(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_f32_f16)))
+svfloat32_t svdot_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s32_s16)))
+svint32_t svdot_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u32_u16)))
+svuint32_t svdot_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_b)))
+svbool_t svget2(svboolx2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_b)))
+svbool_t svget4(svboolx4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u8_x2)))
+svuint8x2_t svld1_x2(svcount_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s8_x2)))
+svint8x2_t svld1_x2(svcount_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u64_x2)))
+svuint64x2_t svld1_x2(svcount_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f64_x2)))
+svfloat64x2_t svld1_x2(svcount_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s64_x2)))
+svint64x2_t svld1_x2(svcount_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u16_x2)))
+svuint16x2_t svld1_x2(svcount_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_bf16_x2)))
+svbfloat16x2_t svld1_x2(svcount_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f16_x2)))
+svfloat16x2_t svld1_x2(svcount_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s16_x2)))
+svint16x2_t svld1_x2(svcount_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u32_x2)))
+svuint32x2_t svld1_x2(svcount_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f32_x2)))
+svfloat32x2_t svld1_x2(svcount_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s32_x2)))
+svint32x2_t svld1_x2(svcount_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u8_x4)))
+svuint8x4_t svld1_x4(svcount_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s8_x4)))
+svint8x4_t svld1_x4(svcount_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u64_x4)))
+svuint64x4_t svld1_x4(svcount_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f64_x4)))
+svfloat64x4_t svld1_x4(svcount_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s64_x4)))
+svint64x4_t svld1_x4(svcount_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u16_x4)))
+svuint16x4_t svld1_x4(svcount_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_bf16_x4)))
+svbfloat16x4_t svld1_x4(svcount_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f16_x4)))
+svfloat16x4_t svld1_x4(svcount_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s16_x4)))
+svint16x4_t svld1_x4(svcount_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u32_x4)))
+svuint32x4_t svld1_x4(svcount_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f32_x4)))
+svfloat32x4_t svld1_x4(svcount_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s32_x4)))
+svint32x4_t svld1_x4(svcount_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u8_x2)))
+svuint8x2_t svld1_vnum_x2(svcount_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s8_x2)))
+svint8x2_t svld1_vnum_x2(svcount_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u64_x2)))
+svuint64x2_t svld1_vnum_x2(svcount_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f64_x2)))
+svfloat64x2_t svld1_vnum_x2(svcount_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s64_x2)))
+svint64x2_t svld1_vnum_x2(svcount_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u16_x2)))
+svuint16x2_t svld1_vnum_x2(svcount_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_bf16_x2)))
+svbfloat16x2_t svld1_vnum_x2(svcount_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f16_x2)))
+svfloat16x2_t svld1_vnum_x2(svcount_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s16_x2)))
+svint16x2_t svld1_vnum_x2(svcount_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u32_x2)))
+svuint32x2_t svld1_vnum_x2(svcount_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f32_x2)))
+svfloat32x2_t svld1_vnum_x2(svcount_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s32_x2)))
+svint32x2_t svld1_vnum_x2(svcount_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u8_x4)))
+svuint8x4_t svld1_vnum_x4(svcount_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s8_x4)))
+svint8x4_t svld1_vnum_x4(svcount_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u64_x4)))
+svuint64x4_t svld1_vnum_x4(svcount_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f64_x4)))
+svfloat64x4_t svld1_vnum_x4(svcount_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s64_x4)))
+svint64x4_t svld1_vnum_x4(svcount_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u16_x4)))
+svuint16x4_t svld1_vnum_x4(svcount_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_bf16_x4)))
+svbfloat16x4_t svld1_vnum_x4(svcount_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f16_x4)))
+svfloat16x4_t svld1_vnum_x4(svcount_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s16_x4)))
+svint16x4_t svld1_vnum_x4(svcount_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u32_x4)))
+svuint32x4_t svld1_vnum_x4(svcount_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f32_x4)))
+svfloat32x4_t svld1_vnum_x4(svcount_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s32_x4)))
+svint32x4_t svld1_vnum_x4(svcount_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u8_x2)))
+svuint8x2_t svldnt1_x2(svcount_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s8_x2)))
+svint8x2_t svldnt1_x2(svcount_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u64_x2)))
+svuint64x2_t svldnt1_x2(svcount_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f64_x2)))
+svfloat64x2_t svldnt1_x2(svcount_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s64_x2)))
+svint64x2_t svldnt1_x2(svcount_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u16_x2)))
+svuint16x2_t svldnt1_x2(svcount_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_bf16_x2)))
+svbfloat16x2_t svldnt1_x2(svcount_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f16_x2)))
+svfloat16x2_t svldnt1_x2(svcount_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s16_x2)))
+svint16x2_t svldnt1_x2(svcount_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u32_x2)))
+svuint32x2_t svldnt1_x2(svcount_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f32_x2)))
+svfloat32x2_t svldnt1_x2(svcount_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s32_x2)))
+svint32x2_t svldnt1_x2(svcount_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u8_x4)))
+svuint8x4_t svldnt1_x4(svcount_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s8_x4)))
+svint8x4_t svldnt1_x4(svcount_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u64_x4)))
+svuint64x4_t svldnt1_x4(svcount_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f64_x4)))
+svfloat64x4_t svldnt1_x4(svcount_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s64_x4)))
+svint64x4_t svldnt1_x4(svcount_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u16_x4)))
+svuint16x4_t svldnt1_x4(svcount_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_bf16_x4)))
+svbfloat16x4_t svldnt1_x4(svcount_t, bfloat16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f16_x4)))
+svfloat16x4_t svldnt1_x4(svcount_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s16_x4)))
+svint16x4_t svldnt1_x4(svcount_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u32_x4)))
+svuint32x4_t svldnt1_x4(svcount_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f32_x4)))
+svfloat32x4_t svldnt1_x4(svcount_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s32_x4)))
+svint32x4_t svldnt1_x4(svcount_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u8_x2)))
+svuint8x2_t svldnt1_vnum_x2(svcount_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s8_x2)))
+svint8x2_t svldnt1_vnum_x2(svcount_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u64_x2)))
+svuint64x2_t svldnt1_vnum_x2(svcount_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f64_x2)))
+svfloat64x2_t svldnt1_vnum_x2(svcount_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s64_x2)))
+svint64x2_t svldnt1_vnum_x2(svcount_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u16_x2)))
+svuint16x2_t svldnt1_vnum_x2(svcount_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_bf16_x2)))
+svbfloat16x2_t svldnt1_vnum_x2(svcount_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f16_x2)))
+svfloat16x2_t svldnt1_vnum_x2(svcount_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s16_x2)))
+svint16x2_t svldnt1_vnum_x2(svcount_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u32_x2)))
+svuint32x2_t svldnt1_vnum_x2(svcount_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32_x2)))
+svfloat32x2_t svldnt1_vnum_x2(svcount_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32_x2)))
+svint32x2_t svldnt1_vnum_x2(svcount_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u8_x4)))
+svuint8x4_t svldnt1_vnum_x4(svcount_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s8_x4)))
+svint8x4_t svldnt1_vnum_x4(svcount_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u64_x4)))
+svuint64x4_t svldnt1_vnum_x4(svcount_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f64_x4)))
+svfloat64x4_t svldnt1_vnum_x4(svcount_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s64_x4)))
+svint64x4_t svldnt1_vnum_x4(svcount_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u16_x4)))
+svuint16x4_t svldnt1_vnum_x4(svcount_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_bf16_x4)))
+svbfloat16x4_t svldnt1_vnum_x4(svcount_t, bfloat16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f16_x4)))
+svfloat16x4_t svldnt1_vnum_x4(svcount_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s16_x4)))
+svint16x4_t svldnt1_vnum_x4(svcount_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u32_x4)))
+svuint32x4_t svldnt1_vnum_x4(svcount_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32_x4)))
+svfloat32x4_t svldnt1_vnum_x4(svcount_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32_x4)))
+svint32x4_t svldnt1_vnum_x4(svcount_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_s16_s32_x2)))
+svint16_t svqcvtn_s16(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_s32_x2)))
+svuint16_t svqcvtn_u16(svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcvtn_u16_u32_x2)))
+svuint16_t svqcvtn_u16(svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_s16_s32_x2)))
+svint16_t svqrshrn_s16(svint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrn_n_u16_u32_x2)))
+svuint16_t svqrshrn_u16(svuint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrun_n_u16_s32_x2)))
+svuint16_t svqrshrun_u16(svint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_b)))
+svbool_t svreinterpret(svcount_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svreinterpret_c)))
+svcount_t svreinterpret(svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_b)))
+svboolx2_t svset2(svboolx2_t, uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_b)))
+svboolx4_t svset4(svboolx4_t, uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u8_x2)))
+void svst1(svcount_t, uint8_t *, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s8_x2)))
+void svst1(svcount_t, int8_t *, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u64_x2)))
+void svst1(svcount_t, uint64_t *, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f64_x2)))
+void svst1(svcount_t, float64_t *, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s64_x2)))
+void svst1(svcount_t, int64_t *, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u16_x2)))
+void svst1(svcount_t, uint16_t *, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_bf16_x2)))
+void svst1(svcount_t, bfloat16_t *, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16_x2)))
+void svst1(svcount_t, float16_t *, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s16_x2)))
+void svst1(svcount_t, int16_t *, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u32_x2)))
+void svst1(svcount_t, uint32_t *, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f32_x2)))
+void svst1(svcount_t, float32_t *, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s32_x2)))
+void svst1(svcount_t, int32_t *, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u8_x4)))
+void svst1(svcount_t, uint8_t *, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s8_x4)))
+void svst1(svcount_t, int8_t *, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u64_x4)))
+void svst1(svcount_t, uint64_t *, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f64_x4)))
+void svst1(svcount_t, float64_t *, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s64_x4)))
+void svst1(svcount_t, int64_t *, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u16_x4)))
+void svst1(svcount_t, uint16_t *, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_bf16_x4)))
+void svst1(svcount_t, bfloat16_t *, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16_x4)))
+void svst1(svcount_t, float16_t *, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s16_x4)))
+void svst1(svcount_t, int16_t *, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u32_x4)))
+void svst1(svcount_t, uint32_t *, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f32_x4)))
+void svst1(svcount_t, float32_t *, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s32_x4)))
+void svst1(svcount_t, int32_t *, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u8_x2)))
+void svst1_vnum(svcount_t, uint8_t *, int64_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s8_x2)))
+void svst1_vnum(svcount_t, int8_t *, int64_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u64_x2)))
+void svst1_vnum(svcount_t, uint64_t *, int64_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f64_x2)))
+void svst1_vnum(svcount_t, float64_t *, int64_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s64_x2)))
+void svst1_vnum(svcount_t, int64_t *, int64_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u16_x2)))
+void svst1_vnum(svcount_t, uint16_t *, int64_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_bf16_x2)))
+void svst1_vnum(svcount_t, bfloat16_t *, int64_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f16_x2)))
+void svst1_vnum(svcount_t, float16_t *, int64_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s16_x2)))
+void svst1_vnum(svcount_t, int16_t *, int64_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u32_x2)))
+void svst1_vnum(svcount_t, uint32_t *, int64_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f32_x2)))
+void svst1_vnum(svcount_t, float32_t *, int64_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s32_x2)))
+void svst1_vnum(svcount_t, int32_t *, int64_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u8_x4)))
+void svst1_vnum(svcount_t, uint8_t *, int64_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s8_x4)))
+void svst1_vnum(svcount_t, int8_t *, int64_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u64_x4)))
+void svst1_vnum(svcount_t, uint64_t *, int64_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f64_x4)))
+void svst1_vnum(svcount_t, float64_t *, int64_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s64_x4)))
+void svst1_vnum(svcount_t, int64_t *, int64_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u16_x4)))
+void svst1_vnum(svcount_t, uint16_t *, int64_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_bf16_x4)))
+void svst1_vnum(svcount_t, bfloat16_t *, int64_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f16_x4)))
+void svst1_vnum(svcount_t, float16_t *, int64_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s16_x4)))
+void svst1_vnum(svcount_t, int16_t *, int64_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u32_x4)))
+void svst1_vnum(svcount_t, uint32_t *, int64_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f32_x4)))
+void svst1_vnum(svcount_t, float32_t *, int64_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s32_x4)))
+void svst1_vnum(svcount_t, int32_t *, int64_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u8_x2)))
+void svstnt1(svcount_t, uint8_t *, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s8_x2)))
+void svstnt1(svcount_t, int8_t *, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u64_x2)))
+void svstnt1(svcount_t, uint64_t *, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f64_x2)))
+void svstnt1(svcount_t, float64_t *, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s64_x2)))
+void svstnt1(svcount_t, int64_t *, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u16_x2)))
+void svstnt1(svcount_t, uint16_t *, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_bf16_x2)))
+void svstnt1(svcount_t, bfloat16_t *, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f16_x2)))
+void svstnt1(svcount_t, float16_t *, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s16_x2)))
+void svstnt1(svcount_t, int16_t *, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u32_x2)))
+void svstnt1(svcount_t, uint32_t *, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f32_x2)))
+void svstnt1(svcount_t, float32_t *, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s32_x2)))
+void svstnt1(svcount_t, int32_t *, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u8_x4)))
+void svstnt1(svcount_t, uint8_t *, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s8_x4)))
+void svstnt1(svcount_t, int8_t *, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u64_x4)))
+void svstnt1(svcount_t, uint64_t *, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f64_x4)))
+void svstnt1(svcount_t, float64_t *, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s64_x4)))
+void svstnt1(svcount_t, int64_t *, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u16_x4)))
+void svstnt1(svcount_t, uint16_t *, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_bf16_x4)))
+void svstnt1(svcount_t, bfloat16_t *, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f16_x4)))
+void svstnt1(svcount_t, float16_t *, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s16_x4)))
+void svstnt1(svcount_t, int16_t *, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u32_x4)))
+void svstnt1(svcount_t, uint32_t *, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f32_x4)))
+void svstnt1(svcount_t, float32_t *, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s32_x4)))
+void svstnt1(svcount_t, int32_t *, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u8_x2)))
+void svstnt1_vnum(svcount_t, uint8_t *, int64_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s8_x2)))
+void svstnt1_vnum(svcount_t, int8_t *, int64_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u64_x2)))
+void svstnt1_vnum(svcount_t, uint64_t *, int64_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f64_x2)))
+void svstnt1_vnum(svcount_t, float64_t *, int64_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s64_x2)))
+void svstnt1_vnum(svcount_t, int64_t *, int64_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u16_x2)))
+void svstnt1_vnum(svcount_t, uint16_t *, int64_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_bf16_x2)))
+void svstnt1_vnum(svcount_t, bfloat16_t *, int64_t, svbfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f16_x2)))
+void svstnt1_vnum(svcount_t, float16_t *, int64_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s16_x2)))
+void svstnt1_vnum(svcount_t, int16_t *, int64_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u32_x2)))
+void svstnt1_vnum(svcount_t, uint32_t *, int64_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f32_x2)))
+void svstnt1_vnum(svcount_t, float32_t *, int64_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s32_x2)))
+void svstnt1_vnum(svcount_t, int32_t *, int64_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u8_x4)))
+void svstnt1_vnum(svcount_t, uint8_t *, int64_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s8_x4)))
+void svstnt1_vnum(svcount_t, int8_t *, int64_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u64_x4)))
+void svstnt1_vnum(svcount_t, uint64_t *, int64_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f64_x4)))
+void svstnt1_vnum(svcount_t, float64_t *, int64_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s64_x4)))
+void svstnt1_vnum(svcount_t, int64_t *, int64_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u16_x4)))
+void svstnt1_vnum(svcount_t, uint16_t *, int64_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_bf16_x4)))
+void svstnt1_vnum(svcount_t, bfloat16_t *, int64_t, svbfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f16_x4)))
+void svstnt1_vnum(svcount_t, float16_t *, int64_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s16_x4)))
+void svstnt1_vnum(svcount_t, int16_t *, int64_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u32_x4)))
+void svstnt1_vnum(svcount_t, uint32_t *, int64_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f32_x4)))
+void svstnt1_vnum(svcount_t, float32_t *, int64_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s32_x4)))
+void svstnt1_vnum(svcount_t, int32_t *, int64_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c8_s64)))
+svcount_t svwhilege_c8(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c32_s64)))
+svcount_t svwhilege_c32(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c64_s64)))
+svcount_t svwhilege_c64(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c16_s64)))
+svcount_t svwhilege_c16(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c8_u64)))
+svcount_t svwhilege_c8(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c32_u64)))
+svcount_t svwhilege_c32(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c64_u64)))
+svcount_t svwhilege_c64(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_c16_u64)))
+svcount_t svwhilege_c16(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s64_x2)))
+svboolx2_t svwhilege_b8_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s64_x2)))
+svboolx2_t svwhilege_b32_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s64_x2)))
+svboolx2_t svwhilege_b64_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s64_x2)))
+svboolx2_t svwhilege_b16_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u64_x2)))
+svboolx2_t svwhilege_b8_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u64_x2)))
+svboolx2_t svwhilege_b32_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u64_x2)))
+svboolx2_t svwhilege_b64_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u64_x2)))
+svboolx2_t svwhilege_b16_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c8_s64)))
+svcount_t svwhilegt_c8(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c32_s64)))
+svcount_t svwhilegt_c32(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c64_s64)))
+svcount_t svwhilegt_c64(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c16_s64)))
+svcount_t svwhilegt_c16(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c8_u64)))
+svcount_t svwhilegt_c8(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c32_u64)))
+svcount_t svwhilegt_c32(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c64_u64)))
+svcount_t svwhilegt_c64(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_c16_u64)))
+svcount_t svwhilegt_c16(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s64_x2)))
+svboolx2_t svwhilegt_b8_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s64_x2)))
+svboolx2_t svwhilegt_b32_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s64_x2)))
+svboolx2_t svwhilegt_b64_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s64_x2)))
+svboolx2_t svwhilegt_b16_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u64_x2)))
+svboolx2_t svwhilegt_b8_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u64_x2)))
+svboolx2_t svwhilegt_b32_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u64_x2)))
+svboolx2_t svwhilegt_b64_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u64_x2)))
+svboolx2_t svwhilegt_b16_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c8_s64)))
+svcount_t svwhilele_c8(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c32_s64)))
+svcount_t svwhilele_c32(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c64_s64)))
+svcount_t svwhilele_c64(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c16_s64)))
+svcount_t svwhilele_c16(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c8_u64)))
+svcount_t svwhilele_c8(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c32_u64)))
+svcount_t svwhilele_c32(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c64_u64)))
+svcount_t svwhilele_c64(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_c16_u64)))
+svcount_t svwhilele_c16(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s64_x2)))
+svboolx2_t svwhilele_b8_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s64_x2)))
+svboolx2_t svwhilele_b32_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s64_x2)))
+svboolx2_t svwhilele_b64_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s64_x2)))
+svboolx2_t svwhilele_b16_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u64_x2)))
+svboolx2_t svwhilele_b8_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u64_x2)))
+svboolx2_t svwhilele_b32_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u64_x2)))
+svboolx2_t svwhilele_b64_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u64_x2)))
+svboolx2_t svwhilele_b16_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c8_u64)))
+svcount_t svwhilelt_c8(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c32_u64)))
+svcount_t svwhilelt_c32(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c64_u64)))
+svcount_t svwhilelt_c64(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c16_u64)))
+svcount_t svwhilelt_c16(uint64_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c8_s64)))
+svcount_t svwhilelt_c8(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c32_s64)))
+svcount_t svwhilelt_c32(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c64_s64)))
+svcount_t svwhilelt_c64(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_c16_s64)))
+svcount_t svwhilelt_c16(int64_t, int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u64_x2)))
+svboolx2_t svwhilelt_b8_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u64_x2)))
+svboolx2_t svwhilelt_b32_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u64_x2)))
+svboolx2_t svwhilelt_b64_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u64_x2)))
+svboolx2_t svwhilelt_b16_x2(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s64_x2)))
+svboolx2_t svwhilelt_b8_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s64_x2)))
+svboolx2_t svwhilelt_b32_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s64_x2)))
+svboolx2_t svwhilelt_b64_x2(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s64_x2)))
+svboolx2_t svwhilelt_b16_x2(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u8)))
+svuint8_t svdup_laneq_u8(svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s8)))
+svint8_t svdup_laneq_s8(svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u64)))
+svuint64_t svdup_laneq_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f64)))
+svfloat64_t svdup_laneq_f64(svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s64)))
+svint64_t svdup_laneq_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u16)))
+svuint16_t svdup_laneq_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f16)))
+svfloat16_t svdup_laneq_f16(svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s16)))
+svint16_t svdup_laneq_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u32)))
+svuint32_t svdup_laneq_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f32)))
+svfloat32_t svdup_laneq_f32(svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s32)))
+svint32_t svdup_laneq_s32(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u8)))
+svuint8_t svdup_laneq(svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s8)))
+svint8_t svdup_laneq(svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u64)))
+svuint64_t svdup_laneq(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f64)))
+svfloat64_t svdup_laneq(svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s64)))
+svint64_t svdup_laneq(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u16)))
+svuint16_t svdup_laneq(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f16)))
+svfloat16_t svdup_laneq(svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s16)))
+svint16_t svdup_laneq(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_u32)))
+svuint32_t svdup_laneq(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_f32)))
+svfloat32_t svdup_laneq(svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_laneq_s32)))
+svint32_t svdup_laneq(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s8)))
+svint8_t svaba_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s32)))
+svint32_t svaba_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s64)))
+svint64_t svaba_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s16)))
+svint16_t svaba_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u8)))
+svuint8_t svaba_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u32)))
+svuint32_t svaba_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u64)))
+svuint64_t svaba_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u16)))
+svuint16_t svaba_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s8)))
+svint8_t svaba_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s32)))
+svint32_t svaba_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s64)))
+svint64_t svaba_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s16)))
+svint16_t svaba_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u8)))
+svuint8_t svaba_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u32)))
+svuint32_t svaba_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u64)))
+svuint64_t svaba_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u16)))
+svuint16_t svaba_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s32)))
+svint32_t svabalb_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s64)))
+svint64_t svabalb_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s16)))
+svint16_t svabalb_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u32)))
+svuint32_t svabalb_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u64)))
+svuint64_t svabalb_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u16)))
+svuint16_t svabalb_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s32)))
+svint32_t svabalb_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s64)))
+svint64_t svabalb_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s16)))
+svint16_t svabalb_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u32)))
+svuint32_t svabalb_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u64)))
+svuint64_t svabalb_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u16)))
+svuint16_t svabalb_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s32)))
+svint32_t svabalt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s64)))
+svint64_t svabalt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s16)))
+svint16_t svabalt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u32)))
+svuint32_t svabalt_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u64)))
+svuint64_t svabalt_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u16)))
+svuint16_t svabalt_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s32)))
+svint32_t svabalt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s64)))
+svint64_t svabalt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s16)))
+svint16_t svabalt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u32)))
+svuint32_t svabalt_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u64)))
+svuint64_t svabalt_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u16)))
+svuint16_t svabalt_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s32)))
+svint32_t svabdlb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s64)))
+svint64_t svabdlb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s16)))
+svint16_t svabdlb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u32)))
+svuint32_t svabdlb_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u64)))
+svuint64_t svabdlb_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u16)))
+svuint16_t svabdlb_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s32)))
+svint32_t svabdlb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s64)))
+svint64_t svabdlb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s16)))
+svint16_t svabdlb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u32)))
+svuint32_t svabdlb_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u64)))
+svuint64_t svabdlb_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u16)))
+svuint16_t svabdlb_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s32)))
+svint32_t svabdlt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s64)))
+svint64_t svabdlt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s16)))
+svint16_t svabdlt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u32)))
+svuint32_t svabdlt_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u64)))
+svuint64_t svabdlt_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u16)))
+svuint16_t svabdlt_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s32)))
+svint32_t svabdlt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s64)))
+svint64_t svabdlt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s16)))
+svint16_t svabdlt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u32)))
+svuint32_t svabdlt_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u64)))
+svuint64_t svabdlt_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u16)))
+svuint16_t svabdlt_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_m)))
+svint32_t svadalp_s32_m(svbool_t, svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_m)))
+svint64_t svadalp_s64_m(svbool_t, svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_m)))
+svint16_t svadalp_s16_m(svbool_t, svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_x)))
+svint32_t svadalp_s32_x(svbool_t, svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_x)))
+svint64_t svadalp_s64_x(svbool_t, svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_x)))
+svint16_t svadalp_s16_x(svbool_t, svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_z)))
+svint32_t svadalp_s32_z(svbool_t, svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_z)))
+svint64_t svadalp_s64_z(svbool_t, svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_z)))
+svint16_t svadalp_s16_z(svbool_t, svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_m)))
+svuint32_t svadalp_u32_m(svbool_t, svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_m)))
+svuint64_t svadalp_u64_m(svbool_t, svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_m)))
+svuint16_t svadalp_u16_m(svbool_t, svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_x)))
+svuint32_t svadalp_u32_x(svbool_t, svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_x)))
+svuint64_t svadalp_u64_x(svbool_t, svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_x)))
+svuint16_t svadalp_u16_x(svbool_t, svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_z)))
+svuint32_t svadalp_u32_z(svbool_t, svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_z)))
+svuint64_t svadalp_u64_z(svbool_t, svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_z)))
+svuint16_t svadalp_u16_z(svbool_t, svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u32)))
+svuint32_t svadclb_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u64)))
+svuint64_t svadclb_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u32)))
+svuint32_t svadclb_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u64)))
+svuint64_t svadclb_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u32)))
+svuint32_t svadclt_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u64)))
+svuint64_t svadclt_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u32)))
+svuint32_t svadclt_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u64)))
+svuint64_t svadclt_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u32)))
+svuint16_t svaddhnb_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u64)))
+svuint32_t svaddhnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u16)))
+svuint8_t svaddhnb_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s32)))
+svint16_t svaddhnb_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s64)))
+svint32_t svaddhnb_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s16)))
+svint8_t svaddhnb_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u32)))
+svuint16_t svaddhnb_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u64)))
+svuint32_t svaddhnb_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u16)))
+svuint8_t svaddhnb_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s32)))
+svint16_t svaddhnb_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s64)))
+svint32_t svaddhnb_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s16)))
+svint8_t svaddhnb_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u32)))
+svuint16_t svaddhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u64)))
+svuint32_t svaddhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u16)))
+svuint8_t svaddhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s32)))
+svint16_t svaddhnt_n_s32(svint16_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s64)))
+svint32_t svaddhnt_n_s64(svint32_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s16)))
+svint8_t svaddhnt_n_s16(svint8_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u32)))
+svuint16_t svaddhnt_u32(svuint16_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u64)))
+svuint32_t svaddhnt_u64(svuint32_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u16)))
+svuint8_t svaddhnt_u16(svuint8_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s32)))
+svint16_t svaddhnt_s32(svint16_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s64)))
+svint32_t svaddhnt_s64(svint32_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s16)))
+svint8_t svaddhnt_s16(svint8_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s32)))
+svint32_t svaddlb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s64)))
+svint64_t svaddlb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s16)))
+svint16_t svaddlb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u32)))
+svuint32_t svaddlb_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u64)))
+svuint64_t svaddlb_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u16)))
+svuint16_t svaddlb_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s32)))
+svint32_t svaddlb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s64)))
+svint64_t svaddlb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s16)))
+svint16_t svaddlb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u32)))
+svuint32_t svaddlb_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u64)))
+svuint64_t svaddlb_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u16)))
+svuint16_t svaddlb_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s32)))
+svint32_t svaddlbt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s64)))
+svint64_t svaddlbt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s16)))
+svint16_t svaddlbt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s32)))
+svint32_t svaddlbt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s64)))
+svint64_t svaddlbt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s16)))
+svint16_t svaddlbt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s32)))
+svint32_t svaddlt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s64)))
+svint64_t svaddlt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s16)))
+svint16_t svaddlt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u32)))
+svuint32_t svaddlt_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u64)))
+svuint64_t svaddlt_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u16)))
+svuint16_t svaddlt_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s32)))
+svint32_t svaddlt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s64)))
+svint64_t svaddlt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s16)))
+svint16_t svaddlt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u32)))
+svuint32_t svaddlt_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u64)))
+svuint64_t svaddlt_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u16)))
+svuint16_t svaddlt_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_m)))
+svfloat64_t svaddp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_m)))
+svfloat32_t svaddp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_m)))
+svfloat16_t svaddp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_x)))
+svfloat64_t svaddp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_x)))
+svfloat32_t svaddp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_x)))
+svfloat16_t svaddp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_m)))
+svuint8_t svaddp_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_m)))
+svuint32_t svaddp_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_m)))
+svuint64_t svaddp_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_m)))
+svuint16_t svaddp_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_m)))
+svint8_t svaddp_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_m)))
+svint32_t svaddp_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_m)))
+svint64_t svaddp_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_m)))
+svint16_t svaddp_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_x)))
+svuint8_t svaddp_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_x)))
+svuint32_t svaddp_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_x)))
+svuint64_t svaddp_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_x)))
+svuint16_t svaddp_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_x)))
+svint8_t svaddp_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_x)))
+svint32_t svaddp_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_x)))
+svint64_t svaddp_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_x)))
+svint16_t svaddp_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s32)))
+svint32_t svaddwb_n_s32(svint32_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s64)))
+svint64_t svaddwb_n_s64(svint64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s16)))
+svint16_t svaddwb_n_s16(svint16_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u32)))
+svuint32_t svaddwb_n_u32(svuint32_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u64)))
+svuint64_t svaddwb_n_u64(svuint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u16)))
+svuint16_t svaddwb_n_u16(svuint16_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s32)))
+svint32_t svaddwb_s32(svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s64)))
+svint64_t svaddwb_s64(svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s16)))
+svint16_t svaddwb_s16(svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u32)))
+svuint32_t svaddwb_u32(svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u64)))
+svuint64_t svaddwb_u64(svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u16)))
+svuint16_t svaddwb_u16(svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s32)))
+svint32_t svaddwt_n_s32(svint32_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s64)))
+svint64_t svaddwt_n_s64(svint64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s16)))
+svint16_t svaddwt_n_s16(svint16_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u32)))
+svuint32_t svaddwt_n_u32(svuint32_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u64)))
+svuint64_t svaddwt_n_u64(svuint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u16)))
+svuint16_t svaddwt_n_u16(svuint16_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s32)))
+svint32_t svaddwt_s32(svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s64)))
+svint64_t svaddwt_s64(svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s16)))
+svint16_t svaddwt_s16(svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u32)))
+svuint32_t svaddwt_u32(svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u64)))
+svuint64_t svaddwt_u64(svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u16)))
+svuint16_t svaddwt_u16(svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u8)))
+svuint8_t svbcax_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u32)))
+svuint32_t svbcax_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u64)))
+svuint64_t svbcax_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u16)))
+svuint16_t svbcax_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s8)))
+svint8_t svbcax_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s32)))
+svint32_t svbcax_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s64)))
+svint64_t svbcax_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s16)))
+svint16_t svbcax_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u8)))
+svuint8_t svbcax_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u32)))
+svuint32_t svbcax_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u64)))
+svuint64_t svbcax_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u16)))
+svuint16_t svbcax_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s8)))
+svint8_t svbcax_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s32)))
+svint32_t svbcax_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s64)))
+svint64_t svbcax_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s16)))
+svint16_t svbcax_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u8)))
+svuint8_t svbsl1n_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u32)))
+svuint32_t svbsl1n_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u64)))
+svuint64_t svbsl1n_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u16)))
+svuint16_t svbsl1n_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s8)))
+svint8_t svbsl1n_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s32)))
+svint32_t svbsl1n_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s64)))
+svint64_t svbsl1n_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s16)))
+svint16_t svbsl1n_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u8)))
+svuint8_t svbsl1n_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u32)))
+svuint32_t svbsl1n_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u64)))
+svuint64_t svbsl1n_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u16)))
+svuint16_t svbsl1n_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s8)))
+svint8_t svbsl1n_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s32)))
+svint32_t svbsl1n_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s64)))
+svint64_t svbsl1n_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s16)))
+svint16_t svbsl1n_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u8)))
+svuint8_t svbsl2n_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u32)))
+svuint32_t svbsl2n_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u64)))
+svuint64_t svbsl2n_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u16)))
+svuint16_t svbsl2n_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s8)))
+svint8_t svbsl2n_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s32)))
+svint32_t svbsl2n_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s64)))
+svint64_t svbsl2n_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s16)))
+svint16_t svbsl2n_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u8)))
+svuint8_t svbsl2n_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u32)))
+svuint32_t svbsl2n_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u64)))
+svuint64_t svbsl2n_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u16)))
+svuint16_t svbsl2n_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s8)))
+svint8_t svbsl2n_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s32)))
+svint32_t svbsl2n_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s64)))
+svint64_t svbsl2n_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s16)))
+svint16_t svbsl2n_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u8)))
+svuint8_t svbsl_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u32)))
+svuint32_t svbsl_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u64)))
+svuint64_t svbsl_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u16)))
+svuint16_t svbsl_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s8)))
+svint8_t svbsl_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s32)))
+svint32_t svbsl_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s64)))
+svint64_t svbsl_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s16)))
+svint16_t svbsl_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u8)))
+svuint8_t svbsl_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u32)))
+svuint32_t svbsl_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u64)))
+svuint64_t svbsl_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u16)))
+svuint16_t svbsl_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s8)))
+svint8_t svbsl_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s32)))
+svint32_t svbsl_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s64)))
+svint64_t svbsl_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s16)))
+svint16_t svbsl_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u8)))
+svuint8_t svcadd_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u32)))
+svuint32_t svcadd_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u64)))
+svuint64_t svcadd_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u16)))
+svuint16_t svcadd_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s8)))
+svint8_t svcadd_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s32)))
+svint32_t svcadd_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s64)))
+svint64_t svcadd_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s16)))
+svint16_t svcadd_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s32)))
+svint32_t svcdot_s32(svint32_t, svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s64)))
+svint64_t svcdot_s64(svint64_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s32)))
+svint32_t svcdot_lane_s32(svint32_t, svint8_t, svint8_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s64)))
+svint64_t svcdot_lane_s64(svint64_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u8)))
+svuint8_t svcmla_u8(svuint8_t, svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u32)))
+svuint32_t svcmla_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u64)))
+svuint64_t svcmla_u64(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u16)))
+svuint16_t svcmla_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s8)))
+svint8_t svcmla_s8(svint8_t, svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s32)))
+svint32_t svcmla_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s64)))
+svint64_t svcmla_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s16)))
+svint16_t svcmla_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u32)))
+svuint32_t svcmla_lane_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u16)))
+svuint16_t svcmla_lane_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s32)))
+svint32_t svcmla_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s16)))
+svint16_t svcmla_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_m)))
+svfloat32_t svcvtlt_f32_f16_m(svfloat32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_x)))
+svfloat32_t svcvtlt_f32_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_m)))
+svfloat64_t svcvtlt_f64_f32_m(svfloat64_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_x)))
+svfloat64_t svcvtlt_f64_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f16_f32_m)))
+svfloat16_t svcvtnt_f16_f32_m(svfloat16_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f32_f64_m)))
+svfloat32_t svcvtnt_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_m)))
+svfloat32_t svcvtx_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_x)))
+svfloat32_t svcvtx_f32_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_z)))
+svfloat32_t svcvtx_f32_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtxnt_f32_f64_m)))
+svfloat32_t svcvtxnt_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u8)))
+svuint8_t sveor3_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u32)))
+svuint32_t sveor3_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u64)))
+svuint64_t sveor3_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u16)))
+svuint16_t sveor3_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s8)))
+svint8_t sveor3_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s32)))
+svint32_t sveor3_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s64)))
+svint64_t sveor3_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s16)))
+svint16_t sveor3_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u8)))
+svuint8_t sveor3_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u32)))
+svuint32_t sveor3_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u64)))
+svuint64_t sveor3_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u16)))
+svuint16_t sveor3_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s8)))
+svint8_t sveor3_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s32)))
+svint32_t sveor3_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s64)))
+svint64_t sveor3_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s16)))
+svint16_t sveor3_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u8)))
+svuint8_t sveorbt_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u32)))
+svuint32_t sveorbt_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u64)))
+svuint64_t sveorbt_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u16)))
+svuint16_t sveorbt_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s8)))
+svint8_t sveorbt_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s32)))
+svint32_t sveorbt_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s64)))
+svint64_t sveorbt_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s16)))
+svint16_t sveorbt_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u8)))
+svuint8_t sveorbt_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u32)))
+svuint32_t sveorbt_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u64)))
+svuint64_t sveorbt_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u16)))
+svuint16_t sveorbt_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s8)))
+svint8_t sveorbt_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s32)))
+svint32_t sveorbt_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s64)))
+svint64_t sveorbt_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s16)))
+svint16_t sveorbt_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u8)))
+svuint8_t sveortb_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u32)))
+svuint32_t sveortb_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u64)))
+svuint64_t sveortb_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u16)))
+svuint16_t sveortb_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s8)))
+svint8_t sveortb_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s32)))
+svint32_t sveortb_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s64)))
+svint64_t sveortb_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s16)))
+svint16_t sveortb_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u8)))
+svuint8_t sveortb_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u32)))
+svuint32_t sveortb_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u64)))
+svuint64_t sveortb_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u16)))
+svuint16_t sveortb_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s8)))
+svint8_t sveortb_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s32)))
+svint32_t sveortb_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s64)))
+svint64_t sveortb_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s16)))
+svint16_t sveortb_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_m)))
+svint8_t svhadd_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_m)))
+svint32_t svhadd_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_m)))
+svint64_t svhadd_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_m)))
+svint16_t svhadd_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_x)))
+svint8_t svhadd_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_x)))
+svint32_t svhadd_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_x)))
+svint64_t svhadd_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_x)))
+svint16_t svhadd_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_z)))
+svint8_t svhadd_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_z)))
+svint32_t svhadd_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_z)))
+svint64_t svhadd_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_z)))
+svint16_t svhadd_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_m)))
+svuint8_t svhadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_m)))
+svuint32_t svhadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_m)))
+svuint64_t svhadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_m)))
+svuint16_t svhadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_x)))
+svuint8_t svhadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_x)))
+svuint32_t svhadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_x)))
+svuint64_t svhadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_x)))
+svuint16_t svhadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_z)))
+svuint8_t svhadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_z)))
+svuint32_t svhadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_z)))
+svuint64_t svhadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_z)))
+svuint16_t svhadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_m)))
+svint8_t svhadd_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_m)))
+svint32_t svhadd_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_m)))
+svint64_t svhadd_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_m)))
+svint16_t svhadd_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_x)))
+svint8_t svhadd_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_x)))
+svint32_t svhadd_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_x)))
+svint64_t svhadd_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_x)))
+svint16_t svhadd_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_z)))
+svint8_t svhadd_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_z)))
+svint32_t svhadd_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_z)))
+svint64_t svhadd_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_z)))
+svint16_t svhadd_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_m)))
+svuint8_t svhadd_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_m)))
+svuint32_t svhadd_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_m)))
+svuint64_t svhadd_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_m)))
+svuint16_t svhadd_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_x)))
+svuint8_t svhadd_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_x)))
+svuint32_t svhadd_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_x)))
+svuint64_t svhadd_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_x)))
+svuint16_t svhadd_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_z)))
+svuint8_t svhadd_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_z)))
+svuint32_t svhadd_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_z)))
+svuint64_t svhadd_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_z)))
+svuint16_t svhadd_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_m)))
+svint8_t svhsub_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_m)))
+svint32_t svhsub_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_m)))
+svint64_t svhsub_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_m)))
+svint16_t svhsub_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_x)))
+svint8_t svhsub_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_x)))
+svint32_t svhsub_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_x)))
+svint64_t svhsub_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_x)))
+svint16_t svhsub_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_z)))
+svint8_t svhsub_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_z)))
+svint32_t svhsub_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_z)))
+svint64_t svhsub_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_z)))
+svint16_t svhsub_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_m)))
+svuint8_t svhsub_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_m)))
+svuint32_t svhsub_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_m)))
+svuint64_t svhsub_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_m)))
+svuint16_t svhsub_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_x)))
+svuint8_t svhsub_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_x)))
+svuint32_t svhsub_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_x)))
+svuint64_t svhsub_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_x)))
+svuint16_t svhsub_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_z)))
+svuint8_t svhsub_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_z)))
+svuint32_t svhsub_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_z)))
+svuint64_t svhsub_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_z)))
+svuint16_t svhsub_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_m)))
+svint8_t svhsub_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_m)))
+svint32_t svhsub_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_m)))
+svint64_t svhsub_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_m)))
+svint16_t svhsub_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_x)))
+svint8_t svhsub_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_x)))
+svint32_t svhsub_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_x)))
+svint64_t svhsub_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_x)))
+svint16_t svhsub_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_z)))
+svint8_t svhsub_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_z)))
+svint32_t svhsub_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_z)))
+svint64_t svhsub_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_z)))
+svint16_t svhsub_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_m)))
+svuint8_t svhsub_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_m)))
+svuint32_t svhsub_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_m)))
+svuint64_t svhsub_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_m)))
+svuint16_t svhsub_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_x)))
+svuint8_t svhsub_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_x)))
+svuint32_t svhsub_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_x)))
+svuint64_t svhsub_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_x)))
+svuint16_t svhsub_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_z)))
+svuint8_t svhsub_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_z)))
+svuint32_t svhsub_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_z)))
+svuint64_t svhsub_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_z)))
+svuint16_t svhsub_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_m)))
+svint8_t svhsubr_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_m)))
+svint32_t svhsubr_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_m)))
+svint64_t svhsubr_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_m)))
+svint16_t svhsubr_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_x)))
+svint8_t svhsubr_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_x)))
+svint32_t svhsubr_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_x)))
+svint64_t svhsubr_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_x)))
+svint16_t svhsubr_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_z)))
+svint8_t svhsubr_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_z)))
+svint32_t svhsubr_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_z)))
+svint64_t svhsubr_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_z)))
+svint16_t svhsubr_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_m)))
+svuint8_t svhsubr_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_m)))
+svuint32_t svhsubr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_m)))
+svuint64_t svhsubr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_m)))
+svuint16_t svhsubr_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_x)))
+svuint8_t svhsubr_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_x)))
+svuint32_t svhsubr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_x)))
+svuint64_t svhsubr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_x)))
+svuint16_t svhsubr_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_z)))
+svuint8_t svhsubr_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_z)))
+svuint32_t svhsubr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_z)))
+svuint64_t svhsubr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_z)))
+svuint16_t svhsubr_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_m)))
+svint8_t svhsubr_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_m)))
+svint32_t svhsubr_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_m)))
+svint64_t svhsubr_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_m)))
+svint16_t svhsubr_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_x)))
+svint8_t svhsubr_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_x)))
+svint32_t svhsubr_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_x)))
+svint64_t svhsubr_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_x)))
+svint16_t svhsubr_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_z)))
+svint8_t svhsubr_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_z)))
+svint32_t svhsubr_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_z)))
+svint64_t svhsubr_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_z)))
+svint16_t svhsubr_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_m)))
+svuint8_t svhsubr_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_m)))
+svuint32_t svhsubr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_m)))
+svuint64_t svhsubr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_m)))
+svuint16_t svhsubr_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_x)))
+svuint8_t svhsubr_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_x)))
+svuint32_t svhsubr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_x)))
+svuint64_t svhsubr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_x)))
+svuint16_t svhsubr_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_z)))
+svuint8_t svhsubr_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_z)))
+svuint32_t svhsubr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_z)))
+svuint64_t svhsubr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_z)))
+svuint16_t svhsubr_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_m)))
+svint64_t svlogb_f64_m(svint64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_m)))
+svint32_t svlogb_f32_m(svint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_m)))
+svint16_t svlogb_f16_m(svint16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_x)))
+svint64_t svlogb_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_x)))
+svint32_t svlogb_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_x)))
+svint16_t svlogb_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_z)))
+svint64_t svlogb_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_z)))
+svint32_t svlogb_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_z)))
+svint16_t svlogb_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_m)))
+svfloat64_t svmaxnmp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_m)))
+svfloat32_t svmaxnmp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_m)))
+svfloat16_t svmaxnmp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_x)))
+svfloat64_t svmaxnmp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_x)))
+svfloat32_t svmaxnmp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_x)))
+svfloat16_t svmaxnmp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_m)))
+svfloat64_t svmaxp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_m)))
+svfloat32_t svmaxp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_m)))
+svfloat16_t svmaxp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_x)))
+svfloat64_t svmaxp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_x)))
+svfloat32_t svmaxp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_x)))
+svfloat16_t svmaxp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_m)))
+svint8_t svmaxp_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_m)))
+svint32_t svmaxp_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_m)))
+svint64_t svmaxp_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_m)))
+svint16_t svmaxp_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_x)))
+svint8_t svmaxp_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_x)))
+svint32_t svmaxp_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_x)))
+svint64_t svmaxp_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_x)))
+svint16_t svmaxp_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_m)))
+svuint8_t svmaxp_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_m)))
+svuint32_t svmaxp_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_m)))
+svuint64_t svmaxp_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_m)))
+svuint16_t svmaxp_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_x)))
+svuint8_t svmaxp_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_x)))
+svuint32_t svmaxp_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_x)))
+svuint64_t svmaxp_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_x)))
+svuint16_t svmaxp_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_m)))
+svfloat64_t svminnmp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_m)))
+svfloat32_t svminnmp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_m)))
+svfloat16_t svminnmp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_x)))
+svfloat64_t svminnmp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_x)))
+svfloat32_t svminnmp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_x)))
+svfloat16_t svminnmp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_m)))
+svfloat64_t svminp_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_m)))
+svfloat32_t svminp_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_m)))
+svfloat16_t svminp_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_x)))
+svfloat64_t svminp_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_x)))
+svfloat32_t svminp_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_x)))
+svfloat16_t svminp_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_m)))
+svint8_t svminp_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_m)))
+svint32_t svminp_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_m)))
+svint64_t svminp_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_m)))
+svint16_t svminp_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_x)))
+svint8_t svminp_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_x)))
+svint32_t svminp_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_x)))
+svint64_t svminp_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_x)))
+svint16_t svminp_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_m)))
+svuint8_t svminp_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_m)))
+svuint32_t svminp_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_m)))
+svuint64_t svminp_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_m)))
+svuint16_t svminp_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_x)))
+svuint8_t svminp_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_x)))
+svuint32_t svminp_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_x)))
+svuint64_t svminp_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_x)))
+svuint16_t svminp_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u32)))
+svuint32_t svmla_lane_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u64)))
+svuint64_t svmla_lane_u64(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u16)))
+svuint16_t svmla_lane_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s32)))
+svint32_t svmla_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s64)))
+svint64_t svmla_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s16)))
+svint16_t svmla_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_f32)))
+svfloat32_t svmlalb_n_f32(svfloat32_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s32)))
+svint32_t svmlalb_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s64)))
+svint64_t svmlalb_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s16)))
+svint16_t svmlalb_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u32)))
+svuint32_t svmlalb_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u64)))
+svuint64_t svmlalb_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u16)))
+svuint16_t svmlalb_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_f32)))
+svfloat32_t svmlalb_f32(svfloat32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s32)))
+svint32_t svmlalb_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s64)))
+svint64_t svmlalb_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s16)))
+svint16_t svmlalb_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u32)))
+svuint32_t svmlalb_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u64)))
+svuint64_t svmlalb_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u16)))
+svuint16_t svmlalb_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_f32)))
+svfloat32_t svmlalb_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s32)))
+svint32_t svmlalb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s64)))
+svint64_t svmlalb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u32)))
+svuint32_t svmlalb_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u64)))
+svuint64_t svmlalb_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_f32)))
+svfloat32_t svmlalt_n_f32(svfloat32_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s32)))
+svint32_t svmlalt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s64)))
+svint64_t svmlalt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s16)))
+svint16_t svmlalt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u32)))
+svuint32_t svmlalt_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u64)))
+svuint64_t svmlalt_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u16)))
+svuint16_t svmlalt_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_f32)))
+svfloat32_t svmlalt_f32(svfloat32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s32)))
+svint32_t svmlalt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s64)))
+svint64_t svmlalt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s16)))
+svint16_t svmlalt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u32)))
+svuint32_t svmlalt_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u64)))
+svuint64_t svmlalt_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u16)))
+svuint16_t svmlalt_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_f32)))
+svfloat32_t svmlalt_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s32)))
+svint32_t svmlalt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s64)))
+svint64_t svmlalt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u32)))
+svuint32_t svmlalt_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u64)))
+svuint64_t svmlalt_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u32)))
+svuint32_t svmls_lane_u32(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u64)))
+svuint64_t svmls_lane_u64(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u16)))
+svuint16_t svmls_lane_u16(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s32)))
+svint32_t svmls_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s64)))
+svint64_t svmls_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s16)))
+svint16_t svmls_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_f32)))
+svfloat32_t svmlslb_n_f32(svfloat32_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s32)))
+svint32_t svmlslb_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s64)))
+svint64_t svmlslb_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s16)))
+svint16_t svmlslb_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u32)))
+svuint32_t svmlslb_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u64)))
+svuint64_t svmlslb_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u16)))
+svuint16_t svmlslb_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_f32)))
+svfloat32_t svmlslb_f32(svfloat32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s32)))
+svint32_t svmlslb_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s64)))
+svint64_t svmlslb_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s16)))
+svint16_t svmlslb_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u32)))
+svuint32_t svmlslb_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u64)))
+svuint64_t svmlslb_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u16)))
+svuint16_t svmlslb_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_f32)))
+svfloat32_t svmlslb_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s32)))
+svint32_t svmlslb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s64)))
+svint64_t svmlslb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u32)))
+svuint32_t svmlslb_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u64)))
+svuint64_t svmlslb_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_f32)))
+svfloat32_t svmlslt_n_f32(svfloat32_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s32)))
+svint32_t svmlslt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s64)))
+svint64_t svmlslt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s16)))
+svint16_t svmlslt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u32)))
+svuint32_t svmlslt_n_u32(svuint32_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u64)))
+svuint64_t svmlslt_n_u64(svuint64_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u16)))
+svuint16_t svmlslt_n_u16(svuint16_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_f32)))
+svfloat32_t svmlslt_f32(svfloat32_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s32)))
+svint32_t svmlslt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s64)))
+svint64_t svmlslt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s16)))
+svint16_t svmlslt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u32)))
+svuint32_t svmlslt_u32(svuint32_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u64)))
+svuint64_t svmlslt_u64(svuint64_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u16)))
+svuint16_t svmlslt_u16(svuint16_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_f32)))
+svfloat32_t svmlslt_lane_f32(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s32)))
+svint32_t svmlslt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s64)))
+svint64_t svmlslt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u32)))
+svuint32_t svmlslt_lane_u32(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u64)))
+svuint64_t svmlslt_lane_u64(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s32)))
+svint32_t svmovlb_s32(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s64)))
+svint64_t svmovlb_s64(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s16)))
+svint16_t svmovlb_s16(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u32)))
+svuint32_t svmovlb_u32(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u64)))
+svuint64_t svmovlb_u64(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u16)))
+svuint16_t svmovlb_u16(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s32)))
+svint32_t svmovlt_s32(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s64)))
+svint64_t svmovlt_s64(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s16)))
+svint16_t svmovlt_s16(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u32)))
+svuint32_t svmovlt_u32(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u64)))
+svuint64_t svmovlt_u64(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u16)))
+svuint16_t svmovlt_u16(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u32)))
+svuint32_t svmul_lane_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u64)))
+svuint64_t svmul_lane_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u16)))
+svuint16_t svmul_lane_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s32)))
+svint32_t svmul_lane_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s64)))
+svint64_t svmul_lane_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s16)))
+svint16_t svmul_lane_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s32)))
+svint32_t svmullb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s64)))
+svint64_t svmullb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s16)))
+svint16_t svmullb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u32)))
+svuint32_t svmullb_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u64)))
+svuint64_t svmullb_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u16)))
+svuint16_t svmullb_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s32)))
+svint32_t svmullb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s64)))
+svint64_t svmullb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s16)))
+svint16_t svmullb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u32)))
+svuint32_t svmullb_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u64)))
+svuint64_t svmullb_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u16)))
+svuint16_t svmullb_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s32)))
+svint32_t svmullb_lane_s32(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s64)))
+svint64_t svmullb_lane_s64(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u32)))
+svuint32_t svmullb_lane_u32(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u64)))
+svuint64_t svmullb_lane_u64(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s32)))
+svint32_t svmullt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s64)))
+svint64_t svmullt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s16)))
+svint16_t svmullt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u32)))
+svuint32_t svmullt_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u64)))
+svuint64_t svmullt_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u16)))
+svuint16_t svmullt_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s32)))
+svint32_t svmullt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s64)))
+svint64_t svmullt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s16)))
+svint16_t svmullt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u32)))
+svuint32_t svmullt_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u64)))
+svuint64_t svmullt_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u16)))
+svuint16_t svmullt_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s32)))
+svint32_t svmullt_lane_s32(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s64)))
+svint64_t svmullt_lane_s64(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u32)))
+svuint32_t svmullt_lane_u32(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u64)))
+svuint64_t svmullt_lane_u64(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u8)))
+svuint8_t svnbsl_n_u8(svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u32)))
+svuint32_t svnbsl_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u64)))
+svuint64_t svnbsl_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u16)))
+svuint16_t svnbsl_n_u16(svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s8)))
+svint8_t svnbsl_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s32)))
+svint32_t svnbsl_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s64)))
+svint64_t svnbsl_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s16)))
+svint16_t svnbsl_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u8)))
+svuint8_t svnbsl_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u32)))
+svuint32_t svnbsl_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u64)))
+svuint64_t svnbsl_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u16)))
+svuint16_t svnbsl_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s8)))
+svint8_t svnbsl_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s32)))
+svint32_t svnbsl_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s64)))
+svint64_t svnbsl_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s16)))
+svint16_t svnbsl_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_n_u8)))
+svuint8_t svpmul_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_u8)))
+svuint8_t svpmul_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u64)))
+svuint64_t svpmullb_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u16)))
+svuint16_t svpmullb_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u64)))
+svuint64_t svpmullb_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u16)))
+svuint16_t svpmullb_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u8)))
+svuint8_t svpmullb_pair_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u32)))
+svuint32_t svpmullb_pair_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u8)))
+svuint8_t svpmullb_pair_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u32)))
+svuint32_t svpmullb_pair_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u64)))
+svuint64_t svpmullt_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u16)))
+svuint16_t svpmullt_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u64)))
+svuint64_t svpmullt_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u16)))
+svuint16_t svpmullt_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u8)))
+svuint8_t svpmullt_pair_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u32)))
+svuint32_t svpmullt_pair_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u8)))
+svuint8_t svpmullt_pair_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u32)))
+svuint32_t svpmullt_pair_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_m)))
+svint8_t svqabs_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_m)))
+svint32_t svqabs_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_m)))
+svint64_t svqabs_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_m)))
+svint16_t svqabs_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_x)))
+svint8_t svqabs_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_x)))
+svint32_t svqabs_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_x)))
+svint64_t svqabs_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_x)))
+svint16_t svqabs_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_z)))
+svint8_t svqabs_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_z)))
+svint32_t svqabs_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_z)))
+svint64_t svqabs_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_z)))
+svint16_t svqabs_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_m)))
+svint8_t svqadd_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_m)))
+svint32_t svqadd_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_m)))
+svint64_t svqadd_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_m)))
+svint16_t svqadd_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_x)))
+svint8_t svqadd_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_x)))
+svint32_t svqadd_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_x)))
+svint64_t svqadd_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_x)))
+svint16_t svqadd_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_z)))
+svint8_t svqadd_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_z)))
+svint32_t svqadd_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_z)))
+svint64_t svqadd_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_z)))
+svint16_t svqadd_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_m)))
+svuint8_t svqadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_m)))
+svuint32_t svqadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_m)))
+svuint64_t svqadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_m)))
+svuint16_t svqadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_x)))
+svuint8_t svqadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_x)))
+svuint32_t svqadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_x)))
+svuint64_t svqadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_x)))
+svuint16_t svqadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_z)))
+svuint8_t svqadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_z)))
+svuint32_t svqadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_z)))
+svuint64_t svqadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_z)))
+svuint16_t svqadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_m)))
+svint8_t svqadd_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_m)))
+svint32_t svqadd_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_m)))
+svint64_t svqadd_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_m)))
+svint16_t svqadd_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_x)))
+svint8_t svqadd_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_x)))
+svint32_t svqadd_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_x)))
+svint64_t svqadd_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_x)))
+svint16_t svqadd_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_z)))
+svint8_t svqadd_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_z)))
+svint32_t svqadd_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_z)))
+svint64_t svqadd_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_z)))
+svint16_t svqadd_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_m)))
+svuint8_t svqadd_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_m)))
+svuint32_t svqadd_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_m)))
+svuint64_t svqadd_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_m)))
+svuint16_t svqadd_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_x)))
+svuint8_t svqadd_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_x)))
+svuint32_t svqadd_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_x)))
+svuint64_t svqadd_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_x)))
+svuint16_t svqadd_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_z)))
+svuint8_t svqadd_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_z)))
+svuint32_t svqadd_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_z)))
+svuint64_t svqadd_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_z)))
+svuint16_t svqadd_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s8)))
+svint8_t svqcadd_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s32)))
+svint32_t svqcadd_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s64)))
+svint64_t svqcadd_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s16)))
+svint16_t svqcadd_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s32)))
+svint32_t svqdmlalb_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s64)))
+svint64_t svqdmlalb_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s16)))
+svint16_t svqdmlalb_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s32)))
+svint32_t svqdmlalb_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s64)))
+svint64_t svqdmlalb_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s16)))
+svint16_t svqdmlalb_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s32)))
+svint32_t svqdmlalb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s64)))
+svint64_t svqdmlalb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s32)))
+svint32_t svqdmlalbt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s64)))
+svint64_t svqdmlalbt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s16)))
+svint16_t svqdmlalbt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s32)))
+svint32_t svqdmlalbt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s64)))
+svint64_t svqdmlalbt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s16)))
+svint16_t svqdmlalbt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s32)))
+svint32_t svqdmlalt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s64)))
+svint64_t svqdmlalt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s16)))
+svint16_t svqdmlalt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s32)))
+svint32_t svqdmlalt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s64)))
+svint64_t svqdmlalt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s16)))
+svint16_t svqdmlalt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s32)))
+svint32_t svqdmlalt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s64)))
+svint64_t svqdmlalt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s32)))
+svint32_t svqdmlslb_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s64)))
+svint64_t svqdmlslb_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s16)))
+svint16_t svqdmlslb_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s32)))
+svint32_t svqdmlslb_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s64)))
+svint64_t svqdmlslb_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s16)))
+svint16_t svqdmlslb_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s32)))
+svint32_t svqdmlslb_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s64)))
+svint64_t svqdmlslb_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s32)))
+svint32_t svqdmlslbt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s64)))
+svint64_t svqdmlslbt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s16)))
+svint16_t svqdmlslbt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s32)))
+svint32_t svqdmlslbt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s64)))
+svint64_t svqdmlslbt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s16)))
+svint16_t svqdmlslbt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s32)))
+svint32_t svqdmlslt_n_s32(svint32_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s64)))
+svint64_t svqdmlslt_n_s64(svint64_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s16)))
+svint16_t svqdmlslt_n_s16(svint16_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s32)))
+svint32_t svqdmlslt_s32(svint32_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s64)))
+svint64_t svqdmlslt_s64(svint64_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s16)))
+svint16_t svqdmlslt_s16(svint16_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s32)))
+svint32_t svqdmlslt_lane_s32(svint32_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s64)))
+svint64_t svqdmlslt_lane_s64(svint64_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s8)))
+svint8_t svqdmulh_n_s8(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s32)))
+svint32_t svqdmulh_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s64)))
+svint64_t svqdmulh_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s16)))
+svint16_t svqdmulh_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8)))
+svint8_t svqdmulh_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32)))
+svint32_t svqdmulh_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64)))
+svint64_t svqdmulh_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16)))
+svint16_t svqdmulh_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s32)))
+svint32_t svqdmulh_lane_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s64)))
+svint64_t svqdmulh_lane_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s16)))
+svint16_t svqdmulh_lane_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s32)))
+svint32_t svqdmullb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s64)))
+svint64_t svqdmullb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s16)))
+svint16_t svqdmullb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s32)))
+svint32_t svqdmullb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s64)))
+svint64_t svqdmullb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s16)))
+svint16_t svqdmullb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s32)))
+svint32_t svqdmullb_lane_s32(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s64)))
+svint64_t svqdmullb_lane_s64(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s32)))
+svint32_t svqdmullt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s64)))
+svint64_t svqdmullt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s16)))
+svint16_t svqdmullt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s32)))
+svint32_t svqdmullt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s64)))
+svint64_t svqdmullt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s16)))
+svint16_t svqdmullt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s32)))
+svint32_t svqdmullt_lane_s32(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s64)))
+svint64_t svqdmullt_lane_s64(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_m)))
+svint8_t svqneg_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_m)))
+svint32_t svqneg_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_m)))
+svint64_t svqneg_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_m)))
+svint16_t svqneg_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_x)))
+svint8_t svqneg_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_x)))
+svint32_t svqneg_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_x)))
+svint64_t svqneg_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_x)))
+svint16_t svqneg_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_z)))
+svint8_t svqneg_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_z)))
+svint32_t svqneg_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_z)))
+svint64_t svqneg_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_z)))
+svint16_t svqneg_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s8)))
+svint8_t svqrdcmlah_s8(svint8_t, svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s32)))
+svint32_t svqrdcmlah_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s64)))
+svint64_t svqrdcmlah_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s16)))
+svint16_t svqrdcmlah_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s32)))
+svint32_t svqrdcmlah_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s16)))
+svint16_t svqrdcmlah_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s8)))
+svint8_t svqrdmlah_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s32)))
+svint32_t svqrdmlah_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s64)))
+svint64_t svqrdmlah_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s16)))
+svint16_t svqrdmlah_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s8)))
+svint8_t svqrdmlah_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s32)))
+svint32_t svqrdmlah_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s64)))
+svint64_t svqrdmlah_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s16)))
+svint16_t svqrdmlah_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s32)))
+svint32_t svqrdmlah_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s64)))
+svint64_t svqrdmlah_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s16)))
+svint16_t svqrdmlah_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s8)))
+svint8_t svqrdmlsh_n_s8(svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s32)))
+svint32_t svqrdmlsh_n_s32(svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s64)))
+svint64_t svqrdmlsh_n_s64(svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s16)))
+svint16_t svqrdmlsh_n_s16(svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s8)))
+svint8_t svqrdmlsh_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s32)))
+svint32_t svqrdmlsh_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s64)))
+svint64_t svqrdmlsh_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s16)))
+svint16_t svqrdmlsh_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s32)))
+svint32_t svqrdmlsh_lane_s32(svint32_t, svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s64)))
+svint64_t svqrdmlsh_lane_s64(svint64_t, svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s16)))
+svint16_t svqrdmlsh_lane_s16(svint16_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s8)))
+svint8_t svqrdmulh_n_s8(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s32)))
+svint32_t svqrdmulh_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s64)))
+svint64_t svqrdmulh_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s16)))
+svint16_t svqrdmulh_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s8)))
+svint8_t svqrdmulh_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s32)))
+svint32_t svqrdmulh_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s64)))
+svint64_t svqrdmulh_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s16)))
+svint16_t svqrdmulh_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s32)))
+svint32_t svqrdmulh_lane_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s64)))
+svint64_t svqrdmulh_lane_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s16)))
+svint16_t svqrdmulh_lane_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_m)))
+svint8_t svqrshl_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_m)))
+svint32_t svqrshl_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_m)))
+svint64_t svqrshl_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_m)))
+svint16_t svqrshl_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_x)))
+svint8_t svqrshl_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_x)))
+svint32_t svqrshl_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_x)))
+svint64_t svqrshl_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_x)))
+svint16_t svqrshl_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_z)))
+svint8_t svqrshl_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_z)))
+svint32_t svqrshl_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_z)))
+svint64_t svqrshl_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_z)))
+svint16_t svqrshl_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_m)))
+svuint8_t svqrshl_n_u8_m(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_m)))
+svuint32_t svqrshl_n_u32_m(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_m)))
+svuint64_t svqrshl_n_u64_m(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_m)))
+svuint16_t svqrshl_n_u16_m(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_x)))
+svuint8_t svqrshl_n_u8_x(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_x)))
+svuint32_t svqrshl_n_u32_x(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_x)))
+svuint64_t svqrshl_n_u64_x(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_x)))
+svuint16_t svqrshl_n_u16_x(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_z)))
+svuint8_t svqrshl_n_u8_z(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_z)))
+svuint32_t svqrshl_n_u32_z(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_z)))
+svuint64_t svqrshl_n_u64_z(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_z)))
+svuint16_t svqrshl_n_u16_z(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_m)))
+svint8_t svqrshl_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_m)))
+svint32_t svqrshl_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_m)))
+svint64_t svqrshl_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_m)))
+svint16_t svqrshl_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_x)))
+svint8_t svqrshl_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_x)))
+svint32_t svqrshl_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_x)))
+svint64_t svqrshl_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_x)))
+svint16_t svqrshl_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_z)))
+svint8_t svqrshl_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_z)))
+svint32_t svqrshl_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_z)))
+svint64_t svqrshl_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_z)))
+svint16_t svqrshl_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_m)))
+svuint8_t svqrshl_u8_m(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_m)))
+svuint32_t svqrshl_u32_m(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_m)))
+svuint64_t svqrshl_u64_m(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_m)))
+svuint16_t svqrshl_u16_m(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_x)))
+svuint8_t svqrshl_u8_x(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_x)))
+svuint32_t svqrshl_u32_x(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_x)))
+svuint64_t svqrshl_u64_x(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_x)))
+svuint16_t svqrshl_u16_x(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_z)))
+svuint8_t svqrshl_u8_z(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_z)))
+svuint32_t svqrshl_u32_z(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_z)))
+svuint64_t svqrshl_u64_z(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_z)))
+svuint16_t svqrshl_u16_z(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s32)))
+svint16_t svqrshrnb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s64)))
+svint32_t svqrshrnb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s16)))
+svint8_t svqrshrnb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u32)))
+svuint16_t svqrshrnb_n_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u64)))
+svuint32_t svqrshrnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u16)))
+svuint8_t svqrshrnb_n_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s32)))
+svint16_t svqrshrnt_n_s32(svint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s64)))
+svint32_t svqrshrnt_n_s64(svint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s16)))
+svint8_t svqrshrnt_n_s16(svint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u32)))
+svuint16_t svqrshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u64)))
+svuint32_t svqrshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u16)))
+svuint8_t svqrshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s32)))
+svuint16_t svqrshrunb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s64)))
+svuint32_t svqrshrunb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s16)))
+svuint8_t svqrshrunb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s32)))
+svuint16_t svqrshrunt_n_s32(svuint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s64)))
+svuint32_t svqrshrunt_n_s64(svuint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s16)))
+svuint8_t svqrshrunt_n_s16(svuint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_m)))
+svint8_t svqshl_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_m)))
+svint32_t svqshl_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_m)))
+svint64_t svqshl_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_m)))
+svint16_t svqshl_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_x)))
+svint8_t svqshl_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_x)))
+svint32_t svqshl_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_x)))
+svint64_t svqshl_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_x)))
+svint16_t svqshl_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_z)))
+svint8_t svqshl_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_z)))
+svint32_t svqshl_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_z)))
+svint64_t svqshl_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_z)))
+svint16_t svqshl_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_m)))
+svuint8_t svqshl_n_u8_m(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_m)))
+svuint32_t svqshl_n_u32_m(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_m)))
+svuint64_t svqshl_n_u64_m(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_m)))
+svuint16_t svqshl_n_u16_m(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_x)))
+svuint8_t svqshl_n_u8_x(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_x)))
+svuint32_t svqshl_n_u32_x(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_x)))
+svuint64_t svqshl_n_u64_x(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_x)))
+svuint16_t svqshl_n_u16_x(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_z)))
+svuint8_t svqshl_n_u8_z(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_z)))
+svuint32_t svqshl_n_u32_z(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_z)))
+svuint64_t svqshl_n_u64_z(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_z)))
+svuint16_t svqshl_n_u16_z(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_m)))
+svint8_t svqshl_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_m)))
+svint32_t svqshl_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_m)))
+svint64_t svqshl_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_m)))
+svint16_t svqshl_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_x)))
+svint8_t svqshl_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_x)))
+svint32_t svqshl_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_x)))
+svint64_t svqshl_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_x)))
+svint16_t svqshl_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_z)))
+svint8_t svqshl_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_z)))
+svint32_t svqshl_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_z)))
+svint64_t svqshl_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_z)))
+svint16_t svqshl_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_m)))
+svuint8_t svqshl_u8_m(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_m)))
+svuint32_t svqshl_u32_m(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_m)))
+svuint64_t svqshl_u64_m(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_m)))
+svuint16_t svqshl_u16_m(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_x)))
+svuint8_t svqshl_u8_x(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_x)))
+svuint32_t svqshl_u32_x(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_x)))
+svuint64_t svqshl_u64_x(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_x)))
+svuint16_t svqshl_u16_x(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_z)))
+svuint8_t svqshl_u8_z(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_z)))
+svuint32_t svqshl_u32_z(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_z)))
+svuint64_t svqshl_u64_z(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_z)))
+svuint16_t svqshl_u16_z(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_m)))
+svuint8_t svqshlu_n_s8_m(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_m)))
+svuint32_t svqshlu_n_s32_m(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_m)))
+svuint64_t svqshlu_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_m)))
+svuint16_t svqshlu_n_s16_m(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_x)))
+svuint8_t svqshlu_n_s8_x(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_x)))
+svuint32_t svqshlu_n_s32_x(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_x)))
+svuint64_t svqshlu_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_x)))
+svuint16_t svqshlu_n_s16_x(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_z)))
+svuint8_t svqshlu_n_s8_z(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_z)))
+svuint32_t svqshlu_n_s32_z(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_z)))
+svuint64_t svqshlu_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_z)))
+svuint16_t svqshlu_n_s16_z(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s32)))
+svint16_t svqshrnb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s64)))
+svint32_t svqshrnb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s16)))
+svint8_t svqshrnb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u32)))
+svuint16_t svqshrnb_n_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u64)))
+svuint32_t svqshrnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u16)))
+svuint8_t svqshrnb_n_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s32)))
+svint16_t svqshrnt_n_s32(svint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s64)))
+svint32_t svqshrnt_n_s64(svint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s16)))
+svint8_t svqshrnt_n_s16(svint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u32)))
+svuint16_t svqshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u64)))
+svuint32_t svqshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u16)))
+svuint8_t svqshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s32)))
+svuint16_t svqshrunb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s64)))
+svuint32_t svqshrunb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s16)))
+svuint8_t svqshrunb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s32)))
+svuint16_t svqshrunt_n_s32(svuint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s64)))
+svuint32_t svqshrunt_n_s64(svuint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s16)))
+svuint8_t svqshrunt_n_s16(svuint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_m)))
+svint8_t svqsub_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_m)))
+svint32_t svqsub_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_m)))
+svint64_t svqsub_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_m)))
+svint16_t svqsub_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_x)))
+svint8_t svqsub_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_x)))
+svint32_t svqsub_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_x)))
+svint64_t svqsub_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_x)))
+svint16_t svqsub_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_z)))
+svint8_t svqsub_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_z)))
+svint32_t svqsub_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_z)))
+svint64_t svqsub_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_z)))
+svint16_t svqsub_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_m)))
+svuint8_t svqsub_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_m)))
+svuint32_t svqsub_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_m)))
+svuint64_t svqsub_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_m)))
+svuint16_t svqsub_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_x)))
+svuint8_t svqsub_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_x)))
+svuint32_t svqsub_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_x)))
+svuint64_t svqsub_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_x)))
+svuint16_t svqsub_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_z)))
+svuint8_t svqsub_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_z)))
+svuint32_t svqsub_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_z)))
+svuint64_t svqsub_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_z)))
+svuint16_t svqsub_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_m)))
+svint8_t svqsub_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_m)))
+svint32_t svqsub_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_m)))
+svint64_t svqsub_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_m)))
+svint16_t svqsub_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_x)))
+svint8_t svqsub_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_x)))
+svint32_t svqsub_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_x)))
+svint64_t svqsub_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_x)))
+svint16_t svqsub_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_z)))
+svint8_t svqsub_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_z)))
+svint32_t svqsub_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_z)))
+svint64_t svqsub_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_z)))
+svint16_t svqsub_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_m)))
+svuint8_t svqsub_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_m)))
+svuint32_t svqsub_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_m)))
+svuint64_t svqsub_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_m)))
+svuint16_t svqsub_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_x)))
+svuint8_t svqsub_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_x)))
+svuint32_t svqsub_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_x)))
+svuint64_t svqsub_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_x)))
+svuint16_t svqsub_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_z)))
+svuint8_t svqsub_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_z)))
+svuint32_t svqsub_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_z)))
+svuint64_t svqsub_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_z)))
+svuint16_t svqsub_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_m)))
+svint8_t svqsubr_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_m)))
+svint32_t svqsubr_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_m)))
+svint64_t svqsubr_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_m)))
+svint16_t svqsubr_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_x)))
+svint8_t svqsubr_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_x)))
+svint32_t svqsubr_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_x)))
+svint64_t svqsubr_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_x)))
+svint16_t svqsubr_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_z)))
+svint8_t svqsubr_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_z)))
+svint32_t svqsubr_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_z)))
+svint64_t svqsubr_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_z)))
+svint16_t svqsubr_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_m)))
+svuint8_t svqsubr_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_m)))
+svuint32_t svqsubr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_m)))
+svuint64_t svqsubr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_m)))
+svuint16_t svqsubr_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_x)))
+svuint8_t svqsubr_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_x)))
+svuint32_t svqsubr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_x)))
+svuint64_t svqsubr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_x)))
+svuint16_t svqsubr_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_z)))
+svuint8_t svqsubr_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_z)))
+svuint32_t svqsubr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_z)))
+svuint64_t svqsubr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_z)))
+svuint16_t svqsubr_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_m)))
+svint8_t svqsubr_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_m)))
+svint32_t svqsubr_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_m)))
+svint64_t svqsubr_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_m)))
+svint16_t svqsubr_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_x)))
+svint8_t svqsubr_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_x)))
+svint32_t svqsubr_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_x)))
+svint64_t svqsubr_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_x)))
+svint16_t svqsubr_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_z)))
+svint8_t svqsubr_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_z)))
+svint32_t svqsubr_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_z)))
+svint64_t svqsubr_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_z)))
+svint16_t svqsubr_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_m)))
+svuint8_t svqsubr_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_m)))
+svuint32_t svqsubr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_m)))
+svuint64_t svqsubr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_m)))
+svuint16_t svqsubr_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_x)))
+svuint8_t svqsubr_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_x)))
+svuint32_t svqsubr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_x)))
+svuint64_t svqsubr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_x)))
+svuint16_t svqsubr_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_z)))
+svuint8_t svqsubr_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_z)))
+svuint32_t svqsubr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_z)))
+svuint64_t svqsubr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_z)))
+svuint16_t svqsubr_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s32)))
+svint16_t svqxtnb_s32(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s64)))
+svint32_t svqxtnb_s64(svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s16)))
+svint8_t svqxtnb_s16(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u32)))
+svuint16_t svqxtnb_u32(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u64)))
+svuint32_t svqxtnb_u64(svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u16)))
+svuint8_t svqxtnb_u16(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s32)))
+svint16_t svqxtnt_s32(svint16_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s64)))
+svint32_t svqxtnt_s64(svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s16)))
+svint8_t svqxtnt_s16(svint8_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u32)))
+svuint16_t svqxtnt_u32(svuint16_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u64)))
+svuint32_t svqxtnt_u64(svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u16)))
+svuint8_t svqxtnt_u16(svuint8_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s32)))
+svuint16_t svqxtunb_s32(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s64)))
+svuint32_t svqxtunb_s64(svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s16)))
+svuint8_t svqxtunb_s16(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s32)))
+svuint16_t svqxtunt_s32(svuint16_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s64)))
+svuint32_t svqxtunt_s64(svuint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s16)))
+svuint8_t svqxtunt_s16(svuint8_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u32)))
+svuint16_t svraddhnb_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u64)))
+svuint32_t svraddhnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u16)))
+svuint8_t svraddhnb_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s32)))
+svint16_t svraddhnb_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s64)))
+svint32_t svraddhnb_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s16)))
+svint8_t svraddhnb_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u32)))
+svuint16_t svraddhnb_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u64)))
+svuint32_t svraddhnb_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u16)))
+svuint8_t svraddhnb_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s32)))
+svint16_t svraddhnb_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s64)))
+svint32_t svraddhnb_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s16)))
+svint8_t svraddhnb_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u32)))
+svuint16_t svraddhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u64)))
+svuint32_t svraddhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u16)))
+svuint8_t svraddhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s32)))
+svint16_t svraddhnt_n_s32(svint16_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s64)))
+svint32_t svraddhnt_n_s64(svint32_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s16)))
+svint8_t svraddhnt_n_s16(svint8_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u32)))
+svuint16_t svraddhnt_u32(svuint16_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u64)))
+svuint32_t svraddhnt_u64(svuint32_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u16)))
+svuint8_t svraddhnt_u16(svuint8_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s32)))
+svint16_t svraddhnt_s32(svint16_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s64)))
+svint32_t svraddhnt_s64(svint32_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s16)))
+svint8_t svraddhnt_s16(svint8_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_m)))
+svuint32_t svrecpe_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_x)))
+svuint32_t svrecpe_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_z)))
+svuint32_t svrecpe_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_m)))
+svint8_t svrhadd_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_m)))
+svint32_t svrhadd_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_m)))
+svint64_t svrhadd_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_m)))
+svint16_t svrhadd_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_x)))
+svint8_t svrhadd_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_x)))
+svint32_t svrhadd_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_x)))
+svint64_t svrhadd_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_x)))
+svint16_t svrhadd_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_z)))
+svint8_t svrhadd_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_z)))
+svint32_t svrhadd_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_z)))
+svint64_t svrhadd_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_z)))
+svint16_t svrhadd_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_m)))
+svuint8_t svrhadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_m)))
+svuint32_t svrhadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_m)))
+svuint64_t svrhadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_m)))
+svuint16_t svrhadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_x)))
+svuint8_t svrhadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_x)))
+svuint32_t svrhadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_x)))
+svuint64_t svrhadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_x)))
+svuint16_t svrhadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_z)))
+svuint8_t svrhadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_z)))
+svuint32_t svrhadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_z)))
+svuint64_t svrhadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_z)))
+svuint16_t svrhadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_m)))
+svint8_t svrhadd_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_m)))
+svint32_t svrhadd_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_m)))
+svint64_t svrhadd_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_m)))
+svint16_t svrhadd_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_x)))
+svint8_t svrhadd_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_x)))
+svint32_t svrhadd_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_x)))
+svint64_t svrhadd_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_x)))
+svint16_t svrhadd_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_z)))
+svint8_t svrhadd_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_z)))
+svint32_t svrhadd_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_z)))
+svint64_t svrhadd_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_z)))
+svint16_t svrhadd_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_m)))
+svuint8_t svrhadd_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_m)))
+svuint32_t svrhadd_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_m)))
+svuint64_t svrhadd_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_m)))
+svuint16_t svrhadd_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_x)))
+svuint8_t svrhadd_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_x)))
+svuint32_t svrhadd_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_x)))
+svuint64_t svrhadd_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_x)))
+svuint16_t svrhadd_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_z)))
+svuint8_t svrhadd_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_z)))
+svuint32_t svrhadd_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_z)))
+svuint64_t svrhadd_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_z)))
+svuint16_t svrhadd_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_m)))
+svint8_t svrshl_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_m)))
+svint32_t svrshl_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_m)))
+svint64_t svrshl_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_m)))
+svint16_t svrshl_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_x)))
+svint8_t svrshl_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_x)))
+svint32_t svrshl_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_x)))
+svint64_t svrshl_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_x)))
+svint16_t svrshl_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_z)))
+svint8_t svrshl_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_z)))
+svint32_t svrshl_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_z)))
+svint64_t svrshl_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_z)))
+svint16_t svrshl_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_m)))
+svuint8_t svrshl_n_u8_m(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_m)))
+svuint32_t svrshl_n_u32_m(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_m)))
+svuint64_t svrshl_n_u64_m(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_m)))
+svuint16_t svrshl_n_u16_m(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_x)))
+svuint8_t svrshl_n_u8_x(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_x)))
+svuint32_t svrshl_n_u32_x(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_x)))
+svuint64_t svrshl_n_u64_x(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_x)))
+svuint16_t svrshl_n_u16_x(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_z)))
+svuint8_t svrshl_n_u8_z(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_z)))
+svuint32_t svrshl_n_u32_z(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_z)))
+svuint64_t svrshl_n_u64_z(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_z)))
+svuint16_t svrshl_n_u16_z(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_m)))
+svint8_t svrshl_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_m)))
+svint32_t svrshl_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_m)))
+svint64_t svrshl_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_m)))
+svint16_t svrshl_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x)))
+svint8_t svrshl_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x)))
+svint32_t svrshl_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x)))
+svint64_t svrshl_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x)))
+svint16_t svrshl_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_z)))
+svint8_t svrshl_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_z)))
+svint32_t svrshl_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_z)))
+svint64_t svrshl_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_z)))
+svint16_t svrshl_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_m)))
+svuint8_t svrshl_u8_m(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_m)))
+svuint32_t svrshl_u32_m(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_m)))
+svuint64_t svrshl_u64_m(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_m)))
+svuint16_t svrshl_u16_m(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x)))
+svuint8_t svrshl_u8_x(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x)))
+svuint32_t svrshl_u32_x(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x)))
+svuint64_t svrshl_u64_x(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x)))
+svuint16_t svrshl_u16_x(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_z)))
+svuint8_t svrshl_u8_z(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_z)))
+svuint32_t svrshl_u32_z(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_z)))
+svuint64_t svrshl_u64_z(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_z)))
+svuint16_t svrshl_u16_z(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_m)))
+svint8_t svrshr_n_s8_m(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_m)))
+svint32_t svrshr_n_s32_m(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_m)))
+svint64_t svrshr_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_m)))
+svint16_t svrshr_n_s16_m(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_m)))
+svuint8_t svrshr_n_u8_m(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_m)))
+svuint32_t svrshr_n_u32_m(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_m)))
+svuint64_t svrshr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_m)))
+svuint16_t svrshr_n_u16_m(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_x)))
+svint8_t svrshr_n_s8_x(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_x)))
+svint32_t svrshr_n_s32_x(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_x)))
+svint64_t svrshr_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_x)))
+svint16_t svrshr_n_s16_x(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_x)))
+svuint8_t svrshr_n_u8_x(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_x)))
+svuint32_t svrshr_n_u32_x(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_x)))
+svuint64_t svrshr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_x)))
+svuint16_t svrshr_n_u16_x(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_z)))
+svint8_t svrshr_n_s8_z(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_z)))
+svint32_t svrshr_n_s32_z(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_z)))
+svint64_t svrshr_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_z)))
+svint16_t svrshr_n_s16_z(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_z)))
+svuint8_t svrshr_n_u8_z(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_z)))
+svuint32_t svrshr_n_u32_z(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_z)))
+svuint64_t svrshr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_z)))
+svuint16_t svrshr_n_u16_z(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u32)))
+svuint16_t svrshrnb_n_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u64)))
+svuint32_t svrshrnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u16)))
+svuint8_t svrshrnb_n_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s32)))
+svint16_t svrshrnb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s64)))
+svint32_t svrshrnb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s16)))
+svint8_t svrshrnb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u32)))
+svuint16_t svrshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u64)))
+svuint32_t svrshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u16)))
+svuint8_t svrshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s32)))
+svint16_t svrshrnt_n_s32(svint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s64)))
+svint32_t svrshrnt_n_s64(svint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s16)))
+svint8_t svrshrnt_n_s16(svint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_m)))
+svuint32_t svrsqrte_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_x)))
+svuint32_t svrsqrte_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_z)))
+svuint32_t svrsqrte_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s8)))
+svint8_t svrsra_n_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s32)))
+svint32_t svrsra_n_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s64)))
+svint64_t svrsra_n_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s16)))
+svint16_t svrsra_n_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u8)))
+svuint8_t svrsra_n_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u32)))
+svuint32_t svrsra_n_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u64)))
+svuint64_t svrsra_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u16)))
+svuint16_t svrsra_n_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u32)))
+svuint16_t svrsubhnb_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u64)))
+svuint32_t svrsubhnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u16)))
+svuint8_t svrsubhnb_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s32)))
+svint16_t svrsubhnb_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s64)))
+svint32_t svrsubhnb_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s16)))
+svint8_t svrsubhnb_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u32)))
+svuint16_t svrsubhnb_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u64)))
+svuint32_t svrsubhnb_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u16)))
+svuint8_t svrsubhnb_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s32)))
+svint16_t svrsubhnb_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s64)))
+svint32_t svrsubhnb_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s16)))
+svint8_t svrsubhnb_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u32)))
+svuint16_t svrsubhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u64)))
+svuint32_t svrsubhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u16)))
+svuint8_t svrsubhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s32)))
+svint16_t svrsubhnt_n_s32(svint16_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s64)))
+svint32_t svrsubhnt_n_s64(svint32_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s16)))
+svint8_t svrsubhnt_n_s16(svint8_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u32)))
+svuint16_t svrsubhnt_u32(svuint16_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u64)))
+svuint32_t svrsubhnt_u64(svuint32_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u16)))
+svuint8_t svrsubhnt_u16(svuint8_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s32)))
+svint16_t svrsubhnt_s32(svint16_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s64)))
+svint32_t svrsubhnt_s64(svint32_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s16)))
+svint8_t svrsubhnt_s16(svint8_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u32)))
+svuint32_t svsbclb_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u64)))
+svuint64_t svsbclb_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u32)))
+svuint32_t svsbclb_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u64)))
+svuint64_t svsbclb_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u32)))
+svuint32_t svsbclt_n_u32(svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u64)))
+svuint64_t svsbclt_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u32)))
+svuint32_t svsbclt_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u64)))
+svuint64_t svsbclt_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s32)))
+svint32_t svshllb_n_s32(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s64)))
+svint64_t svshllb_n_s64(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s16)))
+svint16_t svshllb_n_s16(svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u32)))
+svuint32_t svshllb_n_u32(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u64)))
+svuint64_t svshllb_n_u64(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u16)))
+svuint16_t svshllb_n_u16(svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s32)))
+svint32_t svshllt_n_s32(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s64)))
+svint64_t svshllt_n_s64(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s16)))
+svint16_t svshllt_n_s16(svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u32)))
+svuint32_t svshllt_n_u32(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u64)))
+svuint64_t svshllt_n_u64(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u16)))
+svuint16_t svshllt_n_u16(svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u32)))
+svuint16_t svshrnb_n_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u64)))
+svuint32_t svshrnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u16)))
+svuint8_t svshrnb_n_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s32)))
+svint16_t svshrnb_n_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s64)))
+svint32_t svshrnb_n_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s16)))
+svint8_t svshrnb_n_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u32)))
+svuint16_t svshrnt_n_u32(svuint16_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u64)))
+svuint32_t svshrnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u16)))
+svuint8_t svshrnt_n_u16(svuint8_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s32)))
+svint16_t svshrnt_n_s32(svint16_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s64)))
+svint32_t svshrnt_n_s64(svint32_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s16)))
+svint8_t svshrnt_n_s16(svint8_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u8)))
+svuint8_t svsli_n_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u32)))
+svuint32_t svsli_n_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u64)))
+svuint64_t svsli_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u16)))
+svuint16_t svsli_n_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s8)))
+svint8_t svsli_n_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s32)))
+svint32_t svsli_n_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s64)))
+svint64_t svsli_n_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s16)))
+svint16_t svsli_n_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_m)))
+svuint8_t svsqadd_n_u8_m(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_m)))
+svuint32_t svsqadd_n_u32_m(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_m)))
+svuint64_t svsqadd_n_u64_m(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_m)))
+svuint16_t svsqadd_n_u16_m(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_x)))
+svuint8_t svsqadd_n_u8_x(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_x)))
+svuint32_t svsqadd_n_u32_x(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_x)))
+svuint64_t svsqadd_n_u64_x(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_x)))
+svuint16_t svsqadd_n_u16_x(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_z)))
+svuint8_t svsqadd_n_u8_z(svbool_t, svuint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_z)))
+svuint32_t svsqadd_n_u32_z(svbool_t, svuint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_z)))
+svuint64_t svsqadd_n_u64_z(svbool_t, svuint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_z)))
+svuint16_t svsqadd_n_u16_z(svbool_t, svuint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_m)))
+svuint8_t svsqadd_u8_m(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_m)))
+svuint32_t svsqadd_u32_m(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_m)))
+svuint64_t svsqadd_u64_m(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_m)))
+svuint16_t svsqadd_u16_m(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_x)))
+svuint8_t svsqadd_u8_x(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_x)))
+svuint32_t svsqadd_u32_x(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_x)))
+svuint64_t svsqadd_u64_x(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_x)))
+svuint16_t svsqadd_u16_x(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_z)))
+svuint8_t svsqadd_u8_z(svbool_t, svuint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_z)))
+svuint32_t svsqadd_u32_z(svbool_t, svuint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_z)))
+svuint64_t svsqadd_u64_z(svbool_t, svuint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_z)))
+svuint16_t svsqadd_u16_z(svbool_t, svuint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s8)))
+svint8_t svsra_n_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s32)))
+svint32_t svsra_n_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s64)))
+svint64_t svsra_n_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s16)))
+svint16_t svsra_n_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u8)))
+svuint8_t svsra_n_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u32)))
+svuint32_t svsra_n_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u64)))
+svuint64_t svsra_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u16)))
+svuint16_t svsra_n_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u8)))
+svuint8_t svsri_n_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u32)))
+svuint32_t svsri_n_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u64)))
+svuint64_t svsri_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u16)))
+svuint16_t svsri_n_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s8)))
+svint8_t svsri_n_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s32)))
+svint32_t svsri_n_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s64)))
+svint64_t svsri_n_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s16)))
+svint16_t svsri_n_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u32)))
+svuint16_t svsubhnb_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u64)))
+svuint32_t svsubhnb_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u16)))
+svuint8_t svsubhnb_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s32)))
+svint16_t svsubhnb_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s64)))
+svint32_t svsubhnb_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s16)))
+svint8_t svsubhnb_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u32)))
+svuint16_t svsubhnb_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u64)))
+svuint32_t svsubhnb_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u16)))
+svuint8_t svsubhnb_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s32)))
+svint16_t svsubhnb_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s64)))
+svint32_t svsubhnb_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s16)))
+svint8_t svsubhnb_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u32)))
+svuint16_t svsubhnt_n_u32(svuint16_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u64)))
+svuint32_t svsubhnt_n_u64(svuint32_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u16)))
+svuint8_t svsubhnt_n_u16(svuint8_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s32)))
+svint16_t svsubhnt_n_s32(svint16_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s64)))
+svint32_t svsubhnt_n_s64(svint32_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s16)))
+svint8_t svsubhnt_n_s16(svint8_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u32)))
+svuint16_t svsubhnt_u32(svuint16_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u64)))
+svuint32_t svsubhnt_u64(svuint32_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u16)))
+svuint8_t svsubhnt_u16(svuint8_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s32)))
+svint16_t svsubhnt_s32(svint16_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s64)))
+svint32_t svsubhnt_s64(svint32_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s16)))
+svint8_t svsubhnt_s16(svint8_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s32)))
+svint32_t svsublb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s64)))
+svint64_t svsublb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s16)))
+svint16_t svsublb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u32)))
+svuint32_t svsublb_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u64)))
+svuint64_t svsublb_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u16)))
+svuint16_t svsublb_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s32)))
+svint32_t svsublb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s64)))
+svint64_t svsublb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s16)))
+svint16_t svsublb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u32)))
+svuint32_t svsublb_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u64)))
+svuint64_t svsublb_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u16)))
+svuint16_t svsublb_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s32)))
+svint32_t svsublbt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s64)))
+svint64_t svsublbt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s16)))
+svint16_t svsublbt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s32)))
+svint32_t svsublbt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s64)))
+svint64_t svsublbt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s16)))
+svint16_t svsublbt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s32)))
+svint32_t svsublt_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s64)))
+svint64_t svsublt_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s16)))
+svint16_t svsublt_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u32)))
+svuint32_t svsublt_n_u32(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u64)))
+svuint64_t svsublt_n_u64(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u16)))
+svuint16_t svsublt_n_u16(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s32)))
+svint32_t svsublt_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s64)))
+svint64_t svsublt_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s16)))
+svint16_t svsublt_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u32)))
+svuint32_t svsublt_u32(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u64)))
+svuint64_t svsublt_u64(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u16)))
+svuint16_t svsublt_u16(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s32)))
+svint32_t svsubltb_n_s32(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s64)))
+svint64_t svsubltb_n_s64(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s16)))
+svint16_t svsubltb_n_s16(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s32)))
+svint32_t svsubltb_s32(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s64)))
+svint64_t svsubltb_s64(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s16)))
+svint16_t svsubltb_s16(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s32)))
+svint32_t svsubwb_n_s32(svint32_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s64)))
+svint64_t svsubwb_n_s64(svint64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s16)))
+svint16_t svsubwb_n_s16(svint16_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u32)))
+svuint32_t svsubwb_n_u32(svuint32_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u64)))
+svuint64_t svsubwb_n_u64(svuint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u16)))
+svuint16_t svsubwb_n_u16(svuint16_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s32)))
+svint32_t svsubwb_s32(svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s64)))
+svint64_t svsubwb_s64(svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s16)))
+svint16_t svsubwb_s16(svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u32)))
+svuint32_t svsubwb_u32(svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u64)))
+svuint64_t svsubwb_u64(svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u16)))
+svuint16_t svsubwb_u16(svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s32)))
+svint32_t svsubwt_n_s32(svint32_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s64)))
+svint64_t svsubwt_n_s64(svint64_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s16)))
+svint16_t svsubwt_n_s16(svint16_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u32)))
+svuint32_t svsubwt_n_u32(svuint32_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u64)))
+svuint64_t svsubwt_n_u64(svuint64_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u16)))
+svuint16_t svsubwt_n_u16(svuint16_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s32)))
+svint32_t svsubwt_s32(svint32_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s64)))
+svint64_t svsubwt_s64(svint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s16)))
+svint16_t svsubwt_s16(svint16_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u32)))
+svuint32_t svsubwt_u32(svuint32_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u64)))
+svuint64_t svsubwt_u64(svuint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u16)))
+svuint16_t svsubwt_u16(svuint16_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u8)))
+svuint8_t svtbl2_u8(svuint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u32)))
+svuint32_t svtbl2_u32(svuint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u64)))
+svuint64_t svtbl2_u64(svuint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u16)))
+svuint16_t svtbl2_u16(svuint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s8)))
+svint8_t svtbl2_s8(svint8x2_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f64)))
+svfloat64_t svtbl2_f64(svfloat64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f32)))
+svfloat32_t svtbl2_f32(svfloat32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f16)))
+svfloat16_t svtbl2_f16(svfloat16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s32)))
+svint32_t svtbl2_s32(svint32x2_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s64)))
+svint64_t svtbl2_s64(svint64x2_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s16)))
+svint16_t svtbl2_s16(svint16x2_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u8)))
+svuint8_t svtbx_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u32)))
+svuint32_t svtbx_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u64)))
+svuint64_t svtbx_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u16)))
+svuint16_t svtbx_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s8)))
+svint8_t svtbx_s8(svint8_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f64)))
+svfloat64_t svtbx_f64(svfloat64_t, svfloat64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f32)))
+svfloat32_t svtbx_f32(svfloat32_t, svfloat32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f16)))
+svfloat16_t svtbx_f16(svfloat16_t, svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s32)))
+svint32_t svtbx_s32(svint32_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s64)))
+svint64_t svtbx_s64(svint64_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s16)))
+svint16_t svtbx_s16(svint16_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_m)))
+svint8_t svuqadd_n_s8_m(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_m)))
+svint32_t svuqadd_n_s32_m(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_m)))
+svint64_t svuqadd_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_m)))
+svint16_t svuqadd_n_s16_m(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_x)))
+svint8_t svuqadd_n_s8_x(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_x)))
+svint32_t svuqadd_n_s32_x(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_x)))
+svint64_t svuqadd_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_x)))
+svint16_t svuqadd_n_s16_x(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_z)))
+svint8_t svuqadd_n_s8_z(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_z)))
+svint32_t svuqadd_n_s32_z(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_z)))
+svint64_t svuqadd_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_z)))
+svint16_t svuqadd_n_s16_z(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_m)))
+svint8_t svuqadd_s8_m(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_m)))
+svint32_t svuqadd_s32_m(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_m)))
+svint64_t svuqadd_s64_m(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_m)))
+svint16_t svuqadd_s16_m(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_x)))
+svint8_t svuqadd_s8_x(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_x)))
+svint32_t svuqadd_s32_x(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_x)))
+svint64_t svuqadd_s64_x(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_x)))
+svint16_t svuqadd_s16_x(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_z)))
+svint8_t svuqadd_s8_z(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_z)))
+svint32_t svuqadd_s32_z(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_z)))
+svint64_t svuqadd_s64_z(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_z)))
+svint16_t svuqadd_s16_z(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s32)))
+svbool_t svwhilege_b8_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s32)))
+svbool_t svwhilege_b32_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s32)))
+svbool_t svwhilege_b64_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s32)))
+svbool_t svwhilege_b16_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s64)))
+svbool_t svwhilege_b8_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s64)))
+svbool_t svwhilege_b32_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s64)))
+svbool_t svwhilege_b64_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s64)))
+svbool_t svwhilege_b16_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u32)))
+svbool_t svwhilege_b8_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u32)))
+svbool_t svwhilege_b32_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u32)))
+svbool_t svwhilege_b64_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u32)))
+svbool_t svwhilege_b16_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u64)))
+svbool_t svwhilege_b8_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u64)))
+svbool_t svwhilege_b32_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u64)))
+svbool_t svwhilege_b64_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u64)))
+svbool_t svwhilege_b16_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s32)))
+svbool_t svwhilegt_b8_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s32)))
+svbool_t svwhilegt_b32_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s32)))
+svbool_t svwhilegt_b64_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s32)))
+svbool_t svwhilegt_b16_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s64)))
+svbool_t svwhilegt_b8_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s64)))
+svbool_t svwhilegt_b32_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s64)))
+svbool_t svwhilegt_b64_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s64)))
+svbool_t svwhilegt_b16_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u32)))
+svbool_t svwhilegt_b8_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u32)))
+svbool_t svwhilegt_b32_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u32)))
+svbool_t svwhilegt_b64_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u32)))
+svbool_t svwhilegt_b16_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u64)))
+svbool_t svwhilegt_b8_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u64)))
+svbool_t svwhilegt_b32_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u64)))
+svbool_t svwhilegt_b64_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u64)))
+svbool_t svwhilegt_b16_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u8)))
+svbool_t svwhilerw_u8(uint8_t const *, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s8)))
+svbool_t svwhilerw_s8(int8_t const *, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u64)))
+svbool_t svwhilerw_u64(uint64_t const *, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f64)))
+svbool_t svwhilerw_f64(float64_t const *, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s64)))
+svbool_t svwhilerw_s64(int64_t const *, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u16)))
+svbool_t svwhilerw_u16(uint16_t const *, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f16)))
+svbool_t svwhilerw_f16(float16_t const *, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s16)))
+svbool_t svwhilerw_s16(int16_t const *, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u32)))
+svbool_t svwhilerw_u32(uint32_t const *, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f32)))
+svbool_t svwhilerw_f32(float32_t const *, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s32)))
+svbool_t svwhilerw_s32(int32_t const *, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u8)))
+svbool_t svwhilewr_u8(uint8_t const *, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s8)))
+svbool_t svwhilewr_s8(int8_t const *, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u64)))
+svbool_t svwhilewr_u64(uint64_t const *, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f64)))
+svbool_t svwhilewr_f64(float64_t const *, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s64)))
+svbool_t svwhilewr_s64(int64_t const *, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u16)))
+svbool_t svwhilewr_u16(uint16_t const *, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f16)))
+svbool_t svwhilewr_f16(float16_t const *, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s16)))
+svbool_t svwhilewr_s16(int16_t const *, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u32)))
+svbool_t svwhilewr_u32(uint32_t const *, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f32)))
+svbool_t svwhilewr_f32(float32_t const *, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s32)))
+svbool_t svwhilewr_s32(int32_t const *, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u8)))
+svuint8_t svxar_n_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u32)))
+svuint32_t svxar_n_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u64)))
+svuint64_t svxar_n_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u16)))
+svuint16_t svxar_n_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s8)))
+svint8_t svxar_n_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s32)))
+svint32_t svxar_n_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s64)))
+svint64_t svxar_n_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s16)))
+svint16_t svxar_n_s16(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s8)))
+svint8_t svaba(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s32)))
+svint32_t svaba(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s64)))
+svint64_t svaba(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_s16)))
+svint16_t svaba(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u8)))
+svuint8_t svaba(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u32)))
+svuint32_t svaba(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u64)))
+svuint64_t svaba(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_n_u16)))
+svuint16_t svaba(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s8)))
+svint8_t svaba(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s32)))
+svint32_t svaba(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s64)))
+svint64_t svaba(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_s16)))
+svint16_t svaba(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u8)))
+svuint8_t svaba(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u32)))
+svuint32_t svaba(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u64)))
+svuint64_t svaba(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaba_u16)))
+svuint16_t svaba(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s32)))
+svint32_t svabalb(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s64)))
+svint64_t svabalb(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_s16)))
+svint16_t svabalb(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u32)))
+svuint32_t svabalb(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u64)))
+svuint64_t svabalb(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_n_u16)))
+svuint16_t svabalb(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s32)))
+svint32_t svabalb(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s64)))
+svint64_t svabalb(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_s16)))
+svint16_t svabalb(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u32)))
+svuint32_t svabalb(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u64)))
+svuint64_t svabalb(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalb_u16)))
+svuint16_t svabalb(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s32)))
+svint32_t svabalt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s64)))
+svint64_t svabalt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_s16)))
+svint16_t svabalt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u32)))
+svuint32_t svabalt(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u64)))
+svuint64_t svabalt(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_n_u16)))
+svuint16_t svabalt(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s32)))
+svint32_t svabalt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s64)))
+svint64_t svabalt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_s16)))
+svint16_t svabalt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u32)))
+svuint32_t svabalt(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u64)))
+svuint64_t svabalt(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabalt_u16)))
+svuint16_t svabalt(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s32)))
+svint32_t svabdlb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s64)))
+svint64_t svabdlb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_s16)))
+svint16_t svabdlb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u32)))
+svuint32_t svabdlb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u64)))
+svuint64_t svabdlb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_n_u16)))
+svuint16_t svabdlb(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s32)))
+svint32_t svabdlb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s64)))
+svint64_t svabdlb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_s16)))
+svint16_t svabdlb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u32)))
+svuint32_t svabdlb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u64)))
+svuint64_t svabdlb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlb_u16)))
+svuint16_t svabdlb(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s32)))
+svint32_t svabdlt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s64)))
+svint64_t svabdlt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_s16)))
+svint16_t svabdlt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u32)))
+svuint32_t svabdlt(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u64)))
+svuint64_t svabdlt(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_n_u16)))
+svuint16_t svabdlt(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s32)))
+svint32_t svabdlt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s64)))
+svint64_t svabdlt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_s16)))
+svint16_t svabdlt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u32)))
+svuint32_t svabdlt(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u64)))
+svuint64_t svabdlt(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabdlt_u16)))
+svuint16_t svabdlt(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_m)))
+svint32_t svadalp_m(svbool_t, svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_m)))
+svint64_t svadalp_m(svbool_t, svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_m)))
+svint16_t svadalp_m(svbool_t, svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_x)))
+svint32_t svadalp_x(svbool_t, svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_x)))
+svint64_t svadalp_x(svbool_t, svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_x)))
+svint16_t svadalp_x(svbool_t, svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s32_z)))
+svint32_t svadalp_z(svbool_t, svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s64_z)))
+svint64_t svadalp_z(svbool_t, svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_s16_z)))
+svint16_t svadalp_z(svbool_t, svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_m)))
+svuint32_t svadalp_m(svbool_t, svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_m)))
+svuint64_t svadalp_m(svbool_t, svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_m)))
+svuint16_t svadalp_m(svbool_t, svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_x)))
+svuint32_t svadalp_x(svbool_t, svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_x)))
+svuint64_t svadalp_x(svbool_t, svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_x)))
+svuint16_t svadalp_x(svbool_t, svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u32_z)))
+svuint32_t svadalp_z(svbool_t, svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u64_z)))
+svuint64_t svadalp_z(svbool_t, svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadalp_u16_z)))
+svuint16_t svadalp_z(svbool_t, svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u32)))
+svuint32_t svadclb(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_n_u64)))
+svuint64_t svadclb(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u32)))
+svuint32_t svadclb(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclb_u64)))
+svuint64_t svadclb(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u32)))
+svuint32_t svadclt(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_n_u64)))
+svuint64_t svadclt(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u32)))
+svuint32_t svadclt(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadclt_u64)))
+svuint64_t svadclt(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u32)))
+svuint16_t svaddhnb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u64)))
+svuint32_t svaddhnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_u16)))
+svuint8_t svaddhnb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s32)))
+svint16_t svaddhnb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s64)))
+svint32_t svaddhnb(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_n_s16)))
+svint8_t svaddhnb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u32)))
+svuint16_t svaddhnb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u64)))
+svuint32_t svaddhnb(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_u16)))
+svuint8_t svaddhnb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s32)))
+svint16_t svaddhnb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s64)))
+svint32_t svaddhnb(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnb_s16)))
+svint8_t svaddhnb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u32)))
+svuint16_t svaddhnt(svuint16_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u64)))
+svuint32_t svaddhnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_u16)))
+svuint8_t svaddhnt(svuint8_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s32)))
+svint16_t svaddhnt(svint16_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s64)))
+svint32_t svaddhnt(svint32_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_n_s16)))
+svint8_t svaddhnt(svint8_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u32)))
+svuint16_t svaddhnt(svuint16_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u64)))
+svuint32_t svaddhnt(svuint32_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_u16)))
+svuint8_t svaddhnt(svuint8_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s32)))
+svint16_t svaddhnt(svint16_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s64)))
+svint32_t svaddhnt(svint32_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddhnt_s16)))
+svint8_t svaddhnt(svint8_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s32)))
+svint32_t svaddlb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s64)))
+svint64_t svaddlb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_s16)))
+svint16_t svaddlb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u32)))
+svuint32_t svaddlb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u64)))
+svuint64_t svaddlb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_n_u16)))
+svuint16_t svaddlb(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s32)))
+svint32_t svaddlb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s64)))
+svint64_t svaddlb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_s16)))
+svint16_t svaddlb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u32)))
+svuint32_t svaddlb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u64)))
+svuint64_t svaddlb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlb_u16)))
+svuint16_t svaddlb(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s32)))
+svint32_t svaddlbt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s64)))
+svint64_t svaddlbt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_n_s16)))
+svint16_t svaddlbt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s32)))
+svint32_t svaddlbt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s64)))
+svint64_t svaddlbt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlbt_s16)))
+svint16_t svaddlbt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s32)))
+svint32_t svaddlt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s64)))
+svint64_t svaddlt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_s16)))
+svint16_t svaddlt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u32)))
+svuint32_t svaddlt(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u64)))
+svuint64_t svaddlt(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_n_u16)))
+svuint16_t svaddlt(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s32)))
+svint32_t svaddlt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s64)))
+svint64_t svaddlt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_s16)))
+svint16_t svaddlt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u32)))
+svuint32_t svaddlt(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u64)))
+svuint64_t svaddlt(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddlt_u16)))
+svuint16_t svaddlt(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_m)))
+svfloat64_t svaddp_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_m)))
+svfloat32_t svaddp_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_m)))
+svfloat16_t svaddp_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f64_x)))
+svfloat64_t svaddp_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f32_x)))
+svfloat32_t svaddp_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_f16_x)))
+svfloat16_t svaddp_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_m)))
+svuint8_t svaddp_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_m)))
+svuint32_t svaddp_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_m)))
+svuint64_t svaddp_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_m)))
+svuint16_t svaddp_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_m)))
+svint8_t svaddp_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_m)))
+svint32_t svaddp_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_m)))
+svint64_t svaddp_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_m)))
+svint16_t svaddp_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u8_x)))
+svuint8_t svaddp_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u32_x)))
+svuint32_t svaddp_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u64_x)))
+svuint64_t svaddp_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_u16_x)))
+svuint16_t svaddp_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s8_x)))
+svint8_t svaddp_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s32_x)))
+svint32_t svaddp_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s64_x)))
+svint64_t svaddp_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddp_s16_x)))
+svint16_t svaddp_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s32)))
+svint32_t svaddwb(svint32_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s64)))
+svint64_t svaddwb(svint64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_s16)))
+svint16_t svaddwb(svint16_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u32)))
+svuint32_t svaddwb(svuint32_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u64)))
+svuint64_t svaddwb(svuint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_n_u16)))
+svuint16_t svaddwb(svuint16_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s32)))
+svint32_t svaddwb(svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s64)))
+svint64_t svaddwb(svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_s16)))
+svint16_t svaddwb(svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u32)))
+svuint32_t svaddwb(svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u64)))
+svuint64_t svaddwb(svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwb_u16)))
+svuint16_t svaddwb(svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s32)))
+svint32_t svaddwt(svint32_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s64)))
+svint64_t svaddwt(svint64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_s16)))
+svint16_t svaddwt(svint16_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u32)))
+svuint32_t svaddwt(svuint32_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u64)))
+svuint64_t svaddwt(svuint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_n_u16)))
+svuint16_t svaddwt(svuint16_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s32)))
+svint32_t svaddwt(svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s64)))
+svint64_t svaddwt(svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_s16)))
+svint16_t svaddwt(svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u32)))
+svuint32_t svaddwt(svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u64)))
+svuint64_t svaddwt(svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddwt_u16)))
+svuint16_t svaddwt(svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u8)))
+svuint8_t svbcax(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u32)))
+svuint32_t svbcax(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u64)))
+svuint64_t svbcax(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_u16)))
+svuint16_t svbcax(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s8)))
+svint8_t svbcax(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s32)))
+svint32_t svbcax(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s64)))
+svint64_t svbcax(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_n_s16)))
+svint16_t svbcax(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u8)))
+svuint8_t svbcax(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u32)))
+svuint32_t svbcax(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u64)))
+svuint64_t svbcax(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_u16)))
+svuint16_t svbcax(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s8)))
+svint8_t svbcax(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s32)))
+svint32_t svbcax(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s64)))
+svint64_t svbcax(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbcax_s16)))
+svint16_t svbcax(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u8)))
+svuint8_t svbsl1n(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u32)))
+svuint32_t svbsl1n(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u64)))
+svuint64_t svbsl1n(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_u16)))
+svuint16_t svbsl1n(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s8)))
+svint8_t svbsl1n(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s32)))
+svint32_t svbsl1n(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s64)))
+svint64_t svbsl1n(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_n_s16)))
+svint16_t svbsl1n(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u8)))
+svuint8_t svbsl1n(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u32)))
+svuint32_t svbsl1n(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u64)))
+svuint64_t svbsl1n(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_u16)))
+svuint16_t svbsl1n(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s8)))
+svint8_t svbsl1n(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s32)))
+svint32_t svbsl1n(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s64)))
+svint64_t svbsl1n(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl1n_s16)))
+svint16_t svbsl1n(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u8)))
+svuint8_t svbsl2n(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u32)))
+svuint32_t svbsl2n(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u64)))
+svuint64_t svbsl2n(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_u16)))
+svuint16_t svbsl2n(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s8)))
+svint8_t svbsl2n(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s32)))
+svint32_t svbsl2n(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s64)))
+svint64_t svbsl2n(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_n_s16)))
+svint16_t svbsl2n(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u8)))
+svuint8_t svbsl2n(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u32)))
+svuint32_t svbsl2n(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u64)))
+svuint64_t svbsl2n(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_u16)))
+svuint16_t svbsl2n(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s8)))
+svint8_t svbsl2n(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s32)))
+svint32_t svbsl2n(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s64)))
+svint64_t svbsl2n(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl2n_s16)))
+svint16_t svbsl2n(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u8)))
+svuint8_t svbsl(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u32)))
+svuint32_t svbsl(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u64)))
+svuint64_t svbsl(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_u16)))
+svuint16_t svbsl(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s8)))
+svint8_t svbsl(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s32)))
+svint32_t svbsl(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s64)))
+svint64_t svbsl(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_n_s16)))
+svint16_t svbsl(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u8)))
+svuint8_t svbsl(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u32)))
+svuint32_t svbsl(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u64)))
+svuint64_t svbsl(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_u16)))
+svuint16_t svbsl(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s8)))
+svint8_t svbsl(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s32)))
+svint32_t svbsl(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s64)))
+svint64_t svbsl(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbsl_s16)))
+svint16_t svbsl(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u8)))
+svuint8_t svcadd(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u32)))
+svuint32_t svcadd(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u64)))
+svuint64_t svcadd(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_u16)))
+svuint16_t svcadd(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s8)))
+svint8_t svcadd(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s32)))
+svint32_t svcadd(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s64)))
+svint64_t svcadd(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_s16)))
+svint16_t svcadd(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s32)))
+svint32_t svcdot(svint32_t, svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_s64)))
+svint64_t svcdot(svint64_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s32)))
+svint32_t svcdot_lane(svint32_t, svint8_t, svint8_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcdot_lane_s64)))
+svint64_t svcdot_lane(svint64_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u8)))
+svuint8_t svcmla(svuint8_t, svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u32)))
+svuint32_t svcmla(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u64)))
+svuint64_t svcmla(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_u16)))
+svuint16_t svcmla(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s8)))
+svint8_t svcmla(svint8_t, svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s32)))
+svint32_t svcmla(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s64)))
+svint64_t svcmla(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_s16)))
+svint16_t svcmla(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u32)))
+svuint32_t svcmla_lane(svuint32_t, svuint32_t, svuint32_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_u16)))
+svuint16_t svcmla_lane(svuint16_t, svuint16_t, svuint16_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s32)))
+svint32_t svcmla_lane(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_s16)))
+svint16_t svcmla_lane(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_m)))
+svfloat32_t svcvtlt_f32_m(svfloat32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f32_f16_x)))
+svfloat32_t svcvtlt_f32_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_m)))
+svfloat64_t svcvtlt_f64_m(svfloat64_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtlt_f64_f32_x)))
+svfloat64_t svcvtlt_f64_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f16_f32_m)))
+svfloat16_t svcvtnt_f16_m(svfloat16_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtnt_f32_f64_m)))
+svfloat32_t svcvtnt_f32_m(svfloat32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_m)))
+svfloat32_t svcvtx_f32_m(svfloat32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_x)))
+svfloat32_t svcvtx_f32_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtx_f32_f64_z)))
+svfloat32_t svcvtx_f32_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvtxnt_f32_f64_m)))
+svfloat32_t svcvtxnt_f32_m(svfloat32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u8)))
+svuint8_t sveor3(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u32)))
+svuint32_t sveor3(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u64)))
+svuint64_t sveor3(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_u16)))
+svuint16_t sveor3(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s8)))
+svint8_t sveor3(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s32)))
+svint32_t sveor3(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s64)))
+svint64_t sveor3(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_n_s16)))
+svint16_t sveor3(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u8)))
+svuint8_t sveor3(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u32)))
+svuint32_t sveor3(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u64)))
+svuint64_t sveor3(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_u16)))
+svuint16_t sveor3(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s8)))
+svint8_t sveor3(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s32)))
+svint32_t sveor3(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s64)))
+svint64_t sveor3(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor3_s16)))
+svint16_t sveor3(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u8)))
+svuint8_t sveorbt(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u32)))
+svuint32_t sveorbt(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u64)))
+svuint64_t sveorbt(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_u16)))
+svuint16_t sveorbt(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s8)))
+svint8_t sveorbt(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s32)))
+svint32_t sveorbt(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s64)))
+svint64_t sveorbt(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_n_s16)))
+svint16_t sveorbt(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u8)))
+svuint8_t sveorbt(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u32)))
+svuint32_t sveorbt(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u64)))
+svuint64_t sveorbt(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_u16)))
+svuint16_t sveorbt(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s8)))
+svint8_t sveorbt(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s32)))
+svint32_t sveorbt(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s64)))
+svint64_t sveorbt(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorbt_s16)))
+svint16_t sveorbt(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u8)))
+svuint8_t sveortb(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u32)))
+svuint32_t sveortb(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u64)))
+svuint64_t sveortb(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_u16)))
+svuint16_t sveortb(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s8)))
+svint8_t sveortb(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s32)))
+svint32_t sveortb(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s64)))
+svint64_t sveortb(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_n_s16)))
+svint16_t sveortb(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u8)))
+svuint8_t sveortb(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u32)))
+svuint32_t sveortb(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u64)))
+svuint64_t sveortb(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_u16)))
+svuint16_t sveortb(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s8)))
+svint8_t sveortb(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s32)))
+svint32_t sveortb(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s64)))
+svint64_t sveortb(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveortb_s16)))
+svint16_t sveortb(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_m)))
+svint8_t svhadd_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_m)))
+svint32_t svhadd_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_m)))
+svint64_t svhadd_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_m)))
+svint16_t svhadd_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_x)))
+svint8_t svhadd_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_x)))
+svint32_t svhadd_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_x)))
+svint64_t svhadd_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_x)))
+svint16_t svhadd_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s8_z)))
+svint8_t svhadd_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s32_z)))
+svint32_t svhadd_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s64_z)))
+svint64_t svhadd_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_s16_z)))
+svint16_t svhadd_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_m)))
+svuint8_t svhadd_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_m)))
+svuint32_t svhadd_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_m)))
+svuint64_t svhadd_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_m)))
+svuint16_t svhadd_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_x)))
+svuint8_t svhadd_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_x)))
+svuint32_t svhadd_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_x)))
+svuint64_t svhadd_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_x)))
+svuint16_t svhadd_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u8_z)))
+svuint8_t svhadd_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u32_z)))
+svuint32_t svhadd_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u64_z)))
+svuint64_t svhadd_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_n_u16_z)))
+svuint16_t svhadd_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_m)))
+svint8_t svhadd_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_m)))
+svint32_t svhadd_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_m)))
+svint64_t svhadd_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_m)))
+svint16_t svhadd_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_x)))
+svint8_t svhadd_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_x)))
+svint32_t svhadd_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_x)))
+svint64_t svhadd_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_x)))
+svint16_t svhadd_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s8_z)))
+svint8_t svhadd_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s32_z)))
+svint32_t svhadd_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s64_z)))
+svint64_t svhadd_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_s16_z)))
+svint16_t svhadd_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_m)))
+svuint8_t svhadd_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_m)))
+svuint32_t svhadd_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_m)))
+svuint64_t svhadd_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_m)))
+svuint16_t svhadd_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_x)))
+svuint8_t svhadd_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_x)))
+svuint32_t svhadd_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_x)))
+svuint64_t svhadd_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_x)))
+svuint16_t svhadd_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u8_z)))
+svuint8_t svhadd_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u32_z)))
+svuint32_t svhadd_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u64_z)))
+svuint64_t svhadd_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhadd_u16_z)))
+svuint16_t svhadd_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_m)))
+svint8_t svhsub_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_m)))
+svint32_t svhsub_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_m)))
+svint64_t svhsub_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_m)))
+svint16_t svhsub_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_x)))
+svint8_t svhsub_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_x)))
+svint32_t svhsub_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_x)))
+svint64_t svhsub_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_x)))
+svint16_t svhsub_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s8_z)))
+svint8_t svhsub_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s32_z)))
+svint32_t svhsub_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s64_z)))
+svint64_t svhsub_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_s16_z)))
+svint16_t svhsub_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_m)))
+svuint8_t svhsub_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_m)))
+svuint32_t svhsub_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_m)))
+svuint64_t svhsub_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_m)))
+svuint16_t svhsub_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_x)))
+svuint8_t svhsub_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_x)))
+svuint32_t svhsub_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_x)))
+svuint64_t svhsub_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_x)))
+svuint16_t svhsub_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u8_z)))
+svuint8_t svhsub_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u32_z)))
+svuint32_t svhsub_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u64_z)))
+svuint64_t svhsub_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_n_u16_z)))
+svuint16_t svhsub_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_m)))
+svint8_t svhsub_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_m)))
+svint32_t svhsub_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_m)))
+svint64_t svhsub_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_m)))
+svint16_t svhsub_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_x)))
+svint8_t svhsub_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_x)))
+svint32_t svhsub_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_x)))
+svint64_t svhsub_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_x)))
+svint16_t svhsub_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s8_z)))
+svint8_t svhsub_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s32_z)))
+svint32_t svhsub_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s64_z)))
+svint64_t svhsub_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_s16_z)))
+svint16_t svhsub_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_m)))
+svuint8_t svhsub_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_m)))
+svuint32_t svhsub_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_m)))
+svuint64_t svhsub_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_m)))
+svuint16_t svhsub_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_x)))
+svuint8_t svhsub_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_x)))
+svuint32_t svhsub_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_x)))
+svuint64_t svhsub_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_x)))
+svuint16_t svhsub_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u8_z)))
+svuint8_t svhsub_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u32_z)))
+svuint32_t svhsub_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u64_z)))
+svuint64_t svhsub_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsub_u16_z)))
+svuint16_t svhsub_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_m)))
+svint8_t svhsubr_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_m)))
+svint32_t svhsubr_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_m)))
+svint64_t svhsubr_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_m)))
+svint16_t svhsubr_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_x)))
+svint8_t svhsubr_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_x)))
+svint32_t svhsubr_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_x)))
+svint64_t svhsubr_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_x)))
+svint16_t svhsubr_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s8_z)))
+svint8_t svhsubr_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s32_z)))
+svint32_t svhsubr_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s64_z)))
+svint64_t svhsubr_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_s16_z)))
+svint16_t svhsubr_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_m)))
+svuint8_t svhsubr_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_m)))
+svuint32_t svhsubr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_m)))
+svuint64_t svhsubr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_m)))
+svuint16_t svhsubr_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_x)))
+svuint8_t svhsubr_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_x)))
+svuint32_t svhsubr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_x)))
+svuint64_t svhsubr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_x)))
+svuint16_t svhsubr_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u8_z)))
+svuint8_t svhsubr_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u32_z)))
+svuint32_t svhsubr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u64_z)))
+svuint64_t svhsubr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_n_u16_z)))
+svuint16_t svhsubr_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_m)))
+svint8_t svhsubr_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_m)))
+svint32_t svhsubr_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_m)))
+svint64_t svhsubr_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_m)))
+svint16_t svhsubr_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_x)))
+svint8_t svhsubr_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_x)))
+svint32_t svhsubr_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_x)))
+svint64_t svhsubr_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_x)))
+svint16_t svhsubr_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s8_z)))
+svint8_t svhsubr_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s32_z)))
+svint32_t svhsubr_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s64_z)))
+svint64_t svhsubr_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_s16_z)))
+svint16_t svhsubr_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_m)))
+svuint8_t svhsubr_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_m)))
+svuint32_t svhsubr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_m)))
+svuint64_t svhsubr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_m)))
+svuint16_t svhsubr_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_x)))
+svuint8_t svhsubr_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_x)))
+svuint32_t svhsubr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_x)))
+svuint64_t svhsubr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_x)))
+svuint16_t svhsubr_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u8_z)))
+svuint8_t svhsubr_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u32_z)))
+svuint32_t svhsubr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u64_z)))
+svuint64_t svhsubr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svhsubr_u16_z)))
+svuint16_t svhsubr_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_m)))
+svint64_t svlogb_m(svint64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_m)))
+svint32_t svlogb_m(svint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_m)))
+svint16_t svlogb_m(svint16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_x)))
+svint64_t svlogb_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_x)))
+svint32_t svlogb_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_x)))
+svint16_t svlogb_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f64_z)))
+svint64_t svlogb_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f32_z)))
+svint32_t svlogb_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlogb_f16_z)))
+svint16_t svlogb_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_m)))
+svfloat64_t svmaxnmp_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_m)))
+svfloat32_t svmaxnmp_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_m)))
+svfloat16_t svmaxnmp_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f64_x)))
+svfloat64_t svmaxnmp_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f32_x)))
+svfloat32_t svmaxnmp_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmp_f16_x)))
+svfloat16_t svmaxnmp_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_m)))
+svfloat64_t svmaxp_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_m)))
+svfloat32_t svmaxp_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_m)))
+svfloat16_t svmaxp_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f64_x)))
+svfloat64_t svmaxp_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f32_x)))
+svfloat32_t svmaxp_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_f16_x)))
+svfloat16_t svmaxp_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_m)))
+svint8_t svmaxp_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_m)))
+svint32_t svmaxp_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_m)))
+svint64_t svmaxp_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_m)))
+svint16_t svmaxp_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s8_x)))
+svint8_t svmaxp_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s32_x)))
+svint32_t svmaxp_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s64_x)))
+svint64_t svmaxp_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_s16_x)))
+svint16_t svmaxp_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_m)))
+svuint8_t svmaxp_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_m)))
+svuint32_t svmaxp_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_m)))
+svuint64_t svmaxp_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_m)))
+svuint16_t svmaxp_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u8_x)))
+svuint8_t svmaxp_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u32_x)))
+svuint32_t svmaxp_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u64_x)))
+svuint64_t svmaxp_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxp_u16_x)))
+svuint16_t svmaxp_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_m)))
+svfloat64_t svminnmp_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_m)))
+svfloat32_t svminnmp_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_m)))
+svfloat16_t svminnmp_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f64_x)))
+svfloat64_t svminnmp_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f32_x)))
+svfloat32_t svminnmp_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmp_f16_x)))
+svfloat16_t svminnmp_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_m)))
+svfloat64_t svminp_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_m)))
+svfloat32_t svminp_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_m)))
+svfloat16_t svminp_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f64_x)))
+svfloat64_t svminp_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f32_x)))
+svfloat32_t svminp_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_f16_x)))
+svfloat16_t svminp_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_m)))
+svint8_t svminp_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_m)))
+svint32_t svminp_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_m)))
+svint64_t svminp_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_m)))
+svint16_t svminp_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s8_x)))
+svint8_t svminp_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s32_x)))
+svint32_t svminp_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s64_x)))
+svint64_t svminp_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_s16_x)))
+svint16_t svminp_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_m)))
+svuint8_t svminp_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_m)))
+svuint32_t svminp_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_m)))
+svuint64_t svminp_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_m)))
+svuint16_t svminp_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u8_x)))
+svuint8_t svminp_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u32_x)))
+svuint32_t svminp_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u64_x)))
+svuint64_t svminp_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminp_u16_x)))
+svuint16_t svminp_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u32)))
+svuint32_t svmla_lane(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u64)))
+svuint64_t svmla_lane(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_u16)))
+svuint16_t svmla_lane(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s32)))
+svint32_t svmla_lane(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s64)))
+svint64_t svmla_lane(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_s16)))
+svint16_t svmla_lane(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_f32)))
+svfloat32_t svmlalb(svfloat32_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s32)))
+svint32_t svmlalb(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s64)))
+svint64_t svmlalb(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_s16)))
+svint16_t svmlalb(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u32)))
+svuint32_t svmlalb(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u64)))
+svuint64_t svmlalb(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_n_u16)))
+svuint16_t svmlalb(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_f32)))
+svfloat32_t svmlalb(svfloat32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s32)))
+svint32_t svmlalb(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s64)))
+svint64_t svmlalb(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_s16)))
+svint16_t svmlalb(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u32)))
+svuint32_t svmlalb(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u64)))
+svuint64_t svmlalb(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_u16)))
+svuint16_t svmlalb(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_f32)))
+svfloat32_t svmlalb_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s32)))
+svint32_t svmlalb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_s64)))
+svint64_t svmlalb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u32)))
+svuint32_t svmlalb_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalb_lane_u64)))
+svuint64_t svmlalb_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_f32)))
+svfloat32_t svmlalt(svfloat32_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s32)))
+svint32_t svmlalt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s64)))
+svint64_t svmlalt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_s16)))
+svint16_t svmlalt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u32)))
+svuint32_t svmlalt(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u64)))
+svuint64_t svmlalt(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_n_u16)))
+svuint16_t svmlalt(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_f32)))
+svfloat32_t svmlalt(svfloat32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s32)))
+svint32_t svmlalt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s64)))
+svint64_t svmlalt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_s16)))
+svint16_t svmlalt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u32)))
+svuint32_t svmlalt(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u64)))
+svuint64_t svmlalt(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_u16)))
+svuint16_t svmlalt(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_f32)))
+svfloat32_t svmlalt_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s32)))
+svint32_t svmlalt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_s64)))
+svint64_t svmlalt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u32)))
+svuint32_t svmlalt_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlalt_lane_u64)))
+svuint64_t svmlalt_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u32)))
+svuint32_t svmls_lane(svuint32_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u64)))
+svuint64_t svmls_lane(svuint64_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_u16)))
+svuint16_t svmls_lane(svuint16_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s32)))
+svint32_t svmls_lane(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s64)))
+svint64_t svmls_lane(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_s16)))
+svint16_t svmls_lane(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_f32)))
+svfloat32_t svmlslb(svfloat32_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s32)))
+svint32_t svmlslb(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s64)))
+svint64_t svmlslb(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_s16)))
+svint16_t svmlslb(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u32)))
+svuint32_t svmlslb(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u64)))
+svuint64_t svmlslb(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_n_u16)))
+svuint16_t svmlslb(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_f32)))
+svfloat32_t svmlslb(svfloat32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s32)))
+svint32_t svmlslb(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s64)))
+svint64_t svmlslb(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_s16)))
+svint16_t svmlslb(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u32)))
+svuint32_t svmlslb(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u64)))
+svuint64_t svmlslb(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_u16)))
+svuint16_t svmlslb(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_f32)))
+svfloat32_t svmlslb_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s32)))
+svint32_t svmlslb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_s64)))
+svint64_t svmlslb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u32)))
+svuint32_t svmlslb_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslb_lane_u64)))
+svuint64_t svmlslb_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_f32)))
+svfloat32_t svmlslt(svfloat32_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s32)))
+svint32_t svmlslt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s64)))
+svint64_t svmlslt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_s16)))
+svint16_t svmlslt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u32)))
+svuint32_t svmlslt(svuint32_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u64)))
+svuint64_t svmlslt(svuint64_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_n_u16)))
+svuint16_t svmlslt(svuint16_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_f32)))
+svfloat32_t svmlslt(svfloat32_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s32)))
+svint32_t svmlslt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s64)))
+svint64_t svmlslt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_s16)))
+svint16_t svmlslt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u32)))
+svuint32_t svmlslt(svuint32_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u64)))
+svuint64_t svmlslt(svuint64_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_u16)))
+svuint16_t svmlslt(svuint16_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_f32)))
+svfloat32_t svmlslt_lane(svfloat32_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s32)))
+svint32_t svmlslt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_s64)))
+svint64_t svmlslt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u32)))
+svuint32_t svmlslt_lane(svuint32_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmlslt_lane_u64)))
+svuint64_t svmlslt_lane(svuint64_t, svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s32)))
+svint32_t svmovlb(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s64)))
+svint64_t svmovlb(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_s16)))
+svint16_t svmovlb(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u32)))
+svuint32_t svmovlb(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u64)))
+svuint64_t svmovlb(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlb_u16)))
+svuint16_t svmovlb(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s32)))
+svint32_t svmovlt(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s64)))
+svint64_t svmovlt(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_s16)))
+svint16_t svmovlt(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u32)))
+svuint32_t svmovlt(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u64)))
+svuint64_t svmovlt(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmovlt_u16)))
+svuint16_t svmovlt(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u32)))
+svuint32_t svmul_lane(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u64)))
+svuint64_t svmul_lane(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_u16)))
+svuint16_t svmul_lane(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s32)))
+svint32_t svmul_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s64)))
+svint64_t svmul_lane(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_s16)))
+svint16_t svmul_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s32)))
+svint32_t svmullb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s64)))
+svint64_t svmullb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_s16)))
+svint16_t svmullb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u32)))
+svuint32_t svmullb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u64)))
+svuint64_t svmullb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_n_u16)))
+svuint16_t svmullb(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s32)))
+svint32_t svmullb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s64)))
+svint64_t svmullb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_s16)))
+svint16_t svmullb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u32)))
+svuint32_t svmullb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u64)))
+svuint64_t svmullb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_u16)))
+svuint16_t svmullb(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s32)))
+svint32_t svmullb_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_s64)))
+svint64_t svmullb_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u32)))
+svuint32_t svmullb_lane(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullb_lane_u64)))
+svuint64_t svmullb_lane(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s32)))
+svint32_t svmullt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s64)))
+svint64_t svmullt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_s16)))
+svint16_t svmullt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u32)))
+svuint32_t svmullt(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u64)))
+svuint64_t svmullt(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_n_u16)))
+svuint16_t svmullt(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s32)))
+svint32_t svmullt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s64)))
+svint64_t svmullt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_s16)))
+svint16_t svmullt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u32)))
+svuint32_t svmullt(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u64)))
+svuint64_t svmullt(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_u16)))
+svuint16_t svmullt(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s32)))
+svint32_t svmullt_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_s64)))
+svint64_t svmullt_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u32)))
+svuint32_t svmullt_lane(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmullt_lane_u64)))
+svuint64_t svmullt_lane(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u8)))
+svuint8_t svnbsl(svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u32)))
+svuint32_t svnbsl(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u64)))
+svuint64_t svnbsl(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_u16)))
+svuint16_t svnbsl(svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s8)))
+svint8_t svnbsl(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s32)))
+svint32_t svnbsl(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s64)))
+svint64_t svnbsl(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_n_s16)))
+svint16_t svnbsl(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u8)))
+svuint8_t svnbsl(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u32)))
+svuint32_t svnbsl(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u64)))
+svuint64_t svnbsl(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_u16)))
+svuint16_t svnbsl(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s8)))
+svint8_t svnbsl(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s32)))
+svint32_t svnbsl(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s64)))
+svint64_t svnbsl(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnbsl_s16)))
+svint16_t svnbsl(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_n_u8)))
+svuint8_t svpmul(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmul_u8)))
+svuint8_t svpmul(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u64)))
+svuint64_t svpmullb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_n_u16)))
+svuint16_t svpmullb(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u64)))
+svuint64_t svpmullb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_u16)))
+svuint16_t svpmullb(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u8)))
+svuint8_t svpmullb_pair(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_n_u32)))
+svuint32_t svpmullb_pair(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u8)))
+svuint8_t svpmullb_pair(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullb_pair_u32)))
+svuint32_t svpmullb_pair(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u64)))
+svuint64_t svpmullt(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_n_u16)))
+svuint16_t svpmullt(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u64)))
+svuint64_t svpmullt(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_u16)))
+svuint16_t svpmullt(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u8)))
+svuint8_t svpmullt_pair(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_n_u32)))
+svuint32_t svpmullt_pair(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u8)))
+svuint8_t svpmullt_pair(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpmullt_pair_u32)))
+svuint32_t svpmullt_pair(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_m)))
+svint8_t svqabs_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_m)))
+svint32_t svqabs_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_m)))
+svint64_t svqabs_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_m)))
+svint16_t svqabs_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_x)))
+svint8_t svqabs_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_x)))
+svint32_t svqabs_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_x)))
+svint64_t svqabs_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_x)))
+svint16_t svqabs_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s8_z)))
+svint8_t svqabs_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s32_z)))
+svint32_t svqabs_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s64_z)))
+svint64_t svqabs_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqabs_s16_z)))
+svint16_t svqabs_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_m)))
+svint8_t svqadd_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_m)))
+svint32_t svqadd_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_m)))
+svint64_t svqadd_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_m)))
+svint16_t svqadd_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_x)))
+svint8_t svqadd_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_x)))
+svint32_t svqadd_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_x)))
+svint64_t svqadd_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_x)))
+svint16_t svqadd_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8_z)))
+svint8_t svqadd_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32_z)))
+svint32_t svqadd_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64_z)))
+svint64_t svqadd_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16_z)))
+svint16_t svqadd_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_m)))
+svuint8_t svqadd_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_m)))
+svuint32_t svqadd_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_m)))
+svuint64_t svqadd_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_m)))
+svuint16_t svqadd_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_x)))
+svuint8_t svqadd_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_x)))
+svuint32_t svqadd_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_x)))
+svuint64_t svqadd_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_x)))
+svuint16_t svqadd_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8_z)))
+svuint8_t svqadd_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32_z)))
+svuint32_t svqadd_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64_z)))
+svuint64_t svqadd_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16_z)))
+svuint16_t svqadd_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_m)))
+svint8_t svqadd_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_m)))
+svint32_t svqadd_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_m)))
+svint64_t svqadd_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_m)))
+svint16_t svqadd_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_x)))
+svint8_t svqadd_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_x)))
+svint32_t svqadd_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_x)))
+svint64_t svqadd_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_x)))
+svint16_t svqadd_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8_z)))
+svint8_t svqadd_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32_z)))
+svint32_t svqadd_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64_z)))
+svint64_t svqadd_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16_z)))
+svint16_t svqadd_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_m)))
+svuint8_t svqadd_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_m)))
+svuint32_t svqadd_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_m)))
+svuint64_t svqadd_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_m)))
+svuint16_t svqadd_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_x)))
+svuint8_t svqadd_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_x)))
+svuint32_t svqadd_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_x)))
+svuint64_t svqadd_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_x)))
+svuint16_t svqadd_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8_z)))
+svuint8_t svqadd_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32_z)))
+svuint32_t svqadd_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64_z)))
+svuint64_t svqadd_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16_z)))
+svuint16_t svqadd_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s8)))
+svint8_t svqcadd(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s32)))
+svint32_t svqcadd(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s64)))
+svint64_t svqcadd(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqcadd_s16)))
+svint16_t svqcadd(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s32)))
+svint32_t svqdmlalb(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s64)))
+svint64_t svqdmlalb(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_n_s16)))
+svint16_t svqdmlalb(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s32)))
+svint32_t svqdmlalb(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s64)))
+svint64_t svqdmlalb(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_s16)))
+svint16_t svqdmlalb(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s32)))
+svint32_t svqdmlalb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalb_lane_s64)))
+svint64_t svqdmlalb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s32)))
+svint32_t svqdmlalbt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s64)))
+svint64_t svqdmlalbt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_n_s16)))
+svint16_t svqdmlalbt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s32)))
+svint32_t svqdmlalbt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s64)))
+svint64_t svqdmlalbt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalbt_s16)))
+svint16_t svqdmlalbt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s32)))
+svint32_t svqdmlalt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s64)))
+svint64_t svqdmlalt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_n_s16)))
+svint16_t svqdmlalt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s32)))
+svint32_t svqdmlalt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s64)))
+svint64_t svqdmlalt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_s16)))
+svint16_t svqdmlalt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s32)))
+svint32_t svqdmlalt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlalt_lane_s64)))
+svint64_t svqdmlalt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s32)))
+svint32_t svqdmlslb(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s64)))
+svint64_t svqdmlslb(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_n_s16)))
+svint16_t svqdmlslb(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s32)))
+svint32_t svqdmlslb(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s64)))
+svint64_t svqdmlslb(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_s16)))
+svint16_t svqdmlslb(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s32)))
+svint32_t svqdmlslb_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslb_lane_s64)))
+svint64_t svqdmlslb_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s32)))
+svint32_t svqdmlslbt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s64)))
+svint64_t svqdmlslbt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_n_s16)))
+svint16_t svqdmlslbt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s32)))
+svint32_t svqdmlslbt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s64)))
+svint64_t svqdmlslbt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslbt_s16)))
+svint16_t svqdmlslbt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s32)))
+svint32_t svqdmlslt(svint32_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s64)))
+svint64_t svqdmlslt(svint64_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_n_s16)))
+svint16_t svqdmlslt(svint16_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s32)))
+svint32_t svqdmlslt(svint32_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s64)))
+svint64_t svqdmlslt(svint64_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_s16)))
+svint16_t svqdmlslt(svint16_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s32)))
+svint32_t svqdmlslt_lane(svint32_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmlslt_lane_s64)))
+svint64_t svqdmlslt_lane(svint64_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s8)))
+svint8_t svqdmulh(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s32)))
+svint32_t svqdmulh(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s64)))
+svint64_t svqdmulh(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_n_s16)))
+svint16_t svqdmulh(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s8)))
+svint8_t svqdmulh(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s32)))
+svint32_t svqdmulh(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s64)))
+svint64_t svqdmulh(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_s16)))
+svint16_t svqdmulh(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s32)))
+svint32_t svqdmulh_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s64)))
+svint64_t svqdmulh_lane(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmulh_lane_s16)))
+svint16_t svqdmulh_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s32)))
+svint32_t svqdmullb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s64)))
+svint64_t svqdmullb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_n_s16)))
+svint16_t svqdmullb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s32)))
+svint32_t svqdmullb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s64)))
+svint64_t svqdmullb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_s16)))
+svint16_t svqdmullb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s32)))
+svint32_t svqdmullb_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullb_lane_s64)))
+svint64_t svqdmullb_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s32)))
+svint32_t svqdmullt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s64)))
+svint64_t svqdmullt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_n_s16)))
+svint16_t svqdmullt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s32)))
+svint32_t svqdmullt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s64)))
+svint64_t svqdmullt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_s16)))
+svint16_t svqdmullt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s32)))
+svint32_t svqdmullt_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdmullt_lane_s64)))
+svint64_t svqdmullt_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_m)))
+svint8_t svqneg_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_m)))
+svint32_t svqneg_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_m)))
+svint64_t svqneg_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_m)))
+svint16_t svqneg_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_x)))
+svint8_t svqneg_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_x)))
+svint32_t svqneg_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_x)))
+svint64_t svqneg_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_x)))
+svint16_t svqneg_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s8_z)))
+svint8_t svqneg_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s32_z)))
+svint32_t svqneg_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s64_z)))
+svint64_t svqneg_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqneg_s16_z)))
+svint16_t svqneg_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s8)))
+svint8_t svqrdcmlah(svint8_t, svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s32)))
+svint32_t svqrdcmlah(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s64)))
+svint64_t svqrdcmlah(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_s16)))
+svint16_t svqrdcmlah(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s32)))
+svint32_t svqrdcmlah_lane(svint32_t, svint32_t, svint32_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdcmlah_lane_s16)))
+svint16_t svqrdcmlah_lane(svint16_t, svint16_t, svint16_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s8)))
+svint8_t svqrdmlah(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s32)))
+svint32_t svqrdmlah(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s64)))
+svint64_t svqrdmlah(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_n_s16)))
+svint16_t svqrdmlah(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s8)))
+svint8_t svqrdmlah(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s32)))
+svint32_t svqrdmlah(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s64)))
+svint64_t svqrdmlah(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_s16)))
+svint16_t svqrdmlah(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s32)))
+svint32_t svqrdmlah_lane(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s64)))
+svint64_t svqrdmlah_lane(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlah_lane_s16)))
+svint16_t svqrdmlah_lane(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s8)))
+svint8_t svqrdmlsh(svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s32)))
+svint32_t svqrdmlsh(svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s64)))
+svint64_t svqrdmlsh(svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_n_s16)))
+svint16_t svqrdmlsh(svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s8)))
+svint8_t svqrdmlsh(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s32)))
+svint32_t svqrdmlsh(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s64)))
+svint64_t svqrdmlsh(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_s16)))
+svint16_t svqrdmlsh(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s32)))
+svint32_t svqrdmlsh_lane(svint32_t, svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s64)))
+svint64_t svqrdmlsh_lane(svint64_t, svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmlsh_lane_s16)))
+svint16_t svqrdmlsh_lane(svint16_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s8)))
+svint8_t svqrdmulh(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s32)))
+svint32_t svqrdmulh(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s64)))
+svint64_t svqrdmulh(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_n_s16)))
+svint16_t svqrdmulh(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s8)))
+svint8_t svqrdmulh(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s32)))
+svint32_t svqrdmulh(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s64)))
+svint64_t svqrdmulh(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_s16)))
+svint16_t svqrdmulh(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s32)))
+svint32_t svqrdmulh_lane(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s64)))
+svint64_t svqrdmulh_lane(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrdmulh_lane_s16)))
+svint16_t svqrdmulh_lane(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_m)))
+svint8_t svqrshl_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_m)))
+svint32_t svqrshl_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_m)))
+svint64_t svqrshl_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_m)))
+svint16_t svqrshl_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_x)))
+svint8_t svqrshl_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_x)))
+svint32_t svqrshl_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_x)))
+svint64_t svqrshl_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_x)))
+svint16_t svqrshl_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s8_z)))
+svint8_t svqrshl_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s32_z)))
+svint32_t svqrshl_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s64_z)))
+svint64_t svqrshl_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_s16_z)))
+svint16_t svqrshl_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_m)))
+svuint8_t svqrshl_m(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_m)))
+svuint32_t svqrshl_m(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_m)))
+svuint64_t svqrshl_m(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_m)))
+svuint16_t svqrshl_m(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_x)))
+svuint8_t svqrshl_x(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_x)))
+svuint32_t svqrshl_x(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_x)))
+svuint64_t svqrshl_x(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_x)))
+svuint16_t svqrshl_x(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u8_z)))
+svuint8_t svqrshl_z(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u32_z)))
+svuint32_t svqrshl_z(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u64_z)))
+svuint64_t svqrshl_z(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_n_u16_z)))
+svuint16_t svqrshl_z(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_m)))
+svint8_t svqrshl_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_m)))
+svint32_t svqrshl_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_m)))
+svint64_t svqrshl_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_m)))
+svint16_t svqrshl_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_x)))
+svint8_t svqrshl_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_x)))
+svint32_t svqrshl_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_x)))
+svint64_t svqrshl_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_x)))
+svint16_t svqrshl_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s8_z)))
+svint8_t svqrshl_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s32_z)))
+svint32_t svqrshl_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s64_z)))
+svint64_t svqrshl_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_s16_z)))
+svint16_t svqrshl_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_m)))
+svuint8_t svqrshl_m(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_m)))
+svuint32_t svqrshl_m(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_m)))
+svuint64_t svqrshl_m(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_m)))
+svuint16_t svqrshl_m(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_x)))
+svuint8_t svqrshl_x(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_x)))
+svuint32_t svqrshl_x(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_x)))
+svuint64_t svqrshl_x(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_x)))
+svuint16_t svqrshl_x(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u8_z)))
+svuint8_t svqrshl_z(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u32_z)))
+svuint32_t svqrshl_z(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u64_z)))
+svuint64_t svqrshl_z(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshl_u16_z)))
+svuint16_t svqrshl_z(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s32)))
+svint16_t svqrshrnb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s64)))
+svint32_t svqrshrnb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_s16)))
+svint8_t svqrshrnb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u32)))
+svuint16_t svqrshrnb(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u64)))
+svuint32_t svqrshrnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnb_n_u16)))
+svuint8_t svqrshrnb(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s32)))
+svint16_t svqrshrnt(svint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s64)))
+svint32_t svqrshrnt(svint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_s16)))
+svint8_t svqrshrnt(svint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u32)))
+svuint16_t svqrshrnt(svuint16_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u64)))
+svuint32_t svqrshrnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrnt_n_u16)))
+svuint8_t svqrshrnt(svuint8_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s32)))
+svuint16_t svqrshrunb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s64)))
+svuint32_t svqrshrunb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunb_n_s16)))
+svuint8_t svqrshrunb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s32)))
+svuint16_t svqrshrunt(svuint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s64)))
+svuint32_t svqrshrunt(svuint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqrshrunt_n_s16)))
+svuint8_t svqrshrunt(svuint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_m)))
+svint8_t svqshl_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_m)))
+svint32_t svqshl_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_m)))
+svint64_t svqshl_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_m)))
+svint16_t svqshl_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_x)))
+svint8_t svqshl_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_x)))
+svint32_t svqshl_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_x)))
+svint64_t svqshl_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_x)))
+svint16_t svqshl_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s8_z)))
+svint8_t svqshl_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s32_z)))
+svint32_t svqshl_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s64_z)))
+svint64_t svqshl_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_s16_z)))
+svint16_t svqshl_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_m)))
+svuint8_t svqshl_m(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_m)))
+svuint32_t svqshl_m(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_m)))
+svuint64_t svqshl_m(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_m)))
+svuint16_t svqshl_m(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_x)))
+svuint8_t svqshl_x(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_x)))
+svuint32_t svqshl_x(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_x)))
+svuint64_t svqshl_x(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_x)))
+svuint16_t svqshl_x(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u8_z)))
+svuint8_t svqshl_z(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u32_z)))
+svuint32_t svqshl_z(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u64_z)))
+svuint64_t svqshl_z(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_n_u16_z)))
+svuint16_t svqshl_z(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_m)))
+svint8_t svqshl_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_m)))
+svint32_t svqshl_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_m)))
+svint64_t svqshl_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_m)))
+svint16_t svqshl_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_x)))
+svint8_t svqshl_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_x)))
+svint32_t svqshl_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_x)))
+svint64_t svqshl_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_x)))
+svint16_t svqshl_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s8_z)))
+svint8_t svqshl_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s32_z)))
+svint32_t svqshl_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s64_z)))
+svint64_t svqshl_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_s16_z)))
+svint16_t svqshl_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_m)))
+svuint8_t svqshl_m(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_m)))
+svuint32_t svqshl_m(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_m)))
+svuint64_t svqshl_m(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_m)))
+svuint16_t svqshl_m(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_x)))
+svuint8_t svqshl_x(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_x)))
+svuint32_t svqshl_x(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_x)))
+svuint64_t svqshl_x(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_x)))
+svuint16_t svqshl_x(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u8_z)))
+svuint8_t svqshl_z(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u32_z)))
+svuint32_t svqshl_z(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u64_z)))
+svuint64_t svqshl_z(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshl_u16_z)))
+svuint16_t svqshl_z(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_m)))
+svuint8_t svqshlu_m(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_m)))
+svuint32_t svqshlu_m(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_m)))
+svuint64_t svqshlu_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_m)))
+svuint16_t svqshlu_m(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_x)))
+svuint8_t svqshlu_x(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_x)))
+svuint32_t svqshlu_x(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_x)))
+svuint64_t svqshlu_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_x)))
+svuint16_t svqshlu_x(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s8_z)))
+svuint8_t svqshlu_z(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s32_z)))
+svuint32_t svqshlu_z(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s64_z)))
+svuint64_t svqshlu_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshlu_n_s16_z)))
+svuint16_t svqshlu_z(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s32)))
+svint16_t svqshrnb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s64)))
+svint32_t svqshrnb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_s16)))
+svint8_t svqshrnb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u32)))
+svuint16_t svqshrnb(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u64)))
+svuint32_t svqshrnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnb_n_u16)))
+svuint8_t svqshrnb(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s32)))
+svint16_t svqshrnt(svint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s64)))
+svint32_t svqshrnt(svint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_s16)))
+svint8_t svqshrnt(svint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u32)))
+svuint16_t svqshrnt(svuint16_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u64)))
+svuint32_t svqshrnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrnt_n_u16)))
+svuint8_t svqshrnt(svuint8_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s32)))
+svuint16_t svqshrunb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s64)))
+svuint32_t svqshrunb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunb_n_s16)))
+svuint8_t svqshrunb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s32)))
+svuint16_t svqshrunt(svuint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s64)))
+svuint32_t svqshrunt(svuint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqshrunt_n_s16)))
+svuint8_t svqshrunt(svuint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_m)))
+svint8_t svqsub_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_m)))
+svint32_t svqsub_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_m)))
+svint64_t svqsub_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_m)))
+svint16_t svqsub_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_x)))
+svint8_t svqsub_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_x)))
+svint32_t svqsub_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_x)))
+svint64_t svqsub_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_x)))
+svint16_t svqsub_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8_z)))
+svint8_t svqsub_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32_z)))
+svint32_t svqsub_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64_z)))
+svint64_t svqsub_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16_z)))
+svint16_t svqsub_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_m)))
+svuint8_t svqsub_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_m)))
+svuint32_t svqsub_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_m)))
+svuint64_t svqsub_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_m)))
+svuint16_t svqsub_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_x)))
+svuint8_t svqsub_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_x)))
+svuint32_t svqsub_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_x)))
+svuint64_t svqsub_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_x)))
+svuint16_t svqsub_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8_z)))
+svuint8_t svqsub_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32_z)))
+svuint32_t svqsub_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64_z)))
+svuint64_t svqsub_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16_z)))
+svuint16_t svqsub_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_m)))
+svint8_t svqsub_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_m)))
+svint32_t svqsub_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_m)))
+svint64_t svqsub_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_m)))
+svint16_t svqsub_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_x)))
+svint8_t svqsub_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_x)))
+svint32_t svqsub_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_x)))
+svint64_t svqsub_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_x)))
+svint16_t svqsub_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8_z)))
+svint8_t svqsub_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32_z)))
+svint32_t svqsub_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64_z)))
+svint64_t svqsub_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16_z)))
+svint16_t svqsub_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_m)))
+svuint8_t svqsub_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_m)))
+svuint32_t svqsub_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_m)))
+svuint64_t svqsub_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_m)))
+svuint16_t svqsub_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_x)))
+svuint8_t svqsub_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_x)))
+svuint32_t svqsub_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_x)))
+svuint64_t svqsub_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_x)))
+svuint16_t svqsub_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8_z)))
+svuint8_t svqsub_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32_z)))
+svuint32_t svqsub_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64_z)))
+svuint64_t svqsub_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16_z)))
+svuint16_t svqsub_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_m)))
+svint8_t svqsubr_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_m)))
+svint32_t svqsubr_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_m)))
+svint64_t svqsubr_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_m)))
+svint16_t svqsubr_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_x)))
+svint8_t svqsubr_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_x)))
+svint32_t svqsubr_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_x)))
+svint64_t svqsubr_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_x)))
+svint16_t svqsubr_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s8_z)))
+svint8_t svqsubr_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s32_z)))
+svint32_t svqsubr_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s64_z)))
+svint64_t svqsubr_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_s16_z)))
+svint16_t svqsubr_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_m)))
+svuint8_t svqsubr_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_m)))
+svuint32_t svqsubr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_m)))
+svuint64_t svqsubr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_m)))
+svuint16_t svqsubr_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_x)))
+svuint8_t svqsubr_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_x)))
+svuint32_t svqsubr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_x)))
+svuint64_t svqsubr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_x)))
+svuint16_t svqsubr_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u8_z)))
+svuint8_t svqsubr_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u32_z)))
+svuint32_t svqsubr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u64_z)))
+svuint64_t svqsubr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_n_u16_z)))
+svuint16_t svqsubr_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_m)))
+svint8_t svqsubr_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_m)))
+svint32_t svqsubr_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_m)))
+svint64_t svqsubr_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_m)))
+svint16_t svqsubr_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_x)))
+svint8_t svqsubr_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_x)))
+svint32_t svqsubr_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_x)))
+svint64_t svqsubr_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_x)))
+svint16_t svqsubr_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s8_z)))
+svint8_t svqsubr_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s32_z)))
+svint32_t svqsubr_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s64_z)))
+svint64_t svqsubr_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_s16_z)))
+svint16_t svqsubr_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_m)))
+svuint8_t svqsubr_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_m)))
+svuint32_t svqsubr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_m)))
+svuint64_t svqsubr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_m)))
+svuint16_t svqsubr_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_x)))
+svuint8_t svqsubr_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_x)))
+svuint32_t svqsubr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_x)))
+svuint64_t svqsubr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_x)))
+svuint16_t svqsubr_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u8_z)))
+svuint8_t svqsubr_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u32_z)))
+svuint32_t svqsubr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u64_z)))
+svuint64_t svqsubr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsubr_u16_z)))
+svuint16_t svqsubr_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s32)))
+svint16_t svqxtnb(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s64)))
+svint32_t svqxtnb(svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_s16)))
+svint8_t svqxtnb(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u32)))
+svuint16_t svqxtnb(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u64)))
+svuint32_t svqxtnb(svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnb_u16)))
+svuint8_t svqxtnb(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s32)))
+svint16_t svqxtnt(svint16_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s64)))
+svint32_t svqxtnt(svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_s16)))
+svint8_t svqxtnt(svint8_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u32)))
+svuint16_t svqxtnt(svuint16_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u64)))
+svuint32_t svqxtnt(svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtnt_u16)))
+svuint8_t svqxtnt(svuint8_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s32)))
+svuint16_t svqxtunb(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s64)))
+svuint32_t svqxtunb(svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunb_s16)))
+svuint8_t svqxtunb(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s32)))
+svuint16_t svqxtunt(svuint16_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s64)))
+svuint32_t svqxtunt(svuint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqxtunt_s16)))
+svuint8_t svqxtunt(svuint8_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u32)))
+svuint16_t svraddhnb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u64)))
+svuint32_t svraddhnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_u16)))
+svuint8_t svraddhnb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s32)))
+svint16_t svraddhnb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s64)))
+svint32_t svraddhnb(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_n_s16)))
+svint8_t svraddhnb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u32)))
+svuint16_t svraddhnb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u64)))
+svuint32_t svraddhnb(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_u16)))
+svuint8_t svraddhnb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s32)))
+svint16_t svraddhnb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s64)))
+svint32_t svraddhnb(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnb_s16)))
+svint8_t svraddhnb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u32)))
+svuint16_t svraddhnt(svuint16_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u64)))
+svuint32_t svraddhnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_u16)))
+svuint8_t svraddhnt(svuint8_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s32)))
+svint16_t svraddhnt(svint16_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s64)))
+svint32_t svraddhnt(svint32_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_n_s16)))
+svint8_t svraddhnt(svint8_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u32)))
+svuint16_t svraddhnt(svuint16_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u64)))
+svuint32_t svraddhnt(svuint32_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_u16)))
+svuint8_t svraddhnt(svuint8_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s32)))
+svint16_t svraddhnt(svint16_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s64)))
+svint32_t svraddhnt(svint32_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svraddhnt_s16)))
+svint8_t svraddhnt(svint8_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_m)))
+svuint32_t svrecpe_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_x)))
+svuint32_t svrecpe_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_u32_z)))
+svuint32_t svrecpe_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_m)))
+svint8_t svrhadd_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_m)))
+svint32_t svrhadd_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_m)))
+svint64_t svrhadd_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_m)))
+svint16_t svrhadd_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_x)))
+svint8_t svrhadd_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_x)))
+svint32_t svrhadd_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_x)))
+svint64_t svrhadd_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_x)))
+svint16_t svrhadd_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s8_z)))
+svint8_t svrhadd_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s32_z)))
+svint32_t svrhadd_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s64_z)))
+svint64_t svrhadd_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_s16_z)))
+svint16_t svrhadd_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_m)))
+svuint8_t svrhadd_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_m)))
+svuint32_t svrhadd_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_m)))
+svuint64_t svrhadd_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_m)))
+svuint16_t svrhadd_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_x)))
+svuint8_t svrhadd_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_x)))
+svuint32_t svrhadd_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_x)))
+svuint64_t svrhadd_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_x)))
+svuint16_t svrhadd_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u8_z)))
+svuint8_t svrhadd_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u32_z)))
+svuint32_t svrhadd_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u64_z)))
+svuint64_t svrhadd_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_n_u16_z)))
+svuint16_t svrhadd_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_m)))
+svint8_t svrhadd_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_m)))
+svint32_t svrhadd_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_m)))
+svint64_t svrhadd_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_m)))
+svint16_t svrhadd_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_x)))
+svint8_t svrhadd_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_x)))
+svint32_t svrhadd_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_x)))
+svint64_t svrhadd_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_x)))
+svint16_t svrhadd_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s8_z)))
+svint8_t svrhadd_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s32_z)))
+svint32_t svrhadd_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s64_z)))
+svint64_t svrhadd_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_s16_z)))
+svint16_t svrhadd_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_m)))
+svuint8_t svrhadd_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_m)))
+svuint32_t svrhadd_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_m)))
+svuint64_t svrhadd_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_m)))
+svuint16_t svrhadd_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_x)))
+svuint8_t svrhadd_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_x)))
+svuint32_t svrhadd_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_x)))
+svuint64_t svrhadd_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_x)))
+svuint16_t svrhadd_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u8_z)))
+svuint8_t svrhadd_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u32_z)))
+svuint32_t svrhadd_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u64_z)))
+svuint64_t svrhadd_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrhadd_u16_z)))
+svuint16_t svrhadd_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_m)))
+svint8_t svrshl_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_m)))
+svint32_t svrshl_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_m)))
+svint64_t svrshl_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_m)))
+svint16_t svrshl_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_x)))
+svint8_t svrshl_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_x)))
+svint32_t svrshl_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_x)))
+svint64_t svrshl_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_x)))
+svint16_t svrshl_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s8_z)))
+svint8_t svrshl_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s32_z)))
+svint32_t svrshl_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s64_z)))
+svint64_t svrshl_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_s16_z)))
+svint16_t svrshl_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_m)))
+svuint8_t svrshl_m(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_m)))
+svuint32_t svrshl_m(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_m)))
+svuint64_t svrshl_m(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_m)))
+svuint16_t svrshl_m(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_x)))
+svuint8_t svrshl_x(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_x)))
+svuint32_t svrshl_x(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_x)))
+svuint64_t svrshl_x(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_x)))
+svuint16_t svrshl_x(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u8_z)))
+svuint8_t svrshl_z(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u32_z)))
+svuint32_t svrshl_z(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u64_z)))
+svuint64_t svrshl_z(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_n_u16_z)))
+svuint16_t svrshl_z(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_m)))
+svint8_t svrshl_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_m)))
+svint32_t svrshl_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_m)))
+svint64_t svrshl_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_m)))
+svint16_t svrshl_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_x)))
+svint8_t svrshl_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_x)))
+svint32_t svrshl_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_x)))
+svint64_t svrshl_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_x)))
+svint16_t svrshl_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s8_z)))
+svint8_t svrshl_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s32_z)))
+svint32_t svrshl_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s64_z)))
+svint64_t svrshl_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_s16_z)))
+svint16_t svrshl_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_m)))
+svuint8_t svrshl_m(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_m)))
+svuint32_t svrshl_m(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_m)))
+svuint64_t svrshl_m(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_m)))
+svuint16_t svrshl_m(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_x)))
+svuint8_t svrshl_x(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_x)))
+svuint32_t svrshl_x(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_x)))
+svuint64_t svrshl_x(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_x)))
+svuint16_t svrshl_x(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u8_z)))
+svuint8_t svrshl_z(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u32_z)))
+svuint32_t svrshl_z(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u64_z)))
+svuint64_t svrshl_z(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshl_u16_z)))
+svuint16_t svrshl_z(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_m)))
+svint8_t svrshr_m(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_m)))
+svint32_t svrshr_m(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_m)))
+svint64_t svrshr_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_m)))
+svint16_t svrshr_m(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_m)))
+svuint8_t svrshr_m(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_m)))
+svuint32_t svrshr_m(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_m)))
+svuint64_t svrshr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_m)))
+svuint16_t svrshr_m(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_x)))
+svint8_t svrshr_x(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_x)))
+svint32_t svrshr_x(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_x)))
+svint64_t svrshr_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_x)))
+svint16_t svrshr_x(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_x)))
+svuint8_t svrshr_x(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_x)))
+svuint32_t svrshr_x(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_x)))
+svuint64_t svrshr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_x)))
+svuint16_t svrshr_x(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s8_z)))
+svint8_t svrshr_z(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s32_z)))
+svint32_t svrshr_z(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s64_z)))
+svint64_t svrshr_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_s16_z)))
+svint16_t svrshr_z(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u8_z)))
+svuint8_t svrshr_z(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u32_z)))
+svuint32_t svrshr_z(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u64_z)))
+svuint64_t svrshr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshr_n_u16_z)))
+svuint16_t svrshr_z(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u32)))
+svuint16_t svrshrnb(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u64)))
+svuint32_t svrshrnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_u16)))
+svuint8_t svrshrnb(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s32)))
+svint16_t svrshrnb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s64)))
+svint32_t svrshrnb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnb_n_s16)))
+svint8_t svrshrnb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u32)))
+svuint16_t svrshrnt(svuint16_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u64)))
+svuint32_t svrshrnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_u16)))
+svuint8_t svrshrnt(svuint8_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s32)))
+svint16_t svrshrnt(svint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s64)))
+svint32_t svrshrnt(svint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrshrnt_n_s16)))
+svint8_t svrshrnt(svint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_m)))
+svuint32_t svrsqrte_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_x)))
+svuint32_t svrsqrte_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_u32_z)))
+svuint32_t svrsqrte_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s8)))
+svint8_t svrsra(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s32)))
+svint32_t svrsra(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s64)))
+svint64_t svrsra(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_s16)))
+svint16_t svrsra(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u8)))
+svuint8_t svrsra(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u32)))
+svuint32_t svrsra(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u64)))
+svuint64_t svrsra(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsra_n_u16)))
+svuint16_t svrsra(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u32)))
+svuint16_t svrsubhnb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u64)))
+svuint32_t svrsubhnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_u16)))
+svuint8_t svrsubhnb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s32)))
+svint16_t svrsubhnb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s64)))
+svint32_t svrsubhnb(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_n_s16)))
+svint8_t svrsubhnb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u32)))
+svuint16_t svrsubhnb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u64)))
+svuint32_t svrsubhnb(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_u16)))
+svuint8_t svrsubhnb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s32)))
+svint16_t svrsubhnb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s64)))
+svint32_t svrsubhnb(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnb_s16)))
+svint8_t svrsubhnb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u32)))
+svuint16_t svrsubhnt(svuint16_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u64)))
+svuint32_t svrsubhnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_u16)))
+svuint8_t svrsubhnt(svuint8_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s32)))
+svint16_t svrsubhnt(svint16_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s64)))
+svint32_t svrsubhnt(svint32_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_n_s16)))
+svint8_t svrsubhnt(svint8_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u32)))
+svuint16_t svrsubhnt(svuint16_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u64)))
+svuint32_t svrsubhnt(svuint32_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_u16)))
+svuint8_t svrsubhnt(svuint8_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s32)))
+svint16_t svrsubhnt(svint16_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s64)))
+svint32_t svrsubhnt(svint32_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsubhnt_s16)))
+svint8_t svrsubhnt(svint8_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u32)))
+svuint32_t svsbclb(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_n_u64)))
+svuint64_t svsbclb(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u32)))
+svuint32_t svsbclb(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclb_u64)))
+svuint64_t svsbclb(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u32)))
+svuint32_t svsbclt(svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_n_u64)))
+svuint64_t svsbclt(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u32)))
+svuint32_t svsbclt(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsbclt_u64)))
+svuint64_t svsbclt(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s32)))
+svint32_t svshllb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s64)))
+svint64_t svshllb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_s16)))
+svint16_t svshllb(svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u32)))
+svuint32_t svshllb(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u64)))
+svuint64_t svshllb(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllb_n_u16)))
+svuint16_t svshllb(svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s32)))
+svint32_t svshllt(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s64)))
+svint64_t svshllt(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_s16)))
+svint16_t svshllt(svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u32)))
+svuint32_t svshllt(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u64)))
+svuint64_t svshllt(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshllt_n_u16)))
+svuint16_t svshllt(svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u32)))
+svuint16_t svshrnb(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u64)))
+svuint32_t svshrnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_u16)))
+svuint8_t svshrnb(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s32)))
+svint16_t svshrnb(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s64)))
+svint32_t svshrnb(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnb_n_s16)))
+svint8_t svshrnb(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u32)))
+svuint16_t svshrnt(svuint16_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u64)))
+svuint32_t svshrnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_u16)))
+svuint8_t svshrnt(svuint8_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s32)))
+svint16_t svshrnt(svint16_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s64)))
+svint32_t svshrnt(svint32_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svshrnt_n_s16)))
+svint8_t svshrnt(svint8_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u8)))
+svuint8_t svsli(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u32)))
+svuint32_t svsli(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u64)))
+svuint64_t svsli(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_u16)))
+svuint16_t svsli(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s8)))
+svint8_t svsli(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s32)))
+svint32_t svsli(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s64)))
+svint64_t svsli(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsli_n_s16)))
+svint16_t svsli(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_m)))
+svuint8_t svsqadd_m(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_m)))
+svuint32_t svsqadd_m(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_m)))
+svuint64_t svsqadd_m(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_m)))
+svuint16_t svsqadd_m(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_x)))
+svuint8_t svsqadd_x(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_x)))
+svuint32_t svsqadd_x(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_x)))
+svuint64_t svsqadd_x(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_x)))
+svuint16_t svsqadd_x(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u8_z)))
+svuint8_t svsqadd_z(svbool_t, svuint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u32_z)))
+svuint32_t svsqadd_z(svbool_t, svuint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u64_z)))
+svuint64_t svsqadd_z(svbool_t, svuint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_n_u16_z)))
+svuint16_t svsqadd_z(svbool_t, svuint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_m)))
+svuint8_t svsqadd_m(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_m)))
+svuint32_t svsqadd_m(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_m)))
+svuint64_t svsqadd_m(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_m)))
+svuint16_t svsqadd_m(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_x)))
+svuint8_t svsqadd_x(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_x)))
+svuint32_t svsqadd_x(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_x)))
+svuint64_t svsqadd_x(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_x)))
+svuint16_t svsqadd_x(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u8_z)))
+svuint8_t svsqadd_z(svbool_t, svuint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u32_z)))
+svuint32_t svsqadd_z(svbool_t, svuint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u64_z)))
+svuint64_t svsqadd_z(svbool_t, svuint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqadd_u16_z)))
+svuint16_t svsqadd_z(svbool_t, svuint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s8)))
+svint8_t svsra(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s32)))
+svint32_t svsra(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s64)))
+svint64_t svsra(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_s16)))
+svint16_t svsra(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u8)))
+svuint8_t svsra(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u32)))
+svuint32_t svsra(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u64)))
+svuint64_t svsra(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsra_n_u16)))
+svuint16_t svsra(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u8)))
+svuint8_t svsri(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u32)))
+svuint32_t svsri(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u64)))
+svuint64_t svsri(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_u16)))
+svuint16_t svsri(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s8)))
+svint8_t svsri(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s32)))
+svint32_t svsri(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s64)))
+svint64_t svsri(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsri_n_s16)))
+svint16_t svsri(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u32)))
+svuint16_t svsubhnb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u64)))
+svuint32_t svsubhnb(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_u16)))
+svuint8_t svsubhnb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s32)))
+svint16_t svsubhnb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s64)))
+svint32_t svsubhnb(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_n_s16)))
+svint8_t svsubhnb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u32)))
+svuint16_t svsubhnb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u64)))
+svuint32_t svsubhnb(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_u16)))
+svuint8_t svsubhnb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s32)))
+svint16_t svsubhnb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s64)))
+svint32_t svsubhnb(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnb_s16)))
+svint8_t svsubhnb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u32)))
+svuint16_t svsubhnt(svuint16_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u64)))
+svuint32_t svsubhnt(svuint32_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_u16)))
+svuint8_t svsubhnt(svuint8_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s32)))
+svint16_t svsubhnt(svint16_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s64)))
+svint32_t svsubhnt(svint32_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_n_s16)))
+svint8_t svsubhnt(svint8_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u32)))
+svuint16_t svsubhnt(svuint16_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u64)))
+svuint32_t svsubhnt(svuint32_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_u16)))
+svuint8_t svsubhnt(svuint8_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s32)))
+svint16_t svsubhnt(svint16_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s64)))
+svint32_t svsubhnt(svint32_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubhnt_s16)))
+svint8_t svsubhnt(svint8_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s32)))
+svint32_t svsublb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s64)))
+svint64_t svsublb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_s16)))
+svint16_t svsublb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u32)))
+svuint32_t svsublb(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u64)))
+svuint64_t svsublb(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_n_u16)))
+svuint16_t svsublb(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s32)))
+svint32_t svsublb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s64)))
+svint64_t svsublb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_s16)))
+svint16_t svsublb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u32)))
+svuint32_t svsublb(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u64)))
+svuint64_t svsublb(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublb_u16)))
+svuint16_t svsublb(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s32)))
+svint32_t svsublbt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s64)))
+svint64_t svsublbt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_n_s16)))
+svint16_t svsublbt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s32)))
+svint32_t svsublbt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s64)))
+svint64_t svsublbt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublbt_s16)))
+svint16_t svsublbt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s32)))
+svint32_t svsublt(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s64)))
+svint64_t svsublt(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_s16)))
+svint16_t svsublt(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u32)))
+svuint32_t svsublt(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u64)))
+svuint64_t svsublt(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_n_u16)))
+svuint16_t svsublt(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s32)))
+svint32_t svsublt(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s64)))
+svint64_t svsublt(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_s16)))
+svint16_t svsublt(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u32)))
+svuint32_t svsublt(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u64)))
+svuint64_t svsublt(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsublt_u16)))
+svuint16_t svsublt(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s32)))
+svint32_t svsubltb(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s64)))
+svint64_t svsubltb(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_n_s16)))
+svint16_t svsubltb(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s32)))
+svint32_t svsubltb(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s64)))
+svint64_t svsubltb(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubltb_s16)))
+svint16_t svsubltb(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s32)))
+svint32_t svsubwb(svint32_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s64)))
+svint64_t svsubwb(svint64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_s16)))
+svint16_t svsubwb(svint16_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u32)))
+svuint32_t svsubwb(svuint32_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u64)))
+svuint64_t svsubwb(svuint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_n_u16)))
+svuint16_t svsubwb(svuint16_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s32)))
+svint32_t svsubwb(svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s64)))
+svint64_t svsubwb(svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_s16)))
+svint16_t svsubwb(svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u32)))
+svuint32_t svsubwb(svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u64)))
+svuint64_t svsubwb(svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwb_u16)))
+svuint16_t svsubwb(svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s32)))
+svint32_t svsubwt(svint32_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s64)))
+svint64_t svsubwt(svint64_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_s16)))
+svint16_t svsubwt(svint16_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u32)))
+svuint32_t svsubwt(svuint32_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u64)))
+svuint64_t svsubwt(svuint64_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_n_u16)))
+svuint16_t svsubwt(svuint16_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s32)))
+svint32_t svsubwt(svint32_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s64)))
+svint64_t svsubwt(svint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_s16)))
+svint16_t svsubwt(svint16_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u32)))
+svuint32_t svsubwt(svuint32_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u64)))
+svuint64_t svsubwt(svuint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubwt_u16)))
+svuint16_t svsubwt(svuint16_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u8)))
+svuint8_t svtbl2(svuint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u32)))
+svuint32_t svtbl2(svuint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u64)))
+svuint64_t svtbl2(svuint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_u16)))
+svuint16_t svtbl2(svuint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s8)))
+svint8_t svtbl2(svint8x2_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f64)))
+svfloat64_t svtbl2(svfloat64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f32)))
+svfloat32_t svtbl2(svfloat32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_f16)))
+svfloat16_t svtbl2(svfloat16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s32)))
+svint32_t svtbl2(svint32x2_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s64)))
+svint64_t svtbl2(svint64x2_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl2_s16)))
+svint16_t svtbl2(svint16x2_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u8)))
+svuint8_t svtbx(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u32)))
+svuint32_t svtbx(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u64)))
+svuint64_t svtbx(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_u16)))
+svuint16_t svtbx(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s8)))
+svint8_t svtbx(svint8_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f64)))
+svfloat64_t svtbx(svfloat64_t, svfloat64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f32)))
+svfloat32_t svtbx(svfloat32_t, svfloat32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_f16)))
+svfloat16_t svtbx(svfloat16_t, svfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s32)))
+svint32_t svtbx(svint32_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s64)))
+svint64_t svtbx(svint64_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbx_s16)))
+svint16_t svtbx(svint16_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_m)))
+svint8_t svuqadd_m(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_m)))
+svint32_t svuqadd_m(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_m)))
+svint64_t svuqadd_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_m)))
+svint16_t svuqadd_m(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_x)))
+svint8_t svuqadd_x(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_x)))
+svint32_t svuqadd_x(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_x)))
+svint64_t svuqadd_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_x)))
+svint16_t svuqadd_x(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s8_z)))
+svint8_t svuqadd_z(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s32_z)))
+svint32_t svuqadd_z(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s64_z)))
+svint64_t svuqadd_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_n_s16_z)))
+svint16_t svuqadd_z(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_m)))
+svint8_t svuqadd_m(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_m)))
+svint32_t svuqadd_m(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_m)))
+svint64_t svuqadd_m(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_m)))
+svint16_t svuqadd_m(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_x)))
+svint8_t svuqadd_x(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_x)))
+svint32_t svuqadd_x(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_x)))
+svint64_t svuqadd_x(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_x)))
+svint16_t svuqadd_x(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s8_z)))
+svint8_t svuqadd_z(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s32_z)))
+svint32_t svuqadd_z(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s64_z)))
+svint64_t svuqadd_z(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuqadd_s16_z)))
+svint16_t svuqadd_z(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s32)))
+svbool_t svwhilege_b8(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s32)))
+svbool_t svwhilege_b32(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s32)))
+svbool_t svwhilege_b64(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s32)))
+svbool_t svwhilege_b16(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_s64)))
+svbool_t svwhilege_b8(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_s64)))
+svbool_t svwhilege_b32(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_s64)))
+svbool_t svwhilege_b64(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_s64)))
+svbool_t svwhilege_b16(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u32)))
+svbool_t svwhilege_b8(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u32)))
+svbool_t svwhilege_b32(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u32)))
+svbool_t svwhilege_b64(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u32)))
+svbool_t svwhilege_b16(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b8_u64)))
+svbool_t svwhilege_b8(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b32_u64)))
+svbool_t svwhilege_b32(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b64_u64)))
+svbool_t svwhilege_b64(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilege_b16_u64)))
+svbool_t svwhilege_b16(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s32)))
+svbool_t svwhilegt_b8(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s32)))
+svbool_t svwhilegt_b32(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s32)))
+svbool_t svwhilegt_b64(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s32)))
+svbool_t svwhilegt_b16(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_s64)))
+svbool_t svwhilegt_b8(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_s64)))
+svbool_t svwhilegt_b32(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_s64)))
+svbool_t svwhilegt_b64(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_s64)))
+svbool_t svwhilegt_b16(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u32)))
+svbool_t svwhilegt_b8(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u32)))
+svbool_t svwhilegt_b32(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u32)))
+svbool_t svwhilegt_b64(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u32)))
+svbool_t svwhilegt_b16(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b8_u64)))
+svbool_t svwhilegt_b8(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b32_u64)))
+svbool_t svwhilegt_b32(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b64_u64)))
+svbool_t svwhilegt_b64(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilegt_b16_u64)))
+svbool_t svwhilegt_b16(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u8)))
+svbool_t svwhilerw(uint8_t const *, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s8)))
+svbool_t svwhilerw(int8_t const *, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u64)))
+svbool_t svwhilerw(uint64_t const *, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f64)))
+svbool_t svwhilerw(float64_t const *, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s64)))
+svbool_t svwhilerw(int64_t const *, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u16)))
+svbool_t svwhilerw(uint16_t const *, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f16)))
+svbool_t svwhilerw(float16_t const *, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s16)))
+svbool_t svwhilerw(int16_t const *, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_u32)))
+svbool_t svwhilerw(uint32_t const *, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_f32)))
+svbool_t svwhilerw(float32_t const *, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilerw_s32)))
+svbool_t svwhilerw(int32_t const *, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u8)))
+svbool_t svwhilewr(uint8_t const *, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s8)))
+svbool_t svwhilewr(int8_t const *, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u64)))
+svbool_t svwhilewr(uint64_t const *, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f64)))
+svbool_t svwhilewr(float64_t const *, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s64)))
+svbool_t svwhilewr(int64_t const *, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u16)))
+svbool_t svwhilewr(uint16_t const *, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f16)))
+svbool_t svwhilewr(float16_t const *, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s16)))
+svbool_t svwhilewr(int16_t const *, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_u32)))
+svbool_t svwhilewr(uint32_t const *, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_f32)))
+svbool_t svwhilewr(float32_t const *, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilewr_s32)))
+svbool_t svwhilewr(int32_t const *, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u8)))
+svuint8_t svxar(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u32)))
+svuint32_t svxar(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u64)))
+svuint64_t svxar(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_u16)))
+svuint16_t svxar(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s8)))
+svint8_t svxar(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s32)))
+svint32_t svxar(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s64)))
+svint64_t svxar(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svxar_n_s16)))
+svint16_t svxar(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_m)))
+svfloat64_t svabd_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_m)))
+svfloat32_t svabd_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_m)))
+svfloat16_t svabd_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_x)))
+svfloat64_t svabd_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_x)))
+svfloat32_t svabd_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_x)))
+svfloat16_t svabd_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_z)))
+svfloat64_t svabd_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_z)))
+svfloat32_t svabd_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_z)))
+svfloat16_t svabd_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_m)))
+svint8_t svabd_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_m)))
+svint32_t svabd_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_m)))
+svint64_t svabd_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_m)))
+svint16_t svabd_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_x)))
+svint8_t svabd_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_x)))
+svint32_t svabd_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_x)))
+svint64_t svabd_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_x)))
+svint16_t svabd_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_z)))
+svint8_t svabd_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_z)))
+svint32_t svabd_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_z)))
+svint64_t svabd_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_z)))
+svint16_t svabd_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_m)))
+svuint8_t svabd_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_m)))
+svuint32_t svabd_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_m)))
+svuint64_t svabd_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_m)))
+svuint16_t svabd_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_x)))
+svuint8_t svabd_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_x)))
+svuint32_t svabd_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_x)))
+svuint64_t svabd_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_x)))
+svuint16_t svabd_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_z)))
+svuint8_t svabd_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_z)))
+svuint32_t svabd_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_z)))
+svuint64_t svabd_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_z)))
+svuint16_t svabd_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_m)))
+svfloat64_t svabd_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_m)))
+svfloat32_t svabd_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_m)))
+svfloat16_t svabd_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_x)))
+svfloat64_t svabd_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_x)))
+svfloat32_t svabd_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_x)))
+svfloat16_t svabd_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_z)))
+svfloat64_t svabd_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_z)))
+svfloat32_t svabd_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_z)))
+svfloat16_t svabd_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_m)))
+svint8_t svabd_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_m)))
+svint32_t svabd_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_m)))
+svint64_t svabd_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_m)))
+svint16_t svabd_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_x)))
+svint8_t svabd_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_x)))
+svint32_t svabd_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_x)))
+svint64_t svabd_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_x)))
+svint16_t svabd_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_z)))
+svint8_t svabd_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_z)))
+svint32_t svabd_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_z)))
+svint64_t svabd_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_z)))
+svint16_t svabd_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_m)))
+svuint8_t svabd_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_m)))
+svuint32_t svabd_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_m)))
+svuint64_t svabd_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_m)))
+svuint16_t svabd_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_x)))
+svuint8_t svabd_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_x)))
+svuint32_t svabd_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_x)))
+svuint64_t svabd_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_x)))
+svuint16_t svabd_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_z)))
+svuint8_t svabd_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_z)))
+svuint32_t svabd_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_z)))
+svuint64_t svabd_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_z)))
+svuint16_t svabd_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_m)))
+svfloat64_t svabs_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_m)))
+svfloat32_t svabs_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_m)))
+svfloat16_t svabs_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_x)))
+svfloat64_t svabs_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_x)))
+svfloat32_t svabs_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_x)))
+svfloat16_t svabs_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_z)))
+svfloat64_t svabs_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_z)))
+svfloat32_t svabs_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_z)))
+svfloat16_t svabs_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_m)))
+svint8_t svabs_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_m)))
+svint32_t svabs_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_m)))
+svint64_t svabs_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_m)))
+svint16_t svabs_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_x)))
+svint8_t svabs_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_x)))
+svint32_t svabs_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_x)))
+svint64_t svabs_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_x)))
+svint16_t svabs_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_z)))
+svint8_t svabs_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_z)))
+svint32_t svabs_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_z)))
+svint64_t svabs_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_z)))
+svint16_t svabs_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f64)))
+svbool_t svacge_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f32)))
+svbool_t svacge_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f16)))
+svbool_t svacge_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f64)))
+svbool_t svacge_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f32)))
+svbool_t svacge_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f16)))
+svbool_t svacge_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f64)))
+svbool_t svacgt_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f32)))
+svbool_t svacgt_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f16)))
+svbool_t svacgt_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f64)))
+svbool_t svacgt_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f32)))
+svbool_t svacgt_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f16)))
+svbool_t svacgt_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f64)))
+svbool_t svacle_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f32)))
+svbool_t svacle_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f16)))
+svbool_t svacle_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f64)))
+svbool_t svacle_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f32)))
+svbool_t svacle_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f16)))
+svbool_t svacle_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f64)))
+svbool_t svaclt_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f32)))
+svbool_t svaclt_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f16)))
+svbool_t svaclt_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f64)))
+svbool_t svaclt_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f32)))
+svbool_t svaclt_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f16)))
+svbool_t svaclt_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_m)))
+svfloat64_t svadd_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_m)))
+svfloat32_t svadd_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_m)))
+svfloat16_t svadd_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_x)))
+svfloat64_t svadd_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_x)))
+svfloat32_t svadd_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_x)))
+svfloat16_t svadd_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_z)))
+svfloat64_t svadd_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_z)))
+svfloat32_t svadd_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_z)))
+svfloat16_t svadd_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_m)))
+svuint8_t svadd_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_m)))
+svuint32_t svadd_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_m)))
+svuint64_t svadd_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_m)))
+svuint16_t svadd_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_m)))
+svint8_t svadd_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_m)))
+svint32_t svadd_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_m)))
+svint64_t svadd_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_m)))
+svint16_t svadd_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_x)))
+svuint8_t svadd_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_x)))
+svuint32_t svadd_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_x)))
+svuint64_t svadd_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_x)))
+svuint16_t svadd_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_x)))
+svint8_t svadd_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_x)))
+svint32_t svadd_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_x)))
+svint64_t svadd_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_x)))
+svint16_t svadd_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_z)))
+svuint8_t svadd_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_z)))
+svuint32_t svadd_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_z)))
+svuint64_t svadd_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_z)))
+svuint16_t svadd_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_z)))
+svint8_t svadd_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_z)))
+svint32_t svadd_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_z)))
+svint64_t svadd_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_z)))
+svint16_t svadd_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_m)))
+svfloat64_t svadd_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_m)))
+svfloat32_t svadd_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_m)))
+svfloat16_t svadd_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_x)))
+svfloat64_t svadd_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_x)))
+svfloat32_t svadd_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_x)))
+svfloat16_t svadd_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_z)))
+svfloat64_t svadd_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_z)))
+svfloat32_t svadd_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_z)))
+svfloat16_t svadd_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_m)))
+svuint8_t svadd_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_m)))
+svuint32_t svadd_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_m)))
+svuint64_t svadd_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_m)))
+svuint16_t svadd_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_m)))
+svint8_t svadd_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_m)))
+svint32_t svadd_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_m)))
+svint64_t svadd_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_m)))
+svint16_t svadd_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_x)))
+svuint8_t svadd_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_x)))
+svuint32_t svadd_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_x)))
+svuint64_t svadd_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_x)))
+svuint16_t svadd_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_x)))
+svint8_t svadd_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_x)))
+svint32_t svadd_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_x)))
+svint64_t svadd_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_x)))
+svint16_t svadd_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_z)))
+svuint8_t svadd_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_z)))
+svuint32_t svadd_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_z)))
+svuint64_t svadd_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_z)))
+svuint16_t svadd_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_z)))
+svint8_t svadd_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_z)))
+svint32_t svadd_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_z)))
+svint64_t svadd_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_z)))
+svint16_t svadd_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f64)))
+float64_t svadda_f64(svbool_t, float64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f32)))
+float32_t svadda_f32(svbool_t, float32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f16)))
+float16_t svadda_f16(svbool_t, float16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s8)))
+int64_t svaddv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s32)))
+int64_t svaddv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s64)))
+int64_t svaddv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s16)))
+int64_t svaddv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u8)))
+uint64_t svaddv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u32)))
+uint64_t svaddv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u64)))
+uint64_t svaddv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u16)))
+uint64_t svaddv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f64)))
+float64_t svaddv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f32)))
+float32_t svaddv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f16)))
+float16_t svaddv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_b_z)))
+svbool_t svand_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_m)))
+svuint8_t svand_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_m)))
+svuint32_t svand_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_m)))
+svuint64_t svand_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_m)))
+svuint16_t svand_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_m)))
+svint8_t svand_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_m)))
+svint32_t svand_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_m)))
+svint64_t svand_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_m)))
+svint16_t svand_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_x)))
+svuint8_t svand_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_x)))
+svuint32_t svand_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_x)))
+svuint64_t svand_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_x)))
+svuint16_t svand_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_x)))
+svint8_t svand_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_x)))
+svint32_t svand_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_x)))
+svint64_t svand_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_x)))
+svint16_t svand_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_z)))
+svuint8_t svand_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_z)))
+svuint32_t svand_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_z)))
+svuint64_t svand_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_z)))
+svuint16_t svand_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_z)))
+svint8_t svand_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_z)))
+svint32_t svand_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_z)))
+svint64_t svand_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_z)))
+svint16_t svand_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_m)))
+svuint8_t svand_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_m)))
+svuint32_t svand_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_m)))
+svuint64_t svand_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_m)))
+svuint16_t svand_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_m)))
+svint8_t svand_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_m)))
+svint32_t svand_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_m)))
+svint64_t svand_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_m)))
+svint16_t svand_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_x)))
+svuint8_t svand_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_x)))
+svuint32_t svand_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_x)))
+svuint64_t svand_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_x)))
+svuint16_t svand_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_x)))
+svint8_t svand_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_x)))
+svint32_t svand_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_x)))
+svint64_t svand_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_x)))
+svint16_t svand_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_z)))
+svuint8_t svand_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_z)))
+svuint32_t svand_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_z)))
+svuint64_t svand_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_z)))
+svuint16_t svand_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_z)))
+svint8_t svand_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_z)))
+svint32_t svand_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_z)))
+svint64_t svand_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_z)))
+svint16_t svand_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u8)))
+uint8_t svandv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u32)))
+uint32_t svandv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u64)))
+uint64_t svandv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u16)))
+uint16_t svandv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s8)))
+int8_t svandv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s32)))
+int32_t svandv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s64)))
+int64_t svandv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s16)))
+int16_t svandv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_m)))
+svint8_t svasr_n_s8_m(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_m)))
+svint32_t svasr_n_s32_m(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_m)))
+svint64_t svasr_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_m)))
+svint16_t svasr_n_s16_m(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_x)))
+svint8_t svasr_n_s8_x(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_x)))
+svint32_t svasr_n_s32_x(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_x)))
+svint64_t svasr_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_x)))
+svint16_t svasr_n_s16_x(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_z)))
+svint8_t svasr_n_s8_z(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_z)))
+svint32_t svasr_n_s32_z(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_z)))
+svint64_t svasr_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_z)))
+svint16_t svasr_n_s16_z(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_m)))
+svint8_t svasr_s8_m(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_m)))
+svint32_t svasr_s32_m(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_m)))
+svint64_t svasr_s64_m(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_m)))
+svint16_t svasr_s16_m(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_x)))
+svint8_t svasr_s8_x(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_x)))
+svint32_t svasr_s32_x(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_x)))
+svint64_t svasr_s64_x(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_x)))
+svint16_t svasr_s16_x(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_z)))
+svint8_t svasr_s8_z(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_z)))
+svint32_t svasr_s32_z(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_z)))
+svint64_t svasr_s64_z(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_z)))
+svint16_t svasr_s16_z(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_m)))
+svint8_t svasr_wide_n_s8_m(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_m)))
+svint32_t svasr_wide_n_s32_m(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_m)))
+svint16_t svasr_wide_n_s16_m(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_x)))
+svint8_t svasr_wide_n_s8_x(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_x)))
+svint32_t svasr_wide_n_s32_x(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_x)))
+svint16_t svasr_wide_n_s16_x(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_z)))
+svint8_t svasr_wide_n_s8_z(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_z)))
+svint32_t svasr_wide_n_s32_z(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_z)))
+svint16_t svasr_wide_n_s16_z(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_m)))
+svint8_t svasr_wide_s8_m(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_m)))
+svint32_t svasr_wide_s32_m(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_m)))
+svint16_t svasr_wide_s16_m(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_x)))
+svint8_t svasr_wide_s8_x(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_x)))
+svint32_t svasr_wide_s32_x(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_x)))
+svint16_t svasr_wide_s16_x(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_z)))
+svint8_t svasr_wide_s8_z(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_z)))
+svint32_t svasr_wide_s32_z(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_z)))
+svint16_t svasr_wide_s16_z(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_m)))
+svint8_t svasrd_n_s8_m(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_m)))
+svint32_t svasrd_n_s32_m(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_m)))
+svint64_t svasrd_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_m)))
+svint16_t svasrd_n_s16_m(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_x)))
+svint8_t svasrd_n_s8_x(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_x)))
+svint32_t svasrd_n_s32_x(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_x)))
+svint64_t svasrd_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_x)))
+svint16_t svasrd_n_s16_x(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_z)))
+svint8_t svasrd_n_s8_z(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_z)))
+svint32_t svasrd_n_s32_z(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_z)))
+svint64_t svasrd_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_z)))
+svint16_t svasrd_n_s16_z(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_b_z)))
+svbool_t svbic_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_m)))
+svuint8_t svbic_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_m)))
+svuint32_t svbic_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_m)))
+svuint64_t svbic_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_m)))
+svuint16_t svbic_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_m)))
+svint8_t svbic_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_m)))
+svint32_t svbic_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_m)))
+svint64_t svbic_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_m)))
+svint16_t svbic_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_x)))
+svuint8_t svbic_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_x)))
+svuint32_t svbic_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_x)))
+svuint64_t svbic_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_x)))
+svuint16_t svbic_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_x)))
+svint8_t svbic_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_x)))
+svint32_t svbic_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_x)))
+svint64_t svbic_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_x)))
+svint16_t svbic_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_z)))
+svuint8_t svbic_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_z)))
+svuint32_t svbic_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_z)))
+svuint64_t svbic_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_z)))
+svuint16_t svbic_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_z)))
+svint8_t svbic_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_z)))
+svint32_t svbic_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_z)))
+svint64_t svbic_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_z)))
+svint16_t svbic_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_m)))
+svuint8_t svbic_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_m)))
+svuint32_t svbic_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_m)))
+svuint64_t svbic_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_m)))
+svuint16_t svbic_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_m)))
+svint8_t svbic_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_m)))
+svint32_t svbic_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_m)))
+svint64_t svbic_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_m)))
+svint16_t svbic_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_x)))
+svuint8_t svbic_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_x)))
+svuint32_t svbic_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_x)))
+svuint64_t svbic_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_x)))
+svuint16_t svbic_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_x)))
+svint8_t svbic_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_x)))
+svint32_t svbic_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_x)))
+svint64_t svbic_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_x)))
+svint16_t svbic_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_z)))
+svuint8_t svbic_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_z)))
+svuint32_t svbic_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_z)))
+svuint64_t svbic_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_z)))
+svuint16_t svbic_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_z)))
+svint8_t svbic_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_z)))
+svint32_t svbic_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_z)))
+svint64_t svbic_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_z)))
+svint16_t svbic_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_m)))
+svbool_t svbrka_b_m(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_z)))
+svbool_t svbrka_b_z(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_m)))
+svbool_t svbrkb_b_m(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_z)))
+svbool_t svbrkb_b_z(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkn_b_z)))
+svbool_t svbrkn_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpa_b_z)))
+svbool_t svbrkpa_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpb_b_z)))
+svbool_t svbrkpb_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_m)))
+svfloat64_t svcadd_f64_m(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_m)))
+svfloat32_t svcadd_f32_m(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_m)))
+svfloat16_t svcadd_f16_m(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_x)))
+svfloat64_t svcadd_f64_x(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_x)))
+svfloat32_t svcadd_f32_x(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_x)))
+svfloat16_t svcadd_f16_x(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_z)))
+svfloat64_t svcadd_f64_z(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_z)))
+svfloat32_t svcadd_f32_z(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_z)))
+svfloat16_t svcadd_f16_z(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u8)))
+uint8_t svclasta_n_u8(svbool_t, uint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u32)))
+uint32_t svclasta_n_u32(svbool_t, uint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u64)))
+uint64_t svclasta_n_u64(svbool_t, uint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u16)))
+uint16_t svclasta_n_u16(svbool_t, uint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s8)))
+int8_t svclasta_n_s8(svbool_t, int8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f64)))
+float64_t svclasta_n_f64(svbool_t, float64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f32)))
+float32_t svclasta_n_f32(svbool_t, float32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f16)))
+float16_t svclasta_n_f16(svbool_t, float16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s32)))
+int32_t svclasta_n_s32(svbool_t, int32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s64)))
+int64_t svclasta_n_s64(svbool_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s16)))
+int16_t svclasta_n_s16(svbool_t, int16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u8)))
+svuint8_t svclasta_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u32)))
+svuint32_t svclasta_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u64)))
+svuint64_t svclasta_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u16)))
+svuint16_t svclasta_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s8)))
+svint8_t svclasta_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f64)))
+svfloat64_t svclasta_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f32)))
+svfloat32_t svclasta_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f16)))
+svfloat16_t svclasta_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s32)))
+svint32_t svclasta_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s64)))
+svint64_t svclasta_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s16)))
+svint16_t svclasta_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u8)))
+uint8_t svclastb_n_u8(svbool_t, uint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u32)))
+uint32_t svclastb_n_u32(svbool_t, uint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u64)))
+uint64_t svclastb_n_u64(svbool_t, uint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u16)))
+uint16_t svclastb_n_u16(svbool_t, uint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s8)))
+int8_t svclastb_n_s8(svbool_t, int8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f64)))
+float64_t svclastb_n_f64(svbool_t, float64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f32)))
+float32_t svclastb_n_f32(svbool_t, float32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f16)))
+float16_t svclastb_n_f16(svbool_t, float16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s32)))
+int32_t svclastb_n_s32(svbool_t, int32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s64)))
+int64_t svclastb_n_s64(svbool_t, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s16)))
+int16_t svclastb_n_s16(svbool_t, int16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u8)))
+svuint8_t svclastb_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u32)))
+svuint32_t svclastb_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u64)))
+svuint64_t svclastb_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u16)))
+svuint16_t svclastb_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s8)))
+svint8_t svclastb_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f64)))
+svfloat64_t svclastb_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f32)))
+svfloat32_t svclastb_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f16)))
+svfloat16_t svclastb_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s32)))
+svint32_t svclastb_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s64)))
+svint64_t svclastb_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s16)))
+svint16_t svclastb_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_m)))
+svuint8_t svcls_s8_m(svuint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_m)))
+svuint32_t svcls_s32_m(svuint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_m)))
+svuint64_t svcls_s64_m(svuint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_m)))
+svuint16_t svcls_s16_m(svuint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_x)))
+svuint8_t svcls_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_x)))
+svuint32_t svcls_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_x)))
+svuint64_t svcls_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_x)))
+svuint16_t svcls_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_z)))
+svuint8_t svcls_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_z)))
+svuint32_t svcls_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_z)))
+svuint64_t svcls_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_z)))
+svuint16_t svcls_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_m)))
+svuint8_t svclz_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_m)))
+svuint32_t svclz_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_m)))
+svuint64_t svclz_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_m)))
+svuint16_t svclz_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_m)))
+svuint8_t svclz_s8_m(svuint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_m)))
+svuint32_t svclz_s32_m(svuint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_m)))
+svuint64_t svclz_s64_m(svuint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_m)))
+svuint16_t svclz_s16_m(svuint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_x)))
+svuint8_t svclz_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_x)))
+svuint32_t svclz_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_x)))
+svuint64_t svclz_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_x)))
+svuint16_t svclz_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_x)))
+svuint8_t svclz_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_x)))
+svuint32_t svclz_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_x)))
+svuint64_t svclz_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_x)))
+svuint16_t svclz_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_z)))
+svuint8_t svclz_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_z)))
+svuint32_t svclz_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_z)))
+svuint64_t svclz_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_z)))
+svuint16_t svclz_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_z)))
+svuint8_t svclz_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_z)))
+svuint32_t svclz_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_z)))
+svuint64_t svclz_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_z)))
+svuint16_t svclz_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_m)))
+svfloat64_t svcmla_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_m)))
+svfloat32_t svcmla_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_m)))
+svfloat16_t svcmla_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_x)))
+svfloat64_t svcmla_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_x)))
+svfloat32_t svcmla_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_x)))
+svfloat16_t svcmla_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_z)))
+svfloat64_t svcmla_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_z)))
+svfloat32_t svcmla_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_z)))
+svfloat16_t svcmla_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f32)))
+svfloat32_t svcmla_lane_f32(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f16)))
+svfloat16_t svcmla_lane_f16(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f64)))
+svbool_t svcmpeq_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f32)))
+svbool_t svcmpeq_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f16)))
+svbool_t svcmpeq_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u8)))
+svbool_t svcmpeq_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u32)))
+svbool_t svcmpeq_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u64)))
+svbool_t svcmpeq_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u16)))
+svbool_t svcmpeq_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s8)))
+svbool_t svcmpeq_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s32)))
+svbool_t svcmpeq_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s64)))
+svbool_t svcmpeq_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s16)))
+svbool_t svcmpeq_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u8)))
+svbool_t svcmpeq_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u32)))
+svbool_t svcmpeq_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u64)))
+svbool_t svcmpeq_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u16)))
+svbool_t svcmpeq_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s8)))
+svbool_t svcmpeq_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s32)))
+svbool_t svcmpeq_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s64)))
+svbool_t svcmpeq_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s16)))
+svbool_t svcmpeq_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f64)))
+svbool_t svcmpeq_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f32)))
+svbool_t svcmpeq_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f16)))
+svbool_t svcmpeq_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s8)))
+svbool_t svcmpeq_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s32)))
+svbool_t svcmpeq_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s16)))
+svbool_t svcmpeq_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s8)))
+svbool_t svcmpeq_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s32)))
+svbool_t svcmpeq_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s16)))
+svbool_t svcmpeq_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f64)))
+svbool_t svcmpge_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f32)))
+svbool_t svcmpge_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f16)))
+svbool_t svcmpge_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s8)))
+svbool_t svcmpge_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s32)))
+svbool_t svcmpge_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s64)))
+svbool_t svcmpge_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s16)))
+svbool_t svcmpge_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u8)))
+svbool_t svcmpge_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u32)))
+svbool_t svcmpge_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u64)))
+svbool_t svcmpge_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u16)))
+svbool_t svcmpge_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s8)))
+svbool_t svcmpge_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s32)))
+svbool_t svcmpge_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s64)))
+svbool_t svcmpge_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s16)))
+svbool_t svcmpge_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f64)))
+svbool_t svcmpge_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f32)))
+svbool_t svcmpge_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f16)))
+svbool_t svcmpge_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u8)))
+svbool_t svcmpge_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u32)))
+svbool_t svcmpge_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u64)))
+svbool_t svcmpge_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u16)))
+svbool_t svcmpge_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s8)))
+svbool_t svcmpge_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s32)))
+svbool_t svcmpge_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s16)))
+svbool_t svcmpge_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u8)))
+svbool_t svcmpge_wide_n_u8(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u32)))
+svbool_t svcmpge_wide_n_u32(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u16)))
+svbool_t svcmpge_wide_n_u16(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s8)))
+svbool_t svcmpge_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s32)))
+svbool_t svcmpge_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s16)))
+svbool_t svcmpge_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u8)))
+svbool_t svcmpge_wide_u8(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u32)))
+svbool_t svcmpge_wide_u32(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u16)))
+svbool_t svcmpge_wide_u16(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f64)))
+svbool_t svcmpgt_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f32)))
+svbool_t svcmpgt_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f16)))
+svbool_t svcmpgt_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s8)))
+svbool_t svcmpgt_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s32)))
+svbool_t svcmpgt_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s64)))
+svbool_t svcmpgt_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s16)))
+svbool_t svcmpgt_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u8)))
+svbool_t svcmpgt_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u32)))
+svbool_t svcmpgt_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u64)))
+svbool_t svcmpgt_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u16)))
+svbool_t svcmpgt_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s8)))
+svbool_t svcmpgt_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s32)))
+svbool_t svcmpgt_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s64)))
+svbool_t svcmpgt_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s16)))
+svbool_t svcmpgt_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f64)))
+svbool_t svcmpgt_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f32)))
+svbool_t svcmpgt_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f16)))
+svbool_t svcmpgt_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u8)))
+svbool_t svcmpgt_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u32)))
+svbool_t svcmpgt_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u64)))
+svbool_t svcmpgt_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u16)))
+svbool_t svcmpgt_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s8)))
+svbool_t svcmpgt_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s32)))
+svbool_t svcmpgt_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s16)))
+svbool_t svcmpgt_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u8)))
+svbool_t svcmpgt_wide_n_u8(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u32)))
+svbool_t svcmpgt_wide_n_u32(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u16)))
+svbool_t svcmpgt_wide_n_u16(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s8)))
+svbool_t svcmpgt_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s32)))
+svbool_t svcmpgt_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s16)))
+svbool_t svcmpgt_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u8)))
+svbool_t svcmpgt_wide_u8(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u32)))
+svbool_t svcmpgt_wide_u32(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u16)))
+svbool_t svcmpgt_wide_u16(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f64)))
+svbool_t svcmple_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f32)))
+svbool_t svcmple_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f16)))
+svbool_t svcmple_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s8)))
+svbool_t svcmple_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s32)))
+svbool_t svcmple_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s64)))
+svbool_t svcmple_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s16)))
+svbool_t svcmple_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u8)))
+svbool_t svcmple_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u32)))
+svbool_t svcmple_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u64)))
+svbool_t svcmple_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u16)))
+svbool_t svcmple_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s8)))
+svbool_t svcmple_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s32)))
+svbool_t svcmple_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s64)))
+svbool_t svcmple_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s16)))
+svbool_t svcmple_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f64)))
+svbool_t svcmple_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f32)))
+svbool_t svcmple_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f16)))
+svbool_t svcmple_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u8)))
+svbool_t svcmple_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u32)))
+svbool_t svcmple_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u64)))
+svbool_t svcmple_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u16)))
+svbool_t svcmple_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s8)))
+svbool_t svcmple_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s32)))
+svbool_t svcmple_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s16)))
+svbool_t svcmple_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u8)))
+svbool_t svcmple_wide_n_u8(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u32)))
+svbool_t svcmple_wide_n_u32(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u16)))
+svbool_t svcmple_wide_n_u16(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s8)))
+svbool_t svcmple_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s32)))
+svbool_t svcmple_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s16)))
+svbool_t svcmple_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u8)))
+svbool_t svcmple_wide_u8(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u32)))
+svbool_t svcmple_wide_u32(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u16)))
+svbool_t svcmple_wide_u16(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u8)))
+svbool_t svcmplt_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u32)))
+svbool_t svcmplt_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u64)))
+svbool_t svcmplt_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u16)))
+svbool_t svcmplt_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f64)))
+svbool_t svcmplt_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f32)))
+svbool_t svcmplt_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f16)))
+svbool_t svcmplt_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s8)))
+svbool_t svcmplt_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s32)))
+svbool_t svcmplt_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s64)))
+svbool_t svcmplt_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s16)))
+svbool_t svcmplt_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u8)))
+svbool_t svcmplt_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u32)))
+svbool_t svcmplt_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u64)))
+svbool_t svcmplt_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u16)))
+svbool_t svcmplt_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s8)))
+svbool_t svcmplt_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s32)))
+svbool_t svcmplt_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s64)))
+svbool_t svcmplt_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s16)))
+svbool_t svcmplt_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f64)))
+svbool_t svcmplt_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f32)))
+svbool_t svcmplt_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f16)))
+svbool_t svcmplt_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u8)))
+svbool_t svcmplt_wide_n_u8(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u32)))
+svbool_t svcmplt_wide_n_u32(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u16)))
+svbool_t svcmplt_wide_n_u16(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s8)))
+svbool_t svcmplt_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s32)))
+svbool_t svcmplt_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s16)))
+svbool_t svcmplt_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u8)))
+svbool_t svcmplt_wide_u8(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u32)))
+svbool_t svcmplt_wide_u32(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u16)))
+svbool_t svcmplt_wide_u16(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s8)))
+svbool_t svcmplt_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s32)))
+svbool_t svcmplt_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s16)))
+svbool_t svcmplt_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f64)))
+svbool_t svcmpne_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f32)))
+svbool_t svcmpne_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f16)))
+svbool_t svcmpne_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u8)))
+svbool_t svcmpne_n_u8(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u32)))
+svbool_t svcmpne_n_u32(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u64)))
+svbool_t svcmpne_n_u64(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u16)))
+svbool_t svcmpne_n_u16(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s8)))
+svbool_t svcmpne_n_s8(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s32)))
+svbool_t svcmpne_n_s32(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s64)))
+svbool_t svcmpne_n_s64(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s16)))
+svbool_t svcmpne_n_s16(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u8)))
+svbool_t svcmpne_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u32)))
+svbool_t svcmpne_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u64)))
+svbool_t svcmpne_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u16)))
+svbool_t svcmpne_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s8)))
+svbool_t svcmpne_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s32)))
+svbool_t svcmpne_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s64)))
+svbool_t svcmpne_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s16)))
+svbool_t svcmpne_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f64)))
+svbool_t svcmpne_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f32)))
+svbool_t svcmpne_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f16)))
+svbool_t svcmpne_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s8)))
+svbool_t svcmpne_wide_n_s8(svbool_t, svint8_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s32)))
+svbool_t svcmpne_wide_n_s32(svbool_t, svint32_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s16)))
+svbool_t svcmpne_wide_n_s16(svbool_t, svint16_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s8)))
+svbool_t svcmpne_wide_s8(svbool_t, svint8_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s32)))
+svbool_t svcmpne_wide_s32(svbool_t, svint32_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s16)))
+svbool_t svcmpne_wide_s16(svbool_t, svint16_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f64)))
+svbool_t svcmpuo_n_f64(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f32)))
+svbool_t svcmpuo_n_f32(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f16)))
+svbool_t svcmpuo_n_f16(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f64)))
+svbool_t svcmpuo_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f32)))
+svbool_t svcmpuo_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f16)))
+svbool_t svcmpuo_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_m)))
+svuint8_t svcnot_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_m)))
+svuint32_t svcnot_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_m)))
+svuint64_t svcnot_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_m)))
+svuint16_t svcnot_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_m)))
+svint8_t svcnot_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_m)))
+svint32_t svcnot_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_m)))
+svint64_t svcnot_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_m)))
+svint16_t svcnot_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_x)))
+svuint8_t svcnot_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_x)))
+svuint32_t svcnot_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_x)))
+svuint64_t svcnot_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_x)))
+svuint16_t svcnot_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_x)))
+svint8_t svcnot_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_x)))
+svint32_t svcnot_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_x)))
+svint64_t svcnot_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_x)))
+svint16_t svcnot_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_z)))
+svuint8_t svcnot_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_z)))
+svuint32_t svcnot_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_z)))
+svuint64_t svcnot_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_z)))
+svuint16_t svcnot_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_z)))
+svint8_t svcnot_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_z)))
+svint32_t svcnot_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_z)))
+svint64_t svcnot_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_z)))
+svint16_t svcnot_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_m)))
+svuint8_t svcnt_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_m)))
+svuint32_t svcnt_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_m)))
+svuint64_t svcnt_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_m)))
+svuint16_t svcnt_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_m)))
+svuint8_t svcnt_s8_m(svuint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_m)))
+svuint64_t svcnt_f64_m(svuint64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_m)))
+svuint32_t svcnt_f32_m(svuint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_m)))
+svuint16_t svcnt_f16_m(svuint16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_m)))
+svuint32_t svcnt_s32_m(svuint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_m)))
+svuint64_t svcnt_s64_m(svuint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_m)))
+svuint16_t svcnt_s16_m(svuint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_x)))
+svuint8_t svcnt_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_x)))
+svuint32_t svcnt_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_x)))
+svuint64_t svcnt_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_x)))
+svuint16_t svcnt_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_x)))
+svuint8_t svcnt_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_x)))
+svuint64_t svcnt_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_x)))
+svuint32_t svcnt_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_x)))
+svuint16_t svcnt_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_x)))
+svuint32_t svcnt_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_x)))
+svuint64_t svcnt_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_x)))
+svuint16_t svcnt_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_z)))
+svuint8_t svcnt_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_z)))
+svuint32_t svcnt_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_z)))
+svuint64_t svcnt_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_z)))
+svuint16_t svcnt_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_z)))
+svuint8_t svcnt_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_z)))
+svuint64_t svcnt_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_z)))
+svuint32_t svcnt_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_z)))
+svuint16_t svcnt_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_z)))
+svuint32_t svcnt_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_z)))
+svuint64_t svcnt_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_z)))
+svuint16_t svcnt_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntb)))
+uint64_t svcntb(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntb_pat)))
+uint64_t svcntb_pat(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntd)))
+uint64_t svcntd(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntd_pat)))
+uint64_t svcntd_pat(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnth)))
+uint64_t svcnth(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnth_pat)))
+uint64_t svcnth_pat(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b8)))
+uint64_t svcntp_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b32)))
+uint64_t svcntp_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b64)))
+uint64_t svcntp_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntp_b16)))
+uint64_t svcntp_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntw)))
+uint64_t svcntw(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcntw_pat)))
+uint64_t svcntw_pat(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u8)))
+svuint8x2_t svcreate2_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u32)))
+svuint32x2_t svcreate2_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u64)))
+svuint64x2_t svcreate2_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u16)))
+svuint16x2_t svcreate2_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s8)))
+svint8x2_t svcreate2_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f64)))
+svfloat64x2_t svcreate2_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f32)))
+svfloat32x2_t svcreate2_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f16)))
+svfloat16x2_t svcreate2_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s32)))
+svint32x2_t svcreate2_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s64)))
+svint64x2_t svcreate2_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s16)))
+svint16x2_t svcreate2_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u8)))
+svuint8x3_t svcreate3_u8(svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u32)))
+svuint32x3_t svcreate3_u32(svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u64)))
+svuint64x3_t svcreate3_u64(svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u16)))
+svuint16x3_t svcreate3_u16(svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s8)))
+svint8x3_t svcreate3_s8(svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f64)))
+svfloat64x3_t svcreate3_f64(svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f32)))
+svfloat32x3_t svcreate3_f32(svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f16)))
+svfloat16x3_t svcreate3_f16(svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s32)))
+svint32x3_t svcreate3_s32(svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s64)))
+svint64x3_t svcreate3_s64(svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s16)))
+svint16x3_t svcreate3_s16(svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u8)))
+svuint8x4_t svcreate4_u8(svuint8_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u32)))
+svuint32x4_t svcreate4_u32(svuint32_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u64)))
+svuint64x4_t svcreate4_u64(svuint64_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u16)))
+svuint16x4_t svcreate4_u16(svuint16_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s8)))
+svint8x4_t svcreate4_s8(svint8_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f64)))
+svfloat64x4_t svcreate4_f64(svfloat64_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f32)))
+svfloat32x4_t svcreate4_f32(svfloat32_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f16)))
+svfloat16x4_t svcreate4_f16(svfloat16_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s32)))
+svint32x4_t svcreate4_s32(svint32_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s64)))
+svint64x4_t svcreate4_s64(svint64_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s16)))
+svint16x4_t svcreate4_s16(svint16_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_m)))
+svfloat16_t svcvt_f16_f32_m(svfloat16_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x)))
+svfloat16_t svcvt_f16_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_z)))
+svfloat16_t svcvt_f16_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_m)))
+svfloat16_t svcvt_f16_f64_m(svfloat16_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_x)))
+svfloat16_t svcvt_f16_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_z)))
+svfloat16_t svcvt_f16_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_m)))
+svfloat16_t svcvt_f16_s16_m(svfloat16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_x)))
+svfloat16_t svcvt_f16_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_z)))
+svfloat16_t svcvt_f16_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_m)))
+svfloat16_t svcvt_f16_s32_m(svfloat16_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_x)))
+svfloat16_t svcvt_f16_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_z)))
+svfloat16_t svcvt_f16_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_m)))
+svfloat16_t svcvt_f16_s64_m(svfloat16_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_x)))
+svfloat16_t svcvt_f16_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_z)))
+svfloat16_t svcvt_f16_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_m)))
+svfloat16_t svcvt_f16_u16_m(svfloat16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_x)))
+svfloat16_t svcvt_f16_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_z)))
+svfloat16_t svcvt_f16_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_m)))
+svfloat16_t svcvt_f16_u32_m(svfloat16_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_x)))
+svfloat16_t svcvt_f16_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_z)))
+svfloat16_t svcvt_f16_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_m)))
+svfloat16_t svcvt_f16_u64_m(svfloat16_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_x)))
+svfloat16_t svcvt_f16_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_z)))
+svfloat16_t svcvt_f16_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_m)))
+svfloat32_t svcvt_f32_f16_m(svfloat32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_x)))
+svfloat32_t svcvt_f32_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_z)))
+svfloat32_t svcvt_f32_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_m)))
+svfloat32_t svcvt_f32_f64_m(svfloat32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_x)))
+svfloat32_t svcvt_f32_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_z)))
+svfloat32_t svcvt_f32_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_m)))
+svfloat32_t svcvt_f32_s32_m(svfloat32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x)))
+svfloat32_t svcvt_f32_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_z)))
+svfloat32_t svcvt_f32_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_m)))
+svfloat32_t svcvt_f32_s64_m(svfloat32_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_x)))
+svfloat32_t svcvt_f32_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_z)))
+svfloat32_t svcvt_f32_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_m)))
+svfloat32_t svcvt_f32_u32_m(svfloat32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x)))
+svfloat32_t svcvt_f32_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_z)))
+svfloat32_t svcvt_f32_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_m)))
+svfloat32_t svcvt_f32_u64_m(svfloat32_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_x)))
+svfloat32_t svcvt_f32_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_z)))
+svfloat32_t svcvt_f32_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_m)))
+svfloat64_t svcvt_f64_f16_m(svfloat64_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_x)))
+svfloat64_t svcvt_f64_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_z)))
+svfloat64_t svcvt_f64_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_m)))
+svfloat64_t svcvt_f64_f32_m(svfloat64_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_x)))
+svfloat64_t svcvt_f64_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_z)))
+svfloat64_t svcvt_f64_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_m)))
+svfloat64_t svcvt_f64_s32_m(svfloat64_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_x)))
+svfloat64_t svcvt_f64_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_z)))
+svfloat64_t svcvt_f64_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_m)))
+svfloat64_t svcvt_f64_s64_m(svfloat64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_x)))
+svfloat64_t svcvt_f64_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_z)))
+svfloat64_t svcvt_f64_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_m)))
+svfloat64_t svcvt_f64_u32_m(svfloat64_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_x)))
+svfloat64_t svcvt_f64_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_z)))
+svfloat64_t svcvt_f64_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_m)))
+svfloat64_t svcvt_f64_u64_m(svfloat64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_x)))
+svfloat64_t svcvt_f64_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_z)))
+svfloat64_t svcvt_f64_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_m)))
+svint16_t svcvt_s16_f16_m(svint16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_x)))
+svint16_t svcvt_s16_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_z)))
+svint16_t svcvt_s16_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_m)))
+svint32_t svcvt_s32_f16_m(svint32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_x)))
+svint32_t svcvt_s32_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_z)))
+svint32_t svcvt_s32_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_m)))
+svint32_t svcvt_s32_f32_m(svint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x)))
+svint32_t svcvt_s32_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_z)))
+svint32_t svcvt_s32_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_m)))
+svint32_t svcvt_s32_f64_m(svint32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_x)))
+svint32_t svcvt_s32_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_z)))
+svint32_t svcvt_s32_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_m)))
+svint64_t svcvt_s64_f16_m(svint64_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_x)))
+svint64_t svcvt_s64_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_z)))
+svint64_t svcvt_s64_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_m)))
+svint64_t svcvt_s64_f32_m(svint64_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_x)))
+svint64_t svcvt_s64_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_z)))
+svint64_t svcvt_s64_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_m)))
+svint64_t svcvt_s64_f64_m(svint64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_x)))
+svint64_t svcvt_s64_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_z)))
+svint64_t svcvt_s64_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_m)))
+svuint16_t svcvt_u16_f16_m(svuint16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_x)))
+svuint16_t svcvt_u16_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_z)))
+svuint16_t svcvt_u16_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_m)))
+svuint32_t svcvt_u32_f16_m(svuint32_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_x)))
+svuint32_t svcvt_u32_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_z)))
+svuint32_t svcvt_u32_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_m)))
+svuint32_t svcvt_u32_f32_m(svuint32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x)))
+svuint32_t svcvt_u32_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_z)))
+svuint32_t svcvt_u32_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_m)))
+svuint32_t svcvt_u32_f64_m(svuint32_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_x)))
+svuint32_t svcvt_u32_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_z)))
+svuint32_t svcvt_u32_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_m)))
+svuint64_t svcvt_u64_f16_m(svuint64_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_x)))
+svuint64_t svcvt_u64_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_z)))
+svuint64_t svcvt_u64_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_m)))
+svuint64_t svcvt_u64_f32_m(svuint64_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_x)))
+svuint64_t svcvt_u64_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_z)))
+svuint64_t svcvt_u64_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_m)))
+svuint64_t svcvt_u64_f64_m(svuint64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_x)))
+svuint64_t svcvt_u64_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_z)))
+svuint64_t svcvt_u64_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_m)))
+svfloat64_t svdiv_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_m)))
+svfloat32_t svdiv_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_m)))
+svfloat16_t svdiv_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_x)))
+svfloat64_t svdiv_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_x)))
+svfloat32_t svdiv_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_x)))
+svfloat16_t svdiv_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_z)))
+svfloat64_t svdiv_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_z)))
+svfloat32_t svdiv_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_z)))
+svfloat16_t svdiv_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_m)))
+svint32_t svdiv_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_m)))
+svint64_t svdiv_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_x)))
+svint32_t svdiv_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_x)))
+svint64_t svdiv_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_z)))
+svint32_t svdiv_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_z)))
+svint64_t svdiv_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_m)))
+svuint32_t svdiv_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_m)))
+svuint64_t svdiv_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_x)))
+svuint32_t svdiv_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_x)))
+svuint64_t svdiv_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_z)))
+svuint32_t svdiv_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_z)))
+svuint64_t svdiv_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_m)))
+svfloat64_t svdiv_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_m)))
+svfloat32_t svdiv_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_m)))
+svfloat16_t svdiv_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_x)))
+svfloat64_t svdiv_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_x)))
+svfloat32_t svdiv_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_x)))
+svfloat16_t svdiv_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_z)))
+svfloat64_t svdiv_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_z)))
+svfloat32_t svdiv_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_z)))
+svfloat16_t svdiv_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_m)))
+svint32_t svdiv_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_m)))
+svint64_t svdiv_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_x)))
+svint32_t svdiv_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_x)))
+svint64_t svdiv_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_z)))
+svint32_t svdiv_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_z)))
+svint64_t svdiv_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_m)))
+svuint32_t svdiv_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_m)))
+svuint64_t svdiv_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_x)))
+svuint32_t svdiv_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_x)))
+svuint64_t svdiv_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_z)))
+svuint32_t svdiv_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_z)))
+svuint64_t svdiv_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_m)))
+svfloat64_t svdivr_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_m)))
+svfloat32_t svdivr_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_m)))
+svfloat16_t svdivr_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_x)))
+svfloat64_t svdivr_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_x)))
+svfloat32_t svdivr_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_x)))
+svfloat16_t svdivr_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_z)))
+svfloat64_t svdivr_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_z)))
+svfloat32_t svdivr_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_z)))
+svfloat16_t svdivr_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_m)))
+svint32_t svdivr_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_m)))
+svint64_t svdivr_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_x)))
+svint32_t svdivr_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_x)))
+svint64_t svdivr_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_z)))
+svint32_t svdivr_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_z)))
+svint64_t svdivr_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_m)))
+svuint32_t svdivr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_m)))
+svuint64_t svdivr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_x)))
+svuint32_t svdivr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_x)))
+svuint64_t svdivr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_z)))
+svuint32_t svdivr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_z)))
+svuint64_t svdivr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_m)))
+svfloat64_t svdivr_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_m)))
+svfloat32_t svdivr_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_m)))
+svfloat16_t svdivr_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_x)))
+svfloat64_t svdivr_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_x)))
+svfloat32_t svdivr_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_x)))
+svfloat16_t svdivr_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_z)))
+svfloat64_t svdivr_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_z)))
+svfloat32_t svdivr_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_z)))
+svfloat16_t svdivr_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_m)))
+svint32_t svdivr_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_m)))
+svint64_t svdivr_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_x)))
+svint32_t svdivr_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_x)))
+svint64_t svdivr_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_z)))
+svint32_t svdivr_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_z)))
+svint64_t svdivr_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_m)))
+svuint32_t svdivr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_m)))
+svuint64_t svdivr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_x)))
+svuint32_t svdivr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_x)))
+svuint64_t svdivr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_z)))
+svuint32_t svdivr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_z)))
+svuint64_t svdivr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s32)))
+svint32_t svdot_n_s32(svint32_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s64)))
+svint64_t svdot_n_s64(svint64_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u32)))
+svuint32_t svdot_n_u32(svuint32_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u64)))
+svuint64_t svdot_n_u64(svuint64_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s32)))
+svint32_t svdot_s32(svint32_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s64)))
+svint64_t svdot_s64(svint64_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u32)))
+svuint32_t svdot_u32(svuint32_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u64)))
+svuint64_t svdot_u64(svuint64_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s32)))
+svint32_t svdot_lane_s32(svint32_t, svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s64)))
+svint64_t svdot_lane_s64(svint64_t, svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u32)))
+svuint32_t svdot_lane_u32(svuint32_t, svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u64)))
+svuint64_t svdot_lane_u64(svuint64_t, svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8)))
+svuint8_t svdup_n_u8(uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32)))
+svuint32_t svdup_n_u32(uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64)))
+svuint64_t svdup_n_u64(uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16)))
+svuint16_t svdup_n_u16(uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8)))
+svint8_t svdup_n_s8(int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64)))
+svfloat64_t svdup_n_f64(float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32)))
+svfloat32_t svdup_n_f32(float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16)))
+svfloat16_t svdup_n_f16(float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32)))
+svint32_t svdup_n_s32(int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64)))
+svint64_t svdup_n_s64(int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16)))
+svint16_t svdup_n_s16(int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_m)))
+svuint8_t svdup_n_u8_m(svuint8_t, svbool_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_m)))
+svuint32_t svdup_n_u32_m(svuint32_t, svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_m)))
+svuint64_t svdup_n_u64_m(svuint64_t, svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_m)))
+svuint16_t svdup_n_u16_m(svuint16_t, svbool_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_m)))
+svint8_t svdup_n_s8_m(svint8_t, svbool_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_m)))
+svfloat64_t svdup_n_f64_m(svfloat64_t, svbool_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_m)))
+svfloat32_t svdup_n_f32_m(svfloat32_t, svbool_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_m)))
+svfloat16_t svdup_n_f16_m(svfloat16_t, svbool_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_m)))
+svint32_t svdup_n_s32_m(svint32_t, svbool_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_m)))
+svint64_t svdup_n_s64_m(svint64_t, svbool_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_m)))
+svint16_t svdup_n_s16_m(svint16_t, svbool_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b8)))
+svbool_t svdup_n_b8(bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b32)))
+svbool_t svdup_n_b32(bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b64)))
+svbool_t svdup_n_b64(bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b16)))
+svbool_t svdup_n_b16(bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_x)))
+svuint8_t svdup_n_u8_x(svbool_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_x)))
+svuint32_t svdup_n_u32_x(svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_x)))
+svuint64_t svdup_n_u64_x(svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_x)))
+svuint16_t svdup_n_u16_x(svbool_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_x)))
+svint8_t svdup_n_s8_x(svbool_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_x)))
+svfloat64_t svdup_n_f64_x(svbool_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_x)))
+svfloat32_t svdup_n_f32_x(svbool_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_x)))
+svfloat16_t svdup_n_f16_x(svbool_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_x)))
+svint32_t svdup_n_s32_x(svbool_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_x)))
+svint64_t svdup_n_s64_x(svbool_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_x)))
+svint16_t svdup_n_s16_x(svbool_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_z)))
+svuint8_t svdup_n_u8_z(svbool_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_z)))
+svuint32_t svdup_n_u32_z(svbool_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_z)))
+svuint64_t svdup_n_u64_z(svbool_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_z)))
+svuint16_t svdup_n_u16_z(svbool_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_z)))
+svint8_t svdup_n_s8_z(svbool_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_z)))
+svfloat64_t svdup_n_f64_z(svbool_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_z)))
+svfloat32_t svdup_n_f32_z(svbool_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_z)))
+svfloat16_t svdup_n_f16_z(svbool_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_z)))
+svint32_t svdup_n_s32_z(svbool_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_z)))
+svint64_t svdup_n_s64_z(svbool_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_z)))
+svint16_t svdup_n_s16_z(svbool_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u8)))
+svuint8_t svdup_lane_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u32)))
+svuint32_t svdup_lane_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u64)))
+svuint64_t svdup_lane_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u16)))
+svuint16_t svdup_lane_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s8)))
+svint8_t svdup_lane_s8(svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f64)))
+svfloat64_t svdup_lane_f64(svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f32)))
+svfloat32_t svdup_lane_f32(svfloat32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f16)))
+svfloat16_t svdup_lane_f16(svfloat16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s32)))
+svint32_t svdup_lane_s32(svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s64)))
+svint64_t svdup_lane_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s16)))
+svint16_t svdup_lane_s16(svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u8)))
+svuint8_t svdupq_n_u8(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s8)))
+svint8_t svdupq_n_s8(int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u16)))
+svuint16_t svdupq_n_u16(uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f16)))
+svfloat16_t svdupq_n_f16(float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s16)))
+svint16_t svdupq_n_s16(int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u32)))
+svuint32_t svdupq_n_u32(uint32_t, uint32_t, uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f32)))
+svfloat32_t svdupq_n_f32(float32_t, float32_t, float32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s32)))
+svint32_t svdupq_n_s32(int32_t, int32_t, int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u64)))
+svuint64_t svdupq_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f64)))
+svfloat64_t svdupq_n_f64(float64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s64)))
+svint64_t svdupq_n_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b8)))
+svbool_t svdupq_n_b8(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b16)))
+svbool_t svdupq_n_b16(bool, bool, bool, bool, bool, bool, bool, bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b32)))
+svbool_t svdupq_n_b32(bool, bool, bool, bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b64)))
+svbool_t svdupq_n_b64(bool, bool);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u8)))
+svuint8_t svdupq_lane_u8(svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u32)))
+svuint32_t svdupq_lane_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u64)))
+svuint64_t svdupq_lane_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u16)))
+svuint16_t svdupq_lane_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s8)))
+svint8_t svdupq_lane_s8(svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f64)))
+svfloat64_t svdupq_lane_f64(svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f32)))
+svfloat32_t svdupq_lane_f32(svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f16)))
+svfloat16_t svdupq_lane_f16(svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s32)))
+svint32_t svdupq_lane_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s64)))
+svint64_t svdupq_lane_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s16)))
+svint16_t svdupq_lane_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_b_z)))
+svbool_t sveor_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_m)))
+svuint8_t sveor_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_m)))
+svuint32_t sveor_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_m)))
+svuint64_t sveor_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_m)))
+svuint16_t sveor_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_m)))
+svint8_t sveor_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_m)))
+svint32_t sveor_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_m)))
+svint64_t sveor_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_m)))
+svint16_t sveor_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_x)))
+svuint8_t sveor_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_x)))
+svuint32_t sveor_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_x)))
+svuint64_t sveor_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_x)))
+svuint16_t sveor_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_x)))
+svint8_t sveor_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_x)))
+svint32_t sveor_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_x)))
+svint64_t sveor_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_x)))
+svint16_t sveor_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_z)))
+svuint8_t sveor_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_z)))
+svuint32_t sveor_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_z)))
+svuint64_t sveor_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_z)))
+svuint16_t sveor_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_z)))
+svint8_t sveor_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_z)))
+svint32_t sveor_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_z)))
+svint64_t sveor_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_z)))
+svint16_t sveor_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_m)))
+svuint8_t sveor_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_m)))
+svuint32_t sveor_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_m)))
+svuint64_t sveor_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_m)))
+svuint16_t sveor_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_m)))
+svint8_t sveor_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_m)))
+svint32_t sveor_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_m)))
+svint64_t sveor_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_m)))
+svint16_t sveor_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_x)))
+svuint8_t sveor_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_x)))
+svuint32_t sveor_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_x)))
+svuint64_t sveor_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_x)))
+svuint16_t sveor_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_x)))
+svint8_t sveor_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_x)))
+svint32_t sveor_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_x)))
+svint64_t sveor_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_x)))
+svint16_t sveor_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_z)))
+svuint8_t sveor_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_z)))
+svuint32_t sveor_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_z)))
+svuint64_t sveor_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_z)))
+svuint16_t sveor_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_z)))
+svint8_t sveor_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_z)))
+svint32_t sveor_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_z)))
+svint64_t sveor_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_z)))
+svint16_t sveor_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u8)))
+uint8_t sveorv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u32)))
+uint32_t sveorv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u64)))
+uint64_t sveorv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u16)))
+uint16_t sveorv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s8)))
+int8_t sveorv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s32)))
+int32_t sveorv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s64)))
+int64_t sveorv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s16)))
+int16_t sveorv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u8)))
+svuint8_t svext_u8(svuint8_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u32)))
+svuint32_t svext_u32(svuint32_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u64)))
+svuint64_t svext_u64(svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u16)))
+svuint16_t svext_u16(svuint16_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s8)))
+svint8_t svext_s8(svint8_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f64)))
+svfloat64_t svext_f64(svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f32)))
+svfloat32_t svext_f32(svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f16)))
+svfloat16_t svext_f16(svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s32)))
+svint32_t svext_s32(svint32_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s64)))
+svint64_t svext_s64(svint64_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s16)))
+svint16_t svext_s16(svint16_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_m)))
+svint32_t svextb_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_m)))
+svint64_t svextb_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_m)))
+svint16_t svextb_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_x)))
+svint32_t svextb_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_x)))
+svint64_t svextb_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_x)))
+svint16_t svextb_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_z)))
+svint32_t svextb_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_z)))
+svint64_t svextb_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_z)))
+svint16_t svextb_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_m)))
+svuint32_t svextb_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_m)))
+svuint64_t svextb_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_m)))
+svuint16_t svextb_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_x)))
+svuint32_t svextb_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_x)))
+svuint64_t svextb_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_x)))
+svuint16_t svextb_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_z)))
+svuint32_t svextb_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_z)))
+svuint64_t svextb_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_z)))
+svuint16_t svextb_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_m)))
+svint32_t svexth_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_m)))
+svint64_t svexth_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_x)))
+svint32_t svexth_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_x)))
+svint64_t svexth_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_z)))
+svint32_t svexth_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_z)))
+svint64_t svexth_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_m)))
+svuint32_t svexth_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_m)))
+svuint64_t svexth_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_x)))
+svuint32_t svexth_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_x)))
+svuint64_t svexth_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_z)))
+svuint32_t svexth_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_z)))
+svuint64_t svexth_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_m)))
+svint64_t svextw_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_x)))
+svint64_t svextw_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_z)))
+svint64_t svextw_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_m)))
+svuint64_t svextw_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_x)))
+svuint64_t svextw_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_z)))
+svuint64_t svextw_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u8)))
+svuint8_t svget2_u8(svuint8x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u32)))
+svuint32_t svget2_u32(svuint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u64)))
+svuint64_t svget2_u64(svuint64x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u16)))
+svuint16_t svget2_u16(svuint16x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s8)))
+svint8_t svget2_s8(svint8x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f64)))
+svfloat64_t svget2_f64(svfloat64x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f32)))
+svfloat32_t svget2_f32(svfloat32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f16)))
+svfloat16_t svget2_f16(svfloat16x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s32)))
+svint32_t svget2_s32(svint32x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s64)))
+svint64_t svget2_s64(svint64x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s16)))
+svint16_t svget2_s16(svint16x2_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u8)))
+svuint8_t svget3_u8(svuint8x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u32)))
+svuint32_t svget3_u32(svuint32x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u64)))
+svuint64_t svget3_u64(svuint64x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u16)))
+svuint16_t svget3_u16(svuint16x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s8)))
+svint8_t svget3_s8(svint8x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f64)))
+svfloat64_t svget3_f64(svfloat64x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f32)))
+svfloat32_t svget3_f32(svfloat32x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f16)))
+svfloat16_t svget3_f16(svfloat16x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s32)))
+svint32_t svget3_s32(svint32x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s64)))
+svint64_t svget3_s64(svint64x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s16)))
+svint16_t svget3_s16(svint16x3_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u8)))
+svuint8_t svget4_u8(svuint8x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u32)))
+svuint32_t svget4_u32(svuint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u64)))
+svuint64_t svget4_u64(svuint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u16)))
+svuint16_t svget4_u16(svuint16x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s8)))
+svint8_t svget4_s8(svint8x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f64)))
+svfloat64_t svget4_f64(svfloat64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f32)))
+svfloat32_t svget4_f32(svfloat32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f16)))
+svfloat16_t svget4_f16(svfloat16x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s32)))
+svint32_t svget4_s32(svint32x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s64)))
+svint64_t svget4_s64(svint64x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s16)))
+svint16_t svget4_s16(svint16x4_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u8)))
+svuint8_t svindex_u8(uint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u32)))
+svuint32_t svindex_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u64)))
+svuint64_t svindex_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_u16)))
+svuint16_t svindex_u16(uint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s8)))
+svint8_t svindex_s8(int8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s32)))
+svint32_t svindex_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s64)))
+svint64_t svindex_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svindex_s16)))
+svint16_t svindex_s16(int16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u8)))
+svuint8_t svinsr_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u32)))
+svuint32_t svinsr_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u64)))
+svuint64_t svinsr_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u16)))
+svuint16_t svinsr_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s8)))
+svint8_t svinsr_n_s8(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f64)))
+svfloat64_t svinsr_n_f64(svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f32)))
+svfloat32_t svinsr_n_f32(svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f16)))
+svfloat16_t svinsr_n_f16(svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s32)))
+svint32_t svinsr_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s64)))
+svint64_t svinsr_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s16)))
+svint16_t svinsr_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u8)))
+uint8_t svlasta_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u32)))
+uint32_t svlasta_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u64)))
+uint64_t svlasta_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u16)))
+uint16_t svlasta_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s8)))
+int8_t svlasta_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f64)))
+float64_t svlasta_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f32)))
+float32_t svlasta_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f16)))
+float16_t svlasta_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s32)))
+int32_t svlasta_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s64)))
+int64_t svlasta_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s16)))
+int16_t svlasta_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u8)))
+uint8_t svlastb_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u32)))
+uint32_t svlastb_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u64)))
+uint64_t svlastb_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u16)))
+uint16_t svlastb_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s8)))
+int8_t svlastb_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f64)))
+float64_t svlastb_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f32)))
+float32_t svlastb_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f16)))
+float16_t svlastb_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s32)))
+int32_t svlastb_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s64)))
+int64_t svlastb_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s16)))
+int16_t svlastb_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u8)))
+svuint8_t svld1_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u32)))
+svuint32_t svld1_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u64)))
+svuint64_t svld1_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u16)))
+svuint16_t svld1_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s8)))
+svint8_t svld1_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f64)))
+svfloat64_t svld1_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f32)))
+svfloat32_t svld1_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f16)))
+svfloat16_t svld1_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s32)))
+svint32_t svld1_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s64)))
+svint64_t svld1_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s16)))
+svint16_t svld1_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u8)))
+svuint8_t svld1_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u32)))
+svuint32_t svld1_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u64)))
+svuint64_t svld1_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u16)))
+svuint16_t svld1_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s8)))
+svint8_t svld1_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f64)))
+svfloat64_t svld1_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f32)))
+svfloat32_t svld1_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f16)))
+svfloat16_t svld1_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s32)))
+svint32_t svld1_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s64)))
+svint64_t svld1_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s16)))
+svint16_t svld1_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u8)))
+svuint8_t svld1rq_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u32)))
+svuint32_t svld1rq_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u64)))
+svuint64_t svld1rq_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u16)))
+svuint16_t svld1rq_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s8)))
+svint8_t svld1rq_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f64)))
+svfloat64_t svld1rq_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f32)))
+svfloat32_t svld1rq_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f16)))
+svfloat16_t svld1rq_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s32)))
+svint32_t svld1rq_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s64)))
+svint64_t svld1rq_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s16)))
+svint16_t svld1rq_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_u32)))
+svuint32_t svld1sb_vnum_u32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_u64)))
+svuint64_t svld1sb_vnum_u64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_u16)))
+svuint16_t svld1sb_vnum_u16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_s32)))
+svint32_t svld1sb_vnum_s32(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_s64)))
+svint64_t svld1sb_vnum_s64(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_vnum_s16)))
+svint16_t svld1sb_vnum_s16(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_u32)))
+svuint32_t svld1sb_u32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_u64)))
+svuint64_t svld1sb_u64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_u16)))
+svuint16_t svld1sb_u16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_s32)))
+svint32_t svld1sb_s32(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_s64)))
+svint64_t svld1sb_s64(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sb_s16)))
+svint16_t svld1sb_s16(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_u32)))
+svuint32_t svld1sh_vnum_u32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_u64)))
+svuint64_t svld1sh_vnum_u64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_s32)))
+svint32_t svld1sh_vnum_s32(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_vnum_s64)))
+svint64_t svld1sh_vnum_s64(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_u32)))
+svuint32_t svld1sh_u32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_u64)))
+svuint64_t svld1sh_u64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_s32)))
+svint32_t svld1sh_s32(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sh_s64)))
+svint64_t svld1sh_s64(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_vnum_u64)))
+svuint64_t svld1sw_vnum_u64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_vnum_s64)))
+svint64_t svld1sw_vnum_s64(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_u64)))
+svuint64_t svld1sw_u64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1sw_s64)))
+svint64_t svld1sw_s64(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_u32)))
+svuint32_t svld1ub_vnum_u32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_u64)))
+svuint64_t svld1ub_vnum_u64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_u16)))
+svuint16_t svld1ub_vnum_u16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_s32)))
+svint32_t svld1ub_vnum_s32(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_s64)))
+svint64_t svld1ub_vnum_s64(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_vnum_s16)))
+svint16_t svld1ub_vnum_s16(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_u32)))
+svuint32_t svld1ub_u32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_u64)))
+svuint64_t svld1ub_u64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_u16)))
+svuint16_t svld1ub_u16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_s32)))
+svint32_t svld1ub_s32(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_s64)))
+svint64_t svld1ub_s64(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1ub_s16)))
+svint16_t svld1ub_s16(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_u32)))
+svuint32_t svld1uh_vnum_u32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_u64)))
+svuint64_t svld1uh_vnum_u64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_s32)))
+svint32_t svld1uh_vnum_s32(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_vnum_s64)))
+svint64_t svld1uh_vnum_s64(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_u32)))
+svuint32_t svld1uh_u32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_u64)))
+svuint64_t svld1uh_u64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_s32)))
+svint32_t svld1uh_s32(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uh_s64)))
+svint64_t svld1uh_s64(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_vnum_u64)))
+svuint64_t svld1uw_vnum_u64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_vnum_s64)))
+svint64_t svld1uw_vnum_s64(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_u64)))
+svuint64_t svld1uw_u64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1uw_s64)))
+svint64_t svld1uw_s64(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u8)))
+svuint8x2_t svld2_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u32)))
+svuint32x2_t svld2_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u64)))
+svuint64x2_t svld2_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u16)))
+svuint16x2_t svld2_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s8)))
+svint8x2_t svld2_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f64)))
+svfloat64x2_t svld2_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f32)))
+svfloat32x2_t svld2_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f16)))
+svfloat16x2_t svld2_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s32)))
+svint32x2_t svld2_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s64)))
+svint64x2_t svld2_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s16)))
+svint16x2_t svld2_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u8)))
+svuint8x2_t svld2_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u32)))
+svuint32x2_t svld2_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u64)))
+svuint64x2_t svld2_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u16)))
+svuint16x2_t svld2_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s8)))
+svint8x2_t svld2_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f64)))
+svfloat64x2_t svld2_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f32)))
+svfloat32x2_t svld2_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f16)))
+svfloat16x2_t svld2_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s32)))
+svint32x2_t svld2_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s64)))
+svint64x2_t svld2_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s16)))
+svint16x2_t svld2_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u8)))
+svuint8x3_t svld3_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u32)))
+svuint32x3_t svld3_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u64)))
+svuint64x3_t svld3_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u16)))
+svuint16x3_t svld3_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s8)))
+svint8x3_t svld3_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f64)))
+svfloat64x3_t svld3_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f32)))
+svfloat32x3_t svld3_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f16)))
+svfloat16x3_t svld3_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s32)))
+svint32x3_t svld3_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s64)))
+svint64x3_t svld3_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s16)))
+svint16x3_t svld3_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u8)))
+svuint8x3_t svld3_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u32)))
+svuint32x3_t svld3_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u64)))
+svuint64x3_t svld3_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u16)))
+svuint16x3_t svld3_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s8)))
+svint8x3_t svld3_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f64)))
+svfloat64x3_t svld3_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f32)))
+svfloat32x3_t svld3_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f16)))
+svfloat16x3_t svld3_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s32)))
+svint32x3_t svld3_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s64)))
+svint64x3_t svld3_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s16)))
+svint16x3_t svld3_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u8)))
+svuint8x4_t svld4_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u32)))
+svuint32x4_t svld4_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u64)))
+svuint64x4_t svld4_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u16)))
+svuint16x4_t svld4_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s8)))
+svint8x4_t svld4_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f64)))
+svfloat64x4_t svld4_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f32)))
+svfloat32x4_t svld4_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f16)))
+svfloat16x4_t svld4_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s32)))
+svint32x4_t svld4_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s64)))
+svint64x4_t svld4_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s16)))
+svint16x4_t svld4_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u8)))
+svuint8x4_t svld4_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u32)))
+svuint32x4_t svld4_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u64)))
+svuint64x4_t svld4_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u16)))
+svuint16x4_t svld4_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s8)))
+svint8x4_t svld4_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f64)))
+svfloat64x4_t svld4_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f32)))
+svfloat32x4_t svld4_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f16)))
+svfloat16x4_t svld4_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s32)))
+svint32x4_t svld4_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s64)))
+svint64x4_t svld4_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s16)))
+svint16x4_t svld4_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u8)))
+svuint8_t svldnt1_u8(svbool_t, uint8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u32)))
+svuint32_t svldnt1_u32(svbool_t, uint32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u64)))
+svuint64_t svldnt1_u64(svbool_t, uint64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u16)))
+svuint16_t svldnt1_u16(svbool_t, uint16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s8)))
+svint8_t svldnt1_s8(svbool_t, int8_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f64)))
+svfloat64_t svldnt1_f64(svbool_t, float64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f32)))
+svfloat32_t svldnt1_f32(svbool_t, float32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f16)))
+svfloat16_t svldnt1_f16(svbool_t, float16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s32)))
+svint32_t svldnt1_s32(svbool_t, int32_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s64)))
+svint64_t svldnt1_s64(svbool_t, int64_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s16)))
+svint16_t svldnt1_s16(svbool_t, int16_t const *);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u8)))
+svuint8_t svldnt1_vnum_u8(svbool_t, uint8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u32)))
+svuint32_t svldnt1_vnum_u32(svbool_t, uint32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u64)))
+svuint64_t svldnt1_vnum_u64(svbool_t, uint64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u16)))
+svuint16_t svldnt1_vnum_u16(svbool_t, uint16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s8)))
+svint8_t svldnt1_vnum_s8(svbool_t, int8_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f64)))
+svfloat64_t svldnt1_vnum_f64(svbool_t, float64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32)))
+svfloat32_t svldnt1_vnum_f32(svbool_t, float32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f16)))
+svfloat16_t svldnt1_vnum_f16(svbool_t, float16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32)))
+svint32_t svldnt1_vnum_s32(svbool_t, int32_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s64)))
+svint64_t svldnt1_vnum_s64(svbool_t, int64_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s16)))
+svint16_t svldnt1_vnum_s16(svbool_t, int16_t const *, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u8)))
+uint64_t svlen_u8(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u32)))
+uint64_t svlen_u32(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u64)))
+uint64_t svlen_u64(svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u16)))
+uint64_t svlen_u16(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s8)))
+uint64_t svlen_s8(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f64)))
+uint64_t svlen_f64(svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f32)))
+uint64_t svlen_f32(svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f16)))
+uint64_t svlen_f16(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s32)))
+uint64_t svlen_s32(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s64)))
+uint64_t svlen_s64(svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s16)))
+uint64_t svlen_s16(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_m)))
+svuint8_t svlsl_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_m)))
+svuint32_t svlsl_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_m)))
+svuint64_t svlsl_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_m)))
+svuint16_t svlsl_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_m)))
+svint8_t svlsl_n_s8_m(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_m)))
+svint32_t svlsl_n_s32_m(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_m)))
+svint64_t svlsl_n_s64_m(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_m)))
+svint16_t svlsl_n_s16_m(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_x)))
+svuint8_t svlsl_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_x)))
+svuint32_t svlsl_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_x)))
+svuint64_t svlsl_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_x)))
+svuint16_t svlsl_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_x)))
+svint8_t svlsl_n_s8_x(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_x)))
+svint32_t svlsl_n_s32_x(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_x)))
+svint64_t svlsl_n_s64_x(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_x)))
+svint16_t svlsl_n_s16_x(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_z)))
+svuint8_t svlsl_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_z)))
+svuint32_t svlsl_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_z)))
+svuint64_t svlsl_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_z)))
+svuint16_t svlsl_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_z)))
+svint8_t svlsl_n_s8_z(svbool_t, svint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_z)))
+svint32_t svlsl_n_s32_z(svbool_t, svint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_z)))
+svint64_t svlsl_n_s64_z(svbool_t, svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_z)))
+svint16_t svlsl_n_s16_z(svbool_t, svint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_m)))
+svuint8_t svlsl_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_m)))
+svuint32_t svlsl_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_m)))
+svuint64_t svlsl_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_m)))
+svuint16_t svlsl_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_m)))
+svint8_t svlsl_s8_m(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_m)))
+svint32_t svlsl_s32_m(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_m)))
+svint64_t svlsl_s64_m(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_m)))
+svint16_t svlsl_s16_m(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_x)))
+svuint8_t svlsl_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_x)))
+svuint32_t svlsl_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_x)))
+svuint64_t svlsl_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_x)))
+svuint16_t svlsl_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_x)))
+svint8_t svlsl_s8_x(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_x)))
+svint32_t svlsl_s32_x(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_x)))
+svint64_t svlsl_s64_x(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_x)))
+svint16_t svlsl_s16_x(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_z)))
+svuint8_t svlsl_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_z)))
+svuint32_t svlsl_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_z)))
+svuint64_t svlsl_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_z)))
+svuint16_t svlsl_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_z)))
+svint8_t svlsl_s8_z(svbool_t, svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_z)))
+svint32_t svlsl_s32_z(svbool_t, svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_z)))
+svint64_t svlsl_s64_z(svbool_t, svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_z)))
+svint16_t svlsl_s16_z(svbool_t, svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_m)))
+svuint8_t svlsl_wide_n_u8_m(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_m)))
+svuint32_t svlsl_wide_n_u32_m(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_m)))
+svuint16_t svlsl_wide_n_u16_m(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_m)))
+svint8_t svlsl_wide_n_s8_m(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_m)))
+svint32_t svlsl_wide_n_s32_m(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_m)))
+svint16_t svlsl_wide_n_s16_m(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_x)))
+svuint8_t svlsl_wide_n_u8_x(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_x)))
+svuint32_t svlsl_wide_n_u32_x(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_x)))
+svuint16_t svlsl_wide_n_u16_x(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_x)))
+svint8_t svlsl_wide_n_s8_x(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_x)))
+svint32_t svlsl_wide_n_s32_x(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_x)))
+svint16_t svlsl_wide_n_s16_x(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_z)))
+svuint8_t svlsl_wide_n_u8_z(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_z)))
+svuint32_t svlsl_wide_n_u32_z(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_z)))
+svuint16_t svlsl_wide_n_u16_z(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_z)))
+svint8_t svlsl_wide_n_s8_z(svbool_t, svint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_z)))
+svint32_t svlsl_wide_n_s32_z(svbool_t, svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_z)))
+svint16_t svlsl_wide_n_s16_z(svbool_t, svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_m)))
+svuint8_t svlsl_wide_u8_m(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_m)))
+svuint32_t svlsl_wide_u32_m(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_m)))
+svuint16_t svlsl_wide_u16_m(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_m)))
+svint8_t svlsl_wide_s8_m(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_m)))
+svint32_t svlsl_wide_s32_m(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_m)))
+svint16_t svlsl_wide_s16_m(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_x)))
+svuint8_t svlsl_wide_u8_x(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_x)))
+svuint32_t svlsl_wide_u32_x(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_x)))
+svuint16_t svlsl_wide_u16_x(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_x)))
+svint8_t svlsl_wide_s8_x(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_x)))
+svint32_t svlsl_wide_s32_x(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_x)))
+svint16_t svlsl_wide_s16_x(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_z)))
+svuint8_t svlsl_wide_u8_z(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_z)))
+svuint32_t svlsl_wide_u32_z(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_z)))
+svuint16_t svlsl_wide_u16_z(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_z)))
+svint8_t svlsl_wide_s8_z(svbool_t, svint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_z)))
+svint32_t svlsl_wide_s32_z(svbool_t, svint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_z)))
+svint16_t svlsl_wide_s16_z(svbool_t, svint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_m)))
+svuint8_t svlsr_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_m)))
+svuint32_t svlsr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_m)))
+svuint64_t svlsr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_m)))
+svuint16_t svlsr_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_x)))
+svuint8_t svlsr_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_x)))
+svuint32_t svlsr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_x)))
+svuint64_t svlsr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_x)))
+svuint16_t svlsr_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_z)))
+svuint8_t svlsr_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_z)))
+svuint32_t svlsr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_z)))
+svuint64_t svlsr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_z)))
+svuint16_t svlsr_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_m)))
+svuint8_t svlsr_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_m)))
+svuint32_t svlsr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_m)))
+svuint64_t svlsr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_m)))
+svuint16_t svlsr_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_x)))
+svuint8_t svlsr_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_x)))
+svuint32_t svlsr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_x)))
+svuint64_t svlsr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_x)))
+svuint16_t svlsr_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_z)))
+svuint8_t svlsr_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_z)))
+svuint32_t svlsr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_z)))
+svuint64_t svlsr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_z)))
+svuint16_t svlsr_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_m)))
+svuint8_t svlsr_wide_n_u8_m(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_m)))
+svuint32_t svlsr_wide_n_u32_m(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_m)))
+svuint16_t svlsr_wide_n_u16_m(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_x)))
+svuint8_t svlsr_wide_n_u8_x(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_x)))
+svuint32_t svlsr_wide_n_u32_x(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_x)))
+svuint16_t svlsr_wide_n_u16_x(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_z)))
+svuint8_t svlsr_wide_n_u8_z(svbool_t, svuint8_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_z)))
+svuint32_t svlsr_wide_n_u32_z(svbool_t, svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_z)))
+svuint16_t svlsr_wide_n_u16_z(svbool_t, svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_m)))
+svuint8_t svlsr_wide_u8_m(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_m)))
+svuint32_t svlsr_wide_u32_m(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_m)))
+svuint16_t svlsr_wide_u16_m(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_x)))
+svuint8_t svlsr_wide_u8_x(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_x)))
+svuint32_t svlsr_wide_u32_x(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_x)))
+svuint16_t svlsr_wide_u16_x(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_z)))
+svuint8_t svlsr_wide_u8_z(svbool_t, svuint8_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_z)))
+svuint32_t svlsr_wide_u32_z(svbool_t, svuint32_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_z)))
+svuint16_t svlsr_wide_u16_z(svbool_t, svuint16_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_m)))
+svfloat64_t svmad_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_m)))
+svfloat32_t svmad_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_m)))
+svfloat16_t svmad_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_x)))
+svfloat64_t svmad_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_x)))
+svfloat32_t svmad_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_x)))
+svfloat16_t svmad_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_z)))
+svfloat64_t svmad_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_z)))
+svfloat32_t svmad_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_z)))
+svfloat16_t svmad_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_m)))
+svuint8_t svmad_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_m)))
+svuint32_t svmad_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_m)))
+svuint64_t svmad_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_m)))
+svuint16_t svmad_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_m)))
+svint8_t svmad_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_m)))
+svint32_t svmad_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_m)))
+svint64_t svmad_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_m)))
+svint16_t svmad_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_x)))
+svuint8_t svmad_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_x)))
+svuint32_t svmad_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_x)))
+svuint64_t svmad_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_x)))
+svuint16_t svmad_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_x)))
+svint8_t svmad_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_x)))
+svint32_t svmad_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_x)))
+svint64_t svmad_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_x)))
+svint16_t svmad_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_z)))
+svuint8_t svmad_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_z)))
+svuint32_t svmad_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_z)))
+svuint64_t svmad_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_z)))
+svuint16_t svmad_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_z)))
+svint8_t svmad_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_z)))
+svint32_t svmad_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_z)))
+svint64_t svmad_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_z)))
+svint16_t svmad_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_m)))
+svfloat64_t svmad_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_m)))
+svfloat32_t svmad_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_m)))
+svfloat16_t svmad_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_x)))
+svfloat64_t svmad_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_x)))
+svfloat32_t svmad_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_x)))
+svfloat16_t svmad_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_z)))
+svfloat64_t svmad_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_z)))
+svfloat32_t svmad_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_z)))
+svfloat16_t svmad_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_m)))
+svuint8_t svmad_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_m)))
+svuint32_t svmad_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_m)))
+svuint64_t svmad_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_m)))
+svuint16_t svmad_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_m)))
+svint8_t svmad_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_m)))
+svint32_t svmad_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_m)))
+svint64_t svmad_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_m)))
+svint16_t svmad_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_x)))
+svuint8_t svmad_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_x)))
+svuint32_t svmad_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_x)))
+svuint64_t svmad_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_x)))
+svuint16_t svmad_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_x)))
+svint8_t svmad_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_x)))
+svint32_t svmad_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_x)))
+svint64_t svmad_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_x)))
+svint16_t svmad_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_z)))
+svuint8_t svmad_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_z)))
+svuint32_t svmad_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_z)))
+svuint64_t svmad_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_z)))
+svuint16_t svmad_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_z)))
+svint8_t svmad_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_z)))
+svint32_t svmad_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_z)))
+svint64_t svmad_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_z)))
+svint16_t svmad_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_m)))
+svfloat64_t svmax_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_m)))
+svfloat32_t svmax_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_m)))
+svfloat16_t svmax_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_x)))
+svfloat64_t svmax_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_x)))
+svfloat32_t svmax_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_x)))
+svfloat16_t svmax_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_z)))
+svfloat64_t svmax_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_z)))
+svfloat32_t svmax_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_z)))
+svfloat16_t svmax_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_m)))
+svint8_t svmax_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_m)))
+svint32_t svmax_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_m)))
+svint64_t svmax_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_m)))
+svint16_t svmax_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_x)))
+svint8_t svmax_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_x)))
+svint32_t svmax_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_x)))
+svint64_t svmax_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_x)))
+svint16_t svmax_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_z)))
+svint8_t svmax_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_z)))
+svint32_t svmax_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_z)))
+svint64_t svmax_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_z)))
+svint16_t svmax_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_m)))
+svuint8_t svmax_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_m)))
+svuint32_t svmax_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_m)))
+svuint64_t svmax_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_m)))
+svuint16_t svmax_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_x)))
+svuint8_t svmax_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_x)))
+svuint32_t svmax_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_x)))
+svuint64_t svmax_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_x)))
+svuint16_t svmax_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_z)))
+svuint8_t svmax_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_z)))
+svuint32_t svmax_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_z)))
+svuint64_t svmax_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_z)))
+svuint16_t svmax_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_m)))
+svfloat64_t svmax_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_m)))
+svfloat32_t svmax_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_m)))
+svfloat16_t svmax_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x)))
+svfloat64_t svmax_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x)))
+svfloat32_t svmax_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x)))
+svfloat16_t svmax_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_z)))
+svfloat64_t svmax_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_z)))
+svfloat32_t svmax_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_z)))
+svfloat16_t svmax_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_m)))
+svint8_t svmax_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_m)))
+svint32_t svmax_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_m)))
+svint64_t svmax_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_m)))
+svint16_t svmax_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x)))
+svint8_t svmax_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x)))
+svint32_t svmax_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x)))
+svint64_t svmax_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x)))
+svint16_t svmax_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_z)))
+svint8_t svmax_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_z)))
+svint32_t svmax_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_z)))
+svint64_t svmax_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_z)))
+svint16_t svmax_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_m)))
+svuint8_t svmax_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_m)))
+svuint32_t svmax_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_m)))
+svuint64_t svmax_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_m)))
+svuint16_t svmax_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x)))
+svuint8_t svmax_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x)))
+svuint32_t svmax_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x)))
+svuint64_t svmax_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x)))
+svuint16_t svmax_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_z)))
+svuint8_t svmax_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_z)))
+svuint32_t svmax_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_z)))
+svuint64_t svmax_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_z)))
+svuint16_t svmax_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_m)))
+svfloat64_t svmaxnm_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_m)))
+svfloat32_t svmaxnm_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_m)))
+svfloat16_t svmaxnm_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_x)))
+svfloat64_t svmaxnm_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_x)))
+svfloat32_t svmaxnm_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_x)))
+svfloat16_t svmaxnm_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_z)))
+svfloat64_t svmaxnm_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_z)))
+svfloat32_t svmaxnm_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_z)))
+svfloat16_t svmaxnm_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_m)))
+svfloat64_t svmaxnm_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_m)))
+svfloat32_t svmaxnm_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_m)))
+svfloat16_t svmaxnm_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x)))
+svfloat64_t svmaxnm_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x)))
+svfloat32_t svmaxnm_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x)))
+svfloat16_t svmaxnm_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_z)))
+svfloat64_t svmaxnm_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_z)))
+svfloat32_t svmaxnm_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_z)))
+svfloat16_t svmaxnm_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f64)))
+float64_t svmaxnmv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f32)))
+float32_t svmaxnmv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f16)))
+float16_t svmaxnmv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f64)))
+float64_t svmaxv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f32)))
+float32_t svmaxv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f16)))
+float16_t svmaxv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s8)))
+int8_t svmaxv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s32)))
+int32_t svmaxv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s64)))
+int64_t svmaxv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s16)))
+int16_t svmaxv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u8)))
+uint8_t svmaxv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u32)))
+uint32_t svmaxv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u64)))
+uint64_t svmaxv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u16)))
+uint16_t svmaxv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_m)))
+svfloat64_t svmin_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_m)))
+svfloat32_t svmin_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_m)))
+svfloat16_t svmin_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_x)))
+svfloat64_t svmin_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_x)))
+svfloat32_t svmin_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_x)))
+svfloat16_t svmin_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_z)))
+svfloat64_t svmin_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_z)))
+svfloat32_t svmin_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_z)))
+svfloat16_t svmin_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_m)))
+svint8_t svmin_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_m)))
+svint32_t svmin_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_m)))
+svint64_t svmin_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_m)))
+svint16_t svmin_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_x)))
+svint8_t svmin_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_x)))
+svint32_t svmin_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_x)))
+svint64_t svmin_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_x)))
+svint16_t svmin_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_z)))
+svint8_t svmin_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_z)))
+svint32_t svmin_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_z)))
+svint64_t svmin_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_z)))
+svint16_t svmin_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_m)))
+svuint8_t svmin_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_m)))
+svuint32_t svmin_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_m)))
+svuint64_t svmin_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_m)))
+svuint16_t svmin_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_x)))
+svuint8_t svmin_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_x)))
+svuint32_t svmin_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_x)))
+svuint64_t svmin_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_x)))
+svuint16_t svmin_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_z)))
+svuint8_t svmin_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_z)))
+svuint32_t svmin_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_z)))
+svuint64_t svmin_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_z)))
+svuint16_t svmin_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_m)))
+svfloat64_t svmin_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_m)))
+svfloat32_t svmin_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_m)))
+svfloat16_t svmin_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x)))
+svfloat64_t svmin_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x)))
+svfloat32_t svmin_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x)))
+svfloat16_t svmin_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_z)))
+svfloat64_t svmin_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_z)))
+svfloat32_t svmin_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_z)))
+svfloat16_t svmin_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_m)))
+svint8_t svmin_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_m)))
+svint32_t svmin_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_m)))
+svint64_t svmin_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_m)))
+svint16_t svmin_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x)))
+svint8_t svmin_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x)))
+svint32_t svmin_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x)))
+svint64_t svmin_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x)))
+svint16_t svmin_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_z)))
+svint8_t svmin_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_z)))
+svint32_t svmin_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_z)))
+svint64_t svmin_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_z)))
+svint16_t svmin_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_m)))
+svuint8_t svmin_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_m)))
+svuint32_t svmin_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_m)))
+svuint64_t svmin_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_m)))
+svuint16_t svmin_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x)))
+svuint8_t svmin_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x)))
+svuint32_t svmin_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x)))
+svuint64_t svmin_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x)))
+svuint16_t svmin_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_z)))
+svuint8_t svmin_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_z)))
+svuint32_t svmin_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_z)))
+svuint64_t svmin_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_z)))
+svuint16_t svmin_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_m)))
+svfloat64_t svminnm_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_m)))
+svfloat32_t svminnm_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_m)))
+svfloat16_t svminnm_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_x)))
+svfloat64_t svminnm_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_x)))
+svfloat32_t svminnm_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_x)))
+svfloat16_t svminnm_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_z)))
+svfloat64_t svminnm_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_z)))
+svfloat32_t svminnm_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_z)))
+svfloat16_t svminnm_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_m)))
+svfloat64_t svminnm_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_m)))
+svfloat32_t svminnm_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_m)))
+svfloat16_t svminnm_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x)))
+svfloat64_t svminnm_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x)))
+svfloat32_t svminnm_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x)))
+svfloat16_t svminnm_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_z)))
+svfloat64_t svminnm_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_z)))
+svfloat32_t svminnm_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_z)))
+svfloat16_t svminnm_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f64)))
+float64_t svminnmv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f32)))
+float32_t svminnmv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f16)))
+float16_t svminnmv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f64)))
+float64_t svminv_f64(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f32)))
+float32_t svminv_f32(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f16)))
+float16_t svminv_f16(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s8)))
+int8_t svminv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s32)))
+int32_t svminv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s64)))
+int64_t svminv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s16)))
+int16_t svminv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u8)))
+uint8_t svminv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u32)))
+uint32_t svminv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u64)))
+uint64_t svminv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u16)))
+uint16_t svminv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_m)))
+svfloat64_t svmla_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_m)))
+svfloat32_t svmla_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_m)))
+svfloat16_t svmla_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_x)))
+svfloat64_t svmla_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_x)))
+svfloat32_t svmla_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_x)))
+svfloat16_t svmla_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_z)))
+svfloat64_t svmla_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_z)))
+svfloat32_t svmla_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_z)))
+svfloat16_t svmla_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_m)))
+svuint8_t svmla_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_m)))
+svuint32_t svmla_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_m)))
+svuint64_t svmla_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_m)))
+svuint16_t svmla_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_m)))
+svint8_t svmla_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_m)))
+svint32_t svmla_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_m)))
+svint64_t svmla_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_m)))
+svint16_t svmla_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_x)))
+svuint8_t svmla_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_x)))
+svuint32_t svmla_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_x)))
+svuint64_t svmla_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_x)))
+svuint16_t svmla_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_x)))
+svint8_t svmla_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_x)))
+svint32_t svmla_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_x)))
+svint64_t svmla_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_x)))
+svint16_t svmla_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_z)))
+svuint8_t svmla_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_z)))
+svuint32_t svmla_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_z)))
+svuint64_t svmla_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_z)))
+svuint16_t svmla_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_z)))
+svint8_t svmla_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_z)))
+svint32_t svmla_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_z)))
+svint64_t svmla_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_z)))
+svint16_t svmla_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_m)))
+svfloat64_t svmla_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_m)))
+svfloat32_t svmla_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_m)))
+svfloat16_t svmla_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_x)))
+svfloat64_t svmla_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_x)))
+svfloat32_t svmla_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_x)))
+svfloat16_t svmla_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_z)))
+svfloat64_t svmla_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_z)))
+svfloat32_t svmla_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_z)))
+svfloat16_t svmla_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_m)))
+svuint8_t svmla_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_m)))
+svuint32_t svmla_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_m)))
+svuint64_t svmla_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_m)))
+svuint16_t svmla_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_m)))
+svint8_t svmla_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_m)))
+svint32_t svmla_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_m)))
+svint64_t svmla_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_m)))
+svint16_t svmla_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_x)))
+svuint8_t svmla_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_x)))
+svuint32_t svmla_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_x)))
+svuint64_t svmla_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_x)))
+svuint16_t svmla_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_x)))
+svint8_t svmla_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_x)))
+svint32_t svmla_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_x)))
+svint64_t svmla_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_x)))
+svint16_t svmla_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_z)))
+svuint8_t svmla_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_z)))
+svuint32_t svmla_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_z)))
+svuint64_t svmla_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_z)))
+svuint16_t svmla_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_z)))
+svint8_t svmla_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_z)))
+svint32_t svmla_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_z)))
+svint64_t svmla_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_z)))
+svint16_t svmla_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f64)))
+svfloat64_t svmla_lane_f64(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f32)))
+svfloat32_t svmla_lane_f32(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f16)))
+svfloat16_t svmla_lane_f16(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_m)))
+svfloat64_t svmls_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_m)))
+svfloat32_t svmls_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_m)))
+svfloat16_t svmls_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_x)))
+svfloat64_t svmls_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_x)))
+svfloat32_t svmls_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_x)))
+svfloat16_t svmls_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_z)))
+svfloat64_t svmls_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_z)))
+svfloat32_t svmls_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_z)))
+svfloat16_t svmls_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_m)))
+svuint8_t svmls_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_m)))
+svuint32_t svmls_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_m)))
+svuint64_t svmls_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_m)))
+svuint16_t svmls_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_m)))
+svint8_t svmls_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_m)))
+svint32_t svmls_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_m)))
+svint64_t svmls_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_m)))
+svint16_t svmls_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_x)))
+svuint8_t svmls_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_x)))
+svuint32_t svmls_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_x)))
+svuint64_t svmls_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_x)))
+svuint16_t svmls_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_x)))
+svint8_t svmls_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_x)))
+svint32_t svmls_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_x)))
+svint64_t svmls_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_x)))
+svint16_t svmls_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_z)))
+svuint8_t svmls_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_z)))
+svuint32_t svmls_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_z)))
+svuint64_t svmls_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_z)))
+svuint16_t svmls_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_z)))
+svint8_t svmls_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_z)))
+svint32_t svmls_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_z)))
+svint64_t svmls_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_z)))
+svint16_t svmls_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_m)))
+svfloat64_t svmls_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_m)))
+svfloat32_t svmls_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_m)))
+svfloat16_t svmls_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_x)))
+svfloat64_t svmls_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_x)))
+svfloat32_t svmls_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_x)))
+svfloat16_t svmls_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_z)))
+svfloat64_t svmls_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_z)))
+svfloat32_t svmls_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_z)))
+svfloat16_t svmls_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_m)))
+svuint8_t svmls_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_m)))
+svuint32_t svmls_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_m)))
+svuint64_t svmls_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_m)))
+svuint16_t svmls_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_m)))
+svint8_t svmls_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_m)))
+svint32_t svmls_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_m)))
+svint64_t svmls_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_m)))
+svint16_t svmls_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_x)))
+svuint8_t svmls_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_x)))
+svuint32_t svmls_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_x)))
+svuint64_t svmls_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_x)))
+svuint16_t svmls_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_x)))
+svint8_t svmls_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_x)))
+svint32_t svmls_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_x)))
+svint64_t svmls_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_x)))
+svint16_t svmls_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_z)))
+svuint8_t svmls_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_z)))
+svuint32_t svmls_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_z)))
+svuint64_t svmls_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_z)))
+svuint16_t svmls_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_z)))
+svint8_t svmls_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_z)))
+svint32_t svmls_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_z)))
+svint64_t svmls_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_z)))
+svint16_t svmls_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f64)))
+svfloat64_t svmls_lane_f64(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f32)))
+svfloat32_t svmls_lane_f32(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f16)))
+svfloat16_t svmls_lane_f16(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmov_b_z)))
+svbool_t svmov_b_z(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_m)))
+svfloat64_t svmsb_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_m)))
+svfloat32_t svmsb_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_m)))
+svfloat16_t svmsb_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_x)))
+svfloat64_t svmsb_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_x)))
+svfloat32_t svmsb_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_x)))
+svfloat16_t svmsb_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_z)))
+svfloat64_t svmsb_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_z)))
+svfloat32_t svmsb_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_z)))
+svfloat16_t svmsb_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_m)))
+svuint8_t svmsb_n_u8_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_m)))
+svuint32_t svmsb_n_u32_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_m)))
+svuint64_t svmsb_n_u64_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_m)))
+svuint16_t svmsb_n_u16_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_m)))
+svint8_t svmsb_n_s8_m(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_m)))
+svint32_t svmsb_n_s32_m(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_m)))
+svint64_t svmsb_n_s64_m(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_m)))
+svint16_t svmsb_n_s16_m(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_x)))
+svuint8_t svmsb_n_u8_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_x)))
+svuint32_t svmsb_n_u32_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_x)))
+svuint64_t svmsb_n_u64_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_x)))
+svuint16_t svmsb_n_u16_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_x)))
+svint8_t svmsb_n_s8_x(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_x)))
+svint32_t svmsb_n_s32_x(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_x)))
+svint64_t svmsb_n_s64_x(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_x)))
+svint16_t svmsb_n_s16_x(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_z)))
+svuint8_t svmsb_n_u8_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_z)))
+svuint32_t svmsb_n_u32_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_z)))
+svuint64_t svmsb_n_u64_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_z)))
+svuint16_t svmsb_n_u16_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_z)))
+svint8_t svmsb_n_s8_z(svbool_t, svint8_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_z)))
+svint32_t svmsb_n_s32_z(svbool_t, svint32_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_z)))
+svint64_t svmsb_n_s64_z(svbool_t, svint64_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_z)))
+svint16_t svmsb_n_s16_z(svbool_t, svint16_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_m)))
+svfloat64_t svmsb_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_m)))
+svfloat32_t svmsb_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_m)))
+svfloat16_t svmsb_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_x)))
+svfloat64_t svmsb_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_x)))
+svfloat32_t svmsb_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_x)))
+svfloat16_t svmsb_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_z)))
+svfloat64_t svmsb_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_z)))
+svfloat32_t svmsb_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_z)))
+svfloat16_t svmsb_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_m)))
+svuint8_t svmsb_u8_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_m)))
+svuint32_t svmsb_u32_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_m)))
+svuint64_t svmsb_u64_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_m)))
+svuint16_t svmsb_u16_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_m)))
+svint8_t svmsb_s8_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_m)))
+svint32_t svmsb_s32_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_m)))
+svint64_t svmsb_s64_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_m)))
+svint16_t svmsb_s16_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_x)))
+svuint8_t svmsb_u8_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_x)))
+svuint32_t svmsb_u32_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_x)))
+svuint64_t svmsb_u64_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_x)))
+svuint16_t svmsb_u16_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_x)))
+svint8_t svmsb_s8_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_x)))
+svint32_t svmsb_s32_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_x)))
+svint64_t svmsb_s64_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_x)))
+svint16_t svmsb_s16_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_z)))
+svuint8_t svmsb_u8_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_z)))
+svuint32_t svmsb_u32_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_z)))
+svuint64_t svmsb_u64_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_z)))
+svuint16_t svmsb_u16_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_z)))
+svint8_t svmsb_s8_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_z)))
+svint32_t svmsb_s32_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_z)))
+svint64_t svmsb_s64_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_z)))
+svint16_t svmsb_s16_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_m)))
+svfloat64_t svmul_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_m)))
+svfloat32_t svmul_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_m)))
+svfloat16_t svmul_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_x)))
+svfloat64_t svmul_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_x)))
+svfloat32_t svmul_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_x)))
+svfloat16_t svmul_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_z)))
+svfloat64_t svmul_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_z)))
+svfloat32_t svmul_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_z)))
+svfloat16_t svmul_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_m)))
+svuint8_t svmul_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_m)))
+svuint32_t svmul_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_m)))
+svuint64_t svmul_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_m)))
+svuint16_t svmul_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_m)))
+svint8_t svmul_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_m)))
+svint32_t svmul_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_m)))
+svint64_t svmul_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_m)))
+svint16_t svmul_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_x)))
+svuint8_t svmul_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_x)))
+svuint32_t svmul_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_x)))
+svuint64_t svmul_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_x)))
+svuint16_t svmul_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_x)))
+svint8_t svmul_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_x)))
+svint32_t svmul_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_x)))
+svint64_t svmul_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_x)))
+svint16_t svmul_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_z)))
+svuint8_t svmul_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_z)))
+svuint32_t svmul_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_z)))
+svuint64_t svmul_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_z)))
+svuint16_t svmul_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_z)))
+svint8_t svmul_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_z)))
+svint32_t svmul_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_z)))
+svint64_t svmul_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_z)))
+svint16_t svmul_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_m)))
+svfloat64_t svmul_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_m)))
+svfloat32_t svmul_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_m)))
+svfloat16_t svmul_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_x)))
+svfloat64_t svmul_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_x)))
+svfloat32_t svmul_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_x)))
+svfloat16_t svmul_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_z)))
+svfloat64_t svmul_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_z)))
+svfloat32_t svmul_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_z)))
+svfloat16_t svmul_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_m)))
+svuint8_t svmul_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_m)))
+svuint32_t svmul_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_m)))
+svuint64_t svmul_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_m)))
+svuint16_t svmul_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_m)))
+svint8_t svmul_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_m)))
+svint32_t svmul_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_m)))
+svint64_t svmul_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_m)))
+svint16_t svmul_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_x)))
+svuint8_t svmul_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_x)))
+svuint32_t svmul_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_x)))
+svuint64_t svmul_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_x)))
+svuint16_t svmul_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_x)))
+svint8_t svmul_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_x)))
+svint32_t svmul_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_x)))
+svint64_t svmul_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_x)))
+svint16_t svmul_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_z)))
+svuint8_t svmul_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_z)))
+svuint32_t svmul_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_z)))
+svuint64_t svmul_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_z)))
+svuint16_t svmul_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_z)))
+svint8_t svmul_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_z)))
+svint32_t svmul_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_z)))
+svint64_t svmul_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_z)))
+svint16_t svmul_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f64)))
+svfloat64_t svmul_lane_f64(svfloat64_t, svfloat64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f32)))
+svfloat32_t svmul_lane_f32(svfloat32_t, svfloat32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f16)))
+svfloat16_t svmul_lane_f16(svfloat16_t, svfloat16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_m)))
+svint8_t svmulh_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_m)))
+svint32_t svmulh_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_m)))
+svint64_t svmulh_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_m)))
+svint16_t svmulh_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_x)))
+svint8_t svmulh_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_x)))
+svint32_t svmulh_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_x)))
+svint64_t svmulh_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_x)))
+svint16_t svmulh_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_z)))
+svint8_t svmulh_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_z)))
+svint32_t svmulh_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_z)))
+svint64_t svmulh_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_z)))
+svint16_t svmulh_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_m)))
+svuint8_t svmulh_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_m)))
+svuint32_t svmulh_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_m)))
+svuint64_t svmulh_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_m)))
+svuint16_t svmulh_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_x)))
+svuint8_t svmulh_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_x)))
+svuint32_t svmulh_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_x)))
+svuint64_t svmulh_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_x)))
+svuint16_t svmulh_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_z)))
+svuint8_t svmulh_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_z)))
+svuint32_t svmulh_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_z)))
+svuint64_t svmulh_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_z)))
+svuint16_t svmulh_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_m)))
+svint8_t svmulh_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_m)))
+svint32_t svmulh_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_m)))
+svint64_t svmulh_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_m)))
+svint16_t svmulh_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_x)))
+svint8_t svmulh_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_x)))
+svint32_t svmulh_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_x)))
+svint64_t svmulh_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_x)))
+svint16_t svmulh_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_z)))
+svint8_t svmulh_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_z)))
+svint32_t svmulh_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_z)))
+svint64_t svmulh_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_z)))
+svint16_t svmulh_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_m)))
+svuint8_t svmulh_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_m)))
+svuint32_t svmulh_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_m)))
+svuint64_t svmulh_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_m)))
+svuint16_t svmulh_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_x)))
+svuint8_t svmulh_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_x)))
+svuint32_t svmulh_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_x)))
+svuint64_t svmulh_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_x)))
+svuint16_t svmulh_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_z)))
+svuint8_t svmulh_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_z)))
+svuint32_t svmulh_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_z)))
+svuint64_t svmulh_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_z)))
+svuint16_t svmulh_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_m)))
+svfloat64_t svmulx_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_m)))
+svfloat32_t svmulx_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_m)))
+svfloat16_t svmulx_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_x)))
+svfloat64_t svmulx_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_x)))
+svfloat32_t svmulx_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_x)))
+svfloat16_t svmulx_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_z)))
+svfloat64_t svmulx_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_z)))
+svfloat32_t svmulx_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_z)))
+svfloat16_t svmulx_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_m)))
+svfloat64_t svmulx_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_m)))
+svfloat32_t svmulx_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_m)))
+svfloat16_t svmulx_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_x)))
+svfloat64_t svmulx_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_x)))
+svfloat32_t svmulx_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_x)))
+svfloat16_t svmulx_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_z)))
+svfloat64_t svmulx_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_z)))
+svfloat32_t svmulx_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_z)))
+svfloat16_t svmulx_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnand_b_z)))
+svbool_t svnand_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_m)))
+svfloat64_t svneg_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_m)))
+svfloat32_t svneg_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_m)))
+svfloat16_t svneg_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_x)))
+svfloat64_t svneg_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_x)))
+svfloat32_t svneg_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_x)))
+svfloat16_t svneg_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_z)))
+svfloat64_t svneg_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_z)))
+svfloat32_t svneg_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_z)))
+svfloat16_t svneg_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_m)))
+svint8_t svneg_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_m)))
+svint32_t svneg_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_m)))
+svint64_t svneg_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_m)))
+svint16_t svneg_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_x)))
+svint8_t svneg_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_x)))
+svint32_t svneg_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_x)))
+svint64_t svneg_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_x)))
+svint16_t svneg_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_z)))
+svint8_t svneg_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_z)))
+svint32_t svneg_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_z)))
+svint64_t svneg_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_z)))
+svint16_t svneg_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_m)))
+svfloat64_t svnmad_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_m)))
+svfloat32_t svnmad_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_m)))
+svfloat16_t svnmad_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_x)))
+svfloat64_t svnmad_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_x)))
+svfloat32_t svnmad_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_x)))
+svfloat16_t svnmad_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_z)))
+svfloat64_t svnmad_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_z)))
+svfloat32_t svnmad_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_z)))
+svfloat16_t svnmad_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_m)))
+svfloat64_t svnmad_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_m)))
+svfloat32_t svnmad_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_m)))
+svfloat16_t svnmad_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_x)))
+svfloat64_t svnmad_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_x)))
+svfloat32_t svnmad_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_x)))
+svfloat16_t svnmad_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_z)))
+svfloat64_t svnmad_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_z)))
+svfloat32_t svnmad_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_z)))
+svfloat16_t svnmad_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_m)))
+svfloat64_t svnmla_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_m)))
+svfloat32_t svnmla_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_m)))
+svfloat16_t svnmla_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_x)))
+svfloat64_t svnmla_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_x)))
+svfloat32_t svnmla_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_x)))
+svfloat16_t svnmla_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_z)))
+svfloat64_t svnmla_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_z)))
+svfloat32_t svnmla_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_z)))
+svfloat16_t svnmla_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_m)))
+svfloat64_t svnmla_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_m)))
+svfloat32_t svnmla_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_m)))
+svfloat16_t svnmla_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_x)))
+svfloat64_t svnmla_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_x)))
+svfloat32_t svnmla_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_x)))
+svfloat16_t svnmla_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_z)))
+svfloat64_t svnmla_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_z)))
+svfloat32_t svnmla_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_z)))
+svfloat16_t svnmla_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_m)))
+svfloat64_t svnmls_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_m)))
+svfloat32_t svnmls_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_m)))
+svfloat16_t svnmls_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_x)))
+svfloat64_t svnmls_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_x)))
+svfloat32_t svnmls_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_x)))
+svfloat16_t svnmls_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_z)))
+svfloat64_t svnmls_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_z)))
+svfloat32_t svnmls_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_z)))
+svfloat16_t svnmls_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_m)))
+svfloat64_t svnmls_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_m)))
+svfloat32_t svnmls_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_m)))
+svfloat16_t svnmls_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_x)))
+svfloat64_t svnmls_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_x)))
+svfloat32_t svnmls_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_x)))
+svfloat16_t svnmls_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_z)))
+svfloat64_t svnmls_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_z)))
+svfloat32_t svnmls_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_z)))
+svfloat16_t svnmls_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_m)))
+svfloat64_t svnmsb_n_f64_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_m)))
+svfloat32_t svnmsb_n_f32_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_m)))
+svfloat16_t svnmsb_n_f16_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_x)))
+svfloat64_t svnmsb_n_f64_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_x)))
+svfloat32_t svnmsb_n_f32_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_x)))
+svfloat16_t svnmsb_n_f16_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_z)))
+svfloat64_t svnmsb_n_f64_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_z)))
+svfloat32_t svnmsb_n_f32_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_z)))
+svfloat16_t svnmsb_n_f16_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_m)))
+svfloat64_t svnmsb_f64_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_m)))
+svfloat32_t svnmsb_f32_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_m)))
+svfloat16_t svnmsb_f16_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_x)))
+svfloat64_t svnmsb_f64_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_x)))
+svfloat32_t svnmsb_f32_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_x)))
+svfloat16_t svnmsb_f16_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_z)))
+svfloat64_t svnmsb_f64_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_z)))
+svfloat32_t svnmsb_f32_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_z)))
+svfloat16_t svnmsb_f16_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnor_b_z)))
+svbool_t svnor_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_b_z)))
+svbool_t svnot_b_z(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_m)))
+svuint8_t svnot_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_m)))
+svuint32_t svnot_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_m)))
+svuint64_t svnot_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_m)))
+svuint16_t svnot_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_m)))
+svint8_t svnot_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_m)))
+svint32_t svnot_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_m)))
+svint64_t svnot_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_m)))
+svint16_t svnot_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_x)))
+svuint8_t svnot_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_x)))
+svuint32_t svnot_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_x)))
+svuint64_t svnot_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_x)))
+svuint16_t svnot_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_x)))
+svint8_t svnot_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_x)))
+svint32_t svnot_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_x)))
+svint64_t svnot_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_x)))
+svint16_t svnot_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_z)))
+svuint8_t svnot_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_z)))
+svuint32_t svnot_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_z)))
+svuint64_t svnot_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_z)))
+svuint16_t svnot_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_z)))
+svint8_t svnot_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_z)))
+svint32_t svnot_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_z)))
+svint64_t svnot_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_z)))
+svint16_t svnot_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorn_b_z)))
+svbool_t svorn_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_b_z)))
+svbool_t svorr_b_z(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_m)))
+svuint8_t svorr_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_m)))
+svuint32_t svorr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_m)))
+svuint64_t svorr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_m)))
+svuint16_t svorr_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_m)))
+svint8_t svorr_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_m)))
+svint32_t svorr_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_m)))
+svint64_t svorr_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_m)))
+svint16_t svorr_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_x)))
+svuint8_t svorr_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_x)))
+svuint32_t svorr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_x)))
+svuint64_t svorr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_x)))
+svuint16_t svorr_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_x)))
+svint8_t svorr_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_x)))
+svint32_t svorr_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_x)))
+svint64_t svorr_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_x)))
+svint16_t svorr_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_z)))
+svuint8_t svorr_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_z)))
+svuint32_t svorr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_z)))
+svuint64_t svorr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_z)))
+svuint16_t svorr_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_z)))
+svint8_t svorr_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_z)))
+svint32_t svorr_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_z)))
+svint64_t svorr_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_z)))
+svint16_t svorr_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_m)))
+svuint8_t svorr_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_m)))
+svuint32_t svorr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_m)))
+svuint64_t svorr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_m)))
+svuint16_t svorr_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_m)))
+svint8_t svorr_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_m)))
+svint32_t svorr_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_m)))
+svint64_t svorr_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_m)))
+svint16_t svorr_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_x)))
+svuint8_t svorr_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_x)))
+svuint32_t svorr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_x)))
+svuint64_t svorr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_x)))
+svuint16_t svorr_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_x)))
+svint8_t svorr_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_x)))
+svint32_t svorr_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_x)))
+svint64_t svorr_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_x)))
+svint16_t svorr_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_z)))
+svuint8_t svorr_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_z)))
+svuint32_t svorr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_z)))
+svuint64_t svorr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_z)))
+svuint16_t svorr_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_z)))
+svint8_t svorr_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_z)))
+svint32_t svorr_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_z)))
+svint64_t svorr_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_z)))
+svint16_t svorr_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u8)))
+uint8_t svorv_u8(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u32)))
+uint32_t svorv_u32(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u64)))
+uint64_t svorv_u64(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u16)))
+uint16_t svorv_u16(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s8)))
+int8_t svorv_s8(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s32)))
+int32_t svorv_s32(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s64)))
+int64_t svorv_s64(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s16)))
+int16_t svorv_s16(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfalse_b)))
+svbool_t svpfalse_b(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfirst_b)))
+svbool_t svpfirst_b(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b8)))
+svbool_t svpnext_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b32)))
+svbool_t svpnext_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b64)))
+svbool_t svpnext_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpnext_b16)))
+svbool_t svpnext_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb)))
+void svprfb(svbool_t, void const *, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfb_vnum)))
+void svprfb_vnum(svbool_t, void const *, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd)))
+void svprfd(svbool_t, void const *, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfd_vnum)))
+void svprfd_vnum(svbool_t, void const *, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh)))
+void svprfh(svbool_t, void const *, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfh_vnum)))
+void svprfh_vnum(svbool_t, void const *, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw)))
+void svprfw(svbool_t, void const *, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svprfw_vnum)))
+void svprfw_vnum(svbool_t, void const *, int64_t, enum svprfop);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptest_any)))
+bool svptest_any(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptest_first)))
+bool svptest_first(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptest_last)))
+bool svptest_last(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b8)))
+svbool_t svptrue_pat_b8(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b32)))
+svbool_t svptrue_pat_b32(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b64)))
+svbool_t svptrue_pat_b64(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_pat_b16)))
+svbool_t svptrue_pat_b16(enum svpattern);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b8)))
+svbool_t svptrue_b8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b32)))
+svbool_t svptrue_b32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b64)))
+svbool_t svptrue_b64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svptrue_b16)))
+svbool_t svptrue_b16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8)))
+svint8_t svqadd_n_s8(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32)))
+svint32_t svqadd_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64)))
+svint64_t svqadd_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16)))
+svint16_t svqadd_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8)))
+svuint8_t svqadd_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32)))
+svuint32_t svqadd_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64)))
+svuint64_t svqadd_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16)))
+svuint16_t svqadd_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8)))
+svint8_t svqadd_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32)))
+svint32_t svqadd_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64)))
+svint64_t svqadd_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16)))
+svint16_t svqadd_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8)))
+svuint8_t svqadd_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32)))
+svuint32_t svqadd_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64)))
+svuint64_t svqadd_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16)))
+svuint16_t svqadd_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s32)))
+int32_t svqdecb_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s64)))
+int64_t svqdecb_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u32)))
+uint32_t svqdecb_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u64)))
+uint64_t svqdecb_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s32)))
+int32_t svqdecb_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s64)))
+int64_t svqdecb_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u32)))
+uint32_t svqdecb_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u64)))
+uint64_t svqdecb_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s32)))
+int32_t svqdecd_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s64)))
+int64_t svqdecd_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u32)))
+uint32_t svqdecd_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u64)))
+uint64_t svqdecd_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_s64)))
+svint64_t svqdecd_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_u64)))
+svuint64_t svqdecd_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s32)))
+int32_t svqdecd_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s64)))
+int64_t svqdecd_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u32)))
+uint32_t svqdecd_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u64)))
+uint64_t svqdecd_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_s64)))
+svint64_t svqdecd_pat_s64(svint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_u64)))
+svuint64_t svqdecd_pat_u64(svuint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s32)))
+int32_t svqdech_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s64)))
+int64_t svqdech_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u32)))
+uint32_t svqdech_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u64)))
+uint64_t svqdech_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_s16)))
+svint16_t svqdech_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_u16)))
+svuint16_t svqdech_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s32)))
+int32_t svqdech_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s64)))
+int64_t svqdech_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u32)))
+uint32_t svqdech_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u64)))
+uint64_t svqdech_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_s16)))
+svint16_t svqdech_pat_s16(svint16_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_u16)))
+svuint16_t svqdech_pat_u16(svuint16_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b8)))
+int32_t svqdecp_n_s32_b8(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b32)))
+int32_t svqdecp_n_s32_b32(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b64)))
+int32_t svqdecp_n_s32_b64(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b16)))
+int32_t svqdecp_n_s32_b16(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b8)))
+int64_t svqdecp_n_s64_b8(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b32)))
+int64_t svqdecp_n_s64_b32(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b64)))
+int64_t svqdecp_n_s64_b64(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b16)))
+int64_t svqdecp_n_s64_b16(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b8)))
+uint32_t svqdecp_n_u32_b8(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b32)))
+uint32_t svqdecp_n_u32_b32(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b64)))
+uint32_t svqdecp_n_u32_b64(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b16)))
+uint32_t svqdecp_n_u32_b16(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b8)))
+uint64_t svqdecp_n_u64_b8(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b32)))
+uint64_t svqdecp_n_u64_b32(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b64)))
+uint64_t svqdecp_n_u64_b64(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b16)))
+uint64_t svqdecp_n_u64_b16(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s32)))
+svint32_t svqdecp_s32(svint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s64)))
+svint64_t svqdecp_s64(svint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s16)))
+svint16_t svqdecp_s16(svint16_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u32)))
+svuint32_t svqdecp_u32(svuint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u64)))
+svuint64_t svqdecp_u64(svuint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u16)))
+svuint16_t svqdecp_u16(svuint16_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s32)))
+int32_t svqdecw_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s64)))
+int64_t svqdecw_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u32)))
+uint32_t svqdecw_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u64)))
+uint64_t svqdecw_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_s32)))
+svint32_t svqdecw_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_u32)))
+svuint32_t svqdecw_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s32)))
+int32_t svqdecw_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s64)))
+int64_t svqdecw_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u32)))
+uint32_t svqdecw_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u64)))
+uint64_t svqdecw_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_s32)))
+svint32_t svqdecw_pat_s32(svint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_u32)))
+svuint32_t svqdecw_pat_u32(svuint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s32)))
+int32_t svqincb_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s64)))
+int64_t svqincb_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u32)))
+uint32_t svqincb_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u64)))
+uint64_t svqincb_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s32)))
+int32_t svqincb_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s64)))
+int64_t svqincb_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u32)))
+uint32_t svqincb_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u64)))
+uint64_t svqincb_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s32)))
+int32_t svqincd_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s64)))
+int64_t svqincd_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u32)))
+uint32_t svqincd_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u64)))
+uint64_t svqincd_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_s64)))
+svint64_t svqincd_s64(svint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_u64)))
+svuint64_t svqincd_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s32)))
+int32_t svqincd_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s64)))
+int64_t svqincd_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u32)))
+uint32_t svqincd_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u64)))
+uint64_t svqincd_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_s64)))
+svint64_t svqincd_pat_s64(svint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_u64)))
+svuint64_t svqincd_pat_u64(svuint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s32)))
+int32_t svqinch_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s64)))
+int64_t svqinch_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u32)))
+uint32_t svqinch_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u64)))
+uint64_t svqinch_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_s16)))
+svint16_t svqinch_s16(svint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_u16)))
+svuint16_t svqinch_u16(svuint16_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s32)))
+int32_t svqinch_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s64)))
+int64_t svqinch_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u32)))
+uint32_t svqinch_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u64)))
+uint64_t svqinch_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_s16)))
+svint16_t svqinch_pat_s16(svint16_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_u16)))
+svuint16_t svqinch_pat_u16(svuint16_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b8)))
+int32_t svqincp_n_s32_b8(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b32)))
+int32_t svqincp_n_s32_b32(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b64)))
+int32_t svqincp_n_s32_b64(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b16)))
+int32_t svqincp_n_s32_b16(int32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b8)))
+int64_t svqincp_n_s64_b8(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b32)))
+int64_t svqincp_n_s64_b32(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b64)))
+int64_t svqincp_n_s64_b64(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b16)))
+int64_t svqincp_n_s64_b16(int64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b8)))
+uint32_t svqincp_n_u32_b8(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b32)))
+uint32_t svqincp_n_u32_b32(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b64)))
+uint32_t svqincp_n_u32_b64(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b16)))
+uint32_t svqincp_n_u32_b16(uint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b8)))
+uint64_t svqincp_n_u64_b8(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b32)))
+uint64_t svqincp_n_u64_b32(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b64)))
+uint64_t svqincp_n_u64_b64(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b16)))
+uint64_t svqincp_n_u64_b16(uint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s32)))
+svint32_t svqincp_s32(svint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s64)))
+svint64_t svqincp_s64(svint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s16)))
+svint16_t svqincp_s16(svint16_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u32)))
+svuint32_t svqincp_u32(svuint32_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u64)))
+svuint64_t svqincp_u64(svuint64_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u16)))
+svuint16_t svqincp_u16(svuint16_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s32)))
+int32_t svqincw_n_s32(int32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s64)))
+int64_t svqincw_n_s64(int64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u32)))
+uint32_t svqincw_n_u32(uint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u64)))
+uint64_t svqincw_n_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_s32)))
+svint32_t svqincw_s32(svint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_u32)))
+svuint32_t svqincw_u32(svuint32_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s32)))
+int32_t svqincw_pat_n_s32(int32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s64)))
+int64_t svqincw_pat_n_s64(int64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u32)))
+uint32_t svqincw_pat_n_u32(uint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u64)))
+uint64_t svqincw_pat_n_u64(uint64_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_s32)))
+svint32_t svqincw_pat_s32(svint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_u32)))
+svuint32_t svqincw_pat_u32(svuint32_t, enum svpattern, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8)))
+svint8_t svqsub_n_s8(svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32)))
+svint32_t svqsub_n_s32(svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64)))
+svint64_t svqsub_n_s64(svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16)))
+svint16_t svqsub_n_s16(svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8)))
+svuint8_t svqsub_n_u8(svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32)))
+svuint32_t svqsub_n_u32(svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64)))
+svuint64_t svqsub_n_u64(svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16)))
+svuint16_t svqsub_n_u16(svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8)))
+svint8_t svqsub_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32)))
+svint32_t svqsub_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64)))
+svint64_t svqsub_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16)))
+svint16_t svqsub_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8)))
+svuint8_t svqsub_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32)))
+svuint32_t svqsub_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64)))
+svuint64_t svqsub_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16)))
+svuint16_t svqsub_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_m)))
+svuint8_t svrbit_u8_m(svuint8_t, svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_m)))
+svuint32_t svrbit_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_m)))
+svuint64_t svrbit_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_m)))
+svuint16_t svrbit_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_m)))
+svint8_t svrbit_s8_m(svint8_t, svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_m)))
+svint32_t svrbit_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_m)))
+svint64_t svrbit_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_m)))
+svint16_t svrbit_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_x)))
+svuint8_t svrbit_u8_x(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_x)))
+svuint32_t svrbit_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_x)))
+svuint64_t svrbit_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_x)))
+svuint16_t svrbit_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_x)))
+svint8_t svrbit_s8_x(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_x)))
+svint32_t svrbit_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_x)))
+svint64_t svrbit_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_x)))
+svint16_t svrbit_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_z)))
+svuint8_t svrbit_u8_z(svbool_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_z)))
+svuint32_t svrbit_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_z)))
+svuint64_t svrbit_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_z)))
+svuint16_t svrbit_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_z)))
+svint8_t svrbit_s8_z(svbool_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_z)))
+svint32_t svrbit_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_z)))
+svint64_t svrbit_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_z)))
+svint16_t svrbit_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f64)))
+svfloat64_t svrecpe_f64(svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f32)))
+svfloat32_t svrecpe_f32(svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f16)))
+svfloat16_t svrecpe_f16(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f64)))
+svfloat64_t svrecps_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f32)))
+svfloat32_t svrecps_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f16)))
+svfloat16_t svrecps_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_m)))
+svfloat64_t svrecpx_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_m)))
+svfloat32_t svrecpx_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_m)))
+svfloat16_t svrecpx_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_x)))
+svfloat64_t svrecpx_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_x)))
+svfloat32_t svrecpx_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_x)))
+svfloat16_t svrecpx_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_z)))
+svfloat64_t svrecpx_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_z)))
+svfloat32_t svrecpx_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_z)))
+svfloat16_t svrecpx_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u8)))
+svuint8_t svrev_u8(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u32)))
+svuint32_t svrev_u32(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u64)))
+svuint64_t svrev_u64(svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u16)))
+svuint16_t svrev_u16(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s8)))
+svint8_t svrev_s8(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f64)))
+svfloat64_t svrev_f64(svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f32)))
+svfloat32_t svrev_f32(svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f16)))
+svfloat16_t svrev_f16(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s32)))
+svint32_t svrev_s32(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s64)))
+svint64_t svrev_s64(svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s16)))
+svint16_t svrev_s16(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b16)))
+svbool_t svrev_b16(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b32)))
+svbool_t svrev_b32(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b64)))
+svbool_t svrev_b64(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_b8)))
+svbool_t svrev_b8(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_m)))
+svuint32_t svrevb_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_m)))
+svuint64_t svrevb_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_m)))
+svuint16_t svrevb_u16_m(svuint16_t, svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_m)))
+svint32_t svrevb_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_m)))
+svint64_t svrevb_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_m)))
+svint16_t svrevb_s16_m(svint16_t, svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_x)))
+svuint32_t svrevb_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_x)))
+svuint64_t svrevb_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_x)))
+svuint16_t svrevb_u16_x(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_x)))
+svint32_t svrevb_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_x)))
+svint64_t svrevb_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_x)))
+svint16_t svrevb_s16_x(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_z)))
+svuint32_t svrevb_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_z)))
+svuint64_t svrevb_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_z)))
+svuint16_t svrevb_u16_z(svbool_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_z)))
+svint32_t svrevb_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_z)))
+svint64_t svrevb_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_z)))
+svint16_t svrevb_s16_z(svbool_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_m)))
+svuint32_t svrevh_u32_m(svuint32_t, svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_m)))
+svuint64_t svrevh_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_m)))
+svint32_t svrevh_s32_m(svint32_t, svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_m)))
+svint64_t svrevh_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_x)))
+svuint32_t svrevh_u32_x(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_x)))
+svuint64_t svrevh_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_x)))
+svint32_t svrevh_s32_x(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_x)))
+svint64_t svrevh_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_z)))
+svuint32_t svrevh_u32_z(svbool_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_z)))
+svuint64_t svrevh_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_z)))
+svint32_t svrevh_s32_z(svbool_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_z)))
+svint64_t svrevh_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_m)))
+svuint64_t svrevw_u64_m(svuint64_t, svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_m)))
+svint64_t svrevw_s64_m(svint64_t, svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_x)))
+svuint64_t svrevw_u64_x(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_x)))
+svint64_t svrevw_s64_x(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_z)))
+svuint64_t svrevw_u64_z(svbool_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_z)))
+svint64_t svrevw_s64_z(svbool_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_m)))
+svfloat64_t svrinta_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_m)))
+svfloat32_t svrinta_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_m)))
+svfloat16_t svrinta_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_x)))
+svfloat64_t svrinta_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x)))
+svfloat32_t svrinta_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_x)))
+svfloat16_t svrinta_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_z)))
+svfloat64_t svrinta_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_z)))
+svfloat32_t svrinta_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_z)))
+svfloat16_t svrinta_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_m)))
+svfloat64_t svrinti_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_m)))
+svfloat32_t svrinti_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_m)))
+svfloat16_t svrinti_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_x)))
+svfloat64_t svrinti_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_x)))
+svfloat32_t svrinti_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_x)))
+svfloat16_t svrinti_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_z)))
+svfloat64_t svrinti_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_z)))
+svfloat32_t svrinti_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_z)))
+svfloat16_t svrinti_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_m)))
+svfloat64_t svrintm_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_m)))
+svfloat32_t svrintm_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_m)))
+svfloat16_t svrintm_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_x)))
+svfloat64_t svrintm_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x)))
+svfloat32_t svrintm_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_x)))
+svfloat16_t svrintm_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_z)))
+svfloat64_t svrintm_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_z)))
+svfloat32_t svrintm_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_z)))
+svfloat16_t svrintm_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_m)))
+svfloat64_t svrintn_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_m)))
+svfloat32_t svrintn_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_m)))
+svfloat16_t svrintn_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_x)))
+svfloat64_t svrintn_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x)))
+svfloat32_t svrintn_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_x)))
+svfloat16_t svrintn_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_z)))
+svfloat64_t svrintn_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_z)))
+svfloat32_t svrintn_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_z)))
+svfloat16_t svrintn_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_m)))
+svfloat64_t svrintp_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_m)))
+svfloat32_t svrintp_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_m)))
+svfloat16_t svrintp_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_x)))
+svfloat64_t svrintp_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x)))
+svfloat32_t svrintp_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_x)))
+svfloat16_t svrintp_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_z)))
+svfloat64_t svrintp_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_z)))
+svfloat32_t svrintp_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_z)))
+svfloat16_t svrintp_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_m)))
+svfloat64_t svrintx_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_m)))
+svfloat32_t svrintx_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_m)))
+svfloat16_t svrintx_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_x)))
+svfloat64_t svrintx_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_x)))
+svfloat32_t svrintx_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_x)))
+svfloat16_t svrintx_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_z)))
+svfloat64_t svrintx_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_z)))
+svfloat32_t svrintx_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_z)))
+svfloat16_t svrintx_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_m)))
+svfloat64_t svrintz_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_m)))
+svfloat32_t svrintz_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_m)))
+svfloat16_t svrintz_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_x)))
+svfloat64_t svrintz_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_x)))
+svfloat32_t svrintz_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_x)))
+svfloat16_t svrintz_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_z)))
+svfloat64_t svrintz_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_z)))
+svfloat32_t svrintz_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_z)))
+svfloat16_t svrintz_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f64)))
+svfloat64_t svrsqrte_f64(svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f32)))
+svfloat32_t svrsqrte_f32(svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f16)))
+svfloat16_t svrsqrte_f16(svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f64)))
+svfloat64_t svrsqrts_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f32)))
+svfloat32_t svrsqrts_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f16)))
+svfloat16_t svrsqrts_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_m)))
+svfloat64_t svscale_n_f64_m(svbool_t, svfloat64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_m)))
+svfloat32_t svscale_n_f32_m(svbool_t, svfloat32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_m)))
+svfloat16_t svscale_n_f16_m(svbool_t, svfloat16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_x)))
+svfloat64_t svscale_n_f64_x(svbool_t, svfloat64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_x)))
+svfloat32_t svscale_n_f32_x(svbool_t, svfloat32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_x)))
+svfloat16_t svscale_n_f16_x(svbool_t, svfloat16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_z)))
+svfloat64_t svscale_n_f64_z(svbool_t, svfloat64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_z)))
+svfloat32_t svscale_n_f32_z(svbool_t, svfloat32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_z)))
+svfloat16_t svscale_n_f16_z(svbool_t, svfloat16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_m)))
+svfloat64_t svscale_f64_m(svbool_t, svfloat64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_m)))
+svfloat32_t svscale_f32_m(svbool_t, svfloat32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_m)))
+svfloat16_t svscale_f16_m(svbool_t, svfloat16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_x)))
+svfloat64_t svscale_f64_x(svbool_t, svfloat64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_x)))
+svfloat32_t svscale_f32_x(svbool_t, svfloat32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_x)))
+svfloat16_t svscale_f16_x(svbool_t, svfloat16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_z)))
+svfloat64_t svscale_f64_z(svbool_t, svfloat64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_z)))
+svfloat32_t svscale_f32_z(svbool_t, svfloat32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_z)))
+svfloat16_t svscale_f16_z(svbool_t, svfloat16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_b)))
+svbool_t svsel_b(svbool_t, svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8)))
+svuint8_t svsel_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32)))
+svuint32_t svsel_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64)))
+svuint64_t svsel_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16)))
+svuint16_t svsel_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8)))
+svint8_t svsel_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64)))
+svfloat64_t svsel_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32)))
+svfloat32_t svsel_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16)))
+svfloat16_t svsel_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32)))
+svint32_t svsel_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64)))
+svint64_t svsel_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16)))
+svint16_t svsel_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u8)))
+svuint8x2_t svset2_u8(svuint8x2_t, uint64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u32)))
+svuint32x2_t svset2_u32(svuint32x2_t, uint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u64)))
+svuint64x2_t svset2_u64(svuint64x2_t, uint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u16)))
+svuint16x2_t svset2_u16(svuint16x2_t, uint64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s8)))
+svint8x2_t svset2_s8(svint8x2_t, uint64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f64)))
+svfloat64x2_t svset2_f64(svfloat64x2_t, uint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f32)))
+svfloat32x2_t svset2_f32(svfloat32x2_t, uint64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f16)))
+svfloat16x2_t svset2_f16(svfloat16x2_t, uint64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s32)))
+svint32x2_t svset2_s32(svint32x2_t, uint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s64)))
+svint64x2_t svset2_s64(svint64x2_t, uint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s16)))
+svint16x2_t svset2_s16(svint16x2_t, uint64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u8)))
+svuint8x3_t svset3_u8(svuint8x3_t, uint64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u32)))
+svuint32x3_t svset3_u32(svuint32x3_t, uint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u64)))
+svuint64x3_t svset3_u64(svuint64x3_t, uint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u16)))
+svuint16x3_t svset3_u16(svuint16x3_t, uint64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s8)))
+svint8x3_t svset3_s8(svint8x3_t, uint64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f64)))
+svfloat64x3_t svset3_f64(svfloat64x3_t, uint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f32)))
+svfloat32x3_t svset3_f32(svfloat32x3_t, uint64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f16)))
+svfloat16x3_t svset3_f16(svfloat16x3_t, uint64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s32)))
+svint32x3_t svset3_s32(svint32x3_t, uint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s64)))
+svint64x3_t svset3_s64(svint64x3_t, uint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s16)))
+svint16x3_t svset3_s16(svint16x3_t, uint64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u8)))
+svuint8x4_t svset4_u8(svuint8x4_t, uint64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u32)))
+svuint32x4_t svset4_u32(svuint32x4_t, uint64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u64)))
+svuint64x4_t svset4_u64(svuint64x4_t, uint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u16)))
+svuint16x4_t svset4_u16(svuint16x4_t, uint64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s8)))
+svint8x4_t svset4_s8(svint8x4_t, uint64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f64)))
+svfloat64x4_t svset4_f64(svfloat64x4_t, uint64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f32)))
+svfloat32x4_t svset4_f32(svfloat32x4_t, uint64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f16)))
+svfloat16x4_t svset4_f16(svfloat16x4_t, uint64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s32)))
+svint32x4_t svset4_s32(svint32x4_t, uint64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s64)))
+svint64x4_t svset4_s64(svint64x4_t, uint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s16)))
+svint16x4_t svset4_s16(svint16x4_t, uint64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u8)))
+svuint8_t svsplice_u8(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u32)))
+svuint32_t svsplice_u32(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u64)))
+svuint64_t svsplice_u64(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u16)))
+svuint16_t svsplice_u16(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s8)))
+svint8_t svsplice_s8(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f64)))
+svfloat64_t svsplice_f64(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f32)))
+svfloat32_t svsplice_f32(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f16)))
+svfloat16_t svsplice_f16(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s32)))
+svint32_t svsplice_s32(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s64)))
+svint64_t svsplice_s64(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s16)))
+svint16_t svsplice_s16(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_m)))
+svfloat64_t svsqrt_f64_m(svfloat64_t, svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_m)))
+svfloat32_t svsqrt_f32_m(svfloat32_t, svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_m)))
+svfloat16_t svsqrt_f16_m(svfloat16_t, svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_x)))
+svfloat64_t svsqrt_f64_x(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_x)))
+svfloat32_t svsqrt_f32_x(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_x)))
+svfloat16_t svsqrt_f16_x(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_z)))
+svfloat64_t svsqrt_f64_z(svbool_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_z)))
+svfloat32_t svsqrt_f32_z(svbool_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_z)))
+svfloat16_t svsqrt_f16_z(svbool_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u8)))
+void svst1_u8(svbool_t, uint8_t *, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u32)))
+void svst1_u32(svbool_t, uint32_t *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u64)))
+void svst1_u64(svbool_t, uint64_t *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u16)))
+void svst1_u16(svbool_t, uint16_t *, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s8)))
+void svst1_s8(svbool_t, int8_t *, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f64)))
+void svst1_f64(svbool_t, float64_t *, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f32)))
+void svst1_f32(svbool_t, float32_t *, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16)))
+void svst1_f16(svbool_t, float16_t *, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s32)))
+void svst1_s32(svbool_t, int32_t *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s64)))
+void svst1_s64(svbool_t, int64_t *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s16)))
+void svst1_s16(svbool_t, int16_t *, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u8)))
+void svst1_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u32)))
+void svst1_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u64)))
+void svst1_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u16)))
+void svst1_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s8)))
+void svst1_vnum_s8(svbool_t, int8_t *, int64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f64)))
+void svst1_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f32)))
+void svst1_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f16)))
+void svst1_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s32)))
+void svst1_vnum_s32(svbool_t, int32_t *, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s64)))
+void svst1_vnum_s64(svbool_t, int64_t *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s16)))
+void svst1_vnum_s16(svbool_t, int16_t *, int64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s32)))
+void svst1b_s32(svbool_t, int8_t *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s64)))
+void svst1b_s64(svbool_t, int8_t *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s16)))
+void svst1b_s16(svbool_t, int8_t *, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u32)))
+void svst1b_u32(svbool_t, uint8_t *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u64)))
+void svst1b_u64(svbool_t, uint8_t *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u16)))
+void svst1b_u16(svbool_t, uint8_t *, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s32)))
+void svst1b_vnum_s32(svbool_t, int8_t *, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s64)))
+void svst1b_vnum_s64(svbool_t, int8_t *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s16)))
+void svst1b_vnum_s16(svbool_t, int8_t *, int64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u32)))
+void svst1b_vnum_u32(svbool_t, uint8_t *, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u64)))
+void svst1b_vnum_u64(svbool_t, uint8_t *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u16)))
+void svst1b_vnum_u16(svbool_t, uint8_t *, int64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s32)))
+void svst1h_s32(svbool_t, int16_t *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s64)))
+void svst1h_s64(svbool_t, int16_t *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u32)))
+void svst1h_u32(svbool_t, uint16_t *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u64)))
+void svst1h_u64(svbool_t, uint16_t *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s32)))
+void svst1h_vnum_s32(svbool_t, int16_t *, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s64)))
+void svst1h_vnum_s64(svbool_t, int16_t *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u32)))
+void svst1h_vnum_u32(svbool_t, uint16_t *, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u64)))
+void svst1h_vnum_u64(svbool_t, uint16_t *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_s64)))
+void svst1w_s64(svbool_t, int32_t *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_u64)))
+void svst1w_u64(svbool_t, uint32_t *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_s64)))
+void svst1w_vnum_s64(svbool_t, int32_t *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_u64)))
+void svst1w_vnum_u64(svbool_t, uint32_t *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u8)))
+void svst2_u8(svbool_t, uint8_t *, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u32)))
+void svst2_u32(svbool_t, uint32_t *, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u64)))
+void svst2_u64(svbool_t, uint64_t *, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u16)))
+void svst2_u16(svbool_t, uint16_t *, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s8)))
+void svst2_s8(svbool_t, int8_t *, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f64)))
+void svst2_f64(svbool_t, float64_t *, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f32)))
+void svst2_f32(svbool_t, float32_t *, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f16)))
+void svst2_f16(svbool_t, float16_t *, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s32)))
+void svst2_s32(svbool_t, int32_t *, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s64)))
+void svst2_s64(svbool_t, int64_t *, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s16)))
+void svst2_s16(svbool_t, int16_t *, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u8)))
+void svst2_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u32)))
+void svst2_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u64)))
+void svst2_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u16)))
+void svst2_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s8)))
+void svst2_vnum_s8(svbool_t, int8_t *, int64_t, svint8x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f64)))
+void svst2_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f32)))
+void svst2_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f16)))
+void svst2_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s32)))
+void svst2_vnum_s32(svbool_t, int32_t *, int64_t, svint32x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s64)))
+void svst2_vnum_s64(svbool_t, int64_t *, int64_t, svint64x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s16)))
+void svst2_vnum_s16(svbool_t, int16_t *, int64_t, svint16x2_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u8)))
+void svst3_u8(svbool_t, uint8_t *, svuint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u32)))
+void svst3_u32(svbool_t, uint32_t *, svuint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u64)))
+void svst3_u64(svbool_t, uint64_t *, svuint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u16)))
+void svst3_u16(svbool_t, uint16_t *, svuint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s8)))
+void svst3_s8(svbool_t, int8_t *, svint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f64)))
+void svst3_f64(svbool_t, float64_t *, svfloat64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f32)))
+void svst3_f32(svbool_t, float32_t *, svfloat32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f16)))
+void svst3_f16(svbool_t, float16_t *, svfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s32)))
+void svst3_s32(svbool_t, int32_t *, svint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s64)))
+void svst3_s64(svbool_t, int64_t *, svint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s16)))
+void svst3_s16(svbool_t, int16_t *, svint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u8)))
+void svst3_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u32)))
+void svst3_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u64)))
+void svst3_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u16)))
+void svst3_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s8)))
+void svst3_vnum_s8(svbool_t, int8_t *, int64_t, svint8x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f64)))
+void svst3_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f32)))
+void svst3_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f16)))
+void svst3_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s32)))
+void svst3_vnum_s32(svbool_t, int32_t *, int64_t, svint32x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s64)))
+void svst3_vnum_s64(svbool_t, int64_t *, int64_t, svint64x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s16)))
+void svst3_vnum_s16(svbool_t, int16_t *, int64_t, svint16x3_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u8)))
+void svst4_u8(svbool_t, uint8_t *, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u32)))
+void svst4_u32(svbool_t, uint32_t *, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u64)))
+void svst4_u64(svbool_t, uint64_t *, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u16)))
+void svst4_u16(svbool_t, uint16_t *, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s8)))
+void svst4_s8(svbool_t, int8_t *, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f64)))
+void svst4_f64(svbool_t, float64_t *, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f32)))
+void svst4_f32(svbool_t, float32_t *, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f16)))
+void svst4_f16(svbool_t, float16_t *, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s32)))
+void svst4_s32(svbool_t, int32_t *, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s64)))
+void svst4_s64(svbool_t, int64_t *, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s16)))
+void svst4_s16(svbool_t, int16_t *, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u8)))
+void svst4_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u32)))
+void svst4_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u64)))
+void svst4_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u16)))
+void svst4_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s8)))
+void svst4_vnum_s8(svbool_t, int8_t *, int64_t, svint8x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f64)))
+void svst4_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f32)))
+void svst4_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f16)))
+void svst4_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s32)))
+void svst4_vnum_s32(svbool_t, int32_t *, int64_t, svint32x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s64)))
+void svst4_vnum_s64(svbool_t, int64_t *, int64_t, svint64x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s16)))
+void svst4_vnum_s16(svbool_t, int16_t *, int64_t, svint16x4_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u8)))
+void svstnt1_u8(svbool_t, uint8_t *, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u32)))
+void svstnt1_u32(svbool_t, uint32_t *, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u64)))
+void svstnt1_u64(svbool_t, uint64_t *, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u16)))
+void svstnt1_u16(svbool_t, uint16_t *, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s8)))
+void svstnt1_s8(svbool_t, int8_t *, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f64)))
+void svstnt1_f64(svbool_t, float64_t *, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f32)))
+void svstnt1_f32(svbool_t, float32_t *, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f16)))
+void svstnt1_f16(svbool_t, float16_t *, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s32)))
+void svstnt1_s32(svbool_t, int32_t *, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s64)))
+void svstnt1_s64(svbool_t, int64_t *, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s16)))
+void svstnt1_s16(svbool_t, int16_t *, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u8)))
+void svstnt1_vnum_u8(svbool_t, uint8_t *, int64_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u32)))
+void svstnt1_vnum_u32(svbool_t, uint32_t *, int64_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u64)))
+void svstnt1_vnum_u64(svbool_t, uint64_t *, int64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u16)))
+void svstnt1_vnum_u16(svbool_t, uint16_t *, int64_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s8)))
+void svstnt1_vnum_s8(svbool_t, int8_t *, int64_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f64)))
+void svstnt1_vnum_f64(svbool_t, float64_t *, int64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f32)))
+void svstnt1_vnum_f32(svbool_t, float32_t *, int64_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f16)))
+void svstnt1_vnum_f16(svbool_t, float16_t *, int64_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s32)))
+void svstnt1_vnum_s32(svbool_t, int32_t *, int64_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s64)))
+void svstnt1_vnum_s64(svbool_t, int64_t *, int64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s16)))
+void svstnt1_vnum_s16(svbool_t, int16_t *, int64_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_m)))
+svfloat64_t svsub_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_m)))
+svfloat32_t svsub_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_m)))
+svfloat16_t svsub_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_x)))
+svfloat64_t svsub_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_x)))
+svfloat32_t svsub_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_x)))
+svfloat16_t svsub_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_z)))
+svfloat64_t svsub_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_z)))
+svfloat32_t svsub_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_z)))
+svfloat16_t svsub_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_m)))
+svuint8_t svsub_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_m)))
+svuint32_t svsub_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_m)))
+svuint64_t svsub_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_m)))
+svuint16_t svsub_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_m)))
+svint8_t svsub_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_m)))
+svint32_t svsub_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_m)))
+svint64_t svsub_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_m)))
+svint16_t svsub_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_x)))
+svuint8_t svsub_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_x)))
+svuint32_t svsub_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_x)))
+svuint64_t svsub_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_x)))
+svuint16_t svsub_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_x)))
+svint8_t svsub_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_x)))
+svint32_t svsub_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_x)))
+svint64_t svsub_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_x)))
+svint16_t svsub_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_z)))
+svuint8_t svsub_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_z)))
+svuint32_t svsub_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_z)))
+svuint64_t svsub_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_z)))
+svuint16_t svsub_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_z)))
+svint8_t svsub_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_z)))
+svint32_t svsub_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_z)))
+svint64_t svsub_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_z)))
+svint16_t svsub_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_m)))
+svfloat64_t svsub_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_m)))
+svfloat32_t svsub_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_m)))
+svfloat16_t svsub_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_x)))
+svfloat64_t svsub_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_x)))
+svfloat32_t svsub_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_x)))
+svfloat16_t svsub_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_z)))
+svfloat64_t svsub_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_z)))
+svfloat32_t svsub_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_z)))
+svfloat16_t svsub_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_m)))
+svuint8_t svsub_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_m)))
+svuint32_t svsub_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_m)))
+svuint64_t svsub_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_m)))
+svuint16_t svsub_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_m)))
+svint8_t svsub_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_m)))
+svint32_t svsub_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_m)))
+svint64_t svsub_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_m)))
+svint16_t svsub_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_x)))
+svuint8_t svsub_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_x)))
+svuint32_t svsub_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_x)))
+svuint64_t svsub_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_x)))
+svuint16_t svsub_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_x)))
+svint8_t svsub_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_x)))
+svint32_t svsub_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_x)))
+svint64_t svsub_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_x)))
+svint16_t svsub_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_z)))
+svuint8_t svsub_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_z)))
+svuint32_t svsub_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_z)))
+svuint64_t svsub_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_z)))
+svuint16_t svsub_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_z)))
+svint8_t svsub_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_z)))
+svint32_t svsub_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_z)))
+svint64_t svsub_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_z)))
+svint16_t svsub_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_m)))
+svfloat64_t svsubr_n_f64_m(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_m)))
+svfloat32_t svsubr_n_f32_m(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_m)))
+svfloat16_t svsubr_n_f16_m(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_x)))
+svfloat64_t svsubr_n_f64_x(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_x)))
+svfloat32_t svsubr_n_f32_x(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_x)))
+svfloat16_t svsubr_n_f16_x(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_z)))
+svfloat64_t svsubr_n_f64_z(svbool_t, svfloat64_t, float64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_z)))
+svfloat32_t svsubr_n_f32_z(svbool_t, svfloat32_t, float32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_z)))
+svfloat16_t svsubr_n_f16_z(svbool_t, svfloat16_t, float16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_m)))
+svuint8_t svsubr_n_u8_m(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_m)))
+svuint32_t svsubr_n_u32_m(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_m)))
+svuint64_t svsubr_n_u64_m(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_m)))
+svuint16_t svsubr_n_u16_m(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_m)))
+svint8_t svsubr_n_s8_m(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_m)))
+svint32_t svsubr_n_s32_m(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_m)))
+svint64_t svsubr_n_s64_m(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_m)))
+svint16_t svsubr_n_s16_m(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_x)))
+svuint8_t svsubr_n_u8_x(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_x)))
+svuint32_t svsubr_n_u32_x(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_x)))
+svuint64_t svsubr_n_u64_x(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_x)))
+svuint16_t svsubr_n_u16_x(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_x)))
+svint8_t svsubr_n_s8_x(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_x)))
+svint32_t svsubr_n_s32_x(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_x)))
+svint64_t svsubr_n_s64_x(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_x)))
+svint16_t svsubr_n_s16_x(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_z)))
+svuint8_t svsubr_n_u8_z(svbool_t, svuint8_t, uint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_z)))
+svuint32_t svsubr_n_u32_z(svbool_t, svuint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_z)))
+svuint64_t svsubr_n_u64_z(svbool_t, svuint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_z)))
+svuint16_t svsubr_n_u16_z(svbool_t, svuint16_t, uint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_z)))
+svint8_t svsubr_n_s8_z(svbool_t, svint8_t, int8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_z)))
+svint32_t svsubr_n_s32_z(svbool_t, svint32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_z)))
+svint64_t svsubr_n_s64_z(svbool_t, svint64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_z)))
+svint16_t svsubr_n_s16_z(svbool_t, svint16_t, int16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_m)))
+svfloat64_t svsubr_f64_m(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_m)))
+svfloat32_t svsubr_f32_m(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_m)))
+svfloat16_t svsubr_f16_m(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_x)))
+svfloat64_t svsubr_f64_x(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_x)))
+svfloat32_t svsubr_f32_x(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_x)))
+svfloat16_t svsubr_f16_x(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_z)))
+svfloat64_t svsubr_f64_z(svbool_t, svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_z)))
+svfloat32_t svsubr_f32_z(svbool_t, svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_z)))
+svfloat16_t svsubr_f16_z(svbool_t, svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_m)))
+svuint8_t svsubr_u8_m(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_m)))
+svuint32_t svsubr_u32_m(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_m)))
+svuint64_t svsubr_u64_m(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_m)))
+svuint16_t svsubr_u16_m(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_m)))
+svint8_t svsubr_s8_m(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_m)))
+svint32_t svsubr_s32_m(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_m)))
+svint64_t svsubr_s64_m(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_m)))
+svint16_t svsubr_s16_m(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_x)))
+svuint8_t svsubr_u8_x(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_x)))
+svuint32_t svsubr_u32_x(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_x)))
+svuint64_t svsubr_u64_x(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_x)))
+svuint16_t svsubr_u16_x(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_x)))
+svint8_t svsubr_s8_x(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_x)))
+svint32_t svsubr_s32_x(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_x)))
+svint64_t svsubr_s64_x(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_x)))
+svint16_t svsubr_s16_x(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_z)))
+svuint8_t svsubr_u8_z(svbool_t, svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_z)))
+svuint32_t svsubr_u32_z(svbool_t, svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_z)))
+svuint64_t svsubr_u64_z(svbool_t, svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_z)))
+svuint16_t svsubr_u16_z(svbool_t, svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_z)))
+svint8_t svsubr_s8_z(svbool_t, svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_z)))
+svint32_t svsubr_s32_z(svbool_t, svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_z)))
+svint64_t svsubr_s64_z(svbool_t, svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_z)))
+svint16_t svsubr_s16_z(svbool_t, svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u8)))
+svuint8_t svtbl_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u32)))
+svuint32_t svtbl_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u64)))
+svuint64_t svtbl_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u16)))
+svuint16_t svtbl_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s8)))
+svint8_t svtbl_s8(svint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f64)))
+svfloat64_t svtbl_f64(svfloat64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f32)))
+svfloat32_t svtbl_f32(svfloat32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f16)))
+svfloat16_t svtbl_f16(svfloat16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s32)))
+svint32_t svtbl_s32(svint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s64)))
+svint64_t svtbl_s64(svint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s16)))
+svint16_t svtbl_s16(svint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u8)))
+svuint8_t svtrn1_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u32)))
+svuint32_t svtrn1_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u64)))
+svuint64_t svtrn1_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u16)))
+svuint16_t svtrn1_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s8)))
+svint8_t svtrn1_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f64)))
+svfloat64_t svtrn1_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f32)))
+svfloat32_t svtrn1_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f16)))
+svfloat16_t svtrn1_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s32)))
+svint32_t svtrn1_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s64)))
+svint64_t svtrn1_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s16)))
+svint16_t svtrn1_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b16)))
+svbool_t svtrn1_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b32)))
+svbool_t svtrn1_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b64)))
+svbool_t svtrn1_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_b8)))
+svbool_t svtrn1_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u8)))
+svuint8_t svtrn2_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u32)))
+svuint32_t svtrn2_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u64)))
+svuint64_t svtrn2_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u16)))
+svuint16_t svtrn2_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s8)))
+svint8_t svtrn2_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f64)))
+svfloat64_t svtrn2_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f32)))
+svfloat32_t svtrn2_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f16)))
+svfloat16_t svtrn2_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s32)))
+svint32_t svtrn2_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s64)))
+svint64_t svtrn2_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s16)))
+svint16_t svtrn2_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b16)))
+svbool_t svtrn2_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b32)))
+svbool_t svtrn2_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b64)))
+svbool_t svtrn2_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_b8)))
+svbool_t svtrn2_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u8)))
+svuint8x2_t svundef2_u8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u32)))
+svuint32x2_t svundef2_u32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u64)))
+svuint64x2_t svundef2_u64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_u16)))
+svuint16x2_t svundef2_u16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s8)))
+svint8x2_t svundef2_s8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_f64)))
+svfloat64x2_t svundef2_f64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_f32)))
+svfloat32x2_t svundef2_f32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_f16)))
+svfloat16x2_t svundef2_f16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s32)))
+svint32x2_t svundef2_s32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s64)))
+svint64x2_t svundef2_s64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef2_s16)))
+svint16x2_t svundef2_s16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u8)))
+svuint8x3_t svundef3_u8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u32)))
+svuint32x3_t svundef3_u32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u64)))
+svuint64x3_t svundef3_u64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_u16)))
+svuint16x3_t svundef3_u16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s8)))
+svint8x3_t svundef3_s8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_f64)))
+svfloat64x3_t svundef3_f64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_f32)))
+svfloat32x3_t svundef3_f32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_f16)))
+svfloat16x3_t svundef3_f16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s32)))
+svint32x3_t svundef3_s32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s64)))
+svint64x3_t svundef3_s64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef3_s16)))
+svint16x3_t svundef3_s16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u8)))
+svuint8x4_t svundef4_u8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u32)))
+svuint32x4_t svundef4_u32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u64)))
+svuint64x4_t svundef4_u64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_u16)))
+svuint16x4_t svundef4_u16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s8)))
+svint8x4_t svundef4_s8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_f64)))
+svfloat64x4_t svundef4_f64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_f32)))
+svfloat32x4_t svundef4_f32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_f16)))
+svfloat16x4_t svundef4_f16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s32)))
+svint32x4_t svundef4_s32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s64)))
+svint64x4_t svundef4_s64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef4_s16)))
+svint16x4_t svundef4_s16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u8)))
+svuint8_t svundef_u8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u32)))
+svuint32_t svundef_u32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u64)))
+svuint64_t svundef_u64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_u16)))
+svuint16_t svundef_u16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s8)))
+svint8_t svundef_s8(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_f64)))
+svfloat64_t svundef_f64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_f32)))
+svfloat32_t svundef_f32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_f16)))
+svfloat16_t svundef_f16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s32)))
+svint32_t svundef_s32(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s64)))
+svint64_t svundef_s64(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svundef_s16)))
+svint16_t svundef_s16(void);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_b)))
+svbool_t svunpkhi_b(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s32)))
+svint32_t svunpkhi_s32(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s64)))
+svint64_t svunpkhi_s64(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s16)))
+svint16_t svunpkhi_s16(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u32)))
+svuint32_t svunpkhi_u32(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u64)))
+svuint64_t svunpkhi_u64(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u16)))
+svuint16_t svunpkhi_u16(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_b)))
+svbool_t svunpklo_b(svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s32)))
+svint32_t svunpklo_s32(svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s64)))
+svint64_t svunpklo_s64(svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s16)))
+svint16_t svunpklo_s16(svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u32)))
+svuint32_t svunpklo_u32(svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u64)))
+svuint64_t svunpklo_u64(svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u16)))
+svuint16_t svunpklo_u16(svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u8)))
+svuint8_t svuzp1_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u32)))
+svuint32_t svuzp1_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u64)))
+svuint64_t svuzp1_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u16)))
+svuint16_t svuzp1_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s8)))
+svint8_t svuzp1_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f64)))
+svfloat64_t svuzp1_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f32)))
+svfloat32_t svuzp1_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f16)))
+svfloat16_t svuzp1_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s32)))
+svint32_t svuzp1_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s64)))
+svint64_t svuzp1_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s16)))
+svint16_t svuzp1_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b16)))
+svbool_t svuzp1_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b32)))
+svbool_t svuzp1_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b64)))
+svbool_t svuzp1_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_b8)))
+svbool_t svuzp1_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u8)))
+svuint8_t svuzp2_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u32)))
+svuint32_t svuzp2_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u64)))
+svuint64_t svuzp2_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u16)))
+svuint16_t svuzp2_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s8)))
+svint8_t svuzp2_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f64)))
+svfloat64_t svuzp2_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f32)))
+svfloat32_t svuzp2_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f16)))
+svfloat16_t svuzp2_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s32)))
+svint32_t svuzp2_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s64)))
+svint64_t svuzp2_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s16)))
+svint16_t svuzp2_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b16)))
+svbool_t svuzp2_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b32)))
+svbool_t svuzp2_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b64)))
+svbool_t svuzp2_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_b8)))
+svbool_t svuzp2_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s32)))
+svbool_t svwhilele_b8_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s32)))
+svbool_t svwhilele_b32_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s32)))
+svbool_t svwhilele_b64_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s32)))
+svbool_t svwhilele_b16_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s64)))
+svbool_t svwhilele_b8_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s64)))
+svbool_t svwhilele_b32_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s64)))
+svbool_t svwhilele_b64_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s64)))
+svbool_t svwhilele_b16_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u32)))
+svbool_t svwhilele_b8_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u32)))
+svbool_t svwhilele_b32_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u32)))
+svbool_t svwhilele_b64_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u32)))
+svbool_t svwhilele_b16_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u64)))
+svbool_t svwhilele_b8_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u64)))
+svbool_t svwhilele_b32_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u64)))
+svbool_t svwhilele_b64_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u64)))
+svbool_t svwhilele_b16_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u32)))
+svbool_t svwhilelt_b8_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u32)))
+svbool_t svwhilelt_b32_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u32)))
+svbool_t svwhilelt_b64_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u32)))
+svbool_t svwhilelt_b16_u32(uint32_t, uint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u64)))
+svbool_t svwhilelt_b8_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u64)))
+svbool_t svwhilelt_b32_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u64)))
+svbool_t svwhilelt_b64_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u64)))
+svbool_t svwhilelt_b16_u64(uint64_t, uint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s32)))
+svbool_t svwhilelt_b8_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s32)))
+svbool_t svwhilelt_b32_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s32)))
+svbool_t svwhilelt_b64_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s32)))
+svbool_t svwhilelt_b16_s32(int32_t, int32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s64)))
+svbool_t svwhilelt_b8_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s64)))
+svbool_t svwhilelt_b32_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s64)))
+svbool_t svwhilelt_b64_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s64)))
+svbool_t svwhilelt_b16_s64(int64_t, int64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u8)))
+svuint8_t svzip1_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u32)))
+svuint32_t svzip1_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u64)))
+svuint64_t svzip1_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u16)))
+svuint16_t svzip1_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s8)))
+svint8_t svzip1_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f64)))
+svfloat64_t svzip1_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f32)))
+svfloat32_t svzip1_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f16)))
+svfloat16_t svzip1_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s32)))
+svint32_t svzip1_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s64)))
+svint64_t svzip1_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s16)))
+svint16_t svzip1_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b16)))
+svbool_t svzip1_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b32)))
+svbool_t svzip1_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b64)))
+svbool_t svzip1_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_b8)))
+svbool_t svzip1_b8(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u8)))
+svuint8_t svzip2_u8(svuint8_t, svuint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u32)))
+svuint32_t svzip2_u32(svuint32_t, svuint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u64)))
+svuint64_t svzip2_u64(svuint64_t, svuint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u16)))
+svuint16_t svzip2_u16(svuint16_t, svuint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s8)))
+svint8_t svzip2_s8(svint8_t, svint8_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f64)))
+svfloat64_t svzip2_f64(svfloat64_t, svfloat64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f32)))
+svfloat32_t svzip2_f32(svfloat32_t, svfloat32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f16)))
+svfloat16_t svzip2_f16(svfloat16_t, svfloat16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s32)))
+svint32_t svzip2_s32(svint32_t, svint32_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s64)))
+svint64_t svzip2_s64(svint64_t, svint64_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s16)))
+svint16_t svzip2_s16(svint16_t, svint16_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b16)))
+svbool_t svzip2_b16(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b32)))
+svbool_t svzip2_b32(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b64)))
+svbool_t svzip2_b64(svbool_t, svbool_t);
+__ai __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_b8)))
+svbool_t svzip2_b8(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_m)))
+svfloat64_t svabd_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_m)))
+svfloat32_t svabd_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_m)))
+svfloat16_t svabd_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_x)))
+svfloat64_t svabd_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_x)))
+svfloat32_t svabd_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_x)))
+svfloat16_t svabd_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f64_z)))
+svfloat64_t svabd_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f32_z)))
+svfloat32_t svabd_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_f16_z)))
+svfloat16_t svabd_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_m)))
+svint8_t svabd_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_m)))
+svint32_t svabd_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_m)))
+svint64_t svabd_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_m)))
+svint16_t svabd_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_x)))
+svint8_t svabd_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_x)))
+svint32_t svabd_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_x)))
+svint64_t svabd_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_x)))
+svint16_t svabd_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s8_z)))
+svint8_t svabd_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s32_z)))
+svint32_t svabd_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s64_z)))
+svint64_t svabd_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_s16_z)))
+svint16_t svabd_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_m)))
+svuint8_t svabd_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_m)))
+svuint32_t svabd_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_m)))
+svuint64_t svabd_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_m)))
+svuint16_t svabd_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_x)))
+svuint8_t svabd_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_x)))
+svuint32_t svabd_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_x)))
+svuint64_t svabd_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_x)))
+svuint16_t svabd_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u8_z)))
+svuint8_t svabd_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u32_z)))
+svuint32_t svabd_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u64_z)))
+svuint64_t svabd_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_n_u16_z)))
+svuint16_t svabd_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_m)))
+svfloat64_t svabd_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_m)))
+svfloat32_t svabd_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_m)))
+svfloat16_t svabd_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_x)))
+svfloat64_t svabd_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_x)))
+svfloat32_t svabd_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_x)))
+svfloat16_t svabd_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f64_z)))
+svfloat64_t svabd_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f32_z)))
+svfloat32_t svabd_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_f16_z)))
+svfloat16_t svabd_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_m)))
+svint8_t svabd_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_m)))
+svint32_t svabd_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_m)))
+svint64_t svabd_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_m)))
+svint16_t svabd_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_x)))
+svint8_t svabd_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_x)))
+svint32_t svabd_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_x)))
+svint64_t svabd_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_x)))
+svint16_t svabd_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s8_z)))
+svint8_t svabd_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s32_z)))
+svint32_t svabd_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s64_z)))
+svint64_t svabd_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_s16_z)))
+svint16_t svabd_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_m)))
+svuint8_t svabd_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_m)))
+svuint32_t svabd_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_m)))
+svuint64_t svabd_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_m)))
+svuint16_t svabd_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_x)))
+svuint8_t svabd_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_x)))
+svuint32_t svabd_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_x)))
+svuint64_t svabd_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_x)))
+svuint16_t svabd_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u8_z)))
+svuint8_t svabd_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u32_z)))
+svuint32_t svabd_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u64_z)))
+svuint64_t svabd_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabd_u16_z)))
+svuint16_t svabd_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_m)))
+svfloat64_t svabs_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_m)))
+svfloat32_t svabs_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_m)))
+svfloat16_t svabs_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_x)))
+svfloat64_t svabs_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_x)))
+svfloat32_t svabs_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_x)))
+svfloat16_t svabs_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f64_z)))
+svfloat64_t svabs_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f32_z)))
+svfloat32_t svabs_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_f16_z)))
+svfloat16_t svabs_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_m)))
+svint8_t svabs_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_m)))
+svint32_t svabs_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_m)))
+svint64_t svabs_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_m)))
+svint16_t svabs_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_x)))
+svint8_t svabs_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_x)))
+svint32_t svabs_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_x)))
+svint64_t svabs_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_x)))
+svint16_t svabs_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s8_z)))
+svint8_t svabs_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s32_z)))
+svint32_t svabs_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s64_z)))
+svint64_t svabs_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svabs_s16_z)))
+svint16_t svabs_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f64)))
+svbool_t svacge(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f32)))
+svbool_t svacge(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_n_f16)))
+svbool_t svacge(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f64)))
+svbool_t svacge(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f32)))
+svbool_t svacge(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacge_f16)))
+svbool_t svacge(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f64)))
+svbool_t svacgt(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f32)))
+svbool_t svacgt(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_n_f16)))
+svbool_t svacgt(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f64)))
+svbool_t svacgt(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f32)))
+svbool_t svacgt(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacgt_f16)))
+svbool_t svacgt(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f64)))
+svbool_t svacle(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f32)))
+svbool_t svacle(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_n_f16)))
+svbool_t svacle(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f64)))
+svbool_t svacle(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f32)))
+svbool_t svacle(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svacle_f16)))
+svbool_t svacle(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f64)))
+svbool_t svaclt(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f32)))
+svbool_t svaclt(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_n_f16)))
+svbool_t svaclt(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f64)))
+svbool_t svaclt(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f32)))
+svbool_t svaclt(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaclt_f16)))
+svbool_t svaclt(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_m)))
+svfloat64_t svadd_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_m)))
+svfloat32_t svadd_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_m)))
+svfloat16_t svadd_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_x)))
+svfloat64_t svadd_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_x)))
+svfloat32_t svadd_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_x)))
+svfloat16_t svadd_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f64_z)))
+svfloat64_t svadd_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f32_z)))
+svfloat32_t svadd_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_f16_z)))
+svfloat16_t svadd_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_m)))
+svuint8_t svadd_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_m)))
+svuint32_t svadd_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_m)))
+svuint64_t svadd_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_m)))
+svuint16_t svadd_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_m)))
+svint8_t svadd_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_m)))
+svint32_t svadd_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_m)))
+svint64_t svadd_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_m)))
+svint16_t svadd_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_x)))
+svuint8_t svadd_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_x)))
+svuint32_t svadd_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_x)))
+svuint64_t svadd_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_x)))
+svuint16_t svadd_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_x)))
+svint8_t svadd_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_x)))
+svint32_t svadd_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_x)))
+svint64_t svadd_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_x)))
+svint16_t svadd_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u8_z)))
+svuint8_t svadd_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u32_z)))
+svuint32_t svadd_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u64_z)))
+svuint64_t svadd_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_u16_z)))
+svuint16_t svadd_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s8_z)))
+svint8_t svadd_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s32_z)))
+svint32_t svadd_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s64_z)))
+svint64_t svadd_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_n_s16_z)))
+svint16_t svadd_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_m)))
+svfloat64_t svadd_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_m)))
+svfloat32_t svadd_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_m)))
+svfloat16_t svadd_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_x)))
+svfloat64_t svadd_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_x)))
+svfloat32_t svadd_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_x)))
+svfloat16_t svadd_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f64_z)))
+svfloat64_t svadd_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f32_z)))
+svfloat32_t svadd_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_f16_z)))
+svfloat16_t svadd_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_m)))
+svuint8_t svadd_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_m)))
+svuint32_t svadd_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_m)))
+svuint64_t svadd_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_m)))
+svuint16_t svadd_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_m)))
+svint8_t svadd_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_m)))
+svint32_t svadd_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_m)))
+svint64_t svadd_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_m)))
+svint16_t svadd_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_x)))
+svuint8_t svadd_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_x)))
+svuint32_t svadd_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_x)))
+svuint64_t svadd_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_x)))
+svuint16_t svadd_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_x)))
+svint8_t svadd_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_x)))
+svint32_t svadd_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_x)))
+svint64_t svadd_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_x)))
+svint16_t svadd_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u8_z)))
+svuint8_t svadd_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u32_z)))
+svuint32_t svadd_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u64_z)))
+svuint64_t svadd_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_u16_z)))
+svuint16_t svadd_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s8_z)))
+svint8_t svadd_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s32_z)))
+svint32_t svadd_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s64_z)))
+svint64_t svadd_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadd_s16_z)))
+svint16_t svadd_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f64)))
+float64_t svadda(svbool_t, float64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f32)))
+float32_t svadda(svbool_t, float32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svadda_f16)))
+float16_t svadda(svbool_t, float16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s8)))
+int64_t svaddv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s32)))
+int64_t svaddv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s64)))
+int64_t svaddv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_s16)))
+int64_t svaddv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u8)))
+uint64_t svaddv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u32)))
+uint64_t svaddv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u64)))
+uint64_t svaddv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_u16)))
+uint64_t svaddv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f64)))
+float64_t svaddv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f32)))
+float32_t svaddv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svaddv_f16)))
+float16_t svaddv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_b_z)))
+svbool_t svand_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_m)))
+svuint8_t svand_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_m)))
+svuint32_t svand_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_m)))
+svuint64_t svand_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_m)))
+svuint16_t svand_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_m)))
+svint8_t svand_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_m)))
+svint32_t svand_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_m)))
+svint64_t svand_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_m)))
+svint16_t svand_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_x)))
+svuint8_t svand_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_x)))
+svuint32_t svand_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_x)))
+svuint64_t svand_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_x)))
+svuint16_t svand_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_x)))
+svint8_t svand_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_x)))
+svint32_t svand_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_x)))
+svint64_t svand_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_x)))
+svint16_t svand_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u8_z)))
+svuint8_t svand_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u32_z)))
+svuint32_t svand_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u64_z)))
+svuint64_t svand_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_u16_z)))
+svuint16_t svand_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s8_z)))
+svint8_t svand_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s32_z)))
+svint32_t svand_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s64_z)))
+svint64_t svand_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_n_s16_z)))
+svint16_t svand_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_m)))
+svuint8_t svand_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_m)))
+svuint32_t svand_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_m)))
+svuint64_t svand_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_m)))
+svuint16_t svand_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_m)))
+svint8_t svand_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_m)))
+svint32_t svand_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_m)))
+svint64_t svand_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_m)))
+svint16_t svand_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_x)))
+svuint8_t svand_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_x)))
+svuint32_t svand_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_x)))
+svuint64_t svand_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_x)))
+svuint16_t svand_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_x)))
+svint8_t svand_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_x)))
+svint32_t svand_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_x)))
+svint64_t svand_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_x)))
+svint16_t svand_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u8_z)))
+svuint8_t svand_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u32_z)))
+svuint32_t svand_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u64_z)))
+svuint64_t svand_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_u16_z)))
+svuint16_t svand_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s8_z)))
+svint8_t svand_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s32_z)))
+svint32_t svand_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s64_z)))
+svint64_t svand_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svand_s16_z)))
+svint16_t svand_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u8)))
+uint8_t svandv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u32)))
+uint32_t svandv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u64)))
+uint64_t svandv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_u16)))
+uint16_t svandv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s8)))
+int8_t svandv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s32)))
+int32_t svandv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s64)))
+int64_t svandv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svandv_s16)))
+int16_t svandv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_m)))
+svint8_t svasr_m(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_m)))
+svint32_t svasr_m(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_m)))
+svint64_t svasr_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_m)))
+svint16_t svasr_m(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_x)))
+svint8_t svasr_x(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_x)))
+svint32_t svasr_x(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_x)))
+svint64_t svasr_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_x)))
+svint16_t svasr_x(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s8_z)))
+svint8_t svasr_z(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s32_z)))
+svint32_t svasr_z(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s64_z)))
+svint64_t svasr_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_n_s16_z)))
+svint16_t svasr_z(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_m)))
+svint8_t svasr_m(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_m)))
+svint32_t svasr_m(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_m)))
+svint64_t svasr_m(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_m)))
+svint16_t svasr_m(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_x)))
+svint8_t svasr_x(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_x)))
+svint32_t svasr_x(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_x)))
+svint64_t svasr_x(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_x)))
+svint16_t svasr_x(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s8_z)))
+svint8_t svasr_z(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s32_z)))
+svint32_t svasr_z(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s64_z)))
+svint64_t svasr_z(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_s16_z)))
+svint16_t svasr_z(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_m)))
+svint8_t svasr_wide_m(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_m)))
+svint32_t svasr_wide_m(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_m)))
+svint16_t svasr_wide_m(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_x)))
+svint8_t svasr_wide_x(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_x)))
+svint32_t svasr_wide_x(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_x)))
+svint16_t svasr_wide_x(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s8_z)))
+svint8_t svasr_wide_z(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s32_z)))
+svint32_t svasr_wide_z(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_n_s16_z)))
+svint16_t svasr_wide_z(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_m)))
+svint8_t svasr_wide_m(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_m)))
+svint32_t svasr_wide_m(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_m)))
+svint16_t svasr_wide_m(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_x)))
+svint8_t svasr_wide_x(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_x)))
+svint32_t svasr_wide_x(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_x)))
+svint16_t svasr_wide_x(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s8_z)))
+svint8_t svasr_wide_z(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s32_z)))
+svint32_t svasr_wide_z(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasr_wide_s16_z)))
+svint16_t svasr_wide_z(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_m)))
+svint8_t svasrd_m(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_m)))
+svint32_t svasrd_m(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_m)))
+svint64_t svasrd_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_m)))
+svint16_t svasrd_m(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_x)))
+svint8_t svasrd_x(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_x)))
+svint32_t svasrd_x(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_x)))
+svint64_t svasrd_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_x)))
+svint16_t svasrd_x(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s8_z)))
+svint8_t svasrd_z(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s32_z)))
+svint32_t svasrd_z(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s64_z)))
+svint64_t svasrd_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svasrd_n_s16_z)))
+svint16_t svasrd_z(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_b_z)))
+svbool_t svbic_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_m)))
+svuint8_t svbic_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_m)))
+svuint32_t svbic_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_m)))
+svuint64_t svbic_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_m)))
+svuint16_t svbic_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_m)))
+svint8_t svbic_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_m)))
+svint32_t svbic_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_m)))
+svint64_t svbic_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_m)))
+svint16_t svbic_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_x)))
+svuint8_t svbic_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_x)))
+svuint32_t svbic_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_x)))
+svuint64_t svbic_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_x)))
+svuint16_t svbic_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_x)))
+svint8_t svbic_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_x)))
+svint32_t svbic_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_x)))
+svint64_t svbic_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_x)))
+svint16_t svbic_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u8_z)))
+svuint8_t svbic_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u32_z)))
+svuint32_t svbic_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u64_z)))
+svuint64_t svbic_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_u16_z)))
+svuint16_t svbic_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s8_z)))
+svint8_t svbic_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s32_z)))
+svint32_t svbic_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s64_z)))
+svint64_t svbic_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_n_s16_z)))
+svint16_t svbic_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_m)))
+svuint8_t svbic_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_m)))
+svuint32_t svbic_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_m)))
+svuint64_t svbic_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_m)))
+svuint16_t svbic_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_m)))
+svint8_t svbic_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_m)))
+svint32_t svbic_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_m)))
+svint64_t svbic_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_m)))
+svint16_t svbic_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_x)))
+svuint8_t svbic_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_x)))
+svuint32_t svbic_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_x)))
+svuint64_t svbic_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_x)))
+svuint16_t svbic_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_x)))
+svint8_t svbic_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_x)))
+svint32_t svbic_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_x)))
+svint64_t svbic_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_x)))
+svint16_t svbic_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u8_z)))
+svuint8_t svbic_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u32_z)))
+svuint32_t svbic_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u64_z)))
+svuint64_t svbic_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_u16_z)))
+svuint16_t svbic_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s8_z)))
+svint8_t svbic_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s32_z)))
+svint32_t svbic_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s64_z)))
+svint64_t svbic_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbic_s16_z)))
+svint16_t svbic_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_m)))
+svbool_t svbrka_m(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrka_b_z)))
+svbool_t svbrka_z(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_m)))
+svbool_t svbrkb_m(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkb_b_z)))
+svbool_t svbrkb_z(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkn_b_z)))
+svbool_t svbrkn_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpa_b_z)))
+svbool_t svbrkpa_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svbrkpb_b_z)))
+svbool_t svbrkpb_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_m)))
+svfloat64_t svcadd_m(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_m)))
+svfloat32_t svcadd_m(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_m)))
+svfloat16_t svcadd_m(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_x)))
+svfloat64_t svcadd_x(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_x)))
+svfloat32_t svcadd_x(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_x)))
+svfloat16_t svcadd_x(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f64_z)))
+svfloat64_t svcadd_z(svbool_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f32_z)))
+svfloat32_t svcadd_z(svbool_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcadd_f16_z)))
+svfloat16_t svcadd_z(svbool_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u8)))
+uint8_t svclasta(svbool_t, uint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u32)))
+uint32_t svclasta(svbool_t, uint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u64)))
+uint64_t svclasta(svbool_t, uint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_u16)))
+uint16_t svclasta(svbool_t, uint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s8)))
+int8_t svclasta(svbool_t, int8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f64)))
+float64_t svclasta(svbool_t, float64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f32)))
+float32_t svclasta(svbool_t, float32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_f16)))
+float16_t svclasta(svbool_t, float16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s32)))
+int32_t svclasta(svbool_t, int32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s64)))
+int64_t svclasta(svbool_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_n_s16)))
+int16_t svclasta(svbool_t, int16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u8)))
+svuint8_t svclasta(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u32)))
+svuint32_t svclasta(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u64)))
+svuint64_t svclasta(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_u16)))
+svuint16_t svclasta(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s8)))
+svint8_t svclasta(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f64)))
+svfloat64_t svclasta(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f32)))
+svfloat32_t svclasta(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_f16)))
+svfloat16_t svclasta(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s32)))
+svint32_t svclasta(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s64)))
+svint64_t svclasta(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclasta_s16)))
+svint16_t svclasta(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u8)))
+uint8_t svclastb(svbool_t, uint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u32)))
+uint32_t svclastb(svbool_t, uint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u64)))
+uint64_t svclastb(svbool_t, uint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_u16)))
+uint16_t svclastb(svbool_t, uint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s8)))
+int8_t svclastb(svbool_t, int8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f64)))
+float64_t svclastb(svbool_t, float64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f32)))
+float32_t svclastb(svbool_t, float32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_f16)))
+float16_t svclastb(svbool_t, float16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s32)))
+int32_t svclastb(svbool_t, int32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s64)))
+int64_t svclastb(svbool_t, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_n_s16)))
+int16_t svclastb(svbool_t, int16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u8)))
+svuint8_t svclastb(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u32)))
+svuint32_t svclastb(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u64)))
+svuint64_t svclastb(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_u16)))
+svuint16_t svclastb(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s8)))
+svint8_t svclastb(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f64)))
+svfloat64_t svclastb(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f32)))
+svfloat32_t svclastb(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_f16)))
+svfloat16_t svclastb(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s32)))
+svint32_t svclastb(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s64)))
+svint64_t svclastb(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclastb_s16)))
+svint16_t svclastb(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_m)))
+svuint8_t svcls_m(svuint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_m)))
+svuint32_t svcls_m(svuint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_m)))
+svuint64_t svcls_m(svuint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_m)))
+svuint16_t svcls_m(svuint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_x)))
+svuint8_t svcls_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_x)))
+svuint32_t svcls_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_x)))
+svuint64_t svcls_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_x)))
+svuint16_t svcls_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s8_z)))
+svuint8_t svcls_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s32_z)))
+svuint32_t svcls_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s64_z)))
+svuint64_t svcls_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcls_s16_z)))
+svuint16_t svcls_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_m)))
+svuint8_t svclz_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_m)))
+svuint32_t svclz_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_m)))
+svuint64_t svclz_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_m)))
+svuint16_t svclz_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_m)))
+svuint8_t svclz_m(svuint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_m)))
+svuint32_t svclz_m(svuint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_m)))
+svuint64_t svclz_m(svuint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_m)))
+svuint16_t svclz_m(svuint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_x)))
+svuint8_t svclz_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_x)))
+svuint32_t svclz_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_x)))
+svuint64_t svclz_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_x)))
+svuint16_t svclz_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_x)))
+svuint8_t svclz_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_x)))
+svuint32_t svclz_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_x)))
+svuint64_t svclz_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_x)))
+svuint16_t svclz_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u8_z)))
+svuint8_t svclz_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u32_z)))
+svuint32_t svclz_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u64_z)))
+svuint64_t svclz_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_u16_z)))
+svuint16_t svclz_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s8_z)))
+svuint8_t svclz_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s32_z)))
+svuint32_t svclz_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s64_z)))
+svuint64_t svclz_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svclz_s16_z)))
+svuint16_t svclz_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_m)))
+svfloat64_t svcmla_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_m)))
+svfloat32_t svcmla_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_m)))
+svfloat16_t svcmla_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_x)))
+svfloat64_t svcmla_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_x)))
+svfloat32_t svcmla_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_x)))
+svfloat16_t svcmla_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f64_z)))
+svfloat64_t svcmla_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f32_z)))
+svfloat32_t svcmla_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_f16_z)))
+svfloat16_t svcmla_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f32)))
+svfloat32_t svcmla_lane(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmla_lane_f16)))
+svfloat16_t svcmla_lane(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f64)))
+svbool_t svcmpeq(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f32)))
+svbool_t svcmpeq(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_f16)))
+svbool_t svcmpeq(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u8)))
+svbool_t svcmpeq(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u32)))
+svbool_t svcmpeq(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u64)))
+svbool_t svcmpeq(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_u16)))
+svbool_t svcmpeq(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s8)))
+svbool_t svcmpeq(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s32)))
+svbool_t svcmpeq(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s64)))
+svbool_t svcmpeq(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_n_s16)))
+svbool_t svcmpeq(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u8)))
+svbool_t svcmpeq(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u32)))
+svbool_t svcmpeq(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u64)))
+svbool_t svcmpeq(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_u16)))
+svbool_t svcmpeq(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s8)))
+svbool_t svcmpeq(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s32)))
+svbool_t svcmpeq(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s64)))
+svbool_t svcmpeq(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_s16)))
+svbool_t svcmpeq(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f64)))
+svbool_t svcmpeq(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f32)))
+svbool_t svcmpeq(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_f16)))
+svbool_t svcmpeq(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s8)))
+svbool_t svcmpeq_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s32)))
+svbool_t svcmpeq_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_n_s16)))
+svbool_t svcmpeq_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s8)))
+svbool_t svcmpeq_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s32)))
+svbool_t svcmpeq_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpeq_wide_s16)))
+svbool_t svcmpeq_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f64)))
+svbool_t svcmpge(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f32)))
+svbool_t svcmpge(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_f16)))
+svbool_t svcmpge(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s8)))
+svbool_t svcmpge(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s32)))
+svbool_t svcmpge(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s64)))
+svbool_t svcmpge(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_s16)))
+svbool_t svcmpge(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u8)))
+svbool_t svcmpge(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u32)))
+svbool_t svcmpge(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u64)))
+svbool_t svcmpge(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_n_u16)))
+svbool_t svcmpge(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s8)))
+svbool_t svcmpge(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s32)))
+svbool_t svcmpge(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s64)))
+svbool_t svcmpge(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_s16)))
+svbool_t svcmpge(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f64)))
+svbool_t svcmpge(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f32)))
+svbool_t svcmpge(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_f16)))
+svbool_t svcmpge(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u8)))
+svbool_t svcmpge(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u32)))
+svbool_t svcmpge(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u64)))
+svbool_t svcmpge(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_u16)))
+svbool_t svcmpge(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s8)))
+svbool_t svcmpge_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s32)))
+svbool_t svcmpge_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_s16)))
+svbool_t svcmpge_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u8)))
+svbool_t svcmpge_wide(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u32)))
+svbool_t svcmpge_wide(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_n_u16)))
+svbool_t svcmpge_wide(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s8)))
+svbool_t svcmpge_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s32)))
+svbool_t svcmpge_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_s16)))
+svbool_t svcmpge_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u8)))
+svbool_t svcmpge_wide(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u32)))
+svbool_t svcmpge_wide(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpge_wide_u16)))
+svbool_t svcmpge_wide(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f64)))
+svbool_t svcmpgt(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f32)))
+svbool_t svcmpgt(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_f16)))
+svbool_t svcmpgt(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s8)))
+svbool_t svcmpgt(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s32)))
+svbool_t svcmpgt(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s64)))
+svbool_t svcmpgt(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_s16)))
+svbool_t svcmpgt(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u8)))
+svbool_t svcmpgt(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u32)))
+svbool_t svcmpgt(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u64)))
+svbool_t svcmpgt(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_n_u16)))
+svbool_t svcmpgt(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s8)))
+svbool_t svcmpgt(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s32)))
+svbool_t svcmpgt(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s64)))
+svbool_t svcmpgt(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_s16)))
+svbool_t svcmpgt(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f64)))
+svbool_t svcmpgt(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f32)))
+svbool_t svcmpgt(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_f16)))
+svbool_t svcmpgt(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u8)))
+svbool_t svcmpgt(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u32)))
+svbool_t svcmpgt(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u64)))
+svbool_t svcmpgt(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_u16)))
+svbool_t svcmpgt(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s8)))
+svbool_t svcmpgt_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s32)))
+svbool_t svcmpgt_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_s16)))
+svbool_t svcmpgt_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u8)))
+svbool_t svcmpgt_wide(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u32)))
+svbool_t svcmpgt_wide(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_n_u16)))
+svbool_t svcmpgt_wide(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s8)))
+svbool_t svcmpgt_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s32)))
+svbool_t svcmpgt_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_s16)))
+svbool_t svcmpgt_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u8)))
+svbool_t svcmpgt_wide(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u32)))
+svbool_t svcmpgt_wide(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpgt_wide_u16)))
+svbool_t svcmpgt_wide(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f64)))
+svbool_t svcmple(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f32)))
+svbool_t svcmple(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_f16)))
+svbool_t svcmple(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s8)))
+svbool_t svcmple(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s32)))
+svbool_t svcmple(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s64)))
+svbool_t svcmple(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_s16)))
+svbool_t svcmple(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u8)))
+svbool_t svcmple(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u32)))
+svbool_t svcmple(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u64)))
+svbool_t svcmple(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_n_u16)))
+svbool_t svcmple(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s8)))
+svbool_t svcmple(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s32)))
+svbool_t svcmple(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s64)))
+svbool_t svcmple(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_s16)))
+svbool_t svcmple(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f64)))
+svbool_t svcmple(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f32)))
+svbool_t svcmple(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_f16)))
+svbool_t svcmple(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u8)))
+svbool_t svcmple(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u32)))
+svbool_t svcmple(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u64)))
+svbool_t svcmple(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_u16)))
+svbool_t svcmple(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s8)))
+svbool_t svcmple_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s32)))
+svbool_t svcmple_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_s16)))
+svbool_t svcmple_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u8)))
+svbool_t svcmple_wide(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u32)))
+svbool_t svcmple_wide(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_n_u16)))
+svbool_t svcmple_wide(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s8)))
+svbool_t svcmple_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s32)))
+svbool_t svcmple_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_s16)))
+svbool_t svcmple_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u8)))
+svbool_t svcmple_wide(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u32)))
+svbool_t svcmple_wide(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmple_wide_u16)))
+svbool_t svcmple_wide(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u8)))
+svbool_t svcmplt(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u32)))
+svbool_t svcmplt(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u64)))
+svbool_t svcmplt(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_u16)))
+svbool_t svcmplt(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f64)))
+svbool_t svcmplt(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f32)))
+svbool_t svcmplt(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_f16)))
+svbool_t svcmplt(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s8)))
+svbool_t svcmplt(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s32)))
+svbool_t svcmplt(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s64)))
+svbool_t svcmplt(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_n_s16)))
+svbool_t svcmplt(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u8)))
+svbool_t svcmplt(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u32)))
+svbool_t svcmplt(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u64)))
+svbool_t svcmplt(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_u16)))
+svbool_t svcmplt(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s8)))
+svbool_t svcmplt(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s32)))
+svbool_t svcmplt(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s64)))
+svbool_t svcmplt(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_s16)))
+svbool_t svcmplt(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f64)))
+svbool_t svcmplt(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f32)))
+svbool_t svcmplt(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_f16)))
+svbool_t svcmplt(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u8)))
+svbool_t svcmplt_wide(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u32)))
+svbool_t svcmplt_wide(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_u16)))
+svbool_t svcmplt_wide(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s8)))
+svbool_t svcmplt_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s32)))
+svbool_t svcmplt_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_n_s16)))
+svbool_t svcmplt_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u8)))
+svbool_t svcmplt_wide(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u32)))
+svbool_t svcmplt_wide(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_u16)))
+svbool_t svcmplt_wide(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s8)))
+svbool_t svcmplt_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s32)))
+svbool_t svcmplt_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmplt_wide_s16)))
+svbool_t svcmplt_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f64)))
+svbool_t svcmpne(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f32)))
+svbool_t svcmpne(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_f16)))
+svbool_t svcmpne(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u8)))
+svbool_t svcmpne(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u32)))
+svbool_t svcmpne(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u64)))
+svbool_t svcmpne(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_u16)))
+svbool_t svcmpne(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s8)))
+svbool_t svcmpne(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s32)))
+svbool_t svcmpne(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s64)))
+svbool_t svcmpne(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_n_s16)))
+svbool_t svcmpne(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u8)))
+svbool_t svcmpne(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u32)))
+svbool_t svcmpne(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u64)))
+svbool_t svcmpne(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_u16)))
+svbool_t svcmpne(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s8)))
+svbool_t svcmpne(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s32)))
+svbool_t svcmpne(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s64)))
+svbool_t svcmpne(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_s16)))
+svbool_t svcmpne(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f64)))
+svbool_t svcmpne(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f32)))
+svbool_t svcmpne(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_f16)))
+svbool_t svcmpne(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s8)))
+svbool_t svcmpne_wide(svbool_t, svint8_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s32)))
+svbool_t svcmpne_wide(svbool_t, svint32_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_n_s16)))
+svbool_t svcmpne_wide(svbool_t, svint16_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s8)))
+svbool_t svcmpne_wide(svbool_t, svint8_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s32)))
+svbool_t svcmpne_wide(svbool_t, svint32_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpne_wide_s16)))
+svbool_t svcmpne_wide(svbool_t, svint16_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f64)))
+svbool_t svcmpuo(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f32)))
+svbool_t svcmpuo(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_n_f16)))
+svbool_t svcmpuo(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f64)))
+svbool_t svcmpuo(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f32)))
+svbool_t svcmpuo(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcmpuo_f16)))
+svbool_t svcmpuo(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_m)))
+svuint8_t svcnot_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_m)))
+svuint32_t svcnot_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_m)))
+svuint64_t svcnot_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_m)))
+svuint16_t svcnot_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_m)))
+svint8_t svcnot_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_m)))
+svint32_t svcnot_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_m)))
+svint64_t svcnot_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_m)))
+svint16_t svcnot_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_x)))
+svuint8_t svcnot_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_x)))
+svuint32_t svcnot_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_x)))
+svuint64_t svcnot_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_x)))
+svuint16_t svcnot_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_x)))
+svint8_t svcnot_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_x)))
+svint32_t svcnot_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_x)))
+svint64_t svcnot_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_x)))
+svint16_t svcnot_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u8_z)))
+svuint8_t svcnot_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u32_z)))
+svuint32_t svcnot_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u64_z)))
+svuint64_t svcnot_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_u16_z)))
+svuint16_t svcnot_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s8_z)))
+svint8_t svcnot_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s32_z)))
+svint32_t svcnot_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s64_z)))
+svint64_t svcnot_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnot_s16_z)))
+svint16_t svcnot_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_m)))
+svuint8_t svcnt_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_m)))
+svuint32_t svcnt_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_m)))
+svuint64_t svcnt_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_m)))
+svuint16_t svcnt_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_m)))
+svuint8_t svcnt_m(svuint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_m)))
+svuint64_t svcnt_m(svuint64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_m)))
+svuint32_t svcnt_m(svuint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_m)))
+svuint16_t svcnt_m(svuint16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_m)))
+svuint32_t svcnt_m(svuint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_m)))
+svuint64_t svcnt_m(svuint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_m)))
+svuint16_t svcnt_m(svuint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_x)))
+svuint8_t svcnt_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_x)))
+svuint32_t svcnt_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_x)))
+svuint64_t svcnt_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_x)))
+svuint16_t svcnt_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_x)))
+svuint8_t svcnt_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_x)))
+svuint64_t svcnt_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_x)))
+svuint32_t svcnt_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_x)))
+svuint16_t svcnt_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_x)))
+svuint32_t svcnt_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_x)))
+svuint64_t svcnt_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_x)))
+svuint16_t svcnt_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u8_z)))
+svuint8_t svcnt_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u32_z)))
+svuint32_t svcnt_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u64_z)))
+svuint64_t svcnt_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_u16_z)))
+svuint16_t svcnt_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s8_z)))
+svuint8_t svcnt_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f64_z)))
+svuint64_t svcnt_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f32_z)))
+svuint32_t svcnt_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_f16_z)))
+svuint16_t svcnt_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s32_z)))
+svuint32_t svcnt_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s64_z)))
+svuint64_t svcnt_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcnt_s16_z)))
+svuint16_t svcnt_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u8)))
+svuint8x2_t svcreate2(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u32)))
+svuint32x2_t svcreate2(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u64)))
+svuint64x2_t svcreate2(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_u16)))
+svuint16x2_t svcreate2(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s8)))
+svint8x2_t svcreate2(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f64)))
+svfloat64x2_t svcreate2(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f32)))
+svfloat32x2_t svcreate2(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_f16)))
+svfloat16x2_t svcreate2(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s32)))
+svint32x2_t svcreate2(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s64)))
+svint64x2_t svcreate2(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate2_s16)))
+svint16x2_t svcreate2(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u8)))
+svuint8x3_t svcreate3(svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u32)))
+svuint32x3_t svcreate3(svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u64)))
+svuint64x3_t svcreate3(svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_u16)))
+svuint16x3_t svcreate3(svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s8)))
+svint8x3_t svcreate3(svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f64)))
+svfloat64x3_t svcreate3(svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f32)))
+svfloat32x3_t svcreate3(svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_f16)))
+svfloat16x3_t svcreate3(svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s32)))
+svint32x3_t svcreate3(svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s64)))
+svint64x3_t svcreate3(svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate3_s16)))
+svint16x3_t svcreate3(svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u8)))
+svuint8x4_t svcreate4(svuint8_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u32)))
+svuint32x4_t svcreate4(svuint32_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u64)))
+svuint64x4_t svcreate4(svuint64_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_u16)))
+svuint16x4_t svcreate4(svuint16_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s8)))
+svint8x4_t svcreate4(svint8_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f64)))
+svfloat64x4_t svcreate4(svfloat64_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f32)))
+svfloat32x4_t svcreate4(svfloat32_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_f16)))
+svfloat16x4_t svcreate4(svfloat16_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s32)))
+svint32x4_t svcreate4(svint32_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s64)))
+svint64x4_t svcreate4(svint64_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcreate4_s16)))
+svint16x4_t svcreate4(svint16_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f32_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_f64_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s16_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s32_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_s64_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u16_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u32_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_m)))
+svfloat16_t svcvt_f16_m(svfloat16_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_x)))
+svfloat16_t svcvt_f16_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f16_u64_z)))
+svfloat16_t svcvt_f16_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f16_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_f64_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s32_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_s64_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u32_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_m)))
+svfloat32_t svcvt_f32_m(svfloat32_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_x)))
+svfloat32_t svcvt_f32_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f32_u64_z)))
+svfloat32_t svcvt_f32_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f16_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_f32_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s32_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_s64_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u32_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_m)))
+svfloat64_t svcvt_f64_m(svfloat64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_x)))
+svfloat64_t svcvt_f64_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_f64_u64_z)))
+svfloat64_t svcvt_f64_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_m)))
+svint16_t svcvt_s16_m(svint16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_x)))
+svint16_t svcvt_s16_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s16_f16_z)))
+svint16_t svcvt_s16_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_m)))
+svint32_t svcvt_s32_m(svint32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_x)))
+svint32_t svcvt_s32_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f16_z)))
+svint32_t svcvt_s32_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_m)))
+svint32_t svcvt_s32_m(svint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_x)))
+svint32_t svcvt_s32_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f32_z)))
+svint32_t svcvt_s32_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_m)))
+svint32_t svcvt_s32_m(svint32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_x)))
+svint32_t svcvt_s32_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s32_f64_z)))
+svint32_t svcvt_s32_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_m)))
+svint64_t svcvt_s64_m(svint64_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_x)))
+svint64_t svcvt_s64_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f16_z)))
+svint64_t svcvt_s64_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_m)))
+svint64_t svcvt_s64_m(svint64_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_x)))
+svint64_t svcvt_s64_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f32_z)))
+svint64_t svcvt_s64_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_m)))
+svint64_t svcvt_s64_m(svint64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_x)))
+svint64_t svcvt_s64_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_s64_f64_z)))
+svint64_t svcvt_s64_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_m)))
+svuint16_t svcvt_u16_m(svuint16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_x)))
+svuint16_t svcvt_u16_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u16_f16_z)))
+svuint16_t svcvt_u16_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_m)))
+svuint32_t svcvt_u32_m(svuint32_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_x)))
+svuint32_t svcvt_u32_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f16_z)))
+svuint32_t svcvt_u32_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_m)))
+svuint32_t svcvt_u32_m(svuint32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_x)))
+svuint32_t svcvt_u32_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f32_z)))
+svuint32_t svcvt_u32_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_m)))
+svuint32_t svcvt_u32_m(svuint32_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_x)))
+svuint32_t svcvt_u32_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u32_f64_z)))
+svuint32_t svcvt_u32_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_m)))
+svuint64_t svcvt_u64_m(svuint64_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_x)))
+svuint64_t svcvt_u64_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f16_z)))
+svuint64_t svcvt_u64_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_m)))
+svuint64_t svcvt_u64_m(svuint64_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_x)))
+svuint64_t svcvt_u64_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f32_z)))
+svuint64_t svcvt_u64_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_m)))
+svuint64_t svcvt_u64_m(svuint64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_x)))
+svuint64_t svcvt_u64_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svcvt_u64_f64_z)))
+svuint64_t svcvt_u64_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_m)))
+svfloat64_t svdiv_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_m)))
+svfloat32_t svdiv_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_m)))
+svfloat16_t svdiv_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_x)))
+svfloat64_t svdiv_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_x)))
+svfloat32_t svdiv_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_x)))
+svfloat16_t svdiv_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f64_z)))
+svfloat64_t svdiv_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f32_z)))
+svfloat32_t svdiv_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_f16_z)))
+svfloat16_t svdiv_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_m)))
+svint32_t svdiv_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_m)))
+svint64_t svdiv_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_x)))
+svint32_t svdiv_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_x)))
+svint64_t svdiv_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s32_z)))
+svint32_t svdiv_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_s64_z)))
+svint64_t svdiv_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_m)))
+svuint32_t svdiv_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_m)))
+svuint64_t svdiv_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_x)))
+svuint32_t svdiv_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_x)))
+svuint64_t svdiv_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u32_z)))
+svuint32_t svdiv_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_n_u64_z)))
+svuint64_t svdiv_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_m)))
+svfloat64_t svdiv_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_m)))
+svfloat32_t svdiv_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_m)))
+svfloat16_t svdiv_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_x)))
+svfloat64_t svdiv_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_x)))
+svfloat32_t svdiv_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_x)))
+svfloat16_t svdiv_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f64_z)))
+svfloat64_t svdiv_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f32_z)))
+svfloat32_t svdiv_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_f16_z)))
+svfloat16_t svdiv_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_m)))
+svint32_t svdiv_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_m)))
+svint64_t svdiv_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_x)))
+svint32_t svdiv_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_x)))
+svint64_t svdiv_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s32_z)))
+svint32_t svdiv_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_s64_z)))
+svint64_t svdiv_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_m)))
+svuint32_t svdiv_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_m)))
+svuint64_t svdiv_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_x)))
+svuint32_t svdiv_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_x)))
+svuint64_t svdiv_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u32_z)))
+svuint32_t svdiv_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdiv_u64_z)))
+svuint64_t svdiv_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_m)))
+svfloat64_t svdivr_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_m)))
+svfloat32_t svdivr_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_m)))
+svfloat16_t svdivr_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_x)))
+svfloat64_t svdivr_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_x)))
+svfloat32_t svdivr_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_x)))
+svfloat16_t svdivr_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f64_z)))
+svfloat64_t svdivr_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f32_z)))
+svfloat32_t svdivr_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_f16_z)))
+svfloat16_t svdivr_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_m)))
+svint32_t svdivr_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_m)))
+svint64_t svdivr_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_x)))
+svint32_t svdivr_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_x)))
+svint64_t svdivr_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s32_z)))
+svint32_t svdivr_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_s64_z)))
+svint64_t svdivr_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_m)))
+svuint32_t svdivr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_m)))
+svuint64_t svdivr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_x)))
+svuint32_t svdivr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_x)))
+svuint64_t svdivr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u32_z)))
+svuint32_t svdivr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_n_u64_z)))
+svuint64_t svdivr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_m)))
+svfloat64_t svdivr_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_m)))
+svfloat32_t svdivr_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_m)))
+svfloat16_t svdivr_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_x)))
+svfloat64_t svdivr_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_x)))
+svfloat32_t svdivr_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_x)))
+svfloat16_t svdivr_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f64_z)))
+svfloat64_t svdivr_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f32_z)))
+svfloat32_t svdivr_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_f16_z)))
+svfloat16_t svdivr_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_m)))
+svint32_t svdivr_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_m)))
+svint64_t svdivr_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_x)))
+svint32_t svdivr_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_x)))
+svint64_t svdivr_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s32_z)))
+svint32_t svdivr_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_s64_z)))
+svint64_t svdivr_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_m)))
+svuint32_t svdivr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_m)))
+svuint64_t svdivr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_x)))
+svuint32_t svdivr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_x)))
+svuint64_t svdivr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u32_z)))
+svuint32_t svdivr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdivr_u64_z)))
+svuint64_t svdivr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s32)))
+svint32_t svdot(svint32_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_s64)))
+svint64_t svdot(svint64_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u32)))
+svuint32_t svdot(svuint32_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_n_u64)))
+svuint64_t svdot(svuint64_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s32)))
+svint32_t svdot(svint32_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_s64)))
+svint64_t svdot(svint64_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u32)))
+svuint32_t svdot(svuint32_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_u64)))
+svuint64_t svdot(svuint64_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s32)))
+svint32_t svdot_lane(svint32_t, svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_s64)))
+svint64_t svdot_lane(svint64_t, svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u32)))
+svuint32_t svdot_lane(svuint32_t, svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdot_lane_u64)))
+svuint64_t svdot_lane(svuint64_t, svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8)))
+svuint8_t svdup_u8(uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32)))
+svuint32_t svdup_u32(uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64)))
+svuint64_t svdup_u64(uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16)))
+svuint16_t svdup_u16(uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8)))
+svint8_t svdup_s8(int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64)))
+svfloat64_t svdup_f64(float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32)))
+svfloat32_t svdup_f32(float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16)))
+svfloat16_t svdup_f16(float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32)))
+svint32_t svdup_s32(int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64)))
+svint64_t svdup_s64(int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16)))
+svint16_t svdup_s16(int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_m)))
+svuint8_t svdup_u8_m(svuint8_t, svbool_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_m)))
+svuint32_t svdup_u32_m(svuint32_t, svbool_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_m)))
+svuint64_t svdup_u64_m(svuint64_t, svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_m)))
+svuint16_t svdup_u16_m(svuint16_t, svbool_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_m)))
+svint8_t svdup_s8_m(svint8_t, svbool_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_m)))
+svfloat64_t svdup_f64_m(svfloat64_t, svbool_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_m)))
+svfloat32_t svdup_f32_m(svfloat32_t, svbool_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_m)))
+svfloat16_t svdup_f16_m(svfloat16_t, svbool_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_m)))
+svint32_t svdup_s32_m(svint32_t, svbool_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_m)))
+svint64_t svdup_s64_m(svint64_t, svbool_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_m)))
+svint16_t svdup_s16_m(svint16_t, svbool_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b8)))
+svbool_t svdup_b8(bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b32)))
+svbool_t svdup_b32(bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b64)))
+svbool_t svdup_b64(bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_b16)))
+svbool_t svdup_b16(bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_x)))
+svuint8_t svdup_u8_x(svbool_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_x)))
+svuint32_t svdup_u32_x(svbool_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_x)))
+svuint64_t svdup_u64_x(svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_x)))
+svuint16_t svdup_u16_x(svbool_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_x)))
+svint8_t svdup_s8_x(svbool_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_x)))
+svfloat64_t svdup_f64_x(svbool_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_x)))
+svfloat32_t svdup_f32_x(svbool_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_x)))
+svfloat16_t svdup_f16_x(svbool_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_x)))
+svint32_t svdup_s32_x(svbool_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_x)))
+svint64_t svdup_s64_x(svbool_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_x)))
+svint16_t svdup_s16_x(svbool_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u8_z)))
+svuint8_t svdup_u8_z(svbool_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u32_z)))
+svuint32_t svdup_u32_z(svbool_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u64_z)))
+svuint64_t svdup_u64_z(svbool_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_u16_z)))
+svuint16_t svdup_u16_z(svbool_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s8_z)))
+svint8_t svdup_s8_z(svbool_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f64_z)))
+svfloat64_t svdup_f64_z(svbool_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f32_z)))
+svfloat32_t svdup_f32_z(svbool_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_f16_z)))
+svfloat16_t svdup_f16_z(svbool_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s32_z)))
+svint32_t svdup_s32_z(svbool_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s64_z)))
+svint64_t svdup_s64_z(svbool_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_n_s16_z)))
+svint16_t svdup_s16_z(svbool_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u8)))
+svuint8_t svdup_lane(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u32)))
+svuint32_t svdup_lane(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u64)))
+svuint64_t svdup_lane(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_u16)))
+svuint16_t svdup_lane(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s8)))
+svint8_t svdup_lane(svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f64)))
+svfloat64_t svdup_lane(svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f32)))
+svfloat32_t svdup_lane(svfloat32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_f16)))
+svfloat16_t svdup_lane(svfloat16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s32)))
+svint32_t svdup_lane(svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s64)))
+svint64_t svdup_lane(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdup_lane_s16)))
+svint16_t svdup_lane(svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u8)))
+svuint8_t svdupq_u8(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s8)))
+svint8_t svdupq_s8(int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u16)))
+svuint16_t svdupq_u16(uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f16)))
+svfloat16_t svdupq_f16(float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s16)))
+svint16_t svdupq_s16(int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u32)))
+svuint32_t svdupq_u32(uint32_t, uint32_t, uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f32)))
+svfloat32_t svdupq_f32(float32_t, float32_t, float32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s32)))
+svint32_t svdupq_s32(int32_t, int32_t, int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_u64)))
+svuint64_t svdupq_u64(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_f64)))
+svfloat64_t svdupq_f64(float64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_s64)))
+svint64_t svdupq_s64(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b8)))
+svbool_t svdupq_b8(bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool, bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b16)))
+svbool_t svdupq_b16(bool, bool, bool, bool, bool, bool, bool, bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b32)))
+svbool_t svdupq_b32(bool, bool, bool, bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_n_b64)))
+svbool_t svdupq_b64(bool, bool);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u8)))
+svuint8_t svdupq_lane(svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u32)))
+svuint32_t svdupq_lane(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u64)))
+svuint64_t svdupq_lane(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_u16)))
+svuint16_t svdupq_lane(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s8)))
+svint8_t svdupq_lane(svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f64)))
+svfloat64_t svdupq_lane(svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f32)))
+svfloat32_t svdupq_lane(svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_f16)))
+svfloat16_t svdupq_lane(svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s32)))
+svint32_t svdupq_lane(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s64)))
+svint64_t svdupq_lane(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svdupq_lane_s16)))
+svint16_t svdupq_lane(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_b_z)))
+svbool_t sveor_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_m)))
+svuint8_t sveor_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_m)))
+svuint32_t sveor_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_m)))
+svuint64_t sveor_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_m)))
+svuint16_t sveor_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_m)))
+svint8_t sveor_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_m)))
+svint32_t sveor_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_m)))
+svint64_t sveor_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_m)))
+svint16_t sveor_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_x)))
+svuint8_t sveor_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_x)))
+svuint32_t sveor_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_x)))
+svuint64_t sveor_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_x)))
+svuint16_t sveor_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_x)))
+svint8_t sveor_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_x)))
+svint32_t sveor_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_x)))
+svint64_t sveor_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_x)))
+svint16_t sveor_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u8_z)))
+svuint8_t sveor_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u32_z)))
+svuint32_t sveor_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u64_z)))
+svuint64_t sveor_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_u16_z)))
+svuint16_t sveor_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s8_z)))
+svint8_t sveor_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s32_z)))
+svint32_t sveor_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s64_z)))
+svint64_t sveor_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_n_s16_z)))
+svint16_t sveor_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_m)))
+svuint8_t sveor_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_m)))
+svuint32_t sveor_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_m)))
+svuint64_t sveor_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_m)))
+svuint16_t sveor_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_m)))
+svint8_t sveor_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_m)))
+svint32_t sveor_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_m)))
+svint64_t sveor_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_m)))
+svint16_t sveor_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_x)))
+svuint8_t sveor_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_x)))
+svuint32_t sveor_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_x)))
+svuint64_t sveor_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_x)))
+svuint16_t sveor_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_x)))
+svint8_t sveor_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_x)))
+svint32_t sveor_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_x)))
+svint64_t sveor_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_x)))
+svint16_t sveor_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u8_z)))
+svuint8_t sveor_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u32_z)))
+svuint32_t sveor_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u64_z)))
+svuint64_t sveor_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_u16_z)))
+svuint16_t sveor_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s8_z)))
+svint8_t sveor_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s32_z)))
+svint32_t sveor_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s64_z)))
+svint64_t sveor_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveor_s16_z)))
+svint16_t sveor_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u8)))
+uint8_t sveorv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u32)))
+uint32_t sveorv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u64)))
+uint64_t sveorv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_u16)))
+uint16_t sveorv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s8)))
+int8_t sveorv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s32)))
+int32_t sveorv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s64)))
+int64_t sveorv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_sveorv_s16)))
+int16_t sveorv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u8)))
+svuint8_t svext(svuint8_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u32)))
+svuint32_t svext(svuint32_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u64)))
+svuint64_t svext(svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_u16)))
+svuint16_t svext(svuint16_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s8)))
+svint8_t svext(svint8_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f64)))
+svfloat64_t svext(svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f32)))
+svfloat32_t svext(svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_f16)))
+svfloat16_t svext(svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s32)))
+svint32_t svext(svint32_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s64)))
+svint64_t svext(svint64_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svext_s16)))
+svint16_t svext(svint16_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_m)))
+svint32_t svextb_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_m)))
+svint64_t svextb_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_m)))
+svint16_t svextb_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_x)))
+svint32_t svextb_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_x)))
+svint64_t svextb_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_x)))
+svint16_t svextb_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s32_z)))
+svint32_t svextb_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s64_z)))
+svint64_t svextb_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_s16_z)))
+svint16_t svextb_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_m)))
+svuint32_t svextb_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_m)))
+svuint64_t svextb_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_m)))
+svuint16_t svextb_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_x)))
+svuint32_t svextb_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_x)))
+svuint64_t svextb_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_x)))
+svuint16_t svextb_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u32_z)))
+svuint32_t svextb_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u64_z)))
+svuint64_t svextb_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextb_u16_z)))
+svuint16_t svextb_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_m)))
+svint32_t svexth_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_m)))
+svint64_t svexth_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_x)))
+svint32_t svexth_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_x)))
+svint64_t svexth_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s32_z)))
+svint32_t svexth_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_s64_z)))
+svint64_t svexth_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_m)))
+svuint32_t svexth_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_m)))
+svuint64_t svexth_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_x)))
+svuint32_t svexth_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_x)))
+svuint64_t svexth_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u32_z)))
+svuint32_t svexth_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svexth_u64_z)))
+svuint64_t svexth_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_m)))
+svint64_t svextw_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_x)))
+svint64_t svextw_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_s64_z)))
+svint64_t svextw_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_m)))
+svuint64_t svextw_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_x)))
+svuint64_t svextw_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svextw_u64_z)))
+svuint64_t svextw_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u8)))
+svuint8_t svget2(svuint8x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u32)))
+svuint32_t svget2(svuint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u64)))
+svuint64_t svget2(svuint64x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_u16)))
+svuint16_t svget2(svuint16x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s8)))
+svint8_t svget2(svint8x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f64)))
+svfloat64_t svget2(svfloat64x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f32)))
+svfloat32_t svget2(svfloat32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_f16)))
+svfloat16_t svget2(svfloat16x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s32)))
+svint32_t svget2(svint32x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s64)))
+svint64_t svget2(svint64x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget2_s16)))
+svint16_t svget2(svint16x2_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u8)))
+svuint8_t svget3(svuint8x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u32)))
+svuint32_t svget3(svuint32x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u64)))
+svuint64_t svget3(svuint64x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_u16)))
+svuint16_t svget3(svuint16x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s8)))
+svint8_t svget3(svint8x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f64)))
+svfloat64_t svget3(svfloat64x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f32)))
+svfloat32_t svget3(svfloat32x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_f16)))
+svfloat16_t svget3(svfloat16x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s32)))
+svint32_t svget3(svint32x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s64)))
+svint64_t svget3(svint64x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget3_s16)))
+svint16_t svget3(svint16x3_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u8)))
+svuint8_t svget4(svuint8x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u32)))
+svuint32_t svget4(svuint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u64)))
+svuint64_t svget4(svuint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_u16)))
+svuint16_t svget4(svuint16x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s8)))
+svint8_t svget4(svint8x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f64)))
+svfloat64_t svget4(svfloat64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f32)))
+svfloat32_t svget4(svfloat32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_f16)))
+svfloat16_t svget4(svfloat16x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s32)))
+svint32_t svget4(svint32x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s64)))
+svint64_t svget4(svint64x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svget4_s16)))
+svint16_t svget4(svint16x4_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u8)))
+svuint8_t svinsr(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u32)))
+svuint32_t svinsr(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u64)))
+svuint64_t svinsr(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_u16)))
+svuint16_t svinsr(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s8)))
+svint8_t svinsr(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f64)))
+svfloat64_t svinsr(svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f32)))
+svfloat32_t svinsr(svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_f16)))
+svfloat16_t svinsr(svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s32)))
+svint32_t svinsr(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s64)))
+svint64_t svinsr(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svinsr_n_s16)))
+svint16_t svinsr(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u8)))
+uint8_t svlasta(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u32)))
+uint32_t svlasta(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u64)))
+uint64_t svlasta(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_u16)))
+uint16_t svlasta(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s8)))
+int8_t svlasta(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f64)))
+float64_t svlasta(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f32)))
+float32_t svlasta(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_f16)))
+float16_t svlasta(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s32)))
+int32_t svlasta(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s64)))
+int64_t svlasta(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlasta_s16)))
+int16_t svlasta(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u8)))
+uint8_t svlastb(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u32)))
+uint32_t svlastb(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u64)))
+uint64_t svlastb(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_u16)))
+uint16_t svlastb(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s8)))
+int8_t svlastb(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f64)))
+float64_t svlastb(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f32)))
+float32_t svlastb(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_f16)))
+float16_t svlastb(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s32)))
+int32_t svlastb(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s64)))
+int64_t svlastb(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlastb_s16)))
+int16_t svlastb(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u8)))
+svuint8_t svld1(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u32)))
+svuint32_t svld1(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u64)))
+svuint64_t svld1(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_u16)))
+svuint16_t svld1(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s8)))
+svint8_t svld1(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f64)))
+svfloat64_t svld1(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f32)))
+svfloat32_t svld1(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_f16)))
+svfloat16_t svld1(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s32)))
+svint32_t svld1(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s64)))
+svint64_t svld1(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_s16)))
+svint16_t svld1(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u8)))
+svuint8_t svld1_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u32)))
+svuint32_t svld1_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u64)))
+svuint64_t svld1_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_u16)))
+svuint16_t svld1_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s8)))
+svint8_t svld1_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f64)))
+svfloat64_t svld1_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f32)))
+svfloat32_t svld1_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_f16)))
+svfloat16_t svld1_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s32)))
+svint32_t svld1_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s64)))
+svint64_t svld1_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1_vnum_s16)))
+svint16_t svld1_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u8)))
+svuint8_t svld1rq(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u32)))
+svuint32_t svld1rq(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u64)))
+svuint64_t svld1rq(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_u16)))
+svuint16_t svld1rq(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s8)))
+svint8_t svld1rq(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f64)))
+svfloat64_t svld1rq(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f32)))
+svfloat32_t svld1rq(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_f16)))
+svfloat16_t svld1rq(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s32)))
+svint32_t svld1rq(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s64)))
+svint64_t svld1rq(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld1rq_s16)))
+svint16_t svld1rq(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u8)))
+svuint8x2_t svld2(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u32)))
+svuint32x2_t svld2(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u64)))
+svuint64x2_t svld2(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_u16)))
+svuint16x2_t svld2(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s8)))
+svint8x2_t svld2(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f64)))
+svfloat64x2_t svld2(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f32)))
+svfloat32x2_t svld2(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_f16)))
+svfloat16x2_t svld2(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s32)))
+svint32x2_t svld2(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s64)))
+svint64x2_t svld2(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_s16)))
+svint16x2_t svld2(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u8)))
+svuint8x2_t svld2_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u32)))
+svuint32x2_t svld2_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u64)))
+svuint64x2_t svld2_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_u16)))
+svuint16x2_t svld2_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s8)))
+svint8x2_t svld2_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f64)))
+svfloat64x2_t svld2_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f32)))
+svfloat32x2_t svld2_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_f16)))
+svfloat16x2_t svld2_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s32)))
+svint32x2_t svld2_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s64)))
+svint64x2_t svld2_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld2_vnum_s16)))
+svint16x2_t svld2_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u8)))
+svuint8x3_t svld3(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u32)))
+svuint32x3_t svld3(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u64)))
+svuint64x3_t svld3(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_u16)))
+svuint16x3_t svld3(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s8)))
+svint8x3_t svld3(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f64)))
+svfloat64x3_t svld3(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f32)))
+svfloat32x3_t svld3(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_f16)))
+svfloat16x3_t svld3(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s32)))
+svint32x3_t svld3(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s64)))
+svint64x3_t svld3(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_s16)))
+svint16x3_t svld3(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u8)))
+svuint8x3_t svld3_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u32)))
+svuint32x3_t svld3_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u64)))
+svuint64x3_t svld3_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_u16)))
+svuint16x3_t svld3_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s8)))
+svint8x3_t svld3_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f64)))
+svfloat64x3_t svld3_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f32)))
+svfloat32x3_t svld3_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_f16)))
+svfloat16x3_t svld3_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s32)))
+svint32x3_t svld3_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s64)))
+svint64x3_t svld3_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld3_vnum_s16)))
+svint16x3_t svld3_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u8)))
+svuint8x4_t svld4(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u32)))
+svuint32x4_t svld4(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u64)))
+svuint64x4_t svld4(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_u16)))
+svuint16x4_t svld4(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s8)))
+svint8x4_t svld4(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f64)))
+svfloat64x4_t svld4(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f32)))
+svfloat32x4_t svld4(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_f16)))
+svfloat16x4_t svld4(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s32)))
+svint32x4_t svld4(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s64)))
+svint64x4_t svld4(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_s16)))
+svint16x4_t svld4(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u8)))
+svuint8x4_t svld4_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u32)))
+svuint32x4_t svld4_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u64)))
+svuint64x4_t svld4_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_u16)))
+svuint16x4_t svld4_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s8)))
+svint8x4_t svld4_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f64)))
+svfloat64x4_t svld4_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f32)))
+svfloat32x4_t svld4_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_f16)))
+svfloat16x4_t svld4_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s32)))
+svint32x4_t svld4_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s64)))
+svint64x4_t svld4_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svld4_vnum_s16)))
+svint16x4_t svld4_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u8)))
+svuint8_t svldnt1(svbool_t, uint8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u32)))
+svuint32_t svldnt1(svbool_t, uint32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u64)))
+svuint64_t svldnt1(svbool_t, uint64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_u16)))
+svuint16_t svldnt1(svbool_t, uint16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s8)))
+svint8_t svldnt1(svbool_t, int8_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f64)))
+svfloat64_t svldnt1(svbool_t, float64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f32)))
+svfloat32_t svldnt1(svbool_t, float32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_f16)))
+svfloat16_t svldnt1(svbool_t, float16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s32)))
+svint32_t svldnt1(svbool_t, int32_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s64)))
+svint64_t svldnt1(svbool_t, int64_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_s16)))
+svint16_t svldnt1(svbool_t, int16_t const *);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u8)))
+svuint8_t svldnt1_vnum(svbool_t, uint8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u32)))
+svuint32_t svldnt1_vnum(svbool_t, uint32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u64)))
+svuint64_t svldnt1_vnum(svbool_t, uint64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_u16)))
+svuint16_t svldnt1_vnum(svbool_t, uint16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s8)))
+svint8_t svldnt1_vnum(svbool_t, int8_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f64)))
+svfloat64_t svldnt1_vnum(svbool_t, float64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f32)))
+svfloat32_t svldnt1_vnum(svbool_t, float32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_f16)))
+svfloat16_t svldnt1_vnum(svbool_t, float16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s32)))
+svint32_t svldnt1_vnum(svbool_t, int32_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s64)))
+svint64_t svldnt1_vnum(svbool_t, int64_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svldnt1_vnum_s16)))
+svint16_t svldnt1_vnum(svbool_t, int16_t const *, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u8)))
+uint64_t svlen(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u32)))
+uint64_t svlen(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u64)))
+uint64_t svlen(svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_u16)))
+uint64_t svlen(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s8)))
+uint64_t svlen(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f64)))
+uint64_t svlen(svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f32)))
+uint64_t svlen(svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_f16)))
+uint64_t svlen(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s32)))
+uint64_t svlen(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s64)))
+uint64_t svlen(svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlen_s16)))
+uint64_t svlen(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_m)))
+svuint8_t svlsl_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_m)))
+svuint32_t svlsl_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_m)))
+svuint64_t svlsl_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_m)))
+svuint16_t svlsl_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_m)))
+svint8_t svlsl_m(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_m)))
+svint32_t svlsl_m(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_m)))
+svint64_t svlsl_m(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_m)))
+svint16_t svlsl_m(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_x)))
+svuint8_t svlsl_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_x)))
+svuint32_t svlsl_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_x)))
+svuint64_t svlsl_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_x)))
+svuint16_t svlsl_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_x)))
+svint8_t svlsl_x(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_x)))
+svint32_t svlsl_x(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_x)))
+svint64_t svlsl_x(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_x)))
+svint16_t svlsl_x(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u8_z)))
+svuint8_t svlsl_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u32_z)))
+svuint32_t svlsl_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u64_z)))
+svuint64_t svlsl_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_u16_z)))
+svuint16_t svlsl_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s8_z)))
+svint8_t svlsl_z(svbool_t, svint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s32_z)))
+svint32_t svlsl_z(svbool_t, svint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s64_z)))
+svint64_t svlsl_z(svbool_t, svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_n_s16_z)))
+svint16_t svlsl_z(svbool_t, svint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_m)))
+svuint8_t svlsl_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_m)))
+svuint32_t svlsl_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_m)))
+svuint64_t svlsl_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_m)))
+svuint16_t svlsl_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_m)))
+svint8_t svlsl_m(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_m)))
+svint32_t svlsl_m(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_m)))
+svint64_t svlsl_m(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_m)))
+svint16_t svlsl_m(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_x)))
+svuint8_t svlsl_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_x)))
+svuint32_t svlsl_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_x)))
+svuint64_t svlsl_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_x)))
+svuint16_t svlsl_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_x)))
+svint8_t svlsl_x(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_x)))
+svint32_t svlsl_x(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_x)))
+svint64_t svlsl_x(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_x)))
+svint16_t svlsl_x(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u8_z)))
+svuint8_t svlsl_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u32_z)))
+svuint32_t svlsl_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u64_z)))
+svuint64_t svlsl_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_u16_z)))
+svuint16_t svlsl_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s8_z)))
+svint8_t svlsl_z(svbool_t, svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s32_z)))
+svint32_t svlsl_z(svbool_t, svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s64_z)))
+svint64_t svlsl_z(svbool_t, svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_s16_z)))
+svint16_t svlsl_z(svbool_t, svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_m)))
+svuint8_t svlsl_wide_m(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_m)))
+svuint32_t svlsl_wide_m(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_m)))
+svuint16_t svlsl_wide_m(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_m)))
+svint8_t svlsl_wide_m(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_m)))
+svint32_t svlsl_wide_m(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_m)))
+svint16_t svlsl_wide_m(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_x)))
+svuint8_t svlsl_wide_x(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_x)))
+svuint32_t svlsl_wide_x(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_x)))
+svuint16_t svlsl_wide_x(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_x)))
+svint8_t svlsl_wide_x(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_x)))
+svint32_t svlsl_wide_x(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_x)))
+svint16_t svlsl_wide_x(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u8_z)))
+svuint8_t svlsl_wide_z(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u32_z)))
+svuint32_t svlsl_wide_z(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_u16_z)))
+svuint16_t svlsl_wide_z(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s8_z)))
+svint8_t svlsl_wide_z(svbool_t, svint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s32_z)))
+svint32_t svlsl_wide_z(svbool_t, svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_n_s16_z)))
+svint16_t svlsl_wide_z(svbool_t, svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_m)))
+svuint8_t svlsl_wide_m(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_m)))
+svuint32_t svlsl_wide_m(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_m)))
+svuint16_t svlsl_wide_m(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_m)))
+svint8_t svlsl_wide_m(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_m)))
+svint32_t svlsl_wide_m(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_m)))
+svint16_t svlsl_wide_m(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_x)))
+svuint8_t svlsl_wide_x(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_x)))
+svuint32_t svlsl_wide_x(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_x)))
+svuint16_t svlsl_wide_x(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_x)))
+svint8_t svlsl_wide_x(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_x)))
+svint32_t svlsl_wide_x(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_x)))
+svint16_t svlsl_wide_x(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u8_z)))
+svuint8_t svlsl_wide_z(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u32_z)))
+svuint32_t svlsl_wide_z(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_u16_z)))
+svuint16_t svlsl_wide_z(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s8_z)))
+svint8_t svlsl_wide_z(svbool_t, svint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s32_z)))
+svint32_t svlsl_wide_z(svbool_t, svint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsl_wide_s16_z)))
+svint16_t svlsl_wide_z(svbool_t, svint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_m)))
+svuint8_t svlsr_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_m)))
+svuint32_t svlsr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_m)))
+svuint64_t svlsr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_m)))
+svuint16_t svlsr_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_x)))
+svuint8_t svlsr_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_x)))
+svuint32_t svlsr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_x)))
+svuint64_t svlsr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_x)))
+svuint16_t svlsr_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u8_z)))
+svuint8_t svlsr_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u32_z)))
+svuint32_t svlsr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u64_z)))
+svuint64_t svlsr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_n_u16_z)))
+svuint16_t svlsr_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_m)))
+svuint8_t svlsr_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_m)))
+svuint32_t svlsr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_m)))
+svuint64_t svlsr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_m)))
+svuint16_t svlsr_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_x)))
+svuint8_t svlsr_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_x)))
+svuint32_t svlsr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_x)))
+svuint64_t svlsr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_x)))
+svuint16_t svlsr_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u8_z)))
+svuint8_t svlsr_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u32_z)))
+svuint32_t svlsr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u64_z)))
+svuint64_t svlsr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_u16_z)))
+svuint16_t svlsr_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_m)))
+svuint8_t svlsr_wide_m(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_m)))
+svuint32_t svlsr_wide_m(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_m)))
+svuint16_t svlsr_wide_m(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_x)))
+svuint8_t svlsr_wide_x(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_x)))
+svuint32_t svlsr_wide_x(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_x)))
+svuint16_t svlsr_wide_x(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u8_z)))
+svuint8_t svlsr_wide_z(svbool_t, svuint8_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u32_z)))
+svuint32_t svlsr_wide_z(svbool_t, svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_n_u16_z)))
+svuint16_t svlsr_wide_z(svbool_t, svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_m)))
+svuint8_t svlsr_wide_m(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_m)))
+svuint32_t svlsr_wide_m(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_m)))
+svuint16_t svlsr_wide_m(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_x)))
+svuint8_t svlsr_wide_x(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_x)))
+svuint32_t svlsr_wide_x(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_x)))
+svuint16_t svlsr_wide_x(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u8_z)))
+svuint8_t svlsr_wide_z(svbool_t, svuint8_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u32_z)))
+svuint32_t svlsr_wide_z(svbool_t, svuint32_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svlsr_wide_u16_z)))
+svuint16_t svlsr_wide_z(svbool_t, svuint16_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_m)))
+svfloat64_t svmad_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_m)))
+svfloat32_t svmad_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_m)))
+svfloat16_t svmad_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_x)))
+svfloat64_t svmad_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_x)))
+svfloat32_t svmad_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_x)))
+svfloat16_t svmad_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f64_z)))
+svfloat64_t svmad_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f32_z)))
+svfloat32_t svmad_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_f16_z)))
+svfloat16_t svmad_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_m)))
+svuint8_t svmad_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_m)))
+svuint32_t svmad_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_m)))
+svuint64_t svmad_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_m)))
+svuint16_t svmad_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_m)))
+svint8_t svmad_m(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_m)))
+svint32_t svmad_m(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_m)))
+svint64_t svmad_m(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_m)))
+svint16_t svmad_m(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_x)))
+svuint8_t svmad_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_x)))
+svuint32_t svmad_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_x)))
+svuint64_t svmad_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_x)))
+svuint16_t svmad_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_x)))
+svint8_t svmad_x(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_x)))
+svint32_t svmad_x(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_x)))
+svint64_t svmad_x(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_x)))
+svint16_t svmad_x(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u8_z)))
+svuint8_t svmad_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u32_z)))
+svuint32_t svmad_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u64_z)))
+svuint64_t svmad_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_u16_z)))
+svuint16_t svmad_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s8_z)))
+svint8_t svmad_z(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s32_z)))
+svint32_t svmad_z(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s64_z)))
+svint64_t svmad_z(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_n_s16_z)))
+svint16_t svmad_z(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_m)))
+svfloat64_t svmad_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_m)))
+svfloat32_t svmad_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_m)))
+svfloat16_t svmad_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_x)))
+svfloat64_t svmad_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_x)))
+svfloat32_t svmad_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_x)))
+svfloat16_t svmad_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f64_z)))
+svfloat64_t svmad_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f32_z)))
+svfloat32_t svmad_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_f16_z)))
+svfloat16_t svmad_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_m)))
+svuint8_t svmad_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_m)))
+svuint32_t svmad_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_m)))
+svuint64_t svmad_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_m)))
+svuint16_t svmad_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_m)))
+svint8_t svmad_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_m)))
+svint32_t svmad_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_m)))
+svint64_t svmad_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_m)))
+svint16_t svmad_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_x)))
+svuint8_t svmad_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_x)))
+svuint32_t svmad_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_x)))
+svuint64_t svmad_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_x)))
+svuint16_t svmad_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_x)))
+svint8_t svmad_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_x)))
+svint32_t svmad_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_x)))
+svint64_t svmad_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_x)))
+svint16_t svmad_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u8_z)))
+svuint8_t svmad_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u32_z)))
+svuint32_t svmad_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u64_z)))
+svuint64_t svmad_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_u16_z)))
+svuint16_t svmad_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s8_z)))
+svint8_t svmad_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s32_z)))
+svint32_t svmad_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s64_z)))
+svint64_t svmad_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmad_s16_z)))
+svint16_t svmad_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_m)))
+svfloat64_t svmax_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_m)))
+svfloat32_t svmax_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_m)))
+svfloat16_t svmax_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_x)))
+svfloat64_t svmax_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_x)))
+svfloat32_t svmax_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_x)))
+svfloat16_t svmax_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f64_z)))
+svfloat64_t svmax_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f32_z)))
+svfloat32_t svmax_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_f16_z)))
+svfloat16_t svmax_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_m)))
+svint8_t svmax_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_m)))
+svint32_t svmax_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_m)))
+svint64_t svmax_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_m)))
+svint16_t svmax_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_x)))
+svint8_t svmax_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_x)))
+svint32_t svmax_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_x)))
+svint64_t svmax_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_x)))
+svint16_t svmax_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s8_z)))
+svint8_t svmax_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s32_z)))
+svint32_t svmax_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s64_z)))
+svint64_t svmax_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_s16_z)))
+svint16_t svmax_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_m)))
+svuint8_t svmax_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_m)))
+svuint32_t svmax_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_m)))
+svuint64_t svmax_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_m)))
+svuint16_t svmax_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_x)))
+svuint8_t svmax_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_x)))
+svuint32_t svmax_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_x)))
+svuint64_t svmax_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_x)))
+svuint16_t svmax_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u8_z)))
+svuint8_t svmax_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u32_z)))
+svuint32_t svmax_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u64_z)))
+svuint64_t svmax_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_n_u16_z)))
+svuint16_t svmax_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_m)))
+svfloat64_t svmax_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_m)))
+svfloat32_t svmax_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_m)))
+svfloat16_t svmax_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_x)))
+svfloat64_t svmax_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_x)))
+svfloat32_t svmax_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_x)))
+svfloat16_t svmax_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f64_z)))
+svfloat64_t svmax_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f32_z)))
+svfloat32_t svmax_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_f16_z)))
+svfloat16_t svmax_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_m)))
+svint8_t svmax_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_m)))
+svint32_t svmax_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_m)))
+svint64_t svmax_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_m)))
+svint16_t svmax_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_x)))
+svint8_t svmax_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_x)))
+svint32_t svmax_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_x)))
+svint64_t svmax_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_x)))
+svint16_t svmax_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s8_z)))
+svint8_t svmax_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s32_z)))
+svint32_t svmax_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s64_z)))
+svint64_t svmax_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_s16_z)))
+svint16_t svmax_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_m)))
+svuint8_t svmax_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_m)))
+svuint32_t svmax_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_m)))
+svuint64_t svmax_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_m)))
+svuint16_t svmax_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_x)))
+svuint8_t svmax_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_x)))
+svuint32_t svmax_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_x)))
+svuint64_t svmax_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_x)))
+svuint16_t svmax_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u8_z)))
+svuint8_t svmax_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u32_z)))
+svuint32_t svmax_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u64_z)))
+svuint64_t svmax_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmax_u16_z)))
+svuint16_t svmax_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_m)))
+svfloat64_t svmaxnm_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_m)))
+svfloat32_t svmaxnm_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_m)))
+svfloat16_t svmaxnm_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_x)))
+svfloat64_t svmaxnm_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_x)))
+svfloat32_t svmaxnm_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_x)))
+svfloat16_t svmaxnm_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f64_z)))
+svfloat64_t svmaxnm_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f32_z)))
+svfloat32_t svmaxnm_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_n_f16_z)))
+svfloat16_t svmaxnm_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_m)))
+svfloat64_t svmaxnm_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_m)))
+svfloat32_t svmaxnm_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_m)))
+svfloat16_t svmaxnm_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_x)))
+svfloat64_t svmaxnm_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_x)))
+svfloat32_t svmaxnm_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_x)))
+svfloat16_t svmaxnm_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f64_z)))
+svfloat64_t svmaxnm_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f32_z)))
+svfloat32_t svmaxnm_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnm_f16_z)))
+svfloat16_t svmaxnm_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f64)))
+float64_t svmaxnmv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f32)))
+float32_t svmaxnmv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxnmv_f16)))
+float16_t svmaxnmv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f64)))
+float64_t svmaxv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f32)))
+float32_t svmaxv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_f16)))
+float16_t svmaxv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s8)))
+int8_t svmaxv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s32)))
+int32_t svmaxv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s64)))
+int64_t svmaxv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_s16)))
+int16_t svmaxv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u8)))
+uint8_t svmaxv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u32)))
+uint32_t svmaxv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u64)))
+uint64_t svmaxv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmaxv_u16)))
+uint16_t svmaxv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_m)))
+svfloat64_t svmin_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_m)))
+svfloat32_t svmin_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_m)))
+svfloat16_t svmin_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_x)))
+svfloat64_t svmin_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_x)))
+svfloat32_t svmin_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_x)))
+svfloat16_t svmin_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f64_z)))
+svfloat64_t svmin_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f32_z)))
+svfloat32_t svmin_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_f16_z)))
+svfloat16_t svmin_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_m)))
+svint8_t svmin_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_m)))
+svint32_t svmin_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_m)))
+svint64_t svmin_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_m)))
+svint16_t svmin_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_x)))
+svint8_t svmin_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_x)))
+svint32_t svmin_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_x)))
+svint64_t svmin_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_x)))
+svint16_t svmin_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s8_z)))
+svint8_t svmin_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s32_z)))
+svint32_t svmin_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s64_z)))
+svint64_t svmin_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_s16_z)))
+svint16_t svmin_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_m)))
+svuint8_t svmin_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_m)))
+svuint32_t svmin_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_m)))
+svuint64_t svmin_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_m)))
+svuint16_t svmin_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_x)))
+svuint8_t svmin_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_x)))
+svuint32_t svmin_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_x)))
+svuint64_t svmin_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_x)))
+svuint16_t svmin_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u8_z)))
+svuint8_t svmin_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u32_z)))
+svuint32_t svmin_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u64_z)))
+svuint64_t svmin_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_n_u16_z)))
+svuint16_t svmin_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_m)))
+svfloat64_t svmin_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_m)))
+svfloat32_t svmin_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_m)))
+svfloat16_t svmin_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_x)))
+svfloat64_t svmin_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_x)))
+svfloat32_t svmin_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_x)))
+svfloat16_t svmin_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f64_z)))
+svfloat64_t svmin_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f32_z)))
+svfloat32_t svmin_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_f16_z)))
+svfloat16_t svmin_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_m)))
+svint8_t svmin_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_m)))
+svint32_t svmin_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_m)))
+svint64_t svmin_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_m)))
+svint16_t svmin_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_x)))
+svint8_t svmin_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_x)))
+svint32_t svmin_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_x)))
+svint64_t svmin_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_x)))
+svint16_t svmin_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s8_z)))
+svint8_t svmin_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s32_z)))
+svint32_t svmin_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s64_z)))
+svint64_t svmin_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_s16_z)))
+svint16_t svmin_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_m)))
+svuint8_t svmin_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_m)))
+svuint32_t svmin_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_m)))
+svuint64_t svmin_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_m)))
+svuint16_t svmin_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_x)))
+svuint8_t svmin_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_x)))
+svuint32_t svmin_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_x)))
+svuint64_t svmin_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_x)))
+svuint16_t svmin_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u8_z)))
+svuint8_t svmin_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u32_z)))
+svuint32_t svmin_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u64_z)))
+svuint64_t svmin_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmin_u16_z)))
+svuint16_t svmin_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_m)))
+svfloat64_t svminnm_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_m)))
+svfloat32_t svminnm_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_m)))
+svfloat16_t svminnm_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_x)))
+svfloat64_t svminnm_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_x)))
+svfloat32_t svminnm_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_x)))
+svfloat16_t svminnm_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f64_z)))
+svfloat64_t svminnm_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f32_z)))
+svfloat32_t svminnm_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_n_f16_z)))
+svfloat16_t svminnm_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_m)))
+svfloat64_t svminnm_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_m)))
+svfloat32_t svminnm_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_m)))
+svfloat16_t svminnm_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_x)))
+svfloat64_t svminnm_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_x)))
+svfloat32_t svminnm_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_x)))
+svfloat16_t svminnm_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f64_z)))
+svfloat64_t svminnm_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f32_z)))
+svfloat32_t svminnm_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnm_f16_z)))
+svfloat16_t svminnm_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f64)))
+float64_t svminnmv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f32)))
+float32_t svminnmv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminnmv_f16)))
+float16_t svminnmv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f64)))
+float64_t svminv(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f32)))
+float32_t svminv(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_f16)))
+float16_t svminv(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s8)))
+int8_t svminv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s32)))
+int32_t svminv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s64)))
+int64_t svminv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_s16)))
+int16_t svminv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u8)))
+uint8_t svminv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u32)))
+uint32_t svminv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u64)))
+uint64_t svminv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svminv_u16)))
+uint16_t svminv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_m)))
+svfloat64_t svmla_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_m)))
+svfloat32_t svmla_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_m)))
+svfloat16_t svmla_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_x)))
+svfloat64_t svmla_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_x)))
+svfloat32_t svmla_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_x)))
+svfloat16_t svmla_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f64_z)))
+svfloat64_t svmla_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f32_z)))
+svfloat32_t svmla_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_f16_z)))
+svfloat16_t svmla_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_m)))
+svuint8_t svmla_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_m)))
+svuint32_t svmla_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_m)))
+svuint64_t svmla_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_m)))
+svuint16_t svmla_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_m)))
+svint8_t svmla_m(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_m)))
+svint32_t svmla_m(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_m)))
+svint64_t svmla_m(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_m)))
+svint16_t svmla_m(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_x)))
+svuint8_t svmla_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_x)))
+svuint32_t svmla_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_x)))
+svuint64_t svmla_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_x)))
+svuint16_t svmla_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_x)))
+svint8_t svmla_x(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_x)))
+svint32_t svmla_x(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_x)))
+svint64_t svmla_x(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_x)))
+svint16_t svmla_x(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u8_z)))
+svuint8_t svmla_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u32_z)))
+svuint32_t svmla_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u64_z)))
+svuint64_t svmla_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_u16_z)))
+svuint16_t svmla_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s8_z)))
+svint8_t svmla_z(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s32_z)))
+svint32_t svmla_z(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s64_z)))
+svint64_t svmla_z(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_n_s16_z)))
+svint16_t svmla_z(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_m)))
+svfloat64_t svmla_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_m)))
+svfloat32_t svmla_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_m)))
+svfloat16_t svmla_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_x)))
+svfloat64_t svmla_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_x)))
+svfloat32_t svmla_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_x)))
+svfloat16_t svmla_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f64_z)))
+svfloat64_t svmla_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f32_z)))
+svfloat32_t svmla_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_f16_z)))
+svfloat16_t svmla_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_m)))
+svuint8_t svmla_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_m)))
+svuint32_t svmla_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_m)))
+svuint64_t svmla_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_m)))
+svuint16_t svmla_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_m)))
+svint8_t svmla_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_m)))
+svint32_t svmla_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_m)))
+svint64_t svmla_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_m)))
+svint16_t svmla_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_x)))
+svuint8_t svmla_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_x)))
+svuint32_t svmla_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_x)))
+svuint64_t svmla_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_x)))
+svuint16_t svmla_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_x)))
+svint8_t svmla_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_x)))
+svint32_t svmla_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_x)))
+svint64_t svmla_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_x)))
+svint16_t svmla_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u8_z)))
+svuint8_t svmla_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u32_z)))
+svuint32_t svmla_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u64_z)))
+svuint64_t svmla_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_u16_z)))
+svuint16_t svmla_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s8_z)))
+svint8_t svmla_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s32_z)))
+svint32_t svmla_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s64_z)))
+svint64_t svmla_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_s16_z)))
+svint16_t svmla_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f64)))
+svfloat64_t svmla_lane(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f32)))
+svfloat32_t svmla_lane(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmla_lane_f16)))
+svfloat16_t svmla_lane(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_m)))
+svfloat64_t svmls_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_m)))
+svfloat32_t svmls_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_m)))
+svfloat16_t svmls_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_x)))
+svfloat64_t svmls_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_x)))
+svfloat32_t svmls_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_x)))
+svfloat16_t svmls_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f64_z)))
+svfloat64_t svmls_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f32_z)))
+svfloat32_t svmls_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_f16_z)))
+svfloat16_t svmls_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_m)))
+svuint8_t svmls_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_m)))
+svuint32_t svmls_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_m)))
+svuint64_t svmls_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_m)))
+svuint16_t svmls_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_m)))
+svint8_t svmls_m(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_m)))
+svint32_t svmls_m(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_m)))
+svint64_t svmls_m(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_m)))
+svint16_t svmls_m(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_x)))
+svuint8_t svmls_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_x)))
+svuint32_t svmls_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_x)))
+svuint64_t svmls_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_x)))
+svuint16_t svmls_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_x)))
+svint8_t svmls_x(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_x)))
+svint32_t svmls_x(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_x)))
+svint64_t svmls_x(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_x)))
+svint16_t svmls_x(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u8_z)))
+svuint8_t svmls_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u32_z)))
+svuint32_t svmls_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u64_z)))
+svuint64_t svmls_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_u16_z)))
+svuint16_t svmls_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s8_z)))
+svint8_t svmls_z(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s32_z)))
+svint32_t svmls_z(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s64_z)))
+svint64_t svmls_z(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_n_s16_z)))
+svint16_t svmls_z(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_m)))
+svfloat64_t svmls_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_m)))
+svfloat32_t svmls_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_m)))
+svfloat16_t svmls_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_x)))
+svfloat64_t svmls_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_x)))
+svfloat32_t svmls_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_x)))
+svfloat16_t svmls_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f64_z)))
+svfloat64_t svmls_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f32_z)))
+svfloat32_t svmls_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_f16_z)))
+svfloat16_t svmls_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_m)))
+svuint8_t svmls_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_m)))
+svuint32_t svmls_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_m)))
+svuint64_t svmls_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_m)))
+svuint16_t svmls_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_m)))
+svint8_t svmls_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_m)))
+svint32_t svmls_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_m)))
+svint64_t svmls_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_m)))
+svint16_t svmls_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_x)))
+svuint8_t svmls_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_x)))
+svuint32_t svmls_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_x)))
+svuint64_t svmls_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_x)))
+svuint16_t svmls_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_x)))
+svint8_t svmls_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_x)))
+svint32_t svmls_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_x)))
+svint64_t svmls_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_x)))
+svint16_t svmls_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u8_z)))
+svuint8_t svmls_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u32_z)))
+svuint32_t svmls_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u64_z)))
+svuint64_t svmls_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_u16_z)))
+svuint16_t svmls_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s8_z)))
+svint8_t svmls_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s32_z)))
+svint32_t svmls_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s64_z)))
+svint64_t svmls_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_s16_z)))
+svint16_t svmls_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f64)))
+svfloat64_t svmls_lane(svfloat64_t, svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f32)))
+svfloat32_t svmls_lane(svfloat32_t, svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmls_lane_f16)))
+svfloat16_t svmls_lane(svfloat16_t, svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmov_b_z)))
+svbool_t svmov_z(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_m)))
+svfloat64_t svmsb_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_m)))
+svfloat32_t svmsb_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_m)))
+svfloat16_t svmsb_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_x)))
+svfloat64_t svmsb_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_x)))
+svfloat32_t svmsb_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_x)))
+svfloat16_t svmsb_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f64_z)))
+svfloat64_t svmsb_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f32_z)))
+svfloat32_t svmsb_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_f16_z)))
+svfloat16_t svmsb_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_m)))
+svuint8_t svmsb_m(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_m)))
+svuint32_t svmsb_m(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_m)))
+svuint64_t svmsb_m(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_m)))
+svuint16_t svmsb_m(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_m)))
+svint8_t svmsb_m(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_m)))
+svint32_t svmsb_m(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_m)))
+svint64_t svmsb_m(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_m)))
+svint16_t svmsb_m(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_x)))
+svuint8_t svmsb_x(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_x)))
+svuint32_t svmsb_x(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_x)))
+svuint64_t svmsb_x(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_x)))
+svuint16_t svmsb_x(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_x)))
+svint8_t svmsb_x(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_x)))
+svint32_t svmsb_x(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_x)))
+svint64_t svmsb_x(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_x)))
+svint16_t svmsb_x(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u8_z)))
+svuint8_t svmsb_z(svbool_t, svuint8_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u32_z)))
+svuint32_t svmsb_z(svbool_t, svuint32_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u64_z)))
+svuint64_t svmsb_z(svbool_t, svuint64_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_u16_z)))
+svuint16_t svmsb_z(svbool_t, svuint16_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s8_z)))
+svint8_t svmsb_z(svbool_t, svint8_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s32_z)))
+svint32_t svmsb_z(svbool_t, svint32_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s64_z)))
+svint64_t svmsb_z(svbool_t, svint64_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_n_s16_z)))
+svint16_t svmsb_z(svbool_t, svint16_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_m)))
+svfloat64_t svmsb_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_m)))
+svfloat32_t svmsb_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_m)))
+svfloat16_t svmsb_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_x)))
+svfloat64_t svmsb_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_x)))
+svfloat32_t svmsb_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_x)))
+svfloat16_t svmsb_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f64_z)))
+svfloat64_t svmsb_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f32_z)))
+svfloat32_t svmsb_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_f16_z)))
+svfloat16_t svmsb_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_m)))
+svuint8_t svmsb_m(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_m)))
+svuint32_t svmsb_m(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_m)))
+svuint64_t svmsb_m(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_m)))
+svuint16_t svmsb_m(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_m)))
+svint8_t svmsb_m(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_m)))
+svint32_t svmsb_m(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_m)))
+svint64_t svmsb_m(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_m)))
+svint16_t svmsb_m(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_x)))
+svuint8_t svmsb_x(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_x)))
+svuint32_t svmsb_x(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_x)))
+svuint64_t svmsb_x(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_x)))
+svuint16_t svmsb_x(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_x)))
+svint8_t svmsb_x(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_x)))
+svint32_t svmsb_x(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_x)))
+svint64_t svmsb_x(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_x)))
+svint16_t svmsb_x(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u8_z)))
+svuint8_t svmsb_z(svbool_t, svuint8_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u32_z)))
+svuint32_t svmsb_z(svbool_t, svuint32_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u64_z)))
+svuint64_t svmsb_z(svbool_t, svuint64_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_u16_z)))
+svuint16_t svmsb_z(svbool_t, svuint16_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s8_z)))
+svint8_t svmsb_z(svbool_t, svint8_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s32_z)))
+svint32_t svmsb_z(svbool_t, svint32_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s64_z)))
+svint64_t svmsb_z(svbool_t, svint64_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmsb_s16_z)))
+svint16_t svmsb_z(svbool_t, svint16_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_m)))
+svfloat64_t svmul_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_m)))
+svfloat32_t svmul_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_m)))
+svfloat16_t svmul_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_x)))
+svfloat64_t svmul_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_x)))
+svfloat32_t svmul_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_x)))
+svfloat16_t svmul_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f64_z)))
+svfloat64_t svmul_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f32_z)))
+svfloat32_t svmul_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_f16_z)))
+svfloat16_t svmul_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_m)))
+svuint8_t svmul_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_m)))
+svuint32_t svmul_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_m)))
+svuint64_t svmul_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_m)))
+svuint16_t svmul_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_m)))
+svint8_t svmul_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_m)))
+svint32_t svmul_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_m)))
+svint64_t svmul_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_m)))
+svint16_t svmul_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_x)))
+svuint8_t svmul_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_x)))
+svuint32_t svmul_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_x)))
+svuint64_t svmul_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_x)))
+svuint16_t svmul_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_x)))
+svint8_t svmul_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_x)))
+svint32_t svmul_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_x)))
+svint64_t svmul_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_x)))
+svint16_t svmul_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u8_z)))
+svuint8_t svmul_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u32_z)))
+svuint32_t svmul_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u64_z)))
+svuint64_t svmul_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_u16_z)))
+svuint16_t svmul_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s8_z)))
+svint8_t svmul_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s32_z)))
+svint32_t svmul_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s64_z)))
+svint64_t svmul_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_n_s16_z)))
+svint16_t svmul_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_m)))
+svfloat64_t svmul_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_m)))
+svfloat32_t svmul_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_m)))
+svfloat16_t svmul_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_x)))
+svfloat64_t svmul_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_x)))
+svfloat32_t svmul_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_x)))
+svfloat16_t svmul_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f64_z)))
+svfloat64_t svmul_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f32_z)))
+svfloat32_t svmul_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_f16_z)))
+svfloat16_t svmul_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_m)))
+svuint8_t svmul_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_m)))
+svuint32_t svmul_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_m)))
+svuint64_t svmul_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_m)))
+svuint16_t svmul_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_m)))
+svint8_t svmul_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_m)))
+svint32_t svmul_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_m)))
+svint64_t svmul_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_m)))
+svint16_t svmul_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_x)))
+svuint8_t svmul_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_x)))
+svuint32_t svmul_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_x)))
+svuint64_t svmul_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_x)))
+svuint16_t svmul_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_x)))
+svint8_t svmul_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_x)))
+svint32_t svmul_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_x)))
+svint64_t svmul_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_x)))
+svint16_t svmul_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u8_z)))
+svuint8_t svmul_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u32_z)))
+svuint32_t svmul_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u64_z)))
+svuint64_t svmul_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_u16_z)))
+svuint16_t svmul_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s8_z)))
+svint8_t svmul_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s32_z)))
+svint32_t svmul_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s64_z)))
+svint64_t svmul_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_s16_z)))
+svint16_t svmul_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f64)))
+svfloat64_t svmul_lane(svfloat64_t, svfloat64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f32)))
+svfloat32_t svmul_lane(svfloat32_t, svfloat32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmul_lane_f16)))
+svfloat16_t svmul_lane(svfloat16_t, svfloat16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_m)))
+svint8_t svmulh_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_m)))
+svint32_t svmulh_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_m)))
+svint64_t svmulh_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_m)))
+svint16_t svmulh_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_x)))
+svint8_t svmulh_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_x)))
+svint32_t svmulh_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_x)))
+svint64_t svmulh_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_x)))
+svint16_t svmulh_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s8_z)))
+svint8_t svmulh_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s32_z)))
+svint32_t svmulh_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s64_z)))
+svint64_t svmulh_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_s16_z)))
+svint16_t svmulh_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_m)))
+svuint8_t svmulh_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_m)))
+svuint32_t svmulh_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_m)))
+svuint64_t svmulh_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_m)))
+svuint16_t svmulh_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_x)))
+svuint8_t svmulh_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_x)))
+svuint32_t svmulh_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_x)))
+svuint64_t svmulh_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_x)))
+svuint16_t svmulh_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u8_z)))
+svuint8_t svmulh_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u32_z)))
+svuint32_t svmulh_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u64_z)))
+svuint64_t svmulh_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_n_u16_z)))
+svuint16_t svmulh_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_m)))
+svint8_t svmulh_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_m)))
+svint32_t svmulh_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_m)))
+svint64_t svmulh_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_m)))
+svint16_t svmulh_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_x)))
+svint8_t svmulh_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_x)))
+svint32_t svmulh_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_x)))
+svint64_t svmulh_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_x)))
+svint16_t svmulh_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s8_z)))
+svint8_t svmulh_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s32_z)))
+svint32_t svmulh_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s64_z)))
+svint64_t svmulh_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_s16_z)))
+svint16_t svmulh_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_m)))
+svuint8_t svmulh_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_m)))
+svuint32_t svmulh_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_m)))
+svuint64_t svmulh_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_m)))
+svuint16_t svmulh_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_x)))
+svuint8_t svmulh_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_x)))
+svuint32_t svmulh_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_x)))
+svuint64_t svmulh_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_x)))
+svuint16_t svmulh_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u8_z)))
+svuint8_t svmulh_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u32_z)))
+svuint32_t svmulh_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u64_z)))
+svuint64_t svmulh_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulh_u16_z)))
+svuint16_t svmulh_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_m)))
+svfloat64_t svmulx_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_m)))
+svfloat32_t svmulx_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_m)))
+svfloat16_t svmulx_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_x)))
+svfloat64_t svmulx_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_x)))
+svfloat32_t svmulx_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_x)))
+svfloat16_t svmulx_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f64_z)))
+svfloat64_t svmulx_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f32_z)))
+svfloat32_t svmulx_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_n_f16_z)))
+svfloat16_t svmulx_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_m)))
+svfloat64_t svmulx_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_m)))
+svfloat32_t svmulx_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_m)))
+svfloat16_t svmulx_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_x)))
+svfloat64_t svmulx_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_x)))
+svfloat32_t svmulx_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_x)))
+svfloat16_t svmulx_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f64_z)))
+svfloat64_t svmulx_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f32_z)))
+svfloat32_t svmulx_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svmulx_f16_z)))
+svfloat16_t svmulx_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnand_b_z)))
+svbool_t svnand_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_m)))
+svfloat64_t svneg_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_m)))
+svfloat32_t svneg_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_m)))
+svfloat16_t svneg_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_x)))
+svfloat64_t svneg_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_x)))
+svfloat32_t svneg_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_x)))
+svfloat16_t svneg_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f64_z)))
+svfloat64_t svneg_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f32_z)))
+svfloat32_t svneg_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_f16_z)))
+svfloat16_t svneg_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_m)))
+svint8_t svneg_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_m)))
+svint32_t svneg_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_m)))
+svint64_t svneg_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_m)))
+svint16_t svneg_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_x)))
+svint8_t svneg_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_x)))
+svint32_t svneg_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_x)))
+svint64_t svneg_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_x)))
+svint16_t svneg_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s8_z)))
+svint8_t svneg_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s32_z)))
+svint32_t svneg_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s64_z)))
+svint64_t svneg_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svneg_s16_z)))
+svint16_t svneg_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_m)))
+svfloat64_t svnmad_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_m)))
+svfloat32_t svnmad_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_m)))
+svfloat16_t svnmad_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_x)))
+svfloat64_t svnmad_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_x)))
+svfloat32_t svnmad_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_x)))
+svfloat16_t svnmad_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f64_z)))
+svfloat64_t svnmad_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f32_z)))
+svfloat32_t svnmad_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_n_f16_z)))
+svfloat16_t svnmad_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_m)))
+svfloat64_t svnmad_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_m)))
+svfloat32_t svnmad_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_m)))
+svfloat16_t svnmad_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_x)))
+svfloat64_t svnmad_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_x)))
+svfloat32_t svnmad_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_x)))
+svfloat16_t svnmad_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f64_z)))
+svfloat64_t svnmad_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f32_z)))
+svfloat32_t svnmad_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmad_f16_z)))
+svfloat16_t svnmad_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_m)))
+svfloat64_t svnmla_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_m)))
+svfloat32_t svnmla_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_m)))
+svfloat16_t svnmla_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_x)))
+svfloat64_t svnmla_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_x)))
+svfloat32_t svnmla_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_x)))
+svfloat16_t svnmla_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f64_z)))
+svfloat64_t svnmla_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f32_z)))
+svfloat32_t svnmla_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_n_f16_z)))
+svfloat16_t svnmla_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_m)))
+svfloat64_t svnmla_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_m)))
+svfloat32_t svnmla_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_m)))
+svfloat16_t svnmla_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_x)))
+svfloat64_t svnmla_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_x)))
+svfloat32_t svnmla_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_x)))
+svfloat16_t svnmla_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f64_z)))
+svfloat64_t svnmla_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f32_z)))
+svfloat32_t svnmla_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmla_f16_z)))
+svfloat16_t svnmla_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_m)))
+svfloat64_t svnmls_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_m)))
+svfloat32_t svnmls_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_m)))
+svfloat16_t svnmls_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_x)))
+svfloat64_t svnmls_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_x)))
+svfloat32_t svnmls_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_x)))
+svfloat16_t svnmls_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f64_z)))
+svfloat64_t svnmls_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f32_z)))
+svfloat32_t svnmls_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_n_f16_z)))
+svfloat16_t svnmls_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_m)))
+svfloat64_t svnmls_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_m)))
+svfloat32_t svnmls_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_m)))
+svfloat16_t svnmls_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_x)))
+svfloat64_t svnmls_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_x)))
+svfloat32_t svnmls_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_x)))
+svfloat16_t svnmls_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f64_z)))
+svfloat64_t svnmls_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f32_z)))
+svfloat32_t svnmls_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmls_f16_z)))
+svfloat16_t svnmls_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_m)))
+svfloat64_t svnmsb_m(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_m)))
+svfloat32_t svnmsb_m(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_m)))
+svfloat16_t svnmsb_m(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_x)))
+svfloat64_t svnmsb_x(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_x)))
+svfloat32_t svnmsb_x(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_x)))
+svfloat16_t svnmsb_x(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f64_z)))
+svfloat64_t svnmsb_z(svbool_t, svfloat64_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f32_z)))
+svfloat32_t svnmsb_z(svbool_t, svfloat32_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_n_f16_z)))
+svfloat16_t svnmsb_z(svbool_t, svfloat16_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_m)))
+svfloat64_t svnmsb_m(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_m)))
+svfloat32_t svnmsb_m(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_m)))
+svfloat16_t svnmsb_m(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_x)))
+svfloat64_t svnmsb_x(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_x)))
+svfloat32_t svnmsb_x(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_x)))
+svfloat16_t svnmsb_x(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f64_z)))
+svfloat64_t svnmsb_z(svbool_t, svfloat64_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f32_z)))
+svfloat32_t svnmsb_z(svbool_t, svfloat32_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnmsb_f16_z)))
+svfloat16_t svnmsb_z(svbool_t, svfloat16_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnor_b_z)))
+svbool_t svnor_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_b_z)))
+svbool_t svnot_z(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_m)))
+svuint8_t svnot_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_m)))
+svuint32_t svnot_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_m)))
+svuint64_t svnot_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_m)))
+svuint16_t svnot_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_m)))
+svint8_t svnot_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_m)))
+svint32_t svnot_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_m)))
+svint64_t svnot_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_m)))
+svint16_t svnot_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_x)))
+svuint8_t svnot_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_x)))
+svuint32_t svnot_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_x)))
+svuint64_t svnot_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_x)))
+svuint16_t svnot_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_x)))
+svint8_t svnot_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_x)))
+svint32_t svnot_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_x)))
+svint64_t svnot_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_x)))
+svint16_t svnot_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u8_z)))
+svuint8_t svnot_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u32_z)))
+svuint32_t svnot_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u64_z)))
+svuint64_t svnot_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_u16_z)))
+svuint16_t svnot_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s8_z)))
+svint8_t svnot_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s32_z)))
+svint32_t svnot_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s64_z)))
+svint64_t svnot_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svnot_s16_z)))
+svint16_t svnot_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorn_b_z)))
+svbool_t svorn_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_b_z)))
+svbool_t svorr_z(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_m)))
+svuint8_t svorr_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_m)))
+svuint32_t svorr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_m)))
+svuint64_t svorr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_m)))
+svuint16_t svorr_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_m)))
+svint8_t svorr_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_m)))
+svint32_t svorr_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_m)))
+svint64_t svorr_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_m)))
+svint16_t svorr_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_x)))
+svuint8_t svorr_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_x)))
+svuint32_t svorr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_x)))
+svuint64_t svorr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_x)))
+svuint16_t svorr_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_x)))
+svint8_t svorr_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_x)))
+svint32_t svorr_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_x)))
+svint64_t svorr_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_x)))
+svint16_t svorr_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u8_z)))
+svuint8_t svorr_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u32_z)))
+svuint32_t svorr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u64_z)))
+svuint64_t svorr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_u16_z)))
+svuint16_t svorr_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s8_z)))
+svint8_t svorr_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s32_z)))
+svint32_t svorr_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s64_z)))
+svint64_t svorr_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_n_s16_z)))
+svint16_t svorr_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_m)))
+svuint8_t svorr_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_m)))
+svuint32_t svorr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_m)))
+svuint64_t svorr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_m)))
+svuint16_t svorr_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_m)))
+svint8_t svorr_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_m)))
+svint32_t svorr_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_m)))
+svint64_t svorr_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_m)))
+svint16_t svorr_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_x)))
+svuint8_t svorr_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_x)))
+svuint32_t svorr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_x)))
+svuint64_t svorr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_x)))
+svuint16_t svorr_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_x)))
+svint8_t svorr_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_x)))
+svint32_t svorr_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_x)))
+svint64_t svorr_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_x)))
+svint16_t svorr_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u8_z)))
+svuint8_t svorr_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u32_z)))
+svuint32_t svorr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u64_z)))
+svuint64_t svorr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_u16_z)))
+svuint16_t svorr_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s8_z)))
+svint8_t svorr_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s32_z)))
+svint32_t svorr_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s64_z)))
+svint64_t svorr_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorr_s16_z)))
+svint16_t svorr_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u8)))
+uint8_t svorv(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u32)))
+uint32_t svorv(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u64)))
+uint64_t svorv(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_u16)))
+uint16_t svorv(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s8)))
+int8_t svorv(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s32)))
+int32_t svorv(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s64)))
+int64_t svorv(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svorv_s16)))
+int16_t svorv(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfalse_b)))
+svbool_t svpfalse(void);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svpfirst_b)))
+svbool_t svpfirst(svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s8)))
+svint8_t svqadd(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s32)))
+svint32_t svqadd(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s64)))
+svint64_t svqadd(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_s16)))
+svint16_t svqadd(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u8)))
+svuint8_t svqadd(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u32)))
+svuint32_t svqadd(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u64)))
+svuint64_t svqadd(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_n_u16)))
+svuint16_t svqadd(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s8)))
+svint8_t svqadd(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s32)))
+svint32_t svqadd(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s64)))
+svint64_t svqadd(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_s16)))
+svint16_t svqadd(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u8)))
+svuint8_t svqadd(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u32)))
+svuint32_t svqadd(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u64)))
+svuint64_t svqadd(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqadd_u16)))
+svuint16_t svqadd(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s32)))
+int32_t svqdecb(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_s64)))
+int64_t svqdecb(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u32)))
+uint32_t svqdecb(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_n_u64)))
+uint64_t svqdecb(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s32)))
+int32_t svqdecb_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_s64)))
+int64_t svqdecb_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u32)))
+uint32_t svqdecb_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecb_pat_n_u64)))
+uint64_t svqdecb_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s32)))
+int32_t svqdecd(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_s64)))
+int64_t svqdecd(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u32)))
+uint32_t svqdecd(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_n_u64)))
+uint64_t svqdecd(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_s64)))
+svint64_t svqdecd(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_u64)))
+svuint64_t svqdecd(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s32)))
+int32_t svqdecd_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_s64)))
+int64_t svqdecd_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u32)))
+uint32_t svqdecd_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_n_u64)))
+uint64_t svqdecd_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_s64)))
+svint64_t svqdecd_pat(svint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecd_pat_u64)))
+svuint64_t svqdecd_pat(svuint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s32)))
+int32_t svqdech(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_s64)))
+int64_t svqdech(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u32)))
+uint32_t svqdech(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_n_u64)))
+uint64_t svqdech(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_s16)))
+svint16_t svqdech(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_u16)))
+svuint16_t svqdech(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s32)))
+int32_t svqdech_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_s64)))
+int64_t svqdech_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u32)))
+uint32_t svqdech_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_n_u64)))
+uint64_t svqdech_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_s16)))
+svint16_t svqdech_pat(svint16_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdech_pat_u16)))
+svuint16_t svqdech_pat(svuint16_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b8)))
+int32_t svqdecp_b8(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b32)))
+int32_t svqdecp_b32(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b64)))
+int32_t svqdecp_b64(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s32_b16)))
+int32_t svqdecp_b16(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b8)))
+int64_t svqdecp_b8(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b32)))
+int64_t svqdecp_b32(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b64)))
+int64_t svqdecp_b64(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_s64_b16)))
+int64_t svqdecp_b16(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b8)))
+uint32_t svqdecp_b8(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b32)))
+uint32_t svqdecp_b32(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b64)))
+uint32_t svqdecp_b64(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u32_b16)))
+uint32_t svqdecp_b16(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b8)))
+uint64_t svqdecp_b8(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b32)))
+uint64_t svqdecp_b32(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b64)))
+uint64_t svqdecp_b64(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_n_u64_b16)))
+uint64_t svqdecp_b16(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s32)))
+svint32_t svqdecp(svint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s64)))
+svint64_t svqdecp(svint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_s16)))
+svint16_t svqdecp(svint16_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u32)))
+svuint32_t svqdecp(svuint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u64)))
+svuint64_t svqdecp(svuint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecp_u16)))
+svuint16_t svqdecp(svuint16_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s32)))
+int32_t svqdecw(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_s64)))
+int64_t svqdecw(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u32)))
+uint32_t svqdecw(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_n_u64)))
+uint64_t svqdecw(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_s32)))
+svint32_t svqdecw(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_u32)))
+svuint32_t svqdecw(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s32)))
+int32_t svqdecw_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_s64)))
+int64_t svqdecw_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u32)))
+uint32_t svqdecw_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_n_u64)))
+uint64_t svqdecw_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_s32)))
+svint32_t svqdecw_pat(svint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqdecw_pat_u32)))
+svuint32_t svqdecw_pat(svuint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s32)))
+int32_t svqincb(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_s64)))
+int64_t svqincb(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u32)))
+uint32_t svqincb(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_n_u64)))
+uint64_t svqincb(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s32)))
+int32_t svqincb_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_s64)))
+int64_t svqincb_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u32)))
+uint32_t svqincb_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincb_pat_n_u64)))
+uint64_t svqincb_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s32)))
+int32_t svqincd(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_s64)))
+int64_t svqincd(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u32)))
+uint32_t svqincd(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_n_u64)))
+uint64_t svqincd(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_s64)))
+svint64_t svqincd(svint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_u64)))
+svuint64_t svqincd(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s32)))
+int32_t svqincd_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_s64)))
+int64_t svqincd_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u32)))
+uint32_t svqincd_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_n_u64)))
+uint64_t svqincd_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_s64)))
+svint64_t svqincd_pat(svint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincd_pat_u64)))
+svuint64_t svqincd_pat(svuint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s32)))
+int32_t svqinch(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_s64)))
+int64_t svqinch(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u32)))
+uint32_t svqinch(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_n_u64)))
+uint64_t svqinch(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_s16)))
+svint16_t svqinch(svint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_u16)))
+svuint16_t svqinch(svuint16_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s32)))
+int32_t svqinch_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_s64)))
+int64_t svqinch_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u32)))
+uint32_t svqinch_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_n_u64)))
+uint64_t svqinch_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_s16)))
+svint16_t svqinch_pat(svint16_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqinch_pat_u16)))
+svuint16_t svqinch_pat(svuint16_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b8)))
+int32_t svqincp_b8(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b32)))
+int32_t svqincp_b32(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b64)))
+int32_t svqincp_b64(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s32_b16)))
+int32_t svqincp_b16(int32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b8)))
+int64_t svqincp_b8(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b32)))
+int64_t svqincp_b32(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b64)))
+int64_t svqincp_b64(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_s64_b16)))
+int64_t svqincp_b16(int64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b8)))
+uint32_t svqincp_b8(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b32)))
+uint32_t svqincp_b32(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b64)))
+uint32_t svqincp_b64(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u32_b16)))
+uint32_t svqincp_b16(uint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b8)))
+uint64_t svqincp_b8(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b32)))
+uint64_t svqincp_b32(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b64)))
+uint64_t svqincp_b64(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_n_u64_b16)))
+uint64_t svqincp_b16(uint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s32)))
+svint32_t svqincp(svint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s64)))
+svint64_t svqincp(svint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_s16)))
+svint16_t svqincp(svint16_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u32)))
+svuint32_t svqincp(svuint32_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u64)))
+svuint64_t svqincp(svuint64_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincp_u16)))
+svuint16_t svqincp(svuint16_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s32)))
+int32_t svqincw(int32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_s64)))
+int64_t svqincw(int64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u32)))
+uint32_t svqincw(uint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_n_u64)))
+uint64_t svqincw(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_s32)))
+svint32_t svqincw(svint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_u32)))
+svuint32_t svqincw(svuint32_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s32)))
+int32_t svqincw_pat(int32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_s64)))
+int64_t svqincw_pat(int64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u32)))
+uint32_t svqincw_pat(uint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_n_u64)))
+uint64_t svqincw_pat(uint64_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_s32)))
+svint32_t svqincw_pat(svint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqincw_pat_u32)))
+svuint32_t svqincw_pat(svuint32_t, enum svpattern, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s8)))
+svint8_t svqsub(svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s32)))
+svint32_t svqsub(svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s64)))
+svint64_t svqsub(svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_s16)))
+svint16_t svqsub(svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u8)))
+svuint8_t svqsub(svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u32)))
+svuint32_t svqsub(svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u64)))
+svuint64_t svqsub(svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_n_u16)))
+svuint16_t svqsub(svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s8)))
+svint8_t svqsub(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s32)))
+svint32_t svqsub(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s64)))
+svint64_t svqsub(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_s16)))
+svint16_t svqsub(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u8)))
+svuint8_t svqsub(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u32)))
+svuint32_t svqsub(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u64)))
+svuint64_t svqsub(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svqsub_u16)))
+svuint16_t svqsub(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_m)))
+svuint8_t svrbit_m(svuint8_t, svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_m)))
+svuint32_t svrbit_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_m)))
+svuint64_t svrbit_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_m)))
+svuint16_t svrbit_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_m)))
+svint8_t svrbit_m(svint8_t, svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_m)))
+svint32_t svrbit_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_m)))
+svint64_t svrbit_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_m)))
+svint16_t svrbit_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_x)))
+svuint8_t svrbit_x(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_x)))
+svuint32_t svrbit_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_x)))
+svuint64_t svrbit_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_x)))
+svuint16_t svrbit_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_x)))
+svint8_t svrbit_x(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_x)))
+svint32_t svrbit_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_x)))
+svint64_t svrbit_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_x)))
+svint16_t svrbit_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u8_z)))
+svuint8_t svrbit_z(svbool_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u32_z)))
+svuint32_t svrbit_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u64_z)))
+svuint64_t svrbit_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_u16_z)))
+svuint16_t svrbit_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s8_z)))
+svint8_t svrbit_z(svbool_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s32_z)))
+svint32_t svrbit_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s64_z)))
+svint64_t svrbit_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrbit_s16_z)))
+svint16_t svrbit_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f64)))
+svfloat64_t svrecpe(svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f32)))
+svfloat32_t svrecpe(svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpe_f16)))
+svfloat16_t svrecpe(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f64)))
+svfloat64_t svrecps(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f32)))
+svfloat32_t svrecps(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecps_f16)))
+svfloat16_t svrecps(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_m)))
+svfloat64_t svrecpx_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_m)))
+svfloat32_t svrecpx_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_m)))
+svfloat16_t svrecpx_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_x)))
+svfloat64_t svrecpx_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_x)))
+svfloat32_t svrecpx_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_x)))
+svfloat16_t svrecpx_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f64_z)))
+svfloat64_t svrecpx_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f32_z)))
+svfloat32_t svrecpx_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrecpx_f16_z)))
+svfloat16_t svrecpx_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u8)))
+svuint8_t svrev(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u32)))
+svuint32_t svrev(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u64)))
+svuint64_t svrev(svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_u16)))
+svuint16_t svrev(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s8)))
+svint8_t svrev(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f64)))
+svfloat64_t svrev(svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f32)))
+svfloat32_t svrev(svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_f16)))
+svfloat16_t svrev(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s32)))
+svint32_t svrev(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s64)))
+svint64_t svrev(svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrev_s16)))
+svint16_t svrev(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_m)))
+svuint32_t svrevb_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_m)))
+svuint64_t svrevb_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_m)))
+svuint16_t svrevb_m(svuint16_t, svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_m)))
+svint32_t svrevb_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_m)))
+svint64_t svrevb_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_m)))
+svint16_t svrevb_m(svint16_t, svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_x)))
+svuint32_t svrevb_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_x)))
+svuint64_t svrevb_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_x)))
+svuint16_t svrevb_x(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_x)))
+svint32_t svrevb_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_x)))
+svint64_t svrevb_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_x)))
+svint16_t svrevb_x(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u32_z)))
+svuint32_t svrevb_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u64_z)))
+svuint64_t svrevb_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_u16_z)))
+svuint16_t svrevb_z(svbool_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s32_z)))
+svint32_t svrevb_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s64_z)))
+svint64_t svrevb_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevb_s16_z)))
+svint16_t svrevb_z(svbool_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_m)))
+svuint32_t svrevh_m(svuint32_t, svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_m)))
+svuint64_t svrevh_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_m)))
+svint32_t svrevh_m(svint32_t, svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_m)))
+svint64_t svrevh_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_x)))
+svuint32_t svrevh_x(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_x)))
+svuint64_t svrevh_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_x)))
+svint32_t svrevh_x(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_x)))
+svint64_t svrevh_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u32_z)))
+svuint32_t svrevh_z(svbool_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_u64_z)))
+svuint64_t svrevh_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s32_z)))
+svint32_t svrevh_z(svbool_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevh_s64_z)))
+svint64_t svrevh_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_m)))
+svuint64_t svrevw_m(svuint64_t, svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_m)))
+svint64_t svrevw_m(svint64_t, svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_x)))
+svuint64_t svrevw_x(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_x)))
+svint64_t svrevw_x(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_u64_z)))
+svuint64_t svrevw_z(svbool_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrevw_s64_z)))
+svint64_t svrevw_z(svbool_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_m)))
+svfloat64_t svrinta_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_m)))
+svfloat32_t svrinta_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_m)))
+svfloat16_t svrinta_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_x)))
+svfloat64_t svrinta_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_x)))
+svfloat32_t svrinta_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_x)))
+svfloat16_t svrinta_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f64_z)))
+svfloat64_t svrinta_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f32_z)))
+svfloat32_t svrinta_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinta_f16_z)))
+svfloat16_t svrinta_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_m)))
+svfloat64_t svrinti_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_m)))
+svfloat32_t svrinti_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_m)))
+svfloat16_t svrinti_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_x)))
+svfloat64_t svrinti_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_x)))
+svfloat32_t svrinti_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_x)))
+svfloat16_t svrinti_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f64_z)))
+svfloat64_t svrinti_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f32_z)))
+svfloat32_t svrinti_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrinti_f16_z)))
+svfloat16_t svrinti_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_m)))
+svfloat64_t svrintm_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_m)))
+svfloat32_t svrintm_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_m)))
+svfloat16_t svrintm_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_x)))
+svfloat64_t svrintm_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_x)))
+svfloat32_t svrintm_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_x)))
+svfloat16_t svrintm_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f64_z)))
+svfloat64_t svrintm_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f32_z)))
+svfloat32_t svrintm_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintm_f16_z)))
+svfloat16_t svrintm_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_m)))
+svfloat64_t svrintn_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_m)))
+svfloat32_t svrintn_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_m)))
+svfloat16_t svrintn_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_x)))
+svfloat64_t svrintn_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_x)))
+svfloat32_t svrintn_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_x)))
+svfloat16_t svrintn_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f64_z)))
+svfloat64_t svrintn_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f32_z)))
+svfloat32_t svrintn_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintn_f16_z)))
+svfloat16_t svrintn_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_m)))
+svfloat64_t svrintp_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_m)))
+svfloat32_t svrintp_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_m)))
+svfloat16_t svrintp_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_x)))
+svfloat64_t svrintp_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_x)))
+svfloat32_t svrintp_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_x)))
+svfloat16_t svrintp_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f64_z)))
+svfloat64_t svrintp_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f32_z)))
+svfloat32_t svrintp_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintp_f16_z)))
+svfloat16_t svrintp_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_m)))
+svfloat64_t svrintx_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_m)))
+svfloat32_t svrintx_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_m)))
+svfloat16_t svrintx_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_x)))
+svfloat64_t svrintx_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_x)))
+svfloat32_t svrintx_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_x)))
+svfloat16_t svrintx_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f64_z)))
+svfloat64_t svrintx_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f32_z)))
+svfloat32_t svrintx_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintx_f16_z)))
+svfloat16_t svrintx_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_m)))
+svfloat64_t svrintz_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_m)))
+svfloat32_t svrintz_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_m)))
+svfloat16_t svrintz_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_x)))
+svfloat64_t svrintz_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_x)))
+svfloat32_t svrintz_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_x)))
+svfloat16_t svrintz_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f64_z)))
+svfloat64_t svrintz_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f32_z)))
+svfloat32_t svrintz_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrintz_f16_z)))
+svfloat16_t svrintz_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f64)))
+svfloat64_t svrsqrte(svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f32)))
+svfloat32_t svrsqrte(svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrte_f16)))
+svfloat16_t svrsqrte(svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f64)))
+svfloat64_t svrsqrts(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f32)))
+svfloat32_t svrsqrts(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svrsqrts_f16)))
+svfloat16_t svrsqrts(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_m)))
+svfloat64_t svscale_m(svbool_t, svfloat64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_m)))
+svfloat32_t svscale_m(svbool_t, svfloat32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_m)))
+svfloat16_t svscale_m(svbool_t, svfloat16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_x)))
+svfloat64_t svscale_x(svbool_t, svfloat64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_x)))
+svfloat32_t svscale_x(svbool_t, svfloat32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_x)))
+svfloat16_t svscale_x(svbool_t, svfloat16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f64_z)))
+svfloat64_t svscale_z(svbool_t, svfloat64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f32_z)))
+svfloat32_t svscale_z(svbool_t, svfloat32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_n_f16_z)))
+svfloat16_t svscale_z(svbool_t, svfloat16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_m)))
+svfloat64_t svscale_m(svbool_t, svfloat64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_m)))
+svfloat32_t svscale_m(svbool_t, svfloat32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_m)))
+svfloat16_t svscale_m(svbool_t, svfloat16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_x)))
+svfloat64_t svscale_x(svbool_t, svfloat64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_x)))
+svfloat32_t svscale_x(svbool_t, svfloat32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_x)))
+svfloat16_t svscale_x(svbool_t, svfloat16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f64_z)))
+svfloat64_t svscale_z(svbool_t, svfloat64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f32_z)))
+svfloat32_t svscale_z(svbool_t, svfloat32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svscale_f16_z)))
+svfloat16_t svscale_z(svbool_t, svfloat16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_b)))
+svbool_t svsel(svbool_t, svbool_t, svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u8)))
+svuint8_t svsel(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u32)))
+svuint32_t svsel(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u64)))
+svuint64_t svsel(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_u16)))
+svuint16_t svsel(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s8)))
+svint8_t svsel(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f64)))
+svfloat64_t svsel(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f32)))
+svfloat32_t svsel(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_f16)))
+svfloat16_t svsel(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s32)))
+svint32_t svsel(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s64)))
+svint64_t svsel(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsel_s16)))
+svint16_t svsel(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u8)))
+svuint8x2_t svset2(svuint8x2_t, uint64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u32)))
+svuint32x2_t svset2(svuint32x2_t, uint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u64)))
+svuint64x2_t svset2(svuint64x2_t, uint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_u16)))
+svuint16x2_t svset2(svuint16x2_t, uint64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s8)))
+svint8x2_t svset2(svint8x2_t, uint64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f64)))
+svfloat64x2_t svset2(svfloat64x2_t, uint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f32)))
+svfloat32x2_t svset2(svfloat32x2_t, uint64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_f16)))
+svfloat16x2_t svset2(svfloat16x2_t, uint64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s32)))
+svint32x2_t svset2(svint32x2_t, uint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s64)))
+svint64x2_t svset2(svint64x2_t, uint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset2_s16)))
+svint16x2_t svset2(svint16x2_t, uint64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u8)))
+svuint8x3_t svset3(svuint8x3_t, uint64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u32)))
+svuint32x3_t svset3(svuint32x3_t, uint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u64)))
+svuint64x3_t svset3(svuint64x3_t, uint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_u16)))
+svuint16x3_t svset3(svuint16x3_t, uint64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s8)))
+svint8x3_t svset3(svint8x3_t, uint64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f64)))
+svfloat64x3_t svset3(svfloat64x3_t, uint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f32)))
+svfloat32x3_t svset3(svfloat32x3_t, uint64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_f16)))
+svfloat16x3_t svset3(svfloat16x3_t, uint64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s32)))
+svint32x3_t svset3(svint32x3_t, uint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s64)))
+svint64x3_t svset3(svint64x3_t, uint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset3_s16)))
+svint16x3_t svset3(svint16x3_t, uint64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u8)))
+svuint8x4_t svset4(svuint8x4_t, uint64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u32)))
+svuint32x4_t svset4(svuint32x4_t, uint64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u64)))
+svuint64x4_t svset4(svuint64x4_t, uint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_u16)))
+svuint16x4_t svset4(svuint16x4_t, uint64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s8)))
+svint8x4_t svset4(svint8x4_t, uint64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f64)))
+svfloat64x4_t svset4(svfloat64x4_t, uint64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f32)))
+svfloat32x4_t svset4(svfloat32x4_t, uint64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_f16)))
+svfloat16x4_t svset4(svfloat16x4_t, uint64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s32)))
+svint32x4_t svset4(svint32x4_t, uint64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s64)))
+svint64x4_t svset4(svint64x4_t, uint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svset4_s16)))
+svint16x4_t svset4(svint16x4_t, uint64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u8)))
+svuint8_t svsplice(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u32)))
+svuint32_t svsplice(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u64)))
+svuint64_t svsplice(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_u16)))
+svuint16_t svsplice(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s8)))
+svint8_t svsplice(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f64)))
+svfloat64_t svsplice(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f32)))
+svfloat32_t svsplice(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_f16)))
+svfloat16_t svsplice(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s32)))
+svint32_t svsplice(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s64)))
+svint64_t svsplice(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsplice_s16)))
+svint16_t svsplice(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_m)))
+svfloat64_t svsqrt_m(svfloat64_t, svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_m)))
+svfloat32_t svsqrt_m(svfloat32_t, svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_m)))
+svfloat16_t svsqrt_m(svfloat16_t, svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_x)))
+svfloat64_t svsqrt_x(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_x)))
+svfloat32_t svsqrt_x(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_x)))
+svfloat16_t svsqrt_x(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f64_z)))
+svfloat64_t svsqrt_z(svbool_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f32_z)))
+svfloat32_t svsqrt_z(svbool_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsqrt_f16_z)))
+svfloat16_t svsqrt_z(svbool_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u8)))
+void svst1(svbool_t, uint8_t *, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u32)))
+void svst1(svbool_t, uint32_t *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u64)))
+void svst1(svbool_t, uint64_t *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_u16)))
+void svst1(svbool_t, uint16_t *, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s8)))
+void svst1(svbool_t, int8_t *, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f64)))
+void svst1(svbool_t, float64_t *, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f32)))
+void svst1(svbool_t, float32_t *, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_f16)))
+void svst1(svbool_t, float16_t *, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s32)))
+void svst1(svbool_t, int32_t *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s64)))
+void svst1(svbool_t, int64_t *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_s16)))
+void svst1(svbool_t, int16_t *, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u8)))
+void svst1_vnum(svbool_t, uint8_t *, int64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u32)))
+void svst1_vnum(svbool_t, uint32_t *, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u64)))
+void svst1_vnum(svbool_t, uint64_t *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_u16)))
+void svst1_vnum(svbool_t, uint16_t *, int64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s8)))
+void svst1_vnum(svbool_t, int8_t *, int64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f64)))
+void svst1_vnum(svbool_t, float64_t *, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f32)))
+void svst1_vnum(svbool_t, float32_t *, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_f16)))
+void svst1_vnum(svbool_t, float16_t *, int64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s32)))
+void svst1_vnum(svbool_t, int32_t *, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s64)))
+void svst1_vnum(svbool_t, int64_t *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1_vnum_s16)))
+void svst1_vnum(svbool_t, int16_t *, int64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s32)))
+void svst1b(svbool_t, int8_t *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s64)))
+void svst1b(svbool_t, int8_t *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_s16)))
+void svst1b(svbool_t, int8_t *, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u32)))
+void svst1b(svbool_t, uint8_t *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u64)))
+void svst1b(svbool_t, uint8_t *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_u16)))
+void svst1b(svbool_t, uint8_t *, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s32)))
+void svst1b_vnum(svbool_t, int8_t *, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s64)))
+void svst1b_vnum(svbool_t, int8_t *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_s16)))
+void svst1b_vnum(svbool_t, int8_t *, int64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u32)))
+void svst1b_vnum(svbool_t, uint8_t *, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u64)))
+void svst1b_vnum(svbool_t, uint8_t *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1b_vnum_u16)))
+void svst1b_vnum(svbool_t, uint8_t *, int64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s32)))
+void svst1h(svbool_t, int16_t *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_s64)))
+void svst1h(svbool_t, int16_t *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u32)))
+void svst1h(svbool_t, uint16_t *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_u64)))
+void svst1h(svbool_t, uint16_t *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s32)))
+void svst1h_vnum(svbool_t, int16_t *, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_s64)))
+void svst1h_vnum(svbool_t, int16_t *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u32)))
+void svst1h_vnum(svbool_t, uint16_t *, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1h_vnum_u64)))
+void svst1h_vnum(svbool_t, uint16_t *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_s64)))
+void svst1w(svbool_t, int32_t *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_u64)))
+void svst1w(svbool_t, uint32_t *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_s64)))
+void svst1w_vnum(svbool_t, int32_t *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst1w_vnum_u64)))
+void svst1w_vnum(svbool_t, uint32_t *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u8)))
+void svst2(svbool_t, uint8_t *, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u32)))
+void svst2(svbool_t, uint32_t *, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u64)))
+void svst2(svbool_t, uint64_t *, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_u16)))
+void svst2(svbool_t, uint16_t *, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s8)))
+void svst2(svbool_t, int8_t *, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f64)))
+void svst2(svbool_t, float64_t *, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f32)))
+void svst2(svbool_t, float32_t *, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_f16)))
+void svst2(svbool_t, float16_t *, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s32)))
+void svst2(svbool_t, int32_t *, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s64)))
+void svst2(svbool_t, int64_t *, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_s16)))
+void svst2(svbool_t, int16_t *, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u8)))
+void svst2_vnum(svbool_t, uint8_t *, int64_t, svuint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u32)))
+void svst2_vnum(svbool_t, uint32_t *, int64_t, svuint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u64)))
+void svst2_vnum(svbool_t, uint64_t *, int64_t, svuint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_u16)))
+void svst2_vnum(svbool_t, uint16_t *, int64_t, svuint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s8)))
+void svst2_vnum(svbool_t, int8_t *, int64_t, svint8x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f64)))
+void svst2_vnum(svbool_t, float64_t *, int64_t, svfloat64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f32)))
+void svst2_vnum(svbool_t, float32_t *, int64_t, svfloat32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_f16)))
+void svst2_vnum(svbool_t, float16_t *, int64_t, svfloat16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s32)))
+void svst2_vnum(svbool_t, int32_t *, int64_t, svint32x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s64)))
+void svst2_vnum(svbool_t, int64_t *, int64_t, svint64x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst2_vnum_s16)))
+void svst2_vnum(svbool_t, int16_t *, int64_t, svint16x2_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u8)))
+void svst3(svbool_t, uint8_t *, svuint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u32)))
+void svst3(svbool_t, uint32_t *, svuint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u64)))
+void svst3(svbool_t, uint64_t *, svuint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_u16)))
+void svst3(svbool_t, uint16_t *, svuint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s8)))
+void svst3(svbool_t, int8_t *, svint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f64)))
+void svst3(svbool_t, float64_t *, svfloat64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f32)))
+void svst3(svbool_t, float32_t *, svfloat32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_f16)))
+void svst3(svbool_t, float16_t *, svfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s32)))
+void svst3(svbool_t, int32_t *, svint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s64)))
+void svst3(svbool_t, int64_t *, svint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_s16)))
+void svst3(svbool_t, int16_t *, svint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u8)))
+void svst3_vnum(svbool_t, uint8_t *, int64_t, svuint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u32)))
+void svst3_vnum(svbool_t, uint32_t *, int64_t, svuint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u64)))
+void svst3_vnum(svbool_t, uint64_t *, int64_t, svuint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_u16)))
+void svst3_vnum(svbool_t, uint16_t *, int64_t, svuint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s8)))
+void svst3_vnum(svbool_t, int8_t *, int64_t, svint8x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f64)))
+void svst3_vnum(svbool_t, float64_t *, int64_t, svfloat64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f32)))
+void svst3_vnum(svbool_t, float32_t *, int64_t, svfloat32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_f16)))
+void svst3_vnum(svbool_t, float16_t *, int64_t, svfloat16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s32)))
+void svst3_vnum(svbool_t, int32_t *, int64_t, svint32x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s64)))
+void svst3_vnum(svbool_t, int64_t *, int64_t, svint64x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst3_vnum_s16)))
+void svst3_vnum(svbool_t, int16_t *, int64_t, svint16x3_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u8)))
+void svst4(svbool_t, uint8_t *, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u32)))
+void svst4(svbool_t, uint32_t *, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u64)))
+void svst4(svbool_t, uint64_t *, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_u16)))
+void svst4(svbool_t, uint16_t *, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s8)))
+void svst4(svbool_t, int8_t *, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f64)))
+void svst4(svbool_t, float64_t *, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f32)))
+void svst4(svbool_t, float32_t *, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_f16)))
+void svst4(svbool_t, float16_t *, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s32)))
+void svst4(svbool_t, int32_t *, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s64)))
+void svst4(svbool_t, int64_t *, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_s16)))
+void svst4(svbool_t, int16_t *, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u8)))
+void svst4_vnum(svbool_t, uint8_t *, int64_t, svuint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u32)))
+void svst4_vnum(svbool_t, uint32_t *, int64_t, svuint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u64)))
+void svst4_vnum(svbool_t, uint64_t *, int64_t, svuint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_u16)))
+void svst4_vnum(svbool_t, uint16_t *, int64_t, svuint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s8)))
+void svst4_vnum(svbool_t, int8_t *, int64_t, svint8x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f64)))
+void svst4_vnum(svbool_t, float64_t *, int64_t, svfloat64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f32)))
+void svst4_vnum(svbool_t, float32_t *, int64_t, svfloat32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_f16)))
+void svst4_vnum(svbool_t, float16_t *, int64_t, svfloat16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s32)))
+void svst4_vnum(svbool_t, int32_t *, int64_t, svint32x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s64)))
+void svst4_vnum(svbool_t, int64_t *, int64_t, svint64x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svst4_vnum_s16)))
+void svst4_vnum(svbool_t, int16_t *, int64_t, svint16x4_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u8)))
+void svstnt1(svbool_t, uint8_t *, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u32)))
+void svstnt1(svbool_t, uint32_t *, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u64)))
+void svstnt1(svbool_t, uint64_t *, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_u16)))
+void svstnt1(svbool_t, uint16_t *, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s8)))
+void svstnt1(svbool_t, int8_t *, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f64)))
+void svstnt1(svbool_t, float64_t *, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f32)))
+void svstnt1(svbool_t, float32_t *, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_f16)))
+void svstnt1(svbool_t, float16_t *, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s32)))
+void svstnt1(svbool_t, int32_t *, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s64)))
+void svstnt1(svbool_t, int64_t *, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_s16)))
+void svstnt1(svbool_t, int16_t *, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u8)))
+void svstnt1_vnum(svbool_t, uint8_t *, int64_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u32)))
+void svstnt1_vnum(svbool_t, uint32_t *, int64_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u64)))
+void svstnt1_vnum(svbool_t, uint64_t *, int64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_u16)))
+void svstnt1_vnum(svbool_t, uint16_t *, int64_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s8)))
+void svstnt1_vnum(svbool_t, int8_t *, int64_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f64)))
+void svstnt1_vnum(svbool_t, float64_t *, int64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f32)))
+void svstnt1_vnum(svbool_t, float32_t *, int64_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_f16)))
+void svstnt1_vnum(svbool_t, float16_t *, int64_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s32)))
+void svstnt1_vnum(svbool_t, int32_t *, int64_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s64)))
+void svstnt1_vnum(svbool_t, int64_t *, int64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svstnt1_vnum_s16)))
+void svstnt1_vnum(svbool_t, int16_t *, int64_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_m)))
+svfloat64_t svsub_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_m)))
+svfloat32_t svsub_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_m)))
+svfloat16_t svsub_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_x)))
+svfloat64_t svsub_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_x)))
+svfloat32_t svsub_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_x)))
+svfloat16_t svsub_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f64_z)))
+svfloat64_t svsub_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f32_z)))
+svfloat32_t svsub_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_f16_z)))
+svfloat16_t svsub_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_m)))
+svuint8_t svsub_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_m)))
+svuint32_t svsub_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_m)))
+svuint64_t svsub_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_m)))
+svuint16_t svsub_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_m)))
+svint8_t svsub_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_m)))
+svint32_t svsub_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_m)))
+svint64_t svsub_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_m)))
+svint16_t svsub_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_x)))
+svuint8_t svsub_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_x)))
+svuint32_t svsub_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_x)))
+svuint64_t svsub_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_x)))
+svuint16_t svsub_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_x)))
+svint8_t svsub_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_x)))
+svint32_t svsub_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_x)))
+svint64_t svsub_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_x)))
+svint16_t svsub_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u8_z)))
+svuint8_t svsub_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u32_z)))
+svuint32_t svsub_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u64_z)))
+svuint64_t svsub_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_u16_z)))
+svuint16_t svsub_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s8_z)))
+svint8_t svsub_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s32_z)))
+svint32_t svsub_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s64_z)))
+svint64_t svsub_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_n_s16_z)))
+svint16_t svsub_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_m)))
+svfloat64_t svsub_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_m)))
+svfloat32_t svsub_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_m)))
+svfloat16_t svsub_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_x)))
+svfloat64_t svsub_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_x)))
+svfloat32_t svsub_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_x)))
+svfloat16_t svsub_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f64_z)))
+svfloat64_t svsub_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f32_z)))
+svfloat32_t svsub_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_f16_z)))
+svfloat16_t svsub_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_m)))
+svuint8_t svsub_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_m)))
+svuint32_t svsub_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_m)))
+svuint64_t svsub_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_m)))
+svuint16_t svsub_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_m)))
+svint8_t svsub_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_m)))
+svint32_t svsub_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_m)))
+svint64_t svsub_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_m)))
+svint16_t svsub_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_x)))
+svuint8_t svsub_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_x)))
+svuint32_t svsub_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_x)))
+svuint64_t svsub_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_x)))
+svuint16_t svsub_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_x)))
+svint8_t svsub_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_x)))
+svint32_t svsub_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_x)))
+svint64_t svsub_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_x)))
+svint16_t svsub_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u8_z)))
+svuint8_t svsub_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u32_z)))
+svuint32_t svsub_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u64_z)))
+svuint64_t svsub_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_u16_z)))
+svuint16_t svsub_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s8_z)))
+svint8_t svsub_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s32_z)))
+svint32_t svsub_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s64_z)))
+svint64_t svsub_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsub_s16_z)))
+svint16_t svsub_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_m)))
+svfloat64_t svsubr_m(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_m)))
+svfloat32_t svsubr_m(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_m)))
+svfloat16_t svsubr_m(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_x)))
+svfloat64_t svsubr_x(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_x)))
+svfloat32_t svsubr_x(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_x)))
+svfloat16_t svsubr_x(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f64_z)))
+svfloat64_t svsubr_z(svbool_t, svfloat64_t, float64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f32_z)))
+svfloat32_t svsubr_z(svbool_t, svfloat32_t, float32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_f16_z)))
+svfloat16_t svsubr_z(svbool_t, svfloat16_t, float16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_m)))
+svuint8_t svsubr_m(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_m)))
+svuint32_t svsubr_m(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_m)))
+svuint64_t svsubr_m(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_m)))
+svuint16_t svsubr_m(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_m)))
+svint8_t svsubr_m(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_m)))
+svint32_t svsubr_m(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_m)))
+svint64_t svsubr_m(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_m)))
+svint16_t svsubr_m(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_x)))
+svuint8_t svsubr_x(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_x)))
+svuint32_t svsubr_x(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_x)))
+svuint64_t svsubr_x(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_x)))
+svuint16_t svsubr_x(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_x)))
+svint8_t svsubr_x(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_x)))
+svint32_t svsubr_x(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_x)))
+svint64_t svsubr_x(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_x)))
+svint16_t svsubr_x(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u8_z)))
+svuint8_t svsubr_z(svbool_t, svuint8_t, uint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u32_z)))
+svuint32_t svsubr_z(svbool_t, svuint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u64_z)))
+svuint64_t svsubr_z(svbool_t, svuint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_u16_z)))
+svuint16_t svsubr_z(svbool_t, svuint16_t, uint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s8_z)))
+svint8_t svsubr_z(svbool_t, svint8_t, int8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s32_z)))
+svint32_t svsubr_z(svbool_t, svint32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s64_z)))
+svint64_t svsubr_z(svbool_t, svint64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_n_s16_z)))
+svint16_t svsubr_z(svbool_t, svint16_t, int16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_m)))
+svfloat64_t svsubr_m(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_m)))
+svfloat32_t svsubr_m(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_m)))
+svfloat16_t svsubr_m(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_x)))
+svfloat64_t svsubr_x(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_x)))
+svfloat32_t svsubr_x(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_x)))
+svfloat16_t svsubr_x(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f64_z)))
+svfloat64_t svsubr_z(svbool_t, svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f32_z)))
+svfloat32_t svsubr_z(svbool_t, svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_f16_z)))
+svfloat16_t svsubr_z(svbool_t, svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_m)))
+svuint8_t svsubr_m(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_m)))
+svuint32_t svsubr_m(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_m)))
+svuint64_t svsubr_m(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_m)))
+svuint16_t svsubr_m(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_m)))
+svint8_t svsubr_m(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_m)))
+svint32_t svsubr_m(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_m)))
+svint64_t svsubr_m(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_m)))
+svint16_t svsubr_m(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_x)))
+svuint8_t svsubr_x(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_x)))
+svuint32_t svsubr_x(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_x)))
+svuint64_t svsubr_x(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_x)))
+svuint16_t svsubr_x(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_x)))
+svint8_t svsubr_x(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_x)))
+svint32_t svsubr_x(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_x)))
+svint64_t svsubr_x(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_x)))
+svint16_t svsubr_x(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u8_z)))
+svuint8_t svsubr_z(svbool_t, svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u32_z)))
+svuint32_t svsubr_z(svbool_t, svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u64_z)))
+svuint64_t svsubr_z(svbool_t, svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_u16_z)))
+svuint16_t svsubr_z(svbool_t, svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s8_z)))
+svint8_t svsubr_z(svbool_t, svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s32_z)))
+svint32_t svsubr_z(svbool_t, svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s64_z)))
+svint64_t svsubr_z(svbool_t, svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svsubr_s16_z)))
+svint16_t svsubr_z(svbool_t, svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u8)))
+svuint8_t svtbl(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u32)))
+svuint32_t svtbl(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u64)))
+svuint64_t svtbl(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_u16)))
+svuint16_t svtbl(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s8)))
+svint8_t svtbl(svint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f64)))
+svfloat64_t svtbl(svfloat64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f32)))
+svfloat32_t svtbl(svfloat32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_f16)))
+svfloat16_t svtbl(svfloat16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s32)))
+svint32_t svtbl(svint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s64)))
+svint64_t svtbl(svint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtbl_s16)))
+svint16_t svtbl(svint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u8)))
+svuint8_t svtrn1(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u32)))
+svuint32_t svtrn1(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u64)))
+svuint64_t svtrn1(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_u16)))
+svuint16_t svtrn1(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s8)))
+svint8_t svtrn1(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f64)))
+svfloat64_t svtrn1(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f32)))
+svfloat32_t svtrn1(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_f16)))
+svfloat16_t svtrn1(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s32)))
+svint32_t svtrn1(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s64)))
+svint64_t svtrn1(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn1_s16)))
+svint16_t svtrn1(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u8)))
+svuint8_t svtrn2(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u32)))
+svuint32_t svtrn2(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u64)))
+svuint64_t svtrn2(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_u16)))
+svuint16_t svtrn2(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s8)))
+svint8_t svtrn2(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f64)))
+svfloat64_t svtrn2(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f32)))
+svfloat32_t svtrn2(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_f16)))
+svfloat16_t svtrn2(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s32)))
+svint32_t svtrn2(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s64)))
+svint64_t svtrn2(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svtrn2_s16)))
+svint16_t svtrn2(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_b)))
+svbool_t svunpkhi(svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s32)))
+svint32_t svunpkhi(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s64)))
+svint64_t svunpkhi(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_s16)))
+svint16_t svunpkhi(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u32)))
+svuint32_t svunpkhi(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u64)))
+svuint64_t svunpkhi(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpkhi_u16)))
+svuint16_t svunpkhi(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_b)))
+svbool_t svunpklo(svbool_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s32)))
+svint32_t svunpklo(svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s64)))
+svint64_t svunpklo(svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_s16)))
+svint16_t svunpklo(svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u32)))
+svuint32_t svunpklo(svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u64)))
+svuint64_t svunpklo(svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svunpklo_u16)))
+svuint16_t svunpklo(svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u8)))
+svuint8_t svuzp1(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u32)))
+svuint32_t svuzp1(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u64)))
+svuint64_t svuzp1(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_u16)))
+svuint16_t svuzp1(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s8)))
+svint8_t svuzp1(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f64)))
+svfloat64_t svuzp1(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f32)))
+svfloat32_t svuzp1(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_f16)))
+svfloat16_t svuzp1(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s32)))
+svint32_t svuzp1(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s64)))
+svint64_t svuzp1(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp1_s16)))
+svint16_t svuzp1(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u8)))
+svuint8_t svuzp2(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u32)))
+svuint32_t svuzp2(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u64)))
+svuint64_t svuzp2(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_u16)))
+svuint16_t svuzp2(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s8)))
+svint8_t svuzp2(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f64)))
+svfloat64_t svuzp2(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f32)))
+svfloat32_t svuzp2(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_f16)))
+svfloat16_t svuzp2(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s32)))
+svint32_t svuzp2(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s64)))
+svint64_t svuzp2(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svuzp2_s16)))
+svint16_t svuzp2(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s32)))
+svbool_t svwhilele_b8(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s32)))
+svbool_t svwhilele_b32(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s32)))
+svbool_t svwhilele_b64(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s32)))
+svbool_t svwhilele_b16(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_s64)))
+svbool_t svwhilele_b8(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_s64)))
+svbool_t svwhilele_b32(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_s64)))
+svbool_t svwhilele_b64(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_s64)))
+svbool_t svwhilele_b16(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u32)))
+svbool_t svwhilele_b8(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u32)))
+svbool_t svwhilele_b32(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u32)))
+svbool_t svwhilele_b64(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u32)))
+svbool_t svwhilele_b16(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b8_u64)))
+svbool_t svwhilele_b8(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b32_u64)))
+svbool_t svwhilele_b32(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b64_u64)))
+svbool_t svwhilele_b64(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilele_b16_u64)))
+svbool_t svwhilele_b16(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u32)))
+svbool_t svwhilelt_b8(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u32)))
+svbool_t svwhilelt_b32(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u32)))
+svbool_t svwhilelt_b64(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u32)))
+svbool_t svwhilelt_b16(uint32_t, uint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_u64)))
+svbool_t svwhilelt_b8(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_u64)))
+svbool_t svwhilelt_b32(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_u64)))
+svbool_t svwhilelt_b64(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_u64)))
+svbool_t svwhilelt_b16(uint64_t, uint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s32)))
+svbool_t svwhilelt_b8(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s32)))
+svbool_t svwhilelt_b32(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s32)))
+svbool_t svwhilelt_b64(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s32)))
+svbool_t svwhilelt_b16(int32_t, int32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b8_s64)))
+svbool_t svwhilelt_b8(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b32_s64)))
+svbool_t svwhilelt_b32(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b64_s64)))
+svbool_t svwhilelt_b64(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svwhilelt_b16_s64)))
+svbool_t svwhilelt_b16(int64_t, int64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u8)))
+svuint8_t svzip1(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u32)))
+svuint32_t svzip1(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u64)))
+svuint64_t svzip1(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_u16)))
+svuint16_t svzip1(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s8)))
+svint8_t svzip1(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f64)))
+svfloat64_t svzip1(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f32)))
+svfloat32_t svzip1(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_f16)))
+svfloat16_t svzip1(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s32)))
+svint32_t svzip1(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s64)))
+svint64_t svzip1(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip1_s16)))
+svint16_t svzip1(svint16_t, svint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u8)))
+svuint8_t svzip2(svuint8_t, svuint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u32)))
+svuint32_t svzip2(svuint32_t, svuint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u64)))
+svuint64_t svzip2(svuint64_t, svuint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_u16)))
+svuint16_t svzip2(svuint16_t, svuint16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s8)))
+svint8_t svzip2(svint8_t, svint8_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f64)))
+svfloat64_t svzip2(svfloat64_t, svfloat64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f32)))
+svfloat32_t svzip2(svfloat32_t, svfloat32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_f16)))
+svfloat16_t svzip2(svfloat16_t, svfloat16_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s32)))
+svint32_t svzip2(svint32_t, svint32_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s64)))
+svint64_t svzip2(svint64_t, svint64_t);
+__aio __attribute__((__clang_arm_builtin_alias(__builtin_sve_svzip2_s16)))
+svint16_t svzip2(svint16_t, svint16_t);
+#define svcvtnt_bf16_x      svcvtnt_bf16_m
+#define svcvtnt_bf16_f32_x  svcvtnt_bf16_f32_m
+#define svcvtnt_f16_x      svcvtnt_f16_m
+#define svcvtnt_f16_f32_x  svcvtnt_f16_f32_m
+#define svcvtnt_f32_x      svcvtnt_f32_m
+#define svcvtnt_f32_f64_x  svcvtnt_f32_f64_m
+
+#define svcvtxnt_f32_x     svcvtxnt_f32_m
+#define svcvtxnt_f32_f64_x svcvtxnt_f32_f64_m
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#undef __ai
+
+#undef __aio
+
+#endif /* __ARM_SVE_H */
diff --git a/third_party/aarch64/clang/arm_vector_types.h b/third_party/aarch64/clang/arm_vector_types.h
new file mode 100644
index 000000000..8e79d39a6
--- /dev/null
+++ b/third_party/aarch64/clang/arm_vector_types.h
@@ -0,0 +1,345 @@
+/*===---- arm_vector_types - ARM vector type ------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(__ARM_NEON_H) && !defined(__ARM_SVE_H)
+#error "This file should not be used standalone. Please include arm_neon.h or arm_sve.h instead"
+
+#endif
+#ifndef __ARM_NEON_TYPES_H
+#define __ARM_NEON_TYPES_H
+typedef float float32_t;
+typedef __fp16 float16_t;
+#if defined(__aarch64__) || defined(__arm64ec__)
+typedef double float64_t;
+#endif
+
+typedef __attribute__((neon_vector_type(8))) int8_t int8x8_t;
+typedef __attribute__((neon_vector_type(16))) int8_t int8x16_t;
+typedef __attribute__((neon_vector_type(4))) int16_t int16x4_t;
+typedef __attribute__((neon_vector_type(8))) int16_t int16x8_t;
+typedef __attribute__((neon_vector_type(2))) int32_t int32x2_t;
+typedef __attribute__((neon_vector_type(4))) int32_t int32x4_t;
+typedef __attribute__((neon_vector_type(1))) int64_t int64x1_t;
+typedef __attribute__((neon_vector_type(2))) int64_t int64x2_t;
+typedef __attribute__((neon_vector_type(8))) uint8_t uint8x8_t;
+typedef __attribute__((neon_vector_type(16))) uint8_t uint8x16_t;
+typedef __attribute__((neon_vector_type(4))) uint16_t uint16x4_t;
+typedef __attribute__((neon_vector_type(8))) uint16_t uint16x8_t;
+typedef __attribute__((neon_vector_type(2))) uint32_t uint32x2_t;
+typedef __attribute__((neon_vector_type(4))) uint32_t uint32x4_t;
+typedef __attribute__((neon_vector_type(1))) uint64_t uint64x1_t;
+typedef __attribute__((neon_vector_type(2))) uint64_t uint64x2_t;
+typedef __attribute__((neon_vector_type(4))) float16_t float16x4_t;
+typedef __attribute__((neon_vector_type(8))) float16_t float16x8_t;
+typedef __attribute__((neon_vector_type(2))) float32_t float32x2_t;
+typedef __attribute__((neon_vector_type(4))) float32_t float32x4_t;
+#if defined(__aarch64__) || defined(__arm64ec__)
+typedef __attribute__((neon_vector_type(1))) float64_t float64x1_t;
+typedef __attribute__((neon_vector_type(2))) float64_t float64x2_t;
+#endif
+
+typedef struct int8x8x2_t {
+  int8x8_t val[2];
+} int8x8x2_t;
+
+typedef struct int8x16x2_t {
+  int8x16_t val[2];
+} int8x16x2_t;
+
+typedef struct int16x4x2_t {
+  int16x4_t val[2];
+} int16x4x2_t;
+
+typedef struct int16x8x2_t {
+  int16x8_t val[2];
+} int16x8x2_t;
+
+typedef struct int32x2x2_t {
+  int32x2_t val[2];
+} int32x2x2_t;
+
+typedef struct int32x4x2_t {
+  int32x4_t val[2];
+} int32x4x2_t;
+
+typedef struct int64x1x2_t {
+  int64x1_t val[2];
+} int64x1x2_t;
+
+typedef struct int64x2x2_t {
+  int64x2_t val[2];
+} int64x2x2_t;
+
+typedef struct uint8x8x2_t {
+  uint8x8_t val[2];
+} uint8x8x2_t;
+
+typedef struct uint8x16x2_t {
+  uint8x16_t val[2];
+} uint8x16x2_t;
+
+typedef struct uint16x4x2_t {
+  uint16x4_t val[2];
+} uint16x4x2_t;
+
+typedef struct uint16x8x2_t {
+  uint16x8_t val[2];
+} uint16x8x2_t;
+
+typedef struct uint32x2x2_t {
+  uint32x2_t val[2];
+} uint32x2x2_t;
+
+typedef struct uint32x4x2_t {
+  uint32x4_t val[2];
+} uint32x4x2_t;
+
+typedef struct uint64x1x2_t {
+  uint64x1_t val[2];
+} uint64x1x2_t;
+
+typedef struct uint64x2x2_t {
+  uint64x2_t val[2];
+} uint64x2x2_t;
+
+typedef struct float16x4x2_t {
+  float16x4_t val[2];
+} float16x4x2_t;
+
+typedef struct float16x8x2_t {
+  float16x8_t val[2];
+} float16x8x2_t;
+
+typedef struct float32x2x2_t {
+  float32x2_t val[2];
+} float32x2x2_t;
+
+typedef struct float32x4x2_t {
+  float32x4_t val[2];
+} float32x4x2_t;
+
+#if defined(__aarch64__) || defined(__arm64ec__)
+typedef struct float64x1x2_t {
+  float64x1_t val[2];
+} float64x1x2_t;
+
+typedef struct float64x2x2_t {
+  float64x2_t val[2];
+} float64x2x2_t;
+
+#endif
+typedef struct int8x8x3_t {
+  int8x8_t val[3];
+} int8x8x3_t;
+
+typedef struct int8x16x3_t {
+  int8x16_t val[3];
+} int8x16x3_t;
+
+typedef struct int16x4x3_t {
+  int16x4_t val[3];
+} int16x4x3_t;
+
+typedef struct int16x8x3_t {
+  int16x8_t val[3];
+} int16x8x3_t;
+
+typedef struct int32x2x3_t {
+  int32x2_t val[3];
+} int32x2x3_t;
+
+typedef struct int32x4x3_t {
+  int32x4_t val[3];
+} int32x4x3_t;
+
+typedef struct int64x1x3_t {
+  int64x1_t val[3];
+} int64x1x3_t;
+
+typedef struct int64x2x3_t {
+  int64x2_t val[3];
+} int64x2x3_t;
+
+typedef struct uint8x8x3_t {
+  uint8x8_t val[3];
+} uint8x8x3_t;
+
+typedef struct uint8x16x3_t {
+  uint8x16_t val[3];
+} uint8x16x3_t;
+
+typedef struct uint16x4x3_t {
+  uint16x4_t val[3];
+} uint16x4x3_t;
+
+typedef struct uint16x8x3_t {
+  uint16x8_t val[3];
+} uint16x8x3_t;
+
+typedef struct uint32x2x3_t {
+  uint32x2_t val[3];
+} uint32x2x3_t;
+
+typedef struct uint32x4x3_t {
+  uint32x4_t val[3];
+} uint32x4x3_t;
+
+typedef struct uint64x1x3_t {
+  uint64x1_t val[3];
+} uint64x1x3_t;
+
+typedef struct uint64x2x3_t {
+  uint64x2_t val[3];
+} uint64x2x3_t;
+
+typedef struct float16x4x3_t {
+  float16x4_t val[3];
+} float16x4x3_t;
+
+typedef struct float16x8x3_t {
+  float16x8_t val[3];
+} float16x8x3_t;
+
+typedef struct float32x2x3_t {
+  float32x2_t val[3];
+} float32x2x3_t;
+
+typedef struct float32x4x3_t {
+  float32x4_t val[3];
+} float32x4x3_t;
+
+#if defined(__aarch64__) || defined(__arm64ec__)
+typedef struct float64x1x3_t {
+  float64x1_t val[3];
+} float64x1x3_t;
+
+typedef struct float64x2x3_t {
+  float64x2_t val[3];
+} float64x2x3_t;
+
+#endif
+typedef struct int8x8x4_t {
+  int8x8_t val[4];
+} int8x8x4_t;
+
+typedef struct int8x16x4_t {
+  int8x16_t val[4];
+} int8x16x4_t;
+
+typedef struct int16x4x4_t {
+  int16x4_t val[4];
+} int16x4x4_t;
+
+typedef struct int16x8x4_t {
+  int16x8_t val[4];
+} int16x8x4_t;
+
+typedef struct int32x2x4_t {
+  int32x2_t val[4];
+} int32x2x4_t;
+
+typedef struct int32x4x4_t {
+  int32x4_t val[4];
+} int32x4x4_t;
+
+typedef struct int64x1x4_t {
+  int64x1_t val[4];
+} int64x1x4_t;
+
+typedef struct int64x2x4_t {
+  int64x2_t val[4];
+} int64x2x4_t;
+
+typedef struct uint8x8x4_t {
+  uint8x8_t val[4];
+} uint8x8x4_t;
+
+typedef struct uint8x16x4_t {
+  uint8x16_t val[4];
+} uint8x16x4_t;
+
+typedef struct uint16x4x4_t {
+  uint16x4_t val[4];
+} uint16x4x4_t;
+
+typedef struct uint16x8x4_t {
+  uint16x8_t val[4];
+} uint16x8x4_t;
+
+typedef struct uint32x2x4_t {
+  uint32x2_t val[4];
+} uint32x2x4_t;
+
+typedef struct uint32x4x4_t {
+  uint32x4_t val[4];
+} uint32x4x4_t;
+
+typedef struct uint64x1x4_t {
+  uint64x1_t val[4];
+} uint64x1x4_t;
+
+typedef struct uint64x2x4_t {
+  uint64x2_t val[4];
+} uint64x2x4_t;
+
+typedef struct float16x4x4_t {
+  float16x4_t val[4];
+} float16x4x4_t;
+
+typedef struct float16x8x4_t {
+  float16x8_t val[4];
+} float16x8x4_t;
+
+typedef struct float32x2x4_t {
+  float32x2_t val[4];
+} float32x2x4_t;
+
+typedef struct float32x4x4_t {
+  float32x4_t val[4];
+} float32x4x4_t;
+
+#if defined(__aarch64__) || defined(__arm64ec__)
+typedef struct float64x1x4_t {
+  float64x1_t val[4];
+} float64x1x4_t;
+
+typedef struct float64x2x4_t {
+  float64x2_t val[4];
+} float64x2x4_t;
+
+#endif
+typedef __attribute__((neon_vector_type(4))) bfloat16_t bfloat16x4_t;
+typedef __attribute__((neon_vector_type(8))) bfloat16_t bfloat16x8_t;
+
+typedef struct bfloat16x4x2_t {
+  bfloat16x4_t val[2];
+} bfloat16x4x2_t;
+
+typedef struct bfloat16x8x2_t {
+  bfloat16x8_t val[2];
+} bfloat16x8x2_t;
+
+typedef struct bfloat16x4x3_t {
+  bfloat16x4_t val[3];
+} bfloat16x4x3_t;
+
+typedef struct bfloat16x8x3_t {
+  bfloat16x8_t val[3];
+} bfloat16x8x3_t;
+
+typedef struct bfloat16x4x4_t {
+  bfloat16x4_t val[4];
+} bfloat16x4x4_t;
+
+typedef struct bfloat16x8x4_t {
+  bfloat16x8_t val[4];
+} bfloat16x8x4_t;
+
+#endif // __ARM_NEON_TYPES_H
diff --git a/third_party/aarch64/clang/armintr.h b/third_party/aarch64/clang/armintr.h
new file mode 100644
index 000000000..300ed4ee4
--- /dev/null
+++ b/third_party/aarch64/clang/armintr.h
@@ -0,0 +1,31 @@
+/*===---- armintr.h - ARM Windows intrinsics -------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+/* Only include this if we're compiling for the windows platform. */
+#ifndef _MSC_VER
+#include_next <armintr.h>
+#else
+
+#ifndef __ARMINTR_H
+#define __ARMINTR_H
+
+typedef enum
+{
+  _ARM_BARRIER_SY    = 0xF,
+  _ARM_BARRIER_ST    = 0xE,
+  _ARM_BARRIER_ISH   = 0xB,
+  _ARM_BARRIER_ISHST = 0xA,
+  _ARM_BARRIER_NSH   = 0x7,
+  _ARM_BARRIER_NSHST = 0x6,
+  _ARM_BARRIER_OSH   = 0x3,
+  _ARM_BARRIER_OSHST = 0x2
+} _ARMINTR_BARRIER_TYPE;
+
+#endif /* __ARMINTR_H */
+#endif /* _MSC_VER */
diff --git a/third_party/aarch64/openacc.internal.h b/third_party/aarch64/openacc.internal.h
deleted file mode 100644
index f42e14bb6..000000000
--- a/third_party/aarch64/openacc.internal.h
+++ /dev/null
@@ -1,111 +0,0 @@
-#if defined(__aarch64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
-#ifndef _OPENACC_H
-#define _OPENACC_H 1
-#ifdef __cplusplus
-extern "C" {
-#endif
-#if __cplusplus >= 201103
-# define __GOACC_NOTHROW noexcept
-#elif __cplusplus
-# define __GOACC_NOTHROW throw ()
-#else
-# define __GOACC_NOTHROW __attribute__ ((__nothrow__))
-#endif
-typedef enum acc_device_t {
-  acc_device_current = -1,
-  acc_device_none = 0,
-  acc_device_default = 1,
-  acc_device_host = 2,
-  acc_device_not_host = 4,
-  acc_device_nvidia = 5,
-  acc_device_radeon = 8,
-  _ACC_device_hwm,
-  _ACC_highest = __INT_MAX__,
-  _ACC_neg = -1
-} acc_device_t;
-typedef enum acc_device_property_t {
-  acc_property_memory = 1,
-  acc_property_free_memory = 2,
-  acc_property_name = 0x10001,
-  acc_property_vendor = 0x10002,
-  acc_property_driver = 0x10003
-} acc_device_property_t;
-typedef enum acc_async_t {
-  acc_async_noval = -1,
-  acc_async_sync = -2
-} acc_async_t;
-int acc_get_num_devices (acc_device_t) __GOACC_NOTHROW;
-void acc_set_device_type (acc_device_t) __GOACC_NOTHROW;
-acc_device_t acc_get_device_type (void) __GOACC_NOTHROW;
-void acc_set_device_num (int, acc_device_t) __GOACC_NOTHROW;
-int acc_get_device_num (acc_device_t) __GOACC_NOTHROW;
-size_t acc_get_property
-  (int, acc_device_t, acc_device_property_t) __GOACC_NOTHROW;
-const char *acc_get_property_string
-  (int, acc_device_t, acc_device_property_t) __GOACC_NOTHROW;
-int acc_async_test (int) __GOACC_NOTHROW;
-int acc_async_test_all (void) __GOACC_NOTHROW;
-void acc_wait (int) __GOACC_NOTHROW;
-void acc_async_wait (int) __GOACC_NOTHROW;
-void acc_wait_async (int, int) __GOACC_NOTHROW;
-void acc_wait_all (void) __GOACC_NOTHROW;
-void acc_async_wait_all (void) __GOACC_NOTHROW;
-void acc_wait_all_async (int) __GOACC_NOTHROW;
-void acc_init (acc_device_t) __GOACC_NOTHROW;
-void acc_shutdown (acc_device_t) __GOACC_NOTHROW;
-#ifdef __cplusplus
-int acc_on_device (int __arg) __GOACC_NOTHROW;
-#else
-int acc_on_device (acc_device_t __arg) __GOACC_NOTHROW;
-#endif
-void *acc_malloc (size_t) __GOACC_NOTHROW;
-void acc_free (void *) __GOACC_NOTHROW;
-void *acc_copyin (void *, size_t) __GOACC_NOTHROW;
-void *acc_present_or_copyin (void *, size_t) __GOACC_NOTHROW;
-void *acc_pcopyin (void *, size_t) __GOACC_NOTHROW;
-void *acc_create (void *, size_t) __GOACC_NOTHROW;
-void *acc_present_or_create (void *, size_t) __GOACC_NOTHROW;
-void *acc_pcreate (void *, size_t) __GOACC_NOTHROW;
-void acc_copyout (void *, size_t) __GOACC_NOTHROW;
-void acc_delete (void *, size_t) __GOACC_NOTHROW;
-void acc_update_device (void *, size_t) __GOACC_NOTHROW;
-void acc_update_self (void *, size_t) __GOACC_NOTHROW;
-void acc_map_data (void *, void *, size_t) __GOACC_NOTHROW;
-void acc_unmap_data (void *) __GOACC_NOTHROW;
-void *acc_deviceptr (void *) __GOACC_NOTHROW;
-void *acc_hostptr (void *) __GOACC_NOTHROW;
-int acc_is_present (void *, size_t) __GOACC_NOTHROW;
-void acc_memcpy_to_device (void *, void *, size_t) __GOACC_NOTHROW;
-void acc_memcpy_from_device (void *, void *, size_t) __GOACC_NOTHROW;
-void acc_attach (void **) __GOACC_NOTHROW;
-void acc_attach_async (void **, int) __GOACC_NOTHROW;
-void acc_detach (void **) __GOACC_NOTHROW;
-void acc_detach_async (void **, int) __GOACC_NOTHROW;
-void acc_copyout_finalize (void *, size_t) __GOACC_NOTHROW;
-void acc_copyout_finalize_async (void *, size_t, int) __GOACC_NOTHROW;
-void acc_delete_finalize (void *, size_t) __GOACC_NOTHROW;
-void acc_delete_finalize_async (void *, size_t, int) __GOACC_NOTHROW;
-void acc_detach_finalize (void **) __GOACC_NOTHROW;
-void acc_detach_finalize_async (void **, int) __GOACC_NOTHROW;
-void acc_copyin_async (void *, size_t, int) __GOACC_NOTHROW;
-void acc_create_async (void *, size_t, int) __GOACC_NOTHROW;
-void acc_copyout_async (void *, size_t, int) __GOACC_NOTHROW;
-void acc_delete_async (void *, size_t, int) __GOACC_NOTHROW;
-void acc_update_device_async (void *, size_t, int) __GOACC_NOTHROW;
-void acc_update_self_async (void *, size_t, int) __GOACC_NOTHROW;
-void acc_memcpy_to_device_async (void *, void *, size_t, int) __GOACC_NOTHROW;
-void acc_memcpy_from_device_async (void *, void *, size_t, int) __GOACC_NOTHROW;
-void *acc_get_current_cuda_device (void) __GOACC_NOTHROW;
-void *acc_get_current_cuda_context (void) __GOACC_NOTHROW;
-void *acc_get_cuda_stream (int) __GOACC_NOTHROW;
-int acc_set_cuda_stream (int, void *) __GOACC_NOTHROW;
-#ifdef __cplusplus
-}
-#pragma acc routine seq
-inline int acc_on_device (acc_device_t __arg) __GOACC_NOTHROW
-{
-  return acc_on_device ((int) __arg);
-}
-#endif
-#endif
-#endif
diff --git a/third_party/aarch64/upgrade.sh b/third_party/aarch64/upgrade.sh
index 1e4e6c5b7..083af0c1a 100755
--- a/third_party/aarch64/upgrade.sh
+++ b/third_party/aarch64/upgrade.sh
@@ -13,17 +13,15 @@
 # 3. You should fix up the `#pragma GCC aarch64` things.
 #
 
-s=/opt/goodies/include
+s=/opt/include
 d=third_party/aarch64
 
 FILES='
-acc_prof
 arm_acle
 arm_bf16
 arm_fp16
 arm_neon
 arm_sve
-openacc
 '
 
 strip_c_comments() {
diff --git a/third_party/awk/BUILD.mk b/third_party/awk/BUILD.mk
index 42ea4aad8..da4affc22 100644
--- a/third_party/awk/BUILD.mk
+++ b/third_party/awk/BUILD.mk
@@ -22,10 +22,12 @@ THIRD_PARTY_AWK_A_DIRECTDEPS =				\
 	LIBC_RUNTIME					\
 	LIBC_STDIO					\
 	LIBC_STR					\
+	LIBC_SYSTEM					\
 	LIBC_SYSV					\
 	LIBC_TINYMATH					\
+	THIRD_PARTY_GDTOA				\
+	THIRD_PARTY_MUSL				\
 	TOOL_ARGS					\
-	THIRD_PARTY_GDTOA
 
 THIRD_PARTY_AWK_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_AWK_A_DIRECTDEPS),$($(x))))
diff --git a/third_party/awk/cmd.c b/third_party/awk/cmd.c
index 54882575f..78ca032e8 100644
--- a/third_party/awk/cmd.c
+++ b/third_party/awk/cmd.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/awk/cmd.h"
-#include "tool/args/args.h"
+#include "libc/cosmo.h"
 
 int main(int argc, char *argv[]) {
   LoadZipArgs(&argc, &argv);
diff --git a/third_party/awk/run.c b/third_party/awk/run.c
index e0ab6208d..4d5b28aef 100644
--- a/third_party/awk/run.c
+++ b/third_party/awk/run.c
@@ -495,7 +495,7 @@ makearraystring(Node *p, const char *func)
 
 		if (!adjbuf(&buf, &bufsz, tlen + 1, recsize, 0, func)) {
 			FATAL("%s: out of memory %s[%s...]",
-			    func, x->nval, buf);
+			      func ? func : "NULL", x->nval, buf);
 		}
 		memcpy(buf + blen, s, slen);
 		if (nsub) {
diff --git a/third_party/bash/BUILD.mk b/third_party/bash/BUILD.mk
deleted file mode 100644
index 03c4cb94a..000000000
--- a/third_party/bash/BUILD.mk
+++ /dev/null
@@ -1,99 +0,0 @@
-#-*-mode:bashfile-gbash;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
-#── vi: set noet ft=bash ts=8 sw=8 fenc=utf-8 :vi ────────────────────┘
-
-PKGS += THIRD_PARTY_BASH
-
-THIRD_PARTY_BASH_A = o/$(MODE)/third_party/bash/bash.a
-THIRD_PARTY_BASH_FILES := $(wildcard third_party/bash/*)
-THIRD_PARTY_BASH_HDRS = $(filter %.h,$(THIRD_PARTY_BASH_FILES))
-THIRD_PARTY_BASH_INCS = $(filter %.inc,$(THIRD_PARTY_BASH_FILES))
-THIRD_PARTY_BASH_SRCS = $(filter %.c,$(THIRD_PARTY_BASH_FILES))
-THIRD_PARTY_BASH_OBJS = $(THIRD_PARTY_BASH_SRCS:%.c=o/$(MODE)/%.o)
-THIRD_PARTY_BASH_COMS = o/$(MODE)/third_party/bash/bash
-THIRD_PARTY_BASH_CHECKS = $(THIRD_PARTY_BASH_A).pkg
-
-THIRD_PARTY_BASH_BINS =							\
-	$(THIRD_PARTY_BASH_COMS)					\
-	$(THIRD_PARTY_BASH_COMS:%=%.dbg)
-
-THIRD_PARTY_BASH_DIRECTDEPS =						\
-	LIBC_CALLS							\
-	LIBC_FMT							\
-	LIBC_INTRIN							\
-	LIBC_MEM							\
-	LIBC_NEXGEN32E							\
-	LIBC_PROC							\
-	LIBC_RUNTIME							\
-	LIBC_SOCK							\
-	LIBC_STDIO							\
-	LIBC_STR							\
-	LIBC_SYSV							\
-	LIBC_THREAD							\
-	THIRD_PARTY_COMPILER_RT						\
-	THIRD_PARTY_GDTOA						\
-	THIRD_PARTY_GETOPT						\
-	THIRD_PARTY_MUSL						\
-	THIRD_PARTY_NCURSES						\
-	THIRD_PARTY_READLINE						\
-	THIRD_PARTY_REGEX						\
-	THIRD_PARTY_TZ
-
-THIRD_PARTY_BASH_DEPS :=						\
-	$(call uniq,$(foreach x,$(THIRD_PARTY_BASH_DIRECTDEPS),$($(x))))
-
-$(THIRD_PARTY_BASH_A).pkg:						\
-	$(THIRD_PARTY_BASH_OBJS)					\
-	$(foreach x,$(THIRD_PARTY_BASH_DIRECTDEPS),$($(x)_A).pkg)
-
-$(THIRD_PARTY_BASH_A):							\
-	third_party/bash/						\
-	$(THIRD_PARTY_BASH_A).pkg					\
-	$(filter-out %main.o,$(THIRD_PARTY_BASH_OBJS))
-
-o/$(MODE)/third_party/bash/bash.dbg:					\
-		$(THIRD_PARTY_BASH_DEPS)				\
-		$(THIRD_PARTY_BASH_A)					\
-		$(THIRD_PARTY_BASH_A).pkg				\
-		o/$(MODE)/third_party/bash/shell.o			\
-		$(CRT)							\
-		$(APE_NO_MODIFY_SELF)
-	@$(APELINK)
-
-$(THIRD_PARTY_BASH_OBJS): private					\
-		CPPFLAGS +=						\
-			-DHAVE_CONFIG_H					\
-			-DSHELL						\
-			-DPACKAGE=\"bash\"				\
-			-DLOCALEDIR=\"/zip/usr/share/locale\"		\
-			-DCONF_HOSTTYPE=\"unknown\"			\
-			-DCONF_OSTYPE=\"linux-cosmo\"			\
-			-DCONF_MACHTYPE=\"unknown-pc-unknown-cosmo\"	\
-			-DCONF_VENDOR=\"pc\"
-
-$(THIRD_PARTY_BASH_OBJS): private					\
-		CFLAGS +=						\
-			-Wno-unused-but-set-variable			\
-			-Wno-discarded-qualifiers			\
-			-Wno-maybe-uninitialized			\
-			-Wno-pointer-to-int-cast			\
-			-Wno-stringop-truncation			\
-			-Wno-format-zero-length				\
-			-Wno-format-overflow				\
-			-Wno-char-subscripts				\
-			-Wno-nonnull-compare				\
-			-Wno-unused-variable				\
-			-Wno-missing-braces				\
-			-Wno-use-after-free				\
-			-Wno-unused-label				\
-			-Wno-unused-value				\
-			-Wno-return-type				\
-			-Wno-parentheses				\
-			-fportcosmo
-
-$(THIRD_PARTY_BASH_OBJS): third_party/bash/BUILD.mk
-
-.PHONY: o/$(MODE)/third_party/bash
-o/$(MODE)/third_party/bash:						\
-		$(THIRD_PARTY_BASH_BINS)				\
-		$(THIRD_PARTY_BASH_CHECKS)
-
diff --git a/third_party/bash/LICENSE b/third_party/bash/LICENSE
deleted file mode 100644
index 94a9ed024..000000000
--- a/third_party/bash/LICENSE
+++ /dev/null
@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/third_party/bash/README.cosmo b/third_party/bash/README.cosmo
deleted file mode 100644
index f56894f1b..000000000
--- a/third_party/bash/README.cosmo
+++ /dev/null
@@ -1,16 +0,0 @@
-DESCRIPTION
-
-  the bourne again shell
-
-LICENSE
-
-  GPL v3
-
-ORIGIN
-
-  https://ftp.gnu.org/gnu/bash/bash-5.2.tar.gz
-
-LOCAL CHANGES
-
-  - Force disable mkfifo() code
-  - Added runtime check for broken BSD /dev/fd stuff
diff --git a/third_party/bash/alias.c b/third_party/bash/alias.c
deleted file mode 100644
index 23f967fa8..000000000
--- a/third_party/bash/alias.c
+++ /dev/null
@@ -1,594 +0,0 @@
-/* alias.c -- Not a full alias, but just the kind that we use in the
-   shell.  Csh style alias is somewhere else (`over there, in a box'). */
-
-/* Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (ALIAS)
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "chartypes.h"
-#include "bashansi.h"
-#include "command.h"
-#include "general.h"
-#include "externs.h"
-#include "alias.h"
-
-#if defined (PROGRAMMABLE_COMPLETION)
-#  include "pcomplete.h"
-#endif
-
-#if defined (HAVE_MBSTR_H) && defined (HAVE_MBSCHR)
-#  include <mbstr.h>		/* mbschr */
-#endif
-
-#define ALIAS_HASH_BUCKETS	64	/* must be power of two */
-
-typedef int sh_alias_map_func_t PARAMS((alias_t *));
-
-static void free_alias_data PARAMS((PTR_T));
-static alias_t **map_over_aliases PARAMS((sh_alias_map_func_t *));
-static void sort_aliases PARAMS((alias_t **));
-static int qsort_alias_compare PARAMS((alias_t **, alias_t **));
-
-#if defined (READLINE)
-static int skipquotes PARAMS((char *, int));
-static int skipws PARAMS((char *, int));
-static int rd_token PARAMS((char *, int));
-#endif
-
-/* Non-zero means expand all words on the line.  Otherwise, expand
-   after first expansion if the expansion ends in a space. */
-int alias_expand_all = 0;
-
-/* The list of aliases that we have. */
-HASH_TABLE *aliases = (HASH_TABLE *)NULL;
-
-void
-initialize_aliases ()
-{
-  if (aliases == 0)
-    aliases = hash_create (ALIAS_HASH_BUCKETS);
-}
-
-/* Scan the list of aliases looking for one with NAME.  Return NULL
-   if the alias doesn't exist, else a pointer to the alias_t. */
-alias_t *
-find_alias (name)
-     char *name;
-{
-  BUCKET_CONTENTS *al;
-
-  if (aliases == 0)
-    return ((alias_t *)NULL);
-
-  al = hash_search (name, aliases, 0);
-  return (al ? (alias_t *)al->data : (alias_t *)NULL);
-}
-
-/* Return the value of the alias for NAME, or NULL if there is none. */
-char *
-get_alias_value (name)
-     char *name;
-{
-  alias_t *alias;
-
-  if (aliases == 0)
-    return ((char *)NULL);
-
-  alias = find_alias (name);
-  return (alias ? alias->value : (char *)NULL);
-}
-
-/* Make a new alias from NAME and VALUE.  If NAME can be found,
-   then replace its value. */
-void
-add_alias (name, value)
-     char *name, *value;
-{
-  BUCKET_CONTENTS *elt;
-  alias_t *temp;
-  int n;
-
-  if (aliases == 0)
-    {
-      initialize_aliases ();
-      temp = (alias_t *)NULL;
-    }
-  else
-    temp = find_alias (name);
-
-  if (temp)
-    {
-      free (temp->value);
-      temp->value = savestring (value);
-      temp->flags &= ~AL_EXPANDNEXT;
-      if (value[0])
-	{
-	  n = value[strlen (value) - 1];
-	  if (n == ' ' || n == '\t')
-	    temp->flags |= AL_EXPANDNEXT;
-	}
-    }
-  else
-    {
-      temp = (alias_t *)xmalloc (sizeof (alias_t));
-      temp->name = savestring (name);
-      temp->value = savestring (value);
-      temp->flags = 0;
-
-      if (value[0])
-	{
-	  n = value[strlen (value) - 1];
-	  if (n == ' ' || n == '\t')
-	    temp->flags |= AL_EXPANDNEXT;
-	}
-
-      elt = hash_insert (savestring (name), aliases, HASH_NOSRCH);
-      elt->data = temp;
-#if defined (PROGRAMMABLE_COMPLETION)
-      set_itemlist_dirty (&it_aliases);
-#endif
-    }
-}
-
-/* Delete a single alias structure. */
-static void
-free_alias_data (data)
-     PTR_T data;
-{
-  register alias_t *a;
-
-  a = (alias_t *)data;
-
-  if (a->flags & AL_BEINGEXPANDED)
-    clear_string_list_expander (a);	/* call back to the parser */
-
-  free (a->value);
-  free (a->name);
-  free (data);
-}
-
-/* Remove the alias with name NAME from the alias table.  Returns
-   the number of aliases left in the table, or -1 if the alias didn't
-   exist. */
-int
-remove_alias (name)
-     char *name;
-{
-  BUCKET_CONTENTS *elt;
-
-  if (aliases == 0)
-    return (-1);
-
-  elt = hash_remove (name, aliases, 0);
-  if (elt)
-    {
-      free_alias_data (elt->data);
-      free (elt->key);		/* alias name */
-      free (elt);		/* XXX */
-#if defined (PROGRAMMABLE_COMPLETION)
-      set_itemlist_dirty (&it_aliases);
-#endif
-      return (aliases->nentries);
-    }
-  return (-1);
-}
-
-/* Delete all aliases. */
-void
-delete_all_aliases ()
-{
-  if (aliases == 0)
-    return;
-
-  hash_flush (aliases, free_alias_data);
-  hash_dispose (aliases);
-  aliases = (HASH_TABLE *)NULL;
-#if defined (PROGRAMMABLE_COMPLETION)
-  set_itemlist_dirty (&it_aliases);
-#endif
-}
-
-/* Return an array of aliases that satisfy the conditions tested by FUNCTION.
-   If FUNCTION is NULL, return all aliases. */
-static alias_t **
-map_over_aliases (function)
-     sh_alias_map_func_t *function;
-{
-  register int i;
-  register BUCKET_CONTENTS *tlist;
-  alias_t *alias, **list;
-  int list_index;
-
-  i = HASH_ENTRIES (aliases);
-  if (i == 0)
-    return ((alias_t **)NULL);
-
-  list = (alias_t **)xmalloc ((i + 1) * sizeof (alias_t *));
-  for (i = list_index = 0; i < aliases->nbuckets; i++)
-    {
-      for (tlist = hash_items (i, aliases); tlist; tlist = tlist->next)
-	{
-	  alias = (alias_t *)tlist->data;
-
-	  if (!function || (*function) (alias))
-	    {
-	      list[list_index++] = alias;
-	      list[list_index] = (alias_t *)NULL;
-	    }
-	}
-    }
-  return (list);
-}
-
-static void
-sort_aliases (array)
-     alias_t **array;
-{
-  qsort (array, strvec_len ((char **)array), sizeof (alias_t *), (QSFUNC *)qsort_alias_compare);
-}
-
-static int
-qsort_alias_compare (as1, as2)
-     alias_t **as1, **as2;
-{
-  int result;
-
-  if ((result = (*as1)->name[0] - (*as2)->name[0]) == 0)
-    result = strcmp ((*as1)->name, (*as2)->name);
-
-  return (result);
-}
-
-/* Return a sorted list of all defined aliases */
-alias_t **
-all_aliases ()
-{
-  alias_t **list;
-
-  if (aliases == 0 || HASH_ENTRIES (aliases) == 0)
-    return ((alias_t **)NULL);
-
-  list = map_over_aliases ((sh_alias_map_func_t *)NULL);
-  if (list)
-    sort_aliases (list);
-  return (list);
-}
-
-char *
-alias_expand_word (s)
-     char *s;
-{
-  alias_t *r;
-
-  r = find_alias (s);
-  return (r ? savestring (r->value) : (char *)NULL);
-}
-
-/* Readline support functions -- expand all aliases in a line. */
-
-#if defined (READLINE)
-
-/* Return non-zero if CHARACTER is a member of the class of characters
-   that are self-delimiting in the shell (this really means that these
-   characters delimit tokens). */
-#define self_delimiting(character) (member ((character), " \t\n\r;|&()"))
-
-/* Return non-zero if CHARACTER is a member of the class of characters
-   that delimit commands in the shell. */
-#define command_separator(character) (member ((character), "\r\n;|&("))
-
-/* If this is 1, we are checking the next token read for alias expansion
-   because it is the first word in a command. */
-static int command_word;
-
-/* This is for skipping quoted strings in alias expansions. */
-#define quote_char(c)  (((c) == '\'') || ((c) == '"'))
-
-/* Consume a quoted string from STRING, starting at string[START] (so
-   string[START] is the opening quote character), and return the index
-   of the closing quote character matching the opening quote character.
-   This handles single matching pairs of unquoted quotes; it could afford
-   to be a little smarter... This skips words between balanced pairs of
-   quotes, words where the first character is quoted with a `\', and other
-   backslash-escaped characters. */
-
-static int
-skipquotes (string, start)
-     char *string;
-     int start;
-{
-  register int i;
-  int delimiter = string[start];
-
-  /* i starts at START + 1 because string[START] is the opening quote
-     character. */
-  for (i = start + 1 ; string[i] ; i++)
-    {
-      if (string[i] == '\\')
-	{
-	  i++;		/* skip backslash-quoted quote characters, too */
-	  if (string[i] == 0)
-	    break;
-	  continue;
-	}
-
-      if (string[i] == delimiter)
-	return i;
-    }
-  return (i);
-}
-
-/* Skip the white space and any quoted characters in STRING, starting at
-   START.  Return the new index into STRING, after zero or more characters
-   have been skipped. */
-static int
-skipws (string, start)
-     char *string;
-     int start;
-{
-  register int i;
-  int pass_next, backslash_quoted_word;
-  unsigned char peekc;
-
-  /* skip quoted strings, in ' or ", and words in which a character is quoted
-     with a `\'. */
-  i = backslash_quoted_word = pass_next = 0;
-
-  /* Skip leading whitespace (or separator characters), and quoted words.
-     But save it in the output.  */
-
-  for (i = start; string[i]; i++)
-    {
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  continue;
-	}
-
-      if (whitespace (string[i]))
-	{
-	  backslash_quoted_word = 0; /* we are no longer in a backslash-quoted word */
-	  continue;
-	}
-
-      if (string[i] == '\\')
-	{
-	  peekc = string[i+1];
-	  if (peekc == 0)
-	    break;
-	  if (ISLETTER (peekc))
-	    backslash_quoted_word++;	/* this is a backslash-quoted word */
-	  else
-	    pass_next++;
-	  continue;
-	}
-
-      /* This only handles single pairs of non-escaped quotes.  This
-	 overloads backslash_quoted_word to also mean that a word like
-	 ""f is being scanned, so that the quotes will inhibit any expansion
-	 of the word. */
-      if (quote_char(string[i]))
-	{
-	  i = skipquotes (string, i);
-	  /* This could be a line that contains a single quote character,
-	     in which case skipquotes () terminates with string[i] == '\0'
-	     (the end of the string).  Check for that here. */
-	  if (string[i] == '\0')
-	    break;
-
-	  peekc = string[i + 1];
-	  if (ISLETTER (peekc))
-	    backslash_quoted_word++;
-	  continue;
-	}
-
-      /* If we're in the middle of some kind of quoted word, let it
-	 pass through. */
-      if (backslash_quoted_word)
-	continue;
-
-      /* If this character is a shell command separator, then set a hint for
-	 alias_expand that the next token is the first word in a command. */
-
-      if (command_separator (string[i]))
-	{
-	  command_word++;
-	  continue;
-	}
-      break;
-    }
-  return (i);
-}
-
-/* Characters that may appear in a token.  Basically, anything except white
-   space and a token separator. */
-#define token_char(c)	(!((whitespace (string[i]) || self_delimiting (string[i]))))
-
-/* Read from START in STRING until the next separator character, and return
-   the index of that separator.  Skip backslash-quoted characters.  Call
-   skipquotes () for quoted strings in the middle or at the end of tokens,
-   so all characters show up (e.g. foo'' and foo""bar) */
-static int
-rd_token (string, start)
-     char *string;
-     int start;
-{
-  register int i;
-
-  /* From here to next separator character is a token. */
-  for (i = start; string[i] && token_char (string[i]); i++)
-    {
-      if (string[i] == '\\')
-	{
-	  i++;	/* skip backslash-escaped character */
-	  if (string[i] == 0)
-	    break;
-	  continue;
-	}
-
-      /* If this character is a quote character, we want to call skipquotes
-	 to get the whole quoted portion as part of this word.  That word
-	 will not generally match an alias, even if te unquoted word would
-	 have.  The presence of the quotes in the token serves then to
-	 inhibit expansion. */
-      if (quote_char (string[i]))
-	{
-	  i = skipquotes (string, i);
-	  /* This could be a line that contains a single quote character,
-	     in which case skipquotes () terminates with string[i] == '\0'
-	     (the end of the string).  Check for that here. */
-	  if (string[i] == '\0')
-	    break;
-
-	  /* Now string[i] is the matching quote character, and the
-	     quoted portion of the token has been scanned. */
-	  continue;
-	}
-    }
-  return (i);
-}
-
-/* Return a new line, with any aliases substituted. */
-char *
-alias_expand (string)
-     char *string;
-{
-  register int i, j, start;
-  char *line, *token;
-  int line_len, tl, real_start, expand_next, expand_this_token;
-  alias_t *alias;
-
-  line_len = strlen (string) + 1;
-  line = (char *)xmalloc (line_len);
-  token = (char *)xmalloc (line_len);
-
-  line[0] = i = 0;
-  expand_next = 0;
-  command_word = 1; /* initialized to expand the first word on the line */
-
-  /* Each time through the loop we find the next word in line.  If it
-     has an alias, substitute the alias value.  If the value ends in ` ',
-     then try again with the next word.  Else, if there is no value, or if
-     the value does not end in space, we are done. */
-
-  for (;;)
-    {
-
-      token[0] = 0;
-      start = i;
-
-      /* Skip white space and quoted characters */
-      i = skipws (string, start);
-
-      if (start == i && string[i] == '\0')
-	{
-	  free (token);
-	  return (line);
-	}
-
-      /* copy the just-skipped characters into the output string,
-	 expanding it if there is not enough room. */
-      j = strlen (line);
-      tl = i - start;	/* number of characters just skipped */
-      RESIZE_MALLOCED_BUFFER (line, j, (tl + 1), line_len, (tl + 50));
-      strncpy (line + j, string + start, tl);
-      line[j + tl] = '\0';
-
-      real_start = i;
-
-      command_word = command_word || (command_separator (string[i]));
-      expand_this_token = (command_word || expand_next);
-      expand_next = 0;
-
-      /* Read the next token, and copy it into TOKEN. */
-      start = i;
-      i = rd_token (string, start);
-
-      tl = i - start;	/* token length */
-
-      /* If tl == 0, but we're not at the end of the string, then we have a
-	 single-character token, probably a delimiter */
-      if (tl == 0 && string[i] != '\0')
-	{
-	  tl = 1;
-	  i++;		/* move past it */
-	}
-
-      strncpy (token, string + start, tl);
-      token [tl] = '\0';
-
-      /* If there is a backslash-escaped character quoted in TOKEN,
-	 then we don't do alias expansion.  This should check for all
-	 other quoting characters, too. */
-      if (mbschr (token, '\\'))
-	expand_this_token = 0;
-
-      /* If we should be expanding here, if we are expanding all words, or if
-	 we are in a location in the string where an expansion is supposed to
-	 take place, see if this word has a substitution.  If it does, then do
-	 the expansion.  Note that we defer the alias value lookup until we
-	 are sure we are expanding this token. */
-
-      if ((token[0]) &&
-	  (expand_this_token || alias_expand_all) &&
-	  (alias = find_alias (token)))
-	{
-	  char *v;
-	  int vlen, llen;
-
-	  v = alias->value;
-	  vlen = strlen (v);
-	  llen = strlen (line);
-
-	  /* +3 because we possibly add one more character below. */
-	  RESIZE_MALLOCED_BUFFER (line, llen, (vlen + 3), line_len, (vlen + 50));
-
-	  strcpy (line + llen, v);
-
-	  if ((expand_this_token && vlen && whitespace (v[vlen - 1])) ||
-	      alias_expand_all)
-	    expand_next = 1;
-	}
-      else
-	{
-	  int llen, tlen;
-
-	  llen = strlen (line);
-	  tlen = i - real_start; /* tlen == strlen(token) */
-
-	  RESIZE_MALLOCED_BUFFER (line, llen, (tlen + 1), line_len, (llen + tlen + 50));
-
-	  strncpy (line + llen, string + real_start, tlen);
-	  line[llen + tlen] = '\0';
-	}
-      command_word = 0;
-    }
-}
-#endif /* READLINE */
-#endif /* ALIAS */
diff --git a/third_party/bash/alias.h b/third_party/bash/alias.h
deleted file mode 100644
index 4e2d67c0f..000000000
--- a/third_party/bash/alias.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/* alias.h -- structure definitions. */
-
-/* Copyright (C) 1987-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_ALIAS_H_)
-#define _ALIAS_H_
-
-#include "stdc.h"
-
-#include "hashlib.h"
-
-typedef struct alias {
-  char *name;
-  char *value;
-  char flags;
-} alias_t;
-
-/* Values for `flags' member of struct alias. */
-#define AL_EXPANDNEXT		0x1
-#define AL_BEINGEXPANDED	0x2
-
-/* The list of known aliases. */
-extern HASH_TABLE *aliases;
-
-extern void initialize_aliases PARAMS((void));
-
-/* Scan the list of aliases looking for one with NAME.  Return NULL
-   if the alias doesn't exist, else a pointer to the alias. */
-extern alias_t *find_alias PARAMS((char *));
-
-/* Return the value of the alias for NAME, or NULL if there is none. */
-extern char *get_alias_value PARAMS((char *));
-
-/* Make a new alias from NAME and VALUE.  If NAME can be found,
-   then replace its value. */
-extern void add_alias PARAMS((char *, char *));
-
-/* Remove the alias with name NAME from the alias list.  Returns
-   the index of the removed alias, or -1 if the alias didn't exist. */
-extern int remove_alias PARAMS((char *));
-
-/* Remove all aliases. */
-extern void delete_all_aliases PARAMS((void));
-
-/* Return an array of all defined aliases. */
-extern alias_t **all_aliases PARAMS((void));
-
-/* Expand a single word for aliases. */
-extern char *alias_expand_word PARAMS((char *));
-
-/* Return a new line, with any aliases expanded. */
-extern char *alias_expand PARAMS((char *));
-
-/* Helper definition for the parser */
-extern void clear_string_list_expander PARAMS((alias_t *));
-
-#endif /* _ALIAS_H_ */
diff --git a/third_party/bash/ansi_stdlib.h b/third_party/bash/ansi_stdlib.h
deleted file mode 100644
index 7dc2ee0cf..000000000
--- a/third_party/bash/ansi_stdlib.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/* ansi_stdlib.h -- An ANSI Standard stdlib.h. */
-/* A minimal stdlib.h containing extern declarations for those functions
-   that bash uses. */
-
-/* Copyright (C) 1993 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_STDLIB_H_)
-#define	_STDLIB_H_ 1
-
-/* String conversion functions. */
-extern int atoi ();
-
-extern double atof ();
-extern double strtod ();
-
-/* Memory allocation functions. */
-/* Generic pointer type. */
-#ifndef PTR_T
-
-#if defined (__STDC__)
-#  define PTR_T	void *
-#else
-#  define PTR_T char *
-#endif
-
-#endif /* PTR_T */
-
-extern PTR_T malloc ();
-extern PTR_T realloc ();
-extern void free ();
-
-/* Other miscellaneous functions. */
-extern void abort ();
-extern void exit ();
-extern char *getenv ();
-extern void qsort ();
-
-#endif /* _STDLIB_H  */
diff --git a/third_party/bash/array.c b/third_party/bash/array.c
deleted file mode 100644
index 39a0ef51b..000000000
--- a/third_party/bash/array.c
+++ /dev/null
@@ -1,1303 +0,0 @@
-/*
- * array.c - functions to create, destroy, access, and manipulate arrays
- *	     of strings.
- *
- * Arrays are sparse doubly-linked lists.  An element's index is stored
- * with it.
- *
- * Chet Ramey
- * chet@ins.cwru.edu
- */
-
-/* Copyright (C) 1997-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (ARRAY_VARS)
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "bashansi.h"
-
-#include "shell.h"
-#include "array.h"
-#include "common.h"
-
-#define ADD_BEFORE(ae, new) \
-	do { \
-		ae->prev->next = new; \
-		new->prev = ae->prev; \
-		ae->prev = new; \
-		new->next = ae; \
-	} while(0)
-	
-#define ADD_AFTER(ae, new) \
-	do { \
-		ae->next->prev = new; \
-		new->next = ae->next; \
-		new->prev = ae; \
-		ae->next = new; \
-	} while (0)
-
-static char *array_to_string_internal PARAMS((ARRAY_ELEMENT *, ARRAY_ELEMENT *, char *, int));
-
-static char *spacesep = " ";
-
-#define IS_LASTREF(a)	(a->lastref)
-
-#define LASTREF_START(a, i) \
-	(IS_LASTREF(a) && i >= element_index(a->lastref)) ? a->lastref \
-						          : element_forw(a->head)
-
-#define LASTREF(a)	(a->lastref ? a->lastref : element_forw(a->head))
-
-#define INVALIDATE_LASTREF(a)	a->lastref = 0
-#define SET_LASTREF(a, e)	a->lastref = (e)
-#define UNSET_LASTREF(a)	a->lastref = 0;
-
-ARRAY *
-array_create()
-{
-	ARRAY	*r;
-	ARRAY_ELEMENT	*head;
-
-	r = (ARRAY *)xmalloc(sizeof(ARRAY));
-	r->max_index = -1;
-	r->num_elements = 0;
-	r->lastref = (ARRAY_ELEMENT *)0;
-	head = array_create_element(-1, (char *)NULL);	/* dummy head */
-	head->prev = head->next = head;
-	r->head = head;
-	return(r);
-}
-
-void
-array_flush (a)
-ARRAY	*a;
-{
-	register ARRAY_ELEMENT *r, *r1;
-
-	if (a == 0)
-		return;
-	for (r = element_forw(a->head); r != a->head; ) {
-		r1 = element_forw(r);
-		array_dispose_element(r);
-		r = r1;
-	}
-	a->head->next = a->head->prev = a->head;
-	a->max_index = -1;
-	a->num_elements = 0;
-	INVALIDATE_LASTREF(a);
-}
-
-void
-array_dispose(a)
-ARRAY	*a;
-{
-	if (a == 0)
-		return;
-	array_flush (a);
-	array_dispose_element(a->head);
-	free(a);
-}
-
-ARRAY *
-array_copy(a)
-ARRAY	*a;
-{
-	ARRAY	*a1;
-	ARRAY_ELEMENT	*ae, *new;
-
-	if (a == 0)
-		return((ARRAY *) NULL);
-	a1 = array_create();
-	a1->max_index = a->max_index;
-	a1->num_elements = a->num_elements;
-	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae)) {
-		new = array_create_element(element_index(ae), element_value(ae));
-		ADD_BEFORE(a1->head, new);
-		if (ae == LASTREF(a))
-			SET_LASTREF(a1, new);
-	}
-	return(a1);
-}
-
-/*
- * Make and return a new array composed of the elements in array A from
- * S to E, inclusive.
- */
-ARRAY *
-array_slice(array, s, e)
-ARRAY		*array;
-ARRAY_ELEMENT	*s, *e;
-{
-	ARRAY	*a;
-	ARRAY_ELEMENT *p, *n;
-	int	i;
-	arrayind_t mi;
-
-	a = array_create ();
-
-	for (mi = 0, p = s, i = 0; p != e; p = element_forw(p), i++) {
-		n = array_create_element (element_index(p), element_value(p));
-		ADD_BEFORE(a->head, n);
-		mi = element_index(n);
-	}
-	a->num_elements = i;
-	a->max_index = mi;
-	return a;
-}
-
-/*
- * Walk the array, calling FUNC once for each element, with the array
- * element as the argument.
- */
-void
-array_walk(a, func, udata)
-ARRAY	*a;
-sh_ae_map_func_t *func;
-void	*udata;
-{
-	register ARRAY_ELEMENT *ae;
-
-	if (a == 0 || array_empty(a))
-		return;
-	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae))
-		if ((*func)(ae, udata) < 0)
-			return;
-}
-
-/*
- * Shift the array A N elements to the left.  Delete the first N elements
- * and subtract N from the indices of the remaining elements.  If FLAGS
- * does not include AS_DISPOSE, this returns a singly-linked null-terminated
- * list of elements so the caller can dispose of the chain.  If FLAGS
- * includes AS_DISPOSE, this function disposes of the shifted-out elements
- * and returns NULL.
- */
-ARRAY_ELEMENT *
-array_shift(a, n, flags)
-ARRAY	*a;
-int	n, flags;
-{
-	register ARRAY_ELEMENT *ae, *ret;
-	register int i;
-
-	if (a == 0 || array_empty(a) || n <= 0)
-		return ((ARRAY_ELEMENT *)NULL);
-
-	INVALIDATE_LASTREF(a);
-	for (i = 0, ret = ae = element_forw(a->head); ae != a->head && i < n; ae = element_forw(ae), i++)
-		;
-	if (ae == a->head) {
-		/* Easy case; shifting out all of the elements */
-		if (flags & AS_DISPOSE) {
-			array_flush (a);
-			return ((ARRAY_ELEMENT *)NULL);
-		}
-		for (ae = ret; element_forw(ae) != a->head; ae = element_forw(ae))
-			;
-		element_forw(ae) = (ARRAY_ELEMENT *)NULL;
-		a->head->next = a->head->prev = a->head;
-		a->max_index = -1;
-		a->num_elements = 0;
-		return ret;
-	}
-	/*
-	 * ae now points to the list of elements we want to retain.
-	 * ret points to the list we want to either destroy or return.
-	 */
-	ae->prev->next = (ARRAY_ELEMENT *)NULL;		/* null-terminate RET */
-
-	a->head->next = ae;		/* slice RET out of the array */
-	ae->prev = a->head;
-
-	for ( ; ae != a->head; ae = element_forw(ae))
-		element_index(ae) -= n;	/* renumber retained indices */
-
-	a->num_elements -= n;		/* modify bookkeeping information */
-	a->max_index = element_index(a->head->prev);
-
-	if (flags & AS_DISPOSE) {
-		for (ae = ret; ae; ) {
-			ret = element_forw(ae);
-			array_dispose_element(ae);
-			ae = ret;
-		}
-		return ((ARRAY_ELEMENT *)NULL);
-	}
-
-	return ret;
-}
-
-/*
- * Shift array A right N indices.  If S is non-null, it becomes the value of
- * the new element 0.  Returns the number of elements in the array after the
- * shift.
- */
-int
-array_rshift (a, n, s)
-ARRAY	*a;
-int	n;
-char	*s;
-{
-	register ARRAY_ELEMENT	*ae, *new;
-
-	if (a == 0 || (array_empty(a) && s == 0))
-		return 0;
-	else if (n <= 0)
-		return (a->num_elements);
-
-	ae = element_forw(a->head);
-	if (s) {
-		new = array_create_element(0, s);
-		ADD_BEFORE(ae, new);
-		a->num_elements++;
-		if (array_num_elements(a) == 1)	{	/* array was empty */
-			a->max_index = 0;
-			return 1;
-		}
-	}
-
-	/*
-	 * Renumber all elements in the array except the one we just added.
-	 */
-	for ( ; ae != a->head; ae = element_forw(ae))
-		element_index(ae) += n;
-
-	a->max_index = element_index(a->head->prev);
-
-	INVALIDATE_LASTREF(a);
-	return (a->num_elements);
-}
-
-ARRAY_ELEMENT *
-array_unshift_element(a)
-ARRAY	*a;
-{
-	return (array_shift (a, 1, 0));
-}
-
-int
-array_shift_element(a, v)
-ARRAY	*a;
-char	*v;
-{
-	return (array_rshift (a, 1, v));
-}
-
-ARRAY *
-array_quote(array)
-ARRAY	*array;
-{
-	ARRAY_ELEMENT	*a;
-	char	*t;
-
-	if (array == 0 || array_head(array) == 0 || array_empty(array))
-		return (ARRAY *)NULL;
-	for (a = element_forw(array->head); a != array->head; a = element_forw(a)) {
-		t = quote_string (a->value);
-		FREE(a->value);
-		a->value = t;
-	}
-	return array;
-}
-
-ARRAY *
-array_quote_escapes(array)
-ARRAY	*array;
-{
-	ARRAY_ELEMENT	*a;
-	char	*t;
-
-	if (array == 0 || array_head(array) == 0 || array_empty(array))
-		return (ARRAY *)NULL;
-	for (a = element_forw(array->head); a != array->head; a = element_forw(a)) {
-		t = quote_escapes (a->value);
-		FREE(a->value);
-		a->value = t;
-	}
-	return array;
-}
-
-ARRAY *
-array_dequote(array)
-ARRAY	*array;
-{
-	ARRAY_ELEMENT	*a;
-	char	*t;
-
-	if (array == 0 || array_head(array) == 0 || array_empty(array))
-		return (ARRAY *)NULL;
-	for (a = element_forw(array->head); a != array->head; a = element_forw(a)) {
-		t = dequote_string (a->value);
-		FREE(a->value);
-		a->value = t;
-	}
-	return array;
-}
-
-ARRAY *
-array_dequote_escapes(array)
-ARRAY	*array;
-{
-	ARRAY_ELEMENT	*a;
-	char	*t;
-
-	if (array == 0 || array_head(array) == 0 || array_empty(array))
-		return (ARRAY *)NULL;
-	for (a = element_forw(array->head); a != array->head; a = element_forw(a)) {
-		t = dequote_escapes (a->value);
-		FREE(a->value);
-		a->value = t;
-	}
-	return array;
-}
-
-ARRAY *
-array_remove_quoted_nulls(array)
-ARRAY	*array;
-{
-	ARRAY_ELEMENT	*a;
-
-	if (array == 0 || array_head(array) == 0 || array_empty(array))
-		return (ARRAY *)NULL;
-	for (a = element_forw(array->head); a != array->head; a = element_forw(a))
-		a->value = remove_quoted_nulls (a->value);
-	return array;
-}
-
-/*
- * Return a string whose elements are the members of array A beginning at
- * index START and spanning NELEM members.  Null elements are counted.
- * Since arrays are sparse, unset array elements are not counted.
- */
-char *
-array_subrange (a, start, nelem, starsub, quoted, pflags)
-ARRAY	*a;
-arrayind_t	start, nelem;
-int	starsub, quoted, pflags;
-{
-	ARRAY		*a2;
-	ARRAY_ELEMENT	*h, *p;
-	arrayind_t	i;
-	char		*t;
-	WORD_LIST	*wl;
-
-	p = a ? array_head (a) : 0;
-	if (p == 0 || array_empty (a) || start > array_max_index(a))
-		return ((char *)NULL);
-
-	/*
-	 * Find element with index START.  If START corresponds to an unset
-	 * element (arrays can be sparse), use the first element whose index
-	 * is >= START.  If START is < 0, we count START indices back from
-	 * the end of A (not elements, even with sparse arrays -- START is an
-	 * index).
-	 */
-	for (p = element_forw(p); p != array_head(a) && start > element_index(p); p = element_forw(p))
-		;
-
-	if (p == a->head)
-		return ((char *)NULL);
-
-	/* Starting at P, take NELEM elements, inclusive. */
-	for (i = 0, h = p; p != a->head && i < nelem; i++, p = element_forw(p))
-		;
-
-	a2 = array_slice(a, h, p);
-
-	wl = array_to_word_list(a2);
-	array_dispose(a2);
-	if (wl == 0)
-		return (char *)NULL;
-	t = string_list_pos_params(starsub ? '*' : '@', wl, quoted, pflags);	/* XXX */
-	dispose_words(wl);
-
-	return t;
-}
-
-char *
-array_patsub (a, pat, rep, mflags)
-ARRAY	*a;
-char	*pat, *rep;
-int	mflags;
-{
-	char	*t;
-	int	pchar, qflags, pflags;
-	WORD_LIST	*wl, *save;
-
-	if (a == 0 || array_head(a) == 0 || array_empty(a))
-		return ((char *)NULL);
-
-	wl = array_to_word_list(a);
-	if (wl == 0)
-		return (char *)NULL;
-
-	for (save = wl; wl; wl = wl->next) {
-		t = pat_subst (wl->word->word, pat, rep, mflags);
-		FREE (wl->word->word);
-		wl->word->word = t;
-	}
-
-	pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';
-	qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;
-	pflags = (mflags & MATCH_ASSIGNRHS) ? PF_ASSIGNRHS : 0;
-
-	t = string_list_pos_params (pchar, save, qflags, pflags);
-	dispose_words(save);
-
-	return t;
-}
-
-char *
-array_modcase (a, pat, modop, mflags)
-ARRAY	*a;
-char	*pat;
-int	modop;
-int	mflags;
-{
-	char	*t;
-	int	pchar, qflags, pflags;
-	WORD_LIST	*wl, *save;
-
-	if (a == 0 || array_head(a) == 0 || array_empty(a))
-		return ((char *)NULL);
-
-	wl = array_to_word_list(a);
-	if (wl == 0)
-		return ((char *)NULL);
-
-	for (save = wl; wl; wl = wl->next) {
-		t = sh_modcase(wl->word->word, pat, modop);
-		FREE(wl->word->word);
-		wl->word->word = t;
-	}
-
-	pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';
-	qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;
-	pflags = (mflags & MATCH_ASSIGNRHS) ? PF_ASSIGNRHS : 0;
-
-	t = string_list_pos_params (pchar, save, qflags, pflags);
-	dispose_words(save);
-
-	return t;
-}
-
-/*
- * Allocate and return a new array element with index INDEX and value
- * VALUE.
- */
-ARRAY_ELEMENT *
-array_create_element(indx, value)
-arrayind_t	indx;
-char	*value;
-{
-	ARRAY_ELEMENT *r;
-
-	r = (ARRAY_ELEMENT *)xmalloc(sizeof(ARRAY_ELEMENT));
-	r->ind = indx;
-	r->value = value ? savestring(value) : (char *)NULL;
-	r->next = r->prev = (ARRAY_ELEMENT *) NULL;
-	return(r);
-}
-
-#ifdef INCLUDE_UNUSED
-ARRAY_ELEMENT *
-array_copy_element(ae)
-ARRAY_ELEMENT	*ae;
-{
-	return(ae ? array_create_element(element_index(ae), element_value(ae))
-		  : (ARRAY_ELEMENT *) NULL);
-}
-#endif
-
-void
-array_dispose_element(ae)
-ARRAY_ELEMENT	*ae;
-{
-	if (ae) {
-		FREE(ae->value);
-		free(ae);
-	}
-}
-
-/*
- * Add a new element with index I and value V to array A (a[i] = v).
- */
-int
-array_insert(a, i, v)
-ARRAY	*a;
-arrayind_t	i;
-char	*v;
-{
-	register ARRAY_ELEMENT *new, *ae, *start;
-	arrayind_t startind;
-	int direction;
-
-	if (a == 0)
-		return(-1);
-	new = array_create_element(i, v);
-	if (i > array_max_index(a)) {
-		/*
-		 * Hook onto the end.  This also works for an empty array.
-		 * Fast path for the common case of allocating arrays
-		 * sequentially.
-		 */
-		ADD_BEFORE(a->head, new);
-		a->max_index = i;
-		a->num_elements++;
-		SET_LASTREF(a, new);
-		return(0);
-	} else if (i < array_first_index(a)) {
-		/* Hook at the beginning */
-		ADD_AFTER(a->head, new);
-		a->num_elements++;
-		SET_LASTREF(a, new);
-		return(0);
-	}
-#if OPTIMIZE_SEQUENTIAL_ARRAY_ASSIGNMENT
-	/*
-	 * Otherwise we search for the spot to insert it.  The lastref
-	 * handle optimizes the case of sequential or almost-sequential
-	 * assignments that are not at the end of the array.
-	 */
-	start = LASTREF(a);
-	/* Use same strategy as array_reference to avoid paying large penalty
-	   for semi-random assignment pattern. */
-	startind = element_index(start);
-	if (i < startind/2) {
-		start = element_forw(a->head);
-		startind = element_index(start);
-		direction = 1;
-	} else if (i >= startind) {
-		direction = 1;
-	} else {
-		direction = -1;
-	}
-#else
-	start = element_forw(ae->head);
-	startind = element_index(start);
-	direction = 1;
-#endif
-	for (ae = start; ae != a->head; ) {
-		if (element_index(ae) == i) {
-			/*
-			 * Replacing an existing element.
-			 */
-			free(element_value(ae));
-			/* Just swap in the new value */
-			ae->value = new->value;
-			new->value = 0;
-			array_dispose_element(new);
-			SET_LASTREF(a, ae);
-			return(0);
-		} else if (direction == 1 && element_index(ae) > i) {
-			ADD_BEFORE(ae, new);
-			a->num_elements++;
-			SET_LASTREF(a, new);
-			return(0);
-		} else if (direction == -1 && element_index(ae) < i) {
-			ADD_AFTER(ae, new);
-			a->num_elements++;
-			SET_LASTREF(a, new);
-			return(0);
-		}
-		ae = direction == 1 ? element_forw(ae) : element_back(ae);
-	}
-	array_dispose_element(new);
-	INVALIDATE_LASTREF(a);
-	return (-1);		/* problem */
-}
-
-/*
- * Delete the element with index I from array A and return it so the
- * caller can dispose of it.
- */
-ARRAY_ELEMENT *
-array_remove(a, i)
-ARRAY	*a;
-arrayind_t	i;
-{
-	register ARRAY_ELEMENT *ae, *start;
-	arrayind_t startind;
-	int direction;
-
-	if (a == 0 || array_empty(a))
-		return((ARRAY_ELEMENT *) NULL);
-	if (i > array_max_index(a) || i < array_first_index(a))
-		return((ARRAY_ELEMENT *)NULL);	/* Keep roving pointer into array to optimize sequential access */
-	start = LASTREF(a);
-	/* Use same strategy as array_reference to avoid paying large penalty
-	   for semi-random assignment pattern. */
-	startind = element_index(start);
-	if (i < startind/2) {
-		start = element_forw(a->head);
-		startind = element_index(start);
-		direction = 1;
-	} else if (i >= startind) {
-		direction = 1;
-	} else {
-		direction = -1;
-	}
-	for (ae = start; ae != a->head; ) {
-		if (element_index(ae) == i) {
-			ae->next->prev = ae->prev;
-			ae->prev->next = ae->next;
-			a->num_elements--;
-			if (i == array_max_index(a))
-				a->max_index = element_index(ae->prev);
-#if 0
-			INVALIDATE_LASTREF(a);
-#else
-			if (ae->next != a->head)
-				SET_LASTREF(a, ae->next);
-			else if (ae->prev != a->head)
-				SET_LASTREF(a, ae->prev);
-			else
-				INVALIDATE_LASTREF(a);
-#endif
-			return(ae);
-		}
-		ae = (direction == 1) ? element_forw(ae) : element_back(ae);
-		if (direction == 1 && element_index(ae) > i)
-			break;
-		else if (direction == -1 && element_index(ae) < i)
-			break;
-	}
-	return((ARRAY_ELEMENT *) NULL);
-}
-
-/*
- * Return the value of a[i].
- */
-char *
-array_reference(a, i)
-ARRAY	*a;
-arrayind_t	i;
-{
-	register ARRAY_ELEMENT *ae, *start;
-	arrayind_t startind;
-	int direction;
-
-	if (a == 0 || array_empty(a))
-		return((char *) NULL);
-	if (i > array_max_index(a) || i < array_first_index(a))
-		return((char *)NULL);	/* Keep roving pointer into array to optimize sequential access */
-	start = LASTREF(a);	/* lastref pointer */
-	startind = element_index(start);
-	if (i < startind/2) {	/* XXX - guess */
-		start = element_forw(a->head);
-		startind = element_index(start);
-		direction = 1;
-	} else if (i >= startind) {
-		direction = 1;
-	} else {
-		direction = -1;
-	}
-	for (ae = start; ae != a->head; ) {
-		if (element_index(ae) == i) {
-			SET_LASTREF(a, ae);
-			return(element_value(ae));
-		}
-		ae = (direction == 1) ? element_forw(ae) : element_back(ae);
-		/* Take advantage of index ordering to short-circuit */
-		/* If we don't find it, set the lastref pointer to the element
-		   that's `closest', assuming that the unsuccessful reference
-		   will quickly be followed by an assignment.  No worse than
-		   not changing it from the previous value or resetting it. */
-		if (direction == 1 && element_index(ae) > i) {
-			start = ae;	/* use for SET_LASTREF below */
-			break;
-		} else if (direction == -1 && element_index(ae) < i) {
-			start = ae;	/* use for SET_LASTREF below */
-			break;
-		}
-	}
-#if 0
-	UNSET_LASTREF(a);
-#else
-	SET_LASTREF(a, start);
-#endif
-	return((char *) NULL);
-}
-
-/* Convenience routines for the shell to translate to and from the form used
-   by the rest of the code. */
-
-WORD_LIST *
-array_to_word_list(a)
-ARRAY	*a;
-{
-	WORD_LIST	*list;
-	ARRAY_ELEMENT	*ae;
-
-	if (a == 0 || array_empty(a))
-		return((WORD_LIST *)NULL);
-	list = (WORD_LIST *)NULL;
-	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae))
-		list = make_word_list (make_bare_word(element_value(ae)), list);
-	return (REVERSE_LIST(list, WORD_LIST *));
-}
-
-ARRAY *
-array_from_word_list (list)
-WORD_LIST	*list;
-{
-	ARRAY	*a;
-
-	if (list == 0)
-		return((ARRAY *)NULL);
-	a = array_create();
-	return (array_assign_list (a, list));
-}
-
-WORD_LIST *
-array_keys_to_word_list(a)
-ARRAY	*a;
-{
-	WORD_LIST	*list;
-	ARRAY_ELEMENT	*ae;
-	char		*t;
-
-	if (a == 0 || array_empty(a))
-		return((WORD_LIST *)NULL);
-	list = (WORD_LIST *)NULL;
-	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae)) {
-		t = itos(element_index(ae));
-		list = make_word_list (make_bare_word(t), list);
-		free(t);
-	}
-	return (REVERSE_LIST(list, WORD_LIST *));
-}
-
-WORD_LIST *
-array_to_kvpair_list(a)
-ARRAY	*a;
-{
-	WORD_LIST	*list;
-	ARRAY_ELEMENT	*ae;
-	char		*k, *v;
-
-	if (a == 0 || array_empty(a))
-		return((WORD_LIST *)NULL);
-	list = (WORD_LIST *)NULL;
-	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae)) {
-		k = itos(element_index(ae));
-		v = element_value(ae);
-		list = make_word_list (make_bare_word(k), list);
-		list = make_word_list (make_bare_word(v), list);
-		free(k);
-	}
-	return (REVERSE_LIST(list, WORD_LIST *));
-}
-
-ARRAY *
-array_assign_list (array, list)
-ARRAY	*array;
-WORD_LIST	*list;
-{
-	register WORD_LIST *l;
-	register arrayind_t i;
-
-	for (l = list, i = 0; l; l = l->next, i++)
-		array_insert(array, i, l->word->word);
-	return array;
-}
-
-char **
-array_to_argv (a, countp)
-ARRAY	*a;
-int	*countp;
-{
-	char		**ret, *t;
-	int		i;
-	ARRAY_ELEMENT	*ae;
-
-	if (a == 0 || array_empty(a)) {
-		if (countp)
-			*countp = 0;
-		return ((char **)NULL);
-	}
-	ret = strvec_create (array_num_elements (a) + 1);
-	i = 0;
-	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae)) {
-		t = element_value (ae);
-		if (t)
-			ret[i++] = savestring (t);
-	}
-	ret[i] = (char *)NULL;
-	if (countp)
-		*countp = i;
-	return (ret);
-}
-
-ARRAY *
-array_from_argv(a, vec, count)
-ARRAY	*a;
-char	**vec;
-int	count;
-{
-  arrayind_t	i;
-  ARRAY_ELEMENT	*ae;
-  char	*t;
-
-  if (a == 0 || array_num_elements (a) == 0)
-    {
-      for (i = 0; i < count; i++)
-	array_insert (a, i, t);
-      return a;
-    }
-
-  /* Fast case */
-  if (array_num_elements (a) == count && count == 1)
-    {
-      ae = element_forw (a->head);
-      t = vec[0] ? savestring (vec[0]) : 0;
-      ARRAY_ELEMENT_REPLACE (ae, t);
-    }
-  else if (array_num_elements (a) <= count)
-    {
-      /* modify in array_num_elements members in place, then add */
-      ae = a->head;
-      for (i = 0; i < array_num_elements (a); i++)
-	{
-	  ae = element_forw (ae);
-	  t = vec[0] ? savestring (vec[0]) : 0;
-	  ARRAY_ELEMENT_REPLACE (ae, t);
-	}
-      /* add any more */
-      for ( ; i < count; i++)
-	array_insert (a, i, vec[i]);
-    }
-  else
-    {
-      /* deleting elements.  it's faster to rebuild the array. */	  
-      array_flush (a);
-      for (i = 0; i < count; i++)
-	array_insert (a, i, vec[i]);
-    }
-
-  return a;
-}
-	
-/*
- * Return a string that is the concatenation of the elements in A from START
- * to END, separated by SEP.
- */
-static char *
-array_to_string_internal (start, end, sep, quoted)
-ARRAY_ELEMENT	*start, *end;
-char	*sep;
-int	quoted;
-{
-	char	*result, *t;
-	ARRAY_ELEMENT *ae;
-	int	slen, rsize, rlen, reg;
-
-	if (start == end)	/* XXX - should not happen */
-		return ((char *)NULL);
-
-	slen = strlen(sep);
-	result = NULL;
-	for (rsize = rlen = 0, ae = start; ae != end; ae = element_forw(ae)) {
-		if (rsize == 0)
-			result = (char *)xmalloc (rsize = 64);
-		if (element_value(ae)) {
-			t = quoted ? quote_string(element_value(ae)) : element_value(ae);
-			reg = strlen(t);
-			RESIZE_MALLOCED_BUFFER (result, rlen, (reg + slen + 2),
-						rsize, rsize);
-			strcpy(result + rlen, t);
-			rlen += reg;
-			if (quoted)
-				free(t);
-			/*
-			 * Add a separator only after non-null elements.
-			 */
-			if (element_forw(ae) != end) {
-				strcpy(result + rlen, sep);
-				rlen += slen;
-			}
-		}
-	}
-	if (result)
-	  result[rlen] = '\0';	/* XXX */
-	return(result);
-}
-
-char *
-array_to_kvpair (a, quoted)
-ARRAY	*a;
-int	quoted;
-{
-	char	*result, *valstr, *is;
-	char	indstr[INT_STRLEN_BOUND(intmax_t) + 1];
-	ARRAY_ELEMENT *ae;
-	int	rsize, rlen, elen;
-
-	if (a == 0 || array_empty (a))
-		return((char *)NULL);
-
-	result = (char *)xmalloc (rsize = 128);
-	result[rlen = 0] = '\0';
-
-	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae)) {
-		is = inttostr (element_index(ae), indstr, sizeof(indstr));
-		valstr = element_value (ae) ?
-				(ansic_shouldquote (element_value (ae)) ?
-				   ansic_quote (element_value(ae), 0, (int *)0) :
-				   sh_double_quote (element_value (ae)))
-					    : (char *)NULL;
-		elen = STRLEN (is) + 8 + STRLEN (valstr);
-		RESIZE_MALLOCED_BUFFER (result, rlen, (elen + 1), rsize, rsize);
-
-		strcpy (result + rlen, is);
-		rlen += STRLEN (is);
-		result[rlen++] = ' ';
-		if (valstr) {
-			strcpy (result + rlen, valstr);
-			rlen += STRLEN (valstr);
-		} else {
-			strcpy (result + rlen, "\"\"");
-			rlen += 2;
-		}
-
-		if (element_forw(ae) != a->head)
-		  result[rlen++] = ' ';
-
-		FREE (valstr);
-	}
-	RESIZE_MALLOCED_BUFFER (result, rlen, 1, rsize, 8);
-	result[rlen] = '\0';
-
-	if (quoted) {
-		/* This is not as efficient as it could be... */
-		valstr = sh_single_quote (result);
-		free (result);
-		result = valstr;
-	}
-	return(result);
-}
-
-char *
-array_to_assign (a, quoted)
-ARRAY	*a;
-int	quoted;
-{
-	char	*result, *valstr, *is;
-	char	indstr[INT_STRLEN_BOUND(intmax_t) + 1];
-	ARRAY_ELEMENT *ae;
-	int	rsize, rlen, elen;
-
-	if (a == 0 || array_empty (a))
-		return((char *)NULL);
-
-	result = (char *)xmalloc (rsize = 128);
-	result[0] = '(';
-	rlen = 1;
-
-	for (ae = element_forw(a->head); ae != a->head; ae = element_forw(ae)) {
-		is = inttostr (element_index(ae), indstr, sizeof(indstr));
-		valstr = element_value (ae) ?
-				(ansic_shouldquote (element_value (ae)) ?
-				   ansic_quote (element_value(ae), 0, (int *)0) :
-				   sh_double_quote (element_value (ae)))
-					    : (char *)NULL;
-		elen = STRLEN (is) + 8 + STRLEN (valstr);
-		RESIZE_MALLOCED_BUFFER (result, rlen, (elen + 1), rsize, rsize);
-
-		result[rlen++] = '[';
-		strcpy (result + rlen, is);
-		rlen += STRLEN (is);
-		result[rlen++] = ']';
-		result[rlen++] = '=';
-		if (valstr) {
-			strcpy (result + rlen, valstr);
-			rlen += STRLEN (valstr);
-		}
-
-		if (element_forw(ae) != a->head)
-		  result[rlen++] = ' ';
-
-		FREE (valstr);
-	}
-	RESIZE_MALLOCED_BUFFER (result, rlen, 1, rsize, 8);
-	result[rlen++] = ')';
-	result[rlen] = '\0';
-	if (quoted) {
-		/* This is not as efficient as it could be... */
-		valstr = sh_single_quote (result);
-		free (result);
-		result = valstr;
-	}
-	return(result);
-}
-
-char *
-array_to_string (a, sep, quoted)
-ARRAY	*a;
-char	*sep;
-int	quoted;
-{
-	if (a == 0)
-		return((char *)NULL);
-	if (array_empty(a))
-		return(savestring(""));
-	return (array_to_string_internal (element_forw(a->head), a->head, sep, quoted));
-}
-
-#if defined (INCLUDE_UNUSED) || defined (TEST_ARRAY)
-/*
- * Return an array consisting of elements in S, separated by SEP
- */
-ARRAY *
-array_from_string(s, sep)
-char	*s, *sep;
-{
-	ARRAY	*a;
-	WORD_LIST *w;
-
-	if (s == 0)
-		return((ARRAY *)NULL);
-	w = list_string (s, sep, 0);
-	if (w == 0)
-		return((ARRAY *)NULL);
-	a = array_from_word_list (w);
-	return (a);
-}
-#endif
-
-#if defined (TEST_ARRAY)
-/*
- * To make a running version, compile -DTEST_ARRAY and link with:
- * 	xmalloc.o syntax.o lib/malloc/libmalloc.a lib/sh/libsh.a
- */
-int interrupt_immediately = 0;
-
-int
-signal_is_trapped(s)
-int	s;
-{
-	return 0;
-}
-
-void
-fatal_error(const char *s, ...)
-{
-	fprintf(stderr, "array_test: fatal memory error\n");
-	abort();
-}
-
-void
-programming_error(const char *s, ...)
-{
-	fprintf(stderr, "array_test: fatal programming error\n");
-	abort();
-}
-
-WORD_DESC *
-make_bare_word (s)
-const char	*s;
-{
-	WORD_DESC *w;
-
-	w = (WORD_DESC *)xmalloc(sizeof(WORD_DESC));
-	w->word = s ? savestring(s) : savestring ("");
-	w->flags = 0;
-	return w;
-}
-
-WORD_LIST *
-make_word_list(x, l)
-WORD_DESC	*x;
-WORD_LIST	*l;
-{
-	WORD_LIST *w;
-
-	w = (WORD_LIST *)xmalloc(sizeof(WORD_LIST));
-	w->word = x;
-	w->next = l;
-	return w;
-}
-
-WORD_LIST *
-list_string(s, t, i)
-char	*s, *t;
-int	i;
-{
-	char	*r, *a;
-	WORD_LIST	*wl;
-
-	if (s == 0)
-		return (WORD_LIST *)NULL;
-	r = savestring(s);
-	wl = (WORD_LIST *)NULL;
-	a = strtok(r, t);
-	while (a) {
-		wl = make_word_list (make_bare_word(a), wl);
-		a = strtok((char *)NULL, t);
-	}
-	return (REVERSE_LIST (wl, WORD_LIST *));
-}
-
-GENERIC_LIST *
-list_reverse (list)
-GENERIC_LIST	*list;
-{
-	register GENERIC_LIST *next, *prev;
-
-	for (prev = 0; list; ) {
-		next = list->next;
-		list->next = prev;
-		prev = list;
-		list = next;
-	}
-	return prev;
-}
-
-char *
-pat_subst(s, t, u, i)
-char	*s, *t, *u;
-int	i;
-{
-	return ((char *)NULL);
-}
-
-char *
-quote_string(s)
-char	*s;
-{
-	return savestring(s);
-}
-
-print_element(ae)
-ARRAY_ELEMENT	*ae;
-{
-	char	lbuf[INT_STRLEN_BOUND (intmax_t) + 1];
-
-	printf("array[%s] = %s\n",
-		inttostr (element_index(ae), lbuf, sizeof (lbuf)),
-		element_value(ae));
-}
-
-print_array(a)
-ARRAY	*a;
-{
-	printf("\n");
-	array_walk(a, print_element, (void *)NULL);
-}
-
-main()
-{
-	ARRAY	*a, *new_a, *copy_of_a;
-	ARRAY_ELEMENT	*ae, *aew;
-	char	*s;
-
-	a = array_create();
-	array_insert(a, 1, "one");
-	array_insert(a, 7, "seven");
-	array_insert(a, 4, "four");
-	array_insert(a, 1029, "one thousand twenty-nine");
-	array_insert(a, 12, "twelve");
-	array_insert(a, 42, "forty-two");
-	print_array(a);
-	s = array_to_string (a, " ", 0);
-	printf("s = %s\n", s);
-	copy_of_a = array_from_string(s, " ");
-	printf("copy_of_a:");
-	print_array(copy_of_a);
-	array_dispose(copy_of_a);
-	printf("\n");
-	free(s);
-	ae = array_remove(a, 4);
-	array_dispose_element(ae);
-	ae = array_remove(a, 1029);
-	array_dispose_element(ae);
-	array_insert(a, 16, "sixteen");
-	print_array(a);
-	s = array_to_string (a, " ", 0);
-	printf("s = %s\n", s);
-	copy_of_a = array_from_string(s, " ");
-	printf("copy_of_a:");
-	print_array(copy_of_a);
-	array_dispose(copy_of_a);
-	printf("\n");
-	free(s);
-	array_insert(a, 2, "two");
-	array_insert(a, 1029, "new one thousand twenty-nine");
-	array_insert(a, 0, "zero");
-	array_insert(a, 134, "");
-	print_array(a);
-	s = array_to_string (a, ":", 0);
-	printf("s = %s\n", s);
-	copy_of_a = array_from_string(s, ":");
-	printf("copy_of_a:");
-	print_array(copy_of_a);
-	array_dispose(copy_of_a);
-	printf("\n");
-	free(s);
-	new_a = array_copy(a);
-	print_array(new_a);
-	s = array_to_string (new_a, ":", 0);
-	printf("s = %s\n", s);
-	copy_of_a = array_from_string(s, ":");
-	free(s);
-	printf("copy_of_a:");
-	print_array(copy_of_a);
-	array_shift(copy_of_a, 2, AS_DISPOSE);
-	printf("copy_of_a shifted by two:");
-	print_array(copy_of_a);
-	ae = array_shift(copy_of_a, 2, 0);
-	printf("copy_of_a shifted by two:");
-	print_array(copy_of_a);
-	for ( ; ae; ) {
-		aew = element_forw(ae);
-		array_dispose_element(ae);
-		ae = aew;
-	}
-	array_rshift(copy_of_a, 1, (char *)0);
-	printf("copy_of_a rshift by 1:");
-	print_array(copy_of_a);
-	array_rshift(copy_of_a, 2, "new element zero");
-	printf("copy_of_a rshift again by 2 with new element zero:");
-	print_array(copy_of_a);
-	s = array_to_assign(copy_of_a, 0);
-	printf("copy_of_a=%s\n", s);
-	free(s);
-	ae = array_shift(copy_of_a, array_num_elements(copy_of_a), 0);
-	for ( ; ae; ) {
-		aew = element_forw(ae);
-		array_dispose_element(ae);
-		ae = aew;
-	}
-	array_dispose(copy_of_a);
-	printf("\n");
-	array_dispose(a);
-	array_dispose(new_a);
-}
-
-#endif /* TEST_ARRAY */
-#endif /* ARRAY_VARS */
diff --git a/third_party/bash/array.h b/third_party/bash/array.h
deleted file mode 100644
index 4214e8b41..000000000
--- a/third_party/bash/array.h
+++ /dev/null
@@ -1,182 +0,0 @@
-/* array.h -- definitions for the interface exported by array.c that allows
-   the rest of the shell to manipulate array variables. */
-
-/* Copyright (C) 1997-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-
-#ifndef _ARRAY_H_
-#define _ARRAY_H_
-
-#include "stdc.h"
-
-typedef intmax_t	arrayind_t;
-
-typedef struct array {
-	arrayind_t	max_index;
-	arrayind_t	num_elements;
-#ifdef ALT_ARRAY_IMPLEMENTATION
-	arrayind_t	first_index;
-	arrayind_t	alloc_size;
-	struct array_element **elements;
-#else
-	struct array_element *head;
-	struct array_element *lastref;
-#endif
-} ARRAY;
-
-typedef struct array_element {
-	arrayind_t	ind;
-	char	*value;
-#ifndef ALT_ARRAY_IMPLEMENTATION
-	struct array_element *next, *prev;
-#endif
-} ARRAY_ELEMENT;
-
-#define ARRAY_DEFAULT_SIZE	1024
-
-typedef int sh_ae_map_func_t PARAMS((ARRAY_ELEMENT *, void *));
-
-/* Basic operations on entire arrays */
-#ifdef ALT_ARRAY_IMPLEMENTATION
-extern void   array_alloc PARAMS((ARRAY *, arrayind_t));
-extern void   array_resize PARAMS((ARRAY *, arrayind_t));
-extern void   array_expand PARAMS((ARRAY *, arrayind_t));
-extern void   array_dispose_elements PARAMS((ARRAY_ELEMENT **));
-#endif
-extern ARRAY	*array_create PARAMS((void));
-extern void	array_flush PARAMS((ARRAY *));
-extern void	array_dispose PARAMS((ARRAY *));
-extern ARRAY	*array_copy PARAMS((ARRAY *));
-#ifndef ALT_ARRAY_IMPLEMENTATION
-extern ARRAY	*array_slice PARAMS((ARRAY *, ARRAY_ELEMENT *, ARRAY_ELEMENT *));
-#else
-extern ARRAY	*array_slice PARAMS((ARRAY *, arrayind_t, arrayind_t));
-#endif
-
-extern void	array_walk PARAMS((ARRAY   *, sh_ae_map_func_t *, void *));
-
-#ifndef ALT_ARRAY_IMPLEMENTATION
-extern ARRAY_ELEMENT *array_shift PARAMS((ARRAY *, int, int));
-#else
-extern ARRAY_ELEMENT **array_shift PARAMS((ARRAY *, int, int));
-#endif
-extern int	array_rshift PARAMS((ARRAY *, int, char *));
-extern ARRAY_ELEMENT *array_unshift_element PARAMS((ARRAY *));
-extern int	array_shift_element PARAMS((ARRAY *, char *));
-
-extern ARRAY	*array_quote PARAMS((ARRAY *));
-extern ARRAY	*array_quote_escapes PARAMS((ARRAY *));
-extern ARRAY	*array_dequote PARAMS((ARRAY *));
-extern ARRAY	*array_dequote_escapes PARAMS((ARRAY *));
-extern ARRAY	*array_remove_quoted_nulls PARAMS((ARRAY *));
-
-extern char	*array_subrange PARAMS((ARRAY *, arrayind_t, arrayind_t, int, int, int));
-extern char	*array_patsub PARAMS((ARRAY *, char *, char *, int));
-extern char	*array_modcase PARAMS((ARRAY *, char *, int, int));
-
-/* Basic operations on array elements. */
-extern ARRAY_ELEMENT *array_create_element PARAMS((arrayind_t, char *));
-extern ARRAY_ELEMENT *array_copy_element PARAMS((ARRAY_ELEMENT *));
-extern void	array_dispose_element PARAMS((ARRAY_ELEMENT *));
-
-extern int	array_insert PARAMS((ARRAY *, arrayind_t, char *));
-extern ARRAY_ELEMENT *array_remove PARAMS((ARRAY *, arrayind_t));
-extern char	*array_reference PARAMS((ARRAY *, arrayind_t));
-
-/* Converting to and from arrays */
-extern WORD_LIST *array_to_word_list PARAMS((ARRAY *));
-extern ARRAY *array_from_word_list PARAMS((WORD_LIST *));
-extern WORD_LIST *array_keys_to_word_list PARAMS((ARRAY *));
-extern WORD_LIST *array_to_kvpair_list PARAMS((ARRAY *));
-
-extern ARRAY *array_assign_list PARAMS((ARRAY *, WORD_LIST *));
-
-extern char **array_to_argv PARAMS((ARRAY *, int *));
-extern ARRAY *array_from_argv PARAMS((ARRAY *, char **, int));
-
-extern char *array_to_kvpair PARAMS((ARRAY *, int));
-extern char *array_to_assign PARAMS((ARRAY *, int));
-extern char *array_to_string PARAMS((ARRAY *, char *, int));
-extern ARRAY *array_from_string PARAMS((char *, char *));
-
-/* Flags for array_shift */
-#define AS_DISPOSE	0x01
-
-#define array_num_elements(a)	((a)->num_elements)
-#define array_max_index(a)	((a)->max_index)
-#ifndef ALT_ARRAY_IMPLEMENTATION
-#define array_first_index(a)	((a)->head->next->ind)
-#define array_head(a)		((a)->head)
-#define array_alloc_size(a)	((a)->alloc_size)
-#else
-#define array_first_index(a)	((a)->first_index)
-#define array_head(a)		((a)->elements)
-#endif
-#define array_empty(a)		((a)->num_elements == 0)
-
-#define element_value(ae)	((ae)->value)
-#define element_index(ae)	((ae)->ind)
-
-#ifndef ALT_ARRAY_IMPLEMENTATION
-#define element_forw(ae)	((ae)->next)
-#define element_back(ae)	((ae)->prev)
-#else
-extern arrayind_t element_forw PARAMS((ARRAY *, arrayind_t));
-extern arrayind_t element_back PARAMS((ARRAY *, arrayind_t));
-#endif
-
-
-#define set_element_value(ae, val)	((ae)->value = (val))
-
-#ifdef ALT_ARRAY_IMPLEMENTATION
-#define set_first_index(a, i)	((a)->first_index = (i))
-#endif
-
-#define set_max_index(a, i)	((a)->max_index = (i))
-#define set_num_elements(a, n)	((a)->num_elements = (n))
-
-/* Convenience */
-#define array_push(a,v)	\
-  do { array_rshift ((a), 1, (v)); } while (0)
-#define array_pop(a) \
-  do { array_shift ((a), 1, AS_DISPOSE); } while (0)
-
-#define GET_ARRAY_FROM_VAR(n, v, a) \
-  do { \
-    (v) = find_variable (n); \
-    (a) = ((v) && array_p ((v))) ? array_cell (v) : (ARRAY *)0; \
-  } while (0)
-
-#define ARRAY_ELEMENT_REPLACE(ae, v) \
-  do { \
-    free ((ae)->value); \
-    (ae)->value = (v); \
-  } while (0)
-
-#ifdef ALT_ARRAY_IMPLEMENTATION
-#define ARRAY_VALUE_REPLACE(a, i, v) \
-   ARRAY_ELEMENT_REPLACE((a)->elements[(i)], (v))
-#endif
-
-#define ALL_ELEMENT_SUB(c)	((c) == '@' || (c) == '*')
-
-/* In eval.c, but uses ARRAY * */
-extern int execute_array_command PARAMS((ARRAY *, void *));
-
-#endif /* _ARRAY_H_ */
diff --git a/third_party/bash/arrayfunc.c b/third_party/bash/arrayfunc.c
deleted file mode 100644
index db8e07f3f..000000000
--- a/third_party/bash/arrayfunc.c
+++ /dev/null
@@ -1,1699 +0,0 @@
-/* arrayfunc.c -- High-level array functions used by other parts of the shell. */
-
-/* Copyright (C) 2001-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (ARRAY_VARS)
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-#include <stdio.h>
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "pathexp.h"
-
-#include "shmbutil.h"
-#if defined (HAVE_MBSTR_H) && defined (HAVE_MBSCHR)
-#  include <mbstr.h>		/* mbschr */
-#endif
-
-#include "common.h"
-
-#ifndef LBRACK
-#  define LBRACK '['
-#  define RBRACK ']'
-#endif
-
-/* This variable means to not expand associative array subscripts more than
-   once, when performing variable expansion. */
-int assoc_expand_once = 0;
-
-/* Ditto for indexed array subscripts -- currently unused */
-int array_expand_once = 0;
-
-static SHELL_VAR *bind_array_var_internal PARAMS((SHELL_VAR *, arrayind_t, char *, char *, int));
-static SHELL_VAR *assign_array_element_internal PARAMS((SHELL_VAR *, char *, char *, char *, int, char *, int, array_eltstate_t *));
-
-static void assign_assoc_from_kvlist PARAMS((SHELL_VAR *, WORD_LIST *, HASH_TABLE *, int));
-
-static char *quote_assign PARAMS((const char *));
-static void quote_array_assignment_chars PARAMS((WORD_LIST *));
-static char *quote_compound_array_word PARAMS((char *, int));
-static char *array_value_internal PARAMS((const char *, int, int, array_eltstate_t *));
-
-/* Standard error message to use when encountering an invalid array subscript */
-const char * const bash_badsub_errmsg = N_("bad array subscript");
-
-/* **************************************************************** */
-/*								    */
-/*  Functions to manipulate array variables and perform assignments */
-/*								    */
-/* **************************************************************** */
-
-/* Convert a shell variable to an array variable.  The original value is
-   saved as array[0]. */
-SHELL_VAR *
-convert_var_to_array (var)
-     SHELL_VAR *var;
-{
-  char *oldval;
-  ARRAY *array;
-
-  oldval = value_cell (var);
-  array = array_create ();
-  if (oldval)
-    array_insert (array, 0, oldval);
-
-  FREE (value_cell (var));
-  var_setarray (var, array);
-
-  /* these aren't valid anymore */
-  var->dynamic_value = (sh_var_value_func_t *)NULL;
-  var->assign_func = (sh_var_assign_func_t *)NULL;
-
-  INVALIDATE_EXPORTSTR (var);
-  if (exported_p (var))
-    array_needs_making++;
-
-  VSETATTR (var, att_array);
-  if (oldval)
-    VUNSETATTR (var, att_invisible);
-
-  /* Make sure it's not marked as an associative array any more */
-  VUNSETATTR (var, att_assoc);
-
-  /* Since namerefs can't be array variables, turn off nameref attribute */
-  VUNSETATTR (var, att_nameref);
-
-  return var;
-}
-
-/* Convert a shell variable to an array variable.  The original value is
-   saved as array[0]. */
-SHELL_VAR *
-convert_var_to_assoc (var)
-     SHELL_VAR *var;
-{
-  char *oldval;
-  HASH_TABLE *hash;
-
-  oldval = value_cell (var);
-  hash = assoc_create (0);
-  if (oldval)
-    assoc_insert (hash, savestring ("0"), oldval);
-
-  FREE (value_cell (var));
-  var_setassoc (var, hash);
-
-  /* these aren't valid anymore */
-  var->dynamic_value = (sh_var_value_func_t *)NULL;
-  var->assign_func = (sh_var_assign_func_t *)NULL;
-
-  INVALIDATE_EXPORTSTR (var);
-  if (exported_p (var))
-    array_needs_making++;
-
-  VSETATTR (var, att_assoc);
-  if (oldval)
-    VUNSETATTR (var, att_invisible);
-
-  /* Make sure it's not marked as an indexed array any more */
-  VUNSETATTR (var, att_array);
-
-  /* Since namerefs can't be array variables, turn off nameref attribute */
-  VUNSETATTR (var, att_nameref);
-
-  return var;
-}
-
-char *
-make_array_variable_value (entry, ind, key, value, flags)
-     SHELL_VAR *entry;
-     arrayind_t ind;
-     char *key;
-     char *value;
-     int flags;
-{
-  SHELL_VAR *dentry;
-  char *newval;
-
-  /* If we're appending, we need the old value of the array reference, so
-     fake out make_variable_value with a dummy SHELL_VAR */
-  if (flags & ASS_APPEND)
-    {
-      dentry = (SHELL_VAR *)xmalloc (sizeof (SHELL_VAR));
-      dentry->name = savestring (entry->name);
-      if (assoc_p (entry))
-	newval = assoc_reference (assoc_cell (entry), key);
-      else
-	newval = array_reference (array_cell (entry), ind);
-      if (newval)
-	dentry->value = savestring (newval);
-      else
-	{
-	  dentry->value = (char *)xmalloc (1);
-	  dentry->value[0] = '\0';
-	}
-      dentry->exportstr = 0;
-      dentry->attributes = entry->attributes & ~(att_array|att_assoc|att_exported);
-      /* Leave the rest of the members uninitialized; the code doesn't look
-	 at them. */
-      newval = make_variable_value (dentry, value, flags);	 
-      dispose_variable (dentry);
-    }
-  else
-    newval = make_variable_value (entry, value, flags);
-
-  return newval;
-}
-
-/* Assign HASH[KEY]=VALUE according to FLAGS. ENTRY is an associative array
-   variable; HASH is the hash table to assign into. HASH may or may not be
-   the hash table associated with ENTRY; if it's not, the caller takes care
-   of it.
-   XXX - make sure that any dynamic associative array variables recreate the
-   hash table on each assignment. BASH_CMDS and BASH_ALIASES already do this */
-static SHELL_VAR *
-bind_assoc_var_internal (entry, hash, key, value, flags)
-     SHELL_VAR *entry;
-     HASH_TABLE *hash;
-     char *key;
-     char *value;
-     int flags;
-{
-  char *newval;
-
-  /* Use the existing array contents to expand the value */
-  newval = make_array_variable_value (entry, 0, key, value, flags);
-
-  if (entry->assign_func)
-    (*entry->assign_func) (entry, newval, 0, key);
-  else
-    assoc_insert (hash, key, newval);
-
-  FREE (newval);
-
-  VUNSETATTR (entry, att_invisible);	/* no longer invisible */
-
-  /* check mark_modified_variables if we ever want to export array vars */
-  return (entry);
-}
-
-/* Perform ENTRY[IND]=VALUE or ENTRY[KEY]=VALUE. This is not called for every
-   assignment to an associative array; see assign_compound_array_list below. */
-static SHELL_VAR *
-bind_array_var_internal (entry, ind, key, value, flags)
-     SHELL_VAR *entry;
-     arrayind_t ind;
-     char *key;
-     char *value;
-     int flags;
-{
-  char *newval;
-
-  newval = make_array_variable_value (entry, ind, key, value, flags);
-
-  if (entry->assign_func)
-    (*entry->assign_func) (entry, newval, ind, key);
-  else if (assoc_p (entry))
-    assoc_insert (assoc_cell (entry), key, newval);
-  else
-    array_insert (array_cell (entry), ind, newval);
-  FREE (newval);
-
-  VUNSETATTR (entry, att_invisible);	/* no longer invisible */
-
-  /* check mark_modified_variables if we ever want to export array vars */
-  return (entry);
-}
-
-/* Perform an array assignment name[ind]=value.  If NAME already exists and
-   is not an array, and IND is 0, perform name=value instead.  If NAME exists
-   and is not an array, and IND is not 0, convert it into an array with the
-   existing value as name[0].
-
-   If NAME does not exist, just create an array variable, no matter what
-   IND's value may be. */
-SHELL_VAR *
-bind_array_variable (name, ind, value, flags)
-     char *name;
-     arrayind_t ind;
-     char *value;
-     int flags;
-{
-  SHELL_VAR *entry;
-
-  entry = find_shell_variable (name);
-
-  if (entry == (SHELL_VAR *) 0)
-    {
-      /* Is NAME a nameref variable that points to an unset variable? */
-      entry = find_variable_nameref_for_create (name, 0);
-      if (entry == INVALID_NAMEREF_VALUE)
-	return ((SHELL_VAR *)0);
-      if (entry && nameref_p (entry))
-	entry = make_new_array_variable (nameref_cell (entry));
-    }
-  if (entry == (SHELL_VAR *) 0)
-    entry = make_new_array_variable (name);
-  else if ((readonly_p (entry) && (flags&ASS_FORCE) == 0) || noassign_p (entry))
-    {
-      if (readonly_p (entry))
-	err_readonly (name);
-      return (entry);
-    }
-  else if (array_p (entry) == 0)
-    entry = convert_var_to_array (entry);
-
-  /* ENTRY is an array variable, and ARRAY points to the value. */
-  return (bind_array_var_internal (entry, ind, 0, value, flags));
-}
-
-SHELL_VAR *
-bind_array_element (entry, ind, value, flags)
-     SHELL_VAR *entry;
-     arrayind_t ind;
-     char *value;
-     int flags;
-{
-  return (bind_array_var_internal (entry, ind, 0, value, flags));
-}
-                    
-SHELL_VAR *
-bind_assoc_variable (entry, name, key, value, flags)
-     SHELL_VAR *entry;
-     char *name;
-     char *key;
-     char *value;
-     int flags;
-{
-  if ((readonly_p (entry) && (flags&ASS_FORCE) == 0) || noassign_p (entry))
-    {
-      if (readonly_p (entry))
-	err_readonly (name);
-      return (entry);
-    }
-
-  return (bind_assoc_var_internal (entry, assoc_cell (entry), key, value, flags));
-}
-
-inline void
-init_eltstate (array_eltstate_t *estatep)
-{
-  if (estatep)
-    {
-      estatep->type = ARRAY_INVALID;
-      estatep->subtype = 0;
-      estatep->key = estatep->value = 0;
-      estatep->ind = INTMAX_MIN;
-    }
-}
-
-inline void
-flush_eltstate (array_eltstate_t *estatep)
-{
-  if (estatep)
-    FREE (estatep->key);
-}
-
-/* Parse NAME, a lhs of an assignment statement of the form v[s], and
-   assign VALUE to that array element by calling bind_array_variable().
-   Flags are ASS_ assignment flags */
-SHELL_VAR *
-assign_array_element (name, value, flags, estatep)
-     char *name, *value;
-     int flags;
-     array_eltstate_t *estatep;
-{
-  char *sub, *vname;
-  int sublen, isassoc, avflags;
-  SHELL_VAR *entry;
-
-  avflags = 0;
-  if (flags & ASS_NOEXPAND)
-    avflags |= AV_NOEXPAND;
-  if (flags & ASS_ONEWORD)
-    avflags |= AV_ONEWORD;
-  vname = array_variable_name (name, avflags, &sub, &sublen);
-
-  if (vname == 0)
-    return ((SHELL_VAR *)NULL);
-
-  entry = find_variable (vname);
-  isassoc = entry && assoc_p (entry);
-
-  /* We don't allow assignment to `*' or `@' associative array keys if the
-     caller hasn't told us the subscript has already been expanded
-     (ASS_NOEXPAND). If the caller has explicitly told us it's ok
-     (ASS_ALLOWALLSUB) we allow it. */
-  if (((isassoc == 0 || (flags & (ASS_NOEXPAND|ASS_ALLOWALLSUB)) == 0) &&
-	(ALL_ELEMENT_SUB (sub[0]) && sub[1] == ']')) ||
-      (sublen <= 1) ||
-      (sub[sublen] != '\0'))		/* sanity check */
-    {
-      free (vname);
-      err_badarraysub (name);
-      return ((SHELL_VAR *)NULL);
-    }
-
-  entry = assign_array_element_internal (entry, name, vname, sub, sublen, value, flags, estatep);
-
-#if ARRAY_EXPORT
-  if (entry && exported_p (entry))
-    {
-      INVALIDATE_EXPORTSTR (entry);
-      array_needs_making = 1;
-    }
-#endif
-
-  free (vname);
-  return entry;
-}
-
-static SHELL_VAR *
-assign_array_element_internal (entry, name, vname, sub, sublen, value, flags, estatep)
-     SHELL_VAR *entry;
-     char *name;		/* only used for error messages */
-     char *vname;
-     char *sub;
-     int sublen;
-     char *value;
-     int flags;
-     array_eltstate_t *estatep;
-{
-  char *akey, *nkey;
-  arrayind_t ind;
-  char *newval;
-
-  /* rely on the caller to initialize estatep */
-
-  if (entry && assoc_p (entry))
-    {
-      sub[sublen-1] = '\0';
-      if ((flags & ASS_NOEXPAND) == 0)
-	akey = expand_subscript_string (sub, 0);	/* [ */
-      else
-	akey = savestring (sub);
-      sub[sublen-1] = ']';
-      if (akey == 0 || *akey == 0)
-	{
-	  err_badarraysub (name);
-	  FREE (akey);
-	  return ((SHELL_VAR *)NULL);
-	}
-      if (estatep)
-	nkey = savestring (akey);	/* assoc_insert/assoc_replace frees akey */
-      entry = bind_assoc_variable (entry, vname, akey, value, flags);
-      if (estatep)
-	{
-	  estatep->type = ARRAY_ASSOC;
-	  estatep->key = nkey;
-	  estatep->value = entry ? assoc_reference (assoc_cell (entry), nkey) : 0;
-	}
-    }
-  else
-    {
-      ind = array_expand_index (entry, sub, sublen, 0);
-      /* negative subscripts to indexed arrays count back from end */
-      if (entry && ind < 0)
-	ind = (array_p (entry) ? array_max_index (array_cell (entry)) : 0) + 1 + ind;
-      if (ind < 0)
-	{
-	  err_badarraysub (name);
-	  return ((SHELL_VAR *)NULL);
-	}
-      entry = bind_array_variable (vname, ind, value, flags);
-      if (estatep)
-	{
-	  estatep->type = ARRAY_INDEXED;
-	  estatep->ind = ind;
-	  estatep->value = entry ? array_reference (array_cell (entry), ind) : 0;
-	}
-    }
-
-  return (entry);
-}
-
-/* Find the array variable corresponding to NAME.  If there is no variable,
-   create a new array variable.  If the variable exists but is not an array,
-   convert it to an indexed array.  If FLAGS&1 is non-zero, an existing
-   variable is checked for the readonly or noassign attribute in preparation
-   for assignment (e.g., by the `read' builtin).  If FLAGS&2 is non-zero, we
-   create an associative array. */
-SHELL_VAR *
-find_or_make_array_variable (name, flags)
-     char *name;
-     int flags;
-{
-  SHELL_VAR *var;
-
-  var = find_variable (name);
-  if (var == 0)
-    {
-      /* See if we have a nameref pointing to a variable that hasn't been
-	 created yet. */
-      var = find_variable_last_nameref (name, 1);
-      if (var && nameref_p (var) && invisible_p (var))
-	{
-	  internal_warning (_("%s: removing nameref attribute"), name);
-	  VUNSETATTR (var, att_nameref);
-	}
-      if (var && nameref_p (var))
-	{
-	  if (valid_nameref_value (nameref_cell (var), 2) == 0)
-	    {
-	      sh_invalidid (nameref_cell (var));
-	      return ((SHELL_VAR *)NULL);
-	    }
-	  var = (flags & 2) ? make_new_assoc_variable (nameref_cell (var)) : make_new_array_variable (nameref_cell (var));
-	}
-    }
-
-  if (var == 0)
-    var = (flags & 2) ? make_new_assoc_variable (name) : make_new_array_variable (name);
-  else if ((flags & 1) && (readonly_p (var) || noassign_p (var)))
-    {
-      if (readonly_p (var))
-	err_readonly (name);
-      return ((SHELL_VAR *)NULL);
-    }
-  else if ((flags & 2) && array_p (var))
-    {
-      set_exit_status (EXECUTION_FAILURE);
-      report_error (_("%s: cannot convert indexed to associative array"), name);
-      return ((SHELL_VAR *)NULL);
-    }
-  else if (flags & 2)
-    var = assoc_p (var) ? var : convert_var_to_assoc (var);
-  else if (array_p (var) == 0 && assoc_p (var) == 0)
-    var = convert_var_to_array (var);
-
-  return (var);
-}
-  
-/* Perform a compound assignment statement for array NAME, where VALUE is
-   the text between the parens:  NAME=( VALUE ) */
-SHELL_VAR *
-assign_array_from_string (name, value, flags)
-     char *name, *value;
-     int flags;
-{
-  SHELL_VAR *var;
-  int vflags;
-
-  vflags = 1;
-  if (flags & ASS_MKASSOC)
-    vflags |= 2;
-
-  var = find_or_make_array_variable (name, vflags);
-  if (var == 0)
-    return ((SHELL_VAR *)NULL);
-
-  return (assign_array_var_from_string (var, value, flags));
-}
-
-/* Sequentially assign the indices of indexed array variable VAR from the
-   words in LIST. */
-SHELL_VAR *
-assign_array_var_from_word_list (var, list, flags)
-     SHELL_VAR *var;
-     WORD_LIST *list;
-     int flags;
-{
-  register arrayind_t i;
-  register WORD_LIST *l;
-  ARRAY *a;
-
-  a = array_cell (var);
-  i = (flags & ASS_APPEND) ? array_max_index (a) + 1 : 0;
-
-  for (l = list; l; l = l->next, i++)
-    bind_array_var_internal (var, i, 0, l->word->word, flags & ~ASS_APPEND);
-
-  VUNSETATTR (var, att_invisible);	/* no longer invisible */
-
-  return var;
-}
-
-WORD_LIST *
-expand_compound_array_assignment (var, value, flags)
-     SHELL_VAR *var;
-     char *value;
-     int flags;
-{
-  WORD_LIST *list, *nlist;
-  char *val;
-  int ni;
-
-  /* This condition is true when invoked from the declare builtin with a
-     command like
-	declare -a d='([1]="" [2]="bdef" [5]="hello world" "test")' */
-  if (*value == '(')	/*)*/
-    {
-      ni = 1;
-      val = extract_array_assignment_list (value, &ni);
-      if (val == 0)
-	return (WORD_LIST *)NULL;
-    }
-  else
-    val = value;
-
-  /* Expand the value string into a list of words, performing all the
-     shell expansions including pathname generation and word splitting. */
-  /* First we split the string on whitespace, using the shell parser
-     (ksh93 seems to do this). */
-  /* XXX - this needs a rethink, maybe use split_at_delims */
-  list = parse_string_to_word_list (val, 1, "array assign");
-
-  /* If the parser has quoted CTLESC and CTNLNUL with CTLESC in unquoted
-     words, we need to remove those here because the code below assumes
-     they are there because they exist in the original word. */
-  /* XXX - if we rethink parse_string_to_word_list above, change this. */
-  for (nlist = list; nlist; nlist = nlist->next)
-    if ((nlist->word->flags & W_QUOTED) == 0)
-      remove_quoted_escapes (nlist->word->word);
-
-  /* Note that we defer expansion of the assignment statements for associative
-     arrays here, so we don't have to scan the subscript and find the ending
-     bracket twice. See the caller below. */
-  if (var && assoc_p (var))
-    {
-      if (val != value)
-	free (val);
-      return list;
-    }
-
-  /* If we're using [subscript]=value, we need to quote each [ and ] to
-     prevent unwanted filename expansion.  This doesn't need to be done
-     for associative array expansion, since that uses a different expansion
-     function (see assign_compound_array_list below). */
-  if (list)
-    quote_array_assignment_chars (list);
-
-  /* Now that we've split it, perform the shell expansions on each
-     word in the list. */
-  nlist = list ? expand_words_no_vars (list) : (WORD_LIST *)NULL;
-
-  dispose_words (list);
-
-  if (val != value)
-    free (val);
-
-  return nlist;
-}
-
-#if ASSOC_KVPAIR_ASSIGNMENT
-static void
-assign_assoc_from_kvlist (var, nlist, h, flags)
-     SHELL_VAR *var;
-     WORD_LIST *nlist;
-     HASH_TABLE *h;
-     int flags;
-{
-  WORD_LIST *list;
-  char *akey, *aval, *k, *v;
-
-  for (list = nlist; list; list = list->next)
-    {
-      k = list->word->word;
-      v = list->next ? list->next->word->word : 0;
-
-      if (list->next)
-        list = list->next;
-
-      akey = expand_subscript_string (k, 0);
-      if (akey == 0 || *akey == 0)
-	{
-	  err_badarraysub (k);
-	  FREE (akey);
-	  continue;
-	}	      
-
-      aval = expand_subscript_string (v, 0);
-      if (aval == 0)
-	{
-	  aval = (char *)xmalloc (1);
-	  aval[0] = '\0';	/* like do_assignment_internal */
-	}
-
-      bind_assoc_var_internal (var, h, akey, aval, flags);
-      free (aval);
-    }
-}
-
-/* Return non-zero if L appears to be a key-value pair associative array
-   compound assignment. */ 
-int
-kvpair_assignment_p (l)
-     WORD_LIST *l;
-{
-  return (l && (l->word->flags & W_ASSIGNMENT) == 0 && l->word->word[0] != '[');	/*]*/
-}
-
-char *
-expand_and_quote_kvpair_word (w)
-     char *w;
-{
-  char *r, *s, *t;
-
-  t = w ? expand_subscript_string (w, 0) : 0;
-  s = (t && strchr (t, CTLESC)) ? quote_escapes (t) : t;
-  r = sh_single_quote (s ? s : "");
-  if (s != t)
-    free (s);
-  free (t);
-  return r;
-}
-#endif
-     
-/* Callers ensure that VAR is not NULL. Associative array assignments have not
-   been expanded when this is called, or have been expanded once and single-
-   quoted, so we don't have to scan through an unquoted expanded subscript to
-   find the ending bracket; indexed array assignments have been expanded and
-   possibly single-quoted to prevent further expansion.
-
-   If this is an associative array, we perform the assignments into NHASH and
-   set NHASH to be the value of VAR after processing the assignments in NLIST */
-void
-assign_compound_array_list (var, nlist, flags)
-     SHELL_VAR *var;
-     WORD_LIST *nlist;
-     int flags;
-{
-  ARRAY *a;
-  HASH_TABLE *h, *nhash;
-  WORD_LIST *list;
-  char *w, *val, *nval, *savecmd;
-  int len, iflags, free_val;
-  arrayind_t ind, last_ind;
-  char *akey;
-
-  a = (var && array_p (var)) ? array_cell (var) : (ARRAY *)0;
-  nhash = h = (var && assoc_p (var)) ? assoc_cell (var) : (HASH_TABLE *)0;
-
-  akey = (char *)0;
-  ind = 0;
-
-  /* Now that we are ready to assign values to the array, kill the existing
-     value. */
-  if ((flags & ASS_APPEND) == 0)
-    {
-      if (a && array_p (var))
-	array_flush (a);
-      else if (h && assoc_p (var))
-	nhash = assoc_create (h->nbuckets);
-    }
-
-  last_ind = (a && (flags & ASS_APPEND)) ? array_max_index (a) + 1 : 0;
-
-#if ASSOC_KVPAIR_ASSIGNMENT
-  if (assoc_p (var) && kvpair_assignment_p (nlist))
-    {
-      iflags = flags & ~ASS_APPEND;
-      assign_assoc_from_kvlist (var, nlist, nhash, iflags);
-      if (nhash && nhash != h)
-	{
-	  h = assoc_cell (var);
-	  var_setassoc (var, nhash);
-	  assoc_dispose (h);
-	}
-      return;
-    }
-#endif
-
-  for (list = nlist; list; list = list->next)
-    {
-      /* Don't allow var+=(values) to make assignments in VALUES append to
-	 existing values by default. */
-      iflags = flags & ~ASS_APPEND;
-      w = list->word->word;
-
-      /* We have a word of the form [ind]=value */
-      if ((list->word->flags & W_ASSIGNMENT) && w[0] == '[')
-	{
-	  /* Don't have to handle embedded quotes specially any more, since
-	     associative array subscripts have not been expanded yet (see
-	     above). */
-	  len = skipsubscript (w, 0, 0);
-
-	  /* XXX - changes for `+=' */
- 	  if (w[len] != ']' || (w[len+1] != '=' && (w[len+1] != '+' || w[len+2] != '=')))
-	    {
-	      if (assoc_p (var))
-		{
-		  err_badarraysub (w);
-		  continue;
-		}
-	      nval = make_variable_value (var, w, flags);
-	      if (var->assign_func)
-		(*var->assign_func) (var, nval, last_ind, 0);
-	      else
-		array_insert (a, last_ind, nval);
-	      FREE (nval);
-	      last_ind++;
-	      continue;
-	    }
-
-	  if (len == 1)
-	    {
-	      err_badarraysub (w);
-	      continue;
-	    }
-
-	  if (ALL_ELEMENT_SUB (w[1]) && len == 2 && array_p (var))
-	    {
-	      set_exit_status (EXECUTION_FAILURE);
-	      report_error (_("%s: cannot assign to non-numeric index"), w);
-	      continue;
-	    }
-
-	  if (array_p (var))
-	    {
-	      ind = array_expand_index (var, w + 1, len, 0);
-	      /* negative subscripts to indexed arrays count back from end */
-	      if (ind < 0)
-		ind = array_max_index (array_cell (var)) + 1 + ind;
-	      if (ind < 0)
-		{
-		  err_badarraysub (w);
-		  continue;
-		}
-
-	      last_ind = ind;
-	    }
-	  else if (assoc_p (var))
-	    {
-	      /* This is not performed above, see expand_compound_array_assignment */
-	      w[len] = '\0';	/*[*/
-	      akey = expand_subscript_string (w+1, 0);
-	      w[len] = ']';
-	      /* And we need to expand the value also, see below */
-	      if (akey == 0 || *akey == 0)
-		{
-		  err_badarraysub (w);
-		  FREE (akey);
-		  continue;
-		}
-	    }
-
-	  /* XXX - changes for `+=' -- just accept the syntax.  ksh93 doesn't do this */
-	  if (w[len + 1] == '+' && w[len + 2] == '=')
-	    {
-	      iflags |= ASS_APPEND;
-	      val = w + len + 3;
-	    }
-	  else
-	    val = w + len + 2;	    
-	}
-      else if (assoc_p (var))
-	{
-	  set_exit_status (EXECUTION_FAILURE);
-	  report_error (_("%s: %s: must use subscript when assigning associative array"), var->name, w);
-	  continue;
-	}
-      else		/* No [ind]=value, just a stray `=' */
-	{
-	  ind = last_ind;
-	  val = w;
-	}
-
-      free_val = 0;
-      /* See above; we need to expand the value here */
-      if (assoc_p (var))
-	{
-	  val = expand_subscript_string (val, 0);
-	  if (val == 0)
-	    {
-	      val = (char *)xmalloc (1);
-	      val[0] = '\0';	/* like do_assignment_internal */
-	    }
-	  free_val = 1;
-	}
-
-      savecmd = this_command_name;
-      if (integer_p (var))
-	this_command_name = (char *)NULL;	/* no command name for errors */
-      if (assoc_p (var))
-	bind_assoc_var_internal (var, nhash, akey, val, iflags);
-      else
-	bind_array_var_internal (var, ind, akey, val, iflags);
-      last_ind++;
-      this_command_name = savecmd;
-
-      if (free_val)
-	free (val);
-    }
-
-  if (assoc_p (var) && nhash && nhash != h)
-    {
-      h = assoc_cell (var);
-      var_setassoc (var, nhash);
-      assoc_dispose (h);
-    }
-}
-
-/* Perform a compound array assignment:  VAR->name=( VALUE ).  The
-   VALUE has already had the parentheses stripped. */
-SHELL_VAR *
-assign_array_var_from_string (var, value, flags)
-     SHELL_VAR *var;
-     char *value;
-     int flags;
-{
-  WORD_LIST *nlist;
-
-  if (value == 0)
-    return var;
-
-  nlist = expand_compound_array_assignment (var, value, flags);
-  assign_compound_array_list (var, nlist, flags);
-
-  if (nlist)
-    dispose_words (nlist);
-
-  if (var)
-    VUNSETATTR (var, att_invisible);	/* no longer invisible */
-
-  return (var);
-}
-
-/* Quote globbing chars and characters in $IFS before the `=' in an assignment
-   statement (usually a compound array assignment) to protect them from
-   unwanted filename expansion or word splitting. */
-static char *
-quote_assign (string)
-     const char *string;
-{
-  size_t slen;
-  int saw_eq;
-  char *temp, *t, *subs;
-  const char *s, *send;
-  int ss, se;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  send = string + slen;
-
-  t = temp = (char *)xmalloc (slen * 2 + 1);
-  saw_eq = 0;
-  for (s = string; *s; )
-    {
-      if (*s == '=')
-	saw_eq = 1;
-      if (saw_eq == 0 && *s == '[')		/* looks like a subscript */
-	{
-	  ss = s - string;
-	  se = skipsubscript (string, ss, 0);
-	  subs = substring (s, ss, se);
-	  *t++ = '\\';
-	  strcpy (t, subs);
-	  t += se - ss;
-	  *t++ = '\\';
-	  *t++ = ']';
-	  s += se + 1;
-	  free (subs);
-	  continue;
-	}
-      if (saw_eq == 0 && (glob_char_p (s) || isifs (*s)))
-	*t++ = '\\';
-
-      COPY_CHAR_P (t, s, send);
-    }
-  *t = '\0';
-  return temp;
-}
-
-/* Take a word W of the form [IND]=VALUE and transform it to ['IND']='VALUE'
-   to prevent further expansion. This is called for compound assignments to
-   indexed arrays. W has already undergone word expansions. If W has no [IND]=,
-   just single-quote and return it. */
-static char *
-quote_compound_array_word (w, type)
-     char *w;
-     int type;
-{
-  char *nword, *sub, *value, *t;
-  int ind, wlen, i;
-
-  if (w[0] != LBRACK)
-    return (sh_single_quote (w));	/* XXX - quote CTLESC */
-  ind = skipsubscript (w, 0, 0);
-  if (w[ind] != RBRACK)
-    return (sh_single_quote (w));	/* XXX - quote CTLESC */
-
-  wlen = strlen (w);
-  w[ind] = '\0';
-  t = (strchr (w+1, CTLESC)) ? quote_escapes (w+1) : w+1;
-  sub = sh_single_quote (t);
-  if (t != w+1)
-   free (t);
-  w[ind] = RBRACK;
-
-  nword = xmalloc (wlen * 4 + 5);	/* wlen*4 is max single quoted length */
-  nword[0] = LBRACK;
-  i = STRLEN (sub);
-  memcpy (nword+1, sub, i);
-  free (sub);
-  i++;				/* accommodate the opening LBRACK */
-  nword[i++] = w[ind++];	/* RBRACK */
-  if (w[ind] == '+')
-    nword[i++] = w[ind++];
-  nword[i++] = w[ind++];
-  t = (strchr (w+ind, CTLESC)) ? quote_escapes (w+ind) : w+ind;
-  value = sh_single_quote (t);
-  if (t != w+ind)
-   free (t);
-  strcpy (nword + i, value);
-
-  return nword;
-}
-
-/* Expand the key and value in W, which is of the form [KEY]=VALUE, and
-   reconstruct W with the expanded and single-quoted version:
-   ['expanded-key']='expanded-value'. If there is no [KEY]=, single-quote the
-   word and return it. Very similar to previous function, but does not assume
-   W has already been expanded, and expands the KEY and VALUE separately.
-   Used for compound assignments to associative arrays that are arguments to
-   declaration builtins (declare -A a=( list )). */
-char *
-expand_and_quote_assoc_word (w, type)
-     char *w;
-     int type;
-{
-  char *nword, *key, *value, *s, *t;
-  int ind, wlen, i;
-
-  if (w[0] != LBRACK)
-    return (sh_single_quote (w));	/* XXX - quote_escapes */
-  ind = skipsubscript (w, 0, 0);
-  if (w[ind] != RBRACK)
-    return (sh_single_quote (w));	/* XXX - quote_escapes */
-
-  w[ind] = '\0';
-  t = expand_subscript_string (w+1, 0);
-  s = (t && strchr (t, CTLESC)) ? quote_escapes (t) : t;
-  key = sh_single_quote (s ? s : "");
-  if (s != t)
-    free (s);
-  w[ind] = RBRACK;
-  free (t);
-
-  wlen = STRLEN (key);
-  nword = xmalloc (wlen + 5);
-  nword[0] = LBRACK;
-  memcpy (nword+1, key, wlen);
-  i = wlen + 1;			/* accommodate the opening LBRACK */
-
-  nword[i++] = w[ind++];	/* RBRACK */
-  if (w[ind] == '+')
-    nword[i++] = w[ind++];
-  nword[i++] = w[ind++];
-
-  t = expand_subscript_string (w+ind, 0);
-  s = (t && strchr (t, CTLESC)) ? quote_escapes (t) : t;
-  value = sh_single_quote (s ? s : "");
-  if (s != t)
-    free (s);
-  free (t);
-  nword = xrealloc (nword, wlen + 5 + STRLEN (value));
-  strcpy (nword + i, value);
-
-  free (key);
-  free (value);
-
-  return nword;
-}
-
-/* For each word in a compound array assignment, if the word looks like
-   [ind]=value, single-quote ind and value, but leave the brackets and
-   the = sign (and any `+') alone. If it's not an assignment, just single-
-   quote the word. This is used for indexed arrays. */
-void
-quote_compound_array_list (list, type)
-     WORD_LIST *list;
-     int type;
-{
-  char *s, *t;
-  WORD_LIST *l;
-
-  for (l = list; l; l = l->next)
-    {
-      if (l->word == 0 || l->word->word == 0)
-	continue;	/* should not happen, but just in case... */
-      if ((l->word->flags & W_ASSIGNMENT) == 0)
-	{
-	  s = (strchr (l->word->word, CTLESC)) ? quote_escapes (l->word->word) : l->word->word;
-	  t = sh_single_quote (s);
-	  if (s != l->word->word)
-	    free (s);
-	}
-      else 
-	t = quote_compound_array_word (l->word->word, type);
-      free (l->word->word);
-      l->word->word = t;
-    }
-}
-
-/* For each word in a compound array assignment, if the word looks like
-   [ind]=value, quote globbing chars and characters in $IFS before the `='. */
-static void
-quote_array_assignment_chars (list)
-     WORD_LIST *list;
-{
-  char *nword;
-  WORD_LIST *l;
-
-  for (l = list; l; l = l->next)
-    {
-      if (l->word == 0 || l->word->word == 0 || l->word->word[0] == '\0')
-	continue;	/* should not happen, but just in case... */
-      /* Don't bother if it hasn't been recognized as an assignment or
-	 doesn't look like [ind]=value */
-      if ((l->word->flags & W_ASSIGNMENT) == 0)
-	continue;
-      if (l->word->word[0] != '[' || mbschr (l->word->word, '=') == 0) /* ] */
-	continue;
-
-      nword = quote_assign (l->word->word);
-      free (l->word->word);
-      l->word->word = nword;
-      l->word->flags |= W_NOGLOB;	/* XXX - W_NOSPLIT also? */
-    }
-}
-
-/* skipsubscript moved to subst.c to use private functions. 2009/02/24. */
-
-/* This function is called with SUB pointing to just after the beginning
-   `[' of an array subscript and removes the array element to which SUB
-   expands from array VAR.  A subscript of `*' or `@' unsets the array. */
-/* If FLAGS&1 (VA_NOEXPAND) we don't expand the subscript; we just use it
-   as-is. If FLAGS&VA_ONEWORD, we don't try to use skipsubscript to parse
-   the subscript, we just assume the subscript ends with a close bracket,
-   if one is present, and use what's inside the brackets. */
-int
-unbind_array_element (var, sub, flags)
-     SHELL_VAR *var;
-     char *sub;
-     int flags;
-{
-  arrayind_t ind;
-  char *akey;
-  ARRAY_ELEMENT *ae;
-
-  /* Assume that the caller (unset_builtin) passes us a null-terminated SUB,
-     so we don't have to use VA_ONEWORD or parse the subscript again with
-     skipsubscript(). */
-
-  if (ALL_ELEMENT_SUB (sub[0]) && sub[1] == 0)
-    {
-      if (array_p (var) || assoc_p (var))
-	{
-	  if (flags & VA_ALLOWALL)
-	    {
-	      unbind_variable (var->name);	/* XXX -- {array,assoc}_flush ? */
-	      return (0);
-	    }
-	  /* otherwise we fall through and try to unset element `@' or `*' */
-	}
-      else
-	return -2;	/* don't allow this to unset scalar variables */
-    }
-
-  if (assoc_p (var))
-    {
-      akey = (flags & VA_NOEXPAND) ? sub : expand_subscript_string (sub, 0);
-      if (akey == 0 || *akey == 0)
-	{
-	  builtin_error ("[%s]: %s", sub, _(bash_badsub_errmsg));
-	  FREE (akey);
-	  return -1;
-	}
-      assoc_remove (assoc_cell (var), akey);
-      if (akey != sub)
-	free (akey);
-    }
-  else if (array_p (var))
-    {
-      if (ALL_ELEMENT_SUB (sub[0]) && sub[1] == 0)
-	{
-	  /* We can go several ways here:
-		1) remove the array (backwards compatible)
-		2) empty the array (new behavior)
-		3) do nothing; treat the `@' or `*' as an expression and throw
-		   an error
-	  */
-	  /* Behavior 1 */
-	  if (shell_compatibility_level <= 51)
-	    {
-	      unbind_variable (name_cell (var));
-	      return 0;
-	    }
-	  else /* Behavior 2 */
-	    {
-	      array_flush (array_cell (var));
-	      return 0;
-	    }
-	  /* Fall through for behavior 3 */
-	}
-      ind = array_expand_index (var, sub, strlen (sub) + 1, 0);
-      /* negative subscripts to indexed arrays count back from end */
-      if (ind < 0)
-	ind = array_max_index (array_cell (var)) + 1 + ind;
-      if (ind < 0)
-	{
-	  builtin_error ("[%s]: %s", sub, _(bash_badsub_errmsg));
-	  return -1;
-	}
-      ae = array_remove (array_cell (var), ind);
-      if (ae)
-	array_dispose_element (ae);
-    }
-  else	/* array_p (var) == 0 && assoc_p (var) == 0 */
-    {
-      akey = this_command_name;
-      ind = array_expand_index (var, sub, strlen (sub) + 1, 0);
-      this_command_name = akey;
-      if (ind == 0)
-	{
-	  unbind_variable (var->name);
-	  return (0);
-	}
-      else
-	return -2;	/* any subscript other than 0 is invalid with scalar variables */
-    }
-
-  return 0;
-}
-
-/* Format and output an array assignment in compound form VAR=(VALUES),
-   suitable for re-use as input. */
-void
-print_array_assignment (var, quoted)
-     SHELL_VAR *var;
-     int quoted;
-{
-  char *vstr;
-
-  vstr = array_to_assign (array_cell (var), quoted);
-
-  if (vstr == 0)
-    printf ("%s=%s\n", var->name, quoted ? "'()'" : "()");
-  else
-    {
-      printf ("%s=%s\n", var->name, vstr);
-      free (vstr);
-    }
-}
-
-/* Format and output an associative array assignment in compound form
-   VAR=(VALUES), suitable for re-use as input. */
-void
-print_assoc_assignment (var, quoted)
-     SHELL_VAR *var;
-     int quoted;
-{
-  char *vstr;
-
-  vstr = assoc_to_assign (assoc_cell (var), quoted);
-
-  if (vstr == 0)
-    printf ("%s=%s\n", var->name, quoted ? "'()'" : "()");
-  else
-    {
-      printf ("%s=%s\n", var->name, vstr);
-      free (vstr);
-    }
-}
-
-/***********************************************************************/
-/*								       */
-/* Utility functions to manage arrays and their contents for expansion */
-/*								       */
-/***********************************************************************/
-
-/* Return 1 if NAME is a properly-formed array reference v[sub]. */
-
-/* Return 1 if NAME is a properly-formed array reference v[sub]. */
-
-/* When NAME is a properly-formed array reference and a non-null argument SUBP
-   is supplied, '[' and ']' that enclose the subscript are replaced by '\0',
-   and the pointer to the subscript in NAME is assigned to *SUBP, so that NAME
-   and SUBP can be later used as the array name and the subscript,
-   respectively.  When SUBP is the null pointer, the original string NAME will
-   not be modified. */
-/* We need to reserve 1 for FLAGS, which we pass to skipsubscript. */
-int
-tokenize_array_reference (name, flags, subp)
-     char *name;
-     int flags;
-     char **subp;
-{
-  char *t;
-  int r, len, isassoc, ssflags;
-  SHELL_VAR *entry;
-
-  t = mbschr (name, '[');	/* ] */
-  isassoc = 0;
-  if (t)
-    {
-      *t = '\0';
-      r = legal_identifier (name);
-      if (flags & VA_NOEXPAND)	/* Don't waste a lookup if we don't need one */
-	isassoc = (entry = find_variable (name)) && assoc_p (entry);      
-      *t = '[';
-      if (r == 0)
-	return 0;
-
-      ssflags = 0;
-      if (isassoc && ((flags & (VA_NOEXPAND|VA_ONEWORD)) == (VA_NOEXPAND|VA_ONEWORD)))
-	len = strlen (t) - 1;
-      else if (isassoc)
-	{
-	  if (flags & VA_NOEXPAND)
-	    ssflags |= 1;
-	  len = skipsubscript (t, 0, ssflags);
-	}
-      else
-	/* Check for a properly-terminated non-null subscript. */
-	len = skipsubscript (t, 0, 0);		/* arithmetic expression */
-
-      if (t[len] != ']' || len == 1 || t[len+1] != '\0')
-	return 0;
-
-#if 0
-      /* Could check and allow subscripts consisting only of whitespace for
-	 existing associative arrays, using isassoc */
-      for (r = 1; r < len; r++)
-	if (whitespace (t[r]) == 0)
-	  break;
-      if (r == len)
-	return 0; /* Fail if the subscript contains only whitespaces. */
-#endif
-
-      if (subp)
-	{
-	  t[0] = t[len] = '\0';
-	  *subp = t + 1;
-	}
-
-      /* This allows blank subscripts */
-      return 1;
-    }
-  return 0;
-}
-
-/* Return 1 if NAME is a properly-formed array reference v[sub]. */
-
-/* We need to reserve 1 for FLAGS, which we pass to skipsubscript. */
-int
-valid_array_reference (name, flags)
-     const char *name;
-     int flags;
-{
-  return tokenize_array_reference ((char *)name, flags, (char **)NULL);
-}
-
-/* Expand the array index beginning at S and extending LEN characters. */
-arrayind_t
-array_expand_index (var, s, len, flags)
-     SHELL_VAR *var;
-     char *s;
-     int len;
-     int flags;
-{
-  char *exp, *t, *savecmd;
-  int expok, eflag;
-  arrayind_t val;
-
-  exp = (char *)xmalloc (len);
-  strncpy (exp, s, len - 1);
-  exp[len - 1] = '\0';
-#if 0	/* TAG: maybe bash-5.2 */
-  if ((flags & AV_NOEXPAND) == 0)
-    t = expand_arith_string (exp, Q_DOUBLE_QUOTES|Q_ARITH|Q_ARRAYSUB);	/* XXX - Q_ARRAYSUB for future use */
-  else
-    t = exp;
-#else
-  t = expand_arith_string (exp, Q_DOUBLE_QUOTES|Q_ARITH|Q_ARRAYSUB);	/* XXX - Q_ARRAYSUB for future use */
-#endif
-  savecmd = this_command_name;
-  this_command_name = (char *)NULL;
-  eflag = (shell_compatibility_level > 51) ? 0 : EXP_EXPANDED;
-  val = evalexp (t, eflag, &expok);	/* XXX - was 0 but we expanded exp already */
-  this_command_name = savecmd;
-  if (t != exp)
-    free (t);
-  free (exp);
-  if (expok == 0)
-    {
-      set_exit_status (EXECUTION_FAILURE);
-
-      if (no_longjmp_on_fatal_error)
-	return 0;
-      top_level_cleanup ();      
-      jump_to_top_level (DISCARD);
-    }
-  return val;
-}
-
-/* Return the name of the variable specified by S without any subscript.
-   If SUBP is non-null, return a pointer to the start of the subscript
-   in *SUBP. If LENP is non-null, the length of the subscript is returned
-   in *LENP.  This returns newly-allocated memory. */
-char *
-array_variable_name (s, flags, subp, lenp)
-     const char *s;
-     int flags;
-     char **subp;
-     int *lenp;
-{
-  char *t, *ret;
-  int ind, ni, ssflags;
-
-  t = mbschr (s, '[');
-  if (t == 0)
-    {
-      if (subp)
-      	*subp = t;
-      if (lenp)
-	*lenp = 0;
-      return ((char *)NULL);
-    }
-  ind = t - s;
-  if ((flags & (AV_NOEXPAND|AV_ONEWORD)) == (AV_NOEXPAND|AV_ONEWORD))
-    ni = strlen (s) - 1;
-  else
-    {
-      ssflags = 0;
-      if (flags & AV_NOEXPAND)
-	ssflags |= 1;
-      ni = skipsubscript (s, ind, ssflags);
-    }
-  if (ni <= ind + 1 || s[ni] != ']')
-    {
-      err_badarraysub (s);
-      if (subp)
-      	*subp = t;
-      if (lenp)
-	*lenp = 0;
-      return ((char *)NULL);
-    }
-
-  *t = '\0';
-  ret = savestring (s);
-  *t++ = '[';		/* ] */
-
-  if (subp)
-    *subp = t;
-  if (lenp)
-    *lenp = ni - ind;
-
-  return ret;
-}
-
-/* Return the variable specified by S without any subscript.  If SUBP is
-   non-null, return a pointer to the start of the subscript in *SUBP.
-   If LENP is non-null, the length of the subscript is returned in *LENP. */
-SHELL_VAR *
-array_variable_part (s, flags, subp, lenp)
-     const char *s;
-     int flags;
-     char **subp;
-     int *lenp;
-{
-  char *t;
-  SHELL_VAR *var;
-
-  t = array_variable_name (s, flags, subp, lenp);
-  if (t == 0)
-    return ((SHELL_VAR *)NULL);
-  var = find_variable (t);		/* XXX - handle namerefs here? */
-
-  free (t);
-  return var;	/* now return invisible variables; caller must handle */
-}
-
-#define INDEX_ERROR() \
-  do \
-    { \
-      if (var) \
-	err_badarraysub (var->name); \
-      else \
-	{ \
-	  t[-1] = '\0'; \
-	  err_badarraysub (s); \
-	  t[-1] = '[';	/* ] */\
-	} \
-      return ((char *)NULL); \
-    } \
-  while (0)
-
-/* Return a string containing the elements in the array and subscript
-   described by S.  If the subscript is * or @, obeys quoting rules akin
-   to the expansion of $* and $@ including double quoting.  If RTYPE
-   is non-null it gets 1 if the array reference is name[*], 2 if the
-   reference is name[@], and 0 otherwise. */
-static char *
-array_value_internal (s, quoted, flags, estatep)
-     const char *s;
-     int quoted, flags;
-     array_eltstate_t *estatep;
-{
-  int len, isassoc, subtype;
-  arrayind_t ind;
-  char *akey;
-  char *retval, *t, *temp;
-  WORD_LIST *l;
-  SHELL_VAR *var;
-
-  var = array_variable_part (s, flags, &t, &len);	/* XXX */
-
-  /* Expand the index, even if the variable doesn't exist, in case side
-     effects are needed, like ${w[i++]} where w is unset. */
-#if 0
-  if (var == 0)
-    return (char *)NULL;
-#endif
-
-  if (len == 0)
-    return ((char *)NULL);	/* error message already printed */
-
-  isassoc = var && assoc_p (var);
-  /* [ */
-  akey = 0;
-  subtype = 0;
-  if (estatep)
-    estatep->value = (char *)NULL;
-
-  /* Backwards compatibility: we only change the behavior of A[@] and A[*]
-     for associative arrays, and the caller has to request it. */
-  if ((isassoc == 0 || (flags & AV_ATSTARKEYS) == 0) && ALL_ELEMENT_SUB (t[0]) && t[1] == ']')
-    {
-      if (estatep)
-	estatep->subtype = (t[0] == '*') ? 1 : 2;
-      if ((flags & AV_ALLOWALL) == 0)
-	{
-	  err_badarraysub (s);
-	  return ((char *)NULL);
-	}
-      else if (var == 0 || value_cell (var) == 0)
-	return ((char *)NULL);
-      else if (invisible_p (var))
-	return ((char *)NULL);
-      else if (array_p (var) == 0 && assoc_p (var) == 0)
-        {
-          if (estatep)
-	    estatep->type = ARRAY_SCALAR;
-	  l = add_string_to_list (value_cell (var), (WORD_LIST *)NULL);
-        }
-      else if (assoc_p (var))
-	{
-	  if (estatep)
-	    estatep->type = ARRAY_ASSOC;
-	  l = assoc_to_word_list (assoc_cell (var));
-	  if (l == (WORD_LIST *)NULL)
-	    return ((char *)NULL);
-	}
-      else
-	{
-	  if (estatep)
-	    estatep->type = ARRAY_INDEXED;
-	  l = array_to_word_list (array_cell (var));
-	  if (l == (WORD_LIST *)NULL)
-	    return ((char *) NULL);
-	}
-
-      /* Caller of array_value takes care of inspecting estatep->subtype and
-         duplicating retval if subtype == 0, so this is not a memory leak */
-      if (t[0] == '*' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-	{
-	  temp = string_list_dollar_star (l, quoted, (flags & AV_ASSIGNRHS) ? PF_ASSIGNRHS : 0);
-	  retval = quote_string (temp);
-	  free (temp);
-	}
-      else	/* ${name[@]} or unquoted ${name[*]} */
-	retval = string_list_dollar_at (l, quoted, (flags & AV_ASSIGNRHS) ? PF_ASSIGNRHS : 0);
-
-      dispose_words (l);
-    }
-  else
-    {
-      if (estatep)
-	estatep->subtype = 0;
-      if (var == 0 || array_p (var) || assoc_p (var) == 0)
-	{
-	  if ((flags & AV_USEIND) == 0 || estatep == 0)
-	    {
-	      ind = array_expand_index (var, t, len, flags);
-	      if (ind < 0)
-		{
-		  /* negative subscripts to indexed arrays count back from end */
-		  if (var && array_p (var))
-		    ind = array_max_index (array_cell (var)) + 1 + ind;
-		  if (ind < 0)
-		    INDEX_ERROR();
-		}
-	      if (estatep)
-		estatep->ind = ind;
-	    }
-	  else if (estatep && (flags & AV_USEIND))
-	    ind = estatep->ind;
-	  if (estatep && var)
-	    estatep->type = array_p (var) ? ARRAY_INDEXED : ARRAY_SCALAR;
-	}
-      else if (assoc_p (var))
-	{
-	  t[len - 1] = '\0';
-	  if (estatep)
-	    estatep->type = ARRAY_ASSOC;
-	  if ((flags & AV_USEIND) && estatep && estatep->key)
-	    akey = savestring (estatep->key);
-	  else if ((flags & AV_NOEXPAND) == 0)
-	    akey = expand_subscript_string (t, 0);	/* [ */
-	  else
-	    akey = savestring (t);
-	  t[len - 1] = ']';
-	  if (akey == 0 || *akey == 0)
-	    {
-	      FREE (akey);
-	      INDEX_ERROR();
-	    }
-	}
-
-      if (var == 0 || value_cell (var) == 0)
-	{
-	  FREE (akey);
-	  return ((char *)NULL);
-	}
-      else if (invisible_p (var))
-	{
-	  FREE (akey);
-	  return ((char *)NULL);
-	}
-      if (array_p (var) == 0 && assoc_p (var) == 0)
-	retval = (ind == 0) ? value_cell (var) : (char *)NULL;
-      else if (assoc_p (var))
-        {
-	  retval = assoc_reference (assoc_cell (var), akey);
-	  if (estatep && estatep->key && (flags & AV_USEIND))
-	    free (akey);		/* duplicated estatep->key */
-	  else if (estatep)
-	    estatep->key = akey;	/* XXX - caller must manage */
-	  else				/* not saving it anywhere */
-	    free (akey);
-        }
-      else
-	retval = array_reference (array_cell (var), ind);
-
-      if (estatep)
-	estatep->value = retval;
-    }
-
-  return retval;
-}
-
-/* Return a string containing the elements described by the array and
-   subscript contained in S, obeying quoting for subscripts * and @. */
-char *
-array_value (s, quoted, flags, estatep)
-     const char *s;
-     int quoted, flags;
-     array_eltstate_t *estatep;
-{
-  char *retval;
-
-  retval = array_value_internal (s, quoted, flags|AV_ALLOWALL, estatep);
-  return retval;
-}
-
-/* Return the value of the array indexing expression S as a single string.
-   If (FLAGS & AV_ALLOWALL) is 0, do not allow `@' and `*' subscripts.  This
-   is used by other parts of the shell such as the arithmetic expression
-   evaluator in expr.c. */
-char *
-get_array_value (s, flags, estatep)
-     const char *s;
-     int flags;
-     array_eltstate_t *estatep;
-{
-  char *retval;
-
-  retval = array_value_internal (s, 0, flags, estatep);
-  return retval;
-}
-
-char *
-array_keys (s, quoted, pflags)
-     char *s;
-     int quoted, pflags;
-{
-  int len;
-  char *retval, *t, *temp;
-  WORD_LIST *l;
-  SHELL_VAR *var;
-
-  var = array_variable_part (s, 0, &t, &len);
-
-  /* [ */
-  if (var == 0 || ALL_ELEMENT_SUB (t[0]) == 0 || t[1] != ']')
-    return (char *)NULL;
-
-  if (var_isset (var) == 0 || invisible_p (var))
-    return (char *)NULL;
-
-  if (array_p (var) == 0 && assoc_p (var) == 0)
-    l = add_string_to_list ("0", (WORD_LIST *)NULL);
-  else if (assoc_p (var))
-    l = assoc_keys_to_word_list (assoc_cell (var));
-  else
-    l = array_keys_to_word_list (array_cell (var));
-  if (l == (WORD_LIST *)NULL)
-    return ((char *) NULL);
-
-  retval = string_list_pos_params (t[0], l, quoted, pflags);
-
-  dispose_words (l);
-  return retval;
-}
-#endif /* ARRAY_VARS */
diff --git a/third_party/bash/arrayfunc.h b/third_party/bash/arrayfunc.h
deleted file mode 100644
index 69112b579..000000000
--- a/third_party/bash/arrayfunc.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/* arrayfunc.h -- declarations for miscellaneous array functions in arrayfunc.c */
-
-/* Copyright (C) 2001-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_ARRAYFUNC_H_)
-#define _ARRAYFUNC_H_
-
-/* Must include variables.h before including this file. */
-
-/* An object to encapsulate the state of an array element. It can describe
-   an array assignment A[KEY]=VALUE or a[IND]=VALUE depending on TYPE, or
-   for passing array subscript references around, where VALUE would be
-   ${a[IND]} or ${A[KEY]}.  This is not dependent on ARRAY_VARS so we can
-   use it in function parameters. */
-
-/* values for `type' field */
-#define ARRAY_INVALID	-1
-#define ARRAY_SCALAR	0
-#define ARRAY_INDEXED	1
-#define ARRAY_ASSOC	2
-
-/* KEY will contain allocated memory if called through the assign_array_element
-   code path because of how assoc_insert works. */
-typedef struct element_state
-{
-  short type;			/* assoc or indexed, says which fields are valid */  
-  short subtype;		/* `*', `@', or something else */
-  arrayind_t ind;
-  char *key;			/* can be allocated memory */
-  char *value;
-} array_eltstate_t;
-
-#if defined (ARRAY_VARS)
-
-/* This variable means to not expand associative array subscripts more than
-   once, when performing variable expansion. */
-extern int assoc_expand_once;
-
-/* The analog for indexed array subscripts */
-extern int array_expand_once;
-
-/* Flags for array_value_internal and callers array_value/get_array_value; also
-   used by array_variable_name and array_variable_part. */
-#define AV_ALLOWALL	0x001	/* treat a[@] like $@ and a[*] like $* */
-#define AV_QUOTED	0x002
-#define AV_USEIND	0x004
-#define AV_USEVAL	0x008	/* XXX - should move this */
-#define AV_ASSIGNRHS	0x010	/* no splitting, special case ${a[@]} */
-#define AV_NOEXPAND	0x020	/* don't run assoc subscripts through word expansion */
-#define AV_ONEWORD	0x040	/* not used yet */
-#define AV_ATSTARKEYS	0x080	/* accept a[@] and a[*] but use them as keys, not special values */
-
-/* Flags for valid_array_reference. Value 1 is reserved for skipsubscript().
-   Also used by unbind_array_element, which is currently the only function
-   that uses VA_ALLOWALL. */
-#define VA_NOEXPAND	0x001
-#define VA_ONEWORD	0x002
-#define VA_ALLOWALL	0x004	/* allow @ to mean all elements of the array */
-
-extern SHELL_VAR *convert_var_to_array PARAMS((SHELL_VAR *));
-extern SHELL_VAR *convert_var_to_assoc PARAMS((SHELL_VAR *));
-
-extern char *make_array_variable_value PARAMS((SHELL_VAR *, arrayind_t, char *, char *, int));
-
-extern SHELL_VAR *bind_array_variable PARAMS((char *, arrayind_t, char *, int));
-extern SHELL_VAR *bind_array_element PARAMS((SHELL_VAR *, arrayind_t, char *, int));
-extern SHELL_VAR *assign_array_element PARAMS((char *, char *, int, array_eltstate_t *));
-
-extern SHELL_VAR *bind_assoc_variable PARAMS((SHELL_VAR *, char *, char *, char *, int));
-
-extern SHELL_VAR *find_or_make_array_variable PARAMS((char *, int));
-
-extern SHELL_VAR *assign_array_from_string  PARAMS((char *, char *, int));
-extern SHELL_VAR *assign_array_var_from_word_list PARAMS((SHELL_VAR *, WORD_LIST *, int));
-
-extern WORD_LIST *expand_compound_array_assignment PARAMS((SHELL_VAR *, char *, int));
-extern void assign_compound_array_list PARAMS((SHELL_VAR *, WORD_LIST *, int));
-extern SHELL_VAR *assign_array_var_from_string PARAMS((SHELL_VAR *, char *, int));
-
-extern char *expand_and_quote_assoc_word PARAMS((char *, int));
-extern void quote_compound_array_list PARAMS((WORD_LIST *, int));
-
-extern int kvpair_assignment_p PARAMS((WORD_LIST *));
-extern char *expand_and_quote_kvpair_word PARAMS((char *));
-
-extern int unbind_array_element PARAMS((SHELL_VAR *, char *, int));
-extern int skipsubscript PARAMS((const char *, int, int));
-
-extern void print_array_assignment PARAMS((SHELL_VAR *, int));
-extern void print_assoc_assignment PARAMS((SHELL_VAR *, int));
-
-extern arrayind_t array_expand_index PARAMS((SHELL_VAR *, char *, int, int));
-extern int valid_array_reference PARAMS((const char *, int));
-extern int tokenize_array_reference PARAMS((char *, int, char **));
-
-extern char *array_value PARAMS((const char *, int, int, array_eltstate_t *));
-extern char *get_array_value PARAMS((const char *, int, array_eltstate_t *));
-
-extern char *array_keys PARAMS((char *, int, int));
-
-extern char *array_variable_name PARAMS((const char *, int, char **, int *));
-extern SHELL_VAR *array_variable_part PARAMS((const char *, int, char **, int *));
-
-extern void init_eltstate (array_eltstate_t *);
-extern void flush_eltstate (array_eltstate_t *);
-
-#else
-
-#define AV_ALLOWALL	0
-#define AV_QUOTED	0
-#define AV_USEIND	0
-#define AV_USEVAL	0
-#define AV_ASSIGNRHS	0
-#define AV_NOEXPAND	0
-#define AV_ONEWORD	0
-#define AV_ATSTARKEYS	0
-
-#define VA_NOEXPAND	0
-#define VA_ONEWORD	0
-#define VA_ALLOWALL	0
-
-#endif
-
-#endif /* !_ARRAYFUNC_H_ */
diff --git a/third_party/bash/assoc.c b/third_party/bash/assoc.c
deleted file mode 100644
index e29fade75..000000000
--- a/third_party/bash/assoc.c
+++ /dev/null
@@ -1,611 +0,0 @@
-/*
- * assoc.c - functions to manipulate associative arrays
- *
- * Associative arrays are standard shell hash tables.
- *
- * Chet Ramey
- * chet@ins.cwru.edu
- */
-
-/* Copyright (C) 2008,2009,2011-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (ARRAY_VARS)
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "bashansi.h"
-
-#include "shell.h"
-#include "array.h"
-#include "assoc.h"
-#include "common.h"
-
-static WORD_LIST *assoc_to_word_list_internal PARAMS((HASH_TABLE *, int));
-
-/* assoc_create == hash_create */
-
-void
-assoc_dispose (hash)
-     HASH_TABLE *hash;
-{
-  if (hash)
-    {
-      hash_flush (hash, 0);
-      hash_dispose (hash);
-    }
-}
-
-void
-assoc_flush (hash)
-     HASH_TABLE *hash;
-{
-  hash_flush (hash, 0);
-}
-
-int
-assoc_insert (hash, key, value)
-     HASH_TABLE *hash;
-     char *key;
-     char *value;
-{
-  BUCKET_CONTENTS *b;
-
-  b = hash_search (key, hash, HASH_CREATE);
-  if (b == 0)
-    return -1;
-  /* If we are overwriting an existing element's value, we're not going to
-     use the key.  Nothing in the array assignment code path frees the key
-     string, so we can free it here to avoid a memory leak. */
-  if (b->key != key)
-    free (key);
-  FREE (b->data);
-  b->data = value ? savestring (value) : (char *)0;
-  return (0);
-}
-
-/* Like assoc_insert, but returns b->data instead of freeing it */
-PTR_T
-assoc_replace (hash, key, value)
-     HASH_TABLE *hash;
-     char *key;
-     char *value;
-{
-  BUCKET_CONTENTS *b;
-  PTR_T t;
-
-  b = hash_search (key, hash, HASH_CREATE);
-  if (b == 0)
-    return (PTR_T)0;
-  /* If we are overwriting an existing element's value, we're not going to
-     use the key.  Nothing in the array assignment code path frees the key
-     string, so we can free it here to avoid a memory leak. */
-  if (b->key != key)
-    free (key);
-  t = b->data;
-  b->data = value ? savestring (value) : (char *)0;
-  return t;
-}
-
-void
-assoc_remove (hash, string)
-     HASH_TABLE *hash;
-     char *string;
-{
-  BUCKET_CONTENTS *b;
-
-  b = hash_remove (string, hash, 0);
-  if (b)
-    {
-      free ((char *)b->data);
-      free (b->key);
-      free (b);
-    }
-}
-
-char *
-assoc_reference (hash, string)
-     HASH_TABLE *hash;
-     char *string;
-{
-  BUCKET_CONTENTS *b;
-
-  if (hash == 0)
-    return (char *)0;
-
-  b = hash_search (string, hash, 0);
-  return (b ? (char *)b->data : 0);
-}
-
-/* Quote the data associated with each element of the hash table ASSOC,
-   using quote_string */
-HASH_TABLE *
-assoc_quote (h)
-     HASH_TABLE *h;
-{
-  int i;
-  BUCKET_CONTENTS *tlist;
-  char *t;
-
-  if (h == 0 || assoc_empty (h))
-    return ((HASH_TABLE *)NULL);
-  
-  for (i = 0; i < h->nbuckets; i++)
-    for (tlist = hash_items (i, h); tlist; tlist = tlist->next)
-      {
-	t = quote_string ((char *)tlist->data);
-	FREE (tlist->data);
-	tlist->data = t;
-      }
-
-  return h;
-}
-
-/* Quote escape characters in the data associated with each element
-   of the hash table ASSOC, using quote_escapes */
-HASH_TABLE *
-assoc_quote_escapes (h)
-     HASH_TABLE *h;
-{
-  int i;
-  BUCKET_CONTENTS *tlist;
-  char *t;
-
-  if (h == 0 || assoc_empty (h))
-    return ((HASH_TABLE *)NULL);
-  
-  for (i = 0; i < h->nbuckets; i++)
-    for (tlist = hash_items (i, h); tlist; tlist = tlist->next)
-      {
-	t = quote_escapes ((char *)tlist->data);
-	FREE (tlist->data);
-	tlist->data = t;
-      }
-
-  return h;
-}
-
-HASH_TABLE *
-assoc_dequote (h)
-     HASH_TABLE *h;
-{
-  int i;
-  BUCKET_CONTENTS *tlist;
-  char *t;
-
-  if (h == 0 || assoc_empty (h))
-    return ((HASH_TABLE *)NULL);
-  
-  for (i = 0; i < h->nbuckets; i++)
-    for (tlist = hash_items (i, h); tlist; tlist = tlist->next)
-      {
-	t = dequote_string ((char *)tlist->data);
-	FREE (tlist->data);
-	tlist->data = t;
-      }
-
-  return h;
-}
-
-HASH_TABLE *
-assoc_dequote_escapes (h)
-     HASH_TABLE *h;
-{
-  int i;
-  BUCKET_CONTENTS *tlist;
-  char *t;
-
-  if (h == 0 || assoc_empty (h))
-    return ((HASH_TABLE *)NULL);
-  
-  for (i = 0; i < h->nbuckets; i++)
-    for (tlist = hash_items (i, h); tlist; tlist = tlist->next)
-      {
-	t = dequote_escapes ((char *)tlist->data);
-	FREE (tlist->data);
-	tlist->data = t;
-      }
-
-  return h;
-}
-
-HASH_TABLE *
-assoc_remove_quoted_nulls (h)
-     HASH_TABLE *h;
-{
-  int i;
-  BUCKET_CONTENTS *tlist;
-  char *t;
-
-  if (h == 0 || assoc_empty (h))
-    return ((HASH_TABLE *)NULL);
-  
-  for (i = 0; i < h->nbuckets; i++)
-    for (tlist = hash_items (i, h); tlist; tlist = tlist->next)
-      {
-	t = remove_quoted_nulls ((char *)tlist->data);
-	tlist->data = t;
-      }
-
-  return h;
-}
-
-/*
- * Return a string whose elements are the members of array H beginning at
- * the STARTth element and spanning NELEM members.  Null elements are counted.
- */
-char *
-assoc_subrange (hash, start, nelem, starsub, quoted, pflags)
-     HASH_TABLE *hash;
-     arrayind_t start, nelem;
-     int starsub, quoted, pflags;
-{
-  WORD_LIST *l, *save, *h, *t;
-  int i, j;
-  char *ret;
-
-  if (assoc_empty (hash))
-    return ((char *)NULL);
-
-  save = l = assoc_to_word_list (hash);
-  if (save == 0)
-    return ((char *)NULL);
-
-  for (i = 1; l && i < start; i++)
-    l = l->next;
-  if (l == 0)
-    {
-      dispose_words (save);
-      return ((char *)NULL);
-    }
-  for (j = 0,h = t = l; l && j < nelem; j++)
-    {
-      t = l;
-      l = l->next;
-    }
-
-  t->next = (WORD_LIST *)NULL;
-
-  ret = string_list_pos_params (starsub ? '*' : '@', h, quoted, pflags);
-
-  if (t != l)
-    t->next = l;
-
-  dispose_words (save);
-  return (ret);
-
-}
-
-char *
-assoc_patsub (h, pat, rep, mflags)
-     HASH_TABLE *h;
-     char *pat, *rep;
-     int mflags;
-{
-  char	*t;
-  int pchar, qflags, pflags;
-  WORD_LIST *wl, *save;
-
-  if (h == 0 || assoc_empty (h))
-    return ((char *)NULL);
-
-  wl = assoc_to_word_list (h);
-  if (wl == 0)
-    return (char *)NULL;
-
-  for (save = wl; wl; wl = wl->next)
-    {
-      t = pat_subst (wl->word->word, pat, rep, mflags);
-      FREE (wl->word->word);
-      wl->word->word = t;
-    }
-
-  pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';
-  qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;
-  pflags = (mflags & MATCH_ASSIGNRHS) == MATCH_ASSIGNRHS ? PF_ASSIGNRHS : 0;
-
-  t = string_list_pos_params (pchar, save, qflags, pflags);
-  dispose_words (save);
-
-  return t;
-}
-
-char *
-assoc_modcase (h, pat, modop, mflags)
-     HASH_TABLE *h;
-     char *pat;
-     int modop;
-     int mflags;
-{
-  char	*t;
-  int pchar, qflags, pflags;
-  WORD_LIST *wl, *save;
-
-  if (h == 0 || assoc_empty (h))
-    return ((char *)NULL);
-
-  wl = assoc_to_word_list (h);
-  if (wl == 0)
-    return ((char *)NULL);
-
-  for (save = wl; wl; wl = wl->next)
-    {
-      t = sh_modcase (wl->word->word, pat, modop);
-      FREE (wl->word->word);
-      wl->word->word = t;
-    }
-
-  pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';
-  qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;
-  pflags = (mflags & MATCH_ASSIGNRHS) == MATCH_ASSIGNRHS ? PF_ASSIGNRHS : 0;
-
-  t = string_list_pos_params (pchar, save, qflags, pflags);
-  dispose_words (save);
-
-  return t;
-}
-
-char *
-assoc_to_kvpair (hash, quoted)
-     HASH_TABLE *hash;
-     int quoted;
-{
-  char *ret;
-  char *istr, *vstr;
-  int i, rsize, rlen, elen;
-  BUCKET_CONTENTS *tlist;
-
-  if (hash == 0 || assoc_empty (hash))
-    return (char *)0;
-
-  ret = xmalloc (rsize = 128);
-  ret[rlen = 0] = '\0';
-
-  for (i = 0; i < hash->nbuckets; i++)
-    for (tlist = hash_items (i, hash); tlist; tlist = tlist->next)
-      {
-	if (ansic_shouldquote (tlist->key))
-	  istr = ansic_quote (tlist->key, 0, (int *)0);
-	else if (sh_contains_shell_metas (tlist->key))
-	  istr = sh_double_quote (tlist->key);
-	else if (ALL_ELEMENT_SUB (tlist->key[0]) && tlist->key[1] == '\0')
-	  istr = sh_double_quote (tlist->key);	
-	else
-	  istr = tlist->key;	
-
-	vstr = tlist->data ? (ansic_shouldquote ((char *)tlist->data) ?
-				ansic_quote ((char *)tlist->data, 0, (int *)0) :
-				sh_double_quote ((char *)tlist->data))
-			   : (char *)0;
-
-	elen = STRLEN (istr) + 4 + STRLEN (vstr);
-	RESIZE_MALLOCED_BUFFER (ret, rlen, (elen+1), rsize, rsize);
-
-	strcpy (ret+rlen, istr);
-	rlen += STRLEN (istr);
-	ret[rlen++] = ' ';
-	if (vstr)
-	  {
-	    strcpy (ret + rlen, vstr);
-	    rlen += STRLEN (vstr);
-	  }
-	else
-	  {
-	    strcpy (ret + rlen, "\"\"");
-	    rlen += 2;
-	  }
-	ret[rlen++] = ' ';
-
-	if (istr != tlist->key)
-	  FREE (istr);
-
-	FREE (vstr);
-    }
-
-  RESIZE_MALLOCED_BUFFER (ret, rlen, 1, rsize, 8);
-  ret[rlen] = '\0';
-
-  if (quoted)
-    {
-      vstr = sh_single_quote (ret);
-      free (ret);
-      ret = vstr;
-    }
-
-  return ret;
-}
-
-char *
-assoc_to_assign (hash, quoted)
-     HASH_TABLE *hash;
-     int quoted;
-{
-  char *ret;
-  char *istr, *vstr;
-  int i, rsize, rlen, elen;
-  BUCKET_CONTENTS *tlist;
-
-  if (hash == 0 || assoc_empty (hash))
-    return (char *)0;
-
-  ret = xmalloc (rsize = 128);
-  ret[0] = '(';
-  rlen = 1;
-
-  for (i = 0; i < hash->nbuckets; i++)
-    for (tlist = hash_items (i, hash); tlist; tlist = tlist->next)
-      {
-	if (ansic_shouldquote (tlist->key))
-	  istr = ansic_quote (tlist->key, 0, (int *)0);
-	else if (sh_contains_shell_metas (tlist->key))
-	  istr = sh_double_quote (tlist->key);
-	else if (ALL_ELEMENT_SUB (tlist->key[0]) && tlist->key[1] == '\0')
-	  istr = sh_double_quote (tlist->key);	
-	else
-	  istr = tlist->key;	
-
-	vstr = tlist->data ? (ansic_shouldquote ((char *)tlist->data) ?
-				ansic_quote ((char *)tlist->data, 0, (int *)0) :
-				sh_double_quote ((char *)tlist->data))
-			   : (char *)0;
-
-	elen = STRLEN (istr) + 8 + STRLEN (vstr);
-	RESIZE_MALLOCED_BUFFER (ret, rlen, (elen+1), rsize, rsize);
-
-	ret[rlen++] = '[';
-	strcpy (ret+rlen, istr);
-	rlen += STRLEN (istr);
-	ret[rlen++] = ']';
-	ret[rlen++] = '=';
-	if (vstr)
-	  {
-	    strcpy (ret + rlen, vstr);
-	    rlen += STRLEN (vstr);
-	  }
-	ret[rlen++] = ' ';
-
-	if (istr != tlist->key)
-	  FREE (istr);
-
-	FREE (vstr);
-    }
-
-  RESIZE_MALLOCED_BUFFER (ret, rlen, 1, rsize, 8);
-  ret[rlen++] = ')';
-  ret[rlen] = '\0';
-
-  if (quoted)
-    {
-      vstr = sh_single_quote (ret);
-      free (ret);
-      ret = vstr;
-    }
-
-  return ret;
-}
-
-static WORD_LIST *
-assoc_to_word_list_internal (h, t)
-     HASH_TABLE *h;
-     int t;
-{
-  WORD_LIST *list;
-  int i;
-  BUCKET_CONTENTS *tlist;
-  char *w;
-
-  if (h == 0 || assoc_empty (h))
-    return((WORD_LIST *)NULL);
-  list = (WORD_LIST *)NULL;
-  
-  for (i = 0; i < h->nbuckets; i++)
-    for (tlist = hash_items (i, h); tlist; tlist = tlist->next)
-      {
-	w = (t == 0) ? (char *)tlist->data : (char *)tlist->key;
-	list = make_word_list (make_bare_word(w), list);
-      }
-  return (REVERSE_LIST(list, WORD_LIST *));
-}
-
-WORD_LIST *
-assoc_to_word_list (h)
-     HASH_TABLE *h;
-{
-  return (assoc_to_word_list_internal (h, 0));
-}
-
-WORD_LIST *
-assoc_keys_to_word_list (h)
-     HASH_TABLE *h;
-{
-  return (assoc_to_word_list_internal (h, 1));
-}
-
-WORD_LIST *
-assoc_to_kvpair_list (h)
-     HASH_TABLE *h;
-{
-  WORD_LIST *list;
-  int i;
-  BUCKET_CONTENTS *tlist;
-  char *k, *v;
-
-  if (h == 0 || assoc_empty (h))
-    return((WORD_LIST *)NULL);
-  list = (WORD_LIST *)NULL;
-  
-  for (i = 0; i < h->nbuckets; i++)
-    for (tlist = hash_items (i, h); tlist; tlist = tlist->next)
-      {
-      	k = (char *)tlist->key;
-      	v = (char *)tlist->data;
-	list = make_word_list (make_bare_word (k), list);
-	list = make_word_list (make_bare_word (v), list);
-      }
-  return (REVERSE_LIST(list, WORD_LIST *));
-}
-
-char *
-assoc_to_string (h, sep, quoted)
-     HASH_TABLE *h;
-     char *sep;
-     int quoted;
-{
-  BUCKET_CONTENTS *tlist;
-  int i;
-  char *result, *t, *w;
-  WORD_LIST *list, *l;
-
-  if (h == 0)
-    return ((char *)NULL);
-  if (assoc_empty (h))
-    return (savestring (""));
-
-  result = NULL;
-  l = list = NULL;
-  /* This might be better implemented directly, but it's simple to implement
-     by converting to a word list first, possibly quoting the data, then
-     using list_string */
-  for (i = 0; i < h->nbuckets; i++)
-    for (tlist = hash_items (i, h); tlist; tlist = tlist->next)
-      {
-	w = (char *)tlist->data;
-	if (w == 0)
-	  continue;
-	t = quoted ? quote_string (w) : savestring (w);
-	list = make_word_list (make_bare_word(t), list);
-	FREE (t);
-      }
-
-  l = REVERSE_LIST(list, WORD_LIST *);
-
-  result = l ? string_list_internal (l, sep) : savestring ("");
-  dispose_words (l);  
-
-  return result;
-}
-
-#endif /* ARRAY_VARS */
diff --git a/third_party/bash/assoc.h b/third_party/bash/assoc.h
deleted file mode 100644
index 664d13740..000000000
--- a/third_party/bash/assoc.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/* assoc.h -- definitions for the interface exported by assoc.c that allows
-   the rest of the shell to manipulate associative array variables. */
-
-/* Copyright (C) 2008,2009-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _ASSOC_H_
-#define _ASSOC_H_
-
-#include "stdc.h"
-#include "hashlib.h"
-
-#define ASSOC_HASH_BUCKETS	1024
-
-#define assoc_empty(h)		((h)->nentries == 0)
-#define assoc_num_elements(h)	((h)->nentries)
-
-#define assoc_create(n)		(hash_create((n)))
-
-#define assoc_copy(h)		(hash_copy((h), 0))
-
-#define assoc_walk(h, f)	(hash_walk((h), (f))
-
-extern void assoc_dispose PARAMS((HASH_TABLE *));
-extern void assoc_flush PARAMS((HASH_TABLE *));
-
-extern int assoc_insert PARAMS((HASH_TABLE *, char *, char *));
-extern PTR_T assoc_replace PARAMS((HASH_TABLE *, char *, char *));
-extern void assoc_remove PARAMS((HASH_TABLE *, char *));
-
-extern char *assoc_reference PARAMS((HASH_TABLE *, char *));
-
-extern char *assoc_subrange PARAMS((HASH_TABLE *, arrayind_t, arrayind_t, int, int, int));
-extern char *assoc_patsub PARAMS((HASH_TABLE *, char *, char *, int));
-extern char *assoc_modcase PARAMS((HASH_TABLE *, char *, int, int));
-
-extern HASH_TABLE *assoc_quote PARAMS((HASH_TABLE *));
-extern HASH_TABLE *assoc_quote_escapes PARAMS((HASH_TABLE *));
-extern HASH_TABLE *assoc_dequote PARAMS((HASH_TABLE *));
-extern HASH_TABLE *assoc_dequote_escapes PARAMS((HASH_TABLE *));
-extern HASH_TABLE *assoc_remove_quoted_nulls PARAMS((HASH_TABLE *));
-
-extern char *assoc_to_kvpair PARAMS((HASH_TABLE *, int));
-extern char *assoc_to_assign PARAMS((HASH_TABLE *, int));
-
-extern WORD_LIST *assoc_to_word_list PARAMS((HASH_TABLE *));
-extern WORD_LIST *assoc_keys_to_word_list PARAMS((HASH_TABLE *));
-extern WORD_LIST *assoc_to_kvpair_list PARAMS((HASH_TABLE *));
-
-extern char *assoc_to_string PARAMS((HASH_TABLE *, char *, int));
-#endif /* _ASSOC_H_ */
diff --git a/third_party/bash/bashansi.h b/third_party/bash/bashansi.h
deleted file mode 100644
index dd2a544cd..000000000
--- a/third_party/bash/bashansi.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/* bashansi.h -- Typically included information required by picky compilers. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_BASHANSI_H_)
-#define _BASHANSI_H_
-
-#if defined (HAVE_STRING_H)
-#  include <string.h>
-#endif /* !HAVE_STRING_H */
-
-#if defined (HAVE_STRINGS_H)
-#  include <strings.h>
-#endif /* !HAVE_STRINGS_H */
-
-#if defined (HAVE_STDLIB_H)
-#  include <stdlib.h>
-#else
-#  include "ansi_stdlib.h"
-#endif /* !HAVE_STDLIB_H */
-
-#endif /* !_BASHANSI_H_ */
diff --git a/third_party/bash/bashgetopt.c b/third_party/bash/bashgetopt.c
deleted file mode 100644
index 7c41d6433..000000000
--- a/third_party/bash/bashgetopt.c
+++ /dev/null
@@ -1,194 +0,0 @@
-/* bashgetopt.c -- `getopt' for use by the builtins. */
-
-/* Copyright (C) 1992-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "chartypes.h"
-#include <errno.h>
-
-#include "shell.h"
-#include "common.h"
-
-#include "bashgetopt.h"
-
-#define ISOPT(s)	(((*(s) == '-') || (plus && *(s) == '+')) && (s)[1])
-#define NOTOPT(s)	(((*(s) != '-') && (!plus || *(s) != '+')) || (s)[1] == '\0')
-			
-static int	sp;
-
-char    *list_optarg;
-int	list_optflags;
-int	list_optopt;
-int	list_opttype;
-
-static WORD_LIST *lhead = (WORD_LIST *)NULL;
-WORD_LIST	*lcurrent = (WORD_LIST *)NULL;
-WORD_LIST	*loptend;	/* Points to the first non-option argument in the list */
-
-int
-internal_getopt(list, opts)
-WORD_LIST	*list;
-char		*opts;
-{
-	register int c;
-	register char *cp;
-	int	plus;	/* nonzero means to handle +option */
-	static char errstr[3] = { '-', '\0', '\0' };
-
-	plus = *opts == '+';
-	if (plus)
-		opts++;
-
-	if (list == 0) {
-		list_optarg = (char *)NULL;
-		list_optflags = 0;
-		loptend = (WORD_LIST *)NULL;	/* No non-option arguments */
-		return -1;
-	}
-
-	if (list != lhead || lhead == 0) {
-		/* Hmmm.... called with a different word list.  Reset. */
-		sp = 1;
-		lcurrent = lhead = list;
-		loptend = (WORD_LIST *)NULL;
-	}
-
-	if (sp == 1) {
-		if (lcurrent == 0 || NOTOPT(lcurrent->word->word)) {
-		    	lhead = (WORD_LIST *)NULL;
-		    	loptend = lcurrent;
-			return(-1);
-		} else if (ISHELP (lcurrent->word->word)) {
-			lhead = (WORD_LIST *)NULL;
-			loptend = lcurrent;
-			return (GETOPT_HELP);
-		} else if (lcurrent->word->word[0] == '-' &&
-			   lcurrent->word->word[1] == '-' &&
-			   lcurrent->word->word[2] == 0) {
-			lhead = (WORD_LIST *)NULL;
-			loptend = lcurrent->next;
-			return(-1);
-		}
-		errstr[0] = list_opttype = lcurrent->word->word[0];
-	}
-
-	list_optopt = c = lcurrent->word->word[sp];
-
-	if (c == ':' || (cp = strchr(opts, c)) == NULL) {
-		errstr[1] = c;
-		sh_invalidopt (errstr);		
-		if (lcurrent->word->word[++sp] == '\0') {
-			lcurrent = lcurrent->next;
-			sp = 1;
-		}
-		list_optarg = NULL;
-		list_optflags = 0;
-		if (lcurrent)
-			loptend = lcurrent->next;
-		return('?');
-	}
-
-	if (*++cp == ':' || *cp == ';') {
-		/* `:': Option requires an argument. */
-		/* `;': option argument may be missing */
-		/* We allow -l2 as equivalent to -l 2 */
-		if (lcurrent->word->word[sp+1]) {
-			list_optarg = lcurrent->word->word + sp + 1;
-			list_optflags = 0;
-			lcurrent = lcurrent->next;
-		/* If the specifier is `;', don't set optarg if the next
-		   argument looks like another option. */
-#if 0
-		} else if (lcurrent->next && (*cp == ':' || lcurrent->next->word->word[0] != '-')) {
-#else
-		} else if (lcurrent->next && (*cp == ':' || NOTOPT(lcurrent->next->word->word))) {
-#endif
-			lcurrent = lcurrent->next;
-			list_optarg = lcurrent->word->word;
-			list_optflags = lcurrent->word->flags;
-			lcurrent = lcurrent->next;
-		} else if (*cp == ';') {
-			list_optarg = (char *)NULL;
-			list_optflags = 0;
-			lcurrent = lcurrent->next;
-		} else {	/* lcurrent->next == NULL */
-			errstr[1] = c;
-			sh_needarg (errstr);
-			sp = 1;
-			list_optarg = (char *)NULL;
-			list_optflags = 0;
-			return('?');
-		}
-		sp = 1;
-	} else if (*cp == '#') {
-		/* option requires a numeric argument */
-		if (lcurrent->word->word[sp+1]) {
-			if (DIGIT(lcurrent->word->word[sp+1])) {
-				list_optarg = lcurrent->word->word + sp + 1;
-				list_optflags = 0;
-				lcurrent = lcurrent->next;
-			} else {
-				list_optarg = (char *)NULL;
-				list_optflags = 0;
-			}
-		} else {
-			if (lcurrent->next && legal_number(lcurrent->next->word->word, (intmax_t *)0)) {
-				lcurrent = lcurrent->next;
-				list_optarg = lcurrent->word->word;
-				list_optflags = lcurrent->word->flags;
-				lcurrent = lcurrent->next;
-			} else {
-				errstr[1] = c;
-				sh_neednumarg (errstr);
-				sp = 1;
-				list_optarg = (char *)NULL;
-				list_optflags = 0;
-				return ('?');
-			}
-		}
-
-	} else {
-		/* No argument, just return the option. */
-		if (lcurrent->word->word[++sp] == '\0') {
-			sp = 1;
-			lcurrent = lcurrent->next;
-		}
-		list_optarg = (char *)NULL;
-		list_optflags = 0;
-	}
-
-	return(c);
-}
-
-/*
- * reset_internal_getopt -- force the in[ft]ernal getopt to reset
- */
-
-void
-reset_internal_getopt ()
-{
-	lhead = lcurrent = loptend = (WORD_LIST *)NULL;
-	sp = 1;
-}
diff --git a/third_party/bash/bashgetopt.h b/third_party/bash/bashgetopt.h
deleted file mode 100644
index 5ee811ad1..000000000
--- a/third_party/bash/bashgetopt.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* bashgetopt.h -- extern declarations for stuff defined in bashgetopt.c. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* See getopt.h for the explanation of these variables. */
-
-#if !defined (__BASH_GETOPT_H)
-#  define __BASH_GETOPT_H
-
-#include "stdc.h"
-
-#define GETOPT_EOF	-1
-#define GETOPT_HELP	-99
-
-extern char *list_optarg;
-extern int list_optflags;
-
-extern int list_optopt;
-extern int list_opttype;
-
-extern WORD_LIST *lcurrent;
-extern WORD_LIST *loptend;
-
-extern int internal_getopt PARAMS((WORD_LIST *, char *));
-extern void reset_internal_getopt PARAMS((void));
-
-#endif /* !__BASH_GETOPT_H */
diff --git a/third_party/bash/bashhist.c b/third_party/bash/bashhist.c
deleted file mode 100644
index fc7979abf..000000000
--- a/third_party/bash/bashhist.c
+++ /dev/null
@@ -1,1079 +0,0 @@
-/* bashhist.c -- bash interface to the GNU history library. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HISTORY)
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
- #    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashtypes.h"
-#include <stdio.h>
-#include <errno.h>
-#include "bashansi.h"
-#include "posixstat.h"
-#include "filecntl.h"
-
-#include "bashintl.h"
-
-#if defined (SYSLOG_HISTORY)
-#  include <syslog.h>
-#endif
-
-#include "shell.h"
-#include "flags.h"
-#include "parser.h"
-#include "input.h"
-#include "parser.h"	/* for the struct dstack stuff. */
-#include "pathexp.h"	/* for the struct ignorevar stuff */
-#include "bashhist.h"	/* matching prototypes and declarations */
-#include "common.h"
-
-#include "third_party/readline/history.h"
-#include "glob.h"
-#include "strmatch.h"
-
-#if defined (READLINE)
-#  include "bashline.h"
-extern int rl_done, rl_dispatching;	/* should really include readline.h */
-#endif
-
-#ifndef HISTSIZE_DEFAULT
-#  define HISTSIZE_DEFAULT "500"
-#endif
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-static int histignore_item_func PARAMS((struct ign *));
-static int check_history_control PARAMS((char *));
-static void hc_erasedups PARAMS((char *));
-static void really_add_history PARAMS((char *));
-
-static struct ignorevar histignore =
-{
-  "HISTIGNORE",
-  (struct ign *)0,
-  0,
-  (char *)0,
-  (sh_iv_item_func_t *)histignore_item_func,
-};
-
-#define HIGN_EXPAND 0x01
-
-/* Declarations of bash history variables. */
-/* Non-zero means to remember lines typed to the shell on the history
-   list.  This is different than the user-controlled behaviour; this
-   becomes zero when we read lines from a file, for example. */
-int remember_on_history = 0;
-int enable_history_list = -1;	/* value for `set -o history' */
-
-/* The number of lines that Bash has added to this history session.  The
-   difference between the number of the top element in the history list
-   (offset from history_base) and the number of lines in the history file.
-   Appending this session's history to the history file resets this to 0. */
-int history_lines_this_session;
-
-/* The number of lines that Bash has read from the history file. */
-int history_lines_in_file;
-
-#if defined (BANG_HISTORY)
-/* Non-zero means do no history expansion on this line, regardless
-   of what history_expansion says. */
-int history_expansion_inhibited;
-/* If non-zero, double quotes can quote the history expansion character. */
-int double_quotes_inhibit_history_expansion = 0;
-#endif
-
-/* With the old default, every line was saved in the history individually.
-   I.e., if the user enters:
-	bash$ for i in a b c
-	> do
-	> echo $i
-	> done
-   Each line will be individually saved in the history.
-	bash$ history
-	10  for i in a b c
-	11  do
-	12  echo $i
-	13  done
-	14  history
-   If the variable command_oriented_history is set, multiple lines
-   which form one command will be saved as one history entry.
-	bash$ for i in a b c
-	> do
-	> echo $i
-	> done
-	bash$ history
-	10  for i in a b c
-    do
-    echo $i
-    done
-	11  history
-   The user can then recall the whole command all at once instead
-   of just being able to recall one line at a time.
-
-   This is now enabled by default.
-   */
-int command_oriented_history = 1;
-
-/* Set to 1 if the first line of a possibly-multi-line command was saved
-   in the history list.  Managed by maybe_add_history(), but global so
-   the history-manipluating builtins can see it. */
-int current_command_first_line_saved = 0;
-
-/* Set to the number of the most recent line of a possibly-multi-line command
-   that contains a shell comment.  Used by bash_add_history() to determine
-   whether to add a newline or a semicolon. */
-int current_command_line_comment = 0;
-
-/* Non-zero means to store newlines in the history list when using
-   command_oriented_history rather than trying to use semicolons. */
-int literal_history;
-
-/* Non-zero means to append the history to the history file at shell
-   exit, even if the history has been stifled. */
-int force_append_history;
-
-/* A nit for picking at history saving.  Flags have the following values:
-
-   Value == 0 means save all lines parsed by the shell on the history.
-   Value & HC_IGNSPACE means save all lines that do not start with a space.
-   Value & HC_IGNDUPS means save all lines that do not match the last
-   line saved.
-   Value & HC_ERASEDUPS means to remove all other matching lines from the
-   history list before saving the latest line. */
-int history_control;
-
-/* Set to 1 if the last command was added to the history list successfully
-   as a separate history entry; set to 0 if the line was ignored or added
-   to a previous entry as part of command-oriented-history processing. */
-int hist_last_line_added;
-
-/* Set to 1 if builtins/history.def:push_history added the last history
-   entry. */
-int hist_last_line_pushed;
-
-#if defined (READLINE)
-/* If non-zero, and readline is being used, the user is offered the
-   chance to re-edit a failed history expansion. */
-int history_reediting;
-
-/* If non-zero, and readline is being used, don't directly execute a
-   line with history substitution.  Reload it into the editing buffer
-   instead and let the user further edit and confirm with a newline. */
-int hist_verify;
-
-#endif /* READLINE */
-
-/* Non-zero means to not save function definitions in the history list. */
-int dont_save_function_defs;
-
-#if defined (BANG_HISTORY)
-static int bash_history_inhibit_expansion PARAMS((char *, int));
-#endif
-#if defined (READLINE)
-static void re_edit PARAMS((char *));
-#endif
-static int history_expansion_p PARAMS((char *));
-static int shell_comment PARAMS((char *));
-static int should_expand PARAMS((char *));
-static HIST_ENTRY *last_history_entry PARAMS((void));
-static char *expand_histignore_pattern PARAMS((char *));
-static int history_should_ignore PARAMS((char *));
-
-#if defined (BANG_HISTORY)
-/* Is the history expansion starting at string[i] one that should not
-   be expanded? */
-static int
-bash_history_inhibit_expansion (string, i)
-     char *string;
-     int i;
-{
-  int t, si;
-  char hx[2];
-
-  hx[0] = history_expansion_char;
-  hx[1] = '\0';
-
-  /* The shell uses ! as a pattern negation character in globbing [...]
-     expressions, so let those pass without expansion. */
-  if (i > 0 && (string[i - 1] == '[') && member (']', string + i + 1))
-    return (1);
-  /* The shell uses ! as the indirect expansion character, so let those
-     expansions pass as well. */
-  else if (i > 1 && string[i - 1] == '{' && string[i - 2] == '$' &&
-	     member ('}', string + i + 1))
-    return (1);
-  /* The shell uses $! as a defined parameter expansion. */
-  else if (i > 1 && string[i - 1] == '$' && string[i] == '!')
-    return (1);
-#if defined (EXTENDED_GLOB)
-  else if (extended_glob && i > 1 && string[i+1] == '(' && member (')', string + i + 2))
-    return (1);
-#endif
-
-  si = 0;
-  /* If we're supposed to be in single-quoted string, skip over the
-     single-quoted part and then look at what's left. */
-  if (history_quoting_state == '\'')
-    {
-      si = skip_to_delim (string, 0, "'", SD_NOJMP|SD_HISTEXP);
-      if (string[si] == 0 || si >= i)
-	return (1);
-      si++;
-    }
-
-  /* Make sure the history expansion should not be skipped by quoting or
-     command/process substitution. */
-  if ((t = skip_to_histexp (string, si, hx, SD_NOJMP|SD_HISTEXP)) > 0)
-    {
-      /* Skip instances of history expansion appearing on the line before
-	 this one. */
-      while (t < i)
-	{
-	  t = skip_to_histexp (string, t+1, hx, SD_NOJMP|SD_HISTEXP);
-	  if (t <= 0)
-	    return 0;
-	}
-      return (t > i);
-    }
-  else
-    return (0);
-}
-#endif
-
-void
-bash_initialize_history ()
-{
-  history_quotes_inhibit_expansion = 1;
-  history_search_delimiter_chars = ";&()|<>";
-#if defined (BANG_HISTORY)
-  history_inhibit_expansion_function = bash_history_inhibit_expansion;
-  sv_histchars ("histchars");
-#endif
-}
-
-void
-bash_history_reinit (interact)
-     int interact;
-{
-#if defined (BANG_HISTORY)
-  history_expansion = (interact == 0) ? histexp_flag : HISTEXPAND_DEFAULT;
-  history_expansion_inhibited = (interact == 0) ? 1 - histexp_flag : 0;	/* changed in bash_history_enable() */
-  history_inhibit_expansion_function = bash_history_inhibit_expansion;
-#endif
-  remember_on_history = enable_history_list;
-}
-
-void
-bash_history_disable ()
-{
-  remember_on_history = 0;
-#if defined (BANG_HISTORY)
-  history_expansion_inhibited = 1;
-#endif
-}
-
-void
-bash_history_enable ()
-{
-  remember_on_history = enable_history_list = 1;
-#if defined (BANG_HISTORY)
-  history_expansion_inhibited = 0;
-  history_inhibit_expansion_function = bash_history_inhibit_expansion;
-#endif
-  sv_history_control ("HISTCONTROL");
-  sv_histignore ("HISTIGNORE");
-}
-
-/* Load the history list from the history file. */
-void
-load_history ()
-{
-  char *hf;
-
-  /* Truncate history file for interactive shells which desire it.
-     Note that the history file is automatically truncated to the
-     size of HISTSIZE if the user does not explicitly set the size
-     differently. */
-  set_if_not ("HISTSIZE", HISTSIZE_DEFAULT);
-  sv_histsize ("HISTSIZE");
-
-  set_if_not ("HISTFILESIZE", get_string_value ("HISTSIZE"));
-  sv_histsize ("HISTFILESIZE");
-
-  /* Read the history in HISTFILE into the history list. */
-  hf = get_string_value ("HISTFILE");
-
-  if (hf && *hf && file_exists (hf))
-    {
-      read_history (hf);
-      /* We have read all of the lines from the history file, even if we
-	 read more lines than $HISTSIZE.  Remember the total number of lines
-	 we read so we don't count the last N lines as new over and over
-	 again. */
-      history_lines_in_file = history_lines_read_from_file;
-      using_history ();
-      /* history_lines_in_file = where_history () + history_base - 1; */
-    }
-}
-
-void
-bash_clear_history ()
-{
-  clear_history ();
-  history_lines_this_session = 0;
-  /* XXX - reset history_lines_read_from_file? */
-}
-
-/* Delete and free the history list entry at offset I. */
-int
-bash_delete_histent (i)
-     int i;
-{
-  HIST_ENTRY *discard;
-
-  discard = remove_history (i);
-  if (discard)
-    {
-      free_history_entry (discard);
-      history_lines_this_session--;
-    }
-  return discard != 0;
-}
-
-int
-bash_delete_history_range (first, last)
-     int first, last;
-{
-  register int i;
-  HIST_ENTRY **discard_list;
-
-  discard_list = remove_history_range (first, last);
-  if (discard_list == 0)
-    return 0;
-  for (i = 0; discard_list[i]; i++)
-    free_history_entry (discard_list[i]);
-  free (discard_list);
-  history_lines_this_session -= i;
-
-  return 1;
-}
-
-int
-bash_delete_last_history ()
-{
-  register int i;
-  HIST_ENTRY **hlist, *histent;
-  int r;
-
-  hlist = history_list ();
-  if (hlist == NULL)
-    return 0;
-
-  for (i = 0; hlist[i]; i++)
-    ;
-  i--;
-
-  /* History_get () takes a parameter that must be offset by history_base. */
-  histent = history_get (history_base + i);	/* Don't free this */
-  if (histent == NULL)
-    return 0;
-
-  r = bash_delete_histent (i);
-
-  if (where_history () > history_length)
-    history_set_pos (history_length);
-
-  return r;
-}
-
-#ifdef INCLUDE_UNUSED
-/* Write the existing history out to the history file. */
-void
-save_history ()
-{
-  char *hf;
-  int r;
-
-  hf = get_string_value ("HISTFILE");
-  if (hf && *hf && file_exists (hf))
-    {
-      /* Append only the lines that occurred this session to
-	 the history file. */
-      using_history ();
-
-      if (history_lines_this_session <= where_history () || force_append_history)
-	r = append_history (history_lines_this_session, hf);
-      else
-	r = write_history (hf);
-      sv_histsize ("HISTFILESIZE");
-    }
-}
-#endif
-
-int
-maybe_append_history (filename)
-     char *filename;
-{
-  int fd, result, histlen;
-  struct stat buf;
-
-  result = EXECUTION_SUCCESS;
-  if (history_lines_this_session > 0)
-    {
-      /* If the filename was supplied, then create it if necessary. */
-      if (stat (filename, &buf) == -1 && errno == ENOENT)
-	{
-	  fd = open (filename, O_WRONLY|O_CREAT, 0600);
-	  if (fd < 0)
-	    {
-	      builtin_error (_("%s: cannot create: %s"), filename, strerror (errno));
-	      return (EXECUTION_FAILURE);
-	    }
-	  close (fd);
-	}
-      /* cap the number of lines we write at the length of the history list */
-      histlen = where_history ();
-      if (histlen > 0 && history_lines_this_session > histlen)
-	history_lines_this_session = histlen;	/* reset below anyway */
-      result = append_history (history_lines_this_session, filename);
-      /* Pretend we already read these lines from the file because we just
-	 added them */
-      history_lines_in_file += history_lines_this_session;
-      history_lines_this_session = 0;
-    }
-  else
-    history_lines_this_session = 0;	/* reset if > where_history() */
-
-  return (result);
-}
-
-/* If this is an interactive shell, then append the lines executed
-   this session to the history file. */
-int
-maybe_save_shell_history ()
-{
-  int result;
-  char *hf;
-
-  result = 0;
-  if (history_lines_this_session > 0)
-    {
-      hf = get_string_value ("HISTFILE");
-
-      if (hf && *hf)
-	{
-	  /* If the file doesn't exist, then create it. */
-	  if (file_exists (hf) == 0)
-	    {
-	      int file;
-	      file = open (hf, O_CREAT | O_TRUNC | O_WRONLY, 0600);
-	      if (file != -1)
-		close (file);
-	    }
-
-	  /* Now actually append the lines if the history hasn't been
-	     stifled.  If the history has been stifled, rewrite the
-	     history file. */
-	  using_history ();
-	  if (history_lines_this_session <= where_history () || force_append_history)
-	    {
-	      result = append_history (history_lines_this_session, hf);
-	      history_lines_in_file += history_lines_this_session;
-	    }
-	  else
-	    {
-	      result = write_history (hf);
-	      history_lines_in_file = history_lines_written_to_file;
-	      /* history_lines_in_file = where_history () + history_base - 1; */
-	    }
-	  history_lines_this_session = 0;
-
-	  sv_histsize ("HISTFILESIZE");
-	}
-    }
-  return (result);
-}
-
-#if defined (READLINE)
-/* Tell readline () that we have some text for it to edit. */
-static void
-re_edit (text)
-     char *text;
-{
-  if (bash_input.type == st_stdin)
-    bash_re_edit (text);
-}
-#endif /* READLINE */
-
-/* Return 1 if this line needs history expansion. */
-static int
-history_expansion_p (line)
-     char *line;
-{
-  register char *s;
-
-  for (s = line; *s; s++)
-    if (*s == history_expansion_char || *s == history_subst_char)
-      return 1;
-  return 0;
-}
-
-/* Do pre-processing on LINE.  If PRINT_CHANGES is non-zero, then
-   print the results of expanding the line if there were any changes.
-   If there is an error, return NULL, otherwise the expanded line is
-   returned.  If ADDIT is non-zero the line is added to the history
-   list after history expansion.  ADDIT is just a suggestion;
-   REMEMBER_ON_HISTORY can veto, and does.
-   Right now this does history expansion. */
-char *
-pre_process_line (line, print_changes, addit)
-     char *line;
-     int print_changes, addit;
-{
-  char *history_value;
-  char *return_value;
-  int expanded;
-
-  return_value = line;
-  expanded = 0;
-
-#  if defined (BANG_HISTORY)
-  /* History expand the line.  If this results in no errors, then
-     add that line to the history if ADDIT is non-zero. */
-  if (!history_expansion_inhibited && history_expansion && history_expansion_p (line))
-    {
-      int old_len;
-
-      /* If we are expanding the second or later line of a multi-line
-	 command, decrease history_length so references to history expansions
-	 in these lines refer to the previous history entry and not the
-	 current command. */
-      old_len = history_length;
-      if (history_length > 0 && command_oriented_history && current_command_first_line_saved && current_command_line_count > 1)
-        history_length--;
-      expanded = history_expand (line, &history_value);
-      if (history_length >= 0 && command_oriented_history && current_command_first_line_saved && current_command_line_count > 1)
-        history_length = old_len;
-
-      if (expanded)
-	{
-	  if (print_changes)
-	    {
-	      if (expanded < 0)
-		internal_error ("%s", history_value);
-#if defined (READLINE)
-	      else if (hist_verify == 0 || expanded == 2)
-#else
-	      else
-#endif
-		fprintf (stderr, "%s\n", history_value);
-	    }
-
-	  /* If there was an error, return NULL. */
-	  if (expanded < 0 || expanded == 2)	/* 2 == print only */
-	    {
-#    if defined (READLINE)
-	      if (expanded == 2 && rl_dispatching == 0 && *history_value)
-#    else	      
-	      if (expanded == 2 && *history_value)
-#    endif /* !READLINE */
-		maybe_add_history (history_value);
-
-	      free (history_value);
-
-#    if defined (READLINE)
-	      /* New hack.  We can allow the user to edit the
-		 failed history expansion. */
-	      if (history_reediting && expanded < 0 && rl_done)
-		re_edit (line);
-#    endif /* READLINE */
-	      return ((char *)NULL);
-	    }
-
-#    if defined (READLINE)
-	  if (hist_verify && expanded == 1)
-	    {
-	      re_edit (history_value);
-	      free (history_value);
-	      return ((char *)NULL);
-	    }
-#    endif
-	}
-
-      /* Let other expansions know that return_value can be free'ed,
-	 and that a line has been added to the history list.  Note
-	 that we only add lines that have something in them. */
-      expanded = 1;
-      return_value = history_value;
-    }
-#  endif /* BANG_HISTORY */
-
-  if (addit && remember_on_history && *return_value)
-    maybe_add_history (return_value);
-
-#if 0
-  if (expanded == 0)
-    return_value = savestring (line);
-#endif
-
-  return (return_value);
-}
-
-/* Return 1 if the first non-whitespace character in LINE is a `#', indicating
-   that the line is a shell comment.  Return 2 if there is a comment after the
-   first non-whitespace character. Return 0 if the line does not contain a
-   comment. */
-static int
-shell_comment (line)
-     char *line;
-{
-  char *p;
-  int n;
-
-  if (dstack.delimiter_depth != 0 || (parser_state & PST_HEREDOC))
-    return 0;
-  if (line == 0)
-    return 0;
-  for (p = line; p && *p && whitespace (*p); p++)
-    ;
-  if (p && *p == '#')
-    return 1;
-  n = skip_to_delim (line, p - line, "#", SD_NOJMP|SD_GLOB|SD_EXTGLOB|SD_COMPLETE);
-  return (line[n] == '#') ? 2 : 0;
-}
-
-#ifdef INCLUDE_UNUSED
-/* Remove shell comments from LINE.  A `#' and anything after it is a comment.
-   This isn't really useful yet, since it doesn't handle quoting. */
-static char *
-filter_comments (line)
-     char *line;
-{
-  char *p;
-
-  for (p = line; p && *p && *p != '#'; p++)
-    ;
-  if (p && *p == '#')
-    *p = '\0';
-  return (line);
-}
-#endif
-
-/* Check LINE against what HISTCONTROL says to do.  Returns 1 if the line
-   should be saved; 0 if it should be discarded. */
-static int
-check_history_control (line)
-     char *line;
-{
-  HIST_ENTRY *temp;
-  int r;
-
-  if (history_control == 0)
-    return 1;
-
-  /* ignorespace or ignoreboth */
-  if ((history_control & HC_IGNSPACE) && *line == ' ')
-    return 0;
-
-  /* ignoredups or ignoreboth */
-  if (history_control & HC_IGNDUPS)
-    {
-      using_history ();
-      temp = previous_history ();
-
-      r = (temp == 0 || STREQ (temp->line, line) == 0);
-
-      using_history ();
-
-      if (r == 0)
-	return r;
-    }
-
-  return 1;
-}
-
-/* Remove all entries matching LINE from the history list.  Triggered when
-   HISTCONTROL includes `erasedups'. */
-static void
-hc_erasedups (line)
-     char *line;
-{
-  HIST_ENTRY *temp;
-  int r;
-
-  using_history ();
-  while (temp = previous_history ())
-    {
-      if (STREQ (temp->line, line))
-	{
-	  r = where_history ();
-	  temp = remove_history (r);
-	  if (temp)
-	    free_history_entry (temp);
-	}
-    }
-  using_history ();
-}
-
-/* Add LINE to the history list, handling possibly multi-line compound
-   commands.  We note whether or not we save the first line of each command
-   (which is usually the entire command and history entry), and don't add
-   the second and subsequent lines of a multi-line compound command if we
-   didn't save the first line.  We don't usually save shell comment lines in
-   compound commands in the history, because they could have the effect of
-   commenting out the rest of the command when the entire command is saved as
-   a single history entry (when COMMAND_ORIENTED_HISTORY is enabled).  If
-   LITERAL_HISTORY is set, we're saving lines in the history with embedded
-   newlines, so it's OK to save comment lines.  If we're collecting the body
-   of a here-document, we should act as if literal_history is enabled, because
-   we want to save the entire contents of the here-document as it was
-   entered.  We also make sure to save multiple-line quoted strings or other
-   constructs. */
-void
-maybe_add_history (line)
-     char *line;
-{
-  int is_comment;
-
-  hist_last_line_added = 0;
-  is_comment = shell_comment (line);
-
-  /* Don't use the value of history_control to affect the second
-     and subsequent lines of a multi-line command (old code did
-     this only when command_oriented_history is enabled). */
-  if (current_command_line_count > 1)
-    {
-      if (current_command_first_line_saved &&
-	  ((parser_state & PST_HEREDOC) || literal_history || dstack.delimiter_depth != 0 || is_comment != 1))
-	bash_add_history (line);
-      current_command_line_comment = is_comment ? current_command_line_count : -2;
-      return;
-    }
-
-  /* This is the first line of a (possible multi-line) command.  Note whether
-     or not we should save the first line and remember it. */
-  current_command_line_comment = is_comment ? current_command_line_count : -2;
-  current_command_first_line_saved = check_add_history (line, 0);
-}
-
-/* Just check LINE against HISTCONTROL and HISTIGNORE and add it to the
-   history if it's OK.  Used by `history -s' as well as maybe_add_history().
-   Returns 1 if the line was saved in the history, 0 otherwise. */
-int
-check_add_history (line, force)
-     char *line;
-     int force;
-{
-  if (check_history_control (line) && history_should_ignore (line) == 0)
-    {
-      /* We're committed to saving the line.  If the user has requested it,
-	 remove other matching lines from the history. */
-      if (history_control & HC_ERASEDUPS)
-	hc_erasedups (line);
-        
-      if (force)
-	{
-	  really_add_history (line);
-	  using_history ();
-	}
-      else
-	bash_add_history (line);
-      return 1;
-    }
-  return 0;
-}
-
-#if defined (SYSLOG_HISTORY)
-#define SYSLOG_MAXMSG	1024
-#define SYSLOG_MAXLEN	SYSLOG_MAXMSG
-#define SYSLOG_MAXHDR	256
-
-#ifndef OPENLOG_OPTS
-#define OPENLOG_OPTS 0
-#endif
-
-#if defined (SYSLOG_SHOPT)
-int syslog_history = SYSLOG_SHOPT;
-#else
-int syslog_history = 1;
-#endif
-
-void
-bash_syslog_history (line)
-     const char *line;
-{
-  char trunc[SYSLOG_MAXLEN], *msg;
-  char loghdr[SYSLOG_MAXHDR];
-  char seqbuf[32], *seqnum;
-  int hdrlen, msglen, seqlen, chunks, i;
-  static int first = 1;
-
-  if (first)
-    {
-      openlog (shell_name, OPENLOG_OPTS, SYSLOG_FACILITY);
-      first = 0;
-    }
-
-  hdrlen = snprintf (loghdr, sizeof(loghdr), "HISTORY: PID=%d UID=%d", getpid(), current_user.uid);
-  msglen = strlen (line);
-
-  if ((msglen + hdrlen + 1) < SYSLOG_MAXLEN)
-    syslog (SYSLOG_FACILITY|SYSLOG_LEVEL, "%s %s", loghdr, line);
-  else
-    {
-      chunks = ((msglen + hdrlen) / SYSLOG_MAXLEN) + 1;
-      for (msg = line, i = 0; i < chunks; i++)
-	{
-	  seqnum = inttostr (i + 1, seqbuf, sizeof (seqbuf));
-	  seqlen = STRLEN (seqnum);
-
-	  /* 7 == "(seq=) " */
-	  strncpy (trunc, msg, SYSLOG_MAXLEN - hdrlen - seqlen - 7 - 1);
-	  trunc[SYSLOG_MAXLEN - 1] = '\0';
-	  syslog (SYSLOG_FACILITY|SYSLOG_LEVEL, "%s (seq=%s) %s", loghdr, seqnum, trunc);
-	  msg += SYSLOG_MAXLEN - hdrlen - seqlen - 8;
-	}
-    }
-}
-#endif
-     	
-/* Add a line to the history list.
-   The variable COMMAND_ORIENTED_HISTORY controls the style of history
-   remembering;  when non-zero, and LINE is not the first line of a
-   complete parser construct, append LINE to the last history line instead
-   of adding it as a new line. */
-void
-bash_add_history (line)
-     char *line;
-{
-  int add_it, offset, curlen, is_comment;
-  HIST_ENTRY *current, *old;
-  char *chars_to_add, *new_line;
-
-  add_it = 1;
-  if (command_oriented_history && current_command_line_count > 1)
-    {
-      is_comment = shell_comment (line);
-
-      /* The second and subsequent lines of a here document have the trailing
-	 newline preserved.  We don't want to add extra newlines here, but we
-	 do want to add one after the first line (which is the command that
-	 contains the here-doc specifier).  parse.y:history_delimiting_chars()
-	 does the right thing to take care of this for us.  We don't want to
-	 add extra newlines if the user chooses to enable literal_history,
-	 so we have to duplicate some of what that function does here. */
-      /* If we're in a here document and past the first line,
-		(current_command_line_count > 2)
-	 don't add a newline here. This will also take care of the literal_history
-	 case if the other conditions are met. */
-      if ((parser_state & PST_HEREDOC) && here_doc_first_line == 0 && line[strlen (line) - 1] == '\n')
-	chars_to_add = "";
-      else if (current_command_line_count == current_command_line_comment+1)
-	chars_to_add = "\n";
-      else if (literal_history)
-	chars_to_add = "\n";
-      else
-	chars_to_add = history_delimiting_chars (line);
-
-      using_history ();
-      current = previous_history ();
-
-      current_command_line_comment = is_comment ? current_command_line_count : -2;
-
-      if (current)
-	{
-	  /* If the previous line ended with an escaped newline (escaped
-	     with backslash, but otherwise unquoted), then remove the quoted
-	     newline, since that is what happens when the line is parsed. */
-	  curlen = strlen (current->line);
-
-	  if (dstack.delimiter_depth == 0 && current->line[curlen - 1] == '\\' &&
-	      current->line[curlen - 2] != '\\')
-	    {
-	      current->line[curlen - 1] = '\0';
-	      curlen--;
-	      chars_to_add = "";
-	    }
-
-	  /* If we're not in some kind of quoted construct, the current history
-	     entry ends with a newline, and we're going to add a semicolon,
-	     don't.  In some cases, it results in a syntax error (e.g., before
-	     a close brace), and it should not be needed. */
-	  if (dstack.delimiter_depth == 0 && current->line[curlen - 1] == '\n' && *chars_to_add == ';')
-	    chars_to_add++;
-
-	  new_line = (char *)xmalloc (1
-				      + curlen
-				      + strlen (line)
-				      + strlen (chars_to_add));
-	  sprintf (new_line, "%s%s%s", current->line, chars_to_add, line);
-	  offset = where_history ();
-	  old = replace_history_entry (offset, new_line, current->data);
-	  free (new_line);
-
-	  if (old)
-	    free_history_entry (old);
-
-	  add_it = 0;
-	}
-    }
-
-  if (add_it && history_is_stifled() && history_length == 0 && history_length == history_max_entries)
-    add_it = 0;
-
-  if (add_it)
-    really_add_history (line);
-
-#if defined (SYSLOG_HISTORY)
-  if (syslog_history)
-    bash_syslog_history (line);
-#endif
-
-  using_history ();
-}
-
-static void
-really_add_history (line)
-     char *line;
-{
-  hist_last_line_added = 1;
-  hist_last_line_pushed = 0;
-  add_history (line);
-  history_lines_this_session++;
-}
-
-int
-history_number ()
-{
-  using_history ();
-  return ((remember_on_history || enable_history_list) ? history_base + where_history () : 1);
-}
-
-static int
-should_expand (s)
-     char *s;
-{
-  char *p;
-
-  for (p = s; p && *p; p++)
-    {
-      if (*p == '\\')
-	p++;
-      else if (*p == '&')
-	return 1;
-    }
-  return 0;
-}
-
-static int
-histignore_item_func (ign)
-     struct ign *ign;
-{
-  if (should_expand (ign->val))
-    ign->flags |= HIGN_EXPAND;
-  return (0);
-}
-
-void
-setup_history_ignore (varname)
-     char *varname;
-{
-  setup_ignore_patterns (&histignore);
-}
-
-static HIST_ENTRY *
-last_history_entry ()
-{
-  HIST_ENTRY *he;
-
-  using_history ();
-  he = previous_history ();
-  using_history ();
-  return he;
-}
-
-char *
-last_history_line ()
-{
-  HIST_ENTRY *he;
-
-  he = last_history_entry ();
-  if (he == 0)
-    return ((char *)NULL);
-  return he->line;
-}
-
-static char *
-expand_histignore_pattern (pat)
-     char *pat;
-{
-  HIST_ENTRY *phe;
-  char *ret;
-
-  phe = last_history_entry ();
-
-  if (phe == (HIST_ENTRY *)0)
-    return (savestring (pat));
-
-  ret = strcreplace (pat, '&', phe->line, 1);
-
-  return ret;
-}
-
-/* Return 1 if we should not put LINE into the history according to the
-   patterns in HISTIGNORE. */
-static int
-history_should_ignore (line)
-     char *line;
-{
-  register int i, match;
-  char *npat;
-
-  if (histignore.num_ignores == 0)
-    return 0;
-
-  for (i = match = 0; i < histignore.num_ignores; i++)
-    {
-      if (histignore.ignores[i].flags & HIGN_EXPAND)
-	npat = expand_histignore_pattern (histignore.ignores[i].val);
-      else
-	npat = histignore.ignores[i].val;
-
-      match = strmatch (npat, line, FNMATCH_EXTFLAG) != FNM_NOMATCH;
-
-      if (histignore.ignores[i].flags & HIGN_EXPAND)
-	free (npat);
-
-      if (match)
-	break;
-    }
-
-  return match;
-}
-#endif /* HISTORY */
diff --git a/third_party/bash/bashhist.h b/third_party/bash/bashhist.h
deleted file mode 100644
index 615f5d256..000000000
--- a/third_party/bash/bashhist.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/* bashhist.h -- interface to the bash history functions in bashhist.c. */
-
-/* Copyright (C) 1993-2020 Free Software Foundation,  Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_BASHHIST_H_)
-#define _BASHHIST_H_
-
-#include "stdc.h"
-
-/* Flag values for history_control */
-#define HC_IGNSPACE	0x01
-#define HC_IGNDUPS	0x02
-#define HC_ERASEDUPS	0x04
-
-#define HC_IGNBOTH	(HC_IGNSPACE|HC_IGNDUPS)
-
-#if defined (STRICT_POSIX)
-#  undef HISTEXPAND_DEFAULT
-#  define HISTEXPAND_DEFAULT	0
-#else
-#  if !defined (HISTEXPAND_DEFAULT)
-#    define HISTEXPAND_DEFAULT	1
-#  endif /* !HISTEXPAND_DEFAULT */
-#endif
-
-extern int remember_on_history;
-extern int enable_history_list;		/* value for `set -o history' */
-extern int literal_history;		/* controlled by `shopt lithist' */
-extern int force_append_history;
-extern int history_lines_this_session;
-extern int history_lines_in_file;
-extern int history_expansion;
-extern int history_control;
-extern int command_oriented_history;
-extern int current_command_first_line_saved;
-extern int current_command_first_line_comment;
-extern int hist_last_line_added;
-extern int hist_last_line_pushed;
-
-extern int dont_save_function_defs;
-
-#  if defined (READLINE)
-extern int hist_verify;
-#  endif
-
-#  if defined (BANG_HISTORY)
-extern int history_expansion_inhibited;
-extern int double_quotes_inhibit_history_expansion;
-#  endif /* BANG_HISTORY */
-
-extern void bash_initialize_history PARAMS((void));
-extern void bash_history_reinit PARAMS((int));
-extern void bash_history_disable PARAMS((void));
-extern void bash_history_enable PARAMS((void));
-extern void bash_clear_history PARAMS((void));
-extern int bash_delete_histent PARAMS((int));
-extern int bash_delete_history_range PARAMS((int, int));
-extern int bash_delete_last_history PARAMS((void));
-extern void load_history PARAMS((void));
-extern void save_history PARAMS((void));
-extern int maybe_append_history PARAMS((char *));
-extern int maybe_save_shell_history PARAMS((void));
-extern char *pre_process_line PARAMS((char *, int, int));
-extern void maybe_add_history PARAMS((char *));
-extern void bash_add_history PARAMS((char *));
-extern int check_add_history PARAMS((char *, int));
-extern int history_number PARAMS((void));
-
-extern void setup_history_ignore PARAMS((char *));
-
-extern char *last_history_line PARAMS((void));
-
-#endif /* _BASHHIST_H_ */
diff --git a/third_party/bash/bashintl.h b/third_party/bash/bashintl.h
deleted file mode 100644
index dd3268331..000000000
--- a/third_party/bash/bashintl.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/* bashintl.h -- Internationalization functions and defines. */
-
-/* Copyright (C) 1996-2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_BASHINTL_H_)
-#define _BASHINTL_H_
-
-#if defined (BUILDTOOL)
-#  undef ENABLE_NLS
-#  define ENABLE_NLS 0
-#endif
-
-/* Include this *after* config.h */
-#include "gettext.h"
-
-#if defined (HAVE_LOCALE_H)
-#  include <locale.h>
-#endif
-
-#define _(msgid)	gettext(msgid)
-#define N_(msgid)	msgid
-#define D_(d, msgid)	dgettext(d, msgid)
-
-#define P_(m1, m2, n)	ngettext(m1, m2, n)
-
-#if defined (HAVE_SETLOCALE) && !defined (LC_ALL)
-#  undef HAVE_SETLOCALE
-#endif
-
-#if !defined (HAVE_SETLOCALE)
-#  define setlocale(cat, loc)
-#endif
-
-#if !defined (HAVE_LOCALE_H) || !defined (HAVE_LOCALECONV)
-#  define locale_decpoint()	'.'
-#endif
-
-#endif /* !_BASHINTL_H_ */
diff --git a/third_party/bash/bashjmp.h b/third_party/bash/bashjmp.h
deleted file mode 100644
index 1a4721bc8..000000000
--- a/third_party/bash/bashjmp.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* bashjmp.h -- wrapper for setjmp.h with necessary bash definitions. */
-
-/* Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _BASHJMP_H_
-#define _BASHJMP_H_
-
-#include "posixjmp.h"
-
-extern procenv_t	top_level;
-extern procenv_t	subshell_top_level;
-extern procenv_t	return_catch;	/* used by `return' builtin */
-extern procenv_t	wait_intr_buf;
-
-extern int no_longjmp_on_fatal_error;
-
-#define SHFUNC_RETURN()	sh_longjmp (return_catch, 1)
-
-#define COPY_PROCENV(old, save) \
-	xbcopy ((char *)old, (char *)save, sizeof (procenv_t));
-
-/* Values for the second argument to longjmp/siglongjmp. */
-#define NOT_JUMPED	0	/* Not returning from a longjmp. */
-#define FORCE_EOF	1	/* We want to stop parsing. */
-#define DISCARD		2	/* Discard current command. */
-#define EXITPROG	3	/* Unconditionally exit the program now. */
-#define ERREXIT		4	/* Exit due to error condition */	
-#define SIGEXIT		5	/* Exit due to fatal terminating signal */
-#define EXITBLTIN	6	/* Exit due to the exit builtin. */
-
-#endif /* _BASHJMP_H_ */
diff --git a/third_party/bash/bashline.c b/third_party/bash/bashline.c
deleted file mode 100644
index 2870bd927..000000000
--- a/third_party/bash/bashline.c
+++ /dev/null
@@ -1,4839 +0,0 @@
-/* bashline.c -- Bash's interface to the readline library. */
-
-/* Copyright (C) 1987-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (READLINE)
-
-#include "bashtypes.h"
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#if defined (HAVE_GRP_H)
-#  include <grp.h>
-#endif
-
-#if defined (HAVE_NETDB_H)
-#  include <netdb.h>
-#endif
-
-#include <signal.h>
-
-#include <stdio.h>
-#include "chartypes.h"
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "input.h"
-#include "parser.h"
-#include "builtins.h"
-#include "bashhist.h"
-#include "bashline.h"
-#include "execute_cmd.h"
-#include "findcmd.h"
-#include "pathexp.h"
-#include "shmbutil.h"
-#include "trap.h"
-#include "flags.h"
-#include "timer.h"
-
-#if defined (HAVE_MBSTR_H) && defined (HAVE_MBSCHR)
-#  include <mbstr.h>		/* mbschr */
-#endif
-
-#include "common.h"
-#include "builtext.h"		/* for read_builtin */
-
-#include "third_party/readline/rlconf.h"
-#include "third_party/readline/readline.h"
-#include "third_party/readline/history.h"
-#include "third_party/readline/rlmbutil.h"
-
-#include "glob.h"
-
-#if defined (ALIAS)
-#  include "alias.h"
-#endif
-
-#if defined (PROGRAMMABLE_COMPLETION)
-#  include "pcomplete.h"
-#endif
-
-/* These should agree with the defines for emacs_mode and vi_mode in
-   rldefs.h, even though that's not a public readline header file. */
-#ifndef EMACS_EDITING_MODE
-#  define NO_EDITING_MODE	-1
-#  define EMACS_EDITING_MODE	 1
-#  define VI_EDITING_MODE	 0
-#endif
-
-/* Copied from rldefs.h, since that's not a public readline header file. */
-#ifndef FUNCTION_TO_KEYMAP
-
-#if defined (CRAY)
-#  define FUNCTION_TO_KEYMAP(map, key)	(Keymap)((int)map[key].function)
-#  define KEYMAP_TO_FUNCTION(data)	(rl_command_func_t *)((int)(data))
-#else
-#  define FUNCTION_TO_KEYMAP(map, key)	(Keymap)(map[key].function)
-#  define KEYMAP_TO_FUNCTION(data)	(rl_command_func_t *)(data)
-#endif
-
-#endif
-
-#define RL_BOOLEAN_VARIABLE_VALUE(s)	((s)[0] == 'o' && (s)[1] == 'n' && (s)[2] == '\0')
-
-#if defined (BRACE_COMPLETION)
-extern int bash_brace_completion PARAMS((int, int));
-#endif /* BRACE_COMPLETION */
-
-/* To avoid including curses.h/term.h/termcap.h and that whole mess. */
-#ifdef _MINIX
-extern int tputs PARAMS((const char *string, int nlines, void (*outx)(int)));
-#else
-extern int tputs PARAMS((const char *string, int nlines, int (*outx)(int)));
-#endif
-
-/* Forward declarations */
-
-/* Functions bound to keys in Readline for Bash users. */
-static int shell_expand_line PARAMS((int, int));
-static int display_shell_version PARAMS((int, int));
-
-static int bash_ignore_filenames PARAMS((char **));
-static int bash_ignore_everything PARAMS((char **));
-static int bash_progcomp_ignore_filenames PARAMS((char **));
-
-#if defined (BANG_HISTORY)
-static char *history_expand_line_internal PARAMS((char *));
-static int history_expand_line PARAMS((int, int));
-static int tcsh_magic_space PARAMS((int, int));
-#endif /* BANG_HISTORY */
-#ifdef ALIAS
-static int alias_expand_line PARAMS((int, int));
-#endif
-#if defined (BANG_HISTORY) && defined (ALIAS)
-static int history_and_alias_expand_line PARAMS((int, int));
-#endif
-
-static int bash_forward_shellword PARAMS((int, int));
-static int bash_backward_shellword PARAMS((int, int));
-static int bash_kill_shellword PARAMS((int, int));
-static int bash_backward_kill_shellword PARAMS((int, int));
-static int bash_transpose_shellwords PARAMS((int, int));
-
-static int bash_spell_correct_shellword PARAMS((int, int));
-
-/* Helper functions for Readline. */
-static char *restore_tilde PARAMS((char *, char *));
-static char *maybe_restore_tilde PARAMS((char *, char *));
-
-static char *bash_filename_rewrite_hook PARAMS((char *, int));
-
-static void bash_directory_expansion PARAMS((char **));
-static int bash_filename_stat_hook PARAMS((char **));
-static int bash_command_name_stat_hook PARAMS((char **));
-static int bash_directory_completion_hook PARAMS((char **));
-static int filename_completion_ignore PARAMS((char **));
-static int bash_push_line PARAMS((void));
-
-static int executable_completion PARAMS((const char *, int));
-
-static rl_icppfunc_t *save_directory_hook PARAMS((void));
-static void restore_directory_hook PARAMS((rl_icppfunc_t));
-
-static int directory_exists PARAMS((const char *, int));
-
-static void cleanup_expansion_error PARAMS((void));
-static void maybe_make_readline_line PARAMS((char *));
-static void set_up_new_line PARAMS((char *));
-
-static int check_redir PARAMS((int));
-static char **attempt_shell_completion PARAMS((const char *, int, int));
-static char *variable_completion_function PARAMS((const char *, int));
-static char *hostname_completion_function PARAMS((const char *, int));
-static char *command_subst_completion_function PARAMS((const char *, int));
-
-static void build_history_completion_array PARAMS((void));
-static char *history_completion_generator PARAMS((const char *, int));
-static int dynamic_complete_history PARAMS((int, int));
-static int bash_dabbrev_expand PARAMS((int, int));
-
-static void initialize_hostname_list PARAMS((void));
-static void add_host_name PARAMS((char *));
-static void snarf_hosts_from_file PARAMS((char *));
-static char **hostnames_matching PARAMS((char *));
-
-static void _ignore_completion_names PARAMS((char **, sh_ignore_func_t *));
-static int name_is_acceptable PARAMS((const char *));
-static int test_for_directory PARAMS((const char *));
-static int test_for_canon_directory PARAMS((const char *));
-static int return_zero PARAMS((const char *));
-
-static char *bash_dequote_filename PARAMS((char *, int));
-static char *quote_word_break_chars PARAMS((char *));
-static int bash_check_expchar PARAMS((char *, int, int *, int *));
-static void set_filename_quote_chars PARAMS((int, int, int));
-static void set_filename_bstab PARAMS((const char *));
-static char *bash_quote_filename PARAMS((char *, int, char *));
-
-#ifdef _MINIX
-static void putx PARAMS((int));
-#else
-static int putx PARAMS((int));
-#endif
-static int readline_get_char_offset PARAMS((int));
-static void readline_set_char_offset PARAMS((int, int *));
-
-static Keymap get_cmd_xmap_from_edit_mode PARAMS((void));
-static Keymap get_cmd_xmap_from_keymap PARAMS((Keymap));
-
-static void init_unix_command_map PARAMS((void));
-static int isolate_sequence PARAMS((char *, int, int, int *));
-
-static int set_saved_history PARAMS((void));
-
-#if defined (ALIAS)
-static int posix_edit_macros PARAMS((int, int));
-#endif
-
-static int bash_event_hook PARAMS((void));
-
-#if defined (PROGRAMMABLE_COMPLETION)
-static int find_cmd_start PARAMS((int));
-static int find_cmd_end PARAMS((int));
-static char *find_cmd_name PARAMS((int, int *, int *));
-static char *prog_complete_return PARAMS((const char *, int));
-
-static char **prog_complete_matches;
-#endif
-
-extern int no_symbolic_links;
-extern STRING_INT_ALIST word_token_alist[];
-extern sh_timer *read_timeout;
-
-/* SPECIFIC_COMPLETION_FUNCTIONS specifies that we have individual
-   completion functions which indicate what type of completion should be
-   done (at or before point) that can be bound to key sequences with
-   the readline library. */
-#define SPECIFIC_COMPLETION_FUNCTIONS
-
-#if defined (SPECIFIC_COMPLETION_FUNCTIONS)
-static int bash_specific_completion PARAMS((int, rl_compentry_func_t *));
-
-static int bash_complete_filename_internal PARAMS((int));
-static int bash_complete_username_internal PARAMS((int));
-static int bash_complete_hostname_internal PARAMS((int));
-static int bash_complete_variable_internal PARAMS((int));
-static int bash_complete_command_internal PARAMS((int));
-
-static int bash_complete_filename PARAMS((int, int));
-static int bash_possible_filename_completions PARAMS((int, int));
-static int bash_complete_username PARAMS((int, int));
-static int bash_possible_username_completions PARAMS((int, int));
-static int bash_complete_hostname PARAMS((int, int));
-static int bash_possible_hostname_completions PARAMS((int, int));
-static int bash_complete_variable PARAMS((int, int));
-static int bash_possible_variable_completions PARAMS((int, int));
-static int bash_complete_command PARAMS((int, int));
-static int bash_possible_command_completions PARAMS((int, int));
-
-static int completion_glob_pattern PARAMS((char *));
-static char *glob_complete_word PARAMS((const char *, int));
-static int bash_glob_completion_internal PARAMS((int));
-static int bash_glob_complete_word PARAMS((int, int));
-static int bash_glob_expand_word PARAMS((int, int));
-static int bash_glob_list_expansions PARAMS((int, int));
-
-#endif /* SPECIFIC_COMPLETION_FUNCTIONS */
-
-static int edit_and_execute_command PARAMS((int, int, int, char *));
-#if defined (VI_MODE)
-static int vi_edit_and_execute_command PARAMS((int, int));
-static int bash_vi_complete PARAMS((int, int));
-#endif
-static int emacs_edit_and_execute_command PARAMS((int, int));
-
-/* Non-zero once initialize_readline () has been called. */
-int bash_readline_initialized = 0;
-
-/* If non-zero, we do hostname completion, breaking words at `@' and
-   trying to complete the stuff after the `@' from our own internal
-   host list. */
-int perform_hostname_completion = 1;
-
-/* If non-zero, we don't do command completion on an empty line. */
-int no_empty_command_completion;
-
-/* Set FORCE_FIGNORE if you want to honor FIGNORE even if it ignores the
-   only possible matches.  Set to 0 if you want to match filenames if they
-   are the only possible matches, even if FIGNORE says to. */
-int force_fignore = 1;
-
-/* Perform spelling correction on directory names during word completion */
-int dircomplete_spelling = 0;
-
-/* Expand directory names during word/filename completion. */
-#if DIRCOMPLETE_EXPAND_DEFAULT
-int dircomplete_expand = 1;
-int dircomplete_expand_relpath = 1;
-#else
-int dircomplete_expand = 0;
-int dircomplete_expand_relpath = 0;
-#endif
-
-/* When non-zero, perform `normal' shell quoting on completed filenames
-   even when the completed name contains a directory name with a shell
-   variable reference, so dollar signs in a filename get quoted appropriately.
-   Set to zero to remove dollar sign (and braces or parens as needed) from
-   the set of characters that will be quoted. */
-int complete_fullquote = 1;
-
-static char *bash_completer_word_break_characters = " \t\n\"'@><=;|&(:";
-static char *bash_nohostname_word_break_characters = " \t\n\"'><=;|&(:";
-/* )) */
-
-static const char *default_filename_quote_characters = " \t\n\\\"'@<>=;|&()#$`?*[!:{~";	/*}*/
-static char *custom_filename_quote_characters = 0;
-static char filename_bstab[256];
-
-static rl_hook_func_t *old_rl_startup_hook = (rl_hook_func_t *)NULL;
-
-static int dot_in_path = 0;
-
-/* Set to non-zero when dabbrev-expand is running */
-static int dabbrev_expand_active = 0;
-
-/* What kind of quoting is performed by bash_quote_filename:
-	COMPLETE_DQUOTE = double-quoting the filename
-	COMPLETE_SQUOTE = single_quoting the filename
-	COMPLETE_BSQUOTE = backslash-quoting special chars in the filename
-*/
-#define COMPLETE_DQUOTE  1
-#define COMPLETE_SQUOTE  2
-#define COMPLETE_BSQUOTE 3
-static int completion_quoting_style = COMPLETE_BSQUOTE;
-
-/* Flag values for the final argument to bash_default_completion */
-#define DEFCOMP_CMDPOS		1
-
-static rl_command_func_t *vi_tab_binding = rl_complete;
-
-/* Change the readline VI-mode keymaps into or out of Posix.2 compliance.
-   Called when the shell is put into or out of `posix' mode. */
-void
-posix_readline_initialize (on_or_off)
-     int on_or_off;
-{
-  static char kseq[2] = { CTRL ('I'), 0 };		/* TAB */
-
-  if (on_or_off)
-    rl_variable_bind ("comment-begin", "#");
-#if defined (VI_MODE)
-  if (on_or_off)
-    {
-      vi_tab_binding = rl_function_of_keyseq (kseq, vi_insertion_keymap, (int *)NULL);
-      rl_bind_key_in_map (CTRL ('I'), rl_insert, vi_insertion_keymap);
-    }
-  else
-    {
-      if (rl_function_of_keyseq (kseq, vi_insertion_keymap, (int *)NULL) == rl_insert)
-        rl_bind_key_in_map (CTRL ('I'), vi_tab_binding, vi_insertion_keymap);
-    }
-#endif
-}
-
-void
-reset_completer_word_break_chars ()
-{
-  rl_completer_word_break_characters = perform_hostname_completion ? savestring (bash_completer_word_break_characters) : savestring (bash_nohostname_word_break_characters);
-}
-
-/* When this function returns, rl_completer_word_break_characters points to
-   dynamically allocated memory. */
-int
-enable_hostname_completion (on_or_off)
-     int on_or_off;
-{
-  int old_value;
-  char *nv, *nval;
-  const char *at;
-
-  old_value = perform_hostname_completion;
-
-  if (on_or_off)
-    {
-      perform_hostname_completion = 1;
-      rl_special_prefixes = "$@";
-    }
-  else
-    {
-      perform_hostname_completion = 0;
-      rl_special_prefixes = "$";
-    }
-
-  /* Now we need to figure out how to appropriately modify and assign
-     rl_completer_word_break_characters depending on whether we want
-     hostname completion on or off. */
-
-  /* If this is the first time this has been called
-     (bash_readline_initialized == 0), use the sames values as before, but
-     allocate new memory for rl_completer_word_break_characters. */
-
-  if (bash_readline_initialized == 0 &&
-      (rl_completer_word_break_characters == 0 || 
-       rl_completer_word_break_characters == rl_basic_word_break_characters))
-    {
-      if (on_or_off)
-	rl_completer_word_break_characters = savestring (bash_completer_word_break_characters);
-      else
-	rl_completer_word_break_characters = savestring (bash_nohostname_word_break_characters);
-    }
-  else
-    {
-      /* See if we have anything to do. */
-      at = strchr (rl_completer_word_break_characters, '@');
-      if ((at == 0 && on_or_off == 0) || (at != 0 && on_or_off != 0))
-        return old_value;
-
-      /* We have something to do.  Do it. */
-      nval = (char *)xmalloc (strlen (rl_completer_word_break_characters) + 1 + on_or_off);
-
-      if (on_or_off == 0)
-	{
-	  /* Turn it off -- just remove `@' from word break chars.  We want
-	     to remove all occurrences of `@' from the char list, so we loop
-	     rather than just copy the rest of the list over AT. */
-	  for (nv = nval, at = rl_completer_word_break_characters; *at; )
-	    if (*at != '@')
-	      *nv++ = *at++;
-	    else
-	      at++;
-	  *nv = '\0';
-	}
-      else
-	{
-	  nval[0] = '@';
-	  strcpy (nval + 1, rl_completer_word_break_characters);
-        }
-
-      free ((void *)rl_completer_word_break_characters);
-      rl_completer_word_break_characters = nval;
-    }
-
-  return (old_value);
-}
-
-/* Called once from parse.y if we are going to use readline. */
-void
-initialize_readline ()
-{
-  rl_command_func_t *func;
-  char kseq[2];
-
-  if (bash_readline_initialized)
-    return;
-
-  rl_terminal_name = get_string_value ("TERM");
-  rl_instream = stdin;
-  rl_outstream = stderr;
-
-  /* Allow conditional parsing of the ~/.inputrc file. */
-  rl_readline_name = "Bash";
-
-  /* Add bindable names before calling rl_initialize so they may be
-     referenced in the various inputrc files. */
-  rl_add_defun ("shell-expand-line", shell_expand_line, -1);
-#ifdef BANG_HISTORY
-  rl_add_defun ("history-expand-line", history_expand_line, -1);
-  rl_add_defun ("magic-space", tcsh_magic_space, -1);
-#endif
-
-  rl_add_defun ("shell-forward-word", bash_forward_shellword, -1);
-  rl_add_defun ("shell-backward-word", bash_backward_shellword, -1);
-  rl_add_defun ("shell-kill-word", bash_kill_shellword, -1);
-  rl_add_defun ("shell-backward-kill-word", bash_backward_kill_shellword, -1);
-  rl_add_defun ("shell-transpose-words", bash_transpose_shellwords, -1);
-
-  rl_add_defun ("spell-correct-word", bash_spell_correct_shellword, -1);
-  rl_bind_key_if_unbound_in_map ('s', bash_spell_correct_shellword, emacs_ctlx_keymap);
-
-#ifdef ALIAS
-  rl_add_defun ("alias-expand-line", alias_expand_line, -1);
-#  ifdef BANG_HISTORY
-  rl_add_defun ("history-and-alias-expand-line", history_and_alias_expand_line, -1);
-#  endif
-#endif
-
-  /* Backwards compatibility. */
-  rl_add_defun ("insert-last-argument", rl_yank_last_arg, -1);
-
-  rl_add_defun ("display-shell-version", display_shell_version, -1);
-  rl_add_defun ("edit-and-execute-command", emacs_edit_and_execute_command, -1);
-#if defined (VI_MODE)
-  rl_add_defun ("vi-edit-and-execute-command", vi_edit_and_execute_command, -1);
-#endif
-
-#if defined (BRACE_COMPLETION)
-  rl_add_defun ("complete-into-braces", bash_brace_completion, -1);
-#endif
-
-#if defined (SPECIFIC_COMPLETION_FUNCTIONS)
-  rl_add_defun ("complete-filename", bash_complete_filename, -1);
-  rl_add_defun ("possible-filename-completions", bash_possible_filename_completions, -1);
-  rl_add_defun ("complete-username", bash_complete_username, -1);
-  rl_add_defun ("possible-username-completions", bash_possible_username_completions, -1);
-  rl_add_defun ("complete-hostname", bash_complete_hostname, -1);
-  rl_add_defun ("possible-hostname-completions", bash_possible_hostname_completions, -1);
-  rl_add_defun ("complete-variable", bash_complete_variable, -1);
-  rl_add_defun ("possible-variable-completions", bash_possible_variable_completions, -1);
-  rl_add_defun ("complete-command", bash_complete_command, -1);
-  rl_add_defun ("possible-command-completions", bash_possible_command_completions, -1);
-  rl_add_defun ("glob-complete-word", bash_glob_complete_word, -1);
-  rl_add_defun ("glob-expand-word", bash_glob_expand_word, -1);
-  rl_add_defun ("glob-list-expansions", bash_glob_list_expansions, -1);
-#endif
-
-  rl_add_defun ("dynamic-complete-history", dynamic_complete_history, -1);
-  rl_add_defun ("dabbrev-expand", bash_dabbrev_expand, -1);
-
-  /* Bind defaults before binding our custom shell keybindings. */
-  if (RL_ISSTATE(RL_STATE_INITIALIZED) == 0)
-    rl_initialize ();
-
-  /* Bind up our special shell functions. */
-  rl_bind_key_if_unbound_in_map (CTRL('E'), shell_expand_line, emacs_meta_keymap);
-
-#ifdef BANG_HISTORY
-  rl_bind_key_if_unbound_in_map ('^', history_expand_line, emacs_meta_keymap);
-#endif
-
-  rl_bind_key_if_unbound_in_map (CTRL ('V'), display_shell_version, emacs_ctlx_keymap);
-
-  /* In Bash, the user can switch editing modes with "set -o [vi emacs]",
-     so it is not necessary to allow C-M-j for context switching.  Turn
-     off this occasionally confusing behaviour. */
-  kseq[0] = CTRL('J');
-  kseq[1] = '\0';
-  func = rl_function_of_keyseq (kseq, emacs_meta_keymap, (int *)NULL);
-  if (func == rl_vi_editing_mode)
-    rl_unbind_key_in_map (CTRL('J'), emacs_meta_keymap);
-  kseq[0] = CTRL('M');
-  func = rl_function_of_keyseq (kseq, emacs_meta_keymap, (int *)NULL);
-  if (func == rl_vi_editing_mode)
-    rl_unbind_key_in_map (CTRL('M'), emacs_meta_keymap);
-#if defined (VI_MODE)
-  kseq[0] = CTRL('E');
-  func = rl_function_of_keyseq (kseq, vi_movement_keymap, (int *)NULL);
-  if (func == rl_emacs_editing_mode)
-    rl_unbind_key_in_map (CTRL('E'), vi_movement_keymap);
-#endif
-
-#if defined (BRACE_COMPLETION)
-  rl_bind_key_if_unbound_in_map ('{', bash_brace_completion, emacs_meta_keymap); /*}*/
-#endif /* BRACE_COMPLETION */
-
-#if defined (SPECIFIC_COMPLETION_FUNCTIONS)
-  rl_bind_key_if_unbound_in_map ('/', bash_complete_filename, emacs_meta_keymap);
-  rl_bind_key_if_unbound_in_map ('/', bash_possible_filename_completions, emacs_ctlx_keymap);
-
-  /* Have to jump through hoops here because there is a default binding for
-     M-~ (rl_tilde_expand) */
-  kseq[0] = '~';
-  kseq[1] = '\0';
-  func = rl_function_of_keyseq (kseq, emacs_meta_keymap, (int *)NULL);
-  if (func == 0 || func == rl_tilde_expand)
-    rl_bind_keyseq_in_map (kseq, bash_complete_username, emacs_meta_keymap);
-
-  rl_bind_key_if_unbound_in_map ('~', bash_possible_username_completions, emacs_ctlx_keymap);
-
-  rl_bind_key_if_unbound_in_map ('@', bash_complete_hostname, emacs_meta_keymap);
-  rl_bind_key_if_unbound_in_map ('@', bash_possible_hostname_completions, emacs_ctlx_keymap);
-
-  rl_bind_key_if_unbound_in_map ('$', bash_complete_variable, emacs_meta_keymap);
-  rl_bind_key_if_unbound_in_map ('$', bash_possible_variable_completions, emacs_ctlx_keymap);
-
-  rl_bind_key_if_unbound_in_map ('!', bash_complete_command, emacs_meta_keymap);
-  rl_bind_key_if_unbound_in_map ('!', bash_possible_command_completions, emacs_ctlx_keymap);
-
-  rl_bind_key_if_unbound_in_map ('g', bash_glob_complete_word, emacs_meta_keymap);
-  rl_bind_key_if_unbound_in_map ('*', bash_glob_expand_word, emacs_ctlx_keymap);
-  rl_bind_key_if_unbound_in_map ('g', bash_glob_list_expansions, emacs_ctlx_keymap);
-
-#endif /* SPECIFIC_COMPLETION_FUNCTIONS */
-
-  kseq[0] = TAB;
-  kseq[1] = '\0';
-  func = rl_function_of_keyseq (kseq, emacs_meta_keymap, (int *)NULL);
-  if (func == 0 || func == rl_tab_insert)
-    rl_bind_key_in_map (TAB, dynamic_complete_history, emacs_meta_keymap);
-
-  /* Tell the completer that we want a crack first. */
-  rl_attempted_completion_function = attempt_shell_completion;
-
-  /* Tell the completer that we might want to follow symbolic links or
-     do other expansion on directory names. */
-  set_directory_hook ();
-
-  rl_filename_rewrite_hook = bash_filename_rewrite_hook;
-
-  rl_filename_stat_hook = bash_filename_stat_hook;
-
-  /* Tell the filename completer we want a chance to ignore some names. */
-  rl_ignore_some_completions_function = filename_completion_ignore;
-
-  /* Bind C-xC-e to invoke emacs and run result as commands. */
-  rl_bind_key_if_unbound_in_map (CTRL ('E'), emacs_edit_and_execute_command, emacs_ctlx_keymap);
-#if defined (VI_MODE)
-  rl_bind_key_if_unbound_in_map ('v', vi_edit_and_execute_command, vi_movement_keymap);
-#  if defined (ALIAS)
-  rl_bind_key_if_unbound_in_map ('@', posix_edit_macros, vi_movement_keymap);
-#  endif
-
-  rl_bind_key_in_map ('\\', bash_vi_complete, vi_movement_keymap);
-  rl_bind_key_in_map ('*', bash_vi_complete, vi_movement_keymap);
-  rl_bind_key_in_map ('=', bash_vi_complete, vi_movement_keymap);
-#endif
-
-  rl_completer_quote_characters = "'\"";
-
-  /* This sets rl_completer_word_break_characters and rl_special_prefixes
-     to the appropriate values, depending on whether or not hostname
-     completion is enabled. */
-  enable_hostname_completion (perform_hostname_completion);
-
-  /* characters that need to be quoted when appearing in filenames. */
-  rl_filename_quote_characters = default_filename_quote_characters;
-  set_filename_bstab (rl_filename_quote_characters);
-
-  rl_filename_quoting_function = bash_quote_filename;
-  rl_filename_dequoting_function = bash_dequote_filename;
-  rl_char_is_quoted_p = char_is_quoted;
-
-  /* Add some default bindings for the "shellwords" functions, roughly
-     parallelling the default word bindings in emacs mode. */
-  rl_bind_key_if_unbound_in_map (CTRL('B'), bash_backward_shellword, emacs_meta_keymap);
-  rl_bind_key_if_unbound_in_map (CTRL('D'), bash_kill_shellword, emacs_meta_keymap);
-  rl_bind_key_if_unbound_in_map (CTRL('F'), bash_forward_shellword, emacs_meta_keymap);
-  rl_bind_key_if_unbound_in_map (CTRL('T'), bash_transpose_shellwords, emacs_meta_keymap);
-
-#if 0
-  /* This is superfluous and makes it impossible to use tab completion in
-     vi mode even when explicitly binding it in ~/.inputrc.  sv_strict_posix()
-     should already have called posix_readline_initialize() when
-     posixly_correct was set. */
-  if (posixly_correct)
-    posix_readline_initialize (1);
-#endif
-
-  bash_readline_initialized = 1;
-}
-
-void
-bashline_reinitialize ()
-{
-  bash_readline_initialized = 0;
-}
-
-void
-bashline_set_event_hook ()
-{
-  rl_signal_event_hook = bash_event_hook;
-}
-
-void
-bashline_reset_event_hook ()
-{
-  rl_signal_event_hook = 0;
-}
-
-/* On Sun systems at least, rl_attempted_completion_function can end up
-   getting set to NULL, and rl_completion_entry_function set to do command
-   word completion if Bash is interrupted while trying to complete a command
-   word.  This just resets all the completion functions to the right thing.
-   It's called from throw_to_top_level(). */
-void
-bashline_reset ()
-{
-  tilde_initialize ();
-  rl_attempted_completion_function = attempt_shell_completion;
-  rl_completion_entry_function = NULL;
-  rl_ignore_some_completions_function = filename_completion_ignore;
-
-  complete_fullquote = 1;
-  rl_filename_quote_characters = default_filename_quote_characters;
-  set_filename_bstab (rl_filename_quote_characters);
-
-  set_directory_hook ();
-  rl_filename_stat_hook = bash_filename_stat_hook;
-
-  bashline_reset_event_hook ();
-
-  rl_sort_completion_matches = 1;
-}
-
-/* Contains the line to push into readline. */
-static char *push_to_readline = (char *)NULL;
-
-/* Push the contents of push_to_readline into the
-   readline buffer. */
-static int
-bash_push_line ()
-{
-  if (push_to_readline)
-    {
-      rl_insert_text (push_to_readline);
-      free (push_to_readline);
-      push_to_readline = (char *)NULL;
-      rl_startup_hook = old_rl_startup_hook;
-    }
-  return 0;
-}
-
-/* Call this to set the initial text for the next line to read
-   from readline. */
-int
-bash_re_edit (line)
-     char *line;
-{
-  FREE (push_to_readline);
-
-  push_to_readline = savestring (line);
-  old_rl_startup_hook = rl_startup_hook;
-  rl_startup_hook = bash_push_line;
-
-  return (0);
-}
-
-static int
-display_shell_version (count, c)
-     int count, c;
-{
-  rl_crlf ();
-  show_shell_version (0);
-  putc ('\r', rl_outstream);
-  fflush (rl_outstream);
-  rl_on_new_line ();
-  rl_redisplay ();
-  return 0;
-}
-
-/* **************************************************************** */
-/*								    */
-/*			     Readline Stuff			    */
-/*								    */
-/* **************************************************************** */
-
-/* If the user requests hostname completion, then simply build a list
-   of hosts, and complete from that forever more, or at least until
-   HOSTFILE is unset. */
-
-/* THIS SHOULD BE A STRINGLIST. */
-/* The kept list of hostnames. */
-static char **hostname_list = (char **)NULL;
-
-/* The physical size of the above list. */
-static int hostname_list_size;
-
-/* The number of hostnames in the above list. */
-static int hostname_list_length;
-
-/* Whether or not HOSTNAME_LIST has been initialized. */
-int hostname_list_initialized = 0;
-
-/* Initialize the hostname completion table. */
-static void
-initialize_hostname_list ()
-{
-  char *temp;
-
-  temp = get_string_value ("HOSTFILE");
-  if (temp == 0)
-    temp = get_string_value ("hostname_completion_file");
-  if (temp == 0)
-    temp = DEFAULT_HOSTS_FILE;
-
-  snarf_hosts_from_file (temp);
-
-  if (hostname_list)
-    hostname_list_initialized++;
-}
-
-/* Add NAME to the list of hosts. */
-static void
-add_host_name (name)
-     char *name;
-{
-  if (hostname_list_length + 2 > hostname_list_size)
-    {
-      hostname_list_size = (hostname_list_size + 32) - (hostname_list_size % 32);
-      hostname_list = strvec_resize (hostname_list, hostname_list_size);
-    }
-
-  hostname_list[hostname_list_length++] = savestring (name);
-  hostname_list[hostname_list_length] = (char *)NULL;
-}
-
-#define cr_whitespace(c) ((c) == '\r' || (c) == '\n' || whitespace(c))
-
-static void
-snarf_hosts_from_file (filename)
-     char *filename;
-{
-  FILE *file;
-  char *temp, buffer[256], name[256];
-  register int i, start;
-
-  file = fopen (filename, "r");
-  if (file == 0)
-    return;
-
-  while (temp = fgets (buffer, 255, file))
-    {
-      /* Skip to first character. */
-      for (i = 0; buffer[i] && cr_whitespace (buffer[i]); i++)
-	;
-
-      /* If comment or blank line, ignore. */
-      if (buffer[i] == '\0' || buffer[i] == '#')
-	continue;
-
-      /* If `preprocessor' directive, do the include. */
-      if (strncmp (buffer + i, "$include ", 9) == 0)
-	{
-	  char *incfile, *t;
-
-	  /* Find start of filename. */
-	  for (incfile = buffer + i + 9; *incfile && whitespace (*incfile); incfile++)
-	    ;
-
-	  /* Find end of filename. */
-	  for (t = incfile; *t && cr_whitespace (*t) == 0; t++)
-	    ;
-
-	  *t = '\0';
-
-	  snarf_hosts_from_file (incfile);
-	  continue;
-	}
-
-      /* Skip internet address if present. */
-      if (DIGIT (buffer[i]))
-	for (; buffer[i] && cr_whitespace (buffer[i]) == 0; i++);
-
-      /* Gobble up names.  Each name is separated with whitespace. */
-      while (buffer[i])
-	{
-	  for (; cr_whitespace (buffer[i]); i++)
-	    ;
-	  if (buffer[i] == '\0' || buffer[i] ==  '#')
-	    break;
-
-	  /* Isolate the current word. */
-	  for (start = i; buffer[i] && cr_whitespace (buffer[i]) == 0; i++)
-	    ;
-	  if (i == start)
-	    continue;
-	  strncpy (name, buffer + start, i - start);
-	  name[i - start] = '\0';
-	  add_host_name (name);
-	}
-    }
-  fclose (file);
-}
-
-/* Return the hostname list. */
-char **
-get_hostname_list ()
-{
-  if (hostname_list_initialized == 0)
-    initialize_hostname_list ();
-  return (hostname_list);
-}
-
-void
-clear_hostname_list ()
-{
-  register int i;
-
-  if (hostname_list_initialized == 0)
-    return;
-  for (i = 0; i < hostname_list_length; i++)
-    free (hostname_list[i]);
-  hostname_list_length = hostname_list_initialized = 0;
-}
-
-/* Return a NULL terminated list of hostnames which begin with TEXT.
-   Initialize the hostname list the first time if necessary.
-   The array is malloc ()'ed, but not the individual strings. */
-static char **
-hostnames_matching (text)
-     char *text;
-{
-  register int i, len, nmatch, rsize;
-  char **result;
-
-  if (hostname_list_initialized == 0)
-    initialize_hostname_list ();
-
-  if (hostname_list_initialized == 0)
-    return ((char **)NULL);
-
-  /* Special case.  If TEXT consists of nothing, then the whole list is
-     what is desired. */
-  if (*text == '\0')
-    {
-      result = strvec_create (1 + hostname_list_length);
-      for (i = 0; i < hostname_list_length; i++)
-	result[i] = hostname_list[i];
-      result[i] = (char *)NULL;
-      return (result);
-    }
-
-  /* Scan until found, or failure. */
-  len = strlen (text);
-  result = (char **)NULL;
-  for (i = nmatch = rsize = 0; i < hostname_list_length; i++)
-    {
-      if (STREQN (text, hostname_list[i], len) == 0)
-	continue;
-
-      /* OK, it matches.  Add it to the list. */
-      if (nmatch >= (rsize - 1))
-	{
-	  rsize = (rsize + 16) - (rsize % 16);
-	  result = strvec_resize (result, rsize);
-	}
-
-      result[nmatch++] = hostname_list[i];
-    }
-  if (nmatch)
-    result[nmatch] = (char *)NULL;
-  return (result);
-}
-
-/* This vi mode command causes VI_EDIT_COMMAND to be run on the current
-   command being entered (if no explicit argument is given), otherwise on
-   a command from the history file. */
-
-#define VI_EDIT_COMMAND		"fc -e \"${VISUAL:-${EDITOR:-vi}}\""
-#define EMACS_EDIT_COMMAND	"fc -e \"${VISUAL:-${EDITOR:-emacs}}\""
-#define POSIX_VI_EDIT_COMMAND	"fc -e vi"
-
-static int
-edit_and_execute_command (count, c, editing_mode, edit_command)
-     int count, c, editing_mode;
-     char *edit_command;
-{
-  char *command, *metaval;
-  int r, rrs, metaflag;
-  sh_parser_state_t ps;
-
-  rrs = rl_readline_state;
-  saved_command_line_count = current_command_line_count;
-
-  /* Accept the current line. */
-  rl_newline (1, c);
-
-  if (rl_explicit_arg)
-    {
-      command = (char *)xmalloc (strlen (edit_command) + 8);
-      sprintf (command, "%s %d", edit_command, count);
-    }
-  else
-    {
-      /* Take the command we were just editing, add it to the history file,
-	 then call fc to operate on it.  We have to add a dummy command to
-	 the end of the history because fc ignores the last command (assumes
-	 it's supposed to deal with the command before the `fc'). */
-      /* This breaks down when using command-oriented history and are not
-	 finished with the command, so we should not ignore the last command */
-      using_history ();
-      current_command_line_count++;	/* for rl_newline above */
-      bash_add_history (rl_line_buffer);
-      current_command_line_count = 0;	/* for dummy history entry */
-      bash_add_history ("");
-      history_lines_this_session++;
-      using_history ();
-      command = savestring (edit_command);
-    }
-
-  metaval = rl_variable_value ("input-meta");
-  metaflag = RL_BOOLEAN_VARIABLE_VALUE (metaval);
-  
-  if (rl_deprep_term_function)
-    (*rl_deprep_term_function) ();
-  rl_clear_signals ();
-  save_parser_state (&ps);
-  r = parse_and_execute (command, (editing_mode == VI_EDITING_MODE) ? "v" : "C-xC-e", SEVAL_NOHIST);
-  restore_parser_state (&ps);
-
-  /* if some kind of reset_parser was called, undo it. */
-  reset_readahead_token ();
-
-  if (rl_prep_term_function)
-    (*rl_prep_term_function) (metaflag);
-  rl_set_signals ();
-
-  current_command_line_count = saved_command_line_count;
-
-  /* Now erase the contents of the current line and undo the effects of the
-     rl_accept_line() above.  We don't even want to make the text we just
-     executed available for undoing. */
-  rl_line_buffer[0] = '\0';	/* XXX */
-  rl_point = rl_end = 0;
-  rl_done = 0;
-  rl_readline_state = rrs;
-
-#if defined (VI_MODE)
-  if (editing_mode == VI_EDITING_MODE)
-    rl_vi_insertion_mode (1, c);
-#endif
-
-  rl_forced_update_display ();
-
-  return r;
-}
-
-#if defined (VI_MODE)
-static int
-vi_edit_and_execute_command (count, c)
-     int count, c;
-{
-  if (posixly_correct)
-    return (edit_and_execute_command (count, c, VI_EDITING_MODE, POSIX_VI_EDIT_COMMAND));
-  else
-    return (edit_and_execute_command (count, c, VI_EDITING_MODE, VI_EDIT_COMMAND));
-}
-#endif /* VI_MODE */
-
-static int
-emacs_edit_and_execute_command (count, c)
-     int count, c;
-{
-  return (edit_and_execute_command (count, c, EMACS_EDITING_MODE, EMACS_EDIT_COMMAND));
-}
-
-#if defined (ALIAS)
-static int
-posix_edit_macros (count, key)
-     int count, key;
-{
-  int c;
-  char alias_name[3], *alias_value, *macro;
-
-  c = rl_read_key ();
-  if (c <= 0)
-    return 0;
-  alias_name[0] = '_';
-  alias_name[1] = c;
-  alias_name[2] = '\0';
-
-  alias_value = get_alias_value (alias_name);
-  if (alias_value && *alias_value)
-    {
-      macro = savestring (alias_value);
-      rl_push_macro_input (macro);
-    }
-  return 0;
-}
-#endif
-
-/* Bindable commands that move `shell-words': that is, sequences of
-   non-unquoted-metacharacters. */
-
-#define WORDDELIM(c)	(shellmeta(c) || shellblank(c))
-
-static int
-bash_forward_shellword (count, key)
-     int count, key;
-{
-  size_t slen;
-  int c, p;
-  DECLARE_MBSTATE;
-
-  if (count < 0)
-    return (bash_backward_shellword (-count, key));
-
-  /* The tricky part of this is deciding whether or not the first character
-     we're on is an unquoted metacharacter.  Not completely handled yet. */
-  /* XXX - need to test this stuff with backslash-escaped shell
-     metacharacters and unclosed single- and double-quoted strings. */
-
-  p = rl_point;
-  slen = rl_end;
-
-  while (count)
-    {
-      if (p == rl_end)
-	{
-	  rl_point = rl_end;
-	  return 0;
-	}
-
-      /* Are we in a quoted string?  If we are, move to the end of the quoted
-         string and continue the outer loop. We only want quoted strings, not
-         backslash-escaped characters, but char_is_quoted doesn't
-         differentiate. */
-      if (char_is_quoted (rl_line_buffer, p) && p > 0 && rl_line_buffer[p-1] != '\\')
-	{
-	  do
-	    ADVANCE_CHAR (rl_line_buffer, slen, p);
-	  while (p < rl_end && char_is_quoted (rl_line_buffer, p));
-	  count--;
-	  continue;
-	}
-
-      /* Rest of code assumes we are not in a quoted string. */
-      /* Move forward until we hit a non-metacharacter. */
-      while (p < rl_end && (c = rl_line_buffer[p]) && WORDDELIM (c))
-	{
-	  switch (c)
-	    {
-	    default:
-	      ADVANCE_CHAR (rl_line_buffer, slen, p);
-	      continue;		/* straight back to loop, don't increment p */
-	    case '\\':
-	      if (p < rl_end && rl_line_buffer[p])
-		ADVANCE_CHAR (rl_line_buffer, slen, p);
-	      break;
-	    case '\'':
-	      p = skip_to_delim (rl_line_buffer, ++p, "'", SD_NOJMP);
-	      break;
-	    case '"':
-	      p = skip_to_delim (rl_line_buffer, ++p, "\"", SD_NOJMP);
-	      break;
-	    }
-
-	  if (p < rl_end)
-	    p++;
-	}
-
-      if (rl_line_buffer[p] == 0 || p == rl_end)
-        {
-	  rl_point = rl_end;
-	  rl_ding ();
-	  return 0;
-        }
-	
-      /* Now move forward until we hit a non-quoted metacharacter or EOL */
-      while (p < rl_end && (c = rl_line_buffer[p]) && WORDDELIM (c) == 0)
-	{
-	  switch (c)
-	    {
-	    default:
-	      ADVANCE_CHAR (rl_line_buffer, slen, p);
-	      continue;		/* straight back to loop, don't increment p */
-	    case '\\':
-	      if (p < rl_end && rl_line_buffer[p])
-		ADVANCE_CHAR (rl_line_buffer, slen, p);
-	      break;
-	    case '\'':
-	      p = skip_to_delim (rl_line_buffer, ++p, "'", SD_NOJMP);
-	      break;
-	    case '"':
-	      p = skip_to_delim (rl_line_buffer, ++p, "\"", SD_NOJMP);
-	      break;
-	    }
-
-	  if (p < rl_end)
-	    p++;
-	}
-
-      if (p == rl_end || rl_line_buffer[p] == 0)
-	{
-	  rl_point = rl_end;
-	  return (0);
-	}
-
-      count--;      
-    }
-
-  rl_point = p;
-  return (0);
-}
-
-static int
-bash_backward_shellword (count, key)
-     int count, key;
-{
-  size_t slen;
-  int c, p, prev_p;
-  DECLARE_MBSTATE;
-
-  if (count < 0)
-    return (bash_forward_shellword (-count, key));
-
-  p = rl_point;
-  slen = rl_end;
-
-  while (count)
-    {
-      if (p == 0)
-	{
-	  rl_point = 0;
-	  return 0;
-	}
-
-      /* Move backward until we hit a non-metacharacter. We want to deal
-	 with the characters before point, so we move off a word if we're
-	 at its first character. */
-      BACKUP_CHAR (rl_line_buffer, slen, p);
-      while (p > 0)
-	{
-	  c = rl_line_buffer[p];
-	  if (WORDDELIM (c) == 0 || char_is_quoted (rl_line_buffer, p))
-	    break;
-	  BACKUP_CHAR (rl_line_buffer, slen, p);
-	}
-
-      if (p == 0)
-	{
-	  rl_point = 0;
-	  return 0;
-	}
-
-      /* Now move backward until we hit a metacharacter or BOL. Leave point
-	 at the start of the shellword or at BOL. */
-      prev_p = p;
-      while (p > 0)
-	{
-	  c = rl_line_buffer[p];
-	  if (WORDDELIM (c) && char_is_quoted (rl_line_buffer, p) == 0)
-	    {
-	      p = prev_p;
-	      break;
-	    }
-	  prev_p = p;
-	  BACKUP_CHAR (rl_line_buffer, slen, p);
-	}
-
-      count--;
-    }
-
-  rl_point = p;
-  return 0;
-}
-
-static int
-bash_kill_shellword (count, key)
-     int count, key;
-{
-  int p;
-
-  if (count < 0)
-    return (bash_backward_kill_shellword (-count, key));
-
-  p = rl_point;
-  bash_forward_shellword (count, key);
-
-  if (rl_point != p)
-    rl_kill_text (p, rl_point);
-
-  rl_point = p;
-  if (rl_editing_mode == EMACS_EDITING_MODE)	/* 1 == emacs_mode */
-    rl_mark = rl_point;
-
-  return 0;
-}
-
-static int
-bash_backward_kill_shellword (count, key)
-     int count, key;
-{
-  int p;
-
-  if (count < 0)
-    return (bash_kill_shellword (-count, key));
-
-  p = rl_point;
-  bash_backward_shellword (count, key);
-
-  if (rl_point != p)
-    rl_kill_text (p, rl_point);
-
-  if (rl_editing_mode == EMACS_EDITING_MODE)	/* 1 == emacs_mode */
-    rl_mark = rl_point;
-
-  return 0;
-}
-
-static int
-bash_transpose_shellwords (count, key)
-     int count, key;
-{
-  char *word1, *word2;
-  int w1_beg, w1_end, w2_beg, w2_end;
-  int orig_point = rl_point;
-
-  if (count == 0)
-    return 0;
-
-  /* Find the two shell words. */
-  bash_forward_shellword (count, key);
-  w2_end = rl_point;
-  bash_backward_shellword (1, key);
-  w2_beg = rl_point;
-  bash_backward_shellword (count, key);
-  w1_beg = rl_point;
-  bash_forward_shellword (1, key);
-  w1_end = rl_point;
-
-  /* check that there really are two words. */
-  if ((w1_beg == w2_beg) || (w2_beg < w1_end))
-    {
-      rl_ding ();
-      rl_point = orig_point;
-      return 1;
-    }
-
-  /* Get the text of the words. */
-  word1 = rl_copy_text (w1_beg, w1_end);
-  word2 = rl_copy_text (w2_beg, w2_end);
-
-  /* We are about to do many insertions and deletions.  Remember them
-     as one operation. */
-  rl_begin_undo_group ();
-
-  /* Do the stuff at word2 first, so that we don't have to worry
-     about word1 moving. */
-  rl_point = w2_beg;
-  rl_delete_text (w2_beg, w2_end);
-  rl_insert_text (word1);
-
-  rl_point = w1_beg;
-  rl_delete_text (w1_beg, w1_end);
-  rl_insert_text (word2);
-
-  /* This is exactly correct since the text before this point has not
-     changed in length. */
-  rl_point = w2_end;
-
-  /* I think that does it. */
-  rl_end_undo_group ();
-  xfree (word1);
-  xfree (word2);
-
-  return 0;
-}
-
-/* Directory name spelling correction on the current word (not shellword).
-   COUNT > 1 is not exactly correct yet. */
-static int
-bash_spell_correct_shellword (count, key)
-     int count, key;
-{
-  int opoint, wbeg, wend;
-  char *text, *newdir;
-
-  opoint = rl_point;
-  while (count)
-    {
-      bash_backward_shellword (1, key);
-      wbeg = rl_point;
-      bash_forward_shellword (1, key);
-      wend = rl_point;
-
-      if (wbeg > wend)
-	break;
-
-      text = rl_copy_text (wbeg, wend);
-
-      newdir = dirspell (text);
-      if (newdir)
-	{
-	  rl_begin_undo_group ();
-	  rl_delete_text (wbeg, wend);
-	  rl_point = wbeg;
-	  if (*newdir)
-	    rl_insert_text (newdir);
-	  rl_mark = wbeg;
-	  rl_end_undo_group ();
-	}
-
-      free (text);
-      free (newdir);
-
-      if (rl_point >= rl_end)
-	break;
-
-      count--;
-
-      if (count)
-	bash_forward_shellword (1, key);		/* XXX */
-    }
-
-  return 0;
-}
-
-/* **************************************************************** */
-/*								    */
-/*			How To Do Shell Completion		    */
-/*								    */
-/* **************************************************************** */
-
-#define COMMAND_SEPARATORS ";|&{(`"
-/* )} */ 
-#define COMMAND_SEPARATORS_PLUS_WS ";|&{(` \t"
-/* )} */ 
-
-/* check for redirections and other character combinations that are not
-   command separators */
-static int
-check_redir (ti)
-     int ti;
-{
-  register int this_char, prev_char;
-
-  /* Handle the two character tokens `>&', `<&', and `>|'.
-     We are not in a command position after one of these. */
-  this_char = rl_line_buffer[ti];
-  prev_char = (ti > 0) ? rl_line_buffer[ti - 1] : 0;
-
-  if ((this_char == '&' && (prev_char == '<' || prev_char == '>')) ||
-      (this_char == '|' && prev_char == '>'))
-    return (1);
-  else if (this_char == '{' && prev_char == '$') /*}*/
-    return (1);
-#if 0	/* Not yet */
-  else if (this_char == '(' && prev_char == '$') /*)*/
-    return (1);
-  else if (this_char == '(' && prev_char == '<') /*)*/
-    return (1);
-#if defined (EXTENDED_GLOB)
-  else if (extended_glob && this_char == '(' && prev_char == '!') /*)*/
-    return (1);
-#endif
-#endif
-  else if (char_is_quoted (rl_line_buffer, ti))
-    return (1);
-  return (0);
-}
-
-#if defined (PROGRAMMABLE_COMPLETION)
-/*
- * XXX - because of the <= start test, and setting os = s+1, this can
- * potentially return os > start.  This is probably not what we want to
- * happen, but fix later after 2.05a-release.
- */
-static int
-find_cmd_start (start)
-     int start;
-{
-  register int s, os, ns;
-
-  os = 0;
-  /* Flags == SD_NOJMP only because we want to skip over command substitutions
-     in assignment statements.  Have to test whether this affects `standalone'
-     command substitutions as individual words. */
-  while (((s = skip_to_delim (rl_line_buffer, os, COMMAND_SEPARATORS, SD_NOJMP|SD_COMPLETE/*|SD_NOSKIPCMD*/)) <= start) &&
-	 rl_line_buffer[s])
-    {
-      /* Handle >| token crudely; treat as > not | */
-      if (s > 0 && rl_line_buffer[s] == '|' && rl_line_buffer[s-1] == '>')
-	{
-	  ns = skip_to_delim (rl_line_buffer, s+1, COMMAND_SEPARATORS, SD_NOJMP|SD_COMPLETE/*|SD_NOSKIPCMD*/);
-	  if (ns > start || rl_line_buffer[ns] == 0)
-	    return os;
-	  os = ns+1;
-	  continue;
-	}
-      /* The only reserved word in COMMAND_SEPARATORS is `{', so handle that
-	 specially, making sure it's in a spot acceptable for reserved words */
-      if (s >= os && rl_line_buffer[s] == '{')
-	{
-	  int pc, nc;	/* index of previous non-whitespace, next char */
-	  for (pc = (s > os) ? s - 1 : os; pc > os && whitespace(rl_line_buffer[pc]); pc--)
-	    ;
-	  nc = rl_line_buffer[s+1];
-	  /* must be preceded by a command separator or be the first non-
-	     whitespace character since the last command separator, and
-	     followed by a shell break character (not another `{') to be a reserved word. */
-	  if ((pc > os && (rl_line_buffer[s-1] == '{' || strchr (COMMAND_SEPARATORS, rl_line_buffer[pc]) == 0)) ||
-	      (shellbreak(nc) == 0))	/* }} */
-	    {
-	      /* Not a reserved word, look for another delim */
-	      ns = skip_to_delim (rl_line_buffer, s+1, COMMAND_SEPARATORS, SD_NOJMP|SD_COMPLETE/*|SD_NOSKIPCMD*/);
-	      if (ns > start || rl_line_buffer[ns] == 0)
-		return os;
-	      os = ns+1;
-	      continue;
-	    }
-	}
-      os = s+1;
-    }
-  return os;
-}
-
-static int
-find_cmd_end (end)
-     int end;
-{
-  register int e;
-
-  e = skip_to_delim (rl_line_buffer, end, COMMAND_SEPARATORS, SD_NOJMP|SD_COMPLETE);
-  return e;
-}
-
-static char *
-find_cmd_name (start, sp, ep)
-     int start;
-     int *sp, *ep;
-{
-  char *name;
-  register int s, e;
-
-  for (s = start; whitespace (rl_line_buffer[s]); s++)
-    ;
-
-  /* skip until a shell break character */
-  e = skip_to_delim (rl_line_buffer, s, "()<>;&| \t\n", SD_NOJMP|SD_COMPLETE);
-
-  name = substring (rl_line_buffer, s, e);
-
-  if (sp)
-    *sp = s;
-  if (ep)
-    *ep = e;
-
-  return (name);
-}
-
-static char *
-prog_complete_return (text, matchnum)
-     const char *text;
-     int matchnum;
-{
-  static int ind;
-
-  if (matchnum == 0)
-    ind = 0;
-
-  if (prog_complete_matches == 0 || prog_complete_matches[ind] == 0)
-    return (char *)NULL;
-  return (prog_complete_matches[ind++]);
-}
-
-#endif /* PROGRAMMABLE_COMPLETION */
-
-/* Try and catch completion attempts that are syntax errors or otherwise
-   invalid. */
-static int
-invalid_completion (text, ind)
-     const char *text;
-     int ind;
-{
-  int pind;
-
-  /* If we don't catch these here, the next clause will */
-  if (ind > 0 && rl_line_buffer[ind] == '(' &&	/*)*/
-		 member (rl_line_buffer[ind-1], "$<>"))
-    return 0;
-
-  pind = ind - 1;
-  while (pind > 0 && whitespace (rl_line_buffer[pind]))
-    pind--;
-  /* If we have only whitespace preceding a paren, it's valid */
-  if (ind >= 0 && pind <= 0 && rl_line_buffer[ind] == '(')	/*)*/
-    return 0;
-  /* Flag the invalid completions, which are mostly syntax errors */
-  if (ind > 0 && rl_line_buffer[ind] == '(' &&	/*)*/
-		 member (rl_line_buffer[pind], COMMAND_SEPARATORS) == 0)
-    return 1;
-
-  return 0;
-}
-
-/* Do some completion on TEXT.  The indices of TEXT in RL_LINE_BUFFER are
-   at START and END.  Return an array of matches, or NULL if none. */
-static char **
-attempt_shell_completion (text, start, end)
-     const char *text;
-     int start, end;
-{
-  int in_command_position, ti, qc, dflags;
-  char **matches, *command_separator_chars;
-#if defined (PROGRAMMABLE_COMPLETION)
-  int have_progcomps, was_assignment;
-  COMPSPEC *iw_compspec;
-#endif
-
-  command_separator_chars = COMMAND_SEPARATORS;
-  matches = (char **)NULL;
-  rl_ignore_some_completions_function = filename_completion_ignore;
-
-  complete_fullquote = 1;		/* full filename quoting by default */
-  rl_filename_quote_characters = default_filename_quote_characters;
-  set_filename_bstab (rl_filename_quote_characters);
-  set_directory_hook ();
-  rl_filename_stat_hook = bash_filename_stat_hook;
-
-  rl_sort_completion_matches = 1;	/* sort by default */
-
-  /* Determine if this could be a command word.  It is if it appears at
-     the start of the line (ignoring preceding whitespace), or if it
-     appears after a character that separates commands.  It cannot be a
-     command word if we aren't at the top-level prompt. */
-  ti = start - 1;
-  qc = -1;
-
-  while ((ti > -1) && (whitespace (rl_line_buffer[ti])))
-    ti--;
-
-#if 1
-  /* If this is an open quote, maybe we're trying to complete a quoted
-     command name. */
-  if (ti >= 0 && (rl_line_buffer[ti] == '"' || rl_line_buffer[ti] == '\''))
-    {
-      qc = rl_line_buffer[ti];
-      ti--;
-      while (ti > -1 && (whitespace (rl_line_buffer[ti])))
-	ti--;
-    }
-#endif
-      
-  in_command_position = 0;
-  if (ti < 0)
-    {
-      /* Only do command completion at the start of a line when we
-	 are prompting at the top level. */
-      if (current_prompt_string == ps1_prompt)
-	in_command_position++;
-      else if (parser_in_command_position ())
-	in_command_position++;
-    }
-  else if (member (rl_line_buffer[ti], command_separator_chars))
-    {
-      in_command_position++;
-
-      if (check_redir (ti) == 1)
-	in_command_position = -1;	/* sentinel that we're not the first word on the line */
-    }
-  else
-    {
-      /* This still could be in command position.  It is possible
-	 that all of the previous words on the line are variable
-	 assignments. */
-    }
-
-  if (in_command_position > 0 && invalid_completion (text, ti))
-    {
-      rl_attempted_completion_over = 1;
-      return ((char **)NULL);
-    }
-
-  /* Check that we haven't incorrectly flagged a closed command substitution
-     as indicating we're in a command position. */
-  if (in_command_position > 0 && ti >= 0 && rl_line_buffer[ti] == '`' &&
-	*text != '`' && unclosed_pair (rl_line_buffer, end, "`") == 0)
-    in_command_position = -1;	/* not following a command separator */
-
-  /* Special handling for command substitution.  If *TEXT is a backquote,
-     it can be the start or end of an old-style command substitution, or
-     unmatched.  If it's unmatched, both calls to unclosed_pair will
-     succeed.  Don't bother if readline found a single quote and we are
-     completing on the substring.  */
-  if (*text == '`' && rl_completion_quote_character != '\'' &&
-	(in_command_position > 0 || (unclosed_pair (rl_line_buffer, start, "`") &&
-				     unclosed_pair (rl_line_buffer, end, "`"))))
-    matches = rl_completion_matches (text, command_subst_completion_function);
-
-#if defined (PROGRAMMABLE_COMPLETION)
-  /* Attempt programmable completion. */
-  have_progcomps = prog_completion_enabled && (progcomp_size () > 0);
-  iw_compspec = progcomp_search (INITIALWORD);
-  if (matches == 0 &&
-      (in_command_position == 0 || text[0] == '\0' || (in_command_position > 0 && iw_compspec)) &&
-      current_prompt_string == ps1_prompt)
-    {
-      int s, e, s1, e1, os, foundcs;
-      char *n;
-
-      /* XXX - don't free the members */
-      if (prog_complete_matches)
-	free (prog_complete_matches);
-      prog_complete_matches = (char **)NULL;
-
-      os = start;
-      n = 0;
-      was_assignment = 0;
-      s = find_cmd_start (os);
-      e = find_cmd_end (end);
-      do
-	{
-	  /* Don't read past the end of rl_line_buffer */
-	  if (s > rl_end)
-	    {
-	      s1 = s = e1;
-	      break;
-	    }
-	  /* Or past point if point is within an assignment statement */
-	  else if (was_assignment && s > rl_point)
-	    {
-	      s1 = s = e1;
-	      break;
-	    }
-	  /* Skip over assignment statements preceding a command name.  If we
-	     don't find a command name at all, we can perform command name
-	     completion.  If we find a partial command name, we should perform
-	     command name completion on it. */
-	  FREE (n);
-	  n = find_cmd_name (s, &s1, &e1);
-	  s = e1 + 1;
-	}
-      while (was_assignment = assignment (n, 0));
-      s = s1;		/* reset to index where name begins */
-
-      /* s == index of where command name begins (reset above)
-	 e == end of current command, may be end of line
-         s1 = index of where command name begins
-         e1 == index of where command name ends
-	 start == index of where word to be completed begins
-	 end == index of where word to be completed ends
-	 if (s == start) we are doing command word completion for sure
-	 if (e1 == end) we are at the end of the command name and completing it */
-      if (start == 0 && end == 0 && e != 0 && text[0] == '\0')	/* beginning of non-empty line */
-        foundcs = 0;
-      else if (start == end && start == s1 && e != 0 && e1 > end)	/* beginning of command name, leading whitespace */
-	foundcs = 0;
-      else if (e == 0 && e == s && text[0] == '\0' && have_progcomps)	/* beginning of empty line */
-        prog_complete_matches = programmable_completions (EMPTYCMD, text, s, e, &foundcs);
-      else if (start == end && text[0] == '\0' && s1 > start && whitespace (rl_line_buffer[start]))
-        foundcs = 0;		/* whitespace before command name */
-      else if (e > s && was_assignment == 0 && e1 == end && rl_line_buffer[e] == 0 && whitespace (rl_line_buffer[e-1]) == 0)
-	{
-	  /* not assignment statement, but still want to perform command
-	     completion if we are composing command word. */
-	  foundcs = 0;
-	  in_command_position = s == start && STREQ (n, text);	/* XXX */
-	}
-      else if (e > s && was_assignment == 0 && have_progcomps)
-	{
-	  prog_complete_matches = programmable_completions (n, text, s, e, &foundcs);
-	  /* command completion if programmable completion fails */
-	  /* If we have a completion for the initial word, we can prefer that */
-	  in_command_position = s == start && (iw_compspec || STREQ (n, text));	/* XXX */
-	  if (iw_compspec && in_command_position)
-	    foundcs = 0;
-	}
-      /* empty command name following command separator */
-      else if (s >= e && n[0] == '\0' && text[0] == '\0' && start > 0 &&
-		was_assignment == 0 && member (rl_line_buffer[start-1], COMMAND_SEPARATORS))
-	{
-	  foundcs = 0;
-	  in_command_position = 1;
-	}
-      else if (s >= e && n[0] == '\0' && text[0] == '\0' && start > 0)
-        {
-          foundcs = 0;	/* empty command name following optional assignments */
-          in_command_position += was_assignment;
-        }
-      else if (s == start && e == end && STREQ (n, text) && start > 0)
-        {
-          foundcs = 0;	/* partial command name following assignments */
-          in_command_position = 1;
-        }
-      else
-	foundcs = 0;
-
-      /* If we have defined a compspec for the initial (command) word, call
-	 it and process the results like any other programmable completion. */
-      if (in_command_position && have_progcomps && foundcs == 0 && iw_compspec)
-	prog_complete_matches = programmable_completions (INITIALWORD, text, s, e, &foundcs);
-
-      FREE (n);
-      /* XXX - if we found a COMPSPEC for the command, just return whatever
-	 the programmable completion code returns, and disable the default
-	 filename completion that readline will do unless the COPT_DEFAULT
-	 option has been set with the `-o default' option to complete or
-	 compopt. */
-      if (foundcs)
-	{
-	  pcomp_set_readline_variables (foundcs, 1);
-	  /* Turn what the programmable completion code returns into what
-	     readline wants.  I should have made compute_lcd_of_matches
-	     external... */
-	  matches = rl_completion_matches (text, prog_complete_return);
-	  if ((foundcs & COPT_DEFAULT) == 0)
-	    rl_attempted_completion_over = 1;	/* no default */
-	  if (matches || ((foundcs & COPT_BASHDEFAULT) == 0))
-	    return (matches);
-	}
-    }
-#endif
-
-  if (matches == 0)
-    {
-      dflags = 0;
-      if (in_command_position > 0)
-	dflags |= DEFCOMP_CMDPOS;
-      matches = bash_default_completion (text, start, end, qc, dflags);
-    }
-
-  return matches;
-}
-
-char **
-bash_default_completion (text, start, end, qc, compflags)
-     const char *text;
-     int start, end, qc, compflags;
-{
-  char **matches, *t;
-
-  matches = (char **)NULL;
-
-  /* New posix-style command substitution or variable name? */
-  if (*text == '$')
-    {
-      if (qc != '\'' && text[1] == '(') /* ) */
-	matches = rl_completion_matches (text, command_subst_completion_function);
-      else
-	{
-	  matches = rl_completion_matches (text, variable_completion_function);
-	  /* If a single match, see if it expands to a directory name and append
-	     a slash if it does.  This requires us to expand the variable name,
-	     so we don't want to display errors if the variable is unset.  This
-	     can happen with dynamic variables whose value has never been
-	     requested. */
-	  if (matches && matches[0] && matches[1] == 0)
-	    {
-	      t = savestring (matches[0]);
-	      bash_filename_stat_hook (&t);
-	      /* doesn't use test_for_directory because that performs tilde
-		 expansion */
-	      if (file_isdir (t))
-		rl_completion_append_character = '/';
-	      free (t);
-	    }
-	}
-    }
-
-  /* If the word starts in `~', and there is no slash in the word, then
-     try completing this word as a username. */
-  if (matches == 0 && *text == '~' && mbschr (text, '/') == 0)
-    matches = rl_completion_matches (text, rl_username_completion_function);
-
-  /* Another one.  Why not?  If the word starts in '@', then look through
-     the world of known hostnames for completion first. */
-  if (matches == 0 && perform_hostname_completion && *text == '@')
-    matches = rl_completion_matches (text, hostname_completion_function);
-
-  /* And last, (but not least) if this word is in a command position, then
-     complete over possible command names, including aliases, functions,
-     and command names. */
-  if (matches == 0 && (compflags & DEFCOMP_CMDPOS))
-    {
-      /* If END == START and text[0] == 0, we are trying to complete an empty
-	 command word. */
-      if (no_empty_command_completion && end == start && text[0] == '\0')
-	{
-	  matches = (char **)NULL;
-	  rl_ignore_some_completions_function = bash_ignore_everything;
-	}
-      else
-	{
-#define CMD_IS_DIR(x)	(absolute_pathname(x) == 0 && absolute_program(x) == 0 && *(x) != '~' && test_for_directory (x))
-
-	  dot_in_path = 0;
-	  matches = rl_completion_matches (text, command_word_completion_function);
-
-	  /* If we are attempting command completion and nothing matches, we
-	     do not want readline to perform filename completion for us.  We
-	     still want to be able to complete partial pathnames, so set the
-	     completion ignore function to something which will remove
-	     filenames and leave directories in the match list. */
-	  if (matches == (char **)NULL)
-	    rl_ignore_some_completions_function = bash_ignore_filenames;
-	  else if (matches[1] == 0 && CMD_IS_DIR(matches[0]) && dot_in_path == 0)
-	    /* If we found a single match, without looking in the current
-	       directory (because it's not in $PATH), but the found name is
-	       also a command in the current directory, suppress appending any
-	       terminating character, since it's ambiguous. */
-	    {
-	      rl_completion_suppress_append = 1;
-	      rl_filename_completion_desired = 0;
-	    }
-	  else if (matches[0] && matches[1] && STREQ (matches[0], matches[1]) && CMD_IS_DIR (matches[0]))
-	    /* There are multiple instances of the same match (duplicate
-	       completions haven't yet been removed).  In this case, all of
-	       the matches will be the same, and the duplicate removal code
-	       will distill them all down to one.  We turn on
-	       rl_completion_suppress_append for the same reason as above.
-	       Remember: we only care if there's eventually a single unique
-	       completion.  If there are multiple completions this won't
-	       make a difference and the problem won't occur. */
-	    {
-	      rl_completion_suppress_append = 1;
-	      rl_filename_completion_desired = 0;
-	    }
-	}
-    }
-
-  /* This could be a globbing pattern, so try to expand it using pathname
-     expansion. */
-  if (!matches && completion_glob_pattern ((char *)text))
-    {
-      matches = rl_completion_matches (text, glob_complete_word);
-      /* A glob expression that matches more than one filename is problematic.
-	 If we match more than one filename, punt. */
-      if (matches && matches[1] && rl_completion_type == TAB)
-	{
-	  strvec_dispose (matches);
-	  matches = (char **)0;
-	}
-      else if (matches && matches[1] && rl_completion_type == '!')
-	{
-	  rl_completion_suppress_append = 1;
-	  rl_filename_completion_desired = 0;
-	}
-    }
-
-  return (matches);
-}
-
-static int
-bash_command_name_stat_hook (name)
-     char **name;
-{
-  char *cname, *result;
-
-  /* If it's not something we're going to look up in $PATH, just call the
-     normal filename stat hook. */
-  if (absolute_program (*name))
-    return (bash_filename_stat_hook (name));
-
-  cname = *name;
-  /* XXX - we could do something here with converting aliases, builtins,
-     and functions into something that came out as executable, but we don't. */
-  result = search_for_command (cname, 0);
-  if (result)
-    {
-      *name = result;
-      return 1;
-    }
-  return 0;
-}
-
-static int
-executable_completion (filename, searching_path)
-     const char *filename;
-     int searching_path;
-{
-  char *f, c;
-  int r;
-
-  /* This gets an unquoted filename, so we need to quote special characters
-     in the filename before the completion hook gets it. */
-#if 0
-  f = savestring (filename);
-#else
-  c = 0;
-  f = bash_quote_filename ((char *)filename, SINGLE_MATCH, &c);
-#endif
-  bash_directory_completion_hook (&f);
-  
-  r = searching_path ? executable_file (f) : executable_or_directory (f);
-  free (f);
-  return r;
-}
-
-/* This is the function to call when the word to complete is in a position
-   where a command word can be found.  It grovels $PATH, looking for commands
-   that match.  It also scans aliases, function names, and the shell_builtin
-   table. */
-char *
-command_word_completion_function (hint_text, state)
-     const char *hint_text;
-     int state;
-{
-  static char *hint = (char *)NULL;
-  static char *path = (char *)NULL;
-  static char *val = (char *)NULL;
-  static char *filename_hint = (char *)NULL;
-  static char *fnhint = (char *)NULL;
-  static char *dequoted_hint = (char *)NULL;
-  static char *directory_part = (char *)NULL;
-  static char **glob_matches = (char **)NULL;
-  static int path_index, hint_len, istate, igncase;
-  static int mapping_over, local_index, searching_path, hint_is_dir;
-  static int old_glob_ignore_case, globpat;
-  static SHELL_VAR **varlist = (SHELL_VAR **)NULL;
-#if defined (ALIAS)
-  static alias_t **alias_list = (alias_t **)NULL;
-#endif /* ALIAS */
-  char *temp, *cval;
-
-  /* We have to map over the possibilities for command words.  If we have
-     no state, then make one just for that purpose. */
-  if (state == 0)
-    {
-      rl_filename_stat_hook = bash_command_name_stat_hook;
-
-      if (dequoted_hint && dequoted_hint != hint)
-	free (dequoted_hint);
-      if (hint)
-	free (hint);
-
-      mapping_over = searching_path = 0;
-      hint_is_dir = CMD_IS_DIR (hint_text);
-      val = (char *)NULL;
-
-      temp = rl_variable_value ("completion-ignore-case");
-      igncase = RL_BOOLEAN_VARIABLE_VALUE (temp);
-
-      old_glob_ignore_case = glob_ignore_case;
-
-      if (glob_matches)
-	{
-	  free (glob_matches);
-	  glob_matches = (char **)NULL;
-	}
-
-      globpat = completion_glob_pattern ((char *)hint_text);
-
-      /* If this is an absolute program name, do not check it against
-	 aliases, reserved words, functions or builtins.  We must check
-	 whether or not it is unique, and, if so, whether that filename
-	 is executable. */
-      if (globpat || absolute_program (hint_text))
-	{
-	  /* Perform tilde expansion on what's passed, so we don't end up
-	     passing filenames with tildes directly to stat().  The rest of
-	     the shell doesn't do variable expansion on the word following
-	     the tilde, so we don't do it here even if direxpand is set. */
-	  if (*hint_text == '~')
-	    {
-	      hint = bash_tilde_expand (hint_text, 0);
-	      directory_part = savestring (hint_text);
-	      temp = strchr (directory_part, '/');
-	      if (temp)
-		*temp = 0;
-	      else
-		{
-		  free (directory_part);
-		  directory_part = (char *)NULL;
-		}
-	    }
-	  else if (dircomplete_expand)
-	    {
-	      hint = savestring (hint_text);
-	      bash_directory_completion_hook (&hint);
-	    }
-	  else
-	    hint = savestring (hint_text);
-
-	  dequoted_hint = hint;
-	  /* If readline's completer found a quote character somewhere, but
-	     didn't set the quote character, there must have been a quote
-	     character embedded in the filename.  It can't be at the start of
-	     the filename, so we need to dequote the filename before we look
-	     in the file system for it. */
-	  if (rl_completion_found_quote && rl_completion_quote_character == 0)
-	    {
-	      dequoted_hint = bash_dequote_filename (hint, 0);
-	      free (hint);
-	      hint = dequoted_hint;
-	    }
-	  hint_len = strlen (hint);
-
-	  if (filename_hint)
-	    free (filename_hint);
-
-	  fnhint = filename_hint = savestring (hint);
-
-	  istate = 0;
-
-	  if (globpat)
-	    {
-	      mapping_over = 5;
-	      goto globword;
-	    }
-	  else
-	    {
-	     if (dircomplete_expand && path_dot_or_dotdot (filename_hint))
-		{
-		  dircomplete_expand = 0;
-		  set_directory_hook ();
-		  dircomplete_expand = 1;
-		}
-	      mapping_over = 4;
-	      goto inner;
-	    }
-	}
-
-      dequoted_hint = hint = savestring (hint_text);
-      hint_len = strlen (hint);
-
-      if (rl_completion_found_quote && rl_completion_quote_character == 0)
-	dequoted_hint = bash_dequote_filename (hint, 0);
-      
-      path = get_string_value ("PATH");
-      path_index = dot_in_path = 0;
-
-      /* Initialize the variables for each type of command word. */
-      local_index = 0;
-
-      if (varlist)
-	free (varlist);
-
-      varlist = all_visible_functions ();
-
-#if defined (ALIAS)
-      if (alias_list)
-	free (alias_list);
-
-      alias_list = all_aliases ();
-#endif /* ALIAS */
-    }
-
-  /* mapping_over says what we are currently hacking.  Note that every case
-     in this list must fall through when there are no more possibilities. */
-
-  switch (mapping_over)
-    {
-    case 0:			/* Aliases come first. */
-#if defined (ALIAS)
-      while (alias_list && alias_list[local_index])
-	{
-	  register char *alias;
-
-	  alias = alias_list[local_index++]->name;
-
-	  if (igncase == 0 && (STREQN (alias, hint, hint_len)))
-	    return (savestring (alias));
-	  else if (igncase && strncasecmp (alias, hint, hint_len) == 0)
-	    return (savestring (alias));
-	}
-#endif /* ALIAS */
-      local_index = 0;
-      mapping_over++;
-
-    case 1:			/* Then shell reserved words. */
-      {
-	while (word_token_alist[local_index].word)
-	  {
-	    register char *reserved_word;
-
-	    reserved_word = word_token_alist[local_index++].word;
-
-	    if (STREQN (reserved_word, hint, hint_len))
-	      return (savestring (reserved_word));
-	  }
-	local_index = 0;
-	mapping_over++;
-      }
-
-    case 2:			/* Then function names. */
-      while (varlist && varlist[local_index])
-	{
-	  register char *varname;
-
-	  varname = varlist[local_index++]->name;
-
-	  /* Honor completion-ignore-case for shell function names. */
-	  if (igncase == 0 && (STREQN (varname, hint, hint_len)))
-	    return (savestring (varname));
-	  else if (igncase && strncasecmp (varname, hint, hint_len) == 0)
-	    return (savestring (varname));
-	}
-      local_index = 0;
-      mapping_over++;
-
-    case 3:			/* Then shell builtins. */
-      for (; local_index < num_shell_builtins; local_index++)
-	{
-	  /* Ignore it if it doesn't have a function pointer or if it
-	     is not currently enabled. */
-	  if (!shell_builtins[local_index].function ||
-	      (shell_builtins[local_index].flags & BUILTIN_ENABLED) == 0)
-	    continue;
-
-	  if (STREQN (shell_builtins[local_index].name, hint, hint_len))
-	    {
-	      int i = local_index++;
-
-	      return (savestring (shell_builtins[i].name));
-	    }
-	}
-      local_index = 0;
-      mapping_over++;
-    }
-
-globword:
-  /* Limited support for completing command words with globbing chars.  Only
-     a single match (multiple matches that end up reducing the number of
-     characters in the common prefix are bad) will ever be returned on
-     regular completion. */
-  if (globpat)
-    {
-      if (state == 0)
-	{
-	  rl_filename_completion_desired = 1;
-
-	  glob_ignore_case = igncase;
-	  glob_matches = shell_glob_filename (hint, 0);
-	  glob_ignore_case = old_glob_ignore_case;
-
-	  if (GLOB_FAILED (glob_matches) || glob_matches == 0)
-	    {
-	      glob_matches = (char **)NULL;
-	      return ((char *)NULL);
-	    }
-
-	  local_index = 0;
-		
-	  if (glob_matches[1] && rl_completion_type == TAB)	/* multiple matches are bad */
-	    return ((char *)NULL);
-	}
-
-      while (val = glob_matches[local_index++])
-        {
-	  if (executable_or_directory (val))
-	    {
-	      if (*hint_text == '~' && directory_part)
-		{
-		  temp = maybe_restore_tilde (val, directory_part);
-		  free (val);
-		  val = temp;
-		}
-	      return (val);
-	    }
-	  free (val);
-        }
-
-      glob_ignore_case = old_glob_ignore_case;
-      return ((char *)NULL);
-    }
-
-  /* If the text passed is a directory in the current directory, return it
-     as a possible match.  Executables in directories in the current
-     directory can be specified using relative pathnames and successfully
-     executed even when `.' is not in $PATH. */
-  if (hint_is_dir)
-    {
-      hint_is_dir = 0;	/* only return the hint text once */
-      return (savestring (hint_text));
-    }
-    
-  /* Repeatedly call filename_completion_function while we have
-     members of PATH left.  Question:  should we stat each file?
-     Answer: we call executable_file () on each file. */
- outer:
-
-  istate = (val != (char *)NULL);
-
-  if (istate == 0)
-    {
-      char *current_path;
-
-      /* Get the next directory from the path.  If there is none, then we
-	 are all done. */
-      if (path == 0 || path[path_index] == 0 ||
-	  (current_path = extract_colon_unit (path, &path_index)) == 0)
-	return ((char *)NULL);
-
-      searching_path = 1;
-      if (*current_path == 0)
-	{
-	  free (current_path);
-	  current_path = savestring (".");
-	}
-
-      if (*current_path == '~')
-	{
-	  char *t;
-
-	  t = bash_tilde_expand (current_path, 0);
-	  free (current_path);
-	  current_path = t;
-	}
-
-      if (current_path[0] == '.' && current_path[1] == '\0')
-	dot_in_path = 1;
-
-      if (fnhint && fnhint != filename_hint)
-	free (fnhint);
-      if (filename_hint)
-	free (filename_hint);
-
-      filename_hint = sh_makepath (current_path, hint, 0);
-      /* Need a quoted version (though it doesn't matter much in most
-	 cases) because rl_filename_completion_function dequotes the
-	 filename it gets, assuming that it's been quoted as part of
-	 the input line buffer. */
-      if (strpbrk (filename_hint, "\"'\\"))
-	fnhint = sh_backslash_quote (filename_hint, filename_bstab, 0);
-      else
-	fnhint = filename_hint;
-      free (current_path);		/* XXX */
-    }
-
- inner:
-  val = rl_filename_completion_function (fnhint, istate);
-  if (mapping_over == 4 && dircomplete_expand)
-    set_directory_hook ();
-
-  istate = 1;
-
-  if (val == 0)
-    {
-      /* If the hint text is an absolute program, then don't bother
-	 searching through PATH. */
-      if (absolute_program (hint))
-	return ((char *)NULL);
-
-      goto outer;
-    }
-  else
-    {
-      int match, freetemp;
-
-      if (absolute_program (hint))
-	{
-#if 0
-	  if (igncase == 0)
-	    match = strncmp (val, hint, hint_len) == 0;
-	  else
-	    match = strncasecmp (val, hint, hint_len) == 0;
-#else
-	  /* Why duplicate the comparison rl_filename_completion_function
-	     already performs? */
-	  match = 1;
-#endif
-
-	  /* If we performed tilde expansion, restore the original
-	     filename. */
-	  if (*hint_text == '~')
-	    temp = maybe_restore_tilde (val, directory_part);
-	  else
-	    temp = savestring (val);
-	  freetemp = 1;
-	}
-      else
-	{
-	  temp = strrchr (val, '/');
-
-	  if (temp)
-	    {
-	      temp++;
-	      if (igncase == 0)
-		freetemp = match = strncmp (temp, hint, hint_len) == 0;
-	      else
-		freetemp = match = strncasecmp (temp, hint, hint_len) == 0;
-	      if (match)
-		temp = savestring (temp);
-	    }
-	  else
-	    freetemp = match = 0;
-	}
-
-      /* If we have found a match, and it is an executable file, return it.
-	 We don't return directory names when searching $PATH, since the
-	 bash execution code won't find executables in directories which
-	 appear in directories in $PATH when they're specified using
-	 relative pathnames.  */
-#if 0
-      /* If we're not searching $PATH and we have a relative pathname, we
-	 need to re-canonicalize it before testing whether or not it's an
-	 executable or a directory so the shell treats .. relative to $PWD
-	 according to the physical/logical option.  The shell already
-	 canonicalizes the directory name in order to tell readline where
-	 to look, so not doing it here will be inconsistent. */
-      /* XXX -- currently not used -- will introduce more inconsistency,
-	 since shell does not canonicalize ../foo before passing it to
-	 shell_execve().  */
-      if (match && searching_path == 0 && *val == '.')
-	{
-	  char *t, *t1;
-
-	  t = get_working_directory ("command-word-completion");
-	  t1 = make_absolute (val, t);
-	  free (t);
-	  cval = sh_canonpath (t1, PATH_CHECKDOTDOT|PATH_CHECKEXISTS);
-	}
-      else
-#endif
-	cval = val;
-
-      if (match && executable_completion ((searching_path ? val : cval), searching_path))
-	{
-	  if (cval != val)
-	    free (cval);
-	  free (val);
-	  val = "";		/* So it won't be NULL. */
-	  return (temp);
-	}
-      else
-	{
-	  if (freetemp)
-	    free (temp);
-	  if (cval != val)
-	    free (cval);
-	  free (val);
-	  goto inner;
-	}
-    }
-}
-
-/* Completion inside an unterminated command substitution. */
-static char *
-command_subst_completion_function (text, state)
-     const char *text;
-     int state;
-{
-  static char **matches = (char **)NULL;
-  static const char *orig_start;
-  static char *filename_text = (char *)NULL;
-  static int cmd_index, start_len;
-  char *value;
-
-  if (state == 0)
-    {
-      if (filename_text)
-	free (filename_text);
-      orig_start = text;
-      if (*text == '`')
-	text++;
-      else if (*text == '$' && text[1] == '(')	/* ) */
-	text += 2;
-      /* If the text was quoted, suppress any quote character that the
-	 readline completion code would insert. */
-      rl_completion_suppress_quote = 1;
-      start_len = text - orig_start;
-      filename_text = savestring (text);
-      if (matches)
-	free (matches);
-
-      /*
-       * At this point we can entertain the idea of re-parsing
-       * `filename_text' into a (possibly incomplete) command name and
-       * arguments, and doing completion based on that.  This is
-       * currently very rudimentary, but it is a small improvement.
-       */
-      for (value = filename_text + strlen (filename_text) - 1; value > filename_text; value--)
-        if (whitespace (*value) || member (*value, COMMAND_SEPARATORS))
-          break;
-      if (value <= filename_text)
-	matches = rl_completion_matches (filename_text, command_word_completion_function);
-      else
-	{
-	  value++;
-	  start_len += value - filename_text;
-	  if (whitespace (value[-1]))
-	    matches = rl_completion_matches (value, rl_filename_completion_function);
-	  else
-	    matches = rl_completion_matches (value, command_word_completion_function);
-	}
-
-      /* If there is more than one match, rl_completion_matches has already
-	 put the lcd in matches[0].  Skip over it. */
-      cmd_index = matches && matches[0] && matches[1];
-
-      /* If there's a single match and it's a directory, set the append char
-	 to the expected `/'.  Otherwise, don't append anything. */
-      if (matches && matches[0] && matches[1] == 0 && test_for_directory (matches[0]))
-	rl_completion_append_character = '/';
-      else
-	rl_completion_suppress_append = 1;
-    }
-
-  if (matches == 0 || matches[cmd_index] == 0)
-    {
-      rl_filename_quoting_desired = 0;	/* disable quoting */
-      return ((char *)NULL);
-    }
-  else
-    {
-      value = (char *)xmalloc (1 + start_len + strlen (matches[cmd_index]));
-
-      if (start_len == 1)
-	value[0] = *orig_start;
-      else
-	strncpy (value, orig_start, start_len);
-
-      strcpy (value + start_len, matches[cmd_index]);
-
-      cmd_index++;
-      return (value);
-    }
-}
-
-/* Okay, now we write the entry_function for variable completion. */
-static char *
-variable_completion_function (text, state)
-     const char *text;
-     int state;
-{
-  static char **varlist = (char **)NULL;
-  static int varlist_index;
-  static char *varname = (char *)NULL;
-  static int first_char, first_char_loc;
-
-  if (!state)
-    {
-      if (varname)
-	free (varname);
-
-      first_char_loc = 0;
-      first_char = text[0];
-
-      if (first_char == '$')
-	first_char_loc++;
-
-      if (text[first_char_loc] == '{')
-	first_char_loc++;
-
-      varname = savestring (text + first_char_loc);
-
-      if (varlist)
-	strvec_dispose (varlist);
-
-      varlist = all_variables_matching_prefix (varname);
-      varlist_index = 0;
-    }
-
-  if (!varlist || !varlist[varlist_index])
-    {
-      return ((char *)NULL);
-    }
-  else
-    {
-      char *value;
-
-      value = (char *)xmalloc (4 + strlen (varlist[varlist_index]));
-
-      if (first_char_loc)
-	{
-	  value[0] = first_char;
-	  if (first_char_loc == 2)
-	    value[1] = '{';
-	}
-
-      strcpy (value + first_char_loc, varlist[varlist_index]);
-      if (first_char_loc == 2)
-	strcat (value, "}");
-
-      varlist_index++;
-      return (value);
-    }
-}
-
-/* How about a completion function for hostnames? */
-static char *
-hostname_completion_function (text, state)
-     const char *text;
-     int state;
-{
-  static char **list = (char **)NULL;
-  static int list_index = 0;
-  static int first_char, first_char_loc;
-
-  /* If we don't have any state, make some. */
-  if (state == 0)
-    {
-      FREE (list);
-
-      list = (char **)NULL;
-
-      first_char_loc = 0;
-      first_char = *text;
-
-      if (first_char == '@')
-	first_char_loc++;
-
-      list = hostnames_matching ((char *)text+first_char_loc);
-      list_index = 0;
-    }
-
-  if (list && list[list_index])
-    {
-      char *t;
-
-      t = (char *)xmalloc (2 + strlen (list[list_index]));
-      *t = first_char;
-      strcpy (t + first_char_loc, list[list_index]);
-      list_index++;
-      return (t);
-    }
-
-  return ((char *)NULL);
-}
-
-/*
- * A completion function for service names from /etc/services (or wherever).
- */
-char *
-bash_servicename_completion_function (text, state)
-     const char *text;
-     int state;
-{
-#if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GETSERVENT)
-  return ((char *)NULL);
-#else
-  static char *sname = (char *)NULL;
-  static struct servent *srvent;
-  static int snamelen;
-  char *value;
-  char **alist, *aentry;
-  int afound;
-
-  if (state == 0)
-    {
-      FREE (sname);
-
-      sname = savestring (text);
-      snamelen = strlen (sname);
-      setservent (0);
-    }
-
-  while (srvent = getservent ())
-    {
-      afound = 0;
-      if (snamelen == 0 || (STREQN (sname, srvent->s_name, snamelen)))
-	break;
-      /* Not primary, check aliases */
-      for (alist = srvent->s_aliases; *alist; alist++)
-	{
-	  aentry = *alist;
-	  if (STREQN (sname, aentry, snamelen))
-	    {
-	      afound = 1;
-	      break;
-	    }
-	}
-
-      if (afound)
-	break;
-    }
-
-  if (srvent == 0)
-    {
-      endservent ();
-      return ((char *)NULL);
-    }
-
-  value = afound ? savestring (aentry) : savestring (srvent->s_name);
-  return value;
-#endif
-}
-
-/*
- * A completion function for group names from /etc/group (or wherever).
- */
-char *
-bash_groupname_completion_function (text, state)
-     const char *text;
-     int state;
-{
-#if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GRP_H)
-  return ((char *)NULL);
-#else
-  static char *gname = (char *)NULL;
-  static struct group *grent;
-  static int gnamelen;
-  char *value;
-
-  if (state == 0)
-    {
-      FREE (gname);
-      gname = savestring (text);
-      gnamelen = strlen (gname);
-
-      setgrent ();
-    }
-
-  while (grent = getgrent ())
-    {
-      if (gnamelen == 0 || (STREQN (gname, grent->gr_name, gnamelen)))
-        break;
-    }
-
-  if (grent == 0)
-    {
-      endgrent ();
-      return ((char *)NULL);
-    }
-
-  value = savestring (grent->gr_name);
-  return (value);
-#endif
-}
-
-/* Functions to perform history and alias expansions on the current line. */
-
-#if defined (BANG_HISTORY)
-/* Perform history expansion on the current line.  If no history expansion
-   is done, pre_process_line() returns what it was passed, so we need to
-   allocate a new line here. */
-static char *
-history_expand_line_internal (line)
-     char *line;
-{
-  char *new_line;
-  int old_verify;
-
-  old_verify = hist_verify;
-  hist_verify = 0;
-  new_line = pre_process_line (line, 0, 0);
-  hist_verify = old_verify;
-
-  return (new_line == line) ? savestring (line) : new_line;
-}
-#endif
-
-/* There was an error in expansion.  Let the preprocessor print
-   the error here. */
-static void
-cleanup_expansion_error ()
-{
-  char *to_free;
-#if defined (BANG_HISTORY)
-  int old_verify;
-
-  old_verify = hist_verify;
-  hist_verify = 0;
-#endif
-
-  fprintf (rl_outstream, "\r\n");
-  to_free = pre_process_line (rl_line_buffer, 1, 0);
-#if defined (BANG_HISTORY)
-  hist_verify = old_verify;
-#endif
-  if (to_free != rl_line_buffer)
-    FREE (to_free);
-  putc ('\r', rl_outstream);
-  rl_forced_update_display ();
-}
-
-/* If NEW_LINE differs from what is in the readline line buffer, add an
-   undo record to get from the readline line buffer contents to the new
-   line and make NEW_LINE the current readline line. */
-static void
-maybe_make_readline_line (new_line)
-     char *new_line;
-{
-  if (new_line && strcmp (new_line, rl_line_buffer) != 0)
-    {
-      rl_point = rl_end;
-
-      rl_add_undo (UNDO_BEGIN, 0, 0, 0);
-      rl_delete_text (0, rl_point);
-      rl_point = rl_end = rl_mark = 0;
-      rl_insert_text (new_line);
-      rl_add_undo (UNDO_END, 0, 0, 0);
-    }
-}
-
-/* Make NEW_LINE be the current readline line.  This frees NEW_LINE. */
-static void
-set_up_new_line (new_line)
-     char *new_line;
-{
-  int old_point, at_end;
-
-  old_point = rl_point;
-  at_end = rl_point == rl_end;
-
-  /* If the line was history and alias expanded, then make that
-     be one thing to undo. */
-  maybe_make_readline_line (new_line);
-  free (new_line);
-
-  /* Place rl_point where we think it should go. */
-  if (at_end)
-    rl_point = rl_end;
-  else if (old_point < rl_end)
-    {
-      rl_point = old_point;
-      if (!whitespace (rl_line_buffer[rl_point]))
-	rl_forward_word (1, 0);
-    }
-}
-
-#if defined (ALIAS)
-/* Expand aliases in the current readline line. */
-static int
-alias_expand_line (count, ignore)
-     int count, ignore;
-{
-  char *new_line;
-
-  new_line = alias_expand (rl_line_buffer);
-
-  if (new_line)
-    {
-      set_up_new_line (new_line);
-      return (0);
-    }
-  else
-    {
-      cleanup_expansion_error ();
-      return (1);
-    }
-}
-#endif
-
-#if defined (BANG_HISTORY)
-/* History expand the line. */
-static int
-history_expand_line (count, ignore)
-     int count, ignore;
-{
-  char *new_line;
-
-  new_line = history_expand_line_internal (rl_line_buffer);
-
-  if (new_line)
-    {
-      set_up_new_line (new_line);
-      return (0);
-    }
-  else
-    {
-      cleanup_expansion_error ();
-      return (1);
-    }
-}
-
-/* Expand history substitutions in the current line and then insert a
-   space (hopefully close to where we were before). */
-static int
-tcsh_magic_space (count, ignore)
-     int count, ignore;
-{
-  int dist_from_end, old_point;
-
-  old_point = rl_point;
-  dist_from_end = rl_end - rl_point;
-  if (history_expand_line (count, ignore) == 0)
-    {
-      /* Try a simple heuristic from Stephen Gildea <gildea@intouchsys.com>.
-	 This works if all expansions were before rl_point or if no expansions
-	 were performed. */
-      rl_point = (old_point == 0) ? old_point : rl_end - dist_from_end;
-      rl_insert (1, ' ');
-      return (0);
-    }
-  else
-    return (1);
-}
-#endif /* BANG_HISTORY */
-
-/* History and alias expand the line. */
-static int
-history_and_alias_expand_line (count, ignore)
-     int count, ignore;
-{
-  char *new_line, *t;
-
-  new_line = 0;
-#if defined (BANG_HISTORY)
-  new_line = history_expand_line_internal (rl_line_buffer);
-#endif
-
-#if defined (ALIAS)
-  if (new_line)
-    {
-      char *alias_line;
-
-      alias_line = alias_expand (new_line);
-      free (new_line);
-      new_line = alias_line;
-    }
-#endif /* ALIAS */
-
-  if (new_line)
-    {
-      set_up_new_line (new_line);
-      return (0);
-    }
-  else
-    {
-      cleanup_expansion_error ();
-      return (1);
-    }
-}
-
-/* History and alias expand the line, then perform the shell word
-   expansions by calling expand_string.  This can't use set_up_new_line()
-   because we want the variable expansions as a separate undo'able
-   set of operations. */
-static int
-shell_expand_line (count, ignore)
-     int count, ignore;
-{
-  char *new_line, *t;
-  WORD_LIST *expanded_string;
-  WORD_DESC *w;
-
-  new_line = 0;
-#if defined (BANG_HISTORY)
-  new_line = history_expand_line_internal (rl_line_buffer);
-#endif
-
-  t = expand_string_dollar_quote (new_line ? new_line : rl_line_buffer, 0);
-  FREE (new_line);
-  new_line = t;
-
-#if defined (ALIAS)
-  if (new_line)
-    {
-      char *alias_line;
-
-      alias_line = alias_expand (new_line);
-      free (new_line);
-      new_line = alias_line;
-    }
-#endif /* ALIAS */
-
-  if (new_line)
-    {
-      int old_point = rl_point;
-      int at_end = rl_point == rl_end;
-
-      /* If the line was history and alias expanded, then make that
-	 be one thing to undo. */
-      maybe_make_readline_line (new_line);
-      free (new_line);
-
-      /* If there is variable expansion to perform, do that as a separate
-	 operation to be undone. */
-
-#if 1
-      w = alloc_word_desc ();
-      w->word = savestring (rl_line_buffer);
-      w->flags = rl_explicit_arg ? (W_NOPROCSUB|W_NOCOMSUB) : 0;
-      expanded_string = expand_word (w, rl_explicit_arg ? Q_HERE_DOCUMENT : 0);
-      dispose_word (w);
-#else
-      new_line = savestring (rl_line_buffer);
-      expanded_string = expand_string (new_line, 0);
-      FREE (new_line);
-#endif
-
-      if (expanded_string == 0)
-	{
-	  new_line = (char *)xmalloc (1);
-	  new_line[0] = '\0';
-	}
-      else
-	{
-	  new_line = string_list (expanded_string);
-	  dispose_words (expanded_string);
-	}
-
-      maybe_make_readline_line (new_line);
-      free (new_line);
-
-      /* Place rl_point where we think it should go. */
-      if (at_end)
-	rl_point = rl_end;
-      else if (old_point < rl_end)
-	{
-	  rl_point = old_point;
-	  if (!whitespace (rl_line_buffer[rl_point]))
-	    rl_forward_word (1, 0);
-	}
-      return 0;
-    }
-  else
-    {
-      cleanup_expansion_error ();
-      return 1;
-    }
-}
-
-/* If FIGNORE is set, then don't match files with the given suffixes when
-   completing filenames.  If only one of the possibilities has an acceptable
-   suffix, delete the others, else just return and let the completer
-   signal an error.  It is called by the completer when real
-   completions are done on filenames by the completer's internal
-   function, not for completion lists (M-?) and not on "other"
-   completion types, such as hostnames or commands. */
-
-static struct ignorevar fignore =
-{
-  "FIGNORE",
-  (struct ign *)0,
-  0,
-  (char *)0,
-  (sh_iv_item_func_t *) 0,
-};
-
-static void
-_ignore_completion_names (names, name_func)
-     char **names;
-     sh_ignore_func_t *name_func;
-{
-  char **newnames;
-  int idx, nidx;
-  char **oldnames;
-  int oidx;
-
-  /* If there is only one completion, see if it is acceptable.  If it is
-     not, free it up.  In any case, short-circuit and return.  This is a
-     special case because names[0] is not the prefix of the list of names
-     if there is only one completion; it is the completion itself. */
-  if (names[1] == (char *)0)
-    {
-      if (force_fignore)
-	if ((*name_func) (names[0]) == 0)
-	  {
-	    free (names[0]);
-	    names[0] = (char *)NULL;
-	  }
-
-      return;
-    }
-
-  /* Allocate space for array to hold list of pointers to matching
-     filenames.  The pointers are copied back to NAMES when done. */
-  for (nidx = 1; names[nidx]; nidx++)
-    ;
-  newnames = strvec_create (nidx + 1);
-
-  if (force_fignore == 0)
-    {
-      oldnames = strvec_create (nidx - 1);
-      oidx = 0;
-    }
-
-  newnames[0] = names[0];
-  for (idx = nidx = 1; names[idx]; idx++)
-    {
-      if ((*name_func) (names[idx]))
-	newnames[nidx++] = names[idx];
-      else if (force_fignore == 0)
-	oldnames[oidx++] = names[idx];
-      else
-	free (names[idx]);
-    }
-
-  newnames[nidx] = (char *)NULL;
-
-  /* If none are acceptable then let the completer handle it. */
-  if (nidx == 1)
-    {
-      if (force_fignore)
-	{
-	  free (names[0]);
-	  names[0] = (char *)NULL;
-	}
-      else
-	free (oldnames);
-
-      free (newnames);
-      return;
-    }
-
-  if (force_fignore == 0)
-    {
-      while (oidx)
-	free (oldnames[--oidx]);
-      free (oldnames);
-    }
-
-  /* If only one is acceptable, copy it to names[0] and return. */
-  if (nidx == 2)
-    {
-      free (names[0]);
-      names[0] = newnames[1];
-      names[1] = (char *)NULL;
-      free (newnames);
-      return;
-    }
-
-  /* Copy the acceptable names back to NAMES, set the new array end,
-     and return. */
-  for (nidx = 1; newnames[nidx]; nidx++)
-    names[nidx] = newnames[nidx];
-  names[nidx] = (char *)NULL;
-  free (newnames);
-}
-
-static int
-name_is_acceptable (name)
-     const char *name;
-{
-  struct ign *p;
-  int nlen;
-
-  for (nlen = strlen (name), p = fignore.ignores; p->val; p++)
-    {
-      if (nlen > p->len && p->len > 0 && STREQ (p->val, &name[nlen - p->len]))
-	return (0);
-    }
-
-  return (1);
-}
-
-#if 0
-static int
-ignore_dot_names (name)
-     char *name;
-{
-  return (name[0] != '.');
-}
-#endif
-
-static int
-filename_completion_ignore (names)
-     char **names;
-{
-#if 0
-  if (glob_dot_filenames == 0)
-    _ignore_completion_names (names, ignore_dot_names);
-#endif
-
-  setup_ignore_patterns (&fignore);
-
-  if (fignore.num_ignores == 0)
-    return 0;
-
-  _ignore_completion_names (names, name_is_acceptable);
-
-  return 0;
-}
-
-/* Return 1 if NAME is a directory.  NAME undergoes tilde expansion. */
-static int
-test_for_directory (name)
-     const char *name;
-{
-  char *fn;
-  int r;
-
-  fn = bash_tilde_expand (name, 0);
-  r = file_isdir (fn);
-  free (fn);
-
-  return (r);
-}
-
-static int
-test_for_canon_directory (name)
-     const char *name;
-{
-  char *fn;
-  int r;
-
-  fn = (*name == '~') ? bash_tilde_expand (name, 0) : savestring (name);
-  bash_filename_stat_hook (&fn);
-  r = file_isdir (fn);
-  free (fn);
-
-  return (r);
-}
-
-/* Remove files from NAMES, leaving directories. */
-static int
-bash_ignore_filenames (names)
-     char **names;
-{
-  _ignore_completion_names (names, test_for_directory);
-  return 0;
-}
-
-static int
-bash_progcomp_ignore_filenames (names)
-     char **names;
-{
-  _ignore_completion_names (names, test_for_canon_directory);
-  return 0;
-}
-
-static int
-return_zero (name)
-     const char *name;
-{
-  return 0;
-}
-
-static int
-bash_ignore_everything (names)
-     char **names;
-{
-  _ignore_completion_names (names, return_zero);
-  return 0;
-}
-
-/* Replace a tilde-prefix in VAL with a `~', assuming the user typed it.  VAL
-   is an expanded filename.  DIRECTORY_PART is the tilde-prefix portion
-   of the un-tilde-expanded version of VAL (what the user typed). */
-static char *
-restore_tilde (val, directory_part)
-     char *val, *directory_part;
-{
-  int l, vl, dl2, xl;
-  char *dh2, *expdir, *ret, *v;
-
-  vl = strlen (val);
-
-  /* We need to duplicate the expansions readline performs on the directory
-     portion before passing it to our completion function. */
-  dh2 = directory_part ? bash_dequote_filename (directory_part, 0) : 0;
-  bash_directory_expansion (&dh2);
-  dl2 = strlen (dh2);
-
-  expdir = bash_tilde_expand (directory_part, 0);
-  xl = strlen (expdir);
-  if (*directory_part == '~' && STREQ (directory_part, expdir))
-    {
-      /* tilde expansion failed, so what should we return? we use what the
-	 user typed. */
-      v = mbschr (val, '/');
-      vl = STRLEN (v);
-      ret = (char *)xmalloc (xl + vl + 2);
-      strcpy (ret, directory_part);
-      if (v && *v)
-	strcpy (ret + xl, v);
-
-      free (dh2);
-      free (expdir);
-
-      return ret;
-    }
-  free (expdir);
-
-  /*
-     dh2 = unexpanded but dequoted tilde-prefix
-     dl2 = length of tilde-prefix
-     expdir = tilde-expanded tilde-prefix
-     xl = length of expanded tilde-prefix
-     l = length of remainder after tilde-prefix
-  */
-  l = (vl - xl) + 1;
-  if (l <= 0)
-    {
-      free (dh2);
-      return (savestring (val));		/* XXX - just punt */
-    }
-
-  ret = (char *)xmalloc (dl2 + 2 + l);
-  strcpy (ret, dh2);
-  strcpy (ret + dl2, val + xl);
-
-  free (dh2);
-  return (ret);
-}
-
-static char *
-maybe_restore_tilde (val, directory_part)
-     char *val, *directory_part;
-{
-  rl_icppfunc_t *save;
-  char *ret;
-
-  save = (dircomplete_expand == 0) ? save_directory_hook () : (rl_icppfunc_t *)0;
-  ret = restore_tilde (val, directory_part);
-  if (save)
-    restore_directory_hook (save);
-  return ret;
-}
-
-/* Simulate the expansions that will be performed by
-   rl_filename_completion_function.  This must be called with the address of
-   a pointer to malloc'd memory. */
-static void
-bash_directory_expansion (dirname)
-     char **dirname;
-{
-  char *d, *nd;
-
-  d = savestring (*dirname);
-
-  if ((rl_directory_rewrite_hook) && (*rl_directory_rewrite_hook) (&d))
-    {
-      free (*dirname);
-      *dirname = d;
-    }
-  else if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&d))
-    {
-      free (*dirname);
-      *dirname = d;
-    }
-  else if (rl_completion_found_quote)
-    {
-      nd = bash_dequote_filename (d, rl_completion_quote_character);
-      free (*dirname);
-      free (d);
-      *dirname = nd;
-    }
-  else
-    free (d);
-}
-
-/* If necessary, rewrite directory entry */
-static char *
-bash_filename_rewrite_hook (fname, fnlen)
-     char *fname;
-     int fnlen;
-{
-  char *conv;
-
-  conv = fnx_fromfs (fname, fnlen);
-  if (conv != fname)
-    conv = savestring (conv);
-  return conv;
-}
-
-/* Functions to save and restore the appropriate directory hook */
-/* This is not static so the shopt code can call it */
-void
-set_directory_hook ()
-{
-  if (dircomplete_expand)
-    {
-      rl_directory_completion_hook = bash_directory_completion_hook;
-      rl_directory_rewrite_hook = (rl_icppfunc_t *)0;
-    }
-  else
-    {
-      rl_directory_rewrite_hook = bash_directory_completion_hook;
-      rl_directory_completion_hook = (rl_icppfunc_t *)0;
-    }
-}
-
-static rl_icppfunc_t *
-save_directory_hook ()
-{
-  rl_icppfunc_t *ret;
-
-  if (dircomplete_expand)
-    {
-      ret = rl_directory_completion_hook;
-      rl_directory_completion_hook = (rl_icppfunc_t *)NULL;
-    }
-  else
-    {
-      ret = rl_directory_rewrite_hook;
-      rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL;
-    }
-
-  return ret;
-}
-
-static void
-restore_directory_hook (hookf)
-     rl_icppfunc_t *hookf;
-{
-  if (dircomplete_expand)
-    rl_directory_completion_hook = hookf;
-  else
-    rl_directory_rewrite_hook = hookf;
-}
-
-/* Check whether not DIRNAME, with any trailing slash removed, exists.  If
-   SHOULD_DEQUOTE is non-zero, we dequote the directory name first. */
-static int
-directory_exists (dirname, should_dequote)
-     const char *dirname;
-     int should_dequote;
-{
-  char *new_dirname;
-  int dirlen, r;
-  struct stat sb;
-
-  /* We save the string and chop the trailing slash because stat/lstat behave
-     inconsistently if one is present. */
-  new_dirname = should_dequote ? bash_dequote_filename ((char *)dirname, rl_completion_quote_character) : savestring (dirname);
-  dirlen = STRLEN (new_dirname);
-  if (new_dirname[dirlen - 1] == '/')
-    new_dirname[dirlen - 1] = '\0';
-#if defined (HAVE_LSTAT)
-  r = lstat (new_dirname, &sb) == 0;
-#else
-  r = stat (new_dirname, &sb) == 0;
-#endif
-  free (new_dirname);
-  return (r);
-}
-  
-/* Expand a filename before the readline completion code passes it to stat(2).
-   The filename will already have had tilde expansion performed. */
-static int
-bash_filename_stat_hook (dirname)
-     char **dirname;
-{
-  char *local_dirname, *new_dirname, *t;
-  int should_expand_dirname, return_value;
-  int global_nounset;
-  WORD_LIST *wl;
-
-  local_dirname = *dirname;
-  should_expand_dirname = return_value = 0;
-  if (t = mbschr (local_dirname, '$'))
-    should_expand_dirname = '$';
-  else if (t = mbschr (local_dirname, '`'))	/* XXX */
-    should_expand_dirname = '`';
-
-  if (should_expand_dirname && directory_exists (local_dirname, 0))
-    should_expand_dirname = 0;
-  
-  if (should_expand_dirname)  
-    {
-      new_dirname = savestring (local_dirname);
-      /* no error messages, and expand_prompt_string doesn't longjmp so we don't
-	 have to worry about restoring this setting. */
-      global_nounset = unbound_vars_is_error;
-      unbound_vars_is_error = 0;
-      wl = expand_prompt_string (new_dirname, 0, W_NOCOMSUB|W_NOPROCSUB|W_COMPLETE);	/* does the right thing */
-      unbound_vars_is_error = global_nounset;
-      if (wl)
-	{
-	  free (new_dirname);
-	  new_dirname = string_list (wl);
-	  /* Tell the completer we actually expanded something and change
-	     *dirname only if we expanded to something non-null -- stat
-	     behaves unpredictably when passed null or empty strings */
-	  if (new_dirname && *new_dirname)
-	    {
-	      free (local_dirname);	/* XXX */
-	      local_dirname = *dirname = new_dirname;
-	      return_value = STREQ (local_dirname, *dirname) == 0;
-	    }
-	  else
-	    free (new_dirname);
-	  dispose_words (wl);
-	}
-      else
-	free (new_dirname);
-    }	
-
-  /* This is very similar to the code in bash_directory_completion_hook below,
-     but without spelling correction and not worrying about whether or not
-     we change relative pathnames. */
-  if (no_symbolic_links == 0 && (local_dirname[0] != '.' || local_dirname[1]))
-    {
-      char *temp1, *temp2;
-
-      t = get_working_directory ("symlink-hook");
-      temp1 = make_absolute (local_dirname, t);
-      free (t);
-      temp2 = sh_canonpath (temp1, PATH_CHECKDOTDOT|PATH_CHECKEXISTS);
-
-      /* If we can't canonicalize, bail. */
-      if (temp2 == 0)
-	{
-	  free (temp1);
-	  return return_value;
-	}
-
-      free (local_dirname);
-      *dirname = temp2;
-      free (temp1);
-    }
-
-  return (return_value);
-}
-
-/* Handle symbolic link references and other directory name
-   expansions while hacking completion.  This should return 1 if it modifies
-   the DIRNAME argument, 0 otherwise.  It should make sure not to modify
-   DIRNAME if it returns 0. */
-static int
-bash_directory_completion_hook (dirname)
-     char **dirname;
-{
-  char *local_dirname, *new_dirname, *t;
-  int return_value, should_expand_dirname, nextch, closer;
-  WORD_LIST *wl;
-
-  return_value = should_expand_dirname = nextch = closer = 0;
-  local_dirname = *dirname;
-
-  should_expand_dirname = bash_check_expchar (local_dirname, 1, &nextch, &closer);
-
-  if (should_expand_dirname && directory_exists (local_dirname, 1))
-    should_expand_dirname = 0;
-
-  if (should_expand_dirname)  
-    {
-      new_dirname = savestring (local_dirname);
-      wl = expand_prompt_string (new_dirname, 0, W_NOCOMSUB|W_NOPROCSUB|W_COMPLETE);	/* does the right thing */
-      if (wl)
-	{
-	  *dirname = string_list (wl);
-	  /* Tell the completer to replace the directory name only if we
-	     actually expanded something. */
-	  return_value = STREQ (local_dirname, *dirname) == 0;
-	  free (local_dirname);
-	  free (new_dirname);
-	  dispose_words (wl);
-	  local_dirname = *dirname;
-
-	  set_filename_quote_chars (should_expand_dirname, nextch, closer);
-	}
-      else
-	{
-	  free (new_dirname);
-	  free (local_dirname);
-	  *dirname = (char *)xmalloc (1);
-	  **dirname = '\0';
-	  return 1;
-	}
-    }
-  else 
-    {
-      /* Dequote the filename even if we don't expand it. */
-      new_dirname = bash_dequote_filename (local_dirname, rl_completion_quote_character);
-      return_value = STREQ (local_dirname, new_dirname) == 0;
-      free (local_dirname);
-      local_dirname = *dirname = new_dirname;
-    }
-
-  /* no_symbolic_links == 0 -> use (default) logical view of the file system.
-     local_dirname[0] == '.' && local_dirname[1] == '/' means files in the
-     current directory (./).
-     local_dirname[0] == '.' && local_dirname[1] == 0 means relative pathnames
-     in the current directory (e.g., lib/sh).
-     XXX - should we do spelling correction on these? */
-
-  /* This is test as it was in bash-4.2: skip relative pathnames in current
-     directory.  Change test to
-      (local_dirname[0] != '.' || (local_dirname[1] && local_dirname[1] != '/'))
-     if we want to skip paths beginning with ./ also. */
-  if (no_symbolic_links == 0 && (local_dirname[0] != '.' || local_dirname[1]))
-    {
-      char *temp1, *temp2;
-      int len1, len2;
-
-      /* If we have a relative path
-      		(local_dirname[0] != '/' && local_dirname[0] != '.')
-	 that is canonical after appending it to the current directory, then
-	 	temp1 = temp2+'/'
-	 That is,
-	 	strcmp (temp1, temp2) == 0
-	 after adding a slash to temp2 below.  It should be safe to not
-	 change those.
-      */
-      t = get_working_directory ("symlink-hook");
-      temp1 = make_absolute (local_dirname, t);
-      free (t);
-      temp2 = sh_canonpath (temp1, PATH_CHECKDOTDOT|PATH_CHECKEXISTS);
-
-      /* Try spelling correction if initial canonicalization fails.  Make
-	 sure we are set to replace the directory name with the results so
-	 subsequent directory checks don't fail. */
-      if (temp2 == 0 && dircomplete_spelling && dircomplete_expand)
-	{
-	  size_t l1, l2;
-
-	  temp2 = dirspell (temp1);
-	  l2 = STRLEN (temp2);
-	  /* Don't take matches if they are shorter than the original path */
-	  if (temp2 && l2 < strlen (temp1) && STREQN (temp1, temp2, l2))
-	    {
-	      free (temp2);
-	      temp2 = 0;
-	    }
-	  if (temp2)
-	    {
-	      free (temp1);
-	      temp1 = temp2;
-	      temp2 = sh_canonpath (temp1, PATH_CHECKDOTDOT|PATH_CHECKEXISTS);
-	      return_value |= temp2 != 0;
-	    }
-	}
-      /* If we can't canonicalize, bail. */
-      if (temp2 == 0)
-	{
-	  free (temp1);
-	  return return_value;
-	}
-      len1 = strlen (temp1);
-      if (temp1[len1 - 1] == '/')
-	{
-	  len2 = strlen (temp2);
-	  if (len2 > 2)		/* don't append `/' to `/' or `//' */
-	    {
-	      temp2 = (char *)xrealloc (temp2, len2 + 2);
-	      temp2[len2] = '/';
-	      temp2[len2 + 1] = '\0';
-	    }
-	}
-
-      /* dircomplete_expand_relpath == 0 means we want to leave relative
-	 pathnames that are unchanged by canonicalization alone.
-	 *local_dirname != '/' && *local_dirname != '.' == relative pathname
-	 (consistent with general.c:absolute_pathname())
-	 temp1 == temp2 (after appending a slash to temp2) means the pathname
-	 is not changed by canonicalization as described above. */
-      if (dircomplete_expand_relpath || ((local_dirname[0] != '/' && local_dirname[0] != '.') && STREQ (temp1, temp2) == 0))
-	return_value |= STREQ (local_dirname, temp2) == 0;
-      free (local_dirname);
-      *dirname = temp2;
-      free (temp1);
-    }
-
-  return (return_value);
-}
-
-static char **history_completion_array = (char **)NULL;
-static int harry_size;
-static int harry_len;
-
-static void
-build_history_completion_array ()
-{
-  register int i, j;
-  HIST_ENTRY **hlist;
-  char **tokens;
-
-  /* First, clear out the current dynamic history completion list. */
-  if (harry_size)
-    {
-      strvec_dispose (history_completion_array);
-      history_completion_array = (char **)NULL;
-      harry_size = 0;
-      harry_len = 0;
-    }
-
-  /* Next, grovel each line of history, making each shell-sized token
-     a separate entry in the history_completion_array. */
-  hlist = history_list ();
-
-  if (hlist)
-    {
-      for (i = 0; hlist[i]; i++)
-	;
-      for ( --i; i >= 0; i--)
-	{
-	  /* Separate each token, and place into an array. */
-	  tokens = history_tokenize (hlist[i]->line);
-
-	  for (j = 0; tokens && tokens[j]; j++)
-	    {
-	      if (harry_len + 2 > harry_size)
-	        history_completion_array = strvec_resize (history_completion_array, harry_size += 10);
-
-	      history_completion_array[harry_len++] = tokens[j];
-	      history_completion_array[harry_len] = (char *)NULL;
-	    }
-	  free (tokens);
-	}
-
-      /* Sort the complete list of tokens. */
-      if (dabbrev_expand_active == 0)
-        qsort (history_completion_array, harry_len, sizeof (char *), (QSFUNC *)strvec_strcmp);
-    }
-}
-
-static char *
-history_completion_generator (hint_text, state)
-     const char *hint_text;
-     int state;
-{
-  static int local_index, len;
-  static const char *text;
-
-  /* If this is the first call to the generator, then initialize the
-     list of strings to complete over. */
-  if (state == 0)
-    {
-      if (dabbrev_expand_active)	/* This is kind of messy */
-	rl_completion_suppress_append = 1;
-      local_index = 0;
-      build_history_completion_array ();
-      text = hint_text;
-      len = strlen (text);
-    }
-
-  while (history_completion_array && history_completion_array[local_index])
-    {
-      /* XXX - should this use completion-ignore-case? */
-      if (strncmp (text, history_completion_array[local_index++], len) == 0)
-	return (savestring (history_completion_array[local_index - 1]));
-    }
-  return ((char *)NULL);
-}
-
-static int
-dynamic_complete_history (count, key)
-     int count, key;
-{
-  int r;
-  rl_compentry_func_t *orig_func;
-  rl_completion_func_t *orig_attempt_func;
-  rl_compignore_func_t *orig_ignore_func;
-
-  orig_func = rl_completion_entry_function;
-  orig_attempt_func = rl_attempted_completion_function;
-  orig_ignore_func = rl_ignore_some_completions_function;
-
-  rl_completion_entry_function = history_completion_generator;
-  rl_attempted_completion_function = (rl_completion_func_t *)NULL;
-  rl_ignore_some_completions_function = filename_completion_ignore;
-
-  /* XXX - use rl_completion_mode here? */
-  if (rl_last_func == dynamic_complete_history)
-    r = rl_complete_internal ('?');
-  else
-    r = rl_complete_internal (TAB);
-
-  rl_completion_entry_function = orig_func;
-  rl_attempted_completion_function = orig_attempt_func;
-  rl_ignore_some_completions_function = orig_ignore_func;
-
-  return r;
-}
-
-static int
-bash_dabbrev_expand (count, key)
-     int count, key;
-{
-  int r, orig_suppress, orig_sort;
-  rl_compentry_func_t *orig_func;
-  rl_completion_func_t *orig_attempt_func;
-  rl_compignore_func_t *orig_ignore_func;
-
-  orig_func = rl_menu_completion_entry_function;
-  orig_attempt_func = rl_attempted_completion_function;
-  orig_ignore_func = rl_ignore_some_completions_function;
-  orig_suppress = rl_completion_suppress_append;
-  orig_sort = rl_sort_completion_matches;
-
-  rl_menu_completion_entry_function = history_completion_generator;
-  rl_attempted_completion_function = (rl_completion_func_t *)NULL;
-  rl_ignore_some_completions_function = filename_completion_ignore;
-  rl_filename_completion_desired = 0;
-  rl_completion_suppress_append = 1;
-  rl_sort_completion_matches = 0;
-
-  /* XXX - use rl_completion_mode here? */
-  dabbrev_expand_active = 1;
-  if (rl_last_func == bash_dabbrev_expand)
-    rl_last_func = rl_menu_complete;
-  r = rl_menu_complete (count, key);
-  dabbrev_expand_active = 0;
-
-  rl_last_func = bash_dabbrev_expand;
-  rl_menu_completion_entry_function = orig_func;
-  rl_attempted_completion_function = orig_attempt_func;
-  rl_ignore_some_completions_function = orig_ignore_func;
-  rl_completion_suppress_append = orig_suppress;
-  rl_sort_completion_matches = orig_sort;
-
-  return r;
-}
-
-#if defined (SPECIFIC_COMPLETION_FUNCTIONS)
-static int
-bash_complete_username (ignore, ignore2)
-     int ignore, ignore2;
-{
-  return bash_complete_username_internal (rl_completion_mode (bash_complete_username));
-}
-
-static int
-bash_possible_username_completions (ignore, ignore2)
-     int ignore, ignore2;
-{
-  return bash_complete_username_internal ('?');
-}
-
-static int
-bash_complete_username_internal (what_to_do)
-     int what_to_do;
-{
-  return bash_specific_completion (what_to_do, rl_username_completion_function);
-}
-
-static int
-bash_complete_filename (ignore, ignore2)
-     int ignore, ignore2;
-{
-  return bash_complete_filename_internal (rl_completion_mode (bash_complete_filename));
-}
-
-static int
-bash_possible_filename_completions (ignore, ignore2)
-     int ignore, ignore2;
-{
-  return bash_complete_filename_internal ('?');
-}
-
-static int
-bash_complete_filename_internal (what_to_do)
-     int what_to_do;
-{
-  rl_compentry_func_t *orig_func;
-  rl_completion_func_t *orig_attempt_func;
-  rl_icppfunc_t *orig_dir_func;
-  rl_compignore_func_t *orig_ignore_func;
-  const char *orig_rl_completer_word_break_characters;
-  int r;
-
-  orig_func = rl_completion_entry_function;
-  orig_attempt_func = rl_attempted_completion_function;
-  orig_ignore_func = rl_ignore_some_completions_function;
-  orig_rl_completer_word_break_characters = rl_completer_word_break_characters;
-
-  orig_dir_func = save_directory_hook ();
-
-  rl_completion_entry_function = rl_filename_completion_function;
-  rl_attempted_completion_function = (rl_completion_func_t *)NULL;
-  rl_ignore_some_completions_function = filename_completion_ignore;
-  rl_completer_word_break_characters = " \t\n\"\'";
-
-  r = rl_complete_internal (what_to_do);
-
-  rl_completion_entry_function = orig_func;
-  rl_attempted_completion_function = orig_attempt_func;
-  rl_ignore_some_completions_function = orig_ignore_func;
-  rl_completer_word_break_characters = orig_rl_completer_word_break_characters;
-
-  restore_directory_hook (orig_dir_func);
-
-  return r;
-}
-
-static int
-bash_complete_hostname (ignore, ignore2)
-     int ignore, ignore2;
-{
-  return bash_complete_hostname_internal (rl_completion_mode (bash_complete_hostname));
-}
-
-static int
-bash_possible_hostname_completions (ignore, ignore2)
-     int ignore, ignore2;
-{
-  return bash_complete_hostname_internal ('?');
-}
-
-static int
-bash_complete_variable (ignore, ignore2)
-     int ignore, ignore2;
-{
-  return bash_complete_variable_internal (rl_completion_mode (bash_complete_variable));
-}
-
-static int
-bash_possible_variable_completions (ignore, ignore2)
-     int ignore, ignore2;
-{
-  return bash_complete_variable_internal ('?');
-}
-
-static int
-bash_complete_command (ignore, ignore2)
-     int ignore, ignore2;
-{
-  return bash_complete_command_internal (rl_completion_mode (bash_complete_command));
-}
-
-static int
-bash_possible_command_completions (ignore, ignore2)
-     int ignore, ignore2;
-{
-  return bash_complete_command_internal ('?');
-}
-
-static int
-bash_complete_hostname_internal (what_to_do)
-     int what_to_do;
-{
-  return bash_specific_completion (what_to_do, hostname_completion_function);
-}
-
-static int
-bash_complete_variable_internal (what_to_do)
-     int what_to_do;
-{
-  return bash_specific_completion (what_to_do, variable_completion_function);
-}
-
-static int
-bash_complete_command_internal (what_to_do)
-     int what_to_do;
-{
-  return bash_specific_completion (what_to_do, command_word_completion_function);
-}
-
-static int
-completion_glob_pattern (string)
-     char *string;
-{
-  return (glob_pattern_p (string) == 1);
-}
-
-static char *globtext;
-static char *globorig;
-
-static char *
-glob_complete_word (text, state)
-     const char *text;
-     int state;
-{
-  static char **matches = (char **)NULL;
-  static int ind;
-  int glen;
-  char *ret, *ttext;
-
-  if (state == 0)
-    {
-      rl_filename_completion_desired = 1;
-      FREE (matches);
-      if (globorig != globtext)
-	FREE (globorig);
-      FREE (globtext);
-
-      ttext = bash_tilde_expand (text, 0);
-
-      if (rl_explicit_arg)
-	{
-	  globorig = savestring (ttext);
-	  glen = strlen (ttext);
-	  globtext = (char *)xmalloc (glen + 2);
-	  strcpy (globtext, ttext);
-	  globtext[glen] = '*';
-	  globtext[glen+1] = '\0';
-	}
-      else
-        globtext = globorig = savestring (ttext);
-
-      if (ttext != text)
-	free (ttext);
-
-      matches = shell_glob_filename (globtext, 0);
-      if (GLOB_FAILED (matches))
-	matches = (char **)NULL;
-      ind = 0;
-    }
-
-  ret = matches ? matches[ind] : (char *)NULL;
-  ind++;
-  return ret;
-}
-
-static int
-bash_glob_completion_internal (what_to_do)
-     int what_to_do;
-{
-  return bash_specific_completion (what_to_do, glob_complete_word);
-}
-
-/* A special quoting function so we don't end up quoting globbing characters
-   in the word if there are no matches or multiple matches. */
-static char *
-bash_glob_quote_filename (s, rtype, qcp)
-     char *s;
-     int rtype;
-     char *qcp;
-{
-  if (globorig && qcp && *qcp == '\0' && STREQ (s, globorig))
-    return (savestring (s));
-  else
-    return (bash_quote_filename (s, rtype, qcp));
-}
-
-static int
-bash_glob_complete_word (count, key)
-     int count, key;
-{
-  int r;
-  rl_quote_func_t *orig_quoting_function;
-
-  if (rl_editing_mode == EMACS_EDITING_MODE)
-    rl_explicit_arg = 1;	/* force `*' append */
-  orig_quoting_function = rl_filename_quoting_function;
-  rl_filename_quoting_function = bash_glob_quote_filename;
-  
-  r = bash_glob_completion_internal (rl_completion_mode (bash_glob_complete_word));
-
-  rl_filename_quoting_function = orig_quoting_function;
-  return r;
-}
-
-static int
-bash_glob_expand_word (count, key)
-     int count, key;
-{
-  return bash_glob_completion_internal ('*');
-}
-
-static int
-bash_glob_list_expansions (count, key)
-     int count, key;
-{
-  return bash_glob_completion_internal ('?');
-}
-
-static int
-bash_specific_completion (what_to_do, generator)
-     int what_to_do;
-     rl_compentry_func_t *generator;
-{
-  rl_compentry_func_t *orig_func;
-  rl_completion_func_t *orig_attempt_func;
-  rl_compignore_func_t *orig_ignore_func;
-  int r;
-
-  orig_func = rl_completion_entry_function;
-  orig_attempt_func = rl_attempted_completion_function;
-  orig_ignore_func = rl_ignore_some_completions_function;
-  rl_completion_entry_function = generator;
-  rl_attempted_completion_function = NULL;
-  rl_ignore_some_completions_function = orig_ignore_func;
-
-  r = rl_complete_internal (what_to_do);
-
-  rl_completion_entry_function = orig_func;
-  rl_attempted_completion_function = orig_attempt_func;
-  rl_ignore_some_completions_function = orig_ignore_func;
-
-  return r;
-}
-
-#endif	/* SPECIFIC_COMPLETION_FUNCTIONS */
-
-#if defined (VI_MODE)
-/* Completion, from vi mode's point of view.  This is a modified version of
-   rl_vi_complete which uses the bash globbing code to implement what POSIX
-   specifies, which is to append a `*' and attempt filename generation (which
-   has the side effect of expanding any globbing characters in the word). */
-static int
-bash_vi_complete (count, key)
-     int count, key;
-{
-#if defined (SPECIFIC_COMPLETION_FUNCTIONS)
-  int p, r;
-  char *t;
-
-  if ((rl_point < rl_end) && (!whitespace (rl_line_buffer[rl_point])))
-    {
-      if (!whitespace (rl_line_buffer[rl_point + 1]))
-	rl_vi_end_word (1, 'E');
-      rl_point++;
-    }
-
-  /* Find boundaries of current word, according to vi definition of a
-     `bigword'. */
-  t = 0;
-  if (rl_point > 0)
-    {
-      p = rl_point;
-      rl_vi_bWord (1, 'B');
-      r = rl_point;
-      rl_point = p;
-      p = r;
-
-      t = substring (rl_line_buffer, p, rl_point);
-    }      
-
-  if (t && completion_glob_pattern (t) == 0)
-    rl_explicit_arg = 1;	/* XXX - force glob_complete_word to append `*' */
-  FREE (t);
-
-  if (key == '*')	/* Expansion and replacement. */
-    r = bash_glob_expand_word (count, key);
-  else if (key == '=')	/* List possible completions. */
-    r = bash_glob_list_expansions (count, key);
-  else if (key == '\\')	/* Standard completion */
-    r = bash_glob_complete_word (count, key);
-  else
-    r = rl_complete (0, key);
-
-  if (key == '*' || key == '\\')
-    rl_vi_start_inserting (key, 1, 1);
-
-  return (r);
-#else
-  return rl_vi_complete (count, key);
-#endif /* !SPECIFIC_COMPLETION_FUNCTIONS */
-}
-#endif /* VI_MODE */
-
-/* Filename quoting for completion. */
-/* A function to strip unquoted quote characters (single quotes, double
-   quotes, and backslashes).  It allows single quotes to appear
-   within double quotes, and vice versa.  It should be smarter. */
-static char *
-bash_dequote_filename (text, quote_char)
-     char *text;
-     int quote_char;
-{
-  char *ret, *p, *r;
-  int l, quoted;
-
-  l = strlen (text);
-  ret = (char *)xmalloc (l + 1);
-  for (quoted = quote_char, p = text, r = ret; p && *p; p++)
-    {
-      /* Allow backslash-escaped characters to pass through unscathed. */
-      if (*p == '\\')
-	{
-	  /* Backslashes are preserved within single quotes. */
-	  if (quoted == '\'')
-	    *r++ = *p;
-	  /* Backslashes are preserved within double quotes unless the
-	     character is one that is defined to be escaped */
-	  else if (quoted == '"' && ((sh_syntaxtab[(unsigned char)p[1]] & CBSDQUOTE) == 0))
-	    *r++ = *p;
-
-	  *r++ = *++p;
-	  if (*p == '\0')
-	    return ret;		/* XXX - was break; */
-	  continue;
-	}
-      /* Close quote. */
-      if (quoted && *p == quoted)
-	{
-	  quoted = 0;
-	  continue;
-	}
-      /* Open quote. */
-      if (quoted == 0 && (*p == '\'' || *p == '"'))
-	{
-	  quoted = *p;
-	  continue;
-	}
-      *r++ = *p;
-    }
-  *r = '\0';
-  return ret;
-}
-
-/* Quote characters that the readline completion code would treat as
-   word break characters with backslashes.  Pass backslash-quoted
-   characters through without examination. */
-static char *
-quote_word_break_chars (text)
-     char *text;
-{
-  char *ret, *r, *s;
-  int l;
-
-  l = strlen (text);
-  ret = (char *)xmalloc ((2 * l) + 1);
-  for (s = text, r = ret; *s; s++)
-    {
-      /* Pass backslash-quoted characters through, including the backslash. */
-      if (*s == '\\')
-	{
-	  *r++ = '\\';
-	  *r++ = *++s;
-	  if (*s == '\0')
-	    break;
-	  continue;
-	}
-      /* OK, we have an unquoted character.  Check its presence in
-	 rl_completer_word_break_characters. */
-      if (mbschr (rl_completer_word_break_characters, *s))
-	*r++ = '\\';
-      /* XXX -- check for standalone tildes here and backslash-quote them */
-      if (s == text && *s == '~' && file_exists (text))
-        *r++ = '\\';
-      *r++ = *s;
-    }
-  *r = '\0';
-  return ret;
-}
-
-/* Return a character in DIRNAME that will cause shell expansion to be
-   performed. If NEXTP is non-null, *NEXTP gets the expansion character that
-   follows RET (e.g., '{' or `(' for `$'). If CLOSERP is non-null, *CLOSERP
-   gets the character that should close <RET><NEXTP>. If NEED_CLOSER is non-
-   zero, any expansion pair that isn't closed causes this function to
-   return 0, which indicates that we didn't find an expansion character. It's
-   used in case DIRNAME is going to be expanded. If DIRNAME is just going to
-   be quoted, NEED_CLOSER will be 0. */
-static int
-bash_check_expchar (dirname, need_closer, nextp, closerp)
-     char *dirname;
-     int need_closer;
-     int *nextp, *closerp;
-{
-  char *t;
-  int ret, n, c;
-
-  ret = n = c = 0;
-  if (t = mbschr (dirname, '$'))
-    {
-      ret = '$';
-      n = t[1];
-      /* Deliberately does not handle the deprecated $[...] arithmetic
-	 expansion syntax */
-      if (n == '(')
-	c = ')';
-      else if (n == '{')
-	c = '}';
-      else
-	n = 0;
-
-      if (c && need_closer)		/* XXX */
-	{
-	  int p;
-	  char delims[2];
-
-	  delims[0] = c; delims[1] = 0;
-	  p = skip_to_delim (t, 1, delims, SD_NOJMP|SD_COMPLETE);
-	  if (t[p] != c)
-	    ret = 0;
-	}
-    }
-  else if (dirname[0] == '~')
-    ret = '~';
-  else
-    {
-      t = mbschr (dirname, '`');
-      if (t)
-	{
-	  if (need_closer == 0)
-	    ret = '`';
-	  else if (unclosed_pair (dirname, strlen (dirname), "`") == 0)
-	    ret = '`';
-	}
-    }
-
-  if (nextp)
-    *nextp = n;
-  if (closerp)
-    *closerp = c;
-
-  return ret;
-}
-
-/* Make sure EXPCHAR and, if non-zero, NEXTCH and CLOSER are not in the set
-   of characters to be backslash-escaped. This is the only place
-   custom_filename_quote_characters is modified. */
-static void
-set_filename_quote_chars (expchar, nextch, closer)
-     int expchar, nextch, closer;
-{
-  int i, j, c;
-
-  if (rl_filename_quote_characters && *rl_filename_quote_characters)
-    {
-      i = strlen (default_filename_quote_characters);
-      custom_filename_quote_characters = xrealloc (custom_filename_quote_characters, i+1);
-      for (i = j = 0; c = default_filename_quote_characters[i]; i++)
-	{
-	  if (c == expchar || c == nextch || c == closer)
-	    continue;
-	  custom_filename_quote_characters[j++] = c;
-	}
-      custom_filename_quote_characters[j] = '\0';
-      rl_filename_quote_characters = custom_filename_quote_characters;
-      set_filename_bstab (rl_filename_quote_characters);
-    }
-}
-
-/* Use characters in STRING to populate the table of characters that should
-   be backslash-quoted.  The table will be used for sh_backslash_quote from
-   this file. */
-static void
-set_filename_bstab (string)
-     const char *string;
-{
-  const char *s;
-
-  memset (filename_bstab, 0, sizeof (filename_bstab));
-  for (s = string; s && *s; s++)
-    filename_bstab[(unsigned char)*s] = 1;
-}
-
-/* Quote a filename using double quotes, single quotes, or backslashes
-   depending on the value of completion_quoting_style.  If we're
-   completing using backslashes, we need to quote some additional
-   characters (those that readline treats as word breaks), so we call
-   quote_word_break_chars on the result.  This returns newly-allocated
-   memory. */
-static char *
-bash_quote_filename (s, rtype, qcp)
-     char *s;
-     int rtype;
-     char *qcp;
-{
-  char *rtext, *mtext, *ret;
-  int rlen, cs;
-  int expchar, nextch, closer;
-
-  rtext = (char *)NULL;
-
-  /* If RTYPE == MULT_MATCH, it means that there is
-     more than one match.  In this case, we do not add
-     the closing quote or attempt to perform tilde
-     expansion.  If RTYPE == SINGLE_MATCH, we try
-     to perform tilde expansion, because single and double
-     quotes inhibit tilde expansion by the shell. */
-
-  cs = completion_quoting_style;
-  /* Might need to modify the default completion style based on *qcp,
-     since it's set to any user-provided opening quote.  We also change
-     to single-quoting if there is no user-provided opening quote and
-     the word being completed contains newlines, since those are not
-     quoted correctly using backslashes (a backslash-newline pair is
-     special to the shell parser). */
-  expchar = nextch = closer = 0;
-  if (*qcp == '\0' && cs == COMPLETE_BSQUOTE && dircomplete_expand == 0 &&
-      (expchar = bash_check_expchar (s, 0, &nextch, &closer)) &&
-      file_exists (s) == 0)
-    {
-      /* Usually this will have been set by bash_directory_completion_hook,
-      	 but there are cases where it will not be. */
-      if (rl_filename_quote_characters != custom_filename_quote_characters)
-	set_filename_quote_chars (expchar, nextch, closer);
-      complete_fullquote = 0;
-    }
-  else if (*qcp == '\0' && cs == COMPLETE_BSQUOTE && mbschr (s, '\n'))
-    cs = COMPLETE_SQUOTE;
-  else if (*qcp == '"')
-    cs = COMPLETE_DQUOTE;
-  else if (*qcp == '\'')
-    cs = COMPLETE_SQUOTE;
-#if defined (BANG_HISTORY)
-  else if (*qcp == '\0' && history_expansion && cs == COMPLETE_DQUOTE &&
-	   history_expansion_inhibited == 0 && mbschr (s, '!'))
-    cs = COMPLETE_BSQUOTE;
-
-  if (*qcp == '"' && history_expansion && cs == COMPLETE_DQUOTE &&
-	history_expansion_inhibited == 0 && mbschr (s, '!'))
-    {
-      cs = COMPLETE_BSQUOTE;
-      *qcp = '\0';
-    }
-#endif
-
-  /* Don't tilde-expand backslash-quoted filenames, since only single and
-     double quotes inhibit tilde expansion. */
-  mtext = s;
-  if (mtext[0] == '~' && rtype == SINGLE_MATCH && cs != COMPLETE_BSQUOTE)
-    mtext = bash_tilde_expand (s, 0);
-
-  switch (cs)
-    {
-    case COMPLETE_DQUOTE:
-      rtext = sh_double_quote (mtext);
-      break;
-    case COMPLETE_SQUOTE:
-      rtext = sh_single_quote (mtext);
-      break;
-    case COMPLETE_BSQUOTE:
-      rtext = sh_backslash_quote (mtext, complete_fullquote ? 0 : filename_bstab, 0);
-      break;
-    }
-
-  if (mtext != s)
-    free (mtext);
-
-  /* We may need to quote additional characters: those that readline treats
-     as word breaks that are not quoted by backslash_quote. */
-  /* XXX - test complete_fullquote here? */
-  if (rtext && cs == COMPLETE_BSQUOTE && rl_completer_word_break_characters)
-    {
-      mtext = quote_word_break_chars (rtext);
-      free (rtext);
-      rtext = mtext;
-    }
-
-  /* Leave the opening quote intact.  The readline completion code takes
-     care of avoiding doubled opening quotes. */
-  if (rtext)
-    {
-      rlen = strlen (rtext);
-      ret = (char *)xmalloc (rlen + 1);
-      strcpy (ret, rtext);
-    }
-  else
-    {
-      ret = (char *)xmalloc (rlen = 1);
-      ret[0] = '\0';
-    }
-
-  /* If there are multiple matches, cut off the closing quote. */
-  if (rtype == MULT_MATCH && cs != COMPLETE_BSQUOTE)
-    ret[rlen - 1] = '\0';
-  free (rtext);
-  return ret;
-}
-
-/* Support for binding readline key sequences to Unix commands. Each editing
-   mode has a separate Unix command keymap. */
-
-static Keymap emacs_std_cmd_xmap;
-#if defined (VI_MODE)
-static Keymap vi_insert_cmd_xmap;
-static Keymap vi_movement_cmd_xmap;
-#endif
-
-#ifdef _MINIX
-static void
-#else
-static int
-#endif
-putx(c)
-     int c;
-{
-  int x;
-  x = putc (c, rl_outstream);
-#ifndef _MINIX
-  return x;
-#endif
-}
-
-static int
-readline_get_char_offset (ind)
-     int ind;
-{
-  int r, old_ch;
-
-  r = ind;
-#if defined (HANDLE_MULTIBYTE)
-  if (locale_mb_cur_max > 1)
-    {
-      old_ch = rl_line_buffer[ind];
-      rl_line_buffer[ind] = '\0';
-      r = MB_STRLEN (rl_line_buffer);
-      rl_line_buffer[ind] = old_ch;
-    }
-#endif
-  return r;
-}
-
-static void
-readline_set_char_offset (ind, varp)
-     int ind;
-     int *varp;
-{
-  int i;
-
-  i = ind;
-
-#if defined (HANDLE_MULTIBYTE)
-  if (i > 0 && locale_mb_cur_max > 1)
-    i = _rl_find_next_mbchar (rl_line_buffer, 0, i, 0);		/* XXX */
-#endif
-  if (i != *varp)
-    {
-      if (i > rl_end)
-	i = rl_end;
-      else if (i < 0)
-	i = 0;
-      *varp = i;
-    }
-}
-
-int
-bash_execute_unix_command (count, key)
-     int count;	/* ignored */
-     int key;
-{
-  int type;
-  register int i, r;
-  intmax_t mi;
-  sh_parser_state_t ps;
-  char *cmd, *value, *ce, old_ch;
-  SHELL_VAR *v;
-  char ibuf[INT_STRLEN_BOUND(int) + 1];
-  Keymap cmd_xmap;
-  const char *kseq;
-  size_t kslen;
-
-  kseq = rl_executing_keyseq;
-  kslen = rl_key_sequence_length;
-
-  /* If we have a numeric argument, chop it off the front of the key sequence */
-  if (count > 1 || rl_explicit_arg)
-    {
-      i = rl_trim_arg_from_keyseq (rl_executing_keyseq, rl_key_sequence_length, rl_get_keymap ());
-      if (i > 0)
-	{
-	 kseq = rl_executing_keyseq + i;
-	 kslen = rl_key_sequence_length - i;
-	}
-    }
-
-  /* First, we need to find the right command to execute.  This is tricky,
-     because we might have already indirected into another keymap, so we
-     have to walk cmd_xmap using the entire key sequence. */
-  cmd_xmap = get_cmd_xmap_from_keymap (rl_get_keymap ());
-  cmd = (char *)rl_function_of_keyseq_len (kseq, kslen, cmd_xmap, &type);
-
-  if (type == ISKMAP && (type = ((Keymap) cmd)[ANYOTHERKEY].type) == ISMACR)
-    cmd = (char*)((Keymap) cmd)[ANYOTHERKEY].function;
-
-  if (cmd == 0 || type != ISMACR)
-    {
-      rl_crlf ();
-      internal_error (_("bash_execute_unix_command: cannot find keymap for command"));
-      rl_forced_update_display ();
-      return 1;
-    }
-
-  ce = rl_get_termcap ("ce");
-  if (ce)	/* clear current line */
-    {
-      rl_clear_visible_line ();
-      fflush (rl_outstream);
-    }
-  else
-    rl_crlf ();	/* move to a new line */
-
-  v = bind_variable ("READLINE_LINE", rl_line_buffer, 0);
-  if (v)
-    VSETATTR (v, att_exported);
-
-  i = readline_get_char_offset (rl_point);
-  value = inttostr (i, ibuf, sizeof (ibuf));
-  v = bind_int_variable ("READLINE_POINT", value, 0);
-  if (v)
-    VSETATTR (v, att_exported);
-
-  i = readline_get_char_offset (rl_mark);
-  value = inttostr (i, ibuf, sizeof (ibuf));
-  v = bind_int_variable ("READLINE_MARK", value, 0);
-  if (v)
-    VSETATTR (v, att_exported);
-
-  if (count > 1 || rl_explicit_arg)
-    {
-      value = inttostr (count, ibuf, sizeof (ibuf));
-      v = bind_int_variable ("READLINE_ARGUMENT", value, 0);
-      if (v)
-        VSETATTR (v, att_exported);
-    }
-  array_needs_making = 1;
-
-  save_parser_state (&ps);
-  rl_clear_signals ();
-  r = parse_and_execute (savestring (cmd), "bash_execute_unix_command", SEVAL_NOHIST);
-  rl_set_signals ();
-  restore_parser_state (&ps);
-
-  v = find_variable ("READLINE_LINE");
-  maybe_make_readline_line (v ? value_cell (v) : 0);
-
-  v = find_variable ("READLINE_POINT");
-  if (v && legal_number (value_cell (v), &mi))
-    readline_set_char_offset (mi, &rl_point);
-
-  v = find_variable ("READLINE_MARK");
-  if (v && legal_number (value_cell (v), &mi))
-    readline_set_char_offset (mi, &rl_mark);
-
-  check_unbind_variable ("READLINE_LINE");
-  check_unbind_variable ("READLINE_POINT");
-  check_unbind_variable ("READLINE_MARK");
-  check_unbind_variable ("READLINE_ARGUMENT");
-  array_needs_making = 1;
-
-  /* and restore the readline buffer and display after command execution. */
-  /* If we clear the last line of the prompt above, redraw only that last
-     line.  If the command returns 124, we redraw unconditionally as in
-     previous versions. */
-  if (ce && r != 124)
-    rl_redraw_prompt_last_line ();
-  else
-    rl_forced_update_display ();
-
-  return 0;
-}
-
-int
-print_unix_command_map ()
-{
-  Keymap save, cmd_xmap;
-
-  save = rl_get_keymap ();
-  cmd_xmap = get_cmd_xmap_from_keymap (save);
-  rl_set_keymap (cmd_xmap);
-  rl_macro_dumper (1);
-  rl_set_keymap (save);
-  return 0;
-}
-
-static void
-init_unix_command_map ()
-{
-  emacs_std_cmd_xmap = rl_make_bare_keymap ();
-
-  emacs_std_cmd_xmap[CTRL('X')].type = ISKMAP;
-  emacs_std_cmd_xmap[CTRL('X')].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap ());
-  emacs_std_cmd_xmap[ESC].type = ISKMAP;
-  emacs_std_cmd_xmap[ESC].function = KEYMAP_TO_FUNCTION (rl_make_bare_keymap ());
-
-#if defined (VI_MODE)  
-  vi_insert_cmd_xmap = rl_make_bare_keymap ();
-  vi_movement_cmd_xmap = rl_make_bare_keymap ();
-#endif
-}
-
-static Keymap
-get_cmd_xmap_from_edit_mode ()
-{
-  if (emacs_std_cmd_xmap == 0)
-    init_unix_command_map ();
-
-  switch (rl_editing_mode)
-    {
-    case EMACS_EDITING_MODE:
-      return emacs_std_cmd_xmap;
-#if defined (VI_MODE)
-    case VI_EDITING_MODE:
-      return (get_cmd_xmap_from_keymap (rl_get_keymap ()));
-#endif
-    default:
-      return (Keymap)NULL;
-    }
-}
-
-static Keymap
-get_cmd_xmap_from_keymap (kmap)
-     Keymap kmap;
-{
-  if (emacs_std_cmd_xmap == 0)
-    init_unix_command_map ();
-
-  if (kmap == emacs_standard_keymap)
-    return emacs_std_cmd_xmap;
-  else if (kmap == emacs_meta_keymap)
-    return (FUNCTION_TO_KEYMAP (emacs_std_cmd_xmap, ESC));
-  else if (kmap == emacs_ctlx_keymap)
-    return (FUNCTION_TO_KEYMAP (emacs_std_cmd_xmap, CTRL('X')));
-#if defined (VI_MODE)
-  else if (kmap == vi_insertion_keymap)
-    return vi_insert_cmd_xmap;
-  else if (kmap == vi_movement_keymap)
-    return vi_movement_cmd_xmap;
-#endif
-  else
-    return (Keymap)NULL;
-}
-
-static int
-isolate_sequence (string, ind, need_dquote, startp)
-     char *string;
-     int ind, need_dquote, *startp;
-{
-  register int i;
-  int c, passc, delim;
-
-  for (i = ind; string[i] && whitespace (string[i]); i++)
-    ;
-  /* NEED_DQUOTE means that the first non-white character *must* be `"'. */
-  if (need_dquote && string[i] != '"')
-    {
-      builtin_error (_("%s: first non-whitespace character is not `\"'"), string);
-      return -1;
-    }
-
-  /* We can have delimited strings even if NEED_DQUOTE == 0, like the command
-     string to bind the key sequence to. */
-  delim = (string[i] == '"' || string[i] == '\'') ? string[i] : 0;
-    
-  if (startp)
-    *startp = delim ? ++i : i;
-
-  for (passc = 0; c = string[i]; i++)
-    {
-      if (passc)
-	{
-	  passc = 0;
-	  continue;
-	}
-      if (c == '\\')
-	{
-	  passc++;
-	  continue;
-	}
-      if (c == delim)
-	break;
-    }
-
-  if (delim && string[i] != delim)
-    {
-      builtin_error (_("no closing `%c' in %s"), delim, string);
-      return -1;
-    }
-
-  return i;
-}
-
-int
-bind_keyseq_to_unix_command (line)
-     char *line;
-{
-  Keymap kmap, cmd_xmap;
-  char *kseq, *value;
-  int i, kstart;
-
-  kmap = rl_get_keymap ();
-
-  /* We duplicate some of the work done by rl_parse_and_bind here, but
-     this code only has to handle `"keyseq": ["]command["]' and can
-     generate an error for anything else. */
-  i = isolate_sequence (line, 0, 1, &kstart);
-  if (i < 0)
-    return -1;
-
-  /* Create the key sequence string to pass to rl_generic_bind */
-  kseq = substring (line, kstart, i);
-
-  for ( ; line[i] && line[i] != ':'; i++)
-    ;
-  if (line[i] != ':')
-    {
-      builtin_error (_("%s: missing colon separator"), line);
-      FREE (kseq);
-      return -1;
-    }
-
-  i = isolate_sequence (line, i + 1, 0, &kstart);
-  if (i < 0)
-    {
-      FREE (kseq);
-      return -1;
-    }
-
-  /* Create the value string containing the command to execute. */
-  value = substring (line, kstart, i);
-
-  /* Save the command to execute and the key sequence in the CMD_XMAP */
-  cmd_xmap = get_cmd_xmap_from_keymap (kmap);
-  rl_generic_bind (ISMACR, kseq, value, cmd_xmap);
-
-  /* and bind the key sequence in the current keymap to a function that
-     understands how to execute from CMD_XMAP */
-  rl_bind_keyseq_in_map (kseq, bash_execute_unix_command, kmap);
-
-  free (kseq);  
-  return 0;
-}
-
-int
-unbind_unix_command (kseq)
-     char *kseq;
-{
-  Keymap cmd_xmap;
-
-  cmd_xmap = get_cmd_xmap_from_keymap (rl_get_keymap ());
-  if (rl_bind_keyseq_in_map (kseq, (rl_command_func_t *)NULL, cmd_xmap) != 0)
-    {
-      builtin_error (_("`%s': cannot unbind in command keymap"), kseq);
-      return 0;
-    }
-  return 1;
-}
-
-/* Used by the programmable completion code.  Complete TEXT as a filename,
-   but return only directories as matches.  Dequotes the filename before
-   attempting to find matches. */
-char **
-bash_directory_completion_matches (text)
-     const char *text;
-{
-  char **m1;
-  char *dfn;
-  int qc;
-
-  qc = rl_dispatching ? rl_completion_quote_character : 0;  
-  /* If rl_completion_found_quote != 0, rl_completion_matches will call the
-     filename dequoting function, causing the directory name to be dequoted
-     twice. */
-  if (rl_dispatching && rl_completion_found_quote == 0)
-    dfn = bash_dequote_filename ((char *)text, qc);
-  else
-    dfn = (char *)text;
-  m1 = rl_completion_matches (dfn, rl_filename_completion_function);
-  if (dfn != text)
-    free (dfn);
-
-  if (m1 == 0 || m1[0] == 0)
-    return m1;
-  /* We don't bother recomputing the lcd of the matches, because it will just
-     get thrown away by the programmable completion code and recomputed
-     later. */
-  (void)bash_progcomp_ignore_filenames (m1);
-  return m1;
-}
-
-char *
-bash_dequote_text (text)
-     const char *text;
-{
-  char *dtxt;
-  int qc;
-
-  qc = (text[0] == '"' || text[0] == '\'') ? text[0] : 0;
-  dtxt = bash_dequote_filename ((char *)text, qc);
-  return (dtxt);
-}
-
-/* This event hook is designed to be called after readline receives a signal
-   that interrupts read(2).  It gives reasonable responsiveness to interrupts
-   and fatal signals without executing too much code in a signal handler
-   context. */
-static int
-bash_event_hook ()
-{
-  int sig;
-
-  /* XXX - see if we need to do anything here if sigterm_received == 1,
-     we probably don't want to reset the event hook since we will not be
-     jumping to the top level */
-  if (sigterm_received)
-    {
-      /* RESET_SIGTERM;	*/
-      return 0;
-    }
-
-  sig = 0;
-  if (terminating_signal)
-    sig = terminating_signal;
-  else if (interrupt_state)
-    sig = SIGINT;
-  else if (read_timeout && read_timeout->alrmflag)
-    sig = SIGALRM;
-  else if (RL_ISSTATE (RL_STATE_TIMEOUT))		/* just in case */
-    {
-      sig = SIGALRM;
-      if (read_timeout)
-	read_timeout->alrmflag = 1;
-    }
-  else
-    sig = first_pending_trap ();
-
-  /* If we're going to longjmp to top_level, make sure we clean up readline.
-     check_signals will call QUIT, which will eventually longjmp to top_level,
-     calling run_interrupt_trap along the way.  The check against read_timeout
-     is so we can clean up the read builtin's state. */
-  if (terminating_signal || interrupt_state || (read_timeout && read_timeout->alrmflag))
-    rl_cleanup_after_signal ();
-  bashline_reset_event_hook ();
-
-  RL_UNSETSTATE (RL_STATE_TIMEOUT);			/* XXX */
-
-  /* posix mode SIGINT during read -e. We only get here if SIGINT is trapped. */
-  if (posixly_correct && this_shell_builtin == read_builtin && sig == SIGINT)
-    {
-      last_command_exit_value = 128|SIGINT;
-      throw_to_top_level ();
-    }
-
-  check_signals_and_traps ();	/* XXX */
-  return 0;
-}
-
-#endif /* READLINE */
diff --git a/third_party/bash/bashline.h b/third_party/bash/bashline.h
deleted file mode 100644
index d40228e29..000000000
--- a/third_party/bash/bashline.h
+++ /dev/null
@@ -1,69 +0,0 @@
-/* bashline.h -- interface to the bash readline functions in bashline.c. */
-
-/* Copyright (C) 1993-2019 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_BASHLINE_H_)
-#define _BASHLINE_H_
-
-#include "stdc.h"
-
-extern int bash_readline_initialized;
-extern int hostname_list_initialized;
-
-/* these are controlled via shopt */
-extern int perform_hostname_completion;
-extern int no_empty_command_completion;
-extern int force_fignore;
-extern int dircomplete_spelling;
-extern int dircomplete_expand;
-extern int dircomplete_expand_relpath;
-extern int complete_fullquote;
-
-extern void posix_readline_initialize PARAMS((int));
-extern void reset_completer_word_break_chars PARAMS((void));
-extern int enable_hostname_completion PARAMS((int));
-extern void initialize_readline PARAMS((void));
-extern void bashline_reset PARAMS((void));
-extern void bashline_reinitialize PARAMS((void));
-extern int bash_re_edit PARAMS((char *));
-
-extern void bashline_set_event_hook PARAMS((void));
-extern void bashline_reset_event_hook PARAMS((void));
-
-extern int bind_keyseq_to_unix_command PARAMS((char *));
-extern int bash_execute_unix_command PARAMS((int, int));
-extern int print_unix_command_map PARAMS((void));
-extern int unbind_unix_command PARAMS((char *));
-
-extern char **bash_default_completion PARAMS((const char *, int, int, int, int));
-
-extern void set_directory_hook PARAMS((void));
-
-/* Used by programmable completion code. */
-extern char *command_word_completion_function PARAMS((const char *, int));
-extern char *bash_groupname_completion_function PARAMS((const char *, int));
-extern char *bash_servicename_completion_function PARAMS((const char *, int));
-
-extern char **get_hostname_list PARAMS((void));
-extern void clear_hostname_list PARAMS((void));
-
-extern char **bash_directory_completion_matches PARAMS((const char *));
-extern char *bash_dequote_text PARAMS((const char *));
-
-#endif /* _BASHLINE_H_ */
diff --git a/third_party/bash/bashtypes.h b/third_party/bash/bashtypes.h
deleted file mode 100644
index 01afef4b4..000000000
--- a/third_party/bash/bashtypes.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/* bashtypes.h -- Bash system types. */
-
-/* Copyright (C) 1993-2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_BASHTYPES_H_)
-#  define _BASHTYPES_H_
-
-#if defined (CRAY)
-#  define word __word
-#endif
-
-#include <sys/types.h>
-
-#if defined (CRAY)
-#  undef word
-#endif
-
-#if defined (HAVE_INTTYPES_H)
-#  include <inttypes.h>
-#endif
-
-#if HAVE_STDINT_H
-#  include <stdint.h>
-#endif
-
-#endif /* _BASHTYPES_H_ */
diff --git a/third_party/bash/bracecomp.c b/third_party/bash/bracecomp.c
deleted file mode 100644
index 1e67640e6..000000000
--- a/third_party/bash/bracecomp.c
+++ /dev/null
@@ -1,221 +0,0 @@
-/* bracecomp.c -- Complete a filename with the possible completions enclosed
-   in csh-style braces such that the list of completions is available to the
-   shell. */
-
-/* Original version by tromey@cns.caltech.edu,  Fri Feb  7 1992. */
-
-/* Copyright (C) 1993-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (BRACE_EXPANSION) && defined (READLINE)
-
-#include <stdio.h>
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "shmbutil.h"
-
-#include "shell.h"
-#include "third_party/readline/readline.h"
-
-static int _strcompare PARAMS((char **, char **));
-
-/* Find greatest common prefix of two strings. */
-static int
-string_gcd (s1, s2)
-     char *s1, *s2;
-{
-  register int i;
-
-  if (s1 == NULL || s2 == NULL)
-    return (0);
-
-  for (i = 0; *s1 && *s2; ++s1, ++s2, ++i)
-    {
-      if (*s1 != *s2)
-	break;
-    }
-
-  return (i);
-}
-
-static char *
-really_munge_braces (array, real_start, real_end, gcd_zero)
-     char **array;
-     int real_start, real_end, gcd_zero;
-{
-  int start, end, gcd;
-  char *result, *subterm, *x;
-  int result_size, flag, tlen;
-
-  flag = 0;
-
-  if (real_start == real_end)
-    {
-      x = array[real_start] ? sh_backslash_quote (array[real_start] + gcd_zero, 0, 0)
- 			    : sh_backslash_quote (array[0], 0, 0);
-      return x;
-    }
-
-  result = (char *)xmalloc (result_size = 16);
-  *result = '\0';
-
-  for (start = real_start; start < real_end; start = end + 1)
-    {
-      gcd = strlen (array[start]);
-      for (end = start + 1; end < real_end; end++)
-	{
-	  int temp;
-
-	  temp = string_gcd (array[start], array[end]);
-
-	  if (temp <= gcd_zero)
-	    break;
-
-	  gcd = temp;
-	}
-      end--;
-
-      if (gcd_zero == 0 && start == real_start && end != (real_end - 1))
-	{
-	  /* In this case, add in a leading '{', because we are at
-	     top level, and there isn't a consistent prefix. */
-	  result_size += 1;
-	  result = (char *)xrealloc (result, result_size);
-	  result[0] = '{'; result[1] = '\0';
-	  flag++;
-	}
-
-      /* Make sure we backslash quote every substring we insert into the
-	 resultant brace expression.  This is so the default filename
-	 quoting function won't inappropriately quote the braces. */
-      if (start == end)
-	{
-	  x = savestring (array[start] + gcd_zero);
-	  subterm = sh_backslash_quote (x, 0, 0);
-	  free (x);
-	}
-      else
-	{
-	  /* If there is more than one element in the subarray,
-	     insert the (quoted) prefix and an opening brace. */
-	  tlen = gcd - gcd_zero;
-	  x = (char *)xmalloc (tlen + 1);
-	  strncpy (x, array[start] + gcd_zero, tlen);
-	  x[tlen] = '\0';
-	  subterm = sh_backslash_quote (x, 0, 0);
-	  free (x);
-	  result_size += strlen (subterm) + 1;
-	  result = (char *)xrealloc (result, result_size);
-	  strcat (result, subterm);
-	  free (subterm);
-	  strcat (result, "{");
-	  subterm = really_munge_braces (array, start, end + 1, gcd);
-	  subterm[strlen (subterm) - 1] = '}';
-	}
-
-      result_size += strlen (subterm) + 1;
-      result = (char *)xrealloc (result, result_size);
-      strcat (result, subterm);
-      strcat (result, ",");
-      free (subterm);
-    }
-
-  if (gcd_zero == 0)
-    result[strlen (result) - 1] = flag ? '}' : '\0';
-  return (result);
-}
-
-static int
-_strcompare (s1, s2)
-     char **s1, **s2;
-{
-  int result;
-
-  result = **s1 - **s2;
-  if (result == 0)
-    result = strcmp (*s1, *s2);
-
-  return result;
-}
-
-static int
-hack_braces_completion (names)
-     char **names;
-{
-  register int i;
-  char *temp;
-
-  i = strvec_len (names);
-  if (MB_CUR_MAX > 1 && i > 2)
-    qsort (names+1, i-1, sizeof (char *), (QSFUNC *)_strcompare);
-      
-  temp = really_munge_braces (names, 1, i, 0);
-
-  for (i = 0; names[i]; ++i)
-    {
-      free (names[i]);
-      names[i] = NULL;
-    }
-  names[0] = temp;
-  return 0;
-}
-
-/* We handle quoting ourselves within hack_braces_completion, so we turn off
-   rl_filename_quoting_desired and rl_filename_quoting_function. */
-int
-bash_brace_completion (count, ignore)
-     int count, ignore;
-{
-  rl_compignore_func_t *orig_ignore_func;
-  rl_compentry_func_t *orig_entry_func;
-  rl_quote_func_t *orig_quoting_func;
-  rl_completion_func_t *orig_attempt_func;
-  int orig_quoting_desired, r;
-
-  orig_ignore_func = rl_ignore_some_completions_function;
-  orig_attempt_func = rl_attempted_completion_function;
-  orig_entry_func = rl_completion_entry_function;
-  orig_quoting_func = rl_filename_quoting_function;
-  orig_quoting_desired = rl_filename_quoting_desired;
-
-  rl_completion_entry_function = rl_filename_completion_function;
-  rl_attempted_completion_function = (rl_completion_func_t *)NULL;
-  rl_ignore_some_completions_function = hack_braces_completion;
-  rl_filename_quoting_function = (rl_quote_func_t *)NULL;
-  rl_filename_quoting_desired = 0;
-
-  r = rl_complete_internal (TAB);
-
-  rl_ignore_some_completions_function = orig_ignore_func;
-  rl_attempted_completion_function = orig_attempt_func;
-  rl_completion_entry_function = orig_entry_func;
-  rl_filename_quoting_function = orig_quoting_func;
-  rl_filename_quoting_desired = orig_quoting_desired;
-
-  return r;
-}
-#endif /* BRACE_EXPANSION && READLINE */
diff --git a/third_party/bash/braces.c b/third_party/bash/braces.c
deleted file mode 100644
index e91d326ea..000000000
--- a/third_party/bash/braces.c
+++ /dev/null
@@ -1,843 +0,0 @@
-/* braces.c -- code for doing word expansion in curly braces. */
-
-/* Copyright (C) 1987-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* Stuff in curly braces gets expanded before all other shell expansions. */
-
-#include "config.h"
-
-#if defined (BRACE_EXPANSION)
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <errno.h>
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#if defined (SHELL)
-#  include "shell.h"
-#else
-#  if defined (TEST)
-typedef char *WORD_DESC;
-typedef char **WORD_LIST;
-#define _(X)	X
-#  endif /* TEST */
-#endif /* SHELL */
-
-#include "typemax.h"		/* INTMAX_MIN, INTMAX_MAX */
-#include "general.h"
-#include "shmbutil.h"
-#include "chartypes.h"
-
-#ifndef errno
-extern int errno;
-#endif
-
-#define brace_whitespace(c) (!(c) || (c) == ' ' || (c) == '\t' || (c) == '\n')
-
-#define BRACE_SEQ_SPECIFIER	".."
-
-extern int asprintf PARAMS((char **, const char *, ...)) __attribute__((__format__ (printf, 2, 3)));
-
-/* Basic idea:
-
-   Segregate the text into 3 sections: preamble (stuff before an open brace),
-   postamble (stuff after the matching close brace) and amble (stuff after
-   preamble, and before postamble).  Expand amble, and then tack on the
-   expansions to preamble.  Expand postamble, and tack on the expansions to
-   the result so far.
- */
-
-/* The character which is used to separate arguments. */
-static const int brace_arg_separator = ',';
-
-#if defined (PARAMS)
-static int brace_gobbler PARAMS((char *, size_t, int *, int));
-static char **expand_amble PARAMS((char *, size_t, int));
-static char **expand_seqterm PARAMS((char *, size_t));
-static char **mkseq PARAMS((intmax_t, intmax_t, intmax_t, int, int));
-static char **array_concat PARAMS((char **, char **));
-#else
-static int brace_gobbler ();
-static char **expand_amble ();
-static char **expand_seqterm ();
-static char **mkseq();
-static char **array_concat ();
-#endif
-
-#if 0
-static void
-dump_result (a)
-     char **a;
-{
-  int i;
-
-  for (i = 0; a[i]; i++)
-    printf ("dump_result: a[%d] = -%s-\n", i, a[i]);
-}
-#endif
-
-/* Return an array of strings; the brace expansion of TEXT. */
-char **
-brace_expand (text)
-     char *text;
-{
-  register int start;
-  size_t tlen;
-  char *preamble, *postamble, *amble;
-  size_t alen;
-  char **tack, **result;
-  int i, j, c, c1;
-
-  DECLARE_MBSTATE;
-
-  /* Find the text of the preamble. */
-  tlen = strlen (text);
-  i = 0;
-#if defined (CSH_BRACE_COMPAT)
-  c = brace_gobbler (text, tlen, &i, '{');	/* } */
-#else
-  /* Make sure that when we exit this loop, c == 0 or text[i] begins a
-     valid brace expansion sequence. */
-  do
-    {
-      c = brace_gobbler (text, tlen, &i, '{');	/* } */
-      c1 = c;
-      /* Verify that c begins a valid brace expansion word.  If it doesn't, we
-	 go on.  Loop stops when there are no more open braces in the word. */
-      if (c)
-	{
-	  start = j = i + 1;	/* { */
-	  c = brace_gobbler (text, tlen, &j, '}');
-	  if (c == 0)		/* it's not */
-	    {
-	      i++;
-	      c = c1;
-	      continue;
-	    }
-	  else			/* it is */
-	    {
-	      c = c1;
-	      break;
-	    }
-	}
-      else
-	break;
-    }
-  while (c);
-#endif /* !CSH_BRACE_COMPAT */
-
-  preamble = (char *)xmalloc (i + 1);
-  if (i > 0)
-    strncpy (preamble, text, i);
-  preamble[i] = '\0';
-
-  result = (char **)xmalloc (2 * sizeof (char *));
-  result[0] = preamble;
-  result[1] = (char *)NULL;
-
-  /* Special case.  If we never found an exciting character, then
-     the preamble is all of the text, so just return that. */
-  if (c != '{')
-    return (result);
-
-  /* Find the amble.  This is the stuff inside this set of braces. */
-  start = ++i;
-  c = brace_gobbler (text, tlen, &i, '}');
-
-  /* What if there isn't a matching close brace? */
-  if (c == 0)
-    {
-#if defined (NOTDEF)
-      /* Well, if we found an unquoted BRACE_ARG_SEPARATOR between START
-	 and I, then this should be an error.  Otherwise, it isn't. */
-      j = start;
-      while (j < i)
-	{
-	  if (text[j] == '\\')
-	    {
-	      j++;
-	      ADVANCE_CHAR (text, tlen, j);
-	      continue;
-	    }
-
-	  if (text[j] == brace_arg_separator)
-	    {	/* { */
-	      strvec_dispose (result);
-	      set_exit_status (EXECUTION_FAILURE);
-	      report_error ("no closing `%c' in %s", '}', text);
-	      throw_to_top_level ();
-	    }
-	  ADVANCE_CHAR (text, tlen, j);
-	}
-#endif
-      free (preamble);		/* Same as result[0]; see initialization. */
-      result[0] = savestring (text);
-      return (result);
-    }
-
-#if defined (SHELL)
-  amble = substring (text, start, i);
-  alen = i - start;
-#else
-  amble = (char *)xmalloc (1 + (i - start));
-  strncpy (amble, &text[start], (i - start));
-  alen = i - start;
-  amble[alen] = '\0';
-#endif
-
-#if defined (SHELL)
-  INITIALIZE_MBSTATE;
-
-  /* If the amble does not contain an unquoted BRACE_ARG_SEPARATOR, then
-     just return without doing any expansion.  */
-  j = 0;
-  while (amble[j])
-    {
-      if (amble[j] == '\\')
-	{
-	  j++;
-	  ADVANCE_CHAR (amble, alen, j);
-	  continue;
-	}
-
-      if (amble[j] == brace_arg_separator)
-	break;
-
-      ADVANCE_CHAR (amble, alen, j);
-    }
-
-  if (amble[j] == 0)
-    {
-      tack = expand_seqterm (amble, alen);
-      if (tack)
-	goto add_tack;
-      else if (text[i + 1])
-	{
-	  /* If the sequence expansion fails (e.g., because the integers
-	     overflow), but there is more in the string, try and process
-	     the rest of the string, which may contain additional brace
-	     expansions.  Treat the unexpanded sequence term as a simple
-	     string (including the braces). */
-	  tack = strvec_create (2);
-	  tack[0] = savestring (text+start-1);
-	  tack[0][i-start+2] = '\0';
-	  tack[1] = (char *)0;
-	  goto add_tack;
-	}
-      else
-	{
-	  free (amble);
-	  free (preamble);
-	  result[0] = savestring (text);
-	  return (result);
-	}
-    }
-#endif /* SHELL */
-
-  tack = expand_amble (amble, alen, 0);
-add_tack:
-  result = array_concat (result, tack);
-  free (amble);
-  if (tack != result)
-    strvec_dispose (tack);
-
-  postamble = text + i + 1;
-
-  if (postamble && *postamble)
-    {
-      tack = brace_expand (postamble);
-      result = array_concat (result, tack);
-      if (tack != result)
-	strvec_dispose (tack);
-    }
-
-  return (result);
-}
-
-/* Expand the text found inside of braces.  We simply try to split the
-   text at BRACE_ARG_SEPARATORs into separate strings.  We then brace
-   expand each slot which needs it, until there are no more slots which
-   need it. */
-static char **
-expand_amble (text, tlen, flags)
-     char *text;
-     size_t tlen;
-     int flags;
-{
-  char **result, **partial, **tresult;
-  char *tem;
-  int start, i, c;
-
-#if defined (SHELL)
-  DECLARE_MBSTATE;
-#endif
-
-  result = (char **)NULL;
-
-  start = i = 0;
-  c = 1;
-  while (c)
-    {
-      c = brace_gobbler (text, tlen, &i, brace_arg_separator);
-#if defined (SHELL)
-      tem = substring (text, start, i);
-#else
-      tem = (char *)xmalloc (1 + (i - start));
-      strncpy (tem, &text[start], (i - start));
-      tem[i - start] = '\0';
-#endif
-
-      partial = brace_expand (tem);
-
-      if (!result)
-	result = partial;
-      else
-	{
-	  register int lr, lp, j;
-
-	  lr = strvec_len (result);
-	  lp = strvec_len (partial);
-
-	  tresult = strvec_mresize (result, lp + lr + 1);
-	  if (tresult == 0)
-	    {
-	      internal_error (_("brace expansion: cannot allocate memory for %s"), tem);
-	      free (tem);
-	      strvec_dispose (partial);
-	      strvec_dispose (result);
-	      result = (char **)NULL;
-	      return result;
-	    }
-	  else
-	    result = tresult;
-
-	  for (j = 0; j < lp; j++)
-	    result[lr + j] = partial[j];
-
-	  result[lr + j] = (char *)NULL;
-	  free (partial);
-	}
-      free (tem);
-#if defined (SHELL)
-      ADVANCE_CHAR (text, tlen, i);
-#else
-      i++;
-#endif
-      start = i;
-    }
-  return (result);
-}
-
-#define ST_BAD	0
-#define ST_INT	1
-#define ST_CHAR	2
-#define ST_ZINT	3
-
-static char **
-mkseq (start, end, incr, type, width)
-     intmax_t start, end, incr;
-     int type, width;
-{
-  intmax_t n, prevn;
-  int i, nelem;
-  char **result, *t;
-
-  if (incr == 0)
-    incr = 1;
-
-  if (start > end && incr > 0)
-    incr = -incr;
-  else if (start < end && incr < 0)
-    {
-      if (incr == INTMAX_MIN)		/* Don't use -INTMAX_MIN */
-	return ((char **)NULL);
-      incr = -incr;
-    }
-
-  /* Check that end-start will not overflow INTMAX_MIN, INTMAX_MAX.  The +3
-     and -2, not strictly necessary, are there because of the way the number
-     of elements and value passed to strvec_create() are calculated below. */
-  if (SUBOVERFLOW (end, start, INTMAX_MIN+3, INTMAX_MAX-2))
-    return ((char **)NULL);
-
-  prevn = sh_imaxabs (end - start);
-  /* Need to check this way in case INT_MAX == INTMAX_MAX */
-  if (INT_MAX == INTMAX_MAX && (ADDOVERFLOW (prevn, 2, INT_MIN, INT_MAX)))
-    return ((char **)NULL);
-  /* Make sure the assignment to nelem below doesn't end up <= 0 due to
-     intmax_t overflow */
-  else if (ADDOVERFLOW ((prevn/sh_imaxabs(incr)), 1, INTMAX_MIN, INTMAX_MAX))
-    return ((char **)NULL);
-
-  /* XXX - TOFIX: potentially allocating a lot of extra memory if
-     imaxabs(incr) != 1 */
-  /* Instead of a simple nelem = prevn + 1, something like:
-  	nelem = (prevn / imaxabs(incr)) + 1;
-     would work */
-  if ((prevn / sh_imaxabs (incr)) > INT_MAX - 3)	/* check int overflow */
-    return ((char **)NULL);
-  nelem = (prevn / sh_imaxabs(incr)) + 1;
-  result = strvec_mcreate (nelem + 1);
-  if (result == 0)
-    {
-      internal_error (_("brace expansion: failed to allocate memory for %u elements"), (unsigned int)nelem);
-      return ((char **)NULL);
-    }
-
-  /* Make sure we go through the loop at least once, so {3..3} prints `3' */
-  i = 0;
-  n = start;
-  do
-    {
-#if defined (SHELL)
-      if (ISINTERRUPT)
-        {
-          result[i] = (char *)NULL;
-          strvec_dispose (result);
-          result = (char **)NULL;
-        }
-      QUIT;
-#endif
-      if (type == ST_INT)
-	result[i++] = t = itos (n);
-      else if (type == ST_ZINT)
-	{
-	  int len, arg;
-	  arg = n;
-	  len = asprintf (&t, "%0*d", width, arg);
-	  result[i++] = t;
-	}
-      else
-	{
-	  if (t = (char *)malloc (2))
-	    {
-	      t[0] = n;
-	      t[1] = '\0';
-	    }
-	  result[i++] = t;
-	}
-
-      /* We failed to allocate memory for this number, so we bail. */
-      if (t == 0)
-	{
-	  char *p, lbuf[INT_STRLEN_BOUND(intmax_t) + 1];
-
-	  /* Easier to do this than mess around with various intmax_t printf
-	     formats (%ld? %lld? %jd?) and PRIdMAX. */
-	  p = inttostr (n, lbuf, sizeof (lbuf));
-	  internal_error (_("brace expansion: failed to allocate memory for `%s'"), p);
-	  strvec_dispose (result);
-	  return ((char **)NULL);
-	}
-
-      /* Handle overflow and underflow of n+incr */
-      if (ADDOVERFLOW (n, incr, INTMAX_MIN, INTMAX_MAX))
-        break;
-
-      n += incr;
-
-      if ((incr < 0 && n < end) || (incr > 0 && n > end))
-	break;
-    }
-  while (1);
-
-  result[i] = (char *)0;
-  return (result);
-}
-
-static char **
-expand_seqterm (text, tlen)
-     char *text;
-     size_t tlen;
-{
-  char *t, *lhs, *rhs;
-  int lhs_t, rhs_t, lhs_l, rhs_l, width;
-  intmax_t lhs_v, rhs_v, incr;
-  intmax_t tl, tr;
-  char **result, *ep, *oep;
-
-  t = strstr (text, BRACE_SEQ_SPECIFIER);
-  if (t == 0)
-    return ((char **)NULL);
-
-  lhs_l = t - text;		/* index of start of BRACE_SEQ_SPECIFIER */
-  lhs = substring (text, 0, lhs_l);
-  rhs = substring (text, lhs_l + sizeof(BRACE_SEQ_SPECIFIER) - 1, tlen);
-
-  if (lhs[0] == 0 || rhs[0] == 0)
-    {
-      free (lhs);
-      free (rhs);
-      return ((char **)NULL);
-    }
-
-  /* Now figure out whether LHS and RHS are integers or letters.  Both
-     sides have to match. */
-  lhs_t = (legal_number (lhs, &tl)) ? ST_INT :
-  		((ISALPHA (lhs[0]) && lhs[1] == 0) ?  ST_CHAR : ST_BAD);
-
-  /* Decide on rhs and whether or not it looks like the user specified
-     an increment */
-  ep = 0;
-  if (ISDIGIT (rhs[0]) || ((rhs[0] == '+' || rhs[0] == '-') && ISDIGIT (rhs[1])))
-    {
-      rhs_t = ST_INT;
-      errno = 0;
-      tr = strtoimax (rhs, &ep, 10);
-      if (errno == ERANGE || (ep && *ep != 0 && *ep != '.'))
-	rhs_t = ST_BAD;			/* invalid */
-    }
-  else if (ISALPHA (rhs[0]) && (rhs[1] == 0 || rhs[1] == '.'))
-    {
-      rhs_t = ST_CHAR;
-      ep = rhs + 1;
-    }
-  else
-    {
-      rhs_t = ST_BAD;
-      ep = 0;
-    }
-
-  incr = 1;
-  if (rhs_t != ST_BAD)
-    {
-      oep = ep;
-      errno = 0;
-      if (ep && *ep == '.' && ep[1] == '.' && ep[2])
-	incr = strtoimax (ep + 2, &ep, 10);
-      if (*ep != 0 || errno == ERANGE)
-	rhs_t = ST_BAD;			/* invalid incr or overflow */
-      tlen -= ep - oep;
-    }
-
-  if (lhs_t != rhs_t || lhs_t == ST_BAD || rhs_t == ST_BAD)
-    {
-      free (lhs);
-      free (rhs);
-      return ((char **)NULL);
-    }
-
-  /* OK, we have something.  It's either a sequence of integers, ascending
-     or descending, or a sequence or letters, ditto.  Generate the sequence,
-     put it into a string vector, and return it. */
-  
-  if (lhs_t == ST_CHAR)
-    {
-      lhs_v = (unsigned char)lhs[0];
-      rhs_v = (unsigned char)rhs[0];
-      width = 1;
-    }
-  else
-    {
-      lhs_v = tl;		/* integer truncation */
-      rhs_v = tr;
-
-      /* Decide whether or not the terms need zero-padding */
-      rhs_l = tlen - lhs_l - sizeof (BRACE_SEQ_SPECIFIER) + 1;
-      width = 0;
-      if (lhs_l > 1 && lhs[0] == '0')
-	width = lhs_l, lhs_t = ST_ZINT;
-      if (lhs_l > 2 && lhs[0] == '-' && lhs[1] == '0')
-	width = lhs_l, lhs_t = ST_ZINT;
-      if (rhs_l > 1 && rhs[0] == '0' && width < rhs_l)
-	width = rhs_l, lhs_t = ST_ZINT;
-      if (rhs_l > 2 && rhs[0] == '-' && rhs[1] == '0' && width < rhs_l)
-	width = rhs_l, lhs_t = ST_ZINT;
-
-      if (width < lhs_l && lhs_t == ST_ZINT)
-        width = lhs_l;
-      if (width < rhs_l && lhs_t == ST_ZINT)
-        width = rhs_l;
-    }
-
-  result = mkseq (lhs_v, rhs_v, incr, lhs_t, width);
-
-  free (lhs);
-  free (rhs);
-
-  return (result);
-}
-
-/* Start at INDEX, and skip characters in TEXT. Set INDEX to the
-   index of the character matching SATISFY.  This understands about
-   quoting.  Return the character that caused us to stop searching;
-   this is either the same as SATISFY, or 0. */
-/* If SATISFY is `}', we are looking for a brace expression, so we
-   should enforce the rules that govern valid brace expansions:
-	1) to count as an arg separator, a comma or `..' has to be outside
-	   an inner set of braces.	 
-*/
-static int
-brace_gobbler (text, tlen, indx, satisfy)
-     char *text;
-     size_t tlen;
-     int *indx;
-     int satisfy;
-{
-  register int i, c, quoted, level, commas, pass_next;
-#if defined (SHELL)
-  int si;
-  char *t;
-#endif
-  DECLARE_MBSTATE;
-
-  level = quoted = pass_next = 0;
-#if defined (CSH_BRACE_COMPAT)
-  commas = 1;
-#else
-  commas = (satisfy == '}') ? 0 : 1;
-#endif
-
-  i = *indx;
-  while (c = text[i])
-    {
-      if (pass_next)
-	{
-	  pass_next = 0;
-#if defined (SHELL)
-	  ADVANCE_CHAR (text, tlen, i);
-#else
-	  i++;
-#endif
-	  continue;
-	}
-
-      /* A backslash escapes the next character.  This allows backslash to
-	 escape the quote character in a double-quoted string. */
-      if (c == '\\' && (quoted == 0 || quoted == '"' || quoted == '`'))
-	{
-	  pass_next = 1;
-	  i++;
-	  continue;
-	}
-
-#if defined (SHELL)
-      /* If compiling for the shell, treat ${...} like \{...} */
-      if (c == '$' && text[i+1] == '{' && quoted != '\'')		/* } */
-	{
-	  pass_next = 1;
-	  i++;
-	  if (quoted == 0)
-	    level++;
-	  continue;
-	}
-#endif
-
-      if (quoted)
-	{
-	  if (c == quoted)
-	    quoted = 0;
-#if defined (SHELL)
-	  /* The shell allows quoted command substitutions */
-	  if (quoted == '"' && c == '$' && text[i+1] == '(')	/*)*/
-	    goto comsub;
-#endif
-#if defined (SHELL)
-	  ADVANCE_CHAR (text, tlen, i);
-#else
-	  i++;
-#endif
-	  continue;
-	}
-
-      if (c == '"' || c == '\'' || c == '`')
-	{
-	  quoted = c;
-	  i++;
-	  continue;
-	}
-
-#if defined (SHELL)
-      /* Pass new-style command and process substitutions through unchanged. */
-      if ((c == '$' || c == '<' || c == '>') && text[i+1] == '(')			/* ) */
-	{
-comsub:
-	  si = i + 2;
-	  t = extract_command_subst (text, &si, 0);
-	  i = si;
-	  free (t);
-	  i++;
-	  continue;
-	}
-#endif
-
-      if (c == satisfy && level == 0 && quoted == 0 && commas > 0)
-	{
-	  /* We ignore an open brace surrounded by whitespace, and also
-	     an open brace followed immediately by a close brace preceded
-	     by whitespace.  */
-	  if (c == '{' &&
-	      ((!i || brace_whitespace (text[i - 1])) &&
-	       (brace_whitespace (text[i + 1]) || text[i + 1] == '}')))
-	    {
-	      i++;
-	      continue;
-	    }
-
-	    break;
-	}
-
-      if (c == '{')
-	level++;
-      else if (c == '}' && level)
-	level--;
-#if !defined (CSH_BRACE_COMPAT)
-      else if (satisfy == '}' && c == brace_arg_separator && level == 0)
-	commas++;
-      else if (satisfy == '}' && STREQN (text+i, BRACE_SEQ_SPECIFIER, 2) &&
-      		text[i+2] != satisfy && level == 0)
-	commas++;
-#endif
-
-#if defined (SHELL)
-      ADVANCE_CHAR (text, tlen, i);
-#else
-      i++;
-#endif
-    }
-
-  *indx = i;
-  return (c);
-}
-
-/* Return a new array of strings which is the result of appending each
-   string in ARR2 to each string in ARR1.  The resultant array is
-   len (arr1) * len (arr2) long.  For convenience, ARR1 (and its contents)
-   are free ()'ed.  ARR1 can be NULL, in that case, a new version of ARR2
-   is returned. */
-static char **
-array_concat (arr1, arr2)
-     char **arr1, **arr2;
-{
-  register int i, j, len, len1, len2;
-  register char **result;
-
-  if (arr1 == 0)
-    return (arr2);		/* XXX - see if we can get away without copying? */
-
-  if (arr2 == 0)
-    return (arr1);		/* XXX - caller expects us to free arr1 */
-
-  /* We can only short-circuit if the array consists of a single null element;
-     otherwise we need to replicate the contents of the other array and
-     prefix (or append, below) an empty element to each one. */
-  if (arr1[0] && arr1[0][0] == 0 && arr1[1] == 0)
-    {
-      strvec_dispose (arr1);
-      return (arr2);		/* XXX - use flags to see if we can avoid copying here */
-    }
-
-  if (arr2[0] && arr2[0][0] == 0 && arr2[1] == 0)
-    return (arr1);		/* XXX - rather than copying and freeing it */
-
-  len1 = strvec_len (arr1);
-  len2 = strvec_len (arr2);
-
-  result = (char **)malloc ((1 + (len1 * len2)) * sizeof (char *));
-  if (result == 0)
-    return (result);
-
-  len = 0;
-  for (i = 0; i < len1; i++)
-    {
-      int strlen_1 = strlen (arr1[i]);
-
-      for (j = 0; j < len2; j++)
-	{
-	  result[len] = (char *)xmalloc (1 + strlen_1 + strlen (arr2[j]));
-	  strcpy (result[len], arr1[i]);
-	  strcpy (result[len] + strlen_1, arr2[j]);
-	  len++;
-	}
-      free (arr1[i]);
-    }
-  free (arr1);
-
-  result[len] = (char *)NULL;
-  return (result);
-}
-
-#if defined (TEST)
-#include <stdio.h>
-
-void *
-xmalloc(n)
-     size_t n;
-{
-  return (malloc (n));
-}
-
-void *
-xrealloc(p, n)
-     void *p;
-     size_t n;
-{
-  return (realloc (p, n));
-}
-
-int
-internal_error (format, arg1, arg2)
-     char *format, *arg1, *arg2;
-{
-  fprintf (stderr, format, arg1, arg2);
-  fprintf (stderr, "\n");
-}
-      
-main ()
-{
-  char example[256];
-
-  for (;;)
-    {
-      char **result;
-      int i;
-
-      fprintf (stderr, "brace_expand> ");
-
-      if ((!fgets (example, 256, stdin)) ||
-	  (strncmp (example, "quit", 4) == 0))
-	break;
-
-      if (strlen (example))
-	example[strlen (example) - 1] = '\0';
-
-      result = brace_expand (example);
-
-      for (i = 0; result[i]; i++)
-	printf ("%s\n", result[i]);
-
-      strvec_dispose (result);
-    }
-}
-
-/*
- * Local variables:
- * compile-command: "gcc -g -Bstatic -DTEST -o brace_expand braces.c general.o"
- * end:
- */
-
-#endif /* TEST */
-#endif /* BRACE_EXPANSION */
diff --git a/third_party/bash/break.c b/third_party/bash/break.c
deleted file mode 100644
index 827b1a556..000000000
--- a/third_party/bash/break.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/* break.c, created from break.def. */
-#line 22 "./break.def"
-
-#line 34 "./break.def"
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "common.h"
-
-static int check_loop_level PARAMS((void));
-
-/* The depth of while's and until's. */
-int loop_level = 0;
-
-/* Non-zero when a "break" instruction is encountered. */
-int breaking = 0;
-
-/* Non-zero when we have encountered a continue instruction. */
-int continuing = 0;
-
-/* Set up to break x levels, where x defaults to 1, but can be specified
-   as the first argument. */
-int
-break_builtin (list)
-     WORD_LIST *list;
-{
-  intmax_t newbreak;
-
-  CHECK_HELPOPT (list);
-
-  if (check_loop_level () == 0)
-    return (EXECUTION_SUCCESS);
-
-  (void)get_numeric_arg (list, 1, &newbreak);
-
-  if (newbreak <= 0)
-    {
-      sh_erange (list->word->word, _("loop count"));
-      breaking = loop_level;
-      return (EXECUTION_FAILURE);
-    }
-
-  if (newbreak > loop_level)
-    newbreak = loop_level;
-
-  breaking = newbreak;
-
-  return (EXECUTION_SUCCESS);
-}
-
-#line 101 "./break.def"
-
-/* Set up to continue x levels, where x defaults to 1, but can be specified
-   as the first argument. */
-int
-continue_builtin (list)
-     WORD_LIST *list;
-{
-  intmax_t newcont;
-
-  CHECK_HELPOPT (list);
-
-  if (check_loop_level () == 0)
-    return (EXECUTION_SUCCESS);
-
-  (void)get_numeric_arg (list, 1, &newcont);
-
-  if (newcont <= 0)
-    {
-      sh_erange (list->word->word, _("loop count"));
-      breaking = loop_level;
-      return (EXECUTION_FAILURE);
-    }
-
-  if (newcont > loop_level)
-    newcont = loop_level;
-
-  continuing = newcont;
-
-  return (EXECUTION_SUCCESS);
-}
-
-/* Return non-zero if a break or continue command would be okay.
-   Print an error message if break or continue is meaningless here. */
-static int
-check_loop_level ()
-{
-#if defined (BREAK_COMPLAINS)
-  if (loop_level == 0 && posixly_correct == 0)
-    builtin_error (_("only meaningful in a `for', `while', or `until' loop"));
-#endif /* BREAK_COMPLAINS */
-
-  return (loop_level);
-}
diff --git a/third_party/bash/builtext.h b/third_party/bash/builtext.h
deleted file mode 100644
index a7723fa10..000000000
--- a/third_party/bash/builtext.h
+++ /dev/null
@@ -1,188 +0,0 @@
-/* builtext.h - The list of builtins found in libbuiltins.a. */
-#if defined (ALIAS)
-extern int alias_builtin PARAMS((WORD_LIST *));
-extern char * const alias_doc[];
-#endif /* ALIAS */
-#if defined (ALIAS)
-extern int unalias_builtin PARAMS((WORD_LIST *));
-extern char * const unalias_doc[];
-#endif /* ALIAS */
-#if defined (READLINE)
-extern int bind_builtin PARAMS((WORD_LIST *));
-extern char * const bind_doc[];
-#endif /* READLINE */
-extern int break_builtin PARAMS((WORD_LIST *));
-extern char * const break_doc[];
-extern int continue_builtin PARAMS((WORD_LIST *));
-extern char * const continue_doc[];
-extern int builtin_builtin PARAMS((WORD_LIST *));
-extern char * const builtin_doc[];
-#if defined (DEBUGGER)
-extern int caller_builtin PARAMS((WORD_LIST *));
-extern char * const caller_doc[];
-#endif /* DEBUGGER */
-extern int cd_builtin PARAMS((WORD_LIST *));
-extern char * const cd_doc[];
-extern int pwd_builtin PARAMS((WORD_LIST *));
-extern char * const pwd_doc[];
-extern int colon_builtin PARAMS((WORD_LIST *));
-extern char * const colon_doc[];
-extern int colon_builtin PARAMS((WORD_LIST *));
-extern char * const true_doc[];
-extern int false_builtin PARAMS((WORD_LIST *));
-extern char * const false_doc[];
-extern int command_builtin PARAMS((WORD_LIST *));
-extern char * const command_doc[];
-extern int declare_builtin PARAMS((WORD_LIST *));
-extern char * const declare_doc[];
-extern int declare_builtin PARAMS((WORD_LIST *));
-extern char * const typeset_doc[];
-extern int local_builtin PARAMS((WORD_LIST *));
-extern char * const local_doc[];
-#if defined (V9_ECHO)
-extern int echo_builtin PARAMS((WORD_LIST *));
-extern char * const echo_doc[];
-#endif /* V9_ECHO */
-#if !defined (V9_ECHO)
-extern int echo_builtin PARAMS((WORD_LIST *));
-extern char * const echo_doc[];
-#endif /* !V9_ECHO */
-extern int enable_builtin PARAMS((WORD_LIST *));
-extern char * const enable_doc[];
-extern int eval_builtin PARAMS((WORD_LIST *));
-extern char * const eval_doc[];
-extern int getopts_builtin PARAMS((WORD_LIST *));
-extern char * const getopts_doc[];
-extern int exec_builtin PARAMS((WORD_LIST *));
-extern char * const exec_doc[];
-extern int exit_builtin PARAMS((WORD_LIST *));
-extern char * const exit_doc[];
-extern int logout_builtin PARAMS((WORD_LIST *));
-extern char * const logout_doc[];
-#if defined (HISTORY)
-extern int fc_builtin PARAMS((WORD_LIST *));
-extern char * const fc_doc[];
-#endif /* HISTORY */
-#if defined (JOB_CONTROL)
-extern int fg_builtin PARAMS((WORD_LIST *));
-extern char * const fg_doc[];
-#endif /* JOB_CONTROL */
-#if defined (JOB_CONTROL)
-extern int bg_builtin PARAMS((WORD_LIST *));
-extern char * const bg_doc[];
-#endif /* JOB_CONTROL */
-extern int hash_builtin PARAMS((WORD_LIST *));
-extern char * const hash_doc[];
-#if defined (HELP_BUILTIN)
-extern int help_builtin PARAMS((WORD_LIST *));
-extern char * const help_doc[];
-#endif /* HELP_BUILTIN */
-#if defined (HISTORY)
-extern int history_builtin PARAMS((WORD_LIST *));
-extern char * const history_doc[];
-#endif /* HISTORY */
-#if defined (JOB_CONTROL)
-extern int jobs_builtin PARAMS((WORD_LIST *));
-extern char * const jobs_doc[];
-#endif /* JOB_CONTROL */
-#if defined (JOB_CONTROL)
-extern int disown_builtin PARAMS((WORD_LIST *));
-extern char * const disown_doc[];
-#endif /* JOB_CONTROL */
-extern int kill_builtin PARAMS((WORD_LIST *));
-extern char * const kill_doc[];
-extern int let_builtin PARAMS((WORD_LIST *));
-extern char * const let_doc[];
-extern int read_builtin PARAMS((WORD_LIST *));
-extern char * const read_doc[];
-extern int return_builtin PARAMS((WORD_LIST *));
-extern char * const return_doc[];
-extern int set_builtin PARAMS((WORD_LIST *));
-extern char * const set_doc[];
-extern int unset_builtin PARAMS((WORD_LIST *));
-extern char * const unset_doc[];
-extern int export_builtin PARAMS((WORD_LIST *));
-extern char * const export_doc[];
-extern int readonly_builtin PARAMS((WORD_LIST *));
-extern char * const readonly_doc[];
-extern int shift_builtin PARAMS((WORD_LIST *));
-extern char * const shift_doc[];
-extern int source_builtin PARAMS((WORD_LIST *));
-extern char * const source_doc[];
-extern int source_builtin PARAMS((WORD_LIST *));
-extern char * const dot_doc[];
-#if defined (JOB_CONTROL)
-extern int suspend_builtin PARAMS((WORD_LIST *));
-extern char * const suspend_doc[];
-#endif /* JOB_CONTROL */
-extern int test_builtin PARAMS((WORD_LIST *));
-extern char * const test_doc[];
-extern int test_builtin PARAMS((WORD_LIST *));
-extern char * const test_bracket_doc[];
-extern int times_builtin PARAMS((WORD_LIST *));
-extern char * const times_doc[];
-extern int trap_builtin PARAMS((WORD_LIST *));
-extern char * const trap_doc[];
-extern int type_builtin PARAMS((WORD_LIST *));
-extern char * const type_doc[];
-#if !defined (_MINIX)
-extern int ulimit_builtin PARAMS((WORD_LIST *));
-extern char * const ulimit_doc[];
-#endif /* !_MINIX */
-extern int umask_builtin PARAMS((WORD_LIST *));
-extern char * const umask_doc[];
-#if defined (JOB_CONTROL)
-extern int wait_builtin PARAMS((WORD_LIST *));
-extern char * const wait_doc[];
-#endif /* JOB_CONTROL */
-#if !defined (JOB_CONTROL)
-extern int wait_builtin PARAMS((WORD_LIST *));
-extern char * const wait_doc[];
-#endif /* !JOB_CONTROL */
-extern char * const for_doc[];
-extern char * const arith_for_doc[];
-extern char * const select_doc[];
-extern char * const time_doc[];
-extern char * const case_doc[];
-extern char * const if_doc[];
-extern char * const while_doc[];
-extern char * const until_doc[];
-extern char * const coproc_doc[];
-extern char * const function_doc[];
-extern char * const grouping_braces_doc[];
-extern char * const fg_percent_doc[];
-extern char * const arith_doc[];
-extern char * const conditional_doc[];
-extern char * const variable_help_doc[];
-#if defined (PUSHD_AND_POPD)
-extern int pushd_builtin PARAMS((WORD_LIST *));
-extern char * const pushd_doc[];
-#endif /* PUSHD_AND_POPD */
-#if defined (PUSHD_AND_POPD)
-extern int popd_builtin PARAMS((WORD_LIST *));
-extern char * const popd_doc[];
-#endif /* PUSHD_AND_POPD */
-#if defined (PUSHD_AND_POPD)
-extern int dirs_builtin PARAMS((WORD_LIST *));
-extern char * const dirs_doc[];
-#endif /* PUSHD_AND_POPD */
-extern int shopt_builtin PARAMS((WORD_LIST *));
-extern char * const shopt_doc[];
-extern int printf_builtin PARAMS((WORD_LIST *));
-extern char * const printf_doc[];
-#if defined (PROGRAMMABLE_COMPLETION)
-extern int complete_builtin PARAMS((WORD_LIST *));
-extern char * const complete_doc[];
-#endif /* PROGRAMMABLE_COMPLETION */
-#if defined (PROGRAMMABLE_COMPLETION)
-extern int compgen_builtin PARAMS((WORD_LIST *));
-extern char * const compgen_doc[];
-#endif /* PROGRAMMABLE_COMPLETION */
-#if defined (PROGRAMMABLE_COMPLETION)
-extern int compopt_builtin PARAMS((WORD_LIST *));
-extern char * const compopt_doc[];
-#endif /* PROGRAMMABLE_COMPLETION */
-extern int mapfile_builtin PARAMS((WORD_LIST *));
-extern char * const mapfile_doc[];
-extern int mapfile_builtin PARAMS((WORD_LIST *));
-extern char * const readarray_doc[];
diff --git a/third_party/bash/builtins.c b/third_party/bash/builtins.c
deleted file mode 100644
index 3d5fffc26..000000000
--- a/third_party/bash/builtins.c
+++ /dev/null
@@ -1,2093 +0,0 @@
-/* builtins.c -- the built in shell commands. */
-
-/* This file is manufactured by ./mkbuiltins, and should not be
-   edited by hand.  See the source to mkbuiltins for details. */
-
-/* Copyright (C) 1987-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* The list of shell builtins.  Each element is name, function, flags,
-   long-doc, short-doc.  The long-doc field contains a pointer to an array
-   of help lines.  The function takes a WORD_LIST *; the first word in the
-   list is the first arg to the command.  The list has already had word
-   expansion performed.
-
-   Functions which need to look at only the simple commands (e.g.
-   the enable_builtin ()), should ignore entries where
-   (array[i].function == (sh_builtin_func_t *)NULL).  Such entries are for
-   the list of shell reserved control structures, like `if' and `while'.
-   The end of the list is denoted with a NULL name field. */
-
-/* TRANSLATORS: Please do not translate command names in descriptions */
-
-#include "builtins.h"
-#include "builtext.h"
-#include "bashintl.h"
-
-struct builtin static_shell_builtins[] = {
-#if defined (ALIAS)
-  { "alias", alias_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | ASSIGNMENT_BUILTIN | POSIX_BUILTIN, alias_doc,
-     N_("alias [-p] [name[=value] ... ]"), (char *)NULL },
-#endif /* ALIAS */
-#if defined (ALIAS)
-  { "unalias", unalias_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, unalias_doc,
-     N_("unalias [-a] name [name ...]"), (char *)NULL },
-#endif /* ALIAS */
-#if defined (READLINE)
-  { "bind", bind_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, bind_doc,
-     N_("bind [-lpsvPSVX] [-m keymap] [-f filename] [-q name] [-u name] [-r keyseq] [-x keyseq:shell-command] [keyseq:readline-function or readline-command]"), (char *)NULL },
-#endif /* READLINE */
-  { "break", break_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, break_doc,
-     N_("break [n]"), (char *)NULL },
-  { "continue", continue_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, continue_doc,
-     N_("continue [n]"), (char *)NULL },
-  { "builtin", builtin_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, builtin_doc,
-     N_("builtin [shell-builtin [arg ...]]"), (char *)NULL },
-#if defined (DEBUGGER)
-  { "caller", caller_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, caller_doc,
-     N_("caller [expr]"), (char *)NULL },
-#endif /* DEBUGGER */
-  { "cd", cd_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, cd_doc,
-     N_("cd [-L|[-P [-e]] [-@]] [dir]"), (char *)NULL },
-  { "pwd", pwd_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, pwd_doc,
-     N_("pwd [-LP]"), (char *)NULL },
-  { ":", colon_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, colon_doc,
-     ":", (char *)NULL },
-  { "true", colon_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, true_doc,
-     "true", (char *)NULL },
-  { "false", false_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, false_doc,
-     "false", (char *)NULL },
-  { "command", command_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, command_doc,
-     N_("command [-pVv] command [arg ...]"), (char *)NULL },
-  { "declare", declare_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | ASSIGNMENT_BUILTIN | LOCALVAR_BUILTIN | ARRAYREF_BUILTIN, declare_doc,
-     N_("declare [-aAfFgiIlnrtux] [name[=value] ...] or declare -p [-aAfFilnrtux] [name ...]"), (char *)NULL },
-  { "typeset", declare_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | ASSIGNMENT_BUILTIN | LOCALVAR_BUILTIN | ARRAYREF_BUILTIN, typeset_doc,
-     N_("typeset [-aAfFgiIlnrtux] name[=value] ... or typeset -p [-aAfFilnrtux] [name ...]"), (char *)NULL },
-  { "local", local_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | ASSIGNMENT_BUILTIN | LOCALVAR_BUILTIN | ARRAYREF_BUILTIN, local_doc,
-     N_("local [option] name[=value] ..."), (char *)NULL },
-#if defined (V9_ECHO)
-  { "echo", echo_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, echo_doc,
-     N_("echo [-neE] [arg ...]"), (char *)NULL },
-#endif /* V9_ECHO */
-#if !defined (V9_ECHO)
-  { "echo", echo_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, echo_doc,
-     N_("echo [-n] [arg ...]"), (char *)NULL },
-#endif /* !V9_ECHO */
-  { "enable", enable_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, enable_doc,
-     N_("enable [-a] [-dnps] [-f filename] [name ...]"), (char *)NULL },
-  { "eval", eval_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, eval_doc,
-     N_("eval [arg ...]"), (char *)NULL },
-  { "getopts", getopts_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, getopts_doc,
-     N_("getopts optstring name [arg ...]"), (char *)NULL },
-  { "exec", exec_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, exec_doc,
-     N_("exec [-cl] [-a name] [command [argument ...]] [redirection ...]"), (char *)NULL },
-  { "exit", exit_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, exit_doc,
-     N_("exit [n]"), (char *)NULL },
-  { "logout", logout_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, logout_doc,
-     N_("logout [n]"), (char *)NULL },
-#if defined (HISTORY)
-  { "fc", fc_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, fc_doc,
-     N_("fc [-e ename] [-lnr] [first] [last] or fc -s [pat=rep] [command]"), (char *)NULL },
-#endif /* HISTORY */
-#if defined (JOB_CONTROL)
-  { "fg", fg_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, fg_doc,
-     N_("fg [job_spec]"), (char *)NULL },
-#endif /* JOB_CONTROL */
-#if defined (JOB_CONTROL)
-  { "bg", bg_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, bg_doc,
-     N_("bg [job_spec ...]"), (char *)NULL },
-#endif /* JOB_CONTROL */
-  { "hash", hash_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, hash_doc,
-     N_("hash [-lr] [-p pathname] [-dt] [name ...]"), (char *)NULL },
-#if defined (HELP_BUILTIN)
-  { "help", help_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, help_doc,
-     N_("help [-dms] [pattern ...]"), (char *)NULL },
-#endif /* HELP_BUILTIN */
-#if defined (HISTORY)
-  { "history", history_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, history_doc,
-     N_("history [-c] [-d offset] [n] or history -anrw [filename] or history -ps arg [arg...]"), (char *)NULL },
-#endif /* HISTORY */
-#if defined (JOB_CONTROL)
-  { "jobs", jobs_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, jobs_doc,
-     N_("jobs [-lnprs] [jobspec ...] or jobs -x command [args]"), (char *)NULL },
-#endif /* JOB_CONTROL */
-#if defined (JOB_CONTROL)
-  { "disown", disown_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, disown_doc,
-     N_("disown [-h] [-ar] [jobspec ... | pid ...]"), (char *)NULL },
-#endif /* JOB_CONTROL */
-  { "kill", kill_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, kill_doc,
-     N_("kill [-s sigspec | -n signum | -sigspec] pid | jobspec ... or kill -l [sigspec]"), (char *)NULL },
-  { "let", let_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | ARRAYREF_BUILTIN, let_doc,
-     N_("let arg [arg ...]"), (char *)NULL },
-  { "read", read_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN | ARRAYREF_BUILTIN, read_doc,
-     N_("read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]"), (char *)NULL },
-  { "return", return_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, return_doc,
-     N_("return [n]"), (char *)NULL },
-  { "set", set_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, set_doc,
-     N_("set [-abefhkmnptuvxBCEHPT] [-o option-name] [--] [-] [arg ...]"), (char *)NULL },
-  { "unset", unset_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN | ARRAYREF_BUILTIN, unset_doc,
-     N_("unset [-f] [-v] [-n] [name ...]"), (char *)NULL },
-  { "export", export_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN | ASSIGNMENT_BUILTIN, export_doc,
-     N_("export [-fn] [name[=value] ...] or export -p"), (char *)NULL },
-  { "readonly", readonly_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN | ASSIGNMENT_BUILTIN, readonly_doc,
-     N_("readonly [-aAf] [name[=value] ...] or readonly -p"), (char *)NULL },
-  { "shift", shift_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, shift_doc,
-     N_("shift [n]"), (char *)NULL },
-  { "source", source_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, source_doc,
-     N_("source filename [arguments]"), (char *)NULL },
-  { ".", source_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, dot_doc,
-     N_(". filename [arguments]"), (char *)NULL },
-#if defined (JOB_CONTROL)
-  { "suspend", suspend_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, suspend_doc,
-     N_("suspend [-f]"), (char *)NULL },
-#endif /* JOB_CONTROL */
-  { "test", test_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | ARRAYREF_BUILTIN, test_doc,
-     N_("test [expr]"), (char *)NULL },
-  { "[", test_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | ARRAYREF_BUILTIN, test_bracket_doc,
-     N_("[ arg... ]"), (char *)NULL },
-  { "times", times_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, times_doc,
-     "times", (char *)NULL },
-  { "trap", trap_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | SPECIAL_BUILTIN, trap_doc,
-     N_("trap [-lp] [[arg] signal_spec ...]"), (char *)NULL },
-  { "type", type_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, type_doc,
-     N_("type [-afptP] name [name ...]"), (char *)NULL },
-#if !defined (_MINIX)
-  { "ulimit", ulimit_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, ulimit_doc,
-     N_("ulimit [-SHabcdefiklmnpqrstuvxPRT] [limit]"), (char *)NULL },
-#endif /* !_MINIX */
-  { "umask", umask_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN, umask_doc,
-     N_("umask [-p] [-S] [mode]"), (char *)NULL },
-#if defined (JOB_CONTROL)
-  { "wait", wait_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN | ARRAYREF_BUILTIN, wait_doc,
-     N_("wait [-fn] [-p var] [id ...]"), (char *)NULL },
-#endif /* JOB_CONTROL */
-#if !defined (JOB_CONTROL)
-  { "wait", wait_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | POSIX_BUILTIN | ARRAYREF_BUILTIN, wait_doc,
-     N_("wait [pid ...]"), (char *)NULL },
-#endif /* !JOB_CONTROL */
-  { "for", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, for_doc,
-     N_("for NAME [in WORDS ... ] ; do COMMANDS; done"), (char *)NULL },
-  { "for ((", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, arith_for_doc,
-     N_("for (( exp1; exp2; exp3 )); do COMMANDS; done"), (char *)NULL },
-  { "select", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, select_doc,
-     N_("select NAME [in WORDS ... ;] do COMMANDS; done"), (char *)NULL },
-  { "time", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, time_doc,
-     N_("time [-p] pipeline"), (char *)NULL },
-  { "case", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, case_doc,
-     N_("case WORD in [PATTERN [| PATTERN]...) COMMANDS ;;]... esac"), (char *)NULL },
-  { "if", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, if_doc,
-     N_("if COMMANDS; then COMMANDS; [ elif COMMANDS; then COMMANDS; ]... [ else COMMANDS; ] fi"), (char *)NULL },
-  { "while", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, while_doc,
-     N_("while COMMANDS; do COMMANDS-2; done"), (char *)NULL },
-  { "until", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, until_doc,
-     N_("until COMMANDS; do COMMANDS-2; done"), (char *)NULL },
-  { "coproc", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, coproc_doc,
-     N_("coproc [NAME] command [redirections]"), (char *)NULL },
-  { "function", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, function_doc,
-     N_("function name { COMMANDS ; } or name () { COMMANDS ; }"), (char *)NULL },
-  { "{ ... }", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, grouping_braces_doc,
-     N_("{ COMMANDS ; }"), (char *)NULL },
-  { "%", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, fg_percent_doc,
-     N_("job_spec [&]"), (char *)NULL },
-  { "(( ... ))", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, arith_doc,
-     N_("(( expression ))"), (char *)NULL },
-  { "[[ ... ]]", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, conditional_doc,
-     N_("[[ expression ]]"), (char *)NULL },
-  { "variables", (sh_builtin_func_t *)0x0, BUILTIN_ENABLED | STATIC_BUILTIN, variable_help_doc,
-     N_("variables - Names and meanings of some shell variables"), (char *)NULL },
-#if defined (PUSHD_AND_POPD)
-  { "pushd", pushd_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, pushd_doc,
-     N_("pushd [-n] [+N | -N | dir]"), (char *)NULL },
-#endif /* PUSHD_AND_POPD */
-#if defined (PUSHD_AND_POPD)
-  { "popd", popd_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, popd_doc,
-     N_("popd [-n] [+N | -N]"), (char *)NULL },
-#endif /* PUSHD_AND_POPD */
-#if defined (PUSHD_AND_POPD)
-  { "dirs", dirs_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, dirs_doc,
-     N_("dirs [-clpv] [+N] [-N]"), (char *)NULL },
-#endif /* PUSHD_AND_POPD */
-  { "shopt", shopt_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, shopt_doc,
-     N_("shopt [-pqsu] [-o] [optname ...]"), (char *)NULL },
-  { "printf", printf_builtin, BUILTIN_ENABLED | STATIC_BUILTIN | ARRAYREF_BUILTIN, printf_doc,
-     N_("printf [-v var] format [arguments]"), (char *)NULL },
-#if defined (PROGRAMMABLE_COMPLETION)
-  { "complete", complete_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, complete_doc,
-     N_("complete [-abcdefgjksuv] [-pr] [-DEI] [-o option] [-A action] [-G globpat] [-W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [name ...]"), (char *)NULL },
-#endif /* PROGRAMMABLE_COMPLETION */
-#if defined (PROGRAMMABLE_COMPLETION)
-  { "compgen", compgen_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, compgen_doc,
-     N_("compgen [-abcdefgjksuv] [-o option] [-A action] [-G globpat] [-W wordlist] [-F function] [-C command] [-X filterpat] [-P prefix] [-S suffix] [word]"), (char *)NULL },
-#endif /* PROGRAMMABLE_COMPLETION */
-#if defined (PROGRAMMABLE_COMPLETION)
-  { "compopt", compopt_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, compopt_doc,
-     N_("compopt [-o|+o option] [-DEI] [name ...]"), (char *)NULL },
-#endif /* PROGRAMMABLE_COMPLETION */
-  { "mapfile", mapfile_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, mapfile_doc,
-     N_("mapfile [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]"), (char *)NULL },
-  { "readarray", mapfile_builtin, BUILTIN_ENABLED | STATIC_BUILTIN, readarray_doc,
-     N_("readarray [-d delim] [-n count] [-O origin] [-s count] [-t] [-u fd] [-C callback] [-c quantum] [array]"), (char *)NULL },
-  { (char *)0x0, (sh_builtin_func_t *)0x0, 0, (char **)0x0, (char *)0x0, (char *)0x0 }
-};
-
-struct builtin *shell_builtins = static_shell_builtins;
-struct builtin *current_builtin;
-
-int num_shell_builtins =
-	sizeof (static_shell_builtins) / sizeof (struct builtin) - 1;
-#if defined (ALIAS)
-char * const alias_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Define or display aliases.\n\
-    \n\
-    Without arguments, `alias' prints the list of aliases in the reusable\n\
-    form `alias NAME=VALUE' on standard output.\n\
-    \n\
-    Otherwise, an alias is defined for each NAME whose VALUE is given.\n\
-    A trailing space in VALUE causes the next word to be checked for\n\
-    alias substitution when the alias is expanded.\n\
-    \n\
-    Options:\n\
-      -p	print all defined aliases in a reusable format\n\
-    \n\
-    Exit Status:\n\
-    alias returns true unless a NAME is supplied for which no alias has been\n\
-    defined."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* ALIAS */
-#if defined (ALIAS)
-char * const unalias_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Remove each NAME from the list of defined aliases.\n\
-    \n\
-    Options:\n\
-      -a	remove all alias definitions\n\
-    \n\
-    Return success unless a NAME is not an existing alias."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* ALIAS */
-#if defined (READLINE)
-char * const bind_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Set Readline key bindings and variables.\n\
-    \n\
-    Bind a key sequence to a Readline function or a macro, or set a\n\
-    Readline variable.  The non-option argument syntax is equivalent to\n\
-    that found in ~/.inputrc, but must be passed as a single argument:\n\
-    e.g., bind '\"\\C-x\\C-r\": re-read-init-file'.\n\
-    \n\
-    Options:\n\
-      -m  keymap         Use KEYMAP as the keymap for the duration of this\n\
-                         command.  Acceptable keymap names are emacs,\n\
-                         emacs-standard, emacs-meta, emacs-ctlx, vi, vi-move,\n\
-                         vi-command, and vi-insert.\n\
-      -l                 List names of functions.\n\
-      -P                 List function names and bindings.\n\
-      -p                 List functions and bindings in a form that can be\n\
-                         reused as input.\n\
-      -S                 List key sequences that invoke macros and their values\n\
-      -s                 List key sequences that invoke macros and their values\n\
-                         in a form that can be reused as input.\n\
-      -V                 List variable names and values\n\
-      -v                 List variable names and values in a form that can\n\
-                         be reused as input.\n\
-      -q  function-name  Query about which keys invoke the named function.\n\
-      -u  function-name  Unbind all keys which are bound to the named function.\n\
-      -r  keyseq         Remove the binding for KEYSEQ.\n\
-      -f  filename       Read key bindings from FILENAME.\n\
-      -x  keyseq:shell-command	Cause SHELL-COMMAND to be executed when\n\
-    				KEYSEQ is entered.\n\
-      -X                 List key sequences bound with -x and associated commands\n\
-                         in a form that can be reused as input.\n\
-    \n\
-    Exit Status:\n\
-    bind returns 0 unless an unrecognized option is given or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* READLINE */
-char * const break_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Exit for, while, or until loops.\n\
-    \n\
-    Exit a FOR, WHILE or UNTIL loop.  If N is specified, break N enclosing\n\
-    loops.\n\
-    \n\
-    Exit Status:\n\
-    The exit status is 0 unless N is not greater than or equal to 1."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const continue_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Resume for, while, or until loops.\n\
-    \n\
-    Resumes the next iteration of the enclosing FOR, WHILE or UNTIL loop.\n\
-    If N is specified, resumes the Nth enclosing loop.\n\
-    \n\
-    Exit Status:\n\
-    The exit status is 0 unless N is not greater than or equal to 1."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const builtin_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute shell builtins.\n\
-    \n\
-    Execute SHELL-BUILTIN with arguments ARGs without performing command\n\
-    lookup.  This is useful when you wish to reimplement a shell builtin\n\
-    as a shell function, but need to execute the builtin within the function.\n\
-    \n\
-    Exit Status:\n\
-    Returns the exit status of SHELL-BUILTIN, or false if SHELL-BUILTIN is\n\
-    not a shell builtin."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#if defined (DEBUGGER)
-char * const caller_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Return the context of the current subroutine call.\n\
-    \n\
-    Without EXPR, returns \"$line $filename\".  With EXPR, returns\n\
-    \"$line $subroutine $filename\"; this extra information can be used to\n\
-    provide a stack trace.\n\
-    \n\
-    The value of EXPR indicates how many call frames to go back before the\n\
-    current one; the top frame is frame 0.\n\
-    \n\
-    Exit Status:\n\
-    Returns 0 unless the shell is not executing a shell function or EXPR\n\
-    is invalid."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* DEBUGGER */
-char * const cd_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Change the shell working directory.\n\
-    \n\
-    Change the current directory to DIR.  The default DIR is the value of the\n\
-    HOME shell variable. If DIR is \"-\", it is converted to $OLDPWD.\n\
-    \n\
-    The variable CDPATH defines the search path for the directory containing\n\
-    DIR.  Alternative directory names in CDPATH are separated by a colon (:).\n\
-    A null directory name is the same as the current directory.  If DIR begins\n\
-    with a slash (/), then CDPATH is not used.\n\
-    \n\
-    If the directory is not found, and the shell option `cdable_vars' is set,\n\
-    the word is assumed to be  a variable name.  If that variable has a value,\n\
-    its value is used for DIR.\n\
-    \n\
-    Options:\n\
-      -L	force symbolic links to be followed: resolve symbolic\n\
-    		links in DIR after processing instances of `..'\n\
-      -P	use the physical directory structure without following\n\
-    		symbolic links: resolve symbolic links in DIR before\n\
-    		processing instances of `..'\n\
-      -e	if the -P option is supplied, and the current working\n\
-    		directory cannot be determined successfully, exit with\n\
-    		a non-zero status\n\
-      -@	on systems that support it, present a file with extended\n\
-    		attributes as a directory containing the file attributes\n\
-    \n\
-    The default is to follow symbolic links, as if `-L' were specified.\n\
-    `..' is processed by removing the immediately previous pathname component\n\
-    back to a slash or the beginning of DIR.\n\
-    \n\
-    Exit Status:\n\
-    Returns 0 if the directory is changed, and if $PWD is set successfully when\n\
-    -P is used; non-zero otherwise."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const pwd_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Print the name of the current working directory.\n\
-    \n\
-    Options:\n\
-      -L	print the value of $PWD if it names the current working\n\
-    		directory\n\
-      -P	print the physical directory, without any symbolic links\n\
-    \n\
-    By default, `pwd' behaves as if `-L' were specified.\n\
-    \n\
-    Exit Status:\n\
-    Returns 0 unless an invalid option is given or the current directory\n\
-    cannot be read."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const colon_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Null command.\n\
-    \n\
-    No effect; the command does nothing.\n\
-    \n\
-    Exit Status:\n\
-    Always succeeds."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const true_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Return a successful result.\n\
-    \n\
-    Exit Status:\n\
-    Always succeeds."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const false_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Return an unsuccessful result.\n\
-    \n\
-    Exit Status:\n\
-    Always fails."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const command_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute a simple command or display information about commands.\n\
-    \n\
-    Runs COMMAND with ARGS suppressing  shell function lookup, or display\n\
-    information about the specified COMMANDs.  Can be used to invoke commands\n\
-    on disk when a function with the same name exists.\n\
-    \n\
-    Options:\n\
-      -p    use a default value for PATH that is guaranteed to find all of\n\
-            the standard utilities\n\
-      -v    print a description of COMMAND similar to the `type' builtin\n\
-      -V    print a more verbose description of each COMMAND\n\
-    \n\
-    Exit Status:\n\
-    Returns exit status of COMMAND, or failure if COMMAND is not found."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const declare_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Set variable values and attributes.\n\
-    \n\
-    Declare variables and give them attributes.  If no NAMEs are given,\n\
-    display the attributes and values of all variables.\n\
-    \n\
-    Options:\n\
-      -f	restrict action or display to function names and definitions\n\
-      -F	restrict display to function names only (plus line number and\n\
-    		source file when debugging)\n\
-      -g	create global variables when used in a shell function; otherwise\n\
-    		ignored\n\
-      -I	if creating a local variable, inherit the attributes and value\n\
-    		of a variable with the same name at a previous scope\n\
-      -p	display the attributes and value of each NAME\n\
-    \n\
-    Options which set attributes:\n\
-      -a	to make NAMEs indexed arrays (if supported)\n\
-      -A	to make NAMEs associative arrays (if supported)\n\
-      -i	to make NAMEs have the `integer' attribute\n\
-      -l	to convert the value of each NAME to lower case on assignment\n\
-      -n	make NAME a reference to the variable named by its value\n\
-      -r	to make NAMEs readonly\n\
-      -t	to make NAMEs have the `trace' attribute\n\
-      -u	to convert the value of each NAME to upper case on assignment\n\
-      -x	to make NAMEs export\n\
-    \n\
-    Using `+' instead of `-' turns off the given attribute.\n\
-    \n\
-    Variables with the integer attribute have arithmetic evaluation (see\n\
-    the `let' command) performed when the variable is assigned a value.\n\
-    \n\
-    When used in a function, `declare' makes NAMEs local, as with the `local'\n\
-    command.  The `-g' option suppresses this behavior.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is supplied or a variable\n\
-    assignment error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const typeset_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Set variable values and attributes.\n\
-    \n\
-    A synonym for `declare'.  See `help declare'."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const local_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Define local variables.\n\
-    \n\
-    Create a local variable called NAME, and give it VALUE.  OPTION can\n\
-    be any option accepted by `declare'.\n\
-    \n\
-    Local variables can only be used within a function; they are visible\n\
-    only to the function where they are defined and its children.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is supplied, a variable\n\
-    assignment error occurs, or the shell is not executing a function."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#if defined (V9_ECHO)
-char * const echo_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Write arguments to the standard output.\n\
-    \n\
-    Display the ARGs, separated by a single space character and followed by a\n\
-    newline, on the standard output.\n\
-    \n\
-    Options:\n\
-      -n	do not append a newline\n\
-      -e	enable interpretation of the following backslash escapes\n\
-      -E	explicitly suppress interpretation of backslash escapes\n\
-    \n\
-    `echo' interprets the following backslash-escaped characters:\n\
-      \\a	alert (bell)\n\
-      \\b	backspace\n\
-      \\c	suppress further output\n\
-      \\e	escape character\n\
-      \\E	escape character\n\
-      \\f	form feed\n\
-      \\n	new line\n\
-      \\r	carriage return\n\
-      \\t	horizontal tab\n\
-      \\v	vertical tab\n\
-      \\\\	backslash\n\
-      \\0nnn	the character whose ASCII code is NNN (octal).  NNN can be\n\
-    		0 to 3 octal digits\n\
-      \\xHH	the eight-bit character whose value is HH (hexadecimal).  HH\n\
-    		can be one or two hex digits\n\
-      \\uHHHH	the Unicode character whose value is the hexadecimal value HHHH.\n\
-    		HHHH can be one to four hex digits.\n\
-      \\UHHHHHHHH the Unicode character whose value is the hexadecimal value\n\
-    		HHHHHHHH. HHHHHHHH can be one to eight hex digits.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless a write error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* V9_ECHO */
-#if !defined (V9_ECHO)
-char * const echo_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Write arguments to the standard output.\n\
-    \n\
-    Display the ARGs on the standard output followed by a newline.\n\
-    \n\
-    Options:\n\
-      -n	do not append a newline\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless a write error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* !V9_ECHO */
-char * const enable_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Enable and disable shell builtins.\n\
-    \n\
-    Enables and disables builtin shell commands.  Disabling allows you to\n\
-    execute a disk command which has the same name as a shell builtin\n\
-    without using a full pathname.\n\
-    \n\
-    Options:\n\
-      -a	print a list of builtins showing whether or not each is enabled\n\
-      -n	disable each NAME or display a list of disabled builtins\n\
-      -p	print the list of builtins in a reusable format\n\
-      -s	print only the names of Posix `special' builtins\n\
-    \n\
-    Options controlling dynamic loading:\n\
-      -f	Load builtin NAME from shared object FILENAME\n\
-      -d	Remove a builtin loaded with -f\n\
-    \n\
-    Without options, each NAME is enabled.\n\
-    \n\
-    To use the `test' found in $PATH instead of the shell builtin\n\
-    version, type `enable -n test'.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless NAME is not a shell builtin or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const eval_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute arguments as a shell command.\n\
-    \n\
-    Combine ARGs into a single string, use the result as input to the shell,\n\
-    and execute the resulting commands.\n\
-    \n\
-    Exit Status:\n\
-    Returns exit status of command or success if command is null."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const getopts_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Parse option arguments.\n\
-    \n\
-    Getopts is used by shell procedures to parse positional parameters\n\
-    as options.\n\
-    \n\
-    OPTSTRING contains the option letters to be recognized; if a letter\n\
-    is followed by a colon, the option is expected to have an argument,\n\
-    which should be separated from it by white space.\n\
-    \n\
-    Each time it is invoked, getopts will place the next option in the\n\
-    shell variable $name, initializing name if it does not exist, and\n\
-    the index of the next argument to be processed into the shell\n\
-    variable OPTIND.  OPTIND is initialized to 1 each time the shell or\n\
-    a shell script is invoked.  When an option requires an argument,\n\
-    getopts places that argument into the shell variable OPTARG.\n\
-    \n\
-    getopts reports errors in one of two ways.  If the first character\n\
-    of OPTSTRING is a colon, getopts uses silent error reporting.  In\n\
-    this mode, no error messages are printed.  If an invalid option is\n\
-    seen, getopts places the option character found into OPTARG.  If a\n\
-    required argument is not found, getopts places a ':' into NAME and\n\
-    sets OPTARG to the option character found.  If getopts is not in\n\
-    silent mode, and an invalid option is seen, getopts places '?' into\n\
-    NAME and unsets OPTARG.  If a required argument is not found, a '?'\n\
-    is placed in NAME, OPTARG is unset, and a diagnostic message is\n\
-    printed.\n\
-    \n\
-    If the shell variable OPTERR has the value 0, getopts disables the\n\
-    printing of error messages, even if the first character of\n\
-    OPTSTRING is not a colon.  OPTERR has the value 1 by default.\n\
-    \n\
-    Getopts normally parses the positional parameters, but if arguments\n\
-    are supplied as ARG values, they are parsed instead.\n\
-    \n\
-    Exit Status:\n\
-    Returns success if an option is found; fails if the end of options is\n\
-    encountered or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const exec_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Replace the shell with the given command.\n\
-    \n\
-    Execute COMMAND, replacing this shell with the specified program.\n\
-    ARGUMENTS become the arguments to COMMAND.  If COMMAND is not specified,\n\
-    any redirections take effect in the current shell.\n\
-    \n\
-    Options:\n\
-      -a name	pass NAME as the zeroth argument to COMMAND\n\
-      -c	execute COMMAND with an empty environment\n\
-      -l	place a dash in the zeroth argument to COMMAND\n\
-    \n\
-    If the command cannot be executed, a non-interactive shell exits, unless\n\
-    the shell option `execfail' is set.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless COMMAND is not found or a redirection error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const exit_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Exit the shell.\n\
-    \n\
-    Exits the shell with a status of N.  If N is omitted, the exit status\n\
-    is that of the last command executed."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const logout_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Exit a login shell.\n\
-    \n\
-    Exits a login shell with exit status N.  Returns an error if not executed\n\
-    in a login shell."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#if defined (HISTORY)
-char * const fc_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Display or execute commands from the history list.\n\
-    \n\
-    fc is used to list or edit and re-execute commands from the history list.\n\
-    FIRST and LAST can be numbers specifying the range, or FIRST can be a\n\
-    string, which means the most recent command beginning with that\n\
-    string.\n\
-    \n\
-    Options:\n\
-      -e ENAME	select which editor to use.  Default is FCEDIT, then EDITOR,\n\
-    		then vi\n\
-      -l 	list lines instead of editing\n\
-      -n	omit line numbers when listing\n\
-      -r	reverse the order of the lines (newest listed first)\n\
-    \n\
-    With the `fc -s [pat=rep ...] [command]' format, COMMAND is\n\
-    re-executed after the substitution OLD=NEW is performed.\n\
-    \n\
-    A useful alias to use with this is r='fc -s', so that typing `r cc'\n\
-    runs the last command beginning with `cc' and typing `r' re-executes\n\
-    the last command.\n\
-    \n\
-    Exit Status:\n\
-    Returns success or status of executed command; non-zero if an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* HISTORY */
-#if defined (JOB_CONTROL)
-char * const fg_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Move job to the foreground.\n\
-    \n\
-    Place the job identified by JOB_SPEC in the foreground, making it the\n\
-    current job.  If JOB_SPEC is not present, the shell's notion of the\n\
-    current job is used.\n\
-    \n\
-    Exit Status:\n\
-    Status of command placed in foreground, or failure if an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* JOB_CONTROL */
-#if defined (JOB_CONTROL)
-char * const bg_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Move jobs to the background.\n\
-    \n\
-    Place the jobs identified by each JOB_SPEC in the background, as if they\n\
-    had been started with `&'.  If JOB_SPEC is not present, the shell's notion\n\
-    of the current job is used.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless job control is not enabled or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* JOB_CONTROL */
-char * const hash_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Remember or display program locations.\n\
-    \n\
-    Determine and remember the full pathname of each command NAME.  If\n\
-    no arguments are given, information about remembered commands is displayed.\n\
-    \n\
-    Options:\n\
-      -d	forget the remembered location of each NAME\n\
-      -l	display in a format that may be reused as input\n\
-      -p pathname	use PATHNAME as the full pathname of NAME\n\
-      -r	forget all remembered locations\n\
-      -t	print the remembered location of each NAME, preceding\n\
-    		each location with the corresponding NAME if multiple\n\
-    		NAMEs are given\n\
-    Arguments:\n\
-      NAME	Each NAME is searched for in $PATH and added to the list\n\
-    		of remembered commands.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless NAME is not found or an invalid option is given."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#if defined (HELP_BUILTIN)
-char * const help_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Display information about builtin commands.\n\
-    \n\
-    Displays brief summaries of builtin commands.  If PATTERN is\n\
-    specified, gives detailed help on all commands matching PATTERN,\n\
-    otherwise the list of help topics is printed.\n\
-    \n\
-    Options:\n\
-      -d	output short description for each topic\n\
-      -m	display usage in pseudo-manpage format\n\
-      -s	output only a short usage synopsis for each topic matching\n\
-    		PATTERN\n\
-    \n\
-    Arguments:\n\
-      PATTERN	Pattern specifying a help topic\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless PATTERN is not found or an invalid option is given."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* HELP_BUILTIN */
-#if defined (HISTORY)
-char * const history_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Display or manipulate the history list.\n\
-    \n\
-    Display the history list with line numbers, prefixing each modified\n\
-    entry with a `*'.  An argument of N lists only the last N entries.\n\
-    \n\
-    Options:\n\
-      -c	clear the history list by deleting all of the entries\n\
-      -d offset	delete the history entry at position OFFSET. Negative\n\
-    		offsets count back from the end of the history list\n\
-    \n\
-      -a	append history lines from this session to the history file\n\
-      -n	read all history lines not already read from the history file\n\
-    		and append them to the history list\n\
-      -r	read the history file and append the contents to the history\n\
-    		list\n\
-      -w	write the current history to the history file\n\
-    \n\
-      -p	perform history expansion on each ARG and display the result\n\
-    		without storing it in the history list\n\
-      -s	append the ARGs to the history list as a single entry\n\
-    \n\
-    If FILENAME is given, it is used as the history file.  Otherwise,\n\
-    if HISTFILE has a value, that is used, else ~/.bash_history.\n\
-    \n\
-    If the HISTTIMEFORMAT variable is set and not null, its value is used\n\
-    as a format string for strftime(3) to print the time stamp associated\n\
-    with each displayed history entry.  No time stamps are printed otherwise.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is given or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* HISTORY */
-#if defined (JOB_CONTROL)
-char * const jobs_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Display status of jobs.\n\
-    \n\
-    Lists the active jobs.  JOBSPEC restricts output to that job.\n\
-    Without options, the status of all active jobs is displayed.\n\
-    \n\
-    Options:\n\
-      -l	lists process IDs in addition to the normal information\n\
-      -n	lists only processes that have changed status since the last\n\
-    		notification\n\
-      -p	lists process IDs only\n\
-      -r	restrict output to running jobs\n\
-      -s	restrict output to stopped jobs\n\
-    \n\
-    If -x is supplied, COMMAND is run after all job specifications that\n\
-    appear in ARGS have been replaced with the process ID of that job's\n\
-    process group leader.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is given or an error occurs.\n\
-    If -x is used, returns the exit status of COMMAND."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* JOB_CONTROL */
-#if defined (JOB_CONTROL)
-char * const disown_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Remove jobs from current shell.\n\
-    \n\
-    Removes each JOBSPEC argument from the table of active jobs.  Without\n\
-    any JOBSPECs, the shell uses its notion of the current job.\n\
-    \n\
-    Options:\n\
-      -a	remove all jobs if JOBSPEC is not supplied\n\
-      -h	mark each JOBSPEC so that SIGHUP is not sent to the job if the\n\
-    		shell receives a SIGHUP\n\
-      -r	remove only running jobs\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option or JOBSPEC is given."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* JOB_CONTROL */
-char * const kill_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Send a signal to a job.\n\
-    \n\
-    Send the processes identified by PID or JOBSPEC the signal named by\n\
-    SIGSPEC or SIGNUM.  If neither SIGSPEC nor SIGNUM is present, then\n\
-    SIGTERM is assumed.\n\
-    \n\
-    Options:\n\
-      -s sig	SIG is a signal name\n\
-      -n sig	SIG is a signal number\n\
-      -l	list the signal names; if arguments follow `-l' they are\n\
-    		assumed to be signal numbers for which names should be listed\n\
-      -L	synonym for -l\n\
-    \n\
-    Kill is a shell builtin for two reasons: it allows job IDs to be used\n\
-    instead of process IDs, and allows processes to be killed if the limit\n\
-    on processes that you can create is reached.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is given or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const let_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Evaluate arithmetic expressions.\n\
-    \n\
-    Evaluate each ARG as an arithmetic expression.  Evaluation is done in\n\
-    fixed-width integers with no check for overflow, though division by 0\n\
-    is trapped and flagged as an error.  The following list of operators is\n\
-    grouped into levels of equal-precedence operators.  The levels are listed\n\
-    in order of decreasing precedence.\n\
-    \n\
-    	id++, id--	variable post-increment, post-decrement\n\
-    	++id, --id	variable pre-increment, pre-decrement\n\
-    	-, +		unary minus, plus\n\
-    	!, ~		logical and bitwise negation\n\
-    	**		exponentiation\n\
-    	*, /, %		multiplication, division, remainder\n\
-    	+, -		addition, subtraction\n\
-    	<<, >>		left and right bitwise shifts\n\
-    	<=, >=, <, >	comparison\n\
-    	==, !=		equality, inequality\n\
-    	&		bitwise AND\n\
-    	^		bitwise XOR\n\
-    	|		bitwise OR\n\
-    	&&		logical AND\n\
-    	||		logical OR\n\
-    	expr ? expr : expr\n\
-    			conditional operator\n\
-    	=, *=, /=, %=,\n\
-    	+=, -=, <<=, >>=,\n\
-    	&=, ^=, |=	assignment\n\
-    \n\
-    Shell variables are allowed as operands.  The name of the variable\n\
-    is replaced by its value (coerced to a fixed-width integer) within\n\
-    an expression.  The variable need not have its integer attribute\n\
-    turned on to be used in an expression.\n\
-    \n\
-    Operators are evaluated in order of precedence.  Sub-expressions in\n\
-    parentheses are evaluated first and may override the precedence\n\
-    rules above.\n\
-    \n\
-    Exit Status:\n\
-    If the last ARG evaluates to 0, let returns 1; let returns 0 otherwise."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const read_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Read a line from the standard input and split it into fields.\n\
-    \n\
-    Reads a single line from the standard input, or from file descriptor FD\n\
-    if the -u option is supplied.  The line is split into fields as with word\n\
-    splitting, and the first word is assigned to the first NAME, the second\n\
-    word to the second NAME, and so on, with any leftover words assigned to\n\
-    the last NAME.  Only the characters found in $IFS are recognized as word\n\
-    delimiters. By default, the backslash character escapes delimiter characters\n\
-    and newline.\n\
-    \n\
-    If no NAMEs are supplied, the line read is stored in the REPLY variable.\n\
-    \n\
-    Options:\n\
-      -a array	assign the words read to sequential indices of the array\n\
-    		variable ARRAY, starting at zero\n\
-      -d delim	continue until the first character of DELIM is read, rather\n\
-    		than newline\n\
-      -e	use Readline to obtain the line\n\
-      -i text	use TEXT as the initial text for Readline\n\
-      -n nchars	return after reading NCHARS characters rather than waiting\n\
-    		for a newline, but honor a delimiter if fewer than\n\
-    		NCHARS characters are read before the delimiter\n\
-      -N nchars	return only after reading exactly NCHARS characters, unless\n\
-    		EOF is encountered or read times out, ignoring any\n\
-    		delimiter\n\
-      -p prompt	output the string PROMPT without a trailing newline before\n\
-    		attempting to read\n\
-      -r	do not allow backslashes to escape any characters\n\
-      -s	do not echo input coming from a terminal\n\
-      -t timeout	time out and return failure if a complete line of\n\
-    		input is not read within TIMEOUT seconds.  The value of the\n\
-    		TMOUT variable is the default timeout.  TIMEOUT may be a\n\
-    		fractional number.  If TIMEOUT is 0, read returns\n\
-    		immediately, without trying to read any data, returning\n\
-    		success only if input is available on the specified\n\
-    		file descriptor.  The exit status is greater than 128\n\
-    		if the timeout is exceeded\n\
-      -u fd	read from file descriptor FD instead of the standard input\n\
-    \n\
-    Exit Status:\n\
-    The return code is zero, unless end-of-file is encountered, read times out\n\
-    (in which case it's greater than 128), a variable assignment error occurs,\n\
-    or an invalid file descriptor is supplied as the argument to -u."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const return_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Return from a shell function.\n\
-    \n\
-    Causes a function or sourced script to exit with the return value\n\
-    specified by N.  If N is omitted, the return status is that of the\n\
-    last command executed within the function or script.\n\
-    \n\
-    Exit Status:\n\
-    Returns N, or failure if the shell is not executing a function or script."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const set_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Set or unset values of shell options and positional parameters.\n\
-    \n\
-    Change the value of shell attributes and positional parameters, or\n\
-    display the names and values of shell variables.\n\
-    \n\
-    Options:\n\
-      -a  Mark variables which are modified or created for export.\n\
-      -b  Notify of job termination immediately.\n\
-      -e  Exit immediately if a command exits with a non-zero status.\n\
-      -f  Disable file name generation (globbing).\n\
-      -h  Remember the location of commands as they are looked up.\n\
-      -k  All assignment arguments are placed in the environment for a\n\
-          command, not just those that precede the command name.\n\
-      -m  Job control is enabled.\n\
-      -n  Read commands but do not execute them.\n\
-      -o option-name\n\
-          Set the variable corresponding to option-name:\n\
-              allexport    same as -a\n\
-              braceexpand  same as -B\n\
-              emacs        use an emacs-style line editing interface\n\
-              errexit      same as -e\n\
-              errtrace     same as -E\n\
-              functrace    same as -T\n\
-              hashall      same as -h\n\
-              histexpand   same as -H\n\
-              history      enable command history\n\
-              ignoreeof    the shell will not exit upon reading EOF\n\
-              interactive-comments\n\
-                           allow comments to appear in interactive commands\n\
-              keyword      same as -k\n\
-              monitor      same as -m\n\
-              noclobber    same as -C\n\
-              noexec       same as -n\n\
-              noglob       same as -f\n\
-              nolog        currently accepted but ignored\n\
-              notify       same as -b\n\
-              nounset      same as -u\n\
-              onecmd       same as -t\n\
-              physical     same as -P\n\
-              pipefail     the return value of a pipeline is the status of\n\
-                           the last command to exit with a non-zero status,\n\
-                           or zero if no command exited with a non-zero status\n\
-              posix        change the behavior of bash where the default\n\
-                           operation differs from the Posix standard to\n\
-                           match the standard\n\
-              privileged   same as -p\n\
-              verbose      same as -v\n\
-              vi           use a vi-style line editing interface\n\
-              xtrace       same as -x\n\
-      -p  Turned on whenever the real and effective user ids do not match.\n\
-          Disables processing of the $ENV file and importing of shell\n\
-          functions.  Turning this option off causes the effective uid and\n\
-          gid to be set to the real uid and gid.\n\
-      -t  Exit after reading and executing one command.\n\
-      -u  Treat unset variables as an error when substituting.\n\
-      -v  Print shell input lines as they are read.\n\
-      -x  Print commands and their arguments as they are executed.\n\
-      -B  the shell will perform brace expansion\n\
-      -C  If set, disallow existing regular files to be overwritten\n\
-          by redirection of output.\n\
-      -E  If set, the ERR trap is inherited by shell functions.\n\
-      -H  Enable ! style history substitution.  This flag is on\n\
-          by default when the shell is interactive.\n\
-      -P  If set, do not resolve symbolic links when executing commands\n\
-          such as cd which change the current directory.\n\
-      -T  If set, the DEBUG and RETURN traps are inherited by shell functions.\n\
-      --  Assign any remaining arguments to the positional parameters.\n\
-          If there are no remaining arguments, the positional parameters\n\
-          are unset.\n\
-      -   Assign any remaining arguments to the positional parameters.\n\
-          The -x and -v options are turned off.\n\
-    \n\
-    Using + rather than - causes these flags to be turned off.  The\n\
-    flags can also be used upon invocation of the shell.  The current\n\
-    set of flags may be found in $-.  The remaining n ARGs are positional\n\
-    parameters and are assigned, in order, to $1, $2, .. $n.  If no\n\
-    ARGs are given, all shell variables are printed.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is given."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const unset_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Unset values and attributes of shell variables and functions.\n\
-    \n\
-    For each NAME, remove the corresponding variable or function.\n\
-    \n\
-    Options:\n\
-      -f	treat each NAME as a shell function\n\
-      -v	treat each NAME as a shell variable\n\
-      -n	treat each NAME as a name reference and unset the variable itself\n\
-    		rather than the variable it references\n\
-    \n\
-    Without options, unset first tries to unset a variable, and if that fails,\n\
-    tries to unset a function.\n\
-    \n\
-    Some variables cannot be unset; also see `readonly'.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is given or a NAME is read-only."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const export_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Set export attribute for shell variables.\n\
-    \n\
-    Marks each NAME for automatic export to the environment of subsequently\n\
-    executed commands.  If VALUE is supplied, assign VALUE before exporting.\n\
-    \n\
-    Options:\n\
-      -f	refer to shell functions\n\
-      -n	remove the export property from each NAME\n\
-      -p	display a list of all exported variables and functions\n\
-    \n\
-    An argument of `--' disables further option processing.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is given or NAME is invalid."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const readonly_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Mark shell variables as unchangeable.\n\
-    \n\
-    Mark each NAME as read-only; the values of these NAMEs may not be\n\
-    changed by subsequent assignment.  If VALUE is supplied, assign VALUE\n\
-    before marking as read-only.\n\
-    \n\
-    Options:\n\
-      -a	refer to indexed array variables\n\
-      -A	refer to associative array variables\n\
-      -f	refer to shell functions\n\
-      -p	display a list of all readonly variables or functions,\n\
-    		depending on whether or not the -f option is given\n\
-    \n\
-    An argument of `--' disables further option processing.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is given or NAME is invalid."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const shift_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Shift positional parameters.\n\
-    \n\
-    Rename the positional parameters $N+1,$N+2 ... to $1,$2 ...  If N is\n\
-    not given, it is assumed to be 1.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless N is negative or greater than $#."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const source_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute commands from a file in the current shell.\n\
-    \n\
-    Read and execute commands from FILENAME in the current shell.  The\n\
-    entries in $PATH are used to find the directory containing FILENAME.\n\
-    If any ARGUMENTS are supplied, they become the positional parameters\n\
-    when FILENAME is executed.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last command executed in FILENAME; fails if\n\
-    FILENAME cannot be read."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const dot_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute commands from a file in the current shell.\n\
-    \n\
-    Read and execute commands from FILENAME in the current shell.  The\n\
-    entries in $PATH are used to find the directory containing FILENAME.\n\
-    If any ARGUMENTS are supplied, they become the positional parameters\n\
-    when FILENAME is executed.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last command executed in FILENAME; fails if\n\
-    FILENAME cannot be read."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#if defined (JOB_CONTROL)
-char * const suspend_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Suspend shell execution.\n\
-    \n\
-    Suspend the execution of this shell until it receives a SIGCONT signal.\n\
-    Unless forced, login shells and shells without job control cannot be\n\
-    suspended.\n\
-    \n\
-    Options:\n\
-      -f	force the suspend, even if the shell is a login shell or job\n\
-    		control is not enabled.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless job control is not enabled or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* JOB_CONTROL */
-char * const test_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Evaluate conditional expression.\n\
-    \n\
-    Exits with a status of 0 (true) or 1 (false) depending on\n\
-    the evaluation of EXPR.  Expressions may be unary or binary.  Unary\n\
-    expressions are often used to examine the status of a file.  There\n\
-    are string operators and numeric comparison operators as well.\n\
-    \n\
-    The behavior of test depends on the number of arguments.  Read the\n\
-    bash manual page for the complete specification.\n\
-    \n\
-    File operators:\n\
-    \n\
-      -a FILE        True if file exists.\n\
-      -b FILE        True if file is block special.\n\
-      -c FILE        True if file is character special.\n\
-      -d FILE        True if file is a directory.\n\
-      -e FILE        True if file exists.\n\
-      -f FILE        True if file exists and is a regular file.\n\
-      -g FILE        True if file is set-group-id.\n\
-      -h FILE        True if file is a symbolic link.\n\
-      -L FILE        True if file is a symbolic link.\n\
-      -k FILE        True if file has its `sticky' bit set.\n\
-      -p FILE        True if file is a named pipe.\n\
-      -r FILE        True if file is readable by you.\n\
-      -s FILE        True if file exists and is not empty.\n\
-      -S FILE        True if file is a socket.\n\
-      -t FD          True if FD is opened on a terminal.\n\
-      -u FILE        True if the file is set-user-id.\n\
-      -w FILE        True if the file is writable by you.\n\
-      -x FILE        True if the file is executable by you.\n\
-      -O FILE        True if the file is effectively owned by you.\n\
-      -G FILE        True if the file is effectively owned by your group.\n\
-      -N FILE        True if the file has been modified since it was last read.\n\
-    \n\
-      FILE1 -nt FILE2  True if file1 is newer than file2 (according to\n\
-                       modification date).\n\
-    \n\
-      FILE1 -ot FILE2  True if file1 is older than file2.\n\
-    \n\
-      FILE1 -ef FILE2  True if file1 is a hard link to file2.\n\
-    \n\
-    String operators:\n\
-    \n\
-      -z STRING      True if string is empty.\n\
-    \n\
-      -n STRING\n\
-         STRING      True if string is not empty.\n\
-    \n\
-      STRING1 = STRING2\n\
-                     True if the strings are equal.\n\
-      STRING1 != STRING2\n\
-                     True if the strings are not equal.\n\
-      STRING1 < STRING2\n\
-                     True if STRING1 sorts before STRING2 lexicographically.\n\
-      STRING1 > STRING2\n\
-                     True if STRING1 sorts after STRING2 lexicographically.\n\
-    \n\
-    Other operators:\n\
-    \n\
-      -o OPTION      True if the shell option OPTION is enabled.\n\
-      -v VAR         True if the shell variable VAR is set.\n\
-      -R VAR         True if the shell variable VAR is set and is a name\n\
-                     reference.\n\
-      ! EXPR         True if expr is false.\n\
-      EXPR1 -a EXPR2 True if both expr1 AND expr2 are true.\n\
-      EXPR1 -o EXPR2 True if either expr1 OR expr2 is true.\n\
-    \n\
-      arg1 OP arg2   Arithmetic tests.  OP is one of -eq, -ne,\n\
-                     -lt, -le, -gt, or -ge.\n\
-    \n\
-    Arithmetic binary operators return true if ARG1 is equal, not-equal,\n\
-    less-than, less-than-or-equal, greater-than, or greater-than-or-equal\n\
-    than ARG2.\n\
-    \n\
-    Exit Status:\n\
-    Returns success if EXPR evaluates to true; fails if EXPR evaluates to\n\
-    false or an invalid argument is given."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const test_bracket_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Evaluate conditional expression.\n\
-    \n\
-    This is a synonym for the \"test\" builtin, but the last argument must\n\
-    be a literal `]', to match the opening `['."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const times_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Display process times.\n\
-    \n\
-    Prints the accumulated user and system times for the shell and all of its\n\
-    child processes.\n\
-    \n\
-    Exit Status:\n\
-    Always succeeds."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const trap_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Trap signals and other events.\n\
-    \n\
-    Defines and activates handlers to be run when the shell receives signals\n\
-    or other conditions.\n\
-    \n\
-    ARG is a command to be read and executed when the shell receives the\n\
-    signal(s) SIGNAL_SPEC.  If ARG is absent (and a single SIGNAL_SPEC\n\
-    is supplied) or `-', each specified signal is reset to its original\n\
-    value.  If ARG is the null string each SIGNAL_SPEC is ignored by the\n\
-    shell and by the commands it invokes.\n\
-    \n\
-    If a SIGNAL_SPEC is EXIT (0) ARG is executed on exit from the shell.  If\n\
-    a SIGNAL_SPEC is DEBUG, ARG is executed before every simple command.  If\n\
-    a SIGNAL_SPEC is RETURN, ARG is executed each time a shell function or a\n\
-    script run by the . or source builtins finishes executing.  A SIGNAL_SPEC\n\
-    of ERR means to execute ARG each time a command's failure would cause the\n\
-    shell to exit when the -e option is enabled.\n\
-    \n\
-    If no arguments are supplied, trap prints the list of commands associated\n\
-    with each signal.\n\
-    \n\
-    Options:\n\
-      -l	print a list of signal names and their corresponding numbers\n\
-      -p	display the trap commands associated with each SIGNAL_SPEC\n\
-    \n\
-    Each SIGNAL_SPEC is either a signal name in <signal.h> or a signal number.\n\
-    Signal names are case insensitive and the SIG prefix is optional.  A\n\
-    signal may be sent to the shell with \"kill -signal $$\".\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless a SIGSPEC is invalid or an invalid option is given."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const type_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Display information about command type.\n\
-    \n\
-    For each NAME, indicate how it would be interpreted if used as a\n\
-    command name.\n\
-    \n\
-    Options:\n\
-      -a	display all locations containing an executable named NAME;\n\
-    		includes aliases, builtins, and functions, if and only if\n\
-    		the `-p' option is not also used\n\
-      -f	suppress shell function lookup\n\
-      -P	force a PATH search for each NAME, even if it is an alias,\n\
-    		builtin, or function, and returns the name of the disk file\n\
-    		that would be executed\n\
-      -p	returns either the name of the disk file that would be executed,\n\
-    		or nothing if `type -t NAME' would not return `file'\n\
-      -t	output a single word which is one of `alias', `keyword',\n\
-    		`function', `builtin', `file' or `', if NAME is an alias,\n\
-    		shell reserved word, shell function, shell builtin, disk file,\n\
-    		or not found, respectively\n\
-    \n\
-    Arguments:\n\
-      NAME	Command name to be interpreted.\n\
-    \n\
-    Exit Status:\n\
-    Returns success if all of the NAMEs are found; fails if any are not found."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#if !defined (_MINIX)
-char * const ulimit_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Modify shell resource limits.\n\
-    \n\
-    Provides control over the resources available to the shell and processes\n\
-    it creates, on systems that allow such control.\n\
-    \n\
-    Options:\n\
-      -S	use the `soft' resource limit\n\
-      -H	use the `hard' resource limit\n\
-      -a	all current limits are reported\n\
-      -b	the socket buffer size\n\
-      -c	the maximum size of core files created\n\
-      -d	the maximum size of a process's data segment\n\
-      -e	the maximum scheduling priority (`nice')\n\
-      -f	the maximum size of files written by the shell and its children\n\
-      -i	the maximum number of pending signals\n\
-      -k	the maximum number of kqueues allocated for this process\n\
-      -l	the maximum size a process may lock into memory\n\
-      -m	the maximum resident set size\n\
-      -n	the maximum number of open file descriptors\n\
-      -p	the pipe buffer size\n\
-      -q	the maximum number of bytes in POSIX message queues\n\
-      -r	the maximum real-time scheduling priority\n\
-      -s	the maximum stack size\n\
-      -t	the maximum amount of cpu time in seconds\n\
-      -u	the maximum number of user processes\n\
-      -v	the size of virtual memory\n\
-      -x	the maximum number of file locks\n\
-      -P	the maximum number of pseudoterminals\n\
-      -R	the maximum time a real-time process can run before blocking\n\
-      -T	the maximum number of threads\n\
-    \n\
-    Not all options are available on all platforms.\n\
-    \n\
-    If LIMIT is given, it is the new value of the specified resource; the\n\
-    special LIMIT values `soft', `hard', and `unlimited' stand for the\n\
-    current soft limit, the current hard limit, and no limit, respectively.\n\
-    Otherwise, the current value of the specified resource is printed.  If\n\
-    no option is given, then -f is assumed.\n\
-    \n\
-    Values are in 1024-byte increments, except for -t, which is in seconds,\n\
-    -p, which is in increments of 512 bytes, and -u, which is an unscaled\n\
-    number of processes.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is supplied or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* !_MINIX */
-char * const umask_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Display or set file mode mask.\n\
-    \n\
-    Sets the user file-creation mask to MODE.  If MODE is omitted, prints\n\
-    the current value of the mask.\n\
-    \n\
-    If MODE begins with a digit, it is interpreted as an octal number;\n\
-    otherwise it is a symbolic mode string like that accepted by chmod(1).\n\
-    \n\
-    Options:\n\
-      -p	if MODE is omitted, output in a form that may be reused as input\n\
-      -S	makes the output symbolic; otherwise an octal number is output\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless MODE is invalid or an invalid option is given."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#if defined (JOB_CONTROL)
-char * const wait_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Wait for job completion and return exit status.\n\
-    \n\
-    Waits for each process identified by an ID, which may be a process ID or a\n\
-    job specification, and reports its termination status.  If ID is not\n\
-    given, waits for all currently active child processes, and the return\n\
-    status is zero.  If ID is a job specification, waits for all processes\n\
-    in that job's pipeline.\n\
-    \n\
-    If the -n option is supplied, waits for a single job from the list of IDs,\n\
-    or, if no IDs are supplied, for the next job to complete and returns its\n\
-    exit status.\n\
-    \n\
-    If the -p option is supplied, the process or job identifier of the job\n\
-    for which the exit status is returned is assigned to the variable VAR\n\
-    named by the option argument. The variable will be unset initially, before\n\
-    any assignment. This is useful only when the -n option is supplied.\n\
-    \n\
-    If the -f option is supplied, and job control is enabled, waits for the\n\
-    specified ID to terminate, instead of waiting for it to change status.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last ID; fails if ID is invalid or an invalid\n\
-    option is given, or if -n is supplied and the shell has no unwaited-for\n\
-    children."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* JOB_CONTROL */
-#if !defined (JOB_CONTROL)
-char * const wait_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Wait for process completion and return exit status.\n\
-    \n\
-    Waits for each process specified by a PID and reports its termination status.\n\
-    If PID is not given, waits for all currently active child processes,\n\
-    and the return status is zero.  PID must be a process ID.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last PID; fails if PID is invalid or an invalid\n\
-    option is given."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* !JOB_CONTROL */
-char * const for_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute commands for each member in a list.\n\
-    \n\
-    The `for' loop executes a sequence of commands for each member in a\n\
-    list of items.  If `in WORDS ...;' is not present, then `in \"$@\"' is\n\
-    assumed.  For each element in WORDS, NAME is set to that element, and\n\
-    the COMMANDS are executed.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last command executed."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const arith_for_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Arithmetic for loop.\n\
-    \n\
-    Equivalent to\n\
-    	(( EXP1 ))\n\
-    	while (( EXP2 )); do\n\
-    		COMMANDS\n\
-    		(( EXP3 ))\n\
-    	done\n\
-    EXP1, EXP2, and EXP3 are arithmetic expressions.  If any expression is\n\
-    omitted, it behaves as if it evaluates to 1.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last command executed."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const select_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Select words from a list and execute commands.\n\
-    \n\
-    The WORDS are expanded, generating a list of words.  The\n\
-    set of expanded words is printed on the standard error, each\n\
-    preceded by a number.  If `in WORDS' is not present, `in \"$@\"'\n\
-    is assumed.  The PS3 prompt is then displayed and a line read\n\
-    from the standard input.  If the line consists of the number\n\
-    corresponding to one of the displayed words, then NAME is set\n\
-    to that word.  If the line is empty, WORDS and the prompt are\n\
-    redisplayed.  If EOF is read, the command completes.  Any other\n\
-    value read causes NAME to be set to null.  The line read is saved\n\
-    in the variable REPLY.  COMMANDS are executed after each selection\n\
-    until a break command is executed.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last command executed."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const time_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Report time consumed by pipeline's execution.\n\
-    \n\
-    Execute PIPELINE and print a summary of the real time, user CPU time,\n\
-    and system CPU time spent executing PIPELINE when it terminates.\n\
-    \n\
-    Options:\n\
-      -p	print the timing summary in the portable Posix format\n\
-    \n\
-    The value of the TIMEFORMAT variable is used as the output format.\n\
-    \n\
-    Exit Status:\n\
-    The return status is the return status of PIPELINE."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const case_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute commands based on pattern matching.\n\
-    \n\
-    Selectively execute COMMANDS based upon WORD matching PATTERN.  The\n\
-    `|' is used to separate multiple patterns.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last command executed."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const if_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute commands based on conditional.\n\
-    \n\
-    The `if COMMANDS' list is executed.  If its exit status is zero, then the\n\
-    `then COMMANDS' list is executed.  Otherwise, each `elif COMMANDS' list is\n\
-    executed in turn, and if its exit status is zero, the corresponding\n\
-    `then COMMANDS' list is executed and the if command completes.  Otherwise,\n\
-    the `else COMMANDS' list is executed, if present.  The exit status of the\n\
-    entire construct is the exit status of the last command executed, or zero\n\
-    if no condition tested true.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last command executed."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const while_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute commands as long as a test succeeds.\n\
-    \n\
-    Expand and execute COMMANDS-2 as long as the final command in COMMANDS has\n\
-    an exit status of zero.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last command executed."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const until_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute commands as long as a test does not succeed.\n\
-    \n\
-    Expand and execute COMMANDS-2 as long as the final command in COMMANDS has\n\
-    an exit status which is not zero.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last command executed."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const coproc_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Create a coprocess named NAME.\n\
-    \n\
-    Execute COMMAND asynchronously, with the standard output and standard\n\
-    input of the command connected via a pipe to file descriptors assigned\n\
-    to indices 0 and 1 of an array variable NAME in the executing shell.\n\
-    The default NAME is \"COPROC\".\n\
-    \n\
-    Exit Status:\n\
-    The coproc command returns an exit status of 0."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const function_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Define shell function.\n\
-    \n\
-    Create a shell function named NAME.  When invoked as a simple command,\n\
-    NAME runs COMMANDs in the calling shell's context.  When NAME is invoked,\n\
-    the arguments are passed to the function as $1...$n, and the function's\n\
-    name is in $FUNCNAME.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless NAME is readonly."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const grouping_braces_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Group commands as a unit.\n\
-    \n\
-    Run a set of commands in a group.  This is one way to redirect an\n\
-    entire set of commands.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the last command executed."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const fg_percent_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Resume job in foreground.\n\
-    \n\
-    Equivalent to the JOB_SPEC argument to the `fg' command.  Resume a\n\
-    stopped or background job.  JOB_SPEC can specify either a job name\n\
-    or a job number.  Following JOB_SPEC with a `&' places the job in\n\
-    the background, as if the job specification had been supplied as an\n\
-    argument to `bg'.\n\
-    \n\
-    Exit Status:\n\
-    Returns the status of the resumed job."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const arith_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Evaluate arithmetic expression.\n\
-    \n\
-    The EXPRESSION is evaluated according to the rules for arithmetic\n\
-    evaluation.  Equivalent to `let \"EXPRESSION\"'.\n\
-    \n\
-    Exit Status:\n\
-    Returns 1 if EXPRESSION evaluates to 0; returns 0 otherwise."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const conditional_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Execute conditional command.\n\
-    \n\
-    Returns a status of 0 or 1 depending on the evaluation of the conditional\n\
-    expression EXPRESSION.  Expressions are composed of the same primaries used\n\
-    by the `test' builtin, and may be combined using the following operators:\n\
-    \n\
-      ( EXPRESSION )	Returns the value of EXPRESSION\n\
-      ! EXPRESSION		True if EXPRESSION is false; else false\n\
-      EXPR1 && EXPR2	True if both EXPR1 and EXPR2 are true; else false\n\
-      EXPR1 || EXPR2	True if either EXPR1 or EXPR2 is true; else false\n\
-    \n\
-    When the `==' and `!=' operators are used, the string to the right of\n\
-    the operator is used as a pattern and pattern matching is performed.\n\
-    When the `=~' operator is used, the string to the right of the operator\n\
-    is matched as a regular expression.\n\
-    \n\
-    The && and || operators do not evaluate EXPR2 if EXPR1 is sufficient to\n\
-    determine the expression's value.\n\
-    \n\
-    Exit Status:\n\
-    0 or 1 depending on value of EXPRESSION."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const variable_help_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Common shell variable names and usage.\n\
-    \n\
-    BASH_VERSION	Version information for this Bash.\n\
-    CDPATH	A colon-separated list of directories to search\n\
-    		for directories given as arguments to `cd'.\n\
-    GLOBIGNORE	A colon-separated list of patterns describing filenames to\n\
-    		be ignored by pathname expansion.\n\
-    HISTFILE	The name of the file where your command history is stored.\n\
-    HISTFILESIZE	The maximum number of lines this file can contain.\n\
-    HISTSIZE	The maximum number of history lines that a running\n\
-    		shell can access.\n\
-    HOME	The complete pathname to your login directory.\n\
-    HOSTNAME	The name of the current host.\n\
-    HOSTTYPE	The type of CPU this version of Bash is running under.\n\
-    IGNOREEOF	Controls the action of the shell on receipt of an EOF\n\
-    		character as the sole input.  If set, then the value\n\
-    		of it is the number of EOF characters that can be seen\n\
-    		in a row on an empty line before the shell will exit\n\
-    		(default 10).  When unset, EOF signifies the end of input.\n\
-    MACHTYPE	A string describing the current system Bash is running on.\n\
-    MAILCHECK	How often, in seconds, Bash checks for new mail.\n\
-    MAILPATH	A colon-separated list of filenames which Bash checks\n\
-    		for new mail.\n\
-    OSTYPE	The version of Unix this version of Bash is running on.\n\
-    PATH	A colon-separated list of directories to search when\n\
-    		looking for commands.\n\
-    PROMPT_COMMAND	A command to be executed before the printing of each\n\
-    		primary prompt.\n\
-    PS1		The primary prompt string.\n\
-    PS2		The secondary prompt string.\n\
-    PWD		The full pathname of the current directory.\n\
-    SHELLOPTS	A colon-separated list of enabled shell options.\n\
-    TERM	The name of the current terminal type.\n\
-    TIMEFORMAT	The output format for timing statistics displayed by the\n\
-    		`time' reserved word.\n\
-    auto_resume	Non-null means a command word appearing on a line by\n\
-    		itself is first looked for in the list of currently\n\
-    		stopped jobs.  If found there, that job is foregrounded.\n\
-    		A value of `exact' means that the command word must\n\
-    		exactly match a command in the list of stopped jobs.  A\n\
-    		value of `substring' means that the command word must\n\
-    		match a substring of the job.  Any other value means that\n\
-    		the command must be a prefix of a stopped job.\n\
-    histchars	Characters controlling history expansion and quick\n\
-    		substitution.  The first character is the history\n\
-    		substitution character, usually `!'.  The second is\n\
-    		the `quick substitution' character, usually `^'.  The\n\
-    		third is the `history comment' character, usually `#'.\n\
-    HISTIGNORE	A colon-separated list of patterns used to decide which\n\
-    		commands should be saved on the history list.\n\
-"),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#if defined (PUSHD_AND_POPD)
-char * const pushd_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Add directories to stack.\n\
-    \n\
-    Adds a directory to the top of the directory stack, or rotates\n\
-    the stack, making the new top of the stack the current working\n\
-    directory.  With no arguments, exchanges the top two directories.\n\
-    \n\
-    Options:\n\
-      -n	Suppresses the normal change of directory when adding\n\
-    		directories to the stack, so only the stack is manipulated.\n\
-    \n\
-    Arguments:\n\
-      +N	Rotates the stack so that the Nth directory (counting\n\
-    		from the left of the list shown by `dirs', starting with\n\
-    		zero) is at the top.\n\
-    \n\
-      -N	Rotates the stack so that the Nth directory (counting\n\
-    		from the right of the list shown by `dirs', starting with\n\
-    		zero) is at the top.\n\
-    \n\
-      dir	Adds DIR to the directory stack at the top, making it the\n\
-    		new current working directory.\n\
-    \n\
-    The `dirs' builtin displays the directory stack.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid argument is supplied or the directory\n\
-    change fails."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* PUSHD_AND_POPD */
-#if defined (PUSHD_AND_POPD)
-char * const popd_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Remove directories from stack.\n\
-    \n\
-    Removes entries from the directory stack.  With no arguments, removes\n\
-    the top directory from the stack, and changes to the new top directory.\n\
-    \n\
-    Options:\n\
-      -n	Suppresses the normal change of directory when removing\n\
-    		directories from the stack, so only the stack is manipulated.\n\
-    \n\
-    Arguments:\n\
-      +N	Removes the Nth entry counting from the left of the list\n\
-    		shown by `dirs', starting with zero.  For example: `popd +0'\n\
-    		removes the first directory, `popd +1' the second.\n\
-    \n\
-      -N	Removes the Nth entry counting from the right of the list\n\
-    		shown by `dirs', starting with zero.  For example: `popd -0'\n\
-    		removes the last directory, `popd -1' the next to last.\n\
-    \n\
-    The `dirs' builtin displays the directory stack.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid argument is supplied or the directory\n\
-    change fails."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* PUSHD_AND_POPD */
-#if defined (PUSHD_AND_POPD)
-char * const dirs_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Display directory stack.\n\
-    \n\
-    Display the list of currently remembered directories.  Directories\n\
-    find their way onto the list with the `pushd' command; you can get\n\
-    back up through the list with the `popd' command.\n\
-    \n\
-    Options:\n\
-      -c	clear the directory stack by deleting all of the elements\n\
-      -l	do not print tilde-prefixed versions of directories relative\n\
-    		to your home directory\n\
-      -p	print the directory stack with one entry per line\n\
-      -v	print the directory stack with one entry per line prefixed\n\
-    		with its position in the stack\n\
-    \n\
-    Arguments:\n\
-      +N	Displays the Nth entry counting from the left of the list\n\
-    		shown by dirs when invoked without options, starting with\n\
-    		zero.\n\
-    \n\
-      -N	Displays the Nth entry counting from the right of the list\n\
-    		shown by dirs when invoked without options, starting with\n\
-    		zero.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is supplied or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* PUSHD_AND_POPD */
-char * const shopt_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Set and unset shell options.\n\
-    \n\
-    Change the setting of each shell option OPTNAME.  Without any option\n\
-    arguments, list each supplied OPTNAME, or all shell options if no\n\
-    OPTNAMEs are given, with an indication of whether or not each is set.\n\
-    \n\
-    Options:\n\
-      -o	restrict OPTNAMEs to those defined for use with `set -o'\n\
-      -p	print each shell option with an indication of its status\n\
-      -q	suppress output\n\
-      -s	enable (set) each OPTNAME\n\
-      -u	disable (unset) each OPTNAME\n\
-    \n\
-    Exit Status:\n\
-    Returns success if OPTNAME is enabled; fails if an invalid option is\n\
-    given or OPTNAME is disabled."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const printf_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Formats and prints ARGUMENTS under control of the FORMAT.\n\
-    \n\
-    Options:\n\
-      -v var	assign the output to shell variable VAR rather than\n\
-    		display it on the standard output\n\
-    \n\
-    FORMAT is a character string which contains three types of objects: plain\n\
-    characters, which are simply copied to standard output; character escape\n\
-    sequences, which are converted and copied to the standard output; and\n\
-    format specifications, each of which causes printing of the next successive\n\
-    argument.\n\
-    \n\
-    In addition to the standard format specifications described in printf(1),\n\
-    printf interprets:\n\
-    \n\
-      %b	expand backslash escape sequences in the corresponding argument\n\
-      %q	quote the argument in a way that can be reused as shell input\n\
-      %Q	like %q, but apply any precision to the unquoted argument before\n\
-    		quoting\n\
-      %(fmt)T	output the date-time string resulting from using FMT as a format\n\
-    	        string for strftime(3)\n\
-    \n\
-    The format is re-used as necessary to consume all of the arguments.  If\n\
-    there are fewer arguments than the format requires,  extra format\n\
-    specifications behave as if a zero value or null string, as appropriate,\n\
-    had been supplied.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is given or a write or assignment\n\
-    error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#if defined (PROGRAMMABLE_COMPLETION)
-char * const complete_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Specify how arguments are to be completed by Readline.\n\
-    \n\
-    For each NAME, specify how arguments are to be completed.  If no options\n\
-    are supplied, existing completion specifications are printed in a way that\n\
-    allows them to be reused as input.\n\
-    \n\
-    Options:\n\
-      -p	print existing completion specifications in a reusable format\n\
-      -r	remove a completion specification for each NAME, or, if no\n\
-    		NAMEs are supplied, all completion specifications\n\
-      -D	apply the completions and actions as the default for commands\n\
-    		without any specific completion defined\n\
-      -E	apply the completions and actions to \"empty\" commands --\n\
-    		completion attempted on a blank line\n\
-      -I	apply the completions and actions to the initial (usually the\n\
-    		command) word\n\
-    \n\
-    When completion is attempted, the actions are applied in the order the\n\
-    uppercase-letter options are listed above. If multiple options are supplied,\n\
-    the -D option takes precedence over -E, and both take precedence over -I.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is supplied or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* PROGRAMMABLE_COMPLETION */
-#if defined (PROGRAMMABLE_COMPLETION)
-char * const compgen_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Display possible completions depending on the options.\n\
-    \n\
-    Intended to be used from within a shell function generating possible\n\
-    completions.  If the optional WORD argument is supplied, matches against\n\
-    WORD are generated.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is supplied or an error occurs."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* PROGRAMMABLE_COMPLETION */
-#if defined (PROGRAMMABLE_COMPLETION)
-char * const compopt_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Modify or display completion options.\n\
-    \n\
-    Modify the completion options for each NAME, or, if no NAMEs are supplied,\n\
-    the completion currently being executed.  If no OPTIONs are given, print\n\
-    the completion options for each NAME or the current completion specification.\n\
-    \n\
-    Options:\n\
-    	-o option	Set completion option OPTION for each NAME\n\
-    	-D		Change options for the \"default\" command completion\n\
-    	-E		Change options for the \"empty\" command completion\n\
-    	-I		Change options for completion on the initial word\n\
-    \n\
-    Using `+o' instead of `-o' turns off the specified option.\n\
-    \n\
-    Arguments:\n\
-    \n\
-    Each NAME refers to a command for which a completion specification must\n\
-    have previously been defined using the `complete' builtin.  If no NAMEs\n\
-    are supplied, compopt must be called by a function currently generating\n\
-    completions, and the options for that currently-executing completion\n\
-    generator are modified.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is supplied or NAME does not\n\
-    have a completion specification defined."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-#endif /* PROGRAMMABLE_COMPLETION */
-char * const mapfile_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Read lines from the standard input into an indexed array variable.\n\
-    \n\
-    Read lines from the standard input into the indexed array variable ARRAY, or\n\
-    from file descriptor FD if the -u option is supplied.  The variable MAPFILE\n\
-    is the default ARRAY.\n\
-    \n\
-    Options:\n\
-      -d delim	Use DELIM to terminate lines, instead of newline\n\
-      -n count	Copy at most COUNT lines.  If COUNT is 0, all lines are copied\n\
-      -O origin	Begin assigning to ARRAY at index ORIGIN.  The default index is 0\n\
-      -s count	Discard the first COUNT lines read\n\
-      -t	Remove a trailing DELIM from each line read (default newline)\n\
-      -u fd	Read lines from file descriptor FD instead of the standard input\n\
-      -C callback	Evaluate CALLBACK each time QUANTUM lines are read\n\
-      -c quantum	Specify the number of lines read between each call to\n\
-    			CALLBACK\n\
-    \n\
-    Arguments:\n\
-      ARRAY	Array variable name to use for file data\n\
-    \n\
-    If -C is supplied without -c, the default quantum is 5000.  When\n\
-    CALLBACK is evaluated, it is supplied the index of the next array\n\
-    element to be assigned and the line to be assigned to that element\n\
-    as additional arguments.\n\
-    \n\
-    If not supplied with an explicit origin, mapfile will clear ARRAY before\n\
-    assigning to it.\n\
-    \n\
-    Exit Status:\n\
-    Returns success unless an invalid option is given or ARRAY is readonly or\n\
-    not an indexed array."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
-char * const readarray_doc[] = {
-#if defined (HELP_BUILTIN)
-N_("Read lines from a file into an array variable.\n\
-    \n\
-    A synonym for `mapfile'."),
-#endif /* HELP_BUILTIN */
-  (char *)NULL
-};
diff --git a/third_party/bash/builtins.h b/third_party/bash/builtins.h
deleted file mode 100644
index 015659356..000000000
--- a/third_party/bash/builtins.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/* builtins.h -- What a builtin looks like, and where to find them. */
-
-/* Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef BUILTINS_H
-#define BUILTINS_H
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "command.h"
-#include "general.h"
-
-#if defined (ALIAS)
-#include "alias.h"
-#endif
-
-/* Flags describing various things about a builtin. */
-#define BUILTIN_ENABLED 0x01	/* This builtin is enabled. */
-#define BUILTIN_DELETED 0x02	/* This has been deleted with enable -d. */
-#define STATIC_BUILTIN  0x04	/* This builtin is not dynamically loaded. */
-#define SPECIAL_BUILTIN 0x08	/* This is a Posix `special' builtin. */
-#define ASSIGNMENT_BUILTIN 0x10	/* This builtin takes assignment statements. */
-#define POSIX_BUILTIN	0x20	/* This builtins is special in the Posix command search order. */
-#define LOCALVAR_BUILTIN   0x40	/* This builtin creates local variables */
-#define ARRAYREF_BUILTIN 0x80	/* This builtin takes array references as arguments */
-
-#define BASE_INDENT	4
-
-/* The thing that we build the array of builtins out of. */
-struct builtin {
-  char *name;			/* The name that the user types. */
-  sh_builtin_func_t *function;	/* The address of the invoked function. */
-  int flags;			/* One of the #defines above. */
-  char * const *long_doc;	/* NULL terminated array of strings. */
-  const char *short_doc;	/* Short version of documentation. */
-  char *handle;			/* for future use */
-};
-
-/* Found in builtins.c, created by builtins/mkbuiltins. */
-extern int num_shell_builtins;	/* Number of shell builtins. */
-extern struct builtin static_shell_builtins[];
-extern struct builtin *shell_builtins;
-extern struct builtin *current_builtin;
-
-#endif /* BUILTINS_H */
diff --git a/third_party/bash/builtins_alias.c b/third_party/bash/builtins_alias.c
deleted file mode 100644
index 8eb017ba3..000000000
--- a/third_party/bash/builtins_alias.c
+++ /dev/null
@@ -1,192 +0,0 @@
-/* alias.c, created from alias.def. */
-#line 42 "./alias.def"
-
-#include "config.h"
-
-#if defined (ALIAS)
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#  include "bashansi.h"
-#  include "bashintl.h"
-
-#  include <stdio.h>
-#  include "shell.h"
-#  include "alias.h"
-#  include "common.h"
-#  include "bashgetopt.h"
-
-/* Flags for print_alias */
-#define AL_REUSABLE	0x01
-
-static void print_alias PARAMS((alias_t *, int));
-
-/* Hack the alias command in a Korn shell way. */
-int
-alias_builtin (list)
-     WORD_LIST *list;
-{
-  int any_failed, offset, pflag, dflags;
-  alias_t **alias_list, *t;
-  char *name, *value;
-
-  dflags = posixly_correct ? 0 : AL_REUSABLE;
-  pflag = 0;
-  reset_internal_getopt ();
-  while ((offset = internal_getopt (list, "p")) != -1)
-    {
-      switch (offset)
-	{
-	case 'p':
-	  pflag = 1;
-	  dflags |= AL_REUSABLE;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-
-  list = loptend;
-
-  if (list == 0 || pflag)
-    {
-      if (aliases == 0)
-	return (EXECUTION_SUCCESS);
-
-      alias_list = all_aliases ();
-
-      if (alias_list == 0)
-	return (EXECUTION_SUCCESS);
-
-      for (offset = 0; alias_list[offset]; offset++)
-	print_alias (alias_list[offset], dflags);
-
-      free (alias_list);	/* XXX - Do not free the strings. */
-
-      if (list == 0)
-	return (sh_chkwrite (EXECUTION_SUCCESS));
-    }
-
-  any_failed = 0;
-  while (list)
-    {
-      name = list->word->word;
-
-      for (offset = 0; name[offset] && name[offset] != '='; offset++)
-	;
-
-      if (offset && name[offset] == '=')
-	{
-	  name[offset] = '\0';
-	  value = name + offset + 1;
-
-	  if (legal_alias_name (name, 0) == 0)
-	    {
-	      builtin_error (_("`%s': invalid alias name"), name);
-	      any_failed++;
-	    }
-	  else
-	    add_alias (name, value);
-	}
-      else
-	{
-	  t = find_alias (name);
-	  if (t)
-	    print_alias (t, dflags);
-	  else
-	    {
-	      sh_notfound (name);
-	      any_failed++;
-	    }
-	}
-      list = list->next;
-    }
-
-  return (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
-}
-#endif /* ALIAS */
-
-#line 166 "./alias.def"
-
-#if defined (ALIAS)
-/* Remove aliases named in LIST from the aliases database. */
-int
-unalias_builtin (list)
-     register WORD_LIST *list;
-{
-  register alias_t *alias;
-  int opt, aflag;
-
-  aflag = 0;
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "a")) != -1)
-    {
-      switch (opt)
-	{
-	case 'a':
-	  aflag = 1;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-
-  list = loptend;
-
-  if (aflag)
-    {
-      delete_all_aliases ();
-      return (EXECUTION_SUCCESS);
-    }
-
-  if (list == 0)
-    {
-      builtin_usage ();
-      return (EX_USAGE);
-    }
-
-  aflag = 0;
-  while (list)
-    {
-      alias = find_alias (list->word->word);
-
-      if (alias)
-	remove_alias (alias->name);
-      else
-	{
-	  sh_notfound (list->word->word);
-	  aflag++;
-	}
-
-      list = list->next;
-    }
-
-  return (aflag ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
-}
-
-/* Output ALIAS in such a way as to allow it to be read back in. */
-static void
-print_alias (alias, flags)
-     alias_t *alias;
-     int flags;
-{
-  char *value;
-
-  value = sh_single_quote (alias->value);
-  if (flags & AL_REUSABLE)
-    printf ("alias %s", (alias->name && alias->name[0] == '-') ? "-- " : "");
-  printf ("%s=%s\n", alias->name, value);
-  free (value);
-
-  fflush (stdout);
-}
-#endif /* ALIAS */
diff --git a/third_party/bash/builtins_bind.c b/third_party/bash/builtins_bind.c
deleted file mode 100644
index 1fe36ab9a..000000000
--- a/third_party/bash/builtins_bind.c
+++ /dev/null
@@ -1,349 +0,0 @@
-/* bind.c, created from bind.def. */
-#line 22 "./bind.def"
-
-#include "config.h"
-
-#line 63 "./bind.def"
-
-#if defined (READLINE)
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include <errno.h>
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#include "third_party/readline/readline.h"
-#include "third_party/readline/history.h"
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "bashline.h"
-#include "bashgetopt.h"
-#include "common.h"
-
-static int query_bindings PARAMS((char *));
-static int unbind_command PARAMS((char *));
-static int unbind_keyseq PARAMS((char *));
-
-#define BIND_RETURN(x)  do { return_code = x; goto bind_exit; } while (0)
-
-#define LFLAG	0x0001
-#define PFLAG	0x0002
-#define FFLAG	0x0004
-#define VFLAG	0x0008
-#define QFLAG	0x0010
-#define MFLAG	0x0020
-#define RFLAG	0x0040
-#define PPFLAG	0x0080
-#define VVFLAG	0x0100
-#define SFLAG   0x0200
-#define SSFLAG  0x0400
-#define UFLAG	0x0800
-#define XFLAG	0x1000
-#define XXFLAG	0x2000
-
-int
-bind_builtin (list)
-     WORD_LIST *list;
-{
-  int return_code;
-  Keymap kmap, saved_keymap;
-  int flags, opt;
-  char *initfile, *map_name, *fun_name, *unbind_name, *remove_seq, *cmd_seq, *t;
-
-  if (no_line_editing)
-    {
-#if 0
-      builtin_error (_("line editing not enabled"));
-      return (EXECUTION_FAILURE);
-#else
-      builtin_warning (_("line editing not enabled"));
-#endif
-    }
-
-  kmap = saved_keymap = (Keymap) NULL;
-  flags = 0;
-  initfile = map_name = fun_name = unbind_name = remove_seq = cmd_seq = (char *)NULL;
-  return_code = EXECUTION_SUCCESS;
-
-  if (bash_readline_initialized == 0)
-    initialize_readline ();
-
-  begin_unwind_frame ("bind_builtin");
-  unwind_protect_var (rl_outstream);
-
-  rl_outstream = stdout;
-
-  reset_internal_getopt ();  
-  while ((opt = internal_getopt (list, "lvpVPsSXf:q:u:m:r:x:")) != -1)
-    {
-      switch (opt)
-	{
-	case 'l':
-	  flags |= LFLAG;
-	  break;
-	case 'v':
-	  flags |= VFLAG;
-	  break;
-	case 'p':
-	  flags |= PFLAG;
-	  break;
-	case 'f':
-	  flags |= FFLAG;
-	  initfile = list_optarg;
-	  break;
-	case 'm':
-	  flags |= MFLAG;
-	  map_name = list_optarg;
-	  break;
-	case 'q':
-	  flags |= QFLAG;
-	  fun_name = list_optarg;
-	  break;
-	case 'u':
-	  flags |= UFLAG;
-	  unbind_name = list_optarg;
-	  break;
-	case 'r':
-	  flags |= RFLAG;
-	  remove_seq = list_optarg;
-	  break;
-	case 'V':
-	  flags |= VVFLAG;
-	  break;
-	case 'P':
-	  flags |= PPFLAG;
-	  break;
-	case 's':
-	  flags |= SFLAG;
-	  break;
-	case 'S':
-	  flags |= SSFLAG;
-	  break;
-	case 'x':
-	  flags |= XFLAG;
-	  cmd_seq = list_optarg;
-	  break;
-	case 'X':
-	  flags |= XXFLAG;
-	  break;
-	case GETOPT_HELP:
-	default:
-	  builtin_usage ();
-	  BIND_RETURN (EX_USAGE);
-	}
-    }
-
-  list = loptend;
-
-  /* First, see if we need to install a special keymap for this
-     command.  Then start on the arguments. */
-
-  if ((flags & MFLAG) && map_name)
-    {
-      kmap = rl_get_keymap_by_name (map_name);
-      if (kmap == 0)
-	{
-	  builtin_error (_("`%s': invalid keymap name"), map_name);
-	  BIND_RETURN (EXECUTION_FAILURE);
-	}
-    }
-
-  if (kmap)
-    {
-      saved_keymap = rl_get_keymap ();
-      rl_set_keymap (kmap);
-    }
-
-  /* XXX - we need to add exclusive use tests here.  It doesn't make sense
-     to use some of these options together. */
-  /* Now hack the option arguments */
-  if (flags & LFLAG)
-    rl_list_funmap_names ();
-
-  if (flags & PFLAG)
-    rl_function_dumper (1);
-
-  if (flags & PPFLAG)
-    rl_function_dumper (0);
-
-  if (flags & SFLAG)
-    rl_macro_dumper (1);
-
-  if (flags & SSFLAG)
-    rl_macro_dumper (0);
-
-  if (flags & VFLAG)
-    rl_variable_dumper (1);
-
-  if (flags & VVFLAG)
-    rl_variable_dumper (0);
-
-  if ((flags & FFLAG) && initfile)
-    {
-      if (rl_read_init_file (initfile) != 0)
-	{
-	  t = printable_filename (initfile, 0);
-	  builtin_error (_("%s: cannot read: %s"), t, strerror (errno));
-	  if (t != initfile)
-	    free (t);
-	  BIND_RETURN (EXECUTION_FAILURE);
-	}
-    }
-
-  if ((flags & QFLAG) && fun_name)
-    return_code = query_bindings (fun_name);
-
-  if ((flags & UFLAG) && unbind_name)
-    return_code = unbind_command (unbind_name);
-
-  if ((flags & RFLAG) && remove_seq)
-    {
-      opt = unbind_keyseq (remove_seq);
-      BIND_RETURN (opt);
-    }
-
-  if (flags & XFLAG)
-    return_code = bind_keyseq_to_unix_command (cmd_seq);
-
-  if (flags & XXFLAG)
-    return_code = print_unix_command_map ();
-
-  /* Process the rest of the arguments as binding specifications. */
-  while (list)
-    {
-      int olen, nlen, d, i;
-      char **obindings, **nbindings;
-
-      obindings = rl_invoking_keyseqs (bash_execute_unix_command);
-      olen = obindings ? strvec_len (obindings) : 0;
-
-      rl_parse_and_bind (list->word->word);
-
-      nbindings = rl_invoking_keyseqs (bash_execute_unix_command);
-      nlen = nbindings ? strvec_len (nbindings) : 0;
-
-      if (nlen < olen)	/* fewer bind -x bindings */
-	for (d = olen - nlen, i = 0; i < olen && d > 0; i++)
-	  if (nlen == 0 || strvec_search (nbindings, obindings[i]) < 0)
-	    {
-	      unbind_unix_command (obindings[i]);
-	      d--;
-	    }
-
-      strvec_dispose (obindings);
-      strvec_dispose (nbindings);
-
-      list = list->next;
-    }
-
- bind_exit:
-  if (saved_keymap)
-    rl_set_keymap (saved_keymap);
-
-  run_unwind_frame ("bind_builtin");
-
-  if (return_code < 0)
-    return_code = EXECUTION_FAILURE;
-
-  return (sh_chkwrite (return_code));
-}
-
-static int
-query_bindings (name)
-     char *name;
-{
-  rl_command_func_t *function;
-  char **keyseqs;
-  int j;
-
-  function = rl_named_function (name);
-  if (function == 0)
-    {
-      builtin_error (_("`%s': unknown function name"), name);
-      return EXECUTION_FAILURE;
-    }
-
-  keyseqs = rl_invoking_keyseqs (function);
-
-  if (!keyseqs)
-    {
-      printf (_("%s is not bound to any keys.\n"), name);
-      return EXECUTION_FAILURE;
-    }
-
-  printf (_("%s can be invoked via "), name);
-  for (j = 0; j < 5 && keyseqs[j]; j++)
-    printf ("\"%s\"%s", keyseqs[j], keyseqs[j + 1] ? ", " : ".\n");
-  if (keyseqs[j])
-    printf ("...\n");
-  strvec_dispose (keyseqs);
-  return EXECUTION_SUCCESS;
-}
-
-static int
-unbind_command (name)
-     char *name;
-{
-  rl_command_func_t *function;
-
-  function = rl_named_function (name);
-  if (function == 0)
-    {
-      builtin_error (_("`%s': unknown function name"), name);
-      return EXECUTION_FAILURE;
-    }
-
-  rl_unbind_function_in_map (function, rl_get_keymap ());
-  return EXECUTION_SUCCESS;
-}
-
-static int
-unbind_keyseq (seq)
-     char *seq;
-{
-  char *kseq;
-  int kslen, type;
-  rl_command_func_t *f;
-
-  kseq = (char *)xmalloc ((2 * strlen (seq)) + 1);
-  if (rl_translate_keyseq (seq, kseq, &kslen))
-    {
-      free (kseq);
-      builtin_error (_("`%s': cannot unbind"), seq);
-      return EXECUTION_FAILURE;
-    }
-  if ((f = rl_function_of_keyseq_len (kseq, kslen, (Keymap)0, &type)) == 0)
-    {
-      free (kseq);
-      return (EXECUTION_SUCCESS);
-    }
-  if (type == ISKMAP)
-    f = ((Keymap) f)[ANYOTHERKEY].function;
-
-  /* I wish this didn't have to translate the key sequence again, but readline
-     doesn't have a binding function that takes a translated key sequence as
-     an argument. */
-  if (rl_bind_keyseq (seq, (rl_command_func_t *)NULL) != 0)
-    {
-      free (kseq);
-      builtin_error (_("`%s': cannot unbind"), seq);
-      return (EXECUTION_FAILURE);
-    }
-
-  if (f == bash_execute_unix_command)
-    unbind_unix_command (seq);
-
-  free (kseq);
-  return (EXECUTION_SUCCESS);
-}
-#endif /* READLINE */
diff --git a/third_party/bash/builtins_break.c b/third_party/bash/builtins_break.c
deleted file mode 100644
index 827b1a556..000000000
--- a/third_party/bash/builtins_break.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/* break.c, created from break.def. */
-#line 22 "./break.def"
-
-#line 34 "./break.def"
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "common.h"
-
-static int check_loop_level PARAMS((void));
-
-/* The depth of while's and until's. */
-int loop_level = 0;
-
-/* Non-zero when a "break" instruction is encountered. */
-int breaking = 0;
-
-/* Non-zero when we have encountered a continue instruction. */
-int continuing = 0;
-
-/* Set up to break x levels, where x defaults to 1, but can be specified
-   as the first argument. */
-int
-break_builtin (list)
-     WORD_LIST *list;
-{
-  intmax_t newbreak;
-
-  CHECK_HELPOPT (list);
-
-  if (check_loop_level () == 0)
-    return (EXECUTION_SUCCESS);
-
-  (void)get_numeric_arg (list, 1, &newbreak);
-
-  if (newbreak <= 0)
-    {
-      sh_erange (list->word->word, _("loop count"));
-      breaking = loop_level;
-      return (EXECUTION_FAILURE);
-    }
-
-  if (newbreak > loop_level)
-    newbreak = loop_level;
-
-  breaking = newbreak;
-
-  return (EXECUTION_SUCCESS);
-}
-
-#line 101 "./break.def"
-
-/* Set up to continue x levels, where x defaults to 1, but can be specified
-   as the first argument. */
-int
-continue_builtin (list)
-     WORD_LIST *list;
-{
-  intmax_t newcont;
-
-  CHECK_HELPOPT (list);
-
-  if (check_loop_level () == 0)
-    return (EXECUTION_SUCCESS);
-
-  (void)get_numeric_arg (list, 1, &newcont);
-
-  if (newcont <= 0)
-    {
-      sh_erange (list->word->word, _("loop count"));
-      breaking = loop_level;
-      return (EXECUTION_FAILURE);
-    }
-
-  if (newcont > loop_level)
-    newcont = loop_level;
-
-  continuing = newcont;
-
-  return (EXECUTION_SUCCESS);
-}
-
-/* Return non-zero if a break or continue command would be okay.
-   Print an error message if break or continue is meaningless here. */
-static int
-check_loop_level ()
-{
-#if defined (BREAK_COMPLAINS)
-  if (loop_level == 0 && posixly_correct == 0)
-    builtin_error (_("only meaningful in a `for', `while', or `until' loop"));
-#endif /* BREAK_COMPLAINS */
-
-  return (loop_level);
-}
diff --git a/third_party/bash/builtins_builtin.c b/third_party/bash/builtins_builtin.c
deleted file mode 100644
index 2029376cc..000000000
--- a/third_party/bash/builtins_builtin.c
+++ /dev/null
@@ -1,54 +0,0 @@
-/* builtin.c, created from builtin.def. */
-#line 22 "./builtin.def"
-
-#line 36 "./builtin.def"
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-/* Run the command mentioned in list directly, without going through the
-   normal alias/function/builtin/filename lookup process. */
-int
-builtin_builtin (list)
-     WORD_LIST *list;
-{
-  sh_builtin_func_t *function;
-  register char *command;
-
-  if (no_options (list))
-    return (EX_USAGE);
-  list = loptend;	/* skip over possible `--' */
-
-  if (list == 0)
-    return (EXECUTION_SUCCESS);
-
-  command = list->word->word;
-#if defined (DISABLED_BUILTINS)
-  function = builtin_address (command);
-#else /* !DISABLED_BUILTINS */
-  function = find_shell_builtin (command);
-#endif /* !DISABLED_BUILTINS */
-
-  if (function == 0)
-    {
-      sh_notbuiltin (command);
-      return (EXECUTION_FAILURE);
-    }
-  else
-    {
-      this_command_name = command;
-      this_shell_builtin = function;	/* overwrite "builtin" as this builtin */
-      list = list->next;
-      return ((*function) (list));
-    }
-}
diff --git a/third_party/bash/builtins_caller.c b/third_party/bash/builtins_caller.c
deleted file mode 100644
index accb9455e..000000000
--- a/third_party/bash/builtins_caller.c
+++ /dev/null
@@ -1,120 +0,0 @@
-/* caller.c, created from caller.def. */
-#line 23 "./caller.def"
-
-#line 41 "./caller.def"
-
-#include "config.h"
-#include <stdio.h>
-#include "chartypes.h"
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <errno.h>
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "common.h"
-#include "builtext.h"
-#include "bashgetopt.h"
-
-#ifdef LOADABLE_BUILTIN
-#  include "builtins.h"
-#endif
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-int
-caller_builtin (list)
-     WORD_LIST *list;
-{
-#if !defined (ARRAY_VARS)
-  printf ("1 NULL\n");
-  return (EXECUTION_FAILURE);
-#else
-  SHELL_VAR *funcname_v, *bash_source_v, *bash_lineno_v;
-  ARRAY *funcname_a, *bash_source_a, *bash_lineno_a;
-  char *funcname_s, *source_s, *lineno_s;
-  intmax_t num;
-
-  CHECK_HELPOPT (list);
-
-  GET_ARRAY_FROM_VAR ("FUNCNAME", funcname_v, funcname_a);
-  GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v, bash_source_a);
-  GET_ARRAY_FROM_VAR ("BASH_LINENO", bash_lineno_v, bash_lineno_a);
-
-  if (bash_lineno_a == 0 || array_empty (bash_lineno_a))
-    return (EXECUTION_FAILURE);
-
-  if (bash_source_a == 0 || array_empty (bash_source_a))
-    return (EXECUTION_FAILURE);
-
- if (no_options (list))
-    return (EX_USAGE);
-  list = loptend;       /* skip over possible `--' */
-
-  /* If there is no argument list, then give short form: line filename. */
-  if (list == 0)
-    {
-      lineno_s = array_reference (bash_lineno_a, 0);
-      source_s = array_reference (bash_source_a, 1);
-      printf("%s %s\n", lineno_s ? lineno_s : "NULL", source_s ? source_s : "NULL");
-      return (EXECUTION_SUCCESS);
-    }
-  
-  if (funcname_a == 0 || array_empty (funcname_a))
-    return (EXECUTION_FAILURE);
-
-  if (legal_number (list->word->word, &num))
-    {
-      lineno_s = array_reference (bash_lineno_a, num);
-      source_s = array_reference (bash_source_a, num+1);
-      funcname_s = array_reference (funcname_a, num+1);
-
-      if (lineno_s == NULL|| source_s == NULL || funcname_s == NULL)
-	return (EXECUTION_FAILURE);
-
-      printf("%s %s %s\n", lineno_s, funcname_s, source_s);
-    }
-  else
-    {
-      sh_invalidnum (list->word->word);
-      builtin_usage ();
-      return (EX_USAGE);
-    }
-
-  return (EXECUTION_SUCCESS);
-#endif
-}
-
-#ifdef LOADABLE_BUILTIN
-static char *caller_doc[] = {
-N_("Returns the context of the current subroutine call.\n\
-    \n\
-    Without EXPR, returns \"$line $filename\".  With EXPR, returns\n\
-    \"$line $subroutine $filename\"; this extra information can be used to\n\
-    provide a stack trace.\n\
-    \n\
-    The value of EXPR indicates how many call frames to go back before the\n\
-    current one; the top frame is frame 0."),
-  (char *)NULL
-};
-
-struct builtin caller_struct = {
-	"caller",
-	caller_builtin,
-	BUILTIN_ENABLED,
-	caller_doc,
-	"caller [EXPR]",
-	0
-};
-
-#endif /* LOADABLE_BUILTIN */
diff --git a/third_party/bash/builtins_cd.c b/third_party/bash/builtins_cd.c
deleted file mode 100644
index 29f3b735d..000000000
--- a/third_party/bash/builtins_cd.c
+++ /dev/null
@@ -1,613 +0,0 @@
-/* cd.c, created from cd.def. */
-#line 22 "./cd.def"
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashtypes.h"
-#include "posixdir.h"
-#include "posixstat.h"
-#if defined (HAVE_SYS_PARAM_H)
-#include <sys/param.h>
-#endif
-#include <fcntl.h>
-
-#include <stdio.h>
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include <errno.h>
-#include "tilde.h"
-
-#include "shell.h"
-#include "flags.h"
-#include "maxpath.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-extern const char * const bash_getcwd_errstr;
-
-static int bindpwd PARAMS((int));
-static int setpwd PARAMS((char *));
-static char *resetpwd PARAMS((char *));
-static int change_to_directory PARAMS((char *, int, int));
-
-static int cdxattr PARAMS((char *, char **));
-static void resetxattr PARAMS((void));
-
-/* Change this to 1 to get cd spelling correction by default. */
-int cdspelling = 0;
-
-int cdable_vars;
-
-static int eflag;	/* file scope so bindpwd() can see it */
-static int xattrflag;	/* O_XATTR support for openat */
-static int xattrfd = -1;
-
-#line 115 "./cd.def"
-
-/* Just set $PWD, don't change OLDPWD.  Used by `pwd -P' in posix mode. */
-static int
-setpwd (dirname)
-     char *dirname;
-{
-  int old_anm;
-  SHELL_VAR *tvar;
-
-  old_anm = array_needs_making;
-  tvar = bind_variable ("PWD", dirname ? dirname : "", 0);
-  if (tvar && readonly_p (tvar))
-    return EXECUTION_FAILURE;
-  if (tvar && old_anm == 0 && array_needs_making && exported_p (tvar))
-    {
-      update_export_env_inplace ("PWD=", 4, dirname ? dirname : "");
-      array_needs_making = 0;
-    }
-  return EXECUTION_SUCCESS;
-}
-
-static int
-bindpwd (no_symlinks)
-     int no_symlinks;
-{
-  char *dirname, *pwdvar;
-  int old_anm, r, canon_failed;
-  SHELL_VAR *tvar;
-
-  r = sh_chkwrite (EXECUTION_SUCCESS);
-
-#define tcwd the_current_working_directory
-  dirname = tcwd ? (no_symlinks ? sh_physpath (tcwd, 0) : tcwd)
-  		 : get_working_directory ("cd");
-#undef tcwd
-
-  /* If canonicalization fails, reset dirname to the_current_working_directory */
-  canon_failed = 0;
-  if (dirname == 0)
-    {
-      canon_failed = 1;
-      dirname = the_current_working_directory;
-    }
-
-  old_anm = array_needs_making;
-  pwdvar = get_string_value ("PWD");
-
-  tvar = bind_variable ("OLDPWD", pwdvar, 0);
-  if (tvar && readonly_p (tvar))
-    r = EXECUTION_FAILURE;
-
-  if (old_anm == 0 && array_needs_making && exported_p (tvar))
-    {
-      update_export_env_inplace ("OLDPWD=", 7, pwdvar);
-      array_needs_making = 0;
-    }
-
-  if (setpwd (dirname) == EXECUTION_FAILURE)
-    r = EXECUTION_FAILURE;
-  if (canon_failed && eflag)
-    r = EXECUTION_FAILURE;
-
-  if (dirname && dirname != the_current_working_directory)
-    free (dirname);
-
-  return (r);
-}
-
-/* Call get_working_directory to reset the value of
-   the_current_working_directory () */
-static char *
-resetpwd (caller)
-     char *caller;
-{
-  char *tdir;
-      
-  FREE (the_current_working_directory);
-  the_current_working_directory = (char *)NULL;
-  tdir = get_working_directory (caller);
-  return (tdir);
-}
-
-static int
-cdxattr (dir, ndirp)
-     char *dir;		/* don't assume we can always free DIR */
-     char **ndirp;	/* return new constructed directory name */
-{
-#if defined (O_XATTR)
-  int apfd, fd, r, e;
-  char buf[11+40+40];	/* construct new `fake' path for pwd */
-
-  apfd = openat (AT_FDCWD, dir, O_RDONLY|O_NONBLOCK);
-  if (apfd < 0)
-    return -1;
-  fd = openat (apfd, ".", O_XATTR);
-  e = errno;
-  close (apfd);		/* ignore close error for now */
-  errno = e;
-  if (fd < 0)
-    return -1;
-  r = fchdir (fd);	/* assume fchdir exists everywhere with O_XATTR */
-  if (r < 0)
-    {
-      close (fd);
-      return -1;
-    }
-  /* NFSv4 and ZFS extended attribute directories do not have names which are
-     visible in the standard Unix directory tree structure.  To ensure we have
-     a valid name for $PWD, we synthesize one under /proc, but to keep that
-     path valid, we need to keep the file descriptor open as long as we are in
-     this directory.  This imposes a certain structure on /proc. */
-  if (ndirp)
-    {
-      sprintf (buf, "/proc/%d/fd/%d", getpid(), fd);
-      *ndirp = savestring (buf);
-    }
-
-  if (xattrfd >= 0)
-    close (xattrfd);
-  xattrfd = fd;  
-
-  return r;
-#else
-  return -1;
-#endif
-}
-
-/* Clean up the O_XATTR baggage.  Currently only closes xattrfd */
-static void
-resetxattr ()
-{
-#if defined (O_XATTR)
-  if (xattrfd >= 0)
-    {
-      close (xattrfd);
-      xattrfd = -1;
-    }
-#else
-  xattrfd = -1;		/* not strictly necessary */
-#endif
-}
-
-#define LCD_DOVARS	0x001
-#define LCD_DOSPELL	0x002
-#define LCD_PRINTPATH	0x004
-#define LCD_FREEDIRNAME	0x008
-
-/* This builtin is ultimately the way that all user-visible commands should
-   change the current working directory.  It is called by cd_to_string (),
-   so the programming interface is simple, and it handles errors and
-   restrictions properly. */
-int
-cd_builtin (list)
-     WORD_LIST *list;
-{
-  char *dirname, *cdpath, *path, *temp;
-  int path_index, no_symlinks, opt, lflag, e;
-
-#if defined (RESTRICTED_SHELL)
-  if (restricted)
-    {
-      sh_restricted ((char *)NULL);
-      return (EXECUTION_FAILURE);
-    }
-#endif /* RESTRICTED_SHELL */
-
-  eflag = 0;
-  no_symlinks = no_symbolic_links;
-  xattrflag = 0;
-  reset_internal_getopt ();
-#if defined (O_XATTR)
-  while ((opt = internal_getopt (list, "eLP@")) != -1)
-#else
-  while ((opt = internal_getopt (list, "eLP")) != -1)
-#endif
-    {
-      switch (opt)
-	{
-	case 'P':
-	  no_symlinks = 1;
-	  break;
-	case 'L':
-	  no_symlinks = 0;
-	  break;
-	case 'e':
-	  eflag = 1;
-	  break;
-#if defined (O_XATTR)
-	case '@':
-	  xattrflag = 1;
-	  break;
-#endif
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  lflag = (cdable_vars ? LCD_DOVARS : 0) |
-	  ((interactive && cdspelling) ? LCD_DOSPELL : 0);
-  if (eflag && no_symlinks == 0)
-    eflag = 0;
-
-  if (list == 0)
-    {
-      /* `cd' without arguments is equivalent to `cd $HOME' */
-      dirname = get_string_value ("HOME");
-
-      if (dirname == 0)
-	{
-	  builtin_error (_("HOME not set"));
-	  return (EXECUTION_FAILURE);
-	}
-      lflag = 0;
-    }
-#if defined (CD_COMPLAINS)
-  else if (list->next)
-    {
-      builtin_error (_("too many arguments"));
-      return (EXECUTION_FAILURE);
-    }
-#endif
-#if 0
-  else if (list->word->word[0] == '\0')
-    {
-      builtin_error (_("null directory"));
-      return (EXECUTION_FAILURE);
-    }
-#endif
-  else if (list->word->word[0] == '-' && list->word->word[1] == '\0')
-    {
-      /* This is `cd -', equivalent to `cd $OLDPWD' */
-      dirname = get_string_value ("OLDPWD");
-
-      if (dirname == 0)
-	{
-	  builtin_error (_("OLDPWD not set"));
-	  return (EXECUTION_FAILURE);
-	}
-#if 0
-      lflag = interactive ? LCD_PRINTPATH : 0;
-#else
-      lflag = LCD_PRINTPATH;		/* According to SUSv3 */
-#endif
-    }
-  else if (absolute_pathname (list->word->word))
-    dirname = list->word->word;
-  else if (privileged_mode == 0 && (cdpath = get_string_value ("CDPATH")))
-    {
-      dirname = list->word->word;
-
-      /* Find directory in $CDPATH. */
-      path_index = 0;
-      while (path = extract_colon_unit (cdpath, &path_index))
-	{
-	  /* OPT is 1 if the path element is non-empty */
-	  opt = path[0] != '\0';
-	  temp = sh_makepath (path, dirname, MP_DOTILDE);
-	  free (path);
-
-	  if (change_to_directory (temp, no_symlinks, xattrflag))
-	    {
-	      /* POSIX.2 says that if a nonempty directory from CDPATH
-		 is used to find the directory to change to, the new
-		 directory name is echoed to stdout, whether or not
-		 the shell is interactive. */
-	      if (opt && (path = no_symlinks ? temp : the_current_working_directory))
-		printf ("%s\n", path);
-
-	      free (temp);
-#if 0
-	      /* Posix.2 says that after using CDPATH, the resultant
-		 value of $PWD will not contain `.' or `..'. */
-	      return (bindpwd (posixly_correct || no_symlinks));
-#else
-	      return (bindpwd (no_symlinks));
-#endif
-	    }
-	  else
-	    free (temp);
-	}
-
-#if 0
-      /* changed for bash-4.2 Posix cd description steps 5-6 */
-      /* POSIX.2 says that if `.' does not appear in $CDPATH, we don't
-	 try the current directory, so we just punt now with an error
-	 message if POSIXLY_CORRECT is non-zero.  The check for cdpath[0]
-	 is so we don't mistakenly treat a CDPATH value of "" as not
-	 specifying the current directory. */
-      if (posixly_correct && cdpath[0])
-	{
-	  builtin_error ("%s: %s", dirname, strerror (ENOENT));
-	  return (EXECUTION_FAILURE);
-	}
-#endif
-    }
-  else
-    dirname = list->word->word;
-
-  /* When we get here, DIRNAME is the directory to change to.  If we
-     chdir successfully, just return. */
-  if (change_to_directory (dirname, no_symlinks, xattrflag))
-    {
-      if (lflag & LCD_PRINTPATH)
-	printf ("%s\n", dirname);
-      return (bindpwd (no_symlinks));
-    }
-
-  /* If the user requests it, then perhaps this is the name of
-     a shell variable, whose value contains the directory to
-     change to. */
-  if (lflag & LCD_DOVARS)
-    {
-      temp = get_string_value (dirname);
-      if (temp && change_to_directory (temp, no_symlinks, xattrflag))
-	{
-	  printf ("%s\n", temp);
-	  return (bindpwd (no_symlinks));
-	}
-    }
-
-  /* If the user requests it, try to find a directory name similar in
-     spelling to the one requested, in case the user made a simple
-     typo.  This is similar to the UNIX 8th and 9th Edition shells. */
-  if (lflag & LCD_DOSPELL)
-    {
-      temp = dirspell (dirname);
-      if (temp && change_to_directory (temp, no_symlinks, xattrflag))
-	{
-	  printf ("%s\n", temp);
-	  free (temp);
-	  return (bindpwd (no_symlinks));
-	}
-      else
-	FREE (temp);
-    }
-
-  e = errno;
-  temp = printable_filename (dirname, 0);
-  builtin_error ("%s: %s", temp, strerror (e));
-  if (temp != dirname)
-    free (temp);
-  return (EXECUTION_FAILURE);
-}
-
-#line 478 "./cd.def"
-
-/* Non-zero means that pwd always prints the physical directory, without
-   symbolic links. */
-static int verbatim_pwd;
-
-/* Print the name of the current working directory. */
-int
-pwd_builtin (list)
-     WORD_LIST *list;
-{
-  char *directory;
-  int opt, pflag;
-
-  verbatim_pwd = no_symbolic_links;
-  pflag = 0;
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "LP")) != -1)
-    {
-      switch (opt)
-	{
-	case 'P':
-	  verbatim_pwd = pflag = 1;
-	  break;
-	case 'L':
-	  verbatim_pwd = 0;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-#define tcwd the_current_working_directory
-
-  directory = tcwd ? (verbatim_pwd ? sh_physpath (tcwd, 0) : tcwd)
-		   : get_working_directory ("pwd");
-
-  /* Try again using getcwd() if canonicalization fails (for instance, if
-     the file system has changed state underneath bash). */
-  if ((tcwd && directory == 0) ||
-      (posixly_correct && same_file (".", tcwd, (struct stat *)0, (struct stat *)0) == 0))
-    {
-      if (directory && directory != tcwd)
-        free (directory);
-      directory = resetpwd ("pwd");
-    }
-
-#undef tcwd
-
-  if (directory)
-    {
-      opt = EXECUTION_SUCCESS;
-      printf ("%s\n", directory);
-      /* This is dumb but posix-mandated. */
-      if (posixly_correct && pflag)
-	opt = setpwd (directory);
-      if (directory != the_current_working_directory)
-	free (directory);
-      return (sh_chkwrite (opt));
-    }
-  else
-    return (EXECUTION_FAILURE);
-}
-
-/* Do the work of changing to the directory NEWDIR.  Handle symbolic
-   link following, etc.  This function *must* return with
-   the_current_working_directory either set to NULL (in which case
-   getcwd() will eventually be called), or set to a string corresponding
-   to the working directory.  Return 1 on success, 0 on failure. */
-
-static int
-change_to_directory (newdir, nolinks, xattr)
-     char *newdir;
-     int nolinks, xattr;
-{
-  char *t, *tdir, *ndir;
-  int err, canon_failed, r, ndlen;
-
-  tdir = (char *)NULL;
-
-  if (the_current_working_directory == 0)
-    {
-      t = get_working_directory ("chdir");
-      FREE (t);
-    }
-
-  t = make_absolute (newdir, the_current_working_directory);
-
-  /* TDIR is either the canonicalized absolute pathname of NEWDIR
-     (nolinks == 0) or the absolute physical pathname of NEWDIR
-     (nolinks != 0). */
-  tdir = nolinks ? sh_physpath (t, 0)
-		 : sh_canonpath (t, PATH_CHECKDOTDOT|PATH_CHECKEXISTS);
-
-  ndlen = strlen (newdir);
-
-  /* Use the canonicalized version of NEWDIR, or, if canonicalization
-     failed, use the non-canonical form. */
-  canon_failed = 0;
-  if (tdir && *tdir)
-    free (t);
-  else
-    {
-      FREE (tdir);
-      tdir = t;
-      canon_failed = 1;
-    }
-
-  /* In POSIX mode, if we're resolving symlinks logically and sh_canonpath
-     returns NULL (because it checks the path, it will return NULL if the
-     resolved path doesn't exist), fail immediately. */
-#if defined (ENAMETOOLONG)
-  if (posixly_correct && nolinks == 0 && canon_failed && (errno != ENAMETOOLONG || ndlen > PATH_MAX))
-#else
-  if (posixly_correct && nolinks == 0 && canon_failed && ndlen > PATH_MAX)
-#endif
-    {
-#if defined ENAMETOOLONG
-      if (errno != ENOENT && errno != ENAMETOOLONG)
-#else
-      if (errno != ENOENT)
-#endif
-	errno = ENOTDIR;
-      free (tdir);
-      return (0);
-    }
-
-#if defined (O_XATTR)
-  if (xattrflag)
-    {
-      r = cdxattr (nolinks ? newdir : tdir, &ndir);
-      if (r >= 0)
-	{
-	  canon_failed = 0;
-	  free (tdir);
-	  tdir = ndir;
-	}
-      else
-	{
-	  err = errno;
-	  free (tdir);
-	  errno = err;
-	  return (0);		/* no xattr */
-	}
-    }
-  else
-#endif
-    {
-      r = chdir (nolinks ? newdir : tdir);
-      if (r >= 0)
-	resetxattr ();
-    }
-
-  /* If the chdir succeeds, update the_current_working_directory. */
-  if (r == 0)
-    {
-      /* If canonicalization failed, but the chdir succeeded, reset the
-	 shell's idea of the_current_working_directory. */
-      if (canon_failed)
-	{
-	  t = resetpwd ("cd");
-	  if (t == 0)
-	    set_working_directory (tdir);
-	  else
-	    free (t);
-	}
-      else
-	set_working_directory (tdir);
-
-      free (tdir);
-      return (1);
-    }
-
-  /* We failed to change to the appropriate directory name.  If we tried
-     what the user passed (nolinks != 0), punt now. */
-  if (nolinks)
-    {
-      free (tdir);
-      return (0);
-    }
-
-  err = errno;
-
-  /* We're not in physical mode (nolinks == 0), but we failed to change to
-     the canonicalized directory name (TDIR).  Try what the user passed
-     verbatim. If we succeed, reinitialize the_current_working_directory.
-     POSIX requires that we just fail here, so we do in posix mode. */
-  if (posixly_correct == 0 && chdir (newdir) == 0)
-    {
-      t = resetpwd ("cd");
-      if (t == 0)
-	set_working_directory (tdir);
-      else
-	free (t);
-
-      r = 1;
-    }
-  else
-    {
-      errno = err;
-      r = 0;
-    }
-
-  free (tdir);
-  return r;
-}
diff --git a/third_party/bash/builtins_colon.c b/third_party/bash/builtins_colon.c
deleted file mode 100644
index dcb10e91c..000000000
--- a/third_party/bash/builtins_colon.c
+++ /dev/null
@@ -1,33 +0,0 @@
-/* colon.c, created from colon.def. */
-#line 22 "./colon.def"
-
-#line 34 "./colon.def"
-
-#line 43 "./colon.def"
-
-#line 52 "./colon.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "shell.h"
-
-/* Return a successful result. */
-int
-colon_builtin (ignore)
-     WORD_LIST *ignore;
-{
-  return (0);
-}
-
-/* Return an unsuccessful result. */
-int
-false_builtin (ignore)
-     WORD_LIST *ignore;
-{
-  return (1);
-}
diff --git a/third_party/bash/builtins_command.c b/third_party/bash/builtins_command.c
deleted file mode 100644
index c41887ec9..000000000
--- a/third_party/bash/builtins_command.c
+++ /dev/null
@@ -1,107 +0,0 @@
-/* command.c, created from command.def. */
-#line 22 "./command.def"
-
-#line 41 "./command.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "flags.h"
-#include "bashgetopt.h"
-#include "common.h"
-
-#if defined (_CS_PATH) && defined (HAVE_CONFSTR) && !HAVE_DECL_CONFSTR
-extern size_t confstr PARAMS((int, char *, size_t));
-#endif
-
-/* Run the commands mentioned in LIST without paying attention to shell
-   functions. */
-int
-command_builtin (list)
-     WORD_LIST *list;
-{
-  int result, verbose, use_standard_path, opt;
-  COMMAND *command;
-
-  verbose = use_standard_path = 0;
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "pvV")) != -1)
-    {
-      switch (opt)
-	{
-	case 'p':
-	  use_standard_path = CDESC_STDPATH;
-	  break;
-	case 'V':
-	  verbose = CDESC_SHORTDESC|CDESC_ABSPATH;	/* look in common.h for constants */
-	  break;
-	case 'v':
-	  verbose = CDESC_REUSABLE;	/* ditto */
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  if (list == 0)
-    return (EXECUTION_SUCCESS);
-
-#if defined (RESTRICTED_SHELL)
-  if (use_standard_path && restricted)
-    {
-      sh_restricted ("-p");
-      return (EXECUTION_FAILURE);
-    }
-#endif
-
-  if (verbose)
-    {
-      int found, any_found;
-
-      for (any_found = 0; list; list = list->next)
-	{
-	  found = describe_command (list->word->word, verbose|use_standard_path);
-
-	  if (found == 0 && verbose != CDESC_REUSABLE)
-	    sh_notfound (list->word->word);
-
-	  any_found += found;
-	}
-
-      return (any_found ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-    }
-
-  begin_unwind_frame ("command_builtin");
-
-#define COMMAND_BUILTIN_FLAGS (CMD_NO_FUNCTIONS | CMD_INHIBIT_EXPANSION | CMD_COMMAND_BUILTIN | (use_standard_path ? CMD_STDPATH : 0))
-
-  INTERNAL_DEBUG (("command_builtin: running execute_command for `%s'", list->word->word));
-
-  /* We don't want this to be reparsed (consider command echo 'foo &'), so
-     just make a simple_command structure and call execute_command with it. */
-  command = make_bare_simple_command ();
-  command->value.Simple->words = (WORD_LIST *)copy_word_list (list);
-  command->value.Simple->redirects = (REDIRECT *)NULL;
-  command->flags |= COMMAND_BUILTIN_FLAGS;
-  command->value.Simple->flags |= COMMAND_BUILTIN_FLAGS;
-
-  add_unwind_protect ((char *)dispose_command, command);
-  result = execute_command (command);
-
-  run_unwind_frame ("command_builtin");
-
-  return (result);
-}
diff --git a/third_party/bash/builtins_complete.c b/third_party/bash/builtins_complete.c
deleted file mode 100644
index 2309fe446..000000000
--- a/third_party/bash/builtins_complete.c
+++ /dev/null
@@ -1,805 +0,0 @@
-/* complete.c, created from complete.def. */
-#line 22 "./complete.def"
-
-#line 51 "./complete.def"
-
-#include "config.h"
-
-#include <stdio.h>
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "builtins.h"
-#include "pcomplete.h"
-#include "bashline.h"
-
-#include "common.h"
-#include "bashgetopt.h"
-
-#include "third_party/readline/readline.h"
-
-#define STRDUP(x)       ((x) ? savestring (x) : (char *)NULL)
-
-/* Structure containing all the non-action (binary) options; filled in by
-   build_actions(). */
-struct _optflags {
-  int pflag;
-  int rflag;
-  int Dflag;
-  int Eflag;
-  int Iflag;
-};
-
-static int find_compact PARAMS((char *));
-static int find_compopt PARAMS((char *));
-
-static int build_actions PARAMS((WORD_LIST *, struct _optflags *, unsigned long *, unsigned long *));
-
-static int remove_cmd_completions PARAMS((WORD_LIST *));
-
-static int print_one_completion PARAMS((char *, COMPSPEC *));
-static int print_compitem PARAMS((BUCKET_CONTENTS *));
-static void print_compopts PARAMS((const char *, COMPSPEC *, int));
-static void print_all_completions PARAMS((void));
-static int print_cmd_completions PARAMS((WORD_LIST *));
-
-static void print_compoptions PARAMS((unsigned long, int));
-static void print_compactions PARAMS((unsigned long));
-static void print_arg PARAMS((const char *, const char *, int));
-static void print_cmd_name PARAMS((const char *));
-
-static char *Garg, *Warg, *Parg, *Sarg, *Xarg, *Farg, *Carg;
-
-static const struct _compacts {
-  const char * const actname;
-  unsigned long actflag;
-  int actopt;
-} compacts[] = {
-  { "alias",     CA_ALIAS,     'a' },
-  { "arrayvar",  CA_ARRAYVAR,   0 },
-  { "binding",   CA_BINDING,    0 },
-  { "builtin",   CA_BUILTIN,   'b' },
-  { "command",   CA_COMMAND,   'c' },
-  { "directory", CA_DIRECTORY, 'd' },
-  { "disabled",  CA_DISABLED,   0 },
-  { "enabled",   CA_ENABLED,    0 },
-  { "export",    CA_EXPORT,    'e' },
-  { "file",      CA_FILE,      'f' },
-  { "function",  CA_FUNCTION,   0 },
-  { "helptopic", CA_HELPTOPIC,  0 },
-  { "hostname",  CA_HOSTNAME,   0 },
-  { "group",     CA_GROUP,     'g' },
-  { "job",       CA_JOB,       'j' },
-  { "keyword",   CA_KEYWORD,   'k' },
-  { "running",   CA_RUNNING,    0 },
-  { "service",   CA_SERVICE,   's' },
-  { "setopt",    CA_SETOPT,     0 },
-  { "shopt",     CA_SHOPT,      0 },
-  { "signal",    CA_SIGNAL,     0 },
-  { "stopped",   CA_STOPPED,    0 },
-  { "user",      CA_USER,      'u' },
-  { "variable",  CA_VARIABLE,  'v' },
-  { (char *)NULL, 0, 0 },
-};
-
-/* This should be a STRING_INT_ALIST */
-static const struct _compopt {
-  const char * const optname;
-  unsigned long optflag;
-} compopts[] = {
-  { "bashdefault", COPT_BASHDEFAULT },
-  { "default",	COPT_DEFAULT },
-  { "dirnames", COPT_DIRNAMES },
-  { "filenames",COPT_FILENAMES},
-  { "noquote", COPT_NOQUOTE },
-  { "nosort", COPT_NOSORT },
-  { "nospace",	COPT_NOSPACE },
-  { "plusdirs", COPT_PLUSDIRS },
-  { (char *)NULL, 0 },
-};
-
-static int
-find_compact (name)
-     char *name;
-{
-  register int i;
-
-  for (i = 0; compacts[i].actname; i++)
-    if (STREQ (name, compacts[i].actname))
-      return i;
-  return -1;
-}
-
-static int
-find_compopt (name)
-     char *name;
-{
-  register int i;
-
-  for (i = 0; compopts[i].optname; i++)
-    if (STREQ (name, compopts[i].optname))
-      return i;
-  return -1;
-}
-
-/* Build the actions and compspec options from the options specified in LIST.
-   ACTP is a pointer to an unsigned long in which to place the bitmap of
-   actions.  OPTP is a pointer to an unsigned long in which to place the
-   bitmap of compspec options (arguments to `-o').  PP, if non-null, gets 1
-   if -p is supplied; RP, if non-null, gets 1 if -r is supplied.
-   If either is null, the corresponding option generates an error.
-   This also sets variables corresponding to options that take arguments as
-   a side effect; the caller should ensure that those variables are set to
-   NULL before calling build_actions.  Return value:
-   	EX_USAGE = bad option
-   	EXECUTION_SUCCESS = some options supplied
-   	EXECUTION_FAILURE = no options supplied
-*/
-
-static int
-build_actions (list, flagp, actp, optp)
-     WORD_LIST *list;
-     struct _optflags *flagp;
-     unsigned long *actp, *optp;
-{
-  int opt, ind, opt_given;
-  unsigned long acts, copts;
-  WORD_DESC w;
-
-  acts = copts = (unsigned long)0L;
-  opt_given = 0;
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "abcdefgjko:prsuvA:G:W:P:S:X:F:C:DEI")) != -1)
-    {
-      opt_given = 1;
-      switch (opt)
-	{
-	case 'r':
-	  if (flagp)
-	    {
-	      flagp->rflag = 1;
-	      break;
-	    }
-	  else
-	    {
-	      sh_invalidopt ("-r");
-	      builtin_usage ();
-	      return (EX_USAGE);
-	    }
-
-	case 'p':
-	  if (flagp)
-	    {
-	      flagp->pflag = 1;
-	      break;
-	    }
-	  else
-	    {
-	      sh_invalidopt ("-p");
-	      builtin_usage ();
-	      return (EX_USAGE);
-	    }
-
-	case 'a':
-	  acts |= CA_ALIAS;
-	  break;
-	case 'b':
-	  acts |= CA_BUILTIN;
-	  break;
-	case 'c':
-	  acts |= CA_COMMAND;
-	  break;
-	case 'd':
-	  acts |= CA_DIRECTORY;
-	  break;
-	case 'e':
-	  acts |= CA_EXPORT;
-	  break;
-	case 'f':
-	  acts |= CA_FILE;
-	  break;
-	case 'g':
-	  acts |= CA_GROUP;
-	  break;
-	case 'j':
-	  acts |= CA_JOB;
-	  break;
-	case 'k':
-	  acts |= CA_KEYWORD;
-	  break;
-	case 's':
-	  acts |= CA_SERVICE;
-	  break;
-	case 'u':
-	  acts |= CA_USER;
-	  break;
-	case 'v':
-	  acts |= CA_VARIABLE;
-	  break;
-	case 'o':
-	  ind = find_compopt (list_optarg);
-	  if (ind < 0)
-	    {
-	      sh_invalidoptname (list_optarg);
-	      return (EX_USAGE);
-	    }
-	  copts |= compopts[ind].optflag;
-	  break;
-	case 'A':
-	  ind = find_compact (list_optarg);
-	  if (ind < 0)
-	    {
-	      builtin_error (_("%s: invalid action name"), list_optarg);
-	      return (EX_USAGE);
-	    }
-	  acts |= compacts[ind].actflag;
-	  break;
-	case 'C':
-	  Carg = list_optarg;
-	  break;
-	case 'D':
-	  if (flagp)
-	    {
-	      flagp->Dflag = 1;
-	      break;
-	    }
-	  else
-	    {
-	      sh_invalidopt ("-D");
-	      builtin_usage ();
-	      return (EX_USAGE);
-	    }
-	case 'E':
-	  if (flagp)
-	    {
-	      flagp->Eflag = 1;
-	      break;
-	    }
-	  else
-	    {
-	      sh_invalidopt ("-E");
-	      builtin_usage ();
-	      return (EX_USAGE);
-	    }
-	case 'I':
-	  if (flagp)
-	    {
-	      flagp->Iflag = 1;
-	      break;
-	    }
-	  else
-	    {
-	      sh_invalidopt ("-I");
-	      builtin_usage ();
-	      return (EX_USAGE);
-	    }
-	case 'F':
-	  w.word = Farg = list_optarg;
-	  w.flags = 0;
-	  if (check_identifier (&w, posixly_correct) == 0 || strpbrk (Farg, shell_break_chars) != 0)
-	    {
-	      sh_invalidid (Farg);
-	      return (EX_USAGE);
-	    }
-	  break;
-	case 'G':
-	  Garg = list_optarg;
-	  break;
-	case 'P':
-	  Parg = list_optarg;
-	  break;
-	case 'S':
-	  Sarg = list_optarg;
-	  break;
-	case 'W':
-	  Warg = list_optarg;
-	  break;
-	case 'X':
-	  Xarg = list_optarg;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-
-  *actp = acts;
-  *optp = copts;
-
-  return (opt_given ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-}
-
-/* Add, remove, and display completion specifiers. */
-int
-complete_builtin (list)
-     WORD_LIST *list;
-{
-  int opt_given, rval;
-  unsigned long acts, copts;
-  COMPSPEC *cs;
-  struct _optflags oflags;
-  WORD_LIST *l, *wl;
-
-  if (list == 0)
-    {
-      print_all_completions ();
-      return (EXECUTION_SUCCESS);
-    }
-
-  opt_given = oflags.pflag = oflags.rflag = 0;
-  oflags.Dflag = oflags.Eflag = oflags.Iflag = 0;
-
-  acts = copts = (unsigned long)0L;
-  Garg = Warg = Parg = Sarg = Xarg = Farg = Carg = (char *)NULL;
-  cs = (COMPSPEC *)NULL;
-
-  /* Build the actions from the arguments.  Also sets the [A-Z]arg variables
-     as a side effect if they are supplied as options. */
-  rval = build_actions (list, &oflags, &acts, &copts);
-  if (rval == EX_USAGE)
-    return (rval);
-  opt_given = rval != EXECUTION_FAILURE;
-
-  list = loptend;
-
-  if (oflags.Dflag)
-    wl = make_word_list (make_bare_word (DEFAULTCMD), (WORD_LIST *)NULL);
-  else if (oflags.Eflag)
-    wl = make_word_list (make_bare_word (EMPTYCMD), (WORD_LIST *)NULL);
-  else if (oflags.Iflag)
-    wl = make_word_list (make_bare_word (INITIALWORD), (WORD_LIST *)NULL);
-  else
-    wl = (WORD_LIST *)NULL;
-
-  /* -p overrides everything else */
-  if (oflags.pflag || (list == 0 && opt_given == 0))
-    {
-      if (wl)
-	{
-	  rval = print_cmd_completions (wl);
-	  dispose_words (wl);
-	  return rval;
-	}
-      else if (list == 0)
-	{
-	  print_all_completions ();
-	  return (EXECUTION_SUCCESS);
-	}
-      return (print_cmd_completions (list));
-    }
-
-  /* next, -r overrides everything else. */
-  if (oflags.rflag)
-    {
-      if (wl)
-	{
-	  rval = remove_cmd_completions (wl);
-	  dispose_words (wl);
-	  return rval;
-	}
-      else if (list == 0)
-	{
-	  progcomp_flush ();
-	  return (EXECUTION_SUCCESS);
-	}
-      return (remove_cmd_completions (list));
-    }
-
-  if (wl == 0 && list == 0 && opt_given)
-    {
-      builtin_usage ();
-      return (EX_USAGE);
-    }
-
-  /* If we get here, we need to build a compspec and add it for each
-     remaining argument. */
-  cs = compspec_create ();
-  cs->actions = acts;
-  cs->options = copts;
-
-  cs->globpat = STRDUP (Garg);
-  cs->words = STRDUP (Warg);
-  cs->prefix = STRDUP (Parg);
-  cs->suffix = STRDUP (Sarg);
-  cs->funcname = STRDUP (Farg);
-  cs->command = STRDUP (Carg);
-  cs->filterpat = STRDUP (Xarg);
-
-  for (rval = EXECUTION_SUCCESS, l = wl ? wl : list ; l; l = l->next)
-    {
-      /* Add CS as the compspec for the specified commands. */
-      if (progcomp_insert (l->word->word, cs) == 0)
-	rval = EXECUTION_FAILURE;
-    }
-
-  dispose_words (wl);
-  return (rval);
-}
-
-static int
-remove_cmd_completions (list)
-     WORD_LIST *list;
-{
-  WORD_LIST *l;
-  int ret;
-
-  for (ret = EXECUTION_SUCCESS, l = list; l; l = l->next)
-    {
-      if (progcomp_remove (l->word->word) == 0)
-	{
-	  builtin_error (_("%s: no completion specification"), l->word->word);
-	  ret = EXECUTION_FAILURE;
-	}
-    }
-  return ret;
-}
-
-static void
-print_compoptions (copts, full)
-     unsigned long copts;
-     int full;
-{
-  const struct _compopt *co;
-
-  for (co = compopts; co->optname; co++)
-    if (copts & co->optflag)
-      printf ("-o %s ", co->optname);
-    else if (full)
-      printf ("+o %s ", co->optname);
-}
-
-static void
-print_compactions (acts)
-     unsigned long acts;
-{
-  const struct _compacts *ca;
-
-  /* simple flags first */
-  for (ca = compacts; ca->actname; ca++)
-    if (ca->actopt && (acts & ca->actflag))
-      printf ("-%c ", ca->actopt);
-
-  /* then the rest of the actions */
-  for (ca = compacts; ca->actname; ca++)
-    if (ca->actopt == 0 && (acts & ca->actflag))
-      printf ("-A %s ", ca->actname);
-}
-
-static void
-print_arg (arg, flag, quote)
-     const char *arg, *flag;
-     int quote;
-{
-  char *x;
-
-  if (arg)
-    {
-      x = quote ? sh_single_quote (arg) : (char *)arg;
-      printf ("%s %s ", flag, x);
-      if (x != arg)
-	free (x);
-    }
-}
-
-static void
-print_cmd_name (cmd)
-     const char *cmd;
-{
-  char *x;
-
-  if (STREQ (cmd, DEFAULTCMD))
-    printf ("-D");
-  else if (STREQ (cmd, EMPTYCMD))
-    printf ("-E");
-  else if (STREQ (cmd, INITIALWORD))
-    printf ("-I");
-  else if (*cmd == 0)		/* XXX - can this happen? */
-    printf ("''");
-  else if (sh_contains_shell_metas (cmd))
-    {
-      x = sh_single_quote (cmd);
-      printf ("%s", x);
-      free (x);
-    }
-  else
-    printf ("%s", cmd);
-}
-
-static int
-print_one_completion (cmd, cs)
-     char *cmd;
-     COMPSPEC *cs;
-{
-  printf ("complete ");
-
-  print_compoptions (cs->options, 0);
-  print_compactions (cs->actions);
-
-  /* now the rest of the arguments */
-
-  /* arguments that require quoting */
-  print_arg (cs->globpat, "-G", 1);
-  print_arg (cs->words, "-W", 1);
-  print_arg (cs->prefix, "-P", 1);
-  print_arg (cs->suffix, "-S", 1);
-  print_arg (cs->filterpat, "-X", 1);
-
-  print_arg (cs->command, "-C", 1);
-
-  /* simple arguments that don't require quoting */
-  print_arg (cs->funcname, "-F", sh_contains_shell_metas (cs->funcname) != 0);
-
-  print_cmd_name (cmd);
-  printf ("\n");
-
-  return (0);
-}
-
-static void
-print_compopts (cmd, cs, full)
-     const char *cmd;
-     COMPSPEC *cs;
-     int full;
-{
-  printf ("compopt ");
-
-  print_compoptions (cs->options, full);
-  print_cmd_name (cmd);
-
-  printf ("\n");
-}
-
-static int
-print_compitem (item)
-     BUCKET_CONTENTS *item;
-{
-  COMPSPEC *cs;
-  char *cmd;
-
-  cmd = item->key;
-  cs = (COMPSPEC *)item->data;
-
-  return (print_one_completion (cmd, cs));
-}
-
-static void
-print_all_completions ()
-{
-  progcomp_walk (print_compitem);
-}
-
-static int
-print_cmd_completions (list)
-     WORD_LIST *list;
-{
-  WORD_LIST *l;
-  COMPSPEC *cs;
-  int ret;
-
-  for (ret = EXECUTION_SUCCESS, l = list; l; l = l->next)
-    {
-      cs = progcomp_search (l->word->word);
-      if (cs)
-	print_one_completion (l->word->word, cs);
-      else
-	{
-	  builtin_error (_("%s: no completion specification"), l->word->word);
-	  ret = EXECUTION_FAILURE;
-	}
-    }
-
-  return (sh_chkwrite (ret));
-}
-
-#line 663 "./complete.def"
-
-int
-compgen_builtin (list)
-     WORD_LIST *list;
-{
-  int rval;
-  unsigned long acts, copts;
-  COMPSPEC *cs;
-  STRINGLIST *sl;
-  char *word, **matches;
-  char *old_line;
-  int old_ind;
-
-  if (list == 0)
-    return (EXECUTION_SUCCESS);
-
-  acts = copts = (unsigned long)0L;
-  Garg = Warg = Parg = Sarg = Xarg = Farg = Carg = (char *)NULL;
-  cs = (COMPSPEC *)NULL;
-
-  /* Build the actions from the arguments.  Also sets the [A-Z]arg variables
-     as a side effect if they are supplied as options. */
-  rval = build_actions (list, (struct _optflags *)NULL, &acts, &copts);
-  if (rval == EX_USAGE)
-    return (rval);
-  if (rval == EXECUTION_FAILURE)
-    return (EXECUTION_SUCCESS);
-
-  list = loptend;
-
-  word = (list && list->word) ? list->word->word : "";
-
-  if (Farg)
-    builtin_error (_("warning: -F option may not work as you expect"));
-  if (Carg)
-    builtin_error (_("warning: -C option may not work as you expect"));
-
-  /* If we get here, we need to build a compspec and evaluate it. */
-  cs = compspec_create ();
-  cs->actions = acts;
-  cs->options = copts;
-  cs->refcount = 1;
-
-  cs->globpat = STRDUP (Garg);
-  cs->words = STRDUP (Warg);
-  cs->prefix = STRDUP (Parg);
-  cs->suffix = STRDUP (Sarg);
-  cs->funcname = STRDUP (Farg);
-  cs->command = STRDUP (Carg);
-  cs->filterpat = STRDUP (Xarg);
-
-  rval = EXECUTION_FAILURE;
-
-  /* probably don't have to save these, just being safe */
-  old_line = pcomp_line;
-  old_ind = pcomp_ind;
-  pcomp_line = (char *)NULL;
-  pcomp_ind = 0;
-  sl = gen_compspec_completions (cs, "compgen", word, 0, 0, 0);
-  pcomp_line = old_line;
-  pcomp_ind = old_ind;
-
-  /* If the compspec wants the bash default completions, temporarily
-     turn off programmable completion and call the bash completion code. */
-  if ((sl == 0 || sl->list_len == 0) && (copts & COPT_BASHDEFAULT))
-    {
-      matches = bash_default_completion (word, 0, 0, 0, 0);
-      sl = completions_to_stringlist (matches);
-      strvec_dispose (matches);
-    }
-
-  /* This isn't perfect, but it's the best we can do, given what readline
-     exports from its set of completion utility functions. */
-  if ((sl == 0 || sl->list_len == 0) && (copts & COPT_DEFAULT))
-    {
-      matches = rl_completion_matches (word, rl_filename_completion_function);
-      strlist_dispose (sl);
-      sl = completions_to_stringlist (matches);
-      strvec_dispose (matches);
-    }
-
-  if (sl)
-    {
-      if (sl->list && sl->list_len)
-	{
-	  rval = EXECUTION_SUCCESS;
-	  strlist_print (sl, (char *)NULL);
-	}
-      strlist_dispose (sl);
-    }
-
-  compspec_dispose (cs);
-  return (rval);
-}
-
-#line 788 "./complete.def"
-
-int
-compopt_builtin (list)
-     WORD_LIST *list;
-{
-  int opts_on, opts_off, *opts, opt, oind, ret, Dflag, Eflag, Iflag;
-  WORD_LIST *l, *wl;
-  COMPSPEC *cs;
-
-  opts_on = opts_off = Eflag = Dflag = Iflag = 0;
-  ret = EXECUTION_SUCCESS;
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "+o:DEI")) != -1)
-    {
-      opts = (list_opttype == '-') ? &opts_on : &opts_off;
-
-      switch (opt)
-	{
-	case 'o':
-	  oind = find_compopt (list_optarg);
-	  if (oind < 0)
-	    {
-	      sh_invalidoptname (list_optarg);
-	      return (EX_USAGE);
-	    }
-	  *opts |= compopts[oind].optflag;
-	  break;
-	case 'D':
-	  Dflag = 1;
-	  break;
-	case 'E':
-	  Eflag = 1;
-	  break;
-	case 'I':
-	  Iflag = 1;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  if (Dflag)
-    wl = make_word_list (make_bare_word (DEFAULTCMD), (WORD_LIST *)NULL);
-  else if (Eflag)
-    wl = make_word_list (make_bare_word (EMPTYCMD), (WORD_LIST *)NULL);
-  else if (Iflag)
-    wl = make_word_list (make_bare_word (INITIALWORD), (WORD_LIST *)NULL);
-  else
-    wl = (WORD_LIST *)NULL;
-
-  if (list == 0 && wl == 0)
-    {
-      if (RL_ISSTATE (RL_STATE_COMPLETING) == 0 || pcomp_curcs == 0)
-	{
-	  builtin_error (_("not currently executing completion function"));
-	  return (EXECUTION_FAILURE);
-	}
-      cs = pcomp_curcs;
-
-      if (opts_on == 0 && opts_off == 0)
-	{
-	  print_compopts (pcomp_curcmd, cs, 1);
-          return (sh_chkwrite (ret));
-	}
-
-      /* Set the compspec options */
-      pcomp_set_compspec_options (cs, opts_on, 1);
-      pcomp_set_compspec_options (cs, opts_off, 0);
-
-      /* And change the readline variables the options control */
-      pcomp_set_readline_variables (opts_on, 1);
-      pcomp_set_readline_variables (opts_off, 0);
-
-      return (ret);
-    }
-
-  for (l = wl ? wl : list; l; l = l->next)
-    {
-      cs = progcomp_search (l->word->word);
-      if (cs == 0)
-	{
-	  builtin_error (_("%s: no completion specification"), l->word->word);
-	  ret = EXECUTION_FAILURE;
-	  continue;
-	}
-      if (opts_on == 0 && opts_off == 0)
-	{
-	  print_compopts (l->word->word, cs, 1);
-	  continue;			/* XXX -- fill in later */
-	}
-
-      /* Set the compspec options */
-      pcomp_set_compspec_options (cs, opts_on, 1);
-      pcomp_set_compspec_options (cs, opts_off, 0);
-    }
-
-  if (wl)
-    dispose_words (wl);
-
-  return (ret);
-}
diff --git a/third_party/bash/builtins_declare.c b/third_party/bash/builtins_declare.c
deleted file mode 100644
index 77f9f8e35..000000000
--- a/third_party/bash/builtins_declare.c
+++ /dev/null
@@ -1,969 +0,0 @@
-/* declare.c, created from declare.def. */
-#line 22 "./declare.def"
-
-#line 64 "./declare.def"
-
-#line 72 "./declare.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "flags.h"
-#include "common.h"
-#include "builtext.h"
-#include "bashgetopt.h"
-
-static SHELL_VAR *declare_find_variable PARAMS((const char *, int, int));
-static char *declare_build_newname PARAMS((char *, char *, int, char *, int));
-static char *declare_transform_name PARAMS((char *, int, int));
-
-static int declare_internal PARAMS((register WORD_LIST *, int));
-
-/* Declare or change variable attributes. */
-int
-declare_builtin (list)
-     register WORD_LIST *list;
-{
-  return (declare_internal (list, 0));
-}
-
-#line 122 "./declare.def"
-int
-local_builtin (list)
-     register WORD_LIST *list;
-{
-  /* Catch a straight `local --help' before checking function context */
-  if (list && list->word && STREQ (list->word->word, "--help"))
-    {
-      builtin_help ();
-      return (EX_USAGE);
-    }
-    
-  if (variable_context)
-    return (declare_internal (list, 1));
-  else
-    {
-      builtin_error (_("can only be used in a function"));
-      return (EXECUTION_FAILURE);
-    }
-}
-
-#if defined (ARRAY_VARS)
-#  define DECLARE_OPTS	"+acfgilnprtuxAFGI"
-#else
-#  define DECLARE_OPTS	"+cfgilnprtuxFGI"
-#endif
-
-static SHELL_VAR *
-declare_find_variable (name, mkglobal, chklocal)
-     const char *name;
-     int mkglobal, chklocal;
-{
-  SHELL_VAR *var;
-
-  if (mkglobal == 0)
-    return (find_variable (name));
-  else if (chklocal)
-    {
-      var = find_variable (name);
-      if (var && local_p (var) && var->context == variable_context)
-	return var;
-      return (find_global_variable (name));
-    }
-  else
-    return (find_global_variable (name));
-}
-
-/* Build a new string
-	NAME[SUBSCRIPT][[+]=VALUE]
-   from expanding a nameref into NAME */
-static char *
-declare_build_newname (name, subscript_start, offset, value, aflags)
-     char *name, *subscript_start;
-     int offset;
-     char *value;
-     int aflags;
-{
-  size_t namelen, savelen;
-  char *ret;
-
-  savelen = namelen = strlen (name);
-  if (subscript_start)
-    {
-      *subscript_start = '[';		/* ] */
-      namelen += strlen (subscript_start);
-    }
-  ret = xmalloc (namelen + 2 + strlen (value) + 1);
-  strcpy (ret, name);
-  if (subscript_start)
-    strcpy (ret + savelen, subscript_start);
-  if (offset)
-    {
-      if (aflags & ASS_APPEND)
-	ret[namelen++] = '+';
-      ret[namelen++] = '=';
-      if (value && *value)
-	strcpy (ret + namelen, value);
-      else
-	ret[namelen] = '\0';
-    }
-
-  return (ret);
-}
-
-static char *
-declare_transform_name (name, flags_on, flags_off)
-     char *name;
-     int flags_on, flags_off;
-{
-  SHELL_VAR *var, *v;
-  char *newname;
-  
-  var = find_variable (name);
-  if (var == 0)
-    newname = nameref_transform_name (name, ASS_MKLOCAL);
-  else if ((flags_on & att_nameref) == 0 && (flags_off & att_nameref) == 0)
-    {
-      /* Ok, we're following namerefs here, so let's make sure that if
-	 we followed one, it was at the same context (see below for
-	 more details). */
-      v = find_variable_last_nameref (name, 1);
-      newname = (v && v->context != variable_context) ? name : name_cell (var);
-    }
-  else
-    newname = name;	/* dealing with nameref attribute */
-
-  return (newname);
-}
-
-/* The workhorse function. */
-static int
-declare_internal (list, local_var)
-     register WORD_LIST *list;
-     int local_var;
-{
-  int flags_on, flags_off, *flags;
-  int any_failed, assign_error, pflag, nodefs, opt, onref, offref;
-  int mkglobal, chklocal, inherit_flag;
-  char *t, *subscript_start;
-  SHELL_VAR *var, *refvar, *v;
-  FUNCTION_DEF *shell_fn;
-
-  flags_on = flags_off = any_failed = assign_error = pflag = nodefs = 0;
-  mkglobal = chklocal = inherit_flag = 0;
-  refvar = (SHELL_VAR *)NULL;
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, DECLARE_OPTS)) != -1)
-    {
-      flags = list_opttype == '+' ? &flags_off : &flags_on;
-
-      /* If you add options here, see whether or not they need to be added to
-	 the loop in subst.c:shell_expand_word_list() */
-      switch (opt)
-	{
-	case 'a':
-#if defined (ARRAY_VARS)
-	  *flags |= att_array;
-	  break;
-#else
-	  builtin_usage ();
-	  return (EX_USAGE);
-#endif
-	case 'A':
-#if defined (ARRAY_VARS)
-	  *flags |= att_assoc;
-	  break;
-#else
-	  builtin_usage ();
-	  return (EX_USAGE);
-#endif
-	case 'p':
-	  pflag++;
-	  break;
-	case 'F':
-	  nodefs++;
-	  *flags |= att_function;
-	  break;
-	case 'f':
-	  *flags |= att_function;
-	  break;
-	case 'G':
-	  if (flags == &flags_on)
-	    chklocal = 1;
-	  /*FALLTHROUGH*/
-	case 'g':
-	  if (flags == &flags_on)
-	    mkglobal = 1;
-	  break;
-	case 'i':
-	  *flags |= att_integer;
-	  break;
-	case 'n':
-	  *flags |= att_nameref;
-	  break;
-	case 'r':
-	  *flags |= att_readonly;
-	  break;
-	case 't':
-	  *flags |= att_trace;
-	  break;
-	case 'x':
-	  *flags |= att_exported;
-	  array_needs_making = 1;
-	  break;
-#if defined (CASEMOD_ATTRS)
-#  if defined (CASEMOD_CAPCASE)
-	 case 'c':
-	  *flags |= att_capcase;
-	  if (flags == &flags_on)
-	    flags_off |= att_uppercase|att_lowercase;
-	  break;
-#  endif
-	case 'l':
-	  *flags |= att_lowercase;
-	  if (flags == &flags_on)
-	    flags_off |= att_capcase|att_uppercase;
-	  break;
-	case 'u':
-	  *flags |= att_uppercase;
-	  if (flags == &flags_on)
-	    flags_off |= att_capcase|att_lowercase;
-	  break;
-#endif /* CASEMOD_ATTRS */
-	case 'I':
-	  inherit_flag = MKLOC_INHERIT;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-
-  list = loptend;
-
-  /* If there are no more arguments left, then we just want to show
-     some variables. */
-  if (list == 0)	/* declare -[aAfFilnrtux] */
-    {
-      /* Show local variables defined at this context level if this is
-	 the `local' builtin. */
-      if (local_var)
-	show_local_var_attributes (0, nodefs);	/* XXX - fix up args later */
-      else if (pflag && (flags_on == 0 || flags_on == att_function))
-	show_all_var_attributes (flags_on == 0, nodefs);
-      else if (flags_on == 0)
-	return (set_builtin ((WORD_LIST *)NULL));
-      else
-	set_or_show_attributes ((WORD_LIST *)NULL, flags_on, nodefs);
-
-      return (sh_chkwrite (EXECUTION_SUCCESS));
-    }
-
-  if (pflag)	/* declare -p [-aAfFilnrtux] [name ...] */
-    {
-      for (any_failed = 0; list; list = list->next)
-	{
-	  if (flags_on & att_function)
-	    pflag = show_func_attributes (list->word->word, nodefs);
-	  else if (local_var)
-	    pflag = show_localname_attributes (list->word->word, nodefs);
-	  else
-	    pflag = show_name_attributes (list->word->word, nodefs);
-	  if (pflag)
-	    {
-	      sh_notfound (list->word->word);
-	      any_failed++;
-	    }
-	}
-      return (sh_chkwrite (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS));
-    }
-
-  /* Some option combinations that don't make any sense */
-  if ((flags_on & att_function) && (flags_on & (att_array|att_assoc|att_integer|att_nameref)))
-    {
-      char *optchar;
-
-      if (flags_on & att_nameref)
-	optchar = "-n";
-      else if (flags_on & att_integer)
-	optchar = "-i";
-      else if (flags_on & att_assoc)
-	optchar = "-A";
-      else if (flags_on & att_array)
-	optchar = "-a";
-
-      sh_invalidopt (optchar);	
-      return (EXECUTION_FAILURE);
-    }
-
-#define NEXT_VARIABLE() free (name); list = list->next; continue
-
-  /* There are arguments left, so we are making variables. */
-  while (list)		/* declare [-aAfFilnrtux] name[=value] [name[=value] ...] */
-    {
-      char *value, *name, *newname;
-      int offset, aflags, wflags, created_var;
-      int assoc_noexpand;
-#if defined (ARRAY_VARS)
-      int making_array_special, compound_array_assign, simple_array_assign;
-      int var_exists, array_exists, creating_array, array_subscript_assignment;
-#endif
-
-      name = savestring (list->word->word);
-      wflags = list->word->flags;
-#if defined (ARRAY_VARS)
-      assoc_noexpand = assoc_expand_once && (wflags & W_ASSIGNMENT);
-#else
-      assoc_noexpand = 0;
-#endif
-      /* XXX - we allow unbalanced brackets if assoc_noexpand is set, we count
-	 brackets and make sure they match if assoc_noexpand is not set. So we
-	 need to make sure we're checking assoc_noexpand and expand_once_flag
-	 for backwards compatibility. We also use assoc_noexpand below when
-	 we call assign_array_element, so we need to make sure they're
-	 consistent in how they count brackets. */
-      offset = assignment (name, assoc_noexpand ? 2 : 0);
-      aflags = 0;
-      created_var = 0;
-
-      if (local_var && variable_context && STREQ (name, "-"))
-	{
-	  var = make_local_variable ("-", 0);
-	  FREE (value_cell (var));		/* just in case */
-	  value = get_current_options ();
-	  var_setvalue (var, value);
-	  VSETATTR (var, att_invisible);
-	  NEXT_VARIABLE ();
-	}
-
-      /* If we are declaring a function, then complain about it in some way.
-	 We don't let people make functions by saying `typeset -f foo=bar'. */
-
-      /* Can't define functions using assignment statements */
-      if (offset && (flags_on & att_function))	/* declare -f [-rix] foo=bar */
-	{
-	  builtin_error (_("cannot use `-f' to make functions"));
-	  free (name);
-	  return (EXECUTION_FAILURE);
-	}
-
-      /* There should be a way, however, to let people look at a particular
-	 function definition by saying `typeset -f foo'.  This is the only
-	 place in this builtin where we deal with functions. */
-
-      if (flags_on & att_function)
-	{
-	  /* Should we restrict this when the shell is in posix mode even if
-	     the function was created before the shell entered posix mode?
-	     Previous versions of the shell enforced the restriction. */
-	  if (posixly_correct && legal_identifier (name) == 0)
-	    {
-	      sh_invalidid (name);
-	      assign_error++;
-	      NEXT_VARIABLE ();
-	    }
-
-	  var = find_function (name);
-
-	  if (var)
-	    {
-	      if (readonly_p (var) && (flags_off & att_readonly))
-		{
-		  builtin_error (_("%s: readonly function"), name);
-		  any_failed++;
-		  NEXT_VARIABLE ();
-		}
-	      /* declare -[Ff] name [name...] */
-	      if (flags_on == att_function && flags_off == 0)
-		{
-#if defined (DEBUGGER)
-		  if (nodefs && debugging_mode)
-		    {
-		      shell_fn = find_function_def (name_cell (var));
-		      if (shell_fn)
-			printf ("%s %d %s\n", name_cell (var), shell_fn->line, shell_fn->source_file);
-		      else
-			printf ("%s\n", name_cell (var));
-		    }
-		  else
-#endif /* DEBUGGER */
-		    {	
-		      t = nodefs ? name_cell (var) : named_function_string (name, function_cell (var), FUNC_MULTILINE|FUNC_EXTERNAL);
-		      printf ("%s\n", t);
-		      any_failed = sh_chkwrite (any_failed);
-		    }
-		}
-	      else		/* declare -[fF] -[rx] name [name...] */
-		{
-		  VSETATTR (var, flags_on);
-		  flags_off &= ~att_function;	/* makes no sense */
-		  VUNSETATTR (var, flags_off);
-		}
-	    }
-	  else
-	    any_failed++;
-
-	  NEXT_VARIABLE ();
-	}
-
-      if (offset)	/* declare [-aAfFirx] name=value */
-	{
-	  name[offset] = '\0';
-	  value = name + offset + 1;
-	  if (name[offset - 1] == '+')
-	    {
-	      aflags |= ASS_APPEND;
-	      name[offset - 1] = '\0';
-	    }
-	}
-      else
-	value = "";
-
-      /* Do some lexical error checking on the LHS and RHS of the assignment
-	 that is specific to nameref variables. */
-      if (flags_on & att_nameref)
-	{
-#if defined (ARRAY_VARS)
-	  if (valid_array_reference (name, 0))
-	    {
-	      builtin_error (_("%s: reference variable cannot be an array"), name);
-	      any_failed++;
-	      NEXT_VARIABLE ();
-	    }
-	  else
-#endif
-	  /* disallow self references at global scope, warn at function scope */
-	  if (check_selfref (name, value, 0))
-	    {
-	      if (variable_context == 0)
-		{
-		  builtin_error (_("%s: nameref variable self references not allowed"), name);
-		  assign_error++;	/* XXX any_failed++ instead? */
-		  NEXT_VARIABLE ();
-		}
-	      else
-		builtin_warning (_("%s: circular name reference"), name);
-	    }
-	  if (value && *value && (aflags & ASS_APPEND) == 0 && valid_nameref_value (value, 1) == 0)
-	    {
-	      builtin_error (_("`%s': invalid variable name for name reference"), value);
-	      assign_error++;
-	      NEXT_VARIABLE ();
-	    }
-	}
-
-restart_new_var_name:
-
-      /* The rest of the loop body deals with declare -[aAlinrtux] name [name...]
-	 where each NAME can be an assignment statement. */
-
-      subscript_start = (char *)NULL;	/* used below */
-#if defined (ARRAY_VARS)
-      /* Determine whether we are creating or assigning an array variable */
-      var_exists = array_exists = creating_array = 0;
-      compound_array_assign = simple_array_assign = 0;
-      array_subscript_assignment = 0;
-      if (t = strchr (name, '['))	/* ] */
-	{
-	  /* If offset != 0 we have already validated any array reference
-	     because assignment() calls skipsubscript() */
-	  if (offset == 0 && valid_array_reference (name, 0) == 0)
-	    {
-	      sh_invalidid (name);
-	      assign_error++;
-	      NEXT_VARIABLE ();
-	    }
-	  subscript_start = t;
-	  *t = '\0';
-	  making_array_special = 1;	/* XXX - should this check offset? */
-	  array_subscript_assignment = offset != 0;
-	}
-      else
-	making_array_special = 0;
-#endif
-
-      /* Ensure the argument is a valid, well-formed shell identifier. */
-      if (legal_identifier (name) == 0)
-	{
-	  sh_invalidid (name);
-	  assign_error++;
-	  NEXT_VARIABLE ();
-	}
-
-      /* If VARIABLE_CONTEXT has a non-zero value, then we are executing
-	 inside of a function.  This means we should make local variables,
-	 not global ones. */
-
-      /* XXX - this has consequences when we're making a local copy of a
-	       variable that was in the temporary environment.  Watch out
-	       for this. */
-      refvar = (SHELL_VAR *)NULL;
-      if (variable_context && mkglobal == 0)
-	{
-	  /* We don't check newname for validity here. We should not have an
-	     invalid name assigned as the value of a nameref, but this could
-	     cause problems. */
-	  newname = declare_transform_name (name, flags_on, flags_off);
-
-#if defined (ARRAY_VARS)
-	  /* Pass 1 as second argument to make_local_{assoc,array}_variable
-	     return an existing {array,assoc} variable to be flagged as an
-	     error below. */
-	  if (flags_on & att_assoc)
-	    var = make_local_assoc_variable (newname, MKLOC_ARRAYOK|inherit_flag);
-	  else if ((flags_on & att_array) || making_array_special)
-	    var = make_local_array_variable (newname, MKLOC_ASSOCOK|inherit_flag);
-	  else
-#endif
-	  if (offset == 0 && (flags_on & att_nameref))
-	    {
-	      /* First look for refvar at current scope */
-	      refvar = find_variable_last_nameref (name, 1);
-	      /* VARIABLE_CONTEXT != 0, so we are attempting to create or modify
-		 the attributes for a local variable at the same scope.  If we've
-		 used a reference from a previous context to resolve VAR, we
-		 want to throw REFVAR and VAR away and create a new local var. */
-	      if (refvar && refvar->context != variable_context)
-		{
-		  refvar = 0;
-		  var = make_local_variable (name, inherit_flag);
-		}
-	      else if (refvar && refvar->context == variable_context)
-		var = refvar;
-	      /* Maybe we just want to create a new local variable */
-	      else if ((var = find_variable (name)) == 0 || var->context != variable_context)
-		var = make_local_variable (name, inherit_flag);
-	      /* otherwise we have a var at the right context */
-	    }
-	  else
-	    /* XXX - check name for validity here with valid_nameref_value? */
-	    var = make_local_variable ((flags_on & att_nameref) ? name : newname, inherit_flag);	/* sets att_invisible for new vars */
-
-	  if (var == 0)
-	    {
-	      any_failed++;
-	      NEXT_VARIABLE ();
-	    }
-	  if (var && nameref_p (var) && readonly_p (var) && nameref_cell (var) && (flags_off & att_nameref))
-	    {
-	      sh_readonly (name);
-	      any_failed++;
-	      NEXT_VARIABLE ();
-	    }
-	}
-      else
-	var = (SHELL_VAR *)NULL;
-
-      /* VAR is non-null if we just created or fetched a local variable. */
-
-      /* Here's what ksh93 seems to do as of the 2012 version: if we are
-	 using declare -n to modify the value of an existing nameref
-	 variable, don't follow the nameref chain at all and just search
-	 for a nameref at the current context.  If we have a nameref,
-	 modify its value (changing which variable it references). */
-      if (var == 0 && (flags_on & att_nameref))
-	{
-	  /* See if we are trying to modify an existing nameref variable,
-	     but don't follow the nameref chain. */
-	  var = mkglobal ? find_global_variable_noref (name) : find_variable_noref (name);
-	  if (var && nameref_p (var) == 0)
-	    var = 0;
-	}
-
-      /* However, if we're turning off the nameref attribute on an existing
-	 nameref variable, we first follow the nameref chain to the end,
-	 modify the value of the variable this nameref variable references
-	 if there is an assignment statement argument,
-	 *CHANGING ITS VALUE AS A SIDE EFFECT*, then turn off the nameref
-	 flag *LEAVING THE NAMEREF VARIABLE'S VALUE UNCHANGED* */
-      else if (var == 0 && (flags_off & att_nameref))
-	{
-	  /* See if we are trying to modify an existing nameref variable */
-	     refvar = mkglobal ? find_global_variable_last_nameref (name, 0) : find_variable_last_nameref (name, 0);
-	  if (refvar && nameref_p (refvar) == 0)
-	    refvar = 0;
-	  /* If the nameref is readonly but doesn't have a value, ksh93
-	     allows the nameref attribute to be removed.  If it's readonly
-	     and has a value, even if the value doesn't reference an
-	     existing variable, we disallow the modification */
-	  if (refvar && nameref_cell (refvar) && readonly_p (refvar))
-	    {
-	      sh_readonly (name);
-	      any_failed++;
-	      NEXT_VARIABLE ();
-	    }
-
-	  /* If all we're doing is turning off the nameref attribute, don't
-	     bother with VAR at all, whether it exists or not. Just turn it
-	     off and go on. */
-	  if (refvar && flags_on == 0 && offset == 0 && flags_off == att_nameref)
-	    {
-	      VUNSETATTR (refvar, att_nameref);
-	      NEXT_VARIABLE ();
-	    }
-
-	  if (refvar)
-	    var = declare_find_variable (nameref_cell (refvar), mkglobal, 0);
-	}
-#if defined (ARRAY_VARS)
-      /* If we have an array assignment to a nameref, remove the nameref
-	 attribute and go on.  This handles
-	 declare -n xref[=value]; declare [-a] xref[1]=one */
-      else if (var == 0 && offset && array_subscript_assignment)
-	{
-	  var = mkglobal ? find_global_variable_noref (name) : find_variable_noref (name);
-	  if (var && nameref_p (var))
-	    {
-	      internal_warning (_("%s: removing nameref attribute"), name);
-	      FREE (value_cell (var));		/* XXX - bash-4.3 compat */
-	      var_setvalue (var, (char *)NULL);
-	      VUNSETATTR (var, att_nameref);
-	    }
-	}
-#endif
-
-      /* See if we are trying to set flags or value (or create) for an
-	 existing nameref that points to a non-existent variable: e.g.,
-		declare -n foo=bar
-		unset foo	# unsets bar
-		declare -i foo
-		foo=4+4
-		declare -p foo
-      */
-      if (var == 0 && (mkglobal || flags_on || flags_off || offset))
-	{
-	  refvar = mkglobal ? find_global_variable_last_nameref (name, 0) : find_variable_last_nameref (name, 0);
-	  if (refvar && nameref_p (refvar) == 0)
-	    refvar = 0;
-	  if (refvar)
-	    var = declare_find_variable (nameref_cell (refvar), mkglobal, 0);
-	  if (refvar && var == 0)
-	    {
-	      /* I'm not sure subscript_start is ever non-null here. In any
-		 event, build a new name from the nameref value, including any
-		 subscript, and add the [[+]=value] if offset != 0 */
-	      newname = declare_build_newname (nameref_cell (refvar), subscript_start, offset, value, aflags);
-	      free (name);
-	      name = newname;
-
-	      if (offset)
-		{
-		  offset = assignment (name, 0);
-		  /* If offset was valid previously, but substituting the
-		     the nameref value results in an invalid assignment,
-		     throw an invalid identifier error */
-		  if (offset == 0)
-		    {
-		      sh_invalidid (name);
-		      assign_error++;
-		      NEXT_VARIABLE ();
-		    }
-		  name[(aflags & ASS_APPEND) ? offset - 1 : offset] = '\0';
-		  value = name + offset + 1;
-		}
-
-	      /* OK, let's turn off the nameref attribute.
-		 Now everything else applies to VAR. */
-	      if (flags_off & att_nameref)
-		VUNSETATTR (refvar, att_nameref);
-
-	      goto restart_new_var_name;
-	      /* NOTREACHED */
-	    }
-	}
-      if (var == 0)
-	var = declare_find_variable (name, mkglobal, chklocal);
-
-      /* At this point, VAR is the variable we are dealing with; REFVAR is the
-	 nameref variable we dereferenced to get VAR, if any. */
-#if defined (ARRAY_VARS)
-      var_exists = var != 0;
-      array_exists = var && (array_p (var) || assoc_p (var));
-      creating_array = flags_on & (att_array|att_assoc);
-#endif
-
-      /* Make a new variable if we need to. */
-      if (var == 0)
-	{
-#if defined (ARRAY_VARS)
-	  if (flags_on & att_assoc)
-	    var = make_new_assoc_variable (name);
-	  else if ((flags_on & att_array) || making_array_special)
-	    var = make_new_array_variable (name);
-	  else
-#endif
-	    var = mkglobal ? bind_global_variable (name, (char *)NULL, ASS_FORCE) : bind_variable (name, (char *)NULL, ASS_FORCE);
-
-	  if (var == 0)
-	    {
-	      /* Has to appear in brackets */
-	      NEXT_VARIABLE ();
-	    }
-	  if (offset == 0)
-	    VSETATTR (var, att_invisible);
-	  created_var = 1;
-	}
-
-      /* Nameref variable error checking. */
-
-      /* Can't take an existing array variable and make it a nameref */
-      else if ((array_p (var) || assoc_p (var)) && (flags_on & att_nameref))
-	{
-	  builtin_error (_("%s: reference variable cannot be an array"), name);
-	  any_failed++;
-	  NEXT_VARIABLE ();
-	}
-      /* Can't have an invalid identifier as nameref value */
-      else if (nameref_p (var) && (flags_on & att_nameref) == 0 && (flags_off & att_nameref) == 0 && offset && valid_nameref_value (value, 1) == 0)
-	{
-	  builtin_error (_("`%s': invalid variable name for name reference"), value);
-	  any_failed++;
-	  NEXT_VARIABLE ();
-	}
-      /* Can't make an existing variable a nameref if its current value is not
-	 a valid identifier. Check of offset is to allow an assignment to a
-	 nameref var as part of the declare word to override existing value. */
-      else if ((flags_on & att_nameref) && nameref_p (var) == 0 && var_isset (var) && offset == 0 && valid_nameref_value (value_cell (var), 0) == 0)
-	{
-	  builtin_error (_("`%s': invalid variable name for name reference"), value_cell (var));
-	  any_failed++;
-	  NEXT_VARIABLE ();
-	}
-      /* Can't make an existing readonly variable a nameref. */
-      else if ((flags_on & att_nameref) && readonly_p (var))
-	{
-	  sh_readonly (name);
-	  any_failed++;
-	  NEXT_VARIABLE ();
-	}
-
-      /* Readonly variable error checking. */
-
-      /* Cannot use declare +r to turn off readonly attribute. */ 
-      if (readonly_p (var) && (flags_off & att_readonly))
-	{
-	  sh_readonly (name_cell (var));
-	  any_failed++;
-	  NEXT_VARIABLE ();
-	}
-      /* Cannot use declare to assign value to readonly or noassign variable. */
-      else if ((readonly_p (var) || noassign_p (var)) && offset)
-	{
-	  if (readonly_p (var))
-	    sh_readonly (name);
-	  assign_error++;
-	  NEXT_VARIABLE ();
-	}
-
-#if defined (ARRAY_VARS)
-      /* Array variable error checking. */
-
-      /* Cannot use declare +a name or declare +A name to remove an array variable. */
-      if (((flags_off & att_array) && array_p (var)) || ((flags_off & att_assoc) && assoc_p (var)))
-	{
-	  builtin_error (_("%s: cannot destroy array variables in this way"), name);
-	  any_failed++;
-	  NEXT_VARIABLE ();
-	}
-      else if ((flags_on & att_array) && assoc_p (var))
-	{
-	  builtin_error (_("%s: cannot convert associative to indexed array"), name);
-	  any_failed++;
-	  NEXT_VARIABLE ();
-	}
-      else if ((flags_on & att_assoc) && array_p (var))
-	{
-	  builtin_error (_("%s: cannot convert indexed to associative array"), name);
-	  any_failed++;
-	  NEXT_VARIABLE ();
-	}
-
-      /* make declare A[2]=foo as similar to A[2]=foo as possible if A is
-	 already an array or assoc variable. */
-      if (array_subscript_assignment && array_exists && creating_array == 0)
-	simple_array_assign = 1;
-      else if ((making_array_special || creating_array || array_exists) && offset)
-	{
-	  int vlen;
-	  vlen = STRLEN (value);
-/*itrace("declare_builtin: name = %s value = %s flags = %d", name, value, wflags);*/
-
-	  if (shell_compatibility_level > 43 && (wflags & W_COMPASSIGN) == 0 &&
-		value[0] == '(' && value[vlen-1] == ')')
-	    {
-	      /* I don't believe this warning is printed any more.
-		 We use creating_array to allow things like
-		     declare -a foo$bar='(abc)'
-		 to work as they have in the past. */
-	      if (array_exists == 0 && creating_array == 0)
-		internal_warning (_("%s: quoted compound array assignment deprecated"), list->word->word);
-	      compound_array_assign = array_exists || creating_array;
-	      simple_array_assign = making_array_special;
-	    }
-	  else if (value[0] == '(' && value[vlen-1] == ')' && (shell_compatibility_level < 44 || (wflags & W_COMPASSIGN)))
-	    compound_array_assign = 1;
-	  else
-	    simple_array_assign = 1;
-	}
-
-      /* declare -A name[[n]] makes name an associative array variable. */
-      if (flags_on & att_assoc)
-	{
-	  if (assoc_p (var) == 0)
-	    var = convert_var_to_assoc (var);
-	}
-      /* declare -a name[[n]] or declare name[n] makes NAME an indexed
-	 array variable. */
-      else if ((making_array_special || (flags_on & att_array)) && array_p (var) == 0 && assoc_p (var) == 0)
-	var = convert_var_to_array (var);
-#endif /* ARRAY_VARS */
-
-      /* ksh93 compat: turning on nameref attribute turns off -ilu */
-      if (flags_on & att_nameref)
-	VUNSETATTR (var, att_integer|att_uppercase|att_lowercase|att_capcase);
-
-      /* XXX - we note that we are turning on nameref attribute and defer
-	 setting it until the assignment has been made so we don't do an
-	 inadvertent nameref lookup.  Might have to do the same thing for
-	 flags_off&att_nameref. */
-      /* XXX - ksh93 makes it an error to set a readonly nameref variable
-	 using a single typeset command. */
-      onref = (flags_on & att_nameref);
-      flags_on &= ~att_nameref;
-#if defined (ARRAY_VARS)
-      /* I don't believe this condition ever tests true, but array variables
-	 may not be namerefs */
-      if (array_p (var) || assoc_p (var) || compound_array_assign || simple_array_assign)
-	onref = 0;
-#endif
-
-      /* ksh93 seems to do this */
-      offref = (flags_off & att_nameref);
-      flags_off &= ~att_nameref;
-
-      VSETATTR (var, flags_on);
-      VUNSETATTR (var, flags_off);
-
-#if defined (ARRAY_VARS)
-      if (offset && compound_array_assign)
-	assign_array_var_from_string (var, value, aflags|ASS_FORCE);
-      else if (simple_array_assign && subscript_start)
-	{
-	  int local_aflags;
-
-	  /* declare [-aA] name[N]=value */
-	  *subscript_start = '[';	/* ] */
-	  /* XXX - problem here with appending */
-	  local_aflags = aflags&ASS_APPEND;
-	  local_aflags |= assoc_noexpand ? ASS_NOEXPAND : 0;
-	  local_aflags |= ASS_ALLOWALLSUB;		/* allow declare a[@]=at */
-	  var = assign_array_element (name, value, local_aflags, (array_eltstate_t *)0);	/* XXX - not aflags */
-	  *subscript_start = '\0';
-	  if (var == 0)	/* some kind of assignment error */
-	    {
-	      assign_error++;
-	      flags_on |= onref;
-	      flags_off |= offref;
-	      NEXT_VARIABLE ();
-	    }
-	}
-      else if (simple_array_assign)
-	{
-	  /* let bind_{array,assoc}_variable take care of this. */
-	  if (assoc_p (var))
-	    bind_assoc_variable (var, name, savestring ("0"), value, aflags|ASS_FORCE);
-	  else
-	    bind_array_variable (name, 0, value, aflags|ASS_FORCE);
-	}
-      else
-#endif
-      /* XXX - no ASS_FORCE here */
-      /* bind_variable_value duplicates the essential internals of bind_variable() */
-      if (offset)
-	{
-	  if (onref || nameref_p (var))
-	    aflags |= ASS_NAMEREF;
-	  v = bind_variable_value (var, value, aflags);
-	  if (v == 0 && (onref || nameref_p (var)))
-	    {
-	      if (valid_nameref_value (value, 1) == 0)
-		sh_invalidid (value);
-	      assign_error++;
-	      /* XXX - unset this variable? or leave it as normal var? */
-	      if (created_var)
-		delete_var (name_cell (var), mkglobal ? global_variables : shell_variables);
-	      flags_on |= onref;		/* undo change from above */
-	      flags_off |= offref;
-	      NEXT_VARIABLE ();
-	    }
-	}
-
-      /* If we found this variable in the temporary environment, as with
-	 `var=value declare -x var', make sure it is treated identically
-	 to `var=value export var'.  Do the same for `declare -r' and
-	 `readonly'.  Preserve the attributes, except for att_tempvar. */
-      /* XXX -- should this create a variable in the global scope, or
-	 modify the local variable flags?  ksh93 has it modify the
-	 global scope.
-	 Need to handle case like in set_var_attribute where a temporary
-	 variable is in the same table as the function local vars. */
-      if ((flags_on & (att_exported|att_readonly)) && tempvar_p (var))
-	{
-	  SHELL_VAR *tv;
-	  char *tvalue;
-
-	  tv = find_tempenv_variable (name_cell (var));
-	  if (tv)
-	    {
-	      tvalue = var_isset (var) ? savestring (value_cell (var)) : savestring ("");
-	      tv = bind_variable (name_cell (var), tvalue, 0);
-	      if (tv)
-		{
-		  tv->attributes |= var->attributes & ~att_tempvar;
-		  if (tv->context > 0)
-		    VSETATTR (tv, att_propagate);
-		}
-	      free (tvalue);
-	    }
-	  VSETATTR (var, att_propagate);
-	}
-
-      /* Turn on nameref attribute we deferred above. */
-      VSETATTR (var, onref);
-      flags_on |= onref;
-      VUNSETATTR (var, offref);
-      flags_off |= offref;
-
-      /* Yuck.  ksh93 compatibility.  XXX - need to investigate more but
-	 definitely happens when turning off nameref attribute on nameref
-	 (see comments above).  Under no circumstances allow this to turn
-	 off readonly attribute on readonly nameref variable. */
-      if (refvar)
-	{
-	  if (flags_off & att_readonly)
-	    flags_off &= ~att_readonly;
- 	  VUNSETATTR (refvar, flags_off);
-	}
-
-      stupidly_hack_special_variables (name);
-
-      NEXT_VARIABLE ();
-    }
-
-  return (assign_error ? EX_BADASSIGN
-		       : ((any_failed == 0) ? EXECUTION_SUCCESS
-  					    : EXECUTION_FAILURE));
-}
diff --git a/third_party/bash/builtins_echo.c b/third_party/bash/builtins_echo.c
deleted file mode 100644
index 957d2e34c..000000000
--- a/third_party/bash/builtins_echo.c
+++ /dev/null
@@ -1,133 +0,0 @@
-/* echo.c, created from echo.def. */
-#line 22 "./echo.def"
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-
-#include <stdio.h>
-#include "shell.h"
-
-#include "common.h"
-
-#line 73 "./echo.def"
-
-#line 88 "./echo.def"
-
-#if defined (V9_ECHO)
-#  define VALID_ECHO_OPTIONS "neE"
-#else /* !V9_ECHO */
-#  define VALID_ECHO_OPTIONS "n"
-#endif /* !V9_ECHO */
-
-/* System V machines already have a /bin/sh with a v9 behaviour.  We
-   give Bash the identical behaviour for these machines so that the
-   existing system shells won't barf.  Regrettably, the SUS v2 has
-   standardized the Sys V echo behavior.  This variable is external
-   so that we can have a `shopt' variable to control it at runtime. */
-#if defined (DEFAULT_ECHO_TO_XPG) || defined (STRICT_POSIX)
-int xpg_echo = 1;
-#else
-int xpg_echo = 0;
-#endif /* DEFAULT_ECHO_TO_XPG */
-
-/* Print the words in LIST to standard output.  If the first word is
-   `-n', then don't print a trailing newline.  We also support the
-   echo syntax from Version 9 Unix systems. */
-int
-echo_builtin (list)
-     WORD_LIST *list;
-{
-  int display_return, do_v9, i, len;
-  char *temp, *s;
-
-  do_v9 = xpg_echo;
-  display_return = 1;
-
-  if (posixly_correct && xpg_echo)
-    goto just_echo;
-
-  for (; list && (temp = list->word->word) && *temp == '-'; list = list->next)
-    {
-      /* If it appears that we are handling options, then make sure that
-	 all of the options specified are actually valid.  Otherwise, the
-	 string should just be echoed. */
-      temp++;
-
-      for (i = 0; temp[i]; i++)
-	{
-	  if (strchr (VALID_ECHO_OPTIONS, temp[i]) == 0)
-	    break;
-	}
-
-      /* echo - and echo -<nonopt> both mean to just echo the arguments. */
-      if (*temp == 0 || temp[i])
-	break;
-
-      /* All of the options in TEMP are valid options to ECHO.
-	 Handle them. */
-      while (i = *temp++)
-	{
-	  switch (i)
-	    {
-	    case 'n':
-	      display_return = 0;
-	      break;
-#if defined (V9_ECHO)
-	    case 'e':
-	      do_v9 = 1;
-	      break;
-	    case 'E':
-	      do_v9 = 0;
-	      break;
-#endif /* V9_ECHO */
-	    default:
-	      goto just_echo;	/* XXX */
-	    }
-	}
-    }
-
-just_echo:
-
-  clearerr (stdout);	/* clear error before writing and testing success */
-
-  while (list)
-    {
-      i = len = 0;
-      temp = do_v9 ? ansicstr (list->word->word, STRLEN (list->word->word), 1, &i, &len)
-		   : list->word->word;
-      if (temp)
-	{
-	  if (do_v9)
-	    {
-	      for (s = temp; len > 0; len--)
-		putchar (*s++);
-	    }
-	  else	    
-	    printf ("%s", temp);
-#if defined (SunOS5)
-	  fflush (stdout);	/* Fix for bug in SunOS 5.5 printf(3) */
-#endif
-	}
-      QUIT;
-      if (do_v9 && temp)
-	free (temp);
-      list = list->next;
-      if (i)
-	{
-	  display_return = 0;
-	  break;
-	}
-      if (list)
-	putchar(' ');
-      QUIT;
-    }
-
-  if (display_return)
-    putchar ('\n');
-
-  return (sh_chkwrite (EXECUTION_SUCCESS));
-}
diff --git a/third_party/bash/builtins_enable.c b/third_party/bash/builtins_enable.c
deleted file mode 100644
index 6edacda69..000000000
--- a/third_party/bash/builtins_enable.c
+++ /dev/null
@@ -1,541 +0,0 @@
-/* enable.c, created from enable.def. */
-#line 22 "./enable.def"
-
-#line 50 "./enable.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "builtins.h"
-#include "flags.h"
-#include "common.h"
-#include "bashgetopt.h"
-#include "findcmd.h"
-
-#if defined (PROGRAMMABLE_COMPLETION)
-#  include "pcomplete.h"
-#endif
-
-#define ENABLED  1
-#define DISABLED 2
-#define SPECIAL  4
-#define SILENT	 8	/* affects dyn_load_builtin behavior */
-
-#define AFLAG	0x01
-#define DFLAG	0x02
-#define FFLAG	0x04
-#define NFLAG	0x08
-#define PFLAG	0x10
-#define SFLAG	0x20
-
-#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
-static int dyn_load_builtin PARAMS((WORD_LIST *, int, char *));
-#endif
-
-#if defined (HAVE_DLCLOSE)
-static int dyn_unload_builtin PARAMS((char *));
-static void delete_builtin PARAMS((struct builtin *));
-static int local_dlclose PARAMS((void *));
-#endif
-
-#define STRUCT_SUFFIX	"_struct"
-/* for now */
-#define LOAD_SUFFIX	"_builtin_load"
-#define UNLOAD_SUFFIX	"_builtin_unload"
-
-static void list_some_builtins PARAMS((int));
-static int enable_shell_command PARAMS((char *, int));
-
-/* Enable/disable shell commands present in LIST.  If list is not specified,
-   then print out a list of shell commands showing which are enabled and
-   which are disabled. */
-int
-enable_builtin (list)
-     WORD_LIST *list;
-{
-  int result, flags;
-  int opt, filter;
-  WORD_LIST *next;
-#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
-  char *filename;
-#endif
-
-  result = EXECUTION_SUCCESS;
-  flags = 0;
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "adnpsf:")) != -1)
-    {
-      switch (opt)
-	{
-	case 'a':
-	  flags |= AFLAG;
-	  break;
-	case 'n':
-	  flags |= NFLAG;
-	  break;
-	case 'p':
-	  flags |= PFLAG;
-	  break;
-	case 's':
-	  flags |= SFLAG;
-	  break;
-	case 'f':
-#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
-	  flags |= FFLAG;
-	  filename = list_optarg;
-	  break;
-#else
-	  builtin_error (_("dynamic loading not available"));
-	  return (EX_USAGE);
-#endif
-#if defined (HAVE_DLCLOSE)
-	case 'd':
-	  flags |= DFLAG;
-	  break;
-#else
-	  builtin_error (_("dynamic loading not available"));
-	  return (EX_USAGE);
-#endif /* HAVE_DLCLOSE */
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-
-  list = loptend;
-
-#if defined (RESTRICTED_SHELL)
-  /* Restricted shells cannot load new builtins. */
-  if (restricted && (flags & (FFLAG|DFLAG)))
-    {
-      sh_restricted ((char *)NULL);
-      return (EXECUTION_FAILURE);
-    }
-#endif
-
-  if (list == 0 || (flags & PFLAG))
-    {
-      filter = (flags & AFLAG) ? (ENABLED | DISABLED)
-			       : (flags & NFLAG) ? DISABLED : ENABLED;
-
-      if (flags & SFLAG)
-	filter |= SPECIAL;
-
-      list_some_builtins (filter);
-      result = sh_chkwrite (EXECUTION_SUCCESS);
-    }
-#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
-  else if (flags & FFLAG)
-    {
-      filter = (flags & NFLAG) ? DISABLED : ENABLED;
-      if (flags & SFLAG)
-	filter |= SPECIAL;
-
-      result = dyn_load_builtin (list, filter, filename);
-      if (result != EXECUTION_SUCCESS)
-	result = EXECUTION_FAILURE;	/* normalize return value */
-#if defined (PROGRAMMABLE_COMPLETION)
-      set_itemlist_dirty (&it_builtins);
-#endif
-    }
-#endif
-#if defined (HAVE_DLCLOSE)
-  else if (flags & DFLAG)
-    {
-      while (list)
-	{
-	  opt = dyn_unload_builtin (list->word->word);
-	  if (opt == EXECUTION_FAILURE)
-	    result = EXECUTION_FAILURE;
-	  list = list->next;
-	}
-#if defined (PROGRAMMABLE_COMPLETION)
-      set_itemlist_dirty (&it_builtins);
-#endif
-    }
-#endif
-  else
-    {
-      while (list)
-	{
-	  opt = enable_shell_command (list->word->word, flags & NFLAG);
-	  next = list->next;
-
-#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
-	  /* If we try to enable a non-existent builtin, and we have dynamic
-	     loading, try the equivalent of `enable -f name name'. */
-	  if (opt == EX_NOTFOUND)
-	    {
-	      int dflags, r;
-	      
-	      dflags = ENABLED|SILENT|((flags & SFLAG) ? SPECIAL : 0);
-
-	      list->next = 0;
-	      r = dyn_load_builtin (list, dflags, list->word->word);
-	      list->next = next;
-	      if (r == EXECUTION_SUCCESS)
-		opt = r;
-#if defined (PROGRAMMABLE_COMPLETION)
-	      set_itemlist_dirty (&it_builtins);
-#endif
-	    }
-#endif
-
-	  if (opt == EX_NOTFOUND)
-	    {
-	      sh_notbuiltin (list->word->word);
-	      result = EXECUTION_FAILURE;
-	    }
-	  else if (opt != EXECUTION_SUCCESS)
-	    result = EXECUTION_FAILURE;
-
-	  list = next;
-	}
-    }
-  return (result);
-}
-
-/* List some builtins.
-   FILTER is a mask with two slots: ENABLED and DISABLED. */
-static void
-list_some_builtins (filter)
-     int filter;
-{
-  register int i;
-
-  for (i = 0; i < num_shell_builtins; i++)
-    {
-      if (shell_builtins[i].function == 0 || (shell_builtins[i].flags & BUILTIN_DELETED))
-	continue;
-
-      if ((filter & SPECIAL) &&
-	  (shell_builtins[i].flags & SPECIAL_BUILTIN) == 0)
-	continue;
-
-      if ((filter & ENABLED) && (shell_builtins[i].flags & BUILTIN_ENABLED))
-	printf ("enable %s\n", shell_builtins[i].name);
-      else if ((filter & DISABLED) &&
-	       ((shell_builtins[i].flags & BUILTIN_ENABLED) == 0))
-	printf ("enable -n %s\n", shell_builtins[i].name);
-    }
-}
-
-/* Enable the shell command NAME.  If DISABLE_P is non-zero, then
-   disable NAME instead. */
-static int
-enable_shell_command (name, disable_p)
-     char *name;
-     int disable_p;
-{
-  struct builtin *b;
-
-  b = builtin_address_internal (name, 1);
-  if (b == 0)
-    return (EX_NOTFOUND);
-
-  if (disable_p)
-    b->flags &= ~BUILTIN_ENABLED;
-#if defined (RESTRICTED_SHELL)
-  else if (restricted && ((b->flags & BUILTIN_ENABLED) == 0))
-    {
-      sh_restricted ((char *)NULL);
-      return (EXECUTION_FAILURE);
-    }
-#endif
-  else
-    b->flags |= BUILTIN_ENABLED;
-
-#if defined (PROGRAMMABLE_COMPLETION)
-  set_itemlist_dirty (&it_enabled);
-  set_itemlist_dirty (&it_disabled);
-#endif
-
-  return (EXECUTION_SUCCESS);
-}
-
-#if defined (HAVE_DLOPEN) && defined (HAVE_DLSYM)
-
-#if defined (HAVE_DLFCN_H)
-#  include <dlfcn.h>
-#endif
-
-static int
-dyn_load_builtin (list, flags, filename)
-     WORD_LIST *list;
-     int flags;
-     char *filename;
-{
-  WORD_LIST *l;
-  void *handle;
-  
-  int total, size, new, replaced, r;
-  char *struct_name, *name, *funcname;
-  sh_load_func_t *loadfunc;
-  struct builtin **new_builtins, *b, *new_shell_builtins, *old_builtin;
-  char *loadables_path, *load_path;
-
-  if (list == 0)
-    return (EXECUTION_FAILURE);
-
-#ifndef RTLD_LAZY
-#define RTLD_LAZY 1
-#endif
-
-  handle = 0;
-  if (absolute_program (filename) == 0)
-    {
-      loadables_path = get_string_value ("BASH_LOADABLES_PATH");
-      if (loadables_path)
-	{
-	  load_path = find_in_path (filename, loadables_path, FS_NODIRS|FS_EXEC_PREFERRED);
-	  if (load_path)
-	    {
-#if defined (_AIX)
-	      handle = dlopen (load_path, RTLD_NOW|RTLD_GLOBAL);
-#else
-	      handle = dlopen (load_path, RTLD_LAZY);
-#endif /* !_AIX */
-	      free (load_path);
-	    }
-	}
-    }
-
-  /* Fall back to current directory for now */
-  if (handle == 0)
-#if defined (_AIX)
-    handle = dlopen (filename, RTLD_NOW|RTLD_GLOBAL);
-#else
-    handle = dlopen (filename, RTLD_LAZY);
-#endif /* !_AIX */
-
-  if (handle == 0)
-    {
-      /* If we've been told to be quiet, don't complain about not finding the
-	 specified shared object. */
-      if ((flags & SILENT) == 0)
-	{
-	  name = printable_filename (filename, 0);
-	  builtin_error (_("cannot open shared object %s: %s"), name, dlerror ());
-	  if (name != filename)
-	    free (name);
-	}
-      return (EX_NOTFOUND);
-    }
-
-  for (new = 0, l = list; l; l = l->next, new++)
-    ;
-  new_builtins = (struct builtin **)xmalloc (new * sizeof (struct builtin *));
-
-  /* For each new builtin in the shared object, find it and its describing
-     structure.  If this is overwriting an existing builtin, do so, otherwise
-     save the loaded struct for creating the new list of builtins. */
-  for (replaced = new = 0; list; list = list->next)
-    {
-      name = list->word->word;
-
-      size = strlen (name);
-      struct_name = (char *)xmalloc (size + 8);
-      strcpy (struct_name, name);
-      strcpy (struct_name + size, STRUCT_SUFFIX);
-
-      old_builtin = builtin_address_internal (name, 1);
-
-      b = (struct builtin *)dlsym (handle, struct_name);
-      if (b == 0)
-	{
-	  name = printable_filename (filename, 0);
-	  builtin_error (_("cannot find %s in shared object %s: %s"),
-			    struct_name, name, dlerror ());
-	  if (name != filename)
-	    free (name);
-	  free (struct_name);
-	  continue;
-	}
-
-      funcname = xrealloc (struct_name, size + sizeof (LOAD_SUFFIX) + 1);
-      strcpy (funcname, name);
-      strcpy (funcname + size, LOAD_SUFFIX);
-
-      loadfunc = (sh_load_func_t *)dlsym (handle, funcname);
-      if (loadfunc)
-	{
-	  /* Add warning if running an init function more than once */
-	  if (old_builtin && (old_builtin->flags & STATIC_BUILTIN) == 0)
-	    builtin_warning (_("%s: dynamic builtin already loaded"), name);
-	  r = (*loadfunc) (name);
-	  if (r == 0)
-	    {
-	      builtin_error (_("load function for %s returns failure (%d): not loaded"), name, r);
-	      free (funcname);
-	      continue;
-	    }
-	}
-      free (funcname);
-
-      b->flags &= ~STATIC_BUILTIN;
-      if (flags & SPECIAL)
-	b->flags |= SPECIAL_BUILTIN;
-      b->handle = handle;
-
-      if (old_builtin)
-	{
-	  replaced++;
-	  FASTCOPY ((char *)b, (char *)old_builtin, sizeof (struct builtin));
-	}
-      else
-	  new_builtins[new++] = b;
-    }
-
-  if (replaced == 0 && new == 0)
-    {
-      free (new_builtins);
-      dlclose (handle);
-      return (EXECUTION_FAILURE);
-    }
-
-  if (new)
-    {
-      total = num_shell_builtins + new;
-      size = (total + 1) * sizeof (struct builtin);
-
-      new_shell_builtins = (struct builtin *)xmalloc (size);
-      FASTCOPY ((char *)shell_builtins, (char *)new_shell_builtins,
-		num_shell_builtins * sizeof (struct builtin));
-      for (replaced = 0; replaced < new; replaced++)
-	FASTCOPY ((char *)new_builtins[replaced],
-		  (char *)&new_shell_builtins[num_shell_builtins + replaced],
-		  sizeof (struct builtin));
-
-      new_shell_builtins[total].name = (char *)0;
-      new_shell_builtins[total].function = (sh_builtin_func_t *)0;
-      new_shell_builtins[total].flags = 0;
-
-      if (shell_builtins != static_shell_builtins)
-	free (shell_builtins);
-
-      shell_builtins = new_shell_builtins;
-      num_shell_builtins = total;
-      initialize_shell_builtins ();
-    }
-
-  free (new_builtins);
-  return (EXECUTION_SUCCESS);
-}
-#endif
-
-#if defined (HAVE_DLCLOSE)
-static void
-delete_builtin (b)
-     struct builtin *b;
-{
-  int ind, size;
-  struct builtin *new_shell_builtins;
-
-  /* XXX - funky pointer arithmetic - XXX */
-#ifdef __STDC__
-  ind = b - shell_builtins;
-#else
-  ind = ((int)b - (int)shell_builtins) / sizeof (struct builtin);
-#endif
-  size = num_shell_builtins * sizeof (struct builtin);
-  new_shell_builtins = (struct builtin *)xmalloc (size);
-
-  /* Copy shell_builtins[0]...shell_builtins[ind - 1] to new_shell_builtins */
-  if (ind)
-    FASTCOPY ((char *)shell_builtins, (char *)new_shell_builtins,
-	      ind * sizeof (struct builtin));
-  /* Copy shell_builtins[ind+1]...shell_builtins[num_shell_builtins to
-     new_shell_builtins, starting at ind. */
-  FASTCOPY ((char *)(&shell_builtins[ind+1]),
-  	    (char *)(&new_shell_builtins[ind]),
-  	    (num_shell_builtins - ind) * sizeof (struct builtin));
-
-  if (shell_builtins != static_shell_builtins)
-    free (shell_builtins);
-
-  /* The result is still sorted. */
-  num_shell_builtins--;
-  shell_builtins = new_shell_builtins;
-}
-
-/* Tenon's MachTen has a dlclose that doesn't return a value, so we
-   finesse it with a local wrapper. */
-static int
-local_dlclose (handle)
-     void *handle;
-{
-#if !defined (__MACHTEN__)
-  return (dlclose (handle));
-#else /* __MACHTEN__ */
-  dlclose (handle);
-  return ((dlerror () != NULL) ? -1 : 0);    
-#endif /* __MACHTEN__ */
-}
-
-static int
-dyn_unload_builtin (name)
-     char *name;
-{
-  struct builtin *b;
-  void *handle;
-  char *funcname;
-  sh_unload_func_t *unloadfunc;
-  int ref, i, size;
-
-  b = builtin_address_internal (name, 1);
-  if (b == 0)
-    {
-      sh_notbuiltin (name);
-      return (EXECUTION_FAILURE);
-    }
-  if (b->flags & STATIC_BUILTIN)
-    {
-      builtin_error (_("%s: not dynamically loaded"), name);
-      return (EXECUTION_FAILURE);
-    }
-
-  handle = (void *)b->handle;
-  for (ref = i = 0; i < num_shell_builtins; i++)
-    {
-      if (shell_builtins[i].handle == b->handle)
-	ref++;
-    }
-
-  /* Call any unload function */
-  size = strlen (name);
-  funcname = xmalloc (size + sizeof (UNLOAD_SUFFIX) + 1);
-  strcpy (funcname, name);
-  strcpy (funcname + size, UNLOAD_SUFFIX);
-
-  unloadfunc = (sh_unload_func_t *)dlsym (handle, funcname);
-  if (unloadfunc)
-    (*unloadfunc) (name);	/* void function */
-  free (funcname);
-
-  /* Don't remove the shared object unless the reference count of builtins
-     using it drops to zero. */
-  if (ref == 1 && local_dlclose (handle) != 0)
-    {
-      builtin_error (_("%s: cannot delete: %s"), name, dlerror ());
-      return (EXECUTION_FAILURE);
-    }
-
-  /* Now remove this entry from the builtin table and reinitialize. */
-  delete_builtin (b);
-
-  return (EXECUTION_SUCCESS);
-}
-#endif
diff --git a/third_party/bash/builtins_eval.c b/third_party/bash/builtins_eval.c
deleted file mode 100644
index 8bb0b8b23..000000000
--- a/third_party/bash/builtins_eval.c
+++ /dev/null
@@ -1,28 +0,0 @@
-/* eval.c, created from eval.def. */
-#line 22 "./eval.def"
-
-#line 34 "./eval.def"
-
-#include "config.h"
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "shell.h"
-#include "bashgetopt.h"
-#include "common.h"
-
-/* Parse the string that these words make, and execute the command found. */
-int
-eval_builtin (list)
-     WORD_LIST *list;
-{
-  if (no_options (list))
-    return (EX_USAGE);
-  list = loptend;	/* skip over possible `--' */
-
-  return (list ? evalstring (string_list (list), "eval", SEVAL_NOHIST) : EXECUTION_SUCCESS);
-}
diff --git a/third_party/bash/builtins_exec.c b/third_party/bash/builtins_exec.c
deleted file mode 100644
index ae5ca7eb6..000000000
--- a/third_party/bash/builtins_exec.c
+++ /dev/null
@@ -1,238 +0,0 @@
-/* exec.c, created from exec.def. */
-#line 22 "./exec.def"
-
-#line 43 "./exec.def"
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "posixstat.h"
-#include <signal.h>
-#include <errno.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "findcmd.h"
-#if defined (JOB_CONTROL)
-#  include "jobs.h"
-#endif
-#include "flags.h"
-#include "trap.h"
-#if defined (HISTORY)
-#  include "bashhist.h"
-#endif
-#include "common.h"
-#include "bashgetopt.h"
-#include "input.h"
-
-/* Not all systems declare ERRNO in errno.h... and some systems #define it! */
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-extern REDIRECT *redirection_undo_list;
-extern char *exec_argv0;
-
-int no_exit_on_failed_exec;
-
-/* If the user wants this to look like a login shell, then
-   prepend a `-' onto NAME and return the new name. */
-static char *
-mkdashname (name)
-     char *name;
-{
-  char *ret;
-
-  ret = (char *)xmalloc (2 + strlen (name));
-  ret[0] = '-';
-  strcpy (ret + 1, name);
-  return ret;
-}
-
-int
-exec_builtin (list)
-     WORD_LIST *list;
-{
-  int exit_value = EXECUTION_FAILURE;
-  int cleanenv, login, opt, orig_job_control;
-  char *argv0, *command, **args, **env, *newname, *com2;
-
-  cleanenv = login = orig_job_control = 0;
-  exec_argv0 = argv0 = (char *)NULL;
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "cla:")) != -1)
-    {
-      switch (opt)
-	{
-	case 'c':
-	  cleanenv = 1;
-	  break;
-	case 'l':
-	  login = 1;
-	  break;
-	case 'a':
-	  argv0 = list_optarg;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  /* First, let the redirections remain. */
-  dispose_redirects (redirection_undo_list);
-  redirection_undo_list = (REDIRECT *)NULL;
-
-  if (list == 0)
-    return (EXECUTION_SUCCESS);
-
-#if defined (RESTRICTED_SHELL)
-  if (restricted)
-    {
-      sh_restricted ((char *)NULL);
-      return (EXECUTION_FAILURE);
-    }
-#endif /* RESTRICTED_SHELL */
-
-  args = strvec_from_word_list (list, 1, 0, (int *)NULL);
-  env = (char **)0;
-
-  /* A command with a slash anywhere in its name is not looked up in $PATH. */
-  command = absolute_program (args[0]) ? args[0] : search_for_command (args[0], 1);
-
-  if (command == 0)
-    {
-      if (file_isdir (args[0]))
-	{
-#if defined (EISDIR)
-	  builtin_error (_("%s: cannot execute: %s"), args[0], strerror (EISDIR));
-#else
-	  builtin_error (_("%s: cannot execute: %s"), args[0], strerror (errno));
-#endif
-	  exit_value = EX_NOEXEC;
-	}
-      else
-	{
-	  sh_notfound (args[0]);
-	  exit_value = EX_NOTFOUND;	/* As per Posix.2, 3.14.6 */
-	}
-      goto failed_exec;
-    }
-
-  com2 = full_pathname (command);
-  if (com2)
-    {
-      if (command != args[0])
-	free (command);
-      command = com2;
-    }
-
-  if (argv0)
-    {
-      free (args[0]);
-      args[0] = login ? mkdashname (argv0) : savestring (argv0);
-      exec_argv0 = savestring (args[0]);
-    }
-  else if (login)
-    {
-      newname = mkdashname (args[0]);
-      free (args[0]);
-      args[0] = newname;
-    }
-
-  /* Decrement SHLVL by 1 so a new shell started here has the same value,
-     preserving the appearance.  After we do that, we need to change the
-     exported environment to include the new value.  If we've already forked
-     and are in a subshell, we don't want to decrement the shell level,
-     since we are `increasing' the level */
-
-  if (cleanenv == 0 && (subshell_environment & SUBSHELL_PAREN) == 0)
-    adjust_shell_level (-1);
-
-  if (cleanenv)
-    {
-      env = strvec_create (1);
-      env[0] = (char *)0;
-    }
-  else
-    {	
-      maybe_make_export_env ();
-      env = export_env;
-    }
-
-#if defined (HISTORY)
-  if (interactive_shell && subshell_environment == 0)
-    maybe_save_shell_history ();
-#endif /* HISTORY */
-
-  reset_signal_handlers ();		/* leave trap strings in place */
-
-#if defined (JOB_CONTROL)
-  orig_job_control = job_control;	/* XXX - was also interactive_shell */
-  if (subshell_environment == 0)
-    end_job_control ();
-  if (interactive || job_control)
-    default_tty_job_signals ();		/* undo initialize_job_signals */
-#endif /* JOB_CONTROL */
-
-#if defined (BUFFERED_INPUT)
-  if (default_buffered_input >= 0)
-    sync_buffered_stream (default_buffered_input);
-#endif
-
-  exit_value = shell_execve (command, args, env);
-
-  /* We have to set this to NULL because shell_execve has called realloc()
-     to stuff more items at the front of the array, which may have caused
-     the memory to be freed by realloc().  We don't want to free it twice. */
-  args = (char **)NULL;
-  if (cleanenv == 0)
-    adjust_shell_level (1);
-
-  if (exit_value == EX_NOTFOUND)	/* no duplicate error message */
-    goto failed_exec;
-  else if (executable_file (command) == 0)
-    {
-      builtin_error (_("%s: cannot execute: %s"), command, strerror (errno));
-      exit_value = EX_NOEXEC;	/* As per Posix.2, 3.14.6 */
-    }
-  else
-    file_error (command);
-
-failed_exec:
-  FREE (command);
-
-  if (subshell_environment || (interactive == 0 && no_exit_on_failed_exec == 0))
-    exit_shell (last_command_exit_value = exit_value);
-
-  if (args)
-    strvec_dispose (args);
-
-  if (env && env != export_env)
-    strvec_dispose (env);
-
-  /* If we're not exiting after the exec fails, we restore the shell signal
-     handlers and then modify the signal dispositions based on the trap strings
-     before the failed exec. */
-  initialize_signals (1);
-  restore_traps ();
-
-#if defined (JOB_CONTROL)
-  if (orig_job_control)
-    restart_job_control ();
-#endif /* JOB_CONTROL */
-
-  return (exit_value);
-}
diff --git a/third_party/bash/builtins_exit.c b/third_party/bash/builtins_exit.c
deleted file mode 100644
index 89f8d3a78..000000000
--- a/third_party/bash/builtins_exit.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/* exit.c, created from exit.def. */
-#line 22 "./exit.def"
-
-#line 31 "./exit.def"
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include <stdio.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "jobs.h"
-#include "trap.h"
-
-#include "common.h"
-#include "builtext.h"	/* for jobs_builtin */
-
-extern int check_jobs_at_exit;
-
-static int exit_or_logout PARAMS((WORD_LIST *));
-static int sourced_logout;
-
-int
-exit_builtin (list)
-     WORD_LIST *list;
-{
-  CHECK_HELPOPT (list);
-
-  if (interactive)
-    {
-      fprintf (stderr, login_shell ? _("logout\n") : "exit\n");
-      fflush (stderr);
-    }
-
-  return (exit_or_logout (list));
-}
-
-#line 79 "./exit.def"
-
-/* How to logout. */
-int
-logout_builtin (list)
-     WORD_LIST *list;
-{
-  CHECK_HELPOPT (list);
-
-  if (login_shell == 0 /* && interactive */)
-    {
-      builtin_error (_("not login shell: use `exit'"));
-      return (EXECUTION_FAILURE);
-    }
-  else
-    return (exit_or_logout (list));
-}
-
-static int
-exit_or_logout (list)
-     WORD_LIST *list;
-{
-  int exit_value;
-
-#if defined (JOB_CONTROL)
-  int exit_immediate_okay, stopmsg;
-
-  exit_immediate_okay = (interactive  == 0 ||
-			 last_shell_builtin == exit_builtin ||
-			 last_shell_builtin == logout_builtin ||
-			 last_shell_builtin == jobs_builtin);
-
-  /* Check for stopped jobs if the user wants to. */
-  if (exit_immediate_okay == 0)
-    {
-      register int i;
-      for (i = stopmsg = 0; i < js.j_jobslots; i++)
-	if (jobs[i] && STOPPED (i))
-	  stopmsg = JSTOPPED;
-	else if (check_jobs_at_exit && stopmsg == 0 && jobs[i] && RUNNING (i))
-	  stopmsg = JRUNNING;
-
-      if (stopmsg == JSTOPPED)
-	fprintf (stderr, _("There are stopped jobs.\n"));
-      else if (stopmsg == JRUNNING)
-	fprintf (stderr, _("There are running jobs.\n"));
-
-      if (stopmsg && check_jobs_at_exit)
-        list_all_jobs (JLIST_STANDARD);
-
-      if (stopmsg)
-	{
-	  /* This is NOT superfluous because EOF can get here without
-	     going through the command parser.  Set both last and this
-	     so that either `exit', `logout', or ^D will work to exit
-	     immediately if nothing intervenes. */
-	  this_shell_builtin = last_shell_builtin = exit_builtin;
-	  return (EXECUTION_FAILURE);
-	}
-    }
-#endif /* JOB_CONTROL */
-
-  /* Get return value if present.  This means that you can type
-     `logout 5' to a shell, and it returns 5. */
-
-  /* If we're running the exit trap (running_trap == 1, since running_trap
-     gets set to SIG+1), and we don't have a argument given to `exit'
-     (list == 0), use the exit status we saved before running the trap
-     commands (trap_saved_exit_value). */
-  exit_value = (running_trap == 1 && list == 0) ? trap_saved_exit_value : get_exitstat (list);
-
-  bash_logout ();
-
-  last_command_exit_value = exit_value;
-
-  /* Exit the program. */
-  jump_to_top_level (EXITBLTIN);
-  /*NOTREACHED*/
-}
-
-void
-bash_logout ()
-{
-  /* Run our `~/.bash_logout' file if it exists, and this is a login shell. */
-  if (login_shell && sourced_logout++ == 0 && subshell_environment == 0)
-    {
-      maybe_execute_file ("~/.bash_logout", 1);
-#ifdef SYS_BASH_LOGOUT
-      maybe_execute_file (SYS_BASH_LOGOUT, 1);
-#endif
-    }
-}
diff --git a/third_party/bash/builtins_fc.c b/third_party/bash/builtins_fc.c
deleted file mode 100644
index 20d4b5433..000000000
--- a/third_party/bash/builtins_fc.c
+++ /dev/null
@@ -1,739 +0,0 @@
-/* fc.c, created from fc.def. */
-#line 22 "./fc.def"
-
-#line 51 "./fc.def"
-
-#include "config.h"
-
-#if defined (HISTORY)
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-#include "bashtypes.h"
-#include "posixstat.h"
-#if ! defined(_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "chartypes.h"
-
-#include "bashansi.h"
-#include "bashintl.h"
-#include <errno.h>
-
-#include "shell.h"
-#include "builtins.h"
-#include "flags.h"
-#include "parser.h"
-#include "bashhist.h"
-#include "maxpath.h"
-#include "third_party/readline/history.h"
-#include "bashgetopt.h"
-#include "common.h"
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#define HIST_INVALID INT_MIN
-#define HIST_ERANGE  INT_MIN+1
-#define HIST_NOTFOUND INT_MIN+2
-
-/* Values for the flags argument to fc_gethnum */
-#define HN_LISTING	0x01
-#define HN_FIRST	0x02
-
-extern int unlink PARAMS((const char *));
-
-extern FILE *sh_mktmpfp PARAMS((char *, int, char **));
-
-extern int suppress_debug_trap_verbose;
-
-/* **************************************************************** */
-/*								    */
-/*	The K*rn shell style fc command (Fix Command)		    */
-/*								    */
-/* **************************************************************** */
-
-/* fc builtin command (fix command) for Bash for those who
-   like K*rn-style history better than csh-style.
-
-     fc [-e ename] [-nlr] [first] [last]
-
-   FIRST and LAST can be numbers specifying the range, or FIRST can be
-   a string, which means the most recent command beginning with that
-   string.
-
-   -e ENAME selects which editor to use.  Default is FCEDIT, then EDITOR,
-      then the editor which corresponds to the current readline editing
-      mode, then vi.
-
-   -l means list lines instead of editing.
-   -n means no line numbers listed.
-   -r means reverse the order of the lines (making it newest listed first).
-
-     fc -e - [pat=rep ...] [command]
-     fc -s [pat=rep ...] [command]
-
-   Equivalent to !command:sg/pat/rep execpt there can be multiple PAT=REP's.
-*/
-
-/* Data structure describing a list of global replacements to perform. */
-typedef struct repl {
-  struct repl *next;
-  char *pat;
-  char *rep;
-} REPL;
-
-/* Accessors for HIST_ENTRY lists that are called HLIST. */
-#define histline(i) (hlist[(i)]->line)
-#define histdata(i) (hlist[(i)]->data)
-
-#define FREE_RLIST() \
-	do { \
-		for (rl = rlist; rl; ) { \
-			REPL *r;	\
-			r = rl->next; \
-			if (rl->pat) \
-				free (rl->pat); \
-			if (rl->rep) \
-				free (rl->rep); \
-			free (rl); \
-			rl = r; \
-		} \
-	} while (0)
-
-static char *fc_dosubs PARAMS((char *, REPL *));
-static char *fc_gethist PARAMS((char *, HIST_ENTRY **, int));
-static int fc_gethnum PARAMS((char *, HIST_ENTRY **, int));
-static int fc_number PARAMS((WORD_LIST *));
-static void fc_replhist PARAMS((char *));
-#ifdef INCLUDE_UNUSED
-static char *fc_readline PARAMS((FILE *));
-static void fc_addhist PARAMS((char *));
-#endif
-
-static void
-set_verbose_flag ()
-{
-  echo_input_at_read = verbose_flag;
-}
-
-/* String to execute on a file that we want to edit. */
-#define FC_EDIT_COMMAND "${FCEDIT:-${EDITOR:-vi}}"
-#if defined (STRICT_POSIX)
-#  define POSIX_FC_EDIT_COMMAND "${FCEDIT:-ed}"
-#else
-#  define POSIX_FC_EDIT_COMMAND "${FCEDIT:-${EDITOR:-ed}}"
-#endif
-
-int
-fc_builtin (list)
-     WORD_LIST *list;
-{
-  register int i;
-  register char *sep;
-  int numbering, reverse, listing, execute;
-  int histbeg, histend, last_hist, retval, opt, rh, real_last;
-  FILE *stream;
-  REPL *rlist, *rl;
-  char *ename, *command, *newcom, *fcedit;
-  HIST_ENTRY **hlist;
-  char *fn;
-
-  numbering = 1;
-  reverse = listing = execute = 0;
-  ename = (char *)NULL;
-
-  /* Parse out the options and set which of the two forms we're in. */
-  reset_internal_getopt ();
-  lcurrent = list;		/* XXX */
-  while (fc_number (loptend = lcurrent) == 0 &&
-	 (opt = internal_getopt (list, ":e:lnrs")) != -1)
-    {
-      switch (opt)
-	{
-	case 'n':
-	  numbering = 0;
-	  break;
-
-	case 'l':
-	  listing = HN_LISTING;		/* for fc_gethnum */
-	  break;
-
-	case 'r':
-	  reverse = 1;
-	  break;
-
-	case 's':
-	  execute = 1;
-	  break;
-
-	case 'e':
-	  ename = list_optarg;
-	  break;
-
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-
-  list = loptend;
-
-  if (ename && (*ename == '-') && (ename[1] == '\0'))
-    execute = 1;
-
-  /* The "execute" form of the command (re-run, with possible string
-     substitutions). */
-  if (execute)
-    {
-      rlist = (REPL *)NULL;
-      while (list && ((sep = (char *)strchr (list->word->word, '=')) != NULL))
-	{
-	  *sep++ = '\0';
-	  rl = (REPL *)xmalloc (sizeof (REPL));
-	  rl->next = (REPL *)NULL;
-	  rl->pat = savestring (list->word->word);
-	  rl->rep = savestring (sep);
-
-	  if (rlist == NULL)
-	    rlist = rl;
-	  else
-	    {
-	      rl->next = rlist;
-	      rlist = rl;
-	    }
-	  list = list->next;
-	}
-
-      /* If we have a list of substitutions to do, then reverse it
-	 to get the replacements in the proper order. */
-
-      rlist = REVERSE_LIST (rlist, REPL *);
-
-      hlist = history_list ();
-
-      /* If we still have something in list, it is a command spec.
-	 Otherwise, we use the most recent command in time. */
-      command = fc_gethist (list ? list->word->word : (char *)NULL, hlist, 0);
-
-      if (command == NULL)
-	{
-	  builtin_error (_("no command found"));
-	  if (rlist)
-	    FREE_RLIST ();
-
-	  return (EXECUTION_FAILURE);
-	}
-
-      if (rlist)
-	{
-	  newcom = fc_dosubs (command, rlist);
-	  free (command);
-	  FREE_RLIST ();
-	  command = newcom;
-	}
-
-      fprintf (stderr, "%s\n", command);
-      fc_replhist (command);	/* replace `fc -s' with command */
-      /* Posix says that the re-executed commands should be entered into the
-	 history. */
-      return (parse_and_execute (command, "fc", SEVAL_NOHIST));
-    }
-
-  /* This is the second form of the command (the list-or-edit-and-rerun
-     form). */
-  hlist = history_list ();
-  if (hlist == 0)
-    return (EXECUTION_SUCCESS);
-  for (i = 0; hlist[i]; i++);
-
-  /* With the Bash implementation of history, the current command line
-     ("fc blah..." and so on) is already part of the history list by
-     the time we get to this point.  This just skips over that command
-     and makes the last command that this deals with be the last command
-     the user entered before the fc.  We need to check whether the
-     line was actually added (HISTIGNORE may have caused it to not be),
-     so we check hist_last_line_added. */
-
-  /* Even though command substitution through parse_and_execute turns off
-     remember_on_history, command substitution in a shell when set -o history
-     has been enabled (interactive or not) should use it in the last_hist
-     calculation as if it were on. */
-  rh = remember_on_history || ((subshell_environment & SUBSHELL_COMSUB) && enable_history_list);
-  last_hist = i - rh - hist_last_line_added;
-
-  /* Make sure that real_last is calculated the same way here and in
-     fc_gethnum.  The return value from fc_gethnum is treated specially if
-     it is == real_last and we are listing commands. */
-  real_last = i;
-  /* back up from the end to the last non-null history entry */
-  while (hlist[real_last] == 0 && real_last > 0)
-    real_last--;
-
-  /* XXX */
-  if (i == last_hist && hlist[last_hist] == 0)
-    while (last_hist >= 0 && hlist[last_hist] == 0)
-      last_hist--;
-  if (last_hist < 0)
-    last_hist = 0;		/* per POSIX */
-
-  if (list)
-    {
-      histbeg = fc_gethnum (list->word->word, hlist, listing|HN_FIRST);
-      list = list->next;
-
-      if (list)
-	histend = fc_gethnum (list->word->word, hlist, listing);
-      else if (histbeg == real_last)
-	histend = listing ? real_last : histbeg;
-      else
-	histend = listing ? last_hist : histbeg;
-    }
-  else
-    {
-      /* The default for listing is the last 16 history items. */
-      if (listing)
-	{
-	  histend = last_hist;
-	  histbeg = histend - 16 + 1;	/* +1 because loop below uses >= */
-	  if (histbeg < 0)
-	    histbeg = 0;
-	}
-      else
-	/* For editing, it is the last history command. */
-	histbeg = histend = last_hist;
-    }
-
-  if (histbeg == HIST_INVALID || histend == HIST_INVALID)
-    {
-      sh_erange ((char *)NULL, _("history specification")); 
-      return (EXECUTION_FAILURE);
-    }
-  else if (histbeg == HIST_ERANGE || histend == HIST_ERANGE)
-    {
-      sh_erange ((char *)NULL, _("history specification"));
-      return (EXECUTION_FAILURE);
-    }
-  else if (histbeg == HIST_NOTFOUND || histend == HIST_NOTFOUND)
-    {
-      builtin_error (_("no command found"));
-      return (EXECUTION_FAILURE);
-    }
-
-  /* We don't throw an error for line specifications out of range, per POSIX */
-  if (histbeg < 0)
-    histbeg = 0;
-  if (histend < 0)
-    histend = 0;
-
-  /* "When not listing, the fc command that caused the editing shall not be
-     entered into the history list." */
-  if (listing == 0 && hist_last_line_added)
-    {
-      bash_delete_last_history ();
-      /* If we're editing a single command -- the last command in the
-	 history -- and we just removed the dummy command added by
-	 edit_and_execute_command (), we need to check whether or not we
-	 just removed the last command in the history and need to back
-	 the pointer up.  remember_on_history is off because we're running
-	 in parse_and_execute(). */
-      if (histbeg == histend && histend == last_hist && hlist[last_hist] == 0)
-	last_hist = histbeg = --histend;
-
-      if (hlist[last_hist] == 0)
-	last_hist--;
-      if (histend >= last_hist)
-	histend = last_hist;
-      else if (histbeg >= last_hist)
-	histbeg = last_hist;
-    }
-
-  if (histbeg == HIST_INVALID || histend == HIST_INVALID)
-    {
-      sh_erange ((char *)NULL, _("history specification")); 
-      return (EXECUTION_FAILURE);
-    }
-  else if (histbeg == HIST_ERANGE || histend == HIST_ERANGE)
-    {
-      sh_erange ((char *)NULL, _("history specification"));
-      return (EXECUTION_FAILURE);
-    }
-  else if (histbeg == HIST_NOTFOUND || histend == HIST_NOTFOUND)
-    {
-      builtin_error (_("no command found"));
-      return (EXECUTION_FAILURE);
-    }
-
-  /* We don't throw an error for line specifications out of range, per POSIX */
-  if (histbeg < 0)
-    histbeg = 0;
-  if (histend < 0)
-    histend = 0;
-
-  if (histend < histbeg)
-    {
-      i = histend;
-      histend = histbeg;
-      histbeg = i;
-
-      reverse = 1;
-    }
-
-  if (listing)
-    stream = stdout;
-  else
-    {
-      numbering = 0;
-      stream = sh_mktmpfp ("bash-fc", MT_USERANDOM|MT_USETMPDIR, &fn);
-      if (stream == 0)
-	{
-	  builtin_error (_("%s: cannot open temp file: %s"), fn ? fn : "", strerror (errno));
-	  FREE (fn);
-	  return (EXECUTION_FAILURE);
-	}
-    }
-
-  for (i = reverse ? histend : histbeg; reverse ? i >= histbeg : i <= histend; reverse ? i-- : i++)
-    {
-      QUIT;
-      if (hlist[i] == 0)
-	continue;
-      if (numbering)
-	fprintf (stream, "%d", i + history_base);
-      if (listing)
-	{
-	  if (posixly_correct)
-	    fputs ("\t", stream);
-	  else
-	    fprintf (stream, "\t%c", histdata (i) ? '*' : ' ');
-	}
-      if (histline (i))
-	fprintf (stream, "%s\n", histline (i));
-    }
-
-  if (listing)
-    return (sh_chkwrite (EXECUTION_SUCCESS));
-
-  fflush (stream);
-  if (ferror (stream))
-    {
-      sh_wrerror ();
-      fclose (stream);
-      FREE (fn);
-      return (EXECUTION_FAILURE);
-    }
-  fclose (stream);
-
-  /* Now edit the file of commands. */
-  if (ename)
-    {
-      command = (char *)xmalloc (strlen (ename) + strlen (fn) + 2);
-      sprintf (command, "%s %s", ename, fn);
-    }
-  else
-    {
-      fcedit = posixly_correct ? POSIX_FC_EDIT_COMMAND : FC_EDIT_COMMAND;
-      command = (char *)xmalloc (3 + strlen (fcedit) + strlen (fn));
-      sprintf (command, "%s %s", fcedit, fn);
-    }
-  retval = parse_and_execute (command, "fc", SEVAL_NOHIST);
-  if (retval != EXECUTION_SUCCESS)
-    {
-      unlink (fn);
-      free (fn);
-      return (EXECUTION_FAILURE);
-    }
-
-#if defined (READLINE)
-  /* If we're executing as part of a dispatched readline command like
-     {emacs,vi}_edit_and_execute_command, the readline state will indicate it.
-     We could remove the partial command from the history, but ksh93 doesn't
-     so we stay compatible. */
-#endif
-
-  /* Make sure parse_and_execute doesn't turn this off, even though a
-     call to parse_and_execute farther up the function call stack (e.g.,
-     if this is called by vi_edit_and_execute_command) may have already
-     called bash_history_disable. */
-  remember_on_history = 1;
-
-  /* Turn on the `v' flag while fc_execute_file runs so the commands
-     will be echoed as they are read by the parser. */
-  begin_unwind_frame ("fc builtin");
-  add_unwind_protect (xfree, fn);
-  add_unwind_protect (unlink, fn);
-  add_unwind_protect (set_verbose_flag, (char *)NULL);
-  unwind_protect_int (suppress_debug_trap_verbose);
-  echo_input_at_read = 1;
-  suppress_debug_trap_verbose = 1;
-
-  retval = fc_execute_file (fn);
-  run_unwind_frame ("fc builtin");
-
-  return (retval);
-}
-
-/* Return 1 if LIST->word->word is a legal number for fc's use. */
-static int
-fc_number (list)
-     WORD_LIST *list;
-{
-  char *s;
-
-  if (list == 0)
-    return 0;
-  s = list->word->word;
-  if (*s == '-')
-    s++;
-  return (legal_number (s, (intmax_t *)NULL));
-}
-
-/* Return an absolute index into HLIST which corresponds to COMMAND.  If
-   COMMAND is a number, then it was specified in relative terms.  If it
-   is a string, then it is the start of a command line present in HLIST.
-   MODE includes HN_LISTING if we are listing commands, and does not if we
-   are executing them. If MODE includes HN_FIRST we are looking for the
-   first history number specification. */
-static int
-fc_gethnum (command, hlist, mode)
-     char *command;
-     HIST_ENTRY **hlist;
-     int mode;
-{
-  int sign, n, clen, rh;
-  register int i, j, last_hist, real_last, listing;
-  register char *s;
-
-  listing = mode & HN_LISTING;
-  sign = 1;
-  /* Count history elements. */
-  for (i = 0; hlist[i]; i++);
-
-  /* With the Bash implementation of history, the current command line
-     ("fc blah..." and so on) is already part of the history list by
-     the time we get to this point.  This just skips over that command
-     and makes the last command that this deals with be the last command
-     the user entered before the fc.  We need to check whether the
-     line was actually added (HISTIGNORE may have caused it to not be),
-     so we check hist_last_line_added.  This needs to agree with the
-     calculation of last_hist in fc_builtin above. */
-  /* Even though command substitution through parse_and_execute turns off
-     remember_on_history, command substitution in a shell when set -o history
-     has been enabled (interactive or not) should use it in the last_hist
-     calculation as if it were on. */
-  rh = remember_on_history || ((subshell_environment & SUBSHELL_COMSUB) && enable_history_list);
-  last_hist = i - rh - hist_last_line_added;
-
-  if (i == last_hist && hlist[last_hist] == 0)
-    while (last_hist >= 0 && hlist[last_hist] == 0)
-      last_hist--;
-  if (last_hist < 0)
-    return (-1);
-
-  real_last = i;
-  i = last_hist;
-
-  /* No specification defaults to most recent command. */
-  if (command == NULL)
-    return (i);
-
-  /* back up from the end to the last non-null history entry */
-  while (hlist[real_last] == 0 && real_last > 0)
-    real_last--;
-
-  /* Otherwise, there is a specification.  It can be a number relative to
-     the current position, or an absolute history number. */
-  s = command;
-
-  /* Handle possible leading minus sign. */
-  if (s && (*s == '-'))
-    {
-      sign = -1;
-      s++;
-    }
-
-  if (s && DIGIT(*s))
-    {
-      n = atoi (s);
-      n *= sign;
-
-      /* We want to return something that is an offset to HISTORY_BASE. */
-
-      /* If the value is negative or zero, then it is an offset from
-	 the current history item. */
-      /* We don't use HN_FIRST here, so we don't return different values
-	 depending on whether we're looking for the first or last in a
-	 pair of range arguments, but nobody else does, either. */
-      if (n < 0)
-	{
-	  n += i + 1;
-	  return (n < 0 ? 0 : n);
-	}
-      else if (n == 0)
-	return ((sign == -1) ? (listing ? real_last : HIST_INVALID) : i);
-      else
-	{
-	  /* If we're out of range (greater than I (last history entry) or
-	     less than HISTORY_BASE, we want to return different values
-	     based on whether or not we are looking for the first or last
-	     value in a desired range of history entries. */
-	  n -= history_base;
-	  if (n < 0)
-	    return (mode & HN_FIRST ? 0 : i);
-	  else if (n >= i)
-	    return (mode & HN_FIRST ? 0 : i);
-	  else
-	    return n;
-	}
-    }
-
-  clen = strlen (command);
-  for (j = i; j >= 0; j--)
-    {
-      if (STREQN (command, histline (j), clen))
-	return (j);
-    }
-  return (HIST_NOTFOUND);
-}
-
-/* Locate the most recent history line which begins with
-   COMMAND in HLIST, and return a malloc()'ed copy of it.
-   MODE is 1 if we are listing commands, 0 if we are executing them. */
-static char *
-fc_gethist (command, hlist, mode)
-     char *command;
-     HIST_ENTRY **hlist;
-     int mode;
-{
-  int i;
-
-  if (hlist == 0)
-    return ((char *)NULL);
-
-  i = fc_gethnum (command, hlist, mode);
-
-  if (i >= 0)
-    return (savestring (histline (i)));
-  else
-    return ((char *)NULL);
-}
-
-#ifdef INCLUDE_UNUSED
-/* Read the edited history lines from STREAM and return them
-   one at a time.  This can read unlimited length lines.  The
-   caller should free the storage. */
-static char *
-fc_readline (stream)
-     FILE *stream;
-{
-  register int c;
-  int line_len = 0, lindex = 0;
-  char *line = (char *)NULL;
-
-  while ((c = getc (stream)) != EOF)
-    {
-      if ((lindex + 2) >= line_len)
-	line = (char *)xrealloc (line, (line_len += 128));
-
-      if (c == '\n')
-	{
-	  line[lindex++] = '\n';
-	  line[lindex++] = '\0';
-	  return (line);
-	}
-      else
-	line[lindex++] = c;
-    }
-
-  if (!lindex)
-    {
-      if (line)
-	free (line);
-
-      return ((char *)NULL);
-    }
-
-  if (lindex + 2 >= line_len)
-    line = (char *)xrealloc (line, lindex + 3);
-
-  line[lindex++] = '\n';	    /* Finish with newline if none in file */
-  line[lindex++] = '\0';
-  return (line);
-}
-#endif
-
-/* Perform the SUBS on COMMAND.
-   SUBS is a list of substitutions, and COMMAND is a simple string.
-   Return a pointer to a malloc'ed string which contains the substituted
-   command. */
-static char *
-fc_dosubs (command, subs)
-     char *command;
-     REPL *subs;
-{
-  register char *new, *t;
-  register REPL *r;
-
-  for (new = savestring (command), r = subs; r; r = r->next)
-    {
-      t = strsub (new, r->pat, r->rep, 1);
-      free (new);
-      new = t;
-    }
-  return (new);
-}
-
-/* Use `command' to replace the last entry in the history list, which,
-   by this time, is `fc blah...'.  The intent is that the new command
-   become the history entry, and that `fc' should never appear in the
-   history list.  This way you can do `r' to your heart's content. */
-static void
-fc_replhist (command)
-     char *command;
-{
-  int n;
-
-  if (command == 0 || *command == '\0')
-    return;
-
-  n = strlen (command);
-  if (command[n - 1] == '\n')
-    command[n - 1] = '\0';
-
-  if (command && *command)
-    {
-      bash_delete_last_history ();
-      maybe_add_history (command);	/* Obeys HISTCONTROL setting. */
-    }
-}
-
-#ifdef INCLUDE_UNUSED
-/* Add LINE to the history, after removing a single trailing newline. */
-static void
-fc_addhist (line)
-     char *line;
-{
-  register int n;
-
-  if (line == 0 || *line == 0)
-    return;
-
-  n = strlen (line);
-
-  if (line[n - 1] == '\n')
-    line[n - 1] = '\0';
-
-  if (line && *line)
-    maybe_add_history (line);		/* Obeys HISTCONTROL setting. */
-}
-#endif
-
-#endif /* HISTORY */
diff --git a/third_party/bash/builtins_fg_bg.c b/third_party/bash/builtins_fg_bg.c
deleted file mode 100644
index 93ce42d19..000000000
--- a/third_party/bash/builtins_fg_bg.c
+++ /dev/null
@@ -1,146 +0,0 @@
-/* fg_bg.c, created from fg_bg.def. */
-#line 22 "./fg_bg.def"
-
-#line 36 "./fg_bg.def"
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include <signal.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "jobs.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-#if defined (JOB_CONTROL)
-static int fg_bg PARAMS((WORD_LIST *, int));
-
-/* How to bring a job into the foreground. */
-int
-fg_builtin (list)
-     WORD_LIST *list;
-{
-  int fg_bit;
-  register WORD_LIST *t;
-
-  CHECK_HELPOPT (list);
-
-  if (job_control == 0)
-    {
-      sh_nojobs ((char *)NULL);
-      return (EXECUTION_FAILURE);
-    }
-
-  if (no_options (list))
-    return (EX_USAGE);
-  list = loptend;
-
-  /* If the last arg on the line is '&', then start this job in the
-     background.  Else, fg the job. */
-  for (t = list; t && t->next; t = t->next)
-    ;
-  fg_bit = (t && t->word->word[0] == '&' && t->word->word[1] == '\0') == 0;
-
-  return (fg_bg (list, fg_bit));
-}
-#endif /* JOB_CONTROL */
-
-#line 100 "./fg_bg.def"
-
-#if defined (JOB_CONTROL)
-/* How to put a job into the background. */
-int
-bg_builtin (list)
-     WORD_LIST *list;
-{
-  int r;
-
-  CHECK_HELPOPT (list);
-
-  if (job_control == 0)
-    {
-      sh_nojobs ((char *)NULL);
-      return (EXECUTION_FAILURE);
-    }
-
-  if (no_options (list))
-    return (EX_USAGE);
-  list = loptend;
-
-  /* This relies on the fact that fg_bg() takes a WORD_LIST *, but only acts
-     on the first member (if any) of that list. */
-  r = EXECUTION_SUCCESS;
-  do
-    {
-      if (fg_bg (list, 0) == EXECUTION_FAILURE)
-	r = EXECUTION_FAILURE;
-      if (list)
-	list = list->next;
-    }
-  while (list);
-
-  return r;
-}
-
-/* How to put a job into the foreground/background. */
-static int
-fg_bg (list, foreground)
-     WORD_LIST *list;
-     int foreground;
-{
-  sigset_t set, oset;
-  int job, status, old_async_pid;
-  JOB *j;
-
-  BLOCK_CHILD (set, oset);
-  job = get_job_spec (list);
-
-  if (INVALID_JOB (job))
-    {
-      if (job != DUP_JOB)
-	sh_badjob (list ? list->word->word : _("current"));
-
-      goto failure;
-    }
-
-  j = get_job_by_jid (job);
-  /* Or if j->pgrp == shell_pgrp. */
-  if (IS_JOBCONTROL (job) == 0)
-    {
-      builtin_error (_("job %d started without job control"), job + 1);
-      goto failure;
-    }
-
-  if (foreground == 0)
-    {
-      old_async_pid = last_asynchronous_pid;
-      last_asynchronous_pid = j->pgrp;	/* As per Posix.2 5.4.2 */
-    }
-
-  status = start_job (job, foreground);
-
-  if (status >= 0)
-    {
-    /* win: */
-      UNBLOCK_CHILD (oset);
-      return (foreground ? status : EXECUTION_SUCCESS);
-    }
-  else
-    {
-      if (foreground == 0)
-	last_asynchronous_pid = old_async_pid;
-
-    failure:
-      UNBLOCK_CHILD (oset);
-      return (EXECUTION_FAILURE);
-    }
-}
-#endif /* JOB_CONTROL */
diff --git a/third_party/bash/builtins_getopts.c b/third_party/bash/builtins_getopts.c
deleted file mode 100644
index 961906259..000000000
--- a/third_party/bash/builtins_getopts.c
+++ /dev/null
@@ -1,284 +0,0 @@
-/* getopts.c, created from getopts.def. */
-#line 22 "./getopts.def"
-
-#line 64 "./getopts.def"
-
-#include "config.h"
-
-#include <stdio.h>
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "common.h"
-#include "bashgetopt.h"
-#include "getopt.h"
-
-#define G_EOF		-1
-#define G_INVALID_OPT	-2
-#define G_ARG_MISSING	-3
-
-static int getopts_unbind_variable PARAMS((char *));
-static int getopts_bind_variable PARAMS((char *, char *));
-static int dogetopts PARAMS((int, char **));
-
-/* getopts_reset is magic code for when OPTIND is reset.  N is the
-   value that has just been assigned to OPTIND. */
-void
-getopts_reset (newind)
-     int newind;
-{
-  sh_optind = newind;
-  sh_badopt = 0;
-}
-
-static int
-getopts_unbind_variable (name)
-     char *name;
-{
-#if 0
-  return (unbind_variable (name));
-#else
-  return (unbind_variable_noref (name));
-#endif
-}
-
-static int
-getopts_bind_variable (name, value)
-     char *name, *value;
-{
-  SHELL_VAR *v;
-
-  if (legal_identifier (name))
-    {
-      v = bind_variable (name, value, 0);
-      if (v && (readonly_p (v) || noassign_p (v)))
-	return (EX_MISCERROR);
-      return (v ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-    }
-  else
-    {
-      sh_invalidid (name);
-      return (EXECUTION_FAILURE);
-    }
-}
-
-/* Error handling is now performed as specified by Posix.2, draft 11
-   (identical to that of ksh-88).  The special handling is enabled if
-   the first character of the option string is a colon; this handling
-   disables diagnostic messages concerning missing option arguments
-   and invalid option characters.  The handling is as follows.
-
-   INVALID OPTIONS:
-        name -> "?"
-        if (special_error) then
-                OPTARG = option character found
-                no error output
-        else
-                OPTARG unset
-                diagnostic message
-        fi
- 
-  MISSING OPTION ARGUMENT;
-        if (special_error) then
-                name -> ":"
-                OPTARG = option character found
-        else
-                name -> "?"
-                OPTARG unset
-                diagnostic message
-        fi
- */
-
-static int
-dogetopts (argc, argv)
-     int argc;
-     char **argv;
-{
-  int ret, special_error, old_opterr, i, n;
-  char strval[2], numval[16];
-  char *optstr;			/* list of options */
-  char *name;			/* variable to get flag val */
-  char *t;
-
-  if (argc < 3)
-    {
-      builtin_usage ();
-      return (EX_USAGE);
-    }
-
-  /* argv[0] is "getopts". */
-
-  optstr = argv[1];
-  name = argv[2];
-  argc -= 2;
-  argv += 2;
-
-  special_error = optstr[0] == ':';
-
-  if (special_error)
-    {
-      old_opterr = sh_opterr;
-      optstr++;
-      sh_opterr = 0;		/* suppress diagnostic messages */
-    }
-
-  if (argc > 1)
-    {
-      sh_getopt_restore_state (argv);
-      t = argv[0];
-      argv[0] = dollar_vars[0];
-      ret = sh_getopt (argc, argv, optstr);
-      argv[0] = t;
-    }
-  else if (rest_of_args == (WORD_LIST *)NULL)
-    {
-      for (i = 0; i < 10 && dollar_vars[i]; i++)
-	;
-
-      sh_getopt_restore_state (dollar_vars);
-      ret = sh_getopt (i, dollar_vars, optstr);
-    }
-  else
-    {
-      register WORD_LIST *words;
-      char **v;
-
-      i = number_of_args () + 1;	/* +1 for $0 */
-      v = strvec_create (i + 1);
-      for (i = 0; i < 10 && dollar_vars[i]; i++)
-	v[i] = dollar_vars[i];
-      for (words = rest_of_args; words; words = words->next, i++)
-	v[i] = words->word->word;
-      v[i] = (char *)NULL;
-      sh_getopt_restore_state (v);
-      ret = sh_getopt (i, v, optstr);
-      free (v);
-    }
-
-  if (special_error)
-    sh_opterr = old_opterr;
-
-  /* Set the OPTIND variable in any case, to handle "--" skipping.  It's
-     highly unlikely that 14 digits will be too few. */
-  if (sh_optind < 10)
-    {
-      numval[14] = sh_optind + '0';
-      numval[15] = '\0';
-      i = 14;
-    }
-  else
-    {
-      numval[i = 15] = '\0';
-      n = sh_optind;
-      do
-	{
-	  numval[--i] = (n % 10) + '0';
-	}
-      while (n /= 10);
-    }
-  bind_variable ("OPTIND", numval + i, 0);
-
-  /* If an error occurred, decide which one it is and set the return
-     code appropriately.  In all cases, the option character in error
-     is in OPTOPT.  If an invalid option was encountered, OPTARG is
-     NULL.  If a required option argument was missing, OPTARG points
-     to a NULL string (that is, sh_optarg[0] == 0). */
-  if (ret == '?')
-    {
-      if (sh_optarg == NULL)
-	ret = G_INVALID_OPT;
-      else if (sh_optarg[0] == '\0')
-	ret = G_ARG_MISSING;
-    }
-	    
-  if (ret == G_EOF)
-    {
-      getopts_unbind_variable ("OPTARG");
-      getopts_bind_variable (name, "?");
-      return (EXECUTION_FAILURE);
-    }
-
-  if (ret == G_INVALID_OPT)
-    {
-      /* Invalid option encountered. */
-      ret = getopts_bind_variable (name, "?");
-
-      if (special_error)
-	{
-	  strval[0] = (char)sh_optopt;
-	  strval[1] = '\0';
-	  bind_variable ("OPTARG", strval, 0);
-	}
-      else
-	getopts_unbind_variable ("OPTARG");
-
-      return (ret);
-    }
-
-  if (ret == G_ARG_MISSING)
-    {
-      /* Required argument missing. */
-      if (special_error)
-	{
-	  ret = getopts_bind_variable (name, ":");
-
-	  strval[0] = (char)sh_optopt;
-	  strval[1] = '\0';
-	  bind_variable ("OPTARG", strval, 0);
-	}
-      else
-	{
-	  ret = getopts_bind_variable (name, "?");
-	  getopts_unbind_variable ("OPTARG");
-	}
-      return (ret);
-    }			
-
-  bind_variable ("OPTARG", sh_optarg, 0);
-
-  strval[0] = (char) ret;
-  strval[1] = '\0';
-  return (getopts_bind_variable (name, strval));
-}
-
-/* The getopts builtin.  Build an argv, and call dogetopts with it. */
-int
-getopts_builtin (list)
-     WORD_LIST *list;
-{
-  char **av;
-  int ac, ret;
-
-  if (list == 0)
-    {
-      builtin_usage ();
-      return EX_USAGE;
-    }
-
-  reset_internal_getopt ();
-  if ((ret = internal_getopt (list, "")) != -1)
-    {
-      if (ret == GETOPT_HELP)
-	builtin_help ();
-      else
-	builtin_usage ();
-      return (EX_USAGE);
-    }
-  list = loptend;
-
-  av = make_builtin_argv (list, &ac);
-  ret = dogetopts (ac, av);
-  free ((char *)av);
-
-  return (ret);
-}
diff --git a/third_party/bash/builtins_hash.c b/third_party/bash/builtins_hash.c
deleted file mode 100644
index 39fc71948..000000000
--- a/third_party/bash/builtins_hash.c
+++ /dev/null
@@ -1,264 +0,0 @@
-/* hash.c, created from hash.def. */
-#line 22 "./hash.def"
-
-#line 46 "./hash.def"
-
-#include "config.h"
-
-#include <stdio.h>
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <errno.h>
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "builtins.h"
-#include "execute_cmd.h"
-#include "flags.h"
-#include "findcmd.h"
-#include "hashcmd.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-extern int dot_found_in_search;
-
-static int add_hashed_command PARAMS((char *, int));
-static int print_hash_info PARAMS((BUCKET_CONTENTS *));
-static int print_portable_hash_info PARAMS((BUCKET_CONTENTS *));
-static int print_hashed_commands PARAMS((int));
-static int list_hashed_filename_targets PARAMS((WORD_LIST *, int));
-
-/* Print statistics on the current state of hashed commands.  If LIST is
-   not empty, then rehash (or hash in the first place) the specified
-   commands. */
-int
-hash_builtin (list)
-     WORD_LIST *list;
-{
-  int expunge_hash_table, list_targets, list_portably, delete, opt;
-  char *w, *pathname;
-
-  if (hashing_enabled == 0)
-    {
-      builtin_error (_("hashing disabled"));
-      return (EXECUTION_FAILURE);
-    }
-
-  expunge_hash_table = list_targets = list_portably = delete = 0;
-  pathname = (char *)NULL;
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "dlp:rt")) != -1)
-    {
-      switch (opt)
-	{
-	case 'd':
-	  delete = 1;
-	  break;
-	case 'l':
-	  list_portably = 1;
-	  break;
-	case 'p':
-	  pathname = list_optarg;
-	  break;
-	case 'r':
-	  expunge_hash_table = 1;
-	  break;
-	case 't':
-	  list_targets = 1;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  /* hash -t requires at least one argument. */
-  if (list == 0 && (delete || list_targets))
-    {
-      sh_needarg (delete ? "-d" : "-t");
-      return (EXECUTION_FAILURE);
-    }
-
-  /* We want hash -r to be silent, but hash -- to print hashing info, so
-     we test expunge_hash_table. */
-  if (list == 0 && expunge_hash_table == 0)
-    {
-      opt = print_hashed_commands (list_portably);
-      if (opt == 0 && posixly_correct == 0 &&
-	    (list_portably == 0 || shell_compatibility_level <= 50))
-	printf (_("%s: hash table empty\n"), this_command_name);
-
-      return (sh_chkwrite (EXECUTION_SUCCESS));
-    }
-
-  if (expunge_hash_table)
-    phash_flush ();
-
-  /* If someone runs `hash -r -t xyz' he will be disappointed. */
-  if (list_targets)
-    return (list_hashed_filename_targets (list, list_portably));
-      
-#if defined (RESTRICTED_SHELL)
-  if (restricted && pathname)
-    {
-      if (strchr (pathname, '/'))
-	{
-          sh_restricted (pathname);
-          return (EXECUTION_FAILURE);
-	}
-      /* If we are changing the hash table in a restricted shell, make sure the
-	 target pathname can be found using a $PATH search. */
-      w = find_user_command (pathname);
-      if (w == 0 || *w == 0 || executable_file (w) == 0)
-	{
-	  sh_notfound (pathname);
-	  free (w);
-	  return (EXECUTION_FAILURE);
-	}
-      free (w);
-    }
-#endif
-
-  for (opt = EXECUTION_SUCCESS; list; list = list->next)
-    {
-      /* Add, remove or rehash the specified commands. */
-      w = list->word->word;
-      if (absolute_program (w))
-	continue;
-      else if (pathname)
-	{
-	  if (file_isdir (pathname))
-	    {
-#ifdef EISDIR
-	      builtin_error ("%s: %s", pathname, strerror (EISDIR));
-#else
-	      builtin_error (_("%s: is a directory"), pathname);
-#endif
-	      opt = EXECUTION_FAILURE;
-	    }
-	  else
-	    phash_insert (w, pathname, 0, 0);
-	}
-      else if (delete)
-	{
-	  if (phash_remove (w))
-	    {
-	      sh_notfound (w);
-	      opt = EXECUTION_FAILURE;
-	    }
-	}
-      else if (add_hashed_command (w, 0))
-	opt = EXECUTION_FAILURE;
-    }
-
-  fflush (stdout);
-  return (opt);
-}
-
-static int
-add_hashed_command (w, quiet)
-     char *w;
-     int quiet;
-{
-  int rv;
-  char *full_path;
-
-  rv = 0;
-  if (find_function (w) == 0 && find_shell_builtin (w) == 0)
-    {
-      phash_remove (w);
-      full_path = find_user_command (w);
-      if (full_path && executable_file (full_path))
-	phash_insert (w, full_path, dot_found_in_search, 0);
-      else
-	{
-	  if (quiet == 0)
-	    sh_notfound (w);
-	  rv++;
-	}
-      FREE (full_path);
-    }
-  return (rv);
-}
-
-/* Print information about current hashed info. */
-static int
-print_hash_info (item)
-     BUCKET_CONTENTS *item;
-{
-  printf ("%4d\t%s\n", item->times_found, pathdata(item)->path);
-  return 0;
-}
-
-static int
-print_portable_hash_info (item)
-     BUCKET_CONTENTS *item;
-{
-  char *fp, *fn;
-
-  fp = printable_filename (pathdata(item)->path, 1);
-  fn = printable_filename (item->key, 1);
-  printf ("builtin hash -p %s %s\n", fp, fn);
-  if (fp != pathdata(item)->path)
-    free (fp);
-  if (fn != item->key)
-    free (fn);
-  return 0;
-}
-
-static int
-print_hashed_commands (fmt)
-     int fmt;
-{
-  if (hashed_filenames == 0 || HASH_ENTRIES (hashed_filenames) == 0)
-    return (0);
-
-  if (fmt == 0)
-    printf (_("hits\tcommand\n"));
-  hash_walk (hashed_filenames, fmt ? print_portable_hash_info : print_hash_info);
-  return (1);
-}
-
-static int
-list_hashed_filename_targets (list, fmt)
-     WORD_LIST *list;
-     int fmt;
-{
-  int all_found, multiple;
-  char *target;
-  WORD_LIST *l;
-
-  all_found = 1;
-  multiple = list->next != 0;
-
-  for (l = list; l; l = l->next)
-    {
-      target = phash_search (l->word->word);
-      if (target == 0)
-	{
-	  all_found = 0;
-	  sh_notfound (l->word->word);
-	  continue;
-	}
-      if (fmt)
-	printf ("builtin hash -p %s %s\n", target, l->word->word);
-      else
-	{
-	  if (multiple)
-	    printf ("%s\t", l->word->word);
-	  printf ("%s\n", target);
-	}
-      free (target);
-    }
-
-  return (all_found ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-}
diff --git a/third_party/bash/builtins_help.c b/third_party/bash/builtins_help.c
deleted file mode 100644
index cbb015c46..000000000
--- a/third_party/bash/builtins_help.c
+++ /dev/null
@@ -1,512 +0,0 @@
-/* help.c, created from help.def. */
-#line 22 "./help.def"
-
-#line 45 "./help.def"
-
-#include "config.h"
-
-#if defined (HELP_BUILTIN)
-#include <stdio.h>
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <errno.h>
-
-#include "filecntl.h"
-#include <stddef.h>
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "builtins.h"
-#include "execute_cmd.h"
-#include "pathexp.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-#include "strmatch.h"
-#include "glob.h"
-
-#ifndef errno
-extern int errno;
-#endif
-
-extern const char * const bash_copyright;
-extern const char * const bash_license;
-
-static void show_builtin_command_help PARAMS((void));
-static int open_helpfile PARAMS((char *));
-static void show_desc PARAMS((char *, int));
-static void show_manpage PARAMS((char *, int));
-static void show_longdoc PARAMS((int));
-
-/* Print out a list of the known functions in the shell, and what they do.
-   If LIST is supplied, print out the list which matches for each pattern
-   specified. */
-int
-help_builtin (list)
-     WORD_LIST *list;
-{
-  register int i;
-  char *pattern, *name;
-  int plen, match_found, sflag, dflag, mflag, m, pass, this_found;
-
-  dflag = sflag = mflag = 0;
-  reset_internal_getopt ();
-  while ((i = internal_getopt (list, "dms")) != -1)
-    {
-      switch (i)
-	{
-	case 'd':
-	  dflag = 1;
-	  break;
-	case 'm':
-	  mflag = 1;
-	  break;
-	case 's':
-	  sflag = 1;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  if (list == 0)
-    {
-      show_shell_version (0);
-      show_builtin_command_help ();
-      return (EXECUTION_SUCCESS);
-    }
-
-  /* We should consider making `help bash' do something. */
-
-  if (glob_pattern_p (list->word->word) == 1)
-    {
-      printf ("%s", ngettext ("Shell commands matching keyword `", "Shell commands matching keywords `", (list->next ? 2 : 1)));
-      print_word_list (list, ", ");
-      printf ("%s", _("'\n\n"));
-    }
-
-  for (match_found = 0, pattern = ""; list; list = list->next)
-    {
-      pattern = list->word->word;
-      plen = strlen (pattern);
-
-      for (pass = 1, this_found = 0; pass < 3; pass++)
-	{
-	  for (i = 0; name = shell_builtins[i].name; i++)
-	    {
-	      QUIT;
-
-	      /* First pass: look for exact string or pattern matches.
-		 Second pass: look for prefix matches like bash-4.2 */
-	      if (pass == 1)
-	        m = (strcmp (pattern, name) == 0) ||
-		    (strmatch (pattern, name, FNMATCH_EXTFLAG) != FNM_NOMATCH);
-	      else
-		m = strncmp (pattern, name, plen) == 0;
-
-	      if (m)
-	        {
-	          this_found = 1;
-	          match_found++;
-	          if (dflag)
-		    {
-		      show_desc (name, i);
-		      continue;
-		    }
-	          else if (mflag)
-		    {
-		      show_manpage (name, i);
-		      continue;
-		    }
-
-	          printf ("%s: %s\n", name, _(shell_builtins[i].short_doc));
-
-	          if (sflag == 0)
-		    show_longdoc (i);
-	        }
-	    }
-	  if (pass == 1 && this_found == 1)
-	    break;
-	}
-    }
-
-  if (match_found == 0)
-    {
-      builtin_error (_("no help topics match `%s'.  Try `help help' or `man -k %s' or `info %s'."), pattern, pattern, pattern);
-      return (EXECUTION_FAILURE);
-    }
-
-  return (sh_chkwrite (EXECUTION_SUCCESS));
-}
-
-void
-builtin_help ()
-{
-  int ind;
-  ptrdiff_t d;
-
-  current_builtin = builtin_address_internal (this_command_name, 0);
-  if (current_builtin == 0)
-    return;
-
-  d = current_builtin - shell_builtins;
-
-#if defined (__STDC__)
-  ind = (int)d;
-#else
-  ind = (int)d / sizeof (struct builtin);
-#endif
-
-  printf ("%s: %s\n", this_command_name, _(shell_builtins[ind].short_doc));
-  show_longdoc (ind);  
-}
-
-static int
-open_helpfile (name)
-     char *name;
-{
-  int fd;
-
-  fd = open (name, O_RDONLY);
-  if (fd == -1)
-    {
-      builtin_error (_("%s: cannot open: %s"), name, strerror (errno));
-      return -1;
-    }
-  return fd;
-}
-
-/* By convention, enforced by mkbuiltins.c, if separate help files are being
-   used, the long_doc array contains one string -- the full pathname of the
-   help file for this builtin.  */
-static void
-show_longdoc (i)
-     int i;
-{
-  register int j;
-  char * const *doc;
-  int fd;
-
-  doc = shell_builtins[i].long_doc;
-
-  if (doc && doc[0] && *doc[0] == '/' && doc[1] == (char *)NULL)
-    {
-      fd = open_helpfile (doc[0]);
-      if (fd < 0)
-	return;
-      zcatfd (fd, 1, doc[0]);
-      close (fd);
-    }
-  else if (doc)
-    for (j = 0; doc[j]; j++)
-      printf ("%*s%s\n", BASE_INDENT, " ", _(doc[j]));
-}
-
-static void
-show_desc (name, i)
-     char *name;
-     int i;
-{
-  register int j, r;
-  char **doc, *line;
-  int fd, usefile;
-
-  doc = (char **)shell_builtins[i].long_doc;
-
-  usefile = (doc && doc[0] && *doc[0] == '/' && doc[1] == (char *)NULL);
-  if (usefile)
-    {
-      fd = open_helpfile (doc[0]);
-      if (fd < 0)
-	return;
-      r = zmapfd (fd, &line, doc[0]);
-      close (fd);
-      /* XXX - handle errors if zmapfd returns < 0 */
-    }
-  else
-    line = doc ? doc[0] : (char *)NULL;
-
-  printf ("%s - ", name);
-  for (j = 0; line && line[j]; j++)
-    {
-      putchar (line[j]);
-      if (line[j] == '\n')
-	break;
-    }
-  
-  fflush (stdout);
-
-  if (usefile)
-    free (line);
-}
-
-/* Print builtin help in pseudo-manpage format. */
-static void
-show_manpage (name, i)
-     char *name;
-     int i;
-{
-  register int j;
-  char **doc, *line;
-  int fd, usefile;
-
-  doc = (char **)shell_builtins[i].long_doc;
-
-  usefile = (doc && doc[0] && *doc[0] == '/' && doc[1] == (char *)NULL);
-  if (usefile)
-    {
-      fd = open_helpfile (doc[0]);
-      if (fd < 0)
-	return;
-      zmapfd (fd, &line, doc[0]);
-      close (fd);
-    }
-  else
-    line = doc ? _(doc[0]) : (char *)NULL;
-
-  /* NAME */
-  printf ("NAME\n");
-  printf ("%*s%s - ", BASE_INDENT, " ", name);
-  for (j = 0; line && line[j]; j++)
-    {
-      putchar (line[j]);
-      if (line[j] == '\n')
-	break;
-    }
-  printf ("\n");
-
-  /* SYNOPSIS */
-  printf ("SYNOPSIS\n");
-  printf ("%*s%s\n\n", BASE_INDENT, " ", _(shell_builtins[i].short_doc));
-
-  /* DESCRIPTION */
-  printf ("DESCRIPTION\n");
-  if (usefile == 0)
-    {
-      for (j = 0; doc[j]; j++)
-        printf ("%*s%s\n", BASE_INDENT, " ", _(doc[j]));
-    }
-  else
-    {
-      for (j = 0; line && line[j]; j++)
-	{
-	  putchar (line[j]);
-	  if (line[j] == '\n')
-	    printf ("%*s", BASE_INDENT, " ");
-	}
-    }
-  putchar ('\n');
-
-  /* SEE ALSO */
-  printf ("SEE ALSO\n");
-  printf ("%*sbash(1)\n\n", BASE_INDENT, " ");
-
-  /* IMPLEMENTATION */
-  printf ("IMPLEMENTATION\n");
-  printf ("%*s", BASE_INDENT, " ");
-  show_shell_version (0);
-  printf ("%*s", BASE_INDENT, " ");
-  printf ("%s\n", _(bash_copyright));
-  printf ("%*s", BASE_INDENT, " ");
-  printf ("%s\n", _(bash_license));
-
-  fflush (stdout);
-  if (usefile)
-    free (line);
-}
-
-static void
-dispcolumn (i, buf, bufsize, width, height)
-     int i;
-     char *buf;
-     size_t bufsize;
-     int width, height;
-{
-  int j;
-  int dispcols;
-  char *helpdoc;
-
-  /* first column */
-  helpdoc = _(shell_builtins[i].short_doc);
-
-  buf[0] = (shell_builtins[i].flags & BUILTIN_ENABLED) ? ' ' : '*';
-  strncpy (buf + 1, helpdoc, width - 2);
-  buf[width - 2] = '>';		/* indicate truncation */
-  buf[width - 1] = '\0';
-  printf ("%s", buf);
-  if (((i << 1) >= num_shell_builtins) || (i+height >= num_shell_builtins))
-    {
-      printf ("\n");
-      return;
-    }
-
-  dispcols = strlen (buf);
-  /* two spaces */
-  for (j = dispcols; j < width; j++)
-    putc (' ', stdout);
-
-  /* second column */
-  helpdoc = _(shell_builtins[i+height].short_doc);
-
-  buf[0] = (shell_builtins[i+height].flags & BUILTIN_ENABLED) ? ' ' : '*';
-  strncpy (buf + 1, helpdoc, width - 3);
-  buf[width - 3] = '>';		/* indicate truncation */
-  buf[width - 2] = '\0';
-
-  printf ("%s\n", buf);
-}
-
-#if defined (HANDLE_MULTIBYTE)
-static void
-wdispcolumn (i, buf, bufsize, width, height)
-     int i;
-     char *buf;
-     size_t bufsize;
-     int width, height;
-{
-  int j;
-  int dispcols, dispchars;
-  char *helpdoc;
-  wchar_t *wcstr;
-  size_t slen, n;
-
-  /* first column */
-  helpdoc = _(shell_builtins[i].short_doc);
-
-  wcstr = 0;
-  slen = mbstowcs ((wchar_t *)0, helpdoc, 0);
-  if (slen == -1)
-    {
-      dispcolumn (i, buf, bufsize, width, height);
-      return;
-    }
-
-  /* No bigger than the passed max width */
-  if (slen >= width)
-    slen = width - 2;
-  wcstr = (wchar_t *)xmalloc (sizeof (wchar_t) * (width + 2));
-  n = mbstowcs (wcstr+1, helpdoc, slen + 1);
-  wcstr[n+1] = L'\0';
-
-  /* Turn tabs and newlines into spaces for column display, since wcwidth
-     returns -1 for them */
-  for (j = 1; j < n; j++)
-    if (wcstr[j] == L'\n' || wcstr[j] == L'\t')
-      wcstr[j] = L' ';
-
-  /* dispchars == number of characters that will be displayed */
-  dispchars = wcsnwidth (wcstr+1, slen, width - 2);
-  /* dispcols == number of columns required to display DISPCHARS */
-  dispcols = wcswidth (wcstr+1, dispchars) + 1;	/* +1 for ' ' or '*' */
-
-  wcstr[0] = (shell_builtins[i].flags & BUILTIN_ENABLED) ? L' ' : L'*';
-
-  if (dispcols >= width-2)
-    {
-      wcstr[dispchars] = L'>';		/* indicate truncation */
-      wcstr[dispchars+1] = L'\0';
-    }
-
-  printf ("%ls", wcstr);
-  if (((i << 1) >= num_shell_builtins) || (i+height >= num_shell_builtins))
-    {
-      printf ("\n");
-      free (wcstr);
-      return;
-    }
-
-  /* at least one space */
-  for (j = dispcols; j < width; j++)
-    putc (' ', stdout);
-
-  /* second column */
-  helpdoc = _(shell_builtins[i+height].short_doc);
-  slen = mbstowcs ((wchar_t *)0, helpdoc, 0);
-  if (slen == -1)
-    {
-      /* for now */
-      printf ("%c%s\n", (shell_builtins[i+height].flags & BUILTIN_ENABLED) ? ' ' : '*', helpdoc);
-      free (wcstr);
-      return;
-    }
-
-  /* Reuse wcstr since it is already width wide chars long */
-  if (slen >= width)
-    slen = width - 2;
-  n = mbstowcs (wcstr+1, helpdoc, slen + 1);
-  wcstr[n+1] = L'\0';		/* make sure null-terminated */
-
-  /* Turn tabs and newlines into spaces for column display */
-  for (j = 1; j < n; j++)
-    if (wcstr[j] == L'\n' || wcstr[j] == L'\t')
-      wcstr[j] = L' ';
-
-  /* dispchars == number of characters that will be displayed */
-  dispchars = wcsnwidth (wcstr+1, slen, width - 2);
-  dispcols = wcswidth (wcstr+1, dispchars) + 1;	/* +1 for ' ' or '*' */
-  
-  wcstr[0] = (shell_builtins[i+height].flags & BUILTIN_ENABLED) ? L' ' : L'*';
-
-  /* The dispchars-1 is there for terminals that behave strangely when you
-     have \n in the nth column for terminal width n; this is what bash-4.3
-     did. */
-  if (dispcols >= width - 2)
-    {
-      wcstr[dispchars-1] = L'>';		/* indicate truncation */
-      wcstr[dispchars] = L'\0';
-    }
-
-  printf ("%ls\n", wcstr);
-
-  free (wcstr);
-}
-#endif /* HANDLE_MULTIBYTE */
-
-static void
-show_builtin_command_help ()
-{
-  int i, j;
-  int height, width;
-  char *t, blurb[128];
-
-  printf (
-_("These shell commands are defined internally.  Type `help' to see this list.\n\
-Type `help name' to find out more about the function `name'.\n\
-Use `info bash' to find out more about the shell in general.\n\
-Use `man -k' or `info' to find out more about commands not in this list.\n\
-\n\
-A star (*) next to a name means that the command is disabled.\n\
-\n"));
-
-  width = default_columns ();
-
-  width /= 2;
-  if (width > sizeof (blurb))
-    width = sizeof (blurb);
-  if (width <= 3)
-    width = 40;
-  height = (num_shell_builtins + 1) / 2;	/* number of rows */
-
-  for (i = 0; i < height; i++)
-    {
-      QUIT;
-
-#if defined (HANDLE_MULTIBYTE)
-      if (MB_CUR_MAX > 1)
-	wdispcolumn (i, blurb, sizeof (blurb), width, height);
-      else
-#endif
-	dispcolumn (i, blurb, sizeof (blurb), width, height);
-    }
-}
-#endif /* HELP_BUILTIN */
diff --git a/third_party/bash/builtins_history.c b/third_party/bash/builtins_history.c
deleted file mode 100644
index 7a6a833e1..000000000
--- a/third_party/bash/builtins_history.c
+++ /dev/null
@@ -1,411 +0,0 @@
-/* history.c, created from history.def. */
-#line 22 "./history.def"
-
-#line 58 "./history.def"
-
-#include "config.h"
-
-#if defined (HISTORY)
-#include "bashtypes.h"
-#if ! defined(_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-#include "posixstat.h"
-#include "filecntl.h"
-#include <errno.h>
-#include <stdio.h>
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "flags.h"
-#include "parser.h"
-#include "bashhist.h"
-#include "third_party/readline/history.h"
-#include "bashgetopt.h"
-#include "common.h"
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-static char *histtime PARAMS((HIST_ENTRY *, const char *));
-static int display_history PARAMS((WORD_LIST *));
-static void push_history PARAMS((WORD_LIST *));
-static int expand_and_print_history PARAMS((WORD_LIST *));
-
-#define AFLAG	0x01
-#define RFLAG	0x02
-#define WFLAG	0x04
-#define NFLAG	0x08
-#define SFLAG	0x10
-#define PFLAG	0x20
-#define CFLAG	0x40
-#define DFLAG	0x80
-
-#ifndef TIMELEN_MAX
-#  define TIMELEN_MAX 128
-#endif
-
-int
-history_builtin (list)
-     WORD_LIST *list;
-{
-  int flags, opt, result, old_history_lines, obase, ind;
-  char *filename, *delete_arg, *range;
-  intmax_t delete_offset;
-
-  flags = 0;
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "acd:npsrw")) != -1)
-    {
-      switch (opt)
-	{
-	case 'a':
-	  flags |= AFLAG;
-	  break;
-	case 'c':
-	  flags |= CFLAG;
-	  break;
-	case 'n':
-	  flags |= NFLAG;
-	  break;
-	case 'r':
-	  flags |= RFLAG;
-	  break;
-	case 'w':
-	  flags |= WFLAG;
-	  break;
-	case 's':
-	  flags |= SFLAG;
-	  break;
-	case 'd':
-	  flags |= DFLAG;
-	  delete_arg = list_optarg;
-	  break;
-	case 'p':
-#if defined (BANG_HISTORY)
-	  flags |= PFLAG;
-#endif
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  opt = flags & (AFLAG|RFLAG|WFLAG|NFLAG);
-  if (opt && opt != AFLAG && opt != RFLAG && opt != WFLAG && opt != NFLAG)
-    {
-      builtin_error (_("cannot use more than one of -anrw"));
-      return (EXECUTION_FAILURE);
-    }
-
-  /* clear the history, but allow other arguments to add to it again. */
-  if (flags & CFLAG)
-    {
-      bash_clear_history ();
-      if (list == 0)
-	return (EXECUTION_SUCCESS);
-    }
-
-  if (flags & SFLAG)
-    {
-      if (list)
-	push_history (list);
-      return (EXECUTION_SUCCESS);
-    }
-#if defined (BANG_HISTORY)
-  else if (flags & PFLAG)
-    {
-      if (list)
-	return (expand_and_print_history (list));
-      return (sh_chkwrite (EXECUTION_SUCCESS));
-    }
-#endif
-  else if ((flags & DFLAG) && (range = strchr ((delete_arg[0] == '-') ? delete_arg + 1 : delete_arg, '-')))
-    {
-      intmax_t delete_start, delete_end;
-      *range++ = '\0';
-      if (legal_number (delete_arg, &delete_start) == 0 || legal_number (range, &delete_end) == 0)
-	{
-	  range[-1] = '-';
-	  sh_erange (delete_arg, _("history position"));
-	  return (EXECUTION_FAILURE);
-	}
-      if (delete_arg[0] == '-' && delete_start < 0)
-	/* the_history[history_length] == 0x0, so this is correct */
-        delete_start += history_length;
-      /* numbers as displayed by display_history are offset by history_base */
-      else if (delete_start > 0)
-	delete_start -= history_base;
-
-      if (delete_start < 0 || delete_start >= history_length)
-	{
-	  sh_erange (delete_arg, _("history position"));
-	  return (EXECUTION_FAILURE);
-	}
-
-      if (range[0] == '-' && delete_end < 0)
-        delete_end += history_length;
-      else if (delete_end > 0)
-	delete_end -= history_base;
-
-      if (delete_end < 0 || delete_end >= history_length)
-	{
-	  sh_erange (range, _("history position"));
-	  return (EXECUTION_FAILURE);
-	}
-      /* XXX - print error if end < start? */
-      result = bash_delete_history_range (delete_start, delete_end);
-      if (where_history () > history_length)
-	history_set_pos (history_length);
-      return (result ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-    }
-  else if (flags & DFLAG)
-    {
-      if (legal_number (delete_arg, &delete_offset) == 0)
-	{
-	  sh_erange (delete_arg, _("history position"));
-	  return (EXECUTION_FAILURE);
-	}
-      /* check for negative offsets, count back from end of list */
-      if (delete_arg[0] == '-' && delete_offset < 0)
-	{
-	  /* since the_history[history_length] == 0x0, this calculation means
-	     that history -d -1 will delete the last history entry, which at
-	     this point is the history -d -1 we just added. */
-	  ind = history_length + delete_offset;
-	  if (ind < 0)		/* offset by history_base below */
-	    {
-	      sh_erange (delete_arg, _("history position"));
-	      return (EXECUTION_FAILURE);
-	    }
-	  opt = ind + history_base;	/* compensate for opt - history_base below */
-	}
-      else if ((delete_offset < history_base) || (delete_offset >= (history_base + history_length)))
-	{
-	  sh_erange (delete_arg, _("history position"));
-	  return (EXECUTION_FAILURE);
-	}
-      else
-	opt = delete_offset;
-
-      /* Positive arguments from numbers as displayed by display_history need
-	 to be offset by history_base */
-      result = bash_delete_histent (opt - history_base);
-      /* Since remove_history changes history_length, this can happen if
-	 we delete the last history entry. */
-      if (where_history () > history_length)
-	history_set_pos (history_length);
-      return (result ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-    }
-  else if ((flags & (AFLAG|RFLAG|NFLAG|WFLAG|CFLAG)) == 0)
-    {
-      result = display_history (list);
-      return (sh_chkwrite (result));
-    }
-
-  filename = list ? list->word->word : get_string_value ("HISTFILE");
-  result = EXECUTION_SUCCESS;
-
-#if defined (RESTRICTED_SHELL)
-  if (restricted && strchr (filename, '/'))
-    {
-      sh_restricted (filename);
-      return (EXECUTION_FAILURE);
-    }
-#endif
-
-  if (flags & AFLAG)		/* Append session's history to file. */
-    result = maybe_append_history (filename);
-  else if (flags & WFLAG)	/* Write entire history. */
-    result = write_history (filename);
-  else if (flags & RFLAG)	/* Read entire file. */
-    {
-      result = read_history (filename);
-      history_lines_in_file = history_lines_read_from_file;
-      /* history_lines_in_file = where_history () + history_base - 1; */
-    }
-  else if (flags & NFLAG)	/* Read `new' history from file. */
-    {
-      /* Read all of the lines in the file that we haven't already read. */
-      old_history_lines = history_lines_in_file;
-      obase = history_base;
-
-      using_history ();
-      result = read_history_range (filename, history_lines_in_file, -1);
-      using_history ();
-
-      history_lines_in_file = history_lines_read_from_file;
-      /* history_lines_in_file = where_history () + history_base - 1; */
-
-      /* If we're rewriting the history file at shell exit rather than just
-	 appending the lines from this session to it, the question is whether
-	 we reset history_lines_this_session to 0, losing any history entries
-	 we had before we read the new entries from the history file, or
-	 whether we count the new entries we just read from the file as
-	 history lines added during this session.
-	 Right now, we do the latter.  This will cause these history entries
-	 to be written to the history file along with any intermediate entries
-	 we add when we do a `history -a', but the alternative is losing
-	 them altogether. */
-      if (force_append_history == 0)
-	history_lines_this_session += history_lines_in_file - old_history_lines +
-				    history_base - obase;
-    }
-
-  return (result ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
-}
-
-/* Accessors for HIST_ENTRY lists that are called HLIST. */
-#define histline(i) (hlist[(i)]->line)
-#define histdata(i) (hlist[(i)]->data)
-
-static char *
-histtime (hlist, histtimefmt)
-     HIST_ENTRY *hlist;
-     const char *histtimefmt;
-{
-  static char timestr[TIMELEN_MAX];
-  time_t t;
-  struct tm *tm;
-
-  t = history_get_time (hlist);
-  tm = t ? localtime (&t) : 0;
-  if (t && tm)
-    strftime (timestr, sizeof (timestr), histtimefmt, tm);
-  else if (hlist->timestamp && hlist->timestamp[0])
-    snprintf (timestr, sizeof (timestr), _("%s: invalid timestamp"),
-	(hlist->timestamp[0] == '#') ? hlist->timestamp + 1: hlist->timestamp);
-  else
-    strcpy (timestr, "??");
-  return timestr;
-}
-
-static int
-display_history (list)
-     WORD_LIST *list;
-{
-  register int i;
-  intmax_t limit;
-  HIST_ENTRY **hlist;
-  char *histtimefmt, *timestr;
-
-  if (list)
-    {
-      if (get_numeric_arg (list, 0, &limit) == 0)
-	return (EXECUTION_FAILURE);
-
-      if (limit < 0)
-	limit = -limit;
-    }
-  else
-    limit = -1;
-
-  hlist = history_list ();
-
-  if (hlist)
-    {
-      for (i = 0;  hlist[i]; i++)
-	;
-
-      if (0 <= limit && limit < i)
-	i -= limit;
-      else
-	i = 0;
-
-      histtimefmt = get_string_value ("HISTTIMEFORMAT");
-
-      while (hlist[i])
-	{
-	  QUIT;
-
-	  timestr = (histtimefmt && *histtimefmt) ? histtime (hlist[i], histtimefmt) : (char *)NULL;
-	  printf ("%5d%c %s%s\n", i + history_base,
-		  histdata(i) ? '*' : ' ',
-		  ((timestr && *timestr) ? timestr : ""),
-		  histline(i));
-	  i++;
-	}
-    }
-
-  return (EXECUTION_SUCCESS);
-}
-
-/* Remove the last entry in the history list and add each argument in
-   LIST to the history. */
-static void
-push_history (list)
-     WORD_LIST *list;
-{
-  char *s;
-
-  /* Delete the last history entry if it was a single entry added to the
-     history list (generally the `history -s' itself), or if `history -s'
-     is being used in a compound command and the compound command was
-     added to the history as a single element (command-oriented history).
-     If you don't want history -s to remove the compound command from the
-     history, change #if 0 to #if 1 below. */
-#if 0
-  if (remember_on_history && hist_last_line_pushed == 0 &&
-	hist_last_line_added && bash_delete_last_history () == 0)
-#else
-  if (remember_on_history && hist_last_line_pushed == 0 &&
-	(hist_last_line_added ||
-	  (current_command_line_count > 0 && current_command_first_line_saved && command_oriented_history))
-      && bash_delete_last_history () == 0)
-#endif
-      return;
-
-  s = string_list (list);
-  /* Call check_add_history with FORCE set to 1 to skip the check against
-     current_command_line_count.  If history -s is used in a compound
-     command, the above code will delete the compound command's history
-     entry and this call will add the line to the history as a separate
-     entry.  Without FORCE=1, if current_command_line_count were > 1, the
-     line would be appended to the entry before the just-deleted entry. */
-  check_add_history (s, 1);	/* obeys HISTCONTROL, HISTIGNORE */
-
-  hist_last_line_pushed = 1;	/* XXX */
-  free (s);
-}
-
-#if defined (BANG_HISTORY)
-static int
-expand_and_print_history (list)
-     WORD_LIST *list;
-{
-  char *s;
-  int r, result;
-
-  if (hist_last_line_pushed == 0 && hist_last_line_added && bash_delete_last_history () == 0)
-    return EXECUTION_FAILURE;
-  result = EXECUTION_SUCCESS;
-  while (list)
-    {
-      r = history_expand (list->word->word, &s);
-      if (r < 0)
-	{
-	  builtin_error (_("%s: history expansion failed"), list->word->word);
-	  result = EXECUTION_FAILURE;
-	}
-      else
-	{
-	  fputs (s, stdout);
-	  putchar ('\n');
-	}
-      FREE (s);
-      list = list->next;
-    }
-  fflush (stdout);
-  return result;
-}
-#endif /* BANG_HISTORY */
-#endif /* HISTORY */
diff --git a/third_party/bash/builtins_jobs.c b/third_party/bash/builtins_jobs.c
deleted file mode 100644
index e8cd2eec0..000000000
--- a/third_party/bash/builtins_jobs.c
+++ /dev/null
@@ -1,240 +0,0 @@
-/* jobs.c, created from jobs.def. */
-#line 22 "./jobs.def"
-
-#line 48 "./jobs.def"
-
-#include "config.h"
-
-#if defined (JOB_CONTROL)
-#include "bashtypes.h"
-#include <signal.h>
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "jobs.h"
-#include "execute_cmd.h"
-#include "bashgetopt.h"
-#include "common.h"
-
-#define JSTATE_ANY	0x0
-#define JSTATE_RUNNING	0x1
-#define JSTATE_STOPPED	0x2
-
-static int execute_list_with_replacements PARAMS((WORD_LIST *));
-
-/* The `jobs' command.  Prints outs a list of active jobs.  If the
-   argument `-l' is given, then the process id's are printed also.
-   If the argument `-p' is given, print the process group leader's
-   pid only.  If `-n' is given, only processes that have changed
-   status since the last notification are printed.  If -x is given,
-   replace all job specs with the pid of the appropriate process
-   group leader and execute the command.  The -r and -s options mean
-   to print info about running and stopped jobs only, respectively. */
-int
-jobs_builtin (list)
-     WORD_LIST *list;
-{
-  int form, execute, state, opt, any_failed, job;
-  sigset_t set, oset;
-
-  execute = any_failed = 0;
-  form = JLIST_STANDARD;
-  state = JSTATE_ANY;
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "lpnxrs")) != -1)
-    {
-      switch (opt)
-	{
-	case 'l':
-	  form = JLIST_LONG;
-	  break;
-	case 'p':
-	  form = JLIST_PID_ONLY;
-	  break;
-	case 'n':
-	  form = JLIST_CHANGED_ONLY;
-	  break;
-	case 'x':
-	  if (form != JLIST_STANDARD)
-	    {
-	      builtin_error (_("no other options allowed with `-x'"));
-	      return (EXECUTION_FAILURE);
-	    }
-	  execute++;
-	  break;
-	case 'r':
-	  state = JSTATE_RUNNING;
-	  break;
-	case 's':
-	  state = JSTATE_STOPPED;
-	  break;
-
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-
-  list = loptend;
-
-  if (execute)
-    return (execute_list_with_replacements (list));
-
-  if (!list)
-    {
-      switch (state)
-	{
-	case JSTATE_ANY:
-	  list_all_jobs (form);
-	  break;
-	case JSTATE_RUNNING:
-	  list_running_jobs (form);
-	  break;
-	case JSTATE_STOPPED:
-	  list_stopped_jobs (form);
-	  break;
-	}
-      return (EXECUTION_SUCCESS);
-    }
-
-  while (list)
-    {
-      BLOCK_CHILD (set, oset);
-      job = get_job_spec (list);
-
-      if ((job == NO_JOB) || jobs == 0 || get_job_by_jid (job) == 0)
-	{
-	  sh_badjob (list->word->word);
-	  any_failed++;
-	}
-      else if (job != DUP_JOB)
-	list_one_job ((JOB *)NULL, form, 0, job);
-
-      UNBLOCK_CHILD (oset);
-      list = list->next;
-    }
-  return (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
-}
-
-static int
-execute_list_with_replacements (list)
-     WORD_LIST *list;
-{
-  register WORD_LIST *l;
-  int job, result;
-  COMMAND *command;
-  JOB *j;
-
-  /* First do the replacement of job specifications with pids. */
-  for (l = list; l; l = l->next)
-    {
-      if (l->word->word[0] == '%')	/* we have a winner */
-	{
-	  job = get_job_spec (l);
-
-	  /* A bad job spec is not really a job spec! Pass it through. */
-	  if (INVALID_JOB (job))
-	    continue;
-
-	  j = get_job_by_jid (job);
-	  free (l->word->word);
-	  l->word->word = itos (j->pgrp);
-	}
-    }
-
-  /* Next make a new simple command and execute it. */
-  begin_unwind_frame ("jobs_builtin");
-
-  command = make_bare_simple_command ();
-  command->value.Simple->words = copy_word_list (list);
-  command->value.Simple->redirects = (REDIRECT *)NULL;
-  command->flags |= CMD_INHIBIT_EXPANSION;
-  command->value.Simple->flags |= CMD_INHIBIT_EXPANSION;
-
-  add_unwind_protect (dispose_command, command);
-  result = execute_command (command);
-  dispose_command (command);
-
-  discard_unwind_frame ("jobs_builtin");
-  return (result);
-}
-#endif /* JOB_CONTROL */
-
-#line 231 "./jobs.def"
-
-#if defined (JOB_CONTROL)
-int
-disown_builtin (list)
-     WORD_LIST *list;
-{
-  int opt, job, retval, nohup_only, running_jobs, all_jobs;
-  sigset_t set, oset;
-  intmax_t pid_value;
-
-  nohup_only = running_jobs = all_jobs = 0;
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "ahr")) != -1)
-    {
-      switch (opt)
-	{
-	case 'a':
-	  all_jobs = 1;
-	  break;
-	case 'h':
-	  nohup_only = 1;
-	  break;
-	case 'r':
-	  running_jobs = 1;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-  retval = EXECUTION_SUCCESS;
-
-  /* `disown -a' or `disown -r' */
-  if (list == 0 && (all_jobs || running_jobs))
-    {
-      if (nohup_only)
-	nohup_all_jobs (running_jobs);
-      else
-	delete_all_jobs (running_jobs);
-      return (EXECUTION_SUCCESS);
-    }
-
-  do
-    {
-      BLOCK_CHILD (set, oset);
-      job = (list && legal_number (list->word->word, &pid_value) && pid_value == (pid_t) pid_value)
-		? get_job_by_pid ((pid_t) pid_value, 0, 0)
-		: get_job_spec (list);
-
-      if (job == NO_JOB || jobs == 0 || INVALID_JOB (job))
-	{
-	  sh_badjob (list ? list->word->word : _("current"));
-	  retval = EXECUTION_FAILURE;
-	}
-      else if (nohup_only)
-	nohup_job (job);
-      else
-	delete_job (job, 1);
-      UNBLOCK_CHILD (oset);
-
-      if (list)
-	list = list->next;
-    }
-  while (list);
-
-  return (retval);
-}
-#endif /* JOB_CONTROL */
diff --git a/third_party/bash/builtins_kill.c b/third_party/bash/builtins_kill.c
deleted file mode 100644
index 8a1e73de1..000000000
--- a/third_party/bash/builtins_kill.c
+++ /dev/null
@@ -1,235 +0,0 @@
-/* kill.c, created from kill.def. */
-#line 22 "./kill.def"
-
-#line 46 "./kill.def"
-
-#include "config.h"
-
-#include <stdio.h>
-#include <errno.h>
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include <signal.h>
-
-#include "shell.h"
-#include "trap.h"
-#include "jobs.h"
-#include "common.h"
-
-/* Not all systems declare ERRNO in errno.h... and some systems #define it! */
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-static void kill_error PARAMS((pid_t, int));
-
-#if !defined (CONTINUE_AFTER_KILL_ERROR)
-#  define CONTINUE_OR_FAIL return (EXECUTION_FAILURE)
-#else
-#  define CONTINUE_OR_FAIL goto continue_killing
-#endif /* CONTINUE_AFTER_KILL_ERROR */
-
-/* Here is the kill builtin.  We only have it so that people can type
-   kill -KILL %1?  No, if you fill up the process table this way you
-   can still kill some. */
-int
-kill_builtin (list)
-     WORD_LIST *list;
-{
-  int sig, any_succeeded, listing, saw_signal, dflags;
-  char *sigspec, *word;
-  pid_t pid;
-  intmax_t pid_value;
-
-  if (list == 0)
-    {
-      builtin_usage ();
-      return (EX_USAGE);
-    }
-  CHECK_HELPOPT (list);
-
-  any_succeeded = listing = saw_signal = 0;
-  sig = SIGTERM;
-  sigspec = "TERM";
-
-  dflags = DSIG_NOCASE | ((posixly_correct == 0) ? DSIG_SIGPREFIX : 0);
-  /* Process options. */
-  while (list)
-    {
-      word = list->word->word;
-
-      if (ISOPTION (word, 'l') || ISOPTION (word, 'L'))
-	{
-	  listing++;
-	  list = list->next;
-	}
-      else if (ISOPTION (word, 's') || ISOPTION (word, 'n'))
-	{
-	  list = list->next;
-	  if (list)
-	    {
-	      sigspec = list->word->word;
-use_sigspec:
-	      if (sigspec[0] == '0' && sigspec[1] == '\0')
-		sig = 0;
-	      else
-		sig = decode_signal (sigspec, dflags);
-	      list = list->next;
-	      saw_signal++;
-	    }
-	  else
-	    {
-	      sh_needarg (word);
-	      return (EXECUTION_FAILURE);
-	    }
-	}
-      else if (word[0] == '-' && word[1] == 's' && ISALPHA (word[2]))
-	{
-	  sigspec = word + 2;
-	  goto use_sigspec;
-	}
-      else if (word[0] == '-' && word[1] == 'n' && ISDIGIT (word[2]))
-	{
-	  sigspec = word + 2;
-	  goto use_sigspec;
-	}
-      else if (ISOPTION (word, '-'))
-	{
-	  list = list->next;
-	  break;
-	}
-      else if (ISOPTION (word, '?'))
-	{
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-      /* If this is a signal specification then process it.  We only process
-	 the first one seen; other arguments may signify process groups (e.g,
-	 -num == process group num). */
-      else if (*word == '-' && saw_signal == 0)
-	{
-	  sigspec = word + 1;
-	  sig = decode_signal (sigspec, dflags);
-	  saw_signal++;
-	  list = list->next;
-	}
-      else
-	break;
-    }
-
-  if (listing)
-    return (display_signal_list (list, 0));
-
-  /* OK, we are killing processes. */
-  if (sig == NO_SIG)
-    {
-      sh_invalidsig (sigspec);
-      return (EXECUTION_FAILURE);
-    }
-
-  if (list == 0)
-    {
-      builtin_usage ();
-      return (EX_USAGE);
-    }
-
-  while (list)
-    {
-      word = list->word->word;
-
-      if (*word == '-')
-	word++;
-
-      /* Use the entire argument in case of minus sign presence. */
-      if (*word && legal_number (list->word->word, &pid_value) && (pid_value == (pid_t)pid_value))
-	{
-	  pid = (pid_t) pid_value;
-
-	  if (kill_pid (pid, sig, pid < -1) < 0)
-	    {
-	      if (errno == EINVAL)
-		sh_invalidsig (sigspec);
-	      else
-		kill_error (pid, errno);
-	      CONTINUE_OR_FAIL;
-	    }
-	  else
-	    any_succeeded++;
-	}
-#if defined (JOB_CONTROL)
-      else if (*list->word->word && *list->word->word != '%')
-	{
-	  builtin_error (_("%s: arguments must be process or job IDs"), list->word->word);
-	  CONTINUE_OR_FAIL;
-	}
-      else if (*word)
-	/* Posix.2 says you can kill without job control active (4.32.4) */
-	{			/* Must be a job spec.  Check it out. */
-	  int job;
-	  sigset_t set, oset;
-	  JOB *j;
-
-	  BLOCK_CHILD (set, oset);
-	  job = get_job_spec (list);
-
-	  if (INVALID_JOB (job))
-	    {
-	      if (job != DUP_JOB)
-		sh_badjob (list->word->word);
-	      UNBLOCK_CHILD (oset);
-	      CONTINUE_OR_FAIL;
-	    }
-
-	  j = get_job_by_jid (job);
-	  /* Job spec used.  Kill the process group. If the job was started
-	     without job control, then its pgrp == shell_pgrp, so we have
-	     to be careful.  We take the pid of the first job in the pipeline
-	     in that case. */
-	  pid = IS_JOBCONTROL (job) ? j->pgrp : j->pipe->pid;
-
-	  UNBLOCK_CHILD (oset);
-
-	  if (kill_pid (pid, sig, 1) < 0)
-	    {
-	      if (errno == EINVAL)
-		sh_invalidsig (sigspec);
-	      else
-		kill_error (pid, errno);
-	      CONTINUE_OR_FAIL;
-	    }
-	  else
-	    any_succeeded++;
-	}
-#endif /* !JOB_CONTROL */
-      else
-	{
-	  sh_badpid (list->word->word);
-	  CONTINUE_OR_FAIL;
-	}
-    continue_killing:
-      list = list->next;
-    }
-
-  return (any_succeeded ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-}
-
-static void
-kill_error (pid, e)
-     pid_t pid;
-     int e;
-{
-  char *x;
-
-  x = strerror (e);
-  if (x == 0)
-    x = _("Unknown error");
-  builtin_error ("(%ld) - %s", (long)pid, x);
-}
diff --git a/third_party/bash/builtins_let.c b/third_party/bash/builtins_let.c
deleted file mode 100644
index ae2971270..000000000
--- a/third_party/bash/builtins_let.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/* let.c, created from let.def. */
-#line 66 "./let.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "common.h"
-
-/* Arithmetic LET function. */
-int
-let_builtin (list)
-     WORD_LIST *list;
-{
-  intmax_t ret;
-  int expok;
-
-  CHECK_HELPOPT (list);
-
-  /* Skip over leading `--' argument. */
-  if (list && list->word && ISOPTION (list->word->word, '-'))
-    list = list->next;
-
-  if (list == 0)
-    {
-      builtin_error (_("expression expected"));
-      return (EXECUTION_FAILURE);
-    }
-
-  for (; list; list = list->next)
-    {
-      ret = evalexp (list->word->word, EXP_EXPANDED, &expok);
-      if (expok == 0)
-	return (EXECUTION_FAILURE);
-    }
-
-  return ((ret == 0) ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
-}
-
-#ifdef INCLUDE_UNUSED
-int
-exp_builtin (list)
-     WORD_LIST *list;
-{
-  char *exp;
-  intmax_t ret;
-  int expok;
-
-  if (list == 0)
-    {
-      builtin_error (_("expression expected"));
-      return (EXECUTION_FAILURE);
-    }
-
-  exp = string_list (list);
-  ret = evalexp (exp, EXP_EXPANDED, &expok);
-  (void)free (exp);
-  return (((ret == 0) || (expok == 0)) ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
-}
-#endif
diff --git a/third_party/bash/builtins_mapfile.c b/third_party/bash/builtins_mapfile.c
deleted file mode 100644
index 2ceafffea..000000000
--- a/third_party/bash/builtins_mapfile.c
+++ /dev/null
@@ -1,304 +0,0 @@
-/* mapfile.c, created from mapfile.def. */
-#line 23 "./mapfile.def"
-
-#line 59 "./mapfile.def"
-
-#line 67 "./mapfile.def"
-
-#include "config.h"
-
-#include "builtins.h"
-#include "bashtypes.h"
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include <stdio.h>
-#include <errno.h>
-
-#include "bashintl.h"
-#include "shell.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#if defined (ARRAY_VARS)
-
-static int run_callback PARAMS((const char *, unsigned int, const char *));
-
-#define DEFAULT_ARRAY_NAME	"MAPFILE"
-#define DEFAULT_VARIABLE_NAME	"MAPLINE"	/* not used right now */
-
-/* The value specifying how frequently `mapfile'  calls the callback. */
-#define DEFAULT_QUANTUM 5000
-
-/* Values for FLAGS */
-#define MAPF_CLEARARRAY	0x01
-#define MAPF_CHOP	0x02
-
-static int delim;
-
-static int
-run_callback (callback, curindex, curline)
-     const char *callback;
-     unsigned int curindex;
-     const char *curline;
-{
-  unsigned int execlen;
-  char  *execstr, *qline;
-  int flags;
-
-  qline = sh_single_quote (curline);
-  execlen = strlen (callback) + strlen (qline) + 10;
-  /* 1 for each space between %s and %d,
-     another 1 for the last nul char for C string. */
-  execlen += 3;
-  execstr = xmalloc (execlen);
-
-  flags = SEVAL_NOHIST;
-#if 0
-  if (interactive)
-    flags |= SEVAL_INTERACT;
-#endif
-  snprintf (execstr, execlen, "%s %d %s", callback, curindex, qline);
-  free (qline);
-  return evalstring (execstr, NULL, flags);
-}
-
-static void
-do_chop(line, delim)
-     char *line;
-     unsigned char delim;
-{
-  int length;
-
-  length = strlen (line);
-  if (length && (unsigned char)line[length-1] == delim) 
-    line[length-1] = '\0';
-}
-
-static int
-mapfile (fd, line_count_goal, origin, nskip, callback_quantum, callback, array_name, delim, flags)
-     int fd;
-     long line_count_goal, origin, nskip, callback_quantum;
-     char *callback, *array_name;
-     int delim;
-     int flags;
-{
-  char *line;
-  size_t line_length;
-  unsigned int array_index, line_count;
-  SHELL_VAR *entry;
-  struct stat sb;
-  int unbuffered_read;
-  
-  line = NULL;
-  line_length = 0;
-  unbuffered_read = 0;
-
-  /* The following check should be done before reading any lines.  Doing it
-     here allows us to call bind_array_element instead of bind_array_variable
-     and skip the variable lookup on every call. */
-  entry = builtin_find_indexed_array (array_name, flags & MAPF_CLEARARRAY);
-  if (entry == 0)
-    return EXECUTION_FAILURE;
-
-#ifndef __CYGWIN__
-  /* If the delimiter is a newline, turn on unbuffered reads for pipes
-     (terminals are ok). If the delimiter is not a newline, unbuffered reads
-     for every file descriptor that's not a regular file. */
-  if (delim == '\n')
-    unbuffered_read = (lseek (fd, 0L, SEEK_CUR) < 0) && (errno == ESPIPE);
-  else
-    unbuffered_read = (fstat (fd, &sb) != 0) || (S_ISREG (sb.st_mode) == 0);
-#else
-  unbuffered_read = 1;
-#endif
-
-  zreset ();
-
-  /* Skip any lines at beginning of file? */
-  for (line_count = 0; line_count < nskip; line_count++)
-    if (zgetline (fd, &line, &line_length, delim, unbuffered_read) < 0)
-      break;
-
-  line = 0;
-  line_length = 0;    
-
-  /* Reset the buffer for bash own stream */
-  for (array_index = origin, line_count = 1; 
- 	zgetline (fd, &line, &line_length, delim, unbuffered_read) != -1;
-	array_index++) 
-    {
-      /* Remove trailing newlines? */
-      if (flags & MAPF_CHOP)
-	do_chop (line, delim);
-	  
-      /* Has a callback been registered and if so is it time to call it? */
-      if (callback && line_count && (line_count % callback_quantum) == 0) 
-	{
-	  /* Reset the buffer for bash own stream. */
-	  if (unbuffered_read == 0)
-	    zsyncfd (fd);
-
-	  run_callback (callback, array_index, line);
-	}
-
-      /* XXX - bad things can happen if the callback modifies ENTRY, e.g.,
-	 unsetting it or changing it to a non-indexed-array type. */
-      bind_array_element (entry, array_index, line, 0);
-
-      /* Have we exceeded # of lines to store? */
-      line_count++;
-      if (line_count_goal != 0 && line_count > line_count_goal) 
-	break;
-    }
-
-  free (line);
-
-  if (unbuffered_read == 0)
-    zsyncfd (fd);
-
-  return EXECUTION_SUCCESS;
-}
-
-int
-mapfile_builtin (list)
-     WORD_LIST *list;
-{
-  int opt, code, fd, flags;
-  intmax_t intval;
-  long lines, origin, nskip, callback_quantum;
-  char *array_name, *callback;
-
-  fd = 0;
-  lines = origin = nskip = 0;
-  flags = MAPF_CLEARARRAY;
-  callback_quantum = DEFAULT_QUANTUM;
-  callback = 0;
-  delim = '\n';
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "d:u:n:O:tC:c:s:")) != -1)
-    {
-      switch (opt)
-	{
-	case 'd':
-	  delim = *list_optarg;
-	  break;
-	case 'u':
-	  code = legal_number (list_optarg, &intval);
-	  if (code == 0 || intval < 0 || intval != (int)intval)
-	    {
-	      builtin_error (_("%s: invalid file descriptor specification"), list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    fd = intval;
-
-	  if (sh_validfd (fd) == 0)
-	    {
-	      builtin_error (_("%d: invalid file descriptor: %s"), fd, strerror (errno));
-	      return (EXECUTION_FAILURE);
-	    }
-	  break;	  
-
-	case 'n':
-	  code = legal_number (list_optarg, &intval);
-	  if (code == 0 || intval < 0 || intval != (unsigned)intval)
-	    {
-	      builtin_error (_("%s: invalid line count"), list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    lines = intval;
-	  break;
-
-	case 'O':
-	  code = legal_number (list_optarg, &intval);
-	  if (code == 0 || intval < 0 || intval != (unsigned)intval)
-	    {
-	      builtin_error (_("%s: invalid array origin"), list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    origin = intval;
-	  flags &= ~MAPF_CLEARARRAY;
-	  break;
-	case 't':
-	  flags |= MAPF_CHOP;
-	  break;
-	case 'C':
-	  callback = list_optarg;
-	  break;
-	case 'c':
-	  code = legal_number (list_optarg, &intval);
-	  if (code == 0 || intval <= 0 || intval != (unsigned)intval)
-	    {
-	      builtin_error (_("%s: invalid callback quantum"), list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    callback_quantum = intval;
-	  break;
-	case 's':
-	  code = legal_number (list_optarg, &intval);
-	  if (code == 0 || intval < 0 || intval != (unsigned)intval)
-	    {
-	      builtin_error (_("%s: invalid line count"), list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    nskip = intval;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  if (list == 0) 
-    array_name = DEFAULT_ARRAY_NAME;
-  else if (list->word == 0 || list->word->word == 0)
-    {
-      builtin_error ("internal error: getting variable name");
-      return (EXECUTION_FAILURE);
-    }
-  else if (list->word->word[0] == '\0')
-    {
-      builtin_error (_("empty array variable name"));
-      return (EX_USAGE);
-    } 
-  else
-    array_name = list->word->word;
-  
-  if (legal_identifier (array_name) == 0)
-    {
-      sh_invalidid (array_name);
-      return (EXECUTION_FAILURE);
-    }
-
-  return mapfile (fd, lines, origin, nskip, callback_quantum, callback, array_name, delim, flags);
-}
-
-#else
-
-int
-mapfile_builtin (list)
-     WORD_LIST *list;
-{
-  builtin_error (_("array variable support required"));
-  return (EXECUTION_FAILURE);
-}
-
-#endif  /* ARRAY_VARS */
diff --git a/third_party/bash/builtins_printf.c b/third_party/bash/builtins_printf.c
deleted file mode 100644
index 2ec4e1ba8..000000000
--- a/third_party/bash/builtins_printf.c
+++ /dev/null
@@ -1,1303 +0,0 @@
-/* printf.c, created from printf.def. */
-#line 22 "./printf.def"
-
-#line 57 "./printf.def"
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#include <errno.h>
-#if defined (HAVE_LIMITS_H)
-#  include <limits.h>
-#else
-   /* Assume 32-bit ints. */
-#  define INT_MAX		2147483647
-#  define INT_MIN		(-2147483647-1)
-#endif
-
-#if defined (PREFER_STDARG)
-#  include <stdarg.h>
-#else
-#  include <varargs.h>
-#endif
-
-#include <stdio.h>
-#include "chartypes.h"
-
-#ifdef HAVE_INTTYPES_H
-#  include <inttypes.h>
-#endif
-
-#include "posixtime.h"
-#include "bashansi.h"
-#include "bashintl.h"
-
-#define NEED_STRFTIME_DECL
-
-#include "shell.h"
-#include "shmbutil.h"
-#include "stdc.h"
-#include "bashgetopt.h"
-#include "common.h"
-
-#if defined (PRI_MACROS_BROKEN)
-#  undef PRIdMAX
-#endif
-
-#if !defined (PRIdMAX)
-#  if HAVE_LONG_LONG
-#    define PRIdMAX	"lld"
-#  else
-#    define PRIdMAX	"ld"
-#  endif
-#endif
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#define PC(c) \
-  do { \
-    char b[2]; \
-    tw++; \
-    b[0] = c; b[1] = '\0'; \
-    if (vflag) \
-      vbadd (b, 1); \
-    else \
-      putchar (c); \
-    QUIT; \
-  } while (0)
-
-#define PF(f, func) \
-  do { \
-    int nw; \
-    clearerr (stdout); \
-    if (have_fieldwidth && have_precision) \
-      nw = vflag ? vbprintf (f, fieldwidth, precision, func) : printf (f, fieldwidth, precision, func); \
-    else if (have_fieldwidth) \
-      nw = vflag ? vbprintf (f, fieldwidth, func) : printf (f, fieldwidth, func); \
-    else if (have_precision) \
-      nw = vflag ? vbprintf (f, precision, func) : printf (f, precision, func); \
-    else \
-      nw = vflag ? vbprintf (f, func) : printf (f, func); \
-    tw += nw; \
-    QUIT; \
-    if (ferror (stdout)) \
-      { \
-	sh_wrerror (); \
-	clearerr (stdout); \
-	return (EXECUTION_FAILURE); \
-      } \
-  } while (0)
-
-/* We free the buffer used by mklong() if it's `too big'. */
-#define PRETURN(value) \
-  do \
-    { \
-      QUIT; \
-      if (vflag) \
-	{ \
-	  SHELL_VAR *v; \
-	  v = builtin_bind_variable  (vname, vbuf, bindflags); \
-	  stupidly_hack_special_variables (vname); \
-	  if (v == 0 || readonly_p (v) || noassign_p (v)) \
-	    return (EXECUTION_FAILURE); \
-	} \
-      if (conv_bufsize > 4096 ) \
-	{ \
-	  free (conv_buf); \
-	  conv_bufsize = 0; \
-	  conv_buf = 0; \
-	} \
-      if (vbsize > 4096) \
-	{ \
-	  free (vbuf); \
-	  vbsize = 0; \
-	  vbuf = 0; \
-	} \
-      else if (vbuf) \
-	vbuf[0] = 0; \
-      if (ferror (stdout) == 0) \
-	fflush (stdout); \
-      QUIT; \
-      if (ferror (stdout)) \
-	{ \
-	  sh_wrerror (); \
-	  clearerr (stdout); \
-	  return (EXECUTION_FAILURE); \
-	} \
-      return (value); \
-    } \
-  while (0)
-
-#define SKIP1 "#'-+ 0"
-#define LENMODS "hjlLtz"
-
-#ifndef TIMELEN_MAX
-#  define TIMELEN_MAX 128
-#endif
-
-extern time_t shell_start_time;
-
-#if !HAVE_ASPRINTF
-extern int asprintf PARAMS((char **, const char *, ...)) __attribute__((__format__ (printf, 2, 3)));
-#endif
-
-#if !HAVE_VSNPRINTF
-extern int vsnprintf PARAMS((char *, size_t, const char *, va_list)) __attribute__((__format__ (printf, 3, 0)));
-#endif
-
-static void printf_erange PARAMS((char *));
-static int printstr PARAMS((char *, char *, int, int, int));
-static int tescape PARAMS((char *, char *, int *, int *));
-static char *bexpand PARAMS((char *, int, int *, int *));
-static char *vbadd PARAMS((char *, int));
-static int vbprintf PARAMS((const char *, ...)) __attribute__((__format__ (printf, 1, 2)));
-static char *mklong PARAMS((char *, char *, size_t));
-static int getchr PARAMS((void));
-static char *getstr PARAMS((void));
-static int  getint PARAMS((void));
-static intmax_t getintmax PARAMS((void));
-static uintmax_t getuintmax PARAMS((void));
-
-#if defined (HAVE_LONG_DOUBLE) && HAVE_DECL_STRTOLD && !defined(STRTOLD_BROKEN)
-typedef long double floatmax_t;
-#  define USE_LONG_DOUBLE 1
-#  define FLOATMAX_CONV	"L"
-#  define strtofltmax	strtold
-#else
-typedef double floatmax_t;
-#  define USE_LONG_DOUBLE 0
-#  define FLOATMAX_CONV	""
-#  define strtofltmax	strtod
-#endif
-static double getdouble PARAMS((void));
-static floatmax_t getfloatmax PARAMS((void));
-
-static intmax_t asciicode PARAMS((void));
-
-static WORD_LIST *garglist, *orig_arglist;
-static int retval;
-static int conversion_error;
-
-/* printf -v var support */
-static int vflag = 0;
-static int bindflags = 0;
-static char *vbuf, *vname;
-static size_t vbsize;
-static int vblen;
-
-static intmax_t tw;
-
-static char *conv_buf;
-static size_t conv_bufsize;
-
-int
-printf_builtin (list)
-     WORD_LIST *list;
-{
-  int ch, fieldwidth, precision;
-  int have_fieldwidth, have_precision, use_Lmod, altform;
-  char convch, thisch, nextch, *format, *modstart, *precstart, *fmt, *start;
-#if defined (HANDLE_MULTIBYTE)
-  char mbch[25];		/* 25 > MB_LEN_MAX, plus can handle 4-byte UTF-8 and large Unicode characters*/
-  int mbind, mblen;
-#endif
-#if defined (ARRAY_VARS)
-  int arrayflags;
-#endif
-
-  conversion_error = 0;
-  vflag = 0;
-
-  reset_internal_getopt ();
-  while ((ch = internal_getopt (list, "v:")) != -1)
-    {
-      switch (ch)
-	{
-	case 'v':
-	  vname = list_optarg;
-	  bindflags = 0;
-#if defined (ARRAY_VARS)
-	  SET_VFLAGS (list_optflags, arrayflags, bindflags);
-	  retval = legal_identifier (vname) || valid_array_reference (vname, arrayflags);
-#else
-	  retval = legal_identifier (vname);
-#endif
-	  if (retval)
-	    {
-	      vflag = 1;
-	      if (vbsize == 0)
-		vbuf = xmalloc (vbsize = 16);
-	      vblen = 0;
-	      if (vbuf)
-		vbuf[0] = 0;
-	    }
-	  else
-	    {
-	      sh_invalidid (vname);
-	      return (EX_USAGE);
-	    }
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;	/* skip over possible `--' */
-
-  if (list == 0)
-    {
-      builtin_usage ();
-      return (EX_USAGE);
-    }
-
-  /* Allow printf -v var "" to act like var="" */
-  if (vflag && list->word->word && list->word->word[0] == '\0')
-    {
-      SHELL_VAR *v;
-      v = builtin_bind_variable (vname, "", 0);
-      stupidly_hack_special_variables (vname);
-      return ((v == 0 || readonly_p (v) || noassign_p (v)) ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
-    }
-
-  if (list->word->word == 0 || list->word->word[0] == '\0')
-    return (EXECUTION_SUCCESS);
-
-  format = list->word->word;
-  tw = 0;
-  retval = EXECUTION_SUCCESS;
-
-  garglist = orig_arglist = list->next;
-
-  /* If the format string is empty after preprocessing, return immediately. */
-  if (format == 0 || *format == 0)
-    return (EXECUTION_SUCCESS);
-
-  /* Basic algorithm is to scan the format string for conversion
-     specifications -- once one is found, find out if the field
-     width or precision is a '*'; if it is, gather up value.  Note,
-     format strings are reused as necessary to use up the provided
-     arguments, arguments of zero/null string are provided to use
-     up the format string. */
-  do
-    {
-      tw = 0;
-      /* find next format specification */
-      for (fmt = format; *fmt; fmt++)
-	{
-	  precision = fieldwidth = 0;
-	  have_fieldwidth = have_precision = altform = 0;
-	  precstart = 0;
-
-	  if (*fmt == '\\')
-	    {
-	      fmt++;
-	      /* A NULL third argument to tescape means to bypass the
-		 special processing for arguments to %b. */
-#if defined (HANDLE_MULTIBYTE)
-	      /* Accommodate possible use of \u or \U, which can result in
-		 multibyte characters */
-	      memset (mbch, '\0', sizeof (mbch));
-	      fmt += tescape (fmt, mbch, &mblen, (int *)NULL);
-	      for (mbind = 0; mbind < mblen; mbind++)
-	        PC (mbch[mbind]);
-#else
-	      fmt += tescape (fmt, &nextch, (int *)NULL, (int *)NULL);
-	      PC (nextch);
-#endif
-	      fmt--;	/* for loop will increment it for us again */
-	      continue;
-	    }
-
-	  if (*fmt != '%')
-	    {
-	      PC (*fmt);
-	      continue;
-	    }
-
-	  /* ASSERT(*fmt == '%') */
-	  start = fmt++;
-
-	  if (*fmt == '%')		/* %% prints a % */
-	    {
-	      PC ('%');
-	      continue;
-	    }
-
-	  /* Found format specification, skip to field width. We check for
-	     alternate form for possible later use. */
-	  for (; *fmt && strchr(SKIP1, *fmt); ++fmt)
-	    if (*fmt == '#')
-	      altform++;
-
-	  /* Skip optional field width. */
-	  if (*fmt == '*')
-	    {
-	      fmt++;
-	      have_fieldwidth = 1;
-	      fieldwidth = getint ();
-	    }
-	  else
-	    while (DIGIT (*fmt))
-	      fmt++;
-
-	  /* Skip optional '.' and precision */
-	  if (*fmt == '.')
-	    {
-	      ++fmt;
-	      if (*fmt == '*')
-		{
-		  fmt++;
-		  have_precision = 1;
-		  precision = getint ();
-		}
-	      else
-		{
-		  /* Negative precisions are allowed but treated as if the
-		     precision were missing; I would like to allow a leading
-		     `+' in the precision number as an extension, but lots
-		     of asprintf/fprintf implementations get this wrong. */
-#if 0
-		  if (*fmt == '-' || *fmt == '+')
-#else
-		  if (*fmt == '-')
-#endif
-		    fmt++;
-		  if (DIGIT (*fmt))
-		    precstart = fmt;
-		  while (DIGIT (*fmt))
-		    fmt++;
-		}
-	    }
-
-	  /* skip possible format modifiers */
-	  modstart = fmt;
-	  use_Lmod = 0;
-	  while (*fmt && strchr (LENMODS, *fmt))
-	    {
-	      use_Lmod |= USE_LONG_DOUBLE && *fmt == 'L';
-	      fmt++;
-	    }
-	    
-	  if (*fmt == 0)
-	    {
-	      builtin_error (_("`%s': missing format character"), start);
-	      PRETURN (EXECUTION_FAILURE);
-	    }
-
-	  convch = *fmt;
-	  thisch = modstart[0];
-	  nextch = modstart[1];
-	  modstart[0] = convch;
-	  modstart[1] = '\0';
-
-	  QUIT;
-	  switch(convch)
-	    {
-	    case 'c':
-	      {
-		char p;
-
-		p = getchr ();
-		PF(start, p);
-		break;
-	      }
-
-	    case 's':
-	      {
-		char *p;
-
-		p = getstr ();
-		PF(start, p);
-		break;
-	      }
-
-	    case '(':
-	      {
-		char *timefmt, timebuf[TIMELEN_MAX], *t;
-		int n;
-		intmax_t arg;
-		time_t secs;
-		struct tm *tm;
-
-		modstart[1] = nextch;	/* restore char after left paren */
-		timefmt = xmalloc (strlen (fmt) + 3);
-		fmt++;	/* skip over left paren */
-		for (t = timefmt, n = 1; *fmt; )
-		  {
-		    if (*fmt == '(')
-		      n++;
-		    else if (*fmt == ')')
-		      n--;
-		    if (n == 0)
-		      break;
-		    *t++ = *fmt++;
-		  }
-		*t = '\0';
-		if (*++fmt != 'T')
-		  {
-		    builtin_warning (_("`%c': invalid time format specification"), *fmt);
-		    fmt = start;
-		    free (timefmt);
-		    PC (*fmt);
-		    continue;
-		  }
-		if (timefmt[0] == '\0')
-		  {
-		    timefmt[0] = '%';
-		    timefmt[1] = 'X';	/* locale-specific current time - should we use `+'? */
-		    timefmt[2] = '\0';
-		  }
-		/* argument is seconds since the epoch with special -1 and -2 */
-		/* default argument is equivalent to -1; special case */
-		arg = garglist ? getintmax () : -1;
-		if (arg == -1)
-		  secs = NOW;		/* roughly date +%s */
-		else if (arg == -2)
-		  secs = shell_start_time;	/* roughly $SECONDS */
-		else
-		  secs = arg;
-#if defined (HAVE_TZSET)
-		sv_tz ("TZ");		/* XXX -- just make sure */
-#endif
-		tm = localtime (&secs);
-		if (tm == 0)
-		  {
-		    secs = 0;
-		    tm = localtime (&secs);
-		  }
-		n = tm ? strftime (timebuf, sizeof (timebuf), timefmt, tm) : 0;
-		free (timefmt);
-		if (n == 0)
-		  timebuf[0] = '\0';
-		else
-		  timebuf[sizeof(timebuf) - 1] = '\0';
-		/* convert to %s format that preserves fieldwidth and precision */
-		modstart[0] = 's';
-		modstart[1] = '\0';
-		n = printstr (start, timebuf, strlen (timebuf), fieldwidth, precision);	/* XXX - %s for now */
-		if (n < 0)
-		  {
-		    if (ferror (stdout) == 0)
-		      {
-			sh_wrerror ();
-			clearerr (stdout);
-		      }
-		    PRETURN (EXECUTION_FAILURE);
-		  }
-		break;
-	      }
-
-	    case 'n':
-	      {
-		char *var;
-
-		var = getstr ();
-		if (var && *var)
-		  {
-		    if (legal_identifier (var))
-		      bind_var_to_int (var, tw, 0);
-		    else
-		      {
-			sh_invalidid (var);
-			PRETURN (EXECUTION_FAILURE);
-		      }
-		  }
-		break;
-	      }
-
-	    case 'b':		/* expand escapes in argument */
-	      {
-		char *p, *xp;
-		int rlen, r;
-
-		p = getstr ();
-		ch = rlen = r = 0;
-		xp = bexpand (p, strlen (p), &ch, &rlen);
-
-		if (xp)
-		  {
-		    /* Have to use printstr because of possible NUL bytes
-		       in XP -- printf does not handle that well. */
-		    r = printstr (start, xp, rlen, fieldwidth, precision);
-		    if (r < 0)
-		      {
-			if (ferror (stdout) == 0)
-			  {
-		            sh_wrerror ();
-			    clearerr (stdout);
-			  }
-		        retval = EXECUTION_FAILURE;
-		      }
-		    free (xp);
-		  }
-
-		if (ch || r < 0)
-		  PRETURN (retval);
-		break;
-	      }
-
-	    case 'q':		/* print with shell quoting */
-	    case 'Q':
-	      {
-		char *p, *xp;
-		int r, mpr;
-		size_t slen;
-
-		r = 0;
-		p = getstr ();
-		/* Decode precision and apply it to the unquoted string. */
-		if (convch == 'Q' && precstart)
-		  {
-		    mpr = *precstart++ - '0';
-		    while (DIGIT (*precstart))
-		      mpr = (mpr * 10) + (*precstart++ - '0');
-		    /* Error if precision > INT_MAX here? */
-		    precision = (mpr < 0 || mpr > INT_MAX) ? INT_MAX : mpr;
-		    slen = strlen (p);
-		    /* printf precision works in bytes. */
-		    if (precision < slen)
-		      p[precision] = '\0';
-		  }
-		if (p && *p == 0)	/* XXX - getstr never returns null */
-		  xp = savestring ("''");
-		else if (ansic_shouldquote (p))
-		  xp = ansic_quote (p, 0, (int *)0);
-		else
-		  xp = sh_backslash_quote (p, 0, 3);
-		if (xp)
-		  {
-		    if (convch == 'Q')
-		      {
-			slen = strlen (xp);
-			if (slen > precision)
-			  precision = slen;
-		      }		    
-		    /* Use printstr to get fieldwidth and precision right. */
-		    r = printstr (start, xp, strlen (xp), fieldwidth, precision);
-		    if (r < 0)
-		      {
-			sh_wrerror ();
-			clearerr (stdout);
-		      }
-		    free (xp);
-		  }
-
-		if (r < 0)
-		  PRETURN (EXECUTION_FAILURE);
-		break;
-	      }
-
-	    case 'd':
-	    case 'i':
-	      {
-		char *f;
-		long p;
-		intmax_t pp;
-
-		p = pp = getintmax ();
-		if (p != pp)
-		  {
-		    f = mklong (start, PRIdMAX, sizeof (PRIdMAX) - 2);
-		    PF (f, pp);
-		  }
-		else
-		  {
-		    /* Optimize the common case where the integer fits
-		       in "long".  This also works around some long
-		       long and/or intmax_t library bugs in the common
-		       case, e.g. glibc 2.2 x86.  */
-		    f = mklong (start, "l", 1);
-		    PF (f, p);
-		  }
-		break;
-	      }
-
-	    case 'o':
-	    case 'u':
-	    case 'x':
-	    case 'X':
-	      {
-		char *f;
-		unsigned long p;
-		uintmax_t pp;
-
-		p = pp = getuintmax ();
-		if (p != pp)
-		  {
-		    f = mklong (start, PRIdMAX, sizeof (PRIdMAX) - 2);
-		    PF (f, pp);
-		  }
-		else
-		  {
-		    f = mklong (start, "l", 1);
-		    PF (f, p);
-		  }
-		break;
-	      }
-
-	    case 'e':
-	    case 'E':
-	    case 'f':
-	    case 'F':
-	    case 'g':
-	    case 'G':
-#if defined (HAVE_PRINTF_A_FORMAT)
-	    case 'a':
-	    case 'A':
-#endif
-	      {
-		char *f;
-
-	      	if (use_Lmod || posixly_correct == 0)
-		  {
-		    floatmax_t p;
-
-		    p = getfloatmax ();
-		    f = mklong (start, "L", 1);
-		    PF (f, p);
-		  }
-		else		/* posixly_correct */
-		  {
-		    double p;
-
-		    p = getdouble ();
-		    f = mklong (start, "", 0);
-		    PF (f, p);
-		  }
-
-		break;
-	      }
-
-	    /* We don't output unrecognized format characters; we print an
-	       error message and return a failure exit status. */
-	    default:
-	      builtin_error (_("`%c': invalid format character"), convch);
-	      PRETURN (EXECUTION_FAILURE);
-	    }
-
-	  modstart[0] = thisch;
-	  modstart[1] = nextch;
-	}
-
-      if (ferror (stdout))
-	{
-	  /* PRETURN will print error message. */
-	  PRETURN (EXECUTION_FAILURE);
-	}
-    }
-  while (garglist && garglist != list->next);
-
-  if (conversion_error)
-    retval = EXECUTION_FAILURE;
-
-  PRETURN (retval);
-}
-
-static void
-printf_erange (s)
-     char *s;
-{
-  builtin_error (_("warning: %s: %s"), s, strerror(ERANGE));
-}
-
-/* We duplicate a lot of what printf(3) does here. */
-static int
-printstr (fmt, string, len, fieldwidth, precision)
-     char *fmt;			/* format */
-     char *string;		/* expanded string argument */
-     int len;			/* length of expanded string */
-     int fieldwidth;		/* argument for width of `*' */
-     int precision;		/* argument for precision of `*' */
-{
-#if 0
-  char *s;
-#endif
-  int padlen, nc, ljust, i;
-  int fw, pr;			/* fieldwidth and precision */
-  intmax_t mfw, mpr;
-
-  if (string == 0)
-    string = "";
-
-#if 0
-  s = fmt;
-#endif
-  if (*fmt == '%')
-    fmt++;
-
-  ljust = fw = 0;
-  pr = -1;
-  mfw = 0;
-  mpr = -1;
-
-  /* skip flags */
-  while (strchr (SKIP1, *fmt))
-    {
-      if (*fmt == '-')
-	ljust = 1;
-      fmt++;
-    }
-
-  /* get fieldwidth, if present.  rely on caller to clamp fieldwidth at INT_MAX */
-  if (*fmt == '*')
-    {
-      fmt++;
-      fw = fieldwidth;
-      if (fw < 0)
-	{
-	  fw = -fw;
-	  ljust = 1;
-	}
-    }
-  else if (DIGIT (*fmt))
-    {
-      mfw = *fmt++ - '0';
-      while (DIGIT (*fmt))
-	mfw = (mfw * 10) + (*fmt++ - '0');
-      /* Error if fieldwidth > INT_MAX here? */
-      fw = (mfw < 0 || mfw > INT_MAX) ? INT_MAX : mfw;
-    }
-
-  /* get precision, if present. doesn't handle negative precisions */
-  if (*fmt == '.')
-    {
-      fmt++;
-      if (*fmt == '*')
-	{
-	  fmt++;
-	  pr = precision;
-	}
-      else if (DIGIT (*fmt))
-	{
-	  mpr = *fmt++ - '0';
-	  while (DIGIT (*fmt))
-	    mpr = (mpr * 10) + (*fmt++ - '0');
-	  /* Error if precision > INT_MAX here? */
-	  pr = (mpr < 0 || mpr > INT_MAX) ? INT_MAX : mpr;
-	  if (pr < precision && precision < INT_MAX)
-	    pr = precision;		/* XXX */
-	}
-      else
-	pr = 0;		/* "a null digit string is treated as zero" */
-    }
-
-#if 0
-  /* If we remove this, get rid of `s'. */
-  if (*fmt != 'b' && *fmt != 'q')
-    {
-      internal_error (_("format parsing problem: %s"), s);
-      fw = pr = 0;
-    }
-#endif
-
-  /* chars from string to print */
-  nc = (pr >= 0 && pr <= len) ? pr : len;
-
-  padlen = fw - nc;
-  if (padlen < 0)
-    padlen = 0;
-  if (ljust)
-    padlen = -padlen;
-
-  /* leading pad characters */
-  for (; padlen > 0; padlen--)
-    PC (' ');
-
-  /* output NC characters from STRING */
-  for (i = 0; i < nc; i++)
-    PC (string[i]);
-
-  /* output any necessary trailing padding */
-  for (; padlen < 0; padlen++)
-    PC (' ');
-
-  return (ferror (stdout) ? -1 : 0);
-}
-  
-/* Convert STRING by expanding the escape sequences specified by the
-   POSIX standard for printf's `%b' format string.  If SAWC is non-null,
-   perform the processing appropriate for %b arguments.  In particular,
-   recognize `\c' and use that as a string terminator.  If we see \c, set
-   *SAWC to 1 before returning.  LEN is the length of STRING. */
-
-/* Translate a single backslash-escape sequence starting at ESTART (the
-   character after the backslash) and return the number of characters
-   consumed by the sequence.  CP is the place to return the translated
-   value.  *SAWC is set to 1 if the escape sequence was \c, since that means
-   to short-circuit the rest of the processing.  If SAWC is null, we don't
-   do the \c short-circuiting, and \c is treated as an unrecognized escape
-   sequence; we also bypass the other processing specific to %b arguments.  */
-static int
-tescape (estart, cp, lenp, sawc)
-     char *estart;
-     char *cp;
-     int *lenp, *sawc;
-{
-  register char *p;
-  int temp, c, evalue;
-  unsigned long uvalue;
-
-  p = estart;
-  if (lenp)
-    *lenp = 1;
-
-  switch (c = *p++)
-    {
-#if defined (__STDC__)
-      case 'a': *cp = '\a'; break;
-#else
-      case 'a': *cp = '\007'; break;
-#endif
-
-      case 'b': *cp = '\b'; break;
-
-      case 'e':
-      case 'E': *cp = '\033'; break;	/* ESC -- non-ANSI */
-
-      case 'f': *cp = '\f'; break;
-
-      case 'n': *cp = '\n'; break;
-
-      case 'r': *cp = '\r'; break;
-
-      case 't': *cp = '\t'; break;
-
-      case 'v': *cp = '\v'; break;
-
-      /* The octal escape sequences are `\0' followed by up to three octal
-	 digits (if SAWC), or `\' followed by up to three octal digits (if
-	 !SAWC).  As an extension, we allow the latter form even if SAWC. */
-      case '0': case '1': case '2': case '3':
-      case '4': case '5': case '6': case '7':
-	evalue = OCTVALUE (c);
-	for (temp = 2 + (!evalue && !!sawc); ISOCTAL (*p) && temp--; p++)
-	  evalue = (evalue * 8) + OCTVALUE (*p);
-	*cp = evalue & 0xFF;
-	break;
-
-      /* And, as another extension, we allow \xNN, where each N is a
-	 hex digit. */
-      case 'x':
-	for (temp = 2, evalue = 0; ISXDIGIT ((unsigned char)*p) && temp--; p++)
-	  evalue = (evalue * 16) + HEXVALUE (*p);
-	if (p == estart + 1)
-	  {
-	    builtin_error (_("missing hex digit for \\x"));
-	    *cp = '\\';
-	    return 0;
-	  }
-	*cp = evalue & 0xFF;
-	break;
-
-#if defined (HANDLE_MULTIBYTE)
-      case 'u':
-      case 'U':
-	temp = (c == 'u') ? 4 : 8;	/* \uNNNN \UNNNNNNNN */
-	for (uvalue = 0; ISXDIGIT ((unsigned char)*p) && temp--; p++)
-	  uvalue = (uvalue * 16) + HEXVALUE (*p);
-	if (p == estart + 1)
-	  {
-	    builtin_error (_("missing unicode digit for \\%c"), c);
-	    *cp = '\\';
-	    return 0;
-	  }
-	if (uvalue <= 0x7f)		/* <= 0x7f translates directly */
-	  *cp = uvalue;
-	else
-	  {
-	    temp = u32cconv (uvalue, cp);
-	    cp[temp] = '\0';
-	    if (lenp)
-	      *lenp = temp;
-	  }
-	break;
-#endif
-	
-      case '\\':	/* \\ -> \ */
-	*cp = c;
-	break;
-
-      /* SAWC == 0 means that \', \", and \? are recognized as escape
-	 sequences, though the only processing performed is backslash
-	 removal. */
-      case '\'': case '"': case '?':
-	if (!sawc)
-	  *cp = c;
-	else
-	  {
-	    *cp = '\\';
-	    return 0;
-	  }
-	break;
-
-      case 'c':
-	if (sawc)
-	  {
-	    *sawc = 1;
-	    break;
-	  }
-      /* other backslash escapes are passed through unaltered */
-      default:
-	*cp = '\\';
-	return 0;
-      }
-  return (p - estart);
-}
-
-static char *
-bexpand (string, len, sawc, lenp)
-     char *string;
-     int len, *sawc, *lenp;
-{
-  int temp;
-  char *ret, *r, *s, c;
-#if defined (HANDLE_MULTIBYTE)
-  char mbch[25];
-  int mbind, mblen;
-#endif
-
-  if (string == 0 || len == 0)
-    {
-      if (sawc)
-	*sawc = 0;
-      if (lenp)
-	*lenp = 0;
-      ret = (char *)xmalloc (1);
-      ret[0] = '\0';
-      return (ret);
-    }
-
-  ret = (char *)xmalloc (len + 1);
-  for (r = ret, s = string; s && *s; )
-    {
-      c = *s++;
-      if (c != '\\' || *s == '\0')
-	{
-	  *r++ = c;
-	  continue;
-	}
-      temp = 0;
-#if defined (HANDLE_MULTIBYTE)
-      memset (mbch, '\0', sizeof (mbch));
-      s += tescape (s, mbch, &mblen, &temp);
-#else
-      s += tescape (s, &c, (int *)NULL, &temp);
-#endif
-      if (temp)
-	{
-	  if (sawc)
-	    *sawc = 1;
-	  break;
-	}
-
-#if defined (HANDLE_MULTIBYTE)
-      for (mbind = 0; mbind < mblen; mbind++)
-	*r++ = mbch[mbind];
-#else
-      *r++ = c;
-#endif      
-    }
-
-  *r = '\0';
-  if (lenp)
-    *lenp = r - ret;
-  return ret;
-}
-
-static char *
-vbadd (buf, blen)
-     char *buf;
-     int blen;
-{
-  size_t nlen;
-
-  nlen = vblen + blen + 1;
-  if (nlen >= vbsize)
-    {
-      vbsize = ((nlen + 63) >> 6) << 6;
-      vbuf = (char *)xrealloc (vbuf, vbsize);
-    }
-
-  if (blen == 1)
-    vbuf[vblen++] = buf[0];
-  else if (blen > 1)
-    {
-      FASTCOPY (buf, vbuf  + vblen, blen);
-      vblen += blen;
-    }
-  vbuf[vblen] = '\0';
-
-#ifdef DEBUG
-  if  (strlen (vbuf) != vblen)
-    internal_error  ("printf:vbadd: vblen (%d) != strlen (vbuf) (%d)", vblen, (int)strlen (vbuf));
-#endif
-
-  return vbuf;
-}
-
-static int
-#if defined (PREFER_STDARG)
-vbprintf (const char *format, ...)
-#else
-vbprintf (format, va_alist)
-  const char *format;
-  va_dcl
-#endif
-{
-  va_list args;
-  size_t nlen;
-  int blen;
-
-  SH_VA_START (args, format);
-  blen = vsnprintf (vbuf + vblen, vbsize - vblen, format, args);
-  va_end (args);
-
-  nlen = vblen + blen + 1;
-  if (nlen >= vbsize)
-    {
-      vbsize = ((nlen + 63) >> 6) << 6;
-      vbuf = (char *)xrealloc (vbuf, vbsize);
-      SH_VA_START (args, format);
-      blen = vsnprintf (vbuf + vblen, vbsize - vblen, format, args);
-      va_end (args);
-    }
-
-  vblen += blen;
-  vbuf[vblen] = '\0';
-
-#ifdef DEBUG
-  if  (strlen (vbuf) != vblen)
-    internal_error  ("printf:vbprintf: vblen (%d) != strlen (vbuf) (%d)", vblen, (int)strlen (vbuf));
-#endif
-  
-  return (blen);
-}
-
-static char *
-mklong (str, modifiers, mlen)
-     char *str;
-     char *modifiers;
-     size_t mlen;
-{
-  size_t len, slen;
-
-  slen = strlen (str);
-  len = slen + mlen + 1;
-
-  if (len > conv_bufsize)
-    {
-      conv_bufsize = (((len + 1023) >> 10) << 10);
-      conv_buf = (char *)xrealloc (conv_buf, conv_bufsize);
-    }
-
-  FASTCOPY (str, conv_buf, slen - 1);
-  FASTCOPY (modifiers, conv_buf + slen - 1, mlen);
-
-  conv_buf[len - 2] = str[slen - 1];
-  conv_buf[len - 1] = '\0';
-  return (conv_buf);
-}
-
-static int
-getchr ()
-{
-  int ret;
-
-  if (garglist == 0)
-    return ('\0');
-
-  ret = (int)garglist->word->word[0];
-  garglist = garglist->next;
-  return ret;
-}
-
-static char *
-getstr ()
-{
-  char *ret;
-
-  if (garglist == 0)
-    return ("");
-
-  ret = garglist->word->word;
-  garglist = garglist->next;
-  return ret;
-}
-
-static int
-getint ()
-{
-  intmax_t ret;
-
-  ret = getintmax ();
-
-  if (garglist == 0)
-    return ret;
-
-  if (ret > INT_MAX)
-    {
-      printf_erange (garglist->word->word);
-      ret = INT_MAX;
-    }
-  else if (ret < INT_MIN)
-    {
-      printf_erange (garglist->word->word);
-      ret = INT_MIN;
-    }
-
-  return ((int)ret);
-}
-
-static intmax_t
-getintmax ()
-{
-  intmax_t ret;
-  char *ep;
-
-  if (garglist == 0)
-    return (0);
-
-  if (garglist->word->word[0] == '\'' || garglist->word->word[0] == '"')
-    return asciicode ();
-
-  errno = 0;
-  ret = strtoimax (garglist->word->word, &ep, 0);
-
-  if (*ep)
-    {
-      sh_invalidnum (garglist->word->word);
-      /* POSIX.2 says ``...a diagnostic message shall be written to standard
-	 error, and the utility shall not exit with a zero exit status, but
-	 shall continue processing any remaining operands and shall write the
-         value accumulated at the time the error was detected to standard
-	 output.''  Yecch. */
-#if 0
-      ret = 0;		/* return partially-converted value from strtoimax */
-#endif
-      conversion_error = 1;
-    }
-  else if (errno == ERANGE)
-    printf_erange (garglist->word->word);
-
-  garglist = garglist->next;
-  return (ret);
-}
-
-static uintmax_t
-getuintmax ()
-{
-  uintmax_t ret;
-  char *ep;
-
-  if (garglist == 0)
-    return (0);
-
-  if (garglist->word->word[0] == '\'' || garglist->word->word[0] == '"')
-    return asciicode ();
-
-  errno = 0;
-  ret = strtoumax (garglist->word->word, &ep, 0);
-  
-  if (*ep)
-    {
-      sh_invalidnum (garglist->word->word);
-#if 0
-      /* Same POSIX.2 conversion error requirements as getintmax(). */
-      ret = 0;
-#endif
-      conversion_error = 1;
-    }
-  else if (errno == ERANGE)
-    printf_erange (garglist->word->word);
-
-  garglist = garglist->next;
-  return (ret);
-}
-
-static double
-getdouble ()
-{
-  double ret;
-  char *ep;
-
-  if (garglist == 0)
-    return (0);
-
-  if (garglist->word->word[0] == '\'' || garglist->word->word[0] == '"')
-    return asciicode ();
-
-  errno = 0;
-  ret = strtod (garglist->word->word, &ep);
-
-  if (*ep)
-    {
-      sh_invalidnum (garglist->word->word);
-      conversion_error = 1;
-    }
-  else if (errno == ERANGE)
-    printf_erange (garglist->word->word);
-
-  garglist = garglist->next;
-  return (ret);
-}
-
-static floatmax_t
-getfloatmax ()
-{
-  floatmax_t ret;
-  char *ep;
-
-  if (garglist == 0)
-    return (0);
-
-  if (garglist->word->word[0] == '\'' || garglist->word->word[0] == '"')
-    return asciicode ();
-
-  errno = 0;
-  ret = strtofltmax (garglist->word->word, &ep);
-
-  if (*ep)
-    {
-      sh_invalidnum (garglist->word->word);
-#if 0
-      /* Same thing about POSIX.2 conversion error requirements. */
-      ret = 0;
-#endif
-      conversion_error = 1;
-    }
-  else if (errno == ERANGE)
-    printf_erange (garglist->word->word);
-
-  garglist = garglist->next;
-  return (ret);
-}
-
-/* NO check is needed for garglist here. */
-static intmax_t
-asciicode ()
-{
-  register intmax_t ch;
-#if defined (HANDLE_MULTIBYTE)
-  wchar_t wc;
-  size_t slen;
-  int mblength;
-#endif
-  DECLARE_MBSTATE;
-
-#if defined (HANDLE_MULTIBYTE)
-  slen = strlen (garglist->word->word+1);
-  wc = 0;
-  mblength = mbtowc (&wc, garglist->word->word+1, slen);
-  if (mblength > 0)
-    ch = wc;		/* XXX */
-  else
-#endif
-    ch = (unsigned char)garglist->word->word[1];
-
-  garglist = garglist->next;
-  return (ch);
-}
diff --git a/third_party/bash/builtins_pushd.c b/third_party/bash/builtins_pushd.c
deleted file mode 100644
index 6c9c02352..000000000
--- a/third_party/bash/builtins_pushd.c
+++ /dev/null
@@ -1,690 +0,0 @@
-/* pushd.c, created from pushd.def. */
-#line 22 "./pushd.def"
-
-#line 55 "./pushd.def"
-
-#line 84 "./pushd.def"
-
-#line 115 "./pushd.def"
-
-#include "config.h"
-
-#if defined (PUSHD_AND_POPD)
-#include <stdio.h>
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include <errno.h>
-
-#include "tilde.h"
-
-#include "shell.h"
-#include "maxpath.h"
-#include "common.h"
-#include "builtext.h"
-
-#ifdef LOADABLE_BUILTIN
-#  include "builtins.h"
-#endif
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-/* The list of remembered directories. */
-static char **pushd_directory_list = (char **)NULL;
-
-/* Number of existing slots in this list. */
-static int directory_list_size;
-
-/* Offset to the end of the list. */
-static int directory_list_offset;
-
-static void pushd_error PARAMS((int, char *));
-static void clear_directory_stack PARAMS((void));
-static int cd_to_string PARAMS((char *));
-static int change_to_temp PARAMS((char *));
-static void add_dirstack_element PARAMS((char *));
-static int get_dirstack_index PARAMS((intmax_t, int, int *));
-
-#define NOCD		0x01
-#define ROTATE		0x02
-#define LONGFORM	0x04
-#define CLEARSTAK	0x08
-
-int
-pushd_builtin (list)
-     WORD_LIST *list;
-{
-  WORD_LIST *orig_list;
-  char *temp, *current_directory, *top;
-  int j, flags, skipopt;
-  intmax_t num;
-  char direction;
-
-  orig_list = list;
-
-  CHECK_HELPOPT (list);
-  if (list && list->word && ISOPTION (list->word->word, '-'))
-    {
-      list = list->next;
-      skipopt = 1;
-    }
-  else
-    skipopt = 0;
-
-  /* If there is no argument list then switch current and
-     top of list. */
-  if (list == 0)
-    {
-      if (directory_list_offset == 0)
-	{
-	  builtin_error (_("no other directory"));
-	  return (EXECUTION_FAILURE);
-	}
-
-      current_directory = get_working_directory ("pushd");
-      if (current_directory == 0)
-	return (EXECUTION_FAILURE);
-
-      j = directory_list_offset - 1;
-      temp = pushd_directory_list[j];
-      pushd_directory_list[j] = current_directory;
-      j = change_to_temp (temp);
-      free (temp);
-      return j;
-    }
-
-  for (flags = 0; skipopt == 0 && list; list = list->next)
-    {
-      if (ISOPTION (list->word->word, 'n'))
-	{
-	  flags |= NOCD;
-	}
-      else if (ISOPTION (list->word->word, '-'))
-	{
-	  list = list->next;
-	  break;
-	}
-      else if (list->word->word[0] == '-' && list->word->word[1] == '\0')
-	/* Let `pushd -' work like it used to. */
-	break;
-      else if (((direction = list->word->word[0]) == '+') || direction == '-')
-	{
-	  if (legal_number (list->word->word + 1, &num) == 0)
-	    {
-	      sh_invalidnum (list->word->word);
-	      builtin_usage ();
-	      return (EX_USAGE);
-	    }
-
-	  if (direction == '-')
-	    num = directory_list_offset - num;
-
-	  if (num > directory_list_offset || num < 0)
-	    {
-	      pushd_error (directory_list_offset, list->word->word);
-	      return (EXECUTION_FAILURE);
-	    }
-	  flags |= ROTATE;
-	}
-      else if (*list->word->word == '-')
-	{
-	  sh_invalidopt (list->word->word);
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-      else
-	break;
-    }
-
-  if (flags & ROTATE)
-    {
-      /* Rotate the stack num times.  Remember, the current
-	 directory acts like it is part of the stack. */
-      temp = get_working_directory ("pushd");
-
-      if (num == 0)
-	{
-	  j = ((flags & NOCD) == 0) ? change_to_temp (temp) : EXECUTION_SUCCESS;
-	  free (temp);
-	  return j;
-	}
-
-      do
-	{
-	  top = pushd_directory_list[directory_list_offset - 1];
-
-	  for (j = directory_list_offset - 2; j > -1; j--)
-	    pushd_directory_list[j + 1] = pushd_directory_list[j];
-
-	  pushd_directory_list[j + 1] = temp;
-
-	  temp = top;
-	  num--;
-	}
-      while (num);
-
-      j = ((flags & NOCD) == 0) ? change_to_temp (temp) : EXECUTION_SUCCESS;
-      free (temp);
-      return j;
-    }
-
-  if (list == 0)
-    return (EXECUTION_SUCCESS);
-
-  /* Change to the directory in list->word->word.  Save the current
-     directory on the top of the stack. */
-  current_directory = get_working_directory ("pushd");
-  if (current_directory == 0)
-    return (EXECUTION_FAILURE);
-
-  j = ((flags & NOCD) == 0) ? cd_builtin (skipopt ? orig_list : list) : EXECUTION_SUCCESS;
-  if (j == EXECUTION_SUCCESS)
-    {
-      add_dirstack_element ((flags & NOCD) ? savestring (list->word->word) : current_directory);
-      dirs_builtin ((WORD_LIST *)NULL);
-      if (flags & NOCD)
-	free (current_directory);
-      return (EXECUTION_SUCCESS);
-    }
-  else
-    {
-      free (current_directory);
-      return (EXECUTION_FAILURE);
-    }
-}
-
-/* Pop the directory stack, and then change to the new top of the stack.
-   If LIST is non-null it should consist of a word +N or -N, which says
-   what element to delete from the stack.  The default is the top one. */
-int
-popd_builtin (list)
-     WORD_LIST *list;
-{
-  register int i;
-  intmax_t which;
-  int flags;
-  char direction;
-  char *which_word;
-
-  CHECK_HELPOPT (list);
-
-  which_word = (char *)NULL;
-  for (flags = 0, which = 0, direction = '+'; list; list = list->next)
-    {
-      if (ISOPTION (list->word->word, 'n'))
-	{
-	  flags |= NOCD;
-	}
-      else if (ISOPTION (list->word->word, '-'))
-	{
-	  list = list->next;
-	  break;
-	}
-      else if (((direction = list->word->word[0]) == '+') || direction == '-')
-	{
-	  if (legal_number (list->word->word + 1, &which) == 0)
-	    {
-	      sh_invalidnum (list->word->word);
-	      builtin_usage ();
-	      return (EX_USAGE);
-	    }
-	  which_word = list->word->word;
-	}
-      else if (*list->word->word == '-')
-	{
-	  sh_invalidopt (list->word->word);
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-      else if (*list->word->word)
-	{
-	  builtin_error (_("%s: invalid argument"), list->word->word);
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-      else
-	break;
-    }
-
-  if (which > directory_list_offset || (which < -directory_list_offset) || (directory_list_offset == 0 && which == 0))
-    {
-      pushd_error (directory_list_offset, which_word ? which_word : "");
-      return (EXECUTION_FAILURE);
-    }
-
-  /* Handle case of no specification, or top of stack specification. */
-  if ((direction == '+' && which == 0) ||
-      (direction == '-' && which == directory_list_offset))
-    {
-      i = ((flags & NOCD) == 0) ? cd_to_string (pushd_directory_list[directory_list_offset - 1])
-      				: EXECUTION_SUCCESS;
-      if (i != EXECUTION_SUCCESS)
-	return (i);
-      free (pushd_directory_list[--directory_list_offset]);
-    }
-  else
-    {
-      /* Since an offset other than the top directory was specified,
-	 remove that directory from the list and shift the remainder
-	 of the list into place. */
-      i = (direction == '+') ? directory_list_offset - which : which;
-      if (i < 0 || i > directory_list_offset)
-	{
-	  pushd_error (directory_list_offset, which_word ? which_word : "");
-	  return (EXECUTION_FAILURE);
-	}
-      free (pushd_directory_list[i]);
-      directory_list_offset--;
-
-      /* Shift the remainder of the list into place. */
-      for (; i < directory_list_offset; i++)
-	pushd_directory_list[i] = pushd_directory_list[i + 1];
-    }
-
-  dirs_builtin ((WORD_LIST *)NULL);
-  return (EXECUTION_SUCCESS);
-}
-
-/* Print the current list of directories on the directory stack. */
-int
-dirs_builtin (list)
-     WORD_LIST *list;
-{
-  int flags, desired_index, index_flag, vflag;
-  intmax_t i;
-  char *temp, *w;
-
-  CHECK_HELPOPT (list);
-  for (flags = vflag = index_flag = 0, desired_index = -1, w = ""; list; list = list->next)
-    {
-      if (ISOPTION (list->word->word, 'l'))
-	{
-	  flags |= LONGFORM;
-	}
-      else if (ISOPTION (list->word->word, 'c'))
-	{
-	  flags |= CLEARSTAK;
-	}
-      else if (ISOPTION (list->word->word, 'v'))
-	{
-	  vflag |= 2;
-	}
-      else if (ISOPTION (list->word->word, 'p'))
-	{
-	  vflag |= 1;
-	}
-      else if (ISOPTION (list->word->word, '-'))
-	{
-	  list = list->next;
-	  break;
-	}
-      else if (*list->word->word == '+' || *list->word->word == '-')
-	{
-	  int sign;
-	  if (legal_number (w = list->word->word + 1, &i) == 0)
-	    {
-	      sh_invalidnum (list->word->word);
-	      builtin_usage ();
-	      return (EX_USAGE);
-	    }
-	  sign = (*list->word->word == '+') ? 1 : -1;
-	  desired_index = get_dirstack_index (i, sign, &index_flag);
-	}
-      else
-	{
-	  sh_invalidopt (list->word->word);
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-
-  if (flags & CLEARSTAK)
-    {
-      clear_directory_stack ();
-      return (EXECUTION_SUCCESS);
-    }
-
-  if (index_flag && (desired_index < 0 || desired_index > directory_list_offset))
-    {
-      pushd_error (directory_list_offset, w);
-      return (EXECUTION_FAILURE);
-    }
-
-#define DIRSTACK_FORMAT(temp) \
-  (flags & LONGFORM) ? temp : polite_directory_format (temp)
-
-  /* The first directory printed is always the current working directory. */
-  if (index_flag == 0 || (index_flag == 1 && desired_index == 0))
-    {
-      temp = get_working_directory ("dirs");
-      if (temp == 0)
-	temp = savestring (_("<no current directory>"));
-      if (vflag & 2)
-	printf ("%2d  %s", 0, DIRSTACK_FORMAT (temp));
-      else
-	printf ("%s", DIRSTACK_FORMAT (temp));
-      free (temp);
-      if (index_flag)
-	{
-	  putchar ('\n');
-	  return (sh_chkwrite (EXECUTION_SUCCESS));
-	}
-    }
-
-#define DIRSTACK_ENTRY(i) \
-  (flags & LONGFORM) ? pushd_directory_list[i] \
-		     : polite_directory_format (pushd_directory_list[i])
-
-  /* Now print the requested directory stack entries. */
-  if (index_flag)
-    {
-      if (vflag & 2)
-	printf ("%2d  %s", directory_list_offset - desired_index,
-			   DIRSTACK_ENTRY (desired_index));
-      else
-	printf ("%s", DIRSTACK_ENTRY (desired_index));
-    }
-  else
-    for (i = directory_list_offset - 1; i >= 0; i--)
-      if (vflag >= 2)
-	printf ("\n%2d  %s", directory_list_offset - (int)i, DIRSTACK_ENTRY (i));
-      else
-	printf ("%s%s", (vflag & 1) ? "\n" : " ", DIRSTACK_ENTRY (i));
-
-  putchar ('\n');
-
-  return (sh_chkwrite (EXECUTION_SUCCESS));
-}
-
-static void
-pushd_error (offset, arg)
-     int offset;
-     char *arg;
-{
-  if (offset == 0)
-    builtin_error (_("directory stack empty"));
-  else
-    sh_erange (arg, _("directory stack index"));
-}
-
-static void
-clear_directory_stack ()
-{
-  register int i;
-
-  for (i = 0; i < directory_list_offset; i++)
-    free (pushd_directory_list[i]);
-  directory_list_offset = 0;
-}
-
-/* Switch to the directory in NAME.  This uses the cd_builtin to do the work,
-   so if the result is EXECUTION_FAILURE then an error message has already
-   been printed. */
-static int
-cd_to_string (name)
-     char *name;
-{
-  WORD_LIST *tlist;
-  WORD_LIST *dir;
-  int result;
-
-  dir = make_word_list (make_word (name), NULL);
-  tlist = make_word_list (make_word ("--"), dir);
-  result = cd_builtin (tlist);
-  dispose_words (tlist);
-  return (result);
-}
-
-static int
-change_to_temp (temp)
-     char *temp;
-{
-  int tt;
-
-  tt = temp ? cd_to_string (temp) : EXECUTION_FAILURE;
-
-  if (tt == EXECUTION_SUCCESS)
-    dirs_builtin ((WORD_LIST *)NULL);
-
-  return (tt);
-}
-
-static void
-add_dirstack_element (dir)
-     char *dir;
-{
-  if (directory_list_offset == directory_list_size)
-    pushd_directory_list = strvec_resize (pushd_directory_list, directory_list_size += 10);
-  pushd_directory_list[directory_list_offset++] = dir;
-}
-
-static int
-get_dirstack_index (ind, sign, indexp)
-     intmax_t ind;
-     int sign, *indexp;
-{
-  if (indexp)
-    *indexp = sign > 0 ? 1 : 2;
-
-  /* dirs +0 prints the current working directory. */
-  /* dirs -0 prints last element in directory stack */
-  if (ind == 0 && sign > 0)
-    return 0;
-  else if (ind == directory_list_offset)
-    {
-      if (indexp)
-	*indexp = sign > 0 ? 2 : 1;
-      return 0;
-    }
-  else if (ind >= 0 && ind <= directory_list_offset)
-    return (sign > 0 ? directory_list_offset - ind : ind);
-  else
-    return -1;
-}
-
-/* Used by the tilde expansion code. */
-char *
-get_dirstack_from_string (string)
-     char *string;
-{
-  int ind, sign, index_flag;
-  intmax_t i;
-
-  sign = 1;
-  if (*string == '-' || *string == '+')
-    {
-      sign = (*string == '-') ? -1 : 1;
-      string++;
-    }
-  if (legal_number (string, &i) == 0)
-    return ((char *)NULL);
-
-  index_flag = 0;
-  ind = get_dirstack_index (i, sign, &index_flag);
-  if (index_flag && (ind < 0 || ind > directory_list_offset))
-    return ((char *)NULL);
-  if (index_flag == 0 || (index_flag == 1 && ind == 0))
-    return (get_string_value ("PWD"));
-  else
-    return (pushd_directory_list[ind]);
-}
-
-#ifdef INCLUDE_UNUSED
-char *
-get_dirstack_element (ind, sign)
-     intmax_t ind;
-     int sign;
-{
-  int i;
-
-  i = get_dirstack_index (ind, sign, (int *)NULL);
-  return (i < 0 || i > directory_list_offset) ? (char *)NULL
-					      : pushd_directory_list[i];
-}
-#endif
-
-void
-set_dirstack_element (ind, sign, value)
-     intmax_t ind;
-     int  sign;
-     char *value;
-{
-  int i;
-
-  i = get_dirstack_index (ind, sign, (int *)NULL);
-  if (ind == 0 || i < 0 || i > directory_list_offset)
-    return;
-  free (pushd_directory_list[i]);
-  pushd_directory_list[i] = savestring (value);
-}
-
-WORD_LIST *
-get_directory_stack (flags)
-     int flags;
-{
-  register int i;
-  WORD_LIST *ret;
-  char *d, *t;
-
-  for (ret = (WORD_LIST *)NULL, i = 0; i < directory_list_offset; i++)
-    {
-      d = (flags&1) ? polite_directory_format (pushd_directory_list[i])
-		    : pushd_directory_list[i];
-      ret = make_word_list (make_word (d), ret);
-    }
-  /* Now the current directory. */
-  d = get_working_directory ("dirstack");
-  i = 0;	/* sentinel to decide whether or not to free d */
-  if (d == 0)
-    d = ".";
-  else
-    {
-      t = (flags&1) ? polite_directory_format (d) : d;
-      /* polite_directory_format sometimes returns its argument unchanged.
-	 If it does not, we can free d right away.  If it does, we need to
-	 mark d to be deleted later. */
-      if (t != d)
-	{
-	  free (d);
-	  d = t;
-	}
-      else /* t == d, so d is what we want */
-	i = 1;
-    }
-  ret = make_word_list (make_word (d), ret);
-  if (i)
-    free (d);
-  return ret;	/* was (REVERSE_LIST (ret, (WORD_LIST *)); */
-}
-
-#ifdef LOADABLE_BUILTIN
-char * const dirs_doc[] = {
-N_("Display the list of currently remembered directories.  Directories\n\
-    find their way onto the list with the `pushd' command; you can get\n\
-    back up through the list with the `popd' command.\n\
-    \n\
-    Options:\n\
-      -c	clear the directory stack by deleting all of the elements\n\
-      -l	do not print tilde-prefixed versions of directories relative\n\
-    	to your home directory\n\
-      -p	print the directory stack with one entry per line\n\
-      -v	print the directory stack with one entry per line prefixed\n\
-    	with its position in the stack\n\
-    \n\
-    Arguments:\n\
-      +N	Displays the Nth entry counting from the left of the list shown by\n\
-    	dirs when invoked without options, starting with zero.\n\
-    \n\
-      -N	Displays the Nth entry counting from the right of the list shown by\n\
-	dirs when invoked without options, starting with zero."),
-  (char *)NULL
-};
-
-char * const pushd_doc[] = {
-N_("Adds a directory to the top of the directory stack, or rotates\n\
-    the stack, making the new top of the stack the current working\n\
-    directory.  With no arguments, exchanges the top two directories.\n\
-    \n\
-    Options:\n\
-      -n	Suppresses the normal change of directory when adding\n\
-    	directories to the stack, so only the stack is manipulated.\n\
-    \n\
-    Arguments:\n\
-      +N	Rotates the stack so that the Nth directory (counting\n\
-    	from the left of the list shown by `dirs', starting with\n\
-    	zero) is at the top.\n\
-    \n\
-      -N	Rotates the stack so that the Nth directory (counting\n\
-    	from the right of the list shown by `dirs', starting with\n\
-    	zero) is at the top.\n\
-    \n\
-      dir	Adds DIR to the directory stack at the top, making it the\n\
-    	new current working directory.\n\
-    \n\
-    The `dirs' builtin displays the directory stack."),
-  (char *)NULL
-};
-
-char * const popd_doc[] = {
-N_("Removes entries from the directory stack.  With no arguments, removes\n\
-    the top directory from the stack, and changes to the new top directory.\n\
-    \n\
-    Options:\n\
-      -n	Suppresses the normal change of directory when removing\n\
-    	directories from the stack, so only the stack is manipulated.\n\
-    \n\
-    Arguments:\n\
-      +N	Removes the Nth entry counting from the left of the list\n\
-    	shown by `dirs', starting with zero.  For example: `popd +0'\n\
-    	removes the first directory, `popd +1' the second.\n\
-    \n\
-      -N	Removes the Nth entry counting from the right of the list\n\
-    	shown by `dirs', starting with zero.  For example: `popd -0'\n\
-    	removes the last directory, `popd -1' the next to last.\n\
-    \n\
-    The `dirs' builtin displays the directory stack."),
-  (char *)NULL
-};
-
-struct builtin pushd_struct = {
-	"pushd",
-	pushd_builtin,
-	BUILTIN_ENABLED,
-	pushd_doc,
-	"pushd [+N | -N] [-n] [dir]",
-	0
-};
-
-struct builtin popd_struct = {
-	"popd",
-	popd_builtin,
-	BUILTIN_ENABLED,
-	popd_doc,
-	"popd [+N | -N] [-n]",
-	0
-};
-
-struct builtin dirs_struct = {
-	"dirs",
-	dirs_builtin,
-	BUILTIN_ENABLED,
-	dirs_doc,
-	"dirs [-clpv] [+N] [-N]",
-	0
-};
-#endif /* LOADABLE_BUILTIN */
-
-#endif /* PUSHD_AND_POPD */
diff --git a/third_party/bash/builtins_read.c b/third_party/bash/builtins_read.c
deleted file mode 100644
index fc4346dda..000000000
--- a/third_party/bash/builtins_read.c
+++ /dev/null
@@ -1,1205 +0,0 @@
-/* read.c, created from read.def. */
-#line 22 "./read.def"
-
-#line 70 "./read.def"
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "posixstat.h"
-
-#include <stdio.h>
-
-#include "bashansi.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <signal.h>
-#include <errno.h>
-
-#ifdef __CYGWIN__
-#  include <fcntl.h>
-#  include <io.h>
-#endif
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "common.h"
-#include "bashgetopt.h"
-#include "trap.h"
-
-#include "shtty.h"
-
-#if defined (READLINE)
-#include "bashline.h"
-#include "third_party/readline/readline.h"
-#endif
-
-#if defined (BUFFERED_INPUT)
-#  include "input.h"
-#endif
-
-#include "shmbutil.h"
-#include "timer.h"
-
-#if !defined(errno)
-extern int errno;
-#endif
-
-struct ttsave
-{
-  int fd;
-  TTYSTRUCT attrs;
-};
-
-#if defined (READLINE)
-static void reset_attempted_completion_function PARAMS((char *));
-static int set_itext PARAMS((void));
-static char *edit_line PARAMS((char *, char *));
-static void set_eol_delim PARAMS((int));
-static void reset_eol_delim PARAMS((char *));
-static void set_readline_timeout PARAMS((sh_timer *t, time_t, long));
-#endif
-static SHELL_VAR *bind_read_variable PARAMS((char *, char *, int));
-#if defined (HANDLE_MULTIBYTE)
-static int read_mbchar PARAMS((int, char *, int, int, int));
-#endif
-static void ttyrestore PARAMS((struct ttsave *));
-
-static sighandler sigalrm PARAMS((int));
-static void reset_timeout PARAMS((void));
-
-/* Try this to see what the rest of the shell can do with the information. */
-sh_timer *read_timeout;
-
-static int reading, tty_modified;
-static SigHandler *old_alrm;
-static unsigned char delim;
-
-static struct ttsave termsave;
-
-/* In all cases, SIGALRM just sets a flag that we check periodically.  This
-   avoids problems with the semi-tricky stuff we do with the xfree of
-   input_string at the top of the unwind-protect list (see below). */
-
-/* Set a flag that check_read_timeout can check.  This relies on zread or
-   read_builtin calling trap.c:check_signals() (which calls check_read_timeout()) */
-static sighandler
-sigalrm (s)
-     int s;
-{
-  /* Display warning if this is called without read_timeout set? */
-  if (read_timeout)
-    read_timeout->alrmflag = 1;
-}
-
-static void
-reset_timeout ()
-{
-  /* Cancel alarm before restoring signal handler. */
-  if (read_timeout)
-    shtimer_clear (read_timeout);
-  read_timeout = 0;
-}
-
-void
-check_read_timeout ()
-{
-  if (read_timeout && shtimer_chktimeout (read_timeout))
-    sh_longjmp (read_timeout->jmpenv, 1);
-}
-
-int
-read_builtin_timeout (fd)
-     int fd;
-{
-  if ((read_timeout == 0) ||
-      (read_timeout->fd != fd) ||
-      (read_timeout->tmout.tv_sec == 0 && read_timeout->tmout.tv_usec == 0))
-    return 0;
-
-  return ((read_timeout->flags & SHTIMER_ALARM) ? shtimer_alrm (read_timeout)
-  						: shtimer_select (read_timeout));
-}
-
-/* Read the value of the shell variables whose names follow.
-   The reading is done from the current input stream, whatever
-   that may be.  Successive words of the input line are assigned
-   to the variables mentioned in LIST.  The last variable in LIST
-   gets the remainder of the words on the line.  If no variables
-   are mentioned in LIST, then the default variable is $REPLY. */
-int
-read_builtin (list)
-     WORD_LIST *list;
-{
-  register char *varname;
-  int size, nr, pass_next, saw_escape, eof, opt, retval, code, print_ps2, nflag;
-  volatile int i;
-  int input_is_tty, input_is_pipe, unbuffered_read, skip_ctlesc, skip_ctlnul;
-  int raw, edit, nchars, silent, have_timeout, ignore_delim, fd;
-  int lastsig, t_errno;
-  int mb_cur_max;
-  unsigned int tmsec, tmusec;
-  long ival, uval;
-  intmax_t intval;
-  char c;
-  char *input_string, *orig_input_string, *ifs_chars, *prompt, *arrayname;
-  char *e, *t, *t1, *ps2, *tofree;
-  struct stat tsb;
-  SHELL_VAR *var;
-  TTYSTRUCT ttattrs, ttset;
-  sigset_t chldset, prevset;
-#if defined (ARRAY_VARS)
-  WORD_LIST *alist;
-  int vflags;
-#endif
-  int bindflags;
-#if defined (READLINE)
-  char *rlbuf, *itext;
-  int rlind;
-  FILE *save_instream;
-#endif
-
-  USE_VAR(size);
-  USE_VAR(i);
-  USE_VAR(pass_next);
-  USE_VAR(print_ps2);
-  USE_VAR(saw_escape);
-  USE_VAR(input_is_pipe);
-/*  USE_VAR(raw); */
-  USE_VAR(edit);
-  USE_VAR(tmsec);
-  USE_VAR(tmusec);
-  USE_VAR(nchars);
-  USE_VAR(silent);
-  USE_VAR(ifs_chars);
-  USE_VAR(prompt);
-  USE_VAR(arrayname);
-#if defined (READLINE)
-  USE_VAR(rlbuf);
-  USE_VAR(rlind);
-  USE_VAR(itext);
-#endif
-  USE_VAR(list);
-  USE_VAR(ps2);
-  USE_VAR(lastsig);
-
-  reading = tty_modified = 0;
-  read_timeout = 0;
-
-  i = 0;		/* Index into the string that we are reading. */
-  raw = edit = 0;	/* Not reading raw input by default. */
-  silent = 0;
-  arrayname = prompt = (char *)NULL;
-  fd = 0;		/* file descriptor to read from */
-
-#if defined (READLINE)
-  rlbuf = itext = (char *)0;
-  rlind = 0;
-#endif
-
-  mb_cur_max = MB_CUR_MAX;
-  tmsec = tmusec = 0;		/* no timeout */
-  nr = nchars = input_is_tty = input_is_pipe = unbuffered_read = have_timeout = 0;
-  delim = '\n';		/* read until newline */
-  ignore_delim = nflag = 0;
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "ersa:d:i:n:p:t:u:N:")) != -1)
-    {
-      switch (opt)
-	{
-	case 'r':
-	  raw = 1;
-	  break;
-	case 'p':
-	  prompt = list_optarg;
-	  break;
-	case 's':
-	  silent = 1;
-	  break;
-	case 'e':
-#if defined (READLINE)
-	  edit = 1;
-#endif
-	  break;
-	case 'i':
-#if defined (READLINE)
-	  itext = list_optarg;
-#endif
-	  break;
-#if defined (ARRAY_VARS)
-	case 'a':
-	  arrayname = list_optarg;
-	  break;
-#endif
-	case 't':
-	  code = uconvert (list_optarg, &ival, &uval, (char **)NULL);
-	  if (code == 0 || ival < 0 || uval < 0)
-	    {
-	      builtin_error (_("%s: invalid timeout specification"), list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    {
-	      have_timeout = 1;
-	      tmsec = ival;
-	      tmusec = uval;
-	    }
-	  break;
-	case 'N':
-	  ignore_delim = 1;
-	  delim = -1;
-	case 'n':
-	  nflag = 1;
-	  code = legal_number (list_optarg, &intval);
-	  if (code == 0 || intval < 0 || intval != (int)intval)
-	    {
-	      sh_invalidnum (list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    nchars = intval;
-	  break;
-	case 'u':
-	  code = legal_number (list_optarg, &intval);
-	  if (code == 0 || intval < 0 || intval != (int)intval)
-	    {
-	      builtin_error (_("%s: invalid file descriptor specification"), list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    fd = intval;
-	  if (sh_validfd (fd) == 0)
-	    {
-	      builtin_error (_("%d: invalid file descriptor: %s"), fd, strerror (errno));
-	      return (EXECUTION_FAILURE);
-	    }
-	  break;
-	case 'd':
-	  delim = *list_optarg;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  /* `read -t 0 var' tests whether input is available with select/FIONREAD,
-     and fails if those are unavailable */
-  if (have_timeout && tmsec == 0 && tmusec == 0)
-    return (input_avail (fd) ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-
-  /* Convenience: check early whether or not the first of possibly several
-     variable names is a valid identifier, and bail early if so. */
-#if defined (ARRAY_VARS)
-  if (list)
-    SET_VFLAGS (list->word->flags, vflags, bindflags);
-  if (list && legal_identifier (list->word->word) == 0 && valid_array_reference (list->word->word, vflags) == 0)
-#else
-  bindflags = 0;
-  if (list && legal_identifier (list->word->word) == 0)
-#endif
-    {
-      sh_invalidid (list->word->word);
-      return (EXECUTION_FAILURE);
-    }
-
-  /* If we're asked to ignore the delimiter, make sure we do. */
-  if (ignore_delim)
-    delim = -1;
-
-  /* IF IFS is unset, we use the default of " \t\n". */
-  ifs_chars = getifs ();
-  if (ifs_chars == 0)		/* XXX - shouldn't happen */
-    ifs_chars = "";
-  /* If we want to read exactly NCHARS chars, don't split on IFS */
-  if (ignore_delim)
-    ifs_chars = "";
-  for (skip_ctlesc = skip_ctlnul = 0, e = ifs_chars; *e; e++)
-    skip_ctlesc |= *e == CTLESC, skip_ctlnul |= *e == CTLNUL;
-
-  input_string = (char *)xmalloc (size = 112);	/* XXX was 128 */
-  input_string[0] = '\0';
-
-  /* More input and options validation */
-  if (nflag == 1 && nchars == 0)
-    {
-      retval = read (fd, &c, 0);
-      retval = (retval >= 0) ? EXECUTION_SUCCESS : EXECUTION_FAILURE;
-      goto assign_vars;		/* bail early if asked to read 0 chars */
-    }
-
-  /* $TMOUT, if set, is the default timeout for read. */
-  if (have_timeout == 0 && (e = get_string_value ("TMOUT")))
-    {
-      code = uconvert (e, &ival, &uval, (char **)NULL);
-      if (code == 0 || ival < 0 || uval < 0)
-	tmsec = tmusec = 0;
-      else
-	{
-	  tmsec = ival;
-	  tmusec = uval;
-	}
-    }
-
-#if defined (SIGCHLD)
-  sigemptyset (&chldset);
-  sigprocmask (SIG_BLOCK, (sigset_t *)0, &chldset);
-  sigaddset (&chldset, SIGCHLD);
-#endif
-
-  begin_unwind_frame ("read_builtin");
-
-#if defined (BUFFERED_INPUT)
-  if (interactive == 0 && default_buffered_input >= 0 && fd_is_bash_input (fd))
-    sync_buffered_stream (default_buffered_input);
-#endif
-
-#if 1
-  input_is_tty = isatty (fd);
-#else
-  input_is_tty = 1;
-#endif
-  if (input_is_tty == 0)
-#ifndef __CYGWIN__
-    input_is_pipe = (lseek (fd, 0L, SEEK_CUR) < 0) && (errno == ESPIPE);
-#else
-    input_is_pipe = 1;
-#endif
-
-  /* If the -p, -e or -s flags were given, but input is not coming from the
-     terminal, turn them off. */
-  if ((prompt || edit || silent) && input_is_tty == 0)
-    {
-      prompt = (char *)NULL;
-#if defined (READLINE)
-      itext = (char *)NULL;
-#endif
-      edit = silent = 0;
-    }
-
-#if defined (READLINE)
-  if (edit)
-    add_unwind_protect (xfree, rlbuf);
-#endif
-
-  pass_next = 0;	/* Non-zero signifies last char was backslash. */
-  saw_escape = 0;	/* Non-zero signifies that we saw an escape char */
-
-  if (tmsec > 0 || tmusec > 0)
-    {
-      /* Turn off the timeout if stdin is a regular file (e.g. from
-	 input redirection). */
-      if ((fstat (fd, &tsb) < 0) || S_ISREG (tsb.st_mode))
-	tmsec = tmusec = 0;
-    }
-
-  if (tmsec > 0 || tmusec > 0)
-    {
-      read_timeout = shtimer_alloc ();
-      read_timeout->flags = SHTIMER_LONGJMP;
-
-#if defined (HAVE_SELECT)
-      read_timeout->flags |= (edit || posixly_correct) ? SHTIMER_ALARM : SHTIMER_SELECT;
-#else
-      read_timeout->flags |= SHTIMER_ALARM;
-#endif
-      read_timeout->fd = fd;
-
-      read_timeout->alrm_handler = sigalrm;
-    }
-
-  if (tmsec > 0 || tmusec > 0)
-    {
-      code = setjmp_nosigs (read_timeout->jmpenv);
-      if (code)
-	{
-	  reset_timeout ();
-	  sigprocmask (SIG_SETMASK, &prevset, (sigset_t *)0);
-
-	  /* Tricky.  The top of the unwind-protect stack is the free of
-	     input_string.  We want to run all the rest and use input_string,
-	     so we have to save input_string temporarily, run the unwind-
-	     protects, then restore input_string so we can use it later */
-	  orig_input_string = 0;
-	  input_string[i] = '\0';	/* make sure it's terminated */
-	  if (i == 0)
-	    {
-	      t = (char *)xmalloc (1);
-	      t[0] = 0;
-	    }
-	  else
-	    t = savestring (input_string);
-
-	  run_unwind_frame ("read_builtin");
-	  input_string = t;
-	  retval = 128+SIGALRM;
-	  goto assign_vars;
-	}
-      if (interactive_shell == 0)
-	initialize_terminating_signals ();
-      add_unwind_protect (reset_timeout, (char *)NULL);
-#if defined (READLINE)
-      if (edit)
-	{
-	  add_unwind_protect (reset_attempted_completion_function, (char *)NULL);
-	  add_unwind_protect (bashline_reset_event_hook, (char *)NULL);
-	  set_readline_timeout (read_timeout, tmsec, tmusec);
-	}
-      else
-#endif
-      shtimer_set (read_timeout, tmsec, tmusec);
-    }
-
-  /* If we've been asked to read only NCHARS chars, or we're using some
-     character other than newline to terminate the line, do the right
-     thing to readline or the tty. */
-  if (nchars > 0 || delim != '\n')
-    {
-#if defined (READLINE)
-      if (edit)
-	{
-	  if (nchars > 0)
-	    {
-	      unwind_protect_int (rl_num_chars_to_read);
-	      rl_num_chars_to_read = nchars;
-	    }
-	  if (delim != '\n')
-	    {
-	      set_eol_delim (delim);
-	      add_unwind_protect (reset_eol_delim, (char *)NULL);
-	    }
-	}
-      else
-#endif
-      if (input_is_tty)
-	{
-	  /* ttsave() */
-	  termsave.fd = fd;
-	  ttgetattr (fd, &ttattrs);
-	  termsave.attrs = ttattrs;
-
-	  ttset = ttattrs;	  
-	  i = silent ? ttfd_cbreak (fd, &ttset) : ttfd_onechar (fd, &ttset);
-	  if (i < 0)
-	    sh_ttyerror (1);
-	  tty_modified = 1;
-	  add_unwind_protect ((Function *)ttyrestore, (char *)&termsave);
-	  if (interactive_shell == 0)
-	    initialize_terminating_signals ();
-	}
-    }
-  else if (silent)	/* turn off echo but leave term in canonical mode */
-    {
-      /* ttsave (); */
-      termsave.fd = fd;
-      ttgetattr (fd, &ttattrs);
-      termsave.attrs = ttattrs;
-
-      ttset = ttattrs;
-      i = ttfd_noecho (fd, &ttset);			/* ttnoecho (); */
-      if (i < 0)
-	sh_ttyerror (1);
-
-      tty_modified = 1;
-      add_unwind_protect ((Function *)ttyrestore, (char *)&termsave);
-      if (interactive_shell == 0)
-	initialize_terminating_signals ();
-    }
-
-#if defined (READLINE)
-  save_instream = 0;
-  if (edit && fd != 0)
-    {
-      if (bash_readline_initialized == 0)
-	initialize_readline ();
-
-      unwind_protect_var (rl_instream);
-      save_instream = rl_instream;
-      rl_instream = fdopen (fd, "r");	
-    }
-#endif
-
-  /* This *must* be the top unwind-protect on the stack, so the manipulation
-     of the unwind-protect stack after the realloc() works right. */
-  add_unwind_protect (xfree, input_string);
-
-  check_read_timeout ();
-  /* These only matter if edit == 0 */
-  if ((nchars > 0) && (input_is_tty == 0) && ignore_delim)	/* read -N */
-    unbuffered_read = 2;
-#if 0
-  else if ((nchars > 0) || (delim != '\n') || input_is_pipe)
-#else
-  else if (((nchars > 0 || delim != '\n') && input_is_tty) || input_is_pipe)
-    unbuffered_read = 1;
-#endif
-  if (prompt && edit == 0)
-    {
-      fprintf (stderr, "%s", prompt);
-      fflush (stderr);
-    }
-
-#if defined (__CYGWIN__) && defined (O_TEXT)
-  setmode (0, O_TEXT);
-#endif
-
-  ps2 = 0;
-  for (print_ps2 = eof = retval = 0;;)
-    {
-      check_read_timeout ();
-
-#if defined (READLINE)
-      if (edit)
-	{
-	  /* If we have a null delimiter, don't treat NULL as ending the line */
-	  if (rlbuf && rlbuf[rlind] == '\0' && delim != '\0')
-	    {
-	      free (rlbuf);
-	      rlbuf = (char *)0;
-	    }
-#if defined (SIGCHLD)
-	  if (tmsec > 0 || tmusec > 0)
-	    sigprocmask (SIG_SETMASK, &chldset, &prevset);
-#endif
-	  if (rlbuf == 0)
-	    {
-	      reading = 1;
-	      rlbuf = edit_line (prompt ? prompt : "", itext);
-	      reading = 0;
-	      rlind = 0;
-	    }
-#if defined (SIGCHLD)
-	  if (tmsec > 0 || tmusec > 0)
-	    sigprocmask (SIG_SETMASK, &prevset, (sigset_t *)0);
-#endif
-	  if (rlbuf == 0)
-	    {
-	      eof = 1;
-	      break;
-	    }
-	  c = rlbuf[rlind++];
-	}
-      else
-	{
-#endif
-
-      if (print_ps2)
-	{
-	  if (ps2 == 0)
-	    ps2 = get_string_value ("PS2");
-	  fprintf (stderr, "%s", ps2 ? ps2 : "");
-	  fflush (stderr);
-	  print_ps2 = 0;
-	}
-
-      reading = 1;
-      check_read_timeout ();
-      errno = 0;
-
-#if defined (SIGCHLD)
-      if (tmsec > 0 || tmusec > 0)
-	sigprocmask (SIG_SETMASK, &chldset, &prevset);
-#endif
-      if (unbuffered_read == 2)
-	retval = posixly_correct ? zreadintr (fd, &c, 1) : zreadn (fd, &c, nchars - nr);
-      else if (unbuffered_read)
-	retval = posixly_correct ? zreadintr (fd, &c, 1) : zread (fd, &c, 1);
-      else
-	retval = posixly_correct ? zreadcintr (fd, &c) : zreadc (fd, &c);
-#if defined (SIGCHLD)
-      if (tmsec > 0 || tmusec > 0)
-	sigprocmask (SIG_SETMASK, &prevset, (sigset_t *)0);
-#endif
-
-      reading = 0;
-
-      if (retval <= 0)
-	{
-	  int t;
-
-	  t = errno;
-	  if (retval < 0 && errno == EINTR)
-	    {
-	      check_signals ();		/* in case we didn't call zread via zreadc */
-	      lastsig = LASTSIG();
-	      if (lastsig == 0)
-		lastsig = trapped_signal_received;
-#if 0
-	      run_pending_traps ();	/* because interrupt_immediately is not set */
-#endif
-	    }
-	  else
-	    lastsig = 0;
-	  if (terminating_signal && tty_modified)
-	    ttyrestore (&termsave);	/* fix terminal before exiting */
-	  CHECK_TERMSIG;
-	  eof = 1;
-	  errno = t;	/* preserve it for the error message below */
-	  break;
-	}
-
-      QUIT;		/* in case we didn't call check_signals() */
-#if defined (READLINE)
-	}
-#endif
-
-      if (retval <= 0)			/* XXX shouldn't happen */
-	check_read_timeout ();
-
-      /* XXX -- use i + mb_cur_max (at least 4) for multibyte/read_mbchar */
-      if (i + (mb_cur_max > 4 ? mb_cur_max : 4) >= size)
-	{
-	  char *t;
-	  t = (char *)xrealloc (input_string, size += 128);
-
-	  /* Only need to change unwind-protect if input_string changes */
-	  if (t != input_string)
-	    {
-	      input_string = t;
-	      remove_unwind_protect ();
-	      add_unwind_protect (xfree, input_string);
-	    }
-	}
-
-      /* If the next character is to be accepted verbatim, a backslash
-	 newline pair still disappears from the input. */
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  if (c == '\n')
-	    {
-	      if (skip_ctlesc == 0 && i > 0)
-		i--;		/* back up over the CTLESC */
-	      if (interactive && input_is_tty && raw == 0)
-		print_ps2 = 1;
-	    }
-	  else
-	    goto add_char;
-	  continue;
-	}
-
-      /* This may cause problems if IFS contains CTLESC */
-      if (c == '\\' && raw == 0)
-	{
-	  pass_next++;
-	  if (skip_ctlesc == 0)
-	    {
-	      saw_escape++;
-	      input_string[i++] = CTLESC;
-	    }
-	  continue;
-	}
-
-      if (ignore_delim == 0 && (unsigned char)c == delim)
-	break;
-
-      if (c == '\0' && delim != '\0')
-	continue;		/* skip NUL bytes in input */
-
-      if ((skip_ctlesc == 0 && c == CTLESC) || (skip_ctlnul == 0 && c == CTLNUL))
-	{
-	  saw_escape++;
-	  input_string[i++] = CTLESC;
-	}
-
-add_char:
-      input_string[i++] = c;
-      check_read_timeout ();
-
-#if defined (HANDLE_MULTIBYTE)
-      /* XXX - what if C == 127? Can DEL introduce a multibyte sequence? */
-      if (mb_cur_max > 1 && is_basic (c) == 0)
-	{
-	  input_string[i] = '\0';	/* for simplicity and debugging */
-	  /* If we got input from readline, grab the next multibyte char from
-	     rlbuf. */
-#  if defined (READLINE)
-	  if (edit)
-	    {
-	      size_t clen;
-	      clen = mbrlen (rlbuf + rlind - 1, mb_cur_max, (mbstate_t *)NULL);
-	      /* We only deal with valid multibyte sequences longer than one
-		 byte. If we get anything else, we leave the one character
-		 copied and move on to the next. */
-	      if ((int)clen > 1)
-		{
-		  memcpy (input_string+i, rlbuf+rlind, clen-1);
-		  i += clen - 1;
-		  rlind += clen - 1;
-		}
-	    }
-	  else
-#  endif
-	  if (locale_utf8locale == 0 || ((c & 0x80) != 0))
-	    i += read_mbchar (fd, input_string, i, c, unbuffered_read);
-	}
-#endif
-
-      nr++;
-
-      if (nchars > 0 && nr >= nchars)
-	break;
-    }
-  input_string[i] = '\0';
-  check_read_timeout ();
-
-#if defined (READLINE)
-  if (edit)
-    free (rlbuf);
-#endif
-
-  if (retval < 0)
-    {
-      t_errno = errno;
-      if (errno != EINTR)
-	builtin_error (_("read error: %d: %s"), fd, strerror (errno));
-      run_unwind_frame ("read_builtin");
-      return ((t_errno != EINTR) ? EXECUTION_FAILURE : 128+lastsig);
-    }
-
-  if (tmsec > 0 || tmusec > 0)
-    reset_timeout ();
-
-  if (nchars > 0 || delim != '\n')
-    {
-#if defined (READLINE)
-      if (edit)
-	{
-	  if (nchars > 0)
-	    rl_num_chars_to_read = 0;
-	  if (delim != '\n')
-	    reset_eol_delim ((char *)NULL);
-	}
-      else
-#endif
-      if (input_is_tty)
-	ttyrestore (&termsave);
-    }
-  else if (silent)
-    ttyrestore (&termsave);
-
-  if (unbuffered_read == 0)
-    zsyncfd (fd);
-
-#if defined (READLINE)
-  if (save_instream)
-    rl_instream = save_instream;	/* can't portably free it */
-#endif
-
-  discard_unwind_frame ("read_builtin");
-
-  retval = eof ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
-
-assign_vars:
-
-#if defined (ARRAY_VARS)
-  /* If -a was given, take the string read, break it into a list of words,
-     an assign them to `arrayname' in turn. */
-  if (arrayname)
-    {
-      /* pass 1 for flags arg to clear the existing array + 2 to check for a
-	 valid identifier. */
-      var = builtin_find_indexed_array (arrayname, 3);
-      if (var == 0)
-	{
-	  free (input_string);
-	  return EXECUTION_FAILURE;	/* readonly or noassign */
-	}
-
-      alist = list_string (input_string, ifs_chars, 0);
-      if (alist)
-	{
-	  if (saw_escape)
-	    dequote_list (alist);
-	  else
-	    word_list_remove_quoted_nulls (alist);
-	  assign_array_var_from_word_list (var, alist, 0);
-	  dispose_words (alist);
-	}
-      free (input_string);
-      return (retval);
-    }
-#endif /* ARRAY_VARS */ 
-
-  /* If there are no variables, save the text of the line read to the
-     variable $REPLY.  ksh93 strips leading and trailing IFS whitespace,
-     so that `read x ; echo "$x"' and `read ; echo "$REPLY"' behave the
-     same way, but I believe that the difference in behaviors is useful
-     enough to not do it.  Without the bash behavior, there is no way
-     to read a line completely without interpretation or modification
-     unless you mess with $IFS (e.g., setting it to the empty string).
-     If you disagree, change the occurrences of `#if 0' to `#if 1' below. */
-  if (list == 0)
-    {
-#if 0
-      orig_input_string = input_string;
-      for (t = input_string; ifs_chars && *ifs_chars && spctabnl(*t) && isifs(*t); t++)
-	;
-      input_string = t;
-      input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars, saw_escape);
-#endif
-
-      if (saw_escape)
-	{
-	  t = dequote_string (input_string);
-	  var = bind_variable ("REPLY", t, 0);
-	  free (t);
-	}
-      else
-	var = bind_variable ("REPLY", input_string, 0);
-      if (var == 0 || readonly_p (var) || noassign_p (var))
-	retval = EXECUTION_FAILURE;
-      else
-	VUNSETATTR (var, att_invisible);
-
-      free (input_string);
-      return (retval);
-    }
-
-  /* This code implements the Posix.2 spec for splitting the words
-     read and assigning them to variables. */
-  orig_input_string = input_string;
-
-  /* Remove IFS white space at the beginning of the input string.  If
-     $IFS is null, no field splitting is performed. */
-  for (t = input_string; ifs_chars && *ifs_chars && spctabnl(*t) && isifs(*t); t++)
-    ;
-  input_string = t;
-  for (; list->next; list = list->next)
-    {
-      varname = list->word->word;
-#if defined (ARRAY_VARS)
-      SET_VFLAGS (list->word->flags, vflags, bindflags);
-      if (legal_identifier (varname) == 0 && valid_array_reference (varname, vflags) == 0)
-#else
-      if (legal_identifier (varname) == 0)
-#endif
-	{
-	  sh_invalidid (varname);
-	  free (orig_input_string);
-	  return (EXECUTION_FAILURE);
-	}
-
-      /* If there are more variables than words read from the input,
-	 the remaining variables are set to the empty string. */
-      if (*input_string)
-	{
-	  /* This call updates INPUT_STRING. */
-	  t = get_word_from_string (&input_string, ifs_chars, &e);
-	  if (t)
-	    *e = '\0';
-	  /* Don't bother to remove the CTLESC unless we added one
-	     somewhere while reading the string. */
-	  if (t && saw_escape)
-	    {
-	      t1 = dequote_string (t);
-	      var = bind_read_variable (varname, t1, bindflags);
-	      free (t1);
-	    }
-	  else
-	    var = bind_read_variable (varname, t ? t : "", bindflags);
-	}
-      else
-	{
-	  t = (char *)0;
-	  var = bind_read_variable (varname, "", bindflags);
-	}
-
-      FREE (t);
-      if (var == 0)
-	{
-	  free (orig_input_string);
-	  return (EXECUTION_FAILURE);
-	}
-
-      stupidly_hack_special_variables (varname);
-      VUNSETATTR (var, att_invisible);
-    }
-
-  /* Now assign the rest of the line to the last variable argument. */
-#if defined (ARRAY_VARS)
-  SET_VFLAGS (list->word->flags, vflags, bindflags);
-  if (legal_identifier (list->word->word) == 0 && valid_array_reference (list->word->word, vflags) == 0)
-#else
-  if (legal_identifier (list->word->word) == 0)
-#endif
-    {
-      sh_invalidid (list->word->word);
-      free (orig_input_string);
-      return (EXECUTION_FAILURE);
-    }
-
-#if 0
-  /* This has to be done this way rather than using string_list
-     and list_string because Posix.2 says that the last variable gets the
-     remaining words and their intervening separators. */
-  input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars, saw_escape);
-#else
-  /* Check whether or not the number of fields is exactly the same as the
-     number of variables. */
-  tofree = NULL;
-  if (*input_string)
-    {
-      t1 = input_string;
-      t = get_word_from_string (&input_string, ifs_chars, &e);
-      if (*input_string == 0)
-	tofree = input_string = t;
-      else
-	{
-	  input_string = strip_trailing_ifs_whitespace (t1, ifs_chars, saw_escape);
-	  tofree = t;
-	}
-    }
-#endif
-
-  if (saw_escape && input_string && *input_string)
-    {
-      t = dequote_string (input_string);
-      var = bind_read_variable (list->word->word, t, bindflags);
-      free (t);
-    }
-  else
-    var = bind_read_variable (list->word->word, input_string ? input_string : "", bindflags);
-
-  if (var)
-    {
-      stupidly_hack_special_variables (list->word->word);
-      VUNSETATTR (var, att_invisible);
-    }
-  else
-    retval = EXECUTION_FAILURE;
-
-  FREE (tofree);
-  free (orig_input_string);
-
-  return (retval);
-}
-
-static SHELL_VAR *
-bind_read_variable (name, value, flags)
-     char *name, *value;
-     int flags;
-{
-  SHELL_VAR *v;
-
-  v = builtin_bind_variable (name, value, flags);
-  return (v == 0 ? v
-		 : ((readonly_p (v) || noassign_p (v)) ? (SHELL_VAR *)NULL : v));
-}
-
-#if defined (HANDLE_MULTIBYTE)
-static int
-read_mbchar (fd, string, ind, ch, unbuffered)
-     int fd;
-     char *string;
-     int ind, ch, unbuffered;
-{
-  char mbchar[MB_LEN_MAX + 1];
-  int i, n, r;
-  char c;
-  size_t ret;
-  mbstate_t ps, ps_back;
-  wchar_t wc;
-
-  memset (&ps, '\0', sizeof (mbstate_t));
-  memset (&ps_back, '\0', sizeof (mbstate_t));
-  
-  mbchar[0] = ch;
-  i = 1;
-  for (n = 0; n <= MB_LEN_MAX; n++)
-    {
-      ps_back = ps;
-      ret = mbrtowc (&wc, mbchar, i, &ps);
-      if (ret == (size_t)-2)
-	{
-	  ps = ps_back;
-
-	  /* We don't want to be interrupted during a multibyte char read */
-	  if (unbuffered == 2)
-	    r = zreadn (fd, &c, 1);
-	  else if (unbuffered)
-	    r = zread (fd, &c, 1);
-	  else
-	    r = zreadc (fd, &c);
-	  if (r <= 0)
-	    goto mbchar_return;
-	  mbchar[i++] = c;	
-	  continue;
-	}
-      else if (ret == (size_t)-1 || ret == (size_t)0 || ret > (size_t)0)
-	break;
-    }
-
-mbchar_return:
-  if (i > 1)	/* read a multibyte char */
-    /* mbchar[0] is already string[ind-1] */
-    for (r = 1; r < i; r++)
-      string[ind+r-1] = mbchar[r];
-  return i - 1;
-}
-#endif
-
-
-static void
-ttyrestore (ttp)
-     struct ttsave *ttp;
-{
-  ttsetattr (ttp->fd, &(ttp->attrs));
-  tty_modified = 0;
-}
-
-void
-read_tty_cleanup ()
-{
-  if (tty_modified)
-    ttyrestore (&termsave);
-}
-
-int
-read_tty_modified ()
-{
-  return (tty_modified);
-}
-
-#if defined (READLINE)
-static rl_completion_func_t *old_attempted_completion_function = 0;
-static rl_hook_func_t *old_startup_hook;
-static char *deftext;
-
-static void
-reset_attempted_completion_function (cp)
-     char *cp;
-{
-  if (rl_attempted_completion_function == 0 && old_attempted_completion_function)
-    rl_attempted_completion_function = old_attempted_completion_function;
-}
-
-static int
-set_itext ()
-{
-  int r1, r2;
-
-  r1 = r2 = 0;
-  if (old_startup_hook)
-    r1 = (*old_startup_hook) ();
-  if (deftext)
-    {
-      r2 = rl_insert_text (deftext);
-      deftext = (char *)NULL;
-      rl_startup_hook = old_startup_hook;
-      old_startup_hook = (rl_hook_func_t *)NULL;
-    }
-  return (r1 || r2);
-}
-
-static char *
-edit_line (p, itext)
-     char *p;
-     char *itext;
-{
-  char *ret;
-  int len;
-
-  if (bash_readline_initialized == 0)
-    initialize_readline ();
-
-  old_attempted_completion_function = rl_attempted_completion_function;
-  rl_attempted_completion_function = (rl_completion_func_t *)NULL;
-  bashline_set_event_hook ();
-  if (itext)
-    {
-      old_startup_hook = rl_startup_hook;
-      rl_startup_hook = set_itext;
-      deftext = itext;
-    }
-
-  ret = readline (p);
-
-  rl_attempted_completion_function = old_attempted_completion_function;
-  old_attempted_completion_function = (rl_completion_func_t *)NULL;
-  bashline_reset_event_hook ();
-
-  if (ret == 0)
-    {
-      if (RL_ISSTATE (RL_STATE_TIMEOUT))
-	{
-	  sigalrm (SIGALRM);		/* simulate receiving SIGALRM */
-	  check_read_timeout ();
-	}
-      return ret;
-    }
-
-  len = strlen (ret);
-  ret = (char *)xrealloc (ret, len + 2);
-  ret[len++] = delim;
-  ret[len] = '\0';
-  return ret;
-}
-
-static void
-set_readline_timeout (t, sec, usec)
-     sh_timer *t;
-     time_t sec;
-     long usec;
-{
-  t->tmout.tv_sec = sec;
-  t->tmout.tv_usec = usec;
-  rl_set_timeout (sec, usec);
-}
-
-static int old_delim_ctype;
-static rl_command_func_t *old_delim_func;
-static int old_newline_ctype;
-static rl_command_func_t *old_newline_func;
-
-static unsigned char delim_char;
-
-static void
-set_eol_delim (c)
-     int c;
-{
-  Keymap cmap;
-
-  if (bash_readline_initialized == 0)
-    initialize_readline ();
-  cmap = rl_get_keymap ();
-
-  /* Save the old delimiter char binding */
-  old_newline_ctype = cmap[RETURN].type;
-  old_newline_func =  cmap[RETURN].function;
-  old_delim_ctype = cmap[c].type;
-  old_delim_func = cmap[c].function;
-
-  /* Change newline to self-insert */
-  cmap[RETURN].type = ISFUNC;
-  cmap[RETURN].function = rl_insert;
-
-  /* Bind the delimiter character to accept-line. */
-  cmap[c].type = ISFUNC;
-  cmap[c].function = rl_newline;
-
-  delim_char = c;
-}
-
-static void
-reset_eol_delim (cp)
-     char *cp;
-{
-  Keymap cmap;
-
-  cmap = rl_get_keymap ();
-
-  cmap[RETURN].type = old_newline_ctype;
-  cmap[RETURN].function = old_newline_func;
-
-  cmap[delim_char].type = old_delim_ctype;
-  cmap[delim_char].function = old_delim_func;
-}
-#endif
diff --git a/third_party/bash/builtins_return.c b/third_party/bash/builtins_return.c
deleted file mode 100644
index 7f5fbd289..000000000
--- a/third_party/bash/builtins_return.c
+++ /dev/null
@@ -1,40 +0,0 @@
-/* return.c, created from return.def. */
-#line 22 "./return.def"
-
-#line 36 "./return.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-/* If we are executing a user-defined function then exit with the value
-   specified as an argument.  if no argument is given, then the last
-   exit status is used. */
-int
-return_builtin (list)
-     WORD_LIST *list;
-{
-  CHECK_HELPOPT (list);
-
-  return_catch_value = get_exitstat (list);
-
-  if (return_catch_flag)
-    sh_longjmp (return_catch, 1);
-  else
-    {
-      builtin_error (_("can only `return' from a function or sourced script"));
-      return (EX_USAGE);
-    }
-}
diff --git a/third_party/bash/builtins_set.c b/third_party/bash/builtins_set.c
deleted file mode 100644
index ed1db4508..000000000
--- a/third_party/bash/builtins_set.c
+++ /dev/null
@@ -1,890 +0,0 @@
-/* set.c, created from set.def. */
-#line 22 "./set.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "parser.h"
-#include "flags.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-#if defined (READLINE)
-#  include "input.h"
-#  include "bashline.h"
-#  include "third_party/readline/readline.h"
-#endif
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#endif
-
-#line 153 "./set.def"
-
-typedef int setopt_set_func_t PARAMS((int, char *));
-typedef int setopt_get_func_t PARAMS((char *));
-
-static int find_minus_o_option PARAMS((char *));
-
-static void print_minus_o_option PARAMS((char *, int, int));
-static void print_all_shell_variables PARAMS((void));
-
-static int set_ignoreeof PARAMS((int, char *));
-static int set_posix_mode PARAMS((int, char *));
-
-#if defined (READLINE)
-static int set_edit_mode PARAMS((int, char *));
-static int get_edit_mode PARAMS((char *));
-#endif
-
-#if defined (HISTORY)
-static int bash_set_history PARAMS((int, char *));
-#endif
-
-static const char * const on = "on";
-static const char * const off = "off";
-
-static int previous_option_value;
-
-/* A struct used to match long options for set -o to the corresponding
-   option letter or internal variable.  The functions can be called to
-   dynamically generate values.  If you add a new variable name here
-   that doesn't have a corresponding single-character option letter, make
-   sure to set the value appropriately in reset_shell_options. */
-const struct {
-  char *name;
-  int letter;
-  int *variable;
-  setopt_set_func_t *set_func;
-  setopt_get_func_t *get_func;
-} o_options[] = {
-  { "allexport",  'a', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL },
-#if defined (BRACE_EXPANSION)
-  { "braceexpand",'B', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-#endif
-#if defined (READLINE)
-  { "emacs",     '\0', (int *)NULL, set_edit_mode, get_edit_mode },
-#endif
-  { "errexit",	  'e', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-  { "errtrace",	  'E', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-  { "functrace",  'T', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-  { "hashall",    'h', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-#if defined (BANG_HISTORY)
-  { "histexpand", 'H', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-#endif /* BANG_HISTORY */
-#if defined (HISTORY)
-  { "history",   '\0', &enable_history_list, bash_set_history, (setopt_get_func_t *)NULL },
-#endif
-  { "ignoreeof", '\0', &ignoreeof, set_ignoreeof, (setopt_get_func_t *)NULL },
-  { "interactive-comments", '\0', &interactive_comments, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL },
-  { "keyword",    'k', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-#if defined (JOB_CONTROL)
-  { "monitor",	  'm', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-#endif
-  { "noclobber",  'C', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-  { "noexec",	  'n', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-  { "noglob",	  'f', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-#if defined (HISTORY)
-  { "nolog",     '\0', &dont_save_function_defs, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL },
-#endif
-#if defined (JOB_CONTROL)
-  { "notify",	  'b', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-#endif /* JOB_CONTROL */
-  { "nounset",	  'u', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-  { "onecmd",	  't', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL },
-  { "physical",   'P', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-  { "pipefail",  '\0', &pipefail_opt, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-  { "posix",     '\0', &posixly_correct, set_posix_mode, (setopt_get_func_t *)NULL },
-  { "privileged", 'p', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-  { "verbose",	  'v', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-#if defined (READLINE)
-  { "vi",        '\0', (int *)NULL, set_edit_mode, get_edit_mode },
-#endif
-  { "xtrace",	  'x', (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL  },
-  {(char *)NULL, 0 , (int *)NULL, (setopt_set_func_t *)NULL, (setopt_get_func_t *)NULL },
-};
-
-#define N_O_OPTIONS	(sizeof (o_options) / sizeof (o_options[0]))
-
-#define GET_BINARY_O_OPTION_VALUE(i, name) \
-  ((o_options[i].get_func) ? (*o_options[i].get_func) (name) \
-			   : (*o_options[i].variable))
-
-#define SET_BINARY_O_OPTION_VALUE(i, onoff, name) \
-  ((o_options[i].set_func) ? (*o_options[i].set_func) (onoff, name) \
-			   : (*o_options[i].variable = (onoff == FLAG_ON)))
-
-static int
-find_minus_o_option (name)
-     char *name;
-{
-  register int i;
-
-  for (i = 0; o_options[i].name; i++)
-    if (STREQ (name, o_options[i].name))
-      return i;
-  return -1;
-}
-
-int
-minus_o_option_value (name)
-     char *name;
-{
-  register int	i;
-  int *on_or_off;
-
-  i = find_minus_o_option (name);
-  if (i < 0)
-    return (-1);
-
-  if (o_options[i].letter)
-    {
-      on_or_off = find_flag (o_options[i].letter);
-      return ((on_or_off == FLAG_UNKNOWN) ? -1 : *on_or_off);
-    }
-  else
-    return (GET_BINARY_O_OPTION_VALUE (i, name));
-}
-
-#define MINUS_O_FORMAT "%-15s\t%s\n"
-
-static void
-print_minus_o_option (name, value, pflag)
-     char *name;
-     int value, pflag;
-{
-  if (pflag == 0)
-    printf (MINUS_O_FORMAT, name, value ? on : off);
-  else
-    printf ("set %co %s\n", value ? '-' : '+', name);
-}
-
-void
-list_minus_o_opts (mode, reusable)
-     int mode, reusable;
-{
-  register int	i;
-  int *on_or_off, value;
-
-  for (i = 0; o_options[i].name; i++)
-    {
-      if (o_options[i].letter)
-	{
-	  value = 0;
-	  on_or_off = find_flag (o_options[i].letter);
-	  if (on_or_off == FLAG_UNKNOWN)
-	    on_or_off = &value;
-	  if (mode == -1 || mode == *on_or_off)
-	    print_minus_o_option (o_options[i].name, *on_or_off, reusable);
-	}
-      else
-	{
-	  value = GET_BINARY_O_OPTION_VALUE (i, o_options[i].name);
-	  if (mode == -1 || mode == value)
-	    print_minus_o_option (o_options[i].name, value, reusable);
-	}
-    }
-}
-
-char **
-get_minus_o_opts ()
-{
-  char **ret;
-  int i;
-
-  ret = strvec_create (N_O_OPTIONS + 1);
-  for (i = 0; o_options[i].name; i++)
-    ret[i] = o_options[i].name;
-  ret[i] = (char *)NULL;
-  return ret;
-}
-
-char *
-get_current_options ()
-{
-  char *temp;
-  int i, posixopts;
-
-  posixopts = num_posix_options ();	/* shopts modified by posix mode */
-  /* Make the buffer big enough to hold the set -o options and the shopt
-     options modified by posix mode. */
-  temp = (char *)xmalloc (1 + N_O_OPTIONS + posixopts);
-  for (i = 0; o_options[i].name; i++)
-    {
-      if (o_options[i].letter)
-	temp[i] = *(find_flag (o_options[i].letter));
-      else
-	temp[i] = GET_BINARY_O_OPTION_VALUE (i, o_options[i].name);
-    }
-
-  /* Add the shell options that are modified by posix mode to the end of the
-     bitmap. They will be handled in set_current_options() */
-  get_posix_options (temp+i);
-  temp[i+posixopts] = '\0';
-  return (temp);
-}
-
-void
-set_current_options (bitmap)
-     const char *bitmap;
-{
-  int i, v, cv, *on_or_off;
-
-  if (bitmap == 0)
-    return;
-
-  for (i = 0; o_options[i].name; i++)
-    {
-      v = bitmap[i] ? FLAG_ON : FLAG_OFF;
-      if (o_options[i].letter)
-	{
-	  /* We should not get FLAG_UNKNOWN here */
-	  on_or_off = find_flag (o_options[i].letter);
-	  cv = *on_or_off ? FLAG_ON : FLAG_OFF;
-	  if (v != cv)
-	    change_flag (o_options[i].letter, v);
-	}
-      else
-	{
-	  cv = GET_BINARY_O_OPTION_VALUE (i, o_options[i].name);
-	  cv = cv ? FLAG_ON : FLAG_OFF;
-	  if (v != cv)
-	    SET_BINARY_O_OPTION_VALUE (i, v, o_options[i].name);
-	}
-    }
-
-  /* Now reset the variables changed by posix mode */
-  set_posix_options (bitmap+i);
-}
-
-static int
-set_ignoreeof (on_or_off, option_name)
-     int on_or_off;
-     char *option_name;
-{
-  ignoreeof = on_or_off == FLAG_ON;
-  unbind_variable_noref ("ignoreeof");
-  if (ignoreeof)
-    bind_variable ("IGNOREEOF", "10", 0); 
-  else
-    unbind_variable_noref ("IGNOREEOF");
-  sv_ignoreeof ("IGNOREEOF");
-  return 0;
-}
-
-static int
-set_posix_mode (on_or_off, option_name)
-     int on_or_off;
-     char *option_name;
-{
-  /* short-circuit on no-op */
-  if ((on_or_off == FLAG_ON && posixly_correct) ||
-      (on_or_off == FLAG_OFF && posixly_correct == 0))
-    return 0;
-
-  posixly_correct = on_or_off == FLAG_ON;
-  if (posixly_correct == 0)
-    unbind_variable_noref ("POSIXLY_CORRECT");
-  else
-    bind_variable ("POSIXLY_CORRECT", "y", 0);
-  sv_strict_posix ("POSIXLY_CORRECT");
-  return (0);
-}
-
-#if defined (READLINE)
-/* Magic.  This code `knows' how readline handles rl_editing_mode. */
-static int
-set_edit_mode (on_or_off, option_name)
-     int on_or_off;
-     char *option_name;
-{
-  int isemacs;
-
-  if (on_or_off == FLAG_ON)
-    {
-      rl_variable_bind ("editing-mode", option_name);
-
-      if (interactive)
-	with_input_from_stdin ();
-      no_line_editing = 0;
-    }
-  else
-    {
-      isemacs = rl_editing_mode == 1;
-      if ((isemacs && *option_name == 'e') || (!isemacs && *option_name == 'v'))
-	{
-	  if (interactive)
-	    with_input_from_stream (stdin, "stdin");
-	  no_line_editing = 1;
-	}
-    }
-  return 1-no_line_editing;
-}
-
-static int
-get_edit_mode (name)
-     char *name;
-{
-  return (*name == 'e' ? no_line_editing == 0 && rl_editing_mode == 1
-		       : no_line_editing == 0 && rl_editing_mode == 0);
-}
-#endif /* READLINE */
-
-#if defined (HISTORY)
-static int
-bash_set_history (on_or_off, option_name)
-     int on_or_off;
-     char *option_name;
-{
-  if (on_or_off == FLAG_ON)
-    {
-      enable_history_list = 1;
-      bash_history_enable ();
-      if (history_lines_this_session == 0)
-	load_history ();
-    }
-  else
-    {
-      enable_history_list = 0;
-      bash_history_disable ();
-    }
-  return (1 - enable_history_list);
-}
-#endif
-
-int
-set_minus_o_option (on_or_off, option_name)
-     int on_or_off;
-     char *option_name;
-{
-  register int i;
-
-  i = find_minus_o_option (option_name);
-  if (i < 0)
-    {
-      sh_invalidoptname (option_name);
-      return (EX_USAGE);
-    }
-
-  if (o_options[i].letter == 0)
-    {
-      previous_option_value = GET_BINARY_O_OPTION_VALUE (i, o_options[i].name);
-      SET_BINARY_O_OPTION_VALUE (i, on_or_off, option_name);
-      return (EXECUTION_SUCCESS);
-    }
-  else
-    {
-      if ((previous_option_value = change_flag (o_options[i].letter, on_or_off)) == FLAG_ERROR)
-	{
-	  sh_invalidoptname (option_name);
-	  return (EXECUTION_FAILURE);
-	}
-      else
-	return (EXECUTION_SUCCESS);
-    }
-}
-
-static void
-print_all_shell_variables ()
-{
-  SHELL_VAR **vars;
-
-  vars = all_shell_variables ();
-  if (vars)
-    {
-      print_var_list (vars);
-      free (vars);
-    }
-
-  /* POSIX.2 does not allow function names and definitions to be output when
-     `set' is invoked without options (PASC Interp #202). */
-  if (posixly_correct == 0)
-    {
-      vars = all_shell_functions ();
-      if (vars)
-	{
-	  print_func_list (vars);
-	  free (vars);
-	}
-    }
-}
-
-void
-set_shellopts ()
-{
-  char *value;
-  char tflag[N_O_OPTIONS];
-  int vsize, i, vptr, *ip, exported;
-  SHELL_VAR *v;
-
-  for (vsize = i = 0; o_options[i].name; i++)
-    {
-      tflag[i] = 0;
-      if (o_options[i].letter)
-	{
-	  ip = find_flag (o_options[i].letter);
-	  if (ip && *ip)
-	    {
-	      vsize += strlen (o_options[i].name) + 1;
-	      tflag[i] = 1;
-	    }
-	}
-      else if (GET_BINARY_O_OPTION_VALUE (i, o_options[i].name))
-	{
-	  vsize += strlen (o_options[i].name) + 1;
-	  tflag[i] = 1;
-	}
-    }
-
-  value = (char *)xmalloc (vsize + 1);
-
-  for (i = vptr = 0; o_options[i].name; i++)
-    {
-      if (tflag[i])
-	{
-	  strcpy (value + vptr, o_options[i].name);
-	  vptr += strlen (o_options[i].name);
-	  value[vptr++] = ':';
-	}
-    }
-
-  if (vptr)
-    vptr--;			/* cut off trailing colon */
-  value[vptr] = '\0';
-
-  v = find_variable ("SHELLOPTS");
-
-  /* Turn off the read-only attribute so we can bind the new value, and
-     note whether or not the variable was exported. */
-  if (v)
-    {
-      VUNSETATTR (v, att_readonly);
-      exported = exported_p (v);
-    }
-  else
-    exported = 0;
-
-  v = bind_variable ("SHELLOPTS", value, 0);
-
-  /* Turn the read-only attribute back on, and turn off the export attribute
-     if it was set implicitly by mark_modified_vars and SHELLOPTS was not
-     exported before we bound the new value. */
-  VSETATTR (v, att_readonly);
-  if (mark_modified_vars && exported == 0 && exported_p (v))
-    VUNSETATTR (v, att_exported);
-
-  free (value);
-}
-
-void
-parse_shellopts (value)
-     char *value;
-{
-  char *vname;
-  int vptr;
-
-  vptr = 0;
-  while (vname = extract_colon_unit (value, &vptr))
-    {
-      set_minus_o_option (FLAG_ON, vname);
-      free (vname);
-    }
-}
-
-void
-initialize_shell_options (no_shellopts)
-     int no_shellopts;
-{
-  char *temp;
-  SHELL_VAR *var;
-
-  if (no_shellopts == 0)
-    {
-      var = find_variable ("SHELLOPTS");
-      /* set up any shell options we may have inherited. */
-      if (var && imported_p (var))
-	{
-	  temp = (array_p (var) || assoc_p (var)) ? (char *)NULL : savestring (value_cell (var));
-	  if (temp)
-	    {
-	      parse_shellopts (temp);
-	      free (temp);
-	    }
-	}
-    }
-
-  /* Set up the $SHELLOPTS variable. */
-  set_shellopts ();
-}
-
-/* Reset the values of the -o options that are not also shell flags.  This is
-   called from execute_cmd.c:initialize_subshell() when setting up a subshell
-   to run an executable shell script without a leading `#!'. */
-void
-reset_shell_options ()
-{
-  pipefail_opt = 0;
-  ignoreeof = 0;
-
-#if defined (STRICT_POSIX)
-  posixly_correct = 1;
-#else
-  posixly_correct = 0;
-#endif
-#if defined (HISTORY)
-  dont_save_function_defs = 0;
-  remember_on_history = enable_history_list = 1;	/* XXX */
-#endif
-}
-
-/* Set some flags from the word values in the input list.  If LIST is empty,
-   then print out the values of the variables instead.  If LIST contains
-   non-flags, then set $1 - $9 to the successive words of LIST. */
-int
-set_builtin (list)
-     WORD_LIST *list;
-{
-  int on_or_off, flag_name, force_assignment, opts_changed, rv, r;
-  register char *arg;
-  char s[3];
-
-  if (list == 0)
-    {
-      print_all_shell_variables ();
-      return (sh_chkwrite (EXECUTION_SUCCESS));
-    }
-
-  /* Check validity of flag arguments. */
-  rv = EXECUTION_SUCCESS;
-  reset_internal_getopt ();
-  while ((flag_name = internal_getopt (list, optflags)) != -1)
-    {
-      switch (flag_name)
-	{
-	  case 'i':	/* don't allow set -i */
-	    s[0] = list_opttype;
-	    s[1] = 'i';
-	    s[2] = '\0';
-	    sh_invalidopt (s);
-	    builtin_usage ();
-	    return (EX_USAGE);
-	  CASE_HELPOPT;
-	  case '?':
-	    builtin_usage ();
-	    return (list_optopt == '?' ? EXECUTION_SUCCESS : EX_USAGE);
-	  default:
-	    break;
-	}
-    }
-    
-  /* Do the set command.  While the list consists of words starting with
-     '-' or '+' treat them as flags, otherwise, start assigning them to
-     $1 ... $n. */
-  for (force_assignment = opts_changed = 0; list; )
-    {
-      arg = list->word->word;
-
-      /* If the argument is `--' or `-' then signal the end of the list
-	 and remember the remaining arguments. */
-      if (arg[0] == '-' && (!arg[1] || (arg[1] == '-' && !arg[2])))
-	{
-	  list = list->next;
-
-	  /* `set --' unsets the positional parameters. */
-	  if (arg[1] == '-')
-	    force_assignment = 1;
-
-	  /* Until told differently, the old shell behaviour of
-	     `set - [arg ...]' being equivalent to `set +xv [arg ...]'
-	     stands.  Posix.2 says the behaviour is marked as obsolescent. */
-	  else
-	    {
-	      change_flag ('x', '+');
-	      change_flag ('v', '+');
-	      opts_changed = 1;
-	    }
-
-	  break;
-	}
-
-      if ((on_or_off = *arg) && (on_or_off == '-' || on_or_off == '+'))
-	{
-	  while (flag_name = *++arg)
-	    {
-	      if (flag_name == '?')
-		{
-		  builtin_usage ();
-		  return (EXECUTION_SUCCESS);
-		}
-	      else if (flag_name == 'o') /* -+o option-name */
-		{
-		  char *option_name;
-		  WORD_LIST *opt;
-
-		  opt = list->next;
-
-		  if (opt == 0)
-		    {
-		      list_minus_o_opts (-1, (on_or_off == '+'));
-		      rv = sh_chkwrite (rv);
-		      continue;
-		    }
-
-		  option_name = opt->word->word;
-
-		  if (option_name == 0 || *option_name == '\0' ||
-		      *option_name == '-' || *option_name == '+')
-		    {
-		      list_minus_o_opts (-1, (on_or_off == '+'));
-		      continue;
-		    }
-		  list = list->next; /* Skip over option name. */
-
-		  opts_changed = 1;
-		  if ((r = set_minus_o_option (on_or_off, option_name)) != EXECUTION_SUCCESS)
-		    {
-		      set_shellopts ();
-		      return (r);
-		    }
-		}
-	      else if (change_flag (flag_name, on_or_off) == FLAG_ERROR)
-		{
-		  s[0] = on_or_off;
-		  s[1] = flag_name;
-		  s[2] = '\0';
-		  sh_invalidopt (s);
-		  builtin_usage ();
-		  set_shellopts ();
-		  return (EXECUTION_FAILURE);
-		}
-	      opts_changed = 1;
-	    }
-	}
-      else
-	{
-	  break;
-	}
-      list = list->next;
-    }
-
-  /* Assigning $1 ... $n */
-  if (list || force_assignment)
-    remember_args (list, 1);
-  /* Set up new value of $SHELLOPTS */
-  if (opts_changed)
-    set_shellopts ();
-  return (rv);
-}
-
-#line 830 "./set.def"
-
-#define NEXT_VARIABLE()	any_failed++; list = list->next; continue;
-
-int
-unset_builtin (list)
-  WORD_LIST *list;
-{
-  int unset_function, unset_variable, unset_array, opt, nameref, any_failed;
-  int global_unset_func, global_unset_var, vflags, base_vflags, valid_id;
-  char *name, *tname;
-
-  unset_function = unset_variable = unset_array = nameref = any_failed = 0;
-  global_unset_func = global_unset_var = 0;
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "fnv")) != -1)
-    {
-      switch (opt)
-	{
-	case 'f':
-	  global_unset_func = 1;
-	  break;
-	case 'v':
-	  global_unset_var = 1;
-	  break;
-	case 'n':
-	  nameref = 1;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-
-  list = loptend;
-
-  if (global_unset_func && global_unset_var)
-    {
-      builtin_error (_("cannot simultaneously unset a function and a variable"));
-      return (EXECUTION_FAILURE);
-    }
-  else if (unset_function && nameref)
-    nameref = 0;
-
-#if defined (ARRAY_VARS)
-  base_vflags = assoc_expand_once ? VA_NOEXPAND : 0;
-#endif
-
-  while (list)
-    {
-      SHELL_VAR *var;
-      int tem;
-#if defined (ARRAY_VARS)
-      char *t;
-#endif
-
-      name = list->word->word;
-
-      unset_function = global_unset_func;
-      unset_variable = global_unset_var;
-
-#if defined (ARRAY_VARS)
-      vflags = builtin_arrayref_flags (list->word, base_vflags);
-#endif
-
-#if defined (ARRAY_VARS)
-      unset_array = 0;
-      /* XXX valid array reference second arg was 0 */
-      if (!unset_function && nameref == 0 && tokenize_array_reference (name, vflags, &t))
-	unset_array = 1;
-#endif
-      /* Get error checking out of the way first.  The low-level functions
-	 just perform the unset, relying on the caller to verify. */
-      valid_id = legal_identifier (name);
-
-      /* Whether or not we are in posix mode, if neither -f nor -v appears,
-	 skip over trying to unset variables with invalid names and just
-	 treat them as potential shell function names. */
-      if (global_unset_func == 0 && global_unset_var == 0 && valid_id == 0)
-	{
-	  unset_variable = unset_array = 0;
-	  unset_function = 1;
-	}
-
-      /* Bash allows functions with names which are not valid identifiers
-	 to be created when not in posix mode, so check only when in posix
-	 mode when unsetting a function. */
-      if (unset_function == 0 && valid_id == 0)
-	{
-	  sh_invalidid (name);
-	  NEXT_VARIABLE ();
-	}
-
-      /* Search for functions here if -f supplied or if NAME cannot be a
-	 variable name. */
-      var = unset_function ? find_function (name)
-			   : (nameref ? find_variable_last_nameref (name, 0) : find_variable (name));
-
-      /* Some variables (but not functions yet) cannot be unset, period. */
-      if (var && unset_function == 0 && non_unsettable_p (var))
-	{
-	  builtin_error (_("%s: cannot unset"), name);
-	  NEXT_VARIABLE ();
-	}
-
-      /* if we have a nameref we want to use it */
-      if (var && unset_function == 0 && nameref == 0 && STREQ (name, name_cell(var)) == 0)
-	name = name_cell (var);
-
-      /* Posix.2 says try variables first, then functions.  If we would
-	 find a function after unsuccessfully searching for a variable,
-	 note that we're acting on a function now as if -f were
-	 supplied.  The readonly check below takes care of it. */
-      if (var == 0 && nameref == 0 &&  unset_variable == 0 && unset_function == 0)
-	{
-	  if (var = find_function (name))
-	    unset_function = 1;
-	}
-
-      /* Posix.2 says that unsetting readonly variables is an error. */
-      if (var && readonly_p (var))
-	{
-	  builtin_error (_("%s: cannot unset: readonly %s"),
-			 var->name, unset_function ? "function" : "variable");
-	  NEXT_VARIABLE ();
-	}
-
-      /* Unless the -f option is supplied, the name refers to a variable. */
-#if defined (ARRAY_VARS)
-      if (var && unset_array)
-	{
-	  if (shell_compatibility_level <= 51)
-	    vflags |= VA_ALLOWALL;
-
-	  /* Let unbind_array_element decide what to do with non-array vars */
-	  tem = unbind_array_element (var, t, vflags);	/* XXX new third arg */
-	  if (tem == -2 && array_p (var) == 0 && assoc_p (var) == 0)
-	    {
-	      builtin_error (_("%s: not an array variable"), var->name);
-	      NEXT_VARIABLE ();
-	    }
-	  else if (tem < 0)
-	    any_failed++;
-	}
-      else
-#endif /* ARRAY_VARS */
-      /* If we're trying to unset a nameref variable whose value isn't a set
-	 variable, make sure we still try to unset the nameref's value */
-      if (var == 0 && nameref == 0 && unset_function == 0)
-	{
-	  var = find_variable_last_nameref (name, 0);
-	  if (var && nameref_p (var))
-	    {
-#if defined (ARRAY_VARS)
-	      if (valid_array_reference (nameref_cell (var), 0))
-		{
-		  int len;
-
-		  tname = savestring (nameref_cell (var));
-		  if (var = array_variable_part (tname, 0, &t, &len))
-		    {
-		      /* change to what unbind_array_element now expects */
-		      if (t[len - 1] == ']')
-			t[len - 1] = 0;
-		      tem = unbind_array_element (var, t, vflags);	/* XXX new third arg */
-		    }
-		  free (tname);
-		}
-	      else
-#endif
-		tem = unbind_variable (nameref_cell (var));
-	    }
-	  else
-	    tem = unbind_variable (name);
-	}
-      else
-	tem = unset_function ? unbind_func (name) : (nameref ? unbind_nameref (name) : unbind_variable (name));
-
-      /* This is what Posix.2 says:  ``If neither -f nor -v
-	 is specified, the name refers to a variable; if a variable by
-	 that name does not exist, a function by that name, if any,
-	 shall be unset.'' */
-      if (tem == -1 && nameref == 0 && unset_function == 0 && unset_variable == 0)
-	tem = unbind_func (name);
-
-      name = list->word->word;		/* reset above for namerefs */
-
-      /* SUSv3, POSIX.1-2001 say:  ``Unsetting a variable or function that
-	 was not previously set shall not be considered an error.'' */
-
-      if (unset_function == 0)
-	stupidly_hack_special_variables (name);
-
-      list = list->next;
-    }
-
-  return (any_failed ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
-}
diff --git a/third_party/bash/builtins_setattr.c b/third_party/bash/builtins_setattr.c
deleted file mode 100644
index 8a9ccefa4..000000000
--- a/third_party/bash/builtins_setattr.c
+++ /dev/null
@@ -1,616 +0,0 @@
-/* setattr.c, created from setattr.def. */
-#line 22 "./setattr.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "flags.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-extern sh_builtin_func_t *this_shell_builtin;
-
-#ifdef ARRAY_VARS
-extern int declare_builtin PARAMS((WORD_LIST *));
-#endif
-
-#define READONLY_OR_EXPORT \
-  (this_shell_builtin == readonly_builtin || this_shell_builtin == export_builtin)
-
-#line 69 "./setattr.def"
-
-/* For each variable name in LIST, make that variable appear in the
-   environment passed to simple commands.  If there is no LIST, then
-   print all such variables.  An argument of `-n' says to remove the
-   exported attribute from variables named in LIST.  An argument of
-  -f indicates that the names present in LIST refer to functions. */
-int
-export_builtin (list)
-     register WORD_LIST *list;
-{
-  return (set_or_show_attributes (list, att_exported, 0));
-}
-
-#line 103 "./setattr.def"
-
-/* For each variable name in LIST, make that variable readonly.  Given an
-   empty LIST, print out all existing readonly variables. */
-int
-readonly_builtin (list)
-     register WORD_LIST *list;
-{
-  return (set_or_show_attributes (list, att_readonly, 0));
-}
-
-#if defined (ARRAY_VARS)
-#  define ATTROPTS	"aAfnp"
-#else
-#  define ATTROPTS	"fnp"
-#endif
-
-/* For each variable name in LIST, make that variable have the specified
-   ATTRIBUTE.  An arg of `-n' says to remove the attribute from the the
-   remaining names in LIST (doesn't work for readonly). */
-int
-set_or_show_attributes (list, attribute, nodefs)
-     register WORD_LIST *list;
-     int attribute, nodefs;
-{
-  register SHELL_VAR *var;
-  int assign, undo, any_failed, assign_error, opt;
-  int functions_only, arrays_only, assoc_only;
-  int aflags;
-  char *name;
-#if defined (ARRAY_VARS)
-  WORD_LIST *nlist, *tlist;
-  WORD_DESC *w;
-  char optw[8];
-  int opti;
-#endif
-
-  functions_only = arrays_only = assoc_only = 0;
-  undo = any_failed = assign_error = 0;
-  /* Read arguments from the front of the list. */
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, ATTROPTS)) != -1)
-    {
-      switch (opt)
-	{
-	  case 'n':
-	    undo = 1;
-	    break;
-	  case 'f':
-	    functions_only = 1;
-	    break;
-#if defined (ARRAY_VARS)
-	  case 'a':
-	    arrays_only = 1;
-	    break;
-	  case 'A':
-	    assoc_only = 1;
-	    break;
-#endif
-	  case 'p':
-	    break;
-	  CASE_HELPOPT;
-	  default:
-	    builtin_usage ();
-	    return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  if (list)
-    {
-      if (attribute & att_exported)
-	array_needs_making = 1;
-
-      /* Cannot undo readonly status, silently disallowed. */
-      if (undo && (attribute & att_readonly))
-	attribute &= ~att_readonly;
-
-      while (list)
-	{
-	  name = list->word->word;
-
-	  if (functions_only)		/* xxx -f name */
-	    {
-	      var = find_function (name);
-	      if (var == 0)
-		{
-		  builtin_error (_("%s: not a function"), name);
-		  any_failed++;
-		}
-	      else if ((attribute & att_exported) && undo == 0 && exportable_function_name (name) == 0)
-		{
-		  builtin_error (_("%s: cannot export"), name);
-		  any_failed++;
-		}
-	      else
-		SETVARATTR (var, attribute, undo);
-
-	      list = list->next;
-	      continue;
-	    }
-
-	  /* xxx [-np] name[=value] */
-	  assign = assignment (name, 0);
-
-	  aflags = 0;
-	  if (assign)
-	    {
-	      name[assign] = '\0';
-	      if (name[assign - 1] == '+')
-		{
-		  aflags |= ASS_APPEND;
-		  name[assign - 1] = '\0';
-		}
-	    }
-
-	  if (legal_identifier (name) == 0)
-	    {
-	      sh_invalidid (name);
-	      if (assign)
-		assign_error++;
-	      else
-		any_failed++;
-	      list = list->next;
-	      continue;
-	    }
-
-	  if (assign)	/* xxx [-np] name=value */
-	    {
-	      name[assign] = '=';
-	      if (aflags & ASS_APPEND)
-		name[assign - 1] = '+';
-#if defined (ARRAY_VARS)
-	      /* Let's try something here.  Turn readonly -a xxx=yyy into
-		 declare -ra xxx=yyy and see what that gets us. */
-	      if (arrays_only || assoc_only)
-		{
-		  tlist = list->next;
-		  list->next = (WORD_LIST *)NULL;
-		  /* Add -g to avoid readonly/export creating local variables:
-		     only local/declare/typeset create local variables */
-		  opti = 0;
-		  optw[opti++] = '-';
-		  optw[opti++] = 'g';
-		  if (attribute & att_readonly)
-		    optw[opti++] = 'r';
-		  if (attribute & att_exported)
-		    optw[opti++] = 'x';
-		  if (arrays_only)
-		    optw[opti++] = 'a';
-		  else
-		    optw[opti++] = 'A';
-		  optw[opti] = '\0';
-
-		  w = make_word (optw);
-		  nlist = make_word_list (w, list);
-
-		  opt = declare_builtin (nlist);
-		  if (opt != EXECUTION_SUCCESS)
-		    assign_error++;
-		  list->next = tlist;
-		  dispose_word (w);
-		  free (nlist);
-		}
-	      else
-#endif
-	      /* This word has already been expanded once with command
-		 and parameter expansion.  Call do_assignment_no_expand (),
-		 which does not do command or parameter substitution.  If
-		 the assignment is not performed correctly, flag an error. */
-	      if (do_assignment_no_expand (name) == 0)
-		assign_error++;
-	      name[assign] = '\0';
-	      if (aflags & ASS_APPEND)
-		name[assign - 1] = '\0';
-	    }
-
-	  set_var_attribute (name, attribute, undo);
-	  if (assign)		/* restore word */
-	    {
-	      name[assign] = '=';
-	      if (aflags & ASS_APPEND)
-		name[assign-1] = '+';
-	    }
-	  list = list->next;
-	}
-    }
-  else
-    {
-      SHELL_VAR **variable_list;
-      register int i;
-
-      if ((attribute & att_function) || functions_only)
-	{
-	  variable_list = all_shell_functions ();
-	  if (attribute != att_function)
-	    attribute &= ~att_function;	/* so declare -xf works, for example */
-	}
-      else
-	variable_list = all_shell_variables ();
-
-#if defined (ARRAY_VARS)
-      if (attribute & att_array)
-	{
-	  arrays_only++;
-	  if (attribute != att_array)
-	    attribute &= ~att_array;
-	}
-      else if (attribute & att_assoc)
-	{
-	  assoc_only++;
-	  if (attribute != att_assoc)
-	    attribute &= ~att_assoc;
-	}
-#endif
-
-      if (variable_list)
-	{
-	  for (i = 0; var = variable_list[i]; i++)
-	    {
-#if defined (ARRAY_VARS)
-	      if (arrays_only && array_p (var) == 0)
-		continue;
-	      else if (assoc_only && assoc_p (var) == 0)
-		continue;
-#endif
-
-	      /* If we imported a variable that's not a valid identifier, don't
-		 show it in any lists. */
-	      if ((var->attributes & (att_invisible|att_imported)) == (att_invisible|att_imported))
-		continue;
-
-	      if ((var->attributes & attribute))
-		{
-		  show_var_attributes (var, READONLY_OR_EXPORT, nodefs);
-		  if (any_failed = sh_chkwrite (any_failed))
-		    break;
-		}
-	    }
-	  free (variable_list);
-	}
-    }
-
-  return (assign_error ? EX_BADASSIGN
-		       : ((any_failed == 0) ? EXECUTION_SUCCESS
-  					    : EXECUTION_FAILURE));
-}
-
-/* Show all variable variables (v == 1) or functions (v == 0) with
-   attributes. */
-int
-show_all_var_attributes (v, nodefs)
-     int v, nodefs;
-{
-  SHELL_VAR **variable_list, *var;
-  int any_failed;
-  register int i;
-
-  variable_list = v ? all_shell_variables () : all_shell_functions ();
-  if (variable_list == 0)  
-    return (EXECUTION_SUCCESS);
-
-  for (i = any_failed = 0; var = variable_list[i]; i++)
-    {
-      /* There is no equivalent `declare -'. */
-      if (variable_context && var->context == variable_context && STREQ (var->name, "-"))
-	printf ("local -\n");
-      else  
-	show_var_attributes (var, READONLY_OR_EXPORT, nodefs);
-      if (any_failed = sh_chkwrite (any_failed))
-        break;
-    }
-  free (variable_list);
-  return (any_failed == 0 ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-}
-
-/* Show all local variable variables with their attributes. This shows unset
-   local variables (all_local_variables called with 0 argument). */
-int
-show_local_var_attributes (v, nodefs)
-     int v, nodefs;
-{
-  SHELL_VAR **variable_list, *var;
-  int any_failed;
-  register int i;
-
-  variable_list = all_local_variables (0);
-  if (variable_list == 0)  
-    return (EXECUTION_SUCCESS);
-
-  for (i = any_failed = 0; var = variable_list[i]; i++)
-    {
-      /* There is no equivalent `declare -'. */
-      if (STREQ (var->name, "-"))
-	printf ("local -\n");
-      else  
-	show_var_attributes (var, READONLY_OR_EXPORT, nodefs);
-      if (any_failed = sh_chkwrite (any_failed))
-        break;
-    }
-  free (variable_list);
-  return (any_failed == 0 ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-}
-
-int
-var_attribute_string (var, pattr, flags)
-     SHELL_VAR *var;
-     int pattr;
-     char *flags;	/* filled in with attributes */
-{
-  int i;
-
-  i = 0;
-
-  /* pattr == 0 means we are called from `declare'. */
-  if (pattr == 0 || posixly_correct == 0)
-    {
-#if defined (ARRAY_VARS)
-      if (array_p (var))
-	flags[i++] = 'a';
-
-      if (assoc_p (var))
-	flags[i++] = 'A';
-#endif
-
-      if (function_p (var))
-	flags[i++] = 'f';
-
-      if (integer_p (var))
-	flags[i++] = 'i';
-
-      if (nameref_p (var))
-	flags[i++] = 'n';
-
-      if (readonly_p (var))
-	flags[i++] = 'r';
-
-      if (trace_p (var))
-	flags[i++] = 't';
-
-      if (exported_p (var))
-	flags[i++] = 'x';
-
-      if (capcase_p (var))
-	flags[i++] = 'c';
-
-      if (lowercase_p (var))
-	flags[i++] = 'l';
-
-      if (uppercase_p (var))
-	flags[i++] = 'u';
-    }
-  else
-    {
-#if defined (ARRAY_VARS)
-      if (array_p (var))
-	flags[i++] = 'a';
-
-      if (assoc_p (var))
-	flags[i++] = 'A';
-#endif
-
-      if (function_p (var))
-	flags[i++] = 'f';
-    }
-
-  flags[i] = '\0';
-  return i;
-}
-
-/* Show the attributes for shell variable VAR.  If NODEFS is non-zero,
-   don't show function definitions along with the name.  If PATTR is
-   non-zero, it indicates we're being called from `export' or `readonly'.
-   In POSIX mode, this prints the name of the calling builtin (`export'
-   or `readonly') instead of `declare', and doesn't print function defs
-   when called by `export' or `readonly'. */
-int
-show_var_attributes (var, pattr, nodefs)
-     SHELL_VAR *var;
-     int pattr, nodefs;
-{
-  char flags[MAX_ATTRIBUTES], *x;
-  int i;
-
-  i = var_attribute_string (var, pattr, flags);
-
-  /* If we're printing functions with definitions, print the function def
-     first, then the attributes, instead of printing output that can't be
-     reused as input to recreate the current state. */
-  if (function_p (var) && nodefs == 0 && (pattr == 0 || posixly_correct == 0))
-    {
-      printf ("%s\n", named_function_string (var->name, function_cell (var), FUNC_MULTILINE|FUNC_EXTERNAL));
-      nodefs++;
-      if (pattr == 0 && i == 1 && flags[0] == 'f')
-	return 0;		/* don't print `declare -f name' */
-    }
-
-  if (pattr == 0 || posixly_correct == 0)
-    printf ("declare -%s ", i ? flags : "-");
-  else if (i)
-    printf ("%s -%s ", this_command_name, flags);
-  else
-    printf ("%s ", this_command_name);
-
-#if defined (ARRAY_VARS)
-  if (invisible_p (var) && (array_p (var) || assoc_p (var)))
-    printf ("%s\n", var->name);
-  else if (array_p (var))
-    print_array_assignment (var, 0);
-  else if (assoc_p (var))
-    print_assoc_assignment (var, 0);
-  else
-#endif
-  /* force `readonly' and `export' to not print out function definitions
-     when in POSIX mode. */
-  if (nodefs || (function_p (var) && pattr != 0 && posixly_correct))
-    printf ("%s\n", var->name);
-  else if (function_p (var))
-    printf ("%s\n", named_function_string (var->name, function_cell (var), FUNC_MULTILINE|FUNC_EXTERNAL));
-  else if (invisible_p (var) || var_isset (var) == 0)
-    printf ("%s\n", var->name);
-  else
-    {
-      if (ansic_shouldquote (value_cell (var)))
-	x = ansic_quote (value_cell (var), 0, (int *)0);
-      else
-	x = sh_double_quote (value_cell (var));
-      printf ("%s=%s\n", var->name, x);
-      free (x);
-    }
-  return (0);
-}
-
-int
-show_name_attributes (name, nodefs)
-     char *name;
-     int nodefs;
-{
-  SHELL_VAR *var;
-
-  var = find_variable_noref (name);
-
-  if (var)	/* show every variable with attributes, even unset ones */
-    {
-      show_var_attributes (var, READONLY_OR_EXPORT, nodefs);
-      return (0);
-    }
-  else
-    return (1);
-}
-
-int
-show_localname_attributes (name, nodefs)
-     char *name;
-     int nodefs;
-{
-  SHELL_VAR *var;
-
-  var = find_variable_noref (name);
-
-  if (var && local_p (var) && var->context == variable_context)	/* show every variable with attributes, even unset ones */
-    {
-      show_var_attributes (var, READONLY_OR_EXPORT, nodefs);
-      return (0);
-    }
-  else
-    return (1);
-}
-
-int
-show_func_attributes (name, nodefs)
-     char *name;
-     int nodefs;
-{
-  SHELL_VAR *var;
-
-  var = find_function (name);
-
-  if (var)
-    {
-      show_var_attributes (var, READONLY_OR_EXPORT, nodefs);
-      return (0);
-    }
-  else
-    return (1);
-}
-
-void
-set_var_attribute (name, attribute, undo)
-     char *name;
-     int attribute, undo;
-{
-  SHELL_VAR *var, *tv, *v, *refvar;
-  char *tvalue;
-
-  if (undo)
-    var = find_variable (name);
-  else
-    {
-      tv = find_tempenv_variable (name);
-      /* XXX -- need to handle case where tv is a temp variable in a
-	 function-scope context, since function_env has been merged into
-	 the local variables table. */
-      if (tv && tempvar_p (tv))
-	{
-	  tvalue = var_isset (tv) ? savestring (value_cell (tv)) : savestring ("");
-
-	  var = bind_variable (tv->name, tvalue, 0);
-	  if (var == 0)
-	    {
-	      free (tvalue);
-	      return;		/* XXX - no error message here */
-	    }
-	  var->attributes |= tv->attributes & ~att_tempvar;
-	  /* This avoids an error message when propagating a read-only var
-	     later on. */
-	  if (posixly_correct || shell_compatibility_level <= 44)
-	    {
-	      if (var->context == 0 && (attribute & att_readonly))
-		{
-		  /* Don't bother to set the `propagate to the global variables
-		     table' flag if we've just bound the variable in that
-		     table */
-		  v = find_global_variable (tv->name);
-		  if (v != var)
-		    VSETATTR (tv, att_propagate);
-		}
-	      else
-		VSETATTR (tv, att_propagate);
-	      if (var->context != 0)
-		VSETATTR (var, att_propagate);
-	    }
-
-	  SETVARATTR (tv, attribute, undo);	/* XXX */
-
-	  stupidly_hack_special_variables (tv->name);
-
-	  free (tvalue);
-	}
-      else
-	{
-	  var = find_variable_notempenv (name);
-	  if (var == 0)
-	    {
-	      /* We might have a nameref pointing to something that we can't
-		 resolve to a shell variable.  If we do, skip it.  We do a little
-		 checking just so we can print an error message. */
-	      refvar = find_variable_nameref_for_create (name, 0);
-	      if (refvar == INVALID_NAMEREF_VALUE)
-		return;
-	      /* Otherwise we probably have a nameref pointing to a variable
-		 that hasn't been created yet. bind_variable will take care
-		 of that. */
-	    }
-	  if (var == 0)
-	    {
-	      var = bind_variable (name, (char *)NULL, 0);
-	      if (var)
-		VSETATTR (var, att_invisible);
-	    }
-	  else if (var->context != 0)
-	    VSETATTR (var, att_propagate);
-	}
-    }
-
-  if (var)
-    SETVARATTR (var, attribute, undo);
-
-  if (var && (exported_p (var) || (attribute & att_exported)))
-    array_needs_making++;	/* XXX */
-}
diff --git a/third_party/bash/builtins_shift.c b/third_party/bash/builtins_shift.c
deleted file mode 100644
index 669b60e38..000000000
--- a/third_party/bash/builtins_shift.c
+++ /dev/null
@@ -1,61 +0,0 @@
-/* shift.c, created from shift.def. */
-#line 22 "./shift.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "common.h"
-
-#line 49 "./shift.def"
-
-int print_shift_error;
-
-/* Shift the arguments ``left''.  Shift DOLLAR_VARS down then take one
-   off of REST_OF_ARGS and place it into DOLLAR_VARS[9].  If LIST has
-   anything in it, it is a number which says where to start the
-   shifting.  Return > 0 if `times' > $#, otherwise 0. */
-int
-shift_builtin (list)
-     WORD_LIST *list;
-{
-  intmax_t times;
-  int itimes, nargs;
-
-  CHECK_HELPOPT (list);
-
-  if (get_numeric_arg (list, 0, &times) == 0)
-    return (EXECUTION_FAILURE);
-
-  if (times == 0)
-    return (EXECUTION_SUCCESS);
-  else if (times < 0)
-    {
-      sh_erange (list ? list->word->word : NULL, _("shift count"));
-      return (EXECUTION_FAILURE);
-    }
-  nargs = number_of_args ();
-  if (times > nargs)
-    {
-      if (print_shift_error)
-	sh_erange (list ? list->word->word : NULL, _("shift count"));
-      return (EXECUTION_FAILURE);
-    }
-  else if (times == nargs)
-    clear_dollar_vars ();
-  else
-    shift_args (itimes = times);
-
-  invalidate_cached_quoted_dollar_at ();
-
-  return (EXECUTION_SUCCESS);
-}
diff --git a/third_party/bash/builtins_shopt.c b/third_party/bash/builtins_shopt.c
deleted file mode 100644
index 3935c8077..000000000
--- a/third_party/bash/builtins_shopt.c
+++ /dev/null
@@ -1,900 +0,0 @@
-/* shopt.c, created from shopt.def. */
-#line 22 "./shopt.def"
-
-#line 43 "./shopt.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-
-#include "version.h"
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "flags.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-#if defined (READLINE)
-#  include "bashline.h"
-#endif
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#endif
-
-#define UNSETOPT	0
-#define SETOPT		1
-
-#define OPTFMT		"%-15s\t%s\n"
-
-extern int allow_null_glob_expansion, fail_glob_expansion, glob_dot_filenames;
-extern int cdable_vars, mail_warning, source_uses_path;
-extern int no_exit_on_failed_exec, print_shift_error;
-extern int check_hashed_filenames, promptvars;
-extern int cdspelling, expand_aliases;
-extern int extended_quote;
-extern int check_window_size;
-extern int glob_ignore_case, match_ignore_case;
-extern int hup_on_exit;
-extern int xpg_echo;
-extern int gnu_error_format;
-extern int check_jobs_at_exit;
-extern int autocd;
-extern int glob_star;
-extern int glob_asciirange;
-extern int glob_always_skip_dot_and_dotdot;
-extern int lastpipe_opt;
-extern int inherit_errexit;
-extern int localvar_inherit;
-extern int localvar_unset;
-extern int varassign_redir_autoclose;
-extern int singlequote_translations;
-extern int patsub_replacement;
-
-#if defined (EXTENDED_GLOB)
-extern int extended_glob;
-#endif
-
-#if defined (READLINE)
-extern int hist_verify, history_reediting, perform_hostname_completion;
-extern int no_empty_command_completion;
-extern int force_fignore;
-extern int dircomplete_spelling, dircomplete_expand;
-extern int complete_fullquote;
-
-extern int enable_hostname_completion PARAMS((int));
-#endif
-
-#if defined (PROGRAMMABLE_COMPLETION)
-extern int prog_completion_enabled;
-extern int progcomp_alias;
-#endif
-
-#if defined (DEBUGGER)
-extern int debugging_mode;
-#endif
-
-#if defined (ARRAY_VARS)
-extern int assoc_expand_once;
-extern int array_expand_once;
-int expand_once_flag;
-#endif
-
-#if defined (SYSLOG_HISTORY)
-extern int syslog_history;
-#endif
-
-static void shopt_error PARAMS((char *));
-
-static int set_shellopts_after_change PARAMS((char *, int));
-static int set_compatibility_level PARAMS((char *, int));
-
-#if defined (RESTRICTED_SHELL)
-static int set_restricted_shell PARAMS((char *, int));
-#endif
-
-#if defined (READLINE)
-static int shopt_enable_hostname_completion PARAMS((char *, int));
-static int shopt_set_complete_direxpand PARAMS((char *, int));
-#endif
-
-#if defined (ARRAY_VARS)
-static int set_assoc_expand PARAMS((char *, int));
-#endif
-
-static int shopt_set_debug_mode PARAMS((char *, int));
-
-static int shopt_login_shell;
-static int shopt_compat31;
-static int shopt_compat32;
-static int shopt_compat40;
-static int shopt_compat41;
-static int shopt_compat42;
-static int shopt_compat43;
-static int shopt_compat44;
-
-typedef int shopt_set_func_t PARAMS((char *, int));
-
-/* If you add a new variable name here, make sure to set the default value
-   appropriately in reset_shopt_options. */
-
-static struct {
-  char *name;
-  int  *value;
-  shopt_set_func_t *set_func;
-} shopt_vars[] = {
-  { "autocd", &autocd, (shopt_set_func_t *)NULL },
-#if defined (ARRAY_VARS)
-  { "assoc_expand_once", &expand_once_flag, set_assoc_expand },
-#endif
-  { "cdable_vars", &cdable_vars, (shopt_set_func_t *)NULL },
-  { "cdspell", &cdspelling, (shopt_set_func_t *)NULL },
-  { "checkhash", &check_hashed_filenames, (shopt_set_func_t *)NULL },
-#if defined (JOB_CONTROL)
-  { "checkjobs", &check_jobs_at_exit, (shopt_set_func_t *)NULL },
-#endif
-  { "checkwinsize", &check_window_size, (shopt_set_func_t *)NULL },
-#if defined (HISTORY)
-  { "cmdhist", &command_oriented_history, (shopt_set_func_t *)NULL },
-#endif
-  { "compat31", &shopt_compat31, set_compatibility_level },
-  { "compat32", &shopt_compat32, set_compatibility_level },
-  { "compat40", &shopt_compat40, set_compatibility_level },
-  { "compat41", &shopt_compat41, set_compatibility_level },
-  { "compat42", &shopt_compat42, set_compatibility_level },
-  { "compat43", &shopt_compat43, set_compatibility_level },
-  { "compat44", &shopt_compat44, set_compatibility_level },
-#if defined (READLINE)
-  { "complete_fullquote", &complete_fullquote, (shopt_set_func_t *)NULL},
-  { "direxpand", &dircomplete_expand, shopt_set_complete_direxpand },
-  { "dirspell", &dircomplete_spelling, (shopt_set_func_t *)NULL },
-#endif
-  { "dotglob", &glob_dot_filenames, (shopt_set_func_t *)NULL },
-  { "execfail", &no_exit_on_failed_exec, (shopt_set_func_t *)NULL },
-  { "expand_aliases", &expand_aliases, (shopt_set_func_t *)NULL },
-#if defined (DEBUGGER)
-  { "extdebug", &debugging_mode, shopt_set_debug_mode },
-#endif
-#if defined (EXTENDED_GLOB)
-  { "extglob", &extended_glob, (shopt_set_func_t *)NULL },
-#endif
-  { "extquote", &extended_quote, (shopt_set_func_t *)NULL },
-  { "failglob", &fail_glob_expansion, (shopt_set_func_t *)NULL },
-#if defined (READLINE)
-  { "force_fignore", &force_fignore, (shopt_set_func_t *)NULL },
-#endif
-  { "globasciiranges", &glob_asciirange, (shopt_set_func_t *)NULL },
-  { "globskipdots", &glob_always_skip_dot_and_dotdot, (shopt_set_func_t *)NULL },
-  { "globstar", &glob_star, (shopt_set_func_t *)NULL },
-  { "gnu_errfmt", &gnu_error_format, (shopt_set_func_t *)NULL },
-#if defined (HISTORY)
-  { "histappend", &force_append_history, (shopt_set_func_t *)NULL },
-#endif
-#if defined (READLINE)
-  { "histreedit", &history_reediting, (shopt_set_func_t *)NULL },
-  { "histverify", &hist_verify, (shopt_set_func_t *)NULL },
-  { "hostcomplete", &perform_hostname_completion, shopt_enable_hostname_completion },
-#endif
-  { "huponexit", &hup_on_exit, (shopt_set_func_t *)NULL },
-  { "inherit_errexit", &inherit_errexit, (shopt_set_func_t *)NULL },
-  { "interactive_comments", &interactive_comments, set_shellopts_after_change },
-  { "lastpipe", &lastpipe_opt, (shopt_set_func_t *)NULL },
-#if defined (HISTORY)
-  { "lithist", &literal_history, (shopt_set_func_t *)NULL },
-#endif
-  { "localvar_inherit", &localvar_inherit, (shopt_set_func_t *)NULL },
-  { "localvar_unset", &localvar_unset, (shopt_set_func_t *)NULL },
-  { "login_shell", &shopt_login_shell, set_login_shell },
-  { "mailwarn", &mail_warning, (shopt_set_func_t *)NULL },
-#if defined (READLINE)
-  { "no_empty_cmd_completion", &no_empty_command_completion, (shopt_set_func_t *)NULL },
-#endif
-  { "nocaseglob", &glob_ignore_case, (shopt_set_func_t *)NULL },
-  { "nocasematch", &match_ignore_case, (shopt_set_func_t *)NULL },
-  { "noexpand_translation", &singlequote_translations, (shopt_set_func_t *)NULL },
-  { "nullglob",	&allow_null_glob_expansion, (shopt_set_func_t *)NULL },
-  { "patsub_replacement", &patsub_replacement, (shopt_set_func_t *)NULL },
-#if defined (PROGRAMMABLE_COMPLETION)
-  { "progcomp", &prog_completion_enabled, (shopt_set_func_t *)NULL },
-#  if defined (ALIAS)
-  { "progcomp_alias", &progcomp_alias, (shopt_set_func_t *)NULL },
-#  endif
-#endif
-  { "promptvars", &promptvars, (shopt_set_func_t *)NULL },
-#if defined (RESTRICTED_SHELL)
-  { "restricted_shell", &restricted_shell, set_restricted_shell },
-#endif
-  { "shift_verbose", &print_shift_error, (shopt_set_func_t *)NULL },
-  { "sourcepath", &source_uses_path, (shopt_set_func_t *)NULL },
-#if defined (SYSLOG_HISTORY) && defined (SYSLOG_SHOPT)
-  { "syslog_history", &syslog_history, (shopt_set_func_t *)NULL },
-#endif
-  { "varredir_close", &varassign_redir_autoclose, (shopt_set_func_t *)NULL },
-  { "xpg_echo", &xpg_echo, (shopt_set_func_t *)NULL },
-  { (char *)0, (int *)0, (shopt_set_func_t *)NULL }
-};
-
-#define N_SHOPT_OPTIONS		(sizeof (shopt_vars) / sizeof (shopt_vars[0]))
-
-#define GET_SHOPT_OPTION_VALUE(i)	(*shopt_vars[i].value)
-
-static const char * const on = "on";
-static const char * const off = "off";
-
-static int find_shopt PARAMS((char *));
-static int toggle_shopts PARAMS((int, WORD_LIST *, int));
-static void print_shopt PARAMS((char *, int, int));
-static int list_shopts PARAMS((WORD_LIST *, int));
-static int list_some_shopts PARAMS((int, int));
-static int list_shopt_o_options PARAMS((WORD_LIST *, int));
-static int list_some_o_options PARAMS((int, int));
-static int set_shopt_o_options PARAMS((int, WORD_LIST *, int));
-
-#define SFLAG	0x01
-#define UFLAG	0x02
-#define QFLAG	0x04
-#define OFLAG	0x08
-#define PFLAG	0x10
-
-int
-shopt_builtin (list)
-     WORD_LIST *list;
-{
-  int opt, flags, rval;
-
-  flags = 0;
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "psuoq")) != -1)
-    {
-      switch (opt)
-	{
-	case 's':
-	  flags |= SFLAG;
-	  break;
-	case 'u':
-	  flags |= UFLAG;
-	  break;
-	case 'q':
-	  flags |= QFLAG;
-	  break;
-	case 'o':
-	  flags |= OFLAG;
-	  break;
-	case 'p':
-	  flags |= PFLAG;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  if ((flags & (SFLAG|UFLAG)) == (SFLAG|UFLAG))
-    {
-      builtin_error (_("cannot set and unset shell options simultaneously"));
-      return (EXECUTION_FAILURE);
-    }
-
-  rval = EXECUTION_SUCCESS;
-  if ((flags & OFLAG) && ((flags & (SFLAG|UFLAG)) == 0))	/* shopt -o */
-    rval = list_shopt_o_options (list, flags);
-  else if (list && (flags & OFLAG))		/* shopt -so args */
-    rval = set_shopt_o_options ((flags & SFLAG) ? FLAG_ON : FLAG_OFF, list, flags & QFLAG);
-  else if (flags & OFLAG)	/* shopt -so */
-    rval = list_some_o_options ((flags & SFLAG) ? 1 : 0, flags);
-  else if (list && (flags & (SFLAG|UFLAG)))	/* shopt -su args */
-    rval = toggle_shopts ((flags & SFLAG) ? SETOPT : UNSETOPT, list, flags & QFLAG);
-  else if ((flags & (SFLAG|UFLAG)) == 0)	/* shopt [args] */
-    rval = list_shopts (list, flags);
-  else						/* shopt -su */
-    rval = list_some_shopts ((flags & SFLAG) ? SETOPT : UNSETOPT, flags);
-  return (rval);
-}
-
-/* Reset the options managed by `shopt' to the values they would have at
-   shell startup.  Variables from shopt_vars. */
-void
-reset_shopt_options ()
-{
-  autocd = cdable_vars = cdspelling = 0;
-  check_hashed_filenames = CHECKHASH_DEFAULT;
-  check_window_size = CHECKWINSIZE_DEFAULT;
-  allow_null_glob_expansion = glob_dot_filenames = 0;
-  no_exit_on_failed_exec = 0;
-  expand_aliases = 0;
-  extended_quote = 1;
-  fail_glob_expansion = 0;
-  glob_asciirange = GLOBASCII_DEFAULT;
-  glob_star = 0;
-  gnu_error_format = 0;
-  hup_on_exit = 0;
-  inherit_errexit = 0;
-  interactive_comments = 1;
-  lastpipe_opt = 0;
-  localvar_inherit = localvar_unset = 0;
-  mail_warning = 0;
-  glob_ignore_case = match_ignore_case = 0;
-  print_shift_error = 0;
-  source_uses_path = promptvars = 1;
-  varassign_redir_autoclose = 0;
-  singlequote_translations = 0;
-  patsub_replacement = 1;
-
-#if defined (JOB_CONTROL)
-  check_jobs_at_exit = 0;
-#endif
-
-#if defined (EXTENDED_GLOB)
-  extended_glob = EXTGLOB_DEFAULT;
-#endif
-
-#if defined (ARRAY_VARS)
-  expand_once_flag = assoc_expand_once = 0;
-#endif
-
-#if defined (HISTORY)
-  literal_history = 0;
-  force_append_history = 0;
-  command_oriented_history = 1;
-#endif
-
-#if defined (SYSLOG_HISTORY)
-#  if defined (SYSLOG_SHOPT)
-  syslog_history = SYSLOG_SHOPT;
-#  else
-  syslog_history = 1;
-#  endif /* SYSLOG_SHOPT */
-#endif
-
-#if defined (READLINE)
-  complete_fullquote = 1;
-  force_fignore = 1;
-  hist_verify = history_reediting = 0;
-  perform_hostname_completion = 1;
-#  if DIRCOMPLETE_EXPAND_DEFAULT
-  dircomplete_expand = 1;
-#  else
-  dircomplete_expand = 0;
-#endif
-  dircomplete_spelling = 0;
-  no_empty_command_completion = 0;
-#endif
-
-#if defined (PROGRAMMABLE_COMPLETION)
-  prog_completion_enabled = 1;
-#  if defined (ALIAS)
-  progcomp_alias = 0;
-#  endif
-#endif
-
-#if defined (DEFAULT_ECHO_TO_XPG) || defined (STRICT_POSIX)
-  xpg_echo = 1;
-#else
-  xpg_echo = 0;
-#endif /* DEFAULT_ECHO_TO_XPG */
-
-  shopt_login_shell = login_shell;
-}
-
-static int
-find_shopt (name)
-     char *name;
-{
-  int i;
-
-  for (i = 0; shopt_vars[i].name; i++)
-    if (STREQ (name, shopt_vars[i].name))
-      return i;
-  return -1;
-}
-
-static void
-shopt_error (s)
-     char *s;
-{
-  builtin_error (_("%s: invalid shell option name"), s);
-}
-
-static int
-toggle_shopts (mode, list, quiet)
-     int mode;
-     WORD_LIST *list;
-     int quiet;
-{
-  WORD_LIST *l;
-  int ind, rval;
-  SHELL_VAR *v;
-
-  for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
-    {
-      ind = find_shopt (l->word->word);
-      if (ind < 0)
-	{
-	  shopt_error (l->word->word);
-	  rval = EXECUTION_FAILURE;
-	}
-      else
-	{
-	  *shopt_vars[ind].value = mode;	/* 1 for set, 0 for unset */
-	  if (shopt_vars[ind].set_func)
-	    (*shopt_vars[ind].set_func) (shopt_vars[ind].name, mode);
-	}
-    }
-
-  /* Don't set $BASHOPTS here if it hasn't already been initialized */
-  if (v = find_variable ("BASHOPTS"))
-    set_bashopts ();
-  return (rval);
-}
-
-static void
-print_shopt (name, val, flags)
-     char *name;
-     int val, flags;
-{
-  if (flags & PFLAG)
-    printf ("shopt %s %s\n", val ? "-s" : "-u", name);
-  else
-    printf (OPTFMT, name, val ? on : off);
-}
-
-/* List the values of all or any of the `shopt' options.  Returns 0 if
-   all were listed or all variables queried were on; 1 otherwise. */
-static int
-list_shopts (list, flags)
-     WORD_LIST *list;
-     int flags;
-{
-  WORD_LIST *l;
-  int i, val, rval;
-
-  if (list == 0)
-    {
-      for (i = 0; shopt_vars[i].name; i++)
-	{
-	  val = *shopt_vars[i].value;
-	  if ((flags & QFLAG) == 0)
-	    print_shopt (shopt_vars[i].name, val, flags);
-	}
-      return (sh_chkwrite (EXECUTION_SUCCESS));
-    }
-
-  for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
-    {
-      i = find_shopt (l->word->word);
-      if (i < 0)
-	{
-	  shopt_error (l->word->word);
-	  rval = EXECUTION_FAILURE;
-	  continue;
-	}
-      val = *shopt_vars[i].value;
-      if (val == 0)
-	rval = EXECUTION_FAILURE;
-      if ((flags & QFLAG) == 0)
-	print_shopt (l->word->word, val, flags);
-    }
-
-  return (sh_chkwrite (rval));
-}
-
-static int
-list_some_shopts (mode, flags)
-     int mode, flags;
-{
-  int val, i;
-
-  for (i = 0; shopt_vars[i].name; i++)
-    {
-      val = *shopt_vars[i].value;
-      if (((flags & QFLAG) == 0) && mode == val)
-	print_shopt (shopt_vars[i].name, val, flags);
-    }
-  return (sh_chkwrite (EXECUTION_SUCCESS));
-}
-
-static int
-list_shopt_o_options (list, flags)
-     WORD_LIST *list;
-     int flags;
-{
-  WORD_LIST *l;
-  int val, rval;
-
-  if (list == 0)
-    {
-      if ((flags & QFLAG) == 0)
-	list_minus_o_opts (-1, (flags & PFLAG));
-      return (sh_chkwrite (EXECUTION_SUCCESS));
-    }
-
-  for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
-    {
-      val = minus_o_option_value (l->word->word);
-      if (val == -1)
-	{
-	  sh_invalidoptname (l->word->word);
-	  rval = EXECUTION_FAILURE;
-	  continue;
-	}
-      if (val == 0)
-	rval = EXECUTION_FAILURE;
-      if ((flags & QFLAG) == 0)
-	{
-	  if (flags & PFLAG)
-	    printf ("set %co %s\n", val ? '-' : '+', l->word->word);
-	  else
-	    printf (OPTFMT, l->word->word, val ? on : off);
-	}
-    }
-  return (sh_chkwrite (rval));
-}
-
-static int
-list_some_o_options (mode, flags)
-     int mode, flags;
-{
-  if ((flags & QFLAG) == 0)
-    list_minus_o_opts (mode, (flags & PFLAG));
-  return (sh_chkwrite (EXECUTION_SUCCESS));
-}
-
-static int
-set_shopt_o_options (mode, list, quiet)
-     int mode;
-     WORD_LIST *list;
-     int quiet;
-{
-  WORD_LIST *l;
-  int rval;
-
-  for (l = list, rval = EXECUTION_SUCCESS; l; l = l->next)
-    {
-      if (set_minus_o_option (mode, l->word->word) == EXECUTION_FAILURE)
-	rval = EXECUTION_FAILURE;
-    }
-  set_shellopts ();
-  return rval;
-}
-
-/* If we set or unset interactive_comments with shopt, make sure the
-   change is reflected in $SHELLOPTS. */
-static int
-set_shellopts_after_change (option_name, mode)
-     char *option_name;
-     int mode;
-{
-  set_shellopts ();
-  return (0);
-}
-
-static int
-shopt_set_debug_mode (option_name, mode)
-     char *option_name;
-     int mode;
-{
-#if defined (DEBUGGER)
-  error_trace_mode = function_trace_mode = debugging_mode;
-  set_shellopts ();
-  if (debugging_mode)
-    init_bash_argv ();
-#endif
-  return (0);
-}
-
-#if defined (READLINE)
-static int
-shopt_enable_hostname_completion (option_name, mode)
-     char *option_name;
-     int mode;
-{
-  return (enable_hostname_completion (mode));
-}
-#endif
-
-static int
-set_compatibility_level (option_name, mode)
-     char *option_name;
-     int mode;
-{
-  int ind, oldval;
-  char *rhs;
-
-  /* If we're unsetting one of the compatibility options, make sure the
-     current value is in the range of the compatNN space. */
-  if (mode == 0)
-    oldval = shell_compatibility_level;
-
-  /* If we're setting something, redo some of the work we did above in
-     toggle_shopt().  Unset everything and reset the appropriate option
-     based on OPTION_NAME. */
-  if (mode)
-    {
-      shopt_compat31 = shopt_compat32 = 0;
-      shopt_compat40 = shopt_compat41 = shopt_compat42 = shopt_compat43 = 0;
-      shopt_compat44 = 0;
-      ind = find_shopt (option_name);
-      *shopt_vars[ind].value = mode;
-    }
-
-  /* Then set shell_compatibility_level based on what remains */
-  if (shopt_compat31)
-    shell_compatibility_level = 31;
-  else if (shopt_compat32)
-    shell_compatibility_level = 32;
-  else if (shopt_compat40)
-    shell_compatibility_level = 40;
-  else if (shopt_compat41)
-    shell_compatibility_level = 41;
-  else if (shopt_compat42)
-    shell_compatibility_level = 42;
-  else if (shopt_compat43)
-    shell_compatibility_level = 43;
-  else if (shopt_compat44)
-    shell_compatibility_level = 44;
-  else if (oldval > 44 && shell_compatibility_level < DEFAULT_COMPAT_LEVEL)
-    ;
-  else
-    shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
-
-  /* Make sure the current compatibility level is reflected in BASH_COMPAT */
-  rhs = itos (shell_compatibility_level);
-  bind_variable ("BASH_COMPAT", rhs, 0);
-  free (rhs);
-
-  return 0;
-}
-
-/* Set and unset the various compatibility options from the value of
-   shell_compatibility_level; used by sv_shcompat */
-void
-set_compatibility_opts ()
-{
-  shopt_compat31 = shopt_compat32 = 0;
-  shopt_compat40 = shopt_compat41 = shopt_compat42 = shopt_compat43 = 0;
-  shopt_compat44 = 0;
-  switch (shell_compatibility_level)
-    {
-      case DEFAULT_COMPAT_LEVEL:
-      case 51:			/* completeness */
-      case 50:
-	break;
-      case 44:
-	shopt_compat44 = 1; break;
-      case 43:
-	shopt_compat43 = 1; break;
-      case 42:
-	shopt_compat42 = 1; break;
-      case 41:
-	shopt_compat41 = 1; break;
-      case 40:
-	shopt_compat40 = 1; break;
-      case 32:
-	shopt_compat32 = 1; break;
-      case 31:
-	shopt_compat31 = 1; break;
-    }
-}
-
-#if defined (READLINE)
-static int
-shopt_set_complete_direxpand (option_name, mode)
-     char *option_name;
-     int mode;
-{
-  set_directory_hook ();
-  return 0;
-}
-#endif
-
-#if defined (RESTRICTED_SHELL)
-/* Don't allow the value of restricted_shell to be modified. */
-
-static int
-set_restricted_shell (option_name, mode)
-     char *option_name;
-     int mode;
-{
-  static int save_restricted = -1;
-
-  if (save_restricted == -1)
-    save_restricted = shell_is_restricted (shell_name);
-
-  restricted_shell = save_restricted;
-  return (0);
-}
-#endif /* RESTRICTED_SHELL */
-
-/* Not static so shell.c can call it to initialize shopt_login_shell */
-int
-set_login_shell (option_name, mode)
-     char *option_name;
-     int mode;
-{
-  shopt_login_shell = login_shell != 0;
-  return (0);
-}
-
-char **
-get_shopt_options ()
-{
-  char **ret;
-  int n, i;
-
-  n = sizeof (shopt_vars) / sizeof (shopt_vars[0]);
-  ret = strvec_create (n + 1);
-  for (i = 0; shopt_vars[i].name; i++)
-    ret[i] = savestring (shopt_vars[i].name);
-  ret[i] = (char *)NULL;
-  return ret;
-}
-
-/*
- * External interface for other parts of the shell.  NAME is a string option;
- * MODE is 0 if we want to unset an option; 1 if we want to set an option.
- * REUSABLE is 1 if we want to print output in a form that may be reused.
- */
-int
-shopt_setopt (name, mode)
-     char *name;
-     int mode;
-{
-  WORD_LIST *wl;
-  int r;
-
-  wl = add_string_to_list (name, (WORD_LIST *)NULL);
-  r = toggle_shopts (mode, wl, 0);
-  dispose_words (wl);
-  return r;
-}
-
-int
-shopt_listopt (name, reusable)
-     char *name;
-     int reusable;
-{
-  int i;
-
-  if (name == 0)
-    return (list_shopts ((WORD_LIST *)NULL, reusable ? PFLAG : 0));
-
-  i = find_shopt (name);
-  if (i < 0)
-    {
-      shopt_error (name);
-      return (EXECUTION_FAILURE);
-    }
-
-  print_shopt (name, *shopt_vars[i].value, reusable ? PFLAG : 0);
-  return (sh_chkwrite (EXECUTION_SUCCESS));
-}
-
-void
-set_bashopts ()
-{
-  char *value;
-  char tflag[N_SHOPT_OPTIONS];
-  int vsize, i, vptr, *ip, exported;
-  SHELL_VAR *v;
-
-  for (vsize = i = 0; shopt_vars[i].name; i++)
-    {
-      tflag[i] = 0;
-      if (GET_SHOPT_OPTION_VALUE (i))
-	{
-	  vsize += strlen (shopt_vars[i].name) + 1;
-	  tflag[i] = 1;
-	}
-    }
-
-  value = (char *)xmalloc (vsize + 1);
-
-  for (i = vptr = 0; shopt_vars[i].name; i++)
-    {
-      if (tflag[i])
-	{
-	  strcpy (value + vptr, shopt_vars[i].name);
-	  vptr += strlen (shopt_vars[i].name);
-	  value[vptr++] = ':';
-	}
-    }
-
-  if (vptr)
-    vptr--;			/* cut off trailing colon */
-  value[vptr] = '\0';
-
-  v = find_variable ("BASHOPTS");
-
-  /* Turn off the read-only attribute so we can bind the new value, and
-     note whether or not the variable was exported. */
-  if (v)
-    {
-      VUNSETATTR (v, att_readonly);
-      exported = exported_p (v);
-    }
-  else
-    exported = 0;
-
-  v = bind_variable ("BASHOPTS", value, 0);
-
-  /* Turn the read-only attribute back on, and turn off the export attribute
-     if it was set implicitly by mark_modified_vars and SHELLOPTS was not
-     exported before we bound the new value. */
-  VSETATTR (v, att_readonly);
-  if (mark_modified_vars && exported == 0 && exported_p (v))
-    VUNSETATTR (v, att_exported);
-
-  free (value);
-}
-
-void
-parse_bashopts (value)
-     char *value;
-{
-  char *vname;
-  int vptr, ind;
-
-  vptr = 0;
-  while (vname = extract_colon_unit (value, &vptr))
-    {
-      ind = find_shopt (vname);
-      if (ind >= 0)
-	{
-          *shopt_vars[ind].value = 1;
-	  if (shopt_vars[ind].set_func)
-	    (*shopt_vars[ind].set_func) (shopt_vars[ind].name, 1);
-	}
-      free (vname);
-    }
-}
-
-void
-initialize_bashopts (no_bashopts)
-     int no_bashopts;
-{
-  char *temp;
-  SHELL_VAR *var;
-
-  if (no_bashopts == 0)
-    {
-      var = find_variable ("BASHOPTS");
-      /* set up any shell options we may have inherited. */
-      if (var && imported_p (var))
-	{
-	  temp = (array_p (var) || assoc_p (var)) ? (char *)NULL : savestring (value_cell (var));
-	  if (temp)
-	    {
-	      parse_bashopts (temp);
-	      free (temp);
-	    }
-	}
-    }
-
-  /* Set up the $BASHOPTS variable. */
-  set_bashopts ();
-}
-
-#if defined (ARRAY_VARS)
-static int
-set_assoc_expand (option_name, mode)
-     char *option_name;
-     int mode;
-{
-#if 0 /* leave this disabled */
-  if (shell_compatibility_level <= 51)
-#endif
-    assoc_expand_once = expand_once_flag;
-  return 0;
-}
-#endif
diff --git a/third_party/bash/builtins_source.c b/third_party/bash/builtins_source.c
deleted file mode 100644
index 001b900da..000000000
--- a/third_party/bash/builtins_source.c
+++ /dev/null
@@ -1,154 +0,0 @@
-/* source.c, created from source.def. */
-#line 22 "./source.def"
-
-#line 37 "./source.def"
-
-#line 53 "./source.def"
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "posixstat.h"
-#include "filecntl.h"
-#if ! defined(_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-#include <errno.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "flags.h"
-#include "findcmd.h"
-#include "common.h"
-#include "bashgetopt.h"
-#include "trap.h"
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-static void maybe_pop_dollar_vars PARAMS((void));
-
-/* If non-zero, `.' uses $PATH to look up the script to be sourced. */
-int source_uses_path = 1;
-
-/* If non-zero, `.' looks in the current directory if the filename argument
-   is not found in the $PATH. */
-int source_searches_cwd = 1;
-
-/* If this . script is supplied arguments, we save the dollar vars and
-   replace them with the script arguments for the duration of the script's
-   execution.  If the script does not change the dollar vars, we restore
-   what we saved.  If the dollar vars are changed in the script, and we are
-   not executing a shell function, we leave the new values alone and free
-   the saved values. */
-static void
-maybe_pop_dollar_vars ()
-{
-  if (variable_context == 0 && (dollar_vars_changed () & ARGS_SETBLTIN))
-    dispose_saved_dollar_vars ();
-  else
-    pop_dollar_vars ();
-  if (debugging_mode)
-    pop_args ();	/* restore BASH_ARGC and BASH_ARGV */
-  set_dollar_vars_unchanged ();
-  invalidate_cached_quoted_dollar_at ();	/* just invalidate to be safe */
-}
-
-/* Read and execute commands from the file passed as argument.  Guess what.
-   This cannot be done in a subshell, since things like variable assignments
-   take place in there.  So, I open the file, place it into a large string,
-   close the file, and then execute the string. */
-int
-source_builtin (list)
-     WORD_LIST *list;
-{
-  int result;
-  char *filename, *debug_trap, *x;
-
-  if (no_options (list))
-    return (EX_USAGE);
-  list = loptend;
-
-  if (list == 0)
-    {
-      builtin_error (_("filename argument required"));
-      builtin_usage ();
-      return (EX_USAGE);
-    }
-
-#if defined (RESTRICTED_SHELL)
-  if (restricted && strchr (list->word->word, '/'))
-    {
-      sh_restricted (list->word->word);
-      return (EXECUTION_FAILURE);
-    }
-#endif
-
-  filename = (char *)NULL;
-  /* XXX -- should this be absolute_pathname? */
-  if (posixly_correct && strchr (list->word->word, '/'))
-    filename = savestring (list->word->word);
-  else if (absolute_pathname (list->word->word))
-    filename = savestring (list->word->word);
-  else if (source_uses_path)
-    filename = find_path_file (list->word->word);
-  if (filename == 0)
-    {
-      if (source_searches_cwd == 0)
-	{
-	  x = printable_filename (list->word->word, 0);
-	  builtin_error (_("%s: file not found"), x);
-	  if (x != list->word->word)
-	    free (x);
-	  if (posixly_correct && interactive_shell == 0 && executing_command_builtin == 0)
-	    {
-	      last_command_exit_value = EXECUTION_FAILURE;
-	      jump_to_top_level (EXITPROG);
-	    }
-	  return (EXECUTION_FAILURE);
-	}
-      else
-	filename = savestring (list->word->word);
-    }
-
-  begin_unwind_frame ("source");
-  add_unwind_protect (xfree, filename);
-
-  if (list->next)
-    {
-      push_dollar_vars ();
-      add_unwind_protect ((Function *)maybe_pop_dollar_vars, (char *)NULL);
-      if (debugging_mode || shell_compatibility_level <= 44)
-	init_bash_argv ();	/* Initialize BASH_ARGV and BASH_ARGC */
-      remember_args (list->next, 1);
-      if (debugging_mode)
-	push_args (list->next);	/* Update BASH_ARGV and BASH_ARGC */
-    }
-  set_dollar_vars_unchanged ();
-
-  /* Don't inherit the DEBUG trap unless function_trace_mode (overloaded)
-     is set.  XXX - should sourced files inherit the RETURN trap?  Functions
-     don't. */
-  debug_trap = TRAP_STRING (DEBUG_TRAP);
-  if (debug_trap && function_trace_mode == 0)
-    {
-      debug_trap = savestring (debug_trap);
-      add_unwind_protect (xfree, debug_trap);
-      add_unwind_protect (maybe_set_debug_trap, debug_trap);
-      restore_default_signal (DEBUG_TRAP);
-    }
-
-  result = source_file (filename, (list && list->next));
-
-  run_unwind_frame ("source");
-
-  return (result);
-}
diff --git a/third_party/bash/builtins_suspend.c b/third_party/bash/builtins_suspend.c
deleted file mode 100644
index fe96213f3..000000000
--- a/third_party/bash/builtins_suspend.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/* suspend.c, created from suspend.def. */
-#line 22 "./suspend.def"
-
-#line 40 "./suspend.def"
-
-#include "config.h"
-
-#if defined (JOB_CONTROL)
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashtypes.h"
-#include <signal.h>
-#include "bashintl.h"
-#include "shell.h"
-#include "jobs.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-static sighandler suspend_continue PARAMS((int));
-
-static SigHandler *old_cont;
-#if 0
-static SigHandler *old_stop;
-#endif
-
-/* Continue handler. */
-static sighandler
-suspend_continue (sig)
-     int sig;
-{
-  set_signal_handler (SIGCONT, old_cont);
-#if 0
-  set_signal_handler (SIGSTOP, old_stop);
-#endif
-  SIGRETURN (0);
-}
-
-/* Suspending the shell.  If -f is the arg, then do the suspend
-   no matter what.  Otherwise, complain if a login shell. */
-int
-suspend_builtin (list)
-     WORD_LIST *list;
-{
-  int opt, force;
-
-  reset_internal_getopt ();
-  force = 0;
-  while ((opt = internal_getopt (list, "f")) != -1)
-    switch (opt)
-      {
-      case 'f':
-	force++;
-	break;
-      CASE_HELPOPT;
-      default:
-	builtin_usage ();
-	return (EX_USAGE);
-      }
-      
-  list = loptend;
-  no_args (list);
-
-  if (force == 0)  
-    {
-      if (job_control == 0)
-	{
-	  sh_nojobs (_("cannot suspend"));
-	  return (EXECUTION_FAILURE);
-	}
-
-      if (login_shell)
-	{
-	  builtin_error (_("cannot suspend a login shell"));
-	  return (EXECUTION_FAILURE);
-	}
-    }
-
-  /* XXX - should we put ourselves back into the original pgrp now?  If so,
-     call end_job_control() here and do the right thing in suspend_continue
-     (that is, call restart_job_control()). */
-  old_cont = (SigHandler *)set_signal_handler (SIGCONT, suspend_continue);
-#if 0
-  old_stop = (SigHandler *)set_signal_handler (SIGSTOP, SIG_DFL);
-#endif
-  killpg (shell_pgrp, SIGSTOP);
-  return (EXECUTION_SUCCESS);
-}
-
-#endif /* JOB_CONTROL */
diff --git a/third_party/bash/builtins_test.c b/third_party/bash/builtins_test.c
deleted file mode 100644
index 05f757d68..000000000
--- a/third_party/bash/builtins_test.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/* test.c, created from test.def. */
-#line 22 "./test.def"
-
-#line 104 "./test.def"
-
-#line 114 "./test.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "test.h"
-#include "common.h"
-
-/* TEST/[ builtin. */
-int
-test_builtin (list)
-     WORD_LIST *list;
-{
-  char **argv;
-  int argc, result;
-
-  /* We let Matthew Bradburn and Kevin Braunsdorf's code do the
-     actual test command.  So turn the list of args into an array
-     of strings, since that is what their code wants. */
-  if (list == 0)
-    {
-      if (this_command_name[0] == '[' && !this_command_name[1])
-	{
-	  builtin_error (_("missing `]'"));
-	  return (EX_BADUSAGE);
-	}
-
-      return (EXECUTION_FAILURE);
-    }
-
-  argv = make_builtin_argv  (list, &argc);
-  result = test_command (argc, argv);
-  free ((char *)argv);
-
-  return (result);
-}
diff --git a/third_party/bash/builtins_times.c b/third_party/bash/builtins_times.c
deleted file mode 100644
index 34de78d61..000000000
--- a/third_party/bash/builtins_times.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/* times.c, created from times.def. */
-#line 22 "./times.def"
-
-#line 34 "./times.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "bashtypes.h"
-#include "shell.h"
-
-#include "posixtime.h"
-
-#if defined (HAVE_SYS_TIMES_H)
-#  include <sys/times.h>
-#endif /* HAVE_SYS_TIMES_H */
-
-#if defined (HAVE_SYS_RESOURCE_H) && !defined (RLIMTYPE)
-#  include <sys/resource.h>
-#endif
-
-#include "common.h"
-
-/* Print the totals for system and user time used. */
-int
-times_builtin (list)
-     WORD_LIST *list;
-{
-#if defined (HAVE_GETRUSAGE) && defined (HAVE_TIMEVAL) && defined (RUSAGE_SELF)
-  struct rusage self, kids;
-
-  USE_VAR(list);
-
-  if (no_options (list))
-    return (EX_USAGE);
-
-  getrusage (RUSAGE_SELF, &self);
-  getrusage (RUSAGE_CHILDREN, &kids);	/* terminated child processes */
-
-  print_timeval (stdout, &self.ru_utime);
-  putchar (' ');
-  print_timeval (stdout, &self.ru_stime);
-  putchar ('\n');
-  print_timeval (stdout, &kids.ru_utime);
-  putchar (' ');
-  print_timeval (stdout, &kids.ru_stime);
-  putchar ('\n');
-
-#else
-#  if defined (HAVE_TIMES)
-  /* This uses the POSIX.1/XPG5 times(2) interface, which fills in a 
-     `struct tms' with values of type clock_t. */
-  struct tms t;
-
-  USE_VAR(list);
-
-  if (no_options (list))
-    return (EX_USAGE);
-
-  times (&t);
-
-  print_clock_t (stdout, t.tms_utime);
-  putchar (' ');
-  print_clock_t (stdout, t.tms_stime);
-  putchar ('\n');
-  print_clock_t (stdout, t.tms_cutime);
-  putchar (' ');
-  print_clock_t (stdout, t.tms_cstime);
-  putchar ('\n');
-
-#  else /* !HAVE_TIMES */
-
-  USE_VAR(list);
-
-  if (no_options (list))
-    return (EX_USAGE);
-  printf ("0.00 0.00\n0.00 0.00\n");
-
-#  endif /* HAVE_TIMES */
-#endif /* !HAVE_TIMES */
-
-  return (sh_chkwrite (EXECUTION_SUCCESS));
-}
diff --git a/third_party/bash/builtins_trap.c b/third_party/bash/builtins_trap.c
deleted file mode 100644
index 6d150a406..000000000
--- a/third_party/bash/builtins_trap.c
+++ /dev/null
@@ -1,263 +0,0 @@
-/* trap.c, created from trap.def. */
-#line 22 "./trap.def"
-
-#line 58 "./trap.def"
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashtypes.h"
-#include <signal.h>
-#include <stdio.h>
-#include "bashansi.h"
-
-#include "shell.h"
-#include "trap.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-static void showtrap PARAMS((int, int));
-static int display_traps PARAMS((WORD_LIST *, int));
-
-/* The trap command:
-
-   trap <arg> <signal ...>
-   trap <signal ...>
-   trap -l
-   trap -p [sigspec ...]
-   trap [--]
-
-   Set things up so that ARG is executed when SIGNAL(s) N is received.
-   If ARG is the empty string, then ignore the SIGNAL(s).  If there is
-   no ARG, then set the trap for SIGNAL(s) to its original value.  Just
-   plain "trap" means to print out the list of commands associated with
-   each signal number.  Single arg of "-l" means list the signal names. */
-
-/* Possible operations to perform on the list of signals.*/
-#define SET 0			/* Set this signal to first_arg. */
-#define REVERT 1		/* Revert to this signals original value. */
-#define IGNORE 2		/* Ignore this signal. */
-
-int
-trap_builtin (list)
-     WORD_LIST *list;
-{
-  int list_signal_names, display, result, opt;
-
-  list_signal_names = display = 0;
-  result = EXECUTION_SUCCESS;
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "lp")) != -1)
-    {
-      switch (opt)
-	{
-	case 'l':
-	  list_signal_names++;
-	  break;
-	case 'p':
-	  display++;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  opt = DSIG_NOCASE|DSIG_SIGPREFIX;	/* flags for decode_signal */
-
-  if (list_signal_names)
-    return (sh_chkwrite (display_signal_list ((WORD_LIST *)NULL, 1)));
-  else if (display || list == 0)
-    {
-      initialize_terminating_signals ();
-      get_all_original_signals ();
-      return (sh_chkwrite (display_traps (list, display && posixly_correct)));
-    }
-  else
-    {
-      char *first_arg;
-      int operation, sig, first_signal;
-
-      operation = SET;
-      first_arg = list->word->word;
-      first_signal = first_arg && *first_arg && all_digits (first_arg) && signal_object_p (first_arg, opt);
-
-      /* Backwards compatibility.  XXX - question about whether or not we
-	 should throw an error if an all-digit argument doesn't correspond
-	 to a valid signal number (e.g., if it's `50' on a system with only
-	 32 signals).  */
-      if (first_signal)
-	operation = REVERT;
-      /* When in posix mode, the historical behavior of looking for a
-	 missing first argument is disabled.  To revert to the original
-	 signal handling disposition, use `-' as the first argument. */
-      else if (posixly_correct == 0 && first_arg && *first_arg &&
-		(*first_arg != '-' || first_arg[1]) &&
-		signal_object_p (first_arg, opt) && list->next == 0)
-	operation = REVERT;
-      else
-	{
-	  list = list->next;
-	  if (list == 0)
-	    {
-	      builtin_usage ();
-	      return (EX_USAGE);
-	    }
-	  else if (*first_arg == '\0')
-	    operation = IGNORE;
-	  else if (first_arg[0] == '-' && !first_arg[1])
-	    operation = REVERT;
-	}
-
-      /* If we're in a command substitution, we haven't freed the trap strings
-	 (though we reset the signal handlers).  If we're setting a trap to
-	 handle a signal here, free the rest of the trap strings since they
-	 don't apply any more. */
-      if (subshell_environment & SUBSHELL_RESETTRAP)
-	{
-	  free_trap_strings ();
-	  subshell_environment &= ~SUBSHELL_RESETTRAP;
-	}
-
-      while (list)
-	{
-	  sig = decode_signal (list->word->word, opt);
-
-	  if (sig == NO_SIG)
-	    {
-	      sh_invalidsig (list->word->word);
-	      result = EXECUTION_FAILURE;
-	    }
-	  else
-	    {
-	      switch (operation)
-		{
-		  case SET:
-		    set_signal (sig, first_arg);
-		    break;
-
-		  case REVERT:
-		    restore_default_signal (sig);
-
-		    /* Signals that the shell treats specially need special
-		       handling. */
-		    switch (sig)
-		      {
-		      case SIGINT:
-			/* XXX - should we do this if original disposition
-			   was SIG_IGN? */
-			if (interactive)
-			  set_signal_handler (SIGINT, sigint_sighandler);
-			/* special cases for interactive == 0 */
-			else if (interactive_shell && (sourcelevel||running_trap||parse_and_execute_level))
-			  set_signal_handler (SIGINT, sigint_sighandler);
-			else
-			  set_signal_handler (SIGINT, termsig_sighandler);
-			break;
-
-		      case SIGQUIT:
-			/* Always ignore SIGQUIT. */
-			set_signal_handler (SIGQUIT, SIG_IGN);
-			break;
-		      case SIGTERM:
-#if defined (JOB_CONTROL)
-		      case SIGTTIN:
-		      case SIGTTOU:
-		      case SIGTSTP:
-#endif /* JOB_CONTROL */
-			if (interactive)
-			  set_signal_handler (sig, SIG_IGN);
-			break;
-		      }
-		    break;
-
-		  case IGNORE:
-		    ignore_signal (sig);
-		    break;
-		}
-	    }
-	  list = list->next;
-	}
-    }
-
-  return (result);
-}
-
-static void
-showtrap (i, show_default)
-     int i, show_default;
-{
-  char *t, *p, *sn;
-  int free_t;
-
-  free_t = 1;
-  p = trap_list[i];
-  if (p == (char *)DEFAULT_SIG && signal_is_hard_ignored (i) == 0)
-    {
-      if (show_default)
-	t = "-";
-      else
-	return;
-      free_t = 0;
-    }
-  else if (signal_is_hard_ignored (i))
-    t = (char *)NULL;
-  else
-    t = (p == (char *)IGNORE_SIG) ? (char *)NULL : sh_single_quote (p);
-
-  sn = signal_name (i);
-  /* Make sure that signals whose names are unknown (for whatever reason)
-     are printed as signal numbers. */
-  if (STREQN (sn, "SIGJUNK", 7) || STREQN (sn, "unknown", 7))
-    printf ("trap -- %s %d\n", t ? t : "''", i);
-  else if (posixly_correct)
-    {
-      if (STREQN (sn, "SIG", 3))
-	printf ("trap -- %s %s\n", t ? t : "''", sn+3);
-      else
-	printf ("trap -- %s %s\n", t ? t : "''", sn);
-    }
-  else
-    printf ("trap -- %s %s\n", t ? t : "''", sn);
-
-  if (free_t)
-    FREE (t);
-}
-
-static int
-display_traps (list, show_all)
-     WORD_LIST *list;
-     int show_all;
-{
-  int result, i;
-
-  if (list == 0)
-    {
-      for (i = 0; i < BASH_NSIG; i++)
-	showtrap (i, show_all);
-      return (EXECUTION_SUCCESS);
-    }
-
-  for (result = EXECUTION_SUCCESS; list; list = list->next)
-    {
-      i = decode_signal (list->word->word, DSIG_NOCASE|DSIG_SIGPREFIX);
-      if (i == NO_SIG)
-	{
-	  sh_invalidsig (list->word->word);
-	  result = EXECUTION_FAILURE;
-	}
-      else
-	showtrap (i, show_all);
-    }
-
-  return (result);
-}
diff --git a/third_party/bash/builtins_type.c b/third_party/bash/builtins_type.c
deleted file mode 100644
index d897d6649..000000000
--- a/third_party/bash/builtins_type.c
+++ /dev/null
@@ -1,373 +0,0 @@
-/* type.c, created from type.def. */
-#line 22 "./type.def"
-
-#line 52 "./type.def"
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "parser.h"
-#include "execute_cmd.h"
-#include "findcmd.h"
-#include "hashcmd.h"
-
-#if defined (ALIAS)
-#include "alias.h"
-#endif /* ALIAS */
-
-#include "common.h"
-#include "bashgetopt.h"
-
-extern int find_reserved_word PARAMS((char *));
-
-/* For each word in LIST, find out what the shell is going to do with
-   it as a simple command. i.e., which file would this shell use to
-   execve, or if it is a builtin command, or an alias.  Possible flag
-   arguments:
-	-t		Returns the "type" of the object, one of
-			`alias', `keyword', `function', `builtin',
-			or `file'.
-
-	-p		Returns the pathname of the file if -type is
-			a file.
-
-	-a		Returns all occurrences of words, whether they
-			be a filename in the path, alias, function,
-			or builtin.
-
-	-f		Suppress shell function lookup, like `command'.
-
-	-P		Force a path search even in the presence of other
-			definitions.
-
-   Order of evaluation:
-	alias
-	keyword
-	function
-	builtin
-	file
- */
-
-int
-type_builtin (list)
-     WORD_LIST *list;
-{
-  int dflags, any_failed, opt;
-  WORD_LIST *this;
-
-  if (list == 0)
-    return (EXECUTION_SUCCESS);
-
-  dflags = CDESC_SHORTDESC;	/* default */
-  any_failed = 0;
-
-  /* Handle the obsolescent `-type', `-path', and `-all' by prescanning
-     the arguments and converting those options to the form that
-     internal_getopt recognizes. Converts `--type', `--path', and `--all'
-     also. THIS SHOULD REALLY GO AWAY. */
-  for (this = list; this && this->word->word[0] == '-'; this = this->next)
-    {
-      char *flag = &(this->word->word[1]);
-
-      if (STREQ (flag, "type") || STREQ (flag, "-type"))
-	{
-	  this->word->word[1] = 't';
-	  this->word->word[2] = '\0';
-	}
-      else if (STREQ (flag, "path") || STREQ (flag, "-path"))
-	{
-	  this->word->word[1] = 'p';
-	  this->word->word[2] = '\0';
-	}
-      else if (STREQ (flag, "all") || STREQ (flag, "-all"))
-	{
-	  this->word->word[1] = 'a';
-	  this->word->word[2] = '\0';
-	}
-    }
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "afptP")) != -1)
-    {
-      switch (opt)
-	{
-	case 'a':
-	  dflags |= CDESC_ALL;
-	  break;
-	case 'f':
-	  dflags |= CDESC_NOFUNCS;
-	  break;
-	case 'p':
-	  dflags |= CDESC_PATH_ONLY;
-	  dflags &= ~(CDESC_TYPE|CDESC_SHORTDESC);
-	  break;
-	case 't':
-	  dflags |= CDESC_TYPE;
-	  dflags &= ~(CDESC_PATH_ONLY|CDESC_SHORTDESC);
-	  break;
-	case 'P':	/* shorthand for type -ap */
-	  dflags |= (CDESC_PATH_ONLY|CDESC_FORCE_PATH);
-	  dflags &= ~(CDESC_TYPE|CDESC_SHORTDESC);
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  while (list)
-    {
-      int found;
-
-      found = describe_command (list->word->word, dflags);
-
-      if (!found && (dflags & (CDESC_PATH_ONLY|CDESC_TYPE)) == 0)
-	sh_notfound (list->word->word);
-
-      any_failed += found == 0;
-      list = list->next;
-    }
-
-  opt = (any_failed == 0) ? EXECUTION_SUCCESS : EXECUTION_FAILURE;
-  return (sh_chkwrite (opt));
-}
-
-/*
- * Describe COMMAND as required by the type and command builtins.
- *
- * Behavior is controlled by DFLAGS.  Flag values are
- *	CDESC_ALL	print all descriptions of a command
- *	CDESC_SHORTDESC	print the description for type and command -V
- *	CDESC_REUSABLE	print in a format that may be reused as input
- *	CDESC_TYPE	print the type for type -t
- *	CDESC_PATH_ONLY	print the path for type -p
- *	CDESC_FORCE_PATH	force a path search for type -P
- *	CDESC_NOFUNCS	skip function lookup for type -f
- *	CDESC_ABSPATH	convert to absolute path, no ./ prefix
- *	CDESC_STDPATH	command -p standard path list
- *
- * CDESC_ALL says whether or not to look for all occurrences of COMMAND, or
- * return after finding it once.
- */
-int
-describe_command (command, dflags)
-     char *command;
-     int dflags;
-{
-  int found, i, found_file, f, all;
-  char *full_path, *x, *pathlist;
-  SHELL_VAR *func;
-#if defined (ALIAS)
-  alias_t *alias;
-#endif
-
-  all = (dflags & CDESC_ALL) != 0;
-  found = found_file = 0;
-  full_path = (char *)NULL;
-
-#if defined (ALIAS)
-  /* Command is an alias? */
-  if (((dflags & CDESC_FORCE_PATH) == 0) && expand_aliases && (alias = find_alias (command)))
-    {
-      if (dflags & CDESC_TYPE)
-	puts ("alias");
-      else if (dflags & CDESC_SHORTDESC)
-	printf (_("%s is aliased to `%s'\n"), command, alias->value);
-      else if (dflags & CDESC_REUSABLE)
-	{
-	  x = sh_single_quote (alias->value);
-	  printf ("alias %s=%s\n", command, x);
-	  free (x);
-	}
-
-      found = 1;
-
-      if (all == 0)
-	return (1);
-    }
-#endif /* ALIAS */
-
-  /* Command is a shell reserved word? */
-  if (((dflags & CDESC_FORCE_PATH) == 0) && (i = find_reserved_word (command)) >= 0)
-    {
-      if (dflags & CDESC_TYPE)
-	puts ("keyword");
-      else if (dflags & CDESC_SHORTDESC)
-	printf (_("%s is a shell keyword\n"), command);
-      else if (dflags & CDESC_REUSABLE)
-	printf ("%s\n", command);
-
-      found = 1;
-
-      if (all == 0)
-	return (1);
-    }
-
-  /* Command is a function? */
-  if (((dflags & (CDESC_FORCE_PATH|CDESC_NOFUNCS)) == 0) && (func = find_function (command)))
-    {
-      if (dflags & CDESC_TYPE)
-	puts ("function");
-      else if (dflags & CDESC_SHORTDESC)
-	{
-	  char *result;
-
-	  printf (_("%s is a function\n"), command);
-
-	  /* We're blowing away THE_PRINTED_COMMAND here... */
-
-	  result = named_function_string (command, function_cell (func), FUNC_MULTILINE|FUNC_EXTERNAL);
-	  printf ("%s\n", result);
-	}
-      else if (dflags & CDESC_REUSABLE)
-	printf ("%s\n", command);
-
-      found = 1;
-
-      if (all == 0)
-	return (1);
-    }
-
-  /* Command is a builtin? */
-  if (((dflags & CDESC_FORCE_PATH) == 0) && find_shell_builtin (command))
-    {
-      if (dflags & CDESC_TYPE)
-	puts ("builtin");
-      else if (dflags & CDESC_SHORTDESC)
-	{
-	  if (posixly_correct && find_special_builtin (command) != 0)
-	    printf (_("%s is a special shell builtin\n"), command);
-	  else
-	    printf (_("%s is a shell builtin\n"), command);
-	}
-      else if (dflags & CDESC_REUSABLE)
-	printf ("%s\n", command);
-
-      found = 1;
-
-      if (all == 0)
-	return (1);
-    }
-
-  /* Command is a disk file? */
-  /* If the command name given is already an absolute command, just
-     check to see if it is executable. */
-  if (absolute_program (command))
-    {
-      f = file_status (command);
-      if (f & FS_EXECABLE)
-	{
-	  if (dflags & CDESC_TYPE)
-	    puts ("file");
-	  else if (dflags & CDESC_SHORTDESC)
-	    printf (_("%s is %s\n"), command, command);
-	  else if (dflags & (CDESC_REUSABLE|CDESC_PATH_ONLY))
-	    printf ("%s\n", command);
-
-	  /* There's no use looking in the hash table or in $PATH,
-	     because they're not consulted when an absolute program
-	     name is supplied. */
-	  return (1);
-	}
-    }
-
-  /* If the user isn't doing "-a", then we might care about
-     whether the file is present in our hash table. */
-  if (all == 0 || (dflags & CDESC_FORCE_PATH))
-    {
-      if (full_path = phash_search (command))
-	{
-	  if (dflags & CDESC_TYPE)
-	    puts ("file");
-	  else if (dflags & CDESC_SHORTDESC)
-	    printf (_("%s is hashed (%s)\n"), command, full_path);
-	  else if (dflags & (CDESC_REUSABLE|CDESC_PATH_ONLY))
-	    printf ("%s\n", full_path);
-
-	  free (full_path);
-	  return (1);
-	}
-    }
-
-  /* Now search through $PATH. */
-  while (1)
-    {
-      if (dflags & CDESC_STDPATH)	/* command -p, all cannot be non-zero */
-	{
-	  pathlist = conf_standard_path ();
-	  full_path = find_in_path (command, pathlist, FS_EXEC_PREFERRED|FS_NODIRS);
-	  free (pathlist);
-	  /* Will only go through this once, since all == 0 if STDPATH set */
-	}
-      else if (all == 0)
-	full_path = find_user_command (command);
-      else
-	full_path = user_command_matches (command, FS_EXEC_ONLY, found_file);	/* XXX - should that be FS_EXEC_PREFERRED? */
-
-      if (full_path == 0)
-	break;
-
-      /* If we found the command as itself by looking through $PATH, it
-	 probably doesn't exist.  Check whether or not the command is an
-	 executable file.  If it's not, don't report a match.  This is
-	 the default posix mode behavior */
-      if (STREQ (full_path, command) || posixly_correct)
-	{
-	  f = file_status (full_path);
-	  if ((f & FS_EXECABLE) == 0)
-	    {
-	      free (full_path);
-	      full_path = (char *)NULL;
-	      if (all == 0)
-		break;
-	    }
-	  else if (ABSPATH (full_path))
-	    ;	/* placeholder; don't need to do anything yet */
-	  else if (dflags & (CDESC_REUSABLE|CDESC_PATH_ONLY|CDESC_SHORTDESC))
-	    {
-	      f = MP_DOCWD | ((dflags & CDESC_ABSPATH) ? MP_RMDOT : 0);
-	      x = sh_makepath ((char *)NULL, full_path, f);
-	      free (full_path);
-	      full_path = x;
-	    }
-	}
-      /* If we require a full path and don't have one, make one */
-      else if ((dflags & CDESC_ABSPATH) && ABSPATH (full_path) == 0)
-	{
-	  x = sh_makepath ((char *)NULL, full_path, MP_DOCWD|MP_RMDOT);
-	  free (full_path);
-	  full_path = x;
-	}
-
-      found_file++;
-      found = 1;
-
-      if (dflags & CDESC_TYPE)
-	puts ("file");
-      else if (dflags & CDESC_SHORTDESC)
-	printf (_("%s is %s\n"), command, full_path);
-      else if (dflags & (CDESC_REUSABLE|CDESC_PATH_ONLY))
-	printf ("%s\n", full_path);
-
-      free (full_path);
-      full_path = (char *)NULL;
-
-      if (all == 0)
-	break;
-    }
-
-  return (found);
-}
diff --git a/third_party/bash/builtins_ulimit.c b/third_party/bash/builtins_ulimit.c
deleted file mode 100644
index 445412b93..000000000
--- a/third_party/bash/builtins_ulimit.c
+++ /dev/null
@@ -1,741 +0,0 @@
-/* ulimit.c, created from ulimit.def. */
-#line 22 "./ulimit.def"
-
-#line 73 "./ulimit.def"
-
-#if !defined (_MINIX)
-
-#include "config.h"
-
-#include "bashtypes.h"
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include <errno.h>
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "common.h"
-#include "bashgetopt.h"
-#include "pipesize.h"
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-/* For some reason, HPUX chose to make these definitions visible only if
-   _KERNEL is defined, so we define _KERNEL before including <sys/resource.h>
-   and #undef it afterward. */
-#if defined (HAVE_RESOURCE)
-#  include <sys/time.h>
-#  if defined (HPUX) && defined (RLIMIT_NEEDS_KERNEL)
-#    define _KERNEL
-#  endif
-#  include <sys/resource.h>
-#  if defined (HPUX) && defined (RLIMIT_NEEDS_KERNEL)
-#    undef _KERNEL
-#  endif
-#elif defined (HAVE_SYS_TIMES_H)
-#  include <sys/times.h>
-#endif
-
-#if defined (HAVE_LIMITS_H)
-#  include <limits.h>
-#endif
-
-/* Check for the most basic symbols.  If they aren't present, this
-   system's <sys/resource.h> isn't very useful to us. */
-#if !defined (RLIMIT_FSIZE) || !defined (HAVE_GETRLIMIT)
-#  undef HAVE_RESOURCE
-#endif
-
-#if !defined (HAVE_RESOURCE) && defined (HAVE_ULIMIT_H)
-#  include <ulimit.h>
-#endif
-
-#if !defined (RLIMTYPE)
-#  define RLIMTYPE long
-#  define string_to_rlimtype(s) strtol(s, (char **)NULL, 10)
-#  define print_rlimtype(num, nl) printf ("%ld%s", num, nl ? "\n" : "")
-#endif
-
-/* Alternate names */
-
-/* Some systems use RLIMIT_NOFILE, others use RLIMIT_OFILE */
-#if defined (HAVE_RESOURCE) && defined (RLIMIT_OFILE) && !defined (RLIMIT_NOFILE)
-#  define RLIMIT_NOFILE RLIMIT_OFILE
-#endif /* HAVE_RESOURCE && RLIMIT_OFILE && !RLIMIT_NOFILE */
-
-#if defined (HAVE_RESOURCE) && defined (RLIMIT_POSIXLOCKS) && !defined (RLIMIT_LOCKS)
-#  define RLIMIT_LOCKS RLIMIT_POSIXLOCKS
-#endif /* HAVE_RESOURCE && RLIMIT_POSIXLOCKS && !RLIMIT_LOCKS */
-
-/* Some systems have these, some do not. */
-#ifdef RLIMIT_FSIZE
-#  define RLIMIT_FILESIZE	RLIMIT_FSIZE
-#else
-#  define RLIMIT_FILESIZE	256
-#endif
-
-#define RLIMIT_PIPESIZE	257
-
-#ifdef RLIMIT_NOFILE
-#  define RLIMIT_OPENFILES	RLIMIT_NOFILE
-#else
-#  define RLIMIT_OPENFILES	258
-#endif
-
-#ifdef RLIMIT_VMEM
-#  define RLIMIT_VIRTMEM	RLIMIT_VMEM
-#  define RLIMIT_VMBLKSZ	1024
-#else
-#  ifdef RLIMIT_AS
-#    define RLIMIT_VIRTMEM	RLIMIT_AS
-#    define RLIMIT_VMBLKSZ	1024
-#  else
-#    define RLIMIT_VIRTMEM	259
-#    define RLIMIT_VMBLKSZ	1
-#  endif
-#endif
-
-#ifdef RLIMIT_NPROC
-#  define RLIMIT_MAXUPROC	RLIMIT_NPROC
-#else
-#  define RLIMIT_MAXUPROC	260
-#endif
-
-#if !defined (RLIMIT_PTHREAD) && defined (RLIMIT_NTHR)
-#  define RLIMIT_PTHREAD RLIMIT_NTHR
-#endif
-
-#if !defined (RLIM_INFINITY)
-#  define RLIM_INFINITY 0x7fffffff
-#endif
-
-#if !defined (RLIM_SAVED_CUR)
-#  define RLIM_SAVED_CUR RLIM_INFINITY
-#endif
-
-#if !defined (RLIM_SAVED_MAX)
-#  define RLIM_SAVED_MAX RLIM_INFINITY
-#endif
-
-#define LIMIT_HARD 0x01
-#define LIMIT_SOFT 0x02
-
-/* "Blocks" are defined as 512 bytes when in Posix mode and 1024 bytes
-   otherwise. */
-#define POSIXBLK	-2
-
-#define BLOCKSIZE(x)	(((x) == POSIXBLK) ? (posixly_correct ? 512 : 1024) : (x))
-
-static int _findlim PARAMS((int));
-
-static int ulimit_internal PARAMS((int, char *, int, int));
-
-static int get_limit PARAMS((int, RLIMTYPE *, RLIMTYPE *));
-static int set_limit PARAMS((int, RLIMTYPE, int));
-
-static void printone PARAMS((int, RLIMTYPE, int));
-static void print_all_limits PARAMS((int));
-
-static int set_all_limits PARAMS((int, RLIMTYPE));
-
-static int filesize PARAMS((RLIMTYPE *));
-static int pipesize PARAMS((RLIMTYPE *));
-static int getmaxuprc PARAMS((RLIMTYPE *));
-static int getmaxvm PARAMS((RLIMTYPE *, RLIMTYPE *));
-
-typedef struct {
-  int  option;			/* The ulimit option for this limit. */
-  int  parameter;		/* Parameter to pass to get_limit (). */
-  int  block_factor;		/* Blocking factor for specific limit. */
-  const char * const description;	/* Descriptive string to output. */
-  const char * const units;	/* scale */
-} RESOURCE_LIMITS;
-
-static RESOURCE_LIMITS limits[] = {
-#ifdef RLIMIT_NPTS
-  { 'P',	RLIMIT_NPTS,  1,	"number of pseudoterminals",	(char *)NULL },
-#endif
-#ifdef RLIMIT_RTTIME
-  { 'R',	RLIMIT_RTTIME,  1,	"real-time non-blocking time",	"microseconds" },
-#endif
-#ifdef RLIMIT_PTHREAD
-  { 'T',	RLIMIT_PTHREAD, 1,	"number of threads",	(char *)NULL },
-#endif
-#ifdef RLIMIT_SBSIZE
-  { 'b',	RLIMIT_SBSIZE,  1,	"socket buffer size",	"bytes" },
-#endif
-#ifdef RLIMIT_CORE
-  { 'c',	RLIMIT_CORE,  POSIXBLK,	"core file size",	"blocks" },
-#endif
-#ifdef RLIMIT_DATA
-  { 'd',	RLIMIT_DATA,  1024,	"data seg size",	"kbytes" },
-#endif
-#ifdef RLIMIT_NICE
-  { 'e',	RLIMIT_NICE,  1,	"scheduling priority",	(char *)NULL },
-#endif
-  { 'f',	RLIMIT_FILESIZE, POSIXBLK,	"file size",		"blocks" },
-#ifdef RLIMIT_SIGPENDING
-  { 'i',	RLIMIT_SIGPENDING, 1,	"pending signals",	(char *)NULL },
-#endif
-#ifdef RLIMIT_KQUEUES
-  { 'k',	RLIMIT_KQUEUES, 1,	"max kqueues",		(char *)NULL },
-#endif
-#ifdef RLIMIT_MEMLOCK
-  { 'l',	RLIMIT_MEMLOCK, 1024,	"max locked memory",	"kbytes" },
-#endif
-#ifdef RLIMIT_RSS
-  { 'm',	RLIMIT_RSS,   1024,	"max memory size",	"kbytes" },
-#endif /* RLIMIT_RSS */
-  { 'n',	RLIMIT_OPENFILES, 1,	"open files",		(char *)NULL},
-  { 'p',	RLIMIT_PIPESIZE, 512,	"pipe size", 		"512 bytes" },
-#ifdef RLIMIT_MSGQUEUE
-  { 'q',	RLIMIT_MSGQUEUE, 1,	"POSIX message queues",	"bytes" },
-#endif
-#ifdef RLIMIT_RTPRIO
-  { 'r',	RLIMIT_RTPRIO,  1,	"real-time priority",	(char *)NULL },
-#endif
-#ifdef RLIMIT_STACK
-  { 's',	RLIMIT_STACK, 1024,	"stack size",		"kbytes" },
-#endif
-#ifdef RLIMIT_CPU
-  { 't',	RLIMIT_CPU,      1,	"cpu time",		"seconds" },
-#endif /* RLIMIT_CPU */
-  { 'u',	RLIMIT_MAXUPROC, 1,	"max user processes",	(char *)NULL },
-#if defined (HAVE_RESOURCE)
-  { 'v',	RLIMIT_VIRTMEM, RLIMIT_VMBLKSZ, "virtual memory", "kbytes" },
-#endif
-#ifdef RLIMIT_SWAP
-  { 'w',	RLIMIT_SWAP,	1024,	"swap size",		"kbytes" },
-#endif
-#ifdef RLIMIT_LOCKS
-  { 'x',	RLIMIT_LOCKS,	1,	"file locks",		(char *)NULL },
-#endif
-  { -1, -1, -1, (char *)NULL, (char *)NULL }
-};
-#define NCMDS	(sizeof(limits) / sizeof(limits[0]))
-
-typedef struct _cmd {
-  int cmd;
-  char *arg;
-} ULCMD;
-
-static ULCMD *cmdlist;
-static int ncmd;
-static int cmdlistsz;
-
-#if !defined (HAVE_RESOURCE) && !defined (HAVE_ULIMIT)
-long
-ulimit (cmd, newlim)
-     int cmd;
-     long newlim;
-{
-  errno = EINVAL;
-  return -1;
-}
-#endif /* !HAVE_RESOURCE && !HAVE_ULIMIT */
-
-static int
-_findlim (opt)
-     int opt;
-{
-  register int i;
-
-  for (i = 0; limits[i].option > 0; i++)
-    if (limits[i].option == opt)
-      return i;
-  return -1;
-}
-
-static char optstring[4 + 2 * NCMDS];
-
-/* Report or set limits associated with certain per-process resources.
-   See the help documentation in builtins.c for a full description. */
-int
-ulimit_builtin (list)
-     register WORD_LIST *list;
-{
-  register char *s;
-  int c, limind, mode, opt, all_limits;
-
-  mode = 0;
-
-  all_limits = 0;
-
-  /* Idea stolen from pdksh -- build option string the first time called. */
-  if (optstring[0] == 0)
-    {
-      s = optstring;
-      *s++ = 'a'; *s++ = 'S'; *s++ = 'H';
-      for (c = 0; limits[c].option > 0; c++)
-	{
-	  *s++ = limits[c].option;
-	  *s++ = ';';
-	}
-      *s = '\0';
-    }
-
-  /* Initialize the command list. */
-  if (cmdlistsz == 0)
-    cmdlist = (ULCMD *)xmalloc ((cmdlistsz = 16) * sizeof (ULCMD));
-  ncmd = 0;
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, optstring)) != -1)
-    {
-      switch (opt)
-	{
-	case 'a':
-	  all_limits++;
-	  break;
-
-	/* -S and -H are modifiers, not real options.  */
-	case 'S':
-	  mode |= LIMIT_SOFT;
-	  break;
-
-	case 'H':
-	  mode |= LIMIT_HARD;
-	  break;
-
-	CASE_HELPOPT;
-	case '?':
-	  builtin_usage ();
-	  return (EX_USAGE);
-
-	default:
-	  if (ncmd >= cmdlistsz)
-	    cmdlist = (ULCMD *)xrealloc (cmdlist, (cmdlistsz *= 2) * sizeof (ULCMD));
-	  cmdlist[ncmd].cmd = opt;
-	  cmdlist[ncmd++].arg = list_optarg;
-	  break;
-	}
-    }
-  list = loptend;
-
-  if (all_limits)
-    {
-#ifdef NOTYET
-      if (list)		/* setting */
-        {
-          if (STREQ (list->word->word, "unlimited") == 0)
-            {
-              builtin_error (_("%s: invalid limit argument"), list->word->word);
-              return (EXECUTION_FAILURE);
-            }
-          return (set_all_limits (mode == 0 ? LIMIT_SOFT|LIMIT_HARD : mode, RLIM_INFINITY));
-        }
-#endif
-      print_all_limits (mode == 0 ? LIMIT_SOFT : mode);
-      return (sh_chkwrite (EXECUTION_SUCCESS));
-    }
-
-  /* default is `ulimit -f' */
-  if (ncmd == 0)
-    {
-      cmdlist[ncmd].cmd = 'f';
-      /* `ulimit something' is same as `ulimit -f something' */
-      cmdlist[ncmd++].arg = list ? list->word->word : (char *)NULL;
-      if (list)
-	list = list->next;
-    }
-
-  /* verify each command in the list. */
-  for (c = 0; c < ncmd; c++)
-    {
-      limind = _findlim (cmdlist[c].cmd);
-      if (limind == -1)
-	{
-	  builtin_error (_("`%c': bad command"), cmdlist[c].cmd);
-	  return (EX_USAGE);
-	}
-    }
-
-  /* POSIX compatibility. If the last item in cmdlist does not have an option
-     argument, but there is an operand (list != 0), treat the operand as if
-     it were an option argument for that last command. */
-  if (list && list->word && cmdlist[ncmd - 1].arg == 0)
-    {
-      cmdlist[ncmd - 1].arg = list->word->word;
-      list = list->next;
-    }
-
-  for (c = 0; c < ncmd; c++)
-    if (ulimit_internal (cmdlist[c].cmd, cmdlist[c].arg, mode, ncmd > 1) == EXECUTION_FAILURE)
-      return (EXECUTION_FAILURE);
-
-  return (EXECUTION_SUCCESS);
-}
-
-static int
-ulimit_internal (cmd, cmdarg, mode, multiple)
-     int cmd;
-     char *cmdarg;
-     int mode, multiple;
-{
-  int opt, limind, setting;
-  int block_factor;
-  RLIMTYPE soft_limit, hard_limit, real_limit, limit;
-
-  setting = cmdarg != 0;
-  limind = _findlim (cmd);
-  if (mode == 0)
-    mode = setting ? (LIMIT_HARD|LIMIT_SOFT) : LIMIT_SOFT;
-  opt = get_limit (limind, &soft_limit, &hard_limit);
-  if (opt < 0)
-    {
-      builtin_error (_("%s: cannot get limit: %s"), limits[limind].description,
-						 strerror (errno));
-      return (EXECUTION_FAILURE);
-    }
-
-  if (setting == 0)	/* print the value of the specified limit */
-    {
-      printone (limind, (mode & LIMIT_SOFT) ? soft_limit : hard_limit, multiple);
-      return (EXECUTION_SUCCESS);
-    }
- 
-  /* Setting the limit. */
-  if (STREQ (cmdarg, "hard"))
-    real_limit = hard_limit;
-  else if (STREQ (cmdarg, "soft"))
-    real_limit = soft_limit;
-  else if (STREQ (cmdarg, "unlimited"))
-    real_limit = RLIM_INFINITY;
-  else if (all_digits (cmdarg))
-    {
-      limit = string_to_rlimtype (cmdarg);
-      block_factor = BLOCKSIZE(limits[limind].block_factor);
-      real_limit = limit * block_factor;
-
-      if ((real_limit / block_factor) != limit)
-	{
-	  sh_erange (cmdarg, _("limit"));
-	  return (EXECUTION_FAILURE);
-	}
-    }
-  else
-    {
-      sh_invalidnum (cmdarg);
-      return (EXECUTION_FAILURE);
-    }
-
-  if (set_limit (limind, real_limit, mode) < 0)
-    {
-      builtin_error (_("%s: cannot modify limit: %s"), limits[limind].description,
-						    strerror (errno));
-      return (EXECUTION_FAILURE);
-    }
-
-  return (EXECUTION_SUCCESS);
-}
-
-static int
-get_limit (ind, softlim, hardlim)
-     int ind;
-     RLIMTYPE *softlim, *hardlim;
-{
-  RLIMTYPE value;
-#if defined (HAVE_RESOURCE)
-  struct rlimit limit;
-#endif
-
-  if (limits[ind].parameter >= 256)
-    {
-      switch (limits[ind].parameter)
-	{
-	case RLIMIT_FILESIZE:
-	  if (filesize (&value) < 0)
-	    return -1;
-	  break;
-	case RLIMIT_PIPESIZE:
-	  if (pipesize (&value) < 0)
-	    return -1;
-	  break;
-	case RLIMIT_OPENFILES:
-	  value = (RLIMTYPE)getdtablesize ();
-	  break;
-	case RLIMIT_VIRTMEM:
-	  return (getmaxvm (softlim, hardlim));
-	case RLIMIT_MAXUPROC:
-	  if (getmaxuprc (&value) < 0)
-	    return -1;
-	  break;
-	default:
-	  errno = EINVAL;
-	  return -1;
-	}
-      *softlim = *hardlim = value;
-      return (0);
-    }
-  else
-    {
-#if defined (HAVE_RESOURCE)
-      if (getrlimit (limits[ind].parameter, &limit) < 0)
-	return -1;
-      *softlim = limit.rlim_cur;
-      *hardlim = limit.rlim_max;
-#  if defined (HPUX9)
-      if (limits[ind].parameter == RLIMIT_FILESIZE)
-	{
-	  *softlim *= 512;
-	  *hardlim *= 512;			/* Ugh. */
-	}
-      else
-#  endif /* HPUX9 */
-      return 0;
-#else
-      errno = EINVAL;
-      return -1;
-#endif
-    }
-}
-
-static int
-set_limit (ind, newlim, mode)
-     int ind;
-     RLIMTYPE newlim;
-     int mode;
-{
-#if defined (HAVE_RESOURCE)
-   struct rlimit limit;
-   RLIMTYPE val;
-#endif
-
-  if (limits[ind].parameter >= 256)
-    switch (limits[ind].parameter)
-      {
-      case RLIMIT_FILESIZE:
-#if !defined (HAVE_RESOURCE)
-	return (ulimit (2, newlim / 512L));
-#else
-	errno = EINVAL;
-	return -1;
-#endif
-
-      case RLIMIT_OPENFILES:
-#if defined (HAVE_SETDTABLESIZE)
-#  if defined (__CYGWIN__)
-	/* Grrr... Cygwin declares setdtablesize as void. */
-	setdtablesize (newlim);
-	return 0;
-#  else
-	return (setdtablesize (newlim));
-#  endif
-#endif
-      case RLIMIT_PIPESIZE:
-      case RLIMIT_VIRTMEM:
-      case RLIMIT_MAXUPROC:
-      default:
-	errno = EINVAL;
-	return -1;
-      }
-  else
-    {
-#if defined (HAVE_RESOURCE)
-      if (getrlimit (limits[ind].parameter, &limit) < 0)
-	return -1;
-#  if defined (HPUX9)
-      if (limits[ind].parameter == RLIMIT_FILESIZE)
-	newlim /= 512;				/* Ugh. */
-#  endif /* HPUX9 */
-      val = (current_user.euid != 0 && newlim == RLIM_INFINITY &&
-	       (mode & LIMIT_HARD) == 0 &&		/* XXX -- test */
-	       (limit.rlim_cur <= limit.rlim_max))
-		 ? limit.rlim_max : newlim;
-      if (mode & LIMIT_SOFT)
-	limit.rlim_cur = val;
-      if (mode & LIMIT_HARD)
-	limit.rlim_max = val;
-	  
-      return (setrlimit (limits[ind].parameter, &limit));
-#else
-      errno = EINVAL;
-      return -1;
-#endif
-    }
-}
-
-static int
-getmaxvm (softlim, hardlim)
-     RLIMTYPE *softlim, *hardlim;
-{
-#if defined (HAVE_RESOURCE)
-  struct rlimit datalim, stacklim;
-
-  if (getrlimit (RLIMIT_DATA, &datalim) < 0)
-    return -1;
-
-  if (getrlimit (RLIMIT_STACK, &stacklim) < 0)
-    return -1;
-
-  /* Protect against overflow. */
-  *softlim = (datalim.rlim_cur / 1024L) + (stacklim.rlim_cur / 1024L);
-  *hardlim = (datalim.rlim_max / 1024L) + (stacklim.rlim_max / 1024L);
-  return 0;
-#else
-  errno = EINVAL;
-  return -1;
-#endif /* HAVE_RESOURCE */
-}
-
-static int
-filesize(valuep)
-     RLIMTYPE *valuep;
-{
-#if !defined (HAVE_RESOURCE)
-  long result;
-  if ((result = ulimit (1, 0L)) < 0)
-    return -1;
-  else
-    *valuep = (RLIMTYPE) result * 512;
-  return 0;
-#else
-  errno = EINVAL;
-  return -1;
-#endif
-}
-
-static int
-pipesize (valuep)
-     RLIMTYPE *valuep;
-{
-#if defined (PIPE_BUF)
-  /* This is defined on Posix systems. */
-  *valuep = (RLIMTYPE) PIPE_BUF;
-  return 0;
-#else
-#  if defined (_POSIX_PIPE_BUF)
-  *valuep = (RLIMTYPE) _POSIX_PIPE_BUF;
-  return 0;
-#  else
-#    if defined (PIPESIZE)
-  /* This is defined by running a program from the Makefile. */
-  *valuep = (RLIMTYPE) PIPESIZE;
-  return 0;
-#    else
-  errno = EINVAL;
-  return -1;  
-#    endif /* PIPESIZE */
-#  endif /* _POSIX_PIPE_BUF */
-#endif /* PIPE_BUF */
-}
-
-static int
-getmaxuprc (valuep)
-     RLIMTYPE *valuep;
-{
-  long maxchild;
-
-  maxchild = getmaxchild ();
-  if (maxchild < 0)
-    {
-      errno = EINVAL;
-      return -1;
-    }
-  else
-    {
-      *valuep = (RLIMTYPE) maxchild;
-      return 0;
-    }
-}
-
-static void
-print_all_limits (mode)
-     int mode;
-{
-  register int i;
-  RLIMTYPE softlim, hardlim;
-
-  if (mode == 0)
-    mode |= LIMIT_SOFT;
-
-  for (i = 0; limits[i].option > 0; i++)
-    {
-      if (get_limit (i, &softlim, &hardlim) == 0)
-	printone (i, (mode & LIMIT_SOFT) ? softlim : hardlim, 1);
-      else if (errno != EINVAL)
-	builtin_error ("%s: cannot get limit: %s", limits[i].description,
-						   strerror (errno));
-    }
-}
-
-static void
-printone (limind, curlim, pdesc)
-     int limind;
-     RLIMTYPE curlim;
-     int pdesc;
-{
-  char unitstr[64];
-  int factor;
-
-  factor = BLOCKSIZE(limits[limind].block_factor);
-  if (pdesc)
-    {
-      if (limits[limind].units)
-	sprintf (unitstr, "(%s, -%c) ", limits[limind].units, limits[limind].option);
-      else
-        sprintf (unitstr, "(-%c) ", limits[limind].option);
-
-      printf ("%-20s %20s", limits[limind].description, unitstr);
-    }
-  if (curlim == RLIM_INFINITY)
-    puts ("unlimited");
-  else if (curlim == RLIM_SAVED_MAX)
-    puts ("hard");
-  else if (curlim == RLIM_SAVED_CUR)
-    puts ("soft");
-  else
-    print_rlimtype ((curlim / factor), 1);
-}
-
-/* Set all limits to NEWLIM.  NEWLIM currently must be RLIM_INFINITY, which
-   causes all limits to be set as high as possible depending on mode (like
-   csh `unlimit').  Returns -1 if NEWLIM is invalid, 0 if all limits
-   were set successfully, and 1 if at least one limit could not be set.
-
-   To raise all soft limits to their corresponding hard limits, use
-	ulimit -S -a unlimited
-   To attempt to raise all hard limits to infinity (superuser-only), use
-	ulimit -H -a unlimited
-   To attempt to raise all soft and hard limits to infinity, use
-	ulimit -a unlimited
-*/
-
-static int
-set_all_limits (mode, newlim)
-     int mode;
-     RLIMTYPE newlim;
-{
-  register int i;
-  int retval = 0;
-
-  if (newlim != RLIM_INFINITY)
-    {
-      errno = EINVAL;
-      return -1;
-    }
-  
-  if (mode == 0)
-    mode = LIMIT_SOFT|LIMIT_HARD;
-
-  for (retval = i = 0; limits[i].option > 0; i++)
-    if (set_limit (i, newlim, mode) < 0)
-      {
-	builtin_error (_("%s: cannot modify limit: %s"), limits[i].description,
-						      strerror (errno));
-	retval = 1;
-      }
-  return retval;
-}
-
-#endif /* !_MINIX */
diff --git a/third_party/bash/builtins_umask.c b/third_party/bash/builtins_umask.c
deleted file mode 100644
index 686053764..000000000
--- a/third_party/bash/builtins_umask.c
+++ /dev/null
@@ -1,281 +0,0 @@
-/* umask.c, created from umask.def. */
-#line 22 "./umask.def"
-
-#line 41 "./umask.def"
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "filecntl.h"
-#if ! defined(_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "chartypes.h"
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "posixstat.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-/* **************************************************************** */
-/*                                                                  */
-/*                     UMASK Builtin and Helpers                    */
-/*                                                                  */
-/* **************************************************************** */
-
-static void print_symbolic_umask PARAMS((mode_t));
-static int symbolic_umask PARAMS((WORD_LIST *));
-
-/* Set or display the mask used by the system when creating files.  Flag
-   of -S means display the umask in a symbolic mode. */
-int
-umask_builtin (list)
-     WORD_LIST *list;
-{
-  int print_symbolically, opt, umask_value, pflag;
-  mode_t umask_arg;
-
-  print_symbolically = pflag = 0;
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "Sp")) != -1)
-    {
-      switch (opt)
-	{
-	case 'S':
-	  print_symbolically++;
-	  break;
-	case 'p':
-	  pflag++;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-
-  list = loptend;
-
-  if (list)
-    {
-      if (DIGIT (*list->word->word))
-	{
-	  umask_value = read_octal (list->word->word);
-
-	  /* Note that other shells just let you set the umask to zero
-	     by specifying a number out of range.  This is a problem
-	     with those shells.  We don't change the umask if the input
-	     is lousy. */
-	  if (umask_value == -1)
-	    {
-	      sh_erange (list->word->word, _("octal number"));
-	      return (EXECUTION_FAILURE);
-	    }
-	}
-      else
-	{
-	  umask_value = symbolic_umask (list);
-	  if (umask_value == -1)
-	    return (EXECUTION_FAILURE);
-	}
-      umask_arg = (mode_t)umask_value;
-      umask (umask_arg);
-      if (print_symbolically)
-	print_symbolic_umask (umask_arg);
-    }
-  else				/* Display the UMASK for this user. */
-    {
-      umask_arg = umask (022);
-      umask (umask_arg);
-
-      if (pflag)
-	printf ("umask%s ", (print_symbolically ? " -S" : ""));
-      if (print_symbolically)
-	print_symbolic_umask (umask_arg);
-      else
-	printf ("%04lo\n", (unsigned long)umask_arg);
-    }
-
-  return (sh_chkwrite (EXECUTION_SUCCESS));
-}
-
-/* Print the umask in a symbolic form.  In the output, a letter is
-   printed if the corresponding bit is clear in the umask. */
-static void
-#if defined (__STDC__)
-print_symbolic_umask (mode_t um)
-#else
-print_symbolic_umask (um)
-     mode_t um;
-#endif
-{
-  char ubits[4], gbits[4], obits[4];		/* u=rwx,g=rwx,o=rwx */
-  int i;
-
-  i = 0;
-  if ((um & S_IRUSR) == 0)
-    ubits[i++] = 'r';
-  if ((um & S_IWUSR) == 0)
-    ubits[i++] = 'w';
-  if ((um & S_IXUSR) == 0)
-    ubits[i++] = 'x';
-  ubits[i] = '\0';
-
-  i = 0;
-  if ((um & S_IRGRP) == 0)
-    gbits[i++] = 'r';
-  if ((um & S_IWGRP) == 0)
-    gbits[i++] = 'w';
-  if ((um & S_IXGRP) == 0)
-    gbits[i++] = 'x';
-  gbits[i] = '\0';
-
-  i = 0;
-  if ((um & S_IROTH) == 0)
-    obits[i++] = 'r';
-  if ((um & S_IWOTH) == 0)
-    obits[i++] = 'w';
-  if ((um & S_IXOTH) == 0)
-    obits[i++] = 'x';
-  obits[i] = '\0';
-
-  printf ("u=%s,g=%s,o=%s\n", ubits, gbits, obits);
-}
-
-int
-parse_symbolic_mode (mode, initial_bits)
-     char *mode;
-     int initial_bits;
-{
-  int who, op, perm, bits, c;
-  char *s;
-
-  for (s = mode, bits = initial_bits;;)
-    {
-      who = op = perm = 0;
-
-      /* Parse the `who' portion of the symbolic mode clause. */
-      while (member (*s, "agou"))
-	{
-	  switch (c = *s++)
-	    {
-	    case 'u':
-	      who |= S_IRWXU;
-	      continue;
-	    case 'g':
-	      who |= S_IRWXG;
-	      continue;
-	    case 'o':
-	      who |= S_IRWXO;
-	      continue;
-	    case 'a':
-	      who |= S_IRWXU | S_IRWXG | S_IRWXO;
-	      continue;
-	    default:
-	      break;
-	    }
-	}
-
-      /* The operation is now sitting in *s. */
-      op = *s++;
-      switch (op)
-	{
-	case '+':
-	case '-':
-	case '=':
-	  break;
-	default:
-	  builtin_error (_("`%c': invalid symbolic mode operator"), op);
-	  return (-1);
-	}
-
-      /* Parse out the `perm' section of the symbolic mode clause. */
-      while (member (*s, "rwx"))
-	{
-	  c = *s++;
-
-	  switch (c)
-	    {
-	    case 'r':
-	      perm |= S_IRUGO;
-	      break;
-	    case 'w':
-	      perm |= S_IWUGO;
-	      break;
-	    case 'x':
-	      perm |= S_IXUGO;
-	      break;
-	    }
-	}
-
-      /* Now perform the operation or return an error for a
-	 bad permission string. */
-      if (!*s || *s == ',')
-	{
-	  if (who)
-	    perm &= who;
-
-	  switch (op)
-	    {
-	    case '+':
-	      bits |= perm;
-	      break;
-	    case '-':
-	      bits &= ~perm;
-	      break;
-	    case '=':
-	      if (who == 0)
-		who = S_IRWXU | S_IRWXG | S_IRWXO;
-	      bits &= ~who;
-	      bits |= perm;
-	      break;
-
-	    /* No other values are possible. */
-	    }
-
-	  if (*s == '\0')
-	    break;
-	  else
-	    s++;	/* skip past ',' */
-	}
-      else
-	{
-	  builtin_error (_("`%c': invalid symbolic mode character"), *s);
-	  return (-1);
-	}
-    }
-
-  return (bits);
-}
-
-/* Set the umask from a symbolic mode string similar to that accepted
-   by chmod.  If the -S argument is given, then print the umask in a
-   symbolic form. */
-static int
-symbolic_umask (list)
-     WORD_LIST *list;
-{
-  int um, bits;
-
-  /* Get the initial umask.  Don't change it yet. */
-  um = umask (022);
-  umask (um);
-
-  /* All work is done with the complement of the umask -- it's
-     more intuitive and easier to deal with.  It is complemented
-     again before being returned. */
-  bits = parse_symbolic_mode (list->word->word, ~um & 0777);
-  if (bits == -1)
-    return (-1);
-
-  um = ~bits & 0777;
-  return (um);
-}
diff --git a/third_party/bash/builtins_wait.c b/third_party/bash/builtins_wait.c
deleted file mode 100644
index ab566d59e..000000000
--- a/third_party/bash/builtins_wait.c
+++ /dev/null
@@ -1,320 +0,0 @@
-/* wait.c, created from wait.def. */
-#line 51 "./wait.def"
-
-#line 66 "./wait.def"
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include <signal.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "chartypes.h"
-
-#include "bashansi.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "jobs.h"
-#include "trap.h"
-#include "sig.h"
-#include "common.h"
-#include "bashgetopt.h"
-
-extern int wait_signal_received;
-
-procenv_t wait_intr_buf;
-int wait_intr_flag;
-
-static int set_waitlist PARAMS((WORD_LIST *));
-static void unset_waitlist PARAMS((void));
-
-/* Wait for the pid in LIST to stop or die.  If no arguments are given, then
-   wait for all of the active background processes of the shell and return
-   0.  If a list of pids or job specs are given, return the exit status of
-   the last one waited for. */
-
-#define WAIT_RETURN(s) \
-  do \
-    { \
-      wait_signal_received = 0; \
-      wait_intr_flag = 0; \
-      return (s);\
-    } \
-  while (0)
-
-int
-wait_builtin (list)
-     WORD_LIST *list;
-{
-  int status, code, opt, nflag, vflags, bindflags;
-  volatile int wflags;
-  char *vname;
-  SHELL_VAR *pidvar;
-  struct procstat pstat;
-
-  USE_VAR(list);
-
-  nflag = wflags = vflags = 0;
-  vname = NULL;
-  pidvar = (SHELL_VAR *)NULL;
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "fnp:")) != -1)
-    {
-      switch (opt)
-	{
-#if defined (JOB_CONTROL)
-	case 'n':
-	  nflag = 1;
-	  break;
-	case 'f':
-	  wflags |= JWAIT_FORCE;
-	  break;
-	case 'p':
-	  vname = list_optarg;
-	  vflags = list_optflags;	  
-	  break;	
-#endif
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  /* Sanity-check variable name if -p supplied. */
-  if (vname)
-    {
-#if defined (ARRAY_VARS)
-      int arrayflags;
-
-      SET_VFLAGS (vflags, arrayflags, bindflags);
-      if (legal_identifier (vname) == 0 && valid_array_reference (vname, arrayflags) == 0)
-#else
-      bindflags = 0;
-      if (legal_identifier (vname) == 0)
-#endif
-	{
-	  sh_invalidid (vname);
-	  WAIT_RETURN (EXECUTION_FAILURE);
-	}
-      if (builtin_unbind_variable (vname) == -2)
-	WAIT_RETURN (EXECUTION_FAILURE);
-    }
-
-  /* POSIX.2 says:  When the shell is waiting (by means of the wait utility)
-     for asynchronous commands to complete, the reception of a signal for
-     which a trap has been set shall cause the wait utility to return
-     immediately with an exit status greater than 128, after which the trap
-     associated with the signal shall be taken.
-
-     We handle SIGINT here; it's the only one that needs to be treated
-     specially (I think), since it's handled specially in {no,}jobs.c. */
-  wait_intr_flag = 1;
-  code = setjmp_sigs (wait_intr_buf);
-
-  if (code)
-    {
-      last_command_exit_signal = wait_signal_received;
-      status = 128 + wait_signal_received;
-      wait_sigint_cleanup ();
-#if defined (JOB_CONTROL)
-      if (wflags & JWAIT_WAITING)
-	unset_waitlist ();
-#endif
-      WAIT_RETURN (status);
-    }
-
-  opt = first_pending_trap ();
-#if defined (SIGCHLD)
-  /* We special case SIGCHLD when not in posix mode because we don't break
-     out of the wait even when the signal is trapped; we run the trap after
-     the wait completes. See how it's handled in jobs.c:waitchld(). */
-  if (opt == SIGCHLD && posixly_correct == 0)
-    opt = next_pending_trap (opt+1);
-#endif
-  if (opt != -1)
-    {
-      last_command_exit_signal = wait_signal_received = opt;
-      status = opt + 128;
-      WAIT_RETURN (status);
-    }
-
-  /* We support jobs or pids.
-     wait <pid-or-job> [pid-or-job ...] */
-
-#if defined (JOB_CONTROL)
-  if (nflag)
-    {
-      if (list)
-	{
-	  opt = set_waitlist (list);
-	  if (opt == 0)
-	    WAIT_RETURN (127);
-	  wflags |= JWAIT_WAITING;
-	}
-
-      status = wait_for_any_job (wflags, &pstat);
-      if (vname && status >= 0)
-	builtin_bind_var_to_int (vname, pstat.pid, bindflags);
-
-      if (status < 0)
-	status = 127;
-      if (list)
-	unset_waitlist ();
-      WAIT_RETURN (status);
-    }
-#endif
-      
-  /* But wait without any arguments means to wait for all of the shell's
-     currently active background processes. */
-  if (list == 0)
-    {
-      opt = wait_for_background_pids (&pstat);
-#if 0
-      /* Compatibility with NetBSD sh: don't set VNAME since it doesn't
-	 correspond to the return status. */
-      if (vname && opt)
-	builtin_bind_var_to_int (vname, pstat.pid, bindflags);
-#endif
-      WAIT_RETURN (EXECUTION_SUCCESS);
-    }
-
-  status = EXECUTION_SUCCESS;
-  while (list)
-    {
-      pid_t pid;
-      char *w;
-      intmax_t pid_value;
-
-      w = list->word->word;
-      if (DIGIT (*w))
-	{
-	  if (legal_number (w, &pid_value) && pid_value == (pid_t)pid_value)
-	    {
-	      pid = (pid_t)pid_value;
-	      status = wait_for_single_pid (pid, wflags|JWAIT_PERROR);
-	      /* status > 256 means pid error */
-	      pstat.pid = (status > 256) ? NO_PID : pid;
-	      pstat.status = (status > 256) ? 127 : status;
-	      if (status > 256)
-		status = 127;
-	    }
-	  else
-	    {
-	      sh_badpid (w);
-	      pstat.pid = NO_PID;
-	      pstat.status = 127;
-	      WAIT_RETURN (EXECUTION_FAILURE);
-	    }
-	}
-#if defined (JOB_CONTROL)
-      else if (*w && *w == '%')
-	/* Must be a job spec.  Check it out. */
-	{
-	  int job;
-	  sigset_t set, oset;
-
-	  BLOCK_CHILD (set, oset);
-	  job = get_job_spec (list);
-
-	  if (INVALID_JOB (job))
-	    {
-	      if (job != DUP_JOB)
-		sh_badjob (list->word->word);
-	      UNBLOCK_CHILD (oset);
-	      status = 127;	/* As per Posix.2, section 4.70.2 */
-	      pstat.pid = NO_PID;
-	      pstat.status = status;
-	      list = list->next;
-	      continue;
-	    }
-
-	  /* Job spec used.  Wait for the last pid in the pipeline. */
-	  UNBLOCK_CHILD (oset);
-	  status = wait_for_job (job, wflags, &pstat);
-	}
-#endif /* JOB_CONTROL */
-      else
-	{
-	  sh_badpid (w);
-	  pstat.pid = NO_PID;
-	  pstat.status = 127;
-	  status = EXECUTION_FAILURE;
-	}
-
-      /* Don't waste time with a longjmp. */
-      if (wait_signal_received)
-	{
-	  last_command_exit_signal = wait_signal_received;
-	  status = 128 + wait_signal_received;
-	  wait_sigint_cleanup ();
-	  WAIT_RETURN (status);
-	}
-
-      list = list->next;
-    }
-
-  if (vname && pstat.pid != NO_PID)
-    builtin_bind_var_to_int (vname, pstat.pid, bindflags);
-
-  WAIT_RETURN (status);
-}
-
-#if defined (JOB_CONTROL)
-/* Take each valid pid or jobspec in LIST and mark the corresponding job as
-   J_WAITING, so wait -n knows which jobs to wait for. Return the number of
-   jobs we found. */
-static int
-set_waitlist (list)
-     WORD_LIST *list;
-{
-  sigset_t set, oset;
-  int job, r, njob;
-  intmax_t pid;
-  WORD_LIST *l;
-
-  BLOCK_CHILD (set, oset);
-  njob = 0;
-  for (l = list; l; l = l->next)
-    {
-      job = NO_JOB;
-      job = (l && legal_number (l->word->word, &pid) && pid == (pid_t) pid)
-		? get_job_by_pid ((pid_t) pid, 0, 0)
-		: get_job_spec (l);
-      if (job == NO_JOB || jobs == 0 || INVALID_JOB (job))
-	{
-	  sh_badjob (l->word->word);
-	  continue;
-	}
-      /* We don't check yet to see if one of the desired jobs has already
-	 terminated, but we could. We wait until wait_for_any_job(). This
-	 has the advantage of validating all the arguments. */
-      if ((jobs[job]->flags & J_WAITING) == 0)
-	{
-	  njob++;
-	  jobs[job]->flags |= J_WAITING;
-	}
-    }
-  UNBLOCK_CHILD (oset);
-  return (njob);
-}
-
-/* Clean up after a call to wait -n jobs */
-static void
-unset_waitlist ()
-{
-  int i;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-  for (i = 0; i < js.j_jobslots; i++)
-    if (jobs[i] && (jobs[i]->flags & J_WAITING))
-      jobs[i]->flags &= ~J_WAITING;
-  UNBLOCK_CHILD (oset);
-}
-#endif
diff --git a/third_party/bash/casemod.c b/third_party/bash/casemod.c
deleted file mode 100644
index 6f3f21c78..000000000
--- a/third_party/bash/casemod.c
+++ /dev/null
@@ -1,271 +0,0 @@
-/* casemod.c -- functions to change case of strings */
-
-/* Copyright (C) 2008-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if defined (HAVE_CONFIG_H)
-#  include "config.h"
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif /* HAVE_UNISTD_H */
-
-#include "stdc.h"
-
-#include "bashansi.h"
-#include "bashintl.h"
-#include "bashtypes.h"
-
-#include <stdio.h>
-#include <ctype.h>
-#include "xmalloc.h"
-
-#include "shmbchar.h"
-#include "shmbutil.h"
-#include "chartypes.h"
-#include "typemax.h"
-
-#include "strmatch.h"
-
-#define _to_wupper(wc)	(iswlower (wc) ? towupper (wc) : (wc))
-#define _to_wlower(wc)	(iswupper (wc) ? towlower (wc) : (wc))
-
-#if !defined (HANDLE_MULTIBYTE)
-#  define cval(s, i, l)	((s)[(i)])
-#  define iswalnum(c)	(isalnum(c))
-#  define TOGGLE(x)	(ISUPPER (x) ? tolower ((unsigned char)x) : (TOUPPER (x)))
-#else
-#  define TOGGLE(x)	(iswupper (x) ? towlower (x) : (_to_wupper(x)))
-#endif
-
-/* These must agree with the defines in externs.h */
-#define CASE_NOOP	0x0000
-#define CASE_LOWER	0x0001
-#define CASE_UPPER	0x0002
-#define CASE_CAPITALIZE	0x0004
-#define CASE_UNCAP	0x0008
-#define CASE_TOGGLE	0x0010
-#define CASE_TOGGLEALL	0x0020
-#define CASE_UPFIRST	0x0040
-#define CASE_LOWFIRST	0x0080
-
-#define CASE_USEWORDS	0x1000		/* modify behavior to act on words in passed string */
-
-extern char *substring PARAMS((char *, int, int));
-
-#ifndef UCHAR_MAX
-#  define UCHAR_MAX	TYPE_MAXIMUM(unsigned char)
-#endif
-
-#if defined (HANDLE_MULTIBYTE)
-static wchar_t
-cval (s, i, l)
-     char *s;
-     int i, l;
-{
-  size_t tmp;
-  wchar_t wc;
-  mbstate_t mps;  
-
-  if (MB_CUR_MAX == 1 || is_basic (s[i]))
-    return ((wchar_t)s[i]);
-  if (i >= (l - 1))
-    return ((wchar_t)s[i]);
-  memset (&mps, 0, sizeof (mbstate_t));
-  tmp = mbrtowc (&wc, s + i, l - i, &mps);
-  if (MB_INVALIDCH (tmp) || MB_NULLWCH (tmp))
-    return ((wchar_t)s[i]);
-  return wc;  
-}
-#endif
-
-/* Modify the case of characters in STRING matching PAT based on the value of
-   FLAGS.  If PAT is null, modify the case of each character */
-char *
-sh_modcase (string, pat, flags)
-     const char *string;
-     char *pat;
-     int flags;
-{
-  int start, next, end, retind;
-  int inword, c, nc, nop, match, usewords;
-  char *ret, *s;
-  wchar_t wc;
-  int mb_cur_max;
-#if defined (HANDLE_MULTIBYTE)
-  wchar_t nwc;
-  char mb[MB_LEN_MAX+1];
-  int mlen;
-  size_t m;
-  mbstate_t state;
-#endif
-
-  if (string == 0 || *string == 0)
-    {
-      ret = (char *)xmalloc (1);
-      ret[0] = '\0';
-      return ret;
-    }
-
-#if defined (HANDLE_MULTIBYTE)
-  memset (&state, 0, sizeof (mbstate_t));
-#endif
-
-  start = 0;
-  end = strlen (string);
-  mb_cur_max = MB_CUR_MAX;
-
-  ret = (char *)xmalloc (2*end + 1);
-  retind = 0;
-
-  /* See if we are supposed to split on alphanumerics and operate on each word */
-  usewords = (flags & CASE_USEWORDS);
-  flags &= ~CASE_USEWORDS;
-
-  inword = 0;
-  while (start < end)
-    {
-      wc = cval ((char *)string, start, end);
-
-      if (iswalnum (wc) == 0)
-	inword = 0;
-
-      if (pat)
-	{
-	  next = start;
-	  ADVANCE_CHAR (string, end, next);
-	  s = substring ((char *)string, start, next);
-	  match = strmatch (pat, s, FNM_EXTMATCH) != FNM_NOMATCH;
-	  free (s);
-	  if (match == 0)
-            {
-              /* copy unmatched portion */
-              memcpy (ret + retind, string + start, next - start);
-              retind += next - start;
-              start = next;
-              inword = 1;
-              continue;
-            }
-	}
-
-      /* XXX - for now, the toggling operators work on the individual
-	 words in the string, breaking on alphanumerics.  Should I
-	 leave the capitalization operators to do that also? */
-      if (flags == CASE_CAPITALIZE)
-	{
-	  if (usewords)
-	    nop = inword ? CASE_LOWER : CASE_UPPER;
-	  else
-	    nop = (start > 0) ? CASE_LOWER : CASE_UPPER;
-	  inword = 1;
-	}
-      else if (flags == CASE_UNCAP)
-	{
-	  if (usewords)
-	    nop = inword ? CASE_UPPER : CASE_LOWER;
-	  else
-	    nop = (start > 0) ? CASE_UPPER : CASE_LOWER;
-	  inword = 1;
-	}
-      else if (flags == CASE_UPFIRST)
- 	{
- 	  if (usewords)
-	    nop = inword ? CASE_NOOP : CASE_UPPER;
-	  else
-	    nop = (start > 0) ? CASE_NOOP : CASE_UPPER;
- 	  inword = 1;
- 	}
-      else if (flags == CASE_LOWFIRST)
- 	{
- 	  if (usewords)
-	    nop = inword ? CASE_NOOP : CASE_LOWER;
-	  else
-	    nop = (start > 0) ? CASE_NOOP : CASE_LOWER;
- 	  inword = 1;
- 	}
-      else if (flags == CASE_TOGGLE)
-	{
-	  nop = inword ? CASE_NOOP : CASE_TOGGLE;
-	  inword = 1;
-	}
-      else
-	nop = flags;
-
-      /* Can't short-circuit, some locales have multibyte upper and lower
-	 case equivalents of single-byte ascii characters (e.g., Turkish) */
-      if (mb_cur_max == 1)
-	{
-singlebyte:
-	  switch (nop)
-	    {
-	    default:
-	    case CASE_NOOP:  nc = wc; break;
-	    case CASE_UPPER:  nc = TOUPPER (wc); break;
-	    case CASE_LOWER:  nc = TOLOWER (wc); break;
-	    case CASE_TOGGLEALL:
-	    case CASE_TOGGLE: nc = TOGGLE (wc); break;
-	    }
-	  ret[retind++] = nc;
-	}
-#if defined (HANDLE_MULTIBYTE)
-      else
-	{
-	  m = mbrtowc (&wc, string + start, end - start, &state);
-	  /* Have to go through wide case conversion even for single-byte
-	     chars, to accommodate single-byte characters where the
-	     corresponding upper or lower case equivalent is multibyte. */
-	  if (MB_INVALIDCH (m))
-	    {
-	      wc = (unsigned char)string[start];
-	      goto singlebyte;
-	    }
-	  else if (MB_NULLWCH (m))
-	    wc = L'\0';
-	  switch (nop)
-	    {
-	    default:
-	    case CASE_NOOP:  nwc = wc; break;
-	    case CASE_UPPER:  nwc = _to_wupper (wc); break;
-	    case CASE_LOWER:  nwc = _to_wlower (wc); break;
-	    case CASE_TOGGLEALL:
-	    case CASE_TOGGLE: nwc = TOGGLE (wc); break;
-	    }
-
-	  /* We don't have to convert `wide' characters that are in the
-	     unsigned char range back to single-byte `multibyte' characters. */
-	  if ((int)nwc <= UCHAR_MAX && is_basic ((int)nwc))
-	    ret[retind++] = nwc;
-	  else
-	    {
-	      mlen = wcrtomb (mb, nwc, &state);
-	      if (mlen > 0)
-		mb[mlen] = '\0';
-	      /* Don't assume the same width */
-	      strncpy (ret + retind, mb, mlen);
-	      retind += mlen;
-	    }
-	}
-#endif
-
-      ADVANCE_CHAR (string, end, start);
-    }
-
-  ret[retind] = '\0';
-  return ret;
-}
diff --git a/third_party/bash/chartypes.h b/third_party/bash/chartypes.h
deleted file mode 100644
index d5be4a3ce..000000000
--- a/third_party/bash/chartypes.h
+++ /dev/null
@@ -1,109 +0,0 @@
-/* chartypes.h -- extend ctype.h */
-
-/* Copyright (C) 2001-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _SH_CHARTYPES_H
-#define _SH_CHARTYPES_H
-
-#include <ctype.h>
-
-#ifndef UCHAR_MAX
-#  define UCHAR_MAX 255
-#endif
-#ifndef CHAR_MAX
-#  define CHAR_MAX 127
-#endif
-
-/* use this as a proxy for C89 */
-#if defined (HAVE_STDLIB_H) && defined (HAVE_STRING_H)
-#  define IN_CTYPE_DOMAIN(c) 1
-#else
-#  define IN_CTYPE_DOMAIN(c) ((c) >= 0 && (c) <= CHAR_MAX)
-#endif
-
-#if !defined (isspace) && !defined (HAVE_ISSPACE)
-#  define isspace(c) ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) == '\f')
-#endif
-
-#if !defined (isprint) && !defined (HAVE_ISPRINT)
-#  define isprint(c) (isalpha((unsigned char)c) || isdigit((unsigned char)c) || ispunct((unsigned char)c))
-#endif
-
-#if defined (isblank) || defined (HAVE_ISBLANK)
-#  define ISBLANK(c) (IN_CTYPE_DOMAIN (c) && isblank ((unsigned char)c))
-#else
-#  define ISBLANK(c) ((c) == ' ' || (c) == '\t')
-#endif
-
-#if defined (isgraph) || defined (HAVE_ISGRAPH)
-#  define ISGRAPH(c) (IN_CTYPE_DOMAIN (c) && isgraph (c))
-#else
-#  define ISGRAPH(c) (IN_CTYPE_DOMAIN (c) && isprint ((unsigned char)c) && !isspace ((unsigned char)c))
-#endif
-
-#if !defined (isxdigit) && !defined (HAVE_ISXDIGIT)
-#  define isxdigit(c)	(((c) >= '0' && (c) <= '9') || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
-#endif
-
-#undef ISPRINT
-
-#define ISPRINT(c) (IN_CTYPE_DOMAIN (c) && isprint ((unsigned char)c))
-#define ISDIGIT(c) (IN_CTYPE_DOMAIN (c) && isdigit ((unsigned char)c))
-#define ISALNUM(c) (IN_CTYPE_DOMAIN (c) && isalnum ((unsigned char)c))
-#define ISALPHA(c) (IN_CTYPE_DOMAIN (c) && isalpha ((unsigned char)c))
-#define ISCNTRL(c) (IN_CTYPE_DOMAIN (c) && iscntrl ((unsigned char)c))
-#define ISLOWER(c) (IN_CTYPE_DOMAIN (c) && islower ((unsigned char)c))
-#define ISPUNCT(c) (IN_CTYPE_DOMAIN (c) && ispunct ((unsigned char)c))
-#define ISSPACE(c) (IN_CTYPE_DOMAIN (c) && isspace ((unsigned char)c))
-#define ISUPPER(c) (IN_CTYPE_DOMAIN (c) && isupper ((unsigned char)c))
-#define ISXDIGIT(c) (IN_CTYPE_DOMAIN (c) && isxdigit ((unsigned char)c))
-
-#define ISLETTER(c)	(ISALPHA(c))
-
-#define DIGIT(c)	((c) >= '0' && (c) <= '9')
-
-#define ISWORD(c)	(ISLETTER(c) || DIGIT(c) || ((c) == '_'))
-
-#define HEXVALUE(c) \
-  (((c) >= 'a' && (c) <= 'f') \
-	? (c)-'a'+10 \
-	: (c) >= 'A' && (c) <= 'F' ? (c)-'A'+10 : (c)-'0')
-                  
-#ifndef ISOCTAL
-#  define ISOCTAL(c)	((c) >= '0' && (c) <= '7')
-#endif
-#define OCTVALUE(c)	((c) - '0')
-
-#define TODIGIT(c)	((c) - '0')
-#define TOCHAR(c)	((c) + '0')
-
-#define TOLOWER(c)	(ISUPPER(c) ? tolower(c) : (c))
-#define TOUPPER(c)	(ISLOWER(c) ? toupper(c) : (c))
-
-#ifndef TOCTRL
-   /* letter to control char -- ASCII.  The TOUPPER is in there so \ce and
-      \cE will map to the same character in $'...' expansions. */
-#  define TOCTRL(x)	((x) == '?' ? 0x7f : (TOUPPER(x) & 0x1f))
-#endif
-#ifndef UNCTRL
-   /* control char to letter -- ASCII */
-#  define UNCTRL(x)	(TOUPPER(x ^ 0x40))
-#endif
-
-#endif /* _SH_CHARTYPES_H */
diff --git a/third_party/bash/clktck.c b/third_party/bash/clktck.c
deleted file mode 100644
index 5d370acc1..000000000
--- a/third_party/bash/clktck.c
+++ /dev/null
@@ -1,61 +0,0 @@
-/* clktck.c - get the value of CLK_TCK. */
-
-/* Copyright (C) 1997 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#if defined (HAVE_LIMITS_H)
-#  include <limits.h>
-#endif
-
-#if !defined (HAVE_SYSCONF) || !defined (_SC_CLK_TCK)
-#  if !defined (CLK_TCK)
-#    if defined (HZ)
-#      define CLK_TCK HZ
-#    else
-#      define CLK_TCK 60
-#    endif
-#  endif /* !CLK_TCK */
-#endif /* !HAVE_SYSCONF && !_SC_CLK_TCK */
-
-long
-get_clk_tck ()
-{
-  static long retval = 0;
-
-  if (retval != 0)
-    return (retval);
-
-#if defined (HAVE_SYSCONF) && defined (_SC_CLK_TCK)
-  retval = sysconf (_SC_CLK_TCK);
-#else /* !SYSCONF || !_SC_CLK_TCK */
-  retval = CLK_TCK;
-#endif /* !SYSCONF || !_SC_CLK_TCK */
-
-  return (retval);
-}
diff --git a/third_party/bash/clock.c b/third_party/bash/clock.c
deleted file mode 100644
index 8b9b5a0cc..000000000
--- a/third_party/bash/clock.c
+++ /dev/null
@@ -1,87 +0,0 @@
-/* clock.c - operations on struct tms and clock_t's */
-
-/* Copyright (C) 1999 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_TIMES)
-
-#include <sys/types.h>
-#include "posixtime.h"
-
-#if defined (HAVE_SYS_TIMES_H)
-#  include <sys/times.h>
-#endif
-
-#include <stdio.h>
-#include "stdc.h"
-
-#include "bashintl.h"
-
-#ifndef locale_decpoint
-extern int locale_decpoint PARAMS((void));
-#endif
-
-extern long get_clk_tck PARAMS((void));
-
-void
-clock_t_to_secs (t, sp, sfp)
-     clock_t t;
-     time_t *sp;
-     int *sfp;
-{
-  static long clk_tck = -1;
-
-  if (clk_tck == -1)
-    clk_tck = get_clk_tck ();
-
-  *sfp = t % clk_tck;
-  *sfp = (*sfp * 1000) / clk_tck;
-
-  *sp = t / clk_tck;
-
-  /* Sanity check */
-  if (*sfp >= 1000)
-    {
-      *sp += 1;
-      *sfp -= 1000;
-    }
-}
-
-/* Print the time defined by a clock_t (returned by the `times' and `time'
-   system calls) in a standard way to stdio stream FP.  This is scaled in
-   terms of the value of CLK_TCK, which is what is returned by the
-   `times' call. */
-void
-print_clock_t (fp, t)
-     FILE *fp;
-     clock_t t;
-{
-  time_t timestamp;
-  long minutes;
-  int seconds, seconds_fraction;
-
-  clock_t_to_secs (t, &timestamp, &seconds_fraction);
-
-  minutes = timestamp / 60;
-  seconds = timestamp % 60;
-
-  fprintf (fp, "%ldm%d%c%03ds",  minutes, seconds, locale_decpoint(), seconds_fraction);
-}
-#endif /* HAVE_TIMES */
diff --git a/third_party/bash/collsyms.h b/third_party/bash/collsyms.h
deleted file mode 100644
index d56df6113..000000000
--- a/third_party/bash/collsyms.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/* collsyms.h -- collating symbol names and their corresponding characters
-		 (in ascii) as given by POSIX.2 in table 2.8. */
-
-/* Copyright (C) 1997-2002 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* The upper-case letters, lower-case letters, and digits are omitted from
-   this table.  The digits are not included in the table in the POSIX.2
-   spec.  The upper and lower case letters are translated by the code
-   in smatch.c:collsym(). */
-
-typedef struct _COLLSYM {
-  XCHAR *name;
-  CHAR code;
-} __COLLSYM;
-
-static __COLLSYM POSIXCOLL [] =
-{
-	{  L("NUL"),			L('\0') },
-	{  L("SOH"),			L('\001') },
-	{  L("STX"),			L('\002') },
-	{  L("ETX"),			L('\003') },
-	{  L("EOT"),			L('\004') },
-	{  L("ENQ"),			L('\005') },
-	{  L("ACK"),			L('\006') },
-#ifdef __STDC__
-	{  L("alert"),			L('\a') },
-#else
-	{  L("alert"),			L('\007') },
-#endif
-	{  L("BS"),			L('\010') },
-	{  L("backspace"),		L('\b') },
-	{  L("HT"),			L('\011') },
-	{  L("tab"),			L('\t') },
-	{  L("LF"),			L('\012') },
-	{  L("newline"),		L('\n') },
-	{  L("VT"),			L('\013') },
-	{  L("vertical-tab"),		L('\v') },
-	{  L("FF"),			L('\014') },
-	{  L("form-feed"),		L('\f') },
-	{  L("CR"),			L('\015') },
-	{  L("carriage-return"),	L('\r') },
-	{  L("SO"),			L('\016') },
-	{  L("SI"),			L('\017') },
-	{  L("DLE"),			L('\020') },
-	{  L("DC1"),			L('\021') },
-	{  L("DC2"),			L('\022') },
-	{  L("DC3"),			L('\023') },
-	{  L("DC4"),			L('\024') },
-	{  L("NAK"),			L('\025') },
-	{  L("SYN"),			L('\026') },
-	{  L("ETB"),			L('\027') },
-	{  L("CAN"),			L('\030') },
-	{  L("EM"),			L('\031') },
-	{  L("SUB"),			L('\032') },
-	{  L("ESC"),			L('\033') },
-	{  L("IS4"),			L('\034') },
-	{  L("FS"),			L('\034') },
-	{  L("IS3"),			L('\035') },
-	{  L("GS"),			L('\035') },
-	{  L("IS2"),			L('\036') },
-	{  L("RS"),			L('\036') },
-	{  L("IS1"),			L('\037') },
-	{  L("US"),			L('\037') },
-	{  L("space"),			L(' ') },
-	{  L("exclamation-mark"),	L('!') },
-	{  L("quotation-mark"),		L('"') },
-	{  L("number-sign"),		L('#') },
-	{  L("dollar-sign"),		L('$') },
-	{  L("percent-sign"),		L('%') },
-	{  L("ampersand"),		L('&') },
-	{  L("apostrophe"),		L('\'') },
-	{  L("left-parenthesis"),	L('(') },
-	{  L("right-parenthesis"),	L(')') },
-	{  L("asterisk"),		L('*') },
-	{  L("plus-sign"),		L('+') },
-	{  L("comma"),			L(',') },
-	{  L("hyphen"),			L('-') },
-	{  L("hyphen-minus"),		L('-') },
-	{  L("minus"),			L('-') },	/* extension from POSIX.2 */
-	{  L("dash"),			L('-') },	/* extension from POSIX.2 */
-	{  L("period"),			L('.') },
-	{  L("full-stop"),		L('.') },
-	{  L("slash"),			L('/') },
-	{  L("solidus"),		L('/') },	/* extension from POSIX.2 */
-	{  L("zero"),			L('0') },
-	{  L("one"),			L('1') },
-	{  L("two"),			L('2') },
-	{  L("three"),			L('3') },
-	{  L("four"),			L('4') },
-	{  L("five"),			L('5') },
-	{  L("six"),			L('6') },
-	{  L("seven"),			L('7') },
-	{  L("eight"),			L('8') },
-	{  L("nine"),			L('9') },
-	{  L("colon"),			L(':') },
-	{  L("semicolon"),		L(';') },
-	{  L("less-than-sign"),		L('<') },
-	{  L("equals-sign"),		L('=') },
-	{  L("greater-than-sign"),	L('>') },
-	{  L("question-mark"),		L('?') },
-	{  L("commercial-at"),		L('@') },
-	/* upper-case letters omitted */
-	{  L("left-square-bracket"),	L('[') },
-	{  L("backslash"),		L('\\') },
-	{  L("reverse-solidus"),	L('\\') },
-	{  L("right-square-bracket"),	L(']') },
-	{  L("circumflex"),		L('^') },
-	{  L("circumflex-accent"),	L('^') },	/* extension from POSIX.2 */
-	{  L("underscore"),		L('_') },
-	{  L("grave-accent"),		L('`') },
-	/* lower-case letters omitted */
-	{  L("left-brace"),		L('{') },	/* extension from POSIX.2 */
-	{  L("left-curly-bracket"),	L('{') },
-	{  L("vertical-line"),		L('|') },
-	{  L("right-brace"),		L('}') },	/* extension from POSIX.2 */
-	{  L("right-curly-bracket"),	L('}') },
-	{  L("tilde"),			L('~') },
-	{  L("DEL"),			L('\177') },
-	{  0,	0 },
-};
-
-#undef _COLLSYM
-#undef __COLLSYM
-#undef POSIXCOLL
diff --git a/third_party/bash/command.h b/third_party/bash/command.h
deleted file mode 100644
index e0dc2f955..000000000
--- a/third_party/bash/command.h
+++ /dev/null
@@ -1,409 +0,0 @@
-/* command.h -- The structures used internally to represent commands, and
-   the extern declarations of the functions used to create them. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_COMMAND_H_)
-#define _COMMAND_H_
-
-#include "stdc.h"
-
-/* Instructions describing what kind of thing to do for a redirection. */
-enum r_instruction {
-  r_output_direction, r_input_direction, r_inputa_direction,
-  r_appending_to, r_reading_until, r_reading_string,
-  r_duplicating_input, r_duplicating_output, r_deblank_reading_until,
-  r_close_this, r_err_and_out, r_input_output, r_output_force,
-  r_duplicating_input_word, r_duplicating_output_word,
-  r_move_input, r_move_output, r_move_input_word, r_move_output_word,
-  r_append_err_and_out
-};
-
-/* Redirection flags; values for rflags */
-#define REDIR_VARASSIGN		0x01
-
-/* Redirection errors. */
-#define AMBIGUOUS_REDIRECT  -1
-#define NOCLOBBER_REDIRECT  -2
-#define RESTRICTED_REDIRECT -3	/* can only happen in restricted shells. */
-#define HEREDOC_REDIRECT    -4  /* here-doc temp file can't be created */
-#define BADVAR_REDIRECT	    -5  /* something wrong with {varname}redir */
-
-#define CLOBBERING_REDIRECT(ri) \
-  (ri == r_output_direction || ri == r_err_and_out)
-
-#define OUTPUT_REDIRECT(ri) \
-  (ri == r_output_direction || ri == r_input_output || ri == r_err_and_out || ri == r_append_err_and_out)
-
-#define INPUT_REDIRECT(ri) \
-  (ri == r_input_direction || ri == r_inputa_direction || ri == r_input_output)
-
-#define WRITE_REDIRECT(ri) \
-  (ri == r_output_direction || \
-	ri == r_input_output || \
-	ri == r_err_and_out || \
-	ri == r_appending_to || \
-	ri == r_append_err_and_out || \
-	ri == r_output_force)
-
-/* redirection needs translation */
-#define TRANSLATE_REDIRECT(ri) \
-  (ri == r_duplicating_input_word || ri == r_duplicating_output_word || \
-   ri == r_move_input_word || ri == r_move_output_word)
-
-/* Command Types: */
-enum command_type { cm_for, cm_case, cm_while, cm_if, cm_simple, cm_select,
-		    cm_connection, cm_function_def, cm_until, cm_group,
-		    cm_arith, cm_cond, cm_arith_for, cm_subshell, cm_coproc };
-
-/* Possible values for the `flags' field of a WORD_DESC. */
-#define W_HASDOLLAR	(1 << 0)	/* Dollar sign present. */
-#define W_QUOTED	(1 << 1)	/* Some form of quote character is present. */
-#define W_ASSIGNMENT	(1 << 2)	/* This word is a variable assignment. */
-#define W_SPLITSPACE	(1 << 3)	/* Split this word on " " regardless of IFS */
-#define W_NOSPLIT	(1 << 4)	/* Do not perform word splitting on this word because ifs is empty string. */
-#define W_NOGLOB	(1 << 5)	/* Do not perform globbing on this word. */
-#define W_NOSPLIT2	(1 << 6)	/* Don't split word except for $@ expansion (using spaces) because context does not allow it. */
-#define W_TILDEEXP	(1 << 7)	/* Tilde expand this assignment word */
-#define W_DOLLARAT	(1 << 8)	/* UNUSED - $@ and its special handling */
-#define W_ARRAYREF	(1 << 9)	/* word is a valid array reference */
-#define W_NOCOMSUB	(1 << 10)	/* Don't perform command substitution on this word */
-#define W_ASSIGNRHS	(1 << 11)	/* Word is rhs of an assignment statement */
-#define W_NOTILDE	(1 << 12)	/* Don't perform tilde expansion on this word */
-#define W_NOASSNTILDE	(1 << 13)	/* don't do tilde expansion like an assignment statement */
-#define W_EXPANDRHS	(1 << 14)	/* Expanding word in ${paramOPword} */
-#define W_COMPASSIGN	(1 << 15)	/* Compound assignment */
-#define W_ASSNBLTIN	(1 << 16)	/* word is a builtin command that takes assignments */
-#define W_ASSIGNARG	(1 << 17)	/* word is assignment argument to command */
-#define W_HASQUOTEDNULL	(1 << 18)	/* word contains a quoted null character */
-#define W_DQUOTE	(1 << 19)	/* UNUSED - word should be treated as if double-quoted */
-#define W_NOPROCSUB	(1 << 20)	/* don't perform process substitution */
-#define W_SAWQUOTEDNULL	(1 << 21)	/* word contained a quoted null that was removed */
-#define W_ASSIGNASSOC	(1 << 22)	/* word looks like associative array assignment */
-#define W_ASSIGNARRAY	(1 << 23)	/* word looks like a compound indexed array assignment */
-#define W_ARRAYIND	(1 << 24)	/* word is an array index being expanded */
-#define W_ASSNGLOBAL	(1 << 25)	/* word is a global assignment to declare (declare/typeset -g) */
-#define W_NOBRACE	(1 << 26)	/* Don't perform brace expansion */
-#define W_COMPLETE	(1 << 27)	/* word is being expanded for completion */
-#define W_CHKLOCAL	(1 << 28)	/* check for local vars on assignment */
-#define W_FORCELOCAL	(1 << 29)	/* force assignments to be to local variables, non-fatal on assignment errors */
-/* UNUSED		(1 << 30)	*/
-
-/* Flags for the `pflags' argument to param_expand() and various
-   parameter_brace_expand_xxx functions; also used for string_list_dollar_at */
-#define PF_NOCOMSUB	0x01	/* Do not perform command substitution */
-#define PF_IGNUNBOUND	0x02	/* ignore unbound vars even if -u set */
-#define PF_NOSPLIT2	0x04	/* same as W_NOSPLIT2 */
-#define PF_ASSIGNRHS	0x08	/* same as W_ASSIGNRHS */
-#define PF_COMPLETE	0x10	/* same as W_COMPLETE, sets SX_COMPLETE */
-#define PF_EXPANDRHS	0x20	/* same as W_EXPANDRHS */
-#define PF_ALLINDS	0x40	/* array, act as if [@] was supplied */
-
-/* Possible values for subshell_environment */
-#define SUBSHELL_ASYNC	0x01	/* subshell caused by `command &' */
-#define SUBSHELL_PAREN	0x02	/* subshell caused by ( ... ) */
-#define SUBSHELL_COMSUB	0x04	/* subshell caused by `command` or $(command) */
-#define SUBSHELL_FORK	0x08	/* subshell caused by executing a disk command */
-#define SUBSHELL_PIPE	0x10	/* subshell from a pipeline element */
-#define SUBSHELL_PROCSUB 0x20	/* subshell caused by <(command) or >(command) */
-#define SUBSHELL_COPROC	0x40	/* subshell from a coproc pipeline */
-#define SUBSHELL_RESETTRAP 0x80	/* subshell needs to reset trap strings on first call to trap */
-#define SUBSHELL_IGNTRAP 0x100  /* subshell should reset trapped signals from trap_handler */
-
-/* A structure which represents a word. */
-typedef struct word_desc {
-  char *word;		/* Zero terminated string. */
-  int flags;		/* Flags associated with this word. */
-} WORD_DESC;
-
-/* A linked list of words. */
-typedef struct word_list {
-  struct word_list *next;
-  WORD_DESC *word;
-} WORD_LIST;
-
-
-/* **************************************************************** */
-/*								    */
-/*			Shell Command Structs			    */
-/*								    */
-/* **************************************************************** */
-
-/* What a redirection descriptor looks like.  If the redirection instruction
-   is ri_duplicating_input or ri_duplicating_output, use DEST, otherwise
-   use the file in FILENAME.  Out-of-range descriptors are identified by a
-   negative DEST. */
-
-typedef union {
-  int dest;			/* Place to redirect REDIRECTOR to, or ... */
-  WORD_DESC *filename;		/* filename to redirect to. */
-} REDIRECTEE;
-
-/* Structure describing a redirection.  If REDIRECTOR is negative, the parser
-   (or translator in redir.c) encountered an out-of-range file descriptor. */
-typedef struct redirect {
-  struct redirect *next;	/* Next element, or NULL. */
-  REDIRECTEE redirector;	/* Descriptor or varname to be redirected. */
-  int rflags;			/* Private flags for this redirection */
-  int flags;			/* Flag value for `open'. */
-  enum r_instruction  instruction; /* What to do with the information. */
-  REDIRECTEE redirectee;	/* File descriptor or filename */
-  char *here_doc_eof;		/* The word that appeared in <<foo. */
-} REDIRECT;
-
-/* An element used in parsing.  A single word or a single redirection.
-   This is an ephemeral construct. */
-typedef struct element {
-  WORD_DESC *word;
-  REDIRECT *redirect;
-} ELEMENT;
-
-/* Possible values for command->flags. */
-#define CMD_WANT_SUBSHELL  0x01	/* User wants a subshell: ( command ) */
-#define CMD_FORCE_SUBSHELL 0x02	/* Shell needs to force a subshell. */
-#define CMD_INVERT_RETURN  0x04	/* Invert the exit value. */
-#define CMD_IGNORE_RETURN  0x08	/* Ignore the exit value.  For set -e. */
-#define CMD_NO_FUNCTIONS   0x10 /* Ignore functions during command lookup. */
-#define CMD_INHIBIT_EXPANSION 0x20 /* Do not expand the command words. */
-#define CMD_NO_FORK	   0x40	/* Don't fork; just call execve */
-#define CMD_TIME_PIPELINE  0x80 /* Time a pipeline */
-#define CMD_TIME_POSIX	   0x100 /* time -p; use POSIX.2 time output spec. */
-#define CMD_AMPERSAND	   0x200 /* command & */
-#define CMD_STDIN_REDIR	   0x400 /* async command needs implicit </dev/null */
-#define CMD_COMMAND_BUILTIN 0x0800 /* command executed by `command' builtin */
-#define CMD_COPROC_SUBSHELL 0x1000
-#define CMD_LASTPIPE	    0x2000
-#define CMD_STDPATH	    0x4000	/* use standard path for command lookup */
-#define CMD_TRY_OPTIMIZING  0x8000	/* try to optimize this simple command */
-
-/* What a command looks like. */
-typedef struct command {
-  enum command_type type;	/* FOR CASE WHILE IF CONNECTION or SIMPLE. */
-  int flags;			/* Flags controlling execution environment. */
-  int line;			/* line number the command starts on */
-  REDIRECT *redirects;		/* Special redirects for FOR CASE, etc. */
-  union {
-    struct for_com *For;
-    struct case_com *Case;
-    struct while_com *While;
-    struct if_com *If;
-    struct connection *Connection;
-    struct simple_com *Simple;
-    struct function_def *Function_def;
-    struct group_com *Group;
-#if defined (SELECT_COMMAND)
-    struct select_com *Select;
-#endif
-#if defined (DPAREN_ARITHMETIC)
-    struct arith_com *Arith;
-#endif
-#if defined (COND_COMMAND)
-    struct cond_com *Cond;
-#endif
-#if defined (ARITH_FOR_COMMAND)
-    struct arith_for_com *ArithFor;
-#endif
-    struct subshell_com *Subshell;
-    struct coproc_com *Coproc;
-  } value;
-} COMMAND;
-
-/* Structure used to represent the CONNECTION type. */
-typedef struct connection {
-  int ignore;			/* Unused; simplifies make_command (). */
-  COMMAND *first;		/* Pointer to the first command. */
-  COMMAND *second;		/* Pointer to the second command. */
-  int connector;		/* What separates this command from others. */
-} CONNECTION;
-
-/* Structures used to represent the CASE command. */
-
-/* Values for FLAGS word in a PATTERN_LIST */
-#define CASEPAT_FALLTHROUGH	0x01
-#define CASEPAT_TESTNEXT	0x02
-
-/* Pattern/action structure for CASE_COM. */
-typedef struct pattern_list {
-  struct pattern_list *next;	/* Clause to try in case this one failed. */
-  WORD_LIST *patterns;		/* Linked list of patterns to test. */
-  COMMAND *action;		/* Thing to execute if a pattern matches. */
-  int flags;
-} PATTERN_LIST;
-
-/* The CASE command. */
-typedef struct case_com {
-  int flags;			/* See description of CMD flags. */
-  int line;			/* line number the `case' keyword appears on */
-  WORD_DESC *word;		/* The thing to test. */
-  PATTERN_LIST *clauses;	/* The clauses to test against, or NULL. */
-} CASE_COM;
-
-/* FOR command. */
-typedef struct for_com {
-  int flags;		/* See description of CMD flags. */
-  int line;		/* line number the `for' keyword appears on */
-  WORD_DESC *name;	/* The variable name to get mapped over. */
-  WORD_LIST *map_list;	/* The things to map over.  This is never NULL. */
-  COMMAND *action;	/* The action to execute.
-			   During execution, NAME is bound to successive
-			   members of MAP_LIST. */
-} FOR_COM;
-
-#if defined (ARITH_FOR_COMMAND)
-typedef struct arith_for_com {
-  int flags;
-  int line;	/* generally used for error messages */
-  WORD_LIST *init;
-  WORD_LIST *test;
-  WORD_LIST *step;
-  COMMAND *action;
-} ARITH_FOR_COM;
-#endif
-
-#if defined (SELECT_COMMAND)
-/* KSH SELECT command. */
-typedef struct select_com {
-  int flags;		/* See description of CMD flags. */
-  int line;		/* line number the `select' keyword appears on */
-  WORD_DESC *name;	/* The variable name to get mapped over. */
-  WORD_LIST *map_list;	/* The things to map over.  This is never NULL. */
-  COMMAND *action;	/* The action to execute.
-			   During execution, NAME is bound to the member of
-			   MAP_LIST chosen by the user. */
-} SELECT_COM;
-#endif /* SELECT_COMMAND */
-
-/* IF command. */
-typedef struct if_com {
-  int flags;			/* See description of CMD flags. */
-  COMMAND *test;		/* Thing to test. */
-  COMMAND *true_case;		/* What to do if the test returned non-zero. */
-  COMMAND *false_case;		/* What to do if the test returned zero. */
-} IF_COM;
-
-/* WHILE command. */
-typedef struct while_com {
-  int flags;			/* See description of CMD flags. */
-  COMMAND *test;		/* Thing to test. */
-  COMMAND *action;		/* Thing to do while test is non-zero. */
-} WHILE_COM;
-
-#if defined (DPAREN_ARITHMETIC)
-/* The arithmetic evaluation command, ((...)).  Just a set of flags and
-   a WORD_LIST, of which the first element is the only one used, for the
-   time being. */
-typedef struct arith_com {
-  int flags;
-  int line;
-  WORD_LIST *exp;
-} ARITH_COM;
-#endif /* DPAREN_ARITHMETIC */
-
-/* The conditional command, [[...]].  This is a binary tree -- we slipped
-   a recursive-descent parser into the YACC grammar to parse it. */
-#define COND_AND	1
-#define COND_OR		2
-#define COND_UNARY	3
-#define COND_BINARY	4
-#define COND_TERM	5
-#define COND_EXPR	6
-
-typedef struct cond_com {
-  int flags;
-  int line;
-  int type;
-  WORD_DESC *op;
-  struct cond_com *left, *right;
-} COND_COM;
-
-/* The "simple" command.  Just a collection of words and redirects. */
-typedef struct simple_com {
-  int flags;			/* See description of CMD flags. */
-  int line;			/* line number the command starts on */
-  WORD_LIST *words;		/* The program name, the arguments,
-				   variable assignments, etc. */
-  REDIRECT *redirects;		/* Redirections to perform. */
-} SIMPLE_COM;
-
-/* The "function definition" command. */
-typedef struct function_def {
-  int flags;			/* See description of CMD flags. */
-  int line;			/* Line number the function def starts on. */
-  WORD_DESC *name;		/* The name of the function. */
-  COMMAND *command;		/* The parsed execution tree. */
-  char *source_file;		/* file in which function was defined, if any */
-} FUNCTION_DEF;
-
-/* A command that is `grouped' allows pipes and redirections to affect all
-   commands in the group. */
-typedef struct group_com {
-  int ignore;			/* See description of CMD flags. */
-  COMMAND *command;
-} GROUP_COM;
-
-typedef struct subshell_com {
-  int flags;
-  int line;
-  COMMAND *command;
-} SUBSHELL_COM;
-
-#define COPROC_RUNNING	0x01
-#define COPROC_DEAD	0x02
-
-typedef struct coproc {
-  char *c_name;
-  pid_t c_pid;
-  int c_rfd;
-  int c_wfd;
-  int c_rsave;
-  int c_wsave;
-  int c_flags;
-  int c_status;
-  int c_lock;
-} Coproc;
-
-typedef struct coproc_com {
-  int flags;
-  char *name;
-  COMMAND *command;
-} COPROC_COM;
-
-extern COMMAND *global_command;
-extern Coproc sh_coproc;
-
-/* Possible command errors */
-#define CMDERR_DEFAULT	0
-#define CMDERR_BADTYPE	1
-#define CMDERR_BADCONN	2
-#define CMDERR_BADJUMP	3
-
-#define CMDERR_LAST	3
-
-/* Forward declarations of functions declared in copy_cmd.c. */
-
-extern FUNCTION_DEF *copy_function_def_contents PARAMS((FUNCTION_DEF *, FUNCTION_DEF *));
-extern FUNCTION_DEF *copy_function_def PARAMS((FUNCTION_DEF *));
-
-extern WORD_DESC *copy_word PARAMS((WORD_DESC *));
-extern WORD_LIST *copy_word_list PARAMS((WORD_LIST *));
-extern REDIRECT *copy_redirect PARAMS((REDIRECT *));
-extern REDIRECT *copy_redirects PARAMS((REDIRECT *));
-extern COMMAND *copy_command PARAMS((COMMAND *));
-
-#endif /* _COMMAND_H_ */
diff --git a/third_party/bash/common.c b/third_party/bash/common.c
deleted file mode 100644
index 8f1effa10..000000000
--- a/third_party/bash/common.c
+++ /dev/null
@@ -1,1131 +0,0 @@
-/* common.c - utility functions for all builtins */
-
-/* Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "chartypes.h"
-#include "bashtypes.h"
-#include "posixstat.h"
-#include <signal.h>
-
-#include <errno.h>
-
-#if defined (PREFER_STDARG)
-#  include <stdarg.h>
-#else
-#  include <varargs.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#define NEED_FPURGE_DECL
-
-#include "shell.h"
-#include "maxpath.h"
-#include "flags.h"
-#include "parser.h"
-#include "jobs.h"
-#include "builtins.h"
-#include "input.h"
-#include "execute_cmd.h"
-#include "trap.h"
-#include "bashgetopt.h"
-#include "common.h"
-#include "builtext.h"
-#include "tilde.h"
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#endif
-
-#if !defined (errno)
-extern int errno;   
-#endif /* !errno */
-
-extern const char * const bash_getcwd_errstr;
-
-/* Used by some builtins and the mainline code. */
-sh_builtin_func_t *last_shell_builtin = (sh_builtin_func_t *)NULL;
-sh_builtin_func_t *this_shell_builtin = (sh_builtin_func_t *)NULL;
-
-/* **************************************************************** */
-/*								    */
-/*	     Error reporting, usage, and option processing	    */
-/*								    */
-/* **************************************************************** */
-
-/* This is a lot like report_error (), but it is for shell builtins
-   instead of shell control structures, and it won't ever exit the
-   shell. */
-
-static void
-builtin_error_prolog ()
-{
-  char *name;
-
-  name = get_name_for_error ();
-  fprintf (stderr, "%s: ", name);
-
-  if (interactive_shell == 0)
-    fprintf (stderr, _("line %d: "), executing_line_number ());
-
-  if (this_command_name && *this_command_name)
-    fprintf (stderr, "%s: ", this_command_name);
-}
-
-void
-#if defined (PREFER_STDARG)
-builtin_error (const char *format, ...)
-#else
-builtin_error (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-
-  builtin_error_prolog ();
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  va_end (args);
-  fprintf (stderr, "\n");
-}
-
-void
-#if defined (PREFER_STDARG)
-builtin_warning (const char *format, ...)
-#else
-builtin_warning (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-
-  builtin_error_prolog ();
-  fprintf (stderr, _("warning: "));
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  va_end (args);
-  fprintf (stderr, "\n");
-}
-
-/* Print a usage summary for the currently-executing builtin command. */
-void
-builtin_usage ()
-{
-  if (this_command_name && *this_command_name)
-    fprintf (stderr, _("%s: usage: "), this_command_name);
-  fprintf (stderr, "%s\n", _(current_builtin->short_doc));
-  fflush (stderr);
-}
-
-/* Return if LIST is NULL else barf and jump to top_level.  Used by some
-   builtins that do not accept arguments. */
-void
-no_args (list)
-     WORD_LIST *list;
-{
-  if (list)
-    {
-      builtin_error (_("too many arguments"));
-      top_level_cleanup ();
-      jump_to_top_level (DISCARD);
-    }
-}
-
-/* Check that no options were given to the currently-executing builtin,
-   and return 0 if there were options. */
-int
-no_options (list)
-     WORD_LIST *list;
-{
-  int opt;
-
-  reset_internal_getopt ();
-  if ((opt = internal_getopt (list, "")) != -1)
-    {
-      if (opt == GETOPT_HELP)
-	{
-	  builtin_help ();
-	  return (2);
-	}
-      builtin_usage ();
-      return (1);
-    }
-  return (0);
-}
-
-void
-sh_needarg (s)
-     char *s;
-{
-  builtin_error (_("%s: option requires an argument"), s);
-}
-
-void
-sh_neednumarg (s)
-     char *s;
-{
-  builtin_error (_("%s: numeric argument required"), s);
-}
-
-void
-sh_notfound (s)
-     char *s;
-{
-  builtin_error (_("%s: not found"), s);
-}
-
-/* Function called when one of the builtin commands detects an invalid
-   option. */
-void
-sh_invalidopt (s)
-     char *s;
-{
-  builtin_error (_("%s: invalid option"), s);
-}
-
-void
-sh_invalidoptname (s)
-     char *s;
-{
-  builtin_error (_("%s: invalid option name"), s);
-}
-
-void
-sh_invalidid (s)
-     char *s;
-{
-  builtin_error (_("`%s': not a valid identifier"), s);
-}
-
-void
-sh_invalidnum (s)
-     char *s;
-{
-  char *msg;
-
-  if (*s == '0' && isdigit ((unsigned char)s[1]))
-    msg = _("invalid octal number");
-  else if (*s == '0' && s[1] == 'x')
-    msg = _("invalid hex number");
-  else
-    msg = _("invalid number");
-  builtin_error ("%s: %s", s, msg);
-}
-
-void
-sh_invalidsig (s)
-     char *s;
-{
-  builtin_error (_("%s: invalid signal specification"), s);
-}
-
-void
-sh_badpid (s)
-     char *s;
-{
-  builtin_error (_("`%s': not a pid or valid job spec"), s);
-}
-
-void
-sh_readonly (s)
-     const char *s;
-{
-  builtin_error (_("%s: readonly variable"), s);
-}
-
-void
-sh_noassign (s)
-     const char *s;
-{
-  internal_error (_("%s: cannot assign"), s);	/* XXX */
-}
-
-void
-sh_erange (s, desc)
-     char *s, *desc;
-{
-  if (s)
-    builtin_error (_("%s: %s out of range"), s, desc ? desc : _("argument"));
-  else
-    builtin_error (_("%s out of range"), desc ? desc : _("argument"));
-}
-
-#if defined (JOB_CONTROL)
-void
-sh_badjob (s)
-     char *s;
-{
-  builtin_error (_("%s: no such job"), s);
-}
-
-void
-sh_nojobs (s)
-     char *s;
-{
-  if (s)
-    builtin_error (_("%s: no job control"), s);
-  else
-    builtin_error (_("no job control"));
-}
-#endif
-
-#if defined (RESTRICTED_SHELL)
-void
-sh_restricted (s)
-     char *s;
-{
-  if (s)
-    builtin_error (_("%s: restricted"), s);
-  else
-    builtin_error (_("restricted"));
-}
-#endif
-
-void
-sh_notbuiltin (s)
-     char *s;
-{
-  builtin_error (_("%s: not a shell builtin"), s);
-}
-
-void
-sh_wrerror ()
-{
-#if defined (DONT_REPORT_BROKEN_PIPE_WRITE_ERRORS) && defined (EPIPE)
-  if (errno != EPIPE)
-#endif /* DONT_REPORT_BROKEN_PIPE_WRITE_ERRORS && EPIPE */
-  builtin_error (_("write error: %s"), strerror (errno));
-}
-
-void
-sh_ttyerror (set)
-     int set;
-{
-  if (set)
-    builtin_error (_("error setting terminal attributes: %s"), strerror (errno));
-  else
-    builtin_error (_("error getting terminal attributes: %s"), strerror (errno));
-}
-
-int
-sh_chkwrite (s)
-     int s;
-{
-  QUIT;
-  fflush (stdout);
-  QUIT;
-  if (ferror (stdout))
-    {
-      sh_wrerror ();
-      fpurge (stdout);
-      clearerr (stdout);
-      return (EXECUTION_FAILURE);
-    }
-  return (s);
-}
-
-/* **************************************************************** */
-/*								    */
-/*	     Shell positional parameter manipulation		    */
-/*								    */
-/* **************************************************************** */
-
-/* Convert a WORD_LIST into a C-style argv.  Return the number of elements
-   in the list in *IP, if IP is non-null.  A convenience function for
-   loadable builtins; also used by `test'. */
-char **
-make_builtin_argv (list, ip)
-     WORD_LIST *list;
-     int *ip;
-{
-  char **argv;
-
-  argv = strvec_from_word_list (list, 0, 1, ip);
-  argv[0] = this_command_name;
-  return argv;
-}
-
-/* Remember LIST in $1 ... $9, and REST_OF_ARGS.  If DESTRUCTIVE is
-   non-zero, then discard whatever the existing arguments are, else
-   only discard the ones that are to be replaced.  Set POSPARAM_COUNT
-   to the number of args assigned (length of LIST). */
-void
-remember_args (list, destructive)
-     WORD_LIST *list;
-     int destructive;
-{
-  register int i;
-
-  posparam_count = 0;
-
-  for (i = 1; i < 10; i++)
-    {
-      if ((destructive || list) && dollar_vars[i])
-	{
-	  free (dollar_vars[i]);
-	  dollar_vars[i] = (char *)NULL;
-	}
-
-      if (list)
-	{
-	  dollar_vars[posparam_count = i] = savestring (list->word->word);
-	  list = list->next;
-	}
-    }
-
-  /* If arguments remain, assign them to REST_OF_ARGS.
-     Note that copy_word_list (NULL) returns NULL, and
-     that dispose_words (NULL) does nothing. */
-  if (destructive || list)
-    {
-      dispose_words (rest_of_args);
-      rest_of_args = copy_word_list (list);
-      posparam_count += list_length (list);
-    }
-
-  if (destructive)
-    set_dollar_vars_changed ();
-
-  invalidate_cached_quoted_dollar_at ();
-}
-
-void
-shift_args (times)
-     int times;
-{
-  WORD_LIST *temp;
-  int count;
-
-  if (times <= 0)		/* caller should check */
-    return;
-
-  while (times-- > 0)
-    {
-      if (dollar_vars[1])
-	free (dollar_vars[1]);
-
-      for (count = 1; count < 9; count++)
-	dollar_vars[count] = dollar_vars[count + 1];
-
-      if (rest_of_args)
-	{
-	  temp = rest_of_args;
-	  dollar_vars[9] = savestring (temp->word->word);
-	  rest_of_args = rest_of_args->next;
-	  temp->next = (WORD_LIST *)NULL;
-	  dispose_words (temp);
-	}
-      else
-	dollar_vars[9] = (char *)NULL;
-
-      posparam_count--;
-    }
-}
-
-int
-number_of_args ()
-{
-#if 0
-  register WORD_LIST *list;
-  int n;
-
-  for (n = 0; n < 9 && dollar_vars[n+1]; n++)
-    ;
-  for (list = rest_of_args; list; list = list->next)
-    n++;
-
-if (n != posparam_count)
-  itrace("number_of_args: n (%d) != posparam_count (%d)", n, posparam_count);
-#else
-  return posparam_count;
-#endif
-}
-
-static int changed_dollar_vars;
-
-/* Have the dollar variables been reset to new values since we last
-   checked? */
-int
-dollar_vars_changed ()
-{
-  return (changed_dollar_vars);
-}
-
-void
-set_dollar_vars_unchanged ()
-{
-  changed_dollar_vars = 0;
-}
-
-void
-set_dollar_vars_changed ()
-{
-  if (variable_context)
-    changed_dollar_vars |= ARGS_FUNC;
-  else if (this_shell_builtin == set_builtin)
-    changed_dollar_vars |= ARGS_SETBLTIN;
-  else
-    changed_dollar_vars |= ARGS_INVOC;
-}
-
-/* **************************************************************** */
-/*								    */
-/*		Validating numeric input and arguments		    */
-/*								    */
-/* **************************************************************** */
-
-/* Read a numeric arg for this_command_name, the name of the shell builtin
-   that wants it.  LIST is the word list that the arg is to come from.
-   Accept only the numeric argument; report an error if other arguments
-   follow.  If FATAL is 1, call throw_to_top_level, which exits the
-   shell; if it's 2, call jump_to_top_level (DISCARD), which aborts the
-   current command; if FATAL is 0, return an indication of an invalid
-   number by setting *NUMOK == 0 and return -1. */
-int
-get_numeric_arg (list, fatal, count)
-     WORD_LIST *list;
-     int fatal;
-     intmax_t *count;
-{
-  char *arg;
-
-  if (count)
-    *count = 1;
-
-  if (list && list->word && ISOPTION (list->word->word, '-'))
-    list = list->next;
-
-  if (list)
-    {
-      arg = list->word->word;
-      if (arg == 0 || (legal_number (arg, count) == 0))
-	{
-	  sh_neednumarg (list->word->word ? list->word->word : "`'");
-	  if (fatal == 0)
-	    return 0;
-	  else if (fatal == 1)		/* fatal == 1; abort */
-	    throw_to_top_level ();
-	  else				/* fatal == 2; discard current command */
-	    {
-	      top_level_cleanup ();
-	      jump_to_top_level (DISCARD);
-	    }
-	}
-      no_args (list->next);
-    }
-
-  return (1);
-}
-
-/* Get an eight-bit status value from LIST */
-int
-get_exitstat (list)
-     WORD_LIST *list;
-{
-  int status;
-  intmax_t sval;
-  char *arg;
-
-  if (list && list->word && ISOPTION (list->word->word, '-'))
-    list = list->next;
-
-  if (list == 0)
-    {
-      /* If we're not running the DEBUG trap, the return builtin, when not
-	 given any arguments, uses the value of $? before the trap ran.  If
-	 given an argument, return uses it.  This means that the trap can't
-	 change $?.  The DEBUG trap gets to change $?, though, since that is
-	 part of its reason for existing, and because the extended debug mode
-	 does things with the return value. */
-      if (this_shell_builtin == return_builtin && running_trap > 0 && running_trap != DEBUG_TRAP+1)
-	return (trap_saved_exit_value);
-      return (last_command_exit_value);
-    }
-
-  arg = list->word->word;
-  if (arg == 0 || legal_number (arg, &sval) == 0)
-    {
-      sh_neednumarg (list->word->word ? list->word->word : "`'");
-      return EX_BADUSAGE;
-    }
-  no_args (list->next);
-
-  status = sval & 255;
-  return status;
-}
-
-/* Return the octal number parsed from STRING, or -1 to indicate
-   that the string contained a bad number. */
-int
-read_octal (string)
-     char *string;
-{
-  int result, digits;
-
-  result = digits = 0;
-  while (*string && ISOCTAL (*string))
-    {
-      digits++;
-      result = (result * 8) + (*string++ - '0');
-      if (result > 07777)
-	return -1;
-    }
-
-  if (digits == 0 || *string)
-    result = -1;
-
-  return (result);
-}
-
-/* **************************************************************** */
-/*								    */
-/*	     Manipulating the current working directory		    */
-/*								    */
-/* **************************************************************** */
-
-/* Return a consed string which is the current working directory.
-   FOR_WHOM is the name of the caller for error printing.  */
-char *the_current_working_directory = (char *)NULL;
-
-char *
-get_working_directory (for_whom)
-     char *for_whom;
-{
-  if (no_symbolic_links)
-    {
-      FREE (the_current_working_directory);
-      the_current_working_directory = (char *)NULL;
-    }
-
-  if (the_current_working_directory == 0)
-    {
-#if defined (GETCWD_BROKEN)
-      the_current_working_directory = getcwd (0, PATH_MAX);
-#else
-      the_current_working_directory = getcwd (0, 0);
-#endif
-      if (the_current_working_directory == 0)
-	{
-	  fprintf (stderr, _("%s: error retrieving current directory: %s: %s\n"),
-		   (for_whom && *for_whom) ? for_whom : get_name_for_error (),
-		   _(bash_getcwd_errstr), strerror (errno));
-	  return (char *)NULL;
-	}
-    }
-
-  return (savestring (the_current_working_directory));
-}
-
-/* Make NAME our internal idea of the current working directory. */
-void
-set_working_directory (name)
-     char *name;
-{
-  FREE (the_current_working_directory);
-  the_current_working_directory = savestring (name);
-}
-
-/* **************************************************************** */
-/*								    */
-/*	     	Job control support functions			    */
-/*								    */
-/* **************************************************************** */
-
-#if defined (JOB_CONTROL)
-int
-get_job_by_name (name, flags)
-     const char *name;
-     int flags;
-{
-  register int i, wl, cl, match, job;
-  register PROCESS *p;
-  register JOB *j;
-
-  job = NO_JOB;
-  wl = strlen (name);
-  for (i = js.j_jobslots - 1; i >= 0; i--)
-    {
-      j = get_job_by_jid (i);
-      if (j == 0 || ((flags & JM_STOPPED) && J_JOBSTATE(j) != JSTOPPED))
-        continue;
-
-      p = j->pipe;
-      do
-        {
-	  if (flags & JM_EXACT)
-	    {
-	      cl = strlen (p->command);
-	      match = STREQN (p->command, name, cl);
-	    }
-	  else if (flags & JM_SUBSTRING)
-	    match = strcasestr (p->command, name) != (char *)0;
-	  else
-	    match = STREQN (p->command, name, wl);
-
-	  if (match == 0)
-	    {
-	      p = p->next;
-	      continue;
-	    }
-	  else if (flags & JM_FIRSTMATCH)
-	    return i;		/* return first match */
-	  else if (job != NO_JOB)
-	    {
-	      if (this_shell_builtin)
-	        builtin_error (_("%s: ambiguous job spec"), name);
-	      else
-	        internal_error (_("%s: ambiguous job spec"), name);
-	      return (DUP_JOB);
-	    }
-	  else
-	    job = i;
-        }
-      while (p != j->pipe);
-    }
-
-  return (job);
-}
-
-/* Return the job spec found in LIST. */
-int
-get_job_spec (list)
-     WORD_LIST *list;
-{
-  register char *word;
-  int job, jflags;
-
-  if (list == 0)
-    return (js.j_current);
-
-  word = list->word->word;
-
-  if (*word == '\0')
-    return (NO_JOB);
-
-  if (*word == '%')
-    word++;
-
-  if (DIGIT (*word) && all_digits (word))
-    {
-      job = atoi (word);
-      return ((job < 0 || job > js.j_jobslots) ? NO_JOB : job - 1);
-    }
-
-  jflags = 0;
-  switch (*word)
-    {
-    case 0:
-    case '%':
-    case '+':
-      return (js.j_current);
-
-    case '-':
-      return (js.j_previous);
-
-    case '?':			/* Substring search requested. */
-      jflags |= JM_SUBSTRING;
-      word++;
-      /* FALLTHROUGH */
-
-    default:
-      return get_job_by_name (word, jflags);
-    }
-}
-#endif /* JOB_CONTROL */
-
-/*
- * NOTE:  `kill' calls this function with forcecols == 0
- */
-int
-display_signal_list (list, forcecols)
-     WORD_LIST *list;
-     int forcecols;
-{
-  register int i, column;
-  char *name;
-  int result, signum, dflags;
-  intmax_t lsignum;
-
-  result = EXECUTION_SUCCESS;
-  if (!list)
-    {
-      for (i = 1, column = 0; i < NSIG; i++)
-	{
-	  name = signal_name (i);
-	  if (STREQN (name, "SIGJUNK", 7) || STREQN (name, "Unknown", 7))
-	    continue;
-
-	  if (posixly_correct && !forcecols)
-	    {
-	      /* This is for the kill builtin.  POSIX.2 says the signal names
-		 are displayed without the `SIG' prefix. */
-	      if (STREQN (name, "SIG", 3))
-		name += 3;
-	      printf ("%s%s", name, (i == NSIG - 1) ? "" : " ");
-	    }
-	  else
-	    {
-	      printf ("%2d) %s", i, name);
-
-	      if (++column < 5)
-		printf ("\t");
-	      else
-		{
-		  printf ("\n");
-		  column = 0;
-		}
-	    }
-	}
-
-      if ((posixly_correct && !forcecols) || column != 0)
-	printf ("\n");
-      return result;
-    }
-
-  /* List individual signal names or numbers. */
-  while (list)
-    {
-      if (legal_number (list->word->word, &lsignum))
-	{
-	  /* This is specified by Posix.2 so that exit statuses can be
-	     mapped into signal numbers. */
-	  if (lsignum > 128)
-	    lsignum -= 128;
-	  if (lsignum < 0 || lsignum >= NSIG)
-	    {
-	      sh_invalidsig (list->word->word);
-	      result = EXECUTION_FAILURE;
-	      list = list->next;
-	      continue;
-	    }
-
-	  signum = lsignum;
-	  name = signal_name (signum);
-	  if (STREQN (name, "SIGJUNK", 7) || STREQN (name, "Unknown", 7))
-	    {
-	      list = list->next;
-	      continue;
-	    }
-	  /* POSIX.2 says that `kill -l signum' prints the signal name without
-	     the `SIG' prefix. */
-	  printf ("%s\n", (this_shell_builtin == kill_builtin && signum > 0) ? name + 3 : name);
-	}
-      else
-	{
-	  dflags = DSIG_NOCASE;
-	  if (posixly_correct == 0 || this_shell_builtin != kill_builtin)
-	    dflags |= DSIG_SIGPREFIX;
-	  signum = decode_signal (list->word->word, dflags);
-	  if (signum == NO_SIG)
-	    {
-	      sh_invalidsig (list->word->word);
-	      result = EXECUTION_FAILURE;
-	      list = list->next;
-	      continue;
-	    }
-	  printf ("%d\n", signum);
-	}
-      list = list->next;
-    }
-  return (result);
-}
-
-/* **************************************************************** */
-/*								    */
-/*	    Finding builtin commands and their functions	    */
-/*								    */
-/* **************************************************************** */
-
-/* Perform a binary search and return the address of the builtin function
-   whose name is NAME.  If the function couldn't be found, or the builtin
-   is disabled or has no function associated with it, return NULL.
-   Return the address of the builtin.
-   DISABLED_OKAY means find it even if the builtin is disabled. */
-struct builtin *
-builtin_address_internal (name, disabled_okay)
-     char *name;
-     int disabled_okay;
-{
-  int hi, lo, mid, j;
-
-  hi = num_shell_builtins - 1;
-  lo = 0;
-
-  while (lo <= hi)
-    {
-      mid = (lo + hi) / 2;
-
-      j = shell_builtins[mid].name[0] - name[0];
-
-      if (j == 0)
-	j = strcmp (shell_builtins[mid].name, name);
-
-      if (j == 0)
-	{
-	  /* It must have a function pointer.  It must be enabled, or we
-	     must have explicitly allowed disabled functions to be found,
-	     and it must not have been deleted. */
-	  if (shell_builtins[mid].function &&
-	      ((shell_builtins[mid].flags & BUILTIN_DELETED) == 0) &&
-	      ((shell_builtins[mid].flags & BUILTIN_ENABLED) || disabled_okay))
-	    return (&shell_builtins[mid]);
-	  else
-	    return ((struct builtin *)NULL);
-	}
-      if (j > 0)
-	hi = mid - 1;
-      else
-	lo = mid + 1;
-    }
-  return ((struct builtin *)NULL);
-}
-
-/* Return the pointer to the function implementing builtin command NAME. */
-sh_builtin_func_t *
-find_shell_builtin (name)
-     char *name;
-{
-  current_builtin = builtin_address_internal (name, 0);
-  return (current_builtin ? current_builtin->function : (sh_builtin_func_t *)NULL);
-}
-
-/* Return the address of builtin with NAME, whether it is enabled or not. */
-sh_builtin_func_t *
-builtin_address (name)
-     char *name;
-{
-  current_builtin = builtin_address_internal (name, 1);
-  return (current_builtin ? current_builtin->function : (sh_builtin_func_t *)NULL);
-}
-
-/* Return the function implementing the builtin NAME, but only if it is a
-   POSIX.2 special builtin. */
-sh_builtin_func_t *
-find_special_builtin (name)
-     char *name;
-{
-  current_builtin = builtin_address_internal (name, 0);
-  return ((current_builtin && (current_builtin->flags & SPECIAL_BUILTIN)) ?
-  			current_builtin->function :
-  			(sh_builtin_func_t *)NULL);
-}
-
-static int
-shell_builtin_compare (sbp1, sbp2)
-     struct builtin *sbp1, *sbp2;
-{
-  int result;
-
-  if ((result = sbp1->name[0] - sbp2->name[0]) == 0)
-    result = strcmp (sbp1->name, sbp2->name);
-
-  return (result);
-}
-
-/* Sort the table of shell builtins so that the binary search will work
-   in find_shell_builtin. */
-void
-initialize_shell_builtins ()
-{
-  qsort (shell_builtins, num_shell_builtins, sizeof (struct builtin),
-    (QSFUNC *)shell_builtin_compare);
-}
-
-#if !defined (HELP_BUILTIN)
-void
-builtin_help ()
-{
-  printf ("%s: %s\n", this_command_name, _("help not available in this version"));
-}
-#endif
-
-/* **************************************************************** */
-/*								    */
-/*	    Variable assignments during builtin commands	    */
-/*								    */
-/* **************************************************************** */
-
-/* Assign NAME=VALUE, passing FLAGS to the assignment functions. */
-SHELL_VAR *
-builtin_bind_variable (name, value, flags)
-     char *name;
-     char *value;
-     int flags;
-{
-  SHELL_VAR *v;
-  int vflags, bindflags;
-
-#if defined (ARRAY_VARS)
-  /* Callers are responsible for calling this with array references that have
-     already undergone valid_array_reference checks (read, printf). */
-  vflags = assoc_expand_once ? (VA_NOEXPAND|VA_ONEWORD) : 0;
-  bindflags = flags | (assoc_expand_once ? ASS_NOEXPAND : 0) | ASS_ALLOWALLSUB;
-  if (flags & ASS_NOEXPAND)
-    vflags |= VA_NOEXPAND;
-  if (flags & ASS_ONEWORD)
-    vflags |= VA_ONEWORD;
-
-  if (valid_array_reference (name, vflags) == 0)
-    v = bind_variable (name, value, flags);
-  else
-    v = assign_array_element (name, value, bindflags, (array_eltstate_t *)0);
-#else /* !ARRAY_VARS */
-  v = bind_variable (name, value, flags);
-#endif /* !ARRAY_VARS */
-
-  if (v && readonly_p (v) == 0 && noassign_p (v) == 0)
-    VUNSETATTR (v, att_invisible);
-
-  return v;
-}
-
-SHELL_VAR *
-builtin_bind_var_to_int (name, val, flags)
-     char *name;
-     intmax_t val;
-     int flags;
-{
-  SHELL_VAR *v;
-
-  v = bind_var_to_int (name, val, flags|ASS_ALLOWALLSUB);
-  return v;
-}
-
-#if defined (ARRAY_VARS)
-SHELL_VAR *
-builtin_find_indexed_array (array_name, flags)
-     char *array_name;
-     int flags;
-{
-  SHELL_VAR *entry;
-
-  if ((flags & 2) && legal_identifier (array_name) == 0)
-    {
-      sh_invalidid (array_name);
-      return (SHELL_VAR *)NULL;
-    }
-
-  entry = find_or_make_array_variable (array_name, 1);
-  /* With flags argument & 1, find_or_make_array_variable checks for readonly
-     and noassign variables and prints error messages. */
-  if (entry == 0)
-    return entry;
-  else if (array_p (entry) == 0)
-    {
-      builtin_error (_("%s: not an indexed array"), array_name);
-      return (SHELL_VAR *)NULL;
-    }
-  else if (invisible_p (entry))
-    VUNSETATTR (entry, att_invisible);	/* no longer invisible */
-
-  if (flags & 1)
-    array_flush (array_cell (entry));
-
-  return entry;
-}
-#endif /* ARRAY_VARS */	
-
-/* Like check_unbind_variable, but for use by builtins (only matters for
-   error messages). */
-int
-builtin_unbind_variable (vname)
-     const char *vname;
-{
-  SHELL_VAR *v;
-
-  v = find_variable (vname);
-  if (v && readonly_p (v))
-    {
-      builtin_error (_("%s: cannot unset: readonly %s"), vname, "variable");
-      return -2;
-    }
-  else if (v && non_unsettable_p (v))
-    {
-      builtin_error (_("%s: cannot unset"), vname);
-      return -2;
-    }
-  return (unbind_variable (vname));
-}
-
-int
-builtin_arrayref_flags (w, baseflags)
-     WORD_DESC *w;
-     int baseflags;
-{
-  char *t;
-  int vflags;
-
-  vflags = baseflags;
-
-  /* Don't require assoc_expand_once if we have an argument that's already
-     passed through valid_array_reference and been expanded once. That
-     doesn't protect it from normal expansions like word splitting, so
-     proper quoting is still required. */
-  if (w->flags & W_ARRAYREF)
-    vflags |= VA_ONEWORD|VA_NOEXPAND;
-
-#  if 0
-  /* This is a little sketchier but handles quoted arguments. */
-  if (assoc_expand_once && (t =  strchr (w->word, '[')) && t[strlen(t) - 1] == ']')
-    vflags |= VA_ONEWORD|VA_NOEXPAND;
-#  endif
-
-  return vflags;
-}
-
-/* **************************************************************** */
-/*								    */
-/*	    External interface to manipulate shell options	    */
-/*								    */
-/* **************************************************************** */
-
-#if defined (ARRAY_VARS)
-int
-set_expand_once (nval, uwp)
-     int nval, uwp;
-{
-  int oa;
-
-  oa = assoc_expand_once;
-  if (shell_compatibility_level > 51)	/* XXX - internal */
-    {
-      if (uwp)
-	unwind_protect_int (assoc_expand_once);
-      assoc_expand_once = nval;
-    }
-  return oa;
-}
-#endif
diff --git a/third_party/bash/common.h b/third_party/bash/common.h
deleted file mode 100644
index f5cd87f08..000000000
--- a/third_party/bash/common.h
+++ /dev/null
@@ -1,282 +0,0 @@
-/* common.h -- extern declarations for functions defined in common.c. */
-
-/* Copyright (C) 1993-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if  !defined (__COMMON_H)
-#  define __COMMON_H
-
-#include "stdc.h"
-
-#define ISOPTION(s, c)	(s[0] == '-' && s[1] == c && !s[2])
-#define ISHELP(s)	(STREQ ((s), "--help"))
-
-#define CHECK_HELPOPT(l) \
-do { \
-  if ((l) && (l)->word && ISHELP((l)->word->word)) \
-    { \
-      builtin_help (); \
-      return (EX_USAGE); \
-    } \
-} while (0)
-
-#define CASE_HELPOPT \
-  case GETOPT_HELP: \
-    builtin_help (); \
-    return (EX_USAGE)
-
-/* Flag values for parse_and_execute () and parse_string () */
-#define SEVAL_NONINT	0x001
-#define SEVAL_INTERACT	0x002
-#define SEVAL_NOHIST	0x004
-#define SEVAL_NOFREE	0x008
-#define SEVAL_RESETLINE	0x010
-#define SEVAL_PARSEONLY	0x020
-#define SEVAL_NOLONGJMP 0x040
-#define SEVAL_FUNCDEF	0x080		/* only allow function definitions */
-#define SEVAL_ONECMD	0x100		/* only allow a single command */
-#define SEVAL_NOHISTEXP	0x200		/* inhibit history expansion */
-
-/* Flags for describe_command, shared between type.def and command.def */
-#define CDESC_ALL		0x001	/* type -a */
-#define CDESC_SHORTDESC		0x002	/* command -V */
-#define CDESC_REUSABLE		0x004	/* command -v */
-#define CDESC_TYPE		0x008	/* type -t */
-#define CDESC_PATH_ONLY		0x010	/* type -p */
-#define CDESC_FORCE_PATH	0x020	/* type -ap or type -P */
-#define CDESC_NOFUNCS		0x040	/* type -f */
-#define CDESC_ABSPATH		0x080	/* convert to absolute path, no ./ */
-#define CDESC_STDPATH		0x100	/* command -p */
-
-/* Flags for get_job_by_name */
-#define JM_PREFIX		0x01	/* prefix of job name */
-#define JM_SUBSTRING		0x02	/* substring of job name */
-#define JM_EXACT		0x04	/* match job name exactly */
-#define JM_STOPPED		0x08	/* match stopped jobs only */
-#define JM_FIRSTMATCH		0x10	/* return first matching job */
-
-/* Flags for remember_args and value of changed_dollar_vars */
-#define ARGS_NONE		0x0
-#define ARGS_INVOC		0x01
-#define ARGS_FUNC		0x02
-#define ARGS_SETBLTIN		0x04
-
-/* Maximum number of attribute letters */
-#define MAX_ATTRIBUTES		16
-
-/* Functions from common.c */
-extern void builtin_error PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-extern void builtin_warning PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-extern void builtin_usage PARAMS((void));
-extern void no_args PARAMS((WORD_LIST *));
-extern int no_options PARAMS((WORD_LIST *));
-
-/* common error message functions */
-extern void sh_needarg PARAMS((char *));
-extern void sh_neednumarg PARAMS((char *));
-extern void sh_notfound PARAMS((char *));
-extern void sh_invalidopt PARAMS((char *));
-extern void sh_invalidoptname PARAMS((char *));
-extern void sh_invalidid PARAMS((char *));
-extern void sh_invalidnum PARAMS((char *));
-extern void sh_invalidsig PARAMS((char *));
-extern void sh_readonly PARAMS((const char *));
-extern void sh_noassign PARAMS((const char *));
-extern void sh_erange PARAMS((char *, char *));
-extern void sh_badpid PARAMS((char *));
-extern void sh_badjob PARAMS((char *));
-extern void sh_nojobs PARAMS((char *));
-extern void sh_restricted PARAMS((char *));
-extern void sh_notbuiltin PARAMS((char *));
-extern void sh_wrerror PARAMS((void));
-extern void sh_ttyerror PARAMS((int));
-extern int sh_chkwrite PARAMS((int));
-
-extern char **make_builtin_argv PARAMS((WORD_LIST *, int *));
-extern void remember_args PARAMS((WORD_LIST *, int));
-extern void shift_args PARAMS((int));
-extern int number_of_args PARAMS((void));
-
-extern int dollar_vars_changed PARAMS((void));
-extern void set_dollar_vars_unchanged PARAMS((void));
-extern void set_dollar_vars_changed PARAMS((void));
-
-extern int get_numeric_arg PARAMS((WORD_LIST *, int, intmax_t *));
-extern int get_exitstat PARAMS((WORD_LIST *));
-extern int read_octal PARAMS((char *));
-
-/* Keeps track of the current working directory. */
-extern char *the_current_working_directory;
-extern char *get_working_directory PARAMS((char *));
-extern void set_working_directory PARAMS((char *));
-
-#if defined (JOB_CONTROL)
-extern int get_job_by_name PARAMS((const char *, int));
-extern int get_job_spec PARAMS((WORD_LIST *));
-#endif
-extern int display_signal_list PARAMS((WORD_LIST *, int));
-
-/* It's OK to declare a function as returning a Function * without
-   providing a definition of what a `Function' is. */
-extern struct builtin *builtin_address_internal PARAMS((char *, int));
-extern sh_builtin_func_t *find_shell_builtin PARAMS((char *));
-extern sh_builtin_func_t *builtin_address PARAMS((char *));
-extern sh_builtin_func_t *find_special_builtin PARAMS((char *));
-extern void initialize_shell_builtins PARAMS((void));
-
-#if defined (ARRAY_VARS)
-extern int set_expand_once PARAMS((int, int));
-#endif
-
-/* Functions from exit.def */
-extern void bash_logout PARAMS((void));
-
-/* Functions from getopts.def */
-extern void getopts_reset PARAMS((int));
-
-/* Functions from help.def */
-extern void builtin_help PARAMS((void));
-
-/* Functions from read.def */
-extern void read_tty_cleanup PARAMS((void));
-extern int read_tty_modified PARAMS((void));
-
-extern int read_builtin_timeout PARAMS((int));
-extern void check_read_timeout PARAMS((void));
-
-/* Functions from set.def */
-extern int minus_o_option_value PARAMS((char *));
-extern void list_minus_o_opts PARAMS((int, int));
-extern char **get_minus_o_opts PARAMS((void));
-extern int set_minus_o_option PARAMS((int, char *));
-
-extern void set_shellopts PARAMS((void));
-extern void parse_shellopts PARAMS((char *));
-extern void initialize_shell_options PARAMS((int));
-
-extern void reset_shell_options PARAMS((void));
-
-extern char *get_current_options PARAMS((void));
-extern void set_current_options PARAMS((const char *));
-
-/* Functions from shopt.def */
-extern void reset_shopt_options PARAMS((void));
-extern char **get_shopt_options PARAMS((void));
-
-extern int shopt_setopt PARAMS((char *, int));
-extern int shopt_listopt PARAMS((char *, int));
-
-extern int set_login_shell PARAMS((char *, int));
-
-extern void set_bashopts PARAMS((void));
-extern void parse_bashopts PARAMS((char *));
-extern void initialize_bashopts PARAMS((int));
-
-extern void set_compatibility_opts PARAMS((void));
-
-/* Functions from type.def */
-extern int describe_command PARAMS((char *, int));
-
-/* Functions from setattr.def */
-extern int set_or_show_attributes PARAMS((WORD_LIST *, int, int));
-extern int show_all_var_attributes PARAMS((int, int));
-extern int show_local_var_attributes PARAMS((int, int));
-extern int show_var_attributes PARAMS((SHELL_VAR *, int, int));
-extern int show_name_attributes PARAMS((char *, int));
-extern int show_localname_attributes PARAMS((char *, int));
-extern int show_func_attributes PARAMS((char *, int));
-extern void set_var_attribute PARAMS((char *, int, int));
-extern int var_attribute_string PARAMS((SHELL_VAR *, int, char *));
-
-/* Functions from pushd.def */
-extern char *get_dirstack_from_string PARAMS((char *));
-extern char *get_dirstack_element PARAMS((intmax_t, int));
-extern void set_dirstack_element PARAMS((intmax_t, int, char *));
-extern WORD_LIST *get_directory_stack PARAMS((int));
-
-/* Functions from evalstring.c */
-extern int parse_and_execute PARAMS((char *, const char *, int));
-extern int evalstring PARAMS((char *, const char *, int));
-extern void parse_and_execute_cleanup PARAMS((int));
-extern int parse_string PARAMS((char *, const char *, int, COMMAND **, char **));
-extern int should_suppress_fork PARAMS((COMMAND *));
-extern int can_optimize_connection PARAMS((COMMAND *));
-extern int can_optimize_cat_file PARAMS((COMMAND *));
-extern void optimize_connection_fork PARAMS((COMMAND *));
-extern void optimize_subshell_command PARAMS((COMMAND *));
-extern void optimize_shell_function PARAMS((COMMAND *));
-
-/* Functions from evalfile.c */
-extern int maybe_execute_file PARAMS((const char *, int));
-extern int force_execute_file PARAMS((const char *, int));
-extern int source_file PARAMS((const char *, int));
-extern int fc_execute_file PARAMS((const char *));
-
-/* variables from common.c */
-extern sh_builtin_func_t *this_shell_builtin;
-extern sh_builtin_func_t *last_shell_builtin;
-
-extern SHELL_VAR *builtin_bind_variable PARAMS((char *, char *, int));
-extern SHELL_VAR *builtin_bind_var_to_int PARAMS((char *, intmax_t, int));
-extern int builtin_unbind_variable PARAMS((const char *));
-
-extern SHELL_VAR *builtin_find_indexed_array PARAMS((char *, int));
-extern int builtin_arrayref_flags PARAMS((WORD_DESC *, int));
-
-/* variables from evalfile.c */
-extern int sourcelevel;
-
-/* variables from evalstring.c */
-extern int parse_and_execute_level;
-
-/* variables from break.def/continue.def */
-extern int breaking;
-extern int continuing;
-extern int loop_level;
-
-/* variables from shift.def */
-extern int print_shift_error;
-
-/* variables from shopt.def */
-#if defined (ARRAY_VARS)
-extern int expand_once_flag;
-#endif
-
-/* variables from source.def */
-extern int source_searches_cwd;
-extern int source_uses_path;
-
-/* variables from wait.def */
-extern int wait_intr_flag;
-
-/* common code to set flags for valid_array_reference and builtin_bind_variable */
-#if defined (ARRAY_VARS)
-#define SET_VFLAGS(wordflags, vflags, bindflags) \
-  do { \
-    vflags = assoc_expand_once ?  VA_NOEXPAND : 0; \
-    bindflags = assoc_expand_once ? ASS_NOEXPAND : 0; \
-    if (assoc_expand_once && (wordflags & W_ARRAYREF)) \
-      vflags |= VA_ONEWORD|VA_NOEXPAND; \
-    if (vflags & VA_NOEXPAND) \
-      bindflags |= ASS_NOEXPAND; \
-    if (vflags & VA_ONEWORD) \
-      bindflags |= ASS_ONEWORD; \
-  } while (0)
-#endif
-
-#endif /* !__COMMON_H */
diff --git a/third_party/bash/config-bot.h b/third_party/bash/config-bot.h
deleted file mode 100644
index a687e4029..000000000
--- a/third_party/bash/config-bot.h
+++ /dev/null
@@ -1,207 +0,0 @@
-/* config-bot.h */
-/* modify settings or make new ones based on what autoconf tells us. */
-
-/* Copyright (C) 1989-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/*********************************************************/
-/* Modify or set defines based on the configure results. */
-/*********************************************************/
-
-#if !defined (HAVE_VPRINTF) && defined (HAVE_DOPRNT)
-#  define USE_VFPRINTF_EMULATION
-#  define HAVE_VPRINTF
-#endif
-
-#if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_GETRLIMIT)
-#  define HAVE_RESOURCE
-#endif
-
-#if !defined (GETPGRP_VOID)
-#  define HAVE_BSD_PGRP
-#endif
-
-/* Try this without testing __STDC__ for the time being. */
-#if defined (HAVE_STDARG_H)
-#  define PREFER_STDARG
-#  define USE_VARARGS
-#else
-#  if defined (HAVE_VARARGS_H)
-#    define PREFER_VARARGS
-#    define USE_VARARGS
-#  endif
-#endif
-
-#if defined (HAVE_SYS_SOCKET_H) && defined (HAVE_GETPEERNAME) && defined (HAVE_NETINET_IN_H)
-#  define HAVE_NETWORK
-#endif
-
-#if defined (HAVE_REGEX_H) && defined (HAVE_REGCOMP) && defined (HAVE_REGEXEC)
-#  define HAVE_POSIX_REGEXP
-#endif
-
-/* backwards compatibility between different autoconf versions */
-#if HAVE_DECL_SYS_SIGLIST && !defined (SYS_SIGLIST_DECLARED)
-#  define SYS_SIGLIST_DECLARED
-#endif
-
-/***********************************************************************/
-/* Unset defines based on what configure reports as missing or broken. */
-/***********************************************************************/
-
-/* Ultrix botches type-ahead when switching from canonical to
-   non-canonical mode, at least through version 4.3 */
-#if !defined (HAVE_TERMIOS_H) || !defined (HAVE_TCGETATTR) || defined (ultrix)
-#  define TERMIOS_MISSING
-#endif
-
-/* If we have a getcwd(3), but one that does not dynamically allocate memory,
-   #undef HAVE_GETCWD so the replacement in getcwd.c will be built.  We do
-   not do this on Solaris, because their implementation of loopback mounts
-   breaks the traditional file system assumptions that getcwd uses. */
-#if defined (HAVE_GETCWD) && defined (GETCWD_BROKEN) && !defined (SOLARIS)
-#  undef HAVE_GETCWD
-#endif
-
-#if !defined (HAVE_DEV_FD) && defined (NAMED_PIPES_MISSING)
-#  undef PROCESS_SUBSTITUTION
-#endif
-
-#if defined (JOB_CONTROL_MISSING)
-#  undef JOB_CONTROL
-#endif
-
-#if defined (STRCOLL_BROKEN)
-#  undef HAVE_STRCOLL
-#endif
-
-#if !defined (HAVE_POSIX_REGEXP)
-#  undef COND_REGEXP
-#endif
-
-#if !HAVE_MKSTEMP
-#  undef USE_MKSTEMP
-#endif
-
-#if !HAVE_MKDTEMP
-#  undef USE_MKDTEMP
-#endif
-
-/* If the shell is called by this name, it will become restricted. */
-#if defined (RESTRICTED_SHELL)
-#  define RESTRICTED_SHELL_NAME "rbash"
-#endif
-
-/***********************************************************/
-/* Make sure feature defines have necessary prerequisites. */
-/***********************************************************/
-
-/* BANG_HISTORY requires HISTORY. */
-#if defined (BANG_HISTORY) && !defined (HISTORY)
-#  define HISTORY
-#endif /* BANG_HISTORY && !HISTORY */
-
-#if defined (READLINE) && !defined (HISTORY)
-#  define HISTORY
-#endif
-
-#if defined (PROGRAMMABLE_COMPLETION) && !defined (READLINE)
-#  undef PROGRAMMABLE_COMPLETION
-#endif
-
-#if !defined (V9_ECHO)
-#  undef DEFAULT_ECHO_TO_XPG
-#endif
-
-#if !defined (PROMPT_STRING_DECODE)
-#  undef PPROMPT
-#  define PPROMPT "$ "
-#endif
-
-#if !defined (HAVE_SYSLOG) || !defined (HAVE_SYSLOG_H)
-#  undef SYSLOG_HISTORY
-#endif
-
-/************************************************/
-/* check multibyte capability for I18N code	*/
-/************************************************/
-
-/* For platforms which support the ISO C amendment 1 functionality we
-   support user defined character classes.  */
-/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>.  */
-#if defined (HAVE_WCTYPE_H) && defined (HAVE_WCHAR_H) && defined (HAVE_LOCALE_H)
-#  include <wchar.h>
-#  include <wctype.h>
-#  if defined (HAVE_ISWCTYPE) && \
-      defined (HAVE_ISWLOWER) && \
-      defined (HAVE_ISWUPPER) && \
-      defined (HAVE_MBSRTOWCS) && \
-      defined (HAVE_MBRTOWC) && \
-      defined (HAVE_MBRLEN) && \
-      defined (HAVE_TOWLOWER) && \
-      defined (HAVE_TOWUPPER) && \
-      defined (HAVE_WCHAR_T) && \
-      defined (HAVE_WCTYPE_T) && \
-      defined (HAVE_WINT_T) && \
-      defined (HAVE_WCWIDTH) && \
-      defined (HAVE_WCTYPE)
-     /* system is supposed to support XPG5 */
-#    define HANDLE_MULTIBYTE      1
-#  endif
-#endif
-
-/* If we don't want multibyte chars even on a system that supports them, let
-   the configuring user turn multibyte support off. */
-#if defined (NO_MULTIBYTE_SUPPORT)
-#  undef HANDLE_MULTIBYTE
-#endif
-
-/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t.  */
-#if HANDLE_MULTIBYTE && !defined (HAVE_MBSTATE_T)
-#  define wcsrtombs(dest, src, len, ps) (wcsrtombs) (dest, src, len, 0)
-#  define mbsrtowcs(dest, src, len, ps) (mbsrtowcs) (dest, src, len, 0)
-#  define wcrtomb(s, wc, ps) (wcrtomb) (s, wc, 0)
-#  define mbrtowc(pwc, s, n, ps) (mbrtowc) (pwc, s, n, 0)
-#  define mbrlen(s, n, ps) (mbrlen) (s, n, 0)
-#  define mbstate_t int
-#endif
-
-/* Make sure MB_LEN_MAX is at least 16 (some systems define
-   MB_LEN_MAX as 1) */
-#ifdef HANDLE_MULTIBYTE
-#  include <limits.h>
-#  if defined(MB_LEN_MAX) && (MB_LEN_MAX < 16)
-#    undef MB_LEN_MAX
-#  endif
-#  if !defined (MB_LEN_MAX)
-#    define MB_LEN_MAX 16
-#  endif
-#endif
-
-/************************************************/
-/* end of multibyte capability checks for I18N	*/
-/************************************************/
-
-/******************************************************************/
-/* Placeholder for builders to #undef any unwanted features from  */
-/* config-top.h or created by configure (such as the default mail */
-/* file for mail checking).					  */
-/******************************************************************/
-
-/* If you don't want bash to provide a default mail file to check. */
-/* #undef DEFAULT_MAIL_DIRECTORY */
diff --git a/third_party/bash/config-top.h b/third_party/bash/config-top.h
deleted file mode 100644
index db4ab6ee3..000000000
--- a/third_party/bash/config-top.h
+++ /dev/null
@@ -1,201 +0,0 @@
-/* config-top.h - various user-settable options not under the control of autoconf. */
-
-/* Copyright (C) 2002-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* Define CONTINUE_AFTER_KILL_ERROR if you want the kill command to
-   continue processing arguments after one of them fails.  This is
-   what POSIX.2 specifies. */
-#define CONTINUE_AFTER_KILL_ERROR
-
-/* Define BREAK_COMPLAINS if you want the non-standard, but useful
-   error messages about `break' and `continue' out of context. */
-#define BREAK_COMPLAINS
-
-/* Define CD_COMPLAINS if you want the non-standard, but sometimes-desired
-   error messages about multiple directory arguments to `cd'. */
-#define CD_COMPLAINS
-
-/* Define BUFFERED_INPUT if you want the shell to do its own input
-   buffering, rather than using stdio.  Do not undefine this; it's
-   required to preserve semantics required by POSIX. */
-#define BUFFERED_INPUT
-
-/* Define ONESHOT if you want sh -c 'command' to avoid forking to execute
-   `command' whenever possible.  This is a big efficiency improvement. */
-#define ONESHOT
-
-/* Define V9_ECHO if you want to give the echo builtin backslash-escape
-   interpretation using the -e option, in the style of the Bell Labs 9th
-   Edition version of echo.  You cannot emulate the System V echo behavior
-   without this option. */
-#define V9_ECHO
-
-/* Define DONT_REPORT_SIGPIPE if you don't want to see `Broken pipe' messages
-   when a job like `cat jobs.c | exit 1' terminates due to a SIGPIPE. */
-#define DONT_REPORT_SIGPIPE
-
-/* Define DONT_REPORT_SIGTERM if you don't want to see `Terminates' message
-   when a job exits due to SIGTERM, since that's the default signal sent
-   by the kill builtin. */
-#define DONT_REPORT_SIGTERM
-
-/* Define DONT_REPORT_BROKEN_PIPE_WRITE_ERRORS if you don't want builtins
-   like `echo' and `printf' to report errors when output does not succeed
-   due to EPIPE. */
-/* #define DONT_REPORT_BROKEN_PIPE_WRITE_ERRORS */
-
-/* The default value of the PATH variable. */
-#ifndef DEFAULT_PATH_VALUE
-#define DEFAULT_PATH_VALUE \
-  "/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin:/bin:/sbin:."
-#endif
-
-/* If you want to unconditionally set a value for PATH in every restricted
-   shell, set this. */
-/* #define RBASH_STATIC_PATH_VALUE "/rbin:/usr/rbin" */
-
-/* The value for PATH when invoking `command -p'.  This is only used when
-   the Posix.2 confstr () function, or CS_PATH define are not present. */
-#ifndef STANDARD_UTILS_PATH
-#define STANDARD_UTILS_PATH \
-  "/bin:/usr/bin:/sbin:/usr/sbin:/etc:/usr/etc"
-#endif
-
-/* The default path for enable -f */
-#ifndef DEFAULT_LOADABLE_BUILTINS_PATH
-#define DEFAULT_LOADABLE_BUILTINS_PATH \
-  "/usr/local/lib/bash:/usr/lib/bash:/opt/local/lib/bash:/usr/pkg/lib/bash:/opt/pkg/lib/bash:."
-#endif
-
-/* Default primary and secondary prompt strings. */
-#define PPROMPT "\\s-\\v\\$ "
-#define SPROMPT "> "
-
-/* Undefine this if you don't want the ksh-compatible behavior of reprinting
-   the select menu after a valid choice is made only if REPLY is set to NULL
-   in the body of the select command.  The menu is always reprinted if the
-   reply to the select query is an empty line. */
-#define KSH_COMPATIBLE_SELECT
-
-/* Default interactive shell startup file. */
-#define DEFAULT_BASHRC "~/.bashrc"
-
-/* System-wide .bashrc file for interactive shells. */
-/* #define SYS_BASHRC "/etc/bash.bashrc" */
-
-/* System-wide .bash_logout for login shells. */
-/* #define SYS_BASH_LOGOUT "/etc/bash.bash_logout" */
-
-/* Define this to make non-interactive shells begun with argv[0][0] == '-'
-   run the startup files when not in posix mode. */
-/* #define NON_INTERACTIVE_LOGIN_SHELLS */
-
-/* Define this if you want bash to try to check whether it's being run by
-   sshd and source the .bashrc if so (like the rshd behavior).  This checks
-   for the presence of SSH_CLIENT or SSH2_CLIENT in the initial environment,
-   which can be fooled under certain not-uncommon circumstances. */
-/* #define SSH_SOURCE_BASHRC */
-
-/* Define if you want the case-toggling operators (~[~]) and the
-   `capcase' variable attribute (declare -c). */
-/* TAG: bash-5.2 disable? */
-#define CASEMOD_TOGGLECASE
-#define CASEMOD_CAPCASE
-
-/* This is used as the name of a shell function to call when a command
-   name is not found.  If you want to name it something other than the
-   default ("command_not_found_handle"), change it here. */
-/* #define NOTFOUND_HOOK "command_not_found_handle" */
-
-/* Define if you want each line saved to the history list in bashhist.c:
-   bash_add_history() to be sent to syslog(). */
-/* #define SYSLOG_HISTORY */
-#if defined (SYSLOG_HISTORY)
-#  define SYSLOG_FACILITY LOG_USER
-#  define SYSLOG_LEVEL LOG_INFO
-#  define OPENLOG_OPTS LOG_PID
-#endif
-
-/* Define if you want syslogging history to be controllable at runtime via a
-   shell option; if defined, the value is the default for the syslog_history
-   shopt option */
-#if defined (SYSLOG_HISTORY)
-/* #define SYSLOG_SHOPT 1 */
-#endif
-
-/* Define if you want to include code in shell.c to support wordexp(3) */
-/* #define WORDEXP_OPTION */
-
-/* Define as 1 if you want to enable code that implements multiple coprocs
-   executing simultaneously */
-#ifndef MULTIPLE_COPROCS
-#  define MULTIPLE_COPROCS 0
-#endif
-
-/* Define to 0 if you want the checkwinsize option off by default, 1 if you
-   want it on. */
-#define CHECKWINSIZE_DEFAULT	1
-
-/* Define to 1 if you want to optimize for sequential array assignment when
-   using indexed arrays, 0 if you want bash-4.2 behavior, which favors
-   random access but is O(N) for each array assignment. */
-#define OPTIMIZE_SEQUENTIAL_ARRAY_ASSIGNMENT	1
-
-/* Define to 1 if you want to be able to export indexed arrays to processes
-   using the foo=([0]=one [1]=two) and so on */
-/* #define ARRAY_EXPORT 1 */
-
-/* Define to 1 if you want the shell to exit if it is running setuid and its
-   attempt to drop privilege using setuid(getuid()) fails with errno == EAGAIN */
-/* #define EXIT_ON_SETUID_FAILURE 1 */
-
-/* Define to 1 if you want the shell to re-check $PATH if a hashed filename
-   no longer exists.  This behavior is the default in Posix mode. */
-#define CHECKHASH_DEFAULT 0
-
-/* Define to the maximum level of recursion you want for the eval builtin
-   and trap handlers (since traps are run as if run by eval).
-   0 means the limit is not active. */
-#define EVALNEST_MAX 0
-
-/* Define to the maximum level of recursion you want for the source/. builtin.
-   0 means the limit is not active. */
-#define SOURCENEST_MAX 0
-
-/* Define to use libc mktemp/mkstemp instead of replacements in lib/sh/tmpfile.c */
-#define USE_MKTEMP
-#define USE_MKSTEMP
-#define USE_MKDTEMP
-
-/* Define to force the value of OLDPWD inherited from the environment to be a
-   directory */
-#define OLDPWD_CHECK_DIRECTORY 1
-
-/* Define to set the initial size of the history list ($HISTSIZE). This must
-   be a string. */
-/*#define HISTSIZE_DEFAULT "500"*/
-
-/* Define to 0 if you want history expansion to be disabled by default in
-   interactive shells; define to 1 for the historical behavior of enabling
-   when the shell is interactive. */
-#define HISTEXPAND_DEFAULT	1
-
-/* Undefine or define to 0 if you don't want to allow associative array
-   assignment using a compound list of key-value pairs. */
-#define ASSOC_KVPAIR_ASSIGNMENT 1
diff --git a/third_party/bash/config.h b/third_party/bash/config.h
deleted file mode 100644
index caeab0fa6..000000000
--- a/third_party/bash/config.h
+++ /dev/null
@@ -1,1235 +0,0 @@
-/* config.h.  Generated from config.h.in by configure.  */
-/* config.h -- Configuration file for bash. */
-
-/* Copyright (C) 1987-2009,2011-2012,2013-2019 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _CONFIG_H_
-#define _CONFIG_H_
-
-#ifdef _COSMO_SOURCE
-#undef _COSMO_SOURCE
-#endif
-
-/* Template settings for autoconf */
-
-/* Configuration feature settings controllable by autoconf. */
-
-/* Define JOB_CONTROL if your operating system supports
-   BSD-like job control. */
-#define JOB_CONTROL 1
-
-/* Define ALIAS if you want the alias features. */
-#define ALIAS 1
-
-/* Define PUSHD_AND_POPD if you want those commands to be compiled in.
-   (Also the `dirs' commands.) */
-#define PUSHD_AND_POPD 1
-
-/* Define BRACE_EXPANSION if you want curly brace expansion a la Csh:
-   foo{a,b} -> fooa foob.  Even if this is compiled in (the default) you
-   can turn it off at shell startup with `-nobraceexpansion', or during
-   shell execution with `set +o braceexpand'. */
-#define BRACE_EXPANSION 1
-
-/* Define READLINE to get the nifty/glitzy editing features.
-   This is on by default.  You can turn it off interactively
-   with the -nolineediting flag. */
-#define READLINE 1
-
-/* Define BANG_HISTORY if you want to have Csh style "!" history expansion.
-   This is unrelated to READLINE. */
-#define BANG_HISTORY 1
-
-/* Define HISTORY if you want to have access to previously typed commands.
-
-   If both HISTORY and READLINE are defined, you can get at the commands
-   with line editing commands, and you can directly manipulate the history
-   from the command line.
-
-   If only HISTORY is defined, the `fc' and `history' builtins are
-   available. */
-#define HISTORY 1
-
-/* Define this if you want completion that puts all alternatives into
-   a brace expansion shell expression. */
-#if defined (BRACE_EXPANSION) && defined (READLINE)
-#  define BRACE_COMPLETION
-#endif /* BRACE_EXPANSION */
-
-/* Define DEFAULT_ECHO_TO_XPG if you want the echo builtin to interpret
-   the backslash-escape characters by default, like the XPG Single Unix
-   Specification V2 for echo.
-   This requires that V9_ECHO be defined. */
-/* #undef DEFAULT_ECHO_TO_XPG */
-
-/* Define HELP_BUILTIN if you want the `help' shell builtin and the long
-   documentation strings compiled into the shell. */
-#define HELP_BUILTIN 1
-
-/* Define RESTRICTED_SHELL if you want the generated shell to have the
-   ability to be a restricted one.  The shell thus generated can become
-   restricted by being run with the name "rbash", or by setting the -r
-   flag. */
-#define RESTRICTED_SHELL 1
-
-/* Define DISABLED_BUILTINS if you want "builtin foo" to always run the
-   shell builtin "foo", even if it has been disabled with "enable -n foo". */
-/* #undef DISABLED_BUILTINS */
-
-/* Define PROCESS_SUBSTITUTION if you want the K*rn shell-like process
-   substitution features "<(file)". */
-/* Right now, you cannot do this on machines without fully operational
-   FIFO support.  This currently include NeXT and Alliant. */
-#define PROCESS_SUBSTITUTION 1
-
-/* Define PROMPT_STRING_DECODE if you want the backslash-escaped special
-   characters in PS1 and PS2 expanded.  Variable expansion will still be
-   performed. */
-#define PROMPT_STRING_DECODE 1
-
-/* Define SELECT_COMMAND if you want the Korn-shell style `select' command:
-	select word in word_list; do command_list; done */
-#define SELECT_COMMAND 1
-
-/* Define COMMAND_TIMING of you want the ksh-style `time' reserved word and
-   the ability to time pipelines, functions, and builtins. */
-#define COMMAND_TIMING 1
-
-/* Define ARRAY_VARS if you want ksh-style one-dimensional array variables. */
-#define ARRAY_VARS 1
-
-/* Define DPAREN_ARITHMETIC if you want the ksh-style ((...)) arithmetic
-   evaluation command. */
-#define DPAREN_ARITHMETIC 1
-
-/* Define EXTENDED_GLOB if you want the ksh-style [*+@?!](patlist) extended
-   pattern matching. */
-#define EXTENDED_GLOB 1
-
-/* Define EXTGLOB_DEFAULT to the value you'd like the extglob shell option
-   to have by default */
-#define EXTGLOB_DEFAULT 0
-
-/* Define COND_COMMAND if you want the ksh-style [[...]] conditional
-   command. */
-#define COND_COMMAND 1
-
-/* Define COND_REGEXP if you want extended regular expression matching and the
-   =~ binary operator in the [[...]] conditional command. */
-#define COND_REGEXP 1
-
-/* Define COPROCESS_SUPPORT if you want support for ksh-like coprocesses and
-   the `coproc' reserved word */
-#define COPROCESS_SUPPORT 1
-
-/* Define ARITH_FOR_COMMAND if you want the ksh93-style
-	for (( init; test; step )) do list; done
-   arithmetic for command. */
-#define ARITH_FOR_COMMAND 1
-
-/* Define NETWORK_REDIRECTIONS if you want /dev/(tcp|udp)/host/port to open
-   socket connections when used in redirections */
-#define NETWORK_REDIRECTIONS 1
-
-/* Define PROGRAMMABLE_COMPLETION for the programmable completion features
-   and the complete builtin. */
-#define PROGRAMMABLE_COMPLETION 1
-
-/* Define NO_MULTIBYTE_SUPPORT to not compile in support for multibyte
-   characters, even if the OS supports them. */
-/* #undef NO_MULTIBYTE_SUPPORT */
-
-/* Define DEBUGGER if you want to compile in some features used only by the 
-   bash debugger. */
-#define DEBUGGER 1
-
-/* Define STRICT_POSIX if you want bash to be strictly posix.2 conformant by
-   default (except for echo; that is controlled separately). */
-/* #undef STRICT_POSIX */
-
-/* Define MEMSCRAMBLE if you want the bash malloc and free to scramble
-   memory contents on malloc() and free(). */
-#define MEMSCRAMBLE 1
-
-/* Define for case-modifying variable attributes; variables modified on
-   assignment */
-#define CASEMOD_ATTRS 1
-
-/* Define for case-modifying word expansions */
-#define CASEMOD_EXPANSIONS 1
-
-/* Define to make the `direxpand' shopt option enabled by default. */
-/* #undef DIRCOMPLETE_EXPAND_DEFAULT */
-
-/* Define to make the `globasciiranges' shopt option enabled by default. */
-#define GLOBASCII_DEFAULT 1
-
-/* Define to allow functions to be imported from the environment. */
-#define FUNCTION_IMPORT 1
-
-/* Define AFS if you are using Transarc's AFS. */
-/* #undef AFS */
-
-/* #undef ENABLE_NLS */
-
-/* End of configuration settings controllable by autoconf. */
-/* Other settable options appear in config-top.h. */
-
-#include "config-top.h"
-
-/* Beginning of autoconf additions. */
-
-/* Characteristics of the C compiler */
-/* #undef const */
-
-/* #undef inline */
-
-#define restrict __restrict__
-
-/* #undef volatile */
-
-/* Define if cpp supports the ANSI-C stringizing `#' operator */
-#define HAVE_STRINGIZE 1
-
-/* Define if the compiler supports `long double' variables. */
-#define HAVE_LONG_DOUBLE 1
-
-#define PROTOTYPES 1
-#define __PROTOTYPES 1
-
-/* #undef __CHAR_UNSIGNED__ */
-
-/* Define if the compiler supports `long long int' variables. */
-#define HAVE_LONG_LONG_INT 1
-
-#define HAVE_UNSIGNED_LONG_LONG_INT 1
-
-/* The number of bytes in a int.  */
-#define SIZEOF_INT 4
-
-/* The number of bytes in a long.  */
-#define SIZEOF_LONG 8
-
-/* The number of bytes in a pointer to char.  */
-#define SIZEOF_CHAR_P 8
-
-/* The number of bytes in a size_t.  */
-#define SIZEOF_SIZE_T 8
-
-/* The number of bytes in a double (hopefully 8). */
-#define SIZEOF_DOUBLE 8
-
-/* The number of bytes in an `intmax_t'. */
-#define SIZEOF_INTMAX_T 8
-
-/* The number of bytes in a `long long', if we have one. */
-#define SIZEOF_LONG_LONG 8
-
-/* The number of bytes in a `wchar_t', if supported */
-#define SIZEOF_WCHAR_T 4
-
-/* System paths */
-
-#define DEFAULT_MAIL_DIRECTORY "/var/mail"
-
-/* Characteristics of the system's header files and libraries that affect
-   the compilation environment. */
-
-/* These are set by AC_USE_SYSTEM_EXTENSIONS */
-
-/* Define if the system does not provide POSIX.1 features except
-   with this defined.  */
-/* #undef _POSIX_1_SOURCE */
-
-/* Define if you need to in order for stat and other things to work.  */
-/* #undef _POSIX_SOURCE */
-
-/* Define to use GNU libc extensions. */
-#define _GNU_SOURCE 1
-
-/* Define to enable general system extensions on Solaris. */
-#define __EXTENSIONS__ 1
-
-/* General system extensions on AIX */
-#define _ALL_SOURCE 1
-
-#define _POSIX_PTHREAD_SEMANTICS 1
-#define _TANDEM_SOURCE 1
-/* #undef _MINIX */
-
-/* Memory management functions. */
-
-/* Define if using the bash version of malloc in lib/malloc/malloc.c */
-/* #undef USING_BASH_MALLOC */
-
-/* #undef DISABLE_MALLOC_WRAPPERS */
-
-/* Define if using alloca.c.  */
-/* #undef C_ALLOCA */
-
-/* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems.
-   This function is required for alloca.c support on those systems.  */
-/* #undef CRAY_STACKSEG_END */
-
-/* Define if you have alloca, as a function or macro.  */
-#define HAVE_ALLOCA 1
-
-/* Define if you have <alloca.h> and it should be used (not on Ultrix).  */
-#define HAVE_ALLOCA_H 1
-
-/* Define if major/minor/makedev is defined in <sys/mkdev.h> */
-/* #undef MAJOR_IN_MAKEDEV */
-
-/* Define if major/minor/makedev is defined in <sys/sysmacros.h> */
-#define MAJOR_IN_SYSMACROS 1
-
-/* SYSTEM TYPES */
-
-/* Define to `long' if <sys/types.h> doesn't define.  */
-/* #undef off_t */
-
-/* Define to `int' if <sys/types.h> doesn't define. */
-/* #undef mode_t */
-
-/* Define to `int' if <signal.h> doesn't define. */
-/* #undef sigset_t */
-
-/* Define to `int' if <sys/types.h> doesn't define.  */
-/* #undef pid_t */
-
-/* Define to `short' if <sys/types.h> doesn't define.  */
-#define bits16_t short
-
-/* Define to `unsigned short' if <sys/types.h> doesn't define.  */
-#define u_bits16_t unsigned short
-
-/* Define to `int' if <sys/types.h> doesn't define.  */
-#define bits32_t int
-
-/* Define to `unsigned int' if <sys/types.h> doesn't define.  */
-#define u_bits32_t unsigned int
-
-/* Define to `double' if <sys/types.h> doesn't define. */
-#define bits64_t char *
-
-/* Define to `unsigned int' if <sys/types.h> doesn't define. */
-/* #undef u_int */
-
-/* Define to `unsigned long' if <sys/types.h> doesn't define.  */
-/* #undef u_long */
-
-/* Define to `int' if <sys/types.h> doesn't define. */
-/* #undef ptrdiff_t */
-
-/* Define to `unsigned' if <sys/types.h> doesn't define.  */
-/* #undef size_t */
-
-/* Define to `int' if <sys/types.h> doesn't define. */
-/* #undef ssize_t */
-
-/* Define to `long' if <stdint.h> doesn't define. */
-/* #undef intmax_t */
-
-/* Define to `unsigned long' if <stdint.h> doesn't define. */
-/* #undef uintmax_t */
-
-/* Define to integer type wide enough to hold a pointer if <stdint.h> doesn't define. */
-/* #undef uintptr_t */
- 
-/* Define to `int' if <sys/types.h> doesn't define.  */
-/* #undef uid_t */
-
-/* Define to `long' if <sys/types.h> doesn't define.  */
-/* #undef clock_t */
-
-/* Define to `long' if <sys/types.h> doesn't define.  */
-/* #undef time_t */
-
-/* Define to `int' if <sys/types.h> doesn't define.  */
-/* #undef gid_t */
-
-/* Define to `unsigned int' if <sys/socket.h> doesn't define. */
-/* #undef socklen_t */
-
-/* Define to `int' if <signal.h> doesn't define. */
-/* #undef sig_atomic_t */
-
-#define HAVE_MBSTATE_T 1
-
-/* Define if you have quad_t in <sys/types.h>. */
-#define HAVE_QUAD_T 1
-
-/* Define if you have wchar_t in <wctype.h>. */
-#define HAVE_WCHAR_T 1
-
-/* Define if you have wctype_t in <wctype.h>. */
-#define HAVE_WCTYPE_T 1
-
-/* Define if you have wint_t in <wctype.h>. */
-#define HAVE_WINT_T 1
-
-#define RLIMTYPE rlim_t
-
-/* Define to the type of elements in the array set by `getgroups'.
-   Usually this is either `int' or `gid_t'.  */
-#define GETGROUPS_T gid_t
-
-/* Characteristics of the machine archictecture. */
-
-/* If using the C implementation of alloca, define if you know the
-   direction of stack growth for your system; otherwise it will be
-   automatically deduced at run-time.
-	STACK_DIRECTION > 0 => grows toward higher addresses
-	STACK_DIRECTION < 0 => grows toward lower addresses
-	STACK_DIRECTION = 0 => direction of growth unknown
- */
-/* #undef STACK_DIRECTION */
-
-/* Define if the machine architecture is big-endian. */
-/* #undef WORDS_BIGENDIAN */
-
-/* Check for the presence of certain non-function symbols in the system
-   libraries. */
-
-/* Define if `sys_siglist' is declared by <signal.h> or <unistd.h>.  */
-#define HAVE_DECL_SYS_SIGLIST 0
-/* #undef SYS_SIGLIST_DECLARED */
-
-/* Define if `_sys_siglist' is declared by <signal.h> or <unistd.h>.  */
-/* #undef UNDER_SYS_SIGLIST_DECLARED */
-
-/* #undef HAVE_SYS_SIGLIST */
-
-/* #undef HAVE_UNDER_SYS_SIGLIST */
-
-#define HAVE_SYS_ERRLIST 1
-
-/* #undef HAVE_TZNAME */
-/* #undef HAVE_DECL_TZNAME */
-
-/* Characteristics of some of the system structures. */
-
-#define HAVE_STRUCT_DIRENT_D_INO 1
-
-/* #undef HAVE_STRUCT_DIRENT_D_FILENO */
-
-/* #undef HAVE_STRUCT_DIRENT_D_NAMLEN */
-
-/* #undef TIOCSTAT_IN_SYS_IOCTL */
-
-#define FIONREAD_IN_SYS_IOCTL 1
-
-/* #undef GWINSZ_IN_SYS_IOCTL */
-
-#define STRUCT_WINSIZE_IN_SYS_IOCTL 1
-
-/* #undef TM_IN_SYS_TIME */
-
-/* #undef STRUCT_WINSIZE_IN_TERMIOS */
-
-#define SPEED_T_IN_SYS_TYPES 1
-
-/* #undef TERMIOS_LDISC */
-
-/* #undef TERMIO_LDISC */
-
-#define HAVE_STRUCT_STAT_ST_BLOCKS 1
-
-#define HAVE_STRUCT_TM_TM_ZONE 1
-#define HAVE_TM_ZONE 1
-
-#define HAVE_TIMEVAL 1
-
-#define HAVE_STRUCT_TIMEZONE 1
-
-#define WEXITSTATUS_OFFSET 8
-
-#define HAVE_STRUCT_TIMESPEC 1
-#define TIME_H_DEFINES_STRUCT_TIMESPEC 1
-/* #undef SYS_TIME_H_DEFINES_STRUCT_TIMESPEC */
-/* #undef PTHREAD_H_DEFINES_STRUCT_TIMESPEC */
-
-#define HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC 1
-#define TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC 1
-/* #undef HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC */
-/* #undef HAVE_STRUCT_STAT_ST_ATIMENSEC */
-/* #undef HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC */
-
-/* Characteristics of definitions in the system header files. */
-
-#define HAVE_GETPW_DECLS 1
-
-/* #undef HAVE_RESOURCE */
-
-/* #undef HAVE_LIBC_FNM_EXTMATCH */
-
-/* Define if you have <linux/audit.h> and it defines AUDIT_USER_TTY */
-#define HAVE_DECL_AUDIT_USER_TTY 0
-
-#define HAVE_DECL_CONFSTR 1
-
-#define HAVE_DECL_PRINTF 1
-
-#define HAVE_DECL_SBRK 0
-
-#define HAVE_DECL_STRCPY 1
-
-#define HAVE_DECL_STRSIGNAL 1
-
-#define HAVE_DECL_STRTOLD 1
-
-/* #undef PRI_MACROS_BROKEN */
-
-/* #undef STRTOLD_BROKEN */
-
-/* Define if WCONTINUED is defined in system headers, but rejected by waitpid */
-/* #undef WCONTINUED_BROKEN */
-
-/* These are checked with BASH_CHECK_DECL */
-
-#define HAVE_DECL_STRTOIMAX 1
-#define HAVE_DECL_STRTOL 1
-#define HAVE_DECL_STRTOLL 1
-#define HAVE_DECL_STRTOUL 1
-#define HAVE_DECL_STRTOULL 1
-#define HAVE_DECL_STRTOUMAX 1
-
-/* Characteristics of system calls and C library functions. */
-
-/* Define if the `getpgrp' function takes no argument.  */
-#define GETPGRP_VOID 1
-
-#define NAMED_PIPES_MISSING 1
-
-/* #undef OPENDIR_NOT_ROBUST */
-
-#define PGRP_PIPE 1
-
-/* #undef STAT_MACROS_BROKEN */
-
-/* #undef ULIMIT_MAXFDS */
-
-#define CAN_REDEFINE_GETENV 1
-
-#define HAVE_STD_PUTENV 1
-
-#define HAVE_STD_UNSETENV 1
-
-#define HAVE_PRINTF_A_FORMAT 1
-
-/* Define if you have <langinfo.h> and nl_langinfo(CODESET). */
-#define HAVE_LANGINFO_CODESET 1
-
-/* Characteristics of properties exported by the kernel. */
-
-/* Define if the kernel can exec files beginning with #! */
-#define HAVE_HASH_BANG_EXEC 1
-
-/* Define if you have the /dev/fd devices to map open files into the file system. */
-#define HAVE_DEV_FD 1
-
-/* Defined to /dev/fd or /proc/self/fd (linux). */
-#define DEV_FD_PREFIX "/dev/fd/"
-
-/* Define if you have the /dev/stdin device. */
-#define HAVE_DEV_STDIN 1
-
-/* The type of iconv's `inbuf' argument */
-#define ICONV_CONST 
-
-/* Type and behavior of signal handling functions. */
-
-/* #undef MUST_REINSTALL_SIGHANDLERS */
-
-/* #undef HAVE_BSD_SIGNALS */
-
-#define HAVE_POSIX_SIGNALS 1
-
-/* #undef HAVE_USG_SIGHOLD */
-
-/* #undef UNUSABLE_RT_SIGNALS */
-
-/* Presence of system and C library functions. */
-
-/* Define if you have the arc4random function.  */
-/* #undef HAVE_ARC4RANDOM */
-
-/* Define if you have the asprintf function.  */
-#define HAVE_ASPRINTF 1
-
-/* Define if you have the bcopy function.  */
-#define HAVE_BCOPY 1
-
-/* Define if you have the bzero function.  */
-#define HAVE_BZERO 1
-
-/* Define if you have the chown function.  */
-#define HAVE_CHOWN 1
-
-/* Define if you have the confstr function.  */
-#define HAVE_CONFSTR 1
-
-/* Define if you have the dlclose function.  */
-/* #undef HAVE_DLCLOSE */
-
-/* Define if you have the dlopen function.  */
-/* #undef HAVE_DLOPEN */
-
-/* Define if you have the dlsym function.  */
-/* #undef HAVE_DLSYM */
-
-/* Define if you don't have vprintf but do have _doprnt.  */
-/* #undef HAVE_DOPRNT */
-
-/* Define if you have the dprintf function.  */
-#define HAVE_DPRINTF 1
-
-/* Define if you have the dup2 function.  */
-#define HAVE_DUP2 1
-
-/* Define if you have the eaccess function.  */
-#define HAVE_EACCESS 1
-
-/* Define if you have the faccessat function.  */
-#define HAVE_FACCESSAT 1
-
-/* Define if you have the fcntl function.  */
-#define HAVE_FCNTL 1
-
-/* Define if you have the fnmatch function.  */
-#define HAVE_FNMATCH 1
-
-/* Can fnmatch be used as a fallback to match [=equiv=] with collation weights? */
-#define FNMATCH_EQUIV_FALLBACK 0
-
-/* Define if you have the fpurge/__fpurge function.  */
-#define HAVE_FPURGE 1
-#define HAVE___FPURGE 1
-#define HAVE_DECL_FPURGE 1
-
-/* Define if you have the getaddrinfo function. */
-#define HAVE_GETADDRINFO 1
-
-/* Define if you have the getcwd function.  */
-#define HAVE_GETCWD 1
-
-/* Define if you have the getentropy function.  */
-#define HAVE_GETENTROPY 1
-
-/* Define if you have the getdtablesize function.  */
-#define HAVE_GETDTABLESIZE 1
-
-/* Define if you have the getgroups function.  */
-#define HAVE_GETGROUPS 1
-
-/* Define if you have the gethostbyname function.  */
-#define HAVE_GETHOSTBYNAME 1
-
-/* Define if you have the gethostname function.  */
-#define HAVE_GETHOSTNAME 1
-
-/* Define if you have the getpagesize function.  */
-#define HAVE_GETPAGESIZE 1
-
-/* Define if you have the getpeername function.  */
-#define HAVE_GETPEERNAME 1
-
-/* Define if you have the getpwent function. */
-#define HAVE_GETPWENT 1
-
-/* Define if you have the getpwnam function. */
-#define HAVE_GETPWNAM 1
-
-/* Define if you have the getpwuid function. */
-#define HAVE_GETPWUID 1
-
-/* Define if you have the getrandom function.  */
-#define HAVE_GETRANDOM 1
-
-/* Define if you have the getrlimit function.  */
-#define HAVE_GETRLIMIT 1
-
-/* Define if you have the getrusage function.  */
-#define HAVE_GETRUSAGE 1
-
-/* Define if you have the getservbyname function.  */
-#define HAVE_GETSERVBYNAME 1
-
-/* Define if you have the getservent function.  */
-#define HAVE_GETSERVENT 1
-
-/* Define if you have the gettimeofday function.  */
-#define HAVE_GETTIMEOFDAY 1
-
-/* Define if you have the getwd function.  */
-/* #undef HAVE_GETWD */
-
-/* Define if you have the iconv function.  */
-#define HAVE_ICONV 1
-
-/* Define if you have the imaxdiv function.  */
-#define HAVE_IMAXDIV 1
-
-/* Define if you have the inet_aton function.  */
-#define HAVE_INET_ATON 1
-
-/* Define if you have the isascii function. */
-#define HAVE_ISASCII 1
-
-/* Define if you have the isblank function.  */
-#define HAVE_ISBLANK 1
-
-/* Define if you have the isgraph function.  */
-#define HAVE_ISGRAPH 1
-
-/* Define if you have the isprint function.  */
-#define HAVE_ISPRINT 1
-
-/* Define if you have the isspace function.  */
-#define HAVE_ISSPACE 1
-
-/* Define if you have the iswctype function.  */
-#define HAVE_ISWCTYPE 1
-
-/* Define if you have the iswlower function.  */
-#define HAVE_ISWLOWER 1
-
-/* Define if you have the iswupper function.  */
-#define HAVE_ISWUPPER 1
-
-/* Define if you have the isxdigit function.  */
-#define HAVE_ISXDIGIT 1
-
-/* Define if you have the kill function.  */
-#define HAVE_KILL 1
-
-/* Define if you have the killpg function.  */
-#define HAVE_KILLPG 1
-
-/* Define if you have the lstat function. */
-#define HAVE_LSTAT 1
-
-/* Define if you have the locale_charset function. */
-/* #undef HAVE_LOCALE_CHARSET */
-
-/* Define if you have the mbrlen function. */
-#define HAVE_MBRLEN 1
-
-/* Define if you have the mbrtowc function. */
-#define HAVE_MBRTOWC 1
-
-/* Define if you have the mbscasecmp function. */
-/* #undef HAVE_MBSCASECMP */
-
-/* Define if you have the mbschr function. */
-/* #undef HAVE_MBSCHR */
-
-/* Define if you have the mbscmp function. */
-/* #undef HAVE_MBSCMP */
-
-/* Define if you have the mbsnrtowcs function. */
-#define HAVE_MBSNRTOWCS 1
-
-/* Define if you have the mbsrtowcs function. */
-#define HAVE_MBSRTOWCS 1
-
-/* Define if you have the memmove function.  */
-#define HAVE_MEMMOVE 1
-
-/* Define if you have the memset function.  */
-#define HAVE_MEMSET 1
-
-/* Define if you have the mkdtemp function.  */
-#define HAVE_MKDTEMP 1
-
-/* Define if you have the mkfifo function.  */
-/* #undef HAVE_MKFIFO */
-
-/* Define if you have the mkstemp function.  */
-#define HAVE_MKSTEMP 1
-
-/* Define if you have the pathconf function. */
-#define HAVE_PATHCONF 1
-
-/* Define if you have the pselect function.  */
-#define HAVE_PSELECT 1
-
-/* Define if you have the putenv function.  */
-#define HAVE_PUTENV 1
-
-/* Define if you have the raise function. */
-#define HAVE_RAISE 1
-
-/* Define if you have the random function. */
-#define HAVE_RANDOM 1
-
-/* Define if you have the readlink function. */
-#define HAVE_READLINK 1
-
-/* Define if you have the regcomp function. */
-#define HAVE_REGCOMP 1
-
-/* Define if you have the regexec function. */
-#define HAVE_REGEXEC 1
-
-/* Define if you have the rename function. */
-#define HAVE_RENAME 1
-
-/* Define if you have the sbrk function. */
-/* #undef HAVE_SBRK */
-
-/* Define if you have the select function.  */
-#define HAVE_SELECT 1
-
-/* Define if you have the setdtablesize function.  */
-/* #undef HAVE_SETDTABLESIZE */
-
-/* Define if you have the setenv function.  */
-#define HAVE_SETENV 1
-
-/* Define if you have the setitimer function.  */
-#define HAVE_SETITIMER 1
-
-/* Define if you have the setlinebuf function.  */
-#define HAVE_SETLINEBUF 1
-
-/* Define if you have the setlocale function.  */
-#define HAVE_SETLOCALE 1
-
-/* Define if you have the setostype function.  */
-/* #undef HAVE_SETOSTYPE */
-
-/* Define if you have the setregid function.  */
-/* #undef HAVE_SETREGID */
-#define HAVE_DECL_SETREGID 1
-
-/* Define if you have the setregid function.  */
-#define HAVE_SETRESGID 1
-/* #undef HAVE_DECL_SETRESGID */
-
-/* Define if you have the setresuid function.  */
-#define HAVE_SETRESUID 1
-/* #undef HAVE_DECL_SETRESUID */
-
-/* Define if you have the setvbuf function.  */
-#define HAVE_SETVBUF 1
-
-/* Define if you have the siginterrupt function.  */
-#define HAVE_SIGINTERRUPT 1
-
-/* Define if you have the POSIX.1-style sigsetjmp function.  */
-#define HAVE_POSIX_SIGSETJMP 1
-
-/* Define if you have the snprintf function.  */
-#define HAVE_SNPRINTF 1
-
-/* Define if you have the strcasecmp function.  */
-#define HAVE_STRCASECMP 1
-
-/* Define if you have the strcasestr function.  */
-#define HAVE_STRCASESTR 1
-
-/* Define if you have the strchr function.  */
-#define HAVE_STRCHR 1
-
-/* Define if you have the strchrnul function.  */
-#define HAVE_STRCHRNUL 1
-
-/* Define if you have the strcoll function.  */
-#define HAVE_STRCOLL 1
-
-/* Define if you have the strerror function.  */
-#define HAVE_STRERROR 1
-
-/* Define if you have the strftime function. */
-#define HAVE_STRFTIME 1
-
-/* Define if you have the strnlen function. */
-#define HAVE_STRNLEN 1
-
-/* Define if you have the strpbrk function. */
-#define HAVE_STRPBRK 1
-
-/* Define if you have the strstr function. */
-#define HAVE_STRSTR 1
-
-/* Define if you have the strtod function. */
-#define HAVE_STRTOD 1
-
-/* Define if you have the strtoimax function. */
-#define HAVE_STRTOIMAX 1
-
-/* Define if you have the strtol function. */
-#define HAVE_STRTOL 1
-
-/* Define if you have the strtoll function. */
-#define HAVE_STRTOLL 1
-
-/* Define if you have the strtoul function. */
-#define HAVE_STRTOUL 1
-
-/* Define if you have the strtoull function. */
-#define HAVE_STRTOULL 1
-
-/* Define if you have the strtoumax function. */
-#define HAVE_STRTOUMAX 1
-
-/* Define if you have the strsignal function or macro. */
-#define HAVE_STRSIGNAL 1
-
-/* Define if you have the sysconf function. */
-#define HAVE_SYSCONF 1
-
-/* Define if you have the syslog function. */
-#define HAVE_SYSLOG 1
-
-/* Define if you have the tcgetattr function.  */
-#define HAVE_TCGETATTR 1
-
-/* Define if you have the tcgetpgrp function.  */
-#define HAVE_TCGETPGRP 1
-
-/* Define if you have the times function.  */
-#define HAVE_TIMES 1
-
-/* Define if you have the towlower function.  */
-#define HAVE_TOWLOWER 1
-
-/* Define if you have the towupper function.  */
-#define HAVE_TOWUPPER 1
-
-/* Define if you have the ttyname function.  */
-#define HAVE_TTYNAME 1
-
-/* Define if you have the tzset function. */
-#define HAVE_TZSET 1
-
-/* Define if you have the ulimit function. */
-/* #undef HAVE_ULIMIT */
-
-/* Define if you have the uname function. */
-#define HAVE_UNAME 1
-
-/* Define if you have the unsetenv function.  */
-#define HAVE_UNSETENV 1
-
-/* Define if you have the vasprintf function.  */
-#define HAVE_VASPRINTF 1
-
-/* Define if you have the vprintf function.  */
-#define HAVE_VPRINTF 1
-
-/* Define if you have the vsnprintf function.  */
-#define HAVE_VSNPRINTF 1
-
-/* Define if you have the waitpid function. */
-#define HAVE_WAITPID 1
-
-/* Define if you have the wait3 function.  */
-#define HAVE_WAIT3 1
-
-/* Define if you have the wcrtomb function.  */
-#define HAVE_WCRTOMB 1
-
-/* Define if you have the wcscoll function.  */
-#define HAVE_WCSCOLL 1
-
-/* Define if you have the wcsdup function.  */
-#define HAVE_WCSDUP 1
-
-/* Define if you have the wctype function.  */
-#define HAVE_WCTYPE 1
-
-/* Define if you have the wcswidth function.  */
-#define HAVE_WCSWIDTH 1
-
-/* Define if you have the wcwidth function.  */
-#define HAVE_WCWIDTH 1
-
-/* and if it works */
-/* #undef WCWIDTH_BROKEN */
-
-/* Presence of certain system include files. */
-
-/* Define if you have the <arpa/inet.h> header file. */
-#define HAVE_ARPA_INET_H 1
-
-/* Define if you have the <dirent.h> header file.  */
-#define HAVE_DIRENT_H 1
-
-/* Define if you have the <dlfcn.h> header file.  */
-#define HAVE_DLFCN_H 1
-
-/* Define if you have the <grp.h> header file.  */
-#define HAVE_GRP_H 1
-
-/* Define if you have the <inttypes.h> header file. */
-#define HAVE_INTTYPES_H 1
-
-/* Define if you have the <langinfo.h> header file.  */
-#define HAVE_LANGINFO_H 1
-
-/* Define if you have the <libaudit.h> header file. */
-/* #undef HAVE_LIBAUDIT_H */
-
-/* Define if you have the <libintl.h> header file. */
-/* #undef HAVE_LIBINTL_H */
-
-/* Define if you have the <limits.h> header file.  */
-#define HAVE_LIMITS_H 1
-
-/* Define if you have the <locale.h> header file.  */
-#define HAVE_LOCALE_H 1
-
-/* Define if you have the <mbstr.h> header file.  */
-/* #undef HAVE_MBSTR_H */
-
-/* Define if you have the <ndir.h> header file.  */
-/* #undef HAVE_NDIR_H */
-
-/* Define if you have the <netdh.h> header file. */
-#define HAVE_NETDB_H 1
-
-/* Define if you have the <netinet/in.h> header file. */
-#define HAVE_NETINET_IN_H 1
-
-/* Define if you have the <pwd.h> header file. */
-#define HAVE_PWD_H 1
-
-/* Define if you have the <regex.h> header file. */
-#define HAVE_REGEX_H 1
-
-/* Define if you have the <stdlib.h> header file.  */
-#define HAVE_STDLIB_H 1
-
-/* Define if you have the <stdarg.h> header file.  */
-#define HAVE_STDARG_H 1
-
-/* Define if you have the <string.h> header file.  */
-#define HAVE_STRING_H 1
-
-/* Define if you have the <strings.h> header file.  */
-#define HAVE_STRINGS_H 1
-
-/* Define if you have the <memory.h> header file.  */
-#define HAVE_MEMORY_H 1
-
-/* Define if you have the <stdbool.h> header file. */
-#define HAVE_STDBOOL_H 1
-
-/* Define if you have the <stddef.h> header file. */
-#define HAVE_STDDEF_H 1
-
-/* Define if you have the <stdint.h> header file. */
-#define HAVE_STDINT_H 1
-
-/* Define if you have the <syslog.h> header file. */
-#define HAVE_SYSLOG_H 1
-
-/* Define if you have the <sys/dir.h> header file.  */
-/* #undef HAVE_SYS_DIR_H */
-
-/* Define if you have the <sys/file.h> header file.  */
-#define HAVE_SYS_FILE_H 1
-
-/* Define if you have the <sys/ioctl.h> header file.  */
-#define HAVE_SYS_IOCTL_H 1
-
-/* Define if you have the <sys/mman.h> header file.  */
-#define HAVE_SYS_MMAN_H 1
-
-/* Define if you have the <sys/ndir.h> header file.  */
-/* #undef HAVE_SYS_NDIR_H */
-
-/* Define if you have the <sys/param.h> header file.  */
-#define HAVE_SYS_PARAM_H 1
-
-/* Define if you have the <sys/pte.h> header file.  */
-/* #undef HAVE_SYS_PTE_H */
-
-/* Define if you have the <sys/ptem.h> header file.  */
-/* #undef HAVE_SYS_PTEM_H */
-
-/* Define if you have the <sys/random.h> header file.  */
-#define HAVE_SYS_RANDOM_H 1
-
-/* Define if you have the <sys/resource.h> header file.  */
-#define HAVE_SYS_RESOURCE_H 1
-
-/* Define if you have the <sys/select.h> header file.  */
-#define HAVE_SYS_SELECT_H 1
-
-/* Define if you have the <sys/socket.h> header file.  */
-#define HAVE_SYS_SOCKET_H 1
-
-/* Define if you have the <sys/stat.h> header file. */
-#define HAVE_SYS_STAT_H 1
-
-/* Define if you have the <sys/stream.h> header file.  */
-/* #undef HAVE_SYS_STREAM_H */
-
-/* Define if you have <sys/time.h> */
-#define HAVE_SYS_TIME_H 1
-
-/* Define if you have <sys/times.h> */
-#define HAVE_SYS_TIMES_H 1
-
-/* Define if you have the <sys/types.h> header file. */
-#define HAVE_SYS_TYPES_H 1
-
-/* Define if you have <sys/wait.h> that is POSIX.1 compatible.  */
-#define HAVE_SYS_WAIT_H 1
-
-/* Define if you have the <termcap.h> header file.  */
-/* #undef HAVE_TERMCAP_H */
-
-/* Define if you have the <termio.h> header file.  */
-/* #undef HAVE_TERMIO_H */
-
-/* Define if you have the <termios.h> header file.  */
-#define HAVE_TERMIOS_H 1
-
-/* Define if you have the <ulimit.h> header file.  */
-/* #undef HAVE_ULIMIT_H */
-
-/* Define if you have the <unistd.h> header file.  */
-#define HAVE_UNISTD_H 1
-
-/* Define if you have the <varargs.h> header file.  */
-/* #undef HAVE_VARARGS_H */
-
-/* Define if you have the <wchar.h> header file.  */
-#define HAVE_WCHAR_H 1
-
-/* Define if you have the <varargs.h> header file.  */
-#define HAVE_WCTYPE_H 1
-
-/* Presence of certain system libraries. */
-
-/* #undef HAVE_LIBDL */
-
-/* #undef HAVE_LIBSUN */
-
-/* #undef HAVE_LIBSOCKET */
-
-/* Are we running the GNU C library, version 2.1 or later? */
-/* #undef GLIBC21 */
-
-/* Are we running SVR5 (UnixWare 7)? */
-/* #undef SVR5 */
-
-/* Are we running SVR4.2? */
-/* #undef SVR4_2 */
-
-/* Are we running some version of SVR4? */
-/* #undef SVR4 */
-
-/* Define if job control is unusable or unsupported. */
-/* #undef JOB_CONTROL_MISSING */
-
-/* Do we need to define _KERNEL to get the RLIMIT_* defines from
-   <sys/resource.h>? */
-/* #undef RLIMIT_NEEDS_KERNEL */
-
-/* Number of bits in a file offset, on hosts where this is settable. */
-/* #undef _FILE_OFFSET_BITS */
-
-/* Define for large files on AIX-style hosts. */
-/* #undef _LARGE_FILES */
-
-/* Do strcoll(3) and strcmp(3) give different results in the default locale? */
-/* #undef STRCOLL_BROKEN */
-
-/* #undef DUP2_BROKEN */
-
-/* #undef GETCWD_BROKEN */
-
-#define DEV_FD_STAT_BROKEN
-
-/* An array implementation that prioritizes speed (O(1) access) over space,
-   in array2.c */
-/* #undef ALT_ARRAY_IMPLEMENTATION */
-
-/* Support for $"..." translatable strings. */
-#define TRANSLATABLE_STRINGS 1
-
-/* Additional defines for configuring lib/intl, maintained by autoscan/autoheader */
-
-/* Define if you have the <argz.h> header file. */
-/* #undef HAVE_ARGZ_H */
-
-/* Define if you have the <errno.h> header file. */
-#define HAVE_ERRNO_H 1
-
-/* Define if you have the <fcntl.h> header file. */
-#define HAVE_FCNTL_H 1
-
-/* Define if you have the <malloc.h> header file. */
-#define HAVE_MALLOC_H 1
-
-/* Define if you have the <stdio_ext.h> header file. */
-#define HAVE_STDIO_EXT_H 1
-
-/* Define if you have the `dcgettext' function. */
-/* #undef HAVE_DCGETTEXT */
-
-/* Define if you have the `localeconv' function. */
-#define HAVE_LOCALECONV 1
-
-/* Define if your system has a working `malloc' function. */
-/* #undef HAVE_MALLOC */
-
-/* Define if you have the `mempcpy' function. */
-#define HAVE_MEMPCPY 1
-
-/* Define if you have a working `mmap' system call. */
-/* #undef HAVE_MMAP */
-
-/* Define if you have the `mremap' function. */
-/* #undef HAVE_MREMAP */
-
-/* Define if you have the `munmap' function. */
-#define HAVE_MUNMAP 1
-
-/* Define if you have the `nl_langinfo' function. */
-/* #undef HAVE_NL_LANGINFO */
-
-/* Define if you have the `stpcpy' function. */
-#define HAVE_STPCPY 1
-
-/* Define if you have the `strcspn' function. */
-#define HAVE_STRCSPN 1
-
-/* Define if you have the `strdup' function. */
-#define HAVE_STRDUP 1
-
-/* Define if you have the `__argz_count' function. */
-/* #undef HAVE___ARGZ_COUNT */
-
-/* Define if you have the `__argz_next' function. */
-/* #undef HAVE___ARGZ_NEXT */
-
-/* Define if you have the `__argz_stringify' function. */
-/* #undef HAVE___ARGZ_STRINGIFY */
-
-/* End additions for lib/intl */
-
-#include "config-bot.h"
-
-#endif /* _CONFIG_H_ */
diff --git a/third_party/bash/conftypes.h b/third_party/bash/conftypes.h
deleted file mode 100644
index 1c8c5480a..000000000
--- a/third_party/bash/conftypes.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/* conftypes.h -- defines for build and host system. */
-
-/* Copyright (C) 2001, 2005, 2008,2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_CONFTYPES_H_)
-#define _CONFTYPES_H_
-
-/* Placeholder for future modifications if cross-compiling or building a
-   `fat' binary, e.g. on Apple Rhapsody.  These values are used in multiple
-   files, so they appear here. */
-#if !defined (RHAPSODY) && !defined (MACOSX)
-#  define HOSTTYPE	CONF_HOSTTYPE
-#  define OSTYPE	CONF_OSTYPE
-#  define MACHTYPE	CONF_MACHTYPE
-#else /* RHAPSODY */
-#  if   defined(__powerpc__) || defined(__ppc__)
-#    define HOSTTYPE "powerpc"
-#  elif defined(__i386__)
-#    define HOSTTYPE "i386"
-#  else
-#    define HOSTTYPE CONF_HOSTTYPE
-#  endif
-
-#  define OSTYPE CONF_OSTYPE
-#  define VENDOR CONF_VENDOR
-
-#  define MACHTYPE HOSTTYPE "-" VENDOR "-" OSTYPE
-#endif /* RHAPSODY */
-
-#ifndef HOSTTYPE
-#  define HOSTTYPE "unknown"
-#endif
-
-#ifndef OSTYPE
-#  define OSTYPE "unknown"
-#endif
-
-#ifndef MACHTYPE
-#  define MACHTYPE "unknown"
-#endif
-
-#endif /* _CONFTYPES_H_ */
diff --git a/third_party/bash/copy_cmd.c b/third_party/bash/copy_cmd.c
deleted file mode 100644
index 758ff238a..000000000
--- a/third_party/bash/copy_cmd.c
+++ /dev/null
@@ -1,459 +0,0 @@
-/* copy_command.c -- copy a COMMAND structure.  This is needed
-   primarily for making function definitions, but I'm not sure
-   that anyone else will need it.  */
-
-/* Copyright (C) 1987-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-
-#include "shell.h"
-
-static PATTERN_LIST *copy_case_clause PARAMS((PATTERN_LIST *));
-static PATTERN_LIST *copy_case_clauses PARAMS((PATTERN_LIST *));
-static FOR_COM *copy_for_command PARAMS((FOR_COM *));
-#if defined (ARITH_FOR_COMMAND)
-static ARITH_FOR_COM *copy_arith_for_command PARAMS((ARITH_FOR_COM *));
-#endif
-static GROUP_COM *copy_group_command PARAMS((GROUP_COM *));
-static SUBSHELL_COM *copy_subshell_command PARAMS((SUBSHELL_COM *));
-static COPROC_COM *copy_coproc_command PARAMS((COPROC_COM *));
-static CASE_COM *copy_case_command PARAMS((CASE_COM *));
-static WHILE_COM *copy_while_command PARAMS((WHILE_COM *));
-static IF_COM *copy_if_command PARAMS((IF_COM *));
-#if defined (DPAREN_ARITHMETIC)
-static ARITH_COM *copy_arith_command PARAMS((ARITH_COM *));
-#endif
-#if defined (COND_COMMAND)
-static COND_COM *copy_cond_command PARAMS((COND_COM *));
-#endif
-static SIMPLE_COM *copy_simple_command PARAMS((SIMPLE_COM *));
-
-WORD_DESC *
-copy_word (w)
-     WORD_DESC *w;
-{
-  WORD_DESC *new_word;
-
-  new_word = make_bare_word (w->word);
-  new_word->flags = w->flags;
-  return (new_word);
-}
-
-/* Copy the chain of words in LIST.  Return a pointer to
-   the new chain. */
-WORD_LIST *
-copy_word_list (list)
-     WORD_LIST *list;
-{
-  WORD_LIST *new_list, *tl;
-
-  for (new_list = tl = (WORD_LIST *)NULL; list; list = list->next)
-    {
-      if (new_list == 0)
-	new_list = tl = make_word_list (copy_word (list->word), new_list);
-      else
-	{
-	  tl->next = make_word_list (copy_word (list->word), (WORD_LIST *)NULL);
-	  tl = tl->next;
-	}
-    }
-
-  return (new_list);
-}
-
-static PATTERN_LIST *
-copy_case_clause (clause)
-     PATTERN_LIST *clause;
-{
-  PATTERN_LIST *new_clause;
-
-  new_clause = (PATTERN_LIST *)xmalloc (sizeof (PATTERN_LIST));
-  new_clause->patterns = copy_word_list (clause->patterns);
-  new_clause->action = copy_command (clause->action);
-  new_clause->flags = clause->flags;
-  return (new_clause);
-}
-
-static PATTERN_LIST *
-copy_case_clauses (clauses)
-     PATTERN_LIST *clauses;
-{
-  PATTERN_LIST *new_list, *new_clause;
-
-  for (new_list = (PATTERN_LIST *)NULL; clauses; clauses = clauses->next)
-    {
-      new_clause = copy_case_clause (clauses);
-      new_clause->next = new_list;
-      new_list = new_clause;
-    }
-  return (REVERSE_LIST (new_list, PATTERN_LIST *));
-}
-
-/* Copy a single redirect. */
-REDIRECT *
-copy_redirect (redirect)
-     REDIRECT *redirect;
-{
-  REDIRECT *new_redirect;
-
-  new_redirect = (REDIRECT *)xmalloc (sizeof (REDIRECT));
-#if 0
-  FASTCOPY ((char *)redirect, (char *)new_redirect, (sizeof (REDIRECT)));
-#else
-  *new_redirect = *redirect;	/* let the compiler do the fast structure copy */
-#endif
-
-  if (redirect->rflags & REDIR_VARASSIGN)
-    new_redirect->redirector.filename = copy_word (redirect->redirector.filename);
-
-  switch (redirect->instruction)
-    {
-    case r_reading_until:
-    case r_deblank_reading_until:
-      new_redirect->here_doc_eof = redirect->here_doc_eof ? savestring (redirect->here_doc_eof) : 0;
-      /*FALLTHROUGH*/
-    case r_reading_string:
-    case r_appending_to:
-    case r_output_direction:
-    case r_input_direction:
-    case r_inputa_direction:
-    case r_err_and_out:
-    case r_append_err_and_out:
-    case r_input_output:
-    case r_output_force:
-    case r_duplicating_input_word:
-    case r_duplicating_output_word:
-    case r_move_input_word:
-    case r_move_output_word:
-      new_redirect->redirectee.filename = copy_word (redirect->redirectee.filename);
-      break;
-    case r_duplicating_input:
-    case r_duplicating_output:
-    case r_move_input:
-    case r_move_output:
-    case r_close_this:
-      break;
-    }
-  return (new_redirect);
-}
-
-REDIRECT *
-copy_redirects (list)
-     REDIRECT *list;
-{
-  REDIRECT *new_list, *temp;
-
-  for (new_list = (REDIRECT *)NULL; list; list = list->next)
-    {
-      temp = copy_redirect (list);
-      temp->next = new_list;
-      new_list = temp;
-    }
-  return (REVERSE_LIST (new_list, REDIRECT *));
-}
-
-static FOR_COM *
-copy_for_command (com)
-     FOR_COM *com;
-{
-  FOR_COM *new_for;
-
-  new_for = (FOR_COM *)xmalloc (sizeof (FOR_COM));
-  new_for->flags = com->flags;
-  new_for->line = com->line;
-  new_for->name = copy_word (com->name);
-  new_for->map_list = copy_word_list (com->map_list);
-  new_for->action = copy_command (com->action);
-  return (new_for);
-}
-
-#if defined (ARITH_FOR_COMMAND)
-static ARITH_FOR_COM *
-copy_arith_for_command (com)
-     ARITH_FOR_COM *com;
-{
-  ARITH_FOR_COM *new_arith_for;
-
-  new_arith_for = (ARITH_FOR_COM *)xmalloc (sizeof (ARITH_FOR_COM));
-  new_arith_for->flags = com->flags;
-  new_arith_for->line = com->line;
-  new_arith_for->init = copy_word_list (com->init);
-  new_arith_for->test = copy_word_list (com->test);
-  new_arith_for->step = copy_word_list (com->step);
-  new_arith_for->action = copy_command (com->action);
-  return (new_arith_for);
-}
-#endif /* ARITH_FOR_COMMAND */
-
-static GROUP_COM *
-copy_group_command (com)
-     GROUP_COM *com;
-{
-  GROUP_COM *new_group;
-
-  new_group = (GROUP_COM *)xmalloc (sizeof (GROUP_COM));
-  new_group->command = copy_command (com->command);
-  return (new_group);
-}
-
-static SUBSHELL_COM *
-copy_subshell_command (com)
-     SUBSHELL_COM *com;
-{
-  SUBSHELL_COM *new_subshell;
-
-  new_subshell = (SUBSHELL_COM *)xmalloc (sizeof (SUBSHELL_COM));
-  new_subshell->command = copy_command (com->command);
-  new_subshell->flags = com->flags;
-  new_subshell->line = com->line;
-  return (new_subshell);
-}
-
-static COPROC_COM *
-copy_coproc_command (com)
-     COPROC_COM *com;
-{
-  COPROC_COM *new_coproc;
-
-  new_coproc = (COPROC_COM *)xmalloc (sizeof (COPROC_COM));
-  new_coproc->name = savestring (com->name);
-  new_coproc->command = copy_command (com->command);
-  new_coproc->flags = com->flags;
-  return (new_coproc);
-}
-
-static CASE_COM *
-copy_case_command (com)
-     CASE_COM *com;
-{
-  CASE_COM *new_case;
-
-  new_case = (CASE_COM *)xmalloc (sizeof (CASE_COM));
-  new_case->flags = com->flags;
-  new_case->line = com->line;
-  new_case->word = copy_word (com->word);
-  new_case->clauses = copy_case_clauses (com->clauses);
-  return (new_case);
-}
-
-static WHILE_COM *
-copy_while_command (com)
-     WHILE_COM *com;
-{
-  WHILE_COM *new_while;
-
-  new_while = (WHILE_COM *)xmalloc (sizeof (WHILE_COM));
-  new_while->flags = com->flags;
-  new_while->test = copy_command (com->test);
-  new_while->action = copy_command (com->action);
-  return (new_while);
-}
-
-static IF_COM *
-copy_if_command (com)
-     IF_COM *com;
-{
-  IF_COM *new_if;
-
-  new_if = (IF_COM *)xmalloc (sizeof (IF_COM));
-  new_if->flags = com->flags;
-  new_if->test = copy_command (com->test);
-  new_if->true_case = copy_command (com->true_case);
-  new_if->false_case = com->false_case ? copy_command (com->false_case) : com->false_case;
-  return (new_if);
-}
-
-#if defined (DPAREN_ARITHMETIC)
-static ARITH_COM *
-copy_arith_command (com)
-     ARITH_COM *com;
-{
-  ARITH_COM *new_arith;
-
-  new_arith = (ARITH_COM *)xmalloc (sizeof (ARITH_COM));
-  new_arith->flags = com->flags;
-  new_arith->exp = copy_word_list (com->exp);
-  new_arith->line = com->line;
-
-  return (new_arith);
-}
-#endif
-
-#if defined (COND_COMMAND)
-static COND_COM *
-copy_cond_command (com)
-     COND_COM *com;
-{
-  COND_COM *new_cond;
-
-  new_cond = (COND_COM *)xmalloc (sizeof (COND_COM));
-  new_cond->flags = com->flags;
-  new_cond->line = com->line;
-  new_cond->type = com->type;
-  new_cond->op = com->op ? copy_word (com->op) : com->op;
-  new_cond->left = com->left ? copy_cond_command (com->left) : (COND_COM *)NULL;
-  new_cond->right = com->right ? copy_cond_command (com->right) : (COND_COM *)NULL;
-
-  return (new_cond);
-}
-#endif
-
-static SIMPLE_COM *
-copy_simple_command (com)
-     SIMPLE_COM *com;
-{
-  SIMPLE_COM *new_simple;
-
-  new_simple = (SIMPLE_COM *)xmalloc (sizeof (SIMPLE_COM));
-  new_simple->flags = com->flags;
-  new_simple->words = copy_word_list (com->words);
-  new_simple->redirects = com->redirects ? copy_redirects (com->redirects) : (REDIRECT *)NULL;
-  new_simple->line = com->line;
-  return (new_simple);
-}
-
-FUNCTION_DEF *
-copy_function_def_contents (old, new_def)
-     FUNCTION_DEF *old, *new_def;
-{
-  new_def->name = copy_word (old->name);
-  new_def->command = old->command ? copy_command (old->command) : old->command;
-  new_def->flags = old->flags;
-  new_def->line = old->line;
-  new_def->source_file = old->source_file ? savestring (old->source_file) : old->source_file;
-  return (new_def);
-}
-
-FUNCTION_DEF *
-copy_function_def (com)
-     FUNCTION_DEF *com;
-{
-  FUNCTION_DEF *new_def;
-
-  new_def = (FUNCTION_DEF *)xmalloc (sizeof (FUNCTION_DEF));
-  new_def = copy_function_def_contents (com, new_def);
-  return (new_def);
-}
-
-/* Copy the command structure in COMMAND.  Return a pointer to the
-   copy.  Don't you forget to dispose_command () on this pointer
-   later! */
-COMMAND *
-copy_command (command)
-     COMMAND *command;
-{
-  COMMAND *new_command;
-
-  if (command == NULL)
-    return (command);
-
-  new_command = (COMMAND *)xmalloc (sizeof (COMMAND));
-  FASTCOPY ((char *)command, (char *)new_command, sizeof (COMMAND));
-  new_command->flags = command->flags;
-  new_command->line = command->line;
-
-  if (command->redirects)
-    new_command->redirects = copy_redirects (command->redirects);
-
-  switch (command->type)
-    {
-      case cm_for:
-	new_command->value.For = copy_for_command (command->value.For);
-	break;
-
-#if defined (ARITH_FOR_COMMAND)
-      case cm_arith_for:
-	new_command->value.ArithFor = copy_arith_for_command (command->value.ArithFor);
-	break;
-#endif
-
-#if defined (SELECT_COMMAND)
-      case cm_select:
-	new_command->value.Select =
-	  (SELECT_COM *)copy_for_command ((FOR_COM *)command->value.Select);
-	break;
-#endif
-
-      case cm_group:
-	new_command->value.Group = copy_group_command (command->value.Group);
-	break;
-
-      case cm_subshell:
-	new_command->value.Subshell = copy_subshell_command (command->value.Subshell);
-	break;
-
-      case cm_coproc:
-	new_command->value.Coproc = copy_coproc_command (command->value.Coproc);
-	break;
-
-      case cm_case:
-	new_command->value.Case = copy_case_command (command->value.Case);
-	break;
-
-      case cm_until:
-      case cm_while:
-	new_command->value.While = copy_while_command (command->value.While);
-	break;
-
-      case cm_if:
-	new_command->value.If = copy_if_command (command->value.If);
-	break;
-
-#if defined (DPAREN_ARITHMETIC)
-      case cm_arith:
-	new_command->value.Arith = copy_arith_command (command->value.Arith);
-	break;
-#endif
-
-#if defined (COND_COMMAND)
-      case cm_cond:
-	new_command->value.Cond = copy_cond_command (command->value.Cond);
-	break;
-#endif
-
-      case cm_simple:
-	new_command->value.Simple = copy_simple_command (command->value.Simple);
-	break;
-
-      case cm_connection:
-	{
-	  CONNECTION *new_connection;
-
-	  new_connection = (CONNECTION *)xmalloc (sizeof (CONNECTION));
-	  new_connection->connector = command->value.Connection->connector;
-	  new_connection->first = copy_command (command->value.Connection->first);
-	  new_connection->second = copy_command (command->value.Connection->second);
-	  new_command->value.Connection = new_connection;
-	  break;
-	}
-
-      case cm_function_def:
-	new_command->value.Function_def = copy_function_def (command->value.Function_def);
-	break;
-    }
-  return (new_command);
-}
diff --git a/third_party/bash/dispose_cmd.c b/third_party/bash/dispose_cmd.c
deleted file mode 100644
index c624605b5..000000000
--- a/third_party/bash/dispose_cmd.c
+++ /dev/null
@@ -1,342 +0,0 @@
-/* dispose_command.c -- dispose of a COMMAND structure. */
-
-/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "shell.h"
-
-extern sh_obj_cache_t wdcache, wlcache;
-
-/* Dispose of the command structure passed. */
-void
-dispose_command (command)
-     COMMAND *command;
-{
-  if (command == 0)
-    return;
-
-  if (command->redirects)
-    dispose_redirects (command->redirects);
-
-  switch (command->type)
-    {
-    case cm_for:
-#if defined (SELECT_COMMAND)
-    case cm_select:
-#endif
-      {
-	register FOR_COM *c;
-#if defined (SELECT_COMMAND)
-	if (command->type == cm_select)
-	  c = (FOR_COM *)command->value.Select;
-	else
-#endif
-	c = command->value.For;
-	dispose_word (c->name);
-	dispose_words (c->map_list);
-	dispose_command (c->action);
-	free (c);
-	break;
-      }
-
-#if defined (ARITH_FOR_COMMAND)
-    case cm_arith_for:
-      {
-	register ARITH_FOR_COM *c;
-
-	c = command->value.ArithFor;
-	dispose_words (c->init);
-	dispose_words (c->test);
-	dispose_words (c->step);
-	dispose_command (c->action);
-	free (c);
-	break;
-      }
-#endif /* ARITH_FOR_COMMAND */
-
-    case cm_group:
-      {
-	dispose_command (command->value.Group->command);
-	free (command->value.Group);
-	break;
-      }
-
-    case cm_subshell:
-      {
-	dispose_command (command->value.Subshell->command);
-	free (command->value.Subshell);
-	break;
-      }
-
-    case cm_coproc:
-      {
-	free (command->value.Coproc->name);
-	dispose_command (command->value.Coproc->command);
-	free (command->value.Coproc);
-	break;
-      }
-
-    case cm_case:
-      {
-	register CASE_COM *c;
-	PATTERN_LIST *t, *p;
-
-	c = command->value.Case;
-	dispose_word (c->word);
-
-	for (p = c->clauses; p; )
-	  {
-	    dispose_words (p->patterns);
-	    dispose_command (p->action);
-	    t = p;
-	    p = p->next;
-	    free (t);
-	  }
-	free (c);
-	break;
-      }
-
-    case cm_until:
-    case cm_while:
-      {
-	register WHILE_COM *c;
-
-	c = command->value.While;
-	dispose_command (c->test);
-	dispose_command (c->action);
-	free (c);
-	break;
-      }
-
-    case cm_if:
-      {
-	register IF_COM *c;
-
-	c = command->value.If;
-	dispose_command (c->test);
-	dispose_command (c->true_case);
-	dispose_command (c->false_case);
-	free (c);
-	break;
-      }
-
-    case cm_simple:
-      {
-	register SIMPLE_COM *c;
-
-	c = command->value.Simple;
-	dispose_words (c->words);
-	dispose_redirects (c->redirects);
-	free (c);
-	break;
-      }
-
-    case cm_connection:
-      {
-	register CONNECTION *c;
-
-	c = command->value.Connection;
-	dispose_command (c->first);
-	dispose_command (c->second);
-	free (c);
-	break;
-      }
-
-#if defined (DPAREN_ARITHMETIC)
-    case cm_arith:
-      {
-	register ARITH_COM *c;
-
-	c = command->value.Arith;
-	dispose_words (c->exp);
-	free (c);
-	break;
-      }
-#endif /* DPAREN_ARITHMETIC */
-
-#if defined (COND_COMMAND)
-    case cm_cond:
-      {
-	register COND_COM *c;
-
-	c = command->value.Cond;
-	dispose_cond_node (c);
-	break;
-      }
-#endif /* COND_COMMAND */
-
-    case cm_function_def:
-      {
-	register FUNCTION_DEF *c;
-
-	c = command->value.Function_def;
-	dispose_function_def (c);
-	break;
-      }
-
-    default:
-      command_error ("dispose_command", CMDERR_BADTYPE, command->type, 0);
-      break;
-    }
-  free (command);
-}
-
-#if defined (COND_COMMAND)
-/* How to free a node in a conditional command. */
-void
-dispose_cond_node (cond)
-     COND_COM *cond;
-{
-  if (cond)
-    {
-      if (cond->left)
-	dispose_cond_node (cond->left);
-      if (cond->right)
-	dispose_cond_node (cond->right);
-      if (cond->op)
-	dispose_word (cond->op);
-      free (cond);
-    }
-}
-#endif /* COND_COMMAND */
-
-void
-dispose_function_def_contents (c)
-     FUNCTION_DEF *c;
-{
-  dispose_word (c->name);
-  dispose_command (c->command);
-  FREE (c->source_file);
-}
-
-void
-dispose_function_def (c)
-     FUNCTION_DEF *c;
-{
-  dispose_function_def_contents (c);
-  free (c);
-}
-
-/* How to free a WORD_DESC. */
-void
-dispose_word (w)
-     WORD_DESC *w;
-{
-  FREE (w->word);
-  ocache_free (wdcache, WORD_DESC, w);
-}
-
-/* Free a WORD_DESC, but not the word contained within. */
-void
-dispose_word_desc (w)
-     WORD_DESC *w;
-{
-  w->word = 0;
-  ocache_free (wdcache, WORD_DESC, w);
-}
-
-/* How to get rid of a linked list of words.  A WORD_LIST. */
-void
-dispose_words (list)
-     WORD_LIST *list;
-{
-  WORD_LIST *t;
-
-  while (list)
-    {
-      t = list;
-      list = list->next;
-      dispose_word (t->word);
-#if 0
-      free (t);
-#else
-      ocache_free (wlcache, WORD_LIST, t);
-#endif
-    }
-}
-
-#ifdef INCLUDE_UNUSED
-/* How to dispose of an array of pointers to char.  This is identical to
-   free_array in stringlib.c. */
-void
-dispose_word_array (array)
-     char **array;
-{
-  register int count;
-
-  if (array == 0)
-    return;
-
-  for (count = 0; array[count]; count++)
-    free (array[count]);
-
-  free (array);
-}
-#endif
-
-/* How to dispose of an list of redirections.  A REDIRECT. */
-void
-dispose_redirects (list)
-     REDIRECT *list;
-{
-  register REDIRECT *t;
-
-  while (list)
-    {
-      t = list;
-      list = list->next;
-
-      if (t->rflags & REDIR_VARASSIGN)
-	dispose_word (t->redirector.filename);
-
-      switch (t->instruction)
-	{
-	case r_reading_until:
-	case r_deblank_reading_until:
-	  free (t->here_doc_eof);
-	/*FALLTHROUGH*/
-	case r_reading_string:
-	case r_output_direction:
-	case r_input_direction:
-	case r_inputa_direction:
-	case r_appending_to:
-	case r_err_and_out:
-	case r_append_err_and_out:
-	case r_input_output:
-	case r_output_force:
-	case r_duplicating_input_word:
-	case r_duplicating_output_word:
-	case r_move_input_word:
-	case r_move_output_word:
-	  dispose_word (t->redirectee.filename);
-	  /* FALLTHROUGH */
-	default:
-	  break;
-	}
-      free (t);
-    }
-}
diff --git a/third_party/bash/dispose_cmd.h b/third_party/bash/dispose_cmd.h
deleted file mode 100644
index 6095d44a4..000000000
--- a/third_party/bash/dispose_cmd.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/* dispose_cmd.h -- Functions appearing in dispose_cmd.c. */
-
-/* Copyright (C) 1993-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_DISPOSE_CMD_H_)
-#define _DISPOSE_CMD_H_
-
-#include "stdc.h"
-
-extern void dispose_command PARAMS((COMMAND *));
-extern void dispose_word_desc PARAMS((WORD_DESC *));
-extern void dispose_word PARAMS((WORD_DESC *));
-extern void dispose_words PARAMS((WORD_LIST *));
-extern void dispose_word_array PARAMS((char **));
-extern void dispose_redirects PARAMS((REDIRECT *));
-
-#if defined (COND_COMMAND)
-extern void dispose_cond_node PARAMS((COND_COM *));
-#endif
-
-extern void dispose_function_def_contents PARAMS((FUNCTION_DEF *));
-extern void dispose_function_def PARAMS((FUNCTION_DEF *));
-
-#endif /* !_DISPOSE_CMD_H_ */
diff --git a/third_party/bash/eaccess.c b/third_party/bash/eaccess.c
deleted file mode 100644
index 25a114cb2..000000000
--- a/third_party/bash/eaccess.c
+++ /dev/null
@@ -1,248 +0,0 @@
-#include "libc/dce.h"
-/* eaccess.c - eaccess replacement for the shell, plus other access functions. */
-
-/* Copyright (C) 2006-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if defined (HAVE_CONFIG_H)
-#  include "config.h"
-#endif
-
-#include <stdio.h>
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-
-#include <errno.h>
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#if !defined (_POSIX_VERSION) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif /* !_POSIX_VERSION */
-#include "posixstat.h"
-#include "filecntl.h"
-
-#include "shell.h"
-
-#if !defined (R_OK)
-#define R_OK 4
-#define W_OK 2
-#define X_OK 1
-#define F_OK 0
-#endif /* R_OK */
-
-static int path_is_devfd PARAMS((const char *));
-static int sh_stataccess PARAMS((const char *, int));
-#if HAVE_DECL_SETREGID
-static int sh_euidaccess PARAMS((const char *, int));
-#endif
-
-static int
-path_is_devfd (path)
-     const char *path;
-{
-  if (path[0] == '/' && path[1] == 'd' && strncmp (path, "/dev/fd/", 8) == 0)
-    return 1;
-  else if (STREQN (path, "/dev/std", 8))
-    {
-      if (STREQ (path+8, "in") || STREQ (path+8, "out") || STREQ (path+8, "err"))
-	return 1;
-      else
-	return 0;
-    }
-  else
-    return 0;
-}
-
-/* A wrapper for stat () which disallows pathnames that are empty strings
-   and handles /dev/fd emulation on systems that don't have it. */
-int
-sh_stat (path, finfo)
-     const char *path;
-     struct stat *finfo;
-{
-  static char *pbuf = 0;
-
-  if (*path == '\0')
-    {
-      errno = ENOENT;
-      return (-1);
-    }
-  if (path[0] == '/' && path[1] == 'd' && strncmp (path, "/dev/fd/", 8) == 0)
-    {
-      /* If stating /dev/fd/n doesn't produce the same results as fstat of
-	 FD N, then define DEV_FD_STAT_BROKEN */
-//#if !defined (HAVE_DEV_FD) || defined (DEV_FD_STAT_BROKEN)
-if (IsBsd()) {//[jart]
-      intmax_t fd;
-      int r;
-
-      if (legal_number (path + 8, &fd) && fd == (int)fd)
-        {
-          r = fstat ((int)fd, finfo);
-          if (r == 0 || errno != EBADF)
-            return (r);
-        }
-      errno = ENOENT;
-      return (-1);
-//#else
-} else {//[jart]
-  /* If HAVE_DEV_FD is defined, DEV_FD_PREFIX is defined also, and has a
-     trailing slash.  Make sure /dev/fd/xx really uses DEV_FD_PREFIX/xx.
-     On most systems, with the notable exception of linux, this is
-     effectively a no-op. */
-      pbuf = xrealloc (pbuf, sizeof (DEV_FD_PREFIX) + strlen (path + 8));
-      strcpy (pbuf, DEV_FD_PREFIX);
-      strcat (pbuf, path + 8);
-      return (stat (pbuf, finfo));
-//#endif /* !HAVE_DEV_FD */
-}//[jart]
-    }
-#if !defined (HAVE_DEV_STDIN)
-  else if (STREQN (path, "/dev/std", 8))
-    {
-      if (STREQ (path+8, "in"))
-	return (fstat (0, finfo));
-      else if (STREQ (path+8, "out"))
-	return (fstat (1, finfo));
-      else if (STREQ (path+8, "err"))
-	return (fstat (2, finfo));
-      else
-	return (stat (path, finfo));
-    }
-#endif /* !HAVE_DEV_STDIN */
-  return (stat (path, finfo));
-}
-
-/* Do the same thing access(2) does, but use the effective uid and gid,
-   and don't make the mistake of telling root that any file is
-   executable.  This version uses stat(2). */
-static int
-sh_stataccess (path, mode)
-     const char *path;
-     int mode;
-{
-  struct stat st;
-
-  if (sh_stat (path, &st) < 0)
-    return (-1);
-
-  if (current_user.euid == 0)
-    {
-      /* Root can read or write any file. */
-      if ((mode & X_OK) == 0)
-	return (0);
-
-      /* Root can execute any file that has any one of the execute
-	 bits set. */
-      if (st.st_mode & S_IXUGO)
-	return (0);
-    }
-
-  if (st.st_uid == current_user.euid)	/* owner */
-    mode <<= 6;
-  else if (group_member (st.st_gid))
-    mode <<= 3;
-
-  if (st.st_mode & mode)
-    return (0);
-
-  errno = EACCES;
-  return (-1);
-}
-
-#if HAVE_DECL_SETREGID
-/* Version to call when uid != euid or gid != egid.  We temporarily swap
-   the effective and real uid and gid as appropriate. */
-static int
-sh_euidaccess (path, mode)
-     const char *path;
-     int mode;
-{
-  int r, e;
-
-  if (current_user.uid != current_user.euid)
-    setreuid (current_user.euid, current_user.uid);
-  if (current_user.gid != current_user.egid)
-    setregid (current_user.egid, current_user.gid);
-
-  r = access (path, mode);
-  e = errno;
-
-  if (current_user.uid != current_user.euid)
-    setreuid (current_user.uid, current_user.euid);
-  if (current_user.gid != current_user.egid)
-    setregid (current_user.gid, current_user.egid);
-
-  errno = e;
-  return r;  
-}
-#endif
-
-int
-sh_eaccess (path, mode)
-     const char *path;
-     int mode;
-{
-  int ret;
-
-  if (path_is_devfd (path))
-    return (sh_stataccess (path, mode));
-
-#if (defined (HAVE_FACCESSAT) && defined (AT_EACCESS)) || defined (HAVE_EACCESS)
-#  if defined (HAVE_FACCESSAT) && defined (AT_EACCESS)
-  ret = faccessat (AT_FDCWD, path, mode, AT_EACCESS);
-#  else		/* HAVE_EACCESS */	/* FreeBSD */
-  ret = eaccess (path, mode);	/* XXX -- not always correct for X_OK */
-#  endif	/* HAVE_EACCESS */
-#  if defined (__FreeBSD__) || defined (SOLARIS) || defined (_AIX)
-  if (ret == 0 && current_user.euid == 0 && mode == X_OK)
-    return (sh_stataccess (path, mode));
-#  endif	/* __FreeBSD__ || SOLARIS || _AIX */
-  return ret;
-#elif defined (EFF_ONLY_OK)		/* SVR4(?), SVR4.2 */
-  return access (path, mode|EFF_ONLY_OK);
-#else
-  if (mode == F_OK)
-    return (sh_stataccess (path, mode));
-    
-#  if HAVE_DECL_SETREGID
-  if (current_user.uid != current_user.euid || current_user.gid != current_user.egid)
-    return (sh_euidaccess (path, mode));
-#  endif
-
-  if (current_user.uid == current_user.euid && current_user.gid == current_user.egid)
-    {
-      ret = access (path, mode);
-#if defined (__FreeBSD__) || defined (SOLARIS)
-      if (ret == 0 && current_user.euid == 0 && mode == X_OK)
-	return (sh_stataccess (path, mode));
-#endif
-      return ret;
-    }
-
-  return (sh_stataccess (path, mode));
-#endif
-}
diff --git a/third_party/bash/error.c b/third_party/bash/error.c
deleted file mode 100644
index 3e7a2d617..000000000
--- a/third_party/bash/error.c
+++ /dev/null
@@ -1,537 +0,0 @@
-/* error.c -- Functions for handling errors. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include <fcntl.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#if defined (PREFER_STDARG)
-#  include <stdarg.h>
-#else
-#  include <varargs.h>
-#endif
-
-#include <stdio.h>
-
-#include <errno.h>
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "flags.h"
-#include "input.h"
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#endif
-
-extern int executing_line_number PARAMS((void));
-
-#if defined (JOB_CONTROL)
-extern pid_t shell_pgrp;
-extern int give_terminal_to PARAMS((pid_t, int));
-#endif /* JOB_CONTROL */
-
-#if defined (ARRAY_VARS)
-extern const char * const bash_badsub_errmsg;
-#endif
-
-static void error_prolog PARAMS((int));
-
-/* The current maintainer of the shell.  You change this in the
-   Makefile. */
-#if !defined (MAINTAINER)
-#define MAINTAINER "bash-maintainers@gnu.org"
-#endif
-
-const char * const the_current_maintainer = MAINTAINER;
-
-int gnu_error_format = 0;
-
-static void
-error_prolog (print_lineno)
-     int print_lineno;
-{
-  char *ename;
-  int line;
-
-  ename = get_name_for_error ();
-  line = (print_lineno && interactive_shell == 0) ? executing_line_number () : -1;
-
-  if (line > 0)
-    fprintf (stderr, "%s:%s%d: ", ename, gnu_error_format ? "" : _(" line "), line);
-  else
-    fprintf (stderr, "%s: ", ename);
-}
-
-/* Return the name of the shell or the shell script for error reporting. */
-char *
-get_name_for_error ()
-{
-  char *name;
-#if defined (ARRAY_VARS)
-  SHELL_VAR *bash_source_v;
-  ARRAY *bash_source_a;
-#endif
-
-  name = (char *)NULL;
-  if (interactive_shell == 0)
-    {
-#if defined (ARRAY_VARS)
-      bash_source_v = find_variable ("BASH_SOURCE");
-      if (bash_source_v && array_p (bash_source_v) &&
-	  (bash_source_a = array_cell (bash_source_v)))
-	name = array_reference (bash_source_a, 0);
-      if (name == 0 || *name == '\0')	/* XXX - was just name == 0 */
-#endif
-	name = dollar_vars[0];
-    }
-  if (name == 0 && shell_name && *shell_name)
-    name = base_pathname (shell_name);
-  if (name == 0)
-#if defined (PROGRAM)
-    name = PROGRAM;
-#else
-    name = "bash";
-#endif
-
-  return (name);
-}
-
-/* Report an error having to do with FILENAME.  This does not use
-   sys_error so the filename is not interpreted as a printf-style
-   format string. */
-void
-file_error (filename)
-     const char *filename;
-{
-  report_error ("%s: %s", filename, strerror (errno));
-}
-
-void
-#if defined (PREFER_STDARG)
-programming_error (const char *format, ...)
-#else
-programming_error (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-  char *h;
-
-#if defined (JOB_CONTROL)
-  give_terminal_to (shell_pgrp, 0);
-#endif /* JOB_CONTROL */
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  fprintf (stderr, "\n");
-  va_end (args);
-
-#if defined (HISTORY)
-  if (remember_on_history)
-    {
-      h = last_history_line ();
-      fprintf (stderr, _("last command: %s\n"), h ? h : "(null)");
-    }
-#endif
-
-#if 0
-  fprintf (stderr, "Report this to %s\n", the_current_maintainer);
-#endif
-
-  fprintf (stderr, _("Aborting..."));
-  fflush (stderr);
-
-  abort ();
-}
-
-/* Print an error message and, if `set -e' has been executed, exit the
-   shell.  Used in this file by file_error and programming_error.  Used
-   outside this file mostly to report substitution and expansion errors,
-   and for bad invocation options. */
-void
-#if defined (PREFER_STDARG)
-report_error (const char *format, ...)
-#else
-report_error (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-
-  error_prolog (1);
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  fprintf (stderr, "\n");
-
-  va_end (args);
-  if (exit_immediately_on_error)
-    {
-      if (last_command_exit_value == 0)
-	last_command_exit_value = EXECUTION_FAILURE;
-      exit_shell (last_command_exit_value);
-    }
-}
-
-void
-#if defined (PREFER_STDARG)
-fatal_error (const char *format, ...)
-#else
-fatal_error (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-
-  error_prolog (0);
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  fprintf (stderr, "\n");
-
-  va_end (args);
-  sh_exit (2);
-}
-
-void
-#if defined (PREFER_STDARG)
-internal_error (const char *format, ...)
-#else
-internal_error (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-
-  error_prolog (1);
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  fprintf (stderr, "\n");
-
-  va_end (args);
-}
-
-void
-#if defined (PREFER_STDARG)
-internal_warning (const char *format, ...)
-#else
-internal_warning (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-
-  error_prolog (1);
-  fprintf (stderr, _("warning: "));
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  fprintf (stderr, "\n");
-
-  va_end (args);
-}
-
-void
-#if defined (PREFER_STDARG)
-internal_inform (const char *format, ...)
-#else
-internal_inform (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-
-  error_prolog (1);
-  /* TRANSLATORS: this is a prefix for informational messages. */
-  fprintf (stderr, _("INFORM: "));
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  fprintf (stderr, "\n");
-
-  va_end (args);
-}
-
-void
-#if defined (PREFER_STDARG)
-internal_debug (const char *format, ...)
-#else
-internal_debug (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-#ifdef DEBUG
-  va_list args;
-
-  error_prolog (1);
-  fprintf (stderr, _("DEBUG warning: "));
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  fprintf (stderr, "\n");
-
-  va_end (args);
-#else
-  return;
-#endif
-}
-
-void
-#if defined (PREFER_STDARG)
-sys_error (const char *format, ...)
-#else
-sys_error (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  int e;
-  va_list args;
-
-  e = errno;
-  error_prolog (0);
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  fprintf (stderr, ": %s\n", strerror (e));
-
-  va_end (args);
-}
-
-/* An error from the parser takes the general form
-
-	shell_name: input file name: line number: message
-
-   The input file name and line number are omitted if the shell is
-   currently interactive.  If the shell is not currently interactive,
-   the input file name is inserted only if it is different from the
-   shell name. */
-void
-#if defined (PREFER_STDARG)
-parser_error (int lineno, const char *format, ...)
-#else
-parser_error (lineno, format, va_alist)
-     int lineno;
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-  char *ename, *iname;
-
-  ename = get_name_for_error ();
-  iname = yy_input_name ();
-
-  if (interactive)
-    fprintf (stderr, "%s: ", ename);
-  else if (interactive_shell)
-    fprintf (stderr, "%s: %s:%s%d: ", ename, iname, gnu_error_format ? "" : _(" line "), lineno);
-  else if (STREQ (ename, iname))
-    fprintf (stderr, "%s:%s%d: ", ename, gnu_error_format ? "" : _(" line "), lineno);
-  else
-    fprintf (stderr, "%s: %s:%s%d: ", ename, iname, gnu_error_format ? "" : _(" line "), lineno);
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  fprintf (stderr, "\n");
-
-  va_end (args);
-
-  if (exit_immediately_on_error)
-    exit_shell (last_command_exit_value = 2);
-}
-
-#ifdef DEBUG
-/* This assumes ASCII and is suitable only for debugging */
-char *
-strescape (str)
-     const char *str;
-{
-  char *r, *result;
-  unsigned char *s;
-
-  r = result = (char *)xmalloc (strlen (str) * 2 + 1);
-
-  for (s = (unsigned char *)str; s && *s; s++)
-    {
-      if (*s < ' ')
-	{
-	  *r++ = '^';
-	  *r++ = *s+64;
-	}
-      else if (*s == 127)
-	{
-	  *r++ = '^';
-	  *r++ = '?';
-	}
-     else
-	*r++ = *s;
-    }
-
-  *r = '\0';
-  return result;
-}
-
-void
-#if defined (PREFER_STDARG)
-itrace (const char *format, ...)
-#else
-itrace (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-
-  fprintf(stderr, "TRACE: pid %ld: ", (long)getpid());
-
-  SH_VA_START (args, format);
-
-  vfprintf (stderr, format, args);
-  fprintf (stderr, "\n");
-
-  va_end (args);
-
-  fflush(stderr);
-}
-
-/* A trace function for silent debugging -- doesn't require a control
-   terminal. */
-void
-#if defined (PREFER_STDARG)
-trace (const char *format, ...)
-#else
-trace (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-  static FILE *tracefp = (FILE *)NULL;
-
-  if (tracefp == NULL)
-    tracefp = fopen("/tmp/bash-trace.log", "a+");
-
-  if (tracefp == NULL)
-    tracefp = stderr;
-  else
-    fcntl (fileno (tracefp), F_SETFD, 1);     /* close-on-exec */
-
-  fprintf(tracefp, "TRACE: pid %ld: ", (long)getpid());
-
-  SH_VA_START (args, format);
-
-  vfprintf (tracefp, format, args);
-  fprintf (tracefp, "\n");
-
-  va_end (args);
-
-  fflush(tracefp);
-}
-
-#endif /* DEBUG */
-
-/* **************************************************************** */
-/*								    */
-/*  		    Common error reporting			    */
-/*								    */
-/* **************************************************************** */
-
-
-static const char * const cmd_error_table[] = {
-	N_("unknown command error"),	/* CMDERR_DEFAULT */
-	N_("bad command type"),		/* CMDERR_BADTYPE */
-	N_("bad connector"),		/* CMDERR_BADCONN */
-	N_("bad jump"),			/* CMDERR_BADJUMP */
-	0
-};
-
-void
-command_error (func, code, e, flags)
-     const char *func;
-     int code, e, flags;	/* flags currently unused */
-{
-  if (code > CMDERR_LAST)
-    code = CMDERR_DEFAULT;
-
-  programming_error ("%s: %s: %d", func, _(cmd_error_table[code]), e);
-}
-
-char *
-command_errstr (code)
-     int code;
-{
-  if (code > CMDERR_LAST)
-    code = CMDERR_DEFAULT;
-
-  return (_(cmd_error_table[code]));
-}
-
-#ifdef ARRAY_VARS
-void
-err_badarraysub (s)
-     const char *s;
-{
-  report_error ("%s: %s", s, _(bash_badsub_errmsg));
-}
-#endif
-
-void
-err_unboundvar (s)
-     const char *s;
-{
-  report_error (_("%s: unbound variable"), s);
-}
-
-void
-err_readonly (s)
-     const char *s;
-{
-  report_error (_("%s: readonly variable"), s);
-}
diff --git a/third_party/bash/error.h b/third_party/bash/error.h
deleted file mode 100644
index 785c1deb5..000000000
--- a/third_party/bash/error.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/* error.h -- External declarations of functions appearing in error.c. */
-
-/* Copyright (C) 1993-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_ERROR_H_)
-#define _ERROR_H_
-
-#include "stdc.h"
-
-/* Get the name of the shell or shell script for an error message. */
-extern char *get_name_for_error PARAMS((void));
-
-/* Report an error having to do with FILENAME. */
-extern void file_error PARAMS((const char *));
-
-/* Report a programmer's error, and abort.  Pass REASON, and ARG1 ... ARG5. */
-extern void programming_error PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-
-/* General error reporting.  Pass FORMAT and ARG1 ... ARG5. */
-extern void report_error PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-
-/* Error messages for parts of the parser that don't call report_syntax_error */
-extern void parser_error PARAMS((int, const char *, ...))  __attribute__((__format__ (printf, 2, 3)));
-
-/* Report an unrecoverable error and exit.  Pass FORMAT and ARG1 ... ARG5. */
-extern void fatal_error PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-
-/* Report a system error, like BSD warn(3). */
-extern void sys_error PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-
-/* Report an internal error. */
-extern void internal_error PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-
-/* Report an internal warning. */
-extern void internal_warning PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-
-/* Report an internal warning for debugging purposes. */
-extern void internal_debug PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-
-/* Report an internal informational notice. */
-extern void internal_inform PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-
-/* Debugging functions, not enabled in released version. */
-extern char *strescape PARAMS((const char *));
-extern void itrace PARAMS((const char *, ...)) __attribute__ ((__format__ (printf, 1, 2)));
-extern void trace PARAMS((const char *, ...)) __attribute__ ((__format__ (printf, 1, 2)));
-
-/* Report an error having to do with command parsing or execution. */
-extern void command_error PARAMS((const char *, int, int, int));
-
-extern char *command_errstr PARAMS((int));
-
-/* Specific error message functions that eventually call report_error or
-   internal_error. */
-
-extern void err_badarraysub PARAMS((const char *));
-extern void err_unboundvar PARAMS((const char *));
-extern void err_readonly PARAMS((const char *));
-
-#ifdef DEBUG
-#  define INTERNAL_DEBUG(x)	internal_debug x
-#else
-#  define INTERNAL_DEBUG(x)
-#endif
-
-#endif /* !_ERROR_H_ */
diff --git a/third_party/bash/eval.c b/third_party/bash/eval.c
deleted file mode 100644
index 24c5f04eb..000000000
--- a/third_party/bash/eval.c
+++ /dev/null
@@ -1,401 +0,0 @@
-/* eval.c -- reading and evaluating commands. */
-
-/* Copyright (C) 1996-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include <stdio.h>
-
-#include <signal.h>
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "parser.h"
-#include "flags.h"
-#include "trap.h"
-
-#include "common.h"
-
-#include "input.h"
-#include "execute_cmd.h"
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#endif
-
-static void send_pwd_to_eterm PARAMS((void));
-static sighandler alrm_catcher PARAMS((int));
-
-/* Read and execute commands until EOF is reached.  This assumes that
-   the input source has already been initialized. */
-int
-reader_loop ()
-{
-  int our_indirection_level;
-  COMMAND * volatile current_command;
-
-  USE_VAR(current_command);
-
-  current_command = (COMMAND *)NULL;
-
-  our_indirection_level = ++indirection_level;
-
-  if (just_one_command)
-    reset_readahead_token ();
-
-  while (EOF_Reached == 0)
-    {
-      int code;
-
-      code = setjmp_nosigs (top_level);
-
-#if defined (PROCESS_SUBSTITUTION)
-      unlink_fifo_list ();
-#endif /* PROCESS_SUBSTITUTION */
-
-      /* XXX - why do we set this every time through the loop?  And why do
-	 it if SIGINT is trapped in an interactive shell? */
-      if (interactive_shell && signal_is_ignored (SIGINT) == 0 && signal_is_trapped (SIGINT) == 0)
-	set_signal_handler (SIGINT, sigint_sighandler);
-
-      if (code != NOT_JUMPED)
-	{
-	  indirection_level = our_indirection_level;
-
-	  switch (code)
-	    {
-	      /* Some kind of throw to top_level has occurred. */
-	    case ERREXIT:
-	      if (exit_immediately_on_error)
-		reset_local_contexts ();	/* not in a function */
-	    case FORCE_EOF:
-	    case EXITPROG:
-	    case EXITBLTIN:
-	      current_command = (COMMAND *)NULL;
-	      EOF_Reached = EOF;
-	      goto exec_done;
-
-	    case DISCARD:
-	      /* Make sure the exit status is reset to a non-zero value, but
-		 leave existing non-zero values (e.g., > 128 on signal)
-		 alone. */
-	      if (last_command_exit_value == 0)
-		set_exit_status (EXECUTION_FAILURE);
-	      if (subshell_environment)
-		{
-		  current_command = (COMMAND *)NULL;
-		  EOF_Reached = EOF;
-		  goto exec_done;
-		}
-	      /* Obstack free command elements, etc. */
-	      if (current_command)
-		{
-		  dispose_command (current_command);
-		  current_command = (COMMAND *)NULL;
-		}
-
-	      restore_sigmask ();
-	      break;
-
-	    default:
-	      command_error ("reader_loop", CMDERR_BADJUMP, code, 0);
-	    }
-	}
-
-      executing = 0;
-      if (temporary_env)
-	dispose_used_env_vars ();
-
-#if (defined (ultrix) && defined (mips)) || defined (C_ALLOCA)
-      /* Attempt to reclaim memory allocated with alloca (). */
-      (void) alloca (0);
-#endif
-
-      if (read_command () == 0)
-	{
-	  if (interactive_shell == 0 && read_but_dont_execute)
-	    {
-	      set_exit_status (last_command_exit_value);
-	      dispose_command (global_command);
-	      global_command = (COMMAND *)NULL;
-	    }
-	  else if (current_command = global_command)
-	    {
-	      global_command = (COMMAND *)NULL;
-
-	      /* If the shell is interactive, expand and display $PS0 after reading a
-		 command (possibly a list or pipeline) and before executing it. */
-	      if (interactive && ps0_prompt)
-		{
-		  char *ps0_string;
-
-		  ps0_string = decode_prompt_string (ps0_prompt);
-		  if (ps0_string && *ps0_string)
-		    {
-		      fprintf (stderr, "%s", ps0_string);
-		      fflush (stderr);
-		    }
-		  free (ps0_string);
-		}
-
-	      current_command_number++;
-
-	      executing = 1;
-	      stdin_redir = 0;
-
-	      execute_command (current_command);
-
-	    exec_done:
-	      QUIT;
-
-	      if (current_command)
-		{
-		  dispose_command (current_command);
-		  current_command = (COMMAND *)NULL;
-		}
-	    }
-	}
-      else
-	{
-	  /* Parse error, maybe discard rest of stream if not interactive. */
-	  if (interactive == 0)
-	    EOF_Reached = EOF;
-	}
-      if (just_one_command)
-	EOF_Reached = EOF;
-    }
-  indirection_level--;
-  return (last_command_exit_value);
-}
-
-/* Pretty print shell scripts */
-int
-pretty_print_loop ()
-{
-  COMMAND *current_command;
-  char *command_to_print;
-  int code;
-  int global_posix_mode, last_was_newline;
-
-  global_posix_mode = posixly_correct;
-  last_was_newline = 0;
-  while (EOF_Reached == 0)
-    {
-      code = setjmp_nosigs (top_level);
-      if (code)
-        return (EXECUTION_FAILURE);
-      if (read_command() == 0)
-	{
-	  current_command = global_command;
-	  global_command = 0;
-	  posixly_correct = 1;			/* print posix-conformant */
-	  if (current_command && (command_to_print = make_command_string (current_command)))
-	    {
-	      printf ("%s\n", command_to_print);	/* for now */
-	      last_was_newline = 0;
-	    }
-	  else if (last_was_newline == 0)
-	    {
-	       printf ("\n");
-	       last_was_newline = 1;
-	    }
-	  posixly_correct = global_posix_mode;
-	  dispose_command (current_command);
-	}
-      else
-	return (EXECUTION_FAILURE);
-    }
-    
-  return (EXECUTION_SUCCESS);
-}
-
-static sighandler
-alrm_catcher(i)
-     int i;
-{
-  char *msg;
-
-  msg = _("\007timed out waiting for input: auto-logout\n");
-  write (1, msg, strlen (msg));
-
-  bash_logout ();	/* run ~/.bash_logout if this is a login shell */
-  jump_to_top_level (EXITPROG);
-  SIGRETURN (0);
-}
-
-/* Send an escape sequence to emacs term mode to tell it the
-   current working directory. */
-static void
-send_pwd_to_eterm ()
-{
-  char *pwd, *f;
-
-  f = 0;
-  pwd = get_string_value ("PWD");
-  if (pwd == 0)
-    f = pwd = get_working_directory ("eterm");
-  fprintf (stderr, "\032/%s\n", pwd);
-  free (f);
-}
-
-#if defined (ARRAY_VARS)
-/* Caller ensures that A has a non-zero number of elements */
-int
-execute_array_command (a, v)
-     ARRAY *a;
-     void *v;
-{
-  char *tag;
-  char **argv;
-  int argc, i;
-
-  tag = (char *)v;
-  argc = 0;
-  argv = array_to_argv (a, &argc);
-  for (i = 0; i < argc; i++)
-    {
-      if (argv[i] && argv[i][0])
-	execute_variable_command (argv[i], tag);
-    }
-  strvec_dispose (argv);
-  return 0;
-}
-#endif
-  
-static void
-execute_prompt_command ()
-{
-  char *command_to_execute;
-  SHELL_VAR *pcv;
-#if defined (ARRAY_VARS)
-  ARRAY *pcmds;
-#endif
-
-  pcv = find_variable ("PROMPT_COMMAND");
-  if (pcv  == 0 || var_isset (pcv) == 0 || invisible_p (pcv))
-    return;
-#if defined (ARRAY_VARS)
-  if (array_p (pcv))
-    {
-      if ((pcmds = array_cell (pcv)) && array_num_elements (pcmds) > 0)
-	execute_array_command (pcmds, "PROMPT_COMMAND");
-      return;
-    }
-  else if (assoc_p (pcv))
-    return;	/* currently don't allow associative arrays here */
-#endif
-
-  command_to_execute = value_cell (pcv);
-  if (command_to_execute && *command_to_execute)
-    execute_variable_command (command_to_execute, "PROMPT_COMMAND");
-}
-
-/* Call the YACC-generated parser and return the status of the parse.
-   Input is read from the current input stream (bash_input).  yyparse
-   leaves the parsed command in the global variable GLOBAL_COMMAND.
-   This is where PROMPT_COMMAND is executed. */
-int
-parse_command ()
-{
-  int r;
-
-  need_here_doc = 0;
-  run_pending_traps ();
-
-  /* Allow the execution of a random command just before the printing
-     of each primary prompt.  If the shell variable PROMPT_COMMAND
-     is set then its value (array or string) is the command(s) to execute. */
-  /* The tests are a combination of SHOULD_PROMPT() and prompt_again() 
-     from parse.y, which are the conditions under which the prompt is
-     actually printed. */
-  if (interactive && bash_input.type != st_string && parser_expanding_alias() == 0)
-    {
-#if defined (READLINE)
-      if (no_line_editing || (bash_input.type == st_stdin && parser_will_prompt ()))
-#endif
-        execute_prompt_command ();
-
-      if (running_under_emacs == 2)
-	send_pwd_to_eterm ();	/* Yuck */
-    }
-
-  current_command_line_count = 0;
-  r = yyparse ();
-
-  if (need_here_doc)
-    gather_here_documents ();
-
-  return (r);
-}
-
-/* Read and parse a command, returning the status of the parse.  The command
-   is left in the globval variable GLOBAL_COMMAND for use by reader_loop.
-   This is where the shell timeout code is executed. */
-int
-read_command ()
-{
-  SHELL_VAR *tmout_var;
-  int tmout_len, result;
-  SigHandler *old_alrm;
-
-  set_current_prompt_level (1);
-  global_command = (COMMAND *)NULL;
-
-  /* Only do timeouts if interactive. */
-  tmout_var = (SHELL_VAR *)NULL;
-  tmout_len = 0;
-  old_alrm = (SigHandler *)NULL;
-
-  if (interactive)
-    {
-      tmout_var = find_variable ("TMOUT");
-
-      if (tmout_var && var_isset (tmout_var))
-	{
-	  tmout_len = atoi (value_cell (tmout_var));
-	  if (tmout_len > 0)
-	    {
-	      old_alrm = set_signal_handler (SIGALRM, alrm_catcher);
-	      alarm (tmout_len);
-	    }
-	}
-    }
-
-  QUIT;
-
-  current_command_line_count = 0;
-  result = parse_command ();
-
-  if (interactive && tmout_var && (tmout_len > 0))
-    {
-      alarm(0);
-      set_signal_handler (SIGALRM, old_alrm);
-    }
-
-  return (result);
-}
diff --git a/third_party/bash/evalfile.c b/third_party/bash/evalfile.c
deleted file mode 100644
index 0479a0e62..000000000
--- a/third_party/bash/evalfile.c
+++ /dev/null
@@ -1,384 +0,0 @@
-/* evalfile.c - read and evaluate commands from a file or file descriptor */
-
-/* Copyright (C) 1996-2017 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashtypes.h"
-#include "posixstat.h"
-#include "filecntl.h"
-
-#include <stdio.h>
-#include <signal.h>
-#include <errno.h>
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "parser.h"
-#include "jobs.h"
-#include "builtins.h"
-#include "flags.h"
-#include "input.h"
-#include "execute_cmd.h"
-#include "trap.h"
-
-#include "y.tab.h"
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#endif
-
-#include "typemax.h"
-
-#include "common.h"
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-/* Flags for _evalfile() */
-#define FEVAL_ENOENTOK		0x001
-#define FEVAL_BUILTIN		0x002
-#define FEVAL_UNWINDPROT	0x004
-#define FEVAL_NONINT		0x008
-#define FEVAL_LONGJMP		0x010
-#define FEVAL_HISTORY		0x020
-#define FEVAL_CHECKBINARY	0x040
-#define FEVAL_REGFILE		0x080
-#define FEVAL_NOPUSHARGS	0x100
-
-/* How many `levels' of sourced files we have. */
-int sourcelevel = 0;
-
-static int
-_evalfile (filename, flags)
-     const char *filename;
-     int flags;
-{
-  volatile int old_interactive;
-  procenv_t old_return_catch;
-  int return_val, fd, result, pflags, i, nnull;
-  ssize_t nr;			/* return value from read(2) */
-  char *string;
-  struct stat finfo;
-  size_t file_size;
-  sh_vmsg_func_t *errfunc;
-#if defined (ARRAY_VARS)
-  SHELL_VAR *funcname_v, *bash_source_v, *bash_lineno_v;
-  ARRAY *funcname_a, *bash_source_a, *bash_lineno_a;
-  struct func_array_state *fa;
-#  if defined (DEBUGGER)
-  SHELL_VAR *bash_argv_v, *bash_argc_v;
-  ARRAY *bash_argv_a, *bash_argc_a;
-#  endif
-  char *t, tt[2];
-#endif
-
-  USE_VAR(pflags);
-
-#if defined (ARRAY_VARS)
-  GET_ARRAY_FROM_VAR ("FUNCNAME", funcname_v, funcname_a);
-  GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v, bash_source_a);
-  GET_ARRAY_FROM_VAR ("BASH_LINENO", bash_lineno_v, bash_lineno_a);
-#  if defined (DEBUGGER)
-  GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v, bash_argv_a);
-  GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v, bash_argc_a);
-#  endif
-#endif
-
-  fd = open (filename, O_RDONLY);
-
-  if (fd < 0 || (fstat (fd, &finfo) == -1))
-    {
-      i = errno;
-      if (fd >= 0)
-	close (fd);
-      errno = i;
-
-file_error_and_exit:
-      if (((flags & FEVAL_ENOENTOK) == 0) || errno != ENOENT)
-	file_error (filename);
-
-      if (flags & FEVAL_LONGJMP)
-	{
-	  last_command_exit_value = EXECUTION_FAILURE;
-	  jump_to_top_level (EXITPROG);
-	}
-
-      return ((flags & FEVAL_BUILTIN) ? EXECUTION_FAILURE
-      				      : ((errno == ENOENT && (flags & FEVAL_ENOENTOK) != 0) ? 0 : -1));
-    }
-
-  errfunc = ((flags & FEVAL_BUILTIN) ? builtin_error : internal_error);
-
-  if (S_ISDIR (finfo.st_mode))
-    {
-      (*errfunc) (_("%s: is a directory"), filename);
-      close (fd);
-      return ((flags & FEVAL_BUILTIN) ? EXECUTION_FAILURE : -1);
-    }
-  else if ((flags & FEVAL_REGFILE) && S_ISREG (finfo.st_mode) == 0)
-    {
-      (*errfunc) (_("%s: not a regular file"), filename);
-      close (fd);
-      return ((flags & FEVAL_BUILTIN) ? EXECUTION_FAILURE : -1);
-    }
-
-  file_size = (size_t)finfo.st_size;
-  /* Check for overflow with large files. */
-  if (file_size != finfo.st_size || file_size + 1 < file_size)
-    {
-      (*errfunc) (_("%s: file is too large"), filename);
-      close (fd);
-      return ((flags & FEVAL_BUILTIN) ? EXECUTION_FAILURE : -1);
-    }      
-
-  if (S_ISREG (finfo.st_mode) && file_size <= SSIZE_MAX)
-    {
-      string = (char *)xmalloc (1 + file_size);
-      nr = read (fd, string, file_size);
-      if (nr >= 0)
-	string[nr] = '\0';
-    }
-  else
-    nr = zmapfd (fd, &string, 0);
-
-  return_val = errno;
-  close (fd);
-  errno = return_val;
-
-  if (nr < 0)		/* XXX was != file_size, not < 0 */
-    {
-      free (string);
-      goto file_error_and_exit;
-    }
-
-  if (nr == 0)
-    {
-      free (string);
-      return ((flags & FEVAL_BUILTIN) ? EXECUTION_SUCCESS : 1);
-    }
-      
-  if ((flags & FEVAL_CHECKBINARY) && 
-      check_binary_file (string, (nr > 80) ? 80 : nr))
-    {
-      free (string);
-      (*errfunc) (_("%s: cannot execute binary file"), filename);
-      return ((flags & FEVAL_BUILTIN) ? EX_BINARY_FILE : -1);
-    }
-
-  i = strlen (string);
-  if (i < nr)
-    {
-      for (nnull = i = 0; i < nr; i++)
-	if (string[i] == '\0')
-          {
-	    memmove (string+i, string+i+1, nr - i);
-	    nr--;
-	    /* Even if the `check binary' flag is not set, we want to avoid
-	       sourcing files with more than 256 null characters -- that
-	       probably indicates a binary file. */
-	    if ((flags & FEVAL_BUILTIN) && ++nnull > 256)
-	      {
-		free (string);
-		(*errfunc) (_("%s: cannot execute binary file"), filename);
-		return ((flags & FEVAL_BUILTIN) ? EX_BINARY_FILE : -1);
-	      }
-          }
-    }
-
-  if (flags & FEVAL_UNWINDPROT)
-    {
-      begin_unwind_frame ("_evalfile");
-
-      unwind_protect_int (return_catch_flag);
-      unwind_protect_jmp_buf (return_catch);
-      if (flags & FEVAL_NONINT)
-	unwind_protect_int (interactive);
-      unwind_protect_int (sourcelevel);
-    }
-  else
-    {
-      COPY_PROCENV (return_catch, old_return_catch);
-      if (flags & FEVAL_NONINT)
-	old_interactive = interactive;
-    }
-
-  if (flags & FEVAL_NONINT)
-    interactive = 0;
-
-  return_catch_flag++;
-  sourcelevel++;
-
-#if defined (ARRAY_VARS)
-  array_push (bash_source_a, (char *)filename);
-  t = itos (executing_line_number ());
-  array_push (bash_lineno_a, t);
-  free (t);
-  array_push (funcname_a, "source");	/* not exactly right */
-
-  fa = (struct func_array_state *)xmalloc (sizeof (struct func_array_state));
-  fa->source_a = bash_source_a;
-  fa->source_v = bash_source_v;
-  fa->lineno_a = bash_lineno_a;
-  fa->lineno_v = bash_lineno_v;
-  fa->funcname_a = funcname_a;
-  fa->funcname_v = funcname_v;
-  if (flags & FEVAL_UNWINDPROT)
-    add_unwind_protect (restore_funcarray_state, fa);
-
-#  if defined (DEBUGGER)
-  /* Have to figure out a better way to do this when `source' is supplied
-     arguments */
-  if ((flags & FEVAL_NOPUSHARGS) == 0)
-    {
-      if (shell_compatibility_level <= 44)
-	init_bash_argv ();
-      array_push (bash_argv_a, (char *)filename);	/* XXX - unconditionally? */
-      tt[0] = '1'; tt[1] = '\0';
-      array_push (bash_argc_a, tt);
-      if (flags & FEVAL_UNWINDPROT)
-	add_unwind_protect (pop_args, 0);
-    }
-#  endif
-#endif
-
-  /* set the flags to be passed to parse_and_execute */
-  pflags = SEVAL_RESETLINE;
-  pflags |= (flags & FEVAL_HISTORY) ? 0 : SEVAL_NOHIST;
-
-  if (flags & FEVAL_BUILTIN)
-    result = EXECUTION_SUCCESS;
-
-  return_val = setjmp_nosigs (return_catch);
-
-  /* If `return' was seen outside of a function, but in the script, then
-     force parse_and_execute () to clean up. */
-  if (return_val)
-    {
-      parse_and_execute_cleanup (-1);
-      result = return_catch_value;
-    }
-  else
-    result = parse_and_execute (string, filename, pflags);
-
-  if (flags & FEVAL_UNWINDPROT)
-    run_unwind_frame ("_evalfile");
-  else
-    {
-      if (flags & FEVAL_NONINT)
-	interactive = old_interactive;
-#if defined (ARRAY_VARS)
-      restore_funcarray_state (fa);
-#  if defined (DEBUGGER)
-      if ((flags & FEVAL_NOPUSHARGS) == 0)
-	{
-	  /* Don't need to call pop_args here until we do something better
-	     when source is passed arguments (see above). */
-	  array_pop (bash_argc_a);
-	  array_pop (bash_argv_a);
-	}
-#  endif
-#endif
-      return_catch_flag--;
-      sourcelevel--;
-      COPY_PROCENV (old_return_catch, return_catch);
-    }
-
-  /* If we end up with EOF after sourcing a file, which can happen when the file
-     doesn't end with a newline, pretend that it did. */
-  if (current_token == yacc_EOF)
-    push_token ('\n');		/* XXX */
-
-  return ((flags & FEVAL_BUILTIN) ? result : 1);
-}
-
-int
-maybe_execute_file (fname, force_noninteractive)
-     const char *fname;
-     int force_noninteractive;
-{
-  char *filename;
-  int result, flags;
-
-  filename = bash_tilde_expand (fname, 0);
-  flags = FEVAL_ENOENTOK;
-  if (force_noninteractive)
-    flags |= FEVAL_NONINT;
-  result = _evalfile (filename, flags);
-  free (filename);
-  return result;
-}
-
-int
-force_execute_file (fname, force_noninteractive)
-     const char *fname;
-     int force_noninteractive;
-{
-  char *filename;
-  int result, flags;
-
-  filename = bash_tilde_expand (fname, 0);
-  flags = 0;
-  if (force_noninteractive)
-    flags |= FEVAL_NONINT;
-  result = _evalfile (filename, flags);
-  free (filename);
-  return result;
-}
-
-#if defined (HISTORY)
-int
-fc_execute_file (filename)
-     const char *filename;
-{
-  int flags;
-
-  /* We want these commands to show up in the history list if
-     remember_on_history is set.  We use FEVAL_BUILTIN to return
-     the result of parse_and_execute. */
-  flags = FEVAL_ENOENTOK|FEVAL_HISTORY|FEVAL_REGFILE|FEVAL_BUILTIN;
-  return (_evalfile (filename, flags));
-}
-#endif /* HISTORY */
-
-int
-source_file (filename, sflags)
-     const char *filename;
-     int sflags;
-{
-  int flags, rval;
-
-  flags = FEVAL_BUILTIN|FEVAL_UNWINDPROT|FEVAL_NONINT;
-  if (sflags)
-    flags |= FEVAL_NOPUSHARGS;
-  /* POSIX shells exit if non-interactive and file error. */
-  if (posixly_correct && interactive_shell == 0 && executing_command_builtin == 0)
-    flags |= FEVAL_LONGJMP;
-  rval = _evalfile (filename, flags);
-
-  run_return_trap ();
-  return rval;
-}
diff --git a/third_party/bash/evalstring.c b/third_party/bash/evalstring.c
deleted file mode 100644
index 046be3c7c..000000000
--- a/third_party/bash/evalstring.c
+++ /dev/null
@@ -1,818 +0,0 @@
-/* evalstring.c - evaluate a string as one or more shell commands. */
-
-/* Copyright (C) 1996-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include <signal.h>
-
-#include <errno.h>
-
-#include "filecntl.h"
-#include "bashansi.h"
-
-#include "shell.h"
-#include "jobs.h"
-#include "builtins.h"
-#include "flags.h"
-#include "parser.h"
-#include "input.h"
-#include "execute_cmd.h"
-#include "redir.h"
-#include "trap.h"
-#include "bashintl.h"
-
-#include "y.tab.h"
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#endif
-
-#include "common.h"
-#include "builtext.h"
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#define IS_BUILTIN(s)	(builtin_address_internal(s, 0) != (struct builtin *)NULL)
-
-int parse_and_execute_level = 0;
-
-static int cat_file PARAMS((REDIRECT *));
-
-#define PE_TAG "parse_and_execute top"
-#define PS_TAG "parse_string top"
-
-#if defined (HISTORY)
-static void
-set_history_remembering ()
-{
-  remember_on_history = enable_history_list;
-}
-#endif
-
-static void
-restore_lastcom (x)
-     char *x;
-{
-  FREE (the_printed_command_except_trap);
-  the_printed_command_except_trap = x;
-}
-
-int
-should_optimize_fork (command, subshell)
-     COMMAND *command;
-     int subshell;
-{
-  return (running_trap == 0 &&
-      command->type == cm_simple &&
-      signal_is_trapped (EXIT_TRAP) == 0 &&
-      signal_is_trapped (ERROR_TRAP) == 0 &&
-      any_signals_trapped () < 0 &&
-      (subshell || (command->redirects == 0 && command->value.Simple->redirects == 0)) &&
-      ((command->flags & CMD_TIME_PIPELINE) == 0) &&
-      ((command->flags & CMD_INVERT_RETURN) == 0));
-}
-
-/* This has extra tests to account for STARTUP_STATE == 2, which is for
-   -c command but has been extended to command and process substitution
-   (basically any time you call parse_and_execute in a subshell). */
-int
-should_suppress_fork (command)
-     COMMAND *command;
-{
-  int subshell;
-
-  subshell = subshell_environment & SUBSHELL_PROCSUB;	/* salt to taste */
-  return (startup_state == 2 && parse_and_execute_level == 1 &&
-	  *bash_input.location.string == '\0' &&
-	  parser_expanding_alias () == 0 &&
-	  should_optimize_fork (command, subshell));
-}
-
-int
-can_optimize_connection (command)
-     COMMAND *command;
-{
-  return (*bash_input.location.string == '\0' &&
-	  parser_expanding_alias () == 0 &&
-	  (command->value.Connection->connector == AND_AND || command->value.Connection->connector == OR_OR || command->value.Connection->connector == ';') &&
-	  command->value.Connection->second->type == cm_simple);
-}
-
-void
-optimize_connection_fork (command)
-     COMMAND *command;
-{
-  if (command->type == cm_connection &&
-      (command->value.Connection->connector == AND_AND || command->value.Connection->connector == OR_OR || command->value.Connection->connector == ';') &&
-      (command->value.Connection->second->flags & CMD_TRY_OPTIMIZING) &&
-      ((startup_state == 2 && should_suppress_fork (command->value.Connection->second)) ||
-       ((subshell_environment & SUBSHELL_PAREN) && should_optimize_fork (command->value.Connection->second, 0))))
-    {
-      command->value.Connection->second->flags |= CMD_NO_FORK;
-      command->value.Connection->second->value.Simple->flags |= CMD_NO_FORK;
-    }
-}
-
-void
-optimize_subshell_command (command)
-     COMMAND *command;
-{
-  if (should_optimize_fork (command, 0))
-    {
-      command->flags |= CMD_NO_FORK;
-      command->value.Simple->flags |= CMD_NO_FORK;
-    }
-  else if (command->type == cm_connection &&
-	   (command->value.Connection->connector == AND_AND || command->value.Connection->connector == OR_OR || command->value.Connection->connector == ';') &&
-	   command->value.Connection->second->type == cm_simple &&
-	   parser_expanding_alias () == 0)
-    {	   
-      command->value.Connection->second->flags |= CMD_TRY_OPTIMIZING;
-      command->value.Connection->second->value.Simple->flags |= CMD_TRY_OPTIMIZING;
-    }
-}
-
-void
-optimize_shell_function (command)
-     COMMAND *command;
-{
-  COMMAND *fc;
-
-  fc = (command->type == cm_group) ? command->value.Group->command : command;
-
-  if (fc->type == cm_simple && should_suppress_fork (fc))
-    {
-      fc->flags |= CMD_NO_FORK;
-      fc->value.Simple->flags |= CMD_NO_FORK;
-    }
-  else if (fc->type == cm_connection && can_optimize_connection (fc) && should_suppress_fork (fc->value.Connection->second))
-    {
-      fc->value.Connection->second->flags |= CMD_NO_FORK;
-      fc->value.Connection->second->value.Simple->flags |= CMD_NO_FORK;
-    }  
-}
-
-int
-can_optimize_cat_file (command)
-     COMMAND *command;
-{
-  return (command->type == cm_simple && !command->redirects &&
-	    (command->flags & CMD_TIME_PIPELINE) == 0 &&
-	    command->value.Simple->words == 0 &&
-	    command->value.Simple->redirects &&
-	    command->value.Simple->redirects->next == 0 &&
-	    command->value.Simple->redirects->instruction == r_input_direction &&
-	    command->value.Simple->redirects->redirector.dest == 0);
-}
-
-/* How to force parse_and_execute () to clean up after itself. */
-void
-parse_and_execute_cleanup (old_running_trap)
-     int old_running_trap;
-{
-  if (running_trap > 0)
-    {
-      /* We assume if we have a different value for running_trap than when
-	 we started (the only caller that cares is evalstring()), the
-	 original caller will perform the cleanup, and we should not step
-	 on them. */
-      if (running_trap != old_running_trap)
-	run_trap_cleanup (running_trap - 1);
-      unfreeze_jobs_list ();
-    }
-
-  if (have_unwind_protects ())
-     run_unwind_frame (PE_TAG);
-  else
-    parse_and_execute_level = 0;			/* XXX */
-}
-
-static void
-parse_prologue (string, flags, tag)
-     char *string;
-     int flags;
-     char *tag;
-{
-  char *orig_string, *lastcom;
-  int x;
-
-  orig_string = string;
-  /* Unwind protect this invocation of parse_and_execute (). */
-  begin_unwind_frame (tag);
-  unwind_protect_int (parse_and_execute_level);
-  unwind_protect_jmp_buf (top_level);
-  unwind_protect_int (indirection_level);
-  unwind_protect_int (line_number);
-  unwind_protect_int (line_number_for_err_trap);
-  unwind_protect_int (loop_level);
-  unwind_protect_int (executing_list);
-  unwind_protect_int (comsub_ignore_return);
-  if (flags & (SEVAL_NONINT|SEVAL_INTERACT))
-    unwind_protect_int (interactive);
-
-#if defined (HISTORY)
-  if (parse_and_execute_level == 0)
-    add_unwind_protect (set_history_remembering, (char *)NULL);
-  else
-    unwind_protect_int (remember_on_history);	/* can be used in scripts */
-#  if defined (BANG_HISTORY)
-  unwind_protect_int (history_expansion_inhibited);
-#  endif /* BANG_HISTORY */
-#endif /* HISTORY */
-
-  if (interactive_shell)
-    {
-      x = get_current_prompt_level ();
-      add_unwind_protect (set_current_prompt_level, x);
-    }
-
-  if (the_printed_command_except_trap)
-    {
-      lastcom = savestring (the_printed_command_except_trap);
-      add_unwind_protect (restore_lastcom, lastcom);
-    }
-
-  add_unwind_protect (pop_stream, (char *)NULL);
-  if (parser_expanding_alias ())
-    add_unwind_protect (parser_restore_alias, (char *)NULL);
-
-  if (orig_string && ((flags & SEVAL_NOFREE) == 0))
-    add_unwind_protect (xfree, orig_string);
-  end_unwind_frame ();
-
-  if (flags & (SEVAL_NONINT|SEVAL_INTERACT))
-    interactive = (flags & SEVAL_NONINT) ? 0 : 1;
-
-#if defined (HISTORY)
-  if (flags & SEVAL_NOHIST)
-    bash_history_disable ();
-#  if defined (BANG_HISTORY)
-  if (flags & SEVAL_NOHISTEXP)
-    history_expansion_inhibited = 1;
-#  endif /* BANG_HISTORY */
-#endif /* HISTORY */
-}
-
-/* Parse and execute the commands in STRING.  Returns whatever
-   execute_command () returns.  This frees STRING.  FLAGS is a
-   flags word; look in common.h for the possible values.  Actions
-   are:
-   	(flags & SEVAL_NONINT) -> interactive = 0;
-   	(flags & SEVAL_INTERACT) -> interactive = 1;
-   	(flags & SEVAL_NOHIST) -> call bash_history_disable ()
-   	(flags & SEVAL_NOFREE) -> don't free STRING when finished
-   	(flags & SEVAL_RESETLINE) -> reset line_number to 1
-   	(flags & SEVAL_NOHISTEXP) -> history_expansion_inhibited -> 1
-*/
-
-int
-parse_and_execute (string, from_file, flags)
-     char *string;
-     const char *from_file;
-     int flags;
-{
-  int code, lreset;
-  volatile int should_jump_to_top_level, last_result;
-  COMMAND *volatile command;
-  volatile sigset_t pe_sigmask;
-
-  parse_prologue (string, flags, PE_TAG);
-
-  parse_and_execute_level++;
-
-  lreset = flags & SEVAL_RESETLINE;
-
-#if defined (HAVE_POSIX_SIGNALS)
-  /* If we longjmp and are going to go on, use this to restore signal mask */
-  sigemptyset ((sigset_t *)&pe_sigmask);
-  sigprocmask (SIG_BLOCK, (sigset_t *)NULL, (sigset_t *)&pe_sigmask);
-#endif
-
-  /* Reset the line number if the caller wants us to.  If we don't reset the
-     line number, we have to subtract one, because we will add one just
-     before executing the next command (resetting the line number sets it to
-     0; the first line number is 1). */
-  push_stream (lreset);
-  if (parser_expanding_alias ())
-    /* push current shell_input_line */
-    parser_save_alias ();
-  
-  if (lreset == 0)
-    line_number--;
-    
-  indirection_level++;
-
-  code = should_jump_to_top_level = 0;
-  last_result = EXECUTION_SUCCESS;
-
-  /* We need to reset enough of the token state so we can start fresh. */
-  if (current_token == yacc_EOF)
-    current_token = '\n';		/* reset_parser() ? */
-
-  with_input_from_string (string, from_file);
-  clear_shell_input_line ();
-  while (*(bash_input.location.string) || parser_expanding_alias ())
-    {
-      command = (COMMAND *)NULL;
-
-      if (interrupt_state)
-	{
-	  last_result = EXECUTION_FAILURE;
-	  break;
-	}
-
-      /* Provide a location for functions which `longjmp (top_level)' to
-	 jump to.  This prevents errors in substitution from restarting
-	 the reader loop directly, for example. */
-      code = setjmp_nosigs (top_level);
-
-      if (code)
-	{
-	  should_jump_to_top_level = 0;
-	  switch (code)
-	    {
-	    case ERREXIT:
-	      /* variable_context -> 0 is what eval.c:reader_loop() does in
-		 these circumstances.  Don't bother with cleanup here because
-		 we don't want to run the function execution cleanup stuff
-		 that will cause pop_context and other functions to run.
-		 We call reset_local_contexts() instead, which just frees
-		 context memory.
-		 XXX - change that if we want the function context to be
-		 unwound. */
-	      if (exit_immediately_on_error && variable_context)
-	        {
-	          discard_unwind_frame ("pe_dispose");
-	          reset_local_contexts (); /* not in a function */
-	        }
-	      should_jump_to_top_level = 1;
-	      goto out;
-	    case FORCE_EOF:	      
-	    case EXITPROG:
-	      if (command)
-		run_unwind_frame ("pe_dispose");
-	      /* Remember to call longjmp (top_level) after the old
-		 value for it is restored. */
-	      should_jump_to_top_level = 1;
-	      goto out;
-
-	    case EXITBLTIN:
-	      if (command)
-		{
-		  if (variable_context && signal_is_trapped (0))
-		    {
-		      /* Let's make sure we run the exit trap in the function
-			 context, as we do when not running parse_and_execute.
-			 The pe_dispose unwind frame comes before any unwind-
-			 protects installed by the string we're evaluating, so
-			 it will undo the current function scope. */
-		      dispose_command (command);
-		      discard_unwind_frame ("pe_dispose");
-		    }
-		  else
-		    run_unwind_frame ("pe_dispose");
-		}
-	      should_jump_to_top_level = 1;
-	      goto out;
-
-	    case DISCARD:
-	      if (command)
-		run_unwind_frame ("pe_dispose");
-	      last_result = last_command_exit_value = EXECUTION_FAILURE; /* XXX */
-	      set_pipestatus_from_exit (last_command_exit_value);
-	      if (subshell_environment)
-		{
-		  should_jump_to_top_level = 1;
-		  goto out;
-		}
-	      else
-		{
-#if 0
-		  dispose_command (command);	/* pe_dispose does this */
-#endif
-#if defined (HAVE_POSIX_SIGNALS)
-		  sigprocmask (SIG_SETMASK, (sigset_t *)&pe_sigmask, (sigset_t *)NULL);
-#endif
-		  continue;
-		}
-
-	    default:
-	      command_error ("parse_and_execute", CMDERR_BADJUMP, code, 0);
-	      break;
-	    }
-	}
-
-      if (parse_command () == 0)
-	{
-	  if ((flags & SEVAL_PARSEONLY) || (interactive_shell == 0 && read_but_dont_execute))
-	    {
-	      last_result = EXECUTION_SUCCESS;
-	      dispose_command (global_command);
-	      global_command = (COMMAND *)NULL;
-	    }
-	  else if (command = global_command)
-	    {
-	      struct fd_bitmap *bitmap;
-
-	      if (flags & SEVAL_FUNCDEF)
-		{
-		  char *x;
-
-		  /* If the command parses to something other than a straight
-		     function definition, or if we have not consumed the entire
-		     string, or if the parser has transformed the function
-		     name (as parsing will if it begins or ends with shell
-		     whitespace, for example), reject the attempt */
-		  if (command->type != cm_function_def ||
-		      ((x = parser_remaining_input ()) && *x) ||
-		      (STREQ (from_file, command->value.Function_def->name->word) == 0))
-		    {
-		      internal_warning (_("%s: ignoring function definition attempt"), from_file);
-		      should_jump_to_top_level = 0;
-		      last_result = last_command_exit_value = EX_BADUSAGE;
-		      set_pipestatus_from_exit (last_command_exit_value);
-		      reset_parser ();
-		      break;
-		    }
-		}
-
-	      bitmap = new_fd_bitmap (FD_BITMAP_SIZE);
-	      begin_unwind_frame ("pe_dispose");
-	      add_unwind_protect (dispose_fd_bitmap, bitmap);
-	      add_unwind_protect (dispose_command, command);	/* XXX */
-
-	      global_command = (COMMAND *)NULL;
-
-	      if ((subshell_environment & SUBSHELL_COMSUB) && comsub_ignore_return)
-		command->flags |= CMD_IGNORE_RETURN;
-
-#if defined (ONESHOT)
-	      /*
-	       * IF
-	       *   we were invoked as `bash -c' (startup_state == 2) AND
-	       *   parse_and_execute has not been called recursively AND
-	       *   we're not running a trap AND
-	       *   we have parsed the full command (string == '\0') AND
-	       *   we're not going to run the exit trap AND
-	       *   we have a simple command without redirections AND
-	       *   the command is not being timed AND
-	       *   the command's return status is not being inverted AND
-	       *   there aren't any traps in effect
-	       * THEN
-	       *   tell the execution code that we don't need to fork
-	       */
-	      if (should_suppress_fork (command))
-		{
-		  command->flags |= CMD_NO_FORK;
-		  command->value.Simple->flags |= CMD_NO_FORK;
-		}
-
-	      /* Can't optimize forks out here execept for simple commands.
-		 This knows that the parser sets up commands as left-side heavy
-		 (&& and || are left-associative) and after the single parse,
-		 if we are at the end of the command string, the last in a
-		 series of connection commands is
-		 command->value.Connection->second. */
-	      else if (command->type == cm_connection && can_optimize_connection (command))
-		{
-		  command->value.Connection->second->flags |= CMD_TRY_OPTIMIZING;
-		  command->value.Connection->second->value.Simple->flags |= CMD_TRY_OPTIMIZING;
-		}
-#endif /* ONESHOT */
-
-	      /* See if this is a candidate for $( <file ). */
-	      if (startup_state == 2 &&
-		  (subshell_environment & SUBSHELL_COMSUB) &&
-		  *bash_input.location.string == '\0' &&
-		  can_optimize_cat_file (command))
-		{
-		  int r;
-		  r = cat_file (command->value.Simple->redirects);
-		  last_result = (r < 0) ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
-		}
-	      else
-		last_result = execute_command_internal
-				(command, 0, NO_PIPE, NO_PIPE, bitmap);
-	      dispose_command (command);
-	      dispose_fd_bitmap (bitmap);
-	      discard_unwind_frame ("pe_dispose");
-
-	      if (flags & SEVAL_ONECMD)
-		{
-		  reset_parser ();
-		  break;
-		}
-	    }
-	}
-      else
-	{
-	  last_result = EX_BADUSAGE;	/* was EXECUTION_FAILURE */
-
-	  if (interactive_shell == 0 && this_shell_builtin &&
-	      (this_shell_builtin == source_builtin || this_shell_builtin == eval_builtin) &&
-	      last_command_exit_value == EX_BADSYNTAX && posixly_correct && executing_command_builtin == 0)
-	    {
-	      should_jump_to_top_level = 1;
-	      code = ERREXIT;
-	      last_command_exit_value = EX_BADUSAGE;
-	    }
-
-	  /* Since we are shell compatible, syntax errors in a script
-	     abort the execution of the script.  Right? */
-	  break;
-	}
-    }
-
- out:
-
-  run_unwind_frame (PE_TAG);
-
-  if (interrupt_state && parse_and_execute_level == 0)
-    {
-      /* An interrupt during non-interactive execution in an
-	 interactive shell (e.g. via $PROMPT_COMMAND) should
-	 not cause the shell to exit. */
-      interactive = interactive_shell;
-      throw_to_top_level ();
-    }
-
-  CHECK_TERMSIG;
-
-  if (should_jump_to_top_level)
-    jump_to_top_level (code);
-
-  return (last_result);
-}
-
-/* Parse a command contained in STRING according to FLAGS and return the
-   number of characters consumed from the string.  If non-NULL, set *ENDP
-   to the position in the string where the parse ended.  Used to validate
-   command substitutions during parsing to obey Posix rules about finding
-   the end of the command and balancing parens. */
-int
-parse_string (string, from_file, flags, cmdp, endp)
-     char *string;
-     const char *from_file;
-     int flags;
-     COMMAND **cmdp;
-     char **endp;
-{
-  int code, nc;
-  volatile int should_jump_to_top_level;
-  COMMAND *volatile command, *oglobal;
-  char *ostring;
-  volatile sigset_t ps_sigmask;
-
-  parse_prologue (string, flags, PS_TAG);
-
-#if defined (HAVE_POSIX_SIGNALS)
-  /* If we longjmp and are going to go on, use this to restore signal mask */
-  sigemptyset ((sigset_t *)&ps_sigmask);
-  sigprocmask (SIG_BLOCK, (sigset_t *)NULL, (sigset_t *)&ps_sigmask);
-#endif
-
-  /* Reset the line number if the caller wants us to.  If we don't reset the
-     line number, we have to subtract one, because we will add one just
-     before executing the next command (resetting the line number sets it to
-     0; the first line number is 1). */
-  push_stream (0);
-  if (parser_expanding_alias ())
-    /* push current shell_input_line */
-    parser_save_alias ();
-
-  code = should_jump_to_top_level = 0;
-  oglobal = global_command;
-
-  with_input_from_string (string, from_file);
-  ostring = bash_input.location.string;
-  while (*(bash_input.location.string))		/* XXX - parser_expanding_alias () ? */
-    {
-      command = (COMMAND *)NULL;
-
-#if 0
-      if (interrupt_state)
-	break;
-#endif
-
-      /* Provide a location for functions which `longjmp (top_level)' to
-	 jump to. */
-      code = setjmp_nosigs (top_level);
-
-      if (code)
-	{
-	  INTERNAL_DEBUG(("parse_string: longjmp executed: code = %d", code));
-
-	  should_jump_to_top_level = 0;
-	  switch (code)
-	    {
-	    case FORCE_EOF:
-	    case ERREXIT:
-	    case EXITPROG:
-	    case EXITBLTIN:
-	    case DISCARD:		/* XXX */
-	      if (command)
-		dispose_command (command);
-	      /* Remember to call longjmp (top_level) after the old
-		 value for it is restored. */
-	      should_jump_to_top_level = 1;
-	      goto out;
-
-	    default:
-#if defined (HAVE_POSIX_SIGNALS)
-	      sigprocmask (SIG_SETMASK, (sigset_t *)&ps_sigmask, (sigset_t *)NULL);
-#endif
-	      command_error ("parse_string", CMDERR_BADJUMP, code, 0);
-	      break;
-	    }
-	}
-	  
-      if (parse_command () == 0)
-	{
-	  if (cmdp)
-	    *cmdp = global_command;
-	  else
-	    dispose_command (global_command);
-	  global_command = (COMMAND *)NULL;
-	}
-      else
-	{
-	  if ((flags & SEVAL_NOLONGJMP) == 0)
-	    {
-	      should_jump_to_top_level = 1;
-	      code = DISCARD;
-	    }
-	  else
-	    reset_parser ();	/* XXX - sets token_to_read */
-	  break;
-	}
-
-      if (current_token == yacc_EOF || current_token == shell_eof_token)
-	{
-	  if (current_token == shell_eof_token)
-	    rewind_input_string ();
-	  break;
-	}
-    }
-
-out:
-
-  global_command = oglobal;
-  nc = bash_input.location.string - ostring;
-  if (endp)
-    *endp = bash_input.location.string;
-
-  run_unwind_frame (PS_TAG);
-
-  /* If we return < 0, the caller (xparse_dolparen) will jump_to_top_level for
-     us, after doing cleanup */
-  if (should_jump_to_top_level)
-    {
-      if (parse_and_execute_level == 0)
-	top_level_cleanup ();
-      if (code == DISCARD)
-	return -DISCARD;
-      jump_to_top_level (code);
-    }
-
-  return (nc);
-}
-
-int
-open_redir_file (r, fnp)
-     REDIRECT *r;
-     char **fnp;
-{
-  char *fn;
-  int fd, rval;
-
-  if (r->instruction != r_input_direction)
-    return -1;
-
-  /* Get the filename. */
-  if (posixly_correct && !interactive_shell)
-    disallow_filename_globbing++;
-  fn = redirection_expand (r->redirectee.filename);
-  if (posixly_correct && !interactive_shell)
-    disallow_filename_globbing--;
-
-  if (fn == 0)
-    {
-      redirection_error (r, AMBIGUOUS_REDIRECT, fn);
-      return -1;
-    }
-
-  fd = open(fn, O_RDONLY);
-  if (fd < 0)
-    {
-      file_error (fn);
-      free (fn);
-      if (fnp)
-	*fnp = 0;
-      return -1;
-    }
-
-  if (fnp)
-    *fnp = fn;
-  return fd;
-}
-
-/* Handle a $( < file ) command substitution.  This expands the filename,
-   returning errors as appropriate, then just cats the file to the standard
-   output. */
-static int
-cat_file (r)
-     REDIRECT *r;
-{
-  char *fn;
-  int fd, rval;
-
-  fd = open_redir_file (r, &fn);
-  if (fd < 0)
-    return -1;
-
-  rval = zcatfd (fd, 1, fn);
-
-  free (fn);
-  close (fd);
-
-  return (rval);
-}
-
-int
-evalstring (string, from_file, flags)
-     char *string;
-     const char *from_file;
-     int flags;
-{
-  volatile int r, rflag, rcatch;
-  volatile int was_trap;
-
-  /* Are we running a trap when we execute this function? */
-  was_trap = running_trap;
-
-  rcatch = 0;
-  rflag = return_catch_flag;
-  /* If we are in a place where `return' is valid, we have to catch
-     `eval "... return"' and make sure parse_and_execute cleans up. Then
-     we can trampoline to the previous saved return_catch location. */
-  if (rflag)
-    {
-      begin_unwind_frame ("evalstring");
-
-      unwind_protect_int (return_catch_flag);
-      unwind_protect_jmp_buf (return_catch);
-
-      return_catch_flag++;	/* increment so we have a counter */
-      rcatch = setjmp_nosigs (return_catch);
-    }
-
-  if (rcatch)
-    {
-      /* We care about whether or not we are running the same trap we were
-	 when we entered this function. */
-      parse_and_execute_cleanup (was_trap);
-      r = return_catch_value;
-    }
-  else
-    /* Note that parse_and_execute () frees the string it is passed. */
-    r = parse_and_execute (string, from_file, flags);
-
-  if (rflag)
-    {
-      run_unwind_frame ("evalstring");
-      if (rcatch && return_catch_flag)
-	{
-	  return_catch_value = r;
-	  sh_longjmp (return_catch, 1);
-	}
-    }
-    
-  return (r);
-}
diff --git a/third_party/bash/execute_cmd.c b/third_party/bash/execute_cmd.c
deleted file mode 100644
index 665099968..000000000
--- a/third_party/bash/execute_cmd.c
+++ /dev/null
@@ -1,6229 +0,0 @@
-/* execute_cmd.c -- Execute a COMMAND structure. */
-
-/* Copyright (C) 1987-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
-  #pragma alloca
-#endif /* _AIX && RISC6000 && !__GNUC__ */
-
-#include <stdio.h>
-#include "chartypes.h"
-#include "bashtypes.h"
-#if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-#include "filecntl.h"
-#include "posixstat.h"
-#include <signal.h>
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "posixtime.h"
-
-#if defined (HAVE_SYS_RESOURCE_H) && !defined (RLIMTYPE)
-#  include <sys/resource.h>
-#endif
-
-#if defined (HAVE_SYS_TIMES_H) && defined (HAVE_TIMES)
-#  include <sys/times.h>
-#endif
-
-#include <errno.h>
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#define NEED_FPURGE_DECL
-#define NEED_SH_SETLINEBUF_DECL
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "memalloc.h"
-#include "shell.h"
-#include "y.tab.h"	/* use <...> so we pick it up from the build directory */
-#include "parser.h"
-#include "flags.h"
-#include "builtins.h"
-#include "hashlib.h"
-#include "jobs.h"
-#include "execute_cmd.h"
-#include "findcmd.h"
-#include "redir.h"
-#include "trap.h"
-#include "pathexp.h"
-#include "hashcmd.h"
-
-#if defined (COND_COMMAND)
-#  include "test.h"
-#endif
-
-#include "common.h"
-#include "builtext.h"	/* list of builtins */
-
-#include "getopt.h"
-
-#include "strmatch.h"
-#include "tilde.h"
-
-#if defined (BUFFERED_INPUT)
-#  include "input.h"
-#endif
-
-#if defined (ALIAS)
-#  include "alias.h"
-#endif
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#endif
-
-#if defined (HAVE_MBSTR_H) && defined (HAVE_MBSCHR)
-#  include <mbstr.h>		/* mbschr */
-#endif
-
-extern int command_string_index;
-extern char *the_printed_command;
-extern time_t shell_start_time;
-#if defined (HAVE_GETTIMEOFDAY)
-extern struct timeval shellstart;
-#endif
-#if 0
-extern char *glob_argv_flags;
-#endif
-
-extern int close PARAMS((int));
-
-/* Static functions defined and used in this file. */
-static void close_pipes PARAMS((int, int));
-static void do_piping PARAMS((int, int));
-static void bind_lastarg PARAMS((char *));
-static int shell_control_structure PARAMS((enum command_type));
-static void cleanup_redirects PARAMS((REDIRECT *));
-
-#if defined (JOB_CONTROL)
-static int restore_signal_mask PARAMS((sigset_t *));
-#endif
-
-static int builtin_status PARAMS((int));
-
-static int execute_for_command PARAMS((FOR_COM *));
-#if defined (SELECT_COMMAND)
-static int displen PARAMS((const char *));
-static int print_index_and_element PARAMS((int, int, WORD_LIST *));
-static void indent PARAMS((int, int));
-static void print_select_list PARAMS((WORD_LIST *, int, int, int));
-static char *select_query PARAMS((WORD_LIST *, int, char *, int));
-static int execute_select_command PARAMS((SELECT_COM *));
-#endif
-#if defined (DPAREN_ARITHMETIC)
-static int execute_arith_command PARAMS((ARITH_COM *));
-#endif
-#if defined (COND_COMMAND)
-static int execute_cond_node PARAMS((COND_COM *));
-static int execute_cond_command PARAMS((COND_COM *));
-#endif
-#if defined (COMMAND_TIMING)
-static int mkfmt PARAMS((char *, int, int, time_t, int));
-static void print_formatted_time PARAMS((FILE *, char *,
-				      time_t, int, time_t, int,
-				      time_t, int, int));
-static int time_command PARAMS((COMMAND *, int, int, int, struct fd_bitmap *));
-#endif
-#if defined (ARITH_FOR_COMMAND)
-static intmax_t eval_arith_for_expr PARAMS((WORD_LIST *, int *));
-static int execute_arith_for_command PARAMS((ARITH_FOR_COM *));
-#endif
-static int execute_case_command PARAMS((CASE_COM *));
-static int execute_while_command PARAMS((WHILE_COM *));
-static int execute_until_command PARAMS((WHILE_COM *));
-static int execute_while_or_until PARAMS((WHILE_COM *, int));
-static int execute_if_command PARAMS((IF_COM *));
-static int execute_null_command PARAMS((REDIRECT *, int, int, int));
-static void fix_assignment_words PARAMS((WORD_LIST *));
-static void fix_arrayref_words PARAMS((WORD_LIST *));
-static int execute_simple_command PARAMS((SIMPLE_COM *, int, int, int, struct fd_bitmap *));
-static int execute_builtin PARAMS((sh_builtin_func_t *, WORD_LIST *, int, int));
-static int execute_function PARAMS((SHELL_VAR *, WORD_LIST *, int, struct fd_bitmap *, int, int));
-static int execute_builtin_or_function PARAMS((WORD_LIST *, sh_builtin_func_t *,
-					    SHELL_VAR *,
-					    REDIRECT *, struct fd_bitmap *, int));
-static void execute_subshell_builtin_or_function PARAMS((WORD_LIST *, REDIRECT *,
-						      sh_builtin_func_t *,
-						      SHELL_VAR *,
-						      int, int, int,
-						      struct fd_bitmap *,
-						      int));
-static int execute_disk_command PARAMS((WORD_LIST *, REDIRECT *, char *,
-				      int, int, int, struct fd_bitmap *, int));
-
-static char *getinterp PARAMS((char *, int, int *));
-static void initialize_subshell PARAMS((void));
-static int execute_in_subshell PARAMS((COMMAND *, int, int, int, struct fd_bitmap *));
-#if defined (COPROCESS_SUPPORT)
-static void coproc_setstatus PARAMS((struct coproc *, int));
-static int execute_coproc PARAMS((COMMAND *, int, int, struct fd_bitmap *));
-#endif
-
-static int execute_pipeline PARAMS((COMMAND *, int, int, int, struct fd_bitmap *));
-
-static int execute_connection PARAMS((COMMAND *, int, int, int, struct fd_bitmap *));
-
-static int execute_intern_function PARAMS((WORD_DESC *, FUNCTION_DEF *));
-
-/* Set to 1 if fd 0 was the subject of redirection to a subshell.  Global
-   so that reader_loop can set it to zero before executing a command. */
-int stdin_redir;
-
-/* The name of the command that is currently being executed.
-   `test' needs this, for example. */
-char *this_command_name;
-
-/* The printed representation of the currently-executing command (same as
-   the_printed_command), except when a trap is being executed.  Useful for
-   a debugger to know where exactly the program is currently executing. */
-char *the_printed_command_except_trap;
-
-/* For catching RETURN in a function. */
-int return_catch_flag;
-int return_catch_value;
-procenv_t return_catch;
-
-/* The value returned by the last synchronous command. */
-volatile int last_command_exit_value;
-
-/* Whether or not the last command (corresponding to last_command_exit_value)
-   was terminated by a signal, and, if so, which one. */
-int last_command_exit_signal;
-
-/* Are we currently ignoring the -e option for the duration of a builtin's
-   execution? */
-int builtin_ignoring_errexit = 0;
-
-/* The list of redirections to perform which will undo the redirections
-   that I made in the shell. */
-REDIRECT *redirection_undo_list = (REDIRECT *)NULL;
-
-/* The list of redirections to perform which will undo the internal
-   redirections performed by the `exec' builtin.  These are redirections
-   that must be undone even when exec discards redirection_undo_list. */
-REDIRECT *exec_redirection_undo_list = (REDIRECT *)NULL;
-
-/* When greater than zero, value is the `level' of builtins we are
-   currently executing (e.g. `eval echo a' would have it set to 2). */
-int executing_builtin = 0;
-
-/* Non-zero if we are executing a command list (a;b;c, etc.) */
-int executing_list = 0;
-
-/* Non-zero if failing commands in a command substitution should not exit the
-   shell even if -e is set.  Used to pass the CMD_IGNORE_RETURN flag down to
-   commands run in command substitutions by parse_and_execute. */
-int comsub_ignore_return = 0;
-
-/* Non-zero if we have just forked and are currently running in a subshell
-   environment. */
-int subshell_environment;
-
-/* Count of nested subshells, like SHLVL.  Available via $BASH_SUBSHELL */
-int subshell_level = 0;
-
-/* Currently-executing shell function. */
-SHELL_VAR *this_shell_function;
-
-/* If non-zero, matches in case and [[ ... ]] are case-insensitive */
-int match_ignore_case = 0;
-
-int executing_command_builtin = 0;
-
-struct stat SB;		/* used for debugging */
-
-static int special_builtin_failed;
-
-static COMMAND *currently_executing_command;
-
-/* The line number that the currently executing function starts on. */
-static int function_line_number;
-
-/* XXX - set to 1 if we're running the DEBUG trap and we want to show the line
-   number containing the function name.  Used by executing_line_number to
-   report the correct line number.  Kind of a hack. */
-static int showing_function_line;
-
-static int connection_count;
-
-/* $LINENO ($BASH_LINENO) for use by an ERR trap.  Global so parse_and_execute
-   can save and restore it. */
-int line_number_for_err_trap;
-
-/* A convenience macro to avoid resetting line_number_for_err_trap while
-   running the ERR trap. */
-#define SET_LINE_NUMBER(v) \
-do { \
-  line_number = v; \
-  if (signal_in_progress (ERROR_TRAP) == 0 && running_trap != (ERROR_TRAP + 1)) \
-    line_number_for_err_trap = line_number; \
-} while (0)
-
-/* This can't be in executing_line_number() because that's used for LINENO
-   and we want LINENO to reflect the line number of commands run during
-   the ERR trap. Right now this is only used to push to BASH_LINENO. */
-#define GET_LINE_NUMBER() \
-  (signal_in_progress (ERROR_TRAP) && running_trap == ERROR_TRAP+1) \
-    ? line_number_for_err_trap \
-    : executing_line_number ()
-
-/* A sort of function nesting level counter */
-int funcnest = 0;
-int funcnest_max = 0;
-
-int evalnest = 0;
-int evalnest_max = EVALNEST_MAX;
-
-int sourcenest = 0;
-int sourcenest_max = SOURCENEST_MAX;
-
-volatile int from_return_trap = 0;
-
-int lastpipe_opt = 0;
-
-struct fd_bitmap *current_fds_to_close = (struct fd_bitmap *)NULL;
-
-#define FD_BITMAP_DEFAULT_SIZE 32
-
-/* Functions to allocate and deallocate the structures used to pass
-   information from the shell to its children about file descriptors
-   to close. */
-struct fd_bitmap *
-new_fd_bitmap (size)
-     int size;
-{
-  struct fd_bitmap *ret;
-
-  ret = (struct fd_bitmap *)xmalloc (sizeof (struct fd_bitmap));
-
-  ret->size = size;
-
-  if (size)
-    {
-      ret->bitmap = (char *)xmalloc (size);
-      memset (ret->bitmap, '\0', size);
-    }
-  else
-    ret->bitmap = (char *)NULL;
-  return (ret);
-}
-
-void
-dispose_fd_bitmap (fdbp)
-     struct fd_bitmap *fdbp;
-{
-  FREE (fdbp->bitmap);
-  free (fdbp);
-}
-
-void
-close_fd_bitmap (fdbp)
-     struct fd_bitmap *fdbp;
-{
-  register int i;
-
-  if (fdbp)
-    {
-      for (i = 0; i < fdbp->size; i++)
-	if (fdbp->bitmap[i])
-	  {
-	    close (i);
-	    fdbp->bitmap[i] = 0;
-	  }
-    }
-}
-
-/* Return the line number of the currently executing command. */
-int
-executing_line_number ()
-{
-  if (executing && showing_function_line == 0 &&
-      (variable_context == 0 || interactive_shell == 0) &&
-      currently_executing_command)
-    {
-#if defined (COND_COMMAND)
-      if (currently_executing_command->type == cm_cond)
-	return currently_executing_command->value.Cond->line;
-#endif
-#if defined (DPAREN_ARITHMETIC)
-      if (currently_executing_command->type == cm_arith)
-	return currently_executing_command->value.Arith->line;
-#endif
-#if defined (ARITH_FOR_COMMAND)
-      if (currently_executing_command->type == cm_arith_for)
-	return currently_executing_command->value.ArithFor->line;
-#endif
-
-      return line_number;
-    }
-  else
-    return line_number;
-}
-
-/* Execute the command passed in COMMAND.  COMMAND is exactly what
-   read_command () places into GLOBAL_COMMAND.  See "command.h" for the
-   details of the command structure.
-
-   EXECUTION_SUCCESS or EXECUTION_FAILURE are the only possible
-   return values.  Executing a command with nothing in it returns
-   EXECUTION_SUCCESS. */
-int
-execute_command (command)
-     COMMAND *command;
-{
-  struct fd_bitmap *bitmap;
-  int result;
-
-  current_fds_to_close = (struct fd_bitmap *)NULL;
-  bitmap = new_fd_bitmap (FD_BITMAP_DEFAULT_SIZE);
-  begin_unwind_frame ("execute-command");
-  add_unwind_protect (dispose_fd_bitmap, (char *)bitmap);
-
-  /* Just do the command, but not asynchronously. */
-  result = execute_command_internal (command, 0, NO_PIPE, NO_PIPE, bitmap);
-
-  dispose_fd_bitmap (bitmap);
-  discard_unwind_frame ("execute-command");
-
-#if defined (PROCESS_SUBSTITUTION)
-  /* don't unlink fifos if we're in a shell function; wait until the function
-     returns. */
-  if (variable_context == 0 && executing_list == 0)
-    unlink_fifo_list ();
-#endif /* PROCESS_SUBSTITUTION */
-
-  QUIT;
-  return (result);
-}
-
-/* Return 1 if TYPE is a shell control structure type. */
-static int
-shell_control_structure (type)
-     enum command_type type;
-{
-  switch (type)
-    {
-#if defined (ARITH_FOR_COMMAND)
-    case cm_arith_for:
-#endif
-#if defined (SELECT_COMMAND)
-    case cm_select:
-#endif
-#if defined (DPAREN_ARITHMETIC)
-    case cm_arith:
-#endif
-#if defined (COND_COMMAND)
-    case cm_cond:
-#endif
-    case cm_case:
-    case cm_while:
-    case cm_until:
-    case cm_if:
-    case cm_for:
-    case cm_group:
-    case cm_function_def:
-      return (1);
-
-    default:
-      return (0);
-    }
-}
-
-/* A function to use to unwind_protect the redirection undo list
-   for loops. */
-static void
-cleanup_redirects (list)
-     REDIRECT *list;
-{
-  do_redirections (list, RX_ACTIVE);
-  dispose_redirects (list);
-}
-
-void
-undo_partial_redirects ()
-{
-  if (redirection_undo_list)
-    {
-      cleanup_redirects (redirection_undo_list);
-      redirection_undo_list = (REDIRECT *)NULL;
-    }
-}
-
-#if 0
-/* Function to unwind_protect the redirections for functions and builtins. */
-static void
-cleanup_func_redirects (list)
-     REDIRECT *list;
-{
-  do_redirections (list, RX_ACTIVE);
-}
-#endif
-
-void
-dispose_exec_redirects ()
-{
-  if (exec_redirection_undo_list)
-    {
-      dispose_redirects (exec_redirection_undo_list);
-      exec_redirection_undo_list = (REDIRECT *)NULL;
-    }
-}
-
-void
-dispose_partial_redirects ()
-{
-  if (redirection_undo_list)
-    {
-      dispose_redirects (redirection_undo_list);
-      redirection_undo_list = (REDIRECT *)NULL;
-    }
-}
-
-#if defined (JOB_CONTROL)
-/* A function to restore the signal mask to its proper value when the shell
-   is interrupted or errors occur while creating a pipeline. */
-static int
-restore_signal_mask (set)
-     sigset_t *set;
-{
-  return (sigprocmask (SIG_SETMASK, set, (sigset_t *)NULL));
-}
-#endif /* JOB_CONTROL */
-
-#ifdef DEBUG
-/* A debugging function that can be called from gdb, for instance. */
-void
-open_files (void)
-{
-  register int i;
-  int f, fd_table_size;
-
-  fd_table_size = getdtablesize ();
-
-  fprintf (stderr, "pid %ld open files:", (long)getpid ());
-  for (i = 3; i < fd_table_size; i++)
-    {
-      if ((f = fcntl (i, F_GETFD, 0)) != -1)
-	fprintf (stderr, " %d (%s)", i, f ? "close" : "open");
-    }
-  fprintf (stderr, "\n");
-}
-#endif
-
-void
-async_redirect_stdin ()
-{
-  int fd;
-
-  fd = open ("/dev/null", O_RDONLY);
-  if (fd > 0)
-    {
-      dup2 (fd, 0);
-      close (fd);
-    }
-  else if (fd < 0)
-    internal_error (_("cannot redirect standard input from /dev/null: %s"), strerror (errno));
-}
-
-#define DESCRIBE_PID(pid) do { if (interactive) describe_pid (pid); } while (0)
-
-/* Execute the command passed in COMMAND, perhaps doing it asynchronously.
-   COMMAND is exactly what read_command () places into GLOBAL_COMMAND.
-   ASYNCHRONOUS, if non-zero, says to do this command in the background.
-   PIPE_IN and PIPE_OUT are file descriptors saying where input comes
-   from and where it goes.  They can have the value of NO_PIPE, which means
-   I/O is stdin/stdout.
-   FDS_TO_CLOSE is a list of file descriptors to close once the child has
-   been forked.  This list often contains the unusable sides of pipes, etc.
-
-   EXECUTION_SUCCESS or EXECUTION_FAILURE are the only possible
-   return values.  Executing a command with nothing in it returns
-   EXECUTION_SUCCESS. */
-int
-execute_command_internal (command, asynchronous, pipe_in, pipe_out,
-			  fds_to_close)
-     COMMAND *command;
-     int asynchronous;
-     int pipe_in, pipe_out;
-     struct fd_bitmap *fds_to_close;
-{
-  int exec_result, user_subshell, invert, ignore_return, was_error_trap, fork_flags;
-  REDIRECT *my_undo_list, *exec_undo_list;
-  char *tcmd;
-  volatile int save_line_number;
-#if defined (PROCESS_SUBSTITUTION)
-  volatile int ofifo, nfifo, osize, saved_fifo;
-  volatile void *ofifo_list;
-#endif
-
-  if (breaking || continuing)
-    return (last_command_exit_value);
-  if (read_but_dont_execute)
-    return (last_command_exit_value);
-  if (command == 0)
-    return (EXECUTION_SUCCESS);
-
-  QUIT;
-  run_pending_traps ();
-
-#if 0
-  if (running_trap == 0)
-#endif
-    currently_executing_command = command;
-
-  invert = (command->flags & CMD_INVERT_RETURN) != 0;
-
-  /* If we're inverting the return value and `set -e' has been executed,
-     we don't want a failing command to inadvertently cause the shell
-     to exit. */
-  if (exit_immediately_on_error && invert)	/* XXX */
-    command->flags |= CMD_IGNORE_RETURN;	/* XXX */
-
-  exec_result = EXECUTION_SUCCESS;
-
-  /* If a command was being explicitly run in a subshell, or if it is
-     a shell control-structure, and it has a pipe, then we do the command
-     in a subshell. */
-  if (command->type == cm_subshell && (command->flags & CMD_NO_FORK))
-    return (execute_in_subshell (command, asynchronous, pipe_in, pipe_out, fds_to_close));
-
-#if defined (COPROCESS_SUPPORT)
-  if (command->type == cm_coproc)
-    return (last_command_exit_value = execute_coproc (command, pipe_in, pipe_out, fds_to_close));
-#endif
-
-  user_subshell = command->type == cm_subshell || ((command->flags & CMD_WANT_SUBSHELL) != 0);
-
-#if defined (TIME_BEFORE_SUBSHELL)
-  if ((command->flags & CMD_TIME_PIPELINE) && user_subshell && asynchronous == 0)
-    {
-      command->flags |= CMD_FORCE_SUBSHELL;
-      exec_result = time_command (command, asynchronous, pipe_in, pipe_out, fds_to_close);
-      currently_executing_command = (COMMAND *)NULL;
-      return (exec_result);
-    }
-#endif
-
-  if (command->type == cm_subshell ||
-      (command->flags & (CMD_WANT_SUBSHELL|CMD_FORCE_SUBSHELL)) ||
-      (shell_control_structure (command->type) &&
-       (pipe_out != NO_PIPE || pipe_in != NO_PIPE || asynchronous)))
-    {
-      pid_t paren_pid;
-      int s;
-      char *p;
-
-      /* Fork a subshell, turn off the subshell bit, turn off job
-	 control and call execute_command () on the command again. */
-      save_line_number = line_number;
-      if (command->type == cm_subshell)
-	SET_LINE_NUMBER (command->value.Subshell->line);	/* XXX - save value? */
-	/* Otherwise we defer setting line_number */
-      tcmd = make_command_string (command);
-      fork_flags = asynchronous ? FORK_ASYNC : 0;
-      paren_pid = make_child (p = savestring (tcmd), fork_flags);
-
-      if (user_subshell && signal_is_trapped (ERROR_TRAP) && 
-	  signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
-	{
-	  FREE (the_printed_command_except_trap);
-	  the_printed_command_except_trap = savestring (the_printed_command);
-	}
-
-      if (paren_pid == 0)
-        {
-#if defined (JOB_CONTROL)
-	  FREE (p);		/* child doesn't use pointer */
-#endif
-	  /* We want to run the exit trap for forced {} subshells, and we
-	     want to note this before execute_in_subshell modifies the
-	     COMMAND struct.  Need to keep in mind that execute_in_subshell
-	     runs the exit trap for () subshells itself. */
-	  /* This handles { command; } & */
-	  s = user_subshell == 0 && command->type == cm_group && pipe_in == NO_PIPE && pipe_out == NO_PIPE && asynchronous;
-	  /* run exit trap for : | { ...; } and { ...; } | : */
-	  /* run exit trap for : | ( ...; ) and ( ...; ) | : */
-	  s += user_subshell == 0 && command->type == cm_group && (pipe_in != NO_PIPE || pipe_out != NO_PIPE) && asynchronous == 0;
-
-	  last_command_exit_value = execute_in_subshell (command, asynchronous, pipe_in, pipe_out, fds_to_close);
-	  if (s)
-	    subshell_exit (last_command_exit_value);
-	  else
-	    sh_exit (last_command_exit_value);
-	  /* NOTREACHED */
-        }
-      else
-	{
-	  close_pipes (pipe_in, pipe_out);
-
-#if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
-	  if (variable_context == 0)	/* wait until shell function completes */
-	    unlink_fifo_list ();
-#endif
-	  /* If we are part of a pipeline, and not the end of the pipeline,
-	     then we should simply return and let the last command in the
-	     pipe be waited for.  If we are not in a pipeline, or are the
-	     last command in the pipeline, then we wait for the subshell
-	     and return its exit status as usual. */
-	  if (pipe_out != NO_PIPE)
-	    return (EXECUTION_SUCCESS);
-
-	  stop_pipeline (asynchronous, (COMMAND *)NULL);
-
-	  line_number = save_line_number;
-
-	  if (asynchronous == 0)
-	    {
-	      was_error_trap = signal_is_trapped (ERROR_TRAP) && signal_is_ignored (ERROR_TRAP) == 0;
-	      invert = (command->flags & CMD_INVERT_RETURN) != 0;
-	      ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
-
-	      exec_result = wait_for (paren_pid, 0);
-
-	      /* If we have to, invert the return value. */
-	      if (invert)
-		exec_result = ((exec_result == EXECUTION_SUCCESS)
-				? EXECUTION_FAILURE
-				: EXECUTION_SUCCESS);
-
-	      last_command_exit_value = exec_result;
-	      if (user_subshell && was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
-		{
-		  save_line_number = line_number;
-		  line_number = line_number_for_err_trap;
-		  run_error_trap ();
-		  line_number = save_line_number;
-		}
-
-	      if (user_subshell && ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
-		{
-		  run_pending_traps ();
-		  jump_to_top_level (ERREXIT);
-		}
-
-	      return (last_command_exit_value);
-	    }
-	  else
-	    {
-	      DESCRIBE_PID (paren_pid);
-
-	      run_pending_traps ();
-
-	      /* Posix 2013 2.9.3.1: "the exit status of an asynchronous list
-		 shall be zero." */
-	      last_command_exit_value = 0;
-	      return (EXECUTION_SUCCESS);
-	    }
-	}
-    }
-
-#if defined (COMMAND_TIMING)
-  if (command->flags & CMD_TIME_PIPELINE)
-    {
-      if (asynchronous)
-	{
-	  command->flags |= CMD_FORCE_SUBSHELL;
-	  exec_result = execute_command_internal (command, 1, pipe_in, pipe_out, fds_to_close);
-	}
-      else
-	{
-	  exec_result = time_command (command, asynchronous, pipe_in, pipe_out, fds_to_close);
-#if 0
-	  if (running_trap == 0)
-#endif
-	    currently_executing_command = (COMMAND *)NULL;
-	}
-      return (exec_result);
-    }
-#endif /* COMMAND_TIMING */
-
-  if (shell_control_structure (command->type) && command->redirects)
-    stdin_redir = stdin_redirects (command->redirects);
-
-#if defined (PROCESS_SUBSTITUTION)
-#  if !defined (HAVE_DEV_FD)
-  reap_procsubs ();
-#  endif
-
-  /* XXX - also if sourcelevel != 0? */
-  if (variable_context != 0 || executing_list)
-    {
-      ofifo = num_fifos ();
-      ofifo_list = copy_fifo_list ((int *)&osize);
-      begin_unwind_frame ("internal_fifos");
-      if (ofifo_list)
-	add_unwind_protect (xfree, ofifo_list);
-      saved_fifo = 1;
-    }
-  else
-    saved_fifo = 0;
-#endif
-
-  /* Handle WHILE FOR CASE etc. with redirections.  (Also '&' input
-     redirection.)  */
-  was_error_trap = signal_is_trapped (ERROR_TRAP) && signal_is_ignored (ERROR_TRAP) == 0;
-  ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
-
-  if (do_redirections (command->redirects, RX_ACTIVE|RX_UNDOABLE) != 0)
-    {
-      undo_partial_redirects ();
-      dispose_exec_redirects ();
-#if defined (PROCESS_SUBSTITUTION)
-      if (saved_fifo)
-	{
-	  free ((void *)ofifo_list);
-          discard_unwind_frame ("internal_fifos");
-	}
-#endif
-
-      /* Handle redirection error as command failure if errexit set. */
-      last_command_exit_value = EXECUTION_FAILURE;
-      if (ignore_return == 0 && invert == 0 && pipe_in == NO_PIPE && pipe_out == NO_PIPE)
-	{
-	  if (was_error_trap)
-	    {
-	      save_line_number = line_number;
-	      line_number = line_number_for_err_trap;
-	      run_error_trap ();
-	      line_number = save_line_number;
-	    }
-	  if (exit_immediately_on_error)
-	    {	  
-	      run_pending_traps ();
-	      jump_to_top_level (ERREXIT);
-	    }
-	}
-      return (last_command_exit_value);
-    }
-
-  my_undo_list = redirection_undo_list;
-  redirection_undo_list = (REDIRECT *)NULL;
-
-  exec_undo_list = exec_redirection_undo_list;
-  exec_redirection_undo_list = (REDIRECT *)NULL;
-
-  if (my_undo_list || exec_undo_list)
-    begin_unwind_frame ("loop_redirections");
-
-  if (my_undo_list)
-    add_unwind_protect ((Function *)cleanup_redirects, my_undo_list);
-
-  if (exec_undo_list)
-    add_unwind_protect ((Function *)dispose_redirects, exec_undo_list);
-
-  QUIT;
-
-  switch (command->type)
-    {
-    case cm_simple:
-      {
-	save_line_number = line_number;
-	/* We can't rely on variables retaining their values across a
-	   call to execute_simple_command if a longjmp occurs as the
-	   result of a `return' builtin.  This is true for sure with gcc. */
-#if defined (RECYCLES_PIDS)
-	last_made_pid = NO_PID;
-#endif
-	was_error_trap = signal_is_trapped (ERROR_TRAP) && signal_is_ignored (ERROR_TRAP) == 0;
-
-	if (ignore_return && command->value.Simple)
-	  command->value.Simple->flags |= CMD_IGNORE_RETURN;
-	if (command->flags & CMD_STDIN_REDIR)
-	  command->value.Simple->flags |= CMD_STDIN_REDIR;
-
-	SET_LINE_NUMBER (command->value.Simple->line);
-	exec_result =
-	  execute_simple_command (command->value.Simple, pipe_in, pipe_out,
-				  asynchronous, fds_to_close);
-	line_number = save_line_number;
-
-	/* The temporary environment should be used for only the simple
-	   command immediately following its definition. */
-	dispose_used_env_vars ();
-
-#if (defined (ultrix) && defined (mips)) || defined (C_ALLOCA)
-	/* Reclaim memory allocated with alloca () on machines which
-	   may be using the alloca emulation code. */
-	(void) alloca (0);
-#endif /* (ultrix && mips) || C_ALLOCA */
-
-	/* If we forked to do the command, then we must wait_for ()
-	   the child. */
-
-	/* XXX - this is something to watch out for if there are problems
-	   when the shell is compiled without job control.  Don't worry about
-	   whether or not last_made_pid == last_pid; already_making_children
-	   tells us whether or not there are unwaited-for children to wait
-	   for and reap. */
-	if (already_making_children && pipe_out == NO_PIPE)
-	  {
-	    stop_pipeline (asynchronous, (COMMAND *)NULL);
-
-	    if (asynchronous)
-	      {
-		DESCRIBE_PID (last_made_pid);
-		exec_result = EXECUTION_SUCCESS;
-		invert = 0;		/* async commands always succeed */
-	      }
-	    else
-#if !defined (JOB_CONTROL)
-	      /* Do not wait for asynchronous processes started from
-		 startup files. */
-	    if (last_made_pid != NO_PID && last_made_pid != last_asynchronous_pid)
-#else
-	    if (last_made_pid != NO_PID)
-#endif
-	    /* When executing a shell function that executes other
-	       commands, this causes the last simple command in
-	       the function to be waited for twice.  This also causes
-	       subshells forked to execute builtin commands (e.g., in
-	       pipelines) to be waited for twice. */
-	      exec_result = wait_for (last_made_pid, 0);
-	  }
-      }
-
-      /* 2009/02/13 -- pipeline failure is processed elsewhere.  This handles
-	 only the failure of a simple command. We don't want to run the error
-	 trap if the command run by the `command' builtin fails; we want to
-	 defer that until the command builtin itself returns failure. */
-      /* 2020/07/14 -- this changes with how the command builtin is handled */ 
-      if (was_error_trap && ignore_return == 0 && invert == 0 &&
-	    pipe_in == NO_PIPE && pipe_out == NO_PIPE &&
-	    (command->value.Simple->flags & CMD_COMMAND_BUILTIN) == 0 &&
-	    exec_result != EXECUTION_SUCCESS)
-	{
-	  last_command_exit_value = exec_result;
-	  line_number = line_number_for_err_trap;
-	  run_error_trap ();
-	  line_number = save_line_number;
-	}
-
-      if (ignore_return == 0 && invert == 0 &&
-	  ((posixly_correct && interactive == 0 && special_builtin_failed) ||
-	   (exit_immediately_on_error && pipe_in == NO_PIPE && pipe_out == NO_PIPE && exec_result != EXECUTION_SUCCESS)))
-	{
-	  last_command_exit_value = exec_result;
-	  run_pending_traps ();
-
-	  /* Undo redirections before running exit trap on the way out of
-	     set -e. Report by Mark Farrell 5/19/2014 */
-	  if (exit_immediately_on_error && signal_is_trapped (0) &&
-		unwind_protect_tag_on_stack ("saved-redirects"))
-	    run_unwind_frame ("saved-redirects");
-
-	  jump_to_top_level (ERREXIT);
-	}
-
-      break;
-
-    case cm_for:
-      if (ignore_return)
-	command->value.For->flags |= CMD_IGNORE_RETURN;
-      exec_result = execute_for_command (command->value.For);
-      break;
-
-#if defined (ARITH_FOR_COMMAND)
-    case cm_arith_for:
-      if (ignore_return)
-	command->value.ArithFor->flags |= CMD_IGNORE_RETURN;
-      exec_result = execute_arith_for_command (command->value.ArithFor);
-      break;
-#endif
-
-#if defined (SELECT_COMMAND)
-    case cm_select:
-      if (ignore_return)
-	command->value.Select->flags |= CMD_IGNORE_RETURN;
-      exec_result = execute_select_command (command->value.Select);
-      break;
-#endif
-
-    case cm_case:
-      if (ignore_return)
-	command->value.Case->flags |= CMD_IGNORE_RETURN;
-      exec_result = execute_case_command (command->value.Case);
-      break;
-
-    case cm_while:
-      if (ignore_return)
-	command->value.While->flags |= CMD_IGNORE_RETURN;
-      exec_result = execute_while_command (command->value.While);
-      break;
-
-    case cm_until:
-      if (ignore_return)
-	command->value.While->flags |= CMD_IGNORE_RETURN;
-      exec_result = execute_until_command (command->value.While);
-      break;
-
-    case cm_if:
-      if (ignore_return)
-	command->value.If->flags |= CMD_IGNORE_RETURN;
-      exec_result = execute_if_command (command->value.If);
-      break;
-
-    case cm_group:
-
-      /* This code can be executed from either of two paths: an explicit
-	 '{}' command, or via a function call.  If we are executed via a
-	 function call, we have already taken care of the function being
-	 executed in the background (down there in execute_simple_command ()),
-	 and this command should *not* be marked as asynchronous.  If we
-	 are executing a regular '{}' group command, and asynchronous == 1,
-	 we must want to execute the whole command in the background, so we
-	 need a subshell, and we want the stuff executed in that subshell
-	 (this group command) to be executed in the foreground of that
-	 subshell (i.e. there will not be *another* subshell forked).
-
-	 What we do is to force a subshell if asynchronous, and then call
-	 execute_command_internal again with asynchronous still set to 1,
-	 but with the original group command, so the printed command will
-	 look right.
-
-	 The code above that handles forking off subshells will note that
-	 both subshell and async are on, and turn off async in the child
-	 after forking the subshell (but leave async set in the parent, so
-	 the normal call to describe_pid is made).  This turning off
-	 async is *crucial*; if it is not done, this will fall into an
-	 infinite loop of executions through this spot in subshell after
-	 subshell until the process limit is exhausted. */
-
-      if (asynchronous)
-	{
-	  command->flags |= CMD_FORCE_SUBSHELL;
-	  exec_result =
-	    execute_command_internal (command, 1, pipe_in, pipe_out,
-				      fds_to_close);
-	}
-      else
-	{
-	  if (ignore_return && command->value.Group->command)
-	    command->value.Group->command->flags |= CMD_IGNORE_RETURN;
-	  exec_result =
-	    execute_command_internal (command->value.Group->command,
-				      asynchronous, pipe_in, pipe_out,
-				      fds_to_close);
-	}
-      break;
-
-    case cm_connection:
-      exec_result = execute_connection (command, asynchronous,
-					pipe_in, pipe_out, fds_to_close);
-      if (asynchronous)
-	invert = 0;		/* XXX */
-
-      break;
-
-#if defined (DPAREN_ARITHMETIC)
-    case cm_arith:
-#endif
-#if defined (COND_COMMAND)
-    case cm_cond:
-#endif
-    case cm_function_def:
-      was_error_trap = signal_is_trapped (ERROR_TRAP) && signal_is_ignored (ERROR_TRAP) == 0;
-#if defined (DPAREN_ARITHMETIC)
-      if (ignore_return && command->type == cm_arith)
-	command->value.Arith->flags |= CMD_IGNORE_RETURN;
-#endif
-#if defined (COND_COMMAND)
-      if (ignore_return && command->type == cm_cond)
-	command->value.Cond->flags |= CMD_IGNORE_RETURN;
-#endif
-
-      line_number_for_err_trap = save_line_number = line_number;	/* XXX */
-#if defined (DPAREN_ARITHMETIC)
-      if (command->type == cm_arith)
-	exec_result = execute_arith_command (command->value.Arith);
-      else
-#endif
-#if defined (COND_COMMAND)
-      if (command->type == cm_cond)
-	exec_result = execute_cond_command (command->value.Cond);
-      else
-#endif
-      if (command->type == cm_function_def)
-	exec_result = execute_intern_function (command->value.Function_def->name,
-					       command->value.Function_def);
-      line_number = save_line_number;
-
-      if (was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
-	{
-	  last_command_exit_value = exec_result;
-	  save_line_number = line_number;
-	  line_number = line_number_for_err_trap;
-	  run_error_trap ();
-	  line_number = save_line_number;
-	}
-
-      if (ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
-	{
-	  last_command_exit_value = exec_result;
-	  run_pending_traps ();
-	  jump_to_top_level (ERREXIT);
-	}
-
-      break;
-
-    default:
-      command_error ("execute_command", CMDERR_BADTYPE, command->type, 0);
-    }
-
-  if (my_undo_list)
-    cleanup_redirects (my_undo_list);
-
-  if (exec_undo_list)
-    dispose_redirects (exec_undo_list);
-
-  if (my_undo_list || exec_undo_list)
-    discard_unwind_frame ("loop_redirections");
-
-#if defined (PROCESS_SUBSTITUTION)
-  if (saved_fifo)
-    {
-      nfifo = num_fifos ();
-      if (nfifo > ofifo)
-	close_new_fifos ((void *)ofifo_list, osize);
-      free ((void *)ofifo_list);
-      discard_unwind_frame ("internal_fifos");
-    }
-#endif
-
-  /* Invert the return value if we have to */
-  if (invert)
-    exec_result = (exec_result == EXECUTION_SUCCESS)
-		    ? EXECUTION_FAILURE
-		    : EXECUTION_SUCCESS;
-
-#if defined (DPAREN_ARITHMETIC) || defined (COND_COMMAND)
-  /* This is where we set PIPESTATUS from the exit status of the appropriate
-     compound commands (the ones that look enough like simple commands to
-     cause confusion).  We might be able to optimize by not doing this if
-     subshell_environment != 0. */
-  switch (command->type)
-    {
-#  if defined (DPAREN_ARITHMETIC)
-    case cm_arith:
-#  endif
-#  if defined (COND_COMMAND)
-    case cm_cond:
-#  endif
-      set_pipestatus_from_exit (exec_result);
-      break;
-    default:
-      break;
-    }
-#endif
-
-  last_command_exit_value = exec_result;
-  run_pending_traps ();
-  currently_executing_command = (COMMAND *)NULL;
-
-  return (last_command_exit_value);
-}
-
-#if defined (COMMAND_TIMING)
-
-#if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
-extern struct timeval *difftimeval PARAMS((struct timeval *, struct timeval *, struct timeval *));
-extern struct timeval *addtimeval PARAMS((struct timeval *, struct timeval *, struct timeval *));
-extern int timeval_to_cpu PARAMS((struct timeval *, struct timeval *, struct timeval *));
-#endif
-
-#define POSIX_TIMEFORMAT "real %2R\nuser %2U\nsys %2S"
-#define BASH_TIMEFORMAT  "\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS"
-
-static const int precs[] = { 0, 100, 10, 1 };
-
-/* Expand one `%'-prefixed escape sequence from a time format string. */
-static int
-mkfmt (buf, prec, lng, sec, sec_fraction)
-     char *buf;
-     int prec, lng;
-     time_t sec;
-     int sec_fraction;
-{
-  time_t min;
-  char abuf[INT_STRLEN_BOUND(time_t) + 1];
-  int ind, aind;
-
-  ind = 0;
-  abuf[sizeof(abuf) - 1] = '\0';
-
-  /* If LNG is non-zero, we want to decompose SEC into minutes and seconds. */
-  if (lng)
-    {
-      min = sec / 60;
-      sec %= 60;
-      aind = sizeof(abuf) - 2;
-      do
-	abuf[aind--] = (min % 10) + '0';
-      while (min /= 10);
-      aind++;
-      while (abuf[aind])
-	buf[ind++] = abuf[aind++];
-      buf[ind++] = 'm';
-    }
-
-  /* Now add the seconds. */
-  aind = sizeof (abuf) - 2;
-  do
-    abuf[aind--] = (sec % 10) + '0';
-  while (sec /= 10);
-  aind++;
-  while (abuf[aind])
-    buf[ind++] = abuf[aind++];
-
-  /* We want to add a decimal point and PREC places after it if PREC is
-     nonzero.  PREC is not greater than 3.  SEC_FRACTION is between 0
-     and 999. */
-  if (prec != 0)
-    {
-      buf[ind++] = locale_decpoint ();
-      for (aind = 1; aind <= prec; aind++)
-	{
-	  buf[ind++] = (sec_fraction / precs[aind]) + '0';
-	  sec_fraction %= precs[aind];
-	}
-    }
-
-  if (lng)
-    buf[ind++] = 's';
-  buf[ind] = '\0';
-
-  return (ind);
-}
-
-/* Interpret the format string FORMAT, interpolating the following escape
-   sequences:
-		%[prec][l][RUS]
-
-   where the optional `prec' is a precision, meaning the number of
-   characters after the decimal point, the optional `l' means to format
-   using minutes and seconds (MMmNN[.FF]s), like the `times' builtin',
-   and the last character is one of
-   
-		R	number of seconds of `real' time
-		U	number of seconds of `user' time
-		S	number of seconds of `system' time
-
-   An occurrence of `%%' in the format string is translated to a `%'.  The
-   result is printed to FP, a pointer to a FILE.  The other variables are
-   the seconds and thousandths of a second of real, user, and system time,
-   resectively. */
-static void
-print_formatted_time (fp, format, rs, rsf, us, usf, ss, ssf, cpu)
-     FILE *fp;
-     char *format;
-     time_t rs;
-     int rsf;
-     time_t us;
-     int usf;
-     time_t ss;
-     int ssf, cpu;
-{
-  int prec, lng, len;
-  char *str, *s, ts[INT_STRLEN_BOUND (time_t) + sizeof ("mSS.FFFF")];
-  time_t sum;
-  int sum_frac;
-  int sindex, ssize;
-
-  len = strlen (format);
-  ssize = (len + 64) - (len % 64);
-  str = (char *)xmalloc (ssize);
-  sindex = 0;
-
-  for (s = format; *s; s++)
-    {
-      if (*s != '%' || s[1] == '\0')
-	{
-	  RESIZE_MALLOCED_BUFFER (str, sindex, 1, ssize, 64);
-	  str[sindex++] = *s;
-	}
-      else if (s[1] == '%')
-	{
-	  s++;
-	  RESIZE_MALLOCED_BUFFER (str, sindex, 1, ssize, 64);
-	  str[sindex++] = *s;
-	}
-      else if (s[1] == 'P')
-	{
-	  s++;
-#if 0
-	  /* clamp CPU usage at 100% */
-	  if (cpu > 10000)
-	    cpu = 10000;
-#endif
-	  sum = cpu / 100;
-	  sum_frac = (cpu % 100) * 10;
-	  len = mkfmt (ts, 2, 0, sum, sum_frac);
-	  RESIZE_MALLOCED_BUFFER (str, sindex, len, ssize, 64);
-	  strcpy (str + sindex, ts);
-	  sindex += len;
-	}
-      else
-	{
-	  prec = 3;	/* default is three places past the decimal point. */
-	  lng = 0;	/* default is to not use minutes or append `s' */
-	  s++;
-	  if (DIGIT (*s))		/* `precision' */
-	    {
-	      prec = *s++ - '0';
-	      if (prec > 3) prec = 3;
-	    }
-	  if (*s == 'l')		/* `length extender' */
-	    {
-	      lng = 1;
-	      s++;
-	    }
-	  if (*s == 'R' || *s == 'E')
-	    len = mkfmt (ts, prec, lng, rs, rsf);
-	  else if (*s == 'U')
-	    len = mkfmt (ts, prec, lng, us, usf);
-	  else if (*s == 'S')
-	    len = mkfmt (ts, prec, lng, ss, ssf);
-	  else
-	    {
-	      internal_error (_("TIMEFORMAT: `%c': invalid format character"), *s);
-	      free (str);
-	      return;
-	    }
-	  RESIZE_MALLOCED_BUFFER (str, sindex, len, ssize, 64);
-	  strcpy (str + sindex, ts);
-	  sindex += len;
-	}
-    }
-
-  str[sindex] = '\0';
-  fprintf (fp, "%s\n", str);
-  fflush (fp);
-
-  free (str);
-}
-
-static int
-time_command (command, asynchronous, pipe_in, pipe_out, fds_to_close)
-     COMMAND *command;
-     int asynchronous, pipe_in, pipe_out;
-     struct fd_bitmap *fds_to_close;
-{
-  int rv, posix_time, old_flags, nullcmd, code;
-  time_t rs, us, ss;
-  int rsf, usf, ssf;
-  int cpu;
-  char *time_format;
-  volatile procenv_t save_top_level;
-  volatile int old_subshell;
-
-#if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
-  struct timeval real, user, sys;
-  struct timeval before, after;
-#  if defined (HAVE_STRUCT_TIMEZONE)
-  struct timezone dtz;				/* posix doesn't define this */
-#  endif
-  struct rusage selfb, selfa, kidsb, kidsa;	/* a = after, b = before */
-#else
-#  if defined (HAVE_TIMES)
-  clock_t tbefore, tafter, real, user, sys;
-  struct tms before, after;
-#  endif
-#endif
-
-#if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
-#  if defined (HAVE_STRUCT_TIMEZONE)
-  gettimeofday (&before, &dtz);
-#  else
-  gettimeofday (&before, (void *)NULL);
-#  endif /* !HAVE_STRUCT_TIMEZONE */
-  getrusage (RUSAGE_SELF, &selfb);
-  getrusage (RUSAGE_CHILDREN, &kidsb);
-#else
-#  if defined (HAVE_TIMES)
-  tbefore = times (&before);
-#  endif
-#endif
-
-  old_subshell = subshell_environment;
-  posix_time = command && (command->flags & CMD_TIME_POSIX);
-
-  nullcmd = (command == 0) || (command->type == cm_simple && command->value.Simple->words == 0 && command->value.Simple->redirects == 0);
-  if (posixly_correct && nullcmd)
-    {
-#if defined (HAVE_GETRUSAGE)
-      selfb.ru_utime.tv_sec = kidsb.ru_utime.tv_sec = selfb.ru_stime.tv_sec = kidsb.ru_stime.tv_sec = 0;
-      selfb.ru_utime.tv_usec = kidsb.ru_utime.tv_usec = selfb.ru_stime.tv_usec = kidsb.ru_stime.tv_usec = 0;
-      before = shellstart;
-#else
-      before.tms_utime = before.tms_stime = before.tms_cutime = before.tms_cstime = 0;
-      tbefore = shell_start_time;
-#endif
-    }
-
-  old_flags = command->flags;
-  COPY_PROCENV (top_level, save_top_level);
-  command->flags &= ~(CMD_TIME_PIPELINE|CMD_TIME_POSIX);
-  code = setjmp_nosigs (top_level);
-  if (code == NOT_JUMPED)
-    rv = execute_command_internal (command, asynchronous, pipe_in, pipe_out, fds_to_close);
-  COPY_PROCENV (save_top_level, top_level);
-
-  command->flags = old_flags;
-
-  /* If we're jumping in a different subshell environment than we started,
-     don't bother printing timing stats, just keep longjmping back to the
-     original top level. */
-  if (code != NOT_JUMPED && subshell_environment && subshell_environment != old_subshell)
-    sh_longjmp (top_level, code);
-
-  rs = us = ss = 0;
-  rsf = usf = ssf = cpu = 0;
-
-#if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
-#  if defined (HAVE_STRUCT_TIMEZONE)
-  gettimeofday (&after, &dtz);
-#  else
-  gettimeofday (&after, (void *)NULL);
-#  endif /* !HAVE_STRUCT_TIMEZONE */
-  getrusage (RUSAGE_SELF, &selfa);
-  getrusage (RUSAGE_CHILDREN, &kidsa);
-
-  difftimeval (&real, &before, &after);
-  timeval_to_secs (&real, &rs, &rsf);
-
-  addtimeval (&user, difftimeval(&after, &selfb.ru_utime, &selfa.ru_utime),
-		     difftimeval(&before, &kidsb.ru_utime, &kidsa.ru_utime));
-  timeval_to_secs (&user, &us, &usf);
-
-  addtimeval (&sys, difftimeval(&after, &selfb.ru_stime, &selfa.ru_stime),
-		    difftimeval(&before, &kidsb.ru_stime, &kidsa.ru_stime));
-  timeval_to_secs (&sys, &ss, &ssf);
-
-  cpu = timeval_to_cpu (&real, &user, &sys);
-#else
-#  if defined (HAVE_TIMES)
-  tafter = times (&after);
-
-  real = tafter - tbefore;
-  clock_t_to_secs (real, &rs, &rsf);
-
-  user = (after.tms_utime - before.tms_utime) + (after.tms_cutime - before.tms_cutime);
-  clock_t_to_secs (user, &us, &usf);
-
-  sys = (after.tms_stime - before.tms_stime) + (after.tms_cstime - before.tms_cstime);
-  clock_t_to_secs (sys, &ss, &ssf);
-
-  cpu = (real == 0) ? 0 : ((user + sys) * 10000) / real;
-
-#  else
-  rs = us = ss = 0;
-  rsf = usf = ssf = cpu = 0;
-#  endif
-#endif
-
-  if (posix_time)
-    time_format = POSIX_TIMEFORMAT;
-  else if ((time_format = get_string_value ("TIMEFORMAT")) == 0)
-    {
-      if (posixly_correct && nullcmd)
-	time_format = "user\t%2lU\nsys\t%2lS";
-      else
-	time_format = BASH_TIMEFORMAT;
-    }
-
-  if (time_format && *time_format)
-    print_formatted_time (stderr, time_format, rs, rsf, us, usf, ss, ssf, cpu);
-
-  if (code)
-    sh_longjmp (top_level, code);
-
-  return rv;
-}
-#endif /* COMMAND_TIMING */
-
-/* Execute a command that's supposed to be in a subshell.  This must be
-   called after make_child and we must be running in the child process.
-   The caller will return or exit() immediately with the value this returns. */
-static int
-execute_in_subshell (command, asynchronous, pipe_in, pipe_out, fds_to_close)
-     COMMAND *command;
-     int asynchronous;
-     int pipe_in, pipe_out;
-     struct fd_bitmap *fds_to_close;
-{
-  volatile int user_subshell, user_coproc, invert;
-  int return_code, function_value, should_redir_stdin, ois, result;
-  volatile COMMAND *tcom;
-
-  USE_VAR(user_subshell);
-  USE_VAR(user_coproc);
-  USE_VAR(invert);
-  USE_VAR(tcom);
-  USE_VAR(asynchronous);
-
-  subshell_level++;
-  should_redir_stdin = (asynchronous && (command->flags & CMD_STDIN_REDIR) &&
-			  pipe_in == NO_PIPE &&
-			  stdin_redirects (command->redirects) == 0);
-
-  invert = (command->flags & CMD_INVERT_RETURN) != 0;
-  user_subshell = command->type == cm_subshell || ((command->flags & CMD_WANT_SUBSHELL) != 0);
-  user_coproc = command->type == cm_coproc;
-
-  command->flags &= ~(CMD_FORCE_SUBSHELL | CMD_WANT_SUBSHELL | CMD_INVERT_RETURN);
-
-  /* If a command is asynchronous in a subshell (like ( foo ) & or
-     the special case of an asynchronous GROUP command where the
-
-     the subshell bit is turned on down in case cm_group: below),
-     turn off `asynchronous', so that two subshells aren't spawned.
-     XXX - asynchronous used to be set to 0 in this block, but that
-     means that setup_async_signals was never run.  Now it's set to
-     0 after subshell_environment is set appropriately and setup_async_signals
-     is run.
-
-     This seems semantically correct to me.  For example,
-     ( foo ) & seems to say ``do the command `foo' in a subshell
-     environment, but don't wait for that subshell to finish'',
-     and "{ foo ; bar ; } &" seems to me to be like functions or
-     builtins in the background, which executed in a subshell
-     environment.  I just don't see the need to fork two subshells. */
-
-  /* Don't fork again, we are already in a subshell.  A `doubly
-     async' shell is not interactive, however. */
-  if (asynchronous)
-    {
-#if defined (JOB_CONTROL)
-      /* If a construct like ( exec xxx yyy ) & is given while job
-	 control is active, we want to prevent exec from putting the
-	 subshell back into the original process group, carefully
-	 undoing all the work we just did in make_child. */
-      original_pgrp = -1;
-#endif /* JOB_CONTROL */
-      ois = interactive_shell;
-      interactive_shell = 0;
-      /* This test is to prevent alias expansion by interactive shells that
-	 run `(command) &' but to allow scripts that have enabled alias
-	 expansion with `shopt -s expand_alias' to continue to expand
-	 aliases. */
-      if (ois != interactive_shell)
-	expand_aliases = 0;
-    }
-
-  /* Subshells are neither login nor interactive. */
-  login_shell = interactive = 0;
-
-  /* And we're no longer in a loop. See Posix interp 842 (we are not in the
-     "same execution environment"). */
-  if (shell_compatibility_level > 44)
-    loop_level = 0;
-
-  if (user_subshell)
-    {
-      subshell_environment = SUBSHELL_PAREN;	/* XXX */
-      if (asynchronous)
-	subshell_environment |= SUBSHELL_ASYNC;
-    }
-  else
-    {
-      subshell_environment = 0;			/* XXX */
-      if (asynchronous)
-	subshell_environment |= SUBSHELL_ASYNC;
-      if (pipe_in != NO_PIPE || pipe_out != NO_PIPE)
-	subshell_environment |= SUBSHELL_PIPE;
-      if (user_coproc)
-	subshell_environment |= SUBSHELL_COPROC;
-    }
-
-  QUIT;
-  CHECK_TERMSIG;
-
-  reset_terminating_signals ();		/* in sig.c */
-  /* Cancel traps, in trap.c. */
-  /* Reset the signal handlers in the child, but don't free the
-     trap strings.  Set a flag noting that we have to free the
-     trap strings if we run trap to change a signal disposition. */
-  clear_pending_traps ();
-  reset_signal_handlers ();
-  subshell_environment |= SUBSHELL_RESETTRAP;
-  /* Note that signal handlers have been reset, so we should no longer
-    reset the handler and resend trapped signals to ourselves. */
-  subshell_environment &= ~SUBSHELL_IGNTRAP;
-
-  /* We are in a subshell, so forget that we are running a trap handler or
-     that the signal handler has changed (we haven't changed it!) */
-  /* XXX - maybe do this for `real' signals and not ERR/DEBUG/RETURN/EXIT
-     traps? */
-  if (running_trap > 0)
-    {
-      run_trap_cleanup (running_trap - 1);
-      running_trap = 0;		/* XXX - maybe leave this */
-    }
-
-  /* Make sure restore_original_signals doesn't undo the work done by
-     make_child to ensure that asynchronous children are immune to SIGINT
-     and SIGQUIT.  Turn off asynchronous to make sure more subshells are
-     not spawned. */
-  if (asynchronous)
-    {
-      setup_async_signals ();
-      asynchronous = 0;
-    }
-  else
-    set_sigint_handler ();
-
-#if defined (JOB_CONTROL)
-  set_sigchld_handler ();
-#endif /* JOB_CONTROL */
-
-  /* Delete all traces that there were any jobs running.  This is
-     only for subshells. */
-  without_job_control ();
-
-  if (fds_to_close)
-    close_fd_bitmap (fds_to_close);
-
-  do_piping (pipe_in, pipe_out);
-
-#if defined (COPROCESS_SUPPORT)
-  coproc_closeall ();
-#endif
-
-#if defined (PROCESS_SUBSTITUTION)
-  clear_fifo_list ();		/* XXX- we haven't created any FIFOs */
-#endif
-
-  /* If this is a user subshell, set a flag if stdin was redirected.
-     This is used later to decide whether to redirect fd 0 to
-     /dev/null for async commands in the subshell.  This adds more
-     sh compatibility, but I'm not sure it's the right thing to do.
-     Note that an input pipe to a compound command suffices to inhibit
-     the implicit /dev/null redirection for asynchronous commands
-     executed as part of that compound command. */
-  if (user_subshell)
-    {
-      stdin_redir = stdin_redirects (command->redirects) || pipe_in != NO_PIPE;
-#if 0
-      restore_default_signal (EXIT_TRAP);	/* XXX - reset_signal_handlers above */
-#endif
-    }
-  else if (shell_control_structure (command->type) && pipe_in != NO_PIPE)
-    stdin_redir = 1;
-
-  /* If this is an asynchronous command (command &), we want to
-     redirect the standard input from /dev/null in the absence of
-     any specific redirection involving stdin. */
-  if (should_redir_stdin && stdin_redir == 0)
-    async_redirect_stdin ();
-
-#if defined (BUFFERED_INPUT)
-  /* In any case, we are not reading our command input from stdin. */
-  default_buffered_input = -1;
-#endif
-
-  /* We can't optimize away forks if one of the commands executed by the
-     subshell sets an exit trap, so we set CMD_NO_FORK for simple commands
-     and set CMD_TRY_OPTIMIZING for simple commands on the right side of an
-     and-or or `;' list to test for optimizing forks when they are executed. */
-  if (user_subshell && command->type == cm_subshell)
-    optimize_subshell_command (command->value.Subshell->command);
-
-  /* Do redirections, then dispose of them before recursive call. */
-  if (command->redirects)
-    {
-      if (do_redirections (command->redirects, RX_ACTIVE) != 0)
-	exit (invert ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-
-      dispose_redirects (command->redirects);
-      command->redirects = (REDIRECT *)NULL;
-    }
-
-  if (command->type == cm_subshell)
-    tcom = command->value.Subshell->command;
-  else if (user_coproc)
-    tcom = command->value.Coproc->command;
-  else
-    tcom = command;
-
-  if (command->flags & CMD_TIME_PIPELINE)
-    tcom->flags |= CMD_TIME_PIPELINE;
-  if (command->flags & CMD_TIME_POSIX)
-    tcom->flags |= CMD_TIME_POSIX;
-  
-  /* Make sure the subshell inherits any CMD_IGNORE_RETURN flag. */
-  if ((command->flags & CMD_IGNORE_RETURN) && tcom != command)
-    tcom->flags |= CMD_IGNORE_RETURN;
-
-  /* If this is a simple command, tell execute_disk_command that it
-     might be able to get away without forking and simply exec.
-     This means things like ( sleep 10 ) will only cause one fork.
-     If we're timing the command or inverting its return value, however,
-     we cannot do this optimization. */
-  if ((user_subshell || user_coproc) && (tcom->type == cm_simple || tcom->type == cm_subshell) &&
-      ((tcom->flags & CMD_TIME_PIPELINE) == 0) &&
-      ((tcom->flags & CMD_INVERT_RETURN) == 0))
-    {
-      tcom->flags |= CMD_NO_FORK;
-      if (tcom->type == cm_simple)
-	tcom->value.Simple->flags |= CMD_NO_FORK;
-    }
-
-  invert = (tcom->flags & CMD_INVERT_RETURN) != 0;
-  tcom->flags &= ~CMD_INVERT_RETURN;
-
-  result = setjmp_nosigs (top_level);
-
-  /* If we're inside a function while executing this subshell, we
-     need to handle a possible `return'. */
-  function_value = 0;
-  if (return_catch_flag)
-    function_value = setjmp_nosigs (return_catch);
-
-  /* If we're going to exit the shell, we don't want to invert the return
-     status. */
-  if (result == EXITPROG || result == EXITBLTIN)
-    invert = 0, return_code = last_command_exit_value;
-  else if (result)
-    return_code = (last_command_exit_value == EXECUTION_SUCCESS) ? EXECUTION_FAILURE : last_command_exit_value;
-  else if (function_value)
-    return_code = return_catch_value;
-  else
-    return_code = execute_command_internal ((COMMAND *)tcom, asynchronous, NO_PIPE, NO_PIPE, fds_to_close);
-
-  /* If we are asked to, invert the return value. */
-  if (invert)
-    return_code = (return_code == EXECUTION_SUCCESS) ? EXECUTION_FAILURE
-						     : EXECUTION_SUCCESS;
-
-
-  /* If we were explicitly placed in a subshell with (), we need
-     to do the `shell cleanup' things, such as running traps[0]. */
-  if (user_subshell && signal_is_trapped (0))
-    {
-      last_command_exit_value = return_code;
-      return_code = run_exit_trap ();
-    }
-
-#if 0
-  subshell_level--;		/* don't bother, caller will just exit */
-#endif
-  return (return_code);
-  /* NOTREACHED */
-}
-
-#if defined (COPROCESS_SUPPORT)
-#define COPROC_MAX	16
-
-typedef struct cpelement
-  {
-    struct cpelement *next;
-    struct coproc *coproc;
-  }
-cpelement_t;
-    
-typedef struct cplist
-  {
-    struct cpelement *head;
-    struct cpelement *tail;
-    int ncoproc;
-    int lock;
-  }
-cplist_t;
-
-static struct cpelement *cpe_alloc PARAMS((struct coproc *));
-static void cpe_dispose PARAMS((struct cpelement *));
-static struct cpelement *cpl_add PARAMS((struct coproc *));
-static struct cpelement *cpl_delete PARAMS((pid_t));
-static void cpl_reap PARAMS((void));
-static void cpl_flush PARAMS((void));
-static void cpl_closeall PARAMS((void));
-static struct cpelement *cpl_search PARAMS((pid_t));
-static struct cpelement *cpl_searchbyname PARAMS((const char *));
-static void cpl_prune PARAMS((void));
-
-static void coproc_free PARAMS((struct coproc *));
-
-/* Will go away when there is fully-implemented support for multiple coprocs. */
-Coproc sh_coproc = { 0, NO_PID, -1, -1, 0, 0, 0, 0, 0 };
-
-cplist_t coproc_list = {0, 0, 0};
-
-/* Functions to manage the list of coprocs */
-
-static struct cpelement *
-cpe_alloc (cp)
-     Coproc *cp;
-{
-  struct cpelement *cpe;
-
-  cpe = (struct cpelement *)xmalloc (sizeof (struct cpelement));
-  cpe->coproc = cp;
-  cpe->next = (struct cpelement *)0;
-  return cpe;
-}
-
-static void
-cpe_dispose (cpe)
-      struct cpelement *cpe;
-{
-  free (cpe);
-}
-
-static struct cpelement *
-cpl_add (cp)
-     Coproc *cp;
-{
-  struct cpelement *cpe;
-
-  cpe = cpe_alloc (cp);
-
-  if (coproc_list.head == 0)
-    {
-      coproc_list.head = coproc_list.tail = cpe;
-      coproc_list.ncoproc = 0;			/* just to make sure */
-    }
-  else
-    {
-      coproc_list.tail->next = cpe;
-      coproc_list.tail = cpe;
-    }
-  coproc_list.ncoproc++;
-
-  return cpe;
-}
-
-static struct cpelement *
-cpl_delete (pid)
-     pid_t pid;
-{
-  struct cpelement *prev, *p;
-
-  for (prev = p = coproc_list.head; p; prev = p, p = p->next)
-    if (p->coproc->c_pid == pid)
-      {
-        prev->next = p->next;	/* remove from list */
-        break;
-      }
-
-  if (p == 0)
-    return 0;		/* not found */
-
-  INTERNAL_DEBUG (("cpl_delete: deleting %d", pid));
-
-  /* Housekeeping in the border cases. */
-  if (p == coproc_list.head)
-    coproc_list.head = coproc_list.head->next;
-  else if (p == coproc_list.tail)
-    coproc_list.tail = prev;
-
-  coproc_list.ncoproc--;
-  if (coproc_list.ncoproc == 0)
-    coproc_list.head = coproc_list.tail = 0;
-  else if (coproc_list.ncoproc == 1)
-    coproc_list.tail = coproc_list.head;		/* just to make sure */
-
-  return (p);
-}
-
-static void
-cpl_reap ()
-{
-  struct cpelement *p, *next, *nh, *nt;
-
-  /* Build a new list by removing dead coprocs and fix up the coproc_list
-     pointers when done. */
-  nh = nt = next = (struct cpelement *)0;
-  for (p = coproc_list.head; p; p = next)
-    {
-      next = p->next;
-      if (p->coproc->c_flags & COPROC_DEAD)
-	{
-	  coproc_list.ncoproc--;	/* keep running count, fix up pointers later */
-	  INTERNAL_DEBUG (("cpl_reap: deleting %d", p->coproc->c_pid));
-	  coproc_dispose (p->coproc);
-	  cpe_dispose (p);
-	}
-      else if (nh == 0)
-	nh = nt = p;
-      else
-	{
-	  nt->next = p;
-	  nt = nt->next;
-	}
-    }
-
-  if (coproc_list.ncoproc == 0)
-    coproc_list.head = coproc_list.tail = 0;
-  else
-    {
-      if (nt)
-        nt->next = 0;
-      coproc_list.head = nh;
-      coproc_list.tail = nt;
-      if (coproc_list.ncoproc == 1)
-	coproc_list.tail = coproc_list.head;		/* just to make sure */  
-    }
-}
-
-/* Clear out the list of saved statuses */
-static void
-cpl_flush ()
-{
-  struct cpelement *cpe, *p;
-
-  for (cpe = coproc_list.head; cpe; )
-    {
-      p = cpe;
-      cpe = cpe->next;
-
-      coproc_dispose (p->coproc);
-      cpe_dispose (p);
-    }
-
-  coproc_list.head = coproc_list.tail = 0;
-  coproc_list.ncoproc = 0;
-}
-
-static void
-cpl_closeall ()
-{
-  struct cpelement *cpe;
-
-  for (cpe = coproc_list.head; cpe; cpe = cpe->next)
-    coproc_close (cpe->coproc);
-}
-
-static void
-cpl_fdchk (fd)
-     int fd;
-{
-  struct cpelement *cpe;
-
-  for (cpe = coproc_list.head; cpe; cpe = cpe->next)
-    coproc_checkfd (cpe->coproc, fd);
-}
-
-/* Search for PID in the list of coprocs; return the cpelement struct if
-   found.  If not found, return NULL. */
-static struct cpelement *
-cpl_search (pid)
-     pid_t pid;
-{
-  struct cpelement *cpe;
-
-  for (cpe = coproc_list.head ; cpe; cpe = cpe->next)
-    if (cpe->coproc->c_pid == pid)
-      return cpe;
-  return (struct cpelement *)NULL;
-}
-
-/* Search for the coproc named NAME in the list of coprocs; return the
-   cpelement struct if found.  If not found, return NULL. */
-static struct cpelement *
-cpl_searchbyname (name)
-     const char *name;
-{
-  struct cpelement *cp;
-
-  for (cp = coproc_list.head ; cp; cp = cp->next)
-    if (STREQ (cp->coproc->c_name, name))
-      return cp;
-  return (struct cpelement *)NULL;
-}
-
-static pid_t
-cpl_firstactive ()
-{
-  struct cpelement *cpe;
-
-  for (cpe = coproc_list.head ; cpe; cpe = cpe->next)
-    if ((cpe->coproc->c_flags & COPROC_DEAD) == 0)
-      return cpe->coproc->c_pid;
-  return (pid_t)NO_PID;
-}
-
-#if 0
-static void
-cpl_prune ()
-{
-  struct cpelement *cp;
-
-  while (coproc_list.head && coproc_list.ncoproc > COPROC_MAX)
-    {
-      cp = coproc_list.head;
-      coproc_list.head = coproc_list.head->next;
-      coproc_dispose (cp->coproc);
-      cpe_dispose (cp);
-      coproc_list.ncoproc--;
-    }
-}
-#endif
-
-/* These currently use a single global "shell coproc" but are written in a
-   way to not preclude additional coprocs later (using the list management
-   package above). */
-
-struct coproc *
-getcoprocbypid (pid)
-     pid_t pid;
-{
-#if MULTIPLE_COPROCS
-  struct cpelement *p;
-
-  p = cpl_search (pid);
-  return (p ? p->coproc : 0);
-#else
-  return (pid == sh_coproc.c_pid ? &sh_coproc : 0);
-#endif
-}
-
-struct coproc *
-getcoprocbyname (name)
-     const char *name;
-{
-#if MULTIPLE_COPROCS
-  struct cpelement *p;
-
-  p = cpl_searchbyname (name);
-  return (p ? p->coproc : 0);
-#else
-  return ((sh_coproc.c_name && STREQ (sh_coproc.c_name, name)) ? &sh_coproc : 0);
-#endif
-}
-
-void
-coproc_init (cp)
-     struct coproc *cp;
-{
-  cp->c_name = 0;
-  cp->c_pid = NO_PID;
-  cp->c_rfd = cp->c_wfd = -1;
-  cp->c_rsave = cp->c_wsave = -1;
-  cp->c_flags = cp->c_status = cp->c_lock = 0;
-}
-
-struct coproc *
-coproc_alloc (name, pid)
-     char *name;
-     pid_t pid;
-{
-  struct coproc *cp;
-
-#if MULTIPLE_COPROCS
-  cp = (struct coproc *)xmalloc (sizeof (struct coproc));
-#else
-  cp = &sh_coproc;
-#endif
-  coproc_init (cp);
-  cp->c_lock = 2;
-
-  cp->c_pid = pid;
-  cp->c_name = savestring (name);
-#if MULTIPLE_COPROCS
-  cpl_add (cp);
-#endif
-  cp->c_lock = 0;
-  return (cp);
-}
-
-static void
-coproc_free (cp)
-     struct coproc *cp;
-{
-  free (cp);
-}
-
-void
-coproc_dispose (cp)
-     struct coproc *cp;
-{
-  sigset_t set, oset;
-
-  if (cp == 0)
-    return;
-
-  BLOCK_SIGNAL (SIGCHLD, set, oset);
-  cp->c_lock = 3;
-  coproc_unsetvars (cp);
-  FREE (cp->c_name);
-  coproc_close (cp);
-#if MULTIPLE_COPROCS
-  coproc_free (cp);
-#else
-  coproc_init (cp);
-  cp->c_lock = 0;
-#endif
-  UNBLOCK_SIGNAL (oset);
-}
-
-/* Placeholder for now.  Will require changes for multiple coprocs */
-void
-coproc_flush ()
-{
-#if MULTIPLE_COPROCS
-  cpl_flush ();
-#else
-  coproc_dispose (&sh_coproc);
-#endif
-}
-
-void
-coproc_close (cp)
-     struct coproc *cp;
-{
-  if (cp->c_rfd >= 0)
-    {
-      close (cp->c_rfd);
-      cp->c_rfd = -1;
-    }
-  if (cp->c_wfd >= 0)
-    {
-      close (cp->c_wfd);
-      cp->c_wfd = -1;
-    }
-  cp->c_rsave = cp->c_wsave = -1;
-}
-
-void
-coproc_closeall ()
-{
-#if MULTIPLE_COPROCS
-  cpl_closeall ();
-#else
-  coproc_close (&sh_coproc);	/* XXX - will require changes for multiple coprocs */
-#endif
-}
-
-void
-coproc_reap ()
-{
-#if MULTIPLE_COPROCS
-  cpl_reap ();
-#else
-  struct coproc *cp;
-
-  cp = &sh_coproc;		/* XXX - will require changes for multiple coprocs */
-  if (cp && (cp->c_flags & COPROC_DEAD))
-    coproc_dispose (cp);
-#endif
-}
-
-void
-coproc_rclose (cp, fd)
-     struct coproc *cp;
-     int fd;
-{
-  if (cp->c_rfd >= 0 && cp->c_rfd == fd)
-    {
-      close (cp->c_rfd);
-      cp->c_rfd = -1;
-    }
-}
-
-void
-coproc_wclose (cp, fd)
-     struct coproc *cp;
-     int fd;
-{
-  if (cp->c_wfd >= 0 && cp->c_wfd == fd)
-    {
-      close (cp->c_wfd);
-      cp->c_wfd = -1;
-    }
-}
-
-void
-coproc_checkfd (cp, fd)
-     struct coproc *cp;
-     int fd;
-{
-  int update;
-
-  update = 0;
-  if (cp->c_rfd >= 0 && cp->c_rfd == fd)
-    update = cp->c_rfd = -1;
-  if (cp->c_wfd >= 0 && cp->c_wfd == fd)
-    update = cp->c_wfd = -1;
-  if (update)
-    coproc_setvars (cp);
-}
-
-void
-coproc_fdchk (fd)
-     int fd;
-{
-#if MULTIPLE_COPROCS
-  cpl_fdchk (fd);
-#else
-  coproc_checkfd (&sh_coproc, fd);
-#endif
-}
-
-void
-coproc_fdclose (cp, fd)
-     struct coproc *cp;
-     int fd;
-{
-  coproc_rclose (cp, fd);
-  coproc_wclose (cp, fd);
-  coproc_setvars (cp);
-}
-
-void
-coproc_fdsave (cp)
-     struct coproc *cp;
-{
-  cp->c_rsave = cp->c_rfd;
-  cp->c_wsave = cp->c_wfd;
-}
-
-void
-coproc_fdrestore (cp)
-     struct coproc *cp;
-{
-  cp->c_rfd = cp->c_rsave;
-  cp->c_wfd = cp->c_wsave;
-}
-
-static void
-coproc_setstatus (cp, status)
-     struct coproc *cp;
-     int status;
-{
-  cp->c_lock = 4;
-  cp->c_status = status;
-  cp->c_flags |= COPROC_DEAD;
-  cp->c_flags &= ~COPROC_RUNNING;
-  /* Don't dispose the coproc or unset the COPROC_XXX variables because
-     this is executed in a signal handler context.  Wait until coproc_reap
-     takes care of it. */
-  cp->c_lock = 0;
-}
-
-void
-coproc_pidchk (pid, status)
-     pid_t pid;
-     int status;
-{
-  struct coproc *cp;
-
-#if MULTIPLE_COPROCS
-  struct cpelement *cpe;
-
-  /* We're not disposing the coproc because this is executed in a signal
-     handler context */
-  cpe = cpl_search (pid);
-  cp = cpe ? cpe->coproc : 0;
-#else
-  cp = getcoprocbypid (pid);
-#endif
-  if (cp)
-    coproc_setstatus (cp, status);
-}
-
-pid_t
-coproc_active ()
-{
-#if MULTIPLE_COPROCS
-  return (cpl_firstactive ());
-#else
-  return ((sh_coproc.c_flags & COPROC_DEAD) ? NO_PID : sh_coproc.c_pid);
-#endif
-}
-void
-coproc_setvars (cp)
-     struct coproc *cp;
-{
-  SHELL_VAR *v;
-  char *namevar, *t;
-  size_t l;
-  WORD_DESC w;
-#if defined (ARRAY_VARS)
-  arrayind_t ind;
-#endif
-
-  if (cp->c_name == 0)
-    return;
-
-  /* We could do more here but right now we only check the name, warn if it's
-     not a valid identifier, and refuse to create variables with invalid names
-     if a coproc with such a name is supplied. */
-  w.word = cp->c_name;
-  w.flags = 0;
-  if (check_identifier (&w, 1) == 0)
-    return;
-
-  l = strlen (cp->c_name);
-  namevar = xmalloc (l + 16);
-
-#if defined (ARRAY_VARS)
-  v = find_variable (cp->c_name);
-
-  /* This is the same code as in find_or_make_array_variable */
-  if (v == 0)
-    {
-      v = find_variable_nameref_for_create (cp->c_name, 1);
-      if (v == INVALID_NAMEREF_VALUE)
-	{
-	  free (namevar);
-	  return;
-	}
-      if (v && nameref_p (v))
-	{
-	  free (cp->c_name);
-	  cp->c_name = savestring (nameref_cell (v));
-	  v = make_new_array_variable (cp->c_name);	  
-	}
-    }
-
-  if (v && (readonly_p (v) || noassign_p (v)))
-    {
-      if (readonly_p (v))
-	err_readonly (cp->c_name);
-      free (namevar);
-      return;
-    }
-  if (v == 0)
-    v = make_new_array_variable (cp->c_name);
-  if (array_p (v) == 0)
-    v = convert_var_to_array (v);
-
-  t = itos (cp->c_rfd);
-  ind = 0;
-  v = bind_array_variable (cp->c_name, ind, t, 0);
-  free (t);
-
-  t = itos (cp->c_wfd);
-  ind = 1;
-  v = bind_array_variable (cp->c_name, ind, t, 0);
-  free (t);
-#else
-  sprintf (namevar, "%s_READ", cp->c_name);
-  t = itos (cp->c_rfd);
-  bind_variable (namevar, t, 0);
-  free (t);
-  sprintf (namevar, "%s_WRITE", cp->c_name);
-  t = itos (cp->c_wfd);
-  bind_variable (namevar, t, 0);
-  free (t);
-#endif
-
-  sprintf (namevar, "%s_PID", cp->c_name);
-  t = itos (cp->c_pid);
-  v = bind_variable (namevar, t, 0);
-  free (t);
-
-  free (namevar);
-}
-
-void
-coproc_unsetvars (cp)
-     struct coproc *cp;
-{
-  int l;
-  char *namevar;
-
-  if (cp->c_name == 0)
-    return;
-
-  l = strlen (cp->c_name);
-  namevar = xmalloc (l + 16);
-
-  sprintf (namevar, "%s_PID", cp->c_name);
-  unbind_variable_noref (namevar);  
-
-#if defined (ARRAY_VARS)
-  check_unbind_variable (cp->c_name);
-#else
-  sprintf (namevar, "%s_READ", cp->c_name);
-  unbind_variable (namevar);
-  sprintf (namevar, "%s_WRITE", cp->c_name);
-  unbind_variable (namevar);
-#endif  
-
-  free (namevar);
-}
-
-static int
-execute_coproc (command, pipe_in, pipe_out, fds_to_close)
-     COMMAND *command;
-     int pipe_in, pipe_out;
-     struct fd_bitmap *fds_to_close;
-{
-  int rpipe[2], wpipe[2], estat, invert;
-  pid_t coproc_pid;
-  Coproc *cp;
-  char *tcmd, *p, *name;
-  sigset_t set, oset;
-
-  /* XXX -- can be removed after changes to handle multiple coprocs */
-#if !MULTIPLE_COPROCS
-  if (sh_coproc.c_pid != NO_PID && (sh_coproc.c_rfd >= 0 || sh_coproc.c_wfd >= 0))
-    internal_warning (_("execute_coproc: coproc [%d:%s] still exists"), sh_coproc.c_pid, sh_coproc.c_name);
-  coproc_init (&sh_coproc);
-#endif
-
-  invert = (command->flags & CMD_INVERT_RETURN) != 0;
-
-  /* expand name without splitting - could make this dependent on a shopt option */
-  name = expand_string_unsplit_to_string (command->value.Coproc->name, 0);
-  /* Optional check -- could be relaxed */
-  if (legal_identifier (name) == 0)
-    {
-      internal_error (_("`%s': not a valid identifier"), name);
-      free (name);
-      return (invert ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-    }
-  else
-    {
-      free (command->value.Coproc->name);
-      command->value.Coproc->name = name;
-    }
-
-  command_string_index = 0;
-  tcmd = make_command_string (command);
-
-  sh_openpipe ((int *)&rpipe);	/* 0 = parent read, 1 = child write */
-  sh_openpipe ((int *)&wpipe); /* 0 = child read, 1 = parent write */
-
-  BLOCK_SIGNAL (SIGCHLD, set, oset);
-
-  coproc_pid = make_child (p = savestring (tcmd), FORK_ASYNC);
-
-  if (coproc_pid == 0)
-    {
-      close (rpipe[0]);
-      close (wpipe[1]);
-
-#if defined (JOB_CONTROL)
-      FREE (p);
-#endif
-
-      UNBLOCK_SIGNAL (oset);
-      estat = execute_in_subshell (command, 1, wpipe[0], rpipe[1], fds_to_close);
-
-      fflush (stdout);
-      fflush (stderr);
-
-      exit (estat);
-    }
-
-  close (rpipe[1]);
-  close (wpipe[0]);
-
-  cp = coproc_alloc (command->value.Coproc->name, coproc_pid);
-  cp->c_rfd = rpipe[0];
-  cp->c_wfd = wpipe[1];
-
-  cp->c_flags |= COPROC_RUNNING;
-
-  SET_CLOSE_ON_EXEC (cp->c_rfd);
-  SET_CLOSE_ON_EXEC (cp->c_wfd);
-
-  coproc_setvars (cp);
-
-  UNBLOCK_SIGNAL (oset);
-
-#if 0
-  itrace ("execute_coproc (%s): [%d] %s", command->value.Coproc->name, coproc_pid, the_printed_command);
-#endif
-
-  close_pipes (pipe_in, pipe_out);
-#if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
-  unlink_fifo_list ();
-#endif
-  stop_pipeline (1, (COMMAND *)NULL);
-  DESCRIBE_PID (coproc_pid);
-  run_pending_traps ();
-
-  return (invert ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
-}
-#endif
-
-/* If S == -1, it's a special value saying to close stdin */
-static void
-restore_stdin (s)
-     int s;
-{
-  if (s == -1)
-    close (0);
-  else
-    {
-      dup2 (s, 0);
-      close (s);
-    }
-}
-
-/* Catch-all cleanup function for lastpipe code for unwind-protects */
-static void
-lastpipe_cleanup (s)
-     int s;
-{
-  set_jobs_list_frozen (s);
-}
-
-static int
-execute_pipeline (command, asynchronous, pipe_in, pipe_out, fds_to_close)
-     COMMAND *command;
-     int asynchronous, pipe_in, pipe_out;
-     struct fd_bitmap *fds_to_close;
-{
-  int prev, fildes[2], new_bitmap_size, dummyfd, ignore_return, exec_result;
-  int lstdin, lastpipe_flag, lastpipe_jid, old_frozen, stdin_valid;
-  COMMAND *cmd;
-  struct fd_bitmap *fd_bitmap;
-  pid_t lastpid;
-
-#if defined (JOB_CONTROL)
-  sigset_t set, oset;
-  BLOCK_CHILD (set, oset);
-#endif /* JOB_CONTROL */
-
-  ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
-
-  stdin_valid = sh_validfd (0);
-
-  prev = pipe_in;
-  cmd = command;
-
-  while (cmd && cmd->type == cm_connection &&
-	 cmd->value.Connection && cmd->value.Connection->connector == '|')
-    {
-      /* Make a pipeline between the two commands. */
-      if (pipe (fildes) < 0)
-	{
-	  sys_error (_("pipe error"));
-#if defined (JOB_CONTROL)
-	  terminate_current_pipeline ();
-	  kill_current_pipeline ();
-	  UNBLOCK_CHILD (oset);
-#endif /* JOB_CONTROL */
-	  last_command_exit_value = EXECUTION_FAILURE;
-	  /* The unwind-protects installed below will take care
-	     of closing all of the open file descriptors. */
-	  throw_to_top_level ();
-	  return (EXECUTION_FAILURE);	/* XXX */
-	}
-
-      /* Here is a problem: with the new file close-on-exec
-	 code, the read end of the pipe (fildes[0]) stays open
-	 in the first process, so that process will never get a
-	 SIGPIPE.  There is no way to signal the first process
-	 that it should close fildes[0] after forking, so it
-	 remains open.  No SIGPIPE is ever sent because there
-	 is still a file descriptor open for reading connected
-	 to the pipe.  We take care of that here.  This passes
-	 around a bitmap of file descriptors that must be
-	 closed after making a child process in execute_simple_command. */
-
-      /* We need fd_bitmap to be at least as big as fildes[0].
-	 If fildes[0] is less than fds_to_close->size, then
-	 use fds_to_close->size. */
-      new_bitmap_size = (fildes[0] < fds_to_close->size)
-				? fds_to_close->size
-				: fildes[0] + 8;
-
-      fd_bitmap = new_fd_bitmap (new_bitmap_size);
-
-      /* Now copy the old information into the new bitmap. */
-      xbcopy ((char *)fds_to_close->bitmap, (char *)fd_bitmap->bitmap, fds_to_close->size);
-
-      /* And mark the pipe file descriptors to be closed. */
-      fd_bitmap->bitmap[fildes[0]] = 1;
-
-      /* In case there are pipe or out-of-processes errors, we
-	 want all these file descriptors to be closed when
-	 unwind-protects are run, and the storage used for the
-	 bitmaps freed up. */
-      begin_unwind_frame ("pipe-file-descriptors");
-      add_unwind_protect (dispose_fd_bitmap, fd_bitmap);
-      add_unwind_protect (close_fd_bitmap, fd_bitmap);
-      if (prev >= 0)
-	add_unwind_protect (close, prev);
-      dummyfd = fildes[1];
-      add_unwind_protect (close, dummyfd);
-
-#if defined (JOB_CONTROL)
-      add_unwind_protect (restore_signal_mask, &oset);
-#endif /* JOB_CONTROL */
-
-      if (ignore_return && cmd->value.Connection->first)
-	cmd->value.Connection->first->flags |= CMD_IGNORE_RETURN;
-      execute_command_internal (cmd->value.Connection->first, asynchronous,
-				prev, fildes[1], fd_bitmap);
-
-      if (prev >= 0)
-	close (prev);
-
-      prev = fildes[0];
-      close (fildes[1]);
-
-      dispose_fd_bitmap (fd_bitmap);
-      discard_unwind_frame ("pipe-file-descriptors");
-
-      cmd = cmd->value.Connection->second;
-    }
-
-  lastpid = last_made_pid;
-
-  /* Now execute the rightmost command in the pipeline.  */
-  if (ignore_return && cmd)
-    cmd->flags |= CMD_IGNORE_RETURN;
-
-  lastpipe_flag = 0;
-
-  begin_unwind_frame ("lastpipe-exec");
-  lstdin = -2;		/* -1 is special, meaning fd 0 is closed */
-  /* If the `lastpipe' option is set with shopt, and job control is not
-     enabled, execute the last element of non-async pipelines in the
-     current shell environment. */
-  /* prev can be 0 if fd 0 was closed when this function was executed. prev
-     will never be 0 at this point if fd 0 was valid when this function was
-     executed (though we check above). */
-  if (lastpipe_opt && job_control == 0 && asynchronous == 0 && pipe_out == NO_PIPE && prev >= 0)
-    {
-      /* -1 is a special value meaning to close stdin */
-      lstdin = (prev > 0 && stdin_valid) ? move_to_high_fd (0, 1, -1) : -1;
-      if (lstdin > 0 || lstdin == -1)
-	{
-	  do_piping (prev, pipe_out);
-	  prev = NO_PIPE;
-	  add_unwind_protect (restore_stdin, lstdin);
-	  lastpipe_flag = 1;
-	  old_frozen = freeze_jobs_list ();
-	  lastpipe_jid = stop_pipeline (0, (COMMAND *)NULL);	/* XXX */
-	  add_unwind_protect (lastpipe_cleanup, old_frozen);
-#if defined (JOB_CONTROL)
-	  UNBLOCK_CHILD (oset);		/* XXX */
-#endif
-	}
-      if (cmd)
-	cmd->flags |= CMD_LASTPIPE;
-    }	  
-  if (prev >= 0)
-    add_unwind_protect (close, prev);
-
-  exec_result = execute_command_internal (cmd, asynchronous, prev, pipe_out, fds_to_close);
-
-  if (prev >= 0)
-    close (prev);
-
-  if (lstdin > 0 || lstdin == -1)
-    restore_stdin (lstdin);
-
-#if defined (JOB_CONTROL)
-  UNBLOCK_CHILD (oset);
-#endif
-
-  QUIT;
-
-  if (lastpipe_flag)
-    {
-#if defined (JOB_CONTROL)
-      if (INVALID_JOB (lastpipe_jid) == 0)
-        {
-          append_process (savestring (the_printed_command_except_trap), dollar_dollar_pid, exec_result, lastpipe_jid);
-          lstdin = wait_for (lastpid, 0);
-        }
-      else
-	{
-	  lstdin = wait_for_single_pid (lastpid, 0);		/* checks bgpids list */
-	  if (lstdin > 256)		/* error sentinel */
-	    lstdin = 127;
-	}
-#else
-      lstdin = wait_for (lastpid, 0);
-#endif
-
-#if defined (JOB_CONTROL)
-      /* If wait_for removes the job from the jobs table, use result of last
-	 command as pipeline's exit status as usual.  The jobs list can get
-	 frozen and unfrozen at inconvenient times if there are multiple pipelines
-	 running simultaneously. */
-      if (INVALID_JOB (lastpipe_jid) == 0)
-	exec_result = job_exit_status (lastpipe_jid);
-      else if (pipefail_opt)
-	exec_result = exec_result | lstdin;	/* XXX */
-      /* otherwise we use exec_result */
-#endif
-
-      set_jobs_list_frozen (old_frozen);
-    }
-
-  discard_unwind_frame ("lastpipe-exec");
-
-  return (exec_result);
-}
-
-static int
-execute_connection (command, asynchronous, pipe_in, pipe_out, fds_to_close)
-     COMMAND *command;
-     int asynchronous, pipe_in, pipe_out;
-     struct fd_bitmap *fds_to_close;
-{
-  COMMAND *tc, *second;
-  int ignore_return, exec_result, was_error_trap, invert;
-  volatile int save_line_number;
-
-  ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
-
-  switch (command->value.Connection->connector)
-    {
-    /* Do the first command asynchronously. */
-    case '&':
-      tc = command->value.Connection->first;
-      if (tc == 0)
-	return (EXECUTION_SUCCESS);
-
-      if (ignore_return)
-	tc->flags |= CMD_IGNORE_RETURN;
-      tc->flags |= CMD_AMPERSAND;
-
-      /* If this shell was compiled without job control support,
-	 if we are currently in a subshell via `( xxx )', or if job
-	 control is not active then the standard input for an
-	 asynchronous command is forced to /dev/null. */
-#if defined (JOB_CONTROL)
-      if ((subshell_environment || !job_control) && !stdin_redir)
-#else
-      if (!stdin_redir)
-#endif /* JOB_CONTROL */
-	tc->flags |= CMD_STDIN_REDIR;
-
-      exec_result = execute_command_internal (tc, 1, pipe_in, pipe_out, fds_to_close);
-      QUIT;
-
-      if (tc->flags & CMD_STDIN_REDIR)
-	tc->flags &= ~CMD_STDIN_REDIR;
-
-      second = command->value.Connection->second;
-      if (second)
-	{
-	  if (ignore_return)
-	    second->flags |= CMD_IGNORE_RETURN;
-
-	  exec_result = execute_command_internal (second, asynchronous, pipe_in, pipe_out, fds_to_close);
-	}
-
-      break;
-
-    /* Just call execute command on both sides. */
-    case ';':
-    case '\n':		/* special case, happens in command substitutions */
-      if (ignore_return)
-	{
-	  if (command->value.Connection->first)
-	    command->value.Connection->first->flags |= CMD_IGNORE_RETURN;
-	  if (command->value.Connection->second)
-	    command->value.Connection->second->flags |= CMD_IGNORE_RETURN;
-	}
-      executing_list++;
-      QUIT;
-
-#if 1
-      execute_command (command->value.Connection->first);
-#else
-      execute_command_internal (command->value.Connection->first,
-				  asynchronous, pipe_in, pipe_out,
-				  fds_to_close);
-#endif
-
-      QUIT;
-      optimize_connection_fork (command);			/* XXX */
-      exec_result = execute_command_internal (command->value.Connection->second,
-				      asynchronous, pipe_in, pipe_out,
-				      fds_to_close);
-      executing_list--;
-      break;
-
-    case '|':
-      was_error_trap = signal_is_trapped (ERROR_TRAP) && signal_is_ignored (ERROR_TRAP) == 0;
-      invert = (command->flags & CMD_INVERT_RETURN) != 0;
-      ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
-
-      SET_LINE_NUMBER (line_number);	/* XXX - save value? */
-      exec_result = execute_pipeline (command, asynchronous, pipe_in, pipe_out, fds_to_close);
-
-      if (asynchronous)
-	{
-	  exec_result = EXECUTION_SUCCESS;
-	  invert = 0;
-	}
-
-      if (was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
-	{
-	  last_command_exit_value = exec_result;
-	  save_line_number = line_number;
-	  line_number = line_number_for_err_trap;
-	  run_error_trap ();
-	  line_number = save_line_number;
-	}
-
-      if (ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
-	{
-	  last_command_exit_value = exec_result;
-	  run_pending_traps ();
-	  jump_to_top_level (ERREXIT);
-	}
-
-      break;
-
-    case AND_AND:
-    case OR_OR:
-      if (asynchronous)
-	{
-	  /* If we have something like `a && b &' or `a || b &', run the
-	     && or || stuff in a subshell.  Force a subshell and just call
-	     execute_command_internal again.  Leave asynchronous on
-	     so that we get a report from the parent shell about the
-	     background job. */
-	  command->flags |= CMD_FORCE_SUBSHELL;
-	  exec_result = execute_command_internal (command, 1, pipe_in, pipe_out, fds_to_close);
-	  break;
-	}
-
-      /* Execute the first command.  If the result of that is successful
-	 and the connector is AND_AND, or the result is not successful
-	 and the connector is OR_OR, then execute the second command,
-	 otherwise return. */
-
-      executing_list++;
-      if (command->value.Connection->first)
-	command->value.Connection->first->flags |= CMD_IGNORE_RETURN;
-
-#if 1
-      exec_result = execute_command (command->value.Connection->first);
-#else
-      exec_result = execute_command_internal (command->value.Connection->first, 0, NO_PIPE, NO_PIPE, fds_to_close);
-#endif
-      QUIT;
-      if (((command->value.Connection->connector == AND_AND) &&
-	   (exec_result == EXECUTION_SUCCESS)) ||
-	  ((command->value.Connection->connector == OR_OR) &&
-	   (exec_result != EXECUTION_SUCCESS)))
-	{
-	  optimize_connection_fork (command);
-
-	  second = command->value.Connection->second;
-	  if (ignore_return && second)
-	    second->flags |= CMD_IGNORE_RETURN;
-
-	  exec_result = execute_command (second);
-	}
-      executing_list--;
-      break;
-
-    default:
-      command_error ("execute_connection", CMDERR_BADCONN, command->value.Connection->connector, 0);
-      jump_to_top_level (DISCARD);
-      exec_result = EXECUTION_FAILURE;
-    }
-
-  return exec_result;
-}
-
-/* The test used to be only for interactive_shell, but we don't want to report
-   job status when the shell is not interactive or when job control isn't
-   enabled. */
-#define REAP() \
-  do \
-    { \
-      if (job_control == 0 || interactive_shell == 0) \
-	reap_dead_jobs (); \
-    } \
-  while (0)
-
-/* Execute a FOR command.  The syntax is: FOR word_desc IN word_list;
-   DO command; DONE */
-static int
-execute_for_command (for_command)
-     FOR_COM *for_command;
-{
-  register WORD_LIST *releaser, *list;
-  SHELL_VAR *v;
-  char *identifier;
-  int retval, save_line_number;
-#if 0
-  SHELL_VAR *old_value = (SHELL_VAR *)NULL; /* Remember the old value of x. */
-#endif
-
-  save_line_number = line_number;
-  if (check_identifier (for_command->name, 1) == 0)
-    {
-      if (posixly_correct && interactive_shell == 0)
-	{
-	  last_command_exit_value = EX_BADUSAGE;
-	  jump_to_top_level (ERREXIT);
-	}
-      return (EXECUTION_FAILURE);
-    }
-
-  loop_level++;
-  identifier = for_command->name->word;
-
-  line_number = for_command->line;	/* for expansion error messages */
-  list = releaser = expand_words_no_vars (for_command->map_list);
-
-  begin_unwind_frame ("for");
-  add_unwind_protect (dispose_words, releaser);
-
-#if 0
-  if (lexical_scoping)
-    {
-      old_value = copy_variable (find_variable (identifier));
-      if (old_value)
-	add_unwind_protect (dispose_variable, old_value);
-    }
-#endif
-
-  if (for_command->flags & CMD_IGNORE_RETURN)
-    for_command->action->flags |= CMD_IGNORE_RETURN;
-
-  for (retval = EXECUTION_SUCCESS; list; list = list->next)
-    {
-      QUIT;
-
-      line_number = for_command->line;
-
-      /* Remember what this command looks like, for debugger. */
-      command_string_index = 0;
-      print_for_command_head (for_command);
-
-      if (echo_command_at_execute)
-	xtrace_print_for_command_head (for_command);
-
-      /* Save this command unless it's a trap command and we're not running
-	 a debug trap. */
-      if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
-	{
-	  FREE (the_printed_command_except_trap);
-	  the_printed_command_except_trap = savestring (the_printed_command);
-	}
-
-      retval = run_debug_trap ();
-#if defined (DEBUGGER)
-      /* In debugging mode, if the DEBUG trap returns a non-zero status, we
-	 skip the command. */
-      if (debugging_mode && retval != EXECUTION_SUCCESS)
-        continue;
-#endif
-
-      this_command_name = (char *)NULL;
-      /* XXX - special ksh93 for command index variable handling */
-      v = find_variable_last_nameref (identifier, 1);
-      if (v && nameref_p (v))
-	{
-	  if (valid_nameref_value (list->word->word, 1) == 0)
-	    {
-	      sh_invalidid (list->word->word);
-	      v = 0;
-	    }
-	  else if (readonly_p (v))
-	    err_readonly (name_cell (v));
-	  else
-	    v = bind_variable_value (v, list->word->word, ASS_NAMEREF);
-	}
-      else
-	v = bind_variable (identifier, list->word->word, 0);
-
-      if (v == 0 || readonly_p (v) || noassign_p (v))
-	{
-	  line_number = save_line_number;
-	  if (v && readonly_p (v) && interactive_shell == 0 && posixly_correct)
-	    {
-	      last_command_exit_value = EXECUTION_FAILURE;
-	      jump_to_top_level (FORCE_EOF);
-	    }
-	  else
-	    {
-	      dispose_words (releaser);
-	      discard_unwind_frame ("for");
-	      loop_level--;
-	      return (EXECUTION_FAILURE);
-	    }
-	}
-
-      if (ifsname (identifier))
-	setifs (v);
-      else
-	stupidly_hack_special_variables (identifier);
-
-      retval = execute_command (for_command->action);
-      REAP ();
-      QUIT;
-
-      if (breaking)
-	{
-	  breaking--;
-	  break;
-	}
-
-      if (continuing)
-	{
-	  continuing--;
-	  if (continuing)
-	    break;
-	}
-    }
-
-  loop_level--;
-  line_number = save_line_number;
-
-#if 0
-  if (lexical_scoping)
-    {
-      if (!old_value)
-        unbind_variable (identifier);
-      else
-	{
-	  SHELL_VAR *new_value;
-
-	  new_value = bind_variable (identifier, value_cell (old_value), 0);
-	  new_value->attributes = old_value->attributes;
-	  dispose_variable (old_value);
-	}
-    }
-#endif
-
-  dispose_words (releaser);
-  discard_unwind_frame ("for");
-  return (retval);
-}
-
-#if defined (ARITH_FOR_COMMAND)
-/* Execute an arithmetic for command.  The syntax is
-
-	for (( init ; step ; test ))
-	do
-		body
-	done
-
-   The execution should be exactly equivalent to
-
-	eval \(\( init \)\)
-	while eval \(\( test \)\) ; do
-		body;
-		eval \(\( step \)\)
-	done
-*/
-static intmax_t
-eval_arith_for_expr (l, okp)
-     WORD_LIST *l;
-     int *okp;
-{
-  WORD_LIST *new;
-  intmax_t expresult;
-  int r, eflag;
-  char *expr, *temp;
-
-  expr = l->next ? string_list (l) : l->word->word;
-  temp = expand_arith_string (expr, Q_DOUBLE_QUOTES|Q_ARITH);
-  if (l->next)
-    free (expr);
-  new = make_word_list (make_word (temp), (WORD_LIST *)NULL);
-  free (temp);
-
-  if (new)
-    {
-      if (echo_command_at_execute)
-	xtrace_print_arith_cmd (new);
-
-      command_string_index = 0;
-      print_arith_command (new);
-      if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
-	{
-	  FREE (the_printed_command_except_trap);
-	  the_printed_command_except_trap = savestring (the_printed_command);
-	}
-
-      r = run_debug_trap ();
-      /* In debugging mode, if the DEBUG trap returns a non-zero status, we
-	 skip the command. */
-      eflag = (shell_compatibility_level > 51) ? 0 : EXP_EXPANDED;
-      this_command_name = "((";		/* )) for expression error messages */
-      
-#if defined (DEBUGGER)
-      if (debugging_mode == 0 || r == EXECUTION_SUCCESS)
-	expresult = evalexp (new->word->word, eflag, okp);
-      else
-	{
-	  expresult = 0;
-	  if (okp)
-	    *okp = 1;
-	}
-#else
-      expresult = evalexp (new->word->word, eflag, okp);
-#endif
-      dispose_words (new);
-    }
-  else
-    {
-      expresult = 0;
-      if (okp)
-	*okp = 1;
-    }
-  return (expresult);
-}
-
-static int
-execute_arith_for_command (arith_for_command)
-     ARITH_FOR_COM *arith_for_command;
-{
-  intmax_t expresult;
-  int expok, body_status, arith_lineno, save_lineno;
-
-  body_status = EXECUTION_SUCCESS;
-  loop_level++;
-  save_lineno = line_number;
-
-  if (arith_for_command->flags & CMD_IGNORE_RETURN)
-    arith_for_command->action->flags |= CMD_IGNORE_RETURN;
-
-  this_command_name = "((";	/* )) for expression error messages */
-
-  /* save the starting line number of the command so we can reset
-     line_number before executing each expression -- for $LINENO
-     and the DEBUG trap. */
-  line_number = arith_lineno = arith_for_command->line;
-  if (variable_context && interactive_shell && sourcelevel == 0)
-    {
-      /* line numbers in a function start at 1 */
-      line_number -= function_line_number - 1;
-      if (line_number <= 0)
-	line_number = 1;
-    }
-
-  /* Evaluate the initialization expression. */
-  expresult = eval_arith_for_expr (arith_for_command->init, &expok);
-  if (expok == 0)
-    {
-      line_number = save_lineno;
-      return (EXECUTION_FAILURE);
-    }
-
-  while (1)
-    {
-      /* Evaluate the test expression. */
-      line_number = arith_lineno;
-      expresult = eval_arith_for_expr (arith_for_command->test, &expok);
-      line_number = save_lineno;
-
-      if (expok == 0)
-	{
-	  body_status = EXECUTION_FAILURE;
-	  break;
-	}
-      REAP ();
-      if (expresult == 0)
-	break;
-
-      /* Execute the body of the arithmetic for command. */
-      QUIT;
-      body_status = execute_command (arith_for_command->action);
-      QUIT;
-
-      /* Handle any `break' or `continue' commands executed by the body. */
-      if (breaking)
-	{
-	  breaking--;
-	  break;
-	}
-
-      if (continuing)
-	{
-	  continuing--;
-	  if (continuing)
-	    break;
-	}
-
-      /* Evaluate the step expression. */
-      line_number = arith_lineno;
-      expresult = eval_arith_for_expr (arith_for_command->step, &expok);
-      line_number = save_lineno;
-
-      if (expok == 0)
-	{
-	  body_status = EXECUTION_FAILURE;
-	  break;
-	}
-    }
-
-  loop_level--;
-  line_number = save_lineno;
-
-  return (body_status);
-}
-#endif
-
-#if defined (SELECT_COMMAND)
-static int LINES, COLS, tabsize;
-
-#define RP_SPACE ") "
-#define RP_SPACE_LEN 2
-
-/* XXX - does not handle numbers > 1000000 at all. */
-#define NUMBER_LEN(s) \
-((s < 10) ? 1 \
-	  : ((s < 100) ? 2 \
-		      : ((s < 1000) ? 3 \
-				   : ((s < 10000) ? 4 \
-						 : ((s < 100000) ? 5 \
-								: 6)))))
-
-static int
-displen (s)
-     const char *s;
-{
-#if defined (HANDLE_MULTIBYTE)
-  wchar_t *wcstr;
-  size_t slen;
-  int wclen;
-
-  wcstr = 0;
-  slen = mbstowcs (wcstr, s, 0);
-  if (slen == -1)
-    slen = 0;
-  wcstr = (wchar_t *)xmalloc (sizeof (wchar_t) * (slen + 1));
-  mbstowcs (wcstr, s, slen + 1);
-  wclen = wcswidth (wcstr, slen);
-  free (wcstr);
-  return (wclen < 0 ? STRLEN(s) : wclen);
-#else
-  return (STRLEN (s));
-#endif
-}
-
-static int
-print_index_and_element (len, ind, list)
-      int len, ind;
-      WORD_LIST *list;
-{
-  register WORD_LIST *l;
-  register int i;
-
-  if (list == 0)
-    return (0);
-  for (i = ind, l = list; l && --i; l = l->next)
-    ;
-  if (l == 0)		/* don't think this can happen */
-    return (0);
-  fprintf (stderr, "%*d%s%s", len, ind, RP_SPACE, l->word->word);
-  return (displen (l->word->word));
-}
-
-static void
-indent (from, to)
-     int from, to;
-{
-  while (from < to)
-    {
-      if ((to / tabsize) > (from / tabsize))
-	{
-	  putc ('\t', stderr);
-	  from += tabsize - from % tabsize;
-	}
-      else
-	{
-	  putc (' ', stderr);
-	  from++;
-	}
-    }
-}
-
-static void
-print_select_list (list, list_len, max_elem_len, indices_len)
-     WORD_LIST *list;
-     int list_len, max_elem_len, indices_len;
-{
-  int ind, row, elem_len, pos, cols, rows;
-  int first_column_indices_len, other_indices_len;
-
-  if (list == 0)
-    {
-      putc ('\n', stderr);
-      return;
-    }
-
-  cols = max_elem_len ? COLS / max_elem_len : 1;
-  if (cols == 0)
-    cols = 1;
-  rows = list_len ? list_len / cols + (list_len % cols != 0) : 1;
-  cols = list_len ? list_len / rows + (list_len % rows != 0) : 1;
-
-  if (rows == 1)
-    {
-      rows = cols;
-      cols = 1;
-    }
-
-  first_column_indices_len = NUMBER_LEN (rows);
-  other_indices_len = indices_len;
-
-  for (row = 0; row < rows; row++)
-    {
-      ind = row;
-      pos = 0;
-      while (1)
-	{
-	  indices_len = (pos == 0) ? first_column_indices_len : other_indices_len;
-	  elem_len = print_index_and_element (indices_len, ind + 1, list);
-	  elem_len += indices_len + RP_SPACE_LEN;
-	  ind += rows;
-	  if (ind >= list_len)
-	    break;
-	  indent (pos + elem_len, pos + max_elem_len);
-	  pos += max_elem_len;
-	}
-      putc ('\n', stderr);
-    }
-}
-
-/* Print the elements of LIST, one per line, preceded by an index from 1 to
-   LIST_LEN.  Then display PROMPT and wait for the user to enter a number.
-   If the number is between 1 and LIST_LEN, return that selection.  If EOF
-   is read, return a null string.  If a blank line is entered, or an invalid
-   number is entered, the loop is executed again. */
-static char *
-select_query (list, list_len, prompt, print_menu)
-     WORD_LIST *list;
-     int list_len;
-     char *prompt;
-     int print_menu;
-{
-  int max_elem_len, indices_len, len, r, oe;
-  intmax_t reply;
-  WORD_LIST *l;
-  char *repl_string, *t;
-
-  COLS = default_columns ();
-
-#if 0
-  t = get_string_value ("TABSIZE");
-  tabsize = (t && *t) ? atoi (t) : 8;
-  if (tabsize <= 0)
-    tabsize = 8;
-#else
-  tabsize = 8;
-#endif
-
-  max_elem_len = 0;
-  for (l = list; l; l = l->next)
-    {
-      len = displen (l->word->word);
-      if (len > max_elem_len)
-	max_elem_len = len;
-    }
-  indices_len = NUMBER_LEN (list_len);
-  max_elem_len += indices_len + RP_SPACE_LEN + 2;
-
-  while (1)
-    {
-      if (print_menu)
-	print_select_list (list, list_len, max_elem_len, indices_len);
-      fprintf (stderr, "%s", prompt);
-      fflush (stderr);
-      QUIT;
-
-      oe = executing_builtin;
-      executing_builtin = 1;
-      r = read_builtin ((WORD_LIST *)NULL);
-      executing_builtin = oe;
-      if (r != EXECUTION_SUCCESS)
-	{
-	  putchar ('\n');
-	  return ((char *)NULL);
-	}
-      repl_string = get_string_value ("REPLY");
-      if (repl_string == 0)
-	return ((char *)NULL);
-      if (*repl_string == 0)
-	{
-	  print_menu = 1;
-	  continue;
-	}
-      if (legal_number (repl_string, &reply) == 0)
-	return "";
-      if (reply < 1 || reply > list_len)
-	return "";
-
-      for (l = list; l && --reply; l = l->next)
-	;
-      return (l->word->word);		/* XXX - can't be null? */
-    }
-}
-
-/* Execute a SELECT command.  The syntax is:
-   SELECT word IN list DO command_list DONE
-   Only `break' or `return' in command_list will terminate
-   the command. */
-static int
-execute_select_command (select_command)
-     SELECT_COM *select_command;
-{
-  WORD_LIST *releaser, *list;
-  SHELL_VAR *v;
-  char *identifier, *ps3_prompt, *selection;
-  int retval, list_len, show_menu, save_line_number;
-
-  if (check_identifier (select_command->name, 1) == 0)
-    return (EXECUTION_FAILURE);
-
-  save_line_number = line_number;
-  line_number = select_command->line;
-
-  command_string_index = 0;
-  print_select_command_head (select_command);
-
-  if (echo_command_at_execute)
-    xtrace_print_select_command_head (select_command);
-
-#if 0
-  if (signal_in_progress (DEBUG_TRAP) == 0 && (this_command_name == 0 || (STREQ (this_command_name, "trap") == 0)))
-#else
-  if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
-#endif
-    {
-      FREE (the_printed_command_except_trap);
-      the_printed_command_except_trap = savestring (the_printed_command);
-    }
-
-  retval = run_debug_trap ();
-#if defined (DEBUGGER)
-  /* In debugging mode, if the DEBUG trap returns a non-zero status, we
-     skip the command. */
-  if (debugging_mode && retval != EXECUTION_SUCCESS)
-    return (EXECUTION_SUCCESS);
-#endif
-
-  this_command_name = (char *)0;
-
-  loop_level++;
-  identifier = select_command->name->word;
-
-  /* command and arithmetic substitution, parameter and variable expansion,
-     word splitting, pathname expansion, and quote removal. */
-  list = releaser = expand_words_no_vars (select_command->map_list);
-  list_len = list_length (list);
-  if (list == 0 || list_len == 0)
-    {
-      if (list)
-	dispose_words (list);
-      line_number = save_line_number;
-      return (EXECUTION_SUCCESS);
-    }
-
-  begin_unwind_frame ("select");
-  add_unwind_protect (dispose_words, releaser);
-
-  if (select_command->flags & CMD_IGNORE_RETURN)
-    select_command->action->flags |= CMD_IGNORE_RETURN;
-
-  retval = EXECUTION_SUCCESS;
-  show_menu = 1;
-
-  while (1)
-    {
-      line_number = select_command->line;
-      ps3_prompt = get_string_value ("PS3");
-      if (ps3_prompt == 0)
-	ps3_prompt = "#? ";
-
-      QUIT;
-      selection = select_query (list, list_len, ps3_prompt, show_menu);
-      QUIT;
-      if (selection == 0)
-	{
-	  /* select_query returns EXECUTION_FAILURE if the read builtin
-	     fails, so we want to return failure in this case. */
-	  retval = EXECUTION_FAILURE;
-	  break;
-	}
-
-      v = bind_variable (identifier, selection, 0);
-      if (v == 0 || readonly_p (v) || noassign_p (v))
-	{
-	  if (v && readonly_p (v) && interactive_shell == 0 && posixly_correct)
-	    {
-	      last_command_exit_value = EXECUTION_FAILURE;
-	      jump_to_top_level (FORCE_EOF);
-	    }
-	  else
-	    {
-	      dispose_words (releaser);
-	      discard_unwind_frame ("select");
-	      loop_level--;
-	      line_number = save_line_number;
-	      return (EXECUTION_FAILURE);
-	    }
-	}
-
-      stupidly_hack_special_variables (identifier);
-
-      retval = execute_command (select_command->action);
-
-      REAP ();
-      QUIT;
-
-      if (breaking)
-	{
-	  breaking--;
-	  break;
-	}
-
-      if (continuing)
-	{
-	  continuing--;
-	  if (continuing)
-	    break;
-	}
-
-#if defined (KSH_COMPATIBLE_SELECT)
-      show_menu = 0;
-      selection = get_string_value ("REPLY");
-      if (selection && *selection == '\0')
-        show_menu = 1;
-#endif
-    }
-
-  loop_level--;
-  line_number = save_line_number;
-
-  dispose_words (releaser);
-  discard_unwind_frame ("select");
-  return (retval);
-}
-#endif /* SELECT_COMMAND */
-
-/* Execute a CASE command.  The syntax is: CASE word_desc IN pattern_list ESAC.
-   The pattern_list is a linked list of pattern clauses; each clause contains
-   some patterns to compare word_desc against, and an associated command to
-   execute. */
-static int
-execute_case_command (case_command)
-     CASE_COM *case_command;
-{
-  register WORD_LIST *list;
-  WORD_LIST *wlist, *es;
-  PATTERN_LIST *clauses;
-  char *word, *pattern;
-  int retval, match, ignore_return, save_line_number, qflags;
-
-  save_line_number = line_number;
-  line_number = case_command->line;
-
-  command_string_index = 0;
-  print_case_command_head (case_command);
-
-  if (echo_command_at_execute)
-    xtrace_print_case_command_head (case_command);
-
-#if 0
-  if (signal_in_progress (DEBUG_TRAP) == 0 && (this_command_name == 0 || (STREQ (this_command_name, "trap") == 0)))
-#else
-  if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
-#endif
-    {
-      FREE (the_printed_command_except_trap);
-      the_printed_command_except_trap = savestring (the_printed_command);
-    }
-
-  retval = run_debug_trap();
-#if defined (DEBUGGER)
-  /* In debugging mode, if the DEBUG trap returns a non-zero status, we
-     skip the command. */
-  if (debugging_mode && retval != EXECUTION_SUCCESS)
-    {
-      line_number = save_line_number;
-      return (EXECUTION_SUCCESS);
-    }
-#endif
-
-  /* Use the same expansions (the ones POSIX specifies) as the patterns;
-     dequote the resulting string (as POSIX specifies) since the quotes in
-     patterns are handled specially below. We have to do it in this order
-     because we're not supposed to perform word splitting. */
-  wlist = expand_word_leave_quoted (case_command->word, 0);
-  if (wlist)
-    {
-      char *t;
-      t = string_list (wlist);
-      word = dequote_string (t);
-      free (t);
-    }
-  else
-    word = savestring ("");
-  dispose_words (wlist);
-
-  retval = EXECUTION_SUCCESS;
-  ignore_return = case_command->flags & CMD_IGNORE_RETURN;
-
-  begin_unwind_frame ("case");
-  add_unwind_protect (xfree, word);
-
-#define EXIT_CASE()  goto exit_case_command
-
-  for (clauses = case_command->clauses; clauses; clauses = clauses->next)
-    {
-      QUIT;
-      for (list = clauses->patterns; list; list = list->next)
-	{
-	  es = expand_word_leave_quoted (list->word, 0);
-
-	  if (es && es->word && es->word->word && *(es->word->word))
-	    {
-	      /* Convert quoted null strings into empty strings. */
-	      qflags = QGLOB_CVTNULL;
-
-	      /* We left CTLESC in place quoting CTLESC and CTLNUL after the
-	      	 call to expand_word_leave_quoted; tell quote_string_for_globbing
-	      	 to remove those here. This works for both unquoted portions of
-		 the word (which call quote_escapes) and quoted portions
-		 (which call quote_string). */
-	      qflags |= QGLOB_CTLESC;
-	      pattern = quote_string_for_globbing (es->word->word, qflags);
-	    }
-	  else
-	    {
-	      pattern = (char *)xmalloc (1);
-	      pattern[0] = '\0';
-	    }
-
-	  /* Since the pattern does not undergo quote removal (as per
-	     Posix.2, section 3.9.4.3), the strmatch () call must be able
-	     to recognize backslashes as escape characters. */
-	  match = strmatch (pattern, word, FNMATCH_EXTFLAG|FNMATCH_IGNCASE) != FNM_NOMATCH;
-	  free (pattern);
-
-	  dispose_words (es);
-
-	  if (match)
-	    {
-	      do
-		{
-		  if (clauses->action && ignore_return)
-		    clauses->action->flags |= CMD_IGNORE_RETURN;
-		  retval = execute_command (clauses->action);
-		}
-	      while ((clauses->flags & CASEPAT_FALLTHROUGH) && (clauses = clauses->next));
-	      if (clauses == 0 || (clauses->flags & CASEPAT_TESTNEXT) == 0)
-		EXIT_CASE ();
-	      else
-		break;
-	    }
-
-	  QUIT;
-	}
-    }
-
-exit_case_command:
-  free (word);
-  discard_unwind_frame ("case");
-  line_number = save_line_number;
-  return (retval);
-}
-
-#define CMD_WHILE 0
-#define CMD_UNTIL 1
-
-/* The WHILE command.  Syntax: WHILE test DO action; DONE.
-   Repeatedly execute action while executing test produces
-   EXECUTION_SUCCESS. */
-static int
-execute_while_command (while_command)
-     WHILE_COM *while_command;
-{
-  return (execute_while_or_until (while_command, CMD_WHILE));
-}
-
-/* UNTIL is just like WHILE except that the test result is negated. */
-static int
-execute_until_command (while_command)
-     WHILE_COM *while_command;
-{
-  return (execute_while_or_until (while_command, CMD_UNTIL));
-}
-
-/* The body for both while and until.  The only difference between the
-   two is that the test value is treated differently.  TYPE is
-   CMD_WHILE or CMD_UNTIL.  The return value for both commands should
-   be EXECUTION_SUCCESS if no commands in the body are executed, and
-   the status of the last command executed in the body otherwise. */
-static int
-execute_while_or_until (while_command, type)
-     WHILE_COM *while_command;
-     int type;
-{
-  int return_value, body_status;
-
-  body_status = EXECUTION_SUCCESS;
-  loop_level++;
-
-  while_command->test->flags |= CMD_IGNORE_RETURN;
-  if (while_command->flags & CMD_IGNORE_RETURN)
-    while_command->action->flags |= CMD_IGNORE_RETURN;
-
-  while (1)
-    {
-      return_value = execute_command (while_command->test);
-      REAP ();
-
-      /* Need to handle `break' in the test when we would break out of the
-         loop.  The job control code will set `breaking' to loop_level
-         when a job in a loop is stopped with SIGTSTP.  If the stopped job
-         is in the loop test, `breaking' will not be reset unless we do
-         this, and the shell will cease to execute commands.  The same holds
-         true for `continue'. */
-      if (type == CMD_WHILE && return_value != EXECUTION_SUCCESS)
-	{
-	  if (breaking)
-	    breaking--;
-	  if (continuing)
-	    continuing--;
-	  break;
-	}
-      if (type == CMD_UNTIL && return_value == EXECUTION_SUCCESS)
-	{
-	  if (breaking)
-	    breaking--;
-	  if (continuing)
-	    continuing--;
-	  break;
-	}
-
-      QUIT;
-      body_status = execute_command (while_command->action);
-      QUIT;
-
-      if (breaking)
-	{
-	  breaking--;
-	  break;
-	}
-
-      if (continuing)
-	{
-	  continuing--;
-	  if (continuing)
-	    break;
-	}
-    }
-  loop_level--;
-
-  return (body_status);
-}
-
-/* IF test THEN command [ELSE command].
-   IF also allows ELIF in the place of ELSE IF, but
-   the parser makes *that* stupidity transparent. */
-static int
-execute_if_command (if_command)
-     IF_COM *if_command;
-{
-  int return_value, save_line_number;
-
-  save_line_number = line_number;
-  if_command->test->flags |= CMD_IGNORE_RETURN;
-  return_value = execute_command (if_command->test);
-  line_number = save_line_number;
-
-  if (return_value == EXECUTION_SUCCESS)
-    {
-      QUIT;
-
-      if (if_command->true_case && (if_command->flags & CMD_IGNORE_RETURN))
-	if_command->true_case->flags |= CMD_IGNORE_RETURN;
-
-      return (execute_command (if_command->true_case));
-    }
-  else
-    {
-      QUIT;
-
-      if (if_command->false_case && (if_command->flags & CMD_IGNORE_RETURN))
-	if_command->false_case->flags |= CMD_IGNORE_RETURN;
-
-      return (execute_command (if_command->false_case));
-    }
-}
-
-#if defined (DPAREN_ARITHMETIC)
-static int
-execute_arith_command (arith_command)
-     ARITH_COM *arith_command;
-{
-  int expok, save_line_number, retval, eflag;
-  intmax_t expresult;
-  WORD_LIST *new;
-  char *exp, *t;
-
-  expresult = 0;
-
-  save_line_number = line_number;
-  this_command_name = "((";	/* )) */
-  SET_LINE_NUMBER (arith_command->line);
-  /* If we're in a function, update the line number information. */
-  if (variable_context && interactive_shell && sourcelevel == 0)
-    {
-      /* line numbers in a function start at 1 */
-      line_number -= function_line_number - 1;
-      if (line_number <= 0)
-	line_number = 1;
-    }      
-
-  command_string_index = 0;
-  print_arith_command (arith_command->exp);
-
-  if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
-    {
-      FREE (the_printed_command_except_trap);
-      the_printed_command_except_trap = savestring (the_printed_command);
-    }
-
-  /* Run the debug trap before each arithmetic command, but do it after we
-     update the line number information and before we expand the various
-     words in the expression. */
-  retval = run_debug_trap ();
-#if defined (DEBUGGER)
-  /* In debugging mode, if the DEBUG trap returns a non-zero status, we
-     skip the command. */
-  if (debugging_mode && retval != EXECUTION_SUCCESS)
-    {
-      line_number = save_line_number;
-      return (EXECUTION_SUCCESS);
-    }
-#endif
-
-  this_command_name = "((";	/* )) */
-  t = (char *)NULL;
-  new = arith_command->exp;
-  exp = (new->next) ? (t = string_list (new)) : new->word->word;
-
-  exp = expand_arith_string (exp, Q_DOUBLE_QUOTES|Q_ARITH);
-  FREE (t);
-
-  /* If we're tracing, make a new word list with `((' at the front and `))'
-     at the back and print it. Change xtrace_print_arith_cmd to take a string
-     when I change eval_arith_for_expr to use expand_arith_string(). */
-  if (echo_command_at_execute)
-    {
-      new = make_word_list (make_word (exp ? exp : ""), (WORD_LIST *)NULL);
-      xtrace_print_arith_cmd (new);
-      dispose_words (new);
-    }
-
-  if (exp)
-    {
-      eflag = (shell_compatibility_level > 51) ? 0 : EXP_EXPANDED;
-      expresult = evalexp (exp, eflag, &expok);
-      line_number = save_line_number;
-      free (exp);
-    }
-  else
-    {
-      expresult = 0;
-      expok = 1;
-    }
-
-  if (expok == 0)
-    return (EXECUTION_FAILURE);
-
-  return (expresult == 0 ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
-}
-#endif /* DPAREN_ARITHMETIC */
-
-#if defined (COND_COMMAND)
-
-static char * const nullstr = "";
-
-/* XXX - can COND ever be NULL when this is called? */
-static int
-execute_cond_node (cond)
-     COND_COM *cond;
-{
-  int result, invert, patmatch, rmatch, arith, mode, mflags, ignore;
-  char *arg1, *arg2, *op;
-#if 0
-  char *t1, *t2;
-#endif
-
-  invert = (cond->flags & CMD_INVERT_RETURN);
-  ignore = (cond->flags & CMD_IGNORE_RETURN);
-  if (ignore)
-    {
-      if (cond->left)
-	cond->left->flags |= CMD_IGNORE_RETURN;
-      if (cond->right)
-	cond->right->flags |= CMD_IGNORE_RETURN;
-    }
-      
-  if (cond->type == COND_EXPR)
-    result = execute_cond_node (cond->left);
-  else if (cond->type == COND_OR)
-    {
-      result = execute_cond_node (cond->left);
-      if (result != EXECUTION_SUCCESS)
-	result = execute_cond_node (cond->right);
-    }
-  else if (cond->type == COND_AND)
-    {
-      result = execute_cond_node (cond->left);
-      if (result == EXECUTION_SUCCESS)
-	result = execute_cond_node (cond->right);
-    }
-  else if (cond->type == COND_UNARY)
-    {
-      int oa, varop, varflag;
-
-      if (ignore)
-	comsub_ignore_return++;
-      varop = STREQ (cond->op->word, "-v");
-#if defined (ARRAY_VARS)
-      varflag = (varop && valid_array_reference (cond->left->op->word, VA_NOEXPAND)) ? TEST_ARRAYEXP : 0;
-#else
-      varflag = 0;
-#endif
-      arg1 = cond_expand_word (cond->left->op, varop ? 3 : 0);
-      if (ignore)
-	comsub_ignore_return--;
-      if (arg1 == 0)
-	arg1 = nullstr;
-      if (echo_command_at_execute)
-	xtrace_print_cond_term (cond->type, invert, cond->op, arg1, (char *)NULL);
-#if defined (ARRAY_VARS)
-      if (varop)
-	oa = set_expand_once (0, 0);	/* no-op for compatibility levels <= 51 */
-#endif
-      result = unary_test (cond->op->word, arg1, varflag) ? EXECUTION_SUCCESS : EXECUTION_FAILURE;
-#if defined (ARRAY_VARS)
-      if (varop)
-	assoc_expand_once = oa;
-#endif
-      if (arg1 != nullstr)
-	free (arg1);
-    }
-  else if (cond->type == COND_BINARY)
-    {
-      rmatch = 0;
-      op = cond->op->word;
-      mode = 0;
-      patmatch = (((op[1] == '=') && (op[2] == '\0') &&
-		   (op[0] == '!' || op[0] == '=')) ||
-		  (op[0] == '=' && op[1] == '\0'));
-#if defined (COND_REGEXP)
-      rmatch = (op[0] == '=' && op[1] == '~' && op[2] == '\0');
-#endif
-      arith = STREQ (op, "-eq") || STREQ (op, "-ne") || STREQ (op, "-lt") ||
-	      STREQ (op, "-le") || STREQ (op, "-gt") || STREQ (op, "-ge");
-
-      if (arith)
-	mode = 3;
-      else if (rmatch && shell_compatibility_level > 31)
-	mode = 2;
-      else if (patmatch)
-	mode = 1;
-
-      if (ignore)
-	comsub_ignore_return++;
-      arg1 = cond_expand_word (cond->left->op, arith ? mode : 0);
-      if (ignore)
-	comsub_ignore_return--;
-      if (arg1 == 0)
-	arg1 = nullstr;
-      if (ignore)
-	comsub_ignore_return++;
-      arg2 = cond_expand_word (cond->right->op, mode);
-      if (ignore)
-	comsub_ignore_return--;
-      if (arg2 == 0)
-	arg2 = nullstr;
-
-      if (echo_command_at_execute)
-	xtrace_print_cond_term (cond->type, invert, cond->op, arg1, arg2);
-
-#if defined (COND_REGEXP)
-      if (rmatch)
-	{
-	  mflags = SHMAT_PWARN;
-#if defined (ARRAY_VARS)
-	  mflags |= SHMAT_SUBEXP;
-#endif
-
-#if 0
-	  t1 = strescape(arg1);
-	  t2 = strescape(arg2);
-	  itrace("execute_cond_node: sh_regmatch on `%s' and `%s'", t1, t2);
-	  free(t1);
-	  free(t2);
-#endif
-
-	  result = sh_regmatch (arg1, arg2, mflags);
-	}
-      else
-#endif /* COND_REGEXP */
-	{
-	  int oe;
-	  oe = extended_glob;
-	  extended_glob = 1;
-	  result = binary_test (cond->op->word, arg1, arg2, TEST_PATMATCH|TEST_ARITHEXP|TEST_LOCALE)
-				  ? EXECUTION_SUCCESS
-				  : EXECUTION_FAILURE;
-	  extended_glob = oe;
-	}
-      if (arg1 != nullstr)
-	free (arg1);
-      if (arg2 != nullstr)
-	free (arg2);
-    }
-  else
-    {
-      command_error ("execute_cond_node", CMDERR_BADTYPE, cond->type, 0);
-      jump_to_top_level (DISCARD);
-      result = EXECUTION_FAILURE;
-    }
-
-  if (invert)
-    result = (result == EXECUTION_SUCCESS) ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
-
-  return result;
-}
-
-static int
-execute_cond_command (cond_command)
-     COND_COM *cond_command;
-{
-  int retval, save_line_number;
-
-  save_line_number = line_number;
-
-  SET_LINE_NUMBER (cond_command->line);
-  /* If we're in a function, update the line number information. */
-  if (variable_context && interactive_shell && sourcelevel == 0)
-    {
-      /* line numbers in a function start at 1 */
-      line_number -= function_line_number - 1;
-      if (line_number <= 0)
-	line_number = 1;
-    }
-  command_string_index = 0;
-  print_cond_command (cond_command);
-
-  if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
-    {
-      FREE (the_printed_command_except_trap);
-      the_printed_command_except_trap = savestring (the_printed_command);
-    }
-
-  /* Run the debug trap before each conditional command, but do it after we
-     update the line number information. */
-  retval = run_debug_trap ();
-#if defined (DEBUGGER)
-  /* In debugging mode, if the DEBUG trap returns a non-zero status, we
-     skip the command. */
-  if (debugging_mode && retval != EXECUTION_SUCCESS)
-    {
-      line_number = save_line_number;
-      return (EXECUTION_SUCCESS);
-    }
-#endif
-
-  this_command_name = "[[";	/* ]] */
-
-#if 0
-  debug_print_cond_command (cond_command);
-#endif
-
-  last_command_exit_value = retval = execute_cond_node (cond_command);
-  line_number = save_line_number;
-  return (retval);
-}
-#endif /* COND_COMMAND */
-
-static void
-bind_lastarg (arg)
-     char *arg;
-{
-  SHELL_VAR *var;
-
-  if (arg == 0)
-    arg = "";
-  var = bind_variable ("_", arg, 0);
-  if (var)
-    VUNSETATTR (var, att_exported);
-}
-
-/* Execute a null command.  Fork a subshell if the command uses pipes or is
-   to be run asynchronously.  This handles all the side effects that are
-   supposed to take place. */
-static int
-execute_null_command (redirects, pipe_in, pipe_out, async)
-     REDIRECT *redirects;
-     int pipe_in, pipe_out, async;
-{
-  int r;
-  int forcefork, fork_flags;
-  REDIRECT *rd;
-
-  for (forcefork = 0, rd = redirects; rd; rd = rd->next)
-    {
-      forcefork += rd->rflags & REDIR_VARASSIGN;
-      /* Safety */
-      forcefork += (rd->redirector.dest == 0 || fd_is_bash_input (rd->redirector.dest)) && (INPUT_REDIRECT (rd->instruction) || TRANSLATE_REDIRECT (rd->instruction) || rd->instruction == r_close_this);
-    }
-
-  if (forcefork || pipe_in != NO_PIPE || pipe_out != NO_PIPE || async)
-    {
-      /* We have a null command, but we really want a subshell to take
-	 care of it.  Just fork, do piping and redirections, and exit. */
-      fork_flags = async ? FORK_ASYNC : 0;
-      if (make_child ((char *)NULL, fork_flags) == 0)
-	{
-	  /* Cancel traps, in trap.c. */
-	  restore_original_signals ();		/* XXX */
-
-	  do_piping (pipe_in, pipe_out);
-
-#if defined (COPROCESS_SUPPORT)
-	  coproc_closeall ();
-#endif
-
-	  interactive = 0;			/* XXX */
-
-	  subshell_environment = 0;
-	  if (async)
-	    subshell_environment |= SUBSHELL_ASYNC;
-	  if (pipe_in != NO_PIPE || pipe_out != NO_PIPE)
-	    subshell_environment |= SUBSHELL_PIPE;
-
-	  if (do_redirections (redirects, RX_ACTIVE) == 0)
-	    exit (EXECUTION_SUCCESS);
-	  else
-	    exit (EXECUTION_FAILURE);
-	}
-      else
-	{
-	  close_pipes (pipe_in, pipe_out);
-#if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
-	  if (pipe_out == NO_PIPE)
-	    unlink_fifo_list ();
-#endif
-	  return (EXECUTION_SUCCESS);
-	}
-    }
-  else
-    {
-      /* Even if there aren't any command names, pretend to do the
-	 redirections that are specified.  The user expects the side
-	 effects to take place.  If the redirections fail, then return
-	 failure.  Otherwise, if a command substitution took place while
-	 expanding the command or a redirection, return the value of that
-	 substitution.  Otherwise, return EXECUTION_SUCCESS. */
-
-      r = do_redirections (redirects, RX_ACTIVE|RX_UNDOABLE);
-      cleanup_redirects (redirection_undo_list);
-      redirection_undo_list = (REDIRECT *)NULL;
-
-      if (r != 0)
-	return (EXECUTION_FAILURE);
-      else if (last_command_subst_pid != NO_PID)
-	return (last_command_exit_value);
-      else
-	return (EXECUTION_SUCCESS);
-    }
-}
-
-/* This is a hack to suppress word splitting for assignment statements
-   given as arguments to builtins with the ASSIGNMENT_BUILTIN flag set. */
-static void
-fix_assignment_words (words)
-     WORD_LIST *words;
-{
-  WORD_LIST *w, *wcmd;
-  struct builtin *b;
-  int assoc, global, array, integer;
-
-  if (words == 0)
-    return;
-
-  b = 0;
-  assoc = global = array = integer = 0;
-
-  /* Skip over assignment statements preceding a command name */
-  wcmd = words;
-  for (wcmd = words; wcmd; wcmd = wcmd->next)
-    if ((wcmd->word->flags & W_ASSIGNMENT) == 0)
-      break;
-  /* Posix (post-2008) says that `command' doesn't change whether
-     or not the builtin it shadows is a `declaration command', even
-     though it removes other special builtin properties.  In Posix
-     mode, we skip over one or more instances of `command' and
-     deal with the next word as the assignment builtin. */
-  while (posixly_correct && wcmd && wcmd->word && wcmd->word->word && STREQ (wcmd->word->word, "command"))
-    wcmd = wcmd->next;
-
-  for (w = wcmd; w; w = w->next)
-    if (w->word->flags & W_ASSIGNMENT)
-      {
-      	/* Lazy builtin lookup, only do it if we find an assignment */
-	if (b == 0)
-	  {
-	    b = builtin_address_internal (wcmd->word->word, 0);
-	    if (b == 0 || (b->flags & ASSIGNMENT_BUILTIN) == 0)
-	      return;
-	    else if (b && (b->flags & ASSIGNMENT_BUILTIN))
-	      wcmd->word->flags |= W_ASSNBLTIN;
-	  }
-	w->word->flags |= (W_NOSPLIT|W_NOGLOB|W_TILDEEXP|W_ASSIGNARG);
-#if defined (ARRAY_VARS)
-	if (assoc)
-	  w->word->flags |= W_ASSIGNASSOC;
-	if (array)
-	  w->word->flags |= W_ASSIGNARRAY;
-#endif
-	if (global)
-	  w->word->flags |= W_ASSNGLOBAL;
-
-	/* If we have an assignment builtin that does not create local variables,
-	   make sure we create global variables even if we internally call
-	   `declare'.  The CHKLOCAL flag means to set attributes or values on
-	   an existing local variable, if there is one. */
-	if (b && ((b->flags & (ASSIGNMENT_BUILTIN|LOCALVAR_BUILTIN)) == ASSIGNMENT_BUILTIN))
-	  w->word->flags |= W_ASSNGLOBAL|W_CHKLOCAL;
-	else if (b && (b->flags & ASSIGNMENT_BUILTIN) && (b->flags & LOCALVAR_BUILTIN) && variable_context)
-	  w->word->flags |= W_FORCELOCAL;
-      }
-#if defined (ARRAY_VARS)
-    /* Note that we saw an associative array option to a builtin that takes
-       assignment statements.  This is a bit of a kludge. */
-    else if (w->word->word[0] == '-' && (strpbrk (w->word->word+1, "Aag") != 0))
-#else
-    else if (w->word->word[0] == '-' && strchr (w->word->word+1, 'g'))
-#endif
-      {
-	if (b == 0)
-	  {
-	    b = builtin_address_internal (wcmd->word->word, 0);
-	    if (b == 0 || (b->flags & ASSIGNMENT_BUILTIN) == 0)
-	      return;
-	    else if (b && (b->flags & ASSIGNMENT_BUILTIN))
-	      wcmd->word->flags |= W_ASSNBLTIN;
-	  }
-	if ((wcmd->word->flags & W_ASSNBLTIN) && strchr (w->word->word+1, 'A'))
-	  assoc = 1;
-	else if ((wcmd->word->flags & W_ASSNBLTIN) && strchr (w->word->word+1, 'a'))
-	  array = 1;
-	if ((wcmd->word->flags & W_ASSNBLTIN) && strchr (w->word->word+1, 'g'))
-	  global = 1;
-      }
-}
-
-#if defined (ARRAY_VARS)
-/* Set W_ARRAYREF on words that are valid array references to a builtin that
-   accepts them. This is intended to completely replace assoc_expand_once in
-   time. */
-static void
-fix_arrayref_words (words)
-     WORD_LIST *words;
-{
-  WORD_LIST *w, *wcmd;
-  struct builtin *b;
-
-  if (words == 0)
-    return;
-
-  b = 0;
-
-  /* Skip over assignment statements preceding a command name */
-  wcmd = words;
-  for (wcmd = words; wcmd; wcmd = wcmd->next)
-    if ((wcmd->word->flags & W_ASSIGNMENT) == 0)
-      break;
-
-  /* Skip over `command' */
-  while (wcmd && wcmd->word && wcmd->word->word && STREQ (wcmd->word->word, "command"))
-    wcmd = wcmd->next;
-
-  if (wcmd == 0)
-    return;
-
-  /* If it's not an array reference builtin, we have nothing to do. */
-  b = builtin_address_internal (wcmd->word->word, 0);
-  if (b == 0 || (b->flags & ARRAYREF_BUILTIN) == 0)
-    return;
-
-  for (w = wcmd->next; w; w = w->next)
-    {
-      if (w->word && w->word->word && valid_array_reference (w->word->word, 0))
-	w->word->flags |= W_ARRAYREF;
-    }
-}
-#endif
-
-#ifndef ISOPTION
-#  define ISOPTION(s, c)  (s[0] == '-' && s[1] == c && s[2] == 0)
-#endif
-
-#define RETURN_NOT_COMMAND() \
-  do { if (typep) *typep = 0; return words; } while (0)
-
-/* Make sure we have `command [-p] command_name [args]', and handle skipping
-   over the usual `--' that ends the options.  Returns the updated WORDS with
-   the command and options stripped and sets *TYPEP to a non-zero value. If
-   any other options are supplied, or there is not a command_name, we punt
-   and return a zero value in *TYPEP without updating WORDS. */
-static WORD_LIST *
-check_command_builtin (words, typep)
-     WORD_LIST *words;
-     int *typep;
-{
-  int type;
-  WORD_LIST *w;
-
-  w = words->next;
-  type = 1;
-
-  if (w && ISOPTION (w->word->word, 'p'))	/* command -p */
-    {
-#if defined (RESTRICTED_SHELL)
-      if (restricted)
-        RETURN_NOT_COMMAND();
-#endif
-      w = w->next;
-      type = 2;
-    }
-
-  if (w && ISOPTION (w->word->word, '-'))	/* command [-p] -- */
-    w = w->next;
-  else if (w && w->word->word[0] == '-')	/* any other option */
-    RETURN_NOT_COMMAND();
-
-  if (w == 0 || w->word->word == 0)		/* must have a command_name */
-    RETURN_NOT_COMMAND();
-
-  if (typep)
-    *typep = type;
-  return w;
-}
-
-/* Return 1 if the file found by searching $PATH for PATHNAME, defaulting
-   to PATHNAME, is a directory.  Used by the autocd code below. */
-static int
-is_dirname (pathname)
-     char *pathname;
-{
-  char *temp;
-  int ret;
-
-  temp = search_for_command (pathname, 0);
-  ret = temp ? file_isdir (temp) : file_isdir (pathname);
-  free (temp);
-  return ret;
-}
-
-/* The meaty part of all the executions.  We have to start hacking the
-   real execution of commands here.  Fork a process, set things up,
-   execute the command. */
-static int
-execute_simple_command (simple_command, pipe_in, pipe_out, async, fds_to_close)
-     SIMPLE_COM *simple_command;
-     int pipe_in, pipe_out, async;
-     struct fd_bitmap *fds_to_close;
-{
-  WORD_LIST *words, *lastword;
-  char *command_line, *lastarg, *temp;
-  int first_word_quoted, result, builtin_is_special, already_forked, dofork;
-  int fork_flags, cmdflags;
-  pid_t old_last_async_pid;
-  sh_builtin_func_t *builtin;
-  SHELL_VAR *func;
-  volatile int old_builtin, old_command_builtin;
-
-  result = EXECUTION_SUCCESS;
-  special_builtin_failed = builtin_is_special = 0;
-  command_line = (char *)0;
-
-  QUIT;
-
-  /* If we're in a function, update the line number information. */
-  if (variable_context && interactive_shell && sourcelevel == 0)
-    {
-      /* line numbers in a function start at 1 */
-      line_number -= function_line_number - 1;
-      if (line_number <= 0)
-	line_number = 1;
-    }
-
-  /* Remember what this command line looks like at invocation. */
-  command_string_index = 0;
-  print_simple_command (simple_command);
-
-#if 0
-  if (signal_in_progress (DEBUG_TRAP) == 0 && (this_command_name == 0 || (STREQ (this_command_name, "trap") == 0)))
-#else
-  if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
-#endif
-    {
-      FREE (the_printed_command_except_trap);
-      the_printed_command_except_trap = the_printed_command ? savestring (the_printed_command) : (char *)0;
-    }
-
-  /* Run the debug trap before each simple command, but do it after we
-     update the line number information. */
-  result = run_debug_trap ();
-#if defined (DEBUGGER)
-  /* In debugging mode, if the DEBUG trap returns a non-zero status, we
-     skip the command. */
-  if (debugging_mode && result != EXECUTION_SUCCESS)
-    return (EXECUTION_SUCCESS);
-#endif
-
-  cmdflags = simple_command->flags;
-
-  first_word_quoted =
-    simple_command->words ? (simple_command->words->word->flags & W_QUOTED) : 0;
-
-  last_command_subst_pid = NO_PID;
-  old_last_async_pid = last_asynchronous_pid;
-
-  already_forked = 0;
-
-  /* If we're in a pipeline or run in the background, set DOFORK so we
-     make the child early, before word expansion.  This keeps assignment
-     statements from affecting the parent shell's environment when they
-     should not. */
-  dofork = pipe_in != NO_PIPE || pipe_out != NO_PIPE || async;
-
-  /* Something like `%2 &' should restart job 2 in the background, not cause
-     the shell to fork here. */
-  if (dofork && pipe_in == NO_PIPE && pipe_out == NO_PIPE &&
-	simple_command->words && simple_command->words->word &&
-	simple_command->words->word->word &&
-	(simple_command->words->word->word[0] == '%'))
-    dofork = 0;
-
-  if (dofork)
-    {
-      char *p;
-
-      /* Do this now, because execute_disk_command will do it anyway in the
-	 vast majority of cases. */
-      maybe_make_export_env ();
-
-      /* Don't let a DEBUG trap overwrite the command string to be saved with
-	 the process/job associated with this child. */
-      fork_flags = async ? FORK_ASYNC : 0;
-      if (make_child (p = savestring (the_printed_command_except_trap), fork_flags) == 0)
-	{
-	  already_forked = 1;
-	  cmdflags |= CMD_NO_FORK;
-
-	  /* We redo some of what make_child() does with SUBSHELL_IGNTRAP */
-	  subshell_environment = SUBSHELL_FORK|SUBSHELL_IGNTRAP;	/* XXX */
-	  if (pipe_in != NO_PIPE || pipe_out != NO_PIPE)
-	    subshell_environment |= SUBSHELL_PIPE;
-	  if (async)
-	    subshell_environment |= SUBSHELL_ASYNC;
-
-	  /* We need to do this before piping to handle some really
-	     pathological cases where one of the pipe file descriptors
-	     is < 2. */
-	  if (fds_to_close)
-	    close_fd_bitmap (fds_to_close);
-
-	  /* If we fork because of an input pipe, note input pipe for later to
-	     inhibit async commands from redirecting stdin from /dev/null */
-	  stdin_redir |= pipe_in != NO_PIPE;
-
-	  do_piping (pipe_in, pipe_out);
-	  pipe_in = pipe_out = NO_PIPE;
-#if defined (COPROCESS_SUPPORT)
-	  coproc_closeall ();
-#endif
-
-	  last_asynchronous_pid = old_last_async_pid;
-
-	  if (async)
-	    subshell_level++;		/* not for pipes yet */
-
-#if defined (JOB_CONTROL)
-	  FREE (p);			/* child doesn't use pointer */
-#endif
-	}
-      else
-	{
-	  /* Don't let simple commands that aren't the last command in a
-	     pipeline change $? for the rest of the pipeline (or at all). */
-	  if (pipe_out != NO_PIPE)
-	    result = last_command_exit_value;
-	  close_pipes (pipe_in, pipe_out);
-	  command_line = (char *)NULL;      /* don't free this. */
-	  return (result);
-	}
-    }
-
-  QUIT;		/* XXX */
-
-  /* If we are re-running this as the result of executing the `command'
-     builtin, do not expand the command words a second time. */
-  if ((cmdflags & CMD_INHIBIT_EXPANSION) == 0)
-    {
-      current_fds_to_close = fds_to_close;
-      fix_assignment_words (simple_command->words);
-#if defined (ARRAY_VARS)
-      fix_arrayref_words (simple_command->words);
-#endif
-      /* Pass the ignore return flag down to command substitutions */
-      if (cmdflags & CMD_IGNORE_RETURN)	/* XXX */
-	comsub_ignore_return++;
-      words = expand_words (simple_command->words);
-      if (cmdflags & CMD_IGNORE_RETURN)
-	comsub_ignore_return--;
-      current_fds_to_close = (struct fd_bitmap *)NULL;
-    }
-  else
-    words = copy_word_list (simple_command->words);
-
-  /* It is possible for WORDS not to have anything left in it.
-     Perhaps all the words consisted of `$foo', and there was
-     no variable `$foo'. */
-  if (words == 0)
-    {
-      this_command_name = 0;
-      result = execute_null_command (simple_command->redirects,
-				     pipe_in, pipe_out,
-				     already_forked ? 0 : async);
-      if (already_forked)
-	sh_exit (result);
-      else
-	{
-	  bind_lastarg ((char *)NULL);
-	  set_pipestatus_from_exit (result);
-	  return (result);
-	}
-    }
-
-  lastarg = (char *)NULL;
-
-  begin_unwind_frame ("simple-command");
-
-  if (echo_command_at_execute && (cmdflags & CMD_COMMAND_BUILTIN) == 0)
-    xtrace_print_word_list (words, 1);
-
-  builtin = (sh_builtin_func_t *)NULL;
-  func = (SHELL_VAR *)NULL;
-
-  /* This test is still here in case we want to change the command builtin
-     handler code below to recursively call execute_simple_command (after
-     modifying the simple_command struct). */
-  if ((cmdflags & CMD_NO_FUNCTIONS) == 0)
-    {
-      /* Posix.2 says special builtins are found before functions.  We
-	 don't set builtin_is_special anywhere other than here, because
-	 this path is followed only when the `command' builtin is *not*
-	 being used, and we don't want to exit the shell if a special
-	 builtin executed with `command builtin' fails.  `command' is not
-	 a special builtin. */
-      if (posixly_correct)
-	{
-	  builtin = find_special_builtin (words->word->word);
-	  if (builtin)
-	    builtin_is_special = 1;
-	}
-      if (builtin == 0)
-	func = find_function (words->word->word);
-    }
-
-  /* What happens in posix mode when an assignment preceding a command name
-     fails.  This should agree with the code in execute_cmd.c:
-     do_assignment_statements(), even though I don't think it's executed any
-     more. */
-  if (posixly_correct && tempenv_assign_error)
-    {
-#if defined (DEBUG)
-      /* I don't know if this clause is ever executed, so let's check */
-itrace("execute_simple_command: posix mode tempenv assignment error");
-#endif
-      last_command_exit_value = EXECUTION_FAILURE;
-#if defined (STRICT_POSIX)
-      jump_to_top_level ((interactive_shell == 0) ? FORCE_EOF : DISCARD);
-#else
-      if (interactive_shell == 0 && builtin_is_special)
-	jump_to_top_level (FORCE_EOF);
-      else if (interactive_shell == 0)
-	jump_to_top_level (DISCARD);	/* XXX - maybe change later */
-      else
-	jump_to_top_level (DISCARD);
-#endif
-    }
-  tempenv_assign_error = 0;	/* don't care about this any more */
-
-  /* This is where we handle the command builtin as a pseudo-reserved word
-     prefix. This allows us to optimize away forks if we can. */
-  old_command_builtin = -1;
-  if (builtin == 0 && func == 0)
-    {
-      WORD_LIST *disposer, *l;
-      int cmdtype;
-
-      builtin = find_shell_builtin (words->word->word);
-      while (builtin == command_builtin)
-	{
-	  disposer = words;
-	  cmdtype = 0;
-	  words = check_command_builtin (words, &cmdtype);
-	  if (cmdtype > 0)	/* command -p [--] words */
-	    {
-	      for (l = disposer; l->next != words; l = l->next)
-		;
-	      l->next = 0;
-	      dispose_words (disposer);
-	      cmdflags |= CMD_COMMAND_BUILTIN | CMD_NO_FUNCTIONS;
-	      if (cmdtype == 2)
-		cmdflags |= CMD_STDPATH;
-	      builtin = find_shell_builtin (words->word->word);
-	    }
-	  else
-	    break;
-	}
-      if (cmdflags & CMD_COMMAND_BUILTIN)
-	{
-	  old_command_builtin = executing_command_builtin;
-	  unwind_protect_int (executing_command_builtin);
-	  executing_command_builtin |= 1;
-	}        
-      builtin = 0;
-    }
-
-  add_unwind_protect (dispose_words, words);
-  QUIT;
-
-  /* Bind the last word in this command to "$_" after execution. */
-  for (lastword = words; lastword->next; lastword = lastword->next)
-    ;
-  lastarg = lastword->word->word;
-
-#if defined (JOB_CONTROL)
-  /* Is this command a job control related thing? */
-  if (words->word->word[0] == '%' && already_forked == 0)
-    {
-      this_command_name = async ? "bg" : "fg";
-      last_shell_builtin = this_shell_builtin;
-      this_shell_builtin = builtin_address (this_command_name);
-      result = (*this_shell_builtin) (words);
-      goto return_result;
-    }
-
-  /* One other possibililty.  The user may want to resume an existing job.
-     If they do, find out whether this word is a candidate for a running
-     job. */
-  if (job_control && already_forked == 0 && async == 0 &&
-	!first_word_quoted &&
-	!words->next &&
-	words->word->word[0] &&
-	!simple_command->redirects &&
-	pipe_in == NO_PIPE &&
-	pipe_out == NO_PIPE &&
-	(temp = get_string_value ("auto_resume")))
-    {
-      int job, jflags, started_status;
-
-      jflags = JM_STOPPED|JM_FIRSTMATCH;
-      if (STREQ (temp, "exact"))
-	jflags |= JM_EXACT;
-      else if (STREQ (temp, "substring"))
-	jflags |= JM_SUBSTRING;
-      else
-	jflags |= JM_PREFIX;
-      job = get_job_by_name (words->word->word, jflags);
-      if (job != NO_JOB)
-	{
-	  run_unwind_frame ("simple-command");
-	  this_command_name = "fg";
-	  last_shell_builtin = this_shell_builtin;
-	  this_shell_builtin = builtin_address ("fg");
-
-	  started_status = start_job (job, 1);
-	  return ((started_status < 0) ? EXECUTION_FAILURE : started_status);
-	}
-    }
-#endif /* JOB_CONTROL */
-
-run_builtin:
-  /* Remember the name of this command globally. */
-  this_command_name = words->word->word;
-
-  QUIT;
-
-  /* This command could be a shell builtin or a user-defined function.
-     We have already found special builtins by this time, so we do not
-     set builtin_is_special.  If this is a function or builtin, and we
-     have pipes, then fork a subshell in here.  Otherwise, just execute
-     the command directly. */
-  if (func == 0 && builtin == 0)
-    builtin = find_shell_builtin (this_command_name);
-
-  last_shell_builtin = this_shell_builtin;
-  this_shell_builtin = builtin;
-
-  if (builtin || func)
-    {
-      if (builtin)
-        {
-	  old_builtin = executing_builtin;
-	  unwind_protect_int (executing_builtin);	/* modified in execute_builtin */
-	  if (old_command_builtin == -1)	/* sentinel, can be set above */
-	    {
-	      old_command_builtin = executing_command_builtin;
-	      unwind_protect_int (executing_command_builtin);	/* ditto and set above */
-	    }
-        }
-      if (already_forked)
-	{
-	  /* reset_terminating_signals (); */	/* XXX */
-	  /* Reset the signal handlers in the child, but don't free the
-	     trap strings.  Set a flag noting that we have to free the
-	     trap strings if we run trap to change a signal disposition. */
-	  reset_signal_handlers ();
-	  subshell_environment |= SUBSHELL_RESETTRAP;
-	  subshell_environment &= ~SUBSHELL_IGNTRAP;
-
-	  if (async)
-	    {
-	      if ((cmdflags & CMD_STDIN_REDIR) &&
-		    pipe_in == NO_PIPE &&
-		    (stdin_redirects (simple_command->redirects) == 0))
-		async_redirect_stdin ();
-	      setup_async_signals ();
-	    }
-
-	  if (async == 0)
-	    subshell_level++;
-	  execute_subshell_builtin_or_function
-	    (words, simple_command->redirects, builtin, func,
-	     pipe_in, pipe_out, async, fds_to_close,
-	     cmdflags);
-	  subshell_level--;
-	}
-      else
-	{
-	  result = execute_builtin_or_function
-	    (words, builtin, func, simple_command->redirects, fds_to_close,
-	     cmdflags);
-	  if (builtin)
-	    {
-	      if (result > EX_SHERRBASE)
-		{
-		  switch (result)
-		    {
-		    case EX_REDIRFAIL:
-		    case EX_BADASSIGN:
-		    case EX_EXPFAIL:
-		      /* These errors cause non-interactive posix mode shells to exit */
-		      if (posixly_correct && builtin_is_special && interactive_shell == 0)
-			{
-			  last_command_exit_value = EXECUTION_FAILURE;
-			  jump_to_top_level (ERREXIT);
-			}
-		      break;
-		    case EX_DISKFALLBACK:
-		      /* XXX - experimental */
-		      executing_builtin = old_builtin;
-		      executing_command_builtin = old_command_builtin;
-		      builtin = 0;
-
-		      /* The redirections have already been `undone', so this
-			 will have to do them again. But piping is forever. */
-		      pipe_in = pipe_out = -1;
-		      goto execute_from_filesystem;
-		    }
-		  result = builtin_status (result);
-		  if (builtin_is_special)
-		    special_builtin_failed = 1;	/* XXX - take command builtin into account? */
-		}
-	      /* In POSIX mode, if there are assignment statements preceding
-		 a special builtin, they persist after the builtin
-		 completes. */
-	      if (posixly_correct && builtin_is_special && temporary_env)
-		merge_temporary_env ();
-	    }
-	  else		/* function */
-	    {
-	      if (result == EX_USAGE)
-		result = EX_BADUSAGE;
-	      else if (result > EX_SHERRBASE)
-		result = builtin_status (result);
-	    }
-
-	  set_pipestatus_from_exit (result);
-
-	  goto return_result;
-	}
-    }
-
-  if (autocd && interactive && words->word && is_dirname (words->word->word))
-    {
-      words = make_word_list (make_word ("--"), words);
-      words = make_word_list (make_word ("cd"), words);
-      xtrace_print_word_list (words, 0);
-      func = find_function ("cd");
-      goto run_builtin;
-    }
-
-execute_from_filesystem:
-  if (command_line == 0)
-    command_line = savestring (the_printed_command_except_trap ? the_printed_command_except_trap : "");
-
-#if defined (PROCESS_SUBSTITUTION)
-  /* The old code did not test already_forked and only did this if
-     subshell_environment&SUBSHELL_COMSUB != 0 (comsubs and procsubs). Other
-     uses of the no-fork optimization left FIFOs in $TMPDIR */
-  if (already_forked == 0 && (cmdflags & CMD_NO_FORK) && fifos_pending() > 0)
-    cmdflags &= ~CMD_NO_FORK;
-#endif
-  result = execute_disk_command (words, simple_command->redirects, command_line,
-			pipe_in, pipe_out, async, fds_to_close,
-			cmdflags);
-
- return_result:
-  bind_lastarg (lastarg);
-  FREE (command_line);
-  dispose_words (words);
-  if (builtin)
-    {
-      executing_builtin = old_builtin;
-      executing_command_builtin = old_command_builtin;
-    }
-  discard_unwind_frame ("simple-command");
-  this_command_name = (char *)NULL;	/* points to freed memory now */
-  return (result);
-}
-
-/* Translate the special builtin exit statuses.  We don't really need a
-   function for this; it's a placeholder for future work. */
-static int
-builtin_status (result)
-     int result;
-{
-  int r;
-
-  switch (result)
-    {
-    case EX_USAGE:
-    case EX_BADSYNTAX:
-      r = EX_BADUSAGE;
-      break;
-    case EX_REDIRFAIL:
-    case EX_BADASSIGN:
-    case EX_EXPFAIL:
-      r = EXECUTION_FAILURE;
-      break;
-    default:
-      /* other special exit statuses not yet defined */
-      r = (result > EX_SHERRBASE) ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
-      break;
-    }
-  return (r);
-}
-
-static int
-execute_builtin (builtin, words, flags, subshell)
-     sh_builtin_func_t *builtin;
-     WORD_LIST *words;
-     int flags, subshell;
-{
-  int result, eval_unwind, ignexit_flag;
-  int isbltinenv, should_keep;
-  char *error_trap;
-
-  error_trap = 0;
-  should_keep = 0;
-
-  /* The eval builtin calls parse_and_execute, which does not know about
-     the setting of flags, and always calls the execution functions with
-     flags that will exit the shell on an error if -e is set.  If the
-     eval builtin is being called, and we're supposed to ignore the exit
-     value of the command, we turn the -e flag off ourselves and disable
-     the ERR trap, then restore them when the command completes.  This is
-     also a problem (as below) for the command and source/. builtins. */
-  if (subshell == 0 && (flags & CMD_IGNORE_RETURN) &&
-	(builtin == eval_builtin || (flags & CMD_COMMAND_BUILTIN) || builtin == source_builtin))
-    {
-      begin_unwind_frame ("eval_builtin");
-      unwind_protect_int (exit_immediately_on_error);
-      unwind_protect_int (builtin_ignoring_errexit);
-      error_trap = TRAP_STRING (ERROR_TRAP);
-      if (error_trap)
-	{
-	  error_trap = savestring (error_trap);
-	  add_unwind_protect (xfree, error_trap);
-	  add_unwind_protect (set_error_trap, error_trap);
-	  restore_default_signal (ERROR_TRAP);
-	}
-      exit_immediately_on_error = 0;
-      ignexit_flag = builtin_ignoring_errexit;
-      builtin_ignoring_errexit = 1;
-      eval_unwind = 1;
-    }
-  else
-    eval_unwind = 0;
-
-  /* The temporary environment for a builtin is supposed to apply to
-     all commands executed by that builtin.  Currently, this is a
-     problem only with the `unset', `source' and `eval' builtins.
-     `mapfile' is a special case because it uses evalstring (same as
-     eval or source) to run its callbacks. */
-  /* SHOULD_KEEP is for the pop_scope call below; it only matters when
-     posixly_correct is set, but we should propagate the temporary environment
-     to the enclosing environment only for special builtins. */
-  isbltinenv = (builtin == source_builtin || builtin == eval_builtin || builtin == unset_builtin || builtin == mapfile_builtin);
-  should_keep = isbltinenv && builtin != mapfile_builtin;
-#if defined (HISTORY) && defined (READLINE)
-  if (builtin == fc_builtin || builtin == read_builtin)
-    {
-      isbltinenv = 1;
-      should_keep = 0;
-    }
-#endif
-
-  if (isbltinenv)
-    {
-      if (subshell == 0)
-	begin_unwind_frame ("builtin_env");
-
-      if (temporary_env)
-	{
-	  push_scope (VC_BLTNENV, temporary_env);
-	  if (flags & CMD_COMMAND_BUILTIN)
-	    should_keep = 0;
-	  if (subshell == 0)
-	    add_unwind_protect (pop_scope, should_keep ? "1" : 0);
-          temporary_env = (HASH_TABLE *)NULL;	  
-	}
-    }
-
-  if (subshell == 0 && builtin == eval_builtin)
-    {
-      if (evalnest_max > 0 && evalnest >= evalnest_max)
-	{
-	  internal_error (_("eval: maximum eval nesting level exceeded (%d)"), evalnest);
-	  evalnest = 0;
-	  jump_to_top_level (DISCARD);
-	}
-      unwind_protect_int (evalnest);
-      /* The test for subshell == 0 above doesn't make a difference */
-      evalnest++;	/* execute_subshell_builtin_or_function sets this to 0 */
-    }
-  else if (subshell == 0 && builtin == source_builtin)
-    {
-      if (sourcenest_max > 0 && sourcenest >= sourcenest_max)
-	{
-	  internal_error (_("%s: maximum source nesting level exceeded (%d)"), this_command_name, sourcenest);
-	  sourcenest = 0;
-	  jump_to_top_level (DISCARD);
-	}
-      unwind_protect_int (sourcenest);
-      /* The test for subshell == 0 above doesn't make a difference */
-      sourcenest++;	/* execute_subshell_builtin_or_function sets this to 0 */
-    }
-
-  /* `return' does a longjmp() back to a saved environment in execute_function.
-     If a variable assignment list preceded the command, and the shell is
-     running in POSIX mode, we need to merge that into the shell_variables
-     table, since `return' is a POSIX special builtin. We don't do this if
-     it's being run by the `command' builtin, since that's supposed to inhibit
-     the special builtin properties. */
-  if (posixly_correct && subshell == 0 && builtin == return_builtin && (flags & CMD_COMMAND_BUILTIN) == 0 && temporary_env)
-    {
-      begin_unwind_frame ("return_temp_env");
-      add_unwind_protect (merge_temporary_env, (char *)NULL);
-    }
-
-  executing_builtin++;
-  executing_command_builtin |= builtin == command_builtin;
-  result = ((*builtin) (words->next));
-
-  /* This shouldn't happen, but in case `return' comes back instead of
-     longjmp'ing, we need to unwind. */
-  if (posixly_correct && subshell == 0 && builtin == return_builtin && temporary_env)
-    discard_unwind_frame ("return_temp_env");
-
-  if (subshell == 0 && isbltinenv)
-    run_unwind_frame ("builtin_env");
-
-  if (eval_unwind)
-    {
-      builtin_ignoring_errexit = ignexit_flag;
-      exit_immediately_on_error = builtin_ignoring_errexit ? 0 : errexit_flag;
-      if (error_trap)
-	{
-	  set_error_trap (error_trap);
-	  free (error_trap);
-	}
-      discard_unwind_frame ("eval_builtin");
-    }
-
-  return (result);
-}
-
-static void
-maybe_restore_getopt_state (gs)
-     sh_getopt_state_t *gs;
-{
-  /* If we have a local copy of OPTIND and it's at the right (current)
-     context, then we restore getopt's internal state.  If not, we just
-     let it go.  We know there is a local OPTIND if gs->gs_flags & 1.
-     This is set below in execute_function() before the context is run. */
-  if (gs->gs_flags & 1)
-    sh_getopt_restore_istate (gs);
-  else
-    free (gs);
-}
-
-#if defined (ARRAY_VARS)
-void
-restore_funcarray_state (fa)
-     struct func_array_state *fa;
-{
-  SHELL_VAR *nfv;
-  ARRAY *funcname_a;
-
-  array_pop (fa->source_a);
-  array_pop (fa->lineno_a);
-
-  GET_ARRAY_FROM_VAR ("FUNCNAME", nfv, funcname_a);
-  if (nfv == fa->funcname_v)
-    array_pop (funcname_a);
-
-  free (fa);
-}
-#endif
-
-static int
-execute_function (var, words, flags, fds_to_close, async, subshell)
-     SHELL_VAR *var;
-     WORD_LIST *words;
-     int flags;
-     struct fd_bitmap *fds_to_close;
-     int async, subshell;
-{
-  int return_val, result, lineno;
-  COMMAND *tc, *fc, *save_current;
-  char *debug_trap, *error_trap, *return_trap;
-#if defined (ARRAY_VARS)
-  SHELL_VAR *funcname_v, *bash_source_v, *bash_lineno_v;
-  ARRAY *funcname_a;
-  volatile ARRAY *bash_source_a;
-  volatile ARRAY *bash_lineno_a;
-  struct func_array_state *fa;
-#endif
-  FUNCTION_DEF *shell_fn;
-  char *sfile, *t;
-  sh_getopt_state_t *gs;
-  SHELL_VAR *gv;
-
-  USE_VAR(fc);
-
-  if (funcnest_max > 0 && funcnest >= funcnest_max)
-    {
-      internal_error (_("%s: maximum function nesting level exceeded (%d)"), var->name, funcnest);
-      funcnest = 0;	/* XXX - should we reset it somewhere else? */
-      jump_to_top_level (DISCARD);
-    }
-
-#if defined (ARRAY_VARS)
-  GET_ARRAY_FROM_VAR ("FUNCNAME", funcname_v, funcname_a);
-  GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v, bash_source_a);
-  GET_ARRAY_FROM_VAR ("BASH_LINENO", bash_lineno_v, bash_lineno_a);
-#endif
-
-  tc = (COMMAND *)copy_command (function_cell (var));
-  if (tc && (flags & CMD_IGNORE_RETURN))
-    tc->flags |= CMD_IGNORE_RETURN;
-
-  /* A limited attempt at optimization: shell functions at the end of command
-     substitutions that are already marked NO_FORK. */
-  if (tc && (flags & CMD_NO_FORK) && (subshell_environment & SUBSHELL_COMSUB))
-    optimize_shell_function (tc);
-
-  gs = sh_getopt_save_istate ();
-  if (subshell == 0)
-    {
-      begin_unwind_frame ("function_calling");
-      /* If the shell is in posix mode, this will push the variables in
-	 the temporary environment to the "current shell environment" (the
-	 global scope), and dispose the temporary env before setting it to
-	 NULL later. This behavior has disappeared from the latest edition
-	 of the standard, so I will eventually remove it from variables.c:
-	 push_var_context. */
-      push_context (var->name, subshell, temporary_env);
-      /* This has to be before the pop_context(), because the unwinding of
-	 local variables may cause the restore of a local declaration of
-	 OPTIND to force a getopts state reset. */
-      add_unwind_protect (maybe_restore_getopt_state, gs);
-      add_unwind_protect (pop_context, (char *)NULL);
-      unwind_protect_int (line_number);
-      unwind_protect_int (line_number_for_err_trap);
-      unwind_protect_int (function_line_number);
-      unwind_protect_int (return_catch_flag);
-      unwind_protect_jmp_buf (return_catch);
-      add_unwind_protect (dispose_command, (char *)tc);
-      unwind_protect_pointer (this_shell_function);
-      unwind_protect_int (funcnest);
-      unwind_protect_int (loop_level);
-    }
-  else
-    push_context (var->name, subshell, temporary_env);	/* don't unwind-protect for subshells */
-
-  temporary_env = (HASH_TABLE *)NULL;
-
-  this_shell_function = var;
-  make_funcname_visible (1);
-
-  debug_trap = TRAP_STRING(DEBUG_TRAP);
-  error_trap = TRAP_STRING(ERROR_TRAP);
-  return_trap = TRAP_STRING(RETURN_TRAP);
-  
-  /* The order of the unwind protects for debug_trap, error_trap and
-     return_trap is important here!  unwind-protect commands are run
-     in reverse order of registration.  If this causes problems, take
-     out the xfree unwind-protect calls and live with the small memory leak. */
-
-  /* function_trace_mode != 0 means that all functions inherit the DEBUG trap.
-     if the function has the trace attribute set, it inherits the DEBUG trap */
-  if (debug_trap && ((trace_p (var) == 0) && function_trace_mode == 0))
-    {
-      if (subshell == 0)
-	{
-	  debug_trap = savestring (debug_trap);
-	  add_unwind_protect (xfree, debug_trap);
-	  add_unwind_protect (maybe_set_debug_trap, debug_trap);
-	}
-      restore_default_signal (DEBUG_TRAP);
-    }
-
-  /* error_trace_mode != 0 means that functions inherit the ERR trap. */
-  if (error_trap && error_trace_mode == 0)
-    {
-      if (subshell == 0)
-	{
-	  error_trap = savestring (error_trap);
-	  add_unwind_protect (xfree, error_trap);
-	  add_unwind_protect (maybe_set_error_trap, error_trap);
-	}
-      restore_default_signal (ERROR_TRAP);
-    }
-
-  /* Shell functions inherit the RETURN trap if function tracing is on
-     globally or on individually for this function. */
-  if (return_trap && (signal_in_progress (DEBUG_TRAP) || ((trace_p (var) == 0) && function_trace_mode == 0)))
-    {
-      if (subshell == 0)
-	{
-	  return_trap = savestring (return_trap);
-	  add_unwind_protect (xfree, return_trap);
-	  add_unwind_protect (maybe_set_return_trap, return_trap);
-	}
-      restore_default_signal (RETURN_TRAP);
-    }
-  
-  funcnest++;
-#if defined (ARRAY_VARS)
-  /* This is quite similar to the code in shell.c and elsewhere. */
-  shell_fn = find_function_def (this_shell_function->name);
-  sfile = shell_fn ? shell_fn->source_file : "";
-  array_push ((ARRAY *)funcname_a, this_shell_function->name);
-
-  array_push ((ARRAY *)bash_source_a, sfile);
-  lineno = GET_LINE_NUMBER ();
-  t = itos (lineno);
-  array_push ((ARRAY *)bash_lineno_a, t);
-  free (t);
-#endif
-
-#if defined (ARRAY_VARS)
-  fa = (struct func_array_state *)xmalloc (sizeof (struct func_array_state));
-  fa->source_a = (ARRAY *)bash_source_a;
-  fa->source_v = bash_source_v;
-  fa->lineno_a = (ARRAY *)bash_lineno_a;
-  fa->lineno_v = bash_lineno_v;
-  fa->funcname_a = (ARRAY *)funcname_a;
-  fa->funcname_v = funcname_v;
-  if (subshell == 0)
-    add_unwind_protect (restore_funcarray_state, fa);
-#endif
-
-  /* The temporary environment for a function is supposed to apply to
-     all commands executed within the function body. */
-
-  /* Initialize BASH_ARGC and BASH_ARGV before we blow away the positional
-     parameters */
-  if (debugging_mode || shell_compatibility_level <= 44)
-    init_bash_argv ();
-
-  remember_args (words->next, 1);
-
-  /* Update BASH_ARGV and BASH_ARGC */
-  if (debugging_mode)
-    {
-      push_args (words->next);
-      if (subshell == 0)
-	add_unwind_protect (pop_args, 0);
-    }
-
-  /* Number of the line on which the function body starts. */
-  line_number = function_line_number = tc->line;
-
-#if defined (JOB_CONTROL)
-  if (subshell)
-    stop_pipeline (async, (COMMAND *)NULL);
-#endif
-
-  if (shell_compatibility_level > 43)
-    loop_level = 0;
-
-  fc = tc;
-
-  from_return_trap = 0;
-
-  return_catch_flag++;
-  return_val = setjmp_nosigs (return_catch);
-
-  if (return_val)
-    {
-      result = return_catch_value;
-      /* Run the RETURN trap in the function's context. */
-      save_current = currently_executing_command;
-      if (from_return_trap == 0)
-	run_return_trap ();
-      currently_executing_command = save_current;
-    }
-  else
-    {
-      /* Run the debug trap here so we can trap at the start of a function's
-	 execution rather than the execution of the body's first command. */
-      showing_function_line = 1;
-      save_current = currently_executing_command;
-      result = run_debug_trap ();
-#if defined (DEBUGGER)
-      /* In debugging mode, if the DEBUG trap returns a non-zero status, we
-	 skip the command. */
-      if (debugging_mode == 0 || result == EXECUTION_SUCCESS)
-	{
-	  showing_function_line = 0;
-	  currently_executing_command = save_current;
-	  result = execute_command_internal (fc, 0, NO_PIPE, NO_PIPE, fds_to_close);
-
-	  /* Run the RETURN trap in the function's context */
-	  save_current = currently_executing_command;
-	  run_return_trap ();
-	  currently_executing_command = save_current;
-	}
-#else
-      result = execute_command_internal (fc, 0, NO_PIPE, NO_PIPE, fds_to_close);
-
-      save_current = currently_executing_command;
-      run_return_trap ();
-      currently_executing_command = save_current;
-#endif
-      showing_function_line = 0;
-    }
-
-  /* If we have a local copy of OPTIND, note it in the saved getopts state. */
-  gv = find_variable ("OPTIND");
-  if (gv && gv->context == variable_context)
-    gs->gs_flags |= 1;
-
-  if (subshell == 0)
-    run_unwind_frame ("function_calling");
-#if defined (ARRAY_VARS)
-  else
-    {
-      restore_funcarray_state (fa);
-      /* Restore BASH_ARGC and BASH_ARGV */
-      if (debugging_mode)
-	pop_args ();
-    }
-#endif
-
-  if (variable_context == 0 || this_shell_function == 0)
-    {
-      make_funcname_visible (0);
-#if defined (PROCESS_SUBSTITUTION)
-      unlink_fifo_list ();
-#endif
-    }
-
-  return (result);
-}
-
-/* A convenience routine for use by other parts of the shell to execute
-   a particular shell function. */
-int
-execute_shell_function (var, words)
-     SHELL_VAR *var;
-     WORD_LIST *words;
-{
-  int ret;
-  struct fd_bitmap *bitmap;
-
-  bitmap = new_fd_bitmap (FD_BITMAP_DEFAULT_SIZE);
-  begin_unwind_frame ("execute-shell-function");
-  add_unwind_protect (dispose_fd_bitmap, (char *)bitmap);
-      
-  ret = execute_function (var, words, 0, bitmap, 0, 0);
-
-  dispose_fd_bitmap (bitmap);
-  discard_unwind_frame ("execute-shell-function");
-
-  return ret;
-}
-
-/* Execute a shell builtin or function in a subshell environment.  This
-   routine does not return; it only calls exit().  If BUILTIN is non-null,
-   it points to a function to call to execute a shell builtin; otherwise
-   VAR points at the body of a function to execute.  WORDS is the arguments
-   to the command, REDIRECTS specifies redirections to perform before the
-   command is executed. */
-static void
-execute_subshell_builtin_or_function (words, redirects, builtin, var,
-				      pipe_in, pipe_out, async, fds_to_close,
-				      flags)
-     WORD_LIST *words;
-     REDIRECT *redirects;
-     sh_builtin_func_t *builtin;
-     SHELL_VAR *var;
-     int pipe_in, pipe_out, async;
-     struct fd_bitmap *fds_to_close;
-     int flags;
-{
-  int result, r, funcvalue;
-#if defined (JOB_CONTROL)
-  int jobs_hack;
-
-  jobs_hack = (builtin == jobs_builtin) &&
-		((subshell_environment & SUBSHELL_ASYNC) == 0 || pipe_out != NO_PIPE);
-#endif
-
-  /* A subshell is neither a login shell nor interactive. */
-  login_shell = interactive = 0;
-  if (builtin == eval_builtin)
-    evalnest = 0;
-  else if (builtin == source_builtin)
-    sourcenest = 0;
-
-  if (async)
-    subshell_environment |= SUBSHELL_ASYNC;
-  if (pipe_in != NO_PIPE || pipe_out != NO_PIPE)
-    subshell_environment |= SUBSHELL_PIPE;
-
-  maybe_make_export_env ();	/* XXX - is this needed? */
-
-#if defined (JOB_CONTROL)
-  /* Eradicate all traces of job control after we fork the subshell, so
-     all jobs begun by this subshell are in the same process group as
-     the shell itself. */
-
-  /* Allow the output of `jobs' to be piped. */
-  if (jobs_hack)
-    kill_current_pipeline ();
-  else
-    without_job_control ();
-
-  set_sigchld_handler ();
-#else
-  without_job_control ();
-#endif /* JOB_CONTROL */
-
-  set_sigint_handler ();
-
-  if (fds_to_close)
-    close_fd_bitmap (fds_to_close);
-
-  do_piping (pipe_in, pipe_out);
-
-  if (do_redirections (redirects, RX_ACTIVE) != 0)
-    exit (EXECUTION_FAILURE);
-
-  if (builtin)
-    {
-      /* Give builtins a place to jump back to on failure,
-	 so we don't go back up to main(). */
-      result = setjmp_nosigs (top_level);
-
-      /* Give the return builtin a place to jump to when executed in a subshell
-         or pipeline */
-      funcvalue = 0;
-      if (return_catch_flag && builtin == return_builtin)
-        funcvalue = setjmp_nosigs (return_catch);
-
-      if (result == EXITPROG || result == EXITBLTIN)
-	subshell_exit (last_command_exit_value);
-      else if (result)
-	subshell_exit (EXECUTION_FAILURE);
-      else if (funcvalue)
-	subshell_exit (return_catch_value);
-      else
-	{
-	  r = execute_builtin (builtin, words, flags, 1);
-	  fflush (stdout);
-	  if (r == EX_USAGE)
-	    r = EX_BADUSAGE;
-	  /* XXX - experimental */
-	  else if (r == EX_DISKFALLBACK)
-	    {
-	      char *command_line;
-
-	      command_line = savestring (the_printed_command_except_trap ? the_printed_command_except_trap : "");
-	      r = execute_disk_command (words, (REDIRECT *)0, command_line,
-		  -1, -1, async, (struct fd_bitmap *)0, flags|CMD_NO_FORK);
-	    }
-	  subshell_exit (r);
-	}
-    }
-  else
-    {
-      r = execute_function (var, words, flags, fds_to_close, async, 1);
-      fflush (stdout);
-      subshell_exit (r);
-    }
-}
-
-/* Execute a builtin or function in the current shell context.  If BUILTIN
-   is non-null, it is the builtin command to execute, otherwise VAR points
-   to the body of a function.  WORDS are the command's arguments, REDIRECTS
-   are the redirections to perform.  FDS_TO_CLOSE is the usual bitmap of
-   file descriptors to close.
-
-   If BUILTIN is exec_builtin, the redirections specified in REDIRECTS are
-   not undone before this function returns. */
-static int
-execute_builtin_or_function (words, builtin, var, redirects,
-			     fds_to_close, flags)
-     WORD_LIST *words;
-     sh_builtin_func_t *builtin;
-     SHELL_VAR *var;
-     REDIRECT *redirects;
-     struct fd_bitmap *fds_to_close;
-     int flags;
-{
-  int result;
-  REDIRECT *saved_undo_list;
-#if defined (PROCESS_SUBSTITUTION)
-  int ofifo, nfifo, osize;
-  void *ofifo_list;
-#endif
-
-#if defined (PROCESS_SUBSTITUTION)
-  begin_unwind_frame ("saved_fifos");
-  /* If we return, we longjmp and don't get a chance to restore the old
-     fifo list, so we add an unwind protect to free it */
-  ofifo = num_fifos ();
-  ofifo_list = copy_fifo_list (&osize);
-  if (ofifo_list)
-    add_unwind_protect (xfree, ofifo_list);
-#endif
-
-  if (do_redirections (redirects, RX_ACTIVE|RX_UNDOABLE) != 0)
-    {
-      undo_partial_redirects ();
-      dispose_exec_redirects ();
-#if defined (PROCESS_SUBSTITUTION)
-      free (ofifo_list);
-#endif
-      return (EX_REDIRFAIL);	/* was EXECUTION_FAILURE */
-    }
-
-  saved_undo_list = redirection_undo_list;
-
-  /* Calling the "exec" builtin changes redirections forever. */
-  if (builtin == exec_builtin)
-    {
-      dispose_redirects (saved_undo_list);
-      saved_undo_list = exec_redirection_undo_list;
-      exec_redirection_undo_list = (REDIRECT *)NULL;
-    }
-  else
-    dispose_exec_redirects ();
-
-  if (saved_undo_list)
-    {
-      begin_unwind_frame ("saved-redirects");
-      add_unwind_protect (cleanup_redirects, (char *)saved_undo_list);
-    }
-
-  redirection_undo_list = (REDIRECT *)NULL;
-
-  if (builtin)
-    result = execute_builtin (builtin, words, flags, 0);
-  else
-    result = execute_function (var, words, flags, fds_to_close, 0, 0);
-
-  /* We do this before undoing the effects of any redirections. */
-  fflush (stdout);
-  fpurge (stdout);
-  if (ferror (stdout))
-    clearerr (stdout);  
-
-  /* If we are executing the `command' builtin, but this_shell_builtin is
-     set to `exec_builtin', we know that we have something like
-     `command exec [redirection]', since otherwise `exec' would have
-     overwritten the shell and we wouldn't get here.  In this case, we
-     want to behave as if the `command' builtin had not been specified
-     and preserve the redirections. */
-  if (builtin == command_builtin && this_shell_builtin == exec_builtin)
-    {
-      int discard;
-
-      discard = 0;
-      if (saved_undo_list)
-	{
-	  dispose_redirects (saved_undo_list);
-	  discard = 1;
-	}
-      redirection_undo_list = exec_redirection_undo_list;
-      saved_undo_list = exec_redirection_undo_list = (REDIRECT *)NULL;      
-      if (discard)
-	discard_unwind_frame ("saved-redirects");
-    }
-
-  if (saved_undo_list)
-    {
-      redirection_undo_list = saved_undo_list;
-      discard_unwind_frame ("saved-redirects");
-    }
-
-  undo_partial_redirects ();
-
-#if defined (PROCESS_SUBSTITUTION)
-  /* Close any FIFOs created by this builtin or function. */
-  nfifo = num_fifos ();
-  if (nfifo > ofifo)
-    close_new_fifos (ofifo_list, osize);
-  if (ofifo_list)
-    free (ofifo_list);
-  discard_unwind_frame ("saved_fifos");
-#endif
-
-  return (result);
-}
-
-void
-setup_async_signals ()
-{
-#if defined (__BEOS__)
-  set_signal_handler (SIGHUP, SIG_IGN);	/* they want csh-like behavior */
-#endif
-
-#if defined (JOB_CONTROL)
-  if (job_control == 0)
-#endif
-    {
-      /* Make sure we get the original signal dispositions now so we don't
-	 confuse the trap builtin later if the subshell tries to use it to
-	 reset SIGINT/SIGQUIT.  Don't call set_signal_ignored; that sets
-	 the value of original_signals to SIG_IGN. Posix interpretation 751. */
-      get_original_signal (SIGINT);
-      set_signal_handler (SIGINT, SIG_IGN);
-
-      get_original_signal (SIGQUIT);
-      set_signal_handler (SIGQUIT, SIG_IGN);
-    }
-}
-
-/* Execute a simple command that is hopefully defined in a disk file
-   somewhere.
-
-   1) fork ()
-   2) connect pipes
-   3) look up the command
-   4) do redirections
-   5) execve ()
-   6) If the execve failed, see if the file has executable mode set.
-   If so, and it isn't a directory, then execute its contents as
-   a shell script.
-
-   Note that the filename hashing stuff has to take place up here,
-   in the parent.  This is probably why the Bourne style shells
-   don't handle it, since that would require them to go through
-   this gnarly hair, for no good reason.
-
-   NOTE: callers expect this to fork or exit(). */
-
-/* Name of a shell function to call when a command name is not found. */
-#ifndef NOTFOUND_HOOK
-#  define NOTFOUND_HOOK "command_not_found_handle"
-#endif
-
-static int
-execute_disk_command (words, redirects, command_line, pipe_in, pipe_out,
-		      async, fds_to_close, cmdflags)
-     WORD_LIST *words;
-     REDIRECT *redirects;
-     char *command_line;
-     int pipe_in, pipe_out, async;
-     struct fd_bitmap *fds_to_close;
-     int cmdflags;
-{
-  char *pathname, *command, **args, *p;
-  int nofork, stdpath, result, fork_flags;
-  pid_t pid;
-  SHELL_VAR *hookf;
-  WORD_LIST *wl;
-
-  stdpath = (cmdflags & CMD_STDPATH);	/* use command -p path */
-  nofork = (cmdflags & CMD_NO_FORK);	/* Don't fork, just exec, if no pipes */
-  pathname = words->word->word;
-
-  p = 0;
-  result = EXECUTION_SUCCESS;
-#if defined (RESTRICTED_SHELL)
-  command = (char *)NULL;
-  if (restricted && mbschr (pathname, '/'))
-    {
-      internal_error (_("%s: restricted: cannot specify `/' in command names"),
-		    pathname);
-      result = last_command_exit_value = EXECUTION_FAILURE;
-
-      /* If we're not going to fork below, we must already be in a child
-         process or a context in which it's safe to call exit(2).  */
-      if (nofork && pipe_in == NO_PIPE && pipe_out == NO_PIPE)
-	exit (last_command_exit_value);
-      else
-	goto parent_return;
-    }
-#endif /* RESTRICTED_SHELL */
-
-  /* If we want to change this so `command -p' (CMD_STDPATH) does not insert
-     any pathname it finds into the hash table, it should read
-     command = search_for_command (pathname, stdpath ? CMDSRCH_STDPATH : CMDSRCH_HASH);
-  */
-  command = search_for_command (pathname, CMDSRCH_HASH|(stdpath ? CMDSRCH_STDPATH : 0));
-  QUIT;
-
-  if (command)
-    {
-      /* If we're optimizing out the fork (implicit `exec'), decrement the
-	 shell level like `exec' would do. Don't do this if we are already
-	 in a pipeline environment, assuming it's already been done. */
-      if (nofork && pipe_in == NO_PIPE && pipe_out == NO_PIPE && (subshell_environment & SUBSHELL_PIPE) == 0)
-	adjust_shell_level (-1);
-
-      maybe_make_export_env ();
-      put_command_name_into_env (command);
-    }
-
-  /* We have to make the child before we check for the non-existence
-     of COMMAND, since we want the error messages to be redirected. */
-  /* If we can get away without forking and there are no pipes to deal with,
-     don't bother to fork, just directly exec the command. */
-  if (nofork && pipe_in == NO_PIPE && pipe_out == NO_PIPE)
-    pid = 0;
-  else
-    {
-      fork_flags = async ? FORK_ASYNC : 0;
-      pid = make_child (p = savestring (command_line), fork_flags);
-    }
-
-  if (pid == 0)
-    {
-      int old_interactive;
-
-      reset_terminating_signals ();	/* XXX */
-      /* Cancel traps, in trap.c. */
-      restore_original_signals ();
-      subshell_environment &= ~SUBSHELL_IGNTRAP;
-
-#if defined (JOB_CONTROL)
-      FREE (p);
-#endif
-
-      /* restore_original_signals may have undone the work done
-	 by make_child to ensure that SIGINT and SIGQUIT are ignored
-	 in asynchronous children. */
-      if (async)
-	{
-	  if ((cmdflags & CMD_STDIN_REDIR) &&
-		pipe_in == NO_PIPE &&
-		(stdin_redirects (redirects) == 0))
-	    async_redirect_stdin ();
-	  setup_async_signals ();
-	}
-
-      /* This functionality is now provided by close-on-exec of the
-	 file descriptors manipulated by redirection and piping.
-	 Some file descriptors still need to be closed in all children
-	 because of the way bash does pipes; fds_to_close is a
-	 bitmap of all such file descriptors. */
-      if (fds_to_close)
-	close_fd_bitmap (fds_to_close);
-
-      do_piping (pipe_in, pipe_out);
-
-      old_interactive = interactive;
-      if (async)
-	interactive = 0;
-
-      subshell_environment |= SUBSHELL_FORK;	/* XXX - was just = */
-
-#if defined (PROCESS_SUBSTITUTION) && !defined (HAVE_DEV_FD)
-      clear_fifo_list ();	/* XXX - we haven't created any FIFOs */
-#endif
-
-      /* reset shell_pgrp to pipeline_pgrp here for word expansions performed
-         by the redirections here? */
-      if (redirects && (do_redirections (redirects, RX_ACTIVE) != 0))
-	{
-#if defined (PROCESS_SUBSTITUTION)
-	  /* Try to remove named pipes that may have been created as the
-	     result of redirections. */
-	  unlink_all_fifos ();
-#endif /* PROCESS_SUBSTITUTION */
-	  exit (EXECUTION_FAILURE);
-	}
-
-#if defined (PROCESS_SUBSTITUTION) && !defined (HAVE_DEV_FD)
-      /* This should only contain FIFOs created as part of redirection
-	 expansion. */
-      unlink_all_fifos ();
-#endif
-
-      if (async)
-	interactive = old_interactive;
-
-      if (command == 0)
-	{
-	  hookf = find_function (NOTFOUND_HOOK);
-	  if (hookf == 0)
-	    {
-	      /* Make sure filenames are displayed using printable characters */
-	      pathname = printable_filename (pathname, 0);
-	      internal_error (_("%s: command not found"), pathname);
-	      exit (EX_NOTFOUND);	/* Posix.2 says the exit status is 127 */
-	    }
-
-	  /* We don't want to manage process groups for processes we start
-	     from here, so we turn off job control and don't attempt to
-	     manipulate the terminal's process group. */
-	  without_job_control ();
-
-#if defined (JOB_CONTROL)
-	  set_sigchld_handler ();
-#endif
-
-	  wl = make_word_list (make_word (NOTFOUND_HOOK), words);
-	  exit (execute_shell_function (hookf, wl));
-	}
-
-      /* Execve expects the command name to be in args[0].  So we
-	 leave it there, in the same format that the user used to
-	 type it in. */
-      args = strvec_from_word_list (words, 0, 0, (int *)NULL);
-      exit (shell_execve (command, args, export_env));
-    }
-  else
-    {
-parent_return:
-      QUIT;
-
-      /* Make sure that the pipes are closed in the parent. */
-      close_pipes (pipe_in, pipe_out);
-#if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
-#if 0
-      if (variable_context == 0)
-        unlink_fifo_list ();
-#endif
-#endif
-      FREE (command);
-      return (result);
-    }
-}
-
-/* CPP defines to decide whether a particular index into the #! line
-   corresponds to a valid interpreter name or argument character, or
-   whitespace.  The MSDOS define is to allow \r to be treated the same
-   as \n. */
-
-#if !defined (MSDOS)
-#  define STRINGCHAR(ind) \
-    (ind < sample_len && !whitespace (sample[ind]) && sample[ind] != '\n')
-#  define WHITECHAR(ind) \
-    (ind < sample_len && whitespace (sample[ind]))
-#else	/* MSDOS */
-#  define STRINGCHAR(ind) \
-    (ind < sample_len && !whitespace (sample[ind]) && sample[ind] != '\n' && sample[ind] != '\r')
-#  define WHITECHAR(ind) \
-    (ind < sample_len && whitespace (sample[ind]))
-#endif	/* MSDOS */
-
-static char *
-getinterp (sample, sample_len, endp)
-     char *sample;
-     int sample_len, *endp;
-{
-  register int i;
-  char *execname;
-  int start;
-
-  /* Find the name of the interpreter to exec. */
-  for (i = 2; i < sample_len && whitespace (sample[i]); i++)
-    ;
-
-  for (start = i; STRINGCHAR(i); i++)
-    ;
-
-  execname = substring (sample, start, i);
-
-  if (endp)
-    *endp = i;
-  return execname;
-}
-
-#if !defined (HAVE_HASH_BANG_EXEC)
-/* If the operating system on which we're running does not handle
-   the #! executable format, then help out.  SAMPLE is the text read
-   from the file, SAMPLE_LEN characters.  COMMAND is the name of
-   the script; it and ARGS, the arguments given by the user, will
-   become arguments to the specified interpreter.  ENV is the environment
-   to pass to the interpreter.
-
-   The word immediately following the #! is the interpreter to execute.
-   A single argument to the interpreter is allowed. */
-
-static int
-execute_shell_script (sample, sample_len, command, args, env)
-     char *sample;
-     int sample_len;
-     char *command;
-     char **args, **env;
-{
-  char *execname, *firstarg;
-  int i, start, size_increment, larry;
-
-  /* Find the name of the interpreter to exec. */
-  execname = getinterp (sample, sample_len, &i);
-  size_increment = 1;
-
-  /* Now the argument, if any. */
-  for (firstarg = (char *)NULL, start = i; WHITECHAR(i); i++)
-    ;
-
-  /* If there is more text on the line, then it is an argument for the
-     interpreter. */
-
-  if (STRINGCHAR(i))  
-    {
-      for (start = i; STRINGCHAR(i); i++)
-	;
-      firstarg = substring ((char *)sample, start, i);
-      size_increment = 2;
-    }
-
-  larry = strvec_len (args) + size_increment;
-  args = strvec_resize (args, larry + 1);
-
-  for (i = larry - 1; i; i--)
-    args[i] = args[i - size_increment];
-
-  args[0] = execname;
-  if (firstarg)
-    {
-      args[1] = firstarg;
-      args[2] = command;
-    }
-  else
-    args[1] = command;
-
-  args[larry] = (char *)NULL;
-
-  return (shell_execve (execname, args, env));
-}
-#undef STRINGCHAR
-#undef WHITECHAR
-
-#endif /* !HAVE_HASH_BANG_EXEC */
-
-static void
-initialize_subshell ()
-{
-#if defined (ALIAS)
-  /* Forget about any aliases that we knew of.  We are in a subshell. */
-  delete_all_aliases ();
-#endif /* ALIAS */
-
-#if defined (HISTORY)
-  /* Forget about the history lines we have read.  This is a non-interactive
-     subshell. */
-  history_lines_this_session = 0;
-#endif
-
-  /* Forget about the way job control was working. We are in a subshell. */
-  without_job_control ();
-
-#if defined (JOB_CONTROL)
-  set_sigchld_handler ();
-  init_job_stats ();
-#endif /* JOB_CONTROL */
-
-  /* Reset the values of the shell flags and options. */
-  reset_shell_flags ();
-  reset_shell_options ();
-  reset_shopt_options ();
-
-  /* Zero out builtin_env, since this could be a shell script run from a
-     sourced file with a temporary environment supplied to the `source/.'
-     builtin.  Such variables are not supposed to be exported (empirical
-     testing with sh and ksh).  Just throw it away; don't worry about a
-     memory leak. */
-  if (vc_isbltnenv (shell_variables))
-    shell_variables = shell_variables->down;
-
-  clear_unwind_protect_list (0);
-  /* XXX -- are there other things we should be resetting here? */
-  parse_and_execute_level = 0;		/* nothing left to restore it */
-
-  /* We're no longer inside a shell function. */
-  variable_context = return_catch_flag = funcnest = evalnest = sourcenest = 0;
-
-  executing_list = 0;		/* XXX */
-
-  /* If we're not interactive, close the file descriptor from which we're
-     reading the current shell script. */
-  if (interactive_shell == 0)
-    unset_bash_input (0);
-}
-
-#if defined (HAVE_SETOSTYPE) && defined (_POSIX_SOURCE)
-#  define SETOSTYPE(x)	__setostype(x)
-#else
-#  define SETOSTYPE(x)
-#endif
-
-#define HASH_BANG_BUFSIZ	128
-
-#define READ_SAMPLE_BUF(file, buf, len) \
-  do \
-    { \
-      fd = open(file, O_RDONLY); \
-      if (fd >= 0) \
-	{ \
-	  len = read (fd, buf, HASH_BANG_BUFSIZ); \
-	  close (fd); \
-	} \
-      else \
-	len = -1; \
-    } \
-  while (0)
-      
-/* Call execve (), handling interpreting shell scripts, and handling
-   exec failures. */
-int
-shell_execve (command, args, env)
-     char *command;
-     char **args, **env;
-{
-  int larray, i, fd;
-  char sample[HASH_BANG_BUFSIZ];
-  int sample_len;
-
-  SETOSTYPE (0);		/* Some systems use for USG/POSIX semantics */
-  execve (command, args, env);
-  i = errno;			/* error from execve() */
-  CHECK_TERMSIG;
-  SETOSTYPE (1);
-
-  /* If we get to this point, then start checking out the file.
-     Maybe it is something we can hack ourselves. */
-  if (i != ENOEXEC)
-    {
-      /* make sure this is set correctly for file_error/report_error */
-      last_command_exit_value = (i == ENOENT) ?  EX_NOTFOUND : EX_NOEXEC; /* XXX Posix.2 says that exit status is 126 */
-      if (file_isdir (command))
-#if defined (EISDIR)
-	internal_error (_("%s: %s"), command, strerror (EISDIR));
-#else
-	internal_error (_("%s: is a directory"), command);
-#endif
-      else if (executable_file (command) == 0)
-	{
-	  errno = i;
-	  file_error (command);
-	}
-      /* errors not involving the path argument to execve. */
-      else if (i == E2BIG || i == ENOMEM)
-	{
-	  errno = i;
-	  file_error (command);
-	}
-      else if (i == ENOENT)
-	{
-	  errno = i;
-	  internal_error (_("%s: cannot execute: required file not found"), command);
-	}
-      else
-	{
-	  /* The file has the execute bits set, but the kernel refuses to
-	     run it for some reason.  See why. */
-#if defined (HAVE_HASH_BANG_EXEC)
-	  READ_SAMPLE_BUF (command, sample, sample_len);
-	  if (sample_len > 0)
-	    sample[sample_len - 1] = '\0';
-	  if (sample_len > 2 && sample[0] == '#' && sample[1] == '!')
-	    {
-	      char *interp;
-	      int ilen;
-
-	      interp = getinterp (sample, sample_len, (int *)NULL);
-	      ilen = strlen (interp);
-	      errno = i;
-	      if (interp[ilen - 1] == '\r')
-		{
-		  interp = xrealloc (interp, ilen + 2);
-		  interp[ilen - 1] = '^';
-		  interp[ilen] = 'M';
-		  interp[ilen + 1] = '\0';
-		}
-	      sys_error (_("%s: %s: bad interpreter"), command, interp ? interp : "");
-	      FREE (interp);
-	      return (EX_NOEXEC);
-	    }
-#endif
-	  errno = i;
-	  file_error (command);
-	}
-      return (last_command_exit_value);
-    }
-
-  /* This file is executable.
-     If it begins with #!, then help out people with losing operating
-     systems.  Otherwise, check to see if it is a binary file by seeing
-     if the contents of the first line (or up to 80 characters) are in the
-     ASCII set.  If it's a text file, execute the contents as shell commands,
-     otherwise return 126 (EX_BINARY_FILE). */
-  READ_SAMPLE_BUF (command, sample, sample_len);
-
-  if (sample_len == 0)
-    return (EXECUTION_SUCCESS);
-
-  /* Is this supposed to be an executable script?
-     If so, the format of the line is "#! interpreter [argument]".
-     A single argument is allowed.  The BSD kernel restricts
-     the length of the entire line to 32 characters (32 bytes
-     being the size of the BSD exec header), but we allow up to 128
-     characters. */
-  if (sample_len > 0)
-    {
-#if !defined (HAVE_HASH_BANG_EXEC)
-      if (sample_len > 2 && sample[0] == '#' && sample[1] == '!')
-	return (execute_shell_script (sample, sample_len, command, args, env));
-      else
-#endif
-      if (check_binary_file (sample, sample_len))
-	{
-	  internal_error (_("%s: cannot execute binary file: %s"), command, strerror (i));
-	  errno = i;
-	  return (EX_BINARY_FILE);
-	}
-    }
-
-  /* We have committed to attempting to execute the contents of this file
-     as shell commands. */
-
-  reset_parser ();
-  initialize_subshell ();
-
-  set_sigint_handler ();
-
-  /* Insert the name of this shell into the argument list. */
-  larray = strvec_len (args) + 1;
-  args = strvec_resize (args, larray + 1);
-
-  for (i = larray - 1; i; i--)
-    args[i] = args[i - 1];
-
-  args[0] = shell_name;
-  args[1] = command;
-  args[larray] = (char *)NULL;
-
-  if (args[0][0] == '-')
-    args[0]++;
-
-#if defined (RESTRICTED_SHELL)
-  if (restricted)
-    change_flag ('r', FLAG_OFF);
-#endif
-
-  if (subshell_argv)
-    {
-      /* Can't free subshell_argv[0]; that is shell_name. */
-      for (i = 1; i < subshell_argc; i++)
-	free (subshell_argv[i]);
-      free (subshell_argv);
-    }
-
-  dispose_command (currently_executing_command);	/* XXX */
-  currently_executing_command = (COMMAND *)NULL;
-
-  subshell_argc = larray;
-  subshell_argv = args;
-  subshell_envp = env;
-
-  unbind_args ();	/* remove the positional parameters */
-
-#if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
-  clear_fifo_list ();	/* pipe fds are what they are now */
-#endif
-
-  sh_longjmp (subshell_top_level, 1);
-  /*NOTREACHED*/
-}
-
-static int
-execute_intern_function (name, funcdef)
-     WORD_DESC *name;
-     FUNCTION_DEF *funcdef;
-{
-  SHELL_VAR *var;
-  char *t;
-
-  if (check_identifier (name, posixly_correct) == 0)
-    {
-      if (posixly_correct && interactive_shell == 0)
-	{
-	  last_command_exit_value = EX_BADUSAGE;
-	  jump_to_top_level (ERREXIT);
-	}
-      return (EXECUTION_FAILURE);
-    }
-
-  if (strchr (name->word, CTLESC))	/* WHY? */
-    {
-      t = dequote_escapes (name->word);
-      free (name->word);
-      name->word = t;
-    }
-
-  /* Posix interpretation 383 */
-  if (posixly_correct && find_special_builtin (name->word))
-    {
-      internal_error (_("`%s': is a special builtin"), name->word);
-      last_command_exit_value = EX_BADUSAGE;
-      jump_to_top_level (interactive_shell ? DISCARD : ERREXIT);
-    }
-
-  var = find_function (name->word);
-  if (var && (readonly_p (var) || noassign_p (var)))
-    {
-      if (readonly_p (var))
-	internal_error (_("%s: readonly function"), var->name);
-      return (EXECUTION_FAILURE);
-    }
-
-#if defined (DEBUGGER)
-  bind_function_def (name->word, funcdef, 1);
-#endif
-
-  bind_function (name->word, funcdef->command);
-  return (EXECUTION_SUCCESS);
-}
-
-#if defined (INCLUDE_UNUSED)
-#if defined (PROCESS_SUBSTITUTION)
-void
-close_all_files ()
-{
-  register int i, fd_table_size;
-
-  fd_table_size = getdtablesize ();
-  if (fd_table_size > 256)	/* clamp to a reasonable value */
-    fd_table_size = 256;
-
-  for (i = 3; i < fd_table_size; i++)
-    close (i);
-}
-#endif /* PROCESS_SUBSTITUTION */
-#endif
-
-static void
-close_pipes (in, out)
-     int in, out;
-{
-  if (in >= 0)
-    close (in);
-  if (out >= 0)
-    close (out);
-}
-
-static void
-dup_error (oldd, newd)
-     int oldd, newd;
-{
-  sys_error (_("cannot duplicate fd %d to fd %d"), oldd, newd);
-}
-
-/* Redirect input and output to be from and to the specified pipes.
-   NO_PIPE and REDIRECT_BOTH are handled correctly. */
-static void
-do_piping (pipe_in, pipe_out)
-     int pipe_in, pipe_out;
-{
-  if (pipe_in != NO_PIPE)
-    {
-      if (dup2 (pipe_in, 0) < 0)
-	dup_error (pipe_in, 0);
-      if (pipe_in > 0)
-	close (pipe_in);
-#ifdef __CYGWIN__
-      /* Let stdio know the fd may have changed from text to binary mode. */
-      freopen (NULL, "r", stdin);
-#endif /* __CYGWIN__ */
-    }
-  if (pipe_out != NO_PIPE)
-    {
-      if (pipe_out != REDIRECT_BOTH)
-	{
-	  if (dup2 (pipe_out, 1) < 0)
-	    dup_error (pipe_out, 1);
-	  if (pipe_out == 0 || pipe_out > 1)
-	    close (pipe_out);
-	}
-      else
-	{
-	  if (dup2 (1, 2) < 0)
-	    dup_error (1, 2);
-	}
-#ifdef __CYGWIN__
-      /* Let stdio know the fd may have changed from text to binary mode, and
-	 make sure to preserve stdout line buffering. */
-      freopen (NULL, "w", stdout);
-      sh_setlinebuf (stdout);
-#endif /* __CYGWIN__ */
-    }
-}
diff --git a/third_party/bash/execute_cmd.h b/third_party/bash/execute_cmd.h
deleted file mode 100644
index 465030aef..000000000
--- a/third_party/bash/execute_cmd.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/* execute_cmd.h - functions from execute_cmd.c. */
-
-/* Copyright (C) 1993-2017 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_EXECUTE_CMD_H_)
-#define _EXECUTE_CMD_H_
-
-#include "stdc.h"
-
-#if defined (ARRAY_VARS)
-struct func_array_state
-  {
-    ARRAY *funcname_a;
-    SHELL_VAR *funcname_v;
-    ARRAY *source_a;
-    SHELL_VAR *source_v;
-    ARRAY *lineno_a;
-    SHELL_VAR *lineno_v;
-  };
-#endif
-
-/* Placeholder for later expansion to include more execution state */
-/* XXX - watch out for pid_t */
-struct execstate
-  {
-    pid_t pid;
-    int subshell_env;
-  };
-	
-
-/* Variables declared in execute_cmd.c, used by many other files */
-extern int return_catch_flag;
-extern int return_catch_value;
-extern volatile int last_command_exit_value;
-extern int last_command_exit_signal;
-extern int builtin_ignoring_errexit;
-extern int executing_builtin;
-extern int executing_list;
-extern int comsub_ignore_return;
-extern int subshell_level;
-extern int match_ignore_case;
-extern int executing_command_builtin;
-extern int funcnest, funcnest_max;
-extern int evalnest, evalnest_max;
-extern int sourcenest, sourcenest_max;
-extern int stdin_redir;
-extern int line_number_for_err_trap;
-
-extern char *the_printed_command_except_trap;
-
-extern char *this_command_name;
-extern SHELL_VAR *this_shell_function;
-
-/* Functions declared in execute_cmd.c, used by many other files */
-
-extern struct fd_bitmap *new_fd_bitmap PARAMS((int));
-extern void dispose_fd_bitmap PARAMS((struct fd_bitmap *));
-extern void close_fd_bitmap PARAMS((struct fd_bitmap *));
-extern int executing_line_number PARAMS((void));
-extern int execute_command PARAMS((COMMAND *));
-extern int execute_command_internal PARAMS((COMMAND *, int, int, int, struct fd_bitmap *));
-extern int shell_execve PARAMS((char *, char **, char **));
-extern void setup_async_signals PARAMS((void));
-extern void async_redirect_stdin PARAMS((void));
-
-extern void undo_partial_redirects PARAMS((void));
-extern void dispose_partial_redirects PARAMS((void));
-extern void dispose_exec_redirects PARAMS((void));
-
-extern int execute_shell_function PARAMS((SHELL_VAR *, WORD_LIST *));
-
-extern struct coproc *getcoprocbypid PARAMS((pid_t));
-extern struct coproc *getcoprocbyname PARAMS((const char *));
-
-extern void coproc_init PARAMS((struct coproc *));
-extern struct coproc *coproc_alloc PARAMS((char *, pid_t));
-extern void coproc_dispose PARAMS((struct coproc *));
-extern void coproc_flush PARAMS((void));
-extern void coproc_close PARAMS((struct coproc *));
-extern void coproc_closeall PARAMS((void));
-extern void coproc_reap PARAMS((void));
-extern pid_t coproc_active PARAMS((void));
-
-extern void coproc_rclose PARAMS((struct coproc *, int));
-extern void coproc_wclose PARAMS((struct coproc *, int));
-extern void coproc_fdclose PARAMS((struct coproc *, int));
-
-extern void coproc_checkfd PARAMS((struct coproc *, int));
-extern void coproc_fdchk PARAMS((int));
-
-extern void coproc_pidchk PARAMS((pid_t, int));
-
-extern void coproc_fdsave PARAMS((struct coproc *));
-extern void coproc_fdrestore PARAMS((struct coproc *));
-
-extern void coproc_setvars PARAMS((struct coproc *));
-extern void coproc_unsetvars PARAMS((struct coproc *));
-
-#if defined (PROCESS_SUBSTITUTION)
-extern void close_all_files PARAMS((void));
-#endif
-
-#if defined (ARRAY_VARS)
-extern void restore_funcarray_state PARAMS((struct func_array_state *));
-#endif
-
-#endif /* _EXECUTE_CMD_H_ */
diff --git a/third_party/bash/expr.c b/third_party/bash/expr.c
deleted file mode 100644
index 5079bd476..000000000
--- a/third_party/bash/expr.c
+++ /dev/null
@@ -1,1693 +0,0 @@
-/* expr.c -- arithmetic expression evaluation. */
-
-/* Copyright (C) 1990-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/*
- All arithmetic is done as intmax_t integers with no checking for overflow
- (though division by 0 is caught and flagged as an error).
-
- The following operators are handled, grouped into a set of levels in
- order of decreasing precedence.
-
-	"id++", "id--"		[post-increment and post-decrement]
-	"-", "+"		[(unary operators)]
-	"++id", "--id"		[pre-increment and pre-decrement]
-	"!", "~"
-	"**"			[(exponentiation)]
-	"*", "/", "%"
-	"+", "-"
-	"<<", ">>"
-	"<=", ">=", "<", ">"
-	"==", "!="
-	"&"
-	"^"
-	"|"
-	"&&"
-	"||"
-	"expr ? expr : expr"
-	"=", "*=", "/=", "%=", "+=", "-=", "<<=", ">>=", "&=", "^=", "|="
-	,			[comma]
-
- (Note that most of these operators have special meaning to bash, and an
- entire expression should be quoted, e.g. "a=$a+1" or "a=a+1" to ensure
- that it is passed intact to the evaluator when using `let'.  When using
- the $[] or $(( )) forms, the text between the `[' and `]' or `((' and `))'
- is treated as if in double quotes.)
-
- Sub-expressions within parentheses have a precedence level greater than
- all of the above levels and are evaluated first.  Within a single prece-
- dence group, evaluation is left-to-right, except for the arithmetic
- assignment operator (`='), which is evaluated right-to-left (as in C).
-
- The expression evaluator returns the value of the expression (assignment
- statements have as a value what is returned by the RHS).  The `let'
- builtin, on the other hand, returns 0 if the last expression evaluates to
- a non-zero, and 1 otherwise.
-
- Implementation is a recursive-descent parser.
-
- Chet Ramey
- chet@po.cwru.edu
-*/
-
-#include "config.h"
-
-#include <stdio.h>
-#include "bashansi.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "chartypes.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "arrayfunc.h"
-#include "execute_cmd.h"
-#include "flags.h"
-#include "subst.h"
-#include "typemax.h"		/* INTMAX_MAX, INTMAX_MIN */
-
-/* Because of the $((...)) construct, expressions may include newlines.
-   Here is a macro which accepts newlines, tabs and spaces as whitespace. */
-#define cr_whitespace(c) (whitespace(c) || ((c) == '\n'))
-
-/* Size be which the expression stack grows when necessary. */
-#define EXPR_STACK_GROW_SIZE 10
-
-/* Maximum amount of recursion allowed.  This prevents a non-integer
-   variable such as "num=num+2" from infinitely adding to itself when
-   "let num=num+2" is given. */
-#define MAX_EXPR_RECURSION_LEVEL 1024
-
-/* The Tokens.  Singing "The Lion Sleeps Tonight". */
-
-#define EQEQ	1	/* "==" */
-#define NEQ	2	/* "!=" */
-#define LEQ	3	/* "<=" */
-#define GEQ	4	/* ">=" */
-#define STR	5	/* string */
-#define NUM	6	/* number */
-#define LAND	7	/* "&&" Logical AND */
-#define LOR	8	/* "||" Logical OR */
-#define LSH	9	/* "<<" Left SHift */
-#define RSH    10	/* ">>" Right SHift */
-#define OP_ASSIGN 11	/* op= expassign as in Posix.2 */
-#define COND	12	/* exp1 ? exp2 : exp3 */
-#define POWER	13	/* exp1**exp2 */
-#define PREINC	14	/* ++var */
-#define PREDEC	15	/* --var */
-#define POSTINC	16	/* var++ */
-#define POSTDEC	17	/* var-- */
-#define EQ	'='
-#define GT	'>'
-#define LT	'<'
-#define PLUS	'+'
-#define MINUS	'-'
-#define MUL	'*'
-#define DIV	'/'
-#define MOD	'%'
-#define NOT	'!'
-#define LPAR	'('
-#define RPAR	')'
-#define BAND	'&'	/* Bitwise AND */
-#define BOR	'|'	/* Bitwise OR. */
-#define BXOR	'^'	/* Bitwise eXclusive OR. */
-#define BNOT	'~'	/* Bitwise NOT; Two's complement. */
-#define QUES	'?'
-#define COL	':'
-#define COMMA	','
-
-/* This should be the function corresponding to the operator with the
-   lowest precedence. */
-#define EXP_LOWEST	expcomma
-
-#ifndef MAX_INT_LEN
-#  define MAX_INT_LEN 32
-#endif
-
-struct lvalue
-{
-  char *tokstr;		/* possibly-rewritten lvalue if not NULL */
-  intmax_t tokval;	/* expression evaluated value */
-  SHELL_VAR *tokvar;	/* variable described by array or var reference */
-  intmax_t ind;		/* array index if not -1 */
-};
-
-/* A structure defining a single expression context. */
-typedef struct {
-  int curtok, lasttok;
-  char *expression, *tp, *lasttp;
-  intmax_t tokval;
-  char *tokstr;
-  int noeval;
-  struct lvalue lval;
-} EXPR_CONTEXT;
-
-static char	*expression;	/* The current expression */
-static char	*tp;		/* token lexical position */
-static char	*lasttp;	/* pointer to last token position */
-static int	curtok;		/* the current token */
-static int	lasttok;	/* the previous token */
-static int	assigntok;	/* the OP in OP= */
-static char	*tokstr;	/* current token string */
-static intmax_t	tokval;		/* current token value */
-static int	noeval;		/* set to 1 if no assignment to be done */
-static procenv_t evalbuf;
-
-/* set to 1 if the expression has already been run through word expansion */
-static int	already_expanded;
-
-static struct lvalue curlval = {0, 0, 0, -1};
-static struct lvalue lastlval = {0, 0, 0, -1};
-
-static int	_is_arithop PARAMS((int));
-static void	readtok PARAMS((void));	/* lexical analyzer */
-
-static void	init_lvalue PARAMS((struct lvalue *));
-static struct lvalue *alloc_lvalue PARAMS((void));
-static void	free_lvalue PARAMS((struct lvalue *));
-
-static intmax_t	expr_streval PARAMS((char *, int, struct lvalue *));
-static intmax_t	strlong PARAMS((char *));
-static void	evalerror PARAMS((const char *));
-
-static void	pushexp PARAMS((void));
-static void	popexp PARAMS((void));
-static void	expr_unwind PARAMS((void));
-static void	expr_bind_variable PARAMS((char *, char *));
-#if defined (ARRAY_VARS)
-static void	expr_bind_array_element PARAMS((char *, arrayind_t, char *));
-#endif
-
-static intmax_t subexpr PARAMS((char *));
-
-static intmax_t	expcomma PARAMS((void));
-static intmax_t expassign PARAMS((void));
-static intmax_t	expcond PARAMS((void));
-static intmax_t explor PARAMS((void));
-static intmax_t expland PARAMS((void));
-static intmax_t	expbor PARAMS((void));
-static intmax_t	expbxor PARAMS((void));
-static intmax_t	expband PARAMS((void));
-static intmax_t exp5 PARAMS((void));
-static intmax_t exp4 PARAMS((void));
-static intmax_t expshift PARAMS((void));
-static intmax_t exp3 PARAMS((void));
-static intmax_t expmuldiv PARAMS((void));
-static intmax_t	exppower PARAMS((void));
-static intmax_t exp1 PARAMS((void));
-static intmax_t exp0 PARAMS((void));
-
-/* Global var which contains the stack of expression contexts. */
-static EXPR_CONTEXT **expr_stack;
-static int expr_depth;		   /* Location in the stack. */
-static int expr_stack_size;	   /* Number of slots already allocated. */
-
-#if defined (ARRAY_VARS)
-extern const char * const bash_badsub_errmsg;
-#endif
-
-#define SAVETOK(X) \
-  do { \
-    (X)->curtok = curtok; \
-    (X)->lasttok = lasttok; \
-    (X)->tp = tp; \
-    (X)->lasttp = lasttp; \
-    (X)->tokval = tokval; \
-    (X)->tokstr = tokstr; \
-    (X)->noeval = noeval; \
-    (X)->lval = curlval; \
-  } while (0)
-
-#define RESTORETOK(X) \
-  do { \
-    curtok = (X)->curtok; \
-    lasttok = (X)->lasttok; \
-    tp = (X)->tp; \
-    lasttp = (X)->lasttp; \
-    tokval = (X)->tokval; \
-    tokstr = (X)->tokstr; \
-    noeval = (X)->noeval; \
-    curlval = (X)->lval; \
-  } while (0)
-
-/* Push and save away the contents of the globals describing the
-   current expression context. */
-static void
-pushexp ()
-{
-  EXPR_CONTEXT *context;
-
-  if (expr_depth >= MAX_EXPR_RECURSION_LEVEL)
-    evalerror (_("expression recursion level exceeded"));
-
-  if (expr_depth >= expr_stack_size)
-    {
-      expr_stack_size += EXPR_STACK_GROW_SIZE;
-      expr_stack = (EXPR_CONTEXT **)xrealloc (expr_stack, expr_stack_size * sizeof (EXPR_CONTEXT *));
-    }
-
-  context = (EXPR_CONTEXT *)xmalloc (sizeof (EXPR_CONTEXT));
-
-  context->expression = expression;
-  SAVETOK(context);
-
-  expr_stack[expr_depth++] = context;
-}
-
-/* Pop the the contents of the expression context stack into the
-   globals describing the current expression context. */
-static void
-popexp ()
-{
-  EXPR_CONTEXT *context;
-
-  if (expr_depth <= 0)
-    {
-      /* See the comment at the top of evalexp() for an explanation of why
-	 this is done. */
-      expression = lasttp = 0;
-      evalerror (_("recursion stack underflow"));
-    }
-
-  context = expr_stack[--expr_depth];
-
-  expression = context->expression;
-  RESTORETOK (context);
-
-  free (context);
-}
-
-static void
-expr_unwind ()
-{
-  while (--expr_depth > 0)
-    {
-      if (expr_stack[expr_depth]->tokstr)
-	free (expr_stack[expr_depth]->tokstr);
-
-      if (expr_stack[expr_depth]->expression)
-	free (expr_stack[expr_depth]->expression);
-
-      free (expr_stack[expr_depth]);
-    }
-  if (expr_depth == 0)
-    free (expr_stack[expr_depth]);	/* free the allocated EXPR_CONTEXT */
-
-  noeval = 0;	/* XXX */
-}
-
-static void
-expr_bind_variable (lhs, rhs)
-     char *lhs, *rhs;
-{
-  SHELL_VAR *v;
-  int aflags;
-
-  if (lhs == 0 || *lhs == 0)
-    return;		/* XXX */
-
-#if defined (ARRAY_VARS)
-  aflags = (assoc_expand_once && already_expanded) ? ASS_NOEXPAND : 0;
-  aflags |= ASS_ALLOWALLSUB;		/* allow assoc[@]=value */
-#else
-  aflags = 0;
-#endif
-  v = bind_int_variable (lhs, rhs, aflags);
-  if (v && (readonly_p (v) || noassign_p (v)))
-    sh_longjmp (evalbuf, 1);	/* variable assignment error */
-  stupidly_hack_special_variables (lhs);
-}
-
-#if defined (ARRAY_VARS)
-/* This is similar to the logic in arrayfunc.c:valid_array_reference when
-   you pass VA_NOEXPAND. */
-static int
-expr_skipsubscript (vp, cp)
-     char *vp, *cp;
-{
-  int flags, isassoc;
-  SHELL_VAR *entry;
-
-  isassoc = 0;
-  entry = 0;
-  if (assoc_expand_once & already_expanded)
-    {
-      *cp = '\0';
-      isassoc = legal_identifier (vp) && (entry = find_variable (vp)) && assoc_p (entry);
-      *cp = '[';	/* ] */
-    }
-  flags = (isassoc && assoc_expand_once && already_expanded) ? VA_NOEXPAND : 0;
-  return (skipsubscript (cp, 0, flags));
-}
-
-/* Rewrite tok, which is of the form vname[expression], to vname[ind], where
-   IND is the already-calculated value of expression. */
-static void
-expr_bind_array_element (tok, ind, rhs)
-     char *tok;
-     arrayind_t ind;
-     char *rhs;
-{
-  char *lhs, *vname;
-  size_t llen;
-  char ibuf[INT_STRLEN_BOUND (arrayind_t) + 1], *istr;
-
-  istr = fmtumax (ind, 10, ibuf, sizeof (ibuf), 0);
-  vname = array_variable_name (tok, 0, (char **)NULL, (int *)NULL);
-
-  llen = strlen (vname) + sizeof (ibuf) + 3;
-  lhs = xmalloc (llen);
-
-  sprintf (lhs, "%s[%s]", vname, istr);		/* XXX */
-  
-/*itrace("expr_bind_array_element: %s=%s", lhs, rhs);*/
-  expr_bind_variable (lhs, rhs);
-  free (vname);
-  free (lhs);
-}
-#endif /* ARRAY_VARS */
-
-/* Evaluate EXPR, and return the arithmetic result.  If VALIDP is
-   non-null, a zero is stored into the location to which it points
-   if the expression is invalid, non-zero otherwise.  If a non-zero
-   value is returned in *VALIDP, the return value of evalexp() may
-   be used.
-
-   The `while' loop after the longjmp is caught relies on the above
-   implementation of pushexp and popexp leaving in expr_stack[0] the
-   values that the variables had when the program started.  That is,
-   the first things saved are the initial values of the variables that
-   were assigned at program startup or by the compiler.  Therefore, it is
-   safe to let the loop terminate when expr_depth == 0, without freeing up
-   any of the expr_depth[0] stuff. */
-intmax_t
-evalexp (expr, flags, validp)
-     char *expr;
-     int flags;
-     int *validp;
-{
-  intmax_t val;
-  int c;
-  procenv_t oevalbuf;
-
-  val = 0;
-  noeval = 0;
-  already_expanded = (flags&EXP_EXPANDED);
-
-  FASTCOPY (evalbuf, oevalbuf, sizeof (evalbuf));
-
-  c = setjmp_nosigs (evalbuf);
-
-  if (c)
-    {
-      FREE (tokstr);
-      FREE (expression);
-      tokstr = expression = (char *)NULL;
-
-      expr_unwind ();
-      expr_depth = 0;	/* XXX - make sure */
-
-      /* We copy in case we've called evalexp recursively */
-      FASTCOPY (oevalbuf, evalbuf, sizeof (evalbuf));
-
-      if (validp)
-	*validp = 0;
-      return (0);
-    }
-
-  val = subexpr (expr);
-
-  if (validp)
-    *validp = 1;
-
-  FASTCOPY (oevalbuf, evalbuf, sizeof (evalbuf));
-
-  return (val);
-}
-
-static intmax_t
-subexpr (expr)
-     char *expr;
-{
-  intmax_t val;
-  char *p;
-
-  for (p = expr; p && *p && cr_whitespace (*p); p++)
-    ;
-
-  if (p == NULL || *p == '\0')
-    return (0);
-
-  pushexp ();
-  expression = savestring (expr);
-  tp = expression;
-
-  curtok = lasttok = 0;
-  tokstr = (char *)NULL;
-  tokval = 0;
-  init_lvalue (&curlval);
-  lastlval = curlval;
-
-  readtok ();
-
-  val = EXP_LOWEST ();
-
-  /*TAG:bash-5.3 make it clear that these are arithmetic syntax errors */
-  if (curtok != 0)
-    evalerror (_("syntax error in expression"));
-
-  FREE (tokstr);
-  FREE (expression);
-
-  popexp ();
-
-  return val;
-}
-
-static intmax_t
-expcomma ()
-{
-  register intmax_t value;
-
-  value = expassign ();
-  while (curtok == COMMA)
-    {
-      readtok ();
-      value = expassign ();
-    }
-
-  return value;
-}
-  
-static intmax_t
-expassign ()
-{
-  register intmax_t value;
-  char *lhs, *rhs;
-  arrayind_t lind;
-#if defined (HAVE_IMAXDIV)
-  imaxdiv_t idiv;
-#endif
-
-  value = expcond ();
-  if (curtok == EQ || curtok == OP_ASSIGN)
-    {
-      int special, op;
-      intmax_t lvalue;
-
-      special = curtok == OP_ASSIGN;
-
-      if (lasttok != STR)
-	evalerror (_("attempted assignment to non-variable"));
-
-      if (special)
-	{
-	  op = assigntok;		/* a OP= b */
-	  lvalue = value;
-	}
-
-      if (tokstr == 0)
-	evalerror (_("syntax error in variable assignment"));
-
-      /* XXX - watch out for pointer aliasing issues here */
-      lhs = savestring (tokstr);
-      /* save ind in case rhs is string var and evaluation overwrites it */
-      lind = curlval.ind;
-      readtok ();
-      value = expassign ();
-
-      if (special)
-	{
-	  if ((op == DIV || op == MOD) && value == 0)
-	    {
-	      if (noeval == 0)
-		evalerror (_("division by 0"));
-	      else
-	        value = 1;
-	    }
-
-	  switch (op)
-	    {
-	    case MUL:
-	      /* Handle INTMAX_MIN and INTMAX_MAX * -1 specially here? */
-	      lvalue *= value;
-	      break;
-	    case DIV:
-	    case MOD:
-	      if (lvalue == INTMAX_MIN && value == -1)
-		lvalue = (op == DIV) ? INTMAX_MIN : 0;
-	      else
-#if HAVE_IMAXDIV
-		{
-		  idiv = imaxdiv (lvalue, value);
-		  lvalue = (op == DIV) ? idiv.quot : idiv.rem;
-		}
-#else
-	        lvalue = (op == DIV) ? lvalue / value : lvalue % value;
-#endif
-	      break;
-	    case PLUS:
-	      lvalue += value;
-	      break;
-	    case MINUS:
-	      lvalue -= value;
-	      break;
-	    case LSH:
-	      lvalue <<= value;
-	      break;
-	    case RSH:
-	      lvalue >>= value;
-	      break;
-	    case BAND:
-	      lvalue &= value;
-	      break;
-	    case BOR:
-	      lvalue |= value;
-	      break;
-	    case BXOR:
-	      lvalue ^= value;
-	      break;
-	    default:
-	      free (lhs);
-	      evalerror (_("bug: bad expassign token"));
-	      break;
-	    }
-	  value = lvalue;
-	}
-
-      rhs = itos (value);
-      if (noeval == 0)
-	{
-#if defined (ARRAY_VARS)
-	  if (lind != -1)
-	    expr_bind_array_element (lhs, lind, rhs);
-	  else
-#endif
-	    expr_bind_variable (lhs, rhs);
-	}
-      if (curlval.tokstr && curlval.tokstr == tokstr)
-	init_lvalue (&curlval);
-
-      free (rhs);
-      free (lhs);
-      FREE (tokstr);
-      tokstr = (char *)NULL;		/* For freeing on errors. */
-    }
-
-  return (value);
-}
-
-/* Conditional expression (expr?expr:expr) */
-static intmax_t
-expcond ()
-{
-  intmax_t cval, val1, val2, rval;
-  int set_noeval;
-
-  set_noeval = 0;
-  rval = cval = explor ();
-  if (curtok == QUES)		/* found conditional expr */
-    {
-      if (cval == 0)
-	{
-	  set_noeval = 1;
-	  noeval++;
-	}
-
-      readtok ();
-      if (curtok == 0 || curtok == COL)
-	evalerror (_("expression expected"));
-
-      val1 = EXP_LOWEST ();
-
-      if (set_noeval)
-	noeval--;
-      if (curtok != COL)
-	evalerror (_("`:' expected for conditional expression"));
-
-      set_noeval = 0;
-      if (cval)
- 	{
- 	  set_noeval = 1;
-	  noeval++;
- 	}
-
-      readtok ();
-      if (curtok == 0)
-	evalerror (_("expression expected"));
-      val2 = expcond ();
-
-      if (set_noeval)
-	noeval--;
-      rval = cval ? val1 : val2;
-      lasttok = COND;
-    }
-  return rval;
-}
-
-/* Logical OR. */
-static intmax_t
-explor ()
-{
-  register intmax_t val1, val2;
-  int set_noeval;
-
-  val1 = expland ();
-
-  while (curtok == LOR)
-    {
-      set_noeval = 0;
-      if (val1 != 0)
-	{
-	  noeval++;
-	  set_noeval = 1;
-	}
-      readtok ();
-      val2 = expland ();
-      if (set_noeval)
-	noeval--;
-      val1 = val1 || val2;
-      lasttok = LOR;
-    }
-
-  return (val1);
-}
-
-/* Logical AND. */
-static intmax_t
-expland ()
-{
-  register intmax_t val1, val2;
-  int set_noeval;
-
-  val1 = expbor ();
-
-  while (curtok == LAND)
-    {
-      set_noeval = 0;
-      if (val1 == 0)
-	{
-	  set_noeval = 1;
-	  noeval++;
-	}
-      readtok ();
-      val2 = expbor ();
-      if (set_noeval)
-	noeval--;
-      val1 = val1 && val2;
-      lasttok = LAND;
-    }
-
-  return (val1);
-}
-
-/* Bitwise OR. */
-static intmax_t
-expbor ()
-{
-  register intmax_t val1, val2;
-
-  val1 = expbxor ();
-
-  while (curtok == BOR)
-    {
-      readtok ();
-      val2 = expbxor ();
-      val1 = val1 | val2;
-      lasttok = NUM;
-    }
-
-  return (val1);
-}
-
-/* Bitwise XOR. */
-static intmax_t
-expbxor ()
-{
-  register intmax_t val1, val2;
-
-  val1 = expband ();
-
-  while (curtok == BXOR)
-    {
-      readtok ();
-      val2 = expband ();
-      val1 = val1 ^ val2;
-      lasttok = NUM;
-    }
-
-  return (val1);
-}
-
-/* Bitwise AND. */
-static intmax_t
-expband ()
-{
-  register intmax_t val1, val2;
-
-  val1 = exp5 ();
-
-  while (curtok == BAND)
-    {
-      readtok ();
-      val2 = exp5 ();
-      val1 = val1 & val2;
-      lasttok = NUM;
-    }
-
-  return (val1);
-}
-
-static intmax_t
-exp5 ()
-{
-  register intmax_t val1, val2;
-
-  val1 = exp4 ();
-
-  while ((curtok == EQEQ) || (curtok == NEQ))
-    {
-      int op = curtok;
-
-      readtok ();
-      val2 = exp4 ();
-      if (op == EQEQ)
-	val1 = (val1 == val2);
-      else if (op == NEQ)
-	val1 = (val1 != val2);
-      lasttok = NUM;
-    }
-  return (val1);
-}
-
-static intmax_t
-exp4 ()
-{
-  register intmax_t val1, val2;
-
-  val1 = expshift ();
-  while ((curtok == LEQ) ||
-	 (curtok == GEQ) ||
-	 (curtok == LT) ||
-	 (curtok == GT))
-    {
-      int op = curtok;
-
-      readtok ();
-      val2 = expshift ();
-
-      if (op == LEQ)
-	val1 = val1 <= val2;
-      else if (op == GEQ)
-	val1 = val1 >= val2;
-      else if (op == LT)
-	val1 = val1 < val2;
-      else			/* (op == GT) */
-	val1 = val1 > val2;
-      lasttok = NUM;
-    }
-  return (val1);
-}
-
-/* Left and right shifts. */
-static intmax_t
-expshift ()
-{
-  register intmax_t val1, val2;
-
-  val1 = exp3 ();
-
-  while ((curtok == LSH) || (curtok == RSH))
-    {
-      int op = curtok;
-
-      readtok ();
-      val2 = exp3 ();
-
-      if (op == LSH)
-	val1 = val1 << val2;
-      else
-	val1 = val1 >> val2;
-      lasttok = NUM;
-    }
-
-  return (val1);
-}
-
-static intmax_t
-exp3 ()
-{
-  register intmax_t val1, val2;
-
-  val1 = expmuldiv ();
-
-  while ((curtok == PLUS) || (curtok == MINUS))
-    {
-      int op = curtok;
-
-      readtok ();
-      val2 = expmuldiv ();
-
-      if (op == PLUS)
-	val1 += val2;
-      else if (op == MINUS)
-	val1 -= val2;
-      lasttok = NUM;
-    }
-  return (val1);
-}
-
-static intmax_t
-expmuldiv ()
-{
-  register intmax_t val1, val2;
-#if defined (HAVE_IMAXDIV)
-  imaxdiv_t idiv;
-#endif
-
-  val1 = exppower ();
-
-  while ((curtok == MUL) ||
-	 (curtok == DIV) ||
-	 (curtok == MOD))
-    {
-      int op = curtok;
-      char *stp, *sltp;
-
-      stp = tp;
-      readtok ();
-
-      val2 = exppower ();
-
-      /* Handle division by 0 and twos-complement arithmetic overflow */
-      if (((op == DIV) || (op == MOD)) && (val2 == 0))
-	{
-	  if (noeval == 0)
-	    {
-	      sltp = lasttp;
-	      lasttp = stp;
-	      while (lasttp && *lasttp && whitespace (*lasttp))
-		lasttp++;
-	      evalerror (_("division by 0"));
-	      lasttp = sltp;
-	    }
-	  else
-	    val2 = 1;
-	}
-      else if (op == MOD && val1 == INTMAX_MIN && val2 == -1)
-	{
-	  val1 = 0;
-	  continue;
-	}
-      else if (op == DIV && val1 == INTMAX_MIN && val2 == -1)
-	val2 = 1;
-
-      if (op == MUL)
-	val1 *= val2;
-      else if (op == DIV || op == MOD)
-#if defined (HAVE_IMAXDIV)
-	{
-	  idiv = imaxdiv (val1, val2);
-	  val1 = (op == DIV) ? idiv.quot : idiv.rem;
-	}
-#else
-	val1 = (op == DIV) ? val1 / val2 : val1 % val2;
-#endif
-      lasttok = NUM;
-    }
-  return (val1);
-}
-
-static intmax_t
-ipow (base, exp)
-     intmax_t base, exp;
-{
-  intmax_t result;
-
-  result = 1;
-  while (exp)
-    {
-      if (exp & 1)
-	result *= base;
-      exp >>= 1;
-      base *= base;
-    }
-  return result;
-}
-
-static intmax_t
-exppower ()
-{
-  register intmax_t val1, val2, c;
-
-  val1 = exp1 ();
-  while (curtok == POWER)
-    {
-      readtok ();
-      val2 = exppower ();	/* exponentiation is right-associative */
-      lasttok = NUM;
-      if (val2 == 0)
-	return (1);
-      if (val2 < 0)
-	evalerror (_("exponent less than 0"));
-      val1 = ipow (val1, val2);
-    }
-  return (val1);
-}
-
-static intmax_t
-exp1 ()
-{
-  register intmax_t val;
-
-  if (curtok == NOT)
-    {
-      readtok ();
-      val = !exp1 ();
-      lasttok = NUM;
-    }
-  else if (curtok == BNOT)
-    {
-      readtok ();
-      val = ~exp1 ();
-      lasttok = NUM;
-    }
-  else if (curtok == MINUS)
-    {
-      readtok ();
-      val = - exp1 ();
-      lasttok = NUM;
-    }
-  else if (curtok == PLUS)
-    {
-      readtok ();
-      val = exp1 ();
-      lasttok = NUM;
-    }
-  else
-    val = exp0 ();
-
-  return (val);
-}
-
-static intmax_t
-exp0 ()
-{
-  register intmax_t val = 0, v2;
-  char *vincdec;
-  int stok;
-  EXPR_CONTEXT ec;
-
-  /* XXX - might need additional logic here to decide whether or not
-	   pre-increment or pre-decrement is legal at this point. */
-  if (curtok == PREINC || curtok == PREDEC)
-    {
-      stok = lasttok = curtok;
-      readtok ();
-      if (curtok != STR)
-	/* readtok() catches this */
-	evalerror (_("identifier expected after pre-increment or pre-decrement"));
-
-      v2 = tokval + ((stok == PREINC) ? 1 : -1);
-      vincdec = itos (v2);
-      if (noeval == 0)
-	{
-#if defined (ARRAY_VARS)
-	  if (curlval.ind != -1)
-	    expr_bind_array_element (curlval.tokstr, curlval.ind, vincdec);
-	  else
-#endif
-	    if (tokstr)
-	      expr_bind_variable (tokstr, vincdec);
-	}
-      free (vincdec);
-      val = v2;
-
-      curtok = NUM;	/* make sure --x=7 is flagged as an error */
-      readtok ();
-    }
-  else if (curtok == LPAR)
-    {
-      /* XXX - save curlval here?  Or entire expression context? */
-      readtok ();
-      val = EXP_LOWEST ();
-
-      if (curtok != RPAR) /* ( */
-	evalerror (_("missing `)'"));
-
-      /* Skip over closing paren. */
-      readtok ();
-    }
-  else if ((curtok == NUM) || (curtok == STR))
-    {
-      val = tokval;
-      if (curtok == STR)
-	{
-	  SAVETOK (&ec);
-	  tokstr = (char *)NULL;	/* keep it from being freed */
-          noeval = 1;
-          readtok ();
-          stok = curtok;
-
-	  /* post-increment or post-decrement */
- 	  if (stok == POSTINC || stok == POSTDEC)
- 	    {
- 	      /* restore certain portions of EC */
- 	      tokstr = ec.tokstr;
- 	      noeval = ec.noeval;
- 	      curlval = ec.lval;
- 	      lasttok = STR;	/* ec.curtok */
-
-	      v2 = val + ((stok == POSTINC) ? 1 : -1);
-	      vincdec = itos (v2);
-	      if (noeval == 0)
-		{
-#if defined (ARRAY_VARS)
-		  if (curlval.ind != -1)
-		    expr_bind_array_element (curlval.tokstr, curlval.ind, vincdec);
-		  else
-#endif
-		    expr_bind_variable (tokstr, vincdec);
-		}
-	      free (vincdec);
-	      curtok = NUM;	/* make sure x++=7 is flagged as an error */
- 	    }
- 	  else
- 	    {
-	      /* XXX - watch out for pointer aliasing issues here */
-	      if (stok == STR)	/* free new tokstr before old one is restored */
-		FREE (tokstr);
-	      RESTORETOK (&ec);
- 	    }
-	}
-	  
-      readtok ();
-    }
-  else
-    evalerror (_("syntax error: operand expected"));
-
-  return (val);
-}
-
-static void
-init_lvalue (lv)
-     struct lvalue *lv;
-{
-  lv->tokstr = 0;
-  lv->tokvar = 0;
-  lv->tokval = lv->ind = -1;
-}
-
-static struct lvalue *
-alloc_lvalue ()
-{
-  struct lvalue *lv;
-
-  lv = xmalloc (sizeof (struct lvalue));
-  init_lvalue (lv);
-  return (lv);
-}
-
-static void
-free_lvalue (lv)
-     struct lvalue *lv;
-{
-  free (lv);		/* should be inlined */
-}
-
-static intmax_t
-expr_streval (tok, e, lvalue)
-     char *tok;
-     int e;
-     struct lvalue *lvalue;
-{
-  SHELL_VAR *v;
-  char *value;
-  intmax_t tval;
-  int initial_depth;
-#if defined (ARRAY_VARS)
-  arrayind_t ind;
-  int tflag, aflag;
-  array_eltstate_t es;
-#endif
-
-/*itrace("expr_streval: %s: noeval = %d expanded=%d", tok, noeval, already_expanded);*/
-  /* If we are suppressing evaluation, just short-circuit here instead of
-     going through the rest of the evaluator. */
-  if (noeval)
-    return (0);
-
-  initial_depth = expr_depth;
-
-#if defined (ARRAY_VARS)
-  tflag = (assoc_expand_once && already_expanded) ? AV_NOEXPAND : 0;	/* for a start */
-#endif
-
-  /* [[[[[ */
-#if defined (ARRAY_VARS)
-  aflag = tflag;	/* use a different variable for now */
-  v = (e == ']') ? array_variable_part (tok, tflag, (char **)0, (int *)0) : find_variable (tok);
-#else
-  v = find_variable (tok);
-#endif
-  if (v == 0 && e != ']')
-    v = find_variable_last_nameref (tok, 0);  
-
-  if ((v == 0 || invisible_p (v)) && unbound_vars_is_error)
-    {
-#if defined (ARRAY_VARS)
-      value = (e == ']') ? array_variable_name (tok, tflag, (char **)0, (int *)0) : tok;
-#else
-      value = tok;
-#endif
-
-      set_exit_status (EXECUTION_FAILURE);
-      err_unboundvar (value);
-
-#if defined (ARRAY_VARS)
-      if (e == ']')
-	FREE (value);	/* array_variable_name returns new memory */
-#endif
-
-      if (no_longjmp_on_fatal_error && interactive_shell)
-	sh_longjmp (evalbuf, 1);
-
-      if (interactive_shell)
-	{
-	  expr_unwind ();
-	  top_level_cleanup ();
-	  jump_to_top_level (DISCARD);
-	}
-      else
-	jump_to_top_level (FORCE_EOF);
-    }
-
-#if defined (ARRAY_VARS)
-  init_eltstate (&es);
-  es.ind = -1;
-  /* If the second argument to get_array_value doesn't include AV_ALLOWALL,
-     we don't allow references like array[@].  In this case, get_array_value
-     is just like get_variable_value in that it does not return newly-allocated
-     memory or quote the results.  AFLAG is set above and is either AV_NOEXPAND
-     or 0. */
-  value = (e == ']') ? get_array_value (tok, aflag, &es) : get_variable_value (v);
-  ind = es.ind;
-  flush_eltstate (&es);
-#else
-  value = get_variable_value (v);
-#endif
-
-  if (expr_depth < initial_depth)
-    {
-      if (no_longjmp_on_fatal_error && interactive_shell)
-	sh_longjmp (evalbuf, 1);
-      return (0);
-    }
-
-  tval = (value && *value) ? subexpr (value) : 0;
-
-  if (lvalue)
-    {
-      lvalue->tokstr = tok;	/* XXX */
-      lvalue->tokval = tval;
-      lvalue->tokvar = v;	/* XXX */
-#if defined (ARRAY_VARS)
-      lvalue->ind = ind;
-#else
-      lvalue->ind = -1;
-#endif
-    }
-	  
-  return (tval);
-}
-
-static int
-_is_multiop (c)
-     int c;
-{
-  switch (c)
-    {
-    case EQEQ:
-    case NEQ:
-    case LEQ:
-    case GEQ:
-    case LAND:
-    case LOR:
-    case LSH:
-    case RSH:
-    case OP_ASSIGN:
-    case COND:
-    case POWER:
-    case PREINC:
-    case PREDEC:
-    case POSTINC:
-    case POSTDEC:
-      return 1;
-    default:
-      return 0;
-    }
-}
-
-static int
-_is_arithop (c)
-     int c;
-{
-  switch (c)
-    {
-    case EQ:
-    case GT:
-    case LT:
-    case PLUS:
-    case MINUS:
-    case MUL:
-    case DIV:
-    case MOD:
-    case NOT:
-    case LPAR:
-    case RPAR:
-    case BAND:
-    case BOR:
-    case BXOR:
-    case BNOT:
-      return 1;		/* operator tokens */
-    case QUES:
-    case COL:
-    case COMMA:
-      return 1;		/* questionable */
-    default:
-      return 0;		/* anything else is invalid */
-    }
-}
-
-/* Lexical analyzer/token reader for the expression evaluator.  Reads the
-   next token and puts its value into curtok, while advancing past it.
-   Updates value of tp.  May also set tokval (for number) or tokstr (for
-   string). */
-static void
-readtok ()
-{
-  register char *cp, *xp;
-  register unsigned char c, c1;
-  register int e;
-  struct lvalue lval;
-
-  /* Skip leading whitespace. */
-  cp = tp;
-  c = e = 0;
-  while (cp && (c = *cp) && (cr_whitespace (c)))
-    cp++;
-
-  if (c)
-    cp++;
-
-  if (c == '\0')
-    {
-      lasttok = curtok;
-      curtok = 0;
-      tp = cp;
-      return;
-    }
-  lasttp = tp = cp - 1;
-
-  if (legal_variable_starter (c))
-    {
-      /* variable names not preceded with a dollar sign are shell variables. */
-      char *savecp;
-      EXPR_CONTEXT ec;
-      int peektok;
-
-      while (legal_variable_char (c))
-	c = *cp++;
-
-      c = *--cp;
-
-#if defined (ARRAY_VARS)
-      if (c == '[')
-	{
-	  e = expr_skipsubscript (tp, cp);		/* XXX - was skipsubscript */
-	  if (cp[e] == ']')
-	    {
-	      cp += e + 1;
-	      c = *cp;
-	      e = ']';
-	    }
-	  else
-	    evalerror (bash_badsub_errmsg);
-	}
-#endif /* ARRAY_VARS */
-
-      *cp = '\0';
-      /* XXX - watch out for pointer aliasing issues here */
-      if (curlval.tokstr && curlval.tokstr == tokstr)
-	init_lvalue (&curlval);
-
-      FREE (tokstr);
-      tokstr = savestring (tp);
-      *cp = c;
-
-      /* XXX - make peektok part of saved token state? */
-      SAVETOK (&ec);
-      tokstr = (char *)NULL;	/* keep it from being freed */
-      tp = savecp = cp;
-      noeval = 1;
-      curtok = STR;
-      readtok ();
-      peektok = curtok;
-      if (peektok == STR)	/* free new tokstr before old one is restored */
-	FREE (tokstr);
-      RESTORETOK (&ec);
-      cp = savecp;
-
-      /* The tests for PREINC and PREDEC aren't strictly correct, but they
-	 preserve old behavior if a construct like --x=9 is given. */
-      if (lasttok == PREINC || lasttok == PREDEC || peektok != EQ)
-        {
-          lastlval = curlval;
-	  tokval = expr_streval (tokstr, e, &curlval);
-        }
-      else
-	tokval = 0;
-
-      lasttok = curtok;
-      curtok = STR;
-    }
-  else if (DIGIT(c))
-    {
-      while (ISALNUM (c) || c == '#' || c == '@' || c == '_')
-	c = *cp++;
-
-      c = *--cp;
-      *cp = '\0';
-
-      tokval = strlong (tp);
-      *cp = c;
-      lasttok = curtok;
-      curtok = NUM;
-    }
-  else
-    {
-      c1 = *cp++;
-      if ((c == EQ) && (c1 == EQ))
-	c = EQEQ;
-      else if ((c == NOT) && (c1 == EQ))
-	c = NEQ;
-      else if ((c == GT) && (c1 == EQ))
-	c = GEQ;
-      else if ((c == LT) && (c1 == EQ))
-	c = LEQ;
-      else if ((c == LT) && (c1 == LT))
-	{
-	  if (*cp == '=')	/* a <<= b */
-	    {
-	      assigntok = LSH;
-	      c = OP_ASSIGN;
-	      cp++;
-	    }
-	  else
-	    c = LSH;
-	}
-      else if ((c == GT) && (c1 == GT))
-	{
-	  if (*cp == '=')
-	    {
-	      assigntok = RSH;	/* a >>= b */
-	      c = OP_ASSIGN;
-	      cp++;
-	    }
-	  else
-	    c = RSH;
-	}
-      else if ((c == BAND) && (c1 == BAND))
-	c = LAND;
-      else if ((c == BOR) && (c1 == BOR))
-	c = LOR;
-      else if ((c == '*') && (c1 == '*'))
-	c = POWER;
-      else if ((c == '-' || c == '+') && c1 == c && curtok == STR)
-	c = (c == '-') ? POSTDEC : POSTINC;
-#if STRICT_ARITH_PARSING
-      else if ((c == '-' || c == '+') && c1 == c && curtok == NUM)
-#else
-      else if ((c == '-' || c == '+') && c1 == c && curtok == NUM && (lasttok == PREINC || lasttok == PREDEC))
-#endif
-	{
-	  /* This catches something like --FOO++ */
-	  /* TAG:bash-5.3 add gettext calls here or make this a separate function */
-	  if (c == '-')
-	    evalerror ("--: assignment requires lvalue");
-	  else
-	    evalerror ("++: assignment requires lvalue");
-	}
-      else if ((c == '-' || c == '+') && c1 == c)
-	{
-	  /* Quickly scan forward to see if this is followed by optional
-	     whitespace and an identifier. */
-	  xp = cp;
-	  while (xp && *xp && cr_whitespace (*xp))
-	    xp++;
-	  if (legal_variable_starter ((unsigned char)*xp))
-	    c = (c == '-') ? PREDEC : PREINC;
-	  else
-	    /* Could force parsing as preinc or predec and throw an error */
-#if STRICT_ARITH_PARSING
-	    {
-	      /* Posix says unary plus and minus have higher priority than
-		 preinc and predec. */
-	      /* This catches something like --4++ */
-	      if (c == '-')
-		evalerror ("--: assignment requires lvalue");
-	      else
-		evalerror ("++: assignment requires lvalue");
-	    }
-#else
-	    cp--;	/* not preinc or predec, so unget the character */
-#endif
-	}
-      else if (c1 == EQ && member (c, "*/%+-&^|"))
-	{
-	  assigntok = c;	/* a OP= b */
-	  c = OP_ASSIGN;
-	}
-      else if (_is_arithop (c) == 0)
-	{
-	  cp--;
-	  /* use curtok, since it hasn't been copied to lasttok yet */
-	  if (curtok == 0 || _is_arithop (curtok) || _is_multiop (curtok))
-	    evalerror (_("syntax error: operand expected"));
-	  else
-	    evalerror (_("syntax error: invalid arithmetic operator"));
-	}
-      else
-	cp--;			/* `unget' the character */
-
-      /* Should check here to make sure that the current character is one
-	 of the recognized operators and flag an error if not.  Could create
-	 a character map the first time through and check it on subsequent
-	 calls. */
-      lasttok = curtok;
-      curtok = c;
-    }
-  tp = cp;
-}
-
-static void
-evalerror (msg)
-     const char *msg;
-{
-  char *name, *t;
-
-  name = this_command_name;
-  for (t = expression; t && whitespace (*t); t++)
-    ;
-  internal_error (_("%s%s%s: %s (error token is \"%s\")"),
-		   name ? name : "", name ? ": " : "",
-		   t ? t : "", msg, (lasttp && *lasttp) ? lasttp : "");
-  sh_longjmp (evalbuf, 1);
-}
-
-/* Convert a string to an intmax_t integer, with an arbitrary base.
-   0nnn -> base 8
-   0[Xx]nn -> base 16
-   Anything else: [base#]number (this is implemented to match ksh93)
-
-   Base may be >=2 and <=64.  If base is <= 36, the numbers are drawn
-   from [0-9][a-zA-Z], and lowercase and uppercase letters may be used
-   interchangeably.  If base is > 36 and <= 64, the numbers are drawn
-   from [0-9][a-z][A-Z]_@ (a = 10, z = 35, A = 36, Z = 61, @ = 62, _ = 63 --
-   you get the picture). */
-
-#define VALID_NUMCHAR(c)	(ISALNUM(c) || ((c) == '_') || ((c) == '@'))
-
-static intmax_t
-strlong (num)
-     char *num;
-{
-  register char *s;
-  register unsigned char c;
-  int base, foundbase;
-  intmax_t val, pval;
-
-  s = num;
-
-  base = 10;
-  foundbase = 0;
-  if (*s == '0')
-    {
-      s++;
-
-      if (*s == '\0')
-	return 0;
-
-       /* Base 16? */
-      if (*s == 'x' || *s == 'X')
-	{
-	  base = 16;
-	  s++;
-#if STRICT_ARITH_PARSING
-	  if (*s == 0)
-	    evalerror (_("invalid number"));
-#endif	    
-	}
-      else
-	base = 8;
-      foundbase++;
-    }
-
-  val = 0;
-  for (c = *s++; c; c = *s++)
-    {
-      if (c == '#')
-	{
-	  if (foundbase)
-	    evalerror (_("invalid number"));
-
-	  /* Illegal base specifications raise an evaluation error. */
-	  if (val < 2 || val > 64)
-	    evalerror (_("invalid arithmetic base"));
-
-	  base = val;
-	  val = 0;
-	  foundbase++;
-
-	  /* Make sure a base# is followed by a character that can compose a
-	     valid integer constant. Jeremy Townshend <jeremy.townshend@gmail.com> */
-	  if (VALID_NUMCHAR (*s) == 0)
-	    evalerror (_("invalid integer constant"));
-	}
-      else if (VALID_NUMCHAR (c))
-	{
-	  if (DIGIT(c))
-	    c = TODIGIT(c);
-	  else if (c >= 'a' && c <= 'z')
-	    c -= 'a' - 10;
-	  else if (c >= 'A' && c <= 'Z')
-	    c -= 'A' - ((base <= 36) ? 10 : 36);
-	  else if (c == '@')
-	    c = 62;
-	  else if (c == '_')
-	    c = 63;
-
-	  if (c >= base)
-	    evalerror (_("value too great for base"));
-
-#ifdef CHECK_OVERFLOW
-	  pval = val;
-	  val = (val * base) + c;
-	  if (val < 0 || val < pval)	/* overflow */
-	    return INTMAX_MAX;
-#else
-	  val = (val * base) + c;
-#endif
-	}
-      else
-	break;
-    }
-
-  return (val);
-}
-
-#if defined (EXPR_TEST)
-void *
-xmalloc (n)
-     int n;
-{
-  return (malloc (n));
-}
-
-void *
-xrealloc (s, n)
-     char *s;
-     int n;
-{
-  return (realloc (s, n));
-}
-
-SHELL_VAR *find_variable () { return 0;}
-SHELL_VAR *bind_variable () { return 0; }
-
-char *get_string_value () { return 0; }
-
-procenv_t top_level;
-
-main (argc, argv)
-     int argc;
-     char **argv;
-{
-  register int i;
-  intmax_t v;
-  int expok;
-
-  if (setjmp (top_level))
-    exit (0);
-
-  for (i = 1; i < argc; i++)
-    {
-      v = evalexp (argv[i], 0, &expok);
-      if (expok == 0)
-	fprintf (stderr, _("%s: expression error\n"), argv[i]);
-      else
-	printf ("'%s' -> %ld\n", argv[i], v);
-    }
-  exit (0);
-}
-
-int
-builtin_error (format, arg1, arg2, arg3, arg4, arg5)
-     char *format;
-{
-  fprintf (stderr, "expr: ");
-  fprintf (stderr, format, arg1, arg2, arg3, arg4, arg5);
-  fprintf (stderr, "\n");
-  return 0;
-}
-
-char *
-itos (n)
-     intmax_t n;
-{
-  return ("42");
-}
-
-#endif /* EXPR_TEST */
diff --git a/third_party/bash/externs.h b/third_party/bash/externs.h
deleted file mode 100644
index 931dba9cd..000000000
--- a/third_party/bash/externs.h
+++ /dev/null
@@ -1,554 +0,0 @@
-/* externs.h -- extern function declarations which do not appear in their
-   own header file. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* Make sure that this is included *after* config.h! */
-
-#if !defined (_EXTERNS_H_)
-#  define _EXTERNS_H_
-
-#include "stdc.h"
-
-/* Functions from expr.c. */
-#define EXP_EXPANDED	0x01
-
-extern intmax_t evalexp PARAMS((char *, int, int *));
-
-/* Functions from print_cmd.c. */
-#define FUNC_MULTILINE	0x01
-#define FUNC_EXTERNAL	0x02
-
-extern char *make_command_string PARAMS((COMMAND *));
-extern char *print_comsub PARAMS((COMMAND *));
-extern char *named_function_string PARAMS((char *, COMMAND *, int));
-
-extern void print_command PARAMS((COMMAND *));
-extern void print_simple_command PARAMS((SIMPLE_COM *));
-extern void print_word_list PARAMS((WORD_LIST *, char *));
-
-/* debugger support */
-extern void print_for_command_head PARAMS((FOR_COM *));
-#if defined (SELECT_COMMAND)
-extern void print_select_command_head PARAMS((SELECT_COM *));
-#endif
-extern void print_case_command_head PARAMS((CASE_COM *));
-#if defined (DPAREN_ARITHMETIC)
-extern void print_arith_command PARAMS((WORD_LIST *));
-#endif
-#if defined (COND_COMMAND)
-extern void print_cond_command PARAMS((COND_COM *));
-#endif
-
-/* set -x support */
-extern void xtrace_init PARAMS((void));
-#ifdef NEED_XTRACE_SET_DECL
-extern void xtrace_set PARAMS((int, FILE *));
-#endif
-extern void xtrace_fdchk PARAMS((int));
-extern void xtrace_reset PARAMS((void));
-extern char *indirection_level_string PARAMS((void));
-extern void xtrace_print_assignment PARAMS((char *, char *, int, int));
-extern void xtrace_print_word_list PARAMS((WORD_LIST *, int));
-extern void xtrace_print_for_command_head PARAMS((FOR_COM *));
-#if defined (SELECT_COMMAND)
-extern void xtrace_print_select_command_head PARAMS((SELECT_COM *));
-#endif
-extern void xtrace_print_case_command_head PARAMS((CASE_COM *));
-#if defined (DPAREN_ARITHMETIC)
-extern void xtrace_print_arith_cmd PARAMS((WORD_LIST *));
-#endif
-#if defined (COND_COMMAND)
-extern void xtrace_print_cond_term PARAMS((int, int, WORD_DESC *, char *, char *));
-#endif
-
-/* Functions from shell.c. */
-extern void exit_shell PARAMS((int)) __attribute__((__noreturn__));
-extern void sh_exit PARAMS((int)) __attribute__((__noreturn__));
-extern void subshell_exit PARAMS((int)) __attribute__((__noreturn__));
-extern void set_exit_status PARAMS((int));
-extern void disable_priv_mode PARAMS((void));
-extern void unbind_args PARAMS((void));
-
-#if defined (RESTRICTED_SHELL)
-extern int shell_is_restricted PARAMS((char *));
-extern int maybe_make_restricted PARAMS((char *));
-#endif
-
-extern void unset_bash_input PARAMS((int));
-extern void get_current_user_info PARAMS((void));
-
-/* Functions from eval.c. */
-extern int reader_loop PARAMS((void));
-extern int pretty_print_loop PARAMS((void));
-extern int parse_command PARAMS((void));
-extern int read_command PARAMS((void));
-
-/* Functions from braces.c. */
-#if defined (BRACE_EXPANSION)
-extern char **brace_expand PARAMS((char *));
-#endif
-
-/* Miscellaneous functions from parse.y */
-extern int yyparse PARAMS((void));
-extern int return_EOF PARAMS((void));
-extern void push_token PARAMS((int));
-extern char *xparse_dolparen PARAMS((char *, char *, int *, int));
-extern COMMAND *parse_string_to_command PARAMS((char *, int));
-extern void reset_parser PARAMS((void));
-extern void reset_readahead_token PARAMS((void));
-extern WORD_LIST *parse_string_to_word_list PARAMS((char *, int, const char *));
-
-extern int parser_will_prompt PARAMS((void));
-extern int parser_in_command_position PARAMS((void));
-
-extern void free_pushed_string_input PARAMS((void));
-
-extern int parser_expanding_alias PARAMS((void));
-extern void parser_save_alias PARAMS((void));
-extern void parser_restore_alias PARAMS((void));
-
-extern void clear_shell_input_line PARAMS((void));
-
-extern char *decode_prompt_string PARAMS((char *));
-
-extern int get_current_prompt_level PARAMS((void));
-extern void set_current_prompt_level PARAMS((int));
-
-#if defined (HISTORY)
-extern char *history_delimiting_chars PARAMS((const char *));
-#endif
-
-/* Declarations for functions defined in locale.c */
-extern void set_default_locale PARAMS((void));
-extern void set_default_locale_vars PARAMS((void));
-extern int set_locale_var PARAMS((char *, char *));
-extern int set_lang PARAMS((char *, char *));
-extern void set_default_lang PARAMS((void));
-extern char *get_locale_var PARAMS((char *));
-extern char *localetrans PARAMS((char *, int, int *));
-extern char *mk_msgstr PARAMS((char *, int *));
-extern char *locale_expand PARAMS((char *, int, int, int, int *));
-#ifndef locale_decpoint
-extern int locale_decpoint PARAMS((void));
-#endif
-
-/* Declarations for functions defined in list.c. */
-extern void list_walk PARAMS((GENERIC_LIST *, sh_glist_func_t *));
-extern void wlist_walk PARAMS((WORD_LIST *, sh_icpfunc_t *));
-extern GENERIC_LIST *list_reverse ();
-extern int list_length ();
-extern GENERIC_LIST *list_append ();
-extern GENERIC_LIST *list_remove ();
-
-/* Declarations for functions defined in stringlib.c */
-extern int find_string_in_alist PARAMS((char *, STRING_INT_ALIST *, int));
-extern char *find_token_in_alist PARAMS((int, STRING_INT_ALIST *, int));
-extern int find_index_in_alist PARAMS((char *, STRING_INT_ALIST *, int));
-
-extern char *substring PARAMS((const char *, int, int));
-extern char *strsub PARAMS((char *, char *, char *, int));
-extern char *strcreplace PARAMS((char *, int, const char *, int));
-extern void strip_leading PARAMS((char *));
-extern void strip_trailing PARAMS((char *, int, int));
-extern void xbcopy PARAMS((char *, char *, int));
-
-/* Functions from version.c. */
-extern char *shell_version_string PARAMS((void));
-extern void show_shell_version PARAMS((int));
-
-/* Functions from the bash library, lib/sh/libsh.a.  These should really
-   go into a separate include file. */
-
-/* declarations for functions defined in lib/sh/casemod.c */
-extern char *sh_modcase PARAMS((const char *, char *, int));
-
-/* Defines for flags argument to sh_modcase.  These need to agree with what's
-   in lib/sh/casemode.c */
-#define CASE_LOWER	0x0001
-#define CASE_UPPER	0x0002
-#define CASE_CAPITALIZE	0x0004
-#define CASE_UNCAP	0x0008
-#define CASE_TOGGLE	0x0010
-#define CASE_TOGGLEALL	0x0020
-#define CASE_UPFIRST	0x0040
-#define CASE_LOWFIRST	0x0080
-
-#define CASE_USEWORDS	0x1000
-
-/* declarations for functions defined in lib/sh/clktck.c */
-extern long get_clk_tck PARAMS((void));
-
-/* declarations for functions defined in lib/sh/clock.c */
-extern void clock_t_to_secs ();
-extern void print_clock_t ();
-
-/* Declarations for functions defined in lib/sh/dprintf.c */
-#if !defined (HAVE_DPRINTF)
-extern void dprintf PARAMS((int, const char *, ...))  __attribute__((__format__ (printf, 2, 3)));
-#endif
-
-/* Declarations for functions defined in lib/sh/fmtulong.c */
-#define FL_PREFIX     0x01    /* add 0x, 0X, or 0 prefix as appropriate */
-#define FL_ADDBASE    0x02    /* add base# prefix to converted value */
-#define FL_HEXUPPER   0x04    /* use uppercase when converting to hex */
-#define FL_UNSIGNED   0x08    /* don't add any sign */
-
-extern char *fmtulong PARAMS((unsigned long int, int, char *, size_t, int));
-
-/* Declarations for functions defined in lib/sh/fmtulong.c */
-#if defined (HAVE_LONG_LONG_INT)
-extern char *fmtullong PARAMS((unsigned long long int, int, char *, size_t, int));
-#endif
-
-/* Declarations for functions defined in lib/sh/fmtumax.c */
-extern char *fmtumax PARAMS((uintmax_t, int, char *, size_t, int));
-
-/* Declarations for functions defined in lib/sh/fnxform.c */
-extern char *fnx_fromfs PARAMS((char *, size_t));
-extern char *fnx_tofs PARAMS((char *, size_t));
-
-/* Declarations for functions defined in lib/sh/fpurge.c */
-
-#if defined NEED_FPURGE_DECL
-#if !HAVE_DECL_FPURGE
-
-#if HAVE_FPURGE
-#  define fpurge _bash_fpurge
-#endif
-extern int fpurge PARAMS((FILE *stream));
-
-#endif /* HAVE_DECL_FPURGE */
-#endif /* NEED_FPURGE_DECL */
-
-/* Declarations for functions defined in lib/sh/getcwd.c */
-#if !defined (HAVE_GETCWD)
-extern char *getcwd PARAMS((char *, size_t));
-#endif
-
-/* Declarations for functions defined in lib/sh/input_avail.c */
-extern int input_avail PARAMS((int));
-
-/* Declarations for functions defined in lib/sh/itos.c */
-extern char *inttostr PARAMS((intmax_t, char *, size_t));
-extern char *itos PARAMS((intmax_t));
-extern char *mitos PARAMS((intmax_t));
-extern char *uinttostr PARAMS((uintmax_t, char *, size_t));
-extern char *uitos PARAMS((uintmax_t));
-
-/* declarations for functions defined in lib/sh/makepath.c */
-#define MP_DOTILDE	0x01
-#define MP_DOCWD	0x02
-#define MP_RMDOT	0x04
-#define MP_IGNDOT	0x08
-
-extern char *sh_makepath PARAMS((const char *, const char *, int));
-
-/* declarations for functions defined in lib/sh/mbscasecmp.c */
-#if !defined (HAVE_MBSCASECMP)
-extern char *mbscasecmp PARAMS((const char *, const char *));
-#endif
-
-/* declarations for functions defined in lib/sh/mbschr.c */
-#if !defined (HAVE_MBSCHR)
-extern char *mbschr PARAMS((const char *, int));
-#endif
-
-/* declarations for functions defined in lib/sh/mbscmp.c */
-#if !defined (HAVE_MBSCMP)
-extern char *mbscmp PARAMS((const char *, const char *));
-#endif
-
-/* declarations for functions defined in lib/sh/netconn.c */
-extern int isnetconn PARAMS((int));
-
-/* declarations for functions defined in lib/sh/netopen.c */
-extern int netopen PARAMS((char *));
-
-/* Declarations for  functions defined in lib/sh/oslib.c */
-
-#if !defined (HAVE_DUP2) || defined (DUP2_BROKEN)
-extern int dup2 PARAMS((int, int));
-#endif
-
-#if !defined (HAVE_GETDTABLESIZE)
-extern int getdtablesize PARAMS((void));
-#endif /* !HAVE_GETDTABLESIZE */
-
-#if !defined (HAVE_GETHOSTNAME)
-extern int gethostname PARAMS((char *, int));
-#endif /* !HAVE_GETHOSTNAME */
-
-extern int getmaxgroups PARAMS((void));
-extern long getmaxchild PARAMS((void));
-
-/* declarations for functions defined in lib/sh/pathcanon.c */
-#define PATH_CHECKDOTDOT	0x0001
-#define PATH_CHECKEXISTS	0x0002
-#define PATH_HARDPATH		0x0004
-#define PATH_NOALLOC		0x0008
-
-extern char *sh_canonpath PARAMS((char *, int));
-
-/* declarations for functions defined in lib/sh/pathphys.c */
-extern char *sh_physpath PARAMS((char *, int));
-extern char *sh_realpath PARAMS((const char *, char *));
-
-/* declarations for functions defined in lib/sh/random.c */
-extern int brand PARAMS((void));
-extern void sbrand PARAMS((unsigned long));		/* set bash random number generator. */
-extern void seedrand PARAMS((void));			/* seed generator randomly */
-extern void seedrand32 PARAMS((void));
-extern u_bits32_t get_urandom32 PARAMS((void));
-
-/* declarations for functions defined in lib/sh/setlinebuf.c */
-#ifdef NEED_SH_SETLINEBUF_DECL
-extern int sh_setlinebuf PARAMS((FILE *));
-#endif
-
-/* declarations for functions defined in lib/sh/shaccess.c */
-extern int sh_eaccess PARAMS((const char *, int));
-
-/* declarations for functions defined in lib/sh/shmatch.c */
-extern int sh_regmatch PARAMS((const char *, const char *, int));
-
-/* defines for flags argument to sh_regmatch. */
-#define SHMAT_SUBEXP		0x001	/* save subexpressions in SH_REMATCH */
-#define SHMAT_PWARN		0x002	/* print a warning message on invalid regexp */
-
-/* declarations for functions defined in lib/sh/shmbchar.c */
-extern size_t mbstrlen PARAMS((const char *));
-extern char *mbsmbchar PARAMS((const char *));
-extern int sh_mbsnlen PARAMS((const char *, size_t, int));
-
-/* declarations for functions defined in lib/sh/shquote.c */
-extern char *sh_single_quote PARAMS((const char *));
-extern char *sh_double_quote PARAMS((const char *));
-extern char *sh_mkdoublequoted PARAMS((const char *, int, int));
-extern char *sh_un_double_quote PARAMS((char *));
-extern char *sh_backslash_quote PARAMS((char *, const char *, int));
-extern char *sh_backslash_quote_for_double_quotes PARAMS((char *, int));
-extern char *sh_quote_reusable PARAMS((char *, int));
-extern int sh_contains_shell_metas PARAMS((const char *));
-extern int sh_contains_quotes PARAMS((const char *));
-
-/* declarations for functions defined in lib/sh/spell.c */
-extern int spname PARAMS((char *, char *));
-extern char *dirspell PARAMS((char *));
-
-/* declarations for functions defined in lib/sh/strcasecmp.c */
-#if !defined (HAVE_STRCASECMP)
-extern int strncasecmp PARAMS((const char *, const char *, size_t));
-extern int strcasecmp PARAMS((const char *, const char *));
-#endif /* HAVE_STRCASECMP */
-
-/* declarations for functions defined in lib/sh/strcasestr.c */
-#if ! HAVE_STRCASESTR
-extern char *strcasestr PARAMS((const char *, const char *));
-#endif
-
-/* declarations for functions defined in lib/sh/strchrnul.c */
-#if ! HAVE_STRCHRNUL
-extern char *strchrnul PARAMS((const char *, int));
-#endif
-
-/* declarations for functions defined in lib/sh/strerror.c */
-#if !defined (HAVE_STRERROR) && !defined (strerror)
-extern char *strerror PARAMS((int));
-#endif
-
-/* declarations for functions defined in lib/sh/strftime.c */
-#if !defined (HAVE_STRFTIME) && defined (NEED_STRFTIME_DECL)
-extern size_t strftime PARAMS((char *, size_t, const char *, const struct tm *));
-#endif
-
-/* declarations for functions and structures defined in lib/sh/stringlist.c */
-
-/* This is a general-purpose argv-style array struct. */
-typedef struct _list_of_strings {
-  char **list;
-  int list_size;
-  int list_len;
-} STRINGLIST;
-
-typedef int sh_strlist_map_func_t PARAMS((char *));
-
-extern STRINGLIST *strlist_create PARAMS((int));
-extern STRINGLIST *strlist_resize PARAMS((STRINGLIST *, int));
-extern void strlist_flush PARAMS((STRINGLIST *));
-extern void strlist_dispose PARAMS((STRINGLIST *));
-extern int strlist_remove PARAMS((STRINGLIST *, char *));
-extern STRINGLIST *strlist_copy PARAMS((STRINGLIST *));
-extern STRINGLIST *strlist_merge PARAMS((STRINGLIST *, STRINGLIST *));
-extern STRINGLIST *strlist_append PARAMS((STRINGLIST *, STRINGLIST *));
-extern STRINGLIST *strlist_prefix_suffix PARAMS((STRINGLIST *, char *, char *));
-extern void strlist_print PARAMS((STRINGLIST *, char *));
-extern void strlist_walk PARAMS((STRINGLIST *, sh_strlist_map_func_t *));
-extern void strlist_sort PARAMS((STRINGLIST *));
-
-/* declarations for functions defined in lib/sh/stringvec.c */
-
-extern char **strvec_create PARAMS((int));
-extern char **strvec_resize PARAMS((char **, int));
-extern char **strvec_mcreate PARAMS((int));
-extern char **strvec_mresize PARAMS((char **, int));
-extern void strvec_flush PARAMS((char **));
-extern void strvec_dispose PARAMS((char **));
-extern int strvec_remove PARAMS((char **, char *));
-extern int strvec_len PARAMS((char **));
-extern int strvec_search PARAMS((char **, char *));
-extern char **strvec_copy PARAMS((char **));
-extern int strvec_posixcmp PARAMS((char **, char **));
-extern int strvec_strcmp PARAMS((char **, char **));
-extern void strvec_sort PARAMS((char **, int));
-
-extern char **strvec_from_word_list PARAMS((WORD_LIST *, int, int, int *));
-extern WORD_LIST *strvec_to_word_list PARAMS((char **, int, int));
-
-/* declarations for functions defined in lib/sh/strnlen.c */
-#if !defined (HAVE_STRNLEN)
-extern size_t strnlen PARAMS((const char *, size_t));
-#endif
-
-/* declarations for functions defined in lib/sh/strpbrk.c */
-#if !defined (HAVE_STRPBRK)
-extern char *strpbrk PARAMS((const char *, const char *));
-#endif
-
-/* declarations for functions defined in lib/sh/strtod.c */
-#if !defined (HAVE_STRTOD)
-extern double strtod PARAMS((const char *, char **));
-#endif
-
-/* declarations for functions defined in lib/sh/strtol.c */
-#if !HAVE_DECL_STRTOL
-extern long strtol PARAMS((const char *, char **, int));
-#endif
-
-/* declarations for functions defined in lib/sh/strtoll.c */
-#if defined (HAVE_LONG_LONG_INT) && !HAVE_DECL_STRTOLL
-extern long long strtoll PARAMS((const char *, char **, int));
-#endif
-
-/* declarations for functions defined in lib/sh/strtoul.c */
-#if !HAVE_DECL_STRTOUL
-extern unsigned long strtoul PARAMS((const char *, char **, int));
-#endif
-
-/* declarations for functions defined in lib/sh/strtoull.c */
-#if defined (HAVE_UNSIGNED_LONG_LONG_INT) && !HAVE_DECL_STRTOULL
-extern unsigned long long strtoull PARAMS((const char *, char **, int));
-#endif
-
-/* declarations for functions defined in lib/sh/strimax.c */
-#if !HAVE_DECL_STRTOIMAX
-extern intmax_t strtoimax PARAMS((const char *, char **, int));
-#endif
-
-/* declarations for functions defined in lib/sh/strumax.c */
-#if !HAVE_DECL_STRTOUMAX
-extern uintmax_t strtoumax PARAMS((const char *, char **, int));
-#endif
-
-/* declarations for functions defined in lib/sh/strtrans.c */
-extern char *ansicstr PARAMS((char *, int, int, int *, int *));
-extern char *ansic_quote PARAMS((char *, int, int *));
-extern int ansic_shouldquote PARAMS((const char *));
-extern char *ansiexpand PARAMS((char *, int, int, int *));
-
-/* declarations for functions defined in lib/sh/strvis.c */
-extern int sh_charvis PARAMS((const char *, size_t *, size_t, char *, size_t *));
-extern char *sh_strvis PARAMS((const char *));
-
-/* declarations for functions defined in lib/sh/timeval.c.  No prototypes
-   so we don't have to count on having a definition of struct timeval in
-   scope when this file is included. */
-extern void timeval_to_secs ();
-extern void print_timeval ();
-
-/* declarations for functions defined in lib/sh/tmpfile.c */
-#define MT_USETMPDIR		0x0001
-#define MT_READWRITE		0x0002
-#define MT_USERANDOM		0x0004
-#define MT_TEMPLATE		0x0008
-
-extern char *sh_mktmpname PARAMS((char *, int));
-extern int sh_mktmpfd PARAMS((char *, int, char **));
-/* extern FILE *sh_mktmpfp PARAMS((char *, int, char **)); */
-extern char *sh_mktmpdir PARAMS((char *, int));
-
-/* declarations for functions defined in lib/sh/uconvert.c */
-extern int uconvert PARAMS((char *, long *, long *, char **));
-
-/* declarations for functions defined in lib/sh/ufuncs.c */
-extern unsigned int falarm PARAMS((unsigned int, unsigned int));
-extern unsigned int fsleep PARAMS((unsigned int, unsigned int));
-
-/* declarations for functions defined in lib/sh/unicode.c */
-extern int u32cconv PARAMS((unsigned long, char *));
-extern void u32reset PARAMS((void));
-
-/* declarations for functions defined in lib/sh/utf8.c */
-extern char *utf8_mbschr PARAMS((const char *, int));
-extern int utf8_mbscmp PARAMS((const char *, const char *));
-extern char *utf8_mbsmbchar PARAMS((const char *));
-extern int utf8_mbsnlen PARAMS((const char *, size_t, int));
-extern int utf8_mblen PARAMS((const char *, size_t));
-extern size_t utf8_mbstrlen PARAMS((const char *));
-
-/* declarations for functions defined in lib/sh/wcsnwidth.c */
-#if defined (HANDLE_MULTIBYTE)
-extern int wcsnwidth PARAMS((const wchar_t *, size_t, int));
-#endif
-
-/* declarations for functions defined in lib/sh/winsize.c */
-extern void get_new_window_size PARAMS((int, int *, int *));
-
-/* declarations for functions defined in lib/sh/zcatfd.c */
-extern int zcatfd PARAMS((int, int, char *));
-
-/* declarations for functions defined in lib/sh/zgetline.c */
-extern ssize_t zgetline PARAMS((int, char **, size_t *, int, int));
-
-/* declarations for functions defined in lib/sh/zmapfd.c */
-extern int zmapfd PARAMS((int, char **, char *));
-
-/* declarations for functions defined in lib/sh/zread.c */
-extern ssize_t zread PARAMS((int, char *, size_t));
-extern ssize_t zreadretry PARAMS((int, char *, size_t));
-extern ssize_t zreadintr PARAMS((int, char *, size_t));
-extern ssize_t zreadc PARAMS((int, char *));
-extern ssize_t zreadcintr PARAMS((int, char *));
-extern ssize_t zreadn PARAMS((int, char *, size_t));
-extern void zreset PARAMS((void));
-extern void zsyncfd PARAMS((int));
-
-/* declarations for functions defined in lib/sh/zwrite.c */
-extern int zwrite PARAMS((int, char *, size_t));
-
-/* declarations for functions defined in lib/glob/gmisc.c */
-extern int match_pattern_char PARAMS((char *, char *, int));
-extern int umatchlen PARAMS((char *, size_t));
-
-#if defined (HANDLE_MULTIBYTE)
-extern int match_pattern_wchar PARAMS((wchar_t *, wchar_t *, int));
-extern int wmatchlen PARAMS((wchar_t *, size_t));
-#endif
-
-#endif /* _EXTERNS_H_ */
diff --git a/third_party/bash/filecntl.h b/third_party/bash/filecntl.h
deleted file mode 100644
index 9bcbab8d5..000000000
--- a/third_party/bash/filecntl.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/* filecntl.h - Definitions to set file descriptors to close-on-exec. */
-
-/* Copyright (C) 1993 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_FILECNTL_H_)
-#define _FILECNTL_H_
-
-#include <fcntl.h>
-
-/* Definitions to set file descriptors to close-on-exec, the Posix way. */
-#if !defined (FD_CLOEXEC)
-#define FD_CLOEXEC     1
-#endif
-
-#define FD_NCLOEXEC    0
-
-#define SET_CLOSE_ON_EXEC(fd)  (fcntl ((fd), F_SETFD, FD_CLOEXEC))
-#define SET_OPEN_ON_EXEC(fd)   (fcntl ((fd), F_SETFD, FD_NCLOEXEC))
-
-/* How to open a file in non-blocking mode, the Posix.1 way. */
-#if !defined (O_NONBLOCK)
-#  if defined (O_NDELAY)
-#    define O_NONBLOCK O_NDELAY
-#  else
-#    define O_NONBLOCK 0
-#  endif
-#endif
-
-/* Make sure O_BINARY and O_TEXT are defined to avoid Windows-specific code. */
-#if !defined (O_BINARY)
-#  define O_BINARY 0
-#endif
-#if !defined (O_TEXT)
-#  define O_TEXT 0
-#endif
-
-#endif /* ! _FILECNTL_H_ */
diff --git a/third_party/bash/findcmd.c b/third_party/bash/findcmd.c
deleted file mode 100644
index 7c3017820..000000000
--- a/third_party/bash/findcmd.c
+++ /dev/null
@@ -1,696 +0,0 @@
-/* findcmd.c -- Functions to search for commands by name. */
-
-/* Copyright (C) 1997-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <stdio.h>
-#include "chartypes.h"
-#include "bashtypes.h"
-#if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-#include "filecntl.h"
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-#include <errno.h>
-
-#include "bashansi.h"
-
-#include "memalloc.h"
-#include "shell.h"
-#include "execute_cmd.h"
-#include "flags.h"
-#include "hashlib.h"
-#include "pathexp.h"
-#include "hashcmd.h"
-#include "findcmd.h"	/* matching prototypes and declarations */
-
-#include "strmatch.h"
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-/* Static functions defined and used in this file. */
-static char *_find_user_command_internal PARAMS((const char *, int));
-static char *find_user_command_internal PARAMS((const char *, int));
-static char *find_user_command_in_path PARAMS((const char *, char *, int, int *));
-static char *find_in_path_element PARAMS((const char *, char *, int, int, struct stat *, int *));
-static char *find_absolute_program PARAMS((const char *, int));
-
-static char *get_next_path_element PARAMS((char *, int *));
-
-/* The file name which we would try to execute, except that it isn't
-   possible to execute it.  This is the first file that matches the
-   name that we are looking for while we are searching $PATH for a
-   suitable one to execute.  If we cannot find a suitable executable
-   file, then we use this one. */
-static char *file_to_lose_on;
-
-/* Non-zero if we should stat every command found in the hash table to
-   make sure it still exists. */
-int check_hashed_filenames = CHECKHASH_DEFAULT;
-
-/* DOT_FOUND_IN_SEARCH becomes non-zero when find_user_command ()
-   encounters a `.' as the directory pathname while scanning the
-   list of possible pathnames; i.e., if `.' comes before the directory
-   containing the file of interest. */
-int dot_found_in_search = 0;
-
-/* Set up EXECIGNORE; a blacklist of patterns that executable files should not
-   match. */
-static struct ignorevar execignore =
-{
-  "EXECIGNORE",
-  NULL,
-  0,
-  NULL,
-  NULL
-};
-
-void
-setup_exec_ignore (varname)
-     char *varname;
-{
-  setup_ignore_patterns (&execignore);
-}
-
-static int
-exec_name_should_ignore (name)
-     const char *name;
-{
-  struct ign *p;
-
-  for (p = execignore.ignores; p && p->val; p++)
-    if (strmatch (p->val, (char *)name, FNMATCH_EXTFLAG|FNM_CASEFOLD) != FNM_NOMATCH)
-      return 1;
-  return 0;
-}
-
-/* Return some flags based on information about this file.
-   The EXISTS bit is non-zero if the file is found.
-   The EXECABLE bit is non-zero the file is executable.
-   Zero is returned if the file is not found. */
-int
-file_status (name)
-     const char *name;
-{
-  struct stat finfo;
-  int r;
-
-  /* Determine whether this file exists or not. */
-  if (stat (name, &finfo) < 0)
-    return (0);
-
-  /* If the file is a directory, then it is not "executable" in the
-     sense of the shell. */
-  if (S_ISDIR (finfo.st_mode))
-    return (FS_EXISTS|FS_DIRECTORY);
-
-  r = FS_EXISTS;
-
-#if defined (HAVE_EACCESS)
-  /* Use eaccess(2) if we have it to take things like ACLs and other
-     file access mechanisms into account.  eaccess uses the effective
-     user and group IDs, not the real ones.  We could use sh_eaccess,
-     but we don't want any special treatment for /dev/fd. */
-  if (exec_name_should_ignore (name) == 0 && eaccess (name, X_OK) == 0)
-    r |= FS_EXECABLE;
-  if (eaccess (name, R_OK) == 0)
-    r |= FS_READABLE;
-
-  return r;
-#elif defined (AFS)
-  /* We have to use access(2) to determine access because AFS does not
-     support Unix file system semantics.  This may produce wrong
-     answers for non-AFS files when ruid != euid.  I hate AFS. */
-  if (exec_name_should_ignore (name) == 0 && access (name, X_OK) == 0)
-    r |= FS_EXECABLE;
-  if (access (name, R_OK) == 0)
-    r |= FS_READABLE;
-
-  return r;
-#else /* !HAVE_EACCESS && !AFS */
-
-  /* Find out if the file is actually executable.  By definition, the
-     only other criteria is that the file has an execute bit set that
-     we can use.  The same with whether or not a file is readable. */
-
-  /* Root only requires execute permission for any of owner, group or
-     others to be able to exec a file, and can read any file. */
-  if (current_user.euid == (uid_t)0)
-    {
-      r |= FS_READABLE;
-      if (exec_name_should_ignore (name) == 0 && (finfo.st_mode & S_IXUGO))
-	r |= FS_EXECABLE;
-      return r;
-    }
-
-  /* If we are the owner of the file, the owner bits apply. */
-  if (current_user.euid == finfo.st_uid)
-    {
-      if (exec_name_should_ignore (name) == 0 && (finfo.st_mode & S_IXUSR))
-	r |= FS_EXECABLE;
-      if (finfo.st_mode & S_IRUSR)
-	r |= FS_READABLE;
-    }
-
-  /* If we are in the owning group, the group permissions apply. */
-  else if (group_member (finfo.st_gid))
-    {
-      if (exec_name_should_ignore (name) == 0 && (finfo.st_mode & S_IXGRP))
-	r |= FS_EXECABLE;
-      if (finfo.st_mode & S_IRGRP)
-	r |= FS_READABLE;
-    }
-
-  /* Else we check whether `others' have permission to execute the file */
-  else
-    {
-      if (exec_name_should_ignore (name) == 0 && finfo.st_mode & S_IXOTH)
-	r |= FS_EXECABLE;
-      if (finfo.st_mode & S_IROTH)
-	r |= FS_READABLE;
-    }
-
-  return r;
-#endif /* !AFS */
-}
-
-/* Return non-zero if FILE exists and is executable.
-   Note that this function is the definition of what an
-   executable file is; do not change this unless YOU know
-   what an executable file is. */
-int
-executable_file (file)
-     const char *file;
-{
-  int s;
-
-  s = file_status (file);
-#if defined (EISDIR)
-  if (s & FS_DIRECTORY)
-    errno = EISDIR;	/* let's see if we can improve error messages */
-#endif
-  return ((s & FS_EXECABLE) && ((s & FS_DIRECTORY) == 0));
-}
-
-int
-is_directory (file)
-     const char *file;
-{
-  return (file_status (file) & FS_DIRECTORY);
-}
-
-int
-executable_or_directory (file)
-     const char *file;
-{
-  int s;
-
-  s = file_status (file);
-  return ((s & FS_EXECABLE) || (s & FS_DIRECTORY));
-}
-
-/* Locate the executable file referenced by NAME, searching along
-   the contents of the shell PATH variable.  Return a new string
-   which is the full pathname to the file, or NULL if the file
-   couldn't be found.  If a file is found that isn't executable,
-   and that is the only match, then return that. */
-char *
-find_user_command (name)
-     const char *name;
-{
-  return (find_user_command_internal (name, FS_EXEC_PREFERRED|FS_NODIRS));
-}
-
-/* Locate the file referenced by NAME, searching along the contents
-   of the shell PATH variable.  Return a new string which is the full
-   pathname to the file, or NULL if the file couldn't be found.  This
-   returns the first readable file found; designed to be used to look
-   for shell scripts or files to source. */
-char *
-find_path_file (name)
-     const char *name;
-{
-  return (find_user_command_internal (name, FS_READABLE));
-}
-
-static char *
-_find_user_command_internal (name, flags)
-     const char *name;
-     int flags;
-{
-  char *path_list, *cmd;
-  SHELL_VAR *var;
-
-  /* Search for the value of PATH in both the temporary environments and
-     in the regular list of variables. */
-  if (var = find_variable_tempenv ("PATH"))	/* XXX could be array? */
-    path_list = value_cell (var);
-  else
-    path_list = (char *)NULL;
-
-  if (path_list == 0 || *path_list == '\0')
-    return (savestring (name));
-
-  cmd = find_user_command_in_path (name, path_list, flags, (int *)0);
-
-  return (cmd);
-}
-
-static char *
-find_user_command_internal (name, flags)
-     const char *name;
-     int flags;
-{
-#ifdef __WIN32__
-  char *res, *dotexe;
-
-  dotexe = (char *)xmalloc (strlen (name) + 5);
-  strcpy (dotexe, name);
-  strcat (dotexe, ".exe");
-  res = _find_user_command_internal (dotexe, flags);
-  free (dotexe);
-  if (res == 0)
-    res = _find_user_command_internal (name, flags);
-  return res;
-#else
-  return (_find_user_command_internal (name, flags));
-#endif
-}
-
-/* Return the next element from PATH_LIST, a colon separated list of
-   paths.  PATH_INDEX_POINTER is the address of an index into PATH_LIST;
-   the index is modified by this function.
-   Return the next element of PATH_LIST or NULL if there are no more. */
-static char *
-get_next_path_element (path_list, path_index_pointer)
-     char *path_list;
-     int *path_index_pointer;
-{
-  char *path;
-
-  path = extract_colon_unit (path_list, path_index_pointer);
-
-  if (path == 0)
-    return (path);
-
-  if (*path == '\0')
-    {
-      free (path);
-      path = savestring (".");
-    }
-
-  return (path);
-}
-
-/* Look for PATHNAME in $PATH.  Returns either the hashed command
-   corresponding to PATHNAME or the first instance of PATHNAME found
-   in $PATH.  If (FLAGS&CMDSRCH_HASH) is non-zero, insert the instance of
-   PATHNAME found in $PATH into the command hash table.
-   If (FLAGS&CMDSRCH_STDPATH) is non-zero, we are running in a `command -p'
-   environment and should use the Posix standard path.
-   Returns a newly-allocated string. */
-char *
-search_for_command (pathname, flags)
-     const char *pathname;
-     int flags;
-{
-  char *hashed_file, *command, *path_list;
-  int temp_path, st;
-  SHELL_VAR *path;
-
-  hashed_file = command = (char *)NULL;
-
-  /* If PATH is in the temporary environment for this command, don't use the
-     hash table to search for the full pathname. */
-  path = find_variable_tempenv ("PATH");
-  temp_path = path && tempvar_p (path);
-
-  /* Don't waste time trying to find hashed data for a pathname
-     that is already completely specified or if we're using a command-
-     specific value for PATH. */
-  if (temp_path == 0 && (flags & CMDSRCH_STDPATH) == 0 && absolute_program (pathname) == 0)
-    hashed_file = phash_search (pathname);
-
-  /* If a command found in the hash table no longer exists, we need to
-     look for it in $PATH.  Thank you Posix.2.  This forces us to stat
-     every command found in the hash table. */
-
-  if (hashed_file && (posixly_correct || check_hashed_filenames))
-    {
-      st = file_status (hashed_file);
-      if ((st & (FS_EXISTS|FS_EXECABLE)) != (FS_EXISTS|FS_EXECABLE))
-	{
-	  phash_remove (pathname);
-	  free (hashed_file);
-	  hashed_file = (char *)NULL;
-	}
-    }
-
-  if (hashed_file)
-    command = hashed_file;
-  else if (absolute_program (pathname))
-    /* A command containing a slash is not looked up in PATH or saved in
-       the hash table. */
-    command = savestring (pathname);
-  else
-    {
-      if (flags & CMDSRCH_STDPATH)
-	path_list = conf_standard_path ();
-      else if (temp_path || path)
-	path_list = value_cell (path);
-      else
-	path_list = 0;
-
-      command = find_user_command_in_path (pathname, path_list, FS_EXEC_PREFERRED|FS_NODIRS, &st);
-
-      if (command && hashing_enabled && temp_path == 0 && (flags & CMDSRCH_HASH))
-	{
-	  /* If we found the full pathname the same as the command name, the
-	     command probably doesn't exist.  Don't put it into the hash
-	     table unless it's an executable file in the current directory. */
-	  if (STREQ (command, pathname))
-	    {
-	      if (st & FS_EXECABLE)
-	        phash_insert ((char *)pathname, command, dot_found_in_search, 1);
-	    }
-	  /* If we're in posix mode, don't add files without the execute bit
-	     to the hash table. */
-	  else if (posixly_correct || check_hashed_filenames)
-	    {
-	      if (st & FS_EXECABLE)
-	        phash_insert ((char *)pathname, command, dot_found_in_search, 1);
-	    }
-	  else
-	    phash_insert ((char *)pathname, command, dot_found_in_search, 1);
-	}
-
-      if (flags & CMDSRCH_STDPATH)
-	free (path_list);
-    }
-
-  return (command);
-}
-
-char *
-user_command_matches (name, flags, state)
-     const char *name;
-     int flags, state;
-{
-  register int i;
-  int  path_index, name_len;
-  char *path_list, *path_element, *match;
-  struct stat dotinfo;
-  static char **match_list = NULL;
-  static int match_list_size = 0;
-  static int match_index = 0;
-
-  if (state == 0)
-    {
-      /* Create the list of matches. */
-      if (match_list == 0)
-	{
-	  match_list_size = 5;
-	  match_list = strvec_create (match_list_size);
-	}
-
-      /* Clear out the old match list. */
-      for (i = 0; i < match_list_size; i++)
-	match_list[i] = 0;
-
-      /* We haven't found any files yet. */
-      match_index = 0;
-
-      if (absolute_program (name))
-	{
-	  match_list[0] = find_absolute_program (name, flags);
-	  match_list[1] = (char *)NULL;
-	  path_list = (char *)NULL;
-	}
-      else
-	{
-	  name_len = strlen (name);
-	  file_to_lose_on = (char *)NULL;
-	  dot_found_in_search = 0;
-	  if (stat (".", &dotinfo) < 0)
-	    dotinfo.st_dev = dotinfo.st_ino = 0;	/* so same_file won't match */
-	  path_list = get_string_value ("PATH");
-      	  path_index = 0;
-	}
-
-      while (path_list && path_list[path_index])
-	{
-	  path_element = get_next_path_element (path_list, &path_index);
-
-	  if (path_element == 0)
-	    break;
-
-	  match = find_in_path_element (name, path_element, flags, name_len, &dotinfo, (int *)0);
-	  free (path_element);
-
-	  if (match == 0)
-	    continue;
-
-	  if (match_index + 1 == match_list_size)
-	    {
-	      match_list_size += 10;
-	      match_list = strvec_resize (match_list, (match_list_size + 1));
-	    }
-
-	  match_list[match_index++] = match;
-	  match_list[match_index] = (char *)NULL;
-	  FREE (file_to_lose_on);
-	  file_to_lose_on = (char *)NULL;
-	}
-
-      /* We haven't returned any strings yet. */
-      match_index = 0;
-    }
-
-  match = match_list[match_index];
-
-  if (match)
-    match_index++;
-
-  return (match);
-}
-
-static char *
-find_absolute_program (name, flags)
-     const char *name;
-     int flags;
-{
-  int st;
-
-  st = file_status (name);
-
-  /* If the file doesn't exist, quit now. */
-  if ((st & FS_EXISTS) == 0)
-    return ((char *)NULL);
-
-  /* If we only care about whether the file exists or not, return
-     this filename.  Otherwise, maybe we care about whether this
-     file is executable.  If it is, and that is what we want, return it. */
-  if ((flags & FS_EXISTS) || ((flags & FS_EXEC_ONLY) && (st & FS_EXECABLE)))
-    return (savestring (name));
-
-  return (NULL);
-}
-
-static char *
-find_in_path_element (name, path, flags, name_len, dotinfop, rflagsp)
-     const char *name;
-     char *path;
-     int flags, name_len;
-     struct stat *dotinfop;
-     int *rflagsp;
-{
-  int status;
-  char *full_path, *xpath;
-
-  xpath = (posixly_correct == 0 && *path == '~') ? bash_tilde_expand (path, 0) : path;
-
-  /* Remember the location of "." in the path, in all its forms
-     (as long as they begin with a `.', e.g. `./.') */
-  /* We could also do this or something similar for all relative pathnames
-     found while searching PATH. */
-  if (dot_found_in_search == 0 && *xpath == '.')
-    dot_found_in_search = same_file (".", xpath, dotinfop, (struct stat *)NULL);
-
-  full_path = sh_makepath (xpath, name, 0);
-
-  status = file_status (full_path);
-
-  if (xpath != path)
-    free (xpath);
-
-  if (rflagsp)
-    *rflagsp = status;
-
-  if ((status & FS_EXISTS) == 0)
-    {
-      free (full_path);
-      return ((char *)NULL);
-    }
-
-  /* The file exists.  If the caller simply wants the first file, here it is. */
-  if (flags & FS_EXISTS)
-    return (full_path);
-
-  /* If we have a readable file, and the caller wants a readable file, this
-     is it. */
-  if ((flags & FS_READABLE) && (status & FS_READABLE))
-    return (full_path);
-
-  /* If the file is executable, then it satisfies the cases of
-      EXEC_ONLY and EXEC_PREFERRED.  Return this file unconditionally. */
-  if ((status & FS_EXECABLE) && (flags & (FS_EXEC_ONLY|FS_EXEC_PREFERRED)) &&
-      (((flags & FS_NODIRS) == 0) || ((status & FS_DIRECTORY) == 0)))
-    {
-      FREE (file_to_lose_on);
-      file_to_lose_on = (char *)NULL;
-      return (full_path);
-    }
-
-  /* The file is not executable, but it does exist.  If we prefer
-     an executable, then remember this one if it is the first one
-     we have found. */
-  if ((flags & FS_EXEC_PREFERRED) && file_to_lose_on == 0 && exec_name_should_ignore (full_path) == 0)
-    file_to_lose_on = savestring (full_path);
-
-  /* If we want only executable files, or we don't want directories and
-     this file is a directory, or we want a readable file and this file
-     isn't readable, fail. */
-  if ((flags & (FS_EXEC_ONLY|FS_EXEC_PREFERRED)) ||
-      ((flags & FS_NODIRS) && (status & FS_DIRECTORY)) ||
-      ((flags & FS_READABLE) && (status & FS_READABLE) == 0))
-    {
-      free (full_path);
-      return ((char *)NULL);
-    }
-  else
-    return (full_path);
-}
-
-/* This does the dirty work for find_user_command_internal () and
-   user_command_matches ().
-   NAME is the name of the file to search for.
-   PATH_LIST is a colon separated list of directories to search.
-   FLAGS contains bit fields which control the files which are eligible.
-   Some values are:
-      FS_EXEC_ONLY:		The file must be an executable to be found.
-      FS_EXEC_PREFERRED:	If we can't find an executable, then the
-				the first file matching NAME will do.
-      FS_EXISTS:		The first file found will do.
-      FS_NODIRS:		Don't find any directories.
-*/
-static char *
-find_user_command_in_path (name, path_list, flags, rflagsp)
-     const char *name;
-     char *path_list;
-     int flags, *rflagsp;
-{
-  char *full_path, *path;
-  int path_index, name_len, rflags;
-  struct stat dotinfo;
-
-  /* We haven't started looking, so we certainly haven't seen
-     a `.' as the directory path yet. */
-  dot_found_in_search = 0;
-
-  if (rflagsp)
-    *rflagsp = 0;
-
-  if (absolute_program (name))
-    {
-      full_path = find_absolute_program (name, flags);
-      return (full_path);
-    }
-
-  if (path_list == 0 || *path_list == '\0')
-    return (savestring (name));		/* XXX */
-
-  file_to_lose_on = (char *)NULL;
-  name_len = strlen (name);
-  if (stat (".", &dotinfo) < 0)
-    dotinfo.st_dev = dotinfo.st_ino = 0;
-  path_index = 0;
-
-  while (path_list[path_index])
-    {
-      /* Allow the user to interrupt out of a lengthy path search. */
-      QUIT;
-
-      path = get_next_path_element (path_list, &path_index);
-      if (path == 0)
-	break;
-
-      /* Side effects: sets dot_found_in_search, possibly sets
-	 file_to_lose_on. */
-      full_path = find_in_path_element (name, path, flags, name_len, &dotinfo, &rflags);
-      free (path);
-
-      /* We use the file status flag bits to check whether full_path is a
-	 directory, which we reject here. */
-      if (full_path && (rflags & FS_DIRECTORY))
-	{
-	  free (full_path);
-	  continue;
-	}
-
-      if (full_path)
-	{
-	  if (rflagsp)
-	    *rflagsp = rflags;
-	  FREE (file_to_lose_on);
-	  return (full_path);
-	}
-    }
-
-  /* We didn't find exactly what the user was looking for.  Return
-     the contents of FILE_TO_LOSE_ON which is NULL when the search
-     required an executable, or non-NULL if a file was found and the
-     search would accept a non-executable as a last resort.  If the
-     caller specified FS_NODIRS, and file_to_lose_on is a directory,
-     return NULL. */
-  if (file_to_lose_on && (flags & FS_NODIRS) && file_isdir (file_to_lose_on))
-    {
-      free (file_to_lose_on);
-      file_to_lose_on = (char *)NULL;
-    }
-
-  return (file_to_lose_on);
-}
-
-/* External interface to find a command given a $PATH.  Separate from
-   find_user_command_in_path to allow future customization. */
-char *
-find_in_path (name, path_list, flags)
-     const char *name;
-     char *path_list;
-     int flags;
-{
-  return (find_user_command_in_path (name, path_list, flags, (int *)0));
-}
diff --git a/third_party/bash/findcmd.h b/third_party/bash/findcmd.h
deleted file mode 100644
index bf457814e..000000000
--- a/third_party/bash/findcmd.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* findcmd.h - functions from findcmd.c. */
-
-/* Copyright (C) 1997-2015,2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_FINDCMD_H_)
-#define _FINDCMD_H_
-
-#include "stdc.h"
-
-/* Flags for search_for_command */
-#define CMDSRCH_HASH		0x01
-#define CMDSRCH_STDPATH		0x02
-#define CMDSRCH_TEMPENV		0x04
-
-extern int file_status PARAMS((const char *));
-extern int executable_file PARAMS((const char *));
-extern int is_directory PARAMS((const char *));
-extern int executable_or_directory PARAMS((const char *));
-extern char *find_user_command PARAMS((const char *));
-extern char *find_in_path PARAMS((const char *, char *, int));
-extern char *find_path_file PARAMS((const char *));
-extern char *search_for_command PARAMS((const char *, int));
-extern char *user_command_matches PARAMS((const char *, int, int));
-extern void setup_exec_ignore PARAMS((char *));
-
-extern int dot_found_in_search;
-
-/* variables managed via shopt */
-extern int check_hashed_filenames;
-
-#endif /* _FINDCMD_H_ */
diff --git a/third_party/bash/flags.c b/third_party/bash/flags.c
deleted file mode 100644
index 30f6c13d4..000000000
--- a/third_party/bash/flags.c
+++ /dev/null
@@ -1,385 +0,0 @@
-/* flags.c -- Everything about flags except the `set' command.  That
-   is in builtins.c */
-
-/* Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "flags.h"
-
-#if defined (BANG_HISTORY)
-#  include "bashhist.h"
-#endif
-
-#if defined (JOB_CONTROL)
-extern int set_job_control PARAMS((int));
-#endif
-
-/* **************************************************************** */
-/*								    */
-/*			The Standard sh Flags.			    */
-/*								    */
-/* **************************************************************** */
-
-/* Non-zero means automatically mark variables which are modified or created
-   as auto export variables. */
-int mark_modified_vars = 0;
-
-/* Non-zero causes asynchronous job notification.  Otherwise, job state
-   notification only takes place just before a primary prompt is printed. */
-int asynchronous_notification = 0;
-
-/* Non-zero means exit immediately if a command exits with a non-zero
-   exit status.  The first is what controls set -e; the second is what
-   bash uses internally. */
-int errexit_flag = 0;
-int exit_immediately_on_error = 0;
-
-/* Non-zero means disable filename globbing. */
-int disallow_filename_globbing = 0;
-
-/* Non-zero means that all keyword arguments are placed into the environment
-   for a command, not just those that appear on the line before the command
-   name. */
-int place_keywords_in_env = 0;
-
-/* Non-zero means read commands, but don't execute them.  This is useful
-   for debugging shell scripts that should do something hairy and possibly
-   destructive. */
-int read_but_dont_execute = 0;
-
-/* Non-zero means end of file is after one command. */
-int just_one_command = 0;
-
-/* Non-zero means don't overwrite existing files while doing redirections. */
-int noclobber = 0;
-
-/* Non-zero means trying to get the value of $i where $i is undefined
-   causes an error, instead of a null substitution. */
-int unbound_vars_is_error = 0;
-
-/* Non-zero means type out input lines after you read them. */
-int echo_input_at_read = 0;
-int verbose_flag = 0;
-
-/* Non-zero means type out the command definition after reading, but
-   before executing. */
-int echo_command_at_execute = 0;
-
-/* Non-zero means turn on the job control features. */
-int jobs_m_flag = 0;
-
-/* Non-zero means this shell is interactive, even if running under a
-   pipe. */
-int forced_interactive = 0;
-
-/* By default, follow the symbolic links as if they were real directories
-   while hacking the `cd' command.  This means that `cd ..' moves up in
-   the string of symbolic links that make up the current directory, instead
-   of the absolute directory.  The shell variable `nolinks' also controls
-   this flag. */
-int no_symbolic_links = 0;
-
-/* **************************************************************** */
-/*								    */
-/*		     Non-Standard Flags Follow Here.		    */
-/*								    */
-/* **************************************************************** */
-
-#if 0
-/* Non-zero means do lexical scoping in the body of a FOR command. */
-int lexical_scoping = 0;
-#endif
-
-/* Non-zero means look up and remember command names in a hash table, */
-int hashing_enabled = 1;
-
-#if defined (BANG_HISTORY)
-/* Non-zero means that we are doing history expansion.  The default.
-   This means !22 gets the 22nd line of history. */
-int history_expansion = HISTEXPAND_DEFAULT;
-int histexp_flag = 0;
-#endif /* BANG_HISTORY */
-
-/* Non-zero means that we allow comments to appear in interactive commands. */
-int interactive_comments = 1;
-
-#if defined (RESTRICTED_SHELL)
-/* Non-zero means that this shell is `restricted'.  A restricted shell
-   disallows: changing directories, command or path names containing `/',
-   unsetting or resetting the values of $PATH and $SHELL, and any type of
-   output redirection. */
-int restricted = 0;		/* currently restricted */
-int restricted_shell = 0;	/* shell was started in restricted mode. */
-#endif /* RESTRICTED_SHELL */
-
-/* Non-zero means that this shell is running in `privileged' mode.  This
-   is required if the shell is to run setuid.  If the `-p' option is
-   not supplied at startup, and the real and effective uids or gids
-   differ, disable_priv_mode is called to relinquish setuid status. */
-int privileged_mode = 0;
-
-#if defined (BRACE_EXPANSION)
-/* Zero means to disable brace expansion: foo{a,b} -> fooa foob */
-int brace_expansion = 1;
-#endif
-
-/* Non-zero means that shell functions inherit the DEBUG trap. */
-int function_trace_mode = 0;
-
-/* Non-zero means that shell functions inherit the ERR trap. */
-int error_trace_mode = 0;
-
-/* Non-zero means that the rightmost non-zero exit status in a pipeline
-   is the exit status of the entire pipeline.  If each processes exits
-   with a 0 status, the status of the pipeline is 0. */
-int pipefail_opt = 0;
-
-/* **************************************************************** */
-/*								    */
-/*			The Flags ALIST.			    */
-/*								    */
-/* **************************************************************** */
-
-const struct flags_alist shell_flags[] = {
-  /* Standard sh flags. */
-  { 'a', &mark_modified_vars },
-#if defined (JOB_CONTROL)
-  { 'b', &asynchronous_notification },
-#endif /* JOB_CONTROL */
-  { 'e', &errexit_flag },
-  { 'f', &disallow_filename_globbing },
-  { 'h', &hashing_enabled },
-  { 'i', &forced_interactive },
-  { 'k', &place_keywords_in_env },
-#if defined (JOB_CONTROL)
-  { 'm', &jobs_m_flag },
-#endif /* JOB_CONTROL */
-  { 'n', &read_but_dont_execute },
-  { 'p', &privileged_mode },
-#if defined (RESTRICTED_SHELL)
-  { 'r', &restricted },
-#endif /* RESTRICTED_SHELL */
-  { 't', &just_one_command },
-  { 'u', &unbound_vars_is_error },
-  { 'v', &verbose_flag },
-  { 'x', &echo_command_at_execute },
-
-  /* New flags that control non-standard things. */
-#if 0
-  { 'l', &lexical_scoping },
-#endif
-#if defined (BRACE_EXPANSION)
-  { 'B', &brace_expansion },
-#endif
-  { 'C', &noclobber },
-  { 'E', &error_trace_mode },
-#if defined (BANG_HISTORY)
-  { 'H', &histexp_flag },
-#endif /* BANG_HISTORY */
-  { 'P', &no_symbolic_links },
-  { 'T', &function_trace_mode },
-  {0, (int *)NULL}
-};
-
-#define NUM_SHELL_FLAGS (sizeof (shell_flags) / sizeof (struct flags_alist))
-
-char optflags[NUM_SHELL_FLAGS+4] = { '+' };
-
-int *
-find_flag (name)
-     int name;
-{
-  int i;
-  for (i = 0; shell_flags[i].name; i++)
-    {
-      if (shell_flags[i].name == name)
-	return (shell_flags[i].value);
-    }
-  return (FLAG_UNKNOWN);
-}
-
-/* Change the state of a flag, and return it's original value, or return
-   FLAG_ERROR if there is no flag FLAG.  ON_OR_OFF must be either
-   FLAG_ON or FLAG_OFF. */
-int
-change_flag (flag, on_or_off)
-  int flag;
-  int on_or_off;
-{
-  int *value, old_value;
-
-#if defined (RESTRICTED_SHELL)
-  /* Don't allow "set +r" in a shell which is `restricted'. */
-  if (restricted && flag == 'r' && on_or_off == FLAG_OFF)
-    return (FLAG_ERROR);
-#endif /* RESTRICTED_SHELL */
-
-  value = find_flag (flag);
-
-  if ((value == (int *)FLAG_UNKNOWN) || (on_or_off != FLAG_ON && on_or_off != FLAG_OFF))
-    return (FLAG_ERROR);
-
-  old_value = *value;
-  *value = (on_or_off == FLAG_ON) ? 1 : 0;
-
-  /* Special cases for a few flags. */
-  switch (flag)
-    {
-#if defined (BANG_HISTORY)
-    case 'H':
-      history_expansion = histexp_flag;
-      if (on_or_off == FLAG_ON)
-	bash_initialize_history ();
-      break;
-#endif
-
-#if defined (JOB_CONTROL)
-    case 'm':
-      set_job_control (on_or_off == FLAG_ON);
-      break;
-#endif /* JOB_CONTROL */
-
-    case 'e':
-      if (builtin_ignoring_errexit == 0)
-	exit_immediately_on_error = errexit_flag;
-      break;
-
-    case 'n':
-      if (interactive_shell)
-	read_but_dont_execute = 0;
-      break;
-
-    case 'p':
-      if (on_or_off == FLAG_OFF)
-	disable_priv_mode ();
-      break;
-
-#if defined (RESTRICTED_SHELL)
-    case 'r':
-      if (on_or_off == FLAG_ON && shell_initialized)
-	maybe_make_restricted (shell_name);
-      break;
-#endif
-
-    case 'v':
-      echo_input_at_read = verbose_flag;
-      break;
-    }
-
-  return (old_value);
-}
-
-/* Return a string which is the names of all the currently
-   set shell flags. */
-char *
-which_set_flags ()
-{
-  char *temp;
-  int i, string_index;
-
-  temp = (char *)xmalloc (1 + NUM_SHELL_FLAGS + read_from_stdin + want_pending_command);
-  for (i = string_index = 0; shell_flags[i].name; i++)
-    if (*(shell_flags[i].value))
-      temp[string_index++] = shell_flags[i].name;
-
-  if (want_pending_command)
-    temp[string_index++] = 'c';
-  if (read_from_stdin)
-    temp[string_index++] = 's';
-
-  temp[string_index] = '\0';
-  return (temp);
-}
-
-char *
-get_current_flags ()
-{
-  char *temp;
-  int i;
-
-  temp = (char *)xmalloc (1 + NUM_SHELL_FLAGS);
-  for (i = 0; shell_flags[i].name; i++)
-    temp[i] = *(shell_flags[i].value);
-  temp[i] = '\0';
-  return (temp);
-}
-
-void
-set_current_flags (bitmap)
-     const char *bitmap;
-{
-  int i;
-
-  if (bitmap == 0)
-    return;
-  for (i = 0; shell_flags[i].name; i++)
-    *(shell_flags[i].value) = bitmap[i];
-}
-
-void
-reset_shell_flags ()
-{
-  mark_modified_vars = disallow_filename_globbing = 0;
-  place_keywords_in_env = read_but_dont_execute = just_one_command = 0;
-  noclobber = unbound_vars_is_error = 0;
-  echo_command_at_execute = jobs_m_flag = forced_interactive = 0;
-  no_symbolic_links = 0;
-  privileged_mode = pipefail_opt = 0;
-
-  error_trace_mode = function_trace_mode = 0;
-
-  exit_immediately_on_error = errexit_flag = 0;
-  echo_input_at_read = verbose_flag = 0;
-
-  hashing_enabled = interactive_comments = 1;
-
-#if defined (JOB_CONTROL)
-  asynchronous_notification = 0;
-#endif
-
-#if defined (BANG_HISTORY)
-  histexp_flag = 0;
-#endif
-
-#if defined (BRACE_EXPANSION)
-  brace_expansion = 1;
-#endif
-
-#if defined (RESTRICTED_SHELL)
-  restricted = 0;
-#endif
-}
-
-void
-initialize_flags ()
-{
-  register int i;
-
-  for (i = 0; shell_flags[i].name; i++)
-    optflags[i+1] = shell_flags[i].name;
-  optflags[++i] = 'o';
-  optflags[++i] = ';';
-  optflags[i+1] = '\0';
-}
diff --git a/third_party/bash/flags.h b/third_party/bash/flags.h
deleted file mode 100644
index a3b5daa94..000000000
--- a/third_party/bash/flags.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/* flags.h -- a list of all the flags that the shell knows about.  You add
-   a flag to this program by adding the name here, and in flags.c. */
-
-/* Copyright (C) 1993-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_FLAGS_H_)
-#define _FLAGS_H_
-
-#include "stdc.h"
-
-/* Welcome to the world of Un*x, where everything is slightly backwards. */
-#define FLAG_ON '-'
-#define FLAG_OFF '+'
-
-#define FLAG_ERROR -1
-#define FLAG_UNKNOWN (int *)0
-
-/* The thing that we build the array of flags out of. */
-struct flags_alist {
-  char name;
-  int *value;
-};
-
-extern const struct flags_alist shell_flags[];
-extern char optflags[];
-
-extern int
-  mark_modified_vars, errexit_flag, exit_immediately_on_error,
-  disallow_filename_globbing,
-  place_keywords_in_env, read_but_dont_execute,
-  just_one_command, unbound_vars_is_error, echo_input_at_read, verbose_flag,
-  echo_command_at_execute, noclobber,
-  hashing_enabled, forced_interactive, privileged_mode, jobs_m_flag,
-  asynchronous_notification, interactive_comments, no_symbolic_links,
-  function_trace_mode, error_trace_mode, pipefail_opt;
-
-/* -c, -s invocation options -- not really flags, but they show up in $- */
-extern int want_pending_command, read_from_stdin;
-
-#if 0
-extern int lexical_scoping;
-#endif
-
-#if defined (BRACE_EXPANSION)
-extern int brace_expansion;
-#endif
-
-#if defined (BANG_HISTORY)
-extern int history_expansion;
-extern int histexp_flag;
-#endif /* BANG_HISTORY */
-
-#if defined (RESTRICTED_SHELL)
-extern int restricted;
-extern int restricted_shell;
-#endif /* RESTRICTED_SHELL */
-
-extern int *find_flag PARAMS((int));
-extern int change_flag PARAMS((int, int));
-extern char *which_set_flags PARAMS((void));
-extern void reset_shell_flags PARAMS((void));
-
-extern char *get_current_flags PARAMS((void));
-extern void set_current_flags PARAMS((const char *));
-
-extern void initialize_flags PARAMS((void));
-
-/* A macro for efficiency. */
-#define change_flag_char(flag, on_or_off)  change_flag (flag, on_or_off)
-
-#endif /* _FLAGS_H_ */
diff --git a/third_party/bash/fmtullong.c b/third_party/bash/fmtullong.c
deleted file mode 100644
index 7f385bd45..000000000
--- a/third_party/bash/fmtullong.c
+++ /dev/null
@@ -1,31 +0,0 @@
-/* fmtullong.c - convert `long long int' to string */
-
-/* Copyright (C) 2001-2002 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#ifdef HAVE_LONG_LONG_INT
-
-#define LONG		long long
-#define UNSIGNED_LONG	unsigned long long
-#define fmtulong	fmtullong
-
-#include "fmtulong.c"
-
-#endif
diff --git a/third_party/bash/fmtulong.c b/third_party/bash/fmtulong.c
deleted file mode 100644
index d3c7167f8..000000000
--- a/third_party/bash/fmtulong.c
+++ /dev/null
@@ -1,191 +0,0 @@
-/* fmtulong.c -- Convert unsigned long int to string. */
-
-/* Copyright (C) 1998-2011 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifdef HAVE_CONFIG_H
-#  include "config.h"
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#if defined (HAVE_LIMITS_H)
-#  include <limits.h>
-#endif
-
-#include "bashansi.h"
-#ifdef HAVE_STDDEF_H
-#  include <stddef.h>
-#endif
-
-#ifdef HAVE_STDINT_H
-#  include <stdint.h>
-#endif
-#ifdef HAVE_INTTYPES_H
-#  include <inttypes.h>
-#endif
-#include "chartypes.h"
-#include <errno.h>
-
-#include "bashintl.h"
-
-#include "stdc.h"
-
-#include "typemax.h"
-
-#ifndef errno
-extern int errno;
-#endif
-
-#define x_digs  "0123456789abcdef"
-#define X_digs  "0123456789ABCDEF"
-
-/* XXX -- assumes uppercase letters, lowercase letters, and digits are
-   contiguous */
-#define FMTCHAR(x) \
-  ((x) < 10) ? (x) + '0' \
-	     : (((x) < 36) ? (x) - 10 + 'a' \
-			   : (((x) < 62) ? (x) - 36 + 'A' \
-					 : (((x) == 62) ? '@' : '_')))
-
-#ifndef FL_PREFIX
-#  define FL_PREFIX	0x01	/* add 0x, 0X, or 0 prefix as appropriate */
-#  define FL_ADDBASE	0x02	/* add base# prefix to converted value */
-#  define FL_HEXUPPER	0x04	/* use uppercase when converting to hex */
-#  define FL_UNSIGNED	0x08	/* don't add any sign */
-#endif
-
-#ifndef LONG
-#  define LONG	long
-#  define UNSIGNED_LONG unsigned long
-#endif
-
-/* `unsigned long' (or unsigned long long) to string conversion for a given
-   base.  The caller passes the output buffer and the size.  This should
-   check for buffer underflow, but currently does not. */
-char *
-fmtulong (ui, base, buf, len, flags)
-     UNSIGNED_LONG ui;
-     int base;
-     char *buf;
-     size_t len;
-     int flags;
-{
-  char *p;
-  int sign;
-  LONG si;
-
-  if (base == 0)
-    base = 10;
-
-  if (base < 2 || base > 64)
-    {
-#if 1
-      /* XXX - truncation possible with long translation */
-      strncpy (buf, _("invalid base"), len - 1);
-      buf[len-1] = '\0';
-      errno = EINVAL;
-      return (p = buf);
-#else
-      base = 10;
-#endif
-    }
-
-  sign = 0;
-  if ((flags & FL_UNSIGNED) == 0 && (LONG)ui < 0)
-    {
-      ui = -ui;
-      sign = '-';
-    }
-
-  p = buf + len - 2;
-  p[1] = '\0';
-
-  /* handle common cases explicitly */
-  switch (base)
-    {
-    case 10:
-      if (ui < 10)
-	{
-	  *p-- = TOCHAR (ui);
-	  break;
-	}
-      /* Favor signed arithmetic over unsigned arithmetic; it is faster on
-	 many machines. */
-      if ((LONG)ui < 0)
-	{
-	  *p-- = TOCHAR (ui % 10);
-	  si = ui / 10;
-	}
-      else
-        si = ui;
-      do
-	*p-- = TOCHAR (si % 10);
-      while (si /= 10);
-      break;
-
-    case 8:
-      do
-	*p-- = TOCHAR (ui & 7);
-      while (ui >>= 3);
-      break;
-
-    case 16:
-      do
-	*p-- = (flags & FL_HEXUPPER) ? X_digs[ui & 15] : x_digs[ui & 15];
-      while (ui >>= 4);
-      break;
-
-    case 2:
-      do
-	*p-- = TOCHAR (ui & 1);
-      while (ui >>= 1);
-      break;
-
-    default:
-      do
-	*p-- = FMTCHAR (ui % base);
-      while (ui /= base);
-      break;
-    }
-
-  if ((flags & FL_PREFIX) && (base == 8 || base == 16))
-    {
-      if (base == 16)
-	{
-	  *p-- = (flags & FL_HEXUPPER) ? 'X' : 'x';
-	  *p-- = '0';
-	}
-      else if (p[1] != '0')
-	*p-- = '0';
-    }
-  else if ((flags & FL_ADDBASE) && base != 10)
-    {
-      *p-- = '#';
-      *p-- = TOCHAR (base % 10);
-      if (base > 10)
-        *p-- = TOCHAR (base / 10);
-    }
-
-  if (sign)
-    *p-- = '-';
-
-  return (p + 1);
-}
diff --git a/third_party/bash/fmtumax.c b/third_party/bash/fmtumax.c
deleted file mode 100644
index 78a9aef4d..000000000
--- a/third_party/bash/fmtumax.c
+++ /dev/null
@@ -1,27 +0,0 @@
-/* fmtumax.c -- Convert uintmax_t to string.  */
-
-/* Copyright (C) 2002 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#define LONG	intmax_t
-#define UNSIGNED_LONG	uintmax_t
-#define fmtulong	fmtumax
-
-#include "fmtulong.c"
diff --git a/third_party/bash/fnxform.c b/third_party/bash/fnxform.c
deleted file mode 100644
index 0a9f0247d..000000000
--- a/third_party/bash/fnxform.c
+++ /dev/null
@@ -1,199 +0,0 @@
-/* fnxform - use iconv(3) to transform strings to and from "filename" format */
-
-/* Copyright (C) 2009-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-#include "bashansi.h"
-#include <stdio.h>
-#include "bashtypes.h"
-
-#include "stdc.h"
-#include "bashintl.h"
-#include "xmalloc.h"
-
-#if defined (HAVE_ICONV)
-#  include <iconv.h>
-#endif
-
-#if defined (HAVE_LOCALE_CHARSET)
-extern const char *locale_charset PARAMS((void));
-#else
-extern char *get_locale_var PARAMS((char *));
-#endif
-
-#if defined (HAVE_ICONV)
-static iconv_t conv_fromfs = (iconv_t)-1;
-static iconv_t conv_tofs = (iconv_t)-1;
-
-#define OUTLEN_MAX 4096
-
-static char *outbuf = 0;
-static size_t outlen = 0;
-
-static char *curencoding PARAMS((void));
-static void init_tofs PARAMS((void));
-static void init_fromfs PARAMS((void));
-
-static char *
-curencoding ()
-{
-  char *loc;
-#if defined (HAVE_LOCALE_CHARSET)
-  loc = (char *)locale_charset ();
-  return loc;
-#else
-  char *dot, *mod;
-
-  loc = get_locale_var ("LC_CTYPE");
-  if (loc == 0 || *loc == 0)
-    return "";
-  dot = strchr (loc, '.');
-  if (dot == 0)
-    return loc;
-  mod = strchr (dot, '@');
-  if (mod)
-    *mod = '\0';
-  return ++dot;
-#endif
-}  
-
-static void
-init_tofs ()
-{
-  char *cur;
-
-  cur = curencoding ();
-  conv_tofs = iconv_open ("UTF-8-MAC", cur);
-}
-
-static void
-init_fromfs ()
-{
-  char *cur;
-
-  cur = curencoding ();
-  conv_fromfs = iconv_open (cur, "UTF-8-MAC");
-}
-
-char *
-fnx_tofs (string, len)
-     char *string;
-     size_t len;
-{
-#ifdef MACOSX
-  ICONV_CONST char *inbuf;
-  char *tempbuf;
-  size_t templen;
-  
-  if (conv_tofs == (iconv_t)-1)
-    init_tofs ();
-  if (conv_tofs == (iconv_t)-1)
-    return string;
-
-  /* Free and reallocate outbuf if it's *too* big */
-  if (outlen >= OUTLEN_MAX && len < OUTLEN_MAX - 8)
-    {
-      free (outbuf);
-      outbuf = 0;
-      outlen = 0;
-    }
-
-  inbuf = string;
-  if (outbuf == 0 || outlen < len + 8)
-    {
-      outlen = len + 8;
-      outbuf = outbuf ? xrealloc (outbuf, outlen + 1) : xmalloc (outlen + 1);
-    }
-  tempbuf = outbuf;
-  templen = outlen;
-
-  iconv (conv_tofs, NULL, NULL, NULL, NULL);
-
-  if (iconv (conv_tofs, &inbuf, &len, &tempbuf, &templen) == (size_t)-1)
-    return string;
-
-  *tempbuf = '\0';
-  return outbuf;
-#else
-  return string;
-#endif
-}
-
-char *
-fnx_fromfs (string, len)
-     char *string;
-     size_t len;
-{
-#ifdef MACOSX
-  ICONV_CONST char *inbuf;
-  char *tempbuf;
-  size_t templen;
-
-  if (conv_fromfs == (iconv_t)-1)
-    init_fromfs ();
-  if (conv_fromfs == (iconv_t)-1)
-    return string;
-
-  /* Free and reallocate outbuf if it's *too* big */
-  if (outlen >= OUTLEN_MAX && len < OUTLEN_MAX - 8)
-    {
-      free (outbuf);
-      outbuf = 0;
-      outlen = 0;
-    }
-
-  inbuf = string;
-  if (outbuf == 0 || outlen < (len + 8))
-    {
-      outlen = len + 8;
-      outbuf = outbuf ? xrealloc (outbuf, outlen + 1) : xmalloc (outlen + 1);
-    }
-  tempbuf = outbuf;
-  templen = outlen;
-
-  iconv (conv_fromfs, NULL, NULL, NULL, NULL);
-
-  if (iconv (conv_fromfs, &inbuf, &len, &tempbuf, &templen) == (size_t)-1)
-    return string;
-
-  *tempbuf = '\0';
-  return outbuf;
-#else
-  return string;
-#endif
-}
-
-#else
-char *
-fnx_tofs (string)
-     char *string;
-{
-  return string;
-}
-
-char *
-fnx_fromfs (string)
-     char *string;
-{
-  return string;
-}
-#endif
diff --git a/third_party/bash/fpurge.c b/third_party/bash/fpurge.c
deleted file mode 100644
index 37a5c0d34..000000000
--- a/third_party/bash/fpurge.c
+++ /dev/null
@@ -1,232 +0,0 @@
-/* fpurge - Flushing buffers of a FILE stream. */
-
-/* Copyright (C) 2007-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "stdc.h"
-
-#include <stdio.h>
-
-/* Specification.  Same as in ../../externs.h.  */
-#define NEED_FPURGE_DECL
-#if HAVE_FPURGE
-#  define fpurge _bash_fpurge
-#endif
-extern int fpurge PARAMS((FILE *stream));
-
-#if HAVE___FPURGE                   /* glibc >= 2.2, Haiku, Solaris >= 7 */
-# include <stdio_ext.h>
-#endif
-#include <stdlib.h>
-
-/* Inline contents of gnulib:stdio-impl.h */
-
-/* Many stdio implementations have the same logic and therefore can share
-   the same implementation of stdio extension API, except that some fields
-   have different naming conventions, or their access requires some casts.  */
-
-/* BSD stdio derived implementations.  */
-
-#if defined __NetBSD__                         /* NetBSD */
-/* Get __NetBSD_Version__.  */
-# include <sys/param.h>
-#endif
-
-#if defined __sferror || defined __DragonFly__ /* FreeBSD, NetBSD, OpenBSD, DragonFly, MacOS X, Cygwin */
-
-# if defined __DragonFly__          /* DragonFly */
-  /* See <http://www.dragonflybsd.org/cvsweb/src/lib/libc/stdio/priv_stdio.h?rev=HEAD&content-type=text/x-cvsweb-markup>.  */
-#  define fp_ ((struct { struct __FILE_public pub; \
-                         struct { unsigned char *_base; int _size; } _bf; \
-                         void *cookie; \
-                         void *_close; \
-                         void *_read; \
-                         void *_seek; \
-                         void *_write; \
-                         struct { unsigned char *_base; int _size; } _ub; \
-                         int _ur; \
-                         unsigned char _ubuf[3]; \
-                         unsigned char _nbuf[1]; \
-                         struct { unsigned char *_base; int _size; } _lb; \
-                         int _blksize; \
-                         fpos_t _offset; \
-                         /* More fields, not relevant here.  */ \
-                       } *) fp)
-  /* See <http://www.dragonflybsd.org/cvsweb/src/include/stdio.h?rev=HEAD&content-type=text/x-cvsweb-markup>.  */
-#  define _p pub._p
-#  define _flags pub._flags
-#  define _r pub._r
-#  define _w pub._w
-# else
-#  define fp_ fp
-# endif
-
-# if (defined __NetBSD__ && __NetBSD_Version__ >= 105270000) || defined __OpenBSD__ /* NetBSD >= 1.5ZA, OpenBSD */
-  /* See <http://cvsweb.netbsd.org/bsdweb.cgi/src/lib/libc/stdio/fileext.h?rev=HEAD&content-type=text/x-cvsweb-markup>
-     and <http://www.openbsd.org/cgi-bin/cvsweb/src/lib/libc/stdio/fileext.h?rev=HEAD&content-type=text/x-cvsweb-markup> */
-  struct __sfileext
-    {
-      struct  __sbuf _ub; /* ungetc buffer */
-      /* More fields, not relevant here.  */
-    };
-#  define fp_ub ((struct __sfileext *) fp->_ext._base)->_ub
-# else                                         /* FreeBSD, NetBSD <= 1.5Z, DragonFly, MacOS X, Cygwin */
-#  define fp_ub fp_->_ub
-# endif
-
-# define HASUB(fp) (fp_ub._base != NULL)
-
-#endif
-
-/* SystemV derived implementations.  */
-
-#if defined _IOERR
-
-# if defined __sun && defined _LP64 /* Solaris/{SPARC,AMD64} 64-bit */
-#  define fp_ ((struct { unsigned char *_ptr; \
-                         unsigned char *_base; \
-                         unsigned char *_end; \
-                         long _cnt; \
-                         int _file; \
-                         unsigned int _flag; \
-                       } *) fp)
-# else
-#  define fp_ fp
-# endif
-
-# if defined _SCO_DS                /* OpenServer */
-#  define _cnt __cnt
-#  define _ptr __ptr
-#  define _base __base
-#  define _flag __flag
-# endif
-
-#endif
-
-int
-fpurge (FILE *fp)
-{
-#if HAVE___FPURGE                   /* glibc >= 2.2, Haiku, Solaris >= 7 */
-
-  __fpurge (fp);
-  /* The __fpurge function does not have a return value.  */
-  return 0;
-
-#elif HAVE_FPURGE                   /* FreeBSD, NetBSD, OpenBSD, DragonFly, MacOS X, Cygwin 1.7 */
-
-  /* Call the system's fpurge function.  */
-# undef fpurge
-# if !HAVE_DECL_FPURGE
-  extern int fpurge (FILE *);
-# endif
-  int result = fpurge (fp);
-# if defined __sferror || defined __DragonFly__ /* FreeBSD, NetBSD, OpenBSD, DragonFly, MacOS X, Cygwin */
-  if (result == 0)
-    /* Correct the invariants that fpurge broke.
-       <stdio.h> on BSD systems says:
-         "The following always hold: if _flags & __SRD, _w is 0."
-       If this invariant is not fulfilled and the stream is read-write but
-       currently reading, subsequent putc or fputc calls will write directly
-       into the buffer, although they shouldn't be allowed to.  */
-    if ((fp_->_flags & __SRD) != 0)
-      fp_->_w = 0;
-# endif
-  return result;
-
-#else
-
-  /* Most systems provide FILE as a struct and the necessary bitmask in
-     <stdio.h>, because they need it for implementing getc() and putc() as
-     fast macros.  */
-# if defined _IO_ftrylockfile || __GNU_LIBRARY__ == 1 /* GNU libc, BeOS, Haiku, Linux libc5 */
-  fp->_IO_read_end = fp->_IO_read_ptr;
-  fp->_IO_write_ptr = fp->_IO_write_base;
-  /* Avoid memory leak when there is an active ungetc buffer.  */
-  if (fp->_IO_save_base != NULL)
-    {
-      free (fp->_IO_save_base);
-      fp->_IO_save_base = NULL;
-    }
-  return 0;
-# elif defined __sferror || defined __DragonFly__ /* FreeBSD, NetBSD, OpenBSD, DragonFly, MacOS X, Cygwin */
-  fp_->_p = fp_->_bf._base;
-  fp_->_r = 0;
-  fp_->_w = ((fp_->_flags & (__SLBF | __SNBF | __SRD)) == 0 /* fully buffered and not currently reading? */
-	     ? fp_->_bf._size
-	     : 0);
-  /* Avoid memory leak when there is an active ungetc buffer.  */
-  if (fp_ub._base != NULL)
-    {
-      if (fp_ub._base != fp_->_ubuf)
-	free (fp_ub._base);
-      fp_ub._base = NULL;
-    }
-  return 0;
-# elif defined __EMX__              /* emx+gcc */
-  fp->_ptr = fp->_buffer;
-  fp->_rcount = 0;
-  fp->_wcount = 0;
-  fp->_ungetc_count = 0;
-  return 0;
-# elif defined _IOERR || defined __TANDEM    /* AIX, HP-UX, IRIX, OSF/1, Solaris, OpenServer, mingw */
-  fp->_ptr = fp->_base;
-  if (fp->_ptr != NULL)
-    fp->_cnt = 0;
-  return 0;
-# elif defined __UCLIBC__           /* uClibc */
-#  ifdef __STDIO_BUFFERS
-  if (fp->__modeflags & __FLAG_WRITING)
-    fp->__bufpos = fp->__bufstart;
-  else if (fp->__modeflags & (__FLAG_READONLY | __FLAG_READING))
-    fp->__bufpos = fp->__bufread;
-#  endif
-  return 0;
-# elif defined __QNX__              /* QNX */
-  fp->_Rback = fp->_Back + sizeof (fp->_Back);
-  fp->_Rsave = NULL;
-  if (fp->_Mode & 0x2000 /* _MWRITE */)
-    /* fp->_Buf <= fp->_Next <= fp->_Wend */
-    fp->_Next = fp->_Buf;
-  else
-    /* fp->_Buf <= fp->_Next <= fp->_Rend */
-    fp->_Rend = fp->_Next;
-  return 0;
-# elif defined __MINT__             /* Atari FreeMiNT */
-  if (fp->__pushed_back)
-    {
-      fp->__bufp = fp->__pushback_bufp;
-      fp->__pushed_back = 0;
-    }
-  /* Preserve the current file position.  */
-  if (fp->__target != -1)
-    fp->__target += fp->__bufp - fp->__buffer;
-  fp->__bufp = fp->__buffer;
-  /* Nothing in the buffer, next getc is nontrivial.  */
-  fp->__get_limit = fp->__bufp;
-  /* Nothing in the buffer, next putc is nontrivial.  */
-  fp->__put_limit = fp->__buffer;
-  return 0;
-# else
-# warning "Please port gnulib fpurge.c to your platform! Look at the definitions of fflush, setvbuf and ungetc on your system, then report this to bug-gnulib."
-  return 0;
-# endif
-
-#endif
-}
diff --git a/third_party/bash/general.c b/third_party/bash/general.c
deleted file mode 100644
index b9e43aa4c..000000000
--- a/third_party/bash/general.c
+++ /dev/null
@@ -1,1450 +0,0 @@
-/* general.c -- Stuff that is used by all files. */
-
-/* Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "filecntl.h"
-#include "bashansi.h"
-#include <stdio.h>
-#include "chartypes.h"
-#include <errno.h>
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "parser.h"
-#include "flags.h"
-#include "findcmd.h"
-#include "test.h"
-#include "trap.h"
-#include "pathexp.h"
-
-#include "common.h"
-
-#if defined (HAVE_MBSTR_H) && defined (HAVE_MBSCHR)
-#  include <mbstr.h>		/* mbschr */
-#endif
-
-#include "tilde.h"
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#ifdef __CYGWIN__
-#  include <sys/cygwin.h>
-#endif
-
-static char *bash_special_tilde_expansions PARAMS((char *));
-static int unquoted_tilde_word PARAMS((const char *));
-static void initialize_group_array PARAMS((void));
-
-/* A standard error message to use when getcwd() returns NULL. */
-const char * const bash_getcwd_errstr = N_("getcwd: cannot access parent directories");
-
-/* Do whatever is necessary to initialize `Posix mode'.  This currently
-   modifies the following variables which are controlled via shopt:
-      interactive_comments
-      source_uses_path
-      expand_aliases
-      inherit_errexit
-      print_shift_error
-      posixglob
-
-   and the following variables which cannot be user-modified:
-
-      source_searches_cwd
-
-  If we add to the first list, we need to change the table and functions
-  below */
-
-static struct {
-  int *posix_mode_var;
-} posix_vars[] = 
-{
-  &interactive_comments,
-  &source_uses_path,
-  &expand_aliases,
-  &inherit_errexit,
-  &print_shift_error,
-  0
-};
-
-static char *saved_posix_vars = 0;
-
-void
-posix_initialize (on)
-     int on;
-{
-  /* Things that should be turned on when posix mode is enabled. */
-  if (on != 0)
-    {
-      interactive_comments = source_uses_path = expand_aliases = 1;
-      inherit_errexit = 1;
-      source_searches_cwd = 0;
-      print_shift_error = 1;
-    }
-
-  /* Things that should be turned on when posix mode is disabled. */
-  else if (saved_posix_vars)		/* on == 0, restore saved settings */
-    {
-      set_posix_options (saved_posix_vars);
-      free (saved_posix_vars);
-      saved_posix_vars = 0;
-    }
-  else	/* on == 0, restore a default set of settings */
-    {
-      source_searches_cwd = 1;
-      expand_aliases = interactive_shell;
-      print_shift_error = 0;
-    }
-}
-
-int
-num_posix_options ()
-{
-  return ((sizeof (posix_vars) / sizeof (posix_vars[0])) - 1);
-}
-
-char *
-get_posix_options (bitmap)
-     char *bitmap;
-{
-  register int i;
-
-  if (bitmap == 0)
-    bitmap = (char *)xmalloc (num_posix_options ());	/* no trailing NULL */
-  for (i = 0; posix_vars[i].posix_mode_var; i++)
-    bitmap[i] = *(posix_vars[i].posix_mode_var);
-  return bitmap;
-}
-
-#undef save_posix_options
-void
-save_posix_options ()
-{
-  saved_posix_vars = get_posix_options (saved_posix_vars);
-}
-
-void
-set_posix_options (bitmap)
-     const char *bitmap;
-{
-  register int i;
-
-  for (i = 0; posix_vars[i].posix_mode_var; i++)
-    *(posix_vars[i].posix_mode_var) = bitmap[i];
-}
-
-/* **************************************************************** */
-/*								    */
-/*  Functions to convert to and from and display non-standard types */
-/*								    */
-/* **************************************************************** */
-
-#if defined (RLIMTYPE)
-RLIMTYPE
-string_to_rlimtype (s)
-     char *s;
-{
-  RLIMTYPE ret;
-  int neg;
-
-  ret = 0;
-  neg = 0;
-  while (s && *s && whitespace (*s))
-    s++;
-  if (s && (*s == '-' || *s == '+'))
-    {
-      neg = *s == '-';
-      s++;
-    }
-  for ( ; s && *s && DIGIT (*s); s++)
-    ret = (ret * 10) + TODIGIT (*s);
-  return (neg ? -ret : ret);
-}
-
-void
-print_rlimtype (n, addnl)
-     RLIMTYPE n;
-     int addnl;
-{
-  char s[INT_STRLEN_BOUND (RLIMTYPE) + 1], *p;
-
-  p = s + sizeof(s);
-  *--p = '\0';
-
-  if (n < 0)
-    {
-      do
-	*--p = '0' - n % 10;
-      while ((n /= 10) != 0);
-
-      *--p = '-';
-    }
-  else
-    {
-      do
-	*--p = '0' + n % 10;
-      while ((n /= 10) != 0);
-    }
-
-  printf ("%s%s", p, addnl ? "\n" : "");
-}
-#endif /* RLIMTYPE */
-
-/* **************************************************************** */
-/*								    */
-/*		       Input Validation Functions		    */
-/*								    */
-/* **************************************************************** */
-
-/* Return non-zero if all of the characters in STRING are digits. */
-int
-all_digits (string)
-     const char *string;
-{
-  register const char *s;
-
-  for (s = string; *s; s++)
-    if (DIGIT (*s) == 0)
-      return (0);
-
-  return (1);
-}
-
-/* Return non-zero if the characters pointed to by STRING constitute a
-   valid number.  Stuff the converted number into RESULT if RESULT is
-   not null. */
-int
-legal_number (string, result)
-     const char *string;
-     intmax_t *result;
-{
-  intmax_t value;
-  char *ep;
-
-  if (result)
-    *result = 0;
-
-  if (string == 0)
-    return 0;
-
-  errno = 0;
-  value = strtoimax (string, &ep, 10);
-  if (errno || ep == string)
-    return 0;	/* errno is set on overflow or underflow */
-
-  /* Skip any trailing whitespace, since strtoimax does not. */
-  while (whitespace (*ep))
-    ep++;
-
-  /* If *string is not '\0' but *ep is '\0' on return, the entire string
-     is valid. */
-  if (*string && *ep == '\0')
-    {
-      if (result)
-	*result = value;
-      /* The SunOS4 implementation of strtol() will happily ignore
-	 overflow conditions, so this cannot do overflow correctly
-	 on those systems. */
-      return 1;
-    }
-    
-  return (0);
-}
-
-/* Return 1 if this token is a legal shell `identifier'; that is, it consists
-   solely of letters, digits, and underscores, and does not begin with a
-   digit. */
-int
-legal_identifier (name)
-     const char *name;
-{
-  register const char *s;
-  unsigned char c;
-
-  if (!name || !(c = *name) || (legal_variable_starter (c) == 0))
-    return (0);
-
-  for (s = name + 1; (c = *s) != 0; s++)
-    {
-      if (legal_variable_char (c) == 0)
-	return (0);
-    }
-  return (1);
-}
-
-/* Return 1 if NAME is a valid value that can be assigned to a nameref
-   variable.  FLAGS can be 2, in which case the name is going to be used
-   to create a variable.  Other values are currently unused, but could
-   be used to allow values to be stored and indirectly referenced, but
-   not used in assignments. */
-int
-valid_nameref_value (name, flags)
-     const char *name;
-     int flags;
-{
-  if (name == 0 || *name == 0)
-    return 0;
-
-  /* valid identifier */
-#if defined (ARRAY_VARS)  
-  if (legal_identifier (name) || (flags != 2 && valid_array_reference (name, 0)))
-#else
-  if (legal_identifier (name))
-#endif
-    return 1;
-
-  return 0;
-}
-
-int
-check_selfref (name, value, flags)
-     const char *name;
-     char *value;
-     int flags;
-{
-  char *t;
-
-  if (STREQ (name, value))
-    return 1;
-
-#if defined (ARRAY_VARS)
-  if (valid_array_reference (value, 0))
-    {
-      t = array_variable_name (value, 0, (char **)NULL, (int *)NULL);
-      if (t && STREQ (name, t))
-	{
-	  free (t);
-	  return 1;
-	}
-      free (t);
-    }
-#endif
-
-  return 0;	/* not a self reference */
-}
-
-/* Make sure that WORD is a valid shell identifier, i.e.
-   does not contain a dollar sign, nor is quoted in any way.
-   If CHECK_WORD is non-zero,
-   the word is checked to ensure that it consists of only letters,
-   digits, and underscores, and does not consist of all digits. */
-int
-check_identifier (word, check_word)
-     WORD_DESC *word;
-     int check_word;
-{
-  if (word->flags & (W_HASDOLLAR|W_QUOTED))	/* XXX - HASDOLLAR? */
-    {
-      internal_error (_("`%s': not a valid identifier"), word->word);
-      return (0);
-    }
-  else if (check_word && (all_digits (word->word) || legal_identifier (word->word) == 0))
-    {
-      internal_error (_("`%s': not a valid identifier"), word->word);
-      return (0);
-    }
-  else
-    return (1);
-}
-
-/* Return 1 if STRING is a function name that the shell will import from
-   the environment.  Currently we reject attempts to import shell functions
-   containing slashes, beginning with newlines or containing blanks.  In
-   Posix mode, we require that STRING be a valid shell identifier.  Not
-   used yet. */
-int
-importable_function_name (string, len)
-     const char *string;
-     size_t len;
-{
-  if (absolute_program (string))	/* don't allow slash */
-    return 0;
-  if (*string == '\n')			/* can't start with a newline */
-    return 0;
-  if (shellblank (*string) || shellblank(string[len-1]))
-    return 0;
-  return (posixly_correct ? legal_identifier (string) : 1);
-}
-
-int
-exportable_function_name (string)
-     const char *string;
-{
-  if (absolute_program (string))
-    return 0;
-  if (mbschr (string, '=') != 0)
-    return 0;
-  return 1;
-}
-
-/* Return 1 if STRING comprises a valid alias name.  The shell accepts
-   essentially all characters except those which must be quoted to the
-   parser (which disqualifies them from alias expansion anyway) and `/'. */
-int
-legal_alias_name (string, flags)
-     const char *string;
-     int flags;
-{
-  register const char *s;
-
-  for (s = string; *s; s++)
-    if (shellbreak (*s) || shellxquote (*s) || shellexp (*s) || (*s == '/'))
-      return 0;
-  return 1;
-}
-
-/* Returns non-zero if STRING is an assignment statement.  The returned value
-   is the index of the `=' sign.  If FLAGS&1 we are expecting a compound assignment
-   and require an array subscript before the `=' to denote an assignment
-   statement. */
-int
-assignment (string, flags)
-     const char *string;
-     int flags;
-{
-  register unsigned char c;
-  register int newi, indx;
-
-  c = string[indx = 0];
-
-#if defined (ARRAY_VARS)
-  /* If parser_state includes PST_COMPASSIGN, FLAGS will include 1, so we are
-     parsing the contents of a compound assignment. If parser_state includes
-     PST_REPARSE, we are in the middle of an assignment statement and breaking
-     the words between the parens into words and assignment statements, but
-     we don't need to check for that right now. Within a compound assignment,
-     the subscript is required to make the word an assignment statement. If
-     we don't have a subscript, even if the word is a valid assignment
-     statement otherwise, we don't want to treat it as one. */
-  if ((flags & 1) && c != '[')		/* ] */
-    return (0);
-  else if ((flags & 1) == 0 && legal_variable_starter (c) == 0)
-#else
-  if (legal_variable_starter (c) == 0)
-#endif
-    return (0);
-
-  while (c = string[indx])
-    {
-      /* The following is safe.  Note that '=' at the start of a word
-	 is not an assignment statement. */
-      if (c == '=')
-	return (indx);
-
-#if defined (ARRAY_VARS)
-      if (c == '[')
-	{
-	  newi = skipsubscript (string, indx, (flags & 2) ? 1 : 0);
-	  /* XXX - why not check for blank subscripts here, if we do in
-	     valid_array_reference? */
-	  if (string[newi++] != ']')
-	    return (0);
-	  if (string[newi] == '+' && string[newi+1] == '=')
-	    return (newi + 1);
-	  return ((string[newi] == '=') ? newi : 0);
-	}
-#endif /* ARRAY_VARS */
-
-      /* Check for `+=' */
-      if (c == '+' && string[indx+1] == '=')
-	return (indx + 1);
-
-      /* Variable names in assignment statements may contain only letters,
-	 digits, and `_'. */
-      if (legal_variable_char (c) == 0)
-	return (0);
-
-      indx++;
-    }
-  return (0);
-}
-
-int
-line_isblank (line)
-     const char *line;
-{
-  register int i;
-
-  if (line == 0)
-    return 0;		/* XXX */
-  for (i = 0; line[i]; i++)
-    if (isblank ((unsigned char)line[i]) == 0)
-      break;
-  return (line[i] == '\0');  
-}
-
-/* **************************************************************** */
-/*								    */
-/*	     Functions to manage files and file descriptors	    */
-/*								    */
-/* **************************************************************** */
-
-/* A function to unset no-delay mode on a file descriptor.  Used in shell.c
-   to unset it on the fd passed as stdin.  Should be called on stdin if
-   readline gets an EAGAIN or EWOULDBLOCK when trying to read input. */
-
-#if !defined (O_NDELAY)
-#  if defined (FNDELAY)
-#    define O_NDELAY FNDELAY
-#  endif
-#endif /* O_NDELAY */
-
-/* Make sure no-delay mode is not set on file descriptor FD. */
-int
-sh_unset_nodelay_mode (fd)
-     int fd;
-{
-  int flags, bflags;
-
-  if ((flags = fcntl (fd, F_GETFL, 0)) < 0)
-    return -1;
-
-  bflags = 0;
-
-  /* This is defined to O_NDELAY in filecntl.h if O_NONBLOCK is not present
-     and O_NDELAY is defined. */
-#ifdef O_NONBLOCK
-  bflags |= O_NONBLOCK;
-#endif
-
-#ifdef O_NDELAY
-  bflags |= O_NDELAY;
-#endif
-
-  if (flags & bflags)
-    {
-      flags &= ~bflags;
-      return (fcntl (fd, F_SETFL, flags));
-    }
-
-  return 0;
-}
-
-/* Just a wrapper for the define in include/filecntl.h */
-int
-sh_setclexec (fd)
-     int fd;
-{
-  return (SET_CLOSE_ON_EXEC (fd));
-}
-
-/* Return 1 if file descriptor FD is valid; 0 otherwise. */
-int
-sh_validfd (fd)
-     int fd;
-{
-  return (fcntl (fd, F_GETFD, 0) >= 0);
-}
-
-int
-fd_ispipe (fd)
-     int fd;
-{
-  errno = 0;
-  return ((lseek (fd, 0L, SEEK_CUR) < 0) && (errno == ESPIPE));
-}
-
-/* There is a bug in the NeXT 2.1 rlogind that causes opens
-   of /dev/tty to fail. */
-
-#if defined (__BEOS__)
-/* On BeOS, opening in non-blocking mode exposes a bug in BeOS, so turn it
-   into a no-op.  This should probably go away in the future. */
-#  undef O_NONBLOCK
-#  define O_NONBLOCK 0
-#endif /* __BEOS__ */
-
-void
-check_dev_tty ()
-{
-  int tty_fd;
-  char *tty;
-
-  tty_fd = open ("/dev/tty", O_RDWR|O_NONBLOCK);
-
-  if (tty_fd < 0)
-    {
-      tty = (char *)ttyname (fileno (stdin));
-      if (tty == 0)
-	return;
-      tty_fd = open (tty, O_RDWR|O_NONBLOCK);
-    }
-  if (tty_fd >= 0)
-    close (tty_fd);
-}
-
-/* Return 1 if PATH1 and PATH2 are the same file.  This is kind of
-   expensive.  If non-NULL STP1 and STP2 point to stat structures
-   corresponding to PATH1 and PATH2, respectively. */
-int
-same_file (path1, path2, stp1, stp2)
-     const char *path1, *path2;
-     struct stat *stp1, *stp2;
-{
-  struct stat st1, st2;
-
-  if (stp1 == NULL)
-    {
-      if (stat (path1, &st1) != 0)
-	return (0);
-      stp1 = &st1;
-    }
-
-  if (stp2 == NULL)
-    {
-      if (stat (path2, &st2) != 0)
-	return (0);
-      stp2 = &st2;
-    }
-
-  return ((stp1->st_dev == stp2->st_dev) && (stp1->st_ino == stp2->st_ino));
-}
-
-/* Move FD to a number close to the maximum number of file descriptors
-   allowed in the shell process, to avoid the user stepping on it with
-   redirection and causing us extra work.  If CHECK_NEW is non-zero,
-   we check whether or not the file descriptors are in use before
-   duplicating FD onto them.  MAXFD says where to start checking the
-   file descriptors.  If it's less than 20, we get the maximum value
-   available from getdtablesize(2). */
-int
-move_to_high_fd (fd, check_new, maxfd)
-     int fd, check_new, maxfd;
-{
-  int script_fd, nfds, ignore;
-
-  if (maxfd < 20)
-    {
-      nfds = getdtablesize ();
-      if (nfds <= 0)
-	nfds = 20;
-      if (nfds > HIGH_FD_MAX)
-	nfds = HIGH_FD_MAX;		/* reasonable maximum */
-    }
-  else
-    nfds = maxfd;
-
-  for (nfds--; check_new && nfds > 3; nfds--)
-    if (fcntl (nfds, F_GETFD, &ignore) == -1)
-      break;
-
-  if (nfds > 3 && fd != nfds && (script_fd = dup2 (fd, nfds)) != -1)
-    {
-      if (check_new == 0 || fd != fileno (stderr))	/* don't close stderr */
-	close (fd);
-      return (script_fd);
-    }
-
-  /* OK, we didn't find one less than our artificial maximum; return the
-     original file descriptor. */
-  return (fd);
-}
- 
-/* Return non-zero if the characters from SAMPLE are not all valid
-   characters to be found in the first line of a shell script.  We
-   check up to the first newline, or SAMPLE_LEN, whichever comes first.
-   All of the characters must be printable or whitespace. */
-
-int
-check_binary_file (sample, sample_len)
-     const char *sample;
-     int sample_len;
-{
-  register int i;
-  unsigned char c;
-
-  if (sample_len >= 4 && sample[0] == 0x7f && sample[1] == 'E' && sample[2] == 'L' && sample[3] == 'F')
-    return 1;
-
-  /* Generally we check the first line for NULs. If the first line looks like
-     a `#!' interpreter specifier, we just look for NULs anywhere in the
-     buffer. */
-  if (sample[0] == '#' && sample[1] == '!')
-    return (memchr (sample, '\0', sample_len) != NULL);
-
-  for (i = 0; i < sample_len; i++)
-    {
-      c = sample[i];
-      if (c == '\n')
-	return (0);
-      if (c == '\0')
-	return (1);
-    }
-
-  return (0);
-}
-
-/* **************************************************************** */
-/*								    */
-/*		    Functions to manipulate pipes		    */
-/*								    */
-/* **************************************************************** */
-
-int
-sh_openpipe (pv)
-     int *pv;
-{
-  int r;
-
-  if ((r = pipe (pv)) < 0)
-    return r;
-
-  pv[0] = move_to_high_fd (pv[0], 1, 64);
-  pv[1] = move_to_high_fd (pv[1], 1, 64);
-
-  return 0;  
-}
-
-int
-sh_closepipe (pv)
-     int *pv;
-{
-  if (pv[0] >= 0)
-    close (pv[0]);
-
-  if (pv[1] >= 0)
-    close (pv[1]);
-
-  pv[0] = pv[1] = -1;
-  return 0;
-}
-
-/* **************************************************************** */
-/*								    */
-/*		    Functions to inspect pathnames		    */
-/*								    */
-/* **************************************************************** */
-
-int
-file_exists (fn)
-     const char *fn;
-{
-  struct stat sb;
-
-  return (stat (fn, &sb) == 0);
-}
-
-int
-file_isdir (fn)
-     const char *fn;
-{
-  struct stat sb;
-
-  return ((stat (fn, &sb) == 0) && S_ISDIR (sb.st_mode));
-}
-
-int
-file_iswdir (fn)
-     const char *fn;
-{
-  return (file_isdir (fn) && sh_eaccess (fn, W_OK) == 0);
-}
-
-/* Return 1 if STRING is "." or "..", optionally followed by a directory
-   separator */
-int
-path_dot_or_dotdot (string)
-     const char *string;
-{
-  if (string == 0 || *string == '\0' || *string != '.')
-    return (0);
-
-  /* string[0] == '.' */
-  if (PATHSEP(string[1]) || (string[1] == '.' && PATHSEP(string[2])))
-    return (1);
-
-  return (0);
-}
-
-/* Return 1 if STRING contains an absolute pathname, else 0.  Used by `cd'
-   to decide whether or not to look up a directory name in $CDPATH. */
-int
-absolute_pathname (string)
-     const char *string;
-{
-  if (string == 0 || *string == '\0')
-    return (0);
-
-  if (ABSPATH(string))
-    return (1);
-
-  if (string[0] == '.' && PATHSEP(string[1]))	/* . and ./ */
-    return (1);
-
-  if (string[0] == '.' && string[1] == '.' && PATHSEP(string[2]))	/* .. and ../ */
-    return (1);
-
-  return (0);
-}
-
-/* Return 1 if STRING is an absolute program name; it is absolute if it
-   contains any slashes.  This is used to decide whether or not to look
-   up through $PATH. */
-int
-absolute_program (string)
-     const char *string;
-{
-  return ((char *)mbschr (string, '/') != (char *)NULL);
-}
-
-/* **************************************************************** */
-/*								    */
-/*		    Functions to manipulate pathnames		    */
-/*								    */
-/* **************************************************************** */
-
-/* Turn STRING (a pathname) into an absolute pathname, assuming that
-   DOT_PATH contains the symbolic location of `.'.  This always
-   returns a new string, even if STRING was an absolute pathname to
-   begin with. */
-char *
-make_absolute (string, dot_path)
-     const char *string, *dot_path;
-{
-  char *result;
-
-  if (dot_path == 0 || ABSPATH(string))
-#ifdef __CYGWIN__
-    {
-      char pathbuf[PATH_MAX + 1];
-
-      /* WAS cygwin_conv_to_full_posix_path (string, pathbuf); */
-      cygwin_conv_path (CCP_WIN_A_TO_POSIX, string, pathbuf, PATH_MAX);
-      result = savestring (pathbuf);
-    }
-#else
-    result = savestring (string);
-#endif
-  else
-    result = sh_makepath (dot_path, string, 0);
-
-  return (result);
-}
-
-/* Return the `basename' of the pathname in STRING (the stuff after the
-   last '/').  If STRING is `/', just return it. */
-char *
-base_pathname (string)
-     char *string;
-{
-  char *p;
-
-#if 0
-  if (absolute_pathname (string) == 0)
-    return (string);
-#endif
-
-  if (string[0] == '/' && string[1] == 0)
-    return (string);
-
-  p = (char *)strrchr (string, '/');
-  return (p ? ++p : string);
-}
-
-/* Return the full pathname of FILE.  Easy.  Filenames that begin
-   with a '/' are returned as themselves.  Other filenames have
-   the current working directory prepended.  A new string is
-   returned in either case. */
-char *
-full_pathname (file)
-     char *file;
-{
-  char *ret;
-
-  file = (*file == '~') ? bash_tilde_expand (file, 0) : savestring (file);
-
-  if (ABSPATH(file))
-    return (file);
-
-  ret = sh_makepath ((char *)NULL, file, (MP_DOCWD|MP_RMDOT));
-  free (file);
-
-  return (ret);
-}
-
-/* A slightly related function.  Get the prettiest name of this
-   directory possible. */
-static char tdir[PATH_MAX];
-
-/* Return a pretty pathname.  If the first part of the pathname is
-   the same as $HOME, then replace that with `~'.  */
-char *
-polite_directory_format (name)
-     char *name;
-{
-  char *home;
-  int l;
-
-  home = get_string_value ("HOME");
-  l = home ? strlen (home) : 0;
-  if (l > 1 && strncmp (home, name, l) == 0 && (!name[l] || name[l] == '/'))
-    {
-      strncpy (tdir + 1, name + l, sizeof(tdir) - 2);
-      tdir[0] = '~';
-      tdir[sizeof(tdir) - 1] = '\0';
-      return (tdir);
-    }
-  else
-    return (name);
-}
-
-/* Trim NAME.  If NAME begins with `~/', skip over tilde prefix.  Trim to
-   keep any tilde prefix and PROMPT_DIRTRIM trailing directory components
-   and replace the intervening characters with `...' */
-char *
-trim_pathname (name, maxlen)
-     char *name;
-     int maxlen;
-{
-  int nlen, ndirs;
-  intmax_t nskip;
-  char *nbeg, *nend, *ntail, *v;
-
-  if (name == 0 || (nlen = strlen (name)) == 0)
-    return name;
-  nend = name + nlen;
-
-  v = get_string_value ("PROMPT_DIRTRIM");
-  if (v == 0 || *v == 0)
-    return name;
-  if (legal_number (v, &nskip) == 0 || nskip <= 0)
-    return name;
-
-  /* Skip over tilde prefix */
-  nbeg = name;
-  if (name[0] == '~')
-    for (nbeg = name; *nbeg; nbeg++)
-      if (*nbeg == '/')
-	{
-	  nbeg++;
-	  break;
-	}
-  if (*nbeg == 0)
-    return name;
-
-  for (ndirs = 0, ntail = nbeg; *ntail; ntail++)
-    if (*ntail == '/')
-      ndirs++;
-  if (ndirs < nskip)
-    return name;
-
-  for (ntail = (*nend == '/') ? nend : nend - 1; ntail > nbeg; ntail--)
-    {
-      if (*ntail == '/')
-	nskip--;
-      if (nskip == 0)
-	break;
-    }
-  if (ntail == nbeg)
-    return name;
-
-  /* Now we want to return name[0..nbeg]+"..."+ntail, modifying name in place */
-  nlen = ntail - nbeg;
-  if (nlen <= 3)
-    return name;
-
-  *nbeg++ = '.';
-  *nbeg++ = '.';
-  *nbeg++ = '.';
-
-  nlen = nend - ntail;
-  memmove (nbeg, ntail, nlen);
-  nbeg[nlen] = '\0';
-
-  return name;
-}
-
-/* Return a printable representation of FN without special characters.  The
-   caller is responsible for freeing memory if this returns something other
-   than its argument.  If FLAGS is non-zero, we are printing for portable
-   re-input and should single-quote filenames appropriately. */
-char *
-printable_filename (fn, flags)
-     char *fn;
-     int flags;
-{
-  char *newf;
-
-  if (ansic_shouldquote (fn))
-    newf = ansic_quote (fn, 0, NULL);
-  else if (flags && sh_contains_shell_metas (fn))
-    newf = sh_single_quote (fn);
-  else
-    newf = fn;
-
-  return newf;
-}
-
-/* Given a string containing units of information separated by colons,
-   return the next one pointed to by (P_INDEX), or NULL if there are no more.
-   Advance (P_INDEX) to the character after the colon. */
-char *
-extract_colon_unit (string, p_index)
-     char *string;
-     int *p_index;
-{
-  int i, start, len;
-  char *value;
-
-  if (string == 0)
-    return (string);
-
-  len = strlen (string);
-  if (*p_index >= len)
-    return ((char *)NULL);
-
-  i = *p_index;
-
-  /* Each call to this routine leaves the index pointing at a colon if
-     there is more to the path.  If I is > 0, then increment past the
-     `:'.  If I is 0, then the path has a leading colon.  Trailing colons
-     are handled OK by the `else' part of the if statement; an empty
-     string is returned in that case. */
-  if (i && string[i] == ':')
-    i++;
-
-  for (start = i; string[i] && string[i] != ':'; i++)
-    ;
-
-  *p_index = i;
-
-  if (i == start)
-    {
-      if (string[i])
-	(*p_index)++;
-      /* Return "" in the case of a trailing `:'. */
-      value = (char *)xmalloc (1);
-      value[0] = '\0';
-    }
-  else
-    value = substring (string, start, i);
-
-  return (value);
-}
-
-/* **************************************************************** */
-/*								    */
-/*		    Tilde Initialization and Expansion		    */
-/*								    */
-/* **************************************************************** */
-
-#if defined (PUSHD_AND_POPD)
-extern char *get_dirstack_from_string PARAMS((char *));
-#endif
-
-static char **bash_tilde_prefixes;
-static char **bash_tilde_prefixes2;
-static char **bash_tilde_suffixes;
-static char **bash_tilde_suffixes2;
-
-/* If tilde_expand hasn't been able to expand the text, perhaps it
-   is a special shell expansion.  This function is installed as the
-   tilde_expansion_preexpansion_hook.  It knows how to expand ~- and ~+.
-   If PUSHD_AND_POPD is defined, ~[+-]N expands to directories from the
-   directory stack. */
-static char *
-bash_special_tilde_expansions (text)
-     char *text;
-{
-  char *result;
-
-  result = (char *)NULL;
-
-  if (text[0] == '+' && text[1] == '\0')
-    result = get_string_value ("PWD");
-  else if (text[0] == '-' && text[1] == '\0')
-    result = get_string_value ("OLDPWD");
-#if defined (PUSHD_AND_POPD)
-  else if (DIGIT (*text) || ((*text == '+' || *text == '-') && DIGIT (text[1])))
-    result = get_dirstack_from_string (text);
-#endif
-
-  return (result ? savestring (result) : (char *)NULL);
-}
-
-/* Initialize the tilde expander.  In Bash, we handle `~-' and `~+', as
-   well as handling special tilde prefixes; `:~" and `=~' are indications
-   that we should do tilde expansion. */
-void
-tilde_initialize ()
-{
-  static int times_called = 0;
-
-  /* Tell the tilde expander that we want a crack first. */
-  tilde_expansion_preexpansion_hook = bash_special_tilde_expansions;
-
-  /* Tell the tilde expander about special strings which start a tilde
-     expansion, and the special strings that end one.  Only do this once.
-     tilde_initialize () is called from within bashline_reinitialize (). */
-  if (times_called++ == 0)
-    {
-      bash_tilde_prefixes = strvec_create (3);
-      bash_tilde_prefixes[0] = "=~";
-      bash_tilde_prefixes[1] = ":~";
-      bash_tilde_prefixes[2] = (char *)NULL;
-
-      bash_tilde_prefixes2 = strvec_create (2);
-      bash_tilde_prefixes2[0] = ":~";
-      bash_tilde_prefixes2[1] = (char *)NULL;
-
-      tilde_additional_prefixes = bash_tilde_prefixes;
-
-      bash_tilde_suffixes = strvec_create (3);
-      bash_tilde_suffixes[0] = ":";
-      bash_tilde_suffixes[1] = "=~";	/* XXX - ?? */
-      bash_tilde_suffixes[2] = (char *)NULL;
-
-      tilde_additional_suffixes = bash_tilde_suffixes;
-
-      bash_tilde_suffixes2 = strvec_create (2);
-      bash_tilde_suffixes2[0] = ":";
-      bash_tilde_suffixes2[1] = (char *)NULL;
-    }
-}
-
-/* POSIX.2, 3.6.1:  A tilde-prefix consists of an unquoted tilde character
-   at the beginning of the word, followed by all of the characters preceding
-   the first unquoted slash in the word, or all the characters in the word
-   if there is no slash...If none of the characters in the tilde-prefix are
-   quoted, the characters in the tilde-prefix following the tilde shell be
-   treated as a possible login name. */
-
-#define TILDE_END(c)	((c) == '\0' || (c) == '/' || (c) == ':')
-
-static int
-unquoted_tilde_word (s)
-     const char *s;
-{
-  const char *r;
-
-  for (r = s; TILDE_END(*r) == 0; r++)
-    {
-      switch (*r)
-	{
-	case '\\':
-	case '\'':
-	case '"':
-	  return 0;
-	}
-    }
-  return 1;
-}
-
-/* Find the end of the tilde-prefix starting at S, and return the tilde
-   prefix in newly-allocated memory.  Return the length of the string in
-   *LENP.  FLAGS tells whether or not we're in an assignment context --
-   if so, `:' delimits the end of the tilde prefix as well. */
-char *
-bash_tilde_find_word (s, flags, lenp)
-     const char *s;
-     int flags, *lenp;
-{
-  const char *r;
-  char *ret;
-  int l;
-
-  for (r = s; *r && *r != '/'; r++)
-    {
-      /* Short-circuit immediately if we see a quote character.  Even though
-	 POSIX says that `the first unquoted slash' (or `:') terminates the
-	 tilde-prefix, in practice, any quoted portion of the tilde prefix
-	 will cause it to not be expanded. */
-      if (*r == '\\' || *r == '\'' || *r == '"')  
-	{
-	  ret = savestring (s);
-	  if (lenp)
-	    *lenp = 0;
-	  return ret;
-	}
-      else if (flags && *r == ':')
-	break;
-    }
-  l = r - s;
-  ret = xmalloc (l + 1);
-  strncpy (ret, s, l);
-  ret[l] = '\0';
-  if (lenp)
-    *lenp = l;
-  return ret;
-}
-    
-/* Tilde-expand S by running it through the tilde expansion library.
-   ASSIGN_P is 1 if this is a variable assignment, so the alternate
-   tilde prefixes should be enabled (`=~' and `:~', see above).  If
-   ASSIGN_P is 2, we are expanding the rhs of an assignment statement,
-   so `=~' is not valid. */
-char *
-bash_tilde_expand (s, assign_p)
-     const char *s;
-     int assign_p;
-{
-  int r;
-  char *ret;
-
-  tilde_additional_prefixes = assign_p == 0 ? (char **)0
-  					    : (assign_p == 2 ? bash_tilde_prefixes2 : bash_tilde_prefixes);
-  if (assign_p == 2)
-    tilde_additional_suffixes = bash_tilde_suffixes2;
-
-  r = (*s == '~') ? unquoted_tilde_word (s) : 1;
-  ret = r ? tilde_expand (s) : savestring (s);
-
-  QUIT;
-
-  return (ret);
-}
-
-/* **************************************************************** */
-/*								    */
-/*	  Functions to manipulate and search the group list	    */
-/*								    */
-/* **************************************************************** */
-
-static int ngroups, maxgroups;
-
-/* The set of groups that this user is a member of. */
-static GETGROUPS_T *group_array = (GETGROUPS_T *)NULL;
-
-#if !defined (NOGROUP)
-#  define NOGROUP (gid_t) -1
-#endif
-
-static void
-initialize_group_array ()
-{
-  register int i;
-
-  if (maxgroups == 0)
-    maxgroups = getmaxgroups ();
-
-  ngroups = 0;
-  group_array = (GETGROUPS_T *)xrealloc (group_array, maxgroups * sizeof (GETGROUPS_T));
-
-#if defined (HAVE_GETGROUPS)
-  ngroups = getgroups (maxgroups, group_array);
-#endif
-
-  /* If getgroups returns nothing, or the OS does not support getgroups(),
-     make sure the groups array includes at least the current gid. */
-  if (ngroups == 0)
-    {
-      group_array[0] = current_user.gid;
-      ngroups = 1;
-    }
-
-  /* If the primary group is not in the groups array, add it as group_array[0]
-     and shuffle everything else up 1, if there's room. */
-  for (i = 0; i < ngroups; i++)
-    if (current_user.gid == (gid_t)group_array[i])
-      break;
-  if (i == ngroups && ngroups < maxgroups)
-    {
-      for (i = ngroups; i > 0; i--)
-	group_array[i] = group_array[i - 1];
-      group_array[0] = current_user.gid;
-      ngroups++;
-    }
-
-  /* If the primary group is not group_array[0], swap group_array[0] and
-     whatever the current group is.  The vast majority of systems should
-     not need this; a notable exception is Linux. */
-  if (group_array[0] != current_user.gid)
-    {
-      for (i = 0; i < ngroups; i++)
-	if (group_array[i] == current_user.gid)
-	  break;
-      if (i < ngroups)
-	{
-	  group_array[i] = group_array[0];
-	  group_array[0] = current_user.gid;
-	}
-    }
-}
-
-/* Return non-zero if GID is one that we have in our groups list. */
-int
-#if defined (__STDC__) || defined ( _MINIX)
-group_member (gid_t gid)
-#else
-group_member (gid)
-     gid_t gid;
-#endif /* !__STDC__ && !_MINIX */
-{
-#if defined (HAVE_GETGROUPS)
-  register int i;
-#endif
-
-  /* Short-circuit if possible, maybe saving a call to getgroups(). */
-  if (gid == current_user.gid || gid == current_user.egid)
-    return (1);
-
-#if defined (HAVE_GETGROUPS)
-  if (ngroups == 0)
-    initialize_group_array ();
-
-  /* In case of error, the user loses. */
-  if (ngroups <= 0)
-    return (0);
-
-  /* Search through the list looking for GID. */
-  for (i = 0; i < ngroups; i++)
-    if (gid == (gid_t)group_array[i])
-      return (1);
-#endif
-
-  return (0);
-}
-
-char **
-get_group_list (ngp)
-     int *ngp;
-{
-  static char **group_vector = (char **)NULL;
-  register int i;
-
-  if (group_vector)
-    {
-      if (ngp)
-	*ngp = ngroups;
-      return group_vector;
-    }
-
-  if (ngroups == 0)
-    initialize_group_array ();
-
-  if (ngroups <= 0)
-    {
-      if (ngp)
-	*ngp = 0;
-      return (char **)NULL;
-    }
-
-  group_vector = strvec_create (ngroups);
-  for (i = 0; i < ngroups; i++)
-    group_vector[i] = itos (group_array[i]);
-
-  if (ngp)
-    *ngp = ngroups;
-  return group_vector;
-}
-
-int *
-get_group_array (ngp)
-     int *ngp;
-{
-  int i;
-  static int *group_iarray = (int *)NULL;
-
-  if (group_iarray)
-    {
-      if (ngp)
-	*ngp = ngroups;
-      return (group_iarray);
-    }
-
-  if (ngroups == 0)
-    initialize_group_array ();    
-
-  if (ngroups <= 0)
-    {
-      if (ngp)
-	*ngp = 0;
-      return (int *)NULL;
-    }
-
-  group_iarray = (int *)xmalloc (ngroups * sizeof (int));
-  for (i = 0; i < ngroups; i++)
-    group_iarray[i] = (int)group_array[i];
-
-  if (ngp)
-    *ngp = ngroups;
-  return group_iarray;
-}
-
-/* **************************************************************** */
-/*								    */
-/*	  Miscellaneous functions				    */
-/*								    */
-/* **************************************************************** */
-
-/* Return a value for PATH that is guaranteed to find all of the standard
-   utilities.  This uses Posix.2 configuration variables, if present.  It
-   uses a value defined in config.h as a last resort. */
-char *
-conf_standard_path ()
-{
-#if defined (_CS_PATH) && defined (HAVE_CONFSTR)
-  char *p;
-  size_t len;
-
-  len = (size_t)confstr (_CS_PATH, (char *)NULL, (size_t)0);
-  if (len > 0)
-    {
-      p = (char *)xmalloc (len + 2);
-      *p = '\0';
-      confstr (_CS_PATH, p, len);
-      return (p);
-    }
-  else
-    return (savestring (STANDARD_UTILS_PATH));
-#else /* !_CS_PATH || !HAVE_CONFSTR  */
-#  if defined (CS_PATH)
-  return (savestring (CS_PATH));
-#  else
-  return (savestring (STANDARD_UTILS_PATH));
-#  endif /* !CS_PATH */
-#endif /* !_CS_PATH || !HAVE_CONFSTR */
-}
-
-int
-default_columns ()
-{
-  char *v;
-  int c;
-
-  c = -1;
-  v = get_string_value ("COLUMNS");
-  if (v && *v)
-    {
-      c = atoi (v);
-      if (c > 0)
-	return c;
-    }
-
-  if (check_window_size)
-    get_new_window_size (0, (int *)0, &c);
-
-  return (c > 0 ? c : 80);
-}
-
-  
diff --git a/third_party/bash/general.h b/third_party/bash/general.h
deleted file mode 100644
index 8064c50eb..000000000
--- a/third_party/bash/general.h
+++ /dev/null
@@ -1,372 +0,0 @@
-/* general.h -- defines that everybody likes to use. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_GENERAL_H_)
-#define _GENERAL_H_
-
-#include "stdc.h"
-
-#include "bashtypes.h"
-#include "chartypes.h"
-
-#if defined (HAVE_SYS_RESOURCE_H) && defined (RLIMTYPE)
-#  if defined (HAVE_SYS_TIME_H)
-#    include <sys/time.h>
-#  endif
-#  include <sys/resource.h>
-#endif
-
-#if defined (HAVE_STRING_H)
-#  include <string.h>
-#else
-#  include <strings.h>
-#endif /* !HAVE_STRING_H */
-
-#if defined (HAVE_LIMITS_H)
-#  include <limits.h>
-#endif
-
-#include "xmalloc.h"
-
-/* NULL pointer type. */
-#if !defined (NULL)
-#  if defined (__STDC__)
-#    define NULL ((void *) 0)
-#  else
-#    define NULL 0x0
-#  endif /* !__STDC__ */
-#endif /* !NULL */
-
-/* Hardly used anymore */
-#define pointer_to_int(x)	(int)((char *)x - (char *)0)
-
-#if defined (alpha) && defined (__GNUC__) && !defined (strchr) && !defined (__STDC__)
-extern char *strchr (), *strrchr ();
-#endif
-
-#if !defined (strcpy) && (defined (HAVE_DECL_STRCPY) && !HAVE_DECL_STRCPY)
-extern char *strcpy PARAMS((char *, const char *));
-#endif
-
-#if !defined (savestring)
-#  define savestring(x) (char *)strcpy (xmalloc (1 + strlen (x)), (x))
-#endif
-
-#ifndef member
-#  define member(c, s) ((c) ? ((char *)mbschr ((s), (c)) != (char *)NULL) : 0)
-#endif
-
-#ifndef whitespace
-#define whitespace(c) (((c) == ' ') || ((c) == '\t'))
-#endif
-
-#ifndef CHAR_MAX
-#  ifdef __CHAR_UNSIGNED__
-#    define CHAR_MAX	0xff
-#  else
-#    define CHAR_MAX	0x7f
-#  endif
-#endif
-
-#ifndef CHAR_BIT
-#  define CHAR_BIT 8
-#endif
-
-/* Nonzero if the integer type T is signed.  */
-#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
-
-/* The width in bits of the integer type or expression T.
-   Padding bits are not supported; this is checked at compile-time below.  */
-#define TYPE_WIDTH(t) (sizeof (t) * CHAR_BIT)
-
-/* Bound on length of the string representing an unsigned integer
-   value representable in B bits.  log10 (2.0) < 146/485.  The
-      smallest value of B where this bound is not tight is 2621.  */
-#define INT_BITS_STRLEN_BOUND(b) (((b) * 146 + 484) / 485)
-
-/* Bound on length of the string representing an integer value of type T.
-   Subtract one for the sign bit if T is signed;
-   302 / 1000 is log10 (2) rounded up;
-   add one for integer division truncation;
-   add one more for a minus sign if t is signed.  */
-#define INT_STRLEN_BOUND(t) \
-  ((TYPE_WIDTH (t) - TYPE_SIGNED (t)) * 302 / 1000 \
-   + 1 + TYPE_SIGNED (t))
-
-/* Updated version adapted from gnulib/intprops.h, not used right now.
-   Changes the approximation of log10(2) from 302/1000 to 146/485. */
-#if 0
-#define INT_STRLEN_BOUND(t) \
-  (INT_BITS_STRLEN_BOUND (TYPE_WIDTH (t) - TYPE_SIGNED (t)) + TYPE_SIGNED(t))
-#endif
-
-/* Bound on buffer size needed to represent an integer type or expression T,
-   including the terminating null.  */
-#define INT_BUFSIZE_BOUND(t) (INT_STRLEN_BOUND (t) + 1)
-
-/* Define exactly what a legal shell identifier consists of. */
-#define legal_variable_starter(c) (ISALPHA(c) || (c == '_'))
-#define legal_variable_char(c)	(ISALNUM(c) || c == '_')
-
-/* Definitions used in subst.c and by the `read' builtin for field
-   splitting. */
-#define spctabnl(c)	((c) == ' ' || (c) == '\t' || (c) == '\n')
-
-/* All structs which contain a `next' field should have that field
-   as the first field in the struct.  This means that functions
-   can be written to handle the general case for linked lists. */
-typedef struct g_list {
-  struct g_list *next;
-} GENERIC_LIST;
-
-/* Here is a generic structure for associating character strings
-   with integers.  It is used in the parser for shell tokenization. */
-typedef struct {
-  char *word;
-  int token;
-} STRING_INT_ALIST;
-
-/* A macro to avoid making an unnecessary function call. */
-#define REVERSE_LIST(list, type) \
-  ((list && list->next) ? (type)list_reverse ((GENERIC_LIST *)list) \
-			: (type)(list))
-
-#if __GNUC__ > 1
-#  define FASTCOPY(s, d, n)  __builtin_memcpy ((d), (s), (n))
-#else /* !__GNUC__ */
-#  if !defined (HAVE_BCOPY)
-#    if !defined (HAVE_MEMMOVE)
-#      define FASTCOPY(s, d, n)  memcpy ((d), (s), (n))
-#    else
-#      define FASTCOPY(s, d, n)  memmove ((d), (s), (n))
-#    endif /* !HAVE_MEMMOVE */
-#  else /* HAVE_BCOPY */
-#    define FASTCOPY(s, d, n)  bcopy ((s), (d), (n))
-#  endif /* HAVE_BCOPY */
-#endif /* !__GNUC__ */
-
-/* String comparisons that possibly save a function call each. */
-#define STREQ(a, b) ((a)[0] == (b)[0] && strcmp(a, b) == 0)
-#define STREQN(a, b, n) ((n == 0) ? (1) \
-				  : ((a)[0] == (b)[0] && strncmp(a, b, n) == 0))
-
-/* More convenience definitions that possibly save system or libc calls. */
-#define STRLEN(s) (((s) && (s)[0]) ? ((s)[1] ? ((s)[2] ? strlen(s) : 2) : 1) : 0)
-#define FREE(s)  do { if (s) free (s); } while (0)
-#define MEMBER(c, s) (((c) && c == (s)[0] && !(s)[1]) || (member(c, s)))
-
-/* A fairly hairy macro to check whether an allocated string has more room,
-   and to resize it using xrealloc if it does not.
-   STR is the string (char *)
-   CIND is the current index into the string (int)
-   ROOM is the amount of additional room we need in the string (int)
-   CSIZE is the currently-allocated size of STR (int)
-   SINCR is how much to increment CSIZE before calling xrealloc (int) */
-
-#define RESIZE_MALLOCED_BUFFER(str, cind, room, csize, sincr) \
-  do { \
-    if ((cind) + (room) >= csize) \
-      { \
-	while ((cind) + (room) >= csize) \
-	  csize += (sincr); \
-	str = xrealloc (str, csize); \
-      } \
-  } while (0)
-
-/* Function pointers can be declared as (Function *)foo. */
-#if !defined (_FUNCTION_DEF)
-#  define _FUNCTION_DEF
-typedef int Function ();
-typedef void VFunction ();
-typedef char *CPFunction ();		/* no longer used */
-typedef char **CPPFunction ();		/* no longer used */
-#endif /* _FUNCTION_DEF */
-
-#ifndef SH_FUNCTION_TYPEDEF
-#  define SH_FUNCTION_TYPEDEF
-
-/* Shell function typedefs with prototypes */
-/* `Generic' function pointer typedefs */
-
-typedef int sh_intfunc_t PARAMS((int));
-typedef int sh_ivoidfunc_t PARAMS((void));
-typedef int sh_icpfunc_t PARAMS((char *));
-typedef int sh_icppfunc_t PARAMS((char **));
-typedef int sh_iptrfunc_t PARAMS((PTR_T));
-
-typedef void sh_voidfunc_t PARAMS((void));
-typedef void sh_vintfunc_t PARAMS((int));
-typedef void sh_vcpfunc_t PARAMS((char *));
-typedef void sh_vcppfunc_t PARAMS((char **));
-typedef void sh_vptrfunc_t PARAMS((PTR_T));
-
-typedef int sh_wdesc_func_t PARAMS((WORD_DESC *));
-typedef int sh_wlist_func_t PARAMS((WORD_LIST *));
-
-typedef int sh_glist_func_t PARAMS((GENERIC_LIST *));
-
-typedef char *sh_string_func_t PARAMS((char *));	/* like savestring, et al. */
-
-typedef int sh_msg_func_t PARAMS((const char *, ...));	/* printf(3)-like */
-typedef void sh_vmsg_func_t PARAMS((const char *, ...));	/* printf(3)-like */
-
-/* Specific function pointer typedefs.  Most of these could be done
-   with #defines. */
-typedef void sh_sv_func_t PARAMS((char *));	/* sh_vcpfunc_t */
-typedef void sh_free_func_t PARAMS((PTR_T));	/* sh_vptrfunc_t */
-typedef void sh_resetsig_func_t PARAMS((int));	/* sh_vintfunc_t */
-
-typedef int sh_ignore_func_t PARAMS((const char *));	/* sh_icpfunc_t */
-
-typedef int sh_assign_func_t PARAMS((const char *));
-typedef int sh_wassign_func_t PARAMS((WORD_DESC *, int));
-
-typedef int sh_load_func_t PARAMS((char *));
-typedef void sh_unload_func_t PARAMS((char *));
-
-typedef int sh_builtin_func_t PARAMS((WORD_LIST *)); /* sh_wlist_func_t */
-
-#endif /* SH_FUNCTION_TYPEDEF */
-
-#define NOW	((time_t) time ((time_t *) 0))
-#define GETTIME(tv)	gettimeofday(&(tv), NULL)
-
-/* Some defines for calling file status functions. */
-#define FS_EXISTS	  0x1
-#define FS_EXECABLE	  0x2
-#define FS_EXEC_PREFERRED 0x4
-#define FS_EXEC_ONLY	  0x8
-#define FS_DIRECTORY	  0x10
-#define FS_NODIRS	  0x20
-#define FS_READABLE	  0x40
-
-/* Default maximum for move_to_high_fd */
-#define HIGH_FD_MAX	256
-
-/* The type of function passed as the fourth argument to qsort(3). */
-#ifdef __STDC__
-typedef int QSFUNC (const void *, const void *);
-#else
-typedef int QSFUNC ();
-#endif 
-
-/* Some useful definitions for Unix pathnames.  Argument convention:
-   x == string, c == character */
-
-#if !defined (__CYGWIN__)
-#  define ABSPATH(x)	((x)[0] == '/')
-#  define RELPATH(x)	((x)[0] != '/')
-#else /* __CYGWIN__ */
-#  define ABSPATH(x)	(((x)[0] && ISALPHA((unsigned char)(x)[0]) && (x)[1] == ':') || ISDIRSEP((x)[0]))
-#  define RELPATH(x)	(ABSPATH(x) == 0)
-#endif /* __CYGWIN__ */
-
-#define ROOTEDPATH(x)	(ABSPATH(x))
-
-#define DIRSEP	'/'
-#if !defined (__CYGWIN__)
-#  define ISDIRSEP(c)	((c) == '/')
-#else
-#  define ISDIRSEP(c)	((c) == '/' || (c) == '\\')
-#endif /* __CYGWIN__ */
-#define PATHSEP(c)	(ISDIRSEP(c) || (c) == 0)
-
-#define DOT_OR_DOTDOT(s)	(s[0] == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0)))
-
-#if defined (HANDLE_MULTIBYTE)
-#define WDOT_OR_DOTDOT(w)	(w[0] == L'.' && (w[1] == L'\0' || (w[1] == L'.' && w[2] == L'\0')))
-#endif
-
-#if 0
-/* Declarations for functions defined in xmalloc.c */
-extern PTR_T xmalloc PARAMS((size_t));
-extern PTR_T xrealloc PARAMS((void *, size_t));
-extern void xfree PARAMS((void *));
-#endif
-
-/* Declarations for functions defined in general.c */
-extern void posix_initialize PARAMS((int));
-
-extern int num_posix_options PARAMS((void));
-extern char *get_posix_options PARAMS((char *));
-extern void set_posix_options PARAMS((const char *));
-
-extern void save_posix_options PARAMS((void));
-
-#if defined (RLIMTYPE)
-extern RLIMTYPE string_to_rlimtype PARAMS((char *));
-extern void print_rlimtype PARAMS((RLIMTYPE, int));
-#endif
-
-extern int all_digits PARAMS((const char *));
-extern int legal_number PARAMS((const char *, intmax_t *));
-extern int legal_identifier PARAMS((const char *));
-extern int importable_function_name PARAMS((const char *, size_t));
-extern int exportable_function_name PARAMS((const char *));
-extern int check_identifier PARAMS((WORD_DESC *, int));
-extern int valid_nameref_value PARAMS((const char *, int));
-extern int check_selfref PARAMS((const char *, char *, int));
-extern int legal_alias_name PARAMS((const char *, int));
-extern int line_isblank PARAMS((const char *));
-extern int assignment PARAMS((const char *, int));
-
-extern int sh_unset_nodelay_mode PARAMS((int));
-extern int sh_setclexec PARAMS((int));
-extern int sh_validfd PARAMS((int));
-extern int fd_ispipe PARAMS((int));
-extern void check_dev_tty PARAMS((void));
-extern int move_to_high_fd PARAMS((int, int, int));
-extern int check_binary_file PARAMS((const char *, int));
-
-#ifdef _POSIXSTAT_H_
-extern int same_file PARAMS((const char *, const char *, struct stat *, struct stat *));
-#endif
-
-extern int sh_openpipe PARAMS((int *));
-extern int sh_closepipe PARAMS((int *));
-
-extern int file_exists PARAMS((const char *));
-extern int file_isdir PARAMS((const char  *));
-extern int file_iswdir PARAMS((const char  *));
-extern int path_dot_or_dotdot PARAMS((const char *));
-extern int absolute_pathname PARAMS((const char *));
-extern int absolute_program PARAMS((const char *));
-
-extern char *make_absolute PARAMS((const char *, const char *));
-extern char *base_pathname PARAMS((char *));
-extern char *full_pathname PARAMS((char *));
-extern char *polite_directory_format PARAMS((char *));
-extern char *trim_pathname PARAMS((char *, int));
-extern char *printable_filename PARAMS((char *, int));
-
-extern char *extract_colon_unit PARAMS((char *, int *));
-
-extern void tilde_initialize PARAMS((void));
-extern char *bash_tilde_find_word PARAMS((const char *, int, int *));
-extern char *bash_tilde_expand PARAMS((const char *, int));
-
-extern int group_member PARAMS((gid_t));
-extern char **get_group_list PARAMS((int *));
-extern int *get_group_array PARAMS((int *));
-
-extern char *conf_standard_path PARAMS((void));
-extern int default_columns PARAMS((void));
-
-#endif	/* _GENERAL_H_ */
diff --git a/third_party/bash/getenv.c b/third_party/bash/getenv.c
deleted file mode 100644
index 1704a3a64..000000000
--- a/third_party/bash/getenv.c
+++ /dev/null
@@ -1,233 +0,0 @@
-/* getenv.c - get environment variable value from the shell's variable
-	      list. */
-
-/* Copyright (C) 1997-2002 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (CAN_REDEFINE_GETENV)
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include <errno.h>
-#include "shell.h"
-
-#ifndef errno
-extern int errno;
-#endif
-
-extern char **environ;
-
-/* We supply our own version of getenv () because we want library
-   routines to get the changed values of exported variables. */
-
-/* The NeXT C library has getenv () defined and used in the same file.
-   This screws our scheme.  However, Bash will run on the NeXT using
-   the C library getenv (), since right now the only environment variable
-   that we care about is HOME, and that is already defined.  */
-static char *last_tempenv_value = (char *)NULL;
-
-char *
-getenv (name)
-     const char *name;
-{
-  SHELL_VAR *var;
-
-  if (name == 0 || *name == '\0')
-    return ((char *)NULL);
-
-  var = find_tempenv_variable ((char *)name);
-  if (var)
-    {
-      FREE (last_tempenv_value);
-
-      last_tempenv_value = value_cell (var) ? savestring (value_cell (var)) : (char *)NULL;
-      return (last_tempenv_value);
-    }
-  else if (shell_variables)
-    {
-      var = find_variable ((char *)name);
-      if (var && exported_p (var))
-	return (value_cell (var));
-    }
-  else if (environ)
-    {
-      register int i, len;
-
-      /* In some cases, s5r3 invokes getenv() before main(); BSD systems
-	 using gprof also exhibit this behavior.  This means that
-	 shell_variables will be 0 when this is invoked.  We look up the
-	 variable in the real environment in that case. */
-
-      for (i = 0, len = strlen (name); environ[i]; i++)
-	{
-	  if ((STREQN (environ[i], name, len)) && (environ[i][len] == '='))
-	    return (environ[i] + len + 1);
-	}
-    }
-
-  return ((char *)NULL);
-}
-
-/* Some versions of Unix use _getenv instead. */
-char *
-_getenv (name)
-     const char *name;
-{
-  return (getenv (name));
-}
-
-/* SUSv3 says argument is a `char *'; BSD implementations disagree */
-int
-putenv (str)
-#ifndef HAVE_STD_PUTENV
-     const char *str;
-#else
-     char *str;
-#endif
-{
-  SHELL_VAR *var;
-  char *name, *value;
-  int offset;
-
-  if (str == 0 || *str == '\0')
-    {
-      errno = EINVAL;
-      return -1;
-    }
-
-  offset = assignment (str, 0);
-  if (str[offset] != '=')
-    {
-      errno = EINVAL;
-      return -1;
-    }
-  name = savestring (str);
-  name[offset] = 0;
-
-  value = name + offset + 1;
-
-  /* XXX - should we worry about readonly here? */
-  var = bind_variable (name, value, 0);
-  if (var == 0)
-    {
-      errno = EINVAL;
-      return -1;
-    }
-
-  VUNSETATTR (var, att_invisible);
-  VSETATTR (var, att_exported);
-
-  return 0;
-}
-
-#if 0
-int
-_putenv (name)
-#ifndef HAVE_STD_PUTENV
-     const char *name;
-#else
-     char *name;
-#endif
-{
-  return putenv (name);
-}
-#endif
-
-int
-setenv (name, value, rewrite)
-     const char *name;
-     const char *value;
-     int rewrite;
-{
-  SHELL_VAR *var;
-  char *v;
-
-  if (name == 0 || *name == '\0' || strchr (name, '=') != 0)
-    {
-      errno = EINVAL;
-      return -1;
-    }
-
-  var = 0;
-  v = (char *)value;	/* some compilers need explicit cast */
-  /* XXX - should we worry about readonly here? */
-  if (rewrite == 0)
-    var = find_variable (name);
-
-  if (var == 0)
-    var = bind_variable (name, v, 0);
-
-  if (var == 0)
-    return -1;
-
-  VUNSETATTR (var, att_invisible);
-  VSETATTR (var, att_exported);
-
-  return 0;
-}
-
-#if 0
-int
-_setenv (name, value, rewrite)
-     const char *name;
-     const char *value;
-     int rewrite;
-{
-  return setenv (name, value, rewrite);
-}
-#endif
-
-/* SUSv3 says unsetenv returns int; existing implementations (BSD) disagree. */
-
-#ifdef HAVE_STD_UNSETENV
-#define UNSETENV_RETURN(N)	return(N)
-#define UNSETENV_RETTYPE	int
-#else
-#define UNSETENV_RETURN(N)	return
-#define UNSETENV_RETTYPE	void
-#endif
-
-UNSETENV_RETTYPE
-unsetenv (name)
-     const char *name;
-{
-  if (name == 0 || *name == '\0' || strchr (name, '=') != 0)
-    {
-      errno = EINVAL;
-      UNSETENV_RETURN(-1);
-    }
-
-  /* XXX - should we just remove the export attribute here? */
-#if 1
-  unbind_variable (name);
-#else
-  SHELL_VAR *v;
-
-  v = find_variable (name);
-  if (v)
-    VUNSETATTR (v, att_exported);
-#endif
-
-  UNSETENV_RETURN(0);
-}
-#endif /* CAN_REDEFINE_GETENV */
diff --git a/third_party/bash/getopt.c b/third_party/bash/getopt.c
deleted file mode 100644
index 25f540cc5..000000000
--- a/third_party/bash/getopt.c
+++ /dev/null
@@ -1,355 +0,0 @@
-/* getopt.c - getopt for Bash.  Used by the getopt builtin. */
-
-/* Copyright (C) 1993-2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "memalloc.h"
-#include "bashintl.h"
-#include "shell.h"
-#include "getopt.h"
-
-/* For communication from `sh_getopt' to the caller.
-   When `sh_getopt' finds an option that takes an argument,
-   the argument value is returned here. */
-char *sh_optarg = 0;
-
-/* Index in ARGV of the next element to be scanned.
-   This is used for communication to and from the caller
-   and for communication between successive calls to `sh_getopt'.
-
-   On entry to `sh_getopt', zero means this is the first call; initialize.
-
-   When `sh_getopt' returns EOF, this is the index of the first of the
-   non-option elements that the caller should itself scan.
-
-   Otherwise, `sh_optind' communicates from one call to the next
-   how much of ARGV has been scanned so far.  */
-
-/* XXX 1003.2 says this must be 1 before any call.  */
-int sh_optind = 0;
-
-/* Index of the current argument. */
-static int sh_curopt;
-
-/* The next char to be scanned in the option-element
-   in which the last option character we returned was found.
-   This allows us to pick up the scan where we left off.
-
-   If this is zero, or a null string, it means resume the scan
-   by advancing to the next ARGV-element.  */
-
-static char *nextchar;
-static int sh_charindex;
-
-/* Callers store zero here to inhibit the error message
-   for unrecognized options.  */
-
-int sh_opterr = 1;
-
-/* Set to an option character which was unrecognized.
-   This must be initialized on some systems to avoid linking in the
-   system's own getopt implementation.  */
-
-int sh_optopt = '?';
-
-/* Set to 1 when we see an invalid option; public so getopts can reset it. */
-int sh_badopt = 0;
-
-/* Scan elements of ARGV (whose length is ARGC) for option characters
-   given in OPTSTRING.
-
-   If an element of ARGV starts with '-', and is not exactly "-" or "--",
-   then it is an option element.  The characters of this element
-   (aside from the initial '-') are option characters.  If `sh_getopt'
-   is called repeatedly, it returns successively each of the option characters
-   from each of the option elements.
-
-   If `sh_getopt' finds another option character, it returns that character,
-   updating `sh_optind' and `nextchar' so that the next call to `sh_getopt' can
-   resume the scan with the following option character or ARGV-element.
-
-   If there are no more option characters, `sh_getopt' returns `EOF'.
-   Then `sh_optind' is the index in ARGV of the first ARGV-element
-   that is not an option.
-
-   OPTSTRING is a string containing the legitimate option characters.
-   If an option character is seen that is not listed in OPTSTRING,
-   return '?' after printing an error message.  If you set `sh_opterr' to
-   zero, the error message is suppressed but we still return '?'.
-
-   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
-   so the following text in the same ARGV-element, or the text of the following
-   ARGV-element, is returned in `sh_optarg'. */
-
-/* 1003.2 specifies the format of this message.  */
-#define BADOPT(x)  fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], x)
-#define NEEDARG(x) fprintf (stderr, _("%s: option requires an argument -- %c\n"), argv[0], x)
-
-int
-sh_getopt (argc, argv, optstring)
-     int argc;
-     char *const *argv;
-     const char *optstring;
-{
-  char c, *temp;
-
-  sh_optarg = 0;
-
-  if (sh_optind >= argc || sh_optind < 0)	/* XXX was sh_optind > argc */
-    {
-      sh_optind = argc;
-      return (EOF);
-    }
-
-  /* Initialize the internal data when the first call is made.
-     Start processing options with ARGV-element 1 (since ARGV-element 0
-     is the program name); the sequence of previously skipped
-     non-option ARGV-elements is empty.  */
-
-  if (sh_optind == 0)
-    {
-      sh_optind = 1;
-      nextchar = (char *)NULL;
-    }
-
-  if (nextchar == 0 || *nextchar == '\0')
-    {
-      /* If we have done all the ARGV-elements, stop the scan. */
-      if (sh_optind >= argc)
-	return EOF;
-
-      temp = argv[sh_optind];
-
-      /* Special ARGV-element `--' means premature end of options.
-	 Skip it like a null option, and return EOF. */
-      if (temp[0] == '-' && temp[1] == '-' && temp[2] == '\0')
-	{
-	  sh_optind++;
-	  return EOF;
-	}
-
-      /* If we have come to a non-option, either stop the scan or describe
-	 it to the caller and pass it by.  This makes the pseudo-option
-	 `-' mean the end of options, but does not skip over it. */
-      if (temp[0] != '-' || temp[1] == '\0')
-	return EOF;
-
-      /* We have found another option-ARGV-element.
-	 Start decoding its characters.  */
-      nextchar = argv[sh_curopt = sh_optind] + 1;
-      sh_charindex = 1;
-    }
-
-  /* Look at and handle the next option-character.  */
-
-  c = *nextchar++; sh_charindex++;
-  temp = strchr (optstring, c);
-
-  sh_optopt = c;
-
-  /* Increment `sh_optind' when we start to process its last character.  */
-  if (nextchar == 0 || *nextchar == '\0')
-    {
-      sh_optind++;
-      nextchar = (char *)NULL;
-    }
-
-  if (sh_badopt = (temp == NULL || c == ':'))
-    {
-      if (sh_opterr)
-	BADOPT (c);
-
-      return '?';
-    }
-
-  if (temp[1] == ':')
-    {
-      if (nextchar && *nextchar)
-	{
-	  /* This is an option that requires an argument.  */
-	  sh_optarg = nextchar;
-	  /* If we end this ARGV-element by taking the rest as an arg,
-	     we must advance to the next element now.  */
-	  sh_optind++;
-	}
-      else if (sh_optind == argc)
-	{
-	  if (sh_opterr)
-	    NEEDARG (c);
-
-	  sh_optopt = c;
-	  sh_optarg = "";	/* Needed by getopts. */
-	  c = (optstring[0] == ':') ? ':' : '?';
-	}
-      else
-	/* We already incremented `sh_optind' once;
-	   increment it again when taking next ARGV-elt as argument.  */
-	sh_optarg = argv[sh_optind++];
-      nextchar = (char *)NULL;
-    }
-  return c;
-}
-
-void
-sh_getopt_restore_state (argv)
-     char **argv;
-{
-  if (nextchar)
-    nextchar = argv[sh_curopt] + sh_charindex;
-}
-
-sh_getopt_state_t *
-sh_getopt_alloc_istate ()
-{
-  sh_getopt_state_t *ret;
-
-  ret = (sh_getopt_state_t *)xmalloc (sizeof (sh_getopt_state_t));
-  return ret;
-}
-
-void
-sh_getopt_dispose_istate (gs)
-     sh_getopt_state_t *gs;
-{
-  free (gs);
-}
-
-sh_getopt_state_t *
-sh_getopt_save_istate ()
-{
-  sh_getopt_state_t *ret;
-
-  ret = sh_getopt_alloc_istate ();
-
-  ret->gs_optarg = sh_optarg;
-  ret->gs_optind = sh_optind;
-  ret->gs_curopt = sh_curopt;
-  ret->gs_nextchar = nextchar;		/* XXX */
-  ret->gs_charindex = sh_charindex;
-  ret->gs_flags = 0;			/* XXX for later use */
-
-  return ret;
-}
-
-void
-sh_getopt_restore_istate (state)
-     sh_getopt_state_t *state;
-{
-  sh_optarg = state->gs_optarg;
-  sh_optind = state->gs_optind;
-  sh_curopt = state->gs_curopt;
-  nextchar = state->gs_nextchar;	/* XXX - probably not usable */
-  sh_charindex = state->gs_charindex;
-
-  sh_getopt_dispose_istate (state);
-}
-
-#if 0
-void
-sh_getopt_debug_restore_state (argv)
-     char **argv;
-{
-  if (nextchar && nextchar != argv[sh_curopt] + sh_charindex)
-    {
-      itrace("sh_getopt_debug_restore_state: resetting nextchar");
-      nextchar = argv[sh_curopt] + sh_charindex;
-    }
-}
-#endif
- 
-#ifdef TEST
-
-/* Compile with -DTEST to make an executable for use in testing
-   the above definition of `sh_getopt'.  */
-
-int
-main (argc, argv)
-     int argc;
-     char **argv;
-{
-  int c;
-  int digit_sh_optind = 0;
-
-  while (1)
-    {
-      int this_option_sh_optind = sh_optind ? sh_optind : 1;
-
-      c = sh_getopt (argc, argv, "abc:d:0123456789");
-      if (c == EOF)
-	break;
-
-      switch (c)
-	{
-	case '0':
-	case '1':
-	case '2':
-	case '3':
-	case '4':
-	case '5':
-	case '6':
-	case '7':
-	case '8':
-	case '9':
-	  if (digit_sh_optind != 0 && digit_sh_optind != this_option_sh_optind)
-	    printf ("digits occur in two different argv-elements.\n");
-	  digit_sh_optind = this_option_sh_optind;
-	  printf ("option %c\n", c);
-	  break;
-
-	case 'a':
-	  printf ("option a\n");
-	  break;
-
-	case 'b':
-	  printf ("option b\n");
-	  break;
-
-	case 'c':
-	  printf ("option c with value `%s'\n", sh_optarg);
-	  break;
-
-	case '?':
-	  break;
-
-	default:
-	  printf ("?? sh_getopt returned character code 0%o ??\n", c);
-	}
-    }
-
-  if (sh_optind < argc)
-    {
-      printf ("non-option ARGV-elements: ");
-      while (sh_optind < argc)
-	printf ("%s ", argv[sh_optind++]);
-      printf ("\n");
-    }
-
-  exit (0);
-}
-
-#endif /* TEST */
diff --git a/third_party/bash/getopt.h b/third_party/bash/getopt.h
deleted file mode 100644
index fd9785975..000000000
--- a/third_party/bash/getopt.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/* getopt.h - declarations for getopt. */
-
-/* Copyright (C) 1989-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* XXX THIS HAS BEEN MODIFIED FOR INCORPORATION INTO BASH XXX */
-
-#ifndef _SH_GETOPT_H
-#define _SH_GETOPT_H 1
-
-#include "stdc.h"
-
-/* For communication from `getopt' to the caller.
-   When `getopt' finds an option that takes an argument,
-   the argument value is returned here.
-   Also, when `ordering' is RETURN_IN_ORDER,
-   each non-option ARGV-element is returned here.  */
-
-extern char *sh_optarg;
-
-/* Index in ARGV of the next element to be scanned.
-   This is used for communication to and from the caller
-   and for communication between successive calls to `getopt'.
-
-   On entry to `getopt', zero means this is the first call; initialize.
-
-   When `getopt' returns EOF, this is the index of the first of the
-   non-option elements that the caller should itself scan.
-
-   Otherwise, `sh_optind' communicates from one call to the next
-   how much of ARGV has been scanned so far.  */
-
-extern int sh_optind;
-
-/* Callers store zero here to inhibit the error message `getopt' prints
-   for unrecognized options.  */
-
-extern int sh_opterr;
-
-/* Set to an option character which was unrecognized.  */
-
-extern int sh_optopt;
-
-/* Set to 1 when an unrecognized option is encountered. */
-extern int sh_badopt;
-
-extern int sh_getopt PARAMS((int, char *const *, const char *));
-
-typedef struct sh_getopt_state
-{
-  char *gs_optarg;
-  int gs_optind;
-  int gs_curopt;
-  char *gs_nextchar;
-  int gs_charindex;
-  int gs_flags;
-} sh_getopt_state_t;
-
-extern void sh_getopt_restore_state PARAMS((char **));
-
-extern sh_getopt_state_t *sh_getopt_alloc_istate PARAMS((void));
-extern void sh_getopt_dispose_istate PARAMS((sh_getopt_state_t *));
-
-extern sh_getopt_state_t *sh_getopt_save_istate PARAMS((void));
-extern void sh_getopt_restore_istate PARAMS((sh_getopt_state_t *));
-
-#endif /* _SH_GETOPT_H */
diff --git a/third_party/bash/gettext.h b/third_party/bash/gettext.h
deleted file mode 100644
index 97a1f36d6..000000000
--- a/third_party/bash/gettext.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/* Convenience header for conditional use of GNU <libintl.h>.
-   Copyright (C) 1995-1998, 2000-2002, 2008,2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne-Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _LIBGETTEXT_H
-#define _LIBGETTEXT_H 1
-
-/* NLS can be disabled through the configure --disable-nls option.  */
-#if ENABLE_NLS
-
-/* Get declarations of GNU message catalog functions.  */
-# include <libintl.h>
-
-#else
-
-/* Solaris /usr/include/locale.h includes /usr/include/libintl.h, which
-   chokes if dcgettext is defined as a macro.  So include it now, to make
-   later inclusions of <locale.h> a NOP.  We don't include <libintl.h>
-   as well because people using "gettext.h" will not include <libintl.h>,
-   and also including <libintl.h> would fail on SunOS 4, whereas <locale.h>
-   is OK.  */
-#if defined(__sun)
-# include <locale.h>
-#endif
-
-/* Disabled NLS.
-   The casts to 'const char *' serve the purpose of producing warnings
-   for invalid uses of the value returned from these functions.
-   On pre-ANSI systems without 'const', the config.h file is supposed to
-   contain "#define const".  */
-# define gettext(Msgid) ((const char *) (Msgid))
-# define dgettext(Domainname, Msgid) ((const char *) (Msgid))
-# define dcgettext(Domainname, Msgid, Category) ((const char *) (Msgid))
-# define ngettext(Msgid1, Msgid2, N) \
-    ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
-# define dngettext(Domainname, Msgid1, Msgid2, N) \
-    ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
-# define dcngettext(Domainname, Msgid1, Msgid2, N, Category) \
-    ((N) == 1 ? (const char *) (Msgid1) : (const char *) (Msgid2))
-# define textdomain(Domainname) ((const char *) (Domainname))
-# define bindtextdomain(Domainname, Dirname) ((const char *) (Dirname))
-# define bind_textdomain_codeset(Domainname, Codeset) ((const char *) (Codeset))
-
-#endif
-
-/* A pseudo function call that serves as a marker for the automated
-   extraction of messages, but does not call gettext().  The run-time
-   translation is done at a different place in the code.
-   The argument, String, should be a literal string.  Concatenated strings
-   and other string expressions won't work.
-   The macro's expansion is not parenthesized, so that it is suitable as
-   initializer for static 'char[]' or 'const char[]' variables.  */
-#define gettext_noop(String) String
-
-#endif /* _LIBGETTEXT_H */
diff --git a/third_party/bash/gettimeofday.c b/third_party/bash/gettimeofday.c
deleted file mode 100644
index b654c1547..000000000
--- a/third_party/bash/gettimeofday.c
+++ /dev/null
@@ -1,35 +0,0 @@
-/* gettimeofday.c - gettimeofday replacement using time() */
-
-/* Copyright (C) 2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if !defined (HAVE_GETTIMEOFDAY)
-
-#include "posixtime.h"
-
-/* A version of gettimeofday that just sets tv_sec from time(3) */
-int
-gettimeofday (struct timeval *tv, void *tz)
-{
-  tv->tv_sec = (time_t) time ((time_t *)0);
-  tv->tv_usec = 0;
-  return 0;
-}
-#endif
diff --git a/third_party/bash/glob.c b/third_party/bash/glob.c
deleted file mode 100644
index fe80d41ec..000000000
--- a/third_party/bash/glob.c
+++ /dev/null
@@ -1,1609 +0,0 @@
-/* glob.c -- file-name wildcard pattern matching for Bash.
-
-   Copyright (C) 1985-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne-Again SHell.
-   
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* To whomever it may concern: I have never seen the code which most
-   Unix programs use to perform this function.  I wrote this from scratch
-   based on specifications for the pattern matching.  --RMS.  */
-
-#include "config.h"
-
-#if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
-  #pragma alloca
-#endif /* _AIX && RISC6000 && !__GNUC__ */
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "posixdir.h"
-#include "posixstat.h"
-#include "shmbutil.h"
-#include "xmalloc.h"
-
-#include "filecntl.h"
-#if !defined (F_OK)
-#  define F_OK 0
-#endif
-
-#include "stdc.h"
-#include "memalloc.h"
-
-#include <signal.h>
-
-#include "shell.h"
-#include "general.h"
-
-#include "glob.h"
-#include "strmatch.h"
-
-#if !defined (HAVE_BCOPY) && !defined (bcopy)
-#  define bcopy(s, d, n) ((void) memcpy ((d), (s), (n)))
-#endif /* !HAVE_BCOPY && !bcopy */
-
-#if !defined (NULL)
-#  if defined (__STDC__)
-#    define NULL ((void *) 0)
-#  else
-#    define NULL 0x0
-#  endif /* __STDC__ */
-#endif /* !NULL */
-
-#if !defined (FREE)
-#  define FREE(x)	if (x) free (x)
-#endif
-
-/* Don't try to alloca() more than this much memory for `struct globval'
-   in glob_vector() */
-#ifndef ALLOCA_MAX
-#  define ALLOCA_MAX	100000
-#endif
-
-struct globval
-  {
-    struct globval *next;
-    char *name;
-  };
-
-extern void throw_to_top_level PARAMS((void));
-extern int sh_eaccess PARAMS((const char *, int));
-extern char *sh_makepath PARAMS((const char *, const char *, int));
-extern int signal_is_pending PARAMS((int));
-extern void run_pending_traps PARAMS((void));
-
-extern int extended_glob;
-
-/* Global variable which controls whether or not * matches .*.
-   Non-zero means don't match .*.  */
-int noglob_dot_filenames = 1;
-
-/* Global variable which controls whether or not filename globbing
-   is done without regard to case. */
-int glob_ignore_case = 0;
-
-/* Global variable controlling whether globbing ever returns . or ..
-   regardless of the pattern. If set to 1, no glob pattern will ever
-   match `.' or `..'. Disabled by default. */
-int glob_always_skip_dot_and_dotdot = 1;
-
-/* Global variable to return to signify an error in globbing. */
-char *glob_error_return;
-
-static struct globval finddirs_error_return;
-
-/* Some forward declarations. */
-static int skipname PARAMS((char *, char *, int));
-#if HANDLE_MULTIBYTE
-static int mbskipname PARAMS((char *, char *, int));
-#endif
-void udequote_pathname PARAMS((char *));
-#if HANDLE_MULTIBYTE
-void wcdequote_pathname PARAMS((wchar_t *));
-static void wdequote_pathname PARAMS((char *));
-static void dequote_pathname PARAMS((char *));
-#else
-#  define dequote_pathname(p) udequote_pathname(p)
-#endif
-static int glob_testdir PARAMS((char *, int));
-static char **glob_dir_to_array PARAMS((char *, char **, int));
-
-/* Make sure these names continue to agree with what's in smatch.c */
-extern char *glob_patscan PARAMS((char *, char *, int));
-extern wchar_t *glob_patscan_wc PARAMS((wchar_t *, wchar_t *, int));
-
-/* And this from gmisc.c/gm_loop.c */
-extern int wextglob_pattern_p PARAMS((wchar_t *));
-
-extern char *glob_dirscan PARAMS((char *, int));
-
-/* Compile `glob_loop.inc' for single-byte characters. */
-#define GCHAR	unsigned char
-#define CHAR	char
-#define INT	int
-#define L(CS)	CS
-#define INTERNAL_GLOB_PATTERN_P internal_glob_pattern_p
-#include "glob_loop.inc"
-
-/* Compile `glob_loop.inc' again for multibyte characters. */
-#if HANDLE_MULTIBYTE
-
-#define GCHAR	wchar_t
-#define CHAR	wchar_t
-#define INT	wint_t
-#define L(CS)	L##CS
-#define INTERNAL_GLOB_PATTERN_P internal_glob_wpattern_p
-#include "glob_loop.inc"
-
-#endif /* HANDLE_MULTIBYTE */
-
-/* And now a function that calls either the single-byte or multibyte version
-   of internal_glob_pattern_p. */
-int
-glob_pattern_p (pattern)
-     const char *pattern;
-{
-#if HANDLE_MULTIBYTE
-  size_t n;
-  wchar_t *wpattern;
-  int r;
-
-  if (MB_CUR_MAX == 1 || mbsmbchar (pattern) == 0)
-    return (internal_glob_pattern_p ((unsigned char *)pattern));
-
-  /* Convert strings to wide chars, and call the multibyte version. */
-  n = xdupmbstowcs (&wpattern, NULL, pattern);
-  if (n == (size_t)-1)
-    /* Oops.  Invalid multibyte sequence.  Try it as single-byte sequence. */
-    return (internal_glob_pattern_p ((unsigned char *)pattern));
-
-  r = internal_glob_wpattern_p (wpattern);
-  free (wpattern);
-
-  return r;
-#else
-  return (internal_glob_pattern_p ((unsigned char *)pattern));
-#endif
-}
-
-#if EXTENDED_GLOB
-
-#if defined (HANDLE_MULTIBYTE)
-#  define XSKIPNAME(p, d, f)	mbskipname(p, d, f)
-#else
-#  define XSKIPNAME(p, d, f)	skipname(p, d, f)
-#endif
-
-/* Return 1 if all subpatterns in the extended globbing pattern PAT indicate
-   that the name should be skipped.  XXX - doesn't handle pattern negation,
-   not sure if it should */
-static int
-extglob_skipname (pat, dname, flags)
-     char *pat, *dname;
-     int flags;
-{
-  char *pp, *pe, *t, *se;
-  int n, r, negate, wild, nullpat, xflags;
-
-  negate = *pat == '!';
-  wild = *pat == '*' || *pat == '?';
-  pp = pat + 2;
-  se = pp + strlen (pp);		/* end of pattern string */
-  pe = glob_patscan (pp, se, 0);	/* end of extglob pattern */
-
-  /* if pe == 0, this is an invalid extglob pattern */
-  if (pe == 0)
-    return 0;
-
-  xflags = flags | ( negate ? GX_NEGATE : 0);
-
-  /* if pe != se we have more of the pattern at the end of the extglob
-     pattern. Check the easy case first ( */
-  if (pe == se && *pe == 0 && pe[-1] == ')' && (t = strchr (pp, '|')) == 0)
-    {
-      pe[-1] = '\0';
-      /* This is where we check whether the pattern is being negated and
-	 match all files beginning with `.' if the pattern begins with a
-	 literal `.'. */
-      r = XSKIPNAME (pp, dname, xflags); /*(*/
-      pe[-1] = ')';
-      return r;
-    }
-
-  /* Is the extglob pattern between the parens the null pattern?  The null
-     pattern can match nothing, so should we check any remaining portion of
-     the pattern? */
-  nullpat = pe >= (pat + 2) && pe[-2] == '(' && pe[-1] == ')';
-
-  /* check every subpattern */
-  while (t = glob_patscan (pp, pe, '|'))
-    {
-      /* If T == PE and *T == 0 (&& PE[-1] == RPAREN), we have hit the end
-	 of a pattern with no trailing characters. */
-      n = t[-1];	/* ( */
-      if (extglob_pattern_p (pp) && n == ')')		/* nested extglob? */
-	t[-1] = n;	/* no-op for now */
-      else
-	t[-1] = '\0';
-      r = XSKIPNAME (pp, dname, xflags);
-      t[-1] = n;
-      if (r == 0)	/* if any pattern says not skip, we don't skip */
-        return r;
-      pp = t;
-      if (pp == pe)
-	break;
-    }
-
-  /* glob_patscan might find end of string */
-  if (pp == se)
-    return r;
-
-  /* but if it doesn't then we didn't match a leading dot */
-  if (wild && *pe)	/* if we can match zero instances, check further */
-    return (XSKIPNAME (pe, dname, flags));
-
-  return 1;
-}
-#endif
-
-/* Return 1 if DNAME should be skipped according to PAT.  Mostly concerned
-   with matching leading `.'. */
-static int
-skipname (pat, dname, flags)
-     char *pat;
-     char *dname;
-     int flags;
-{
-  int i;
-
-#if EXTENDED_GLOB
-  if (extglob_pattern_p (pat))		/* XXX */
-    return (extglob_skipname (pat, dname, flags));
-#endif
-
-  if (glob_always_skip_dot_and_dotdot && DOT_OR_DOTDOT (dname))
-    return 1;
-
-  /* If a leading dot need not be explicitly matched, and the pattern
-     doesn't start with a `.', don't match `.' or `..' */
-  if (noglob_dot_filenames == 0 && pat[0] != '.' &&
-	(pat[0] != '\\' || pat[1] != '.') &&
-	DOT_OR_DOTDOT (dname))
-    return 1;
-
-#if 0
-  /* This is where we check whether the pattern is being negated and
-     match all files beginning with `.' if the pattern begins with a
-     literal `.'. This is the negation of the next clause. */
-  else if ((flags & GX_NEGATE) && noglob_dot_filenames == 0 &&
-	dname[0] == '.' &&
-	(pat[0] == '.' || (pat[0] == '\\' && pat[1] == '.')))
-    return 0;
-#endif
-
-  /* If a dot must be explicitly matched, check to see if they do. */
-  else if (noglob_dot_filenames && dname[0] == '.' &&
- 	   pat[0] != '.' && (pat[0] != '\\' || pat[1] != '.'))
-    return 1;
-
-  return 0;
-}
-
-#if HANDLE_MULTIBYTE
-
-static int
-wskipname (pat, dname, flags)
-     wchar_t *pat, *dname;
-     int flags;
-{
-  int i;
-
-  if (glob_always_skip_dot_and_dotdot && WDOT_OR_DOTDOT (dname))
-    return 1;
-
-  /* If a leading dot need not be explicitly matched, and the
-     pattern doesn't start with a `.', don't match `.' or `..' */
-  if (noglob_dot_filenames == 0 && pat[0] != L'.' &&
-	(pat[0] != L'\\' || pat[1] != L'.') &&
-	WDOT_OR_DOTDOT (dname))
-    return 1;
-
-#if 0
-  /* This is where we check whether the pattern is being negated and
-     match all files beginning with `.' if the pattern begins with a
-     literal `.'. This is the negation of the next clause. */
-  else if ((flags & GX_NEGATE) && noglob_dot_filenames == 0 &&
-	dname[0] == L'.' &&
-	(pat[0] == L'.' || (pat[0] == L'\\' && pat[1] == L'.')))
-    return 0;
-#endif
-
-  /* If a leading dot must be explicitly matched, check to see if the
-     pattern and dirname both have one. */
-  else if (noglob_dot_filenames && dname[0] == L'.' &&
-	pat[0] != L'.' && (pat[0] != L'\\' || pat[1] != L'.'))
-    return 1;
-
-  return 0;
-}
-
-static int
-wextglob_skipname (pat, dname, flags)
-     wchar_t *pat, *dname;
-     int flags;
-{
-#if EXTENDED_GLOB
-  wchar_t *pp, *pe, *t, *se, n;
-  int r, negate, wild, nullpat, xflags;
-
-  negate = *pat == L'!';
-  wild = *pat == L'*' || *pat == L'?';
-  pp = pat + 2;
-  se = pp + wcslen (pp);
-  pe = glob_patscan_wc (pp, se, 0);
-
-  /* if pe == 0, this is an invalid extglob pattern */
-  if (pe == 0)
-    return 0;
-
-  xflags = flags | ( negate ? GX_NEGATE : 0);
-
-  /* if pe != se we have more of the pattern at the end of the extglob
-     pattern. Check the easy case first ( */
-  if (pe == se && *pe == L'\0' && pe[-1] == L')' && (t = wcschr (pp, L'|')) == 0)
-    {
-      pe[-1] = L'\0';
-      r = wskipname (pp, dname, xflags); /*(*/
-      pe[-1] = L')';
-      return r;
-    }
-
-  /* Is the extglob pattern between the parens the null pattern?  The null
-     pattern can match nothing, so should we check any remaining portion of
-     the pattern? */
-  nullpat = pe >= (pat + 2) && pe[-2] == L'(' && pe[-1] == L')';
-
-  /* check every subpattern */
-  while (t = glob_patscan_wc (pp, pe, '|'))
-    {
-      n = t[-1];	/* ( */
-      if (wextglob_pattern_p (pp) && n == L')')		/* nested extglob? */
-	t[-1] = n;	/* no-op for now */
-      else
-	t[-1] = L'\0';
-      r = wskipname (pp, dname, xflags);
-      t[-1] = n;
-      if (r == 0)
-	return 0;
-      pp = t;
-      if (pp == pe)
-	break;
-    }
-
-  /* glob_patscan_wc might find end of string */
-  if (pp == se)
-    return r;
-
-  /* but if it doesn't then we didn't match a leading dot */
-  if (wild && *pe != L'\0')
-    return (wskipname (pe, dname, flags));
-
-  return 1;
-#else
-  return (wskipname (pat, dname, flags));
-#endif
-}
-
-/* Return 1 if DNAME should be skipped according to PAT.  Handles multibyte
-   characters in PAT and DNAME.  Mostly concerned with matching leading `.'. */
-static int
-mbskipname (pat, dname, flags)
-     char *pat, *dname;
-     int flags;
-{
-  int ret, ext;
-  wchar_t *pat_wc, *dn_wc;
-  size_t pat_n, dn_n;
-
-  if (mbsmbchar (dname) == 0 && mbsmbchar (pat) == 0)
-    return (skipname (pat, dname, flags));
-
-  ext = 0;
-#if EXTENDED_GLOB
-  ext = extglob_pattern_p (pat);
-#endif
-
-  pat_wc = dn_wc = (wchar_t *)NULL;
-
-  pat_n = xdupmbstowcs (&pat_wc, NULL, pat);
-  if (pat_n != (size_t)-1)
-    dn_n = xdupmbstowcs (&dn_wc, NULL, dname);
-
-  ret = 0;
-  if (pat_n != (size_t)-1 && dn_n !=(size_t)-1)
-    ret = ext ? wextglob_skipname (pat_wc, dn_wc, flags) : wskipname (pat_wc, dn_wc, flags);
-  else
-    ret = skipname (pat, dname, flags);
-
-  FREE (pat_wc);
-  FREE (dn_wc);
-
-  return ret;
-}
-#endif /* HANDLE_MULTIBYTE */
-
-/* Remove backslashes quoting characters in PATHNAME by modifying PATHNAME. */
-void
-udequote_pathname (pathname)
-     char *pathname;
-{
-  register int i, j;
-
-  for (i = j = 0; pathname && pathname[i]; )
-    {
-      if (pathname[i] == '\\')
-	i++;
-
-      pathname[j++] = pathname[i++];
-
-      if (pathname[i - 1] == 0)
-	break;
-    }
-  if (pathname)
-    pathname[j] = '\0';
-}
-
-#if HANDLE_MULTIBYTE
-/* Remove backslashes quoting characters in PATHNAME by modifying PATHNAME. */
-void
-wcdequote_pathname (wpathname)
-     wchar_t *wpathname;
-{
-  int i, j;
-
-  for (i = j = 0; wpathname && wpathname[i]; )
-    {
-      if (wpathname[i] == L'\\')
-	i++;
-
-      wpathname[j++] = wpathname[i++];
-
-      if (wpathname[i - 1] == L'\0')
-	break;
-    }
-  if (wpathname)
-    wpathname[j] = L'\0';
-}
-
-static void
-wdequote_pathname (pathname)
-     char *pathname;
-{
-  mbstate_t ps;
-  size_t len, n;
-  wchar_t *wpathname;
-  int i, j;
-  wchar_t *orig_wpathname;
-
-  if (mbsmbchar (pathname) == 0)
-    {
-      udequote_pathname (pathname);
-      return;
-    }
-
-  len = strlen (pathname);
-  /* Convert the strings into wide characters.  */
-  n = xdupmbstowcs (&wpathname, NULL, pathname);
-  if (n == (size_t) -1)
-    {
-      /* Something wrong.  Fall back to single-byte */
-      udequote_pathname (pathname);
-      return;
-    }
-  orig_wpathname = wpathname;
-
-  wcdequote_pathname (wpathname);
-
-  /* Convert the wide character string into unibyte character set. */
-  memset (&ps, '\0', sizeof(mbstate_t));
-  n = wcsrtombs(pathname, (const wchar_t **)&wpathname, len, &ps);
-  if (n == (size_t)-1 || (wpathname && *wpathname != 0))	/* what? now you tell me? */
-    {
-      wpathname = orig_wpathname;
-      memset (&ps, '\0', sizeof(mbstate_t));
-      n = xwcsrtombs (pathname, (const wchar_t **)&wpathname, len, &ps);
-    }
-  pathname[len] = '\0';
-
-  /* Can't just free wpathname here; wcsrtombs changes it in many cases. */
-  free (orig_wpathname);
-}
-
-static void
-dequote_pathname (pathname)
-     char *pathname;
-{
-  if (MB_CUR_MAX > 1)
-    wdequote_pathname (pathname);
-  else
-    udequote_pathname (pathname);
-}
-#endif /* HANDLE_MULTIBYTE */
-
-/* Test whether NAME exists. */
-
-#if defined (HAVE_LSTAT)
-#  define GLOB_TESTNAME(name)  (lstat (name, &finfo))
-#else /* !HAVE_LSTAT */
-#  if !defined (AFS)
-#    define GLOB_TESTNAME(name)  (sh_eaccess (name, F_OK))
-#  else /* AFS */
-#    define GLOB_TESTNAME(name)  (access (name, F_OK))
-#  endif /* AFS */
-#endif /* !HAVE_LSTAT */
-
-/* Return 0 if DIR is a directory, -2 if DIR is a symlink,  -1 otherwise. */
-static int
-glob_testdir (dir, flags)
-     char *dir;
-     int flags;
-{
-  struct stat finfo;
-  int r;
-
-/*itrace("glob_testdir: testing %s" flags = %d, dir, flags);*/
-#if defined (HAVE_LSTAT)
-  r = (flags & GX_ALLDIRS) ? lstat (dir, &finfo) : stat (dir, &finfo);
-#else
-  r = stat (dir, &finfo);
-#endif
-  if (r < 0)
-    return (-1);
-
-#if defined (S_ISLNK)
-  if (S_ISLNK (finfo.st_mode))
-    return (-2);
-#endif
-
-  if (S_ISDIR (finfo.st_mode) == 0)
-    return (-1);
-
-  return (0);
-}
-
-/* Recursively scan SDIR for directories matching PAT (PAT is always `**').
-   FLAGS is simply passed down to the recursive call to glob_vector.  Returns
-   a list of matching directory names.  EP, if non-null, is set to the last
-   element of the returned list.  NP, if non-null, is set to the number of
-   directories in the returned list.  These two variables exist for the
-   convenience of the caller (always glob_vector). */
-static struct globval *
-finddirs (pat, sdir, flags, ep, np)
-     char *pat;
-     char *sdir;
-     int flags;
-     struct globval **ep;
-     int *np;
-{
-  char **r, *n;
-  int ndirs;
-  struct globval *ret, *e, *g;
-
-/*itrace("finddirs: pat = `%s' sdir = `%s' flags = 0x%x", pat, sdir, flags);*/
-  e = ret = 0;
-  r = glob_vector (pat, sdir, flags);
-  if (r == 0 || r[0] == 0)
-    {
-      if (np)
-	*np = 0;
-      if (ep)
-        *ep = 0;
-      if (r && r != &glob_error_return)
-	free (r);
-      return (struct globval *)0;
-    }
-  for (ndirs = 0; r[ndirs] != 0; ndirs++)
-    {
-      g = (struct globval *) malloc (sizeof (struct globval));
-      if (g == 0)
-	{
-	  while (ret)		/* free list built so far */
-	    {
-	      g = ret->next;
-	      free (ret);
-	      ret = g;
-	    }
-
-	  free (r);
-	  if (np)
-	    *np = 0;
-	  if (ep)
-	    *ep = 0;
-	  return (&finddirs_error_return);
-	}
-      if (e == 0)
-	e = g;
-
-      g->next = ret;
-      ret = g;
-
-      g->name = r[ndirs];
-    }
-
-  free (r);
-  if (ep)
-    *ep = e;
-  if (np)
-    *np = ndirs;
-
-  return ret;
-}
-     	
-/* Return a vector of names of files in directory DIR
-   whose names match glob pattern PAT.
-   The names are not in any particular order.
-   Wildcards at the beginning of PAT do not match an initial period.
-
-   The vector is terminated by an element that is a null pointer.
-
-   To free the space allocated, first free the vector's elements,
-   then free the vector.
-
-   Return 0 if cannot get enough memory to hold the pointer
-   and the names.
-
-   Return -1 if cannot access directory DIR.
-   Look in errno for more information.  */
-
-char **
-glob_vector (pat, dir, flags)
-     char *pat;
-     char *dir;
-     int flags;
-{
-  DIR *d;
-  register struct dirent *dp;
-  struct globval *lastlink, *e, *dirlist;
-  register struct globval *nextlink;
-  register char *nextname, *npat, *subdir;
-  unsigned int count;
-  int lose, skip, ndirs, isdir, sdlen, add_current, patlen;
-  register char **name_vector;
-  register unsigned int i;
-  int mflags;		/* Flags passed to strmatch (). */
-  int pflags;		/* flags passed to sh_makepath () */
-  int hasglob;		/* return value from glob_pattern_p */
-  int nalloca;
-  struct globval *firstmalloc, *tmplink;
-  char *convfn;
-
-  lastlink = 0;
-  count = lose = skip = add_current = 0;
-
-  firstmalloc = 0;
-  nalloca = 0;
-
-  name_vector = NULL;
-
-/*itrace("glob_vector: pat = `%s' dir = `%s' flags = 0x%x", pat, dir, flags);*/
-  /* If PAT is empty, skip the loop, but return one (empty) filename. */
-  if (pat == 0 || *pat == '\0')
-    {
-      if (glob_testdir (dir, 0) < 0)
-	return ((char **) &glob_error_return);
-
-      nextlink = (struct globval *)alloca (sizeof (struct globval));
-      if (nextlink == NULL)
-	return ((char **) NULL);
-
-      nextlink->next = (struct globval *)0;
-      nextname = (char *) malloc (1);
-      if (nextname == 0)
-	lose = 1;
-      else
-	{
-	  lastlink = nextlink;
-	  nextlink->name = nextname;
-	  nextname[0] = '\0';
-	  count = 1;
-	}
-
-      skip = 1;
-    }
-
-  patlen = (pat && *pat) ? strlen (pat) : 0;
-
-  /* If the filename pattern (PAT) does not contain any globbing characters,
-     or contains a pattern with only backslash escapes (hasglob == 2),
-     we can dispense with reading the directory, and just see if there is
-     a filename `DIR/PAT'.  If there is, and we can access it, just make the
-     vector to return and bail immediately. */
-  hasglob = 0;
-  if (skip == 0 && ((hasglob = glob_pattern_p (pat)) == 0 || hasglob == 2))
-    {
-      int dirlen;
-      struct stat finfo;
-
-      if (glob_testdir (dir, 0) < 0)
-	return ((char **) &glob_error_return);
-
-      dirlen = strlen (dir);
-      nextname = (char *)malloc (dirlen + patlen + 2);
-      npat = (char *)malloc (patlen + 1);
-      if (nextname == 0 || npat == 0)
-	{
-	  FREE (nextname);
-	  FREE (npat);
-	  lose = 1;
-	}
-      else
-	{
-	  strcpy (npat, pat);
-	  dequote_pathname (npat);
-
-	  strcpy (nextname, dir);
-	  nextname[dirlen++] = '/';
-	  strcpy (nextname + dirlen, npat);
-
-	  if (GLOB_TESTNAME (nextname) >= 0)
-	    {
-	      free (nextname);
-	      nextlink = (struct globval *)alloca (sizeof (struct globval));
-	      if (nextlink)
-		{
-		  nextlink->next = (struct globval *)0;
-		  lastlink = nextlink;
-		  nextlink->name = npat;
-		  count = 1;
-		}
-	      else
-		{
-		  free (npat);
-		  lose = 1;
-		}
-	    }
-	  else
-	    {
-	      free (nextname);
-	      free (npat);
-	    }
-	}
-
-      skip = 1;
-    }
-
-  if (skip == 0)
-    {
-      /* Open the directory, punting immediately if we cannot.  If opendir
-	 is not robust (i.e., it opens non-directories successfully), test
-	 that DIR is a directory and punt if it's not. */
-#if defined (OPENDIR_NOT_ROBUST)
-      if (glob_testdir (dir, 0) < 0)
-	return ((char **) &glob_error_return);
-#endif
-
-      d = opendir (dir);
-      if (d == NULL)
-	return ((char **) &glob_error_return);
-
-      /* Compute the flags that will be passed to strmatch().  We don't
-	 need to do this every time through the loop. */
-      mflags = (noglob_dot_filenames ? FNM_PERIOD : FNM_DOTDOT) | FNM_PATHNAME;
-
-#ifdef FNM_CASEFOLD
-      if (glob_ignore_case)
-	mflags |= FNM_CASEFOLD;
-#endif
-
-      if (extended_glob)
-	mflags |= FNM_EXTMATCH;
-
-      add_current = ((flags & (GX_ALLDIRS|GX_ADDCURDIR)) == (GX_ALLDIRS|GX_ADDCURDIR));
-
-      /* Scan the directory, finding all names that match	 For each name that matches, allocate a struct globval
-	 on the stack and store the name in it.
-	 Chain those structs together; lastlink is the front of the chain.  */
-      while (1)
-	{
-	  /* Make globbing interruptible in the shell. */
-	  if (interrupt_state || terminating_signal)
-	    {
-	      lose = 1;
-	      break;
-	    }
-	  else if (signal_is_pending (SIGINT))	/* XXX - make SIGINT traps responsive */
-	    {
-	      lose = 1;
-	      break;
-	    }
-
-	  dp = readdir (d);
-	  if (dp == NULL)
-	    break;
-
-	  /* If this directory entry is not to be used, try again. */
-	  if (REAL_DIR_ENTRY (dp) == 0)
-	    continue;
-
-#if 0
-	  if (dp->d_name == 0 || *dp->d_name == 0)
-	    continue;
-#endif
-
-#if HANDLE_MULTIBYTE
-	  if (MB_CUR_MAX > 1 && mbskipname (pat, dp->d_name, flags))
-	    continue;
-	  else
-#endif
-	  if (skipname (pat, dp->d_name, flags))
-	    continue;
-
-	  /* If we're only interested in directories, don't bother with files */
-	  if (flags & (GX_MATCHDIRS|GX_ALLDIRS))
-	    {
-	      pflags = (flags & GX_ALLDIRS) ? MP_RMDOT : 0;
-	      if (flags & GX_NULLDIR)
-		pflags |= MP_IGNDOT;
-	      subdir = sh_makepath (dir, dp->d_name, pflags);
-	      isdir = glob_testdir (subdir, flags);
-	      if (isdir < 0 && (flags & GX_MATCHDIRS))
-		{
-		  free (subdir);
-		  continue;
-		}
-	    }
-
-	  if (flags & GX_ALLDIRS)
-	    {
-	      if (isdir == 0)
-		{
-		  dirlist = finddirs (pat, subdir, (flags & ~GX_ADDCURDIR), &e, &ndirs);
-		  if (dirlist == &finddirs_error_return)
-		    {
-		      free (subdir);
-		      lose = 1;
-		      break;
-		    }
-		  if (ndirs)		/* add recursive directories to list */
-		    {
-		      if (firstmalloc == 0)
-		        firstmalloc = e;
-		      e->next = lastlink;
-		      lastlink = dirlist;
-		      count += ndirs;
-		    }
-		}
-
-	      /* XXX - should we even add this if it's not a directory? */
-	      nextlink = (struct globval *) malloc (sizeof (struct globval));
-	      if (firstmalloc == 0)
-		firstmalloc = nextlink;
-	      sdlen = strlen (subdir);
-	      nextname = (char *) malloc (sdlen + 1);
-	      if (nextlink == 0 || nextname == 0)
-		{
-		  if (firstmalloc && firstmalloc == nextlink)
-		    firstmalloc = 0;
-		  /* If we reset FIRSTMALLOC we can free this here. */
-		  FREE (nextlink);
-		  FREE (nextname);
-		  free (subdir);
-		  lose = 1;
-		  break;
-		}
-	      nextlink->next = lastlink;
-	      lastlink = nextlink;
-	      nextlink->name = nextname;
-	      bcopy (subdir, nextname, sdlen + 1);
-	      free (subdir);
-	      ++count;
-	      continue;
-	    }
-	  else if (flags & GX_MATCHDIRS)
-	    free (subdir);
-
-	  convfn = fnx_fromfs (dp->d_name, D_NAMLEN (dp));
-	  if (strmatch (pat, convfn, mflags) != FNM_NOMATCH)
-	    {
-	      if (nalloca < ALLOCA_MAX)
-		{
-		  nextlink = (struct globval *) alloca (sizeof (struct globval));
-		  nalloca += sizeof (struct globval);
-		}
-	      else
-		{
-		  nextlink = (struct globval *) malloc (sizeof (struct globval));
-		  if (firstmalloc == 0)
-		    firstmalloc = nextlink;
-		}
-
-	      nextname = (char *) malloc (D_NAMLEN (dp) + 1);
-	      if (nextlink == 0 || nextname == 0)
-		{
-		  /* We free NEXTLINK here, since it won't be added to the
-		     LASTLINK chain. If we used malloc, and it returned non-
-		     NULL, firstmalloc will be set to something valid. If it's
-		     NEXTLINK, reset it before we free NEXTLINK to avoid
-		     duplicate frees. If not, it will be taken care of by the
-		     loop below with TMPLINK. */
-		  if (firstmalloc)
-		    {
-		      if (firstmalloc == nextlink)
-			firstmalloc = 0;
-		      FREE (nextlink);
-		    }
-		  FREE (nextname);
-		  lose = 1;
-		  break;
-		}
-	      nextlink->next = lastlink;
-	      lastlink = nextlink;
-	      nextlink->name = nextname;
-	      bcopy (dp->d_name, nextname, D_NAMLEN (dp) + 1);
-	      ++count;
-	    }
-	}
-
-      (void) closedir (d);
-    }
-
-  /* compat: if GX_ADDCURDIR, add the passed directory also.  Add an empty
-     directory name as a placeholder if GX_NULLDIR (in which case the passed
-     directory name is "."). */
-  if (add_current && lose == 0)
-    {
-      sdlen = strlen (dir);
-      nextname = (char *)malloc (sdlen + 1);
-      nextlink = (struct globval *) malloc (sizeof (struct globval));
-      if (nextlink == 0 || nextname == 0)
-	{
-	  FREE (nextlink);
-	  FREE (nextname);
-	  lose = 1;
-	}
-      else
-	{
-	  nextlink->name = nextname;
-	  nextlink->next = lastlink;
-	  lastlink = nextlink;
-	  if (flags & GX_NULLDIR)
-	    nextname[0] = '\0';
-	  else
-	    bcopy (dir, nextname, sdlen + 1);
-	  ++count;
-	}
-    }
-
-  if (lose == 0)
-    {
-      name_vector = (char **) malloc ((count + 1) * sizeof (char *));
-      lose |= name_vector == NULL;
-    }
-
-  /* Have we run out of memory or been interrupted? */
-  if (lose)
-    {
-      tmplink = 0;
-
-      /* Here free the strings we have got.  */
-      while (lastlink)
-	{
-	  /* Since we build the list in reverse order, the first N entries
-	     will be allocated with malloc, if firstmalloc is set, from
-	     lastlink to firstmalloc. */
-	  if (firstmalloc)
-	    {
-	      if (lastlink == firstmalloc)
-		firstmalloc = 0;
-	      tmplink = lastlink;
-	    }
-	  else
-	    tmplink = 0;
-	  free (lastlink->name);
-	  lastlink = lastlink->next;
-	  FREE (tmplink);
-	}
-
-      /* Don't call QUIT; here; let higher layers deal with it. */
-
-      return ((char **)NULL);
-    }
-
-  /* Copy the name pointers from the linked list into the vector.  */
-  for (tmplink = lastlink, i = 0; i < count; ++i)
-    {
-      name_vector[i] = tmplink->name;
-      tmplink = tmplink->next;
-    }
-
-  name_vector[count] = NULL;
-
-  /* If we allocated some of the struct globvals, free them now. */
-  if (firstmalloc)
-    {
-      tmplink = 0;
-      while (lastlink)
-	{
-	  tmplink = lastlink;
-	  if (lastlink == firstmalloc)
-	    lastlink = firstmalloc = 0;
-	  else
-	    lastlink = lastlink->next;
-	  free (tmplink);
-	}
-    }
-
-  return (name_vector);
-}
-
-/* Return a new array which is the concatenation of each string in ARRAY
-   to DIR.  This function expects you to pass in an allocated ARRAY, and
-   it takes care of free()ing that array.  Thus, you might think of this
-   function as side-effecting ARRAY.  This should handle GX_MARKDIRS. */
-static char **
-glob_dir_to_array (dir, array, flags)
-     char *dir, **array;
-     int flags;
-{
-  register unsigned int i, l;
-  int add_slash;
-  char **result, *new;
-  struct stat sb;
-
-  l = strlen (dir);
-  if (l == 0)
-    {
-      if (flags & GX_MARKDIRS)
-	for (i = 0; array[i]; i++)
-	  {
-	    if ((stat (array[i], &sb) == 0) && S_ISDIR (sb.st_mode))
-	      {
-		l = strlen (array[i]);
-		new = (char *)realloc (array[i], l + 2);
-		if (new == 0)
-		  return NULL;
-		new[l] = '/';
-		new[l+1] = '\0';
-		array[i] = new;
-	      }
-	  }
-      return (array);
-    }
-
-  add_slash = dir[l - 1] != '/';
-
-  i = 0;
-  while (array[i] != NULL)
-    ++i;
-
-  result = (char **) malloc ((i + 1) * sizeof (char *));
-  if (result == NULL)
-    return (NULL);
-
-  for (i = 0; array[i] != NULL; i++)
-    {
-      /* 3 == 1 for NUL, 1 for slash at end of DIR, 1 for GX_MARKDIRS */
-      result[i] = (char *) malloc (l + strlen (array[i]) + 3);
-
-      if (result[i] == NULL)
-	{
-	  int ind;
-	  for (ind = 0; ind < i; ind++)
-	    free (result[ind]);
-	  free (result);
-	  return (NULL);
-	}
-
-      strcpy (result[i], dir);
-      if (add_slash)
-	result[i][l] = '/';
-      if (array[i][0])
-	{
-	  strcpy (result[i] + l + add_slash, array[i]);
-	  if (flags & GX_MARKDIRS)
-	    {
-	      if ((stat (result[i], &sb) == 0) && S_ISDIR (sb.st_mode))
-		{
-		  size_t rlen;
-		  rlen = strlen (result[i]);
-		  result[i][rlen] = '/';
-		  result[i][rlen+1] = '\0';
-		}
-	    }
-	}
-      else
-        result[i][l+add_slash] = '\0';
-    }
-  result[i] = NULL;
-
-  /* Free the input array.  */
-  for (i = 0; array[i] != NULL; i++)
-    free (array[i]);
-  free ((char *) array);
-
-  return (result);
-}
-
-/* Do globbing on PATHNAME.  Return an array of pathnames that match,
-   marking the end of the array with a null-pointer as an element.
-   If no pathnames match, then the array is empty (first element is null).
-   If there isn't enough memory, then return NULL.
-   If a file system error occurs, return -1; `errno' has the error code.  */
-char **
-glob_filename (pathname, flags)
-     char *pathname;
-     int flags;
-{
-  char **result, **new_result;
-  unsigned int result_size;
-  char *directory_name, *filename, *dname, *fn;
-  unsigned int directory_len;
-  int free_dirname;			/* flag */
-  int dflags, hasglob;
-
-  result = (char **) malloc (sizeof (char *));
-  result_size = 1;
-  if (result == NULL)
-    return (NULL);
-
-  result[0] = NULL;
-
-  directory_name = NULL;
-
-  /* Find the filename.  */
-  filename = strrchr (pathname, '/');
-#if defined (EXTENDED_GLOB)
-  if (filename && extended_glob)
-    {
-      fn = glob_dirscan (pathname, '/');
-#if DEBUG_MATCHING
-      if (fn != filename)
-	fprintf (stderr, "glob_filename: glob_dirscan: fn (%s) != filename (%s)\n", fn ? fn : "(null)", filename);
-#endif
-      filename = fn;
-    }
-#endif
-
-  if (filename == NULL)
-    {
-      filename = pathname;
-      directory_name = "";
-      directory_len = 0;
-      free_dirname = 0;
-    }
-  else
-    {
-      directory_len = (filename - pathname) + 1;
-      directory_name = (char *) malloc (directory_len + 1);
-
-      if (directory_name == 0)		/* allocation failed? */
-	{
-	  free (result);
-	  return (NULL);
-	}
-
-      bcopy (pathname, directory_name, directory_len);
-      directory_name[directory_len] = '\0';
-      ++filename;
-      free_dirname = 1;
-    }
-
-  hasglob = 0;
-  /* If directory_name contains globbing characters, then we
-     have to expand the previous levels.  Just recurse.
-     If glob_pattern_p returns != [0,1] we have a pattern that has backslash
-     quotes but no unquoted glob pattern characters. We dequote it below. */
-  if (directory_len > 0 && (hasglob = glob_pattern_p (directory_name)) == 1)
-    {
-      char **directories, *d, *p;
-      register unsigned int i;
-      int all_starstar, last_starstar;
-
-      all_starstar = last_starstar = 0;
-      d = directory_name;
-      dflags = flags & ~GX_MARKDIRS;
-      /* Collapse a sequence of ** patterns separated by one or more slashes
-	 to a single ** terminated by a slash or NUL */
-      if ((flags & GX_GLOBSTAR) && d[0] == '*' && d[1] == '*' && (d[2] == '/' || d[2] == '\0'))
-	{
-	  p = d;
-	  while (d[0] == '*' && d[1] == '*' && (d[2] == '/' || d[2] == '\0'))
-	    {
-	      p = d;
-	      if (d[2])
-		{
-		  d += 3;
-		  while (*d == '/')
-		    d++;
-		  if (*d == 0)
-		    break;
-		}
-	    }
-	  if (*d == 0)
-	    all_starstar = 1;
-	  d = p;
-	  dflags |= GX_ALLDIRS|GX_ADDCURDIR;
-	  directory_len = strlen (d);
-	}
-
-      /* If there is a non [star][star]/ component in directory_name, we
-	 still need to collapse trailing sequences of [star][star]/ into
-	 a single one and note that the directory name ends with [star][star],
-	 so we can compensate if filename is [star][star] */
-      if ((flags & GX_GLOBSTAR) && all_starstar == 0)
-	{
-	  int dl, prev;
-	  prev = dl = directory_len;
-	  while (dl >= 4 && d[dl - 1] == '/' &&
-			   d[dl - 2] == '*' &&
-			   d[dl - 3] == '*' &&
-			   d[dl - 4] == '/')
-	    prev = dl, dl -= 3;
-	  if (dl != directory_len)
-	    last_starstar = 1;
-	  directory_len = prev;
-	}
-
-      /* If the directory name ends in [star][star]/ but the filename is
-	 [star][star], just remove the final [star][star] from the directory
-	 so we don't have to scan everything twice. */
-      if (last_starstar && directory_len > 4 &&
-	    filename[0] == '*' && filename[1] == '*' && filename[2] == 0)
-	{
-	  directory_len -= 3;
-	}
-
-      if (d[directory_len - 1] == '/')
-	d[directory_len - 1] = '\0';
-
-      directories = glob_filename (d, dflags|GX_RECURSE);
-
-      if (free_dirname)
-	{
-	  free (directory_name);
-	  directory_name = NULL;
-	}
-
-      if (directories == NULL)
-	goto memory_error;
-      else if (directories == (char **)&glob_error_return)
-	{
-	  free ((char *) result);
-	  return ((char **) &glob_error_return);
-	}
-      else if (*directories == NULL)
-	{
-	  free ((char *) directories);
-	  free ((char *) result);
-	  return ((char **) &glob_error_return);
-	}
-
-      /* If we have something like [star][star]/[star][star], it's no use to
-         glob **, then do it again, and throw half the results away.  */
-      if (all_starstar && filename[0] == '*' && filename[1] == '*' && filename[2] == 0)
-	{
-	  free ((char *) directories);
-	  free (directory_name);
-	  directory_name = NULL;
-	  directory_len = 0;
-	  goto only_filename;
-	}
-
-      /* We have successfully globbed the preceding directory name.
-	 For each name in DIRECTORIES, call glob_vector on it and
-	 FILENAME.  Concatenate the results together.  */
-      for (i = 0; directories[i] != NULL; ++i)
-	{
-	  char **temp_results;
-	  int shouldbreak;
-
-	  shouldbreak = 0;
-	  /* XXX -- we've recursively scanned any directories resulting from
-	     a `**', so turn off the flag.  We turn it on again below if
-	     filename is `**' */
-	  /* Scan directory even on a NULL filename.  That way, `*h/'
-	     returns only directories ending in `h', instead of all
-	     files ending in `h' with a `/' appended. */
-	  dname = directories[i];
-	  dflags = flags & ~(GX_MARKDIRS|GX_ALLDIRS|GX_ADDCURDIR);
-	  /* last_starstar? */
-	  if ((flags & GX_GLOBSTAR) && filename[0] == '*' && filename[1] == '*' && filename[2] == '\0')
-	    dflags |= GX_ALLDIRS|GX_ADDCURDIR;
-	  if (dname[0] == '\0' && filename[0])
-	    {
-	      dflags |= GX_NULLDIR;
-	      dname = ".";	/* treat null directory name and non-null filename as current directory */
-	    }
-
-	  /* Special handling for symlinks to directories with globstar on */
-	  if (all_starstar && (dflags & GX_NULLDIR) == 0)
-	    {
-	      int dlen;
-
-	      /* If we have a directory name that is not null (GX_NULLDIR above)
-		 and is a symlink to a directory, we return the symlink if
-		 we're not `descending' into it (filename[0] == 0) and return
-		 glob_error_return (which causes the code below to skip the
-		 name) otherwise. I should fold this into a test that does both
-		 checks instead of calling stat twice. */
-	      if (glob_testdir (dname, flags|GX_ALLDIRS) == -2 && glob_testdir (dname, 0) == 0)
-		{
-		  if (filename[0] != 0)
-		    temp_results = (char **)&glob_error_return;		/* skip */
-		  else
-		    {
-		      /* Construct array to pass to glob_dir_to_array */
-		      temp_results = (char **)malloc (2 * sizeof (char *));
-		      if (temp_results == NULL)
-			goto memory_error;
-		      temp_results[0] = (char *)malloc (1);
-		      if (temp_results[0] == 0)
-			{
-			  free (temp_results);
-			  goto memory_error;
-			}
-		      **temp_results = '\0';
-		      temp_results[1] = NULL;
-		      dflags |= GX_SYMLINK;	/* mostly for debugging */
-		    }
-		}
-	      else
-		temp_results = glob_vector (filename, dname, dflags);
-	    }
-	  else
-	    temp_results = glob_vector (filename, dname, dflags);
-
-	  /* Handle error cases. */
-	  if (temp_results == NULL)
-	    goto memory_error;
-	  else if (temp_results == (char **)&glob_error_return)
-	    /* This filename is probably not a directory.  Ignore it.  */
-	    ;
-	  else
-	    {
-	      char **array;
-	      register unsigned int l;
-
-	      /* If we're expanding **, we don't need to glue the directory
-		 name to the results; we've already done it in glob_vector */
-	      if ((dflags & GX_ALLDIRS) && filename[0] == '*' && filename[1] == '*' && (filename[2] == '\0' || filename[2] == '/'))
-		{
-		  /* When do we remove null elements from temp_results?  And
-		     how to avoid duplicate elements in the final result? */
-		  /* If (dflags & GX_NULLDIR) glob_filename potentially left a
-		     NULL placeholder in the temp results just in case
-		     glob_vector/glob_dir_to_array did something with it, but
-		     if it didn't, and we're not supposed to be passing them
-		     through for some reason ((flags & GX_NULLDIR) == 0) we
-		     need to remove all the NULL elements from the beginning
-		     of TEMP_RESULTS. */
-		  /* If we have a null directory name and ** as the filename,
-		     we have just searched for everything from the current
-		     directory on down. Break now (shouldbreak = 1) to avoid
-		     duplicate entries in the final result. */
-#define NULL_PLACEHOLDER(x)	((x) && *(x) && **(x) == 0)
-		  if ((dflags & GX_NULLDIR) && (flags & GX_NULLDIR) == 0 &&
-			NULL_PLACEHOLDER (temp_results))
-#undef NULL_PLACEHOLDER
-		    {
-		      register int i, n;
-		      for (n = 0; temp_results[n] && *temp_results[n] == 0; n++)
-			;
-		      i = n;
-		      do
-			temp_results[i - n] = temp_results[i];
-		      while (temp_results[i++] != 0);
-		      array = temp_results;
-		      shouldbreak = 1;
-		    }
-	          else
-		    array = temp_results;
-		}
-	      else if (dflags & GX_SYMLINK)
-		array = glob_dir_to_array (directories[i], temp_results, flags);
-	      else
-		array = glob_dir_to_array (directories[i], temp_results, flags);
-	      l = 0;
-	      while (array[l] != NULL)
-		++l;
-
-	      new_result = (char **)realloc (result, (result_size + l) * sizeof (char *));
-
-	      if (new_result == NULL)
-		{
-		  for (l = 0; array[l]; ++l)
-		    free (array[l]);
-		  free ((char *)array);
-		  goto memory_error;
-		}
-	      result = new_result;
-
-	      for (l = 0; array[l] != NULL; ++l)
-		result[result_size++ - 1] = array[l];
-
-	      result[result_size - 1] = NULL;
-
-	      /* Note that the elements of ARRAY are not freed.  */
-	      if (array != temp_results)
-		free ((char *) array);
-	      else if ((dflags & GX_ALLDIRS) && filename[0] == '*' && filename[1] == '*' && filename[2] == '\0')
-		free (temp_results);	/* expanding ** case above */
-
-	      if (shouldbreak)
-		break;
-	    }
-	}
-      /* Free the directories.  */
-      for (i = 0; directories[i]; i++)
-	free (directories[i]);
-
-      free ((char *) directories);
-
-      return (result);
-    }
-
-only_filename:
-  /* If there is only a directory name, return it. */
-  if (*filename == '\0')
-    {
-      result = (char **) realloc ((char *) result, 2 * sizeof (char *));
-      if (result == NULL)
-	{
-	  if (free_dirname)
-	    free (directory_name);
-	  return (NULL);
-	}
-      /* If we have a directory name with quoted characters, and we are
-	 being called recursively to glob the directory portion of a pathname,
-	 we need to dequote the directory name before returning it so the
-	 caller can read the directory */
-      if (directory_len > 0 && hasglob == 2 && (flags & GX_RECURSE) != 0)
-	{
-	  dequote_pathname (directory_name);
-	  directory_len = strlen (directory_name);
-	}
-
-      /* We could check whether or not the dequoted directory_name is a
-	 directory and return it here, returning the original directory_name
-	 if not, but we don't do that. We do return the dequoted directory
-	 name if we're not being called recursively and the dequoted name
-	 corresponds to an actual directory. For better backwards compatibility,
-	 we can return &glob_error_return unconditionally in this case. */
-
-      if (directory_len > 0 && hasglob == 2 && (flags & GX_RECURSE) == 0)
-	{
-	  dequote_pathname (directory_name);
-	  if (glob_testdir (directory_name, 0) < 0)
-	    {
-	      if (free_dirname)
-		free (directory_name);
-	      free ((char *) result);
-	      return ((char **)&glob_error_return);
-	    }
-	}
-
-      /* Handle GX_MARKDIRS here. */
-      result[0] = (char *) malloc (directory_len + 1);
-      if (result[0] == NULL)
-	goto memory_error;
-      bcopy (directory_name, result[0], directory_len + 1);
-      if (free_dirname)
-	free (directory_name);
-      result[1] = NULL;
-      return (result);
-    }
-  else
-    {
-      char **temp_results;
-
-      /* There are no unquoted globbing characters in DIRECTORY_NAME.
-	 Dequote it before we try to open the directory since there may
-	 be quoted globbing characters which should be treated verbatim. */
-      if (directory_len > 0)
-	dequote_pathname (directory_name);
-
-      /* We allocated a small array called RESULT, which we won't be using.
-	 Free that memory now. */
-      free (result);
-
-      /* Just return what glob_vector () returns appended to the
-	 directory name. */
-      /* If flags & GX_ALLDIRS, we're called recursively */
-      dflags = flags & ~GX_MARKDIRS;
-      if (directory_len == 0)
-	dflags |= GX_NULLDIR;
-      if ((flags & GX_GLOBSTAR) && filename[0] == '*' && filename[1] == '*' && filename[2] == '\0')
-	{
-	  dflags |= GX_ALLDIRS|GX_ADDCURDIR;
-#if 0
-	  /* If we want all directories (dflags & GX_ALLDIRS) and we're not
-	     being called recursively as something like `echo [star][star]/[star].o'
-	     ((flags & GX_ALLDIRS) == 0), we want to prevent glob_vector from
-	     adding a null directory name to the front of the temp_results
-	     array.  We turn off ADDCURDIR if not called recursively and
-	     dlen == 0 */
-#endif
-	  if (directory_len == 0 && (flags & GX_ALLDIRS) == 0)
-	    dflags &= ~GX_ADDCURDIR;
-	}
-      temp_results = glob_vector (filename,
-				  (directory_len == 0 ? "." : directory_name),
-				  dflags);
-
-      if (temp_results == NULL || temp_results == (char **)&glob_error_return)
-	{
-	  if (free_dirname)
-	    free (directory_name);
-	  QUIT;			/* XXX - shell */
-	  run_pending_traps ();
-	  return (temp_results);
-	}
-
-      result = glob_dir_to_array ((dflags & GX_ALLDIRS) ? "" : directory_name, temp_results, flags);
-
-      if (free_dirname)
-	free (directory_name);
-      return (result);
-    }
-
-  /* We get to memory_error if the program has run out of memory, or
-     if this is the shell, and we have been interrupted. */
- memory_error:
-  if (result != NULL)
-    {
-      register unsigned int i;
-      for (i = 0; result[i] != NULL; ++i)
-	free (result[i]);
-      free ((char *) result);
-    }
-
-  if (free_dirname && directory_name)
-    free (directory_name);
-
-  QUIT;
-  run_pending_traps ();
-
-  return (NULL);
-}
-
-#if defined (TEST)
-
-main (argc, argv)
-     int argc;
-     char **argv;
-{
-  unsigned int i;
-
-  for (i = 1; i < argc; ++i)
-    {
-      char **value = glob_filename (argv[i], 0);
-      if (value == NULL)
-	puts ("Out of memory.");
-      else if (value == &glob_error_return)
-	perror (argv[i]);
-      else
-	for (i = 0; value[i] != NULL; i++)
-	  puts (value[i]);
-    }
-
-  exit (0);
-}
-#endif	/* TEST.  */
diff --git a/third_party/bash/glob.h b/third_party/bash/glob.h
deleted file mode 100644
index 47410577c..000000000
--- a/third_party/bash/glob.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* File-name wildcard pattern matching for GNU.
-   Copyright (C) 1985-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne-Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef	_GLOB_H_
-#define	_GLOB_H_
-
-#include "stdc.h"
-
-#define GX_MARKDIRS	0x001	/* mark directory names with trailing `/' */
-#define GX_NOCASE	0x002	/* ignore case */
-#define GX_MATCHDOT	0x004	/* match `.' literally */
-#define GX_MATCHDIRS	0x008	/* match only directory names */
-#define GX_ALLDIRS	0x010	/* match all directory names, no others */
-#define GX_NULLDIR	0x100	/* internal -- no directory preceding pattern */
-#define GX_ADDCURDIR	0x200	/* internal -- add passed directory name */
-#define GX_GLOBSTAR	0x400	/* turn on special handling of ** */
-#define GX_RECURSE	0x800	/* internal -- glob_filename called recursively */
-#define GX_SYMLINK	0x1000	/* internal -- symlink to a directory */
-#define GX_NEGATE	0x2000	/* internal -- extglob pattern being negated */
-
-extern int glob_pattern_p PARAMS((const char *));
-extern char **glob_vector PARAMS((char *, char *, int));
-extern char **glob_filename PARAMS((char *, int));
-
-extern int extglob_pattern_p PARAMS((const char *));
-
-extern char *glob_error_return;
-extern int noglob_dot_filenames;
-extern int glob_ignore_case;
-
-#endif /* _GLOB_H_ */
diff --git a/third_party/bash/glob_loop.inc b/third_party/bash/glob_loop.inc
deleted file mode 100644
index 467e7ae33..000000000
--- a/third_party/bash/glob_loop.inc
+++ /dev/null
@@ -1,84 +0,0 @@
-/* Copyright (C) 1991-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-   
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-static int INTERNAL_GLOB_PATTERN_P PARAMS((const GCHAR *));
-
-/* Return nonzero if PATTERN has any special globbing chars in it.
-   Compiled twice, once each for single-byte and multibyte characters. */
-static int
-INTERNAL_GLOB_PATTERN_P (pattern)
-     const GCHAR *pattern;
-{
-  register const GCHAR *p;
-  register GCHAR c;
-  int bopen, bsquote;
-
-  p = pattern;
-  bopen = bsquote = 0;
-
-  while ((c = *p++) != L('\0'))
-    switch (c)
-      {
-      case L('?'):
-      case L('*'):
-	return 1;
-
-      case L('['):      /* Only accept an open brace if there is a close */
-	bopen++;        /* brace to match it.  Bracket expressions must be */
-	continue;       /* complete, according to Posix.2 */
-      case L(']'):
-	if (bopen)
-	  return 1;
-	continue;
-
-      case L('+'):         /* extended matching operators */
-      case L('@'):
-      case L('!'):
-	if (*p == L('('))  /*) */
-	  return 1;
-	continue;
-
-      case L('\\'):
-	/* Don't let the pattern end in a backslash (GMATCH returns no match
-	   if the pattern ends in a backslash anyway), but otherwise note that 
-	   we have seen this, since the matching engine uses backslash as an
-	   escape character and it can be removed. We return 2 later if we
-	   have seen only backslash-escaped characters, so interested callers
-	   know they can shortcut and just dequote the pathname. */
-	if (*p != L('\0'))
-	  {
-	    p++;
-	    bsquote = 1;
-	    continue;
-	  }
-	else 	/* (*p == L('\0')) */
-	  return 0;
-      }
-
-#if 0
-  return bsquote ? 2 : 0;
-#else
-  return (0);
-#endif
-}
-
-#undef INTERNAL_GLOB_PATTERN_P
-#undef L
-#undef INT
-#undef CHAR
-#undef GCHAR
diff --git a/third_party/bash/gm_loop.inc b/third_party/bash/gm_loop.inc
deleted file mode 100644
index ac516f82c..000000000
--- a/third_party/bash/gm_loop.inc
+++ /dev/null
@@ -1,208 +0,0 @@
-/* Copyright (C) 1991-2017 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-   
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if EXTENDED_GLOB
-int
-EXTGLOB_PATTERN_P (pat)
-     const CHAR *pat;
-{
-  switch (pat[0])
-    {
-    case L('*'):
-    case L('+'):
-    case L('!'):
-    case L('@'):
-    case L('?'):
-      return (pat[1] == L('('));	/* ) */
-    default:
-      return 0;
-    }
-    
-  return 0;
-}
-#endif
-
-/* Return 1 of the first character of STRING could match the first
-   character of pattern PAT.  Compiled to both single and wiide character
-   versions.  FLAGS is a subset of strmatch flags; used to do case-insensitive
-   matching for now. */
-int
-MATCH_PATTERN_CHAR (pat, string, flags)
-     CHAR *pat, *string;
-     int flags;
-{
-  CHAR c;
-
-  if (*string == 0)
-    return (*pat == L('*'));	/* XXX  - allow only * to match empty string */
-
-  switch (c = *pat++)
-    {
-    default:
-      return (FOLD(*string) == FOLD(c));
-    case L('\\'):
-      return (FOLD(*string) == FOLD(*pat));
-    case L('?'):
-      return (*pat == L('(') ? 1 : (*string != L'\0'));
-    case L('*'):
-      return (1);
-    case L('+'):
-    case L('!'):
-    case L('@'):
-      return (*pat ==  L('(') ? 1 : (FOLD(*string) == FOLD(c)));
-    case L('['):
-      return (*string != L('\0'));
-    }
-}
-
-int
-MATCHLEN (pat, max)
-     CHAR *pat;
-     size_t max;
-{
-  CHAR c;
-  int matlen, bracklen, t, in_cclass, in_collsym, in_equiv;
-
-  if (*pat == 0)
-    return (0);
-
-  matlen = in_cclass = in_collsym = in_equiv = 0;
-  while (c = *pat++)
-    {
-      switch (c)
-	{
-	default:
-	  matlen++;
-	  break;
-	case L('\\'):
-	  if (*pat == 0)
-	    return ++matlen;
-	  else
-	    {
-	      matlen++;
-	      pat++;
-	    }
-	  break;
-	case L('?'):
-	  if (*pat == LPAREN)
-	    return (matlen = -1);		/* XXX for now */
-	  else
-	    matlen++;
-	  break;
-	case L('*'):
-	  return (matlen = -1);
-	case L('+'):
-	case L('!'):
-	case L('@'):
-	  if (*pat == LPAREN)
-	    return (matlen = -1);		/* XXX for now */
-	  else
-	    matlen++;
-	  break;
-	case L('['):
-	  /* scan for ending `]', skipping over embedded [:...:] */
-	  bracklen = 1;
-	  c = *pat++;
-	  do
-	    {
-	      if (c == 0)
-		{
-		  pat--;			/* back up to NUL */
-	          matlen += bracklen;
-	          goto bad_bracket;
-	        }
-	      else if (c == L('\\'))
-		{
-		  /* *pat == backslash-escaped character */
-		  bracklen++;
-		  /* If the backslash or backslash-escape ends the string,
-		     bail.  The ++pat skips over the backslash escape */
-		  if (*pat == 0 || *++pat == 0)
-		    {
-		      matlen += bracklen;
-		      goto bad_bracket;
-		    }
-		}
-	      else if (c == L('[') && *pat == L(':'))	/* character class */
-		{
-		  pat++;
-		  bracklen++;
-		  in_cclass = 1;
-		}
-	      else if (in_cclass && c == L(':') && *pat == L(']'))
-		{
-		  pat++;
-		  bracklen++;
-		  in_cclass = 0;
-		}
-	      else if (c == L('[') && *pat == L('.'))	/* collating symbol */
-		{
-		  pat++;
-		  bracklen++;
-		  if (*pat == L(']'))	/* right bracket can appear as collating symbol */
-		    {
-		      pat++;
-		      bracklen++;
-		    }
-		  in_collsym = 1;
-		}
-	      else if (in_collsym && c == L('.') && *pat == L(']'))
-		{
-		  pat++;
-		  bracklen++;
-		  in_collsym = 0;
-		}
-	      else if (c == L('[') && *pat == L('='))	/* equivalence class */
-		{
-		  pat++;
-		  bracklen++;
-		  if (*pat == L(']'))	/* right bracket can appear as equivalence class */
-		    {
-		      pat++;
-		      bracklen++;
-		    }
-		  in_equiv = 1;
-		}
-	      else if (in_equiv && c == L('=') && *pat == L(']'))
-		{
-		  pat++;
-		  bracklen++;
-		  in_equiv = 0;
-		}
-	      else
-		bracklen++;
-	    }
-	  while ((c = *pat++) != L(']'));
-	  matlen++;		/* bracket expression can only match one char */
-bad_bracket:
-	  break;
-	}
-    }
-
-  return matlen;
-}
-
-#undef EXTGLOB_PATTERN_P
-#undef MATCH_PATTERN_CHAR
-#undef MATCHLEN
-#undef FOLD
-#undef L
-#undef LPAREN
-#undef RPAREN
-#undef INT
-#undef CHAR
diff --git a/third_party/bash/gmisc.c b/third_party/bash/gmisc.c
deleted file mode 100644
index 11d3b0294..000000000
--- a/third_party/bash/gmisc.c
+++ /dev/null
@@ -1,108 +0,0 @@
-/* gmisc.c -- miscellaneous pattern matching utility functions for Bash.
-
-   Copyright (C) 2010-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne-Again SHell.
-   
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "shmbutil.h"
-#include "chartypes.h"
-
-#include "stdc.h"
-
-#ifndef FNM_CASEFOLD
-#  include "strmatch.h"
-#endif
-#include "glob.h"
-
-/* Make sure these names continue to agree with what's in smatch.c */
-extern char *glob_patscan PARAMS((char *, char *, int));
-
-/* Compile `gm_loop.inc' for single-byte characters. */
-#define CHAR	char
-#define INT	int
-#define L(CS)	CS
-#define EXTGLOB_PATTERN_P extglob_pattern_p
-#define MATCH_PATTERN_CHAR match_pattern_char
-#define MATCHLEN umatchlen
-#define FOLD(c) ((flags & FNM_CASEFOLD) \
-	? TOLOWER ((unsigned char)c) \
-	: ((unsigned char)c))
-#ifndef LPAREN
-#define LPAREN '('
-#define RPAREN ')'
-#endif
-#include "gm_loop.inc"
-
-/* Compile `gm_loop.inc' again for multibyte characters. */
-#if HANDLE_MULTIBYTE
-
-#define CHAR	wchar_t
-#define INT	wint_t
-#define L(CS)	L##CS
-#define EXTGLOB_PATTERN_P wextglob_pattern_p
-#define MATCH_PATTERN_CHAR match_pattern_wchar
-#define MATCHLEN wmatchlen
-
-#define FOLD(c) ((flags & FNM_CASEFOLD) && iswupper (c) ? towlower (c) : (c))
-#define LPAREN L'('
-#define RPAREN L')'
-#include "gm_loop.inc"
-
-#endif /* HANDLE_MULTIBYTE */
-
-
-#if defined (EXTENDED_GLOB)
-/* Skip characters in PAT and return the final occurrence of DIRSEP.  This
-   is only called when extended_glob is set, so we have to skip over extglob
-   patterns x(...) */
-char *
-glob_dirscan (pat, dirsep)
-     char *pat;
-     int dirsep;
-{
-  char *p, *d, *pe, *se;
-
-  d = pe = se = 0;
-  for (p = pat; p && *p; p++)
-    {
-      if (extglob_pattern_p (p))
-	{
-	  if (se == 0)
-	    se = p + strlen (p) - 1;
-	  pe = glob_patscan (p + 2, se, 0);
-	  if (pe == 0)
-	    continue;
-	  else if (*pe == 0)
-	    break;
-	  p = pe - 1;	/* will do increment above */
-	  continue;
-	}
-      if (*p ==  dirsep)
-	d = p;
-    }
-  return d;
-}
-#endif /* EXTENDED_GLOB */
diff --git a/third_party/bash/hashcmd.c b/third_party/bash/hashcmd.c
deleted file mode 100644
index f6e6f11d1..000000000
--- a/third_party/bash/hashcmd.c
+++ /dev/null
@@ -1,195 +0,0 @@
-/* hashcmd.c - functions for managing a hash table mapping command names to
-	       full pathnames. */
-
-/* Copyright (C) 1997-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-
-#include "shell.h"
-#include "flags.h"
-#include "findcmd.h"
-#include "hashcmd.h"
-
-HASH_TABLE *hashed_filenames = (HASH_TABLE *)NULL;
-
-static void phash_freedata PARAMS((PTR_T));
-
-void
-phash_create ()
-{
-  if (hashed_filenames == 0)
-    hashed_filenames = hash_create (FILENAME_HASH_BUCKETS);
-}
-
-static void
-phash_freedata (data)
-     PTR_T data;
-{
-  free (((PATH_DATA *)data)->path);
-  free (data);
-}
-
-void
-phash_flush ()
-{
-  if (hashed_filenames)
-    hash_flush (hashed_filenames, phash_freedata);
-}
-
-/* Remove FILENAME from the table of hashed commands. */
-int
-phash_remove (filename)
-     const char *filename;
-{
-  register BUCKET_CONTENTS *item;
-
-  if (hashing_enabled == 0 || hashed_filenames == 0)
-    return 0;
-
-  item = hash_remove (filename, hashed_filenames, 0);
-  if (item)
-    {
-      if (item->data)
-	phash_freedata (item->data);
-      free (item->key);
-      free (item);
-      return 0;
-    }
-  return 1;
-}
-
-/* Place FILENAME (key) and FULL_PATH (data->path) into the
-   hash table.  CHECK_DOT if non-null is for future calls to
-   phash_search (); it means that this file was found
-   in a directory in $PATH that is not an absolute pathname.
-   FOUND is the initial value for times_found. */
-void
-phash_insert (filename, full_path, check_dot, found)
-     char *filename, *full_path;
-     int check_dot, found;
-{
-  register BUCKET_CONTENTS *item;
-
-  if (hashing_enabled == 0)
-    return;
-
-  if (hashed_filenames == 0)
-    phash_create ();
-
-  item = hash_insert (filename, hashed_filenames, 0);
-  if (item->data)
-    free (pathdata(item)->path);
-  else
-    {
-      item->key = savestring (filename);
-      item->data = xmalloc (sizeof (PATH_DATA));
-    }
-  pathdata(item)->path = savestring (full_path);
-  pathdata(item)->flags = 0;
-  if (check_dot)
-    pathdata(item)->flags |= HASH_CHKDOT;
-  if (*full_path != '/')
-    pathdata(item)->flags |= HASH_RELPATH;
-  item->times_found = found;
-}
-
-/* Return the full pathname that FILENAME hashes to.  If FILENAME
-   is hashed, but (data->flags & HASH_CHKDOT) is non-zero, check
-   ./FILENAME and return that if it is executable.  This always
-   returns a newly-allocated string; the caller is responsible
-   for freeing it. */
-char *
-phash_search (filename)
-     const char *filename;
-{
-  register BUCKET_CONTENTS *item;
-  char *path, *dotted_filename, *tail;
-  int same;
-
-  if (hashing_enabled == 0 || hashed_filenames == 0)
-    return ((char *)NULL);
-
-  item = hash_search (filename, hashed_filenames, 0);
-
-  if (item == NULL)
-    return ((char *)NULL);
-
-  /* If this filename is hashed, but `.' comes before it in the path,
-     see if ./filename is executable.  If the hashed value is not an
-     absolute pathname, see if ./`hashed-value' exists. */
-  path = pathdata(item)->path;
-  if (pathdata(item)->flags & (HASH_CHKDOT|HASH_RELPATH))
-    {
-      tail = (pathdata(item)->flags & HASH_RELPATH) ? path : (char *)filename;	/* XXX - fix const later */
-      /* If the pathname does not start with a `./', add a `./' to it. */
-      if (tail[0] != '.' || tail[1] != '/')
-	{
-	  dotted_filename = (char *)xmalloc (3 + strlen (tail));
-	  dotted_filename[0] = '.'; dotted_filename[1] = '/';
-	  strcpy (dotted_filename + 2, tail);
-	}
-      else
-	dotted_filename = savestring (tail);
-
-      if (executable_file (dotted_filename))
-	return (dotted_filename);
-
-      free (dotted_filename);
-
-#if 0
-      if (pathdata(item)->flags & HASH_RELPATH)
-	return ((char *)NULL);
-#endif
-
-      /* Watch out.  If this file was hashed to "./filename", and
-	 "./filename" is not executable, then return NULL. */
-
-      /* Since we already know "./filename" is not executable, what
-	 we're really interested in is whether or not the `path'
-	 portion of the hashed filename is equivalent to the current
-	 directory, but only if it starts with a `.'.  (This catches
-	 ./. and so on.)  same_file () tests general Unix file
-	 equivalence -- same device and inode. */
-      if (*path == '.')
-	{
-	  same = 0;
-	  tail = (char *)strrchr (path, '/');
-
-	  if (tail)
-	    {
-	      *tail = '\0';
-	      same = same_file (".", path, (struct stat *)NULL, (struct stat *)NULL);
-	      *tail = '/';
-	    }
-
-	  return same ? (char *)NULL : savestring (path);
-	}
-    }
-
-  return (savestring (path));
-}
diff --git a/third_party/bash/hashcmd.h b/third_party/bash/hashcmd.h
deleted file mode 100644
index 2459f2004..000000000
--- a/third_party/bash/hashcmd.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* hashcmd.h - Common defines for hashing filenames. */
-
-/* Copyright (C) 1993-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "stdc.h"
-#include "hashlib.h"
-
-#define FILENAME_HASH_BUCKETS 256	/* must be power of two */
-
-extern HASH_TABLE *hashed_filenames;
-
-typedef struct _pathdata {
-  char *path;		/* The full pathname of the file. */
-  int flags;
-} PATH_DATA;
-
-#define HASH_RELPATH	0x01	/* this filename is a relative pathname. */
-#define HASH_CHKDOT	0x02	/* check `.' since it was earlier in $PATH */
-
-#define pathdata(x) ((PATH_DATA *)(x)->data)
-
-extern void phash_create PARAMS((void));
-extern void phash_flush PARAMS((void));
-
-extern void phash_insert PARAMS((char *, char *, int, int));
-extern int phash_remove PARAMS((const char *));
-extern char *phash_search PARAMS((const char *));
diff --git a/third_party/bash/hashlib.c b/third_party/bash/hashlib.c
deleted file mode 100644
index a3c896051..000000000
--- a/third_party/bash/hashlib.c
+++ /dev/null
@@ -1,545 +0,0 @@
-/* hashlib.c -- functions to manage and access hash tables for bash. */
-
-/* Copyright (C) 1987,1989,1991,1995,1998,2001,2003,2005,2006,2008,2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashansi.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-
-#include "shell.h"
-#include "hashlib.h"
-
-/* tunable constants for rehashing */
-#define HASH_REHASH_MULTIPLIER	4
-#define HASH_REHASH_FACTOR	2
-
-#define HASH_SHOULDGROW(table) \
-  ((table)->nentries >= (table)->nbuckets * HASH_REHASH_FACTOR)
-
-/* an initial approximation */
-#define HASH_SHOULDSHRINK(table) \
-  (((table)->nbuckets > DEFAULT_HASH_BUCKETS) && \
-   ((table)->nentries < (table)->nbuckets / HASH_REHASH_MULTIPLIER))
-
-/* Rely on properties of unsigned division (unsigned/int -> unsigned) and
-   don't discard the upper 32 bits of the value, if present. */
-#define HASH_BUCKET(s, t, h) (((h) = hash_string (s)) & ((t)->nbuckets - 1))
-
-static BUCKET_CONTENTS *copy_bucket_array PARAMS((BUCKET_CONTENTS *, sh_string_func_t *));
-
-static void hash_rehash PARAMS((HASH_TABLE *, int));
-static void hash_grow PARAMS((HASH_TABLE *));
-static void hash_shrink PARAMS((HASH_TABLE *));
-
-/* Make a new hash table with BUCKETS number of buckets.  Initialize
-   each slot in the table to NULL. */
-HASH_TABLE *
-hash_create (buckets)
-     int buckets;
-{
-  HASH_TABLE *new_table;
-  register int i;
-
-  new_table = (HASH_TABLE *)xmalloc (sizeof (HASH_TABLE));
-  if (buckets == 0)
-    buckets = DEFAULT_HASH_BUCKETS;
-
-  new_table->bucket_array =
-    (BUCKET_CONTENTS **)xmalloc (buckets * sizeof (BUCKET_CONTENTS *));
-  new_table->nbuckets = buckets;
-  new_table->nentries = 0;
-
-  for (i = 0; i < buckets; i++)
-    new_table->bucket_array[i] = (BUCKET_CONTENTS *)NULL;
-
-  return (new_table);
-}
-
-int
-hash_size (table)
-     HASH_TABLE *table;
-{
-  return (HASH_ENTRIES(table));
-}
-
-static BUCKET_CONTENTS *
-copy_bucket_array (ba, cpdata)
-     BUCKET_CONTENTS *ba;
-     sh_string_func_t *cpdata;	/* data copy function */
-{
-  BUCKET_CONTENTS *new_bucket, *n, *e;
-
-  if (ba == 0)
-    return ((BUCKET_CONTENTS *)0);
-
-  for (n = (BUCKET_CONTENTS *)0, e = ba; e; e = e->next)
-    {
-      if (n == 0)
-        {
-          new_bucket = (BUCKET_CONTENTS *)xmalloc (sizeof (BUCKET_CONTENTS));
-          n = new_bucket;
-        }
-      else
-        {
-          n->next = (BUCKET_CONTENTS *)xmalloc (sizeof (BUCKET_CONTENTS));
-          n = n->next;
-        }
-
-      n->key = savestring (e->key);
-      n->data = e->data ? (cpdata ? (*cpdata) (e->data) : savestring (e->data))
-			: NULL;
-      n->khash = e->khash;
-      n->times_found = e->times_found;
-      n->next = (BUCKET_CONTENTS *)NULL;
-    }
-
-  return new_bucket;  
-}
-
-static void
-hash_rehash (table, nsize)
-     HASH_TABLE *table;
-     int nsize;
-{
-  int osize, i, j;
-  BUCKET_CONTENTS **old_bucket_array, *item, *next;
-
-  if (table == NULL || nsize == table->nbuckets)
-    return;
-
-  osize = table->nbuckets;
-  old_bucket_array = table->bucket_array;
-
-  table->nbuckets = nsize;
-  table->bucket_array = (BUCKET_CONTENTS **)xmalloc (table->nbuckets * sizeof (BUCKET_CONTENTS *));
-  for (i = 0; i < table->nbuckets; i++)
-    table->bucket_array[i] = (BUCKET_CONTENTS *)NULL;
-
-  for (j = 0; j < osize; j++)
-    {
-      for (item = old_bucket_array[j]; item; item = next)
-	{
-	  next = item->next;
-	  i = item->khash & (table->nbuckets - 1);
-	  item->next = table->bucket_array[i];
-	  table->bucket_array[i] = item;
-	}
-    }
-
-  free (old_bucket_array);
-}
-
-static void
-hash_grow (table)
-     HASH_TABLE *table;
-{
-  int nsize;
-
-  nsize = table->nbuckets * HASH_REHASH_MULTIPLIER;
-  if (nsize > 0)		/* overflow */
-    hash_rehash (table, nsize);
-}
-
-static void
-hash_shrink (table)
-     HASH_TABLE *table;
-{
-  int nsize;
-
-  nsize = table->nbuckets / HASH_REHASH_MULTIPLIER;
-  hash_rehash (table, nsize);
-}
-
-HASH_TABLE *
-hash_copy (table, cpdata)
-     HASH_TABLE *table;
-     sh_string_func_t *cpdata;
-{
-  HASH_TABLE *new_table;
-  int i;
-
-  if (table == 0)
-    return ((HASH_TABLE *)NULL);
-
-  new_table = hash_create (table->nbuckets);
-
-  for (i = 0; i < table->nbuckets; i++)
-    new_table->bucket_array[i] = copy_bucket_array (table->bucket_array[i], cpdata);
-
-  new_table->nentries = table->nentries;
-  return new_table;
-}
-
-/* This is the best 32-bit string hash function I found. It's one of the
-   Fowler-Noll-Vo family (FNV-1).
-
-   The magic is in the interesting relationship between the special prime
-   16777619 (2^24 + 403) and 2^32 and 2^8. */
-
-#define FNV_OFFSET 2166136261
-#define FNV_PRIME 16777619
-
-/* If you want to use 64 bits, use
-FNV_OFFSET	14695981039346656037
-FNV_PRIME	1099511628211
-*/
-
-/* The `khash' check below requires that strings that compare equally with
-   strcmp hash to the same value. */
-unsigned int
-hash_string (s)
-     const char *s;
-{
-  register unsigned int i;
-
-  for (i = FNV_OFFSET; *s; s++)
-    {
-      /* FNV-1a has the XOR first, traditional FNV-1 has the multiply first */
-
-      /* was i *= FNV_PRIME */
-      i += (i<<1) + (i<<4) + (i<<7) + (i<<8) + (i<<24);
-      i ^= *s;
-    }
-
-  return i;
-}
-
-/* Return the location of the bucket which should contain the data
-   for STRING.  TABLE is a pointer to a HASH_TABLE. */
-
-int
-hash_bucket (string, table)
-     const char *string;
-     HASH_TABLE *table;
-{
-  unsigned int h;
-
-  return (HASH_BUCKET (string, table, h));
-}
-
-/* Return a pointer to the hashed item.  If the HASH_CREATE flag is passed,
-   create a new hash table entry for STRING, otherwise return NULL. */
-BUCKET_CONTENTS *
-hash_search (string, table, flags)
-     const char *string;
-     HASH_TABLE *table;
-     int flags;
-{
-  BUCKET_CONTENTS *list;
-  int bucket;
-  unsigned int hv;
-
-  if (table == 0 || ((flags & HASH_CREATE) == 0 && HASH_ENTRIES (table) == 0))
-    return (BUCKET_CONTENTS *)NULL;
-
-  bucket = HASH_BUCKET (string, table, hv);
-
-  for (list = table->bucket_array ? table->bucket_array[bucket] : 0; list; list = list->next)
-    {
-      /* This is the comparison function */
-      if (hv == list->khash && STREQ (list->key, string))
-	{
-	  list->times_found++;
-	  return (list);
-	}
-    }
-
-  if (flags & HASH_CREATE)
-    {
-      if (HASH_SHOULDGROW (table))
-	{
-	  hash_grow (table);
-	  bucket = HASH_BUCKET (string, table, hv);
-	}
-
-      list = (BUCKET_CONTENTS *)xmalloc (sizeof (BUCKET_CONTENTS));
-      list->next = table->bucket_array[bucket];
-      table->bucket_array[bucket] = list;
-
-      list->data = NULL;
-      list->key = (char *)string;	/* XXX fix later */
-      list->khash = hv;
-      list->times_found = 0;
-
-      table->nentries++;
-      return (list);
-    }
-      
-  return (BUCKET_CONTENTS *)NULL;
-}
-
-/* Remove the item specified by STRING from the hash table TABLE.
-   The item removed is returned, so you can free its contents.  If
-   the item isn't in this table NULL is returned. */
-BUCKET_CONTENTS *
-hash_remove (string, table, flags)
-     const char *string;
-     HASH_TABLE *table;
-     int flags;
-{
-  int bucket;
-  BUCKET_CONTENTS *prev, *temp;
-  unsigned int hv;
-
-  if (table == 0 || HASH_ENTRIES (table) == 0)
-    return (BUCKET_CONTENTS *)NULL;
-
-  bucket = HASH_BUCKET (string, table, hv);
-  prev = (BUCKET_CONTENTS *)NULL;
-  for (temp = table->bucket_array[bucket]; temp; temp = temp->next)
-    {
-      if (hv == temp->khash && STREQ (temp->key, string))
-	{
-	  if (prev)
-	    prev->next = temp->next;
-	  else
-	    table->bucket_array[bucket] = temp->next;
-
-	  table->nentries--;
-	  return (temp);
-	}
-      prev = temp;
-    }
-  return ((BUCKET_CONTENTS *) NULL);
-}
-
-/* Create an entry for STRING, in TABLE.  If the entry already
-   exists, then return it (unless the HASH_NOSRCH flag is set). */
-BUCKET_CONTENTS *
-hash_insert (string, table, flags)
-     char *string;
-     HASH_TABLE *table;
-     int flags;
-{
-  BUCKET_CONTENTS *item;
-  int bucket;
-  unsigned int hv;
-
-  if (table == 0)
-    table = hash_create (0);
-
-  item = (flags & HASH_NOSRCH) ? (BUCKET_CONTENTS *)NULL
-  			       : hash_search (string, table, 0);
-
-  if (item == 0)
-    {
-      if (HASH_SHOULDGROW (table))
-	hash_grow (table);
-
-      bucket = HASH_BUCKET (string, table, hv);
-
-      item = (BUCKET_CONTENTS *)xmalloc (sizeof (BUCKET_CONTENTS));
-      item->next = table->bucket_array[bucket];
-      table->bucket_array[bucket] = item;
-
-      item->data = NULL;
-      item->key = string;
-      item->khash = hv;
-      item->times_found = 0;
-
-      table->nentries++;
-    }
-
-  return (item);
-}
-
-/* Remove and discard all entries in TABLE.  If FREE_DATA is non-null, it
-   is a function to call to dispose of a hash item's data.  Otherwise,
-   free() is called. */
-void
-hash_flush (table, free_data)
-     HASH_TABLE *table;
-     sh_free_func_t *free_data;
-{
-  int i;
-  register BUCKET_CONTENTS *bucket, *item;
-
-  if (table == 0 || HASH_ENTRIES (table) == 0)
-    return;
-
-  for (i = 0; i < table->nbuckets; i++)
-    {
-      bucket = table->bucket_array[i];
-
-      while (bucket)
-	{
-	  item = bucket;
-	  bucket = bucket->next;
-
-	  if (free_data)
-	    (*free_data) (item->data);
-	  else
-	    free (item->data);
-	  free (item->key);
-	  free (item);
-	}
-      table->bucket_array[i] = (BUCKET_CONTENTS *)NULL;
-    }
-
-  table->nentries = 0;
-}
-
-/* Free the hash table pointed to by TABLE. */
-void
-hash_dispose (table)
-     HASH_TABLE *table;
-{
-  free (table->bucket_array);
-  free (table);
-}
-
-void
-hash_walk (table, func)
-     HASH_TABLE *table;
-     hash_wfunc *func;
-{
-  register int i;
-  BUCKET_CONTENTS *item;
-
-  if (table == 0 || HASH_ENTRIES (table) == 0)
-    return;
-
-  for (i = 0; i < table->nbuckets; i++)
-    {
-      for (item = hash_items (i, table); item; item = item->next)
-	if ((*func) (item) < 0)
-	  return;
-    }
-}
-
-#if defined (DEBUG) || defined (TEST_HASHING)
-void
-hash_pstats (table, name)
-     HASH_TABLE *table;
-     char *name;
-{
-  register int slot, bcount;
-  register BUCKET_CONTENTS *bc;
-
-  if (name == 0)
-    name = "unknown hash table";
-
-  fprintf (stderr, "%s: %d buckets; %d items\n", name, table->nbuckets, table->nentries);
-
-  /* Print out a count of how many strings hashed to each bucket, so we can
-     see how even the distribution is. */
-  for (slot = 0; slot < table->nbuckets; slot++)
-    {
-      bc = hash_items (slot, table);
-
-      fprintf (stderr, "\tslot %3d: ", slot);
-      for (bcount = 0; bc; bc = bc->next)
-	bcount++;
-
-      fprintf (stderr, "%d\n", bcount);
-    }
-}
-#endif
-
-#ifdef TEST_HASHING
-
-/* link with xmalloc.o and lib/malloc/libmalloc.a */
-#undef NULL
-#include <stdio.h>
-
-#ifndef NULL
-#define NULL 0
-#endif
-
-HASH_TABLE *table, *ntable;
-
-int interrupt_immediately = 0;
-int running_trap = 0;
-
-int
-signal_is_trapped (s)
-     int s;
-{
-  return (0);
-}
-
-void
-programming_error (const char *format, ...)
-{
-  abort();
-}
-
-void
-fatal_error (const char *format, ...)
-{
-  abort();
-}
-
-void
-internal_warning (const char *format, ...)
-{
-}
-
-int
-main ()
-{
-  char string[256];
-  int count = 0;
-  BUCKET_CONTENTS *tt;
-
-#if defined (TEST_NBUCKETS)
-  table = hash_create (TEST_NBUCKETS);
-#else
-  table = hash_create (0);
-#endif
-
-  for (;;)
-    {
-      char *temp_string;
-      if (fgets (string, sizeof (string), stdin) == 0)
-	break;
-      if (!*string)
-	break;
-      temp_string = savestring (string);
-      tt = hash_insert (temp_string, table, 0);
-      if (tt->times_found)
-	{
-	  fprintf (stderr, "You have already added item `%s'\n", string);
-	  free (temp_string);
-	}
-      else
-	{
-	  count++;
-	}
-    }
-
-  hash_pstats (table, "hash test");
-
-  ntable = hash_copy (table, (sh_string_func_t *)NULL);
-  hash_flush (table, (sh_free_func_t *)NULL);
-  hash_pstats (ntable, "hash copy test");
-
-  exit (0);
-}
-
-#endif /* TEST_HASHING */
diff --git a/third_party/bash/hashlib.h b/third_party/bash/hashlib.h
deleted file mode 100644
index cf2de9884..000000000
--- a/third_party/bash/hashlib.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/* hashlib.h -- the data structures used in hashing in Bash. */
-
-/* Copyright (C) 1993-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_HASHLIB_H_)
-#define _HASHLIB_H_
-
-#include "stdc.h"
-
-#ifndef PTR_T
-#  ifdef __STDC__
-#    define PTR_T void *
-#  else
-#    define PTR_T char *
-#  endif
-#endif
-
-typedef struct bucket_contents {
-  struct bucket_contents *next;	/* Link to next hashed key in this bucket. */
-  char *key;			/* What we look up. */
-  PTR_T data;			/* What we really want. */
-  unsigned int khash;		/* What key hashes to */
-  int times_found;		/* Number of times this item has been found. */
-} BUCKET_CONTENTS;
-
-typedef struct hash_table {
-  BUCKET_CONTENTS **bucket_array;	/* Where the data is kept. */
-  int nbuckets;			/* How many buckets does this table have. */
-  int nentries;			/* How many entries does this table have. */
-} HASH_TABLE;
-
-typedef int hash_wfunc PARAMS((BUCKET_CONTENTS *));
-
-/* Operations on tables as a whole */
-extern HASH_TABLE *hash_create PARAMS((int));
-extern HASH_TABLE *hash_copy PARAMS((HASH_TABLE *, sh_string_func_t *));
-extern void hash_flush PARAMS((HASH_TABLE *, sh_free_func_t *));
-extern void hash_dispose PARAMS((HASH_TABLE *));
-extern void hash_walk PARAMS((HASH_TABLE *, hash_wfunc *));
-
-/* Operations to extract information from or pieces of tables */
-extern int hash_bucket PARAMS((const char *, HASH_TABLE *));
-extern int hash_size PARAMS((HASH_TABLE *));
-
-/* Operations on hash table entries */
-extern BUCKET_CONTENTS *hash_search PARAMS((const char *, HASH_TABLE *, int));
-extern BUCKET_CONTENTS *hash_insert PARAMS((char *, HASH_TABLE *, int));
-extern BUCKET_CONTENTS *hash_remove PARAMS((const char *, HASH_TABLE *, int));
-
-/* Miscellaneous */
-extern unsigned int hash_string PARAMS((const char *));
-
-/* Redefine the function as a macro for speed. */
-#define hash_items(bucket, table) \
-	((table && (bucket < table->nbuckets)) ?  \
-		table->bucket_array[bucket] : \
-		(BUCKET_CONTENTS *)NULL)
-
-/* Default number of buckets in the hash table. */
-#define DEFAULT_HASH_BUCKETS 128	/* must be power of two */
-
-#define HASH_ENTRIES(ht)	((ht) ? (ht)->nentries : 0)
-
-/* flags for hash_search and hash_insert */
-#define HASH_NOSRCH	0x01
-#define HASH_CREATE	0x02
-
-#if !defined (NULL)
-#  if defined (__STDC__)
-#    define NULL ((void *) 0)
-#  else
-#    define NULL 0x0
-#  endif /* !__STDC__ */
-#endif /* !NULL */
-
-#endif /* _HASHLIB_H */
diff --git a/third_party/bash/input.c b/third_party/bash/input.c
deleted file mode 100644
index 7b439f8c8..000000000
--- a/third_party/bash/input.c
+++ /dev/null
@@ -1,677 +0,0 @@
-/* input.c -- functions to perform buffered input with synchronization. */
-
-/* Copyright (C) 1992-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-#include "filecntl.h"
-#include "posixstat.h"
-#include <stdio.h>
-#include <errno.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "input.h"
-#include "externs.h"
-#include "trap.h"
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#if defined (EAGAIN)
-#  define X_EAGAIN EAGAIN
-#else
-#  define X_EAGAIN -99
-#endif
-
-#if defined (EWOULDBLOCK)
-#  define X_EWOULDBLOCK EWOULDBLOCK
-#else
-#  define X_EWOULDBLOCK -99
-#endif
-
-extern void termsig_handler PARAMS((int));
-
-/* Functions to handle reading input on systems that don't restart read(2)
-   if a signal is received. */
-
-static char localbuf[1024];
-static int local_index = 0, local_bufused = 0;
-
-/* Posix and USG systems do not guarantee to restart read () if it is
-   interrupted by a signal.  We do the read ourselves, and restart it
-   if it returns EINTR. */
-int
-getc_with_restart (stream)
-     FILE *stream;
-{
-  unsigned char uc;
-
-  CHECK_TERMSIG;
-
-  /* Try local buffering to reduce the number of read(2) calls. */
-  if (local_index == local_bufused || local_bufused == 0)
-    {
-      while (1)
-	{
-	  QUIT;
-	  run_pending_traps ();
-
-	  local_bufused = read (fileno (stream), localbuf, sizeof(localbuf));
-	  if (local_bufused > 0)
-	    break;
-	  else if (local_bufused == 0)
-	    {
-	      local_index = 0;
-	      return EOF;
-	    }
-	  else if (errno == X_EAGAIN || errno == X_EWOULDBLOCK)
-	    {
-	      if (sh_unset_nodelay_mode (fileno (stream)) < 0)
-		{
-		  sys_error (_("cannot reset nodelay mode for fd %d"), fileno (stream));
-		  local_index = local_bufused = 0;
-		  return EOF;
-		}
-	      continue;
-	    }
-	  else if (errno != EINTR)
-	    {
-	      local_index = local_bufused = 0;
-	      return EOF;
-	    }
-	  else if (interrupt_state || terminating_signal)	/* QUIT; */
-	    local_index = local_bufused = 0;
-	}
-      local_index = 0;
-    }
-  uc = localbuf[local_index++];
-  return uc;
-}
-
-int
-ungetc_with_restart (c, stream)
-     int c;
-     FILE *stream;
-{
-  if (local_index == 0 || c == EOF)
-    return EOF;
-  localbuf[--local_index] = c;
-  return c;
-}
-
-#if defined (BUFFERED_INPUT)
-
-/* A facility similar to stdio, but input-only. */
-
-#if defined (USING_BASH_MALLOC)
-#  define MAX_INPUT_BUFFER_SIZE	8172
-#else
-#  define MAX_INPUT_BUFFER_SIZE	8192
-#endif
-
-#if !defined (SEEK_CUR)
-#  define SEEK_CUR 1
-#endif /* !SEEK_CUR */
-
-#ifdef max
-#  undef max
-#endif
-#define max(a, b)	(((a) > (b)) ? (a) : (b))
-#ifdef min
-#  undef min
-#endif
-#define min(a, b)	((a) > (b) ? (b) : (a))
-
-int bash_input_fd_changed;
-
-/* This provides a way to map from a file descriptor to the buffer
-   associated with that file descriptor, rather than just the other
-   way around.  This is needed so that buffers are managed properly
-   in constructs like 3<&4.  buffers[x]->b_fd == x -- that is how the
-   correspondence is maintained. */
-static BUFFERED_STREAM **buffers = (BUFFERED_STREAM **)NULL;
-static int nbuffers;
-
-#define ALLOCATE_BUFFERS(n) \
-	do { if ((n) >= nbuffers) allocate_buffers (n); } while (0)
-
-/* Make sure `buffers' has at least N elements. */
-static void
-allocate_buffers (n)
-     int n;
-{
-  register int i, orig_nbuffers;
-
-  orig_nbuffers = nbuffers;
-  nbuffers = n + 20;
-  buffers = (BUFFERED_STREAM **)xrealloc
-    (buffers, nbuffers * sizeof (BUFFERED_STREAM *));
-
-  /* Zero out the new buffers. */
-  for (i = orig_nbuffers; i < nbuffers; i++)
-    buffers[i] = (BUFFERED_STREAM *)NULL;
-}
-
-/* Construct and return a BUFFERED_STREAM corresponding to file descriptor
-   FD, using BUFFER. */
-static BUFFERED_STREAM *
-make_buffered_stream (fd, buffer, bufsize)
-     int fd;
-     char *buffer;
-     size_t bufsize;
-{
-  BUFFERED_STREAM *bp;
-
-  bp = (BUFFERED_STREAM *)xmalloc (sizeof (BUFFERED_STREAM));
-  ALLOCATE_BUFFERS (fd);
-  buffers[fd] = bp;
-  bp->b_fd = fd;
-  bp->b_buffer = buffer;
-  bp->b_size = bufsize;
-  bp->b_used = bp->b_inputp = bp->b_flag = 0;
-  if (bufsize == 1)
-    bp->b_flag |= B_UNBUFF;
-  if (O_TEXT && (fcntl (fd, F_GETFL) & O_TEXT) != 0)
-    bp->b_flag |= B_TEXT;
-  return (bp);
-}
-
-/* Allocate a new BUFFERED_STREAM, copy BP to it, and return the new copy. */
-static BUFFERED_STREAM *
-copy_buffered_stream (bp)
-     BUFFERED_STREAM *bp;
-{
-  BUFFERED_STREAM *nbp;
-
-  if (!bp)
-    return ((BUFFERED_STREAM *)NULL);
-
-  nbp = (BUFFERED_STREAM *)xmalloc (sizeof (BUFFERED_STREAM));
-  xbcopy ((char *)bp, (char *)nbp, sizeof (BUFFERED_STREAM));
-  return (nbp);
-}
-
-int
-set_bash_input_fd (fd)
-     int fd;
-{
-  if (bash_input.type == st_bstream)
-    bash_input.location.buffered_fd = fd;
-  else if (interactive_shell == 0)
-    default_buffered_input = fd;
-  return 0;
-}
-
-int
-fd_is_bash_input (fd)
-     int fd;
-{
-  if (bash_input.type == st_bstream && bash_input.location.buffered_fd == fd)
-    return 1;
-  else if (interactive_shell == 0 && default_buffered_input == fd)
-    return 1;
-  return 0;
-}
-
-/* Save the buffered stream corresponding to file descriptor FD (which bash
-   is using to read input) to a buffered stream associated with NEW_FD.  If
-   NEW_FD is -1, a new file descriptor is allocated with fcntl.  The new
-   file descriptor is returned on success, -1 on error. */
-int
-save_bash_input (fd, new_fd)
-     int fd, new_fd;
-{
-  int nfd;
-
-  /* Sync the stream so we can re-read from the new file descriptor.  We
-     might be able to avoid this by copying the buffered stream verbatim
-     to the new file descriptor. */
-  if (buffers[fd])
-    sync_buffered_stream (fd);
-
-  /* Now take care of duplicating the file descriptor that bash is
-     using for input, so we can reinitialize it later. */
-  nfd = (new_fd == -1) ? fcntl (fd, F_DUPFD, 10) : new_fd;
-  if (nfd == -1)
-    {
-      if (fcntl (fd, F_GETFD, 0) == 0)
-	sys_error (_("cannot allocate new file descriptor for bash input from fd %d"), fd);
-      return -1;
-    }
-
-  if (nfd < nbuffers && buffers[nfd])
-    {
-      /* What's this?  A stray buffer without an associated open file
-	 descriptor?  Free up the buffer and report the error. */
-      internal_error (_("save_bash_input: buffer already exists for new fd %d"), nfd);
-      if (buffers[nfd]->b_flag & B_SHAREDBUF)
-	buffers[nfd]->b_buffer = (char *)NULL;
-      free_buffered_stream (buffers[nfd]);
-    }
-
-  /* Reinitialize bash_input.location. */
-  if (bash_input.type == st_bstream)
-    {
-      bash_input.location.buffered_fd = nfd;
-      fd_to_buffered_stream (nfd);
-      close_buffered_fd (fd);	/* XXX */
-    }
-  else
-    /* If the current input type is not a buffered stream, but the shell
-       is not interactive and therefore using a buffered stream to read
-       input (e.g. with an `eval exec 3>output' inside a script), note
-       that the input fd has been changed.  pop_stream() looks at this
-       value and adjusts the input fd to the new value of
-       default_buffered_input accordingly. */
-    bash_input_fd_changed++;
-
-  if (default_buffered_input == fd)
-    default_buffered_input = nfd;
-
-  SET_CLOSE_ON_EXEC (nfd);
-  return nfd;
-}
-
-/* Check that file descriptor FD is not the one that bash is currently
-   using to read input from a script.  FD is about to be duplicated onto,
-   which means that the kernel will close it for us.  If FD is the bash
-   input file descriptor, we need to seek backwards in the script (if
-   possible and necessary -- scripts read from stdin are still unbuffered),
-   allocate a new file descriptor to use for bash input, and re-initialize
-   the buffered stream.  Make sure the file descriptor used to save bash
-   input is set close-on-exec. Returns 0 on success, -1 on failure.  This
-   works only if fd is > 0 -- if fd == 0 and bash is reading input from
-   fd 0, sync_buffered_stream is used instead, to cooperate with input
-   redirection (look at redir.c:add_undo_redirect()). */
-int
-check_bash_input (fd)
-     int fd;
-{
-  if (fd_is_bash_input (fd))
-    {
-      if (fd > 0)
-	return ((save_bash_input (fd, -1) == -1) ? -1 : 0);
-      else if (fd == 0)
-        return ((sync_buffered_stream (fd) == -1) ? -1 : 0);
-    }
-  return 0;
-}
-      
-/* This is the buffered stream analogue of dup2(fd1, fd2).  The
-   BUFFERED_STREAM corresponding to fd2 is deallocated, if one exists.
-   BUFFERS[fd1] is copied to BUFFERS[fd2].  This is called by the
-   redirect code for constructs like 4<&0 and 3</etc/rc.local. */
-int
-duplicate_buffered_stream (fd1, fd2)
-     int fd1, fd2;
-{
-  int is_bash_input, m;
-
-  if (fd1 == fd2)
-    return 0;
-
-  m = max (fd1, fd2);
-  ALLOCATE_BUFFERS (m);
-
-  /* If FD2 is the file descriptor bash is currently using for shell input,
-     we need to do some extra work to make sure that the buffered stream
-     actually exists (it might not if fd1 was not active, and the copy
-     didn't actually do anything). */
-  is_bash_input = (bash_input.type == st_bstream) &&
-		  (bash_input.location.buffered_fd == fd2);
-
-  if (buffers[fd2])
-    {
-      /* If the two objects share the same b_buffer, don't free it. */
-      if (buffers[fd1] && buffers[fd1]->b_buffer && buffers[fd1]->b_buffer == buffers[fd2]->b_buffer)
-	buffers[fd2] = (BUFFERED_STREAM *)NULL;
-      /* If this buffer is shared with another fd, don't free the buffer */
-      else if (buffers[fd2]->b_flag & B_SHAREDBUF)
-	{
-	  buffers[fd2]->b_buffer = (char *)NULL;
-	  free_buffered_stream (buffers[fd2]);
-	}
-      else
-	free_buffered_stream (buffers[fd2]);
-    }
-  buffers[fd2] = copy_buffered_stream (buffers[fd1]);
-  if (buffers[fd2])
-    buffers[fd2]->b_fd = fd2;
-
-  if (is_bash_input)
-    {
-      if (!buffers[fd2])
-	fd_to_buffered_stream (fd2);
-      buffers[fd2]->b_flag |= B_WASBASHINPUT;
-    }
-
-  if (fd_is_bash_input (fd1) || (buffers[fd1] && (buffers[fd1]->b_flag & B_SHAREDBUF)))
-    buffers[fd2]->b_flag |= B_SHAREDBUF;
-
-  return (fd2);
-}
-
-/* Return 1 if a seek on FD will succeed. */
-#define fd_is_seekable(fd) (lseek ((fd), 0L, SEEK_CUR) >= 0)
-
-/* Take FD, a file descriptor, and create and return a buffered stream
-   corresponding to it.  If something is wrong and the file descriptor
-   is invalid, return a NULL stream. */
-BUFFERED_STREAM *
-fd_to_buffered_stream (fd)
-     int fd;
-{
-  char *buffer;
-  size_t size;
-  struct stat sb;
-
-  if (fstat (fd, &sb) < 0)
-    {
-      close (fd);
-      return ((BUFFERED_STREAM *)NULL);
-    }
-
-  size = (fd_is_seekable (fd)) ? min (sb.st_size, MAX_INPUT_BUFFER_SIZE) : 1;
-  if (size == 0)
-    size = 1;
-  buffer = (char *)xmalloc (size);
-
-  return (make_buffered_stream (fd, buffer, size));
-}
-
-/* Return a buffered stream corresponding to FILE, a file name. */
-BUFFERED_STREAM *
-open_buffered_stream (file)
-     char *file;
-{
-  int fd;
-
-  fd = open (file, O_RDONLY);
-  return ((fd >= 0) ? fd_to_buffered_stream (fd) : (BUFFERED_STREAM *)NULL);
-}
-
-/* Deallocate a buffered stream and free up its resources.  Make sure we
-   zero out the slot in BUFFERS that points to BP. */
-void
-free_buffered_stream (bp)
-     BUFFERED_STREAM *bp;
-{
-  int n;
-
-  if (!bp)
-    return;
-
-  n = bp->b_fd;
-  if (bp->b_buffer)
-    free (bp->b_buffer);
-  free (bp);
-  buffers[n] = (BUFFERED_STREAM *)NULL;
-}
-
-/* Close the file descriptor associated with BP, a buffered stream, and free
-   up the stream.  Return the status of closing BP's file descriptor. */
-int
-close_buffered_stream (bp)
-     BUFFERED_STREAM *bp;
-{
-  int fd;
-
-  if (!bp)
-    return (0);
-  fd = bp->b_fd;
-  if (bp->b_flag & B_SHAREDBUF)
-    bp->b_buffer = (char *)NULL;
-  free_buffered_stream (bp);
-  return (close (fd));
-}
-
-/* Deallocate the buffered stream associated with file descriptor FD, and
-   close FD.  Return the status of the close on FD. */
-int
-close_buffered_fd (fd)
-     int fd;
-{
-  if (fd < 0)
-    {
-      errno = EBADF;
-      return -1;
-    }
-  if (fd >= nbuffers || !buffers || !buffers[fd])
-    return (close (fd));
-  return (close_buffered_stream (buffers[fd]));
-}
-
-/* Make the BUFFERED_STREAM associated with buffers[FD] be BP, and return
-   the old BUFFERED_STREAM. */
-BUFFERED_STREAM *
-set_buffered_stream (fd, bp)
-     int fd;
-     BUFFERED_STREAM *bp;
-{
-  BUFFERED_STREAM *ret;
-
-  ret = buffers[fd];
-  buffers[fd] = bp;
-  return ret;
-}
-
-/* Read a buffer full of characters from BP, a buffered stream. */
-static int
-b_fill_buffer (bp)
-     BUFFERED_STREAM *bp;
-{
-  ssize_t nr;
-  off_t o;
-
-  CHECK_TERMSIG;
-  /* In an environment where text and binary files are treated differently,
-     compensate for lseek() on text files returning an offset different from
-     the count of characters read() returns.  Text-mode streams have to be
-     treated as unbuffered. */
-  if ((bp->b_flag & (B_TEXT | B_UNBUFF)) == B_TEXT)
-    {
-      o = lseek (bp->b_fd, 0, SEEK_CUR);
-      nr = zread (bp->b_fd, bp->b_buffer, bp->b_size);
-      if (nr > 0 && nr < lseek (bp->b_fd, 0, SEEK_CUR) - o)
-	{
-	  lseek (bp->b_fd, o, SEEK_SET);
-	  bp->b_flag |= B_UNBUFF;
-	  bp->b_size = 1;
-	  nr = zread (bp->b_fd, bp->b_buffer, bp->b_size);
-	}
-    }
-  else
-    nr = zread (bp->b_fd, bp->b_buffer, bp->b_size);
-  if (nr <= 0)
-    {
-      bp->b_used = bp->b_inputp = 0;
-      bp->b_buffer[0] = 0;
-      if (nr == 0)
-	bp->b_flag |= B_EOF;
-      else
-	bp->b_flag |= B_ERROR;
-      return (EOF);
-    }
-
-  bp->b_used = nr;
-  bp->b_inputp = 0;
-  return (bp->b_buffer[bp->b_inputp++] & 0xFF);
-}
-
-/* Get a character from buffered stream BP. */
-#define bufstream_getc(bp) \
-  (bp->b_inputp == bp->b_used || !bp->b_used) \
-  		? b_fill_buffer (bp) \
-		: bp->b_buffer[bp->b_inputp++] & 0xFF
-
-/* Push C back onto buffered stream BP. */
-static int
-bufstream_ungetc(c, bp)
-     int c;
-     BUFFERED_STREAM *bp;
-{
-  if (c == EOF || bp == 0 || bp->b_inputp == 0)
-    return (EOF);
-
-  bp->b_buffer[--bp->b_inputp] = c;
-  return (c);
-}
-
-/* Seek backwards on file BFD to synchronize what we've read so far
-   with the underlying file pointer. */
-int
-sync_buffered_stream (bfd)
-     int bfd;
-{
-  BUFFERED_STREAM *bp;
-  off_t chars_left;
-
-  if (buffers == 0 || (bp = buffers[bfd]) == 0)
-    return (-1);
-
-  chars_left = bp->b_used - bp->b_inputp;
-  if (chars_left)
-    lseek (bp->b_fd, -chars_left, SEEK_CUR);
-  bp->b_used = bp->b_inputp = 0;
-  return (0);
-}
-
-int
-buffered_getchar ()
-{
-  CHECK_TERMSIG;
-
-  if (bash_input.location.buffered_fd < 0 || buffers[bash_input.location.buffered_fd] == 0)
-    return EOF;
-
-#if !defined (DJGPP)
-  return (bufstream_getc (buffers[bash_input.location.buffered_fd]));
-#else
-  /* On DJGPP, ignore \r. */
-  int ch;
-  while ((ch = bufstream_getc (buffers[bash_input.location.buffered_fd])) == '\r')
-    ;
-  return ch;
-#endif
-}
-
-int
-buffered_ungetchar (c)
-     int c;
-{
-  return (bufstream_ungetc (c, buffers[bash_input.location.buffered_fd]));
-}
-
-/* Make input come from file descriptor BFD through a buffered stream. */
-void
-with_input_from_buffered_stream (bfd, name)
-     int bfd;
-     char *name;
-{
-  INPUT_STREAM location;
-  BUFFERED_STREAM *bp;
-
-  location.buffered_fd = bfd;
-  /* Make sure the buffered stream exists. */
-  bp = fd_to_buffered_stream (bfd);
-  init_yy_io (bp == 0 ? return_EOF : buffered_getchar,
-	      buffered_ungetchar, st_bstream, name, location);
-}
-
-#if defined (TEST)
-void *
-xmalloc(s)
-int s;
-{
-	return (malloc (s));
-}
-
-void *
-xrealloc(s, size)
-char	*s;
-int	size;
-{
-	if (!s)
-		return(malloc (size));
-	else
-		return(realloc (s, size));
-}
-
-void
-init_yy_io ()
-{
-}
-
-process(bp)
-BUFFERED_STREAM *bp;
-{
-	int c;
-
-	while ((c = bufstream_getc(bp)) != EOF)
-		putchar(c);
-}
-
-BASH_INPUT bash_input;
-
-struct stat dsb;		/* can be used from gdb */
-
-/* imitate /bin/cat */
-main(argc, argv)
-int	argc;
-char	**argv;
-{
-	register int i;
-	BUFFERED_STREAM *bp;
-
-	if (argc == 1) {
-		bp = fd_to_buffered_stream (0);
-		process(bp);
-		exit(0);
-	}
-	for (i = 1; i < argc; i++) {
-		if (argv[i][0] == '-' && argv[i][1] == '\0') {
-			bp = fd_to_buffered_stream (0);
-			if (!bp)
-				continue;
-			process(bp);
-			free_buffered_stream (bp);
-		} else {
-			bp = open_buffered_stream (argv[i]);
-			if (!bp)
-				continue;
-			process(bp);
-			close_buffered_stream (bp);
-		}
-	}
-	exit(0);
-}
-#endif /* TEST */
-#endif /* BUFFERED_INPUT */
diff --git a/third_party/bash/input.h b/third_party/bash/input.h
deleted file mode 100644
index cb3eee425..000000000
--- a/third_party/bash/input.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/* input.h -- Structures and unions used for reading input. */
-
-/* Copyright (C) 1993-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_INPUT_H_)
-#define _INPUT_H_
-
-#include "stdc.h"
-
-/* Function pointers can be declared as (Function *)foo. */
-#if !defined (_FUNCTION_DEF)
-#  define _FUNCTION_DEF
-typedef int Function ();
-typedef void VFunction ();
-typedef char *CPFunction ();		/* no longer used */
-typedef char **CPPFunction ();		/* no longer used */
-#endif /* _FUNCTION_DEF */
-
-typedef int sh_cget_func_t PARAMS((void));		/* sh_ivoidfunc_t */
-typedef int sh_cunget_func_t PARAMS((int));	/* sh_intfunc_t */
-
-enum stream_type {st_none, st_stdin, st_stream, st_string, st_bstream};
-
-#if defined (BUFFERED_INPUT)
-
-/* Possible values for b_flag. */
-#undef B_EOF
-#undef B_ERROR		/* There are some systems with this define */
-#undef B_UNBUFF
-
-#define B_EOF		0x01
-#define B_ERROR		0x02
-#define B_UNBUFF	0x04
-#define B_WASBASHINPUT	0x08
-#define B_TEXT		0x10
-#define B_SHAREDBUF	0x20	/* shared input buffer */
-
-/* A buffered stream.  Like a FILE *, but with our own buffering and
-   synchronization.  Look in input.c for the implementation. */
-typedef struct BSTREAM
-{
-  int	 b_fd;
-  char	*b_buffer;		/* The buffer that holds characters read. */
-  size_t b_size;		/* How big the buffer is. */
-  size_t b_used;		/* How much of the buffer we're using, */
-  int	 b_flag;		/* Flag values. */
-  size_t b_inputp;		/* The input pointer, index into b_buffer. */
-} BUFFERED_STREAM;
-
-#if 0
-extern BUFFERED_STREAM **buffers;
-#endif
-
-extern int default_buffered_input;
-extern int bash_input_fd_changed;
-
-#endif /* BUFFERED_INPUT */
-
-typedef union {
-  FILE *file;
-  char *string;
-#if defined (BUFFERED_INPUT)
-  int buffered_fd;
-#endif
-} INPUT_STREAM;
-
-typedef struct {
-  enum stream_type type;
-  char *name;
-  INPUT_STREAM location;
-  sh_cget_func_t *getter;
-  sh_cunget_func_t *ungetter;
-} BASH_INPUT;
-
-extern BASH_INPUT bash_input;
-
-/* Functions from parse.y whose use directly or indirectly depends on the
-   definitions in this file. */
-extern void initialize_bash_input PARAMS((void));
-extern void init_yy_io PARAMS((sh_cget_func_t *, sh_cunget_func_t *, enum stream_type, const char *, INPUT_STREAM));
-extern char *yy_input_name PARAMS((void));
-extern void with_input_from_stdin PARAMS((void));
-extern void with_input_from_string PARAMS((char *, const char *));
-extern void with_input_from_stream PARAMS((FILE *, const char *));
-extern void push_stream PARAMS((int));
-extern void pop_stream PARAMS((void));
-extern int stream_on_stack PARAMS((enum stream_type));
-extern char *read_secondary_line PARAMS((int));
-extern int find_reserved_word PARAMS((char *));
-extern void gather_here_documents PARAMS((void));
-extern void execute_variable_command PARAMS((char *, char *));
-
-extern int *save_token_state PARAMS((void));
-extern void restore_token_state PARAMS((int *));
-
-/* Functions from input.c */
-extern int getc_with_restart PARAMS((FILE *));
-extern int ungetc_with_restart PARAMS((int, FILE *));
-
-#if defined (BUFFERED_INPUT)
-/* Functions from input.c. */
-extern int fd_is_bash_input PARAMS((int));
-extern int set_bash_input_fd PARAMS((int));
-extern int save_bash_input PARAMS((int, int));
-extern int check_bash_input PARAMS((int));
-extern int duplicate_buffered_stream PARAMS((int, int));
-extern BUFFERED_STREAM *fd_to_buffered_stream PARAMS((int));
-extern BUFFERED_STREAM *set_buffered_stream PARAMS((int, BUFFERED_STREAM *));
-extern BUFFERED_STREAM *open_buffered_stream PARAMS((char *));
-extern void free_buffered_stream PARAMS((BUFFERED_STREAM *));
-extern int close_buffered_stream PARAMS((BUFFERED_STREAM *));
-extern int close_buffered_fd PARAMS((int));
-extern int sync_buffered_stream PARAMS((int));
-extern int buffered_getchar PARAMS((void));
-extern int buffered_ungetchar PARAMS((int));
-extern void with_input_from_buffered_stream PARAMS((int, char *));
-#endif /* BUFFERED_INPUT */
-
-#endif /* _INPUT_H_ */
diff --git a/third_party/bash/input_avail.c b/third_party/bash/input_avail.c
deleted file mode 100644
index 36981cf26..000000000
--- a/third_party/bash/input_avail.c
+++ /dev/null
@@ -1,165 +0,0 @@
-/* input_avail.c -- check whether or not data is available for reading on a
-		    specified file descriptor. */
-
-/* Copyright (C) 2008,2009-2019 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if defined (__TANDEM)
-#  include <floss.h>
-#endif
-
-#if defined (HAVE_CONFIG_H)
-#  include "config.h"
-#endif
-
-#include <sys/types.h>
-#include <fcntl.h>
-#if defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif /* HAVE_SYS_FILE_H */
-
-#if defined (HAVE_PSELECT)
-#  include <signal.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif /* HAVE_UNISTD_H */
-
-#include "bashansi.h"
-
-#include "posixselect.h"
-
-#if defined (FIONREAD_IN_SYS_IOCTL)
-#  include <sys/ioctl.h>
-#endif
-
-#include <stdio.h>
-#include <errno.h>
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#if !defined (O_NDELAY) && defined (O_NONBLOCK)
-#  define O_NDELAY O_NONBLOCK	/* Posix style */
-#endif
-
-/* Return >= 1 if select/FIONREAD indicates data available for reading on
-   file descriptor FD; 0 if no data available.  Return -1 on error. */
-int
-input_avail (fd)
-     int fd;
-{
-  int result, chars_avail;
-#if defined(HAVE_SELECT)
-  fd_set readfds, exceptfds;
-  struct timeval timeout;
-#endif
-
-  if (fd < 0)
-    return -1;
-
-  chars_avail = 0;
-
-#if defined (HAVE_SELECT)
-  FD_ZERO (&readfds);
-  FD_ZERO (&exceptfds);
-  FD_SET (fd, &readfds);
-  FD_SET (fd, &exceptfds);
-  timeout.tv_sec = 0;
-  timeout.tv_usec = 0;
-  result = select (fd + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout);
-  return ((result <= 0) ? 0 : 1);
-#endif
-
-#if defined (FIONREAD)
-  errno = 0;
-  result = ioctl (fd, FIONREAD, &chars_avail);
-  if (result == -1 && errno == EIO)
-    return -1;
-  return (chars_avail);
-#endif
-
-  return 0;
-}
-
-/* Wait until NCHARS are available for reading on file descriptor FD.
-   This can wait indefinitely. Return -1 on error. */
-int
-nchars_avail (fd, nchars)
-     int fd;
-     int nchars;
-{
-  int result, chars_avail;
-#if defined(HAVE_SELECT)
-  fd_set readfds, exceptfds;
-#endif
-#if defined (HAVE_PSELECT) || defined (HAVE_SELECT)
-  sigset_t set, oset;
-#endif
-
-  if (fd < 0 || nchars < 0)
-    return -1;
-  if (nchars == 0)
-    return (input_avail (fd));
-
-  chars_avail = 0;
-
-#if defined (HAVE_SELECT)
-  FD_ZERO (&readfds);
-  FD_ZERO (&exceptfds);
-  FD_SET (fd, &readfds);
-  FD_SET (fd, &exceptfds);
-#endif
-#if defined (HAVE_SELECT) || defined (HAVE_PSELECT)
-  sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
-#  ifdef SIGCHLD
-  sigaddset (&set, SIGCHLD);
-#  endif
-  sigemptyset (&oset);
-#endif
-
-  while (1)
-    {
-      result = 0;
-#if defined (HAVE_PSELECT)
-      /* XXX - use pselect(2) to block SIGCHLD atomically */
-      result = pselect (fd + 1, &readfds, (fd_set *)NULL, &exceptfds, (struct timespec *)NULL, &set);
-#elif defined (HAVE_SELECT)
-      sigprocmask (SIG_BLOCK, &set, &oset);
-      result = select (fd + 1, &readfds, (fd_set *)NULL, &exceptfds, (struct timeval *)NULL);
-      sigprocmask (SIG_BLOCK, &oset, (sigset_t *)NULL);
-#endif
-      if (result < 0)
-        return -1;
-
-#if defined (FIONREAD)
-      errno = 0;
-      result = ioctl (fd, FIONREAD, &chars_avail);
-      if (result == -1 && errno == EIO)
-        return -1;
-      if (chars_avail >= nchars)
-        break;
-#else
-      break;
-#endif
-    }
-
-  return 0;
-}
diff --git a/third_party/bash/itos.c b/third_party/bash/itos.c
deleted file mode 100644
index ecdc99686..000000000
--- a/third_party/bash/itos.c
+++ /dev/null
@@ -1,84 +0,0 @@
-/* itos.c -- Convert integer to string. */
-
-/* Copyright (C) 1998-2002 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifdef HAVE_CONFIG_H
-#  include "config.h"
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "shell.h"
-
-char *
-inttostr (i, buf, len)
-     intmax_t i;
-     char *buf;
-     size_t len;
-{
-  return (fmtumax (i, 10, buf, len, 0));
-}
-
-/* Integer to string conversion.  This conses the string; the
-   caller should free it. */
-char *
-itos (i)
-     intmax_t i;
-{
-  char *p, lbuf[INT_STRLEN_BOUND(intmax_t) + 1];
-
-  p = fmtumax (i, 10, lbuf, sizeof(lbuf), 0);
-  return (savestring (p));
-}
-
-/* Integer to string conversion.  This conses the string using strdup;
-   caller should free it and be prepared to deal with NULL return. */
-char *
-mitos (i)
-     intmax_t i;
-{
-  char *p, lbuf[INT_STRLEN_BOUND(intmax_t) + 1];
-
-  p = fmtumax (i, 10, lbuf, sizeof(lbuf), 0);
-  return (strdup (p));
-}
-
-char *
-uinttostr (i, buf, len)
-     uintmax_t i;
-     char *buf;
-     size_t len;
-{
-  return (fmtumax (i, 10, buf, len, FL_UNSIGNED));
-}
-
-/* Integer to string conversion.  This conses the string; the
-   caller should free it. */
-char *
-uitos (i)
-     uintmax_t i;
-{
-  char *p, lbuf[INT_STRLEN_BOUND(uintmax_t) + 1];
-
-  p = fmtumax (i, 10, lbuf, sizeof(lbuf), FL_UNSIGNED);
-  return (savestring (p));
-}
diff --git a/third_party/bash/jobs.c b/third_party/bash/jobs.c
deleted file mode 100644
index c6e9eaf3f..000000000
--- a/third_party/bash/jobs.c
+++ /dev/null
@@ -1,5119 +0,0 @@
-/* jobs.c - functions that make children, remember them, and handle their termination. */
-
-/* This file works with both POSIX and BSD systems.  It implements job
-   control. */
-
-/* Copyright (C) 1989-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "trap.h"
-#include <stdio.h>
-#include <signal.h>
-#include <errno.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "posixtime.h"
-
-#if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
-#  include <sys/resource.h>
-#endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */
-
-#if defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-
-#include "filecntl.h"
-#include <sys/ioctl.h>
-#if defined (HAVE_SYS_PARAM_H)
-#include <sys/param.h>
-#endif
-
-#if defined (BUFFERED_INPUT)
-#  include "input.h"
-#endif
-
-/* Need to include this up here for *_TTY_DRIVER definitions. */
-#include "shtty.h"
-
-/* Define this if your output is getting swallowed.  It's a no-op on
-   machines with the termio or termios tty drivers. */
-/* #define DRAIN_OUTPUT */
-
-/* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
-#if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
-#  include <bsdtty.h>
-#endif /* hpux && !TERMIOS_TTY_DRIVER */
-
-#include "bashansi.h"
-#include "bashintl.h"
-#include "shell.h"
-#include "parser.h"
-#include "jobs.h"
-#include "execute_cmd.h"
-#include "flags.h"
-
-#include "typemax.h"
-
-#include "builtext.h"
-#include "common.h"
-
-#if defined (READLINE)
-# include "third_party/readline/readline.h"
-#endif
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#if !defined (HAVE_KILLPG)
-extern int killpg PARAMS((pid_t, int));
-#endif
-
-#if !DEFAULT_CHILD_MAX
-#  define DEFAULT_CHILD_MAX 4096
-#endif
-
-#if !MAX_CHILD_MAX
-#  define MAX_CHILD_MAX 32768
-#endif
-
-#if !defined (DEBUG)
-#define MAX_JOBS_IN_ARRAY 4096		/* production */
-#else
-#define MAX_JOBS_IN_ARRAY 128		/* testing */
-#endif
-
-/* XXX for now */
-#define PIDSTAT_TABLE_SZ 4096
-#define BGPIDS_TABLE_SZ 512
-
-/* Flag values for second argument to delete_job */
-#define DEL_WARNSTOPPED		1	/* warn about deleting stopped jobs */
-#define DEL_NOBGPID		2	/* don't add pgrp leader to bgpids */
-
-/* Take care of system dependencies that must be handled when waiting for
-   children.  The arguments to the WAITPID macro match those to the Posix.1
-   waitpid() function. */
-
-#if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
-#  define WAITPID(pid, statusp, options) \
-	wait3 ((union wait *)statusp, options, (struct rusage *)0)
-#else
-#  if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
-#    define WAITPID(pid, statusp, options) \
-	waitpid ((pid_t)pid, statusp, options)
-#  else
-#    if defined (HAVE_WAIT3)
-#      define WAITPID(pid, statusp, options) \
-	wait3 (statusp, options, (struct rusage *)0)
-#    else
-#      define WAITPID(pid, statusp, options) \
-	wait3 (statusp, options, (int *)0)
-#    endif /* HAVE_WAIT3 */
-#  endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
-#endif /* !(Ultrix && mips && _POSIX_VERSION) */
-
-/* getpgrp () varies between systems.  Even systems that claim to be
-   Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
-#if defined (GETPGRP_VOID)
-#  define getpgid(p) getpgrp ()
-#else
-#  define getpgid(p) getpgrp (p)
-#endif /* !GETPGRP_VOID */
-
-/* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
-   handler for SIGCHLD. */
-#if defined (MUST_REINSTALL_SIGHANDLERS)
-#  define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
-#else
-#  define REINSTALL_SIGCHLD_HANDLER
-#endif /* !MUST_REINSTALL_SIGHANDLERS */
-
-/* Some systems let waitpid(2) tell callers about stopped children. */
-#if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
-#  undef WCONTINUED
-#  define WCONTINUED 0
-#endif
-#if !defined (WIFCONTINUED)
-#  define WIFCONTINUED(s)	(0)
-#endif
-
-/* The number of additional slots to allocate when we run out. */
-#define JOB_SLOTS 8
-
-typedef int sh_job_map_func_t PARAMS((JOB *, int, int, int));
-
-/* Variables used here but defined in other files. */
-extern WORD_LIST *subst_assign_varlist;
-
-extern SigHandler **original_signals;
-
-extern void set_original_signal PARAMS((int, SigHandler *));
-
-static struct jobstats zerojs = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 };
-struct jobstats js = { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB, NO_JOB, 0, 0 };
-
-ps_index_t pidstat_table[PIDSTAT_TABLE_SZ];
-struct bgpids bgpids = { 0, 0, 0, 0 };
-
-struct procchain procsubs = { 0, 0, 0 };
-
-/* The array of known jobs. */
-JOB **jobs = (JOB **)NULL;
-
-#if 0
-/* The number of slots currently allocated to JOBS. */
-int job_slots = 0;
-#endif
-
-/* The controlling tty for this shell. */
-int shell_tty = -1;
-
-/* The shell's process group. */
-pid_t shell_pgrp = NO_PID;
-
-/* The terminal's process group. */
-pid_t terminal_pgrp = NO_PID;
-
-/* The process group of the shell's parent. */
-pid_t original_pgrp = NO_PID;
-
-/* The process group of the pipeline currently being made. */
-pid_t pipeline_pgrp = (pid_t)0;
-
-#if defined (PGRP_PIPE)
-/* Pipes which each shell uses to communicate with the process group leader
-   until all of the processes in a pipeline have been started.  Then the
-   process leader is allowed to continue. */
-int pgrp_pipe[2] = { -1, -1 };
-#endif
-
-/* Last child made by the shell.  */
-volatile pid_t last_made_pid = NO_PID;
-
-/* Pid of the last asynchronous child. */
-volatile pid_t last_asynchronous_pid = NO_PID;
-
-/* The pipeline currently being built. */
-PROCESS *the_pipeline = (PROCESS *)NULL;
-
-/* If this is non-zero, do job control. */
-int job_control = 1;
-
-/* Are we running in background? (terminal_pgrp != shell_pgrp) */
-int running_in_background = 0;
-
-/* Call this when you start making children. */
-int already_making_children = 0;
-
-/* If this is non-zero, $LINES and $COLUMNS are reset after every process
-   exits from get_tty_state(). */
-int check_window_size = CHECKWINSIZE_DEFAULT;
-
-PROCESS *last_procsub_child = (PROCESS *)NULL;
-
-/* Functions local to this file. */
-
-void debug_print_pgrps (void);
-
-static sighandler wait_sigint_handler PARAMS((int));
-static sighandler sigchld_handler PARAMS((int));
-static sighandler sigcont_sighandler PARAMS((int));
-static sighandler sigstop_sighandler PARAMS((int));
-
-static int waitchld PARAMS((pid_t, int));
-
-static PROCESS *find_pid_in_pipeline PARAMS((pid_t, PROCESS *, int));
-static PROCESS *find_pipeline PARAMS((pid_t, int, int *));
-static PROCESS *find_process PARAMS((pid_t, int, int *));
-
-static char *current_working_directory PARAMS((void));
-static char *job_working_directory PARAMS((void));
-static char *j_strsignal PARAMS((int));
-static char *printable_job_status PARAMS((int, PROCESS *, int));
-
-static PROCESS *find_last_proc PARAMS((int, int));
-static pid_t find_last_pid PARAMS((int, int));
-
-static int set_new_line_discipline PARAMS((int));
-static int map_over_jobs PARAMS((sh_job_map_func_t *, int, int));
-static int job_last_stopped PARAMS((int));
-static int job_last_running PARAMS((int));
-static int most_recent_job_in_state PARAMS((int, JOB_STATE));
-static int find_job PARAMS((pid_t, int, PROCESS **));
-static int print_job PARAMS((JOB *, int, int, int));
-static int process_exit_status PARAMS((WAIT));
-static int process_exit_signal PARAMS((WAIT));
-static int set_job_status_and_cleanup PARAMS((int));
-
-static WAIT job_signal_status PARAMS((int));
-static WAIT raw_job_exit_status PARAMS((int));
-
-static void notify_of_job_status PARAMS((void));
-static void reset_job_indices PARAMS((void));
-static void cleanup_dead_jobs PARAMS((void));
-static int processes_in_job PARAMS((int));
-static void realloc_jobs_list PARAMS((void));
-static int compact_jobs_list PARAMS((int));
-static void add_process PARAMS((char *, pid_t));
-static void print_pipeline PARAMS((PROCESS *, int, int, FILE *));
-static void pretty_print_job PARAMS((int, int, FILE *));
-static void set_current_job PARAMS((int));
-static void reset_current PARAMS((void));
-static void set_job_running PARAMS((int));
-static void setjstatus PARAMS((int));
-static int maybe_give_terminal_to PARAMS((pid_t, pid_t, int));
-static void mark_all_jobs_as_dead PARAMS((void));
-static void mark_dead_jobs_as_notified PARAMS((int));
-static void restore_sigint_handler PARAMS((void));
-#if defined (PGRP_PIPE)
-static void pipe_read PARAMS((int *));
-#endif
-
-/* Hash table manipulation */
-
-static ps_index_t *pshash_getbucket PARAMS((pid_t));
-static void pshash_delindex PARAMS((ps_index_t));
-
-/* Saved background process status management */
-static struct pidstat *bgp_add PARAMS((pid_t, int));
-static int bgp_delete PARAMS((pid_t));
-static void bgp_clear PARAMS((void));
-static int bgp_search PARAMS((pid_t));
-
-static struct pipeline_saver *alloc_pipeline_saver PARAMS((void));
-
-static ps_index_t bgp_getindex PARAMS((void));
-static void bgp_resize PARAMS((void));	/* XXX */
-
-#if defined (ARRAY_VARS)
-static int *pstatuses;		/* list of pipeline statuses */
-static int statsize;
-#endif
-
-/* Used to synchronize between wait_for and other functions and the SIGCHLD
-   signal handler. */
-static int sigchld;
-static int queue_sigchld;
-
-#define QUEUE_SIGCHLD(os)	(os) = sigchld, queue_sigchld++
-
-/* We set queue_sigchld around the call to waitchld to protect data structures
-   from a SIGCHLD arriving while waitchld is executing. */
-#define UNQUEUE_SIGCHLD(os) \
-	do { \
-	  queue_sigchld--; \
-	  if (queue_sigchld == 0 && os != sigchld) \
-	    { \
-	      queue_sigchld = 1; \
-	      waitchld (-1, 0); \
-	      queue_sigchld = 0; \
-	    } \
-	} while (0)
-
-static SigHandler *old_tstp, *old_ttou, *old_ttin;
-static SigHandler *old_cont = (SigHandler *)SIG_DFL;
-
-/* A place to temporarily save the current pipeline. */
-static struct pipeline_saver *saved_pipeline;
-static int saved_already_making_children;
-
-/* Set this to non-zero whenever you don't want the jobs list to change at
-   all: no jobs deleted and no status change notifications.  This is used,
-   for example, when executing SIGCHLD traps, which may run arbitrary
-   commands. */
-static int jobs_list_frozen;
-
-static char retcode_name_buffer[64];
-
-#if !defined (_POSIX_VERSION)
-
-/* These are definitions to map POSIX 1003.1 functions onto existing BSD
-   library functions and system calls. */
-#define setpgid(pid, pgrp)	setpgrp (pid, pgrp)
-#define tcsetpgrp(fd, pgrp)	ioctl ((fd), TIOCSPGRP, &(pgrp))
-
-pid_t
-tcgetpgrp (fd)
-     int fd;
-{
-  pid_t pgrp;
-
-  /* ioctl will handle setting errno correctly. */
-  if (ioctl (fd, TIOCGPGRP, &pgrp) < 0)
-    return (-1);
-  return (pgrp);
-}
-
-#endif /* !_POSIX_VERSION */
-
-/* Initialize the global job stats structure and other bookkeeping variables */
-void
-init_job_stats ()
-{
-  js = zerojs;
-}
-
-/* Return the working directory for the current process.  Unlike
-   job_working_directory, this does not call malloc (), nor do any
-   of the functions it calls.  This is so that it can safely be called
-   from a signal handler. */
-static char *
-current_working_directory ()
-{
-  char *dir;
-  static char d[PATH_MAX];
-
-  dir = get_string_value ("PWD");
-
-  if (dir == 0 && the_current_working_directory && no_symbolic_links)
-    dir = the_current_working_directory;
-
-  if (dir == 0)
-    {
-      dir = getcwd (d, sizeof(d));
-      if (dir)
-	dir = d;
-    }
-
-  return (dir == 0) ? "<unknown>" : dir;
-}
-
-/* Return the working directory for the current process. */
-static char *
-job_working_directory ()
-{
-  char *dir;
-
-  dir = get_string_value ("PWD");
-  if (dir)
-    return (savestring (dir));
-
-  dir = get_working_directory ("job-working-directory");
-  if (dir)
-    return (dir);
-
-  return (savestring ("<unknown>"));
-}
-
-void
-making_children ()
-{
-  if (already_making_children)
-    return;
-
-  already_making_children = 1;
-  start_pipeline ();
-}
-
-void
-stop_making_children ()
-{
-  already_making_children = 0;
-}
-
-void
-cleanup_the_pipeline ()
-{
-  PROCESS *disposer;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-  disposer = the_pipeline;
-  the_pipeline = (PROCESS *)NULL;
-  UNBLOCK_CHILD (oset);
-
-  if (disposer)
-    discard_pipeline (disposer);
-}
-
-/* Not used right now */
-void
-discard_last_procsub_child ()
-{
-  PROCESS *disposer;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-  disposer = last_procsub_child;
-  last_procsub_child = (PROCESS *)NULL;
-  UNBLOCK_CHILD (oset);
-
-  if (disposer)
-    discard_pipeline (disposer);
-}
-
-static struct pipeline_saver *
-alloc_pipeline_saver ()
-{
-  struct pipeline_saver *ret;
-
-  ret = (struct pipeline_saver *)xmalloc (sizeof (struct pipeline_saver));
-  ret->pipeline = 0;
-  ret->next = 0;
-  return ret;
-}
-
-void
-save_pipeline (clear)
-     int clear;
-{
-  sigset_t set, oset;
-  struct pipeline_saver *saver;
-
-  BLOCK_CHILD (set, oset);
-  saver = alloc_pipeline_saver ();
-  saver->pipeline = the_pipeline;
-  saver->next = saved_pipeline;
-  saved_pipeline = saver;
-  if (clear)
-    the_pipeline = (PROCESS *)NULL;
-  saved_already_making_children = already_making_children;
-  UNBLOCK_CHILD (oset);
-}
-
-PROCESS *
-restore_pipeline (discard)
-     int discard;
-{
-  PROCESS *old_pipeline;
-  sigset_t set, oset;
-  struct pipeline_saver *saver;
-
-  BLOCK_CHILD (set, oset);
-  old_pipeline = the_pipeline;
-  the_pipeline = saved_pipeline->pipeline;
-  saver = saved_pipeline;
-  saved_pipeline = saved_pipeline->next;
-  free (saver);
-  already_making_children = saved_already_making_children;
-  UNBLOCK_CHILD (oset);
-
-  if (discard && old_pipeline)
-    {
-      discard_pipeline (old_pipeline);
-      return ((PROCESS *)NULL);
-    }
-  return old_pipeline;
-}
-
-/* Start building a pipeline.  */
-void
-start_pipeline ()
-{
-  if (the_pipeline)
-    {
-      cleanup_the_pipeline ();
-      /* If job_control == 0, pipeline_pgrp will always be equal to shell_pgrp;
-	 if job_control != 0, pipeline_pgrp == shell_pgrp for command and
-	 process substitution, in which case we want it to be the same as
-	 shell_pgrp for the lifetime of this shell instance. */
-      if (pipeline_pgrp != shell_pgrp)
-	pipeline_pgrp = 0;
-#if defined (PGRP_PIPE)
-      sh_closepipe (pgrp_pipe);
-#endif
-    }
-
-#if defined (PGRP_PIPE)
-  if (job_control)
-    {
-      if (pipe (pgrp_pipe) == -1)
-	sys_error (_("start_pipeline: pgrp pipe"));
-    }
-#endif
-}
-
-/* Stop building a pipeline.  Install the process list in the job array.
-   This returns the index of the newly installed job.
-   DEFERRED is a command structure to be executed upon satisfactory
-   execution exit of this pipeline. */
-int
-stop_pipeline (async, deferred)
-     int async;
-     COMMAND *deferred;
-{
-  register int i, j;
-  JOB *newjob;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-
-#if defined (PGRP_PIPE)
-  /* The parent closes the process group synchronization pipe. */
-  sh_closepipe (pgrp_pipe);
-#endif
-
-  cleanup_dead_jobs ();
-
-  if (js.j_jobslots == 0)
-    {
-      js.j_jobslots = JOB_SLOTS;
-      jobs = (JOB **)xmalloc (js.j_jobslots * sizeof (JOB *));
-
-      /* Now blank out these new entries. */
-      for (i = 0; i < js.j_jobslots; i++)
-	jobs[i] = (JOB *)NULL;
-
-      js.j_firstj = js.j_lastj = js.j_njobs = 0;
-    }
-
-  /* Scan from the last slot backward, looking for the next free one. */
-  /* XXX - revisit this interactive assumption */
-  /* XXX - this way for now */
-  if (interactive)
-    {
-      for (i = js.j_jobslots; i; i--)
-	if (jobs[i - 1])
-	  break;
-    }
-  else
-    {
-#if 0
-      /* This wraps around, but makes it inconvenient to extend the array */
-      for (i = js.j_lastj+1; i != js.j_lastj; i++)
-	{
-	  if (i >= js.j_jobslots)
-	    i = 0;
-	  if (jobs[i] == 0)
-	    break;
-	}	
-      if (i == js.j_lastj)
-        i = js.j_jobslots;
-#else
-      /* This doesn't wrap around yet. */
-      for (i = js.j_lastj ? js.j_lastj + 1 : js.j_lastj; i < js.j_jobslots; i++)
-	if (jobs[i] == 0)
-	  break;
-#endif
-    }
-
-  /* Do we need more room? */
-
-  /* First try compaction */
-  if ((interactive_shell == 0 || subshell_environment) && i == js.j_jobslots && js.j_jobslots >= MAX_JOBS_IN_ARRAY)
-    i = compact_jobs_list (0);
-
-  /* If we can't compact, reallocate */
-  if (i == js.j_jobslots)
-    {
-      js.j_jobslots += JOB_SLOTS;
-      jobs = (JOB **)xrealloc (jobs, (js.j_jobslots * sizeof (JOB *)));
-
-      for (j = i; j < js.j_jobslots; j++)
-	jobs[j] = (JOB *)NULL;
-    }
-
-  /* Add the current pipeline to the job list. */
-  if (the_pipeline)
-    {
-      register PROCESS *p;
-      int any_running, any_stopped, n;
-
-      newjob = (JOB *)xmalloc (sizeof (JOB));
-
-      for (n = 1, p = the_pipeline; p->next != the_pipeline; n++, p = p->next)
-	;
-      p->next = (PROCESS *)NULL;
-      newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *);
-      for (p = newjob->pipe; p->next; p = p->next)
-	;
-      p->next = newjob->pipe;
-
-      the_pipeline = (PROCESS *)NULL;
-      newjob->pgrp = pipeline_pgrp;
-
-      /* Invariant: if the shell is executing a command substitution,
-	 pipeline_pgrp == shell_pgrp. Other parts of the shell assume this. */
-      if (pipeline_pgrp != shell_pgrp)
-	pipeline_pgrp = 0;
-
-      newjob->flags = 0;
-      if (pipefail_opt)
-	newjob->flags |= J_PIPEFAIL;
-
-      /* Flag to see if in another pgrp. */
-      if (job_control)
-	newjob->flags |= J_JOBCONTROL;
-
-      /* Set the state of this pipeline. */
-      p = newjob->pipe;
-      any_running = any_stopped = 0;
-      do
-	{
-	  any_running |= PRUNNING (p);
-	  any_stopped |= PSTOPPED (p);
-	  p = p->next;
-	}
-      while (p != newjob->pipe);
-
-      newjob->state = any_running ? JRUNNING : (any_stopped ? JSTOPPED : JDEAD);
-      newjob->wd = job_working_directory ();
-      newjob->deferred = deferred;
-
-      newjob->j_cleanup = (sh_vptrfunc_t *)NULL;
-      newjob->cleanarg = (PTR_T) NULL;
-
-      jobs[i] = newjob;
-      if (newjob->state == JDEAD && (newjob->flags & J_FOREGROUND))
-	setjstatus (i);
-      if (newjob->state == JDEAD)
-	{
-	  js.c_reaped += n;	/* wouldn't have been done since this was not part of a job */
-	  js.j_ndead++;
-	}
-      js.c_injobs += n;
-
-      js.j_lastj = i;
-      js.j_njobs++;
-    }
-  else
-    newjob = (JOB *)NULL;
-
-  if (newjob)
-    js.j_lastmade = newjob;
-
-  if (async)
-    {
-      if (newjob)
-	{
-	  newjob->flags &= ~J_FOREGROUND;
-	  newjob->flags |= J_ASYNC;
-	  js.j_lastasync = newjob;
-	}
-      reset_current ();
-    }
-  else
-    {
-      if (newjob)
-	{
-	  newjob->flags |= J_FOREGROUND;
-	  /*
-	   *		!!!!! NOTE !!!!!  (chet@po.cwru.edu)
-	   *
-	   * The currently-accepted job control wisdom says to set the
-	   * terminal's process group n+1 times in an n-step pipeline:
-	   * once in the parent and once in each child.  This is where
-	   * the parent gives it away.
-	   *
-	   * Don't give the terminal away if this shell is an asynchronous
-	   * subshell or if we're a (presumably non-interactive) shell running
-	   * in the background.
-	   *
-	   */
-	  if (job_control && newjob->pgrp && (subshell_environment&SUBSHELL_ASYNC) == 0 && running_in_background == 0)
-	    maybe_give_terminal_to (shell_pgrp, newjob->pgrp, 0);
-	}
-    }
-
-  stop_making_children ();
-  UNBLOCK_CHILD (oset);
-  return (newjob ? i : js.j_current);
-}
-
-/* Functions to manage the list of exited background pids whose status has
-   been saved.
-
-   pidstat_table:
-
-   The current implementation is a hash table using a single (separate) arena
-   for storage that can be allocated and freed as a unit.  The size of the hash
-   table is a multiple of PIDSTAT_TABLE_SZ (4096) and multiple PIDs that hash
-   to the same value are chained through the bucket_next and bucket_prev
-   pointers (basically coalesced hashing for collision resolution).
-
-   bgpids.storage:
-
-   All pid/status storage is done using the circular buffer bgpids.storage.
-   This must contain at least js.c_childmax entries.  The circular buffer is
-   used to supply the ordered list Posix requires ("the last CHILD_MAX
-   processes").  To avoid searching the entire storage table for a given PID,
-   the hash table (pidstat_table) holds pointers into the storage arena and
-   uses a doubly-linked list of cells (bucket_next/bucket_prev, also pointers
-   into the arena) to implement collision resolution. */
-
-/* The number of elements in bgpids.storage always has to be > js.c_childmax for
-   the circular buffer to work right. */
-static void
-bgp_resize ()
-{
-  ps_index_t nsize, nsize_cur, nsize_max;
-  ps_index_t psi;
-
-  if (bgpids.nalloc == 0)
-    {
-      /* invalidate hash table when bgpids table is reallocated */
-      for (psi = 0; psi < PIDSTAT_TABLE_SZ; psi++)
-        pidstat_table[psi] = NO_PIDSTAT;
-      nsize = BGPIDS_TABLE_SZ;	/* should be power of 2 */
-      bgpids.head = 0;
-    }
-  else
-    nsize = bgpids.nalloc;
-
-  nsize_max = TYPE_MAXIMUM (ps_index_t);
-  nsize_cur = (ps_index_t)js.c_childmax;
-  if (nsize_cur < 0)				/* overflow */
-    nsize_cur = MAX_CHILD_MAX;
-
-  while (nsize > 0 && nsize < nsize_cur)	/* > 0 should catch overflow */
-    nsize <<= 1;
-  if (nsize > nsize_max || nsize <= 0)		/* overflow? */
-    nsize = nsize_max;
-  if (nsize > MAX_CHILD_MAX)
-    nsize = nsize_max = MAX_CHILD_MAX;		/* hard cap */
-
-  if (bgpids.nalloc < nsize_cur && bgpids.nalloc < nsize_max)
-    {
-      bgpids.storage = (struct pidstat *)xrealloc (bgpids.storage, nsize * sizeof (struct pidstat));
-
-      for (psi = bgpids.nalloc; psi < nsize; psi++)
-	bgpids.storage[psi].pid = NO_PID;
-
-      bgpids.nalloc = nsize;
-
-    }
-  else if (bgpids.head >= bgpids.nalloc)	/* wrap around */
-    bgpids.head = 0;
-}
-
-static ps_index_t
-bgp_getindex ()
-{
-  if (bgpids.nalloc < (ps_index_t)js.c_childmax || bgpids.head >= bgpids.nalloc)
-    bgp_resize ();
-
-  pshash_delindex (bgpids.head);		/* XXX - clear before reusing */
-  return bgpids.head++;
-}
-
-static ps_index_t *
-pshash_getbucket (pid)
-     pid_t pid;
-{
-  unsigned long hash;		/* XXX - u_bits32_t */
-
-  hash = pid * 0x9e370001UL;
-  return (&pidstat_table[hash % PIDSTAT_TABLE_SZ]);
-}
-
-static struct pidstat *
-bgp_add (pid, status)
-     pid_t pid;
-     int status;
-{
-  ps_index_t *bucket, psi;
-  struct pidstat *ps;
-
-  /* bucket == existing chain of pids hashing to same value
-     psi = where were going to put this pid/status */
-
-  bucket = pshash_getbucket (pid);	/* index into pidstat_table */
-  psi = bgp_getindex ();		/* bgpids.head, index into storage */
-
-  /* XXX - what if psi == *bucket? */
-  if (psi == *bucket)
-    {
-      internal_debug ("hashed pid %d (pid %d) collides with bgpids.head, skipping", psi, pid);
-      bgpids.storage[psi].pid = NO_PID;		/* make sure */
-      psi = bgp_getindex ();			/* skip to next one */
-    }
-
-  ps = &bgpids.storage[psi];
-
-  ps->pid = pid;
-  ps->status = status;
-  ps->bucket_next = *bucket;
-  ps->bucket_prev = NO_PIDSTAT;
-
-  bgpids.npid++;
-
-#if 0
-  if (bgpids.npid > js.c_childmax)
-    bgp_prune ();
-#endif
-
-  if (ps->bucket_next != NO_PIDSTAT)
-    bgpids.storage[ps->bucket_next].bucket_prev = psi;
-
-  *bucket = psi;		/* set chain head in hash table */
-
-  return ps;
-}
-
-static void
-pshash_delindex (psi)
-     ps_index_t psi;
-{
-  struct pidstat *ps;
-  ps_index_t *bucket;
-
-  ps = &bgpids.storage[psi];
-  if (ps->pid == NO_PID)
-    return;
-
-  if (ps->bucket_next != NO_PIDSTAT)
-    bgpids.storage[ps->bucket_next].bucket_prev = ps->bucket_prev;
-  if (ps->bucket_prev != NO_PIDSTAT)
-    bgpids.storage[ps->bucket_prev].bucket_next = ps->bucket_next;
-  else
-    {
-      bucket = pshash_getbucket (ps->pid);
-      *bucket = ps->bucket_next;	/* deleting chain head in hash table */
-    }
-
-  /* clear out this cell, in case it gets reused. */
-  ps->pid = NO_PID;
-  ps->bucket_next = ps->bucket_prev = NO_PIDSTAT;
-}
-
-static int
-bgp_delete (pid)
-     pid_t pid;
-{
-  ps_index_t psi, orig_psi;
-
-  if (bgpids.storage == 0 || bgpids.nalloc == 0 || bgpids.npid == 0)
-    return 0;
-
-  /* Search chain using hash to find bucket in pidstat_table */
-  for (orig_psi = psi = *(pshash_getbucket (pid)); psi != NO_PIDSTAT; psi = bgpids.storage[psi].bucket_next)
-    {
-      if (bgpids.storage[psi].pid == pid)
-	break;
-      if (orig_psi == bgpids.storage[psi].bucket_next)	/* catch reported bug */
-	{
-	  internal_warning (_("bgp_delete: LOOP: psi (%d) == storage[psi].bucket_next"), psi);
-	  return 0;
-	}
-    }
-
-  if (psi == NO_PIDSTAT)
-    return 0;		/* not found */
-
-#if 0
-  itrace("bgp_delete: deleting %d", pid);
-#endif
-
-  pshash_delindex (psi);	/* hash table management */
-
-  bgpids.npid--;
-  return 1;
-}
-
-/* Clear out the list of saved statuses */
-static void
-bgp_clear ()
-{
-  if (bgpids.storage == 0 || bgpids.nalloc == 0)
-    return;
-
-  free (bgpids.storage);
-
-  bgpids.storage = 0;
-  bgpids.nalloc = 0;
-  bgpids.head = 0;
-
-  bgpids.npid = 0;
-}
-
-/* Search for PID in the list of saved background pids; return its status if
-   found.  If not found, return -1.  We hash to the right spot in pidstat_table
-   and follow the bucket chain to the end. */
-static int
-bgp_search (pid)
-     pid_t pid;
-{
-  ps_index_t psi, orig_psi;
-
-  if (bgpids.storage == 0 || bgpids.nalloc == 0 || bgpids.npid == 0)
-    return -1;
-
-  /* Search chain using hash to find bucket in pidstat_table */
-  for (orig_psi = psi = *(pshash_getbucket (pid)); psi != NO_PIDSTAT; psi = bgpids.storage[psi].bucket_next)
-    {
-      if (bgpids.storage[psi].pid == pid)
-	return (bgpids.storage[psi].status);
-      if (orig_psi == bgpids.storage[psi].bucket_next)	/* catch reported bug */
-	{
-	  internal_warning (_("bgp_search: LOOP: psi (%d) == storage[psi].bucket_next"), psi);
-	  return -1;
-	}
-    }
-
-  return -1;
-}
-
-#if 0
-static void
-bgp_prune ()
-{
-  return;
-}
-#endif
-
-/* External interface to bgp_add; takes care of blocking and unblocking
-   SIGCHLD. Not really used. */
-void
-save_proc_status (pid, status)
-     pid_t pid;
-     int status;
-{
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-  bgp_add (pid, status);
-  UNBLOCK_CHILD (oset);  
-}
-
-#if defined (PROCESS_SUBSTITUTION)
-/* Functions to add and remove PROCESS * children from the list of running
-   asynchronous process substitutions. The list is currently a simple singly
-   linked list of PROCESS *, so it works with the set of callers that want
-   a child. subst.c:process_substitute adds to the list, the various wait*
-   functions manipulate child->running and child->status, and processes are
-   eventually removed from the list and added to the bgpids table. */
-
-static void
-procsub_free (p)
-     PROCESS *p;
-{
-  FREE (p->command);
-  free (p);
-}
-    
-PROCESS *
-procsub_add (p)
-     PROCESS *p;
-{
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-  if (procsubs.head == 0)
-    {
-      procsubs.head = procsubs.end = p;
-      procsubs.nproc = 0;
-    }
-  else
-    {
-      procsubs.end->next = p;
-      procsubs.end = p;
-    }
-  procsubs.nproc++;
-  UNBLOCK_CHILD (oset);
-
-  return p;
-}
-
-PROCESS *
-procsub_search (pid)
-     pid_t pid;
-{
-  PROCESS *p;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-  for (p = procsubs.head; p; p = p->next)
-    if (p->pid == pid)
-      break;
-  UNBLOCK_CHILD (oset);
-
-  return p;
-}
-
-PROCESS *
-procsub_delete (pid)
-     pid_t pid;
-{
-  PROCESS *p, *prev;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-  for (p = prev = procsubs.head; p; prev = p, p = p->next)
-    if (p->pid == pid)
-      {
-	prev->next = p->next;
-	break;
-      }
-
-  if (p == 0)
-    {
-      UNBLOCK_CHILD (oset);
-      return p;
-    }
-
-  if (p == procsubs.head)
-    procsubs.head = procsubs.head->next;
-  else if (p == procsubs.end)
-    procsubs.end = prev;
-
-  procsubs.nproc--;
-  if (procsubs.nproc == 0)
-    procsubs.head = procsubs.end = 0;
-  else if (procsubs.nproc == 1)		/* XXX */
-    procsubs.end = procsubs.head;
-
-  /* this can't be called anywhere in a signal handling path */
-  bgp_add (p->pid, process_exit_status (p->status));
-  UNBLOCK_CHILD (oset);
-  return (p);  
-}
-
-int
-procsub_waitpid (pid)
-     pid_t pid;
-{
-  PROCESS *p;
-  int r;
-
-  p = procsub_search (pid);
-  if (p == 0)
-    return -1;
-  if (p->running == PS_DONE)
-    return (p->status);
-  r = wait_for (p->pid, 0);
-  return (r);			/* defer removing until later */
-}
-
-void
-procsub_waitall ()
-{
-  PROCESS *p;
-  int r;
-
-  for (p = procsubs.head; p; p = p->next)
-    {
-      if (p->running == PS_DONE)
-	continue;
-      r = wait_for (p->pid, 0);
-    }
-}
-
-void
-procsub_clear ()
-{
-  PROCESS *p, *ps;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-  
-  for (ps = procsubs.head; ps; )
-    {
-      p = ps;
-      ps = ps->next;
-      procsub_free (p);
-    }
-  procsubs.head = procsubs.end = 0;
-  procsubs.nproc = 0;        
-  UNBLOCK_CHILD (oset);
-}
-
-/* Must be called with SIGCHLD blocked. */
-void
-procsub_prune ()
-{
-  PROCESS *ohead, *oend, *ps, *p;
-  int onproc;
-
-  if (procsubs.nproc == 0)
-    return;
-
-  ohead = procsubs.head;
-  oend = procsubs.end;
-  onproc = procsubs.nproc;
-
-  procsubs.head = procsubs.end = 0;
-  procsubs.nproc = 0;
-
-  for (p = ohead; p; )
-    {
-      ps = p->next;
-      p->next = 0;
-      if (p->running == PS_DONE)
-	{
-	  bgp_add (p->pid, process_exit_status (p->status));
-	  procsub_free (p);
-	}
-      else
-	procsub_add (p);
-      p = ps;
-    }
-}
-#endif
-
-/* Reset the values of js.j_lastj and js.j_firstj after one or both have
-   been deleted.  The caller should check whether js.j_njobs is 0 before
-   calling this.  This wraps around, but the rest of the code does not.  At
-   this point, it should not matter. */
-static void
-reset_job_indices ()
-{
-  int old;
-
-  if (jobs[js.j_firstj] == 0)
-    {
-      old = js.j_firstj++;
-      if (old >= js.j_jobslots)
-	old = js.j_jobslots - 1;
-      while (js.j_firstj != old)
-	{
-	  if (js.j_firstj >= js.j_jobslots)
-	    js.j_firstj = 0;
-	  if (jobs[js.j_firstj] || js.j_firstj == old)	/* needed if old == 0 */
-	    break;
-	  js.j_firstj++;
-	}
-      if (js.j_firstj == old)
-	js.j_firstj = js.j_lastj = js.j_njobs = 0;
-    }
-  if (jobs[js.j_lastj] == 0)
-    {
-      old = js.j_lastj--;
-      if (old < 0)
-	old = 0;
-      while (js.j_lastj != old)
-	{
-	  if (js.j_lastj < 0)
-	    js.j_lastj = js.j_jobslots - 1;
-	  if (jobs[js.j_lastj] || js.j_lastj == old)	/* needed if old == js.j_jobslots */
-	    break;
-	  js.j_lastj--;
-	}
-      if (js.j_lastj == old)
-	js.j_firstj = js.j_lastj = js.j_njobs = 0;
-    }
-}
-      
-/* Delete all DEAD jobs that the user had received notification about. */
-static void
-cleanup_dead_jobs ()
-{
-  register int i;
-  int os;
-  PROCESS *discard;
-
-  if (js.j_jobslots == 0 || jobs_list_frozen)
-    return;
-
-  QUEUE_SIGCHLD(os);
-
-  /* XXX could use js.j_firstj and js.j_lastj here */
-  for (i = 0; i < js.j_jobslots; i++)
-    {
-      if (i < js.j_firstj && jobs[i])
-	INTERNAL_DEBUG (("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj));
-      if (i > js.j_lastj && jobs[i])
-	INTERNAL_DEBUG(("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj));
-
-      if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i))
-	delete_job (i, 0);
-    }
-
-#if defined (PROCESS_SUBSTITUTION)
-  procsub_prune ();
-  last_procsub_child = (PROCESS *)NULL;
-#endif
-
-#if defined (COPROCESS_SUPPORT)
-  coproc_reap ();
-#endif
-
-  UNQUEUE_SIGCHLD(os);
-}
-
-static int
-processes_in_job (job)
-     int job;
-{
-  int nproc;
-  register PROCESS *p;
-
-  nproc = 0;
-  p = jobs[job]->pipe;
-  do
-    {
-      p = p->next;
-      nproc++;
-    }
-  while (p != jobs[job]->pipe);
-
-  return nproc;
-}
-
-static void
-delete_old_job (pid)
-     pid_t pid;
-{
-  PROCESS *p;
-  int job;
-
-  job = find_job (pid, 0, &p);
-  if (job != NO_JOB)
-    {
-      INTERNAL_DEBUG (("delete_old_job: found pid %d in job %d with state %d", pid, job, jobs[job]->state));
-      if (JOBSTATE (job) == JDEAD)
-	delete_job (job, DEL_NOBGPID);
-      else
-	{
-	  internal_debug (_("forked pid %d appears in running job %d"), pid, job+1);
-	  if (p)
-	    p->pid = 0;
-	}
-    }
-}
-
-/* Reallocate and compress the jobs list.  This returns with a jobs array
-   whose size is a multiple of JOB_SLOTS and can hold the current number of
-   jobs.  Heuristics are used to minimize the number of new reallocs. */
-static void
-realloc_jobs_list ()
-{
-  sigset_t set, oset;
-  int nsize, i, j, ncur, nprev;
-  JOB **nlist;
-
-  ncur = nprev = NO_JOB;
-  nsize = ((js.j_njobs + JOB_SLOTS - 1) / JOB_SLOTS);
-  nsize *= JOB_SLOTS;
-  i = js.j_njobs % JOB_SLOTS;
-  if (i == 0 || i > (JOB_SLOTS >> 1))
-    nsize += JOB_SLOTS;
-
-  BLOCK_CHILD (set, oset);
-  nlist = (js.j_jobslots == nsize) ? jobs : (JOB **) xmalloc (nsize * sizeof (JOB *));
-
-  js.c_reaped = js.j_ndead = 0;
-  for (i = j = 0; i < js.j_jobslots; i++)
-    if (jobs[i])
-      {
-	if (i == js.j_current)
-	  ncur = j;
-	if (i == js.j_previous)
-	  nprev = j;
-	nlist[j++] = jobs[i];
-	if (jobs[i]->state == JDEAD)
-	  {
-	    js.j_ndead++;
-	    js.c_reaped += processes_in_job (i);
-	  }
-      }
-
-#if 0
-  itrace ("realloc_jobs_list: resize jobs list from %d to %d", js.j_jobslots, nsize);
-  itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js.j_lastj, (j > 0) ? j - 1 : 0);
-  itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js.j_njobs, j);
-  itrace ("realloc_jobs_list: js.j_ndead %d js.c_reaped %d", js.j_ndead, js.c_reaped);
-#endif
-
-  js.j_firstj = 0;
-  js.j_lastj = (j > 0) ? j - 1 : 0;
-  js.j_njobs = j;
-  js.j_jobslots = nsize;
-
-  /* Zero out remaining slots in new jobs list */
-  for ( ; j < nsize; j++)
-    nlist[j] = (JOB *)NULL;
-
-  if (jobs != nlist)
-    {
-      free (jobs);
-      jobs = nlist;
-    }
-
-  if (ncur != NO_JOB)
-    js.j_current = ncur;
-  if (nprev != NO_JOB)
-    js.j_previous = nprev;
-
-  /* Need to reset these */
-  if (js.j_current == NO_JOB || js.j_previous == NO_JOB || js.j_current > js.j_lastj || js.j_previous > js.j_lastj)
-    reset_current ();
-
-#if 0
-  itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js.j_current, js.j_previous);
-#endif
-
-  UNBLOCK_CHILD (oset);
-}
-
-/* Compact the jobs list by removing dead jobs.  Assume that we have filled
-   the jobs array to some predefined maximum.  Called when the shell is not
-   the foreground process (subshell_environment != 0).  Returns the first
-   available slot in the compacted list.  If that value is js.j_jobslots, then
-   the list needs to be reallocated.  The jobs array may be in new memory if
-   this returns > 0 and < js.j_jobslots.  FLAGS is reserved for future use. */
-static int
-compact_jobs_list (flags)
-     int flags;
-{
-  if (js.j_jobslots == 0 || jobs_list_frozen)
-    return js.j_jobslots;
-
-  reap_dead_jobs ();
-  realloc_jobs_list ();
-
-#if 0
-  itrace("compact_jobs_list: returning %d", (js.j_lastj || jobs[js.j_lastj]) ? js.j_lastj + 1 : 0);
-#endif
-
-  return ((js.j_lastj || jobs[js.j_lastj]) ? js.j_lastj + 1 : 0);
-}
-
-/* Delete the job at INDEX from the job list.  Must be called
-   with SIGCHLD blocked. */
-void
-delete_job (job_index, dflags)
-     int job_index, dflags;
-{
-  register JOB *temp;
-  PROCESS *proc;
-  int ndel;
-
-  if (js.j_jobslots == 0 || jobs_list_frozen)
-    return;
-
-  if ((dflags & DEL_WARNSTOPPED) && subshell_environment == 0 && STOPPED (job_index))
-    internal_warning (_("deleting stopped job %d with process group %ld"), job_index+1, (long)jobs[job_index]->pgrp);
-  temp = jobs[job_index];
-  if (temp == 0)
-    return;
-
-  if ((dflags & DEL_NOBGPID) == 0 && (temp->flags & (J_ASYNC|J_FOREGROUND)) == J_ASYNC)
-    {
-      proc = find_last_proc (job_index, 0);
-      if (proc)
-	bgp_add (proc->pid, process_exit_status (proc->status));
-    }
-
-  jobs[job_index] = (JOB *)NULL;
-  if (temp == js.j_lastmade)
-    js.j_lastmade = 0;
-  else if (temp == js.j_lastasync)
-    js.j_lastasync = 0;
-
-  free (temp->wd);
-  ndel = discard_pipeline (temp->pipe);
-
-  js.c_injobs -= ndel;
-  if (temp->state == JDEAD)
-    {
-      /* XXX - save_pipeline and restore_pipeline (e.g., for DEBUG trap) can
-	 mess with this total. */
-      js.c_reaped -= ndel;	/* assumes proc hadn't been reaped earlier */
-      js.j_ndead--;
-      if (js.c_reaped < 0)
-	{
-	  INTERNAL_DEBUG (("delete_job (%d pgrp %d): js.c_reaped (%d) < 0 ndel = %d js.j_ndead = %d", job_index, temp->pgrp, js.c_reaped, ndel, js.j_ndead));
-	  js.c_reaped = 0;
-	}
-    }
-
-  if (temp->deferred)
-    dispose_command (temp->deferred);
-
-  free (temp);
-
-  js.j_njobs--;
-  if (js.j_njobs == 0)
-    js.j_firstj = js.j_lastj = 0;
-  else if (jobs[js.j_firstj] == 0 || jobs[js.j_lastj] == 0)
-    reset_job_indices ();
-
-  if (job_index == js.j_current || job_index == js.j_previous)
-    reset_current ();
-}
-
-/* Must be called with SIGCHLD blocked. */
-void
-nohup_job (job_index)
-     int job_index;
-{
-  register JOB *temp;
-
-  if (js.j_jobslots == 0)
-    return;
-
-  if (temp = jobs[job_index])
-    temp->flags |= J_NOHUP;
-}
-
-/* Get rid of the data structure associated with a process chain. */
-int
-discard_pipeline (chain)
-     register PROCESS *chain;
-{
-  register PROCESS *this, *next;
-  int n;
-
-  this = chain;
-  n = 0;
-  do
-    {
-      next = this->next;
-      FREE (this->command);
-      free (this);
-      n++;
-      this = next;
-    }
-  while (this != chain);
-
-  return n;
-}
-
-/* Add this process to the chain being built in the_pipeline.
-   NAME is the command string that will be exec'ed later.
-   PID is the process id of the child. */
-static void
-add_process (name, pid)
-     char *name;
-     pid_t pid;
-{
-  PROCESS *t, *p;
-
-#if defined (RECYCLES_PIDS)
-  int j;
-  p = find_process (pid, 0, &j);
-  if (p)
-    {
-      if (j == NO_JOB)
-	internal_debug ("add_process: process %5ld (%s) in the_pipeline", (long)p->pid, p->command);
-      if (PALIVE (p))
-	internal_warning (_("add_process: pid %5ld (%s) marked as still alive"), (long)p->pid, p->command);
-      p->running = PS_RECYCLED;		/* mark as recycled */
-    }
-#endif
-
-  t = (PROCESS *)xmalloc (sizeof (PROCESS));
-  t->next = the_pipeline;
-  t->pid = pid;
-  WSTATUS (t->status) = 0;
-  t->running = PS_RUNNING;
-  t->command = name;
-  the_pipeline = t;
-
-  if (t->next == 0)
-    t->next = t;
-  else
-    {
-      p = t->next;
-      while (p->next != t->next)
-	p = p->next;
-      p->next = t;
-    }
-}
-
-/* Create a (dummy) PROCESS with NAME, PID, and STATUS, and make it the last
-   process in jobs[JID]->pipe.  Used by the lastpipe code. */
-void
-append_process (name, pid, status, jid)
-     char *name;
-     pid_t pid;
-     int status;
-     int jid;
-{
-  PROCESS *t, *p;
-
-  t = (PROCESS *)xmalloc (sizeof (PROCESS));
-  t->next = (PROCESS *)NULL;
-  t->pid = pid;
-  /* set process exit status using offset discovered by configure */
-  t->status = (status & 0xff) << WEXITSTATUS_OFFSET;
-  t->running = PS_DONE;
-  t->command = name;
-
-  js.c_reaped++;	/* XXX */
-
-  for (p = jobs[jid]->pipe; p->next != jobs[jid]->pipe; p = p->next)
-    ;
-  p->next = t;
-  t->next = jobs[jid]->pipe;
-}
-
-#if 0
-/* Take the last job and make it the first job.  Must be called with
-   SIGCHLD blocked. */
-int
-rotate_the_pipeline ()
-{
-  PROCESS *p;
-
-  if (the_pipeline->next == the_pipeline)
-    return;
-  for (p = the_pipeline; p->next != the_pipeline; p = p->next)
-    ;
-  the_pipeline = p;
-}
-
-/* Reverse the order of the processes in the_pipeline.  Must be called with
-   SIGCHLD blocked. */
-int
-reverse_the_pipeline ()
-{
-  PROCESS *p, *n;
-
-  if (the_pipeline->next == the_pipeline)
-    return;
-
-  for (p = the_pipeline; p->next != the_pipeline; p = p->next)
-    ;
-  p->next = (PROCESS *)NULL;
-
-  n = REVERSE_LIST (the_pipeline, PROCESS *);
-
-  the_pipeline = n;
-  for (p = the_pipeline; p->next; p = p->next)
-    ;
-  p->next = the_pipeline;
-}
-#endif
-
-/* Map FUNC over the list of jobs.  If FUNC returns non-zero,
-   then it is time to stop mapping, and that is the return value
-   for map_over_jobs.  FUNC is called with a JOB, arg1, arg2,
-   and INDEX. */
-static int
-map_over_jobs (func, arg1, arg2)
-     sh_job_map_func_t *func;
-     int arg1, arg2;
-{
-  register int i;
-  int result;
-  sigset_t set, oset;
-
-  if (js.j_jobslots == 0)
-    return 0;
-
-  BLOCK_CHILD (set, oset);
-
-  /* XXX could use js.j_firstj here */
-  for (i = result = 0; i < js.j_jobslots; i++)
-    {
-      if (i < js.j_firstj && jobs[i])
-	INTERNAL_DEBUG (("map_over_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj));
-      if (i > js.j_lastj && jobs[i])
-	INTERNAL_DEBUG (("map_over_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj));
-
-      if (jobs[i])
-	{
-	  result = (*func)(jobs[i], arg1, arg2, i);
-	  if (result)
-	    break;
-	}
-    }
-
-  UNBLOCK_CHILD (oset);
-
-  return (result);
-}
-
-/* Cause all the jobs in the current pipeline to exit. */
-void
-terminate_current_pipeline ()
-{
-  if (pipeline_pgrp && pipeline_pgrp != shell_pgrp)
-    {
-      killpg (pipeline_pgrp, SIGTERM);
-      killpg (pipeline_pgrp, SIGCONT);
-    }
-}
-
-/* Cause all stopped jobs to exit. */
-void
-terminate_stopped_jobs ()
-{
-  register int i;
-
-  /* XXX could use js.j_firstj here */
-  for (i = 0; i < js.j_jobslots; i++)
-    {
-      if (jobs[i] && STOPPED (i))
-	{
-	  killpg (jobs[i]->pgrp, SIGTERM);
-	  killpg (jobs[i]->pgrp, SIGCONT);
-	}
-    }
-}
-
-/* Cause all jobs, running or stopped, to receive a hangup signal.  If
-   a job is marked J_NOHUP, don't send the SIGHUP. */
-void
-hangup_all_jobs ()
-{
-  register int i;
-
-  /* XXX could use js.j_firstj here */
-  for (i = 0; i < js.j_jobslots; i++)
-    {
-      if (jobs[i])
-	{
-	  if  (jobs[i]->flags & J_NOHUP)
-	    continue;
-	  killpg (jobs[i]->pgrp, SIGHUP);
-	  if (STOPPED (i))
-	    killpg (jobs[i]->pgrp, SIGCONT);
-	}
-    }
-}
-
-void
-kill_current_pipeline ()
-{
-  stop_making_children ();
-  start_pipeline ();
-}
-
-static PROCESS *
-find_pid_in_pipeline (pid, pipeline, alive_only)
-     pid_t pid;
-     PROCESS *pipeline;
-     int alive_only;
-{
-  PROCESS *p;
-
-  p = pipeline;
-  do
-    {
-      /* Return it if we found it.  Don't ever return a recycled pid. */
-      if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
-	return (p);
-
-      p = p->next;
-    }
-  while (p != pipeline);
-  return ((PROCESS *)NULL);
-}
-
-/* Return the pipeline that PID belongs to.  Note that the pipeline
-   doesn't have to belong to a job.  Must be called with SIGCHLD blocked.
-   If JOBP is non-null, return the index of the job containing PID.  */
-static PROCESS *
-find_pipeline (pid, alive_only, jobp)
-     pid_t pid;
-     int alive_only;
-     int *jobp;		/* index into jobs list or NO_JOB */
-{
-  int job;
-  PROCESS *p;
-  struct pipeline_saver *save;
-
-  /* See if this process is in the pipeline that we are building. */
-  p = (PROCESS *)NULL;
-  if (jobp)
-    *jobp = NO_JOB;
-
-  if (the_pipeline && (p = find_pid_in_pipeline (pid, the_pipeline, alive_only)))
-    return (p);
-
-  /* Is this process in a saved pipeline? */
-  for (save = saved_pipeline; save; save = save->next)
-    if (save->pipeline && (p = find_pid_in_pipeline (pid, save->pipeline, alive_only)))
-      return (p);
-
-#if defined (PROCESS_SUBSTITUTION)
-  if (procsubs.nproc > 0 && (p = procsub_search (pid)) && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
-    return (p);
-#endif
-
-  job = find_job (pid, alive_only, &p);
-  if (jobp)
-    *jobp = job;
-  return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe;
-}
-
-/* Return the PROCESS * describing PID.  If JOBP is non-null return the index
-   into the jobs array of the job containing PID.  Must be called with
-   SIGCHLD blocked. */
-static PROCESS *
-find_process (pid, alive_only, jobp)
-     pid_t pid;
-     int alive_only;
-     int *jobp;		/* index into jobs list or NO_JOB */
-{
-  PROCESS *p;
-
-  p = find_pipeline (pid, alive_only, jobp);
-  while (p && p->pid != pid)
-    p = p->next;
-  return p;
-}
-
-/* Return the job index that PID belongs to, or NO_JOB if it doesn't
-   belong to any job.  Must be called with SIGCHLD blocked. */
-static int
-find_job (pid, alive_only, procp)
-     pid_t pid;
-     int alive_only;
-     PROCESS **procp;
-{
-  register int i;
-  PROCESS *p;
-
-  /* XXX could use js.j_firstj here, and should check js.j_lastj */
-  for (i = 0; i < js.j_jobslots; i++)
-    {
-      if (i < js.j_firstj && jobs[i])
-	INTERNAL_DEBUG (("find_job: job %d non-null before js.j_firstj (%d)", i, js.j_firstj));
-      if (i > js.j_lastj && jobs[i])
-	INTERNAL_DEBUG (("find_job: job %d non-null after js.j_lastj (%d)", i, js.j_lastj));
-
-      if (jobs[i])
-	{
-	  p = jobs[i]->pipe;
-
-	  do
-	    {
-	      if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p)))
-		{
-		  if (procp)
-		    *procp = p;
-		  return (i);
-		}
-
-	      p = p->next;
-	    }
-	  while (p != jobs[i]->pipe);
-	}
-    }
-
-  return (NO_JOB);
-}
-
-/* Find a job given a PID.  If BLOCK is non-zero, block SIGCHLD as
-   required by find_job. */
-int
-get_job_by_pid (pid, block, procp)
-     pid_t pid;
-     int block;
-     PROCESS **procp;
-{
-  int job;
-  sigset_t set, oset;
-
-  if (block)
-    BLOCK_CHILD (set, oset);
-
-  job = find_job (pid, 0, procp);
-
-  if (block)
-    UNBLOCK_CHILD (oset);
-
-  return job;
-}
-
-/* Print descriptive information about the job with leader pid PID. */
-void
-describe_pid (pid)
-     pid_t pid;
-{
-  int job;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-
-  job = find_job (pid, 0, NULL);
-
-  if (job != NO_JOB)
-    fprintf (stderr, "[%d] %ld\n", job + 1, (long)pid);
-  else
-    programming_error (_("describe_pid: %ld: no such pid"), (long)pid);
-
-  UNBLOCK_CHILD (oset);
-}
-
-static char *
-j_strsignal (s)
-     int s;
-{
-  char *x;
-
-  x = strsignal (s);
-  if (x == 0)
-    {
-      x = retcode_name_buffer;
-      snprintf (x, sizeof(retcode_name_buffer), _("Signal %d"), s);
-    }
-  return x;
-}
-
-static char *
-printable_job_status (j, p, format)
-     int j;
-     PROCESS *p;
-     int format;
-{
-  static char *temp;
-  int es;
-
-  temp = _("Done");
-
-  if (STOPPED (j) && format == 0)
-    {
-      if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0))
-	temp = _("Stopped");
-      else
-	{
-	  temp = retcode_name_buffer;
-	  snprintf (temp, sizeof(retcode_name_buffer), _("Stopped(%s)"), signal_name (WSTOPSIG (p->status)));
-	}
-    }
-  else if (RUNNING (j))
-    temp = _("Running");
-  else
-    {
-      if (WIFSTOPPED (p->status))
-	temp = j_strsignal (WSTOPSIG (p->status));
-      else if (WIFSIGNALED (p->status))
-	temp = j_strsignal (WTERMSIG (p->status));
-      else if (WIFEXITED (p->status))
-	{
-	  temp = retcode_name_buffer;
-	  es = WEXITSTATUS (p->status);
-	  if (es == 0)
-	    {
-	      strncpy (temp, _("Done"), sizeof (retcode_name_buffer) - 1);
-	      temp[sizeof (retcode_name_buffer) - 1] = '\0';
-	    }
-	  else if (posixly_correct)
-	    snprintf (temp, sizeof(retcode_name_buffer), _("Done(%d)"), es);
-	  else
-	    snprintf (temp, sizeof(retcode_name_buffer), _("Exit %d"), es);
-	}
-      else
-	temp = _("Unknown status");
-    }
-
-  return temp;
-}
-
-/* This is the way to print out information on a job if you
-   know the index.  FORMAT is:
-
-    JLIST_NORMAL)   [1]+ Running	   emacs
-    JLIST_LONG  )   [1]+ 2378 Running      emacs
-    -1	  )   [1]+ 2378	      emacs
-
-    JLIST_NORMAL)   [1]+ Stopped	   ls | more
-    JLIST_LONG  )   [1]+ 2369 Stopped      ls
-			 2367	    | more
-    JLIST_PID_ONLY)
-	Just list the pid of the process group leader (really
-	the process group).
-    JLIST_CHANGED_ONLY)
-	Use format JLIST_NORMAL, but list only jobs about which
-	the user has not been notified. */
-
-/* Print status for pipeline P.  If JOB_INDEX is >= 0, it is the index into
-   the JOBS array corresponding to this pipeline.  FORMAT is as described
-   above.  Must be called with SIGCHLD blocked.
-
-   If you're printing a pipeline that's not in the jobs array, like the
-   current pipeline as it's being created, pass -1 for JOB_INDEX */
-static void
-print_pipeline (p, job_index, format, stream)
-     PROCESS *p;
-     int job_index, format;
-     FILE *stream;
-{
-  PROCESS *first, *last, *show;
-  int es, name_padding;
-  char *temp;
-
-  if (p == 0)
-    return;
-
-  first = last = p;
-  while (last->next != first)
-    last = last->next;
-
-  for (;;)
-    {
-      if (p != first)
-	fprintf (stream, format ? "     " : " |");
-
-      if (format != JLIST_STANDARD)
-	fprintf (stream, "%5ld", (long)p->pid);
-
-      fprintf (stream, " ");
-
-      if (format > -1 && job_index >= 0)
-	{
-	  show = format ? p : last;
-	  temp = printable_job_status (job_index, show, format);
-
-	  if (p != first)
-	    {
-	      if (format)
-		{
-		  if (show->running == first->running &&
-		      WSTATUS (show->status) == WSTATUS (first->status))
-		    temp = "";
-		}
-	      else
-		temp = (char *)NULL;
-	    }
-
-	  if (temp)
-	    {
-	      fprintf (stream, "%s", temp);
-
-	      es = STRLEN (temp);
-	      if (es == 0)
-		es = 2;	/* strlen ("| ") */
-	      name_padding = LONGEST_SIGNAL_DESC - es;
-
-	      fprintf (stream, "%*s", name_padding, "");
-
-	      if ((WIFSTOPPED (show->status) == 0) &&
-		  (WIFCONTINUED (show->status) == 0) &&
-		  WIFCORED (show->status))
-		fprintf (stream, _("(core dumped) "));
-	    }
-	}
-
-      if (p != first && format)
-	fprintf (stream, "| ");
-
-      if (p->command)
-	fprintf (stream, "%s", p->command);
-
-      if (p == last && job_index >= 0)
-	{
-	  temp = current_working_directory ();
-
-	  if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0))
-	    fprintf (stream, " &");
-
-	  if (strcmp (temp, jobs[job_index]->wd) != 0)
-	    fprintf (stream,
-	      _("  (wd: %s)"), polite_directory_format (jobs[job_index]->wd));
-	}
-
-      if (format || (p == last))
-	{
-	  /* We need to add a CR only if this is an interactive shell, and
-	     we're reporting the status of a completed job asynchronously.
-	     We can't really check whether this particular job is being
-	     reported asynchronously, so just add the CR if the shell is
-	     currently interactive and asynchronous notification is enabled. */
-	  if (asynchronous_notification && interactive)
-	    putc ('\r', stream);
-	  fprintf (stream, "\n");
-	}
-
-      if (p == last)
-	break;
-      p = p->next;
-    }
-  fflush (stream);
-}
-
-/* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
-   Must be called with SIGCHLD blocked or queued with queue_sigchld */
-static void
-pretty_print_job (job_index, format, stream)
-     int job_index, format;
-     FILE *stream;
-{
-  register PROCESS *p;
-
-  /* Format only pid information about the process group leader? */
-  if (format == JLIST_PID_ONLY)
-    {
-      fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid);
-      return;
-    }
-
-  if (format == JLIST_CHANGED_ONLY)
-    {
-      if (IS_NOTIFIED (job_index))
-	return;
-      format = JLIST_STANDARD;
-    }
-
-  if (format != JLIST_NONINTERACTIVE)
-    fprintf (stream, "[%d]%c ", job_index + 1,
-	      (job_index == js.j_current) ? '+':
-		(job_index == js.j_previous) ? '-' : ' ');
-
-  if (format == JLIST_NONINTERACTIVE)
-    format = JLIST_LONG;
-
-  p = jobs[job_index]->pipe;
-
-  print_pipeline (p, job_index, format, stream);
-
-  /* We have printed information about this job.  When the job's
-     status changes, waitchld () sets the notification flag to 0. */
-  jobs[job_index]->flags |= J_NOTIFIED;
-}
-
-static int
-print_job (job, format, state, job_index)
-     JOB *job;
-     int format, state, job_index;
-{
-  if (state == -1 || (JOB_STATE)state == job->state)
-    pretty_print_job (job_index, format, stdout);
-  return (0);
-}
-
-void
-list_one_job (job, format, ignore, job_index)
-     JOB *job;
-     int format, ignore, job_index;
-{
-  pretty_print_job (job_index, format, stdout);
-  cleanup_dead_jobs ();
-}
-
-void
-list_stopped_jobs (format)
-     int format;
-{
-  cleanup_dead_jobs ();
-  map_over_jobs (print_job, format, (int)JSTOPPED);
-}
-
-void
-list_running_jobs (format)
-     int format;
-{
-  cleanup_dead_jobs ();
-  map_over_jobs (print_job, format, (int)JRUNNING);
-}
-
-/* List jobs.  If FORMAT is non-zero, then the long form of the information
-   is printed, else just a short version. */
-void
-list_all_jobs (format)
-     int format;
-{
-  cleanup_dead_jobs ();
-  map_over_jobs (print_job, format, -1);
-}
-
-/* Fork, handling errors.  Returns the pid of the newly made child, or 0.
-   COMMAND is just for remembering the name of the command; we don't do
-   anything else with it.  ASYNC_P says what to do with the tty.  If
-   non-zero, then don't give it away. */
-pid_t
-make_child (command, flags)
-     char *command;
-     int flags;
-{
-  int async_p, forksleep;
-  sigset_t set, oset, termset, chldset, oset_copy;
-  pid_t pid;
-  SigHandler *oterm;
-
-  sigemptyset (&oset_copy);
-  sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &oset_copy);
-  sigaddset (&oset_copy, SIGTERM);
-
-  /* Block SIGTERM here and unblock in child after fork resets the
-     set of pending signals. */
-  sigemptyset (&set);
-  sigaddset (&set, SIGCHLD);
-  sigaddset (&set, SIGINT);
-  sigaddset (&set, SIGTERM);
-
-  sigemptyset (&oset);
-  sigprocmask (SIG_BLOCK, &set, &oset);
-
-  /* Blocked in the parent, child will receive it after unblocking SIGTERM */
-  if (interactive_shell)
-    oterm = set_signal_handler (SIGTERM, SIG_DFL);
-
-  making_children ();
-
-  async_p = (flags & FORK_ASYNC);
-  forksleep = 1;
-
-#if defined (BUFFERED_INPUT)
-  /* If default_buffered_input is active, we are reading a script.  If
-     the command is asynchronous, we have already duplicated /dev/null
-     as fd 0, but have not changed the buffered stream corresponding to
-     the old fd 0.  We don't want to sync the stream in this case. */
-  if (default_buffered_input != -1 &&
-      (!async_p || default_buffered_input > 0))
-    sync_buffered_stream (default_buffered_input);
-#endif /* BUFFERED_INPUT */
-
-  /* Create the child, handle severe errors.  Retry on EAGAIN. */
-  while ((pid = fork ()) < 0 && errno == EAGAIN && forksleep < FORKSLEEP_MAX)
-    {
-      /* bash-4.2 */
-      /* keep SIGTERM blocked until we reset the handler to SIG_IGN */
-      sigprocmask (SIG_SETMASK, &oset_copy, (sigset_t *)NULL);
-      /* If we can't create any children, try to reap some dead ones. */
-      waitchld (-1, 0);
-
-      errno = EAGAIN;		/* restore errno */
-      sys_error ("fork: retry");
-
-      if (sleep (forksleep) != 0)
-	break;
-      forksleep <<= 1;
-
-      if (interrupt_state)
-	break;
-      sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL);
-    }
-
-  if (pid != 0)
-    if (interactive_shell)
-      set_signal_handler (SIGTERM, oterm);
-
-  if (pid < 0)
-    {
-      sys_error ("fork");
-
-      /* Kill all of the processes in the current pipeline. */
-      terminate_current_pipeline ();
-
-      /* Discard the current pipeline, if any. */
-      if (the_pipeline)
-	kill_current_pipeline ();
-
-      set_exit_status (EX_NOEXEC);
-      throw_to_top_level ();	/* Reset signals, etc. */
-    }
-
-  if (pid == 0)
-    {
-      /* In the child.  Give this child the right process group, set the
-	 signals to the default state for a new process. */
-      pid_t mypid;
-
-      subshell_environment |= SUBSHELL_IGNTRAP;
-
-      /* If this ends up being changed to modify or use `command' in the
-	 child process, go back and change callers who free `command' in
-	 the child process when this returns. */
-      mypid = getpid ();
-#if defined (BUFFERED_INPUT)
-      /* Close default_buffered_input if it's > 0.  We don't close it if it's
-	 0 because that's the file descriptor used when redirecting input,
-	 and it's wrong to close the file in that case. */
-      unset_bash_input (0);
-#endif /* BUFFERED_INPUT */
-
-      CLRINTERRUPT;	/* XXX - children have their own interrupt state */
-
-      /* Restore top-level signal mask, including unblocking SIGTERM */
-      restore_sigmask ();
-  
-      if (job_control)
-	{
-	  /* All processes in this pipeline belong in the same
-	     process group. */
-
-	  if (pipeline_pgrp == 0)	/* This is the first child. */
-	    pipeline_pgrp = mypid;
-
-	  /* Check for running command in backquotes. */
-	  if (pipeline_pgrp == shell_pgrp)
-	    ignore_tty_job_signals ();
-	  else
-	    default_tty_job_signals ();
-
-	  /* Set the process group before trying to mess with the terminal's
-	     process group.  This is mandated by POSIX. */
-	  /* This is in accordance with the Posix 1003.1 standard,
-	     section B.7.2.4, which says that trying to set the terminal
-	     process group with tcsetpgrp() to an unused pgrp value (like
-	     this would have for the first child) is an error.  Section
-	     B.4.3.3, p. 237 also covers this, in the context of job control
-	     shells. */
-	  if (setpgid (mypid, pipeline_pgrp) < 0)
-	    sys_error (_("child setpgid (%ld to %ld)"), (long)mypid, (long)pipeline_pgrp);
-
-	  /* By convention (and assumption above), if
-	     pipeline_pgrp == shell_pgrp, we are making a child for
-	     command substitution.
-	     In this case, we don't want to give the terminal to the
-	     shell's process group (we could be in the middle of a
-	     pipeline, for example). */
-	  if ((flags & FORK_NOTERM) == 0 && async_p == 0 && pipeline_pgrp != shell_pgrp && ((subshell_environment&(SUBSHELL_ASYNC|SUBSHELL_PIPE)) == 0) && running_in_background == 0)
-	    give_terminal_to (pipeline_pgrp, 0);
-
-#if defined (PGRP_PIPE)
-	  if (pipeline_pgrp == mypid)
-	    pipe_read (pgrp_pipe);
-#endif
-	}
-      else			/* Without job control... */
-	{
-	  if (pipeline_pgrp == 0)
-	    pipeline_pgrp = shell_pgrp;
-
-	  /* If these signals are set to SIG_DFL, we encounter the curious
-	     situation of an interactive ^Z to a running process *working*
-	     and stopping the process, but being unable to do anything with
-	     that process to change its state.  On the other hand, if they
-	     are set to SIG_IGN, jobs started from scripts do not stop when
-	     the shell running the script gets a SIGTSTP and stops. */
-
-	  default_tty_job_signals ();
-	}
-
-#if defined (PGRP_PIPE)
-      /* Release the process group pipe, since our call to setpgid ()
-	 is done.  The last call to sh_closepipe is done in stop_pipeline. */
-      sh_closepipe (pgrp_pipe);
-#endif /* PGRP_PIPE */
-
-      /* Don't set last_asynchronous_pid in the child */
-
-#if defined (RECYCLES_PIDS)
-      if (last_asynchronous_pid == mypid)
-	/* Avoid pid aliasing.  1 seems like a safe, unusual pid value. */
-	last_asynchronous_pid = 1;
-#endif
-    }
-  else
-    {
-      /* In the parent.  Remember the pid of the child just created
-	 as the proper pgrp if this is the first child. */
-
-      if (job_control)
-	{
-	  if (pipeline_pgrp == 0)
-	    {
-	      pipeline_pgrp = pid;
-	      /* Don't twiddle terminal pgrps in the parent!  This is the bug,
-		 not the good thing of twiddling them in the child! */
-	      /* give_terminal_to (pipeline_pgrp, 0); */
-	    }
-	  /* This is done on the recommendation of the Rationale section of
-	     the POSIX 1003.1 standard, where it discusses job control and
-	     shells.  It is done to avoid possible race conditions. (Ref.
-	     1003.1 Rationale, section B.4.3.3, page 236). */
-	  setpgid (pid, pipeline_pgrp);
-	}
-      else
-	{
-	  if (pipeline_pgrp == 0)
-	    pipeline_pgrp = shell_pgrp;
-	}
-
-      /* Place all processes into the jobs array regardless of the
-	 state of job_control. */
-      add_process (command, pid);
-
-      if (async_p)
-	last_asynchronous_pid = pid;
-#if defined (RECYCLES_PIDS)
-      else if (last_asynchronous_pid == pid)
-	/* Avoid pid aliasing.  1 seems like a safe, unusual pid value. */
-	last_asynchronous_pid = 1;
-#endif
-
-      /* Delete the saved status for any job containing this PID in case it's
-	 been reused. */
-      delete_old_job (pid);
-
-      /* Perform the check for pid reuse unconditionally.  Some systems reuse
-	 PIDs before giving a process CHILD_MAX/_SC_CHILD_MAX unique ones. */
-      bgp_delete (pid);		/* new process, discard any saved status */
-
-      last_made_pid = pid;
-
-      /* keep stats */
-      js.c_totforked++;
-      js.c_living++;
-
-      /* Unblock SIGTERM, SIGINT, and SIGCHLD unless creating a pipeline, in
-	 which case SIGCHLD remains blocked until all commands in the pipeline
-	 have been created (execute_cmd.c:execute_pipeline()). */
-      sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
-    }
-
-  return (pid);
-}
-
-/* These two functions are called only in child processes. */
-void
-ignore_tty_job_signals ()
-{
-  set_signal_handler (SIGTSTP, SIG_IGN);
-  set_signal_handler (SIGTTIN, SIG_IGN);
-  set_signal_handler (SIGTTOU, SIG_IGN);
-}
-
-/* Reset the tty-generated job control signals to SIG_DFL unless that signal
-   was ignored at entry to the shell, in which case we need to set it to
-   SIG_IGN in the child.  We can't rely on resetting traps, since the hard
-   ignored signals can't be trapped. */
-void
-default_tty_job_signals ()
-{
-  if (signal_is_trapped (SIGTSTP) == 0 && signal_is_hard_ignored (SIGTSTP))
-    set_signal_handler (SIGTSTP, SIG_IGN);
-  else
-    set_signal_handler (SIGTSTP, SIG_DFL);
-
-  if (signal_is_trapped (SIGTTIN) == 0 && signal_is_hard_ignored (SIGTTIN))
-    set_signal_handler (SIGTTIN, SIG_IGN);
-  else
-    set_signal_handler (SIGTTIN, SIG_DFL);
-
-  if (signal_is_trapped (SIGTTOU) == 0 && signal_is_hard_ignored (SIGTTOU))
-    set_signal_handler (SIGTTOU, SIG_IGN);
-  else
-    set_signal_handler (SIGTTOU, SIG_DFL);
-}
-
-/* Called once in a parent process. */
-void
-get_original_tty_job_signals ()
-{
-  static int fetched = 0;
-
-  if (fetched == 0)
-    {
-      if (interactive_shell)
-	{
-	  set_original_signal (SIGTSTP, SIG_DFL);
-	  set_original_signal (SIGTTIN, SIG_DFL);
-	  set_original_signal (SIGTTOU, SIG_DFL);
-	}
-      else
-	{
-	  get_original_signal (SIGTSTP);
-	  get_original_signal (SIGTTIN);
-	  get_original_signal (SIGTTOU);
-	}
-      fetched = 1;
-    }
-}
-
-/* When we end a job abnormally, or if we stop a job, we set the tty to the
-   state kept in here.  When a job ends normally, we set the state in here
-   to the state of the tty. */
-
-static TTYSTRUCT shell_tty_info;
-
-#if defined (NEW_TTY_DRIVER)
-static struct tchars shell_tchars;
-static struct ltchars shell_ltchars;
-#endif /* NEW_TTY_DRIVER */
-
-#if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
-/* Since the BSD tty driver does not allow us to change the tty modes
-   while simultaneously waiting for output to drain and preserving
-   typeahead, we have to drain the output ourselves before calling
-   ioctl.  We cheat by finding the length of the output queue, and
-   using select to wait for an appropriate length of time.  This is
-   a hack, and should be labeled as such (it's a hastily-adapted
-   mutation of a `usleep' implementation).  It's only reason for
-   existing is the flaw in the BSD tty driver. */
-
-static int ttspeeds[] =
-{
-  0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
-  1800, 2400, 4800, 9600, 19200, 38400
-};
-
-static void
-draino (fd, ospeed)
-     int fd, ospeed;
-{
-  register int delay = ttspeeds[ospeed];
-  int n;
-
-  if (!delay)
-    return;
-
-  while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n)
-    {
-      if (n > (delay / 100))
-	{
-	  struct timeval tv;
-
-	  n *= 10;		/* 2 bits more for conservativeness. */
-	  tv.tv_sec = n / delay;
-	  tv.tv_usec = ((n % delay) * 1000000) / delay;
-	  select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
-	}
-      else
-	break;
-    }
-}
-#endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
-
-/* Return the fd from which we are actually getting input. */
-#define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
-
-/* Fill the contents of shell_tty_info with the current tty info. */
-int
-get_tty_state ()
-{
-  int tty;
-
-  tty = input_tty ();
-  if (tty != -1)
-    {
-#if defined (NEW_TTY_DRIVER)
-      ioctl (tty, TIOCGETP, &shell_tty_info);
-      ioctl (tty, TIOCGETC, &shell_tchars);
-      ioctl (tty, TIOCGLTC, &shell_ltchars);
-#endif /* NEW_TTY_DRIVER */
-
-#if defined (TERMIO_TTY_DRIVER)
-      ioctl (tty, TCGETA, &shell_tty_info);
-#endif /* TERMIO_TTY_DRIVER */
-
-#if defined (TERMIOS_TTY_DRIVER)
-      if (tcgetattr (tty, &shell_tty_info) < 0)
-	{
-#if 0
-	  /* Only print an error message if we're really interactive at
-	     this time. */
-	  if (interactive)
-	    sys_error ("[%ld: %d (%d)] tcgetattr", (long)getpid (), shell_level, tty);
-#endif
-	  return -1;
-	}
-#endif /* TERMIOS_TTY_DRIVER */
-      if (check_window_size)
-	get_new_window_size (0, (int *)0, (int *)0);
-    }
-  return 0;
-}
-
-/* Make the current tty use the state in shell_tty_info. */
-int
-set_tty_state ()
-{
-  int tty;
-
-  tty = input_tty ();
-  if (tty != -1)
-    {
-#if defined (NEW_TTY_DRIVER)
-#  if defined (DRAIN_OUTPUT)
-      draino (tty, shell_tty_info.sg_ospeed);
-#  endif /* DRAIN_OUTPUT */
-      ioctl (tty, TIOCSETN, &shell_tty_info);
-      ioctl (tty, TIOCSETC, &shell_tchars);
-      ioctl (tty, TIOCSLTC, &shell_ltchars);
-#endif /* NEW_TTY_DRIVER */
-
-#if defined (TERMIO_TTY_DRIVER)
-      ioctl (tty, TCSETAW, &shell_tty_info);
-#endif /* TERMIO_TTY_DRIVER */
-
-#if defined (TERMIOS_TTY_DRIVER)
-      if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
-	{
-	  /* Only print an error message if we're really interactive at
-	     this time. */
-	  if (interactive)
-	    sys_error ("[%ld: %d (%d)] tcsetattr", (long)getpid (), shell_level, tty);
-	  return -1;
-	}
-#endif /* TERMIOS_TTY_DRIVER */
-    }
-  return 0;
-}
-
-/* Given an index into the jobs array JOB, return the PROCESS struct of the last
-   process in that job's pipeline.  This is the one whose exit status
-   counts.  Must be called with SIGCHLD blocked or queued. */
-static PROCESS *
-find_last_proc (job, block)
-     int job;
-     int block;
-{
-  register PROCESS *p;
-  sigset_t set, oset;
-
-  if (block)
-    BLOCK_CHILD (set, oset);
-
-  p = jobs[job]->pipe;
-  while (p && p->next != jobs[job]->pipe)
-    p = p->next;
-
-  if (block)
-    UNBLOCK_CHILD (oset);
-
-  return (p);
-}
-
-static pid_t
-find_last_pid (job, block)
-     int job;
-     int block;
-{
-  PROCESS *p;
-
-  p = find_last_proc (job, block);
-  /* Possible race condition here. */
-  return p->pid;
-}     
-
-/* Wait for a particular child of the shell to finish executing.
-   This low-level function prints an error message if PID is not
-   a child of this shell.  It returns -1 if it fails, or whatever
-   wait_for returns otherwise.  If the child is not found in the
-   jobs table, it returns 127.  If FLAGS doesn't include JWAIT_PERROR,
-   we suppress the error message if PID isn't found. */
-
-int
-wait_for_single_pid (pid, flags)
-     pid_t pid;
-     int flags;
-{
-  register PROCESS *child;
-  sigset_t set, oset;
-  int r, job, alive;
-
-  BLOCK_CHILD (set, oset);
-  child = find_pipeline (pid, 0, (int *)NULL);
-  UNBLOCK_CHILD (oset);
-
-  if (child == 0)
-    {
-      r = bgp_search (pid);
-      if (r >= 0)
-	return r;
-    }
-
-  if (child == 0)
-    {
-      if (flags & JWAIT_PERROR)
-	internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid);
-      return (257);
-    }
-
-  alive = 0;
-  do
-    {
-      r = wait_for (pid, 0);
-      if ((flags & JWAIT_FORCE) == 0)
-	break;
-
-      BLOCK_CHILD (set, oset);
-      alive = PALIVE (child);
-      UNBLOCK_CHILD (oset);
-    }
-  while (alive);
-
-  /* POSIX.2: if we just waited for a job, we can remove it from the jobs
-     table. */
-  BLOCK_CHILD (set, oset);
-  job = find_job (pid, 0, NULL);
-  if (job != NO_JOB && jobs[job] && DEADJOB (job))
-    jobs[job]->flags |= J_NOTIFIED;
-  UNBLOCK_CHILD (oset);
-
-  /* If running in posix mode, remove the job from the jobs table immediately */
-  if (posixly_correct)
-    {
-      cleanup_dead_jobs ();
-      bgp_delete (pid);
-    }
-
-  /* Check for a trapped signal interrupting the wait builtin and jump out */
-  CHECK_WAIT_INTR;
-
-  return r;
-}
-
-/* Wait for all of the background processes started by this shell to finish. */
-int
-wait_for_background_pids (ps)
-     struct procstat *ps;
-{
-  register int i, r;
-  int any_stopped, check_async, njobs;
-  sigset_t set, oset;
-  pid_t pid;
-
-  for (njobs = any_stopped = 0, check_async = 1;;)
-    {
-      BLOCK_CHILD (set, oset);
-
-      /* find first running job; if none running in foreground, break */
-      /* XXX could use js.j_firstj and js.j_lastj here */
-      for (i = 0; i < js.j_jobslots; i++)
-	{
-	  if (i < js.j_firstj && jobs[i])
-	    INTERNAL_DEBUG (("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i, js.j_firstj));
-	  if (i > js.j_lastj && jobs[i])
-	    INTERNAL_DEBUG (("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i, js.j_lastj));
-
-	  if (jobs[i] && STOPPED (i))
-	    {
-	      builtin_warning ("job %d[%d] stopped", i+1, find_last_pid (i, 0));
-	      any_stopped = 1;
-	    }
-
-	  if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
-	    break;
-	}
-      if (i == js.j_jobslots)
-	{
-	  UNBLOCK_CHILD (oset);
-	  break;
-	}
-
-      /* now wait for the last pid in that job. */
-      pid = find_last_pid (i, 0);
-      UNBLOCK_CHILD (oset);
-      QUIT;
-      errno = 0;		/* XXX */
-      r = wait_for_single_pid (pid, JWAIT_PERROR);
-      if (ps)
-	{
-	  ps->pid = pid;
-	  ps->status = (r < 0 || r > 256) ? 127 : r;
-	}
-      if (r == -1 && errno == ECHILD)
-	{
-	  /* If we're mistaken about job state, compensate. */
-	  check_async = 0;
-	  mark_all_jobs_as_dead ();
-	}
-      njobs++;
-    }
-
-#if defined (PROCESS_SUBSTITUTION)
-  procsub_waitall ();
-#endif
-      
-  /* POSIX.2 says the shell can discard the statuses of all completed jobs if
-     `wait' is called with no arguments. */
-  mark_dead_jobs_as_notified (1);
-  cleanup_dead_jobs ();
-  bgp_clear ();
-
-  return njobs;
-}
-
-/* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
-#define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
-static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER;
-
-static int wait_sigint_received;
-static int child_caught_sigint;
-
-int waiting_for_child;
-
-/* Clean up state after longjmp to wait_intr_buf */
-void
-wait_sigint_cleanup ()
-{
-  queue_sigchld = 0;
-  waiting_for_child = 0;
-  restore_sigint_handler ();
-}
-
-static void
-restore_sigint_handler ()
-{
-  if (old_sigint_handler != INVALID_SIGNAL_HANDLER)
-    {
-      set_signal_handler (SIGINT, old_sigint_handler);
-      old_sigint_handler = INVALID_SIGNAL_HANDLER;
-      waiting_for_child = 0;
-    }
-}
-
-/* Handle SIGINT while we are waiting for children in a script to exit.
-   The `wait' builtin should be interruptible, but all others should be
-   effectively ignored (i.e. not cause the shell to exit). */
-static sighandler
-wait_sigint_handler (sig)
-     int sig;
-{
-  SigHandler *sigint_handler;
-
-  if (this_shell_builtin && this_shell_builtin == wait_builtin)
-    {
-      set_exit_status (128+SIGINT);
-      restore_sigint_handler ();
-      /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
-	 what POSIX.2 says (see builtins/wait.def for more info). */
-      if (this_shell_builtin && this_shell_builtin == wait_builtin &&
-	  signal_is_trapped (SIGINT) &&
-	  ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler))
-	{
-	  trap_handler (SIGINT);	/* set pending_traps[SIGINT] */
-	  wait_signal_received = SIGINT;
-	  if (wait_intr_flag)
-	    sh_longjmp (wait_intr_buf, 1);
-	  else
-	    /* Let CHECK_WAIT_INTR handle it in wait_for/waitchld */
-	    SIGRETURN (0);
-	}
-      else /* wait_builtin but signal not trapped, treat as interrupt */
-	kill (getpid (), SIGINT);
-    }
-
-  /* XXX - should this be interrupt_state?  If it is, the shell will act
-     as if it got the SIGINT interrupt. */
-  if (waiting_for_child)
-    wait_sigint_received = 1;
-  else
-    {
-      set_exit_status (128+SIGINT);
-      restore_sigint_handler ();
-      kill (getpid (), SIGINT);
-    }
-
-  /* Otherwise effectively ignore the SIGINT and allow the running job to
-     be killed. */
-  SIGRETURN (0);
-}
-
-static int
-process_exit_signal (status)
-     WAIT status;
-{
-  return (WIFSIGNALED (status) ? WTERMSIG (status) : 0);
-}
-
-static int
-process_exit_status (status)
-     WAIT status;
-{
-  if (WIFSIGNALED (status))
-    return (128 + WTERMSIG (status));
-  else if (WIFSTOPPED (status) == 0)
-    return (WEXITSTATUS (status));
-  else
-    return (EXECUTION_SUCCESS);
-}
-
-static WAIT
-job_signal_status (job)
-     int job;
-{
-  register PROCESS *p;
-  WAIT s;
-
-  p = jobs[job]->pipe;
-  do
-    {
-      s = p->status;
-      if (WIFSIGNALED(s) || WIFSTOPPED(s))
-	break;
-      p = p->next;
-    }
-  while (p != jobs[job]->pipe);
-
-  return s;
-}
-  
-/* Return the exit status of the last process in the pipeline for job JOB.
-   This is the exit status of the entire job. */
-static WAIT
-raw_job_exit_status (job)
-     int job;
-{
-  register PROCESS *p;
-  int fail;
-  WAIT ret;
-
-  if (jobs[job]->flags & J_PIPEFAIL)
-    {
-      fail = 0;
-      p = jobs[job]->pipe;
-      do
-	{
-	  if (WSTATUS (p->status) != EXECUTION_SUCCESS)
-	    fail = WSTATUS(p->status);
-	  p = p->next;
-	}
-      while (p != jobs[job]->pipe);
-      WSTATUS (ret) = fail;
-      return ret;
-    }
-
-  for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next)
-    ;
-  return (p->status);
-}
-
-/* Return the exit status of job JOB.  This is the exit status of the last
-   (rightmost) process in the job's pipeline, modified if the job was killed
-   by a signal or stopped. */
-int
-job_exit_status (job)
-     int job;
-{
-  return (process_exit_status (raw_job_exit_status (job)));
-}
-
-int
-job_exit_signal (job)
-     int job;
-{
-  return (process_exit_signal (raw_job_exit_status (job)));
-}
-
-#define FIND_CHILD(pid, child) \
-  do \
-    { \
-      child = find_pipeline (pid, 0, (int *)NULL); \
-      if (child == 0) \
-	{ \
-	  give_terminal_to (shell_pgrp, 0); \
-	  UNBLOCK_CHILD (oset); \
-	  internal_error (_("wait_for: No record of process %ld"), (long)pid); \
-	  restore_sigint_handler (); \
-	  return (termination_state = 127); \
-	} \
-    } \
-  while (0)
-
-/* Wait for pid (one of our children) to terminate, then
-   return the termination state.  Returns 127 if PID is not found in
-   the jobs table.  Returns -1 if waitchld() returns -1, indicating
-   that there are no unwaited-for child processes. */
-int
-wait_for (pid, flags)
-     pid_t pid;
-     int flags;
-{
-  int job, termination_state, r;
-  WAIT s;
-  register PROCESS *child;
-  sigset_t set, oset;
-
-  /* In the case that this code is interrupted, and we longjmp () out of it,
-     we are relying on the code in throw_to_top_level () to restore the
-     top-level signal mask. */
-  child = 0;
-  BLOCK_CHILD (set, oset);
-
-  /* Ignore interrupts while waiting for a job run without job control
-     to finish.  We don't want the shell to exit if an interrupt is
-     received, only if one of the jobs run is killed via SIGINT.  If
-     job control is not set, the job will be run in the same pgrp as
-     the shell, and the shell will see any signals the job gets.  In
-     fact, we want this set every time the waiting shell and the waited-
-     for process are in the same process group, including command
-     substitution. */
-
-  /* This is possibly a race condition -- should it go in stop_pipeline? */
-  wait_sigint_received = child_caught_sigint = 0;
-  if (job_control == 0 || (subshell_environment&SUBSHELL_COMSUB))
-    {
-      SigHandler *temp_sigint_handler;
-
-      temp_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler);
-      if (temp_sigint_handler == wait_sigint_handler)
-	internal_debug ("wait_for: recursively setting old_sigint_handler to wait_sigint_handler: running_trap = %d", running_trap);
-      else
-	old_sigint_handler = temp_sigint_handler;
-      waiting_for_child = 0;
-      if (old_sigint_handler == SIG_IGN)
-	set_signal_handler (SIGINT, old_sigint_handler);
-    }
-
-  termination_state = last_command_exit_value;
-
-  if (interactive && job_control == 0)
-    QUIT;
-  /* Check for terminating signals and exit the shell if we receive one */
-  CHECK_TERMSIG;
-
-  /* Check for a trapped signal interrupting the wait builtin and jump out */
-  CHECK_WAIT_INTR;
-
-  /* If we say wait_for (), then we have a record of this child somewhere.
-     If it and none of its peers are running, don't call waitchld(). */
-
-  job = NO_JOB;
-  do
-    {
-      if (pid != ANY_PID)
-	FIND_CHILD (pid, child);
-
-      /* If this child is part of a job, then we are really waiting for the
-	 job to finish.  Otherwise, we are waiting for the child to finish.
-	 We check for JDEAD in case the job state has been set by waitchld
-	 after receipt of a SIGCHLD. */
-      if (job == NO_JOB && pid != ANY_PID)	/* XXX -- && pid != ANY_PID ? */
-	job = find_job (pid, 0, NULL);
-
-      /* waitchld() takes care of setting the state of the job.  If the job
-	 has already exited before this is called, sigchld_handler will have
-	 called waitchld and the state will be set to JDEAD. */
-
-      if (pid == ANY_PID || PRUNNING(child) || (job != NO_JOB && RUNNING (job)))
-	{
-	  int old_waiting;
-
-	  queue_sigchld = 1;
-	  old_waiting = waiting_for_child;
-	  waiting_for_child = 1;
-	  /* XXX - probably not strictly necessary but we want to catch
-	     everything that happened before we switch the behavior of
-	     trap_handler to longjmp on a trapped signal (waiting_for_child) */
-	  CHECK_WAIT_INTR;
-	  r = waitchld (pid, 1);	/* XXX */
-	  waiting_for_child = old_waiting;
-#if 0
-itrace("wait_for: blocking wait for %d returns %d child = %p", (int)pid, r, child);
-#endif
-	  queue_sigchld = 0;
-	  if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin)
-	    {
-	      termination_state = -1;
-	      /* XXX - restore sigint handler here */
-	      restore_sigint_handler ();
-	      goto wait_for_return;
-	    }
-
-	  /* If child is marked as running, but waitpid() returns -1/ECHILD,
-	     there is something wrong.  Somewhere, wait should have returned
-	     that child's pid.  Mark the child as not running and the job,
-	     if it exists, as JDEAD. */
-	  if (r == -1 && errno == ECHILD)
-	    {
-	      if (child)
-		{
-		  child->running = PS_DONE;
-		  WSTATUS (child->status) = 0;	/* XXX -- can't find true status */
-		}
-	      js.c_living = 0;		/* no living child processes */
-	      if (job != NO_JOB)
-		{
-		  jobs[job]->state = JDEAD;
-		  js.c_reaped++;
-		  js.j_ndead++;
-		}
-	      if (pid == ANY_PID)
-		{
-		  termination_state = -1;
-		  break;
-		}
-	    }
-	}
-
-      /* If the shell is interactive, and job control is disabled, see
-	 if the foreground process has died due to SIGINT and jump out
-	 of the wait loop if it has.  waitchld has already restored the
-	 old SIGINT signal handler. */
-      if (interactive && job_control == 0)
-	QUIT;
-      /* Check for terminating signals and exit the shell if we receive one */
-      CHECK_TERMSIG;
-
-      /* Check for a trapped signal interrupting the wait builtin and jump out */
-      CHECK_WAIT_INTR;
-
-      if (pid == ANY_PID)
-	{
-	  /* XXX - could set child but we don't have a handle on what waitchld
-	    reaps.  Leave termination_state alone. */
-	  restore_sigint_handler ();
-	  goto wait_for_return;
-	}
-    }
-  while (PRUNNING (child) || (job != NO_JOB && RUNNING (job)));
-
-  /* Restore the original SIGINT signal handler before we return. */
-  restore_sigint_handler ();
-
-  /* The exit state of the command is either the termination state of the
-     child, or the termination state of the job.  If a job, the status
-     of the last child in the pipeline is the significant one.  If the command
-     or job was terminated by a signal, note that value also. */
-  termination_state = (job != NO_JOB) ? job_exit_status (job)
-				      : (child ? process_exit_status (child->status) : EXECUTION_SUCCESS);
-  last_command_exit_signal = (job != NO_JOB) ? job_exit_signal (job)
-					     : (child ? process_exit_signal (child->status) : 0);
-
-  /* XXX */
-  if ((job != NO_JOB && JOBSTATE (job) == JSTOPPED) || (child && WIFSTOPPED (child->status)))
-    termination_state = 128 + WSTOPSIG (child->status);
-
-  if (job == NO_JOB || IS_JOBCONTROL (job))
-    {
-      /* XXX - under what circumstances is a job not present in the jobs
-	 table (job == NO_JOB)?
-	 	1.  command substitution
-
-	 In the case of command substitution, at least, it's probably not
-	 the right thing to give the terminal to the shell's process group,
-	 even though there is code in subst.c:command_substitute to work
-	 around it.
-
-	 Things that don't:
-		$PROMPT_COMMAND execution
-		process substitution
-       */
-#if 0
-if (job == NO_JOB)
-  itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp);
-#endif
-      /* Don't modify terminal pgrp if we are running in background or a
-	 subshell.  Make sure subst.c:command_substitute uses the same
-	 conditions to determine whether or not it should undo this and
-	 give the terminal to pipeline_pgrp. */
-      
-      if ((flags & JWAIT_NOTERM) == 0 && running_in_background == 0 &&
-	  (subshell_environment & (SUBSHELL_ASYNC|SUBSHELL_PIPE)) == 0)
-	give_terminal_to (shell_pgrp, 0);
-    }
-
-  /* If the command did not exit cleanly, or the job is just
-     being stopped, then reset the tty state back to what it
-     was before this command.  Reset the tty state and notify
-     the user of the job termination only if the shell is
-     interactive.  Clean up any dead jobs in either case. */
-  if (job != NO_JOB)
-    {
-      if (interactive_shell && subshell_environment == 0)
-	{
-	  /* This used to use `child->status'.  That's wrong, however, for
-	     pipelines.  `child' is the first process in the pipeline.  It's
-	     likely that the process we want to check for abnormal termination
-	     or stopping is the last process in the pipeline, especially if
-	     it's long-lived and the first process is short-lived.  Since we
-	     know we have a job here, we can check all the processes in this
-	     job's pipeline and see if one of them stopped or terminated due
-	     to a signal.  We might want to change this later to just check
-	     the last process in the pipeline.  If no process exits due to a
-	     signal, S is left as the status of the last job in the pipeline. */
-	  s = job_signal_status (job);
-
-	  if (WIFSIGNALED (s) || WIFSTOPPED (s))
-	    {
-	      set_tty_state ();
-
-	      /* If the current job was stopped or killed by a signal, and
-		 the user has requested it, get a possibly new window size */
-	      if (check_window_size && (job == js.j_current || IS_FOREGROUND (job)))
-		get_new_window_size (0, (int *)0, (int *)0);
-	    }
-	  else
-#if defined (READLINE)
-	    /* We don't want to do this if we are running a process during
-	       programmable completion or a command bound to `bind -x'. */
-	    if (RL_ISSTATE (RL_STATE_COMPLETING|RL_STATE_DISPATCHING|RL_STATE_TERMPREPPED) == 0)
-#endif
-	    get_tty_state ();
-
-	  /* If job control is enabled, the job was started with job
-	     control, the job was the foreground job, and it was killed
-	     by SIGINT, then print a newline to compensate for the kernel
-	     printing the ^C without a trailing newline. */
-	  if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) &&
-		WIFSIGNALED (s) && WTERMSIG (s) == SIGINT)
-	    {
-	      /* If SIGINT is not trapped and the shell is in a for, while,
-		 or until loop, act as if the shell received SIGINT as
-		 well, so the loop can be broken.  This doesn't call the
-		 SIGINT signal handler; maybe it should. */
-	      if (signal_is_trapped (SIGINT) == 0 && (loop_level || (shell_compatibility_level > 32 && executing_list)))
-		ADDINTERRUPT;
-	      /* Call any SIGINT trap handler if the shell is running a loop, so
-		 the loop can be broken.  This seems more useful and matches the
-		 behavior when the shell is running a builtin command in a loop
-		 when it is interrupted.  Change ADDINTERRUPT to
-		 trap_handler (SIGINT) to run the trap without interrupting the
-		 loop. */
-	      else if (signal_is_trapped (SIGINT) && loop_level)
-		ADDINTERRUPT;
-	      /* If an interactive shell with job control enabled is sourcing
-		 a file, allow the interrupt to terminate the file sourcing. */
-	      else if (interactive_shell && signal_is_trapped (SIGINT) == 0 && sourcelevel)
-		ADDINTERRUPT;
-	      else
-		{
-		  putchar ('\n');
-		  fflush (stdout);
-		}
-	    }
-	}
-      else if ((subshell_environment & (SUBSHELL_COMSUB|SUBSHELL_PIPE)) && wait_sigint_received)
-	{
-	  /* If waiting for a job in a subshell started to do command
-	     substitution or to run a pipeline element that consists of
-	     something like a while loop or a for loop, simulate getting
-	     and being killed by the SIGINT to pass the status back to our
-	     parent. */
-	  if (child_caught_sigint == 0 && signal_is_trapped (SIGINT) == 0)
-	    {
-	      UNBLOCK_CHILD (oset);
-	      old_sigint_handler = set_signal_handler (SIGINT, SIG_DFL);
-	      if (old_sigint_handler == SIG_IGN)
-		restore_sigint_handler ();
-	      else
-		kill (getpid (), SIGINT);
-	    }
-	}
-      else if (interactive_shell == 0 && subshell_environment == 0 && IS_FOREGROUND (job))
-	{
-	  s = job_signal_status (job);
-
-	  /* If we are non-interactive, but job control is enabled, and the job
-	     died due to SIGINT, pretend we got the SIGINT */
-	  if (job_control && IS_JOBCONTROL (job) && WIFSIGNALED (s) && WTERMSIG (s) == SIGINT)
-	    {
-	      ADDINTERRUPT;	/* For now */
-	    }
-
-	  if (check_window_size)
-	    get_new_window_size (0, (int *)0, (int *)0);
-	}
-
-      /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
-	 signal handler path */
-      if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/)
-	setjstatus (job);
-
-      /* If this job is dead, notify the user of the status.  If the shell
-	 is interactive, this will display a message on the terminal.  If
-	 the shell is not interactive, make sure we turn on the notify bit
-	 so we don't get an unwanted message about the job's termination,
-	 and so delete_job really clears the slot in the jobs table. */
-      notify_and_cleanup ();
-    }
-
-wait_for_return:
-
-  UNBLOCK_CHILD (oset);
-
-  return (termination_state);
-}
-
-/* Wait for the last process in the pipeline for JOB.  Returns whatever
-   wait_for returns: the last process's termination state or -1 if there
-   are no unwaited-for child processes or an error occurs.  If FLAGS
-   includes JWAIT_FORCE, we wait for the job to terminate, no just change
-   state */
-int
-wait_for_job (job, flags, ps)
-     int job, flags;
-     struct procstat *ps;
-{
-  pid_t pid;
-  int r, state;
-  sigset_t set, oset;
-
-  BLOCK_CHILD(set, oset);
-  state = JOBSTATE (job);
-  if (state == JSTOPPED)
-    internal_warning (_("wait_for_job: job %d is stopped"), job+1);
-
-  pid = find_last_pid (job, 0);
-  UNBLOCK_CHILD(oset);
-
-  do
-    {
-      r = wait_for (pid, 0);
-      if (r == -1 && errno == ECHILD)
-	mark_all_jobs_as_dead ();
-
-      CHECK_WAIT_INTR;
-
-      if ((flags & JWAIT_FORCE) == 0)
-	break;
-
-      BLOCK_CHILD (set, oset);
-      state = (job != NO_JOB && jobs[job]) ? JOBSTATE (job) : JDEAD;
-      UNBLOCK_CHILD (oset);
-    }
-  while (state != JDEAD);
-
-  /* POSIX.2: we can remove the job from the jobs table if we just waited
-     for it. */
-  BLOCK_CHILD (set, oset);
-  if (job != NO_JOB && jobs[job] && DEADJOB (job))
-    jobs[job]->flags |= J_NOTIFIED;
-  UNBLOCK_CHILD (oset);
-
-  if (ps)
-    {
-      ps->pid = pid;
-      ps->status = (r < 0) ? 127 : r;
-    }
-  return r;
-}
-
-/* Wait for any background job started by this shell to finish.  Very
-   similar to wait_for_background_pids().  Returns the exit status of
-   the next exiting job, -1 if there are no background jobs.  The caller
-   is responsible for translating -1 into the right return value. RPID,
-   if non-null, gets the pid of the job's process leader. */
-int
-wait_for_any_job (flags, ps)
-     int flags;
-     struct procstat *ps;
-{
-  pid_t pid;
-  int i, r;
-  sigset_t set, oset;
-
-  if (jobs_list_frozen)
-    return -1;
-
-  /* First see if there are any unnotified dead jobs that we can report on */
-  BLOCK_CHILD (set, oset);
-  for (i = 0; i < js.j_jobslots; i++)
-    {
-      if ((flags & JWAIT_WAITING) && jobs[i] && IS_WAITING (i) == 0)
-	continue;		/* if we don't want it, skip it */
-      if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i) == 0)
-	{
-return_job:
-	  r = job_exit_status (i);
-	  pid = find_last_pid (i, 0);
-	  if (ps)
-	    {
-	      ps->pid = pid;
-	      ps->status = r;
-	    }
-	  notify_of_job_status ();		/* XXX */
-	  delete_job (i, 0);
-#if defined (COPROCESS_SUPPORT)
-	  coproc_reap ();
-#endif
-	  UNBLOCK_CHILD (oset);
-	  return r;
-	}
-    }
-  UNBLOCK_CHILD (oset);
-
-  /* At this point, we have no dead jobs in the jobs table.  Wait until we
-     get one, even if it takes multiple pids exiting. */
-  for (;;)
-    {
-      /* Make sure there is a background job to wait for */
-      BLOCK_CHILD (set, oset);
-      for (i = 0; i < js.j_jobslots; i++)
-	if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0)
-	  break;
-      if (i == js.j_jobslots)
-	{
-	  UNBLOCK_CHILD (oset);
-	  return -1;
-	}
-
-      UNBLOCK_CHILD (oset);
-
-      QUIT;
-      CHECK_TERMSIG;
-      CHECK_WAIT_INTR;
-
-      errno = 0;
-      r = wait_for (ANY_PID, 0);	/* special sentinel value for wait_for */
-      if (r == -1 && errno == ECHILD)
-	mark_all_jobs_as_dead ();
-	
-      /* Now we see if we have any dead jobs and return the first one */
-      BLOCK_CHILD (set, oset);
-      for (i = 0; i < js.j_jobslots; i++)
-	{
-	  if ((flags & JWAIT_WAITING) && jobs[i] && IS_WAITING (i) == 0)
-	    continue;		/* if we don't want it, skip it */
-	  if (jobs[i] && DEADJOB (i))
-	    goto return_job;
-	}
-      UNBLOCK_CHILD (oset);
-    }
-
-  return -1;
-}
-
-/* Print info about dead jobs, and then delete them from the list
-   of known jobs.  This does not actually delete jobs when the
-   shell is not interactive, because the dead jobs are not marked
-   as notified. */
-void
-notify_and_cleanup ()
-{
-  if (jobs_list_frozen)
-    return;
-
-  if (interactive || interactive_shell == 0 || sourcelevel)
-    notify_of_job_status ();
-
-  cleanup_dead_jobs ();
-}
-
-/* Make dead jobs disappear from the jobs array without notification.
-   This is used when the shell is not interactive. */
-void
-reap_dead_jobs ()
-{
-  mark_dead_jobs_as_notified (0);
-  cleanup_dead_jobs ();
-}
-
-/* Return the next closest (chronologically) job to JOB which is in
-   STATE.  STATE can be JSTOPPED, JRUNNING.  NO_JOB is returned if
-   there is no next recent job. */
-static int
-most_recent_job_in_state (job, state)
-     int job;
-     JOB_STATE state;
-{
-  register int i, result;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-
-  for (result = NO_JOB, i = job - 1; i >= 0; i--)
-    {
-      if (jobs[i] && (JOBSTATE (i) == state))
-	{
-	  result = i;
-	  break;
-	}
-    }
-
-  UNBLOCK_CHILD (oset);
-
-  return (result);
-}
-
-/* Return the newest *stopped* job older than JOB, or NO_JOB if not
-   found. */
-static int
-job_last_stopped (job)
-     int job;
-{
-  return (most_recent_job_in_state (job, JSTOPPED));
-}
-
-/* Return the newest *running* job older than JOB, or NO_JOB if not
-   found. */
-static int
-job_last_running (job)
-     int job;
-{
-  return (most_recent_job_in_state (job, JRUNNING));
-}
-
-/* Make JOB be the current job, and make previous be useful.  Must be
-   called with SIGCHLD blocked. */
-static void
-set_current_job (job)
-     int job;
-{
-  int candidate;
-
-  if (js.j_current != job)
-    {
-      js.j_previous = js.j_current;
-      js.j_current = job;
-    }
-
-  /* First choice for previous job is the old current job. */
-  if (js.j_previous != js.j_current &&
-      js.j_previous != NO_JOB &&
-      jobs[js.j_previous] &&
-      STOPPED (js.j_previous))
-    return;
-
-  /* Second choice:  Newest stopped job that is older than
-     the current job. */
-  candidate = NO_JOB;
-  if (STOPPED (js.j_current))
-    {
-      candidate = job_last_stopped (js.j_current);
-
-      if (candidate != NO_JOB)
-	{
-	  js.j_previous = candidate;
-	  return;
-	}
-    }
-
-  /* If we get here, there is either only one stopped job, in which case it is
-     the current job and the previous job should be set to the newest running
-     job, or there are only running jobs and the previous job should be set to
-     the newest running job older than the current job.  We decide on which
-     alternative to use based on whether or not JOBSTATE(js.j_current) is
-     JSTOPPED. */
-
-  candidate = RUNNING (js.j_current) ? job_last_running (js.j_current)
-				    : job_last_running (js.j_jobslots);
-
-  if (candidate != NO_JOB)
-    {
-      js.j_previous = candidate;
-      return;
-    }
-
-  /* There is only a single job, and it is both `+' and `-'. */
-  js.j_previous = js.j_current;
-}
-
-/* Make current_job be something useful, if it isn't already. */
-
-/* Here's the deal:  The newest non-running job should be `+', and the
-   next-newest non-running job should be `-'.  If there is only a single
-   stopped job, the js.j_previous is the newest non-running job.  If there
-   are only running jobs, the newest running job is `+' and the
-   next-newest running job is `-'.  Must be called with SIGCHLD blocked. */
-
-static void
-reset_current ()
-{
-  int candidate;
-
-  if (js.j_jobslots && js.j_current != NO_JOB && jobs[js.j_current] && STOPPED (js.j_current))
-    candidate = js.j_current;
-  else
-    {
-      candidate = NO_JOB;
-
-      /* First choice: the previous job. */
-      if (js.j_previous != NO_JOB && jobs[js.j_previous] && STOPPED (js.j_previous))
-	candidate = js.j_previous;
-
-      /* Second choice: the most recently stopped job. */
-      if (candidate == NO_JOB)
-	candidate = job_last_stopped (js.j_jobslots);
-
-      /* Third choice: the newest running job. */
-      if (candidate == NO_JOB)
-	candidate = job_last_running (js.j_jobslots);
-    }
-
-  /* If we found a job to use, then use it.  Otherwise, there
-     are no jobs period. */
-  if (candidate != NO_JOB)
-    set_current_job (candidate);
-  else
-    js.j_current = js.j_previous = NO_JOB;
-}
-
-/* Set up the job structures so we know the job and its processes are
-   all running. */
-static void
-set_job_running (job)
-     int job;
-{
-  register PROCESS *p;
-
-  /* Each member of the pipeline is now running. */
-  p = jobs[job]->pipe;
-
-  do
-    {
-      if (WIFSTOPPED (p->status))
-	p->running = PS_RUNNING;	/* XXX - could be PS_STOPPED */
-      p = p->next;
-    }
-  while (p != jobs[job]->pipe);
-
-  /* This means that the job is running. */
-  JOBSTATE (job) = JRUNNING;
-}
-
-/* Start a job.  FOREGROUND if non-zero says to do that.  Otherwise,
-   start the job in the background.  JOB is a zero-based index into
-   JOBS.  Returns -1 if it is unable to start a job, and the return
-   status of the job otherwise. */
-int
-start_job (job, foreground)
-     int job, foreground;
-{
-  register PROCESS *p;
-  int already_running;
-  sigset_t set, oset;
-  char *wd, *s;
-  static TTYSTRUCT save_stty;
-
-  BLOCK_CHILD (set, oset);
-
-  if ((subshell_environment & SUBSHELL_COMSUB) && (pipeline_pgrp == shell_pgrp))
-    {
-      internal_error (_("%s: no current jobs"), this_command_name);
-      UNBLOCK_CHILD (oset);
-      return (-1);
-    }
-
-  if (DEADJOB (job))
-    {
-      internal_error (_("%s: job has terminated"), this_command_name);
-      UNBLOCK_CHILD (oset);
-      return (-1);
-    }
-
-  already_running = RUNNING (job);
-
-  if (foreground == 0 && already_running)
-    {
-      internal_error (_("%s: job %d already in background"), this_command_name, job + 1);
-      UNBLOCK_CHILD (oset);
-      return (0);		/* XPG6/SUSv3 says this is not an error */
-    }
-
-  wd = current_working_directory ();
-
-  /* You don't know about the state of this job.  Do you? */
-  jobs[job]->flags &= ~J_NOTIFIED;
-
-  if (foreground)
-    {
-      set_current_job (job);
-      jobs[job]->flags |= J_FOREGROUND;
-    }
-
-  /* Tell the outside world what we're doing. */
-  p = jobs[job]->pipe;
-
-  if (foreground == 0)
-    {
-      /* POSIX.2 says `bg' doesn't give any indication about current or
-	 previous job. */
-      if (posixly_correct == 0)
-	s = (job == js.j_current) ? "+ ": ((job == js.j_previous) ? "- " : " ");       
-      else
-	s = " ";
-      printf ("[%d]%s", job + 1, s);
-    }
-
-  do
-    {
-      printf ("%s%s",
-	       p->command ? p->command : "",
-	       p->next != jobs[job]->pipe? " | " : "");
-      p = p->next;
-    }
-  while (p != jobs[job]->pipe);
-
-  if (foreground == 0)
-    printf (" &");
-
-  if (strcmp (wd, jobs[job]->wd) != 0)
-    printf ("	(wd: %s)", polite_directory_format (jobs[job]->wd));
-
-  printf ("\n");
-
-  /* Run the job. */
-  if (already_running == 0)
-    set_job_running (job);
-
-  /* Save the tty settings before we start the job in the foreground. */
-  if (foreground)
-    {
-      get_tty_state ();
-      save_stty = shell_tty_info;
-      /* Give the terminal to this job. */
-      if (IS_JOBCONTROL (job))
-	give_terminal_to (jobs[job]->pgrp, 0);
-    }
-  else
-    jobs[job]->flags &= ~J_FOREGROUND;
-
-  /* If the job is already running, then don't bother jump-starting it. */
-  if (already_running == 0)
-    {
-      jobs[job]->flags |= J_NOTIFIED;
-      killpg (jobs[job]->pgrp, SIGCONT);
-    }
-
-  if (foreground)
-    {
-      pid_t pid;
-      int st;
-
-      pid = find_last_pid (job, 0);
-      UNBLOCK_CHILD (oset);
-      st = wait_for (pid, 0);
-      shell_tty_info = save_stty;
-      set_tty_state ();
-      return (st);
-    }
-  else
-    {
-      reset_current ();
-      UNBLOCK_CHILD (oset);
-      return (0);
-    }
-}
-
-/* Give PID SIGNAL.  This determines what job the pid belongs to (if any).
-   If PID does belong to a job, and the job is stopped, then CONTinue the
-   job after giving it SIGNAL.  Returns -1 on failure.  If GROUP is non-null,
-   then kill the process group associated with PID. */
-int
-kill_pid (pid, sig, group)
-     pid_t pid;
-     int sig, group;
-{
-  register PROCESS *p;
-  int job, result, negative;
-  sigset_t set, oset;
-
-  if (pid < -1)
-    {
-      pid = -pid;
-      group = negative = 1;
-    }
-  else
-    negative = 0;
-
-  result = EXECUTION_SUCCESS;
-  if (group)
-    {
-      BLOCK_CHILD (set, oset);
-      p = find_pipeline (pid, 0, &job);
-
-      if (job != NO_JOB)
-	{
-	  jobs[job]->flags &= ~J_NOTIFIED;
-
-	  /* Kill process in backquotes or one started without job control? */
-
-	  /* If we're passed a pid < -1, just call killpg and see what happens  */
-	  if (negative && jobs[job]->pgrp == shell_pgrp)
-	    result = killpg (pid, sig);
-	  /* If we're killing using job control notification, for example,
-	     without job control active, we have to do things ourselves. */
-	  else if (jobs[job]->pgrp == shell_pgrp)	/* XXX - IS_JOBCONTROL(job) == 0? */
-	    {
-	      p = jobs[job]->pipe;
-	      do
-		{
-		  if (PALIVE (p) == 0)
-		    continue;		/* avoid pid recycling problem */
-		  kill (p->pid, sig);
-		  if (PEXITED (p) && (sig == SIGTERM || sig == SIGHUP))
-		    kill (p->pid, SIGCONT);
-		  p = p->next;
-		}
-	      while  (p != jobs[job]->pipe);
-	    }
-	  else
-	    {
-	      result = killpg (jobs[job]->pgrp, sig);
-	      if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP))
-		killpg (jobs[job]->pgrp, SIGCONT);
-	      /* If we're continuing a stopped job via kill rather than bg or
-		 fg, emulate the `bg' behavior. */
-	      if (p && STOPPED (job) && (sig == SIGCONT))
-		{
-		  set_job_running (job);
-		  jobs[job]->flags &= ~J_FOREGROUND;
-		  jobs[job]->flags |= J_NOTIFIED;
-		}
-	    }
-	}
-      else
-	result = killpg (pid, sig);
-
-      UNBLOCK_CHILD (oset);
-    }
-  else
-    result = kill (pid, sig);
-
-  return (result);
-}
-
-/* sigchld_handler () flushes at least one of the children that we are
-   waiting for.  It gets run when we have gotten a SIGCHLD signal. */
-static sighandler
-sigchld_handler (sig)
-     int sig;
-{
-  int n, oerrno;
-
-  oerrno = errno;
-  REINSTALL_SIGCHLD_HANDLER;
-  sigchld++;
-  n = 0;
-  if (queue_sigchld == 0)
-    n = waitchld (-1, 0);
-  errno = oerrno;
-  SIGRETURN (n);
-}
-
-/* waitchld() reaps dead or stopped children.  It's called by wait_for and
-   sigchld_handler, and runs until there aren't any children terminating any
-   more.
-   If BLOCK is 1, this is to be a blocking wait for a single child, although
-   an arriving SIGCHLD could cause the wait to be non-blocking.  It returns
-   the number of children reaped, or -1 if there are no unwaited-for child
-   processes. */
-static int
-waitchld (wpid, block)
-     pid_t wpid;
-     int block;
-{
-  WAIT status;
-  PROCESS *child;
-  pid_t pid;
-  int ind;
-
-  int call_set_current, last_stopped_job, job, children_exited, waitpid_flags;
-  static int wcontinued = WCONTINUED;	/* run-time fix for glibc problem */
-
-  call_set_current = children_exited = 0;
-  last_stopped_job = NO_JOB;
-
-  do
-    {
-      /* We don't want to be notified about jobs stopping if job control
-	 is not active.  XXX - was interactive_shell instead of job_control */
-      waitpid_flags = (job_control && subshell_environment == 0)
-			? (WUNTRACED|wcontinued)
-			: 0;
-      if (sigchld || block == 0)
-	waitpid_flags |= WNOHANG;
-
-      /* Check for terminating signals and exit the shell if we receive one */
-      CHECK_TERMSIG;
-      /* Check for a trapped signal interrupting the wait builtin and jump out */
-      CHECK_WAIT_INTR;
-
-      if (block == 1 && queue_sigchld == 0 && (waitpid_flags & WNOHANG) == 0)
-	{
-	  internal_warning (_("waitchld: turning on WNOHANG to avoid indefinite block"));
-	  waitpid_flags |= WNOHANG;
-	}
-
-      pid = WAITPID (-1, &status, waitpid_flags);
-
-#if 0
-if (wpid != -1 && block)
-  itrace("waitchld: blocking waitpid returns %d", pid);
-#endif
-#if 0
-if (wpid != -1)
-  itrace("waitchld: %s waitpid returns %d", block?"blocking":"non-blocking", pid);
-#endif
-      /* WCONTINUED may be rejected by waitpid as invalid even when defined */
-      if (wcontinued && pid < 0 && errno == EINVAL)
-	{
-	  wcontinued = 0;
-	  continue;	/* jump back to the test and retry without WCONTINUED */
-	}
-
-      /* The check for WNOHANG is to make sure we decrement sigchld only
-	 if it was non-zero before we called waitpid. */
-      if (sigchld > 0 && (waitpid_flags & WNOHANG))
-	sigchld--;
-
-      /* If waitpid returns -1 with errno == ECHILD, there are no more
-	 unwaited-for child processes of this shell. */
-      if (pid < 0 && errno == ECHILD)
-	{
-	  if (children_exited == 0)
-	    return -1;
-	  else
-	    break;
-	}
-
-#if 0
-itrace("waitchld: waitpid returns %d block = %d children_exited = %d", pid, block, children_exited);
-#endif
-      /* If waitpid returns 0, there are running children.  If it returns -1,
-	 the only other error POSIX says it can return is EINTR. */
-      CHECK_TERMSIG;
-      CHECK_WAIT_INTR;
-
-      /* If waitpid returns -1/EINTR and the shell saw a SIGINT, then we
-	 assume the child has blocked or handled SIGINT.  In that case, we
-	 require the child to actually die due to SIGINT to act on the
-	 SIGINT we received; otherwise we assume the child handled it and
-	 let it go. */
-      if (pid < 0 && errno == EINTR && wait_sigint_received)
-	child_caught_sigint = 1;
-
-      if (pid <= 0)
-	continue;	/* jumps right to the test */
-
-      /* Linux kernels appear to signal the parent but not interrupt the
-	 waitpid() (or restart it even without SA_RESTART) on SIGINT, so if
-	 we saw a SIGINT and the process exited or died due to some other
-	 signal, assume the child caught the SIGINT. */
-      if (wait_sigint_received && (WIFSIGNALED (status) == 0 || WTERMSIG (status) != SIGINT))
-	child_caught_sigint = 1;
-
-      /* If the child process did die due to SIGINT, forget our assumption
-	 that it caught or otherwise handled it. */
-      if (WIFSIGNALED (status) && WTERMSIG (status) == SIGINT)
-	child_caught_sigint = 0;
-
-      /* children_exited is used to run traps on SIGCHLD.  We don't want to
-	 run the trap if a process is just being continued. */
-      if (WIFCONTINUED(status) == 0)
-	{
-	  children_exited++;
-	  js.c_living--;
-	}
-
-      /* Locate our PROCESS for this pid. */
-      child = find_process (pid, 1, &job);	/* want living procs only */
-
-#if defined (COPROCESS_SUPPORT)
-      coproc_pidchk (pid, WSTATUS(status));
-#endif
-
-#if defined (PROCESS_SUBSTITUTION)
-      /* Only manipulate the list of process substitutions while SIGCHLD
-	 is blocked. We only use this as a hint that we can remove FIFOs
-	 or close file descriptors corresponding to terminated process
-	 substitutions. */
-      if ((ind = find_procsub_child (pid)) >= 0)
-	set_procsub_status (ind, pid, WSTATUS (status));
-#endif
-
-      /* It is not an error to have a child terminate that we did
-	 not have a record of.  This child could have been part of
-	 a pipeline in backquote substitution.  Even so, I'm not
-	 sure child is ever non-zero. */
-      if (child == 0)
-	{
-	  if (WIFEXITED (status) || WIFSIGNALED (status))
-	    js.c_reaped++;
-	  continue;
-	}
-
-      /* Remember status, and whether or not the process is running. */
-      child->status = status;
-      child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE;
-
-      if (PEXITED (child))
-	{
-	  js.c_totreaped++;
-	  if (job != NO_JOB)
-	    js.c_reaped++;
-	}
-
-      if (job == NO_JOB)
-	continue;
-
-      call_set_current += set_job_status_and_cleanup (job);
-
-      if (STOPPED (job))
-	last_stopped_job = job;
-      else if (DEADJOB (job) && last_stopped_job == job)
-	last_stopped_job = NO_JOB;
-    }
-  while ((sigchld || block == 0) && pid > (pid_t)0);
-
-  /* If a job was running and became stopped, then set the current
-     job.  Otherwise, don't change a thing. */
-  if (call_set_current)
-    {
-      if (last_stopped_job != NO_JOB)
-	set_current_job (last_stopped_job);
-      else
-	reset_current ();
-    }
-
-  /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
-  if (children_exited &&
-      (signal_is_trapped (SIGCHLD) || trap_list[SIGCHLD] == (char *)IMPOSSIBLE_TRAP_HANDLER) &&
-      trap_list[SIGCHLD] != (char *)IGNORE_SIG)
-    {
-      if (posixly_correct && this_shell_builtin && this_shell_builtin == wait_builtin)
-	{
-	  /* This was trap_handler (SIGCHLD) but that can lose traps if
-	     children_exited > 1 */
-	  queue_sigchld_trap (children_exited);
-	  wait_signal_received = SIGCHLD;
-	  /* If we're in a signal handler, let CHECK_WAIT_INTR pick it up;
-	     run_pending_traps will call run_sigchld_trap later  */
-	  if (sigchld == 0 && wait_intr_flag)
-	    sh_longjmp (wait_intr_buf, 1);
-	}
-      /* If not in posix mode and not executing the wait builtin, queue the
-	 signal for later handling.  Run the trap immediately if we are
-	 executing the wait builtin, but don't break out of `wait'. */
-      else if (sigchld)	/* called from signal handler */
-	queue_sigchld_trap (children_exited);
-      else if (signal_in_progress (SIGCHLD))
-	queue_sigchld_trap (children_exited);     
-      else if (trap_list[SIGCHLD] == (char *)IMPOSSIBLE_TRAP_HANDLER)
-	queue_sigchld_trap (children_exited);
-      else if (running_trap)
-	queue_sigchld_trap (children_exited);
-      else if (this_shell_builtin == wait_builtin)
-	run_sigchld_trap (children_exited);	/* XXX */
-      else
-	queue_sigchld_trap (children_exited);
-    }
-
-  /* We have successfully recorded the useful information about this process
-     that has just changed state.  If we notify asynchronously, and the job
-     that this process belongs to is no longer running, then notify the user
-     of that fact now. */
-  if (asynchronous_notification && interactive && executing_builtin == 0)
-    notify_of_job_status ();
-
-  return (children_exited);
-}
-
-/* Set the status of JOB and perform any necessary cleanup if the job is
-   marked as JDEAD.
-
-   Currently, the cleanup activity is restricted to handling any SIGINT
-   received while waiting for a foreground job to finish. */
-static int
-set_job_status_and_cleanup (job)
-     int job;
-{
-  PROCESS *child;
-  int tstatus, job_state, any_stopped, any_tstped, call_set_current;
-  SigHandler *temp_handler;
-
-  child = jobs[job]->pipe;
-  jobs[job]->flags &= ~J_NOTIFIED;
-
-  call_set_current = 0;
-
-  /*
-   * COMPUTE JOB STATUS
-   */
-
-  /* If all children are not running, but any of them is  stopped, then
-     the job is stopped, not dead. */
-  job_state = any_stopped = any_tstped = 0;
-  do
-    {
-      job_state |= PRUNNING (child);
-#if 0
-      if (PEXITED (child) && (WIFSTOPPED (child->status)))
-#else
-      /* Only checking for WIFSTOPPED now, not for PS_DONE */
-      if (PSTOPPED (child))
-#endif
-	{
-	  any_stopped = 1;
-	  any_tstped |= job_control && (WSTOPSIG (child->status) == SIGTSTP);
-	}
-      child = child->next;
-    }
-  while (child != jobs[job]->pipe);
-
-  /* If job_state != 0, the job is still running, so don't bother with
-     setting the process exit status and job state unless we're
-     transitioning from stopped to running. */
-  if (job_state != 0 && JOBSTATE(job) != JSTOPPED)
-    return 0;
-
-  /*
-   * SET JOB STATUS
-   */
-
-  /* The job is either stopped or dead.  Set the state of the job accordingly. */
-  if (any_stopped)
-    {
-      jobs[job]->state = JSTOPPED;
-      jobs[job]->flags &= ~J_FOREGROUND;
-      call_set_current++;
-      /* Suspending a job with SIGTSTP breaks all active loops. */
-      if (any_tstped && loop_level)
-	breaking = loop_level;
-    }
-  else if (job_state != 0)	/* was stopped, now running */
-    {
-      jobs[job]->state = JRUNNING;
-      call_set_current++;
-    }
-  else
-    {
-      jobs[job]->state = JDEAD;
-      js.j_ndead++;
-
-#if 0
-      if (IS_FOREGROUND (job))
-	setjstatus (job);
-#endif
-
-      /* If this job has a cleanup function associated with it, call it
-	 with `cleanarg' as the single argument, then set the function
-	 pointer to NULL so it is not inadvertently called twice.  The
-	 cleanup function is responsible for deallocating cleanarg. */
-      if (jobs[job]->j_cleanup)
-	{
-	  (*jobs[job]->j_cleanup) (jobs[job]->cleanarg);
-	  jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL;
-	}
-    }
-
-  /*
-   * CLEANUP
-   *
-   * Currently, we just do special things if we got a SIGINT while waiting
-   * for a foreground job to complete
-   */
-
-  if (JOBSTATE (job) == JDEAD)
-    {
-      /* If we're running a shell script and we get a SIGINT with a
-	 SIGINT trap handler, but the foreground job handles it and
-	 does not exit due to SIGINT, run the trap handler but do not
-	 otherwise act as if we got the interrupt. */
-      if (wait_sigint_received && interactive_shell == 0 &&
-	  child_caught_sigint && IS_FOREGROUND (job) &&
-	  signal_is_trapped (SIGINT))
-	{
-	  int old_frozen;
-	  wait_sigint_received = 0;
-	  last_command_exit_value = process_exit_status (child->status);
-
-	  old_frozen = jobs_list_frozen;
-	  jobs_list_frozen = 1;
-	  tstatus = maybe_call_trap_handler (SIGINT);
-	  jobs_list_frozen = old_frozen;
-	}
-
-      /* If the foreground job is killed by SIGINT when job control is not
-	 active, we need to perform some special handling.
-
-	 The check of wait_sigint_received is a way to determine if the
-	 SIGINT came from the keyboard (in which case the shell has already
-	 seen it, and wait_sigint_received is non-zero, because keyboard
-	 signals are sent to process groups) or via kill(2) to the foreground
-	 process by another process (or itself).  If the shell did receive the
-	 SIGINT, it needs to perform normal SIGINT processing.  XXX - should
-	 this change its behavior depending on whether the last command in an
-	 pipeline exited due to SIGINT, or any process in the pipeline?  Right
-	 now it does this if any process in the pipeline exits due to SIGINT. */
-      else if (wait_sigint_received &&
-	      child_caught_sigint == 0 &&
-	      IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0)
-	{
-	  int old_frozen;
-
-	  wait_sigint_received = 0;
-
-	  /* If SIGINT is trapped, set the exit status so that the trap
-	     handler can see it. */
-	  if (signal_is_trapped (SIGINT))
-	    last_command_exit_value = process_exit_status (child->status);
-
-	  /* If the signal is trapped, let the trap handler get it no matter
-	     what and simply return if the trap handler returns.
-	     maybe_call_trap_handler() may cause dead jobs to be removed from
-	     the job table because of a call to execute_command.  We work
-	     around this by setting JOBS_LIST_FROZEN. */
-	  old_frozen = jobs_list_frozen;
-	  jobs_list_frozen = 1;
-	  tstatus = maybe_call_trap_handler (SIGINT);
-	  jobs_list_frozen = old_frozen;
-	  if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER)
-	    {
-	      /* wait_sigint_handler () has already seen SIGINT and
-		 allowed the wait builtin to jump out.  We need to
-		 call the original SIGINT handler, if necessary.  If
-		 the original handler is SIG_DFL, we need to resend
-		 the signal to ourselves. */
-
-	      temp_handler = old_sigint_handler;
-
-	      /* Bogus.  If we've reset the signal handler as the result
-		 of a trap caught on SIGINT, then old_sigint_handler
-		 will point to trap_handler, which now knows nothing about
-		 SIGINT (if we reset the sighandler to the default).
-		 In this case, we have to fix things up.  What a crock. */
-	      if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0)
-		  temp_handler = trap_to_sighandler (SIGINT);
-	      restore_sigint_handler ();
-	      if (temp_handler == SIG_DFL)
-		termsig_handler (SIGINT);	/* XXX */
-	      else if (temp_handler != SIG_IGN)
-		(*temp_handler) (SIGINT);
-	    }
-	}
-    }
-
-  return call_set_current;
-}
-
-/* Build the array of values for the $PIPESTATUS variable from the set of
-   exit statuses of all processes in the job J. */
-static void
-setjstatus (j)
-     int j;
-{
-#if defined (ARRAY_VARS)
-  register int i;
-  register PROCESS *p;
-
-  for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++)
-    ;
-  i++;
-  if (statsize < i)
-    {
-      pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int));
-      statsize = i;
-    }
-  i = 0;
-  p = jobs[j]->pipe;
-  do
-    {
-      pstatuses[i++] = process_exit_status (p->status);
-      p = p->next;
-    }
-  while (p != jobs[j]->pipe);
-
-  pstatuses[i] = -1;	/* sentinel */
-  set_pipestatus_array (pstatuses, i);
-#endif
-}
-
-void
-run_sigchld_trap (nchild)
-     int nchild;
-{
-  char *trap_command;
-  int i;
-
-  /* Turn off the trap list during the call to parse_and_execute ()
-     to avoid potentially infinite recursive calls.  Preserve the
-     values of last_command_exit_value, last_made_pid, and the_pipeline
-     around the execution of the trap commands. */
-  trap_command = savestring (trap_list[SIGCHLD]);
-
-  begin_unwind_frame ("SIGCHLD trap");
-  unwind_protect_int (last_command_exit_value);
-  unwind_protect_int (last_command_exit_signal);
-  unwind_protect_var (last_made_pid);
-  unwind_protect_int (jobs_list_frozen);
-  unwind_protect_pointer (the_pipeline);
-  unwind_protect_pointer (subst_assign_varlist);
-  unwind_protect_pointer (this_shell_builtin);
-  unwind_protect_pointer (temporary_env);
-
-  /* We have to add the commands this way because they will be run
-     in reverse order of adding.  We don't want maybe_set_sigchld_trap ()
-     to reference freed memory. */
-  add_unwind_protect (xfree, trap_command);
-  add_unwind_protect (maybe_set_sigchld_trap, trap_command);
-
-  subst_assign_varlist = (WORD_LIST *)NULL;
-  the_pipeline = (PROCESS *)NULL;
-  temporary_env = 0;	/* traps should not run with temporary env */
-
-  running_trap = SIGCHLD + 1;
-
-  set_impossible_sigchld_trap ();
-  jobs_list_frozen = 1;
-  for (i = 0; i < nchild; i++)
-    {
-      parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST|SEVAL_RESETLINE);
-    }
-
-  run_unwind_frame ("SIGCHLD trap");
-  running_trap = 0;
-}
-
-/* Function to call when you want to notify people of changes
-   in job status.  This prints out all jobs which are pending
-   notification to stderr, and marks those printed as already
-   notified, thus making them candidates for cleanup. */
-static void
-notify_of_job_status ()
-{
-  register int job, termsig;
-  char *dir;
-  sigset_t set, oset;
-  WAIT s;
-
-  if (jobs == 0 || js.j_jobslots == 0)
-    return;
-
-  if (old_ttou != 0)
-    {
-      sigemptyset (&set);
-      sigaddset (&set, SIGCHLD);
-      sigaddset (&set, SIGTTOU);
-      sigemptyset (&oset);
-      sigprocmask (SIG_BLOCK, &set, &oset);
-    }
-  else
-    queue_sigchld++;
-
-  /* XXX could use js.j_firstj here */
-  for (job = 0, dir = (char *)NULL; job < js.j_jobslots; job++)
-    {
-      if (jobs[job] && IS_NOTIFIED (job) == 0)
-	{
-	  s = raw_job_exit_status (job);
-	  termsig = WTERMSIG (s);
-
-	  /* POSIX.2 says we have to hang onto the statuses of at most the
-	     last CHILD_MAX background processes if the shell is running a
-	     script.  If the shell is running a script, either from a file
-	     or standard input, don't print anything unless the job was
-	     killed by a signal. */
-	  if (startup_state == 0 && WIFSIGNALED (s) == 0 &&
-		((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job)))
-	    continue;
-	  
-	  /* If job control is disabled, don't print the status messages.
-	     Mark dead jobs as notified so that they get cleaned up.  If
-	     startup_state == 2 and subshell_environment has the
-	     SUBSHELL_COMSUB bit turned on, we were started to run a command
-	     substitution, so don't print anything.
-	     Otherwise, if the shell is not interactive, POSIX says that `jobs'
-	     is the only way to notify of job status. */
-	  if ((job_control == 0 && interactive_shell) ||
-	      (startup_state == 2 && (subshell_environment & SUBSHELL_COMSUB)) ||
-	      (startup_state == 2 && posixly_correct && (subshell_environment & SUBSHELL_COMSUB) == 0))
-	    {
-	      /* POSIX.2 compatibility:  if the shell is not interactive,
-		 hang onto the job corresponding to the last asynchronous
-		 pid until the user has been notified of its status or does
-		 a `wait'. */
-	      if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid)))
-		jobs[job]->flags |= J_NOTIFIED;
-	      continue;
-	    }
-
-	  /* Print info on jobs that are running in the background,
-	     and on foreground jobs that were killed by anything
-	     except SIGINT (and possibly SIGPIPE). */
-	  switch (JOBSTATE (job))
-	    {
-	    case JDEAD:
-	      if (interactive_shell == 0 && termsig && WIFSIGNALED (s) &&
-		  termsig != SIGINT &&
-#if defined (DONT_REPORT_SIGTERM)
-		  termsig != SIGTERM &&
-#endif
-#if defined (DONT_REPORT_SIGPIPE)
-		  termsig != SIGPIPE &&
-#endif
-		  signal_is_trapped (termsig) == 0)
-		{
-		  /* Don't print `0' for a line number. */
-		  fprintf (stderr, _("%s: line %d: "), get_name_for_error (), (line_number == 0) ? 1 : line_number);
-		  pretty_print_job (job, JLIST_NONINTERACTIVE, stderr);
-		}
-	      else if (IS_FOREGROUND (job))
-		{
-#if !defined (DONT_REPORT_SIGPIPE)
-		  if (termsig && WIFSIGNALED (s) && termsig != SIGINT)
-#else
-		  if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE)
-#endif
-		    {
-		      fprintf (stderr, "%s", j_strsignal (termsig));
-
-		      if (WIFCORED (s))
-			fprintf (stderr, _(" (core dumped)"));
-
-		      fprintf (stderr, "\n");
-		    }
-		}
-	      else if (job_control)	/* XXX job control test added */
-		{
-		  if (dir == 0)
-		    dir = current_working_directory ();
-		  pretty_print_job (job, JLIST_STANDARD, stderr);
-		  if (dir && strcmp (dir, jobs[job]->wd) != 0)
-		    fprintf (stderr,
-			     _("(wd now: %s)\n"), polite_directory_format (dir));
-		}
-
-	      jobs[job]->flags |= J_NOTIFIED;
-	      break;
-
-	    case JSTOPPED:
-	      fprintf (stderr, "\n");
-	      if (dir == 0)
-		dir = current_working_directory ();
-	      pretty_print_job (job, JLIST_STANDARD, stderr);
-	      if (dir && (strcmp (dir, jobs[job]->wd) != 0))
-		fprintf (stderr,
-			 _("(wd now: %s)\n"), polite_directory_format (dir));
-	      jobs[job]->flags |= J_NOTIFIED;
-	      break;
-
-	    case JRUNNING:
-	    case JMIXED:
-	      break;
-
-	    default:
-	      programming_error ("notify_of_job_status");
-	    }
-	}
-    }
-  if (old_ttou != 0)
-    sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
-  else
-    queue_sigchld--;
-}
-
-/* Initialize the job control mechanism, and set up the tty stuff. */
-int
-initialize_job_control (force)
-     int force;
-{
-  pid_t t;
-  int t_errno, tty_sigs;
-
-  t_errno = -1;
-  shell_pgrp = getpgid (0);
-
-  if (shell_pgrp == -1)
-    {
-      sys_error (_("initialize_job_control: getpgrp failed"));
-      exit (1);
-    }
-
-  /* We can only have job control if we are interactive unless we force it. */
-  if (interactive == 0 && force == 0)
-    {
-      job_control = 0;
-      original_pgrp = NO_PID;
-      shell_tty = fileno (stderr);
-      terminal_pgrp = tcgetpgrp (shell_tty);	/* for checking later */
-    }
-  else
-    {
-      shell_tty = -1;
-
-      /* If forced_interactive is set, we skip the normal check that stderr
-	 is attached to a tty, so we need to check here.  If it's not, we
-	 need to see whether we have a controlling tty by opening /dev/tty,
-	 since trying to use job control tty pgrp manipulations on a non-tty
-	 is going to fail. */
-      if (forced_interactive && isatty (fileno (stderr)) == 0)
-	shell_tty = open ("/dev/tty", O_RDWR|O_NONBLOCK);
-
-      /* Get our controlling terminal.  If job_control is set, or
-	 interactive is set, then this is an interactive shell no
-	 matter where fd 2 is directed. */
-      if (shell_tty == -1)
-	shell_tty = dup (fileno (stderr));	/* fd 2 */
-
-      if (shell_tty != -1)
-	shell_tty = move_to_high_fd (shell_tty, 1, -1);
-
-      /* Compensate for a bug in systems that compiled the BSD
-	 rlogind with DEBUG defined, like NeXT and Alliant. */
-      if (shell_pgrp == 0)
-	{
-	  shell_pgrp = getpid ();
-	  setpgid (0, shell_pgrp);
-	  if (shell_tty != -1)
-	    tcsetpgrp (shell_tty, shell_pgrp);
-	}
-
-      tty_sigs = 0;
-      while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1)
-	{
-	  if (shell_pgrp != terminal_pgrp)
-	    {
-	      SigHandler *ottin;
-
-	      CHECK_TERMSIG;
-	      ottin = set_signal_handler (SIGTTIN, SIG_DFL);
-	      kill (0, SIGTTIN);
-	      set_signal_handler (SIGTTIN, ottin);
-	      if (tty_sigs++ > 16)
-		{
-		  sys_error (_("initialize_job_control: no job control in background"));
-		  job_control = 0;
-		  original_pgrp = terminal_pgrp;	/* for eventual give_terminal_to */
-		  goto just_bail;
-		}
-	      continue;
-	    }
-	  break;
-	}
-
-      if (terminal_pgrp == -1)
-	t_errno = errno;
-
-      /* Make sure that we are using the new line discipline. */
-      if (set_new_line_discipline (shell_tty) < 0)
-	{
-	  sys_error (_("initialize_job_control: line discipline"));
-	  job_control = 0;
-	}
-      else
-	{
-	  original_pgrp = shell_pgrp;
-	  shell_pgrp = getpid ();
-
-	  if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0))
-	    {
-	      sys_error (_("initialize_job_control: setpgid"));
-	      shell_pgrp = original_pgrp;
-	    }
-
-	  job_control = 1;
-
-	  /* If (and only if) we just set our process group to our pid,
-	     thereby becoming a process group leader, and the terminal
-	     is not in the same process group as our (new) process group,
-	     then set the terminal's process group to our (new) process
-	     group.  If that fails, set our process group back to what it
-	     was originally (so we can still read from the terminal) and
-	     turn off job control.  */
-	  if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp)
-	    {
-	      if (give_terminal_to (shell_pgrp, 0) < 0)
-		{
-		  t_errno = errno;
-		  setpgid (0, original_pgrp);
-		  shell_pgrp = original_pgrp;
-		  errno = t_errno;
-		  sys_error (_("cannot set terminal process group (%d)"), shell_pgrp);
-		  job_control = 0;
-		}
-	    }
-
-	  if (job_control && ((t = tcgetpgrp (shell_tty)) == -1 || t != shell_pgrp))
-	    {
-	      if (t_errno != -1)
-		errno = t_errno;
-	      sys_error (_("cannot set terminal process group (%d)"), t);
-	      job_control = 0;
-	    }
-	}
-      if (job_control == 0)
-	internal_error (_("no job control in this shell"));
-    }
-
-just_bail:
-  running_in_background = terminal_pgrp != shell_pgrp;
-
-  if (shell_tty != fileno (stderr))
-    SET_CLOSE_ON_EXEC (shell_tty);
-
-  set_signal_handler (SIGCHLD, sigchld_handler);
-
-  change_flag ('m', job_control ? '-' : '+');
-
-  if (interactive)
-    get_tty_state ();
-
-  set_maxchild (0);
-
-  return job_control;
-}
-
-#ifdef DEBUG
-void
-debug_print_pgrps ()
-{
-  itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
-	 (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp);
-  itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
-	 shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0));
-  itrace("pipeline_pgrp -> %ld", (long)pipeline_pgrp);
-}
-#endif
-
-/* Set the line discipline to the best this system has to offer.
-   Return -1 if this is not possible. */
-static int
-set_new_line_discipline (tty)
-     int tty;
-{
-#if defined (NEW_TTY_DRIVER)
-  int ldisc;
-
-  if (ioctl (tty, TIOCGETD, &ldisc) < 0)
-    return (-1);
-
-  if (ldisc != NTTYDISC)
-    {
-      ldisc = NTTYDISC;
-
-      if (ioctl (tty, TIOCSETD, &ldisc) < 0)
-	return (-1);
-    }
-  return (0);
-#endif /* NEW_TTY_DRIVER */
-
-#if defined (TERMIO_TTY_DRIVER)
-#  if defined (TERMIO_LDISC) && (NTTYDISC)
-  if (ioctl (tty, TCGETA, &shell_tty_info) < 0)
-    return (-1);
-
-  if (shell_tty_info.c_line != NTTYDISC)
-    {
-      shell_tty_info.c_line = NTTYDISC;
-      if (ioctl (tty, TCSETAW, &shell_tty_info) < 0)
-	return (-1);
-    }
-#  endif /* TERMIO_LDISC && NTTYDISC */
-  return (0);
-#endif /* TERMIO_TTY_DRIVER */
-
-#if defined (TERMIOS_TTY_DRIVER)
-#  if defined (TERMIOS_LDISC) && defined (NTTYDISC)
-  if (tcgetattr (tty, &shell_tty_info) < 0)
-    return (-1);
-
-  if (shell_tty_info.c_line != NTTYDISC)
-    {
-      shell_tty_info.c_line = NTTYDISC;
-      if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0)
-	return (-1);
-    }
-#  endif /* TERMIOS_LDISC && NTTYDISC */
-  return (0);
-#endif /* TERMIOS_TTY_DRIVER */
-
-#if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
-  return (-1);
-#endif
-}
-
-/* Setup this shell to handle C-C, etc. */
-void
-initialize_job_signals ()
-{
-  if (interactive)
-    {
-      set_signal_handler (SIGINT, sigint_sighandler);
-      set_signal_handler (SIGTSTP, SIG_IGN);
-      set_signal_handler (SIGTTOU, SIG_IGN);
-      set_signal_handler (SIGTTIN, SIG_IGN);
-    }
-  else if (job_control)
-    {
-      old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler);
-      old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler);
-      old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler);
-    }
-  /* Leave disposition unmodified for non-interactive shells without job
-     control. */
-}
-
-/* Here we handle CONT signals. */
-static sighandler
-sigcont_sighandler (sig)
-     int sig;
-{
-  initialize_job_signals ();
-  set_signal_handler (SIGCONT, old_cont);
-  kill (getpid (), SIGCONT);
-
-  SIGRETURN (0);
-}
-
-/* Here we handle stop signals while we are running not as a login shell. */
-static sighandler
-sigstop_sighandler (sig)
-     int sig;
-{
-  set_signal_handler (SIGTSTP, old_tstp);
-  set_signal_handler (SIGTTOU, old_ttou);
-  set_signal_handler (SIGTTIN, old_ttin);
-
-  old_cont = set_signal_handler (SIGCONT, sigcont_sighandler);
-
-  give_terminal_to (shell_pgrp, 0);
-
-  kill (getpid (), sig);
-
-  SIGRETURN (0);
-}
-
-/* Give the terminal to PGRP.  */
-int
-give_terminal_to (pgrp, force)
-     pid_t pgrp;
-     int force;
-{
-  sigset_t set, oset;
-  int r, e;
-
-  r = 0;
-  if (job_control || force)
-    {
-      sigemptyset (&set);
-      sigaddset (&set, SIGTTOU);
-      sigaddset (&set, SIGTTIN);
-      sigaddset (&set, SIGTSTP);
-      sigaddset (&set, SIGCHLD);
-      sigemptyset (&oset);
-      sigprocmask (SIG_BLOCK, &set, &oset);
-
-      if (tcsetpgrp (shell_tty, pgrp) < 0)
-	{
-	  /* Maybe we should print an error message? */
-#if 0
-	  sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
-	    shell_tty, (long)getpid(), (long)pgrp);
-#endif
-	  r = -1;
-	  e = errno;
-	}
-      else
-	terminal_pgrp = pgrp;
-      sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
-    }
-
-  if (r == -1)
-    errno = e;
-
-  return r;
-}
-
-/* Give terminal to NPGRP iff it's currently owned by OPGRP.  FLAGS are the
-   flags to pass to give_terminal_to(). */
-static int
-maybe_give_terminal_to (opgrp, npgrp, flags)
-     pid_t opgrp, npgrp;
-     int flags;
-{
-  int tpgrp;
-
-  tpgrp = tcgetpgrp (shell_tty);
-  if (tpgrp < 0 && errno == ENOTTY)
-    return -1;
-  if (tpgrp == npgrp)
-    {
-      terminal_pgrp = npgrp;
-      return 0;
-    }
-  else if (tpgrp != opgrp)
-    {
-      internal_debug ("%d: maybe_give_terminal_to: terminal pgrp == %d shell pgrp = %d new pgrp = %d in_background = %d", (int)getpid(), tpgrp, opgrp, npgrp, running_in_background);
-      return -1;
-    }
-  else
-    return (give_terminal_to (npgrp, flags));     
-}
-
-/* Clear out any jobs in the job array.  This is intended to be used by
-   children of the shell, who should not have any job structures as baggage
-   when they start executing (forking subshells for parenthesized execution
-   and functions with pipes are the two that spring to mind).  If RUNNING_ONLY
-   is nonzero, only running jobs are removed from the table. */
-void
-delete_all_jobs (running_only)
-     int running_only;
-{
-  register int i;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-
-  /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
-  if (js.j_jobslots)
-    {
-      js.j_current = js.j_previous = NO_JOB;
-
-      /* XXX could use js.j_firstj here */
-      for (i = 0; i < js.j_jobslots; i++)
-	{
-	  if (i < js.j_firstj && jobs[i])
-	    INTERNAL_DEBUG (("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj));
-	  if (i > js.j_lastj && jobs[i])
-	    INTERNAL_DEBUG (("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj));
-
-	  if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
-	    /* We don't want to add any of these pids to bgpids.  If running_only
-	       is non-zero, we don't want to add running jobs to the list.
-	       If we are interested in all jobs, not just running jobs, and
-	       we are going to clear the bgpids list below (bgp_clear()), we
-	       don't need to bother. */
-	    delete_job (i, DEL_WARNSTOPPED|DEL_NOBGPID);
-	}
-      if (running_only == 0)
-	{
-	  free ((char *)jobs);
-	  js.j_jobslots = 0;
-	  js.j_firstj = js.j_lastj = js.j_njobs = 0;
-	}
-    }
-
-  if (running_only == 0)
-    bgp_clear ();
-
-  UNBLOCK_CHILD (oset);
-}
-
-/* Mark all jobs in the job array so that they don't get a SIGHUP when the
-   shell gets one.  If RUNNING_ONLY is nonzero, mark only running jobs. */
-void
-nohup_all_jobs (running_only)
-     int running_only;
-{
-  register int i;
-  sigset_t set, oset;
-
-  BLOCK_CHILD (set, oset);
-
-  if (js.j_jobslots)
-    {
-      /* XXX could use js.j_firstj here */
-      for (i = 0; i < js.j_jobslots; i++)
-	if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i))))
-	  nohup_job (i);
-    }
-
-  UNBLOCK_CHILD (oset);
-}
-
-int
-count_all_jobs ()
-{
-  int i, n;
-  sigset_t set, oset;
-
-  /* This really counts all non-dead jobs. */
-  BLOCK_CHILD (set, oset);
-  /* XXX could use js.j_firstj here */
-  for (i = n = 0; i < js.j_jobslots; i++)
-    {
-      if (i < js.j_firstj && jobs[i])
-	INTERNAL_DEBUG (("count_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj));
-      if (i > js.j_lastj && jobs[i])
-	INTERNAL_DEBUG (("count_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj));
-
-      if (jobs[i] && DEADJOB(i) == 0)
-	n++;
-    }
-  UNBLOCK_CHILD (oset);
-  return n;
-}
-
-static void
-mark_all_jobs_as_dead ()
-{
-  register int i;
-  sigset_t set, oset;
-
-  if (js.j_jobslots == 0)
-    return;
-
-  BLOCK_CHILD (set, oset);
-
-  /* XXX could use js.j_firstj here */
-  for (i = 0; i < js.j_jobslots; i++)
-    if (jobs[i])
-      {
-	jobs[i]->state = JDEAD;
-	js.j_ndead++;
-      }
-
-  UNBLOCK_CHILD (oset);
-}
-
-/* Mark all dead jobs as notified, so delete_job () cleans them out
-   of the job table properly.  POSIX.2 says we need to save the
-   status of the last CHILD_MAX jobs, so we count the number of dead
-   jobs and mark only enough as notified to save CHILD_MAX statuses. */
-static void
-mark_dead_jobs_as_notified (force)
-     int force;
-{
-  register int i, ndead, ndeadproc;
-  sigset_t set, oset;
-
-  if (js.j_jobslots == 0)
-    return;
-
-  BLOCK_CHILD (set, oset);
-
-  /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
-     around; just run through the array. */
-  if (force)
-    {
-    /* XXX could use js.j_firstj here */
-      for (i = 0; i < js.j_jobslots; i++)
-	{
-	  if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
-	    jobs[i]->flags |= J_NOTIFIED;
-	}
-      UNBLOCK_CHILD (oset);
-      return;
-    }
-
-  /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
-     array with the corresponding not marked as notified.  This is a better
-     way to avoid pid aliasing and reuse problems than keeping the POSIX-
-     mandated CHILD_MAX jobs around.  delete_job() takes care of keeping the
-     bgpids list regulated. */
-
-  /* Count the number of dead jobs */
-  /* XXX could use js.j_firstj here */
-  for (i = ndead = ndeadproc = 0; i < js.j_jobslots; i++)
-    {
-      if (i < js.j_firstj && jobs[i])
-	INTERNAL_DEBUG (("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj));
-      if (i > js.j_lastj && jobs[i])
-	INTERNAL_DEBUG (("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj));
-
-      if (jobs[i] && DEADJOB (i))
-	{
-	  ndead++;
-	  ndeadproc += processes_in_job (i);
-	}
-    }
-
-# if 0
-  if (ndeadproc != js.c_reaped)
-    itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc, js.c_reaped);
-# endif
-  if (ndead != js.j_ndead)
-    INTERNAL_DEBUG (("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead, js.j_ndead));
-
-  if (js.c_childmax < 0)
-    set_maxchild (0);
-
-  /* Don't do anything if the number of dead processes is less than CHILD_MAX
-     and we're not forcing a cleanup. */
-  if (ndeadproc <= js.c_childmax)
-    {
-      UNBLOCK_CHILD (oset);
-      return;
-    }
-
-#if 0
-itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js.c_childmax, ndead, ndeadproc);
-#endif
-
-  /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
-     the list.  This isn't exactly right yet; changes need to be made
-     to stop_pipeline so we don't mark the newer jobs after we've
-     created CHILD_MAX slots in the jobs array.  This needs to be
-     integrated with a way to keep the jobs array from growing without
-     bound.  Maybe we wrap back around to 0 after we reach some max
-     limit, and there are sufficient job slots free (keep track of total
-     size of jobs array (js.j_jobslots) and running count of number of jobs
-     in jobs array.  Then keep a job index corresponding to the `oldest job'
-     and start this loop there, wrapping around as necessary.  In effect,
-     we turn the list into a circular buffer. */
-  /* XXX could use js.j_firstj here */
-  for (i = 0; i < js.j_jobslots; i++)
-    {
-      if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid)))
-	{
-	  if (i < js.j_firstj && jobs[i])
-	    INTERNAL_DEBUG (("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj));
-	  if (i > js.j_lastj && jobs[i])
-	    INTERNAL_DEBUG (("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj));
-
-	  /* If marking this job as notified would drop us down below
-	     child_max, don't mark it so we can keep at least child_max
-	     statuses.  XXX -- need to check what Posix actually says
-	     about keeping statuses. */
-	  if ((ndeadproc -= processes_in_job (i)) <= js.c_childmax)
-	    break;
-	  jobs[i]->flags |= J_NOTIFIED;
-	}
-    }
-
-  UNBLOCK_CHILD (oset);
-}
-
-/* Here to allow other parts of the shell (like the trap stuff) to
-   freeze and unfreeze the jobs list. */
-int
-freeze_jobs_list ()
-{
-  int o;
-
-  o = jobs_list_frozen;
-  jobs_list_frozen = 1;
-  return o;
-}
-
-void
-unfreeze_jobs_list ()
-{
-  jobs_list_frozen = 0;
-}
-
-void
-set_jobs_list_frozen (s)
-     int s;
-{
-  jobs_list_frozen = s;
-}
-
-/* Allow or disallow job control to take place.  Returns the old value
-   of job_control. */
-int
-set_job_control (arg)
-     int arg;
-{
-  int old;
-
-  old = job_control;
-  job_control = arg;
-
-  if (terminal_pgrp == NO_PID && shell_tty >= 0)
-    terminal_pgrp = tcgetpgrp (shell_tty);
-
-  /* If we're turning on job control we're going to want to know the shell's
-     process group. */
-  if (job_control != old && job_control)
-    shell_pgrp = getpgid (0);  
-
-  running_in_background = (terminal_pgrp != shell_pgrp);
-
-#if 0
-  if (interactive_shell == 0 && running_in_background == 0 && job_control != old)
-    {
-      if (job_control)
-	initialize_job_signals ();
-      else
-	default_tty_job_signals ();
-    }
-#endif
-
-  /* If we're turning on job control, reset pipeline_pgrp so make_child will
-     put new child processes into the right pgrp */
-  if (job_control != old && job_control)
-    pipeline_pgrp = 0;
-
-  return (old);
-}
-
-/* Turn off all traces of job control.  This is run by children of the shell
-   which are going to do shellsy things, like wait (), etc. */
-void
-without_job_control ()
-{
-  stop_making_children ();
-  start_pipeline ();
-#if defined (PGRP_PIPE)
-  sh_closepipe (pgrp_pipe);
-#endif
-  delete_all_jobs (0);
-  set_job_control (0);
-}
-
-/* If this shell is interactive, terminate all stopped jobs and
-   restore the original terminal process group.  This is done
-   before the `exec' builtin calls shell_execve. */
-void
-end_job_control ()
-{
-  if (job_control)
-    terminate_stopped_jobs ();
-
-  if (original_pgrp >= 0 && terminal_pgrp != original_pgrp)
-    give_terminal_to (original_pgrp, 1);
-
-  if (original_pgrp >= 0 && setpgid (0, original_pgrp) == 0)
-    shell_pgrp = original_pgrp;
-}
-
-/* Restart job control by closing shell tty and reinitializing.  This is
-   called after an exec fails in an interactive shell and we do not exit. */
-void
-restart_job_control ()
-{
-  if (shell_tty != -1)
-    close (shell_tty);
-  initialize_job_control (0);
-}
-
-/* Set the maximum number of background children we keep track of to NCHILD.
-   If the caller passes NCHILD as 0 or -1, this ends up setting it to
-   LMAXCHILD, which is initialized the first time through. */
-void
-set_maxchild (nchild)
-     int nchild;
-{
-  static int lmaxchild = -1;
-
-  /* Initialize once. */
-  if (lmaxchild < 0)
-    {
-      errno = 0;
-      lmaxchild = getmaxchild ();
-      if (lmaxchild < 0 && errno == 0)
-        lmaxchild = MAX_CHILD_MAX;		/* assume unlimited */
-    }
-  if (lmaxchild < 0)
-    lmaxchild = DEFAULT_CHILD_MAX;
-
-  /* Clamp value we set.  Minimum is what Posix requires, maximum is defined
-     above as MAX_CHILD_MAX. */
-  if (nchild < lmaxchild)
-    nchild = lmaxchild;
-  else if (nchild > MAX_CHILD_MAX)
-    nchild = MAX_CHILD_MAX;
-
-  js.c_childmax = nchild;
-}
-
-/* Set the handler to run when the shell receives a SIGCHLD signal. */
-void
-set_sigchld_handler ()
-{
-  set_signal_handler (SIGCHLD, sigchld_handler);
-}
-
-#if defined (PGRP_PIPE)
-/* Read from the read end of a pipe.  This is how the process group leader
-   blocks until all of the processes in a pipeline have been made. */
-static void
-pipe_read (pp)
-     int *pp;
-{
-  char ch;
-
-  if (pp[1] >= 0)
-    {
-      close (pp[1]);
-      pp[1] = -1;
-    }
-
-  if (pp[0] >= 0)
-    {
-      while (read (pp[0], &ch, 1) == -1 && errno == EINTR)
-	;
-    }
-}
-
-/* Functional interface closes our local-to-job-control pipes. */
-void
-close_pgrp_pipe ()
-{
-  sh_closepipe (pgrp_pipe);
-}
-
-void
-save_pgrp_pipe (p, clear)
-     int *p;
-     int clear;
-{
-  p[0] = pgrp_pipe[0];
-  p[1] = pgrp_pipe[1];
-  if (clear)
-    pgrp_pipe[0] = pgrp_pipe[1] = -1;
-}
-
-void
-restore_pgrp_pipe (p)
-     int *p;
-{
-  pgrp_pipe[0] = p[0];
-  pgrp_pipe[1] = p[1];
-}
-
-#endif /* PGRP_PIPE */
diff --git a/third_party/bash/jobs.h b/third_party/bash/jobs.h
deleted file mode 100644
index 276204f0c..000000000
--- a/third_party/bash/jobs.h
+++ /dev/null
@@ -1,325 +0,0 @@
-/* jobs.h -- structures and definitions used by the jobs.c file. */
-
-/* Copyright (C) 1993-2022  Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_JOBS_H_)
-#  define _JOBS_H_
-
-#include "quit.h"
-#include "siglist.h"
-
-#include "stdc.h"
-
-#include "posixwait.h"
-
-/* Defines controlling the fashion in which jobs are listed. */
-#define JLIST_STANDARD       0
-#define JLIST_LONG	     1
-#define JLIST_PID_ONLY	     2
-#define JLIST_CHANGED_ONLY   3
-#define JLIST_NONINTERACTIVE 4
-
-/* I looked it up.  For pretty_print_job ().  The real answer is 24. */
-#define LONGEST_SIGNAL_DESC 24
-
-/* Defines for the wait_for_* functions and for the wait builtin to use */
-#define JWAIT_PERROR		(1 << 0)
-#define JWAIT_FORCE		(1 << 1)
-#define JWAIT_NOWAIT		(1 << 2) /* don't waitpid(), just return status if already exited */
-#define JWAIT_WAITING		(1 << 3) /* wait for jobs marked J_WAITING only */
-
-/* flags for wait_for */
-#define JWAIT_NOTERM		(1 << 8) /* wait_for doesn't give terminal away */
-
-/* The max time to sleep while retrying fork() on EAGAIN failure */
-#define FORKSLEEP_MAX	16
-
-/* We keep an array of jobs.  Each entry in the array is a linked list
-   of processes that are piped together.  The first process encountered is
-   the group leader. */
-
-/* Values for the `running' field of a struct process. */
-#define PS_DONE		0
-#define PS_RUNNING	1
-#define PS_STOPPED	2
-#define PS_RECYCLED	4
-
-/* Each child of the shell is remembered in a STRUCT PROCESS.  A circular
-   chain of such structures is a pipeline. */
-typedef struct process {
-  struct process *next;	/* Next process in the pipeline.  A circular chain. */
-  pid_t pid;		/* Process ID. */
-  WAIT status;		/* The status of this command as returned by wait. */
-  int running;		/* Non-zero if this process is running. */
-  char *command;	/* The particular program that is running. */
-} PROCESS;
-
-struct pipeline_saver {
-  struct process *pipeline;
-  struct pipeline_saver *next;
-};
-
-/* PALIVE really means `not exited' */
-#define PSTOPPED(p)	(WIFSTOPPED((p)->status))
-#define PRUNNING(p)	((p)->running == PS_RUNNING)
-#define PALIVE(p)	(PRUNNING(p) || PSTOPPED(p))
-
-#define PEXITED(p)	((p)->running == PS_DONE)
-#if defined (RECYCLES_PIDS)
-#  define PRECYCLED(p)	((p)->running == PS_RECYCLED)
-#else
-#  define PRECYCLED(p)	(0)
-#endif
-#define PDEADPROC(p)	(PEXITED(p) || PRECYCLED(p))
-
-#define get_job_by_jid(ind)	(jobs[(ind)])
-
-/* A description of a pipeline's state. */
-typedef enum { JNONE = -1, JRUNNING = 1, JSTOPPED = 2, JDEAD = 4, JMIXED = 8 } JOB_STATE;
-#define JOBSTATE(job)	(jobs[(job)]->state)
-#define J_JOBSTATE(j)	((j)->state)
-
-#define STOPPED(j)	(jobs[(j)]->state == JSTOPPED)
-#define RUNNING(j)	(jobs[(j)]->state == JRUNNING)
-#define DEADJOB(j)	(jobs[(j)]->state == JDEAD)
-
-#define INVALID_JOB(j)	((j) < 0 || (j) >= js.j_jobslots || get_job_by_jid(j) == 0)
-
-/* Values for the FLAGS field in the JOB struct below. */
-#define J_FOREGROUND 0x01 /* Non-zero if this is running in the foreground.  */
-#define J_NOTIFIED   0x02 /* Non-zero if already notified about job state.   */
-#define J_JOBCONTROL 0x04 /* Non-zero if this job started under job control. */
-#define J_NOHUP      0x08 /* Don't send SIGHUP to job if shell gets SIGHUP. */
-#define J_STATSAVED  0x10 /* A process in this job had status saved via $! */
-#define J_ASYNC	     0x20 /* Job was started asynchronously */
-#define J_PIPEFAIL   0x40 /* pipefail set when job was started */
-#define J_WAITING    0x80 /* one of a list of jobs for which we are waiting */
-
-#define IS_FOREGROUND(j)	((jobs[j]->flags & J_FOREGROUND) != 0)
-#define IS_NOTIFIED(j)		((jobs[j]->flags & J_NOTIFIED) != 0)
-#define IS_JOBCONTROL(j)	((jobs[j]->flags & J_JOBCONTROL) != 0)
-#define IS_ASYNC(j)		((jobs[j]->flags & J_ASYNC) != 0)
-#define IS_WAITING(j)		((jobs[j]->flags & J_WAITING) != 0)
-
-typedef struct job {
-  char *wd;	   /* The working directory at time of invocation. */
-  PROCESS *pipe;   /* The pipeline of processes that make up this job. */
-  pid_t pgrp;	   /* The process ID of the process group (necessary). */
-  JOB_STATE state; /* The state that this job is in. */
-  int flags;	   /* Flags word: J_NOTIFIED, J_FOREGROUND, or J_JOBCONTROL. */
-#if defined (JOB_CONTROL)
-  COMMAND *deferred;	/* Commands that will execute when this job is done. */
-  sh_vptrfunc_t *j_cleanup; /* Cleanup function to call when job marked JDEAD */
-  PTR_T cleanarg;	/* Argument passed to (*j_cleanup)() */
-#endif /* JOB_CONTROL */
-} JOB;
-
-struct jobstats {
-  /* limits */
-  long c_childmax;
-  /* child process statistics */
-  int c_living;		/* running or stopped child processes */
-  int c_reaped;		/* exited child processes still in jobs list */
-  int c_injobs;		/* total number of child processes in jobs list */
-  /* child process totals */
-  int c_totforked;	/* total number of children this shell has forked */
-  int c_totreaped;	/* total number of children this shell has reaped */
-  /* job counters and indices */
-  int j_jobslots;	/* total size of jobs array */
-  int j_lastj;		/* last (newest) job allocated */
-  int j_firstj;		/* first (oldest) job allocated */
-  int j_njobs;		/* number of non-NULL jobs in jobs array */
-  int j_ndead;		/* number of JDEAD jobs in jobs array */
-  /* */
-  int j_current;	/* current job */
-  int j_previous;	/* previous job */
-  /* */
-  JOB *j_lastmade;	/* last job allocated by stop_pipeline */
-  JOB *j_lastasync;	/* last async job allocated by stop_pipeline */
-};
-
-/* Revised to accommodate new hash table bgpids implementation. */
-typedef pid_t ps_index_t;
-
-struct pidstat {
-  ps_index_t bucket_next;
-  ps_index_t bucket_prev;
-
-  pid_t pid;
-  bits16_t status;		/* only 8 bits really needed */
-};
-
-struct bgpids {
-  struct pidstat *storage;	/* storage arena */
-
-  ps_index_t head;
-  ps_index_t nalloc;
-
-  int npid;
-};
-
-#define NO_PIDSTAT (ps_index_t)-1
-
-/* standalone process status struct, without bgpids indexes */
-struct procstat {
-  pid_t pid;
-  bits16_t status;
-};
-
-/* A standalone singly-linked list of PROCESS *, used in various places
-   including keeping track of process substitutions. */
-struct procchain {
-  PROCESS *head;
-  PROCESS *end;
-  int nproc;
-};
-
-#define NO_JOB  -1	/* An impossible job array index. */
-#define DUP_JOB -2	/* A possible return value for get_job_spec (). */
-#define BAD_JOBSPEC -3	/* Bad syntax for job spec. */
-
-/* A value which cannot be a process ID. */
-#define NO_PID (pid_t)-1
-
-#define ANY_PID (pid_t)-1
-
-/* flags for make_child () */
-#define FORK_SYNC	0		/* normal synchronous process */
-#define FORK_ASYNC	1		/* background process */
-#define FORK_NOJOB	2		/* don't put process in separate pgrp */
-#define FORK_NOTERM	4		/* don't give terminal to any pgrp */
-
-/* System calls. */
-#if !defined (HAVE_UNISTD_H)
-extern pid_t fork (), getpid (), getpgrp ();
-#endif /* !HAVE_UNISTD_H */
-
-/* Stuff from the jobs.c file. */
-extern struct jobstats js;
-
-extern pid_t original_pgrp, shell_pgrp, pipeline_pgrp;
-extern volatile pid_t last_made_pid, last_asynchronous_pid;
-extern int asynchronous_notification;
-
-extern int already_making_children;
-extern int running_in_background;
-
-extern PROCESS *last_procsub_child;
-
-extern JOB **jobs;
-
-extern void making_children PARAMS((void));
-extern void stop_making_children PARAMS((void));
-extern void cleanup_the_pipeline PARAMS((void));
-extern void discard_last_procsub_child PARAMS((void));
-extern void save_pipeline PARAMS((int));
-extern PROCESS *restore_pipeline PARAMS((int));
-extern void start_pipeline PARAMS((void));
-extern int stop_pipeline PARAMS((int, COMMAND *));
-extern int discard_pipeline PARAMS((PROCESS *));
-extern void append_process PARAMS((char *, pid_t, int, int));
-
-extern void save_proc_status PARAMS((pid_t, int));
-
-extern PROCESS *procsub_add PARAMS((PROCESS *));
-extern PROCESS *procsub_search PARAMS((pid_t));
-extern PROCESS *procsub_delete PARAMS((pid_t));
-extern int procsub_waitpid PARAMS((pid_t));
-extern void procsub_waitall PARAMS((void));
-extern void procsub_clear PARAMS((void));
-extern void procsub_prune PARAMS((void));
-
-extern void delete_job PARAMS((int, int));
-extern void nohup_job PARAMS((int));
-extern void delete_all_jobs PARAMS((int));
-extern void nohup_all_jobs PARAMS((int));
-
-extern int count_all_jobs PARAMS((void));
-
-extern void terminate_current_pipeline PARAMS((void));
-extern void terminate_stopped_jobs PARAMS((void));
-extern void hangup_all_jobs PARAMS((void));
-extern void kill_current_pipeline PARAMS((void));
-
-#if defined (__STDC__) && defined (pid_t)
-extern int get_job_by_pid PARAMS((int, int, PROCESS **));
-extern void describe_pid PARAMS((int));
-#else
-extern int get_job_by_pid PARAMS((pid_t, int, PROCESS **));
-extern void describe_pid PARAMS((pid_t));
-#endif
-
-extern void list_one_job PARAMS((JOB *, int, int, int));
-extern void list_all_jobs PARAMS((int));
-extern void list_stopped_jobs PARAMS((int));
-extern void list_running_jobs PARAMS((int));
-
-extern pid_t make_child PARAMS((char *, int));
-
-extern int get_tty_state PARAMS((void));
-extern int set_tty_state PARAMS((void));
-
-extern int job_exit_status PARAMS((int));
-extern int job_exit_signal PARAMS((int));
-
-extern int wait_for_single_pid PARAMS((pid_t, int));
-extern int wait_for_background_pids PARAMS((struct procstat *));
-extern int wait_for PARAMS((pid_t, int));
-extern int wait_for_job PARAMS((int, int, struct procstat *));
-extern int wait_for_any_job PARAMS((int, struct procstat *));
-
-extern void wait_sigint_cleanup PARAMS((void));
-
-extern void notify_and_cleanup PARAMS((void));
-extern void reap_dead_jobs PARAMS((void));
-extern int start_job PARAMS((int, int));
-extern int kill_pid PARAMS((pid_t, int, int));
-extern int initialize_job_control PARAMS((int));
-extern void initialize_job_signals PARAMS((void));
-extern int give_terminal_to PARAMS((pid_t, int));
-
-extern void run_sigchld_trap PARAMS((int));
-
-extern int freeze_jobs_list PARAMS((void));
-extern void unfreeze_jobs_list PARAMS((void));
-extern void set_jobs_list_frozen PARAMS((int));
-extern int set_job_control PARAMS((int));
-extern void without_job_control PARAMS((void));
-extern void end_job_control PARAMS((void));
-extern void restart_job_control PARAMS((void));
-extern void set_sigchld_handler PARAMS((void));
-extern void ignore_tty_job_signals PARAMS((void));
-extern void default_tty_job_signals PARAMS((void));
-extern void get_original_tty_job_signals PARAMS((void));
-
-extern void init_job_stats PARAMS((void));
-
-extern void close_pgrp_pipe PARAMS((void));
-extern void save_pgrp_pipe PARAMS((int *, int));
-extern void restore_pgrp_pipe PARAMS((int *));
-
-extern void set_maxchild PARAMS((int));
-
-#ifdef DEBUG
-extern void debug_print_pgrps (void);
-#endif
-
-extern int job_control;		/* set to 0 in nojobs.c */
-
-#endif /* _JOBS_H_ */
diff --git a/third_party/bash/list.c b/third_party/bash/list.c
deleted file mode 100644
index 88835f58e..000000000
--- a/third_party/bash/list.c
+++ /dev/null
@@ -1,136 +0,0 @@
-/* list.c - Functions for manipulating linked lists of objects. */
-
-/* Copyright (C) 1996-2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "shell.h"
-
-/* A global variable which acts as a sentinel for an `error' list return. */
-GENERIC_LIST global_error_list;
-
-#ifdef INCLUDE_UNUSED
-/* Call FUNCTION on every member of LIST, a generic list. */
-void
-list_walk (list, function)
-     GENERIC_LIST *list;
-     sh_glist_func_t *function;
-{
-  for ( ; list; list = list->next)
-    if ((*function) (list) < 0)
-      return;
-}
-
-/* Call FUNCTION on every string in WORDS. */
-void
-wlist_walk (words, function)
-     WORD_LIST *words;
-     sh_icpfunc_t *function;
-{
-  for ( ; words; words = words->next)
-    if ((*function) (words->word->word) < 0)
-      return;
-}
-#endif /* INCLUDE_UNUSED */
-
-/* Reverse the chain of structures in LIST.  Output the new head
-   of the chain.  You should always assign the output value of this
-   function to something, or you will lose the chain. */
-GENERIC_LIST *
-list_reverse (list)
-     GENERIC_LIST *list;
-{
-  register GENERIC_LIST *next, *prev;
-
-  for (prev = (GENERIC_LIST *)NULL; list; )
-    {
-      next = list->next;
-      list->next = prev;
-      prev = list;
-      list = next;
-    }
-  return (prev);
-}
-
-/* Return the number of elements in LIST, a generic list. */
-int
-list_length (list)
-     GENERIC_LIST *list;
-{
-  register int i;
-
-  for (i = 0; list; list = list->next, i++);
-  return (i);
-}
-
-/* Append TAIL to HEAD.  Return the header of the list. */
-GENERIC_LIST *
-list_append (head, tail)
-     GENERIC_LIST *head, *tail;
-{
-  register GENERIC_LIST *t_head;
-
-  if (head == 0)
-    return (tail);
-
-  for (t_head = head; t_head->next; t_head = t_head->next)
-    ;
-  t_head->next = tail;
-  return (head);
-}
-
-#ifdef INCLUDE_UNUSED
-/* Delete the element of LIST which satisfies the predicate function COMPARER.
-   Returns the element that was deleted, so you can dispose of it, or -1 if
-   the element wasn't found.  COMPARER is called with the list element and
-   then ARG.  Note that LIST contains the address of a variable which points
-   to the list.  You might call this function like this:
-
-   SHELL_VAR *elt = list_remove (&variable_list, check_var_has_name, "foo");
-   dispose_variable (elt);
-*/
-GENERIC_LIST *
-list_remove (list, comparer, arg)
-     GENERIC_LIST **list;
-     Function *comparer;
-     char *arg;
-{
-  register GENERIC_LIST *prev, *temp;
-
-  for (prev = (GENERIC_LIST *)NULL, temp = *list; temp; prev = temp, temp = temp->next)
-    {
-      if ((*comparer) (temp, arg))
-	{
-	  if (prev)
-	    prev->next = temp->next;
-	  else
-	    *list = temp->next;
-	  return (temp);
-	}
-    }
-  return ((GENERIC_LIST *)&global_error_list);
-}
-#endif
diff --git a/third_party/bash/locale.c b/third_party/bash/locale.c
deleted file mode 100644
index fabf7b125..000000000
--- a/third_party/bash/locale.c
+++ /dev/null
@@ -1,645 +0,0 @@
-/* locale.c - Miscellaneous internationalization functions. */
-
-/* Copyright (C) 1996-2009,2012,2016-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#if HAVE_LANGINFO_CODESET
-#  include <langinfo.h>
-#endif
-
-#include "bashintl.h"
-#include "bashansi.h"
-#include <stdio.h>
-#include "chartypes.h"
-#include <errno.h>
-
-#include "shell.h"
-#include "input.h"	/* For bash_input */
-
-#ifndef errno
-extern int errno;
-#endif
-
-int locale_utf8locale;
-int locale_mb_cur_max;	/* value of MB_CUR_MAX for current locale (LC_CTYPE) */
-int locale_shiftstates = 0;
-
-int singlequote_translations = 0;	/* single-quote output of $"..." */
-
-extern int dump_translatable_strings, dump_po_strings;
-
-/* The current locale when the program begins */
-static char *default_locale;
-
-/* The current domain for textdomain(3). */
-static char *default_domain;
-static char *default_dir;
-
-/* tracks the value of LC_ALL; used to override values for other locale
-   categories */
-static char *lc_all;
-
-/* tracks the value of LC_ALL; used to provide defaults for locale
-   categories */
-static char *lang;
-
-/* Called to reset all of the locale variables to their appropriate values
-   if (and only if) LC_ALL has not been assigned a value. */
-static int reset_locale_vars PARAMS((void));
-
-static void locale_setblanks PARAMS((void));
-static int locale_isutf8 PARAMS((char *));
-
-/* Set the value of default_locale and make the current locale the
-   system default locale.  This should be called very early in main(). */
-void
-set_default_locale ()
-{
-#if defined (HAVE_SETLOCALE)
-  default_locale = setlocale (LC_ALL, "");
-  if (default_locale)
-    default_locale = savestring (default_locale);
-#else
-  default_locale = savestring ("C");
-#endif /* HAVE_SETLOCALE */
-  bindtextdomain (PACKAGE, LOCALEDIR);
-  textdomain (PACKAGE);
-
-  locale_mb_cur_max = MB_CUR_MAX;
-  locale_utf8locale = locale_isutf8 (default_locale);
-#if defined (HANDLE_MULTIBYTE)
-  locale_shiftstates = mblen ((char *)NULL, 0);
-#else
-  locale_shiftstates = 0;
-#endif
-}
-
-/* Set default values for LC_CTYPE, LC_COLLATE, LC_MESSAGES, LC_NUMERIC and
-   LC_TIME if they are not specified in the environment, but LC_ALL is.  This
-   should be called from main() after parsing the environment. */
-void
-set_default_locale_vars ()
-{
-  char *val;
-
-#if defined (HAVE_SETLOCALE)
-
-#  if defined (LC_CTYPE)
-  val = get_string_value ("LC_CTYPE");
-  if (val == 0 && lc_all && *lc_all)
-    {
-      setlocale (LC_CTYPE, lc_all);
-      locale_setblanks ();
-      locale_mb_cur_max = MB_CUR_MAX;
-      locale_utf8locale = locale_isutf8 (lc_all);
-
-#    if defined (HANDLE_MULTIBYTE)
-      locale_shiftstates = mblen ((char *)NULL, 0);
-#    else
-      locale_shiftstates = 0;
-#    endif
-
-      u32reset ();
-    }
-#  endif
-
-#  if defined (LC_COLLATE)
-  val = get_string_value ("LC_COLLATE");
-  if (val == 0 && lc_all && *lc_all)
-    setlocale (LC_COLLATE, lc_all);
-#  endif /* LC_COLLATE */
-
-#  if defined (LC_MESSAGES)
-  val = get_string_value ("LC_MESSAGES");
-  if (val == 0 && lc_all && *lc_all)
-    setlocale (LC_MESSAGES, lc_all);
-#  endif /* LC_MESSAGES */
-
-#  if defined (LC_NUMERIC)
-  val = get_string_value ("LC_NUMERIC");
-  if (val == 0 && lc_all && *lc_all)
-    setlocale (LC_NUMERIC, lc_all);
-#  endif /* LC_NUMERIC */
-
-#  if defined (LC_TIME)
-  val = get_string_value ("LC_TIME");
-  if (val == 0 && lc_all && *lc_all)
-    setlocale (LC_TIME, lc_all);
-#  endif /* LC_TIME */
-
-#endif /* HAVE_SETLOCALE */
-
-  val = get_string_value ("TEXTDOMAIN");
-  if (val && *val)
-    {
-      FREE (default_domain);
-      default_domain = savestring (val);
-      if (default_dir && *default_dir)
-	bindtextdomain (default_domain, default_dir);
-    }
-
-  val = get_string_value ("TEXTDOMAINDIR");
-  if (val && *val)
-    {
-      FREE (default_dir);
-      default_dir = savestring (val);
-      if (default_domain && *default_domain)
-	bindtextdomain (default_domain, default_dir);
-    }
-}
-
-/* Set one of the locale categories (specified by VAR) to VALUE.  Returns 1
-  if successful, 0 otherwise. */
-int
-set_locale_var (var, value)
-     char *var, *value;
-{
-  int r;
-  char *x;
-
-  x = "";
-  errno = 0;
-  if (var[0] == 'T' && var[10] == 0)		/* TEXTDOMAIN */
-    {
-      FREE (default_domain);
-      default_domain = value ? savestring (value) : (char *)NULL;
-      if (default_dir && *default_dir)
-	bindtextdomain (default_domain, default_dir);
-      return (1);
-    }
-  else if (var[0] == 'T')			/* TEXTDOMAINDIR */
-    {
-      FREE (default_dir);
-      default_dir = value ? savestring (value) : (char *)NULL;
-      if (default_domain && *default_domain)
-	bindtextdomain (default_domain, default_dir);
-      return (1);
-    }
-
-  /* var[0] == 'L' && var[1] == 'C' && var[2] == '_' */
-
-  else if (var[3] == 'A')			/* LC_ALL */
-    {
-      FREE (lc_all);
-      if (value)
-	lc_all = savestring (value);
-      else
-	{
-	  lc_all = (char *)xmalloc (1);
-	  lc_all[0] = '\0';
-	}
-#if defined (HAVE_SETLOCALE)
-      r = *lc_all ? ((x = setlocale (LC_ALL, lc_all)) != 0) : reset_locale_vars ();
-      if (x == 0)
-	{
-	  if (errno == 0)
-	    internal_warning(_("setlocale: LC_ALL: cannot change locale (%s)"), lc_all);
-	  else
-	    internal_warning(_("setlocale: LC_ALL: cannot change locale (%s): %s"), lc_all, strerror (errno));
-	}
-      locale_setblanks ();
-      locale_mb_cur_max = MB_CUR_MAX;
-      /* if LC_ALL == "", reset_locale_vars has already called this */
-      if (*lc_all && x)
-	locale_utf8locale = locale_isutf8 (lc_all);
-#  if defined (HANDLE_MULTIBYTE)
-      locale_shiftstates = mblen ((char *)NULL, 0);
-#  else
-      locale_shiftstates = 0;
-#  endif
-      u32reset ();
-      return r;
-#else
-      return (1);
-#endif
-    }
-
-#if defined (HAVE_SETLOCALE)
-  else if (var[3] == 'C' && var[4] == 'T')	/* LC_CTYPE */
-    {
-#  if defined (LC_CTYPE)
-      if (lc_all == 0 || *lc_all == '\0')
-	{
-	  x = setlocale (LC_CTYPE, get_locale_var ("LC_CTYPE"));
-	  locale_setblanks ();
-	  locale_mb_cur_max = MB_CUR_MAX;
-	  /* if setlocale() returns NULL, the locale is not changed */
-	  if (x)
-	    locale_utf8locale = locale_isutf8 (x);
-#if defined (HANDLE_MULTIBYTE)
-	  locale_shiftstates = mblen ((char *)NULL, 0);
-#else
-	  locale_shiftstates = 0;
-#endif
-	  u32reset ();
-	}
-#  endif
-    }
-  else if (var[3] == 'C' && var[4] == 'O')	/* LC_COLLATE */
-    {
-#  if defined (LC_COLLATE)
-      if (lc_all == 0 || *lc_all == '\0')
-	x = setlocale (LC_COLLATE, get_locale_var ("LC_COLLATE"));
-#  endif /* LC_COLLATE */
-    }
-  else if (var[3] == 'M' && var[4] == 'E')	/* LC_MESSAGES */
-    {
-#  if defined (LC_MESSAGES)
-      if (lc_all == 0 || *lc_all == '\0')
-	x = setlocale (LC_MESSAGES, get_locale_var ("LC_MESSAGES"));
-#  endif /* LC_MESSAGES */
-    }
-  else if (var[3] == 'N' && var[4] == 'U')	/* LC_NUMERIC */
-    {
-#  if defined (LC_NUMERIC)
-      if (lc_all == 0 || *lc_all == '\0')
-	x = setlocale (LC_NUMERIC, get_locale_var ("LC_NUMERIC"));
-#  endif /* LC_NUMERIC */
-    }
-  else if (var[3] == 'T' && var[4] == 'I')	/* LC_TIME */
-    {
-#  if defined (LC_TIME)
-      if (lc_all == 0 || *lc_all == '\0')
-	x = setlocale (LC_TIME, get_locale_var ("LC_TIME"));
-#  endif /* LC_TIME */
-    }
-#endif /* HAVE_SETLOCALE */
-  
-  if (x == 0)
-    {
-      if (errno == 0)
-	internal_warning(_("setlocale: %s: cannot change locale (%s)"), var, get_locale_var (var));
-      else
-	internal_warning(_("setlocale: %s: cannot change locale (%s): %s"), var, get_locale_var (var), strerror (errno));
-    }
-
-  return (x != 0);
-}
-
-/* Called when LANG is assigned a value.  Tracks value in `lang'.  Calls
-   reset_locale_vars() to reset any default values if LC_ALL is unset or
-   null. */
-int
-set_lang (var, value)
-     char *var, *value;
-{
-  FREE (lang);
-  if (value)
-    lang = savestring (value);
-  else
-    {
-      lang = (char *)xmalloc (1);
-      lang[0] = '\0';
-    }
-
-  return ((lc_all == 0 || *lc_all == 0) ? reset_locale_vars () : 0);
-}
-
-/* Set default values for LANG and LC_ALL.  Default values for all other
-   locale-related variables depend on these. */
-void
-set_default_lang ()
-{
-  char *v;
-
-  v = get_string_value ("LC_ALL");
-  set_locale_var ("LC_ALL", v);
-
-  v = get_string_value ("LANG");
-  set_lang ("LANG", v);
-}
-
-/* Get the value of one of the locale variables (LC_MESSAGES, LC_CTYPE).
-   The precedence is as POSIX.2 specifies:  LC_ALL has precedence over
-   the specific locale variables, and LANG, if set, is used as the default. */
-char *
-get_locale_var (var)
-     char *var;
-{
-  char *locale;
-
-  locale = lc_all;
-
-  if (locale == 0 || *locale == 0)
-    locale = get_string_value (var);	/* XXX - no mem leak */
-  if (locale == 0 || *locale == 0)
-    locale = lang;
-  if (locale == 0 || *locale == 0)
-#if 0
-    locale = default_locale;	/* system-dependent; not really portable.  should it be "C"? */
-#else
-    locale = "";
-#endif
-  return (locale);
-}
-
-/* Called to reset all of the locale variables to their appropriate values
-   if (and only if) LC_ALL has not been assigned a value.  DO NOT CALL THIS
-   IF LC_ALL HAS BEEN ASSIGNED A VALUE. */
-static int
-reset_locale_vars ()
-{
-  char *t, *x;
-#if defined (HAVE_SETLOCALE)
-  if (lang == 0 || *lang == '\0')
-    maybe_make_export_env ();		/* trust that this will change environment for setlocale */
-  if (setlocale (LC_ALL, lang ? lang : "") == 0)
-    return 0;
-
-  x = 0;
-#  if defined (LC_CTYPE)
-  x = setlocale (LC_CTYPE, get_locale_var ("LC_CTYPE"));
-#  endif
-#  if defined (LC_COLLATE)
-  t = setlocale (LC_COLLATE, get_locale_var ("LC_COLLATE"));
-#  endif
-#  if defined (LC_MESSAGES)
-  t = setlocale (LC_MESSAGES, get_locale_var ("LC_MESSAGES"));
-#  endif
-#  if defined (LC_NUMERIC)
-  t = setlocale (LC_NUMERIC, get_locale_var ("LC_NUMERIC"));
-#  endif
-#  if defined (LC_TIME)
-  t = setlocale (LC_TIME, get_locale_var ("LC_TIME"));
-#  endif
-
-  locale_setblanks ();  
-  locale_mb_cur_max = MB_CUR_MAX;
-  if (x)
-    locale_utf8locale = locale_isutf8 (x);
-#  if defined (HANDLE_MULTIBYTE)
-  locale_shiftstates = mblen ((char *)NULL, 0);
-#  else
-  locale_shiftstates = 0;
-#  endif
-  u32reset ();
-#endif
-  return 1;
-}
-
-#if defined (TRANSLATABLE_STRINGS)
-/* Translate the contents of STRING, a $"..." quoted string, according
-   to the current locale.  In the `C' or `POSIX' locale, or if gettext()
-   is not available, the passed string is returned unchanged.  The
-   length of the translated string is returned in LENP, if non-null. */
-char *
-localetrans (string, len, lenp)
-     char *string;
-     int len, *lenp;
-{
-  char *locale, *t;
-  char *translated;
-  int tlen;
-
-  /* Don't try to translate null strings. */
-  if (string == 0 || *string == 0)
-    {
-      if (lenp)
-	*lenp = 0;
-      return ((char *)NULL);
-    }
-
-  locale = get_locale_var ("LC_MESSAGES");
-
-  /* If we don't have setlocale() or the current locale is `C' or `POSIX',
-     just return the string.  If we don't have gettext(), there's no use
-     doing anything else. */
-  if (locale == 0 || locale[0] == '\0' ||
-      (locale[0] == 'C' && locale[1] == '\0') || STREQ (locale, "POSIX"))
-    {
-      t = (char *)xmalloc (len + 1);
-      strcpy (t, string);
-      if (lenp)
-	*lenp = len;
-      return (t);
-    }
-
-  /* Now try to translate it. */
-  if (default_domain && *default_domain)
-    translated = dgettext (default_domain, string);
-  else
-    translated = string;
-
-  if (translated == string)	/* gettext returns its argument if untranslatable */
-    {
-      t = (char *)xmalloc (len + 1);
-      strcpy (t, string);
-      if (lenp)
-	*lenp = len;
-    }
-  else
-    {
-      tlen = strlen (translated);
-      t = (char *)xmalloc (tlen + 1);
-      strcpy (t, translated);
-      if (lenp)
-	*lenp = tlen;
-    }
-  return (t);
-}
-
-/* Change a bash string into a string suitable for inclusion in a `po' file.
-   This backslash-escapes `"' and `\' and changes newlines into \\\n"\n". */
-char *
-mk_msgstr (string, foundnlp)
-     char *string;
-     int *foundnlp;
-{
-  register int c, len;
-  char *result, *r, *s;
-
-  for (len = 0, s = string; s && *s; s++)
-    {
-      len++;
-      if (*s == '"' || *s == '\\')
-	len++;
-      else if (*s == '\n')
-	len += 5;
-    }
-  
-  r = result = (char *)xmalloc (len + 3);
-  *r++ = '"';
-
-  for (s = string; s && (c = *s); s++)
-    {
-      if (c == '\n')	/* <NL> -> \n"<NL>" */
-	{
-	  *r++ = '\\';
-	  *r++ = 'n';
-	  *r++ = '"';
-	  *r++ = '\n';
-	  *r++ = '"';
-	  if (foundnlp)
-	    *foundnlp = 1;
-	  continue;
-	}
-      if (c == '"' || c == '\\')
-	*r++ = '\\';
-      *r++ = c;
-    }
-
-  *r++ = '"';
-  *r++ = '\0';
-
-  return result;
-}
-
-/* $"..." -- Translate the portion of STRING between START and END
-   according to current locale using gettext (if available) and return
-   the result.  The caller will take care of leaving the quotes intact.
-   The string will be left without the leading `$' by the caller.
-   If translation is performed, the translated string will be double-quoted
-   by the caller.  The length of the translated string is returned in LENP,
-   if non-null. */
-char *
-locale_expand (string, start, end, lineno, lenp)
-     char *string;
-     int start, end, lineno, *lenp;
-{
-  int len, tlen, foundnl;
-  char *temp, *t, *t2;
-
-  temp = (char *)xmalloc (end - start + 1);
-  for (tlen = 0, len = start; len < end; )
-    temp[tlen++] = string[len++];
-  temp[tlen] = '\0';
-
-  /* If we're just dumping translatable strings, don't do anything with the
-     string itself, but if we're dumping in `po' file format, convert it into
-     a form more palatable to gettext(3) and friends by quoting `"' and `\'
-     with backslashes and converting <NL> into `\n"<NL>"'.  If we find a
-     newline in TEMP, we first output a `msgid ""' line and then the
-     translated string; otherwise we output the `msgid' and translated
-     string all on one line. */
-  if (dump_translatable_strings)
-    {
-      if (dump_po_strings)
-	{
-	  foundnl = 0;
-	  t = mk_msgstr (temp, &foundnl);
-	  t2 = foundnl ? "\"\"\n" : "";
-
-	  printf ("#: %s:%d\nmsgid %s%s\nmsgstr \"\"\n",
-			yy_input_name (), lineno, t2, t);
-	  free (t);
-	}
-      else
-	printf ("\"%s\"\n", temp);
-
-      if (lenp)
-	*lenp = tlen;
-      return (temp);
-    }
-  else if (*temp)
-    {
-      t = localetrans (temp, tlen, &len);
-      free (temp);
-      if (lenp)
-	*lenp = len;
-      return (t);
-    }
-  else
-    {
-      if (lenp)
-	*lenp = 0;
-      return (temp);
-    }
-}
-#endif
-
-/* Set every character in the <blank> character class to be a shell break
-   character for the lexical analyzer when the locale changes. */
-static void
-locale_setblanks ()
-{
-  int x;
-
-  for (x = 0; x < sh_syntabsiz; x++)
-    {
-      if (isblank ((unsigned char)x))
-	sh_syntaxtab[x] |= CSHBRK|CBLANK;
-      else if (member (x, shell_break_chars))
-	{
-	  sh_syntaxtab[x] |= CSHBRK;
-	  sh_syntaxtab[x] &= ~CBLANK;
-	}
-      else
-	sh_syntaxtab[x] &= ~(CSHBRK|CBLANK);
-    }
-}
-
-/* Parse a locale specification
-     language[_territory][.codeset][@modifier][+special][,[sponsor][_revision]]
-   and return TRUE if the codeset is UTF-8 or utf8 */
-static int
-locale_isutf8 (lspec)
-     char *lspec;
-{
-  char *cp, *encoding;
-
-#if HAVE_LANGINFO_CODESET
-  cp = nl_langinfo (CODESET);
-  return (STREQ (cp, "UTF-8") || STREQ (cp, "utf8"));
-#elif HAVE_LOCALE_CHARSET
-  cp = locale_charset ();
-  return (STREQ (cp, "UTF-8") || STREQ (cp, "utf8"));
-#else
-  /* Take a shot */
-  for (cp = lspec; *cp && *cp != '@' && *cp != '+' && *cp != ','; cp++)
-    {
-      if (*cp == '.')
-	{
-	  for (encoding = ++cp; *cp && *cp != '@' && *cp != '+' && *cp != ','; cp++)
-	    ;
-	  /* The encoding (codeset) is the substring between encoding and cp */
-	  if ((cp - encoding == 5 && STREQN (encoding, "UTF-8", 5)) ||
-	      (cp - encoding == 4 && STREQN (encoding, "utf8", 4)))
-	    return 1;
-	  else
-	    return 0;
-	}
-    }
-  return 0;
-#endif
-}
-
-#if defined (HAVE_LOCALECONV)
-int
-locale_decpoint ()
-{
-  struct lconv *lv;
-
-  lv = localeconv ();
-  return (lv && lv->decimal_point && lv->decimal_point[0]) ? lv->decimal_point[0] : '.';
-}
-#else
-#  undef locale_decpoint
-int
-locale_decpoint ()
-{
-  return '.';
-}
-#endif
diff --git a/third_party/bash/mailcheck.c b/third_party/bash/mailcheck.c
deleted file mode 100644
index f5bfe8e1a..000000000
--- a/third_party/bash/mailcheck.c
+++ /dev/null
@@ -1,491 +0,0 @@
-/* mailcheck.c -- The check is in the mail... */
-
-/* Copyright (C) 1987-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <stdio.h>
-#include "bashtypes.h"
-#include "posixstat.h"
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-#include "posixtime.h"
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "mailcheck.h"
-#include "tilde.h"
-
-/* Values for flags word in struct _fileinfo */
-#define MBOX_INITIALIZED	0x01
-
-extern time_t shell_start_time;
-
-extern int mailstat PARAMS((const char *, struct stat *));
-
-typedef struct _fileinfo {
-  char *name;
-  char *msg;
-  time_t access_time;
-  time_t mod_time;
-  off_t file_size;
-  int flags;
-} FILEINFO;
-
-/* The list of remembered mail files. */
-static FILEINFO **mailfiles = (FILEINFO **)NULL;
-
-/* Number of mail files that we have. */
-static int mailfiles_count;
-
-/* The last known time that mail was checked. */
-static time_t last_time_mail_checked = 0;
-
-/* Non-zero means warn if a mail file has been read since last checked. */
-int mail_warning;
-
-static int find_mail_file PARAMS((char *));
-static void init_mail_file PARAMS((int));
-static void update_mail_file PARAMS((int));
-static int add_mail_file PARAMS((char *, char *));
-
-static FILEINFO *alloc_mail_file PARAMS((char *, char *));
-static void dispose_mail_file PARAMS((FILEINFO *));
-
-static int file_mod_date_changed PARAMS((int));
-static int file_access_date_changed PARAMS((int));
-static int file_has_grown PARAMS((int));
-
-static char *parse_mailpath_spec PARAMS((char *));
-
-/* Returns non-zero if it is time to check mail. */
-int
-time_to_check_mail ()
-{
-  char *temp;
-  time_t now;
-  intmax_t seconds;
-
-  temp = get_string_value ("MAILCHECK");
-
-  /* Negative number, or non-numbers (such as empty string) cause no
-     checking to take place. */
-  if (temp == 0 || legal_number (temp, &seconds) == 0 || seconds < 0)
-    return (0);
-
-  now = NOW;
-  /* Time to check if MAILCHECK is explicitly set to zero, or if enough
-     time has passed since the last check. */
-  return (seconds == 0 || ((now - last_time_mail_checked) >= seconds));
-}
-
-/* Okay, we have checked the mail.  Perhaps I should make this function
-   go away. */
-void
-reset_mail_timer ()
-{
-  last_time_mail_checked = NOW;
-}
-
-/* Locate a file in the list.  Return index of
-   entry, or -1 if not found. */
-static int
-find_mail_file (file)
-     char *file;
-{
-  register int i;
-
-  for (i = 0; i < mailfiles_count; i++)
-    if (STREQ (mailfiles[i]->name, file))
-      return i;
-
-  return -1;
-}
-
-#define RESET_MAIL_FILE(i) \
-  do \
-    { \
-      mailfiles[i]->access_time = mailfiles[i]->mod_time = 0; \
-      mailfiles[i]->file_size = 0; \
-      mailfiles[i]->flags = 0; \
-    } \
-  while (0)
-
-#define UPDATE_MAIL_FILE(i, finfo) \
-  do \
-    { \
-      mailfiles[i]->access_time = finfo.st_atime; \
-      mailfiles[i]->mod_time = finfo.st_mtime; \
-      mailfiles[i]->file_size = finfo.st_size; \
-      mailfiles[i]->flags |= MBOX_INITIALIZED; \
-    } \
-  while (0)
-
-static void
-init_mail_file (i)
-     int i;
-{
-  mailfiles[i]->access_time = mailfiles[i]->mod_time = last_time_mail_checked ? last_time_mail_checked : shell_start_time;
-  mailfiles[i]->file_size = 0;
-  mailfiles[i]->flags = 0;
-}
-
-static void
-update_mail_file (i)
-     int i;
-{
-  char *file;
-  struct stat finfo;
-
-  file = mailfiles[i]->name;
-  if (mailstat (file, &finfo) == 0)
-    UPDATE_MAIL_FILE (i, finfo);
-  else
-    RESET_MAIL_FILE (i);
-}
-
-/* Add this file to the list of remembered files and return its index
-   in the list of mail files. */
-static int
-add_mail_file (file, msg)
-     char *file, *msg;
-{
-  struct stat finfo;
-  char *filename;
-  int i;
-
-  filename = full_pathname (file);
-  i = find_mail_file (filename);
-  if (i >= 0)
-    {
-      if (mailstat (filename, &finfo) == 0)
-	UPDATE_MAIL_FILE (i, finfo);
-
-      free (filename);
-      return i;
-    }
-
-  i = mailfiles_count++;
-  mailfiles = (FILEINFO **)xrealloc
-		(mailfiles, mailfiles_count * sizeof (FILEINFO *));
-
-  mailfiles[i] = alloc_mail_file (filename, msg);
-  init_mail_file (i);
-
-  return i;
-}
-
-/* Reset the existing mail files access and modification times to zero. */
-void
-reset_mail_files ()
-{
-  register int i;
-
-  for (i = 0; i < mailfiles_count; i++)
-    RESET_MAIL_FILE (i);
-}
-
-static FILEINFO *
-alloc_mail_file (filename, msg)
-     char *filename, *msg;
-{
-  FILEINFO *mf;
-
-  mf = (FILEINFO *)xmalloc (sizeof (FILEINFO));
-  mf->name = filename;
-  mf->msg = msg ? savestring (msg) : (char *)NULL;
-  mf->flags = 0;
-
-  return mf;
-}
-
-static void
-dispose_mail_file (mf)
-     FILEINFO *mf;
-{
-  free (mf->name);
-  FREE (mf->msg);
-  free (mf);
-}
-
-/* Free the information that we have about the remembered mail files. */
-void
-free_mail_files ()
-{
-  register int i;
-
-  for (i = 0; i < mailfiles_count; i++)
-    dispose_mail_file (mailfiles[i]);
-
-  if (mailfiles)
-    free (mailfiles);
-
-  mailfiles_count = 0;
-  mailfiles = (FILEINFO **)NULL;
-}
-
-void
-init_mail_dates ()
-{
-  if (mailfiles == 0)
-    remember_mail_dates ();
-}
-
-/* Return non-zero if FILE's mod date has changed and it has not been
-   accessed since modified.  If the size has dropped to zero, reset
-   the cached mail file info. */
-static int
-file_mod_date_changed (i)
-     int i;
-{
-  time_t mtime;
-  struct stat finfo;
-  char *file;
-
-  file = mailfiles[i]->name;
-  mtime = mailfiles[i]->mod_time;
-
-  if (mailstat (file, &finfo) != 0)
-    return (0);
-
-  if (finfo.st_size > 0)
-    return (mtime < finfo.st_mtime);
-
-  if (finfo.st_size == 0 && mailfiles[i]->file_size > 0)
-    UPDATE_MAIL_FILE (i, finfo);
-
-  return (0);
-}
-
-/* Return non-zero if FILE's access date has changed. */
-static int
-file_access_date_changed (i)
-     int i;
-{
-  time_t atime;
-  struct stat finfo;
-  char *file;
-
-  file = mailfiles[i]->name;
-  atime = mailfiles[i]->access_time;
-
-  if (mailstat (file, &finfo) != 0)
-    return (0);
-
-  if (finfo.st_size > 0)
-    return (atime < finfo.st_atime);
-
-  return (0);
-}
-
-/* Return non-zero if FILE's size has increased. */
-static int
-file_has_grown (i)
-     int i;
-{
-  off_t size;
-  struct stat finfo;
-  char *file;
-
-  file = mailfiles[i]->name;
-  size = mailfiles[i]->file_size;
-
-  return ((mailstat (file, &finfo) == 0) && (finfo.st_size > size));
-}
-
-/* Take an element from $MAILPATH and return the portion from
-   the first unquoted `?' or `%' to the end of the string.  This is the
-   message to be printed when the file contents change. */
-static char *
-parse_mailpath_spec (str)
-     char *str;
-{
-  char *s;
-  int pass_next;
-
-  for (s = str, pass_next = 0; s && *s; s++)
-    {
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  continue;
-	}
-      if (*s == '\\')
-	{
-	  pass_next++;
-	  continue;
-	}
-      if (*s == '?' || *s == '%')
-	return s;
-    }
-  return ((char *)NULL);
-}
-
-char *
-make_default_mailpath ()
-{
-#if defined (DEFAULT_MAIL_DIRECTORY)
-  char *mp;
-
-  get_current_user_info ();
-  mp = (char *)xmalloc (2 + sizeof (DEFAULT_MAIL_DIRECTORY) + strlen (current_user.user_name));
-  strcpy (mp, DEFAULT_MAIL_DIRECTORY);
-  mp[sizeof(DEFAULT_MAIL_DIRECTORY) - 1] = '/';
-  strcpy (mp + sizeof (DEFAULT_MAIL_DIRECTORY), current_user.user_name);
-  return (mp);
-#else
-  return ((char *)NULL);
-#endif
-}
-
-/* Remember the dates of the files specified by MAILPATH, or if there is
-   no MAILPATH, by the file specified in MAIL.  If neither exists, use a
-   default value, which we randomly concoct from using Unix. */
-
-void
-remember_mail_dates ()
-{
-  char *mailpaths;
-  char *mailfile, *mp;
-  int i = 0;
-
-  mailpaths = get_string_value ("MAILPATH");
-
-  /* If no $MAILPATH, but $MAIL, use that as a single filename to check. */
-  if (mailpaths == 0 && (mailpaths = get_string_value ("MAIL")))
-    {
-      add_mail_file (mailpaths, (char *)NULL);
-      return;
-    }
-
-  if (mailpaths == 0)
-    {
-      mailpaths = make_default_mailpath ();
-      if (mailpaths)
-	{
-	  add_mail_file (mailpaths, (char *)NULL);
-	  free (mailpaths);
-	}
-      return;
-    }
-
-  while (mailfile = extract_colon_unit (mailpaths, &i))
-    {
-      mp = parse_mailpath_spec (mailfile);
-      if (mp && *mp)
-	*mp++ = '\0';
-      add_mail_file (mailfile, mp);
-      free (mailfile);
-    }
-}
-
-/* check_mail () is useful for more than just checking mail.  Since it has
-   the paranoids dream ability of telling you when someone has read your
-   mail, it can just as easily be used to tell you when someones .profile
-   file has been read, thus letting one know when someone else has logged
-   in.  Pretty good, huh? */
-
-/* Check for mail in some files.  If the modification date of any
-   of the files in MAILPATH has changed since we last did a
-   remember_mail_dates () then mention that the user has mail.
-   Special hack:  If the variable MAIL_WARNING is non-zero and the
-   mail file has been accessed since the last time we remembered, then
-   the message "The mail in <mailfile> has been read" is printed. */
-void
-check_mail ()
-{
-  char *current_mail_file, *message;
-  int i, use_user_notification;
-  char *dollar_underscore, *temp;
-
-  dollar_underscore = get_string_value ("_");
-  if (dollar_underscore)
-    dollar_underscore = savestring (dollar_underscore);
-
-  for (i = 0; i < mailfiles_count; i++)
-    {
-      current_mail_file = mailfiles[i]->name;
-
-      if (*current_mail_file == '\0')
-	continue;
-
-      if (file_mod_date_changed (i))
-	{
-	  int file_is_bigger;
-
-	  use_user_notification = mailfiles[i]->msg != (char *)NULL;
-	  message = mailfiles[i]->msg ? mailfiles[i]->msg : _("You have mail in $_");
-
-	  bind_variable ("_", current_mail_file, 0);
-
-#define atime mailfiles[i]->access_time
-#define mtime mailfiles[i]->mod_time
-
-	  /* Have to compute this before the call to update_mail_file, which
-	     resets all the information. */
-	  file_is_bigger = file_has_grown (i);
-
-	  update_mail_file (i);
-
-	  /* If the user has just run a program which manipulates the
-	     mail file, then don't bother explaining that the mail
-	     file has been manipulated.  Since some systems don't change
-	     the access time to be equal to the modification time when
-	     the mail in the file is manipulated, check the size also.  If
-	     the file has not grown, continue. */
-	  if ((atime >= mtime) && !file_is_bigger)
-	    continue;
-
-	  /* If the mod time is later than the access time and the file
-	     has grown, note the fact that this is *new* mail. */
-	  if (use_user_notification == 0 && (atime < mtime) && file_is_bigger)
-	    message = _("You have new mail in $_");
-#undef atime
-#undef mtime
-
-	  if (temp = expand_string_to_string (message, Q_DOUBLE_QUOTES))
-	    {
-	      puts (temp);
-	      free (temp);
-	    }
-	  else
-	    putchar ('\n');
-	}
-
-      if (mail_warning && file_access_date_changed (i))
-	{
-	  update_mail_file (i);
-	  printf (_("The mail in %s has been read\n"), current_mail_file);
-	}
-    }
-
-  if (dollar_underscore)
-    {
-      bind_variable ("_", dollar_underscore, 0);
-      free (dollar_underscore);
-    }
-  else
-    unbind_variable ("_");
-}
diff --git a/third_party/bash/mailcheck.h b/third_party/bash/mailcheck.h
deleted file mode 100644
index e930124c3..000000000
--- a/third_party/bash/mailcheck.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/* mailcheck.h -- variables and function declarations for mail checking. */
-
-/* Copyright (C) 1987-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_MAILCHECK_H_)
-#define _MAILCHECK_H_
-
-/* Functions from mailcheck.c */
-extern int time_to_check_mail PARAMS((void));
-extern void reset_mail_timer PARAMS((void));
-extern void reset_mail_files PARAMS((void));
-extern void free_mail_files PARAMS((void));
-extern char *make_default_mailpath PARAMS((void));
-extern void remember_mail_dates PARAMS((void));
-extern void init_mail_dates PARAMS((void));
-extern void check_mail PARAMS((void));
-
-#endif /* _MAILCHECK_H */
diff --git a/third_party/bash/mailstat.c b/third_party/bash/mailstat.c
deleted file mode 100644
index ba971b205..000000000
--- a/third_party/bash/mailstat.c
+++ /dev/null
@@ -1,159 +0,0 @@
-/* mailstat.c -- stat a mailbox file, handling maildir-type mail directories */
-
-/* Copyright (C) 2001 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
- 
-#include <stdio.h>
-#include <errno.h>
-
-#include "bashtypes.h"
-#include "posixstat.h"
-#include "posixdir.h"
-#include "bashansi.h"
-
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-
-#include "maxpath.h"
-
-/*
- *     Stat a file. If it's a maildir, check all messages
- *     in the maildir and present the grand total as a file.
- *     The fields in the 'struct stat' are from the mail directory.
- *     The following fields are emulated:
- *
- *     st_nlink	always 1, unless st_blocks is not present, in which case it's
- *		the total number of messages
- *     st_size	 total number of bytes in all files
- *     st_blocks       total number of messages, if present in struct stat
- *     st_atime	access time of newest file in maildir
- *     st_mtime	modify time of newest file in maildir
- *     st_mode	 S_IFDIR changed to S_IFREG
- *
- *     This is good enough for most mail-checking applications.
- */
-
-int
-mailstat(path, st)
-     const char *path;
-     struct stat *st;
-{
-  static struct stat st_new_last, st_ret_last;
-  struct stat st_ret, st_tmp;
-  DIR *dd;
-  struct dirent *fn;
-  char dir[PATH_MAX * 2], file[PATH_MAX * 2 + 1];
-  int i, l;
-  time_t atime, mtime;
-
-  atime = mtime = 0;
-
-  /* First see if it's a directory. */
-  if ((i = stat(path, st)) != 0 || S_ISDIR(st->st_mode) == 0)
-    return i;
-
-  if (strlen(path) > sizeof(dir) - 5)
-    {
-#ifdef ENAMETOOLONG
-      errno = ENAMETOOLONG;
-#else
-      errno = EINVAL;
-#endif
-      return -1;
-    }
-
-  st_ret = *st;
-  st_ret.st_nlink = 1;
-  st_ret.st_size  = 0;
-#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
-  st_ret.st_blocks  = 0;
-#else
-  st_ret.st_nlink = 0;
-#endif
-  st_ret.st_mode  &= ~S_IFDIR;
-  st_ret.st_mode  |= S_IFREG;
-
-  /* See if cur/ is present */
-  sprintf(dir, "%s/cur", path);
-  if (stat(dir, &st_tmp) || S_ISDIR(st_tmp.st_mode) == 0)
-    return 0;
-  st_ret.st_atime = st_tmp.st_atime;
-
-  /* See if tmp/ is present */
-  sprintf(dir, "%s/tmp", path);
-  if (stat(dir, &st_tmp) || S_ISDIR(st_tmp.st_mode) == 0)
-    return 0;
-  st_ret.st_mtime = st_tmp.st_mtime;
-
-  /* And new/ */
-  sprintf(dir, "%s/new", path);
-  if (stat(dir, &st_tmp) || S_ISDIR(st_tmp.st_mode) == 0)
-    return 0;
-  st_ret.st_mtime = st_tmp.st_mtime;
-
-  /* Optimization - if new/ didn't change, nothing else did. */
-  if (st_tmp.st_dev == st_new_last.st_dev &&
-      st_tmp.st_ino == st_new_last.st_ino &&
-      st_tmp.st_atime == st_new_last.st_atime &&
-      st_tmp.st_mtime == st_new_last.st_mtime)
-    {
-      *st = st_ret_last;
-      return 0;
-    }
-  st_new_last = st_tmp;
-
-  /* Loop over new/ and cur/ */
-  for (i = 0; i < 2; i++)
-    {
-      sprintf(dir, "%s/%s", path, i ? "cur" : "new");
-      sprintf(file, "%s/", dir);
-      l = strlen(file);
-      if ((dd = opendir(dir)) == NULL)
-	return 0;
-      while ((fn = readdir(dd)) != NULL)
-	{
-	  if (fn->d_name[0] == '.' || strlen(fn->d_name) + l >= sizeof(file))
-	    continue;
-	  strcpy(file + l, fn->d_name);
-	  if (stat(file, &st_tmp) != 0)
-	    continue;
-	  st_ret.st_size += st_tmp.st_size;
-#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
-	  st_ret.st_blocks++;
-#else
-	  st_ret.st_nlink++;
-#endif
-	  if (st_tmp.st_atime != st_tmp.st_mtime && st_tmp.st_atime > atime)
-	    atime = st_tmp.st_atime;
-	  if (st_tmp.st_mtime > mtime)
-	    mtime = st_tmp.st_mtime;
-	}
-      closedir(dd);
-    }
-
-/*  if (atime) */	/* Set atime even if cur/ is empty */
-      st_ret.st_atime = atime;
-    if (mtime)
-      st_ret.st_mtime = mtime;
-
-    *st = st_ret_last = st_ret;
-    return 0;
-}
diff --git a/third_party/bash/make_cmd.c b/third_party/bash/make_cmd.c
deleted file mode 100644
index 98151a41a..000000000
--- a/third_party/bash/make_cmd.c
+++ /dev/null
@@ -1,907 +0,0 @@
-/* make_cmd.c -- Functions for making instances of the various
-   parser constructs. */
-
-/* Copyright (C) 1989-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <stdio.h>
-#include "bashtypes.h"
-#if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-#include "filecntl.h"
-#include "bashansi.h"
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "parser.h"
-#include "flags.h"
-#include "input.h"
-
-#if defined (JOB_CONTROL)
-#include "jobs.h"
-#endif
-
-#include "shmbutil.h"
-
-int here_doc_first_line = 0;
-
-/* Object caching */
-sh_obj_cache_t wdcache = {0, 0, 0};
-sh_obj_cache_t wlcache = {0, 0, 0};
-
-#define WDCACHESIZE	128
-#define WLCACHESIZE	128
-
-static COMMAND *make_for_or_select PARAMS((enum command_type, WORD_DESC *, WORD_LIST *, COMMAND *, int));
-#if defined (ARITH_FOR_COMMAND)
-static WORD_LIST *make_arith_for_expr PARAMS((char *));
-#endif
-static COMMAND *make_until_or_while PARAMS((enum command_type, COMMAND *, COMMAND *));
-
-void
-cmd_init ()
-{
-  ocache_create (wdcache, WORD_DESC, WDCACHESIZE);
-  ocache_create (wlcache, WORD_LIST, WLCACHESIZE);
-}
-
-WORD_DESC *
-alloc_word_desc ()
-{
-  WORD_DESC *temp;
-
-  ocache_alloc (wdcache, WORD_DESC, temp);
-  temp->flags = 0;
-  temp->word = 0;
-  return temp;
-}
-
-WORD_DESC *
-make_bare_word (string)
-     const char *string;
-{
-  WORD_DESC *temp;
-
-  temp = alloc_word_desc ();
-
-  if (*string)
-    temp->word = savestring (string);
-  else
-    {
-      temp->word = (char *)xmalloc (1);
-      temp->word[0] = '\0';
-    }
-
-  return (temp);
-}
-
-WORD_DESC *
-make_word_flags (w, string)
-     WORD_DESC *w;
-     const char *string;
-{
-  register int i;
-  size_t slen;
-  DECLARE_MBSTATE;
-
-  i = 0;
-  slen = strlen (string);
-  while (i < slen)
-    {
-      switch (string[i])
-	{
-	case '$':
-	  w->flags |= W_HASDOLLAR;
-	  break;
-	case '\\':
-	  break;	/* continue the loop */
-	case '\'':
-	case '`':
-	case '"':
-	  w->flags |= W_QUOTED;
-	  break;
-	}
-
-      ADVANCE_CHAR (string, slen, i);
-    }
-
-  return (w);
-}
-
-WORD_DESC *
-make_word (string)
-     const char *string;
-{
-  WORD_DESC *temp;
-
-  temp = make_bare_word (string);
-  return (make_word_flags (temp, string));
-}
-
-WORD_DESC *
-make_word_from_token (token)
-     int token;
-{
-  char tokenizer[2];
-
-  tokenizer[0] = token;
-  tokenizer[1] = '\0';
-
-  return (make_word (tokenizer));
-}
-
-WORD_LIST *
-make_word_list (word, wlink)
-     WORD_DESC *word;
-     WORD_LIST *wlink;
-{
-  WORD_LIST *temp;
-
-  ocache_alloc (wlcache, WORD_LIST, temp);
-
-  temp->word = word;
-  temp->next = wlink;
-  return (temp);
-}
-
-COMMAND *
-make_command (type, pointer)
-     enum command_type type;
-     SIMPLE_COM *pointer;
-{
-  COMMAND *temp;
-
-  temp = (COMMAND *)xmalloc (sizeof (COMMAND));
-  temp->type = type;
-  temp->value.Simple = pointer;
-  temp->value.Simple->flags = temp->flags = 0;
-  temp->redirects = (REDIRECT *)NULL;
-  return (temp);
-}
-
-COMMAND *
-command_connect (com1, com2, connector)
-     COMMAND *com1, *com2;
-     int connector;
-{
-  CONNECTION *temp;
-
-  temp = (CONNECTION *)xmalloc (sizeof (CONNECTION));
-  temp->connector = connector;
-  temp->first = com1;
-  temp->second = com2;
-  return (make_command (cm_connection, (SIMPLE_COM *)temp));
-}
-
-static COMMAND *
-make_for_or_select (type, name, map_list, action, lineno)
-     enum command_type type;
-     WORD_DESC *name;
-     WORD_LIST *map_list;
-     COMMAND *action;
-     int lineno;
-{
-  FOR_COM *temp;
-
-  temp = (FOR_COM *)xmalloc (sizeof (FOR_COM));
-  temp->flags = 0;
-  temp->name = name;
-  temp->line = lineno;
-  temp->map_list = map_list;
-  temp->action = action;
-  return (make_command (type, (SIMPLE_COM *)temp));
-}
-
-COMMAND *
-make_for_command (name, map_list, action, lineno)
-     WORD_DESC *name;
-     WORD_LIST *map_list;
-     COMMAND *action;
-     int lineno;
-{
-  return (make_for_or_select (cm_for, name, map_list, action, lineno));
-}
-
-COMMAND *
-make_select_command (name, map_list, action, lineno)
-     WORD_DESC *name;
-     WORD_LIST *map_list;
-     COMMAND *action;
-     int lineno;
-{
-#if defined (SELECT_COMMAND)
-  return (make_for_or_select (cm_select, name, map_list, action, lineno));
-#else
-  set_exit_status (2);
-  return ((COMMAND *)NULL);
-#endif
-}
-
-#if defined (ARITH_FOR_COMMAND)
-static WORD_LIST *
-make_arith_for_expr (s)
-     char *s;
-{
-  WORD_LIST *result;
-  WORD_DESC *wd;
-
-  if (s == 0 || *s == '\0')
-    return ((WORD_LIST *)NULL);
-  wd = make_word (s);
-  wd->flags |= W_NOGLOB|W_NOSPLIT|W_QUOTED|W_NOTILDE|W_NOPROCSUB;	/* no word splitting or globbing */
-  result = make_word_list (wd, (WORD_LIST *)NULL);
-  return result;
-}
-#endif
-
-/* Note that this function calls dispose_words on EXPRS, since it doesn't
-   use the word list directly.  We free it here rather than at the caller
-   because no other function in this file requires that the caller free
-   any arguments. */
-COMMAND *
-make_arith_for_command (exprs, action, lineno)
-     WORD_LIST *exprs;
-     COMMAND *action;
-     int lineno;
-{
-#if defined (ARITH_FOR_COMMAND)
-  ARITH_FOR_COM *temp;
-  WORD_LIST *init, *test, *step;
-  char *s, *t, *start;
-  int nsemi, i;
-
-  init = test = step = (WORD_LIST *)NULL;
-  /* Parse the string into the three component sub-expressions. */
-  start = t = s = exprs->word->word;
-  for (nsemi = 0; ;)
-    {
-      /* skip whitespace at the start of each sub-expression. */
-      while (whitespace (*s))
-	s++;
-      start = s;
-      /* skip to the semicolon or EOS */
-      i = skip_to_delim (start, 0, ";", SD_NOJMP|SD_NOPROCSUB);
-      s = start + i;
-
-      t = (i > 0) ? substring (start, 0, i) : (char *)NULL;
-
-      nsemi++;
-      switch (nsemi)
-	{
-	case 1:
-	  init = make_arith_for_expr (t);
-	  break;
-	case 2:
-	  test = make_arith_for_expr (t);
-	  break;
-	case 3:
-	  step = make_arith_for_expr (t);
-	  break;
-	}
-
-      FREE (t);
-      if (*s == '\0')
-	break;
-      s++;	/* skip over semicolon */
-    }
-
-  if (nsemi != 3)
-    {
-      if (nsemi < 3)
-	parser_error (lineno, _("syntax error: arithmetic expression required"));
-      else
-	parser_error (lineno, _("syntax error: `;' unexpected"));
-      parser_error (lineno, _("syntax error: `((%s))'"), exprs->word->word);
-      free (init);
-      free (test);
-      free (step);
-      set_exit_status (2);
-      return ((COMMAND *)NULL);
-    }
-
-  temp = (ARITH_FOR_COM *)xmalloc (sizeof (ARITH_FOR_COM));
-  temp->flags = 0;
-  temp->line = lineno;
-  temp->init = init ? init : make_arith_for_expr ("1");
-  temp->test = test ? test : make_arith_for_expr ("1");
-  temp->step = step ? step : make_arith_for_expr ("1");
-  temp->action = action;
-
-  dispose_words (exprs);
-  return (make_command (cm_arith_for, (SIMPLE_COM *)temp));
-#else
-  dispose_words (exprs);
-  set_exit_status (2);
-  return ((COMMAND *)NULL);
-#endif /* ARITH_FOR_COMMAND */
-}
-
-COMMAND *
-make_group_command (command)
-     COMMAND *command;
-{
-  GROUP_COM *temp;
-
-  temp = (GROUP_COM *)xmalloc (sizeof (GROUP_COM));
-  temp->command = command;
-  return (make_command (cm_group, (SIMPLE_COM *)temp));
-}
-
-COMMAND *
-make_case_command (word, clauses, lineno)
-     WORD_DESC *word;
-     PATTERN_LIST *clauses;
-     int lineno;
-{
-  CASE_COM *temp;
-
-  temp = (CASE_COM *)xmalloc (sizeof (CASE_COM));
-  temp->flags = 0;
-  temp->line = lineno;
-  temp->word = word;
-  temp->clauses = REVERSE_LIST (clauses, PATTERN_LIST *);
-  return (make_command (cm_case, (SIMPLE_COM *)temp));
-}
-
-PATTERN_LIST *
-make_pattern_list (patterns, action)
-     WORD_LIST *patterns;
-     COMMAND *action;
-{
-  PATTERN_LIST *temp;
-
-  temp = (PATTERN_LIST *)xmalloc (sizeof (PATTERN_LIST));
-  temp->patterns = REVERSE_LIST (patterns, WORD_LIST *);
-  temp->action = action;
-  temp->next = NULL;
-  temp->flags = 0;
-  return (temp);
-}
-
-COMMAND *
-make_if_command (test, true_case, false_case)
-     COMMAND *test, *true_case, *false_case;
-{
-  IF_COM *temp;
-
-  temp = (IF_COM *)xmalloc (sizeof (IF_COM));
-  temp->flags = 0;
-  temp->test = test;
-  temp->true_case = true_case;
-  temp->false_case = false_case;
-  return (make_command (cm_if, (SIMPLE_COM *)temp));
-}
-
-static COMMAND *
-make_until_or_while (which, test, action)
-     enum command_type which;
-     COMMAND *test, *action;
-{
-  WHILE_COM *temp;
-
-  temp = (WHILE_COM *)xmalloc (sizeof (WHILE_COM));
-  temp->flags = 0;
-  temp->test = test;
-  temp->action = action;
-  return (make_command (which, (SIMPLE_COM *)temp));
-}
-
-COMMAND *
-make_while_command (test, action)
-     COMMAND *test, *action;
-{
-  return (make_until_or_while (cm_while, test, action));
-}
-
-COMMAND *
-make_until_command (test, action)
-     COMMAND *test, *action;
-{
-  return (make_until_or_while (cm_until, test, action));
-}
-
-COMMAND *
-make_arith_command (exp)
-     WORD_LIST *exp;
-{
-#if defined (DPAREN_ARITHMETIC)
-  COMMAND *command;
-  ARITH_COM *temp;
-
-  command = (COMMAND *)xmalloc (sizeof (COMMAND));
-  command->value.Arith = temp = (ARITH_COM *)xmalloc (sizeof (ARITH_COM));
-
-  temp->flags = 0;
-  temp->line = line_number;
-  temp->exp = exp;
-
-  command->type = cm_arith;
-  command->redirects = (REDIRECT *)NULL;
-  command->flags = 0;
-
-  return (command);
-#else
-  set_exit_status (2);
-  return ((COMMAND *)NULL);
-#endif
-}
-
-#if defined (COND_COMMAND)
-struct cond_com *
-make_cond_node (type, op, left, right)
-     int type;
-     WORD_DESC *op;
-     struct cond_com *left, *right;
-{
-  COND_COM *temp;
-
-  temp = (COND_COM *)xmalloc (sizeof (COND_COM));
-  temp->flags = 0;
-  temp->line = line_number;
-  temp->type = type;
-  temp->op = op;
-  temp->left = left;
-  temp->right = right;
-
-  return (temp);
-}
-#endif
-
-COMMAND *
-make_cond_command (cond_node)
-     COND_COM *cond_node;
-{
-#if defined (COND_COMMAND)
-  COMMAND *command;
-
-  command = (COMMAND *)xmalloc (sizeof (COMMAND));
-  command->value.Cond = cond_node;
-
-  command->type = cm_cond;
-  command->redirects = (REDIRECT *)NULL;
-  command->flags = 0;
-  command->line = cond_node ? cond_node->line : 0;
-
-  return (command);
-#else
-  set_exit_status (2);
-  return ((COMMAND *)NULL);
-#endif
-}
-
-COMMAND *
-make_bare_simple_command ()
-{
-  COMMAND *command;
-  SIMPLE_COM *temp;
-
-  command = (COMMAND *)xmalloc (sizeof (COMMAND));
-  command->value.Simple = temp = (SIMPLE_COM *)xmalloc (sizeof (SIMPLE_COM));
-
-  temp->flags = 0;
-  temp->line = line_number;
-  temp->words = (WORD_LIST *)NULL;
-  temp->redirects = (REDIRECT *)NULL;
-
-  command->type = cm_simple;
-  command->redirects = (REDIRECT *)NULL;
-  command->flags = 0;
-
-  return (command);
-}
-
-/* Return a command which is the connection of the word or redirection
-   in ELEMENT, and the command * or NULL in COMMAND. */
-COMMAND *
-make_simple_command (element, command)
-     ELEMENT element;
-     COMMAND *command;
-{
-  /* If we are starting from scratch, then make the initial command
-     structure.  Also note that we have to fill in all the slots, since
-     malloc doesn't return zeroed space. */
-  if (command == 0)
-    {
-      command = make_bare_simple_command ();
-      parser_state |= PST_REDIRLIST;
-    }
-
-  if (element.word)
-    {
-      command->value.Simple->words = make_word_list (element.word, command->value.Simple->words);
-      parser_state &= ~PST_REDIRLIST;
-    }
-  else if (element.redirect)
-    {
-      REDIRECT *r = element.redirect;
-      /* Due to the way <> is implemented, there may be more than a single
-	 redirection in element.redirect.  We just follow the chain as far
-	 as it goes, and hook onto the end. */
-      while (r->next)
-	r = r->next;
-      r->next = command->value.Simple->redirects;
-      command->value.Simple->redirects = element.redirect;
-    }
-
-  return (command);
-}
-
-/* Because we are Bourne compatible, we read the input for this
-   << or <<- redirection now, from wherever input is coming from.
-   We store the input read into a WORD_DESC.  Replace the text of
-   the redirectee.word with the new input text.  If <<- is on,
-   then remove leading TABS from each line. */
-void
-make_here_document (temp, lineno)
-     REDIRECT *temp;
-     int lineno;
-{
-  int kill_leading, redir_len;
-  char *redir_word, *document, *full_line;
-  int document_index, document_size, delim_unquoted;
-
-  if (temp->instruction != r_deblank_reading_until &&
-      temp->instruction != r_reading_until)
-    {
-      internal_error (_("make_here_document: bad instruction type %d"), temp->instruction);
-      return;
-    }
-
-  kill_leading = temp->instruction == r_deblank_reading_until;
-
-  full_line = document = (char *)NULL;
-  document_index = document_size = 0;
-
-  delim_unquoted = (temp->redirectee.filename->flags & W_QUOTED) == 0;
-
-  /* Quote removal is the only expansion performed on the delimiter
-     for here documents, making it an extremely special case. */
-  /* "If any part of word is quoted, the delimiter shall be formed by
-     performing quote removal on word." */
-  if (delim_unquoted == 0)
-    redir_word = string_quote_removal (temp->redirectee.filename->word, 0);
-  else
-    redir_word = savestring (temp->redirectee.filename->word);
-
-  /* redirection_expand will return NULL if the expansion results in
-     multiple words or no words.  Check for that here, and just abort
-     this here document if it does. */
-  if (redir_word)
-    redir_len = strlen (redir_word);
-  else
-    {
-      temp->here_doc_eof = (char *)xmalloc (1);
-      temp->here_doc_eof[0] = '\0';
-      goto document_done;
-    }
-
-  free (temp->redirectee.filename->word);
-  temp->here_doc_eof = redir_word;
-
-  /* Read lines from wherever lines are coming from.
-     For each line read, if kill_leading, then kill the
-     leading tab characters.
-     If the line matches redir_word exactly, then we have
-     manufactured the document.  Otherwise, add the line to the
-     list of lines in the document. */
-
-  /* If the here-document delimiter was quoted, the lines should
-     be read verbatim from the input.  If it was not quoted, we
-     need to perform backslash-quoted newline removal. */
-  while (full_line = read_secondary_line (delim_unquoted))
-    {
-      register char *line;
-      int len;
-
-      here_doc_first_line = 0;
-      line = full_line;
-      line_number++;
-
-      /* If set -v is in effect, echo the line read.  read_secondary_line/
-	 read_a_line leaves the newline at the end, so don't print another. */
-      if (echo_input_at_read)
-	fprintf (stderr, "%s", line);
-
-      if (kill_leading && *line)
-	{
-	  /* Hack:  To be compatible with some Bourne shells, we
-	     check the word before stripping the whitespace.  This
-	     is a hack, though. */
-	  if (STREQN (line, redir_word, redir_len) && line[redir_len] == '\n')
-	    break;
-
-	  while (*line == '\t')
-	    line++;
-	}
-
-      if (*line == 0)
-	continue;
-
-      if (STREQN (line, redir_word, redir_len) && line[redir_len] == '\n')
-	break;
-
-      /* Backwards compatibility here */
-      if (STREQN (line, redir_word, redir_len) && (parser_state & PST_EOFTOKEN) && shell_eof_token && strchr (line+redir_len, shell_eof_token))
-	{
-	  shell_ungets (line + redir_len);
-	  full_line = 0;
-	  break;
-	}
-
-      len = strlen (line);
-      if (len + document_index >= document_size)
-	{
-	  document_size = document_size ? 2 * (document_size + len) : len + 2;
-	  document = (char *)xrealloc (document, document_size);
-	}
-
-      /* len is guaranteed to be > 0 because of the check for line
-	 being an empty string before the call to strlen. */
-      FASTCOPY (line, document + document_index, len);
-      document_index += len;
-    }
-
-  if (full_line == 0)
-    internal_warning (_("here-document at line %d delimited by end-of-file (wanted `%s')"), lineno, redir_word);
-
-document_done:
-  if (document)
-    document[document_index] = '\0';
-  else
-    {
-      document = (char *)xmalloc (1);
-      document[0] = '\0';
-    }
-  temp->redirectee.filename->word = document;
-  here_doc_first_line = 0;
-}
-
-/* Generate a REDIRECT from SOURCE, DEST, and INSTRUCTION.
-   INSTRUCTION is the instruction type, SOURCE is a file descriptor,
-   and DEST is a file descriptor or a WORD_DESC *. */
-REDIRECT *
-make_redirection (source, instruction, dest_and_filename, flags)
-     REDIRECTEE source;
-     enum r_instruction instruction;
-     REDIRECTEE dest_and_filename;
-     int flags;
-{
-  REDIRECT *temp;
-  WORD_DESC *w;
-  int wlen;
-  intmax_t lfd;
-
-  temp = (REDIRECT *)xmalloc (sizeof (REDIRECT));
-
-  /* First do the common cases. */
-  temp->redirector = source;
-  temp->redirectee = dest_and_filename;
-  temp->here_doc_eof = 0;
-  temp->instruction = instruction;
-  temp->flags = 0;
-  temp->rflags = flags;
-  temp->next = (REDIRECT *)NULL;
-
-  switch (instruction)
-    {
-
-    case r_output_direction:		/* >foo */
-    case r_output_force:		/* >| foo */
-    case r_err_and_out:			/* &>filename */
-      temp->flags = O_TRUNC | O_WRONLY | O_CREAT;
-      break;
-
-    case r_appending_to:		/* >>foo */
-    case r_append_err_and_out:		/* &>> filename */
-      temp->flags = O_APPEND | O_WRONLY | O_CREAT;
-      break;
-
-    case r_input_direction:		/* <foo */
-    case r_inputa_direction:		/* foo & makes this. */
-      temp->flags = O_RDONLY;
-      break;
-
-    case r_input_output:		/* <>foo */
-      temp->flags = O_RDWR | O_CREAT;
-      break;
-
-    case r_deblank_reading_until: 	/* <<-foo */
-    case r_reading_until:		/* << foo */
-    case r_reading_string:		/* <<< foo */
-    case r_close_this:			/* <&- */
-    case r_duplicating_input:		/* 1<&2 */
-    case r_duplicating_output:		/* 1>&2 */
-      break;
-
-    /* the parser doesn't pass these. */
-    case r_move_input:			/* 1<&2- */
-    case r_move_output:			/* 1>&2- */
-    case r_move_input_word:		/* 1<&$foo- */
-    case r_move_output_word:		/* 1>&$foo- */
-      break;
-
-    /* The way the lexer works we have to do this here. */
-    case r_duplicating_input_word:	/* 1<&$foo */
-    case r_duplicating_output_word:	/* 1>&$foo */
-      w = dest_and_filename.filename;
-      wlen = strlen (w->word) - 1;
-      if (w->word[wlen] == '-')		/* Yuck */
-        {
-          w->word[wlen] = '\0';
-	  if (all_digits (w->word) && legal_number (w->word, &lfd) && lfd == (int)lfd)
-	    {
-	      dispose_word (w);
-	      temp->instruction = (instruction == r_duplicating_input_word) ? r_move_input : r_move_output;
-	      temp->redirectee.dest = lfd;
-	    }
-	  else
-	    temp->instruction = (instruction == r_duplicating_input_word) ? r_move_input_word : r_move_output_word;
-        }
-          
-      break;
-
-    default:
-      programming_error (_("make_redirection: redirection instruction `%d' out of range"), instruction);
-      abort ();
-      break;
-    }
-  return (temp);
-}
-
-COMMAND *
-make_function_def (name, command, lineno, lstart)
-     WORD_DESC *name;
-     COMMAND *command;
-     int lineno, lstart;
-{
-  FUNCTION_DEF *temp;
-#if defined (ARRAY_VARS)
-  SHELL_VAR *bash_source_v;
-  ARRAY *bash_source_a;
-#endif
-
-  temp = (FUNCTION_DEF *)xmalloc (sizeof (FUNCTION_DEF));
-  temp->command = command;
-  temp->name = name;
-  temp->line = lineno;
-  temp->flags = 0;
-  command->line = lstart;
-
-  /* Information used primarily for debugging. */
-  temp->source_file = 0;
-#if defined (ARRAY_VARS)
-  GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v, bash_source_a);
-  if (bash_source_a && array_num_elements (bash_source_a) > 0)
-    temp->source_file = array_reference (bash_source_a, 0);
-#endif
-  /* Assume that shell functions without a source file before the shell is
-     initialized come from the environment.  Otherwise default to "main"
-     (usually functions being defined interactively) */
-  if (temp->source_file == 0)
-    temp->source_file = shell_initialized ? "main" : "environment";
-
-#if defined (DEBUGGER)
-  bind_function_def (name->word, temp, 0);
-#endif
-
-  temp->source_file = temp->source_file ? savestring (temp->source_file) : 0;
-
-  return (make_command (cm_function_def, (SIMPLE_COM *)temp));
-}
-
-COMMAND *
-make_subshell_command (command)
-     COMMAND *command;
-{
-  SUBSHELL_COM *temp;
-
-  temp = (SUBSHELL_COM *)xmalloc (sizeof (SUBSHELL_COM));
-  temp->command = command;
-  temp->flags = CMD_WANT_SUBSHELL;
-  temp->line = line_number;
-  return (make_command (cm_subshell, (SIMPLE_COM *)temp));
-}
-
-COMMAND *
-make_coproc_command (name, command)
-     char *name;
-     COMMAND *command;
-{
-  COPROC_COM *temp;
-
-  temp = (COPROC_COM *)xmalloc (sizeof (COPROC_COM));
-  temp->name = savestring (name);
-  temp->command = command;
-  temp->flags = CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
-  return (make_command (cm_coproc, (SIMPLE_COM *)temp));
-}
-
-/* Reverse the word list and redirection list in the simple command
-   has just been parsed.  It seems simpler to do this here the one
-   time then by any other method that I can think of. */
-COMMAND *
-clean_simple_command (command)
-     COMMAND *command;
-{
-  if (command->type != cm_simple)
-    command_error ("clean_simple_command", CMDERR_BADTYPE, command->type, 0);
-  else
-    {
-      command->value.Simple->words =
-	REVERSE_LIST (command->value.Simple->words, WORD_LIST *);
-      command->value.Simple->redirects =
-	REVERSE_LIST (command->value.Simple->redirects, REDIRECT *);
-    }
-
-  parser_state &= ~PST_REDIRLIST;
-  return (command);
-}
-
-/* The Yacc grammar productions have a problem, in that they take a
-   list followed by an ampersand (`&') and do a simple command connection,
-   making the entire list effectively asynchronous, instead of just
-   the last command.  This means that when the list is executed, all
-   the commands have stdin set to /dev/null when job control is not
-   active, instead of just the last.  This is wrong, and needs fixing
-   up.  This function takes the `&' and applies it to the last command
-   in the list.  This is done only for lists connected by `;'; it makes
-   `;' bind `tighter' than `&'. */
-COMMAND *
-connect_async_list (command, command2, connector)
-     COMMAND *command, *command2;
-     int connector;
-{
-  COMMAND *t, *t1, *t2;
-
-  t1 = command;
-  t = command->value.Connection->second;
-
-  if (!t || (command->flags & CMD_WANT_SUBSHELL) ||
-      command->value.Connection->connector != ';')
-    {
-      t = command_connect (command, command2, connector);
-      return t;
-    }
-
-  /* This is just defensive programming.  The Yacc precedence rules
-     will generally hand this function a command where t points directly
-     to the command we want (e.g. given a ; b ; c ; d &, t1 will point
-     to the `a ; b ; c' list and t will be the `d').  We only want to do
-     this if the list is not being executed as a unit in the background
-     with `( ... )', so we have to check for CMD_WANT_SUBSHELL.  That's
-     the only way to tell. */
-  while (((t->flags & CMD_WANT_SUBSHELL) == 0) && t->type == cm_connection &&
-	 t->value.Connection->connector == ';')
-    {
-      t1 = t;
-      t = t->value.Connection->second;
-    }
-  /* Now we have t pointing to the last command in the list, and
-     t1->value.Connection->second == t. */
-  t2 = command_connect (t, command2, connector);
-  t1->value.Connection->second = t2;
-  return command;
-}
diff --git a/third_party/bash/make_cmd.h b/third_party/bash/make_cmd.h
deleted file mode 100644
index bf1fb008d..000000000
--- a/third_party/bash/make_cmd.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/* make_cmd.h -- Declarations of functions found in make_cmd.c */
-
-/* Copyright (C) 1993-2009,2020  Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_MAKE_CMD_H_)
-#define _MAKE_CMD_H_
-
-#include "stdc.h"
-
-extern int here_doc_first_line;
-
-extern void cmd_init PARAMS((void));
-
-extern WORD_DESC *alloc_word_desc PARAMS((void));
-extern WORD_DESC *make_bare_word PARAMS((const char *));
-extern WORD_DESC *make_word_flags PARAMS((WORD_DESC *, const char *));
-extern WORD_DESC *make_word PARAMS((const char *));
-extern WORD_DESC *make_word_from_token PARAMS((int));
-
-extern WORD_LIST *make_word_list PARAMS((WORD_DESC *, WORD_LIST *));
-
-#define add_string_to_list(s, l) make_word_list (make_word(s), (l))
-
-extern COMMAND *make_command PARAMS((enum command_type, SIMPLE_COM *));
-extern COMMAND *command_connect PARAMS((COMMAND *, COMMAND *, int));
-extern COMMAND *make_for_command PARAMS((WORD_DESC *, WORD_LIST *, COMMAND *, int));
-extern COMMAND *make_group_command PARAMS((COMMAND *));
-extern COMMAND *make_case_command PARAMS((WORD_DESC *, PATTERN_LIST *, int));
-extern PATTERN_LIST *make_pattern_list PARAMS((WORD_LIST *, COMMAND *));
-extern COMMAND *make_if_command PARAMS((COMMAND *, COMMAND *, COMMAND *));
-extern COMMAND *make_while_command PARAMS((COMMAND *, COMMAND *));
-extern COMMAND *make_until_command PARAMS((COMMAND *, COMMAND *));
-extern COMMAND *make_bare_simple_command PARAMS((void));
-extern COMMAND *make_simple_command PARAMS((ELEMENT, COMMAND *));
-extern void make_here_document PARAMS((REDIRECT *, int));
-extern REDIRECT *make_redirection PARAMS((REDIRECTEE, enum r_instruction, REDIRECTEE, int));
-extern COMMAND *make_function_def PARAMS((WORD_DESC *, COMMAND *, int, int));
-extern COMMAND *clean_simple_command PARAMS((COMMAND *));
-
-extern COMMAND *make_arith_command PARAMS((WORD_LIST *));
-
-extern COMMAND *make_select_command PARAMS((WORD_DESC *, WORD_LIST *, COMMAND *, int));
-
-#if defined (COND_COMMAND)
-extern COND_COM *make_cond_node PARAMS((int, WORD_DESC *, COND_COM *, COND_COM *));
-extern COMMAND *make_cond_command PARAMS((COND_COM *));
-#endif
-
-extern COMMAND *make_arith_for_command PARAMS((WORD_LIST *, COMMAND *, int));
-
-extern COMMAND *make_subshell_command PARAMS((COMMAND *));
-extern COMMAND *make_coproc_command PARAMS((char *, COMMAND *));
-
-extern COMMAND *connect_async_list PARAMS((COMMAND *, COMMAND *, int));
-
-#endif /* !_MAKE_CMD_H */
diff --git a/third_party/bash/makepath.c b/third_party/bash/makepath.c
deleted file mode 100644
index b0d661671..000000000
--- a/third_party/bash/makepath.c
+++ /dev/null
@@ -1,128 +0,0 @@
-/* makepath.c - glue PATH and DIR together into a full pathname. */
-
-/* Copyright (C) 1987-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include "shell.h"
-
-#include "tilde.h"
-
-#ifndef NULL
-#  define NULL 0
-#endif
-
-/* MAKE SURE THESE AGREE WITH ../../externs.h. */
-
-#ifndef MP_DOTILDE
-#  define MP_DOTILDE	0x01
-#  define MP_DOCWD	0x02
-#  define MP_RMDOT	0x04
-#  define MP_IGNDOT	0x08
-#endif
-
-extern char *get_working_directory PARAMS((char *));
-
-static char *nullpath = "";
-
-/* Take PATH, an element from, e.g., $CDPATH, and DIR, a directory name,
-   and paste them together into PATH/DIR.  Tilde expansion is performed on
-   PATH if (flags & MP_DOTILDE) is non-zero.  If PATH is NULL or the empty
-   string, it is converted to the current directory.  A full pathname is
-   used if (flags & MP_DOCWD) is non-zero, otherwise `./' is used.  If
-   (flags & MP_RMDOT) is non-zero, any `./' is removed from the beginning
-   of DIR.  If (flags & MP_IGNDOT) is non-zero, a PATH that is "." or "./"
-   is ignored. */
-
-#define MAKEDOT() \
-  do { \
-    xpath = (char *)xmalloc (2); \
-    xpath[0] = '.'; \
-    xpath[1] = '\0'; \
-    pathlen = 1; \
-  } while (0)
-
-char *
-sh_makepath (path, dir, flags)
-     const char *path, *dir;
-     int flags;
-{
-  int dirlen, pathlen;
-  char *ret, *xpath, *xdir, *r, *s;
-
-  if (path == 0 || *path == '\0')
-    {
-      if (flags & MP_DOCWD)
-	{
-	  xpath = get_working_directory ("sh_makepath");
-	  if (xpath == 0)
-	    {
-	      ret = get_string_value ("PWD");
-	      if (ret)
-		xpath = savestring (ret);
-	    }
-	  if (xpath == 0)
-	    MAKEDOT();
-	  else
-	    pathlen = strlen (xpath);
-	}
-      else
-	MAKEDOT();
-    }
-  else if ((flags & MP_IGNDOT) && path[0] == '.' && (path[1] == '\0' ||
-						     (path[1] == '/' && path[2] == '\0')))
-    {
-      xpath = nullpath;
-      pathlen = 0;
-    }
-  else
-    {
-      xpath = ((flags & MP_DOTILDE) && *path == '~') ? bash_tilde_expand (path, 0) : (char *)path;
-      pathlen = strlen (xpath);
-    }
-
-  xdir = (char *)dir;
-  dirlen = strlen (xdir);
-  if ((flags & MP_RMDOT) && dir[0] == '.' && dir[1] == '/')
-    {
-      xdir += 2;
-      dirlen -= 2;
-    }
-
-  r = ret = (char *)xmalloc (2 + dirlen + pathlen);
-  s = xpath;
-  while (*s)
-    *r++ = *s++;
-  if (s > xpath && s[-1] != '/')
-    *r++ = '/';      
-  s = xdir;
-  while (*r++ = *s++)
-    ;
-  if (xpath != path && xpath != nullpath)
-    free (xpath);
-  return (ret);
-}
diff --git a/third_party/bash/maxpath.h b/third_party/bash/maxpath.h
deleted file mode 100644
index db2e1fb42..000000000
--- a/third_party/bash/maxpath.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/* maxpath.h - Find out what this system thinks PATH_MAX and NAME_MAX are. */
-
-/* Copyright (C) 1993 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_MAXPATH_H_)
-#define _MAXPATH_H_
-
-/* These values are supposed to be in <limits.h> or one of the files
-   it includes. */
-#if defined (HAVE_LIMITS_H)
-#  include <limits.h>
-#endif /* !HAVE_LIMITS_H */
-
-/* If PATH_MAX is not defined, look for MAXPATHLEN */
-#if !defined (PATH_MAX)
-#  if defined (HAVE_SYS_PARAM_H)
-#    include <sys/param.h>
-#    define maxpath_param_h
-#  endif
-#  if defined (MAXPATHLEN) && !defined (PATH_MAX)
-#    define PATH_MAX MAXPATHLEN
-#  endif /* MAXPATHLEN && !PATH_MAX */
-#endif /* !PATH_MAX */
-
-/* If NAME_MAX is not defined, look for MAXNAMLEN */
-#if !defined (NAME_MAX)
-#  if defined (HAVE_SYS_PARAM_H) && !defined (maxpath_param_h)
-#    include <sys/param.h>
-#  endif
-#  if defined (MAXNAMLEN) && !defined (NAME_MAX)
-#    define NAME_MAX MAXNAMLEN
-#  endif /* MAXNAMLEN && !NAME_MAX */
-#endif /* !NAME_MAX */
-
-/* Default POSIX values */
-#if !defined (PATH_MAX) && defined (_POSIX_PATH_MAX)
-#  define PATH_MAX _POSIX_PATH_MAX
-#endif
-
-#if !defined (NAME_MAX) && defined (_POSIX_NAME_MAX)
-#  define NAME_MAX _POSIX_NAME_MAX
-#endif
-
-
-/* Default values */
-#if !defined (PATH_MAX)
-#  define PATH_MAX 1024
-#endif
-
-#if !defined (NAME_MAX)
-#  define NAME_MAX 14
-#endif
-
-#if PATH_MAX < 1024
-#  undef PATH_MAX
-#  define PATH_MAX 1024
-#endif
-
-#endif /* _MAXPATH_H_ */
diff --git a/third_party/bash/mbscasecmp.c b/third_party/bash/mbscasecmp.c
deleted file mode 100644
index 6f65d79bd..000000000
--- a/third_party/bash/mbscasecmp.c
+++ /dev/null
@@ -1,79 +0,0 @@
-/* mbscasecmp - case-insensitive multibyte string comparison. */
-
-/* Copyright (C) 2009-2015 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if !defined (HAVE_MBSCASECMP) && defined (HANDLE_MULTIBYTE)
-
-#include <stdlib.h>
-#include <stddef.h>
-#include <string.h>
-
-#include <wchar.h>
-#include <wctype.h>
-
-/* Compare MBS1 and MBS2 without regard to case.  */
-int
-mbscasecmp (mbs1, mbs2)
-    const char *mbs1;
-    const char *mbs2;
-{
-  int len1, len2, mb_cur_max;
-  wchar_t c1, c2, l1, l2;
-
-  len1 = len2 = 0;
-  /* Reset multibyte characters to their initial state.	 */
-  (void) mblen ((char *) NULL, 0);
-
-  mb_cur_max = MB_CUR_MAX;
-  do
-    {
-      len1 = mbtowc (&c1, mbs1, mb_cur_max);
-      len2 = mbtowc (&c2, mbs2, mb_cur_max);
-
-      if (len1 == 0)
-	return len2 == 0 ? 0 : -1;
-      else if (len2 == 0)
-	return 1;
-      else if (len1 > 0 && len2 < 0)
-        return -1;
-      else if (len1 < 0 && len2 > 0)
-        return 1;
-      else if (len1 < 0 && len2 < 0)
-	{
-	  len1 = strlen (mbs1);
-	  len2 = strlen (mbs2);
-	  return (len1 == len2 ? memcmp (mbs1, mbs2, len1)
-			       : ((len1 < len2) ? (memcmp (mbs1, mbs2, len1) > 0 ? 1 : -1)
-						: (memcmp (mbs1, mbs2, len2) >= 0 ? 1 : -1)));
-	}
-
-      l1 = towlower (c1);
-      l2 = towlower (c2);
- 
-      mbs1 += len1;
-      mbs2 += len2;
-    }
-  while (l1 == l2);
-
-  return l1 - l2;
-}
-
-#endif
diff --git a/third_party/bash/mbschr.c b/third_party/bash/mbschr.c
deleted file mode 100644
index dced76089..000000000
--- a/third_party/bash/mbschr.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/* mbschr.c - strchr(3) that handles multibyte characters. */
-
-/* Copyright (C) 2002 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#ifdef HAVE_STDLIB_H
-#  include <stdlib.h>
-#endif
-
-#include "bashansi.h"
-#include "shmbutil.h"
-
-extern int locale_mb_cur_max;
-extern int locale_utf8locale;
-
-#undef mbschr
-
-extern char *utf8_mbschr (const char *, int);	/* XXX */
-
-/* In some locales, the non-first byte of some multibyte characters have
-   the same value as some ascii character.  Faced with these strings, a
-   legacy strchr() might return the wrong value. */
-
-char *
-#if defined (PROTOTYPES)
-mbschr (const char *s, int c)
-#else
-mbschr (s, c)
-     const char *s;
-     int c;
-#endif
-{
-#if HANDLE_MULTIBYTE
-  char *pos;
-  mbstate_t state;
-  size_t strlength, mblength;
-
-  if (locale_utf8locale && c < 0x80)
-    return (utf8_mbschr (s, c));		/* XXX */
-
-  /* The locale encodings with said weird property are BIG5, BIG5-HKSCS,
-     GBK, GB18030, SHIFT_JIS, and JOHAB.  They exhibit the problem only
-     when c >= 0x30.  We can therefore use the faster bytewise search if
-     c <= 0x30. */
-  if ((unsigned char)c >= '0' && locale_mb_cur_max > 1)
-    {
-      pos = (char *)s;
-      memset (&state, '\0', sizeof(mbstate_t));
-      strlength = strlen (s);
-
-      while (strlength > 0)
-	{
-	  if (is_basic (*pos))
-	    mblength = 1;
-	  else
-	    {
-	      mblength = mbrlen (pos, strlength, &state);
-	      if (mblength == (size_t)-2 || mblength == (size_t)-1 || mblength == (size_t)0)
-	        mblength = 1;
-	    }
-
-	  if (mblength == 1 && c == (unsigned char)*pos)
-	    return pos;
-
-	  strlength -= mblength;
-	  pos += mblength;
-	}
-
-      return ((char *)NULL);
-    }
-  else
-#endif
-  return (strchr (s, c));
-}
diff --git a/third_party/bash/mbscmp.c b/third_party/bash/mbscmp.c
deleted file mode 100644
index 9be01378a..000000000
--- a/third_party/bash/mbscmp.c
+++ /dev/null
@@ -1,77 +0,0 @@
-/* mbscmp - multibyte string comparison. */
-
-/* Copyright (C) 1995-2018 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if !defined (HAVE_MBSCMP) && defined (HANDLE_MULTIBYTE)
-
-#include <stdlib.h>
-#include <stddef.h>
-#include <string.h>
-
-extern int locale_utf8locale;
-
-extern int utf8_mbscmp (const char *, const char *);
-
-/* Compare MBS1 and MBS2.  */
-int
-mbscmp (mbs1, mbs2)
-    const char *mbs1;
-    const char *mbs2;
-{
-  int len1, len2, mb_cur_max;
-  wchar_t c1, c2;
-
-  len1 = len2 = 0;
-  /* Reset multibyte characters to their initial state.	 */
-  (void) mblen ((char *) NULL, 0);
-
-  mb_cur_max = MB_CUR_MAX;
-  do
-    {
-      len1 = mbtowc (&c1, mbs1, mb_cur_max);
-      len2 = mbtowc (&c2, mbs2, mb_cur_max);
-
-      if (len1 == 0)
-	return len2 == 0 ? 0 : -1;
-      else if (len2 == 0)
-	return 1;
-      else if (len1 > 0 && len2 < 0)
-        return -1;
-      else if (len1 < 0 && len2 > 0)
-        return 1;
-      else if (len1 < 0 && len2 < 0)
-	{
-	  len1 = strlen (mbs1);
-	  len2 = strlen (mbs2);
-	  return (len1 == len2 ? memcmp (mbs1, mbs2, len1)
-			       : ((len1 < len2) ? (memcmp (mbs1, mbs2, len1) > 0 ? 1 : -1)
-						: (memcmp (mbs1, mbs2, len2) >= 0 ? 1 : -1)));
-	}
-
-      mbs1 += len1;
-      mbs2 += len2;
-    }
-  while (c1 == c2);
-
-  return c1 - c2;
-}
-
-#endif
diff --git a/third_party/bash/memalloc.h b/third_party/bash/memalloc.h
deleted file mode 100644
index 57318b9d3..000000000
--- a/third_party/bash/memalloc.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/* memalloc.h -- consolidate code for including alloca.h or malloc.h and
-   defining alloca. */
-
-/* Copyright (C) 1993 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_MEMALLOC_H_)
-#  define _MEMALLOC_H_
-
-#if defined (sparc) && defined (sun) && !defined (HAVE_ALLOCA_H)
-#  define HAVE_ALLOCA_H
-#endif
-
-#if defined (__GNUC__) && !defined (HAVE_ALLOCA)
-#  define HAVE_ALLOCA
-#endif
-
-#if defined (HAVE_ALLOCA_H) && !defined (HAVE_ALLOCA) && !defined (C_ALLOCA)
-#  define HAVE_ALLOCA
-#endif /* HAVE_ALLOCA_H && !HAVE_ALLOCA */
-
-#if defined (__GNUC__) && !defined (C_ALLOCA)
-#  undef alloca
-#  define alloca __builtin_alloca
-#else /* !__GNUC__ || C_ALLOCA */
-#  if defined (HAVE_ALLOCA_H) && !defined (C_ALLOCA)
-#    if defined (IBMESA)
-#      include <malloc.h>
-#    else /* !IBMESA */
-#      include <alloca.h>
-#    endif /* !IBMESA */
-#  else  /* !HAVE_ALLOCA_H || C_ALLOCA */
-#    if defined (__hpux) && defined (__STDC__) && !defined (alloca)
-extern void *alloca ();
-#    else
-#      if !defined (alloca)
-#        if defined (__STDC__)
-extern void *alloca (size_t);
-#        else
-extern char *alloca ();
-#        endif /* !__STDC__ */
-#      endif /* !alloca */
-#    endif /* !__hpux || !__STDC__ && !alloca */
-#  endif /* !HAVE_ALLOCA_H || C_ALLOCA */
-#endif /* !__GNUC__ || C_ALLOCA */
-
-#endif /* _MEMALLOC_H_ */
diff --git a/third_party/bash/ndir.h b/third_party/bash/ndir.h
deleted file mode 100644
index 0aeb3a58c..000000000
--- a/third_party/bash/ndir.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/* <dir.h> -- definitions for 4.2BSD-compatible directory access.
-   last edit:	09-Jul-1983	D A Gwyn. */
-
-/* Size of directory block. */
-#define DIRBLKSIZ 512
-
-/* NOTE:  MAXNAMLEN must be one less than a multiple of 4 */
-
-#if defined (VMS)
-#  define MAXNAMLEN (DIR$S_NAME + 7)	/* 80 plus room for version #.  */
-#  define MAXFULLSPEC NAM$C_MAXRSS	/* Maximum full spec */
-#else
-#  define MAXNAMLEN 15			/* Maximum filename length. */
-#endif /* VMS */
-
-/* Data from readdir (). */
-struct direct {
-  long d_ino;			/* Inode number of entry. */
-  unsigned short d_reclen;	/* Length of this record. */
-  unsigned short d_namlen;	/* Length of string in d_name. */
-  char d_name[MAXNAMLEN + 1];	/* Name of file. */
-};
-
-/* Stream data from opendir (). */
-typedef struct {
-  int dd_fd;			/* File descriptor. */
-  int dd_loc;			/* Offset in block. */
-  int dd_size;			/* Amount of valid data. */
-  char	dd_buf[DIRBLKSIZ];	/* Directory block. */
-} DIR;
-
-extern DIR *opendir ();
-extern struct direct *readdir ();
-extern long telldir ();
-extern void seekdir (), closedir ();
-
-#define rewinddir(dirp) seekdir (dirp, 0L)
diff --git a/third_party/bash/netconn.c b/third_party/bash/netconn.c
deleted file mode 100644
index a5fc381c1..000000000
--- a/third_party/bash/netconn.c
+++ /dev/null
@@ -1,82 +0,0 @@
-/* netconn.c -- is a particular file descriptor a network connection?. */
-
-/* Copyright (C) 2002-2005 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#if ! defined(_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-#include "posixstat.h"
-#include "filecntl.h"
-
-#include <errno.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-/* The second and subsequent conditions must match those used to decide
-   whether or not to call getpeername() in isnetconn(). */
-#if defined (HAVE_SYS_SOCKET_H) && defined (HAVE_GETPEERNAME) && !defined (SVR4_2)
-#  include <sys/socket.h>
-#endif
-
-/* Is FD a socket or network connection? */
-int
-isnetconn (fd)
-     int fd;
-{
-#if defined (HAVE_SYS_SOCKET_H) && defined (HAVE_GETPEERNAME) && !defined (SVR4_2) && !defined (__BEOS__)
-  int rv;
-  socklen_t l;
-  struct sockaddr sa;
-
-  l = sizeof(sa);
-  rv = getpeername(fd, &sa, &l);
-  /* Posix.2 says getpeername can return these errors. */
-  return ((rv < 0 && (errno == ENOTSOCK || errno == ENOTCONN || errno == EINVAL || errno == EBADF)) ? 0 : 1);
-#else /* !HAVE_GETPEERNAME || SVR4_2 || __BEOS__ */
-#  if defined (SVR4) || defined (SVR4_2)
-  /* Sockets on SVR4 and SVR4.2 are character special (streams) devices. */
-  struct stat sb;
-
-  if (isatty (fd))
-    return (0);
-  if (fstat (fd, &sb) < 0)
-    return (0);
-#    if defined (S_ISFIFO)
-  if (S_ISFIFO (sb.st_mode))
-    return (0);
-#    endif /* S_ISFIFO */
-  return (S_ISCHR (sb.st_mode));
-#  else /* !SVR4 && !SVR4_2 */
-#    if defined (S_ISSOCK) && !defined (__BEOS__)
-  struct stat sb;
-
-  if (fstat (fd, &sb) < 0)
-    return (0);
-  return (S_ISSOCK (sb.st_mode));
-#    else /* !S_ISSOCK || __BEOS__ */
-  return (0);
-#    endif /* !S_ISSOCK || __BEOS__ */
-#  endif /* !SVR4 && !SVR4_2 */
-#endif /* !HAVE_GETPEERNAME || SVR4_2 || __BEOS__ */
-}
diff --git a/third_party/bash/netopen.c b/third_party/bash/netopen.c
deleted file mode 100644
index a2fd760d4..000000000
--- a/third_party/bash/netopen.c
+++ /dev/null
@@ -1,351 +0,0 @@
-/*   
- * netopen.c -- functions to make tcp/udp connections
- *
- * Chet Ramey
- * chet@ins.CWRU.Edu
- */
-
-/* Copyright (C) 1987-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_NETWORK)
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <stdio.h> 
-#include <sys/types.h>
-
-#if defined (HAVE_SYS_SOCKET_H)
-#  include <sys/socket.h>
-#endif
-
-#if defined (HAVE_NETINET_IN_H)
-#  include <netinet/in.h>
-#endif
-
-#if defined (HAVE_NETDB_H)
-#  include <netdb.h>
-#endif
-
-#if defined (HAVE_ARPA_INET_H)
-#  include <arpa/inet.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include <errno.h>
-
-#include "shell.h"
-#include "xmalloc.h"
-
-#ifndef errno
-extern int errno;
-#endif
-
-#if !defined (HAVE_INET_ATON)
-extern int inet_aton PARAMS((const char *, struct in_addr *));
-#endif
-
-#ifndef HAVE_GETADDRINFO
-static int _getaddr PARAMS((char *, struct in_addr *));
-static int _getserv PARAMS((char *, int, unsigned short *));
-static int _netopen4 PARAMS((char *, char *, int));
-#else /* HAVE_GETADDRINFO */
-static int _netopen6 PARAMS((char *, char *, int));
-#endif
-
-static int _netopen PARAMS((char *, char *, int));
-
-#ifndef HAVE_GETADDRINFO
-/* Stuff the internet address corresponding to HOST into AP, in network
-   byte order.  Return 1 on success, 0 on failure. */
-
-static int
-_getaddr (host, ap)
-     char *host;
-     struct in_addr *ap;
-{
-  struct hostent *h;
-  int r;
-
-  r = 0;
-  if (host[0] >= '0' && host[0] <= '9')
-    {
-      /* If the first character is a digit, guess that it's an
-	 Internet address and return immediately if inet_aton succeeds. */
-      r = inet_aton (host, ap);
-      if (r)
-	return r;
-    }
-#if !defined (HAVE_GETHOSTBYNAME)
-  return 0;
-#else
-  h = gethostbyname (host);
-  if (h && h->h_addr)
-    {
-      bcopy(h->h_addr, (char *)ap, h->h_length);
-      return 1;
-    }
-#endif
-  return 0;
-  
-}
-
-/* Return 1 if SERV is a valid port number and stuff the converted value into
-   PP in network byte order. */   
-static int
-_getserv (serv, proto, pp)
-     char *serv;
-     int proto;
-     unsigned short *pp;
-{
-  intmax_t l;
-  unsigned short s;
-
-  if (legal_number (serv, &l))
-    {
-      s = (unsigned short)(l & 0xFFFF);
-      if (s != l)
-	return (0);
-      s = htons (s);
-      if (pp)
-	*pp = s;
-      return 1;
-    }
-  else
-#if defined (HAVE_GETSERVBYNAME)
-    {
-      struct servent *se;
-
-      se = getservbyname (serv, (proto == 't') ? "tcp" : "udp");
-      if (se == 0)
-	return 0;
-      if (pp)
-	*pp = se->s_port;	/* ports returned in network byte order */
-      return 1;
-    }
-#else /* !HAVE_GETSERVBYNAME */
-    return 0;
-#endif /* !HAVE_GETSERVBYNAME */
-}
-
-/*
- * Open a TCP or UDP connection to HOST on port SERV.  Uses the
- * traditional BSD mechanisms.  Returns the connected socket or -1 on error.
- */
-static int 
-_netopen4(host, serv, typ)
-     char *host, *serv;
-     int typ;
-{
-  struct in_addr ina;
-  struct sockaddr_in sin;
-  unsigned short p;
-  int s, e;
-
-  if (_getaddr(host, &ina) == 0)
-    {
-      internal_error (_("%s: host unknown"), host);
-      errno = EINVAL;
-      return -1;
-    }
-
-  if (_getserv(serv, typ, &p) == 0)
-    {
-      internal_error(_("%s: invalid service"), serv);
-      errno = EINVAL;
-      return -1;
-    }
-	
-  memset ((char *)&sin, 0, sizeof(sin));
-  sin.sin_family = AF_INET;
-  sin.sin_port = p;
-  sin.sin_addr = ina;
-
-  s = socket(AF_INET, (typ == 't') ? SOCK_STREAM : SOCK_DGRAM, 0);
-  if (s < 0)
-    {
-      sys_error ("socket");
-      return (-1);
-    }
-
-  if (connect (s, (struct sockaddr *)&sin, sizeof (sin)) < 0)
-    {
-      e = errno;
-      sys_error("connect");
-      close(s);
-      errno = e;
-      return (-1);
-    }
-
-  return(s);
-}
-#endif /* ! HAVE_GETADDRINFO */
-
-#ifdef HAVE_GETADDRINFO
-/*
- * Open a TCP or UDP connection to HOST on port SERV.  Uses getaddrinfo(3)
- * which provides support for IPv6.  Returns the connected socket or -1
- * on error.
- */
-static int
-_netopen6 (host, serv, typ)
-     char *host, *serv;
-     int typ;
-{
-  int s, e;
-  struct addrinfo hints, *res, *res0;
-  int gerr;
-
-  memset ((char *)&hints, 0, sizeof (hints));
-  /* XXX -- if problems with IPv6, set to PF_INET for IPv4 only */
-#ifdef DEBUG	/* PF_INET is the one that works for me */
-  hints.ai_family = PF_INET;
-#else
-  hints.ai_family = PF_UNSPEC;
-#endif
-  hints.ai_socktype = (typ == 't') ? SOCK_STREAM : SOCK_DGRAM;
-
-  gerr = getaddrinfo (host, serv, &hints, &res0);
-  if (gerr)
-    {
-      if (gerr == EAI_SERVICE)
-	internal_error ("%s: %s", serv, gai_strerror (gerr));
-      else
-	internal_error ("%s: %s", host, gai_strerror (gerr));
-      errno = EINVAL;
-      return -1;
-    }
-
-  for (res = res0; res; res = res->ai_next)
-    {
-      if ((s = socket (res->ai_family, res->ai_socktype, res->ai_protocol)) < 0)
-	{
-	  if (res->ai_next)
-	    continue;
-	  sys_error ("socket");
-	  freeaddrinfo (res0);
-	  return -1;
-	}
-      if (connect (s, res->ai_addr, res->ai_addrlen) < 0)
-	{
-	  if (res->ai_next)
-	    {
-	      close (s);
-	      continue;
-	    }
-	  e = errno;
-	  sys_error ("connect");
-	  close (s);
-	  freeaddrinfo (res0);
-	  errno = e;
-	  return -1;
-	}
-      freeaddrinfo (res0);
-      break;
-    }
-  return s;
-}
-#endif /* HAVE_GETADDRINFO */
-
-/*
- * Open a TCP or UDP connection to HOST on port SERV.  Uses getaddrinfo(3)
- * if available, falling back to the traditional BSD mechanisms otherwise.
- * Returns the connected socket or -1 on error.
- */
-static int 
-_netopen(host, serv, typ)
-     char *host, *serv;
-     int typ;
-{
-#ifdef HAVE_GETADDRINFO
-  return (_netopen6 (host, serv, typ));
-#else
-  return (_netopen4 (host, serv, typ));
-#endif
-}
-
-/*
- * Open a TCP or UDP connection given a path like `/dev/tcp/host/port' to
- * host `host' on port `port' and return the connected socket.
- */
-int
-netopen (path)
-     char *path;
-{
-  char *np, *s, *t;
-  int fd;
-
-  np = (char *)xmalloc (strlen (path) + 1);
-  strcpy (np, path);
-
-  s = np + 9;
-  t = strchr (s, '/');
-  if (t == 0)
-    {
-      internal_error (_("%s: bad network path specification"), path);
-      free (np);
-      return -1;
-    }
-  *t++ = '\0';
-  fd = _netopen (s, t, path[5]);
-  free (np);
-
-  return fd;
-}
-
-#if 0
-/*
- * Open a TCP connection to host `host' on the port defined for service
- * `serv' and return the connected socket.
- */
-int
-tcpopen (host, serv)
-     char *host, *serv;
-{
-  return (_netopen (host, serv, 't'));
-}
-
-/*
- * Open a UDP connection to host `host' on the port defined for service
- * `serv' and return the connected socket.
- */
-int
-udpopen (host, serv)
-     char *host, *serv;
-{
-  return _netopen (host, serv, 'u');
-}
-#endif
-
-#else /* !HAVE_NETWORK */
-
-int
-netopen (path)
-     char *path;
-{
-  internal_error (_("network operations not supported"));
-  return -1;
-}
-
-#endif /* !HAVE_NETWORK */
diff --git a/third_party/bash/ocache.h b/third_party/bash/ocache.h
deleted file mode 100644
index c596c2725..000000000
--- a/third_party/bash/ocache.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/* ocache.h -- a minimal object caching implementation. */
-
-/* Copyright (C) 2002 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_OCACHE_H_)
-#define	_OCACHE_H_ 1
-
-#ifndef PTR_T
-
-#if defined (__STDC__)
-#  define PTR_T void *
-#else
-#  define PTR_T char *
-#endif
-
-#endif /* PTR_T */
-
-#define OC_MEMSET(memp, xch, nbytes)					\
-do {									\
-  if ((nbytes) <= 32) {							\
-    register char * mzp = (char *)(memp);				\
-    unsigned long mctmp = (nbytes);					\
-    register long mcn;							\
-    if (mctmp < 8) mcn = 0; else { mcn = (mctmp-1)/8; mctmp &= 7; }	\
-    switch (mctmp) {							\
-      case 0: for(;;) { *mzp++ = xch;					\
-      case 7:	   *mzp++ = xch;					\
-      case 6:	   *mzp++ = xch;					\
-      case 5:	   *mzp++ = xch;					\
-      case 4:	   *mzp++ = xch;					\
-      case 3:	   *mzp++ = xch;					\
-      case 2:	   *mzp++ = xch;					\
-      case 1:	   *mzp++ = xch; if(mcn <= 0) break; mcn--; }		\
-    }									\
-  } else								\
-    memset ((memp), (xch), (nbytes));					\
-} while(0)
-
-typedef struct objcache {
-	PTR_T	data;
-	int	cs;		/* cache size, number of objects */
-	int	nc;		/* number of cache entries */
-} sh_obj_cache_t;
-
-/* Create an object cache C of N pointers to OTYPE. */
-#define ocache_create(c, otype, n) \
-	do { \
-		(c).data = xmalloc((n) * sizeof (otype *)); \
-		(c).cs = (n); \
-		(c).nc = 0; \
-	} while (0)
-
-/* Destroy an object cache C. */
-#define ocache_destroy(c) \
-	do { \
-		if ((c).data) \
-			xfree ((c).data); \
-		(c).data = 0; \
-		(c).cs = (c).nc = 0; \
-	} while (0)
-
-/* Free all cached items, which are pointers to OTYPE, in object cache C. */
-#define ocache_flush(c, otype) \
-	do { \
-		while ((c).nc > 0) \
-			xfree (((otype **)((c).data))[--(c).nc]); \
-	} while (0)
-
-/*
- * Allocate a new item of type pointer to OTYPE, using data from object
- * cache C if any cached items exist, otherwise calling xmalloc.  Return
- * the object in R.
- */
-#define ocache_alloc(c, otype, r) \
-	do { \
-		if ((c).nc > 0) { \
-			(r) = (otype *)((otype **)((c).data))[--(c).nc]; \
-		} else \
-			(r) = (otype *)xmalloc (sizeof (otype)); \
-	} while (0)
-
-/*
- * Free an item R of type pointer to OTYPE, adding to object cache C if
- * there is room and calling xfree if the cache is full.  If R is added
- * to the object cache, the contents are scrambled.
- */
-#define ocache_free(c, otype, r) \
-	do { \
-		if ((c).nc < (c).cs) { \
-			OC_MEMSET ((r), 0xdf, sizeof(otype)); \
-			((otype **)((c).data))[(c).nc++] = (r); \
-		} else \
-			xfree (r); \
-	} while (0)
-
-/*
- * One may declare and use an object cache as (for instance):
- *
- *	sh_obj_cache_t wdcache = {0, 0, 0};
- *	sh_obj_cache_t wlcache = {0, 0, 0};
- *
- *	ocache_create(wdcache, WORD_DESC, 30);
- *	ocache_create(wlcache, WORD_LIST, 30);
- *
- *	WORD_DESC *wd;
- *	ocache_alloc (wdcache, WORD_DESC, wd);
- *
- *	WORD_LIST *wl;
- *	ocache_alloc (wlcache, WORD_LIST, wl);
- *
- *	ocache_free(wdcache, WORD_DESC, wd);
- *	ocache_free(wlcache, WORD_LIST, wl);
- *
- * The use is almost arbitrary.
- */
-
-#endif /* _OCACHE_H  */
diff --git a/third_party/bash/oslib.c b/third_party/bash/oslib.c
deleted file mode 100644
index ab284cb5f..000000000
--- a/third_party/bash/oslib.c
+++ /dev/null
@@ -1,159 +0,0 @@
-/* oslib.c - functions present only in some unix versions. */
-
-/* Copyright (C) 1995,2010 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#if defined (HAVE_LIMITS_H)
-#  include <limits.h>
-#endif
-
-#include "posixstat.h"
-#include "filecntl.h"
-#include "bashansi.h"
-
-#if !defined (HAVE_KILLPG)
-#  include <signal.h>
-#endif
-
-#include <stdio.h>
-#include <errno.h>
-#include "chartypes.h"
-
-#include "shell.h"
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-/*
- * Return the total number of available file descriptors.
- *
- * On some systems, like 4.2BSD and its descendants, there is a system call
- * that returns the size of the descriptor table: getdtablesize().  There are
- * lots of ways to emulate this on non-BSD systems.
- *
- * On System V.3, this can be obtained via a call to ulimit:
- *	return (ulimit(4, 0L));
- *
- * On other System V systems, NOFILE is defined in /usr/include/sys/param.h
- * (this is what we assume below), so we can simply use it:
- *	return (NOFILE);
- *
- * On POSIX systems, there are specific functions for retrieving various
- * configuration parameters:
- *	return (sysconf(_SC_OPEN_MAX));
- *
- */
-
-#if !defined (HAVE_GETDTABLESIZE)
-int
-getdtablesize ()
-{
-#  if defined (_POSIX_VERSION) && defined (HAVE_SYSCONF) && defined (_SC_OPEN_MAX)
-  return (sysconf(_SC_OPEN_MAX));	/* Posix systems use sysconf */
-#  else /* ! (_POSIX_VERSION && HAVE_SYSCONF && _SC_OPEN_MAX) */
-#    if defined (ULIMIT_MAXFDS)
-  return (ulimit (4, 0L));	/* System V.3 systems use ulimit(4, 0L) */
-#    else /* !ULIMIT_MAXFDS */
-#      if defined (NOFILE)	/* Other systems use NOFILE */
-  return (NOFILE);
-#      else /* !NOFILE */
-  return (20);			/* XXX - traditional value is 20 */
-#      endif /* !NOFILE */
-#    endif /* !ULIMIT_MAXFDS */
-#  endif /* ! (_POSIX_VERSION && _SC_OPEN_MAX) */
-}
-#endif /* !HAVE_GETDTABLESIZE */
-
-#if !defined (HAVE_MKFIFO) && defined (PROCESS_SUBSTITUTION)
-int
-mkfifo (path, mode)
-     char *path;
-     mode_t mode;
-{
-#if 0 && defined (S_IFIFO)  // [jart] cosmo local change
-  return (mknod (path, (mode | S_IFIFO), 0));
-#else /* !S_IFIFO */
-  return (-1);
-#endif /* !S_IFIFO */
-}
-#endif /* !HAVE_MKFIFO && PROCESS_SUBSTITUTION */
-
-#define DEFAULT_MAXGROUPS 64
-
-int
-getmaxgroups ()
-{
-  static int maxgroups = -1;
-
-  if (maxgroups > 0)
-    return maxgroups;
-
-#if defined (HAVE_SYSCONF) && defined (_SC_NGROUPS_MAX)
-  maxgroups = sysconf (_SC_NGROUPS_MAX);
-#else
-#  if defined (NGROUPS_MAX)
-  maxgroups = NGROUPS_MAX;
-#  else /* !NGROUPS_MAX */
-#    if defined (NGROUPS)
-  maxgroups = NGROUPS;
-#    else /* !NGROUPS */
-  maxgroups = DEFAULT_MAXGROUPS;
-#    endif /* !NGROUPS */
-#  endif /* !NGROUPS_MAX */  
-#endif /* !HAVE_SYSCONF || !SC_NGROUPS_MAX */
-
-  if (maxgroups <= 0)
-    maxgroups = DEFAULT_MAXGROUPS;
-
-  return maxgroups;
-}
-
-long
-getmaxchild ()
-{
-  static long maxchild = -1L;
-
-  if (maxchild > 0)
-    return maxchild;
-
-#if defined (HAVE_SYSCONF) && defined (_SC_CHILD_MAX)
-  maxchild = sysconf (_SC_CHILD_MAX);
-#else
-#  if defined (CHILD_MAX)
-  maxchild = CHILD_MAX;
-#  else
-#    if defined (MAXUPRC)
-  maxchild = MAXUPRC;
-#    endif /* MAXUPRC */
-#  endif /* CHILD_MAX */
-#endif /* !HAVE_SYSCONF || !_SC_CHILD_MAX */
-
-  return (maxchild);
-}
diff --git a/third_party/bash/parser.h b/third_party/bash/parser.h
deleted file mode 100644
index 59bf0fec4..000000000
--- a/third_party/bash/parser.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/* parser.h -- Everything you wanted to know about the parser, but were
-   afraid to ask. */
-
-/* Copyright (C) 1995-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_PARSER_H_)
-#  define _PARSER_H_
-
-#  include "command.h"
-#  include "input.h"
-
-/* Possible states for the parser that require it to do special things. */
-#define PST_CASEPAT	0x000001	/* in a case pattern list */
-#define PST_ALEXPNEXT	0x000002	/* expand next word for aliases */
-#define PST_ALLOWOPNBRC	0x000004	/* allow open brace for function def */
-#define PST_NEEDCLOSBRC	0x000008	/* need close brace */
-#define PST_DBLPAREN	0x000010	/* double-paren parsing - unused */
-#define PST_SUBSHELL	0x000020	/* ( ... ) subshell */
-#define PST_CMDSUBST	0x000040	/* $( ... ) command substitution */
-#define PST_CASESTMT	0x000080	/* parsing a case statement */
-#define PST_CONDCMD	0x000100	/* parsing a [[...]] command */
-#define PST_CONDEXPR	0x000200	/* parsing the guts of [[...]] */
-#define PST_ARITHFOR	0x000400	/* parsing an arithmetic for command - unused */
-#define PST_ALEXPAND	0x000800	/* OK to expand aliases - unused */
-#define PST_EXTPAT	0x001000	/* parsing an extended shell pattern */
-#define PST_COMPASSIGN	0x002000	/* parsing x=(...) compound assignment */
-#define PST_ASSIGNOK	0x004000	/* assignment statement ok in this context */
-#define PST_EOFTOKEN	0x008000	/* yylex checks against shell_eof_token */
-#define PST_REGEXP	0x010000	/* parsing an ERE/BRE as a single word */
-#define PST_HEREDOC	0x020000	/* reading body of here-document */
-#define PST_REPARSE	0x040000	/* re-parsing in parse_string_to_word_list */
-#define PST_REDIRLIST	0x080000	/* parsing a list of redirections preceding a simple command name */
-#define PST_COMMENT	0x100000	/* parsing a shell comment; used by aliases */
-#define PST_ENDALIAS	0x200000	/* just finished expanding and consuming an alias */
-#define PST_NOEXPAND	0x400000	/* don't expand anything in read_token_word; for command substitution */
-#define PST_NOERROR	0x800000	/* don't print error messages in yyerror */
-
-/* Definition of the delimiter stack.  Needed by parse.y and bashhist.c. */
-struct dstack {
-/* DELIMITERS is a stack of the nested delimiters that we have
-   encountered so far. */
-  char *delimiters;
-
-/* Offset into the stack of delimiters. */
-  int delimiter_depth;
-
-/* How many slots are allocated to DELIMITERS. */
-  int delimiter_space;
-};
-
-/* States we can be in while scanning a ${...} expansion.  Shared between
-   parse.y and subst.c */
-#define DOLBRACE_PARAM	0x01
-#define DOLBRACE_OP	0x02
-#define DOLBRACE_WORD	0x04
-
-#define DOLBRACE_QUOTE	0x40	/* single quote is special in double quotes */
-#define DOLBRACE_QUOTE2	0x80	/* single quote is semi-special in double quotes */
-
-/* variable declarations from parse.y */
-extern struct dstack dstack;
-
-extern char *primary_prompt;
-extern char *secondary_prompt;
-
-extern char *current_prompt_string;
-
-extern char *ps1_prompt;
-extern char *ps2_prompt;
-extern char *ps0_prompt;
-
-extern int expand_aliases;
-extern int current_command_line_count;
-extern int saved_command_line_count;
-extern int shell_eof_token;
-extern int current_token;
-extern int parser_state;
-extern int need_here_doc;
-
-extern int ignoreeof;
-extern int eof_encountered;
-extern int eof_encountered_limit;
-
-extern int line_number, line_number_base;
-
-#endif /* _PARSER_H_ */
diff --git a/third_party/bash/patchlevel.h b/third_party/bash/patchlevel.h
deleted file mode 100644
index 165390c15..000000000
--- a/third_party/bash/patchlevel.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/* patchlevel.h -- current bash patch level */
-
-/* Copyright (C) 2001-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_PATCHLEVEL_H_)
-#define _PATCHLEVEL_H_
-
-/* It's important that there be no other strings in this file that match the
-   regexp `^#define[ 	]*PATCHLEVEL', since that's what support/mkversion.sh
-   looks for to find the patch level (for the sccs version string). */
-
-#define PATCHLEVEL 0
-
-#endif /* _PATCHLEVEL_H_ */
diff --git a/third_party/bash/pathcanon.c b/third_party/bash/pathcanon.c
deleted file mode 100644
index 41abbd26c..000000000
--- a/third_party/bash/pathcanon.c
+++ /dev/null
@@ -1,234 +0,0 @@
-/* pathcanon.c -- canonicalize and manipulate pathnames. */
-
-/* Copyright (C) 2000 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "filecntl.h"
-#include "bashansi.h"
-#include <stdio.h>
-#include "chartypes.h"
-#include <errno.h>
-
-#include "shell.h"
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#if defined (__CYGWIN__)
-#include <sys/cygwin.h>
-
-static int
-_is_cygdrive (path)
-     char *path;
-{
-  static char user[MAXPATHLEN];
-  static char system[MAXPATHLEN];
-  static int first_time = 1;
-
-  /* If the path is the first part of a network path, treat it as
-     existing. */
-  if (path[0] == '/' && path[1] == '/' && !strchr (path + 2, '/'))
-    return 1; 
-  /* Otherwise check for /cygdrive prefix. */
-  if (first_time)
-    {
-      char user_flags[MAXPATHLEN];
-      char system_flags[MAXPATHLEN];
-      /* Get the cygdrive info */
-      cygwin_internal (CW_GET_CYGDRIVE_INFO, user, system, user_flags, system_flags);
-      first_time = 0;
-    }
-  return !strcasecmp (path, user) || !strcasecmp (path, system);
-}
-#endif /* __CYGWIN__ */	
-
-/* Return 1 if PATH corresponds to a directory.  A function for debugging. */
-static int
-_path_isdir (path)
-     char *path;
-{
-  int l;
-  struct stat sb;
-
-  /* This should leave errno set to the correct value. */
-  errno = 0;
-  l = stat (path, &sb) == 0 && S_ISDIR (sb.st_mode);
-#if defined (__CYGWIN__)
-  if (l == 0)
-    l = _is_cygdrive (path);
-#endif
-  return l;
-}
-
-/* Canonicalize PATH, and return a new path.  The new path differs from PATH
-   in that:
-	Multiple `/'s are collapsed to a single `/'.
-	Leading `./'s and trailing `/.'s are removed.
-	Trailing `/'s are removed.
-	Non-leading `../'s and trailing `..'s are handled by removing
-	portions of the path. */
-
-/* Look for ROOTEDPATH, PATHSEP, DIRSEP, and ISDIRSEP in ../../general.h */
-
-#define DOUBLE_SLASH(p)	((p[0] == '/') && (p[1] == '/') && p[2] != '/')
-
-char *
-sh_canonpath (path, flags)
-     char *path;
-     int flags;
-{
-  char stub_char;
-  char *result, *p, *q, *base, *dotdot;
-  int rooted, double_slash_path;
-
-  /* The result cannot be larger than the input PATH. */
-  result = (flags & PATH_NOALLOC) ? path : savestring (path);
-
-  /* POSIX.2 says to leave a leading `//' alone.  On cygwin, we skip over any
-     leading `x:' (dos drive name). */
-  if (rooted = ROOTEDPATH(path))
-    {
-      stub_char = DIRSEP;
-#if defined (__CYGWIN__)
-      base = (ISALPHA((unsigned char)result[0]) && result[1] == ':') ? result + 3 : result + 1;
-#else
-      base = result + 1;
-#endif
-      double_slash_path = DOUBLE_SLASH (path);
-      base += double_slash_path;
-    }
-  else
-    {
-      stub_char = '.';
-#if defined (__CYGWIN__)
-      base = (ISALPHA((unsigned char)result[0]) && result[1] == ':') ? result + 2 : result;
-#else
-      base = result;
-#endif
-      double_slash_path = 0;
-    }
-
-  /*
-   * invariants:
-   *	  base points to the portion of the path we want to modify
-   *      p points at beginning of path element we're considering.
-   *      q points just past the last path element we wrote (no slash).
-   *      dotdot points just past the point where .. cannot backtrack
-   *	  any further (no slash).
-   */
-  p = q = dotdot = base;
-
-  while (*p)
-    {
-      if (ISDIRSEP(p[0])) /* null element */
-	p++;
-      else if(p[0] == '.' && PATHSEP(p[1]))	/* . and ./ */
-	p += 1; 	/* don't count the separator in case it is nul */
-      else if (p[0] == '.' && p[1] == '.' && PATHSEP(p[2])) /* .. and ../ */
-	{
-	  p += 2; /* skip `..' */
-	  if (q > dotdot)	/* can backtrack */
-	    {
-	      if (flags & PATH_CHECKDOTDOT)
-		{
-		  char c;
-
-		  /* Make sure what we have so far corresponds to a valid
-		     path before we chop some of it off. */
-		  c = *q;
-		  *q = '\0';
-		  if (_path_isdir (result) == 0)
-		    {
-		      if ((flags & PATH_NOALLOC) == 0)
-			free (result);
-		      return ((char *)NULL);
-		    }
-		  *q = c;
-		}
-
-	      while (--q > dotdot && ISDIRSEP(*q) == 0)
-		;
-	    }
-	  else if (rooted == 0)
-	    {
-	      /* /.. is / but ./../ is .. */
-	      if (q != base)
-		*q++ = DIRSEP;
-	      *q++ = '.';
-	      *q++ = '.';
-	      dotdot = q;
-	    }
-	}
-      else	/* real path element */
-	{
-	  /* add separator if not at start of work portion of result */
-	  if (q != base)
-	    *q++ = DIRSEP;
-	  while (*p && (ISDIRSEP(*p) == 0))
-	    *q++ = *p++;
-	  /* Check here for a valid directory with _path_isdir. */
-	  if (flags & PATH_CHECKEXISTS)
-	    {
-	      char c;
-
-	      /* Make sure what we have so far corresponds to a valid
-		 path before we chop some of it off. */
-	      c = *q;
-	      *q = '\0';
-	      if (_path_isdir (result) == 0)
-		{
-		  if ((flags & PATH_NOALLOC) == 0)
-		    free (result);
-		  return ((char *)NULL);
-		}
-	      *q = c;
-	    }
-	}
-    }
-
-  /* Empty string is really ``.'' or `/', depending on what we started with. */
-  if (q == result)
-    *q++ = stub_char;
-  *q = '\0';
-
-  /* If the result starts with `//', but the original path does not, we
-     can turn the // into /.  Because of how we set `base', this should never
-     be true, but it's a sanity check. */
-  if (DOUBLE_SLASH(result) && double_slash_path == 0)
-    {
-      if (result[2] == '\0')	/* short-circuit for bare `//' */
-	result[1] = '\0';
-      else
-	memmove (result, result + 1, strlen (result + 1) + 1);
-    }
-
-  return (result);
-}
diff --git a/third_party/bash/pathexp.c b/third_party/bash/pathexp.c
deleted file mode 100644
index 9ba07d974..000000000
--- a/third_party/bash/pathexp.c
+++ /dev/null
@@ -1,637 +0,0 @@
-/* pathexp.c -- The shell interface to the globbing library. */
-
-/* Copyright (C) 1995-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include <stdio.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-
-#include "shell.h"
-#include "pathexp.h"
-#include "flags.h"
-
-#include "shmbutil.h"
-#include "bashintl.h"
-
-#include "strmatch.h"
-
-static int glob_name_is_acceptable PARAMS((const char *));
-static void ignore_globbed_names PARAMS((char **, sh_ignore_func_t *));
-static char *split_ignorespec PARAMS((char *, int *));
-	       
-#include "glob.h"
-
-/* Control whether * matches .files in globbing. */
-int glob_dot_filenames;
-
-/* Control whether the extended globbing features are enabled. */
-int extended_glob = EXTGLOB_DEFAULT;
-
-/* Control enabling special handling of `**' */
-int glob_star = 0;
-
-/* Return nonzero if STRING has any unquoted special globbing chars in it.
-   This is supposed to be called when pathname expansion is performed, so
-   it implements the rules in Posix 2.13.3, specifically that an unquoted
-   slash cannot appear in a bracket expression. */
-int
-unquoted_glob_pattern_p (string)
-     register char *string;
-{
-  register int c;
-  char *send;
-  int open, bsquote;
-
-  DECLARE_MBSTATE;
-
-  open = bsquote = 0;
-  send = string + strlen (string);
-
-  while (c = *string++)
-    {
-      switch (c)
-	{
-	case '?':
-	case '*':
-	  return (1);
-
-	case '[':
-	  open++;
-	  continue;
-
-	case ']':
-	  if (open)		/* XXX - if --open == 0? */
-	    return (1);
-	  continue;
-
-	case '/':
-	  if (open)
-	    open = 0;
-
-	case '+':
-	case '@':
-	case '!':
-	  if (*string == '(')	/*)*/
-	    return (1);
-	  continue;
-
-	/* A pattern can't end with a backslash, but a backslash in the pattern
-	   can be special to the matching engine, so we note it in case we
-	   need it later. */
-	case '\\':
-	  if (*string != '\0' && *string != '/')
-	    {
-	      bsquote = 1;
-	      string++;
-	      continue;
-	    }
-	  else if (open && *string == '/')
-	    {
-	      string++;		/* quoted slashes in bracket expressions are ok */
-	      continue;
-	    }
-	  else if (*string == 0)
-	    return (0);
-	 	  
-	case CTLESC:
-	  if (*string++ == '\0')
-	    return (0);
-	}
-
-      /* Advance one fewer byte than an entire multibyte character to
-	 account for the auto-increment in the loop above. */
-#ifdef HANDLE_MULTIBYTE
-      string--;
-      ADVANCE_CHAR_P (string, send - string);
-      string++;
-#else
-      ADVANCE_CHAR_P (string, send - string);
-#endif
-    }
-
-#if 0
-  return (bsquote ? 2 : 0);
-#else
-  return (0);
-#endif
-}
-
-/* Return 1 if C is a character that is `special' in a POSIX ERE and needs to
-   be quoted to match itself. */
-static inline int
-ere_char (c)
-     int c;
-{
-  switch (c)
-    {
-    case '.':
-    case '[':
-    case '\\':
-    case '(':
-    case ')':
-    case '*':
-    case '+':
-    case '?':
-    case '{':
-    case '|':
-    case '^':
-    case '$':
-      return 1;
-    default: 
-      return 0;
-    }
-  return (0);
-}
-
-/* This is only used to determine whether to backslash-quote a character. */
-int
-glob_char_p (s)
-     const char *s;
-{
-  switch (*s)
-    {
-    case '*':
-    case '[':
-    case ']':
-    case '?':
-    case '\\':
-      return 1;
-    case '+':
-    case '@':
-    case '!':
-      if (s[1] == '(')	/*(*/
-	return 1;
-      break;
-    }
-  return 0;
-}
-
-/* PATHNAME can contain characters prefixed by CTLESC; this indicates
-   that the character is to be quoted.  We quote it here in the style
-   that the glob library recognizes.  If flags includes QGLOB_CVTNULL,
-   we change quoted null strings (pathname[0] == CTLNUL) into empty
-   strings (pathname[0] == 0).  If this is called after quote removal
-   is performed, (flags & QGLOB_CVTNULL) should be 0; if called when quote
-   removal has not been done (for example, before attempting to match a
-   pattern while executing a case statement), flags should include
-   QGLOB_CVTNULL.  If flags includes QGLOB_CTLESC, we need to remove CTLESC
-   quoting CTLESC or CTLNUL (as if dequote_string were called).  If flags
-   includes QGLOB_FILENAME, appropriate quoting to match a filename should be
-   performed.  QGLOB_REGEXP means we're quoting for a Posix ERE (for
-   [[ string =~ pat ]]) and that requires some special handling. */
-char *
-quote_string_for_globbing (pathname, qflags)
-     const char *pathname;
-     int qflags;
-{
-  char *temp;
-  register int i, j;
-  int cclass, collsym, equiv, c, last_was_backslash;
-  int savei, savej;
-
-  temp = (char *)xmalloc (2 * strlen (pathname) + 1);
-
-  if ((qflags & QGLOB_CVTNULL) && QUOTED_NULL (pathname))
-    {
-      temp[0] = '\0';
-      return temp;
-    }
-
-  cclass = collsym = equiv = last_was_backslash = 0;
-  for (i = j = 0; pathname[i]; i++)
-    {
-      /* Fix for CTLESC at the end of the string? */
-      if (pathname[i] == CTLESC && pathname[i+1] == '\0')
-	{
-	  temp[j++] = pathname[i++];
-	  break;
-	}
-      /* If we are parsing regexp, turn CTLESC CTLESC into CTLESC. It's not an
-	 ERE special character, so we should just be able to pass it through. */
-      else if ((qflags & (QGLOB_REGEXP|QGLOB_CTLESC)) && pathname[i] == CTLESC && (pathname[i+1] == CTLESC || pathname[i+1] == CTLNUL))
-	{
-	  i++;
-	  temp[j++] = pathname[i];
-	  continue;
-	}
-      else if (pathname[i] == CTLESC)
-	{
-convert_to_backslash:
-	  if ((qflags & QGLOB_FILENAME) && pathname[i+1] == '/')
-	    continue;
-	  /* What to do if preceding char is backslash? */
-	  if (pathname[i+1] != CTLESC && (qflags & QGLOB_REGEXP) && ere_char (pathname[i+1]) == 0)
-	    continue;
-	  temp[j++] = '\\';
-	  i++;
-	  if (pathname[i] == '\0')
-	    break;
-	}
-      else if ((qflags & QGLOB_REGEXP) && (i == 0 || pathname[i-1] != CTLESC) && pathname[i] == '[')	/*]*/
-	{
-	  temp[j++] = pathname[i++];	/* open bracket */
-	  savej = j;
-	  savei = i;
-	  c = pathname[i++];	/* c == char after open bracket */
-	  if (c == '^')		/* ignore pattern negation */
-	    {
-	      temp[j++] = c;
-	      c = pathname[i++];
-	    }
-	  if (c == ']')		/* ignore right bracket if first char */
-	    {
-	      temp[j++] = c;
-	      c = pathname[i++];
-	    }
-	  do
-	    {
-	      if (c == 0)
-		goto endpat;
-	      else if (c == CTLESC)
-		{
-		  /* skip c, check for EOS, let assignment at end of loop */
-		  /* pathname[i] == backslash-escaped character */
-		  if (pathname[i] == 0)
-		    goto endpat;
-		  temp[j++] = pathname[i++];
-		}
-	      else if (c == '[' && pathname[i] == ':')
-		{
-		  temp[j++] = c;
-		  temp[j++] = pathname[i++];
-		  cclass = 1;
-		}
-	      else if (cclass && c == ':' && pathname[i] == ']')
-		{
-		  temp[j++] = c;
-		  temp[j++] = pathname[i++];
-		  cclass = 0;
-		}
-	      else if (c == '[' && pathname[i] == '=')
-		{
-		  temp[j++] = c;
-		  temp[j++] = pathname[i++];
-		  if (pathname[i] == ']')
-		    temp[j++] = pathname[i++];		/* right brack can be in equiv */
-		  equiv = 1;
-		}
-	      else if (equiv && c == '=' && pathname[i] == ']')
-		{
-		  temp[j++] = c;
-		  temp[j++] = pathname[i++];
-		  equiv = 0;
-		}
-	      else if (c == '[' && pathname[i] == '.')
-		{
-		  temp[j++] = c;
-		  temp[j++] = pathname[i++];
-		  if (pathname[i] == ']')
-		    temp[j++] = pathname[i++];		/* right brack can be in collsym */
-		  collsym = 1;
-		}
-	      else if (collsym && c == '.' && pathname[i] == ']')
-		{
-		  temp[j++] = c;
-		  temp[j++] = pathname[i++];
-		  collsym = 0;
-		}
-	      else
-		temp[j++] = c;
-	    }
-	  while (((c = pathname[i++]) != ']') && c != 0);
-
-	  /* If we don't find the closing bracket before we hit the end of
-	     the string, rescan string without treating it as a bracket
-	     expression (has implications for backslash and special ERE
-	     chars) */
-	  if (c == 0)
-	    {
-	      i = savei - 1;	/* -1 for autoincrement above */
-	      j = savej;
-	      continue;
-	    }
-
-	  temp[j++] = c;	/* closing right bracket */
-	  i--;			/* increment will happen above in loop */
-	  continue;		/* skip double assignment below */
-	}
-      else if (pathname[i] == '\\' && (qflags & QGLOB_REGEXP) == 0)
-	{
-	  /* XXX - if not quoting regexp, use backslash as quote char. Should
-	     We just pass it through without treating it as special? That is
-	     what ksh93 seems to do. */
-
-	  /* If we want to pass through backslash unaltered, comment out these
-	     lines. */
-	  temp[j++] = '\\';
-
-	  i++;
-	  if (pathname[i] == '\0')
-	    break;
-	  /* If we are turning CTLESC CTLESC into CTLESC, we need to do that
-	     even when the first CTLESC is preceded by a backslash. */
-	  if ((qflags & QGLOB_CTLESC) && pathname[i] == CTLESC && (pathname[i+1] == CTLESC || pathname[i+1] == CTLNUL))
-	    i++;	/* skip over the CTLESC */
-	  else if ((qflags & QGLOB_CTLESC) && pathname[i] == CTLESC)
-	    /* A little more general: if there is an unquoted backslash in the
-	       pattern and we are handling quoted characters in the pattern,
-	       convert the CTLESC to backslash and add the next character on
-	       the theory that the backslash will quote the next character
-	       but it would be inconsistent not to replace the CTLESC with
-	       another backslash here. We can't tell at this point whether the
-	       CTLESC comes from a backslash or other form of quoting in the
-	       original pattern. */
-	    goto convert_to_backslash;
-	}
-      else if (pathname[i] == '\\' && (qflags & QGLOB_REGEXP))
-        last_was_backslash = 1;
-      temp[j++] = pathname[i];
-    }
-endpat:
-  temp[j] = '\0';
-
-  return (temp);
-}
-
-char *
-quote_globbing_chars (string)
-     const char *string;
-{
-  size_t slen;
-  char *temp, *t;
-  const char *s, *send;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  send = string + slen;
-
-  temp = (char *)xmalloc (slen * 2 + 1);
-  for (t = temp, s = string; *s; )
-    {
-      if (glob_char_p (s))
-	*t++ = '\\';
-
-      /* Copy a single (possibly multibyte) character from s to t,
-	 incrementing both. */
-      COPY_CHAR_P (t, s, send);
-    }
-  *t = '\0';
-  return temp;
-}
-
-/* Call the glob library to do globbing on PATHNAME. */
-char **
-shell_glob_filename (pathname, qflags)
-     const char *pathname;
-     int qflags;
-{
-  char *temp, **results;
-  int gflags, quoted_pattern;
-
-  noglob_dot_filenames = glob_dot_filenames == 0;
-
-  temp = quote_string_for_globbing (pathname, QGLOB_FILENAME|qflags);
-  gflags = glob_star ? GX_GLOBSTAR : 0;
-  results = glob_filename (temp, gflags);
-  free (temp);
-
-  if (results && ((GLOB_FAILED (results)) == 0))
-    {
-      if (should_ignore_glob_matches ())
-	ignore_glob_matches (results);
-      if (results && results[0])
-	strvec_sort (results, 1);		/* posix sort */
-      else
-	{
-	  FREE (results);
-	  results = (char **)&glob_error_return;
-	}
-    }
-
-  return (results);
-}
-
-/* Stuff for GLOBIGNORE. */
-
-static struct ignorevar globignore =
-{
-  "GLOBIGNORE",
-  (struct ign *)0,
-  0,
-  (char *)0,
-  (sh_iv_item_func_t *)0,
-};
-
-/* Set up to ignore some glob matches because the value of GLOBIGNORE
-   has changed.  If GLOBIGNORE is being unset, we also need to disable
-   the globbing of filenames beginning with a `.'. */
-void
-setup_glob_ignore (name)
-     char *name;
-{
-  char *v;
-
-  v = get_string_value (name);
-  setup_ignore_patterns (&globignore);
-
-  if (globignore.num_ignores)
-    glob_dot_filenames = 1;
-  else if (v == 0)
-    glob_dot_filenames = 0;
-}
-
-int
-should_ignore_glob_matches ()
-{
-  return globignore.num_ignores;
-}
-
-/* Return 0 if NAME matches a pattern in the globignore.ignores list. */
-static int
-glob_name_is_acceptable (name)
-     const char *name;
-{
-  struct ign *p;
-  char *n;
-  int flags;
-
-  /* . and .. are never matched. We extend this to the terminal component of a
-     pathname. */
-  n = strrchr (name, '/');
-  if (n == 0 || n[1] == 0)
-    n = (char *)name;
-  else
-    n++;
-
-  if (n[0] == '.' && (n[1] == '\0' || (n[1] == '.' && n[2] == '\0')))
-    return (0);
-
-  flags = FNM_PATHNAME | FNMATCH_EXTFLAG | FNMATCH_NOCASEGLOB;
-  for (p = globignore.ignores; p->val; p++)
-    {
-      if (strmatch (p->val, (char *)name, flags) != FNM_NOMATCH)
-	return (0);
-    }
-  return (1);
-}
-
-/* Internal function to test whether filenames in NAMES should be
-   ignored.  NAME_FUNC is a pointer to a function to call with each
-   name.  It returns non-zero if the name is acceptable to the particular
-   ignore function which called _ignore_names; zero if the name should
-   be removed from NAMES. */
-
-static void
-ignore_globbed_names (names, name_func)
-     char **names;
-     sh_ignore_func_t *name_func;
-{
-  char **newnames;
-  int n, i;
-
-  for (i = 0; names[i]; i++)
-    ;
-  newnames = strvec_create (i + 1);
-
-  for (n = i = 0; names[i]; i++)
-    {
-      if ((*name_func) (names[i]))
-	newnames[n++] = names[i];
-      else
-	free (names[i]);
-    }
-
-  newnames[n] = (char *)NULL;
-
-  if (n == 0)
-    {
-      names[0] = (char *)NULL;
-      free (newnames);
-      return;
-    }
-
-  /* Copy the acceptable names from NEWNAMES back to NAMES and set the
-     new array end. */
-  for (n = 0; newnames[n]; n++)
-    names[n] = newnames[n];
-  names[n] = (char *)NULL;
-  free (newnames);
-}
-
-void
-ignore_glob_matches (names)
-     char **names;
-{
-  if (globignore.num_ignores == 0)
-    return;
-
-  ignore_globbed_names (names, glob_name_is_acceptable);
-}
-
-static char *
-split_ignorespec (s, ip)
-     char *s;
-     int *ip;
-{
-  char *t;
-  int n, i;
-
-  if (s == 0)
-    return 0;
-
-  i = *ip;
-  if (s[i] == 0)
-    return 0;
-
-  n = skip_to_delim (s, i, ":", SD_NOJMP|SD_EXTGLOB|SD_GLOB);
-  t = substring (s, i, n);
-
-  if (s[n] == ':')
-    n++;  
-  *ip = n;  
-  return t;
-}
-  
-void
-setup_ignore_patterns (ivp)
-     struct ignorevar *ivp;
-{
-  int numitems, maxitems, ptr;
-  char *colon_bit, *this_ignoreval;
-  struct ign *p;
-
-  this_ignoreval = get_string_value (ivp->varname);
-
-  /* If nothing has changed then just exit now. */
-  if ((this_ignoreval && ivp->last_ignoreval && STREQ (this_ignoreval, ivp->last_ignoreval)) ||
-      (!this_ignoreval && !ivp->last_ignoreval))
-    return;
-
-  /* Oops.  The ignore variable has changed.  Re-parse it. */
-  ivp->num_ignores = 0;
-
-  if (ivp->ignores)
-    {
-      for (p = ivp->ignores; p->val; p++)
-	free(p->val);
-      free (ivp->ignores);
-      ivp->ignores = (struct ign *)NULL;
-    }
-
-  if (ivp->last_ignoreval)
-    {
-      free (ivp->last_ignoreval);
-      ivp->last_ignoreval = (char *)NULL;
-    }
-
-  if (this_ignoreval == 0 || *this_ignoreval == '\0')
-    return;
-
-  ivp->last_ignoreval = savestring (this_ignoreval);
-
-  numitems = maxitems = ptr = 0;
-
-#if 0
-  while (colon_bit = extract_colon_unit (this_ignoreval, &ptr))
-#else
-  while (colon_bit = split_ignorespec (this_ignoreval, &ptr))
-#endif
-    {
-      if (numitems + 1 >= maxitems)
-	{
-	  maxitems += 10;
-	  ivp->ignores = (struct ign *)xrealloc (ivp->ignores, maxitems * sizeof (struct ign));
-	}
-      ivp->ignores[numitems].val = colon_bit;
-      ivp->ignores[numitems].len = strlen (colon_bit);
-      ivp->ignores[numitems].flags = 0;
-      if (ivp->item_func)
-	(*ivp->item_func) (&ivp->ignores[numitems]);
-      numitems++;
-    }
-  ivp->ignores[numitems].val = (char *)NULL;
-  ivp->num_ignores = numitems;
-}
diff --git a/third_party/bash/pathexp.h b/third_party/bash/pathexp.h
deleted file mode 100644
index b96f92af4..000000000
--- a/third_party/bash/pathexp.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/* pathexp.h -- The shell interface to the globbing library. */
-
-/* Copyright (C) 1987-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_PATHEXP_H_)
-#define _PATHEXP_H_
-
-#define GLOB_FAILED(glist)	(glist) == (char **)&glob_error_return
-
-extern int noglob_dot_filenames;
-extern char *glob_error_return;
-
-/* Flag values for quote_string_for_globbing */
-#define QGLOB_CVTNULL	0x01	/* convert QUOTED_NULL strings to '\0' */
-#define QGLOB_FILENAME	0x02	/* do correct quoting for matching filenames */
-#define QGLOB_REGEXP	0x04	/* quote an ERE for regcomp/regexec */
-#define QGLOB_CTLESC	0x08	/* turn CTLESC CTLESC into CTLESC for BREs */
-#define QGLOB_DEQUOTE	0x10	/* like dequote_string but quote glob chars */
-
-#if defined (EXTENDED_GLOB)
-/* Flags to OR with other flag args to strmatch() to enabled the extended
-   pattern matching. */
-#  define FNMATCH_EXTFLAG	(extended_glob ? FNM_EXTMATCH : 0)
-#else
-#  define FNMATCH_EXTFLAG	0
-#endif /* !EXTENDED_GLOB */
-
-#define FNMATCH_IGNCASE		(match_ignore_case ? FNM_CASEFOLD : 0)
-#define FNMATCH_NOCASEGLOB	(glob_ignore_case ? FNM_CASEFOLD : 0)
-
-extern int glob_dot_filenames;
-extern int extended_glob;
-extern int glob_star;
-extern int match_ignore_case;	/* doesn't really belong here */
-
-extern int unquoted_glob_pattern_p PARAMS((char *));
-
-/* PATHNAME can contain characters prefixed by CTLESC; this indicates
-   that the character is to be quoted.  We quote it here in the style
-   that the glob library recognizes.  If flags includes QGLOB_CVTNULL,
-   we change quoted null strings (pathname[0] == CTLNUL) into empty
-   strings (pathname[0] == 0).  If this is called after quote removal
-   is performed, (flags & QGLOB_CVTNULL) should be 0; if called when quote
-   removal has not been done (for example, before attempting to match a
-   pattern while executing a case statement), flags should include
-   QGLOB_CVTNULL.  If flags includes QGLOB_FILENAME, appropriate quoting
-   to match a filename should be performed. */
-extern char *quote_string_for_globbing PARAMS((const char *, int));
-
-extern int glob_char_p PARAMS((const char *));
-extern char *quote_globbing_chars PARAMS((const char *));
-
-/* Call the glob library to do globbing on PATHNAME. FLAGS is additional
-   flags to pass to QUOTE_STRING_FOR_GLOBBING, mostly having to do with
-   whether or not we've already performed quote removal. */
-extern char **shell_glob_filename PARAMS((const char *, int));
-
-/* Filename completion ignore.  Used to implement the "fignore" facility of
-   tcsh, GLOBIGNORE (like ksh-93 FIGNORE), and EXECIGNORE.
-
-   It is passed a NULL-terminated array of (char *)'s that must be
-   free()'d if they are deleted.  The first element (names[0]) is the
-   least-common-denominator string of the matching patterns (i.e.
-   u<TAB> produces names[0] = "und", names[1] = "under.c", names[2] =
-   "undun.c", name[3] = NULL).  */
-
-struct ign {
-  char *val;
-  int len, flags;
-};
-
-typedef int sh_iv_item_func_t PARAMS((struct ign *));
-
-struct ignorevar {
-  char *varname;	/* FIGNORE, GLOBIGNORE, or EXECIGNORE */
-  struct ign *ignores;	/* Store the ignore strings here */
-  int num_ignores;	/* How many are there? */
-  char *last_ignoreval;	/* Last value of variable - cached for speed */
-  sh_iv_item_func_t *item_func; /* Called when each item is parsed from $`varname' */
-};
-
-extern void setup_ignore_patterns PARAMS((struct ignorevar *));
-
-extern void setup_glob_ignore PARAMS((char *));
-extern int should_ignore_glob_matches PARAMS((void));
-extern void ignore_glob_matches PARAMS((char **));
-
-#endif
diff --git a/third_party/bash/pathnames.h b/third_party/bash/pathnames.h
deleted file mode 100644
index f506f3cb4..000000000
--- a/third_party/bash/pathnames.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/* pathnames.h -- absolute filenames that bash wants for various defaults. */
-
-/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_PATHNAMES_H_)
-#define _PATHNAMES_H_
-
-/* The default file for hostname completion. */
-#define DEFAULT_HOSTS_FILE "/etc/hosts"
-
-/* The default login shell startup file. */
-#define SYS_PROFILE "/etc/profile"
-
-/* The default location of the bash debugger initialization/startup file. */
-#define DEBUGGER_START_FILE	"/zip/usr/share/bashdb/bashdb-main.inc"
-
-#endif /* _PATHNAMES_H */
diff --git a/third_party/bash/pathphys.c b/third_party/bash/pathphys.c
deleted file mode 100644
index 2b6211d6a..000000000
--- a/third_party/bash/pathphys.c
+++ /dev/null
@@ -1,296 +0,0 @@
-/* pathphys.c -- return pathname with all symlinks expanded. */
-
-/* Copyright (C) 2000-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#if defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "filecntl.h"
-#include "bashansi.h"
-#include <stdio.h>
-#include "chartypes.h"
-#include <errno.h>
-
-#include "shell.h"
-
-#if !defined (MAXSYMLINKS)
-#  define MAXSYMLINKS 32
-#endif
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-extern char *get_working_directory PARAMS((char *));
-
-static int
-_path_readlink (path, buf, bufsiz)
-     char *path;
-     char *buf;
-     int bufsiz;
-{
-#ifdef HAVE_READLINK
-  return readlink (path, buf, bufsiz);
-#else
-  errno = EINVAL;
-  return -1;
-#endif
-}
-
-/* Look for ROOTEDPATH, PATHSEP, DIRSEP, and ISDIRSEP in ../../general.h */
-
-#define DOUBLE_SLASH(p)	((p[0] == '/') && (p[1] == '/') && p[2] != '/')
-
-/*
- * Return PATH with all symlinks expanded in newly-allocated memory.
- * This always gets an absolute pathname.
- */
-
-char *
-sh_physpath (path, flags)
-     char *path;
-     int flags;
-{
-  char tbuf[PATH_MAX+1], linkbuf[PATH_MAX+1];
-  char *result, *p, *q, *qsave, *qbase, *workpath;
-  int double_slash_path, linklen, nlink;
-
-  linklen = strlen (path);
-
-#if 0
-  /* First sanity check -- punt immediately if the name is too long. */
-  if (linklen >= PATH_MAX)
-    return (savestring (path));
-#endif
-
-  nlink = 0;
-  q = result = (char *)xmalloc (PATH_MAX + 1);
-
-  /* Even if we get something longer than PATH_MAX, we might be able to
-     shorten it, so we try. */
-  if (linklen >= PATH_MAX)
-    workpath = savestring (path);
-  else
-    {
-      workpath = (char *)xmalloc (PATH_MAX + 1);
-      strcpy (workpath, path);
-    }
-
-  /* This always gets an absolute pathname. */
-
-  /* POSIX.2 says to leave a leading `//' alone.  On cygwin, we skip over any
-     leading `x:' (dos drive name). */
-#if defined (__CYGWIN__)
-  qbase = (ISALPHA((unsigned char)workpath[0]) && workpath[1] == ':') ? workpath + 3 : workpath + 1;
-#else
-  qbase = workpath + 1;
-#endif
-  double_slash_path = DOUBLE_SLASH (workpath);
-  qbase += double_slash_path;
-
-  for (p = workpath; p < qbase; )
-    *q++ = *p++;
-  qbase = q;
-
-  /*
-   * invariants:
-   *	  qbase points to the portion of the result path we want to modify
-   *      p points at beginning of path element we're considering.
-   *      q points just past the last path element we wrote (no slash).
-   *
-   * XXX -- need to fix error checking for too-long pathnames
-   */
-
-  while (*p)
-    {
-      if (ISDIRSEP(p[0])) /* null element */
-	p++;
-      else if(p[0] == '.' && PATHSEP(p[1]))	/* . and ./ */
-	p += 1; 	/* don't count the separator in case it is nul */
-      else if (p[0] == '.' && p[1] == '.' && PATHSEP(p[2])) /* .. and ../ */
-	{
-	  p += 2; /* skip `..' */
-	  if (q > qbase)
-	    {
-	      while (--q > qbase && ISDIRSEP(*q) == 0)
-		;
-	    }
-	}
-      else	/* real path element */
-	{
-	  /* add separator if not at start of work portion of result */
-	  qsave = q;
-	  if (q != qbase)
-	    *q++ = DIRSEP;
-	  while (*p && (ISDIRSEP(*p) == 0))
-	    {
-	      if (q - result >= PATH_MAX)
-		{
-#ifdef ENAMETOOLONG
-		  errno = ENAMETOOLONG;
-#else
-		  errno = EINVAL;
-#endif
-		  goto error;
-		}
-		
-	      *q++ = *p++;
-	    }
-
-	  *q = '\0';
-
-	  linklen = _path_readlink (result, linkbuf, PATH_MAX);
-	  if (linklen < 0)	/* if errno == EINVAL, it's not a symlink */
-	    {
-	      if (errno != EINVAL)
-		goto error;
-	      continue;
-	    }
-
-	  /* It's a symlink, and the value is in LINKBUF. */
-	  nlink++;
-	  if (nlink > MAXSYMLINKS)
-	    {
-#ifdef ELOOP
-	      errno = ELOOP;
-#else
-	      errno = EINVAL;
-#endif
-error:
-	      free (result);
-	      free (workpath);
-	      return ((char *)NULL);
-	    }
-
-	  linkbuf[linklen] = '\0';
-
-	  /* If the new path length would overrun PATH_MAX, punt now. */
-	  if ((strlen (p) + linklen + 2) >= PATH_MAX)
-	    {
-#ifdef ENAMETOOLONG
-	      errno = ENAMETOOLONG;
-#else
-	      errno = EINVAL;
-#endif
-	      goto error;
-	    }
-
-	  /* Form the new pathname by copying the link value to a temporary
-	     buffer and appending the rest of `workpath'.  Reset p to point
-	     to the start of the rest of the path.  If the link value is an
-	     absolute pathname, reset p, q, and qbase.  If not, reset p
-	     and q. */
-	  strcpy (tbuf, linkbuf);
-	  tbuf[linklen] = '/';
-	  strcpy (tbuf + linklen, p);
-	  strcpy (workpath, tbuf);
-
-	  if (ABSPATH(linkbuf))
-	    {
-	      q = result;
-	      /* Duplicating some code here... */
-#if defined (__CYGWIN__)
-	      qbase = (ISALPHA((unsigned char)workpath[0]) && workpath[1] == ':') ? workpath + 3 : workpath + 1;
-#else
-	      qbase = workpath + 1;
-#endif
-	      double_slash_path = DOUBLE_SLASH (workpath);
-	      qbase += double_slash_path;
-    
-	      for (p = workpath; p < qbase; )
-		*q++ = *p++;
-	      qbase = q;
-	    }
-	  else
-	    {
-	      p = workpath;
-	      q = qsave;
-	    }
-	}
-    }
-
-  *q = '\0';
-  free (workpath);
-
-  /* If the result starts with `//', but the original path does not, we
-     can turn the // into /.  Because of how we set `qbase', this should never
-     be true, but it's a sanity check. */
-  if (DOUBLE_SLASH(result) && double_slash_path == 0)
-    {
-      if (result[2] == '\0')	/* short-circuit for bare `//' */
-	result[1] = '\0';
-      else
-	memmove (result, result + 1, strlen (result + 1) + 1);
-    }
-
-  return (result);
-}
-
-char *
-sh_realpath (pathname, resolved)
-     const char *pathname;
-     char *resolved;
-{
-  char *tdir, *wd;
-
-  if (pathname == 0 || *pathname == '\0')
-    {
-      errno = (pathname == 0) ? EINVAL : ENOENT;
-      return ((char *)NULL);
-    }
-
-  if (ABSPATH (pathname) == 0)
-    {
-      wd = get_working_directory ("sh_realpath");
-      if (wd == 0)
-	return ((char *)NULL);
-      tdir = sh_makepath (wd, (char *)pathname, 0);
-      free (wd);
-    }
-  else
-    tdir = savestring (pathname);
-
-  wd = sh_physpath (tdir, 0);
-  free (tdir);
-
-  if (resolved == 0)
-    return (wd);
-
-  if (wd)
-    {
-      strncpy (resolved, wd, PATH_MAX - 1);
-      resolved[PATH_MAX - 1] = '\0';
-      free (wd);
-      return resolved;
-    }
-  else
-    {
-      resolved[0] = '\0';
-      return wd;
-    }
-}
diff --git a/third_party/bash/pcomplete.c b/third_party/bash/pcomplete.c
deleted file mode 100644
index e78b929be..000000000
--- a/third_party/bash/pcomplete.c
+++ /dev/null
@@ -1,1757 +0,0 @@
-/* pcomplete.c - functions to generate lists of matches for programmable completion. */
-
-/* Copyright (C) 1999-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (PROGRAMMABLE_COMPLETION)
-
-#include "bashtypes.h"
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <signal.h>
-
-#if defined (PREFER_STDARG)
-#  include <stdarg.h>
-#else
-#  include <varargs.h>
-#endif
-
-#include "posixtime.h"
-
-#include <stdio.h>
-#include "bashansi.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "pcomplete.h"
-#include "alias.h"
-#include "bashline.h"
-#include "execute_cmd.h"
-#include "pathexp.h"
-
-#if defined (JOB_CONTROL)
-#  include "jobs.h"
-#endif
-
-#if !defined (NSIG)
-#  include "trap.h"
-#endif
-
-#include "shmbutil.h"
-
-#include "builtins.h"
-#include "common.h"
-#include "builtext.h"
-
-#include "glob.h"
-#include "strmatch.h"
-
-#include "third_party/readline/rlconf.h"
-#include "third_party/readline/readline.h"
-#include "third_party/readline/history.h"
-
-#ifdef STRDUP
-#  undef STRDUP
-#endif
-#define STRDUP(x)	((x) ? savestring (x) : (char *)NULL)
-
-typedef SHELL_VAR **SVFUNC ();
-
-#ifndef HAVE_STRPBRK
-extern char *strpbrk PARAMS((char *, char *));
-#endif
-
-extern STRING_INT_ALIST word_token_alist[];
-extern char *signal_names[];
-
-#if defined (DEBUG)
-#if defined (PREFER_STDARG)
-static void debug_printf (const char *, ...)  __attribute__((__format__ (printf, 1, 2)));
-#endif
-#endif /* DEBUG */
-
-static int it_init_joblist PARAMS((ITEMLIST *, int));
-
-static int it_init_aliases PARAMS((ITEMLIST *));
-static int it_init_arrayvars PARAMS((ITEMLIST *));
-static int it_init_bindings PARAMS((ITEMLIST *));
-static int it_init_builtins PARAMS((ITEMLIST *));
-static int it_init_disabled PARAMS((ITEMLIST *));
-static int it_init_enabled PARAMS((ITEMLIST *));
-static int it_init_exported PARAMS((ITEMLIST *));
-static int it_init_functions PARAMS((ITEMLIST *));
-static int it_init_helptopics PARAMS((ITEMLIST *));
-static int it_init_hostnames PARAMS((ITEMLIST *));
-static int it_init_jobs PARAMS((ITEMLIST *));
-static int it_init_running PARAMS((ITEMLIST *));
-static int it_init_stopped PARAMS((ITEMLIST *));
-static int it_init_keywords PARAMS((ITEMLIST *));
-static int it_init_signals PARAMS((ITEMLIST *));
-static int it_init_variables PARAMS((ITEMLIST *));
-static int it_init_setopts PARAMS((ITEMLIST *));
-static int it_init_shopts PARAMS((ITEMLIST *));
-
-static int shouldexp_filterpat PARAMS((char *));
-static char *preproc_filterpat PARAMS((char *, const char *));
-
-static void init_itemlist_from_varlist PARAMS((ITEMLIST *, SVFUNC *));
-
-static STRINGLIST *gen_matches_from_itemlist PARAMS((ITEMLIST *, const char *));
-static STRINGLIST *gen_action_completions PARAMS((COMPSPEC *, const char *));
-static STRINGLIST *gen_globpat_matches PARAMS((COMPSPEC *, const char *));
-static STRINGLIST *gen_wordlist_matches PARAMS((COMPSPEC *, const char *));
-static STRINGLIST *gen_shell_function_matches PARAMS((COMPSPEC *, const char *,
-						   const char *,
-						   char *, int, WORD_LIST *,
-						   int, int, int *));
-static STRINGLIST *gen_command_matches PARAMS((COMPSPEC *, const char *,
-					    const char *,
-					    char *, int, WORD_LIST *,
-					    int, int));
-
-static STRINGLIST *gen_progcomp_completions PARAMS((const char *, const char *,
-						 const char *,
-						 int, int, int *, int *,
-						 COMPSPEC **));
-
-static char *pcomp_filename_completion_function PARAMS((const char *, int));
-
-#if defined (ARRAY_VARS)
-static SHELL_VAR *bind_comp_words PARAMS((WORD_LIST *));
-#endif
-static void bind_compfunc_variables PARAMS((char *, int, WORD_LIST *, int, int));
-static void unbind_compfunc_variables PARAMS((int));
-static WORD_LIST *build_arg_list PARAMS((char *, const char *, const char *, WORD_LIST *, int));
-static WORD_LIST *command_line_to_word_list PARAMS((char *, int, int, int *, int *));
-
-#ifdef DEBUG
-static int progcomp_debug = 0;
-#endif
-
-int prog_completion_enabled = 1;
-
-#ifdef ALIAS
-int progcomp_alias = 0;	/* unavailable to user code for now */
-#endif
-
-/* These are used to manage the arrays of strings for possible completions. */
-ITEMLIST it_aliases = { 0, it_init_aliases, (STRINGLIST *)0 };
-ITEMLIST it_arrayvars  = { LIST_DYNAMIC, it_init_arrayvars, (STRINGLIST *)0 };
-ITEMLIST it_bindings  = { 0, it_init_bindings, (STRINGLIST *)0 };
-ITEMLIST it_builtins  = { 0, it_init_builtins, (STRINGLIST *)0 };
-ITEMLIST it_commands = { LIST_DYNAMIC };	/* unused */
-ITEMLIST it_directories = { LIST_DYNAMIC };	/* unused */
-ITEMLIST it_disabled = { 0, it_init_disabled, (STRINGLIST *)0 };
-ITEMLIST it_enabled = { 0, it_init_enabled, (STRINGLIST *)0 };
-ITEMLIST it_exports  = { LIST_DYNAMIC, it_init_exported, (STRINGLIST *)0 };
-ITEMLIST it_files = { LIST_DYNAMIC };		/* unused */
-ITEMLIST it_functions  = { 0, it_init_functions, (STRINGLIST *)0 };
-ITEMLIST it_helptopics  = { 0, it_init_helptopics, (STRINGLIST *)0 };
-ITEMLIST it_hostnames  = { LIST_DYNAMIC, it_init_hostnames, (STRINGLIST *)0 };
-ITEMLIST it_groups = { LIST_DYNAMIC };		/* unused */
-ITEMLIST it_jobs = { LIST_DYNAMIC, it_init_jobs, (STRINGLIST *)0 };
-ITEMLIST it_keywords = { 0, it_init_keywords, (STRINGLIST *)0 };
-ITEMLIST it_running = { LIST_DYNAMIC, it_init_running, (STRINGLIST *)0 };
-ITEMLIST it_services = { LIST_DYNAMIC };	/* unused */
-ITEMLIST it_setopts = { 0, it_init_setopts, (STRINGLIST *)0 };
-ITEMLIST it_shopts = { 0, it_init_shopts, (STRINGLIST *)0 };
-ITEMLIST it_signals = { 0, it_init_signals, (STRINGLIST *)0 };
-ITEMLIST it_stopped = { LIST_DYNAMIC, it_init_stopped, (STRINGLIST *)0 };
-ITEMLIST it_users = { LIST_DYNAMIC };		/* unused */
-ITEMLIST it_variables = { LIST_DYNAMIC, it_init_variables, (STRINGLIST *)0 };
-
-COMPSPEC *pcomp_curcs;
-const char *pcomp_curcmd;
-const char *pcomp_curtxt;
-
-char *pcomp_line;
-int pcomp_ind;
-
-#ifdef DEBUG
-/* Debugging code */
-static void
-#if defined (PREFER_STDARG)
-debug_printf (const char *format, ...)
-#else
-debug_printf (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-
-  if (progcomp_debug == 0)
-    return;
-
-  SH_VA_START (args, format);
-
-  fprintf (stdout, "DEBUG: ");
-  vfprintf (stdout, format, args);
-  fprintf (stdout, "\n");
-
-  rl_on_new_line ();
-
-  va_end (args);
-}
-#endif
-
-/* Functions to manage the item lists */
-
-void
-set_itemlist_dirty (it)
-     ITEMLIST *it;
-{
-  it->flags |= LIST_DIRTY;
-}
-
-void
-initialize_itemlist (itp)
-     ITEMLIST *itp;
-{
-  (*itp->list_getter) (itp);
-  itp->flags |= LIST_INITIALIZED;
-  itp->flags &= ~LIST_DIRTY;
-}
-
-void
-clean_itemlist (itp)
-     ITEMLIST *itp;
-{
-  STRINGLIST *sl;
-
-  sl = itp->slist;
-  if (sl)
-    {
-      if ((itp->flags & (LIST_DONTFREEMEMBERS|LIST_DONTFREE)) == 0)
-	strvec_flush (sl->list);
-      if ((itp->flags & LIST_DONTFREE) == 0)
-	free (sl->list);
-      free (sl);
-    }
-  itp->slist = (STRINGLIST *)NULL;
-  itp->flags &= ~(LIST_DONTFREE|LIST_DONTFREEMEMBERS|LIST_INITIALIZED|LIST_DIRTY);
-}
-
-
-static int
-shouldexp_filterpat (s)
-     char *s;
-{
-  register char *p;
-
-  for (p = s; p && *p; p++)
-    {
-      if (*p == '\\')
-	p++;
-      else if (*p == '&')
-	return 1;
-    }
-  return 0;
-}
-
-/* Replace any instance of `&' in PAT with TEXT.  Backslash may be used to
-   quote a `&' and inhibit substitution.  Returns a new string.  This just
-   calls stringlib.c:strcreplace(). */
-static char *
-preproc_filterpat (pat, text)
-     char *pat;
-     const char *text;
-{
-  char *ret;
-
-  ret = strcreplace (pat, '&', text, 1);
-  return ret;
-}
-	
-/* Remove any match of FILTERPAT from SL.  A `&' in FILTERPAT is replaced by
-   TEXT.  A leading `!' in FILTERPAT negates the pattern; in this case
-   any member of SL->list that does *not* match will be removed.  This returns
-   a new STRINGLIST with the matching members of SL *copied*.  Any
-   non-matching members of SL->list are *freed*. */   
-STRINGLIST *
-filter_stringlist (sl, filterpat, text)
-     STRINGLIST *sl;
-     char *filterpat;
-     const char *text;
-{
-  int i, m, not;
-  STRINGLIST *ret;
-  char *npat, *t;
-
-  if (sl == 0 || sl->list == 0 || sl->list_len == 0)
-    return sl;
-
-  npat = shouldexp_filterpat (filterpat) ? preproc_filterpat (filterpat, text) : filterpat;
-
-#if defined (EXTENDED_GLOB)
-  not = (npat[0] == '!' && (extended_glob == 0 || npat[1] != '('));	/*)*/
-#else
-  not = (npat[0] == '!');
-#endif
-  t = not ? npat + 1 : npat;
-
-  ret = strlist_create (sl->list_size);
-  for (i = 0; i < sl->list_len; i++)
-    {
-      m = strmatch (t, sl->list[i], FNMATCH_EXTFLAG | FNMATCH_IGNCASE);
-      if ((not && m == FNM_NOMATCH) || (not == 0 && m != FNM_NOMATCH))
-	free (sl->list[i]);
-      else
-	ret->list[ret->list_len++] = sl->list[i];
-    }
-
-  ret->list[ret->list_len] = (char *)NULL;
-  if (npat != filterpat)
-    free (npat);
-
-  return ret;
-}
-
-/* Turn an array of strings returned by rl_completion_matches into a STRINGLIST.
-   This understands how rl_completion_matches sets matches[0] (the lcd of the
-   strings in the list, unless it's the only match). */
-STRINGLIST *
-completions_to_stringlist (matches)
-     char **matches;
-{
-  STRINGLIST *sl;
-  int mlen, i, n;
-
-  mlen = (matches == 0) ? 0 : strvec_len (matches);
-  sl = strlist_create (mlen + 1);
-
-  if (matches == 0 || matches[0] == 0)
-    return sl;
-
-  if (matches[1] == 0)
-    {
-      sl->list[0] = STRDUP (matches[0]);
-      sl->list[sl->list_len = 1] = (char *)NULL;
-      return sl;
-    }
-
-  for (i = 1, n = 0; i < mlen; i++, n++)
-    sl->list[n] = STRDUP (matches[i]);
-  sl->list_len = n;
-  sl->list[n] = (char *)NULL;
-
-  return sl;
-}
-
-/* Functions to manage the various ITEMLISTs that we populate internally.
-   The caller is responsible for setting ITP->flags correctly. */
-
-static int
-it_init_aliases (itp)
-     ITEMLIST *itp;
-{
-#ifdef ALIAS
-  alias_t **alias_list;
-  register int i, n;
-  STRINGLIST *sl;
-
-  alias_list = all_aliases ();
-  if (alias_list == 0)
-    {
-      itp->slist = (STRINGLIST *)NULL;
-      return 0;
-    }
-  for (n = 0; alias_list[n]; n++)
-    ;
-  sl = strlist_create (n+1);
-  for (i = 0; i < n; i++)
-    sl->list[i] = STRDUP (alias_list[i]->name);
-  sl->list[n] = (char *)NULL;
-  sl->list_size = sl->list_len = n;
-  itp->slist = sl;
-#else
-  itp->slist = (STRINGLIST *)NULL;
-#endif
-  free (alias_list);
-  return 1;
-}
-
-static void
-init_itemlist_from_varlist (itp, svfunc)
-     ITEMLIST *itp;
-     SVFUNC *svfunc;
-{
-  SHELL_VAR **vlist;
-  STRINGLIST *sl;
-  register int i, n;
-
-  vlist = (*svfunc) ();
-  if (vlist == 0)
-    {
-      itp->slist = (STRINGLIST *)NULL;
-      return;
-    }    
-  for (n = 0; vlist[n]; n++)
-    ;
-  sl = strlist_create (n+1);
-  for (i = 0; i < n; i++)
-    sl->list[i] = savestring (vlist[i]->name);
-  sl->list[sl->list_len = n] = (char *)NULL;
-  itp->slist = sl;
-  free (vlist);
-}
-
-static int
-it_init_arrayvars (itp)
-     ITEMLIST *itp;
-{
-#if defined (ARRAY_VARS)
-  init_itemlist_from_varlist (itp, all_array_variables);
-  return 1;
-#else
-  return 0;
-#endif
-}
-
-static int
-it_init_bindings (itp)
-     ITEMLIST *itp;
-{
-  char **blist;
-  STRINGLIST *sl;
-
-  /* rl_funmap_names allocates blist, but not its members */
-  blist = (char **)rl_funmap_names ();	/* XXX fix const later */
-  sl = strlist_create (0);
-  sl->list = blist;
-  sl->list_size = 0;
-  sl->list_len = strvec_len (sl->list);
-  itp->flags |= LIST_DONTFREEMEMBERS;
-  itp->slist = sl;
-
-  return 0;
-}
-
-static int
-it_init_builtins (itp)
-     ITEMLIST *itp;
-{
-  STRINGLIST *sl;
-  register int i, n;
-
-  sl = strlist_create (num_shell_builtins);
-  for (i = n = 0; i < num_shell_builtins; i++)
-    if (shell_builtins[i].function)
-      sl->list[n++] = shell_builtins[i].name;
-  sl->list[sl->list_len = n] = (char *)NULL;
-  itp->flags |= LIST_DONTFREEMEMBERS;
-  itp->slist = sl;
-  return 0;
-}
-
-static int
-it_init_enabled (itp)
-     ITEMLIST *itp;
-{
-  STRINGLIST *sl;
-  register int i, n;
-
-  sl = strlist_create (num_shell_builtins);
-  for (i = n = 0; i < num_shell_builtins; i++)
-    {
-      if (shell_builtins[i].function && (shell_builtins[i].flags & BUILTIN_ENABLED))
-	sl->list[n++] = shell_builtins[i].name;
-    }
-  sl->list[sl->list_len = n] = (char *)NULL;
-  itp->flags |= LIST_DONTFREEMEMBERS;
-  itp->slist = sl;
-  return 0;
-}
-
-static int
-it_init_disabled (itp)
-     ITEMLIST *itp;
-{
-  STRINGLIST *sl;
-  register int i, n;
-
-  sl = strlist_create (num_shell_builtins);
-  for (i = n = 0; i < num_shell_builtins; i++)
-    {
-      if (shell_builtins[i].function && ((shell_builtins[i].flags & BUILTIN_ENABLED) == 0))
-	sl->list[n++] = shell_builtins[i].name;
-    }
-  sl->list[sl->list_len = n] = (char *)NULL;
-  itp->flags |= LIST_DONTFREEMEMBERS;
-  itp->slist = sl;
-  return 0;
-}
-
-static int
-it_init_exported (itp)
-     ITEMLIST *itp;
-{
-  init_itemlist_from_varlist (itp, all_exported_variables);
-  return 0;
-}
-
-static int
-it_init_functions (itp)
-     ITEMLIST *itp;
-{
-  init_itemlist_from_varlist (itp, all_visible_functions);
-  return 0;
-}
-
-/* Like it_init_builtins, but includes everything the help builtin looks at,
-   not just builtins with an active implementing function. */
-static int
-it_init_helptopics (itp)
-     ITEMLIST *itp;
-{
-  STRINGLIST *sl;
-  register int i, n;
-
-  sl = strlist_create (num_shell_builtins);
-  for (i = n = 0; i < num_shell_builtins; i++)
-    sl->list[n++] = shell_builtins[i].name;
-  sl->list[sl->list_len = n] = (char *)NULL;
-  itp->flags |= LIST_DONTFREEMEMBERS;
-  itp->slist = sl;
-  return 0;
-}
-
-static int
-it_init_hostnames (itp)
-     ITEMLIST *itp;
-{
-  STRINGLIST *sl;
-
-  sl = strlist_create (0);
-  sl->list = get_hostname_list ();
-  sl->list_len = sl->list ? strvec_len (sl->list) : 0;
-  sl->list_size = sl->list_len;
-  itp->slist = sl;
-  itp->flags |= LIST_DONTFREEMEMBERS|LIST_DONTFREE;
-  return 0;
-}
-
-static int
-it_init_joblist (itp, jstate)
-     ITEMLIST *itp;
-     int jstate;
-{
-#if defined (JOB_CONTROL)
-  STRINGLIST *sl;
-  register int i;
-  register PROCESS *p;
-  char *s, *t;
-  JOB *j;
-  JOB_STATE ws;		/* wanted state */
-
-  ws = JNONE;
-  if (jstate == 0)
-    ws = JRUNNING;
-  else if (jstate == 1)
-    ws = JSTOPPED;
-
-  sl = strlist_create (js.j_jobslots);
-  for (i = js.j_jobslots - 1; i >= 0; i--)
-    {
-      j = get_job_by_jid (i);
-      if (j == 0)
-	continue;
-      p = j->pipe;
-      if (jstate == -1 || JOBSTATE(i) == ws)
-	{
-	  s = savestring (p->command);
-	  t = strpbrk (s, " \t\n");
-	  if (t)
-	    *t = '\0';
-	  sl->list[sl->list_len++] = s;
-	}
-    }
-  itp->slist = sl;
-#else
-  itp->slist = (STRINGLIST *)NULL;
-#endif
-  return 0;
-}
-
-static int
-it_init_jobs (itp)
-     ITEMLIST *itp;
-{
-  return (it_init_joblist (itp, -1));
-}
-
-static int
-it_init_running (itp)
-     ITEMLIST *itp;
-{
-  return (it_init_joblist (itp, 0));
-}
-
-static int
-it_init_stopped (itp)
-     ITEMLIST *itp;
-{
-  return (it_init_joblist (itp, 1));
-}
-
-static int
-it_init_keywords (itp)
-     ITEMLIST *itp;
-{
-  STRINGLIST *sl;
-  register int i, n;
-
-  for (n = 0; word_token_alist[n].word; n++)
-    ;
-  sl = strlist_create (n);
-  for (i = 0; i < n; i++)
-    sl->list[i] = word_token_alist[i].word;
-  sl->list[sl->list_len = i] = (char *)NULL;
-  itp->flags |= LIST_DONTFREEMEMBERS;
-  itp->slist = sl;
-  return 0;
-}
-
-static int
-it_init_signals (itp)
-     ITEMLIST *itp;
-{
-  STRINGLIST *sl;
-
-  sl = strlist_create (0);
-  sl->list = signal_names;
-  sl->list_len = strvec_len (sl->list);
-  itp->flags |= LIST_DONTFREE;
-  itp->slist = sl;
-  return 0;
-}
-
-static int
-it_init_variables (itp)
-     ITEMLIST *itp;
-{
-  init_itemlist_from_varlist (itp, all_visible_variables);
-  return 0;
-}
-
-static int
-it_init_setopts (itp)
-     ITEMLIST *itp;
-{
-  STRINGLIST *sl;
-
-  sl = strlist_create (0);
-  sl->list = get_minus_o_opts ();
-  sl->list_len = strvec_len (sl->list);
-  itp->slist = sl;
-  itp->flags |= LIST_DONTFREEMEMBERS;
-  return 0;
-}
-
-static int
-it_init_shopts (itp)
-     ITEMLIST *itp;
-{
-  STRINGLIST *sl;
-
-  sl = strlist_create (0);
-  sl->list = get_shopt_options ();
-  sl->list_len = strvec_len (sl->list);
-  itp->slist = sl;
-  itp->flags |= LIST_DONTFREEMEMBERS;
-  return 0;
-}
-
-/* Generate a list of all matches for TEXT using the STRINGLIST in itp->slist
-   as the list of possibilities.  If the itemlist has been marked dirty or
-   it should be regenerated every time, destroy the old STRINGLIST and make a
-   new one before trying the match.  TEXT is dequoted before attempting a
-   match. */
-static STRINGLIST *
-gen_matches_from_itemlist (itp, text)
-     ITEMLIST *itp;
-     const char *text;
-{
-  STRINGLIST *ret, *sl;
-  int tlen, i, n;
-  char *ntxt;
-
-  if ((itp->flags & (LIST_DIRTY|LIST_DYNAMIC)) ||
-      (itp->flags & LIST_INITIALIZED) == 0)
-    {
-      if (itp->flags & (LIST_DIRTY|LIST_DYNAMIC))
-	clean_itemlist (itp);
-      if ((itp->flags & LIST_INITIALIZED) == 0)
-	initialize_itemlist (itp);
-    }
-  if (itp->slist == 0)
-    return ((STRINGLIST *)NULL);
-  ret = strlist_create (itp->slist->list_len+1);
-  sl = itp->slist;
-
-  ntxt = bash_dequote_text (text);
-  tlen = STRLEN (ntxt);
-
-  for (i = n = 0; i < sl->list_len; i++)
-    {
-      if (tlen == 0 || STREQN (sl->list[i], ntxt, tlen))
-	ret->list[n++] = STRDUP (sl->list[i]);
-    }
-  ret->list[ret->list_len = n] = (char *)NULL;
-
-  FREE (ntxt);
-  return ret;
-}
-
-/* A wrapper for rl_filename_completion_function that dequotes the filename
-   before attempting completions. */
-static char *
-pcomp_filename_completion_function (text, state)
-     const char *text;
-     int state;
-{
-  static char *dfn;	/* dequoted filename */
-  int iscompgen, iscompleting;
-
-  if (state == 0)
-    {
-      FREE (dfn);
-      /* remove backslashes quoting special characters in filenames. */
-      /* There are roughly three paths we can follow to get here:
-		1.  complete -f
-		2.  compgen -f "$word" from a completion function
-		3.  compgen -f "$word" from the command line
-	 They all need to be handled.
-
-	 In the first two cases, readline will run the filename dequoting
-	 function in rl_filename_completion_function if it found a filename
-	 quoting character in the word to be completed
-	 (rl_completion_found_quote).  We run the dequoting function here
-	 if we're running compgen, we're not completing, and the
-	 rl_filename_completion_function won't dequote the filename
-	 (rl_completion_found_quote == 0). */
-      iscompgen = this_shell_builtin == compgen_builtin;
-      iscompleting = RL_ISSTATE (RL_STATE_COMPLETING);
-      if (iscompgen && iscompleting == 0 && rl_completion_found_quote == 0
-	  && rl_filename_dequoting_function)
-	{
-	  /* Use rl_completion_quote_character because any single or
-	     double quotes have been removed by the time TEXT makes it
-	     here, and we don't want to remove backslashes inside
-	     quoted strings. */
-	  dfn = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
-	}
-      /* Intended to solve a mismatched assumption by bash-completion.  If
-	 the text to be completed is empty, but bash-completion turns it into
-	 a quoted string ('') assuming that this code will dequote it before
-	 calling readline, do the dequoting. */
-      else if (iscompgen && iscompleting &&
-	       pcomp_curtxt && *pcomp_curtxt == 0 &&
-	       text && (*text == '\'' || *text == '"') && text[1] == text[0] && text[2] == 0 && 
-	       rl_filename_dequoting_function)
-	dfn = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
-      /* Another mismatched assumption by bash-completion.  If compgen is being
-      	 run as part of bash-completion, and the argument to compgen is not
-      	 the same as the word originally passed to the programmable completion
-      	 code, dequote the argument if it has quote characters.  It's an
-      	 attempt to detect when bash-completion is quoting its filename
-      	 argument before calling compgen. */
-      /* We could check whether gen_shell_function_matches is in the call
-	 stack by checking whether the gen-shell-function-matches tag is in
-	 the unwind-protect stack, but there's no function to do that yet.
-	 We could simply check whether we're executing in a function by
-	 checking variable_context, and may end up doing that. */
-      else if (iscompgen && iscompleting && rl_filename_dequoting_function &&
-	       pcomp_curtxt && text &&
-	       STREQ (pcomp_curtxt, text) == 0 &&
-	       variable_context &&
-	       sh_contains_quotes (text))	/* guess */
-	dfn = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
-      else
-	dfn = savestring (text);
-    }
-
-  return (rl_filename_completion_function (dfn, state));
-}
-
-#define GEN_COMPS(bmap, flag, it, text, glist, tlist) \
-  do { \
-    if (bmap & flag) \
-      { \
-	tlist = gen_matches_from_itemlist (it, text); \
-	if (tlist) \
-	  { \
-	    glist = strlist_append (glist, tlist); \
-	    strlist_dispose (tlist); \
-	  } \
-      } \
-  } while (0)
-
-#define GEN_XCOMPS(bmap, flag, text, func, cmatches, glist, tlist) \
-  do { \
-    if (bmap & flag) \
-      { \
-	cmatches = rl_completion_matches (text, func); \
-	tlist = completions_to_stringlist (cmatches); \
-	glist = strlist_append (glist, tlist); \
-	strvec_dispose (cmatches); \
-	strlist_dispose (tlist); \
-      } \
-  } while (0)
-
-/* Functions to generate lists of matches from the actions member of CS. */
-
-static STRINGLIST *
-gen_action_completions (cs, text)
-     COMPSPEC *cs;
-     const char *text;
-{
-  STRINGLIST *ret, *tmatches;
-  char **cmatches;	/* from rl_completion_matches ... */
-  unsigned long flags;
-  int t;
-
-  ret = tmatches = (STRINGLIST *)NULL;
-  flags = cs->actions;
-
-  GEN_COMPS (flags, CA_ALIAS, &it_aliases, text, ret, tmatches);
-  GEN_COMPS (flags, CA_ARRAYVAR, &it_arrayvars, text, ret, tmatches);
-  GEN_COMPS (flags, CA_BINDING, &it_bindings, text, ret, tmatches);
-  GEN_COMPS (flags, CA_BUILTIN, &it_builtins, text, ret, tmatches);
-  GEN_COMPS (flags, CA_DISABLED, &it_disabled, text, ret, tmatches);
-  GEN_COMPS (flags, CA_ENABLED, &it_enabled, text, ret, tmatches);
-  GEN_COMPS (flags, CA_EXPORT, &it_exports, text, ret, tmatches);
-  GEN_COMPS (flags, CA_FUNCTION, &it_functions, text, ret, tmatches);
-  GEN_COMPS (flags, CA_HELPTOPIC, &it_helptopics, text, ret, tmatches);
-  GEN_COMPS (flags, CA_HOSTNAME, &it_hostnames, text, ret, tmatches);
-  GEN_COMPS (flags, CA_JOB, &it_jobs, text, ret, tmatches);
-  GEN_COMPS (flags, CA_KEYWORD, &it_keywords, text, ret, tmatches);
-  GEN_COMPS (flags, CA_RUNNING, &it_running, text, ret, tmatches);
-  GEN_COMPS (flags, CA_SETOPT, &it_setopts, text, ret, tmatches);
-  GEN_COMPS (flags, CA_SHOPT, &it_shopts, text, ret, tmatches);
-  GEN_COMPS (flags, CA_SIGNAL, &it_signals, text, ret, tmatches);
-  GEN_COMPS (flags, CA_STOPPED, &it_stopped, text, ret, tmatches);
-  GEN_COMPS (flags, CA_VARIABLE, &it_variables, text, ret, tmatches);
-
-  GEN_XCOMPS(flags, CA_COMMAND, text, command_word_completion_function, cmatches, ret, tmatches);
-  GEN_XCOMPS(flags, CA_FILE, text, pcomp_filename_completion_function, cmatches, ret, tmatches);
-  GEN_XCOMPS(flags, CA_USER, text, rl_username_completion_function, cmatches, ret, tmatches);
-  GEN_XCOMPS(flags, CA_GROUP, text, bash_groupname_completion_function, cmatches, ret, tmatches);
-  GEN_XCOMPS(flags, CA_SERVICE, text, bash_servicename_completion_function, cmatches, ret, tmatches);
-
-  /* And lastly, the special case for directories */
-  if (flags & CA_DIRECTORY)
-    {
-      t = rl_filename_completion_desired;
-      rl_completion_mark_symlink_dirs = 1;	/* override user preference */
-      cmatches = bash_directory_completion_matches (text);
-      /* If we did not want filename completion before this, and there are
-	 no matches, turn off rl_filename_completion_desired so whatever
-	 matches we get are not treated as filenames (it gets turned on by
-	 rl_filename_completion_function unconditionally). */
-      if (t == 0 && cmatches == 0 && rl_filename_completion_desired == 1)
-        rl_filename_completion_desired = 0;
-      tmatches = completions_to_stringlist (cmatches);
-      ret = strlist_append (ret, tmatches);
-      strvec_dispose (cmatches);
-      strlist_dispose (tmatches);
-    }
-
-  return ret;
-}
-
-/* Generate a list of matches for CS->globpat.  Unresolved: should this use
-   TEXT as a match prefix, or just go without?  Currently, the code does not
-   use TEXT, just globs CS->globpat and returns the results.  If we do decide
-   to use TEXT, we should call quote_string_for_globbing before the call to
-   glob_filename (in which case we could use shell_glob_filename). */
-static STRINGLIST *
-gen_globpat_matches (cs, text)
-      COMPSPEC *cs;
-      const char *text;
-{
-  STRINGLIST *sl;
-  int gflags;
-
-  sl = strlist_create (0);
-  gflags = glob_star ? GX_GLOBSTAR : 0;
-  sl->list = glob_filename (cs->globpat, gflags);
-  if (GLOB_FAILED (sl->list))
-    sl->list = (char **)NULL;
-  if (sl->list)
-    sl->list_len = sl->list_size = strvec_len (sl->list);
-  return sl;
-}
-
-/* Perform the shell word expansions on CS->words and return the results.
-   Again, this ignores TEXT. */
-static STRINGLIST *
-gen_wordlist_matches (cs, text)
-     COMPSPEC *cs;
-     const char *text;
-{
-  WORD_LIST *l, *l2;
-  STRINGLIST *sl;
-  int nw, tlen;
-  char *ntxt;		/* dequoted TEXT to use in comparisons */
-
-  if (cs->words == 0 || cs->words[0] == '\0')
-    return ((STRINGLIST *)NULL);
-
-  /* This used to be a simple expand_string(cs->words, 0), but that won't
-     do -- there's no way to split a simple list into individual words
-     that way, since the shell semantics say that word splitting is done
-     only on the results of expansion.  split_at_delims also handles embedded
-     quoted strings and preserves the quotes for the expand_words_shellexp
-     function call that follows. */
-  /* XXX - this is where this function spends most of its time */
-  l = split_at_delims (cs->words, strlen (cs->words), (char *)NULL, -1, 0, (int *)NULL, (int *)NULL);
-  if (l == 0)
-    return ((STRINGLIST *)NULL);
-  /* This will jump back to the top level if the expansion fails... */
-  l2 = expand_words_shellexp (l);
-  dispose_words (l);
-
-  nw = list_length (l2);
-  sl = strlist_create (nw + 1);
-
-  ntxt = bash_dequote_text (text);
-  tlen = STRLEN (ntxt);
-
-  for (nw = 0, l = l2; l; l = l->next)
-    {
-      if (tlen == 0 || STREQN (l->word->word, ntxt, tlen))
-	sl->list[nw++] = STRDUP (l->word->word);
-    }
-  sl->list[sl->list_len = nw] = (char *)NULL;
-
-  dispose_words (l2);
-  FREE (ntxt);
-  return sl;
-}
-
-#ifdef ARRAY_VARS
-
-static SHELL_VAR *
-bind_comp_words (lwords)
-     WORD_LIST *lwords;
-{
-  SHELL_VAR *v;
-
-  v = find_variable_noref ("COMP_WORDS");
-  if (v == 0)
-    v = make_new_array_variable ("COMP_WORDS");
-  if (nameref_p (v))
-    VUNSETATTR (v, att_nameref);
-#if 0
-  if (readonly_p (v))
-    VUNSETATTR (v, att_readonly);
-#endif
-  if (array_p (v) == 0)
-    v = convert_var_to_array (v);
-  v = assign_array_var_from_word_list (v, lwords, 0);
-
-  VUNSETATTR (v, att_invisible);
-  return v;
-}
-#endif /* ARRAY_VARS */
-
-static void
-bind_compfunc_variables (line, ind, lwords, cw, exported)
-     char *line;
-     int ind;
-     WORD_LIST *lwords;
-     int cw, exported;
-{
-  char ibuf[INT_STRLEN_BOUND(int) + 1];
-  char *value;
-  SHELL_VAR *v;
-  size_t llen;
-  int c;
-
-  /* Set the variables that the function expects while it executes.  Maybe
-     these should be in the function environment (temporary_env). */
-  v = bind_variable ("COMP_LINE", line, 0);
-  if (v && exported)
-    VSETATTR(v, att_exported);
-
-  /* Post bash-4.2: COMP_POINT is characters instead of bytes. */
-  c = line[ind];
-  line[ind] = '\0';
-  llen = MB_STRLEN (line);
-  line[ind] = c;
-  value = inttostr (llen, ibuf, sizeof(ibuf));
-  v = bind_int_variable ("COMP_POINT", value, 0);
-  if (v && exported)
-    VSETATTR(v, att_exported);
-
-  value = inttostr (rl_completion_type, ibuf, sizeof (ibuf));
-  v = bind_int_variable ("COMP_TYPE", value, 0);
-  if (v && exported)
-    VSETATTR(v, att_exported);
-
-  value = inttostr (rl_completion_invoking_key, ibuf, sizeof (ibuf));
-  v = bind_int_variable ("COMP_KEY", value, 0);
-  if (v && exported)
-    VSETATTR(v, att_exported);
-
-  /* Since array variables can't be exported, we don't bother making the
-     array of words. */
-  if (exported == 0)
-    {
-#ifdef ARRAY_VARS
-      v = bind_comp_words (lwords);
-      value = inttostr (cw, ibuf, sizeof(ibuf));
-      bind_int_variable ("COMP_CWORD", value, 0);
-#endif
-    }
-  else
-    array_needs_making = 1;
-}
-
-static void
-unbind_compfunc_variables (exported)
-     int exported;
-{
-  unbind_variable_noref ("COMP_LINE");
-  unbind_variable_noref ("COMP_POINT");
-  unbind_variable_noref ("COMP_TYPE");
-  unbind_variable_noref ("COMP_KEY");
-#ifdef ARRAY_VARS
-  unbind_variable_noref ("COMP_WORDS");
-  unbind_variable_noref ("COMP_CWORD");
-#endif
-  if (exported)
-    array_needs_making = 1;
-}
-
-/* Build the list of words to pass to a function or external command
-   as arguments.  When the function or command is invoked,
-
-	$0 == function or command being invoked
-   	$1 == command name
-   	$2 == word to be completed (possibly null)
-   	$3 == previous word
-
-   Functions can access all of the words in the current command line
-   with the COMP_WORDS array.  External commands cannot; they have to
-   make do with the COMP_LINE and COMP_POINT variables. */
-
-static WORD_LIST *
-build_arg_list (cmd, cname, text, lwords, ind)
-     char *cmd;
-     const char *cname;
-     const char *text;
-     WORD_LIST *lwords;
-     int ind;
-{
-  WORD_LIST *ret, *cl, *l;
-  WORD_DESC *w;
-  int i;
-
-  ret = (WORD_LIST *)NULL;
-  w = make_word (cmd);
-  ret = make_word_list (w, (WORD_LIST *)NULL);	/* $0 */
-
-  w = make_word (cname);			/* $1 */
-  cl = ret->next = make_word_list (w, (WORD_LIST *)NULL);
-
-  w = make_word (text);
-  cl->next = make_word_list (w, (WORD_LIST *)NULL);	/* $2 */
-  cl = cl->next;
-
-  /* Search lwords for current word */
-  for (l = lwords, i = 1; l && i < ind-1; l = l->next, i++)
-    ;
-  w = (l && l->word) ? copy_word (l->word) : make_word ("");
-  cl->next = make_word_list (w, (WORD_LIST *)NULL);
-
-  return ret;
-}
-
-/* Build a command string with
-	$0 == cs->funcname	(function to execute for completion list)
-   	$1 == command name	(command being completed)
-   	$2 = word to be completed (possibly null)
-   	$3 = previous word
-   and run in the current shell.  The function should put its completion
-   list into the array variable COMPREPLY.  We build a STRINGLIST
-   from the results and return it.
-
-   Since the shell function should return its list of matches in an array
-   variable, this does nothing if arrays are not compiled into the shell. */
-
-static STRINGLIST *
-gen_shell_function_matches (cs, cmd, text, line, ind, lwords, nw, cw, foundp)
-     COMPSPEC *cs;
-     const char *cmd;
-     const char *text;
-     char *line;
-     int ind;
-     WORD_LIST *lwords;
-     int nw, cw;
-     int *foundp;
-{
-  char *funcname;
-  STRINGLIST *sl;
-  SHELL_VAR *f, *v;
-  WORD_LIST *cmdlist;
-  int fval, found;
-  sh_parser_state_t ps;
-  sh_parser_state_t * restrict pps;
-#if defined (ARRAY_VARS)
-  ARRAY *a;
-#endif
-
-  found = 0;
-  if (foundp)
-    *foundp = found;
-
-  funcname = cs->funcname;
-  f = find_function (funcname);
-  if (f == 0)
-    {
-      internal_error (_("completion: function `%s' not found"), funcname);
-      rl_ding ();
-      rl_on_new_line ();
-      return ((STRINGLIST *)NULL);
-    }
-
-#if !defined (ARRAY_VARS)
-  return ((STRINGLIST *)NULL);
-#else
-
-  /* We pass cw - 1 because command_line_to_word_list returns indices that are
-     1-based, while bash arrays are 0-based. */
-  bind_compfunc_variables (line, ind, lwords, cw - 1, 0);
-
-  cmdlist = build_arg_list (funcname, cmd, text, lwords, cw);
-
-  pps = &ps;
-  save_parser_state (pps);
-  begin_unwind_frame ("gen-shell-function-matches");
-  add_unwind_protect (restore_parser_state, (char *)pps);
-  add_unwind_protect (dispose_words, (char *)cmdlist);
-  add_unwind_protect (unbind_compfunc_variables, (char *)0);
-
-  fval = execute_shell_function (f, cmdlist);  
-
-  discard_unwind_frame ("gen-shell-function-matches");
-  restore_parser_state (pps);
-
-  found = fval != EX_NOTFOUND;
-  if (fval == EX_RETRYFAIL)
-    found |= PCOMP_RETRYFAIL;
-  if (foundp)
-    *foundp = found;
-
-  /* Now clean up and destroy everything. */
-  dispose_words (cmdlist);
-  unbind_compfunc_variables (0);
-
-  /* The list of completions is returned in the array variable COMPREPLY. */
-  v = find_variable ("COMPREPLY");
-  if (v == 0)
-    return ((STRINGLIST *)NULL);
-  if (array_p (v) == 0 && assoc_p (v) == 0)
-    v = convert_var_to_array (v);
-
-  VUNSETATTR (v, att_invisible);
-
-  a = array_cell (v);
-  if (found == 0 || (found & PCOMP_RETRYFAIL) || a == 0 || array_p (v) == 0 || array_empty (a))
-    sl = (STRINGLIST *)NULL;
-  else
-    {
-      /* XXX - should we filter the list of completions so only those matching
-	 TEXT are returned?  Right now, we do not. */
-      sl = strlist_create (0);
-      sl->list = array_to_argv (a, 0);
-      sl->list_len = sl->list_size = array_num_elements (a);
-    }
-
-  /* XXX - should we unbind COMPREPLY here? */
-  unbind_variable_noref ("COMPREPLY");
-
-  return (sl);
-#endif
-}
-
-/* Build a command string with
-	$0 == cs->command	(command to execute for completion list)
-   	$1 == command name	(command being completed)
-	$2 == word to be completed (possibly null)
-	$3 == previous word
-   and run it with command substitution.  Parse the results, one word
-   per line, with backslashes allowed to escape newlines.  Build a
-   STRINGLIST from the results and return it. */
-
-static STRINGLIST *
-gen_command_matches (cs, cmd, text, line, ind, lwords, nw, cw)
-     COMPSPEC *cs;
-     const char *cmd;
-     const char *text;
-     char *line;
-     int ind;
-     WORD_LIST *lwords;
-     int nw, cw;
-{
-  char *csbuf, *cscmd, *t;
-  int cmdlen, cmdsize, n, ws, we;
-  WORD_LIST *cmdlist, *cl;
-  WORD_DESC *tw;
-  STRINGLIST *sl;
-
-  bind_compfunc_variables (line, ind, lwords, cw, 1);
-  cmdlist = build_arg_list (cs->command, cmd, text, lwords, cw);
-
-  /* Estimate the size needed for the buffer. */
-  n = strlen (cs->command);
-  cmdsize = n + 1;
-  for (cl = cmdlist->next; cl; cl = cl->next)
-    cmdsize += STRLEN (cl->word->word) + 3;
-  cmdsize += 2;
-
-  /* allocate the string for the command and fill it in. */
-  cscmd = (char *)xmalloc (cmdsize + 1);
-
-  strcpy (cscmd, cs->command);			/* $0 */
-  cmdlen = n;
-  cscmd[cmdlen++] = ' ';
-  for (cl = cmdlist->next; cl; cl = cl->next)   /* $1, $2, $3, ... */
-    {
-      t = sh_single_quote (cl->word->word ? cl->word->word : "");
-      n = strlen (t);
-      RESIZE_MALLOCED_BUFFER (cscmd, cmdlen, n + 2, cmdsize, 64);
-      strcpy (cscmd + cmdlen, t);
-      cmdlen += n;
-      if (cl->next)
-	cscmd[cmdlen++] = ' ';
-      free (t);
-    }
-  cscmd[cmdlen] = '\0';
-
-  tw = command_substitute (cscmd, 0, 0);
-  csbuf = tw ? tw->word : (char *)NULL;
-  if (tw)
-    dispose_word_desc (tw);
-
-  /* Now clean up and destroy everything. */
-  dispose_words (cmdlist);
-  free (cscmd);
-  unbind_compfunc_variables (1);
-
-  if (csbuf == 0 || *csbuf == '\0')
-    {
-      FREE (csbuf);
-      return ((STRINGLIST *)NULL);
-    }
-
-  /* Now break CSBUF up at newlines, with backslash allowed to escape a
-     newline, and put the individual words into a STRINGLIST. */
-  sl = strlist_create (16);
-  for (ws = 0; csbuf[ws]; )
-    {
-      we = ws;
-      while (csbuf[we] && csbuf[we] != '\n')
-	{
-	  if (csbuf[we] == '\\' && csbuf[we+1] == '\n')
-	    we++;
-	  we++;
-	}
-      t = substring (csbuf, ws, we);
-      if (sl->list_len >= sl->list_size - 1)
-	strlist_resize (sl, sl->list_size + 16);
-      sl->list[sl->list_len++] = t;
-      while (csbuf[we] == '\n') we++;
-      ws = we;
-    }
-  sl->list[sl->list_len] = (char *)NULL;
-
-  free (csbuf);
-  return (sl);
-}
-
-static WORD_LIST *
-command_line_to_word_list (line, llen, sentinel, nwp, cwp)
-     char *line;
-     int llen, sentinel, *nwp, *cwp;
-{
-  WORD_LIST *ret;
-  const char *delims;
-
-#if 0
-  delims = "()<>;&| \t\n";	/* shell metacharacters break words */
-#else
-  delims = rl_completer_word_break_characters;
-#endif
-  ret = split_at_delims (line, llen, delims, sentinel, SD_NOQUOTEDELIM|SD_COMPLETE, nwp, cwp);
-  return (ret);
-}
-
-/* Evaluate COMPSPEC *cs and return all matches for WORD. */
-
-STRINGLIST *
-gen_compspec_completions (cs, cmd, word, start, end, foundp)
-     COMPSPEC *cs;
-     const char *cmd;
-     const char *word;
-     int start, end;
-     int *foundp;
-{
-  STRINGLIST *ret, *tmatches;
-  char *line;
-  int llen, nw, cw, found, foundf;
-  WORD_LIST *lwords;
-  WORD_DESC *lw;
-  COMPSPEC *tcs;
-
-  found = 1;
-
-#ifdef DEBUG
-  debug_printf ("gen_compspec_completions (%s, %s, %d, %d)", cmd, word, start, end);
-  debug_printf ("gen_compspec_completions: %s -> %p", cmd, cs);
-#endif
-  ret = gen_action_completions (cs, word);
-#ifdef DEBUG
-  if (ret && progcomp_debug)
-    {
-      debug_printf ("gen_action_completions (%p, %s) -->", cs, word);
-      strlist_print (ret, "\t");
-      rl_on_new_line ();
-    }
-#endif
-
-  /* Now we start generating completions based on the other members of CS. */
-  if (cs->globpat)
-    {
-      tmatches = gen_globpat_matches (cs, word);
-      if (tmatches)
-	{
-#ifdef DEBUG
-	  if (progcomp_debug)
-	    {
-	      debug_printf ("gen_globpat_matches (%p, %s) -->", cs, word);
-	      strlist_print (tmatches, "\t");
-	      rl_on_new_line ();
-	    }
-#endif
-	  ret = strlist_append (ret, tmatches);
-	  strlist_dispose (tmatches);
-	  rl_filename_completion_desired = 1;
-	}
-    }
-
-  if (cs->words)
-    {
-      tmatches = gen_wordlist_matches (cs, word);
-      if (tmatches)
-	{
-#ifdef DEBUG
-	  if (progcomp_debug)
-	    {
-	      debug_printf ("gen_wordlist_matches (%p, %s) -->", cs, word);
-	      strlist_print (tmatches, "\t");
-	      rl_on_new_line ();
-	    }
-#endif
-	  ret = strlist_append (ret, tmatches);
-	  strlist_dispose (tmatches);
-	}
-    }
-
-  lwords = (WORD_LIST *)NULL;
-  line = (char *)NULL;
-  if (cs->command || cs->funcname)
-    {
-      /* If we have a command or function to execute, we need to first break
-	 the command line into individual words, find the number of words,
-	 and find the word in the list containing the word to be completed. */
-      line = substring (pcomp_line, start, end);
-      llen = end - start;
-
-#ifdef DEBUG
-      debug_printf ("command_line_to_word_list (%s, %d, %d, %p, %p)",
-		line, llen, pcomp_ind - start, &nw, &cw);
-#endif
-      lwords = command_line_to_word_list (line, llen, pcomp_ind - start, &nw, &cw);
-      /* If we skipped a NULL word at the beginning of the line, add it back */
-      if (lwords && lwords->word && cmd[0] == 0 && lwords->word->word[0] != 0)
-	{
-	  lw = make_bare_word (cmd);
-	  lwords = make_word_list (lw, lwords);
-	  nw++;
-	  cw++;
-	}
-#ifdef DEBUG
-      if (lwords == 0 && llen > 0)
-	debug_printf ("ERROR: command_line_to_word_list returns NULL");
-      else if (progcomp_debug)
-	{
-	  debug_printf ("command_line_to_word_list -->");
-	  printf ("\t");
-	  print_word_list (lwords, "!");
-	  printf ("\n");
-	  fflush(stdout);
-	  rl_on_new_line ();
-	}
-#endif
-    }
-
-  if (cs->funcname)
-    {
-      foundf = 0;
-      tmatches = gen_shell_function_matches (cs, cmd, word, line, pcomp_ind - start, lwords, nw, cw, &foundf);
-      if (foundf != 0)
-	found = foundf;
-      if (tmatches)
-	{
-#ifdef DEBUG
-	  if (progcomp_debug)
-	    {
-	      debug_printf ("gen_shell_function_matches (%p, %s, %s, %p, %d, %d) -->", cs, cmd, word, lwords, nw, cw);
-	      strlist_print (tmatches, "\t");
-	      rl_on_new_line ();
-	    }
-#endif
-	  ret = strlist_append (ret, tmatches);
-	  strlist_dispose (tmatches);
-	}
-    }
-
-  if (cs->command)
-    {
-      tmatches = gen_command_matches (cs, cmd, word, line, pcomp_ind - start, lwords, nw, cw);
-      if (tmatches)
-	{
-#ifdef DEBUG
-	  if (progcomp_debug)
-	    {
-	      debug_printf ("gen_command_matches (%p, %s, %s, %p, %d, %d) -->", cs, cmd, word, lwords, nw, cw);
-	      strlist_print (tmatches, "\t");
-	      rl_on_new_line ();
-	    }
-#endif
-	  ret = strlist_append (ret, tmatches);
-	  strlist_dispose (tmatches);
-	}
-    }
-
-  if (cs->command || cs->funcname)
-    {
-      if (lwords)
-	dispose_words (lwords);
-      FREE (line);
-    }
-
-  if (foundp)
-    *foundp = found;
-
-  if (found == 0 || (found & PCOMP_RETRYFAIL))
-    {
-      strlist_dispose (ret);
-      return NULL;
-    }
-
-  if (cs->filterpat)
-    {
-      tmatches = filter_stringlist (ret, cs->filterpat, word);
-#ifdef DEBUG
-      if (progcomp_debug)
-	{
-	  debug_printf ("filter_stringlist (%p, %s, %s) -->", ret, cs->filterpat, word);
-	  strlist_print (tmatches, "\t");
-	  rl_on_new_line ();
-	}
-#endif
-      if (ret && ret != tmatches)
-	{
-	  FREE (ret->list);
-	  free (ret);
-	}
-      ret = tmatches;
-    }
-
-  if (cs->prefix || cs->suffix)
-    ret = strlist_prefix_suffix (ret, cs->prefix, cs->suffix);
-
-  /* If no matches have been generated and the user has specified that
-      directory completion should be done as a default, call
-      gen_action_completions again to generate a list of matching directory
-      names. */
-  if ((ret == 0 || ret->list_len == 0) && (cs->options & COPT_DIRNAMES))
-    {
-      tcs = compspec_create ();
-      tcs->actions = CA_DIRECTORY;
-      FREE (ret);
-      ret = gen_action_completions (tcs, word);
-      compspec_dispose (tcs);
-    }
-  else if (cs->options & COPT_PLUSDIRS)
-    {
-      tcs = compspec_create ();
-      tcs->actions = CA_DIRECTORY;
-      tmatches = gen_action_completions (tcs, word);
-      ret = strlist_append (ret, tmatches);
-      strlist_dispose (tmatches);
-      compspec_dispose (tcs);
-    }
-
-  return (ret);
-}
-
-void
-pcomp_set_readline_variables (flags, nval)
-     int flags, nval;
-{
-  /* If the user specified that the compspec returns filenames, make
-     sure that readline knows it. */
-  if (flags & COPT_FILENAMES)
-    rl_filename_completion_desired = nval;
-  /* If the user doesn't want a space appended, tell readline. */
-  if (flags & COPT_NOSPACE)
-    rl_completion_suppress_append = nval;
-  /* The value here is inverted, since the default is on and the `noquote'
-     option is supposed to turn it off */
-  if (flags & COPT_NOQUOTE)
-    rl_filename_quoting_desired = 1 - nval;
-  if (flags & COPT_NOSORT)
-    rl_sort_completion_matches = 1 - nval;
-}
-
-/* Set or unset FLAGS in the options word of the current compspec.
-   SET_OR_UNSET is 1 for setting, 0 for unsetting. */
-void
-pcomp_set_compspec_options (cs, flags, set_or_unset)
-     COMPSPEC *cs;
-     int flags, set_or_unset;
-{
-  if (cs == 0 && ((cs = pcomp_curcs) == 0))
-    return;
-  if (set_or_unset)
-    cs->options |= flags;
-  else
-    cs->options &= ~flags;
-}
-
-static STRINGLIST *
-gen_progcomp_completions (ocmd, cmd, word, start, end, foundp, retryp, lastcs)
-     const char *ocmd;
-     const char *cmd;
-     const char *word;
-     int start, end;
-     int *foundp, *retryp;
-     COMPSPEC **lastcs;
-{
-  COMPSPEC *cs, *oldcs;
-  const char *oldcmd, *oldtxt;
-  STRINGLIST *ret;
-
-  cs = progcomp_search (ocmd);
-
-  if (cs == 0 || cs == *lastcs)
-    {
-#if 0
-      if (foundp)
-	*foundp = 0;
-#endif
-      return (NULL);
-    }
-
-  if (*lastcs)
-    compspec_dispose (*lastcs);
-  cs->refcount++;	/* XXX */
-  *lastcs = cs;
-
-  cs = compspec_copy (cs);
-
-  oldcs = pcomp_curcs;
-  oldcmd = pcomp_curcmd;
-  oldtxt = pcomp_curtxt;
-
-  pcomp_curcs = cs;
-  pcomp_curcmd = cmd;
-  pcomp_curtxt = word;
-
-  ret = gen_compspec_completions (cs, cmd, word, start, end, foundp);
-
-  pcomp_curcs = oldcs;
-  pcomp_curcmd = oldcmd;
-  pcomp_curtxt = oldtxt;
-
-  /* We need to conditionally handle setting *retryp here */
-  if (retryp)
-    *retryp = foundp && (*foundp & PCOMP_RETRYFAIL);    	
-
-  if (foundp)
-    {
-      *foundp &= ~PCOMP_RETRYFAIL;
-      *foundp |= cs->options;
-    }
-
-  compspec_dispose (cs);
-  return ret;  
-}
-
-/* The driver function for the programmable completion code.  Returns a list
-   of matches for WORD, which is an argument to command CMD.  START and END
-   bound the command currently being completed in pcomp_line (usually
-   rl_line_buffer). */
-char **
-programmable_completions (cmd, word, start, end, foundp)
-     const char *cmd;
-     const char *word;
-     int start, end, *foundp;
-{
-  COMPSPEC *lastcs;
-  STRINGLIST *ret;
-  char **rmatches, *t;
-  int found, retry, count;
-  char *ocmd;
-  int oend;
-#if defined (ALIAS)
-  alias_t *al;
-#endif
-
-  lastcs = 0;
-  found = count = 0;
-
-  pcomp_line = rl_line_buffer;
-  pcomp_ind = rl_point;
-
-  ocmd = (char *)cmd;
-  oend = end;
-
-  do
-    {
-      retry = 0;
-
-      /* We look at the basename of CMD if the full command does not have
-	 an associated COMPSPEC. */
-      ret = gen_progcomp_completions (ocmd, ocmd, word, start, oend, &found, &retry, &lastcs);
-      if (found == 0)
-	{
-	  t = strrchr (ocmd, '/');
-	  if (t && *(++t))
-	    ret = gen_progcomp_completions (t, ocmd, word, start, oend, &found, &retry, &lastcs);
-	}
-
-      if (found == 0)
-	ret = gen_progcomp_completions (DEFAULTCMD, ocmd, word, start, oend, &found, &retry, &lastcs);
-
-#if defined (ALIAS)
-      /* Look up any alias for CMD, try to gen completions for it */
-      /* Look up the alias, find the value, build a new line replacing CMD
-	 with that value, offsetting PCOMP_IND and END appropriately, reset
-	 PCOMP_LINE to the new line and OCMD with the new command name, then
-	 call gen_progcomp_completions again. We could use alias_expand for
-	 this, but it does more (and less) than we need right now. */
-      if (found == 0 && retry == 0 && progcomp_alias && (al = find_alias (ocmd)))
-	{
-	  char *ncmd, *nline, *ntxt;
-	  int ind, lendiff;
-	  size_t nlen, olen, llen;
-
-	  /* We found an alias for OCMD. Take the value and build a new line */
-	  ntxt = al->value;
-	  nlen = strlen (ntxt);
-	  if (nlen == 0)
-	    break;
-	  olen = strlen (ocmd);
-	  lendiff = nlen - olen;	/* can be negative */
-	  llen = strlen (pcomp_line);
-
-	  nline = (char *)xmalloc (llen + lendiff + 1);
-	  if (start > 0)
-	    strncpy (nline, pcomp_line, start);
-	  strncpy (nline + start, ntxt, nlen);
-	  strcpy (nline + start + nlen, pcomp_line + start + olen);
-
-	  /* Find the first word of the alias value and use that as OCMD. We
-	     don't check the alias value to see whether it begins with a valid
-	     command name, so this can be fooled. */
-	  ind = skip_to_delim (ntxt, 0, "()<>;&| \t\n", SD_NOJMP|SD_COMPLETE);
-	  if (ind > 0)
-	    ncmd = substring (ntxt, 0, ind);
-	  else
-	    {
-	      free (nline);
-	      break;		/* will free pcomp_line and ocmd later */
-	    }
-
-	  /* Adjust PCOMP_IND and OEND appropriately */
-	  pcomp_ind += lendiff;
-	  oend += lendiff;
-
-	  /* Set up values with new line. WORD stays the same. */
-	  if (ocmd != cmd)
-	    free (ocmd);
-	  if (pcomp_line != rl_line_buffer)
-	    free (pcomp_line);
-
-	  ocmd = ncmd;
-	  pcomp_line = nline;
-
-	  /* And go back and start over. */
-	  retry = 1;
-	}
-#endif /* ALIAS */
-
-      count++;
-
-      if (count > 32)
-	{
-	  internal_warning (_("programmable_completion: %s: possible retry loop"), cmd);
-	  break;
-	}
-    }
-  while (retry);
-
-  if (pcomp_line != rl_line_buffer)
-    free (pcomp_line);
-  if (ocmd != cmd)
-    free (ocmd);
-
-  if (ret)
-    {
-      rmatches = ret->list;
-      free (ret);
-    }
-  else
-    rmatches = (char **)NULL;
-
-  if (foundp)
-    *foundp = found;
-
-  if (lastcs)	/* XXX - should be while? */
-    compspec_dispose (lastcs);
-
-  /* XXX restore pcomp_line and pcomp_ind? */
-  pcomp_line = rl_line_buffer;
-  pcomp_ind = rl_point;
-
-  return (rmatches);
-}
-
-#endif /* PROGRAMMABLE_COMPLETION */
diff --git a/third_party/bash/pcomplete.h b/third_party/bash/pcomplete.h
deleted file mode 100644
index 2a68e6a3f..000000000
--- a/third_party/bash/pcomplete.h
+++ /dev/null
@@ -1,177 +0,0 @@
-/* pcomplete.h - structure definitions and other stuff for programmable
-		 completion. */
-
-/* Copyright (C) 1999-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_PCOMPLETE_H_)
-#  define _PCOMPLETE_H_
-
-#include "stdc.h"
-#include "hashlib.h"
-
-typedef struct compspec {
-  int refcount;
-  unsigned long actions;
-  unsigned long options;
-  char *globpat;
-  char *words;
-  char *prefix;
-  char *suffix;
-  char *funcname;
-  char *command;
-  char *lcommand;
-  char *filterpat;
-} COMPSPEC;
-
-/* Values for COMPSPEC actions.  These are things the shell knows how to
-   build internally. */
-#define CA_ALIAS	(1<<0)
-#define CA_ARRAYVAR	(1<<1)
-#define CA_BINDING	(1<<2)
-#define CA_BUILTIN	(1<<3)
-#define CA_COMMAND	(1<<4)
-#define CA_DIRECTORY	(1<<5)
-#define CA_DISABLED	(1<<6)
-#define CA_ENABLED	(1<<7)
-#define CA_EXPORT	(1<<8)
-#define CA_FILE		(1<<9)
-#define CA_FUNCTION	(1<<10)
-#define CA_GROUP	(1<<11)
-#define CA_HELPTOPIC	(1<<12)
-#define CA_HOSTNAME	(1<<13)
-#define CA_JOB		(1<<14)
-#define CA_KEYWORD	(1<<15)
-#define CA_RUNNING	(1<<16)
-#define CA_SERVICE	(1<<17)
-#define CA_SETOPT	(1<<18)
-#define CA_SHOPT	(1<<19)
-#define CA_SIGNAL	(1<<20)
-#define CA_STOPPED	(1<<21)
-#define CA_USER		(1<<22)
-#define CA_VARIABLE	(1<<23)
-
-/* Values for COMPSPEC options field. */
-#define COPT_RESERVED	(1<<0)		/* reserved for other use */
-#define COPT_DEFAULT	(1<<1)
-#define COPT_FILENAMES	(1<<2)
-#define COPT_DIRNAMES	(1<<3)
-#define COPT_NOQUOTE	(1<<4)
-#define COPT_NOSPACE	(1<<5)
-#define COPT_BASHDEFAULT (1<<6)
-#define COPT_PLUSDIRS	(1<<7)
-#define COPT_NOSORT	(1<<8)
-
-#define COPT_LASTUSER	COPT_NOSORT
-
-#define PCOMP_RETRYFAIL (COPT_LASTUSER << 1)
-#define PCOMP_NOTFOUND	(COPT_LASTUSER << 2)
-
-
-/* List of items is used by the code that implements the programmable
-   completions. */
-typedef struct _list_of_items {
-  int flags;
-  int (*list_getter) PARAMS((struct _list_of_items *));	/* function to call to get the list */
-
-  STRINGLIST *slist;
-
-  /* These may or may not be used. */
-  STRINGLIST *genlist;	/* for handing to the completion code one item at a time */
-  int genindex;		/* index of item last handed to completion code */
-
-} ITEMLIST;
-
-/* Values for ITEMLIST -> flags */
-#define LIST_DYNAMIC		0x001
-#define LIST_DIRTY		0x002
-#define LIST_INITIALIZED	0x004
-#define LIST_MUSTSORT		0x008
-#define LIST_DONTFREE		0x010
-#define LIST_DONTFREEMEMBERS	0x020
-
-#define EMPTYCMD	"_EmptycmD_"
-#define DEFAULTCMD	"_DefaultCmD_"
-#define INITIALWORD	"_InitialWorD_"
-
-extern HASH_TABLE *prog_completes;
-
-extern char *pcomp_line;
-extern int pcomp_ind;
-
-extern int prog_completion_enabled;
-extern int progcomp_alias;
-
-/* Not all of these are used yet. */
-extern ITEMLIST it_aliases;
-extern ITEMLIST it_arrayvars;
-extern ITEMLIST it_bindings;
-extern ITEMLIST it_builtins;
-extern ITEMLIST it_commands;
-extern ITEMLIST it_directories;
-extern ITEMLIST it_disabled;
-extern ITEMLIST it_enabled;
-extern ITEMLIST it_exports;
-extern ITEMLIST it_files;
-extern ITEMLIST it_functions;
-extern ITEMLIST it_groups;
-extern ITEMLIST it_helptopics;
-extern ITEMLIST it_hostnames;
-extern ITEMLIST it_jobs;
-extern ITEMLIST it_keywords;
-extern ITEMLIST it_running;
-extern ITEMLIST it_services;
-extern ITEMLIST it_setopts;
-extern ITEMLIST it_shopts;
-extern ITEMLIST it_signals;
-extern ITEMLIST it_stopped;
-extern ITEMLIST it_users;
-extern ITEMLIST it_variables;
-
-extern COMPSPEC *pcomp_curcs;
-extern const char *pcomp_curcmd;
-
-/* Functions from pcomplib.c */
-extern COMPSPEC *compspec_create PARAMS((void));
-extern void compspec_dispose PARAMS((COMPSPEC *));
-extern COMPSPEC *compspec_copy PARAMS((COMPSPEC *));
-
-extern void progcomp_create PARAMS((void));
-extern void progcomp_flush PARAMS((void));
-extern void progcomp_dispose PARAMS((void));
-
-extern int progcomp_size PARAMS((void));
-
-extern int progcomp_insert PARAMS((char *, COMPSPEC *));
-extern int progcomp_remove PARAMS((char *));
-
-extern COMPSPEC *progcomp_search PARAMS((const char *));
-
-extern void progcomp_walk PARAMS((hash_wfunc *));
-
-/* Functions from pcomplete.c */
-extern void set_itemlist_dirty PARAMS((ITEMLIST *));
-
-extern STRINGLIST *completions_to_stringlist PARAMS((char **));
-
-extern STRINGLIST *gen_compspec_completions PARAMS((COMPSPEC *, const char *, const char *, int, int, int *));
-extern char **programmable_completions PARAMS((const char *, const char *, int, int, int *));
-
-extern void pcomp_set_readline_variables PARAMS((int, int));
-extern void pcomp_set_compspec_options PARAMS((COMPSPEC *, int, int));
-#endif /* _PCOMPLETE_H_ */
diff --git a/third_party/bash/pcomplib.c b/third_party/bash/pcomplib.c
deleted file mode 100644
index f3ecea662..000000000
--- a/third_party/bash/pcomplib.c
+++ /dev/null
@@ -1,228 +0,0 @@
-/* pcomplib.c - library functions for programmable completion. */
-
-/* Copyright (C) 1999-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (PROGRAMMABLE_COMPLETION)
-
-#include "bashansi.h"
-#include <stdio.h>
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "pcomplete.h"
-
-#define COMPLETE_HASH_BUCKETS	512	/* must be power of two */
-
-#define STRDUP(x)	((x) ? savestring (x) : (char *)NULL)
-
-HASH_TABLE *prog_completes = (HASH_TABLE *)NULL;
-
-static void free_progcomp PARAMS((PTR_T));
-
-COMPSPEC *
-compspec_create ()
-{
-  COMPSPEC *ret;
-
-  ret = (COMPSPEC *)xmalloc (sizeof (COMPSPEC));
-  ret->refcount = 0;
-
-  ret->actions = (unsigned long)0;
-  ret->options = (unsigned long)0;
-
-  ret->globpat = (char *)NULL;
-  ret->words = (char *)NULL;
-  ret->prefix = (char *)NULL;
-  ret->suffix = (char *)NULL;
-  ret->funcname = (char *)NULL;
-  ret->command = (char *)NULL;
-  ret->lcommand = (char *)NULL;
-  ret->filterpat = (char *)NULL;
-
-  return ret;
-}
-
-void
-compspec_dispose (cs)
-     COMPSPEC *cs;
-{
-  cs->refcount--;
-  if (cs->refcount == 0)
-    {
-      FREE (cs->globpat);
-      FREE (cs->words);
-      FREE (cs->prefix);
-      FREE (cs->suffix);
-      FREE (cs->funcname);
-      FREE (cs->command);
-      FREE (cs->lcommand);
-      FREE (cs->filterpat);
-
-      free (cs);
-    }
-}
-
-COMPSPEC *
-compspec_copy (cs)
-     COMPSPEC *cs;
-{
-  COMPSPEC *new;
-
-  new = (COMPSPEC *)xmalloc (sizeof (COMPSPEC));
-
-  new->refcount = 1; 	/* was cs->refcount, but this is a fresh copy */
-  new->actions = cs->actions;
-  new->options = cs->options;
-
-  new->globpat = STRDUP (cs->globpat);
-  new->words = STRDUP (cs->words);
-  new->prefix = STRDUP (cs->prefix);
-  new->suffix = STRDUP (cs->suffix);
-  new->funcname = STRDUP (cs->funcname);
-  new->command = STRDUP (cs->command);
-  new->lcommand = STRDUP (cs->lcommand);
-  new->filterpat = STRDUP (cs->filterpat);
-
-  return new;
-}
-
-void
-progcomp_create ()
-{
-  if (prog_completes == 0)
-    prog_completes = hash_create (COMPLETE_HASH_BUCKETS);
-}
-
-int
-progcomp_size ()
-{
-  return (HASH_ENTRIES (prog_completes));
-}
-
-static void
-free_progcomp (data)
-     PTR_T data;
-{
-  COMPSPEC *cs;
-
-  cs = (COMPSPEC *)data;
-  compspec_dispose (cs);
-}
-  
-void
-progcomp_flush ()
-{
-  if (prog_completes)
-    hash_flush (prog_completes, free_progcomp);
-}
-
-void
-progcomp_dispose ()
-{
-  if (prog_completes)
-    hash_dispose (prog_completes);
-  prog_completes = (HASH_TABLE *)NULL;
-}
-
-int
-progcomp_remove (cmd)
-     char *cmd;
-{
-  register BUCKET_CONTENTS *item;
-
-  if (prog_completes == 0)
-    return 1;
-
-  item = hash_remove (cmd, prog_completes, 0);
-  if (item)
-    {
-      if (item->data)
-	free_progcomp (item->data);
-      free (item->key);
-      free (item);
-      return (1);
-    }
-  return (0);
-}
-
-int
-progcomp_insert (cmd, cs)
-      char *cmd;
-      COMPSPEC *cs;
-{
-  register BUCKET_CONTENTS *item;
-
-  if (cs == NULL)
-    programming_error (_("progcomp_insert: %s: NULL COMPSPEC"), cmd);
-
-  if (prog_completes == 0)
-    progcomp_create ();
-
-  cs->refcount++;
-  item = hash_insert (cmd, prog_completes, 0);
-  if (item->data)
-    free_progcomp (item->data);
-  else
-    item->key = savestring (cmd);
-  item->data = cs;
-
-  return 1;
-}
-
-COMPSPEC *
-progcomp_search (cmd)
-     const char *cmd;
-{
-  register BUCKET_CONTENTS *item;
-  COMPSPEC *cs;
-
-  if (prog_completes == 0)
-    return ((COMPSPEC *)NULL);
-
-  item = hash_search (cmd, prog_completes, 0);
-
-  if (item == NULL)
-    return ((COMPSPEC *)NULL);
-
-  cs = (COMPSPEC *)item->data;
-
-  return (cs);
-}
-
-void
-progcomp_walk (pfunc)
-     hash_wfunc *pfunc;
-{
-  if (prog_completes == 0 || pfunc == 0 || HASH_ENTRIES (prog_completes) == 0)
-    return;
-
-  hash_walk (prog_completes, pfunc);
-}
-
-#endif /* PROGRAMMABLE_COMPLETION */
diff --git a/third_party/bash/pipesize.h b/third_party/bash/pipesize.h
deleted file mode 100644
index 816a0b2d1..000000000
--- a/third_party/bash/pipesize.h
+++ /dev/null
@@ -1,8 +0,0 @@
-/*
- * pipesize.h
- *
- * This file is automatically generated by psize.sh
- * Do not edit!
- */
-
-#define PIPESIZE 65536
diff --git a/third_party/bash/posixdir.h b/third_party/bash/posixdir.h
deleted file mode 100644
index b737bd7d1..000000000
--- a/third_party/bash/posixdir.h
+++ /dev/null
@@ -1,71 +0,0 @@
-/* posixdir.h -- Posix directory reading includes and defines. */
-
-/* Copyright (C) 1987,1991,2012,2019,2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* This file should be included instead of <dirent.h> or <sys/dir.h>. */
-
-#if !defined (_POSIXDIR_H_)
-#define _POSIXDIR_H_
-
-#if defined (HAVE_DIRENT_H)
-#  include <dirent.h>
-#  if defined (HAVE_STRUCT_DIRENT_D_NAMLEN)
-#    define D_NAMLEN(d)	((d)->d_namlen)
-#  else
-#    define D_NAMLEN(d)   (strlen ((d)->d_name))
-#  endif /* !HAVE_STRUCT_DIRENT_D_NAMLEN */
-#else
-#  if defined (HAVE_SYS_NDIR_H)
-#    include <sys/ndir.h>
-#  endif
-#  if defined (HAVE_SYS_DIR_H)
-#    include <sys/dir.h>
-#  endif
-#  if defined (HAVE_NDIR_H)
-#    include <ndir.h>
-#  endif
-#  if !defined (dirent)
-#    define dirent direct
-#  endif /* !dirent */
-#  define D_NAMLEN(d)   ((d)->d_namlen)
-#endif /* !HAVE_DIRENT_H */
-
-/* The bash code fairly consistently uses d_fileno; make sure it's available */
-#if defined (HAVE_STRUCT_DIRENT_D_INO) && !defined (HAVE_STRUCT_DIRENT_D_FILENO)
-#  define d_fileno d_ino
-#endif
-
-/* Posix does not require that the d_ino field be present, and some
-   systems do not provide it. */
-#if !defined (HAVE_STRUCT_DIRENT_D_INO) || defined (BROKEN_DIRENT_D_INO)
-#  define REAL_DIR_ENTRY(dp) 1
-#else
-#  define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
-#endif /* _POSIX_SOURCE */
-
-#if defined (HAVE_STRUCT_DIRENT_D_INO) && !defined (BROKEN_DIRENT_D_INO)
-#  define D_INO_AVAILABLE
-#endif
-
-/* Signal the rest of the code that it can safely use dirent.d_fileno */
-#if defined (D_INO_AVAILABLE) || defined (HAVE_STRUCT_DIRENT_D_FILENO)
-#  define D_FILENO_AVAILABLE 1
-#endif
-
-#endif /* !_POSIXDIR_H_ */
diff --git a/third_party/bash/posixjmp.h b/third_party/bash/posixjmp.h
deleted file mode 100644
index 9c7e99ed4..000000000
--- a/third_party/bash/posixjmp.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/* posixjmp.h -- wrapper for setjmp.h with changes for POSIX systems. */
-
-/* Copyright (C) 1987,1991-2015 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _POSIXJMP_H_
-#define _POSIXJMP_H_
-
-#include <setjmp.h>
-
-/* This *must* be included *after* config.h */
-
-#if defined (HAVE_POSIX_SIGSETJMP)
-#  define procenv_t	sigjmp_buf
-
-#  define setjmp_nosigs(x)	sigsetjmp((x), 0)
-#  define setjmp_sigs(x)	sigsetjmp((x), 1)
-
-#  define _rl_longjmp(x, n)	siglongjmp((x), (n))
-#  define sh_longjmp(x, n)	siglongjmp((x), (n))
-#else
-#  define procenv_t	jmp_buf
-
-#  define setjmp_nosigs		setjmp
-#  define setjmp_sigs		setjmp
-
-#  define _rl_longjmp(x, n)	longjmp((x), (n))
-#  define sh_longjmp(x, n)	longjmp((x), (n))
-#endif
-
-#endif /* _POSIXJMP_H_ */
diff --git a/third_party/bash/posixselect.h b/third_party/bash/posixselect.h
deleted file mode 100644
index da6a1ace0..000000000
--- a/third_party/bash/posixselect.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* posixselect.h -- wrapper for select(2) includes and definitions */
-
-/* Copyright (C) 2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _POSIXSELECT_H_
-#define _POSIXSELECT_H_
-
-#if defined (FD_SET) && !defined (HAVE_SELECT)
-#  define HAVE_SELECT 1
-#endif
-
-#if defined (HAVE_SELECT)
-#  if !defined (HAVE_SYS_SELECT_H) || !defined (M_UNIX)
-#    include <sys/time.h>
-#  endif
-#endif /* HAVE_SELECT */
-#if defined (HAVE_SYS_SELECT_H)
-#  include <sys/select.h>
-#endif
-
-#ifndef USEC_PER_SEC
-#  define USEC_PER_SEC 1000000
-#endif
-
-#define USEC_TO_TIMEVAL(us, tv) \
-do { \
-  (tv).tv_sec = (us) / USEC_PER_SEC; \
-  (tv).tv_usec = (us) % USEC_PER_SEC; \
-} while (0)
-
-#endif /* _POSIXSELECT_H_ */
diff --git a/third_party/bash/posixstat.h b/third_party/bash/posixstat.h
deleted file mode 100644
index b60778606..000000000
--- a/third_party/bash/posixstat.h
+++ /dev/null
@@ -1,162 +0,0 @@
-/* posixstat.h -- Posix stat(2) definitions for systems that
-   don't have them. */
-
-/* Copyright (C) 1987-2019 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* This file should be included instead of <sys/stat.h>.
-   It relies on the local sys/stat.h to work though. */
-#if !defined (_POSIXSTAT_H_)
-#define _POSIXSTAT_H_
-
-#include <sys/stat.h>
-
-#if defined (STAT_MACROS_BROKEN)
-#  undef S_ISBLK
-#  undef S_ISCHR
-#  undef S_ISDIR
-#  undef S_ISFIFO
-#  undef S_ISREG
-#  undef S_ISLNK
-#endif /* STAT_MACROS_BROKEN */
-
-/* These are guaranteed to work only on isc386 */
-#if !defined (S_IFDIR) && !defined (S_ISDIR)
-#  define S_IFDIR 0040000
-#endif /* !S_IFDIR && !S_ISDIR */
-#if !defined (S_IFMT)
-#  define S_IFMT  0170000
-#endif /* !S_IFMT */
-
-/* Posix 1003.1 5.6.1.1 <sys/stat.h> file types */
-
-/* Some Posix-wannabe systems define _S_IF* macros instead of S_IF*, but
-   do not provide the S_IS* macros that Posix requires. */
-
-#if defined (_S_IFMT) && !defined (S_IFMT)
-#define S_IFMT _S_IFMT
-#endif
-#if defined (_S_IFIFO) && !defined (S_IFIFO)
-#define S_IFIFO _S_IFIFO
-#endif
-#if defined (_S_IFCHR) && !defined (S_IFCHR)
-#define S_IFCHR _S_IFCHR
-#endif
-#if defined (_S_IFDIR) && !defined (S_IFDIR)
-#define S_IFDIR _S_IFDIR
-#endif
-#if defined (_S_IFBLK) && !defined (S_IFBLK)
-#define S_IFBLK _S_IFBLK
-#endif
-#if defined (_S_IFREG) && !defined (S_IFREG)
-#define S_IFREG _S_IFREG
-#endif
-#if defined (_S_IFLNK) && !defined (S_IFLNK)
-#define S_IFLNK _S_IFLNK
-#endif
-#if defined (_S_IFSOCK) && !defined (S_IFSOCK)
-#define S_IFSOCK _S_IFSOCK
-#endif
-
-/* Test for each symbol individually and define the ones necessary (some
-   systems claiming Posix compatibility define some but not all). */
-
-#if defined (S_IFBLK) && !defined (S_ISBLK)
-#define	S_ISBLK(m)	(((m)&S_IFMT) == S_IFBLK)	/* block device */
-#endif
-
-#if defined (S_IFCHR) && !defined (S_ISCHR)
-#define	S_ISCHR(m)	(((m)&S_IFMT) == S_IFCHR)	/* character device */
-#endif
-
-#if defined (S_IFDIR) && !defined (S_ISDIR)
-#define	S_ISDIR(m)	(((m)&S_IFMT) == S_IFDIR)	/* directory */
-#endif
-
-#if defined (S_IFREG) && !defined (S_ISREG)
-#define	S_ISREG(m)	(((m)&S_IFMT) == S_IFREG)	/* file */
-#endif
-
-#if defined (S_IFIFO) && !defined (S_ISFIFO)
-#define	S_ISFIFO(m)	(((m)&S_IFMT) == S_IFIFO)	/* fifo - named pipe */
-#endif
-
-#if defined (S_IFLNK) && !defined (S_ISLNK)
-#define	S_ISLNK(m)	(((m)&S_IFMT) == S_IFLNK)	/* symbolic link */
-#endif
-
-#if defined (S_IFSOCK) && !defined (S_ISSOCK)
-#define	S_ISSOCK(m)	(((m)&S_IFMT) == S_IFSOCK)	/* socket */
-#endif
-
-/*
- * POSIX 1003.1 5.6.1.2 <sys/stat.h> File Modes
- */
-
-#if !defined (S_IRWXU)
-#  if !defined (S_IREAD)
-#    define S_IREAD	00400
-#    define S_IWRITE	00200
-#    define S_IEXEC	00100
-#  endif /* S_IREAD */
-
-#  if !defined (S_IRUSR)
-#    define S_IRUSR	S_IREAD			/* read, owner */
-#    define S_IWUSR	S_IWRITE		/* write, owner */
-#    define S_IXUSR	S_IEXEC			/* execute, owner */
-
-#    define S_IRGRP	(S_IREAD  >> 3)		/* read, group */
-#    define S_IWGRP	(S_IWRITE >> 3)		/* write, group */
-#    define S_IXGRP	(S_IEXEC  >> 3)		/* execute, group */
-
-#    define S_IROTH	(S_IREAD  >> 6)		/* read, other */
-#    define S_IWOTH	(S_IWRITE >> 6)		/* write, other */
-#    define S_IXOTH	(S_IEXEC  >> 6)		/* execute, other */
-#  endif /* !S_IRUSR */
-
-#  define S_IRWXU	(S_IRUSR | S_IWUSR | S_IXUSR)
-#  define S_IRWXG	(S_IRGRP | S_IWGRP | S_IXGRP)
-#  define S_IRWXO	(S_IROTH | S_IWOTH | S_IXOTH)
-#else /* !S_IRWXU */
-  /* S_IRWXU is defined, but "group" and "other" bits might not be
-     (happens in certain versions of MinGW).  */
-#  if !defined (S_IRGRP)
-#    define S_IRGRP	(S_IREAD  >> 3)		/* read, group */
-#    define S_IWGRP	(S_IWRITE >> 3)		/* write, group */
-#    define S_IXGRP	(S_IEXEC  >> 3)		/* execute, group */
-#  endif /* !S_IRGRP */
-
-#  if !defined (S_IROTH)
-#    define S_IROTH	(S_IREAD  >> 6)		/* read, other */
-#    define S_IWOTH	(S_IWRITE >> 6)		/* write, other */
-#    define S_IXOTH	(S_IEXEC  >> 6)		/* execute, other */
-#  endif /* !S_IROTH */
-#  if !defined (S_IRWXG)
-#    define S_IRWXG	(S_IRGRP | S_IWGRP | S_IXGRP)
-#  endif
-#  if !defined (S_IRWXO)
-#    define S_IRWXO	(S_IROTH | S_IWOTH | S_IXOTH)
-#  endif
-#endif /* !S_IRWXU */
-
-/* These are non-standard, but are used in builtins.c$symbolic_umask() */
-#define S_IRUGO		(S_IRUSR | S_IRGRP | S_IROTH)
-#define S_IWUGO		(S_IWUSR | S_IWGRP | S_IWOTH)
-#define S_IXUGO		(S_IXUSR | S_IXGRP | S_IXOTH)
-
-#endif /* _POSIXSTAT_H_ */
diff --git a/third_party/bash/posixtime.h b/third_party/bash/posixtime.h
deleted file mode 100644
index e70ebec67..000000000
--- a/third_party/bash/posixtime.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/* posixtime.h -- wrapper for time.h, sys/times.h mess. */
-
-/* Copyright (C) 1999-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _POSIXTIME_H_
-#define _POSIXTIME_H_
-
-/* include this after config.h */
-/* Some systems require this, mostly for the definition of `struct timezone'.
-   For example, Dynix/ptx has that definition in <time.h> rather than
-      sys/time.h */
-#if defined (HAVE_SYS_TIME_H)
-#  include <sys/time.h>
-#endif
-#include <time.h>
-
-#if !defined (HAVE_SYSCONF) || !defined (_SC_CLK_TCK)
-#  if !defined (CLK_TCK)
-#    if defined (HZ)
-#      define CLK_TCK	HZ
-#    else
-#      define CLK_TCK	60			/* 60HZ */
-#    endif
-#  endif /* !CLK_TCK */
-#endif /* !HAVE_SYSCONF && !_SC_CLK_TCK */
-
-#if !HAVE_TIMEVAL
-struct timeval
-{
-  time_t tv_sec;
-  long int tv_usec;
-};
-#endif
-
-#if !HAVE_GETTIMEOFDAY
-extern int gettimeofday PARAMS((struct timeval *, void *));
-#endif
-
-/* These exist on BSD systems, at least. */
-#if !defined (timerclear)
-#  define timerclear(tvp)	do { (tvp)->tv_sec = 0; (tvp)->tv_usec = 0; } while (0)
-#endif
-#if !defined (timerisset)
-#  define timerisset(tvp)	((tvp)->tv_sec || (tvp)->tv_usec)
-#endif
-#if !defined (timercmp)
-#  define timercmp(a, b, CMP) \
-	(((a)->tv_sec == (b)->tv_sec) ? ((a)->tv_usec CMP (b)->tv_usec) \
-				      : ((a)->tv_sec CMP (b)->tv_sec))
-#endif
-
-/* These are non-standard. */
-#if !defined (timerisunset)
-#  define timerisunset(tvp)	((tvp)->tv_sec == 0 && (tvp)->tv_usec == 0)
-#endif
-#if !defined (timerset)
-#  define timerset(tvp, s, u)	do { tvp->tv_sec = s; tvp->tv_usec = u; } while (0)
-#endif
-
-#ifndef TIMEVAL_TO_TIMESPEC
-#  define TIMEVAL_TO_TIMESPEC(tv, ts) \
-  do { \
-    (ts)->tv_sec = (tv)->tv_sec; \
-    (ts)->tv_nsec = (tv)->tv_usec * 1000; \
-  } while (0)
-#endif
-
-#endif /* _POSIXTIME_H_ */
diff --git a/third_party/bash/posixwait.h b/third_party/bash/posixwait.h
deleted file mode 100644
index 63b59c24a..000000000
--- a/third_party/bash/posixwait.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/* posixwait.h -- job control definitions from POSIX 1003.1 */
-
-/* Copyright (C) 1997 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_POSIXWAIT_H_)
-#  define _POSIXWAIT_H_
-
-/* If _POSIX_VERSION is not defined, we assume that <sys/wait.h> defines
-   a `union wait' and various macros used to manipulate it.  Look in
-   unionwait.h for the things we expect to find. */
-#if defined (HAVE_SYS_WAIT_H)
-#  include <sys/wait.h>
-#else /* !HAVE_SYS_WAIT_H */
-#  if !defined (_POSIX_VERSION)
-#    include "unionwait.h"
-#  endif
-#endif  /* !HAVE_SYS_WAIT_H */
-
-/* How to get the status of a job.  For Posix, this is just an
-   int, but for other systems we have to crack the union wait. */
-#if !defined (_POSIX_VERSION)
-typedef union wait WAIT;
-#  define WSTATUS(t)  (t.w_status)
-#else /* _POSIX_VERSION */
-typedef int WAIT;
-#  define WSTATUS(t)  (t)
-#endif /* _POSIX_VERSION */
-
-/* Make sure that parameters to wait3 are defined. */
-#if !defined (WNOHANG)
-#  define WNOHANG 1
-#  define WUNTRACED 2
-#endif /* WNOHANG */
-
-/* More Posix P1003.1 definitions.  In the POSIX versions, the parameter is
-   passed as an `int', in the non-POSIX version, as `union wait'. */
-#if defined (_POSIX_VERSION)
-
-#  if !defined (WSTOPSIG)
-#    define WSTOPSIG(s)       ((s) >> 8)
-#  endif /* !WSTOPSIG */
-
-#  if !defined (WTERMSIG)
-#    define WTERMSIG(s)	      ((s) & 0177)
-#  endif /* !WTERMSIG */
-
-#  if !defined (WEXITSTATUS)
-#    define WEXITSTATUS(s)    ((s) >> 8)
-#  endif /* !WEXITSTATUS */
-
-#  if !defined (WIFSTOPPED)
-#    define WIFSTOPPED(s)     (((s) & 0177) == 0177)
-#  endif /* !WIFSTOPPED */
-
-#  if !defined (WIFEXITED)
-#    define WIFEXITED(s)      (((s) & 0377) == 0)
-#  endif /* !WIFEXITED */
-
-#  if !defined (WIFSIGNALED)
-#    define WIFSIGNALED(s)    (!WIFSTOPPED(s) && !WIFEXITED(s))
-#  endif /* !WIFSIGNALED */
-
-#  if !defined (WIFCORED)
-#    if defined (WCOREDUMP)
-#      define WIFCORED(s)	(WCOREDUMP(s))
-#    else
-#      define WIFCORED(s)       ((s) & 0200)
-#    endif
-#  endif /* !WIFCORED */
-
-#else /* !_POSIX_VERSION */
-
-#  if !defined (WSTOPSIG)
-#    define WSTOPSIG(s)	      ((s).w_stopsig)
-#  endif /* !WSTOPSIG */
-
-#  if !defined (WTERMSIG)
-#    define WTERMSIG(s)	      ((s).w_termsig)
-#  endif /* !WTERMSIG */
-
-#  if !defined (WEXITSTATUS)
-#    define WEXITSTATUS(s)    ((s).w_retcode)
-#  endif /* !WEXITSTATUS */
-
-#  if !defined (WIFCORED)
-#    define WIFCORED(s)       ((s).w_coredump)
-#  endif /* !WIFCORED */
-
-#endif /* !_POSIX_VERSION */
-
-#endif /* !_POSIXWAIT_H_ */
diff --git a/third_party/bash/print_cmd.c b/third_party/bash/print_cmd.c
deleted file mode 100644
index e7bffc8cb..000000000
--- a/third_party/bash/print_cmd.c
+++ /dev/null
@@ -1,1654 +0,0 @@
-/* print_command -- A way to make readable commands from a command tree. */
-
-/* Copyright (C) 1989-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <stdio.h>
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#if defined (PREFER_STDARG)
-#  include <stdarg.h>
-#else
-#  include <varargs.h>
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-
-#define NEED_XTRACE_SET_DECL
-
-#include "shell.h"
-#include "flags.h"
-#include "y.tab.h"	/* use <...> so we pick it up from the build directory */
-#include "input.h"
-
-#include "shmbutil.h"
-
-#include "common.h"
-
-#if !HAVE_DECL_PRINTF
-extern int printf PARAMS((const char *, ...));	/* Yuck.  Double yuck. */
-#endif
-
-static int indentation;
-static int indentation_amount = 4;
-
-#if defined (PREFER_STDARG)
-typedef void PFUNC PARAMS((const char *, ...));
-
-static void cprintf PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-static void xprintf PARAMS((const char *, ...))  __attribute__((__format__ (printf, 1, 2)));
-#else
-#define PFUNC VFunction
-static void cprintf ();
-static void xprintf ();
-#endif
-
-static void reset_locals PARAMS((void));
-static void newline PARAMS((char *));
-static void indent PARAMS((int));
-static void semicolon PARAMS((void));
-static void the_printed_command_resize PARAMS((int));
-
-static void make_command_string_internal PARAMS((COMMAND *));
-static void _print_word_list PARAMS((WORD_LIST *, char *, PFUNC *));
-static void command_print_word_list PARAMS((WORD_LIST *, char *));
-static void print_case_clauses PARAMS((PATTERN_LIST *));
-static void print_redirection_list PARAMS((REDIRECT *));
-static void print_redirection PARAMS((REDIRECT *));
-static void print_heredoc_header PARAMS((REDIRECT *));
-static void print_heredoc_body PARAMS((REDIRECT *));
-static void print_heredocs PARAMS((REDIRECT *));
-static void print_heredoc_bodies PARAMS((REDIRECT *));
-static void print_deferred_heredocs PARAMS((const char *));
-
-static void print_for_command PARAMS((FOR_COM *));
-#if defined (ARITH_FOR_COMMAND)
-static void print_arith_for_command PARAMS((ARITH_FOR_COM *));
-#endif
-#if defined (SELECT_COMMAND)
-static void print_select_command PARAMS((SELECT_COM *));
-#endif
-static void print_group_command PARAMS((GROUP_COM *));
-static void print_case_command PARAMS((CASE_COM *));
-static void print_while_command PARAMS((WHILE_COM *));
-static void print_until_command PARAMS((WHILE_COM *));
-static void print_until_or_while PARAMS((WHILE_COM *, char *));
-static void print_if_command PARAMS((IF_COM *));
-#if defined (COND_COMMAND)
-static void print_cond_node PARAMS((COND_COM *));
-#endif
-static void print_function_def PARAMS((FUNCTION_DEF *));
-
-#define PRINTED_COMMAND_INITIAL_SIZE 64
-#define PRINTED_COMMAND_GROW_SIZE 128
-
-char *the_printed_command = (char *)NULL;
-int the_printed_command_size = 0;
-int command_string_index = 0;
-
-int xtrace_fd = -1;
-FILE *xtrace_fp = 0;
-
-#define CHECK_XTRACE_FP	xtrace_fp = (xtrace_fp ? xtrace_fp : stderr)
-
-/* shell expansion characters: used in print_redirection_list */
-#define EXPCHAR(c) ((c) == '{' || (c) == '~' || (c) == '$' || (c) == '`')
-
-#define PRINT_DEFERRED_HEREDOCS(x) \
-  do { \
-    if (deferred_heredocs) \
-      print_deferred_heredocs (x); \
-  } while (0)
-
-/* Non-zero means the stuff being printed is inside of a function def. */
-static int inside_function_def;
-static int skip_this_indent;
-static int was_heredoc;
-static int printing_connection;
-static int printing_comsub;
-static REDIRECT *deferred_heredocs;
-
-/* The depth of the group commands that we are currently printing.  This
-   includes the group command that is a function body. */
-static int group_command_nesting;
-
-/* A buffer to indicate the indirection level (PS4) when set -x is enabled. */
-static char *indirection_string = 0;
-static int indirection_stringsiz = 0;
-
-/* Print COMMAND (a command tree) on standard output. */
-void
-print_command (command)
-     COMMAND *command;
-{
-  command_string_index = 0;
-  printf ("%s", make_command_string (command));
-}
-
-/* Make a string which is the printed representation of the command
-   tree in COMMAND.  We return this string.  However, the string is
-   not consed, so you have to do that yourself if you want it to
-   remain around. */
-char *
-make_command_string (command)
-     COMMAND *command;
-{
-  command_string_index = was_heredoc = 0;
-  deferred_heredocs = 0;
-  make_command_string_internal (command);
-  return (the_printed_command);
-}
-
-/* Print a command substitution after parsing it in parse_comsub to turn it
-   back into an external representation without turning newlines into `;'.
-   Placeholder for other changes, if any are necessary. */
-char *
-print_comsub (command)
-     COMMAND *command;
-{
-  char *ret;
-
-  printing_comsub++;
-  ret = make_command_string (command);
-  printing_comsub--;
-  return ret;
-}
-
-/* The internal function.  This is the real workhorse. */
-static void
-make_command_string_internal (command)
-     COMMAND *command;
-{
-  char s[3];
-
-  if (command == 0)
-    cprintf ("");
-  else
-    {
-      if (skip_this_indent)
-	skip_this_indent--;
-      else
-	indent (indentation);
-
-      if (command->flags & CMD_TIME_PIPELINE)
-	{
-	  cprintf ("time ");
-	  if (command->flags & CMD_TIME_POSIX)
-	    cprintf ("-p ");
-	}
-
-      if (command->flags & CMD_INVERT_RETURN)
-	cprintf ("! ");
-
-      switch (command->type)
-	{
-	case cm_for:
-	  print_for_command (command->value.For);
-	  break;
-
-#if defined (ARITH_FOR_COMMAND)
-	case cm_arith_for:
-	  print_arith_for_command (command->value.ArithFor);
-	  break;
-#endif
-
-#if defined (SELECT_COMMAND)
-	case cm_select:
-	  print_select_command (command->value.Select);
-	  break;
-#endif
-
-	case cm_case:
-	  print_case_command (command->value.Case);
-	  break;
-
-	case cm_while:
-	  print_while_command (command->value.While);
-	  break;
-
-	case cm_until:
-	  print_until_command (command->value.While);
-	  break;
-
-	case cm_if:
-	  print_if_command (command->value.If);
-	  break;
-
-#if defined (DPAREN_ARITHMETIC)
-	case cm_arith:
-	  print_arith_command (command->value.Arith->exp);
-	  break;
-#endif
-
-#if defined (COND_COMMAND)
-	case cm_cond:
-	  print_cond_command (command->value.Cond);
-	  break;
-#endif
-
-	case cm_simple:
-	  print_simple_command (command->value.Simple);
-	  break;
-
-	case cm_connection:
-
-	  skip_this_indent++;
-	  printing_connection++;
-	  make_command_string_internal (command->value.Connection->first);
-
-	  switch (command->value.Connection->connector)
-	    {
-	    case '&':
-	    case '|':
-	      {
-		char c = command->value.Connection->connector;
-
-		s[0] = ' ';
-		s[1] = c;
-		s[2] = '\0';
-		
-		print_deferred_heredocs (s);
-
-		if (c != '&' || command->value.Connection->second)
-		  {
-		    cprintf (" ");
-		    skip_this_indent++;
-		  }
-	      }
-	      break;
-
-	    case AND_AND:
-	      print_deferred_heredocs (" && ");
-	      if (command->value.Connection->second)
-		skip_this_indent++;
-	      break;
-
-	    case OR_OR:
-	      print_deferred_heredocs (" || ");
-	      if (command->value.Connection->second)
-		skip_this_indent++;
-	      break;
-
-	    case ';':
-	    case '\n':				/* special case this */
-	      {
-		char c = command->value.Connection->connector;
-
-		s[0] = printing_comsub ? c : ';';
-		s[1] = '\0';
-
-		if (deferred_heredocs == 0)
-		  {
-		    if (was_heredoc == 0)
-		      cprintf ("%s", s);	/* inside_function_def? */
-		    else
-		      was_heredoc = 0;
-		  }
-		else
-		  /* print_deferred_heredocs special-cases `;' */
-		  print_deferred_heredocs (inside_function_def ? "" : ";");
-
-		if (inside_function_def)
-		  cprintf ("\n");
-		else
-		  {
-		    if (c == ';')
-		      cprintf (" ");
-		    if (command->value.Connection->second)
-		      skip_this_indent++;
-		  }
-		break;
-	      }
-
-	    default:
-	      cprintf (_("print_command: bad connector `%d'"),
-		       command->value.Connection->connector);
-	      break;
-	    }
-
-	  make_command_string_internal (command->value.Connection->second);
-	  PRINT_DEFERRED_HEREDOCS ("");
-	  printing_connection--;	  	  
-	  break;
-
-	case cm_function_def:
-	  print_function_def (command->value.Function_def);
-	  break;
-
-	case cm_group:
-	  print_group_command (command->value.Group);
-	  break;
-
-	case cm_subshell:
-	  cprintf ("( ");
-	  skip_this_indent++;
-	  make_command_string_internal (command->value.Subshell->command);
-	  PRINT_DEFERRED_HEREDOCS ("");
-	  cprintf (" )");
-	  break;
-
-	case cm_coproc:
-	  cprintf ("coproc %s ", command->value.Coproc->name);
-	  skip_this_indent++;
-	  make_command_string_internal (command->value.Coproc->command);
-	  break;
-
-	default:
-	  command_error ("print_command", CMDERR_BADTYPE, command->type, 0);
-	  break;
-	}
-
-
-      if (command->redirects)
-	{
-	  cprintf (" ");
-	  print_redirection_list (command->redirects);
-	}
-    }
-}
-
-static void
-_print_word_list (list, separator, pfunc)
-     WORD_LIST *list;
-     char *separator;
-     PFUNC *pfunc;
-{
-  WORD_LIST *w;
-
-  for (w = list; w; w = w->next)
-    (*pfunc) ("%s%s", w->word->word, w->next ? separator : "");
-}
-
-void
-print_word_list (list, separator)
-     WORD_LIST *list;
-     char *separator;
-{
-  _print_word_list (list, separator, xprintf);
-}
-
-void
-xtrace_set (fd, fp)
-     int fd;
-     FILE *fp;
-{
-  if (fd >= 0 && sh_validfd (fd) == 0)
-    {
-      internal_error (_("xtrace_set: %d: invalid file descriptor"), fd);
-      return;
-    }
-  if (fp == 0)
-    {
-      internal_error (_("xtrace_set: NULL file pointer"));
-      return;
-    }
-  if (fd >= 0 && fileno (fp) != fd)
-    internal_warning (_("xtrace fd (%d) != fileno xtrace fp (%d)"), fd, fileno (fp));
-  
-  xtrace_fd = fd;
-  xtrace_fp = fp;
-}
-
-void
-xtrace_init ()
-{
-  xtrace_set (-1, stderr);
-}
-
-void
-xtrace_reset ()
-{
-  if (xtrace_fd >= 0 && xtrace_fp)
-    {
-      fflush (xtrace_fp);
-      fclose (xtrace_fp);
-    }
-  else if (xtrace_fd >= 0)
-    close (xtrace_fd);
-
-  xtrace_fd = -1;
-  xtrace_fp = stderr;
-}
-
-void
-xtrace_fdchk (fd)
-     int fd;
-{
-  if (fd == xtrace_fd)
-    xtrace_reset ();
-}
-
-/* Return a string denoting what our indirection level is. */
-
-char *
-indirection_level_string ()
-{
-  register int i, j;
-  char *ps4;
-  char ps4_firstc[MB_LEN_MAX+1];
-  int ps4_firstc_len, ps4_len, ineed, old;
-
-  ps4 = get_string_value ("PS4");
-  if (indirection_string == 0)
-    indirection_string = xmalloc (indirection_stringsiz = 100);
-  indirection_string[0] = '\0';
-
-  if (ps4 == 0 || *ps4 == '\0')
-    return (indirection_string);
-
-  old = change_flag ('x', FLAG_OFF);
-  ps4 = decode_prompt_string (ps4);
-  if (old)
-    change_flag ('x', FLAG_ON);
-
-  if (ps4 == 0 || *ps4 == '\0')
-    {
-      FREE (ps4);
-      return (indirection_string);
-    }
-
-#if defined (HANDLE_MULTIBYTE)
-  ps4_len = strnlen (ps4, MB_CUR_MAX);
-  ps4_firstc_len = MBLEN (ps4, ps4_len);
-  if (ps4_firstc_len == 1 || ps4_firstc_len == 0 || ps4_firstc_len < 0)
-    {
-      ps4_firstc[0] = ps4[0];
-      ps4_firstc[ps4_firstc_len = 1] = '\0';
-    }
-  else
-    memcpy (ps4_firstc, ps4, ps4_firstc_len);
-#else
-  ps4_firstc[0] = ps4[0];
-  ps4_firstc[ps4_firstc_len = 1] = '\0';
-#endif
-
-  /* Dynamically resize indirection_string so we have room for everything
-     and we don't have to truncate ps4 */
-  ineed = (ps4_firstc_len * indirection_level) + strlen (ps4);
-  if (ineed > indirection_stringsiz - 1)
-    {
-      indirection_stringsiz = ineed + 1;
-      indirection_string = xrealloc (indirection_string, indirection_stringsiz);
-    }
-
-  for (i = j = 0; ps4_firstc[0] && j < indirection_level && i < indirection_stringsiz - 1; i += ps4_firstc_len, j++)
-    {
-      if (ps4_firstc_len == 1)
-	indirection_string[i] = ps4_firstc[0];
-      else
-	memcpy (indirection_string+i, ps4_firstc, ps4_firstc_len);
-    }      
-
-  for (j = ps4_firstc_len; *ps4 && ps4[j] && i < indirection_stringsiz - 1; i++, j++)
-    indirection_string[i] = ps4[j];
-
-  indirection_string[i] = '\0';
-  free (ps4);
-  return (indirection_string);
-}
-
-void
-xtrace_print_assignment (name, value, assign_list, xflags)
-     char *name, *value;
-     int assign_list, xflags;
-{
-  char *nval;
-
-  CHECK_XTRACE_FP;
-
-  if (xflags)
-    fprintf (xtrace_fp, "%s", indirection_level_string ());
-
-  /* VALUE should not be NULL when this is called. */
-  if (*value == '\0' || assign_list)
-    nval = value;
-  else if (sh_contains_shell_metas (value))
-    nval = sh_single_quote (value);
-  else if (ansic_shouldquote (value))
-    nval = ansic_quote (value, 0, (int *)0);
-  else
-    nval = value;
-
-  if (assign_list)
-    fprintf (xtrace_fp, "%s=(%s)\n", name, nval);
-  else
-    fprintf (xtrace_fp, "%s=%s\n", name, nval);
-
-  if (nval != value)
-    FREE (nval);
-
-  fflush (xtrace_fp);
-}
-
-/* A function to print the words of a simple command when set -x is on.  Also used to
-   print the word list in a for or select command header; in that case, we suppress
-   quoting the words because they haven't been expanded yet.  XTFLAGS&1 means to
-   print $PS4; XTFLAGS&2 means to suppress quoting the words in LIST. */
-void
-xtrace_print_word_list (list, xtflags)
-     WORD_LIST *list;
-     int xtflags;
-{
-  WORD_LIST *w;
-  char *t, *x;
-
-  CHECK_XTRACE_FP;
-
-  if (xtflags&1)
-    fprintf (xtrace_fp, "%s", indirection_level_string ());
-
-  for (w = list; w; w = w->next)
-    {
-      t = w->word->word;
-      if (t == 0 || *t == '\0')
-	fprintf (xtrace_fp, "''%s", w->next ? " " : "");
-      else if (xtflags & 2)
-	fprintf (xtrace_fp, "%s%s", t, w->next ? " " : "");
-      else if (sh_contains_shell_metas (t))
-	{
-	  x = sh_single_quote (t);
-	  fprintf (xtrace_fp, "%s%s", x, w->next ? " " : "");
-	  free (x);
-	}
-      else if (ansic_shouldquote (t))
-	{
-	  x = ansic_quote (t, 0, (int *)0);
-	  fprintf (xtrace_fp, "%s%s", x, w->next ? " " : "");
-	  free (x);
-	}
-      else
-	fprintf (xtrace_fp, "%s%s", t, w->next ? " " : "");
-    }
-  fprintf (xtrace_fp, "\n");
-  fflush (xtrace_fp);
-}
-
-static void
-command_print_word_list (list, separator)
-     WORD_LIST *list;
-     char *separator;
-{
-  _print_word_list (list, separator, cprintf);
-}
-
-void
-print_for_command_head (for_command)
-     FOR_COM *for_command;
-{
-  cprintf ("for %s in ", for_command->name->word);
-  command_print_word_list (for_command->map_list, " ");
-}
-
-void
-xtrace_print_for_command_head (for_command)
-     FOR_COM *for_command;
-{
-  CHECK_XTRACE_FP;
-  fprintf (xtrace_fp, "%s", indirection_level_string ());
-  fprintf (xtrace_fp, "for %s in ", for_command->name->word);
-  xtrace_print_word_list (for_command->map_list, 2);
-}
-
-static void
-print_for_command (for_command)
-     FOR_COM *for_command;
-{
-  print_for_command_head (for_command);
-  cprintf (";");
-  newline ("do\n");
-
-  indentation += indentation_amount;
-  make_command_string_internal (for_command->action);
-  PRINT_DEFERRED_HEREDOCS ("");
-  semicolon ();
-  indentation -= indentation_amount;
-
-  newline ("done");
-}
-
-#if defined (ARITH_FOR_COMMAND)
-static void
-print_arith_for_command (arith_for_command)
-     ARITH_FOR_COM *arith_for_command;
-{
-  cprintf ("for ((");
-  command_print_word_list (arith_for_command->init, " ");
-  cprintf ("; ");
-  command_print_word_list (arith_for_command->test, " ");
-  cprintf ("; ");
-  command_print_word_list (arith_for_command->step, " ");
-  cprintf ("))");
-  newline ("do\n");
-  indentation += indentation_amount;
-  make_command_string_internal (arith_for_command->action);
-  PRINT_DEFERRED_HEREDOCS ("");
-  semicolon ();
-  indentation -= indentation_amount;
-  newline ("done");
-}
-#endif /* ARITH_FOR_COMMAND */
-
-#if defined (SELECT_COMMAND)
-void
-print_select_command_head (select_command)
-     SELECT_COM *select_command;
-{
-  cprintf ("select %s in ", select_command->name->word);
-  command_print_word_list (select_command->map_list, " ");
-}
-
-void
-xtrace_print_select_command_head (select_command)
-     SELECT_COM *select_command;
-{
-  CHECK_XTRACE_FP;
-  fprintf (xtrace_fp, "%s", indirection_level_string ());
-  fprintf (xtrace_fp, "select %s in ", select_command->name->word);
-  xtrace_print_word_list (select_command->map_list, 2);
-}
-
-static void
-print_select_command (select_command)
-     SELECT_COM *select_command;
-{
-  print_select_command_head (select_command);
-
-  cprintf (";");
-  newline ("do\n");
-  indentation += indentation_amount;
-  make_command_string_internal (select_command->action);
-  PRINT_DEFERRED_HEREDOCS ("");
-  semicolon ();
-  indentation -= indentation_amount;
-  newline ("done");
-}
-#endif /* SELECT_COMMAND */
-
-static void
-print_group_command (group_command)
-     GROUP_COM *group_command;
-{
-  group_command_nesting++;
-  cprintf ("{ ");
-
-  if (inside_function_def == 0)
-    skip_this_indent++;
-  else
-    {
-      /* This is a group command { ... } inside of a function
-	 definition, and should be printed as a multiline group
-	 command, using the current indentation. */
-      cprintf ("\n");
-      indentation += indentation_amount;
-    }
-
-  make_command_string_internal (group_command->command);
-  PRINT_DEFERRED_HEREDOCS ("");
-
-  if (inside_function_def)
-    {
-      cprintf ("\n");
-      indentation -= indentation_amount;
-      indent (indentation);
-    }
-  else
-    {
-      semicolon ();
-      cprintf (" ");
-    }
-
-  cprintf ("}");
-
-  group_command_nesting--;
-}
-
-void
-print_case_command_head (case_command)
-     CASE_COM *case_command;
-{
-  cprintf ("case %s in ", case_command->word->word);
-}
-
-void
-xtrace_print_case_command_head (case_command)
-     CASE_COM *case_command;
-{
-  CHECK_XTRACE_FP;
-  fprintf (xtrace_fp, "%s", indirection_level_string ());
-  fprintf (xtrace_fp, "case %s in\n", case_command->word->word);
-}
-
-static void
-print_case_command (case_command)
-     CASE_COM *case_command;
-{
-  print_case_command_head (case_command);
-
-  if (case_command->clauses)
-    print_case_clauses (case_command->clauses);
-  newline ("esac");
-}
-
-static void
-print_case_clauses (clauses)
-     PATTERN_LIST *clauses;
-{
-  indentation += indentation_amount;
-  while (clauses)
-    {
-      newline ("");
-      command_print_word_list (clauses->patterns, " | ");
-      cprintf (")\n");
-      indentation += indentation_amount;
-      make_command_string_internal (clauses->action);
-      indentation -= indentation_amount;
-      PRINT_DEFERRED_HEREDOCS ("");
-      if (clauses->flags & CASEPAT_FALLTHROUGH)
-	newline (";&");
-      else if (clauses->flags & CASEPAT_TESTNEXT)
-	newline (";;&");
-      else
-	newline (";;");
-      clauses = clauses->next;
-    }
-  indentation -= indentation_amount;
-}
-
-static void
-print_while_command (while_command)
-     WHILE_COM *while_command;
-{
-  print_until_or_while (while_command, "while");
-}
-
-static void
-print_until_command (while_command)
-     WHILE_COM *while_command;
-{
-  print_until_or_while (while_command, "until");
-}
-
-static void
-print_until_or_while (while_command, which)
-     WHILE_COM *while_command;
-     char *which;
-{
-  cprintf ("%s ", which);
-  skip_this_indent++;
-  make_command_string_internal (while_command->test);
-  PRINT_DEFERRED_HEREDOCS ("");
-  semicolon ();
-  cprintf (" do\n");	/* was newline ("do\n"); */
-  indentation += indentation_amount;
-  make_command_string_internal (while_command->action);
-  PRINT_DEFERRED_HEREDOCS ("");
-  indentation -= indentation_amount;
-  semicolon ();
-  newline ("done");
-}
-
-static void
-print_if_command (if_command)
-     IF_COM *if_command;
-{
-  cprintf ("if ");
-  skip_this_indent++;
-  make_command_string_internal (if_command->test);
-  semicolon ();
-  cprintf (" then\n");
-  indentation += indentation_amount;
-  make_command_string_internal (if_command->true_case);
-  PRINT_DEFERRED_HEREDOCS ("");
-  indentation -= indentation_amount;
-
-  if (if_command->false_case)
-    {
-      semicolon ();
-      newline ("else\n");
-      indentation += indentation_amount;
-      make_command_string_internal (if_command->false_case);
-      PRINT_DEFERRED_HEREDOCS ("");
-      indentation -= indentation_amount;
-    }
-  semicolon ();
-  newline ("fi");
-}
-
-#if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
-void
-print_arith_command (arith_cmd_list)
-     WORD_LIST *arith_cmd_list;
-{
-  cprintf ("((");
-  command_print_word_list (arith_cmd_list, " ");
-  cprintf ("))");
-}
-#endif
-
-#if defined (COND_COMMAND)
-static void
-print_cond_node (cond)
-     COND_COM *cond;
-{
-  if (cond->flags & CMD_INVERT_RETURN)
-    cprintf ("! ");
-
-  if (cond->type == COND_EXPR)
-    {
-      cprintf ("( ");
-      print_cond_node (cond->left);
-      cprintf (" )");
-    }
-  else if (cond->type == COND_AND)
-    {
-      print_cond_node (cond->left);
-      cprintf (" && ");
-      print_cond_node (cond->right);
-    }
-  else if (cond->type == COND_OR)
-    {
-      print_cond_node (cond->left);
-      cprintf (" || ");
-      print_cond_node (cond->right);
-    }
-  else if (cond->type == COND_UNARY)
-    {
-      cprintf ("%s", cond->op->word);
-      cprintf (" ");
-      print_cond_node (cond->left);
-    }
-  else if (cond->type == COND_BINARY)
-    {
-      print_cond_node (cond->left);
-      cprintf (" ");
-      cprintf ("%s", cond->op->word);
-      cprintf (" ");
-      print_cond_node (cond->right);
-    }
-  else if (cond->type == COND_TERM)
-    {
-      cprintf ("%s", cond->op->word);		/* need to add quoting here */
-    }
-}
-
-void
-print_cond_command (cond)
-     COND_COM *cond;
-{
-  cprintf ("[[ ");
-  print_cond_node (cond);
-  cprintf (" ]]");
-}
-
-#ifdef DEBUG
-void
-debug_print_word_list (s, list, sep)
-     char *s;
-     WORD_LIST *list;
-     char *sep;
-{
-  WORD_LIST *w;
-
-  if (s)
-    fprintf (stderr, "%s: ", s);
-  for (w = list; w; w = w->next)
-    fprintf (stderr, "%s%s", w->word->word, w->next ? sep : "");
-  fprintf (stderr, "\n");
-}
-
-void
-debug_print_cond_command (cond)
-     COND_COM *cond;
-{
-  fprintf (stderr, "DEBUG: ");
-  command_string_index = 0;
-  print_cond_command (cond);
-  fprintf (stderr, "%s\n", the_printed_command);
-}
-#endif
-
-void
-xtrace_print_cond_term (type, invert, op, arg1, arg2)
-     int type, invert;
-     WORD_DESC *op;
-     char *arg1, *arg2;
-{
-  CHECK_XTRACE_FP;
-  command_string_index = 0;
-  fprintf (xtrace_fp, "%s", indirection_level_string ());
-  fprintf (xtrace_fp, "[[ ");
-  if (invert)
-    fprintf (xtrace_fp, "! ");
-
-  if (type == COND_UNARY)
-    {
-      fprintf (xtrace_fp, "%s ", op->word);
-      fprintf (xtrace_fp, "%s", (arg1 && *arg1) ? arg1 : "''");
-    }
-  else if (type == COND_BINARY)
-    {
-      fprintf (xtrace_fp, "%s", (arg1 && *arg1) ? arg1 : "''");
-      fprintf (xtrace_fp, " %s ", op->word);
-      fprintf (xtrace_fp, "%s", (arg2 && *arg2) ? arg2 : "''");
-    }
-
-  fprintf (xtrace_fp, " ]]\n");
-
-  fflush (xtrace_fp);
-}	  
-#endif /* COND_COMMAND */
-
-#if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
-/* A function to print the words of an arithmetic command when set -x is on. */
-void
-xtrace_print_arith_cmd (list)
-     WORD_LIST *list;
-{
-  WORD_LIST *w;
-
-  CHECK_XTRACE_FP;
-  fprintf (xtrace_fp, "%s", indirection_level_string ());
-  fprintf (xtrace_fp, "(( ");
-  for (w = list; w; w = w->next)
-    fprintf (xtrace_fp, "%s%s", w->word->word, w->next ? " " : "");
-  fprintf (xtrace_fp, " ))\n");
-
-  fflush (xtrace_fp);
-}
-#endif
-
-void
-print_simple_command (simple_command)
-     SIMPLE_COM *simple_command;
-{
-  if (simple_command->words)
-    command_print_word_list (simple_command->words, " ");
-
-  if (simple_command->redirects)
-    {
-      if (simple_command->words)
-	cprintf (" ");
-      print_redirection_list (simple_command->redirects);
-    }
-}
-
-static void
-print_heredocs (heredocs)
-     REDIRECT *heredocs;
-{
-  REDIRECT *hdtail;
-
-  cprintf (" "); 
-  for (hdtail = heredocs; hdtail; hdtail = hdtail->next)
-    {
-      print_redirection (hdtail);
-      cprintf ("\n");
-    }
-  was_heredoc = 1;
-}
-
-static void
-print_heredoc_bodies (heredocs)
-     REDIRECT *heredocs;
-{
-  REDIRECT *hdtail;
-
-  cprintf ("\n"); 
-  for (hdtail = heredocs; hdtail; hdtail = hdtail->next)
-    {
-      print_heredoc_body (hdtail);
-      cprintf ("\n");
-    }
-  was_heredoc = 1;
-}
-
-/* Print heredocs that are attached to the command before the connector
-   represented by CSTRING.  The parsing semantics require us to print the
-   here-doc delimiters, then the connector (CSTRING), then the here-doc
-   bodies.  We print the here-doc delimiters in print_redirection_list
-   and print the connector and the bodies here. We don't print the connector
-   if it's a `;', but we use it to note not to print an extra space after the
-   last heredoc body and newline. */
-static void
-print_deferred_heredocs (cstring)
-     const char *cstring;
-{
-  /* We now print the heredoc headers in print_redirection_list */
-  if (cstring && cstring[0] && (cstring[0] != ';' || cstring[1]))
-    cprintf ("%s", cstring); 
-  if (deferred_heredocs)
-    {
-      print_heredoc_bodies (deferred_heredocs);
-      if (cstring && cstring[0] && (cstring[0] != ';' || cstring[1]))
-	cprintf (" ");	/* make sure there's at least one space */
-      dispose_redirects (deferred_heredocs);
-      was_heredoc = 1;
-    }
-  deferred_heredocs = (REDIRECT *)NULL;
-}
-      
-static void
-print_redirection_list (redirects)
-     REDIRECT *redirects;
-{
-  REDIRECT *heredocs, *hdtail, *newredir;
-  char *rw;
-
-  heredocs = (REDIRECT *)NULL;
-  hdtail = heredocs;
-
-  was_heredoc = 0;
-  while (redirects)
-    {
-      /* Defer printing the here document bodiess until we've printed the rest of the
-         redirections, but print the headers in the order they're given.  */
-      if (redirects->instruction == r_reading_until || redirects->instruction == r_deblank_reading_until)
-	{
-	  newredir = copy_redirect (redirects);
-	  newredir->next = (REDIRECT *)NULL;
-
-	  print_heredoc_header (newredir);
-
-	  if (heredocs)
-	    {
-	      hdtail->next = newredir;
-	      hdtail = newredir;
-	    }
-	  else
-	    hdtail = heredocs = newredir;
-	}
-#if 0
-      /* Remove this heuristic now that the command printing code doesn't
-	 unconditionally put in the redirector file descriptor. */
-      else if (redirects->instruction == r_duplicating_output_word && (redirects->flags & REDIR_VARASSIGN) == 0 && redirects->redirector.dest == 1)
-	{
-	  /* Temporarily translate it as the execution code does. */
-	  rw = redirects->redirectee.filename->word;
-	  if (rw && *rw != '-' && DIGIT (*rw) == 0 && EXPCHAR (*rw) == 0)
-	    redirects->instruction = r_err_and_out;
-	  print_redirection (redirects);
-	  redirects->instruction = r_duplicating_output_word;
-	}
-#endif
-      else
-	print_redirection (redirects);
-
-      redirects = redirects->next;
-      if (redirects)
-	cprintf (" ");
-    }
-
-  /* Now that we've printed all the other redirections (on one line),
-     print the here documents.  If we're printing a connection, we wait until
-     we print the connector symbol, then we print the here document bodies */
-  if (heredocs && printing_connection)
-    deferred_heredocs = heredocs;
-  else if (heredocs)
-    {
-      print_heredoc_bodies (heredocs);
-      dispose_redirects (heredocs);
-    }
-}
-
-static void
-print_heredoc_header (redirect)
-     REDIRECT *redirect;
-{
-  int kill_leading;
-  char *x;
-
-  kill_leading = redirect->instruction == r_deblank_reading_until;
-
-  /* Here doc header */
-  if (redirect->rflags & REDIR_VARASSIGN)
-    cprintf ("{%s}", redirect->redirector.filename->word);
-  else if (redirect->redirector.dest != 0)
-    cprintf ("%d", redirect->redirector.dest);
-
-  /* If the here document delimiter is quoted, single-quote it. */
-  if (redirect->redirectee.filename->flags & W_QUOTED)
-    {
-      x = sh_single_quote (redirect->here_doc_eof);
-      cprintf ("<<%s%s", kill_leading ? "-" : "", x);
-      free (x);
-    }
-  else
-    cprintf ("<<%s%s", kill_leading ? "-" : "", redirect->here_doc_eof);
-}
-
-static void
-print_heredoc_body (redirect)
-     REDIRECT *redirect;
-{
-  /* Here doc body */
-  cprintf ("%s%s", redirect->redirectee.filename->word, redirect->here_doc_eof);
-}
-
-static void
-print_redirection (redirect)
-     REDIRECT *redirect;
-{
-  int redirector, redir_fd;
-  WORD_DESC *redirectee, *redir_word;
-
-  redirectee = redirect->redirectee.filename;
-  redir_fd = redirect->redirectee.dest;
-
-  redir_word = redirect->redirector.filename;
-  redirector = redirect->redirector.dest;
-
-  switch (redirect->instruction)
-    {
-    case r_input_direction:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}", redir_word->word);
-      else if (redirector != 0)
-	cprintf ("%d", redirector);
-      cprintf ("< %s", redirectee->word);
-      break;
-
-    case r_output_direction:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}", redir_word->word);
-      else if (redirector != 1)
-	cprintf ("%d", redirector);
-      cprintf ("> %s", redirectee->word);
-      break;
-
-    case r_inputa_direction:	/* Redirection created by the shell. */
-      cprintf ("&");
-      break;
-
-    case r_output_force:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}", redir_word->word);
-      else if (redirector != 1)
-	cprintf ("%d", redirector);
-      cprintf (">| %s", redirectee->word);
-      break;
-
-    case r_appending_to:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}", redir_word->word);
-      else if (redirector != 1)
-	cprintf ("%d", redirector);
-      cprintf (">> %s", redirectee->word);
-      break;
-
-    case r_input_output:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}", redir_word->word);
-      else if (redirector != 1)
-	cprintf ("%d", redirector);
-      cprintf ("<> %s", redirectee->word);
-      break;
-
-    case r_deblank_reading_until:
-    case r_reading_until:
-      print_heredoc_header (redirect);
-      cprintf ("\n");
-      print_heredoc_body (redirect);
-      break;
-
-    case r_reading_string:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}", redir_word->word);
-      else if (redirector != 0)
-	cprintf ("%d", redirector);
-#if 0
-      /* Don't need to check whether or not to requote, since original quotes
-         are still intact.  The only thing that has happened is that $'...'
-         has been replaced with 'expanded ...'. */
-      if (ansic_shouldquote (redirect->redirectee.filename->word))
-	{
-	  char *x;
-	  x = ansic_quote (redirect->redirectee.filename->word, 0, (int *)0);
-	  cprintf ("<<< %s", x);
-	  free (x);
-	}
-      else
-#endif
-	cprintf ("<<< %s", redirect->redirectee.filename->word);
-      break;
-
-    case r_duplicating_input:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}<&%d", redir_word->word, redir_fd);
-      else
-	cprintf ("%d<&%d", redirector, redir_fd);
-      break;
-
-    case r_duplicating_output:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}>&%d", redir_word->word, redir_fd);
-      else
-	cprintf ("%d>&%d", redirector, redir_fd);
-      break;
-
-    case r_duplicating_input_word:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}<&%s", redir_word->word, redirectee->word);
-      else if (redirector == 0)
-	cprintf ("<&%s", redirectee->word);
-      else
-	cprintf ("%d<&%s", redirector, redirectee->word);
-      break;
-
-    case r_duplicating_output_word:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}>&%s", redir_word->word, redirectee->word);
-      else if (redirector == 1)
-	cprintf (">&%s", redirectee->word);
-      else
-	cprintf ("%d>&%s", redirector, redirectee->word);
-      break;
-
-    case r_move_input:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}<&%d-", redir_word->word, redir_fd);
-      else
-	cprintf ("%d<&%d-", redirector, redir_fd);
-      break;
-
-    case r_move_output:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}>&%d-", redir_word->word, redir_fd);
-      else
-	cprintf ("%d>&%d-", redirector, redir_fd);
-      break;
-
-    case r_move_input_word:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}<&%s-", redir_word->word, redirectee->word);
-      else
-	cprintf ("%d<&%s-", redirector, redirectee->word);
-      break;
-
-    case r_move_output_word:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}>&%s-", redir_word->word, redirectee->word);
-      else
-	cprintf ("%d>&%s-", redirector, redirectee->word);
-      break;
-
-    case r_close_this:
-      if (redirect->rflags & REDIR_VARASSIGN)
-	cprintf ("{%s}>&-", redir_word->word);
-      else
-	cprintf ("%d>&-", redirector);
-      break;
-
-    case r_err_and_out:
-      cprintf ("&> %s", redirectee->word);
-      break;
-
-    case r_append_err_and_out:
-      cprintf ("&>> %s", redirectee->word);
-      break;
-    }
-}
-
-static void
-reset_locals ()
-{
-  inside_function_def = 0;
-  indentation = 0;
-  printing_connection = 0;
-  deferred_heredocs = 0;
-  printing_comsub = 0;
-}
-
-static void
-print_function_def (func)
-     FUNCTION_DEF *func;
-{
-  COMMAND *cmdcopy;
-  REDIRECT *func_redirects;
-
-  func_redirects = NULL;
-  /* When in posix mode, print functions as posix specifies them. */
-  if (posixly_correct == 0)
-    cprintf ("function %s () \n", func->name->word);
-  else
-    cprintf ("%s () \n", func->name->word);
-  add_unwind_protect (reset_locals, 0);
-
-  indent (indentation);
-  cprintf ("{ \n");
-
-  inside_function_def++;
-  indentation += indentation_amount;
-
-  cmdcopy = copy_command (func->command);
-  if (cmdcopy->type == cm_group)
-    {
-      func_redirects = cmdcopy->redirects;
-      cmdcopy->redirects = (REDIRECT *)NULL;
-    }
-  make_command_string_internal (cmdcopy->type == cm_group
-					? cmdcopy->value.Group->command
-					: cmdcopy);
-  PRINT_DEFERRED_HEREDOCS ("");
-
-  remove_unwind_protect ();
-  indentation -= indentation_amount;
-  inside_function_def--;
-
-  if (func_redirects)
-    { /* { */
-      newline ("} ");
-      print_redirection_list (func_redirects);
-      cmdcopy->redirects = func_redirects;
-    }
-  else
-    newline ("}");
-
-  dispose_command (cmdcopy);
-}
-
-/* Return the string representation of the named function.
-   NAME is the name of the function.
-   COMMAND is the function body.  It should be a GROUP_COM.
-   flags&FUNC_MULTILINE is non-zero to pretty-print, or zero for all on one line.
-   flags&FUNC_EXTERNAL means convert from internal to external form
-  */
-char *
-named_function_string (name, command, flags)
-     char *name;
-     COMMAND *command;
-     int flags;
-{
-  char *result;
-  int old_indent, old_amount;
-  COMMAND *cmdcopy;
-  REDIRECT *func_redirects;
-
-  old_indent = indentation;
-  old_amount = indentation_amount;
-  command_string_index = was_heredoc = 0;
-  deferred_heredocs = 0;
-  printing_comsub = 0;
-
-  if (name && *name)
-    {
-      if (find_reserved_word (name) >= 0)
-	cprintf ("function ");
-      cprintf ("%s ", name);
-    }
-
-  cprintf ("() ");
-
-  if ((flags & FUNC_MULTILINE) == 0)
-    {
-      indentation = 1;
-      indentation_amount = 0;
-    }
-  else
-    {
-      cprintf ("\n");
-      indentation += indentation_amount;
-    }
-
-  inside_function_def++;
-
-  cprintf ((flags & FUNC_MULTILINE) ? "{ \n" : "{ ");
-
-  cmdcopy = copy_command (command);
-  /* Take any redirections specified in the function definition (which should
-     apply to the function as a whole) and save them for printing later. */
-  func_redirects = (REDIRECT *)NULL;
-  if (cmdcopy->type == cm_group)
-    {
-      func_redirects = cmdcopy->redirects;
-      cmdcopy->redirects = (REDIRECT *)NULL;
-    }
-  make_command_string_internal (cmdcopy->type == cm_group
-					? cmdcopy->value.Group->command
-					: cmdcopy);
-  PRINT_DEFERRED_HEREDOCS ("");
-
-  indentation = old_indent;
-  indentation_amount = old_amount;
-  inside_function_def--;
-
-  if (func_redirects)
-    { /* { */
-      newline ("} ");
-      print_redirection_list (func_redirects);
-      cmdcopy->redirects = func_redirects;
-    }
-  else
-    newline ("}");
-
-  result = the_printed_command;
-
-  if ((flags & FUNC_MULTILINE) == 0)
-    {
-#if 0
-      register int i;
-      for (i = 0; result[i]; i++)
-	if (result[i] == '\n')
-	  {
-	    strcpy (result + i, result + i + 1);
-	    --i;
-	  }
-#else
-      if (result[2] == '\n')	/* XXX -- experimental */
-	memmove (result + 2, result + 3, strlen (result) - 2);	
-#endif
-    }
-
-  dispose_command (cmdcopy);
-
-  if (flags & FUNC_EXTERNAL)
-    result = remove_quoted_escapes (result);
-
-  return (result);
-}
-
-static void
-newline (string)
-     char *string;
-{
-  cprintf ("\n");
-  indent (indentation);
-  if (string && *string)
-    cprintf ("%s", string);
-}
-
-static char *indentation_string;
-static int indentation_size;
-
-static void
-indent (amount)
-     int amount;
-{
-  register int i;
-
-  RESIZE_MALLOCED_BUFFER (indentation_string, 0, amount, indentation_size, 16);
-
-  for (i = 0; amount > 0; amount--)
-    indentation_string[i++] = ' ';
-  indentation_string[i] = '\0';
-  cprintf ("%s", indentation_string);
-}
-
-static void
-semicolon ()
-{
-  if (command_string_index > 0 &&
-       (the_printed_command[command_string_index - 1] == '&' ||
-	the_printed_command[command_string_index - 1] == '\n'))
-    return;
-  cprintf (";");
-}
-
-/* How to make the string. */
-static void
-#if defined (PREFER_STDARG)
-cprintf (const char *control, ...)
-#else
-cprintf (control, va_alist)
-     const char *control;
-     va_dcl
-#endif
-{
-  register const char *s;
-  char char_arg[2], *argp, intbuf[INT_STRLEN_BOUND (unsigned int) + 1];
-  int digit_arg, arg_len, c;
-  va_list args;
-
-  SH_VA_START (args, control);
-
-  arg_len = strlen (control);
-  the_printed_command_resize (arg_len + 1);
-
-  char_arg[1] = '\0';
-  s = control;
-  while (s && *s)
-    {
-      c = *s++;
-      argp = (char *)NULL;
-      if (c != '%' || !*s)
-	{
-	  char_arg[0] = c;
-	  argp = char_arg;
-	  arg_len = 1;
-	}
-      else
-	{
-	  c = *s++;
-	  switch (c)
-	    {
-	    case '%':
-	      char_arg[0] = c;
-	      argp = char_arg;
-	      arg_len = 1;
-	      break;
-
-	    case 's':
-	      argp = va_arg (args, char *);
-	      arg_len = strlen (argp);
-	      break;
-
-	    case 'd':
-	      /* Represent an out-of-range file descriptor with an out-of-range
-		 integer value.  We can do this because the only use of `%d' in
-		 the calls to cprintf is to output a file descriptor number for
-		 a redirection. */
-	      digit_arg = va_arg (args, int);
-	      if (digit_arg < 0)
-		{
-		  sprintf (intbuf, "%u", (unsigned int)-1);
-		  argp = intbuf;
-		}
-	      else
-		argp = inttostr (digit_arg, intbuf, sizeof (intbuf));
-	      arg_len = strlen (argp);
-	      break;
-
-	    case 'c':
-	      char_arg[0] = va_arg (args, int);
-	      argp = char_arg;
-	      arg_len = 1;
-	      break;
-
-	    default:
-	      programming_error (_("cprintf: `%c': invalid format character"), c);
-	      /*NOTREACHED*/
-	    }
-	}
-
-      if (argp && arg_len)
-	{
-	  the_printed_command_resize (arg_len + 1);
-	  FASTCOPY (argp, the_printed_command + command_string_index, arg_len);
-	  command_string_index += arg_len;
-	}
-    }
-
-  va_end (args);
-
-  the_printed_command[command_string_index] = '\0';
-}
-
-/* Ensure that there is enough space to stuff LENGTH characters into
-   THE_PRINTED_COMMAND. */
-static void
-the_printed_command_resize (length)
-     int length;
-{
-  if (the_printed_command == 0)
-    {
-      the_printed_command_size = (length + PRINTED_COMMAND_INITIAL_SIZE - 1) & ~(PRINTED_COMMAND_INITIAL_SIZE - 1);
-      the_printed_command = (char *)xmalloc (the_printed_command_size);
-      command_string_index = 0;
-    }
-  else if ((command_string_index + length) >= the_printed_command_size)
-    {
-      int new;
-      new = command_string_index + length + 1;
-
-      /* Round up to the next multiple of PRINTED_COMMAND_GROW_SIZE. */
-      new = (new + PRINTED_COMMAND_GROW_SIZE - 1) & ~(PRINTED_COMMAND_GROW_SIZE - 1);
-      the_printed_command_size = new;
-
-      the_printed_command = (char *)xrealloc (the_printed_command, the_printed_command_size);
-    }
-}
-
-#if defined (HAVE_VPRINTF)
-/* ``If vprintf is available, you may assume that vfprintf and vsprintf are
-     also available.'' */
-
-static void
-#if defined (PREFER_STDARG)
-xprintf (const char *format, ...)
-#else
-xprintf (format, va_alist)
-     const char *format;
-     va_dcl
-#endif
-{
-  va_list args;
-
-  SH_VA_START (args, format);
-
-  vfprintf (stdout, format, args);
-  va_end (args);
-}
-
-#else
-
-static void
-xprintf (format, arg1, arg2, arg3, arg4, arg5)
-     const char *format;
-{
-  printf (format, arg1, arg2, arg3, arg4, arg5);
-}
-
-#endif /* !HAVE_VPRINTF */
diff --git a/third_party/bash/psize.c b/third_party/bash/psize.c
deleted file mode 100644
index 66f5f918a..000000000
--- a/third_party/bash/psize.c
+++ /dev/null
@@ -1,79 +0,0 @@
-/* psize.c - Find pipe size. */
-
-/* Copyright (C) 1987, 1991 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/*  Write output in 128-byte chunks until we get a sigpipe or write gets an
-    EPIPE.  Then report how many bytes we wrote.  We assume that this is the
-    pipe size. */
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#ifndef _MINIX
-#include "bashtypes.h"
-#endif
-#include <signal.h>
-#include <errno.h>
-
-#include "command.h"
-#include "general.h"
-#include "sig.h"
-
-#ifndef errno
-extern int errno;
-#endif
-
-int nw;
-
-sighandler
-sigpipe (sig)
-     int sig;
-{
-  fprintf (stderr, "%d\n", nw);
-  exit (0);
-}
-
-int
-main (argc, argv)
-     int argc;
-     char **argv;
-{
-  char buf[128];
-  register int i;
-
-  for (i = 0; i < 128; i++)
-    buf[i] = ' ';
-
-  signal (SIGPIPE, sigpipe);
-
-  nw = 0;
-  for (;;)
-    {
-      int n;
-      n = write (1, buf, 128);
-      nw += n;
-    }
-  return (0);
-}
diff --git a/third_party/bash/quit.h b/third_party/bash/quit.h
deleted file mode 100644
index 0af1d121f..000000000
--- a/third_party/bash/quit.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/* quit.h -- How to handle SIGINT gracefully. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_QUIT_H_)
-#define _QUIT_H_
-
-#include "sig.h"	/* for sig_atomic_t */
-
-/* Non-zero means SIGINT has already occurred. */
-extern volatile sig_atomic_t interrupt_state;
-extern volatile sig_atomic_t terminating_signal;
-
-/* Macro to call a great deal.  SIGINT just sets the interrupt_state variable.
-   When it is safe, put QUIT in the code, and the "interrupt" will take
-   place.  The same scheme is used for terminating signals (e.g., SIGHUP)
-   and the terminating_signal variable.  That calls a function which will
-   end up exiting the shell. */
-#define QUIT \
-  do { \
-    if (terminating_signal) termsig_handler (terminating_signal); \
-    if (interrupt_state) throw_to_top_level (); \
-  } while (0)
-
-#define SETINTERRUPT interrupt_state = 1
-#define CLRINTERRUPT interrupt_state = 0
-
-#define ADDINTERRUPT interrupt_state++
-#define DELINTERRUPT interrupt_state--
-
-#define ISINTERRUPT interrupt_state != 0
-
-/* The same sort of thing, this time just for signals that would ordinarily
-   cause the shell to terminate. */
-
-#define CHECK_TERMSIG \
-  do { \
-    if (terminating_signal) termsig_handler (terminating_signal); \
-  } while (0)
-
-#define LASTSIG() \
-  (terminating_signal ? terminating_signal : (interrupt_state ? SIGINT : 0))
-
-#define CHECK_WAIT_INTR \
-  do { \
-    if (wait_intr_flag && wait_signal_received && this_shell_builtin && (this_shell_builtin == wait_builtin)) \
-      sh_longjmp (wait_intr_buf, 1); \
-  } while (0)
-
-#define RESET_SIGTERM \
-  do { \
-    sigterm_received = 0; \
-  } while (0)
-
-#define CHECK_SIGTERM \
-  do { \
-    if (sigterm_received) termsig_handler (SIGTERM); \
-  } while (0)
-#endif /* _QUIT_H_ */
diff --git a/third_party/bash/random.c b/third_party/bash/random.c
deleted file mode 100644
index 1eaa71aac..000000000
--- a/third_party/bash/random.c
+++ /dev/null
@@ -1,240 +0,0 @@
-/* random.c -- Functions for managing 16-bit and 32-bit random numbers. */
-
-/* Copyright (C) 2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#if defined (HAVE_SYS_RANDOM_H)
-#  include <sys/random.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-#include "filecntl.h"
-
-#include <stdio.h>
-#include "bashansi.h"
-
-#include "shell.h"
-
-extern time_t shell_start_time;
-
-extern int last_random_value;
-
-static u_bits32_t intrand32 PARAMS((u_bits32_t));
-static u_bits32_t genseed PARAMS((void));
-
-static u_bits32_t brand32 PARAMS((void));
-static void sbrand32 PARAMS((u_bits32_t));
-static void perturb_rand32 PARAMS((void));
-
-/* The random number seed.  You can change this by setting RANDOM. */
-static u_bits32_t rseed = 1;
-
-/* Returns a 32-bit pseudo-random number. */
-static u_bits32_t
-intrand32 (last)
-     u_bits32_t last;
-{
-  /* Minimal Standard generator from
-     "Random number generators: good ones are hard to find",
-     Park and Miller, Communications of the ACM, vol. 31, no. 10,
-     October 1988, p. 1195. Filtered through FreeBSD.
-
-     x(n+1) = 16807 * x(n) mod (m).
-
-     We split up the calculations to avoid overflow.
-
-     h = last / q; l = x - h * q; t = a * l - h * r
-     m = 2147483647, a = 16807, q = 127773, r = 2836
-
-     There are lots of other combinations of constants to use; look at
-     https://www.gnu.org/software/gsl/manual/html_node/Other-random-number-generators.html#Other-random-number-generators */
-
-  bits32_t h, l, t;
-  u_bits32_t ret;
-
-  /* Can't seed with 0. */
-  ret = (last == 0) ? 123459876 : last;
-  h = ret / 127773;
-  l = ret - (127773 * h);
-  t = 16807 * l - 2836 * h;
-  ret = (t < 0) ? t + 0x7fffffff : t;
-
-  return (ret);
-}
-
-static u_bits32_t
-genseed ()
-{
-  struct timeval tv;
-  u_bits32_t iv;
-
-  gettimeofday (&tv, NULL);
-  iv = (u_bits32_t)seedrand;		/* let the compiler truncate */
-  iv = tv.tv_sec ^ tv.tv_usec ^ getpid () ^ getppid () ^ current_user.uid ^ iv;
-  return (iv);
-}
-
-#define BASH_RAND_MAX	32767		/* 0x7fff - 16 bits */
-
-/* Returns a pseudo-random number between 0 and 32767. */
-int
-brand ()
-{
-  unsigned int ret;
-
-  rseed = intrand32 (rseed);
-  if (shell_compatibility_level > 50)
-    ret = (rseed >> 16) ^ (rseed & 65535);
-  else
-    ret = rseed;
-  return (ret & BASH_RAND_MAX);
-}
-
-/* Set the random number generator seed to SEED. */
-void
-sbrand (seed)
-     unsigned long seed;
-{
-  rseed = seed;
-  last_random_value = 0;
-}
-
-void
-seedrand ()
-{
-  u_bits32_t iv;
-
-  iv = genseed ();
-  sbrand (iv);
-}
-
-static u_bits32_t rseed32 = 1073741823;
-static int last_rand32;
-
-static int urandfd = -1;
-
-#define BASH_RAND32_MAX	0x7fffffff	/* 32 bits */
-
-/* Returns a 32-bit pseudo-random number between 0 and 4294967295. */
-static u_bits32_t
-brand32 ()
-{
-  u_bits32_t ret;
-
-  rseed32 = intrand32 (rseed32);
-  return (rseed32 & BASH_RAND32_MAX);
-}
-
-static void
-sbrand32 (seed)
-     u_bits32_t seed;
-{
-  last_rand32 = rseed32 = seed;
-}
-
-void
-seedrand32 ()
-{
-  u_bits32_t iv;
-
-  iv = genseed ();
-  sbrand32 (iv);
-}
-
-static void
-perturb_rand32 ()
-{
-  rseed32 ^= genseed ();
-}
-
-/* Force another attempt to open /dev/urandom on the next call to get_urandom32 */
-void
-urandom_close ()
-{
-  if (urandfd >= 0)
-    close (urandfd);
-  urandfd = -1;
-}
-
-#if !defined (HAVE_GETRANDOM)
-/* Imperfect emulation of getrandom(2). */
-#ifndef GRND_NONBLOCK
-#  define GRND_NONBLOCK 1
-#  define GRND_RANDOM 2
-#endif
-
-static ssize_t
-getrandom (buf, len, flags)
-     void *buf;
-     size_t len;
-     unsigned int flags;
-{
-  int oflags;
-  ssize_t r;
-  static int urand_unavail = 0;
-
-#if HAVE_GETENTROPY
-  r = getentropy (buf, len);
-  return (r == 0) ? len : -1;
-#endif
-
-  if (urandfd == -1 && urand_unavail == 0)
-    {
-      oflags = O_RDONLY;
-      if (flags & GRND_NONBLOCK)
-	oflags |= O_NONBLOCK;
-      urandfd = open ("/dev/urandom", oflags, 0);
-      if (urandfd >= 0)
-	SET_CLOSE_ON_EXEC (urandfd);
-      else
-	{
-	  urand_unavail = 1;
-	  return -1;
-	}
-    }
-  if (urandfd >= 0 && (r = read (urandfd, buf, len)) == len)
-    return (r);
-  return -1;
-}
-#endif
-      
-u_bits32_t
-get_urandom32 ()
-{
-  u_bits32_t ret;
-
-  if (getrandom ((void *)&ret, sizeof (ret), GRND_NONBLOCK) == sizeof (ret))
-    return (last_rand32 = ret);
-
-#if defined (HAVE_ARC4RANDOM)
-  ret = arc4random ();
-#else
-  if (subshell_environment)
-    perturb_rand32 ();
-  do
-    ret = brand32 ();
-  while (ret == last_rand32);
-#endif
-  return (last_rand32 = ret);
-}
diff --git a/third_party/bash/read.c b/third_party/bash/read.c
deleted file mode 100644
index fc4346dda..000000000
--- a/third_party/bash/read.c
+++ /dev/null
@@ -1,1205 +0,0 @@
-/* read.c, created from read.def. */
-#line 22 "./read.def"
-
-#line 70 "./read.def"
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "posixstat.h"
-
-#include <stdio.h>
-
-#include "bashansi.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <signal.h>
-#include <errno.h>
-
-#ifdef __CYGWIN__
-#  include <fcntl.h>
-#  include <io.h>
-#endif
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "common.h"
-#include "bashgetopt.h"
-#include "trap.h"
-
-#include "shtty.h"
-
-#if defined (READLINE)
-#include "bashline.h"
-#include "third_party/readline/readline.h"
-#endif
-
-#if defined (BUFFERED_INPUT)
-#  include "input.h"
-#endif
-
-#include "shmbutil.h"
-#include "timer.h"
-
-#if !defined(errno)
-extern int errno;
-#endif
-
-struct ttsave
-{
-  int fd;
-  TTYSTRUCT attrs;
-};
-
-#if defined (READLINE)
-static void reset_attempted_completion_function PARAMS((char *));
-static int set_itext PARAMS((void));
-static char *edit_line PARAMS((char *, char *));
-static void set_eol_delim PARAMS((int));
-static void reset_eol_delim PARAMS((char *));
-static void set_readline_timeout PARAMS((sh_timer *t, time_t, long));
-#endif
-static SHELL_VAR *bind_read_variable PARAMS((char *, char *, int));
-#if defined (HANDLE_MULTIBYTE)
-static int read_mbchar PARAMS((int, char *, int, int, int));
-#endif
-static void ttyrestore PARAMS((struct ttsave *));
-
-static sighandler sigalrm PARAMS((int));
-static void reset_timeout PARAMS((void));
-
-/* Try this to see what the rest of the shell can do with the information. */
-sh_timer *read_timeout;
-
-static int reading, tty_modified;
-static SigHandler *old_alrm;
-static unsigned char delim;
-
-static struct ttsave termsave;
-
-/* In all cases, SIGALRM just sets a flag that we check periodically.  This
-   avoids problems with the semi-tricky stuff we do with the xfree of
-   input_string at the top of the unwind-protect list (see below). */
-
-/* Set a flag that check_read_timeout can check.  This relies on zread or
-   read_builtin calling trap.c:check_signals() (which calls check_read_timeout()) */
-static sighandler
-sigalrm (s)
-     int s;
-{
-  /* Display warning if this is called without read_timeout set? */
-  if (read_timeout)
-    read_timeout->alrmflag = 1;
-}
-
-static void
-reset_timeout ()
-{
-  /* Cancel alarm before restoring signal handler. */
-  if (read_timeout)
-    shtimer_clear (read_timeout);
-  read_timeout = 0;
-}
-
-void
-check_read_timeout ()
-{
-  if (read_timeout && shtimer_chktimeout (read_timeout))
-    sh_longjmp (read_timeout->jmpenv, 1);
-}
-
-int
-read_builtin_timeout (fd)
-     int fd;
-{
-  if ((read_timeout == 0) ||
-      (read_timeout->fd != fd) ||
-      (read_timeout->tmout.tv_sec == 0 && read_timeout->tmout.tv_usec == 0))
-    return 0;
-
-  return ((read_timeout->flags & SHTIMER_ALARM) ? shtimer_alrm (read_timeout)
-  						: shtimer_select (read_timeout));
-}
-
-/* Read the value of the shell variables whose names follow.
-   The reading is done from the current input stream, whatever
-   that may be.  Successive words of the input line are assigned
-   to the variables mentioned in LIST.  The last variable in LIST
-   gets the remainder of the words on the line.  If no variables
-   are mentioned in LIST, then the default variable is $REPLY. */
-int
-read_builtin (list)
-     WORD_LIST *list;
-{
-  register char *varname;
-  int size, nr, pass_next, saw_escape, eof, opt, retval, code, print_ps2, nflag;
-  volatile int i;
-  int input_is_tty, input_is_pipe, unbuffered_read, skip_ctlesc, skip_ctlnul;
-  int raw, edit, nchars, silent, have_timeout, ignore_delim, fd;
-  int lastsig, t_errno;
-  int mb_cur_max;
-  unsigned int tmsec, tmusec;
-  long ival, uval;
-  intmax_t intval;
-  char c;
-  char *input_string, *orig_input_string, *ifs_chars, *prompt, *arrayname;
-  char *e, *t, *t1, *ps2, *tofree;
-  struct stat tsb;
-  SHELL_VAR *var;
-  TTYSTRUCT ttattrs, ttset;
-  sigset_t chldset, prevset;
-#if defined (ARRAY_VARS)
-  WORD_LIST *alist;
-  int vflags;
-#endif
-  int bindflags;
-#if defined (READLINE)
-  char *rlbuf, *itext;
-  int rlind;
-  FILE *save_instream;
-#endif
-
-  USE_VAR(size);
-  USE_VAR(i);
-  USE_VAR(pass_next);
-  USE_VAR(print_ps2);
-  USE_VAR(saw_escape);
-  USE_VAR(input_is_pipe);
-/*  USE_VAR(raw); */
-  USE_VAR(edit);
-  USE_VAR(tmsec);
-  USE_VAR(tmusec);
-  USE_VAR(nchars);
-  USE_VAR(silent);
-  USE_VAR(ifs_chars);
-  USE_VAR(prompt);
-  USE_VAR(arrayname);
-#if defined (READLINE)
-  USE_VAR(rlbuf);
-  USE_VAR(rlind);
-  USE_VAR(itext);
-#endif
-  USE_VAR(list);
-  USE_VAR(ps2);
-  USE_VAR(lastsig);
-
-  reading = tty_modified = 0;
-  read_timeout = 0;
-
-  i = 0;		/* Index into the string that we are reading. */
-  raw = edit = 0;	/* Not reading raw input by default. */
-  silent = 0;
-  arrayname = prompt = (char *)NULL;
-  fd = 0;		/* file descriptor to read from */
-
-#if defined (READLINE)
-  rlbuf = itext = (char *)0;
-  rlind = 0;
-#endif
-
-  mb_cur_max = MB_CUR_MAX;
-  tmsec = tmusec = 0;		/* no timeout */
-  nr = nchars = input_is_tty = input_is_pipe = unbuffered_read = have_timeout = 0;
-  delim = '\n';		/* read until newline */
-  ignore_delim = nflag = 0;
-
-  reset_internal_getopt ();
-  while ((opt = internal_getopt (list, "ersa:d:i:n:p:t:u:N:")) != -1)
-    {
-      switch (opt)
-	{
-	case 'r':
-	  raw = 1;
-	  break;
-	case 'p':
-	  prompt = list_optarg;
-	  break;
-	case 's':
-	  silent = 1;
-	  break;
-	case 'e':
-#if defined (READLINE)
-	  edit = 1;
-#endif
-	  break;
-	case 'i':
-#if defined (READLINE)
-	  itext = list_optarg;
-#endif
-	  break;
-#if defined (ARRAY_VARS)
-	case 'a':
-	  arrayname = list_optarg;
-	  break;
-#endif
-	case 't':
-	  code = uconvert (list_optarg, &ival, &uval, (char **)NULL);
-	  if (code == 0 || ival < 0 || uval < 0)
-	    {
-	      builtin_error (_("%s: invalid timeout specification"), list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    {
-	      have_timeout = 1;
-	      tmsec = ival;
-	      tmusec = uval;
-	    }
-	  break;
-	case 'N':
-	  ignore_delim = 1;
-	  delim = -1;
-	case 'n':
-	  nflag = 1;
-	  code = legal_number (list_optarg, &intval);
-	  if (code == 0 || intval < 0 || intval != (int)intval)
-	    {
-	      sh_invalidnum (list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    nchars = intval;
-	  break;
-	case 'u':
-	  code = legal_number (list_optarg, &intval);
-	  if (code == 0 || intval < 0 || intval != (int)intval)
-	    {
-	      builtin_error (_("%s: invalid file descriptor specification"), list_optarg);
-	      return (EXECUTION_FAILURE);
-	    }
-	  else
-	    fd = intval;
-	  if (sh_validfd (fd) == 0)
-	    {
-	      builtin_error (_("%d: invalid file descriptor: %s"), fd, strerror (errno));
-	      return (EXECUTION_FAILURE);
-	    }
-	  break;
-	case 'd':
-	  delim = *list_optarg;
-	  break;
-	CASE_HELPOPT;
-	default:
-	  builtin_usage ();
-	  return (EX_USAGE);
-	}
-    }
-  list = loptend;
-
-  /* `read -t 0 var' tests whether input is available with select/FIONREAD,
-     and fails if those are unavailable */
-  if (have_timeout && tmsec == 0 && tmusec == 0)
-    return (input_avail (fd) ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
-
-  /* Convenience: check early whether or not the first of possibly several
-     variable names is a valid identifier, and bail early if so. */
-#if defined (ARRAY_VARS)
-  if (list)
-    SET_VFLAGS (list->word->flags, vflags, bindflags);
-  if (list && legal_identifier (list->word->word) == 0 && valid_array_reference (list->word->word, vflags) == 0)
-#else
-  bindflags = 0;
-  if (list && legal_identifier (list->word->word) == 0)
-#endif
-    {
-      sh_invalidid (list->word->word);
-      return (EXECUTION_FAILURE);
-    }
-
-  /* If we're asked to ignore the delimiter, make sure we do. */
-  if (ignore_delim)
-    delim = -1;
-
-  /* IF IFS is unset, we use the default of " \t\n". */
-  ifs_chars = getifs ();
-  if (ifs_chars == 0)		/* XXX - shouldn't happen */
-    ifs_chars = "";
-  /* If we want to read exactly NCHARS chars, don't split on IFS */
-  if (ignore_delim)
-    ifs_chars = "";
-  for (skip_ctlesc = skip_ctlnul = 0, e = ifs_chars; *e; e++)
-    skip_ctlesc |= *e == CTLESC, skip_ctlnul |= *e == CTLNUL;
-
-  input_string = (char *)xmalloc (size = 112);	/* XXX was 128 */
-  input_string[0] = '\0';
-
-  /* More input and options validation */
-  if (nflag == 1 && nchars == 0)
-    {
-      retval = read (fd, &c, 0);
-      retval = (retval >= 0) ? EXECUTION_SUCCESS : EXECUTION_FAILURE;
-      goto assign_vars;		/* bail early if asked to read 0 chars */
-    }
-
-  /* $TMOUT, if set, is the default timeout for read. */
-  if (have_timeout == 0 && (e = get_string_value ("TMOUT")))
-    {
-      code = uconvert (e, &ival, &uval, (char **)NULL);
-      if (code == 0 || ival < 0 || uval < 0)
-	tmsec = tmusec = 0;
-      else
-	{
-	  tmsec = ival;
-	  tmusec = uval;
-	}
-    }
-
-#if defined (SIGCHLD)
-  sigemptyset (&chldset);
-  sigprocmask (SIG_BLOCK, (sigset_t *)0, &chldset);
-  sigaddset (&chldset, SIGCHLD);
-#endif
-
-  begin_unwind_frame ("read_builtin");
-
-#if defined (BUFFERED_INPUT)
-  if (interactive == 0 && default_buffered_input >= 0 && fd_is_bash_input (fd))
-    sync_buffered_stream (default_buffered_input);
-#endif
-
-#if 1
-  input_is_tty = isatty (fd);
-#else
-  input_is_tty = 1;
-#endif
-  if (input_is_tty == 0)
-#ifndef __CYGWIN__
-    input_is_pipe = (lseek (fd, 0L, SEEK_CUR) < 0) && (errno == ESPIPE);
-#else
-    input_is_pipe = 1;
-#endif
-
-  /* If the -p, -e or -s flags were given, but input is not coming from the
-     terminal, turn them off. */
-  if ((prompt || edit || silent) && input_is_tty == 0)
-    {
-      prompt = (char *)NULL;
-#if defined (READLINE)
-      itext = (char *)NULL;
-#endif
-      edit = silent = 0;
-    }
-
-#if defined (READLINE)
-  if (edit)
-    add_unwind_protect (xfree, rlbuf);
-#endif
-
-  pass_next = 0;	/* Non-zero signifies last char was backslash. */
-  saw_escape = 0;	/* Non-zero signifies that we saw an escape char */
-
-  if (tmsec > 0 || tmusec > 0)
-    {
-      /* Turn off the timeout if stdin is a regular file (e.g. from
-	 input redirection). */
-      if ((fstat (fd, &tsb) < 0) || S_ISREG (tsb.st_mode))
-	tmsec = tmusec = 0;
-    }
-
-  if (tmsec > 0 || tmusec > 0)
-    {
-      read_timeout = shtimer_alloc ();
-      read_timeout->flags = SHTIMER_LONGJMP;
-
-#if defined (HAVE_SELECT)
-      read_timeout->flags |= (edit || posixly_correct) ? SHTIMER_ALARM : SHTIMER_SELECT;
-#else
-      read_timeout->flags |= SHTIMER_ALARM;
-#endif
-      read_timeout->fd = fd;
-
-      read_timeout->alrm_handler = sigalrm;
-    }
-
-  if (tmsec > 0 || tmusec > 0)
-    {
-      code = setjmp_nosigs (read_timeout->jmpenv);
-      if (code)
-	{
-	  reset_timeout ();
-	  sigprocmask (SIG_SETMASK, &prevset, (sigset_t *)0);
-
-	  /* Tricky.  The top of the unwind-protect stack is the free of
-	     input_string.  We want to run all the rest and use input_string,
-	     so we have to save input_string temporarily, run the unwind-
-	     protects, then restore input_string so we can use it later */
-	  orig_input_string = 0;
-	  input_string[i] = '\0';	/* make sure it's terminated */
-	  if (i == 0)
-	    {
-	      t = (char *)xmalloc (1);
-	      t[0] = 0;
-	    }
-	  else
-	    t = savestring (input_string);
-
-	  run_unwind_frame ("read_builtin");
-	  input_string = t;
-	  retval = 128+SIGALRM;
-	  goto assign_vars;
-	}
-      if (interactive_shell == 0)
-	initialize_terminating_signals ();
-      add_unwind_protect (reset_timeout, (char *)NULL);
-#if defined (READLINE)
-      if (edit)
-	{
-	  add_unwind_protect (reset_attempted_completion_function, (char *)NULL);
-	  add_unwind_protect (bashline_reset_event_hook, (char *)NULL);
-	  set_readline_timeout (read_timeout, tmsec, tmusec);
-	}
-      else
-#endif
-      shtimer_set (read_timeout, tmsec, tmusec);
-    }
-
-  /* If we've been asked to read only NCHARS chars, or we're using some
-     character other than newline to terminate the line, do the right
-     thing to readline or the tty. */
-  if (nchars > 0 || delim != '\n')
-    {
-#if defined (READLINE)
-      if (edit)
-	{
-	  if (nchars > 0)
-	    {
-	      unwind_protect_int (rl_num_chars_to_read);
-	      rl_num_chars_to_read = nchars;
-	    }
-	  if (delim != '\n')
-	    {
-	      set_eol_delim (delim);
-	      add_unwind_protect (reset_eol_delim, (char *)NULL);
-	    }
-	}
-      else
-#endif
-      if (input_is_tty)
-	{
-	  /* ttsave() */
-	  termsave.fd = fd;
-	  ttgetattr (fd, &ttattrs);
-	  termsave.attrs = ttattrs;
-
-	  ttset = ttattrs;	  
-	  i = silent ? ttfd_cbreak (fd, &ttset) : ttfd_onechar (fd, &ttset);
-	  if (i < 0)
-	    sh_ttyerror (1);
-	  tty_modified = 1;
-	  add_unwind_protect ((Function *)ttyrestore, (char *)&termsave);
-	  if (interactive_shell == 0)
-	    initialize_terminating_signals ();
-	}
-    }
-  else if (silent)	/* turn off echo but leave term in canonical mode */
-    {
-      /* ttsave (); */
-      termsave.fd = fd;
-      ttgetattr (fd, &ttattrs);
-      termsave.attrs = ttattrs;
-
-      ttset = ttattrs;
-      i = ttfd_noecho (fd, &ttset);			/* ttnoecho (); */
-      if (i < 0)
-	sh_ttyerror (1);
-
-      tty_modified = 1;
-      add_unwind_protect ((Function *)ttyrestore, (char *)&termsave);
-      if (interactive_shell == 0)
-	initialize_terminating_signals ();
-    }
-
-#if defined (READLINE)
-  save_instream = 0;
-  if (edit && fd != 0)
-    {
-      if (bash_readline_initialized == 0)
-	initialize_readline ();
-
-      unwind_protect_var (rl_instream);
-      save_instream = rl_instream;
-      rl_instream = fdopen (fd, "r");	
-    }
-#endif
-
-  /* This *must* be the top unwind-protect on the stack, so the manipulation
-     of the unwind-protect stack after the realloc() works right. */
-  add_unwind_protect (xfree, input_string);
-
-  check_read_timeout ();
-  /* These only matter if edit == 0 */
-  if ((nchars > 0) && (input_is_tty == 0) && ignore_delim)	/* read -N */
-    unbuffered_read = 2;
-#if 0
-  else if ((nchars > 0) || (delim != '\n') || input_is_pipe)
-#else
-  else if (((nchars > 0 || delim != '\n') && input_is_tty) || input_is_pipe)
-    unbuffered_read = 1;
-#endif
-  if (prompt && edit == 0)
-    {
-      fprintf (stderr, "%s", prompt);
-      fflush (stderr);
-    }
-
-#if defined (__CYGWIN__) && defined (O_TEXT)
-  setmode (0, O_TEXT);
-#endif
-
-  ps2 = 0;
-  for (print_ps2 = eof = retval = 0;;)
-    {
-      check_read_timeout ();
-
-#if defined (READLINE)
-      if (edit)
-	{
-	  /* If we have a null delimiter, don't treat NULL as ending the line */
-	  if (rlbuf && rlbuf[rlind] == '\0' && delim != '\0')
-	    {
-	      free (rlbuf);
-	      rlbuf = (char *)0;
-	    }
-#if defined (SIGCHLD)
-	  if (tmsec > 0 || tmusec > 0)
-	    sigprocmask (SIG_SETMASK, &chldset, &prevset);
-#endif
-	  if (rlbuf == 0)
-	    {
-	      reading = 1;
-	      rlbuf = edit_line (prompt ? prompt : "", itext);
-	      reading = 0;
-	      rlind = 0;
-	    }
-#if defined (SIGCHLD)
-	  if (tmsec > 0 || tmusec > 0)
-	    sigprocmask (SIG_SETMASK, &prevset, (sigset_t *)0);
-#endif
-	  if (rlbuf == 0)
-	    {
-	      eof = 1;
-	      break;
-	    }
-	  c = rlbuf[rlind++];
-	}
-      else
-	{
-#endif
-
-      if (print_ps2)
-	{
-	  if (ps2 == 0)
-	    ps2 = get_string_value ("PS2");
-	  fprintf (stderr, "%s", ps2 ? ps2 : "");
-	  fflush (stderr);
-	  print_ps2 = 0;
-	}
-
-      reading = 1;
-      check_read_timeout ();
-      errno = 0;
-
-#if defined (SIGCHLD)
-      if (tmsec > 0 || tmusec > 0)
-	sigprocmask (SIG_SETMASK, &chldset, &prevset);
-#endif
-      if (unbuffered_read == 2)
-	retval = posixly_correct ? zreadintr (fd, &c, 1) : zreadn (fd, &c, nchars - nr);
-      else if (unbuffered_read)
-	retval = posixly_correct ? zreadintr (fd, &c, 1) : zread (fd, &c, 1);
-      else
-	retval = posixly_correct ? zreadcintr (fd, &c) : zreadc (fd, &c);
-#if defined (SIGCHLD)
-      if (tmsec > 0 || tmusec > 0)
-	sigprocmask (SIG_SETMASK, &prevset, (sigset_t *)0);
-#endif
-
-      reading = 0;
-
-      if (retval <= 0)
-	{
-	  int t;
-
-	  t = errno;
-	  if (retval < 0 && errno == EINTR)
-	    {
-	      check_signals ();		/* in case we didn't call zread via zreadc */
-	      lastsig = LASTSIG();
-	      if (lastsig == 0)
-		lastsig = trapped_signal_received;
-#if 0
-	      run_pending_traps ();	/* because interrupt_immediately is not set */
-#endif
-	    }
-	  else
-	    lastsig = 0;
-	  if (terminating_signal && tty_modified)
-	    ttyrestore (&termsave);	/* fix terminal before exiting */
-	  CHECK_TERMSIG;
-	  eof = 1;
-	  errno = t;	/* preserve it for the error message below */
-	  break;
-	}
-
-      QUIT;		/* in case we didn't call check_signals() */
-#if defined (READLINE)
-	}
-#endif
-
-      if (retval <= 0)			/* XXX shouldn't happen */
-	check_read_timeout ();
-
-      /* XXX -- use i + mb_cur_max (at least 4) for multibyte/read_mbchar */
-      if (i + (mb_cur_max > 4 ? mb_cur_max : 4) >= size)
-	{
-	  char *t;
-	  t = (char *)xrealloc (input_string, size += 128);
-
-	  /* Only need to change unwind-protect if input_string changes */
-	  if (t != input_string)
-	    {
-	      input_string = t;
-	      remove_unwind_protect ();
-	      add_unwind_protect (xfree, input_string);
-	    }
-	}
-
-      /* If the next character is to be accepted verbatim, a backslash
-	 newline pair still disappears from the input. */
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  if (c == '\n')
-	    {
-	      if (skip_ctlesc == 0 && i > 0)
-		i--;		/* back up over the CTLESC */
-	      if (interactive && input_is_tty && raw == 0)
-		print_ps2 = 1;
-	    }
-	  else
-	    goto add_char;
-	  continue;
-	}
-
-      /* This may cause problems if IFS contains CTLESC */
-      if (c == '\\' && raw == 0)
-	{
-	  pass_next++;
-	  if (skip_ctlesc == 0)
-	    {
-	      saw_escape++;
-	      input_string[i++] = CTLESC;
-	    }
-	  continue;
-	}
-
-      if (ignore_delim == 0 && (unsigned char)c == delim)
-	break;
-
-      if (c == '\0' && delim != '\0')
-	continue;		/* skip NUL bytes in input */
-
-      if ((skip_ctlesc == 0 && c == CTLESC) || (skip_ctlnul == 0 && c == CTLNUL))
-	{
-	  saw_escape++;
-	  input_string[i++] = CTLESC;
-	}
-
-add_char:
-      input_string[i++] = c;
-      check_read_timeout ();
-
-#if defined (HANDLE_MULTIBYTE)
-      /* XXX - what if C == 127? Can DEL introduce a multibyte sequence? */
-      if (mb_cur_max > 1 && is_basic (c) == 0)
-	{
-	  input_string[i] = '\0';	/* for simplicity and debugging */
-	  /* If we got input from readline, grab the next multibyte char from
-	     rlbuf. */
-#  if defined (READLINE)
-	  if (edit)
-	    {
-	      size_t clen;
-	      clen = mbrlen (rlbuf + rlind - 1, mb_cur_max, (mbstate_t *)NULL);
-	      /* We only deal with valid multibyte sequences longer than one
-		 byte. If we get anything else, we leave the one character
-		 copied and move on to the next. */
-	      if ((int)clen > 1)
-		{
-		  memcpy (input_string+i, rlbuf+rlind, clen-1);
-		  i += clen - 1;
-		  rlind += clen - 1;
-		}
-	    }
-	  else
-#  endif
-	  if (locale_utf8locale == 0 || ((c & 0x80) != 0))
-	    i += read_mbchar (fd, input_string, i, c, unbuffered_read);
-	}
-#endif
-
-      nr++;
-
-      if (nchars > 0 && nr >= nchars)
-	break;
-    }
-  input_string[i] = '\0';
-  check_read_timeout ();
-
-#if defined (READLINE)
-  if (edit)
-    free (rlbuf);
-#endif
-
-  if (retval < 0)
-    {
-      t_errno = errno;
-      if (errno != EINTR)
-	builtin_error (_("read error: %d: %s"), fd, strerror (errno));
-      run_unwind_frame ("read_builtin");
-      return ((t_errno != EINTR) ? EXECUTION_FAILURE : 128+lastsig);
-    }
-
-  if (tmsec > 0 || tmusec > 0)
-    reset_timeout ();
-
-  if (nchars > 0 || delim != '\n')
-    {
-#if defined (READLINE)
-      if (edit)
-	{
-	  if (nchars > 0)
-	    rl_num_chars_to_read = 0;
-	  if (delim != '\n')
-	    reset_eol_delim ((char *)NULL);
-	}
-      else
-#endif
-      if (input_is_tty)
-	ttyrestore (&termsave);
-    }
-  else if (silent)
-    ttyrestore (&termsave);
-
-  if (unbuffered_read == 0)
-    zsyncfd (fd);
-
-#if defined (READLINE)
-  if (save_instream)
-    rl_instream = save_instream;	/* can't portably free it */
-#endif
-
-  discard_unwind_frame ("read_builtin");
-
-  retval = eof ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
-
-assign_vars:
-
-#if defined (ARRAY_VARS)
-  /* If -a was given, take the string read, break it into a list of words,
-     an assign them to `arrayname' in turn. */
-  if (arrayname)
-    {
-      /* pass 1 for flags arg to clear the existing array + 2 to check for a
-	 valid identifier. */
-      var = builtin_find_indexed_array (arrayname, 3);
-      if (var == 0)
-	{
-	  free (input_string);
-	  return EXECUTION_FAILURE;	/* readonly or noassign */
-	}
-
-      alist = list_string (input_string, ifs_chars, 0);
-      if (alist)
-	{
-	  if (saw_escape)
-	    dequote_list (alist);
-	  else
-	    word_list_remove_quoted_nulls (alist);
-	  assign_array_var_from_word_list (var, alist, 0);
-	  dispose_words (alist);
-	}
-      free (input_string);
-      return (retval);
-    }
-#endif /* ARRAY_VARS */ 
-
-  /* If there are no variables, save the text of the line read to the
-     variable $REPLY.  ksh93 strips leading and trailing IFS whitespace,
-     so that `read x ; echo "$x"' and `read ; echo "$REPLY"' behave the
-     same way, but I believe that the difference in behaviors is useful
-     enough to not do it.  Without the bash behavior, there is no way
-     to read a line completely without interpretation or modification
-     unless you mess with $IFS (e.g., setting it to the empty string).
-     If you disagree, change the occurrences of `#if 0' to `#if 1' below. */
-  if (list == 0)
-    {
-#if 0
-      orig_input_string = input_string;
-      for (t = input_string; ifs_chars && *ifs_chars && spctabnl(*t) && isifs(*t); t++)
-	;
-      input_string = t;
-      input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars, saw_escape);
-#endif
-
-      if (saw_escape)
-	{
-	  t = dequote_string (input_string);
-	  var = bind_variable ("REPLY", t, 0);
-	  free (t);
-	}
-      else
-	var = bind_variable ("REPLY", input_string, 0);
-      if (var == 0 || readonly_p (var) || noassign_p (var))
-	retval = EXECUTION_FAILURE;
-      else
-	VUNSETATTR (var, att_invisible);
-
-      free (input_string);
-      return (retval);
-    }
-
-  /* This code implements the Posix.2 spec for splitting the words
-     read and assigning them to variables. */
-  orig_input_string = input_string;
-
-  /* Remove IFS white space at the beginning of the input string.  If
-     $IFS is null, no field splitting is performed. */
-  for (t = input_string; ifs_chars && *ifs_chars && spctabnl(*t) && isifs(*t); t++)
-    ;
-  input_string = t;
-  for (; list->next; list = list->next)
-    {
-      varname = list->word->word;
-#if defined (ARRAY_VARS)
-      SET_VFLAGS (list->word->flags, vflags, bindflags);
-      if (legal_identifier (varname) == 0 && valid_array_reference (varname, vflags) == 0)
-#else
-      if (legal_identifier (varname) == 0)
-#endif
-	{
-	  sh_invalidid (varname);
-	  free (orig_input_string);
-	  return (EXECUTION_FAILURE);
-	}
-
-      /* If there are more variables than words read from the input,
-	 the remaining variables are set to the empty string. */
-      if (*input_string)
-	{
-	  /* This call updates INPUT_STRING. */
-	  t = get_word_from_string (&input_string, ifs_chars, &e);
-	  if (t)
-	    *e = '\0';
-	  /* Don't bother to remove the CTLESC unless we added one
-	     somewhere while reading the string. */
-	  if (t && saw_escape)
-	    {
-	      t1 = dequote_string (t);
-	      var = bind_read_variable (varname, t1, bindflags);
-	      free (t1);
-	    }
-	  else
-	    var = bind_read_variable (varname, t ? t : "", bindflags);
-	}
-      else
-	{
-	  t = (char *)0;
-	  var = bind_read_variable (varname, "", bindflags);
-	}
-
-      FREE (t);
-      if (var == 0)
-	{
-	  free (orig_input_string);
-	  return (EXECUTION_FAILURE);
-	}
-
-      stupidly_hack_special_variables (varname);
-      VUNSETATTR (var, att_invisible);
-    }
-
-  /* Now assign the rest of the line to the last variable argument. */
-#if defined (ARRAY_VARS)
-  SET_VFLAGS (list->word->flags, vflags, bindflags);
-  if (legal_identifier (list->word->word) == 0 && valid_array_reference (list->word->word, vflags) == 0)
-#else
-  if (legal_identifier (list->word->word) == 0)
-#endif
-    {
-      sh_invalidid (list->word->word);
-      free (orig_input_string);
-      return (EXECUTION_FAILURE);
-    }
-
-#if 0
-  /* This has to be done this way rather than using string_list
-     and list_string because Posix.2 says that the last variable gets the
-     remaining words and their intervening separators. */
-  input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars, saw_escape);
-#else
-  /* Check whether or not the number of fields is exactly the same as the
-     number of variables. */
-  tofree = NULL;
-  if (*input_string)
-    {
-      t1 = input_string;
-      t = get_word_from_string (&input_string, ifs_chars, &e);
-      if (*input_string == 0)
-	tofree = input_string = t;
-      else
-	{
-	  input_string = strip_trailing_ifs_whitespace (t1, ifs_chars, saw_escape);
-	  tofree = t;
-	}
-    }
-#endif
-
-  if (saw_escape && input_string && *input_string)
-    {
-      t = dequote_string (input_string);
-      var = bind_read_variable (list->word->word, t, bindflags);
-      free (t);
-    }
-  else
-    var = bind_read_variable (list->word->word, input_string ? input_string : "", bindflags);
-
-  if (var)
-    {
-      stupidly_hack_special_variables (list->word->word);
-      VUNSETATTR (var, att_invisible);
-    }
-  else
-    retval = EXECUTION_FAILURE;
-
-  FREE (tofree);
-  free (orig_input_string);
-
-  return (retval);
-}
-
-static SHELL_VAR *
-bind_read_variable (name, value, flags)
-     char *name, *value;
-     int flags;
-{
-  SHELL_VAR *v;
-
-  v = builtin_bind_variable (name, value, flags);
-  return (v == 0 ? v
-		 : ((readonly_p (v) || noassign_p (v)) ? (SHELL_VAR *)NULL : v));
-}
-
-#if defined (HANDLE_MULTIBYTE)
-static int
-read_mbchar (fd, string, ind, ch, unbuffered)
-     int fd;
-     char *string;
-     int ind, ch, unbuffered;
-{
-  char mbchar[MB_LEN_MAX + 1];
-  int i, n, r;
-  char c;
-  size_t ret;
-  mbstate_t ps, ps_back;
-  wchar_t wc;
-
-  memset (&ps, '\0', sizeof (mbstate_t));
-  memset (&ps_back, '\0', sizeof (mbstate_t));
-  
-  mbchar[0] = ch;
-  i = 1;
-  for (n = 0; n <= MB_LEN_MAX; n++)
-    {
-      ps_back = ps;
-      ret = mbrtowc (&wc, mbchar, i, &ps);
-      if (ret == (size_t)-2)
-	{
-	  ps = ps_back;
-
-	  /* We don't want to be interrupted during a multibyte char read */
-	  if (unbuffered == 2)
-	    r = zreadn (fd, &c, 1);
-	  else if (unbuffered)
-	    r = zread (fd, &c, 1);
-	  else
-	    r = zreadc (fd, &c);
-	  if (r <= 0)
-	    goto mbchar_return;
-	  mbchar[i++] = c;	
-	  continue;
-	}
-      else if (ret == (size_t)-1 || ret == (size_t)0 || ret > (size_t)0)
-	break;
-    }
-
-mbchar_return:
-  if (i > 1)	/* read a multibyte char */
-    /* mbchar[0] is already string[ind-1] */
-    for (r = 1; r < i; r++)
-      string[ind+r-1] = mbchar[r];
-  return i - 1;
-}
-#endif
-
-
-static void
-ttyrestore (ttp)
-     struct ttsave *ttp;
-{
-  ttsetattr (ttp->fd, &(ttp->attrs));
-  tty_modified = 0;
-}
-
-void
-read_tty_cleanup ()
-{
-  if (tty_modified)
-    ttyrestore (&termsave);
-}
-
-int
-read_tty_modified ()
-{
-  return (tty_modified);
-}
-
-#if defined (READLINE)
-static rl_completion_func_t *old_attempted_completion_function = 0;
-static rl_hook_func_t *old_startup_hook;
-static char *deftext;
-
-static void
-reset_attempted_completion_function (cp)
-     char *cp;
-{
-  if (rl_attempted_completion_function == 0 && old_attempted_completion_function)
-    rl_attempted_completion_function = old_attempted_completion_function;
-}
-
-static int
-set_itext ()
-{
-  int r1, r2;
-
-  r1 = r2 = 0;
-  if (old_startup_hook)
-    r1 = (*old_startup_hook) ();
-  if (deftext)
-    {
-      r2 = rl_insert_text (deftext);
-      deftext = (char *)NULL;
-      rl_startup_hook = old_startup_hook;
-      old_startup_hook = (rl_hook_func_t *)NULL;
-    }
-  return (r1 || r2);
-}
-
-static char *
-edit_line (p, itext)
-     char *p;
-     char *itext;
-{
-  char *ret;
-  int len;
-
-  if (bash_readline_initialized == 0)
-    initialize_readline ();
-
-  old_attempted_completion_function = rl_attempted_completion_function;
-  rl_attempted_completion_function = (rl_completion_func_t *)NULL;
-  bashline_set_event_hook ();
-  if (itext)
-    {
-      old_startup_hook = rl_startup_hook;
-      rl_startup_hook = set_itext;
-      deftext = itext;
-    }
-
-  ret = readline (p);
-
-  rl_attempted_completion_function = old_attempted_completion_function;
-  old_attempted_completion_function = (rl_completion_func_t *)NULL;
-  bashline_reset_event_hook ();
-
-  if (ret == 0)
-    {
-      if (RL_ISSTATE (RL_STATE_TIMEOUT))
-	{
-	  sigalrm (SIGALRM);		/* simulate receiving SIGALRM */
-	  check_read_timeout ();
-	}
-      return ret;
-    }
-
-  len = strlen (ret);
-  ret = (char *)xrealloc (ret, len + 2);
-  ret[len++] = delim;
-  ret[len] = '\0';
-  return ret;
-}
-
-static void
-set_readline_timeout (t, sec, usec)
-     sh_timer *t;
-     time_t sec;
-     long usec;
-{
-  t->tmout.tv_sec = sec;
-  t->tmout.tv_usec = usec;
-  rl_set_timeout (sec, usec);
-}
-
-static int old_delim_ctype;
-static rl_command_func_t *old_delim_func;
-static int old_newline_ctype;
-static rl_command_func_t *old_newline_func;
-
-static unsigned char delim_char;
-
-static void
-set_eol_delim (c)
-     int c;
-{
-  Keymap cmap;
-
-  if (bash_readline_initialized == 0)
-    initialize_readline ();
-  cmap = rl_get_keymap ();
-
-  /* Save the old delimiter char binding */
-  old_newline_ctype = cmap[RETURN].type;
-  old_newline_func =  cmap[RETURN].function;
-  old_delim_ctype = cmap[c].type;
-  old_delim_func = cmap[c].function;
-
-  /* Change newline to self-insert */
-  cmap[RETURN].type = ISFUNC;
-  cmap[RETURN].function = rl_insert;
-
-  /* Bind the delimiter character to accept-line. */
-  cmap[c].type = ISFUNC;
-  cmap[c].function = rl_newline;
-
-  delim_char = c;
-}
-
-static void
-reset_eol_delim (cp)
-     char *cp;
-{
-  Keymap cmap;
-
-  cmap = rl_get_keymap ();
-
-  cmap[RETURN].type = old_newline_ctype;
-  cmap[RETURN].function = old_newline_func;
-
-  cmap[delim_char].type = old_delim_ctype;
-  cmap[delim_char].function = old_delim_func;
-}
-#endif
diff --git a/third_party/bash/redir.c b/third_party/bash/redir.c
deleted file mode 100644
index 6a9feac99..000000000
--- a/third_party/bash/redir.c
+++ /dev/null
@@ -1,1528 +0,0 @@
-/* redir.c -- Functions to perform input and output redirection. */
-
-/* Copyright (C) 1997-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
-  #pragma alloca
-#endif /* _AIX && RISC6000 && !__GNUC__ */
-
-#include <stdio.h>
-#include "bashtypes.h"
-#if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-#include "filecntl.h"
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <errno.h>
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#include "bashansi.h"
-#include "bashintl.h"
-#include "memalloc.h"
-
-#define NEED_FPURGE_DECL
-
-#include "shell.h"
-#include "flags.h"
-#include "execute_cmd.h"
-#include "redir.h"
-#include "trap.h"
-
-#if defined (BUFFERED_INPUT)
-#  include "input.h"
-#endif
-
-#include "pipesize.h"
-
-/* FreeBSD 13 can reliably handle atomic writes at this capacity without
-   hanging. */
-#if __FreeBSD__ && !defined (HEREDOC_PIPESIZE)
-#  define HEREDOC_PIPESIZE 4096
-#endif
-
-/* Normally set by a build process command that computes pipe capacity */
-#ifndef PIPESIZE
-#  ifdef PIPE_BUF
-#    define PIPESIZE PIPE_BUF
-#  else
-#    define PIPESIZE 4096
-#  endif
-#endif
-
-#ifndef HEREDOC_PIPESIZE
-#  define HEREDOC_PIPESIZE PIPESIZE
-#endif
-
-#if defined (HEREDOC_PIPEMAX)
-#  if HEREDOC_PIPESIZE > HEREDOC_PIPEMAX
-#    define HEREDOC_PIPESIZE HEREDOC_PIPEMAX
-#  endif
-#endif
-
-#define SHELL_FD_BASE	10
-
-int expanding_redir;
-int varassign_redir_autoclose = 0;
-
-extern REDIRECT *redirection_undo_list;
-extern REDIRECT *exec_redirection_undo_list;
-
-/* Static functions defined and used in this file. */
-static void add_exec_redirect PARAMS((REDIRECT *));
-static int add_undo_redirect PARAMS((int, enum r_instruction, int));
-static int add_undo_close_redirect PARAMS((int));
-static int expandable_redirection_filename PARAMS((REDIRECT *));
-static int stdin_redirection PARAMS((enum r_instruction, int));
-static int undoablefd PARAMS((int));
-static int do_redirection_internal PARAMS((REDIRECT *, int, char **));
-
-static char *heredoc_expand PARAMS((WORD_DESC *, enum r_instruction, size_t *));
-static int heredoc_write PARAMS((int, char *, size_t));
-static int here_document_to_fd PARAMS((WORD_DESC *, enum r_instruction));
-
-static int redir_special_open PARAMS((int, char *, int, int, enum r_instruction));
-static int noclobber_open PARAMS((char *, int, int, enum r_instruction));
-static int redir_open PARAMS((char *, int, int, enum r_instruction));
-
-static int redir_varassign PARAMS((REDIRECT *, int));
-static int redir_varvalue PARAMS((REDIRECT *));
-
-/* Spare redirector used when translating [N]>&WORD[-] or [N]<&WORD[-] to
-   a new redirection and when creating the redirection undo list. */
-static REDIRECTEE rd;
-
-/* Set to errno when a here document cannot be created for some reason.
-   Used to print a reasonable error message. */
-static int heredoc_errno;
-
-#define REDIRECTION_ERROR(r, e, fd) \
-do { \
-  if ((r) < 0) \
-    { \
-      if (fd >= 0) \
-	close (fd); \
-      set_exit_status (EXECUTION_FAILURE);\
-      return ((e) == 0 ? EINVAL : (e));\
-    } \
-} while (0)
-
-void
-redirection_error (temp, error, fn)
-     REDIRECT *temp;
-     int error;
-     char *fn;		/* already-expanded filename */
-{
-  char *filename, *allocname;
-  int oflags;
-
-  allocname = 0;
-  if ((temp->rflags & REDIR_VARASSIGN) && error < 0)
-    filename = allocname = savestring (temp->redirector.filename->word);
-  else if ((temp->rflags & REDIR_VARASSIGN) == 0 && temp->redirector.dest < 0)
-    /* This can happen when read_token_word encounters overflow, like in
-       exec 4294967297>x */
-    filename = _("file descriptor out of range");
-#ifdef EBADF
-  /* This error can never involve NOCLOBBER */
-  else if (error != NOCLOBBER_REDIRECT && temp->redirector.dest >= 0 && error == EBADF)
-    {
-      /* If we're dealing with two file descriptors, we have to guess about
-         which one is invalid; in the cases of r_{duplicating,move}_input and
-         r_{duplicating,move}_output we're here because dup2() failed. */
-      switch (temp->instruction)
-        {
-        case r_duplicating_input:
-        case r_duplicating_output:
-        case r_move_input:
-        case r_move_output:
-	  filename = allocname = itos (temp->redirectee.dest);
-	  break;
-	case r_duplicating_input_word:
-	  if (temp->redirector.dest == 0)	/* Guess */
-	    filename = temp->redirectee.filename->word;	/* XXX */
-	  else
-	    filename = allocname = itos (temp->redirector.dest);
-	  break;
-	case r_duplicating_output_word:
-	  if (temp->redirector.dest == 1)	/* Guess */
-	    filename = temp->redirectee.filename->word;	/* XXX */
-	  else
-	    filename = allocname = itos (temp->redirector.dest);
-	  break;
-	default:
-	  filename = allocname = itos (temp->redirector.dest);
-	  break;
-        }
-    }
-#endif
-  else if (fn)
-    filename = fn;
-  else if (expandable_redirection_filename (temp))
-    {
-      oflags = temp->redirectee.filename->flags;
-      if (posixly_correct && interactive_shell == 0)
-	temp->redirectee.filename->flags |= W_NOGLOB;
-      temp->redirectee.filename->flags |= W_NOCOMSUB;
-      filename = allocname = redirection_expand (temp->redirectee.filename);
-      temp->redirectee.filename->flags = oflags;
-      if (filename == 0)
-	filename = temp->redirectee.filename->word;
-    }
-  else if (temp->redirectee.dest < 0)
-    filename = _("file descriptor out of range");
-  else
-    filename = allocname = itos (temp->redirectee.dest);
-
-  switch (error)
-    {
-    case AMBIGUOUS_REDIRECT:
-      internal_error (_("%s: ambiguous redirect"), filename);
-      break;
-
-    case NOCLOBBER_REDIRECT:
-      internal_error (_("%s: cannot overwrite existing file"), filename);
-      break;
-
-#if defined (RESTRICTED_SHELL)
-    case RESTRICTED_REDIRECT:
-      internal_error (_("%s: restricted: cannot redirect output"), filename);
-      break;
-#endif /* RESTRICTED_SHELL */
-
-    case HEREDOC_REDIRECT:
-      internal_error (_("cannot create temp file for here-document: %s"), strerror (heredoc_errno));
-      break;
-
-    case BADVAR_REDIRECT:
-      internal_error (_("%s: cannot assign fd to variable"), filename);
-      break;
-
-    default:
-      internal_error ("%s: %s", filename, strerror (error));
-      break;
-    }
-
-  FREE (allocname);
-}
-
-/* Perform the redirections on LIST.  If flags & RX_ACTIVE, then actually
-   make input and output file descriptors, otherwise just do whatever is
-   necessary for side effecting.  flags & RX_UNDOABLE says to remember
-   how to undo the redirections later, if non-zero.  If flags & RX_CLEXEC
-   is non-zero, file descriptors opened in do_redirection () have their
-   close-on-exec flag set. */
-int
-do_redirections (list, flags)
-     REDIRECT *list;
-     int flags;
-{
-  int error;
-  REDIRECT *temp;
-  char *fn;
-
-  if (flags & RX_UNDOABLE)
-    {
-      if (redirection_undo_list)
-	{
-	  dispose_redirects (redirection_undo_list);
-	  redirection_undo_list = (REDIRECT *)NULL;
-	}
-      if (exec_redirection_undo_list)
-	dispose_exec_redirects ();
-    }
-
-  for (temp = list; temp; temp = temp->next)
-    {
-      fn = 0;
-      error = do_redirection_internal (temp, flags, &fn);
-      if (error)
-	{
-	  redirection_error (temp, error, fn);
-	  FREE (fn);
-	  return (error);
-	}
-      FREE (fn);
-    }
-  return (0);
-}
-
-/* Return non-zero if the redirection pointed to by REDIRECT has a
-   redirectee.filename that can be expanded. */
-static int
-expandable_redirection_filename (redirect)
-     REDIRECT *redirect;
-{
-  switch (redirect->instruction)
-    {
-    case r_output_direction:
-    case r_appending_to:
-    case r_input_direction:
-    case r_inputa_direction:
-    case r_err_and_out:
-    case r_append_err_and_out:
-    case r_input_output:
-    case r_output_force:
-    case r_duplicating_input_word:
-    case r_duplicating_output_word:
-    case r_move_input_word:
-    case r_move_output_word:
-      return 1;
-
-    default:
-      return 0;
-    }
-}
-
-/* Expand the word in WORD returning a string.  If WORD expands to
-   multiple words (or no words), then return NULL. */
-char *
-redirection_expand (word)
-     WORD_DESC *word;
-{
-  char *result;
-  WORD_LIST *tlist1, *tlist2;
-  WORD_DESC *w;
-  int old;
-
-  w = copy_word (word);
-  if (posixly_correct)
-    w->flags |= W_NOSPLIT;
-
-  tlist1 = make_word_list (w, (WORD_LIST *)NULL);
-  expanding_redir = 1;
-  /* Now that we've changed the variable search order to ignore the temp
-     environment, see if we need to change the cached IFS values. */
-  sv_ifs ("IFS");
-  tlist2 = expand_words_no_vars (tlist1);
-  expanding_redir = 0;
-  /* Now we need to change the variable search order back to include the temp
-     environment.  We force the temp environment search by forcing
-     executing_builtin to 1.  This is what makes `read' get the right values
-     for the IFS-related cached variables, for example. */
-  old = executing_builtin;
-  executing_builtin = 1;
-  sv_ifs ("IFS");
-  executing_builtin = old;
-  dispose_words (tlist1);
-
-  if (tlist2 == 0 || tlist2->next)
-    {
-      /* We expanded to no words, or to more than a single word.
-	 Dispose of the word list and return NULL. */
-      if (tlist2)
-	dispose_words (tlist2);
-      return ((char *)NULL);
-    }
-  result = string_list (tlist2);  /* XXX savestring (tlist2->word->word)? */
-  dispose_words (tlist2);
-  return (result);
-}
-
-/* Expand a here-document or here-string (determined by RI) contained in
-   REDIRECTEE and return the expanded document. If LENP is non-zero, put
-   the length of the returned string into *LENP.
-
-   This captures everything about expanding here-documents and here-strings:
-   the returned document should be written directly to whatever file
-   descriptor is specified. In particular, it adds a newline to the end of
-   a here-string to preserve previous semantics. */
-static char *
-heredoc_expand (redirectee, ri, lenp)
-     WORD_DESC *redirectee;
-     enum r_instruction ri;
-     size_t *lenp;
-{
-  char *document;
-  size_t dlen;
-  int old;
-
-  if (redirectee->word == 0 || redirectee->word[0] == '\0')
-    {
-      if (lenp)
-        *lenp = 0;
-      return (redirectee->word);
-    }
-
-  /* Quoted here documents are not expanded */
-  if (ri != r_reading_string && (redirectee->flags & W_QUOTED))
-    {
-      if (lenp)
-        *lenp = STRLEN (redirectee->word);
-      return (redirectee->word);
-    }
-  
-  expanding_redir = 1;
-  /* Now that we've changed the variable search order to ignore the temp
-     environment, see if we need to change the cached IFS values. */
-  sv_ifs ("IFS");
-  document = (ri == r_reading_string) ? expand_assignment_string_to_string (redirectee->word, 0)
-  				      : expand_string_to_string (redirectee->word, Q_HERE_DOCUMENT);
-  expanding_redir = 0;
-  /* Now we need to change the variable search order back to include the temp
-     environment.  We force the temp environment search by forcing
-     executing_builtin to 1.  This is what makes `read' get the right values
-     for the IFS-related cached variables, for example. */
-  old = executing_builtin;
-  executing_builtin = 1;
-  sv_ifs ("IFS");
-  executing_builtin = old;
-
-  dlen = STRLEN (document);
-  /* XXX - Add trailing newline to here-string */
-  if (ri == r_reading_string)
-    {
-      document = xrealloc (document, dlen + 2);
-      document[dlen++] = '\n';
-      document[dlen] = '\0';
-    }
-  if (lenp)
-    *lenp = dlen;    
-
-  return document;
-}
-
-/* Write HEREDOC (of length HDLEN) to FD, returning 0 on success and ERRNO on
-   error. Don't handle interrupts. */
-static int
-heredoc_write (fd, heredoc, herelen)
-     int fd;
-     char *heredoc;
-     size_t herelen;
-{
-  ssize_t nw;
-  int e;
-
-  errno = 0;
-  nw = write (fd, heredoc, herelen);
-  e = errno;
-  if (nw != herelen)
-    {
-      if (e == 0)
-	e = ENOSPC;
-      return e;
-    }
-  return 0;
-}
-
-/* Create a temporary file or pipe holding the text of the here document
-   pointed to by REDIRECTEE, and return a file descriptor open for reading
-   to it. Return -1 on any error, and make sure errno is set appropriately. */
-static int
-here_document_to_fd (redirectee, ri)
-     WORD_DESC *redirectee;
-     enum r_instruction ri;
-{
-  char *filename;
-  int r, fd, fd2, herepipe[2];
-  char *document;
-  size_t document_len;
-#if HEREDOC_PARANOID
-  struct stat st1, st2;
-#endif
-
-  /* Expand the here-document/here-string first and then decide what to do. */
-  document = heredoc_expand (redirectee, ri, &document_len);
-
-  /* If we have a zero-length document, don't mess with a temp file */
-  if (document_len == 0)
-    {
-      fd = open ("/dev/null", O_RDONLY);
-      r = errno;
-      if (document != redirectee->word)
-	FREE (document);
-      errno = r;
-      return fd;
-    }
-
-  if (shell_compatibility_level <= 50)
-    goto use_tempfile;
-
-#if HEREDOC_PIPESIZE
-  /* Try to use a pipe internal to this process if the document is shorter
-     than the system's pipe capacity (computed at build time). We want to
-     write the entire document without write blocking. */
-  if (document_len <= HEREDOC_PIPESIZE)
-    {
-      if (pipe (herepipe) < 0)
-	{
-	  /* XXX - goto use_tempfile; ? */
-	  r = errno;
-	  if (document != redirectee->word)
-	    free (document);
-	  errno = r;
-	  return (-1);
-	}
-
-#if defined (F_GETPIPE_SZ)
-      if (fcntl (herepipe[1], F_GETPIPE_SZ, 0) < document_len)
-	goto use_tempfile;
-#endif
-
-      r = heredoc_write (herepipe[1], document, document_len);
-      if (document != redirectee->word)
-	free (document);
-      close (herepipe[1]);
-      if (r)			/* write error */
-	{
-	  close (herepipe[0]);
-	  errno = r;
-	  return (-1);
-	}
-      return (herepipe[0]);
-    }
-#endif
-
-use_tempfile:
-
-  fd = sh_mktmpfd ("sh-thd", MT_USERANDOM|MT_USETMPDIR, &filename);
-
-  /* If we failed for some reason other than the file existing, abort */
-  if (fd < 0)
-    {
-      r = errno;
-      FREE (filename);
-      if (document != redirectee->word)
-	FREE (document);
-      errno = r;
-      return (fd);
-    }
-
-  fchmod (fd, S_IRUSR | S_IWUSR);
-  SET_CLOSE_ON_EXEC (fd);
-
-  errno = r = 0;		/* XXX */
-  r = heredoc_write (fd, document, document_len);
-  if (document != redirectee->word)
-    FREE (document);
-
-  if (r)
-    {
-      close (fd);
-      unlink (filename);
-      free (filename);
-      errno = r;
-      return (-1);
-    }
-
-  /* In an attempt to avoid races, we close the first fd only after opening
-     the second. */
-  /* Make the document really temporary.  Also make it the input. */
-  fd2 = open (filename, O_RDONLY|O_BINARY, 0600);
-
-  if (fd2 < 0)
-    {
-      r = errno;
-      unlink (filename);
-      free (filename);
-      close (fd);
-      errno = r;
-      return -1;
-    }
-
-#if HEREDOC_PARANOID
-  /* We can use same_file here to check whether or not fd and fd2 refer to
-     the same file, but we don't do that unless HEREDOC_PARANOID is defined. */
-  if (fstat (fd, &st1) < 0 || S_ISREG (st1.st_mode) == 0 ||
-      fstat (fd2, &st2) < 0 || S_ISREG (st2.st_mode) == 0 ||
-      same_file (filename, filename, &st1, &st2) == 0)
-    {
-      unlink (filename);
-      free (filename);
-      close (fd);
-      close (fd2);
-      errno = EEXIST;
-      return -1;
-    }
-#endif
-
-  close (fd);
-  if (unlink (filename) < 0)
-    {
-      r = errno;
-      close (fd2);
-      free (filename);
-      errno = r;
-      return (-1);
-    }
-
-  free (filename);
-
-  fchmod (fd2, S_IRUSR);
-  return (fd2);
-}
-
-#define RF_DEVFD	1
-#define RF_DEVSTDERR	2
-#define RF_DEVSTDIN	3
-#define RF_DEVSTDOUT	4
-#define RF_DEVTCP	5
-#define RF_DEVUDP	6
-
-/* A list of pattern/value pairs for filenames that the redirection
-   code handles specially. */
-static STRING_INT_ALIST _redir_special_filenames[] = {
-#if !defined (HAVE_DEV_FD)
-  { "/dev/fd/[0-9]*", RF_DEVFD },
-#endif
-#if !defined (HAVE_DEV_STDIN)
-  { "/dev/stderr", RF_DEVSTDERR },
-  { "/dev/stdin", RF_DEVSTDIN },
-  { "/dev/stdout", RF_DEVSTDOUT },
-#endif
-#if defined (NETWORK_REDIRECTIONS)
-  { "/dev/tcp/*/*", RF_DEVTCP },
-  { "/dev/udp/*/*", RF_DEVUDP },
-#endif
-  { (char *)NULL, -1 }
-};
-
-static int
-redir_special_open (spec, filename, flags, mode, ri)
-     int spec;
-     char *filename;
-     int flags, mode;
-     enum r_instruction ri;
-{
-  int fd;
-#if !defined (HAVE_DEV_FD)
-  intmax_t lfd;
-#endif
-
-  fd = -1;
-  switch (spec)
-    {
-#if !defined (HAVE_DEV_FD)
-    case RF_DEVFD:
-      if (all_digits (filename+8) && legal_number (filename+8, &lfd) && lfd == (int)lfd)
-	{
-	  fd = lfd;
-	  fd = fcntl (fd, F_DUPFD, SHELL_FD_BASE);
-	}
-      else
-	fd = AMBIGUOUS_REDIRECT;
-      break;
-#endif
-
-#if !defined (HAVE_DEV_STDIN)
-    case RF_DEVSTDIN:
-      fd = fcntl (0, F_DUPFD, SHELL_FD_BASE);
-      break;
-    case RF_DEVSTDOUT:
-      fd = fcntl (1, F_DUPFD, SHELL_FD_BASE);
-      break;
-    case RF_DEVSTDERR:
-      fd = fcntl (2, F_DUPFD, SHELL_FD_BASE);
-      break;
-#endif
-
-#if defined (NETWORK_REDIRECTIONS)
-    case RF_DEVTCP:
-    case RF_DEVUDP:
-#if defined (RESTRICTED_SHELL)
-      if (restricted)
-	return (RESTRICTED_REDIRECT);
-#endif
-#if defined (HAVE_NETWORK)
-      fd = netopen (filename);
-#else
-      internal_warning (_("/dev/(tcp|udp)/host/port not supported without networking"));
-      fd = open (filename, flags, mode);
-#endif
-      break;
-#endif /* NETWORK_REDIRECTIONS */
-    }
-
-  return fd;
-}
-      
-/* Open FILENAME with FLAGS in noclobber mode, hopefully avoiding most
-   race conditions and avoiding the problem where the file is replaced
-   between the stat(2) and open(2). */
-static int
-noclobber_open (filename, flags, mode, ri)
-     char *filename;
-     int flags, mode;
-     enum r_instruction ri;
-{
-  int r, fd;
-  struct stat finfo, finfo2;
-
-  /* If the file exists and is a regular file, return an error
-     immediately. */
-  r = stat (filename, &finfo);
-  if (r == 0 && (S_ISREG (finfo.st_mode)))
-    return (NOCLOBBER_REDIRECT);
-
-  /* If the file was not present (r != 0), make sure we open it
-     exclusively so that if it is created before we open it, our open
-     will fail.  Make sure that we do not truncate an existing file.
-     Note that we don't turn on O_EXCL unless the stat failed -- if
-     the file was not a regular file, we leave O_EXCL off. */
-  flags &= ~O_TRUNC;
-  if (r != 0)
-    {
-      fd = open (filename, flags|O_EXCL, mode);
-      return ((fd < 0 && errno == EEXIST) ? NOCLOBBER_REDIRECT : fd);
-    }
-  fd = open (filename, flags, mode);
-
-  /* If the open failed, return the file descriptor right away. */
-  if (fd < 0)
-    return (errno == EEXIST ? NOCLOBBER_REDIRECT : fd);
-
-  /* OK, the open succeeded, but the file may have been changed from a
-     non-regular file to a regular file between the stat and the open.
-     We are assuming that the O_EXCL open handles the case where FILENAME
-     did not exist and is symlinked to an existing file between the stat
-     and open. */
-
-  /* If we can open it and fstat the file descriptor, and neither check
-     revealed that it was a regular file, and the file has not been replaced,
-     return the file descriptor. */
-  if ((fstat (fd, &finfo2) == 0) && (S_ISREG (finfo2.st_mode) == 0) &&
-      r == 0 && (S_ISREG (finfo.st_mode) == 0) &&
-      same_file (filename, filename, &finfo, &finfo2))
-    return fd;
-
-  /* The file has been replaced.  badness. */
-  close (fd);  
-  errno = EEXIST;
-  return (NOCLOBBER_REDIRECT);
-}
-
-static int
-redir_open (filename, flags, mode, ri)
-     char *filename;
-     int flags, mode;
-     enum r_instruction ri;
-{
-  int fd, r, e;
-
-  r = find_string_in_alist (filename, _redir_special_filenames, 1);
-  if (r >= 0)
-    return (redir_special_open (r, filename, flags, mode, ri));
-
-  /* If we are in noclobber mode, you are not allowed to overwrite
-     existing files.  Check before opening. */
-  if (noclobber && CLOBBERING_REDIRECT (ri))
-    {
-      fd = noclobber_open (filename, flags, mode, ri);
-      if (fd == NOCLOBBER_REDIRECT)
-	return (NOCLOBBER_REDIRECT);
-    }
-  else
-    {
-      do
-	{
-	  fd = open (filename, flags, mode);
-	  e = errno;
-	  if (fd < 0 && e == EINTR)
-	    {
-	      QUIT;
-	      run_pending_traps ();
-	    }
-	  errno = e;
-	}
-      while (fd < 0 && errno == EINTR);
-
-#if defined (AFS)
-      if ((fd < 0) && (errno == EACCES))
-	{
-	  fd = open (filename, flags & ~O_CREAT, mode);
-	  errno = EACCES;	/* restore errno */
-	}
-#endif /* AFS */
-    }
-
-  return fd;
-}
-
-static int
-undoablefd (fd)
-     int fd;
-{
-  int clexec;
-
-  clexec = fcntl (fd, F_GETFD, 0);
-  if (clexec == -1 || (fd >= SHELL_FD_BASE && clexec == 1))
-    return 0;
-  return 1;
-}
-
-/* Do the specific redirection requested.  Returns errno or one of the
-   special redirection errors (*_REDIRECT) in case of error, 0 on success.
-   If flags & RX_ACTIVE is zero, then just do whatever is necessary to
-   produce the appropriate side effects.   flags & RX_UNDOABLE, if non-zero,
-   says to remember how to undo each redirection.  If flags & RX_CLEXEC is
-   non-zero, then we set all file descriptors > 2 that we open to be
-   close-on-exec. FNP, if non-null is a pointer to a location where the
-   expanded filename is stored. The caller will free it. */
-static int
-do_redirection_internal (redirect, flags, fnp)
-     REDIRECT *redirect;
-     int flags;
-     char **fnp;
-{
-  WORD_DESC *redirectee;
-  int redir_fd, fd, redirector, r, oflags;
-  intmax_t lfd;
-  char *redirectee_word;
-  enum r_instruction ri;
-  REDIRECT *new_redirect;
-  REDIRECTEE sd;
-
-  redirectee = redirect->redirectee.filename;
-  redir_fd = redirect->redirectee.dest;
-  redirector = redirect->redirector.dest;
-  ri = redirect->instruction;
-
-  if (redirect->flags & RX_INTERNAL)
-    flags |= RX_INTERNAL;
-
-  if (TRANSLATE_REDIRECT (ri))
-    {
-      /* We have [N]>&WORD[-] or [N]<&WORD[-] (or {V}>&WORD[-] or {V}<&WORD-).
-         and WORD, then translate the redirection into a new one and 
-	 continue. */
-      redirectee_word = redirection_expand (redirectee);
-
-      /* XXX - what to do with [N]<&$w- where w is unset or null?  ksh93
-	       turns it into [N]<&- or [N]>&- and closes N. */
-      if ((ri == r_move_input_word || ri == r_move_output_word) && redirectee_word == 0)
-	{
-	  sd = redirect->redirector;
-	  rd.dest = 0;
-	  new_redirect = make_redirection (sd, r_close_this, rd, 0);
-	}
-      else if (redirectee_word == 0)
-	return (AMBIGUOUS_REDIRECT);
-      else if (redirectee_word[0] == '-' && redirectee_word[1] == '\0')
-	{
-	  sd = redirect->redirector;
-	  rd.dest = 0;
-	  new_redirect = make_redirection (sd, r_close_this, rd, 0);
-	}
-      else if (all_digits (redirectee_word))
-	{
-	  sd = redirect->redirector;
-	  if (legal_number (redirectee_word, &lfd) && (int)lfd == lfd)
-	    rd.dest = lfd;
-	  else
-	    rd.dest = -1;	/* XXX */
-	  switch (ri)
-	    {
-	    case r_duplicating_input_word:
-	      new_redirect = make_redirection (sd, r_duplicating_input, rd, 0);
-	      break;
-	    case r_duplicating_output_word:
-	      new_redirect = make_redirection (sd, r_duplicating_output, rd, 0);
-	      break;
-	    case r_move_input_word:
-	      new_redirect = make_redirection (sd, r_move_input, rd, 0);
-	      break;
-	    case r_move_output_word:
-	      new_redirect = make_redirection (sd, r_move_output, rd, 0);
-	      break;
-	    default:
-	      break;	/* shut up gcc */
-	    }
-	}
-      else if (ri == r_duplicating_output_word && (redirect->rflags & REDIR_VARASSIGN) == 0 && redirector == 1)
-	{
-	  sd = redirect->redirector;
-	  rd.filename = make_bare_word (redirectee_word);
-	  new_redirect = make_redirection (sd, r_err_and_out, rd, 0);
-	}
-      else
-	{
-	  free (redirectee_word);
-	  return (AMBIGUOUS_REDIRECT);
-	}
-
-      free (redirectee_word);
-
-      /* Set up the variables needed by the rest of the function from the
-	 new redirection. */
-      if (new_redirect->instruction == r_err_and_out)
-	{
-	  char *alloca_hack;
-
-	  /* Copy the word without allocating any memory that must be
-	     explicitly freed. */
-	  redirectee = (WORD_DESC *)alloca (sizeof (WORD_DESC));
-	  xbcopy ((char *)new_redirect->redirectee.filename,
-		 (char *)redirectee, sizeof (WORD_DESC));
-
-	  alloca_hack = (char *)
-	    alloca (1 + strlen (new_redirect->redirectee.filename->word));
-	  redirectee->word = alloca_hack;
-	  strcpy (redirectee->word, new_redirect->redirectee.filename->word);
-	}
-      else
-	/* It's guaranteed to be an integer, and shouldn't be freed. */
-	redirectee = new_redirect->redirectee.filename;
-
-      redir_fd = new_redirect->redirectee.dest;
-      redirector = new_redirect->redirector.dest;
-      ri = new_redirect->instruction;
-
-      /* Overwrite the flags element of the old redirect with the new value. */
-      redirect->flags = new_redirect->flags;
-      dispose_redirects (new_redirect);
-    }
-
-  switch (ri)
-    {
-    case r_output_direction:
-    case r_appending_to:
-    case r_input_direction:
-    case r_inputa_direction:
-    case r_err_and_out:		/* command &>filename */
-    case r_append_err_and_out:	/* command &>> filename */
-    case r_input_output:
-    case r_output_force:
-      if (posixly_correct && interactive_shell == 0)
-	{
-	  oflags = redirectee->flags;
-	  redirectee->flags |= W_NOGLOB;
-	}
-      redirectee_word = redirection_expand (redirectee);
-      if (posixly_correct && interactive_shell == 0)
-	redirectee->flags = oflags;
-
-      if (redirectee_word == 0)
-	return (AMBIGUOUS_REDIRECT);
-
-#if defined (RESTRICTED_SHELL)
-      if (restricted && (WRITE_REDIRECT (ri)))
-	{
-	  free (redirectee_word);
-	  return (RESTRICTED_REDIRECT);
-	}
-#endif /* RESTRICTED_SHELL */
-
-      fd = redir_open (redirectee_word, redirect->flags, 0666, ri);
-      if (fnp)
-	*fnp = redirectee_word;
-      else
-	free (redirectee_word);
-
-      if (fd == NOCLOBBER_REDIRECT || fd == RESTRICTED_REDIRECT)
-	return (fd);
-
-      if (fd < 0)
-	return (errno);
-
-      if (flags & RX_ACTIVE)
-	{
-	  if (redirect->rflags & REDIR_VARASSIGN)
-	    {
-	      redirector = fcntl (fd, F_DUPFD, SHELL_FD_BASE);		/* XXX try this for now */
-	      r = errno;
-	      if (redirector < 0)
-		sys_error (_("redirection error: cannot duplicate fd"));
-	      REDIRECTION_ERROR (redirector, r, fd);
-	    }
-
-	  if ((flags & RX_UNDOABLE) && ((redirect->rflags & REDIR_VARASSIGN) == 0 || varassign_redir_autoclose))
-	    {
-	      /* Only setup to undo it if the thing to undo is active. We want
-		 to autoclose if we are doing a varassign redirection and the
-		 varredir_close shell option is set, and we can't test
-		 redirector in this case since we just assigned it above. */		 
-	      if (fd != redirector && (redirect->rflags & REDIR_VARASSIGN) && varassign_redir_autoclose)
-		r = add_undo_close_redirect (redirector);	      
-	      else if ((fd != redirector) && (fcntl (redirector, F_GETFD, 0) != -1))
-		r = add_undo_redirect (redirector, ri, -1);
-	      else
-		r = add_undo_close_redirect (redirector);
-	      REDIRECTION_ERROR (r, errno, fd);
-	    }
-
-#if defined (BUFFERED_INPUT)
-	  /* inhibit call to sync_buffered_stream() for async processes */
-	  if (redirector != 0 || (subshell_environment & SUBSHELL_ASYNC) == 0)
-	    check_bash_input (redirector);
-#endif
-
-	  /* Make sure there is no pending output before we change the state
-	     of the underlying file descriptor, since the builtins use stdio
-	     for output. */
-	  if (redirector == 1 && fileno (stdout) == redirector)
-	    {
-	      fflush (stdout);
-	      fpurge (stdout);
-	    }
-	  else if (redirector == 2 && fileno (stderr) == redirector)
-	    {
-	      fflush (stderr);
-	      fpurge (stderr);
-	    }
-
-	  if (redirect->rflags & REDIR_VARASSIGN)
-	    {
-	      if ((r = redir_varassign (redirect, redirector)) < 0)
-		{
-		  close (redirector);
-		  close (fd);
-		  return (r);	/* XXX */
-		}
-	    }
-	  else if ((fd != redirector) && (dup2 (fd, redirector) < 0))
-	    {
-	      close (fd);	/* dup2 failed? must be fd limit issue */
-	      return (errno);
-	    }
-
-#if defined (BUFFERED_INPUT)
-	  /* Do not change the buffered stream for an implicit redirection
-	     of /dev/null to fd 0 for asynchronous commands without job
-	     control (r_inputa_direction). */
-	  if (ri == r_input_direction || ri == r_input_output)
-	    duplicate_buffered_stream (fd, redirector);
-#endif /* BUFFERED_INPUT */
-
-	  /*
-	   * If we're remembering, then this is the result of a while, for
-	   * or until loop with a loop redirection, or a function/builtin
-	   * executing in the parent shell with a redirection.  In the
-	   * function/builtin case, we want to set all file descriptors > 2
-	   * to be close-on-exec to duplicate the effect of the old
-	   * for i = 3 to NOFILE close(i) loop.  In the case of the loops,
-	   * both sh and ksh leave the file descriptors open across execs.
-	   * The Posix standard mentions only the exec builtin.
-	   */
-	  if ((flags & RX_CLEXEC) && (redirector > 2))
-	    SET_CLOSE_ON_EXEC (redirector);
-	}
-
-      if (fd != redirector)
-	{
-#if defined (BUFFERED_INPUT)
-	  if (INPUT_REDIRECT (ri))
-	    close_buffered_fd (fd);
-	  else
-#endif /* !BUFFERED_INPUT */
-	    close (fd);		/* Don't close what we just opened! */
-	}
-
-      /* If we are hacking both stdout and stderr, do the stderr
-	 redirection here.  XXX - handle {var} here? */
-      if (ri == r_err_and_out || ri == r_append_err_and_out)
-	{
-	  if (flags & RX_ACTIVE)
-	    {
-	      if (flags & RX_UNDOABLE)
-		add_undo_redirect (2, ri, -1);
-	      if (dup2 (1, 2) < 0)
-		return (errno);
-	    }
-	}
-      break;
-
-    case r_reading_until:
-    case r_deblank_reading_until:
-    case r_reading_string:
-      /* REDIRECTEE is a pointer to a WORD_DESC containing the text of
-	 the new input.  Place it in a temporary file. */
-      if (redirectee)
-	{
-	  fd = here_document_to_fd (redirectee, ri);
-
-	  if (fd < 0)
-	    {
-	      heredoc_errno = errno;
-	      return (HEREDOC_REDIRECT);
-	    }
-
-	  if (redirect->rflags & REDIR_VARASSIGN)
-	    {
-	      redirector = fcntl (fd, F_DUPFD, SHELL_FD_BASE);		/* XXX try this for now */
-	      r = errno;
-	      if (redirector < 0)
-		sys_error (_("redirection error: cannot duplicate fd"));
-	      REDIRECTION_ERROR (redirector, r, fd);
-	    }
-
-	  if (flags & RX_ACTIVE)
-	    {
-	      if ((flags & RX_UNDOABLE) && ((redirect->rflags & REDIR_VARASSIGN) == 0 || varassign_redir_autoclose))
-	        {
-		  /* Only setup to undo it if the thing to undo is active.
-		     Close if the right option is set and we are doing a
-		     varassign redirection. */
-		  if (fd != redirector && (redirect->rflags & REDIR_VARASSIGN) && varassign_redir_autoclose)
-		    r = add_undo_close_redirect (redirector);	      
-		  else if ((fd != redirector) && (fcntl (redirector, F_GETFD, 0) != -1))
-		    r = add_undo_redirect (redirector, ri, -1);
-		  else
-		    r = add_undo_close_redirect (redirector);
-		  REDIRECTION_ERROR (r, errno, fd);
-	        }
-
-#if defined (BUFFERED_INPUT)
-	      check_bash_input (redirector);
-#endif
-	      if (redirect->rflags & REDIR_VARASSIGN)
-		{
-		  if ((r = redir_varassign (redirect, redirector)) < 0)
-		    {
-		      close (redirector);
-		      close (fd);
-		      return (r);	/* XXX */
-		    }
-		}
-	      else if (fd != redirector && dup2 (fd, redirector) < 0)
-		{
-		  r = errno;
-		  close (fd);
-		  return (r);
-		}
-
-#if defined (BUFFERED_INPUT)
-	      duplicate_buffered_stream (fd, redirector);
-#endif
-
-	      if ((flags & RX_CLEXEC) && (redirector > 2))
-		SET_CLOSE_ON_EXEC (redirector);
-	    }
-
-	  if (fd != redirector)
-#if defined (BUFFERED_INPUT)
-	    close_buffered_fd (fd);
-#else
-	    close (fd);
-#endif
-	}
-      break;
-
-    case r_duplicating_input:
-    case r_duplicating_output:
-    case r_move_input:
-    case r_move_output:
-      if ((flags & RX_ACTIVE) && (redirect->rflags & REDIR_VARASSIGN))
-        {
-	  redirector = fcntl (redir_fd, F_DUPFD, SHELL_FD_BASE);		/* XXX try this for now */
-	  r = errno;
-	  if (redirector < 0)
-	    sys_error (_("redirection error: cannot duplicate fd"));
-	  REDIRECTION_ERROR (redirector, r, -1);
-        }
-
-      if ((flags & RX_ACTIVE) && (redir_fd != redirector))
-	{
-	  if ((flags & RX_UNDOABLE) && ((redirect->rflags & REDIR_VARASSIGN) == 0 || varassign_redir_autoclose))
-	    {
-	      /* Only setup to undo it if the thing to undo is active.
-		 Close if the right option is set and we are doing a
-		 varassign redirection. */
-	      if ((redirect->rflags & REDIR_VARASSIGN) && varassign_redir_autoclose)
-		r = add_undo_close_redirect (redirector);	      
-	      else if (fcntl (redirector, F_GETFD, 0) != -1)
-		r = add_undo_redirect (redirector, ri, redir_fd);
-	      else
-		r = add_undo_close_redirect (redirector);
-	      REDIRECTION_ERROR (r, errno, -1);
-	    }
-	  if ((flags & RX_UNDOABLE) && (ri == r_move_input || ri == r_move_output))
-	    {
-	      /* r_move_input and r_move_output add an additional close()
-		 that needs to be undone */
-	      if (fcntl (redirector, F_GETFD, 0) != -1)
-		{
-		  r = add_undo_redirect (redir_fd, r_close_this, -1);
-		  REDIRECTION_ERROR (r, errno, -1);
-		}
-	    }
-#if defined (BUFFERED_INPUT)
-	  /* inhibit call to sync_buffered_stream() for async processes */
-	  if (redirector != 0 || (subshell_environment & SUBSHELL_ASYNC) == 0)
-	    check_bash_input (redirector);
-#endif
-	  if (redirect->rflags & REDIR_VARASSIGN)
-	    {
-	      if ((r = redir_varassign (redirect, redirector)) < 0)
-		{
-		  close (redirector);
-		  return (r);	/* XXX */
-		}
-	    }
-	  /* This is correct.  2>&1 means dup2 (1, 2); */
-	  else if (dup2 (redir_fd, redirector) < 0)
-	    return (errno);
-
-#if defined (BUFFERED_INPUT)
-	  if (ri == r_duplicating_input || ri == r_move_input)
-	    duplicate_buffered_stream (redir_fd, redirector);
-#endif /* BUFFERED_INPUT */
-
-	  /* First duplicate the close-on-exec state of redirectee.  dup2
-	     leaves the flag unset on the new descriptor, which means it
-	     stays open.  Only set the close-on-exec bit for file descriptors
-	     greater than 2 in any case, since 0-2 should always be open
-	     unless closed by something like `exec 2<&-'.  It should always
-	     be safe to set fds > 2 to close-on-exec if they're being used to
-	     save file descriptors < 2, since we don't need to preserve the
-	     state of the close-on-exec flag for those fds -- they should
-	     always be open. */
-	  /* if ((already_set || set_unconditionally) && (ok_to_set))
-		set_it () */
-#if 0
-	  if (((fcntl (redir_fd, F_GETFD, 0) == 1) || redir_fd < 2 || (flags & RX_CLEXEC)) &&
-	       (redirector > 2))
-#else
-	  if (((fcntl (redir_fd, F_GETFD, 0) == 1) || (redir_fd < 2 && (flags & RX_INTERNAL)) || (flags & RX_CLEXEC)) &&
-	       (redirector > 2))
-#endif
-	    SET_CLOSE_ON_EXEC (redirector);
-
-	  /* When undoing saving of non-standard file descriptors (>=3) using
-	     file descriptors >= SHELL_FD_BASE, we set the saving fd to be
-	     close-on-exec and use a flag to decide how to set close-on-exec
-	     when the fd is restored. */
-	  if ((redirect->flags & RX_INTERNAL) && (redirect->flags & RX_SAVCLEXEC) && redirector >= 3 && (redir_fd >= SHELL_FD_BASE || (redirect->flags & RX_SAVEFD)))
-	    SET_OPEN_ON_EXEC (redirector);
-	    
-	  /* dup-and-close redirection */
-	  if (ri == r_move_input || ri == r_move_output)
-	    {
-	      xtrace_fdchk (redir_fd);
-
-	      close (redir_fd);
-#if defined (COPROCESS_SUPPORT)
-	      coproc_fdchk (redir_fd);	/* XXX - loses coproc fds */
-#endif
-	    }
-	}
-      break;
-
-    case r_close_this:
-      if (flags & RX_ACTIVE)
-	{
-	  if (redirect->rflags & REDIR_VARASSIGN)
-	    {
-	      redirector = redir_varvalue (redirect);
-	      if (redirector < 0)
-		return AMBIGUOUS_REDIRECT;
-	    }
-
-	  r = 0;
-	  if (flags & RX_UNDOABLE)
-	    {
-	      if (fcntl (redirector, F_GETFD, 0) != -1)
-		r = add_undo_redirect (redirector, ri, -1);
-	      else
-		r = add_undo_close_redirect (redirector);
-	      REDIRECTION_ERROR (r, errno, redirector);
-	    }
-
-#if defined (COPROCESS_SUPPORT)
-	  coproc_fdchk (redirector);
-#endif
-	  xtrace_fdchk (redirector);
-
-#if defined (BUFFERED_INPUT)
-	  /* inhibit call to sync_buffered_stream() for async processes */
-	  if (redirector != 0 || (subshell_environment & SUBSHELL_ASYNC) == 0)
-	    check_bash_input (redirector);
-	  r = close_buffered_fd (redirector);
-#else /* !BUFFERED_INPUT */
-	  r = close (redirector);
-#endif /* !BUFFERED_INPUT */
-
-	  if (r < 0 && (flags & RX_INTERNAL) && (errno == EIO || errno == ENOSPC))
-	    REDIRECTION_ERROR (r, errno, -1);
-	}
-      break;
-
-    case r_duplicating_input_word:
-    case r_duplicating_output_word:
-    case r_move_input_word:
-    case r_move_output_word:
-      break;
-    }
-  return (0);
-}
-
-/* Remember the file descriptor associated with the slot FD,
-   on REDIRECTION_UNDO_LIST.  Note that the list will be reversed
-   before it is executed.  Any redirections that need to be undone
-   even if REDIRECTION_UNDO_LIST is discarded by the exec builtin
-   are also saved on EXEC_REDIRECTION_UNDO_LIST.  FDBASE says where to
-   start the duplicating.  If it's less than SHELL_FD_BASE, we're ok,
-   and can use SHELL_FD_BASE (-1 == don't care).  If it's >= SHELL_FD_BASE,
-   we have to make sure we don't use fdbase to save a file descriptor,
-   since we're going to use it later (e.g., make sure we don't save fd 0
-   to fd 10 if we have a redirection like 0<&10).  If the value of fdbase
-   puts the process over its fd limit, causing fcntl to fail, we try
-   again with SHELL_FD_BASE.  Return 0 on success, -1 on error. */
-static int
-add_undo_redirect (fd, ri, fdbase)
-     int fd;
-     enum r_instruction ri;
-     int fdbase;
-{
-  int new_fd, clexec_flag, savefd_flag;
-  REDIRECT *new_redirect, *closer, *dummy_redirect;
-  REDIRECTEE sd;
-
-  savefd_flag = 0;
-  new_fd = fcntl (fd, F_DUPFD, (fdbase < SHELL_FD_BASE) ? SHELL_FD_BASE : fdbase+1);
-  if (new_fd < 0)
-    new_fd = fcntl (fd, F_DUPFD, SHELL_FD_BASE);
-  if (new_fd < 0)
-    {
-      new_fd = fcntl (fd, F_DUPFD, 0);
-      savefd_flag = 1;
-    }
-
-  if (new_fd < 0)
-    {
-      sys_error (_("redirection error: cannot duplicate fd"));
-      return (-1);
-    }
-
-  clexec_flag = fcntl (fd, F_GETFD, 0);
-
-  sd.dest = new_fd;
-  rd.dest = 0;
-  closer = make_redirection (sd, r_close_this, rd, 0);
-  closer->flags |= RX_INTERNAL;
-  dummy_redirect = copy_redirects (closer);
-
-  sd.dest = fd;
-  rd.dest = new_fd;
-  if (fd == 0)
-    new_redirect = make_redirection (sd, r_duplicating_input, rd, 0);
-  else
-    new_redirect = make_redirection (sd, r_duplicating_output, rd, 0);
-  new_redirect->flags |= RX_INTERNAL;
-  if (savefd_flag)
-    new_redirect->flags |= RX_SAVEFD;
-  if (clexec_flag == 0 && fd >= 3 && (new_fd >= SHELL_FD_BASE || savefd_flag))
-    new_redirect->flags |= RX_SAVCLEXEC;
-  new_redirect->next = closer;
-
-  closer->next = redirection_undo_list;
-  redirection_undo_list = new_redirect;
-
-  /* Save redirections that need to be undone even if the undo list
-     is thrown away by the `exec' builtin. */
-  add_exec_redirect (dummy_redirect);
-
-  /* experimental:  if we're saving a redirection to undo for a file descriptor
-     above SHELL_FD_BASE, add a redirection to be undone if the exec builtin
-     causes redirections to be discarded.  There needs to be a difference
-     between fds that are used to save other fds and then are the target of
-     user redirections and fds that are just the target of user redirections.
-     We use the close-on-exec flag to tell the difference; fds > SHELL_FD_BASE
-     that have the close-on-exec flag set are assumed to be fds used internally
-     to save others. */
-  if (fd >= SHELL_FD_BASE && ri != r_close_this && clexec_flag)
-    {
-      sd.dest = fd;
-      rd.dest = new_fd;
-      new_redirect = make_redirection (sd, r_duplicating_output, rd, 0);
-      new_redirect->flags |= RX_INTERNAL;
-
-      add_exec_redirect (new_redirect);
-    }
-
-  /* File descriptors used only for saving others should always be
-     marked close-on-exec.  Unfortunately, we have to preserve the
-     close-on-exec state of the file descriptor we are saving, since
-     fcntl (F_DUPFD) sets the new file descriptor to remain open
-     across execs.  If, however, the file descriptor whose state we
-     are saving is <= 2, we can just set the close-on-exec flag,
-     because file descriptors 0-2 should always be open-on-exec,
-     and the restore above in do_redirection() will take care of it. */
-  if (clexec_flag || fd < 3)
-    SET_CLOSE_ON_EXEC (new_fd);
-  else if (redirection_undo_list->flags & RX_SAVCLEXEC)
-    SET_CLOSE_ON_EXEC (new_fd);
-
-  return (0);
-}
-
-/* Set up to close FD when we are finished with the current command
-   and its redirections.  Return 0 on success, -1 on error. */
-static int
-add_undo_close_redirect (fd)
-     int fd;
-{
-  REDIRECT *closer;
-  REDIRECTEE sd;
-
-  sd.dest = fd;
-  rd.dest = 0;
-  closer = make_redirection (sd, r_close_this, rd, 0);
-  closer->flags |= RX_INTERNAL;
-  closer->next = redirection_undo_list;
-  redirection_undo_list = closer;
-
-  return 0;
-}
-
-static void
-add_exec_redirect (dummy_redirect)
-     REDIRECT *dummy_redirect;
-{
-  dummy_redirect->next = exec_redirection_undo_list;
-  exec_redirection_undo_list = dummy_redirect;
-}
-
-/* Return 1 if the redirection specified by RI and REDIRECTOR alters the
-   standard input. */
-static int
-stdin_redirection (ri, redirector)
-     enum r_instruction ri;
-     int redirector;
-{
-  switch (ri)
-    {
-    case r_input_direction:
-    case r_inputa_direction:
-    case r_input_output:
-    case r_reading_until:
-    case r_deblank_reading_until:
-    case r_reading_string:
-      return (1);
-    case r_duplicating_input:
-    case r_duplicating_input_word:
-    case r_close_this:
-      return (redirector == 0);
-    case r_output_direction:
-    case r_appending_to:
-    case r_duplicating_output:
-    case r_err_and_out:
-    case r_append_err_and_out:
-    case r_output_force:
-    case r_duplicating_output_word:
-    case r_move_input:
-    case r_move_output:
-    case r_move_input_word:
-    case r_move_output_word:
-      return (0);
-    }
-  return (0);
-}
-
-/* Return non-zero if any of the redirections in REDIRS alter the standard
-   input. */
-int
-stdin_redirects (redirs)
-     REDIRECT *redirs;
-{
-  REDIRECT *rp;
-  int n;
-
-  for (n = 0, rp = redirs; rp; rp = rp->next)
-    if ((rp->rflags & REDIR_VARASSIGN) == 0)
-      n += stdin_redirection (rp->instruction, rp->redirector.dest);
-  return n;
-}
-/* bind_var_to_int handles array references */
-static int
-redir_varassign (redir, fd)
-     REDIRECT *redir;
-     int fd;
-{
-  WORD_DESC *w;
-  SHELL_VAR *v;
-
-  w = redir->redirector.filename;
-  v = bind_var_to_int (w->word, fd, 0);
-  if (v == 0 || readonly_p (v) || noassign_p (v))
-    return BADVAR_REDIRECT;
-
-  stupidly_hack_special_variables (w->word);
-  return 0;
-}
-
-/* Handles {array[ind]} for redirection words */
-static int
-redir_varvalue (redir)
-     REDIRECT *redir;
-{
-  SHELL_VAR *v;
-  char *val, *w;
-  intmax_t vmax;
-  int i;
-#if defined (ARRAY_VARS)
-  char *sub;
-  int len, vr;
-#endif
-
-  w = redir->redirector.filename->word;		/* shorthand */
-  /* XXX - handle set -u here? */
-#if defined (ARRAY_VARS)
-  if (vr = valid_array_reference (w, 0))
-    {
-      v = array_variable_part (w, 0, &sub, &len);
-    }
-  else
-#endif
-    {
-      v = find_variable (w);
-#if defined (ARRAY_VARS)
-      if (v == 0)
-	{
-	  v = find_variable_last_nameref (w, 0);
-	  if (v && nameref_p (v))
-	    {
-	      w = nameref_cell (v);
-	      if (vr = valid_array_reference (w, 0))
-		v = array_variable_part (w, 0, &sub, &len);
-	      else
-	        v = find_variable (w);
-	    }
-	}
-#endif
-    }
-	
-  if (v == 0 || invisible_p (v))
-    return -1;
-
-#if defined (ARRAY_VARS)
-  /* get_variable_value handles references to array variables without
-     subscripts */
-  if (vr && (array_p (v) || assoc_p (v)))
-    val = get_array_value (w, 0, (array_eltstate_t *)NULL);
-  else
-#endif
-  val = get_variable_value (v);
-  if (val == 0 || *val == 0)
-    return -1;
-
-  if (legal_number (val, &vmax) < 0)
-    return -1;
-
-  i = vmax;	/* integer truncation */
-  return i;
-}
diff --git a/third_party/bash/redir.h b/third_party/bash/redir.h
deleted file mode 100644
index 340dc1c02..000000000
--- a/third_party/bash/redir.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* redir.h - functions from redir.c. */
-
-/* Copyright (C) 1997, 2001, 2005, 2008, 2009-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_REDIR_H_)
-#define _REDIR_H_
-
-#include "stdc.h"
-
-/* Values for flags argument to do_redirections */
-#define RX_ACTIVE	0x01	/* do it; don't just go through the motions */
-#define RX_UNDOABLE	0x02	/* make a list to undo these redirections */
-#define RX_CLEXEC	0x04	/* set close-on-exec for opened fds > 2 */
-#define RX_INTERNAL	0x08
-#define RX_USER		0x10
-#define RX_SAVCLEXEC	0x20	/* set close-on-exec off in restored fd even though saved on has it on */
-#define RX_SAVEFD	0x40	/* fd used to save another even if < SHELL_FD_BASE */
-
-extern void redirection_error PARAMS((REDIRECT *, int, char *));
-extern int do_redirections PARAMS((REDIRECT *, int));
-extern char *redirection_expand PARAMS((WORD_DESC *));
-extern int stdin_redirects PARAMS((REDIRECT *));
-
-/* in builtins/evalstring.c for now, could move later */
-extern int open_redir_file PARAMS((REDIRECT *, char **));
-
-#endif /* _REDIR_H_ */
diff --git a/third_party/bash/rename.c b/third_party/bash/rename.c
deleted file mode 100644
index 1fa90a159..000000000
--- a/third_party/bash/rename.c
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * rename - rename a file
- */
-
-/* Copyright (C) 1999 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if !defined (HAVE_RENAME)
-
-#include "bashtypes.h"
-#include "posixstat.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-#include <errno.h>
-
-#include "stdc.h"
-
-#ifndef errno
-extern int errno;
-#endif
-
-int
-rename (from, to)
-     const char *from, *to;
-{
-  struct stat fb, tb;
-
-  if (stat (from, &fb) < 0)
-    return -1;  
-
-  if (stat (to, &tb) < 0)
-    {
-      if (errno != ENOENT)
-	return -1;
-    }
-  else
-    {
-      if (fb.st_dev == tb.st_dev && fb.st_ino == tb.st_ino)
-        return 0;		/* same file */
-      if (unlink (to) < 0 && errno != ENOENT)
-        return -1;
-    }
-
-  if (link (from, to) < 0)
-    return (-1);
-
-  if (unlink (from) < 0 && errno != ENOENT)
-    {
-      int e = errno;
-      unlink (to);
-      errno = e;
-      return (-1);
-    }
-
-  return (0);
-}
-#endif /* !HAVE_RENAME */
diff --git a/third_party/bash/setlinebuf.c b/third_party/bash/setlinebuf.c
deleted file mode 100644
index 3c9afb8c1..000000000
--- a/third_party/bash/setlinebuf.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/* setlinebuf.c - line-buffer a stdio stream. */
-
-/* Copyright (C) 1997,2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <stdio.h>
-
-#include "xmalloc.h"
-
-#if defined (USING_BASH_MALLOC)
-#  define LBUF_BUFSIZE	2016
-#else
-#  define LBUF_BUFSIZE	BUFSIZ
-#endif
-
-static char *stdoutbuf = 0;
-static char *stderrbuf = 0;
-
-/* Cause STREAM to buffer lines as opposed to characters or blocks. */
-int
-sh_setlinebuf (stream)
-     FILE *stream;
-{
-#if !defined (HAVE_SETLINEBUF) && !defined (HAVE_SETVBUF)
-  return (0);
-#endif
-
-#if defined (HAVE_SETVBUF)
-  char *local_linebuf;
-
-#if defined (USING_BASH_MALLOC)
-  if (stream == stdout && stdoutbuf == 0)
-    local_linebuf = stdoutbuf = (char *)xmalloc (LBUF_BUFSIZE);
-  else if (stream == stderr && stderrbuf == 0)
-    local_linebuf = stderrbuf = (char *)xmalloc (LBUF_BUFSIZE);
-  else
-    local_linebuf = (char *)NULL;	/* let stdio handle it */
-#else
-  local_linebuf = (char *)NULL;
-#endif
-
-  return (setvbuf (stream, local_linebuf, _IOLBF, LBUF_BUFSIZE));
-#else /* !HAVE_SETVBUF */
-
-  setlinebuf (stream);
-  return (0);
-
-#endif /* !HAVE_SETVBUF */
-}
diff --git a/third_party/bash/shell.c b/third_party/bash/shell.c
deleted file mode 100644
index da5ffb58b..000000000
--- a/third_party/bash/shell.c
+++ /dev/null
@@ -1,2136 +0,0 @@
-/* shell.c -- GNU's idea of the POSIX shell specification. */
-
-/* Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/*
-  Birthdate:
-  Sunday, January 10th, 1988.
-  Initial author: Brian Fox
-*/
-#define INSTALL_DEBUG_MODE
-
-#include "config.h"
-
-#include "bashtypes.h"
-#if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif
-#include "posixstat.h"
-#include "posixtime.h"
-#include "bashansi.h"
-#include <stdio.h>
-#include <signal.h>
-#include <errno.h>
-#include "filecntl.h"
-#if defined (HAVE_PWD_H)
-#  include <pwd.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashintl.h"
-
-#define NEED_SH_SETLINEBUF_DECL		/* used in externs.h */
-
-#include "shell.h"
-#include "parser.h"
-#include "flags.h"
-#include "trap.h"
-#include "mailcheck.h"
-#include "builtins.h"
-#include "common.h"
-
-#if defined (JOB_CONTROL)
-#include "jobs.h"
-#else
-extern int running_in_background;
-extern int initialize_job_control PARAMS((int));
-extern int get_tty_state PARAMS((void));
-#endif /* JOB_CONTROL */
-
-#include "input.h"
-#include "execute_cmd.h"
-#include "findcmd.h"
-
-#if defined (USING_BASH_MALLOC) && defined (DEBUG) && !defined (DISABLE_MALLOC_WRAPPERS)
-#  include <malloc/shmalloc.h>
-#elif defined (MALLOC_DEBUG) && defined (USING_BASH_MALLOC)
-#  include <malloc/shmalloc.h>
-#endif
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#  include "third_party/readline/history.h"
-#endif
-
-#if defined (READLINE)
-#  include "third_party/readline/readline.h"
-#  include "bashline.h"
-#endif
-
-#include "tilde.h"
-#include "strmatch.h"
-
-#if defined (__OPENNT)
-#  include <opennt/opennt.h>
-#endif
-
-#if !defined (HAVE_GETPW_DECLS)
-extern struct passwd *getpwuid ();
-#endif /* !HAVE_GETPW_DECLS */
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#if defined (NO_MAIN_ENV_ARG)
-extern char **environ;	/* used if no third argument to main() */
-#endif
-
-extern int gnu_error_format;
-
-/* Non-zero means that this shell has already been run; i.e. you should
-   call shell_reinitialize () if you need to start afresh. */
-int shell_initialized = 0;
-int bash_argv_initialized = 0;
-
-COMMAND *global_command = (COMMAND *)NULL;
-
-/* Information about the current user. */
-struct user_info current_user =
-{
-  (uid_t)-1, (uid_t)-1, (gid_t)-1, (gid_t)-1,
-  (char *)NULL, (char *)NULL, (char *)NULL
-};
-
-/* The current host's name. */
-char *current_host_name = (char *)NULL;
-
-/* Non-zero means that this shell is a login shell.
-   Specifically:
-   0 = not login shell.
-   1 = login shell from getty (or equivalent fake out)
-  -1 = login shell from "--login" (or -l) flag.
-  -2 = both from getty, and from flag.
- */
-int login_shell = 0;
-
-/* Non-zero means that at this moment, the shell is interactive.  In
-   general, this means that the shell is at this moment reading input
-   from the keyboard. */
-int interactive = 0;
-
-/* Non-zero means that the shell was started as an interactive shell. */
-int interactive_shell = 0;
-
-/* Non-zero means to send a SIGHUP to all jobs when an interactive login
-   shell exits. */
-int hup_on_exit = 0;
-
-/* Non-zero means to list status of running and stopped jobs at shell exit */
-int check_jobs_at_exit = 0;
-
-/* Non-zero means to change to a directory name supplied as a command name */
-int autocd = 0;
-
-/* Tells what state the shell was in when it started:
-	0 = non-interactive shell script
-	1 = interactive
-	2 = -c command
-	3 = wordexp evaluation
-   This is a superset of the information provided by interactive_shell.
-*/
-int startup_state = 0;
-int reading_shell_script = 0;
-
-/* Special debugging helper. */
-int debugging_login_shell = 0;
-
-/* The environment that the shell passes to other commands. */
-char **shell_environment;
-
-/* Non-zero when we are executing a top-level command. */
-int executing = 0;
-
-/* The number of commands executed so far. */
-int current_command_number = 1;
-
-/* Non-zero is the recursion depth for commands. */
-int indirection_level = 0;
-
-/* The name of this shell, as taken from argv[0]. */
-char *shell_name = (char *)NULL;
-
-/* time in seconds when the shell was started */
-time_t shell_start_time;
-struct timeval shellstart;
-
-/* Are we running in an emacs shell window? */
-int running_under_emacs;
-
-/* Do we have /dev/fd? */
-#ifdef HAVE_DEV_FD
-int have_devfd = HAVE_DEV_FD;
-#else
-int have_devfd = 0;
-#endif
-
-/* The name of the .(shell)rc file. */
-static char *bashrc_file = DEFAULT_BASHRC;
-
-/* Non-zero means to act more like the Bourne shell on startup. */
-static int act_like_sh;
-
-/* Non-zero if this shell is being run by `su'. */
-static int su_shell;
-
-/* Non-zero if we have already expanded and sourced $ENV. */
-static int sourced_env;
-
-/* Is this shell running setuid? */
-static int running_setuid;
-
-/* Values for the long-winded argument names. */
-static int debugging;			/* Do debugging things. */
-static int no_rc;			/* Don't execute ~/.bashrc */
-static int no_profile;			/* Don't execute .profile */
-static int do_version;			/* Display interesting version info. */
-static int make_login_shell;		/* Make this shell be a `-bash' shell. */
-static int want_initial_help;		/* --help option */
-
-int debugging_mode = 0;		/* In debugging mode with --debugger */
-#if defined (READLINE)
-int no_line_editing = 0;	/* non-zero -> don't do fancy line editing. */
-#else
-int no_line_editing = 1;	/* can't have line editing without readline */
-#endif
-#if defined (TRANSLATABLE_STRINGS)
-int dump_translatable_strings;	/* Dump strings in $"...", don't execute. */
-int dump_po_strings;		/* Dump strings in $"..." in po format */
-#endif
-int wordexp_only = 0;		/* Do word expansion only */
-int protected_mode = 0;		/* No command substitution with --wordexp */
-
-int pretty_print_mode = 0;	/* pretty-print a shell script */
-
-#if defined (STRICT_POSIX)
-int posixly_correct = 1;	/* Non-zero means posix.2 superset. */
-#else
-int posixly_correct = 0;	/* Non-zero means posix.2 superset. */
-#endif
-
-/* Some long-winded argument names.  These are obviously new. */
-#define Int 1
-#define Charp 2
-static const struct {
-  const char *name;
-  int type;
-  int *int_value;
-  char **char_value;
-} long_args[] = {
-  { "debug", Int, &debugging, (char **)0x0 },
-#if defined (DEBUGGER)
-  { "debugger", Int, &debugging_mode, (char **)0x0 },
-#endif
-#if defined (TRANSLATABLE_STRINGS)
-  { "dump-po-strings", Int, &dump_po_strings, (char **)0x0 },
-  { "dump-strings", Int, &dump_translatable_strings, (char **)0x0 },
-#endif
-  { "help", Int, &want_initial_help, (char **)0x0 },
-  { "init-file", Charp, (int *)0x0, &bashrc_file },
-  { "login", Int, &make_login_shell, (char **)0x0 },
-  { "noediting", Int, &no_line_editing, (char **)0x0 },
-  { "noprofile", Int, &no_profile, (char **)0x0 },
-  { "norc", Int, &no_rc, (char **)0x0 },
-  { "posix", Int, &posixly_correct, (char **)0x0 },
-  { "pretty-print", Int, &pretty_print_mode, (char **)0x0 },
-#if defined (WORDEXP_OPTION)
-  { "protected", Int, &protected_mode, (char **)0x0 },
-#endif
-  { "rcfile", Charp, (int *)0x0, &bashrc_file },
-#if defined (RESTRICTED_SHELL)
-  { "restricted", Int, &restricted, (char **)0x0 },
-#endif
-  { "verbose", Int, &verbose_flag, (char **)0x0 },
-  { "version", Int, &do_version, (char **)0x0 },
-#if defined (WORDEXP_OPTION)
-  { "wordexp", Int, &wordexp_only, (char **)0x0 },
-#endif
-  { (char *)0x0, Int, (int *)0x0, (char **)0x0 }
-};
-
-/* These are extern so execute_simple_command can set them, and then
-   longjmp back to main to execute a shell script, instead of calling
-   main () again and resulting in indefinite, possibly fatal, stack
-   growth. */
-procenv_t subshell_top_level;
-int subshell_argc;
-char **subshell_argv;
-char **subshell_envp;
-
-char *exec_argv0;
-
-#if defined (BUFFERED_INPUT)
-/* The file descriptor from which the shell is reading input. */
-int default_buffered_input = -1;
-#endif
-
-/* The following two variables are not static so they can show up in $-. */
-int read_from_stdin;		/* -s flag supplied */
-int want_pending_command;	/* -c flag supplied */
-
-/* This variable is not static so it can be bound to $BASH_EXECUTION_STRING */
-char *command_execution_string;	/* argument to -c option */
-char *shell_script_filename; 	/* shell script */
-
-int malloc_trace_at_exit = 0;
-
-static int shell_reinitialized = 0;
-
-static FILE *default_input;
-
-static STRING_INT_ALIST *shopt_alist;
-static int shopt_ind = 0, shopt_len = 0;
-
-static int parse_long_options PARAMS((char **, int, int));
-static int parse_shell_options PARAMS((char **, int, int));
-static int bind_args PARAMS((char **, int, int, int));
-
-static void start_debugger PARAMS((void));
-
-static void add_shopt_to_alist PARAMS((char *, int));
-static void run_shopt_alist PARAMS((void));
-
-static void execute_env_file PARAMS((char *));
-static void run_startup_files PARAMS((void));
-static int open_shell_script PARAMS((char *));
-static void set_bash_input PARAMS((void));
-static int run_one_command PARAMS((char *));
-#if defined (WORDEXP_OPTION)
-static int run_wordexp PARAMS((char *));
-#endif
-
-static int uidget PARAMS((void));
-
-static void set_option_defaults PARAMS((void));
-static void reset_option_defaults PARAMS((void));
-
-static void init_interactive PARAMS((void));
-static void init_noninteractive PARAMS((void));
-static void init_interactive_script PARAMS((void));
-
-static void set_shell_name PARAMS((char *));
-static void shell_initialize PARAMS((void));
-static void shell_reinitialize PARAMS((void));
-
-static void show_shell_usage PARAMS((FILE *, int));
-
-#ifdef __CYGWIN__
-static void
-_cygwin32_check_tmp ()
-{
-  struct stat sb;
-
-  if (stat ("/tmp", &sb) < 0)
-    internal_warning (_("could not find /tmp, please create!"));
-  else
-    {
-      if (S_ISDIR (sb.st_mode) == 0)
-	internal_warning (_("/tmp must be a valid directory name"));
-    }
-}
-#endif /* __CYGWIN__ */
-
-#if defined (NO_MAIN_ENV_ARG)
-/* systems without third argument to main() */
-int
-main (argc, argv)
-     int argc;
-     char **argv;
-#else /* !NO_MAIN_ENV_ARG */
-int
-main (argc, argv, env)
-     int argc;
-     char **argv, **env;
-#endif /* !NO_MAIN_ENV_ARG */
-{
-  register int i;
-  int code, old_errexit_flag;
-#if defined (RESTRICTED_SHELL)
-  int saverst;
-#endif
-  volatile int locally_skip_execution;
-  volatile int arg_index, top_level_arg_index;
-#ifdef __OPENNT
-  char **env;
-
-  env = environ;
-#endif /* __OPENNT */
-
-  USE_VAR(argc);
-  USE_VAR(argv);
-  USE_VAR(env);
-  USE_VAR(code);
-  USE_VAR(old_errexit_flag);
-#if defined (RESTRICTED_SHELL)
-  USE_VAR(saverst);
-#endif
-
-  /* Catch early SIGINTs. */
-  code = setjmp_nosigs (top_level);
-  if (code)
-    exit (2);
-
-  xtrace_init ();
-
-#if defined (USING_BASH_MALLOC) && defined (DEBUG) && !defined (DISABLE_MALLOC_WRAPPERS)
-  malloc_set_register (1);	/* XXX - change to 1 for malloc debugging */
-#endif
-
-  check_dev_tty ();
-
-#ifdef __CYGWIN__
-  _cygwin32_check_tmp ();
-#endif /* __CYGWIN__ */
-
-  /* Wait forever if we are debugging a login shell. */
-  while (debugging_login_shell) sleep (3);
-
-  set_default_locale ();
-
-  running_setuid = uidget ();
-
-  if (getenv ("POSIXLY_CORRECT") || getenv ("POSIX_PEDANTIC"))
-    posixly_correct = 1;
-
-#if defined (USE_GNU_MALLOC_LIBRARY)
-  mcheck (programming_error, (void (*) ())0);
-#endif /* USE_GNU_MALLOC_LIBRARY */
-
-  if (setjmp_sigs (subshell_top_level))
-    {
-      argc = subshell_argc;
-      argv = subshell_argv;
-      env = subshell_envp;
-      sourced_env = 0;
-    }
-
-  shell_reinitialized = 0;
-
-  /* Initialize `local' variables for all `invocations' of main (). */
-  arg_index = 1;
-  if (arg_index > argc)
-    arg_index = argc;
-  command_execution_string = shell_script_filename = (char *)NULL;
-  want_pending_command = locally_skip_execution = read_from_stdin = 0;
-  default_input = stdin;
-#if defined (BUFFERED_INPUT)
-  default_buffered_input = -1;
-#endif
-
-  /* Fix for the `infinite process creation' bug when running shell scripts
-     from startup files on System V. */
-  login_shell = make_login_shell = 0;
-
-  /* If this shell has already been run, then reinitialize it to a
-     vanilla state. */
-  if (shell_initialized || shell_name)
-    {
-      /* Make sure that we do not infinitely recurse as a login shell. */
-      if (*shell_name == '-')
-	shell_name++;
-
-      shell_reinitialize ();
-      if (setjmp_nosigs (top_level))
-	exit (2);
-    }
-
-  shell_environment = env;
-  set_shell_name (argv[0]);
-
-  gettimeofday (&shellstart, 0);
-  shell_start_time = shellstart.tv_sec;
-
-  /* Parse argument flags from the input line. */
-
-  /* Find full word arguments first. */
-  arg_index = parse_long_options (argv, arg_index, argc);
-  
-  if (want_initial_help)
-    {
-      show_shell_usage (stdout, 1);
-      exit (EXECUTION_SUCCESS);
-    }
-
-  if (do_version)
-    {
-      show_shell_version (1);
-      exit (EXECUTION_SUCCESS);
-    }
-
-  echo_input_at_read = verbose_flag;	/* --verbose given */
-
-  /* All done with full word options; do standard shell option parsing.*/
-  this_command_name = shell_name;	/* for error reporting */
-  arg_index = parse_shell_options (argv, arg_index, argc);
-
-  /* If user supplied the "--login" (or -l) flag, then set and invert
-     LOGIN_SHELL. */
-  if (make_login_shell)
-    {
-      login_shell++;
-      login_shell = -login_shell;
-    }
-
-  set_login_shell ("login_shell", login_shell != 0);
-
-#if defined (TRANSLATABLE_STRINGS)
-  if (dump_po_strings)
-    dump_translatable_strings = 1;
-
-  if (dump_translatable_strings)
-    read_but_dont_execute = 1;
-#endif
-
-  if (running_setuid && privileged_mode == 0)
-    disable_priv_mode ();
-
-  /* Need to get the argument to a -c option processed in the
-     above loop.  The next arg is a command to execute, and the
-     following args are $0...$n respectively. */
-  if (want_pending_command)
-    {
-      command_execution_string = argv[arg_index];
-      if (command_execution_string == 0)
-	{
-	  report_error (_("%s: option requires an argument"), "-c");
-	  exit (EX_BADUSAGE);
-	}
-      arg_index++;
-    }
-  this_command_name = (char *)NULL;
-
-  /* First, let the outside world know about our interactive status.
-     A shell is interactive if the `-i' flag was given, or if all of
-     the following conditions are met:
-	no -c command
-	no arguments remaining or the -s flag given
-	standard input is a terminal
-	standard error is a terminal
-     Refer to Posix.2, the description of the `sh' utility. */
-
-  if (forced_interactive ||		/* -i flag */
-      (!command_execution_string &&	/* No -c command and ... */
-       wordexp_only == 0 &&		/* No --wordexp and ... */
-       ((arg_index == argc) ||		/*   no remaining args or... */
-	read_from_stdin) &&		/*   -s flag with args, and */
-       isatty (fileno (stdin)) &&	/* Input is a terminal and */
-       isatty (fileno (stderr))))	/* error output is a terminal. */
-    init_interactive ();
-  else
-    init_noninteractive ();
-
-  /*
-   * Some systems have the bad habit of starting login shells with lots of open
-   * file descriptors.  For instance, most systems that have picked up the
-   * pre-4.0 Sun YP code leave a file descriptor open each time you call one
-   * of the getpw* functions, and it's set to be open across execs.  That
-   * means one for login, one for xterm, one for shelltool, etc.  There are
-   * also systems that open persistent FDs to other agents or files as part
-   * of process startup; these need to be set to be close-on-exec.
-   */
-  if (login_shell && interactive_shell)
-    {
-      for (i = 3; i < 20; i++)
-	SET_CLOSE_ON_EXEC (i);
-    }
-
-  /* If we're in a strict Posix.2 mode, turn on interactive comments,
-     alias expansion in non-interactive shells, and other Posix.2 things. */
-  if (posixly_correct)
-    {
-      bind_variable ("POSIXLY_CORRECT", "y", 0);
-      sv_strict_posix ("POSIXLY_CORRECT");
-    }
-
-  /* Now we run the shopt_alist and process the options. */
-  if (shopt_alist)
-    run_shopt_alist ();
-
-  /* From here on in, the shell must be a normal functioning shell.
-     Variables from the environment are expected to be set, etc. */
-  shell_initialize ();
-
-  set_default_lang ();
-  set_default_locale_vars ();
-
-  /*
-   * M-x term -> TERM=eterm-color INSIDE_EMACS='251,term:0.96' (eterm)
-   * M-x shell -> TERM='dumb' INSIDE_EMACS='25.1,comint' (no line editing)
-   *
-   * Older versions of Emacs may set EMACS to 't' or to something like
-   * '22.1 (term:0.96)' instead of (or in addition to) setting INSIDE_EMACS.
-   * They may set TERM to 'eterm' instead of 'eterm-color'.  They may have
-   * a now-obsolete command that sets neither EMACS nor INSIDE_EMACS:
-   * M-x terminal -> TERM='emacs-em7955' (line editing)
-   */
-  if (interactive_shell)
-    {
-      char *term, *emacs, *inside_emacs;
-      int emacs_term, in_emacs;
-
-      term = get_string_value ("TERM");
-      emacs = get_string_value ("EMACS");
-      inside_emacs = get_string_value ("INSIDE_EMACS");
-
-      if (inside_emacs)
-	{
-	  emacs_term = strstr (inside_emacs, ",term:") != 0;
-	  in_emacs = 1;
-	}
-      else if (emacs)
-	{
-	  /* Infer whether we are in an older Emacs. */
-	  emacs_term = strstr (emacs, " (term:") != 0;
-	  in_emacs = emacs_term || STREQ (emacs, "t");
-	}
-      else
-	in_emacs = emacs_term = 0;
-
-      /* Not sure any emacs terminal emulator sets TERM=emacs any more */
-      no_line_editing |= STREQ (term, "emacs");
-      no_line_editing |= in_emacs && STREQ (term, "dumb");
-
-      /* running_under_emacs == 2 for `eterm' */
-      running_under_emacs = in_emacs || STREQN (term, "emacs", 5);
-      running_under_emacs += emacs_term && STREQN (term, "eterm", 5);
-
-      if (running_under_emacs)
-	gnu_error_format = 1;
-    }
-
-  top_level_arg_index = arg_index;
-  old_errexit_flag = exit_immediately_on_error;
-
-  /* Give this shell a place to longjmp to before executing the
-     startup files.  This allows users to press C-c to abort the
-     lengthy startup. */
-  code = setjmp_sigs (top_level);
-  if (code)
-    {
-      if (code == EXITPROG || code == ERREXIT || code == EXITBLTIN)
-	exit_shell (last_command_exit_value);
-      else
-	{
-#if defined (JOB_CONTROL)
-	  /* Reset job control, since run_startup_files turned it off. */
-	  set_job_control (interactive_shell);
-#endif
-	  /* Reset value of `set -e', since it's turned off before running
-	     the startup files. */
-	  exit_immediately_on_error += old_errexit_flag;
-	  locally_skip_execution++;
-	}
-    }
-
-  arg_index = top_level_arg_index;
-
-  /* Execute the start-up scripts. */
-
-  if (interactive_shell == 0)
-    {
-      unbind_variable ("PS1");
-      unbind_variable ("PS2");
-      interactive = 0;
-#if 0
-      /* This has already been done by init_noninteractive */
-      expand_aliases = posixly_correct;
-#endif
-    }
-  else
-    {
-      change_flag ('i', FLAG_ON);
-      interactive = 1;
-    }
-
-#if defined (RESTRICTED_SHELL)
-  /* Set restricted_shell based on whether the basename of $0 indicates that
-     the shell should be restricted or if the `-r' option was supplied at
-     startup. */
-  restricted_shell = shell_is_restricted (shell_name);
-
-  /* If the `-r' option is supplied at invocation, make sure that the shell
-     is not in restricted mode when running the startup files. */
-  saverst = restricted;
-  restricted = 0;
-#endif
-
-  /* Set positional parameters before running startup files. top_level_arg_index
-     holds the index of the current argument before setting the positional
-     parameters, so any changes performed in the startup files won't affect
-     later option processing. */
-  if (wordexp_only)
-    ;			/* nothing yet */
-  else if (command_execution_string)
-    arg_index = bind_args (argv, arg_index, argc, 0);	/* $0 ... $n */
-  else if (arg_index != argc && read_from_stdin == 0)
-    {
-      shell_script_filename = argv[arg_index++];
-      arg_index = bind_args (argv, arg_index, argc, 1);	/* $1 ... $n */
-    }
-  else
-    arg_index = bind_args (argv, arg_index, argc, 1);	/* $1 ... $n */
-
-  /* The startup files are run with `set -e' temporarily disabled. */
-  if (locally_skip_execution == 0 && running_setuid == 0)
-    {
-      char *t;
-
-      old_errexit_flag = exit_immediately_on_error;
-      exit_immediately_on_error = 0;
-
-      /* Temporarily set $0 while running startup files, then restore it so
-	 we get better error messages when trying to open script files. */
-      if (shell_script_filename)
-	{
-	  t = dollar_vars[0];
-	  dollar_vars[0] = exec_argv0 ? savestring (exec_argv0) : savestring (shell_script_filename);
-	}
-      run_startup_files ();
-      if (shell_script_filename)
-	{
-	  free (dollar_vars[0]);
-	  dollar_vars[0] = t;
-	}
-      exit_immediately_on_error += old_errexit_flag;
-    }
-
-  /* If we are invoked as `sh', turn on Posix mode. */
-  if (act_like_sh)
-    {
-      bind_variable ("POSIXLY_CORRECT", "y", 0);
-      sv_strict_posix ("POSIXLY_CORRECT");
-    }
-
-#if defined (RESTRICTED_SHELL)
-  /* Turn on the restrictions after executing the startup files.  This
-     means that `bash -r' or `set -r' invoked from a startup file will
-     turn on the restrictions after the startup files are executed. */
-  restricted = saverst || restricted;
-  if (shell_reinitialized == 0)
-    maybe_make_restricted (shell_name);
-#endif /* RESTRICTED_SHELL */
-
-#if defined (WORDEXP_OPTION)
-  if (wordexp_only)
-    {
-      startup_state = 3;
-      last_command_exit_value = run_wordexp (argv[top_level_arg_index]);
-      exit_shell (last_command_exit_value);
-    }
-#endif
-
-  cmd_init ();		/* initialize the command object caches */
-  uwp_init ();
-
-  if (command_execution_string)
-    {
-      startup_state = 2;
-
-      if (debugging_mode)
-	start_debugger ();
-
-#if defined (ONESHOT)
-      executing = 1;
-      run_one_command (command_execution_string);
-      exit_shell (last_command_exit_value);
-#else /* ONESHOT */
-      with_input_from_string (command_execution_string, "-c");
-      goto read_and_execute;
-#endif /* !ONESHOT */
-    }
-
-  /* Get possible input filename and set up default_buffered_input or
-     default_input as appropriate. */
-  if (shell_script_filename)
-    open_shell_script (shell_script_filename);
-  else if (interactive == 0)
-    {
-      /* In this mode, bash is reading a script from stdin, which is a
-	 pipe or redirected file. */
-#if defined (BUFFERED_INPUT)
-      default_buffered_input = fileno (stdin);	/* == 0 */
-#else
-      setbuf (default_input, (char *)NULL);
-#endif /* !BUFFERED_INPUT */
-      read_from_stdin = 1;
-    }
-  else if (top_level_arg_index == argc)		/* arg index before startup files */
-    /* "If there are no operands and the -c option is not specified, the -s
-       option shall be assumed." */
-    read_from_stdin = 1;
-
-  set_bash_input ();
-
-  if (debugging_mode && locally_skip_execution == 0 && running_setuid == 0 && (reading_shell_script || interactive_shell == 0))
-    start_debugger ();
-
-  /* Do the things that should be done only for interactive shells. */
-  if (interactive_shell)
-    {
-      /* Set up for checking for presence of mail. */
-      reset_mail_timer ();
-      init_mail_dates ();
-
-#if defined (HISTORY)
-      /* Initialize the interactive history stuff. */
-      bash_initialize_history ();
-      /* Don't load the history from the history file if we've already
-	 saved some lines in this session (e.g., by putting `history -s xx'
-	 into one of the startup files). */
-      if (shell_initialized == 0 && history_lines_this_session == 0)
-	load_history ();
-#endif /* HISTORY */
-
-      /* Initialize terminal state for interactive shells after the
-	 .bash_profile and .bashrc are interpreted. */
-      get_tty_state ();
-    }
-
-#if !defined (ONESHOT)
- read_and_execute:
-#endif /* !ONESHOT */
-
-  shell_initialized = 1;
-
-  if (pretty_print_mode && interactive_shell)
-    {
-      internal_warning (_("pretty-printing mode ignored in interactive shells"));
-      pretty_print_mode = 0;
-    }
-  if (pretty_print_mode)
-    exit_shell (pretty_print_loop ());
-
-  /* Read commands until exit condition. */
-  reader_loop ();
-  exit_shell (last_command_exit_value);
-}
-
-static int
-parse_long_options (argv, arg_start, arg_end)
-     char **argv;
-     int arg_start, arg_end;
-{
-  int arg_index, longarg, i;
-  char *arg_string;
-
-  arg_index = arg_start;
-  while ((arg_index != arg_end) && (arg_string = argv[arg_index]) &&
-	 (*arg_string == '-'))
-    {
-      longarg = 0;
-
-      /* Make --login equivalent to -login. */
-      if (arg_string[1] == '-' && arg_string[2])
-	{
-	  longarg = 1;
-	  arg_string++;
-	}
-
-      for (i = 0; long_args[i].name; i++)
-	{
-	  if (STREQ (arg_string + 1, long_args[i].name))
-	    {
-	      if (long_args[i].type == Int)
-		*long_args[i].int_value = 1;
-	      else if (argv[++arg_index] == 0)
-		{
-		  report_error (_("%s: option requires an argument"), long_args[i].name);
-		  exit (EX_BADUSAGE);
-		}
-	      else
-		*long_args[i].char_value = argv[arg_index];
-
-	      break;
-	    }
-	}
-      if (long_args[i].name == 0)
-	{
-	  if (longarg)
-	    {
-	      report_error (_("%s: invalid option"), argv[arg_index]);
-	      show_shell_usage (stderr, 0);
-	      exit (EX_BADUSAGE);
-	    }
-	  break;		/* No such argument.  Maybe flag arg. */
-	}
-
-      arg_index++;
-    }
-
-  return (arg_index);
-}
-
-static int
-parse_shell_options (argv, arg_start, arg_end)
-     char **argv;
-     int arg_start, arg_end;
-{
-  int arg_index;
-  int arg_character, on_or_off, next_arg, i;
-  char *o_option, *arg_string;
-
-  arg_index = arg_start;
-  while (arg_index != arg_end && (arg_string = argv[arg_index]) &&
-	 (*arg_string == '-' || *arg_string == '+'))
-    {
-      /* There are flag arguments, so parse them. */
-      next_arg = arg_index + 1;
-
-      /* A single `-' signals the end of options.  From the 4.3 BSD sh.
-	 An option `--' means the same thing; this is the standard
-	 getopt(3) meaning. */
-      if (arg_string[0] == '-' &&
-	   (arg_string[1] == '\0' ||
-	     (arg_string[1] == '-' && arg_string[2] == '\0')))
-	return (next_arg);
-
-      i = 1;
-      on_or_off = arg_string[0];
-      while (arg_character = arg_string[i++])
-	{
-	  switch (arg_character)
-	    {
-	    case 'c':
-	      want_pending_command = 1;
-	      break;
-
-	    case 'l':
-	      make_login_shell = 1;
-	      break;
-
-	    case 's':
-	      read_from_stdin = 1;
-	      break;
-
-	    case 'o':
-	      o_option = argv[next_arg];
-	      if (o_option == 0)
-		{
-		  set_option_defaults ();
-		  list_minus_o_opts (-1, (on_or_off == '-') ? 0 : 1);
-		  reset_option_defaults ();
-		  break;
-		}
-	      if (set_minus_o_option (on_or_off, o_option) != EXECUTION_SUCCESS)
-		exit (EX_BADUSAGE);
-	      next_arg++;
-	      break;
-
-	    case 'O':
-	      /* Since some of these can be overridden by the normal
-		 interactive/non-interactive shell initialization or
-		 initializing posix mode, we save the options and process
-		 them after initialization. */
-	      o_option = argv[next_arg];
-	      if (o_option == 0)
-		{
-		  shopt_listopt (o_option, (on_or_off == '-') ? 0 : 1);
-		  break;
-		}
-	      add_shopt_to_alist (o_option, on_or_off);
-	      next_arg++;
-	      break;
-
-	    case 'D':
-#if defined (TRANSLATABLE_STRINGS)
-	      dump_translatable_strings = 1;
-#endif
-	      break;
-
-	    default:
-	      if (change_flag (arg_character, on_or_off) == FLAG_ERROR)
-		{
-		  report_error (_("%c%c: invalid option"), on_or_off, arg_character);
-		  show_shell_usage (stderr, 0);
-		  exit (EX_BADUSAGE);
-		}
-	    }
-	}
-      /* Can't do just a simple increment anymore -- what about
-	 "bash -abouo emacs ignoreeof -hP"? */
-      arg_index = next_arg;
-    }
-
-  return (arg_index);
-}
-
-/* Exit the shell with status S. */
-void
-exit_shell (s)
-     int s;
-{
-  fflush (stdout);		/* XXX */
-  fflush (stderr);
-
-  /* Clean up the terminal if we are in a state where it's been modified. */
-#if defined (READLINE)
-  if (RL_ISSTATE (RL_STATE_TERMPREPPED) && rl_deprep_term_function)
-    (*rl_deprep_term_function) ();
-#endif
-  if (read_tty_modified ())
-    read_tty_cleanup ();
-
-  /* Do trap[0] if defined.  Allow it to override the exit status
-     passed to us. */
-  if (signal_is_trapped (0))
-    s = run_exit_trap ();
-
-#if defined (PROCESS_SUBSTITUTION)
-  unlink_all_fifos ();
-#endif /* PROCESS_SUBSTITUTION */
-
-#if defined (HISTORY)
-  if (remember_on_history)
-    maybe_save_shell_history ();
-#endif /* HISTORY */
-
-#if defined (COPROCESS_SUPPORT)
-  coproc_flush ();
-#endif
-
-#if defined (JOB_CONTROL)
-  /* If the user has run `shopt -s huponexit', hangup all jobs when we exit
-     an interactive login shell.  ksh does this unconditionally. */
-  if (interactive_shell && login_shell && hup_on_exit)
-    hangup_all_jobs ();
-
-  /* If this shell is interactive, or job control is active, terminate all
-     stopped jobs and restore the original terminal process group.  Don't do
-     this if we're in a subshell and calling exit_shell after, for example,
-     a failed word expansion.  We want to do this even if the shell is not
-     interactive because we set the terminal's process group when job control
-     is enabled regardless of the interactive status. */
-  if (subshell_environment == 0)
-    end_job_control ();
-#endif /* JOB_CONTROL */
-
-  /* Always return the exit status of the last command to our parent. */
-  sh_exit (s);
-}
-
-/* A wrapper for exit that (optionally) can do other things, like malloc
-   statistics tracing. */
-void
-sh_exit (s)
-     int s;
-{
-#if defined (MALLOC_DEBUG) && defined (USING_BASH_MALLOC)
-  if (malloc_trace_at_exit && (subshell_environment & (SUBSHELL_COMSUB|SUBSHELL_PROCSUB)) == 0)
-    trace_malloc_stats (get_name_for_error (), (char *)NULL);
-  /* mlocation_write_table (); */
-#endif
-
-  exit (s);
-}
-
-/* Exit a subshell, which includes calling the exit trap.  We don't want to
-   do any more cleanup, since a subshell is created as an exact copy of its
-   parent. */
-void
-subshell_exit (s)
-     int s;
-{
-  fflush (stdout);
-  fflush (stderr);
-
-  /* Do trap[0] if defined.  Allow it to override the exit status
-     passed to us. */
-  last_command_exit_value = s;
-  if (signal_is_trapped (0))
-    s = run_exit_trap ();
-
-  sh_exit (s);
-}
-
-void
-set_exit_status (s)
-     int s;
-{
-  set_pipestatus_from_exit (last_command_exit_value = s);
-}
-
-/* Source the bash startup files.  If POSIXLY_CORRECT is non-zero, we obey
-   the Posix.2 startup file rules:  $ENV is expanded, and if the file it
-   names exists, that file is sourced.  The Posix.2 rules are in effect
-   for interactive shells only. (section 4.56.5.3) */
-
-/* Execute ~/.bashrc for most shells.  Never execute it if
-   ACT_LIKE_SH is set, or if NO_RC is set.
-
-   If the executable file "/usr/gnu/src/bash/foo" contains:
-
-   #!/usr/gnu/bin/bash
-   echo hello
-
-   then:
-
-	 COMMAND	    EXECUTE BASHRC
-	 --------------------------------
-	 bash -c foo		NO
-	 bash foo		NO
-	 foo			NO
-	 rsh machine ls		YES (for rsh, which calls `bash -c')
-	 rsh machine foo	YES (for shell started by rsh) NO (for foo!)
-	 echo ls | bash		NO
-	 login			NO
-	 bash			YES
-*/
-
-static void
-execute_env_file (env_file)
-      char *env_file;
-{
-  char *fn;
-
-  if (env_file && *env_file)
-    {
-      fn = expand_string_unsplit_to_string (env_file, Q_DOUBLE_QUOTES);
-      if (fn && *fn)
-	maybe_execute_file (fn, 1);
-      FREE (fn);
-    }
-}
-
-static void
-run_startup_files ()
-{
-#if defined (JOB_CONTROL)
-  int old_job_control;
-#endif
-  int sourced_login, run_by_ssh;
-
-#if 1	/* TAG:bash-5.3 andrew.gregory.8@gmail.com 2/21/2022 */
-  /* get the rshd/sshd case out of the way first. */
-  if (interactive_shell == 0 && no_rc == 0 && login_shell == 0 &&
-      act_like_sh == 0 && command_execution_string)
-    {
-#ifdef SSH_SOURCE_BASHRC
-      run_by_ssh = (find_variable ("SSH_CLIENT") != (SHELL_VAR *)0) ||
-		   (find_variable ("SSH2_CLIENT") != (SHELL_VAR *)0);
-#else
-      run_by_ssh = 0;
-#endif
-#endif
-
-      /* If we were run by sshd or we think we were run by rshd, execute
-	 ~/.bashrc if we are a top-level shell. */
-#if 1	/* TAG:bash-5.3 */
-      if ((run_by_ssh || isnetconn (fileno (stdin))) && shell_level < 2)
-#else
-      if (isnetconn (fileno (stdin) && shell_level < 2)
-#endif
-	{
-#ifdef SYS_BASHRC
-#  if defined (__OPENNT)
-	  maybe_execute_file (_prefixInstallPath(SYS_BASHRC, NULL, 0), 1);
-#  else
-	  maybe_execute_file (SYS_BASHRC, 1);
-#  endif
-#endif
-	  maybe_execute_file (bashrc_file, 1);
-	  return;
-	}
-    }
-
-#if defined (JOB_CONTROL)
-  /* Startup files should be run without job control enabled. */
-  old_job_control = interactive_shell ? set_job_control (0) : 0;
-#endif
-
-  sourced_login = 0;
-
-  /* A shell begun with the --login (or -l) flag that is not in posix mode
-     runs the login shell startup files, no matter whether or not it is
-     interactive.  If NON_INTERACTIVE_LOGIN_SHELLS is defined, run the
-     startup files if argv[0][0] == '-' as well. */
-#if defined (NON_INTERACTIVE_LOGIN_SHELLS)
-  if (login_shell && posixly_correct == 0)
-#else
-  if (login_shell < 0 && posixly_correct == 0)
-#endif
-    {
-      /* We don't execute .bashrc for login shells. */
-      no_rc++;
-
-      /* Execute /etc/profile and one of the personal login shell
-	 initialization files. */
-      if (no_profile == 0)
-	{
-	  maybe_execute_file (SYS_PROFILE, 1);
-
-	  if (act_like_sh)	/* sh */
-	    maybe_execute_file ("~/.profile", 1);
-	  else if ((maybe_execute_file ("~/.bash_profile", 1) == 0) &&
-		   (maybe_execute_file ("~/.bash_login", 1) == 0))	/* bash */
-	    maybe_execute_file ("~/.profile", 1);
-	}
-
-      sourced_login = 1;
-    }
-
-  /* A non-interactive shell not named `sh' and not in posix mode reads and
-     executes commands from $BASH_ENV.  If `su' starts a shell with `-c cmd'
-     and `-su' as the name of the shell, we want to read the startup files.
-     No other non-interactive shells read any startup files. */
-  if (interactive_shell == 0 && !(su_shell && login_shell))
-    {
-      if (posixly_correct == 0 && act_like_sh == 0 && privileged_mode == 0 &&
-	    sourced_env++ == 0)
-	execute_env_file (get_string_value ("BASH_ENV"));
-      return;
-    }
-
-  /* Interactive shell or `-su' shell. */
-  if (posixly_correct == 0)		  /* bash, sh */
-    {
-      if (login_shell && sourced_login++ == 0)
-	{
-	  /* We don't execute .bashrc for login shells. */
-	  no_rc++;
-
-	  /* Execute /etc/profile and one of the personal login shell
-	     initialization files. */
-	  if (no_profile == 0)
-	    {
-	      maybe_execute_file (SYS_PROFILE, 1);
-
-	      if (act_like_sh)	/* sh */
-		maybe_execute_file ("~/.profile", 1);
-	      else if ((maybe_execute_file ("~/.bash_profile", 1) == 0) &&
-		       (maybe_execute_file ("~/.bash_login", 1) == 0))	/* bash */
-		maybe_execute_file ("~/.profile", 1);
-	    }
-	}
-
-      /* bash */
-      if (act_like_sh == 0 && no_rc == 0)
-	{
-#ifdef SYS_BASHRC
-#  if defined (__OPENNT)
-	  maybe_execute_file (_prefixInstallPath(SYS_BASHRC, NULL, 0), 1);
-#  else
-	  maybe_execute_file (SYS_BASHRC, 1);
-#  endif
-#endif
-	  maybe_execute_file (bashrc_file, 1);
-	}
-      /* sh */
-      else if (act_like_sh && privileged_mode == 0 && sourced_env++ == 0)
-	execute_env_file (get_string_value ("ENV"));
-    }
-  else		/* bash --posix, sh --posix */
-    {
-      /* bash and sh */
-      if (interactive_shell && privileged_mode == 0 && sourced_env++ == 0)
-	execute_env_file (get_string_value ("ENV"));
-    }
-
-#if defined (JOB_CONTROL)
-  set_job_control (old_job_control);
-#endif
-}
-
-#if defined (RESTRICTED_SHELL)
-/* Return 1 if the shell should be a restricted one based on NAME or the
-   value of `restricted'.  Don't actually do anything, just return a
-   boolean value. */
-int
-shell_is_restricted (name)
-     char *name;
-{
-  char *temp;
-
-  if (restricted)
-    return 1;
-  temp = base_pathname (name);
-  if (*temp == '-')
-    temp++;
-  return (STREQ (temp, RESTRICTED_SHELL_NAME));
-}
-
-/* Perhaps make this shell a `restricted' one, based on NAME.  If the
-   basename of NAME is "rbash", then this shell is restricted.  The
-   name of the restricted shell is a configurable option, see config.h.
-   In a restricted shell, PATH, SHELL, ENV, and BASH_ENV are read-only
-   and non-unsettable.
-   Do this also if `restricted' is already set to 1; maybe the shell was
-   started with -r. */
-int
-maybe_make_restricted (name)
-     char *name;
-{
-  char *temp;
-
-  temp = base_pathname (name);
-  if (*temp == '-')
-    temp++;
-  if (restricted || (STREQ (temp, RESTRICTED_SHELL_NAME)))
-    {
-#if defined (RBASH_STATIC_PATH_VALUE)
-      bind_variable ("PATH", RBASH_STATIC_PATH_VALUE, 0);
-      stupidly_hack_special_variables ("PATH");		/* clear hash table */
-#endif
-      set_var_read_only ("PATH");
-      set_var_read_only ("SHELL");
-      set_var_read_only ("ENV");
-      set_var_read_only ("BASH_ENV");
-      set_var_read_only ("HISTFILE");
-      restricted = 1;
-    }
-  return (restricted);
-}
-#endif /* RESTRICTED_SHELL */
-
-/* Fetch the current set of uids and gids and return 1 if we're running
-   setuid or setgid. */
-static int
-uidget ()
-{
-  uid_t u;
-
-  u = getuid ();
-  if (current_user.uid != u)
-    {
-      FREE (current_user.user_name);
-      FREE (current_user.shell);
-      FREE (current_user.home_dir);
-      current_user.user_name = current_user.shell = current_user.home_dir = (char *)NULL;
-    }
-  current_user.uid = u;
-  current_user.gid = getgid ();
-  current_user.euid = geteuid ();
-  current_user.egid = getegid ();
-
-  /* See whether or not we are running setuid or setgid. */
-  return (current_user.uid != current_user.euid) ||
-	   (current_user.gid != current_user.egid);
-}
-
-void
-disable_priv_mode ()
-{
-  int e;
-
-#if HAVE_SETRESUID
-  if (setresuid (current_user.uid, current_user.uid, current_user.uid) < 0)
-#else
-  if (setuid (current_user.uid) < 0)
-#endif
-    {
-      e = errno;
-      sys_error (_("cannot set uid to %d: effective uid %d"), current_user.uid, current_user.euid);
-#if defined (EXIT_ON_SETUID_FAILURE)
-      if (e == EAGAIN)
-	exit (e);
-#endif
-    }
-#if HAVE_SETRESGID
-  if (setresgid (current_user.gid, current_user.gid, current_user.gid) < 0)
-#else
-  if (setgid (current_user.gid) < 0)
-#endif
-    sys_error (_("cannot set gid to %d: effective gid %d"), current_user.gid, current_user.egid);
-
-  current_user.euid = current_user.uid;
-  current_user.egid = current_user.gid;
-}
-
-#if defined (WORDEXP_OPTION)
-static int
-run_wordexp (words)
-     char *words;
-{
-  int code, nw, nb;
-  WORD_LIST *wl, *tl, *result;
-
-  code = setjmp_nosigs (top_level);
-
-  if (code != NOT_JUMPED)
-    {
-      switch (code)
-	{
-	  /* Some kind of throw to top_level has occurred. */
-	case FORCE_EOF:
-	  return last_command_exit_value = 127;
-	case ERREXIT:
-	case EXITPROG:
-	case EXITBLTIN:
-	  return last_command_exit_value;
-	case DISCARD:
-	  return last_command_exit_value = 1;
-	default:
-	  command_error ("run_wordexp", CMDERR_BADJUMP, code, 0);
-	}
-    }
-
-  /* Run it through the parser to get a list of words and expand them */
-  if (words && *words)
-    {
-      with_input_from_string (words, "--wordexp");
-      if (parse_command () != 0)
-	return (126);
-      if (global_command == 0)
-	{
-	  printf ("0\n0\n");
-	  return (0);
-	}
-      if (global_command->type != cm_simple)
-	return (126);
-      wl = global_command->value.Simple->words;
-      if (protected_mode)
-	for (tl = wl; tl; tl = tl->next)
-	  tl->word->flags |= W_NOCOMSUB|W_NOPROCSUB;
-      result = wl ? expand_words_no_vars (wl) : (WORD_LIST *)0;
-    }
-  else
-    result = (WORD_LIST *)0;
-
-  last_command_exit_value = 0;
-
-  if (result == 0)
-    {
-      printf ("0\n0\n");
-      return (0);
-    }
-
-  /* Count up the number of words and bytes, and print them.  Don't count
-     the trailing NUL byte. */
-  for (nw = nb = 0, wl = result; wl; wl = wl->next)
-    {
-      nw++;
-      nb += strlen (wl->word->word);
-    }
-  printf ("%u\n%u\n", nw, nb);
-  /* Print each word on a separate line.  This will have to be changed when
-     the interface to glibc is completed. */
-  for (wl = result; wl; wl = wl->next)
-    printf ("%s\n", wl->word->word);
-
-  return (0);
-}
-#endif
-
-#if defined (ONESHOT)
-/* Run one command, given as the argument to the -c option.  Tell
-   parse_and_execute not to fork for a simple command. */
-static int
-run_one_command (command)
-     char *command;
-{
-  int code;
-
-  code = setjmp_nosigs (top_level);
-
-  if (code != NOT_JUMPED)
-    {
-#if defined (PROCESS_SUBSTITUTION)
-      unlink_fifo_list ();
-#endif /* PROCESS_SUBSTITUTION */
-      switch (code)
-	{
-	  /* Some kind of throw to top_level has occurred. */
-	case FORCE_EOF:
-	  return last_command_exit_value = 127;
-	case ERREXIT:
-	case EXITPROG:
-	case EXITBLTIN:
-	  return last_command_exit_value;
-	case DISCARD:
-	  return last_command_exit_value = 1;
-	default:
-	  command_error ("run_one_command", CMDERR_BADJUMP, code, 0);
-	}
-    }
-   return (parse_and_execute (savestring (command), "-c", SEVAL_NOHIST|SEVAL_RESETLINE));
-}
-#endif /* ONESHOT */
-
-static int
-bind_args (argv, arg_start, arg_end, start_index)
-     char **argv;
-     int arg_start, arg_end, start_index;
-{
-  register int i;
-  WORD_LIST *args, *tl;
-
-  for (i = arg_start, args = tl = (WORD_LIST *)NULL; i < arg_end; i++)
-    {
-      if (args == 0)
-	args = tl = make_word_list (make_word (argv[i]), args);
-      else
-	{
-	  tl->next = make_word_list (make_word (argv[i]), (WORD_LIST *)NULL);
-	  tl = tl->next;
-	}
-    }
-
-  if (args)
-    {
-      if (start_index == 0)	/* bind to $0...$n for sh -c command */
-	{
-	  /* Posix.2 4.56.3 says that the first argument after sh -c command
-	     becomes $0, and the rest of the arguments become $1...$n */
-	  shell_name = savestring (args->word->word);
-	  FREE (dollar_vars[0]);
-	  dollar_vars[0] = savestring (args->word->word);
-	  remember_args (args->next, 1);
-	  if (debugging_mode)
-	    {
-	      push_args (args->next);	/* BASH_ARGV and BASH_ARGC */
-	      bash_argv_initialized = 1;
-	    }
-	}
-      else			/* bind to $1...$n for shell script */
-        {
-	  remember_args (args, 1);
-	  /* We do this unconditionally so something like -O extdebug doesn't
-	     do it first.  We're setting the definitive positional params
-	     here. */
-	  if (debugging_mode)
-	    {
-	      push_args (args);		/* BASH_ARGV and BASH_ARGC */
-	      bash_argv_initialized = 1;
-	    }
-        }
-
-      dispose_words (args);
-    }
-
-  return (i);
-}
-
-void
-unbind_args ()
-{
-  remember_args ((WORD_LIST *)NULL, 1);
-  pop_args ();				/* Reset BASH_ARGV and BASH_ARGC */
-}
-
-static void
-start_debugger ()
-{
-#if defined (DEBUGGER) && defined (DEBUGGER_START_FILE)
-  int old_errexit;
-  int r;
-
-  old_errexit = exit_immediately_on_error;
-  exit_immediately_on_error = 0;
-
-  r = force_execute_file (DEBUGGER_START_FILE, 1);
-  if (r < 0)
-    {
-      internal_warning (_("cannot start debugger; debugging mode disabled"));
-      debugging_mode = 0;
-    }
-  error_trace_mode = function_trace_mode = debugging_mode;
-
-  set_shellopts ();
-  set_bashopts ();
-
-  exit_immediately_on_error += old_errexit;
-#endif
-}
-
-static int
-open_shell_script (script_name)
-     char *script_name;
-{
-  int fd, e, fd_is_tty;
-  char *filename, *path_filename, *t;
-  char sample[80];
-  int sample_len;
-  struct stat sb;
-#if defined (ARRAY_VARS)
-  SHELL_VAR *funcname_v, *bash_source_v, *bash_lineno_v;
-  ARRAY *funcname_a, *bash_source_a, *bash_lineno_a;
-#endif
-
-  filename = savestring (script_name);
-
-  fd = open (filename, O_RDONLY);
-  if ((fd < 0) && (errno == ENOENT) && (absolute_program (filename) == 0))
-    {
-      e = errno;
-      /* If it's not in the current directory, try looking through PATH
-	 for it. */
-      path_filename = find_path_file (script_name);
-      if (path_filename)
-	{
-	  free (filename);
-	  filename = path_filename;
-	  fd = open (filename, O_RDONLY);
-	}
-      else
-	errno = e;
-    }
-
-  if (fd < 0)
-    {
-      e = errno;
-      file_error (filename);
-#if defined (JOB_CONTROL)
-      end_job_control ();	/* just in case we were run as bash -i script */
-#endif
-      sh_exit ((e == ENOENT) ? EX_NOTFOUND : EX_NOINPUT);
-    }
-
-  free (dollar_vars[0]);
-  dollar_vars[0] = exec_argv0 ? savestring (exec_argv0) : savestring (script_name);
-  if (exec_argv0)
-    {
-      free (exec_argv0);
-      exec_argv0 = (char *)NULL;
-    }
-
-  if (file_isdir (filename))
-    {
-#if defined (EISDIR)
-      errno = EISDIR;
-#else
-      errno = EINVAL;
-#endif
-      file_error (filename);
-#if defined (JOB_CONTROL)
-      end_job_control ();	/* just in case we were run as bash -i script */
-#endif
-      sh_exit (EX_NOINPUT);
-    }
-
-#if defined (ARRAY_VARS)
-  GET_ARRAY_FROM_VAR ("FUNCNAME", funcname_v, funcname_a);
-  GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v, bash_source_a);
-  GET_ARRAY_FROM_VAR ("BASH_LINENO", bash_lineno_v, bash_lineno_a);
-
-  array_push (bash_source_a, filename);
-  if (bash_lineno_a)
-    {
-      t = itos (executing_line_number ());
-      array_push (bash_lineno_a, t);
-      free (t);
-    }
-  array_push (funcname_a, "main");
-#endif
-
-#ifdef HAVE_DEV_FD
-  fd_is_tty = isatty (fd);
-#else
-  fd_is_tty = 0;
-#endif
-
-  /* Only do this with non-tty file descriptors we can seek on. */
-  if (fd_is_tty == 0 && (lseek (fd, 0L, 1) != -1))
-    {
-      /* Check to see if the `file' in `bash file' is a binary file
-	 according to the same tests done by execute_simple_command (),
-	 and report an error and exit if it is. */
-      sample_len = read (fd, sample, sizeof (sample));
-      if (sample_len < 0)
-	{
-	  e = errno;
-	  if ((fstat (fd, &sb) == 0) && S_ISDIR (sb.st_mode))
-	    {
-#if defined (EISDIR)
-	      errno = EISDIR;
-	      file_error (filename);
-#else	      
-	      internal_error (_("%s: Is a directory"), filename);
-#endif
-	    }
-	  else
-	    {
-	      errno = e;
-	      file_error (filename);
-	    }
-#if defined (JOB_CONTROL)
-	  end_job_control ();	/* just in case we were run as bash -i script */
-#endif
-	  exit (EX_NOEXEC);
-	}
-      else if (sample_len > 0 && (check_binary_file (sample, sample_len)))
-	{
-	  internal_error (_("%s: cannot execute binary file"), filename);
-#if defined (JOB_CONTROL)
-	  end_job_control ();	/* just in case we were run as bash -i script */
-#endif
-	  exit (EX_BINARY_FILE);
-	}
-      /* Now rewind the file back to the beginning. */
-      lseek (fd, 0L, 0);
-    }
-
-  /* Open the script.  But try to move the file descriptor to a randomly
-     large one, in the hopes that any descriptors used by the script will
-     not match with ours. */
-  fd = move_to_high_fd (fd, 1, -1);
-
-#if defined (BUFFERED_INPUT)
-  default_buffered_input = fd;
-  SET_CLOSE_ON_EXEC (default_buffered_input);
-#else /* !BUFFERED_INPUT */
-  default_input = fdopen (fd, "r");
-
-  if (default_input == 0)
-    {
-      file_error (filename);
-      exit (EX_NOTFOUND);
-    }
-
-  SET_CLOSE_ON_EXEC (fd);
-  if (fileno (default_input) != fd)
-    SET_CLOSE_ON_EXEC (fileno (default_input));
-#endif /* !BUFFERED_INPUT */
-
-  /* Just about the only way for this code to be executed is if something
-     like `bash -i /dev/stdin' is executed. */
-  if (interactive_shell && fd_is_tty)
-    {
-      dup2 (fd, 0);
-      close (fd);
-      fd = 0;
-#if defined (BUFFERED_INPUT)
-      default_buffered_input = 0;
-#else
-      fclose (default_input);
-      default_input = stdin;
-#endif
-    }
-  else if (forced_interactive && fd_is_tty == 0)
-    /* But if a script is called with something like `bash -i scriptname',
-       we need to do a non-interactive setup here, since we didn't do it
-       before. */
-    init_interactive_script ();
-
-  free (filename);
-
-  reading_shell_script = 1;
-  return (fd);
-}
-
-/* Initialize the input routines for the parser. */
-static void
-set_bash_input ()
-{
-  /* Make sure the fd from which we are reading input is not in
-     no-delay mode. */
-#if defined (BUFFERED_INPUT)
-  if (interactive == 0)
-    sh_unset_nodelay_mode (default_buffered_input);
-  else
-#endif /* !BUFFERED_INPUT */
-    sh_unset_nodelay_mode (fileno (stdin));
-
-  /* with_input_from_stdin really means `with_input_from_readline' */
-  if (interactive && no_line_editing == 0)
-    with_input_from_stdin ();
-#if defined (BUFFERED_INPUT)
-  else if (interactive == 0)
-    with_input_from_buffered_stream (default_buffered_input, dollar_vars[0]);
-#endif /* BUFFERED_INPUT */
-  else
-    with_input_from_stream (default_input, dollar_vars[0]);
-}
-
-/* Close the current shell script input source and forget about it.  This is
-   extern so execute_cmd.c:initialize_subshell() can call it.  If CHECK_ZERO
-   is non-zero, we close default_buffered_input even if it's the standard
-   input (fd 0). */
-void
-unset_bash_input (check_zero)
-     int check_zero;
-{
-#if defined (BUFFERED_INPUT)
-  if ((check_zero && default_buffered_input >= 0) ||
-      (check_zero == 0 && default_buffered_input > 0))
-    {
-      close_buffered_fd (default_buffered_input);
-      default_buffered_input = bash_input.location.buffered_fd = -1;
-      bash_input.type = st_none;		/* XXX */
-    }
-#else /* !BUFFERED_INPUT */
-  if (default_input)
-    {
-      fclose (default_input);
-      default_input = (FILE *)NULL;
-    }
-#endif /* !BUFFERED_INPUT */
-}
-      
-
-#if !defined (PROGRAM)
-#  define PROGRAM "bash"
-#endif
-
-static void
-set_shell_name (argv0)
-     char *argv0;
-{
-  /* Here's a hack.  If the name of this shell is "sh", then don't do
-     any startup files; just try to be more like /bin/sh. */
-  shell_name = argv0 ? base_pathname (argv0) : PROGRAM;
-
-  if (argv0 && *argv0 == '-')
-    {
-      if (*shell_name == '-')
-	shell_name++;
-      login_shell = 1;
-    }
-
-  if (shell_name[0] == 's' && shell_name[1] == 'h' && shell_name[2] == '\0')
-    act_like_sh++;
-  if (shell_name[0] == 's' && shell_name[1] == 'u' && shell_name[2] == '\0')
-    su_shell++;
-
-  shell_name = argv0 ? argv0 : PROGRAM;
-  FREE (dollar_vars[0]);
-  dollar_vars[0] = savestring (shell_name);
-
-  /* A program may start an interactive shell with
-	  "execl ("/bin/bash", "-", NULL)".
-     If so, default the name of this shell to our name. */
-  if (!shell_name || !*shell_name || (shell_name[0] == '-' && !shell_name[1]))
-    shell_name = PROGRAM;
-}
-
-/* Some options are initialized to -1 so we have a way to determine whether
-   they were set on the command line. This is an issue when listing the option
-   values at invocation (`bash -o'), so we set the defaults here and reset
-   them after the call to list_minus_o_options (). */
-/* XXX - could also do this for histexp_flag, jobs_m_flag */
-static void
-set_option_defaults ()
-{
-#if defined (HISTORY)
-  enable_history_list = 0;
-#endif
-}
-
-static void
-reset_option_defaults ()
-{
-#if defined (HISTORY)
-  enable_history_list = -1;
-#endif
-}
-
-static void
-init_interactive ()
-{
-  expand_aliases = interactive_shell = startup_state = 1;
-  interactive = 1;
-#if defined (HISTORY)
-  if (enable_history_list == -1)
-    enable_history_list = 1;				/* set default  */
-  remember_on_history = enable_history_list;
-#  if defined (BANG_HISTORY)
-  histexp_flag = history_expansion;			/* XXX */
-#  endif
-#endif
-}
-
-static void
-init_noninteractive ()
-{
-#if defined (HISTORY)
-  if (enable_history_list == -1)			/* set default */
-    enable_history_list = 0;
-  bash_history_reinit (0);
-#endif /* HISTORY */
-  interactive_shell = startup_state = interactive = 0;
-  expand_aliases = posixly_correct;	/* XXX - was 0 not posixly_correct */
-  no_line_editing = 1;
-#if defined (JOB_CONTROL)
-  /* Even if the shell is not interactive, enable job control if the -i or
-     -m option is supplied at startup. */
-  set_job_control (forced_interactive||jobs_m_flag);
-#endif /* JOB_CONTROL */
-}
-
-static void
-init_interactive_script ()
-{
-#if defined (HISTORY)
-  if (enable_history_list == -1)
-    enable_history_list = 1;
-#endif
-  init_noninteractive ();
-  expand_aliases = interactive_shell = startup_state = 1;
-#if defined (HISTORY)
-  remember_on_history = enable_history_list;	/* XXX */
-#endif
-}
-
-void
-get_current_user_info ()
-{
-  struct passwd *entry;
-
-  /* Don't fetch this more than once. */
-  if (current_user.user_name == 0)
-    {
-#if defined (__TANDEM)
-      entry = getpwnam (getlogin ());
-#else
-      entry = getpwuid (current_user.uid);
-#endif
-      if (entry)
-	{
-	  current_user.user_name = savestring (entry->pw_name);
-	  current_user.shell = (entry->pw_shell && entry->pw_shell[0])
-				? savestring (entry->pw_shell)
-				: savestring ("/bin/sh");
-	  current_user.home_dir = savestring (entry->pw_dir);
-	}
-      else
-	{
-	  current_user.user_name = _("I have no name!");
-	  current_user.user_name = savestring (current_user.user_name);
-	  current_user.shell = savestring ("/bin/sh");
-	  current_user.home_dir = savestring ("/");
-	}
-#if defined (HAVE_GETPWENT)
-      endpwent ();
-#endif
-    }
-}
-
-/* Do whatever is necessary to initialize the shell.
-   Put new initializations in here. */
-static void
-shell_initialize ()
-{
-  char hostname[256];
-  int should_be_restricted;
-
-  /* Line buffer output for stderr and stdout. */
-  if (shell_initialized == 0)
-    {
-      sh_setlinebuf (stderr);
-      sh_setlinebuf (stdout);
-    }
-
-  /* Sort the array of shell builtins so that the binary search in
-     find_shell_builtin () works correctly. */
-  initialize_shell_builtins ();
-
-  /* Initialize the trap signal handlers before installing our own
-     signal handlers.  traps.c:restore_original_signals () is responsible
-     for restoring the original default signal handlers.  That function
-     is called when we make a new child. */
-  initialize_traps ();
-  initialize_signals (0);
-
-  /* It's highly unlikely that this will change. */
-  if (current_host_name == 0)
-    {
-      /* Initialize current_host_name. */
-      if (gethostname (hostname, 255) < 0)
-	current_host_name = "??host??";
-      else
-	current_host_name = savestring (hostname);
-    }
-
-  /* Initialize the stuff in current_user that comes from the password
-     file.  We don't need to do this right away if the shell is not
-     interactive. */
-  if (interactive_shell)
-    get_current_user_info ();
-
-  /* Initialize our interface to the tilde expander. */
-  tilde_initialize ();
-
-#if defined (RESTRICTED_SHELL)
-  should_be_restricted = shell_is_restricted (shell_name);
-#endif
-
-  /* Initialize internal and environment variables.  Don't import shell
-     functions from the environment if we are running in privileged or
-     restricted mode or if the shell is running setuid. */
-#if defined (RESTRICTED_SHELL)
-  initialize_shell_variables (shell_environment, privileged_mode||restricted||should_be_restricted||running_setuid);
-#else
-  initialize_shell_variables (shell_environment, privileged_mode||running_setuid);
-#endif
-
-  /* Initialize the data structures for storing and running jobs. */
-  initialize_job_control (jobs_m_flag);
-
-  /* Initialize input streams to null. */
-  initialize_bash_input ();
-
-  initialize_flags ();
-
-  /* Initialize the shell options.  Don't import the shell options
-     from the environment variables $SHELLOPTS or $BASHOPTS if we are
-     running in privileged or restricted mode or if the shell is running
-     setuid. */
-#if defined (RESTRICTED_SHELL)
-  initialize_shell_options (privileged_mode||restricted||should_be_restricted||running_setuid);
-  initialize_bashopts (privileged_mode||restricted||should_be_restricted||running_setuid);
-#else
-  initialize_shell_options (privileged_mode||running_setuid);
-  initialize_bashopts (privileged_mode||running_setuid);
-#endif
-}
-
-/* Function called by main () when it appears that the shell has already
-   had some initialization performed.  This is supposed to reset the world
-   back to a pristine state, as if we had been exec'ed. */
-static void
-shell_reinitialize ()
-{
-  /* The default shell prompts. */
-  primary_prompt = PPROMPT;
-  secondary_prompt = SPROMPT;
-
-  /* Things that get 1. */
-  current_command_number = 1;
-
-  /* We have decided that the ~/.bashrc file should not be executed
-     for the invocation of each shell script.  If the variable $ENV
-     (or $BASH_ENV) is set, its value is used as the name of a file
-     to source. */
-  no_rc = no_profile = 1;
-
-  /* Things that get 0. */
-  login_shell = make_login_shell = interactive = executing = 0;
-  debugging = do_version = line_number = last_command_exit_value = 0;
-  forced_interactive = interactive_shell = 0;
-  subshell_environment = running_in_background = 0;
-  expand_aliases = 0;
-  bash_argv_initialized = 0;
-
-  /* XXX - should we set jobs_m_flag to 0 here? */
-
-#if defined (HISTORY)
-  bash_history_reinit (enable_history_list = 0);
-#endif /* HISTORY */
-
-#if defined (RESTRICTED_SHELL)
-  restricted = 0;
-#endif /* RESTRICTED_SHELL */
-
-  /* Ensure that the default startup file is used.  (Except that we don't
-     execute this file for reinitialized shells). */
-  bashrc_file = DEFAULT_BASHRC;
-
-  /* Delete all variables and functions.  They will be reinitialized when
-     the environment is parsed. */
-  delete_all_contexts (shell_variables);
-  delete_all_variables (shell_functions);
-
-  reinit_special_variables ();
-
-#if defined (READLINE)
-  bashline_reinitialize ();
-#endif
-
-  shell_reinitialized = 1;
-}
-
-static void
-show_shell_usage (fp, extra)
-     FILE *fp;
-     int extra;
-{
-  int i;
-  char *set_opts, *s, *t;
-
-  if (extra)
-    fprintf (fp, _("GNU bash, version %s-(%s)\n"), shell_version_string (), MACHTYPE);
-  fprintf (fp, _("Usage:\t%s [GNU long option] [option] ...\n\t%s [GNU long option] [option] script-file ...\n"),
-	     shell_name, shell_name);
-  fputs (_("GNU long options:\n"), fp);
-  for (i = 0; long_args[i].name; i++)
-    fprintf (fp, "\t--%s\n", long_args[i].name);
-
-  fputs (_("Shell options:\n"), fp);
-  fputs (_("\t-ilrsD or -c command or -O shopt_option\t\t(invocation only)\n"), fp);
-
-  for (i = 0, set_opts = 0; shell_builtins[i].name; i++)
-    if (STREQ (shell_builtins[i].name, "set"))
-      {
-	set_opts = savestring (shell_builtins[i].short_doc);
-	break;
-      }
-
-  if (set_opts)
-    {
-      s = strchr (set_opts, '[');
-      if (s == 0)
-	s = set_opts;
-      while (*++s == '-')
-	;
-      t = strchr (s, ']');
-      if (t)
-	*t = '\0';
-      fprintf (fp, _("\t-%s or -o option\n"), s);
-      free (set_opts);
-    }
-
-  if (extra)
-    {
-      fprintf (fp, _("Type `%s -c \"help set\"' for more information about shell options.\n"), shell_name);
-      fprintf (fp, _("Type `%s -c help' for more information about shell builtin commands.\n"), shell_name);
-      fprintf (fp, _("Use the `bashbug' command to report bugs.\n"));
-      fprintf (fp, "\n");
-      fprintf (fp, _("bash home page: <http://www.gnu.org/software/bash>\n"));
-      fprintf (fp, _("General help using GNU software: <http://www.gnu.org/gethelp/>\n"));
-    }
-}
-
-static void
-add_shopt_to_alist (opt, on_or_off)
-     char *opt;
-     int on_or_off;
-{
-  if (shopt_ind >= shopt_len)
-    {
-      shopt_len += 8;
-      shopt_alist = (STRING_INT_ALIST *)xrealloc (shopt_alist, shopt_len * sizeof (shopt_alist[0]));
-    }
-  shopt_alist[shopt_ind].word = opt;
-  shopt_alist[shopt_ind].token = on_or_off;
-  shopt_ind++;
-}
-
-static void
-run_shopt_alist ()
-{
-  register int i;
-
-  for (i = 0; i < shopt_ind; i++)
-    if (shopt_setopt (shopt_alist[i].word, (shopt_alist[i].token == '-')) != EXECUTION_SUCCESS)
-      exit (EX_BADUSAGE);
-  free (shopt_alist);
-  shopt_alist = 0;
-  shopt_ind = shopt_len = 0;
-}
diff --git a/third_party/bash/shell.h b/third_party/bash/shell.h
deleted file mode 100644
index 6e44bca69..000000000
--- a/third_party/bash/shell.h
+++ /dev/null
@@ -1,240 +0,0 @@
-/* shell.h -- The data structures used by the shell */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "bashjmp.h"
-
-#include "command.h"
-#include "syntax.h"
-#include "general.h"
-#include "error.h"
-#include "variables.h"
-#include "arrayfunc.h"
-#include "quit.h"
-#include "maxpath.h"
-#include "unwind_prot.h"
-#include "dispose_cmd.h"
-#include "make_cmd.h"
-#include "ocache.h"
-#include "subst.h"
-#include "sig.h"
-#include "pathnames.h"
-#include "externs.h"
-
-extern int EOF_Reached;
-
-#define NO_PIPE -1
-#define REDIRECT_BOTH -2
-
-#define NO_VARIABLE -1
-
-/* Values that can be returned by execute_command (). */
-#define EXECUTION_FAILURE 1
-#define EXECUTION_SUCCESS 0
-
-/* Usage messages by builtins result in a return status of 2. */
-#define EX_BADUSAGE	2
-
-#define EX_MISCERROR	2
-
-/* Special exit statuses used by the shell, internally and externally. */
-#define EX_RETRYFAIL	124
-#define EX_WEXPCOMSUB	125
-#define EX_BINARY_FILE	126
-#define EX_NOEXEC	126
-#define EX_NOINPUT	126
-#define EX_NOTFOUND	127
-
-#define EX_SHERRBASE	256	/* all special error values are > this. */
-
-#define EX_BADSYNTAX	257	/* shell syntax error */
-#define EX_USAGE	258	/* syntax error in usage */
-#define EX_REDIRFAIL	259	/* redirection failed */
-#define EX_BADASSIGN	260	/* variable assignment error */
-#define EX_EXPFAIL	261	/* word expansion failed */
-#define EX_DISKFALLBACK	262	/* fall back to disk command from builtin */
-
-/* Flag values that control parameter pattern substitution. */
-#define MATCH_ANY	0x000
-#define MATCH_BEG	0x001
-#define MATCH_END	0x002
-
-#define MATCH_TYPEMASK	0x003
-
-#define MATCH_GLOBREP	0x010
-#define MATCH_QUOTED	0x020
-#define MATCH_ASSIGNRHS	0x040
-#define MATCH_STARSUB	0x080
-#define MATCH_EXPREP	0x100	/* for pattern substitution, expand replacement */
-
-/* Some needed external declarations. */
-extern char **shell_environment;
-extern WORD_LIST *rest_of_args;
-
-/* Generalized global variables. */
-extern char *command_execution_string;
-
-extern int debugging_mode;
-extern int executing, login_shell;
-extern int interactive, interactive_shell;
-extern int startup_state;
-extern int reading_shell_script;
-extern int shell_initialized;
-extern int bash_argv_initialized;
-extern int subshell_environment;
-extern int current_command_number;
-extern int indirection_level;
-extern int shell_compatibility_level;
-extern int running_under_emacs;
-
-extern int posixly_correct;
-extern int no_line_editing;
-
-extern char *shell_name;
-extern char *current_host_name;
-
-extern int subshell_argc;
-extern char **subshell_argv;
-extern char **subshell_envp;
-
-/* variables managed using shopt */
-extern int hup_on_exit;
-extern int check_jobs_at_exit;
-extern int autocd;
-extern int check_window_size;
-
-/* from version.c */
-extern int build_version, patch_level;
-extern char *dist_version, *release_status;
-
-extern int locale_mb_cur_max;
-extern int locale_utf8locale;
-
-/* Structure to pass around that holds a bitmap of file descriptors
-   to close, and the size of that structure.  Used in execute_cmd.c. */
-struct fd_bitmap {
-  int size;
-  char *bitmap;
-};
-
-#define FD_BITMAP_SIZE 32
-
-#define CTLESC '\001'
-#define CTLNUL '\177'
-
-/* Information about the current user. */
-struct user_info {
-  uid_t uid, euid;
-  gid_t gid, egid;
-  char *user_name;
-  char *shell;		/* shell from the password file */
-  char *home_dir;
-};
-
-extern struct user_info current_user;
-
-/* Force gcc to not clobber X on a longjmp().  Old versions of gcc mangle
-   this badly. */
-#if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ > 8)
-#  define USE_VAR(x)	((void) &(x))
-#else
-#  define USE_VAR(x)
-#endif
-
-#define HEREDOC_MAX 16
-
-/* Structure in which to save partial parsing state when doing things like
-   PROMPT_COMMAND and bash_execute_unix_command execution. */
-
-typedef struct _sh_parser_state_t
-{
-  /* parsing state */
-  int parser_state;
-  int *token_state;
-
-  char *token;
-  size_t token_buffer_size;
-  int eof_token;
-
-  /* input line state -- line number saved elsewhere */
-  int input_line_terminator;
-  int eof_encountered;
-  int eol_lookahead;
-
-#if defined (HANDLE_MULTIBYTE)
-  /* Nothing right now for multibyte state, but might want something later. */
-#endif
-
-  char **prompt_string_pointer;
-
-  /* history state affecting or modified by the parser */
-  int current_command_line_count;
-#if defined (HISTORY)
-  int remember_on_history;
-  int history_expansion_inhibited;
-#endif
-
-  /* execution state possibly modified by the parser */
-  int last_command_exit_value;
-#if defined (ARRAY_VARS)
-  ARRAY *pipestatus;
-#endif
-  sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;
-
-  /* flags state affecting the parser */
-  int expand_aliases;
-  int echo_input_at_read;
-  int need_here_doc;
-  int here_doc_first_line;
-
-  int esacs_needed;
-  int expecting_in;
-
-  /* structures affecting the parser */
-  void *pushed_strings;
-  REDIRECT *redir_stack[HEREDOC_MAX];
-} sh_parser_state_t;
-
-typedef struct _sh_input_line_state_t
-{
-  char *input_line;
-  size_t input_line_index;
-  size_t input_line_size;
-  size_t input_line_len;
-#if defined (HANDLE_MULTIBYTE)
-  char *input_property;
-  size_t input_propsize;
-#endif
-} sh_input_line_state_t;
-
-/* Let's try declaring these here. */
-extern void shell_ungets PARAMS((char *));
-extern void rewind_input_string PARAMS((void));
-
-extern char *parser_remaining_input PARAMS((void));
-
-extern sh_parser_state_t *save_parser_state PARAMS((sh_parser_state_t *));
-extern void restore_parser_state PARAMS((sh_parser_state_t *));
-
-extern sh_input_line_state_t *save_input_line_state PARAMS((sh_input_line_state_t *));
-extern void restore_input_line_state PARAMS((sh_input_line_state_t *));
diff --git a/third_party/bash/shmatch.c b/third_party/bash/shmatch.c
deleted file mode 100644
index dd5a2f802..000000000
--- a/third_party/bash/shmatch.c
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * shmatch.c -- shell interface to posix regular expression matching.
- */
-
-/* Copyright (C) 2003-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifdef HAVE_CONFIG_H
-#  include "config.h"
-#endif
-
-#if defined (HAVE_POSIX_REGEXP)
-
-#ifdef HAVE_UNISTD_H
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-
-#include <stdio.h>
-#include <regex.h>
-
-#include "shell.h"
-#include "variables.h"
-#include "externs.h"
-
-extern int glob_ignore_case, match_ignore_case;
-
-#if defined (ARRAY_VARS)
-extern SHELL_VAR *builtin_find_indexed_array (char *, int);
-#endif
-
-int
-sh_regmatch (string, pattern, flags)
-     const char *string;
-     const char *pattern;
-     int flags;
-{
-  regex_t regex = { 0 };
-  regmatch_t *matches;
-  int rflags;
-#if defined (ARRAY_VARS)
-  SHELL_VAR *rematch;
-  ARRAY *amatch;
-  int subexp_ind;
-  char *subexp_str;
-  int subexp_len;
-#endif
-  int result;
-
-#if defined (ARRAY_VARS)
-  rematch = (SHELL_VAR *)NULL;
-#endif
-
-  rflags = REG_EXTENDED;
-  if (match_ignore_case)
-    rflags |= REG_ICASE;
-#if !defined (ARRAY_VARS)
-  rflags |= REG_NOSUB;
-#endif
-
-  if (regcomp (&regex, pattern, rflags))
-    return 2;		/* flag for printing a warning here. */
-
-#if defined (ARRAY_VARS)
-  matches = (regmatch_t *)malloc (sizeof (regmatch_t) * (regex.re_nsub + 1));
-#else
-  matches = NULL;
-#endif
-
-  /* man regexec: NULL PMATCH ignored if NMATCH == 0 */
-  if (regexec (&regex, string, matches ? regex.re_nsub + 1 : 0, matches, 0))
-    result = EXECUTION_FAILURE;
-  else
-    result = EXECUTION_SUCCESS;		/* match */
-
-#if defined (ARRAY_VARS)
-  subexp_len = strlen (string) + 10;
-  subexp_str = malloc (subexp_len + 1);
-
-  /* Store the parenthesized subexpressions in the array BASH_REMATCH.
-     Element 0 is the portion that matched the entire regexp.  Element 1
-     is the part that matched the first subexpression, and so on. */
-#if 1
-  unbind_global_variable_noref ("BASH_REMATCH");
-  rematch = make_new_array_variable ("BASH_REMATCH");
-#else
-  /* TAG:bash-5.3 */
-  rematch = builtin_find_indexed_array ("BASH_REMATCH", 1);
-#endif
-  amatch = rematch ? array_cell (rematch) : (ARRAY *)0;
-
-  if (matches && amatch && (flags & SHMAT_SUBEXP) && result == EXECUTION_SUCCESS && subexp_str)
-    {
-      for (subexp_ind = 0; subexp_ind <= regex.re_nsub; subexp_ind++)
-	{
-	  memset (subexp_str, 0, subexp_len);
-	  strncpy (subexp_str, string + matches[subexp_ind].rm_so,
-		     matches[subexp_ind].rm_eo - matches[subexp_ind].rm_so);
-	  array_insert (amatch, subexp_ind, subexp_str);
-	}
-    }
-
-#if 0
-  VSETATTR (rematch, att_readonly);
-#endif
-
-  free (subexp_str);
-  free (matches);
-#endif /* ARRAY_VARS */
-
-  regfree (&regex);
-
-  return result;
-}
-
-#endif /* HAVE_POSIX_REGEXP */
diff --git a/third_party/bash/shmbchar.c b/third_party/bash/shmbchar.c
deleted file mode 100644
index 827ee6b39..000000000
--- a/third_party/bash/shmbchar.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/* Copyright (C) 2001, 2006, 2009, 2010, 2012, 2015-2018 Free Software Foundation, Inc.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-
-#include "config.h"
-
-#if defined (HANDLE_MULTIBYTE)
-#include <stdlib.h>
-#include <limits.h>
-
-#include <errno.h>
-
-#include "shmbutil.h"
-#include "shmbchar.h"
-
-#ifndef errno
-extern int errno;
-#endif
-
-#if IS_BASIC_ASCII
-
-/* Bit table of characters in the ISO C "basic character set".  */
-const unsigned int is_basic_table [UCHAR_MAX / 32 + 1] =
-{
-  0x00001a00,           /* '\t' '\v' '\f' */
-  0xffffffef,           /* ' '...'#' '%'...'?' */
-  0xfffffffe,           /* 'A'...'Z' '[' '\\' ']' '^' '_' */
-  0x7ffffffe            /* 'a'...'z' '{' '|' '}' '~' */
-  /* The remaining bits are 0.  */
-};
-
-#endif /* IS_BASIC_ASCII */
-
-extern int locale_utf8locale;
-
-extern char *utf8_mbsmbchar (const char *);
-extern int utf8_mblen (const char *, size_t);
-
-/* Count the number of characters in S, counting multi-byte characters as a
-   single character. */
-size_t
-mbstrlen (s)
-     const char *s;
-{
-  size_t clen, nc;
-  mbstate_t mbs = { 0 }, mbsbak = { 0 };
-  int f, mb_cur_max;
-
-  nc = 0;
-  mb_cur_max = MB_CUR_MAX;
-  while (*s && (clen = (f = is_basic (*s)) ? 1 : mbrlen(s, mb_cur_max, &mbs)) != 0)
-    {
-      if (MB_INVALIDCH(clen))
-	{
-	  clen = 1;	/* assume single byte */
-	  mbs = mbsbak;
-	}
-
-      if (f == 0)
-	mbsbak = mbs;
-
-      s += clen;
-      nc++;
-    }
-  return nc;
-}
-
-/* Return pointer to first multibyte char in S, or NULL if none. */
-/* XXX - if we know that the locale is UTF-8, we can just check whether or
-   not any byte has the eighth bit turned on */
-char *
-mbsmbchar (s)
-     const char *s;
-{
-  char *t;
-  size_t clen;
-  mbstate_t mbs = { 0 };
-  int mb_cur_max;
-
-  if (locale_utf8locale)
-    return (utf8_mbsmbchar (s));	/* XXX */
-
-  mb_cur_max = MB_CUR_MAX;
-  for (t = (char *)s; *t; t++)
-    {
-      if (is_basic (*t))
-	continue;
-
-      if (locale_utf8locale)		/* not used if above code active */
-	clen = utf8_mblen (t, mb_cur_max);
-      else
-	clen = mbrlen (t, mb_cur_max, &mbs);
-
-      if (clen == 0)
-        return 0;
-      if (MB_INVALIDCH(clen))
-	continue;
-
-      if (clen > 1)
-	return t;
-    }
-  return 0;
-}
-
-int
-sh_mbsnlen(src, srclen, maxlen)
-     const char *src;
-     size_t srclen;
-     int maxlen;
-{
-  int count;
-  int sind;
-  DECLARE_MBSTATE;
-
-  for (sind = count = 0; src[sind]; )
-    {
-      count++;		/* number of multibyte characters */
-      ADVANCE_CHAR (src, srclen, sind);
-      if (sind > maxlen)
-        break;
-    }
-
-  return count;
-}
-#endif
diff --git a/third_party/bash/shmbchar.h b/third_party/bash/shmbchar.h
deleted file mode 100644
index 27b0024fb..000000000
--- a/third_party/bash/shmbchar.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/* Multibyte character data type.
-   Copyright (C) 2001, 2005-2007, 2009-2010, 2021 Free Software Foundation, Inc.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* Written by Bruno Haible <bruno@clisp.org>.  */
-
-#ifndef _SHMBCHAR_H
-#define _SHMBCHAR_H 1
-
-#if defined (HANDLE_MULTIBYTE)
-
-#include <string.h>
-
-/* Tru64 with Desktop Toolkit C has a bug: <stdio.h> must be included before
-   <wchar.h>.
-   BSD/OS 4.1 has a bug: <stdio.h> and <time.h> must be included before
-   <wchar.h>.  */
-#include <stdio.h>
-#include <time.h>
-#include <wchar.h>
-#include <wctype.h>
-
-
-/* is_basic(c) tests whether the single-byte character c is in the
-   ISO C "basic character set". */
-
-#if (' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
-    && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
-    && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
-    && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
-    && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
-    && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
-    && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
-    && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
-    && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
-    && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
-    && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
-    && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
-    && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
-    && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
-    && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
-    && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
-    && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
-    && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
-    && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
-    && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
-    && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
-    && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
-    && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126)
-/* The character set is ISO-646, not EBCDIC. */
-# define IS_BASIC_ASCII 1
-
-extern const unsigned int is_basic_table[];
-
-static inline int
-is_basic (char c)
-{
-  return (is_basic_table [(unsigned char) c >> 5] >> ((unsigned char) c & 31))
-         & 1;
-}
-
-#else
-
-static inline int
-is_basic (char c)
-{
-  switch (c)
-    {
-    case '\b': case '\r': case '\n':
-    case '\t': case '\v': case '\f':
-    case ' ': case '!': case '"': case '#': case '%':
-    case '&': case '\'': case '(': case ')': case '*':
-    case '+': case ',': case '-': case '.': case '/':
-    case '0': case '1': case '2': case '3': case '4':
-    case '5': case '6': case '7': case '8': case '9':
-    case ':': case ';': case '<': case '=': case '>':
-    case '?':
-    case 'A': case 'B': case 'C': case 'D': case 'E':
-    case 'F': case 'G': case 'H': case 'I': case 'J':
-    case 'K': case 'L': case 'M': case 'N': case 'O':
-    case 'P': case 'Q': case 'R': case 'S': case 'T':
-    case 'U': case 'V': case 'W': case 'X': case 'Y':
-    case 'Z':
-    case '[': case '\\': case ']': case '^': case '_':
-    case 'a': case 'b': case 'c': case 'd': case 'e':
-    case 'f': case 'g': case 'h': case 'i': case 'j':
-    case 'k': case 'l': case 'm': case 'n': case 'o':
-    case 'p': case 'q': case 'r': case 's': case 't':
-    case 'u': case 'v': case 'w': case 'x': case 'y':
-    case 'z': case '{': case '|': case '}': case '~':
-      return 1;
-    default:
-      return 0;
-    }
-}
-
-#endif
-
-#endif /* HANDLE_MULTIBYTE */
-#endif /* _SHMBCHAR_H */
diff --git a/third_party/bash/shmbutil.h b/third_party/bash/shmbutil.h
deleted file mode 100644
index 68c457a2f..000000000
--- a/third_party/bash/shmbutil.h
+++ /dev/null
@@ -1,559 +0,0 @@
-/* shmbutil.h -- utility functions for multibyte characters. */
-
-/* Copyright (C) 2002-2019 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-                                 
-#if !defined (_SH_MBUTIL_H_)
-#define _SH_MBUTIL_H_
-
-#include "stdc.h"
-
-/* Include config.h for HANDLE_MULTIBYTE */
-#include "config.h"
-
-#if defined (HANDLE_MULTIBYTE)
-#include "shmbchar.h"
-
-extern size_t xwcsrtombs PARAMS((char *, const wchar_t **, size_t, mbstate_t *));
-extern size_t xmbsrtowcs PARAMS((wchar_t *, const char **, size_t, mbstate_t *));
-extern size_t xdupmbstowcs PARAMS((wchar_t **, char ***, const char *));
-
-extern size_t mbstrlen PARAMS((const char *));
-
-extern char *xstrchr PARAMS((const char *, int));
-
-extern int locale_mb_cur_max;	/* XXX */
-extern int locale_utf8locale;	/* XXX */
-
-#ifndef MB_INVALIDCH
-#define MB_INVALIDCH(x)		((x) == (size_t)-1 || (x) == (size_t)-2)
-#define MB_NULLWCH(x)		((x) == 0)
-#endif
-
-#define MBSLEN(s)	(((s) && (s)[0]) ? ((s)[1] ? mbstrlen (s) : 1) : 0)
-#define MB_STRLEN(s)	((MB_CUR_MAX > 1) ? MBSLEN (s) : STRLEN (s))
-
-#define MBLEN(s, n)	((MB_CUR_MAX > 1) ? mblen ((s), (n)) : 1)
-#define MBRLEN(s, n, p)	((MB_CUR_MAX > 1) ? mbrlen ((s), (n), (p)) : 1)
-
-#define UTF8_SINGLEBYTE(c)	(((c) & 0x80) == 0)
-#define UTF8_MBFIRSTCHAR(c)	(((c) & 0xc0) == 0xc0)
-#define UTF8_MBCHAR(c)		(((c) & 0xc0) == 0x80)
-
-#else /* !HANDLE_MULTIBYTE */
-
-#undef MB_LEN_MAX
-#undef MB_CUR_MAX
-
-#define MB_LEN_MAX	1
-#define MB_CUR_MAX	1
-
-#undef xstrchr
-#define xstrchr(s, c)	strchr(s, c)
-
-#ifndef MB_INVALIDCH
-#define MB_INVALIDCH(x)		(0)
-#define MB_NULLWCH(x)		(0)
-#endif
-
-#define MB_STRLEN(s)		(STRLEN(s))
-
-#define MBLEN(s, n)		1
-#define MBRLEN(s, n, p)		1
-
-#ifndef wchar_t
-#  define wchar_t	int
-#endif
-
-#define UTF8_SINGLEBYTE(c)	(1)
-#define UTF8_MBFIRSTCHAR(c)	(0)
-
-#endif /* !HANDLE_MULTIBYTE */
-
-/* Declare and initialize a multibyte state.  Call must be terminated
-   with `;'. */
-#if defined (HANDLE_MULTIBYTE)
-#  define DECLARE_MBSTATE \
-	mbstate_t state; \
-	memset (&state, '\0', sizeof (mbstate_t))
-#else
-#  define DECLARE_MBSTATE
-#endif  /* !HANDLE_MULTIBYTE */
-
-/* Initialize or reinitialize a multibyte state named `state'.  Call must be
-   terminated with `;'. */
-#if defined (HANDLE_MULTIBYTE)
-#  define INITIALIZE_MBSTATE memset (&state, '\0', sizeof (mbstate_t))
-#else
-#  define INITIALIZE_MBSTATE
-#endif  /* !HANDLE_MULTIBYTE */
-
-/* Advance one (possibly multi-byte) character in string _STR of length
-   _STRSIZE, starting at index _I.  STATE must have already been declared. */
-#if defined (HANDLE_MULTIBYTE)
-#  define ADVANCE_CHAR(_str, _strsize, _i) \
-    do \
-      { \
-	if (locale_mb_cur_max > 1) \
-	  { \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-	    int _f; \
-\
-	    _f = is_basic ((_str)[_i]); \
-	    if (_f) \
-	      mblength = 1; \
-	    else if (locale_utf8locale && (((_str)[_i] & 0x80) == 0)) \
-	      mblength = (_str)[_i] != 0; \
-	    else \
-	      { \
-	        state_bak = state; \
-	        mblength = mbrlen ((_str) + (_i), (_strsize) - (_i), &state); \
-	      } \
-\
-	    if (mblength == (size_t)-2 || mblength == (size_t)-1) \
-	      { \
-		state = state_bak; \
-		(_i)++; \
-	      } \
-	    else if (mblength == 0) \
-	      (_i)++; \
-	    else \
-	      (_i) += mblength; \
-	  } \
-	else \
-	  (_i)++; \
-      } \
-    while (0)
-#else
-#  define ADVANCE_CHAR(_str, _strsize, _i)	(_i)++
-#endif  /* !HANDLE_MULTIBYTE */
-
-/* Advance one (possibly multibyte) character in the string _STR of length
-   _STRSIZE.
-   SPECIAL:  assume that _STR will be incremented by 1 after this call. */
-#if defined (HANDLE_MULTIBYTE)
-#  define ADVANCE_CHAR_P(_str, _strsize) \
-    do \
-      { \
-	if (locale_mb_cur_max > 1) \
-	  { \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-	    int _f; \
-\
-	    _f = is_basic (*(_str)); \
-	    if (_f) \
-	      mblength = 1; \
-	    else if (locale_utf8locale && ((*(_str) & 0x80) == 0)) \
-	      mblength = *(_str) != 0; \
-	    else \
-	      { \
-		state_bak = state; \
-		mblength = mbrlen ((_str), (_strsize), &state); \
-	      } \
-\
-	    if (mblength == (size_t)-2 || mblength == (size_t)-1) \
-	      { \
-		state = state_bak; \
-		mblength = 1; \
-	      } \
-	    else \
-	      (_str) += (mblength < 1) ? 0 : (mblength - 1); \
-	  } \
-      } \
-    while (0)
-#else
-#  define ADVANCE_CHAR_P(_str, _strsize)
-#endif  /* !HANDLE_MULTIBYTE */
-
-/* Back up one (possibly multi-byte) character in string _STR of length
-   _STRSIZE, starting at index _I.  STATE must have already been declared. */
-#if defined (HANDLE_MULTIBYTE)
-#  define BACKUP_CHAR(_str, _strsize, _i) \
-    do \
-      { \
-	if (locale_mb_cur_max > 1) \
-	  { \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-	    int _x, _p; /* _x == temp index into string, _p == prev index */ \
-\
-	    _x = _p = 0; \
-	    while (_x < (_i)) \
-	      { \
-	        state_bak = state; \
-	        mblength = mbrlen ((_str) + (_x), (_strsize) - (_x), &state); \
-\
-		if (mblength == (size_t)-2 || mblength == (size_t)-1) \
-		  { \
-		    state = state_bak; \
-		    _x++; \
-		  } \
-		else if (mblength == 0) \
-		  _x++; \
-		else \
-		  { \
-		    _p = _x; /* _p == start of prev mbchar */ \
-		    _x += mblength; \
-		  } \
-	      } \
-	    (_i) = _p; \
-	  } \
-	else \
-	  (_i)--; \
-      } \
-    while (0)
-#else
-#  define BACKUP_CHAR(_str, _strsize, _i)	(_i)--
-#endif  /* !HANDLE_MULTIBYTE */
-
-/* Back up one (possibly multibyte) character in the string _BASE of length
-   _STRSIZE starting at _STR (_BASE <= _STR <= (_BASE + _STRSIZE) ).
-   SPECIAL: DO NOT assume that _STR will be decremented by 1 after this call. */
-#if defined (HANDLE_MULTIBYTE)
-#  define BACKUP_CHAR_P(_base, _strsize, _str) \
-    do \
-      { \
-	if (locale_mb_cur_max > 1) \
-	  { \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-	    char *_x, _p; /* _x == temp pointer into string, _p == prev pointer */ \
-\
-	    _x = _p = _base; \
-	    while (_x < (_str)) \
-	      { \
-	        state_bak = state; \
-	        mblength = mbrlen (_x, (_strsize) - _x, &state); \
-\
-		if (mblength == (size_t)-2 || mblength == (size_t)-1) \
-		  { \
-		    state = state_bak; \
-		    _x++; \
-		  } \
-		else if (mblength == 0) \
-		  _x++; \
-		else \
-		  { \
-		    _p = _x; /* _p == start of prev mbchar */ \
-		    _x += mblength; \
-		  } \
-	      } \
-	    (_str) = _p; \
-	  } \
-	else \
-	  (_str)--; \
-      } \
-    while (0)
-#else
-#  define BACKUP_CHAR_P(_base, _strsize, _str) (_str)--
-#endif  /* !HANDLE_MULTIBYTE */
-
-/* Copy a single character from the string _SRC to the string _DST.
-   _SRCEND is a pointer to the end of _SRC. */
-#if defined (HANDLE_MULTIBYTE)
-#  define COPY_CHAR_P(_dst, _src, _srcend) \
-    do \
-      { \
-	if (locale_mb_cur_max > 1) \
-	  { \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-	    int _k; \
-\
-	    _k = is_basic (*(_src)); \
-	    if (_k) \
-	      mblength = 1; \
-	    else if (locale_utf8locale && ((*(_src) & 0x80) == 0)) \
-	      mblength = *(_src) != 0; \
-	    else \
-	      { \
-		state_bak = state; \
-		mblength = mbrlen ((_src), (_srcend) - (_src), &state); \
-	      } \
-	    if (mblength == (size_t)-2 || mblength == (size_t)-1) \
-	      { \
-		state = state_bak; \
-		mblength = 1; \
-	      } \
-	    else \
-	      mblength = (mblength < 1) ? 1 : mblength; \
-\
-	    for (_k = 0; _k < mblength; _k++) \
-	      *(_dst)++ = *(_src)++; \
-	  } \
-	else \
-	  *(_dst)++ = *(_src)++; \
-      } \
-    while (0)
-#else
-#  define COPY_CHAR_P(_dst, _src, _srcend)	*(_dst)++ = *(_src)++
-#endif  /* !HANDLE_MULTIBYTE */
-
-/* Copy a single character from the string _SRC at index _SI to the string
-   _DST at index _DI.  _SRCEND is a pointer to the end of _SRC. */
-#if defined (HANDLE_MULTIBYTE)
-#  define COPY_CHAR_I(_dst, _di, _src, _srcend, _si) \
-    do \
-      { \
-	if (locale_mb_cur_max > 1) \
-	  { \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-	    int _k; \
-\
-	    _k = is_basic ((_src)[(_si)]); \
-	    if (_k) \
-	      mblength = 1; \
-	    else if (locale_utf8locale && ((_src)[(_si)] & 0x80) == 0) \
-	      mblength = (_src)[(_si)] != 0; \
-	    else \
-	      {\
-		state_bak = state; \
-		mblength = mbrlen ((_src) + (_si), (_srcend) - ((_src)+(_si)), &state); \
-	      } \
-	    if (mblength == (size_t)-2 || mblength == (size_t)-1) \
-	      { \
-		state = state_bak; \
-		mblength = 1; \
-	      } \
-	    else \
-	      mblength = (mblength < 1) ? 1 : mblength; \
-\
-	    for (_k = 0; _k < mblength; _k++) \
-	      _dst[_di++] = _src[_si++]; \
-	  } \
-	else \
-	  _dst[_di++] = _src[_si++]; \
-      } \
-    while (0)
-#else
-#  define COPY_CHAR_I(_dst, _di, _src, _srcend, _si)	_dst[_di++] = _src[_si++]
-#endif  /* !HANDLE_MULTIBYTE */
-
-/****************************************************************
- *								*
- * The following are only guaranteed to work in subst.c		*
- *								*
- ****************************************************************/
-
-#if defined (HANDLE_MULTIBYTE)
-#  define SCOPY_CHAR_I(_dst, _escchar, _sc, _src, _si, _slen) \
-    do \
-      { \
-	if (locale_mb_cur_max > 1) \
-	  { \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-	    int _i; \
-\
-	    _i = is_basic ((_src)[(_si)]); \
-	    if (_i) \
-	      mblength = 1; \
-	    else if (locale_utf8locale && ((_src)[(_si)] & 0x80) == 0) \
-	      mblength = (_src)[(_si)] != 0; \
-	    else \
-	      { \
-		state_bak = state; \
-		mblength = mbrlen ((_src) + (_si), (_slen) - (_si), &state); \
-	      } \
-	    if (mblength == (size_t)-2 || mblength == (size_t)-1) \
-	      { \
-		state = state_bak; \
-		mblength = 1; \
-	      } \
-	    else \
-	      mblength = (mblength < 1) ? 1 : mblength; \
-\
-	    temp = xmalloc (mblength + 2); \
-	    temp[0] = _escchar; \
-	    for (_i = 0; _i < mblength; _i++) \
-	      temp[_i + 1] = _src[_si++]; \
-	    temp[mblength + 1] = '\0'; \
-\
-	    goto add_string; \
-	  } \
-	else \
-	  { \
-	    _dst[0] = _escchar; \
-	    _dst[1] = _sc; \
-	  } \
-      } \
-    while (0)
-#else
-#  define SCOPY_CHAR_I(_dst, _escchar, _sc, _src, _si, _slen) \
-    _dst[0] = _escchar; \
-    _dst[1] = _sc
-#endif  /* !HANDLE_MULTIBYTE */
-
-#if defined (HANDLE_MULTIBYTE)
-#  define SCOPY_CHAR_M(_dst, _src, _srcend, _si) \
-    do \
-      { \
-	if (locale_mb_cur_max > 1) \
-	  { \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-	    int _i; \
-\
-	    _i = is_basic (*((_src) + (_si))); \
-	    if (_i) \
-	      mblength = 1; \
-	    else if (locale_utf8locale && (((_src)[_si] & 0x80) == 0)) \
-              mblength = (_src)[_si] != 0; \
-	    else \
-	      { \
-		state_bak = state; \
-		mblength = mbrlen ((_src) + (_si), (_srcend) - ((_src) + (_si)), &state); \
-	      } \
-	    if (mblength == (size_t)-2 || mblength == (size_t)-1) \
-	      { \
-		state = state_bak; \
-		mblength = 1; \
-	      } \
-	    else \
-	      mblength = (mblength < 1) ? 1 : mblength; \
-\
-	    FASTCOPY(((_src) + (_si)), (_dst), mblength); \
-\
-	    (_dst) += mblength; \
-	    (_si) += mblength; \
-	  } \
-	else \
-	  { \
-	    *(_dst)++ = _src[(_si)]; \
-	    (_si)++; \
-	  } \
-      } \
-    while (0)
-#else
-#  define SCOPY_CHAR_M(_dst, _src, _srcend, _si) \
-	*(_dst)++ = _src[(_si)]; \
-	(_si)++
-#endif  /* !HANDLE_MULTIBYTE */
-
-#if HANDLE_MULTIBYTE
-#  define SADD_MBCHAR(_dst, _src, _si, _srcsize) \
-    do \
-      { \
-	if (locale_mb_cur_max > 1) \
-	  { \
-	    int i; \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-\
-	    i = is_basic (*((_src) + (_si))); \
-	    if (i) \
-	      mblength = 1; \
-	    else if (locale_utf8locale && (((_src)[_si] & 0x80) == 0)) \
-	      mblength = (_src)[_si] != 0; \
-	    else \
-	      { \
-		state_bak = state; \
-		mblength = mbrlen ((_src) + (_si), (_srcsize) - (_si), &state); \
-	      } \
-	    if (mblength == (size_t)-1 || mblength == (size_t)-2) \
-	      { \
-		state = state_bak; \
-		mblength = 1; \
-	      } \
-	    if (mblength < 1) \
-	      mblength = 1; \
-\
-	    _dst = (char *)xmalloc (mblength + 1); \
-	    for (i = 0; i < mblength; i++) \
-	      (_dst)[i] = (_src)[(_si)++]; \
-	    (_dst)[mblength] = '\0'; \
-\
-	    goto add_string; \
-	  } \
-      } \
-    while (0)
-
-#else
-#  define SADD_MBCHAR(_dst, _src, _si, _srcsize)
-#endif
-
-/* Watch out when using this -- it's just straight textual substitution */
-#if defined (HANDLE_MULTIBYTE)
-#  define SADD_MBQCHAR_BODY(_dst, _src, _si, _srcsize) \
-\
-	    int i; \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-\
-	    i = is_basic (*((_src) + (_si))); \
-	    if (i) \
-	      mblength = 1; \
-	    else if (locale_utf8locale && (((_src)[_si] & 0x80) == 0)) \
-	      mblength = (_src)[_si] != 0; \
-	    else \
-	      { \
-		state_bak = state; \
-		mblength = mbrlen ((_src) + (_si), (_srcsize) - (_si), &state); \
-	      } \
-	    if (mblength == (size_t)-1 || mblength == (size_t)-2) \
-	      { \
-		state = state_bak; \
-		mblength = 1; \
-	      } \
-	    if (mblength < 1) \
-	      mblength = 1; \
-\
-	    (_dst) = (char *)xmalloc (mblength + 2); \
-	    (_dst)[0] = CTLESC; \
-	    for (i = 0; i < mblength; i++) \
-	      (_dst)[i+1] = (_src)[(_si)++]; \
-	    (_dst)[mblength+1] = '\0'; \
-\
-	    goto add_string
-
-#  define SADD_MBCHAR_BODY(_dst, _src, _si, _srcsize) \
-\
-	    int i; \
-	    mbstate_t state_bak; \
-	    size_t mblength; \
-\
-	    i = is_basic (*((_src) + (_si))); \
-	    if (i) \
-	      mblength = 1; \
-	    else if (locale_utf8locale && (((_src)[_si] & 0x80) == 0)) \
-              mblength = (_src)[_si] != 0; \
-            else \
-	      { \
-		state_bak = state; \
-		mblength = mbrlen ((_src) + (_si), (_srcsize) - (_si), &state); \
-	      } \
-	    if (mblength == (size_t)-1 || mblength == (size_t)-2) \
-	      { \
-		state = state_bak; \
-		mblength = 1; \
-	      } \
-	    if (mblength < 1) \
-	      mblength = 1; \
-\
-	    (_dst) = (char *)xmalloc (mblength + 1); \
-	    for (i = 0; i < mblength; i++) \
-	      (_dst)[i+1] = (_src)[(_si)++]; \
-	    (_dst)[mblength+1] = '\0'; \
-\
-	    goto add_string
-
-#endif /* HANDLE_MULTIBYTE */
-#endif /* _SH_MBUTIL_H_ */
diff --git a/third_party/bash/shquote.c b/third_party/bash/shquote.c
deleted file mode 100644
index 59436c65f..000000000
--- a/third_party/bash/shquote.c
+++ /dev/null
@@ -1,432 +0,0 @@
-/* shquote - functions to quote and dequote strings */
-
-/* Copyright (C) 1999-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "stdc.h"
-
-#include "syntax.h"
-#include "xmalloc.h"
-
-#include "shmbchar.h"
-#include "shmbutil.h"
-
-extern char *ansic_quote PARAMS((char *, int, int *));
-extern int ansic_shouldquote PARAMS((const char *));
-
-/* Default set of characters that should be backslash-quoted in strings */
-static const char bstab[256] =
-  {
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 1, 1, 0, 0, 0, 0, 0,	/* TAB, NL */
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-
-    1, 1, 1, 0, 1, 0, 1, 1,	/* SPACE, !, DQUOTE, DOL, AMP, SQUOTE */
-    1, 1, 1, 0, 1, 0, 0, 0,	/* LPAR, RPAR, STAR, COMMA */
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 1, 1, 0, 1, 1,	/* SEMI, LESSTHAN, GREATERTHAN, QUEST */
-
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 1, 1, 1, 1, 0,	/* LBRACK, BS, RBRACK, CARAT */
-
-    1, 0, 0, 0, 0, 0, 0, 0,	/* BACKQ */
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 1, 1, 1, 0, 0,	/* LBRACE, BAR, RBRACE */
-
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0,
-  };
-
-/* **************************************************************** */
-/*								    */
-/*	 Functions for quoting strings to be re-read as input	    */
-/*								    */
-/* **************************************************************** */
-
-/* Return a new string which is the single-quoted version of STRING.
-   Used by alias and trap, among others. */
-char *
-sh_single_quote (string)
-     const char *string;
-{
-  register int c;
-  char *result, *r;
-  const char *s;
-
-  result = (char *)xmalloc (3 + (4 * strlen (string)));
-  r = result;
-
-  if (string[0] == '\'' && string[1] == 0)
-    {
-      *r++ = '\\';
-      *r++ = '\'';
-      *r++ = 0;
-      return result;
-    }
-
-  *r++ = '\'';
-
-  for (s = string; s && (c = *s); s++)
-    {
-      *r++ = c;
-
-      if (c == '\'')
-	{
-	  *r++ = '\\';	/* insert escaped single quote */
-	  *r++ = '\'';
-	  *r++ = '\'';	/* start new quoted string */
-	}
-    }
-
-  *r++ = '\'';
-  *r = '\0';
-
-  return (result);
-}
-
-/* Quote STRING using double quotes.  Return a new string. */
-char *
-sh_double_quote (string)
-     const char *string;
-{
-  register unsigned char c;
-  int mb_cur_max;
-  char *result, *r;
-  size_t slen;
-  const char *s, *send;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  send = string + slen;
-  mb_cur_max = MB_CUR_MAX;
-
-  result = (char *)xmalloc (3 + (2 * strlen (string)));
-  r = result;
-  *r++ = '"';
-
-  for (s = string; s && (c = *s); s++)
-    {
-      /* Backslash-newline disappears within double quotes, so don't add one. */
-      if ((sh_syntaxtab[c] & CBSDQUOTE) && c != '\n')
-	*r++ = '\\';
-
-#if defined (HANDLE_MULTIBYTE)
-      if ((locale_utf8locale && (c & 0x80)) ||
-	  (locale_utf8locale == 0 && mb_cur_max > 1 && is_basic (c) == 0))
-	{
-	  COPY_CHAR_P (r, s, send);
-	  s--;		/* compensate for auto-increment in loop above */
-	  continue;
-	}
-#endif
-
-      /* Assume that the string will not be further expanded, so no need to
-	 add CTLESC to protect CTLESC or CTLNUL. */
-      *r++ = c;
-    }
-
-  *r++ = '"';
-  *r = '\0';
-
-  return (result);
-}
-
-/* Turn S into a simple double-quoted string.  If FLAGS is non-zero, quote
-   double quote characters in S with backslashes. */
-char *
-sh_mkdoublequoted (s, slen, flags)
-     const char *s;
-     int slen, flags;
-{
-  char *r, *ret;
-  const char *send;
-  int rlen, mb_cur_max;
-  DECLARE_MBSTATE;
-
-  send = s + slen;
-  mb_cur_max = flags ? MB_CUR_MAX : 1;
-  rlen = (flags == 0) ? slen + 3 : (2 * slen) + 1;
-  ret = r = (char *)xmalloc (rlen);
-
-  *r++ = '"';
-  while (*s)
-    {
-      if (flags && *s == '"')
-	*r++ = '\\';
-
-#if defined (HANDLE_MULTIBYTE)
-      if  (flags && ((locale_utf8locale && (*s & 0x80)) ||
-		     (locale_utf8locale == 0 && mb_cur_max > 1 && is_basic (*s) == 0)))
-	{
-	  COPY_CHAR_P (r, s, send);
-	  continue;
-	}
-#endif
-      *r++ = *s++;
-    }
-  *r++ = '"';
-  *r = '\0';
-
-  return ret;
-}
-
-/* Remove backslashes that are quoting characters that are special between
-   double quotes.  Return a new string.  XXX - should this handle CTLESC
-   and CTLNUL? */
-char *
-sh_un_double_quote (string)
-     char *string;
-{
-  register int c, pass_next;
-  char *result, *r, *s;
-
-  r = result = (char *)xmalloc (strlen (string) + 1);
-
-  for (pass_next = 0, s = string; s && (c = *s); s++)
-    {
-      if (pass_next)
-	{
-	  *r++ = c;
-	  pass_next = 0;
-	  continue;
-	}
-      if (c == '\\' && (sh_syntaxtab[(unsigned char) s[1]] & CBSDQUOTE))
-	{
-	  pass_next = 1;
-	  continue;
-	}
-      *r++ = c;
-    }
-
-  *r = '\0';
-  return result;
-}
-
-/* Quote special characters in STRING using backslashes.  Return a new
-   string.  NOTE:  if the string is to be further expanded, we need a
-   way to protect the CTLESC and CTLNUL characters.  As I write this,
-   the current callers will never cause the string to be expanded without
-   going through the shell parser, which will protect the internal
-   quoting characters.  TABLE, if set, points to a map of the ascii code
-   set with char needing to be backslash-quoted if table[char]==1.  FLAGS,
-   if 1, causes tildes to be quoted as well.  If FLAGS&2, backslash-quote
-   other shell blank characters. */
-   
-char *
-sh_backslash_quote (string, table, flags)
-     char *string;
-     char *table;
-     int flags;
-{
-  int c, mb_cur_max;
-  size_t slen;
-  char *result, *r, *s, *backslash_table, *send;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  send = string + slen;
-  result = (char *)xmalloc (2 * slen + 1);
-
-  backslash_table = table ? table : (char *)bstab;
-  mb_cur_max = MB_CUR_MAX;
-
-  for (r = result, s = string; s && (c = *s); s++)
-    {
-#if defined (HANDLE_MULTIBYTE)
-      /* XXX - isascii, even if is_basic(c) == 0 - works in most cases. */
-      if (c >= 0 && c <= 127 && backslash_table[(unsigned char)c] == 1)
-	{
-	  *r++ = '\\';
-	  *r++ = c;
-	  continue;
-	}
-      if ((locale_utf8locale && (c & 0x80)) ||
-	  (locale_utf8locale == 0 && mb_cur_max > 1 && is_basic (c) == 0))
-	{
-	  COPY_CHAR_P (r, s, send);
-	  s--;		/* compensate for auto-increment in loop above */
-	  continue;
-	}
-#endif
-      if (backslash_table[(unsigned char)c] == 1)
-	*r++ = '\\';
-      else if (c == '#' && s == string)			/* comment char */
-	*r++ = '\\';
-      else if ((flags&1) && c == '~' && (s == string || s[-1] == ':' || s[-1] == '='))
-        /* Tildes are special at the start of a word or after a `:' or `='
-	   (technically unquoted, but it doesn't make a difference in practice) */
-	*r++ = '\\';
-      else if ((flags&2) && shellblank((unsigned char)c))
-	*r++ = '\\';
-      *r++ = c;
-    }
-
-  *r = '\0';
-  return (result);
-}
-
-#if defined (PROMPT_STRING_DECODE) || defined (TRANSLATABLE_STRINGS)
-/* Quote characters that get special treatment when in double quotes in STRING
-   using backslashes. FLAGS is reserved for future use. Return a new string. */
-char *
-sh_backslash_quote_for_double_quotes (string, flags)
-     char *string;
-     int flags;
-{
-  unsigned char c;
-  char *result, *r, *s, *send;
-  size_t slen;
-  int mb_cur_max;
-  DECLARE_MBSTATE;
- 
-  slen = strlen (string);
-  send = string + slen;
-  mb_cur_max = MB_CUR_MAX;
-  result = (char *)xmalloc (2 * slen + 1);
-
-  for (r = result, s = string; s && (c = *s); s++)
-    {
-      /* Backslash-newline disappears within double quotes, so don't add one. */
-      if ((sh_syntaxtab[c] & CBSDQUOTE) && c != '\n')
-	*r++ = '\\';
-      /* I should probably use the CSPECL flag for these in sh_syntaxtab[] */
-      else if (c == CTLESC || c == CTLNUL)
-	*r++ = CTLESC;		/* could be '\\'? */
-
-#if defined (HANDLE_MULTIBYTE)
-      if ((locale_utf8locale && (c & 0x80)) ||
-	  (locale_utf8locale == 0 && mb_cur_max > 1 && is_basic (c) == 0))
-	{
-	  COPY_CHAR_P (r, s, send);
-	  s--;		/* compensate for auto-increment in loop above */
-	  continue;
-	}
-#endif
-
-      *r++ = c;
-    }
-
-  *r = '\0';
-  return (result);
-}
-#endif /* PROMPT_STRING_DECODE */
-
-char *
-sh_quote_reusable (s, flags)
-     char *s;
-     int flags;
-{
-  char *ret;
-
-  if (s == 0)
-    return s;
-  else if (*s == 0)
-    {
-      ret = (char *)xmalloc (3);
-      ret[0] = ret[1] = '\'';
-      ret[2] = '\0';
-    }
-  else if (ansic_shouldquote (s))
-    ret = ansic_quote (s, 0, (int *)0);
-  else if (flags)
-    ret = sh_backslash_quote (s, 0, 1);
-  else
-    ret = sh_single_quote (s);
-
-  return ret;
-}
-
-int
-sh_contains_shell_metas (string)
-     const char *string;
-{
-  const char *s;
-
-  for (s = string; s && *s; s++)
-    {
-      switch (*s)
-	{
-	case ' ': case '\t': case '\n':		/* IFS white space */
-	case '\'': case '"': case '\\':		/* quoting chars */
-	case '|': case '&': case ';':		/* shell metacharacters */
-	case '(': case ')': case '<': case '>':
-	case '!': case '{': case '}':		/* reserved words */
-	case '*': case '[': case '?': case ']':	/* globbing chars */
-	case '^':
-	case '$': case '`':			/* expansion chars */
-	  return (1);
-	case '~':				/* tilde expansion */
-	  if (s == string || s[-1] == '=' || s[-1] == ':')
-	    return (1);
-	  break;
-	case '#':
-	  if (s == string)			/* comment char */
-	    return (1);
-	  /* FALLTHROUGH */
-	default:
-	  break;
-	}
-    }
-
-  return (0);
-}
-
-int
-sh_contains_quotes (string)
-     const char *string;
-{
-  const char *s;
-
-  for (s = string; s && *s; s++)
-    {
-      if (*s == '\'' || *s == '"' || *s == '\\')
-	return 1;
-    }
-  return 0;
-}
diff --git a/third_party/bash/shtty.c b/third_party/bash/shtty.c
deleted file mode 100644
index 461e574d4..000000000
--- a/third_party/bash/shtty.c
+++ /dev/null
@@ -1,330 +0,0 @@
-/*
- * shtty.c -- abstract interface to the terminal, focusing on capabilities.
- */
-
-/* Copyright (C) 1999 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifdef HAVE_CONFIG_H
-#  include "config.h"
-#endif
-
-#ifdef HAVE_UNISTD_H
-#  include <unistd.h>
-#endif
-
-#include "shtty.h"
-
-static TTYSTRUCT ttin, ttout;
-static int ttsaved = 0;
-
-int
-ttgetattr(fd, ttp)
-int	fd;
-TTYSTRUCT *ttp;
-{
-#ifdef TERMIOS_TTY_DRIVER
-  return tcgetattr(fd, ttp);
-#else
-#  ifdef TERMIO_TTY_DRIVER
-  return ioctl(fd, TCGETA, ttp);
-#  else
-  return ioctl(fd, TIOCGETP, ttp);
-#  endif
-#endif
-}
-
-int
-ttsetattr(fd, ttp)
-int	fd;
-TTYSTRUCT *ttp;
-{
-#ifdef TERMIOS_TTY_DRIVER
-  return tcsetattr(fd, TCSADRAIN, ttp);
-#else
-#  ifdef TERMIO_TTY_DRIVER
-  return ioctl(fd, TCSETAW, ttp);
-#  else
-  return ioctl(fd, TIOCSETN, ttp);
-#  endif
-#endif
-}
-
-void
-ttsave()
-{
-  if (ttsaved)
-   return;
-  ttgetattr (0, &ttin);
-  ttgetattr (1, &ttout);
-  ttsaved = 1;
-}
-
-void
-ttrestore()
-{
-  if (ttsaved == 0)
-    return;
-  ttsetattr (0, &ttin);
-  ttsetattr (1, &ttout);
-  ttsaved = 0;
-}
-
-/* Retrieve the internally-saved attributes associated with tty fd FD. */
-TTYSTRUCT *
-ttattr (fd)
-     int fd;
-{
-  if (ttsaved == 0)
-    return ((TTYSTRUCT *)0);
-  if (fd == 0)
-    return &ttin;
-  else if (fd == 1)
-    return &ttout;
-  else
-    return ((TTYSTRUCT *)0);
-}
-
-/*
- * Change attributes in ttp so that when it is installed using
- * ttsetattr, the terminal will be in one-char-at-a-time mode.
- */
-int
-tt_setonechar(ttp)
-     TTYSTRUCT *ttp;
-{
-#if defined (TERMIOS_TTY_DRIVER) || defined (TERMIO_TTY_DRIVER)
-
-  /* XXX - might not want this -- it disables erase and kill processing. */
-  ttp->c_lflag &= ~ICANON;
-
-  ttp->c_lflag |= ISIG;
-#  ifdef IEXTEN
-  ttp->c_lflag |= IEXTEN;
-#  endif
-
-  ttp->c_iflag |= ICRNL;	/* make sure we get CR->NL on input */
-  ttp->c_iflag &= ~INLCR;	/* but no NL->CR */
-
-#  ifdef OPOST
-  ttp->c_oflag |= OPOST;
-#  endif
-#  ifdef ONLCR
-  ttp->c_oflag |= ONLCR;
-#  endif
-#  ifdef OCRNL
-  ttp->c_oflag &= ~OCRNL;
-#  endif
-#  ifdef ONOCR
-  ttp->c_oflag &= ~ONOCR;
-#  endif
-#  ifdef ONLRET
-  ttp->c_oflag &= ~ONLRET;
-#  endif
-
-  ttp->c_cc[VMIN] = 1;
-  ttp->c_cc[VTIME] = 0;
-
-#else
-
-  ttp->sg_flags |= CBREAK;
-
-#endif
-
-  return 0;
-}
-
-/* Set the tty associated with FD and TTP into one-character-at-a-time mode */
-int
-ttfd_onechar (fd, ttp)
-     int fd;
-     TTYSTRUCT *ttp;
-{
-  if (tt_setonechar(ttp) < 0)
-    return -1;
-  return (ttsetattr (fd, ttp));
-}
-
-/* Set the terminal into one-character-at-a-time mode */
-int
-ttonechar ()
-{
-  TTYSTRUCT tt;
-
-  if (ttsaved == 0)
-    return -1;
-  tt = ttin;
-  return (ttfd_onechar (0, &tt));
-}
-
-/*
- * Change attributes in ttp so that when it is installed using
- * ttsetattr, the terminal will be in no-echo mode.
- */
-int
-tt_setnoecho(ttp)
-     TTYSTRUCT *ttp;
-{
-#if defined (TERMIOS_TTY_DRIVER) || defined (TERMIO_TTY_DRIVER)
-  ttp->c_lflag &= ~(ECHO|ECHOK|ECHONL);
-#else
-  ttp->sg_flags &= ~ECHO;
-#endif
-
-  return 0;
-}
-
-/* Set the tty associated with FD and TTP into no-echo mode */
-int
-ttfd_noecho (fd, ttp)
-     int fd;
-     TTYSTRUCT *ttp;
-{
-  if (tt_setnoecho (ttp) < 0)
-    return -1;
-  return (ttsetattr (fd, ttp));
-}
-
-/* Set the terminal into no-echo mode */
-int
-ttnoecho ()
-{
-  TTYSTRUCT tt;
-
-  if (ttsaved == 0)
-    return -1;
-  tt = ttin;
-  return (ttfd_noecho (0, &tt));
-}
-
-/*
- * Change attributes in ttp so that when it is installed using
- * ttsetattr, the terminal will be in eight-bit mode (pass8).
- */
-int
-tt_seteightbit (ttp)
-     TTYSTRUCT *ttp;
-{
-#if defined (TERMIOS_TTY_DRIVER) || defined (TERMIO_TTY_DRIVER)
-  ttp->c_iflag &= ~ISTRIP;
-  ttp->c_cflag |= CS8;
-  ttp->c_cflag &= ~PARENB;
-#else
-  ttp->sg_flags |= ANYP;
-#endif
-
-  return 0;
-}
-
-/* Set the tty associated with FD and TTP into eight-bit mode */
-int
-ttfd_eightbit (fd, ttp)
-     int fd;
-     TTYSTRUCT *ttp;
-{
-  if (tt_seteightbit (ttp) < 0)
-    return -1;
-  return (ttsetattr (fd, ttp));
-}
-
-/* Set the terminal into eight-bit mode */
-int
-tteightbit ()
-{
-  TTYSTRUCT tt;
-
-  if (ttsaved == 0)
-    return -1;
-  tt = ttin;
-  return (ttfd_eightbit (0, &tt));
-}
-
-/*
- * Change attributes in ttp so that when it is installed using
- * ttsetattr, the terminal will be in non-canonical input mode.
- */
-int
-tt_setnocanon (ttp)
-     TTYSTRUCT *ttp;
-{
-#if defined (TERMIOS_TTY_DRIVER) || defined (TERMIO_TTY_DRIVER)
-  ttp->c_lflag &= ~ICANON;
-#endif
-
-  return 0;
-}
-
-/* Set the tty associated with FD and TTP into non-canonical mode */
-int
-ttfd_nocanon (fd, ttp)
-     int fd;
-     TTYSTRUCT *ttp;
-{
-  if (tt_setnocanon (ttp) < 0)
-    return -1;
-  return (ttsetattr (fd, ttp));
-}
-
-/* Set the terminal into non-canonical mode */
-int
-ttnocanon ()
-{
-  TTYSTRUCT tt;
-
-  if (ttsaved == 0)
-    return -1;
-  tt = ttin;
-  return (ttfd_nocanon (0, &tt));
-}
-
-/*
- * Change attributes in ttp so that when it is installed using
- * ttsetattr, the terminal will be in cbreak, no-echo mode.
- */
-int
-tt_setcbreak(ttp)
-     TTYSTRUCT *ttp;
-{
-  if (tt_setonechar (ttp) < 0)
-    return -1;
-  return (tt_setnoecho (ttp));
-}
-
-/* Set the tty associated with FD and TTP into cbreak (no-echo,
-   one-character-at-a-time) mode */
-int
-ttfd_cbreak (fd, ttp)
-     int fd;
-     TTYSTRUCT *ttp;
-{
-  if (tt_setcbreak (ttp) < 0)
-    return -1;
-  return (ttsetattr (fd, ttp));
-}
-
-/* Set the terminal into cbreak (no-echo, one-character-at-a-time) mode */
-int
-ttcbreak ()
-{
-  TTYSTRUCT tt;
-
-  if (ttsaved == 0)
-    return -1;
-  tt = ttin;
-  return (ttfd_cbreak (0, &tt));
-}
diff --git a/third_party/bash/shtty.h b/third_party/bash/shtty.h
deleted file mode 100644
index fdf379b89..000000000
--- a/third_party/bash/shtty.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/* Copyright (C) 1999-2020 Free Software Foundation, Inc. */
-
-/* This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/*
- * shtty.h -- include the correct system-dependent files to manipulate the
- *	      tty
- */
-
-#ifndef __SH_TTY_H_
-#define __SH_TTY_H_
-
-#include "stdc.h"
-
-#if defined (_POSIX_VERSION) && defined (HAVE_TERMIOS_H) && defined (HAVE_TCGETATTR) && !defined (TERMIOS_MISSING)
-#  define TERMIOS_TTY_DRIVER
-#else
-#  if defined (HAVE_TERMIO_H)
-#    define TERMIO_TTY_DRIVER
-#  else
-#    define NEW_TTY_DRIVER
-#  endif
-#endif
-
-/*
- * The _POSIX_SOURCE define is to avoid multiple symbol definitions
- * between sys/ioctl.h and termios.h.  Ditto for the test against SunOS4
- * and the undefining of several symbols.
- */
-      
-#ifdef TERMIOS_TTY_DRIVER
-#  if (defined (SunOS4) || defined (SunOS5)) && !defined (_POSIX_SOURCE)
-#    define _POSIX_SOURCE
-#  endif
-#  if defined (SunOS4)
-#    undef ECHO
-#    undef NOFLSH
-#    undef TOSTOP
-#  endif /* SunOS4 */
-#  include <termios.h>
-#  define TTYSTRUCT struct termios
-#else
-#  ifdef TERMIO_TTY_DRIVER
-#    include <termio.h>
-#    define TTYSTRUCT struct termio
-#  else	/* NEW_TTY_DRIVER */
-#    include <sgtty.h>
-#    define TTYSTRUCT struct sgttyb
-#  endif
-#endif
-
-/* Functions imported from lib/sh/shtty.c */
-
-/* Get and set terminal attributes for the file descriptor passed as
-   an argument. */
-extern int ttgetattr PARAMS((int, TTYSTRUCT *));
-extern int ttsetattr PARAMS((int, TTYSTRUCT *));
-
-/* Save and restore the terminal's attributes from static storage. */
-extern void ttsave PARAMS((void));
-extern void ttrestore PARAMS((void));
-
-/* Return the attributes corresponding to the file descriptor (0 or 1)
-   passed as an argument. */
-extern TTYSTRUCT *ttattr PARAMS((int));
-
-/* These functions only operate on the passed TTYSTRUCT; they don't
-   actually change anything with the kernel's current tty settings. */
-extern int tt_setonechar PARAMS((TTYSTRUCT *));
-extern int tt_setnoecho PARAMS((TTYSTRUCT *));
-extern int tt_seteightbit PARAMS((TTYSTRUCT *));
-extern int tt_setnocanon PARAMS((TTYSTRUCT *));
-extern int tt_setcbreak PARAMS((TTYSTRUCT *));
-
-/* These functions are all generally mutually exclusive.  If you call
-   more than one (bracketed with calls to ttsave and ttrestore, of
-   course), the right thing will happen, but more system calls will be
-   executed than absolutely necessary.  You can do all of this yourself
-   with the other functions; these are only conveniences. */
-
-/* These functions work with a given file descriptor and set terminal
-   attributes */
-extern int ttfd_onechar PARAMS((int, TTYSTRUCT *));
-extern int ttfd_noecho PARAMS((int, TTYSTRUCT *));
-extern int ttfd_eightbit PARAMS((int, TTYSTRUCT *));
-extern int ttfd_nocanon PARAMS((int, TTYSTRUCT *));
-
-extern int ttfd_cbreak PARAMS((int, TTYSTRUCT *));
-
-/* These functions work with fd 0 and the TTYSTRUCT saved with ttsave () */
-extern int ttonechar PARAMS((void));
-extern int ttnoecho PARAMS((void));
-extern int tteightbit PARAMS((void));
-extern int ttnocanon PARAMS((void));
-
-extern int ttcbreak PARAMS((void));
-
-#endif
diff --git a/third_party/bash/sig.c b/third_party/bash/sig.c
deleted file mode 100644
index 6c0615d73..000000000
--- a/third_party/bash/sig.c
+++ /dev/null
@@ -1,817 +0,0 @@
-/* sig.c - interface for shell signal handlers and signal initialization. */
-
-/* Copyright (C) 1994-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include <signal.h>
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#if defined (JOB_CONTROL)
-#include "jobs.h"
-#endif /* JOB_CONTROL */
-#include "siglist.h"
-#include "sig.h"
-#include "trap.h"
-
-#include "common.h"
-#include "builtext.h"
-
-#if defined (READLINE)
-#  include "bashline.h"
-#  include "third_party/readline/readline.h"
-#endif
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#endif
-
-extern void initialize_siglist PARAMS((void));
-extern void set_original_signal PARAMS((int, SigHandler *));
-
-#if !defined (JOB_CONTROL)
-extern void initialize_job_signals PARAMS((void));
-#endif
-
-/* Non-zero after SIGINT. */
-volatile sig_atomic_t interrupt_state = 0;
-
-/* Non-zero after SIGWINCH */
-volatile sig_atomic_t sigwinch_received = 0;
-
-/* Non-zero after SIGTERM */
-volatile sig_atomic_t sigterm_received = 0;
-
-/* Set to the value of any terminating signal received. */
-volatile sig_atomic_t terminating_signal = 0;
-
-/* The environment at the top-level R-E loop.  We use this in
-   the case of error return. */
-procenv_t top_level;
-
-#if defined (JOB_CONTROL) || defined (HAVE_POSIX_SIGNALS)
-/* The signal masks that this shell runs with. */
-sigset_t top_level_mask;
-#endif /* JOB_CONTROL */
-
-/* When non-zero, we throw_to_top_level (). */
-int interrupt_immediately = 0;
-
-/* When non-zero, we call the terminating signal handler immediately. */
-int terminate_immediately = 0;
-
-#if defined (SIGWINCH)
-static SigHandler *old_winch = (SigHandler *)SIG_DFL;
-#endif
-
-static void initialize_shell_signals PARAMS((void));
-
-void
-initialize_signals (reinit)
-     int reinit;
-{
-  initialize_shell_signals ();
-  initialize_job_signals ();
-#if !defined (HAVE_SYS_SIGLIST) && !defined (HAVE_UNDER_SYS_SIGLIST) && !defined (HAVE_STRSIGNAL)
-  if (reinit == 0)
-    initialize_siglist ();
-#endif /* !HAVE_SYS_SIGLIST && !HAVE_UNDER_SYS_SIGLIST && !HAVE_STRSIGNAL */
-}
-
-/* A structure describing a signal that terminates the shell if not
-   caught.  The orig_handler member is present so children can reset
-   these signals back to their original handlers. */
-struct termsig {
-     int signum;
-     SigHandler *orig_handler;
-     int orig_flags;
-     int core_dump;
-};
-
-#define NULL_HANDLER (SigHandler *)SIG_DFL
-
-/* The list of signals that would terminate the shell if not caught.
-   We catch them, but just so that we can write the history file,
-   and so forth. */
-static struct termsig terminating_signals[] = {
-#ifdef SIGHUP
-{  SIGHUP, NULL_HANDLER, 0 },
-#endif
-
-#ifdef SIGINT
-{  SIGINT, NULL_HANDLER, 0 },
-#endif
-
-#ifdef SIGILL
-{  SIGILL, NULL_HANDLER, 0, 1},
-#endif
-
-#ifdef SIGTRAP
-{  SIGTRAP, NULL_HANDLER, 0, 1 },
-#endif
-
-#ifdef SIGIOT
-{  SIGIOT, NULL_HANDLER, 0, 1 },
-#endif
-
-#ifdef SIGDANGER
-{  SIGDANGER, NULL_HANDLER, 0 },
-#endif
-
-#ifdef SIGEMT
-{  SIGEMT, NULL_HANDLER, 0 },
-#endif
-
-#ifdef SIGFPE
-{  SIGFPE, NULL_HANDLER, 0, 1 },
-#endif
-
-#ifdef SIGBUS
-{  SIGBUS, NULL_HANDLER, 0, 1 },
-#endif
-
-#ifdef SIGSEGV
-{  SIGSEGV, NULL_HANDLER, 0, 1 },
-#endif
-
-#ifdef SIGSYS
-{  SIGSYS, NULL_HANDLER, 0, 1 },
-#endif
-
-#ifdef SIGPIPE
-{  SIGPIPE, NULL_HANDLER, 0 },
-#endif
-
-#ifdef SIGALRM
-{  SIGALRM, NULL_HANDLER, 0 },
-#endif
-
-#ifdef SIGTERM
-{  SIGTERM, NULL_HANDLER, 0 },
-#endif
-
-/* These don't generate core dumps on anything but Linux, but we're doing
-   this just for Linux anyway. */
-#ifdef SIGXCPU
-{  SIGXCPU, NULL_HANDLER, 0, 1 },
-#endif
-
-#ifdef SIGXFSZ
-{  SIGXFSZ, NULL_HANDLER, 0, 1 },
-#endif
-
-#ifdef SIGVTALRM
-{  SIGVTALRM, NULL_HANDLER, 0 },
-#endif
-
-#if 0
-#ifdef SIGPROF
-{  SIGPROF, NULL_HANDLER, 0 },
-#endif
-#endif
-
-#ifdef SIGLOST
-{  SIGLOST, NULL_HANDLER, 0 },
-#endif
-
-#ifdef SIGUSR1
-{  SIGUSR1, NULL_HANDLER, 0 },
-#endif
-
-#ifdef SIGUSR2
-{  SIGUSR2, NULL_HANDLER, 0 },
-#endif
-};
-
-#define TERMSIGS_LENGTH (sizeof (terminating_signals) / sizeof (struct termsig))
-
-#define XSIG(x) (terminating_signals[x].signum)
-#define XHANDLER(x) (terminating_signals[x].orig_handler)
-#define XSAFLAGS(x) (terminating_signals[x].orig_flags)
-#define XCOREDUMP(x) (terminating_signals[x].core_dump)
-
-static int termsigs_initialized = 0;
-
-/* Initialize signals that will terminate the shell to do some
-   unwind protection.  For non-interactive shells, we only call
-   this when a trap is defined for EXIT (0) or when trap is run
-   to display signal dispositions. */
-void
-initialize_terminating_signals ()
-{
-  register int i;
-#if defined (HAVE_POSIX_SIGNALS)
-  struct sigaction act, oact;
-#endif
-
-  if (termsigs_initialized)
-    return;
-
-  /* The following code is to avoid an expensive call to
-     set_signal_handler () for each terminating_signals.  Fortunately,
-     this is possible in Posix.  Unfortunately, we have to call signal ()
-     on non-Posix systems for each signal in terminating_signals. */
-#if defined (HAVE_POSIX_SIGNALS)
-  act.sa_handler = termsig_sighandler;
-  act.sa_flags = 0;
-  sigemptyset (&act.sa_mask);
-  sigemptyset (&oact.sa_mask);
-  for (i = 0; i < TERMSIGS_LENGTH; i++)
-    sigaddset (&act.sa_mask, XSIG (i));
-  for (i = 0; i < TERMSIGS_LENGTH; i++)
-    {
-      /* If we've already trapped it, don't do anything. */
-      if (signal_is_trapped (XSIG (i)))
-	continue;
-
-      sigaction (XSIG (i), &act, &oact);
-      XHANDLER(i) = oact.sa_handler;
-      XSAFLAGS(i) = oact.sa_flags;
-
-#if 0
-      set_original_signal (XSIG(i), XHANDLER(i));	/* optimization */
-#else
-      set_original_signal (XSIG(i), act.sa_handler);	/* optimization */
-#endif
-
-      /* Don't do anything with signals that are ignored at shell entry
-	 if the shell is not interactive. */
-      /* XXX - should we do this for interactive shells, too? */
-      if (interactive_shell == 0 && XHANDLER (i) == SIG_IGN)
-	{
-	  sigaction (XSIG (i), &oact, &act);
-	  set_signal_hard_ignored (XSIG (i));
-	}
-#if defined (SIGPROF) && !defined (_MINIX)
-      if (XSIG (i) == SIGPROF && XHANDLER (i) != SIG_DFL && XHANDLER (i) != SIG_IGN)
-	sigaction (XSIG (i), &oact, (struct sigaction *)NULL);
-#endif /* SIGPROF && !_MINIX */
-    }
-#else /* !HAVE_POSIX_SIGNALS */
-
-  for (i = 0; i < TERMSIGS_LENGTH; i++)
-    {
-      /* If we've already trapped it, don't do anything. */
-      if (signal_is_trapped (XSIG (i)))
-	continue;
-
-      XHANDLER(i) = signal (XSIG (i), termsig_sighandler);
-      XSAFLAGS(i) = 0;
-      /* Don't do anything with signals that are ignored at shell entry
-	 if the shell is not interactive. */
-      /* XXX - should we do this for interactive shells, too? */
-      if (interactive_shell == 0 && XHANDLER (i) == SIG_IGN)
-	{
-	  signal (XSIG (i), SIG_IGN);
-	  set_signal_hard_ignored (XSIG (i));
-	}
-#ifdef SIGPROF
-      if (XSIG (i) == SIGPROF && XHANDLER (i) != SIG_DFL && XHANDLER (i) != SIG_IGN)
-	signal (XSIG (i), XHANDLER (i));
-#endif
-    }
-
-#endif /* !HAVE_POSIX_SIGNALS */
-
-  termsigs_initialized = 1;
-}
-
-static void
-initialize_shell_signals ()
-{
-  if (interactive)
-    initialize_terminating_signals ();
-
-#if defined (JOB_CONTROL) || defined (HAVE_POSIX_SIGNALS)
-  /* All shells use the signal mask they inherit, and pass it along
-     to child processes.  Children will never block SIGCHLD, though. */
-  sigemptyset (&top_level_mask);
-  sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &top_level_mask);
-#  if defined (SIGCHLD)
-  if (sigismember (&top_level_mask, SIGCHLD))
-    {
-      sigdelset (&top_level_mask, SIGCHLD);
-      sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
-    }
-#  endif
-#endif /* JOB_CONTROL || HAVE_POSIX_SIGNALS */
-
-  /* And, some signals that are specifically ignored by the shell. */
-  set_signal_handler (SIGQUIT, SIG_IGN);
-
-  if (interactive)
-    {
-      set_signal_handler (SIGINT, sigint_sighandler);
-      get_original_signal (SIGTERM);
-      set_signal_handler (SIGTERM, SIG_IGN);
-      set_sigwinch_handler ();
-    }
-}
-
-void
-reset_terminating_signals ()
-{
-  register int i;
-#if defined (HAVE_POSIX_SIGNALS)
-  struct sigaction act;
-#endif
-
-  if (termsigs_initialized == 0)
-    return;
-
-#if defined (HAVE_POSIX_SIGNALS)
-  act.sa_flags = 0;
-  sigemptyset (&act.sa_mask);
-  for (i = 0; i < TERMSIGS_LENGTH; i++)
-    {
-      /* Skip a signal if it's trapped or handled specially, because the
-	 trap code will restore the correct value. */
-      if (signal_is_trapped (XSIG (i)) || signal_is_special (XSIG (i)))
-	continue;
-
-      act.sa_handler = XHANDLER (i);
-      act.sa_flags = XSAFLAGS (i);
-      sigaction (XSIG (i), &act, (struct sigaction *) NULL);
-    }
-#else /* !HAVE_POSIX_SIGNALS */
-  for (i = 0; i < TERMSIGS_LENGTH; i++)
-    {
-      if (signal_is_trapped (XSIG (i)) || signal_is_special (XSIG (i)))
-	continue;
-
-      signal (XSIG (i), XHANDLER (i));
-    }
-#endif /* !HAVE_POSIX_SIGNALS */
-
-  termsigs_initialized = 0;
-}
-#undef XHANDLER
-
-/* Run some of the cleanups that should be performed when we run
-   jump_to_top_level from a builtin command context.  XXX - might want to
-   also call reset_parser here. */
-void
-top_level_cleanup ()
-{
-  /* Clean up string parser environment. */
-  while (parse_and_execute_level)
-    parse_and_execute_cleanup (-1);
-
-#if defined (PROCESS_SUBSTITUTION)
-  unlink_fifo_list ();
-#endif /* PROCESS_SUBSTITUTION */
-
-  run_unwind_protects ();
-  loop_level = continuing = breaking = funcnest = 0;
-  executing_list = comsub_ignore_return = return_catch_flag = wait_intr_flag = 0;
-}
-
-/* What to do when we've been interrupted, and it is safe to handle it. */
-void
-throw_to_top_level ()
-{
-  int print_newline = 0;
-
-  if (interrupt_state)
-    {
-      if (last_command_exit_value < 128)
-	last_command_exit_value = 128 + SIGINT;
-      set_pipestatus_from_exit (last_command_exit_value);
-      print_newline = 1;
-      DELINTERRUPT;
-    }
-
-  if (interrupt_state)
-    return;
-
-  last_command_exit_signal = (last_command_exit_value > 128) ?
-				(last_command_exit_value - 128) : 0;
-  last_command_exit_value |= 128;
-  set_pipestatus_from_exit (last_command_exit_value);
-
-  /* Run any traps set on SIGINT, mostly for interactive shells */
-  if (signal_is_trapped (SIGINT) && signal_is_pending (SIGINT))
-    run_interrupt_trap (1);
-
-  /* Clean up string parser environment. */
-  while (parse_and_execute_level)
-    parse_and_execute_cleanup (-1);
-
-  if (running_trap > 0)
-    {
-      run_trap_cleanup (running_trap - 1);
-      running_trap = 0;
-    }
-
-#if defined (JOB_CONTROL)
-  give_terminal_to (shell_pgrp, 0);
-#endif /* JOB_CONTROL */
-
-  /* This needs to stay because jobs.c:make_child() uses it without resetting
-     the signal mask. */
-  restore_sigmask ();  
-
-  reset_parser ();
-
-#if defined (READLINE)
-  if (interactive)
-    bashline_reset ();
-#endif /* READLINE */
-
-#if defined (PROCESS_SUBSTITUTION)
-  unlink_fifo_list ();
-#endif /* PROCESS_SUBSTITUTION */
-
-  run_unwind_protects ();
-  loop_level = continuing = breaking = funcnest = 0;
-  executing_list = comsub_ignore_return = return_catch_flag = wait_intr_flag = 0;
-
-  if (interactive && print_newline)
-    {
-      fflush (stdout);
-      fprintf (stderr, "\n");
-      fflush (stderr);
-    }
-
-  /* An interrupted `wait' command in a script does not exit the script. */
-  if (interactive || (interactive_shell && !shell_initialized) ||
-      (print_newline && signal_is_trapped (SIGINT)))
-    jump_to_top_level (DISCARD);
-  else
-    jump_to_top_level (EXITPROG);
-}
-
-/* This is just here to isolate the longjmp calls. */
-void
-jump_to_top_level (value)
-     int value;
-{
-  sh_longjmp (top_level, value);
-}
-
-void
-restore_sigmask ()
-{
-#if defined (JOB_CONTROL) || defined (HAVE_POSIX_SIGNALS)
-  sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL);
-#endif
-}
-
-sighandler
-termsig_sighandler (sig)
-     int sig;
-{
-  /* If we get called twice with the same signal before handling it,
-     terminate right away. */
-  if (
-#ifdef SIGHUP
-    sig != SIGHUP &&
-#endif
-#ifdef SIGINT
-    sig != SIGINT &&
-#endif
-#ifdef SIGDANGER
-    sig != SIGDANGER &&
-#endif
-#ifdef SIGPIPE
-    sig != SIGPIPE &&
-#endif
-#ifdef SIGALRM
-    sig != SIGALRM &&
-#endif
-#ifdef SIGTERM
-    sig != SIGTERM &&
-#endif
-#ifdef SIGXCPU
-    sig != SIGXCPU &&
-#endif
-#ifdef SIGXFSZ
-    sig != SIGXFSZ &&
-#endif
-#ifdef SIGVTALRM
-    sig != SIGVTALRM &&
-#endif
-#ifdef SIGLOST
-    sig != SIGLOST &&
-#endif
-#ifdef SIGUSR1
-    sig != SIGUSR1 &&
-#endif
-#ifdef SIGUSR2
-   sig != SIGUSR2 &&
-#endif
-   sig == terminating_signal)
-    terminate_immediately = 1;
-
-  terminating_signal = sig;
-
-  if (terminate_immediately)
-    {
-#if defined (HISTORY)
-      /* XXX - will inhibit history file being written */
-#  if defined (READLINE)
-      if (interactive_shell == 0 || interactive == 0 || (sig != SIGHUP && sig != SIGTERM) || no_line_editing || (RL_ISSTATE (RL_STATE_READCMD) == 0))
-#  endif
-        history_lines_this_session = 0;
-#endif
-      terminate_immediately = 0;
-      termsig_handler (sig);
-    }
-
-#if defined (READLINE)
-  /* Set the event hook so readline will call it after the signal handlers
-     finish executing, so if this interrupted character input we can get
-     quick response.  If readline is active or has modified the terminal we
-     need to set this no matter what the signal is, though the check for
-     RL_STATE_TERMPREPPED is possibly redundant. */
-  if (RL_ISSTATE (RL_STATE_SIGHANDLER) || RL_ISSTATE (RL_STATE_TERMPREPPED))
-    bashline_set_event_hook ();
-#endif
-
-  SIGRETURN (0);
-}
-
-void
-termsig_handler (sig)
-     int sig;
-{
-  static int handling_termsig = 0;
-  int i, core;
-  sigset_t mask;
-
-  /* Simple semaphore to keep this function from being executed multiple
-     times.  Since we no longer are running as a signal handler, we don't
-     block multiple occurrences of the terminating signals while running. */
-  if (handling_termsig)
-    return;
-  handling_termsig = 1;
-  terminating_signal = 0;	/* keep macro from re-testing true. */
-
-  /* I don't believe this condition ever tests true. */
-  if (sig == SIGINT && signal_is_trapped (SIGINT))
-    run_interrupt_trap (0);
-
-#if defined (HISTORY)
-  /* If we don't do something like this, the history will not be saved when
-     an interactive shell is running in a terminal window that gets closed
-     with the `close' button.  We can't test for RL_STATE_READCMD because
-     readline no longer handles SIGTERM synchronously.  */
-  if (interactive_shell && interactive && (sig == SIGHUP || sig == SIGTERM) && remember_on_history)
-    maybe_save_shell_history ();
-#endif /* HISTORY */
-
-  if (this_shell_builtin == read_builtin)
-    read_tty_cleanup ();
-
-#if defined (JOB_CONTROL)
-  if (sig == SIGHUP && (interactive || (subshell_environment & (SUBSHELL_COMSUB|SUBSHELL_PROCSUB))))
-    hangup_all_jobs ();
-
-  if ((subshell_environment & (SUBSHELL_COMSUB|SUBSHELL_PROCSUB)) == 0)
-    end_job_control ();
-#endif /* JOB_CONTROL */
-
-#if defined (PROCESS_SUBSTITUTION)
-  unlink_all_fifos ();
-#  if defined (JOB_CONTROL)
-  procsub_clear ();
-#  endif
-#endif /* PROCESS_SUBSTITUTION */
-
-  /* Reset execution context */
-  loop_level = continuing = breaking = funcnest = 0;
-  executing_list = comsub_ignore_return = return_catch_flag = wait_intr_flag = 0;
-
-  run_exit_trap ();	/* XXX - run exit trap possibly in signal context? */
-
-  /* We don't change the set of blocked signals. If a user starts the shell
-     with a terminating signal blocked, we won't get here (and if by some
-     magic chance we do, we'll exit below). What we do is to restore the
-     top-level signal mask, in case this is called from a terminating signal
-     handler context, in which case the signal is blocked. */
-  restore_sigmask ();
-
-  set_signal_handler (sig, SIG_DFL);
-
-  kill (getpid (), sig);
-
-  if (dollar_dollar_pid != 1)
-    exit (128+sig);		/* just in case the kill fails? */
-
-  /* We get here only under extraordinary circumstances. */
-
-  /* We are PID 1, and the kill above failed to kill the process. We assume
-     this means that we are running as an init process in a pid namespace
-     on Linux. In this case, we can't send ourselves a fatal signal, so we
-     determine whether or not we should have generated a core dump with the
-     kill call and attempt to trick the kernel into generating one if
-     necessary. */
-  sigprocmask (SIG_SETMASK, (sigset_t *)NULL, &mask);
-  for (i = core = 0; i < TERMSIGS_LENGTH; i++)
-    {
-      set_signal_handler (XSIG (i), SIG_DFL);
-      sigdelset (&mask, XSIG (i));
-      if (sig == XSIG (i))
-	core = XCOREDUMP (i);
-    }
-  sigprocmask (SIG_SETMASK, &mask, (sigset_t *)NULL);
-
-  if (core)
-    *((volatile unsigned long *) NULL) = 0xdead0000 + sig;	/* SIGSEGV */
-
-  exit (128+sig);
-}
-#undef XSIG
-
-/* What we really do when SIGINT occurs. */
-sighandler
-sigint_sighandler (sig)
-     int sig;
-{
-#if defined (MUST_REINSTALL_SIGHANDLERS)
-  signal (sig, sigint_sighandler);
-#endif
-
-  /* interrupt_state needs to be set for the stack of interrupts to work
-     right.  Should it be set unconditionally? */
-  if (interrupt_state == 0)
-    ADDINTERRUPT;
-
-  /* We will get here in interactive shells with job control active; allow
-     an interactive wait to be interrupted.  wait_intr_flag is only set during
-     the execution of the wait builtin and when wait_intr_buf is valid. */
-  if (wait_intr_flag)
-    {
-      last_command_exit_value = 128 + sig;
-      set_pipestatus_from_exit (last_command_exit_value);
-      wait_signal_received = sig;
-      SIGRETURN (0);
-    }
-
-  /* In interactive shells, we will get here instead of trap_handler() so
-     note that we have a trap pending. */
-  if (signal_is_trapped (sig))
-    set_trap_state (sig);
-
-  /* This is no longer used, but this code block remains as a reminder. */
-  if (interrupt_immediately)
-    {
-      interrupt_immediately = 0;
-      set_exit_status (128 + sig);
-      throw_to_top_level ();
-    }
-#if defined (READLINE)
-  /* Set the event hook so readline will call it after the signal handlers
-     finish executing, so if this interrupted character input we can get
-     quick response. */
-  else if (RL_ISSTATE (RL_STATE_SIGHANDLER))
-    bashline_set_event_hook ();
-#endif
-
-  SIGRETURN (0);
-}
-
-#if defined (SIGWINCH)
-sighandler
-sigwinch_sighandler (sig)
-     int sig;
-{
-#if defined (MUST_REINSTALL_SIGHANDLERS)
-  set_signal_handler (SIGWINCH, sigwinch_sighandler);
-#endif /* MUST_REINSTALL_SIGHANDLERS */
-  sigwinch_received = 1;
-  SIGRETURN (0);
-}
-#endif /* SIGWINCH */
-
-void
-set_sigwinch_handler ()
-{
-#if defined (SIGWINCH)
- old_winch = set_signal_handler (SIGWINCH, sigwinch_sighandler);
-#endif
-}
-
-void
-unset_sigwinch_handler ()
-{
-#if defined (SIGWINCH)
-  set_signal_handler (SIGWINCH, old_winch);
-#endif
-}
-
-sighandler
-sigterm_sighandler (sig)
-     int sig;
-{
-  sigterm_received = 1;		/* XXX - counter? */
-  SIGRETURN (0);
-}
-
-/* Signal functions used by the rest of the code. */
-#if !defined (HAVE_POSIX_SIGNALS)
-
-/* Perform OPERATION on NEWSET, perhaps leaving information in OLDSET. */
-sigprocmask (operation, newset, oldset)
-     int operation, *newset, *oldset;
-{
-  int old, new;
-
-  if (newset)
-    new = *newset;
-  else
-    new = 0;
-
-  switch (operation)
-    {
-    case SIG_BLOCK:
-      old = sigblock (new);
-      break;
-
-    case SIG_SETMASK:
-      old = sigsetmask (new);
-      break;
-
-    default:
-      internal_error (_("sigprocmask: %d: invalid operation"), operation);
-    }
-
-  if (oldset)
-    *oldset = old;
-}
-
-#else
-
-#if !defined (SA_INTERRUPT)
-#  define SA_INTERRUPT 0
-#endif
-
-#if !defined (SA_RESTART)
-#  define SA_RESTART 0
-#endif
-
-SigHandler *
-set_signal_handler (sig, handler)
-     int sig;
-     SigHandler *handler;
-{
-  struct sigaction act, oact;
-
-  act.sa_handler = handler;
-  act.sa_flags = 0;
-
-  /* XXX - bash-4.2 */
-  /* We don't want a child death to interrupt interruptible system calls, even
-     if we take the time to reap children */
-#if defined (SIGCHLD)
-  if (sig == SIGCHLD)
-    act.sa_flags |= SA_RESTART;		/* XXX */
-#endif
-  /* Let's see if we can keep SIGWINCH from interrupting interruptible system
-     calls, like open(2)/read(2)/write(2) */
-#if defined (SIGWINCH)
-  if (sig == SIGWINCH)
-    act.sa_flags |= SA_RESTART;		/* XXX */
-#endif
-  /* If we're installing a SIGTERM handler for interactive shells, we want
-     it to be as close to SIG_IGN as possible. */
-  if (sig == SIGTERM && handler == sigterm_sighandler)
-    act.sa_flags |= SA_RESTART;		/* XXX */
-
-  sigemptyset (&act.sa_mask);
-  sigemptyset (&oact.sa_mask);
-  if (sigaction (sig, &act, &oact) == 0)
-    return (oact.sa_handler);
-  else
-    return (SIG_DFL);
-}
-#endif /* HAVE_POSIX_SIGNALS */
diff --git a/third_party/bash/sig.h b/third_party/bash/sig.h
deleted file mode 100644
index 0217be53d..000000000
--- a/third_party/bash/sig.h
+++ /dev/null
@@ -1,136 +0,0 @@
-/* sig.h -- header file for signal handler definitions. */
-
-/* Copyright (C) 1994-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* Make sure that this is included *after* config.h! */
-
-#if !defined (_SIG_H_)
-#  define _SIG_H_
-
-#include "stdc.h"
-
-#include <signal.h>		/* for sig_atomic_t */
-
-#if !defined (SIGABRT) && defined (SIGIOT)
-#  define SIGABRT SIGIOT
-#endif
-
-#define sighandler void
-typedef void SigHandler PARAMS((int));
-
-#define SIGRETURN(n)	return
-
-/* Here is a definition for set_signal_handler () which simply expands to
-   a call to signal () for non-Posix systems.  The code for set_signal_handler
-   in the Posix case resides in general.c. */
-#if !defined (HAVE_POSIX_SIGNALS)
-#  define set_signal_handler(sig, handler) (SigHandler *)signal (sig, handler)
-#else
-extern SigHandler *set_signal_handler PARAMS((int, SigHandler *));	/* in sig.c */
-#endif /* _POSIX_VERSION */
-
-#if !defined (SIGCHLD) && defined (SIGCLD)
-#  define SIGCHLD SIGCLD
-#endif
-
-#if !defined (HAVE_POSIX_SIGNALS) && !defined (sigmask)
-#  define sigmask(x) (1 << ((x)-1))
-#endif /* !HAVE_POSIX_SIGNALS && !sigmask */
-
-#if !defined (HAVE_POSIX_SIGNALS)
-#  if !defined (SIG_BLOCK)
-#    define SIG_BLOCK 2
-#    define SIG_SETMASK 3
-#  endif /* SIG_BLOCK */
-
-/* sigset_t defined in config.h */
-
-/* Make sure there is nothing inside the signal set. */
-#  define sigemptyset(set) (*(set) = 0)
-
-/* Initialize the signal set to hold all signals. */
-#  define sigfillset(set) (*set) = sigmask (NSIG) - 1
-
-/* Add SIG to the contents of SET. */
-#  define sigaddset(set, sig) *(set) |= sigmask (sig)
-
-/* Delete SIG from signal set SET. */
-#  define sigdelset(set, sig) *(set) &= ~sigmask (sig)
-
-/* Is SIG a member of the signal set SET? */
-#  define sigismember(set, sig) ((*(set) & sigmask (sig)) != 0)
-
-/* Suspend the process until the reception of one of the signals
-   not present in SET. */
-#  define sigsuspend(set) sigpause (*(set))
-#endif /* !HAVE_POSIX_SIGNALS */
-
-/* These definitions are used both in POSIX and non-POSIX implementations. */
-
-#define BLOCK_SIGNAL(sig, nvar, ovar) \
-do { \
-  sigemptyset (&nvar); \
-  sigaddset (&nvar, sig); \
-  sigemptyset (&ovar); \
-  sigprocmask (SIG_BLOCK, &nvar, &ovar); \
-} while (0)
-
-#define UNBLOCK_SIGNAL(ovar) sigprocmask (SIG_SETMASK, &ovar, (sigset_t *) NULL)
-
-#if defined (HAVE_POSIX_SIGNALS)
-#  define BLOCK_CHILD(nvar, ovar) BLOCK_SIGNAL (SIGCHLD, nvar, ovar)
-#  define UNBLOCK_CHILD(ovar) UNBLOCK_SIGNAL(ovar)
-#else /* !HAVE_POSIX_SIGNALS */
-#  define BLOCK_CHILD(nvar, ovar) ovar = sigblock (sigmask (SIGCHLD))
-#  define UNBLOCK_CHILD(ovar) sigsetmask (ovar)
-#endif /* !HAVE_POSIX_SIGNALS */
-
-/* Extern variables */
-extern volatile sig_atomic_t sigwinch_received;
-extern volatile sig_atomic_t sigterm_received;
-
-extern int interrupt_immediately;	/* no longer used */
-extern int terminate_immediately;
-
-/* Functions from sig.c. */
-extern sighandler termsig_sighandler PARAMS((int));
-extern void termsig_handler PARAMS((int));
-extern sighandler sigint_sighandler PARAMS((int));
-extern void initialize_signals PARAMS((int));
-extern void initialize_terminating_signals PARAMS((void));
-extern void reset_terminating_signals PARAMS((void));
-extern void top_level_cleanup PARAMS((void));
-extern void throw_to_top_level PARAMS((void));
-extern void jump_to_top_level PARAMS((int)) __attribute__((__noreturn__));
-extern void restore_sigmask PARAMS((void));
-
-extern sighandler sigwinch_sighandler PARAMS((int));
-extern void set_sigwinch_handler PARAMS((void));
-extern void unset_sigwinch_handler PARAMS((void));
-
-extern sighandler sigterm_sighandler PARAMS((int));
-
-/* Functions defined in trap.c. */
-extern SigHandler *set_sigint_handler PARAMS((void));
-extern SigHandler *trap_to_sighandler PARAMS((int));
-extern sighandler trap_handler PARAMS((int));
-
-extern int block_trapped_signals PARAMS((sigset_t *, sigset_t *));
-extern int unblock_trapped_signals PARAMS((sigset_t *));
-#endif /* _SIG_H_ */
diff --git a/third_party/bash/siglist.h b/third_party/bash/siglist.h
deleted file mode 100644
index 321c20c46..000000000
--- a/third_party/bash/siglist.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/* siglist.h -- encapsulate various definitions for sys_siglist */
-
-/* Copyright (C) 1993, 2001, 2005, 2008-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_SIGLIST_H_)
-#define _SIGLIST_H_
-
-#if !defined (SYS_SIGLIST_DECLARED) && !defined (HAVE_STRSIGNAL)
-
-#if defined (HAVE_UNDER_SYS_SIGLIST) && !defined (HAVE_SYS_SIGLIST) && !defined (sys_siglist)
-#  define sys_siglist _sys_siglist
-#endif /* HAVE_UNDER_SYS_SIGLIST && !HAVE_SYS_SIGLIST && !sys_siglist */
-
-#if !defined (sys_siglist)
-extern char *sys_siglist[];
-#endif /* !sys_siglist */
-
-#endif /* !SYS_SIGLIST_DECLARED && !HAVE_STRSIGNAL */
-
-#if !defined (strsignal) && !defined (HAVE_STRSIGNAL)
-#  define strsignal(sig) (char *)sys_siglist[sig]
-#endif /* !strsignal && !HAVE_STRSIGNAL */
-
-#if !defined (strsignal) && !HAVE_DECL_STRSIGNAL
-extern char *strsignal PARAMS((int));
-#endif
-
-#endif /* _SIGLIST_H */
diff --git a/third_party/bash/signames.c b/third_party/bash/signames.c
deleted file mode 100644
index 391482893..000000000
--- a/third_party/bash/signames.c
+++ /dev/null
@@ -1,446 +0,0 @@
-/* signames.c -- Create an array of signal names. */
-
-/* Copyright (C) 2006-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <stdio.h>
-
-#include <sys/types.h>
-#include <signal.h>
-
-#if defined (HAVE_STDLIB_H)
-#  include <stdlib.h>
-#else
-#  include "ansi_stdlib.h"
-#endif /* HAVE_STDLIB_H */
-
-#if !defined (NSIG)
-#  define NSIG 64
-#endif
-
-/*
- * Special traps:
- *	EXIT == 0
- *	DEBUG == NSIG
- *	ERR == NSIG+1
- *	RETURN == NSIG+2
- */
-#define LASTSIG NSIG+2
-
-char *signal_names[2 * (LASTSIG)];
-
-#define signal_names_size (sizeof(signal_names)/sizeof(signal_names[0]))
-
-/* AIX 4.3 defines SIGRTMIN and SIGRTMAX as 888 and 999 respectively.
-   I don't want to allocate so much unused space for the intervening signal
-   numbers, so we just punt if SIGRTMAX is past the bounds of the
-   signal_names array (handled in configure). */
-#if defined (SIGRTMAX) && defined (UNUSABLE_RT_SIGNALS)
-#  undef SIGRTMAX
-#  undef SIGRTMIN
-#endif
-
-#if defined (SIGRTMAX) || defined (SIGRTMIN)
-#  define RTLEN 14
-#  define RTLIM 256
-#endif
-
-#if defined (BUILDTOOL)
-extern char *progname;
-#endif
-
-void
-initialize_signames ()
-{
-  register int i;
-#if defined (SIGRTMAX) || defined (SIGRTMIN)
-  int rtmin, rtmax, rtcnt;
-#endif
-
-  for (i = 1; i < signal_names_size; i++)
-    signal_names[i] = (char *)NULL;
-
-  /* `signal' 0 is what we do on exit. */
-  signal_names[0] = "EXIT";
-
-  /* Place signal names which can be aliases for more common signal
-     names first.  This allows (for example) SIGABRT to overwrite SIGLOST. */
-
-  /* POSIX 1003.1b-1993 real time signals, but take care of incomplete
-     implementations. According to the standard, both SIGRTMIN and
-     SIGRTMAX must be defined, SIGRTMIN must be strictly less than
-     SIGRTMAX, and the difference must be at least 7; that is, there
-     must be at least eight distinct real time signals. */
-
-  /* The generated signal names are SIGRTMIN, SIGRTMIN+1, ...,
-     SIGRTMIN+x, SIGRTMAX-x, ..., SIGRTMAX-1, SIGRTMAX. If the number
-     of RT signals is odd, there is an extra SIGRTMIN+(x+1).
-     These names are the ones used by ksh and /usr/xpg4/bin/sh on SunOS5. */
-
-#if defined (SIGRTMIN)
-  rtmin = SIGRTMIN;
-  signal_names[rtmin] = "SIGRTMIN";
-#endif
-
-#if defined (SIGRTMAX)
-  rtmax = SIGRTMAX;
-  signal_names[rtmax] = "SIGRTMAX";
-#endif
-
-#if defined (SIGRTMAX) && defined (SIGRTMIN)
-  if (rtmax > rtmin)
-    {
-      rtcnt = (rtmax - rtmin - 1) / 2;
-      /* croak if there are too many RT signals */
-      if (rtcnt >= RTLIM/2)
-	{
-	  rtcnt = RTLIM/2-1;
-#ifdef BUILDTOOL
-	  fprintf(stderr, "%s: error: more than %d real time signals, fix `%s'\n",
-		  progname, RTLIM, progname);
-#endif
-	}
-
-      for (i = 1; i <= rtcnt; i++)
-	{
-	  signal_names[rtmin+i] = (char *)malloc(RTLEN);
-	  if (signal_names[rtmin+i])
-	    sprintf (signal_names[rtmin+i], "SIGRTMIN+%d", i);
-	  signal_names[rtmax-i] = (char *)malloc(RTLEN);
-	  if (signal_names[rtmax-i])
-	    sprintf (signal_names[rtmax-i], "SIGRTMAX-%d", i);
-	}
-
-      if (rtcnt < RTLIM/2-1 && rtcnt != (rtmax-rtmin)/2)
-	{
-	  /* Need an extra RTMIN signal */
-	  signal_names[rtmin+rtcnt+1] = (char *)malloc(RTLEN);
-	  if (signal_names[rtmin+rtcnt+1])
-	    sprintf (signal_names[rtmin+rtcnt+1], "SIGRTMIN+%d", rtcnt+1);
-	}
-    }
-#endif /* SIGRTMIN && SIGRTMAX */
-
-#if defined (SIGLOST)	/* resource lost (eg, record-lock lost) */
-  signal_names[SIGLOST] = "SIGLOST";
-#endif
-
-/* AIX */
-#if defined (SIGMSG)	/* HFT input data pending */
-  signal_names[SIGMSG] = "SIGMSG";
-#endif
-
-#if defined (SIGDANGER)	/* system crash imminent */
-  signal_names[SIGDANGER] = "SIGDANGER";
-#endif
-
-#if defined (SIGMIGRATE) /* migrate process to another CPU */
-  signal_names[SIGMIGRATE] = "SIGMIGRATE";
-#endif
-
-#if defined (SIGPRE)	/* programming error */
-  signal_names[SIGPRE] = "SIGPRE";
-#endif
-
-#if defined (SIGPHONE)	/* Phone interrupt */
-  signal_names[SIGPHONE] = "SIGPHONE";
-#endif
-
-#if defined (SIGVIRT)	/* AIX virtual time alarm */
-  signal_names[SIGVIRT] = "SIGVIRT";
-#endif
-
-#if defined (SIGTINT)	/* Interrupt */
-  signal_names[SIGTINT] = "SIGTINT";
-#endif
-
-#if defined (SIGALRM1)	/* m:n condition variables */
-  signal_names[SIGALRM1] = "SIGALRM1";
-#endif
-
-#if defined (SIGWAITING)	/* m:n scheduling */
-  signal_names[SIGWAITING] = "SIGWAITING";
-#endif
-
-#if defined (SIGGRANT)	/* HFT monitor mode granted */
-  signal_names[SIGGRANT] = "SIGGRANT";
-#endif
-
-#if defined (SIGKAP)	/* keep alive poll from native keyboard */
-  signal_names[SIGKAP] = "SIGKAP";
-#endif
-
-#if defined (SIGRETRACT) /* HFT monitor mode retracted */
-  signal_names[SIGRETRACT] = "SIGRETRACT";
-#endif
-
-#if defined (SIGSOUND)	/* HFT sound sequence has completed */
-  signal_names[SIGSOUND] = "SIGSOUND";
-#endif
-
-#if defined (SIGSAK)	/* Secure Attention Key */
-  signal_names[SIGSAK] = "SIGSAK";
-#endif
-
-#if defined (SIGCPUFAIL)	/* Predictive processor deconfiguration */
-  signal_names[SIGCPUFAIL] = "SIGCPUFAIL";
-#endif
-
-#if defined (SIGAIO)	/* Asynchronous I/O */
-  signal_names[SIGAIO] = "SIGAIO";
-#endif
-
-#if defined (SIGLAB)	/* Security label changed */
-  signal_names[SIGLAB] = "SIGLAB";
-#endif
-
-/* SunOS5 */
-#if defined (SIGLWP)	/* Solaris: special signal used by thread library */
-  signal_names[SIGLWP] = "SIGLWP";
-#endif
-
-#if defined (SIGFREEZE)	/* Solaris: special signal used by CPR */
-  signal_names[SIGFREEZE] = "SIGFREEZE";
-#endif
-
-#if defined (SIGTHAW)	/* Solaris: special signal used by CPR */
-  signal_names[SIGTHAW] = "SIGTHAW";
-#endif
-
-#if defined (SIGCANCEL)	/* Solaris: thread cancellation signal used by libthread */
-  signal_names[SIGCANCEL] = "SIGCANCEL";
-#endif
-
-#if defined (SIGXRES)	/* Solaris: resource control exceeded */
-  signal_names[SIGXRES] = "SIGXRES";
-#endif
-
-#if defined (SIGJVM1)	/* Solaris: Java Virtual Machine 1 */
-  signal_names[SIGJVM1] = "SIGJVM1";
-#endif
-
-#if defined (SIGJVM2)	/* Solaris: Java Virtual Machine 2 */
-  signal_names[SIGJVM2] = "SIGJVM2";
-#endif
-
-#if defined (SIGDGTIMER1)
-  signal_names[SIGDGTIMER1] = "SIGDGTIMER1";
-#endif
-
-#if defined (SIGDGTIMER2)
-  signal_names[SIGDGTIMER2] = "SIGDGTIMER2";
-#endif
-
-#if defined (SIGDGTIMER3)
-  signal_names[SIGDGTIMER3] = "SIGDGTIMER3";
-#endif
-
-#if defined (SIGDGTIMER4)
-  signal_names[SIGDGTIMER4] = "SIGDGTIMER4";
-#endif
-
-#if defined (SIGDGNOTIFY)
-  signal_names[SIGDGNOTIFY] = "SIGDGNOTIFY";
-#endif
-
-/* Apollo */
-#if defined (SIGAPOLLO)
-  signal_names[SIGAPOLLO] = "SIGAPOLLO";
-#endif
-
-/* HP-UX */
-#if defined (SIGDIL)	/* DIL signal (?) */
-  signal_names[SIGDIL] = "SIGDIL";
-#endif
-
-/* System V */
-#if defined (SIGCLD)	/* Like SIGCHLD.  */
-  signal_names[SIGCLD] = "SIGCLD";
-#endif
-
-#if defined (SIGPWR)	/* power state indication */
-  signal_names[SIGPWR] = "SIGPWR";
-#endif
-
-#if defined (SIGPOLL)	/* Pollable event (for streams)  */
-  signal_names[SIGPOLL] = "SIGPOLL";
-#endif
-
-/* Unknown */
-#if defined (SIGWINDOW)
-  signal_names[SIGWINDOW] = "SIGWINDOW";
-#endif
-
-/* Linux */
-#if defined (SIGSTKFLT)
-  signal_names[SIGSTKFLT] = "SIGSTKFLT";
-#endif
-
-/* FreeBSD */
-#if defined (SIGTHR)	/* thread interrupt */
-  signal_names[SIGTHR] = "SIGTHR";
-#endif
-
-/* Common */
-#if defined (SIGHUP)	/* hangup */
-  signal_names[SIGHUP] = "SIGHUP";
-#endif
-
-#if defined (SIGINT)	/* interrupt */
-  signal_names[SIGINT] = "SIGINT";
-#endif
-
-#if defined (SIGQUIT)	/* quit */
-  signal_names[SIGQUIT] = "SIGQUIT";
-#endif
-
-#if defined (SIGILL)	/* illegal instruction (not reset when caught) */
-  signal_names[SIGILL] = "SIGILL";
-#endif
-
-#if defined (SIGTRAP)	/* trace trap (not reset when caught) */
-  signal_names[SIGTRAP] = "SIGTRAP";
-#endif
-
-#if defined (SIGIOT)	/* IOT instruction */
-  signal_names[SIGIOT] = "SIGIOT";
-#endif
-
-#if defined (SIGABRT)	/* Cause current process to dump core. */
-  signal_names[SIGABRT] = "SIGABRT";
-#endif
-
-#if defined (SIGEMT)	/* EMT instruction */
-  signal_names[SIGEMT] = "SIGEMT";
-#endif
-
-#if defined (SIGFPE)	/* floating point exception */
-  signal_names[SIGFPE] = "SIGFPE";
-#endif
-
-#if defined (SIGKILL)	/* kill (cannot be caught or ignored) */
-  signal_names[SIGKILL] = "SIGKILL";
-#endif
-
-#if defined (SIGBUS)	/* bus error */
-  signal_names[SIGBUS] = "SIGBUS";
-#endif
-
-#if defined (SIGSEGV)	/* segmentation violation */
-  signal_names[SIGSEGV] = "SIGSEGV";
-#endif
-
-#if defined (SIGSYS)	/* bad argument to system call */
-  signal_names[SIGSYS] = "SIGSYS";
-#endif
-
-#if defined (SIGPIPE)	/* write on a pipe with no one to read it */
-  signal_names[SIGPIPE] = "SIGPIPE";
-#endif
-
-#if defined (SIGALRM)	/* alarm clock */
-  signal_names[SIGALRM] = "SIGALRM";
-#endif
-
-#if defined (SIGTERM)	/* software termination signal from kill */
-  signal_names[SIGTERM] = "SIGTERM";
-#endif
-
-#if defined (SIGURG)	/* urgent condition on IO channel */
-  signal_names[SIGURG] = "SIGURG";
-#endif
-
-#if defined (SIGSTOP)	/* sendable stop signal not from tty */
-  signal_names[SIGSTOP] = "SIGSTOP";
-#endif
-
-#if defined (SIGTSTP)	/* stop signal from tty */
-  signal_names[SIGTSTP] = "SIGTSTP";
-#endif
-
-#if defined (SIGCONT)	/* continue a stopped process */
-  signal_names[SIGCONT] = "SIGCONT";
-#endif
-
-#if defined (SIGCHLD)	/* to parent on child stop or exit */
-  signal_names[SIGCHLD] = "SIGCHLD";
-#endif
-
-#if defined (SIGTTIN)	/* to readers pgrp upon background tty read */
-  signal_names[SIGTTIN] = "SIGTTIN";
-#endif
-
-#if defined (SIGTTOU)	/* like TTIN for output if (tp->t_local&LTOSTOP) */
-  signal_names[SIGTTOU] = "SIGTTOU";
-#endif
-
-#if defined (SIGIO)	/* input/output possible signal */
-  signal_names[SIGIO] = "SIGIO";
-#endif
-
-#if defined (SIGXCPU)	/* exceeded CPU time limit */
-  signal_names[SIGXCPU] = "SIGXCPU";
-#endif
-
-#if defined (SIGXFSZ)	/* exceeded file size limit */
-  signal_names[SIGXFSZ] = "SIGXFSZ";
-#endif
-
-#if defined (SIGVTALRM)	/* virtual time alarm */
-  signal_names[SIGVTALRM] = "SIGVTALRM";
-#endif
-
-#if defined (SIGPROF)	/* profiling time alarm */
-  signal_names[SIGPROF] = "SIGPROF";
-#endif
-
-#if defined (SIGWINCH)	/* window changed */
-  signal_names[SIGWINCH] = "SIGWINCH";
-#endif
-
-/* 4.4 BSD */
-#if defined (SIGINFO) && !defined (_SEQUENT_)	/* information request */
-  signal_names[SIGINFO] = "SIGINFO";
-#endif
-
-#if defined (SIGUSR1)	/* user defined signal 1 */
-  signal_names[SIGUSR1] = "SIGUSR1";
-#endif
-
-#if defined (SIGUSR2)	/* user defined signal 2 */
-  signal_names[SIGUSR2] = "SIGUSR2";
-#endif
-
-#if defined (SIGKILLTHR)	/* BeOS: Kill Thread */
-  signal_names[SIGKILLTHR] = "SIGKILLTHR";
-#endif
-
-  for (i = 0; i < NSIG; i++)
-    if (signal_names[i] == (char *)NULL)
-      {
-	signal_names[i] = (char *)malloc (18);
-	if (signal_names[i])
-	  sprintf (signal_names[i], "SIGJUNK(%d)", i);
-      }
-
-  signal_names[NSIG] = "DEBUG";
-  signal_names[NSIG+1] = "ERR";
-  signal_names[NSIG+2] = "RETURN";
-}
diff --git a/third_party/bash/signames.h b/third_party/bash/signames.h
deleted file mode 100644
index 29efbf1ed..000000000
--- a/third_party/bash/signames.h
+++ /dev/null
@@ -1,2 +0,0 @@
-extern char *signal_names[NSIG + 4];
-void initialize_signames ();
diff --git a/third_party/bash/sm_loop.inc b/third_party/bash/sm_loop.inc
deleted file mode 100644
index 247ba28aa..000000000
--- a/third_party/bash/sm_loop.inc
+++ /dev/null
@@ -1,981 +0,0 @@
-/* Copyright (C) 1991-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-   
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-extern int interrupt_state, terminating_signal;
-
-struct STRUCT
-{
-  CHAR *pattern;
-  CHAR *string;
-};
-
-int FCT PARAMS((CHAR *, CHAR *, int));
-
-static int GMATCH PARAMS((CHAR *, CHAR *, CHAR *, CHAR *, struct STRUCT *, int));
-static CHAR *PARSE_COLLSYM PARAMS((CHAR *, INT *));
-static CHAR *BRACKMATCH PARAMS((CHAR *, U_CHAR, int));
-static int EXTMATCH PARAMS((INT, CHAR *, CHAR *, CHAR *, CHAR *, int));
-
-extern void DEQUOTE_PATHNAME PARAMS((CHAR *));
-
-/*static*/ CHAR *PATSCAN PARAMS((CHAR *, CHAR *, INT));
-
-int
-FCT (pattern, string, flags)
-     CHAR *pattern;
-     CHAR *string;
-     int flags;
-{
-  CHAR *se, *pe;
-
-  if (string == 0 || pattern == 0)
-    return FNM_NOMATCH;
-
-  se = string + STRLEN ((XCHAR *)string);
-  pe = pattern + STRLEN ((XCHAR *)pattern);
-
-  return (GMATCH (string, se, pattern, pe, (struct  STRUCT *)NULL, flags));
-}
-
-/* Match STRING against the filename pattern PATTERN, returning zero if
-   it matches, FNM_NOMATCH if not.  */
-static int
-GMATCH (string, se, pattern, pe, ends, flags)
-     CHAR *string, *se;
-     CHAR *pattern, *pe;
-     struct STRUCT *ends;
-     int flags;
-{
-  CHAR *p, *n;		/* pattern, string */
-  INT c;		/* current pattern character - XXX U_CHAR? */
-  INT sc;		/* current string character - XXX U_CHAR? */
-
-  p = pattern;
-  n = string;
-
-  if (string == 0 || pattern == 0)
-    return FNM_NOMATCH;
-
-#if DEBUG_MATCHING
-fprintf(stderr, "gmatch: string = %s; se = %s\n", string, se);
-fprintf(stderr, "gmatch: pattern = %s; pe = %s\n", pattern, pe);
-#endif
-
-  while (p < pe)
-    {
-      c = *p++;
-      c = FOLD (c);
-
-      sc = n < se ? *n : '\0';
-
-      if (interrupt_state || terminating_signal)
-	return FNM_NOMATCH;
-
-#ifdef EXTENDED_GLOB
-      /* EXTMATCH () will handle recursively calling GMATCH, so we can
-	 just return what EXTMATCH() returns. */
-      if ((flags & FNM_EXTMATCH) && *p == L('(') &&
-	  (c == L('+') || c == L('*') || c == L('?') || c == L('@') || c == L('!'))) /* ) */
-	{
-	  int lflags;
-	  /* If we're not matching the start of the string, we're not
-	     concerned about the special cases for matching `.' */
-	  lflags = (n == string) ? flags : (flags & ~(FNM_PERIOD|FNM_DOTDOT));
-	  return (EXTMATCH (c, n, se, p, pe, lflags));
-	}
-#endif /* EXTENDED_GLOB */
-
-      switch (c)
-	{
-	case L('?'):		/* Match single character */
-	  if (sc == '\0')
-	    return FNM_NOMATCH;
-	  else if ((flags & FNM_PATHNAME) && sc == L('/'))
-	    /* If we are matching a pathname, `?' can never match a `/'. */
-	    return FNM_NOMATCH;
-	  else if ((flags & FNM_PERIOD) && sc == L('.') &&
-		   (n == string || ((flags & FNM_PATHNAME) && n[-1] == L('/'))))
-	    /* `?' cannot match a `.' if it is the first character of the
-	       string or if it is the first character following a slash and
-	       we are matching a pathname. */
-	    return FNM_NOMATCH;
-
-	  /* `?' cannot match `.' or `..' if it is the first character of the
-	     string or if it is the first character following a slash and
-	     we are matching a pathname. */
-	  if ((flags & FNM_DOTDOT) &&
-	      ((n == string && SDOT_OR_DOTDOT(n)) ||
-	       ((flags & FNM_PATHNAME) && n[-1] == L('/') && PDOT_OR_DOTDOT(n))))
-	    return FNM_NOMATCH;
-
-	  break;
-
-	case L('\\'):		/* backslash escape removes special meaning */
-	  if (p == pe && sc == '\\' && (n+1 == se))
-	    break;
-
-	  if (p == pe)
-	    return FNM_NOMATCH;
-
-	  if ((flags & FNM_NOESCAPE) == 0)
-	    {
-	      c = *p++;
-	      /* A trailing `\' cannot match. */
-	      if (p > pe)
-		return FNM_NOMATCH;
-	      c = FOLD (c);
-	    }
-	  if (FOLD (sc) != (U_CHAR)c)
-	    return FNM_NOMATCH;
-	  break;
-
-	case L('*'):		/* Match zero or more characters */
-	  /* See below for the reason for using this. It avoids backtracking
-	     back to a previous `*'.  Picked up from glibc. */
-	  if (ends != NULL)
-	    {
-	      ends->pattern = p - 1;
-	      ends->string = n;
-	      return (0);
-	    }
-
-	  if ((flags & FNM_PERIOD) && sc == L('.') &&
-	      (n == string || ((flags & FNM_PATHNAME) && n[-1] == L('/'))))
-	    /* `*' cannot match a `.' if it is the first character of the
-	       string or if it is the first character following a slash and
-	       we are matching a pathname. */
-	    return FNM_NOMATCH;
-
-	  /* `*' cannot match `.' or `..' if it is the first character of the
-	     string or if it is the first character following a slash and
-	     we are matching a pathname. */
-	  if ((flags & FNM_DOTDOT) &&
-	      ((n == string && SDOT_OR_DOTDOT(n)) ||
-	       ((flags & FNM_PATHNAME) && n[-1] == L('/') && PDOT_OR_DOTDOT(n))))
-	    return FNM_NOMATCH;
-
-	  if (p == pe)
-	    return 0;
-
-	  /* Collapse multiple consecutive `*' and `?', but make sure that
-	     one character of the string is consumed for each `?'. */
-	  for (c = *p++; (c == L('?') || c == L('*')); c = *p++)
-	    {
-	      if ((flags & FNM_PATHNAME) && sc == L('/'))
-		/* A slash does not match a wildcard under FNM_PATHNAME. */
-		return FNM_NOMATCH;
-#ifdef EXTENDED_GLOB
-	      else if ((flags & FNM_EXTMATCH) && c == L('?') && *p == L('(')) /* ) */
-		{
-		  CHAR *newn;
-
-		  /* We can match 0 or 1 times.  If we match, return success */
-		  if (EXTMATCH (c, n, se, p, pe, flags) == 0)
-		    return (0);
-
-		  /* We didn't match the extended glob pattern, but
-		     that's OK, since we can match 0 or 1 occurrences.
-		     We need to skip the glob pattern and see if we
-		     match the rest of the string. */
-		  newn = PATSCAN (p + 1, pe, 0);
-		  /* If NEWN is 0, we have an ill-formed pattern. */
-		  p = newn ? newn : pe;
-		}
-#endif
-	      else if (c == L('?'))
-		{
-		  if (sc == L('\0'))
-		    return FNM_NOMATCH;
-		  /* One character of the string is consumed in matching
-		     this ? wildcard, so *??? won't match if there are
-		     fewer than three characters. */
-		  n++;
-		  sc = n < se ? *n : '\0';
-		}
-
-#ifdef EXTENDED_GLOB
-	      /* Handle ******(patlist) */
-	      if ((flags & FNM_EXTMATCH) && c == L('*') && *p == L('('))  /*)*/
-		{
-		  CHAR *newn;
-		  /* We need to check whether or not the extended glob
-		     pattern matches the remainder of the string.
-		     If it does, we match the entire pattern. */
-		  for (newn = n; newn < se; ++newn)
-		    {
-		      if (EXTMATCH (c, newn, se, p, pe, flags) == 0)
-			return (0);
-		    }
-		  /* We didn't match the extended glob pattern, but
-		     that's OK, since we can match 0 or more occurrences.
-		     We need to skip the glob pattern and see if we
-		     match the rest of the string. */
-		  newn = PATSCAN (p + 1, pe, 0);
-		  /* If NEWN is 0, we have an ill-formed pattern. */
-		  p = newn ? newn : pe;
-		}
-#endif
-	      if (p == pe)
-		break;
-	    }
-
-	  /* The wildcards are the last element of the pattern.  The name
-	     cannot match completely if we are looking for a pathname and
-	     it contains another slash, unless FNM_LEADING_DIR is set. */
-	  if (c == L('\0'))
-	    {
-	      int r = (flags & FNM_PATHNAME) == 0 ? 0 : FNM_NOMATCH;
-	      if (flags & FNM_PATHNAME)
-		{
-		  if (flags & FNM_LEADING_DIR)
-		    r = 0;
-		  else if (MEMCHR (n, L('/'), se - n) == NULL)
-		    r = 0;
-		}
-	      return r;
-	    }
-
-	  /* If we've hit the end of the pattern and the last character of
-	     the pattern was handled by the loop above, we've succeeded.
-	     Otherwise, we need to match that last character. */
-	  if (p == pe && (c == L('?') || c == L('*')))
-	    return (0);
-
-	  /* If we've hit the end of the string and the rest of the pattern
-	     is something that matches the empty string, we can succeed. */
-#if defined (EXTENDED_GLOB)
-	  if (n == se && ((flags & FNM_EXTMATCH) && (c == L('!') || c == L('?')) && *p == L('(')))
-	    {
-	      --p;
-	      if (EXTMATCH (c, n, se, p, pe, flags) == 0)
-		return (c == L('!') ? FNM_NOMATCH : 0);
-	      return (c == L('!') ? 0 : FNM_NOMATCH);
-	    }
-#endif
-
-	  /* If we stop at a slash in the pattern and we are looking for a
-	     pathname ([star]/foo), then consume enough of the string to stop
-	     at any slash and then try to match the rest of the pattern.  If
-	     the string doesn't contain a slash, fail */
-	  if (c == L('/') && (flags & FNM_PATHNAME))
-	    {
-	      while (n < se && *n != L('/'))
-		++n;
-	      if (n < se && *n == L('/') && (GMATCH (n+1, se, p, pe, NULL, flags) == 0))
-		return 0;
-	      return FNM_NOMATCH;	/* XXX */
-	    }
-
-	  /* General case, use recursion. */
-	  {
-	    U_CHAR c1;
-	    const CHAR *endp;
-	    struct STRUCT end;
-
-	    end.pattern = NULL;
-	    endp = MEMCHR (n, (flags & FNM_PATHNAME) ? L('/') : L('\0'), se - n);
-	    if (endp == 0)
-	      endp = se;
-
-	    c1 = ((flags & FNM_NOESCAPE) == 0 && c == L('\\')) ? *p : c;
-	    c1 = FOLD (c1);
-	    for (--p; n < endp; ++n)
-	      {
-		/* Only call strmatch if the first character indicates a
-		   possible match.  We can check the first character if
-		   we're not doing an extended glob match. */
-		if ((flags & FNM_EXTMATCH) == 0 && c != L('[') && FOLD (*n) != c1) /*]*/
-		  continue;
-
-		/* If we're doing an extended glob match and the pattern is not
-		   one of the extended glob patterns, we can check the first
-		   character. */
-		if ((flags & FNM_EXTMATCH) && p[1] != L('(') && /*)*/
-		    STRCHR (L("?*+@!"), *p) == 0 && c != L('[') && FOLD (*n) != c1) /*]*/
-		  continue;
-
-		/* Otherwise, we just recurse. */
-		if (GMATCH (n, se, p, pe, &end, flags & ~(FNM_PERIOD|FNM_DOTDOT)) == 0)
-		  {
-		    if (end.pattern == NULL)
-		      return (0);
-		    break;
-		  }
-	      }
-	    /* This is a clever idea from glibc, used to avoid backtracking
-	       to a `*' that appears earlier in the pattern.  We get away
-	       without saving se and pe because they are always the same,
-	       even in the recursive calls to gmatch */ 
-	    if (end.pattern != NULL)
-	      {
-		p = end.pattern;
-		n = end.string;
-		continue;
-	      }
-
-	    return FNM_NOMATCH;
-	  }
-
-	case L('['):
-	  {
-	    if (sc == L('\0') || n == se)
-	      return FNM_NOMATCH;
-
-	    /* A character class cannot match a `.' if it is the first
-	       character of the string or if it is the first character
-	       following a slash and we are matching a pathname. */
-	    if ((flags & FNM_PERIOD) && sc == L('.') &&
-		(n == string || ((flags & FNM_PATHNAME) && n[-1] == L('/'))))
-	      return (FNM_NOMATCH);
-
-	    /* `?' cannot match `.' or `..' if it is the first character of the
-	       string or if it is the first character following a slash and
-	       we are matching a pathname. */
-	    if ((flags & FNM_DOTDOT) &&
-		((n == string && SDOT_OR_DOTDOT(n)) ||
-		((flags & FNM_PATHNAME) && n[-1] == L('/') && PDOT_OR_DOTDOT(n))))
-	      return FNM_NOMATCH;
-
-	    p = BRACKMATCH (p, sc, flags);
-	    if (p == 0)
-	      return FNM_NOMATCH;
-	  }
-	  break;
-
-	default:
-	  if ((U_CHAR)c != FOLD (sc))
-	    return (FNM_NOMATCH);
-	}
-
-      ++n;
-    }
-
-  if (n == se)
-    return (0);
-
-  if ((flags & FNM_LEADING_DIR) && *n == L('/'))
-    /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz".  */
-    return 0;
-	  
-  return (FNM_NOMATCH);
-}
-
-/* Parse a bracket expression collating symbol ([.sym.]) starting at P, find
-   the value of the symbol, and move P past the collating symbol expression.
-   The value is returned in *VP, if VP is not null. */
-static CHAR *
-PARSE_COLLSYM (p, vp)
-     CHAR *p;
-     INT *vp;
-{
-  register int pc;
-  INT val;
-
-  p++;				/* move past the `.' */
-	  
-  for (pc = 0; p[pc]; pc++)
-    if (p[pc] == L('.') && p[pc+1] == L(']'))
-      break;
-   if (p[pc] == 0)
-    {
-      if (vp)
-	*vp = INVALID;
-      return (p + pc);
-    }
-   val = COLLSYM (p, pc);
-   if (vp)
-     *vp = val;
-   return (p + pc + 2);
-}
-
-/* Use prototype definition here because of type promotion. */
-static CHAR *
-#if defined (PROTOTYPES)
-BRACKMATCH (CHAR *p, U_CHAR test, int flags)
-#else
-BRACKMATCH (p, test, flags)
-     CHAR *p;
-     U_CHAR test;
-     int flags;
-#endif
-{
-  register CHAR cstart, cend, c;
-  register int not;    /* Nonzero if the sense of the character class is inverted.  */
-  int brcnt, forcecoll, isrange;
-  INT pc;
-  CHAR *savep;
-  CHAR *brchrp;
-  U_CHAR orig_test;
-
-  orig_test = test;
-  test = FOLD (orig_test);
-
-  savep = p;
-
-  /* POSIX.2 3.13.1 says that an exclamation mark (`!') shall replace the
-     circumflex (`^') in its role in a `nonmatching list'.  A bracket
-     expression starting with an unquoted circumflex character produces
-     unspecified results.  This implementation treats the two identically. */
-  if (not = (*p == L('!') || *p == L('^')))
-    ++p;
-
-  c = *p++;
-  for (;;)
-    {
-      /* Initialize cstart and cend in case `-' is the last
-	 character of the pattern. */
-      cstart = cend = c;
-      forcecoll = 0;
-
-      /* POSIX.2 equivalence class:  [=c=].  See POSIX.2 2.8.3.2.  Find
-	 the end of the equivalence class, move the pattern pointer past
-	 it, and check for equivalence.  XXX - this handles only
-	 single-character equivalence classes, which is wrong, or at
-	 least incomplete. */
-      if (c == L('[') && *p == L('=') && p[2] == L('=') && p[3] == L(']'))
-	{
-	  pc = FOLD (p[1]);
-	  p += 4;
-	  if (COLLEQUIV (test, pc))
-	    {
-/*[*/	      /* Move past the closing `]', since the first thing we do at
-		 the `matched:' label is back p up one. */
-	      p++;
-	      goto matched;
-	    }
-	  else
-	    {
-	      c = *p++;
-	      if (c == L('\0'))
-		return ((test == L('[')) ? savep : (CHAR *)0); /*]*/
-	      c = FOLD (c);
-	      continue;
-	    }
-	}
-
-      /* POSIX.2 character class expression.  See POSIX.2 2.8.3.2. */
-      if (c == L('[') && *p == L(':'))
-	{
-	  CHAR *close, *ccname;
-
-	  pc = 0;	/* make sure invalid char classes don't match. */
-	  /* Find end of character class name */
-	  for (close = p + 1; *close != '\0'; close++)
-	    if (*close == L(':') && *(close+1) == L(']'))
-	      break;
-
-	  if (*close != L('\0'))
-	    {
-	      ccname = (CHAR *)malloc ((close - p) * sizeof (CHAR));
-	      if (ccname == 0)
-		pc = 0;
-	      else
-		{
-		  bcopy (p + 1, ccname, (close - p - 1) * sizeof (CHAR));
-		  *(ccname + (close - p - 1)) = L('\0');
-		  /* As a result of a POSIX discussion, char class names are
-		     allowed to be quoted (?) */
-		  DEQUOTE_PATHNAME (ccname);
-		  pc = IS_CCLASS (orig_test, (XCHAR *)ccname);
-		}
-	      if (pc == -1)
-		{
-		  /* CCNAME is not a valid character class in the current
-		     locale. In addition to noting no match (pc = 0), we have
-		     a choice about what to do with the invalid charclass.
-		     Posix leaves the behavior unspecified, but we're going
-		     to skip over the charclass and keep going instead of
-		     testing ORIG_TEST against each character in the class
-		     string. If we don't want to do that, take out the update
-		     of P. */
-		  pc = 0;
-		  p = close + 2;
-		}
-	      else
-		p = close + 2;		/* move past the closing `]' */
-
-	      free (ccname);
-	    }
-	    
-	  if (pc)
-	    {
-/*[*/	      /* Move past the closing `]', since the first thing we do at
-		 the `matched:' label is back p up one. */
-	      p++;
-	      goto matched;
-	    }
-	  else
-	    {
-	      /* continue the loop here, since this expression can't be
-		 the first part of a range expression. */
-	      c = *p++;
-	      if (c == L('\0'))
-		return ((test == L('[')) ? savep : (CHAR *)0);
-	      else if (c == L(']'))
-		break;
-	      c = FOLD (c);
-	      continue;
-	    }
-	}
- 
-      /* POSIX.2 collating symbols.  See POSIX.2 2.8.3.2.  Find the end of
-	 the symbol name, make sure it is terminated by `.]', translate
-	 the name to a character using the external table, and do the
-	 comparison. */
-      if (c == L('[') && *p == L('.'))
-	{
-	  p = PARSE_COLLSYM (p, &pc);
-	  /* An invalid collating symbol cannot be the first point of a
-	     range.  If it is, we set cstart to one greater than `test',
-	     so any comparisons later will fail. */
-	  cstart = (pc == INVALID) ? test + 1 : pc;
-	  forcecoll = 1;
-	}
-
-      if (!(flags & FNM_NOESCAPE) && c == L('\\'))
-	{
-	  if (*p == '\0')
-	    return (CHAR *)0;
-	  cstart = cend = *p++;
-	}
-
-      cstart = cend = FOLD (cstart);
-      isrange = 0;
-
-      /* POSIX.2 2.8.3.1.2 says: `An expression containing a `[' that
-	 is not preceded by a backslash and is not part of a bracket
-	 expression produces undefined results.'  This implementation
-	 treats the `[' as just a character to be matched if there is
-	 not a closing `]'. */
-      if (c == L('\0'))
-	return ((test == L('[')) ? savep : (CHAR *)0);
-
-      c = *p++;
-      c = FOLD (c);
-
-      if (c == L('\0'))
-	return ((test == L('[')) ? savep : (CHAR *)0);
-
-      if ((flags & FNM_PATHNAME) && c == L('/'))
-	/* [/] can never match when matching a pathname.  */
-	return (CHAR *)0;
-
-      /* This introduces a range, unless the `-' is the last
-	 character of the class.  Find the end of the range
-	 and move past it. */
-      if (c == L('-') && *p != L(']'))
-	{
-	  cend = *p++;
-	  if (!(flags & FNM_NOESCAPE) && cend == L('\\'))
-	    cend = *p++;
-	  if (cend == L('\0'))
-	    return (CHAR *)0;
-	  if (cend == L('[') && *p == L('.'))
-	    {
-	      p = PARSE_COLLSYM (p, &pc);
-	      /* An invalid collating symbol cannot be the second part of a
-		 range expression.  If we get one, we set cend to one fewer
-		 than the test character to make sure the range test fails. */
-	      cend = (pc == INVALID) ? test - 1 : pc;
-	      forcecoll = 1;
-	    }
-	  cend = FOLD (cend);
-
-	  c = *p++;
-
-	  /* POSIX.2 2.8.3.2:  ``The ending range point shall collate
-	     equal to or higher than the starting range point; otherwise
-	     the expression shall be treated as invalid.''  Note that this
-	     applies to only the range expression; the rest of the bracket
-	     expression is still checked for matches. */
-	  if (RANGECMP (cstart, cend, forcecoll) > 0)
-	    {
-	      if (c == L(']'))
-		break;
-	      c = FOLD (c);
-	      continue;
-	    }
-	  isrange = 1;
-	}
-
-      if (isrange == 0 && test == cstart)
-        goto matched;
-      if (isrange && RANGECMP (test, cstart, forcecoll) >= 0 && RANGECMP (test, cend, forcecoll) <= 0)
-	goto matched;
-
-      if (c == L(']'))
-	break;
-    }
-  /* No match. */
-  return (!not ? (CHAR *)0 : p);
-
-matched:
-  /* Skip the rest of the [...] that already matched.  */
-  c = *--p;
-  brcnt = 1;
-  brchrp = 0;
-  while (brcnt > 0)
-    {
-      int oc;
-
-      /* A `[' without a matching `]' is just another character to match. */
-      if (c == L('\0'))
-	return ((test == L('[')) ? savep : (CHAR *)0);
-
-      oc = c;
-      c = *p++;
-      if (c == L('[') && (*p == L('=') || *p == L(':') || *p == L('.')))
-	{
-	  brcnt++;
-	  brchrp = p++;		/* skip over the char after the left bracket */
-	  if ((c = *p) == L('\0'))
-	    return ((test == L('[')) ? savep : (CHAR *)0);
-	  /* If *brchrp == ':' we should check that the rest of the characters
-	     form a valid character class name. We don't do that yet, but we
-	     keep BRCHRP in case we want to. */
-	}
-      /* We only want to check brchrp if we set it above. */
-      else if (c == L(']') && brcnt > 1 && brchrp != 0 && oc == *brchrp)
-	{
-	  brcnt--;
-	  brchrp = 0;		/* just in case */
-	}
-      /* Left bracket loses its special meaning inside a bracket expression.
-         It is only valid when followed by a `.', `=', or `:', which we check
-         for above. Technically the right bracket can appear in a collating
-         symbol, so we check for that here. Otherwise, it terminates the
-         bracket expression. */
-      else if (c == L(']') && (brchrp == 0 || *brchrp != L('.')) && brcnt >= 1)
-	brcnt = 0;
-      else if (!(flags & FNM_NOESCAPE) && c == L('\\'))
-	{
-	  if (*p == '\0')
-	    return (CHAR *)0;
-	  /* XXX 1003.2d11 is unclear if this is right. */
-	  ++p;
-	}
-    }
-  return (not ? (CHAR *)0 : p);
-}
-
-#if defined (EXTENDED_GLOB)
-/* ksh-like extended pattern matching:
-
-	[?*+@!](pat-list)
-
-   where pat-list is a list of one or patterns separated by `|'.  Operation
-   is as follows:
-
-	?(patlist)	match zero or one of the given patterns
-	*(patlist)	match zero or more of the given patterns
-	+(patlist)	match one or more of the given patterns
-	@(patlist)	match exactly one of the given patterns
-	!(patlist)	match anything except one of the given patterns
-*/
-
-/* Scan a pattern starting at STRING and ending at END, keeping track of
-   embedded () and [].  If DELIM is 0, we scan until a matching `)'
-   because we're scanning a `patlist'.  Otherwise, we scan until we see
-   DELIM.  In all cases, we never scan past END.  The return value is the
-   first character after the matching DELIM or NULL if the pattern is
-   empty or invalid. */
-/*static*/ CHAR *
-PATSCAN (string, end, delim)
-     CHAR *string, *end;
-     INT delim;
-{
-  int pnest, bnest, skip;
-  INT cchar;
-  CHAR *s, c, *bfirst;
-
-  pnest = bnest = skip = 0;
-  cchar = 0;
-  bfirst = NULL;
-
-  if (string == end)
-    return (NULL);
-
-  for (s = string; c = *s; s++)
-    {
-      if (s >= end)
-	return (s);
-      if (skip)
-	{
-	  skip = 0;
-	  continue;
-	}
-      switch (c)
-	{
-	case L('\\'):
-	  skip = 1;
-	  break;
-
-	case L('\0'):
-	  return ((CHAR *)NULL);
-
-	/* `[' is not special inside a bracket expression, but it may
-	   introduce one of the special POSIX bracket expressions
-	   ([.SYM.], [=c=], [: ... :]) that needs special handling. */
-	case L('['):
-	  if (bnest == 0)
-	    {
-	      bfirst = s + 1;
-	      if (*bfirst == L('!') || *bfirst == L('^'))
-		bfirst++;
-	      bnest++;
-	    }
-	  else if (s[1] == L(':') || s[1] == L('.') || s[1] == L('='))
-	    cchar = s[1];
-	  break;
-
-	/* `]' is not special if it's the first char (after a leading `!'
-	   or `^') in a bracket expression or if it's part of one of the
-	   special POSIX bracket expressions ([.SYM.], [=c=], [: ... :]) */
-	case L(']'):
-	  if (bnest)
-	    {
-	      if (cchar && s[-1] == cchar)
-		cchar = 0;
-	      else if (s != bfirst)
-		{
-		  bnest--;
-		  bfirst = 0;
-		}
-	    }
-	  break;
-
-	case L('('):
-	  if (bnest == 0)
-	    pnest++;
-	  break;
-
-	case L(')'):
-	  if (bnest == 0 && pnest-- <= 0)
-	    return ++s;
-	  break;
-
-	case L('|'):
-	  if (bnest == 0 && pnest == 0 && delim == L('|'))
-	    return ++s;
-	  break;
-	}
-    }
-
-  return (NULL);
-}
-
-/* Return 0 if dequoted pattern matches S in the current locale. */
-static int
-STRCOMPARE (p, pe, s, se)
-     CHAR *p, *pe, *s, *se;
-{
-  int ret;
-  CHAR c1, c2;
-  int l1, l2;
-
-  l1 = pe - p;
-  l2 = se - s;
-
-  if (l1 != l2)
-    return (FNM_NOMATCH);	/* unequal lengths, can't be identical */
-  
-  c1 = *pe;
-  c2 = *se;
-
-  if (c1 != 0)
-    *pe = '\0';
-  if (c2 != 0)
-    *se = '\0';
-    
-#if HAVE_MULTIBYTE || defined (HAVE_STRCOLL)
-  ret = STRCOLL ((XCHAR *)p, (XCHAR *)s);
-#else
-  ret = STRCMP ((XCHAR *)p, (XCHAR *)s);
-#endif
-
-  if (c1 != 0)
-    *pe = c1;
-  if (c2 != 0)
-    *se = c2;
-
-  return (ret == 0 ? ret : FNM_NOMATCH);
-}
-
-/* Match a ksh extended pattern specifier.  Return FNM_NOMATCH on failure or
-   0 on success.  This is handed the entire rest of the pattern and string
-   the first time an extended pattern specifier is encountered, so it calls
-   gmatch recursively. */
-static int
-EXTMATCH (xc, s, se, p, pe, flags)
-     INT xc;		/* select which operation */
-     CHAR *s, *se;
-     CHAR *p, *pe;
-     int flags;
-{
-  CHAR *prest;			/* pointer to rest of pattern */
-  CHAR *psub;			/* pointer to sub-pattern */
-  CHAR *pnext;			/* pointer to next sub-pattern */
-  CHAR *srest;			/* pointer to rest of string */
-  int m1, m2, xflags;		/* xflags = flags passed to recursive matches */
-
-#if DEBUG_MATCHING
-fprintf(stderr, "extmatch: xc = %c\n", xc);
-fprintf(stderr, "extmatch: s = %s; se = %s\n", s, se);
-fprintf(stderr, "extmatch: p = %s; pe = %s\n", p, pe);
-fprintf(stderr, "extmatch: flags = %d\n", flags);
-#endif
-
-  prest = PATSCAN (p + (*p == L('(')), pe, 0); /* ) */
-  if (prest == 0)
-    /* If PREST is 0, we failed to scan a valid pattern.  In this
-       case, we just want to compare the two as strings. */
-    return (STRCOMPARE (p - 1, pe, s, se));
-
-  switch (xc)
-    {
-    case L('+'):		/* match one or more occurrences */
-    case L('*'):		/* match zero or more occurrences */
-      /* If we can get away with no matches, don't even bother.  Just
-	 call GMATCH on the rest of the pattern and return success if
-	 it succeeds. */
-      if (xc == L('*') && (GMATCH (s, se, prest, pe, NULL, flags) == 0))
-	return 0;
-
-      /* OK, we have to do this the hard way.  First, we make sure one of
-	 the subpatterns matches, then we try to match the rest of the
-	 string. */
-      for (psub = p + 1; ; psub = pnext)
-	{
-	  pnext = PATSCAN (psub, pe, L('|'));
-	  for (srest = s; srest <= se; srest++)
-	    {
-	      /* Match this substring (S -> SREST) against this
-		 subpattern (psub -> pnext - 1) */
-	      m1 = GMATCH (s, srest, psub, pnext - 1, NULL, flags) == 0;
-	      /* OK, we matched a subpattern, so make sure the rest of the
-		 string matches the rest of the pattern.  Also handle
-		 multiple matches of the pattern. */
-	      if (m1)
-		{
-		  /* if srest > s, we are not at start of string */
-		  xflags = (srest > s) ? (flags & ~(FNM_PERIOD|FNM_DOTDOT)) : flags;
-		  m2 = (GMATCH (srest, se, prest, pe, NULL, xflags) == 0) ||
-			(s != srest && GMATCH (srest, se, p - 1, pe, NULL, xflags) == 0);
-		}
-	      if (m1 && m2)
-		return (0);
-	    }
-	  if (pnext == prest)
-	    break;
-	}
-      return (FNM_NOMATCH);
-
-    case L('?'):		/* match zero or one of the patterns */
-    case L('@'):		/* match one (or more) of the patterns */
-      /* If we can get away with no matches, don't even bother.  Just
-	 call gmatch on the rest of the pattern and return success if
-	 it succeeds. */
-      if (xc == L('?') && (GMATCH (s, se, prest, pe, NULL, flags) == 0))
-	return 0;
-
-      /* OK, we have to do this the hard way.  First, we see if one of
-	 the subpatterns matches, then, if it does, we try to match the
-	 rest of the string. */
-      for (psub = p + 1; ; psub = pnext)
-	{
-	  pnext = PATSCAN (psub, pe, L('|'));
-	  srest = (prest == pe) ? se : s;
-	  for ( ; srest <= se; srest++)
-	    {
-	      /* if srest > s, we are not at start of string */
-	      xflags = (srest > s) ? (flags & ~(FNM_PERIOD|FNM_DOTDOT)) : flags;
-	      if (GMATCH (s, srest, psub, pnext - 1, NULL, flags) == 0 &&
-		  GMATCH (srest, se, prest, pe, NULL, xflags) == 0)
-		return (0);
-	    }
-	  if (pnext == prest)
-	    break;
-	}
-      return (FNM_NOMATCH);
-
-    case '!':		/* match anything *except* one of the patterns */
-      for (srest = s; srest <= se; srest++)
-	{
-	  m1 = 0;
-	  for (psub = p + 1; ; psub = pnext)
-	    {
-	      pnext = PATSCAN (psub, pe, L('|'));
-	      /* If one of the patterns matches, just bail immediately. */
-	      if (m1 = (GMATCH (s, srest, psub, pnext - 1, NULL, flags) == 0))
-		break;
-	      if (pnext == prest)
-		break;
-	    }
-
-	  /* If nothing matched, but the string starts with a period and we
-	     need to match periods explicitly, don't return this as a match,
-	     even for negation. */
-	  if (m1 == 0 && (flags & FNM_PERIOD) && *s == '.')
-	    return (FNM_NOMATCH);
-
-	  if (m1 == 0 && (flags & FNM_DOTDOT) &&
-	      (SDOT_OR_DOTDOT (s) ||
-	       ((flags & FNM_PATHNAME) && s[-1] == L('/') && PDOT_OR_DOTDOT(s))))
-	    return (FNM_NOMATCH);
-
-	  /* if srest > s, we are not at start of string */
-	  xflags = (srest > s) ? (flags & ~(FNM_PERIOD|FNM_DOTDOT)) : flags;
-	  if (m1 == 0 && GMATCH (srest, se, prest, pe, NULL, xflags) == 0)
-	    return (0);
-	}
-      return (FNM_NOMATCH);
-    }
-
-  return (FNM_NOMATCH);
-}
-#endif /* EXTENDED_GLOB */
-
-#undef IS_CCLASS
-#undef FOLD
-#undef CHAR
-#undef U_CHAR
-#undef XCHAR
-#undef INT
-#undef INVALID
-#undef FCT
-#undef GMATCH
-#undef COLLSYM
-#undef PARSE_COLLSYM
-#undef PATSCAN
-#undef STRCOMPARE
-#undef EXTMATCH
-#undef DEQUOTE_PATHNAME
-#undef STRUCT
-#undef BRACKMATCH
-#undef STRCHR
-#undef STRCOLL
-#undef STRLEN
-#undef STRCMP
-#undef MEMCHR
-#undef COLLEQUIV
-#undef RANGECMP
-#undef ISDIRSEP
-#undef PATHSEP
-#undef PDOT_OR_DOTDOT
-#undef SDOT_OR_DOTDOT
-#undef L
diff --git a/third_party/bash/smatch.c b/third_party/bash/smatch.c
deleted file mode 100644
index e265c9571..000000000
--- a/third_party/bash/smatch.c
+++ /dev/null
@@ -1,638 +0,0 @@
-/* strmatch.c -- ksh-like extended pattern matching for the shell and filename
-		globbing. */
-
-/* Copyright (C) 1991-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-   
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <stdio.h>	/* for debugging */
-				
-#include "strmatch.h"
-#include "chartypes.h"
-
-#include "bashansi.h"
-#include "shmbutil.h"
-#include "xmalloc.h"
-
-#include <errno.h>
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#if FNMATCH_EQUIV_FALLBACK
-/* We don't include <fnmatch.h> in order to avoid namespace collisions; the
-   internal strmatch still uses the FNM_ constants. */
-extern int fnmatch (const char *, const char *, int);
-#endif
-
-/* First, compile `sm_loop.c' for single-byte characters. */
-#define CHAR	unsigned char
-#define U_CHAR	unsigned char
-#define XCHAR	char
-#define INT	int
-#define L(CS)	CS
-#define INVALID	-1
-
-#undef STREQ
-#undef STREQN
-#define STREQ(a, b) ((a)[0] == (b)[0] && strcmp(a, b) == 0)
-#define STREQN(a, b, n) ((a)[0] == (b)[0] && strncmp(a, b, n) == 0)
-
-#ifndef GLOBASCII_DEFAULT
-#  define GLOBASCII_DEFAULT 0
-#endif
-
-int glob_asciirange = GLOBASCII_DEFAULT;
-
-#if FNMATCH_EQUIV_FALLBACK
-/* Construct a string w1 = "c1" and a pattern w2 = "[[=c2=]]" and pass them
-   to fnmatch to see if wide characters c1 and c2 collate as members of the
-   same equivalence class. We can't really do this portably any other way */
-static int
-_fnmatch_fallback (s, p)
-     int s, p;			/* string char, patchar */
-{
-  char s1[2];			/* string */
-  char s2[8];			/* constructed pattern */
-
-  s1[0] = (unsigned char)s;
-  s1[1] = '\0';
-
-  /* reconstruct the pattern */
-  s2[0] = s2[1] = '[';
-  s2[2] = '=';
-  s2[3] = (unsigned char)p;
-  s2[4] = '=';
-  s2[5] = s2[6] = ']';
-  s2[7] = '\0';
-
-  return (fnmatch ((const char *)s2, (const char *)s1, 0));
-}
-#endif
-
-/* We use strcoll(3) for range comparisons in bracket expressions,
-   even though it can have unwanted side effects in locales
-   other than POSIX or US.  For instance, in the de locale, [A-Z] matches
-   all characters.  If GLOB_ASCIIRANGE is non-zero, and we're not forcing
-   the use of strcoll (e.g., for explicit collating symbols), we use
-   straight ordering as if in the C locale. */
-
-#if defined (HAVE_STRCOLL)
-/* Helper functions for collating symbol equivalence. */
-
-/* Return 0 if C1 == C2 or collates equally if FORCECOLL is non-zero. */
-static int
-charcmp (c1, c2, forcecoll)
-     int c1, c2;
-     int forcecoll;
-{
-  static char s1[2] = { ' ', '\0' };
-  static char s2[2] = { ' ', '\0' };
-  int ret;
-
-  /* Eight bits only.  Period. */
-  c1 &= 0xFF;
-  c2 &= 0xFF;
-
-  if (c1 == c2)
-    return (0);
-
-  if (forcecoll == 0 && glob_asciirange)
-    return (c1 - c2);
-
-  s1[0] = c1;
-  s2[0] = c2;
-
-  return (strcoll (s1, s2));
-}
-
-static int
-rangecmp (c1, c2, forcecoll)
-     int c1, c2;
-     int forcecoll;
-{
-  int r;
-
-  r = charcmp (c1, c2, forcecoll);
-
-  /* We impose a total ordering here by returning c1-c2 if charcmp returns 0 */
-  if (r != 0)
-    return r;
-  return (c1 - c2);		/* impose total ordering */
-}
-#else /* !HAVE_STRCOLL */
-#  define rangecmp(c1, c2, f)	((int)(c1) - (int)(c2))
-#endif /* !HAVE_STRCOLL */
-
-#if defined (HAVE_STRCOLL)
-/* Returns 1 if chars C and EQUIV collate equally in the current locale. */
-static int
-collequiv (c, equiv)
-     int c, equiv;
-{
-  if (charcmp (c, equiv, 1) == 0)
-    return 1;
-
-#if FNMATCH_EQUIV_FALLBACK
-  return (_fnmatch_fallback (c, equiv) == 0);
-#else
-  return 0;
-#endif
-  
-}
-#else
-#  define collequiv(c, equiv)	((c) == (equiv))
-#endif
-
-#define _COLLSYM	_collsym
-#define __COLLSYM	__collsym
-#define POSIXCOLL	posix_collsyms
-#include "collsyms.h"
-
-static int
-collsym (s, len)
-     CHAR *s;
-     int len;
-{
-  register struct _collsym *csp;
-  char *x;
-
-  x = (char *)s;
-  for (csp = posix_collsyms; csp->name; csp++)
-    {
-      if (STREQN(csp->name, x, len) && csp->name[len] == '\0')
-	return (csp->code);
-    }
-  if (len == 1)
-    return s[0];
-  return INVALID;
-}
-
-/* unibyte character classification */
-#if !defined (isascii) && !defined (HAVE_ISASCII)
-#  define isascii(c)	((unsigned int)(c) <= 0177)
-#endif
-
-enum char_class
-  {
-    CC_NO_CLASS = 0,
-    CC_ASCII, CC_ALNUM, CC_ALPHA, CC_BLANK, CC_CNTRL, CC_DIGIT, CC_GRAPH,
-    CC_LOWER, CC_PRINT, CC_PUNCT, CC_SPACE, CC_UPPER, CC_WORD, CC_XDIGIT
-  };
-
-static char const *const cclass_name[] =
-  {
-    "",
-    "ascii", "alnum", "alpha", "blank", "cntrl", "digit", "graph",
-    "lower", "print", "punct", "space", "upper", "word", "xdigit"
-  };
-
-#define N_CHAR_CLASS (sizeof(cclass_name) / sizeof (cclass_name[0]))
-
-static enum char_class
-is_valid_cclass (name)
-     const char *name;
-{
-  enum char_class ret;
-  int i;
-
-  ret = CC_NO_CLASS;
-
-  for (i = 1; i < N_CHAR_CLASS; i++)
-    {
-      if (STREQ (name, cclass_name[i]))
-	{
-	  ret = (enum char_class)i;
-	  break;
-	}
-    }
-
-  return ret;
-}
-
-static int
-cclass_test (c, char_class)
-     int c;
-     enum char_class char_class;
-{
-  int result;
-
-  switch (char_class)
-    {
-      case CC_ASCII:
-	result = isascii (c);
-	break;
-      case CC_ALNUM:
-	result = ISALNUM (c);
-	break;
-      case CC_ALPHA:
-	result = ISALPHA (c);
-	break;
-      case CC_BLANK:  
-	result = ISBLANK (c);
-	break;
-      case CC_CNTRL:
-	result = ISCNTRL (c);
-	break;
-      case CC_DIGIT:
-	result = ISDIGIT (c);
-	break;
-      case CC_GRAPH:
-	result = ISGRAPH (c);
-	break;
-      case CC_LOWER:
-	result = ISLOWER (c);
-	break;
-      case CC_PRINT: 
-	result = ISPRINT (c);
-	break;
-      case CC_PUNCT:
-	result = ISPUNCT (c);
-	break;
-      case CC_SPACE:
-	result = ISSPACE (c);
-	break;
-      case CC_UPPER:
-	result = ISUPPER (c);
-	break;
-      case CC_WORD:
-        result = (ISALNUM (c) || c == '_');
-	break;
-      case CC_XDIGIT:
-	result = ISXDIGIT (c);
-	break;
-      default:
-	result = -1;
-	break;
-    }
-
-  return result;  
-}
-	
-static int
-is_cclass (c, name)
-     int c;
-     const char *name;
-{
-  enum char_class char_class;
-  int result;
-
-  char_class = is_valid_cclass (name);
-  if (char_class == CC_NO_CLASS)
-    return -1;
-
-  result = cclass_test (c, char_class);
-  return (result);
-}
-
-/* Now include `sm_loop.c' for single-byte characters. */
-/* The result of FOLD is an `unsigned char' */
-# define FOLD(c) ((flags & FNM_CASEFOLD) \
-	? TOLOWER ((unsigned char)c) \
-	: ((unsigned char)c))
-
-#if !defined (__CYGWIN__)
-#  define ISDIRSEP(c)	((c) == '/')
-#else
-#  define ISDIRSEP(c)	((c) == '/' || (c) == '\\')
-#endif /* __CYGWIN__ */
-#define PATHSEP(c)	(ISDIRSEP(c) || (c) == 0)
-
-#  define PDOT_OR_DOTDOT(s)	(s[0] == '.' && (PATHSEP (s[1]) || (s[1] == '.' && PATHSEP (s[2]))))
-#  define SDOT_OR_DOTDOT(s)	(s[0] == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0)))
-
-#define FCT			internal_strmatch
-#define GMATCH			gmatch
-#define COLLSYM			collsym
-#define PARSE_COLLSYM		parse_collsym
-#define BRACKMATCH		brackmatch
-#define PATSCAN			glob_patscan
-#define STRCOMPARE		strcompare
-#define EXTMATCH		extmatch
-#define DEQUOTE_PATHNAME	udequote_pathname
-#define STRUCT			smat_struct
-#define STRCHR(S, C)		strchr((S), (C))
-#define MEMCHR(S, C, N)		memchr((S), (C), (N))
-#define STRCOLL(S1, S2)		strcoll((S1), (S2))
-#define STRLEN(S)		strlen(S)
-#define STRCMP(S1, S2)		strcmp((S1), (S2))
-#define RANGECMP(C1, C2, F)	rangecmp((C1), (C2), (F))
-#define COLLEQUIV(C1, C2)	collequiv((C1), (C2))
-#define CTYPE_T			enum char_class
-#define IS_CCLASS(C, S)		is_cclass((C), (S))
-#include "sm_loop.inc"
-
-#if HANDLE_MULTIBYTE
-
-#  define CHAR		wchar_t
-#  define U_CHAR	wint_t
-#  define XCHAR		wchar_t
-#  define INT		wint_t
-#  define L(CS)		L##CS
-#  define INVALID	WEOF
-
-#  undef STREQ
-#  undef STREQN
-#  define STREQ(s1, s2) ((wcscmp (s1, s2) == 0))
-#  define STREQN(a, b, n) ((a)[0] == (b)[0] && wcsncmp(a, b, n) == 0)
-
-extern char *mbsmbchar PARAMS((const char *));
-
-#if FNMATCH_EQUIV_FALLBACK
-/* Construct a string w1 = "c1" and a pattern w2 = "[[=c2=]]" and pass them
-   to fnmatch to see if wide characters c1 and c2 collate as members of the
-   same equivalence class. We can't really do this portably any other way */
-static int
-_fnmatch_fallback_wc (c1, c2)
-     wchar_t c1, c2;			/* string char, patchar */
-{
-  char w1[MB_LEN_MAX+1];		/* string */
-  char w2[MB_LEN_MAX+8];		/* constructed pattern */
-  int l1, l2;
-
-  l1 = wctomb (w1, c1);
-  if (l1 == -1)
-    return (2);
-  w1[l1] = '\0';
-
-  /* reconstruct the pattern */
-  w2[0] = w2[1] = '[';
-  w2[2] = '=';
-  l2 = wctomb (w2+3, c2);
-  if (l2 == -1)
-    return (2);
-  w2[l2+3] = '=';
-  w2[l2+4] = w2[l2+5] = ']';
-  w2[l2+6] = '\0';
-
-  return (fnmatch ((const char *)w2, (const char *)w1, 0));
-}
-#endif
-
-static int
-charcmp_wc (c1, c2, forcecoll)
-     wint_t c1, c2;
-     int forcecoll;
-{
-  static wchar_t s1[2] = { L' ', L'\0' };
-  static wchar_t s2[2] = { L' ', L'\0' };
-  int r;
-
-  if (c1 == c2)
-    return 0;
-
-  if (forcecoll == 0 && glob_asciirange && c1 <= UCHAR_MAX && c2 <= UCHAR_MAX)
-    return ((int)(c1 - c2));
-
-  s1[0] = c1;
-  s2[0] = c2;
-
-  return (wcscoll (s1, s2));
-}
-
-static int
-rangecmp_wc (c1, c2, forcecoll)
-     wint_t c1, c2;
-     int forcecoll;
-{
-  int r;
-
-  r = charcmp_wc (c1, c2, forcecoll);
-
-  /* We impose a total ordering here by returning c1-c2 if charcmp returns 0,
-     as we do above in the single-byte case. */
-  if (r != 0 || forcecoll)
-    return r;
-  return ((int)(c1 - c2));		/* impose total ordering */
-}
-
-/* Returns 1 if wide chars C and EQUIV collate equally in the current locale. */
-static int
-collequiv_wc (c, equiv)
-     wint_t c, equiv;
-{
-  wchar_t s, p;
-
-  if (charcmp_wc (c, equiv, 1) == 0)
-    return 1;
-
-#if FNMATCH_EQUIV_FALLBACK
-/* We check explicitly for success (fnmatch returns 0) to avoid problems if
-   our local definition of FNM_NOMATCH (strmatch.h) doesn't match the
-   system's (fnmatch.h). We don't care about error return values here. */
-
-  s = c;
-  p = equiv;
-  return (_fnmatch_fallback_wc (s, p) == 0);
-#else
-  return 0;
-#endif
-}
-
-/* Helper function for collating symbol. */
-#  define _COLLSYM	_collwcsym
-#  define __COLLSYM	__collwcsym
-#  define POSIXCOLL	posix_collwcsyms
-#  include "collsyms.h"
-
-static wint_t
-collwcsym (s, len)
-     wchar_t *s;
-     int len;
-{
-  register struct _collwcsym *csp;
-
-  for (csp = posix_collwcsyms; csp->name; csp++)
-    {
-      if (STREQN(csp->name, s, len) && csp->name[len] == L'\0')
-	return (csp->code);
-    }
-  if (len == 1)
-    return s[0];
-  return INVALID;
-}
-
-static int
-is_wcclass (wc, name)
-     wint_t wc;
-     wchar_t *name;
-{
-  char *mbs;
-  mbstate_t state;
-  size_t mbslength;
-  wctype_t desc;
-  int want_word;
-
-  if ((wctype ("ascii") == (wctype_t)0) && (wcscmp (name, L"ascii") == 0))
-    {
-      int c;
-
-      if ((c = wctob (wc)) == EOF)
-	return 0;
-      else
-        return (c <= 0x7F);
-    }
-
-  want_word = (wcscmp (name, L"word") == 0);
-  if (want_word)
-    name = L"alnum";
-
-  memset (&state, '\0', sizeof (mbstate_t));
-  mbs = (char *) malloc (wcslen(name) * MB_CUR_MAX + 1);
-  if (mbs == 0)
-    return -1;
-  mbslength = wcsrtombs (mbs, (const wchar_t **)&name, (wcslen(name) * MB_CUR_MAX + 1), &state);
-
-  if (mbslength == (size_t)-1 || mbslength == (size_t)-2)
-    {
-      free (mbs);
-      return -1;
-    }
-  desc = wctype (mbs);
-  free (mbs);
-
-  if (desc == (wctype_t)0)
-    return -1;
-
-  if (want_word)
-    return (iswctype (wc, desc) || wc == L'_');
-  else
-    return (iswctype (wc, desc));
-}
-
-/* Return 1 if there are no char class [:class:] expressions (degenerate case)
-   or only posix-specified (C locale supported) char class expressions in
-   PATTERN.  These are the ones where it's safe to punt to the single-byte
-   code, since wide character support allows locale-defined char classes.
-   This only uses single-byte code, but is only needed to support multibyte
-   locales. */
-static int
-posix_cclass_only (pattern)
-     char *pattern;
-{
-  char *p, *p1;
-  char cc[16];		/* sufficient for all valid posix char class names */
-  enum char_class valid;
-
-  p = pattern;
-  while (p = strchr (p, '['))
-    {
-      if (p[1] != ':')
-	{
-	  p++;
-	  continue;
-        }
-      p += 2;		/* skip past "[:" */
-      /* Find end of char class expression */
-      for (p1 = p; *p1;  p1++)
-	if (*p1 == ':' && p1[1] == ']')
-	  break;
-      if (*p1 == 0)	/* no char class expression found */
-	break;
-      /* Find char class name and validate it against posix char classes */
-      if ((p1 - p) >= sizeof (cc))
-	return 0;
-      bcopy (p, cc, p1 - p);
-      cc[p1 - p] = '\0';
-      valid = is_valid_cclass (cc);
-      if (valid == CC_NO_CLASS)
-	return 0;		/* found unrecognized char class name */
-
-      p = p1 + 2;		/* found posix char class name */
-    }
-    
-  return 1;			/* no char class names or only posix */
-}      
-
-/* Now include `sm_loop.c' for multibyte characters. */
-#define FOLD(c) ((flags & FNM_CASEFOLD) && iswupper (c) ? towlower (c) : (c))
-
-#  if !defined (__CYGWIN__)
-#    define ISDIRSEP(c)	((c) == L'/')
-#  else
-#    define ISDIRSEP(c)	((c) == L'/' || (c) == L'\\')
-#  endif /* __CYGWIN__ */
-#  define PATHSEP(c)	(ISDIRSEP(c) || (c) == L'\0')
-
-#  define PDOT_OR_DOTDOT(w)	(w[0] == L'.' && (PATHSEP(w[1]) || (w[1] == L'.' && PATHSEP(w[2]))))
-#  define SDOT_OR_DOTDOT(w)	(w[0] == L'.' && (w[1] == L'\0' || (w[1] == L'.' && w[2] == L'\0')))
-
-#define FCT			internal_wstrmatch
-#define GMATCH			gmatch_wc
-#define COLLSYM			collwcsym
-#define PARSE_COLLSYM		parse_collwcsym
-#define BRACKMATCH		brackmatch_wc
-#define PATSCAN			glob_patscan_wc
-#define STRCOMPARE		wscompare
-#define EXTMATCH		extmatch_wc
-#define DEQUOTE_PATHNAME	wcdequote_pathname
-#define STRUCT			wcsmat_struct
-#define STRCHR(S, C)		wcschr((S), (C))
-#define MEMCHR(S, C, N)		wmemchr((S), (C), (N))
-#define STRCOLL(S1, S2)		wcscoll((S1), (S2))
-#define STRLEN(S)		wcslen(S)
-#define STRCMP(S1, S2)		wcscmp((S1), (S2))
-#define RANGECMP(C1, C2, F)	rangecmp_wc((C1), (C2), (F))
-#define COLLEQUIV(C1, C2)	collequiv_wc((C1), (C2))
-#define CTYPE_T			enum char_class
-#define IS_CCLASS(C, S)		is_wcclass((C), (S))
-#include "sm_loop.inc"
-
-#endif /* HAVE_MULTIBYTE */
-
-int
-xstrmatch (pattern, string, flags)
-     char *pattern;
-     char *string;
-     int flags;
-{
-#if HANDLE_MULTIBYTE
-  int ret;
-  size_t n;
-  wchar_t *wpattern, *wstring;
-  size_t plen, slen, mplen, mslen;
-
-  if (MB_CUR_MAX == 1)
-    return (internal_strmatch ((unsigned char *)pattern, (unsigned char *)string, flags));
-
-  if (mbsmbchar (string) == 0 && mbsmbchar (pattern) == 0 && posix_cclass_only (pattern))
-    return (internal_strmatch ((unsigned char *)pattern, (unsigned char *)string, flags));
-
-  n = xdupmbstowcs (&wpattern, NULL, pattern);
-  if (n == (size_t)-1 || n == (size_t)-2)
-    return (internal_strmatch ((unsigned char *)pattern, (unsigned char *)string, flags));
-
-  n = xdupmbstowcs (&wstring, NULL, string);
-  if (n == (size_t)-1 || n == (size_t)-2)
-    {
-      free (wpattern);
-      return (internal_strmatch ((unsigned char *)pattern, (unsigned char *)string, flags));
-    }
-
-  ret = internal_wstrmatch (wpattern, wstring, flags);
-
-  free (wpattern);
-  free (wstring);
-
-  return ret;
-#else
-  return (internal_strmatch ((unsigned char *)pattern, (unsigned char *)string, flags));
-#endif /* !HANDLE_MULTIBYTE */
-}
diff --git a/third_party/bash/spell.c b/third_party/bash/spell.c
deleted file mode 100644
index 2ad89836b..000000000
--- a/third_party/bash/spell.c
+++ /dev/null
@@ -1,212 +0,0 @@
-/* spell.c -- spelling correction for pathnames. */
-
-/* Copyright (C) 2000-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#include "bashtypes.h"
-#include "posixdir.h"
-#include "posixstat.h"
-#if defined (HAVE_SYS_PARAM_H)
-#include <sys/param.h>
-#endif
-
-#include <stdio.h>
-
-#include "bashansi.h"
-#include "maxpath.h"
-#include "stdc.h"
-
-static int mindist PARAMS((char *, char *, char *));
-static int spdist PARAMS((char *, char *));
-
-/*
- * `spname' and its helpers are inspired by the code in "The UNIX
- * Programming Environment", Kernighan & Pike, Prentice-Hall 1984,
- * pages 209 - 213.
- */
-
-/*
- *	`spname' -- return a correctly spelled filename
- *
- *	int spname(char * oldname, char * newname)
- *	Returns:  -1 if no reasonable match found
- *		   0 if exact match found
- *		   1 if corrected
- *	Stores corrected name in `newname'.
- */
-int
-spname(oldname, newname)
-     char *oldname;
-     char *newname;
-{
-  char *op, *np, *p;
-  char guess[PATH_MAX + 1], best[PATH_MAX + 1];
-
-  op = oldname;
-  np = newname;
-  for (;;)
-    {
-      while (*op == '/')    /* Skip slashes */
-	*np++ = *op++;
-      *np = '\0';
-
-      if (*op == '\0')    /* Exact or corrected */
-	{
-	  /* `.' is rarely the right thing. */
-	  if (oldname[1] == '\0' && newname[1] == '\0' &&
-		oldname[0] != '.' && newname[0] == '.')
-	    return -1;
-	  return strcmp(oldname, newname) != 0;
-	}
-
-      /* Copy next component into guess */
-      for (p = guess; *op != '/' && *op != '\0'; op++)
-	if (p < guess + PATH_MAX)
-	  *p++ = *op;
-      *p = '\0';
-
-      if (mindist(newname, guess, best) >= 3)
-	return -1;  /* Hopeless */
-
-      /*
-       *  Add to end of newname
-       */
-      for (p = best; *np = *p++; np++)
-	;
-    }
-}
-
-/*
- *  Search directory for a guess
- */
-static int
-mindist(dir, guess, best)
-     char *dir;
-     char *guess;
-     char *best;
-{
-  DIR *fd;
-  struct dirent *dp;
-  int dist, x;
-
-  dist = 3;    /* Worst distance */
-  if (*dir == '\0')
-    dir = ".";
-
-  if ((fd = opendir(dir)) == NULL)
-    return dist;
-
-  while ((dp = readdir(fd)) != NULL)
-    {
-      /*
-       *  Look for a better guess.  If the new guess is as
-       *  good as the current one, we take it.  This way,
-       *  any single character match will be a better match
-       *  than ".".
-       */
-      x = spdist(dp->d_name, guess);
-      if (x <= dist && x != 3)
-	{
-	  strcpy(best, dp->d_name);
-	  dist = x;
-	  if (dist == 0)    /* Exact match */
-	    break;
-	}
-    }
-  (void)closedir(fd);
-
-  /* Don't return `.' */
-  if (best[0] == '.' && best[1] == '\0')
-    dist = 3;
-  return dist;
-}
-
-/*
- *  `spdist' -- return the "distance" between two names.
- *
- *  int spname(char * oldname, char * newname)
- *  Returns:  0 if strings are identical
- *      1 if two characters are transposed
- *      2 if one character is wrong, added or deleted
- *      3 otherwise
- */
-static int
-spdist(cur, new)
-     char *cur, *new;
-{
-  while (*cur == *new)
-    {
-      if (*cur == '\0')
-	return 0;    /* Exact match */
-      cur++;
-      new++;
-    }
-
-  if (*cur)
-    {
-      if (*new)
-	{
-	  if (cur[1] && new[1] && cur[0] == new[1] && cur[1] == new[0] && strcmp (cur + 2, new + 2) == 0)
-	    return 1;  /* Transposition */
-
-	  if (strcmp (cur + 1, new + 1) == 0)
-	    return 2;  /* One character mismatch */
-	}
-
-      if (strcmp(&cur[1], &new[0]) == 0)
-	return 2;    /* Extra character */
-    }
-
-  if (*new && strcmp(cur, new + 1) == 0)
-    return 2;      /* Missing character */
-
-  return 3;
-}
-
-char *
-dirspell (dirname)
-     char *dirname;
-{
-  int n;
-  char *guess;
-
-  n = (strlen (dirname) * 3 + 1) / 2 + 1;
-  guess = (char *)malloc (n);
-  if (guess == 0)
-    return 0;
-
-  switch (spname (dirname, guess))
-    {
-    case -1:
-    default:
-      free (guess);
-      return (char *)NULL;
-    case 0:
-    case 1:
-      return guess;
-    }
-}
diff --git a/third_party/bash/stat-time.h b/third_party/bash/stat-time.h
deleted file mode 100644
index e04cc619e..000000000
--- a/third_party/bash/stat-time.h
+++ /dev/null
@@ -1,214 +0,0 @@
-/* stat-related time functions.
-
-   Copyright (C) 2005, 2007, 2009-2012 Free Software Foundation, Inc.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
-
-/* Written by Paul Eggert.  */
-
-#ifndef STAT_TIME_H
-#define STAT_TIME_H 1
-
-#include <sys/stat.h>
-
-#if defined (TIME_H_DEFINES_STRUCT_TIMESPEC)
-#  include <time.h>
-#elif defined (SYS_TIME_H_DEFINES_STRUCT_TIMESPEC)
-#  include <sys/time.h>
-#elif defined (PTHREAD_H_DEFINES_STRUCT_TIMESPEC)
-#  include <pthread.h>
-#endif
-
-#ifndef HAVE_STRUCT_TIMESPEC
-struct timespec
-{
-  time_t tv_sec;
-  long int tv_nsec;
-};
-#endif
-
-/* STAT_TIMESPEC (ST, ST_XTIM) is the ST_XTIM member for *ST of type
-   struct timespec, if available.  If not, then STAT_TIMESPEC_NS (ST,
-   ST_XTIM) is the nanosecond component of the ST_XTIM member for *ST,
-   if available.  ST_XTIM can be st_atim, st_ctim, st_mtim, or st_birthtim
-   for access, status change, data modification, or birth (creation)
-   time respectively.
-
-   These macros are private to stat-time.h.  */
-#if defined HAVE_STRUCT_STAT_ST_ATIM_TV_NSEC
-# ifdef TYPEOF_STRUCT_STAT_ST_ATIM_IS_STRUCT_TIMESPEC
-#  define STAT_TIMESPEC(st, st_xtim) ((st)->st_xtim)
-# else
-#  define STAT_TIMESPEC_NS(st, st_xtim) ((st)->st_xtim.tv_nsec)
-# endif
-#elif defined HAVE_STRUCT_STAT_ST_ATIMESPEC_TV_NSEC
-# define STAT_TIMESPEC(st, st_xtim) ((st)->st_xtim##espec)
-#elif defined HAVE_STRUCT_STAT_ST_ATIMENSEC
-# define STAT_TIMESPEC_NS(st, st_xtim) ((st)->st_xtim##ensec)
-#elif defined HAVE_STRUCT_STAT_ST_ATIM_ST__TIM_TV_NSEC
-# define STAT_TIMESPEC_NS(st, st_xtim) ((st)->st_xtim.st__tim.tv_nsec)
-#endif
-
-/* Return the nanosecond component of *ST's access time.  */
-static inline long int
-get_stat_atime_ns (struct stat const *st)
-{
-# if defined STAT_TIMESPEC
-  return STAT_TIMESPEC (st, st_atim).tv_nsec;
-# elif defined STAT_TIMESPEC_NS
-  return STAT_TIMESPEC_NS (st, st_atim);
-# else
-  return 0;
-# endif
-}
-
-/* Return the nanosecond component of *ST's status change time.  */
-static inline long int
-get_stat_ctime_ns (struct stat const *st)
-{
-# if defined STAT_TIMESPEC
-  return STAT_TIMESPEC (st, st_ctim).tv_nsec;
-# elif defined STAT_TIMESPEC_NS
-  return STAT_TIMESPEC_NS (st, st_ctim);
-# else
-  return 0;
-# endif
-}
-
-/* Return the nanosecond component of *ST's data modification time.  */
-static inline long int
-get_stat_mtime_ns (struct stat const *st)
-{
-# if defined STAT_TIMESPEC
-  return STAT_TIMESPEC (st, st_mtim).tv_nsec;
-# elif defined STAT_TIMESPEC_NS
-  return STAT_TIMESPEC_NS (st, st_mtim);
-# else
-  return 0;
-# endif
-}
-
-/* Return the nanosecond component of *ST's birth time.  */
-static inline long int
-get_stat_birthtime_ns (struct stat const *st)
-{
-# if defined HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC
-  return STAT_TIMESPEC (st, st_birthtim).tv_nsec;
-# elif defined HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC
-  return STAT_TIMESPEC_NS (st, st_birthtim);
-# else
-  /* Avoid a "parameter unused" warning.  */
-  (void) st;
-  return 0;
-# endif
-}
-
-/* Return *ST's access time.  */
-static inline struct timespec
-get_stat_atime (struct stat const *st)
-{
-#ifdef STAT_TIMESPEC
-  return STAT_TIMESPEC (st, st_atim);
-#else
-  struct timespec t;
-  t.tv_sec = st->st_atime;
-  t.tv_nsec = get_stat_atime_ns (st);
-  return t;
-#endif
-}
-
-/* Return *ST's status change time.  */
-static inline struct timespec
-get_stat_ctime (struct stat const *st)
-{
-#ifdef STAT_TIMESPEC
-  return STAT_TIMESPEC (st, st_ctim);
-#else
-  struct timespec t;
-  t.tv_sec = st->st_ctime;
-  t.tv_nsec = get_stat_ctime_ns (st);
-  return t;
-#endif
-}
-
-/* Return *ST's data modification time.  */
-static inline struct timespec
-get_stat_mtime (struct stat const *st)
-{
-#ifdef STAT_TIMESPEC
-  return STAT_TIMESPEC (st, st_mtim);
-#else
-  struct timespec t;
-  t.tv_sec = st->st_mtime;
-  t.tv_nsec = get_stat_mtime_ns (st);
-  return t;
-#endif
-}
-
-static inline int
-timespec_cmp (struct timespec a, struct timespec b)
-{
-  return (a.tv_sec < b.tv_sec
-  	    ? -1
-	    : (a.tv_sec > b.tv_sec
-		 ? 1
-		 : (int) (a.tv_nsec - b.tv_nsec)));
-}
-
-/* Return *ST's birth time, if available; otherwise return a value
-   with tv_sec and tv_nsec both equal to -1.  */
-static inline struct timespec
-get_stat_birthtime (struct stat const *st)
-{
-  struct timespec t;
-
-#if (defined HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC \
-     || defined HAVE_STRUCT_STAT_ST_BIRTHTIM_TV_NSEC)
-  t = STAT_TIMESPEC (st, st_birthtim);
-#elif defined HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC
-  t.tv_sec = st->st_birthtime;
-  t.tv_nsec = st->st_birthtimensec;
-#elif (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
-  /* Native Windows platforms (but not Cygwin) put the "file creation
-     time" in st_ctime (!).  See
-     <http://msdn2.microsoft.com/de-de/library/14h5k7ff(VS.80).aspx>.  */
-  t.tv_sec = st->st_ctime;
-  t.tv_nsec = 0;
-#else
-  /* Birth time is not supported.  */
-  t.tv_sec = -1;
-  t.tv_nsec = -1;
-  /* Avoid a "parameter unused" warning.  */
-  (void) st;
-#endif
-
-#if (defined HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC \
-     || defined HAVE_STRUCT_STAT_ST_BIRTHTIM_TV_NSEC \
-     || defined HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC)
-  /* FreeBSD and NetBSD sometimes signal the absence of knowledge by
-     using zero.  Attempt to work around this problem.  Alas, this can
-     report failure even for valid time stamps.  Also, NetBSD
-     sometimes returns junk in the birth time fields; work around this
-     bug if it is detected.  */
-  if (! (t.tv_sec && 0 <= t.tv_nsec && t.tv_nsec < 1000000000))
-    {
-      t.tv_sec = -1;
-      t.tv_nsec = -1;
-    }
-#endif
-
-  return t;
-}
-
-#endif
diff --git a/third_party/bash/stdc.h b/third_party/bash/stdc.h
deleted file mode 100644
index 38516ae5d..000000000
--- a/third_party/bash/stdc.h
+++ /dev/null
@@ -1,89 +0,0 @@
-/* stdc.h -- macros to make source compile on both ANSI C and K&R C
-   compilers. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_STDC_H_)
-#define _STDC_H_
-
-/* Adapted from BSD /usr/include/sys/cdefs.h. */
-
-/* A function can be defined using prototypes and compile on both ANSI C
-   and traditional C compilers with something like this:
-	extern char *func PARAMS((char *, char *, int)); */
-
-#if !defined (PARAMS)
-#  if defined (__STDC__) || defined (__GNUC__) || defined (__cplusplus) || defined (PROTOTYPES)
-#    define PARAMS(protos) protos
-#  else 
-#    define PARAMS(protos) ()
-#  endif
-#endif
-
-/* Fortify, at least, has trouble with this definition */
-#if defined (HAVE_STRINGIZE)
-#  define CPP_STRING(x) #x
-#else
-#  define CPP_STRING(x) "x"
-#endif
-
-#if !defined (__STDC__)
-
-#if defined (__GNUC__)		/* gcc with -traditional */
-#  if !defined (signed)
-#    define signed __signed
-#  endif
-#  if !defined (volatile)
-#    define volatile __volatile
-#  endif
-#else /* !__GNUC__ */
-#  if !defined (inline)
-#    define inline
-#  endif
-#  if !defined (signed)
-#    define signed
-#  endif
-#  if !defined (volatile)
-#    define volatile
-#  endif
-#endif /* !__GNUC__ */
-
-#endif /* !__STDC__ */
-
-#ifndef __attribute__
-#  if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8)
-#    define __attribute__(x)
-#  endif
-#endif
-
-/* For those situations when gcc handles inlining a particular function but
-   other compilers complain. */
-#ifdef __GNUC__
-#  define INLINE inline
-#else
-#  define INLINE
-#endif
-
-#if defined (PREFER_STDARG)
-#  define SH_VA_START(va, arg)  va_start(va, arg)
-#else
-#  define SH_VA_START(va, arg)  va_start(va)
-#endif
-
-#endif /* !_STDC_H_ */
diff --git a/third_party/bash/stringlib.c b/third_party/bash/stringlib.c
deleted file mode 100644
index 5f25fffd6..000000000
--- a/third_party/bash/stringlib.c
+++ /dev/null
@@ -1,295 +0,0 @@
-/* stringlib.c - Miscellaneous string functions. */
-
-/* Copyright (C) 1996-2009 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include <stdio.h>
-#include "chartypes.h"
-
-#include "shell.h"
-#include "pathexp.h"
-
-#include "glob.h"
-
-#if defined (EXTENDED_GLOB)
-#  include "strmatch.h"
-#endif
-
-/* **************************************************************** */
-/*								    */
-/*		Functions to manage arrays of strings		    */
-/*								    */
-/* **************************************************************** */
-
-/* Find STRING in ALIST, a list of string key/int value pairs.  If FLAGS
-   is 1, STRING is treated as a pattern and matched using strmatch. */
-int
-find_string_in_alist (string, alist, flags)
-     char *string;
-     STRING_INT_ALIST *alist;
-     int flags;
-{
-  register int i;
-  int r;
-
-  for (i = r = 0; alist[i].word; i++)
-    {
-#if defined (EXTENDED_GLOB)
-      if (flags)
-	r = strmatch (alist[i].word, string, FNM_EXTMATCH) != FNM_NOMATCH;
-      else
-#endif
-	r = STREQ (string, alist[i].word);
-
-      if (r)
-	return (alist[i].token);
-    }
-  return -1;
-}
-
-/* Find TOKEN in ALIST, a list of string/int value pairs.  Return the
-   corresponding string.  Allocates memory for the returned
-   string.  FLAGS is currently ignored, but reserved. */
-char *
-find_token_in_alist (token, alist, flags)
-     int token;
-     STRING_INT_ALIST *alist;
-     int flags;
-{
-  register int i;
-
-  for (i = 0; alist[i].word; i++)
-    {
-      if (alist[i].token == token)
-        return (savestring (alist[i].word));
-    }
-  return ((char *)NULL);
-}
-
-int
-find_index_in_alist (string, alist, flags)
-     char *string;
-     STRING_INT_ALIST *alist;
-     int flags;
-{
-  register int i;
-  int r;
-
-  for (i = r = 0; alist[i].word; i++)
-    {
-#if defined (EXTENDED_GLOB)
-      if (flags)
-	r = strmatch (alist[i].word, string, FNM_EXTMATCH) != FNM_NOMATCH;
-      else
-#endif
-	r = STREQ (string, alist[i].word);
-
-      if (r)
-	return (i);
-    }
-
-  return -1;
-}
-
-/* **************************************************************** */
-/*								    */
-/*		    String Management Functions			    */
-/*								    */
-/* **************************************************************** */
-
-/* Cons a new string from STRING starting at START and ending at END,
-   not including END. */
-char *
-substring (string, start, end)
-     const char *string;
-     int start, end;
-{
-  register int len;
-  register char *result;
-
-  len = end - start;
-  result = (char *)xmalloc (len + 1);
-  memcpy (result, string + start, len);
-  result[len] = '\0';
-  return (result);
-}
-
-/* Replace occurrences of PAT with REP in STRING.  If GLOBAL is non-zero,
-   replace all occurrences, otherwise replace only the first.
-   This returns a new string; the caller should free it. */
-char *
-strsub (string, pat, rep, global)
-     char *string, *pat, *rep;
-     int global;
-{
-  size_t patlen, replen, templen, tempsize, i;
-  int repl;
-  char *temp, *r;
-
-  patlen = strlen (pat);
-  replen = strlen (rep);
-  for (temp = (char *)NULL, i = templen = tempsize = 0, repl = 1; string[i]; )
-    {
-      if (repl && STREQN (string + i, pat, patlen))
-	{
-	  if (replen)
-	    RESIZE_MALLOCED_BUFFER (temp, templen, replen, tempsize, (replen * 2));
-
-	  for (r = rep; *r; )	/* can rep == "" */
-	    temp[templen++] = *r++;
-
-	  i += patlen ? patlen : 1;	/* avoid infinite recursion */
-	  repl = global != 0;
-	}
-      else
-	{
-	  RESIZE_MALLOCED_BUFFER (temp, templen, 1, tempsize, 16);
-	  temp[templen++] = string[i++];
-	}
-    }
-  if (temp)
-    temp[templen] = 0;
-  else
-    temp = savestring (string);
-  return (temp);
-}
-
-/* Replace all instances of C in STRING with TEXT.  TEXT may be empty or
-   NULL.  If (FLAGS & 1) is non-zero, we quote the replacement text for
-   globbing.  Backslash may be used to quote C. If (FLAGS & 2) we allow
-   backslash to escape backslash as well. */
-char *
-strcreplace (string, c, text, flags)
-     char *string;
-     int c;
-     const char *text;
-     int flags;
-{
-  char *ret, *p, *r, *t;
-  size_t len, rlen, ind, tlen;
-  int do_glob, escape_backslash;
-
-  do_glob = flags & 1;
-  escape_backslash = flags & 2;
-
-  len = STRLEN (text);
-  rlen = len + strlen (string) + 2;
-  ret = (char *)xmalloc (rlen);
-
-  for (p = string, r = ret; p && *p; )
-    {
-      if (*p == c)
-	{
-	  if (len)
-	    {
-	      ind = r - ret;
-	      if (do_glob && (glob_pattern_p (text) || strchr (text, '\\')))
-		{
-		  t = quote_globbing_chars (text);
-		  tlen = strlen (t);
-		  RESIZE_MALLOCED_BUFFER (ret, ind, tlen, rlen, rlen);
-		  r = ret + ind;	/* in case reallocated */
-		  strcpy (r, t);
-		  r += tlen;
-		  free (t);
-		}
-	      else
-		{
-		  RESIZE_MALLOCED_BUFFER (ret, ind, len, rlen, rlen);
-		  r = ret + ind;	/* in case reallocated */
-		  strcpy (r, text);
-		  r += len;
-		}
-	    }
-	  p++;
-	  continue;
-	}
-
-      if (*p == '\\' && p[1] == c)
-	p++;
-      else if (escape_backslash && *p == '\\' && p[1] == '\\')
-	p++;
-
-      ind = r - ret;
-      RESIZE_MALLOCED_BUFFER (ret, ind, 2, rlen, rlen);
-      r = ret + ind;			/* in case reallocated */
-      *r++ = *p++;
-    }
-  *r = '\0';
-
-  return ret;
-}
-
-#ifdef INCLUDE_UNUSED
-/* Remove all leading whitespace from STRING.  This includes
-   newlines.  STRING should be terminated with a zero. */
-void
-strip_leading (string)
-     char *string;
-{
-  char *start = string;
-
-  while (*string && (whitespace (*string) || *string == '\n'))
-    string++;
-
-  if (string != start)
-    {
-      int len = strlen (string);
-      FASTCOPY (string, start, len);
-      start[len] = '\0';
-    }
-}
-#endif
-
-/* Remove all trailing whitespace from STRING.  This includes
-   newlines.  If NEWLINES_ONLY is non-zero, only trailing newlines
-   are removed.  STRING should be terminated with a zero. */
-void
-strip_trailing (string, len, newlines_only)
-     char *string;
-     int len;
-     int newlines_only;
-{
-  while (len >= 0)
-    {
-      if ((newlines_only && string[len] == '\n') ||
-	  (!newlines_only && whitespace (string[len])))
-	len--;
-      else
-	break;
-    }
-  string[len + 1] = '\0';
-}
-
-/* A wrapper for bcopy that can be prototyped in general.h */
-void
-xbcopy (s, d, n)
-     char *s, *d;
-     int n;
-{
-  FASTCOPY (s, d, n);
-}
diff --git a/third_party/bash/stringlist.c b/third_party/bash/stringlist.c
deleted file mode 100644
index 0ad6177b9..000000000
--- a/third_party/bash/stringlist.c
+++ /dev/null
@@ -1,297 +0,0 @@
-/* stringlist.c - functions to handle a generic `list of strings' structure */
-
-/* Copyright (C) 2000-2019 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "bashansi.h"
-
-#include "shell.h"
-
-#ifdef STRDUP
-#  undef STRDUP
-#endif
-#define STRDUP(x)	((x) ? savestring (x) : (char *)NULL)
-
-/* Allocate a new STRINGLIST, with room for N strings. */
-
-STRINGLIST *
-strlist_create (n)
-     int n;
-{
-  STRINGLIST *ret;
-  register int i;
-
-  ret = (STRINGLIST *)xmalloc (sizeof (STRINGLIST));
-  if (n)
-    {
-      ret->list = strvec_create (n+1);
-      ret->list_size = n;
-      for (i = 0; i < n; i++)
-	ret->list[i] = (char *)NULL;
-    }
-  else
-    {
-      ret->list = (char **)NULL;
-      ret->list_size = 0;
-    }
-  ret->list_len = 0;
-  return ret;
-}
-
-STRINGLIST *
-strlist_resize (sl, n)
-     STRINGLIST *sl;
-     int n;
-{
-  register int i;
-
-  if (sl == 0)
-    return (sl = strlist_create (n));
-
-  if (n > sl->list_size)
-    {
-      sl->list = strvec_resize (sl->list, n + 1);
-      for (i = sl->list_size; i <= n; i++)
-	sl->list[i] = (char *)NULL;
-      sl->list_size = n;
-    }
-  return sl;
-}
-
-void
-strlist_flush (sl)
-     STRINGLIST *sl;
-{
-  if (sl == 0 || sl->list == 0)
-    return;
-  strvec_flush (sl->list);
-  sl->list_len = 0;
-}
-  
-void
-strlist_dispose (sl)
-     STRINGLIST *sl;
-{
-  if (sl == 0)
-    return;
-  if (sl->list)
-    strvec_dispose (sl->list);
-  free (sl);
-}
-
-int
-strlist_remove (sl, s)
-     STRINGLIST *sl;
-     char *s;
-{
-  int r;
-
-  if (sl == 0 || sl->list == 0 || sl->list_len == 0)
-    return 0;
-
-  r = strvec_remove (sl->list, s);
-  if (r)
-    sl->list_len--;
-  return r;
-}
-
-STRINGLIST *
-strlist_copy (sl)
-     STRINGLIST *sl;
-{
-  STRINGLIST *new;
-  register int i;
-
-  if (sl == 0)
-    return ((STRINGLIST *)0);
-  new = strlist_create (sl->list_size);
-  /* I'd like to use strvec_copy, but that doesn't copy everything. */
-  if (sl->list)
-    {
-      for (i = 0; i < sl->list_size; i++)
-	new->list[i] = STRDUP (sl->list[i]);
-    }
-  new->list_size = sl->list_size;
-  new->list_len = sl->list_len;
-  /* just being careful */
-  if (new->list)
-    new->list[new->list_len] = (char *)NULL;
-  return new;
-}
-
-/* Return a new STRINGLIST with everything from M1 and M2. */
-
-STRINGLIST *
-strlist_merge (m1, m2)
-     STRINGLIST *m1, *m2;
-{
-  STRINGLIST *sl;
-  int i, n, l1, l2;
-
-  l1 = m1 ? m1->list_len : 0;
-  l2 = m2 ? m2->list_len : 0;
-
-  sl = strlist_create (l1 + l2 + 1);
-  for (i = n = 0; i < l1; i++, n++)
-    sl->list[n] = STRDUP (m1->list[i]);
-  for (i = 0; i < l2; i++, n++)
-    sl->list[n] = STRDUP (m2->list[i]);
-  sl->list_len = n;
-  sl->list[n] = (char *)NULL;
-  return (sl);
-}
-
-/* Make STRINGLIST M1 contain everything in M1 and M2. */
-STRINGLIST *
-strlist_append (m1, m2)
-     STRINGLIST *m1, *m2;
-{
-  register int i, n, len1, len2;
-
-  if (m1 == 0)
-    return (m2 ? strlist_copy (m2) : (STRINGLIST *)0);
-
-  len1 = m1->list_len;
-  len2 = m2 ? m2->list_len : 0;
-
-  if (len2)
-    {
-      m1 = strlist_resize (m1, len1 + len2 + 1);
-      for (i = 0, n = len1; i < len2; i++, n++)
-	m1->list[n] = STRDUP (m2->list[i]);
-      m1->list[n] = (char *)NULL;
-      m1->list_len = n;
-    }
-
-  return m1;
-}
-
-STRINGLIST *
-strlist_prefix_suffix (sl, prefix, suffix)
-     STRINGLIST *sl;
-     char *prefix, *suffix;
-{
-  int plen, slen, tlen, llen, i;
-  char *t;
-
-  if (sl == 0 || sl->list == 0 || sl->list_len == 0)
-    return sl;
-
-  plen = STRLEN (prefix);
-  slen = STRLEN (suffix);
-
-  if (plen == 0 && slen == 0)
-    return (sl);
-
-  for (i = 0; i < sl->list_len; i++)
-    {
-      llen = STRLEN (sl->list[i]);
-      tlen = plen + llen + slen + 1;
-      t = (char *)xmalloc (tlen + 1);
-      if (plen)
-	strcpy (t, prefix);
-      strcpy (t + plen, sl->list[i]);
-      if (slen)
-	strcpy (t + plen + llen, suffix);
-      free (sl->list[i]);
-      sl->list[i] = t;
-    }
-
-  return (sl);	 
-}
-   
-void
-strlist_print (sl, prefix)
-     STRINGLIST *sl;
-     char *prefix;
-{
-  register int i;
-
-  if (sl == 0)
-    return;
-  for (i = 0; i < sl->list_len; i++)
-    printf ("%s%s\n", prefix ? prefix : "", sl->list[i]);
-}
-
-void
-strlist_walk (sl, func)
-     STRINGLIST *sl;
-     sh_strlist_map_func_t *func;
-{
-  register int i;
-
-  if (sl == 0)
-    return;
-  for (i = 0; i < sl->list_len; i++)
-    if ((*func)(sl->list[i]) < 0)
-      break;
-} 
-     
-void
-strlist_sort (sl)
-     STRINGLIST *sl;
-{
-  if (sl == 0 || sl->list_len == 0 || sl->list == 0)
-    return;
-  strvec_sort (sl->list, 0);
-}
-
-STRINGLIST *
-strlist_from_word_list (list, alloc, starting_index, ip)
-     WORD_LIST *list;
-     int alloc, starting_index, *ip;
-{
-  STRINGLIST *ret;
-  int slen, len;
-
-  if (list == 0)
-    {
-      if (ip)
-        *ip = 0;
-      return ((STRINGLIST *)0);
-    }
-  slen = list_length (list);
-  ret = (STRINGLIST *)xmalloc (sizeof (STRINGLIST));
-  ret->list = strvec_from_word_list (list, alloc, starting_index, &len);
-  ret->list_size = slen + starting_index;
-  ret->list_len = len;
-  if (ip)
-    *ip = len;
-  return ret;
-}
-
-WORD_LIST *
-strlist_to_word_list (sl, alloc, starting_index)
-     STRINGLIST *sl;
-     int alloc, starting_index;
-{
-  WORD_LIST *list;
-
-  if (sl == 0 || sl->list == 0)
-    return ((WORD_LIST *)NULL);
-
-  list = strvec_to_word_list (sl->list, alloc, starting_index);
-  return list;
-}
diff --git a/third_party/bash/stringvec.c b/third_party/bash/stringvec.c
deleted file mode 100644
index 52693c6e3..000000000
--- a/third_party/bash/stringvec.c
+++ /dev/null
@@ -1,272 +0,0 @@
-/* stringvec.c - functions for managing arrays of strings. */
-
-/* Copyright (C) 2000-2002 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include <stdio.h>
-#include "chartypes.h"
-
-#include "shell.h"
-
-/* Allocate an array of strings with room for N members. */
-char **
-strvec_create (n)
-     int n;
-{
-  return ((char **)xmalloc ((n) * sizeof (char *)));
-}
-
-/* Allocate an array of strings with room for N members. */
-char **
-strvec_mcreate (n)
-     int n;
-{
-  return ((char **)malloc ((n) * sizeof (char *)));
-}
-
-char **
-strvec_resize (array, nsize)
-     char **array;
-     int nsize;
-{
-  return ((char **)xrealloc (array, nsize * sizeof (char *)));
-}
-
-char **
-strvec_mresize (array, nsize)
-     char **array;
-     int nsize;
-{
-  return ((char **)realloc (array, nsize * sizeof (char *)));
-}
-
-/* Return the length of ARRAY, a NULL terminated array of char *. */
-int
-strvec_len (array)
-     char **array;
-{
-  register int i;
-
-  for (i = 0; array[i]; i++);
-  return (i);
-}
-
-/* Free the contents of ARRAY, a NULL terminated array of char *. */
-void
-strvec_flush (array)
-     char **array;
-{
-  register int i;
-
-  if (array == 0)
-    return;
-
-  for (i = 0; array[i]; i++)
-    free (array[i]);
-}
-
-void
-strvec_dispose (array)
-     char **array;
-{
-  if (array == 0)
-    return;
-
-  strvec_flush (array);
-  free (array);
-}
-
-int
-strvec_remove (array, name)
-     char **array, *name;
-{
-  register int i, j;
-  char *x;
-
-  if (array == 0)
-    return 0;
-
-  for (i = 0; array[i]; i++)
-    if (STREQ (name, array[i]))
-      {
-	x = array[i];
-	for (j = i; array[j]; j++)
-	  array[j] = array[j + 1];
-	free (x);
-	return 1;
-      }
-  return 0;
-}
-
-/* Find NAME in ARRAY.  Return the index of NAME, or -1 if not present.
-   ARRAY should be NULL terminated. */
-int
-strvec_search (array, name)
-     char **array, *name;
-{
-  int i;
-
-  for (i = 0; array[i]; i++)
-    if (STREQ (name, array[i]))
-      return (i);
-
-  return (-1);
-}
-
-/* Allocate and return a new copy of ARRAY and its contents. */
-char **
-strvec_copy (array)
-     char **array;
-{
-  register int i;
-  int len;
-  char **ret;
-
-  len = strvec_len (array);
-
-  ret = (char **)xmalloc ((len + 1) * sizeof (char *));
-  for (i = 0; array[i]; i++)
-    ret[i] = savestring (array[i]);
-  ret[i] = (char *)NULL;
-
-  return (ret);
-}
-
-/* Comparison routine for use by qsort that conforms to the new Posix
-   requirements (http://austingroupbugs.net/view.php?id=1070).
-
-   Perform a bytewise comparison if *S1 and *S2 collate equally. */
-int
-strvec_posixcmp (s1, s2)
-     register char **s1, **s2;
-{
-  int result;
-
-#if defined (HAVE_STRCOLL)
-   result = strcoll (*s1, *s2);
-   if (result != 0)
-     return result;
-#endif
-
-  if ((result = **s1 - **s2) == 0)
-    result = strcmp (*s1, *s2);
-
-  return (result);
-}
-
-/* Comparison routine for use with qsort() on arrays of strings.  Uses
-   strcoll(3) if available, otherwise it uses strcmp(3). */
-int
-strvec_strcmp (s1, s2)
-     register char **s1, **s2;
-{
-#if defined (HAVE_STRCOLL)
-   return (strcoll (*s1, *s2));
-#else /* !HAVE_STRCOLL */
-  int result;
-
-  if ((result = **s1 - **s2) == 0)
-    result = strcmp (*s1, *s2);
-
-  return (result);
-#endif /* !HAVE_STRCOLL */
-}
-
-/* Sort ARRAY, a null terminated array of pointers to strings. */
-void
-strvec_sort (array, posix)
-     char **array;
-     int posix;
-{
-  if (posix)
-    qsort (array, strvec_len (array), sizeof (char *), (QSFUNC *)strvec_posixcmp);
-  else
-    qsort (array, strvec_len (array), sizeof (char *), (QSFUNC *)strvec_strcmp);
-}
-
-/* Cons up a new array of words.  The words are taken from LIST,
-   which is a WORD_LIST *.  If ALLOC is true, everything is malloc'ed,
-   so you should free everything in this array when you are done.
-   The array is NULL terminated.  If IP is non-null, it gets the
-   number of words in the returned array.  STARTING_INDEX says where
-   to start filling in the returned array; it can be used to reserve
-   space at the beginning of the array. */
-
-char **
-strvec_from_word_list (list, alloc, starting_index, ip)
-     WORD_LIST *list;
-     int alloc, starting_index, *ip;
-{
-  int count;
-  char **array;
-
-  count = list_length (list);
-  array = (char **)xmalloc ((1 + count + starting_index) * sizeof (char *));
-
-  for (count = 0; count < starting_index; count++)
-    array[count] = (char *)NULL;
-  for (count = starting_index; list; count++, list = list->next)
-    array[count] = alloc ? savestring (list->word->word) : list->word->word;
-  array[count] = (char *)NULL;
-
-  if (ip)
-    *ip = count;
-  return (array);
-}
-
-/* Convert an array of strings into the form used internally by the shell.
-   ALLOC means to allocate new storage for each WORD_DESC in the returned
-   list rather than copy the values in ARRAY.  STARTING_INDEX says where
-   in ARRAY to begin. */
-
-WORD_LIST *
-strvec_to_word_list (array, alloc, starting_index)
-     char **array;
-     int alloc, starting_index;
-{
-  WORD_LIST *list;
-  WORD_DESC *w;
-  int i, count;
-
-  if (array == 0 || array[0] == 0)
-    return (WORD_LIST *)NULL;
-
-  for (count = 0; array[count]; count++)
-    ;
-
-  for (i = starting_index, list = (WORD_LIST *)NULL; i < count; i++)
-    {
-      w = make_bare_word (alloc ? array[i] : "");
-      if (alloc == 0)
-	{
-	  free (w->word);
-	  w->word = array[i];
-	}
-      list = make_word_list (w, list);
-    }
-  return (REVERSE_LIST (list, WORD_LIST *));
-}
diff --git a/third_party/bash/strmatch.c b/third_party/bash/strmatch.c
deleted file mode 100644
index 0de45eb41..000000000
--- a/third_party/bash/strmatch.c
+++ /dev/null
@@ -1,79 +0,0 @@
-/* strmatch.c -- ksh-like extended pattern matching for the shell and filename
-		globbing. */
-
-/* Copyright (C) 1991-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-   
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "stdc.h"
-#include "strmatch.h"
-
-extern int xstrmatch PARAMS((char *, char *, int));
-#if defined (HANDLE_MULTIBYTE)
-extern int internal_wstrmatch PARAMS((wchar_t *, wchar_t *, int));
-#endif
-
-int
-strmatch (pattern, string, flags)
-     char *pattern;
-     char *string;
-     int flags;
-{
-  if (string == 0 || pattern == 0)
-    return FNM_NOMATCH;
-
-  return (xstrmatch (pattern, string, flags));
-}
-
-#if defined (HANDLE_MULTIBYTE)
-int
-wcsmatch (wpattern, wstring, flags)
-     wchar_t *wpattern;
-     wchar_t *wstring;
-     int flags;
-{
-  if (wstring == 0 || wpattern == 0)
-    return (FNM_NOMATCH);
-
-  return (internal_wstrmatch (wpattern, wstring, flags));
-}
-#endif
-
-#ifdef TEST
-main (c, v)
-     int c;
-     char **v;
-{
-  char *string, *pat;
-
-  string = v[1];
-  pat = v[2];
-
-  if (strmatch (pat, string, 0) == 0)
-    {
-      printf ("%s matches %s\n", string, pat);
-      exit (0);
-    }
-  else
-    {
-      printf ("%s does not match %s\n", string, pat);
-      exit (1);
-    }
-}
-#endif
diff --git a/third_party/bash/strmatch.h b/third_party/bash/strmatch.h
deleted file mode 100644
index b1efad907..000000000
--- a/third_party/bash/strmatch.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/* Copyright (C) 1991-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne-Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef	_STRMATCH_H
-#define	_STRMATCH_H	1
-
-#include "config.h"
-
-#include "stdc.h"
-
-/* We #undef these before defining them because some losing systems
-   (HP-UX A.08.07 for example) define these in <unistd.h>.  */
-#undef  FNM_PATHNAME
-#undef  FNM_NOESCAPE
-#undef  FNM_PERIOD
-
-/* Bits set in the FLAGS argument to `strmatch'.  */
-
-/* standard flags are like fnmatch(3). */
-#define	FNM_PATHNAME	(1 << 0) /* No wildcard can ever match `/'.  */
-#define	FNM_NOESCAPE	(1 << 1) /* Backslashes don't quote special chars.  */
-#define	FNM_PERIOD	(1 << 2) /* Leading `.' is matched only explicitly.  */
-
-/* extended flags not available in most libc fnmatch versions, but we undef
-   them to avoid any possible warnings. */
-#undef FNM_LEADING_DIR
-#undef FNM_CASEFOLD
-#undef FNM_EXTMATCH
-
-#define FNM_LEADING_DIR	(1 << 3) /* Ignore `/...' after a match. */
-#define FNM_CASEFOLD	(1 << 4) /* Compare without regard to case. */
-#define FNM_EXTMATCH	(1 << 5) /* Use ksh-like extended matching. */
-
-#define FNM_FIRSTCHAR	(1 << 6) /* Match only the first character */
-#define FNM_DOTDOT	(1 << 7) /* force `.' and `..' to match explicitly even if FNM_PERIOD not supplied. */
-
-/* Value returned by `strmatch' if STRING does not match PATTERN.  */
-#undef FNM_NOMATCH
-
-#define	FNM_NOMATCH	1
-
-/* Match STRING against the filename pattern PATTERN,
-   returning zero if it matches, FNM_NOMATCH if not.  */
-extern int strmatch PARAMS((char *, char *, int));
-
-#if HANDLE_MULTIBYTE
-extern int wcsmatch PARAMS((wchar_t *, wchar_t *, int));
-#endif
-
-#endif /* _STRMATCH_H */
diff --git a/third_party/bash/strtrans.c b/third_party/bash/strtrans.c
deleted file mode 100644
index aae07a82b..000000000
--- a/third_party/bash/strtrans.c
+++ /dev/null
@@ -1,400 +0,0 @@
-/* strtrans.c - Translate and untranslate strings with ANSI-C escape sequences. */
-
-/* Copyright (C) 2000-2015 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-#include <stdio.h>
-#include "chartypes.h"
-
-#include "shell.h"
-
-#include "shmbchar.h"
-#include "shmbutil.h"
-
-#ifdef ESC
-#undef ESC
-#endif
-#define ESC '\033'	/* ASCII */
-
-/* Convert STRING by expanding the escape sequences specified by the
-   ANSI C standard.  If SAWC is non-null, recognize `\c' and use that
-   as a string terminator.  If we see \c, set *SAWC to 1 before
-   returning.  LEN is the length of STRING.  If (FLAGS&1) is non-zero,
-   that we're translating a string for `echo -e', and therefore should not
-   treat a single quote as a character that may be escaped with a backslash.
-   If (FLAGS&2) is non-zero, we're expanding for the parser and want to
-   quote CTLESC and CTLNUL with CTLESC.  If (flags&4) is non-zero, we want
-   to remove the backslash before any unrecognized escape sequence. */
-char *
-ansicstr (string, len, flags, sawc, rlen)
-     char *string;
-     int len, flags, *sawc, *rlen;
-{
-  int c, temp;
-  char *ret, *r, *s;
-  unsigned long v;
-  size_t clen;
-  int b, mb_cur_max;
-#if defined (HANDLE_MULTIBYTE)
-  wchar_t wc;
-#endif
-
-  if (string == 0 || *string == '\0')
-    return ((char *)NULL);
-
-  mb_cur_max = MB_CUR_MAX;
-#if defined (HANDLE_MULTIBYTE)
-  temp = 4*len + 4;
-  if (temp < 12)
-    temp = 12;				/* ensure enough for eventual u32cesc */
-  ret = (char *)xmalloc (temp);
-#else
-  ret = (char *)xmalloc (2*len + 1);	/* 2*len for possible CTLESC */
-#endif
-  for (r = ret, s = string; s && *s; )
-    {
-      c = *s++;
-      if (c != '\\' || *s == '\0')
-	{
-	  clen = 1;
-#if defined (HANDLE_MULTIBYTE)
-	  if ((locale_utf8locale && (c & 0x80)) ||
-	      (locale_utf8locale == 0 && mb_cur_max > 0 && is_basic (c) == 0))
-	    {
-	      clen = mbrtowc (&wc, s - 1, mb_cur_max, 0);
-	      if (MB_INVALIDCH (clen))
-		clen = 1;
-	    }
-#endif
-	  *r++ = c;
-	  for (--clen; clen > 0; clen--)
-	    *r++ = *s++;
-	}
-      else
-	{
-	  switch (c = *s++)
-	    {
-#if defined (__STDC__)
-	    case 'a': c = '\a'; break;
-	    case 'v': c = '\v'; break;
-#else
-	    case 'a': c = (int) 0x07; break;
-	    case 'v': c = (int) 0x0B; break;
-#endif
-	    case 'b': c = '\b'; break;
-	    case 'e': case 'E':		/* ESC -- non-ANSI */
-	      c = ESC; break;
-	    case 'f': c = '\f'; break;
-	    case 'n': c = '\n'; break;
-	    case 'r': c = '\r'; break;
-	    case 't': c = '\t'; break;
-	    case '1': case '2': case '3':
-	    case '4': case '5': case '6':
-	    case '7':
-#if 1
-	      if (flags & 1)
-		{
-		  *r++ = '\\';
-		  break;
-		}
-	    /*FALLTHROUGH*/
-#endif
-	    case '0':
-	      /* If (FLAGS & 1), we're translating a string for echo -e (or
-		 the equivalent xpg_echo option), so we obey the SUSv3/
-		 POSIX-2001 requirement and accept 0-3 octal digits after
-		 a leading `0'. */
-	      temp = 2 + ((flags & 1) && (c == '0'));
-	      for (c -= '0'; ISOCTAL (*s) && temp--; s++)
-		c = (c * 8) + OCTVALUE (*s);
-	      c &= 0xFF;
-	      break;
-	    case 'x':			/* Hex digit -- non-ANSI */
-	      if ((flags & 2) && *s == '{')
-		{
-		  flags |= 16;		/* internal flag value */
-		  s++;
-		}
-	      /* Consume at least two hex characters */
-	      for (temp = 2, c = 0; ISXDIGIT ((unsigned char)*s) && temp--; s++)
-		c = (c * 16) + HEXVALUE (*s);
-	      /* DGK says that after a `\x{' ksh93 consumes ISXDIGIT chars
-		 until a non-xdigit or `}', so potentially more than two
-		 chars are consumed. */
-	      if (flags & 16)
-		{
-		  for ( ; ISXDIGIT ((unsigned char)*s); s++)
-		    c = (c * 16) + HEXVALUE (*s);
-		  flags &= ~16;
-		  if (*s == '}')
-		    s++;
-	        }
-	      /* \x followed by non-hex digits is passed through unchanged */
-	      else if (temp == 2)
-		{
-		  *r++ = '\\';
-		  c = 'x';
-		}
-	      c &= 0xFF;
-	      break;
-#if defined (HANDLE_MULTIBYTE)
-	    case 'u':
-	    case 'U':
-	      temp = (c == 'u') ? 4 : 8;	/* \uNNNN \UNNNNNNNN */
-	      for (v = 0; ISXDIGIT ((unsigned char)*s) && temp--; s++)
-		v = (v * 16) + HEXVALUE (*s);
-	      if (temp == ((c == 'u') ? 4 : 8))
-		{
-		  *r++ = '\\';	/* c remains unchanged */
-		  break;
-		}
-	      else if (v <= 0x7f)	/* <= 0x7f translates directly */
-		{
-		  c = v;
-		  break;
-		}
-	      else
-		{
-		  temp = u32cconv (v, r);
-		  r += temp;
-		  continue;
-		}
-#endif
-	    case '\\':
-	      break;
-	    case '\'': case '"': case '?':
-	      if (flags & 1)
-		*r++ = '\\';
-	      break;
-	    case 'c':
-	      if (sawc)
-		{
-		  *sawc = 1;
-		  *r = '\0';
-		  if (rlen)
-		    *rlen = r - ret;
-		  return ret;
-		}
-	      else if ((flags & 1) == 0 && *s == 0)
-		;		/* pass \c through */
-	      else if ((flags & 1) == 0 && (c = *s))
-		{
-		  s++;
-		  if ((flags & 2) && c == '\\' && c == *s)
-		    s++;	/* Posix requires $'\c\\' do backslash escaping */
-		  c = TOCTRL(c);
-		  break;
-		}
-		/*FALLTHROUGH*/
-	    default:
-		if ((flags & 4) == 0)
-		  *r++ = '\\';
-		break;
-	    }
-	  if ((flags & 2) && (c == CTLESC || c == CTLNUL))
-	    *r++ = CTLESC;
-	  *r++ = c;
-	}
-    }
-  *r = '\0';
-  if (rlen)
-    *rlen = r - ret;
-  return ret;
-}
-
-/* Take a string STR, possibly containing non-printing characters, and turn it
-   into a $'...' ANSI-C style quoted string.  Returns a new string. */
-char *
-ansic_quote (str, flags, rlen)
-     char *str;
-     int flags, *rlen;
-{
-  char *r, *ret, *s;
-  int l, rsize;
-  unsigned char c;
-  size_t clen;
-  int b;
-#if defined (HANDLE_MULTIBYTE)
-  wchar_t wc;
-#endif
-
-  if (str == 0 || *str == 0)
-    return ((char *)0);
-
-  l = strlen (str);
-  rsize = 4 * l + 4;
-  r = ret = (char *)xmalloc (rsize);
-
-  *r++ = '$';
-  *r++ = '\'';
-
-  for (s = str; c = *s; s++)
-    {
-      b = l = 1;		/* 1 == add backslash; 0 == no backslash */
-      clen = 1;
-
-      switch (c)
-	{
-	case ESC: c = 'E'; break;
-#ifdef __STDC__
-	case '\a': c = 'a'; break;
-	case '\v': c = 'v'; break;
-#else
-	case 0x07: c = 'a'; break;
-	case 0x0b: c = 'v'; break;
-#endif
-
-	case '\b': c = 'b'; break;
-	case '\f': c = 'f'; break;
-	case '\n': c = 'n'; break;
-	case '\r': c = 'r'; break;
-	case '\t': c = 't'; break;
-	case '\\':
-	case '\'':
-	  break;
-	default:
-#if defined (HANDLE_MULTIBYTE)
-	  b = is_basic (c);
-	  /* XXX - clen comparison to 0 is dicey */
-	  if ((b == 0 && ((clen = mbrtowc (&wc, s, MB_CUR_MAX, 0)) < 0 || MB_INVALIDCH (clen) || iswprint (wc) == 0)) ||
-	      (b == 1 && ISPRINT (c) == 0))
-#else
-	  if (ISPRINT (c) == 0)
-#endif
-	    {
-	      *r++ = '\\';
-	      *r++ = TOCHAR ((c >> 6) & 07);
-	      *r++ = TOCHAR ((c >> 3) & 07);
-	      *r++ = TOCHAR (c & 07);
-	      continue;
-	    }
-	  l = 0;
-	  break;
-	}
-      if (b == 0 && clen == 0)
-	break;
-
-      if (l)
-	*r++ = '\\';
-
-      if (clen == 1)
-	*r++ = c;
-      else
-	{
-	  for (b = 0; b < (int)clen; b++)
-	    *r++ = (unsigned char)s[b];
-	  s += clen - 1;	/* -1 because of the increment above */
-	}
-    }
-
-  *r++ = '\'';
-  *r = '\0';
-  if (rlen)
-    *rlen = r - ret;
-  return ret;
-}
-
-#if defined (HANDLE_MULTIBYTE)
-int
-ansic_wshouldquote (string)
-     const char *string;
-{
-  const wchar_t *wcs;
-  wchar_t wcc;
-  wchar_t *wcstr = NULL;
-  size_t slen;
-
-  slen = mbstowcs (wcstr, string, 0);
-
-  if (slen == (size_t)-1)
-    return 1;
-
-  wcstr = (wchar_t *)xmalloc (sizeof (wchar_t) * (slen + 1));
-  mbstowcs (wcstr, string, slen + 1);
-
-  for (wcs = wcstr; wcc = *wcs; wcs++)
-    if (iswprint(wcc) == 0)
-      {
-	free (wcstr);
-	return 1;
-      }
-
-  free (wcstr);
-  return 0;
-}
-#endif
-
-/* return 1 if we need to quote with $'...' because of non-printing chars. */
-int
-ansic_shouldquote (string)
-     const char *string;
-{
-  const char *s;
-  unsigned char c;
-
-  if (string == 0)
-    return 0;
-
-  for (s = string; c = *s; s++)
-    {
-#if defined (HANDLE_MULTIBYTE)
-      if (is_basic (c) == 0)
-	return (ansic_wshouldquote (s));
-#endif
-      if (ISPRINT (c) == 0)
-	return 1;
-    }
-
-  return 0;
-}
-
-/* $'...' ANSI-C expand the portion of STRING between START and END and
-   return the result.  The result cannot be longer than the input string. */
-char *
-ansiexpand (string, start, end, lenp)
-     char *string;
-     int start, end, *lenp;
-{
-  char *temp, *t;
-  int len, tlen;
-
-  temp = (char *)xmalloc (end - start + 1);
-  for (tlen = 0, len = start; len < end; )
-    temp[tlen++] = string[len++];
-  temp[tlen] = '\0';
-
-  if (*temp)
-    {
-      t = ansicstr (temp, tlen, 2, (int *)NULL, lenp);
-      free (temp);
-      return (t);
-    }
-  else
-    {
-      if (lenp)
-	*lenp = 0;
-      return (temp);
-    }
-}
diff --git a/third_party/bash/strvis.c b/third_party/bash/strvis.c
deleted file mode 100644
index 6d8a5f32f..000000000
--- a/third_party/bash/strvis.c
+++ /dev/null
@@ -1,154 +0,0 @@
-/* strvis.c - make unsafe graphical characters in a string visible. */
-
-/* Copyright (C) 2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-   
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* This is a stripped-down version suitable for the shell's use. */
-#include "config.h"
-
-#include <unistd.h>
-
-#include "bashansi.h"
-#include <stdio.h>
-
-#include "chartypes.h"
-#include "bashintl.h"
-#include "shmbutil.h"
-
-#define SAFECHAR(c)   ((c) == ' ' || (c) == '\t')
-
-#ifndef RUBOUT
-#define RUBOUT 0x7f
-#endif
-
-#ifndef CTRL_CHAR
-#define CTRL_CHAR(c)	((c) < 0x20)
-#endif
-
-#ifndef META_CHAR
-#define META_CHAR(c)	((c) > 0x7f && (c) <= UCHAR_MAX)
-#endif
-
-#ifndef UNCTRL
-#define UNCTRL(c)	(TOUPPER ((c) | 0x40))
-#endif
-
-#ifndef UNMETA
-#define UNMETA(c)	((c) & 0x7f)
-#endif
-
-int
-sh_charvis (s, sindp, slen, ret, rindp)
-     const char *s;
-     size_t *sindp;
-     size_t slen;
-     char *ret;
-     size_t *rindp;
-{
-  unsigned char c;
-  size_t si, ri;
-  const char *send;
-  DECLARE_MBSTATE;
-
-  si = *sindp;
-  ri = *rindp;
-  c = s[*sindp];
-
-#if defined (HANDLE_MULTIBYTE)
-  send = (locale_mb_cur_max > 1) ? s + slen : 0;
-#else
-  send = 0;
-#endif
-
-  if (SAFECHAR (c))
-    {
-      ret[ri++] = c;
-      si++;
-    }
-  else if (c == RUBOUT)
-    {
-      ret[ri++] = '^';
-      ret[ri++] = '?';
-      si++;
-    }
-  else if (CTRL_CHAR (c))
-    {
-      ret[ri++] = '^';
-      ret[ri++] = UNCTRL (c);
-      si++;
-    }
-#if defined (HANDLE_MULTIBYTE)
-  else if (locale_utf8locale && (c & 0x80))
-    COPY_CHAR_I (ret, ri, s, send, si);
-  else if (locale_mb_cur_max > 1 && is_basic (c) == 0)
-    COPY_CHAR_I (ret, ri, s, send, si);
-#endif
-  else if (META_CHAR (c))
-    {
-      ret[ri++] = 'M';
-      ret[ri++] = '-';
-      ret[ri++] = UNMETA (c);
-      si++;
-    }
-  else
-    ret[ri++] = s[si++];
-  
-  *sindp = si;
-  *rindp = ri;
-
-  return si;    
-}
-
-/* Return a new string with `unsafe' non-graphical characters in S rendered
-   in a visible way. */
-char *
-sh_strvis (string)
-     const char *string;
-{
-  size_t slen, sind;
-  char *ret;
-  size_t retind, retsize;
-  unsigned char c;
-  DECLARE_MBSTATE;
-
-  if (string == 0)
-    return 0;
-  if (*string == '\0')
-    {
-      if ((ret = (char *)malloc (1)) == 0)
-	return 0;
-      ret[0] = '\0';
-      return ret;
-    }
-
-  slen = strlen (string);
-  retsize = 3 * slen + 1;
-
-  ret = (char *)malloc (retsize);
-  if (ret == 0)
-    return 0;
-
-  retind = 0;
-  sind = 0;
-
-  while (string[sind])
-    sind = sh_charvis (string, &sind, slen, ret, &retind);
-
-  ret[retind] = '\0';
-  return ret;
-}
diff --git a/third_party/bash/subst.c b/third_party/bash/subst.c
deleted file mode 100644
index b682a84ca..000000000
--- a/third_party/bash/subst.c
+++ /dev/null
@@ -1,13006 +0,0 @@
-/* subst.c -- The part of the shell that does parameter, command, arithmetic,
-   and globbing substitutions. */
-
-/* ``Have a little faith, there's magic in the night.  You ain't a
-     beauty, but, hey, you're alright.'' */
-
-/* Copyright (C) 1987-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include <stdio.h>
-#include "chartypes.h"
-#if defined (HAVE_PWD_H)
-#  include <pwd.h>
-#endif
-#include <signal.h>
-#include <errno.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#define NEED_FPURGE_DECL
-
-#include "bashansi.h"
-#include "posixstat.h"
-#include "bashintl.h"
-
-#include "shell.h"
-#include "parser.h"
-#include "redir.h"
-#include "flags.h"
-#include "jobs.h"
-#include "execute_cmd.h"
-#include "filecntl.h"
-#include "trap.h"
-#include "pathexp.h"
-#include "mailcheck.h"
-
-#include "shmbutil.h"
-#if defined (HAVE_MBSTR_H) && defined (HAVE_MBSCHR)
-#  include <mbstr.h>		/* mbschr */
-#endif
-#include "typemax.h"
-
-#include "getopt.h"
-#include "common.h"
-
-#include "builtext.h"
-
-#include "tilde.h"
-#include "strmatch.h"
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-/* The size that strings change by. */
-#define DEFAULT_INITIAL_ARRAY_SIZE 112
-#define DEFAULT_ARRAY_SIZE 128
-
-/* Variable types. */
-#define VT_VARIABLE	0
-#define VT_POSPARMS	1
-#define VT_ARRAYVAR	2
-#define VT_ARRAYMEMBER	3
-#define VT_ASSOCVAR	4
-
-#define VT_STARSUB	128	/* $* or ${array[*]} -- used to split */
-
-/* Flags for quoted_strchr */
-#define ST_BACKSL	0x01
-#define ST_CTLESC	0x02
-#define ST_SQUOTE	0x04	/* unused yet */
-#define ST_DQUOTE	0x08	/* unused yet */
-
-/* These defs make it easier to use the editor. */
-#define LBRACE		'{'
-#define RBRACE		'}'
-#define LPAREN		'('
-#define RPAREN		')'
-#define LBRACK		'['
-#define RBRACK		']'
-
-#if defined (HANDLE_MULTIBYTE)
-#define WLPAREN		L'('
-#define WRPAREN		L')'
-#endif
-
-#define DOLLAR_AT_STAR(c)	((c) == '@' || (c) == '*')
-#define STR_DOLLAR_AT_STAR(s)	(DOLLAR_AT_STAR ((s)[0]) && (s)[1] == '\0')
-
-/* Evaluates to 1 if C is one of the shell's special parameters whose length
-   can be taken, but is also one of the special expansion characters. */
-#define VALID_SPECIAL_LENGTH_PARAM(c) \
-  ((c) == '-' || (c) == '?' || (c) == '#' || (c) == '@')
-
-/* Evaluates to 1 if C is one of the shell's special parameters for which an
-   indirect variable reference may be made. */
-#define VALID_INDIR_PARAM(c) \
-  ((posixly_correct == 0 && (c) == '#') || (posixly_correct == 0 && (c) == '?') || (c) == '@' || (c) == '*')
-
-/* Evaluates to 1 if C is one of the OP characters that follows the parameter
-   in ${parameter[:]OPword}. */
-#define VALID_PARAM_EXPAND_CHAR(c) (sh_syntaxtab[(unsigned char)c] & CSUBSTOP)
-
-/* Evaluates to 1 if this is one of the shell's special variables. */
-#define SPECIAL_VAR(name, wi) \
- (*name && ((DIGIT (*name) && all_digits (name)) || \
-      (name[1] == '\0' && (sh_syntaxtab[(unsigned char)*name] & CSPECVAR)) || \
-      (wi && name[2] == '\0' && VALID_INDIR_PARAM (name[1]))))
-
-/* This can be used by all of the *_extract_* functions that have a similar
-   structure.  It can't just be wrapped in a do...while(0) loop because of
-   the embedded `break'. The dangling else accommodates a trailing semicolon;
-   we could also put in a do ; while (0) */
-
-#define CHECK_STRING_OVERRUN(oind, ind, len, ch) \
-  if (ind >= len) \
-    { \
-      oind = len; \
-      ch = 0; \
-      break; \
-    } \
-  else \
-
-/* An expansion function that takes a string and a quoted flag and returns
-   a WORD_LIST *.  Used as the type of the third argument to
-   expand_string_if_necessary(). */
-typedef WORD_LIST *EXPFUNC PARAMS((char *, int));
-
-/* Process ID of the last command executed within command substitution. */
-pid_t last_command_subst_pid = NO_PID;
-pid_t current_command_subst_pid = NO_PID;
-
-/* Variables used to keep track of the characters in IFS. */
-SHELL_VAR *ifs_var;
-char *ifs_value;
-unsigned char ifs_cmap[UCHAR_MAX + 1];
-int ifs_is_set, ifs_is_null;
-
-#if defined (HANDLE_MULTIBYTE)
-unsigned char ifs_firstc[MB_LEN_MAX];
-size_t ifs_firstc_len;
-#else
-unsigned char ifs_firstc;
-#endif
-
-/* If non-zero, command substitution inherits the value of errexit option */
-int inherit_errexit = 0;
-
-/* Sentinel to tell when we are performing variable assignments preceding a
-   command name and putting them into the environment.  Used to make sure
-   we use the temporary environment when looking up variable values. */
-int assigning_in_environment;
-
-/* Used to hold a list of variable assignments preceding a command.  Global
-   so the SIGCHLD handler in jobs.c can unwind-protect it when it runs a
-   SIGCHLD trap and so it can be saved and restored by the trap handlers. */
-WORD_LIST *subst_assign_varlist = (WORD_LIST *)NULL;
-
-/* Tell the expansion functions to not longjmp back to top_level on fatal
-   errors.  Enabled when doing completion and prompt string expansion. */
-int no_longjmp_on_fatal_error = 0;
-
-/* Non-zero means to allow unmatched globbed filenames to expand to
-   a null file. */
-int allow_null_glob_expansion;
-
-/* Non-zero means to throw an error when globbing fails to match anything. */
-int fail_glob_expansion;
-
-/* If non-zero, perform `&' substitution on the replacement string in the
-   pattern substitution word expansion. */
-int patsub_replacement = 1;
-
-/* Extern functions and variables from different files. */
-extern struct fd_bitmap *current_fds_to_close;
-extern int wordexp_only;
-extern int singlequote_translations;
-extern int extended_quote;
-
-#if defined (JOB_CONTROL) && defined (PROCESS_SUBSTITUTION)
-extern PROCESS *last_procsub_child;
-#endif
-
-#if !defined (HAVE_WCSDUP) && defined (HANDLE_MULTIBYTE)
-extern wchar_t *wcsdup PARAMS((const wchar_t *));
-#endif
-
-#if 0
-/* Variables to keep track of which words in an expanded word list (the
-   output of expand_word_list_internal) are the result of globbing
-   expansions.  GLOB_ARGV_FLAGS is used by execute_cmd.c.
-   (CURRENTLY UNUSED). */
-char *glob_argv_flags;
-static int glob_argv_flags_size;
-#endif
-
-static WORD_LIST *cached_quoted_dollar_at = 0;
-
-/* Distinguished error values to return from expansion functions */
-static WORD_LIST expand_word_error, expand_word_fatal;
-static WORD_DESC expand_wdesc_error, expand_wdesc_fatal;
-static char expand_param_error, expand_param_fatal, expand_param_unset;
-static char extract_string_error, extract_string_fatal;
-
-/* Set by expand_word_unsplit and several of the expand_string_XXX functions;
-   used to inhibit splitting and re-joining $* on $IFS, primarily when doing
-   assignment statements.  The idea is that if we're in a context where this
-   is set, we're not going to be performing word splitting, so we use the same
-   rules to expand $* as we would if it appeared within double quotes. */
-static int expand_no_split_dollar_star = 0;
-
-/* A WORD_LIST of words to be expanded by expand_word_list_internal,
-   without any leading variable assignments. */
-static WORD_LIST *garglist = (WORD_LIST *)NULL;
-
-static char *quoted_substring PARAMS((char *, int, int));
-static int quoted_strlen PARAMS((char *));
-static char *quoted_strchr PARAMS((char *, int, int));
-
-static char *expand_string_if_necessary PARAMS((char *, int, EXPFUNC *));
-static inline char *expand_string_to_string_internal PARAMS((char *, int, EXPFUNC *));
-static WORD_LIST *call_expand_word_internal PARAMS((WORD_DESC *, int, int, int *, int *));
-static WORD_LIST *expand_string_internal PARAMS((char *, int));
-static WORD_LIST *expand_string_leave_quoted PARAMS((char *, int));
-static WORD_LIST *expand_string_for_rhs PARAMS((char *, int, int, int, int *, int *));
-static WORD_LIST *expand_string_for_pat PARAMS((char *, int, int *, int *));
-
-static char *quote_escapes_internal PARAMS((const char *, int));
-
-static WORD_LIST *list_quote_escapes PARAMS((WORD_LIST *));
-static WORD_LIST *list_dequote_escapes PARAMS((WORD_LIST *));
-
-static char *make_quoted_char PARAMS((int));
-static WORD_LIST *quote_list PARAMS((WORD_LIST *));
-
-static int unquoted_substring PARAMS((char *, char *));
-static int unquoted_member PARAMS((int, char *));
-
-#if defined (ARRAY_VARS)
-static SHELL_VAR *do_compound_assignment PARAMS((char *, char *, int));
-#endif
-static int do_assignment_internal PARAMS((const WORD_DESC *, int));
-
-static char *string_extract_verbatim PARAMS((char *, size_t, int *, char *, int));
-static char *string_extract PARAMS((char *, int *, char *, int));
-static char *string_extract_double_quoted PARAMS((char *, int *, int));
-static inline char *string_extract_single_quoted PARAMS((char *, int *, int));
-static inline int skip_single_quoted PARAMS((const char *, size_t, int, int));
-static int skip_double_quoted PARAMS((char *, size_t, int, int));
-static char *extract_delimited_string PARAMS((char *, int *, char *, char *, char *, int));
-static char *extract_heredoc_dolbrace_string PARAMS((char *, int *, int, int));
-static char *extract_dollar_brace_string PARAMS((char *, int *, int, int));
-static int skip_matched_pair PARAMS((const char *, int, int, int, int));
-
-static char *pos_params PARAMS((char *, int, int, int, int));
-
-static unsigned char *mb_getcharlens PARAMS((char *, int));
-
-static char *remove_upattern PARAMS((char *, char *, int));
-#if defined (HANDLE_MULTIBYTE) 
-static wchar_t *remove_wpattern PARAMS((wchar_t *, size_t, wchar_t *, int));
-#endif
-static char *remove_pattern PARAMS((char *, char *, int));
-
-static int match_upattern PARAMS((char *, char *, int, char **, char **));
-#if defined (HANDLE_MULTIBYTE)
-static int match_wpattern PARAMS((wchar_t *, char **, size_t, wchar_t *, int, char **, char **));
-#endif
-static int match_pattern PARAMS((char *, char *, int, char **, char **));
-static int getpatspec PARAMS((int, char *));
-static char *getpattern PARAMS((char *, int, int));
-static char *variable_remove_pattern PARAMS((char *, char *, int, int));
-static char *list_remove_pattern PARAMS((WORD_LIST *, char *, int, int, int));
-static char *parameter_list_remove_pattern PARAMS((int, char *, int, int));
-#ifdef ARRAY_VARS
-static char *array_remove_pattern PARAMS((SHELL_VAR *, char *, int, int, int));
-#endif
-static char *parameter_brace_remove_pattern PARAMS((char *, char *, array_eltstate_t *, char *, int, int, int));
-
-static char *string_var_assignment PARAMS((SHELL_VAR *, char *));
-#if defined (ARRAY_VARS)
-static char *array_var_assignment PARAMS((SHELL_VAR *, int, int, int));
-#endif
-static char *pos_params_assignment PARAMS((WORD_LIST *, int, int));
-static char *string_transform PARAMS((int, SHELL_VAR *, char *));
-static char *list_transform PARAMS((int, SHELL_VAR *, WORD_LIST *, int, int));
-static char *parameter_list_transform PARAMS((int, int, int));
-#if defined ARRAY_VARS
-static char *array_transform PARAMS((int, SHELL_VAR *, int, int));
-#endif
-static char *parameter_brace_transform PARAMS((char *, char *, array_eltstate_t *, char *, int, int, int, int));
-static int valid_parameter_transform PARAMS((char *));
-
-static char *process_substitute PARAMS((char *, int));
-
-static char *optimize_cat_file PARAMS((REDIRECT *, int, int, int *));
-static char *read_comsub PARAMS((int, int, int, int *));
-
-#ifdef ARRAY_VARS
-static arrayind_t array_length_reference PARAMS((char *));
-#endif
-
-static int valid_brace_expansion_word PARAMS((char *, int));
-static int chk_atstar PARAMS((char *, int, int, int *, int *));
-static int chk_arithsub PARAMS((const char *, int));
-
-static WORD_DESC *parameter_brace_expand_word PARAMS((char *, int, int, int, array_eltstate_t *));
-static char *parameter_brace_find_indir PARAMS((char *, int, int, int));
-static WORD_DESC *parameter_brace_expand_indir PARAMS((char *, int, int, int, int *, int *));
-static WORD_DESC *parameter_brace_expand_rhs PARAMS((char *, char *, int, int, int, int *, int *));
-static void parameter_brace_expand_error PARAMS((char *, char *, int));
-
-static int valid_length_expression PARAMS((char *));
-static intmax_t parameter_brace_expand_length PARAMS((char *));
-
-static char *skiparith PARAMS((char *, int));
-static int verify_substring_values PARAMS((SHELL_VAR *, char *, char *, int, intmax_t *, intmax_t *));
-static int get_var_and_type PARAMS((char *, char *, array_eltstate_t *, int, int, SHELL_VAR **, char **));
-static char *mb_substring PARAMS((char *, int, int));
-static char *parameter_brace_substring PARAMS((char *, char *, array_eltstate_t *, char *, int, int, int));
-
-static int shouldexp_replacement PARAMS((char *));
-
-static char *pos_params_pat_subst PARAMS((char *, char *, char *, int));
-
-static char *expand_string_for_patsub PARAMS((char *, int));
-static char *parameter_brace_patsub PARAMS((char *, char *, array_eltstate_t *, char *, int, int, int));
-
-static char *pos_params_casemod PARAMS((char *, char *, int, int));
-static char *parameter_brace_casemod PARAMS((char *, char *, array_eltstate_t *, int, char *, int, int, int));
-
-static WORD_DESC *parameter_brace_expand PARAMS((char *, int *, int, int, int *, int *));
-static WORD_DESC *param_expand PARAMS((char *, int *, int, int *, int *, int *, int *, int));
-
-static WORD_LIST *expand_word_internal PARAMS((WORD_DESC *, int, int, int *, int *));
-
-static WORD_LIST *word_list_split PARAMS((WORD_LIST *));
-
-static void exp_jump_to_top_level PARAMS((int));
-
-static WORD_LIST *separate_out_assignments PARAMS((WORD_LIST *));
-static WORD_LIST *glob_expand_word_list PARAMS((WORD_LIST *, int));
-#ifdef BRACE_EXPANSION
-static WORD_LIST *brace_expand_word_list PARAMS((WORD_LIST *, int));
-#endif
-#if defined (ARRAY_VARS)
-static int make_internal_declare PARAMS((char *, char *, char *));
-static void expand_compound_assignment_word PARAMS((WORD_LIST *, int));
-static WORD_LIST *expand_declaration_argument PARAMS((WORD_LIST *, WORD_LIST *));
-#endif
-static WORD_LIST *shell_expand_word_list PARAMS((WORD_LIST *, int));
-static WORD_LIST *expand_word_list_internal PARAMS((WORD_LIST *, int));
-
-static int do_assignment_statements PARAMS((WORD_LIST *, char *, int));
-
-/* **************************************************************** */
-/*								    */
-/*			Utility Functions			    */
-/*								    */
-/* **************************************************************** */
-
-#if defined (DEBUG)
-void
-dump_word_flags (flags)
-     int flags;
-{
-  int f;
-
-  f = flags;
-  fprintf (stderr, "%d -> ", f);
-  if (f & W_ARRAYIND)
-    {
-      f &= ~W_ARRAYIND;
-      fprintf (stderr, "W_ARRAYIND%s", f ? "|" : "");
-    }
-  if (f & W_ASSIGNASSOC)
-    {
-      f &= ~W_ASSIGNASSOC;
-      fprintf (stderr, "W_ASSIGNASSOC%s", f ? "|" : "");
-    }
-  if (f & W_ASSIGNARRAY)
-    {
-      f &= ~W_ASSIGNARRAY;
-      fprintf (stderr, "W_ASSIGNARRAY%s", f ? "|" : "");
-    }
-  if (f & W_SAWQUOTEDNULL)
-    {
-      f &= ~W_SAWQUOTEDNULL;
-      fprintf (stderr, "W_SAWQUOTEDNULL%s", f ? "|" : "");
-    }
-  if (f & W_NOPROCSUB)
-    {
-      f &= ~W_NOPROCSUB;
-      fprintf (stderr, "W_NOPROCSUB%s", f ? "|" : "");
-    }
-  if (f & W_DQUOTE)
-    {
-      f &= ~W_DQUOTE;
-      fprintf (stderr, "W_DQUOTE%s", f ? "|" : "");
-    }
-  if (f & W_HASQUOTEDNULL)
-    {
-      f &= ~W_HASQUOTEDNULL;
-      fprintf (stderr, "W_HASQUOTEDNULL%s", f ? "|" : "");
-    }
-  if (f & W_ASSIGNARG)
-    {
-      f &= ~W_ASSIGNARG;
-      fprintf (stderr, "W_ASSIGNARG%s", f ? "|" : "");
-    }
-  if (f & W_ASSNBLTIN)
-    {
-      f &= ~W_ASSNBLTIN;
-      fprintf (stderr, "W_ASSNBLTIN%s", f ? "|" : "");
-    }
-  if (f & W_ASSNGLOBAL)
-    {
-      f &= ~W_ASSNGLOBAL;
-      fprintf (stderr, "W_ASSNGLOBAL%s", f ? "|" : "");
-    }
-  if (f & W_COMPASSIGN)
-    {
-      f &= ~W_COMPASSIGN;
-      fprintf (stderr, "W_COMPASSIGN%s", f ? "|" : "");
-    }
-  if (f & W_EXPANDRHS)
-    {
-      f &= ~W_EXPANDRHS;
-      fprintf (stderr, "W_EXPANDRHS%s", f ? "|" : "");
-    }
-  if (f & W_NOTILDE)
-    {
-      f &= ~W_NOTILDE;
-      fprintf (stderr, "W_NOTILDE%s", f ? "|" : "");
-    }
-  if (f & W_ASSIGNRHS)
-    {
-      f &= ~W_ASSIGNRHS;
-      fprintf (stderr, "W_ASSIGNRHS%s", f ? "|" : "");
-    }
-  if (f & W_NOASSNTILDE)
-    {
-      f &= ~W_NOASSNTILDE;
-      fprintf (stderr, "W_NOASSNTILDE%s", f ? "|" : "");
-    }
-  if (f & W_NOCOMSUB)
-    {
-      f &= ~W_NOCOMSUB;
-      fprintf (stderr, "W_NOCOMSUB%s", f ? "|" : "");
-    }
-  if (f & W_ARRAYREF)
-    {
-      f &= ~W_ARRAYREF;
-      fprintf (stderr, "W_ARRAYREF%s", f ? "|" : "");
-    }
-  if (f & W_DOLLARAT)
-    {
-      f &= ~W_DOLLARAT;
-      fprintf (stderr, "W_DOLLARAT%s", f ? "|" : "");
-    }
-  if (f & W_TILDEEXP)
-    {
-      f &= ~W_TILDEEXP;
-      fprintf (stderr, "W_TILDEEXP%s", f ? "|" : "");
-    }
-  if (f & W_NOSPLIT2)
-    {
-      f &= ~W_NOSPLIT2;
-      fprintf (stderr, "W_NOSPLIT2%s", f ? "|" : "");
-    }
-  if (f & W_NOSPLIT)
-    {
-      f &= ~W_NOSPLIT;
-      fprintf (stderr, "W_NOSPLIT%s", f ? "|" : "");
-    }
-  if (f & W_NOBRACE)
-    {
-      f &= ~W_NOBRACE;
-      fprintf (stderr, "W_NOBRACE%s", f ? "|" : "");
-    }
-  if (f & W_NOGLOB)
-    {
-      f &= ~W_NOGLOB;
-      fprintf (stderr, "W_NOGLOB%s", f ? "|" : "");
-    }
-  if (f & W_SPLITSPACE)
-    {
-      f &= ~W_SPLITSPACE;
-      fprintf (stderr, "W_SPLITSPACE%s", f ? "|" : "");
-    }
-  if (f & W_ASSIGNMENT)
-    {
-      f &= ~W_ASSIGNMENT;
-      fprintf (stderr, "W_ASSIGNMENT%s", f ? "|" : "");
-    }
-  if (f & W_QUOTED)
-    {
-      f &= ~W_QUOTED;
-      fprintf (stderr, "W_QUOTED%s", f ? "|" : "");
-    }
-  if (f & W_HASDOLLAR)
-    {
-      f &= ~W_HASDOLLAR;
-      fprintf (stderr, "W_HASDOLLAR%s", f ? "|" : "");
-    }
-  if (f & W_COMPLETE)
-    {
-      f &= ~W_COMPLETE;
-      fprintf (stderr, "W_COMPLETE%s", f ? "|" : "");
-    }
-  if (f & W_CHKLOCAL)
-    {
-      f &= ~W_CHKLOCAL;
-      fprintf (stderr, "W_CHKLOCAL%s", f ? "|" : "");
-    }
-  if (f & W_FORCELOCAL)
-    {
-      f &= ~W_FORCELOCAL;
-      fprintf (stderr, "W_FORCELOCAL%s", f ? "|" : "");
-    }
-
-  fprintf (stderr, "\n");
-  fflush (stderr);
-}
-#endif
-
-#ifdef INCLUDE_UNUSED
-static char *
-quoted_substring (string, start, end)
-     char *string;
-     int start, end;
-{
-  register int len, l;
-  register char *result, *s, *r;
-
-  len = end - start;
-
-  /* Move to string[start], skipping quoted characters. */
-  for (s = string, l = 0; *s && l < start; )
-    {
-      if (*s == CTLESC)
-	{
-	  s++;
-	  continue;
-	}
-      l++;
-      if (*s == 0)
-	break;
-    }
-
-  r = result = (char *)xmalloc (2*len + 1);      /* save room for quotes */
-
-  /* Copy LEN characters, including quote characters. */
-  s = string + l;
-  for (l = 0; l < len; s++)
-    {
-      if (*s == CTLESC)
-	*r++ = *s++;
-      *r++ = *s;
-      l++;
-      if (*s == 0)
-	break;
-    }
-  *r = '\0';
-  return result;
-}
-#endif
-
-#ifdef INCLUDE_UNUSED
-/* Return the length of S, skipping over quoted characters */
-static int
-quoted_strlen (s)
-     char *s;
-{
-  register char *p;
-  int i;
-
-  i = 0;
-  for (p = s; *p; p++)
-    {
-      if (*p == CTLESC)
-	{
-	  p++;
-	  if (*p == 0)
-	    return (i + 1);
-	}
-      i++;
-    }
-
-  return i;
-}
-#endif
-
-#ifdef INCLUDE_UNUSED
-/* Find the first occurrence of character C in string S, obeying shell
-   quoting rules.  If (FLAGS & ST_BACKSL) is non-zero, backslash-escaped
-   characters are skipped.  If (FLAGS & ST_CTLESC) is non-zero, characters
-   escaped with CTLESC are skipped. */
-static char *
-quoted_strchr (s, c, flags)
-     char *s;
-     int c, flags;
-{
-  register char *p;
-
-  for (p = s; *p; p++)
-    {
-      if (((flags & ST_BACKSL) && *p == '\\')
-	    || ((flags & ST_CTLESC) && *p == CTLESC))
-	{
-	  p++;
-	  if (*p == '\0')
-	    return ((char *)NULL);
-	  continue;
-	}
-      else if (*p == c)
-	return p;
-    }
-  return ((char *)NULL);
-}
-
-/* Return 1 if CHARACTER appears in an unquoted portion of
-   STRING.  Return 0 otherwise.  CHARACTER must be a single-byte character. */
-static int
-unquoted_member (character, string)
-     int character;
-     char *string;
-{
-  size_t slen;
-  int sindex, c;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  sindex = 0;
-  while (c = string[sindex])
-    {
-      if (c == character)
-	return (1);
-
-      switch (c)
-	{
-	default:
-	  ADVANCE_CHAR (string, slen, sindex);
-	  break;
-
-	case '\\':
-	  sindex++;
-	  if (string[sindex])
-	    ADVANCE_CHAR (string, slen, sindex);
-	  break;
-
-	case '\'':
-	  sindex = skip_single_quoted (string, slen, ++sindex, 0);
-	  break;
-
-	case '"':
-	  sindex = skip_double_quoted (string, slen, ++sindex, 0);
-	  break;
-	}
-    }
-  return (0);
-}
-
-/* Return 1 if SUBSTR appears in an unquoted portion of STRING. */
-static int
-unquoted_substring (substr, string)
-     char *substr, *string;
-{
-  size_t slen;
-  int sindex, c, sublen;
-  DECLARE_MBSTATE;
-
-  if (substr == 0 || *substr == '\0')
-    return (0);
-
-  slen = strlen (string);
-  sublen = strlen (substr);
-  for (sindex = 0; c = string[sindex]; )
-    {
-      if (STREQN (string + sindex, substr, sublen))
-	return (1);
-
-      switch (c)
-	{
-	case '\\':
-	  sindex++;
-	  if (string[sindex])
-	    ADVANCE_CHAR (string, slen, sindex);
-	  break;
-
-	case '\'':
-	  sindex = skip_single_quoted (string, slen, ++sindex, 0);
-	  break;
-
-	case '"':
-	  sindex = skip_double_quoted (string, slen, ++sindex, 0);
-	  break;
-
-	default:
-	  ADVANCE_CHAR (string, slen, sindex);
-	  break;
-	}
-    }
-  return (0);
-}
-#endif
-
-/* Most of the substitutions must be done in parallel.  In order
-   to avoid using tons of unclear goto's, I have some functions
-   for manipulating malloc'ed strings.  They all take INDX, a
-   pointer to an integer which is the offset into the string
-   where manipulation is taking place.  They also take SIZE, a
-   pointer to an integer which is the current length of the
-   character array for this string. */
-
-/* Append SOURCE to TARGET at INDEX.  SIZE is the current amount
-   of space allocated to TARGET.  SOURCE can be NULL, in which
-   case nothing happens.  Gets rid of SOURCE by freeing it.
-   Returns TARGET in case the location has changed. */
-INLINE char *
-sub_append_string (source, target, indx, size)
-     char *source, *target;
-     size_t *indx;
-     size_t *size;
-{
-  if (source)
-    {
-      size_t n, srclen;
-
-      srclen = STRLEN (source);
-      if (srclen >= (*size - *indx))
-	{
-	  n = srclen + *indx;
-	  n = (n + DEFAULT_ARRAY_SIZE) - (n % DEFAULT_ARRAY_SIZE);
-	  target = (char *)xrealloc (target, (*size = n));
-	}
-
-      FASTCOPY (source, target + *indx, srclen);
-      *indx += srclen;
-      target[*indx] = '\0';
-
-      free (source);
-    }
-  return (target);
-}
-
-#if 0
-/* UNUSED */
-/* Append the textual representation of NUMBER to TARGET.
-   INDX and SIZE are as in SUB_APPEND_STRING. */
-char *
-sub_append_number (number, target, indx, size)
-     intmax_t number;
-     char *target;
-     size_t *indx;
-     size_t *size;
-{
-  char *temp;
-
-  temp = itos (number);
-  return (sub_append_string (temp, target, indx, size));
-}
-#endif
-
-/* Extract a substring from STRING, starting at SINDEX and ending with
-   one of the characters in CHARLIST.  Don't make the ending character
-   part of the string.  Leave SINDEX pointing at the ending character.
-   Understand about backslashes in the string.  If (flags & SX_VARNAME)
-   is non-zero, and array variables have been compiled into the shell,
-   everything between a `[' and a corresponding `]' is skipped over.
-   If (flags & SX_NOALLOC) is non-zero, don't return the substring, just
-   update SINDEX.  If (flags & SX_REQMATCH) is non-zero, the string must
-   contain a closing character from CHARLIST. */
-static char *
-string_extract (string, sindex, charlist, flags)
-     char *string;
-     int *sindex;
-     char *charlist;
-     int flags;
-{
-  register int c, i;
-  int found;
-  size_t slen;
-  char *temp;
-  DECLARE_MBSTATE;
-
-  slen = (MB_CUR_MAX > 1) ? strlen (string + *sindex) + *sindex : 0;
-  i = *sindex;
-  found = 0;
-  while (c = string[i])
-    {
-      if (c == '\\')
-	{
-	  if (string[i + 1])
-	    i++;
-	  else
-	    break;
-	}
-#if defined (ARRAY_VARS)
-      else if ((flags & SX_VARNAME) && c == LBRACK)
-	{
-	  int ni;
-	  /* If this is an array subscript, skip over it and continue. */
-	  ni = skipsubscript (string, i, 0);
-	  if (string[ni] == RBRACK)
-	    i = ni;
-	}
-#endif
-      else if (MEMBER (c, charlist))
-	{
-	  found = 1;
-	  break;
-	}
-
-      ADVANCE_CHAR (string, slen, i);
-    }
-
-  /* If we had to have a matching delimiter and didn't find one, return an
-     error and let the caller deal with it. */
-  if ((flags & SX_REQMATCH) && found == 0)
-    {
-      *sindex = i;
-      return (&extract_string_error);
-    }
-  
-  temp = (flags & SX_NOALLOC) ? (char *)NULL : substring (string, *sindex, i);
-  *sindex = i;
-  
-  return (temp);
-}
-
-/* Extract the contents of STRING as if it is enclosed in double quotes.
-   SINDEX, when passed in, is the offset of the character immediately
-   following the opening double quote; on exit, SINDEX is left pointing after
-   the closing double quote.  If STRIPDQ is non-zero, unquoted double
-   quotes are stripped and the string is terminated by a null byte.
-   Backslashes between the embedded double quotes are processed.  If STRIPDQ
-   is zero, an unquoted `"' terminates the string. */
-static char *
-string_extract_double_quoted (string, sindex, flags)
-     char *string;
-     int *sindex, flags;
-{
-  size_t slen;
-  char *send;
-  int j, i, t;
-  unsigned char c;
-  char *temp, *ret;		/* The new string we return. */
-  int pass_next, backquote, si;	/* State variables for the machine. */
-  int dquote;
-  int stripdq;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string + *sindex) + *sindex;
-  send = string + slen;
-
-  stripdq = (flags & SX_STRIPDQ);
-
-  pass_next = backquote = dquote = 0;
-  temp = (char *)xmalloc (1 + slen - *sindex);
-
-  j = 0;
-  i = *sindex;
-  while (c = string[i])
-    {
-      /* Process a character that was quoted by a backslash. */
-      if (pass_next)
-	{
-	  /* XXX - take another look at this in light of Interp 221 */
-	  /* Posix.2 sez:
-
-	     ``The backslash shall retain its special meaning as an escape
-	     character only when followed by one of the characters:
-		$	`	"	\	<newline>''.
-
-	     If STRIPDQ is zero, we handle the double quotes here and let
-	     expand_word_internal handle the rest.  If STRIPDQ is non-zero,
-	     we have already been through one round of backslash stripping,
-	     and want to strip these backslashes only if DQUOTE is non-zero,
-	     indicating that we are inside an embedded double-quoted string. */
-
-	  /* If we are in an embedded quoted string, then don't strip
-	     backslashes before characters for which the backslash
-	     retains its special meaning, but remove backslashes in
-	     front of other characters.  If we are not in an
-	     embedded quoted string, don't strip backslashes at all.
-	     This mess is necessary because the string was already
-	     surrounded by double quotes (and sh has some really weird
-	     quoting rules).
-	     The returned string will be run through expansion as if
-	     it were double-quoted. */
-	  if ((stripdq == 0 && c != '"') ||
-	      (stripdq && ((dquote && (sh_syntaxtab[c] & CBSDQUOTE)) || dquote == 0)))
-	    temp[j++] = '\\';
-	  pass_next = 0;
-
-add_one_character:
-	  COPY_CHAR_I (temp, j, string, send, i);
-	  continue;
-	}
-
-      /* A backslash protects the next character.  The code just above
-	 handles preserving the backslash in front of any character but
-	 a double quote. */
-      if (c == '\\')
-	{
-	  pass_next++;
-	  i++;
-	  continue;
-	}
-
-      /* Inside backquotes, ``the portion of the quoted string from the
-	 initial backquote and the characters up to the next backquote
-	 that is not preceded by a backslash, having escape characters
-	 removed, defines that command''. */
-      if (backquote)
-	{
-	  if (c == '`')
-	    backquote = 0;
-	  temp[j++] = c;	/* COPY_CHAR_I? */
-	  i++;
-	  continue;
-	}
-
-      if (c == '`')
-	{
-	  temp[j++] = c;
-	  backquote++;
-	  i++;
-	  continue;
-	}
-
-      /* Pass everything between `$(' and the matching `)' or a quoted
-	 ${ ... } pair through according to the Posix.2 specification. */
-      if (c == '$' && ((string[i + 1] == LPAREN) || (string[i + 1] == LBRACE)))
-	{
-	  int free_ret = 1;
-
-	  si = i + 2;
-	  if (string[i + 1] == LPAREN)
-	    ret = extract_command_subst (string, &si, (flags & SX_COMPLETE));
-	  else
-	    ret = extract_dollar_brace_string (string, &si, Q_DOUBLE_QUOTES, 0);
-
-	  temp[j++] = '$';
-	  temp[j++] = string[i + 1];
-
-	  /* Just paranoia; ret will not be 0 unless no_longjmp_on_fatal_error
-	     is set. */
-	  if (ret == 0 && no_longjmp_on_fatal_error)
-	    {
-	      free_ret = 0;
-	      ret = string + i + 2;
-	    }
-
-	  /* XXX - CHECK_STRING_OVERRUN here? */
-	  for (t = 0; ret[t]; t++, j++)
-	    temp[j] = ret[t];
-	  temp[j] = string[si];
-
-	  if (si < i + 2)	/* we went back? */
-	    i += 2;
-	  else if (string[si])
-	    {
-	      j++;
-	      i = si + 1;
-	    }
-	  else
-	    i = si;
-
-	  if (free_ret)
-	    free (ret);
-	  continue;
-	}
-
-      /* Add any character but a double quote to the quoted string we're
-	 accumulating. */
-      if (c != '"')
-	goto add_one_character;
-
-      /* c == '"' */
-      if (stripdq)
-	{
-	  dquote ^= 1;
-	  i++;
-	  continue;
-	}
-
-      break;
-    }
-  temp[j] = '\0';
-
-  /* Point to after the closing quote. */
-  if (c)
-    i++;
-  *sindex = i;
-
-  return (temp);
-}
-
-/* This should really be another option to string_extract_double_quoted. */
-static int
-skip_double_quoted (string, slen, sind, flags)
-     char *string;
-     size_t slen;
-     int sind;
-     int flags;
-{
-  int c, i;
-  char *ret;
-  int pass_next, backquote, si;
-  DECLARE_MBSTATE;
-
-  pass_next = backquote = 0;
-  i = sind;
-  while (c = string[i])
-    {
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else if (c == '\\')
-	{
-	  pass_next++;
-	  i++;
-	  continue;
-	}
-      else if (backquote)
-	{
-	  if (c == '`')
-	    backquote = 0;
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else if (c == '`')
-	{
-	  backquote++;
-	  i++;
-	  continue;
-	}
-      else if (c == '$' && ((string[i + 1] == LPAREN) || (string[i + 1] == LBRACE)))
-	{
-	  si = i + 2;
-	  if (string[i + 1] == LPAREN)
-	    ret = extract_command_subst (string, &si, SX_NOALLOC|(flags&SX_COMPLETE));
-	  else
-	    ret = extract_dollar_brace_string (string, &si, Q_DOUBLE_QUOTES, SX_NOALLOC);
-
-	  /* These can consume the entire string if they are unterminated */
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  i = si + 1;
-	  continue;
-	}
-      else if (c != '"')
-	{
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else
-	break;
-    }
-
-  if (c)
-    i++;
-
-  return (i);
-}
-
-/* Extract the contents of STRING as if it is enclosed in single quotes.
-   SINDEX, when passed in, is the offset of the character immediately
-   following the opening single quote; on exit, SINDEX is left pointing after
-   the closing single quote. ALLOWESC allows the single quote to be quoted by
-   a backslash; it's not used yet. */
-static inline char *
-string_extract_single_quoted (string, sindex, allowesc)
-     char *string;
-     int *sindex;
-     int allowesc;
-{
-  register int i;
-  size_t slen;
-  char *t;
-  int pass_next;
-  DECLARE_MBSTATE;
-
-  /* Don't need slen for ADVANCE_CHAR unless multibyte chars possible. */
-  slen = (MB_CUR_MAX > 1) ? strlen (string + *sindex) + *sindex : 0;
-  i = *sindex;
-  pass_next = 0;
-  while (string[i])
-    {
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      if (allowesc && string[i] == '\\')
-	pass_next++;
-      else if (string[i] == '\'')
-        break;
-      ADVANCE_CHAR (string, slen, i);
-    }
-
-  t = substring (string, *sindex, i);
-
-  if (string[i])
-    i++;
-  *sindex = i;
-
-  return (t);
-}
-
-/* Skip over a single-quoted string.  We overload the SX_COMPLETE flag to mean
-   that we are splitting out words for completion and have encountered a $'...'
-   string, which allows backslash-escaped single quotes. */
-static inline int
-skip_single_quoted (string, slen, sind, flags)
-     const char *string;
-     size_t slen;
-     int sind;
-     int flags;
-{
-  register int c;
-  DECLARE_MBSTATE;
-
-  c = sind;
-  while (string[c] && string[c] != '\'')
-    {
-      if ((flags & SX_COMPLETE) && string[c] == '\\' && string[c+1] == '\'' && string[c+2])
-	ADVANCE_CHAR (string, slen, c);
-      ADVANCE_CHAR (string, slen, c);
-    }
-
-  if (string[c])
-    c++;
-  return c;
-}
-
-/* Just like string_extract, but doesn't hack backslashes or any of
-   that other stuff.  Obeys CTLESC quoting.  Used to do splitting on $IFS. */
-static char *
-string_extract_verbatim (string, slen, sindex, charlist, flags)
-     char *string;
-     size_t slen;
-     int *sindex;
-     char *charlist;
-     int flags;
-{
-  register int i;
-#if defined (HANDLE_MULTIBYTE)
-  wchar_t *wcharlist;
-#endif
-  int c;
-  char *temp;
-  DECLARE_MBSTATE;
-
-  if ((flags & SX_NOCTLESC) && charlist[0] == '\'' && charlist[1] == '\0')
-    {
-      temp = string_extract_single_quoted (string, sindex, 0);
-      --*sindex;	/* leave *sindex at separator character */
-      return temp;
-    }
-
-  /* This can never be called with charlist == NULL. If *charlist == NULL,
-     we can skip the loop and just return a copy of the string, updating
-     *sindex */
-  if (*charlist == 0)
-    {
-      temp = string + *sindex;
-      c = (*sindex == 0) ? slen : STRLEN (temp);
-      temp = savestring (temp);
-      *sindex += c;
-      return temp;
-    }
-
-  i = *sindex;
-#if defined (HANDLE_MULTIBYTE)
-  wcharlist = 0;
-#endif
-  while (c = string[i])
-    {
-#if defined (HANDLE_MULTIBYTE)
-      size_t mblength;
-#endif
-      if ((flags & SX_NOCTLESC) == 0 && c == CTLESC)
-	{
-	  i += 2;
-	  CHECK_STRING_OVERRUN (i, i, slen, c);
-	  continue;
-	}
-      /* Even if flags contains SX_NOCTLESC, we let CTLESC quoting CTLNUL
-	 through, to protect the CTLNULs from later calls to
-	 remove_quoted_nulls. */
-      else if ((flags & SX_NOESCCTLNUL) == 0 && c == CTLESC && string[i+1] == CTLNUL)
-	{
-	  i += 2;
-	  CHECK_STRING_OVERRUN (i, i, slen, c);
-	  continue;
-	}
-
-#if defined (HANDLE_MULTIBYTE)
-      if (locale_utf8locale && slen > i && UTF8_SINGLEBYTE (string[i]))
-	mblength = (string[i] != 0) ? 1 : 0;
-      else
-	mblength = MBLEN (string + i, slen - i);
-      if (mblength > 1)
-	{
-	  wchar_t wc;
-	  mblength = mbtowc (&wc, string + i, slen - i);
-	  if (MB_INVALIDCH (mblength))
-	    {
-	      if (MEMBER (c, charlist))
-		break;
-	    }
-	  else
-	    {
-	      if (wcharlist == 0)
-		{
-		  size_t len;
-		  len = mbstowcs (wcharlist, charlist, 0);
-		  if (len == -1)
-		    len = 0;
-		  wcharlist = (wchar_t *)xmalloc (sizeof (wchar_t) * (len + 1));
-		  mbstowcs (wcharlist, charlist, len + 1);
-		}
-
-	      if (wcschr (wcharlist, wc))
-		break;
-	    }
-	}
-      else		
-#endif
-      if (MEMBER (c, charlist))
-	break;
-
-      ADVANCE_CHAR (string, slen, i);
-    }
-
-#if defined (HANDLE_MULTIBYTE)
-  FREE (wcharlist);
-#endif
-
-  temp = substring (string, *sindex, i);
-  *sindex = i;
-
-  return (temp);
-}
-
-/* Extract the $( construct in STRING, and return a new string.
-   Start extracting at (SINDEX) as if we had just seen "$(".
-   Make (SINDEX) get the position of the matching ")". )
-   XFLAGS is additional flags to pass to other extraction functions. */
-char *
-extract_command_subst (string, sindex, xflags)
-     char *string;
-     int *sindex;
-     int xflags;
-{
-  char *ret;
-
-  if (string[*sindex] == LPAREN || (xflags & SX_COMPLETE))
-    return (extract_delimited_string (string, sindex, "$(", "(", ")", xflags|SX_COMMAND)); /*)*/
-  else
-    {
-      xflags |= (no_longjmp_on_fatal_error ? SX_NOLONGJMP : 0);
-      ret = xparse_dolparen (string, string+*sindex, sindex, xflags);
-      return ret;
-    }
-}
-
-/* Extract the $[ construct in STRING, and return a new string. (])
-   Start extracting at (SINDEX) as if we had just seen "$[".
-   Make (SINDEX) get the position of the matching "]". */
-char *
-extract_arithmetic_subst (string, sindex)
-     char *string;
-     int *sindex;
-{
-  return (extract_delimited_string (string, sindex, "$[", "[", "]", 0)); /*]*/
-}
-
-#if defined (PROCESS_SUBSTITUTION)
-/* Extract the <( or >( construct in STRING, and return a new string.
-   Start extracting at (SINDEX) as if we had just seen "<(".
-   Make (SINDEX) get the position of the matching ")". */ /*))*/
-char *
-extract_process_subst (string, starter, sindex, xflags)
-     char *string;
-     char *starter;
-     int *sindex;
-     int xflags;
-{
-#if 0
-  /* XXX - check xflags&SX_COMPLETE here? */
-  return (extract_delimited_string (string, sindex, starter, "(", ")", SX_COMMAND));
-#else
-  xflags |= (no_longjmp_on_fatal_error ? SX_NOLONGJMP : 0);
-  return (xparse_dolparen (string, string+*sindex, sindex, xflags));
-#endif
-}
-#endif /* PROCESS_SUBSTITUTION */
-
-#if defined (ARRAY_VARS)
-/* This can be fooled by unquoted right parens in the passed string. If
-   each caller verifies that the last character in STRING is a right paren,
-   we don't even need to call extract_delimited_string. */
-char *
-extract_array_assignment_list (string, sindex)
-     char *string;
-     int *sindex;
-{
-  int slen;
-  char *ret;
-
-  slen = strlen (string);
-  if (string[slen - 1] == RPAREN)
-   {
-      ret = substring (string, *sindex, slen - 1);
-      *sindex = slen - 1;
-      return ret;
-    }
-  return 0;  
-}
-#endif
-
-/* Extract and create a new string from the contents of STRING, a
-   character string delimited with OPENER and CLOSER.  SINDEX is
-   the address of an int describing the current offset in STRING;
-   it should point to just after the first OPENER found.  On exit,
-   SINDEX gets the position of the last character of the matching CLOSER.
-   If OPENER is more than a single character, ALT_OPENER, if non-null,
-   contains a character string that can also match CLOSER and thus
-   needs to be skipped. */
-static char *
-extract_delimited_string (string, sindex, opener, alt_opener, closer, flags)
-     char *string;
-     int *sindex;
-     char *opener, *alt_opener, *closer;
-     int flags;
-{
-  int i, c, si;
-  size_t slen;
-  char *t, *result;
-  int pass_character, nesting_level, in_comment;
-  int len_closer, len_opener, len_alt_opener;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string + *sindex) + *sindex;
-  len_opener = STRLEN (opener);
-  len_alt_opener = STRLEN (alt_opener);
-  len_closer = STRLEN (closer);
-
-  pass_character = in_comment = 0;
-
-  nesting_level = 1;
-  i = *sindex;
-
-  while (nesting_level)
-    {
-      c = string[i];
-
-      /* If a recursive call or a call to ADVANCE_CHAR leaves the index beyond
-	 the end of the string, catch it and cut the loop. */
-      if (i > slen)
-	{
-	  i = slen;
-	  c = string[i = slen];
-	  break;
-	}
-
-      if (c == 0)
-	break;
-
-      if (in_comment)
-	{
-	  if (c == '\n')
-	    in_comment = 0;
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-
-      if (pass_character)	/* previous char was backslash */
-	{
-	  pass_character = 0;
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-
-      /* Not exactly right yet; should handle shell metacharacters and
-	 multibyte characters, too.  See COMMENT_BEGIN define in parse.y */
-      if ((flags & SX_COMMAND) && c == '#' && (i == 0 || string[i - 1] == '\n' || shellblank (string[i - 1])))
-	{
-          in_comment = 1;
-          ADVANCE_CHAR (string, slen, i);
-          continue;
-	}
-        
-      if (c == CTLESC || c == '\\')
-	{
-	  pass_character++;
-	  i++;
-	  continue;
-	}
-
-      /* Process a nested command substitution, but only if we're parsing an
-	 arithmetic substitution. */
-      if ((flags & SX_COMMAND) && string[i] == '$' && string[i+1] == LPAREN)
-        {
-          si = i + 2;
-          t = extract_command_subst (string, &si, flags|SX_NOALLOC);
-          CHECK_STRING_OVERRUN (i, si, slen, c);
-          i = si + 1;
-          continue;
-        }
-
-      /* Process a nested OPENER. */
-      if (STREQN (string + i, opener, len_opener))
-	{
-	  si = i + len_opener;
-	  t = extract_delimited_string (string, &si, opener, alt_opener, closer, flags|SX_NOALLOC);
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-	  i = si + 1;
-	  continue;
-	}
-
-      /* Process a nested ALT_OPENER */
-      if (len_alt_opener && STREQN (string + i, alt_opener, len_alt_opener))
-	{
-	  si = i + len_alt_opener;
-	  t = extract_delimited_string (string, &si, alt_opener, alt_opener, closer, flags|SX_NOALLOC);
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-	  i = si + 1;
-	  continue;
-	}
-
-      /* If the current substring terminates the delimited string, decrement
-	 the nesting level. */
-      if (STREQN (string + i, closer, len_closer))
-	{
-	  i += len_closer - 1;	/* move to last byte of the closer */
-	  nesting_level--;
-	  if (nesting_level == 0)
-	    break;
-	}
-
-      /* Pass old-style command substitution through verbatim. */
-      if (c == '`')
-	{
-	  si = i + 1;
-	  t = string_extract (string, &si, "`", flags|SX_NOALLOC);
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-	  i = si + 1;
-	  continue;
-	}
-
-      /* Pass single-quoted and double-quoted strings through verbatim. */
-      if (c == '\'' || c == '"')
-	{
-	  si = i + 1;
-	  i = (c == '\'') ? skip_single_quoted (string, slen, si, 0)
-			  : skip_double_quoted (string, slen, si, 0);
-	  continue;
-	}
-
-      /* move past this character, which was not special. */
-      ADVANCE_CHAR (string, slen, i);
-    }
-
-  if (c == 0 && nesting_level)
-    {
-      if (no_longjmp_on_fatal_error == 0)
-	{
-	  last_command_exit_value = EXECUTION_FAILURE;
-	  report_error (_("bad substitution: no closing `%s' in %s"), closer, string);
-	  exp_jump_to_top_level (DISCARD);
-	}
-      else
-	{
-	  *sindex = i;
-	  return (char *)NULL;
-	}
-    }
-
-  si = i - *sindex - len_closer + 1;
-  if (flags & SX_NOALLOC)
-    result = (char *)NULL;
-  else    
-    {
-      result = (char *)xmalloc (1 + si);
-      strncpy (result, string + *sindex, si);
-      result[si] = '\0';
-    }
-  *sindex = i;
-
-  return (result);
-}
-
-/* A simplified version of extract_dollar_brace_string that exists to handle
-   $'...' and $"..." quoting in here-documents, since the here-document read
-   path doesn't. It's separate because we don't want to mess with the fast
-   common path. We already know we're going to allocate and return a new
-   string and quoted == Q_HERE_DOCUMENT. We might be able to cut it down
-   some more, but extracting strings and adding them as we go adds complexity.
-   This needs to match the logic in parse.y:parse_matched_pair so we get
-   consistent behavior between here-documents and double-quoted strings. */
-static char *
-extract_heredoc_dolbrace_string (string, sindex, quoted, flags)
-     char *string;
-     int *sindex, quoted, flags;
-{
-  register int i, c;
-  size_t slen, tlen, result_index, result_size;
-  int pass_character, nesting_level, si, dolbrace_state;
-  char *result, *t, *send;
-  DECLARE_MBSTATE;
-
-  pass_character = 0;
-  nesting_level = 1;
-  slen = strlen (string + *sindex) + *sindex;
-  send = string + slen;
-
-  result_size = slen;
-  result_index = 0;
-  result = xmalloc (result_size + 1);
-
-  /* This function isn't called if this condition is not true initially. */
-  dolbrace_state = DOLBRACE_QUOTE;
-
-  i = *sindex;
-  while (c = string[i])
-    {
-      if (pass_character)
-	{
-	  pass_character = 0;
-	  RESIZE_MALLOCED_BUFFER (result, result_index, locale_mb_cur_max + 1, result_size, 64);
-	  COPY_CHAR_I (result, result_index, string, send, i);
-	  continue;
-	}
-
-      /* CTLESCs and backslashes quote the next character. */
-      if (c == CTLESC || c == '\\')
-	{
-	  pass_character++;
-	  RESIZE_MALLOCED_BUFFER (result, result_index, 2, result_size, 64);
-	  result[result_index++] = c;
-	  i++;
-	  continue;
-	}
-
-      /* The entire reason we have this separate function right here. */
-      if (c == '$' && string[i+1] == '\'')
-	{
-	  char *ttrans;
-	  int ttranslen;
-
-	  if ((posixly_correct || extended_quote == 0) && dolbrace_state != DOLBRACE_QUOTE && dolbrace_state != DOLBRACE_QUOTE2)
-	    {
-	      RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, 64);
-	      result[result_index++] = '$';
-	      result[result_index++] = '\'';
-	      i += 2;
-	      continue;
-	    }
-
-	  si = i + 2;
-	  t = string_extract_single_quoted (string, &si, 1);	/* XXX */
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  tlen = si - i - 2;	/* -2 since si is one after the close quote */
-	  ttrans = ansiexpand (t, 0, tlen, &ttranslen);
-	  free (t);
-
-	  /* needed to correctly quote any embedded single quotes. */
-	  if (dolbrace_state == DOLBRACE_QUOTE || dolbrace_state == DOLBRACE_QUOTE2)
-	    {
-	      t = sh_single_quote (ttrans);
-	      tlen = strlen (t);
-	      free (ttrans);
-	    }
-	  else if (extended_quote) /* dolbrace_state == DOLBRACE_PARAM */
-	    {
-	      /* This matches what parse.y:parse_matched_pair() does */
-	      t = ttrans;
-	      tlen = strlen (t);
-	    }
-
-	  RESIZE_MALLOCED_BUFFER (result, result_index, tlen + 1, result_size, 64);
-	  strncpy (result + result_index, t, tlen);
-	  result_index += tlen;
-	  free (t);
-	  i = si;
-	  continue;
-	}
-
-#if defined (TRANSLATABLE_STRINGS)
-      if (c == '$' && string[i+1] == '"')
-	{
-	  char *ttrans;
-	  int ttranslen;
-
-	  si = i + 2;
-	  t = string_extract_double_quoted (string, &si, flags);	/* XXX */
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  tlen = si - i - 2;	/* -2 since si is one after the close quote */
-	  ttrans = locale_expand (t, 0, tlen, line_number, &ttranslen);
-	  free (t);
-
-	  t = singlequote_translations ? sh_single_quote (ttrans) : sh_mkdoublequoted (ttrans, ttranslen, 0);
-	  tlen = strlen (t);
-	  free (ttrans);
-
-	  RESIZE_MALLOCED_BUFFER (result, result_index, tlen + 1, result_size, 64);
-	  strncpy (result + result_index, t, tlen);
-	  result_index += tlen;
-	  free (t);
-	  i = si;
-	  continue;
-	}
-#endif /* TRANSLATABLE_STRINGS */
-
-      if (c == '$' && string[i+1] == LBRACE)
-	{
-	  nesting_level++;
-	  RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, 64);
-	  result[result_index++] = c;
-	  result[result_index++] = string[i+1];
-	  i += 2;
-	  if (dolbrace_state == DOLBRACE_QUOTE || dolbrace_state == DOLBRACE_QUOTE2 || dolbrace_state == DOLBRACE_WORD)
-	    dolbrace_state = DOLBRACE_PARAM;
-	  continue;
-	}
-
-      if (c == RBRACE)
-	{
-	  nesting_level--;
-	  if (nesting_level == 0)
-	    break;
-	  RESIZE_MALLOCED_BUFFER (result, result_index, 2, result_size, 64);
-	  result[result_index++] = c;
-	  i++;
-	  continue;
-	}
-
-      /* Pass the contents of old-style command substitutions through
-	 verbatim. */
-      if (c == '`')
-	{
-	  si = i + 1;
-	  t = string_extract (string, &si, "`", flags);	/* already know (flags & SX_NOALLOC) == 0) */
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  tlen = si - i - 1;
-	  RESIZE_MALLOCED_BUFFER (result, result_index, tlen + 3, result_size, 64);
-	  result[result_index++] = c;
-	  strncpy (result + result_index, t, tlen);
-	  result_index += tlen;
-	  result[result_index++] = string[si];
-	  free (t);
-	  i = si + 1;
-	  continue;
-	}
-
-      /* Pass the contents of new-style command substitutions and
-	 arithmetic substitutions through verbatim. */
-      if (string[i] == '$' && string[i+1] == LPAREN)
-	{
-	  si = i + 2;
-	  t = extract_command_subst (string, &si, flags);
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  tlen = si - i - 1;
-	  RESIZE_MALLOCED_BUFFER (result, result_index, tlen + 4, result_size, 64);
-	  result[result_index++] = c;
-	  result[result_index++] = LPAREN;
-	  strncpy (result + result_index, t, tlen);
-	  result_index += tlen;
-	  result[result_index++] = string[si];
-	  free (t);
-	  i = si + 1;
-	  continue;
-	}
-
-#if defined (PROCESS_SUBSTITUTION)
-      /* Technically this should only work at the start of a word */
-      if ((string[i] == '<' || string[i] == '>') && string[i+1] == LPAREN)
-	{
-	  si = i + 2;
-	  t = extract_process_subst (string, (string[i] == '<' ? "<(" : ">)"), &si, flags);
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  tlen = si - i - 1;
-	  RESIZE_MALLOCED_BUFFER (result, result_index, tlen + 4, result_size, 64);
-	  result[result_index++] = c;
-	  result[result_index++] = LPAREN;
-	  strncpy (result + result_index, t, tlen);
-	  result_index += tlen;
-	  result[result_index++] = string[si];
-	  free (t);
-	  i = si + 1;
-	  continue;
-	}
-#endif
-
-      if (c == '\'' && posixly_correct && shell_compatibility_level > 42 && dolbrace_state != DOLBRACE_QUOTE)
-	{
-	  COPY_CHAR_I (result, result_index, string, send, i);
-	  continue;
-	}
-
-      /* Pass the contents of single and double-quoted strings through verbatim. */
-      if (c == '"' || c == '\'')
-	{
-	  si = i + 1;
-	  if (c == '"')
-	    t = string_extract_double_quoted (string, &si, flags);
-	  else
-	    t = string_extract_single_quoted (string, &si, 0);
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  tlen = si - i - 2;	/* -2 since si is one after the close quote */
-	  RESIZE_MALLOCED_BUFFER (result, result_index, tlen + 3, result_size, 64);
-	  result[result_index++] = c;
-	  strncpy (result + result_index, t, tlen);
-	  result_index += tlen;
-	  result[result_index++] = string[si - 1];
-	  free (t);
-	  i = si;
-	  continue;
-	}
-
-      /* copy this character, which was not special. */
-      COPY_CHAR_I (result, result_index, string, send, i);
-
-      /* This logic must agree with parse.y:parse_matched_pair, since they
-	 share the same defines. */
-      if (dolbrace_state == DOLBRACE_PARAM && c == '%' && (i - *sindex) > 1)
-	dolbrace_state = DOLBRACE_QUOTE;
-      else if (dolbrace_state == DOLBRACE_PARAM && c == '#' && (i - *sindex) > 1)
-        dolbrace_state = DOLBRACE_QUOTE;
-      else if (dolbrace_state == DOLBRACE_PARAM && c == '/' && (i - *sindex) > 1)
-        dolbrace_state = DOLBRACE_QUOTE2;	/* XXX */
-      else if (dolbrace_state == DOLBRACE_PARAM && c == '^' && (i - *sindex) > 1)
-        dolbrace_state = DOLBRACE_QUOTE;
-      else if (dolbrace_state == DOLBRACE_PARAM && c == ',' && (i - *sindex) > 1)
-        dolbrace_state = DOLBRACE_QUOTE;
-      /* This is intended to handle all of the [:]op expansions and the substring/
-	 length/pattern removal/pattern substitution expansions. */
-      else if (dolbrace_state == DOLBRACE_PARAM && strchr ("#%^,~:-=?+/", c) != 0)
-	dolbrace_state = DOLBRACE_OP;
-      else if (dolbrace_state == DOLBRACE_OP && strchr ("#%^,~:-=?+/", c) == 0)
-	dolbrace_state = DOLBRACE_WORD;
-    }
-
-  if (c == 0 && nesting_level)
-    {
-      free (result);
-      if (no_longjmp_on_fatal_error == 0)
-	{			/* { */
-	  last_command_exit_value = EXECUTION_FAILURE;
-	  report_error (_("bad substitution: no closing `%s' in %s"), "}", string);
-	  exp_jump_to_top_level (DISCARD);
-	}
-      else
-	{
-	  *sindex = i;
-	  return ((char *)NULL);
-	}
-    }
-
-  *sindex = i;
-  result[result_index] = '\0';
-
-  return (result);
-}
-
-/* Extract a parameter expansion expression within ${ and } from STRING.
-   Obey the Posix.2 rules for finding the ending `}': count braces while
-   skipping over enclosed quoted strings and command substitutions.
-   SINDEX is the address of an int describing the current offset in STRING;
-   it should point to just after the first `{' found.  On exit, SINDEX
-   gets the position of the matching `}'.  QUOTED is non-zero if this
-   occurs inside double quotes. */
-/* XXX -- this is very similar to extract_delimited_string -- XXX */
-static char *
-extract_dollar_brace_string (string, sindex, quoted, flags)
-     char *string;
-     int *sindex, quoted, flags;
-{
-  register int i, c;
-  size_t slen;
-  int pass_character, nesting_level, si, dolbrace_state;
-  char *result, *t;
-  DECLARE_MBSTATE;
-
-  /* The handling of dolbrace_state needs to agree with the code in parse.y:
-     parse_matched_pair().  The different initial value is to handle the
-     case where this function is called to parse the word in
-     ${param op word} (SX_WORD). */
-  dolbrace_state = (flags & SX_WORD) ? DOLBRACE_WORD : DOLBRACE_PARAM;
-  if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && (flags & SX_POSIXEXP))
-    dolbrace_state = DOLBRACE_QUOTE;
-
-  if (quoted == Q_HERE_DOCUMENT && dolbrace_state == DOLBRACE_QUOTE && (flags & SX_NOALLOC) == 0)
-    return (extract_heredoc_dolbrace_string (string, sindex, quoted, flags));
-
-  pass_character = 0;
-  nesting_level = 1;
-  slen = strlen (string + *sindex) + *sindex;
-
-  i = *sindex;
-  while (c = string[i])
-    {
-      if (pass_character)
-	{
-	  pass_character = 0;
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-
-      /* CTLESCs and backslashes quote the next character. */
-      if (c == CTLESC || c == '\\')
-	{
-	  pass_character++;
-	  i++;
-	  continue;
-	}
-
-      if (string[i] == '$' && string[i+1] == LBRACE)
-	{
-	  nesting_level++;
-	  i += 2;
-	  if (dolbrace_state == DOLBRACE_QUOTE || dolbrace_state == DOLBRACE_WORD)
-	    dolbrace_state = DOLBRACE_PARAM;
-	  continue;
-	}
-
-      if (c == RBRACE)
-	{
-	  nesting_level--;
-	  if (nesting_level == 0)
-	    break;
-	  i++;
-	  continue;
-	}
-
-      /* Pass the contents of old-style command substitutions through
-	 verbatim. */
-      if (c == '`')
-	{
-	  si = i + 1;
-	  t = string_extract (string, &si, "`", flags|SX_NOALLOC);
-
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  i = si + 1;
-	  continue;
-	}
-
-      /* Pass the contents of new-style command substitutions and
-	 arithmetic substitutions through verbatim. */
-      if (string[i] == '$' && string[i+1] == LPAREN)
-	{
-	  si = i + 2;
-	  t = extract_command_subst (string, &si, flags|SX_NOALLOC);
-
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  i = si + 1;
-	  continue;
-	}
-
-#if defined (PROCESS_SUBSTITUTION)
-      /* Technically this should only work at the start of a word */
-      if ((string[i] == '<' || string[i] == '>') && string[i+1] == LPAREN)
-	{
-	  si = i + 2;
-	  t = extract_process_subst (string, (string[i] == '<' ? "<(" : ">)"), &si, flags|SX_NOALLOC);
-
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  i = si + 1;
-	  continue;
-	}
-#endif
-
-      /* Pass the contents of double-quoted strings through verbatim. */
-      if (c == '"')
-	{
-	  si = i + 1;
-	  i = skip_double_quoted (string, slen, si, 0);
-	  /* skip_XXX_quoted leaves index one past close quote */
-	  continue;
-	}
-
-      if (c == '\'')
-	{
-/*itrace("extract_dollar_brace_string: c == single quote flags = %d quoted = %d dolbrace_state = %d", flags, quoted, dolbrace_state);*/
-	  if (posixly_correct && shell_compatibility_level > 42 && dolbrace_state != DOLBRACE_QUOTE && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-	    ADVANCE_CHAR (string, slen, i);
-	  else
-	    {
-	      si = i + 1;
-	      i = skip_single_quoted (string, slen, si, 0);
-	    }
-
-          continue;
-	}
-
-#if defined (ARRAY_VARS)
-      if (c == LBRACK && dolbrace_state == DOLBRACE_PARAM)
-	{
-	  si = skipsubscript (string, i, 0);
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-	  if (string[si] == RBRACK)
-	    c = string[i = si];
-	}
-#endif
-
-      /* move past this character, which was not special. */
-      ADVANCE_CHAR (string, slen, i);
-
-      /* This logic must agree with parse.y:parse_matched_pair, since they
-	 share the same defines. */
-      if (dolbrace_state == DOLBRACE_PARAM && c == '%' && (i - *sindex) > 1)
-	dolbrace_state = DOLBRACE_QUOTE;
-      else if (dolbrace_state == DOLBRACE_PARAM && c == '#' && (i - *sindex) > 1)
-        dolbrace_state = DOLBRACE_QUOTE;
-      else if (dolbrace_state == DOLBRACE_PARAM && c == '/' && (i - *sindex) > 1)
-        dolbrace_state = DOLBRACE_QUOTE2;	/* XXX */
-      else if (dolbrace_state == DOLBRACE_PARAM && c == '^' && (i - *sindex) > 1)
-        dolbrace_state = DOLBRACE_QUOTE;
-      else if (dolbrace_state == DOLBRACE_PARAM && c == ',' && (i - *sindex) > 1)
-        dolbrace_state = DOLBRACE_QUOTE;
-      /* This is intended to handle all of the [:]op expansions and the substring/
-	 length/pattern removal/pattern substitution expansions. */
-      else if (dolbrace_state == DOLBRACE_PARAM && strchr ("#%^,~:-=?+/", c) != 0)
-	dolbrace_state = DOLBRACE_OP;
-      else if (dolbrace_state == DOLBRACE_OP && strchr ("#%^,~:-=?+/", c) == 0)
-	dolbrace_state = DOLBRACE_WORD;
-    }
-
-  if (c == 0 && nesting_level)
-    {
-      if (no_longjmp_on_fatal_error == 0)
-	{			/* { */
-	  last_command_exit_value = EXECUTION_FAILURE;
-	  report_error (_("bad substitution: no closing `%s' in %s"), "}", string);
-	  exp_jump_to_top_level (DISCARD);
-	}
-      else
-	{
-	  *sindex = i;
-	  return ((char *)NULL);
-	}
-    }
-
-  result = (flags & SX_NOALLOC) ? (char *)NULL : substring (string, *sindex, i);
-  *sindex = i;
-
-  return (result);
-}
-
-/* Remove backslashes which are quoting backquotes from STRING.  Modifies
-   STRING, and returns a pointer to it. */
-char *
-de_backslash (string)
-     char *string;
-{
-  register size_t slen;
-  register int i, j, prev_i;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  i = j = 0;
-
-  /* Loop copying string[i] to string[j], i >= j. */
-  while (i < slen)
-    {
-      if (string[i] == '\\' && (string[i + 1] == '`' || string[i + 1] == '\\' ||
-			      string[i + 1] == '$'))
-	i++;
-      prev_i = i;
-      ADVANCE_CHAR (string, slen, i);
-      if (j < prev_i)
-	do string[j++] = string[prev_i++]; while (prev_i < i);
-      else
-	j = i;
-    }
-  string[j] = '\0';
-
-  return (string);
-}
-
-#if 0
-/*UNUSED*/
-/* Replace instances of \! in a string with !. */
-void
-unquote_bang (string)
-     char *string;
-{
-  register int i, j;
-  register char *temp;
-
-  temp = (char *)xmalloc (1 + strlen (string));
-
-  for (i = 0, j = 0; (temp[j] = string[i]); i++, j++)
-    {
-      if (string[i] == '\\' && string[i + 1] == '!')
-	{
-	  temp[j] = '!';
-	  i++;
-	}
-    }
-  strcpy (string, temp);
-  free (temp);
-}
-#endif
-
-#define CQ_RETURN(x) do { no_longjmp_on_fatal_error = oldjmp; return (x); } while (0)
-
-/* When FLAGS & 2 == 0, this function assumes STRING[I] == OPEN; when
-   FLAGS & 2 != 0, it assumes STRING[I] points to one character past OPEN;
-   returns with STRING[RET] == close; used to parse array subscripts.
-   FLAGS & 1 means not to attempt to skip over matched pairs of quotes or
-   backquotes, or skip word expansions; it is intended to be used after
-   expansion has been performed and during final assignment parsing (see
-   arrayfunc.c:assign_compound_array_list()) or during execution by a builtin
-   which has already undergone word expansion. */
-static int
-skip_matched_pair (string, start, open, close, flags)
-     const char *string;
-     int start, open, close, flags;
-{
-  int i, pass_next, backq, si, c, count, oldjmp;
-  size_t slen;
-  char *temp, *ss;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string + start) + start;
-  oldjmp = no_longjmp_on_fatal_error;
-  no_longjmp_on_fatal_error = 1;
-
-  /* Move to the first character after a leading OPEN. If FLAGS&2, we assume
-    that START already points to that character. If not, we need to skip over
-    it here. */
-  i = (flags & 2) ? start : start + 1;
-  count = 1;
-  pass_next = backq = 0;
-  ss = (char *)string;
-  while (c = string[i])
-    {
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  if (c == 0)
-	    CQ_RETURN(i);
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else if ((flags & 1) == 0 && c == '\\')
-	{
-	  pass_next = 1;
-	  i++;
-	  continue;
-	}
-      else if (backq)
-	{
-	  if (c == '`')
-	    backq = 0;
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else if ((flags & 1) == 0 && c == '`')
-	{
-	  backq = 1;
-	  i++;
-	  continue;
-	}
-      else if ((flags & 1) == 0 && c == open)
-	{
-	  count++;
-	  i++;
-	  continue;
-	}
-      else if (c == close)
-	{
-	  count--;
-	  if (count == 0)
-	    break;
-	  i++;
-	  continue;
-	}
-      else if ((flags & 1) == 0 && (c == '\'' || c == '"'))
-	{
-	  i = (c == '\'') ? skip_single_quoted (ss, slen, ++i, 0)
-			  : skip_double_quoted (ss, slen, ++i, 0);
-	  /* no increment, the skip functions increment past the closing quote. */
-	}
-      else if ((flags & 1) == 0 && c == '$' && (string[i+1] == LPAREN || string[i+1] == LBRACE))
-	{
-	  si = i + 2;
-	  if (string[si] == '\0')
-	    CQ_RETURN(si);
-
-	  /* XXX - extract_command_subst here? */
-	  if (string[i+1] == LPAREN)
-	    temp = extract_delimited_string (ss, &si, "$(", "(", ")", SX_NOALLOC|SX_COMMAND); /* ) */
-	  else
-	    temp = extract_dollar_brace_string (ss, &si, 0, SX_NOALLOC);
-
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-
-	  i = si;
-	  if (string[i] == '\0')	/* don't increment i past EOS in loop */
-	    break;
-	  i++;
-	  continue;
-	}
-      else
-	ADVANCE_CHAR (string, slen, i);
-    }
-
-  CQ_RETURN(i);
-}
-
-#if defined (ARRAY_VARS)
-/* FLAGS has 1 as a reserved value, since skip_matched_pair uses it for
-   skipping over quoted strings and taking the first instance of the
-   closing character. FLAGS & 2 means that STRING[START] points one
-   character past the open bracket; FLAGS & 2 == 0 means that STRING[START]
-   points to the open bracket. skip_matched_pair knows how to deal with this. */
-int
-skipsubscript (string, start, flags)
-     const char *string;
-     int start, flags;
-{
-  return (skip_matched_pair (string, start, '[', ']', flags));
-}
-#endif
-
-/* Skip characters in STRING until we find a character in DELIMS, and return
-   the index of that character.  START is the index into string at which we
-   begin.  This is similar in spirit to strpbrk, but it returns an index into
-   STRING and takes a starting index.  This little piece of code knows quite
-   a lot of shell syntax.  It's very similar to skip_double_quoted and other
-   functions of that ilk. */
-int
-skip_to_delim (string, start, delims, flags)
-     char *string;
-     int start;
-     char *delims;
-     int flags;
-{
-  int i, pass_next, backq, dquote, si, c, oldjmp;
-  int invert, skipquote, skipcmd, noprocsub, completeflag;
-  int arithexp, skipcol;
-  size_t slen;
-  char *temp, open[3];
-  DECLARE_MBSTATE;
-
-  slen = strlen (string + start) + start;
-  oldjmp = no_longjmp_on_fatal_error;
-  if (flags & SD_NOJMP)
-    no_longjmp_on_fatal_error = 1;
-  invert = (flags & SD_INVERT);
-  skipcmd = (flags & SD_NOSKIPCMD) == 0;
-  noprocsub = (flags & SD_NOPROCSUB);
-  completeflag = (flags & SD_COMPLETE) ? SX_COMPLETE : 0;
-
-  arithexp = (flags & SD_ARITHEXP);
-  skipcol = 0;
-
-  i = start;
-  pass_next = backq = dquote = 0;
-  while (c = string[i])
-    {
-      /* If this is non-zero, we should not let quote characters be delimiters
-	 and the current character is a single or double quote.  We should not
-	 test whether or not it's a delimiter until after we skip single- or
-	 double-quoted strings. */
-      skipquote = ((flags & SD_NOQUOTEDELIM) && (c == '\'' || c =='"'));
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  if (c == 0)
-	    CQ_RETURN(i);
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else if (c == '\\')
-	{
-	  pass_next = 1;
-	  i++;
-	  continue;
-	}
-      else if (backq)
-	{
-	  if (c == '`')
-	    backq = 0;
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else if (c == '`')
-	{
-	  backq = 1;
-	  i++;
-	  continue;
-	}
-      else if (arithexp && skipcol && c == ':')
-	{
-	  skipcol--;
-	  i++;
-	  continue;
-	}
-      else if (arithexp && c == '?')
-	{
-	  skipcol++;
-	  i++;
-	  continue;
-	}
-      else if (skipquote == 0 && invert == 0 && member (c, delims))
-	break;
-      /* the usual case is to use skip_xxx_quoted, but we don't skip over double
-	 quoted strings when looking for the history expansion character as a
-	 delimiter. */
-      /* special case for programmable completion which takes place before
-         parser converts backslash-escaped single quotes between $'...' to
-         `regular' single-quoted strings. */
-      else if (completeflag && i > 0 && string[i-1] == '$' && c == '\'')
-	i = skip_single_quoted (string, slen, ++i, SX_COMPLETE);
-      else if (c == '\'')
-	i = skip_single_quoted (string, slen, ++i, 0);
-      else if (c == '"')
-	i = skip_double_quoted (string, slen, ++i, completeflag);
-      else if (c == LPAREN && arithexp)
-        {
-          si = i + 1;
-          if (string[si] == '\0')
-	    CQ_RETURN(si);
-
-	  temp = extract_delimited_string (string, &si, "(", "(", ")", SX_NOALLOC); /* ) */
-	  i = si;
-	  if (string[i] == '\0')	/* don't increment i past EOS in loop */
-	    break;
-	  i++;
-	  continue;         
-        }
-      else if (c == '$' && ((skipcmd && string[i+1] == LPAREN) || string[i+1] == LBRACE))
-	{
-	  si = i + 2;
-	  if (string[si] == '\0')
-	    CQ_RETURN(si);
-
-	  if (string[i+1] == LPAREN)
-	    temp = extract_delimited_string (string, &si, "$(", "(", ")", SX_NOALLOC|SX_COMMAND|completeflag); /* ) */
-	  else
-	    temp = extract_dollar_brace_string (string, &si, 0, SX_NOALLOC);
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-	  i = si;
-	  if (string[i] == '\0')	/* don't increment i past EOS in loop */
-	    break;
-	  i++;
-	  continue;
-	}
-#if defined (PROCESS_SUBSTITUTION)
-      else if (skipcmd && noprocsub == 0 && (c == '<' || c == '>') && string[i+1] == LPAREN)
-	{
-	  si = i + 2;
-	  if (string[si] == '\0')
-	    CQ_RETURN(si);
-
-	  temp = extract_delimited_string (string, &si, (c == '<') ? "<(" : ">(", "(", ")", SX_COMMAND|SX_NOALLOC); /* )) */
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-	  i = si;
-	  if (string[i] == '\0')
-	    break;
-	  i++;
-	  continue;
-	}
-#endif /* PROCESS_SUBSTITUTION */
-#if defined (EXTENDED_GLOB)
-      else if ((flags & SD_EXTGLOB) && extended_glob && string[i+1] == LPAREN && member (c, "?*+!@"))
-	{
-	  si = i + 2;
-	  if (string[si] == '\0')
-	    CQ_RETURN(si);
-
-	  open[0] = c;
-	  open[1] = LPAREN;
-	  open[2] = '\0';
-	  temp = extract_delimited_string (string, &si, open, "(", ")", SX_NOALLOC); /* ) */
-
-	  CHECK_STRING_OVERRUN (i, si, slen, c);
-	  i = si;
-	  if (string[i] == '\0')	/* don't increment i past EOS in loop */
-	    break;
-	  i++;
-	  continue;
-	}
-#endif
-      else if ((flags & SD_GLOB) && c == LBRACK)
-	{
-	  si = i + 1;
-	  if (string[si] == '\0')
-	    CQ_RETURN(si);
-
-	  temp = extract_delimited_string (string, &si, "[", "[", "]", SX_NOALLOC); /* ] */
-
-	  i = si;
-	  if (string[i] == '\0')	/* don't increment i past EOS in loop */
-	    break;
-	  i++;
-	  continue;
-	}
-      else if ((skipquote || invert) && (member (c, delims) == 0))
-	break;
-      else
-	ADVANCE_CHAR (string, slen, i);
-    }
-
-  CQ_RETURN(i);
-}
-
-#if defined (BANG_HISTORY)
-/* Skip to the history expansion character (delims[0]), paying attention to
-   quoted strings and command and process substitution.  This is a stripped-
-   down version of skip_to_delims.  The essential difference is that this
-   resets the quoting state when starting a command substitution */
-int
-skip_to_histexp (string, start, delims, flags)
-     char *string;
-     int start;
-     char *delims;
-     int flags;
-{
-  int i, pass_next, backq, dquote, c, oldjmp;
-  int histexp_comsub, histexp_backq, old_dquote;
-  size_t slen;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string + start) + start;
-  oldjmp = no_longjmp_on_fatal_error;
-  if (flags & SD_NOJMP)
-    no_longjmp_on_fatal_error = 1;
-
-  histexp_comsub = histexp_backq = old_dquote = 0;
-
-  i = start;
-  pass_next = backq = dquote = 0;
-  while (c = string[i])
-    {
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  if (c == 0)
-	    CQ_RETURN(i);
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else if (c == '\\')
-	{
-	  pass_next = 1;
-	  i++;
-	  continue;
-	}
-      else if (backq && c == '`')
-	{
-	  backq = 0;
-	  histexp_backq--;
-	  dquote = old_dquote;
-	  i++;
-	  continue;
-	}
-      else if (c == '`')
-	{
-	  backq = 1;
-	  histexp_backq++;
-	  old_dquote = dquote;		/* simple - one level for now */
-	  dquote = 0;
-	  i++;
-	  continue;
-	}
-      /* When in double quotes, act as if the double quote is a member of
-	 history_no_expand_chars, like the history library does */
-      else if (dquote && c == delims[0] && string[i+1] == '"')
-	{
-	  i++;
-	  continue;
-	}
-      else if (c == delims[0])
-	break;
-      /* the usual case is to use skip_xxx_quoted, but we don't skip over double
-	 quoted strings when looking for the history expansion character as a
-	 delimiter. */
-      else if (dquote && c == '\'')
-        {
-          i++;
-          continue;
-        }
-      else if (c == '\'')
-	i = skip_single_quoted (string, slen, ++i, 0);
-      /* The posixly_correct test makes posix-mode shells allow double quotes
-	 to quote the history expansion character */
-      else if (posixly_correct == 0 && c == '"')
-	{
-	  dquote = 1 - dquote;
-	  i++;
-	  continue;
-	}     
-      else if (c == '"')
-	i = skip_double_quoted (string, slen, ++i, 0);
-#if defined (PROCESS_SUBSTITUTION)
-      else if ((c == '$' || c == '<' || c == '>') && string[i+1] == LPAREN && string[i+2] != LPAREN)
-#else
-      else if (c == '$' && string[i+1] == LPAREN && string[i+2] != LPAREN)
-#endif
-        {
-	  if (string[i+2] == '\0')
-	    CQ_RETURN(i+2);
-	  i += 2;
-	  histexp_comsub++;
-	  old_dquote = dquote;
-	  dquote = 0;
-        }
-      else if (histexp_comsub && c == RPAREN)
-	{
-	  histexp_comsub--;
-	  dquote = old_dquote;
-	  i++;
-	  continue;
-	}
-      else if (backq)		/* placeholder */
-	{
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else
-	ADVANCE_CHAR (string, slen, i);
-    }
-
-  CQ_RETURN(i);
-}
-#endif /* BANG_HISTORY */
-
-#if defined (READLINE)
-/* Return 1 if the portion of STRING ending at EINDEX is quoted (there is
-   an unclosed quoted string), or if the character at EINDEX is quoted
-   by a backslash. NO_LONGJMP_ON_FATAL_ERROR is used to flag that the various
-   single and double-quoted string parsing functions should not return an
-   error if there are unclosed quotes or braces.  The characters that this
-   recognizes need to be the same as the contents of
-   rl_completer_quote_characters. */
-
-int
-char_is_quoted (string, eindex)
-     char *string;
-     int eindex;
-{
-  int i, pass_next, c, oldjmp;
-  size_t slen;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  oldjmp = no_longjmp_on_fatal_error;
-  no_longjmp_on_fatal_error = 1;
-  i = pass_next = 0;
-
-  /* If we have an open quoted string from a previous line, see if it's
-     closed before string[eindex], so we don't interpret that close quote
-     as starting a new quoted string. */
-  if (current_command_line_count > 0 && dstack.delimiter_depth > 0)
-    {
-      c = dstack.delimiters[dstack.delimiter_depth - 1];
-      if (c == '\'')
-	i = skip_single_quoted (string, slen, 0, 0);
-      else if (c == '"')
-	i = skip_double_quoted (string, slen, 0, SX_COMPLETE);
-      if (i > eindex)
-	CQ_RETURN (1);
-    }
-
-  while (i <= eindex)
-    {
-      c = string[i];
-
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  if (i >= eindex)	/* XXX was if (i >= eindex - 1) */
-	    CQ_RETURN(1);
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else if (c == '\\')
-	{
-	  pass_next = 1;
-	  i++;
-	  continue;
-	}
-      else if (c == '$' && string[i+1] == '\'' && string[i+2])
-	{
-	  i += 2;
-	  i = skip_single_quoted (string, slen, i, SX_COMPLETE);
-	  if (i > eindex)
-	    CQ_RETURN (i);
-	}
-      else if (c == '\'' || c == '"')
-	{
-	  i = (c == '\'') ? skip_single_quoted (string, slen, ++i, 0)
-			  : skip_double_quoted (string, slen, ++i, SX_COMPLETE);
-	  if (i > eindex)
-	    CQ_RETURN(1);
-	  /* no increment, the skip_xxx functions go one past end */
-	}
-      else
-	ADVANCE_CHAR (string, slen, i);
-    }
-
-  CQ_RETURN(0);
-}
-
-int
-unclosed_pair (string, eindex, openstr)
-     char *string;
-     int eindex;
-     char *openstr;
-{
-  int i, pass_next, openc, olen;
-  size_t slen;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  olen = strlen (openstr);
-  i = pass_next = openc = 0;
-  while (i <= eindex)
-    {
-      if (pass_next)
-	{
-	  pass_next = 0;
-	  if (i >= eindex)	/* XXX was if (i >= eindex - 1) */
-	    return 0;
-	  ADVANCE_CHAR (string, slen, i);
-	  continue;
-	}
-      else if (string[i] == '\\')
-	{
-	  pass_next = 1;
-	  i++;
-	  continue;
-	}
-      else if (STREQN (string + i, openstr, olen))
-	{
-	  openc = 1 - openc;
-	  i += olen;
-	}
-      /* XXX - may want to handle $'...' specially here */
-      else if (string[i] == '\'' || string[i] == '"')
-	{
-	  i = (string[i] == '\'') ? skip_single_quoted (string, slen, i, 0)
-				  : skip_double_quoted (string, slen, i, SX_COMPLETE);
-	  if (i > eindex)
-	    return 0;
-	}
-      else
-	ADVANCE_CHAR (string, slen, i);
-    }
-  return (openc);
-}
-
-/* Split STRING (length SLEN) at DELIMS, and return a WORD_LIST with the
-   individual words.  If DELIMS is NULL, the current value of $IFS is used
-   to split the string, and the function follows the shell field splitting
-   rules.  SENTINEL is an index to look for.  NWP, if non-NULL,
-   gets the number of words in the returned list.  CWP, if non-NULL, gets
-   the index of the word containing SENTINEL.  Non-whitespace chars in
-   DELIMS delimit separate fields.  This is used by programmable completion. */
-WORD_LIST *
-split_at_delims (string, slen, delims, sentinel, flags, nwp, cwp)
-     char *string;
-     int slen;
-     const char *delims;
-     int sentinel, flags;
-     int *nwp, *cwp;
-{
-  int ts, te, i, nw, cw, ifs_split, dflags;
-  char *token, *d, *d2;
-  WORD_LIST *ret, *tl;
-
-  if (string == 0 || *string == '\0')
-    {
-      if (nwp)
-	*nwp = 0;
-      if (cwp)
-	*cwp = 0;	
-      return ((WORD_LIST *)NULL);
-    }
-
-  d = (delims == 0) ? ifs_value : (char *)delims;
-  ifs_split = delims == 0;
-
-  /* Make d2 the non-whitespace characters in delims */
-  d2 = 0;
-  if (delims)
-    {
-      size_t slength;
-#if defined (HANDLE_MULTIBYTE)
-      size_t mblength = 1;
-#endif
-      DECLARE_MBSTATE;
-
-      slength = strlen (delims);
-      d2 = (char *)xmalloc (slength + 1);
-      i = ts = 0;
-      while (delims[i])
-	{
-#if defined (HANDLE_MULTIBYTE)
-	  mbstate_t state_bak;
-	  state_bak = state;
-	  mblength = MBRLEN (delims + i, slength, &state);
-	  if (MB_INVALIDCH (mblength))
-	    state = state_bak;
-	  else if (mblength > 1)
-	    {
-	      memcpy (d2 + ts, delims + i, mblength);
-	      ts += mblength;
-	      i += mblength;
-	      slength -= mblength;
-	      continue;
-	    }
-#endif
-	  if (whitespace (delims[i]) == 0)
-	    d2[ts++] = delims[i];
-
-	  i++;
-	  slength--;
-	}
-      d2[ts] = '\0';
-    }
-
-  ret = (WORD_LIST *)NULL;
-
-  /* Remove sequences of whitespace characters at the start of the string, as
-     long as those characters are delimiters. */
-  for (i = 0; member (string[i], d) && spctabnl (string[i]); i++)
-    ;
-  if (string[i] == '\0')
-    {
-      FREE (d2);
-      return (ret);
-    }
-
-  ts = i;
-  nw = 0;
-  cw = -1;
-  dflags = flags|SD_NOJMP;
-  while (1)
-    {
-      te = skip_to_delim (string, ts, d, dflags);
-
-      /* If we have a non-whitespace delimiter character, use it to make a
-	 separate field.  This is just about what $IFS splitting does and
-	 is closer to the behavior of the shell parser. */
-      if (ts == te && d2 && member (string[ts], d2))
-	{
-	  te = ts + 1;
-	  /* If we're using IFS splitting, the non-whitespace delimiter char
-	     and any additional IFS whitespace delimits a field. */
-	  if (ifs_split)
-	    while (member (string[te], d) && spctabnl (string[te]) && ((flags&SD_NOQUOTEDELIM) == 0 || (string[te] != '\'' && string[te] != '"')))
-	      te++;
-	  else
-	    while (member (string[te], d2) && ((flags&SD_NOQUOTEDELIM) == 0 || (string[te] != '\'' && string[te] != '"')))
-	      te++;
-	}
-
-      token = substring (string, ts, te);
-
-      ret = add_string_to_list (token, ret);	/* XXX */
-      free (token);
-      nw++;
-
-      if (sentinel >= ts && sentinel <= te)
-	cw = nw;
-
-      /* If the cursor is at whitespace just before word start, set the
-	 sentinel word to the current word. */
-      if (cwp && cw == -1 && sentinel == ts-1)
-	cw = nw;
-
-      /* If the cursor is at whitespace between two words, make a new, empty
-	 word, add it before (well, after, since the list is in reverse order)
-	 the word we just added, and set the current word to that one. */
-      if (cwp && cw == -1 && sentinel < ts)
-	{
-	  tl = make_word_list (make_word (""), ret->next);
-	  ret->next = tl;
-	  cw = nw;
-	  nw++;
-	}
-
-      if (string[te] == 0)
-	break;
-
-      i = te;
-      /* XXX - honor SD_NOQUOTEDELIM here */
-      while (member (string[i], d) && (ifs_split || spctabnl(string[i])) && ((flags&SD_NOQUOTEDELIM) == 0 || (string[te] != '\'' && string[te] != '"')))
-	i++;
-
-      if (string[i])
-	ts = i;
-      else
-	break;
-    }
-
-  /* Special case for SENTINEL at the end of STRING.  If we haven't found
-     the word containing SENTINEL yet, and the index we're looking for is at
-     the end of STRING (or past the end of the previously-found token,
-     possible if the end of the line is composed solely of IFS whitespace)
-     add an additional null argument and set the current word pointer to that. */
-  if (cwp && cw == -1 && (sentinel >= slen || sentinel >= te))
-    {
-      if (whitespace (string[sentinel - 1]))
-	{
-	  token = "";
-	  ret = add_string_to_list (token, ret);
-	  nw++;
-	}
-      cw = nw;
-    }
-
-  if (nwp)
-    *nwp = nw;
-  if (cwp)
-    *cwp = cw;
-
-  FREE (d2);
-
-  return (REVERSE_LIST (ret, WORD_LIST *));
-}
-#endif /* READLINE */
-
-#if 0
-/* UNUSED */
-/* Extract the name of the variable to bind to from the assignment string. */
-char *
-assignment_name (string)
-     char *string;
-{
-  int offset;
-  char *temp;
-
-  offset = assignment (string, 0);
-  if (offset == 0)
-    return (char *)NULL;
-  temp = substring (string, 0, offset);
-  return (temp);
-}
-#endif
-
-/* **************************************************************** */
-/*								    */
-/*     Functions to convert strings to WORD_LISTs and vice versa    */
-/*								    */
-/* **************************************************************** */
-
-/* Return a single string of all the words in LIST.  SEP is the separator
-   to put between individual elements of LIST in the output string. */
-char *
-string_list_internal (list, sep)
-     WORD_LIST *list;
-     char *sep;
-{
-  register WORD_LIST *t;
-  char *result, *r;
-  size_t word_len, sep_len, result_size;
-
-  if (list == 0)
-    return ((char *)NULL);
-
-  /* Short-circuit quickly if we don't need to separate anything. */
-  if (list->next == 0)
-    return (savestring (list->word->word));
-
-  /* This is nearly always called with either sep[0] == 0 or sep[1] == 0. */
-  sep_len = STRLEN (sep);
-  result_size = 0;
-
-  for (t = list; t; t = t->next)
-    {
-      if (t != list)
-	result_size += sep_len;
-      result_size += strlen (t->word->word);
-    }
-
-  r = result = (char *)xmalloc (result_size + 1);
-
-  for (t = list; t; t = t->next)
-    {
-      if (t != list && sep_len)
-	{
-	  if (sep_len > 1)
-	    {
-	      FASTCOPY (sep, r, sep_len);
-	      r += sep_len;
-	    }
-	  else
-	    *r++ = sep[0];
-	}
-
-      word_len = strlen (t->word->word);
-      FASTCOPY (t->word->word, r, word_len);
-      r += word_len;
-    }
-
-  *r = '\0';
-  return (result);
-}
-
-/* Return a single string of all the words present in LIST, separating
-   each word with a space. */
-char *
-string_list (list)
-     WORD_LIST *list;
-{
-  return (string_list_internal (list, " "));
-}
-
-/* An external interface that can be used by the rest of the shell to
-   obtain a string containing the first character in $IFS.  Handles all
-   the multibyte complications.  If LENP is non-null, it is set to the
-   length of the returned string. */
-char *
-ifs_firstchar (lenp)
-     int *lenp;
-{
-  char *ret;
-  int len;
-
-  ret = xmalloc (MB_LEN_MAX + 1);
-#if defined (HANDLE_MULTIBYTE)
-  if (ifs_firstc_len == 1)
-    {
-      ret[0] = ifs_firstc[0];
-      ret[1] = '\0';
-      len = ret[0] ? 1 : 0;
-    }
-  else
-    {
-      memcpy (ret, ifs_firstc, ifs_firstc_len);
-      ret[len = ifs_firstc_len] = '\0';
-    }
-#else
-  ret[0] = ifs_firstc;
-  ret[1] = '\0';
-  len = ret[0] ? 0 : 1;
-#endif
-
-  if (lenp)
-    *lenp = len;
-
-  return ret;
-}
-
-/* Return a single string of all the words present in LIST, obeying the
-   quoting rules for "$*", to wit: (P1003.2, draft 11, 3.5.2) "If the
-   expansion [of $*] appears within a double quoted string, it expands
-   to a single field with the value of each parameter separated by the
-   first character of the IFS variable, or by a <space> if IFS is unset." */
-/* Posix interpretation 888 changes this when IFS is null by specifying
-   that when unquoted, this expands to separate arguments */
-char *
-string_list_dollar_star (list, quoted, flags)
-     WORD_LIST *list;
-     int quoted, flags;
-{
-  char *ret;
-#if defined (HANDLE_MULTIBYTE)
-#  if defined (__GNUC__)
-  char sep[MB_CUR_MAX + 1];
-#  else
-  char *sep = 0;
-#  endif
-#else
-  char sep[2];
-#endif
-
-#if defined (HANDLE_MULTIBYTE)
-#  if !defined (__GNUC__)
-  sep = (char *)xmalloc (MB_CUR_MAX + 1);
-#  endif /* !__GNUC__ */
-  if (ifs_firstc_len == 1)
-    {
-      sep[0] = ifs_firstc[0];
-      sep[1] = '\0';
-    }
-  else
-    {
-      memcpy (sep, ifs_firstc, ifs_firstc_len);
-      sep[ifs_firstc_len] = '\0';
-    }
-#else
-  sep[0] = ifs_firstc;
-  sep[1] = '\0';
-#endif
-
-  ret = string_list_internal (list, sep);
-#if defined (HANDLE_MULTIBYTE) && !defined (__GNUC__)
-  free (sep);
-#endif
-  return ret;
-}
-
-/* Turn $@ into a string.  If (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-   is non-zero, the $@ appears within double quotes, and we should quote
-   the list before converting it into a string.  If IFS is unset, and the
-   word is not quoted, we just need to quote CTLESC and CTLNUL characters
-   in the words in the list, because the default value of $IFS is
-   <space><tab><newline>, IFS characters in the words in the list should
-   also be split.  If IFS is null, and the word is not quoted, we need
-   to quote the words in the list to preserve the positional parameters
-   exactly.
-   Valid values for the FLAGS argument are the PF_ flags in command.h,
-   the only one we care about is PF_ASSIGNRHS.  $@ is supposed to expand
-   to the positional parameters separated by spaces no matter what IFS is
-   set to if in a context where word splitting is not performed.  The only
-   one that we didn't handle before is assignment statement arguments to
-   declaration builtins like `declare'. */
-char *
-string_list_dollar_at (list, quoted, flags)
-     WORD_LIST *list;
-     int quoted;
-     int flags;
-{
-  char *ifs, *ret;
-#if defined (HANDLE_MULTIBYTE)
-#  if defined (__GNUC__)
-  char sep[MB_CUR_MAX + 1];
-#  else
-  char *sep = 0;
-#  endif /* !__GNUC__ */
-#else
-  char sep[2];
-#endif
-  WORD_LIST *tlist;
-
-  /* XXX this could just be ifs = ifs_value; */
-  ifs = ifs_var ? value_cell (ifs_var) : (char *)0;
-
-#if defined (HANDLE_MULTIBYTE)
-#  if !defined (__GNUC__)
-  sep = (char *)xmalloc (MB_CUR_MAX + 1);
-#  endif /* !__GNUC__ */
-  /* XXX - testing PF_ASSIGNRHS to make sure positional parameters are
-     separated with a space even when word splitting will not occur. */
-  if (flags & PF_ASSIGNRHS)
-    {
-      sep[0] = ' ';
-      sep[1] = '\0';
-    }
-  else if (ifs && *ifs)
-    {
-      if (ifs_firstc_len == 1)
-	{
-	  sep[0] = ifs_firstc[0];
-	  sep[1] = '\0';
-	}
-      else
-	{
-	  memcpy (sep, ifs_firstc, ifs_firstc_len);
-	  sep[ifs_firstc_len] = '\0';
-	}
-    }
-  else
-    {
-      sep[0] = ' ';
-      sep[1] = '\0';
-    }
-#else	/* !HANDLE_MULTIBYTE */
-  /* XXX - PF_ASSIGNRHS means no word splitting, so we want positional
-     parameters separated by a space. */
-  sep[0] = ((flags & PF_ASSIGNRHS) || ifs == 0 || *ifs == 0) ? ' ' : *ifs;
-  sep[1] = '\0';
-#endif	/* !HANDLE_MULTIBYTE */
-
-  /* XXX -- why call quote_list if ifs == 0?  we can get away without doing
-     it now that quote_escapes quotes spaces */
-  tlist = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES|Q_PATQUOTE))
-		? quote_list (list)
-		: list_quote_escapes (list);
-
-  ret = string_list_internal (tlist, sep);
-#if defined (HANDLE_MULTIBYTE) && !defined (__GNUC__)
-  free (sep);
-#endif
-  return ret;
-}
-
-/* Turn the positional parameters into a string, understanding quoting and
-   the various subtleties of using the first character of $IFS as the
-   separator.  Calls string_list_dollar_at, string_list_dollar_star, and
-   string_list as appropriate. */
-/* This needs to fully understand the additional contexts where word
-   splitting does not occur (W_ASSIGNRHS, etc.) */
-char *
-string_list_pos_params (pchar, list, quoted, pflags)
-     int pchar;
-     WORD_LIST *list;
-     int quoted, pflags;
-{
-  char *ret;
-  WORD_LIST *tlist;
-
-  if (pchar == '*' && (quoted & Q_DOUBLE_QUOTES))
-    {
-      tlist = quote_list (list);
-      word_list_remove_quoted_nulls (tlist);
-      ret = string_list_dollar_star (tlist, 0, 0);
-    }
-  else if (pchar == '*' && (quoted & Q_HERE_DOCUMENT))
-    {
-      tlist = quote_list (list);
-      word_list_remove_quoted_nulls (tlist);
-      ret = string_list (tlist);
-    }
-  else if (pchar == '*' && quoted == 0 && ifs_is_null)	/* XXX */
-    ret = expand_no_split_dollar_star ? string_list_dollar_star (list, quoted, 0) : string_list_dollar_at (list, quoted, 0);	/* Posix interp 888 */
-  else if (pchar == '*' && quoted == 0 && (pflags & PF_ASSIGNRHS))	/* XXX */
-    ret = expand_no_split_dollar_star ? string_list_dollar_star (list, quoted, 0) : string_list_dollar_at (list, quoted, 0);	/* Posix interp 888 */
-  else if (pchar == '*')
-    {
-      /* Even when unquoted, string_list_dollar_star does the right thing
-	 making sure that the first character of $IFS is used as the
-	 separator. */
-      ret = string_list_dollar_star (list, quoted, 0);
-    }
-  else if (pchar == '@' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-    /* We use string_list_dollar_at, but only if the string is quoted, since
-       that quotes the escapes if it's not, which we don't want.  We could
-       use string_list (the old code did), but that doesn't do the right
-       thing if the first character of $IFS is not a space.  We use
-       string_list_dollar_star if the string is unquoted so we make sure that
-       the elements of $@ are separated by the first character of $IFS for
-       later splitting. */
-    ret = string_list_dollar_at (list, quoted, 0);
-  else if (pchar == '@' && quoted == 0 && ifs_is_null)	/* XXX */
-    ret = string_list_dollar_at (list, quoted, 0);	/* Posix interp 888 */
-  else if (pchar == '@' && quoted == 0 && (pflags & PF_ASSIGNRHS))
-    ret = string_list_dollar_at (list, quoted, pflags);	/* Posix interp 888 */
-  else if (pchar == '@')
-    ret = string_list_dollar_star (list, quoted, 0);
-  else
-    ret = string_list ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? quote_list (list) : list);
-
-  return ret;
-}
-
-/* Return the list of words present in STRING.  Separate the string into
-   words at any of the characters found in SEPARATORS.  If QUOTED is
-   non-zero then word in the list will have its quoted flag set, otherwise
-   the quoted flag is left as make_word () deemed fit.
-
-   This obeys the P1003.2 word splitting semantics.  If `separators' is
-   exactly <space><tab><newline>, then the splitting algorithm is that of
-   the Bourne shell, which treats any sequence of characters from `separators'
-   as a delimiter.  If IFS is unset, which results in `separators' being set
-   to "", no splitting occurs.  If separators has some other value, the
-   following rules are applied (`IFS white space' means zero or more
-   occurrences of <space>, <tab>, or <newline>, as long as those characters
-   are in `separators'):
-
-	1) IFS white space is ignored at the start and the end of the
-	   string.
-	2) Each occurrence of a character in `separators' that is not
-	   IFS white space, along with any adjacent occurrences of
-	   IFS white space delimits a field.
-	3) Any nonzero-length sequence of IFS white space delimits a field.
-   */
-
-/* BEWARE!  list_string strips null arguments.  Don't call it twice and
-   expect to have "" preserved! */
-
-/* This performs word splitting and quoted null character removal on
-   STRING. */
-#define issep(c) \
-	(((separators)[0]) ? ((separators)[1] ? isifs(c) \
-					      : (c) == (separators)[0]) \
-			   : 0)
-
-/* member of the space character class in the current locale */
-#define ifs_whitespace(c)	ISSPACE(c)
-
-/* "adjacent IFS white space" */
-#define ifs_whitesep(c)	((sh_style_split || separators == 0) ? spctabnl (c) \
-							     : ifs_whitespace (c))
-
-WORD_LIST *
-list_string (string, separators, quoted)
-     register char *string, *separators;
-     int quoted;
-{
-  WORD_LIST *result;
-  WORD_DESC *t;
-  char *current_word, *s;
-  int sindex, sh_style_split, whitesep, xflags, free_word;
-  size_t slen;
-
-  if (!string || !*string)
-    return ((WORD_LIST *)NULL);
-
-  sh_style_split = separators && separators[0] == ' ' &&
-				 separators[1] == '\t' &&
-				 separators[2] == '\n' &&
-				 separators[3] == '\0';
-  for (xflags = 0, s = ifs_value; s && *s; s++)
-    {
-      if (*s == CTLESC) xflags |= SX_NOCTLESC;
-      else if (*s == CTLNUL) xflags |= SX_NOESCCTLNUL;
-    }
-
-  slen = 0;
-  /* Remove sequences of whitespace at the beginning of STRING, as
-     long as those characters appear in IFS.  Do not do this if
-     STRING is quoted or if there are no separator characters. We use the
-     Posix definition of whitespace as a member of the space character
-     class in the current locale. */
-#if 0
-  if (!quoted || !separators || !*separators)
-#else
-  /* issep() requires that separators be non-null, and always returns 0 if
-     separator is the empty string, so don't bother if we get an empty string
-     for separators. We already returned NULL above if STRING is empty. */
-  if (!quoted && separators && *separators)
-#endif
-    {
-      for (s = string; *s && issep (*s) && ifs_whitespace (*s); s++);
-
-      if (!*s)
-	return ((WORD_LIST *)NULL);
-
-      string = s;
-    }
-
-  /* OK, now STRING points to a word that does not begin with white space.
-     The splitting algorithm is:
-	extract a word, stopping at a separator
-	skip sequences of whitespace characters as long as they are separators
-     This obeys the field splitting rules in Posix.2. */
-  slen = STRLEN (string);
-  for (result = (WORD_LIST *)NULL, sindex = 0; string[sindex]; )
-    {
-      /* Don't need string length in ADVANCE_CHAR unless multibyte chars are
-	 possible, but need it in string_extract_verbatim for bounds checking */
-      current_word = string_extract_verbatim (string, slen, &sindex, separators, xflags);
-      if (current_word == 0)
-	break;
-
-      free_word = 1;	/* If non-zero, we free current_word */
-
-      /* If we have a quoted empty string, add a quoted null argument.  We
-	 want to preserve the quoted null character iff this is a quoted
-	 empty string; otherwise the quoted null characters are removed
-	 below. */
-      if (QUOTED_NULL (current_word))
-	{
-	  t = alloc_word_desc ();
-	  t->word = make_quoted_char ('\0');
-	  t->flags |= W_QUOTED|W_HASQUOTEDNULL;
-	  result = make_word_list (t, result);
-	}
-      else if (current_word[0] != '\0')
-	{
-	  /* If we have something, then add it regardless.  However,
-	     perform quoted null character removal on the current word. */
-	  remove_quoted_nulls (current_word);
-
-	  /* We don't want to set the word flags based on the string contents
-	     here -- that's mostly for the parser -- so we just allocate a
-	     WORD_DESC *, assign current_word (noting that we don't want to
-	     free it), and skip all of make_word. */
-	  t = alloc_word_desc ();
-	  t->word = current_word;
-	  result = make_word_list (t, result);
-	  free_word = 0;
-	  result->word->flags &= ~W_HASQUOTEDNULL;	/* just to be sure */
-	  if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
-	    result->word->flags |= W_QUOTED;
-	  /* If removing quoted null characters leaves an empty word, note
-	     that we saw this for the caller to act on. */
-	  if (current_word == 0 || current_word[0] == '\0')
-	    result->word->flags |= W_SAWQUOTEDNULL;
-	}
-
-      /* If we're not doing sequences of separators in the traditional
-	 Bourne shell style, then add a quoted null argument. */
-      else if (!sh_style_split && !ifs_whitespace (string[sindex]))
-	{
-	  t = alloc_word_desc ();
-	  t->word = make_quoted_char ('\0');
-	  t->flags |= W_QUOTED|W_HASQUOTEDNULL;
-	  result = make_word_list (t, result);
-	}
-
-      if (free_word)
-	free (current_word);
-
-      /* Note whether or not the separator is IFS whitespace, used later. */
-      whitesep = string[sindex] && ifs_whitesep (string[sindex]);
-
-      /* Move past the current separator character. */
-      if (string[sindex])
-	{
-	  DECLARE_MBSTATE;
-	  ADVANCE_CHAR (string, slen, sindex);
-	}
-
-      /* Now skip sequences of whitespace characters if they are
-	 in the list of separators. */
-      while (string[sindex] && ifs_whitesep (string[sindex]) && issep (string[sindex]))
-	sindex++;
-
-      /* If the first separator was IFS whitespace and the current character
-	 is a non-whitespace IFS character, it should be part of the current
-	 field delimiter, not a separate delimiter that would result in an
-	 empty field.  Look at POSIX.2, 3.6.5, (3)(b). */
-      if (string[sindex] && whitesep && issep (string[sindex]) && !ifs_whitesep (string[sindex]))
-	{
-	  sindex++;
-	  /* An IFS character that is not IFS white space, along with any
-	     adjacent IFS white space, shall delimit a field. (SUSv3) */
-	  while (string[sindex] && ifs_whitesep (string[sindex]) && isifs (string[sindex]))
-	    sindex++;
-	}
-    }
-  return (REVERSE_LIST (result, WORD_LIST *));
-}
-
-/* Parse a single word from STRING, using SEPARATORS to separate fields.
-   ENDPTR is set to the first character after the word.  This is used by
-   the `read' builtin.
-   
-   This is never called with SEPARATORS != $IFS, and takes advantage of that.
-
-   XXX - this function is very similar to list_string; they should be
-	 combined - XXX */
-
-/* character is in $IFS */
-#define islocalsep(c)	(local_cmap[(unsigned char)(c)] != 0)
-
-char *
-get_word_from_string (stringp, separators, endptr)
-     char **stringp, *separators, **endptr;
-{
-  register char *s;
-  char *current_word;
-  int sindex, sh_style_split, whitesep, xflags;
-  unsigned char local_cmap[UCHAR_MAX+1];	/* really only need single-byte chars here */
-  size_t slen;
-
-  if (!stringp || !*stringp || !**stringp)
-    return ((char *)NULL);
-
-  sh_style_split = separators && separators[0] == ' ' &&
-				 separators[1] == '\t' &&
-				 separators[2] == '\n' &&
-				 separators[3] == '\0';
-  memset (local_cmap, '\0', sizeof (local_cmap));
-  for (xflags = 0, s = separators; s && *s; s++)
-    {
-      if (*s == CTLESC) xflags |= SX_NOCTLESC;
-      if (*s == CTLNUL) xflags |= SX_NOESCCTLNUL;
-      local_cmap[(unsigned char)*s] = 1;	/* local charmap of separators */
-    }
-
-  s = *stringp;
-  slen = 0;
-
-  /* Remove sequences of whitespace at the beginning of STRING, as
-     long as those characters appear in SEPARATORS.  This happens if
-     SEPARATORS == $' \t\n' or if IFS is unset. */
-  if (sh_style_split || separators == 0)
-    for (; *s && spctabnl (*s) && islocalsep (*s); s++);
-  else
-    for (; *s && ifs_whitespace (*s) && islocalsep (*s); s++);
-
-  /* If the string is nothing but whitespace, update it and return. */
-  if (!*s)
-    {
-      *stringp = s;
-      if (endptr)
-	*endptr = s;
-      return ((char *)NULL);
-    }
-
-  /* OK, S points to a word that does not begin with white space.
-     Now extract a word, stopping at a separator, save a pointer to
-     the first character after the word, then skip sequences of spc,
-     tab, or nl as long as they are separators.
-
-     This obeys the field splitting rules in Posix.2. */
-  sindex = 0;
-  /* Don't need string length in ADVANCE_CHAR unless multibyte chars are
-     possible, but need it in string_extract_verbatim for bounds checking */
-  slen = STRLEN (s);
-  current_word = string_extract_verbatim (s, slen, &sindex, separators, xflags);
-
-  /* Set ENDPTR to the first character after the end of the word. */
-  if (endptr)
-    *endptr = s + sindex;
-
-  /* Note whether or not the separator is IFS whitespace, used later. */
-  whitesep = s[sindex] && ifs_whitesep (s[sindex]);
-
-  /* Move past the current separator character. */
-  if (s[sindex])
-    {
-      DECLARE_MBSTATE;
-      ADVANCE_CHAR (s, slen, sindex);
-    }
-
-  /* Now skip sequences of space, tab, or newline characters if they are
-     in the list of separators. */
-  while (s[sindex] && spctabnl (s[sindex]) && islocalsep (s[sindex]))
-    sindex++;
-
-  /* If the first separator was IFS whitespace and the current character is
-     a non-whitespace IFS character, it should be part of the current field
-     delimiter, not a separate delimiter that would result in an empty field.
-     Look at POSIX.2, 3.6.5, (3)(b). */
-  if (s[sindex] && whitesep && islocalsep (s[sindex]) && !ifs_whitesep (s[sindex]))
-    {
-      sindex++;
-      /* An IFS character that is not IFS white space, along with any adjacent
-	 IFS white space, shall delimit a field. */
-      while (s[sindex] && ifs_whitesep (s[sindex]) && islocalsep(s[sindex]))
-	sindex++;
-    }
-
-  /* Update STRING to point to the next field. */
-  *stringp = s + sindex;
-  return (current_word);
-}
-
-/* Remove IFS white space at the end of STRING.  Start at the end
-   of the string and walk backwards until the beginning of the string
-   or we find a character that's not IFS white space and not CTLESC.
-   Only let CTLESC escape a white space character if SAW_ESCAPE is
-   non-zero.  */
-char *
-strip_trailing_ifs_whitespace (string, separators, saw_escape)
-     char *string, *separators;
-     int saw_escape;
-{
-  char *s;
-
-  s = string + STRLEN (string) - 1;
-  while (s > string && ((spctabnl (*s) && isifs (*s)) ||
-			(saw_escape && *s == CTLESC && spctabnl (s[1]))))
-    s--;
-  *++s = '\0';
-  return string;
-}
-
-#if 0
-/* UNUSED */
-/* Split STRING into words at whitespace.  Obeys shell-style quoting with
-   backslashes, single and double quotes. */
-WORD_LIST *
-list_string_with_quotes (string)
-     char *string;
-{
-  WORD_LIST *list;
-  char *token, *s;
-  size_t s_len;
-  int c, i, tokstart, len;
-
-  for (s = string; s && *s && spctabnl (*s); s++)
-    ;
-  if (s == 0 || *s == 0)
-    return ((WORD_LIST *)NULL);
-
-  s_len = strlen (s);
-  tokstart = i = 0;
-  list = (WORD_LIST *)NULL;
-  while (1)
-    {
-      c = s[i];
-      if (c == '\\')
-	{
-	  i++;
-	  if (s[i])
-	    i++;
-	}
-      else if (c == '\'')
-	i = skip_single_quoted (s, s_len, ++i, 0);
-      else if (c == '"')
-	i = skip_double_quoted (s, s_len, ++i, 0);
-      else if (c == 0 || spctabnl (c))
-	{
-	  /* We have found the end of a token.  Make a word out of it and
-	     add it to the word list. */
-	  token = substring (s, tokstart, i);
-	  list = add_string_to_list (token, list);
-	  free (token);
-	  while (spctabnl (s[i]))
-	    i++;
-	  if (s[i])
-	    tokstart = i;
-	  else
-	    break;
-	}
-      else
-	i++;	/* normal character */
-    }
-  return (REVERSE_LIST (list, WORD_LIST *));
-}
-#endif
-
-/********************************************************/
-/*							*/
-/*	Functions to perform assignment statements	*/
-/*							*/
-/********************************************************/
-
-#if defined (ARRAY_VARS)
-static SHELL_VAR *
-do_compound_assignment (name, value, flags)
-     char *name, *value;
-     int flags;
-{
-  SHELL_VAR *v;
-  int mklocal, mkassoc, mkglobal, chklocal;
-  WORD_LIST *list;
-  char *newname;	/* used for local nameref references */
-
-  mklocal = flags & ASS_MKLOCAL;
-  mkassoc = flags & ASS_MKASSOC;
-  mkglobal = flags & ASS_MKGLOBAL;
-  chklocal = flags & ASS_CHKLOCAL;
-
-  if (mklocal && variable_context)
-    {
-      v = find_variable (name);		/* follows namerefs */
-      newname = (v == 0) ? nameref_transform_name (name, flags) : v->name;
-      if (v && ((readonly_p (v) && (flags & ASS_FORCE) == 0) || noassign_p (v)))
-	{
-	  if (readonly_p (v))
-	    err_readonly (name);
-	  return (v);	/* XXX */
-	}
-      list = expand_compound_array_assignment (v, value, flags);
-      if (mkassoc)
-	v = make_local_assoc_variable (newname, 0);
-      else if (v == 0 || (array_p (v) == 0 && assoc_p (v) == 0) || v->context != variable_context)
-        v = make_local_array_variable (newname, 0);
-      if (v)
-	assign_compound_array_list (v, list, flags);
-      if (list)
-	dispose_words (list);
-    }
-  /* In a function but forcing assignment in global context. CHKLOCAL means to
-     check for an existing local variable first. */
-  else if (mkglobal && variable_context)
-    {
-      v = chklocal ? find_variable (name) : 0;
-      if (v && (local_p (v) == 0 || v->context != variable_context))
-	v = 0;
-      if (v == 0)
-        v = find_global_variable (name);
-      if (v && ((readonly_p (v) && (flags & ASS_FORCE) == 0) || noassign_p (v)))
-	{
-	  if (readonly_p (v))
-	    err_readonly (name);
-	  return (v);	/* XXX */
-	}
-      /* sanity check */
-      newname = (v == 0) ? nameref_transform_name (name, flags) : name;
-      list = expand_compound_array_assignment (v, value, flags);
-      if (v == 0 && mkassoc)
-	v = make_new_assoc_variable (newname);
-      else if (v && mkassoc && assoc_p (v) == 0)
-	v = convert_var_to_assoc (v);
-      else if (v == 0)
-	v = make_new_array_variable (newname);
-      else if (v && mkassoc == 0 && array_p (v) == 0)
-	v = convert_var_to_array (v);
-      if (v)
-	assign_compound_array_list (v, list, flags);
-      if (list)
-	dispose_words (list);
-    }
-  else
-    {
-      v = assign_array_from_string (name, value, flags);
-      if (v && ((readonly_p (v) && (flags & ASS_FORCE) == 0) || noassign_p (v)))
-	{
-	  if (readonly_p (v))
-	    err_readonly (name);
-	  return (v);	/* XXX */
-	}
-    }
-
-  return (v);
-}
-#endif
-
-/* Given STRING, an assignment string, get the value of the right side
-   of the `=', and bind it to the left side.  If EXPAND is true, then
-   perform parameter expansion, command substitution, and arithmetic
-   expansion on the right-hand side.  Perform tilde expansion in any
-   case.  Do not perform word splitting on the result of expansion. */
-static int
-do_assignment_internal (word, expand)
-     const WORD_DESC *word;
-     int expand;
-{
-  int offset, appendop, assign_list, aflags, retval;
-  char *name, *value, *temp;
-  SHELL_VAR *entry;
-#if defined (ARRAY_VARS)
-  char *t;
-  int ni;
-#endif
-  const char *string;
-
-  if (word == 0 || word->word == 0)
-    return 0;
-
-  appendop = assign_list = aflags = 0;
-  string = word->word;
-  offset = assignment (string, 0);
-  name = savestring (string);
-  value = (char *)NULL;
-
-  if (name[offset] == '=')
-    {
-      if (name[offset - 1] == '+')
-	{
-	  appendop = 1;
-	  name[offset - 1] = '\0';
-	}
-
-      name[offset] = 0;		/* might need this set later */
-      temp = name + offset + 1;
-
-#if defined (ARRAY_VARS)
-      if (expand && (word->flags & W_COMPASSIGN))
-	{
-	  assign_list = ni = 1;
-	  value = extract_array_assignment_list (temp, &ni);
-	}
-      else
-#endif
-      if (expand && temp[0])
-	value = expand_string_if_necessary (temp, 0, expand_string_assignment);
-      else
-	value = savestring (temp);
-    }
-
-  if (value == 0)
-    {
-      value = (char *)xmalloc (1);
-      value[0] = '\0';
-    }
-
-  if (echo_command_at_execute)
-    {
-      if (appendop)
-	name[offset - 1] = '+';
-      xtrace_print_assignment (name, value, assign_list, 1);
-      if (appendop)
-	name[offset - 1] = '\0';
-    }
-
-#define ASSIGN_RETURN(r)	do { FREE (value); free (name); return (r); } while (0)
-
-  if (appendop)
-    aflags |= ASS_APPEND;
-
-#if defined (ARRAY_VARS)
-  if (t = mbschr (name, LBRACK))
-    {
-      if (assign_list)
-	{
-	  report_error (_("%s: cannot assign list to array member"), name);
-	  ASSIGN_RETURN (0);
-	}
-      aflags |= ASS_ALLOWALLSUB;	/* allow a[@]=value for existing associative arrays */
-      entry = assign_array_element (name, value, aflags, (array_eltstate_t *)0);
-      if (entry == 0)
-	ASSIGN_RETURN (0);
-    }
-  else if (assign_list)
-    {
-      if ((word->flags & W_ASSIGNARG) && (word->flags & W_CHKLOCAL))
-	aflags |= ASS_CHKLOCAL;
-      if ((word->flags & W_ASSIGNARG) && (word->flags & W_ASSNGLOBAL) == 0)
-	aflags |= ASS_MKLOCAL;
-      if ((word->flags & W_ASSIGNARG) && (word->flags & W_ASSNGLOBAL))
-	aflags |= ASS_MKGLOBAL;
-      if (word->flags & W_ASSIGNASSOC)
-	aflags |= ASS_MKASSOC;
-      entry = do_compound_assignment (name, value, aflags);
-    }
-  else
-#endif /* ARRAY_VARS */
-  entry = bind_variable (name, value, aflags);
-
-  if (entry)
-    stupidly_hack_special_variables (entry->name);	/* might be a nameref */
-  else
-    stupidly_hack_special_variables (name);
-
-  /* Return 1 if the assignment seems to have been performed correctly. */
-  if (entry == 0 || readonly_p (entry))
-    retval = 0;		/* assignment failure */
-  else if (noassign_p (entry))
-    {
-      set_exit_status (EXECUTION_FAILURE);
-      retval = 1;	/* error status, but not assignment failure */
-    }
-  else
-    retval = 1;
-
-  if (entry && retval != 0 && noassign_p (entry) == 0)
-    VUNSETATTR (entry, att_invisible);
-
-  ASSIGN_RETURN (retval);
-}
-
-/* Perform the assignment statement in STRING, and expand the
-   right side by doing tilde, command and parameter expansion. */
-int
-do_assignment (string)
-     char *string;
-{
-  WORD_DESC td;
-
-  td.flags = W_ASSIGNMENT;
-  td.word = string;
-
-  return do_assignment_internal (&td, 1);
-}
-
-int
-do_word_assignment (word, flags)
-     WORD_DESC *word;
-     int flags;
-{
-  return do_assignment_internal (word, 1);
-}
-
-/* Given STRING, an assignment string, get the value of the right side
-   of the `=', and bind it to the left side.  Do not perform any word
-   expansions on the right hand side. */
-int
-do_assignment_no_expand (string)
-     char *string;
-{
-  WORD_DESC td;
-
-  td.flags = W_ASSIGNMENT;
-  td.word = string;
-
-  return (do_assignment_internal (&td, 0));
-}
-
-/***************************************************
- *						   *
- *  Functions to manage the positional parameters  *
- *						   *
- ***************************************************/
-
-/* Return the word list that corresponds to `$*'. */
-WORD_LIST *
-list_rest_of_args ()
-{
-  register WORD_LIST *list, *args;
-  int i;
-
-  /* Break out of the loop as soon as one of the dollar variables is null. */
-  for (i = 1, list = (WORD_LIST *)NULL; i < 10 && dollar_vars[i]; i++)
-    list = make_word_list (make_bare_word (dollar_vars[i]), list);
-
-  for (args = rest_of_args; args; args = args->next)
-    list = make_word_list (make_bare_word (args->word->word), list);
-
-  return (REVERSE_LIST (list, WORD_LIST *));
-}
-
-/* Return the value of a positional parameter.  This handles values > 10. */
-char *
-get_dollar_var_value (ind)
-     intmax_t ind;
-{
-  char *temp;
-  WORD_LIST *p;
-
-  if (ind < 10)
-    temp = dollar_vars[ind] ? savestring (dollar_vars[ind]) : (char *)NULL;
-  else	/* We want something like ${11} */
-    {
-      ind -= 10;
-      for (p = rest_of_args; p && ind--; p = p->next)
-	;
-      temp = p ? savestring (p->word->word) : (char *)NULL;
-    }
-  return (temp);
-}
-
-/* Make a single large string out of the dollar digit variables,
-   and the rest_of_args.  If DOLLAR_STAR is 1, then obey the special
-   case of "$*" with respect to IFS. */
-char *
-string_rest_of_args (dollar_star)
-     int dollar_star;
-{
-  register WORD_LIST *list;
-  char *string;
-
-  list = list_rest_of_args ();
-  string = dollar_star ? string_list_dollar_star (list, 0, 0) : string_list (list);
-  dispose_words (list);
-  return (string);
-}
-
-/* Return a string containing the positional parameters from START to
-   END, inclusive.  If STRING[0] == '*', we obey the rules for $*,
-   which only makes a difference if QUOTED is non-zero.  If QUOTED includes
-   Q_HERE_DOCUMENT or Q_DOUBLE_QUOTES, this returns a quoted list, otherwise
-   no quoting chars are added. */
-static char *
-pos_params (string, start, end, quoted, pflags)
-     char *string;
-     int start, end, quoted, pflags;
-{
-  WORD_LIST *save, *params, *h, *t;
-  char *ret;
-  int i;
-
-  /* see if we can short-circuit.  if start == end, we want 0 parameters. */
-  if (start == end)
-    return ((char *)NULL);
-
-  save = params = list_rest_of_args ();
-  if (save == 0 && start > 0)
-    return ((char *)NULL);
-
-  if (start == 0)		/* handle ${@:0[:x]} specially */
-    {
-      t = make_word_list (make_word (dollar_vars[0]), params);
-      save = params = t;
-    }
-
-  for (i = start ? 1 : 0; params && i < start; i++)
-    params = params->next;
-  if (params == 0)
-    {
-      dispose_words (save);
-      return ((char *)NULL);
-    }
-  for (h = t = params; params && i < end; i++)
-    {
-      t = params;
-      params = params->next;
-    }
-  t->next = (WORD_LIST *)NULL;
-
-  ret = string_list_pos_params (string[0], h, quoted, pflags);
-
-  if (t != params)
-    t->next = params;
-
-  dispose_words (save);
-  return (ret);
-}
-
-/******************************************************************/
-/*								  */
-/*	Functions to expand strings to strings or WORD_LISTs      */
-/*								  */
-/******************************************************************/
-
-#if defined (PROCESS_SUBSTITUTION)
-#define EXP_CHAR(s) (s == '$' || s == '`' || s == '<' || s == '>' || s == CTLESC || s == '~')
-#else
-#define EXP_CHAR(s) (s == '$' || s == '`' || s == CTLESC || s == '~')
-#endif
-
-/* If there are any characters in STRING that require full expansion,
-   then call FUNC to expand STRING; otherwise just perform quote
-   removal if necessary.  This returns a new string. */
-static char *
-expand_string_if_necessary (string, quoted, func)
-     char *string;
-     int quoted;
-     EXPFUNC *func;
-{
-  WORD_LIST *list;
-  size_t slen;
-  int i, saw_quote;
-  char *ret;
-  DECLARE_MBSTATE;
-
-  /* Don't need string length for ADVANCE_CHAR unless multibyte chars possible. */
-  slen = (MB_CUR_MAX > 1) ? strlen (string) : 0;
-  i = saw_quote = 0;
-  while (string[i])
-    {
-      if (EXP_CHAR (string[i]))
-	break;
-      else if (string[i] == '\'' || string[i] == '\\' || string[i] == '"')
-	saw_quote = 1;
-      ADVANCE_CHAR (string, slen, i);
-    }
-
-  if (string[i])
-    {
-      list = (*func) (string, quoted);
-      if (list)
-	{
-	  ret = string_list (list);
-	  dispose_words (list);
-	}
-      else
-	ret = (char *)NULL;
-    }
-  else if (saw_quote && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
-    ret = string_quote_removal (string, quoted);
-  else
-    ret = savestring (string);
-
-  return ret;
-}
-
-static inline char *
-expand_string_to_string_internal (string, quoted, func)
-     char *string;
-     int quoted;
-     EXPFUNC *func;
-{
-  WORD_LIST *list;
-  char *ret;
-
-  if (string == 0 || *string == '\0')
-    return ((char *)NULL);
-
-  list = (*func) (string, quoted);
-  if (list)
-    {
-      ret = string_list (list);
-      dispose_words (list);
-    }
-  else
-    ret = (char *)NULL;
-
-  return (ret);
-}
-
-char *
-expand_string_to_string (string, quoted)
-     char *string;
-     int quoted;
-{
-  return (expand_string_to_string_internal (string, quoted, expand_string));
-}
-
-char *
-expand_string_unsplit_to_string (string, quoted)
-     char *string;
-     int quoted;
-{
-  return (expand_string_to_string_internal (string, quoted, expand_string_unsplit));
-}
-
-char *
-expand_assignment_string_to_string (string, quoted)
-     char *string;
-     int quoted;
-{
-  return (expand_string_to_string_internal (string, quoted, expand_string_assignment));
-}
-
-/* Kind of like a combination of dequote_string and quote_string_for_globbing;
-   try to remove CTLESC quoting characters and convert CTLESC escaping a `&'
-   or a backslash into a backslash. The output of this function must eventually
-   be processed by strcreplace(). */
-static char *
-quote_string_for_repl (string, flags)
-     char *string;
-     int flags;
-{
-  size_t slen;
-  char *result, *t;
-  const char *s, *send;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  send = string + slen;
-
-  result = (char *)xmalloc (slen * 2 + 1);
-
-  if (string[0] == CTLESC && string[1] == 0)
-    {
-      result[0] = CTLESC;
-      result[1] = '\0';
-      return (result);
-    }
-
-  /* This is awkward. We want to translate CTLESC-\ to \\ if we will
-     eventually send this string through strcreplace(), which we will do
-     only if shouldexp_replacement() determines that there is something
-     to replace. We can either make sure to escape backslashes here and
-     have shouldexp_replacement() signal that we should send the string to
-     strcreplace() if it sees an escaped backslash, or we can scan the
-     string before copying it and turn CTLESC-\ into \\ only if we encounter
-     a CTLESC-& or a &. This does the former and changes shouldexp_replacement().
-     If we double the backslashes  here, we'll get doubled backslashes in any
-     result that doesn't get passed to strcreplace(). */
-
-  for (s = string, t = result; *s; )
-    {
-      /* This function's result has to be processed by strcreplace() */
-      if (*s == CTLESC && (s[1] == '&' || s[1] == '\\'))
-        {
-          *t++ = '\\';
-          s++;
-          *t++ = *s++;
-          continue;
-        }
-      /* Dequote it */
-      if (*s == CTLESC)
-        {
-	  s++;
-	  if (*s == '\0')
-	    break;
-        }
-      COPY_CHAR_P (t, s, send);
-    }
-
-  *t = '\0';
-  return (result);
-}
-	
-/* This does not perform word splitting on the WORD_LIST it returns and
-   it treats $* as if it were quoted. It dequotes the WORD_LIST, adds
-   backslash escapes before CTLESC-quoted backslash and `& if 
-   patsub_replacement is enabled. */
-static char *
-expand_string_for_patsub (string, quoted)
-     char *string;
-     int quoted;
-{
-  WORD_LIST *value;
-  char *ret, *t;
-
-  if (string == 0 || *string == '\0')
-    return (char *)NULL;
-
-  value = expand_string_for_pat (string, quoted, (int *)0, (int *)0);
-
-  if (value && value->word)
-    {
-      remove_quoted_nulls (value->word->word);	/* XXX */
-      value->word->flags &= ~W_HASQUOTEDNULL;
-    }
-
-  if (value)
-    {
-      t = (value->next) ? string_list (value) : value->word->word;
-      ret = quote_string_for_repl (t, quoted);
-      if (t != value->word->word)
-	free (t);
-      dispose_words (value);
-    }
-  else
-    ret = (char *)NULL;
-
-  return (ret);
-}
-
-char *
-expand_arith_string (string, quoted)
-     char *string;
-     int quoted;
-{
-  WORD_DESC td;
-  WORD_LIST *list, *tlist;
-  size_t slen;
-  int i, saw_quote;
-  char *ret;
-  DECLARE_MBSTATE;
-
-  /* Don't need string length for ADVANCE_CHAR unless multibyte chars possible. */
-  slen = (MB_CUR_MAX > 1) ? strlen (string) : 0;
-  i = saw_quote = 0;
-  while (string[i])
-    {
-      if (EXP_CHAR (string[i]))
-	break;
-      else if (string[i] == '\'' || string[i] == '\\' || string[i] == '"')
-	saw_quote = string[i];
-      ADVANCE_CHAR (string, slen, i);
-    }
-
-  if (string[i])
-    {
-      /* This is expanded version of expand_string_internal as it's called by
-	 expand_string_leave_quoted  */
-      td.flags = W_NOPROCSUB|W_NOTILDE;	/* don't want process substitution or tilde expansion */
-#if 0	/* TAG: bash-5.2 */
-      if (quoted & Q_ARRAYSUB)
-	td.flags |= W_NOCOMSUB;
-#endif
-      td.word = savestring (string);
-      list = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
-      /* This takes care of the calls from expand_string_leave_quoted and
-	 expand_string */
-      if (list)
-	{
-	  tlist = word_list_split (list);
-	  dispose_words (list);
-	  list = tlist;
-	  if (list)
-	    dequote_list (list);
-	}
-      /* This comes from expand_string_if_necessary */
-      if (list)
-	{
-	  ret = string_list (list);
-	  dispose_words (list);
-	}
-      else
-	ret = (char *)NULL;
-      FREE (td.word);
-    }
-  else if (saw_quote && (quoted & Q_ARITH))
-    ret = string_quote_removal (string, quoted);
-  else if (saw_quote && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
-    ret = string_quote_removal (string, quoted);
-  else
-    ret = savestring (string);
-
-  return ret;
-}
-
-#if defined (COND_COMMAND)
-/* Just remove backslashes in STRING.  Returns a new string. */
-char *
-remove_backslashes (string)
-     char *string;
-{
-  char *r, *ret, *s;
-
-  r = ret = (char *)xmalloc (strlen (string) + 1);
-  for (s = string; s && *s; )
-    {
-      if (*s == '\\')
-	s++;
-      if (*s == 0)
-	break;
-      *r++ = *s++;
-    }
-  *r = '\0';
-  return ret;
-}
-
-/* This needs better error handling. */
-/* Expand W for use as an argument to a unary or binary operator in a
-   [[...]] expression.  If SPECIAL is 1, this is the rhs argument
-   to the != or == operator, and should be treated as a pattern.  In
-   this case, we quote the string specially for the globbing code.  If
-   SPECIAL is 2, this is an rhs argument for the =~ operator, and should
-   be quoted appropriately for regcomp/regexec.  If SPECIAL is 3, this is
-   an array subscript and should be quoted after expansion so it's only
-   expanded once (Q_ARITH). The caller is responsible
-   for removing the backslashes if the unquoted word is needed later. In
-   any case, since we don't perform word splitting, we need to do quoted
-   null character removal. */
-char *
-cond_expand_word (w, special)
-     WORD_DESC *w;
-     int special;
-{
-  char *r, *p;
-  WORD_LIST *l;
-  int qflags;
-
-  if (w->word == 0 || w->word[0] == '\0')
-    return ((char *)NULL);
-
-  expand_no_split_dollar_star = 1;
-  w->flags |= W_NOSPLIT2;
-  qflags = (special == 3) ? Q_ARITH : 0;
-  l = call_expand_word_internal (w, qflags, 0, (int *)0, (int *)0);
-  expand_no_split_dollar_star = 0;
-  if (l)
-    {
-      if (special == 0)			/* LHS */
-	{
-	  if (l->word)
-	    word_list_remove_quoted_nulls (l);
-	  dequote_list (l);
-	  r = string_list (l);
-	}
-      else if (special == 3)		/* arithmetic expression, Q_ARITH */
-	{
-	  if (l->word)
-	    word_list_remove_quoted_nulls (l);	/* for now */
-	  dequote_list (l);
-	  r = string_list (l);
-	}
-      else
-	{
-	  /* Need to figure out whether or not we should call dequote_escapes
-	     or a new dequote_ctlnul function here, and under what
-	     circumstances. */
-	  qflags = QGLOB_CVTNULL|QGLOB_CTLESC;
-	  if (special == 2)
-	    qflags |= QGLOB_REGEXP;
-	  word_list_remove_quoted_nulls (l);
-	  p = string_list (l);
-	  r = quote_string_for_globbing (p, qflags);
-	  free (p);
-	}
-      dispose_words (l);
-    }
-  else
-    r = (char *)NULL;
-
-  return r;
-}
-#endif
-
-/* Expand $'...' and $"..." in a string for code paths that don't do it. The
-   FLAGS argument is 1 if this function should treat CTLESC as a quote
-   character (e.g., for here-documents) or not (e.g., for shell_expand_line). */
-char *
-expand_string_dollar_quote (string, flags)
-     char *string;
-     int flags;
-{
-  size_t slen, retind, retsize;
-  int sindex, c, translen, peekc, news;
-  char *ret, *trans, *send, *t;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  send = string + slen;
-  sindex = 0;
-
-  retsize = slen + 1;
-  ret = xmalloc (retsize);
-  retind = 0;
-
-  while (c = string[sindex])
-    {
-      switch (c)
-	{
-	default:
-	  RESIZE_MALLOCED_BUFFER (ret, retind, locale_mb_cur_max + 1, retsize, 64);
-	  COPY_CHAR_I (ret, retind, string, send, sindex);
-	  break;
-
-	case '\\':
-	  RESIZE_MALLOCED_BUFFER (ret, retind, locale_mb_cur_max + 2, retsize, 64);
-	  ret[retind++] = string[sindex++];
-
-	  if (string[sindex])
-	    COPY_CHAR_I (ret, retind, string, send, sindex);
-	  break;
-
-	case '\'':
-	case '"':
-	  if (c == '\'')
-	    news = skip_single_quoted (string, slen, ++sindex, SX_COMPLETE);
-	  else
-	    news = skip_double_quoted (string, slen, ++sindex, SX_COMPLETE);
-	  translen = news - sindex - 1;
-	  RESIZE_MALLOCED_BUFFER (ret, retind, translen + 3, retsize, 64);
-	  ret[retind++] = c;
-	  if (translen > 0)
-	    {
-	      strncpy (ret + retind, string + sindex, translen);
-	      retind += translen;
-	    }
-	  if (news > sindex && string[news - 1] == c)
-	    ret[retind++] = c;
-	  sindex = news;
-	  break;
-
-	case CTLESC:
-	  RESIZE_MALLOCED_BUFFER (ret, retind, locale_mb_cur_max + 2, retsize, 64);
-	  if (flags)
-	    ret[retind++] = string[sindex++];
-	  if (string[sindex])
-	    COPY_CHAR_I (ret, retind, string, send, sindex);
-	  break;
-
-	case '$':
-	  peekc = string[++sindex];
-#if defined (TRANSLATABLE_STRINGS)
-	  if (peekc != '\'' && peekc != '"')
-#else
-	  if (peekc != '\'')
-#endif
-	    {
-	      RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 16);
-	      ret[retind++] = c;
-	      break;
-	    }
-	  if (string[sindex + 1] == '\0')	/* don't bother */	
-	    {
-	      RESIZE_MALLOCED_BUFFER (ret, retind, 3, retsize, 16);
-	      ret[retind++] = c;
-	      ret[retind++] = peekc;
-	      sindex++;
-	      break;
-	    }
-	  if (peekc == '\'')
-	    {
-	      /* SX_COMPLETE is the  equivalent of ALLOWESC here */
-	      /* We overload SX_COMPLETE below */
-	      news = skip_single_quoted (string, slen, ++sindex, SX_COMPLETE);
-	      /* Check for unclosed string and don't bother if so */
-	      if (news > sindex && string[news] == '\0' && string[news-1] != peekc)
-		{
-		  RESIZE_MALLOCED_BUFFER (ret, retind, 3, retsize, 16);
-		  ret[retind++] = c;
-		  ret[retind++] = peekc;
-		  continue;
-		}
-	      t = substring (string, sindex, news - 1);
-	      trans = ansiexpand (t, 0, news-sindex-1, &translen);
-	      free (t);
-	      t = sh_single_quote (trans);
-	      sindex = news;
-	    }
-#if defined (TRANSLATABLE_STRINGS)
-	  else
-	    {
-	      news = ++sindex;
-	      t = string_extract_double_quoted (string, &news, SX_COMPLETE);
-	      /* Check for unclosed string and don't bother if so */
-	      if (news > sindex && string[news] == '\0' && string[news-1] != peekc)
-		{
-		  RESIZE_MALLOCED_BUFFER (ret, retind, 3, retsize, 16);
-		  ret[retind++] = c;
-		  ret[retind++] = peekc;
-		  free (t);
-		  continue;
-		}
-	      trans = locale_expand (t, 0, news-sindex, 0, &translen);
-	      free (t);
-	      if (singlequote_translations &&
-		    ((news-sindex-1) != translen || STREQN (t, trans, translen) == 0))
-		t = sh_single_quote (trans);
-	      else
-		t = sh_mkdoublequoted (trans, translen, 0);
-	      sindex = news;
-	    }
-#endif /* TRANSLATABLE_STRINGS */
-	  free (trans);
-	  trans = t;
-	  translen = strlen (trans);
-
-	  RESIZE_MALLOCED_BUFFER (ret, retind, translen + 1, retsize, 128);
-	  strcpy (ret + retind, trans);
-	  retind += translen;
-	  FREE (trans);
-	  break;
-	}
-    }
-
-  ret[retind] = 0;
-  return ret;
-}
-
-/* Call expand_word_internal to expand W and handle error returns.
-   A convenience function for functions that don't want to handle
-   any errors or free any memory before aborting. */
-static WORD_LIST *
-call_expand_word_internal (w, q, i, c, e)
-     WORD_DESC *w;
-     int q, i, *c, *e;
-{
-  WORD_LIST *result;
-
-  result = expand_word_internal (w, q, i, c, e);
-  if (result == &expand_word_error || result == &expand_word_fatal)
-    {
-      /* By convention, each time this error is returned, w->word has
-	 already been freed (it sometimes may not be in the fatal case,
-	 but that doesn't result in a memory leak because we're going
-	 to exit in most cases). */
-      w->word = (char *)NULL;
-      last_command_exit_value = EXECUTION_FAILURE;
-      exp_jump_to_top_level ((result == &expand_word_error) ? DISCARD : FORCE_EOF);
-      /* NOTREACHED */
-      return (NULL);
-    }
-  else
-    return (result);
-}
-
-/* Perform parameter expansion, command substitution, and arithmetic
-   expansion on STRING, as if it were a word.  Leave the result quoted.
-   Since this does not perform word splitting, it leaves quoted nulls
-   in the result.  */
-static WORD_LIST *
-expand_string_internal (string, quoted)
-     char *string;
-     int quoted;
-{
-  WORD_DESC td;
-  WORD_LIST *tresult;
-
-  if (string == 0 || *string == 0)
-    return ((WORD_LIST *)NULL);
-
-  td.flags = 0;
-  td.word = savestring (string);
-
-  tresult = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
-
-  FREE (td.word);
-  return (tresult);
-}
-
-/* Expand STRING by performing parameter expansion, command substitution,
-   and arithmetic expansion.  Dequote the resulting WORD_LIST before
-   returning it, but do not perform word splitting.  The call to
-   remove_quoted_nulls () is in here because word splitting normally
-   takes care of quote removal. */
-WORD_LIST *
-expand_string_unsplit (string, quoted)
-     char *string;
-     int quoted;
-{
-  WORD_LIST *value;
-
-  if (string == 0 || *string == '\0')
-    return ((WORD_LIST *)NULL);
-
-  expand_no_split_dollar_star = 1;
-  value = expand_string_internal (string, quoted);
-  expand_no_split_dollar_star = 0;
-
-  if (value)
-    {
-      if (value->word)
-	{
-	  remove_quoted_nulls (value->word->word);	/* XXX */
-	  value->word->flags &= ~W_HASQUOTEDNULL;
-	}
-      dequote_list (value);
-    }
-  return (value);
-}
-
-/* Expand the rhs of an assignment statement */
-WORD_LIST *
-expand_string_assignment (string, quoted)
-     char *string;
-     int quoted;
-{
-  WORD_DESC td;
-  WORD_LIST *value;
-
-  if (string == 0 || *string == '\0')
-    return ((WORD_LIST *)NULL);
-
-  expand_no_split_dollar_star = 1;
-
-#if 0
-  /* Other shells (ksh93) do it this way, which affects how $@ is expanded
-     in constructs like bar=${@#0} (preserves the spaces resulting from the
-     expansion of $@ in a context where you don't do word splitting); Posix
-     interp 888 makes the expansion of $@ in contexts where word splitting
-     is not performed unspecified. */
-  td.flags = W_ASSIGNRHS|W_NOSPLIT2;		/* Posix interp 888 */
-#else
-  td.flags = W_ASSIGNRHS;
-#endif
-  td.flags |= (W_NOGLOB|W_TILDEEXP);
-  td.word = savestring (string);
-  value = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
-  FREE (td.word);
-
-  expand_no_split_dollar_star = 0;
-
-  if (value)
-    {
-      if (value->word)
-	{
-	  remove_quoted_nulls (value->word->word);	/* XXX */
-	  value->word->flags &= ~W_HASQUOTEDNULL;
-	}
-      dequote_list (value);
-    }
-  return (value);
-}
-
-/* Expand one of the PS? prompt strings. This is a sort of combination of
-   expand_string_unsplit and expand_string_internal, but returns the
-   passed string when an error occurs.  Might want to trap other calls
-   to jump_to_top_level here so we don't endlessly loop. */
-WORD_LIST *
-expand_prompt_string (string, quoted, wflags)
-     char *string;
-     int quoted;
-     int wflags;
-{
-  WORD_LIST *value;
-  WORD_DESC td;
-
-  if (string == 0 || *string == 0)
-    return ((WORD_LIST *)NULL);
-
-  td.flags = wflags;
-  td.word = savestring (string);
-
-  no_longjmp_on_fatal_error = 1;
-  value = expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
-  no_longjmp_on_fatal_error = 0;
-
-  if (value == &expand_word_error || value == &expand_word_fatal)
-    {
-      value = make_word_list (make_bare_word (string), (WORD_LIST *)NULL);
-      return value;
-    }
-  FREE (td.word);
-  if (value)
-    {
-      if (value->word)
-	{
-	  remove_quoted_nulls (value->word->word);	/* XXX */
-	  value->word->flags &= ~W_HASQUOTEDNULL;
-	}
-      dequote_list (value);
-    }
-  return (value);
-}
-
-/* Expand STRING just as if you were expanding a word, but do not dequote
-   the resultant WORD_LIST.  This is called only from within this file,
-   and is used to correctly preserve quoted characters when expanding
-   things like ${1+"$@"}.  This does parameter expansion, command
-   substitution, arithmetic expansion, and word splitting. */
-static WORD_LIST *
-expand_string_leave_quoted (string, quoted)
-     char *string;
-     int quoted;
-{
-  WORD_LIST *tlist;
-  WORD_LIST *tresult;
-
-  if (string == 0 || *string == '\0')
-    return ((WORD_LIST *)NULL);
-
-  tlist = expand_string_internal (string, quoted);
-
-  if (tlist)
-    {
-      tresult = word_list_split (tlist);
-      dispose_words (tlist);
-      return (tresult);
-    }
-  return ((WORD_LIST *)NULL);
-}
-
-/* This does not perform word splitting or dequote the WORD_LIST
-   it returns. */
-static WORD_LIST *
-expand_string_for_rhs (string, quoted, op, pflags, dollar_at_p, expanded_p)
-     char *string;
-     int quoted, op, pflags;
-     int *dollar_at_p, *expanded_p;
-{
-  WORD_DESC td;
-  WORD_LIST *tresult;
-  int old_nosplit;
-
-  if (string == 0 || *string == '\0')
-    return (WORD_LIST *)NULL;
-
-  /* We want field splitting to be determined by what is going to be done with
-     the entire ${parameterOPword} expansion, so we don't want to split the RHS
-     we expand here.  However, the expansion of $* is determined by whether we
-     are going to eventually perform word splitting, so we want to set this
-     depending on whether or not are are going to be splitting: if the expansion
-     is quoted, if the OP is `=', or if IFS is set to the empty string, we
-     are not going to be splitting, so we set expand_no_split_dollar_star to
-     note this to callees.
-     We pass through PF_ASSIGNRHS as W_ASSIGNRHS if this is on the RHS of an
-     assignment statement. */
-  /* The updated treatment of $* is the result of Posix interp 888 */
-  /* This was further clarified on the austin-group list in March, 2017 and
-     in Posix bug 1129 */
-  old_nosplit = expand_no_split_dollar_star;
-  expand_no_split_dollar_star = (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) || op == '=' || ifs_is_null == 0;	/* XXX - was 1 */
-  td.flags = W_EXPANDRHS;		/* expanding RHS of ${paramOPword} */
-  td.flags |= W_NOSPLIT2;		/* no splitting, remove "" and '' */
-  if (pflags & PF_ASSIGNRHS)		/* pass through */
-    td.flags |= W_ASSIGNRHS;
-  if (op == '=')
-#if 0
-    td.flags |= W_ASSIGNRHS;		/* expand b in ${a=b} like assignment */
-#else
-    td.flags |= W_ASSIGNRHS|W_NOASSNTILDE;		/* expand b in ${a=b} like assignment */
-#endif
-  td.word = savestring (string);
-  tresult = call_expand_word_internal (&td, quoted, 1, dollar_at_p, expanded_p);
-  expand_no_split_dollar_star = old_nosplit;
-  free (td.word);
-
-  return (tresult);
-}
-
-/* This does not perform word splitting or dequote the WORD_LIST
-   it returns and it treats $* as if it were quoted. */
-static WORD_LIST *
-expand_string_for_pat (string, quoted, dollar_at_p, expanded_p)
-     char *string;
-     int quoted, *dollar_at_p, *expanded_p;
-{
-  WORD_DESC td;
-  WORD_LIST *tresult;
-  int oexp;
-
-  if (string == 0 || *string == '\0')
-    return (WORD_LIST *)NULL;
-
-  oexp = expand_no_split_dollar_star;
-  expand_no_split_dollar_star = 1;
-  td.flags = W_NOSPLIT2;		/* no splitting, remove "" and '' */
-  td.word = savestring (string);
-  tresult = call_expand_word_internal (&td, quoted, 1, dollar_at_p, expanded_p);
-  expand_no_split_dollar_star = oexp;
-  free (td.word);
-
-  return (tresult);
-}
-
-/* Expand STRING just as if you were expanding a word.  This also returns
-   a list of words.  Note that filename globbing is *NOT* done for word
-   or string expansion, just when the shell is expanding a command.  This
-   does parameter expansion, command substitution, arithmetic expansion,
-   and word splitting.  Dequote the resultant WORD_LIST before returning. */
-WORD_LIST *
-expand_string (string, quoted)
-     char *string;
-     int quoted;
-{
-  WORD_LIST *result;
-
-  if (string == 0 || *string == '\0')
-    return ((WORD_LIST *)NULL);
-
-  result = expand_string_leave_quoted (string, quoted);
-  return (result ? dequote_list (result) : result);
-}
-
-/*******************************************
- *					   *
- *	Functions to expand WORD_DESCs	   *
- *					   *
- *******************************************/
-
-/* Expand WORD, performing word splitting on the result.  This does
-   parameter expansion, command substitution, arithmetic expansion,
-   word splitting, and quote removal. */
-
-WORD_LIST *
-expand_word (word, quoted)
-     WORD_DESC *word;
-     int quoted;
-{
-  WORD_LIST *result, *tresult;
-
-  tresult = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);
-  result = word_list_split (tresult);
-  dispose_words (tresult);
-  return (result ? dequote_list (result) : result);
-}
-
-/* Expand WORD, but do not perform word splitting on the result.  This
-   does parameter expansion, command substitution, arithmetic expansion,
-   and quote removal. */
-WORD_LIST *
-expand_word_unsplit (word, quoted)
-     WORD_DESC *word;
-     int quoted;
-{
-  WORD_LIST *result;
-
-  result = expand_word_leave_quoted (word, quoted);
-  return (result ? dequote_list (result) : result);
-}
-
-/* Perform shell expansions on WORD, but do not perform word splitting or
-   quote removal on the result.  Virtually identical to expand_word_unsplit;
-   could be combined if implementations don't diverge. */
-WORD_LIST *
-expand_word_leave_quoted (word, quoted)
-     WORD_DESC *word;
-     int quoted;
-{
-  WORD_LIST *result;
-
-  expand_no_split_dollar_star = 1;
-  if (ifs_is_null)
-    word->flags |= W_NOSPLIT;
-  word->flags |= W_NOSPLIT2;
-  result = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);
-  expand_no_split_dollar_star = 0;
-
-  return result;
-}
-
-/***************************************************
- *						   *
- *	Functions to handle quoting chars	   *
- *						   *
- ***************************************************/
-
-/* Conventions:
-
-     A string with s[0] == CTLNUL && s[1] == 0 is a quoted null string.
-     The parser passes CTLNUL as CTLESC CTLNUL. */
-
-/* Quote escape characters in string s, but no other characters.  This is
-   used to protect CTLESC and CTLNUL in variable values from the rest of
-   the word expansion process after the variable is expanded (word splitting
-   and filename generation).  If IFS is null, we quote spaces as well, just
-   in case we split on spaces later (in the case of unquoted $@, we will
-   eventually attempt to split the entire word on spaces).  Corresponding
-   code exists in dequote_escapes.  Even if we don't end up splitting on
-   spaces, quoting spaces is not a problem.  This should never be called on
-   a string that is quoted with single or double quotes or part of a here
-   document (effectively double-quoted).
-   FLAGS says whether or not we are going to split the result. If we are not,
-   and there is a CTLESC or CTLNUL in IFS, we need to quote CTLESC and CTLNUL,
-   respectively, to prevent them from being removed as part of dequoting. */
-static char *
-quote_escapes_internal (string, flags)
-     const char *string;
-     int flags;
-{
-  const char *s, *send;
-  char *t, *result;
-  size_t slen;
-  int quote_spaces, skip_ctlesc, skip_ctlnul, nosplit;
-  DECLARE_MBSTATE; 
-
-  slen = strlen (string);
-  send = string + slen;
-
-  quote_spaces = (ifs_value && *ifs_value == 0);
-  nosplit = (flags & PF_NOSPLIT2);
-
-  for (skip_ctlesc = skip_ctlnul = 0, s = ifs_value; s && *s; s++)
-    {
-      skip_ctlesc |= (nosplit == 0 && *s == CTLESC);
-      skip_ctlnul |= (nosplit == 0 && *s == CTLNUL);
-    }
-
-  t = result = (char *)xmalloc ((slen * 2) + 1);
-  s = string;
-
-  while (*s)
-    {
-      if ((skip_ctlesc == 0 && *s == CTLESC) || (skip_ctlnul == 0 && *s == CTLNUL) || (quote_spaces && *s == ' '))
-	*t++ = CTLESC;
-      COPY_CHAR_P (t, s, send);
-    }
-  *t = '\0';
-
-  return (result);
-}
-
-char *
-quote_escapes (string)
-     const char *string;
-{
-  return (quote_escapes_internal (string, 0));
-}
-
-char *
-quote_rhs (string)
-     const char *string;
-{
-  return (quote_escapes_internal (string, PF_NOSPLIT2));
-}
-
-static WORD_LIST *
-list_quote_escapes (list)
-     WORD_LIST *list;
-{
-  register WORD_LIST *w;
-  char *t;
-
-  for (w = list; w; w = w->next)
-    {
-      t = w->word->word;
-      w->word->word = quote_escapes (t);
-      free (t);
-    }
-  return list;
-}
-
-/* Inverse of quote_escapes; remove CTLESC protecting CTLESC or CTLNUL.
-
-   The parser passes us CTLESC as CTLESC CTLESC and CTLNUL as CTLESC CTLNUL.
-   This is necessary to make unquoted CTLESC and CTLNUL characters in the
-   data stream pass through properly.
-
-   We need to remove doubled CTLESC characters inside quoted strings before
-   quoting the entire string, so we do not double the number of CTLESC
-   characters.
-
-   Also used by parts of the pattern substitution code. */
-char *
-dequote_escapes (string)
-     const char *string;
-{
-  const char *s, *send;
-  char *t, *result;
-  size_t slen;
-  int quote_spaces;
-  DECLARE_MBSTATE;
-
-  if (string == 0)
-    return (char *)0;
-
-  slen = strlen (string);
-  send = string + slen;
-
-  t = result = (char *)xmalloc (slen + 1);
-
-  if (strchr (string, CTLESC) == 0)
-    return (strcpy (result, string));
-
-  quote_spaces = (ifs_value && *ifs_value == 0);
-
-  s = string;
-  while (*s)
-    {
-      if (*s == CTLESC && (s[1] == CTLESC || s[1] == CTLNUL || (quote_spaces && s[1] == ' ')))
-	{
-	  s++;
-	  if (*s == '\0')
-	    break;
-	}
-      COPY_CHAR_P (t, s, send);
-    }
-  *t = '\0';
-
-  return result;
-}
-
-#if defined (INCLUDE_UNUSED)
-static WORD_LIST *
-list_dequote_escapes (list)
-     WORD_LIST *list;
-{
-  register WORD_LIST *w;
-  char *t;
-
-  for (w = list; w; w = w->next)
-    {
-      t = w->word->word;
-      w->word->word = dequote_escapes (t);
-      free (t);
-    }
-  return list;
-}
-#endif
-
-/* Return a new string with the quoted representation of character C.
-   This turns "" into QUOTED_NULL, so the W_HASQUOTEDNULL flag needs to be
-   set in any resultant WORD_DESC where this value is the word. */
-static char *
-make_quoted_char (c)
-     int c;
-{
-  char *temp;
-
-  temp = (char *)xmalloc (3);
-  if (c == 0)
-    {
-      temp[0] = CTLNUL;
-      temp[1] = '\0';
-    }
-  else
-    {
-      temp[0] = CTLESC;
-      temp[1] = c;
-      temp[2] = '\0';
-    }
-  return (temp);
-}
-
-/* Quote STRING, returning a new string.  This turns "" into QUOTED_NULL, so
-   the W_HASQUOTEDNULL flag needs to be set in any resultant WORD_DESC where
-   this value is the word. */
-char *
-quote_string (string)
-     char *string;
-{
-  register char *t;
-  size_t slen;
-  char *result, *send;
-
-  if (*string == 0)
-    {
-      result = (char *)xmalloc (2);
-      result[0] = CTLNUL;
-      result[1] = '\0';
-    }
-  else
-    {
-      DECLARE_MBSTATE;
-
-      slen = strlen (string);
-      send = string + slen;
-
-      result = (char *)xmalloc ((slen * 2) + 1);
-
-      for (t = result; string < send; )
-	{
-	  *t++ = CTLESC;
-	  COPY_CHAR_P (t, string, send);
-	}
-      *t = '\0';
-    }
-  return (result);
-}
-
-/* De-quote quoted characters in STRING. */
-char *
-dequote_string (string)
-     char *string;
-{
-  register char *s, *t;
-  size_t slen;
-  char *result, *send;
-  DECLARE_MBSTATE;
-
-  if (string[0] == CTLESC && string[1] == 0)
-    internal_debug ("dequote_string: string with bare CTLESC");
-
-  slen = STRLEN (string);
-
-  t = result = (char *)xmalloc (slen + 1);
-
-  if (QUOTED_NULL (string))
-    {
-      result[0] = '\0';
-      return (result);
-    }
-
-  /* A string consisting of only a single CTLESC should pass through unchanged */
-  if (string[0] == CTLESC && string[1] == 0)
-    {
-      result[0] = CTLESC;
-      result[1] = '\0';
-      return (result);
-    }
-
-  /* If no character in the string can be quoted, don't bother examining
-     each character.  Just return a copy of the string passed to us. */
-  if (strchr (string, CTLESC) == NULL)
-    return (strcpy (result, string));
-
-  send = string + slen;
-  s = string;
-  while (*s)
-    {
-      if (*s == CTLESC)
-	{
-	  s++;
-	  if (*s == '\0')
-	    break;
-	}
-      COPY_CHAR_P (t, s, send);
-    }
-
-  *t = '\0';
-  return (result);
-}
-
-/* Quote the entire WORD_LIST list. */
-static WORD_LIST *
-quote_list (list)
-     WORD_LIST *list;
-{
-  register WORD_LIST *w;
-  char *t;
-
-  for (w = list; w; w = w->next)
-    {
-      t = w->word->word;
-      w->word->word = quote_string (t);
-      if (*t == 0)
-	w->word->flags |= W_HASQUOTEDNULL;	/* XXX - turn on W_HASQUOTEDNULL here? */
-      w->word->flags |= W_QUOTED;
-      free (t);
-    }
-  return list;
-}
-
-WORD_DESC *
-dequote_word (word)
-     WORD_DESC *word;
-{
-  register char *s;
-
-  s = dequote_string (word->word);
-  if (QUOTED_NULL (word->word))
-    word->flags &= ~W_HASQUOTEDNULL;
-  free (word->word);
-  word->word = s;
-
-  return word;
-}
-
-/* De-quote quoted characters in each word in LIST. */
-WORD_LIST *
-dequote_list (list)
-     WORD_LIST *list;
-{
-  register char *s;
-  register WORD_LIST *tlist;
-
-  for (tlist = list; tlist; tlist = tlist->next)
-    {
-      s = dequote_string (tlist->word->word);
-      if (QUOTED_NULL (tlist->word->word))
-	tlist->word->flags &= ~W_HASQUOTEDNULL;
-      free (tlist->word->word);
-      tlist->word->word = s;
-    }
-  return list;
-}
-
-/* Remove CTLESC protecting a CTLESC or CTLNUL in place.  Return the passed
-   string. */
-char *
-remove_quoted_escapes (string)
-     char *string;
-{
-  char *t;
-
-  if (string)
-    {
-      t = dequote_escapes (string);
-      strcpy (string, t);
-      free (t);
-    }
-
-  return (string);
-}
-
-/* Remove quoted $IFS characters from STRING.  Quoted IFS characters are
-   added to protect them from word splitting, but we need to remove them
-   if no word splitting takes place.  This returns newly-allocated memory,
-   so callers can use it to replace savestring(). */
-char *
-remove_quoted_ifs (string)
-     char *string;
-{
-  register size_t slen;
-  register int i, j;
-  char *ret, *send;
-  DECLARE_MBSTATE;
-
-  slen = strlen (string);
-  send = string + slen;
-
-  i = j = 0;
-  ret = (char *)xmalloc (slen + 1);
-
-  while (i < slen)
-    {
-      if (string[i] == CTLESC)
-	{
-	  i++;
-	  if (string[i] == 0 || isifs (string[i]) == 0)
-	    ret[j++] = CTLESC;
-	  if (i == slen)
-	    break;
-	}
-
-      COPY_CHAR_I (ret, j, string, send, i);
-    }
-  ret[j] = '\0';
-
-  return (ret);
-}
-
-char *
-remove_quoted_nulls (string)
-     char *string;
-{
-  register size_t slen;
-  register int i, j, prev_i;
-  DECLARE_MBSTATE;
-
-  if (strchr (string, CTLNUL) == 0)		/* XXX */
-    return string;				/* XXX */
-
-  slen = strlen (string);
-  i = j = 0;
-
-  while (i < slen)
-    {
-      if (string[i] == CTLESC)
-	{
-	  /* Old code had j++, but we cannot assume that i == j at this
-	     point -- what if a CTLNUL has already been removed from the
-	     string?  We don't want to drop the CTLESC or recopy characters
-	     that we've already copied down. */
-	  i++;
-	  string[j++] = CTLESC;
-	  if (i == slen)
-	    break;
-	}
-      else if (string[i] == CTLNUL)
-	{
-	  i++;
-	  continue;
-	}
-
-      prev_i = i;
-      ADVANCE_CHAR (string, slen, i);		/* COPY_CHAR_I? */
-      if (j < prev_i)
-	{
-	  do string[j++] = string[prev_i++]; while (prev_i < i);
-	}
-      else
-	j = i;
-    }
-  string[j] = '\0';
-
-  return (string);
-}
-
-/* Perform quoted null character removal on each element of LIST.
-   This modifies LIST. */
-void
-word_list_remove_quoted_nulls (list)
-     WORD_LIST *list;
-{
-  register WORD_LIST *t;
-
-  for (t = list; t; t = t->next)
-    {
-      remove_quoted_nulls (t->word->word);
-      t->word->flags &= ~W_HASQUOTEDNULL;
-    }
-}
-
-/* **************************************************************** */
-/*								    */
-/*	   Functions for Matching and Removing Patterns		    */
-/*								    */
-/* **************************************************************** */
-
-#if defined (HANDLE_MULTIBYTE)
-# ifdef INCLUDE_UNUSED
-static unsigned char *
-mb_getcharlens (string, len)
-     char *string;
-     int len;
-{
-  int i, offset, last;
-  unsigned char *ret;
-  char *p;
-  DECLARE_MBSTATE;
-
-  i = offset = 0;
-  last = 0;
-  ret = (unsigned char *)xmalloc (len);
-  memset (ret, 0, len);
-  while (string[last])
-    {
-      ADVANCE_CHAR (string, len, offset);
-      ret[last] = offset - last;
-      last = offset;
-    }
-  return ret;
-}
-#  endif
-#endif
-
-/* Remove the portion of PARAM matched by PATTERN according to OP, where OP
-   can have one of 4 values:
-	RP_LONG_LEFT	remove longest matching portion at start of PARAM
-	RP_SHORT_LEFT	remove shortest matching portion at start of PARAM
-	RP_LONG_RIGHT	remove longest matching portion at end of PARAM
-	RP_SHORT_RIGHT	remove shortest matching portion at end of PARAM
-*/
-
-#define RP_LONG_LEFT	1
-#define RP_SHORT_LEFT	2
-#define RP_LONG_RIGHT	3
-#define RP_SHORT_RIGHT	4
-
-/* Returns its first argument if nothing matched; new memory otherwise */
-static char *
-remove_upattern (param, pattern, op)
-     char *param, *pattern;
-     int op;
-{
-  register size_t len;
-  register char *end;
-  register char *p, *ret, c;
-
-  len = STRLEN (param);
-  end = param + len;
-
-  switch (op)
-    {
-      case RP_LONG_LEFT:	/* remove longest match at start */
-	for (p = end; p >= param; p--)
-	  {
-	    c = *p; *p = '\0';
-	    if (strmatch (pattern, param, FNMATCH_EXTFLAG) != FNM_NOMATCH)
-	      {
-		*p = c;
-		return (savestring (p));
-	      }
-	    *p = c;
-
-	  }
-	break;
-
-      case RP_SHORT_LEFT:	/* remove shortest match at start */
-	for (p = param; p <= end; p++)
-	  {
-	    c = *p; *p = '\0';
-	    if (strmatch (pattern, param, FNMATCH_EXTFLAG) != FNM_NOMATCH)
-	      {
-		*p = c;
-		return (savestring (p));
-	      }
-	    *p = c;
-	  }
-	break;
-
-      case RP_LONG_RIGHT:	/* remove longest match at end */
-	for (p = param; p <= end; p++)
-	  {
-	    if (strmatch (pattern, p, FNMATCH_EXTFLAG) != FNM_NOMATCH)
-	      {
-		c = *p; *p = '\0';
-		ret = savestring (param);
-		*p = c;
-		return (ret);
-	      }
-	  }
-	break;
-
-      case RP_SHORT_RIGHT:	/* remove shortest match at end */
-	for (p = end; p >= param; p--)
-	  {
-	    if (strmatch (pattern, p, FNMATCH_EXTFLAG) != FNM_NOMATCH)
-	      {
-		c = *p; *p = '\0';
-		ret = savestring (param);
-		*p = c;
-		return (ret);
-	      }
-	  }
-	break;
-    }
-
-  return (param);	/* no match, return original string */
-}
-
-#if defined (HANDLE_MULTIBYTE)
-/* Returns its first argument if nothing matched; new memory otherwise */
-static wchar_t *
-remove_wpattern (wparam, wstrlen, wpattern, op)
-     wchar_t *wparam;
-     size_t wstrlen;
-     wchar_t *wpattern;
-     int op;
-{
-  wchar_t wc, *ret;
-  int n;
-
-  switch (op)
-    {
-      case RP_LONG_LEFT:	/* remove longest match at start */
-        for (n = wstrlen; n >= 0; n--)
-	  {
-	    wc = wparam[n]; wparam[n] = L'\0';
-	    if (wcsmatch (wpattern, wparam, FNMATCH_EXTFLAG) != FNM_NOMATCH)
-	      {
-		wparam[n] = wc;
-		return (wcsdup (wparam + n));
-	      }
-	    wparam[n] = wc;
-	  }
-	break;
-
-      case RP_SHORT_LEFT:	/* remove shortest match at start */
-	for (n = 0; n <= wstrlen; n++)
-	  {
-	    wc = wparam[n]; wparam[n] = L'\0';
-	    if (wcsmatch (wpattern, wparam, FNMATCH_EXTFLAG) != FNM_NOMATCH)
-	      {
-		wparam[n] = wc;
-		return (wcsdup (wparam + n));
-	      }
-	    wparam[n] = wc;
-	  }
-	break;
-
-      case RP_LONG_RIGHT:	/* remove longest match at end */
-        for (n = 0; n <= wstrlen; n++)
-	  {
-	    if (wcsmatch (wpattern, wparam + n, FNMATCH_EXTFLAG) != FNM_NOMATCH)
-	      {
-		wc = wparam[n]; wparam[n] = L'\0';
-		ret = wcsdup (wparam);
-		wparam[n] = wc;
-		return (ret);
-	      }
-	  }
-	break;
-
-      case RP_SHORT_RIGHT:	/* remove shortest match at end */
-	for (n = wstrlen; n >= 0; n--)
-	  {
-	    if (wcsmatch (wpattern, wparam + n, FNMATCH_EXTFLAG) != FNM_NOMATCH)
-	      {
-		wc = wparam[n]; wparam[n] = L'\0';
-		ret = wcsdup (wparam);
-		wparam[n] = wc;
-		return (ret);
-	      }
-	  }
-	break;
-    }
-
-  return (wparam);	/* no match, return original string */
-}
-#endif /* HANDLE_MULTIBYTE */
-
-static char *
-remove_pattern (param, pattern, op)
-     char *param, *pattern;
-     int op;
-{
-  char *xret;
-
-  if (param == NULL)
-    return (param);
-  if (*param == '\0' || pattern == NULL || *pattern == '\0')	/* minor optimization */
-    return (savestring (param));
-
-#if defined (HANDLE_MULTIBYTE)
-  if (MB_CUR_MAX > 1)
-    {
-      wchar_t *ret, *oret;
-      size_t n;
-      wchar_t *wparam, *wpattern;
-      mbstate_t ps;
-
-      /* XXX - could optimize here by checking param and pattern for multibyte
-	 chars with mbsmbchar and calling remove_upattern. */
-
-      n = xdupmbstowcs (&wpattern, NULL, pattern);
-      if (n == (size_t)-1)
-	{
-	  xret = remove_upattern (param, pattern, op);
-	  return ((xret == param) ? savestring (param) : xret);
-	}
-      n = xdupmbstowcs (&wparam, NULL, param);
-
-      if (n == (size_t)-1)
-	{
-	  free (wpattern);
-	  xret = remove_upattern (param, pattern, op);
-	  return ((xret == param) ? savestring (param) : xret);
-	}
-      oret = ret = remove_wpattern (wparam, n, wpattern, op);
-      /* Don't bother to convert wparam back to multibyte string if nothing
-	 matched; just return copy of original string */
-      if (ret == wparam)
-        {
-          free (wparam);
-          free (wpattern);
-          return (savestring (param));
-        }
-
-      free (wparam);
-      free (wpattern);
-
-      n = strlen (param);
-      xret = (char *)xmalloc (n + 1);
-      memset (&ps, '\0', sizeof (mbstate_t));
-      n = wcsrtombs (xret, (const wchar_t **)&ret, n, &ps);
-      xret[n] = '\0';		/* just to make sure */
-      free (oret);
-      return xret;      
-    }
-  else
-#endif
-    {
-      xret = remove_upattern (param, pattern, op);
-      return ((xret == param) ? savestring (param) : xret);
-    }
-}
-
-/* Match PAT anywhere in STRING and return the match boundaries.
-   This returns 1 in case of a successful match, 0 otherwise.  SP
-   and EP are pointers into the string where the match begins and
-   ends, respectively.  MTYPE controls what kind of match is attempted.
-   MATCH_BEG and MATCH_END anchor the match at the beginning and end
-   of the string, respectively.  The longest match is returned. */
-static int
-match_upattern (string, pat, mtype, sp, ep)
-     char *string, *pat;
-     int mtype;
-     char **sp, **ep;
-{
-  int c, mlen;
-  size_t len;
-  register char *p, *p1, *npat;
-  char *end;
-
-  /* If the pattern doesn't match anywhere in the string, go ahead and
-     short-circuit right away.  A minor optimization, saves a bunch of
-     unnecessary calls to strmatch (up to N calls for a string of N
-     characters) if the match is unsuccessful.  To preserve the semantics
-     of the substring matches below, we make sure that the pattern has
-     `*' as first and last character, making a new pattern if necessary. */
-  /* XXX - check this later if I ever implement `**' with special meaning,
-     since this will potentially result in `**' at the beginning or end */
-  len = STRLEN (pat);
-  if (pat[0] != '*' || (pat[0] == '*' && pat[1] == LPAREN && extended_glob) || pat[len - 1] != '*')
-    {
-      int unescaped_backslash;
-      char *pp;
-
-      p = npat = (char *)xmalloc (len + 3);
-      p1 = pat;
-      if ((mtype != MATCH_BEG) && (*p1 != '*' || (*p1 == '*' && p1[1] == LPAREN && extended_glob)))
-	*p++ = '*';
-      while (*p1)
-	*p++ = *p1++;
-#if 1
-      /* Need to also handle a pattern that ends with an unescaped backslash.
-	 For right now, we ignore it because the pattern matching code will
-	 fail the match anyway */
-      /* If the pattern ends with a `*' we leave it alone if it's preceded by
-	 an even number of backslashes, but if it's escaped by a backslash
-	 we need to add another `*'. */
-      if ((mtype != MATCH_END) && (p1[-1] == '*' && (unescaped_backslash = p1[-2] == '\\')))
-	{
-	  pp = p1 - 3;
-	  while (pp >= pat && *pp-- == '\\')
-	    unescaped_backslash = 1 - unescaped_backslash;
-	  if (unescaped_backslash)
-	    *p++ = '*';
-	}
-      else if (mtype != MATCH_END && p1[-1] != '*')
-	*p++ = '*';
-#else 
-      if (p1[-1] != '*' || p1[-2] == '\\')
-	*p++ = '*';
-#endif
-      *p = '\0';
-    }
-  else
-    npat = pat;
-  c = strmatch (npat, string, FNMATCH_EXTFLAG | FNMATCH_IGNCASE);
-  if (npat != pat)
-    free (npat);
-  if (c == FNM_NOMATCH)
-    return (0);
-
-  len = STRLEN (string);
-  end = string + len;
-
-  mlen = umatchlen (pat, len);
-  if (mlen > (int)len)
-    return (0);
-
-  switch (mtype)
-    {
-    case MATCH_ANY:
-      for (p = string; p <= end; p++)
-	{
-	  if (match_pattern_char (pat, p, FNMATCH_IGNCASE))
-	    {
-	      p1 = (mlen == -1) ? end : p + mlen;
-	      /* p1 - p = length of portion of string to be considered
-	         p = current position in string
-	         mlen = number of characters consumed by match (-1 for entire string)
-	         end = end of string
-	         we want to break immediately if the potential match len
-	         is greater than the number of characters remaining in the
-	         string
-	      */
-	      if (p1 > end)
-		break;
-	      for ( ; p1 >= p; p1--)
-		{
-		  c = *p1; *p1 = '\0';
-		  if (strmatch (pat, p, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)
-		    {
-		      *p1 = c;
-		      *sp = p;
-		      *ep = p1;
-		      return 1;
-		    }
-		  *p1 = c;
-#if 1
-		  /* If MLEN != -1, we have a fixed length pattern. */
-		  if (mlen != -1)
-		    break;
-#endif
-		}
-	    }
-	}
-
-      return (0);
-
-    case MATCH_BEG:
-      if (match_pattern_char (pat, string, FNMATCH_IGNCASE) == 0)
-	return (0);
-
-      for (p = (mlen == -1) ? end : string + mlen; p >= string; p--)
-	{
-	  c = *p; *p = '\0';
-	  if (strmatch (pat, string, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)
-	    {
-	      *p = c;
-	      *sp = string;
-	      *ep = p;
-	      return 1;
-	    }
-	  *p = c;
-	  /* If MLEN != -1, we have a fixed length pattern. */
-	  if (mlen != -1)
-	    break;
-	}
-
-      return (0);
-
-    case MATCH_END:
-      for (p = end - ((mlen == -1) ? len : mlen); p <= end; p++)
-	{
-	  if (strmatch (pat, p, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)
-	    {
-	      *sp = p;
-	      *ep = end;
-	      return 1;
-	    }
-	  /* If MLEN != -1, we have a fixed length pattern. */
-	  if (mlen != -1)
-	    break;
-	}
-
-      return (0);
-    }
-
-  return (0);
-}
-
-#if defined (HANDLE_MULTIBYTE)
-
-#define WFOLD(c) (match_ignore_case && iswupper (c) ? towlower (c) : (c))
-
-/* Match WPAT anywhere in WSTRING and return the match boundaries.
-   This returns 1 in case of a successful match, 0 otherwise.  Wide
-   character version. */
-static int
-match_wpattern (wstring, indices, wstrlen, wpat, mtype, sp, ep)
-     wchar_t *wstring;
-     char **indices;
-     size_t wstrlen;
-     wchar_t *wpat;
-     int mtype;
-     char **sp, **ep;
-{
-  wchar_t wc, *wp, *nwpat, *wp1;
-  size_t len;
-  int mlen;
-  int n, n1, n2, simple;
-
-  simple = (wpat[0] != L'\\' && wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'[');
-#if defined (EXTENDED_GLOB)
-  if (extended_glob)
-    simple &= (wpat[1] != L'(' || (wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'+' && wpat[0] != L'!' && wpat[0] != L'@')); /*)*/
-#endif
-
-  /* If the pattern doesn't match anywhere in the string, go ahead and
-     short-circuit right away.  A minor optimization, saves a bunch of
-     unnecessary calls to strmatch (up to N calls for a string of N
-     characters) if the match is unsuccessful.  To preserve the semantics
-     of the substring matches below, we make sure that the pattern has
-     `*' as first and last character, making a new pattern if necessary. */
-  len = wcslen (wpat);
-  if (wpat[0] != L'*' || (wpat[0] == L'*' && wpat[1] == WLPAREN && extended_glob) || wpat[len - 1] != L'*')
-    {
-      int unescaped_backslash;
-      wchar_t *wpp;
-
-      wp = nwpat = (wchar_t *)xmalloc ((len + 3) * sizeof (wchar_t));
-      wp1 = wpat;
-      if (*wp1 != L'*' || (*wp1 == '*' && wp1[1] == WLPAREN && extended_glob))
-	*wp++ = L'*';
-      while (*wp1 != L'\0')
-	*wp++ = *wp1++;
-#if 1
-      /* See comments above in match_upattern. */
-      if (wp1[-1] == L'*' && (unescaped_backslash = wp1[-2] == L'\\'))
-        {
-          wpp = wp1 - 3;
-          while (wpp >= wpat && *wpp-- == L'\\')
-            unescaped_backslash = 1 - unescaped_backslash;
-          if (unescaped_backslash)
-            *wp++ = L'*';
-        }
-      else if (wp1[-1] != L'*')
-        *wp++ = L'*';
-#else      
-      if (wp1[-1] != L'*' || wp1[-2] == L'\\')
-        *wp++ = L'*';
-#endif
-      *wp = '\0';
-    }
-  else
-    nwpat = wpat;
-  len = wcsmatch (nwpat, wstring, FNMATCH_EXTFLAG | FNMATCH_IGNCASE);
-  if (nwpat != wpat)
-    free (nwpat);
-  if (len == FNM_NOMATCH)
-    return (0);
-
-  mlen = wmatchlen (wpat, wstrlen);
-  if (mlen > (int)wstrlen)
-    return (0);
-
-/* itrace("wmatchlen (%ls) -> %d", wpat, mlen); */
-  switch (mtype)
-    {
-    case MATCH_ANY:
-      for (n = 0; n <= wstrlen; n++)
-	{
-	  n2 = simple ? (WFOLD(*wpat) == WFOLD(wstring[n])) : match_pattern_wchar (wpat, wstring + n, FNMATCH_IGNCASE);
-	  if (n2)
-	    {
-	      n1 = (mlen == -1) ? wstrlen : n + mlen;
-	      if (n1 > wstrlen)
-	        break;
-
-	      for ( ; n1 >= n; n1--)
-		{
-		  wc = wstring[n1]; wstring[n1] = L'\0';
-		  if (wcsmatch (wpat, wstring + n, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)
-		    {
-		      wstring[n1] = wc;
-		      *sp = indices[n];
-		      *ep = indices[n1];
-		      return 1;
-		    }
-		  wstring[n1] = wc;
-		  /* If MLEN != -1, we have a fixed length pattern. */
-		  if (mlen != -1)
-		    break;
-		}
-	    }
-	}
-
-      return (0);
-
-    case MATCH_BEG:
-      if (match_pattern_wchar (wpat, wstring, FNMATCH_IGNCASE) == 0)
-	return (0);
-
-      for (n = (mlen == -1) ? wstrlen : mlen; n >= 0; n--)
-	{
-	  wc = wstring[n]; wstring[n] = L'\0';
-	  if (wcsmatch (wpat, wstring, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)
-	    {
-	      wstring[n] = wc;
-	      *sp = indices[0];
-	      *ep = indices[n];
-	      return 1;
-	    }
-	  wstring[n] = wc;
-	  /* If MLEN != -1, we have a fixed length pattern. */
-	  if (mlen != -1)
-	    break;
-	}
-
-      return (0);
-
-    case MATCH_END:
-      for (n = wstrlen - ((mlen == -1) ? wstrlen : mlen); n <= wstrlen; n++)
-	{
-	  if (wcsmatch (wpat, wstring + n, FNMATCH_EXTFLAG | FNMATCH_IGNCASE) == 0)
-	    {
-	      *sp = indices[n];
-	      *ep = indices[wstrlen];
-	      return 1;
-	    }
-	  /* If MLEN != -1, we have a fixed length pattern. */
-	  if (mlen != -1)
-	    break;
-	}
-
-      return (0);
-    }
-
-  return (0);
-}
-#undef WFOLD
-#endif /* HANDLE_MULTIBYTE */
-
-static int
-match_pattern (string, pat, mtype, sp, ep)
-     char *string, *pat;
-     int mtype;
-     char **sp, **ep;
-{
-#if defined (HANDLE_MULTIBYTE)
-  int ret;
-  size_t n;
-  wchar_t *wstring, *wpat;
-  char **indices;
-#endif
-
-  if (string == 0 || pat == 0 || *pat == 0)
-    return (0);
-
-#if defined (HANDLE_MULTIBYTE)
-  if (MB_CUR_MAX > 1)
-    {
-      if (mbsmbchar (string) == 0 && mbsmbchar (pat) == 0)
-        return (match_upattern (string, pat, mtype, sp, ep));
-
-      n = xdupmbstowcs (&wpat, NULL, pat);
-      if (n == (size_t)-1)
-	return (match_upattern (string, pat, mtype, sp, ep));
-      n = xdupmbstowcs (&wstring, &indices, string);
-      if (n == (size_t)-1)
-	{
-	  free (wpat);
-	  return (match_upattern (string, pat, mtype, sp, ep));
-	}
-      ret = match_wpattern (wstring, indices, n, wpat, mtype, sp, ep);
-
-      free (wpat);
-      free (wstring);
-      free (indices);
-
-      return (ret);
-    }
-  else
-#endif
-    return (match_upattern (string, pat, mtype, sp, ep));
-}
-
-static int
-getpatspec (c, value)
-     int c;
-     char *value;
-{
-  if (c == '#')
-    return ((*value == '#') ? RP_LONG_LEFT : RP_SHORT_LEFT);
-  else	/* c == '%' */
-    return ((*value == '%') ? RP_LONG_RIGHT : RP_SHORT_RIGHT);
-}
-
-/* Posix.2 says that the WORD should be run through tilde expansion,
-   parameter expansion, command substitution and arithmetic expansion.
-   This leaves the result quoted, so quote_string_for_globbing () has
-   to be called to fix it up for strmatch ().  If QUOTED is non-zero,
-   it means that the entire expression was enclosed in double quotes.
-   This means that quoting characters in the pattern do not make any
-   special pattern characters quoted.  For example, the `*' in the
-   following retains its special meaning: "${foo#'*'}". */
-static char *
-getpattern (value, quoted, expandpat)
-     char *value;
-     int quoted, expandpat;
-{
-  char *pat, *tword;
-  WORD_LIST *l;
-#if 0
-  int i;
-#endif
-  /* There is a problem here:  how to handle single or double quotes in the
-     pattern string when the whole expression is between double quotes?
-     POSIX.2 says that enclosing double quotes do not cause the pattern to
-     be quoted, but does that leave us a problem with @ and array[@] and their
-     expansions inside a pattern? */
-#if 0
-  if (expandpat && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && *tword)
-    {
-      i = 0;
-      pat = string_extract_double_quoted (tword, &i, SX_STRIPDQ);
-      free (tword);
-      tword = pat;
-    }
-#endif
-
-  /* expand_string_for_pat () leaves WORD quoted and does not perform
-     word splitting. */
-  l = *value ? expand_string_for_pat (value,
-				      (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? Q_PATQUOTE : quoted,
-				      (int *)NULL, (int *)NULL)
-	     : (WORD_LIST *)0;
-  if (l)
-    word_list_remove_quoted_nulls (l);
-  pat = string_list (l);
-  dispose_words (l);
-  if (pat)
-    {
-      tword = quote_string_for_globbing (pat, QGLOB_CVTNULL);
-      free (pat);
-      pat = tword;
-    }
-  return (pat);
-}
-
-#if 0
-/* Handle removing a pattern from a string as a result of ${name%[%]value}
-   or ${name#[#]value}. */
-static char *
-variable_remove_pattern (value, pattern, patspec, quoted)
-     char *value, *pattern;
-     int patspec, quoted;
-{
-  char *tword;
-
-  tword = remove_pattern (value, pattern, patspec);
-
-  return (tword);
-}
-#endif
-
-static char *
-list_remove_pattern (list, pattern, patspec, itype, quoted)
-     WORD_LIST *list;
-     char *pattern;
-     int patspec, itype, quoted;
-{
-  WORD_LIST *new, *l;
-  WORD_DESC *w;
-  char *tword;
-
-  for (new = (WORD_LIST *)NULL, l = list; l; l = l->next)
-    {
-      tword = remove_pattern (l->word->word, pattern, patspec);
-      w = alloc_word_desc ();
-      w->word = tword ? tword : savestring ("");
-      new = make_word_list (w, new);
-    }
-
-  l = REVERSE_LIST (new, WORD_LIST *);
-  tword = string_list_pos_params (itype, l, quoted, 0);
-  dispose_words (l);
-
-  return (tword);
-}
-
-static char *
-parameter_list_remove_pattern (itype, pattern, patspec, quoted)
-     int itype;
-     char *pattern;
-     int patspec, quoted;
-{
-  char *ret;
-  WORD_LIST *list;
-
-  list = list_rest_of_args ();
-  if (list == 0)
-    return ((char *)NULL);
-  ret = list_remove_pattern (list, pattern, patspec, itype, quoted);
-  dispose_words (list);
-  return (ret);
-}
-
-#if defined (ARRAY_VARS)
-static char *
-array_remove_pattern (var, pattern, patspec, starsub, quoted)
-     SHELL_VAR *var;
-     char *pattern;
-     int patspec;
-     int starsub;	/* so we can figure out how it's indexed */
-     int quoted;
-{
-  ARRAY *a;
-  HASH_TABLE *h;
-  int itype;
-  char *ret;
-  WORD_LIST *list;
-  SHELL_VAR *v;
-
-  v = var;		/* XXX - for now */
-
-  itype = starsub ? '*' : '@';
-
-  a = (v && array_p (v)) ? array_cell (v) : 0;
-  h = (v && assoc_p (v)) ? assoc_cell (v) : 0;
-  
-  list = a ? array_to_word_list (a) : (h ? assoc_to_word_list (h) : 0);
-  if (list == 0)
-   return ((char *)NULL);
-  ret = list_remove_pattern (list, pattern, patspec, itype, quoted);
-  dispose_words (list);
-
-  return ret;
-}
-#endif /* ARRAY_VARS */
-
-static char *
-parameter_brace_remove_pattern (varname, value, estatep, patstr, rtype, quoted, flags)
-     char *varname, *value;
-     array_eltstate_t *estatep;
-     char *patstr;
-     int rtype, quoted, flags;
-{
-  int vtype, patspec, starsub;
-  char *temp1, *val, *pattern, *oname;
-  SHELL_VAR *v;
-
-  if (value == 0)
-    return ((char *)NULL);
-
-  oname = this_command_name;
-  this_command_name = varname;
-
-  vtype = get_var_and_type (varname, value, estatep, quoted, flags, &v, &val);
-  if (vtype == -1)
-    {
-      this_command_name = oname;
-      return ((char *)NULL);
-    }
-
-  starsub = vtype & VT_STARSUB;
-  vtype &= ~VT_STARSUB;
-
-  patspec = getpatspec (rtype, patstr);
-  if (patspec == RP_LONG_LEFT || patspec == RP_LONG_RIGHT)
-    patstr++;
-
-  /* Need to pass getpattern newly-allocated memory in case of expansion --
-     the expansion code will free the passed string on an error. */
-  temp1 = savestring (patstr);
-  pattern = getpattern (temp1, quoted, 1);
-  free (temp1);
-
-  temp1 = (char *)NULL;		/* shut up gcc */
-  switch (vtype)
-    {
-    case VT_VARIABLE:
-    case VT_ARRAYMEMBER:
-      temp1 = remove_pattern (val, pattern, patspec);
-      if (vtype == VT_VARIABLE)
-	FREE (val);
-      if (temp1)
-	{
-	  val = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-			? quote_string (temp1)
-			: quote_escapes (temp1);
-	  free (temp1);
-	  temp1 = val;
-	}
-      break;
-#if defined (ARRAY_VARS)
-    case VT_ARRAYVAR:
-      temp1 = array_remove_pattern (v, pattern, patspec, starsub, quoted);
-      if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
-	{
-	  val = quote_escapes (temp1);
-	  free (temp1);
-	  temp1 = val;
-	}
-      break;
-#endif
-    case VT_POSPARMS:
-      temp1 = parameter_list_remove_pattern (varname[0], pattern, patspec, quoted);
-      if (temp1 && quoted == 0 && ifs_is_null)
-	{
-	  /* Posix interp 888 */
-	}
-      else if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
-	{
-	  val = quote_escapes (temp1);
-	  free (temp1);
-	  temp1 = val;
-	}
-      break;
-    }
-
-  this_command_name = oname;
-
-  FREE (pattern);
-  return temp1;
-}    
-
-#if defined (PROCESS_SUBSTITUTION)
-
-static void reap_some_procsubs PARAMS((int));
-
-/*****************************************************************/
-/*								 */
-/*		    Hacking Process Substitution		 */
-/*								 */
-/*****************************************************************/
-
-#if !defined (HAVE_DEV_FD)
-/* Named pipes must be removed explicitly with `unlink'.  This keeps a list
-   of FIFOs the shell has open.  unlink_fifo_list will walk the list and
-   unlink the ones that don't have a living process on the other end.
-   unlink_all_fifos will walk the list and unconditionally unlink them, trying
-   to open and close the FIFO first to release any child processes sleeping on
-   the FIFO. add_fifo_list adds the name of an open FIFO to the list. 
-   NFIFO is a count of the number of FIFOs in the list. */
-#define FIFO_INCR 20
-
-/* PROC value of -1 means the process has been reaped and the FIFO needs to
-   be removed. PROC value of 0 means the slot is unused. */
-struct temp_fifo {
-  char *file;
-  pid_t proc;
-};
-
-static struct temp_fifo *fifo_list = (struct temp_fifo *)NULL;
-static int nfifo;
-static int fifo_list_size;
-
-void
-clear_fifo_list ()
-{
-  int i;
-
-  for (i = 0; i < fifo_list_size; i++)
-    {
-      if (fifo_list[i].file)
-	free (fifo_list[i].file);
-      fifo_list[i].file = NULL;
-      fifo_list[i].proc = 0;
-    }
-  nfifo = 0;
-}
-
-void *
-copy_fifo_list (sizep)
-     int *sizep;
-{
-  if (sizep)
-    *sizep = 0;
-  return (void *)NULL;
-}
-
-static void
-add_fifo_list (pathname)
-     char *pathname;
-{
-  int osize, i;
-
-  if (nfifo >= fifo_list_size - 1)
-    {
-      osize = fifo_list_size;
-      fifo_list_size += FIFO_INCR;
-      fifo_list = (struct temp_fifo *)xrealloc (fifo_list,
-				fifo_list_size * sizeof (struct temp_fifo));
-      for (i = osize; i < fifo_list_size; i++)
-	{
-	  fifo_list[i].file = (char *)NULL;
-	  fifo_list[i].proc = 0;	/* unused */
-	}
-    }
-
-  fifo_list[nfifo].file = savestring (pathname);
-  nfifo++;
-}
-
-void
-unlink_fifo (i)
-     int i;
-{
-  if ((fifo_list[i].proc == (pid_t)-1) || (fifo_list[i].proc > 0 && (kill(fifo_list[i].proc, 0) == -1)))
-    {
-      unlink (fifo_list[i].file);
-      free (fifo_list[i].file);
-      fifo_list[i].file = (char *)NULL;
-      fifo_list[i].proc = 0;
-    }
-}
-
-void
-unlink_fifo_list ()
-{
-  int saved, i, j;
-
-  if (nfifo == 0)
-    return;
-
-  for (i = saved = 0; i < nfifo; i++)
-    {
-      if ((fifo_list[i].proc == (pid_t)-1) || (fifo_list[i].proc > 0 && (kill(fifo_list[i].proc, 0) == -1)))
-	{
-	  unlink (fifo_list[i].file);
-	  free (fifo_list[i].file);
-	  fifo_list[i].file = (char *)NULL;
-	  fifo_list[i].proc = 0;
-	}
-      else
-	saved++;
-    }
-
-  /* If we didn't remove some of the FIFOs, compact the list. */
-  if (saved)
-    {
-      for (i = j = 0; i < nfifo; i++)
-	if (fifo_list[i].file)
-	  {
-	    if (i != j)
-	      {
-		fifo_list[j].file = fifo_list[i].file;
-		fifo_list[j].proc = fifo_list[i].proc;
-		fifo_list[i].file = (char *)NULL;
-		fifo_list[i].proc = 0;
-	      }
-	    j++;
-	  }
-      nfifo = j;
-    }
-  else
-    nfifo = 0;
-}
-
-void
-unlink_all_fifos ()
-{
-  int i, fd;
-
-  if (nfifo == 0)
-    return;
-
-  for (i = 0; i < nfifo; i++)
-    {
-      fifo_list[i].proc = (pid_t)-1;
-#if defined (O_NONBLOCK)
-      fd = open (fifo_list[i].file, O_RDWR|O_NONBLOCK);
-#else
-      fd = -1;
-#endif
-      unlink_fifo (i);
-      if (fd >= 0)
-	close (fd);
-    }
-
-  nfifo = 0;
-}
-
-/* Take LIST, which is a bitmap denoting active FIFOs in fifo_list
-   from some point in the past, and close all open FIFOs in fifo_list
-   that are not marked as active in LIST.  If LIST is NULL, close
-   everything in fifo_list. LSIZE is the number of elements in LIST, in
-   case it's larger than fifo_list_size (size of fifo_list). */
-void
-close_new_fifos (list, lsize)
-     void *list;
-     int lsize;
-{
-  int i;
-  char *plist;
-
-  if (list == 0)
-    {
-      unlink_fifo_list ();
-      return;
-    }
-
-  for (plist = (char *)list, i = 0; i < lsize; i++)
-    if (plist[i] == 0 && i < fifo_list_size && fifo_list[i].proc != -1)
-      unlink_fifo (i);
-
-  for (i = lsize; i < fifo_list_size; i++)
-    unlink_fifo (i);  
-}
-
-int
-find_procsub_child (pid)
-     pid_t pid;
-{
-  int i;
-
-  for (i = 0; i < nfifo; i++)
-    if (fifo_list[i].proc == pid)
-      return i;
-  return -1;
-}
-
-void
-set_procsub_status (ind, pid, status)
-     int ind;
-     pid_t pid;
-     int status;
-{
-  if (ind >= 0 && ind < nfifo)
-    fifo_list[ind].proc = (pid_t)-1;		/* sentinel */
-}
-
-/* If we've marked the process for this procsub as dead, close the
-   associated file descriptor and delete the FIFO. */
-static void
-reap_some_procsubs (max)
-     int max;
-{
-  int i;
-
-  for (i = 0; i < max; i++)
-    if (fifo_list[i].proc == (pid_t)-1)	/* reaped */
-      unlink_fifo (i);
-}
-
-void
-reap_procsubs ()
-{
-  reap_some_procsubs (nfifo);
-}
-
-#if 0
-/* UNUSED */
-void
-wait_procsubs ()
-{
-  int i, r;
-
-  for (i = 0; i < nfifo; i++)
-    {
-      if (fifo_list[i].proc != (pid_t)-1 && fifo_list[i].proc > 0)
-	{
-	  r = wait_for (fifo_list[i].proc, 0);
-	  save_proc_status (fifo_list[i].proc, r);
-	  fifo_list[i].proc = (pid_t)-1;
-	}
-    }
-}
-#endif
-
-int
-fifos_pending ()
-{
-  return nfifo;
-}
-
-int
-num_fifos ()
-{
-  return nfifo;
-}
-
-static char *
-make_named_pipe ()
-{
-  char *tname;
-
-  tname = sh_mktmpname ("sh-np", MT_USERANDOM|MT_USETMPDIR);
-  if (mkfifo (tname, 0600) < 0)
-    {
-      free (tname);
-      return ((char *)NULL);
-    }
-
-  add_fifo_list (tname);
-  return (tname);
-}
-
-#else /* HAVE_DEV_FD */
-
-/* DEV_FD_LIST is a bitmap of file descriptors attached to pipes the shell
-   has open to children.  NFDS is a count of the number of bits currently
-   set in DEV_FD_LIST.  TOTFDS is a count of the highest possible number
-   of open files. */
-/* dev_fd_list[I] value of -1 means the process has been reaped and file
-   descriptor I needs to be closed. Value of 0 means the slot is unused. */
-
-static pid_t *dev_fd_list = (pid_t *)NULL;
-static int nfds;
-static int totfds;	/* The highest possible number of open files. */
-
-void
-clear_fifo (i)
-     int i;
-{
-  if (dev_fd_list[i])
-    {
-      dev_fd_list[i] = 0;
-      nfds--;
-    }
-}
-
-void
-clear_fifo_list ()
-{
-  register int i;
-
-  if (nfds == 0)
-    return;
-
-  for (i = 0; nfds && i < totfds; i++)
-    clear_fifo (i);
-
-  nfds = 0;
-}
-
-void *
-copy_fifo_list (sizep)
-     int *sizep;
-{
-  void *ret;
-
-  if (nfds == 0 || totfds == 0)
-    {
-      if (sizep)
-	*sizep = 0;
-      return (void *)NULL;
-    }
-
-  if (sizep)
-    *sizep = totfds;
-  ret = xmalloc (totfds * sizeof (pid_t));
-  return (memcpy (ret, dev_fd_list, totfds * sizeof (pid_t)));
-}
-
-static void
-add_fifo_list (fd)
-     int fd;
-{
-  if (dev_fd_list == 0 || fd >= totfds)
-    {
-      int ofds;
-
-      ofds = totfds;
-      totfds = getdtablesize ();
-      if (totfds < 0 || totfds > 256)
-	totfds = 256;
-      if (fd >= totfds)
-	totfds = fd + 2;
-
-      dev_fd_list = (pid_t *)xrealloc (dev_fd_list, totfds * sizeof (dev_fd_list[0]));
-      /* XXX - might need a loop for this */
-      memset (dev_fd_list + ofds, '\0', (totfds - ofds) * sizeof (pid_t));
-    }
-
-  dev_fd_list[fd] = 1;		/* marker; updated later */
-  nfds++;
-}
-
-int
-fifos_pending ()
-{
-  return 0;	/* used for cleanup; not needed with /dev/fd */
-}
-
-int
-num_fifos ()
-{
-  return nfds;
-}
-
-void
-unlink_fifo (fd)
-     int fd;
-{
-  if (dev_fd_list[fd])
-    {
-      close (fd);
-      dev_fd_list[fd] = 0;
-      nfds--;
-    }
-}
-
-void
-unlink_fifo_list ()
-{
-  register int i;
-
-  if (nfds == 0)
-    return;
-
-  for (i = totfds-1; nfds && i >= 0; i--)
-    unlink_fifo (i);
-
-  nfds = 0;
-}
-
-void
-unlink_all_fifos ()
-{
-  unlink_fifo_list ();
-}
-
-/* Take LIST, which is a snapshot copy of dev_fd_list from some point in
-   the past, and close all open fds in dev_fd_list that are not marked
-   as open in LIST.  If LIST is NULL, close everything in dev_fd_list.
-   LSIZE is the number of elements in LIST, in case it's larger than
-   totfds (size of dev_fd_list). */
-void
-close_new_fifos (list, lsize)
-     void *list;
-     int lsize;
-{
-  int i;
-  pid_t *plist;
-
-  if (list == 0)
-    {
-      unlink_fifo_list ();
-      return;
-    }
-
-  for (plist = (pid_t *)list, i = 0; i < lsize; i++)
-    if (plist[i] == 0 && i < totfds && dev_fd_list[i])
-      unlink_fifo (i);
-
-  for (i = lsize; i < totfds; i++)
-    unlink_fifo (i);  
-}
-
-int
-find_procsub_child (pid)
-     pid_t pid;
-{
-  int i;
-
-  if (nfds == 0)
-    return -1;
-
-  for (i = 0; i < totfds; i++)
-    if (dev_fd_list[i] == pid)
-      return i;
-
-  return -1;
-}
-
-void
-set_procsub_status (ind, pid, status)
-     int ind;
-     pid_t pid;
-     int status;
-{
-  if (ind >= 0 && ind < totfds)
-    dev_fd_list[ind] = (pid_t)-1;		/* sentinel */
-}
-
-/* If we've marked the process for this procsub as dead, close the
-   associated file descriptor. */
-static void
-reap_some_procsubs (max)
-     int max;
-{
-  int i;
-
-  for (i = 0; nfds > 0 && i < max; i++)
-    if (dev_fd_list[i] == (pid_t)-1)
-      unlink_fifo (i);
-}
-
-void
-reap_procsubs ()
-{
-  reap_some_procsubs (totfds);
-}
-
-#if 0
-/* UNUSED */
-void
-wait_procsubs ()
-{
-  int i, r;
-
-  for (i = 0; nfds > 0 && i < totfds; i++)
-    {
-      if (dev_fd_list[i] != (pid_t)-1 && dev_fd_list[i] > 0)
-	{
-	  r = wait_for (dev_fd_list[i], 0);
-	  save_proc_status (dev_fd_list[i], r);
-	  dev_fd_list[i] = (pid_t)-1;
-	}
-    }
-}
-#endif
-
-#if defined (NOTDEF)
-print_dev_fd_list ()
-{
-  register int i;
-
-  fprintf (stderr, "pid %ld: dev_fd_list:", (long)getpid ());
-  fflush (stderr);
-
-  for (i = 0; i < totfds; i++)
-    {
-      if (dev_fd_list[i])
-	fprintf (stderr, " %d", i);
-    }
-  fprintf (stderr, "\n");
-}
-#endif /* NOTDEF */
-
-static char *
-make_dev_fd_filename (fd)
-     int fd;
-{
-  char *ret, intbuf[INT_STRLEN_BOUND (int) + 1], *p;
-
-  ret = (char *)xmalloc (sizeof (DEV_FD_PREFIX) + 8);
-
-  strcpy (ret, DEV_FD_PREFIX);
-  p = inttostr (fd, intbuf, sizeof (intbuf));
-  strcpy (ret + sizeof (DEV_FD_PREFIX) - 1, p);
-
-  add_fifo_list (fd);
-  return (ret);
-}
-
-#endif /* HAVE_DEV_FD */
-
-/* Return a filename that will open a connection to the process defined by
-   executing STRING.  HAVE_DEV_FD, if defined, means open a pipe and return
-   a filename in /dev/fd corresponding to a descriptor that is one of the
-   ends of the pipe.  If not defined, we use named pipes on systems that have
-   them.  Systems without /dev/fd and named pipes are out of luck.
-
-   OPEN_FOR_READ_IN_CHILD, if 1, means open the named pipe for reading or
-   use the read end of the pipe and dup that file descriptor to fd 0 in
-   the child.  If OPEN_FOR_READ_IN_CHILD is 0, we open the named pipe for
-   writing or use the write end of the pipe in the child, and dup that
-   file descriptor to fd 1 in the child.  The parent does the opposite. */
-
-static char *
-process_substitute (string, open_for_read_in_child)
-     char *string;
-     int open_for_read_in_child;
-{
-  char *pathname;
-  int fd, result, rc, function_value;
-  pid_t old_pid, pid;
-#if defined (HAVE_DEV_FD)
-  int parent_pipe_fd, child_pipe_fd;
-  int fildes[2];
-#endif /* HAVE_DEV_FD */
-#if defined (JOB_CONTROL)
-  pid_t old_pipeline_pgrp;
-#endif
-
-  if (!string || !*string || wordexp_only)
-    return ((char *)NULL);
-
-#if !defined (HAVE_DEV_FD)
-  pathname = make_named_pipe ();
-#else /* HAVE_DEV_FD */
-  if (pipe (fildes) < 0)
-    {
-      sys_error ("%s", _("cannot make pipe for process substitution"));
-      return ((char *)NULL);
-    }
-  /* If OPEN_FOR_READ_IN_CHILD == 1, we want to use the write end of
-     the pipe in the parent, otherwise the read end. */
-  parent_pipe_fd = fildes[open_for_read_in_child];
-  child_pipe_fd = fildes[1 - open_for_read_in_child];
-  /* Move the parent end of the pipe to some high file descriptor, to
-     avoid clashes with FDs used by the script. */
-  parent_pipe_fd = move_to_high_fd (parent_pipe_fd, 1, 64);
-
-  pathname = make_dev_fd_filename (parent_pipe_fd);
-#endif /* HAVE_DEV_FD */
-
-  if (pathname == 0)
-    {
-      sys_error ("%s", _("cannot make pipe for process substitution"));
-      return ((char *)NULL);
-    }
-
-  old_pid = last_made_pid;
-
-#if defined (JOB_CONTROL)
-  old_pipeline_pgrp = pipeline_pgrp;
-  if (pipeline_pgrp == 0 || (subshell_environment & (SUBSHELL_PIPE|SUBSHELL_FORK|SUBSHELL_ASYNC)) == 0)
-    pipeline_pgrp = shell_pgrp;
-  save_pipeline (1);
-#endif /* JOB_CONTROL */
-
-  pid = make_child ((char *)NULL, FORK_ASYNC);
-  if (pid == 0)
-    {
-#if 0
-      int old_interactive;
-
-      old_interactive = interactive;
-#endif
-      /* The currently-executing shell is not interactive */
-      interactive = 0;
-
-      reset_terminating_signals ();	/* XXX */
-      free_pushed_string_input ();
-      /* Cancel traps, in trap.c. */
-      restore_original_signals ();	/* XXX - what about special builtins? bash-4.2 */
-      subshell_environment &= ~SUBSHELL_IGNTRAP;
-      QUIT;	/* catch any interrupts we got post-fork */
-      setup_async_signals ();
-#if 0
-      if (open_for_read_in_child == 0 && old_interactive && (bash_input.type == st_stdin || bash_input.type == st_stream))
-	async_redirect_stdin ();
-#endif
-
-      subshell_environment |= SUBSHELL_COMSUB|SUBSHELL_PROCSUB|SUBSHELL_ASYNC;
-
-      /* We don't inherit the verbose option for command substitutions now, so
-	 let's try it for process substitutions. */
-      change_flag ('v', FLAG_OFF);
-
-      /* if we're expanding a redirection, we shouldn't have access to the
-	 temporary environment, but commands in the subshell should have
-	 access to their own temporary environment. */
-      if (expanding_redir)
-        flush_temporary_env ();
-    }
-
-#if defined (JOB_CONTROL)
-  set_sigchld_handler ();
-  stop_making_children ();
-  /* XXX - should we only do this in the parent? (as in command subst) */
-  pipeline_pgrp = old_pipeline_pgrp;
-#else
-  stop_making_children ();
-#endif /* JOB_CONTROL */
-
-  if (pid < 0)
-    {
-      sys_error ("%s", _("cannot make child for process substitution"));
-      free (pathname);
-#if defined (HAVE_DEV_FD)
-      close (parent_pipe_fd);
-      close (child_pipe_fd);
-#endif /* HAVE_DEV_FD */
-#if defined (JOB_CONTROL)
-      restore_pipeline (1);
-#endif
-      return ((char *)NULL);
-    }
-
-  if (pid > 0)
-    {
-#if defined (JOB_CONTROL)
-      last_procsub_child = restore_pipeline (0);
-      /* We assume that last_procsub_child->next == last_procsub_child because
-	 of how jobs.c:add_process() works. */
-      last_procsub_child->next = 0;
-      procsub_add (last_procsub_child);
-#endif
-
-#if defined (HAVE_DEV_FD)
-      dev_fd_list[parent_pipe_fd] = pid;
-#else
-      fifo_list[nfifo-1].proc = pid;
-#endif
-
-      last_made_pid = old_pid;
-
-#if defined (JOB_CONTROL) && defined (PGRP_PIPE)
-      close_pgrp_pipe ();
-#endif /* JOB_CONTROL && PGRP_PIPE */
-
-#if defined (HAVE_DEV_FD)
-      close (child_pipe_fd);
-#endif /* HAVE_DEV_FD */
-
-      return (pathname);
-    }
-
-  set_sigint_handler ();
-
-#if defined (JOB_CONTROL)
-  /* make sure we don't have any job control */
-  set_job_control (0);
-
-  /* Clear out any existing list of process substitutions */
-  procsub_clear ();
-
-  /* The idea is that we want all the jobs we start from an async process
-     substitution to be in the same process group, but not the same pgrp
-     as our parent shell, since we don't want to affect our parent shell's
-     jobs if we get a SIGHUP and end up calling hangup_all_jobs, for example.
-     If pipeline_pgrp != shell_pgrp, we assume that there is a job control
-     shell somewhere in our parent process chain (since make_child initializes
-     pipeline_pgrp to shell_pgrp if job_control == 0). What we do in this
-     case is to set pipeline_pgrp to our PID, so all jobs started by this
-     process have that same pgrp and we are basically the process group leader.
-     This should not have negative effects on child processes surviving
-     after we exit, since we wait for the children we create, but that is
-     something to watch for. */
-
-  if (pipeline_pgrp != shell_pgrp)
-    pipeline_pgrp = getpid ();
-#endif /* JOB_CONTROL */
-
-#if !defined (HAVE_DEV_FD)
-  /* Open the named pipe in the child. */
-  fd = open (pathname, open_for_read_in_child ? O_RDONLY : O_WRONLY);
-  if (fd < 0)
-    {
-      /* Two separate strings for ease of translation. */
-      if (open_for_read_in_child)
-	sys_error (_("cannot open named pipe %s for reading"), pathname);
-      else
-	sys_error (_("cannot open named pipe %s for writing"), pathname);
-
-      exit (127);
-    }
-  if (open_for_read_in_child)
-    {
-      if (sh_unset_nodelay_mode (fd) < 0)
-	{
-	  sys_error (_("cannot reset nodelay mode for fd %d"), fd);
-	  exit (127);
-	}
-    }
-#else /* HAVE_DEV_FD */
-  fd = child_pipe_fd;
-#endif /* HAVE_DEV_FD */
-
-  /* Discard  buffered stdio output before replacing the underlying file
-     descriptor. */
-  if (open_for_read_in_child == 0)
-    fpurge (stdout);
-
-  if (dup2 (fd, open_for_read_in_child ? 0 : 1) < 0)
-    {
-      sys_error (_("cannot duplicate named pipe %s as fd %d"), pathname,
-	open_for_read_in_child ? 0 : 1);
-      exit (127);
-    }
-
-  if (fd != (open_for_read_in_child ? 0 : 1))
-    close (fd);
-
-  /* Need to close any files that this process has open to pipes inherited
-     from its parent. */
-  if (current_fds_to_close)
-    {
-      close_fd_bitmap (current_fds_to_close);
-      current_fds_to_close = (struct fd_bitmap *)NULL;
-    }
-
-#if defined (HAVE_DEV_FD)
-  /* Make sure we close the parent's end of the pipe and clear the slot
-     in the fd list so it is not closed later, if reallocated by, for
-     instance, pipe(2). */
-  close (parent_pipe_fd);
-  dev_fd_list[parent_pipe_fd] = 0;
-#endif /* HAVE_DEV_FD */
-
-  /* subshells shouldn't have this flag, which controls using the temporary
-     environment for variable lookups.  We have already flushed the temporary
-     environment above in the case we're expanding a redirection, so processes
-     executed by this command need to be able to set it independently of their
-     parent. */
-  expanding_redir = 0;
-
-  remove_quoted_escapes (string);
-
-  startup_state = 2;	/* see if we can avoid a fork */
-  parse_and_execute_level = 0;
-
-  /* Give process substitution a place to jump back to on failure,
-     so we don't go back up to main (). */
-  result = setjmp_nosigs (top_level);
-
-  /* If we're running a process substitution inside a shell function,
-     trap `return' so we don't return from the function in the subshell
-     and go off to never-never land. */
-  if (result == 0 && return_catch_flag)
-    function_value = setjmp_nosigs (return_catch);
-  else
-    function_value = 0;
-
-  if (result == ERREXIT)
-    rc = last_command_exit_value;
-  else if (result == EXITPROG || result == EXITBLTIN)
-    rc = last_command_exit_value;
-  else if (result)
-    rc = EXECUTION_FAILURE;
-  else if (function_value)
-    rc = return_catch_value;
-  else
-    {
-      subshell_level++;
-      rc = parse_and_execute (string, "process substitution", (SEVAL_NONINT|SEVAL_NOHIST));
-      /* leave subshell level intact for any exit trap */
-    }
-
-#if !defined (HAVE_DEV_FD)
-  /* Make sure we close the named pipe in the child before we exit. */
-  close (open_for_read_in_child ? 0 : 1);
-#endif /* !HAVE_DEV_FD */
-
-  last_command_exit_value = rc;
-  rc = run_exit_trap ();
-  exit (rc);
-  /*NOTREACHED*/
-}
-#endif /* PROCESS_SUBSTITUTION */
-
-/***********************************/
-/*				   */
-/*	Command Substitution	   */
-/*				   */
-/***********************************/
-
-#define COMSUB_PIPEBUF	4096
-
-static char *
-optimize_cat_file (r, quoted, flags, flagp)
-     REDIRECT *r;
-     int quoted, flags, *flagp;
-{
-  char *ret;
-  int fd;
-
-  fd = open_redir_file (r, (char **)0);
-  if (fd < 0)
-    return &expand_param_error;
-
-  ret = read_comsub (fd, quoted, flags, flagp);
-  close (fd);
-
-  return ret;
-}
-
-static char *
-read_comsub (fd, quoted, flags, rflag)
-     int fd, quoted, flags;
-     int *rflag;
-{
-  char *istring, buf[COMSUB_PIPEBUF], *bufp;
-  int c, tflag, skip_ctlesc, skip_ctlnul;
-  int mb_cur_max;
-  size_t istring_index;
-  size_t istring_size;
-  ssize_t bufn;
-  int nullbyte;
-#if defined (HANDLE_MULTIBYTE)
-  mbstate_t ps;
-  wchar_t wc;
-  size_t mblen;
-  int i;
-#endif
-
-  istring = (char *)NULL;
-  istring_index = istring_size = bufn = tflag = 0;
-
-  skip_ctlesc = ifs_cmap[CTLESC];
-  skip_ctlnul = ifs_cmap[CTLNUL];
-
-  mb_cur_max = MB_CUR_MAX;
-  nullbyte = 0;
-
-  /* Read the output of the command through the pipe. */
-  while (1)
-    {
-      if (fd < 0)
-	break;
-      if (--bufn <= 0)
-	{
-	  bufn = zread (fd, buf, sizeof (buf));
-	  if (bufn <= 0) 
-	    break;
-	  bufp = buf;
-	}
-      c = *bufp++;
-
-      if (c == 0)
-	{
-#if 1
-	  if (nullbyte == 0)
-	    {
-	      internal_warning ("%s", _("command substitution: ignored null byte in input"));
-	      nullbyte = 1;
-	    }
-#endif
-	  continue;
-	}
-
-      /* Add the character to ISTRING, possibly after resizing it. */
-      RESIZE_MALLOCED_BUFFER (istring, istring_index, mb_cur_max+1, istring_size, 512);
-
-      /* This is essentially quote_string inline */
-      if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) /* || c == CTLESC || c == CTLNUL */)
-	istring[istring_index++] = CTLESC;
-      else if ((flags & PF_ASSIGNRHS) && skip_ctlesc && c == CTLESC)
-	istring[istring_index++] = CTLESC;
-      /* Escape CTLESC and CTLNUL in the output to protect those characters
-	 from the rest of the word expansions (word splitting and globbing.)
-	 This is essentially quote_escapes inline. */
-      else if (skip_ctlesc == 0 && c == CTLESC)
-	istring[istring_index++] = CTLESC;
-      else if ((skip_ctlnul == 0 && c == CTLNUL) || (c == ' ' && (ifs_value && *ifs_value == 0)))
-	istring[istring_index++] = CTLESC;
-
-#if defined (HANDLE_MULTIBYTE)
-      if ((locale_utf8locale && (c & 0x80)) ||
-	  (locale_utf8locale == 0 && mb_cur_max > 1 && (unsigned char)c > 127))
-	{
-	  /* read a multibyte character from buf */
-	  /* punt on the hard case for now */
-	  memset (&ps, '\0', sizeof (mbstate_t));
-	  mblen = mbrtowc (&wc, bufp-1, bufn, &ps);
-	  if (MB_INVALIDCH (mblen) || mblen == 0 || mblen == 1)
-	    istring[istring_index++] = c;
-	  else
-	    {
-	      istring[istring_index++] = c;
-	      for (i = 0; i < mblen-1; i++)
-		istring[istring_index++] = *bufp++;
-	      bufn -= mblen - 1;
-	    }
-	  continue;
-	}
-#endif
-
-      istring[istring_index++] = c;
-    }
-
-  if (istring)
-    istring[istring_index] = '\0';
-
-  /* If we read no output, just return now and save ourselves some
-     trouble. */
-  if (istring_index == 0)
-    {
-      FREE (istring);
-      if (rflag)
-	*rflag = tflag;
-      return (char *)NULL;
-    }
-
-  /* Strip trailing newlines from the output of the command. */
-  if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-    {
-      while (istring_index > 0)
-	{
-	  if (istring[istring_index - 1] == '\n')
-	    {
-	      --istring_index;
-
-	      /* If the newline was quoted, remove the quoting char. */
-	      if (istring[istring_index - 1] == CTLESC)
-		--istring_index;
-	    }
-	  else
-	    break;
-	}
-      istring[istring_index] = '\0';
-    }
-  else
-    strip_trailing (istring, istring_index - 1, 1);
-
-  if (rflag)
-    *rflag = tflag;
-  return istring;
-}
-
-/* Perform command substitution on STRING.  This returns a WORD_DESC * with the
-   contained string possibly quoted. */
-WORD_DESC *
-command_substitute (string, quoted, flags)
-     char *string;
-     int quoted;
-     int flags;
-{
-  pid_t pid, old_pid, old_pipeline_pgrp, old_async_pid;
-  char *istring, *s;
-  int result, fildes[2], function_value, pflags, rc, tflag, fork_flags;
-  WORD_DESC *ret;
-  sigset_t set, oset;
-
-  istring = (char *)NULL;
-
-  /* Don't fork () if there is no need to.  In the case of no command to
-     run, just return NULL. */
-  for (s = string; s && *s && (shellblank (*s) || *s == '\n'); s++)
-    ;
-  if (s == 0 || *s == 0)
-    return ((WORD_DESC *)NULL);
-
-  if (*s == '<' && (s[1] != '<' && s[1] != '>' && s[1] != '&'))
-    {
-      COMMAND *cmd;
-
-      cmd = parse_string_to_command (string, 0);	/* XXX - flags */
-      if (cmd && can_optimize_cat_file (cmd))
-	{
-	  tflag = 0;
-	  istring = optimize_cat_file (cmd->value.Simple->redirects, quoted, flags, &tflag);
-	  if (istring == &expand_param_error)
-	    {
-	      last_command_exit_value = EXECUTION_FAILURE;
-	      istring = 0;
-	    }
-	  else
-	    last_command_exit_value = EXECUTION_SUCCESS;	/* compat */
-	  last_command_subst_pid = dollar_dollar_pid;
-
-	  dispose_command (cmd);	  
-	  ret = alloc_word_desc ();
-	  ret->word = istring;
-	  ret->flags = tflag;
-
-	  return ret;
-	}
-      dispose_command (cmd);
-    }
-
-  if (wordexp_only && read_but_dont_execute)
-    {
-      last_command_exit_value = EX_WEXPCOMSUB;
-      jump_to_top_level (EXITPROG);
-    }
-
-  /* We're making the assumption here that the command substitution will
-     eventually run a command from the file system.  Since we'll run
-     maybe_make_export_env in this subshell before executing that command,
-     the parent shell and any other shells it starts will have to remake
-     the environment.  If we make it before we fork, other shells won't
-     have to.  Don't bother if we have any temporary variable assignments,
-     though, because the export environment will be remade after this
-     command completes anyway, but do it if all the words to be expanded
-     are variable assignments. */
-  if (subst_assign_varlist == 0 || garglist == 0)
-    maybe_make_export_env ();	/* XXX */
-
-  /* Flags to pass to parse_and_execute() */
-  pflags = (interactive && sourcelevel == 0) ? SEVAL_RESETLINE : 0;
-
-  old_pid = last_made_pid;
-
-  /* Pipe the output of executing STRING into the current shell. */
-  if (pipe (fildes) < 0)
-    {
-      sys_error ("%s", _("cannot make pipe for command substitution"));
-      goto error_exit;
-    }
-
-#if defined (JOB_CONTROL)
-  old_pipeline_pgrp = pipeline_pgrp;
-  /* Don't reset the pipeline pgrp if we're already a subshell in a pipeline or
-     we've already forked to run a disk command (and are expanding redirections,
-     for example). */
-  if ((subshell_environment & (SUBSHELL_FORK|SUBSHELL_PIPE)) == 0)
-    pipeline_pgrp = shell_pgrp;
-  cleanup_the_pipeline ();
-#endif /* JOB_CONTROL */
-
-  old_async_pid = last_asynchronous_pid;
-  fork_flags = (subshell_environment&SUBSHELL_ASYNC) ? FORK_ASYNC : 0;
-  pid = make_child ((char *)NULL, fork_flags|FORK_NOTERM);
-  last_asynchronous_pid = old_async_pid;
-
-  if (pid == 0)
-    {
-      /* Reset the signal handlers in the child, but don't free the
-	 trap strings.  Set a flag noting that we have to free the
-	 trap strings if we run trap to change a signal disposition. */
-      reset_signal_handlers ();
-      if (ISINTERRUPT)
-	{
-	  kill (getpid (), SIGINT);
-	  CLRINTERRUPT;		/* if we're ignoring SIGINT somehow */
-	}	
-      QUIT;	/* catch any interrupts we got post-fork */
-      subshell_environment |= SUBSHELL_RESETTRAP;
-      subshell_environment &= ~SUBSHELL_IGNTRAP;
-    }
-
-#if defined (JOB_CONTROL)
-  /* XXX DO THIS ONLY IN PARENT ? XXX */
-  set_sigchld_handler ();
-  stop_making_children ();
-  if (pid != 0)
-    pipeline_pgrp = old_pipeline_pgrp;
-#else
-  stop_making_children ();
-#endif /* JOB_CONTROL */
-
-  if (pid < 0)
-    {
-      sys_error (_("cannot make child for command substitution"));
-    error_exit:
-
-      last_made_pid = old_pid;
-
-      FREE (istring);
-      close (fildes[0]);
-      close (fildes[1]);
-      return ((WORD_DESC *)NULL);
-    }
-
-  if (pid == 0)
-    {
-      /* The currently executing shell is not interactive. */
-      interactive = 0;
-
-#if defined (JOB_CONTROL)
-      /* Invariant: in child processes started to run command substitutions,
-	 pipeline_pgrp == shell_pgrp. Other parts of the shell assume this. */
-      if (pipeline_pgrp > 0 && pipeline_pgrp != shell_pgrp)
-	shell_pgrp = pipeline_pgrp;
-#endif
-
-      set_sigint_handler ();	/* XXX */
-
-      free_pushed_string_input ();
-
-      /* Discard  buffered stdio output before replacing the underlying file
-	 descriptor. */
-      fpurge (stdout);
-
-      if (dup2 (fildes[1], 1) < 0)
-	{
-	  sys_error ("%s", _("command_substitute: cannot duplicate pipe as fd 1"));
-	  exit (EXECUTION_FAILURE);
-	}
-
-      /* If standard output is closed in the parent shell
-	 (such as after `exec >&-'), file descriptor 1 will be
-	 the lowest available file descriptor, and end up in
-	 fildes[0].  This can happen for stdin and stderr as well,
-	 but stdout is more important -- it will cause no output
-	 to be generated from this command. */
-      if ((fildes[1] != fileno (stdin)) &&
-	  (fildes[1] != fileno (stdout)) &&
-	  (fildes[1] != fileno (stderr)))
-	close (fildes[1]);
-
-      if ((fildes[0] != fileno (stdin)) &&
-	  (fildes[0] != fileno (stdout)) &&
-	  (fildes[0] != fileno (stderr)))
-	close (fildes[0]);
-
-#ifdef __CYGWIN__
-      /* Let stdio know the fd may have changed from text to binary mode, and
-	 make sure to preserve stdout line buffering. */
-      freopen (NULL, "w", stdout);
-      sh_setlinebuf (stdout);
-#endif /* __CYGWIN__ */
-
-      /* This is a subshell environment. */
-      subshell_environment |= SUBSHELL_COMSUB;
-
-      /* Many shells do not appear to inherit the -v option for command
-	 substitutions. */
-      change_flag ('v', FLAG_OFF);
-
-      /* When inherit_errexit option is not enabled, command substitution does
-	 not inherit the -e flag.  It is enabled when Posix mode is enabled */
-      if (inherit_errexit == 0)
-        {
-          builtin_ignoring_errexit = 0;
-	  change_flag ('e', FLAG_OFF);
-        }
-      set_shellopts ();
-
-      /* If we are expanding a redirection, we can dispose of any temporary
-	 environment we received, since redirections are not supposed to have
-	 access to the temporary environment.  We will have to see whether this
-	 affects temporary environments supplied to `eval', but the temporary
-	 environment gets copied to builtin_env at some point. */
-      if (expanding_redir)
-	{
-	  flush_temporary_env ();
-	  expanding_redir = 0;
-	}
-
-      remove_quoted_escapes (string);
-
-      /* We want to expand aliases on this pass if we are not in posix mode
-	 for backwards compatibility. */
-      if (expand_aliases)
-        expand_aliases = posixly_correct == 0;
-
-      startup_state = 2;	/* see if we can avoid a fork */
-      parse_and_execute_level = 0;
-
-      /* Give command substitution a place to jump back to on failure,
-	 so we don't go back up to main (). */
-      result = setjmp_nosigs (top_level);
-
-      /* If we're running a command substitution inside a shell function,
-	 trap `return' so we don't return from the function in the subshell
-	 and go off to never-never land. */
-      if (result == 0 && return_catch_flag)
-	function_value = setjmp_nosigs (return_catch);
-      else
-	function_value = 0;
-
-      if (result == ERREXIT)
-	rc = last_command_exit_value;
-      else if (result == EXITPROG || result == EXITBLTIN)
-	rc = last_command_exit_value;
-      else if (result)
-	rc = EXECUTION_FAILURE;
-      else if (function_value)
-	rc = return_catch_value;
-      else
-	{
-	  subshell_level++;
-	  rc = parse_and_execute (string, "command substitution", pflags|SEVAL_NOHIST);
-	  /* leave subshell level intact for any exit trap */
-	}
-
-      last_command_exit_value = rc;
-      rc = run_exit_trap ();
-#if defined (PROCESS_SUBSTITUTION)
-      unlink_fifo_list ();
-#endif
-      exit (rc);
-    }
-  else
-    {
-      int dummyfd;
-
-#if defined (JOB_CONTROL) && defined (PGRP_PIPE)
-      close_pgrp_pipe ();
-#endif /* JOB_CONTROL && PGRP_PIPE */
-
-      close (fildes[1]);
-
-      begin_unwind_frame ("read-comsub");
-      dummyfd = fildes[0];
-      add_unwind_protect (close, dummyfd);
-
-      /* Block SIGINT while we're reading from the pipe. If the child
-	 process gets a SIGINT, it will either handle it or die, and the
-	 read will return. */
-      BLOCK_SIGNAL (SIGINT, set, oset);
-      tflag = 0;
-      istring = read_comsub (fildes[0], quoted, flags, &tflag);
-
-      close (fildes[0]);
-      discard_unwind_frame ("read-comsub");
-      UNBLOCK_SIGNAL (oset);
-
-      current_command_subst_pid = pid;
-      last_command_exit_value = wait_for (pid, JWAIT_NOTERM);
-      last_command_subst_pid = pid;
-      last_made_pid = old_pid;
-
-#if defined (JOB_CONTROL)
-      /* If last_command_exit_value > 128, then the substituted command
-	 was terminated by a signal.  If that signal was SIGINT, then send
-	 SIGINT to ourselves.  This will break out of loops, for instance. */
-      if (last_command_exit_value == (128 + SIGINT) && last_command_exit_signal == SIGINT)
-	kill (getpid (), SIGINT);
-#endif /* JOB_CONTROL */
-
-      ret = alloc_word_desc ();
-      ret->word = istring;
-      ret->flags = tflag;
-
-      return ret;
-    }
-}
-
-/********************************************************
- *							*
- *	Utility functions for parameter expansion	*
- *							*
- ********************************************************/
-
-#if defined (ARRAY_VARS)
-
-static arrayind_t
-array_length_reference (s)
-     char *s;
-{
-  int len;
-  arrayind_t ind;
-  char *akey;
-  char *t, c;
-  ARRAY *array;
-  HASH_TABLE *h;
-  SHELL_VAR *var;
-
-  var = array_variable_part (s, 0, &t, &len);
-
-  /* If unbound variables should generate an error, report one and return
-     failure. */
-  if ((var == 0 || invisible_p (var) || (assoc_p (var) == 0 && array_p (var) == 0)) && unbound_vars_is_error)
-    {
-      c = *--t;
-      *t = '\0';
-      set_exit_status (EXECUTION_FAILURE);
-      err_unboundvar (s);
-      *t = c;
-      return (-1);
-    }
-  else if (var == 0 || invisible_p (var))
-    return 0;
-
-  /* We support a couple of expansions for variables that are not arrays.
-     We'll return the length of the value for v[0], and 1 for v[@] or
-     v[*].  Return 0 for everything else. */
-
-  array = array_p (var) ? array_cell (var) : (ARRAY *)NULL;
-  h = assoc_p (var) ? assoc_cell (var) : (HASH_TABLE *)NULL;
-
-  if (ALL_ELEMENT_SUB (t[0]) && t[1] == RBRACK)
-    {
-      if (assoc_p (var))
-	return (h ? assoc_num_elements (h) : 0);
-      else if (array_p (var))
-	return (array ? array_num_elements (array) : 0);
-      else
-	return (var_isset (var) ? 1 : 0);
-    }
-
-  if (assoc_p (var))
-    {
-      t[len - 1] = '\0';
-      akey = expand_subscript_string (t, 0);	/* [ */
-      t[len - 1] = RBRACK;
-      if (akey == 0 || *akey == 0)
-	{
-	  err_badarraysub (t);
-	  FREE (akey);
-	  return (-1);
-	}
-      t = assoc_reference (assoc_cell (var), akey);
-      free (akey);
-    }
-  else
-    {
-      ind = array_expand_index (var, t, len, 0);
-      /* negative subscripts to indexed arrays count back from end */
-      if (var && array_p (var) && ind < 0)
-	ind = array_max_index (array_cell (var)) + 1 + ind;
-      if (ind < 0)
-	{
-	  err_badarraysub (t);
-	  return (-1);
-	}
-      if (array_p (var))
-	t = array_reference (array, ind);
-      else
-	t = (ind == 0) ? value_cell (var) : (char *)NULL;
-    }
-
-  len = MB_STRLEN (t);
-  return (len);
-}
-#endif /* ARRAY_VARS */
-
-static int
-valid_brace_expansion_word (name, var_is_special)
-     char *name;
-     int var_is_special;
-{
-  if (DIGIT (*name) && all_digits (name))
-    return 1;
-  else if (var_is_special)
-    return 1;
-#if defined (ARRAY_VARS)
-  else if (valid_array_reference (name, 0))
-    return 1;
-#endif /* ARRAY_VARS */
-  else if (legal_identifier (name))
-    return 1;
-  else
-    return 0;
-}
-
-static int
-chk_atstar (name, quoted, pflags, quoted_dollar_atp, contains_dollar_at)
-     char *name;
-     int quoted, pflags;
-     int *quoted_dollar_atp, *contains_dollar_at;
-{
-  char *temp1;
-
-  if (name == 0)
-    {
-      if (quoted_dollar_atp)
-	*quoted_dollar_atp = 0;
-      if (contains_dollar_at)
-	*contains_dollar_at = 0;
-      return 0;
-    }
-
-  /* check for $@ and $* */
-  if (name[0] == '@' && name[1] == 0)
-    {
-      if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
-	*quoted_dollar_atp = 1;
-      if (contains_dollar_at)
-	*contains_dollar_at = 1;
-      return 1;
-    }
-  else if (name[0] == '*' && name[1] == '\0' && quoted == 0)
-    {
-      /* Need more checks here that parallel what string_list_pos_params and
-	 param_expand do. Check expand_no_split_dollar_star and ??? */
-      if (contains_dollar_at && expand_no_split_dollar_star == 0)
-	*contains_dollar_at = 1;
-      return 1;
-    }
-
-  /* Now check for ${array[@]} and ${array[*]} */
-#if defined (ARRAY_VARS)
-  else if (valid_array_reference (name, 0))
-    {
-      temp1 = mbschr (name, LBRACK);
-      if (temp1 && temp1[1] == '@' && temp1[2] == RBRACK)
-	{
-	  if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
-	    *quoted_dollar_atp = 1;
-	  if (contains_dollar_at)
-	    *contains_dollar_at = 1;
-	  return 1;
-	}
-      /* ${array[*]}, when unquoted, should be treated like ${array[@]},
-	 which should result in separate words even when IFS is unset. */
-      if (temp1 && temp1[1] == '*' && temp1[2] == RBRACK && quoted == 0)
-	{
-	  if (contains_dollar_at)
-	    *contains_dollar_at = 1;
-	  return 1;
-	}
-    }
-#endif
-  return 0;
-}
-
-/* Parameter expand NAME, and return a new string which is the expansion,
-   or NULL if there was no expansion.  NAME is as given in ${NAMEcWORD}.
-   VAR_IS_SPECIAL is non-zero if NAME is one of the special variables in
-   the shell, e.g., "@", "$", "*", etc.  QUOTED, if non-zero, means that
-   NAME was found inside of a double-quoted expression. */
-static WORD_DESC *
-parameter_brace_expand_word (name, var_is_special, quoted, pflags, estatep)
-     char *name;
-     int var_is_special, quoted, pflags;
-     array_eltstate_t *estatep;
-{
-  WORD_DESC *ret;
-  char *temp, *tt;
-  intmax_t arg_index;
-  SHELL_VAR *var;
-  int rflags;
-  array_eltstate_t es;
-
-  ret = 0;
-  temp = 0;
-  rflags = 0;
-
-#if defined (ARRAY_VARS)
-  if (estatep)
-    es = *estatep;	/* structure copy */
-  else
-    {
-      init_eltstate (&es);
-      es.ind = INTMAX_MIN;
-    }
-#endif
-
-  /* Handle multiple digit arguments, as in ${11}. */  
-  if (legal_number (name, &arg_index))
-    {
-      tt = get_dollar_var_value (arg_index);
-      if (tt)
- 	temp = (*tt && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
- 		  ? quote_string (tt)
- 		  : quote_escapes (tt);
-      else
-        temp = (char *)NULL;
-      FREE (tt);
-    }
-  else if (var_is_special)      /* ${@} */
-    {
-      int sindex;
-      tt = (char *)xmalloc (2 + strlen (name));
-      tt[sindex = 0] = '$';
-      strcpy (tt + 1, name);
-
-      ret = param_expand (tt, &sindex, quoted, (int *)NULL, (int *)NULL,
-			  (int *)NULL, (int *)NULL, pflags);
-
-      /* Make sure we note that we saw a quoted null string and pass the flag back
-	 to the caller in addition to the value. */
-      if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) && STR_DOLLAR_AT_STAR (name) &&
-	  ret && ret->word && QUOTED_NULL (ret->word))
-	ret->flags |= W_HASQUOTEDNULL;
-
-      free (tt);
-    }
-#if defined (ARRAY_VARS)
-  else if (valid_array_reference (name, 0))
-    {
-expand_arrayref:
-      var = array_variable_part (name, 0, &tt, (int *)0);
-      /* These are the cases where word splitting will not be performed */
-      if (pflags & PF_ASSIGNRHS)
-	{
-	  if (ALL_ELEMENT_SUB (tt[0]) && tt[1] == RBRACK)
-	    {
-	      /* Only treat as double quoted if array variable */
-	      if (var && (array_p (var) || assoc_p (var)))
-		temp = array_value (name, quoted|Q_DOUBLE_QUOTES, AV_ASSIGNRHS, &es);
-	      else		
-		temp = array_value (name, quoted, 0, &es);
-	    }
-	  else
-	    temp = array_value (name, quoted, 0, &es);
-	}
-      /* Posix interp 888 */
-      else if (pflags & PF_NOSPLIT2)
-	{
-	  /* Special cases, then general case, for each of A[@], A[*], A[n] */
-#if defined (HANDLE_MULTIBYTE)
-          if (tt[0] == '@' && tt[1] == RBRACK && var && quoted == 0 && ifs_is_set && ifs_is_null == 0 && ifs_firstc[0] != ' ')
-#else
-	  if (tt[0] == '@' && tt[1] == RBRACK && var && quoted == 0 && ifs_is_set && ifs_is_null == 0 && ifs_firstc != ' ')
-#endif
-	    temp = array_value (name, Q_DOUBLE_QUOTES, AV_ASSIGNRHS, &es);
-	  else if (tt[0] == '@' && tt[1] == RBRACK)
-	    temp = array_value (name, quoted, 0, &es);
-	  else if (tt[0] == '*' && tt[1] == RBRACK && expand_no_split_dollar_star && ifs_is_null)
-	    temp = array_value (name, Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT, 0, &es);
-	  else if (tt[0] == '*' && tt[1] == RBRACK)
-	    temp = array_value (name, quoted, 0, &es);
-	  else
-	    temp = array_value (name, quoted, 0, &es);
-	}	  	  
-      else if (tt[0] == '*' && tt[1] == RBRACK && expand_no_split_dollar_star && ifs_is_null)
-	temp = array_value (name, Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT, 0, &es);
-      else
-	temp = array_value (name, quoted, 0, &es);
-      if (es.subtype == 0 && temp)
-	{
-	  temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
-		    ? quote_string (temp)
-		    : quote_escapes (temp);
-	  rflags |= W_ARRAYIND;
-	  if (estatep)
-	    *estatep = es;	/* structure copy */
-	}
-      /* Note that array[*] and array[@] expanded to a quoted null string by
-	 returning the W_HASQUOTEDNULL flag to the caller in addition to TEMP. */
-      else if (es.subtype == 1 && temp && QUOTED_NULL (temp) && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
-	rflags |= W_HASQUOTEDNULL;
-      else if (es.subtype == 2 && temp && QUOTED_NULL (temp) && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
-	rflags |= W_HASQUOTEDNULL;
-
-      if (estatep == 0)
-	flush_eltstate (&es);
-    }
-#endif
-  else if (var = find_variable (name))
-    {
-      if (var_isset (var) && invisible_p (var) == 0)
-	{
-#if defined (ARRAY_VARS)
-	  /* We avoid a memory leak by saving TT as the memory allocated by
-	     assoc_to_string or array_to_string and leaving it 0 otherwise,
-	     then freeing TT after quoting temp. */
-	  tt = (char *)NULL;
-	  if ((pflags & PF_ALLINDS) && assoc_p (var))
-	    tt = temp = assoc_empty (assoc_cell (var)) ? (char *)NULL : assoc_to_string (assoc_cell (var), " ", quoted);
-	  else if ((pflags & PF_ALLINDS) && array_p (var))
-	    tt = temp = array_empty (array_cell (var)) ? (char *)NULL : array_to_string (array_cell (var), " ", quoted);
-	  else if (assoc_p (var))
-	    temp = assoc_reference (assoc_cell (var), "0");
-	  else if (array_p (var))
-	    temp = array_reference (array_cell (var), 0);
-	  else
-	    temp = value_cell (var);
-#else
-	  temp = value_cell (var);
-#endif
-
-	  if (temp)
-	    temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
-		      ? quote_string (temp)
-		      : ((pflags & PF_ASSIGNRHS) ? quote_rhs (temp)
-						 : quote_escapes (temp));
-	  FREE (tt);
-	}
-      else
-	temp = (char *)NULL;
-    }
-  else if (var = find_variable_last_nameref (name, 0))
-    {
-      temp = nameref_cell (var);
-#if defined (ARRAY_VARS)
-      /* Handle expanding nameref whose value is x[n] */
-      if (temp && *temp && valid_array_reference (temp, 0))
-	{
-	  name = temp;
-	  goto expand_arrayref;
-	}
-      else
-#endif
-      /* y=2 ; typeset -n x=y; echo ${x} is not the same as echo ${2} in ksh */
-      if (temp && *temp && legal_identifier (temp) == 0)
-        {
-	  set_exit_status (EXECUTION_FAILURE);
-	  report_error (_("%s: invalid variable name for name reference"), temp);
-	  temp = &expand_param_error;
-        }
-      else
-	temp = (char *)NULL;
-    }
-  else
-    temp = (char *)NULL;
-
-  if (ret == 0)
-    {
-      ret = alloc_word_desc ();
-      ret->word = temp;
-      ret->flags |= rflags;
-    }
-  return ret;
-}
-
-static char *
-parameter_brace_find_indir (name, var_is_special, quoted, find_nameref)
-     char *name;
-     int var_is_special, quoted, find_nameref;
-{
-  char *temp, *t;
-  WORD_DESC *w;
-  SHELL_VAR *v;
-  int pflags, oldex;
-
-  if (find_nameref && var_is_special == 0 && (v = find_variable_last_nameref (name, 0)) &&
-      nameref_p (v) && (t = nameref_cell (v)) && *t)
-    return (savestring (t));
-
-  /* If var_is_special == 0, and name is not an array reference, this does
-     more expansion than necessary.  It should really look up the variable's
-     value and not try to expand it. */
-  pflags = PF_IGNUNBOUND;
-  /* Note that we're not going to be doing word splitting here */
-  if (var_is_special)
-    {
-      pflags |= PF_ASSIGNRHS;	/* suppresses word splitting */
-      oldex = expand_no_split_dollar_star;
-      expand_no_split_dollar_star = 1;
-    }
-  w = parameter_brace_expand_word (name, var_is_special, quoted, pflags, 0);
-  if (var_is_special)
-    expand_no_split_dollar_star = oldex;
-
-  t = w->word;
-  /* Have to dequote here if necessary */
-  if (t)
-    {
-      temp = ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) || var_is_special)
-		? dequote_string (t)
-		: dequote_escapes (t);
-      free (t);
-      t = temp;
-    }
-  dispose_word_desc (w);
-
-  return t;
-}
-  
-/* Expand an indirect reference to a variable: ${!NAME} expands to the
-   value of the variable whose name is the value of NAME. */
-static WORD_DESC *
-parameter_brace_expand_indir (name, var_is_special, quoted, pflags, quoted_dollar_atp, contains_dollar_at)
-     char *name;
-     int var_is_special, quoted, pflags;
-     int *quoted_dollar_atp, *contains_dollar_at;
-{
-  char *t;
-  WORD_DESC *w;
-  SHELL_VAR *v;
-
-  /* See if it's a nameref first, behave in ksh93-compatible fashion.
-     There is at least one incompatibility: given ${!foo[0]} where foo=bar,
-     bash performs an indirect lookup on foo[0] and expands the result;
-     ksh93 expands bar[0].  We could do that here -- there are enough usable
-     primitives to do that -- but do not at this point. */
-  if (var_is_special == 0 && (v = find_variable_last_nameref (name, 0)))
-    {
-      if (nameref_p (v) && (t = nameref_cell (v)) && *t)
-	{
-	  w = alloc_word_desc ();
-	  w->word = savestring (t);
-	  w->flags = 0;
-	  return w;
-	}
-    }
-
-  /* An indirect reference to a positional parameter or a special parameter
-     is ok.  Indirect references to array references, as explained above, are
-     ok (currently).  Only references to unset variables are errors at this
-     point. */
-  if (legal_identifier (name) && v == 0)
-    {
-      report_error (_("%s: invalid indirect expansion"), name);
-      w = alloc_word_desc ();
-      w->word = &expand_param_error;
-      w->flags = 0;
-      return (w);
-    }
-      
-  t = parameter_brace_find_indir (name, var_is_special, quoted, 0);
-
-  chk_atstar (t, quoted, pflags, quoted_dollar_atp, contains_dollar_at);
-
-#if defined (ARRAY_VARS)
-  /* Array references to unset variables are also an error */
-  if (t == 0 && valid_array_reference (name, 0))
-    {
-      v = array_variable_part (name, 0, (char **)0, (int *)0);
-      if (v == 0)
-	{
-	  report_error (_("%s: invalid indirect expansion"), name);
-	  w = alloc_word_desc ();
-	  w->word = &expand_param_error;
-	  w->flags = 0;
-	  return (w);
-	}
-      else
-        return (WORD_DESC *)NULL;      
-    }
-#endif
-
-  if (t == 0)
-    return (WORD_DESC *)NULL;
-
-  if (valid_brace_expansion_word (t, SPECIAL_VAR (t, 0)) == 0)
-    {
-      report_error (_("%s: invalid variable name"), t);
-      free (t);
-      w = alloc_word_desc ();
-      w->word = &expand_param_error;
-      w->flags = 0;
-      return (w);
-    }
-	
-  w = parameter_brace_expand_word (t, SPECIAL_VAR(t, 0), quoted, pflags, 0);
-  free (t);
-
-  return w;
-}
-
-/* Expand the right side of a parameter expansion of the form ${NAMEcVALUE},
-   depending on the value of C, the separating character.  C can be one of
-   "-", "+", or "=".  QUOTED is true if the entire brace expression occurs
-   between double quotes. */
-static WORD_DESC *
-parameter_brace_expand_rhs (name, value, op, quoted, pflags, qdollaratp, hasdollarat)
-     char *name, *value;
-     int op, quoted, pflags, *qdollaratp, *hasdollarat;
-{
-  WORD_DESC *w;
-  WORD_LIST *l, *tl;
-  char *t, *t1, *temp, *vname, *newval;
-  int l_hasdollat, sindex, arrayref;
-  SHELL_VAR *v;
-  array_eltstate_t es;
-
-/*itrace("parameter_brace_expand_rhs: %s:%s pflags = %d", name, value, pflags);*/
-  /* If the entire expression is between double quotes, we want to treat
-     the value as a double-quoted string, with the exception that we strip
-     embedded unescaped double quotes (for sh backwards compatibility). */
-  if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && *value)
-    {
-      sindex = 0;
-      temp = string_extract_double_quoted (value, &sindex, SX_STRIPDQ);
-    }
-  else
-    temp = value;
-
-  w = alloc_word_desc ();
-  l_hasdollat = 0;
-  l = *temp ? expand_string_for_rhs (temp, quoted, op, pflags, &l_hasdollat, (int *)NULL)
-	    : (WORD_LIST *)0;
-  if (hasdollarat)
-    *hasdollarat = l_hasdollat || (l && l->next);
-  if (temp != value)
-    free (temp);
-
-  /* list_string takes multiple CTLNULs and turns them into an empty word
-     with W_SAWQUOTEDNULL set. Turn it back into a single CTLNUL for the
-     rest of this function and the caller. */
-  for (tl = l; tl; tl = tl->next)
-    {
-      if (tl->word && (tl->word->word == 0 || tl->word->word[0] == 0) &&
-	    (tl->word->flags | W_SAWQUOTEDNULL))
-	{
-	  t = make_quoted_char ('\0');
-	  FREE (tl->word->word);
-	  tl->word->word = t;
-	  tl->word->flags |= W_QUOTED|W_HASQUOTEDNULL;
-	  tl->word->flags &= ~W_SAWQUOTEDNULL;
-	}
-    }
-
-  if (l)
-    {
-      /* If l->next is not null, we know that TEMP contained "$@", since that
-	 is the only expansion that creates more than one word. */
-      if (qdollaratp && ((l_hasdollat && quoted) || l->next))
-	{
-/*itrace("parameter_brace_expand_rhs: %s:%s: l != NULL, set *qdollaratp", name, value);*/
-	  *qdollaratp = 1;
-	}
-
-      /* The expansion of TEMP returned something.  We need to treat things
-	  slightly differently if L_HASDOLLAT is non-zero.  If we have "$@",
-	  the individual words have already been quoted.  We need to turn them
-	  into a string with the words separated by the first character of
-	  $IFS without any additional quoting, so string_list_dollar_at won't
-	  do the right thing.  If IFS is null, we want "$@" to split into
-	  separate arguments, not be concatenated, so we use string_list_internal
-	  and mark the word to be split on spaces later.  We use
-	  string_list_dollar_star for "$@" otherwise. */
-      if (l->next && ifs_is_null)
-	{
-	  temp = string_list_internal (l, " ");
-	  w->flags |= W_SPLITSPACE;
-	}
-      else if (l_hasdollat || l->next)
-	temp = string_list_dollar_star (l, quoted, 0);
-      else
-	{
-	  temp = string_list (l);
-	  if (temp && (QUOTED_NULL (temp) == 0) && (l->word->flags & W_SAWQUOTEDNULL))
-	    w->flags |= W_SAWQUOTEDNULL;	/* XXX */
-	}
-
-      /* If we have a quoted null result (QUOTED_NULL(temp)) and the word is
-	 a quoted null (l->next == 0 && QUOTED_NULL(l->word->word)), the
-	 flags indicate it (l->word->flags & W_HASQUOTEDNULL), and the
-	 expansion is quoted (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-	 (which is more paranoia than anything else), we need to return the
-	 quoted null string and set the flags to indicate it. */
-      if (l->next == 0 && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && QUOTED_NULL (temp) && QUOTED_NULL (l->word->word) && (l->word->flags & W_HASQUOTEDNULL))
-	{
-	  w->flags |= W_HASQUOTEDNULL;
-/*itrace("parameter_brace_expand_rhs (%s:%s): returning quoted null, turning off qdollaratp", name, value);*/
-	  /* If we return a quoted null with L_HASDOLLARAT, we either have a
-	     construct like "${@-$@}" or "${@-${@-$@}}" with no positional
-	     parameters or a quoted expansion of "$@" with $1 == ''.  In either
-	     case, we don't want to enable special handling of $@. */
-	  if (qdollaratp && l_hasdollat)
-	    *qdollaratp = 0;
-	}
-      dispose_words (l);
-    }
-  else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && l_hasdollat)
-    {
-      /* Posix interp 221 changed the rules on this.  The idea is that
-	 something like "$xxx$@" should expand the same as "${foo-$xxx$@}"
-	 when foo and xxx are unset.  The problem is that it's not in any
-	 way backwards compatible and few other shells do it.  We're eventually
-	 going to try and split the difference (heh) a little bit here. */
-      /* l_hasdollat == 1 means we saw a quoted dollar at.  */
-
-      /* The brace expansion occurred between double quotes and there was
-	 a $@ in TEMP.  It does not matter if the $@ is quoted, as long as
-	 it does not expand to anything.  In this case, we want to return
-	 a quoted empty string.  Posix interp 888 */
-      temp = make_quoted_char ('\0');
-      w->flags |= W_HASQUOTEDNULL;
-/*itrace("parameter_brace_expand_rhs (%s:%s): returning quoted null", name, value);*/
-    }
-  else
-    temp = (char *)NULL;
-
-  if (op == '-' || op == '+')
-    {
-      w->word = temp;
-      return w;
-    }
-
-  /* op == '=' */
-  t1 = temp ? dequote_string (temp) : savestring ("");
-  free (temp);
-
-  /* bash-4.4/5.0 */
-  vname = name;
-  if (*name == '!' &&
-      (legal_variable_starter ((unsigned char)name[1]) || DIGIT (name[1]) || VALID_INDIR_PARAM (name[1])))
-    {
-      vname = parameter_brace_find_indir (name + 1, SPECIAL_VAR (name, 1), quoted, 1);
-      if (vname == 0 || *vname == 0)
-	{
-	  report_error (_("%s: invalid indirect expansion"), name);
-	  free (vname);
-	  free (t1);
-	  dispose_word (w);
-	  return &expand_wdesc_error;
-	}
-      if (legal_identifier (vname) == 0)
-	{
-	  report_error (_("%s: invalid variable name"), vname);
-	  free (vname);
-	  free (t1);
-	  dispose_word (w);
-	  return &expand_wdesc_error;
-	}
-    }
-    
-  arrayref = 0;
-#if defined (ARRAY_VARS)
-  if (valid_array_reference (vname, 0))
-    {
-      init_eltstate (&es);
-      v = assign_array_element (vname, t1, ASS_ALLOWALLSUB, &es);
-      arrayref = 1;
-      newval = es.value;
-    }
-  else
-#endif /* ARRAY_VARS */
-  v = bind_variable (vname, t1, 0);
-
-  if (v == 0 || readonly_p (v) || noassign_p (v))	/* expansion error  */
-    {
-      if ((v == 0 || readonly_p (v)) && interactive_shell == 0 && posixly_correct)
-	{
-	  last_command_exit_value = EXECUTION_FAILURE;
-	  exp_jump_to_top_level (FORCE_EOF);
-	}
-      else
-	{
-	  if (vname != name)
-	    free (vname);
-	  last_command_exit_value = EX_BADUSAGE;
-	  exp_jump_to_top_level (DISCARD);
-	}
-    }
-
-  stupidly_hack_special_variables (vname);
-
-  /* "In all cases, the final value of parameter shall be substituted." */
-  if (shell_compatibility_level > 51)
-    {
-      FREE (t1);
-#if defined (ARRAY_VARS)
-      if (arrayref)
-	{
-	  t1 = newval;
-	  flush_eltstate (&es);
-	}
-      else
-        t1 = get_variable_value (v);
-#else
-      t1 = value_cell (v);
-#endif
-    }
-
-  if (vname != name)
-    free (vname);
-
-  /* From Posix group discussion Feb-March 2010.  Issue 7 0000221 */
-
-  /* If we are double-quoted or if we are not going to be performing word
-     splitting, we want to quote the value we return appropriately, like
-     the other expansions this function handles. */
-  w->word = (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) ? quote_string (t1) : quote_escapes (t1);
-  /* If we have something that's non-null, but not a quoted null string,
-     and we're not going to be performing word splitting (we know we're not
-     because the operator is `='), we can forget we saw a quoted null. */
-  if (w->word && w->word[0] && QUOTED_NULL (w->word) == 0)
-    w->flags &= ~W_SAWQUOTEDNULL;
-
-  /* If we convert a null string into a quoted null, make sure the caller
-     knows it. */
-  if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) && QUOTED_NULL (w->word))
-    w->flags |= W_HASQUOTEDNULL;
-
-  return w;
-}
-
-/* Deal with the right hand side of a ${name:?value} expansion in the case
-   that NAME is null or not set.  If VALUE is non-null it is expanded and
-   used as the error message to print, otherwise a standard message is
-   printed. */
-static void
-parameter_brace_expand_error (name, value, check_null)
-     char *name, *value;
-     int check_null;
-{
-  WORD_LIST *l;
-  char *temp;
-
-  set_exit_status (EXECUTION_FAILURE);	/* ensure it's non-zero */
-  if (value && *value)
-    {
-      l = expand_string (value, 0);
-      temp =  string_list (l);
-      report_error ("%s: %s", name, temp ? temp : "");	/* XXX was value not "" */
-      FREE (temp);
-      dispose_words (l);
-    }
-  else if (check_null == 0)
-    report_error (_("%s: parameter not set"), name);
-  else
-    report_error (_("%s: parameter null or not set"), name);
-
-  /* Free the data we have allocated during this expansion, since we
-     are about to longjmp out. */
-  free (name);
-  FREE (value);
-}
-
-/* Return 1 if NAME is something for which parameter_brace_expand_length is
-   OK to do. */
-static int
-valid_length_expression (name)
-     char *name;
-{
-  return (name[1] == '\0' ||					/* ${#} */
-	  ((sh_syntaxtab[(unsigned char) name[1]] & CSPECVAR) && name[2] == '\0') ||  /* special param */
-	  (DIGIT (name[1]) && all_digits (name + 1)) ||	/* ${#11} */
-#if defined (ARRAY_VARS)
-	  valid_array_reference (name + 1, 0) ||		/* ${#a[7]} */
-#endif
-	  legal_identifier (name + 1));				/* ${#PS1} */
-}
-
-/* Handle the parameter brace expansion that requires us to return the
-   length of a parameter. */
-static intmax_t
-parameter_brace_expand_length (name)
-     char *name;
-{
-  char *t, *newname;
-  intmax_t number, arg_index;
-  WORD_LIST *list;
-  SHELL_VAR *var;
-
-  var = (SHELL_VAR *)NULL;
-
-  if (name[1] == '\0')			/* ${#} */
-    number = number_of_args ();
-  else if (DOLLAR_AT_STAR (name[1]) && name[2] == '\0')	/* ${#@}, ${#*} */
-    number = number_of_args ();
-  else if ((sh_syntaxtab[(unsigned char) name[1]] & CSPECVAR) && name[2] == '\0')
-    {
-      /* Take the lengths of some of the shell's special parameters. */
-      switch (name[1])
-	{
-	case '-':
-	  t = which_set_flags ();
-	  break;
-	case '?':
-	  t = itos (last_command_exit_value);
-	  break;
-	case '$':
-	  t = itos (dollar_dollar_pid);
-	  break;
-	case '!':
-	  if (last_asynchronous_pid == NO_PID)
-	    t = (char *)NULL;	/* XXX - error if set -u set? */
-	  else
-	    t = itos (last_asynchronous_pid);
-	  break;
-	case '#':
-	  t = itos (number_of_args ());
-	  break;
-	}
-      number = STRLEN (t);
-      FREE (t);
-    }
-#if defined (ARRAY_VARS)
-  else if (valid_array_reference (name + 1, 0))
-    number = array_length_reference (name + 1);
-#endif /* ARRAY_VARS */
-  else
-    {
-      number = 0;
-
-      if (legal_number (name + 1, &arg_index))		/* ${#1} */
-	{
-	  t = get_dollar_var_value (arg_index);
-	  if (t == 0 && unbound_vars_is_error)
-	    return INTMAX_MIN;
-	  number = MB_STRLEN (t);
-	  FREE (t);
-	}
-#if defined (ARRAY_VARS)
-      else if ((var = find_variable (name + 1)) && (invisible_p (var) == 0) && (array_p (var) || assoc_p (var)))
-	{
-	  if (assoc_p (var))
-	    t = assoc_reference (assoc_cell (var), "0");
-	  else
-	    t = array_reference (array_cell (var), 0);
-	  if (t == 0 && unbound_vars_is_error)
-	    return INTMAX_MIN;
-	  number = MB_STRLEN (t);
-	}
-#endif
-      /* Fast path for the common case of taking the length of a non-dynamic
-	 scalar variable value. */
-      else if ((var || (var = find_variable (name + 1))) &&
-      		invisible_p (var) == 0 &&
-		array_p (var) == 0 && assoc_p (var) == 0 &&
-		var->dynamic_value == 0)
-	number = value_cell (var) ? MB_STRLEN (value_cell (var)) : 0;
-      else if (var == 0 && unbound_vars_is_error == 0)
-	number = 0;
-      else				/* ${#PS1} */
-	{
-	  newname = savestring (name);
-	  newname[0] = '$';
-	  list = expand_string (newname, Q_DOUBLE_QUOTES);
-	  t = list ? string_list (list) : (char *)NULL;
-	  free (newname);
-	  if (list)
-	    dispose_words (list);
-
-	  number = t ? MB_STRLEN (t) : 0;
-	  FREE (t);
-	}
-    }
-
-  return (number);
-}
-
-/* Skip characters in SUBSTR until DELIM.  SUBSTR is an arithmetic expression,
-   so we do some ad-hoc parsing of an arithmetic expression to find
-   the first DELIM, instead of using strchr(3).  Two rules:
-	1.  If the substring contains a `(', read until closing `)'.
-	2.  If the substring contains a `?', read past one `:' for each `?'.
-   The SD_ARITHEXP flag to skip_to_delim takes care of doing this.
-*/
-
-static char *
-skiparith (substr, delim)
-     char *substr;
-     int delim;
-{
-  int i;
-  char delims[2];
-
-  delims[0] = delim;
-  delims[1] = '\0';
-
-  i = skip_to_delim (substr, 0, delims, SD_ARITHEXP);
-  return (substr + i);
-}
-
-/* Verify and limit the start and end of the desired substring.  If
-   VTYPE == 0, a regular shell variable is being used; if it is 1,
-   then the positional parameters are being used; if it is 2, then
-   VALUE is really a pointer to an array variable that should be used.
-   Return value is 1 if both values were OK, 0 if there was a problem
-   with an invalid expression, or -1 if the values were out of range. */
-static int
-verify_substring_values (v, value, substr, vtype, e1p, e2p)
-     SHELL_VAR *v;
-     char *value, *substr;
-     int vtype;
-     intmax_t *e1p, *e2p;
-{
-  char *t, *temp1, *temp2;
-  arrayind_t len;
-  int expok, eflag;
-#if defined (ARRAY_VARS)
- ARRAY *a;
- HASH_TABLE *h;
-#endif
-
-  /* duplicate behavior of strchr(3) */
-  t = skiparith (substr, ':');
-  if (*t && *t == ':')
-    *t = '\0';
-  else
-    t = (char *)0;
-
-  temp1 = expand_arith_string (substr, Q_DOUBLE_QUOTES|Q_ARITH);
-  eflag = (shell_compatibility_level > 51) ? 0 : EXP_EXPANDED;
-
-  *e1p = evalexp (temp1, eflag, &expok);
-  free (temp1);
-  if (expok == 0)
-    return (0);
-
-  len = -1;	/* paranoia */
-  switch (vtype)
-    {
-    case VT_VARIABLE:
-    case VT_ARRAYMEMBER:
-      len = MB_STRLEN (value);
-      break;
-    case VT_POSPARMS:
-      len = number_of_args () + 1;
-      if (*e1p == 0)
-	len++;		/* add one arg if counting from $0 */
-      break;
-#if defined (ARRAY_VARS)
-    case VT_ARRAYVAR:
-      /* For arrays, the first value deals with array indices.  Negative
-	 offsets count from one past the array's maximum index.  Associative
-	 arrays treat the number of elements as the maximum index. */
-      if (assoc_p (v))
-	{
-	  h = assoc_cell (v);
-	  len = assoc_num_elements (h) + (*e1p < 0);
-	}
-      else
-	{
-	  a = (ARRAY *)value;
-	  len = array_max_index (a) + (*e1p < 0);	/* arrays index from 0 to n - 1 */
-	}
-      break;
-#endif
-    }
-
-  if (len == -1)	/* paranoia */
-    return -1;
-
-  if (*e1p < 0)		/* negative offsets count from end */
-    *e1p += len;
-
-  if (*e1p > len || *e1p < 0)
-    return (-1);
-
-#if defined (ARRAY_VARS)
-  /* For arrays, the second offset deals with the number of elements. */
-  if (vtype == VT_ARRAYVAR)
-    len = assoc_p (v) ? assoc_num_elements (h) : array_num_elements (a);
-#endif
-
-  if (t)
-    {
-      t++;
-      temp2 = savestring (t);
-      temp1 = expand_arith_string (temp2, Q_DOUBLE_QUOTES|Q_ARITH);
-      free (temp2);
-      t[-1] = ':';
-      *e2p = evalexp (temp1, eflag, &expok);
-      free (temp1);
-      if (expok == 0)
-	return (0);
-
-      /* Should we allow positional parameter length < 0 to count backwards
-	 from end of positional parameters? */
-#if 1
-      if ((vtype == VT_ARRAYVAR || vtype == VT_POSPARMS) && *e2p < 0)
-#else /* XXX - postponed; this isn't really a valuable feature */
-      if (vtype == VT_ARRAYVAR && *e2p < 0)
-#endif
-	{
-	  internal_error (_("%s: substring expression < 0"), t);
-	  return (0);
-	}
-#if defined (ARRAY_VARS)
-      /* In order to deal with sparse arrays, push the intelligence about how
-	 to deal with the number of elements desired down to the array-
-	 specific functions.  */
-      if (vtype != VT_ARRAYVAR)
-#endif
-	{
-	  if (*e2p < 0)
-	    {
-	      *e2p += len;
-	      if (*e2p < 0 || *e2p < *e1p)
-		{
-		  internal_error (_("%s: substring expression < 0"), t);
-		  return (0);
-		}
-	    }
-	  else
-	    *e2p += *e1p;		/* want E2 chars starting at E1 */
-	  if (*e2p > len)
-	    *e2p = len;
-	}
-    }
-  else
-    *e2p = len;
-
-  return (1);
-}
-
-/* Return the type of variable specified by VARNAME (simple variable,
-   positional param, or array variable).  Also return the value specified
-   by VARNAME (value of a variable or a reference to an array element).
-   QUOTED is the standard description of quoting state, using Q_* defines.
-   FLAGS is currently a set of flags to pass to array_value.  If IND is
-   not INTMAX_MIN, and FLAGS includes AV_USEIND, IND is
-   passed to array_value so the array index is not computed again.
-   If this returns VT_VARIABLE, the caller assumes that CTLESC and CTLNUL
-   characters in the value are quoted with CTLESC and takes appropriate
-   steps.  For convenience, *VALP is set to the dequoted VALUE. */
-static int
-get_var_and_type (varname, value, estatep, quoted, flags, varp, valp)
-     char *varname, *value;
-     array_eltstate_t *estatep;
-     int quoted, flags;
-     SHELL_VAR **varp;
-     char **valp;
-{
-  int vtype, want_indir;
-  char *temp, *vname;
-  SHELL_VAR *v;
-
-  want_indir = *varname == '!' &&
-    (legal_variable_starter ((unsigned char)varname[1]) || DIGIT (varname[1])
-					|| VALID_INDIR_PARAM (varname[1]));
-  if (want_indir)
-    vname = parameter_brace_find_indir (varname+1, SPECIAL_VAR (varname, 1), quoted, 1);
-    /* XXX - what if vname == 0 || *vname == 0 ? */
-  else
-    vname = varname;
-
-  if (vname == 0)
-    {
-      vtype = VT_VARIABLE;
-      *varp = (SHELL_VAR *)NULL;
-      *valp = (char *)NULL;
-      return (vtype);
-    }
-
-  /* This sets vtype to VT_VARIABLE or VT_POSPARMS */
-  vtype = STR_DOLLAR_AT_STAR (vname);
-  if (vtype == VT_POSPARMS && vname[0] == '*')
-    vtype |= VT_STARSUB;
-  *varp = (SHELL_VAR *)NULL;
-
-#if defined (ARRAY_VARS)
-  if (valid_array_reference (vname, 0))
-    {
-      v = array_variable_part (vname, 0, &temp, (int *)0);
-      /* If we want to signal array_value to use an already-computed index,
-	 the caller will set ESTATEP->IND to that index and pass AV_USEIND in
-	 FLAGS. */
-      if (estatep && (flags & AV_USEIND) == 0)
-	estatep->ind = INTMAX_MIN;
-
-      if (v && invisible_p (v))
-	{
-	  vtype = VT_ARRAYMEMBER;
-	  *varp = (SHELL_VAR *)NULL;
-	  *valp = (char *)NULL;
-	}
-      if (v && (array_p (v) || assoc_p (v)))
-	{
-	  if (ALL_ELEMENT_SUB (temp[0]) && temp[1] == RBRACK)
-	    {
-	      /* Callers have to differentiate between indexed and associative */
-	      vtype = VT_ARRAYVAR;
-	      if (temp[0] == '*')
-		vtype |= VT_STARSUB;
-	      *valp = array_p (v) ? (char *)array_cell (v) : (char *)assoc_cell (v);
-	    }
-	  else
-	    {
-	      vtype = VT_ARRAYMEMBER;
-	      *valp = array_value (vname, Q_DOUBLE_QUOTES, flags, estatep);
-	    }
-	  *varp = v;
-	}
-      else if (v && (ALL_ELEMENT_SUB (temp[0]) && temp[1] == RBRACK))
-	{
-	  vtype = VT_VARIABLE;
-	  *varp = v;
-	  if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
-	    *valp = value ? dequote_string (value) : (char *)NULL;
-	  else
-	    *valp = value ? dequote_escapes (value) : (char *)NULL;
-	}
-      else
-	{
-	  vtype = VT_ARRAYMEMBER;
-	  *varp = v;
-	  *valp = array_value (vname, Q_DOUBLE_QUOTES, flags, estatep);
-	}
-    }
-  else if ((v = find_variable (vname)) && (invisible_p (v) == 0) && (assoc_p (v) || array_p (v)))
-    {
-      vtype = VT_ARRAYMEMBER;
-      *varp = v;
-      *valp = assoc_p (v) ? assoc_reference (assoc_cell (v), "0") : array_reference (array_cell (v), 0);
-    }
-  else
-#endif
-    {
-      if (value && vtype == VT_VARIABLE)
-	{
-	  *varp = find_variable (vname);
-	  if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
-	    *valp = dequote_string (value);
-	  else
-	    *valp = dequote_escapes (value);
-	}
-      else
-	*valp = value;
-    }
-
-  if (want_indir)
-    free (vname);
-
-  return vtype;
-}
-
-/***********************************************************/
-/*						           */
-/* Functions to perform transformations on variable values */
-/*						           */
-/***********************************************************/
-
-static char *
-string_var_assignment (v, s)
-     SHELL_VAR *v;
-     char *s;
-{
-  char flags[MAX_ATTRIBUTES], *ret, *val;
-  int i;
-
-  val = (v && (invisible_p (v) || var_isset (v) == 0)) ? (char *)NULL : sh_quote_reusable (s, 0);
-  i = var_attribute_string (v, 0, flags);
-  if (i == 0 && val == 0)
-    return (char *)NULL;
-
-  ret = (char *)xmalloc (i + STRLEN (val) + strlen (v->name) + 16 + MAX_ATTRIBUTES);
-  if (i > 0 && val == 0)
-    sprintf (ret, "declare -%s %s", flags, v->name);
-  else if (i > 0)
-    sprintf (ret, "declare -%s %s=%s", flags, v->name, val);
-  else
-    sprintf (ret, "%s=%s", v->name, val);
-  free (val);
-  return ret;
-}
-
-#if defined (ARRAY_VARS)
-static char *
-array_var_assignment (v, itype, quoted, atype)
-     SHELL_VAR *v;
-     int itype, quoted, atype;
-{
-  char *ret, *val, flags[MAX_ATTRIBUTES];
-  int i;
-
-  if (v == 0)
-    return (char *)NULL;
-  if (atype == 2)
-    val = array_p (v) ? array_to_kvpair (array_cell (v), 0)
-		      : assoc_to_kvpair (assoc_cell (v), 0);
-  else
-    val = array_p (v) ? array_to_assign (array_cell (v), 0)
-		      : assoc_to_assign (assoc_cell (v), 0);
-
-  if (val == 0 && (invisible_p (v) || var_isset (v) == 0))
-    ;	/* placeholder */
-  else if (val == 0)
-    {
-      val = (char *)xmalloc (3);
-      val[0] = LPAREN;
-      val[1] = RPAREN;
-      val[2] = 0;
-    }
-  else
-    {
-      ret = (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) ? quote_string (val) : quote_escapes (val);
-      free (val);
-      val = ret;
-    }
-
-  if (atype == 2)
-    return val;
-
-  i = var_attribute_string (v, 0, flags);
-  ret = (char *)xmalloc (i + STRLEN (val) + strlen (v->name) + 16);
-  if (val)
-    sprintf (ret, "declare -%s %s=%s", flags, v->name, val);
-  else
-    sprintf (ret, "declare -%s %s", flags, v->name);
-  free (val);
-  return ret;
-}
-#endif
-
-static char *
-pos_params_assignment (list, itype, quoted)
-     WORD_LIST *list;
-     int itype;
-     int quoted;
-{
-  char *temp, *ret;
-
-  /* first, we transform the list to quote each word. */
-  temp = list_transform ('Q', (SHELL_VAR *)0, list, itype, quoted);
-  ret = (char *)xmalloc (strlen (temp) + 8);
-  strcpy (ret, "set -- ");
-  strcpy (ret + 7, temp);
-  free (temp);
-  return ret;
-}
-
-static char *
-string_transform (xc, v, s)
-     int xc;
-     SHELL_VAR *v;
-     char *s;
-{
-  char *ret, flags[MAX_ATTRIBUTES], *t;
-  int i;
-
-  if (((xc == 'A' || xc == 'a') && v == 0))
-    return (char *)NULL;
-  else if (xc != 'a' && xc != 'A' && s == 0)
-    return (char *)NULL;
-
-  switch (xc)
-    {
-      /* Transformations that interrogate the variable */
-      case 'a':
-	i = var_attribute_string (v, 0, flags);
-	ret = (i > 0) ? savestring (flags) : (char *)NULL;
-	break;
-      case 'A':
-	ret = string_var_assignment (v, s);
-	break;
-      case 'K':
-      case 'k':
-	ret = sh_quote_reusable (s, 0);
-	break;
-      /* Transformations that modify the variable's value */
-      case 'E':
-	t = ansiexpand (s, 0, strlen (s), (int *)0);
-	ret = dequote_escapes (t);
-	free (t);
-	break;
-      case 'P':
-	ret = decode_prompt_string (s);
-	break;
-      case 'Q':
-	ret = sh_quote_reusable (s, 0);
-	break;
-      case 'U':
-	ret = sh_modcase (s, 0, CASE_UPPER);
-	break;
-      case 'u':
-	ret = sh_modcase (s, 0, CASE_UPFIRST);	/* capitalize */
- 	break;
-      case 'L':
- 	ret = sh_modcase (s, 0, CASE_LOWER);
- 	break;
-      default:
-	ret = (char *)NULL;
-	break;
-    }
-  return ret;
-}
-
-static char *
-list_transform (xc, v, list, itype, quoted)
-     int xc;
-     SHELL_VAR *v;
-     WORD_LIST *list;
-     int itype, quoted;
-{
-  WORD_LIST *new, *l;
-  WORD_DESC *w;
-  char *tword;
-  int qflags;
-
-  for (new = (WORD_LIST *)NULL, l = list; l; l = l->next)
-    {
-      tword = string_transform (xc, v, l->word->word);
-      w = alloc_word_desc ();
-      w->word = tword ? tword : savestring ("");	/* XXX */
-      new = make_word_list (w, new);
-    }
-  l = REVERSE_LIST (new, WORD_LIST *);
-
-  qflags = quoted;
-  /* If we are expanding in a context where word splitting will not be
-     performed, treat as quoted.  This changes how $* will be expanded. */
-  if (itype == '*' && expand_no_split_dollar_star && ifs_is_null)
-    qflags |= Q_DOUBLE_QUOTES;		/* Posix interp 888 */
-
-  tword = string_list_pos_params (itype, l, qflags, 0);
-  dispose_words (l);
-
-  return (tword);
-}
-
-static char *
-parameter_list_transform (xc, itype, quoted)
-     int xc;
-     int itype;
-     int quoted;
-{
-  char *ret;
-  WORD_LIST *list;
-
-  list = list_rest_of_args ();
-  if (list == 0)
-    return ((char *)NULL);
-  if (xc == 'A')
-    ret = pos_params_assignment (list, itype, quoted);
-  else
-    ret = list_transform (xc, (SHELL_VAR *)0, list, itype, quoted);
-  dispose_words (list);
-  return (ret);
-}
-
-#if defined (ARRAY_VARS)
-static char *
-array_transform (xc, var, starsub, quoted)
-     int xc;
-     SHELL_VAR *var;
-     int starsub;	/* so we can figure out how it's indexed */
-     int quoted;
-{
-  ARRAY *a;
-  HASH_TABLE *h;
-  int itype, qflags;
-  char *ret;
-  WORD_LIST *list;
-  SHELL_VAR *v;
-
-  v = var;	/* XXX - for now */
-
-  itype = starsub ? '*' : '@';
-
-  if (xc == 'A')
-    return (array_var_assignment (v, itype, quoted, 1));
-  else if (xc == 'K')
-    return (array_var_assignment (v, itype, quoted, 2));
-
-  /* special case for unset arrays and attributes */
-  if (xc == 'a' && (invisible_p (v) || var_isset (v) == 0))
-    {
-      char flags[MAX_ATTRIBUTES];
-      int i;
-
-      i = var_attribute_string (v, 0, flags);
-      return ((i > 0) ? savestring (flags) : (char *)NULL);
-    }
-
-  a = (v && array_p (v)) ? array_cell (v) : 0;
-  h = (v && assoc_p (v)) ? assoc_cell (v) : 0;
-
-  /* XXX - for now */
-  if (xc == 'k')
-    {
-      if (v == 0)
-	return ((char *)NULL);
-      list = array_p (v) ? array_to_kvpair_list (a) : assoc_to_kvpair_list (h);
-      qflags = quoted;
-      /* If we are expanding in a context where word splitting will not be
-	 performed, treat as quoted.  This changes how $* will be expanded. */
-      if (itype == '*' && expand_no_split_dollar_star && ifs_is_null)
-	qflags |= Q_DOUBLE_QUOTES;		/* Posix interp 888 */
-
-      ret = string_list_pos_params (itype, list, qflags, 0);
-      dispose_words (list);
-      return ret;
-    }
-
-  list = a ? array_to_word_list (a) : (h ? assoc_to_word_list (h) : 0);
-  if (list == 0)
-   return ((char *)NULL);
-  ret = list_transform (xc, v, list, itype, quoted);
-  dispose_words (list);
-
-  return ret;
-}
-#endif /* ARRAY_VARS */
-
-static int
-valid_parameter_transform (xform)
-     char *xform;
-{
-  if (xform[1])
-    return 0;
-
-  /* check for valid values of xform[0] */
-  switch (xform[0])
-    {
-    case 'a':		/* expand to a string with just attributes */
-    case 'A':		/* expand as an assignment statement with attributes */
-    case 'K':		/* expand assoc array to list of key/value pairs */
-    case 'k':		/* XXX - for now */
-    case 'E':		/* expand like $'...' */
-    case 'P':		/* expand like prompt string */
-    case 'Q':		/* quote reusably */
-    case 'U':		/* transform to uppercase */
-    case 'u':		/* transform by capitalizing */
-    case 'L':		/* transform to lowercase */
-      return 1;
-    default:
-      return 0;
-    }
-}
-      
-static char *
-parameter_brace_transform (varname, value, estatep, xform, rtype, quoted, pflags, flags)
-     char *varname, *value;
-     array_eltstate_t *estatep;
-     char *xform;
-     int rtype, quoted, pflags, flags;
-{
-  int vtype, xc, starsub;
-  char *temp1, *val, *oname;
-  SHELL_VAR *v;
-
-  xc = xform[0];
-  if (value == 0 && xc != 'A' && xc != 'a')
-    return ((char *)NULL);
-
-  oname = this_command_name;
-  this_command_name = varname;
-
-  vtype = get_var_and_type (varname, value, estatep, quoted, flags, &v, &val);
-  if (vtype == -1)
-    {
-      this_command_name = oname;
-      return ((char *)NULL);
-    }
-
-  if (xform[0] == 0 || valid_parameter_transform (xform) == 0)
-    {
-      this_command_name = oname;
-      if (vtype == VT_VARIABLE)
-	FREE (val);
-      return (interactive_shell ? &expand_param_error : &expand_param_fatal);
-    }
-
-  starsub = vtype & VT_STARSUB;
-  vtype &= ~VT_STARSUB;
-
-  /* If we are asked to display the attributes of an unset variable, V will
-     be NULL after the call to get_var_and_type. Double-check here. */
-  if ((xc == 'a' || xc == 'A') && vtype == VT_VARIABLE && varname && v == 0)
-    v = find_variable (varname);
-
-  temp1 = (char *)NULL;		/* shut up gcc */
-  switch (vtype)
-    {
-    case VT_VARIABLE:
-    case VT_ARRAYMEMBER:
-      temp1 = string_transform (xc, v, val);
-      if (vtype == VT_VARIABLE)
-	FREE (val);
-      if (temp1)
-	{
-	  val = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-			? quote_string (temp1)
-			: quote_escapes (temp1);
-	  free (temp1);
-	  temp1 = val;
-	}
-      break;
-#if defined (ARRAY_VARS)
-    case VT_ARRAYVAR:
-      temp1 = array_transform (xc, v, starsub, quoted);
-      if (temp1 && quoted == 0 && ifs_is_null)
-	{
-		/* Posix interp 888 */
-	}
-      else if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
-	{
-	  val = quote_escapes (temp1);
-	  free (temp1);
-	  temp1 = val;
-	}
-      break;
-#endif
-    case VT_POSPARMS:
-      temp1 = parameter_list_transform (xc, varname[0], quoted);
-      if (temp1 && quoted == 0 && ifs_is_null)
-	{
-		/* Posix interp 888 */
-	}
-      else if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
-	{
-	  val = quote_escapes (temp1);
-	  free (temp1);
-	  temp1 = val;
-	}
-      break;
-    }
-
-  this_command_name = oname;
-  return temp1;
-}
-
-/******************************************************/
-/*						      */
-/* Functions to extract substrings of variable values */
-/*						      */
-/******************************************************/
-
-#if defined (HANDLE_MULTIBYTE)
-/* Character-oriented rather than strictly byte-oriented substrings.  S and
-   E, rather being strict indices into STRING, indicate character (possibly
-   multibyte character) positions that require calculation.
-   Used by the ${param:offset[:length]} expansion. */
-static char *
-mb_substring (string, s, e)
-     char *string;
-     int s, e;
-{
-  char *tt;
-  int start, stop, i;
-  size_t slen;
-  DECLARE_MBSTATE;
-
-  start = 0;
-  /* Don't need string length in ADVANCE_CHAR unless multibyte chars possible. */
-  slen = (MB_CUR_MAX > 1) ? STRLEN (string) : 0;
-
-  i = s;
-  while (string[start] && i--)
-    ADVANCE_CHAR (string, slen, start);
-  stop = start;
-  i = e - s;
-  while (string[stop] && i--)
-    ADVANCE_CHAR (string, slen, stop);
-  tt = substring (string, start, stop);
-  return tt;
-}
-#endif
-  
-/* Process a variable substring expansion: ${name:e1[:e2]}.  If VARNAME
-   is `@', use the positional parameters; otherwise, use the value of
-   VARNAME.  If VARNAME is an array variable, use the array elements. */
-
-static char *
-parameter_brace_substring (varname, value, estatep, substr, quoted, pflags, flags)
-     char *varname, *value;
-     array_eltstate_t *estatep;
-     char *substr;
-     int quoted, pflags, flags;
-{
-  intmax_t e1, e2;
-  int vtype, r, starsub;
-  char *temp, *val, *tt, *oname;
-  SHELL_VAR *v;
-
-  if (value == 0 && ((varname[0] != '@' && varname[0] != '*') || varname[1]))
-    return ((char *)NULL);
-
-  oname = this_command_name;
-  this_command_name = varname;
-
-  vtype = get_var_and_type (varname, value, estatep, quoted, flags, &v, &val);
-  if (vtype == -1)
-    {
-      this_command_name = oname;
-      return ((char *)NULL);
-    }
-
-  starsub = vtype & VT_STARSUB;
-  vtype &= ~VT_STARSUB;
-
-  r = verify_substring_values (v, val, substr, vtype, &e1, &e2);
-  this_command_name = oname;
-  if (r <= 0)
-    {
-      if (vtype == VT_VARIABLE)
-	FREE (val);
-      return ((r == 0) ? &expand_param_error : (char *)NULL);
-    }
-
-  switch (vtype)
-    {
-    case VT_VARIABLE:
-    case VT_ARRAYMEMBER:
-#if defined (HANDLE_MULTIBYTE)
-      if (MB_CUR_MAX > 1)
-	tt = mb_substring (val, e1, e2);
-      else
-#endif
-      tt = substring (val, e1, e2);
-
-      if (vtype == VT_VARIABLE)
-	FREE (val);
-      if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
-	temp = quote_string (tt);
-      else
-	temp = tt ? quote_escapes (tt) : (char *)NULL;
-      FREE (tt);
-      break;
-    case VT_POSPARMS:
-    case VT_ARRAYVAR:
-      if (vtype == VT_POSPARMS)
-	tt = pos_params (varname, e1, e2, quoted, pflags);
-#if defined (ARRAY_VARS)
-        /* assoc_subrange and array_subrange both call string_list_pos_params,
-	   so we can treat this case just like VT_POSPARAMS. */
-      else if (assoc_p (v))
-	/* we convert to list and take first e2 elements starting at e1th
-	   element -- officially undefined for now */	
-	tt = assoc_subrange (assoc_cell (v), e1, e2, starsub, quoted, pflags);
-      else
-	/* We want E2 to be the number of elements desired (arrays can be
-	   sparse, so verify_substring_values just returns the numbers
-	   specified and we rely on array_subrange to understand how to
-	   deal with them). */
-	tt = array_subrange (array_cell (v), e1, e2, starsub, quoted, pflags);
-#endif
-      /* We want to leave this alone in every case where pos_params/
-	 string_list_pos_params quotes the list members */
-      if (tt && quoted == 0 && ifs_is_null)
-	{
-	  temp = tt;	/* Posix interp 888 */
-	}
-      else if (tt && quoted == 0 && (pflags & PF_ASSIGNRHS))
-	{
-	  temp = tt;	/* Posix interp 888 */
-	}
-      else if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) == 0)
-	{
-	  temp = tt ? quote_escapes (tt) : (char *)NULL;
-	  FREE (tt);
-	}
-      else
-	temp = tt;
-      break;
-
-    default:
-      temp = (char *)NULL;
-    }
-
-  return temp;
-}
-
-/****************************************************************/
-/*								*/
-/* Functions to perform pattern substitution on variable values */
-/*								*/
-/****************************************************************/
-
-static int
-shouldexp_replacement (s)
-     char *s;
-{
-  size_t slen;
-  int sindex, c;
-  DECLARE_MBSTATE;
-
-  sindex = 0;
-  slen = STRLEN (s);
-  while (c = s[sindex])
-    {
-      if (c == '\\')
-	{
-	  sindex++;
-	  if (s[sindex] == 0)
-	    return 0;
-	  /* We want to remove this backslash because we treat it as special
-	     in this context. THIS ASSUMES THE STRING IS PROCESSED BY
-	     strcreplace() OR EQUIVALENT that handles removing backslashes
-	     preceding the special character. */
-	  if (s[sindex] == '&')
-	    return 1;
-	  if (s[sindex] == '\\')
-	    return 1;
-	}
-      else if (c == '&')
-	return 1;
-      ADVANCE_CHAR (s, slen, sindex);
-    }
-  return 0;
-}
-
-char *
-pat_subst (string, pat, rep, mflags)
-     char *string, *pat, *rep;
-     int mflags;
-{
-  char *ret, *s, *e, *str, *rstr, *mstr, *send;
-  int rptr, mtype, rxpand, mlen;
-  size_t rsize, l, replen, rslen;
-  DECLARE_MBSTATE;
-
-  if (string == 0)
-    return (savestring (""));
-
-  mtype = mflags & MATCH_TYPEMASK;
-  rxpand = mflags & MATCH_EXPREP;
-
-  /* Special cases:
-   * 	1.  A null pattern with mtype == MATCH_BEG means to prefix STRING
-   *	    with REP and return the result.
-   *	2.  A null pattern with mtype == MATCH_END means to append REP to
-   *	    STRING and return the result.
-   *	3.  A null STRING with a matching pattern means to append REP to
-   *	    STRING and return the result.
-   *
-   * These process `&' in the replacement string, like `sed' does when
-   * presented with a BRE of `^' or `$'.
-   */
-  if ((pat == 0 || *pat == 0) && (mtype == MATCH_BEG || mtype == MATCH_END))
-    {
-      rstr = (mflags & MATCH_EXPREP) ? strcreplace (rep, '&', "", 2) : rep;
-      rslen = STRLEN (rstr);
-      l = STRLEN (string);
-      ret = (char *)xmalloc (rslen + l + 2);
-      if (rslen == 0)
-	strcpy (ret, string);
-      else if (mtype == MATCH_BEG)
-	{
-	  strcpy (ret, rstr);
-	  strcpy (ret + rslen, string);
-	}
-      else
-	{
-	  strcpy (ret, string);
-	  strcpy (ret + l, rstr);
-	}
-      if (rstr != rep)
-	free (rstr);
-      return (ret);
-    }
-  else if (*string == 0 && (match_pattern (string, pat, mtype, &s, &e) != 0))
-    return ((mflags & MATCH_EXPREP) ? strcreplace (rep, '&', "", 2) : savestring (rep));
-
-  ret = (char *)xmalloc (rsize = 64);
-  ret[0] = '\0';
-  send = string + strlen (string);
-
-  for (replen = STRLEN (rep), rptr = 0, str = string; *str;)
-    {
-      if (match_pattern (str, pat, mtype, &s, &e) == 0)
-	break;
-      l = s - str;
-
-      if (rep && rxpand)
-        {
-	  int x;
-	  mlen = e - s;
-	  mstr = xmalloc (mlen + 1);
-	  for (x = 0; x < mlen; x++)
-	    mstr[x] = s[x];
-	  mstr[mlen] = '\0';
-	  rstr = strcreplace (rep, '&', mstr, 2);
-	  free (mstr);
-	  rslen = strlen (rstr);
-        }
-      else
-	{
-	  rstr = rep;
-	  rslen = replen;
-	}
-        
-      RESIZE_MALLOCED_BUFFER (ret, rptr, (l + rslen), rsize, 64);
-
-      /* OK, now copy the leading unmatched portion of the string (from
-	 str to s) to ret starting at rptr (the current offset).  Then copy
-	 the replacement string at ret + rptr + (s - str).  Increment
-	 rptr (if necessary) and str and go on. */
-      if (l)
-	{
-	  strncpy (ret + rptr, str, l);
-	  rptr += l;
-	}
-      if (replen)
-	{
-	  strncpy (ret + rptr, rstr, rslen);
-	  rptr += rslen;
-	}
-      str = e;		/* e == end of match */
-
-      if (rstr != rep)
-	free (rstr);
-
-      if (((mflags & MATCH_GLOBREP) == 0) || mtype != MATCH_ANY)
-	break;
-
-      if (s == e)
-	{
-	  /* On a zero-length match, make sure we copy one character, since
-	     we increment one character to avoid infinite recursion. */
-	  char *p, *origp, *origs;
-	  size_t clen;
-
-	  RESIZE_MALLOCED_BUFFER (ret, rptr, locale_mb_cur_max, rsize, 64);
-#if defined (HANDLE_MULTIBYTE)
-	  p = origp = ret + rptr;
-	  origs = str;
-	  COPY_CHAR_P (p, str, send);
-	  rptr += p - origp;
-	  e += str - origs;
-#else
-	  ret[rptr++] = *str++;
-	  e++;		/* avoid infinite recursion on zero-length match */
-#endif
-	}
-    }
-
-  /* Now copy the unmatched portion of the input string */
-  if (str && *str)
-    {
-      l = send - str + 1;
-      RESIZE_MALLOCED_BUFFER (ret, rptr, l, rsize, 64);
-      strcpy (ret + rptr, str);
-    }
-  else
-    ret[rptr] = '\0';
-
-  return ret;
-}
-
-/* Do pattern match and replacement on the positional parameters. */
-static char *
-pos_params_pat_subst (string, pat, rep, mflags)
-     char *string, *pat, *rep;
-     int mflags;
-{
-  WORD_LIST *save, *params;
-  WORD_DESC *w;
-  char *ret;
-  int pchar, qflags, pflags;
-
-  save = params = list_rest_of_args ();
-  if (save == 0)
-    return ((char *)NULL);
-
-  for ( ; params; params = params->next)
-    {
-      ret = pat_subst (params->word->word, pat, rep, mflags);
-      w = alloc_word_desc ();
-      w->word = ret ? ret : savestring ("");
-      dispose_word (params->word);
-      params->word = w;
-    }
-
-  pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';
-  qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;
-  pflags = (mflags & MATCH_ASSIGNRHS) == MATCH_ASSIGNRHS ? PF_ASSIGNRHS : 0;
-
-  /* If we are expanding in a context where word splitting will not be
-     performed, treat as quoted. This changes how $* will be expanded. */
-  if (pchar == '*' && (mflags & MATCH_ASSIGNRHS) && expand_no_split_dollar_star && ifs_is_null)
-    qflags |= Q_DOUBLE_QUOTES;		/* Posix interp 888 */
-
-  ret = string_list_pos_params (pchar, save, qflags, pflags);
-  dispose_words (save);
-
-  return (ret);
-}
-
-/* Perform pattern substitution on VALUE, which is the expansion of
-   VARNAME.  PATSUB is an expression supplying the pattern to match
-   and the string to substitute.  QUOTED is a flags word containing
-   the type of quoting currently in effect. */
-static char *
-parameter_brace_patsub (varname, value, estatep, patsub, quoted, pflags, flags)
-     char *varname, *value;
-     array_eltstate_t *estatep;
-     char *patsub;
-     int quoted, pflags, flags;
-{
-  int vtype, mflags, starsub, delim;
-  char *val, *temp, *pat, *rep, *p, *lpatsub, *tt, *oname;
-  SHELL_VAR *v;
-
-  if (value == 0)
-    return ((char *)NULL);
-
-  oname = this_command_name;
-  this_command_name = varname;		/* error messages */
-
-  vtype = get_var_and_type (varname, value, estatep, quoted, flags, &v, &val);
-  if (vtype == -1)
-    {
-      this_command_name = oname;
-      return ((char *)NULL);
-    }
-
-  starsub = vtype & VT_STARSUB;
-  vtype &= ~VT_STARSUB;
-
-  mflags = 0;
-  /* PATSUB is never NULL when this is called. */
-  if (*patsub == '/')
-    {
-      mflags |= MATCH_GLOBREP;
-      patsub++;
-    }
-
-  /* Malloc this because expand_string_if_necessary or one of the expansion
-     functions in its call chain may free it on a substitution error. */
-  lpatsub = savestring (patsub);
-
-  if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-    mflags |= MATCH_QUOTED;
-
-  if (starsub)
-    mflags |= MATCH_STARSUB;
-
-  if (pflags & PF_ASSIGNRHS)
-    mflags |= MATCH_ASSIGNRHS;
-
-  /* If the pattern starts with a `/', make sure we skip over it when looking
-     for the replacement delimiter. */
-  delim = skip_to_delim (lpatsub, ((*patsub == '/') ? 1 : 0), "/", 0);
-  if (lpatsub[delim] == '/')
-    {
-      lpatsub[delim] = 0;
-      rep = lpatsub + delim + 1;
-    }
-  else
-    rep = (char *)NULL;
-
-  if (rep && *rep == '\0')
-    rep = (char *)NULL;
-
-  /* Perform the same expansions on the pattern as performed by the
-     pattern removal expansions. */
-  pat = getpattern (lpatsub, quoted, 1);
-
-  if (rep)
-    {
-      /* We want to perform quote removal on the expanded replacement even if
-	 the entire expansion is double-quoted because the parser and string
-	 extraction functions treated quotes in the replacement string as
-	 special.  THIS IS NOT BACKWARDS COMPATIBLE WITH BASH-4.2. */
-      if (shell_compatibility_level > 42 && patsub_replacement == 0)
-	rep = expand_string_if_necessary (rep, quoted & ~(Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT), expand_string_unsplit);
-      else if (shell_compatibility_level > 42 && patsub_replacement)
-	rep = expand_string_for_patsub (rep, quoted & ~(Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT));
-      /* This is the bash-4.2 code. */      
-      else if ((mflags & MATCH_QUOTED) == 0)
-	rep = expand_string_if_necessary (rep, quoted, expand_string_unsplit);
-      else
-	rep = expand_string_to_string_internal (rep, quoted, expand_string_unsplit);
-
-      /* Check whether or not to replace `&' in the replacement string after
-	 expanding it, since we want to treat backslashes quoting the `&'
-	 consistently. */
-      if (patsub_replacement && rep && *rep && shouldexp_replacement (rep))
-	mflags |= MATCH_EXPREP;
-
-    }
-
-  /* ksh93 doesn't allow the match specifier to be a part of the expanded
-     pattern.  This is an extension.  Make sure we don't anchor the pattern
-     at the beginning or end of the string if we're doing global replacement,
-     though. */
-  p = pat;
-  if (mflags & MATCH_GLOBREP)
-    mflags |= MATCH_ANY;
-  else if (pat && pat[0] == '#')
-    {
-      mflags |= MATCH_BEG;
-      p++;
-    }
-  else if (pat && pat[0] == '%')
-    {
-      mflags |= MATCH_END;
-      p++;
-    }
-  else
-    mflags |= MATCH_ANY;
-
-  /* OK, we now want to substitute REP for PAT in VAL.  If
-     flags & MATCH_GLOBREP is non-zero, the substitution is done
-     everywhere, otherwise only the first occurrence of PAT is
-     replaced.  The pattern matching code doesn't understand
-     CTLESC quoting CTLESC and CTLNUL so we use the dequoted variable
-     values passed in (VT_VARIABLE) so the pattern substitution
-     code works right.  We need to requote special chars after
-     we're done for VT_VARIABLE and VT_ARRAYMEMBER, and for the
-     other cases if QUOTED == 0, since the posparams and arrays
-     indexed by * or @ do special things when QUOTED != 0. */
-
-  switch (vtype)
-    {
-    case VT_VARIABLE:
-    case VT_ARRAYMEMBER:
-      temp = pat_subst (val, p, rep, mflags);
-      if (vtype == VT_VARIABLE)
-	FREE (val);
-      if (temp)
-	{
-	  tt = (mflags & MATCH_QUOTED) ? quote_string (temp) : quote_escapes (temp);
-	  free (temp);
-	  temp = tt;
-	}
-      break;
-    case VT_POSPARMS:
-      /* This does the right thing for the case where we are not performing
-	 word splitting. MATCH_STARSUB restricts it to ${* /foo/bar}, and
-	 pos_params_pat_subst/string_list_pos_params will do the right thing
-	 in turn for the case where ifs_is_null. Posix interp 888 */
-      if ((pflags & PF_NOSPLIT2) && (mflags & MATCH_STARSUB))
-        mflags |= MATCH_ASSIGNRHS;
-      temp = pos_params_pat_subst (val, p, rep, mflags);
-      if (temp && quoted == 0 && ifs_is_null)
-	{
-	  /* Posix interp 888 */
-	}
-      else if (temp && quoted == 0 && (pflags & PF_ASSIGNRHS))
-	{
-	  /* Posix interp 888 */
-	}
-      else if (temp && (mflags & MATCH_QUOTED) == 0)
-	{
-	  tt = quote_escapes (temp);
-	  free (temp);
-	  temp = tt;
-	}
-      break;
-#if defined (ARRAY_VARS)
-    case VT_ARRAYVAR:
-      /* If we are expanding in a context where word splitting will not be
-	 performed, treat as quoted.  This changes how ${A[*]} will be
-	 expanded to make it identical to $*. */
-      if ((mflags & MATCH_STARSUB) && (mflags & MATCH_ASSIGNRHS) && ifs_is_null)
-	mflags |= MATCH_QUOTED;		/* Posix interp 888 */
-
-      /* these eventually call string_list_pos_params */
-      if (assoc_p (v))
-	temp = assoc_patsub (assoc_cell (v), p, rep, mflags);
-      else
-	temp = array_patsub (array_cell (v), p, rep, mflags);
-
-      if (temp && quoted == 0 && ifs_is_null)
-	{
-	  /* Posix interp 888 */
-	}
-      else if (temp && (mflags & MATCH_QUOTED) == 0)
-	{
-	  tt = quote_escapes (temp);
-	  free (temp);
-	  temp = tt;
-	}
-      break;
-#endif
-    }
-
-  FREE (pat);
-  FREE (rep);
-  free (lpatsub);
-
-  this_command_name = oname;
-
-  return temp;
-}
-
-/****************************************************************/
-/*								*/
-/*   Functions to perform case modification on variable values  */
-/*								*/
-/****************************************************************/
-
-/* Do case modification on the positional parameters. */
-
-static char *
-pos_params_modcase (string, pat, modop, mflags)
-     char *string, *pat;
-     int modop;
-     int mflags;
-{
-  WORD_LIST *save, *params;
-  WORD_DESC *w;
-  char *ret;
-  int pchar, qflags, pflags;
-
-  save = params = list_rest_of_args ();
-  if (save == 0)
-    return ((char *)NULL);
-
-  for ( ; params; params = params->next)
-    {
-      ret = sh_modcase (params->word->word, pat, modop);
-      w = alloc_word_desc ();
-      w->word = ret ? ret : savestring ("");
-      dispose_word (params->word);
-      params->word = w;
-    }
-
-  pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';
-  qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;
-  pflags = (mflags & MATCH_ASSIGNRHS) == MATCH_ASSIGNRHS ? PF_ASSIGNRHS : 0;
-
-  /* If we are expanding in a context where word splitting will not be
-     performed, treat as quoted.  This changes how $* will be expanded. */
-  if (pchar == '*' && (mflags & MATCH_ASSIGNRHS) && ifs_is_null)
-    qflags |= Q_DOUBLE_QUOTES;		/* Posix interp 888 */
-
-  ret = string_list_pos_params (pchar, save, qflags, pflags);
-  dispose_words (save);
-
-  return (ret);
-}
-
-/* Perform case modification on VALUE, which is the expansion of
-   VARNAME.  MODSPEC is an expression supplying the type of modification
-   to perform.  QUOTED is a flags word containing the type of quoting
-   currently in effect. */
-static char *
-parameter_brace_casemod (varname, value, estatep, modspec, patspec, quoted, pflags, flags)
-     char *varname, *value;
-     array_eltstate_t *estatep;
-     int modspec;
-     char *patspec;
-     int quoted, pflags, flags;
-{
-  int vtype, starsub, modop, mflags, x;
-  char *val, *temp, *pat, *p, *lpat, *tt, *oname;
-  SHELL_VAR *v;
-
-  if (value == 0)
-    return ((char *)NULL);
-
-  oname = this_command_name;
-  this_command_name = varname;
-
-  vtype = get_var_and_type (varname, value, estatep, quoted, flags, &v, &val);
-  if (vtype == -1)
-    {
-      this_command_name = oname;
-      return ((char *)NULL);
-    }
-
-  starsub = vtype & VT_STARSUB;
-  vtype &= ~VT_STARSUB;
-
-  modop = 0;
-  mflags = 0;
-  if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-    mflags |= MATCH_QUOTED;
-  if (starsub)
-    mflags |= MATCH_STARSUB;
-  if (pflags & PF_ASSIGNRHS)
-    mflags |= MATCH_ASSIGNRHS;
-  
-  p = patspec;
-  if (modspec == '^')
-    {
-      x = p && p[0] == modspec;
-      modop = x ? CASE_UPPER : CASE_UPFIRST;
-      p += x;
-    }
-  else if (modspec == ',')
-    {
-      x = p && p[0] == modspec;
-      modop = x ? CASE_LOWER : CASE_LOWFIRST;
-      p += x;
-    }
-  else if (modspec == '~')
-    {
-      x = p && p[0] == modspec;
-      modop = x ? CASE_TOGGLEALL : CASE_TOGGLE;
-      p += x;
-    }
-    
-  lpat = p ? savestring (p) : 0;
-  /* Perform the same expansions on the pattern as performed by the
-     pattern removal expansions. */
-  pat = lpat ? getpattern (lpat, quoted, 1) : 0;
-
-  /* OK, now we do the case modification. */
-  switch (vtype)
-    {
-    case VT_VARIABLE:
-    case VT_ARRAYMEMBER:
-      temp = sh_modcase (val, pat, modop);
-      if (vtype == VT_VARIABLE)
-	FREE (val);
-      if (temp)
-	{
-	  tt = (mflags & MATCH_QUOTED) ? quote_string (temp) : quote_escapes (temp);
-	  free (temp);
-	  temp = tt;
-	}
-      break;
-
-    case VT_POSPARMS:
-      temp = pos_params_modcase (val, pat, modop, mflags);
-      if (temp && quoted == 0 && ifs_is_null)
-	{
-	  /* Posix interp 888 */
-	}
-      else if (temp && (mflags & MATCH_QUOTED) == 0)
-	{
-	  tt = quote_escapes (temp);
-	  free (temp);
-	  temp = tt;
-	}
-      break;
-
-#if defined (ARRAY_VARS)
-    case VT_ARRAYVAR:
-      /* If we are expanding in a context where word splitting will not be
-	 performed, treat as quoted.  This changes how ${A[*]} will be
-	 expanded to make it identical to $*. */
-      if ((mflags & MATCH_STARSUB) && (mflags & MATCH_ASSIGNRHS) && ifs_is_null)
-	mflags |= MATCH_QUOTED;		/* Posix interp 888 */
-
-      temp = assoc_p (v) ? assoc_modcase (assoc_cell (v), pat, modop, mflags)
-			 : array_modcase (array_cell (v), pat, modop, mflags);
-
-      if (temp && quoted == 0 && ifs_is_null)
-	{
-	  /* Posix interp 888 */
-	}
-      else if (temp && (mflags & MATCH_QUOTED) == 0)
-	{
-	  tt = quote_escapes (temp);
-	  free (temp);
-	  temp = tt;
-	}
-
-      break;
-#endif
-    }
-
-  FREE (pat);
-  free (lpat);
-
-  this_command_name = oname;
-
-  return temp;
-}
-
-/* Check for unbalanced parens in S, which is the contents of $(( ... )).  If
-   any occur, this must be a nested command substitution, so return 0.
-   Otherwise, return 1.  A valid arithmetic expression must always have a
-   ( before a matching ), so any cases where there are more right parens
-   means that this must not be an arithmetic expression, though the parser
-   will not accept it without a balanced total number of parens. */
-static int
-chk_arithsub (s, len)
-     const char *s;
-     int len;
-{
-  int i, count;
-  DECLARE_MBSTATE;
-
-  i = count = 0;
-  while (i < len)
-    {
-      if (s[i] == LPAREN)
-	count++;
-      else if (s[i] == RPAREN)
-	{
-	  count--;
-	  if (count < 0)
-	    return 0;
-	}
-
-      switch (s[i])
-	{
-	default:
-	  ADVANCE_CHAR (s, len, i);
-	  break;
-
-	case '\\':
-	  i++;
-	  if (s[i])
-	    ADVANCE_CHAR (s, len, i);
-	  break;
-
-	case '\'':
-	  i = skip_single_quoted (s, len, ++i, 0);
-	  break;
-
-	case '"':
-	  i = skip_double_quoted ((char *)s, len, ++i, 0);
-	  break;
-	}
-    }
-
-  return (count == 0);
-}
-
-/****************************************************************/
-/*								*/
-/*	Functions to perform parameter expansion on a string	*/
-/*								*/
-/****************************************************************/
-
-/* ${[#][!]name[[:][^[^]][,[,]]#[#]%[%]-=?+[word][:e1[:e2]]]} */
-static WORD_DESC *
-parameter_brace_expand (string, indexp, quoted, pflags, quoted_dollar_atp, contains_dollar_at)
-     char *string;
-     int *indexp, quoted, pflags, *quoted_dollar_atp, *contains_dollar_at;
-{
-  int check_nullness, var_is_set, var_is_null, var_is_special;
-  int want_substring, want_indir, want_patsub, want_casemod, want_attributes;
-  char *name, *value, *temp, *temp1;
-  WORD_DESC *tdesc, *ret;
-  int t_index, sindex, c, tflag, modspec, local_pflags, all_element_arrayref;
-  intmax_t number;
-  array_eltstate_t es;
-
-  temp = temp1 = value = (char *)NULL;
-  var_is_set = var_is_null = var_is_special = check_nullness = 0;
-  want_substring = want_indir = want_patsub = want_casemod = want_attributes = 0;
-
-  local_pflags = 0;
-  all_element_arrayref = 0;
-
-  sindex = *indexp;
-  t_index = ++sindex;
-  /* ${#var} doesn't have any of the other parameter expansions on it. */
-  if (string[t_index] == '#' && legal_variable_starter (string[t_index+1]))		/* {{ */
-    name = string_extract (string, &t_index, "}", SX_VARNAME);
-  else
-#if defined (CASEMOD_EXPANSIONS)
-    /* To enable case-toggling expansions using the `~' operator character
-       define CASEMOD_TOGGLECASE in config-top.h */
-#  if defined (CASEMOD_TOGGLECASE)
-    name = string_extract (string, &t_index, "#%^,~:-=?+/@}", SX_VARNAME);
-#  else
-    name = string_extract (string, &t_index, "#%^,:-=?+/@}", SX_VARNAME);
-#  endif /* CASEMOD_TOGGLECASE */
-#else
-    name = string_extract (string, &t_index, "#%:-=?+/@}", SX_VARNAME);
-#endif /* CASEMOD_EXPANSIONS */
-
-  /* Handle ${@[stuff]} now that @ is a word expansion operator.  Not exactly
-     the cleanest code ever. */
-  if (*name == 0 && sindex == t_index && string[sindex] == '@')
-    {
-      name = (char *)xrealloc (name, 2);
-      name[0] = '@';
-      name[1] = '\0';
-      t_index++;
-    }
-  else if (*name == '!' && t_index > sindex && string[t_index] == '@' && string[t_index+1] == RBRACE)
-    {
-      name = (char *)xrealloc (name, t_index - sindex + 2);
-      name[t_index - sindex] = '@';
-      name[t_index - sindex + 1] = '\0';
-      t_index++;
-    }
-
-  ret = 0;
-  tflag = 0;
-
-#if defined (ARRAY_VARS)
-  init_eltstate (&es);
-#endif
-  es.ind = INTMAX_MIN;	/* XXX */
-
-  /* If the name really consists of a special variable, then make sure
-     that we have the entire name.  We don't allow indirect references
-     to special variables except `#', `?', `@' and `*'.  This clause is
-     designed to handle ${#SPECIAL} and ${!SPECIAL}, not anything more
-     general. */
-  if ((sindex == t_index && VALID_SPECIAL_LENGTH_PARAM (string[t_index])) ||
-      (sindex == t_index && string[sindex] == '#' && VALID_SPECIAL_LENGTH_PARAM (string[sindex + 1])) ||
-      (sindex == t_index - 1 && string[sindex] == '!' && VALID_INDIR_PARAM (string[t_index])))
-    {
-      t_index++;
-      temp1 = string_extract (string, &t_index, "#%:-=?+/@}", 0);
-      name = (char *)xrealloc (name, 3 + (strlen (temp1)));
-      *name = string[sindex];
-      if (string[sindex] == '!')
-	{
-	  /* indirect reference of $#, $?, $@, or $* */
-	  name[1] = string[sindex + 1];
-	  strcpy (name + 2, temp1);
-	}
-      else	
-	strcpy (name + 1, temp1);
-      free (temp1);
-    }
-  sindex = t_index;
-
-  /* Find out what character ended the variable name.  Then
-     do the appropriate thing. */
-  if (c = string[sindex])
-    sindex++;
-
-  /* If c is followed by one of the valid parameter expansion
-     characters, move past it as normal.  If not, assume that
-     a substring specification is being given, and do not move
-     past it. */
-  if (c == ':' && VALID_PARAM_EXPAND_CHAR (string[sindex]))
-    {
-      check_nullness++;
-      if (c = string[sindex])
-	sindex++;
-    }
-  else if (c == ':' && string[sindex] != RBRACE)
-    want_substring = 1;
-  else if (c == '/' /* && string[sindex] != RBRACE */)	/* XXX */
-    want_patsub = 1;
-#if defined (CASEMOD_EXPANSIONS)
-  else if (c == '^' || c == ',' || c == '~')
-    {
-      modspec = c;
-      want_casemod = 1;
-    }
-#endif
-  else if (c == '@' && (string[sindex] == 'a' || string[sindex] == 'A') && string[sindex+1] == RBRACE)
-    {
-      /* special case because we do not want to shortcut foo as foo[0] here */
-      want_attributes = 1;
-      local_pflags |= PF_ALLINDS;
-    }
-
-  /* Catch the valid and invalid brace expressions that made it through the
-     tests above. */
-  /* ${#-} is a valid expansion and means to take the length of $-.
-     Similarly for ${#?} and ${##}... */
-  if (name[0] == '#' && name[1] == '\0' && check_nullness == 0 &&
-	VALID_SPECIAL_LENGTH_PARAM (c) && string[sindex] == RBRACE)
-    {
-      name = (char *)xrealloc (name, 3);
-      name[1] = c;
-      name[2] = '\0';
-      c = string[sindex++];
-    }
-
-  /* ...but ${#%}, ${#:}, ${#=}, ${#+}, and ${#/} are errors. */
-  if (name[0] == '#' && name[1] == '\0' && check_nullness == 0 &&
-	member (c, "%:=+/") && string[sindex] == RBRACE)
-    {
-      temp = (char *)NULL;
-      goto bad_substitution;	/* XXX - substitution error */
-    }
-
-  /* Indirect expansion begins with a `!'.  A valid indirect expansion is
-     either a variable name, one of the positional parameters or a special
-     variable that expands to one of the positional parameters. */
-  want_indir = *name == '!' &&
-    (legal_variable_starter ((unsigned char)name[1]) || DIGIT (name[1])
-					|| VALID_INDIR_PARAM (name[1]));
-
-  /* Determine the value of this variable whose name is NAME. */
-
-  /* Check for special variables, directly referenced. */
-  if (SPECIAL_VAR (name, want_indir))
-    var_is_special++;
-
-  /* Check for special expansion things, like the length of a parameter */
-  if (*name == '#' && name[1])
-    {
-      /* If we are not pointing at the character just after the
-	 closing brace, then we haven't gotten all of the name.
-	 Since it begins with a special character, this is a bad
-	 substitution.  Also check NAME for validity before trying
-	 to go on. */
-      if (string[sindex - 1] != RBRACE || (valid_length_expression (name) == 0))
-	{
-	  temp = (char *)NULL;
-	  goto bad_substitution;	/* substitution error */
-	}
-
-      number = parameter_brace_expand_length (name);
-      if (number == INTMAX_MIN && unbound_vars_is_error)
-	{
-	  set_exit_status (EXECUTION_FAILURE);
-	  err_unboundvar (name+1);
-	  free (name);
-	  return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
-	}
-      free (name);
-
-      *indexp = sindex;
-      if (number < 0)
-        return (&expand_wdesc_error);
-      else
-	{
-	  ret = alloc_word_desc ();
-	  ret->word = itos (number);
-	  return ret;
-	}
-    }
-
-  /* ${@} is identical to $@. */
-  if (name[0] == '@' && name[1] == '\0')
-    {
-      if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
-	*quoted_dollar_atp = 1;
-
-      if (contains_dollar_at)
-	*contains_dollar_at = 1;
-
-      tflag |= W_DOLLARAT;
-    }
-
-  /* Process ${!PREFIX*} expansion. */
-  if (want_indir && string[sindex - 1] == RBRACE &&
-      (string[sindex - 2] == '*' || string[sindex - 2] == '@') &&
-      legal_variable_starter ((unsigned char) name[1]))
-    {
-      char **x;
-      WORD_LIST *xlist;
-
-      temp1 = savestring (name + 1);
-      number = strlen (temp1);
-      temp1[number - 1] = '\0';
-      x = all_variables_matching_prefix (temp1);
-      xlist = strvec_to_word_list (x, 0, 0);
-      if (string[sindex - 2] == '*')
-	temp = string_list_dollar_star (xlist, quoted, 0);
-      else
-	{
-	  temp = string_list_dollar_at (xlist, quoted, 0);
-	  if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
-	    *quoted_dollar_atp = 1;
-	  if (contains_dollar_at)
-	    *contains_dollar_at = 1;
-
-	  tflag |= W_DOLLARAT;
-	}
-      free (x);
-      dispose_words (xlist);
-      free (temp1);
-      *indexp = sindex;
-
-      free (name);
-
-      ret = alloc_word_desc ();
-      ret->word = temp;
-      ret->flags = tflag;	/* XXX */
-      return ret;
-    }
-
-#if defined (ARRAY_VARS)      
-  /* Process ${!ARRAY[@]} and ${!ARRAY[*]} expansion. */
-  if (want_indir && string[sindex - 1] == RBRACE &&
-      string[sindex - 2] == RBRACK && valid_array_reference (name+1, 0))
-    {
-      char *x, *x1;
-
-      temp1 = savestring (name + 1);
-      x = array_variable_name (temp1, 0, &x1, (int *)0);
-      FREE (x);
-      if (ALL_ELEMENT_SUB (x1[0]) && x1[1] == RBRACK)
-	{
-	  temp = array_keys (temp1, quoted, pflags);	/* handles assoc vars too */
-	  if (x1[0] == '@')
-	    {
-	      if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
-		*quoted_dollar_atp = 1;
-	      if (contains_dollar_at)
-		*contains_dollar_at = 1;
-
-	      tflag |= W_DOLLARAT;
-	    }	    
-
-	  free (name);
-	  free (temp1);
-	  *indexp = sindex;
-
-	  ret = alloc_word_desc ();
-	  ret->word = temp;
-	  ret->flags = tflag;	/* XXX */
-	  return ret;
-	}
-
-      free (temp1);
-    }
-#endif /* ARRAY_VARS */
-      
-  /* Make sure that NAME is valid before trying to go on. */
-  if (valid_brace_expansion_word (want_indir ? name + 1 : name,
-					var_is_special) == 0)
-    {
-      temp = (char *)NULL;
-      goto bad_substitution;		/* substitution error */
-    }
-
-  if (want_indir)
-    {
-      tdesc = parameter_brace_expand_indir (name + 1, var_is_special, quoted, pflags|local_pflags, quoted_dollar_atp, contains_dollar_at);
-      if (tdesc == &expand_wdesc_error || tdesc == &expand_wdesc_fatal)
-	{
-	  temp = (char *)NULL;
-	  goto bad_substitution;
-	}
-
-      /* Turn off the W_ARRAYIND flag because there is no way for this function
-	 to return the index we're supposed to be using. */
-      if (tdesc && tdesc->flags)
-	tdesc->flags &= ~W_ARRAYIND;
-
-      /* If the indir expansion contains $@/$*, extend the special treatment
-	 of the case of no positional parameters and `set -u' to it. */
-      if (contains_dollar_at && *contains_dollar_at)
-	all_element_arrayref = 1;
-    }
-  else
-    {
-      local_pflags |= PF_IGNUNBOUND|(pflags&(PF_NOSPLIT2|PF_ASSIGNRHS));
-      tdesc = parameter_brace_expand_word (name, var_is_special, quoted, local_pflags, &es);
-    }
-
-  if (tdesc == &expand_wdesc_error || tdesc == &expand_wdesc_fatal)
-    {
-      tflag = 0;
-      tdesc = 0;
-    }
-
-  if (tdesc)
-    {
-      temp = tdesc->word;
-      tflag = tdesc->flags;
-      dispose_word_desc (tdesc);
-    }
-  else
-    temp = (char *)0;
-
-  if (temp == &expand_param_error || temp == &expand_param_fatal)
-    {
-      FREE (name);
-      FREE (value);
-      return (temp == &expand_param_error ? &expand_wdesc_error : &expand_wdesc_fatal);
-    }
-
-#if defined (ARRAY_VARS)
-  if (valid_array_reference (name, 0))
-    {
-      int qflags;
-      char *t;
-
-      qflags = quoted;
-      /* If in a context where word splitting will not take place, treat as
-	 if double-quoted.  Has effects with $* and ${array[*]} */
-
-      if (pflags & PF_ASSIGNRHS)
-	qflags |= Q_DOUBLE_QUOTES;
-      /* We duplicate a little code here */
-      t = mbschr (name, LBRACK);
-      if (t && ALL_ELEMENT_SUB (t[1]) && t[2] == RBRACK)
-	{
-	  all_element_arrayref = 1;
-	  if (expand_no_split_dollar_star && t[1] == '*')	/* XXX */
-	    qflags |= Q_DOUBLE_QUOTES;
-	}
-      chk_atstar (name, qflags, pflags, quoted_dollar_atp, contains_dollar_at);
-    }
-#endif
-
-  var_is_set = temp != (char *)0;
-  var_is_null = check_nullness && (var_is_set == 0 || *temp == 0);
-  /* XXX - this may not need to be restricted to special variables */
-  if (check_nullness)
-    var_is_null |= var_is_set && var_is_special && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && QUOTED_NULL (temp);
-#if defined (ARRAY_VARS)
-  if (check_nullness)
-    var_is_null |= var_is_set && 
-		   (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) &&
-		   QUOTED_NULL (temp) &&
-		   valid_array_reference (name, 0) &&
-		   chk_atstar (name, 0, 0, (int *)0, (int *)0);
-#endif
-
-  /* Get the rest of the stuff inside the braces. */
-  if (c && c != RBRACE)
-    {
-      /* Extract the contents of the ${ ... } expansion
-	 according to the Posix.2 rules. */
-      value = extract_dollar_brace_string (string, &sindex, quoted, (c == '%' || c == '#' || c =='/' || c == '^' || c == ',' || c ==':') ? SX_POSIXEXP|SX_WORD : SX_WORD);
-      if (string[sindex] == RBRACE)
-	sindex++;
-      else
-	goto bad_substitution;		/* substitution error */
-    }
-  else
-    value = (char *)NULL;
-
-  *indexp = sindex;
-
-  /* All the cases where an expansion can possibly generate an unbound
-     variable error. */
-  if (want_substring || want_patsub || want_casemod || c == '@' || c == '#' || c == '%' || c == RBRACE)
-    {
-      if (var_is_set == 0 && unbound_vars_is_error && ((name[0] != '@' && name[0] != '*') || name[1]) && all_element_arrayref == 0)
-	{
-	  set_exit_status (EXECUTION_FAILURE);
-	  err_unboundvar (name);
-	  FREE (value);
-	  FREE (temp);
-	  free (name);
-	  return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
-	}
-    }
-    
-  /* If this is a substring spec, process it and add the result. */
-  if (want_substring)
-    {
-      temp1 = parameter_brace_substring (name, temp, &es, value, quoted, pflags, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
-      FREE (value);
-      FREE (temp);
-#if defined (ARRAY_VARS)
-      flush_eltstate (&es);
-#endif
-
-      if (temp1 == &expand_param_error || temp1 == &expand_param_fatal)
-        {
-          FREE (name);
-	  return (temp1 == &expand_param_error ? &expand_wdesc_error : &expand_wdesc_fatal);
-        }
-
-      ret = alloc_word_desc ();
-      ret->word = temp1;
-      /* We test quoted_dollar_atp because we want variants with double-quoted
-	 "$@" to take a different code path. In fact, we make sure at the end
-	 of expand_word_internal that we're only looking at these flags if
-	 quoted_dollar_at == 0. */
-      if (temp1 &&
-          (quoted_dollar_atp == 0 || *quoted_dollar_atp == 0) &&
-	  QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-	ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
-      else if (temp1 && (name[0] == '*' && name[1] == 0) && quoted == 0 &&
-		(pflags & PF_ASSIGNRHS))
-	ret->flags |= W_SPLITSPACE;	/* Posix interp 888 */	
-      /* Special handling for $* when unquoted and $IFS is null. Posix interp 888 */
-      else if (temp1 && (name[0] == '*' && name[1] == 0) && quoted == 0 && ifs_is_null)
-	ret->flags |= W_SPLITSPACE;	/* Posix interp 888 */
-
-      FREE (name);
-      return ret;
-    }
-  else if (want_patsub)
-    {
-      temp1 = parameter_brace_patsub (name, temp, &es, value, quoted, pflags, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
-      FREE (value);
-      FREE (temp);
-#if defined (ARRAY_VARS)
-      flush_eltstate (&es);
-#endif
-
-      if (temp1 == &expand_param_error || temp1 == &expand_param_fatal)
-        {
-          FREE (name);
-	  return (temp1 == &expand_param_error ? &expand_wdesc_error : &expand_wdesc_fatal);
-        }
-
-      ret = alloc_word_desc ();
-      ret->word = temp1;
-      if (temp1 && 
-          (quoted_dollar_atp == 0 || *quoted_dollar_atp == 0) &&
-	  QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-	ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
-      /* Special handling for $* when unquoted and $IFS is null. Posix interp 888 */
-      else if (temp1 && (name[0] == '*' && name[1] == 0) && quoted == 0 && ifs_is_null)
-	ret->flags |= W_SPLITSPACE;	/* Posix interp 888 */
-
-      FREE (name);
-      return ret;
-    }
-#if defined (CASEMOD_EXPANSIONS)
-  else if (want_casemod)
-    {
-      temp1 = parameter_brace_casemod (name, temp, &es, modspec, value, quoted, pflags, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
-      FREE (value);
-      FREE (temp);
-#if defined (ARRAY_VARS)
-      flush_eltstate (&es);
-#endif
-
-      if (temp1 == &expand_param_error || temp1 == &expand_param_fatal)
-        {
-          FREE (name);
-	  return (temp1 == &expand_param_error ? &expand_wdesc_error : &expand_wdesc_fatal);
-        }
-
-      ret = alloc_word_desc ();
-      ret->word = temp1;
-      if (temp1 &&
-          (quoted_dollar_atp == 0 || *quoted_dollar_atp == 0) &&
-	  QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-	ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
-      /* Special handling for $* when unquoted and $IFS is null. Posix interp 888 */
-      else if (temp1 && (name[0] == '*' && name[1] == 0) && quoted == 0 && ifs_is_null)
-	ret->flags |= W_SPLITSPACE;	/* Posix interp 888 */
-
-      FREE (name);
-      return ret;
-    }
-#endif
-
-  /* Do the right thing based on which character ended the variable name. */
-  switch (c)
-    {
-    default:
-    case '\0':
-bad_substitution:
-      set_exit_status (EXECUTION_FAILURE);
-      report_error (_("%s: bad substitution"), string ? string : "??");
-      FREE (value);
-      FREE (temp);
-      free (name);
-#if defined (ARRAY_VARS)
-      flush_eltstate (&es);
-#endif
-      if (shell_compatibility_level <= 43)
-	return &expand_wdesc_error;
-      else
-	return ((posixly_correct && interactive_shell == 0) ? &expand_wdesc_fatal : &expand_wdesc_error);
-
-    case RBRACE:
-      break;
-
-    case '@':
-      temp1 = parameter_brace_transform (name, temp, &es, value, c, quoted, pflags, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
-      free (temp);
-      free (value);
-#if defined (ARRAY_VARS)
-      flush_eltstate (&es);
-#endif
-
-      if (temp1 == &expand_param_error || temp1 == &expand_param_fatal)
-	{
-	  free (name);
-	  set_exit_status (EXECUTION_FAILURE);
-	  report_error (_("%s: bad substitution"), string ? string : "??");
-	  return (temp1 == &expand_param_error ? &expand_wdesc_error : &expand_wdesc_fatal);
-	}
-
-      ret = alloc_word_desc ();
-      ret->word = temp1;
-      if (temp1 && QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-	ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
-      /* Special handling for $* when unquoted and $IFS is null. Posix interp 888 */
-      else if (temp1 && (name[0] == '*' && name[1] == 0) && quoted == 0 && ifs_is_null)
-	ret->flags |= W_SPLITSPACE;	/* Posix interp 888 */
-
-      free (name);
-      return ret;
-
-    case '#':	/* ${param#[#]pattern} */
-    case '%':	/* ${param%[%]pattern} */
-      if (value == 0 || *value == '\0' || temp == 0 || *temp == '\0')
-	{
-	  FREE (value);
-	  break;
-	}
-      temp1 = parameter_brace_remove_pattern (name, temp, &es, value, c, quoted, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
-      free (temp);
-      free (value);
-#if defined (ARRAY_VARS)
-      flush_eltstate (&es);
-#endif
-
-      ret = alloc_word_desc ();
-      ret->word = temp1;
-      if (temp1 && QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-	ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
-      /* Special handling for $* when unquoted and $IFS is null. Posix interp 888 */
-      else if (temp1 && (name[0] == '*' && name[1] == 0) && quoted == 0 && ifs_is_null)
-	ret->flags |= W_SPLITSPACE;	/* Posix interp 888 */
-
-      free (name);
-      return ret;
-
-    case '-':
-    case '=':
-    case '?':
-    case '+':
-      if (var_is_set && var_is_null == 0)
-	{
-	  /* If the operator is `+', we don't want the value of the named
-	     variable for anything, just the value of the right hand side. */
-	  if (c == '+')
-	    {
-	      /* XXX -- if we're double-quoted and the named variable is "$@",
-			we want to turn off any special handling of "$@" --
-			we're not using it, so whatever is on the rhs applies. */
-	      if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
-		*quoted_dollar_atp = 0;
-	      if (contains_dollar_at)
-		*contains_dollar_at = 0;
-
-	      FREE (temp);
-	      if (value)
-		{
-		  /* From Posix discussion on austin-group list.  Issue 221
-		     requires that backslashes escaping `}' inside
-		     double-quoted ${...} be removed. */
-		  if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-		    quoted |= Q_DOLBRACE;
-		  ret = parameter_brace_expand_rhs (name, value, c,
-						    quoted,
-						    pflags,
-						    quoted_dollar_atp,
-						    contains_dollar_at);
-		  /* XXX - fix up later, esp. noting presence of
-			   W_HASQUOTEDNULL in ret->flags */
-		  free (value);
-		}
-	      else
-		temp = (char *)NULL;
-	    }
-	  else
-	    {
-	      FREE (value);
-	    }
-	  /* Otherwise do nothing; just use the value in TEMP. */
-	}
-      else	/* VAR not set or VAR is NULL. */
-	{
-	  /* If we're freeing a quoted null here, we need to remember we saw
-	     it so we can restore it later if needed, or the caller can note it.
-	     The check against `+' doesn't really matter, since the other cases
-	     don't use or return TFLAG, but it's good for clarity. */
-	  if (c == '+' && temp && QUOTED_NULL (temp) &&
-	      (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
-	    tflag |= W_HASQUOTEDNULL;
-
-	  FREE (temp);
-	  temp = (char *)NULL;
-	  if (c == '=' && var_is_special)
-	    {
-	      set_exit_status (EXECUTION_FAILURE);
-	      report_error (_("$%s: cannot assign in this way"), name);
-	      free (name);
-	      free (value);
-#if defined (ARRAY_VARS)
-	      flush_eltstate (&es);
-#endif
-	      return &expand_wdesc_error;
-	    }
-	  else if (c == '?')
-	    {
-	      parameter_brace_expand_error (name, value, check_nullness);
-#if defined (ARRAY_VARS)
-	      flush_eltstate (&es);
-#endif
-	      return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
-	    }
-	  else if (c != '+')
-	    {
-	      /* XXX -- if we're double-quoted and the named variable is "$@",
-			we want to turn off any special handling of "$@" --
-			we're not using it, so whatever is on the rhs applies. */
-	      if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
-		*quoted_dollar_atp = 0;
-	      if (contains_dollar_at)
-		*contains_dollar_at = 0;
-
-	      /* From Posix discussion on austin-group list.  Issue 221 requires
-		 that backslashes escaping `}' inside double-quoted ${...} be
-		 removed. */
-	      if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-		quoted |= Q_DOLBRACE;
-	      ret = parameter_brace_expand_rhs (name, value, c, quoted, pflags,
-						quoted_dollar_atp,
-						contains_dollar_at);
-	      /* XXX - fix up later, esp. noting presence of
-		       W_HASQUOTEDNULL in tdesc->flags */
-	    }
-	  free (value);
-	}
-
-      break;
-    }
-  free (name);
-#if defined (ARRAY_VARS)
-  flush_eltstate (&es);
-#endif
-
-  if (ret == 0)
-    {
-      ret = alloc_word_desc ();
-      ret->flags = tflag;
-      ret->word = temp;
-    }
-  return (ret);
-}
-
-/* Expand a single ${xxx} expansion.  The braces are optional.  When
-   the braces are used, parameter_brace_expand() does the work,
-   possibly calling param_expand recursively. */
-static WORD_DESC *
-param_expand (string, sindex, quoted, expanded_something,
-	      contains_dollar_at, quoted_dollar_at_p, had_quoted_null_p,
-	      pflags)
-     char *string;
-     int *sindex, quoted, *expanded_something, *contains_dollar_at;
-     int *quoted_dollar_at_p, *had_quoted_null_p, pflags;
-{
-  char *temp, *temp1, uerror[3], *savecmd;
-  int zindex, t_index, expok, eflag;
-  unsigned char c;
-  intmax_t number;
-  SHELL_VAR *var;
-  WORD_LIST *list, *l;
-  WORD_DESC *tdesc, *ret;
-  int tflag, nullarg;
-
-/*itrace("param_expand: `%s' pflags = %d", string+*sindex, pflags);*/
-  zindex = *sindex;
-  c = string[++zindex];
-
-  temp = (char *)NULL;
-  ret = tdesc = (WORD_DESC *)NULL;
-  tflag = 0;
-
-  /* Do simple cases first. Switch on what follows '$'. */
-  switch (c)
-    {
-    /* $0 .. $9? */
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-      temp1 = dollar_vars[TODIGIT (c)];
-      /* This doesn't get called when (pflags&PF_IGNUNBOUND) != 0 */
-      if (unbound_vars_is_error && temp1 == (char *)NULL)
-	{
-	  uerror[0] = '$';
-	  uerror[1] = c;
-	  uerror[2] = '\0';
-	  set_exit_status (EXECUTION_FAILURE);
-	  err_unboundvar (uerror);
-	  return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
-	}
-      if (temp1)
-	temp = (*temp1 && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-		  ? quote_string (temp1)
-		  : quote_escapes (temp1);
-      else
-	temp = (char *)NULL;
-
-      break;
-
-    /* $$ -- pid of the invoking shell. */
-    case '$':
-      temp = itos (dollar_dollar_pid);
-      break;
-
-    /* $# -- number of positional parameters. */
-    case '#':
-      temp = itos (number_of_args ());
-      break;
-
-    /* $? -- return value of the last synchronous command. */
-    case '?':
-      temp = itos (last_command_exit_value);
-      break;
-
-    /* $- -- flags supplied to the shell on invocation or by `set'. */
-    case '-':
-      temp = which_set_flags ();
-      break;
-
-      /* $! -- Pid of the last asynchronous command. */
-    case '!':
-      /* If no asynchronous pids have been created, expand to nothing.
-	 If `set -u' has been executed, and no async processes have
-	 been created, this is an expansion error. */
-      if (last_asynchronous_pid == NO_PID)
-	{
-	  if (expanded_something)
-	    *expanded_something = 0;
-	  temp = (char *)NULL;
-	  if (unbound_vars_is_error && (pflags & PF_IGNUNBOUND) == 0)
-	    {
-	      uerror[0] = '$';
-	      uerror[1] = c;
-	      uerror[2] = '\0';
-	      set_exit_status (EXECUTION_FAILURE);
-	      err_unboundvar (uerror);
-	      return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
-	    }
-	}
-      else
-	temp = itos (last_asynchronous_pid);
-      break;
-
-    /* The only difference between this and $@ is when the arg is quoted. */
-    case '*':		/* `$*' */
-      list = list_rest_of_args ();
-
-#if 0
-      /* According to austin-group posix proposal by Geoff Clare in
-	 <20090505091501.GA10097@squonk.masqnet> of 5 May 2009:
-
- 	"The shell shall write a message to standard error and
- 	 immediately exit when it tries to expand an unset parameter
- 	 other than the '@' and '*' special parameters."
-      */
-
-      if (list == 0 && unbound_vars_is_error && (pflags & PF_IGNUNBOUND) == 0)
-	{
-	  uerror[0] = '$';
-	  uerror[1] = '*';
-	  uerror[2] = '\0';
-	  set_exit_status (EXECUTION_FAILURE);
-	  err_unboundvar (uerror);
-	  return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
-	}
-#endif
-
-      /* If there are no command-line arguments, this should just
-	 disappear if there are other characters in the expansion,
-	 even if it's quoted. */
-      if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && list == 0)
-	temp = (char *)NULL;
-      else if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES|Q_PATQUOTE))
-	{
-	  /* If we have "$*" we want to make a string of the positional
-	     parameters, separated by the first character of $IFS, and
-	     quote the whole string, including the separators.  If IFS
-	     is unset, the parameters are separated by ' '; if $IFS is
-	     null, the parameters are concatenated. */
-	  temp = (quoted & (Q_DOUBLE_QUOTES|Q_PATQUOTE)) ? string_list_dollar_star (list, quoted, 0) : string_list (list);
-	  if (temp)
-	    {
-	      temp1 = (quoted & Q_DOUBLE_QUOTES) ? quote_string (temp) : temp;
-	      if (*temp == 0)
-		tflag |= W_HASQUOTEDNULL;
-	      if (temp != temp1)
-		free (temp);
-	      temp = temp1;
-	    }
-	}
-      else
-	{
-	  /* We check whether or not we're eventually going to split $* here,
-	     for example when IFS is empty and we are processing the rhs of
-	     an assignment statement.  In that case, we don't separate the
-	     arguments at all.  Otherwise, if the $* is not quoted it is
-	     identical to $@ */
-	  if (expand_no_split_dollar_star && quoted == 0 && ifs_is_set == 0 && (pflags & PF_ASSIGNRHS))
-	    {
-	      /* Posix interp 888: RHS of assignment, IFS unset: no splitting,
-		 separate with space */
-	      temp1 = string_list_dollar_star (list, quoted, pflags);
-	      temp = temp1 ? quote_string (temp1) : temp1;
-	      /* XXX - tentative - note that we saw a quoted null here */
-	      if (temp1 && *temp1 == 0 && QUOTED_NULL (temp))
-		tflag |= W_SAWQUOTEDNULL;
-	      FREE (temp1);
-	    }
-	  else if (expand_no_split_dollar_star && quoted == 0 && ifs_is_null && (pflags & PF_ASSIGNRHS))
-	    {
-	      /* Posix interp 888: RHS of assignment, IFS set to '' */
-	      temp1 = string_list_dollar_star (list, quoted, pflags);
-	      temp = temp1 ? quote_escapes (temp1) : temp1;
-	      FREE (temp1);
-	    }
-	  else if (expand_no_split_dollar_star && quoted == 0 && ifs_is_set && ifs_is_null == 0 && (pflags & PF_ASSIGNRHS))
-	    {
-	      /* Posix interp 888: RHS of assignment, IFS set to non-null value */
-	      temp1 = string_list_dollar_star (list, quoted, pflags);
-	      temp = temp1 ? quote_string (temp1) : temp1;
-
-	      /* XXX - tentative - note that we saw a quoted null here */
-	      if (temp1 && *temp1 == 0 && QUOTED_NULL (temp))
-		tflag |= W_SAWQUOTEDNULL;
-	      FREE (temp1);
-	    }
-	  /* XXX - should we check ifs_is_set here as well? */
-#  if defined (HANDLE_MULTIBYTE)
-	  else if (expand_no_split_dollar_star && ifs_firstc[0] == 0)
-#  else
-	  else if (expand_no_split_dollar_star && ifs_firstc == 0)
-#  endif
-	    /* Posix interp 888: not RHS, no splitting, IFS set to '' */
-	    temp = string_list_dollar_star (list, quoted, 0);
-	  else
-	    {
-	      temp = string_list_dollar_at (list, quoted, 0);
-	      /* Set W_SPLITSPACE to make sure the individual positional
-		 parameters are split into separate arguments */
-#if 0
-	      if (quoted == 0 && (ifs_is_set == 0 || ifs_is_null))
-#else	/* change with bash-5.0 */
-	      if (quoted == 0 && ifs_is_null)
-#endif
-		tflag |= W_SPLITSPACE;
-	      /* If we're not quoted but we still don't want word splitting, make
-		 we quote the IFS characters to protect them from splitting (e.g.,
-		 when $@ is in the string as well). */
-	      else if (temp && quoted == 0 && ifs_is_set && (pflags & PF_ASSIGNRHS))
-		{
-		  temp1 = quote_string (temp);
-		  free (temp);
-		  temp = temp1;
-		}
-	    }
-
-	  if (expand_no_split_dollar_star == 0 && contains_dollar_at)
-	    *contains_dollar_at = 1;
-	}
-
-      dispose_words (list);
-      break;
-
-    /* When we have "$@" what we want is "$1" "$2" "$3" ... This
-       means that we have to turn quoting off after we split into
-       the individually quoted arguments so that the final split
-       on the first character of $IFS is still done.  */
-    case '@':		/* `$@' */
-      list = list_rest_of_args ();
-
-#if 0
-      /* According to austin-group posix proposal by Geoff Clare in
-	 <20090505091501.GA10097@squonk.masqnet> of 5 May 2009:
-
- 	"The shell shall write a message to standard error and
- 	 immediately exit when it tries to expand an unset parameter
- 	 other than the '@' and '*' special parameters."
-      */
-
-      if (list == 0 && unbound_vars_is_error && (pflags & PF_IGNUNBOUND) == 0)
-	{
-	  uerror[0] = '$';
-	  uerror[1] = '@';
-	  uerror[2] = '\0';
-	  set_exit_status (EXECUTION_FAILURE);
-	  err_unboundvar (uerror);
-	  return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
-	}
-#endif
-
-      for (nullarg = 0, l = list; l; l = l->next)
-	{
-	  if (l->word && (l->word->word == 0 || l->word->word[0] == 0))
-	    nullarg = 1;
-	}
-
-      /* We want to flag the fact that we saw this.  We can't turn
-	 off quoting entirely, because other characters in the
-	 string might need it (consider "\"$@\""), but we need some
-	 way to signal that the final split on the first character
-	 of $IFS should be done, even though QUOTED is 1. */
-      /* XXX - should this test include Q_PATQUOTE? */
-      if (quoted_dollar_at_p && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-	*quoted_dollar_at_p = 1;
-      if (contains_dollar_at)
-	*contains_dollar_at = 1;
-
-      /* We want to separate the positional parameters with the first
-	 character of $IFS in case $IFS is something other than a space.
-	 We also want to make sure that splitting is done no matter what --
-	 according to POSIX.2, this expands to a list of the positional
-	 parameters no matter what IFS is set to. */
-      /* XXX - what to do when in a context where word splitting is not
-	 performed? Even when IFS is not the default, posix seems to imply
-	 that we have to expand $@ to all the positional parameters and
-	 separate them with spaces, which are preserved because word splitting
-	 doesn't take place.  See below for how we use PF_NOSPLIT2 here. */
-
-      /* These are the cases where word splitting will not be performed. */
-      if (pflags & PF_ASSIGNRHS)
-	{
-	  temp = string_list_dollar_at (list, (quoted|Q_DOUBLE_QUOTES), pflags);
-	  if (nullarg)
-	    tflag |= W_HASQUOTEDNULL;	/* we know quoting produces quoted nulls */
-	}
-
-      /* This needs to match what expand_word_internal does with non-quoted $@
-	 does with separating with spaces.  Passing Q_DOUBLE_QUOTES means that
-	 the characters in LIST will be quoted, and PF_ASSIGNRHS ensures that
-	 they will separated by spaces. After doing this, we need the special
-	 handling for PF_NOSPLIT2 in expand_word_internal to remove the CTLESC
-	 quotes. */
-      else if (pflags & PF_NOSPLIT2)
-        {
-#if defined (HANDLE_MULTIBYTE)
-	  if (quoted == 0 && ifs_is_set && ifs_is_null == 0 && ifs_firstc[0] != ' ')
-#else
-	  if (quoted == 0 && ifs_is_set && ifs_is_null == 0 && ifs_firstc != ' ')
-#endif
-	    /* Posix interp 888 */
-	    temp = string_list_dollar_at (list, Q_DOUBLE_QUOTES, pflags);
-	  else
-	    temp = string_list_dollar_at (list, quoted, pflags);
-	}
-      else
-	temp = string_list_dollar_at (list, quoted, pflags);
-
-      tflag |= W_DOLLARAT;
-      dispose_words (list);
-      break;
-
-    case LBRACE:
-      tdesc = parameter_brace_expand (string, &zindex, quoted, pflags,
-				      quoted_dollar_at_p,
-				      contains_dollar_at);
-
-      if (tdesc == &expand_wdesc_error || tdesc == &expand_wdesc_fatal)
-	return (tdesc);
-      temp = tdesc ? tdesc->word : (char *)0;
-
-      /* XXX */
-      /* Quoted nulls should be removed if there is anything else
-	 in the string. */
-      /* Note that we saw the quoted null so we can add one back at
-	 the end of this function if there are no other characters
-	 in the string, discard TEMP, and go on.  The exception to
-	 this is when we have "${@}" and $1 is '', since $@ needs
-	 special handling. */
-      if (tdesc && tdesc->word && (tdesc->flags & W_HASQUOTEDNULL) && QUOTED_NULL (temp))
-	{
-	  if (had_quoted_null_p)
-	    *had_quoted_null_p = 1;
-	  if (*quoted_dollar_at_p == 0)
-	    {
-	      free (temp);
-	      tdesc->word = temp = (char *)NULL;
-	    }
-	    
-	}
-
-      ret = tdesc;
-      goto return0;
-
-    /* Do command or arithmetic substitution. */
-    case LPAREN:
-      /* We have to extract the contents of this paren substitution. */
-      t_index = zindex + 1;
-      /* XXX - might want to check for string[t_index+2] == LPAREN and parse
-	 as arithmetic substitution immediately. */
-      temp = extract_command_subst (string, &t_index, (pflags&PF_COMPLETE) ? SX_COMPLETE : 0);
-      zindex = t_index;
-
-      /* For Posix.2-style `$(( ))' arithmetic substitution,
-	 extract the expression and pass it to the evaluator. */
-      if (temp && *temp == LPAREN)
-	{
-	  char *temp2;
-	  temp1 = temp + 1;
-	  temp2 = savestring (temp1);
-	  t_index = strlen (temp2) - 1;
-
-	  if (temp2[t_index] != RPAREN)
-	    {
-	      free (temp2);
-	      goto comsub;
-	    }
-
-	  /* Cut off ending `)' */
-	  temp2[t_index] = '\0';
-
-	  if (chk_arithsub (temp2, t_index) == 0)
-	    {
-	      free (temp2);
-#if 0
-	      internal_warning (_("future versions of the shell will force evaluation as an arithmetic substitution"));
-#endif
-	      goto comsub;
-	    }
-
-	  /* Expand variables found inside the expression. */
-	  temp1 = expand_arith_string (temp2, Q_DOUBLE_QUOTES|Q_ARITH);
-	  free (temp2);
-
-arithsub:
-	  /* No error messages. */
-	  savecmd = this_command_name;
-	  this_command_name = (char *)NULL;
-
-	  eflag = (shell_compatibility_level > 51) ? 0 : EXP_EXPANDED;
-	  number = evalexp (temp1, eflag, &expok);
-	  this_command_name = savecmd;
-	  free (temp);
-	  free (temp1);
-	  if (expok == 0)
-	    {
-	      if (interactive_shell == 0 && posixly_correct)
-		{
-		  set_exit_status (EXECUTION_FAILURE);
-		  return (&expand_wdesc_fatal);
-		}
-	      else
-		return (&expand_wdesc_error);
-	    }
-	  temp = itos (number);
-	  break;
-	}
-
-comsub:
-      if (pflags & PF_NOCOMSUB)
-	/* we need zindex+1 because string[zindex] == RPAREN */
-	temp1 = substring (string, *sindex, zindex+1);
-      else
-	{
-	  tdesc = command_substitute (temp, quoted, pflags&PF_ASSIGNRHS);
-	  temp1 = tdesc ? tdesc->word : (char *)NULL;
-	  if (tdesc)
-	    dispose_word_desc (tdesc);
-	}
-      FREE (temp);
-      temp = temp1;
-      break;
-
-    /* Do POSIX.2d9-style arithmetic substitution.  This will probably go
-       away in a future bash release. */
-    case '[':		/*]*/
-      /* Extract the contents of this arithmetic substitution. */
-      t_index = zindex + 1;
-      temp = extract_arithmetic_subst (string, &t_index);
-      zindex = t_index;
-      if (temp == 0)
-	{
-	  temp = savestring (string);
-	  if (expanded_something)
-	    *expanded_something = 0;
-	  goto return0;
-	}	  
-
-       /* Do initial variable expansion. */
-      temp1 = expand_arith_string (temp, Q_DOUBLE_QUOTES|Q_ARITH);
-
-      goto arithsub;
-
-    default:
-      /* Find the variable in VARIABLE_LIST. */
-      temp = (char *)NULL;
-
-      for (t_index = zindex; (c = string[zindex]) && legal_variable_char (c); zindex++)
-	;
-      temp1 = (zindex > t_index) ? substring (string, t_index, zindex) : (char *)NULL;
-
-      /* If this isn't a variable name, then just output the `$'. */
-      if (temp1 == 0 || *temp1 == '\0')
-	{
-	  FREE (temp1);
-	  temp = (char *)xmalloc (2);
-	  temp[0] = '$';
-	  temp[1] = '\0';
-	  if (expanded_something)
-	    *expanded_something = 0;
-	  goto return0;
-	}
-
-      /* If the variable exists, return its value cell. */
-      var = find_variable (temp1);
-
-      if (var && invisible_p (var) == 0 && var_isset (var))
-	{
-#if defined (ARRAY_VARS)
-	  if (assoc_p (var) || array_p (var))
-	    {
-	      temp = array_p (var) ? array_reference (array_cell (var), 0)
-				   : assoc_reference (assoc_cell (var), "0");
-	      if (temp)
-		temp = (*temp && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-			  ? quote_string (temp)
-			  : quote_escapes (temp);
-	      else if (unbound_vars_is_error)
-		goto unbound_variable;
-	    }
-	  else
-#endif
-	    {
-	      temp = value_cell (var);
-
-	      temp = (*temp && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
-			? quote_string (temp)
-			: ((pflags & PF_ASSIGNRHS) ? quote_rhs (temp)
-						   : quote_escapes (temp));
-	    }
-
-	  free (temp1);
-
-	  goto return0;
-	}
-      else if (var && (invisible_p (var) || var_isset (var) == 0))
-	temp = (char *)NULL;
-      else if ((var = find_variable_last_nameref (temp1, 0)) && var_isset (var) && invisible_p (var) == 0)
-	{
-	  temp = nameref_cell (var);
-#if defined (ARRAY_VARS)
-	  if (temp && *temp && valid_array_reference (temp, 0))
-	    {
-	      chk_atstar (temp, quoted, pflags, quoted_dollar_at_p, contains_dollar_at);
-	      tdesc = parameter_brace_expand_word (temp, SPECIAL_VAR (temp, 0), quoted, pflags, 0);
-	      if (tdesc == &expand_wdesc_error || tdesc == &expand_wdesc_fatal)
-		return (tdesc);
-	      ret = tdesc;
-	      goto return0;
-	    }
-	  else
-#endif
-	  /* y=2 ; typeset -n x=y; echo $x is not the same as echo $2 in ksh */
-	  if (temp && *temp && legal_identifier (temp) == 0)
-	    {
-	      set_exit_status (EXECUTION_FAILURE);
-	      report_error (_("%s: invalid variable name for name reference"), temp);
-	      return (&expand_wdesc_error);	/* XXX */
-	    }
-	  else
-	    temp = (char *)NULL;
-	}
-
-      temp = (char *)NULL;
-
-unbound_variable:
-      if (unbound_vars_is_error)
-	{
-	  set_exit_status (EXECUTION_FAILURE);
-	  err_unboundvar (temp1);
-	}
-      else
-	{
-	  free (temp1);
-	  goto return0;
-	}
-
-      free (temp1);
-      set_exit_status (EXECUTION_FAILURE);
-      return ((unbound_vars_is_error && interactive_shell == 0)
-		? &expand_wdesc_fatal
-		: &expand_wdesc_error);
-    }
-
-  if (string[zindex])
-    zindex++;
-
-return0:
-  *sindex = zindex;
-
-  if (ret == 0)
-    {
-      ret = alloc_word_desc ();
-      ret->flags = tflag;	/* XXX */
-      ret->word = temp;
-    }
-  return ret;
-}
-
-#if defined (ARRAY_VARS)
-/* Characters that need to be backslash-quoted after expanding array subscripts */
-static char abstab[256] = { '\1' };
-
-/* Run an array subscript through the appropriate word expansions. */
-char *
-expand_subscript_string (string, quoted)
-     char *string;
-     int quoted;
-{
-  WORD_DESC td;
-  WORD_LIST *tlist;
-  int oe;
-  char *ret;
-
-  if (string == 0 || *string == 0)
-    return (char *)NULL;
-
-  oe = expand_no_split_dollar_star;
-  ret = (char *)NULL;
-
-  td.flags = W_NOPROCSUB|W_NOTILDE|W_NOSPLIT2;	/* XXX - W_NOCOMSUB? */
-  td.word = savestring (string);		/* in case it's freed on error */
-
-  expand_no_split_dollar_star = 1;
-  tlist = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
-  expand_no_split_dollar_star = oe;
-
-  if (tlist)
-    {
-      if (tlist->word)
-	{
-	  remove_quoted_nulls (tlist->word->word);
-	  tlist->word->flags &= ~W_HASQUOTEDNULL;
-	}
-      dequote_list (tlist);
-      ret = string_list (tlist);
-      dispose_words (tlist);
-    }
-
-  free (td.word);
-  return (ret);
-}
-
-/* Expand the subscript in STRING, which is an array reference. To ensure we
-   only expand it once, we quote the characters that would start another
-   expansion and the bracket characters that are special to array subscripts. */
-static char *
-expand_array_subscript (string, sindex, quoted, flags)
-     char *string;
-     int *sindex;
-     int quoted, flags;
-{
-  char *ret, *exp, *t;
-  size_t slen;
-  int si, ni;
-
-  si = *sindex;
-  slen = STRLEN (string);
-
-  if (abstab[0] == '\1')
-    {
-      /* These are basically the characters that start shell expansions plus
-	 the characters that delimit subscripts. */
-      memset (abstab, '\0', sizeof (abstab));
-      abstab[LBRACK] = abstab[RBRACK] = 1;
-      abstab['$'] = abstab['`'] = abstab['~'] = 1;
-      abstab['\\'] = abstab['\''] = 1;
-      abstab['"'] = 1;	/* XXX */
-      /* We don't quote `@' or `*' in the subscript at all. */
-    }
-
-  /* string[si] == LBRACK */
-  ni = skipsubscript (string, si, 0);
-  /* These checks mirror the ones in valid_array_reference. The check for
-     (ni - si) == 1 checks for empty subscripts. We don't check that the
-     subscript is a separate word if we're parsing an arithmetic expression. */
-  if (ni >= slen || string[ni] != RBRACK || (ni - si) == 1 ||
-      (string[ni+1] != '\0' && (quoted & Q_ARITH) == 0))
-    {
-      /* let's check and see what fails this check */
-      INTERNAL_DEBUG (("expand_array_subscript: bad subscript string: `%s'", string+si));
-      ret = (char *)xmalloc (2);	/* badly-formed subscript */
-      ret[0] = string[si];
-      ret[1] = '\0';
-      *sindex = si + 1;
-      return ret;
-    }
-
-  /* STRING[ni] == RBRACK */
-  exp = substring (string, si+1, ni);
-  t = expand_subscript_string (exp, quoted & ~(Q_ARITH|Q_DOUBLE_QUOTES));
-  free (exp);
-  exp = sh_backslash_quote (t, abstab, 0);
-  free (t);
-
-  slen = STRLEN (exp);
-  ret = xmalloc (slen + 2 + 1);
-  ret[0] ='[';
-  strcpy (ret + 1, exp);
-  ret[slen + 1] = ']';
-  ret[slen + 2] = '\0';
-
-  free (exp);
-  *sindex = ni + 1;
-
-  return ret;
-}
-#endif
-
-void
-invalidate_cached_quoted_dollar_at ()
-{
-  dispose_words (cached_quoted_dollar_at);
-  cached_quoted_dollar_at = 0;
-}
-
-/* Make a word list which is the result of parameter and variable
-   expansion, command substitution, arithmetic substitution, and
-   quote removal of WORD.  Return a pointer to a WORD_LIST which is
-   the result of the expansion.  If WORD contains a null word, the
-   word list returned is also null.
-
-   QUOTED contains flag values defined in shell.h.
-
-   ISEXP is used to tell expand_word_internal that the word should be
-   treated as the result of an expansion.  This has implications for
-   how IFS characters in the word are treated.
-
-   CONTAINS_DOLLAR_AT and EXPANDED_SOMETHING are return values; when non-null
-   they point to an integer value which receives information about expansion.
-   CONTAINS_DOLLAR_AT gets non-zero if WORD contained "$@", else zero.
-   EXPANDED_SOMETHING get non-zero if WORD contained any parameter expansions,
-   else zero.
-
-   This only does word splitting in the case of $@ expansion.  In that
-   case, we split on ' '. */
-
-/* Values for the local variable quoted_state. */
-#define UNQUOTED	 0
-#define PARTIALLY_QUOTED 1
-#define WHOLLY_QUOTED    2
-
-static WORD_LIST *
-expand_word_internal (word, quoted, isexp, contains_dollar_at, expanded_something)
-     WORD_DESC *word;
-     int quoted, isexp;
-     int *contains_dollar_at;
-     int *expanded_something;
-{
-  WORD_LIST *list;
-  WORD_DESC *tword;
-
-  /* The intermediate string that we build while expanding. */
-  char *istring;
-
-  /* The current size of the above object. */
-  size_t istring_size;
-
-  /* Index into ISTRING. */
-  size_t istring_index;
-
-  /* Temporary string storage. */
-  char *temp, *temp1;
-
-  /* The text of WORD. */
-  register char *string;
-
-  /* The size of STRING. */
-  size_t string_size;
-
-  /* The index into STRING. */
-  int sindex;
-
-  /* This gets 1 if we see a $@ while quoted. */
-  int quoted_dollar_at;
-
-  /* One of UNQUOTED, PARTIALLY_QUOTED, or WHOLLY_QUOTED, depending on
-     whether WORD contains no quoting characters, a partially quoted
-     string (e.g., "xx"ab), or is fully quoted (e.g., "xxab"). */
-  int quoted_state;
-
-  /* State flags */
-  int had_quoted_null;
-  int has_quoted_ifs;		/* did we add a quoted $IFS character here? */
-  int has_dollar_at, temp_has_dollar_at;
-  int internal_tilde;
-  int split_on_spaces;
-  int local_expanded;
-  int tflag;
-  int pflags;			/* flags passed to param_expand */
-  int mb_cur_max;
-
-  int assignoff;		/* If assignment, offset of `=' */
-
-  register unsigned char c;	/* Current character. */
-  int t_index;			/* For calls to string_extract_xxx. */
-
-  char twochars[2];
-
-  DECLARE_MBSTATE;
-
-  /* OK, let's see if we can optimize a common idiom: "$@". This needs to make sure
-     that all of the flags callers care about (e.g., W_HASQUOTEDNULL) are set in
-     list->flags. */
-  if (STREQ (word->word, "\"$@\"") &&
-      (word->flags == (W_HASDOLLAR|W_QUOTED)) &&
-      dollar_vars[1])		/* XXX - check IFS here as well? */
-    {
-      if (contains_dollar_at)
-	*contains_dollar_at = 1;
-      if (expanded_something)
-	*expanded_something = 1;
-      if (cached_quoted_dollar_at)
-	return (copy_word_list (cached_quoted_dollar_at));
-      list = list_rest_of_args ();
-      list = quote_list (list);
-      cached_quoted_dollar_at = copy_word_list (list);
-      return (list);
-    }
-
-  istring = (char *)xmalloc (istring_size = DEFAULT_INITIAL_ARRAY_SIZE);
-  istring[istring_index = 0] = '\0';
-  quoted_dollar_at = had_quoted_null = has_dollar_at = 0;
-  has_quoted_ifs = 0;
-  split_on_spaces = 0;
-  internal_tilde = 0;		/* expanding =~ or :~ */
-  quoted_state = UNQUOTED;
-
-  string = word->word;
-  if (string == 0)
-    goto finished_with_string;
-  mb_cur_max = MB_CUR_MAX;
-
-  /* Don't need the string length for the SADD... and COPY_ macros unless
-     multibyte characters are possible, but do need it for bounds checking. */
-  string_size = (mb_cur_max > 1) ? strlen (string) : 1;
-
-  if (contains_dollar_at)
-    *contains_dollar_at = 0;
-
-  assignoff = -1;
-
-  /* Begin the expansion. */
-
-  for (sindex = 0; ;)
-    {
-      c = string[sindex];
-
-      /* Case on top-level character. */
-      switch (c)
-	{
-	case '\0':
-	  goto finished_with_string;
-
-	case CTLESC:
-	  sindex++;
-#if HANDLE_MULTIBYTE
-	  if (mb_cur_max > 1 && string[sindex])
-	    {
-	      SADD_MBQCHAR_BODY(temp, string, sindex, string_size);
-	    }
-	  else
-#endif
-	    {
-	      temp = (char *)xmalloc (3);
-	      temp[0] = CTLESC;
-	      temp[1] = c = string[sindex];
-	      temp[2] = '\0';
-	    }
-
-dollar_add_string:
-	  if (string[sindex])
-	    sindex++;
-
-add_string:
-	  if (temp)
-	    {
-	      istring = sub_append_string (temp, istring, &istring_index, &istring_size);
-	      temp = (char *)0;
-	    }
-
-	  break;
-
-#if defined (PROCESS_SUBSTITUTION)
-	  /* Process substitution. */
-	case '<':
-	case '>':
-	  {
-	       /* XXX - technically this should only be expanded at the start
-	       of a word */
-	    if (string[++sindex] != LPAREN || (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || (word->flags & W_NOPROCSUB))
-	      {
-		sindex--;	/* add_character: label increments sindex */
-		goto add_character;
-	      }
-	    else
-	      t_index = sindex + 1; /* skip past both '<' and LPAREN */
-
-	    temp1 = extract_process_subst (string, (c == '<') ? "<(" : ">(", &t_index, 0); /*))*/
-	    sindex = t_index;
-
-	    /* If the process substitution specification is `<()', we want to
-	       open the pipe for writing in the child and produce output; if
-	       it is `>()', we want to open the pipe for reading in the child
-	       and consume input. */
-	    temp = temp1 ? process_substitute (temp1, (c == '>')) : (char *)0;
-
-	    FREE (temp1);
-
-	    goto dollar_add_string;
-	  }
-#endif /* PROCESS_SUBSTITUTION */
-
-#if defined (ARRAY_VARS)
-	case '[':		/*]*/
-	  if ((quoted & Q_ARITH) == 0 || shell_compatibility_level <= 51)
-	    {
-	      if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c) && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) == 0)
-		goto add_ifs_character;
-	      else
-		goto add_character;
-	    }
-	  else
-	    {
-	      temp = expand_array_subscript (string, &sindex, quoted, word->flags);
-	      goto add_string;
-	    }
-#endif
-
-	case '=':
-	  /* Posix.2 section 3.6.1 says that tildes following `=' in words
-	     which are not assignment statements are not expanded.  If the
-	     shell isn't in posix mode, though, we perform tilde expansion
-	     on `likely candidate' unquoted assignment statements (flags
-	     include W_ASSIGNMENT but not W_QUOTED).  A likely candidate
-	     contains an unquoted :~ or =~.  Something to think about: we
-	     now have a flag that says  to perform tilde expansion on arguments
-	     to `assignment builtins' like declare and export that look like
-	     assignment statements.  We now do tilde expansion on such words
-	     even in POSIX mode. */	
-	  if (word->flags & (W_ASSIGNRHS|W_NOTILDE))
-	    {
-	      if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
-		goto add_ifs_character;
-	      else
-		goto add_character;
-	    }
-	  /* If we're not in posix mode or forcing assignment-statement tilde
-	     expansion, note where the first `=' appears in the word and prepare
-	     to do tilde expansion following the first `='. We have to keep
-	     track of the first `=' (using assignoff) to avoid being confused
-	     by an `=' in the rhs of the assignment statement. */
-	  if ((word->flags & W_ASSIGNMENT) &&
-	      (posixly_correct == 0 || (word->flags & W_TILDEEXP)) &&
-	      assignoff == -1 && sindex > 0)
-	    assignoff = sindex;
-	  if (sindex == assignoff && string[sindex+1] == '~')	/* XXX */
-	    internal_tilde = 1;
-
-	  if (word->flags & W_ASSIGNARG)
-	    word->flags |= W_ASSIGNRHS;		/* affects $@ */
-
-	  if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
-	    {
-	      has_quoted_ifs++;
-	      goto add_ifs_character;
-	    }
-	  else
-	    goto add_character;
-
-	case ':':
-	  if (word->flags & (W_NOTILDE|W_NOASSNTILDE))
-	    {
-	      if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
-		goto add_ifs_character;
-	      else
-		goto add_character;
-	    }
-
-	  if ((word->flags & (W_ASSIGNMENT|W_ASSIGNRHS)) &&
-	      (posixly_correct == 0 || (word->flags & W_TILDEEXP)) &&
-	      string[sindex+1] == '~')
-	    internal_tilde = 1;
-
-	  if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
-	    goto add_ifs_character;
-	  else
-	    goto add_character;
-
-	case '~':
-	  /* If the word isn't supposed to be tilde expanded, or we're not
-	     at the start of a word or after an unquoted : or = in an
-	     assignment statement, we don't do tilde expansion.  We don't
-	     do tilde expansion if quoted or in an arithmetic context. */
-
-	  if ((word->flags & W_NOTILDE) ||
-	      (sindex > 0 && (internal_tilde == 0)) ||
-	      (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
-	    {
-	      internal_tilde = 0;
-	      if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c) && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) == 0)
-		goto add_ifs_character;
-	      else
-		goto add_character;
-	    }
-
-	  if (word->flags & W_ASSIGNRHS)
-	    tflag = 2;
-	  else if (word->flags & (W_ASSIGNMENT|W_TILDEEXP))
-	    tflag = 1;
-	  else
-	    tflag = 0;
-
-	  temp = bash_tilde_find_word (string + sindex, tflag, &t_index);
-	    
-	  internal_tilde = 0;
-
-	  if (temp && *temp && t_index > 0)
-	    {
-	      temp1 = bash_tilde_expand (temp, tflag);
-	      if  (temp1 && *temp1 == '~' && STREQ (temp, temp1))
-		{
-		  FREE (temp);
-		  FREE (temp1);
-		  goto add_character;		/* tilde expansion failed */
-		}
-	      free (temp);
-	      temp = temp1;
-	      sindex += t_index;
-	      goto add_quoted_string;		/* XXX was add_string */
-	    }
-	  else
-	    {
-	      FREE (temp);
-	      goto add_character;
-	    }
-	
-	case '$':
-	  if (expanded_something)
-	    *expanded_something = 1;
-	  local_expanded = 1;
-
-	  temp_has_dollar_at = 0;
-	  pflags = (word->flags & W_NOCOMSUB) ? PF_NOCOMSUB : 0;
-	  if (word->flags & W_NOSPLIT2)
-	    pflags |= PF_NOSPLIT2;
-	  if (word->flags & W_ASSIGNRHS)
-	    pflags |= PF_ASSIGNRHS;
-	  if (word->flags & W_COMPLETE)
-	    pflags |= PF_COMPLETE;
-
-	  tword = param_expand (string, &sindex, quoted, expanded_something,
-			       &temp_has_dollar_at, &quoted_dollar_at,
-			       &had_quoted_null, pflags);
-	  has_dollar_at += temp_has_dollar_at;
-	  split_on_spaces += (tword->flags & W_SPLITSPACE);
-
-	  if (tword == &expand_wdesc_error || tword == &expand_wdesc_fatal)
-	    {
-	      free (string);
-	      free (istring);
-	      return ((tword == &expand_wdesc_error) ? &expand_word_error
-						     : &expand_word_fatal);
-	    }
-	  if (contains_dollar_at && has_dollar_at)
-	    *contains_dollar_at = 1;
-
-	  if (tword && (tword->flags & W_HASQUOTEDNULL))
-	    had_quoted_null = 1;		/* note for later */
-	  if (tword && (tword->flags & W_SAWQUOTEDNULL))
-	    had_quoted_null = 1;		/* XXX */
-
-	  temp = tword ? tword->word : (char *)NULL;
-	  dispose_word_desc (tword);
-
-	  /* Kill quoted nulls; we will add them back at the end of
-	     expand_word_internal if nothing else in the string */
-	  if (had_quoted_null && temp && QUOTED_NULL (temp))
-	    {
-	      FREE (temp);
-	      temp = (char *)NULL;
-	    }
-
-	  goto add_string;
-	  break;
-
-	case '`':		/* Backquoted command substitution. */
-	  {
-	    t_index = sindex++;
-
-	    temp = string_extract (string, &sindex, "`", (word->flags & W_COMPLETE) ? SX_COMPLETE : SX_REQMATCH);
-	    /* The test of sindex against t_index is to allow bare instances of
-	       ` to pass through, for backwards compatibility. */
-	    if (temp == &extract_string_error || temp == &extract_string_fatal)
-	      {
-		if (sindex - 1 == t_index)
-		  {
-		    sindex = t_index;
-		    goto add_character;
-		  }
-		set_exit_status (EXECUTION_FAILURE);
-		report_error (_("bad substitution: no closing \"`\" in %s") , string+t_index);
-		free (string);
-		free (istring);
-		return ((temp == &extract_string_error) ? &expand_word_error
-							: &expand_word_fatal);
-	      }
-		
-	    if (expanded_something)
-	      *expanded_something = 1;
-	    local_expanded = 1;
-
-	    if (word->flags & W_NOCOMSUB)
-	      /* sindex + 1 because string[sindex] == '`' */
-	      temp1 = substring (string, t_index, sindex + 1);
-	    else
-	      {
-		de_backslash (temp);
-		tword = command_substitute (temp, quoted, 0);
-		temp1 = tword ? tword->word : (char *)NULL;
-		if (tword)
-		  dispose_word_desc (tword);
-	      }
-	    FREE (temp);
-	    temp = temp1;
-	    goto dollar_add_string;
-	  }
-
-	case '\\':
-	  if (string[sindex + 1] == '\n')
-	    {
-	      sindex += 2;
-	      continue;
-	    }
-
-	  c = string[++sindex];
-
-	  /* "However, the double-quote character ( '"' ) shall not be treated
-	     specially within a here-document, except when the double-quote
-	     appears within "$()", "``", or "${}"." */
-	  if ((quoted & Q_HERE_DOCUMENT) && (quoted & Q_DOLBRACE) && c == '"')
-	    tflag = CBSDQUOTE;		/* special case */
-	  else if (quoted & Q_HERE_DOCUMENT)
-	    tflag = CBSHDOC;
-	  else if (quoted & Q_DOUBLE_QUOTES)
-	    tflag = CBSDQUOTE;
-	  else
-	    tflag = 0;
-
-	  /* From Posix discussion on austin-group list:  Backslash escaping
-	     a } in ${...} is removed.  Issue 0000221 */
-	  if ((quoted & Q_DOLBRACE) && c == RBRACE)
-	    {
-	      SCOPY_CHAR_I (twochars, CTLESC, c, string, sindex, string_size);
-	    }
-	  /* This is the fix for " $@\ " */
-	  else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && ((sh_syntaxtab[c] & tflag) == 0) && isexp == 0 && isifs (c))
-	    {
-	      RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size,
-				      DEFAULT_ARRAY_SIZE);
-	      istring[istring_index++] = CTLESC;
-	      istring[istring_index++] = '\\';
-	      istring[istring_index] = '\0';
-
-	      SCOPY_CHAR_I (twochars, CTLESC, c, string, sindex, string_size);
-	    }
-	  else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && c == 0)
-	    {
-	      RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size,
-				      DEFAULT_ARRAY_SIZE);
-	      istring[istring_index++] = CTLESC;
-	      istring[istring_index++] = '\\';
-	      istring[istring_index] = '\0';
-	      break;	      
-	    }
-	  else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && ((sh_syntaxtab[c] & tflag) == 0))
-	    {
-	      SCOPY_CHAR_I (twochars, '\\', c, string, sindex, string_size);
-	    }
-	  else if (c == 0)
-	    {
-	      c = CTLNUL;
-	      sindex--;		/* add_character: label increments sindex */
-	      goto add_character;
-	    }
-	  else
-	    {
-	      SCOPY_CHAR_I (twochars, CTLESC, c, string, sindex, string_size);
-	    }
-
-	  sindex++;
-add_twochars:
-	  /* BEFORE jumping here, we need to increment sindex if appropriate */
-	  RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size,
-				  DEFAULT_ARRAY_SIZE);
-	  istring[istring_index++] = twochars[0];
-	  istring[istring_index++] = twochars[1];
-	  istring[istring_index] = '\0';
-
-	  break;
-
-	case '"':
-	  /* XXX - revisit this */
-	  if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) && ((quoted & Q_ARITH) == 0))
-	    goto add_character;
-
-	  t_index = ++sindex;
-	  temp = string_extract_double_quoted (string, &sindex, (word->flags & W_COMPLETE) ? SX_COMPLETE : 0);
-
-	  /* If the quotes surrounded the entire string, then the
-	     whole word was quoted. */
-	  quoted_state = (t_index == 1 && string[sindex] == '\0')
-			    ? WHOLLY_QUOTED
-			    : PARTIALLY_QUOTED;
-
-	  if (temp && *temp)
-	    {
-	      tword = alloc_word_desc ();
-	      tword->word = temp;
-
-	      if (word->flags & W_ASSIGNARG)
-		tword->flags |= word->flags & (W_ASSIGNARG|W_ASSIGNRHS); /* affects $@ */
-	      if (word->flags & W_COMPLETE)
-		tword->flags |= W_COMPLETE;	/* for command substitutions */
-	      if (word->flags & W_NOCOMSUB)
-		tword->flags |= W_NOCOMSUB;
-	      if (word->flags & W_NOPROCSUB)
-		tword->flags |= W_NOPROCSUB;
-
-	      if (word->flags & W_ASSIGNRHS)
-		tword->flags |= W_ASSIGNRHS;
-
-	      temp = (char *)NULL;
-
-	      temp_has_dollar_at = 0;	/* does this quoted (sub)string include $@? */
-	      /* Need to get W_HASQUOTEDNULL flag through this function. */
-	      /* XXX - preserve Q_ARITH here? */
-	      list = expand_word_internal (tword, Q_DOUBLE_QUOTES|(quoted&Q_ARITH), 0, &temp_has_dollar_at, (int *)NULL);
-	      has_dollar_at += temp_has_dollar_at;
-
-	      if (list == &expand_word_error || list == &expand_word_fatal)
-		{
-		  free (istring);
-		  free (string);
-		  /* expand_word_internal has already freed temp_word->word
-		     for us because of the way it prints error messages. */
-		  tword->word = (char *)NULL;
-		  dispose_word (tword);
-		  return list;
-		}
-
-	      dispose_word (tword);
-
-	      /* "$@" (a double-quoted dollar-at) expands into nothing,
-		 not even a NULL word, when there are no positional
-		 parameters.  Posix interp 888 says that other parts of the
-		 word that expand to quoted nulls result in quoted nulls, so
-		 we can't just throw the entire word away if we have "$@"
-		 anywhere in it.  We use had_quoted_null to keep track */
-	      if (list == 0 && temp_has_dollar_at)	/* XXX - was has_dollar_at */
-		{
-		  quoted_dollar_at++;
-		  break;
-		}
-
-	      /* If this list comes back with a quoted null from expansion,
-		 we have either "$x" or "$@" with $1 == ''. In either case,
-		 we need to make sure we add a quoted null argument and
-		 disable the special handling that "$@" gets. */
-	      if (list && list->word && list->next == 0 && (list->word->flags & W_HASQUOTEDNULL))
-		{
-		  if (had_quoted_null && temp_has_dollar_at)
-		    quoted_dollar_at++;
-		  had_quoted_null = 1;		/* XXX */
-		}
-
-	      /* If we get "$@", we know we have expanded something, so we
-		 need to remember it for the final split on $IFS.  This is
-		 a special case; it's the only case where a quoted string
-		 can expand into more than one word.  It's going to come back
-		 from the above call to expand_word_internal as a list with
-		 multiple words. */
-	      if (list)
-		dequote_list (list);
-
-	      if (temp_has_dollar_at)		/* XXX - was has_dollar_at */
-		{
-		  quoted_dollar_at++;
-		  if (contains_dollar_at)
-		    *contains_dollar_at = 1;
-		  if (expanded_something)
-		    *expanded_something = 1;
-		  local_expanded = 1;
-		}
-	    }
-	  else
-	    {
-	      /* What we have is "".  This is a minor optimization. */
-	      FREE (temp);
-	      list = (WORD_LIST *)NULL;
-	      had_quoted_null = 1;	/* note for later */
-	    }
-
-	  /* The code above *might* return a list (consider the case of "$@",
-	     where it returns "$1", "$2", etc.).  We can't throw away the
-	     rest of the list, and we have to make sure each word gets added
-	     as quoted.  We test on tresult->next:  if it is non-NULL, we
-	     quote the whole list, save it to a string with string_list, and
-	     add that string. We don't need to quote the results of this
-	     (and it would be wrong, since that would quote the separators
-	     as well), so we go directly to add_string. */
-	  if (list)
-	    {
-	      if (list->next)
-		{
-		  /* Testing quoted_dollar_at makes sure that "$@" is
-		     split correctly when $IFS does not contain a space. */
-		  temp = quoted_dollar_at
-				? string_list_dollar_at (list, Q_DOUBLE_QUOTES, 0)
-				: string_list (quote_list (list));
-		  dispose_words (list);
-		  goto add_string;
-		}
-	      else
-		{
-		  temp = savestring (list->word->word);
-		  tflag = list->word->flags;
-		  dispose_words (list);
-
-		  /* If the string is not a quoted null string, we want
-		     to remove any embedded unquoted CTLNUL characters.
-		     We do not want to turn quoted null strings back into
-		     the empty string, though.  We do this because we
-		     want to remove any quoted nulls from expansions that
-		     contain other characters.  For example, if we have
-		     x"$*"y or "x$*y" and there are no positional parameters,
-		     the $* should expand into nothing. */
-		  /* We use the W_HASQUOTEDNULL flag to differentiate the
-		     cases:  a quoted null character as above and when
-		     CTLNUL is contained in the (non-null) expansion
-		     of some variable.  We use the had_quoted_null flag to
-		     pass the value through this function to its caller. */
-		  if ((tflag & W_HASQUOTEDNULL) && QUOTED_NULL (temp) == 0)
-		    remove_quoted_nulls (temp);	/* XXX */
-		}
-	    }
-	  else
-	    temp = (char *)NULL;
-
-	  if (temp == 0 && quoted_state == PARTIALLY_QUOTED)
-	    had_quoted_null = 1;	/* note for later */
-
-	  /* We do not want to add quoted nulls to strings that are only
-	     partially quoted; we can throw them away.  The exception to
-	     this is when we are going to be performing word splitting,
-	     since we have to preserve a null argument if the next character
-	     will cause word splitting. */
-	  if (temp == 0 && quoted_state == PARTIALLY_QUOTED && quoted == 0 && (word->flags & (W_NOSPLIT|W_EXPANDRHS|W_ASSIGNRHS)) == W_EXPANDRHS)
-	    {
-	      c = CTLNUL;
-	      sindex--;
-	      had_quoted_null = 1;
-	      goto add_character;
-	    }
-	  if (temp == 0 && quoted_state == PARTIALLY_QUOTED && (word->flags & (W_NOSPLIT|W_NOSPLIT2)))
-	    continue;
-
-	add_quoted_string:
-
-	  if (temp)
-	    {
-	      temp1 = temp;
-	      temp = quote_string (temp);
-	      free (temp1);
-	      goto add_string;
-	    }
-	  else
-	    {
-	      /* Add NULL arg. */
-	      c = CTLNUL;
-	      sindex--;		/* add_character: label increments sindex */
-	      had_quoted_null = 1;	/* note for later */
-	      goto add_character;
-	    }
-
-	  /* break; */
-
-	case '\'':
-	  if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
-	    goto add_character;
-
-	  t_index = ++sindex;
-	  temp = string_extract_single_quoted (string, &sindex, 0);
-
-	  /* If the entire STRING was surrounded by single quotes,
-	     then the string is wholly quoted. */
-	  quoted_state = (t_index == 1 && string[sindex] == '\0')
-			    ? WHOLLY_QUOTED
-			    : PARTIALLY_QUOTED;
-
-	  /* If all we had was '', it is a null expansion. */
-	  if (*temp == '\0')
-	    {
-	      free (temp);
-	      temp = (char *)NULL;
-	    }
-	  else
-	    remove_quoted_escapes (temp);	/* ??? */
-
-	  if (temp == 0 && quoted_state == PARTIALLY_QUOTED)
-	    had_quoted_null = 1;	/* note for later */
-
-	  /* We do not want to add quoted nulls to strings that are only
-	     partially quoted; such nulls are discarded.  See above for the
-	     exception, which is when the string is going to be split.
-	     Posix interp 888/1129 */
-	  if (temp == 0 && quoted_state == PARTIALLY_QUOTED && quoted == 0 && (word->flags & (W_NOSPLIT|W_EXPANDRHS|W_ASSIGNRHS)) == W_EXPANDRHS)
-	    {
-	      c = CTLNUL;
-	      sindex--;
-	      goto add_character;
-	    }
-
-	  if (temp == 0 && (quoted_state == PARTIALLY_QUOTED) && (word->flags & (W_NOSPLIT|W_NOSPLIT2)))
-	    continue;
-
-	  /* If we have a quoted null expansion, add a quoted NULL to istring. */
-	  if (temp == 0)
-	    {
-	      c = CTLNUL;
-	      sindex--;		/* add_character: label increments sindex */
-	      goto add_character;
-	    }
-	  else
-	    goto add_quoted_string;
-
-	  /* break; */
-
-	case ' ':
-	  /* If we are in a context where the word is not going to be split, but
-	     we need to account for $@ and $* producing one word for each
-	     positional parameter, add quoted spaces so the spaces in the
-	     expansion of "$@", if any, behave correctly. We still may need to
-	     split if we are expanding the rhs of a word expansion. */
-	  if (ifs_is_null || split_on_spaces || ((word->flags & (W_NOSPLIT|W_NOSPLIT2|W_ASSIGNRHS)) && (word->flags & W_EXPANDRHS) == 0))
-	    {
-	      if (string[sindex])
-		sindex++;
-	      twochars[0] = CTLESC;
-	      twochars[1] = c;
-	      goto add_twochars;
-	    }
-	  /* FALLTHROUGH */
-	  
-	default:
-	  /* This is the fix for " $@ " */
-add_ifs_character:
-	  if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || (isexp == 0 && isifs (c) && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0))
-	    {
-	      if ((quoted&(Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0)
-		has_quoted_ifs++;
-add_quoted_character:
-	      if (string[sindex])	/* from old goto dollar_add_string */
-		sindex++;
-	      if (c == 0)
-		{
-		  c = CTLNUL;
-		  goto add_character;
-		}
-	      else
-		{
-#if HANDLE_MULTIBYTE
-		  /* XXX - should make sure that c is actually multibyte,
-		     otherwise we can use the twochars branch */
-		  if (mb_cur_max > 1)
-		    sindex--;
-
-		  if (mb_cur_max > 1)
-		    {
-		      SADD_MBQCHAR_BODY(temp, string, sindex, string_size);
-		    }
-		  else
-#endif
-		    {
-		      twochars[0] = CTLESC;
-		      twochars[1] = c;
-		      goto add_twochars;
-		    }
-		}
-	    }
-
-	  SADD_MBCHAR (temp, string, sindex, string_size);
-
-add_character:
-	  RESIZE_MALLOCED_BUFFER (istring, istring_index, 1, istring_size,
-				  DEFAULT_ARRAY_SIZE);
-	  istring[istring_index++] = c;
-	  istring[istring_index] = '\0';
-
-	  /* Next character. */
-	  sindex++;
-	}
-    }
-
-finished_with_string:
-  /* OK, we're ready to return.  If we have a quoted string, and
-     quoted_dollar_at is not set, we do no splitting at all; otherwise
-     we split on ' '.  The routines that call this will handle what to
-     do if nothing has been expanded. */
-
-  /* Partially and wholly quoted strings which expand to the empty
-     string are retained as an empty arguments.  Unquoted strings
-     which expand to the empty string are discarded.  The single
-     exception is the case of expanding "$@" when there are no
-     positional parameters.  In that case, we discard the expansion. */
-
-  /* Because of how the code that handles "" and '' in partially
-     quoted strings works, we need to make ISTRING into a QUOTED_NULL
-     if we saw quoting characters, but the expansion was empty.
-     "" and '' are tossed away before we get to this point when
-     processing partially quoted strings.  This makes "" and $xxx""
-     equivalent when xxx is unset.  We also look to see whether we
-     saw a quoted null from a ${} expansion and add one back if we
-     need to. */
-
-  /* If we expand to nothing and there were no single or double quotes
-     in the word, we throw it away.  Otherwise, we return a NULL word.
-     The single exception is for $@ surrounded by double quotes when
-     there are no positional parameters.  In that case, we also throw
-     the word away. */
-
-  if (*istring == '\0')
-    {
-#if 0
-      if (quoted_dollar_at == 0 && (had_quoted_null || quoted_state == PARTIALLY_QUOTED))
-#else
-      if (had_quoted_null || (quoted_dollar_at == 0 && quoted_state == PARTIALLY_QUOTED))
-#endif
-	{
-	  istring[0] = CTLNUL;
-	  istring[1] = '\0';
-	  tword = alloc_word_desc ();
-	  tword->word = istring;
-	  istring = 0;		/* avoid later free() */
-	  tword->flags |= W_HASQUOTEDNULL;		/* XXX */
-	  list = make_word_list (tword, (WORD_LIST *)NULL);
-	  if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-	    tword->flags |= W_QUOTED;
-	}
-      /* According to sh, ksh, and Posix.2, if a word expands into nothing
-	 and a double-quoted "$@" appears anywhere in it, then the entire
-	 word is removed. */
-      /* XXX - exception appears to be that quoted null strings result in
-	 null arguments */
-      else  if (quoted_state == UNQUOTED || quoted_dollar_at)
-	list = (WORD_LIST *)NULL;
-      else
-	list = (WORD_LIST *)NULL;
-    }
-  else if (word->flags & W_NOSPLIT)
-    {
-      tword = alloc_word_desc ();
-      tword->word = istring;
-      if (had_quoted_null && QUOTED_NULL (istring))
-	tword->flags |= W_HASQUOTEDNULL;
-      istring = 0;		/* avoid later free() */
-      if (word->flags & W_ASSIGNMENT)
-	tword->flags |= W_ASSIGNMENT;	/* XXX */
-      if (word->flags & W_COMPASSIGN)
-	tword->flags |= W_COMPASSIGN;	/* XXX */
-      if (word->flags & W_NOGLOB)
-	tword->flags |= W_NOGLOB;	/* XXX */
-      if (word->flags & W_NOBRACE)
-	tword->flags |= W_NOBRACE;	/* XXX */
-      if (word->flags & W_ARRAYREF)
-	tword->flags |= W_ARRAYREF;
-      if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
-	tword->flags |= W_QUOTED;
-      list = make_word_list (tword, (WORD_LIST *)NULL);
-    }
-  else if (word->flags & W_ASSIGNRHS)
-    {
-      list = list_string (istring, "", quoted);
-      tword = list->word;
-      if (had_quoted_null && QUOTED_NULL (istring))
-	tword->flags |= W_HASQUOTEDNULL;
-      free (list);
-      free (istring);
-      istring = 0;			/* avoid later free() */
-      goto set_word_flags;
-    }
-  else
-    {
-      char *ifs_chars;
-
-      ifs_chars = (quoted_dollar_at || has_dollar_at) ? ifs_value : (char *)NULL;
-
-      /* If we have $@, we need to split the results no matter what.  If
-	 IFS is unset or NULL, string_list_dollar_at has separated the
-	 positional parameters with a space, so we split on space (we have
-	 set ifs_chars to " \t\n" above if ifs is unset).  If IFS is set,
-	 string_list_dollar_at has separated the positional parameters
-	 with the first character of $IFS, so we split on $IFS.  If
-	 SPLIT_ON_SPACES is set, we expanded $* (unquoted) with IFS either
-	 unset or null, and we want to make sure that we split on spaces
-	 regardless of what else has happened to IFS since the expansion,
-	 or we expanded "$@" with IFS null and we need to split the positional
-	 parameters into separate words. */
-      if (split_on_spaces)
-	{
-	  /* If IFS is not set, and the word is not quoted, we want to split
-	     the individual words on $' \t\n'. We rely on previous steps to
-	     quote the portions of the word that should not be split */
-	  if (ifs_is_set == 0)
-	    list = list_string (istring, " \t\n", 1);	/* XXX quoted == 1? */
-	  else
-	    list = list_string (istring, " ", 1);	/* XXX quoted == 1? */
-	}
-
-      /* If we have $@ (has_dollar_at != 0) and we are in a context where we
-	 don't want to split the result (W_NOSPLIT2), and we are not quoted,
-	 we have already separated the arguments with the first character of
-	 $IFS.  In this case, we want to return a list with a single word
-	 with the separator possibly replaced with a space (it's what other
-	 shells seem to do).
-	 quoted_dollar_at is internal to this function and is set if we are
-	 passed an argument that is unquoted (quoted == 0) but we encounter a
-	 double-quoted $@ while expanding it. */
-      else if (has_dollar_at && quoted_dollar_at == 0 && ifs_chars && quoted == 0 && (word->flags & W_NOSPLIT2))
-	{
-	  tword = alloc_word_desc ();
-	  /* Only split and rejoin if we have to */
-	  if (*ifs_chars && *ifs_chars != ' ')
-	    {
-	      /* list_string dequotes CTLESCs in the string it's passed, so we
-		 need it to get the space separation right if space isn't the
-		 first character in IFS (but is present) and to remove the 
-		 quoting we added back in param_expand(). */
-	      list = list_string (istring, *ifs_chars ? ifs_chars : " ", 1);
-	      /* This isn't exactly right in the case where we're expanding
-		 the RHS of an expansion like ${var-$@} where IFS=: (for
-		 example). The W_NOSPLIT2 means we do the separation with :;
-		 the list_string removes the quotes and breaks the string into
-		 a list, and the string_list rejoins it on spaces. When we
-		 return, we expect to be able to split the results, but the
-		 space separation means the right split doesn't happen. */
-	      tword->word = string_list (list);	
-	    }
-	  else
-	    tword->word = istring;
-	  if (had_quoted_null && QUOTED_NULL (istring))
-	    tword->flags |= W_HASQUOTEDNULL;	/* XXX */
-	  if (tword->word != istring)
-	    free (istring);
-	  istring = 0;			/* avoid later free() */
-	  goto set_word_flags;
-	}
-      else if (has_dollar_at && ifs_chars)
-	list = list_string (istring, *ifs_chars ? ifs_chars : " ", 1);
-      else
-	{
-	  tword = alloc_word_desc ();
-	  if (expanded_something && *expanded_something == 0 && has_quoted_ifs)
-	    tword->word = remove_quoted_ifs (istring);
-	  else
-	    tword->word = istring;
-	  if (had_quoted_null && QUOTED_NULL (istring))	/* should check for more than one */
-	    tword->flags |= W_HASQUOTEDNULL;	/* XXX */
-	  else if (had_quoted_null)
-	    tword->flags |= W_SAWQUOTEDNULL;	/* XXX */
-	  if (tword->word != istring)
-	    free (istring);
-	  istring = 0;			/* avoid later free() */
-set_word_flags:
-	  if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) || (quoted_state == WHOLLY_QUOTED))
-	    tword->flags |= W_QUOTED;
-	  if (word->flags & W_ASSIGNMENT)
-	    tword->flags |= W_ASSIGNMENT;
-	  if (word->flags & W_COMPASSIGN)
-	    tword->flags |= W_COMPASSIGN;
-	  if (word->flags & W_NOGLOB)
-	    tword->flags |= W_NOGLOB;
-	  if (word->flags & W_NOBRACE)
-	    tword->flags |= W_NOBRACE;
-	  if (word->flags & W_ARRAYREF)
-	    tword->flags |= W_ARRAYREF;
-	  list = make_word_list (tword, (WORD_LIST *)NULL);
-	}
-    }
-
-  free (istring);
-  return (list);
-}
-
-/* **************************************************************** */
-/*								    */
-/*		   Functions for Quote Removal			    */
-/*								    */
-/* **************************************************************** */
-
-/* Perform quote removal on STRING.  If QUOTED > 0, assume we are obeying the
-   backslash quoting rules for within double quotes or a here document. */
-char *
-string_quote_removal (string, quoted)
-     char *string;
-     int quoted;
-{
-  size_t slen;
-  char *r, *result_string, *temp, *send;
-  int sindex, tindex, dquote;
-  unsigned char c;
-  DECLARE_MBSTATE;
-
-  /* The result can be no longer than the original string. */
-  slen = strlen (string);
-  send = string + slen;
-
-  r = result_string = (char *)xmalloc (slen + 1);
-
-  for (dquote = sindex = 0; c = string[sindex];)
-    {
-      switch (c)
-	{
-	case '\\':
-	  c = string[++sindex];
-	  if (c == 0)
-	    {
-	      *r++ = '\\';
-	      break;
-	    }
-	  if (((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || dquote) && (sh_syntaxtab[c] & CBSDQUOTE) == 0)
-	    *r++ = '\\';
-	  /* FALLTHROUGH */
-
-	default:
-	  SCOPY_CHAR_M (r, string, send, sindex);
-	  break;
-
-	case '\'':
-	  if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || dquote)
-	    {
-	      *r++ = c;
-	      sindex++;
-	      break;
-	    }
-	  tindex = sindex + 1;
-	  temp = string_extract_single_quoted (string, &tindex, 0);
-	  if (temp)
-	    {
-	      strcpy (r, temp);
-	      r += strlen (r);
-	      free (temp);
-	    }
-	  sindex = tindex;
-	  break;
-
-	case '"':
-	  dquote = 1 - dquote;
-	  sindex++;
-	  break;
-	}
-    }
-    *r = '\0';
-    return (result_string);
-}
-
-#if 0
-/* UNUSED */
-/* Perform quote removal on word WORD.  This allocates and returns a new
-   WORD_DESC *. */
-WORD_DESC *
-word_quote_removal (word, quoted)
-     WORD_DESC *word;
-     int quoted;
-{
-  WORD_DESC *w;
-  char *t;
-
-  t = string_quote_removal (word->word, quoted);
-  w = alloc_word_desc ();
-  w->word = t ? t : savestring ("");
-  return (w);
-}
-
-/* Perform quote removal on all words in LIST.  If QUOTED is non-zero,
-   the members of the list are treated as if they are surrounded by
-   double quotes.  Return a new list, or NULL if LIST is NULL. */
-WORD_LIST *
-word_list_quote_removal (list, quoted)
-     WORD_LIST *list;
-     int quoted;
-{
-  WORD_LIST *result, *t, *tresult, *e;
-
-  for (t = list, result = (WORD_LIST *)NULL; t; t = t->next)
-    {
-      tresult = make_word_list (word_quote_removal (t->word, quoted), (WORD_LIST *)NULL);
-#if 0
-      result = (WORD_LIST *) list_append (result, tresult);
-#else
-      if (result == 0)
-	result = e = tresult;
-      else
-	{
-	  e->next = tresult;
-	  while (e->next)
-	    e = e->next;
-	}
-#endif
-    }
-  return (result);
-}
-#endif
-
-/*******************************************
- *					   *
- *    Functions to perform word splitting  *
- *					   *
- *******************************************/
-
-void
-setifs (v)
-     SHELL_VAR *v;
-{
-  char *t;
-  unsigned char uc;
-
-  ifs_var = v;
-  ifs_value = (v && value_cell (v)) ? value_cell (v) : " \t\n";
-
-  ifs_is_set = ifs_var != 0;
-  ifs_is_null = ifs_is_set && (*ifs_value == 0);
-
-  /* Should really merge ifs_cmap with sh_syntaxtab.  XXX - doesn't yet
-     handle multibyte chars in IFS */
-  memset (ifs_cmap, '\0', sizeof (ifs_cmap));
-  for (t = ifs_value ; t && *t; t++)
-    {
-      uc = *t;
-      ifs_cmap[uc] = 1;
-    }
-
-#if defined (HANDLE_MULTIBYTE)
-  if (ifs_value == 0)
-    {
-      ifs_firstc[0] = '\0';	/* XXX - ? */
-      ifs_firstc_len = 1;
-    }
-  else
-    {
-      if (locale_utf8locale && UTF8_SINGLEBYTE (*ifs_value))
-	ifs_firstc_len = (*ifs_value != 0) ? 1 : 0;
-      else
-	{
-	  size_t ifs_len;
-	  ifs_len = strnlen (ifs_value, MB_CUR_MAX);
-	  ifs_firstc_len = MBLEN (ifs_value, ifs_len);
-	}
-      if (ifs_firstc_len == 1 || ifs_firstc_len == 0 || MB_INVALIDCH (ifs_firstc_len))
-	{
-	  ifs_firstc[0] = ifs_value[0];
-	  ifs_firstc[1] = '\0';
-	  ifs_firstc_len = 1;
-	}
-      else
-	memcpy (ifs_firstc, ifs_value, ifs_firstc_len);
-    }
-#else
-  ifs_firstc = ifs_value ? *ifs_value : 0;
-#endif
-}
-
-char *
-getifs ()
-{
-  return ifs_value;
-}
-
-/* This splits a single word into a WORD LIST on $IFS, but only if the word
-   is not quoted.  list_string () performs quote removal for us, even if we
-   don't do any splitting. */
-WORD_LIST *
-word_split (w, ifs_chars)
-     WORD_DESC *w;
-     char *ifs_chars;
-{
-  WORD_LIST *result;
-
-  if (w)
-    {
-      char *xifs;
-
-      xifs = ((w->flags & W_QUOTED) || ifs_chars == 0) ? "" : ifs_chars;
-      result = list_string (w->word, xifs, w->flags & W_QUOTED);
-    }
-  else
-    result = (WORD_LIST *)NULL;
-
-  return (result);
-}
-
-/* Perform word splitting on LIST and return the RESULT.  It is possible
-   to return (WORD_LIST *)NULL. */
-static WORD_LIST *
-word_list_split (list)
-     WORD_LIST *list;
-{
-  WORD_LIST *result, *t, *tresult, *e;
-  WORD_DESC *w;
-
-  for (t = list, result = (WORD_LIST *)NULL; t; t = t->next)
-    {
-      tresult = word_split (t->word, ifs_value);
-      /* POSIX 2.6: "If the complete expansion appropriate for a word results
-	 in an empty field, that empty field shall be deleted from the list
-	 of fields that form the completely expanded command, unless the
-	 original word contained single-quote or double-quote characters."
-	 This is where we handle these words that contain quoted null strings
-	 and other characters that expand to nothing after word splitting. */
-      if (tresult == 0 && t->word && (t->word->flags & W_SAWQUOTEDNULL))	/* XXX */
-	{
-	  w = alloc_word_desc ();
-	  w->word = (char *)xmalloc (1);
-	  w->word[0] = '\0';
-	  tresult = make_word_list (w, (WORD_LIST *)NULL);
-	}
-#if defined (ARRAY_VARS)
-      /* pass W_ARRAYREF through for words that are not split and are
-	 identical to the original word. */
-      if (tresult && tresult->next == 0 && t->next == 0 && (t->word->flags & W_ARRAYREF) && STREQ (t->word->word, tresult->word->word))
-	tresult->word->flags |= W_ARRAYREF;
-#endif
-      if (result == 0)
-        result = e = tresult;
-      else
-	{
-	  e->next = tresult;
-	  while (e->next)
-	    e = e->next;
-	}
-    }
-  return (result);
-}
-
-/**************************************************
- * 						  *
- *    Functions to expand an entire WORD_LIST	  *
- *						  *
- **************************************************/
-
-/* Do any word-expansion-specific cleanup and jump to top_level */
-static void
-exp_jump_to_top_level (v)
-     int v;
-{
-  set_pipestatus_from_exit (last_command_exit_value);
-
-  /* Cleanup code goes here. */
-  expand_no_split_dollar_star = 0;	/* XXX */
-  if (expanding_redir)
-    undo_partial_redirects ();
-  expanding_redir = 0;
-  assigning_in_environment = 0;
-
-  if (parse_and_execute_level == 0)
-    top_level_cleanup ();			/* from sig.c */
-
-  jump_to_top_level (v);
-}
-
-/* Put NLIST (which is a WORD_LIST * of only one element) at the front of
-   ELIST, and set ELIST to the new list. */
-#define PREPEND_LIST(nlist, elist) \
-	do { nlist->next = elist; elist = nlist; } while (0)
-
-/* Separate out any initial variable assignments from TLIST.  If set -k has
-   been executed, remove all assignment statements from TLIST.  Initial
-   variable assignments and other environment assignments are placed
-   on SUBST_ASSIGN_VARLIST. */
-static WORD_LIST *
-separate_out_assignments (tlist)
-     WORD_LIST *tlist;
-{
-  register WORD_LIST *vp, *lp;
-
-  if (tlist == 0)
-    return ((WORD_LIST *)NULL);
-
-  if (subst_assign_varlist)
-    dispose_words (subst_assign_varlist);	/* Clean up after previous error */
-
-  subst_assign_varlist = (WORD_LIST *)NULL;
-  vp = lp = tlist;
-
-  /* Separate out variable assignments at the start of the command.
-     Loop invariant: vp->next == lp
-     Loop postcondition:
-	lp = list of words left after assignment statements skipped
-	tlist = original list of words
-  */
-  while (lp && (lp->word->flags & W_ASSIGNMENT))
-    {
-      vp = lp;
-      lp = lp->next;
-    }
-
-  /* If lp != tlist, we have some initial assignment statements.
-     We make SUBST_ASSIGN_VARLIST point to the list of assignment
-     words and TLIST point to the remaining words.  */
-  if (lp != tlist)
-    {
-      subst_assign_varlist = tlist;
-      /* ASSERT(vp->next == lp); */
-      vp->next = (WORD_LIST *)NULL;	/* terminate variable list */
-      tlist = lp;			/* remainder of word list */
-    }
-
-  /* vp == end of variable list */
-  /* tlist == remainder of original word list without variable assignments */
-  if (!tlist)
-    /* All the words in tlist were assignment statements */
-    return ((WORD_LIST *)NULL);
-
-  /* ASSERT(tlist != NULL); */
-  /* ASSERT((tlist->word->flags & W_ASSIGNMENT) == 0); */
-
-  /* If the -k option is in effect, we need to go through the remaining
-     words, separate out the assignment words, and place them on
-     SUBST_ASSIGN_VARLIST. */
-  if (place_keywords_in_env)
-    {
-      WORD_LIST *tp;	/* tp == running pointer into tlist */
-
-      tp = tlist;
-      lp = tlist->next;
-
-      /* Loop Invariant: tp->next == lp */
-      /* Loop postcondition: tlist == word list without assignment statements */
-      while (lp)
-	{
-	  if (lp->word->flags & W_ASSIGNMENT)
-	    {
-	      /* Found an assignment statement, add this word to end of
-		 subst_assign_varlist (vp). */
-	      if (!subst_assign_varlist)
-		subst_assign_varlist = vp = lp;
-	      else
-		{
-		  vp->next = lp;
-		  vp = lp;
-		}
-
-	      /* Remove the word pointed to by LP from TLIST. */
-	      tp->next = lp->next;
-	      /* ASSERT(vp == lp); */
-	      lp->next = (WORD_LIST *)NULL;
-	      lp = tp->next;
-	    }
-	  else
-	    {
-	      tp = lp;
-	      lp = lp->next;
-	    }
-	}
-    }
-  return (tlist);
-}
-
-#define WEXP_VARASSIGN	0x001
-#define WEXP_BRACEEXP	0x002
-#define WEXP_TILDEEXP	0x004
-#define WEXP_PARAMEXP	0x008
-#define WEXP_PATHEXP	0x010
-
-/* All of the expansions, including variable assignments at the start of
-   the list. */
-#define WEXP_ALL	(WEXP_VARASSIGN|WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP|WEXP_PATHEXP)
-
-/* All of the expansions except variable assignments at the start of
-   the list. */
-#define WEXP_NOVARS	(WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP|WEXP_PATHEXP)
-
-/* All of the `shell expansions': brace expansion, tilde expansion, parameter
-   expansion, command substitution, arithmetic expansion, word splitting, and
-   quote removal. */
-#define WEXP_SHELLEXP	(WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP)
-
-/* Take the list of words in LIST and do the various substitutions.  Return
-   a new list of words which is the expanded list, and without things like
-   variable assignments. */
-
-WORD_LIST *
-expand_words (list)
-     WORD_LIST *list;
-{
-  return (expand_word_list_internal (list, WEXP_ALL));
-}
-
-/* Same as expand_words (), but doesn't hack variable or environment
-   variables. */
-WORD_LIST *
-expand_words_no_vars (list)
-     WORD_LIST *list;
-{
-  return (expand_word_list_internal (list, WEXP_NOVARS));
-}
-
-WORD_LIST *
-expand_words_shellexp (list)
-     WORD_LIST *list;
-{
-  return (expand_word_list_internal (list, WEXP_SHELLEXP));
-}
-
-static WORD_LIST *
-glob_expand_word_list (tlist, eflags)
-     WORD_LIST *tlist;
-     int eflags;
-{
-  char **glob_array, *temp_string;
-  register int glob_index;
-  WORD_LIST *glob_list, *output_list, *disposables, *next;
-  WORD_DESC *tword;
-  int x;
-
-  output_list = disposables = (WORD_LIST *)NULL;
-  glob_array = (char **)NULL;
-  while (tlist)
-    {
-      /* For each word, either globbing is attempted or the word is
-	 added to orig_list.  If globbing succeeds, the results are
-	 added to orig_list and the word (tlist) is added to the list
-	 of disposable words.  If globbing fails and failed glob
-	 expansions are left unchanged (the shell default), the
-	 original word is added to orig_list.  If globbing fails and
-	 failed glob expansions are removed, the original word is
-	 added to the list of disposable words.  orig_list ends up
-	 in reverse order and requires a call to REVERSE_LIST to
-	 be set right.  After all words are examined, the disposable
-	 words are freed. */
-      next = tlist->next;
-
-      /* If the word isn't an assignment and contains an unquoted
-	 pattern matching character, then glob it. */
-      if ((tlist->word->flags & W_NOGLOB) == 0 &&
-	  unquoted_glob_pattern_p (tlist->word->word))
-	{
-	  glob_array = shell_glob_filename (tlist->word->word, QGLOB_CTLESC);	/* XXX */
-
-	  /* Handle error cases.
-	     I don't think we should report errors like "No such file
-	     or directory".  However, I would like to report errors
-	     like "Read failed". */
-
-	  if (glob_array == 0 || GLOB_FAILED (glob_array))
-	    {
-	      glob_array = (char **)xmalloc (sizeof (char *));
-	      glob_array[0] = (char *)NULL;
-	    }
-
-	  /* Dequote the current word in case we have to use it. */
-	  if (glob_array[0] == NULL)
-	    {
-	      temp_string = dequote_string (tlist->word->word);
-	      free (tlist->word->word);
-	      tlist->word->word = temp_string;
-	    }
-
-	  /* Make the array into a word list. */
-	  glob_list = (WORD_LIST *)NULL;
-	  for (glob_index = 0; glob_array[glob_index]; glob_index++)
-	    {
-	      tword = make_bare_word (glob_array[glob_index]);
-	      glob_list = make_word_list (tword, glob_list);
-	    }
-
-	  if (glob_list)
-	    {
-	      output_list = (WORD_LIST *)list_append (glob_list, output_list);
-	      PREPEND_LIST (tlist, disposables);
-	    }
-	  else if (fail_glob_expansion != 0)
-	    {
-	      last_command_exit_value = EXECUTION_FAILURE;
-	      report_error (_("no match: %s"), tlist->word->word);
-	      exp_jump_to_top_level (DISCARD);
-	    }
-	  else if (allow_null_glob_expansion == 0)
-	    {
-	      /* Failed glob expressions are left unchanged. */
-	      PREPEND_LIST (tlist, output_list);
-	    }
-	  else
-	    {
-	      /* Failed glob expressions are removed. */
-	      PREPEND_LIST (tlist, disposables);
-	    }
-	}
-      else
-	{
-	  /* Dequote the string. */
-	  temp_string = dequote_string (tlist->word->word);
-	  free (tlist->word->word);
-	  tlist->word->word = temp_string;
-	  PREPEND_LIST (tlist, output_list);
-	}
-
-      strvec_dispose (glob_array);
-      glob_array = (char **)NULL;
-
-      tlist = next;
-    }
-
-  if (disposables)
-    dispose_words (disposables);
-
-  if (output_list)
-    output_list = REVERSE_LIST (output_list, WORD_LIST *);
-
-  return (output_list);
-}
-
-#if defined (BRACE_EXPANSION)
-static WORD_LIST *
-brace_expand_word_list (tlist, eflags)
-     WORD_LIST *tlist;
-     int eflags;
-{
-  register char **expansions;
-  char *temp_string;
-  WORD_LIST *disposables, *output_list, *next;
-  WORD_DESC *w;
-  int eindex;
-
-  for (disposables = output_list = (WORD_LIST *)NULL; tlist; tlist = next)
-    {
-      next = tlist->next;
-
-      if (tlist->word->flags & W_NOBRACE)
-        {
-/*itrace("brace_expand_word_list: %s: W_NOBRACE", tlist->word->word);*/
-	  PREPEND_LIST (tlist, output_list);
-	  continue;
-        }
-
-      if ((tlist->word->flags & (W_COMPASSIGN|W_ASSIGNARG)) == (W_COMPASSIGN|W_ASSIGNARG))
-        {
-/*itrace("brace_expand_word_list: %s: W_COMPASSIGN|W_ASSIGNARG", tlist->word->word);*/
-	  PREPEND_LIST (tlist, output_list);
-	  continue;
-        }
-
-      /* Only do brace expansion if the word has a brace character.  If
-	 not, just add the word list element to BRACES and continue.  In
-	 the common case, at least when running shell scripts, this will
-	 degenerate to a bunch of calls to `mbschr', and then what is
-	 basically a reversal of TLIST into BRACES, which is corrected
-	 by a call to REVERSE_LIST () on BRACES when the end of TLIST
-	 is reached. */
-      if (mbschr (tlist->word->word, LBRACE))
-	{
-	  expansions = brace_expand (tlist->word->word);
-
-	  for (eindex = 0; temp_string = expansions[eindex]; eindex++)
-	    {
-	      w = alloc_word_desc ();
-	      w->word = temp_string;
-
-	      /* If brace expansion didn't change the word, preserve
-		 the flags.  We may want to preserve the flags
-		 unconditionally someday -- XXX */
-	      if (STREQ (temp_string, tlist->word->word))
-		w->flags = tlist->word->flags;
-	      else
-		w = make_word_flags (w, temp_string);
-
-	      output_list = make_word_list (w, output_list);
-	    }
-	  free (expansions);
-
-	  /* Add TLIST to the list of words to be freed after brace
-	     expansion has been performed. */
-	  PREPEND_LIST (tlist, disposables);
-	}
-      else
-	PREPEND_LIST (tlist, output_list);
-    }
-
-  if (disposables)
-    dispose_words (disposables);
-
-  if (output_list)
-    output_list = REVERSE_LIST (output_list, WORD_LIST *);
-
-  return (output_list);
-}
-#endif
-
-#if defined (ARRAY_VARS)
-/* Take WORD, a compound array assignment, and internally run (for example),
-   'declare -A w', where W is the variable name portion of WORD. OPTION is
-   the list of options to supply to `declare'. CMD is the declaration command
-   we are expanding right now; it's unused currently. */
-static int
-make_internal_declare (word, option, cmd)
-     char *word;
-     char *option;
-     char *cmd;
-{
-  int t, r;
-  WORD_LIST *wl;
-  WORD_DESC *w;
-
-  w = make_word (word);
-
-  t = assignment (w->word, 0);
-  if (w->word[t] == '=')
-    {
-      w->word[t] = '\0';
-      if (w->word[t - 1] == '+')	/* cut off any append op */
-	w->word[t - 1] = '\0';
-    }
-
-  wl = make_word_list (w, (WORD_LIST *)NULL);
-  wl = make_word_list (make_word (option), wl);
-
-  r = declare_builtin (wl);
-
-  dispose_words (wl);
-  return r;
-}  
-
-/* Expand VALUE in NAME[+]=( VALUE ) to a list of words. FLAGS is 1 if NAME
-   is an associative array.
-
-   If we are  processing an indexed array, expand_compound_array_assignment
-   will expand all the individual words and quote_compound_array_list will
-   single-quote them. If we are processing an associative array, we use
-   parse_string_to_word_list to split VALUE into a list of words instead of
-   faking up a shell variable and calling expand_compound_array_assignment.
-   expand_and_quote_assoc_word expands and single-quotes each word in VALUE
-   together so we don't have problems finding the end of the subscript when
-   quoting it.
-
-   Words in VALUE can be individual words, which are expanded and single-quoted,
-   or words of the form [IND]=VALUE, which end up as explained below, as
-   ['expanded-ind']='expanded-value'. */
-
-static WORD_LIST *
-expand_oneword (value, flags)
-     char *value;
-     int flags;
-{
-  WORD_LIST *l, *nl;
-  char *t;
-  int kvpair;
-  
-  if (flags == 0)
-    {
-      /* Indexed array */
-      l = expand_compound_array_assignment ((SHELL_VAR *)NULL, value, flags);
-      /* Now we quote the results of the expansion above to prevent double
-	 expansion. */
-      quote_compound_array_list (l, flags);
-      return l;
-    }
-  else
-    {
-      /* Associative array */
-      l = parse_string_to_word_list (value, 1, "array assign");
-#if ASSOC_KVPAIR_ASSIGNMENT
-      kvpair = kvpair_assignment_p (l);
-#endif
-
-      /* For associative arrays, with their arbitrary subscripts, we have to
-	 expand and quote in one step so we don't have to search for the
-	 closing right bracket more than once. */
-      for (nl = l; nl; nl = nl->next)
-	{
-#if ASSOC_KVPAIR_ASSIGNMENT
-	  if (kvpair)
-	    /* keys and values undergo the same set of expansions */
-	    t = expand_and_quote_kvpair_word (nl->word->word);
-	  else
-#endif
-	  if ((nl->word->flags & W_ASSIGNMENT) == 0)
-	    t = sh_single_quote (nl->word->word ? nl->word->word : "");
-	  else
-	    t = expand_and_quote_assoc_word (nl->word->word, flags);
-	  free (nl->word->word);
-	  nl->word->word = t;
-	}
-      return l;
-    }
-}
-
-/* Expand a single compound assignment argument to a declaration builtin.
-   This word takes the form NAME[+]=( VALUE ). The NAME[+]= is passed through
-   unchanged. The VALUE is expanded and each word in the result is single-
-   quoted. Words of the form [key]=value end up as
-   ['expanded-key']='expanded-value'. Associative arrays have special
-   handling, see expand_oneword() above. The return value is
-   NAME[+]=( expanded-and-quoted-VALUE ). */
-static void
-expand_compound_assignment_word (tlist, flags)
-     WORD_LIST *tlist;
-     int flags;
-{
-  WORD_LIST *l;
-  int wlen, oind, t;
-  char *value, *temp;
-
-/*itrace("expand_compound_assignment_word: original word = -%s-", tlist->word->word);*/
-  t = assignment (tlist->word->word, 0);
-
-  /* value doesn't have the open and close parens */
-  oind = 1;
-  value = extract_array_assignment_list (tlist->word->word + t + 1, &oind);
-  /* This performs one round of expansion on the index/key and value and
-     single-quotes each word in the result. */
-  l = expand_oneword (value, flags);
-  free (value);
-
-  value = string_list (l);
-  dispose_words (l);
-
-  wlen = STRLEN (value);
-
-  /* Now, let's rebuild the string */
-  temp = xmalloc (t + 3 + wlen + 1);	/* name[+]=(value) */
-  memcpy (temp, tlist->word->word, ++t);
-  temp[t++] = '(';
-  if (value)
-    memcpy (temp + t, value, wlen);
-  t += wlen;
-  temp[t++] = ')';
-  temp[t] = '\0';
-/*itrace("expand_compound_assignment_word: reconstructed word = -%s-", temp);*/
-
-  free (tlist->word->word);
-  tlist->word->word = temp;
-
-  free (value);
-}
-
-/* Expand and process an argument to a declaration command. We have already
-   set flags in TLIST->word->flags depending on the declaration command
-   (declare, local, etc.) and the options supplied to it (-a, -A, etc.).
-   TLIST->word->word is of the form NAME[+]=( VALUE ).   
-
-   This does several things, all using pieces of other functions to get the
-   evaluation sequence right. It's called for compound array assignments with
-   the W_ASSIGNMENT flag set (basically, valid identifier names on the lhs).
-   It parses out which flags need to be set for declare to create the variable
-   correctly, then calls declare internally (make_internal_declare) to make
-   sure the variable exists with the correct attributes. Before the variable
-   is created, it calls expand_compound_assignment_word to expand VALUE to a
-   list of words, appropriately quoted for further evaluation. This preserves
-   the semantics of word-expansion-before-calling-builtins. Finally, it calls
-   do_word_assignment to perform the expansion and assignment with the same
-   expansion semantics as a standalone assignment statement (no word splitting,
-   etc.) even though the word is single-quoted so all that needs to happen is
-   quote removal. */
-static WORD_LIST *
-expand_declaration_argument (tlist, wcmd)
-     WORD_LIST *tlist, *wcmd;
-{
-  char opts[16], omap[128];
-  int t, opti, oind, skip, inheriting;
-  WORD_LIST *l;
-
-  inheriting = localvar_inherit;
-  opti = 0;
-  if (tlist->word->flags & (W_ASSIGNASSOC|W_ASSNGLOBAL|W_CHKLOCAL|W_ASSIGNARRAY))
-    opts[opti++] = '-';
-
-  if ((tlist->word->flags & (W_ASSIGNASSOC|W_ASSNGLOBAL)) == (W_ASSIGNASSOC|W_ASSNGLOBAL))
-    {
-      opts[opti++] = 'g';
-      opts[opti++] = 'A';
-    }
-  else if (tlist->word->flags & W_ASSIGNASSOC)
-    {
-      opts[opti++] = 'A';
-    }
-  else if ((tlist->word->flags & (W_ASSIGNARRAY|W_ASSNGLOBAL)) == (W_ASSIGNARRAY|W_ASSNGLOBAL))
-    {
-      opts[opti++] = 'g';
-      opts[opti++] = 'a';
-    }
-  else if (tlist->word->flags & W_ASSIGNARRAY)
-    {
-      opts[opti++] = 'a';
-    }
-  else if (tlist->word->flags & W_ASSNGLOBAL)
-    opts[opti++] = 'g';
-
-  if (tlist->word->flags & W_CHKLOCAL)
-    opts[opti++] = 'G';
-
-  /* If we have special handling note the integer attribute and others
-     that transform the value upon assignment.  What we do is take all
-     of the option arguments and scan through them looking for options
-     that cause such transformations, and add them to the `opts' array. */
-
-  memset (omap, '\0', sizeof (omap));
-  for (l = wcmd->next; l != tlist; l = l->next)
-    {
-      int optchar;
-
-      if (l->word->word[0] != '-' && l->word->word[0] != '+')
-	break;	/* non-option argument */
-      if (l->word->word[0] == '-' && l->word->word[1] == '-' && l->word->word[2] == 0)
-	break;	/* -- signals end of options */
-      optchar = l->word->word[0];
-      for (oind = 1; l->word->word[oind]; oind++)
-	switch (l->word->word[oind])
-	  {
-	    case 'I':
-	      inheriting = 1;
-	    case 'i':
-	    case 'l':
-	    case 'u':
-	    case 'c':
-	      omap[l->word->word[oind]] = 1;
-	      if (opti == 0)
-		opts[opti++] = optchar;
-	      break;
-	    default:
-	      break;
-	  }
-    }
-
-  for (oind = 0; oind < sizeof (omap); oind++)
-    if (omap[oind])
-      opts[opti++] = oind;
-
-  /* If there are no -a/-A options, but we have a compound assignment,
-     we have a choice: we can set opts[0]='-', opts[1]='a', since the
-     default is to create an indexed array, and call
-     make_internal_declare with that, or we can just skip the -a and let
-     declare_builtin deal with it.  Once we're here, we're better set
-     up for the latter, since we don't want to deal with looking up
-     any existing variable here -- better to let declare_builtin do it.
-     We need the variable created, though, especially if it's local, so
-     we get the scoping right before we call do_word_assignment.
-     To ensure that make_local_declare gets called, we add `--' if there
-     aren't any options. */
-  if ((tlist->word->flags & (W_ASSIGNASSOC|W_ASSIGNARRAY)) == 0)
-    {
-      if (opti == 0)
-	{
-	  opts[opti++] = '-';
-          opts[opti++] = '-';
-	}
-    }
-  opts[opti] = '\0';
-
-  /* This isn't perfect, but it's a start. Improvements later. We expand
-     tlist->word->word and single-quote the results to avoid multiple
-     expansions by, say, do_assignment_internal(). We have to weigh the
-     cost of reconstructing the compound assignment string with its single
-     quoting and letting the declare builtin handle it. The single quotes
-     will prevent any unwanted additional expansion or word splitting. */
-  expand_compound_assignment_word (tlist, (tlist->word->flags & W_ASSIGNASSOC) ? 1 : 0);
-
-  skip = 0;
-  if (opti > 0)
-    {
-      t = make_internal_declare (tlist->word->word, opts, wcmd ? wcmd->word->word : (char *)0);
-      if (t != EXECUTION_SUCCESS)
-	{
-	  last_command_exit_value = t;
-	  if (tlist->word->flags & W_FORCELOCAL)	/* non-fatal error */
-	    skip = 1;
-	  else
-	    exp_jump_to_top_level (DISCARD);
-	}
-    }
-
-  if (skip == 0)
-    {
-      t = do_word_assignment (tlist->word, 0);
-      if (t == 0)
-	{
-	  last_command_exit_value = EXECUTION_FAILURE;
-	  exp_jump_to_top_level (DISCARD);
-	}
-    }
-
-  /* Now transform the word as ksh93 appears to do and go on */
-  t = assignment (tlist->word->word, 0);
-  tlist->word->word[t] = '\0';
-  if (tlist->word->word[t - 1] == '+')
-    tlist->word->word[t - 1] = '\0';	/* cut off append op */
-  tlist->word->flags &= ~(W_ASSIGNMENT|W_NOSPLIT|W_COMPASSIGN|W_ASSIGNARG|W_ASSIGNASSOC|W_ASSIGNARRAY);
-
-  return (tlist);
-}
-#endif /* ARRAY_VARS */
-
-static WORD_LIST *
-shell_expand_word_list (tlist, eflags)
-     WORD_LIST *tlist;
-     int eflags;
-{
-  WORD_LIST *expanded, *orig_list, *new_list, *next, *temp_list, *wcmd;
-  int expanded_something, has_dollar_at;
-
-  /* We do tilde expansion all the time.  This is what 1003.2 says. */
-  wcmd = new_list = (WORD_LIST *)NULL;
-
-  for (orig_list = tlist; tlist; tlist = next)
-    {
-      if (wcmd == 0 && (tlist->word->flags & W_ASSNBLTIN))
-	wcmd = tlist;
-	
-      next = tlist->next;
-
-#if defined (ARRAY_VARS)
-      /* If this is a compound array assignment to a builtin that accepts
-         such assignments (e.g., `declare'), take the assignment and perform
-         it separately, handling the semantics of declarations inside shell
-         functions.  This avoids the double-evaluation of such arguments,
-         because `declare' does some evaluation of compound assignments on
-         its own. */
-      if ((tlist->word->flags & (W_COMPASSIGN|W_ASSIGNARG)) == (W_COMPASSIGN|W_ASSIGNARG))
-	expand_declaration_argument (tlist, wcmd);
-#endif
-
-      expanded_something = 0;
-      expanded = expand_word_internal
-	(tlist->word, 0, 0, &has_dollar_at, &expanded_something);
-
-      if (expanded == &expand_word_error || expanded == &expand_word_fatal)
-	{
-	  /* By convention, each time this error is returned,
-	     tlist->word->word has already been freed. */
-	  tlist->word->word = (char *)NULL;
-
-	  /* Dispose our copy of the original list. */
-	  dispose_words (orig_list);
-	  /* Dispose the new list we're building. */
-	  dispose_words (new_list);
-
-	  last_command_exit_value = EXECUTION_FAILURE;
-	  if (expanded == &expand_word_error)
-	    exp_jump_to_top_level (DISCARD);
-	  else
-	    exp_jump_to_top_level (FORCE_EOF);
-	}
-
-      /* Don't split words marked W_NOSPLIT. */
-      if (expanded_something && (tlist->word->flags & W_NOSPLIT) == 0)
-	{
-	  temp_list = word_list_split (expanded);
-	  dispose_words (expanded);
-	}
-      else
-	{
-	  /* If no parameter expansion, command substitution, process
-	     substitution, or arithmetic substitution took place, then
-	     do not do word splitting.  We still have to remove quoted
-	     null characters from the result. */
-	  word_list_remove_quoted_nulls (expanded);
-	  temp_list = expanded;
-	}
-
-      expanded = REVERSE_LIST (temp_list, WORD_LIST *);
-      new_list = (WORD_LIST *)list_append (expanded, new_list);
-    }
-
-  if (orig_list)  
-    dispose_words (orig_list);
-
-  if (new_list)
-    new_list = REVERSE_LIST (new_list, WORD_LIST *);
-
-  return (new_list);
-}
-
-/* Perform assignment statements optionally preceding a command name COMMAND.
-   If COMMAND == NULL, is_nullcmd usually == 1. Follow the POSIX rules for
-   variable assignment errors. */
-static int
-do_assignment_statements (varlist, command, is_nullcmd)
-     WORD_LIST *varlist;
-     char *command;
-     int is_nullcmd;
-{
-  WORD_LIST *temp_list;
-  char *savecmd;
-  sh_wassign_func_t *assign_func;
-  int is_special_builtin, is_builtin_or_func, tint;
-
-  /* If the remainder of the words expand to nothing, Posix.2 requires
-     that the variable and environment assignments affect the shell's
-     environment (do_word_assignment). */
-  assign_func = is_nullcmd ? do_word_assignment : assign_in_env;
-  tempenv_assign_error = 0;
-
-  is_builtin_or_func = command && (find_shell_builtin (command) || find_function (command));
-  /* Posix says that special builtins exit if a variable assignment error
-     occurs in an assignment preceding it. (XXX - this is old -- current Posix
-     says that any variable assignment error causes a non-interactive shell
-     to exit. See the STRICT_POSIX checks below. */
-  is_special_builtin = posixly_correct && command && find_special_builtin (command);
-
-  savecmd = this_command_name;
-  for (temp_list = varlist; temp_list; temp_list = temp_list->next)
-    {
-      this_command_name = (char *)NULL;
-      assigning_in_environment = is_nullcmd == 0;
-      tint = (*assign_func) (temp_list->word, is_builtin_or_func);
-      assigning_in_environment = 0;
-      this_command_name = savecmd;
-
-      /* Variable assignment errors in non-interactive shells running
-	 in posix mode cause the shell to exit. */
-      if (tint == 0)
-	{
-	  if (is_nullcmd)	/* assignment statement */
-	    {
-	      last_command_exit_value = EXECUTION_FAILURE;
-#if defined (STRICT_POSIX)
-	      if (posixly_correct && interactive_shell == 0)
-#else
-	      if (posixly_correct && interactive_shell == 0 && executing_command_builtin == 0)
-#endif
-	        exp_jump_to_top_level (FORCE_EOF);
-	      else
-		exp_jump_to_top_level (DISCARD);
-	    }
-	  /* In posix mode, assignment errors in the temporary environment
-	     cause a non-interactive shell executing a special builtin to
-	     exit and a non-interactive shell to otherwise jump back to the
-	     top level. This is what POSIX says to do for variable assignment
-	     errors, and POSIX says errors in assigning to the temporary
-	     environment are treated as variable assignment errors.
-	     (XXX - this is not what current POSIX says - look at the
-	     STRICT_POSIX defines. */
-	  else if (posixly_correct)
-	    {
-	      last_command_exit_value = EXECUTION_FAILURE;
-#if defined (STRICT_POSIX)
-	      exp_jump_to_top_level ((interactive_shell == 0) ? FORCE_EOF : DISCARD);
-#else
-	      if (interactive_shell == 0 && is_special_builtin)
-		exp_jump_to_top_level (FORCE_EOF);
-	      else if (interactive_shell == 0)
-		exp_jump_to_top_level (DISCARD);	/* XXX - maybe change later */
-	      else
-		exp_jump_to_top_level (DISCARD);
-#endif
-	    }
-	  else
-	    tempenv_assign_error++;
-	}
-    }
-  return (tempenv_assign_error);
-}
-
-/* The workhorse for expand_words () and expand_words_no_vars ().
-   First arg is LIST, a WORD_LIST of words.
-   Second arg EFLAGS is a flags word controlling which expansions are
-   performed.
-
-   This does all of the substitutions: brace expansion, tilde expansion,
-   parameter expansion, command substitution, arithmetic expansion,
-   process substitution, word splitting, and pathname expansion, according
-   to the bits set in EFLAGS.  Words with the W_QUOTED or W_NOSPLIT bits
-   set, or for which no expansion is done, do not undergo word splitting.
-   Words with the W_NOGLOB bit set do not undergo pathname expansion; words
-   with W_NOBRACE set do not undergo brace expansion (see
-   brace_expand_word_list above). */
-static WORD_LIST *
-expand_word_list_internal (list, eflags)
-     WORD_LIST *list;
-     int eflags;
-{
-  WORD_LIST *new_list, *temp_list;
-
-  tempenv_assign_error = 0;
-  if (list == 0)
-    return ((WORD_LIST *)NULL);
-
-  garglist = new_list = copy_word_list (list);
-  if (eflags & WEXP_VARASSIGN)
-    {
-      garglist = new_list = separate_out_assignments (new_list);
-      if (new_list == 0)
-	{
-	  if (subst_assign_varlist)
-	    do_assignment_statements (subst_assign_varlist, (char *)NULL, 1);
-	    
-	  dispose_words (subst_assign_varlist);
-	  subst_assign_varlist = (WORD_LIST *)NULL;
-
-	  return ((WORD_LIST *)NULL);
-	}
-    }
-
-  /* Begin expanding the words that remain.  The expansions take place on
-     things that aren't really variable assignments. */
-
-#if defined (BRACE_EXPANSION)
-  /* Do brace expansion on this word if there are any brace characters
-     in the string. */
-  if ((eflags & WEXP_BRACEEXP) && brace_expansion && new_list)
-    new_list = brace_expand_word_list (new_list, eflags);
-#endif /* BRACE_EXPANSION */
-
-  /* Perform the `normal' shell expansions: tilde expansion, parameter and
-     variable substitution, command substitution, arithmetic expansion,
-     and word splitting. */
-  new_list = shell_expand_word_list (new_list, eflags);
-
-  /* Okay, we're almost done.  Now let's just do some filename
-     globbing. */
-  if (new_list)
-    {
-      if ((eflags & WEXP_PATHEXP) && disallow_filename_globbing == 0)
-	/* Glob expand the word list unless globbing has been disabled. */
-	new_list = glob_expand_word_list (new_list, eflags);
-      else
-	/* Dequote the words, because we're not performing globbing. */
-	new_list = dequote_list (new_list);
-    }
-
-  if ((eflags & WEXP_VARASSIGN) && subst_assign_varlist)
-    {
-      do_assignment_statements (subst_assign_varlist, (new_list && new_list->word) ? new_list->word->word : (char *)NULL, new_list == 0);
-
-      dispose_words (subst_assign_varlist);
-      subst_assign_varlist = (WORD_LIST *)NULL;
-    }
-
-  return (new_list);
-}
diff --git a/third_party/bash/subst.h b/third_party/bash/subst.h
deleted file mode 100644
index 28cc92031..000000000
--- a/third_party/bash/subst.h
+++ /dev/null
@@ -1,362 +0,0 @@
-/* subst.h -- Names of externally visible functions in subst.c. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_SUBST_H_)
-#define _SUBST_H_
-
-#include "stdc.h"
-
-/* Constants which specify how to handle backslashes and quoting in
-   expand_word_internal ().  Q_DOUBLE_QUOTES means to use the function
-   slashify_in_quotes () to decide whether the backslash should be
-   retained.  Q_HERE_DOCUMENT means slashify_in_here_document () to
-   decide whether to retain the backslash.  Q_KEEP_BACKSLASH means
-   to unconditionally retain the backslash.  Q_PATQUOTE means that we're
-   expanding a pattern ${var%#[#%]pattern} in an expansion surrounded
-   by double quotes. Q_DOLBRACE means we are expanding a ${...} word, so
-   backslashes should also escape { and } and be removed. */
-#define Q_DOUBLE_QUOTES  0x001
-#define Q_HERE_DOCUMENT  0x002
-#define Q_KEEP_BACKSLASH 0x004
-#define Q_PATQUOTE	 0x008
-#define Q_QUOTED	 0x010
-#define Q_ADDEDQUOTES	 0x020
-#define Q_QUOTEDNULL	 0x040
-#define Q_DOLBRACE	 0x080
-#define Q_ARITH		 0x100	/* expanding string for arithmetic evaluation */
-#define Q_ARRAYSUB	 0x200	/* expanding indexed array subscript */
-
-/* Flag values controlling how assignment statements are treated. */
-#define ASS_APPEND	0x0001
-#define ASS_MKLOCAL	0x0002
-#define ASS_MKASSOC	0x0004
-#define ASS_MKGLOBAL	0x0008	/* force global assignment */
-#define ASS_NAMEREF	0x0010	/* assigning to nameref variable */
-#define ASS_FORCE	0x0020	/* force assignment even to readonly variable */
-#define ASS_CHKLOCAL	0x0040	/* check local variable before assignment */
-#define ASS_NOEXPAND	0x0080	/* don't expand associative array subscripts */
-#define ASS_NOEVAL	0x0100	/* don't evaluate value as expression */
-#define ASS_NOLONGJMP	0x0200	/* don't longjmp on fatal assignment error */
-#define ASS_NOINVIS	0x0400	/* don't resolve local invisible variables */
-#define ASS_ALLOWALLSUB	0x0800	/* allow * and @ as associative array keys */
-#define ASS_ONEWORD	0x1000	/* don't check array subscripts, assume higher level has done that */
-
-/* Flags for the string extraction functions. */
-#define SX_NOALLOC	0x0001	/* just skip; don't return substring */
-#define SX_VARNAME	0x0002	/* variable name; for string_extract () */
-#define SX_REQMATCH	0x0004	/* closing/matching delimiter required */
-#define SX_COMMAND	0x0008	/* extracting a shell script/command */
-#define SX_NOCTLESC	0x0010	/* don't honor CTLESC quoting */
-#define SX_NOESCCTLNUL	0x0020	/* don't let CTLESC quote CTLNUL */
-#define SX_NOLONGJMP	0x0040	/* don't longjmp on fatal error */
-#define SX_ARITHSUB	0x0080	/* extracting $(( ... )) (currently unused) */
-#define SX_POSIXEXP	0x0100	/* extracting new Posix pattern removal expansions in extract_dollar_brace_string */
-#define SX_WORD		0x0200	/* extracting word in ${param op word} */
-#define SX_COMPLETE	0x0400	/* extracting word for completion */
-#define SX_STRIPDQ	0x0800	/* strip double quotes when extracting double-quoted string */
-#define SX_NOERROR	0x1000	/* don't print parser error messages */
-
-/* Remove backslashes which are quoting backquotes from STRING.  Modifies
-   STRING, and returns a pointer to it. */
-extern char * de_backslash PARAMS((char *));
-
-/* Replace instances of \! in a string with !. */
-extern void unquote_bang PARAMS((char *));
-
-/* Extract the $( construct in STRING, and return a new string.
-   Start extracting at (SINDEX) as if we had just seen "$(".
-   Make (SINDEX) get the position just after the matching ")".
-   XFLAGS is additional flags to pass to other extraction functions, */
-extern char *extract_command_subst PARAMS((char *, int *, int));
-
-/* Extract the $[ construct in STRING, and return a new string.
-   Start extracting at (SINDEX) as if we had just seen "$[".
-   Make (SINDEX) get the position just after the matching "]". */
-extern char *extract_arithmetic_subst PARAMS((char *, int *));
-
-#if defined (PROCESS_SUBSTITUTION)
-/* Extract the <( or >( construct in STRING, and return a new string.
-   Start extracting at (SINDEX) as if we had just seen "<(".
-   Make (SINDEX) get the position just after the matching ")". */
-extern char *extract_process_subst PARAMS((char *, char *, int *, int));
-#endif /* PROCESS_SUBSTITUTION */
-
-/* Extract the name of the variable to bind to from the assignment string. */
-extern char *assignment_name PARAMS((char *));
-
-/* Return a single string of all the words present in LIST, separating
-   each word with SEP. */
-extern char *string_list_internal PARAMS((WORD_LIST *, char *));
-
-/* Return a single string of all the words present in LIST, separating
-   each word with a space. */
-extern char *string_list PARAMS((WORD_LIST *));
-
-/* Turn $* into a single string, obeying POSIX rules. */
-extern char *string_list_dollar_star PARAMS((WORD_LIST *, int, int));
-
-/* Expand $@ into a single string, obeying POSIX rules. */
-extern char *string_list_dollar_at PARAMS((WORD_LIST *, int, int));
-
-/* Turn the positional parameters into a string, understanding quoting and
-   the various subtleties of using the first character of $IFS as the
-   separator.  Calls string_list_dollar_at, string_list_dollar_star, and
-   string_list as appropriate. */
-extern char *string_list_pos_params PARAMS((int, WORD_LIST *, int, int));
-
-/* Perform quoted null character removal on each element of LIST.
-   This modifies LIST. */
-extern void word_list_remove_quoted_nulls PARAMS((WORD_LIST *));
-
-/* This performs word splitting and quoted null character removal on
-   STRING. */
-extern WORD_LIST *list_string PARAMS((char *, char *, int));
-
-extern char *ifs_firstchar  PARAMS((int *));
-extern char *get_word_from_string PARAMS((char **, char *, char **));
-extern char *strip_trailing_ifs_whitespace PARAMS((char *, char *, int));
-
-/* Given STRING, an assignment string, get the value of the right side
-   of the `=', and bind it to the left side.  If EXPAND is true, then
-   perform tilde expansion, parameter expansion, command substitution,
-   and arithmetic expansion on the right-hand side.  Do not perform word
-   splitting on the result of expansion. */
-extern int do_assignment PARAMS((char *));
-extern int do_assignment_no_expand PARAMS((char *));
-extern int do_word_assignment PARAMS((WORD_DESC *, int));
-
-/* Append SOURCE to TARGET at INDEX.  SIZE is the current amount
-   of space allocated to TARGET.  SOURCE can be NULL, in which
-   case nothing happens.  Gets rid of SOURCE by free ()ing it.
-   Returns TARGET in case the location has changed. */
-extern char *sub_append_string PARAMS((char *, char *, size_t *, size_t *));
-
-/* Append the textual representation of NUMBER to TARGET.
-   INDEX and SIZE are as in SUB_APPEND_STRING. */
-extern char *sub_append_number PARAMS((intmax_t, char *, int *, int *));
-
-/* Return the word list that corresponds to `$*'. */
-extern WORD_LIST *list_rest_of_args PARAMS((void));
-
-/* Make a single large string out of the dollar digit variables,
-   and the rest_of_args.  If DOLLAR_STAR is 1, then obey the special
-   case of "$*" with respect to IFS. */
-extern char *string_rest_of_args PARAMS((int));
-
-/* Expand STRING by performing parameter expansion, command substitution,
-   and arithmetic expansion.  Dequote the resulting WORD_LIST before
-   returning it, but do not perform word splitting.  The call to
-   remove_quoted_nulls () is made here because word splitting normally
-   takes care of quote removal. */
-extern WORD_LIST *expand_string_unsplit PARAMS((char *, int));
-
-/* Expand the rhs of an assignment statement. */
-extern WORD_LIST *expand_string_assignment PARAMS((char *, int));
-
-/* Expand a prompt string. */
-extern WORD_LIST *expand_prompt_string PARAMS((char *, int, int));
-
-/* Expand STRING just as if you were expanding a word.  This also returns
-   a list of words.  Note that filename globbing is *NOT* done for word
-   or string expansion, just when the shell is expanding a command.  This
-   does parameter expansion, command substitution, arithmetic expansion,
-   and word splitting.  Dequote the resultant WORD_LIST before returning. */
-extern WORD_LIST *expand_string PARAMS((char *, int));
-
-/* Convenience functions that expand strings to strings, taking care of
-   converting the WORD_LIST * returned by the expand_string* functions
-   to a string and deallocating the WORD_LIST *. */
-extern char *expand_string_to_string PARAMS((char *, int));
-extern char *expand_string_unsplit_to_string PARAMS((char *, int));
-extern char *expand_assignment_string_to_string PARAMS((char *, int));
-extern char *expand_subscript_string PARAMS((char *, int));
-
-/* Expand an arithmetic expression string */
-extern char *expand_arith_string PARAMS((char *, int));
-
-/* Expand $'...' and $"..." in a string for code paths that do not. */
-extern char *expand_string_dollar_quote PARAMS((char *, int));
-
-/* De-quote quoted characters in STRING. */
-extern char *dequote_string PARAMS((char *));
-
-/* De-quote CTLESC-escaped CTLESC or CTLNUL characters in STRING. */
-extern char *dequote_escapes PARAMS((const char *));
-
-extern WORD_DESC *dequote_word PARAMS((WORD_DESC *));
-
-/* De-quote quoted characters in each word in LIST. */
-extern WORD_LIST *dequote_list PARAMS((WORD_LIST *));
-
-/* Expand WORD, performing word splitting on the result.  This does
-   parameter expansion, command substitution, arithmetic expansion,
-   word splitting, and quote removal. */
-extern WORD_LIST *expand_word PARAMS((WORD_DESC *, int));
-
-/* Expand WORD, but do not perform word splitting on the result.  This
-   does parameter expansion, command substitution, arithmetic expansion,
-   and quote removal. */
-extern WORD_LIST *expand_word_unsplit PARAMS((WORD_DESC *, int));
-extern WORD_LIST *expand_word_leave_quoted PARAMS((WORD_DESC *, int));
-
-/* Return the value of a positional parameter.  This handles values > 10. */
-extern char *get_dollar_var_value PARAMS((intmax_t));
-
-/* Quote a string to protect it from word splitting. */
-extern char *quote_string PARAMS((char *));
-
-/* Quote escape characters (characters special to internals of expansion)
-   in a string. */
-extern char *quote_escapes PARAMS((const char *));
-
-/* And remove such quoted special characters. */
-extern char *remove_quoted_escapes PARAMS((char *));
-
-/* Remove CTLNUL characters from STRING unless they are quoted with CTLESC. */
-extern char *remove_quoted_nulls PARAMS((char *));
-
-/* Perform quote removal on STRING.  If QUOTED > 0, assume we are obeying the
-   backslash quoting rules for within double quotes. */
-extern char *string_quote_removal PARAMS((char *, int));
-
-/* Perform quote removal on word WORD.  This allocates and returns a new
-   WORD_DESC *. */
-extern WORD_DESC *word_quote_removal PARAMS((WORD_DESC *, int));
-
-/* Perform quote removal on all words in LIST.  If QUOTED is non-zero,
-   the members of the list are treated as if they are surrounded by
-   double quotes.  Return a new list, or NULL if LIST is NULL. */
-extern WORD_LIST *word_list_quote_removal PARAMS((WORD_LIST *, int));
-
-/* Called when IFS is changed to maintain some private variables. */
-extern void setifs PARAMS((SHELL_VAR *));
-
-/* Return the value of $IFS, or " \t\n" if IFS is unset. */
-extern char *getifs PARAMS((void));
-
-/* This splits a single word into a WORD LIST on $IFS, but only if the word
-   is not quoted.  list_string () performs quote removal for us, even if we
-   don't do any splitting. */
-extern WORD_LIST *word_split PARAMS((WORD_DESC *, char *));
-
-/* Take the list of words in LIST and do the various substitutions.  Return
-   a new list of words which is the expanded list, and without things like
-   variable assignments. */
-extern WORD_LIST *expand_words PARAMS((WORD_LIST *));
-
-/* Same as expand_words (), but doesn't hack variable or environment
-   variables. */
-extern WORD_LIST *expand_words_no_vars PARAMS((WORD_LIST *));
-
-/* Perform the `normal shell expansions' on a WORD_LIST.  These are
-   brace expansion, tilde expansion, parameter and variable substitution,
-   command substitution, arithmetic expansion, and word splitting. */
-extern WORD_LIST *expand_words_shellexp PARAMS((WORD_LIST *));
-
-extern WORD_DESC *command_substitute PARAMS((char *, int, int));
-extern char *pat_subst PARAMS((char *, char *, char *, int));
-
-#if defined (PROCESS_SUBSTITUTION)
-extern int fifos_pending PARAMS((void));
-extern int num_fifos PARAMS((void));
-extern void unlink_fifo_list PARAMS((void));
-extern void unlink_all_fifos PARAMS((void));
-extern void unlink_fifo PARAMS((int));
-
-extern void *copy_fifo_list PARAMS((int *));
-extern void close_new_fifos PARAMS((void *, int));
-
-extern void clear_fifo_list PARAMS((void));
-
-extern int find_procsub_child PARAMS((pid_t));
-extern void set_procsub_status PARAMS((int, pid_t, int));
-
-extern void wait_procsubs PARAMS((void));
-extern void reap_procsubs PARAMS((void));
-#endif
-
-extern WORD_LIST *list_string_with_quotes PARAMS((char *));
-
-#if defined (ARRAY_VARS)
-extern char *extract_array_assignment_list PARAMS((char *, int *));
-#endif
-
-#if defined (COND_COMMAND)
-extern char *remove_backslashes PARAMS((char *));
-extern char *cond_expand_word PARAMS((WORD_DESC *, int));
-#endif
-
-/* Flags for skip_to_delim */
-#define SD_NOJMP	0x001	/* don't longjmp on fatal error. */
-#define SD_INVERT	0x002	/* look for chars NOT in passed set */
-#define SD_NOQUOTEDELIM	0x004	/* don't let single or double quotes act as delimiters */
-#define SD_NOSKIPCMD	0x008	/* don't skip over $(, <(, or >( command/process substitution; parse them as commands */
-#define SD_EXTGLOB	0x010	/* skip over extended globbing patterns if appropriate */
-#define SD_IGNOREQUOTE	0x020	/* single and double quotes are not special */
-#define SD_GLOB		0x040	/* skip over glob patterns like bracket expressions */
-#define SD_NOPROCSUB	0x080	/* don't parse process substitutions as commands */
-#define SD_COMPLETE	0x100	/* skip_to_delim during completion */
-#define SD_HISTEXP	0x200	/* skip_to_delim during history expansion */
-#define SD_ARITHEXP	0x400	/* skip_to_delim during arithmetic expansion */
-#define SD_NOERROR	0x800	/* don't print error messages */
-
-extern int skip_to_delim PARAMS((char *, int, char *, int));
-
-#if defined (BANG_HISTORY)
-extern int skip_to_histexp PARAMS((char *, int, char *, int));
-#endif
-
-#if defined (READLINE)
-extern int char_is_quoted PARAMS((char *, int));
-extern int unclosed_pair PARAMS((char *, int, char *));
-extern WORD_LIST *split_at_delims PARAMS((char *, int, const char *, int, int, int *, int *));
-#endif
-
-/* Variables used to keep track of the characters in IFS. */
-extern SHELL_VAR *ifs_var;
-extern char *ifs_value;
-extern unsigned char ifs_cmap[];
-extern int ifs_is_set, ifs_is_null;
-
-#if defined (HANDLE_MULTIBYTE)
-extern unsigned char ifs_firstc[];
-extern size_t ifs_firstc_len;
-#else
-extern unsigned char ifs_firstc;
-#endif
-
-extern int assigning_in_environment;
-extern int expanding_redir;
-extern int inherit_errexit;
-
-extern pid_t last_command_subst_pid;
-
-/* Evaluates to 1 if C is a character in $IFS. */
-#define isifs(c)	(ifs_cmap[(unsigned char)(c)] != 0)
-
-/* How to determine the quoted state of the character C. */
-#define QUOTED_CHAR(c)  ((c) == CTLESC)
-
-/* Is the first character of STRING a quoted NULL character? */
-#define QUOTED_NULL(string) ((string)[0] == CTLNUL && (string)[1] == '\0')
-
-extern void invalidate_cached_quoted_dollar_at PARAMS((void));
-
-#endif /* !_SUBST_H_ */
diff --git a/third_party/bash/syntax.c b/third_party/bash/syntax.c
deleted file mode 100644
index c14e068f3..000000000
--- a/third_party/bash/syntax.c
+++ /dev/null
@@ -1,269 +0,0 @@
-/*
- * This file was generated by mksyntax.  DO NOT EDIT.
- */
-
-
-#include "config.h"
-#include "stdc.h"
-#include "syntax.h"
-
-
-int sh_syntabsiz = 256;
-int sh_syntaxtab[256] = {
-	CWORD,		/* 0 */
-	CSPECL,		/* CTLESC */
-	CWORD,		/* 2 */
-	CWORD,		/* 3 */
-	CWORD,		/* 4 */
-	CWORD,		/* 5 */
-	CWORD,		/* 6 */
-	CWORD,		/* \a */
-	CWORD,		/* \b */
-	CSHBRK|CBLANK,		/* \t */
-	CSHBRK|CBSDQUOTE,		/* \n */
-	CWORD,		/* \v */
-	CWORD,		/* \f */
-	CWORD,		/* \r */
-	CWORD,		/* 14 */
-	CWORD,		/* 15 */
-	CWORD,		/* 16 */
-	CWORD,		/* 17 */
-	CWORD,		/* 18 */
-	CWORD,		/* 19 */
-	CWORD,		/* 20 */
-	CWORD,		/* 21 */
-	CWORD,		/* 22 */
-	CWORD,		/* 23 */
-	CWORD,		/* 24 */
-	CWORD,		/* 25 */
-	CWORD,		/* 26 */
-	CWORD,		/* ESC */
-	CWORD,		/* 28 */
-	CWORD,		/* 29 */
-	CWORD,		/* 30 */
-	CWORD,		/* 31 */
-	CSHBRK|CBLANK,		/* SPC */
-	CXGLOB|CSPECVAR,		/* ! */
-	CQUOTE|CBSDQUOTE|CXQUOTE,		/* " */
-	CSPECVAR,		/* # */
-	CEXP|CBSDQUOTE|CBSHDOC|CSPECVAR,		/* $ */
-	CWORD,		/* % */
-	CSHMETA|CSHBRK,		/* & */
-	CQUOTE|CXQUOTE,		/* ' */
-	CSHMETA|CSHBRK,		/* ( */
-	CSHMETA|CSHBRK,		/* ) */
-	CGLOB|CXGLOB|CSPECVAR,		/* * */
-	CXGLOB|CSUBSTOP,		/* + */
-	CWORD,		/* , */
-	CSPECVAR|CSUBSTOP,		/* - */
-	CWORD,		/* . */
-	CWORD,		/* / */
-	CWORD,		/* 0 */
-	CWORD,		/* 1 */
-	CWORD,		/* 2 */
-	CWORD,		/* 3 */
-	CWORD,		/* 4 */
-	CWORD,		/* 5 */
-	CWORD,		/* 6 */
-	CWORD,		/* 7 */
-	CWORD,		/* 8 */
-	CWORD,		/* 9 */
-	CWORD,		/* : */
-	CSHMETA|CSHBRK,		/* ; */
-	CSHMETA|CSHBRK|CEXP,		/* < */
-	CSUBSTOP,		/* = */
-	CSHMETA|CSHBRK|CEXP,		/* > */
-	CGLOB|CXGLOB|CSPECVAR|CSUBSTOP,		/* ? */
-	CXGLOB|CSPECVAR,		/* @ */
-	CWORD,		/* A */
-	CWORD,		/* B */
-	CWORD,		/* C */
-	CWORD,		/* D */
-	CWORD,		/* E */
-	CWORD,		/* F */
-	CWORD,		/* G */
-	CWORD,		/* H */
-	CWORD,		/* I */
-	CWORD,		/* J */
-	CWORD,		/* K */
-	CWORD,		/* L */
-	CWORD,		/* M */
-	CWORD,		/* N */
-	CWORD,		/* O */
-	CWORD,		/* P */
-	CWORD,		/* Q */
-	CWORD,		/* R */
-	CWORD,		/* S */
-	CWORD,		/* T */
-	CWORD,		/* U */
-	CWORD,		/* V */
-	CWORD,		/* W */
-	CWORD,		/* X */
-	CWORD,		/* Y */
-	CWORD,		/* Z */
-	CGLOB,		/* [ */
-	CBSDQUOTE|CBSHDOC|CXQUOTE,		/* \ */
-	CGLOB,		/* ] */
-	CGLOB,		/* ^ */
-	CWORD,		/* _ */
-	CBACKQ|CQUOTE|CBSDQUOTE|CBSHDOC|CXQUOTE,		/* ` */
-	CWORD,		/* a */
-	CWORD,		/* b */
-	CWORD,		/* c */
-	CWORD,		/* d */
-	CWORD,		/* e */
-	CWORD,		/* f */
-	CWORD,		/* g */
-	CWORD,		/* h */
-	CWORD,		/* i */
-	CWORD,		/* j */
-	CWORD,		/* k */
-	CWORD,		/* l */
-	CWORD,		/* m */
-	CWORD,		/* n */
-	CWORD,		/* o */
-	CWORD,		/* p */
-	CWORD,		/* q */
-	CWORD,		/* r */
-	CWORD,		/* s */
-	CWORD,		/* t */
-	CWORD,		/* u */
-	CWORD,		/* v */
-	CWORD,		/* w */
-	CWORD,		/* x */
-	CWORD,		/* y */
-	CWORD,		/* z */
-	CWORD,		/* { */
-	CSHMETA|CSHBRK,		/* | */
-	CWORD,		/* } */
-	CWORD,		/* ~ */
-	CSPECL,		/* CTLNUL */
-	CWORD,		/* 128 */
-	CWORD,		/* 129 */
-	CWORD,		/* 130 */
-	CWORD,		/* 131 */
-	CWORD,		/* 132 */
-	CWORD,		/* 133 */
-	CWORD,		/* 134 */
-	CWORD,		/* 135 */
-	CWORD,		/* 136 */
-	CWORD,		/* 137 */
-	CWORD,		/* 138 */
-	CWORD,		/* 139 */
-	CWORD,		/* 140 */
-	CWORD,		/* 141 */
-	CWORD,		/* 142 */
-	CWORD,		/* 143 */
-	CWORD,		/* 144 */
-	CWORD,		/* 145 */
-	CWORD,		/* 146 */
-	CWORD,		/* 147 */
-	CWORD,		/* 148 */
-	CWORD,		/* 149 */
-	CWORD,		/* 150 */
-	CWORD,		/* 151 */
-	CWORD,		/* 152 */
-	CWORD,		/* 153 */
-	CWORD,		/* 154 */
-	CWORD,		/* 155 */
-	CWORD,		/* 156 */
-	CWORD,		/* 157 */
-	CWORD,		/* 158 */
-	CWORD,		/* 159 */
-	CWORD,		/* 160 */
-	CWORD,		/* 161 */
-	CWORD,		/* 162 */
-	CWORD,		/* 163 */
-	CWORD,		/* 164 */
-	CWORD,		/* 165 */
-	CWORD,		/* 166 */
-	CWORD,		/* 167 */
-	CWORD,		/* 168 */
-	CWORD,		/* 169 */
-	CWORD,		/* 170 */
-	CWORD,		/* 171 */
-	CWORD,		/* 172 */
-	CWORD,		/* 173 */
-	CWORD,		/* 174 */
-	CWORD,		/* 175 */
-	CWORD,		/* 176 */
-	CWORD,		/* 177 */
-	CWORD,		/* 178 */
-	CWORD,		/* 179 */
-	CWORD,		/* 180 */
-	CWORD,		/* 181 */
-	CWORD,		/* 182 */
-	CWORD,		/* 183 */
-	CWORD,		/* 184 */
-	CWORD,		/* 185 */
-	CWORD,		/* 186 */
-	CWORD,		/* 187 */
-	CWORD,		/* 188 */
-	CWORD,		/* 189 */
-	CWORD,		/* 190 */
-	CWORD,		/* 191 */
-	CWORD,		/* 192 */
-	CWORD,		/* 193 */
-	CWORD,		/* 194 */
-	CWORD,		/* 195 */
-	CWORD,		/* 196 */
-	CWORD,		/* 197 */
-	CWORD,		/* 198 */
-	CWORD,		/* 199 */
-	CWORD,		/* 200 */
-	CWORD,		/* 201 */
-	CWORD,		/* 202 */
-	CWORD,		/* 203 */
-	CWORD,		/* 204 */
-	CWORD,		/* 205 */
-	CWORD,		/* 206 */
-	CWORD,		/* 207 */
-	CWORD,		/* 208 */
-	CWORD,		/* 209 */
-	CWORD,		/* 210 */
-	CWORD,		/* 211 */
-	CWORD,		/* 212 */
-	CWORD,		/* 213 */
-	CWORD,		/* 214 */
-	CWORD,		/* 215 */
-	CWORD,		/* 216 */
-	CWORD,		/* 217 */
-	CWORD,		/* 218 */
-	CWORD,		/* 219 */
-	CWORD,		/* 220 */
-	CWORD,		/* 221 */
-	CWORD,		/* 222 */
-	CWORD,		/* 223 */
-	CWORD,		/* 224 */
-	CWORD,		/* 225 */
-	CWORD,		/* 226 */
-	CWORD,		/* 227 */
-	CWORD,		/* 228 */
-	CWORD,		/* 229 */
-	CWORD,		/* 230 */
-	CWORD,		/* 231 */
-	CWORD,		/* 232 */
-	CWORD,		/* 233 */
-	CWORD,		/* 234 */
-	CWORD,		/* 235 */
-	CWORD,		/* 236 */
-	CWORD,		/* 237 */
-	CWORD,		/* 238 */
-	CWORD,		/* 239 */
-	CWORD,		/* 240 */
-	CWORD,		/* 241 */
-	CWORD,		/* 242 */
-	CWORD,		/* 243 */
-	CWORD,		/* 244 */
-	CWORD,		/* 245 */
-	CWORD,		/* 246 */
-	CWORD,		/* 247 */
-	CWORD,		/* 248 */
-	CWORD,		/* 249 */
-	CWORD,		/* 250 */
-	CWORD,		/* 251 */
-	CWORD,		/* 252 */
-	CWORD,		/* 253 */
-	CWORD,		/* 254 */
-	CWORD,		/* 255 */
-};
diff --git a/third_party/bash/syntax.h b/third_party/bash/syntax.h
deleted file mode 100644
index 34f549647..000000000
--- a/third_party/bash/syntax.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/* syntax.h -- Syntax definitions for the shell */
-
-/* Copyright (C) 2000, 2001, 2005, 2008, 2009-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _SYNTAX_H_
-#define _SYNTAX_H_
-
-/* Defines for use by mksyntax.c */
-
-#define slashify_in_quotes "\\`$\"\n"
-#define slashify_in_here_document "\\`$"
-
-#define shell_meta_chars   "()<>;&|"
-#define shell_break_chars  "()<>;&| \t\n"
-
-#define shell_quote_chars	"\"`'"
-
-#if defined (PROCESS_SUBSTITUTION)
-#  define shell_exp_chars		"$<>"
-#else
-#  define shell_exp_chars		"$"
-#endif
-
-#if defined (EXTENDED_GLOB)
-#  define ext_glob_chars	"@*+?!"
-#else
-#  define ext_glob_chars	""
-#endif
-#define shell_glob_chars	"*?[]^"
-
-/* Defines shared by mksyntax.c and the rest of the shell code. */
-
-/* Values for character flags in syntax tables */
-
-#define CWORD		0x0000	/* nothing special; an ordinary character */
-#define CSHMETA		0x0001	/* shell meta character */
-#define CSHBRK		0x0002	/* shell break character */
-#define CBACKQ		0x0004	/* back quote */
-#define CQUOTE		0x0008	/* shell quote character */
-#define CSPECL		0x0010	/* special character that needs quoting */
-#define CEXP		0x0020	/* shell expansion character */
-#define CBSDQUOTE	0x0040	/* characters escaped by backslash in double quotes */
-#define CBSHDOC		0x0080	/* characters escaped by backslash in here doc */
-#define CGLOB		0x0100	/* globbing characters */
-#define CXGLOB		0x0200	/* extended globbing characters */
-#define CXQUOTE		0x0400	/* cquote + backslash */
-#define CSPECVAR	0x0800	/* single-character shell variable name */
-#define CSUBSTOP	0x1000	/* values of OP for ${word[:]OPstuff} */
-#define CBLANK		0x2000	/* whitespace (blank) character */
-
-/* Defines for use by the rest of the shell. */
-extern int sh_syntaxtab[];
-extern int sh_syntabsiz;
-
-#define shellmeta(c)	(sh_syntaxtab[(unsigned char)(c)] & CSHMETA)
-#define shellbreak(c)	(sh_syntaxtab[(unsigned char)(c)] & CSHBRK)
-#define shellquote(c)	(sh_syntaxtab[(unsigned char)(c)] & CQUOTE)
-#define shellxquote(c)	(sh_syntaxtab[(unsigned char)(c)] & CXQUOTE)
-
-#define shellblank(c)	(sh_syntaxtab[(unsigned char)(c)] & CBLANK)
-
-#define parserblank(c)	((c) == ' ' || (c) == '\t')
-
-#define issyntype(c, t)	((sh_syntaxtab[(unsigned char)(c)] & (t)) != 0)
-#define notsyntype(c,t) ((sh_syntaxtab[(unsigned char)(c)] & (t)) == 0)
-
-#if defined (PROCESS_SUBSTITUTION)
-#  define shellexp(c)	((c) == '$' || (c) == '<' || (c) == '>')
-#else
-#  define shellexp(c)	((c) == '$')
-#endif
-
-#if defined (EXTENDED_GLOB)
-#  define PATTERN_CHAR(c) \
-	((c) == '@' || (c) == '*' || (c) == '+' || (c) == '?' || (c) == '!')
-#else
-#  define PATTERN_CHAR(c) 0
-#endif
-
-#define GLOB_CHAR(c) \
-	((c) == '*' || (c) == '?' || (c) == '[' || (c) == ']' || (c) == '^')
-
-#define CTLESC '\001'
-#define CTLNUL '\177'
-
-#if !defined (HAVE_ISBLANK) && !defined (isblank)
-#  define isblank(x)	((x) == ' ' || (x) == '\t')
-#endif
-
-#endif /* _SYNTAX_H_ */
diff --git a/third_party/bash/systimes.h b/third_party/bash/systimes.h
deleted file mode 100644
index 27cdb3e53..000000000
--- a/third_party/bash/systimes.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/* Copyright (C) 1991-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/*
- *	POSIX Standard: 4.5.2 Process Times	<sys/times.h>
- */
-
-/*
- * If we don't have a standard system clock_t type, this must be included
- * after config.h
- */
-
-#ifndef	_BASH_SYSTIMES_H
-#define _BASH_SYSTIMES_H	1
-
-#if defined (HAVE_SYS_TIMES_H)
-#  include <sys/times.h>
-#else /* !HAVE_SYS_TIMES_H */
-
-#include "stdc.h"
-
-/* Structure describing CPU time used by a process and its children.  */
-struct tms
-  {
-    clock_t tms_utime;		/* User CPU time.  */
-    clock_t tms_stime;		/* System CPU time.  */
-
-    clock_t tms_cutime;		/* User CPU time of dead children.  */
-    clock_t tms_cstime;		/* System CPU time of dead children.  */
-  };
-
-/* Store the CPU time used by this process and all its
-   dead descendants in BUFFER.
-   Return the elapsed real time from an arbitrary point in the
-   past (the bash emulation uses the epoch), or (clock_t) -1 for
-   errors.  All times are in CLK_TCKths of a second.  */
-extern clock_t times PARAMS((struct tms *buffer));
-
-#endif /* !HAVE_SYS_TIMES_H */
-#endif /* _BASH_SYSTIMES_H */
diff --git a/third_party/bash/test.c b/third_party/bash/test.c
deleted file mode 100644
index b058922c7..000000000
--- a/third_party/bash/test.c
+++ /dev/null
@@ -1,921 +0,0 @@
-/* test.c - GNU test program (ksb and mjb) */
-
-/* Modified to run with the GNU shell Apr 25, 1988 by bfox. */
-
-/* Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* Define PATTERN_MATCHING to get the csh-like =~ and !~ pattern-matching
-   binary operators. */
-/* #define PATTERN_MATCHING */
-
-#if defined (HAVE_CONFIG_H)
-#  include "config.h"
-#endif
-
-#include <stdio.h>
-
-#include "bashtypes.h"
-
-#if !defined (HAVE_LIMITS_H) && defined (HAVE_SYS_PARAM_H)
-#  include <sys/param.h>
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <errno.h>
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#if !defined (_POSIX_VERSION) && defined (HAVE_SYS_FILE_H)
-#  include <sys/file.h>
-#endif /* !_POSIX_VERSION */
-#include "posixstat.h"
-#include "filecntl.h"
-#include "stat-time.h"
-
-#include "bashintl.h"
-
-#include "shell.h"
-#include "pathexp.h"
-#include "test.h"
-#include "common.h"
-
-#include "strmatch.h"
-
-#if !defined (STRLEN)
-#  define STRLEN(s) ((s)[0] ? ((s)[1] ? ((s)[2] ? strlen(s) : 2) : 1) : 0)
-#endif
-
-#if !defined (STREQ)
-#  define STREQ(a, b) ((a)[0] == (b)[0] && strcmp ((a), (b)) == 0)
-#endif /* !STREQ */
-#define STRCOLLEQ(a, b) ((a)[0] == (b)[0] && strcoll ((a), (b)) == 0)
-
-#if !defined (R_OK)
-#define R_OK 4
-#define W_OK 2
-#define X_OK 1
-#define F_OK 0
-#endif /* R_OK */
-
-#define EQ	0
-#define NE	1
-#define LT	2
-#define GT	3
-#define LE	4
-#define GE	5
-
-#define NT	0
-#define OT	1
-#define EF	2
-
-/* The following few defines control the truth and false output of each stage.
-   TRUE and FALSE are what we use to compute the final output value.
-   SHELL_BOOLEAN is the form which returns truth or falseness in shell terms.
-   Default is TRUE = 1, FALSE = 0, SHELL_BOOLEAN = (!value). */
-#define TRUE 1
-#define FALSE 0
-#define SHELL_BOOLEAN(value) (!(value))
-
-#define TEST_ERREXIT_STATUS	2
-
-static procenv_t test_exit_buf;
-static int test_error_return;
-#define test_exit(val) \
-	do { test_error_return = val; sh_longjmp (test_exit_buf, 1); } while (0)
-
-extern int sh_stat PARAMS((const char *, struct stat *));
-
-static int pos;		/* The offset of the current argument in ARGV. */
-static int argc;	/* The number of arguments present in ARGV. */
-static char **argv;	/* The argument list. */
-static int noeval;
-
-static void test_syntax_error PARAMS((char *, char *)) __attribute__((__noreturn__));
-static void beyond PARAMS((void)) __attribute__((__noreturn__));
-static void integer_expected_error PARAMS((char *)) __attribute__((__noreturn__));
-
-static int unary_operator PARAMS((void));
-static int binary_operator PARAMS((void));
-static int two_arguments PARAMS((void));
-static int three_arguments PARAMS((void));
-static int posixtest PARAMS((void));
-
-static int expr PARAMS((void));
-static int term PARAMS((void));
-static int and PARAMS((void));
-static int or PARAMS((void));
-
-static int filecomp PARAMS((char *, char *, int));
-static int arithcomp PARAMS((char *, char *, int, int));
-static int patcomp PARAMS((char *, char *, int));
-
-static void
-test_syntax_error (format, arg)
-     char *format, *arg;
-{
-  builtin_error (format, arg);
-  test_exit (TEST_ERREXIT_STATUS);
-}
-
-/*
- * beyond - call when we're beyond the end of the argument list (an
- *	error condition)
- */
-static void
-beyond ()
-{
-  test_syntax_error (_("argument expected"), (char *)NULL);
-}
-
-/* Syntax error for when an integer argument was expected, but
-   something else was found. */
-static void
-integer_expected_error (pch)
-     char *pch;
-{
-  test_syntax_error (_("%s: integer expression expected"), pch);
-}
-
-/* Increment our position in the argument list.  Check that we're not
-   past the end of the argument list.  This check is suppressed if the
-   argument is FALSE.  Made a macro for efficiency. */
-#define advance(f) do { ++pos; if (f && pos >= argc) beyond (); } while (0)
-#define unary_advance() do { advance (1); ++pos; } while (0)
-
-/*
- * expr:
- *	or
- */
-static int
-expr ()
-{
-  if (pos >= argc)
-    beyond ();
-
-  return (FALSE ^ or ());		/* Same with this. */
-}
-
-/*
- * or:
- *	and
- *	and '-o' or
- */
-static int
-or ()
-{
-  int value, v2;
-
-  value = and ();
-  if (pos < argc && argv[pos][0] == '-' && argv[pos][1] == 'o' && !argv[pos][2])
-    {
-      advance (0);
-      v2 = or ();
-      return (value || v2);
-    }
-
-  return (value);
-}
-
-/*
- * and:
- *	term
- *	term '-a' and
- */
-static int
-and ()
-{
-  int value, v2;
-
-  value = term ();
-  if (pos < argc && argv[pos][0] == '-' && argv[pos][1] == 'a' && !argv[pos][2])
-    {
-      advance (0);
-      v2 = and ();
-      return (value && v2);
-    }
-  return (value);
-}
-
-/*
- * term - parse a term and return 1 or 0 depending on whether the term
- *	evaluates to true or false, respectively.
- *
- * term ::=
- *	'-'('a'|'b'|'c'|'d'|'e'|'f'|'g'|'h'|'k'|'p'|'r'|'s'|'u'|'w'|'x') filename
- *	'-'('G'|'L'|'O'|'S'|'N') filename
- * 	'-t' [int]
- *	'-'('z'|'n') string
- *	'-'('v'|'R') varname
- *	'-o' option
- *	string
- *	string ('!='|'='|'==') string
- *	<int> '-'(eq|ne|le|lt|ge|gt) <int>
- *	file '-'(nt|ot|ef) file
- *	'(' <expr> ')'
- * int ::=
- *	positive and negative integers
- */
-static int
-term ()
-{
-  int value;
-
-  if (pos >= argc)
-    beyond ();
-
-  /* Deal with leading `not's. */
-  if (argv[pos][0] == '!' && argv[pos][1] == '\0')
-    {
-      value = 0;
-      while (pos < argc && argv[pos][0] == '!' && argv[pos][1] == '\0')
-	{
-	  advance (1);
-	  value = 1 - value;
-	}
-
-      return (value ? !term() : term());
-    }
-
-  /* A paren-bracketed argument. */
-  if (argv[pos][0] == '(' && argv[pos][1] == '\0') /* ) */
-    {
-      advance (1);
-      value = expr ();
-      if (argv[pos] == 0) /* ( */
-	test_syntax_error (_("`)' expected"), (char *)NULL);
-      else if (argv[pos][0] != ')' || argv[pos][1]) /* ( */
-	test_syntax_error (_("`)' expected, found %s"), argv[pos]);
-      advance (0);
-      return (value);
-    }
-
-  /* are there enough arguments left that this could be dyadic? */
-  if ((pos + 3 <= argc) && test_binop (argv[pos + 1]))
-    value = binary_operator ();
-
-  /* Might be a switch type argument -- make sure we have enough arguments for
-     the unary operator and argument */
-  else if ((pos + 2) <= argc && test_unop (argv[pos]))
-    value = unary_operator ();
-
-  else
-    {
-      value = argv[pos][0] != '\0';
-      advance (0);
-    }
-
-  return (value);
-}
-
-static int
-stat_mtime (fn, st, ts)
-     char *fn;
-     struct stat *st;
-     struct timespec *ts;
-{
-  int r;
-
-  r = sh_stat (fn, st);
-  if (r < 0)
-    return r;
-  *ts = get_stat_mtime (st);
-  return 0;
-}
-
-static int
-filecomp (s, t, op)
-     char *s, *t;
-     int op;
-{
-  struct stat st1, st2;
-  struct timespec ts1, ts2;
-  int r1, r2;
-
-  if ((r1 = stat_mtime (s, &st1, &ts1)) < 0)
-    {
-      if (op == EF)
-	return (FALSE);
-    }
-  if ((r2 = stat_mtime (t, &st2, &ts2)) < 0)
-    {
-      if (op == EF)
-	return (FALSE);
-    }
-  
-  switch (op)
-    {
-    case OT: return (r1 < r2 || (r2 == 0 && timespec_cmp (ts1, ts2) < 0));
-    case NT: return (r1 > r2 || (r1 == 0 && timespec_cmp (ts1, ts2) > 0));
-    case EF: return (same_file (s, t, &st1, &st2));
-    }
-  return (FALSE);
-}
-
-static int
-arithcomp (s, t, op, flags)
-     char *s, *t;
-     int op, flags;
-{
-  intmax_t l, r;
-  int expok;
-
-  if (flags & TEST_ARITHEXP)		/* conditional command */
-    {
-      int eflag;
-
-      eflag = (shell_compatibility_level > 51) ? 0 : EXP_EXPANDED;
-      l = evalexp (s, eflag, &expok);
-      if (expok == 0)
-	return (FALSE);		/* should probably longjmp here */
-      r = evalexp (t, eflag, &expok);
-      if (expok == 0)
-	return (FALSE);		/* ditto */
-    }
-  else
-    {
-      if (legal_number (s, &l) == 0)
-	integer_expected_error (s);
-      if (legal_number (t, &r) == 0)
-	integer_expected_error (t);
-    }
-
-  switch (op)
-    {
-    case EQ: return (l == r);
-    case NE: return (l != r);
-    case LT: return (l < r);
-    case GT: return (l > r);
-    case LE: return (l <= r);
-    case GE: return (l >= r);
-    }
-
-  return (FALSE);
-}
-
-static int
-patcomp (string, pat, op)
-     char *string, *pat;
-     int op;
-{
-  int m;
-
-  m = strmatch (pat, string, FNMATCH_EXTFLAG|FNMATCH_IGNCASE);
-  return ((op == EQ) ? (m == 0) : (m != 0));
-}
-
-int
-binary_test (op, arg1, arg2, flags)
-     char *op, *arg1, *arg2;
-     int flags;
-{
-  int patmatch;
-
-  patmatch = (flags & TEST_PATMATCH);
-
-  if (op[0] == '=' && (op[1] == '\0' || (op[1] == '=' && op[2] == '\0')))
-    return (patmatch ? patcomp (arg1, arg2, EQ) : STREQ (arg1, arg2));
-  else if ((op[0] == '>' || op[0] == '<') && op[1] == '\0')
-    {
-#if defined (HAVE_STRCOLL)
-      if (shell_compatibility_level > 40 && flags & TEST_LOCALE)
-	return ((op[0] == '>') ? (strcoll (arg1, arg2) > 0) : (strcoll (arg1, arg2) < 0));
-      else
-#endif
-	return ((op[0] == '>') ? (strcmp (arg1, arg2) > 0) : (strcmp (arg1, arg2) < 0));
-    }
-  else if (op[0] == '!' && op[1] == '=' && op[2] == '\0')
-    return (patmatch ? patcomp (arg1, arg2, NE) : (STREQ (arg1, arg2) == 0));
-    
-
-  else if (op[2] == 't')
-    {
-      switch (op[1])
-	{
-	case 'n': return (filecomp (arg1, arg2, NT));		/* -nt */
-	case 'o': return (filecomp (arg1, arg2, OT));		/* -ot */
-	case 'l': return (arithcomp (arg1, arg2, LT, flags));	/* -lt */
-	case 'g': return (arithcomp (arg1, arg2, GT, flags));	/* -gt */
-	}
-    }
-  else if (op[1] == 'e')
-    {
-      switch (op[2])
-	{
-	case 'f': return (filecomp (arg1, arg2, EF));		/* -ef */
-	case 'q': return (arithcomp (arg1, arg2, EQ, flags));	/* -eq */
-	}
-    }
-  else if (op[2] == 'e')
-    {
-      switch (op[1])
-	{
-	case 'n': return (arithcomp (arg1, arg2, NE, flags));	/* -ne */
-	case 'g': return (arithcomp (arg1, arg2, GE, flags));	/* -ge */
-	case 'l': return (arithcomp (arg1, arg2, LE, flags));	/* -le */
-	}
-    }
-
-  return (FALSE);	/* should never get here */
-}
-
-
-static int
-binary_operator ()
-{
-  int value;
-  char *w;
-
-  w = argv[pos + 1];
-  if ((w[0] == '=' && (w[1] == '\0' || (w[1] == '=' && w[2] == '\0'))) || /* =, == */
-      ((w[0] == '>' || w[0] == '<') && w[1] == '\0') ||		/* <, > */
-      (w[0] == '!' && w[1] == '=' && w[2] == '\0'))		/* != */
-    {
-      value = binary_test (w, argv[pos], argv[pos + 2], 0);
-      pos += 3;
-      return (value);
-    }
-
-#if defined (PATTERN_MATCHING)
-  if ((w[0] == '=' || w[0] == '!') && w[1] == '~' && w[2] == '\0')
-    {
-      value = patcomp (argv[pos], argv[pos + 2], w[0] == '=' ? EQ : NE);
-      pos += 3;
-      return (value);
-    }
-#endif
-
-  if ((w[0] != '-' || w[3] != '\0') || test_binop (w) == 0)
-    {
-      test_syntax_error (_("%s: binary operator expected"), w);
-      /* NOTREACHED */
-      return (FALSE);
-    }
-
-  value = binary_test (w, argv[pos], argv[pos + 2], 0);
-  pos += 3;
-  return value;
-}
-
-static int
-unary_operator ()
-{
-  char *op;
-  intmax_t r;
-
-  op = argv[pos];
-  if (test_unop (op) == 0)
-    return (FALSE);
-
-  /* the only tricky case is `-t', which may or may not take an argument. */
-  if (op[1] == 't')
-    {
-      advance (0);
-      if (pos < argc)
-	{
-	  if (legal_number (argv[pos], &r))
-	    {
-	      advance (0);
-	      return (unary_test (op, argv[pos - 1], 0));
-	    }
-	  else
-	    return (FALSE);
-	}
-      else
-	return (unary_test (op, "1", 0));
-    }
-
-  /* All of the unary operators take an argument, so we first call
-     unary_advance (), which checks to make sure that there is an
-     argument, and then advances pos right past it.  This means that
-     pos - 1 is the location of the argument. */
-  unary_advance ();
-  return (unary_test (op, argv[pos - 1], 0));
-}
-
-int
-unary_test (op, arg, flags)
-     char *op, *arg;
-     int flags;
-{
-  intmax_t r;
-  struct stat stat_buf;
-  struct timespec mtime, atime;
-  SHELL_VAR *v;
-  int aflags;
-     
-  switch (op[1])
-    {
-    case 'a':			/* file exists in the file system? */
-    case 'e':
-      return (sh_stat (arg, &stat_buf) == 0);
-
-    case 'r':			/* file is readable? */
-      return (sh_eaccess (arg, R_OK) == 0);
-
-    case 'w':			/* File is writeable? */
-      return (sh_eaccess (arg, W_OK) == 0);
-
-    case 'x':			/* File is executable? */
-      return (sh_eaccess (arg, X_OK) == 0);
-
-    case 'O':			/* File is owned by you? */
-      return (sh_stat (arg, &stat_buf) == 0 &&
-	      (uid_t) current_user.euid == (uid_t) stat_buf.st_uid);
-
-    case 'G':			/* File is owned by your group? */
-      return (sh_stat (arg, &stat_buf) == 0 &&
-	      (gid_t) current_user.egid == (gid_t) stat_buf.st_gid);
-
-    case 'N':
-      if (sh_stat (arg, &stat_buf) < 0)
-	return (FALSE);
-      atime = get_stat_atime (&stat_buf);
-      mtime = get_stat_mtime (&stat_buf);
-      return (timespec_cmp (mtime, atime) > 0);
-
-    case 'f':			/* File is a file? */
-      if (sh_stat (arg, &stat_buf) < 0)
-	return (FALSE);
-
-      /* -f is true if the given file exists and is a regular file. */
-#if defined (S_IFMT)
-      return (S_ISREG (stat_buf.st_mode) || (stat_buf.st_mode & S_IFMT) == 0);
-#else
-      return (S_ISREG (stat_buf.st_mode));
-#endif /* !S_IFMT */
-
-    case 'd':			/* File is a directory? */
-      return (sh_stat (arg, &stat_buf) == 0 && (S_ISDIR (stat_buf.st_mode)));
-
-    case 's':			/* File has something in it? */
-      return (sh_stat (arg, &stat_buf) == 0 && stat_buf.st_size > (off_t) 0);
-
-    case 'S':			/* File is a socket? */
-#if !defined (S_ISSOCK)
-      return (FALSE);
-#else
-      return (sh_stat (arg, &stat_buf) == 0 && S_ISSOCK (stat_buf.st_mode));
-#endif /* S_ISSOCK */
-
-    case 'c':			/* File is character special? */
-      return (sh_stat (arg, &stat_buf) == 0 && S_ISCHR (stat_buf.st_mode));
-
-    case 'b':			/* File is block special? */
-      return (sh_stat (arg, &stat_buf) == 0 && S_ISBLK (stat_buf.st_mode));
-
-    case 'p':			/* File is a named pipe? */
-#ifndef S_ISFIFO
-      return (FALSE);
-#else
-      return (sh_stat (arg, &stat_buf) == 0 && S_ISFIFO (stat_buf.st_mode));
-#endif /* S_ISFIFO */
-
-    case 'L':			/* Same as -h  */
-    case 'h':			/* File is a symbolic link? */
-#if !defined (S_ISLNK) || !defined (HAVE_LSTAT)
-      return (FALSE);
-#else
-      return ((arg[0] != '\0') &&
-	      (lstat (arg, &stat_buf) == 0) && S_ISLNK (stat_buf.st_mode));
-#endif /* S_IFLNK && HAVE_LSTAT */
-
-    case 'u':			/* File is setuid? */
-      return (sh_stat (arg, &stat_buf) == 0 && (stat_buf.st_mode & S_ISUID) != 0);
-
-    case 'g':			/* File is setgid? */
-      return (sh_stat (arg, &stat_buf) == 0 && (stat_buf.st_mode & S_ISGID) != 0);
-
-    case 'k':			/* File has sticky bit set? */
-#if !defined (S_ISVTX)
-      /* This is not Posix, and is not defined on some Posix systems. */
-      return (FALSE);
-#else
-      return (sh_stat (arg, &stat_buf) == 0 && (stat_buf.st_mode & S_ISVTX) != 0);
-#endif
-
-    case 't':	/* File fd is a terminal? */
-      if (legal_number (arg, &r) == 0)
-	return (FALSE);
-      return ((r == (int)r) && isatty ((int)r));
-
-    case 'n':			/* True if arg has some length. */
-      return (arg[0] != '\0');
-
-    case 'z':			/* True if arg has no length. */
-      return (arg[0] == '\0');
-
-    case 'o':			/* True if option `arg' is set. */
-      return (minus_o_option_value (arg) == 1);
-
-    case 'v':
-#if defined (ARRAY_VARS)
-      aflags = assoc_expand_once ? AV_NOEXPAND : 0;
-      if (valid_array_reference (arg, aflags))
-	{
-	  char *t;
-	  int ret;
-	  array_eltstate_t es;
-
-	  /* Let's assume that this has already been expanded once. */
-	  /* XXX - TAG:bash-5.2 fix with corresponding fix to execute_cmd.c:
-	     execute_cond_node() that passes TEST_ARRAYEXP in FLAGS */
-
-	  if (shell_compatibility_level > 51)
-	    /* Allow associative arrays to use `test -v array[@]' to look for
-	       a key named `@'. */
-	    aflags |= AV_ATSTARKEYS;	/* XXX */
-	  init_eltstate (&es);
-	  t = get_array_value (arg, aflags|AV_ALLOWALL, &es);
-	  ret = t ? TRUE : FALSE;
-	  if (es.subtype > 0)	/* subscript is * or @ */
-	    free (t);
-	  flush_eltstate (&es);
-	  return ret;
-	}
-      else if (legal_number (arg, &r))		/* -v n == is $n set? */
-	return ((r >= 0 && r <= number_of_args()) ? TRUE : FALSE);
-      v = find_variable (arg);
-      if (v && invisible_p (v) == 0 && array_p (v))
-	{
-	  char *t;
-	  /* [[ -v foo ]] == [[ -v foo[0] ]] */
-	  t = array_reference (array_cell (v), 0);
-	  return (t ? TRUE : FALSE);
-	}
-      else if (v && invisible_p (v) == 0 && assoc_p (v))
-	{
-	  char *t;
-	  t = assoc_reference (assoc_cell (v), "0");
-	  return (t ? TRUE : FALSE);
-	}
-#else
-      v = find_variable (arg);
-#endif
-      return (v && invisible_p (v) == 0 && var_isset (v) ? TRUE : FALSE);
-
-    case 'R':
-      v = find_variable_noref (arg);
-      return ((v && invisible_p (v) == 0 && var_isset (v) && nameref_p (v)) ? TRUE : FALSE);
-    }
-
-  /* We can't actually get here, but this shuts up gcc. */
-  return (FALSE);
-}
-
-/* Return TRUE if OP is one of the test command's binary operators. */
-int
-test_binop (op)
-     char *op;
-{
-  if (op[0] == '=' && op[1] == '\0')
-    return (1);		/* '=' */
-  else if ((op[0] == '<' || op[0] == '>') && op[1] == '\0')  /* string <, > */
-    return (1);
-  else if ((op[0] == '=' || op[0] == '!') && op[1] == '=' && op[2] == '\0')
-    return (1);		/* `==' and `!=' */
-#if defined (PATTERN_MATCHING)
-  else if (op[2] == '\0' && op[1] == '~' && (op[0] == '=' || op[0] == '!'))
-    return (1);
-#endif
-  else if (op[0] != '-' || op[1] == '\0' || op[2] == '\0' || op[3] != '\0')
-    return (0);
-  else
-    {
-      if (op[2] == 't')
-	switch (op[1])
-	  {
-	  case 'n':		/* -nt */
-	  case 'o':		/* -ot */
-	  case 'l':		/* -lt */
-	  case 'g':		/* -gt */
-	    return (1);
-	  default:
-	    return (0);
-	  }
-      else if (op[1] == 'e')
-	switch (op[2])
-	  {
-	  case 'q':		/* -eq */
-	  case 'f':		/* -ef */
-	    return (1);
-	  default:
-	    return (0);
-	  }
-      else if (op[2] == 'e')
-	switch (op[1])
-	  {
-	  case 'n':		/* -ne */
-	  case 'g':		/* -ge */
-	  case 'l':		/* -le */
-	    return (1);
-	  default:
-	    return (0);
-	  }
-      else
-	return (0);
-    }
-}
-
-/* Return non-zero if OP is one of the test command's unary operators. */
-int
-test_unop (op)
-     char *op;
-{
-  if (op[0] != '-' || (op[1] && op[2] != 0))
-    return (0);
-
-  switch (op[1])
-    {
-    case 'a': case 'b': case 'c': case 'd': case 'e':
-    case 'f': case 'g': case 'h': case 'k': case 'n':
-    case 'o': case 'p': case 'r': case 's': case 't':
-    case 'u': case 'v': case 'w': case 'x': case 'z':
-    case 'G': case 'L': case 'O': case 'S': case 'N':
-    case 'R':
-      return (1);
-    }
-
-  return (0);
-}
-
-static int
-two_arguments ()
-{
-  if (argv[pos][0] == '!' && argv[pos][1] == '\0')
-    return (argv[pos + 1][0] == '\0');
-  else if (argv[pos][0] == '-' && argv[pos][1] && argv[pos][2] == '\0')
-    {
-      if (test_unop (argv[pos]))
-	return (unary_operator ());
-      else
-	test_syntax_error (_("%s: unary operator expected"), argv[pos]);
-    }
-  else
-    test_syntax_error (_("%s: unary operator expected"), argv[pos]);
-
-  return (0);
-}
-
-#define ANDOR(s)  (s[0] == '-' && (s[1] == 'a' || s[1] == 'o') && s[2] == 0)
-
-/* This could be augmented to handle `-t' as equivalent to `-t 1', but
-   POSIX requires that `-t' be given an argument. */
-#define ONE_ARG_TEST(s)		((s)[0] != '\0')
-
-static int
-three_arguments ()
-{
-  int value;
-
-  if (test_binop (argv[pos+1]))
-    {
-      value = binary_operator ();
-      pos = argc;
-    }
-  else if (ANDOR (argv[pos+1]))
-    {
-      if (argv[pos+1][1] == 'a')
-	value = ONE_ARG_TEST(argv[pos]) && ONE_ARG_TEST(argv[pos+2]);
-      else
-	value = ONE_ARG_TEST(argv[pos]) || ONE_ARG_TEST(argv[pos+2]);
-      pos = argc;
-    }
-  else if (argv[pos][0] == '!' && argv[pos][1] == '\0')
-    {
-      advance (1);
-      value = !two_arguments ();
-      pos = argc;
-    }
-  else if (argv[pos][0] == '(' && argv[pos+2][0] == ')')
-    {
-      value = ONE_ARG_TEST(argv[pos+1]);
-      pos = argc;
-    }
-  else
-    test_syntax_error (_("%s: binary operator expected"), argv[pos+1]);
-
-  return (value);
-}
-
-/* This is an implementation of a Posix.2 proposal by David Korn. */
-static int
-posixtest ()
-{
-  int value;
-
-  switch (argc - 1)	/* one extra passed in */
-    {
-      case 0:
-	value = FALSE;
-	pos = argc;
-	break;
-
-      case 1:
-	value = ONE_ARG_TEST(argv[1]);
-	pos = argc;
-	break;
-
-      case 2:
-	value = two_arguments ();
-	pos = argc;
-	break;
-
-      case 3:
-	value = three_arguments ();
-	break;
-
-      case 4:
-	if (argv[pos][0] == '!' && argv[pos][1] == '\0')
-	  {
-	    advance (1);
-	    value = !three_arguments ();
-	    break;
-	  }
-	else if (argv[pos][0] == '(' && argv[pos][1] == '\0' && argv[argc-1][0] == ')' && argv[argc-1][1] == '\0')
-	  {
-	    advance (1);
-	    value = two_arguments ();
-	    pos = argc;
-	    break;
-	  }
-	/* FALLTHROUGH */
-      default:
-	value = expr ();
-    }
-
-  return (value);
-}
-
-/*
- * [:
- *	'[' expr ']'
- * test:
- *	test expr
- */
-int
-test_command (margc, margv)
-     int margc;
-     char **margv;
-{
-  int value;
-  int code;
-
-  USE_VAR(margc);
-
-  code = setjmp_nosigs (test_exit_buf);
-
-  if (code)
-    return (test_error_return);
-
-  argv = margv;
-
-  if (margv[0] && margv[0][0] == '[' && margv[0][1] == '\0')
-    {
-      --margc;
-
-      if (margv[margc] && (margv[margc][0] != ']' || margv[margc][1]))
-	test_syntax_error (_("missing `]'"), (char *)NULL);
-
-      if (margc < 2)
-	test_exit (SHELL_BOOLEAN (FALSE));
-    }
-
-  argc = margc;
-  pos = 1;
-
-  if (pos >= argc)
-    test_exit (SHELL_BOOLEAN (FALSE));
-
-  noeval = 0;
-  value = posixtest ();
-
-  if (pos != argc)
-    {
-      if (pos < argc && argv[pos][0] == '-')
-	test_syntax_error (_("syntax error: `%s' unexpected"), argv[pos]);
-      else
-	test_syntax_error (_("too many arguments"), (char *)NULL);
-    }
-
-  test_exit (SHELL_BOOLEAN (value));
-}
diff --git a/third_party/bash/test.h b/third_party/bash/test.h
deleted file mode 100644
index ffd79e5e0..000000000
--- a/third_party/bash/test.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/* test.h -- external interface to the conditional command code. */
-
-/* Copyright (C) 1997-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _TEST_H_
-#define _TEST_H_
-
-#include "stdc.h"
-
-/* Values for the flags argument to binary_test */
-#define TEST_PATMATCH	0x01
-#define TEST_ARITHEXP	0x02
-#define TEST_LOCALE	0x04
-#define TEST_ARRAYEXP	0x08		/* array subscript expansion */
-
-extern int test_unop PARAMS((char *));
-extern int test_binop PARAMS((char *));
-
-extern int unary_test PARAMS((char *, char *, int));
-extern int binary_test PARAMS((char *, char *, char *, int));
-
-extern int test_command PARAMS((int, char **));
-
-#endif /* _TEST_H_ */
diff --git a/third_party/bash/tilde.c b/third_party/bash/tilde.c
deleted file mode 100644
index 5bafbb214..000000000
--- a/third_party/bash/tilde.c
+++ /dev/null
@@ -1,493 +0,0 @@
-/* tilde.c -- Tilde expansion code (~/foo := $HOME/foo). */
-
-/* Copyright (C) 1988-2020 Free Software Foundation, Inc.
-
-   This file is part of the GNU Readline Library (Readline), a library
-   for reading lines of text with interactive input and history editing.
-
-   Readline is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Readline is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Readline.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if defined (HAVE_CONFIG_H)
-#  include "config.h"
-#endif
-
-#if defined (HAVE_UNISTD_H)
-#  ifdef _MINIX
-#    include <sys/types.h>
-#  endif
-#  include <unistd.h>
-#endif
-
-#if defined (HAVE_STRING_H)
-#  include <string.h>
-#else /* !HAVE_STRING_H */
-#  include <strings.h>
-#endif /* !HAVE_STRING_H */  
-
-#if defined (HAVE_STDLIB_H)
-#  include <stdlib.h>
-#else
-#  include "ansi_stdlib.h"
-#endif /* HAVE_STDLIB_H */
-
-#include <sys/types.h>
-#if defined (HAVE_PWD_H)
-#include <pwd.h>
-#endif
-
-#include "tilde.h"
-
-#if defined (TEST) || defined (STATIC_MALLOC)
-static void *xmalloc (), *xrealloc ();
-#else
-#  include "xmalloc.h"
-#endif /* TEST || STATIC_MALLOC */
-
-#if !defined (HAVE_GETPW_DECLS)
-#  if defined (HAVE_GETPWUID)
-extern struct passwd *getpwuid (uid_t);
-#  endif
-#  if defined (HAVE_GETPWNAM)
-extern struct passwd *getpwnam (const char *);
-#  endif
-#endif /* !HAVE_GETPW_DECLS */
-
-#if !defined (savestring)
-#define savestring(x) strcpy ((char *)xmalloc (1 + strlen (x)), (x))
-#endif /* !savestring */
-
-#if !defined (NULL)
-#  if defined (__STDC__)
-#    define NULL ((void *) 0)
-#  else
-#    define NULL 0x0
-#  endif /* !__STDC__ */
-#endif /* !NULL */
-
-/* If being compiled as part of bash, these will be satisfied from
-   variables.o.  If being compiled as part of readline, they will
-   be satisfied from shell.o. */
-extern char *sh_get_home_dir (void);
-extern char *sh_get_env_value (const char *);
-
-/* The default value of tilde_additional_prefixes.  This is set to
-   whitespace preceding a tilde so that simple programs which do not
-   perform any word separation get desired behaviour. */
-static const char *default_prefixes[] =
-  { " ~", "\t~", (const char *)NULL };
-
-/* The default value of tilde_additional_suffixes.  This is set to
-   whitespace or newline so that simple programs which do not
-   perform any word separation get desired behaviour. */
-static const char *default_suffixes[] =
-  { " ", "\n", (const char *)NULL };
-
-/* If non-null, this contains the address of a function that the application
-   wants called before trying the standard tilde expansions.  The function
-   is called with the text sans tilde, and returns a malloc()'ed string
-   which is the expansion, or a NULL pointer if the expansion fails. */
-tilde_hook_func_t *tilde_expansion_preexpansion_hook = (tilde_hook_func_t *)NULL;
-
-/* If non-null, this contains the address of a function to call if the
-   standard meaning for expanding a tilde fails.  The function is called
-   with the text (sans tilde, as in "foo"), and returns a malloc()'ed string
-   which is the expansion, or a NULL pointer if there is no expansion. */
-tilde_hook_func_t *tilde_expansion_failure_hook = (tilde_hook_func_t *)NULL;
-
-/* When non-null, this is a NULL terminated array of strings which
-   are duplicates for a tilde prefix.  Bash uses this to expand
-   `=~' and `:~'. */
-char **tilde_additional_prefixes = (char **)default_prefixes;
-
-/* When non-null, this is a NULL terminated array of strings which match
-   the end of a username, instead of just "/".  Bash sets this to
-   `:' and `=~'. */
-char **tilde_additional_suffixes = (char **)default_suffixes;
-
-static int tilde_find_prefix (const char *, int *);
-static int tilde_find_suffix (const char *);
-static char *isolate_tilde_prefix (const char *, int *);
-static char *glue_prefix_and_suffix (char *, const char *, int);
-
-/* Find the start of a tilde expansion in STRING, and return the index of
-   the tilde which starts the expansion.  Place the length of the text
-   which identified this tilde starter in LEN, excluding the tilde itself. */
-static int
-tilde_find_prefix (const char *string, int *len)
-{
-  register int i, j, string_len;
-  register char **prefixes;
-
-  prefixes = tilde_additional_prefixes;
-
-  string_len = strlen (string);
-  *len = 0;
-
-  if (*string == '\0' || *string == '~')
-    return (0);
-
-  if (prefixes)
-    {
-      for (i = 0; i < string_len; i++)
-	{
-	  for (j = 0; prefixes[j]; j++)
-	    {
-	      if (strncmp (string + i, prefixes[j], strlen (prefixes[j])) == 0)
-		{
-		  *len = strlen (prefixes[j]) - 1;
-		  return (i + *len);
-		}
-	    }
-	}
-    }
-  return (string_len);
-}
-
-/* Find the end of a tilde expansion in STRING, and return the index of
-   the character which ends the tilde definition.  */
-static int
-tilde_find_suffix (const char *string)
-{
-  register int i, j, string_len;
-  register char **suffixes;
-
-  suffixes = tilde_additional_suffixes;
-  string_len = strlen (string);
-
-  for (i = 0; i < string_len; i++)
-    {
-#if defined (__MSDOS__)
-      if (string[i] == '/' || string[i] == '\\' /* || !string[i] */)
-#else
-      if (string[i] == '/' /* || !string[i] */)
-#endif
-	break;
-
-      for (j = 0; suffixes && suffixes[j]; j++)
-	{
-	  if (strncmp (string + i, suffixes[j], strlen (suffixes[j])) == 0)
-	    return (i);
-	}
-    }
-  return (i);
-}
-
-/* Return a new string which is the result of tilde expanding STRING. */
-char *
-tilde_expand (const char *string)
-{
-  char *result;
-  int result_size, result_index;
-
-  result_index = result_size = 0;
-  if (result = strchr (string, '~'))
-    result = (char *)xmalloc (result_size = (strlen (string) + 16));
-  else
-    result = (char *)xmalloc (result_size = (strlen (string) + 1));
-
-  /* Scan through STRING expanding tildes as we come to them. */
-  while (1)
-    {
-      register int start, end;
-      char *tilde_word, *expansion;
-      int len;
-
-      /* Make START point to the tilde which starts the expansion. */
-      start = tilde_find_prefix (string, &len);
-
-      /* Copy the skipped text into the result. */
-      if ((result_index + start + 1) > result_size)
-	result = (char *)xrealloc (result, 1 + (result_size += (start + 20)));
-
-      strncpy (result + result_index, string, start);
-      result_index += start;
-
-      /* Advance STRING to the starting tilde. */
-      string += start;
-
-      /* Make END be the index of one after the last character of the
-	 username. */
-      end = tilde_find_suffix (string);
-
-      /* If both START and END are zero, we are all done. */
-      if (!start && !end)
-	break;
-
-      /* Expand the entire tilde word, and copy it into RESULT. */
-      tilde_word = (char *)xmalloc (1 + end);
-      strncpy (tilde_word, string, end);
-      tilde_word[end] = '\0';
-      string += end;
-
-      expansion = tilde_expand_word (tilde_word);
-
-      if (expansion == 0)
-	expansion = tilde_word;
-      else
-	xfree (tilde_word);	
-
-      len = strlen (expansion);
-#ifdef __CYGWIN__
-      /* Fix for Cygwin to prevent ~user/xxx from expanding to //xxx when
-	 $HOME for `user' is /.  On cygwin, // denotes a network drive. */
-      if (len > 1 || *expansion != '/' || *string != '/')
-#endif
-	{
-	  if ((result_index + len + 1) > result_size)
-	    result = (char *)xrealloc (result, 1 + (result_size += (len + 20)));
-
-	  strcpy (result + result_index, expansion);
-	  result_index += len;
-	}
-      xfree (expansion);
-    }
-
-  result[result_index] = '\0';
-
-  return (result);
-}
-
-/* Take FNAME and return the tilde prefix we want expanded.  If LENP is
-   non-null, the index of the end of the prefix into FNAME is returned in
-   the location it points to. */
-static char *
-isolate_tilde_prefix (const char *fname, int *lenp)
-{
-  char *ret;
-  int i;
-
-  ret = (char *)xmalloc (strlen (fname));
-#if defined (__MSDOS__)
-  for (i = 1; fname[i] && fname[i] != '/' && fname[i] != '\\'; i++)
-#else
-  for (i = 1; fname[i] && fname[i] != '/'; i++)
-#endif
-    ret[i - 1] = fname[i];
-  ret[i - 1] = '\0';
-  if (lenp)
-    *lenp = i;
-  return ret;
-}
-
-#if 0
-/* Public function to scan a string (FNAME) beginning with a tilde and find
-   the portion of the string that should be passed to the tilde expansion
-   function.  Right now, it just calls tilde_find_suffix and allocates new
-   memory, but it can be expanded to do different things later. */
-char *
-tilde_find_word (const char *fname, int flags, int *lenp)
-{
-  int x;
-  char *r;
-
-  x = tilde_find_suffix (fname);
-  if (x == 0)
-    {
-      r = savestring (fname);
-      if (lenp)
-	*lenp = 0;
-    }
-  else
-    {
-      r = (char *)xmalloc (1 + x);
-      strncpy (r, fname, x);
-      r[x] = '\0';
-      if (lenp)
-	*lenp = x;
-    }
-
-  return r;
-}
-#endif
-
-/* Return a string that is PREFIX concatenated with SUFFIX starting at
-   SUFFIND. */
-static char *
-glue_prefix_and_suffix (char *prefix, const char *suffix, int suffind)
-{
-  char *ret;
-  int plen, slen;
-
-  plen = (prefix && *prefix) ? strlen (prefix) : 0;
-  slen = strlen (suffix + suffind);
-  ret = (char *)xmalloc (plen + slen + 1);
-  if (plen)
-    strcpy (ret, prefix);
-  strcpy (ret + plen, suffix + suffind);
-  return ret;
-}
-
-/* Do the work of tilde expansion on FILENAME.  FILENAME starts with a
-   tilde.  If there is no expansion, call tilde_expansion_failure_hook.
-   This always returns a newly-allocated string, never static storage. */
-char *
-tilde_expand_word (const char *filename)
-{
-  char *dirname, *expansion, *username;
-  int user_len;
-  struct passwd *user_entry;
-
-  if (filename == 0)
-    return ((char *)NULL);
-
-  if (*filename != '~')
-    return (savestring (filename));
-
-  /* A leading `~/' or a bare `~' is *always* translated to the value of
-     $HOME or the home directory of the current user, regardless of any
-     preexpansion hook. */
-  if (filename[1] == '\0' || filename[1] == '/')
-    {
-      /* Prefix $HOME to the rest of the string. */
-      expansion = sh_get_env_value ("HOME");
-#if defined (_WIN32)
-      if (expansion == 0)
-	expansion = sh_get_env_value ("APPDATA");
-#endif
-
-      /* If there is no HOME variable, look up the directory in
-	 the password database. */
-      if (expansion == 0)
-	expansion = sh_get_home_dir ();
-
-      return (glue_prefix_and_suffix (expansion, filename, 1));
-    }
-
-  username = isolate_tilde_prefix (filename, &user_len);
-
-  if (tilde_expansion_preexpansion_hook)
-    {
-      expansion = (*tilde_expansion_preexpansion_hook) (username);
-      if (expansion)
-	{
-	  dirname = glue_prefix_and_suffix (expansion, filename, user_len);
-	  xfree (username);
-	  xfree (expansion);
-	  return (dirname);
-	}
-    }
-
-  /* No preexpansion hook, or the preexpansion hook failed.  Look in the
-     password database. */
-  dirname = (char *)NULL;
-#if defined (HAVE_GETPWNAM)
-  user_entry = getpwnam (username);
-#else
-  user_entry = 0;
-#endif
-  if (user_entry == 0)
-    {
-      /* If the calling program has a special syntax for expanding tildes,
-	 and we couldn't find a standard expansion, then let them try. */
-      if (tilde_expansion_failure_hook)
-	{
-	  expansion = (*tilde_expansion_failure_hook) (username);
-	  if (expansion)
-	    {
-	      dirname = glue_prefix_and_suffix (expansion, filename, user_len);
-	      xfree (expansion);
-	    }
-	}
-      /* If we don't have a failure hook, or if the failure hook did not
-	 expand the tilde, return a copy of what we were passed. */
-      if (dirname == 0)
-	dirname = savestring (filename);
-    }
-#if defined (HAVE_GETPWENT)
-  else
-    dirname = glue_prefix_and_suffix (user_entry->pw_dir, filename, user_len);
-#endif
-
-  xfree (username);
-#if defined (HAVE_GETPWENT)
-  endpwent ();
-#endif
-  return (dirname);
-}
-
-
-#if defined (TEST)
-#undef NULL
-#include <stdio.h>
-
-main (int argc, char **argv)
-{
-  char *result, line[512];
-  int done = 0;
-
-  while (!done)
-    {
-      printf ("~expand: ");
-      fflush (stdout);
-
-      if (!gets (line))
-	strcpy (line, "done");
-
-      if ((strcmp (line, "done") == 0) ||
-	  (strcmp (line, "quit") == 0) ||
-	  (strcmp (line, "exit") == 0))
-	{
-	  done = 1;
-	  break;
-	}
-
-      result = tilde_expand (line);
-      printf ("  --> %s\n", result);
-      free (result);
-    }
-  exit (0);
-}
-
-static void memory_error_and_abort (void);
-
-static void *
-xmalloc (size_t bytes)
-{
-  void *temp = (char *)malloc (bytes);
-
-  if (!temp)
-    memory_error_and_abort ();
-  return (temp);
-}
-
-static void *
-xrealloc (void *pointer, int bytes)
-{
-  void *temp;
-
-  if (!pointer)
-    temp = malloc (bytes);
-  else
-    temp = realloc (pointer, bytes);
-
-  if (!temp)
-    memory_error_and_abort ();
-
-  return (temp);
-}
-
-static void
-memory_error_and_abort (void)
-{
-  fprintf (stderr, "readline: out of virtual memory\n");
-  abort ();
-}
-
-/*
- * Local variables:
- * compile-command: "gcc -g -DTEST -o tilde tilde.c"
- * end:
- */
-#endif /* TEST */
diff --git a/third_party/bash/tilde.h b/third_party/bash/tilde.h
deleted file mode 100644
index bc8022afc..000000000
--- a/third_party/bash/tilde.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/* tilde.h: Externally available variables and function in libtilde.a. */
-
-/* Copyright (C) 1992-2009,2021 Free Software Foundation, Inc.
-
-   This file contains the Readline Library (Readline), a set of
-   routines for providing Emacs style line input to programs that ask
-   for it.
-
-   Readline is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Readline is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Readline.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_TILDE_H_)
-#  define _TILDE_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef char *tilde_hook_func_t (char *);
-
-/* If non-null, this contains the address of a function that the application
-   wants called before trying the standard tilde expansions.  The function
-   is called with the text sans tilde, and returns a malloc()'ed string
-   which is the expansion, or a NULL pointer if the expansion fails. */
-extern tilde_hook_func_t *tilde_expansion_preexpansion_hook;
-
-/* If non-null, this contains the address of a function to call if the
-   standard meaning for expanding a tilde fails.  The function is called
-   with the text (sans tilde, as in "foo"), and returns a malloc()'ed string
-   which is the expansion, or a NULL pointer if there is no expansion. */
-extern tilde_hook_func_t *tilde_expansion_failure_hook;
-
-/* When non-null, this is a NULL terminated array of strings which
-   are duplicates for a tilde prefix.  Bash uses this to expand
-   `=~' and `:~'. */
-extern char **tilde_additional_prefixes;
-
-/* When non-null, this is a NULL terminated array of strings which match
-   the end of a username, instead of just "/".  Bash sets this to
-   `:' and `=~'. */
-extern char **tilde_additional_suffixes;
-
-/* Return a new string which is the result of tilde expanding STRING. */
-extern char *tilde_expand (const char *);
-
-/* Do the work of tilde expansion on FILENAME.  FILENAME starts with a
-   tilde.  If there is no expansion, call tilde_expansion_failure_hook. */
-extern char *tilde_expand_word (const char *);
-
-/* Find the portion of the string beginning with ~ that should be expanded. */
-extern char *tilde_find_word (const char *, int, int *);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _TILDE_H_ */
diff --git a/third_party/bash/timer.h b/third_party/bash/timer.h
deleted file mode 100644
index 277947563..000000000
--- a/third_party/bash/timer.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/* timer.h -- data structures used by the shell timers in lib/sh/timers.c */
-
-/* Copyright (C) 2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "bashjmp.h"
-typedef struct _shtimer
-{
-  struct timeval tmout;
-
-  int fd;
-  int flags;
-
-  int alrmflag;					/* should be set by alrm_handler */
-
-  SigHandler *alrm_handler;
-  SigHandler *old_handler;
-
-  procenv_t jmpenv;
-
-  int (*tm_handler) (struct _shtimer *);	/* called on timeout if set */
-  PTR_T	*data;					/* reserved */
-} sh_timer;
-
-#define SHTIMER_ALARM	0x01			/* mutually exclusive */
-#define SHTIMER_SELECT	0x02
-#define SHTIMER_LONGJMP	0x04
-
-#define SHTIMER_SIGSET	0x100
-#define SHTIMER_ALRMSET	0x200
-
-extern sh_timer *shtimer_alloc (void);
-extern void shtimer_flush (sh_timer *);
-extern void shtimer_dispose (sh_timer *);
-
-extern void shtimer_set (sh_timer *, time_t, long);
-extern void shtimer_unset (sh_timer *);
-
-extern void shtimer_cleanup (sh_timer *);
-extern void shtimer_clear (sh_timer *);
-
-extern int shtimer_chktimeout (sh_timer *);
-
-extern int shtimer_select (sh_timer *);
-extern int shtimer_alrm (sh_timer *);
diff --git a/third_party/bash/timers.c b/third_party/bash/timers.c
deleted file mode 100644
index 69b754c97..000000000
--- a/third_party/bash/timers.c
+++ /dev/null
@@ -1,262 +0,0 @@
-/* timers - functions to manage shell timers */
-
-/* Copyright (C) 2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "posixtime.h"
-
-#if defined (HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-
-#if defined (HAVE_SELECT)
-#  include "posixselect.h"
-#  include "stat-time.h"
-#endif
-
-#include "sig.h"
-#include "bashjmp.h"
-#include "xmalloc.h"
-
-#include "timer.h"
-
-#include <errno.h>
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#ifndef FREE
-#define FREE(s)  do { if (s) free (s); } while (0)
-#endif
-
-extern unsigned int falarm (unsigned int, unsigned int);
-
-static void shtimer_zero (sh_timer *);
-
-static void
-shtimer_zero (sh_timer *t)
-{
-  t->tmout.tv_sec = 0;
-  t->tmout.tv_usec = 0;
-
-  t->fd = -1;
-  t->flags = t->alrmflag = 0;
-
-  t->alrm_handler = t->old_handler = 0;
-
-  memset (t->jmpenv, '\0', sizeof (t->jmpenv));
-
-  t->tm_handler = 0;
-  t->data = 0;
-}
-
-sh_timer *
-shtimer_alloc (void)
-{
-  sh_timer *t;
-
-  t = (sh_timer *)xmalloc (sizeof (sh_timer));
-  shtimer_zero (t);
-  return t;
-}
-
-void
-shtimer_flush (sh_timer *t)
-{
-  /* The caller can manage t->data arbitrarily as long as it frees and sets
-     t->data to 0 before calling this function. Otherwise, we do what we can
-     to avoid memleaks. */
-  FREE (t->data);
-  shtimer_zero (t);
-}
-
-void
-shtimer_dispose (sh_timer *t)
-{
-  free (t);
-}
-
-/* We keep the timer as an offset into the future from the time it's set. */
-void
-shtimer_set (sh_timer *t, time_t sec, long usec)
-{
-  struct timeval now;
-
-  if (t->flags & SHTIMER_ALARM)
-    {
-      t->alrmflag = 0;		/* just paranoia */
-      t->old_handler = set_signal_handler (SIGALRM, t->alrm_handler);
-      t->flags |= SHTIMER_SIGSET;
-      falarm (t->tmout.tv_sec = sec, t->tmout.tv_usec = usec);
-      t->flags |= SHTIMER_ALRMSET;
-      return;
-    }
-
-  if (gettimeofday (&now, 0) < 0)
-    timerclear (&now);
-
-  t->tmout.tv_sec = now.tv_sec + sec;
-  t->tmout.tv_usec = now.tv_usec + usec;
-  if (t->tmout.tv_usec > USEC_PER_SEC)
-    {
-      t->tmout.tv_sec++;
-      t->tmout.tv_usec -= USEC_PER_SEC;
-    }
-}
-
-void
-shtimer_unset (sh_timer *t)
-{
-  t->tmout.tv_sec = 0;
-  t->tmout.tv_usec = 0;
-
-  if (t->flags & SHTIMER_ALARM)
-    {
-      t->alrmflag = 0;
-      if (t->flags & SHTIMER_ALRMSET)
-	falarm (0, 0);
-      if (t->old_handler && (t->flags & SHTIMER_SIGSET))
-	{
-	  set_signal_handler (SIGALRM, t->old_handler);
-	  t->flags &= ~SHTIMER_SIGSET;
-	  t->old_handler = 0;
-	}
-    }
-}
-
-void
-shtimer_cleanup (sh_timer *t)
-{
-  shtimer_unset (t);
-}
-
-void
-shtimer_clear (sh_timer *t)
-{
-  shtimer_unset (t);
-  shtimer_dispose (t);
-}
-
-int
-shtimer_chktimeout (sh_timer *t)
-{
-  struct timeval now;
-  int r;
-
-  /* Use the flag to avoid returning sigalrm_seen here */
-  if (t->flags & SHTIMER_ALARM)
-    return t->alrmflag;
-
-  /* Could check a flag for this */
-  if (t->tmout.tv_sec == 0 && t->tmout.tv_usec == 0)
-    return 0;
-
-  if (gettimeofday (&now, 0) < 0)
-    return 0;
-  r = ((now.tv_sec > t->tmout.tv_sec) ||
-	(now.tv_sec == t->tmout.tv_sec && now.tv_usec >= t->tmout.tv_usec));
-
-  return r;
-}
-
-#if defined (HAVE_SELECT) || defined (HAVE_PSELECT)
-int
-shtimer_select (sh_timer *t)
-{
-  int r, nfd;
-  sigset_t blocked_sigs, prevmask;
-  struct timeval now, tv;
-  fd_set readfds;
-#if defined (HAVE_PSELECT)
-  struct timespec ts;
-#endif
-
-  /* We don't want a SIGCHLD to interrupt this */
-  sigemptyset (&blocked_sigs);
-#  if defined (SIGCHLD)
-  sigaddset (&blocked_sigs, SIGCHLD);
-#  endif
-
-  if (gettimeofday (&now, 0) < 0)
-    {
-      if (t->flags & SHTIMER_LONGJMP)
-	sh_longjmp (t->jmpenv, 1);
-      else
-	return -1;
-    }
-
-  /* If the timer has already expired, return immediately */    
-  if ((now.tv_sec > t->tmout.tv_sec) ||
-	(now.tv_sec == t->tmout.tv_sec && now.tv_usec >= t->tmout.tv_usec))
-    {
-      if (t->flags & SHTIMER_LONGJMP)
-	sh_longjmp (t->jmpenv, 1);
-      else if (t->tm_handler)
-	return ((*t->tm_handler) (t));
-      else
-	return 0;
-    }
-
-  /* compute timeout */
-  tv.tv_sec = t->tmout.tv_sec - now.tv_sec;
-  tv.tv_usec = t->tmout.tv_usec - now.tv_usec;
-  if (tv.tv_usec < 0)
-    {
-      tv.tv_sec--;
-      tv.tv_usec += USEC_PER_SEC;
-    }
-
-#if defined (HAVE_PSELECT)
-  ts.tv_sec = tv.tv_sec;
-  ts.tv_nsec = tv.tv_usec * 1000;
-#else
-  sigemptyset (&prevmask);
-#endif /* !HAVE_PSELECT */
-
-  nfd = (t->fd >= 0) ? t->fd + 1 : 0;
-  FD_ZERO (&readfds);
-  if (t->fd >= 0)
-    FD_SET (t->fd, &readfds);
-
-#if defined (HAVE_PSELECT)
-  r = pselect(nfd, &readfds, (fd_set *)0, (fd_set *)0, &ts, &blocked_sigs);
-#else
-  sigprocmask (SIG_SETMASK, &blocked_sigs, &prevmask);
-  r = select(nfd, &readfds, (fd_set *)0, (fd_set *)0, &tv);
-  sigprocmask (SIG_SETMASK, &prevmask, NULL);
-#endif
-
-  if (r < 0)
-    return r;		/* caller will handle */
-  else if (r == 0 && (t->flags & SHTIMER_LONGJMP))
-    sh_longjmp (t->jmpenv, 1);
-  else if (r == 0 && t->tm_handler)
-    return ((*t->tm_handler) (t));
-  else
-    return r;
-}
-#endif /* !HAVE_TIMEVAL || !HAVE_SELECT */
-
-int
-shtimer_alrm (sh_timer *t)
-{
-  return 0;
-}
diff --git a/third_party/bash/timeval.c b/third_party/bash/timeval.c
deleted file mode 100644
index a5a5bc946..000000000
--- a/third_party/bash/timeval.c
+++ /dev/null
@@ -1,179 +0,0 @@
-/* timeval.c - functions to perform operations on struct timevals */
-
-/* Copyright (C) 1999 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_TIMEVAL)
-
-#include <sys/types.h>
-#include "posixtime.h"
-
-#include "bashintl.h"
-#include "stdc.h"
-
-#ifndef locale_decpoint
-extern int locale_decpoint PARAMS((void));
-#endif
-
-#include <stdio.h>
-
-struct timeval *
-difftimeval (d, t1, t2)
-     struct timeval *d, *t1, *t2;
-{
-  d->tv_sec = t2->tv_sec - t1->tv_sec;
-  d->tv_usec = t2->tv_usec - t1->tv_usec;
-  if (d->tv_usec < 0)
-    {
-      d->tv_usec += 1000000;
-      d->tv_sec -= 1;
-      if (d->tv_sec < 0)		/* ??? -- BSD/OS does this */
-	{
-	  d->tv_sec = 0;
-	  d->tv_usec = 0;
-	}
-    }
-  return d;
-}
-
-struct timeval *
-addtimeval (d, t1, t2)
-     struct timeval *d, *t1, *t2;
-{
-  d->tv_sec = t1->tv_sec + t2->tv_sec;
-  d->tv_usec = t1->tv_usec + t2->tv_usec;
-  if (d->tv_usec >= 1000000)
-    {
-      d->tv_usec -= 1000000;
-      d->tv_sec += 1;
-    }
-  return d;
-}
-
-struct timeval *
-multimeval (d, m)
-     struct timeval *d;
-     int m;
-{
-  time_t t;
-
-  t = d->tv_usec * m;
-  d->tv_sec = d->tv_sec * m + t / 1000000;
-  d->tv_usec = t % 1000000;
-  return d;
-}
-
-struct timeval *
-divtimeval (d, m)
-     struct timeval *d;
-     int m;
-{
-  time_t t;
-
-  t = d->tv_sec;
-  d->tv_sec = t / m;
-  d->tv_usec = (d->tv_usec + 1000000 * (t % m)) / m;
-  return d;
-}
-  
-/* Do "cpu = ((user + sys) * 10000) / real;" with timevals.
-   Barely-tested code from Deven T. Corzine <deven@ties.org>. */
-int
-timeval_to_cpu (rt, ut, st)
-     struct timeval *rt, *ut, *st;	/* real, user, sys */
-{
-  struct timeval t1, t2;
-  register int i;
-
-  addtimeval (&t1, ut, st);
-  t2.tv_sec = rt->tv_sec;
-  t2.tv_usec = rt->tv_usec;
-
-  for (i = 0; i < 6; i++)
-    {
-      if ((t1.tv_sec > 99999999) || (t2.tv_sec > 99999999))
-	break;
-      t1.tv_sec *= 10;
-      t1.tv_sec += t1.tv_usec / 100000;
-      t1.tv_usec *= 10;
-      t1.tv_usec %= 1000000;
-      t2.tv_sec *= 10;
-      t2.tv_sec += t2.tv_usec / 100000;
-      t2.tv_usec *= 10;
-      t2.tv_usec %= 1000000;
-    }
-  for (i = 0; i < 4; i++)
-    {
-      if (t1.tv_sec < 100000000)
-	t1.tv_sec *= 10;
-      else
-	t2.tv_sec /= 10;
-    }
-
-  return ((t2.tv_sec == 0) ? 0 : t1.tv_sec / t2.tv_sec);
-}  
-
-/* Convert a pointer to a struct timeval to seconds and thousandths of a
-   second, returning the values in *SP and *SFP, respectively.  This does
-   rounding on the fractional part, not just truncation to three places. */
-void
-timeval_to_secs (tvp, sp, sfp)
-     struct timeval *tvp;
-     time_t *sp;
-     int *sfp;
-{
-  int rest;
-
-  *sp = tvp->tv_sec;
-
-  *sfp = tvp->tv_usec % 1000000;	/* pretty much a no-op */
-  rest = *sfp % 1000;
-  *sfp = (*sfp * 1000) / 1000000;
-  if (rest >= 500)
-    *sfp += 1;
-
-  /* Sanity check */
-  if (*sfp >= 1000)
-    {
-      *sp += 1;
-      *sfp -= 1000;
-    }
-}
-  
-/* Print the contents of a struct timeval * in a standard way to stdio
-   stream FP.  */
-void
-print_timeval (fp, tvp)
-     FILE *fp;
-     struct timeval *tvp;
-{
-  time_t timestamp;
-  long minutes;
-  int seconds, seconds_fraction;
-
-  timeval_to_secs (tvp, &timestamp, &seconds_fraction);
-
-  minutes = timestamp / 60;
-  seconds = timestamp % 60;
-
-  fprintf (fp, "%ldm%d%c%03ds",  minutes, seconds, locale_decpoint (), seconds_fraction);
-}
-
-#endif /* HAVE_TIMEVAL */
diff --git a/third_party/bash/tmpfile.c b/third_party/bash/tmpfile.c
deleted file mode 100644
index 8f5cf3f11..000000000
--- a/third_party/bash/tmpfile.c
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * tmpfile.c - functions to create and safely open temp files for the shell.
- */
-
-/* Copyright (C) 2000-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "posixstat.h"
-#include "posixtime.h"
-#include "filecntl.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashansi.h"
-
-#include <stdio.h>
-#include <errno.h>
-
-#include "shell.h"
-
-#ifndef errno
-extern int errno;
-#endif
-
-#define BASEOPENFLAGS	(O_CREAT | O_TRUNC | O_EXCL | O_BINARY)
-
-#define DEFAULT_TMPDIR		"."	/* bogus default, should be changed */
-#define DEFAULT_NAMEROOT	"shtmp"
-
-/* Use ANSI-C rand() interface if random(3) is not available */
-#if !HAVE_RANDOM
-#define random() rand()
-#endif
-
-extern pid_t dollar_dollar_pid;
-
-static char *get_sys_tmpdir PARAMS((void));
-static char *get_tmpdir PARAMS((int));
-
-static char *sys_tmpdir = (char *)NULL;
-static int ntmpfiles;
-static int tmpnamelen = -1;
-static unsigned long filenum = 1L;
-
-static char *
-get_sys_tmpdir ()
-{
-  if (sys_tmpdir)
-    return sys_tmpdir;
-
-#ifdef P_tmpdir
-  sys_tmpdir = P_tmpdir;
-  if (file_iswdir (sys_tmpdir))
-    return sys_tmpdir;
-#endif
-
-  sys_tmpdir = "/tmp";
-  if (file_iswdir (sys_tmpdir))
-    return sys_tmpdir;
-
-  sys_tmpdir = "/var/tmp";
-  if (file_iswdir (sys_tmpdir))
-    return sys_tmpdir;
-
-  sys_tmpdir = "/usr/tmp";
-  if (file_iswdir (sys_tmpdir))
-    return sys_tmpdir;
-
-  sys_tmpdir = DEFAULT_TMPDIR;
-
-  return sys_tmpdir;
-}
-
-static char *
-get_tmpdir (flags)
-     int flags;
-{
-  char *tdir;
-
-  tdir = (flags & MT_USETMPDIR) ? get_string_value ("TMPDIR") : (char *)NULL;
-  if (tdir && (file_iswdir (tdir) == 0 || strlen (tdir) > PATH_MAX))
-    tdir = 0;
-
-  if (tdir == 0)
-    tdir = get_sys_tmpdir ();
-
-#if defined (HAVE_PATHCONF) && defined (_PC_NAME_MAX)
-  if (tmpnamelen == -1)
-    tmpnamelen = pathconf (tdir, _PC_NAME_MAX);
-#else
-  tmpnamelen = 0;
-#endif
-
-  return tdir;
-}
-
-static void
-sh_seedrand ()
-{
-#if HAVE_RANDOM
-  int d;
-  static int seeded = 0;
-  if (seeded == 0)
-    {
-      struct timeval tv;
-  	      
-      gettimeofday (&tv, NULL);
-      srandom (tv.tv_sec ^ tv.tv_usec ^ (getpid () << 16) ^ (uintptr_t)&d);
-      seeded = 1;
-    }
-#endif
-}
-
-char *
-sh_mktmpname (nameroot, flags)
-     char *nameroot;
-     int flags;
-{
-  char *filename, *tdir, *lroot;
-  struct stat sb;
-  int r, tdlen;
-  static int seeded = 0;
-
-  filename = (char *)xmalloc (PATH_MAX + 1);
-  tdir = get_tmpdir (flags);
-  tdlen = strlen (tdir);
-
-  lroot = nameroot ? nameroot : DEFAULT_NAMEROOT;
-  if (nameroot == 0)
-    flags &= ~MT_TEMPLATE;
-
-  if ((flags & MT_TEMPLATE) && strlen (nameroot) > PATH_MAX)
-    flags &= ~MT_TEMPLATE;
-
-#ifdef USE_MKTEMP
-  if (flags & MT_TEMPLATE)
-    strcpy (filename, nameroot);
-  else
-    sprintf (filename, "%s/%s.XXXXXX", tdir, lroot);
-  if (mktemp (filename) == 0)
-    {
-      free (filename);
-      filename = NULL;
-    }
-#else  /* !USE_MKTEMP */
-  sh_seedrand ();
-  while (1)
-    {
-      filenum = (filenum << 1) ^
-		(unsigned long) time ((time_t *)0) ^
-		(unsigned long) dollar_dollar_pid ^
-		(unsigned long) ((flags & MT_USERANDOM) ? random () : ntmpfiles++);
-      sprintf (filename, "%s/%s-%lu", tdir, lroot, filenum);
-      if (tmpnamelen > 0 && tmpnamelen < 32)
-	filename[tdlen + 1 + tmpnamelen] = '\0';
-#  ifdef HAVE_LSTAT
-      r = lstat (filename, &sb);
-#  else
-      r = stat (filename, &sb);
-#  endif
-      if (r < 0 && errno == ENOENT)
-	break;
-    }
-#endif /* !USE_MKTEMP */
-
-  return filename;
-}
-
-int
-sh_mktmpfd (nameroot, flags, namep)
-     char *nameroot;
-     int flags;
-     char **namep;
-{
-  char *filename, *tdir, *lroot;
-  int fd, tdlen;
-  
-  filename = (char *)xmalloc (PATH_MAX + 1);
-  tdir = get_tmpdir (flags);
-  tdlen = strlen (tdir);
-
-  lroot = nameroot ? nameroot : DEFAULT_NAMEROOT;
-  if (nameroot == 0)
-    flags &= ~MT_TEMPLATE;
-
-  if ((flags & MT_TEMPLATE) && strlen (nameroot) > PATH_MAX)
-    flags &= ~MT_TEMPLATE;
-
-#ifdef USE_MKSTEMP
-  if (flags & MT_TEMPLATE)
-    strcpy (filename, nameroot);
-  else
-    sprintf (filename, "%s/%s.XXXXXX", tdir, lroot);
-  fd = mkstemp (filename);
-  if (fd < 0 || namep == 0)
-    {
-      free (filename);
-      filename = NULL;
-    }
-  if (namep)
-    *namep = filename;
-  return fd;
-#else /* !USE_MKSTEMP */
-  sh_seedrand ();
-  do
-    {
-      filenum = (filenum << 1) ^
-		(unsigned long) time ((time_t *)0) ^
-		(unsigned long) dollar_dollar_pid ^
-		(unsigned long) ((flags & MT_USERANDOM) ? random () : ntmpfiles++);
-      sprintf (filename, "%s/%s-%lu", tdir, lroot, filenum);
-      if (tmpnamelen > 0 && tmpnamelen < 32)
-	filename[tdlen + 1 + tmpnamelen] = '\0';
-      fd = open (filename, BASEOPENFLAGS | ((flags & MT_READWRITE) ? O_RDWR : O_WRONLY), 0600);
-    }
-  while (fd < 0 && errno == EEXIST);
-
-  if (namep)
-    *namep = filename;
-  else
-    free (filename);
-
-  return fd;
-#endif /* !USE_MKSTEMP */
-}
-
-FILE *
-sh_mktmpfp (nameroot, flags, namep)
-     char *nameroot;
-     int flags;
-     char **namep;
-{
-  int fd;
-  FILE *fp;
-
-  fd = sh_mktmpfd (nameroot, flags, namep);
-  if (fd < 0)
-    return ((FILE *)NULL);
-  fp = fdopen (fd, (flags & MT_READWRITE) ? "w+" : "w");
-  if (fp == 0)
-    close (fd);
-  return fp;
-}
-
-char *
-sh_mktmpdir (nameroot, flags)
-     char *nameroot;
-     int flags;
-{
-  char *filename, *tdir, *lroot, *dirname;
-  int fd, tdlen;
-  
-#ifdef USE_MKDTEMP
-  filename = (char *)xmalloc (PATH_MAX + 1);
-  tdir = get_tmpdir (flags);
-  tdlen = strlen (tdir);
-
-  lroot = nameroot ? nameroot : DEFAULT_NAMEROOT;
-  if (nameroot == 0)
-    flags &= ~MT_TEMPLATE;
-
-  if ((flags & MT_TEMPLATE) && strlen (nameroot) > PATH_MAX)
-    flags &= ~MT_TEMPLATE;
-
-  if (flags & MT_TEMPLATE)
-    strcpy (filename, nameroot);
-  else
-    sprintf (filename, "%s/%s.XXXXXX", tdir, lroot);
-  dirname = mkdtemp (filename);
-  if (dirname == 0)
-    {
-      free (filename);
-      filename = NULL;
-    }
-  return dirname;
-#else /* !USE_MKDTEMP */
-  filename = (char *)NULL;
-  do
-    {
-      filename = sh_mktmpname (nameroot, flags);
-      fd = mkdir (filename, 0700);
-      if (fd == 0)
-	break;
-      free (filename);
-      filename = (char *)NULL;
-    }
-  while (fd < 0 && errno == EEXIST);
-
-  return (filename);
-#endif /* !USE_MKDTEMP */
-}
diff --git a/third_party/bash/trap.c b/third_party/bash/trap.c
deleted file mode 100644
index 40afd9a78..000000000
--- a/third_party/bash/trap.c
+++ /dev/null
@@ -1,1575 +0,0 @@
-/* trap.c -- Not the trap command, but useful functions for manipulating
-   those objects.  The trap command is in builtins/trap.def. */
-
-/* Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include "bashtypes.h"
-#include "bashansi.h"
-
-#include <stdio.h>
-#include <errno.h>
-
-#include "bashintl.h"
-
-#include <signal.h>
-
-#include "trap.h"
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "flags.h"
-#include "parser.h"
-#include "input.h"	/* for save_token_state, restore_token_state */
-#include "jobs.h"
-#include "signames.h"
-#include "builtins.h"
-#include "common.h"
-#include "builtext.h"
-
-#if defined (READLINE)
-#  include "third_party/readline/readline.h"
-#  include "bashline.h"
-#endif
-
-#ifndef errno
-extern int errno;
-#endif
-
-/* Flags which describe the current handling state of a signal. */
-#define SIG_INHERITED   0x0	/* Value inherited from parent. */
-#define SIG_TRAPPED     0x1	/* Currently trapped. */
-#define SIG_HARD_IGNORE 0x2	/* Signal was ignored on shell entry. */
-#define SIG_SPECIAL     0x4	/* Treat this signal specially. */
-#define SIG_NO_TRAP     0x8	/* Signal cannot be trapped. */
-#define SIG_INPROGRESS	0x10	/* Signal handler currently executing. */
-#define SIG_CHANGED	0x20	/* Trap value changed in trap handler. */
-#define SIG_IGNORED	0x40	/* The signal is currently being ignored. */
-
-#define SPECIAL_TRAP(s)	((s) == EXIT_TRAP || (s) == DEBUG_TRAP || (s) == ERROR_TRAP || (s) == RETURN_TRAP)
-
-/* An array of such flags, one for each signal, describing what the
-   shell will do with a signal.  DEBUG_TRAP == NSIG; some code below
-   assumes this. */
-static int sigmodes[BASH_NSIG];
-
-static void free_trap_command (int);
-static void change_signal (int, char *);
-
-static int _run_trap_internal (int, char *);
-
-static void free_trap_string (int);
-static void reset_signal (int);
-static void restore_signal (int);
-static void reset_or_restore_signal_handlers (sh_resetsig_func_t *);
-static void reinit_trap (int);
-
-static void trap_if_untrapped (int, char *);
-
-/* Variables used here but defined in other files. */
-
-extern volatile int from_return_trap;
-extern int waiting_for_child;
-
-extern WORD_LIST *subst_assign_varlist;
-
-/* The list of things to do originally, before we started trapping. */
-SigHandler *original_signals[NSIG];
-
-/* For each signal, a slot for a string, which is a command to be
-   executed when that signal is received.  The slot can also contain
-   DEFAULT_SIG, which means do whatever you were going to do before
-   you were so rudely interrupted, or IGNORE_SIG, which says ignore
-   this signal. */
-char *trap_list[BASH_NSIG];
-
-/* A bitmap of signals received for which we have trap handlers. */
-int pending_traps[NSIG];
-
-/* Set to the number of the signal we're running the trap for + 1.
-   Used in execute_cmd.c and builtins/common.c to clean up when
-   parse_and_execute does not return normally after executing the
-   trap command (e.g., when `return' is executed in the trap command). */
-int running_trap;
-
-/* Set to last_command_exit_value before running a trap. */
-int trap_saved_exit_value;
-
-/* The (trapped) signal received while executing in the `wait' builtin */
-int wait_signal_received;
-
-int trapped_signal_received;
-
-/* Set to 1 to suppress the effect of `set v' in the DEBUG trap. */
-int suppress_debug_trap_verbose = 0;
-
-#define GETORIGSIG(sig) \
-  do { \
-    original_signals[sig] = (SigHandler *)set_signal_handler (sig, SIG_DFL); \
-    set_signal_handler (sig, original_signals[sig]); \
-    if (original_signals[sig] == SIG_IGN) \
-      sigmodes[sig] |= SIG_HARD_IGNORE; \
-  } while (0)
-
-#define SETORIGSIG(sig,handler) \
-  do { \
-    original_signals[sig] = handler; \
-    if (original_signals[sig] == SIG_IGN) \
-      sigmodes[sig] |= SIG_HARD_IGNORE; \
-  } while (0)
-
-#define GET_ORIGINAL_SIGNAL(sig) \
-  if (sig && sig < NSIG && original_signals[sig] == IMPOSSIBLE_TRAP_HANDLER) \
-    GETORIGSIG(sig)
-
-void
-initialize_traps ()
-{
-  register int i;
-
-  initialize_signames();
-
-  trap_list[EXIT_TRAP] = trap_list[DEBUG_TRAP] = trap_list[ERROR_TRAP] = trap_list[RETURN_TRAP] = (char *)NULL;
-  sigmodes[EXIT_TRAP] = sigmodes[DEBUG_TRAP] = sigmodes[ERROR_TRAP] = sigmodes[RETURN_TRAP] = SIG_INHERITED;
-  original_signals[EXIT_TRAP] = IMPOSSIBLE_TRAP_HANDLER;
-
-  for (i = 1; i < NSIG; i++)
-    {
-      pending_traps[i] = 0;
-      trap_list[i] = (char *)DEFAULT_SIG;
-      sigmodes[i] = SIG_INHERITED;	/* XXX - only set, not used */
-      original_signals[i] = IMPOSSIBLE_TRAP_HANDLER;
-    }
-
-  /* Show which signals are treated specially by the shell. */
-#if defined (SIGCHLD)
-  GETORIGSIG (SIGCHLD);
-  sigmodes[SIGCHLD] |= (SIG_SPECIAL | SIG_NO_TRAP);
-#endif /* SIGCHLD */
-
-  GETORIGSIG (SIGINT);
-  sigmodes[SIGINT] |= SIG_SPECIAL;
-
-#if defined (__BEOS__)
-  /* BeOS sets SIGINT to SIG_IGN! */
-  original_signals[SIGINT] = SIG_DFL;
-  sigmodes[SIGINT] &= ~SIG_HARD_IGNORE;
-#endif
-
-  GETORIGSIG (SIGQUIT);
-  sigmodes[SIGQUIT] |= SIG_SPECIAL;
-
-  if (interactive)
-    {
-      GETORIGSIG (SIGTERM);
-      sigmodes[SIGTERM] |= SIG_SPECIAL;
-    }
-
-  get_original_tty_job_signals ();
-}
-
-#ifdef DEBUG
-/* Return a printable representation of the trap handler for SIG. */
-static char *
-trap_handler_string (sig)
-     int sig;
-{
-  if (trap_list[sig] == (char *)DEFAULT_SIG)
-    return "DEFAULT_SIG";
-  else if (trap_list[sig] == (char *)IGNORE_SIG)
-    return "IGNORE_SIG";
-  else if (trap_list[sig] == (char *)IMPOSSIBLE_TRAP_HANDLER)
-    return "IMPOSSIBLE_TRAP_HANDLER";
-  else if (trap_list[sig])
-    return trap_list[sig];
-  else
-    return "NULL";
-}
-#endif
-
-/* Return the print name of this signal. */
-char *
-signal_name (sig)
-     int sig;
-{
-  char *ret;
-
-  /* on cygwin32, signal_names[sig] could be null */
-  ret = (sig >= BASH_NSIG || sig < 0 || signal_names[sig] == NULL)
-	? _("invalid signal number")
-	: signal_names[sig];
-
-  return ret;
-}
-
-/* Turn a string into a signal number, or a number into
-   a signal number.  If STRING is "2", "SIGINT", or "INT",
-   then (int)2 is returned.  Return NO_SIG if STRING doesn't
-   contain a valid signal descriptor. */
-int
-decode_signal (string, flags)
-     char *string;
-     int flags;
-{
-  intmax_t sig;
-  char *name;
-
-  if (legal_number (string, &sig))
-    return ((sig >= 0 && sig < NSIG) ? (int)sig : NO_SIG);
-
-#if defined (SIGRTMIN) && defined (SIGRTMAX)
-  if (STREQN (string, "SIGRTMIN+", 9) || ((flags & DSIG_NOCASE) && strncasecmp (string, "SIGRTMIN+", 9) == 0))
-    {
-      if (legal_number (string+9, &sig) && sig >= 0 && sig <= SIGRTMAX - SIGRTMIN)
-	return (SIGRTMIN + sig);
-      else
-	return NO_SIG;
-    }
-  else if (STREQN (string, "RTMIN+", 6) || ((flags & DSIG_NOCASE) && strncasecmp (string, "RTMIN+", 6) == 0))
-    {
-      if (legal_number (string+6, &sig) && sig >= 0 && sig <= SIGRTMAX - SIGRTMIN)
-	return (SIGRTMIN + sig);
-      else
-	return NO_SIG;
-    }
-#endif /* SIGRTMIN && SIGRTMAX */
-
-  /* A leading `SIG' may be omitted. */
-  for (sig = 0; sig < BASH_NSIG; sig++)
-    {
-      name = signal_names[sig];
-      if (name == 0 || name[0] == '\0')
-	continue;
-
-      /* Check name without the SIG prefix first case sensitively or
-	 insensitively depending on whether flags includes DSIG_NOCASE */
-      if (STREQN (name, "SIG", 3))
-	{
-	  name += 3;
-
-	  if ((flags & DSIG_NOCASE) && strcasecmp (string, name) == 0)
-	    return ((int)sig);
-	  else if ((flags & DSIG_NOCASE) == 0 && strcmp (string, name) == 0)
-	    return ((int)sig);
-	  /* If we can't use the `SIG' prefix to match, punt on this
-	     name now. */
-	  else if ((flags & DSIG_SIGPREFIX) == 0)
-	    continue;
-	}
-
-      /* Check name with SIG prefix case sensitively or insensitively
-	 depending on whether flags includes DSIG_NOCASE */
-      name = signal_names[sig];
-      if ((flags & DSIG_NOCASE) && strcasecmp (string, name) == 0)
-	return ((int)sig);
-      else if ((flags & DSIG_NOCASE) == 0 && strcmp (string, name) == 0)
-	return ((int)sig);
-    }
-
-  return (NO_SIG);
-}
-
-/* Non-zero when we catch a trapped signal. */
-static int catch_flag;
-
-void
-run_pending_traps ()
-{
-  register int sig;
-  int x;
-  volatile int old_exit_value, old_running;
-  WORD_LIST *save_subst_varlist;
-  HASH_TABLE *save_tempenv;
-  sh_parser_state_t pstate;
-  volatile int save_return_catch_flag, function_code;
-  procenv_t save_return_catch;
-#if defined (ARRAY_VARS)
-  ARRAY *ps;
-#endif
-
-  if (catch_flag == 0)		/* simple optimization */
-    return;
-
-  if (running_trap > 0)
-    {
-      internal_debug ("run_pending_traps: recursive invocation while running trap for signal %d", running_trap-1);
-#if defined (SIGWINCH)
-      if (running_trap == SIGWINCH+1 && pending_traps[SIGWINCH])
-	return;			/* no recursive SIGWINCH trap invocations */
-#endif
-      /* could check for running the trap handler for the same signal here
-	 (running_trap == sig+1) */
-      if (evalnest_max > 0 && evalnest > evalnest_max)
-	{
-	  internal_error (_("trap handler: maximum trap handler level exceeded (%d)"), evalnest_max);
-	  evalnest = 0;
-	  jump_to_top_level (DISCARD);
-	}
-    }
-
-  catch_flag = trapped_signal_received = 0;
-
-  /* Preserve $? when running trap. */
-  trap_saved_exit_value = old_exit_value = last_command_exit_value;
-#if defined (ARRAY_VARS)
-  ps = save_pipestatus_array ();
-#endif
-  old_running = running_trap;
-
-  for (sig = 1; sig < NSIG; sig++)
-    {
-      /* XXX this could be made into a counter by using
-	 while (pending_traps[sig]--) instead of the if statement. */
-      if (pending_traps[sig])
-	{
-	  /* XXX - set last_command_exit_value = trap_saved_exit_value here? */
-	  running_trap = sig + 1;
-
-	  if (sig == SIGINT)
-	    {
-	      pending_traps[sig] = 0;	/* XXX */
-	      /* We don't modify evalnest here, since run_interrupt_trap() calls
-		 _run_trap_internal, which does. */
-	      run_interrupt_trap (0);
-	      CLRINTERRUPT;	/* interrupts don't stack */
-	    }
-#if defined (JOB_CONTROL) && defined (SIGCHLD)
-	  else if (sig == SIGCHLD &&
-		   trap_list[SIGCHLD] != (char *)IMPOSSIBLE_TRAP_HANDLER &&
-		   (sigmodes[SIGCHLD] & SIG_INPROGRESS) == 0)
-	    {
-	      sigmodes[SIGCHLD] |= SIG_INPROGRESS;
-	      /* We modify evalnest here even though run_sigchld_trap can run
-		 the trap action more than once */
-	      evalnest++;
-	      x = pending_traps[sig];
-	      pending_traps[sig] = 0;
-	      run_sigchld_trap (x);	/* use as counter */
-	      running_trap = 0;
-	      evalnest--;
-	      sigmodes[SIGCHLD] &= ~SIG_INPROGRESS;
-	      /* continue here rather than reset pending_traps[SIGCHLD] below in
-		 case there are recursive calls to run_pending_traps and children
-		 have been reaped while run_sigchld_trap was running. */
-	      continue;
-	    }
-	  else if (sig == SIGCHLD &&
-		   trap_list[SIGCHLD] == (char *)IMPOSSIBLE_TRAP_HANDLER &&
-		   (sigmodes[SIGCHLD] & SIG_INPROGRESS) != 0)
-	    {
-	      /* This can happen when run_pending_traps is called while
-		 running a SIGCHLD trap handler. */
-	      running_trap = 0;
-	      /* want to leave pending_traps[SIGCHLD] alone here */
-	      continue;					/* XXX */
-	    }
-	  else if (sig == SIGCHLD && (sigmodes[SIGCHLD] & SIG_INPROGRESS))
-	    {
-	      /* whoops -- print warning? */
-	      running_trap = 0;		/* XXX */
-	      /* want to leave pending_traps[SIGCHLD] alone here */
-	      continue;
-	    }
-#endif
-	  else if (trap_list[sig] == (char *)DEFAULT_SIG ||
-		   trap_list[sig] == (char *)IGNORE_SIG ||
-		   trap_list[sig] == (char *)IMPOSSIBLE_TRAP_HANDLER)
-	    {
-	      /* This is possible due to a race condition.  Say a bash
-		 process has SIGTERM trapped.  A subshell is spawned
-		 using { list; } & and the parent does something and kills
-		 the subshell with SIGTERM.  It's possible for the subshell
-		 to set pending_traps[SIGTERM] to 1 before the code in
-		 execute_cmd.c eventually calls restore_original_signals
-		 to reset the SIGTERM signal handler in the subshell.  The
-		 next time run_pending_traps is called, pending_traps[SIGTERM]
-		 will be 1, but the trap handler in trap_list[SIGTERM] will
-		 be invalid (probably DEFAULT_SIG, but it could be IGNORE_SIG).
-		 Unless we catch this, the subshell will dump core when
-		 trap_list[SIGTERM] == DEFAULT_SIG, because DEFAULT_SIG is
-		 usually 0x0. */
-	      internal_warning (_("run_pending_traps: bad value in trap_list[%d]: %p"),
-				sig, trap_list[sig]);
-	      if (trap_list[sig] == (char *)DEFAULT_SIG)
-		{
-		  internal_warning (_("run_pending_traps: signal handler is SIG_DFL, resending %d (%s) to myself"), sig, signal_name (sig));
-		  kill (getpid (), sig);
-		}
-	    }
-	  else
-	    {
-	      save_parser_state (&pstate);
-	      save_subst_varlist = subst_assign_varlist;
-	      subst_assign_varlist = 0;
-	      save_tempenv = temporary_env;
-	      temporary_env = 0;	/* traps should not run with temporary env */
-
-#if defined (JOB_CONTROL)
-	      save_pipeline (1);	/* XXX only provides one save level */
-#endif
-	      /* XXX - set pending_traps[sig] = 0 here? */
-	      pending_traps[sig] = 0;
-	      evalnest++;
-
-	      function_code = 0;
-	      save_return_catch_flag = return_catch_flag;
-	      if (return_catch_flag)
-		{
-		  COPY_PROCENV (return_catch, save_return_catch);
-		  function_code = setjmp_nosigs (return_catch);
-		}
-
-	      if (function_code == 0)
-		x = parse_and_execute (savestring (trap_list[sig]), "trap", SEVAL_NONINT|SEVAL_NOHIST|SEVAL_RESETLINE);
-	      else
-		{
-		  parse_and_execute_cleanup (sig + 1);	/* XXX - could use -1 */
-		  x = return_catch_value;
-		}
-
-	      evalnest--;
-#if defined (JOB_CONTROL)
-	      restore_pipeline (1);
-#endif
-
-	      subst_assign_varlist = save_subst_varlist;
-	      restore_parser_state (&pstate);
-	      temporary_env = save_tempenv;
-
-	      if (save_return_catch_flag)
-		{
-		  return_catch_flag = save_return_catch_flag;
-		  return_catch_value = x;
-		  COPY_PROCENV (save_return_catch, return_catch);
-		  if (function_code)
-		    {
-		      running_trap = old_running;		/* XXX */
-		      /* caller will set last_command_exit_value */
-		      sh_longjmp (return_catch, 1);
-		    }
-		}
-	    }
-
-	  pending_traps[sig] = 0;	/* XXX - move before evalstring? */
-	  running_trap = old_running;
-	}
-    }
-
-#if defined (ARRAY_VARS)
-  restore_pipestatus_array (ps);
-#endif
-  last_command_exit_value = old_exit_value;
-}
-
-/* Set the private state variables noting that we received a signal SIG
-   for which we have a trap set. */
-void
-set_trap_state (sig)
-     int sig;
-{
-  catch_flag = 1;
-  pending_traps[sig]++;
-  trapped_signal_received = sig;
-}
-    
-sighandler
-trap_handler (sig)
-     int sig;
-{
-  int oerrno;
-
-  if ((sigmodes[sig] & SIG_TRAPPED) == 0)
-    {
-      internal_debug ("trap_handler: signal %d: signal not trapped", sig);
-      SIGRETURN (0);
-    }
-
-  /* This means we're in a subshell, but have not yet reset the handler for
-     trapped signals. We're not supposed to execute the trap in this situation;
-     we should restore the original signal and resend the signal to ourselves
-     to preserve the Posix "signal traps that are not being ignored shall be
-     set to the default action" semantics. */
-  if ((subshell_environment & SUBSHELL_IGNTRAP) && trap_list[sig] != (char *)IGNORE_SIG)
-    {
-      sigset_t mask;
-
-      /* Paranoia */
-      if (original_signals[sig] == IMPOSSIBLE_TRAP_HANDLER)
-	original_signals[sig] = SIG_DFL;
-
-      restore_signal (sig);
-
-      /* Make sure we let the signal we just caught through */
-      sigemptyset (&mask);
-      sigprocmask (SIG_SETMASK, (sigset_t *)NULL, &mask);
-      sigdelset (&mask, sig);
-      sigprocmask (SIG_SETMASK, &mask, (sigset_t *)NULL);
-
-      kill (getpid (), sig);
-
-      SIGRETURN (0);
-    }
-
-  if ((sig >= NSIG) ||
-      (trap_list[sig] == (char *)DEFAULT_SIG) ||
-      (trap_list[sig] == (char *)IGNORE_SIG))
-    programming_error (_("trap_handler: bad signal %d"), sig);
-  else
-    {
-      oerrno = errno;
-#if defined (MUST_REINSTALL_SIGHANDLERS)
-#  if defined (JOB_CONTROL) && defined (SIGCHLD)
-      if (sig != SIGCHLD)
-#  endif /* JOB_CONTROL && SIGCHLD */
-      set_signal_handler (sig, trap_handler);
-#endif /* MUST_REINSTALL_SIGHANDLERS */
-
-      set_trap_state (sig);
-
-      if (this_shell_builtin && (this_shell_builtin == wait_builtin))
-	{
-	  wait_signal_received = sig;
-	  if (waiting_for_child && wait_intr_flag)
-	    sh_longjmp (wait_intr_buf, 1);
-	}
-
-#if defined (READLINE)
-      /* Set the event hook so readline will call it after the signal handlers
-	 finish executing, so if this interrupted character input we can get
-	 quick response. */
-      if (RL_ISSTATE (RL_STATE_SIGHANDLER))
-        bashline_set_event_hook ();
-#endif
-
-      errno = oerrno;
-    }
-  
-  SIGRETURN (0);
-}
-
-int
-next_pending_trap (start)
-     int start;
-{
-  register int i;
-
-  for (i = start; i < NSIG; i++)
-    if (pending_traps[i])
-      return i;
-  return -1;
-}
-
-int
-first_pending_trap ()
-{
-  return (next_pending_trap (1));
-}
-
-/* Return > 0 if any of the "real" signals (not fake signals like EXIT) are
-   trapped. */
-int
-any_signals_trapped ()
-{
-  register int i;
-
-  for (i = 1; i < NSIG; i++)
-    if ((sigmodes[i] & SIG_TRAPPED) && (sigmodes[i] & SIG_IGNORED) == 0)
-      return i;
-  return -1;
-}
-
-void
-clear_pending_traps ()
-{
-  register int i;
-
-  for (i = 1; i < NSIG; i++)
-    pending_traps[i] = 0;
-}
-
-void
-check_signals ()
-{
-  /* Add any other shell timeouts here */
-  check_read_timeout ();	/* set by the read builtin */
-  QUIT;
-}
-
-/* Convenience functions the rest of the shell can use */
-void
-check_signals_and_traps ()
-{
-  check_signals ();
-
-  run_pending_traps ();
-}
-
-#if defined (JOB_CONTROL) && defined (SIGCHLD)
-
-#ifdef INCLUDE_UNUSED
-/* Make COMMAND_STRING be executed when SIGCHLD is caught. */
-void
-set_sigchld_trap (command_string)
-     char *command_string;
-{
-  set_signal (SIGCHLD, command_string);
-}
-#endif
-
-/* Make COMMAND_STRING be executed when SIGCHLD is caught iff SIGCHLD
-   is not already trapped.  IMPOSSIBLE_TRAP_HANDLER is used as a sentinel
-   to make sure that a SIGCHLD trap handler run via run_sigchld_trap can
-   reset the disposition to the default and not have the original signal
-   accidentally restored, undoing the user's command. */
-void
-maybe_set_sigchld_trap (command_string)
-     char *command_string;
-{
-  if ((sigmodes[SIGCHLD] & SIG_TRAPPED) == 0 && trap_list[SIGCHLD] == (char *)IMPOSSIBLE_TRAP_HANDLER)
-    set_signal (SIGCHLD, command_string);
-}
-
-/* Temporarily set the SIGCHLD trap string to IMPOSSIBLE_TRAP_HANDLER.  Used
-   as a sentinel in run_sigchld_trap and maybe_set_sigchld_trap to see whether
-   or not a SIGCHLD trap handler reset SIGCHLD disposition to the default. */
-void
-set_impossible_sigchld_trap ()
-{
-  restore_default_signal (SIGCHLD);
-  change_signal (SIGCHLD, (char *)IMPOSSIBLE_TRAP_HANDLER);
-  sigmodes[SIGCHLD] &= ~SIG_TRAPPED;	/* maybe_set_sigchld_trap checks this */
-}
-
-/* Act as if we received SIGCHLD NCHILD times and increment
-   pending_traps[SIGCHLD] by that amount.  This allows us to still run the
-   SIGCHLD trap once for each exited child. */
-void
-queue_sigchld_trap (nchild)
-     int nchild;
-{
-  if (nchild > 0)
-    {
-      catch_flag = 1;
-      pending_traps[SIGCHLD] += nchild;
-      trapped_signal_received = SIGCHLD;
-    }
-}
-#endif /* JOB_CONTROL && SIGCHLD */
-
-/* Set a trap for SIG only if SIG is not already trapped. */
-static inline void
-trap_if_untrapped (sig, command)
-     int sig;
-     char *command;
-{
-  if ((sigmodes[sig] & SIG_TRAPPED) == 0)
-    set_signal (sig, command);
-}
-
-void
-set_debug_trap (command)
-     char *command;
-{
-  set_signal (DEBUG_TRAP, command);
-}
-
-/* Separate function to call when functions and sourced files want to restore
-   the original version of the DEBUG trap before returning.  Unless the -T
-   option is set, source and shell function execution save the old debug trap
-   and unset the trap.  If the function or sourced file changes the DEBUG trap,
-   SIG_TRAPPED will be set and we don't bother restoring the original trap string.
-   This is used by both functions and the source builtin. */
-void
-maybe_set_debug_trap (command)
-     char *command;
-{
-  trap_if_untrapped (DEBUG_TRAP, command);
-}
-
-void
-set_error_trap (command)
-     char *command;
-{
-  set_signal (ERROR_TRAP, command);
-}
-
-void
-maybe_set_error_trap (command)
-     char *command;
-{
-  trap_if_untrapped (ERROR_TRAP, command);
-}
-
-void
-set_return_trap (command)
-     char *command;
-{
-  set_signal (RETURN_TRAP, command);
-}
-
-void
-maybe_set_return_trap (command)
-     char *command;
-{
-  trap_if_untrapped (RETURN_TRAP, command);
-}
-
-#ifdef INCLUDE_UNUSED
-void
-set_sigint_trap (command)
-     char *command;
-{
-  set_signal (SIGINT, command);
-}
-#endif
-
-/* Reset the SIGINT handler so that subshells that are doing `shellsy'
-   things, like waiting for command substitution or executing commands
-   in explicit subshells ( ( cmd ) ), can catch interrupts properly. */
-SigHandler *
-set_sigint_handler ()
-{
-  if (sigmodes[SIGINT] & SIG_HARD_IGNORE)
-    return ((SigHandler *)SIG_IGN);
-
-  else if (sigmodes[SIGINT] & SIG_IGNORED)
-    return ((SigHandler *)set_signal_handler (SIGINT, SIG_IGN)); /* XXX */
-
-  else if (sigmodes[SIGINT] & SIG_TRAPPED)
-    return ((SigHandler *)set_signal_handler (SIGINT, trap_handler));
-
-  /* The signal is not trapped, so set the handler to the shell's special
-     interrupt handler. */
-  else if (interactive)	/* XXX - was interactive_shell */
-    return (set_signal_handler (SIGINT, sigint_sighandler));
-  else
-    return (set_signal_handler (SIGINT, termsig_sighandler));
-}
-
-/* Return the correct handler for signal SIG according to the values in
-   sigmodes[SIG]. */
-SigHandler *
-trap_to_sighandler (sig)
-     int sig;
-{
-  if (sigmodes[sig] & (SIG_IGNORED|SIG_HARD_IGNORE))
-    return (SIG_IGN);
-  else if (sigmodes[sig] & SIG_TRAPPED)
-    return (trap_handler);
-  else
-    return (SIG_DFL);
-}
-
-/* Set SIG to call STRING as a command. */
-void
-set_signal (sig, string)
-     int sig;
-     char *string;
-{
-  sigset_t set, oset;
-
-  if (SPECIAL_TRAP (sig))
-    {
-      change_signal (sig, savestring (string));
-      if (sig == EXIT_TRAP && interactive == 0)
-	initialize_terminating_signals ();
-      return;
-    }
-
-  /* A signal ignored on entry to the shell cannot be trapped or reset, but
-     no error is reported when attempting to do so.  -- Posix.2 */
-  if (sigmodes[sig] & SIG_HARD_IGNORE)
-    return;
-
-  /* Make sure we have original_signals[sig] if the signal has not yet
-     been trapped. */
-  if ((sigmodes[sig] & SIG_TRAPPED) == 0)
-    {
-      /* If we aren't sure of the original value, check it. */
-      if (original_signals[sig] == IMPOSSIBLE_TRAP_HANDLER)
-        GETORIGSIG (sig);
-      if (original_signals[sig] == SIG_IGN)
-	return;
-    }
-
-  /* Only change the system signal handler if SIG_NO_TRAP is not set.
-     The trap command string is changed in either case.  The shell signal
-     handlers for SIGINT and SIGCHLD run the user specified traps in an
-     environment in which it is safe to do so. */
-  if ((sigmodes[sig] & SIG_NO_TRAP) == 0)
-    {
-      BLOCK_SIGNAL (sig, set, oset);
-      change_signal (sig, savestring (string));
-      set_signal_handler (sig, trap_handler);
-      UNBLOCK_SIGNAL (oset);
-    }
-  else
-    change_signal (sig, savestring (string));
-}
-
-static void
-free_trap_command (sig)
-     int sig;
-{
-  if ((sigmodes[sig] & SIG_TRAPPED) && trap_list[sig] &&
-      (trap_list[sig] != (char *)IGNORE_SIG) &&
-      (trap_list[sig] != (char *)DEFAULT_SIG) &&
-      (trap_list[sig] != (char *)IMPOSSIBLE_TRAP_HANDLER))
-    free (trap_list[sig]);
-}
-
-/* If SIG has a string assigned to it, get rid of it.  Then give it
-   VALUE. */
-static void
-change_signal (sig, value)
-     int sig;
-     char *value;
-{
-  if ((sigmodes[sig] & SIG_INPROGRESS) == 0)
-    free_trap_command (sig);
-  trap_list[sig] = value;
-
-  sigmodes[sig] |= SIG_TRAPPED;
-  if (value == (char *)IGNORE_SIG)
-    sigmodes[sig] |= SIG_IGNORED;
-  else
-    sigmodes[sig] &= ~SIG_IGNORED;
-  if (sigmodes[sig] & SIG_INPROGRESS)
-    sigmodes[sig] |= SIG_CHANGED;
-}
-
-void
-get_original_signal (sig)
-     int sig;
-{
-  /* If we aren't sure the of the original value, then get it. */
-  if (sig > 0 && sig < NSIG && original_signals[sig] == (SigHandler *)IMPOSSIBLE_TRAP_HANDLER)
-    GETORIGSIG (sig);
-}
-
-void
-get_all_original_signals ()
-{
-  register int i;
-
-  for (i = 1; i < NSIG; i++)
-    GET_ORIGINAL_SIGNAL (i);
-}
-
-void
-set_original_signal (sig, handler)
-     int sig;
-     SigHandler *handler;
-{
-  if (sig > 0 && sig < NSIG && original_signals[sig] == (SigHandler *)IMPOSSIBLE_TRAP_HANDLER)
-    SETORIGSIG (sig, handler);
-}
-
-/* Restore the default action for SIG; i.e., the action the shell
-   would have taken before you used the trap command.  This is called
-   from trap_builtin (), which takes care to restore the handlers for
-   the signals the shell treats specially. */
-void
-restore_default_signal (sig)
-     int sig;
-{
-  if (SPECIAL_TRAP (sig))
-    {
-      if ((sig != DEBUG_TRAP && sig != ERROR_TRAP && sig != RETURN_TRAP) ||
-	  (sigmodes[sig] & SIG_INPROGRESS) == 0)
-	free_trap_command (sig);
-      trap_list[sig] = (char *)NULL;
-      sigmodes[sig] &= ~SIG_TRAPPED;
-      if (sigmodes[sig] & SIG_INPROGRESS)
-	sigmodes[sig] |= SIG_CHANGED;
-      return;
-    }
-
-  GET_ORIGINAL_SIGNAL (sig);
-
-  /* A signal ignored on entry to the shell cannot be trapped or reset, but
-     no error is reported when attempting to do so.  Thanks Posix.2. */
-  if (sigmodes[sig] & SIG_HARD_IGNORE)
-    return;
-
-  /* If we aren't trapping this signal, don't bother doing anything else. */
-  /* We special-case SIGCHLD and IMPOSSIBLE_TRAP_HANDLER (see above) as a
-     sentinel to determine whether or not disposition is reset to the default
-     while the trap handler is executing. */
-  if (((sigmodes[sig] & SIG_TRAPPED) == 0) &&
-      (sig != SIGCHLD || (sigmodes[sig] & SIG_INPROGRESS) == 0 || trap_list[sig] != (char *)IMPOSSIBLE_TRAP_HANDLER))
-    return;
-
-  /* Only change the signal handler for SIG if it allows it. */
-  if ((sigmodes[sig] & SIG_NO_TRAP) == 0)
-    set_signal_handler (sig, original_signals[sig]);
-
-  /* Change the trap command in either case. */
-  change_signal (sig, (char *)DEFAULT_SIG);
-
-  /* Mark the signal as no longer trapped. */
-  sigmodes[sig] &= ~SIG_TRAPPED;
-}
-
-/* Make this signal be ignored. */
-void
-ignore_signal (sig)
-     int sig;
-{
-  if (SPECIAL_TRAP (sig) && ((sigmodes[sig] & SIG_IGNORED) == 0))
-    {
-      change_signal (sig, (char *)IGNORE_SIG);
-      return;
-    }
-
-  GET_ORIGINAL_SIGNAL (sig);
-
-  /* A signal ignored on entry to the shell cannot be trapped or reset.
-     No error is reported when the user attempts to do so. */
-  if (sigmodes[sig] & SIG_HARD_IGNORE)
-    return;
-
-  /* If already trapped and ignored, no change necessary. */
-  if (sigmodes[sig] & SIG_IGNORED)
-    return;
-
-  /* Only change the signal handler for SIG if it allows it. */
-  if ((sigmodes[sig] & SIG_NO_TRAP) == 0)
-    set_signal_handler (sig, SIG_IGN);
-
-  /* Change the trap command in either case. */
-  change_signal (sig, (char *)IGNORE_SIG);
-}
-
-/* Handle the calling of "trap 0".  The only sticky situation is when
-   the command to be executed includes an "exit".  This is why we have
-   to provide our own place for top_level to jump to. */
-int
-run_exit_trap ()
-{
-  char *trap_command;
-  int code, function_code, retval;
-#if defined (ARRAY_VARS)
-  ARRAY *ps;
-#endif
-
-  trap_saved_exit_value = last_command_exit_value;
-#if defined (ARRAY_VARS)
-  ps = save_pipestatus_array ();
-#endif
-  function_code = 0;
-
-  /* Run the trap only if signal 0 is trapped and not ignored, and we are not
-     currently running in the trap handler (call to exit in the list of
-     commands given to trap 0). */
-  if ((sigmodes[EXIT_TRAP] & SIG_TRAPPED) &&
-      (sigmodes[EXIT_TRAP] & (SIG_IGNORED|SIG_INPROGRESS)) == 0)
-    {
-      trap_command = savestring (trap_list[EXIT_TRAP]);
-      sigmodes[EXIT_TRAP] &= ~SIG_TRAPPED;
-      sigmodes[EXIT_TRAP] |= SIG_INPROGRESS;
-
-      retval = trap_saved_exit_value;
-      running_trap = 1;
-
-      code = setjmp_nosigs (top_level);
-
-      /* If we're in a function, make sure return longjmps come here, too. */
-      if (return_catch_flag)
-	function_code = setjmp_nosigs (return_catch);
-
-      if (code == 0 && function_code == 0)
-	{
-	  reset_parser ();
-	  parse_and_execute (trap_command, "exit trap", SEVAL_NONINT|SEVAL_NOHIST|SEVAL_RESETLINE);
-	}
-      else if (code == ERREXIT)
-	retval = last_command_exit_value;
-      else if (code == EXITPROG || code == EXITBLTIN)
-	retval = last_command_exit_value;
-      else if (function_code != 0)
-        retval = return_catch_value;
-      else
-	retval = trap_saved_exit_value;
-
-      running_trap = 0;
-#if defined (ARRAY_VARS)
-      array_dispose (ps);
-#endif
-
-      return retval;
-    }
-
-#if defined (ARRAY_VARS)
-  restore_pipestatus_array (ps);
-#endif
-  return (trap_saved_exit_value);
-}
-
-void
-run_trap_cleanup (sig)
-     int sig;
-{
-  /* XXX - should we clean up trap_list[sig] == IMPOSSIBLE_TRAP_HANDLER? */
-  sigmodes[sig] &= ~(SIG_INPROGRESS|SIG_CHANGED);
-}
-
-#define RECURSIVE_SIG(s) (SPECIAL_TRAP(s) == 0)
-
-/* Run a trap command for SIG.  SIG is one of the signals the shell treats
-   specially.  Returns the exit status of the executed trap command list. */
-static int
-_run_trap_internal (sig, tag)
-     int sig;
-     char *tag;
-{
-  char *trap_command, *old_trap;
-  int trap_exit_value;
-  volatile int save_return_catch_flag, function_code;
-  int old_modes, old_running, old_int;
-  int flags;
-  procenv_t save_return_catch;
-  WORD_LIST *save_subst_varlist;
-  HASH_TABLE *save_tempenv;
-  sh_parser_state_t pstate;
-#if defined (ARRAY_VARS)
-  ARRAY *ps;
-#endif
-
-  old_modes = old_running = -1;
-
-  trap_exit_value = function_code = 0;
-  trap_saved_exit_value = last_command_exit_value;
-  /* Run the trap only if SIG is trapped and not ignored, and we are not
-     currently executing in the trap handler. */
-  if ((sigmodes[sig] & SIG_TRAPPED) && ((sigmodes[sig] & SIG_IGNORED) == 0) &&
-      (trap_list[sig] != (char *)IMPOSSIBLE_TRAP_HANDLER) &&
-#if 1
-      /* Uncomment this to allow some special signals to recursively execute
-	 trap handlers. */
-      (RECURSIVE_SIG (sig) || (sigmodes[sig] & SIG_INPROGRESS) == 0))
-#else
-      ((sigmodes[sig] & SIG_INPROGRESS) == 0))
-#endif
-    {
-      old_trap = trap_list[sig];
-      old_modes = sigmodes[sig];
-      old_running = running_trap;
-
-      sigmodes[sig] |= SIG_INPROGRESS;
-      sigmodes[sig] &= ~SIG_CHANGED;		/* just to be sure */
-      trap_command =  savestring (old_trap);
-
-      running_trap = sig + 1;
-
-      old_int = interrupt_state;	/* temporarily suppress pending interrupts */
-      CLRINTERRUPT;
-
-#if defined (ARRAY_VARS)
-      ps = save_pipestatus_array ();
-#endif
-
-      save_parser_state (&pstate);
-      save_subst_varlist = subst_assign_varlist;
-      subst_assign_varlist = 0;
-      save_tempenv = temporary_env;
-      temporary_env = 0;	/* traps should not run with temporary env */
-
-#if defined (JOB_CONTROL)
-      if (sig != DEBUG_TRAP)	/* run_debug_trap does this */
-	save_pipeline (1);	/* XXX only provides one save level */
-#endif
-
-      /* If we're in a function, make sure return longjmps come here, too. */
-      save_return_catch_flag = return_catch_flag;
-      if (return_catch_flag)
-	{
-	  COPY_PROCENV (return_catch, save_return_catch);
-	  function_code = setjmp_nosigs (return_catch);
-	}
-
-      flags = SEVAL_NONINT|SEVAL_NOHIST;
-      if (sig != DEBUG_TRAP && sig != RETURN_TRAP && sig != ERROR_TRAP)
-	flags |= SEVAL_RESETLINE;
-      evalnest++;
-      if (function_code == 0)
-        {
-	  parse_and_execute (trap_command, tag, flags);
-	  trap_exit_value = last_command_exit_value;
-        }
-      else
-        trap_exit_value = return_catch_value;
-      evalnest--;
-
-#if defined (JOB_CONTROL)
-      if (sig != DEBUG_TRAP)	/* run_debug_trap does this */
-	restore_pipeline (1);
-#endif
-
-      subst_assign_varlist = save_subst_varlist;
-      restore_parser_state (&pstate);
-
-#if defined (ARRAY_VARS)
-      restore_pipestatus_array (ps);
-#endif
-
-      temporary_env = save_tempenv;
-
-      if ((old_modes & SIG_INPROGRESS) == 0)
-	sigmodes[sig] &= ~SIG_INPROGRESS;
-
-      running_trap = old_running;
-      interrupt_state = old_int;
-
-      if (sigmodes[sig] & SIG_CHANGED)
-	{
-#if 0
-	  /* Special traps like EXIT, DEBUG, RETURN are handled explicitly in
-	     the places where they can be changed using unwind-protects.  For
-	     example, look at execute_cmd.c:execute_function(). */
-	  if (SPECIAL_TRAP (sig) == 0)
-#endif
-	    free (old_trap);
-	  sigmodes[sig] &= ~SIG_CHANGED;
-
-	  CHECK_TERMSIG;	/* some pathological conditions lead here */
-	}
-
-      if (save_return_catch_flag)
-	{
-	  return_catch_flag = save_return_catch_flag;
-	  return_catch_value = trap_exit_value;
-	  COPY_PROCENV (save_return_catch, return_catch);
-	  if (function_code)
-	    {
-#if 0
-	      from_return_trap = sig == RETURN_TRAP;
-#endif
-	      sh_longjmp (return_catch, 1);
-	    }
-	}
-    }
-
-  return trap_exit_value;
-}
-
-int
-run_debug_trap ()
-{
-  int trap_exit_value, old_verbose;
-  pid_t save_pgrp;
-#if defined (PGRP_PIPE)
-  int save_pipe[2];
-#endif
-
-  /* XXX - question:  should the DEBUG trap inherit the RETURN trap? */
-  trap_exit_value = 0;
-  if ((sigmodes[DEBUG_TRAP] & SIG_TRAPPED) && ((sigmodes[DEBUG_TRAP] & SIG_IGNORED) == 0) && ((sigmodes[DEBUG_TRAP] & SIG_INPROGRESS) == 0))
-    {
-#if defined (JOB_CONTROL)
-      save_pgrp = pipeline_pgrp;
-      pipeline_pgrp = 0;
-      save_pipeline (1);
-#  if defined (PGRP_PIPE)
-      save_pgrp_pipe (save_pipe, 1);
-#  endif
-      stop_making_children ();
-#endif
-
-      old_verbose = echo_input_at_read;
-      echo_input_at_read = suppress_debug_trap_verbose ? 0 : echo_input_at_read;
-
-      trap_exit_value = _run_trap_internal (DEBUG_TRAP, "debug trap");
-
-      echo_input_at_read = old_verbose;
-
-#if defined (JOB_CONTROL)
-      pipeline_pgrp = save_pgrp;
-      restore_pipeline (1);
-#  if defined (PGRP_PIPE)
-      close_pgrp_pipe ();
-      restore_pgrp_pipe (save_pipe);
-#  endif
-      if (pipeline_pgrp > 0 && ((subshell_environment & (SUBSHELL_ASYNC|SUBSHELL_PIPE)) == 0))
-	give_terminal_to (pipeline_pgrp, 1);
-
-      notify_and_cleanup ();
-#endif
-      
-#if defined (DEBUGGER)
-      /* If we're in the debugger and the DEBUG trap returns 2 while we're in
-	 a function or sourced script, we force a `return'. */
-      if (debugging_mode && trap_exit_value == 2 && return_catch_flag)
-	{
-	  return_catch_value = trap_exit_value;
-	  sh_longjmp (return_catch, 1);
-	}
-#endif
-    }
-  return trap_exit_value;
-}
-
-void
-run_error_trap ()
-{
-  if ((sigmodes[ERROR_TRAP] & SIG_TRAPPED) && ((sigmodes[ERROR_TRAP] & SIG_IGNORED) == 0) && (sigmodes[ERROR_TRAP] & SIG_INPROGRESS) == 0)
-    _run_trap_internal (ERROR_TRAP, "error trap");
-}
-
-void
-run_return_trap ()
-{
-  int old_exit_value;
-
-#if 0
-  if ((sigmodes[DEBUG_TRAP] & SIG_TRAPPED) && (sigmodes[DEBUG_TRAP] & SIG_INPROGRESS))
-    return;
-#endif
-
-  if ((sigmodes[RETURN_TRAP] & SIG_TRAPPED) && ((sigmodes[RETURN_TRAP] & SIG_IGNORED) == 0) && (sigmodes[RETURN_TRAP] & SIG_INPROGRESS) == 0)
-    {
-      old_exit_value = last_command_exit_value;
-      _run_trap_internal (RETURN_TRAP, "return trap");
-      last_command_exit_value = old_exit_value;
-    }
-}
-
-/* Run a trap set on SIGINT.  This is called from throw_to_top_level (), and
-   declared here to localize the trap functions. */
-void
-run_interrupt_trap (will_throw)
-     int will_throw;	/* from throw_to_top_level? */
-{
-  if (will_throw && running_trap > 0)
-    run_trap_cleanup (running_trap - 1);
-  pending_traps[SIGINT] = 0;	/* run_pending_traps does this */
-  catch_flag = 0;
-  _run_trap_internal (SIGINT, "interrupt trap");
-}
-
-/* Free all the allocated strings in the list of traps and reset the trap
-   values to the default.  Intended to be called from subshells that want
-   to complete work done by reset_signal_handlers upon execution of a
-   subsequent `trap' command that changes a signal's disposition.  We need
-   to make sure that we duplicate the behavior of
-   reset_or_restore_signal_handlers and not change the disposition of signals
-   that are set to be ignored. */
-void
-free_trap_strings ()
-{
-  register int i;
-
-  for (i = 0; i < NSIG; i++)
-    {
-      if (trap_list[i] != (char *)IGNORE_SIG)
-	free_trap_string (i);
-    }
-  for (i = NSIG; i < BASH_NSIG; i++)
-    {
-      /* Don't free the trap string if the subshell inherited the trap */
-      if ((sigmodes[i] & SIG_TRAPPED) == 0)
-	{
-	  free_trap_string (i);
-	  trap_list[i] = (char *)NULL;
-	}
-    }
-}
-
-/* Free a trap command string associated with SIG without changing signal
-   disposition.  Intended to be called from free_trap_strings()  */
-static void
-free_trap_string (sig)
-     int sig;
-{
-  change_signal (sig, (char *)DEFAULT_SIG);
-  sigmodes[sig] &= ~SIG_TRAPPED;		/* XXX - SIG_INPROGRESS? */
-}
-
-/* Reset the handler for SIG to the original value but leave the trap string
-   in place. */
-static void
-reset_signal (sig)
-     int sig;
-{
-  set_signal_handler (sig, original_signals[sig]);
-  sigmodes[sig] &= ~SIG_TRAPPED;		/* XXX - SIG_INPROGRESS? */
-}
-
-/* Set the handler signal SIG to the original and free any trap
-   command associated with it. */
-static void
-restore_signal (sig)
-     int sig;
-{
-  set_signal_handler (sig, original_signals[sig]);
-  change_signal (sig, (char *)DEFAULT_SIG);
-  sigmodes[sig] &= ~SIG_TRAPPED;
-}
-
-static void
-reset_or_restore_signal_handlers (reset)
-     sh_resetsig_func_t *reset;
-{
-  register int i;
-
-  /* Take care of the exit trap first */
-  if (sigmodes[EXIT_TRAP] & SIG_TRAPPED)
-    {
-      sigmodes[EXIT_TRAP] &= ~SIG_TRAPPED;	/* XXX - SIG_INPROGRESS? */
-      if (reset != reset_signal)
-	{
-	  free_trap_command (EXIT_TRAP);
-	  trap_list[EXIT_TRAP] = (char *)NULL;
-	}
-    }
-
-  for (i = 1; i < NSIG; i++)
-    {
-      if (sigmodes[i] & SIG_TRAPPED)
-	{
-	  if (trap_list[i] == (char *)IGNORE_SIG)
-	    set_signal_handler (i, SIG_IGN);
-	  else
-	    (*reset) (i);
-	}
-      else if (sigmodes[i] & SIG_SPECIAL)
-	(*reset) (i);
-      pending_traps[i] = 0;	/* XXX */
-    }
-
-  /* Command substitution and other child processes don't inherit the
-     debug, error, or return traps.  If we're in the debugger, and the
-     `functrace' or `errtrace' options have been set, then let command
-     substitutions inherit them.  Let command substitution inherit the
-     RETURN trap if we're in the debugger and tracing functions. */
-  if (function_trace_mode == 0)
-    {
-      sigmodes[DEBUG_TRAP] &= ~SIG_TRAPPED;
-      sigmodes[RETURN_TRAP] &= ~SIG_TRAPPED;
-    }
-  if (error_trace_mode == 0)
-    sigmodes[ERROR_TRAP] &= ~SIG_TRAPPED;
-}
-
-/* Reset trapped signals to their original values, but don't free the
-   trap strings.  Called by the command substitution code and other places
-   that create a "subshell environment". */
-void
-reset_signal_handlers ()
-{
-  reset_or_restore_signal_handlers (reset_signal);
-}
-
-/* Reset all trapped signals to their original values.  Signals set to be
-   ignored with trap '' SIGNAL should be ignored, so we make sure that they
-   are.  Called by child processes after they are forked. */
-void
-restore_original_signals ()
-{
-  reset_or_restore_signal_handlers (restore_signal);
-}
-
-/* Change the flags associated with signal SIG without changing the trap
-   string. The string is TRAP_LIST[SIG] if we need it. */
-static void
-reinit_trap (sig)
-     int sig;
-{
-  sigmodes[sig] |= SIG_TRAPPED;
-  if (trap_list[sig] == (char *)IGNORE_SIG)
-    sigmodes[sig] |= SIG_IGNORED;
-  else
-    sigmodes[sig] &= ~SIG_IGNORED;
-  if (sigmodes[sig] & SIG_INPROGRESS)
-    sigmodes[sig] |= SIG_CHANGED;
-}
-
-/* Undo the effects of reset_signal_handlers(), which unsets the traps but
-   leaves the trap strings in place. This understands how reset_signal_handlers
-   works. */
-void
-restore_traps ()
-{
-  char *trapstr;
-  int i;
-
-  /* Take care of the exit trap first. If TRAP_LIST[0] is non-null, the trap
-     has been set. */
-  trapstr = trap_list[EXIT_TRAP];
-  if (trapstr)
-    reinit_trap (EXIT_TRAP);
-
-  /* Then DEBUG, RETURN, and ERROR. TRAP_LIST[N] == 0 if these signals are
-     not trapped. This knows what reset_signal_handlers does for these traps */
-  trapstr = trap_list[DEBUG_TRAP];
-  if (trapstr && function_trace_mode == 0)
-    reinit_trap (DEBUG_TRAP);
-  trapstr = trap_list[RETURN_TRAP];
-  if (trapstr && function_trace_mode == 0)
-    reinit_trap (RETURN_TRAP);
-  trapstr = trap_list[ERROR_TRAP];
-  if (trapstr && error_trace_mode == 0)
-    reinit_trap (ERROR_TRAP);
-
-  /* And finally all the `real' signals. reset_signal_handlers just changes the
-     signal handler for these signals, leaving the trap value in place. We
-     intuit what to do based on that value. We assume that signals marked as
-     SIG_SPECIAL are reinitialized by initialize_signals (), so we don't
-     change the signal handler unless the signal is supposed to be ignored. */
-  for (i = 1; i < NSIG; i++)
-    {
-      trapstr = trap_list[i];
-      if (sigmodes[i] & SIG_SPECIAL)
-	{
-	  if (trapstr && trapstr != (char *)DEFAULT_SIG)
-	    reinit_trap (i);
-	  if (trapstr == (char *)IGNORE_SIG && (sigmodes[i] & SIG_NO_TRAP) == 0)
-	    set_signal_handler (i, SIG_IGN);
-	}
-      else if (trapstr == (char *)IGNORE_SIG)
-	{
-	  reinit_trap (i);
-	  if ((sigmodes[i] & SIG_NO_TRAP) == 0)
-	    set_signal_handler (i, SIG_IGN);
-	}
-      else if (trapstr != (char *)DEFAULT_SIG)
-        /* set_signal duplicates the string argument before freeing it. */
-	set_signal (i, trapstr);
-
-      pending_traps[i] = 0;	/* XXX */
-    }
-}
-
-/* If a trap handler exists for signal SIG, then call it; otherwise just
-   return failure.  Returns 1 if it called the trap handler. */
-int
-maybe_call_trap_handler (sig)
-     int sig;
-{
-  /* Call the trap handler for SIG if the signal is trapped and not ignored. */
-  if ((sigmodes[sig] & SIG_TRAPPED) && ((sigmodes[sig] & SIG_IGNORED) == 0))
-    {
-      switch (sig)
-	{
-	case SIGINT:
-	  run_interrupt_trap (0);
-	  break;
-	case EXIT_TRAP:
-	  run_exit_trap ();
-	  break;
-	case DEBUG_TRAP:
-	  run_debug_trap ();
-	  break;
-	case ERROR_TRAP:
-	  run_error_trap ();
-	  break;
-	default:
-	  trap_handler (sig);
-	  break;
-	}
-      return (1);
-    }
-  else
-    return (0);
-}
-
-int
-signal_is_trapped (sig)
-     int sig;
-{
-  return (sigmodes[sig] & SIG_TRAPPED);
-}
-
-int
-signal_is_pending (sig)
-     int sig;
-{
-  return (pending_traps[sig]);
-}
-
-int
-signal_is_special (sig)
-     int sig;
-{
-  return (sigmodes[sig] & SIG_SPECIAL);
-}
-
-int
-signal_is_ignored (sig)
-     int sig;
-{
-  return (sigmodes[sig] & SIG_IGNORED);
-}
-
-int
-signal_is_hard_ignored (sig)
-     int sig;
-{
-  return (sigmodes[sig] & SIG_HARD_IGNORE);
-}
-
-void
-set_signal_hard_ignored (sig)
-     int sig;
-{
-  sigmodes[sig] |= SIG_HARD_IGNORE;
-  original_signals[sig] = SIG_IGN;
-}
-
-void
-set_signal_ignored (sig)
-     int sig;
-{
-  original_signals[sig] = SIG_IGN;
-}
-
-int
-signal_in_progress (sig)
-     int sig;
-{
-  return (sigmodes[sig] & SIG_INPROGRESS);
-}
-
-#if 0 /* unused */
-int
-block_trapped_signals (maskp, omaskp)
-     sigset_t *maskp;
-     sigset_t *omaskp;
-{
-  int i;
-
-  sigemptyset (maskp);
-  for (i = 1; i < NSIG; i++)
-    if (sigmodes[i] & SIG_TRAPPED)
-      sigaddset (maskp, i);
-  return (sigprocmask (SIG_BLOCK, maskp, omaskp));
-}
-
-int
-unblock_trapped_signals (maskp)
-     sigset_t *maskp;
-{
-  return (sigprocmask (SIG_SETMASK, maskp, 0));
-}
-#endif
diff --git a/third_party/bash/trap.h b/third_party/bash/trap.h
deleted file mode 100644
index 89402a1bc..000000000
--- a/third_party/bash/trap.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/* trap.h -- data structures used in the trap mechanism. */
-
-/* Copyright (C) 1993-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_TRAP_H_)
-#define _TRAP_H_
-
-#include "stdc.h"
-
-#if !defined (SIG_DFL)
-#include "bashtypes.h"
-#include <signal.h>
-#endif /* SIG_DFL */
-
-#if !defined (NSIG)
-#define NSIG 64
-#endif /* !NSIG */
-
-#define NO_SIG -1
-#define DEFAULT_SIG	SIG_DFL
-#define IGNORE_SIG	SIG_IGN
-
-/* Special shell trap names. */
-#define DEBUG_TRAP	NSIG
-#define ERROR_TRAP	NSIG+1
-#define RETURN_TRAP	NSIG+2
-#define EXIT_TRAP 	0
-
-/* system signals plus special bash traps */
-#define BASH_NSIG	NSIG+3
-
-/* Flags values for decode_signal() */
-#define DSIG_SIGPREFIX	0x01		/* don't allow `SIG' PREFIX */
-#define DSIG_NOCASE	0x02		/* case-insensitive comparison */
-
-/* A value which can never be the target of a trap handler. */
-#define IMPOSSIBLE_TRAP_HANDLER (SigHandler *)initialize_traps
-
-#define signal_object_p(x,f) (decode_signal (x,f) != NO_SIG)
-
-#define TRAP_STRING(s) \
-  (signal_is_trapped (s) && signal_is_ignored (s) == 0) ? trap_list[s] \
-							: (char *)NULL
-
-extern char *trap_list[];
-
-extern int trapped_signal_received;
-extern int wait_signal_received;
-extern int running_trap;
-extern int trap_saved_exit_value;
-extern int suppress_debug_trap_verbose;
-
-/* Externally-visible functions declared in trap.c. */
-extern void initialize_traps PARAMS((void));
-
-extern void run_pending_traps PARAMS((void));
-
-extern void queue_sigchld_trap PARAMS((int));
-extern void maybe_set_sigchld_trap PARAMS((char *));
-extern void set_impossible_sigchld_trap PARAMS((void));
-extern void set_sigchld_trap PARAMS((char *));
-
-extern void set_debug_trap PARAMS((char *));
-extern void set_error_trap PARAMS((char *));
-extern void set_return_trap PARAMS((char *));
-
-extern void maybe_set_debug_trap PARAMS((char *));
-extern void maybe_set_error_trap PARAMS((char *));
-extern void maybe_set_return_trap PARAMS((char *));
-
-extern void set_sigint_trap PARAMS((char *));
-extern void set_signal PARAMS((int, char *));
-
-extern void restore_default_signal PARAMS((int));
-extern void ignore_signal PARAMS((int));
-extern int run_exit_trap PARAMS((void));
-extern void run_trap_cleanup PARAMS((int));
-extern int run_debug_trap PARAMS((void));
-extern void run_error_trap PARAMS((void));
-extern void run_return_trap PARAMS((void));
-
-extern void free_trap_strings PARAMS((void));
-extern void reset_signal_handlers PARAMS((void));
-extern void restore_original_signals PARAMS((void));
-extern void restore_traps PARAMS((void));
-
-extern void get_original_signal PARAMS((int));
-extern void get_all_original_signals PARAMS((void));
-
-extern char *signal_name PARAMS((int));
-
-extern int decode_signal PARAMS((char *, int));
-extern void run_interrupt_trap PARAMS((int));
-extern int maybe_call_trap_handler PARAMS((int));
-extern int signal_is_special PARAMS((int));
-extern int signal_is_trapped PARAMS((int));
-extern int signal_is_pending PARAMS((int));
-extern int signal_is_ignored PARAMS((int));
-extern int signal_is_hard_ignored PARAMS((int));
-extern void set_signal_hard_ignored PARAMS((int));
-extern void set_signal_ignored PARAMS((int));
-extern int signal_in_progress PARAMS((int));
-
-extern void set_trap_state PARAMS((int));
-
-extern int next_pending_trap PARAMS((int));
-extern int first_pending_trap PARAMS((void));
-extern void clear_pending_traps PARAMS((void));
-extern int any_signals_trapped PARAMS((void));
-extern void check_signals PARAMS((void));
-extern void check_signals_and_traps PARAMS((void));
-
-#endif /* _TRAP_H_ */
diff --git a/third_party/bash/typemax.h b/third_party/bash/typemax.h
deleted file mode 100644
index e3b98f472..000000000
--- a/third_party/bash/typemax.h
+++ /dev/null
@@ -1,141 +0,0 @@
-/* typemax.h -- encapsulate max values for long, long long, etc. */
-
-/* Copyright (C) 2001-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/*
- * NOTE:  This should be included after config.h, limits.h, stdint.h, and
- *	  inttypes.h
- */
-
-#ifndef _SH_TYPEMAX_H
-#define _SH_TYPEMAX_H
-
-#ifndef CHAR_BIT
-#  define CHAR_BIT 8
-#endif
-
-/* Nonzero if the integer type T is signed.  */
-#ifndef TYPE_SIGNED
-#  define TYPE_SIGNED(t)	(! ((t) 0 < (t) -1))
-#endif
-
-#ifndef TYPE_SIGNED_MAGNITUDE
-#  define TYPE_SIGNED_MAGNITUDE(t) ((t) ~ (t) 0 < (t) -1)
-#endif
-
-#ifndef TYPE_WIDTH
-#  define TYPE_WIDTH(t) (sizeof (t) * CHAR_BIT)
-#endif
-
-#ifndef TYPE_MINIMUM
-#  define TYPE_MINIMUM(t) ((t) ~ TYPE_MAXIMUM (t))
-#endif
-
-#ifndef TYPE_MAXIMUM
-#  define TYPE_MAXIMUM(t)  \
-  ((t) (! TYPE_SIGNED (t) \
-        ? (t) -1 \
-        : ((((t) 1 << (TYPE_WIDTH (t) - 2)) - 1) * 2 + 1)))
-#endif
-
-#ifdef HAVE_LONG_LONG_INT
-#  ifndef LLONG_MAX
-#    define LLONG_MAX   TYPE_MAXIMUM(long long int)
-#    define LLONG_MIN	TYPE_MINIMUM(long long int)
-#  endif
-#  ifndef ULLONG_MAX
-#    define ULLONG_MAX  TYPE_MAXIMUM(unsigned long long int)
-#  endif
-#endif
-
-#ifndef ULONG_MAX
-#  define ULONG_MAX	((unsigned long) ~(unsigned long) 0)
-#endif
-
-#ifndef LONG_MAX
-#  define LONG_MAX	((long int) (ULONG_MAX >> 1))
-#  define LONG_MIN	((long int) (-LONG_MAX - 1L))
-#endif
-
-#ifndef INT_MAX		/* ouch */
-#  define INT_MAX	TYPE_MAXIMUM(int)
-#  define INT_MIN	TYPE_MINIMUM(int)
-#  define UINT_MAX	((unsigned int) ~(unsigned int)0)
-#endif
-
-#ifndef SHRT_MAX
-#  define SHRT_MAX	TYPE_MAXIMUM(short)
-#  define SHRT_MIN	TYPE_MINIMUM(short)
-#  define USHRT_MAX	((unsigned short) ~(unsigned short)0)
-#endif
-
-#ifndef UCHAR_MAX
-#  define UCHAR_MAX	255
-#endif
-
-/* workaround for gcc bug in versions < 2.7 */
-#if defined (HAVE_LONG_LONG_INT) && __GNUC__ == 2 && __GNUC_MINOR__ < 7
-static const unsigned long long int maxquad = ULLONG_MAX;
-#  undef ULLONG_MAX
-#  define ULLONG_MAX maxquad
-#endif
-
-#if !defined (INTMAX_MAX) || !defined (INTMAX_MIN)
-
-#if SIZEOF_INTMAX_T == SIZEOF_LONG_LONG
-#  define INTMAX_MAX	LLONG_MAX
-#  define INTMAX_MIN	LLONG_MIN
-#elif SIZEOF_INTMAX_T == SIZEOF_LONG
-#  define INTMAX_MAX	LONG_MAX
-#  define INTMAX_MIN	LONG_MIN
-#else
-#  define INTMAX_MAX	INT_MAX
-#  define INTMAX_MIN	INT_MIN
-#endif
-
-#endif
-
-#ifndef SSIZE_MAX
-#  define SSIZE_MAX	INT_MAX
-#endif
-
-#ifndef SIZE_MAX
-#  define SIZE_MAX	((size_t) ~(size_t)0)
-#endif
-
-#ifndef sh_imaxabs
-#  define sh_imaxabs(x)	(((x) >= 0) ? (x) : -(x))
-#endif
-
-/* Handle signed arithmetic overflow and underflow.  Have to do it this way
-   to avoid compilers optimizing out simpler overflow checks. */
-
-/* Make sure that a+b does not exceed MAXV or is smaller than MINV (if b < 0).
-   Assumes that b > 0 if a > 0 and b < 0 if a < 0 */
-#define ADDOVERFLOW(a,b,minv,maxv) \
-	((((a) > 0) && ((b) > ((maxv) - (a)))) || \
-	 (((a) < 0) && ((b) < ((minv) - (a)))))
-
-/* Make sure that a-b is not smaller than MINV or exceeds MAXV (if b < 0).
-   Assumes that b > 0 if a > 0 and b < 0 if a < 0 */
-#define SUBOVERFLOW(a,b,minv,maxv) \
-	((((b) > 0) && ((a) < ((minv) + (b)))) || \
-	 (((b) < 0) && ((a) > ((maxv) + (b)))))
-
-#endif /* _SH_TYPEMAX_H */
diff --git a/third_party/bash/uconvert.c b/third_party/bash/uconvert.c
deleted file mode 100644
index 457552eb4..000000000
--- a/third_party/bash/uconvert.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/* uconvert - convert string representations of decimal numbers into whole
-	      number/fractional value pairs. */
-
-/* Copyright (C) 2008,2009,2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#include "posixtime.h"
-
-#if defined (HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "chartypes.h"
-
-#include "shell.h"
-#include "builtins.h"
-
-#define DECIMAL	'.'		/* XXX - should use locale */
-
-#define RETURN(x) \
-do { \
-  if (ip) *ip = ipart * mult; \
-  if (up) *up = upart; \
-  if (ep) *ep = p; \
-  return (x); \
-} while (0)
-
-/*
- * An incredibly simplistic floating point converter.
- */
-static int multiplier[7] = { 1, 100000, 10000, 1000, 100, 10, 1 };
-
-/* Take a decimal number int-part[.[micro-part]] and convert it to the whole
-   and fractional portions.  The fractional portion is returned in
-   millionths (micro); callers are responsible for multiplying appropriately.
-   EP, if non-null, gets the address of the character where conversion stops.
-   Return 1 if value converted; 0 if invalid integer for either whole or
-   fractional parts. */
-int
-uconvert(s, ip, up, ep)
-     char *s;
-     long *ip, *up;
-     char **ep;
-{
-  int n, mult;
-  long ipart, upart;
-  char *p;
-
-  ipart = upart = 0;
-  mult = 1;
-
-  if (s && (*s == '-' || *s == '+'))
-    {
-      mult = (*s == '-') ? -1 : 1;
-      p = s + 1;
-    }
-  else
-    p = s;
-
-  for ( ; p && *p; p++)
-    {
-      if (*p == DECIMAL)		/* decimal point */
-	break;
-      if (DIGIT(*p) == 0)
-	RETURN(0);
-      ipart = (ipart * 10) + (*p - '0');
-    }
-
-  if (p == 0 || *p == 0)	/* callers ensure p can never be 0; this is to shut up clang */
-    RETURN(1);
-
-  if (*p == DECIMAL)
-    p++;
-
-  /* Look for up to six digits past a decimal point. */
-  for (n = 0; n < 6 && p[n]; n++)
-    {
-      if (DIGIT(p[n]) == 0)
-	{
-	  if (ep)
-	    {
-	      upart *= multiplier[n];
-	      p += n;		/* To set EP */
-	    }
-	  RETURN(0);
-	}
-      upart = (upart * 10) + (p[n] - '0');
-    }
-
-  /* Now convert to millionths */
-  upart *= multiplier[n];
-
-  if (n == 6 && p[6] >= '5' && p[6] <= '9')
-    upart++;			/* round up 1 */
-
-  if (ep)
-    {
-      p += n;
-      while (DIGIT(*p))
-	p++;
-    }
-
-  RETURN(1);
-}
diff --git a/third_party/bash/ufuncs.c b/third_party/bash/ufuncs.c
deleted file mode 100644
index 4dc4853b1..000000000
--- a/third_party/bash/ufuncs.c
+++ /dev/null
@@ -1,140 +0,0 @@
-/* ufuncs - sleep and alarm functions that understand fractional values */
-
-/* Copyright (C) 2008,2009-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-
-#include "posixtime.h"
-
-#if defined (HAVE_UNISTD_H)
-#include <unistd.h>
-#endif
-
-#include <errno.h>
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-#if defined (HAVE_SELECT)
-#  include "posixselect.h"
-#  include "quit.h"
-#  include "trap.h"
-#  include "stat-time.h"
-#endif
-
-/* A version of `alarm' using setitimer if it's available. */
-
-#if defined (HAVE_SETITIMER)
-unsigned int
-falarm(secs, usecs)
-     unsigned int secs, usecs;
-{
-  struct itimerval it, oit;
-
-  it.it_interval.tv_sec = 0;
-  it.it_interval.tv_usec = 0;
-
-  it.it_value.tv_sec = secs;
-  it.it_value.tv_usec = usecs;
-
-  if (setitimer(ITIMER_REAL, &it, &oit) < 0)
-    return (-1);		/* XXX will be converted to unsigned */
-
-  /* Backwards compatibility with alarm(3) */
-  if (oit.it_value.tv_usec)
-    oit.it_value.tv_sec++;
-  return (oit.it_value.tv_sec);
-}
-#else
-int
-falarm (secs, usecs)
-     unsigned int secs, usecs;
-{
-  if (secs == 0 && usecs == 0)
-    return (alarm (0));
-
-  if (secs == 0 || usecs >= 500000)
-    {
-      secs++;
-      usecs = 0;
-    }
-  return (alarm (secs));
-}
-#endif /* !HAVE_SETITIMER */
-
-/* A version of sleep using fractional seconds and select.  I'd like to use
-   `usleep', but it's already taken */
-
-#if defined (HAVE_TIMEVAL) && (defined (HAVE_SELECT) || defined (HAVE_PSELECT))
-int
-fsleep(sec, usec)
-     unsigned int sec, usec;
-{
-  int e, r;
-  sigset_t blocked_sigs, prevmask;
-#if defined (HAVE_PSELECT)
-  struct timespec ts;
-#else
-  struct timeval tv;
-#endif
-
-  sigemptyset (&blocked_sigs);
-#  if defined (SIGCHLD)
-  sigaddset (&blocked_sigs, SIGCHLD);
-#  endif
-
-#if defined (HAVE_PSELECT)
-  ts.tv_sec = sec;
-  ts.tv_nsec = usec * 1000;
-#else
-  sigemptyset (&prevmask);
-  tv.tv_sec = sec;
-  tv.tv_usec = usec;
-#endif /* !HAVE_PSELECT */
-
-  do
-    {
-#if defined (HAVE_PSELECT)
-      r = pselect(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &ts, &blocked_sigs);
-#else
-      sigprocmask (SIG_SETMASK, &blocked_sigs, &prevmask);
-      r = select(0, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv);
-      sigprocmask (SIG_SETMASK, &prevmask, NULL);
-#endif
-      e = errno;
-      if (r < 0 && errno == EINTR)
-	return -1;		/* caller will handle */
-      errno = e;
-    }
-  while (r < 0 && errno == EINTR);
-
-  return r;
-}
-#else /* !HAVE_TIMEVAL || !HAVE_SELECT */
-int
-fsleep(sec, usec)
-     long sec, usec;
-{
-  if (usec >= 500000)	/* round */
-   sec++;
-  return (sleep(sec));
-}
-#endif /* !HAVE_TIMEVAL || !HAVE_SELECT */
diff --git a/third_party/bash/unicode.c b/third_party/bash/unicode.c
deleted file mode 100644
index a79ec4aab..000000000
--- a/third_party/bash/unicode.c
+++ /dev/null
@@ -1,339 +0,0 @@
-/* unicode.c - functions to convert unicode characters */
-
-/* Copyright (C) 2010-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#if defined (HANDLE_MULTIBYTE)
-
-#include "stdc.h"
-#include <wchar.h>
-#include "bashansi.h"
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#include <stdio.h>
-#include <limits.h>
-
-#if HAVE_ICONV
-#  include <iconv.h>
-#endif
-
-#include "xmalloc.h"
-
-#ifndef USHORT_MAX
-#  ifdef USHRT_MAX
-#    define USHORT_MAX USHRT_MAX
-#  else
-#    define USHORT_MAX ((unsigned short) ~(unsigned short)0)
-#  endif
-#endif
-
-#if !defined (STREQ)
-#  define STREQ(a, b) ((a)[0] == (b)[0] && strcmp ((a), (b)) == 0)
-#endif /* !STREQ */
-
-#if defined (HAVE_LOCALE_CHARSET)
-extern const char *locale_charset PARAMS((void));
-#else
-extern char *get_locale_var PARAMS((char *));
-#endif
-
-extern int locale_utf8locale;
-
-static int u32init = 0;
-static int utf8locale = 0;
-#if defined (HAVE_ICONV)
-static iconv_t localconv;
-#endif
-
-#ifndef HAVE_LOCALE_CHARSET
-static char charsetbuf[40];
-
-static char *
-stub_charset ()
-{
-  char *locale, *s, *t;
-
-  locale = get_locale_var ("LC_CTYPE");
-  if (locale == 0 || *locale == 0)
-    {
-      strcpy (charsetbuf, "ASCII");
-      return charsetbuf;
-    }
-  s = strrchr (locale, '.');
-  if (s)
-    {
-      strncpy (charsetbuf, s+1, sizeof (charsetbuf) - 1);
-      charsetbuf[sizeof (charsetbuf) - 1] = '\0';
-      t = strchr (charsetbuf, '@');
-      if (t)
-	*t = 0;
-      return charsetbuf;
-    }
-  strncpy (charsetbuf, locale, sizeof (charsetbuf) - 1);
-  charsetbuf[sizeof (charsetbuf) - 1] = '\0';
-  return charsetbuf;
-}
-#endif
-
-void
-u32reset ()
-{
-#if defined (HAVE_ICONV)
-  if (u32init && localconv != (iconv_t)-1)
-    {
-      iconv_close (localconv);
-      localconv = (iconv_t)-1;
-    }
-#endif
-  u32init = 0;
-  utf8locale = 0;
-}
-
-/* u32toascii ? */
-int
-u32tochar (x, s)
-     unsigned long x;
-     char *s;
-{
-  int l;
-
-  l = (x <= UCHAR_MAX) ? 1 : ((x <= USHORT_MAX) ? 2 : 4);
-
-  if (x <= UCHAR_MAX)
-    s[0] = x & 0xFF;
-  else if (x <= USHORT_MAX)	/* assume unsigned short = 16 bits */
-    {
-      s[0] = (x >> 8) & 0xFF;
-      s[1] = x & 0xFF;
-    }
-  else
-    {
-      s[0] = (x >> 24) & 0xFF;
-      s[1] = (x >> 16) & 0xFF;
-      s[2] = (x >> 8) & 0xFF;
-      s[3] = x & 0xFF;
-    }
-  s[l] = '\0';
-  return l;  
-}
-
-int
-u32tocesc (wc, s)
-     u_bits32_t wc;
-     char *s;
-{
-  int l;
-
-  if (wc < 0x10000)
-    l = sprintf (s, "\\u%04X", wc);
-  else
-    l = sprintf (s, "\\U%08X", wc);
-  return l;
-}
-
-/* Convert unsigned 32-bit int to utf-8 character string */
-int
-u32toutf8 (wc, s)
-     u_bits32_t wc;
-     char *s;
-{
-  int l;
-
-  if (wc < 0x0080)
-    {
-      s[0] = (char)wc;
-      l = 1;
-    }
-  else if (wc < 0x0800)
-    {
-      s[0] = (wc >> 6) | 0xc0;
-      s[1] = (wc & 0x3f) | 0x80;
-      l = 2;
-    }
-  else if (wc < 0x10000)
-    {
-      /* Technically, we could return 0 here if 0xd800 <= wc <= 0x0dfff */
-      s[0] = (wc >> 12) | 0xe0;
-      s[1] = ((wc >> 6) & 0x3f) | 0x80;
-      s[2] = (wc & 0x3f) | 0x80;
-      l = 3;
-    }
-  else if (wc < 0x200000)
-    {
-      s[0] = (wc >> 18) | 0xf0;
-      s[1] = ((wc >> 12) & 0x3f) | 0x80;
-      s[2] = ((wc >>  6) & 0x3f) | 0x80;
-      s[3] = (wc & 0x3f) | 0x80;
-      l = 4;
-    }
-  /* Strictly speaking, UTF-8 doesn't have characters longer than 4 bytes */
-  else if (wc < 0x04000000)
-    {
-      s[0] = (wc >> 24) | 0xf8;
-      s[1] = ((wc >> 18) & 0x3f) | 0x80;
-      s[2] = ((wc >> 12) & 0x3f) | 0x80;
-      s[3] = ((wc >>  6) & 0x3f) | 0x80;
-      s[4] = (wc & 0x3f) | 0x80;
-      l = 5;
-    }
-  else if (wc < 0x080000000)
-    {
-      s[0] = (wc >> 30) | 0xfc;
-      s[1] = ((wc >> 24) & 0x3f) | 0x80;
-      s[2] = ((wc >> 18) & 0x3f) | 0x80;
-      s[3] = ((wc >> 12) & 0x3f) | 0x80;
-      s[4] = ((wc >>  6) & 0x3f) | 0x80;
-      s[5] = (wc & 0x3f) | 0x80;
-      l = 6;
-    }
-  else
-    l = 0;
-
-  s[l] = '\0';
-  return l;
-}
-
-/* Convert a 32-bit unsigned int (unicode) to a UTF-16 string.  Rarely used,
-   only if sizeof(wchar_t) == 2. */
-int
-u32toutf16 (c, s)
-     u_bits32_t c;
-     wchar_t *s;
-{
-  int l;
-
-  l = 0;
-  if (c < 0x0d800 || (c >= 0x0e000 && c <= 0x0ffff))
-    {
-      s[0] = (wchar_t) (c & 0xFFFF);
-      l = 1;
-    }
-  else if (c >= 0x10000 && c <= 0x010ffff)
-    {
-      c -= 0x010000;
-      s[0] = (wchar_t)((c >> 10) + 0xd800);
-      s[1] = (wchar_t)((c & 0x3ff) + 0xdc00);
-      l = 2;
-    }
-  s[l] = 0;
-  return l;
-}
-
-/* convert a single unicode-32 character into a multibyte string and put the
-   result in S, which must be large enough (at least max(10,MB_LEN_MAX) bytes) */
-int
-u32cconv (c, s)
-     unsigned long c;
-     char *s;
-{
-  wchar_t wc;
-  wchar_t ws[3];
-  int n;
-#if HAVE_ICONV
-  const char *charset;
-  char obuf[25], *optr;
-  size_t obytesleft;
-  const char *iptr;
-  size_t sn;
-#endif
-
-#if __STDC_ISO_10646__
-  wc = c;
-  if (sizeof (wchar_t) == 4 && c <= 0x7fffffff)
-    n = wctomb (s, wc);
-  else if (sizeof (wchar_t) == 2 && c <= 0x10ffff && u32toutf16 (c, ws))
-    n = wcstombs (s, ws, MB_LEN_MAX);
-  else
-    n = -1;
-  if (n != -1)
-    return n;
-#endif
-
-#if HAVE_ICONV
-  /* this is mostly from coreutils-8.5/lib/unicodeio.c */
-  if (u32init == 0)
-    {
-      utf8locale = locale_utf8locale;
-      localconv = (iconv_t)-1;
-      if (utf8locale == 0)
-	{
-#if HAVE_LOCALE_CHARSET
-	  charset = locale_charset ();
-#elif HAVE_NL_LANGINFO
-	  charset = nl_langinfo (CODESET);
-#else
-	  charset = stub_charset ();
-#endif
-	  localconv = iconv_open (charset, "UTF-8");
-	  if (localconv == (iconv_t)-1)
-	    /* We assume ASCII when presented with an unknown encoding. */
-	    localconv = iconv_open ("ASCII", "UTF-8");
-	}
-      u32init = 1;
-    }
-
-  /* NL_LANGINFO and locale_charset used when setting locale_utf8locale */
-  
-  /* If we have a UTF-8 locale, convert to UTF-8 and return converted value. */
-  n = u32toutf8 (c, s);
-  if (utf8locale)
-    return n;
-
-  /* If the conversion is not supported, even the ASCII requested above, we
-     bail now.  Currently we return the UTF-8 conversion.  We could return
-     u32tocesc(). */
-  if (localconv == (iconv_t)-1)
-    return n;
-    
-  optr = obuf;
-  obytesleft = sizeof (obuf);
-  iptr = s;
-  sn = n;
-
-  iconv (localconv, NULL, NULL, NULL, NULL);
-
-  if (iconv (localconv, (ICONV_CONST char **)&iptr, &sn, &optr, &obytesleft) == (size_t)-1)
-    {
-      /* You get ISO C99 escape sequences if iconv fails */      
-      n = u32tocesc (c, s);
-      return n;
-    }
-
-  *optr = '\0';
-
-  /* number of chars to be copied is optr - obuf if we want to do bounds
-     checking */
-  strcpy (s, obuf);
-  return (optr - obuf);
-#endif	/* HAVE_ICONV */
-
-  if (locale_utf8locale)
-    n = u32toutf8 (c, s);
-  else
-    n = u32tocesc (c, s);	/* fallback is ISO C99 escape sequences */
-  return n;
-}
-#else
-void
-u32reset ()
-{
-}
-#endif /* HANDLE_MULTIBYTE */
diff --git a/third_party/bash/unionwait.h b/third_party/bash/unionwait.h
deleted file mode 100644
index b1b4dfaff..000000000
--- a/third_party/bash/unionwait.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/* unionwait.h -- definitions for using a `union wait' on systems without
-   one. */
-
-/* Copyright (C) 1996 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef _UNIONWAIT_H
-#define _UNIONWAIT_H
-
-#if !defined (WORDS_BIGENDIAN)
-union wait
-  {
-    int	w_status;		/* used in syscall */
-
-    /* Terminated process status. */
-    struct
-      {
-	unsigned short
-	  w_Termsig  : 7,	/* termination signal */
-	  w_Coredump : 1,	/* core dump indicator */
-	  w_Retcode  : 8,	/* exit code if w_termsig==0 */
-	  w_Fill1    : 16;	/* high 16 bits unused */
-      } w_T;
-
-    /* Stopped process status.  Returned
-       only for traced children unless requested
-       with the WUNTRACED option bit. */
-    struct
-      {
-	unsigned short
-	  w_Stopval : 8,	/* == W_STOPPED if stopped */
-	  w_Stopsig : 8,	/* actually zero on XENIX */
-	  w_Fill2   : 16;	/* high 16 bits unused */
-      } w_S;
-  };
-
-#else  /* WORDS_BIGENDIAN */
-
-/* This is for big-endian machines like the IBM RT, HP 9000, or Sun-3 */
-
-union wait
-  {
-    int	w_status;		/* used in syscall */
-
-    /* Terminated process status. */
-    struct
-      {
-	unsigned short w_Fill1    : 16;	/* high 16 bits unused */
-	unsigned       w_Retcode  : 8;	/* exit code if w_termsig==0 */
-	unsigned       w_Coredump : 1;	/* core dump indicator */
-	unsigned       w_Termsig  : 7;	/* termination signal */
-      } w_T;
-
-    /* Stopped process status.  Returned
-       only for traced children unless requested
-       with the WUNTRACED option bit. */
-    struct
-      {
-	unsigned short w_Fill2   : 16;	/* high 16 bits unused */
-	unsigned       w_Stopsig : 8;	/* signal that stopped us */
-	unsigned       w_Stopval : 8;	/* == W_STOPPED if stopped */
-      } w_S;
-  };
-
-#endif /* WORDS_BIGENDIAN */
-
-#define w_termsig  w_T.w_Termsig
-#define w_coredump w_T.w_Coredump
-#define w_retcode  w_T.w_Retcode
-#define w_stopval  w_S.w_Stopval
-#define w_stopsig  w_S.w_Stopsig
-
-#define WSTOPPED       0177
-#define WIFSTOPPED(x)  ((x).w_stopval == WSTOPPED)
-#define WIFEXITED(x)   ((x).w_stopval != WSTOPPED && (x).w_termsig == 0)
-#define WIFSIGNALED(x) ((x).w_stopval != WSTOPPED && (x).w_termsig != 0)
-
-#define WTERMSIG(x)    ((x).w_termsig)
-#define WSTOPSIG(x)    ((x).w_stopsig)
-#define WEXITSTATUS(x) ((x).w_retcode)
-#define WIFCORED(x)    ((x).w_coredump)
-
-#endif /* _UNIONWAIT_H */
diff --git a/third_party/bash/unwind_prot.c b/third_party/bash/unwind_prot.c
deleted file mode 100644
index ec82393d5..000000000
--- a/third_party/bash/unwind_prot.c
+++ /dev/null
@@ -1,383 +0,0 @@
-/* unwind_prot.c - a simple unwind-protect system for internal variables */
-
-/* I can't stand it anymore!  Please can't we just write the
-   whole Unix system in lisp or something? */
-
-/* Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* **************************************************************** */
-/*								    */
-/*		      Unwind Protection Scheme for Bash		    */
-/*								    */
-/* **************************************************************** */
-#include "config.h"
-
-#include "bashtypes.h"
-#include "bashansi.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#if defined (HAVE_STDDEF_H)
-#  include <stddef.h>
-#endif
-
-#ifndef offsetof
-#  define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
-#endif
-
-#include "command.h"
-#include "general.h"
-#include "unwind_prot.h"
-#include "sig.h"
-#include "quit.h"
-#include "bashintl.h"	/* for _() */
-#include "error.h"	/* for internal_warning */
-#include "ocache.h"
-
-/* Structure describing a saved variable and the value to restore it to.  */
-typedef struct {
-  char *variable;
-  int size;
-  char desired_setting[1]; /* actual size is `size' */
-} SAVED_VAR;
-
-/* If HEAD.CLEANUP is null, then ARG.V contains a tag to throw back to.
-   If HEAD.CLEANUP is restore_variable, then SV.V contains the saved
-   variable.  Otherwise, call HEAD.CLEANUP (ARG.V) to clean up.  */
-typedef union uwp {
-  struct uwp_head {
-    union uwp *next;
-    Function *cleanup;
-  } head;
-  struct {
-    struct uwp_head uwp_head;
-    char *v;
-  } arg;
-  struct {
-    struct uwp_head uwp_head;
-    SAVED_VAR v;
-  } sv;
-} UNWIND_ELT;
-
-static void without_interrupts PARAMS((VFunction *, char *, char *));
-static void unwind_frame_discard_internal PARAMS((char *, char *));
-static void unwind_frame_run_internal PARAMS((char *, char *));
-static void add_unwind_protect_internal PARAMS((Function *, char *));
-static void remove_unwind_protect_internal PARAMS((char *, char *));
-static void run_unwind_protects_internal PARAMS((char *, char *));
-static void clear_unwind_protects_internal PARAMS((char *, char *));
-static inline void restore_variable PARAMS((SAVED_VAR *));
-static void unwind_protect_mem_internal PARAMS((char *, char *));
-
-static UNWIND_ELT *unwind_protect_list = (UNWIND_ELT *)NULL;
-
-/* Allocating from a cache of unwind-protect elements */
-#define UWCACHESIZE	128
-
-sh_obj_cache_t uwcache = {0, 0, 0};
-
-#if 0
-#define uwpalloc(elt)	(elt) = (UNWIND_ELT *)xmalloc (sizeof (UNWIND_ELT))
-#define uwpfree(elt)	free(elt)
-#else
-#define uwpalloc(elt)	ocache_alloc (uwcache, UNWIND_ELT, elt)
-#define uwpfree(elt)	ocache_free (uwcache, UNWIND_ELT, elt)
-#endif
-
-void
-uwp_init ()
-{
-  ocache_create (uwcache, UNWIND_ELT, UWCACHESIZE);
-}
-
-/* Run a function without interrupts.  This relies on the fact that the
-   FUNCTION cannot call QUIT (). */
-static void
-without_interrupts (function, arg1, arg2)
-     VFunction *function;
-     char *arg1, *arg2;
-{
-  (*function)(arg1, arg2);
-}
-
-/* Start the beginning of a region. */
-void
-begin_unwind_frame (tag)
-     char *tag;
-{
-  add_unwind_protect ((Function *)NULL, tag);
-}
-
-/* Discard the unwind protects back to TAG. */
-void
-discard_unwind_frame (tag)
-     char *tag;
-{
-  if (unwind_protect_list)
-    without_interrupts (unwind_frame_discard_internal, tag, (char *)NULL);
-}
-
-/* Run the unwind protects back to TAG. */
-void
-run_unwind_frame (tag)
-     char *tag;
-{
-  if (unwind_protect_list)
-    without_interrupts (unwind_frame_run_internal, tag, (char *)NULL);
-}
-
-/* Add the function CLEANUP with ARG to the list of unwindable things. */
-void
-add_unwind_protect (cleanup, arg)
-     Function *cleanup;
-     char *arg;
-{
-  without_interrupts (add_unwind_protect_internal, (char *)cleanup, arg);
-}
-
-/* Remove the top unwind protect from the list. */
-void
-remove_unwind_protect ()
-{
-  if (unwind_protect_list)
-    without_interrupts
-      (remove_unwind_protect_internal, (char *)NULL, (char *)NULL);
-}
-
-/* Run the list of cleanup functions in unwind_protect_list. */
-void
-run_unwind_protects ()
-{
-  if (unwind_protect_list)
-    without_interrupts
-      (run_unwind_protects_internal, (char *)NULL, (char *)NULL);
-}
-
-/* Erase the unwind-protect list.  If flags is 1, free the elements. */
-void
-clear_unwind_protect_list (flags)
-     int flags;
-{
-  char *flag;
-
-  if (unwind_protect_list)
-    {
-      flag = flags ? "" : (char *)NULL;
-      without_interrupts
-        (clear_unwind_protects_internal, flag, (char *)NULL);
-    }
-}
-
-int
-have_unwind_protects ()
-{
-  return (unwind_protect_list != 0);
-}
-
-int
-unwind_protect_tag_on_stack (tag)
-     const char *tag;
-{
-  UNWIND_ELT *elt;
-
-  elt = unwind_protect_list;
-  while (elt)
-    {
-      if (elt->head.cleanup == 0 && STREQ (elt->arg.v, tag))
-	return 1;
-      elt = elt->head.next;
-    }
-  return 0;
-}
-
-/* **************************************************************** */
-/*								    */
-/*			The Actual Functions		 	    */
-/*								    */
-/* **************************************************************** */
-
-static void
-add_unwind_protect_internal (cleanup, arg)
-     Function *cleanup;
-     char *arg;
-{
-  UNWIND_ELT *elt;
-
-  uwpalloc (elt);
-  elt->head.next = unwind_protect_list;
-  elt->head.cleanup = cleanup;
-  elt->arg.v = arg;
-  unwind_protect_list = elt;
-}
-
-static void
-remove_unwind_protect_internal (ignore1, ignore2)
-     char *ignore1, *ignore2;
-{
-  UNWIND_ELT *elt;
-
-  elt = unwind_protect_list;
-  if (elt)
-    {
-      unwind_protect_list = unwind_protect_list->head.next;
-      uwpfree (elt);
-    }
-}
-
-static void
-run_unwind_protects_internal (ignore1, ignore2)
-     char *ignore1, *ignore2;
-{
-  unwind_frame_run_internal ((char *) NULL, (char *) NULL);
-}
-
-static void
-clear_unwind_protects_internal (flag, ignore)
-     char *flag, *ignore;
-{
-  if (flag)
-    {
-      while (unwind_protect_list)
-	remove_unwind_protect_internal ((char *)NULL, (char *)NULL);
-    }
-  unwind_protect_list = (UNWIND_ELT *)NULL;
-}
-
-static void
-unwind_frame_discard_internal (tag, ignore)
-     char *tag, *ignore;
-{
-  UNWIND_ELT *elt;
-  int found;
-
-  found = 0;
-  while (elt = unwind_protect_list)
-    {
-      unwind_protect_list = unwind_protect_list->head.next;
-      if (elt->head.cleanup == 0 && (STREQ (elt->arg.v, tag)))
-	{
-	  uwpfree (elt);
-	  found = 1;
-	  break;
-	}
-      else
-	uwpfree (elt);
-    }
-
-  if (found == 0)
-    internal_warning (_("unwind_frame_discard: %s: frame not found"), tag);
-}
-
-/* Restore the value of a variable, based on the contents of SV.
-   sv->desired_setting is a block of memory SIZE bytes long holding the
-   value itself.  This block of memory is copied back into the variable. */
-static inline void
-restore_variable (sv)
-     SAVED_VAR *sv;
-{
-  FASTCOPY (sv->desired_setting, sv->variable, sv->size);
-}
-
-static void
-unwind_frame_run_internal (tag, ignore)
-     char *tag, *ignore;
-{
-  UNWIND_ELT *elt;
-  int found;
-
-  found = 0;
-  while (elt = unwind_protect_list)
-    {
-      unwind_protect_list = elt->head.next;
-
-      /* If tag, then compare. */
-      if (elt->head.cleanup == 0)
-	{
-	  if (tag && STREQ (elt->arg.v, tag))
-	    {
-	      uwpfree (elt);
-	      found = 1;
-	      break;
-	    }
-	}
-      else
-	{
-	  if (elt->head.cleanup == (Function *) restore_variable)
-	    restore_variable (&elt->sv.v);
-	  else
-	    (*(elt->head.cleanup)) (elt->arg.v);
-	}
-
-      uwpfree (elt);
-    }
-  if (tag && found == 0)
-    internal_warning (_("unwind_frame_run: %s: frame not found"), tag);
-}
-
-static void
-unwind_protect_mem_internal (var, psize)
-     char *var;
-     char *psize;
-{
-  int size, allocated;
-  UNWIND_ELT *elt;
-
-  size = *(int *) psize;
-  allocated = size + offsetof (UNWIND_ELT, sv.v.desired_setting[0]);
-  if (allocated < sizeof (UNWIND_ELT))
-    allocated = sizeof (UNWIND_ELT);
-  elt = (UNWIND_ELT *)xmalloc (allocated);
-  elt->head.next = unwind_protect_list;
-  elt->head.cleanup = (Function *) restore_variable;
-  elt->sv.v.variable = var;
-  elt->sv.v.size = size;
-  FASTCOPY (var, elt->sv.v.desired_setting, size);
-  unwind_protect_list = elt;
-}
-
-/* Save the value of a variable so it will be restored when unwind-protects
-   are run.  VAR is a pointer to the variable.  SIZE is the size in
-   bytes of VAR.  */
-void
-unwind_protect_mem (var, size)
-     char *var;
-     int size;
-{
-  without_interrupts (unwind_protect_mem_internal, var, (char *) &size);
-}
-
-#if defined (DEBUG)
-#include <stdio.h>
-
-void
-print_unwind_protect_tags ()
-{
-  UNWIND_ELT *elt;
-
-  elt = unwind_protect_list;
-  while (elt)
-    {
-      if (elt->head.cleanup == 0)
-        fprintf(stderr, "tag: %s\n", elt->arg.v);
-      elt = elt->head.next;
-    }
-}
-#endif
diff --git a/third_party/bash/unwind_prot.h b/third_party/bash/unwind_prot.h
deleted file mode 100644
index 97b3af902..000000000
--- a/third_party/bash/unwind_prot.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/* unwind_prot.h - Macros and functions for hacking unwind protection. */
-
-/* Copyright (C) 1993-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_UNWIND_PROT_H)
-#define _UNWIND_PROT_H
-
-extern void uwp_init PARAMS((void));
-
-/* Run a function without interrupts. */
-extern void begin_unwind_frame PARAMS((char *));
-extern void discard_unwind_frame PARAMS((char *));
-extern void run_unwind_frame PARAMS((char *));
-extern void add_unwind_protect (); /* Not portable to arbitrary C99 hosts.  */
-extern void remove_unwind_protect PARAMS((void));
-extern void run_unwind_protects PARAMS((void));
-extern void clear_unwind_protect_list PARAMS((int));
-extern int have_unwind_protects PARAMS((void));
-extern int unwind_protect_tag_on_stack PARAMS((const char *));
-extern void uwp_init PARAMS((void));
-
-/* Define for people who like their code to look a certain way. */
-#define end_unwind_frame()
-
-/* How to protect a variable.  */
-#define unwind_protect_var(X) unwind_protect_mem ((char *)&(X), sizeof (X))
-extern void unwind_protect_mem PARAMS((char *, int));
-
-/* Backwards compatibility */
-#define unwind_protect_int	unwind_protect_var
-#define unwind_protect_short	unwind_protect_var
-#define unwind_protect_string	unwind_protect_var
-#define unwind_protect_pointer	unwind_protect_var
-#define unwind_protect_jmp_buf	unwind_protect_var
-
-#endif /* _UNWIND_PROT_H */
diff --git a/third_party/bash/utf8.c b/third_party/bash/utf8.c
deleted file mode 100644
index 88eaa4f42..000000000
--- a/third_party/bash/utf8.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/* utf8.c - UTF-8 character handling functions */
-
-/* Copyright (C) 2018 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#ifdef HAVE_STDLIB_H
-#  include <stdlib.h>
-#endif
-
-#include "bashansi.h"
-#include "shmbutil.h"
-
-extern int locale_mb_cur_max;
-extern int locale_utf8locale;
-
-#if defined (HANDLE_MULTIBYTE)
-
-char *
-utf8_mbschr (s, c)
-     const char *s;
-     int c;
-{
-  return strchr (s, c);		/* for now */
-}
-
-int
-utf8_mbscmp (s1, s2)
-     const char *s1, *s2;
-{
-  /* Use the fact that the UTF-8 encoding preserves lexicographic order.  */
-  return strcmp (s1, s2);
-}
-
-char *
-utf8_mbsmbchar (str)
-     const char *str;
-{
-  register char *s;
-
-  for (s = (char *)str; *s; s++)
-    if ((*s & 0xc0) == 0x80)
-      return s;
-  return (0);
-}
-
-int
-utf8_mbsnlen(src, srclen, maxlen)
-     const char *src;
-     size_t srclen;
-     int maxlen;
-{
-  register int sind, count;
-
-  for (sind = count = 0; src[sind] && sind <= maxlen; sind++)
-    {
-      if ((src[sind] & 0xc0) != 0x80)
-	count++;
-    }
-  return (count);
-}
-
-/* Adapted from GNU gnulib. Handles UTF-8 characters up to 4 bytes long */
-int
-utf8_mblen (s, n)
-     const char *s;
-     size_t n;
-{
-  unsigned char c, c1, c2, c3;
-
-  if (s == 0)
-    return (0);	/* no shift states */
-  if (n <= 0)
-    return (-1);
-
-  c = (unsigned char)*s;
-  if (c < 0x80)
-    return (c != 0);
-  if (c >= 0xc2)
-    {
-      c1 = (unsigned char)s[1];
-      if (c < 0xe0)
-	{
-	  if (n == 1)
-	    return -2;
-
-	  /*
-	   *				c	c1
-	   *
-	   *    U+0080..U+07FF       C2..DF   80..BF
-	   */
-
-	  if (n >= 2 && (c1 ^ 0x80) < 0x40)		/* 0x80..0xbf */
-	    return 2;
-	}
-      else if (c < 0xf0)
-	{
-	  if (n == 1)
-	    return -2;
-
-	  /*
-	   *				c	c1	c2
-	   *
-	   *    U+0800..U+0FFF       E0       A0..BF   80..BF
-	   *    U+1000..U+CFFF       E1..EC   80..BF   80..BF
-	   *    U+D000..U+D7FF       ED       80..9F   80..BF
-	   *    U+E000..U+FFFF       EE..EF   80..BF   80..BF
-	   */
-
-	  if ((c1 ^ 0x80) < 0x40
-		&& (c >= 0xe1 || c1 >= 0xa0)
-		&& (c != 0xed || c1 < 0xa0))
-	    {
-	      if (n == 2)
-		return -2;		/* incomplete */
-
-	      c2 = (unsigned char)s[2];
-	      if ((c2 ^ 0x80) < 0x40)
-		 return 3;
-	    }
-	}
-      else if (c <= 0xf4)
-	{
-	  if (n == 1)
-	    return -2;
-	 
-	  /*
-	   *				c	c1	c2	c3
-	   *
-	   *    U+10000..U+3FFFF     F0       90..BF   80..BF   80..BF
-	   *    U+40000..U+FFFFF     F1..F3   80..BF   80..BF   80..BF
-	   *    U+100000..U+10FFFF   F4       80..8F   80..BF   80..BF
-	   */
-	  if (((c1 ^ 0x80) < 0x40) 
-		&& (c >= 0xf1 || c1 >= 0x90)
-		&& (c < 0xf4 || (c == 0xf4 && c1 < 0x90)))
-	    {
-	      if (n == 2)
-		return -2;		/* incomplete */
-
-	      c2 = (unsigned char)s[2];
-	      if ((c2 ^ 0x80) < 0x40)
-		{
-		  if (n == 3)
-		    return -2;
-
-		  c3 = (unsigned char)s[3];
-	 	  if ((c3 ^ 0x80) < 0x40)
-	  	    return 4;
-		}
-	    }
-	}
-    }
-  /* invalid or incomplete multibyte character */
-  return -1;
-}
-
-/* We can optimize this if we know the locale is UTF-8, but needs to handle
-   malformed byte sequences. */
-size_t
-utf8_mbstrlen(s)
-     const char *s;
-{
-  size_t clen, nc;
-  int mb_cur_max;
-
-  nc = 0;
-  mb_cur_max = MB_CUR_MAX;
-  while (*s && (clen = (size_t)utf8_mblen(s, mb_cur_max)) != 0)
-    {
-      if (MB_INVALIDCH(clen))
-	clen = 1;	/* assume single byte */
-
-      s += clen;
-      nc++;
-    }
-  return nc;
-}
-
-#endif
diff --git a/third_party/bash/variables.c b/third_party/bash/variables.c
deleted file mode 100644
index 58abd5b86..000000000
--- a/third_party/bash/variables.c
+++ /dev/null
@@ -1,6590 +0,0 @@
-/* variables.c -- Functions for hacking shell variables. */
-
-/* Copyright (C) 1987-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "posixstat.h"
-#include "posixtime.h"
-
-#if defined (__QNX__)
-#  if defined (__QNXNTO__)
-#    include <sys/netmgr.h>
-#  else
-#    include <sys/vc.h>
-#  endif /* !__QNXNTO__ */
-#endif /* __QNX__ */
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <stdio.h>
-#include "chartypes.h"
-#if defined (HAVE_PWD_H)
-#  include <pwd.h>
-#endif
-#include "bashansi.h"
-#include "bashintl.h"
-#include "filecntl.h"
-
-#define NEED_XTRACE_SET_DECL
-
-#include "shell.h"
-#include "parser.h"
-#include "flags.h"
-#include "execute_cmd.h"
-#include "findcmd.h"
-#include "mailcheck.h"
-#include "input.h"
-#include "hashcmd.h"
-#include "pathexp.h"
-#include "alias.h"
-#include "jobs.h"
-
-#include "version.h"
-
-#include "getopt.h"
-#include "common.h"
-#include "builtext.h"
-
-#if defined (READLINE)
-#  include "bashline.h"
-#  include "third_party/readline/readline.h"
-#else
-#  include "tilde.h"
-#endif
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#  include "third_party/readline/history.h"
-#endif /* HISTORY */
-
-#if defined (PROGRAMMABLE_COMPLETION)
-#  include "pcomplete.h"
-#endif
-
-#define VARIABLES_HASH_BUCKETS	1024	/* must be power of two */
-#define FUNCTIONS_HASH_BUCKETS	512
-#define TEMPENV_HASH_BUCKETS	4	/* must be power of two */
-
-#define BASHFUNC_PREFIX		"BASH_FUNC_"
-#define BASHFUNC_PREFLEN	10	/* == strlen(BASHFUNC_PREFIX */
-#define BASHFUNC_SUFFIX		"%%"
-#define BASHFUNC_SUFFLEN	2	/* == strlen(BASHFUNC_SUFFIX) */
-
-#if ARRAY_EXPORT
-#define BASHARRAY_PREFIX	"BASH_ARRAY_"
-#define BASHARRAY_PREFLEN	11
-#define BASHARRAY_SUFFIX	"%%"
-#define BASHARRAY_SUFFLEN	2
-
-#define BASHASSOC_PREFIX	"BASH_ASSOC_"
-#define BASHASSOC_PREFLEN	11
-#define BASHASSOC_SUFFIX	"%%"	/* needs to be the same as BASHARRAY_SUFFIX */
-#define BASHASSOC_SUFFLEN	2
-#endif
-
-/* flags for find_variable_internal */
-
-#define FV_FORCETEMPENV		0x01
-#define FV_SKIPINVISIBLE	0x02
-#define FV_NODYNAMIC		0x04
-
-extern char **environ;
-
-/* Variables used here and defined in other files. */
-extern time_t shell_start_time;
-extern struct timeval shellstart;
-
-/* The list of shell variables that the user has created at the global
-   scope, or that came from the environment. */
-VAR_CONTEXT *global_variables = (VAR_CONTEXT *)NULL;
-
-/* The current list of shell variables, including function scopes */
-VAR_CONTEXT *shell_variables = (VAR_CONTEXT *)NULL;
-
-/* The list of shell functions that the user has created, or that came from
-   the environment. */
-HASH_TABLE *shell_functions = (HASH_TABLE *)NULL;
-
-HASH_TABLE *invalid_env = (HASH_TABLE *)NULL;
-
-#if defined (DEBUGGER)
-/* The table of shell function definitions that the user defined or that
-   came from the environment. */
-HASH_TABLE *shell_function_defs = (HASH_TABLE *)NULL;
-#endif
-
-/* The current variable context.  This is really a count of how deep into
-   executing functions we are. */
-int variable_context = 0;
-
-/* If non-zero, local variables inherit values and attributes from a variable
-   with the same name at a previous scope. */
-int localvar_inherit = 0;
-
-/* If non-zero, calling `unset' on local variables in previous scopes marks
-   them as invisible so lookups find them unset. This is the same behavior
-   as local variables in the current local scope. */
-int localvar_unset = 0;
-
-/* The set of shell assignments which are made only in the environment
-   for a single command. */
-HASH_TABLE *temporary_env = (HASH_TABLE *)NULL;
-
-/* Set to non-zero if an assignment error occurs while putting variables
-   into the temporary environment. */
-int tempenv_assign_error;
-
-/* Some funky variables which are known about specially.  Here is where
-   "$*", "$1", and all the cruft is kept. */
-char *dollar_vars[10];
-WORD_LIST *rest_of_args = (WORD_LIST *)NULL;
-int posparam_count = 0;
-
-/* The value of $$. */
-pid_t dollar_dollar_pid;
-
-/* Non-zero means that we have to remake EXPORT_ENV. */
-int array_needs_making = 1;
-
-/* The number of times BASH has been executed.  This is set
-   by initialize_variables (). */
-int shell_level = 0;
-
-/* An array which is passed to commands as their environment.  It is
-   manufactured from the union of the initial environment and the
-   shell variables that are marked for export. */
-char **export_env = (char **)NULL;
-static int export_env_index;
-static int export_env_size;
-
-#if defined (READLINE)
-static int winsize_assignment;		/* currently assigning to LINES or COLUMNS */
-#endif
-
-SHELL_VAR nameref_invalid_value;
-static SHELL_VAR nameref_maxloop_value;
-
-static HASH_TABLE *last_table_searched;	/* hash_lookup sets this */
-static VAR_CONTEXT *last_context_searched;
-
-/* Some forward declarations. */
-static void create_variable_tables PARAMS((void));
-
-static void set_machine_vars PARAMS((void));
-static void set_home_var PARAMS((void));
-static void set_shell_var PARAMS((void));
-static char *get_bash_name PARAMS((void));
-static void initialize_shell_level PARAMS((void));
-static void uidset PARAMS((void));
-#if defined (ARRAY_VARS)
-static void make_vers_array PARAMS((void));
-#endif
-
-static SHELL_VAR *null_assign PARAMS((SHELL_VAR *, char *, arrayind_t, char *));
-#if defined (ARRAY_VARS)
-static SHELL_VAR *null_array_assign PARAMS((SHELL_VAR *, char *, arrayind_t, char *));
-#endif
-static SHELL_VAR *get_self PARAMS((SHELL_VAR *));
-
-#if defined (ARRAY_VARS)
-static SHELL_VAR *init_dynamic_array_var PARAMS((char *, sh_var_value_func_t *, sh_var_assign_func_t *, int));
-static SHELL_VAR *init_dynamic_assoc_var PARAMS((char *, sh_var_value_func_t *, sh_var_assign_func_t *, int));
-#endif
-
-static inline SHELL_VAR *set_int_value (SHELL_VAR *, intmax_t, int);
-static inline SHELL_VAR *set_string_value (SHELL_VAR *, const char *, int);
-
-static SHELL_VAR *assign_seconds PARAMS((SHELL_VAR *, char *, arrayind_t, char *));
-static SHELL_VAR *get_seconds PARAMS((SHELL_VAR *));
-static SHELL_VAR *init_seconds_var PARAMS((void));
-
-static SHELL_VAR *assign_random PARAMS((SHELL_VAR *, char *, arrayind_t, char *));
-static SHELL_VAR *get_random PARAMS((SHELL_VAR *));
-
-static SHELL_VAR *get_urandom PARAMS((SHELL_VAR *));
-
-static SHELL_VAR *assign_lineno PARAMS((SHELL_VAR *, char *, arrayind_t, char *));
-static SHELL_VAR *get_lineno PARAMS((SHELL_VAR *));
-
-static SHELL_VAR *assign_subshell PARAMS((SHELL_VAR *, char *, arrayind_t, char *));
-static SHELL_VAR *get_subshell PARAMS((SHELL_VAR *));
-
-static SHELL_VAR *get_epochseconds PARAMS((SHELL_VAR *));
-static SHELL_VAR *get_epochrealtime PARAMS((SHELL_VAR *));
-
-static SHELL_VAR *get_bashpid PARAMS((SHELL_VAR *));
-
-static SHELL_VAR *get_bash_argv0 PARAMS((SHELL_VAR *));
-static SHELL_VAR *assign_bash_argv0 PARAMS((SHELL_VAR *, char *, arrayind_t, char *));
-static void set_argv0 PARAMS((void));
-
-#if defined (HISTORY)
-static SHELL_VAR *get_histcmd PARAMS((SHELL_VAR *));
-#endif
-
-#if defined (READLINE)
-static SHELL_VAR *get_comp_wordbreaks PARAMS((SHELL_VAR *));
-static SHELL_VAR *assign_comp_wordbreaks PARAMS((SHELL_VAR *, char *, arrayind_t, char *));
-#endif
-
-#if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
-static SHELL_VAR *assign_dirstack PARAMS((SHELL_VAR *, char *, arrayind_t, char *));
-static SHELL_VAR *get_dirstack PARAMS((SHELL_VAR *));
-#endif
-
-#if defined (ARRAY_VARS)
-static SHELL_VAR *get_groupset PARAMS((SHELL_VAR *));
-#  if defined (DEBUGGER)
-static SHELL_VAR *get_bashargcv PARAMS((SHELL_VAR *));
-#  endif
-static SHELL_VAR *build_hashcmd PARAMS((SHELL_VAR *));
-static SHELL_VAR *get_hashcmd PARAMS((SHELL_VAR *));
-static SHELL_VAR *assign_hashcmd PARAMS((SHELL_VAR *,  char *, arrayind_t, char *));
-#  if defined (ALIAS)
-static SHELL_VAR *build_aliasvar PARAMS((SHELL_VAR *));
-static SHELL_VAR *get_aliasvar PARAMS((SHELL_VAR *));
-static SHELL_VAR *assign_aliasvar PARAMS((SHELL_VAR *,  char *, arrayind_t, char *));
-#  endif
-#endif
-
-static SHELL_VAR *get_funcname PARAMS((SHELL_VAR *));
-static SHELL_VAR *init_funcname_var PARAMS((void));
-
-static void initialize_dynamic_variables PARAMS((void));
-
-static SHELL_VAR *bind_invalid_envvar PARAMS((const char *, char *, int));
-
-static int var_sametype PARAMS((SHELL_VAR *, SHELL_VAR *));
-
-static SHELL_VAR *hash_lookup PARAMS((const char *, HASH_TABLE *));
-static SHELL_VAR *new_shell_variable PARAMS((const char *));
-static SHELL_VAR *make_new_variable PARAMS((const char *, HASH_TABLE *));
-static SHELL_VAR *bind_variable_internal PARAMS((const char *, char *, HASH_TABLE *, int, int));
-
-static void dispose_variable_value PARAMS((SHELL_VAR *));
-static void free_variable_hash_data PARAMS((PTR_T));
-
-static VARLIST *vlist_alloc PARAMS((int));
-static VARLIST *vlist_realloc PARAMS((VARLIST *, int));
-static void vlist_add PARAMS((VARLIST *, SHELL_VAR *, int));
-
-static void flatten PARAMS((HASH_TABLE *, sh_var_map_func_t *, VARLIST *, int));
-
-static int qsort_var_comp PARAMS((SHELL_VAR **, SHELL_VAR **));
-
-static SHELL_VAR **vapply PARAMS((sh_var_map_func_t *));
-static SHELL_VAR **fapply PARAMS((sh_var_map_func_t *));
-
-static int visible_var PARAMS((SHELL_VAR *));
-static int visible_and_exported PARAMS((SHELL_VAR *));
-static int export_environment_candidate PARAMS((SHELL_VAR *));
-static int local_and_exported PARAMS((SHELL_VAR *));
-static int visible_variable_in_context PARAMS((SHELL_VAR *));
-static int variable_in_context PARAMS((SHELL_VAR *));
-#if defined (ARRAY_VARS)
-static int visible_array_vars PARAMS((SHELL_VAR *));
-#endif
-
-static SHELL_VAR *find_variable_internal PARAMS((const char *, int));
-
-static SHELL_VAR *find_nameref_at_context PARAMS((SHELL_VAR *, VAR_CONTEXT *));
-static SHELL_VAR *find_variable_nameref_context PARAMS((SHELL_VAR *, VAR_CONTEXT *, VAR_CONTEXT **));
-static SHELL_VAR *find_variable_last_nameref_context PARAMS((SHELL_VAR *, VAR_CONTEXT *, VAR_CONTEXT **));
-
-static SHELL_VAR *bind_tempenv_variable PARAMS((const char *, char *));
-static void push_posix_temp_var PARAMS((PTR_T));
-static void push_temp_var PARAMS((PTR_T));
-static void propagate_temp_var PARAMS((PTR_T));
-static void dispose_temporary_env PARAMS((sh_free_func_t *));     
-
-static inline char *mk_env_string PARAMS((const char *, const char *, int));
-static char **make_env_array_from_var_list PARAMS((SHELL_VAR **));
-static char **make_var_export_array PARAMS((VAR_CONTEXT *));
-static char **make_func_export_array PARAMS((void));
-static void add_temp_array_to_env PARAMS((char **, int, int));
-
-static int n_shell_variables PARAMS((void));
-static int set_context PARAMS((SHELL_VAR *));
-
-static void push_func_var PARAMS((PTR_T));
-static void push_builtin_var PARAMS((PTR_T));
-static void push_exported_var PARAMS((PTR_T));
-
-static void delete_local_contexts PARAMS((VAR_CONTEXT *));
-
-/* This needs to be looked at again. */
-static inline void push_posix_tempvar_internal PARAMS((SHELL_VAR *, int));
-
-static inline int find_special_var PARAMS((const char *));
-
-static void
-create_variable_tables ()
-{
-  if (shell_variables == 0)
-    {
-      shell_variables = global_variables = new_var_context ((char *)NULL, 0);
-      shell_variables->scope = 0;
-      shell_variables->table = hash_create (VARIABLES_HASH_BUCKETS);
-    }
-
-  if (shell_functions == 0)
-    shell_functions = hash_create (FUNCTIONS_HASH_BUCKETS);
-
-#if defined (DEBUGGER)
-  if (shell_function_defs == 0)
-    shell_function_defs = hash_create (FUNCTIONS_HASH_BUCKETS);
-#endif
-}
-
-/* Initialize the shell variables from the current environment.
-   If PRIVMODE is nonzero, don't import functions from ENV or
-   parse $SHELLOPTS. */
-void
-initialize_shell_variables (env, privmode)
-     char **env;
-     int privmode;
-{
-  char *name, *string, *temp_string;
-  int c, char_index, string_index, string_length, ro;
-  SHELL_VAR *temp_var;
-
-  create_variable_tables ();
-
-  for (string_index = 0; env && (string = env[string_index++]); )
-    {
-      char_index = 0;
-      name = string;
-      while ((c = *string++) && c != '=')
-	;
-      if (string[-1] == '=')
-	char_index = string - name - 1;
-
-      /* If there are weird things in the environment, like `=xxx' or a
-	 string without an `=', just skip them. */
-      if (char_index == 0)
-	continue;
-
-      /* ASSERT(name[char_index] == '=') */
-      name[char_index] = '\0';
-      /* Now, name = env variable name, string = env variable value, and
-	 char_index == strlen (name) */
-
-      temp_var = (SHELL_VAR *)NULL;
-
-#if defined (FUNCTION_IMPORT)
-      /* If exported function, define it now.  Don't import functions from
-	 the environment in privileged mode. */
-      if (privmode == 0 && read_but_dont_execute == 0 && 
-          STREQN (BASHFUNC_PREFIX, name, BASHFUNC_PREFLEN) &&
-          STREQ (BASHFUNC_SUFFIX, name + char_index - BASHFUNC_SUFFLEN) &&
-	  STREQN ("() {", string, 4))
-	{
-	  size_t namelen;
-	  char *tname;		/* desired imported function name */
-
-	  namelen = char_index - BASHFUNC_PREFLEN - BASHFUNC_SUFFLEN;
-
-	  tname = name + BASHFUNC_PREFLEN;	/* start of func name */
-	  tname[namelen] = '\0';		/* now tname == func name */
-
-	  string_length = strlen (string);
-	  temp_string = (char *)xmalloc (namelen + string_length + 2);
-
-	  memcpy (temp_string, tname, namelen);
-	  temp_string[namelen] = ' ';
-	  memcpy (temp_string + namelen + 1, string, string_length + 1);
-
-	  /* Don't import function names that are invalid identifiers from the
-	     environment in posix mode, though we still allow them to be defined as
-	     shell variables. */
-	  if (absolute_program (tname) == 0 && (posixly_correct == 0 || legal_identifier (tname)))
-	    parse_and_execute (temp_string, tname, SEVAL_NONINT|SEVAL_NOHIST|SEVAL_FUNCDEF|SEVAL_ONECMD);
-	  else
-	    free (temp_string);		/* parse_and_execute does this */
-
-	  if (temp_var = find_function (tname))
-	    {
-	      VSETATTR (temp_var, (att_exported|att_imported));
-	      array_needs_making = 1;
-	    }
-	  else
-	    {
-	      if (temp_var = bind_invalid_envvar (name, string, 0))
-		{
-		  VSETATTR (temp_var, (att_exported | att_imported | att_invisible));
-		  array_needs_making = 1;
-		}
-	      last_command_exit_value = EXECUTION_FAILURE;
-	      report_error (_("error importing function definition for `%s'"), tname);
-	    }
-
-	  /* Restore original suffix */
-	  tname[namelen] = BASHFUNC_SUFFIX[0];
-	}
-      else
-#endif /* FUNCTION_IMPORT */
-#if defined (ARRAY_VARS)
-#  if ARRAY_EXPORT
-      /* Array variables may not yet be exported. */
-      if (STREQN (BASHARRAY_PREFIX, name, BASHARRAY_PREFLEN) &&
-	  STREQN (BASHARRAY_SUFFIX, name + char_index - BASHARRAY_SUFFLEN, BASHARRAY_SUFFLEN) &&
-	  *string == '(' && string[1] == '[' && string[strlen (string) - 1] == ')')
-	{
-	  size_t namelen;
-	  char *tname;		/* desired imported array variable name */
-
-	  namelen = char_index - BASHARRAY_PREFLEN - BASHARRAY_SUFFLEN;
-
-	  tname = name + BASHARRAY_PREFLEN;	/* start of variable name */
-	  tname[namelen] = '\0';		/* now tname == varname */
-	  
-	  string_length = 1;
-	  temp_string = extract_array_assignment_list (string, &string_length);
-	  temp_var = assign_array_from_string (tname, temp_string, 0);
-	  FREE (temp_string);
-	  if (temp_var)
-	    {
-	      VSETATTR (temp_var, (att_exported | att_imported));
-	      array_needs_making = 1;
-	    }
-	}
-      else if (STREQN (BASHASSOC_PREFIX, name, BASHASSOC_PREFLEN) &&
-	  STREQN (BASHASSOC_SUFFIX, name + char_index - BASHASSOC_SUFFLEN, BASHASSOC_SUFFLEN) &&
-	  *string == '(' && string[1] == '[' && string[strlen (string) - 1] == ')')
-	{
-	  size_t namelen;
-	  char *tname;		/* desired imported assoc variable name */
-
-	  namelen = char_index - BASHASSOC_PREFLEN - BASHASSOC_SUFFLEN;
-
-	  tname = name + BASHASSOC_PREFLEN;	/* start of variable name */
-	  tname[namelen] = '\0';		/* now tname == varname */
-
-	  /* need to make sure it exists as an associative array first */
-	  temp_var = find_or_make_array_variable (tname, 2);
-	  if (temp_var)
-	    {
-	      string_length = 1;
-	      temp_string = extract_array_assignment_list (string, &string_length);
-	      temp_var = assign_array_var_from_string (temp_var, temp_string, 0);
-	    }
-	  FREE (temp_string);
-	  if (temp_var)
-	    {
-	      VSETATTR (temp_var, (att_exported | att_imported));
-	      array_needs_making = 1;
-	    }
-	}
-      else
-#  endif /* ARRAY_EXPORT */
-#endif
-	{
-	  ro = 0;
-	  /* If we processed a command-line option that caused SHELLOPTS to be
-	     set, it may already be set (and read-only) by the time we process
-	     the shell's environment. */
-	  if (/* posixly_correct &&*/ STREQ (name, "SHELLOPTS"))
-	    {
-	      temp_var = find_variable ("SHELLOPTS");
-	      ro = temp_var && readonly_p (temp_var);
-	      if (temp_var)
-		VUNSETATTR (temp_var, att_readonly);
-	    }
-	  if (legal_identifier (name))
-	    {
-	      temp_var = bind_variable (name, string, 0);
-	      if (temp_var)
-		{
-		  VSETATTR (temp_var, (att_exported | att_imported));
-		  if (ro)
-		    VSETATTR (temp_var, att_readonly);
-		}
-	    }
-	  else
-	    {
-	      temp_var = bind_invalid_envvar (name, string, 0);
-	      if (temp_var)
-		VSETATTR (temp_var, (att_exported | att_imported | att_invisible));
-	    }
-	  if (temp_var)
-	    array_needs_making = 1;
-	}
-
-      name[char_index] = '=';
-      /* temp_var can be NULL if it was an exported function with a syntax
-	 error (a different bug, but it still shouldn't dump core). */
-      if (temp_var && function_p (temp_var) == 0)	/* XXX not yet */
-	{
-	  CACHE_IMPORTSTR (temp_var, name);
-	}
-    }
-
-  set_pwd ();
-
-  /* Set up initial value of $_ */
-  temp_var = set_if_not ("_", dollar_vars[0]);
-
-  /* Remember this pid. */
-  dollar_dollar_pid = getpid ();
-
-  /* Now make our own defaults in case the vars that we think are
-     important are missing. */
-  temp_var = set_if_not ("PATH", DEFAULT_PATH_VALUE);
-  temp_var = set_if_not ("TERM", "dumb");
-
-#if defined (__QNX__)
-  /* set node id -- don't import it from the environment */
-  {
-    char node_name[22];
-#  if defined (__QNXNTO__)
-    netmgr_ndtostr(ND2S_LOCAL_STR, ND_LOCAL_NODE, node_name, sizeof(node_name));
-#  else
-    qnx_nidtostr (getnid (), node_name, sizeof (node_name));
-#  endif
-    temp_var = bind_variable ("NODE", node_name, 0);
-    if (temp_var)
-      set_auto_export (temp_var);
-  }
-#endif
-
-  /* set up the prompts. */
-  if (interactive_shell)
-    {
-#if defined (PROMPT_STRING_DECODE)
-      set_if_not ("PS1", primary_prompt);
-#else
-      if (current_user.uid == -1)
-	get_current_user_info ();
-      set_if_not ("PS1", current_user.euid == 0 ? "# " : primary_prompt);
-#endif
-      set_if_not ("PS2", secondary_prompt);
-    }
-
-  if (current_user.euid == 0)
-    bind_variable ("PS4", "+ ", 0);
-  else
-    set_if_not ("PS4", "+ ");
-
-  /* Don't allow IFS to be imported from the environment. */
-  temp_var = bind_variable ("IFS", " \t\n", 0);
-  setifs (temp_var);
-
-  /* Magic machine types.  Pretty convenient. */
-  set_machine_vars ();
-
-  /* Default MAILCHECK for interactive shells.  Defer the creation of a
-     default MAILPATH until the startup files are read, because MAIL
-     names a mail file if MAILPATH is not set, and we should provide a
-     default only if neither is set. */
-  if (interactive_shell)
-    {
-      temp_var = set_if_not ("MAILCHECK", posixly_correct ? "600" : "60");
-      VSETATTR (temp_var, att_integer);
-    }
-
-  /* Do some things with shell level. */
-  initialize_shell_level ();
-
-  set_ppid ();
-
-  set_argv0 ();
-
-  /* Initialize the `getopts' stuff. */
-  temp_var = bind_variable ("OPTIND", "1", 0);
-  VSETATTR (temp_var, att_integer);
-  getopts_reset (0);
-  bind_variable ("OPTERR", "1", 0);
-  sh_opterr = 1;
-
-  if (login_shell == 1 && posixly_correct == 0)
-    set_home_var ();
-
-  /* Get the full pathname to THIS shell, and set the BASH variable
-     to it. */
-  name = get_bash_name ();
-  temp_var = bind_variable ("BASH", name, 0);
-  free (name);
-
-  /* Make the exported environment variable SHELL be the user's login
-     shell.  Note that the `tset' command looks at this variable
-     to determine what style of commands to output; if it ends in "csh",
-     then C-shell commands are output, else Bourne shell commands. */
-  set_shell_var ();
-
-  /* Make a variable called BASH_VERSION which contains the version info. */
-  bind_variable ("BASH_VERSION", shell_version_string (), 0);
-#if defined (ARRAY_VARS)
-  make_vers_array ();
-#endif
-
-  if (command_execution_string)
-    bind_variable ("BASH_EXECUTION_STRING", command_execution_string, 0);
-
-  /* Find out if we're supposed to be in Posix.2 mode via an
-     environment variable. */
-  temp_var = find_variable ("POSIXLY_CORRECT");
-  if (!temp_var)
-    temp_var = find_variable ("POSIX_PEDANTIC");
-  if (temp_var && imported_p (temp_var))
-    sv_strict_posix (temp_var->name);
-
-#if defined (HISTORY)
-  /* Set history variables to defaults, and then do whatever we would
-     do if the variable had just been set.  Do this only in the case
-     that we are remembering commands on the history list. */
-  if (remember_on_history)
-    {
-      name = bash_tilde_expand (posixly_correct ? "~/.sh_history" : "~/.bash_history", 0);
-
-      set_if_not ("HISTFILE", name);
-      free (name);
-    }
-#endif /* HISTORY */
-
-  /* Seed the random number generators. */
-  seedrand ();
-  seedrand32 ();
-
-  /* Handle some "special" variables that we may have inherited from a
-     parent shell. */
-  if (interactive_shell)
-    {
-      temp_var = find_variable ("IGNOREEOF");
-      if (!temp_var)
-	temp_var = find_variable ("ignoreeof");
-      if (temp_var && imported_p (temp_var))
-	sv_ignoreeof (temp_var->name);
-    }
-
-#if defined (HISTORY)
-  if (interactive_shell && remember_on_history)
-    {
-      sv_history_control ("HISTCONTROL");
-      sv_histignore ("HISTIGNORE");
-      sv_histtimefmt ("HISTTIMEFORMAT");
-    }
-#endif /* HISTORY */
-
-#if defined (READLINE) && defined (STRICT_POSIX)
-  /* POSIXLY_CORRECT will be 1 here if the shell was compiled
-     -DSTRICT_POSIX or if POSIXLY_CORRECT was supplied in the shell's
-     environment */
-  if (interactive_shell && posixly_correct && no_line_editing == 0)
-    rl_prefer_env_winsize = 1;
-#endif /* READLINE && STRICT_POSIX */
-
-  /* Get the user's real and effective user ids. */
-  uidset ();
-
-  temp_var = set_if_not ("BASH_LOADABLES_PATH", DEFAULT_LOADABLE_BUILTINS_PATH);
-
-  temp_var = find_variable ("BASH_XTRACEFD");
-  if (temp_var && imported_p (temp_var))
-    sv_xtracefd (temp_var->name);
-
-  sv_shcompat ("BASH_COMPAT");
-
-  /* Allow FUNCNEST to be inherited from the environment. */
-  sv_funcnest ("FUNCNEST");
-
-  /* Initialize the dynamic variables, and seed their values. */
-  initialize_dynamic_variables ();
-}
-
-/* **************************************************************** */
-/*								    */
-/*	     Setting values for special shell variables		    */
-/*								    */
-/* **************************************************************** */
-
-static void
-set_machine_vars ()
-{
-  SHELL_VAR *temp_var;
-
-  temp_var = set_if_not ("HOSTTYPE", HOSTTYPE);
-  temp_var = set_if_not ("OSTYPE", OSTYPE);
-  temp_var = set_if_not ("MACHTYPE", MACHTYPE);
-
-  temp_var = set_if_not ("HOSTNAME", current_host_name);
-}
-
-/* Set $HOME to the information in the password file if we didn't get
-   it from the environment. */
-
-/* This function is not static so the tilde and readline libraries can
-   use it. */
-char *
-sh_get_home_dir ()
-{
-  if (current_user.home_dir == 0)
-    get_current_user_info ();
-  return current_user.home_dir;
-}
-
-static void
-set_home_var ()
-{
-  SHELL_VAR *temp_var;
-
-  temp_var = find_variable ("HOME");
-  if (temp_var == 0)
-    temp_var = bind_variable ("HOME", sh_get_home_dir (), 0);
-#if 0
-  VSETATTR (temp_var, att_exported);
-#endif
-}
-
-/* Set $SHELL to the user's login shell if it is not already set.  Call
-   get_current_user_info if we haven't already fetched the shell. */
-static void
-set_shell_var ()
-{
-  SHELL_VAR *temp_var;
-
-  temp_var = find_variable ("SHELL");
-  if (temp_var == 0)
-    {
-      if (current_user.shell == 0)
-	get_current_user_info ();
-      temp_var = bind_variable ("SHELL", current_user.shell, 0);
-    }
-#if 0
-  VSETATTR (temp_var, att_exported);
-#endif
-}
-
-static char *
-get_bash_name ()
-{
-  char *name;
-
-  if ((login_shell == 1) && RELPATH(shell_name))
-    {
-      if (current_user.shell == 0)
-	get_current_user_info ();
-      name = savestring (current_user.shell);
-    }
-  else if (ABSPATH(shell_name))
-    name = savestring (shell_name);
-  else if (shell_name[0] == '.' && shell_name[1] == '/')
-    {
-      /* Fast path for common case. */
-      char *cdir;
-      int len;
-
-      cdir = get_string_value ("PWD");
-      if (cdir)
-	{
-	  len = strlen (cdir);
-	  name = (char *)xmalloc (len + strlen (shell_name) + 1);
-	  strcpy (name, cdir);
-	  strcpy (name + len, shell_name + 1);
-	}
-      else
-	name = savestring (shell_name);
-    }
-  else
-    {
-      char *tname;
-      int s;
-
-      tname = find_user_command (shell_name);
-
-      if (tname == 0)
-	{
-	  /* Try the current directory.  If there is not an executable
-	     there, just punt and use the login shell. */
-	  s = file_status (shell_name);
-	  if (s & FS_EXECABLE)
-	    {
-	      tname = make_absolute (shell_name, get_string_value ("PWD"));
-	      if (*shell_name == '.')
-		{
-		  name = sh_canonpath (tname, PATH_CHECKDOTDOT|PATH_CHECKEXISTS);
-		  if (name == 0)
-		    name = tname;
-		  else
-		    free (tname);
-		}
-	     else
-		name = tname;
-	    }
-	  else
-	    {
-	      if (current_user.shell == 0)
-		get_current_user_info ();
-	      name = savestring (current_user.shell);
-	    }
-	}
-      else
-	{
-	  name = full_pathname (tname);
-	  free (tname);
-	}
-    }
-
-  return (name);
-}
-
-void
-adjust_shell_level (change)
-     int change;
-{
-  char new_level[5], *old_SHLVL;
-  intmax_t old_level;
-  SHELL_VAR *temp_var;
-
-  old_SHLVL = get_string_value ("SHLVL");
-  if (old_SHLVL == 0 || *old_SHLVL == '\0' || legal_number (old_SHLVL, &old_level) == 0)
-    old_level = 0;
-
-  shell_level = old_level + change;
-  if (shell_level < 0)
-    shell_level = 0;
-  else if (shell_level >= 1000)
-    {
-      internal_warning (_("shell level (%d) too high, resetting to 1"), shell_level);
-      shell_level = 1;
-    }
-
-  /* We don't need the full generality of itos here. */
-  if (shell_level < 10)
-    {
-      new_level[0] = shell_level + '0';
-      new_level[1] = '\0';
-    }
-  else if (shell_level < 100)
-    {
-      new_level[0] = (shell_level / 10) + '0';
-      new_level[1] = (shell_level % 10) + '0';
-      new_level[2] = '\0';
-    }
-  else if (shell_level < 1000)
-    {
-      new_level[0] = (shell_level / 100) + '0';
-      old_level = shell_level % 100;
-      new_level[1] = (old_level / 10) + '0';
-      new_level[2] = (old_level % 10) + '0';
-      new_level[3] = '\0';
-    }
-
-  temp_var = bind_variable ("SHLVL", new_level, 0);
-  set_auto_export (temp_var);
-}
-
-static void
-initialize_shell_level ()
-{
-  adjust_shell_level (1);
-}
-
-/* If we got PWD from the environment, update our idea of the current
-   working directory.  In any case, make sure that PWD exists before
-   checking it.  It is possible for getcwd () to fail on shell startup,
-   and in that case, PWD would be undefined.  If this is an interactive
-   login shell, see if $HOME is the current working directory, and if
-   that's not the same string as $PWD, set PWD=$HOME. */
-
-void
-set_pwd ()
-{
-  SHELL_VAR *temp_var, *home_var;
-  char *temp_string, *home_string, *current_dir;
-
-  home_var = find_variable ("HOME");
-  home_string = home_var ? value_cell (home_var) : (char *)NULL;
-
-  temp_var = find_variable ("PWD");
-  /* Follow posix rules for importing PWD */
-  if (temp_var && imported_p (temp_var) &&
-      (temp_string = value_cell (temp_var)) &&
-      temp_string[0] == '/' &&
-      same_file (temp_string, ".", (struct stat *)NULL, (struct stat *)NULL))
-    {
-      current_dir = sh_canonpath (temp_string, PATH_CHECKDOTDOT|PATH_CHECKEXISTS);
-      if (current_dir == 0)
-	current_dir = get_working_directory ("shell_init");
-      else
-	set_working_directory (current_dir);
-      if (posixly_correct && current_dir)
-	{
-	  temp_var = bind_variable ("PWD", current_dir, 0);
-	  set_auto_export (temp_var);
-	}  
-      free (current_dir);
-    }
-  else if (home_string && interactive_shell && login_shell &&
-	   same_file (home_string, ".", (struct stat *)NULL, (struct stat *)NULL))
-    {
-      set_working_directory (home_string);
-      temp_var = bind_variable ("PWD", home_string, 0);
-      set_auto_export (temp_var);
-    }
-  else
-    {
-      temp_string = get_working_directory ("shell-init");
-      if (temp_string)
-	{
-	  temp_var = bind_variable ("PWD", temp_string, 0);
-	  set_auto_export (temp_var);
-	  free (temp_string);
-	}
-    }
-
-  /* According to the Single Unix Specification, v2, $OLDPWD is an
-     `environment variable' and therefore should be auto-exported.  If we
-     don't find OLDPWD in the environment, or it doesn't name a directory,
-     make a dummy invisible variable for OLDPWD, and mark it as exported. */
-  temp_var = find_variable ("OLDPWD");
-#if defined (OLDPWD_CHECK_DIRECTORY)
-  if (temp_var == 0 || value_cell (temp_var) == 0 || file_isdir (value_cell (temp_var)) == 0)
-#else
-  if (temp_var == 0 || value_cell (temp_var) == 0)
-#endif
-    {
-      temp_var = bind_variable ("OLDPWD", (char *)NULL, 0);
-      VSETATTR (temp_var, (att_exported | att_invisible));
-    }
-}
-
-/* Make a variable $PPID, which holds the pid of the shell's parent.  */
-void
-set_ppid ()
-{
-  char namebuf[INT_STRLEN_BOUND(pid_t) + 1], *name;
-  SHELL_VAR *temp_var;
-
-  name = inttostr (getppid (), namebuf, sizeof(namebuf));
-  temp_var = find_variable ("PPID");
-  if (temp_var)
-    VUNSETATTR (temp_var, (att_readonly | att_exported));
-  temp_var = bind_variable ("PPID", name, 0);
-  VSETATTR (temp_var, (att_readonly | att_integer));
-}
-
-static void
-uidset ()
-{
-  char buff[INT_STRLEN_BOUND(uid_t) + 1], *b;
-  register SHELL_VAR *v;
-
-  b = inttostr (current_user.uid, buff, sizeof (buff));
-  v = find_variable ("UID");
-  if (v == 0)
-    {
-      v = bind_variable ("UID", b, 0);
-      VSETATTR (v, (att_readonly | att_integer));
-    }
-
-  if (current_user.euid != current_user.uid)
-    b = inttostr (current_user.euid, buff, sizeof (buff));
-
-  v = find_variable ("EUID");
-  if (v == 0)
-    {
-      v = bind_variable ("EUID", b, 0);
-      VSETATTR (v, (att_readonly | att_integer));
-    }
-}
-
-#if defined (ARRAY_VARS)
-static void
-make_vers_array ()
-{
-  SHELL_VAR *vv;
-  ARRAY *av;
-  char *s, d[32], b[INT_STRLEN_BOUND(int) + 1];
-
-  unbind_variable_noref ("BASH_VERSINFO");
-
-  vv = make_new_array_variable ("BASH_VERSINFO");
-  av = array_cell (vv);
-  strcpy (d, dist_version);
-  s = strchr (d, '.');
-  if (s)
-    *s++ = '\0';
-  array_insert (av, 0, d);
-  array_insert (av, 1, s);
-  s = inttostr (patch_level, b, sizeof (b));
-  array_insert (av, 2, s);
-  s = inttostr (build_version, b, sizeof (b));
-  array_insert (av, 3, s);
-  array_insert (av, 4, release_status);
-  array_insert (av, 5, MACHTYPE);
-
-  VSETATTR (vv, att_readonly);
-}
-#endif /* ARRAY_VARS */
-
-/* Set the environment variables $LINES and $COLUMNS in response to
-   a window size change. */
-void
-sh_set_lines_and_columns (lines, cols)
-     int lines, cols;
-{
-  char val[INT_STRLEN_BOUND(int) + 1], *v;
-
-#if defined (READLINE)
-  /* If we are currently assigning to LINES or COLUMNS, don't do anything. */
-  if (winsize_assignment)
-    return;
-#endif
-
-  v = inttostr (lines, val, sizeof (val));
-  bind_variable ("LINES", v, 0);
-
-  v = inttostr (cols, val, sizeof (val));
-  bind_variable ("COLUMNS", v, 0);
-}
-
-/* **************************************************************** */
-/*								    */
-/*		   Printing variables and values		    */
-/*								    */
-/* **************************************************************** */
-
-/* Print LIST (a list of shell variables) to stdout in such a way that
-   they can be read back in. */
-void
-print_var_list (list)
-     register SHELL_VAR **list;
-{
-  register int i;
-  register SHELL_VAR *var;
-
-  for (i = 0; list && (var = list[i]); i++)
-    if (invisible_p (var) == 0)
-      print_assignment (var);
-}
-
-/* Print LIST (a list of shell functions) to stdout in such a way that
-   they can be read back in. */
-void
-print_func_list (list)
-     register SHELL_VAR **list;
-{
-  register int i;
-  register SHELL_VAR *var;
-
-  for (i = 0; list && (var = list[i]); i++)
-    {
-      printf ("%s ", var->name);
-      print_var_function (var);
-      printf ("\n");
-    }
-}
-      
-/* Print the value of a single SHELL_VAR.  No newline is
-   output, but the variable is printed in such a way that
-   it can be read back in. */
-void
-print_assignment (var)
-     SHELL_VAR *var;
-{
-  if (var_isset (var) == 0)
-    return;
-
-  if (function_p (var))
-    {
-      printf ("%s", var->name);
-      print_var_function (var);
-      printf ("\n");
-    }
-#if defined (ARRAY_VARS)
-  else if (array_p (var))
-    print_array_assignment (var, 0);
-  else if (assoc_p (var))
-    print_assoc_assignment (var, 0);
-#endif /* ARRAY_VARS */
-  else
-    {
-      printf ("%s=", var->name);
-      print_var_value (var, 1);
-      printf ("\n");
-    }
-}
-
-/* Print the value cell of VAR, a shell variable.  Do not print
-   the name, nor leading/trailing newline.  If QUOTE is non-zero,
-   and the value contains shell metacharacters, quote the value
-   in such a way that it can be read back in. */
-void
-print_var_value (var, quote)
-     SHELL_VAR *var;
-     int quote;
-{
-  char *t;
-
-  if (var_isset (var) == 0)
-    return;
-
-  if (quote && posixly_correct == 0 && ansic_shouldquote (value_cell (var)))
-    {
-      t = ansic_quote (value_cell (var), 0, (int *)0);
-      printf ("%s", t);
-      free (t);
-    }
-  else if (quote && sh_contains_shell_metas (value_cell (var)))
-    {
-      t = sh_single_quote (value_cell (var));
-      printf ("%s", t);
-      free (t);
-    }
-  else
-    printf ("%s", value_cell (var));
-}
-
-/* Print the function cell of VAR, a shell variable.  Do not
-   print the name, nor leading/trailing newline. */
-void
-print_var_function (var)
-     SHELL_VAR *var;
-{
-  char *x;
-
-  if (function_p (var) && var_isset (var))
-    {
-      x = named_function_string ((char *)NULL, function_cell(var), FUNC_MULTILINE|FUNC_EXTERNAL);
-      printf ("%s", x);
-    }
-}
-
-/* **************************************************************** */
-/*								    */
-/*		 	Dynamic Variables			    */
-/*								    */
-/* **************************************************************** */
-
-/* DYNAMIC VARIABLES
-
-   These are variables whose values are generated anew each time they are
-   referenced.  These are implemented using a pair of function pointers
-   in the struct variable: assign_func, which is called from bind_variable
-   and, if arrays are compiled into the shell, some of the functions in
-   arrayfunc.c, and dynamic_value, which is called from find_variable.
-
-   assign_func is called from bind_variable_internal, if
-   bind_variable_internal discovers that the variable being assigned to
-   has such a function.  The function is called as
-	SHELL_VAR *temp = (*(entry->assign_func)) (entry, value, ind)
-   and the (SHELL_VAR *)temp is returned as the value of bind_variable.  It
-   is usually ENTRY (self).  IND is an index for an array variable, and
-   unused otherwise.
-
-   dynamic_value is called from find_variable_internal to return a `new'
-   value for the specified dynamic variable.  If this function is NULL,
-   the variable is treated as a `normal' shell variable.  If it is not,
-   however, then this function is called like this:
-	tempvar = (*(var->dynamic_value)) (var);
-
-   Sometimes `tempvar' will replace the value of `var'.  Other times, the
-   shell will simply use the string value.  Pretty object-oriented, huh?
-
-   Be warned, though: if you `unset' a special variable, it loses its
-   special meaning, even if you subsequently set it.
-
-   The special assignment code would probably have been better put in
-   subst.c: do_assignment_internal, in the same style as
-   stupidly_hack_special_variables, but I wanted the changes as
-   localized as possible.  */
-
-#define INIT_DYNAMIC_VAR(var, val, gfunc, afunc) \
-  do \
-    { \
-      v = bind_variable (var, (val), 0); \
-      v->dynamic_value = gfunc; \
-      v->assign_func = afunc; \
-    } \
-  while (0)
-
-#define INIT_DYNAMIC_ARRAY_VAR(var, gfunc, afunc) \
-  do \
-    { \
-      v = make_new_array_variable (var); \
-      v->dynamic_value = gfunc; \
-      v->assign_func = afunc; \
-    } \
-  while (0)
-
-#define INIT_DYNAMIC_ASSOC_VAR(var, gfunc, afunc) \
-  do \
-    { \
-      v = make_new_assoc_variable (var); \
-      v->dynamic_value = gfunc; \
-      v->assign_func = afunc; \
-    } \
-  while (0)
-
-static SHELL_VAR *
-null_assign (self, value, unused, key)
-     SHELL_VAR *self;
-     char *value;
-     arrayind_t unused;
-     char *key;
-{
-  return (self);
-}
-
-#if defined (ARRAY_VARS)
-static SHELL_VAR *
-null_array_assign (self, value, ind, key)
-     SHELL_VAR *self;
-     char *value;
-     arrayind_t ind;
-     char *key;
-{
-  return (self);
-}
-#endif
-
-/* Degenerate `dynamic_value' function; just returns what's passed without
-   manipulation. */
-static SHELL_VAR *
-get_self (self)
-     SHELL_VAR *self;
-{
-  return (self);
-}
-
-#if defined (ARRAY_VARS)
-/* A generic dynamic array variable initializer.  Initialize array variable
-   NAME with dynamic value function GETFUNC and assignment function SETFUNC. */
-static SHELL_VAR *
-init_dynamic_array_var (name, getfunc, setfunc, attrs)
-     char *name;
-     sh_var_value_func_t *getfunc;
-     sh_var_assign_func_t *setfunc;
-     int attrs;
-{
-  SHELL_VAR *v;
-
-  v = find_variable (name);
-  if (v)
-    return (v);
-  INIT_DYNAMIC_ARRAY_VAR (name, getfunc, setfunc);
-  if (attrs)
-    VSETATTR (v, attrs);
-  return v;
-}
-
-static SHELL_VAR *
-init_dynamic_assoc_var (name, getfunc, setfunc, attrs)
-     char *name;
-     sh_var_value_func_t *getfunc;
-     sh_var_assign_func_t *setfunc;
-     int attrs;
-{
-  SHELL_VAR *v;
-
-  v = find_variable (name);
-  if (v)
-    return (v);
-  INIT_DYNAMIC_ASSOC_VAR (name, getfunc, setfunc);
-  if (attrs)
-    VSETATTR (v, attrs);
-  return v;
-}
-#endif
-
-/* Set the string value of VAR to the string representation of VALUE.
-   Right now this takes an INTMAX_T because that's what itos needs. If
-   FLAGS&1, we force the integer attribute on. */
-static inline SHELL_VAR *
-set_int_value (SHELL_VAR *var, intmax_t value, int flags)
-{
-  char *p;
-
-  p = itos (value);
-  FREE (value_cell (var));
-  var_setvalue (var, p);
-  if (flags & 1)
-    VSETATTR (var, att_integer);
-  return (var);
-}
-
-static inline SHELL_VAR *
-set_string_value (SHELL_VAR *var, const char *value, int flags)
-{
-  char *p;
-
-  if (value && *value)
-    p = savestring (value);
-  else
-    {
-      p = (char *)xmalloc (1);
-      p[0] = '\0';
-    }
-  FREE (value_cell (var));
-  var_setvalue (var, p);
-  return (var);
-}
-
-/* The value of $SECONDS.  This is the number of seconds since shell
-   invocation, or, the number of seconds since the last assignment + the
-   value of the last assignment. */
-static intmax_t seconds_value_assigned;
-
-static SHELL_VAR *
-assign_seconds (self, value, unused, key)
-     SHELL_VAR *self;
-     char *value;
-     arrayind_t unused;
-     char *key;
-{
-  intmax_t nval;
-  int expok;
-
-  if (integer_p (self))
-    nval = evalexp (value, 0, &expok);
-  else
-    expok = legal_number (value, &nval);
-  seconds_value_assigned = expok ? nval : 0;
-  gettimeofday (&shellstart, NULL);
-  shell_start_time = shellstart.tv_sec;
-  return (set_int_value (self, nval, integer_p (self) != 0));
-}
-
-static SHELL_VAR *
-get_seconds (var)
-     SHELL_VAR *var;
-{
-  time_t time_since_start;
-  struct timeval tv;
-
-  gettimeofday(&tv, NULL);
-  time_since_start = tv.tv_sec - shell_start_time;
-  return (set_int_value (var, seconds_value_assigned + time_since_start, 1));
-}
-
-static SHELL_VAR *
-init_seconds_var ()
-{
-  SHELL_VAR *v;
-
-  v = find_variable ("SECONDS");
-  if (v)
-    {
-      if (legal_number (value_cell(v), &seconds_value_assigned) == 0)
-	seconds_value_assigned = 0;
-    }
-  INIT_DYNAMIC_VAR ("SECONDS", (v ? value_cell (v) : (char *)NULL), get_seconds, assign_seconds);
-  return v;      
-}
-
-/* Functions for $RANDOM and $SRANDOM */
-
-int last_random_value;
-static int seeded_subshell = 0;
-
-static SHELL_VAR *
-assign_random (self, value, unused, key)
-     SHELL_VAR *self;
-     char *value;
-     arrayind_t unused;
-     char *key;
-{
-  intmax_t seedval;
-  int expok;
-
-  if (integer_p (self))
-    seedval = evalexp (value, 0, &expok);
-  else
-    expok = legal_number (value, &seedval);
-  if (expok == 0)
-    return (self);
-  sbrand (seedval);
-  if (subshell_environment)
-    seeded_subshell = getpid ();
-  return (set_int_value (self, seedval, integer_p (self) != 0));
-}
-
-int
-get_random_number ()
-{
-  int rv, pid;
-
-  /* Reset for command and process substitution. */
-  pid = getpid ();
-  if (subshell_environment && seeded_subshell != pid)
-    {
-      seedrand ();
-      seeded_subshell = pid;
-    }
-
-  do
-    rv = brand ();
-  while (rv == last_random_value);
-
-  return (last_random_value = rv);
-}
-
-static SHELL_VAR *
-get_random (var)
-     SHELL_VAR *var;
-{
-  int rv;
-
-  rv = get_random_number ();
-  return (set_int_value (var, rv, 1));
-}
-
-static SHELL_VAR *
-get_urandom (var)
-     SHELL_VAR *var;
-{
-  u_bits32_t rv;
-
-  rv = get_urandom32 ();
-  return (set_int_value (var, rv, 1));
-}
-
-static SHELL_VAR *
-assign_lineno (var, value, unused, key)
-     SHELL_VAR *var;
-     char *value;
-     arrayind_t unused;
-     char *key;
-{
-  intmax_t new_value;
-
-  if (value == 0 || *value == '\0' || legal_number (value, &new_value) == 0)
-    new_value = 0;
-  line_number = line_number_base = new_value;
-  return (set_int_value (var, line_number, integer_p (var) != 0));
-}
-
-/* Function which returns the current line number. */
-static SHELL_VAR *
-get_lineno (var)
-     SHELL_VAR *var;
-{
-  int ln;
-
-  ln = executing_line_number ();
-  return (set_int_value (var, ln, 0));
-}
-
-static SHELL_VAR *
-assign_subshell (var, value, unused, key)
-     SHELL_VAR *var;
-     char *value;
-     arrayind_t unused;
-     char *key;
-{
-  intmax_t new_value;
-
-  if (value == 0 || *value == '\0' || legal_number (value, &new_value) == 0)
-    new_value = 0;
-  subshell_level = new_value;
-  return var;
-}
-
-static SHELL_VAR *
-get_subshell (var)
-     SHELL_VAR *var;
-{
-  return (set_int_value (var, subshell_level, 0));
-}
-
-static SHELL_VAR *
-get_epochseconds (var)
-     SHELL_VAR *var;
-{
-  intmax_t now;
-
-  now = NOW;
-  return (set_int_value (var, now, 0));
-}
-
-static SHELL_VAR *
-get_epochrealtime (var)
-     SHELL_VAR *var;
-{
-  char buf[32];
-  struct timeval tv;
-
-  gettimeofday (&tv, NULL);
-  snprintf (buf, sizeof (buf), "%u%c%06u", (unsigned)tv.tv_sec,
-					   locale_decpoint (),
-					   (unsigned)tv.tv_usec);
-
-  return (set_string_value (var, buf, 0));
-}
-
-static SHELL_VAR *
-get_bashpid (var)
-     SHELL_VAR *var;
-{
-  int pid;
-
-  pid = getpid ();
-  return (set_int_value (var, pid, 1));
-}
-
-static SHELL_VAR *
-get_bash_argv0 (var)
-     SHELL_VAR *var;
-{
-  return (set_string_value (var, dollar_vars[0], 0));
-}
-
-static char *static_shell_name = 0;
-
-static SHELL_VAR *
-assign_bash_argv0 (var, value, unused, key)
-     SHELL_VAR *var;
-     char *value;
-     arrayind_t unused;
-     char *key;
-{
-  size_t vlen;
-
-  if (value == 0)
-    return var;
-
-  FREE (dollar_vars[0]);
-  dollar_vars[0] = savestring (value);
-
-  /* Need these gyrations because shell_name isn't dynamically allocated */
-  vlen = STRLEN (value);
-  static_shell_name = xrealloc (static_shell_name, vlen + 1);
-  strcpy (static_shell_name, value);
-  
-  shell_name = static_shell_name;
-  return var;
-}
-
-static void
-set_argv0 ()
-{
-  SHELL_VAR *v;
-
-  v = find_variable ("BASH_ARGV0");
-  if (v && imported_p (v))
-    assign_bash_argv0 (v, value_cell (v), 0, 0);
-}
-  
-static SHELL_VAR *
-get_bash_command (var)
-     SHELL_VAR *var;
-{
-  char *p;
-
-  p = the_printed_command_except_trap ? the_printed_command_except_trap : "";
-  return (set_string_value (var, p, 0));
-}
-
-#if defined (HISTORY)
-static SHELL_VAR *
-get_histcmd (var)
-     SHELL_VAR *var;
-{
-  int n;
-
-  /* Do the same adjustment here we do in parse.y:prompt_history_number,
-     assuming that we are in one of two states: decoding this as part of
-     the prompt string, in which case we do not want to assume that the
-     command has been saved to the history and the history number incremented,
-     or the expansion is part of the current command being executed and has
-     already been saved to history and the history number incremented.
-     Right now we use EXECUTING as the determinant. */
-  n = history_number () - executing;
-  return (set_int_value (var, n, 0));
-}
-#endif
-
-#if defined (READLINE)
-/* When this function returns, VAR->value points to malloced memory. */
-static SHELL_VAR *
-get_comp_wordbreaks (var)
-     SHELL_VAR *var;
-{
-  /* If we don't have anything yet, assign a default value. */
-  if (rl_completer_word_break_characters == 0 && bash_readline_initialized == 0)
-    enable_hostname_completion (perform_hostname_completion);
-
-  return (set_string_value (var, rl_completer_word_break_characters, 0));
-}
-
-/* When this function returns, rl_completer_word_break_characters points to
-   malloced memory. */
-static SHELL_VAR *
-assign_comp_wordbreaks (self, value, unused, key)
-     SHELL_VAR *self;
-     char *value;
-     arrayind_t unused;
-     char *key;
-{
-  if (rl_completer_word_break_characters &&
-      rl_completer_word_break_characters != rl_basic_word_break_characters)
-    free ((void *)rl_completer_word_break_characters);
-
-  rl_completer_word_break_characters = savestring (value);
-  return self;
-}
-#endif /* READLINE */
-
-#if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
-static SHELL_VAR *
-assign_dirstack (self, value, ind, key)
-     SHELL_VAR *self;
-     char *value;
-     arrayind_t ind;
-     char *key;
-{
-  set_dirstack_element (ind, 1, value);
-  return self;
-}
-
-static SHELL_VAR *
-get_dirstack (self)
-     SHELL_VAR *self;
-{
-  ARRAY *a;
-  WORD_LIST *l;
-
-  l = get_directory_stack (0);
-  a = array_from_word_list (l);
-  array_dispose (array_cell (self));
-  dispose_words (l);
-  var_setarray (self, a);
-  return self;
-}
-#endif /* PUSHD AND POPD && ARRAY_VARS */
-
-#if defined (ARRAY_VARS)
-/* We don't want to initialize the group set with a call to getgroups()
-   unless we're asked to, but we only want to do it once. */
-static SHELL_VAR *
-get_groupset (self)
-     SHELL_VAR *self;
-{
-  register int i;
-  int ng;
-  ARRAY *a;
-  static char **group_set = (char **)NULL;
-
-  if (group_set == 0)
-    {
-      group_set = get_group_list (&ng);
-      a = array_cell (self);
-      for (i = 0; i < ng; i++)
-	array_insert (a, i, group_set[i]);
-    }
-  return (self);
-}
-
-#  if defined (DEBUGGER)
-static SHELL_VAR *
-get_bashargcv (self)
-     SHELL_VAR *self;
-{
-  static int self_semaphore = 0;
-
-  /* Backwards compatibility: if we refer to BASH_ARGV or BASH_ARGC at the
-     top level without enabling debug mode, and we don't have an instance
-     of the variable set, initialize the arg arrays.
-     This will already have been done if debugging_mode != 0. */
-  if (self_semaphore == 0 && variable_context == 0 && debugging_mode == 0)	/* don't do it for shell functions */
-    {
-      self_semaphore = 1;
-      init_bash_argv ();
-      self_semaphore = 0;
-    }
-  return self;
-}
-#  endif
-
-static SHELL_VAR *
-build_hashcmd (self)
-     SHELL_VAR *self;
-{
-  HASH_TABLE *h;
-  int i;
-  char *k, *v;
-  BUCKET_CONTENTS *item;
-
-  h = assoc_cell (self);
-  if (h)
-    assoc_dispose (h);
-
-  if (hashed_filenames == 0 || HASH_ENTRIES (hashed_filenames) == 0)
-    {
-      var_setvalue (self, (char *)NULL);
-      return self;
-    }
-
-  h = assoc_create (hashed_filenames->nbuckets);
-  for (i = 0; i < hashed_filenames->nbuckets; i++)
-    {
-      for (item = hash_items (i, hashed_filenames); item; item = item->next)
-	{
-	  k = savestring (item->key);
-	  v = pathdata(item)->path;
-	  assoc_insert (h, k, v);
-	}
-    }
-
-  var_setvalue (self, (char *)h);
-  return self;
-}
-
-static SHELL_VAR *
-get_hashcmd (self)
-     SHELL_VAR *self;
-{
-  build_hashcmd (self);
-  return (self);
-}
-
-static SHELL_VAR *
-assign_hashcmd (self, value, ind, key)
-     SHELL_VAR *self;
-     char *value;
-     arrayind_t ind;
-     char *key;
-{
-#if defined (RESTRICTED_SHELL)
-  char *full_path;
-
-  if (restricted)
-    {
-      if (strchr (value, '/'))
-	{
-	  sh_restricted (value);
-	  return (SHELL_VAR *)NULL;
-	}
-      /* If we are changing the hash table in a restricted shell, make sure the
-	 target pathname can be found using a $PATH search. */
-      full_path = find_user_command (value);
-      if (full_path == 0 || *full_path == 0 || executable_file (full_path) == 0)
-	{
-	  sh_notfound (value);
-	  free (full_path);
-	  return ((SHELL_VAR *)NULL);
-	}
-      free (full_path);
-    }
-#endif
-  phash_insert (key, value, 0, 0);
-  return (build_hashcmd (self));
-}
-
-#if defined (ALIAS)
-static SHELL_VAR *
-build_aliasvar (self)
-     SHELL_VAR *self;
-{
-  HASH_TABLE *h;
-  int i;
-  char *k, *v;
-  BUCKET_CONTENTS *item;
-
-  h = assoc_cell (self);
-  if (h)
-    assoc_dispose (h);
-
-  if (aliases == 0 || HASH_ENTRIES (aliases) == 0)
-    {
-      var_setvalue (self, (char *)NULL);
-      return self;
-    }
-
-  h = assoc_create (aliases->nbuckets);
-  for (i = 0; i < aliases->nbuckets; i++)
-    {
-      for (item = hash_items (i, aliases); item; item = item->next)
-	{
-	  k = savestring (item->key);
-	  v = ((alias_t *)(item->data))->value;
-	  assoc_insert (h, k, v);
-	}
-    }
-
-  var_setvalue (self, (char *)h);
-  return self;
-}
-
-static SHELL_VAR *
-get_aliasvar (self)
-     SHELL_VAR *self;
-{
-  build_aliasvar (self);
-  return (self);
-}
-
-static SHELL_VAR *
-assign_aliasvar (self, value, ind, key)
-     SHELL_VAR *self;
-     char *value;
-     arrayind_t ind;
-     char *key;
-{
-  if (legal_alias_name (key, 0) == 0)
-    {
-       report_error (_("`%s': invalid alias name"), key);
-       return (self);
-    }
-  add_alias (key, value);
-  return (build_aliasvar (self));
-}
-#endif /* ALIAS */
-
-#endif /* ARRAY_VARS */
-
-/* If ARRAY_VARS is not defined, this just returns the name of any
-   currently-executing function.  If we have arrays, it's a call stack. */
-static SHELL_VAR *
-get_funcname (self)
-     SHELL_VAR *self;
-{
-#if ! defined (ARRAY_VARS)
-  if (variable_context && this_shell_function)
-    return (set_string_value (self, this_shell_function->name, 0));
-#endif
-  return (self);
-}
-
-void
-make_funcname_visible (on_or_off)
-     int on_or_off;
-{
-  SHELL_VAR *v;
-
-  v = find_variable ("FUNCNAME");
-  if (v == 0 || v->dynamic_value == 0)
-    return;
-
-  if (on_or_off)
-    VUNSETATTR (v, att_invisible);
-  else
-    VSETATTR (v, att_invisible);
-}
-
-static SHELL_VAR *
-init_funcname_var ()
-{
-  SHELL_VAR *v;
-
-  v = find_variable ("FUNCNAME");
-  if (v)
-    return v;
-#if defined (ARRAY_VARS)
-  INIT_DYNAMIC_ARRAY_VAR ("FUNCNAME", get_funcname, null_array_assign);
-#else
-  INIT_DYNAMIC_VAR ("FUNCNAME", (char *)NULL, get_funcname, null_assign);
-#endif
-  VSETATTR (v, att_invisible|att_noassign);
-  return v;
-}
-
-static void
-initialize_dynamic_variables ()
-{
-  SHELL_VAR *v;
-
-  v = init_seconds_var ();
-
-  INIT_DYNAMIC_VAR ("BASH_ARGV0", (char *)NULL, get_bash_argv0, assign_bash_argv0);
-
-  INIT_DYNAMIC_VAR ("BASH_COMMAND", (char *)NULL, get_bash_command, (sh_var_assign_func_t *)NULL);
-  INIT_DYNAMIC_VAR ("BASH_SUBSHELL", (char *)NULL, get_subshell, assign_subshell);
-
-  INIT_DYNAMIC_VAR ("RANDOM", (char *)NULL, get_random, assign_random);
-  VSETATTR (v, att_integer);
-  INIT_DYNAMIC_VAR ("SRANDOM", (char *)NULL, get_urandom, (sh_var_assign_func_t *)NULL);
-  VSETATTR (v, att_integer);  
-  INIT_DYNAMIC_VAR ("LINENO", (char *)NULL, get_lineno, assign_lineno);
-  VSETATTR (v, att_regenerate);
-
-  INIT_DYNAMIC_VAR ("BASHPID", (char *)NULL, get_bashpid, null_assign);
-  VSETATTR (v, att_integer);
-
-  INIT_DYNAMIC_VAR ("EPOCHSECONDS", (char *)NULL, get_epochseconds, null_assign);
-  VSETATTR (v, att_regenerate);
-  INIT_DYNAMIC_VAR ("EPOCHREALTIME", (char *)NULL, get_epochrealtime, null_assign);
-  VSETATTR (v, att_regenerate);
-
-#if defined (HISTORY)
-  INIT_DYNAMIC_VAR ("HISTCMD", (char *)NULL, get_histcmd, (sh_var_assign_func_t *)NULL);
-  VSETATTR (v, att_integer);
-#endif
-
-#if defined (READLINE)
-  INIT_DYNAMIC_VAR ("COMP_WORDBREAKS", (char *)NULL, get_comp_wordbreaks, assign_comp_wordbreaks);
-#endif
-
-#if defined (PUSHD_AND_POPD) && defined (ARRAY_VARS)
-  v = init_dynamic_array_var ("DIRSTACK", get_dirstack, assign_dirstack, 0);
-#endif /* PUSHD_AND_POPD && ARRAY_VARS */
-
-#if defined (ARRAY_VARS)
-  v = init_dynamic_array_var ("GROUPS", get_groupset, null_array_assign, att_noassign);
-
-#  if defined (DEBUGGER)
-  v = init_dynamic_array_var ("BASH_ARGC", get_bashargcv, null_array_assign, att_noassign|att_nounset);
-  v = init_dynamic_array_var ("BASH_ARGV", get_bashargcv, null_array_assign, att_noassign|att_nounset);
-#  endif /* DEBUGGER */
-  v = init_dynamic_array_var ("BASH_SOURCE", get_self, null_array_assign, att_noassign|att_nounset);
-  v = init_dynamic_array_var ("BASH_LINENO", get_self, null_array_assign, att_noassign|att_nounset);
-
-  v = init_dynamic_assoc_var ("BASH_CMDS", get_hashcmd, assign_hashcmd, att_nofree);
-#  if defined (ALIAS)
-  v = init_dynamic_assoc_var ("BASH_ALIASES", get_aliasvar, assign_aliasvar, att_nofree);
-#  endif
-#endif
-
-  v = init_funcname_var ();
-}
-
-/* **************************************************************** */
-/*								    */
-/*		Retrieving variables and values			    */
-/*								    */
-/* **************************************************************** */
-
-#if 0	/* not yet */
-int
-var_isset (var)
-     SHELL_VAR *var;
-{
-  return (var->value != 0);
-}
-
-int
-var_isunset (var)
-     SHELL_VAR *var;
-{
-  return (var->value == 0);
-}
-#endif
-
-/* How to get a pointer to the shell variable or function named NAME.
-   HASHED_VARS is a pointer to the hash table containing the list
-   of interest (either variables or functions). */
-
-static SHELL_VAR *
-hash_lookup (name, hashed_vars)
-     const char *name;
-     HASH_TABLE *hashed_vars;
-{
-  BUCKET_CONTENTS *bucket;
-
-  bucket = hash_search (name, hashed_vars, 0);
-  /* If we find the name in HASHED_VARS, set LAST_TABLE_SEARCHED to that
-     table. */
-  if (bucket)
-    last_table_searched = hashed_vars;
-  return (bucket ? (SHELL_VAR *)bucket->data : (SHELL_VAR *)NULL);
-}
-
-SHELL_VAR *
-var_lookup (name, vcontext)
-     const char *name;
-     VAR_CONTEXT *vcontext;
-{
-  VAR_CONTEXT *vc;
-  SHELL_VAR *v;
-
-  v = (SHELL_VAR *)NULL;
-  for (vc = vcontext; vc; vc = vc->down)
-    if (v = hash_lookup (name, vc->table))
-      break;
-
-  return v;
-}
-
-/* Look up the variable entry named NAME.  If SEARCH_TEMPENV is non-zero,
-   then also search the temporarily built list of exported variables.
-   The lookup order is:
-	temporary_env
-	shell_variables list
-*/
-
-SHELL_VAR *
-find_variable_internal (name, flags)
-     const char *name;
-     int flags;
-{
-  SHELL_VAR *var;
-  int search_tempenv, force_tempenv;
-  VAR_CONTEXT *vc;
-
-  var = (SHELL_VAR *)NULL;
-
-  force_tempenv = (flags & FV_FORCETEMPENV);
-
-  /* If explicitly requested, first look in the temporary environment for
-     the variable.  This allows constructs such as "foo=x eval 'echo $foo'"
-     to get the `exported' value of $foo.  This happens if we are executing
-     a function or builtin, or if we are looking up a variable in a
-     "subshell environment". */
-  search_tempenv = force_tempenv || (expanding_redir == 0 && subshell_environment);
-
-  if (search_tempenv && temporary_env)		
-    var = hash_lookup (name, temporary_env);
-
-  if (var == 0)
-    {
-      if ((flags & FV_SKIPINVISIBLE) == 0)
-	var = var_lookup (name, shell_variables);
-      else
-	{
-	  /* essentially var_lookup expanded inline so we can check for
-	     att_invisible */
-	  for (vc = shell_variables; vc; vc = vc->down)
-	    {
-	      var = hash_lookup (name, vc->table);
-	      if (var && invisible_p (var))
-		var = 0;
-	      if (var)
-		break;
-	    }
-	}
-    }
-
-  if (var == 0)
-    return ((SHELL_VAR *)NULL);
-
-  return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
-}
-
-/* Look up and resolve the chain of nameref variables starting at V all the
-   way to NULL or non-nameref. */
-SHELL_VAR *
-find_variable_nameref (v)
-     SHELL_VAR *v;
-{
-  int level, flags;
-  char *newname;
-  SHELL_VAR *orig, *oldv;
-
-  level = 0;
-  orig = v;
-  while (v && nameref_p (v))
-    {
-      level++;
-      if (level > NAMEREF_MAX)
-	return ((SHELL_VAR *)0);	/* error message here? */
-      newname = nameref_cell (v);
-      if (newname == 0 || *newname == '\0')
-	return ((SHELL_VAR *)0);
-      oldv = v;
-      flags = 0;
-      if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
-	flags |= FV_FORCETEMPENV;
-      /* We don't handle array subscripts here. */
-      v = find_variable_internal (newname, flags);
-      if (v == orig || v == oldv)
-	{
-	  internal_warning (_("%s: circular name reference"), orig->name);
-#if 1
-	  /* XXX - provisional change - circular refs go to
-	     global scope for resolution, without namerefs. */
-	  if (variable_context && v->context)
-	    return (find_global_variable_noref (v->name));
-	  else
-#endif
-	  return ((SHELL_VAR *)0);
-	}
-    }
-  return v;
-}
-
-/* Resolve the chain of nameref variables for NAME.  XXX - could change later */
-SHELL_VAR *
-find_variable_last_nameref (name, vflags)
-     const char *name;
-     int vflags;
-{
-  SHELL_VAR *v, *nv;
-  char *newname;
-  int level, flags;
-
-  nv = v = find_variable_noref (name);
-  level = 0;
-  while (v && nameref_p (v))
-    {
-      level++;
-      if (level > NAMEREF_MAX)
-        return ((SHELL_VAR *)0);	/* error message here? */
-      newname = nameref_cell (v);
-      if (newname == 0 || *newname == '\0')
-	return ((vflags && invisible_p (v)) ? v : (SHELL_VAR *)0);
-      nv = v;
-      flags = 0;
-      if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
-	flags |= FV_FORCETEMPENV;
-      /* We don't accommodate array subscripts here. */
-      v = find_variable_internal (newname, flags);
-    }
-  return nv;
-}
-
-/* Resolve the chain of nameref variables for NAME.  XXX - could change later */
-SHELL_VAR *
-find_global_variable_last_nameref (name, vflags)
-     const char *name;
-     int vflags;
-{
-  SHELL_VAR *v, *nv;
-  char *newname;
-  int level;
-
-  nv = v = find_global_variable_noref (name);
-  level = 0;
-  while (v && nameref_p (v))
-    {
-      level++;
-      if (level > NAMEREF_MAX)
-        return ((SHELL_VAR *)0);	/* error message here? */
-      newname = nameref_cell (v);
-      if (newname == 0 || *newname == '\0')
-	return ((vflags && invisible_p (v)) ? v : (SHELL_VAR *)0);
-      nv = v;
-      /* We don't accommodate array subscripts here. */
-      v = find_global_variable_noref (newname);
-    }
-  return nv;
-}
-
-static SHELL_VAR *
-find_nameref_at_context (v, vc)
-     SHELL_VAR *v;
-     VAR_CONTEXT *vc;
-{
-  SHELL_VAR *nv, *nv2;
-  char *newname;
-  int level;
-
-  nv = v;
-  level = 1;
-  while (nv && nameref_p (nv))
-    {
-      level++;
-      if (level > NAMEREF_MAX)
-        return (&nameref_maxloop_value);
-      newname = nameref_cell (nv);
-      if (newname == 0 || *newname == '\0')
-        return ((SHELL_VAR *)NULL);      
-      nv2 = hash_lookup (newname, vc->table);
-      if (nv2 == 0)
-        break;
-      nv = nv2;
-    }
-  return nv;
-}
-
-/* Do nameref resolution from the VC, which is the local context for some
-   function or builtin, `up' the chain to the global variables context.  If
-   NVCP is not NULL, return the variable context where we finally ended the
-   nameref resolution (so the bind_variable_internal can use the correct
-   variable context and hash table). */
-static SHELL_VAR *
-find_variable_nameref_context (v, vc, nvcp)
-     SHELL_VAR *v;
-     VAR_CONTEXT *vc;
-     VAR_CONTEXT **nvcp;
-{
-  SHELL_VAR *nv, *nv2;
-  VAR_CONTEXT *nvc;
-
-  /* Look starting at the current context all the way `up' */
-  for (nv = v, nvc = vc; nvc; nvc = nvc->down)
-    {
-      nv2 = find_nameref_at_context (nv, nvc);
-      if (nv2 == &nameref_maxloop_value)
-	return (nv2);			/* XXX */
-      if (nv2 == 0)
-        continue;
-      nv = nv2;
-      if (*nvcp)
-        *nvcp = nvc;
-      if (nameref_p (nv) == 0)
-        break;
-    }
-  return (nameref_p (nv) ? (SHELL_VAR *)NULL : nv);
-}
-
-/* Do nameref resolution from the VC, which is the local context for some
-   function or builtin, `up' the chain to the global variables context.  If
-   NVCP is not NULL, return the variable context where we finally ended the
-   nameref resolution (so the bind_variable_internal can use the correct
-   variable context and hash table). */
-static SHELL_VAR *
-find_variable_last_nameref_context (v, vc, nvcp)
-     SHELL_VAR *v;
-     VAR_CONTEXT *vc;
-     VAR_CONTEXT **nvcp;
-{
-  SHELL_VAR *nv, *nv2;
-  VAR_CONTEXT *nvc;
-
-  /* Look starting at the current context all the way `up' */
-  for (nv = v, nvc = vc; nvc; nvc = nvc->down)
-    {
-      nv2 = find_nameref_at_context (nv, nvc);
-      if (nv2 == &nameref_maxloop_value)
-	return (nv2);			/* XXX */
-      if (nv2 == 0)
-	continue;
-      nv = nv2;
-      if (*nvcp)
-        *nvcp = nvc;
-    }
-  return (nameref_p (nv) ? nv : (SHELL_VAR *)NULL);
-}
-
-SHELL_VAR *
-find_variable_nameref_for_create (name, flags)
-     const char *name;
-     int flags;
-{
-  SHELL_VAR *var;
-
-  /* See if we have a nameref pointing to a variable that hasn't been
-     created yet. */
-  var = find_variable_last_nameref (name, 1);
-  if ((flags&1) && var && nameref_p (var) && invisible_p (var))
-    {
-      internal_warning (_("%s: removing nameref attribute"), name);
-      VUNSETATTR (var, att_nameref);
-    }
-  if (var && nameref_p (var))
-    {
-      if (legal_identifier (nameref_cell (var)) == 0)
-	{
-	  sh_invalidid (nameref_cell (var) ? nameref_cell (var) : "");
-	  return ((SHELL_VAR *)INVALID_NAMEREF_VALUE);
-	}
-    }
-  return (var);
-}
-
-SHELL_VAR *
-find_variable_nameref_for_assignment (name, flags)
-     const char *name;
-     int flags;
-{
-  SHELL_VAR *var;
-
-  /* See if we have a nameref pointing to a variable that hasn't been
-     created yet. */
-  var = find_variable_last_nameref (name, 1);
-  if (var && nameref_p (var) && invisible_p (var))	/* XXX - flags */
-    {
-      internal_warning (_("%s: removing nameref attribute"), name);
-      VUNSETATTR (var, att_nameref);
-    }
-  if (var && nameref_p (var))
-    {
-      if (valid_nameref_value (nameref_cell (var), 1) == 0)
-	{
-	  sh_invalidid (nameref_cell (var) ? nameref_cell (var) : "");
-	  return ((SHELL_VAR *)INVALID_NAMEREF_VALUE);
-	}
-    }
-  return (var);
-}
-
-/* If find_variable (name) returns NULL, check that it's not a nameref
-   referencing a variable that doesn't exist. If it is, return the new
-   name. If not, return the original name. Kind of like the previous
-   function, but dealing strictly with names. This takes assignment flags
-   so it can deal with the various assignment modes used by `declare'. */
-char *
-nameref_transform_name (name, flags)
-     char *name;
-     int flags;
-{
-  SHELL_VAR *v;
-  char *newname;
-
-  v = 0;
-  if (flags & ASS_MKLOCAL)
-    {
-      v = find_variable_last_nameref (name, 1);
-      /* If we're making local variables, only follow namerefs that point to
-	 non-existent variables at the same variable context. */
-      if (v && v->context != variable_context)
-	v = 0;
-    }
-  else if (flags & ASS_MKGLOBAL)
-    v = (flags & ASS_CHKLOCAL) ? find_variable_last_nameref (name, 1)
-			       : find_global_variable_last_nameref (name, 1);
-  if (v && nameref_p (v) && valid_nameref_value (nameref_cell (v), 1))
-    return nameref_cell (v);
-  return name;
-}
-
-/* Find a variable, forcing a search of the temporary environment first */
-SHELL_VAR *
-find_variable_tempenv (name)
-     const char *name;
-{
-  SHELL_VAR *var;
-
-  var = find_variable_internal (name, FV_FORCETEMPENV);
-  if (var && nameref_p (var))
-    var = find_variable_nameref (var);
-  return (var);
-}
-
-/* Find a variable, not forcing a search of the temporary environment first */
-SHELL_VAR *
-find_variable_notempenv (name)
-     const char *name;
-{
-  SHELL_VAR *var;
-
-  var = find_variable_internal (name, 0);
-  if (var && nameref_p (var))
-    var = find_variable_nameref (var);
-  return (var);
-}
-
-SHELL_VAR *
-find_global_variable (name)
-     const char *name;
-{
-  SHELL_VAR *var;
-
-  var = var_lookup (name, global_variables);
-  if (var && nameref_p (var))
-    var = find_variable_nameref (var);	/* XXX - find_global_variable_noref? */
-
-  if (var == 0)
-    return ((SHELL_VAR *)NULL);
-
-  return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
-}
-
-SHELL_VAR *
-find_global_variable_noref (name)
-     const char *name;
-{
-  SHELL_VAR *var;
-
-  var = var_lookup (name, global_variables);
-
-  if (var == 0)
-    return ((SHELL_VAR *)NULL);
-
-  return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
-}
-
-SHELL_VAR *
-find_shell_variable (name)
-     const char *name;
-{
-  SHELL_VAR *var;
-
-  var = var_lookup (name, shell_variables);
-  if (var && nameref_p (var))
-    var = find_variable_nameref (var);
-
-  if (var == 0)
-    return ((SHELL_VAR *)NULL);
-
-  return (var->dynamic_value ? (*(var->dynamic_value)) (var) : var);
-}
-
-/* Look up the variable entry named NAME.  Returns the entry or NULL. */
-SHELL_VAR *
-find_variable (name)
-     const char *name;
-{
-  SHELL_VAR *v;
-  int flags;
-
-  last_table_searched = 0;
-  flags = 0;
-  if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
-    flags |= FV_FORCETEMPENV;
-  v = find_variable_internal (name, flags);
-  if (v && nameref_p (v))
-    v = find_variable_nameref (v);
-  return v;
-}
-
-/* Find the first instance of NAME in the variable context chain; return first
-   one found without att_invisible set; return 0 if no non-invisible instances
-   found. */
-SHELL_VAR *
-find_variable_no_invisible (name)
-     const char *name;
-{
-  SHELL_VAR *v;
-  int flags;
-
-  last_table_searched = 0;
-  flags = FV_SKIPINVISIBLE;
-  if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
-    flags |= FV_FORCETEMPENV;
-  v = find_variable_internal (name, flags);
-  if (v && nameref_p (v))
-    v = find_variable_nameref (v);
-  return v;
-}
-
-/* Find the first instance of NAME in the variable context chain; return first
-   one found even if att_invisible set. */
-SHELL_VAR *
-find_variable_for_assignment (name)
-     const char *name;
-{
-  SHELL_VAR *v;
-  int flags;
-
-  last_table_searched = 0;
-  flags = 0;
-  if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
-    flags |= FV_FORCETEMPENV;
-  v = find_variable_internal (name, flags);
-  if (v && nameref_p (v))
-    v = find_variable_nameref (v);
-  return v;
-}
-
-SHELL_VAR *
-find_variable_noref (name)
-     const char *name;
-{
-  SHELL_VAR *v;
-  int flags;
-
-  flags = 0;
-  if (expanding_redir == 0 && (assigning_in_environment || executing_builtin))
-    flags |= FV_FORCETEMPENV;
-  v = find_variable_internal (name, flags);
-  return v;
-}
-
-/* Look up the function entry whose name matches STRING.
-   Returns the entry or NULL. */
-SHELL_VAR *
-find_function (name)
-     const char *name;
-{
-  return (hash_lookup (name, shell_functions));
-}
-
-/* Find the function definition for the shell function named NAME.  Returns
-   the entry or NULL. */
-FUNCTION_DEF *
-find_function_def (name)
-     const char *name;
-{
-#if defined (DEBUGGER)
-  return ((FUNCTION_DEF *)hash_lookup (name, shell_function_defs));
-#else
-  return ((FUNCTION_DEF *)0);
-#endif
-}
-
-/* Return the value of VAR.  VAR is assumed to have been the result of a
-   lookup without any subscript, if arrays are compiled into the shell. */
-char *
-get_variable_value (var)
-     SHELL_VAR *var;
-{
-  if (var == 0)
-    return ((char *)NULL);
-#if defined (ARRAY_VARS)
-  else if (array_p (var))
-    return (array_reference (array_cell (var), 0));
-  else if (assoc_p (var))
-    return (assoc_reference (assoc_cell (var), "0"));
-#endif
-  else
-    return (value_cell (var));
-}
-
-/* Return the string value of a variable.  Return NULL if the variable
-   doesn't exist.  Don't cons a new string.  This is a potential memory
-   leak if the variable is found in the temporary environment, but doesn't
-   leak in practice.  Since functions and variables have separate name
-   spaces, returns NULL if var_name is a shell function only. */
-char *
-get_string_value (var_name)
-     const char *var_name;
-{
-  SHELL_VAR *var;
-
-  var = find_variable (var_name);
-  return ((var) ? get_variable_value (var) : (char *)NULL);
-}
-
-/* This is present for use by the tilde and readline libraries. */
-char *
-sh_get_env_value (v)
-     const char *v;
-{
-  return get_string_value (v);
-}
-
-/* **************************************************************** */
-/*								    */
-/*		  Creating and setting variables		    */
-/*								    */
-/* **************************************************************** */
-
-static int
-var_sametype (v1, v2)
-     SHELL_VAR *v1;
-     SHELL_VAR *v2;
-{
-  if (v1 == 0 || v2 == 0)
-    return 0;
-#if defined (ARRAY_VARS)
-  else if (assoc_p (v1) && assoc_p (v2))
-    return 1;
-  else if (array_p (v1) && array_p (v2))
-    return 1;
-  else if (array_p (v1) || array_p (v2))
-    return 0;
-  else if (assoc_p (v1) || assoc_p (v2))
-    return 0;
-#endif
-  else
-    return 1;
-}
-
-int
-validate_inherited_value (var, type)
-     SHELL_VAR *var;
-     int type;
-{
-#if defined (ARRAY_VARS)
-  if (type == att_array && assoc_p (var))
-    return 0;
-  else if (type == att_assoc && array_p (var))
-    return 0;
-  else
-#endif
-  return 1;	/* should we run convert_var_to_array here or let the caller? */
-}
-
-/* Set NAME to VALUE if NAME has no value. */
-SHELL_VAR *
-set_if_not (name, value)
-     char *name, *value;
-{
-  SHELL_VAR *v;
-
-  if (shell_variables == 0)
-    create_variable_tables ();
-
-  v = find_variable (name);
-  if (v == 0)
-    v = bind_variable_internal (name, value, global_variables->table, HASH_NOSRCH, 0);
-  return (v);
-}
-
-/* Create a local variable referenced by NAME. */
-SHELL_VAR *
-make_local_variable (name, flags)
-     const char *name;
-     int flags;
-{
-  SHELL_VAR *new_var, *old_var, *old_ref;
-  VAR_CONTEXT *vc;
-  int was_tmpvar;
-  char *old_value;
-
-  /* We don't want to follow the nameref chain when making local variables; we
-     just want to create them. */
-  old_ref = find_variable_noref (name);
-  if (old_ref && nameref_p (old_ref) == 0)
-    old_ref = 0;
-  /* local foo; local foo;  is a no-op. */
-  old_var = find_variable (name);
-  if (old_ref == 0 && old_var && local_p (old_var) && old_var->context == variable_context)
-    return (old_var);
-
-  /* local -n foo; local -n foo;  is a no-op. */
-  if (old_ref && local_p (old_ref) && old_ref->context == variable_context)
-    return (old_ref);
-
-  /* From here on, we want to use the refvar, not the variable it references */
-  if (old_ref)
-    old_var = old_ref;
-
-  was_tmpvar = old_var && tempvar_p (old_var);
-  /* If we're making a local variable in a shell function, the temporary env
-     has already been merged into the function's variable context stack.  We
-     can assume that a temporary var in the same context appears in the same
-     VAR_CONTEXT and can safely be returned without creating a new variable
-     (which results in duplicate names in the same VAR_CONTEXT->table */
-  /* We can't just test tmpvar_p because variables in the temporary env given
-     to a shell function appear in the function's local variable VAR_CONTEXT
-     but retain their tempvar attribute.  We want temporary variables that are
-     found in temporary_env, hence the test for last_table_searched, which is
-     set in hash_lookup and only (so far) checked here. */
-  if (was_tmpvar && old_var->context == variable_context && last_table_searched != temporary_env)
-    {
-      VUNSETATTR (old_var, att_invisible);	/* XXX */
-      /* We still want to flag this variable as local, though, and set things
-         up so that it gets treated as a local variable. */
-      new_var = old_var;
-      /* Since we found the variable in a temporary environment, this will
-	 succeed. */
-      for (vc = shell_variables; vc; vc = vc->down)
-	if (vc_isfuncenv (vc) && vc->scope == variable_context)
-	  break;
-      goto set_local_var_flags;
-
-      return (old_var);
-    }
-
-  /* If we want to change to "inherit the old variable's value" semantics,
-     here is where to save the old value. */
-  old_value = was_tmpvar ? value_cell (old_var) : (char *)NULL;
-
-  for (vc = shell_variables; vc; vc = vc->down)
-    if (vc_isfuncenv (vc) && vc->scope == variable_context)
-      break;
-
-  if (vc == 0)
-    {
-      internal_error (_("make_local_variable: no function context at current scope"));
-      return ((SHELL_VAR *)NULL);
-    }
-  else if (vc->table == 0)
-    vc->table = hash_create (TEMPENV_HASH_BUCKETS);
-
-  /* Since this is called only from the local/declare/typeset code, we can
-     call builtin_error here without worry (of course, it will also work
-     for anything that sets this_command_name).  Variables with the `noassign'
-     attribute may not be made local.  The test against old_var's context
-     level is to disallow local copies of readonly global variables (since I
-     believe that this could be a security hole).  Readonly copies of calling
-     function local variables are OK. */
-  if (old_var && (noassign_p (old_var) ||
-		 (readonly_p (old_var) && old_var->context == 0)))
-    {
-      if (readonly_p (old_var))
-	sh_readonly (name);
-      else if (noassign_p (old_var))
-	builtin_error (_("%s: variable may not be assigned value"), name);
-#if 0
-      /* Let noassign variables through with a warning */
-      if (readonly_p (old_var))
-#endif
-	return ((SHELL_VAR *)NULL);
-    }
-
-  if (old_var == 0)
-    new_var = make_new_variable (name, vc->table);
-  else
-    {
-      new_var = make_new_variable (name, vc->table);
-
-      /* If we found this variable in one of the temporary environments,
-	 inherit its value.  Watch to see if this causes problems with
-	 things like `x=4 local x'. XXX - see above for temporary env
-	 variables with the same context level as variable_context */
-      /* XXX - we should only do this if the variable is not an array. */
-      /* If we want to change the local variable semantics to "inherit
-	 the old variable's value" here is where to set it.  And we would
-	 need to use copy_variable (currently unused) to do it for all
-	 possible variable values. */
-      if (was_tmpvar)
-	var_setvalue (new_var, savestring (old_value));
-      else if (localvar_inherit || (flags & MKLOC_INHERIT))
-	{
-	  /* This may not make sense for nameref variables that are shadowing
-	     variables with the same name, but we don't know that yet. */
-#if defined (ARRAY_VARS)
-	  if (assoc_p (old_var))
-	    var_setassoc (new_var, assoc_copy (assoc_cell (old_var)));
-	  else if (array_p (old_var))
-	    var_setarray (new_var, array_copy (array_cell (old_var)));
-	  else if (value_cell (old_var))
-#else
-	  if (value_cell (old_var))
-#endif
-	    var_setvalue (new_var, savestring (value_cell (old_var)));
-	  else
-	    var_setvalue (new_var, (char *)NULL);
-	}
-
-      if (localvar_inherit || (flags & MKLOC_INHERIT))
-	{
-	  /* It doesn't make sense to inherit the nameref attribute */
-	  new_var->attributes = old_var->attributes & ~att_nameref;
-	  new_var->dynamic_value = old_var->dynamic_value;
-	  new_var->assign_func = old_var->assign_func;
-	}
-      else
-	/* We inherit the export attribute, but no others. */
-	new_var->attributes = exported_p (old_var) ? att_exported : 0;
-    }
-
-set_local_var_flags:
-  vc->flags |= VC_HASLOCAL;
-
-  new_var->context = variable_context;
-  VSETATTR (new_var, att_local);
-
-  if (ifsname (name))
-    setifs (new_var);
-
-  /* value_cell will be 0 if localvar_inherit == 0 or there was no old variable
-     with the same name or the old variable was invisible */
-  if (was_tmpvar == 0 && value_cell (new_var) == 0)
-    VSETATTR (new_var, att_invisible);	/* XXX */
-  return (new_var);
-}
-
-/* Create a new shell variable with name NAME. */
-static SHELL_VAR *
-new_shell_variable (name)
-     const char *name;
-{
-  SHELL_VAR *entry;
-
-  entry = (SHELL_VAR *)xmalloc (sizeof (SHELL_VAR));
-
-  entry->name = savestring (name);
-  var_setvalue (entry, (char *)NULL);
-  CLEAR_EXPORTSTR (entry);
-
-  entry->dynamic_value = (sh_var_value_func_t *)NULL;
-  entry->assign_func = (sh_var_assign_func_t *)NULL;
-
-  entry->attributes = 0;
-
-  /* Always assume variables are to be made at toplevel!
-     make_local_variable has the responsibility of changing the
-     variable context. */
-  entry->context = 0;
-
-  return (entry);
-}
-
-/* Create a new shell variable with name NAME and add it to the hash table
-   TABLE. */
-static SHELL_VAR *
-make_new_variable (name, table)
-     const char *name;
-     HASH_TABLE *table;
-{
-  SHELL_VAR *entry;
-  BUCKET_CONTENTS *elt;
-
-  entry = new_shell_variable (name);
-
-  /* Make sure we have a shell_variables hash table to add to. */
-  if (shell_variables == 0)
-    create_variable_tables ();
-
-  elt = hash_insert (savestring (name), table, HASH_NOSRCH);
-  elt->data = (PTR_T)entry;
-
-  return entry;
-}
-
-#if defined (ARRAY_VARS)
-SHELL_VAR *
-make_new_array_variable (name)
-     char *name;
-{
-  SHELL_VAR *entry;
-  ARRAY *array;
-
-  entry = make_new_variable (name, global_variables->table);
-  array = array_create ();
-
-  var_setarray (entry, array);
-  VSETATTR (entry, att_array);
-  return entry;
-}
-
-SHELL_VAR *
-make_local_array_variable (name, flags)
-     char *name;
-     int flags;
-{
-  SHELL_VAR *var;
-  ARRAY *array;
-  int assoc_ok;
-
-  assoc_ok = flags & MKLOC_ASSOCOK;
-
-  var = make_local_variable (name, flags & MKLOC_INHERIT);	/* XXX for now */
-  /* If ASSOC_OK is non-zero, assume that we are ok with letting an assoc
-     variable return to the caller without converting it. The caller will
-     either flag an error or do the conversion itself. */
-  if (var == 0 || array_p (var) || (assoc_ok && assoc_p (var)))
-    return var;
-
-  /* Validate any value we inherited from a variable instance at a previous
-     scope and discard anything that's invalid. */
-  if (localvar_inherit && assoc_p (var))
-    {
-      internal_warning (_("%s: cannot inherit value from incompatible type"), name);
-      VUNSETATTR (var, att_assoc);
-      dispose_variable_value (var);
-      array = array_create ();
-      var_setarray (var, array);
-    }
-  else if (localvar_inherit)
-    var = convert_var_to_array (var);		/* XXX */
-  else
-    {
-      dispose_variable_value (var);
-      array = array_create ();
-      var_setarray (var, array);
-    }
-
-  VSETATTR (var, att_array);
-  return var;
-}
-
-SHELL_VAR *
-make_new_assoc_variable (name)
-     char *name;
-{
-  SHELL_VAR *entry;
-  HASH_TABLE *hash;
-
-  entry = make_new_variable (name, global_variables->table);
-  hash = assoc_create (ASSOC_HASH_BUCKETS);
-
-  var_setassoc (entry, hash);
-  VSETATTR (entry, att_assoc);
-  return entry;
-}
-
-SHELL_VAR *
-make_local_assoc_variable (name, flags)
-     char *name;
-     int flags;
-{
-  SHELL_VAR *var;
-  HASH_TABLE *hash;
-  int array_ok;
-
-  array_ok = flags & MKLOC_ARRAYOK;
-
-  var = make_local_variable (name, flags & MKLOC_INHERIT);	/* XXX for now */
-  /* If ARRAY_OK is non-zero, assume that we are ok with letting an array
-     variable return to the caller without converting it. The caller will
-     either flag an error or do the conversion itself. */
-  if (var == 0 || assoc_p (var) || (array_ok && array_p (var)))
-    return var;
-
-  /* Validate any value we inherited from a variable instance at a previous
-     scope and discard anything that's invalid. */
-  if (localvar_inherit && array_p (var))
-    {
-      internal_warning (_("%s: cannot inherit value from incompatible type"), name);
-      VUNSETATTR (var, att_array);
-      dispose_variable_value (var);
-      hash = assoc_create (ASSOC_HASH_BUCKETS);
-      var_setassoc (var, hash);
-    }
-  else if (localvar_inherit)
-    var = convert_var_to_assoc (var);		/* XXX */
-  else
-    {
-      dispose_variable_value (var);
-      hash = assoc_create (ASSOC_HASH_BUCKETS);
-      var_setassoc (var, hash);
-    }
-
-  VSETATTR (var, att_assoc);
-  return var;
-}
-#endif
-
-char *
-make_variable_value (var, value, flags)
-     SHELL_VAR *var;
-     char *value;
-     int flags;
-{
-  char *retval, *oval;
-  intmax_t lval, rval;
-  int expok, olen, op;
-
-  /* If this variable has had its type set to integer (via `declare -i'),
-     then do expression evaluation on it and store the result.  The
-     functions in expr.c (evalexp()) and bind_int_variable() are responsible
-     for turning off the integer flag if they don't want further
-     evaluation done.  Callers that find it inconvenient to do this can set
-     the ASS_NOEVAL flag.  For the special case of arithmetic expression
-     evaluation, the caller can set ASS_NOLONGJMP to avoid jumping out to
-     top_level. */
-  if ((flags & ASS_NOEVAL) == 0 && integer_p (var))
-    {
-      if (flags & ASS_APPEND)
-	{
-	  oval = value_cell (var);
-	  lval = evalexp (oval, 0, &expok);	/* ksh93 seems to do this */
-	  if (expok == 0)
-	    {
-	      if (flags & ASS_NOLONGJMP)
-		goto make_value;
-	      else
-		{
-		  top_level_cleanup ();
-		  jump_to_top_level (DISCARD);
-		}
-	    }
-	}
-      rval = evalexp (value, 0, &expok);
-      if (expok == 0)
-	{
-	  if (flags & ASS_NOLONGJMP)
-	    goto make_value;
-	  else
-	    {
-	      top_level_cleanup ();
-	      jump_to_top_level (DISCARD);
-	    }
-	}
-      /* This can be fooled if the variable's value changes while evaluating
-	 `rval'.  We can change it if we move the evaluation of lval to here. */
-      if (flags & ASS_APPEND)
-	rval += lval;
-      retval = itos (rval);
-    }
-#if defined (CASEMOD_ATTRS)
-  else if ((flags & ASS_NOEVAL) == 0 && (capcase_p (var) || uppercase_p (var) || lowercase_p (var)))
-    {
-      if (flags & ASS_APPEND)
-	{
-	  oval = get_variable_value (var);
-	  if (oval == 0)	/* paranoia */
-	    oval = "";
-	  olen = STRLEN (oval);
-	  retval = (char *)xmalloc (olen + (value ? STRLEN (value) : 0) + 1);
-	  strcpy (retval, oval);
-	  if (value)
-	    strcpy (retval+olen, value);
-	}
-      else if (*value)
-	retval = savestring (value);
-      else
-	{
-	  retval = (char *)xmalloc (1);
-	  retval[0] = '\0';
-	}
-      op = capcase_p (var) ? CASE_CAPITALIZE
-			 : (uppercase_p (var) ? CASE_UPPER : CASE_LOWER);
-      oval = sh_modcase (retval, (char *)0, op);
-      free (retval);
-      retval = oval;
-    }
-#endif /* CASEMOD_ATTRS */
-  else if (value)
-    {
-make_value:
-      if (flags & ASS_APPEND)
-	{
-	  oval = get_variable_value (var);
-	  if (oval == 0)	/* paranoia */
-	    oval = "";
-	  olen = STRLEN (oval);
-	  retval = (char *)xmalloc (olen + (value ? STRLEN (value) : 0) + 1);
-	  strcpy (retval, oval);
-	  if (value)
-	    strcpy (retval+olen, value);
-	}
-      else if (*value)
-	retval = savestring (value);
-      else
-	{
-	  retval = (char *)xmalloc (1);
-	  retval[0] = '\0';
-	}
-    }
-  else
-    retval = (char *)NULL;
-
-  return retval;
-}
-
-/* If we can optimize appending to string variables, say so */
-static int
-can_optimize_assignment (entry, value, aflags)
-     SHELL_VAR *entry;
-     char *value;
-     int aflags;
-{
-  if ((aflags & ASS_APPEND) == 0)
-    return 0;
-#if defined (ARRAY_VARS)
-  if (array_p (entry) || assoc_p (entry))
-    return 0;
-#endif
-  if (integer_p (entry) || uppercase_p (entry) || lowercase_p (entry) || capcase_p (entry))
-    return 0;
-  if (readonly_p (entry) || noassign_p (entry))
-    return 0;
-  return 1;
-}
-
-/* right now we optimize appends to string variables */
-static SHELL_VAR *
-optimized_assignment (entry, value, aflags)
-     SHELL_VAR *entry;
-     char *value;
-     int aflags;
-{
-  size_t len, vlen;
-  char *v, *new;
-
-  v = value_cell (entry);
-  len = STRLEN (v);
-  vlen = STRLEN (value);
-
-  new = (char *)xrealloc (v, len + vlen + 8);	/* for now */
-  if (vlen == 1)
-    {
-      new[len] = *value;
-      new[len+1] = '\0';
-    }
-  else
-    strcpy (new + len, value);
-  var_setvalue (entry, new);
-  return entry;
-}
-
-/* Bind a variable NAME to VALUE in the HASH_TABLE TABLE, which may be the
-   temporary environment (but usually is not).  HFLAGS controls how NAME
-   is looked up in TABLE; AFLAGS controls how VALUE is assigned */
-static SHELL_VAR *
-bind_variable_internal (name, value, table, hflags, aflags)
-     const char *name;
-     char *value;
-     HASH_TABLE *table;
-     int hflags, aflags;
-{
-  char *newval, *tname;
-  SHELL_VAR *entry, *tentry;
-
-  entry = (hflags & HASH_NOSRCH) ? (SHELL_VAR *)NULL : hash_lookup (name, table);
-  /* Follow the nameref chain here if this is the global variables table */
-  if (entry && nameref_p (entry) && (invisible_p (entry) == 0) && table == global_variables->table)
-    {
-      entry = find_global_variable (entry->name);
-      /* Let's see if we have a nameref referencing a variable that hasn't yet
-	 been created. */
-      if (entry == 0)
-	entry = find_variable_last_nameref (name, 0);	/* XXX */
-      if (entry == 0)					/* just in case */
-        return (entry);
-    }
-
-  /* The first clause handles `declare -n ref; ref=x;' or `declare -n ref;
-     declare -n ref' */
-  if (entry && invisible_p (entry) && nameref_p (entry))
-    {
-      if ((aflags & ASS_FORCE) == 0 && value && valid_nameref_value (value, 0) == 0)
-	{
-	  sh_invalidid (value);
-	  return ((SHELL_VAR *)NULL);
-	}
-      goto assign_value;
-    }
-  else if (entry && nameref_p (entry))
-    {
-      newval = nameref_cell (entry);	/* XXX - newval can't be NULL here */
-      if (valid_nameref_value (newval, 0) == 0)
-	{
-	  sh_invalidid (newval);
-	  return ((SHELL_VAR *)NULL);
-	}
-#if defined (ARRAY_VARS)
-      /* declare -n foo=x[2] ; foo=bar */
-      if (valid_array_reference (newval, 0))
-	{
-	  tname = array_variable_name (newval, 0, (char **)0, (int *)0);
-	  if (tname && (tentry = find_variable_noref (tname)) && nameref_p (tentry))
-	    {
-	      /* nameref variables can't be arrays */
-	      internal_warning (_("%s: removing nameref attribute"), name_cell (tentry));
-	      FREE (value_cell (tentry));		/* XXX - bash-4.3 compat */
-	      var_setvalue (tentry, (char *)NULL);
-	      VUNSETATTR (tentry, att_nameref);
-	    }
-	  free (tname);
-
-	  /* entry == nameref variable; tentry == array variable;
-	     newval == x[2]; value = bar
-	     We don't need to call make_variable_value here, since
-	     assign_array_element will eventually do it itself based on
-	     newval and aflags. */
-
-	  entry = assign_array_element (newval, value, aflags|ASS_NAMEREF, (array_eltstate_t *)0);
-	  if (entry == 0)
-	    return entry;
-	}
-      else
-#endif
-	{
-	  entry = make_new_variable (newval, table);
-	  var_setvalue (entry, make_variable_value (entry, value, aflags));
-	}
-    }
-  else if (entry == 0)
-    {
-      entry = make_new_variable (name, table);
-      var_setvalue (entry, make_variable_value (entry, value, aflags)); /* XXX */
-    }
-  else if (entry->assign_func)	/* array vars have assign functions now */
-    {
-      if ((readonly_p (entry) && (aflags & ASS_FORCE) == 0) || noassign_p (entry))
-	{
-	  if (readonly_p (entry))
-	    err_readonly (name_cell (entry));
-	  return (entry);
-	}
-
-      INVALIDATE_EXPORTSTR (entry);
-      newval = (aflags & ASS_APPEND) ? make_variable_value (entry, value, aflags) : value;
-      if (assoc_p (entry))
-	entry = (*(entry->assign_func)) (entry, newval, -1, savestring ("0"));
-      else if (array_p (entry))
-	entry = (*(entry->assign_func)) (entry, newval, 0, 0);
-      else
-	entry = (*(entry->assign_func)) (entry, newval, -1, 0);
-      if (newval != value)
-	free (newval);
-      return (entry);
-    }
-  else
-    {
-assign_value:
-      if ((readonly_p (entry) && (aflags & ASS_FORCE) == 0) || noassign_p (entry))
-	{
-	  if (readonly_p (entry))
-	    err_readonly (name_cell (entry));
-	  return (entry);
-	}
-
-      /* Variables which are bound are visible. */
-      VUNSETATTR (entry, att_invisible);
-
-      /* If we can optimize the assignment, do so and return.  Right now, we
-	 optimize appends to string variables. */
-      if (can_optimize_assignment (entry, value, aflags))
-	{
-	  INVALIDATE_EXPORTSTR (entry);
-	  optimized_assignment (entry, value, aflags);
-
-	  if (mark_modified_vars)
-	    VSETATTR (entry, att_exported);
-
-	  if (exported_p (entry))
-	    array_needs_making = 1;
-
-	  return (entry);
-	}
-
-#if defined (ARRAY_VARS)
-      if (assoc_p (entry) || array_p (entry))
-        newval = make_array_variable_value (entry, 0, "0", value, aflags);
-      else
-#endif
-      newval = make_variable_value (entry, value, aflags);	/* XXX */
-
-      /* Invalidate any cached export string */
-      INVALIDATE_EXPORTSTR (entry);
-
-#if defined (ARRAY_VARS)
-      /* XXX -- this bears looking at again -- XXX */
-      /* If an existing array variable x is being assigned to with x=b or
-	 `read x' or something of that nature, silently convert it to
-	 x[0]=b or `read x[0]'. */
-      if (assoc_p (entry))
-	{
-	  assoc_insert (assoc_cell (entry), savestring ("0"), newval);
-	  free (newval);
-	}
-      else if (array_p (entry))
-	{
-	  array_insert (array_cell (entry), 0, newval);
-	  free (newval);
-	}
-      else
-#endif
-	{
-	  FREE (value_cell (entry));
-	  var_setvalue (entry, newval);
-	}
-    }
-
-  if (mark_modified_vars)
-    VSETATTR (entry, att_exported);
-
-  if (exported_p (entry))
-    array_needs_making = 1;
-
-  return (entry);
-}
-	
-/* Bind a variable NAME to VALUE.  This conses up the name
-   and value strings.  If we have a temporary environment, we bind there
-   first, then we bind into shell_variables. */
-
-SHELL_VAR *
-bind_variable (name, value, flags)
-     const char *name;
-     char *value;
-     int flags;
-{
-  SHELL_VAR *v, *nv;
-  VAR_CONTEXT *vc, *nvc;
-
-  if (shell_variables == 0)
-    create_variable_tables ();
-
-  /* If we have a temporary environment, look there first for the variable,
-     and, if found, modify the value there before modifying it in the
-     shell_variables table.  This allows sourced scripts to modify values
-     given to them in a temporary environment while modifying the variable
-     value that the caller sees. */
-  if (temporary_env && value)		/* XXX - can value be null here? */
-    bind_tempenv_variable (name, value);
-
-  /* XXX -- handle local variables here. */
-  for (vc = shell_variables; vc; vc = vc->down)
-    {
-      if (vc_isfuncenv (vc) || vc_isbltnenv (vc))
-	{
-	  v = hash_lookup (name, vc->table);
-	  nvc = vc;
-	  if (v && nameref_p (v))
-	    {
-	      /* This starts at the context where we found the nameref. If we
-		 want to start the name resolution over again at the original
-		 context, this is where we need to change it */
-	      nv = find_variable_nameref_context (v, vc, &nvc);
-	      if (nv == 0)
-		{
-		  nv = find_variable_last_nameref_context (v, vc, &nvc);
-		  if (nv && nameref_p (nv))
-		    {
-		      /* If this nameref variable doesn't have a value yet,
-			 set the value.  Otherwise, assign using the value as
-			 normal. */
-		      if (nameref_cell (nv) == 0)
-			return (bind_variable_internal (nv->name, value, nvc->table, 0, flags));
-#if defined (ARRAY_VARS)
-		      else if (valid_array_reference (nameref_cell (nv), 0))
-			return (assign_array_element (nameref_cell (nv), value, flags, (array_eltstate_t *)0));
-		      else
-#endif
-		      return (bind_variable_internal (nameref_cell (nv), value, nvc->table, 0, flags));
-		    }
-		  else if (nv == &nameref_maxloop_value)
-		    {
-		      internal_warning (_("%s: circular name reference"), v->name);
-		      return (bind_global_variable (v->name, value, flags));
-		    }
-		  else
-		    v = nv;
-		}
-	      else if (nv == &nameref_maxloop_value)
-		{
-		  internal_warning (_("%s: circular name reference"), v->name);
-		  return (bind_global_variable (v->name, value, flags));
-		}
-	      else
-	        v = nv;
-	    }
-	  if (v)
-	    return (bind_variable_internal (v->name, value, nvc->table, 0, flags));
-	}
-    }
-  /* bind_variable_internal will handle nameref resolution in this case */
-  return (bind_variable_internal (name, value, global_variables->table, 0, flags));
-}
-
-SHELL_VAR *
-bind_global_variable (name, value, flags)
-     const char *name;
-     char *value;
-     int flags;
-{
-  if (shell_variables == 0)
-    create_variable_tables ();
-
-  /* bind_variable_internal will handle nameref resolution in this case */
-  return (bind_variable_internal (name, value, global_variables->table, 0, flags));
-}
-
-static SHELL_VAR *
-bind_invalid_envvar (name, value, flags)
-     const char *name;
-     char *value;
-     int flags;
-{
-  if (invalid_env == 0)
-    invalid_env = hash_create (64);	/* XXX */
-  return (bind_variable_internal (name, value, invalid_env, HASH_NOSRCH, flags));
-}
-
-/* Make VAR, a simple shell variable, have value VALUE.  Once assigned a
-   value, variables are no longer invisible.  This is a duplicate of part
-   of the internals of bind_variable.  If the variable is exported, or
-   all modified variables should be exported, mark the variable for export
-   and note that the export environment needs to be recreated. */
-SHELL_VAR *
-bind_variable_value (var, value, aflags)
-     SHELL_VAR *var;
-     char *value;
-     int aflags;
-{
-  char *t;
-  int invis;
-
-  invis = invisible_p (var);
-  VUNSETATTR (var, att_invisible);
-
-  if (var->assign_func)
-    {
-      /* If we're appending, we need the old value, so use
-	 make_variable_value */
-      t = (aflags & ASS_APPEND) ? make_variable_value (var, value, aflags) : value;
-      (*(var->assign_func)) (var, t, -1, 0);
-      if (t != value && t)
-	free (t);      
-    }
-  else
-    {
-      t = make_variable_value (var, value, aflags);
-      if ((aflags & (ASS_NAMEREF|ASS_FORCE)) == ASS_NAMEREF && check_selfref (name_cell (var), t, 0))
-	{
-	  if (variable_context)
-	    internal_warning (_("%s: circular name reference"), name_cell (var));
-	  else
-	    {
-	      internal_error (_("%s: nameref variable self references not allowed"), name_cell (var));
-	      free (t);
-	      if (invis)
-		VSETATTR (var, att_invisible);	/* XXX */
-	      return ((SHELL_VAR *)NULL);
-	    }
-	}
-      if ((aflags & ASS_NAMEREF) && (valid_nameref_value (t, 0) == 0))
-	{
-	  free (t);
-	  if (invis)
-	    VSETATTR (var, att_invisible);	/* XXX */
-	  return ((SHELL_VAR *)NULL);
-	}
-      FREE (value_cell (var));
-      var_setvalue (var, t);
-    }
-
-  INVALIDATE_EXPORTSTR (var);
-
-  if (mark_modified_vars)
-    VSETATTR (var, att_exported);
-
-  if (exported_p (var))
-    array_needs_making = 1;
-
-  return (var);
-}
-
-/* Bind/create a shell variable with the name LHS to the RHS.
-   This creates or modifies a variable such that it is an integer.
-
-   This used to be in expr.c, but it is here so that all of the
-   variable binding stuff is localized.  Since we don't want any
-   recursive evaluation from bind_variable() (possible without this code,
-   since bind_variable() calls the evaluator for variables with the integer
-   attribute set), we temporarily turn off the integer attribute for each
-   variable we set here, then turn it back on after binding as necessary. */
-
-SHELL_VAR *
-bind_int_variable (lhs, rhs, flags)
-     char *lhs, *rhs;
-     int flags;
-{
-  register SHELL_VAR *v;
-  int isint, isarr, implicitarray, vflags, avflags;
-
-  isint = isarr = implicitarray = 0;
-#if defined (ARRAY_VARS)
-  /* Don't rely on VA_NOEXPAND being 1, set it explicitly */
-  vflags = (flags & ASS_NOEXPAND) ? VA_NOEXPAND : 0;
-  if (flags & ASS_ONEWORD)
-    vflags |= VA_ONEWORD;
-  if (valid_array_reference (lhs, vflags))
-    {
-      isarr = 1;
-      avflags = 0;
-      /* Common code to translate between assignment and reference flags. */
-      if (flags & ASS_NOEXPAND)
-	avflags |= AV_NOEXPAND;
-      if (flags & ASS_ONEWORD)
-	avflags |= AV_ONEWORD;
-      v = array_variable_part (lhs, avflags, (char **)0, (int *)0);
-    }
-  else if (legal_identifier (lhs) == 0)
-    {
-      sh_invalidid (lhs);
-      return ((SHELL_VAR *)NULL);      
-    }
-  else
-#endif
-    v = find_variable (lhs);
-
-  if (v)
-    {
-      isint = integer_p (v);
-      VUNSETATTR (v, att_integer);
-#if defined (ARRAY_VARS)
-      if (array_p (v) && isarr == 0)
-	implicitarray = 1;
-#endif
-    }
-
-#if defined (ARRAY_VARS)
-  if (isarr)
-    v = assign_array_element (lhs, rhs, flags, (array_eltstate_t *)0);
-  else if (implicitarray)
-    v = bind_array_variable (lhs, 0, rhs, 0);	/* XXX - check on flags */
-  else
-#endif
-    v = bind_variable (lhs, rhs, 0);	/* why not use bind_variable_value? */
-
-  if (v)
-    {
-      if (isint)
-	VSETATTR (v, att_integer);
-      VUNSETATTR (v, att_invisible);
-    }
-
-  if (v && nameref_p (v))
-    internal_warning (_("%s: assigning integer to name reference"), lhs);
-     
-  return (v);
-}
-
-SHELL_VAR *
-bind_var_to_int (var, val, flags)
-     char *var;
-     intmax_t val;
-     int flags;
-{
-  char ibuf[INT_STRLEN_BOUND (intmax_t) + 1], *p;
-
-  p = fmtulong (val, 10, ibuf, sizeof (ibuf), 0);
-  return (bind_int_variable (var, p, flags));
-}
-
-/* Do a function binding to a variable.  You pass the name and
-   the command to bind to.  This conses the name and command. */
-SHELL_VAR *
-bind_function (name, value)
-     const char *name;
-     COMMAND *value;
-{
-  SHELL_VAR *entry;
-
-  entry = find_function (name);
-  if (entry == 0)
-    {
-      BUCKET_CONTENTS *elt;
-
-      elt = hash_insert (savestring (name), shell_functions, HASH_NOSRCH);
-      entry = new_shell_variable (name);
-      elt->data = (PTR_T)entry;
-    }
-  else
-    INVALIDATE_EXPORTSTR (entry);
-
-  if (var_isset (entry))
-    dispose_command (function_cell (entry));
-
-  if (value)
-    var_setfunc (entry, copy_command (value));
-  else
-    var_setfunc (entry, 0);
-
-  VSETATTR (entry, att_function);
-
-  if (mark_modified_vars)
-    VSETATTR (entry, att_exported);
-
-  VUNSETATTR (entry, att_invisible);		/* Just to be sure */
-
-  if (exported_p (entry))
-    array_needs_making = 1;
-
-#if defined (PROGRAMMABLE_COMPLETION)
-  set_itemlist_dirty (&it_functions);
-#endif
-
-  return (entry);
-}
-
-#if defined (DEBUGGER)
-/* Bind a function definition, which includes source file and line number
-   information in addition to the command, into the FUNCTION_DEF hash table.
-   If (FLAGS & 1), overwrite any existing definition. If FLAGS == 0, leave
-   any existing definition alone. */
-void
-bind_function_def (name, value, flags)
-     const char *name;
-     FUNCTION_DEF *value;
-     int flags;
-{
-  FUNCTION_DEF *entry;
-  BUCKET_CONTENTS *elt;
-  COMMAND *cmd;
-
-  entry = find_function_def (name);
-  if (entry && (flags & 1))
-    {
-      dispose_function_def_contents (entry);
-      entry = copy_function_def_contents (value, entry);
-    }
-  else if (entry)
-    return;
-  else
-    {
-      cmd = value->command;
-      value->command = 0;
-      entry = copy_function_def (value);
-      value->command = cmd;
-
-      elt = hash_insert (savestring (name), shell_function_defs, HASH_NOSRCH);
-      elt->data = (PTR_T *)entry;
-    }
-}
-#endif /* DEBUGGER */
-
-/* Add STRING, which is of the form foo=bar, to the temporary environment
-   HASH_TABLE (temporary_env).  The functions in execute_cmd.c are
-   responsible for moving the main temporary env to one of the other
-   temporary environments.  The expansion code in subst.c calls this. */
-int
-assign_in_env (word, flags)
-     WORD_DESC *word;
-     int flags;
-{
-  int offset, aflags;
-  char *name, *temp, *value, *newname;
-  SHELL_VAR *var;
-  const char *string;
-
-  string = word->word;
-
-  aflags = 0;
-  offset = assignment (string, 0);
-  newname = name = savestring (string);
-  value = (char *)NULL;
-
-  if (name[offset] == '=')
-    {
-      name[offset] = 0;
-
-      /* don't ignore the `+' when assigning temporary environment */
-      if (name[offset - 1] == '+')
-	{
-	  name[offset - 1] = '\0';
-	  aflags |= ASS_APPEND;
-	}
-
-      if (legal_identifier (name) == 0)
-	{
-	  sh_invalidid (name);
-	  free (name);
-	  return (0);
-	}
-  
-      var = find_variable (name);
-      if (var == 0)
-	{
-	  var = find_variable_last_nameref (name, 1);
-	  /* If we're assigning a value to a nameref variable in the temp
-	     environment, and the value of the nameref is valid for assignment,
-	     but the variable does not already exist, assign to the nameref
-	     target and add the target to the temporary environment.  This is
-	     what ksh93 does */
-	  /* We use 2 in the call to valid_nameref_value because we don't want
-	     to allow array references here at all (newname will be used to
-	     create a variable directly below) */
-	  if (var && nameref_p (var) && valid_nameref_value (nameref_cell (var), 2))
-	    {
-	      newname = nameref_cell (var);
-	      var = 0;		/* don't use it for append */
-	    }
-	}
-      else
-        newname = name_cell (var);	/* no-op if not nameref */
-	  
-      if (var && (readonly_p (var) || noassign_p (var)))
-	{
-	  if (readonly_p (var))
-	    err_readonly (name);
-	  free (name);
-  	  return (0);
-	}
-      temp = name + offset + 1;
-
-      value = expand_assignment_string_to_string (temp, 0);
-
-      if (var && (aflags & ASS_APPEND))
-	{
-	  if (value == 0)
-	    {
-	      value = (char *)xmalloc (1);	/* like do_assignment_internal */
-	      value[0] = '\0';
-	    }
-	  temp = make_variable_value (var, value, aflags);
-	  FREE (value);
-	  value = temp;
-	}
-    }
-
-  if (temporary_env == 0)
-    temporary_env = hash_create (TEMPENV_HASH_BUCKETS);
-
-  var = hash_lookup (newname, temporary_env);
-  if (var == 0)
-    var = make_new_variable (newname, temporary_env);
-  else
-    FREE (value_cell (var));
-
-  if (value == 0)
-    {
-      value = (char *)xmalloc (1);	/* see above */
-      value[0] = '\0';
-    }
-
-  var_setvalue (var, value);
-  var->attributes |= (att_exported|att_tempvar);
-  var->context = variable_context;	/* XXX */
-
-  INVALIDATE_EXPORTSTR (var);
-  var->exportstr = mk_env_string (newname, value, 0);
-
-  array_needs_making = 1;
-
-  if (flags)
-    {
-      if (STREQ (newname, "POSIXLY_CORRECT") || STREQ (newname, "POSIX_PEDANDTIC"))
-	save_posix_options ();		/* XXX one level of saving right now */
-      stupidly_hack_special_variables (newname);
-    }
-
-  if (echo_command_at_execute)
-    /* The Korn shell prints the `+ ' in front of assignment statements,
-	so we do too. */
-    xtrace_print_assignment (name, value, 0, 1);
-
-  free (name);
-  return 1;
-}
-
-/* **************************************************************** */
-/*								    */
-/*			Copying variables			    */
-/*								    */
-/* **************************************************************** */
-
-#ifdef INCLUDE_UNUSED
-/* Copy VAR to a new data structure and return that structure. */
-SHELL_VAR *
-copy_variable (var)
-     SHELL_VAR *var;
-{
-  SHELL_VAR *copy = (SHELL_VAR *)NULL;
-
-  if (var)
-    {
-      copy = (SHELL_VAR *)xmalloc (sizeof (SHELL_VAR));
-
-      copy->attributes = var->attributes;
-      copy->name = savestring (var->name);
-
-      if (function_p (var))
-	var_setfunc (copy, copy_command (function_cell (var)));
-#if defined (ARRAY_VARS)
-      else if (array_p (var))
-	var_setarray (copy, array_copy (array_cell (var)));
-      else if (assoc_p (var))
-	var_setassoc (copy, assoc_copy (assoc_cell (var)));
-#endif
-      else if (nameref_cell (var))	/* XXX - nameref */
-	var_setref (copy, savestring (nameref_cell (var)));
-      else if (value_cell (var))	/* XXX - nameref */
-	var_setvalue (copy, savestring (value_cell (var)));
-      else
-	var_setvalue (copy, (char *)NULL);
-
-      copy->dynamic_value = var->dynamic_value;
-      copy->assign_func = var->assign_func;
-
-      copy->exportstr = COPY_EXPORTSTR (var);
-
-      copy->context = var->context;
-    }
-  return (copy);
-}
-#endif
-
-/* **************************************************************** */
-/*								    */
-/*		  Deleting and unsetting variables		    */
-/*								    */
-/* **************************************************************** */
-
-/* Dispose of the information attached to VAR. */
-static void
-dispose_variable_value (var)
-     SHELL_VAR *var;
-{
-  if (function_p (var))
-    dispose_command (function_cell (var));
-#if defined (ARRAY_VARS)
-  else if (array_p (var))
-    array_dispose (array_cell (var));
-  else if (assoc_p (var))
-    assoc_dispose (assoc_cell (var));
-#endif
-  else if (nameref_p (var))
-    FREE (nameref_cell (var));
-  else
-    FREE (value_cell (var));
-}
-
-void
-dispose_variable (var)
-     SHELL_VAR *var;
-{
-  if (var == 0)
-    return;
-
-  if (nofree_p (var) == 0)
-    dispose_variable_value (var);
-
-  FREE_EXPORTSTR (var);
-
-  free (var->name);
-
-  if (exported_p (var))
-    array_needs_making = 1;
-
-  free (var);
-}
-
-/* Unset the shell variable referenced by NAME.  Unsetting a nameref variable
-   unsets the variable it resolves to but leaves the nameref alone. */
-int
-unbind_variable (name)
-     const char *name;
-{
-  SHELL_VAR *v, *nv;
-  int r;
-
-  v = var_lookup (name, shell_variables);
-  nv = (v && nameref_p (v)) ? find_variable_nameref (v) : (SHELL_VAR *)NULL;
-
-  r = nv ? makunbound (nv->name, shell_variables) : makunbound (name, shell_variables);
-  return r;
-}
-
-/* Unbind NAME, where NAME is assumed to be a nameref variable */
-int
-unbind_nameref (name)
-     const char *name;
-{
-  SHELL_VAR *v;
-
-  v = var_lookup (name, shell_variables);
-  if (v && nameref_p (v))
-    return makunbound (name, shell_variables);
-  return 0;
-}
-
-/* Unbind the first instance of NAME, whether it's a nameref or not */
-int
-unbind_variable_noref (name)
-     const char *name;
-{
-  SHELL_VAR *v;
-
-  v = var_lookup (name, shell_variables);
-  if (v)
-    return makunbound (name, shell_variables);
-  return 0;
-}
-
-int
-unbind_global_variable (name)
-     const char *name;
-{
-  SHELL_VAR *v, *nv;
-  int r;
-
-  v = var_lookup (name, global_variables);
-  /* This starts at the current scope, just like find_global_variable; should we
-     use find_global_variable_nameref here? */
-  nv = (v && nameref_p (v)) ? find_variable_nameref (v) : (SHELL_VAR *)NULL;
-
-  r = nv ? makunbound (nv->name, shell_variables) : makunbound (name, global_variables);
-  return r;
-}
-
-int
-unbind_global_variable_noref (name)
-     const char *name;
-{
-  SHELL_VAR *v;
-
-  v = var_lookup (name, global_variables);
-  if (v)
-    return makunbound (name, global_variables);
-  return 0;
-}
- 
-int
-check_unbind_variable (name)
-     const char *name;
-{
-  SHELL_VAR *v;
-
-  v = find_variable (name);
-  if (v && readonly_p (v))
-    {
-      internal_error (_("%s: cannot unset: readonly %s"), name, "variable");
-      return -2;
-    }
-  else if (v && non_unsettable_p (v))
-    {
-      internal_error (_("%s: cannot unset"), name);
-      return -2;
-    }
-  return (unbind_variable (name));
-}
-
-/* Unset the shell function named NAME. */
-int
-unbind_func (name)
-     const char *name;
-{
-  BUCKET_CONTENTS *elt;
-  SHELL_VAR *func;
-
-  elt = hash_remove (name, shell_functions, 0);
-
-  if (elt == 0)
-    return -1;
-
-#if defined (PROGRAMMABLE_COMPLETION)
-  set_itemlist_dirty (&it_functions);
-#endif
-
-  func = (SHELL_VAR *)elt->data;
-  if (func)
-    {
-      if (exported_p (func))
-	array_needs_making++;
-      dispose_variable (func);
-    }
-
-  free (elt->key);
-  free (elt);
-
-  return 0;  
-}
-
-#if defined (DEBUGGER)
-int
-unbind_function_def (name)
-     const char *name;
-{
-  BUCKET_CONTENTS *elt;
-  FUNCTION_DEF *funcdef;
-
-  elt = hash_remove (name, shell_function_defs, 0);
-
-  if (elt == 0)
-    return -1;
-
-  funcdef = (FUNCTION_DEF *)elt->data;
-  if (funcdef)
-    dispose_function_def (funcdef);
-
-  free (elt->key);
-  free (elt);
-
-  return 0;  
-}
-#endif /* DEBUGGER */
-
-int
-delete_var (name, vc)
-     const char *name;
-     VAR_CONTEXT *vc;
-{
-  BUCKET_CONTENTS *elt;
-  SHELL_VAR *old_var;
-  VAR_CONTEXT *v;
-
-  for (elt = (BUCKET_CONTENTS *)NULL, v = vc; v; v = v->down)
-    if (elt = hash_remove (name, v->table, 0))
-      break;
-
-  if (elt == 0)
-    return (-1);
-
-  old_var = (SHELL_VAR *)elt->data;
-  free (elt->key);
-  free (elt);
-
-  dispose_variable (old_var);
-  return (0);
-}
-
-/* Make the variable associated with NAME go away.  HASH_LIST is the
-   hash table from which this variable should be deleted (either
-   shell_variables or shell_functions).
-   Returns non-zero if the variable couldn't be found. */
-int
-makunbound (name, vc)
-     const char *name;
-     VAR_CONTEXT *vc;
-{
-  BUCKET_CONTENTS *elt, *new_elt;
-  SHELL_VAR *old_var;
-  VAR_CONTEXT *v;
-  char *t;
-
-  for (elt = (BUCKET_CONTENTS *)NULL, v = vc; v; v = v->down)
-    if (elt = hash_remove (name, v->table, 0))
-      break;
-
-  if (elt == 0)
-    return (-1);
-
-  old_var = (SHELL_VAR *)elt->data;
-
-  if (old_var && exported_p (old_var))
-    array_needs_making++;
-
-  /* If we're unsetting a local variable and we're still executing inside
-     the function, just mark the variable as invisible.  The function
-     eventually called by pop_var_context() will clean it up later.  This
-     must be done so that if the variable is subsequently assigned a new
-     value inside the function, the `local' attribute is still present.
-     We also need to add it back into the correct hash table. */
-  if (old_var && local_p (old_var) &&
-	(old_var->context == variable_context || (localvar_unset && old_var->context < variable_context)))
-    {
-      if (nofree_p (old_var))
-	var_setvalue (old_var, (char *)NULL);
-#if defined (ARRAY_VARS)
-      else if (array_p (old_var))
-	array_dispose (array_cell (old_var));
-      else if (assoc_p (old_var))
-	assoc_dispose (assoc_cell (old_var));
-#endif
-      else if (nameref_p (old_var))
-	FREE (nameref_cell (old_var));
-      else
-	FREE (value_cell (old_var));
-      /* Reset the attributes.  Preserve the export attribute if the variable
-	 came from a temporary environment.  Make sure it stays local, and
-	 make it invisible. */ 
-      old_var->attributes = (exported_p (old_var) && tempvar_p (old_var)) ? att_exported : 0;
-      VSETATTR (old_var, att_local);
-      VSETATTR (old_var, att_invisible);
-      var_setvalue (old_var, (char *)NULL);
-      INVALIDATE_EXPORTSTR (old_var);
-
-      new_elt = hash_insert (savestring (old_var->name), v->table, 0);
-      new_elt->data = (PTR_T)old_var;
-      stupidly_hack_special_variables (old_var->name);
-
-      free (elt->key);
-      free (elt);
-      return (0);
-    }
-
-  /* Have to save a copy of name here, because it might refer to
-     old_var->name.  If so, stupidly_hack_special_variables will
-     reference freed memory. */
-  t = savestring (name);
-
-  free (elt->key);
-  free (elt);
-
-  dispose_variable (old_var);
-  stupidly_hack_special_variables (t);
-  free (t);
-
-  return (0);
-}
-
-/* Get rid of all of the variables in the current context. */
-void
-kill_all_local_variables ()
-{
-  VAR_CONTEXT *vc;
-
-  for (vc = shell_variables; vc; vc = vc->down)
-    if (vc_isfuncenv (vc) && vc->scope == variable_context)
-      break;
-  if (vc == 0)
-    return;		/* XXX */
-
-  if (vc->table && vc_haslocals (vc))
-    {
-      delete_all_variables (vc->table);
-      hash_dispose (vc->table);
-    }
-  vc->table = (HASH_TABLE *)NULL;
-}
-
-static void
-free_variable_hash_data (data)
-     PTR_T data;
-{
-  SHELL_VAR *var;
-
-  var = (SHELL_VAR *)data;
-  dispose_variable (var);
-}
-
-/* Delete the entire contents of the hash table. */
-void
-delete_all_variables (hashed_vars)
-     HASH_TABLE *hashed_vars;
-{
-  hash_flush (hashed_vars, free_variable_hash_data);
-}
-
-/* **************************************************************** */
-/*								    */
-/*		     Setting variable attributes		    */
-/*								    */
-/* **************************************************************** */
-
-#define FIND_OR_MAKE_VARIABLE(name, entry) \
-  do \
-    { \
-      entry = find_variable (name); \
-      if (!entry) \
-	{ \
-	  entry = bind_variable (name, "", 0); \
-	  if (entry) entry->attributes |= att_invisible; \
-	} \
-    } \
-  while (0)
-
-/* Make the variable associated with NAME be readonly.
-   If NAME does not exist yet, create it. */
-void
-set_var_read_only (name)
-     char *name;
-{
-  SHELL_VAR *entry;
-
-  FIND_OR_MAKE_VARIABLE (name, entry);
-  VSETATTR (entry, att_readonly);
-}
-
-#ifdef INCLUDE_UNUSED
-/* Make the function associated with NAME be readonly.
-   If NAME does not exist, we just punt, like auto_export code below. */
-void
-set_func_read_only (name)
-     const char *name;
-{
-  SHELL_VAR *entry;
-
-  entry = find_function (name);
-  if (entry)
-    VSETATTR (entry, att_readonly);
-}
-
-/* Make the variable associated with NAME be auto-exported.
-   If NAME does not exist yet, create it. */
-void
-set_var_auto_export (name)
-     char *name;
-{
-  SHELL_VAR *entry;
-
-  FIND_OR_MAKE_VARIABLE (name, entry);
-  set_auto_export (entry);
-}
-
-/* Make the function associated with NAME be auto-exported. */
-void
-set_func_auto_export (name)
-     const char *name;
-{
-  SHELL_VAR *entry;
-
-  entry = find_function (name);
-  if (entry)
-    set_auto_export (entry);
-}
-#endif
-
-/* **************************************************************** */
-/*								    */
-/*		     Creating lists of variables		    */
-/*								    */
-/* **************************************************************** */
-
-static VARLIST *
-vlist_alloc (nentries)
-     int nentries;
-{
-  VARLIST  *vlist;
-
-  vlist = (VARLIST *)xmalloc (sizeof (VARLIST));
-  vlist->list = (SHELL_VAR **)xmalloc ((nentries + 1) * sizeof (SHELL_VAR *));
-  vlist->list_size = nentries;
-  vlist->list_len = 0;
-  vlist->list[0] = (SHELL_VAR *)NULL;
-
-  return vlist;
-}
-
-static VARLIST *
-vlist_realloc (vlist, n)
-     VARLIST *vlist;
-     int n;
-{
-  if (vlist == 0)
-    return (vlist = vlist_alloc (n));
-  if (n > vlist->list_size)
-    {
-      vlist->list_size = n;
-      vlist->list = (SHELL_VAR **)xrealloc (vlist->list, (vlist->list_size + 1) * sizeof (SHELL_VAR *));
-    }
-  return vlist;
-}
-
-static void
-vlist_add (vlist, var, flags)
-     VARLIST *vlist;
-     SHELL_VAR *var;
-     int flags;
-{
-  register int i;
-
-  for (i = 0; i < vlist->list_len; i++)
-    if (STREQ (var->name, vlist->list[i]->name))
-      break;
-  if (i < vlist->list_len)
-    return;
-
-  if (i >= vlist->list_size)
-    vlist = vlist_realloc (vlist, vlist->list_size + 16);
-
-  vlist->list[vlist->list_len++] = var;
-  vlist->list[vlist->list_len] = (SHELL_VAR *)NULL;
-}
-
-/* Map FUNCTION over the variables in VAR_HASH_TABLE.  Return an array of the
-   variables for which FUNCTION returns a non-zero value.  A NULL value
-   for FUNCTION means to use all variables. */
-SHELL_VAR **
-map_over (function, vc)
-     sh_var_map_func_t *function;
-     VAR_CONTEXT *vc;
-{
-  VAR_CONTEXT *v;
-  VARLIST *vlist;
-  SHELL_VAR **ret;
-  int nentries;
-
-  for (nentries = 0, v = vc; v; v = v->down)
-    nentries += HASH_ENTRIES (v->table);
-
-  if (nentries == 0)
-    return (SHELL_VAR **)NULL;
-
-  vlist = vlist_alloc (nentries);
-
-  for (v = vc; v; v = v->down)
-    flatten (v->table, function, vlist, 0);
-
-  ret = vlist->list;
-  free (vlist);
-  return ret;
-}
-
-SHELL_VAR **
-map_over_funcs (function)
-     sh_var_map_func_t *function;
-{
-  VARLIST *vlist;
-  SHELL_VAR **ret;
-
-  if (shell_functions == 0 || HASH_ENTRIES (shell_functions) == 0)
-    return ((SHELL_VAR **)NULL);
-
-  vlist = vlist_alloc (HASH_ENTRIES (shell_functions));
-
-  flatten (shell_functions, function, vlist, 0);
-
-  ret = vlist->list;
-  free (vlist);
-  return ret;
-}
-
-/* Flatten VAR_HASH_TABLE, applying FUNC to each member and adding those
-   elements for which FUNC succeeds to VLIST->list.  FLAGS is reserved
-   for future use.  Only unique names are added to VLIST.  If FUNC is
-   NULL, each variable in VAR_HASH_TABLE is added to VLIST.  If VLIST is
-   NULL, FUNC is applied to each SHELL_VAR in VAR_HASH_TABLE.  If VLIST
-   and FUNC are both NULL, nothing happens. */
-static void
-flatten (var_hash_table, func, vlist, flags)
-     HASH_TABLE *var_hash_table;
-     sh_var_map_func_t *func;
-     VARLIST *vlist;
-     int flags;
-{
-  register int i;
-  register BUCKET_CONTENTS *tlist;
-  int r;
-  SHELL_VAR *var;
-
-  if (var_hash_table == 0 || (HASH_ENTRIES (var_hash_table) == 0) || (vlist == 0 && func == 0))
-    return;
-
-  for (i = 0; i < var_hash_table->nbuckets; i++)
-    {
-      for (tlist = hash_items (i, var_hash_table); tlist; tlist = tlist->next)
-	{
-	  var = (SHELL_VAR *)tlist->data;
-
-	  r = func ? (*func) (var) : 1;
-	  if (r && vlist)
-	    vlist_add (vlist, var, flags);
-	}
-    }
-}
-
-void
-sort_variables (array)
-     SHELL_VAR **array;
-{
-  qsort (array, strvec_len ((char **)array), sizeof (SHELL_VAR *), (QSFUNC *)qsort_var_comp);
-}
-
-static int
-qsort_var_comp (var1, var2)
-     SHELL_VAR **var1, **var2;
-{
-  int result;
-
-  if ((result = (*var1)->name[0] - (*var2)->name[0]) == 0)
-    result = strcmp ((*var1)->name, (*var2)->name);
-
-  return (result);
-}
-
-/* Apply FUNC to each variable in SHELL_VARIABLES, adding each one for
-   which FUNC succeeds to an array of SHELL_VAR *s.  Returns the array. */
-static SHELL_VAR **
-vapply (func)
-     sh_var_map_func_t *func;
-{
-  SHELL_VAR **list;
-
-  list = map_over (func, shell_variables);
-  if (list /* && posixly_correct */)
-    sort_variables (list);
-  return (list);
-}
-
-/* Apply FUNC to each variable in SHELL_FUNCTIONS, adding each one for
-   which FUNC succeeds to an array of SHELL_VAR *s.  Returns the array. */
-static SHELL_VAR **
-fapply (func)
-     sh_var_map_func_t *func;
-{
-  SHELL_VAR **list;
-
-  list = map_over_funcs (func);
-  if (list /* && posixly_correct */)
-    sort_variables (list);
-  return (list);
-}
-
-/* Create a NULL terminated array of all the shell variables. */
-SHELL_VAR **
-all_shell_variables ()
-{
-  return (vapply ((sh_var_map_func_t *)NULL));
-}
-
-/* Create a NULL terminated array of all the shell functions. */
-SHELL_VAR **
-all_shell_functions ()
-{
-  return (fapply ((sh_var_map_func_t *)NULL));
-}
-
-static int
-visible_var (var)
-     SHELL_VAR *var;
-{
-  return (invisible_p (var) == 0);
-}
-
-SHELL_VAR **
-all_visible_functions ()
-{
-  return (fapply (visible_var));
-}
-
-SHELL_VAR **
-all_visible_variables ()
-{
-  return (vapply (visible_var));
-}
-
-/* Return non-zero if the variable VAR is visible and exported.  Array
-   variables cannot be exported. */
-static int
-visible_and_exported (var)
-     SHELL_VAR *var;
-{
-  return (invisible_p (var) == 0 && exported_p (var));
-}
-
-/* Candidate variables for the export environment are either valid variables
-   with the export attribute or invalid variables inherited from the initial
-   environment and simply passed through. */
-static int
-export_environment_candidate (var)
-     SHELL_VAR *var;
-{
-  return (exported_p (var) && (invisible_p (var) == 0 || imported_p (var)));
-}
-
-/* Return non-zero if VAR is a local variable in the current context and
-   is exported. */
-static int
-local_and_exported (var)
-     SHELL_VAR *var;
-{
-  return (invisible_p (var) == 0 && local_p (var) && var->context == variable_context && exported_p (var));
-}
-
-SHELL_VAR **
-all_exported_variables ()
-{
-  return (vapply (visible_and_exported));
-}
-
-SHELL_VAR **
-local_exported_variables ()
-{
-  return (vapply (local_and_exported));
-}
-
-static int
-variable_in_context (var)
-     SHELL_VAR *var;
-{
-  return (local_p (var) && var->context == variable_context);
-}
-
-static int
-visible_variable_in_context (var)
-     SHELL_VAR *var;
-{
-  return (invisible_p (var) == 0 && local_p (var) && var->context == variable_context);
-}
-
-SHELL_VAR **
-all_local_variables (visible_only)
-     int visible_only;
-{
-  VARLIST *vlist;
-  SHELL_VAR **ret;
-  VAR_CONTEXT *vc;
-
-  vc = shell_variables;
-  for (vc = shell_variables; vc; vc = vc->down)
-    if (vc_isfuncenv (vc) && vc->scope == variable_context)
-      break;
-
-  if (vc == 0)
-    {
-      internal_error (_("all_local_variables: no function context at current scope"));
-      return (SHELL_VAR **)NULL;
-    }
-  if (vc->table == 0 || HASH_ENTRIES (vc->table) == 0 || vc_haslocals (vc) == 0)
-    return (SHELL_VAR **)NULL;
-    
-  vlist = vlist_alloc (HASH_ENTRIES (vc->table));
-
-  if (visible_only)
-    flatten (vc->table, visible_variable_in_context, vlist, 0);
-  else
-    flatten (vc->table, variable_in_context, vlist, 0);
-
-  ret = vlist->list;
-  free (vlist);
-  if (ret)
-    sort_variables (ret);
-  return ret;
-}
-
-#if defined (ARRAY_VARS)
-/* Return non-zero if the variable VAR is visible and an array. */
-static int
-visible_array_vars (var)
-     SHELL_VAR *var;
-{
-  return (invisible_p (var) == 0 && (array_p (var) || assoc_p (var)));
-}
-
-SHELL_VAR **
-all_array_variables ()
-{
-  return (vapply (visible_array_vars));
-}
-#endif /* ARRAY_VARS */
-
-char **
-all_variables_matching_prefix (prefix)
-     const char *prefix;
-{
-  SHELL_VAR **varlist;
-  char **rlist;
-  int vind, rind, plen;
-
-  plen = STRLEN (prefix);
-  varlist = all_visible_variables ();
-  for (vind = 0; varlist && varlist[vind]; vind++)
-    ;
-  if (varlist == 0 || vind == 0)
-    return ((char **)NULL);
-  rlist = strvec_create (vind + 1);
-  for (vind = rind = 0; varlist[vind]; vind++)
-    {
-      if (plen == 0 || STREQN (prefix, varlist[vind]->name, plen))
-	rlist[rind++] = savestring (varlist[vind]->name);
-    }
-  rlist[rind] = (char *)0;
-  free (varlist);
-
-  return rlist;
-}
-
-/* **************************************************************** */
-/*								    */
-/*		 Managing temporary variable scopes		    */
-/*								    */
-/* **************************************************************** */
-
-/* Make variable NAME have VALUE in the temporary environment. */
-static SHELL_VAR *
-bind_tempenv_variable (name, value)
-     const char *name;
-     char *value;
-{
-  SHELL_VAR *var;
-
-  var = temporary_env ? hash_lookup (name, temporary_env) : (SHELL_VAR *)NULL;
-
-  if (var)
-    {
-      FREE (value_cell (var));
-      var_setvalue (var, savestring (value));
-      INVALIDATE_EXPORTSTR (var);
-    }
-
-  return (var);
-}
-
-/* Find a variable in the temporary environment that is named NAME.
-   Return the SHELL_VAR *, or NULL if not found. */
-SHELL_VAR *
-find_tempenv_variable (name)
-     const char *name;
-{
-  return (temporary_env ? hash_lookup (name, temporary_env) : (SHELL_VAR *)NULL);
-}
-
-char **tempvar_list;
-int tvlist_ind;
-
-/* Take a variable from an assignment statement preceding a posix special
-   builtin (including `return') and create a global variable from it. This
-   is called from merge_temporary_env, which is only called when in posix
-   mode. */
-static void
-push_posix_temp_var (data)
-     PTR_T data;
-{
-  SHELL_VAR *var, *v;
-  HASH_TABLE *binding_table;
-
-  var = (SHELL_VAR *)data;
-
-  /* Just like do_assignment_internal(). This makes assignments preceding
-     special builtins act like standalone assignment statements when in
-     posix mode, satisfying the posix requirement that this affect the
-     "current execution environment." */
-  v = bind_variable (var->name, value_cell (var), ASS_FORCE|ASS_NOLONGJMP);
-
-  /* XXX - do we need to worry about array variables here? */
-
-  /* If this modifies an existing local variable, v->context will be non-zero.
-     If it comes back with v->context == 0, we bound at the global context.
-     Set binding_table appropriately. It doesn't matter whether it's correct
-     if the variable is local, only that it's not global_variables->table */
-  binding_table = v->context ? shell_variables->table : global_variables->table;
-
-  /* global variables are no longer temporary and don't need propagating. */
-  if (v->context == 0)
-    var->attributes &= ~(att_tempvar|att_propagate);
-
-  if (v)
-    {
-      v->attributes |= var->attributes;		/* preserve tempvar attribute if appropriate */
-      /* If we don't bind a local variable, propagate the value. If we bind a
-	 local variable (the "current execution environment"), keep it as local
-	 and don't propagate it to the calling environment. */
-      if (v->context > 0 && local_p (v) == 0)
-	v->attributes |= att_propagate;
-      else
-	v->attributes &= ~att_propagate;
-    }
-
-  if (find_special_var (var->name) >= 0)
-    tempvar_list[tvlist_ind++] = savestring (var->name);
-
-  dispose_variable (var);
-}
-
-/* Push the variable described by (SHELL_VAR *)DATA down to the next
-   variable context from the temporary environment. This can be called
-   from one context:
-      1. propagate_temp_var: which is called to propagate variables in
-	 assignments like `var=value declare -x var' to the surrounding
-	 scope.
-
-  In this case, the variable should have the att_propagate flag set and
-  we can create variables in the current scope.
-*/
-static void
-push_temp_var (data)
-     PTR_T data;
-{
-  SHELL_VAR *var, *v;
-  HASH_TABLE *binding_table;
-
-  var = (SHELL_VAR *)data;
-
-  binding_table = shell_variables->table;
-  if (binding_table == 0)
-    {
-      if (shell_variables == global_variables)
-	/* shouldn't happen */
-	binding_table = shell_variables->table = global_variables->table = hash_create (VARIABLES_HASH_BUCKETS);
-      else
-	binding_table = shell_variables->table = hash_create (TEMPENV_HASH_BUCKETS);
-    }
-
-  v = bind_variable_internal (var->name, value_cell (var), binding_table, 0, ASS_FORCE|ASS_NOLONGJMP);
-
-  /* XXX - should we set the context here?  It shouldn't matter because of how
-     assign_in_env works, but we do it anyway. */
-  if (v)
-    v->context = shell_variables->scope;
-
-  if (binding_table == global_variables->table)		/* XXX */
-    var->attributes &= ~(att_tempvar|att_propagate);
-  else
-    {
-      var->attributes |= att_propagate;			/* XXX - propagate more than once? */
-      if  (binding_table == shell_variables->table)
-	shell_variables->flags |= VC_HASTMPVAR;
-    }
-  if (v)
-    v->attributes |= var->attributes;
-
-  if (find_special_var (var->name) >= 0)
-    tempvar_list[tvlist_ind++] = savestring (var->name);
-
-  dispose_variable (var);
-}
-
-/* Take a variable described by DATA and push it to the surrounding scope if
-   the PROPAGATE attribute is set. That gets set by push_temp_var if we are
-   taking a variable like `var=value declare -x var' and propagating it to
-   the enclosing scope. */
-static void
-propagate_temp_var (data)
-     PTR_T data;
-{
-  SHELL_VAR *var;
-
-  var = (SHELL_VAR *)data;
-  if (tempvar_p (var) && (var->attributes & att_propagate))
-    push_temp_var (data);
-  else
-    {
-      if (find_special_var (var->name) >= 0)
-	tempvar_list[tvlist_ind++] = savestring (var->name);
-      dispose_variable (var);
-    }
-}
-
-/* Free the storage used in the hash table for temporary
-   environment variables.  PUSHF is a function to be called
-   to free each hash table entry.  It takes care of pushing variables
-   to previous scopes if appropriate.  PUSHF stores names of variables
-   that require special handling (e.g., IFS) on tempvar_list, so this
-   function can call stupidly_hack_special_variables on all the
-   variables in the list when the temporary hash table is destroyed. */
-static void
-dispose_temporary_env (pushf)
-     sh_free_func_t *pushf;
-{
-  int i;
-  HASH_TABLE *disposer;
-
-  tempvar_list = strvec_create (HASH_ENTRIES (temporary_env) + 1);
-  tempvar_list[tvlist_ind = 0] = 0;
-
-  disposer = temporary_env;
-  temporary_env = (HASH_TABLE *)NULL;
-
-  hash_flush (disposer, pushf);
-  hash_dispose (disposer);
-
-  tempvar_list[tvlist_ind] = 0;
-
-  array_needs_making = 1;
-
-  for (i = 0; i < tvlist_ind; i++)
-    stupidly_hack_special_variables (tempvar_list[i]);
-
-  strvec_dispose (tempvar_list);
-  tempvar_list = 0;
-  tvlist_ind = 0;
-}
-
-void
-dispose_used_env_vars ()
-{
-  if (temporary_env)
-    {
-      dispose_temporary_env (propagate_temp_var);
-      maybe_make_export_env ();
-    }
-}
-
-/* Take all of the shell variables in the temporary environment HASH_TABLE
-   and make shell variables from them at the current variable context.
-   Right now, this is only called in Posix mode to implement the historical
-   accident of creating global variables from assignment statements preceding
-   special builtins, but we check in case this acquires another caller later. */
-void
-merge_temporary_env ()
-{
-  if (temporary_env)
-    dispose_temporary_env (posixly_correct ? push_posix_temp_var : push_temp_var);
-}
-
-/* Temporary function to use if we want to separate function and special
-   builtin behavior. */
-void
-merge_function_temporary_env ()
-{
-  if (temporary_env)
-    dispose_temporary_env (push_temp_var);
-}
-
-void
-flush_temporary_env ()
-{
-  if (temporary_env)
-    {
-      hash_flush (temporary_env, free_variable_hash_data);
-      hash_dispose (temporary_env);
-      temporary_env = (HASH_TABLE *)NULL;
-    }
-}
-
-/* **************************************************************** */
-/*								    */
-/*	     Creating and manipulating the environment		    */
-/*								    */
-/* **************************************************************** */
-
-static inline char *
-mk_env_string (name, value, attributes)
-     const char *name, *value;
-     int attributes;
-{
-  size_t name_len, value_len;
-  char	*p, *q, *t;
-  int isfunc, isarray;
-
-  name_len = strlen (name);
-  value_len = STRLEN (value);
-
-  isfunc = attributes & att_function;
-#if defined (ARRAY_VARS) && defined (ARRAY_EXPORT)
-  isarray = attributes & (att_array|att_assoc);
-#endif
-
-  /* If we are exporting a shell function, construct the encoded function
-     name. */
-  if (isfunc && value)
-    {
-      p = (char *)xmalloc (BASHFUNC_PREFLEN + name_len + BASHFUNC_SUFFLEN + value_len + 2);
-      q = p;
-      memcpy (q, BASHFUNC_PREFIX, BASHFUNC_PREFLEN);
-      q += BASHFUNC_PREFLEN;
-      memcpy (q, name, name_len);
-      q += name_len;
-      memcpy (q, BASHFUNC_SUFFIX, BASHFUNC_SUFFLEN);
-      q += BASHFUNC_SUFFLEN;
-    }
-#if defined (ARRAY_VARS) && defined (ARRAY_EXPORT)
-  else if (isarray && value)
-    {
-      if (attributes & att_assoc)
-	p = (char *)xmalloc (BASHASSOC_PREFLEN + name_len + BASHASSOC_SUFFLEN + value_len + 2);
-      else
-	p = (char *)xmalloc (BASHARRAY_PREFLEN + name_len + BASHARRAY_SUFFLEN + value_len + 2);
-      q = p;
-      if (attributes & att_assoc)
-	{
-	  memcpy (q, BASHASSOC_PREFIX, BASHASSOC_PREFLEN);
-	  q += BASHASSOC_PREFLEN;
-	}
-      else
-	{
-	  memcpy (q, BASHARRAY_PREFIX, BASHARRAY_PREFLEN);
-	  q += BASHARRAY_PREFLEN;
-	}
-      memcpy (q, name, name_len);
-      q += name_len;
-      /* These are actually the same currently */
-      if (attributes & att_assoc)
-        {
-	  memcpy (q, BASHASSOC_SUFFIX, BASHASSOC_SUFFLEN);
-	  q += BASHARRAY_SUFFLEN;
-        }
-      else
-        {
-	  memcpy (q, BASHARRAY_SUFFIX, BASHARRAY_SUFFLEN);
-	  q += BASHARRAY_SUFFLEN;
-        }
-    }
-#endif  
-  else
-    {
-      p = (char *)xmalloc (2 + name_len + value_len);
-      memcpy (p, name, name_len);
-      q = p + name_len;
-    }
-
-  q[0] = '=';
-  if (value && *value)
-    {
-      if (isfunc)
-	{
-	  t = dequote_escapes (value);
-	  value_len = STRLEN (t);
-	  memcpy (q + 1, t, value_len + 1);
-	  free (t);
-	}
-      else
-	memcpy (q + 1, value, value_len + 1);
-    }
-  else
-    q[1] = '\0';
-
-  return (p);
-}
-
-#ifdef DEBUG
-/* Debugging */
-static int
-valid_exportstr (v)
-     SHELL_VAR *v;
-{
-  char *s;
-
-  s = v->exportstr;
-  if (s == 0)
-    {
-      internal_error (_("%s has null exportstr"), v->name);
-      return (0);
-    }
-  if (legal_variable_starter ((unsigned char)*s) == 0)
-    {
-      internal_error (_("invalid character %d in exportstr for %s"), *s, v->name);
-      return (0);
-    }
-  for (s = v->exportstr + 1; s && *s; s++)
-    {
-      if (*s == '=')
-	break;
-      if (legal_variable_char ((unsigned char)*s) == 0)
-	{
-	  internal_error (_("invalid character %d in exportstr for %s"), *s, v->name);
-	  return (0);
-	}
-    }
-  if (*s != '=')
-    {
-      internal_error (_("no `=' in exportstr for %s"), v->name);
-      return (0);
-    }
-  return (1);
-}
-#endif
-
-#if defined (ARRAY_VARS)
-#  define USE_EXPORTSTR (value == var->exportstr && array_p (var) == 0 && assoc_p (var) == 0)
-#else
-#  define USE_EXPORTSTR (value == var->exportstr)
-#endif
-
-static char **
-make_env_array_from_var_list (vars)
-     SHELL_VAR **vars;
-{
-  register int i, list_index;
-  register SHELL_VAR *var;
-  char **list, *value;
-
-  list = strvec_create ((1 + strvec_len ((char **)vars)));
-
-  for (i = 0, list_index = 0; var = vars[i]; i++)
-    {
-#if defined (__CYGWIN__)
-      /* We don't use the exportstr stuff on Cygwin at all. */
-      INVALIDATE_EXPORTSTR (var);
-#endif
-
-      /* If the value is generated dynamically, generate it here. */
-      if (regen_p (var) && var->dynamic_value)
-	{
-	  var = (*(var->dynamic_value)) (var);
-	  INVALIDATE_EXPORTSTR (var);
-	}
-
-      if (var->exportstr)
-	value = var->exportstr;
-      else if (function_p (var))
-	value = named_function_string ((char *)NULL, function_cell (var), 0);
-#if defined (ARRAY_VARS)
-      else if (array_p (var))
-#  if ARRAY_EXPORT
-	value = array_to_assign (array_cell (var), 0);
-#  else
-	continue;	/* XXX array vars cannot yet be exported */
-#  endif /* ARRAY_EXPORT */
-      else if (assoc_p (var))
-#  if ARRAY_EXPORT
-	value = assoc_to_assign (assoc_cell (var), 0);
-#  else
-	continue;	/* XXX associative array vars cannot yet be exported */
-#  endif /* ARRAY_EXPORT */
-#endif
-      else
-	value = value_cell (var);
-
-      if (value)
-	{
-	  /* Gee, I'd like to get away with not using savestring() if we're
-	     using the cached exportstr... */
-	  list[list_index] = USE_EXPORTSTR ? savestring (value)
-					   : mk_env_string (var->name, value, var->attributes);
-
-	  if (USE_EXPORTSTR == 0)
-	    SAVE_EXPORTSTR (var, list[list_index]);
-
-	  list_index++;
-#undef USE_EXPORTSTR
-
-#if defined (ARRAY_VARS) && defined (ARRAY_EXPORT)
-	  if (array_p (var) || assoc_p (var))
-	    free (value);
-#endif
-	}
-    }
-
-  list[list_index] = (char *)NULL;
-  return (list);
-}
-
-/* Make an array of assignment statements from the hash table
-   HASHED_VARS which contains SHELL_VARs.  Only visible, exported
-   variables are eligible. */
-static char **
-make_var_export_array (vcxt)
-     VAR_CONTEXT *vcxt;
-{
-  char **list;
-  SHELL_VAR **vars;
-
-#if 0
-  vars = map_over (visible_and_exported, vcxt);
-#else
-  vars = map_over (export_environment_candidate, vcxt);
-#endif
-
-  if (vars == 0)
-    return (char **)NULL;
-
-  list = make_env_array_from_var_list (vars);
-
-  free (vars);
-  return (list);
-}
-
-static char **
-make_func_export_array ()
-{
-  char **list;
-  SHELL_VAR **vars;
-
-  vars = map_over_funcs (visible_and_exported);
-  if (vars == 0)
-    return (char **)NULL;
-
-  list = make_env_array_from_var_list (vars);
-
-  free (vars);
-  return (list);
-}
-
-/* Add ENVSTR to the end of the exported environment, EXPORT_ENV. */
-#define add_to_export_env(envstr,do_alloc) \
-do \
-  { \
-    if (export_env_index >= (export_env_size - 1)) \
-      { \
-	export_env_size += 16; \
-	export_env = strvec_resize (export_env, export_env_size); \
-	environ = export_env; \
-      } \
-    export_env[export_env_index++] = (do_alloc) ? savestring (envstr) : envstr; \
-    export_env[export_env_index] = (char *)NULL; \
-  } while (0)
-
-/* Add ASSIGN to EXPORT_ENV, or supersede a previous assignment in the
-   array with the same left-hand side.  Return the new EXPORT_ENV. */
-char **
-add_or_supercede_exported_var (assign, do_alloc)
-     char *assign;
-     int do_alloc;
-{
-  register int i;
-  int equal_offset;
-
-  equal_offset = assignment (assign, 0);
-  if (equal_offset == 0)
-    return (export_env);
-
-  /* If this is a function, then only supersede the function definition.
-     We do this by including the `=() {' in the comparison, like
-     initialize_shell_variables does. */
-  if (assign[equal_offset + 1] == '(' &&
-     strncmp (assign + equal_offset + 2, ") {", 3) == 0)		/* } */
-    equal_offset += 4;
-
-  for (i = 0; i < export_env_index; i++)
-    {
-      if (STREQN (assign, export_env[i], equal_offset + 1))
-	{
-	  free (export_env[i]);
-	  export_env[i] = do_alloc ? savestring (assign) : assign;
-	  return (export_env);
-	}
-    }
-  add_to_export_env (assign, do_alloc);
-  return (export_env);
-}
-
-static void
-add_temp_array_to_env (temp_array, do_alloc, do_supercede)
-     char **temp_array;
-     int do_alloc, do_supercede;
-{
-  register int i;
-
-  if (temp_array == 0)
-    return;
-
-  for (i = 0; temp_array[i]; i++)
-    {
-      if (do_supercede)
-	export_env = add_or_supercede_exported_var (temp_array[i], do_alloc);
-      else
-	add_to_export_env (temp_array[i], do_alloc);
-    }
-
-  free (temp_array);
-}
-
-/* Make the environment array for the command about to be executed, if the
-   array needs making.  Otherwise, do nothing.  If a shell action could
-   change the array that commands receive for their environment, then the
-   code should `array_needs_making++'.
-
-   The order to add to the array is:
-   	temporary_env
-   	list of var contexts whose head is shell_variables
-  	shell_functions
-
-  This is the shell variable lookup order.  We add only new variable
-  names at each step, which allows local variables and variables in
-  the temporary environments to shadow variables in the global (or
-  any previous) scope.
-*/
-
-static int
-n_shell_variables ()
-{
-  VAR_CONTEXT *vc;
-  int n;
-
-  for (n = 0, vc = shell_variables; vc; vc = vc->down)
-    n += HASH_ENTRIES (vc->table);
-  return n;
-}
-
-int
-chkexport (name)
-     char *name;
-{
-  SHELL_VAR *v;
-
-  v = find_variable (name);
-  if (v && exported_p (v))
-    {
-      array_needs_making = 1;
-      maybe_make_export_env ();
-      return 1;
-    }
-  return 0;
-}
-
-void
-maybe_make_export_env ()
-{
-  register char **temp_array;
-  int new_size;
-  VAR_CONTEXT *tcxt, *icxt;
-
-  if (array_needs_making)
-    {
-      if (export_env)
-	strvec_flush (export_env);
-
-      /* Make a guess based on how many shell variables and functions we
-	 have.  Since there will always be array variables, and array
-	 variables are not (yet) exported, this will always be big enough
-	 for the exported variables and functions. */
-      new_size = n_shell_variables () + HASH_ENTRIES (shell_functions) + 1 +
-		 HASH_ENTRIES (temporary_env) + HASH_ENTRIES (invalid_env);
-      if (new_size > export_env_size)
-	{
-	  export_env_size = new_size;
-	  export_env = strvec_resize (export_env, export_env_size);
-	  environ = export_env;
-	}
-      export_env[export_env_index = 0] = (char *)NULL;
-
-      /* Make a dummy variable context from the temporary_env, stick it on
-	 the front of shell_variables, call make_var_export_array on the
-	 whole thing to flatten it, and convert the list of SHELL_VAR *s
-	 to the form needed by the environment. */
-      if (temporary_env)
-	{
-	  tcxt = new_var_context ((char *)NULL, 0);
-	  tcxt->table = temporary_env;
-	  tcxt->down = shell_variables;
-	}
-      else
-	tcxt = shell_variables;
-
-      if (invalid_env)
-	{
-	  icxt = new_var_context ((char *)NULL, 0);
-	  icxt->table = invalid_env;
-	  icxt->down = tcxt;
-	}
-      else
-	icxt = tcxt;
-      
-      temp_array = make_var_export_array (icxt);
-      if (temp_array)
-	add_temp_array_to_env (temp_array, 0, 0);
-
-      if (icxt != tcxt)
-	free (icxt);
-
-      if (tcxt != shell_variables)
-	free (tcxt);
-
-#if defined (RESTRICTED_SHELL)
-      /* Restricted shells may not export shell functions. */
-      temp_array = restricted ? (char **)0 : make_func_export_array ();
-#else
-      temp_array = make_func_export_array ();
-#endif
-      if (temp_array)
-	add_temp_array_to_env (temp_array, 0, 0);
-
-      array_needs_making = 0;
-    }
-}
-
-/* This is an efficiency hack.  PWD and OLDPWD are auto-exported, so
-   we will need to remake the exported environment every time we
-   change directories.  `_' is always put into the environment for
-   every external command, so without special treatment it will always
-   cause the environment to be remade.
-
-   If there is no other reason to make the exported environment, we can
-   just update the variables in place and mark the exported environment
-   as no longer needing a remake. */
-void
-update_export_env_inplace (env_prefix, preflen, value)
-     char *env_prefix;
-     int preflen;
-     char *value;
-{
-  char *evar;
-
-  evar = (char *)xmalloc (STRLEN (value) + preflen + 1);
-  strcpy (evar, env_prefix);
-  if (value)
-    strcpy (evar + preflen, value);
-  export_env = add_or_supercede_exported_var (evar, 0);
-}
-
-/* We always put _ in the environment as the name of this command. */
-void
-put_command_name_into_env (command_name)
-     char *command_name;
-{
-  update_export_env_inplace ("_=", 2, command_name);
-}
-
-/* **************************************************************** */
-/*								    */
-/*		      Managing variable contexts		    */
-/*								    */
-/* **************************************************************** */
-
-/* Allocate and return a new variable context with NAME and FLAGS.
-   NAME can be NULL. */
-
-VAR_CONTEXT *
-new_var_context (name, flags)
-     char *name;
-     int flags;
-{
-  VAR_CONTEXT *vc;
-
-  vc = (VAR_CONTEXT *)xmalloc (sizeof (VAR_CONTEXT));
-  vc->name = name ? savestring (name) : (char *)NULL;
-  vc->scope = variable_context;
-  vc->flags = flags;
-
-  vc->up = vc->down = (VAR_CONTEXT *)NULL;
-  vc->table = (HASH_TABLE *)NULL;
-
-  return vc;
-}
-
-/* Free a variable context and its data, including the hash table.  Dispose
-   all of the variables. */
-void
-dispose_var_context (vc)
-     VAR_CONTEXT *vc;
-{
-  FREE (vc->name);
-
-  if (vc->table)
-    {
-      delete_all_variables (vc->table);
-      hash_dispose (vc->table);
-    }
-
-  free (vc);
-}
-
-/* Set VAR's scope level to the current variable context. */
-static int
-set_context (var)
-     SHELL_VAR *var;
-{
-  return (var->context = variable_context);
-}
-
-/* Make a new variable context with NAME and FLAGS and a HASH_TABLE of
-   temporary variables, and push it onto shell_variables.  This is
-   for shell functions. */
-VAR_CONTEXT *
-push_var_context (name, flags, tempvars)
-     char *name;
-     int flags;
-     HASH_TABLE *tempvars;
-{
-  VAR_CONTEXT *vc;
-  int posix_func_behavior;
-
-  /* As of IEEE Std 1003.1-2017, assignment statements preceding shell
-     functions no longer behave like assignment statements preceding
-     special builtins, and do not persist in the current shell environment.
-     This is austin group interp #654, though nobody implements it yet. */
-  posix_func_behavior = 0;
-
-  vc = new_var_context (name, flags);
-  /* Posix interp 1009, temporary assignments preceding function calls modify
-     the current environment *before* the command is executed. */
-  if (posix_func_behavior && (flags & VC_FUNCENV) && tempvars == temporary_env)
-    merge_temporary_env ();
-  else if (tempvars)
-    {
-      vc->table = tempvars;
-      /* Have to do this because the temp environment was created before
-	 variable_context was incremented. */
-      /* XXX - only need to do it if flags&VC_FUNCENV */
-      flatten (tempvars, set_context, (VARLIST *)NULL, 0);
-      vc->flags |= VC_HASTMPVAR;
-    }
-  vc->down = shell_variables;
-  shell_variables->up = vc;
-
-  return (shell_variables = vc);
-}
-
-/* This can be called from one of two code paths:
-	1. pop_scope, which implements the posix rules for propagating variable
-	   assignments preceding special builtins to the surrounding scope
-	   (push_builtin_var -- isbltin == 1);
-	2. pop_var_context, which is called from pop_context and implements the
-	   posix rules for propagating variable assignments preceding function
-	   calls to the surrounding scope (push_func_var -- isbltin == 0)
-
-  It takes variables out of a temporary environment hash table. We take the
-  variable in data.
-*/
-
-static inline void
-push_posix_tempvar_internal (var, isbltin)
-     SHELL_VAR *var;
-     int isbltin;
-{
-  SHELL_VAR *v;
-  int posix_var_behavior;
-
-  /* As of IEEE Std 1003.1-2017, assignment statements preceding shell
-     functions no longer behave like assignment statements preceding
-     special builtins, and do not persist in the current shell environment.
-     This is austin group interp #654, though nobody implements it yet. */
-  posix_var_behavior = posixly_correct && isbltin;
-  v = 0;
-
-  if (local_p (var) && STREQ (var->name, "-"))
-    {
-      set_current_options (value_cell (var));
-      set_shellopts ();
-    }
-  /* This takes variable assignments preceding special builtins that can execute
-     multiple commands (source, eval, etc.) and performs the equivalent of
-     an assignment statement to modify the closest enclosing variable (the
-     posix "current execution environment"). This makes the behavior the same
-     as push_posix_temp_var; but the circumstances of calling are slightly
-     different. */
-  else if (tempvar_p (var) && posix_var_behavior)
-    {
-      /* similar to push_posix_temp_var */
-      v = bind_variable (var->name, value_cell (var), ASS_FORCE|ASS_NOLONGJMP);
-      if (v)
-	{
-	  v->attributes |= var->attributes;
-	  if (v->context == 0)
-	    v->attributes &= ~(att_tempvar|att_propagate);
-	  /* XXX - set att_propagate here if v->context > 0? */
-	}
-    }
-  else if (tempvar_p (var) && propagate_p (var))
-    {
-      /* Make sure we have a hash table to store the variable in while it is
-	 being propagated down to the global variables table.  Create one if
-	 we have to */
-      if ((vc_isfuncenv (shell_variables) || vc_istempenv (shell_variables)) && shell_variables->table == 0)
-	shell_variables->table = hash_create (VARIABLES_HASH_BUCKETS);
-      v = bind_variable_internal (var->name, value_cell (var), shell_variables->table, 0, 0);
-      /* XXX - should we set v->context here? */
-      if (v)
-	v->context = shell_variables->scope;
-      if (shell_variables == global_variables)
-	var->attributes &= ~(att_tempvar|att_propagate);
-      else
-	shell_variables->flags |= VC_HASTMPVAR;
-      if (v)
-	v->attributes |= var->attributes;
-    }
-  else
-    stupidly_hack_special_variables (var->name);	/* XXX */
-
-#if defined (ARRAY_VARS)
-  if (v && (array_p (var) || assoc_p (var)))
-    {
-      FREE (value_cell (v));
-      if (array_p (var))
-	var_setarray (v, array_copy (array_cell (var)));
-      else
-	var_setassoc (v, assoc_copy (assoc_cell (var)));
-    }
-#endif	  
-
-  dispose_variable (var);
-}
-
-static void
-push_func_var (data)
-     PTR_T data;
-{
-  SHELL_VAR *var;
-
-  var = (SHELL_VAR *)data;
-  push_posix_tempvar_internal (var, 0);
-}
-
-static void
-push_builtin_var (data)
-     PTR_T data;
-{
-  SHELL_VAR *var;
-
-  var = (SHELL_VAR *)data;
-  push_posix_tempvar_internal (var, 1);
-}
-
-/* Pop the top context off of VCXT and dispose of it, returning the rest of
-   the stack. */
-void
-pop_var_context ()
-{
-  VAR_CONTEXT *ret, *vcxt;
-
-  vcxt = shell_variables;
-  if (vc_isfuncenv (vcxt) == 0)
-    {
-      internal_error (_("pop_var_context: head of shell_variables not a function context"));
-      return;
-    }
-
-  if (ret = vcxt->down)
-    {
-      ret->up = (VAR_CONTEXT *)NULL;
-      shell_variables = ret;
-      if (vcxt->table)
-	hash_flush (vcxt->table, push_func_var);
-      dispose_var_context (vcxt);
-    }
-  else
-    internal_error (_("pop_var_context: no global_variables context"));
-}
-
-static void
-delete_local_contexts (vcxt)
-     VAR_CONTEXT *vcxt;
-{
-  VAR_CONTEXT *v, *t;
-
-  for (v = vcxt; v != global_variables; v = t)
-    {
-      t = v->down;
-      dispose_var_context (v);
-    }
-}
-
-/* Delete the HASH_TABLEs for all variable contexts beginning at VCXT, and
-   all of the VAR_CONTEXTs except GLOBAL_VARIABLES. */
-void
-delete_all_contexts (vcxt)
-     VAR_CONTEXT *vcxt;
-{
-  delete_local_contexts (vcxt);
-  delete_all_variables (global_variables->table);
-  shell_variables = global_variables;
-}
-
-/* Reset the context so we are not executing in a shell function. Only call
-   this if you are getting ready to exit the shell. */
-void
-reset_local_contexts ()
-{
-  delete_local_contexts (shell_variables);
-  shell_variables = global_variables;
-  variable_context = 0;
-}
-
-/* **************************************************************** */
-/*								    */
-/*	   Pushing and Popping temporary variable scopes	    */
-/*								    */
-/* **************************************************************** */
-
-VAR_CONTEXT *
-push_scope (flags, tmpvars)
-     int flags;
-     HASH_TABLE *tmpvars;
-{
-  return (push_var_context ((char *)NULL, flags, tmpvars));
-}
-
-static void
-push_exported_var (data)
-     PTR_T data;
-{
-  SHELL_VAR *var, *v;
-
-  var = (SHELL_VAR *)data;
-
-  /* If a temp var had its export attribute set, or it's marked to be
-     propagated, bind it in the previous scope before disposing it. */
-  /* XXX - This isn't exactly right, because all tempenv variables have the
-    export attribute set. */
-  if (tempvar_p (var) && exported_p (var) && (var->attributes & att_propagate))
-    {
-      var->attributes &= ~att_tempvar;		/* XXX */
-      v = bind_variable_internal (var->name, value_cell (var), shell_variables->table, 0, 0);
-      if (shell_variables == global_variables)
-	var->attributes &= ~att_propagate;
-      if (v)
-	{
-	  v->attributes |= var->attributes;
-	  v->context = shell_variables->scope;
-	}
-    }
-  else
-    stupidly_hack_special_variables (var->name);	/* XXX */
-
-  dispose_variable (var);
-}
-
-/* This is called to propagate variables in the temporary environment of a
-   special builtin (if IS_SPECIAL != 0) or exported variables that are the
-   result of a builtin like `source' or `command' that can operate on the
-   variables in its temporary environment. In the first case, we call
-   push_builtin_var, which does the right thing. */
-void
-pop_scope (is_special)
-     int is_special;
-{
-  VAR_CONTEXT *vcxt, *ret;
-  int is_bltinenv;
-
-  vcxt = shell_variables;
-  if (vc_istempscope (vcxt) == 0)
-    {
-      internal_error (_("pop_scope: head of shell_variables not a temporary environment scope"));
-      return;
-    }
-  is_bltinenv = vc_isbltnenv (vcxt);	/* XXX - for later */
-
-  ret = vcxt->down;
-  if (ret)
-    ret->up = (VAR_CONTEXT *)NULL;
-
-  shell_variables = ret;
-
-  /* Now we can take care of merging variables in VCXT into set of scopes
-     whose head is RET (shell_variables). */
-  FREE (vcxt->name);
-  if (vcxt->table)
-    {
-      if (is_special)
-	hash_flush (vcxt->table, push_builtin_var);
-      else
-	hash_flush (vcxt->table, push_exported_var);
-      hash_dispose (vcxt->table);
-    }
-  free (vcxt);
-
-  sv_ifs ("IFS");	/* XXX here for now */
-}
-
-/* **************************************************************** */
-/*								    */
-/*		 Pushing and Popping function contexts		    */
-/*								    */
-/* **************************************************************** */
-
-struct saved_dollar_vars {
-  char **first_ten;
-  WORD_LIST *rest;
-  int count;
-};
-
-static struct saved_dollar_vars *dollar_arg_stack = (struct saved_dollar_vars *)NULL;
-static int dollar_arg_stack_slots;
-static int dollar_arg_stack_index;
-
-/* Functions to manipulate dollar_vars array. Need to keep these in sync with
-   whatever remember_args() does. */
-static char **
-save_dollar_vars ()
-{
-  char **ret;
-  int i;
-
-  ret = strvec_create (10);
-  for (i = 1; i < 10; i++)
-    {
-      ret[i] = dollar_vars[i];
-      dollar_vars[i] = (char *)NULL;
-    }
-  return ret;
-}
-
-static void
-restore_dollar_vars (args)
-     char **args;
-{
-  int i;
-
-  for (i = 1; i < 10; i++)
-    dollar_vars[i] = args[i];
-}
-
-static void
-free_dollar_vars ()
-{
-  int i;
-
-  for (i = 1; i < 10; i++)
-    {
-      FREE (dollar_vars[i]);
-      dollar_vars[i] = (char *)NULL;
-    }
-}
-
-static void
-free_saved_dollar_vars (args)
-     char **args;
-{
-  int i;
-
-  for (i = 1; i < 10; i++)
-    FREE (args[i]);
-}
-
-/* Do what remember_args (xxx, 1) would have done. */
-void
-clear_dollar_vars ()
-{
-  free_dollar_vars ();
-  dispose_words (rest_of_args);
-
-  rest_of_args = (WORD_LIST *)NULL;
-  posparam_count = 0;
-}
-
-/* XXX - should always be followed by remember_args () */
-void
-push_context (name, is_subshell, tempvars)
-     char *name;	/* function name */
-     int is_subshell;
-     HASH_TABLE *tempvars;
-{
-  if (is_subshell == 0)
-    push_dollar_vars ();
-  variable_context++;
-  push_var_context (name, VC_FUNCENV, tempvars);
-}
-
-/* Only called when subshell == 0, so we don't need to check, and can
-   unconditionally pop the dollar vars off the stack. */
-void
-pop_context ()
-{
-  pop_dollar_vars ();
-  variable_context--;
-  pop_var_context ();
-
-  sv_ifs ("IFS");		/* XXX here for now */
-}
-
-/* Save the existing positional parameters on a stack. */
-void
-push_dollar_vars ()
-{
-  if (dollar_arg_stack_index + 2 > dollar_arg_stack_slots)
-    {
-      dollar_arg_stack = (struct saved_dollar_vars *)
-	xrealloc (dollar_arg_stack, (dollar_arg_stack_slots += 10)
-		  * sizeof (struct saved_dollar_vars));
-    }
-
-  dollar_arg_stack[dollar_arg_stack_index].count = posparam_count;
-  dollar_arg_stack[dollar_arg_stack_index].first_ten = save_dollar_vars ();
-  dollar_arg_stack[dollar_arg_stack_index++].rest = rest_of_args;
-  rest_of_args = (WORD_LIST *)NULL;
-  posparam_count = 0;
-  
-  dollar_arg_stack[dollar_arg_stack_index].first_ten = (char **)NULL;
-  dollar_arg_stack[dollar_arg_stack_index].rest = (WORD_LIST *)NULL;  
-}
-
-/* Restore the positional parameters from our stack. */
-void
-pop_dollar_vars ()
-{
-  if (dollar_arg_stack == 0 || dollar_arg_stack_index == 0)
-    return;
-
-  /* Wipe out current values */
-  clear_dollar_vars ();
-
-  rest_of_args = dollar_arg_stack[--dollar_arg_stack_index].rest;
-  restore_dollar_vars (dollar_arg_stack[dollar_arg_stack_index].first_ten);
-  free (dollar_arg_stack[dollar_arg_stack_index].first_ten);
-  posparam_count = dollar_arg_stack[dollar_arg_stack_index].count;
-
-  dollar_arg_stack[dollar_arg_stack_index].first_ten = (char **)NULL;
-  dollar_arg_stack[dollar_arg_stack_index].rest = (WORD_LIST *)NULL;
-  dollar_arg_stack[dollar_arg_stack_index].count = 0;
-
-  set_dollar_vars_unchanged ();
-  invalidate_cached_quoted_dollar_at ();
-}
-
-void
-dispose_saved_dollar_vars ()
-{
-  if (dollar_arg_stack == 0 || dollar_arg_stack_index == 0)
-    return;
-
-  dispose_words (dollar_arg_stack[--dollar_arg_stack_index].rest);    
-  free_saved_dollar_vars (dollar_arg_stack[dollar_arg_stack_index].first_ten);	
-  free (dollar_arg_stack[dollar_arg_stack_index].first_ten);
-
-  dollar_arg_stack[dollar_arg_stack_index].first_ten = (char **)NULL;  
-  dollar_arg_stack[dollar_arg_stack_index].rest = (WORD_LIST *)NULL;
-  dollar_arg_stack[dollar_arg_stack_index].count = 0;
-}
-
-/* Initialize BASH_ARGV and BASH_ARGC after turning on extdebug after the
-   shell is initialized */
-void
-init_bash_argv ()
-{
-  if (bash_argv_initialized == 0)
-    {
-      save_bash_argv ();
-      bash_argv_initialized = 1;
-    }
-}
-
-void
-save_bash_argv ()
-{
-  WORD_LIST *list;
-
-  list = list_rest_of_args ();
-  push_args (list);
-  dispose_words (list);
-}
-
-/* Manipulate the special BASH_ARGV and BASH_ARGC variables. */
-
-void
-push_args (list)
-     WORD_LIST *list;
-{
-#if defined (ARRAY_VARS) && defined (DEBUGGER)
-  SHELL_VAR *bash_argv_v, *bash_argc_v;
-  ARRAY *bash_argv_a, *bash_argc_a;
-  WORD_LIST *l;
-  arrayind_t i;
-  char *t;
-
-  GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v, bash_argv_a);
-  GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v, bash_argc_a);
-
-  for (l = list, i = 0; l; l = l->next, i++)
-    array_push (bash_argv_a, l->word->word);
-
-  t = itos (i);
-  array_push (bash_argc_a, t);
-  free (t);
-#endif /* ARRAY_VARS && DEBUGGER */
-}
-
-/* Remove arguments from BASH_ARGV array.  Pop top element off BASH_ARGC
-   array and use that value as the count of elements to remove from
-   BASH_ARGV. */
-void
-pop_args ()
-{
-#if defined (ARRAY_VARS) && defined (DEBUGGER)
-  SHELL_VAR *bash_argv_v, *bash_argc_v;
-  ARRAY *bash_argv_a, *bash_argc_a;
-  ARRAY_ELEMENT *ce;
-  intmax_t i;
-
-  GET_ARRAY_FROM_VAR ("BASH_ARGV", bash_argv_v, bash_argv_a);
-  GET_ARRAY_FROM_VAR ("BASH_ARGC", bash_argc_v, bash_argc_a);
-
-  ce = array_unshift_element (bash_argc_a);
-  if (ce == 0 || legal_number (element_value (ce), &i) == 0)
-    i = 0;
-
-  for ( ; i > 0; i--)
-    array_pop (bash_argv_a);
-  array_dispose_element (ce);
-#endif /* ARRAY_VARS && DEBUGGER */
-}
-
-/*************************************************
- *						 *
- *	Functions to manage special variables	 *
- *						 *
- *************************************************/
-
-/* Extern declarations for variables this code has to manage. */
-
-/* An alist of name.function for each special variable.  Most of the
-   functions don't do much, and in fact, this would be faster with a
-   switch statement, but by the end of this file, I am sick of switch
-   statements. */
-
-#define SET_INT_VAR(name, intvar)  intvar = find_variable (name) != 0
-
-/* This table will be sorted with qsort() the first time it's accessed. */
-struct name_and_function {
-  char *name;
-  sh_sv_func_t *function;
-};
-
-static struct name_and_function special_vars[] = {
-  { "BASH_COMPAT", sv_shcompat },
-  { "BASH_XTRACEFD", sv_xtracefd },
-
-#if defined (JOB_CONTROL)
-  { "CHILD_MAX", sv_childmax },
-#endif
-
-#if defined (READLINE)
-#  if defined (STRICT_POSIX)
-  { "COLUMNS", sv_winsize },
-#  endif
-  { "COMP_WORDBREAKS", sv_comp_wordbreaks },
-#endif
-
-  { "EXECIGNORE", sv_execignore },
-
-  { "FUNCNEST", sv_funcnest },
-
-  { "GLOBIGNORE", sv_globignore },
-
-#if defined (HISTORY)
-  { "HISTCONTROL", sv_history_control },
-  { "HISTFILESIZE", sv_histsize },
-  { "HISTIGNORE", sv_histignore },
-  { "HISTSIZE", sv_histsize },
-  { "HISTTIMEFORMAT", sv_histtimefmt },
-#endif
-
-#if defined (__CYGWIN__)
-  { "HOME", sv_home },
-#endif
-
-#if defined (READLINE)
-  { "HOSTFILE", sv_hostfile },
-#endif
-
-  { "IFS", sv_ifs },
-  { "IGNOREEOF", sv_ignoreeof },
-
-  { "LANG", sv_locale },
-  { "LC_ALL", sv_locale },
-  { "LC_COLLATE", sv_locale },
-  { "LC_CTYPE", sv_locale },
-  { "LC_MESSAGES", sv_locale },
-  { "LC_NUMERIC", sv_locale },
-  { "LC_TIME", sv_locale },
-
-#if defined (READLINE) && defined (STRICT_POSIX)
-  { "LINES", sv_winsize },
-#endif
-
-  { "MAIL", sv_mail },
-  { "MAILCHECK", sv_mail },
-  { "MAILPATH", sv_mail },
-
-  { "OPTERR", sv_opterr },
-  { "OPTIND", sv_optind },
-
-  { "PATH", sv_path },
-  { "POSIXLY_CORRECT", sv_strict_posix },
-
-#if defined (READLINE)
-  { "TERM", sv_terminal },
-  { "TERMCAP", sv_terminal },
-  { "TERMINFO", sv_terminal },
-#endif /* READLINE */
-
-  { "TEXTDOMAIN", sv_locale },
-  { "TEXTDOMAINDIR", sv_locale },
-
-#if defined (HAVE_TZSET)
-  { "TZ", sv_tz },
-#endif
-
-#if defined (HISTORY) && defined (BANG_HISTORY)
-  { "histchars", sv_histchars },
-#endif /* HISTORY && BANG_HISTORY */
-
-  { "ignoreeof", sv_ignoreeof },
-
-  { (char *)0, (sh_sv_func_t *)0 }
-};
-
-#define N_SPECIAL_VARS	(sizeof (special_vars) / sizeof (special_vars[0]) - 1)
-
-static int
-sv_compare (sv1, sv2)
-     struct name_and_function *sv1, *sv2;
-{
-  int r;
-
-  if ((r = sv1->name[0] - sv2->name[0]) == 0)
-    r = strcmp (sv1->name, sv2->name);
-  return r;
-}
-
-static inline int
-find_special_var (name)
-     const char *name;
-{
-  register int i, r;
-
-  for (i = 0; special_vars[i].name; i++)
-    {
-      r = special_vars[i].name[0] - name[0];
-      if (r == 0)
-	r = strcmp (special_vars[i].name, name);
-      if (r == 0)
-	return i;
-      else if (r > 0)
-	/* Can't match any of rest of elements in sorted list.  Take this out
-	   if it causes problems in certain environments. */
-	break;
-    }
-  return -1;
-}
-
-/* The variable in NAME has just had its state changed.  Check to see if it
-   is one of the special ones where something special happens. */
-void
-stupidly_hack_special_variables (name)
-     char *name;
-{
-  static int sv_sorted = 0;
-  int i;
-
-  if (sv_sorted == 0)	/* shouldn't need, but it's fairly cheap. */
-    {
-      qsort (special_vars, N_SPECIAL_VARS, sizeof (special_vars[0]),
-		(QSFUNC *)sv_compare);
-      sv_sorted = 1;
-    }
-
-  i = find_special_var (name);
-  if (i != -1)
-    (*(special_vars[i].function)) (name);
-}
-
-/* Special variables that need hooks to be run when they are unset as part
-   of shell reinitialization should have their sv_ functions run here. */
-void
-reinit_special_variables ()
-{
-#if defined (READLINE)
-  sv_comp_wordbreaks ("COMP_WORDBREAKS");
-#endif
-  sv_globignore ("GLOBIGNORE");
-  sv_opterr ("OPTERR");
-}
-
-void
-sv_ifs (name)
-     char *name;
-{
-  SHELL_VAR *v;
-
-  v = find_variable ("IFS");
-  setifs (v);
-}
-
-/* What to do just after the PATH variable has changed. */
-void
-sv_path (name)
-     char *name;
-{
-  /* hash -r */
-  phash_flush ();
-}
-
-/* What to do just after one of the MAILxxxx variables has changed.  NAME
-   is the name of the variable.  This is called with NAME set to one of
-   MAIL, MAILCHECK, or MAILPATH.  */
-void
-sv_mail (name)
-     char *name;
-{
-  /* If the time interval for checking the files has changed, then
-     reset the mail timer.  Otherwise, one of the pathname vars
-     to the users mailbox has changed, so rebuild the array of
-     filenames. */
-  if (name[4] == 'C')  /* if (strcmp (name, "MAILCHECK") == 0) */
-    reset_mail_timer ();
-  else
-    {
-      free_mail_files ();
-      remember_mail_dates ();
-    }
-}
-
-void
-sv_funcnest (name)
-     char *name;
-{
-  SHELL_VAR *v;
-  intmax_t num;
-
-  v = find_variable (name);
-  if (v == 0)
-    funcnest_max = 0;
-  else if (legal_number (value_cell (v), &num) == 0)
-    funcnest_max = 0;
-  else
-    funcnest_max = num;
-}
-
-/* What to do when EXECIGNORE changes. */
-void
-sv_execignore (name)
-     char *name;
-{
-  setup_exec_ignore (name);
-}
-
-/* What to do when GLOBIGNORE changes. */
-void
-sv_globignore (name)
-     char *name;
-{
-  if (privileged_mode == 0)
-    setup_glob_ignore (name);
-}
-
-#if defined (READLINE)
-void
-sv_comp_wordbreaks (name)
-     char *name;
-{
-  SHELL_VAR *sv;
-
-  sv = find_variable (name);
-  if (sv == 0)
-    reset_completer_word_break_chars ();
-}
-
-/* What to do just after one of the TERMxxx variables has changed.
-   If we are an interactive shell, then try to reset the terminal
-   information in readline. */
-void
-sv_terminal (name)
-     char *name;
-{
-  if (interactive_shell && no_line_editing == 0)
-    rl_reset_terminal (get_string_value ("TERM"));
-}
-
-void
-sv_hostfile (name)
-     char *name;
-{
-  SHELL_VAR *v;
-
-  v = find_variable (name);
-  if (v == 0)
-    clear_hostname_list ();
-  else
-    hostname_list_initialized = 0;
-}
-
-#if defined (STRICT_POSIX)
-/* In strict posix mode, we allow assignments to LINES and COLUMNS (and values
-   found in the initial environment) to override the terminal size reported by
-   the kernel. */
-void
-sv_winsize (name)
-     char *name;
-{
-  SHELL_VAR *v;
-  intmax_t xd;
-  int d;
-
-  if (posixly_correct == 0 || interactive_shell == 0 || no_line_editing)
-    return;
-
-  v = find_variable (name);
-  if (v == 0 || var_isset (v) == 0)
-    rl_reset_screen_size ();
-  else
-    {
-      if (legal_number (value_cell (v), &xd) == 0)
-	return;
-      winsize_assignment = 1;
-      d = xd;			/* truncate */
-      if (name[0] == 'L')	/* LINES */
-	rl_set_screen_size (d, -1);
-      else			/* COLUMNS */
-	rl_set_screen_size (-1, d);
-      winsize_assignment = 0;
-    }
-}
-#endif /* STRICT_POSIX */
-#endif /* READLINE */
-
-/* Update the value of HOME in the export environment so tilde expansion will
-   work on cygwin. */
-#if defined (__CYGWIN__)
-sv_home (name)
-     char *name;
-{
-  array_needs_making = 1;
-  maybe_make_export_env ();
-}
-#endif
-
-#if defined (HISTORY)
-/* What to do after the HISTSIZE or HISTFILESIZE variables change.
-   If there is a value for this HISTSIZE (and it is numeric), then stifle
-   the history.  Otherwise, if there is NO value for this variable,
-   unstifle the history.  If name is HISTFILESIZE, and its value is
-   numeric, truncate the history file to hold no more than that many
-   lines. */
-void
-sv_histsize (name)
-     char *name;
-{
-  char *temp;
-  intmax_t num;
-  int hmax;
-
-  temp = get_string_value (name);
-
-  if (temp && *temp)
-    {
-      if (legal_number (temp, &num))
-	{
-	  hmax = num;
-	  if (hmax < 0 && name[4] == 'S')
-	    unstifle_history ();	/* unstifle history if HISTSIZE < 0 */
-	  else if (name[4] == 'S')
-	    {
-	      stifle_history (hmax);
-	      hmax = where_history ();
-	      if (history_lines_this_session > hmax)
-		history_lines_this_session = hmax;
-	    }
-	  else if (hmax >= 0)	/* truncate HISTFILE if HISTFILESIZE >= 0 */
-	    {
-	      history_truncate_file (get_string_value ("HISTFILE"), hmax);
-	      /* If we just shrank the history file to fewer lines than we've
-		 already read, make sure we adjust our idea of how many lines
-		 we have read from the file. */
-	      if (hmax < history_lines_in_file)
-		history_lines_in_file = hmax;
-	    }
-	}
-    }
-  else if (name[4] == 'S')
-    unstifle_history ();
-}
-
-/* What to do after the HISTIGNORE variable changes. */
-void
-sv_histignore (name)
-     char *name;
-{
-  setup_history_ignore (name);
-}
-
-/* What to do after the HISTCONTROL variable changes. */
-void
-sv_history_control (name)
-     char *name;
-{
-  char *temp;
-  char *val;
-  int tptr;
-
-  history_control = 0;
-  temp = get_string_value (name);
-
-  if (temp == 0 || *temp == 0)
-    return;
-
-  tptr = 0;
-  while (val = extract_colon_unit (temp, &tptr))
-    {
-      if (STREQ (val, "ignorespace"))
-	history_control |= HC_IGNSPACE;
-      else if (STREQ (val, "ignoredups"))
-	history_control |= HC_IGNDUPS;
-      else if (STREQ (val, "ignoreboth"))
-	history_control |= HC_IGNBOTH;
-      else if (STREQ (val, "erasedups"))
-	history_control |= HC_ERASEDUPS;
-
-      free (val);
-    }
-}
-
-#if defined (BANG_HISTORY)
-/* Setting/unsetting of the history expansion character. */
-void
-sv_histchars (name)
-     char *name;
-{
-  char *temp;
-
-  temp = get_string_value (name);
-  if (temp)
-    {
-      history_expansion_char = *temp;
-      if (temp[0] && temp[1])
-	{
-	  history_subst_char = temp[1];
-	  if (temp[2])
-	      history_comment_char = temp[2];
-	}
-    }
-  else
-    {
-      history_expansion_char = '!';
-      history_subst_char = '^';
-      history_comment_char = '#';
-    }
-}
-#endif /* BANG_HISTORY */
-
-void
-sv_histtimefmt (name)
-     char *name;
-{
-  SHELL_VAR *v;
-
-  if (v = find_variable (name))
-    {
-      if (history_comment_char == 0)
-	history_comment_char = '#';
-    }
-  history_write_timestamps = (v != 0);
-}
-#endif /* HISTORY */
-
-#if defined (HAVE_TZSET)
-void
-sv_tz (name)
-     char *name;
-{
-  SHELL_VAR *v;
-
-  v = find_variable (name);
-  if (v && exported_p (v))
-    array_needs_making = 1;
-  else if (v == 0)
-    array_needs_making = 1;
-
-  if (array_needs_making)
-    {
-      maybe_make_export_env ();  
-      tzset ();
-    }
-}
-#endif
-
-/* If the variable exists, then the value of it can be the number
-   of times we actually ignore the EOF.  The default is small,
-   (smaller than csh, anyway). */
-void
-sv_ignoreeof (name)
-     char *name;
-{
-  SHELL_VAR *tmp_var;
-  char *temp;
-
-  eof_encountered = 0;
-
-  tmp_var = find_variable (name);
-  ignoreeof = tmp_var && var_isset (tmp_var);
-  temp = tmp_var ? value_cell (tmp_var) : (char *)NULL;
-  if (temp)
-    eof_encountered_limit = (*temp && all_digits (temp)) ? atoi (temp) : 10;
-  set_shellopts ();	/* make sure `ignoreeof' is/is not in $SHELLOPTS */
-}
-
-void
-sv_optind (name)
-     char *name;
-{
-  SHELL_VAR *var;
-  char *tt;
-  int s;
-
-  var = find_variable ("OPTIND");
-  tt = var ? get_variable_value (var) : (char *)NULL;
-
-  /* Assume that if var->context < variable_context and variable_context > 0
-     then we are restoring the variables's previous state while returning
-     from a function. */
-  if (tt && *tt)
-    {
-      s = atoi (tt);
-
-      /* According to POSIX, setting OPTIND=1 resets the internal state
-	 of getopt (). */
-      if (s < 0 || s == 1)
-	s = 0;
-    }
-  else
-    s = 0;
-  getopts_reset (s);
-}
-
-void
-sv_opterr (name)
-     char *name;
-{
-  char *tt;
-
-  tt = get_string_value ("OPTERR");
-  sh_opterr = (tt && *tt) ? atoi (tt) : 1;
-}
-
-void
-sv_strict_posix (name)
-     char *name;
-{
-  SHELL_VAR *var;
-
-  var = find_variable (name);
-  posixly_correct = var && var_isset (var);
-  posix_initialize (posixly_correct);
-#if defined (READLINE)
-  if (interactive_shell)
-    posix_readline_initialize (posixly_correct);
-#endif /* READLINE */
-  set_shellopts ();	/* make sure `posix' is/is not in $SHELLOPTS */
-}
-
-void
-sv_locale (name)
-     char *name;
-{
-  char *v;
-  int r;
-
-  v = get_string_value (name);
-  if (name[0] == 'L' && name[1] == 'A')	/* LANG */
-    r = set_lang (name, v);
-  else
-    r = set_locale_var (name, v);		/* LC_*, TEXTDOMAIN* */
-
-#if 1
-  if (r == 0 && posixly_correct)
-    set_exit_status (EXECUTION_FAILURE);
-#endif
-}
-
-#if defined (ARRAY_VARS)
-void
-set_pipestatus_array (ps, nproc)
-     int *ps;
-     int nproc;
-{
-  SHELL_VAR *v;
-  ARRAY *a;
-  ARRAY_ELEMENT *ae;
-  register int i;
-  char *t, tbuf[INT_STRLEN_BOUND(int) + 1];
-
-  v = find_variable ("PIPESTATUS");
-  if (v == 0)
-    v = make_new_array_variable ("PIPESTATUS");
-  if (array_p (v) == 0)
-    return;		/* Do nothing if not an array variable. */
-  a = array_cell (v);
-
-  if (a == 0 || array_num_elements (a) == 0)
-    {
-      for (i = 0; i < nproc; i++)	/* was ps[i] != -1, not i < nproc */
-	{
-	  t = inttostr (ps[i], tbuf, sizeof (tbuf));
-	  array_insert (a, i, t);
-	}
-      return;
-    }
-
-  /* Fast case */
-  if (array_num_elements (a) == nproc && nproc == 1)
-    {
-#ifndef ALT_ARRAY_IMPLEMENTATION
-      ae = element_forw (a->head);
-#else
-      ae = a->elements[0];
-#endif
-      ARRAY_ELEMENT_REPLACE (ae, itos (ps[0]));
-    }
-  else if (array_num_elements (a) <= nproc)
-    {
-      /* modify in array_num_elements members in place, then add */
-#ifndef ALT_ARRAY_IMPLEMENTATION
-      ae = a->head;
-#endif
-      for (i = 0; i < array_num_elements (a); i++)
-	{
-#ifndef ALT_ARRAY_IMPLEMENTATION
-	  ae = element_forw (ae);
-#else
-	  ae = a->elements[i];
-#endif
-	  ARRAY_ELEMENT_REPLACE (ae, itos (ps[i]));
-	}
-      /* add any more */
-      for ( ; i < nproc; i++)
-	{
-	  t = inttostr (ps[i], tbuf, sizeof (tbuf));
-	  array_insert (a, i, t);
-	}
-    }
-  else
-    {
-#ifndef ALT_ARRAY_IMPLEMENTATION
-      /* deleting elements.  it's faster to rebuild the array. */	  
-      array_flush (a);
-      for (i = 0; i < nproc; i++)
-	{
-	  t = inttostr (ps[i], tbuf, sizeof (tbuf));
-	  array_insert (a, i, t);
-	}
-#else
-      /* deleting elements. replace the first NPROC, free the rest */
-      for (i = 0; i < nproc; i++)
-	{
-	  ae = a->elements[i];
-	  ARRAY_ELEMENT_REPLACE (ae, itos (ps[i]));
-	}
-      for ( ; i <= array_max_index (a); i++)
-	{
-	  array_dispose_element (a->elements[i]);
-	  a->elements[i] = (ARRAY_ELEMENT *)NULL;
-	}
-
-      /* bookkeeping usually taken care of by array_insert */
-      set_max_index (a, nproc - 1);
-      set_first_index (a, 0);
-      set_num_elements (a, nproc);
-#endif /* ALT_ARRAY_IMPLEMENTATION */
-    }
-}
-
-ARRAY *
-save_pipestatus_array ()
-{
-  SHELL_VAR *v;
-  ARRAY *a;
-
-  v = find_variable ("PIPESTATUS");
-  if (v == 0 || array_p (v) == 0 || array_cell (v) == 0)
-    return ((ARRAY *)NULL);
-    
-  a = array_copy (array_cell (v));
-
-  return a;
-}
-
-void
-restore_pipestatus_array (a)
-     ARRAY *a;
-{
-  SHELL_VAR *v;
-  ARRAY *a2;
-
-  v = find_variable ("PIPESTATUS");
-  /* XXX - should we still assign even if existing value is NULL? */
-  if (v == 0 || array_p (v) == 0 || array_cell (v) == 0)
-    return;
-
-  a2 = array_cell (v);
-  var_setarray (v, a); 
-
-  array_dispose (a2);
-}
-#endif
-
-void
-set_pipestatus_from_exit (s)
-     int s;
-{
-#if defined (ARRAY_VARS)
-  static int v[2] = { 0, -1 };
-
-  v[0] = s;
-  set_pipestatus_array (v, 1);
-#endif
-}
-
-void
-sv_xtracefd (name)
-     char *name;
-{
-  SHELL_VAR *v;
-  char *t, *e;
-  int fd;
-  FILE *fp;
-
-  v = find_variable (name);
-  if (v == 0)
-    {
-      xtrace_reset ();
-      return;
-    }
-
-  t = value_cell (v);
-  if (t == 0 || *t == 0)
-    xtrace_reset ();
-  else
-    {
-      fd = (int)strtol (t, &e, 10);
-      if (e != t && *e == '\0' && sh_validfd (fd))
-	{
-	  fp = fdopen (fd, "w");
-	  if (fp == 0)
-	    internal_error (_("%s: %s: cannot open as FILE"), name, value_cell (v));
-	  else
-	    xtrace_set (fd, fp);
-	}
-      else
-	internal_error (_("%s: %s: invalid value for trace file descriptor"), name, value_cell (v));
-    }
-}
-
-#define MIN_COMPAT_LEVEL 31
-
-void
-sv_shcompat (name)
-     char *name;
-{
-  SHELL_VAR *v;
-  char *val;
-  int tens, ones, compatval;
-
-  v = find_variable (name);
-  if (v == 0)
-    {
-      shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
-      set_compatibility_opts ();
-      return;
-    }
-  val = value_cell (v);
-  if (val == 0 || *val == '\0')
-    {
-      shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
-      set_compatibility_opts ();
-      return;
-    }
-  /* Handle decimal-like compatibility version specifications: 4.2 */
-  if (ISDIGIT (val[0]) && val[1] == '.' && ISDIGIT (val[2]) && val[3] == 0)
-    {
-      tens = val[0] - '0';
-      ones = val[2] - '0';
-      compatval = tens*10 + ones;
-    }
-  /* Handle integer-like compatibility version specifications: 42 */
-  else if (ISDIGIT (val[0]) && ISDIGIT (val[1]) && val[2] == 0)
-    {
-      tens = val[0] - '0';
-      ones = val[1] - '0';
-      compatval = tens*10 + ones;
-    }
-  else
-    {
-compat_error:
-      internal_error (_("%s: %s: compatibility value out of range"), name, val);
-      shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
-      set_compatibility_opts ();
-      return;
-    }
-
-  if (compatval < MIN_COMPAT_LEVEL || compatval > DEFAULT_COMPAT_LEVEL)
-    goto compat_error;
-
-  shell_compatibility_level = compatval;
-  set_compatibility_opts ();
-}
-
-#if defined (JOB_CONTROL)
-void
-sv_childmax (name)
-     char *name;
-{
-  char *tt;
-  int s;
-
-  tt = get_string_value (name);
-  s = (tt && *tt) ? atoi (tt) : 0;
-  set_maxchild (s);
-}
-#endif
diff --git a/third_party/bash/variables.h b/third_party/bash/variables.h
deleted file mode 100644
index 55f497de0..000000000
--- a/third_party/bash/variables.h
+++ /dev/null
@@ -1,462 +0,0 @@
-/* variables.h -- data structures for shell variables. */
-
-/* Copyright (C) 1987-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_VARIABLES_H_)
-#define _VARIABLES_H_
-
-#include "stdc.h"
-#include "array.h"
-#include "assoc.h"
-
-/* Shell variables and functions are stored in hash tables. */
-#include "hashlib.h"
-
-#include "conftypes.h"
-
-/* A variable context. */
-typedef struct var_context {
-  char *name;		/* empty or NULL means global context */
-  int scope;		/* 0 means global context */
-  int flags;
-  struct var_context *up;	/* previous function calls */
-  struct var_context *down;	/* down towards global context */
-  HASH_TABLE *table;		/* variables at this scope */
-} VAR_CONTEXT;
-
-/* Flags for var_context->flags */
-#define VC_HASLOCAL	0x01
-#define VC_HASTMPVAR	0x02
-#define VC_FUNCENV	0x04	/* also function if name != NULL */
-#define VC_BLTNENV	0x08	/* builtin_env */
-#define VC_TEMPENV	0x10	/* temporary_env */
-
-#define VC_TEMPFLAGS	(VC_FUNCENV|VC_BLTNENV|VC_TEMPENV)
-
-/* Accessing macros */
-#define vc_isfuncenv(vc)	(((vc)->flags & VC_FUNCENV) != 0)
-#define vc_isbltnenv(vc)	(((vc)->flags & VC_BLTNENV) != 0)
-#define vc_istempenv(vc)	(((vc)->flags & (VC_TEMPFLAGS)) == VC_TEMPENV)
-
-#define vc_istempscope(vc)	(((vc)->flags & (VC_TEMPENV|VC_BLTNENV)) != 0)
-
-#define vc_haslocals(vc)	(((vc)->flags & VC_HASLOCAL) != 0)
-#define vc_hastmpvars(vc)	(((vc)->flags & VC_HASTMPVAR) != 0)
-
-/* What a shell variable looks like. */
-
-typedef struct variable *sh_var_value_func_t PARAMS((struct variable *));
-typedef struct variable *sh_var_assign_func_t PARAMS((struct variable *, char *, arrayind_t, char *));
-
-/* For the future */
-union _value {
-  char *s;			/* string value */
-  intmax_t i;			/* int value */
-  COMMAND *f;			/* function */
-  ARRAY *a;			/* array */
-  HASH_TABLE *h;		/* associative array */
-  double d;			/* floating point number */
-#if defined (HAVE_LONG_DOUBLE)
-  long double ld;		/* long double */
-#endif
-  struct variable *v;		/* possible indirect variable use */
-  void *opaque;			/* opaque data for future use */
-};
-
-typedef struct variable {
-  char *name;			/* Symbol that the user types. */
-  char *value;			/* Value that is returned. */
-  char *exportstr;		/* String for the environment. */
-  sh_var_value_func_t *dynamic_value;	/* Function called to return a `dynamic'
-				   value for a variable, like $SECONDS
-				   or $RANDOM. */
-  sh_var_assign_func_t *assign_func; /* Function called when this `special
-				   variable' is assigned a value in
-				   bind_variable. */
-  int attributes;		/* export, readonly, array, invisible... */
-  int context;			/* Which context this variable belongs to. */
-} SHELL_VAR;
-
-typedef struct _vlist {
-  SHELL_VAR **list;
-  int list_size;	/* allocated size */
-  int list_len;		/* current number of entries */
-} VARLIST;
-
-/* The various attributes that a given variable can have. */
-/* First, the user-visible attributes */
-#define att_exported	0x0000001	/* export to environment */
-#define att_readonly	0x0000002	/* cannot change */
-#define att_array	0x0000004	/* value is an array */
-#define att_function	0x0000008	/* value is a function */
-#define att_integer	0x0000010	/* internal representation is int */
-#define att_local	0x0000020	/* variable is local to a function */
-#define att_assoc	0x0000040	/* variable is an associative array */
-#define att_trace	0x0000080	/* function is traced with DEBUG trap */
-#define att_uppercase	0x0000100	/* word converted to uppercase on assignment */
-#define att_lowercase	0x0000200	/* word converted to lowercase on assignment */
-#define att_capcase	0x0000400	/* word capitalized on assignment */
-#define att_nameref	0x0000800	/* word is a name reference */
-
-#define user_attrs	(att_exported|att_readonly|att_integer|att_local|att_trace|att_uppercase|att_lowercase|att_capcase|att_nameref)
-
-#define attmask_user	0x0000fff
-
-/* Internal attributes used for bookkeeping */
-#define att_invisible	0x0001000	/* cannot see */
-#define att_nounset	0x0002000	/* cannot unset */
-#define att_noassign	0x0004000	/* assignment not allowed */
-#define att_imported	0x0008000	/* came from environment */
-#define att_special	0x0010000	/* requires special handling */
-#define att_nofree	0x0020000	/* do not free value on unset */
-#define att_regenerate	0x0040000	/* regenerate when exported */
-
-#define	attmask_int	0x00ff000
-
-/* Internal attributes used for variable scoping. */
-#define att_tempvar	0x0100000	/* variable came from the temp environment */
-#define att_propagate	0x0200000	/* propagate to previous scope */
-
-#define attmask_scope	0x0f00000
-
-#define exported_p(var)		((((var)->attributes) & (att_exported)))
-#define readonly_p(var)		((((var)->attributes) & (att_readonly)))
-#define array_p(var)		((((var)->attributes) & (att_array)))
-#define function_p(var)		((((var)->attributes) & (att_function)))
-#define integer_p(var)		((((var)->attributes) & (att_integer)))
-#define local_p(var)		((((var)->attributes) & (att_local)))
-#define assoc_p(var)		((((var)->attributes) & (att_assoc)))
-#define trace_p(var)		((((var)->attributes) & (att_trace)))
-#define uppercase_p(var)	((((var)->attributes) & (att_uppercase)))
-#define lowercase_p(var)	((((var)->attributes) & (att_lowercase)))
-#define capcase_p(var)		((((var)->attributes) & (att_capcase)))
-#define nameref_p(var)		((((var)->attributes) & (att_nameref)))
-
-#define invisible_p(var)	((((var)->attributes) & (att_invisible)))
-#define non_unsettable_p(var)	((((var)->attributes) & (att_nounset)))
-#define noassign_p(var)		((((var)->attributes) & (att_noassign)))
-#define imported_p(var)		((((var)->attributes) & (att_imported)))
-#define specialvar_p(var)	((((var)->attributes) & (att_special)))
-#define nofree_p(var)		((((var)->attributes) & (att_nofree)))
-#define regen_p(var)		((((var)->attributes) & (att_regenerate)))
-
-#define tempvar_p(var)		((((var)->attributes) & (att_tempvar)))
-#define propagate_p(var)	((((var)->attributes) & (att_propagate)))
-
-/* Variable names: lvalues */
-#define name_cell(var)		((var)->name)
-
-/* Accessing variable values: rvalues */
-#define value_cell(var)		((var)->value)
-#define function_cell(var)	(COMMAND *)((var)->value)
-#define array_cell(var)		(ARRAY *)((var)->value)
-#define assoc_cell(var)		(HASH_TABLE *)((var)->value)
-#define nameref_cell(var)	((var)->value)		/* so it can change later */
-
-#define NAMEREF_MAX	8	/* only 8 levels of nameref indirection */
-
-#define var_isset(var)		((var)->value != 0)
-#define var_isunset(var)	((var)->value == 0)
-#define var_isnull(var)		((var)->value && *(var)->value == 0)
-
-/* Assigning variable values: lvalues */
-#define var_setvalue(var, str)	((var)->value = (str))
-#define var_setfunc(var, func)	((var)->value = (char *)(func))
-#define var_setarray(var, arr)	((var)->value = (char *)(arr))
-#define var_setassoc(var, arr)	((var)->value = (char *)(arr))
-#define var_setref(var, str)	((var)->value = (str))
-
-/* Make VAR be auto-exported. */
-#define set_auto_export(var) \
-  do { (var)->attributes |= att_exported; array_needs_making = 1; } while (0)
-
-#define SETVARATTR(var, attr, undo) \
-	((undo == 0) ? ((var)->attributes |= (attr)) \
-		     : ((var)->attributes &= ~(attr)))
-
-#define VSETATTR(var, attr)	((var)->attributes |= (attr))
-#define VUNSETATTR(var, attr)	((var)->attributes &= ~(attr))
-
-#define VGETFLAGS(var)		((var)->attributes)
-
-#define VSETFLAGS(var, flags)	((var)->attributes = (flags))
-#define VCLRFLAGS(var)		((var)->attributes = 0)
-
-/* Macros to perform various operations on `exportstr' member of a SHELL_VAR. */
-#define CLEAR_EXPORTSTR(var)	(var)->exportstr = (char *)NULL
-#define COPY_EXPORTSTR(var)	((var)->exportstr) ? savestring ((var)->exportstr) : (char *)NULL
-#define SET_EXPORTSTR(var, value)  (var)->exportstr = (value)
-#define SAVE_EXPORTSTR(var, value) (var)->exportstr = (value) ? savestring (value) : (char *)NULL
-
-#define FREE_EXPORTSTR(var) \
-	do { if ((var)->exportstr) free ((var)->exportstr); } while (0)
-
-#define CACHE_IMPORTSTR(var, value) \
-	(var)->exportstr = savestring (value)
-
-#define INVALIDATE_EXPORTSTR(var) \
-	do { \
-	  if ((var)->exportstr) \
-	    { \
-	      free ((var)->exportstr); \
-	      (var)->exportstr = (char *)NULL; \
-	    } \
-	} while (0)
-
-#define ifsname(s)	((s)[0] == 'I' && (s)[1] == 'F' && (s)[2] == 'S' && (s)[3] == '\0')
-
-/* Flag values for make_local_variable and its array counterparts */
-#define MKLOC_ASSOCOK		0x01
-#define MKLOC_ARRAYOK		0x02
-#define MKLOC_INHERIT		0x04
-
-/* Special value for nameref with invalid value for creation or assignment */
-extern SHELL_VAR nameref_invalid_value;
-#define INVALID_NAMEREF_VALUE	(void *)&nameref_invalid_value
-	
-/* Stuff for hacking variables. */
-typedef int sh_var_map_func_t PARAMS((SHELL_VAR *));
-
-/* Where we keep the variables and functions */
-extern VAR_CONTEXT *global_variables;
-extern VAR_CONTEXT *shell_variables;
-
-extern HASH_TABLE *shell_functions;
-extern HASH_TABLE *temporary_env;
-
-extern int variable_context;
-extern char *dollar_vars[];
-extern char **export_env;
-
-extern int tempenv_assign_error;
-extern int array_needs_making;
-extern int shell_level;
-
-/* XXX */
-extern WORD_LIST *rest_of_args;
-extern int posparam_count;
-extern pid_t dollar_dollar_pid;
-
-extern int localvar_inherit;		/* declared in variables.c */
-
-extern void initialize_shell_variables PARAMS((char **, int));
-
-extern int validate_inherited_value PARAMS((SHELL_VAR *, int));
-
-extern SHELL_VAR *set_if_not PARAMS((char *, char *));
-
-extern void sh_set_lines_and_columns PARAMS((int, int));
-extern void set_pwd PARAMS((void));
-extern void set_ppid PARAMS((void));
-extern void make_funcname_visible PARAMS((int));
-
-extern SHELL_VAR *var_lookup PARAMS((const char *, VAR_CONTEXT *));
-
-extern SHELL_VAR *find_function PARAMS((const char *));
-extern FUNCTION_DEF *find_function_def PARAMS((const char *));
-extern SHELL_VAR *find_variable PARAMS((const char *));
-extern SHELL_VAR *find_variable_noref PARAMS((const char *));
-extern SHELL_VAR *find_variable_last_nameref PARAMS((const char *, int));
-extern SHELL_VAR *find_global_variable_last_nameref PARAMS((const char *, int));
-extern SHELL_VAR *find_variable_nameref PARAMS((SHELL_VAR *));
-extern SHELL_VAR *find_variable_nameref_for_create PARAMS((const char *, int));
-extern SHELL_VAR *find_variable_nameref_for_assignment PARAMS((const char *, int));
-/*extern SHELL_VAR *find_variable_internal PARAMS((const char *, int));*/
-extern SHELL_VAR *find_variable_tempenv PARAMS((const char *));
-extern SHELL_VAR *find_variable_notempenv PARAMS((const char *));
-extern SHELL_VAR *find_global_variable PARAMS((const char *));
-extern SHELL_VAR *find_global_variable_noref PARAMS((const char *));
-extern SHELL_VAR *find_shell_variable PARAMS((const char *));
-extern SHELL_VAR *find_tempenv_variable PARAMS((const char *));
-extern SHELL_VAR *find_variable_no_invisible PARAMS((const char *));
-extern SHELL_VAR *find_variable_for_assignment PARAMS((const char *));
-extern char *nameref_transform_name PARAMS((char *, int));
-extern SHELL_VAR *copy_variable PARAMS((SHELL_VAR *));
-extern SHELL_VAR *make_local_variable PARAMS((const char *, int));
-extern SHELL_VAR *bind_variable PARAMS((const char *, char *, int));
-extern SHELL_VAR *bind_global_variable PARAMS((const char *, char *, int));
-extern SHELL_VAR *bind_function PARAMS((const char *, COMMAND *));
-
-extern void bind_function_def PARAMS((const char *, FUNCTION_DEF *, int));
-
-extern SHELL_VAR **map_over PARAMS((sh_var_map_func_t *, VAR_CONTEXT *));
-SHELL_VAR **map_over_funcs PARAMS((sh_var_map_func_t *));
-     
-extern SHELL_VAR **all_shell_variables PARAMS((void));
-extern SHELL_VAR **all_shell_functions PARAMS((void));
-extern SHELL_VAR **all_visible_variables PARAMS((void));
-extern SHELL_VAR **all_visible_functions PARAMS((void));
-extern SHELL_VAR **all_exported_variables PARAMS((void));
-extern SHELL_VAR **local_exported_variables PARAMS((void));
-extern SHELL_VAR **all_local_variables PARAMS((int));
-#if defined (ARRAY_VARS)
-extern SHELL_VAR **all_array_variables PARAMS((void));
-#endif
-extern char **all_variables_matching_prefix PARAMS((const char *));
-
-extern char **make_var_array PARAMS((HASH_TABLE *));
-extern char **add_or_supercede_exported_var PARAMS((char *, int));
-
-extern char *get_variable_value PARAMS((SHELL_VAR *));
-extern char *get_string_value PARAMS((const char *));
-extern char *sh_get_env_value PARAMS((const char *));
-extern char *make_variable_value PARAMS((SHELL_VAR *, char *, int));
-
-extern SHELL_VAR *bind_variable_value PARAMS((SHELL_VAR *, char *, int));
-extern SHELL_VAR *bind_int_variable PARAMS((char *, char *, int));
-extern SHELL_VAR *bind_var_to_int PARAMS((char *, intmax_t, int));
-
-extern int assign_in_env PARAMS((WORD_DESC *, int));
-
-extern int unbind_variable PARAMS((const char *));
-extern int check_unbind_variable PARAMS((const char *));
-extern int unbind_nameref PARAMS((const char *));
-extern int unbind_variable_noref PARAMS((const char *));
-extern int unbind_global_variable PARAMS((const char *));
-extern int unbind_global_variable_noref PARAMS((const char *));
-extern int unbind_func PARAMS((const char *));
-extern int unbind_function_def PARAMS((const char *));
-extern int delete_var PARAMS((const char *, VAR_CONTEXT *));
-extern int makunbound PARAMS((const char *, VAR_CONTEXT *));
-extern int kill_local_variable PARAMS((const char *));
-
-extern void delete_all_variables PARAMS((HASH_TABLE *));
-extern void delete_all_contexts PARAMS((VAR_CONTEXT *));
-extern void reset_local_contexts PARAMS((void));
-
-extern VAR_CONTEXT *new_var_context PARAMS((char *, int));
-extern void dispose_var_context PARAMS((VAR_CONTEXT *));
-extern VAR_CONTEXT *push_var_context PARAMS((char *, int, HASH_TABLE *));
-extern void pop_var_context PARAMS((void));
-extern VAR_CONTEXT *push_scope PARAMS((int, HASH_TABLE *));
-extern void pop_scope PARAMS((int));
-
-extern void clear_dollar_vars PARAMS((void));
-
-extern void push_context PARAMS((char *, int, HASH_TABLE *));
-extern void pop_context PARAMS((void));
-extern void push_dollar_vars PARAMS((void));
-extern void pop_dollar_vars PARAMS((void));
-extern void dispose_saved_dollar_vars PARAMS((void));
-
-extern void init_bash_argv PARAMS((void));
-extern void save_bash_argv PARAMS((void));
-extern void push_args PARAMS((WORD_LIST *));
-extern void pop_args PARAMS((void));
-
-extern void adjust_shell_level PARAMS((int));
-extern void non_unsettable PARAMS((char *));
-extern void dispose_variable PARAMS((SHELL_VAR *));
-extern void dispose_used_env_vars PARAMS((void));
-extern void dispose_function_env PARAMS((void));
-extern void dispose_builtin_env PARAMS((void));
-extern void merge_temporary_env PARAMS((void));
-extern void flush_temporary_env PARAMS((void));
-extern void merge_builtin_env PARAMS((void));
-extern void kill_all_local_variables PARAMS((void));
-
-extern void set_var_read_only PARAMS((char *));
-extern void set_func_read_only PARAMS((const char *));
-extern void set_var_auto_export PARAMS((char *));
-extern void set_func_auto_export PARAMS((const char *));
-
-extern void sort_variables PARAMS((SHELL_VAR **));
-
-extern int chkexport PARAMS((char *));
-extern void maybe_make_export_env PARAMS((void));
-extern void update_export_env_inplace PARAMS((char *, int, char *));
-extern void put_command_name_into_env PARAMS((char *));
-extern void put_gnu_argv_flags_into_env PARAMS((intmax_t, char *));
-
-extern void print_var_list PARAMS((SHELL_VAR **));
-extern void print_func_list PARAMS((SHELL_VAR **));
-extern void print_assignment PARAMS((SHELL_VAR *));
-extern void print_var_value PARAMS((SHELL_VAR *, int));
-extern void print_var_function PARAMS((SHELL_VAR *));
-
-#if defined (ARRAY_VARS)
-extern SHELL_VAR *make_new_array_variable PARAMS((char *));
-extern SHELL_VAR *make_local_array_variable PARAMS((char *, int));
-
-extern SHELL_VAR *make_new_assoc_variable PARAMS((char *));
-extern SHELL_VAR *make_local_assoc_variable PARAMS((char *, int));
-
-extern void set_pipestatus_array PARAMS((int *, int));
-extern ARRAY *save_pipestatus_array PARAMS((void));
-extern void restore_pipestatus_array PARAMS((ARRAY *));
-#endif
-
-extern void set_pipestatus_from_exit PARAMS((int));
-
-/* The variable in NAME has just had its state changed.  Check to see if it
-   is one of the special ones where something special happens. */
-extern void stupidly_hack_special_variables PARAMS((char *));
-
-/* Reinitialize some special variables that have external effects upon unset
-   when the shell reinitializes itself. */
-extern void reinit_special_variables PARAMS((void));
-
-extern int get_random_number PARAMS((void));
-
-/* The `special variable' functions that get called when a particular
-   variable is set. */
-extern void sv_ifs PARAMS((char *));
-extern void sv_path PARAMS((char *));
-extern void sv_mail PARAMS((char *));
-extern void sv_funcnest PARAMS((char *));
-extern void sv_execignore PARAMS((char *));
-extern void sv_globignore PARAMS((char *));
-extern void sv_ignoreeof PARAMS((char *));
-extern void sv_strict_posix PARAMS((char *));
-extern void sv_optind PARAMS((char *));
-extern void sv_opterr PARAMS((char *));
-extern void sv_locale PARAMS((char *));
-extern void sv_xtracefd PARAMS((char *));
-extern void sv_shcompat PARAMS((char *));
-
-#if defined (READLINE)
-extern void sv_comp_wordbreaks PARAMS((char *));
-extern void sv_terminal PARAMS((char *));
-extern void sv_hostfile PARAMS((char *));
-extern void sv_winsize PARAMS((char *));
-#endif
-
-#if defined (__CYGWIN__)
-extern void sv_home PARAMS((char *));
-#endif
-
-#if defined (HISTORY)
-extern void sv_histsize PARAMS((char *));
-extern void sv_histignore PARAMS((char *));
-extern void sv_history_control PARAMS((char *));
-#  if defined (BANG_HISTORY)
-extern void sv_histchars PARAMS((char *));
-#  endif
-extern void sv_histtimefmt PARAMS((char *));
-#endif /* HISTORY */
-
-#if defined (HAVE_TZSET)
-extern void sv_tz PARAMS((char *));
-#endif
-
-#if defined (JOB_CONTROL)
-extern void sv_childmax PARAMS((char *));
-#endif
-
-#endif /* !_VARIABLES_H_ */
diff --git a/third_party/bash/version.c b/third_party/bash/version.c
deleted file mode 100644
index 38af8edca..000000000
--- a/third_party/bash/version.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/* version.c -- distribution and version numbers. */
-
-/* Copyright (C) 1989-2022 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <stdio.h>
-
-#include "stdc.h"
-
-#include "version.h"
-#include "patchlevel.h"
-#include "conftypes.h"
-
-#include "bashintl.h"
-
-extern char *shell_name;
-
-/* Defines from version.h */
-const char * const dist_version = DISTVERSION;
-const int patch_level = PATCHLEVEL;
-const int build_version = BUILDVERSION;
-#ifdef RELSTATUS
-const char * const release_status = RELSTATUS;
-#else
-const char * const release_status = (char *)0;
-#endif
-const char * const sccs_version = SCCSVERSION;
-
-const char * const bash_copyright = N_("Copyright (C) 2022 Free Software Foundation, Inc.");
-const char * const bash_license = N_("License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n");
-
-/* If == 31, shell compatible with bash-3.1, == 32 with bash-3.2, and so on */
-int shell_compatibility_level = DEFAULT_COMPAT_LEVEL;
-
-/* Functions for getting, setting, and displaying the shell version. */
-
-/* Forward declarations so we don't have to include externs.h */
-extern char *shell_version_string PARAMS((void));
-extern void show_shell_version PARAMS((int));
-
-/* Give version information about this shell. */
-char *
-shell_version_string ()
-{
-  static char tt[32] = { '\0' };
-
-  if (tt[0] == '\0')
-    {
-      if (release_status)
-#if HAVE_SNPRINTF
-	snprintf (tt, sizeof (tt), "%s.%d(%d)-%s", dist_version, patch_level, build_version, release_status);
-#else
-	sprintf (tt, "%s.%d(%d)-%s", dist_version, patch_level, build_version, release_status);
-#endif
-      else
-#if HAVE_SNPRINTF
-	snprintf (tt, sizeof (tt), "%s.%d(%d)", dist_version, patch_level, build_version);
-#else
-	sprintf (tt, "%s.%d(%d)", dist_version, patch_level, build_version);
-#endif
-    }
-  return tt;
-}
-
-void
-show_shell_version (extended)
-     int extended;
-{
-  printf (_("GNU bash, version %s (%s)\n"), shell_version_string (), MACHTYPE);
-  if (extended)
-    {
-      printf ("%s\n", _(bash_copyright));
-      printf ("%s\n", _(bash_license));
-      printf ("%s\n", _("This is free software; you are free to change and redistribute it."));
-      printf ("%s\n", _("There is NO WARRANTY, to the extent permitted by law."));
-    }
-}
diff --git a/third_party/bash/version.h b/third_party/bash/version.h
deleted file mode 100644
index 1a749cdbe..000000000
--- a/third_party/bash/version.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/* Version control for the shell.  This file gets changed when you say
-   `make version.h' to the Makefile.  It is created by mkversion. */
-
-/* The distribution version number of this shell. */
-#define DISTVERSION "5.2"
-
-/* The last built version of this shell. */
-#define BUILDVERSION 1
-
-/* The release status of this shell. */
-#define RELSTATUS "release"
-
-/* The default shell compatibility-level (the current version) */
-#define DEFAULT_COMPAT_LEVEL 52
-
-/* A version string for use by sccs and the what command. */
-#define SCCSVERSION "@(#)Bash version 5.2.0(1) release GNU"
diff --git a/third_party/bash/winsize.c b/third_party/bash/winsize.c
deleted file mode 100644
index e672a324d..000000000
--- a/third_party/bash/winsize.c
+++ /dev/null
@@ -1,104 +0,0 @@
-/* winsize.c - handle window size changes and information. */
-
-/* Copyright (C) 2005-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include "stdc.h"
-
-#include "bashtypes.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <sys/ioctl.h>
-
-/* Try to find the definitions of `struct winsize' and TIOGCWINSZ */
-
-#if 0
-#if defined (GWINSZ_IN_SYS_IOCTL) && !defined (TIOCGWINSZ)
-#  include <sys/ioctl.h>
-#endif /* GWINSZ_IN_SYS_IOCTL && !TIOCGWINSZ */
-#endif
-
-#if defined (STRUCT_WINSIZE_IN_TERMIOS) && !defined (STRUCT_WINSIZE_IN_SYS_IOCTL)
-#  include <termios.h>
-#endif /* STRUCT_WINSIZE_IN_TERMIOS && !STRUCT_WINSIZE_IN_SYS_IOCTL */
-
-/* Not in either of the standard places, look around. */
-#if !defined (STRUCT_WINSIZE_IN_TERMIOS) && !defined (STRUCT_WINSIZE_IN_SYS_IOCTL)
-#  if defined (HAVE_SYS_STREAM_H)
-#    include <sys/stream.h>
-#  endif /* HAVE_SYS_STREAM_H */
-#  if defined (HAVE_SYS_PTEM_H) /* SVR4.2, at least, has it here */
-#    include <sys/ptem.h>
-#    define _IO_PTEM_H          /* work around SVR4.2 1.1.4 bug */
-#  endif /* HAVE_SYS_PTEM_H */
-#  if defined (HAVE_SYS_PTE_H)  /* ??? */
-#    include <sys/pte.h>
-#  endif /* HAVE_SYS_PTE_H */
-#endif /* !STRUCT_WINSIZE_IN_TERMIOS && !STRUCT_WINSIZE_IN_SYS_IOCTL */
-
-#include <stdio.h>
-
-/* Return the fd from which we are actually getting input. */
-#define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
-
-#if !defined (errno)
-extern int errno;
-#endif /* !errno */
-
-extern int shell_tty;
-
-#if defined (READLINE)
-/* Let's not call readline, forcing readline to initialize the termcap/terminfo
-   variables it needs, unless we have to. */
-extern int interactive_shell;
-extern int no_line_editing;
-extern int bash_readline_initialized;
-extern void rl_set_screen_size PARAMS((int, int));
-#endif
-extern void sh_set_lines_and_columns PARAMS((int, int));
-
-void
-get_new_window_size (from_sig, rp, cp)
-     int from_sig;
-     int *rp, *cp;
-{
-#if defined (TIOCGWINSZ)
-  struct winsize win;
-  int tty;
-
-  tty = input_tty ();
-  if (tty >= 0 && (ioctl (tty, TIOCGWINSZ, &win) == 0) &&
-      win.ws_row > 0 && win.ws_col > 0)
-    {
-      sh_set_lines_and_columns (win.ws_row, win.ws_col);
-#if defined (READLINE)
-      if ((interactive_shell && no_line_editing == 0) || bash_readline_initialized)
-	rl_set_screen_size (win.ws_row, win.ws_col);
-#endif
-      if (rp)
-	*rp = win.ws_row;
-      if (cp)
-	*cp = win.ws_col;
-    }
-#endif
-}
diff --git a/third_party/bash/xmalloc.c b/third_party/bash/xmalloc.c
deleted file mode 100644
index 21b598d59..000000000
--- a/third_party/bash/xmalloc.c
+++ /dev/null
@@ -1,225 +0,0 @@
-/* xmalloc.c -- safe versions of malloc and realloc */
-
-/* Copyright (C) 1991-2016 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the GNU Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if defined (HAVE_CONFIG_H)
-#include "config.h"
-#endif
-
-#include "bashtypes.h"
-#include <stdio.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#if defined (HAVE_STDLIB_H)
-#  include <stdlib.h>
-#else
-#  include "ansi_stdlib.h"
-#endif /* HAVE_STDLIB_H */
-
-#include "error.h"
-
-#include "bashintl.h"
-
-#if !defined (PTR_T)
-#  if defined (__STDC__)
-#    define PTR_T void *
-#  else
-#    define PTR_T char *
-#  endif /* !__STDC__ */
-#endif /* !PTR_T */
-
-#if HAVE_SBRK && !HAVE_DECL_SBRK
-extern char *sbrk();
-#endif
-
-#if HAVE_SBRK && defined (USING_BASH_MALLOC)
-static PTR_T lbreak;
-static int brkfound;
-static size_t allocated;
-#endif
-
-/* **************************************************************** */
-/*								    */
-/*		   Memory Allocation and Deallocation.		    */
-/*								    */
-/* **************************************************************** */
-
-#if HAVE_SBRK && defined (USING_BASH_MALLOC)
-#define FINDBRK() \
-do { \
-  if (brkfound == 0) \
-    { \
-      lbreak = (PTR_T)sbrk (0); \
-      brkfound++; \
-    } \
-} while (0)
-
-static size_t
-findbrk ()
-{
-  FINDBRK();
-  return (char *)sbrk (0) - (char *)lbreak;
-}
-#else
-#define FINDBRK()
-#endif
-
-static void
-allocerr (func, bytes)
-     const char *func;
-     size_t bytes;
-{
-#if HAVE_SBRK && defined (USING_BASH_MALLOC)
-      allocated = findbrk ();
-      fatal_error (_("%s: cannot allocate %lu bytes (%lu bytes allocated)"), func, (unsigned long)bytes, (unsigned long)allocated);
-#else
-      fatal_error (_("%s: cannot allocate %lu bytes"), func, (unsigned long)bytes);
-#endif /* !HAVE_SBRK */
-}
-
-/* Return a pointer to free()able block of memory large enough
-   to hold BYTES number of bytes.  If the memory cannot be allocated,
-   print an error message and abort. */
-PTR_T
-xmalloc (bytes)
-     size_t bytes;
-{
-  PTR_T temp;
-
-#if defined (DEBUG)
-  if (bytes == 0)
-    internal_warning("xmalloc: size argument is 0");
-#endif
-
-  FINDBRK();
-  temp = malloc (bytes);
-
-  if (temp == 0)
-    allocerr ("xmalloc", bytes);
-
-  return (temp);
-}
-
-PTR_T
-xrealloc (pointer, bytes)
-     PTR_T pointer;
-     size_t bytes;
-{
-  PTR_T temp;
-
-#if defined (DEBUG)
-  if (bytes == 0)
-    internal_warning("xrealloc: size argument is 0");
-#endif
-
-  FINDBRK();
-  temp = pointer ? realloc (pointer, bytes) : malloc (bytes);
-
-  if (temp == 0)
-    allocerr ("xrealloc", bytes);
-
-  return (temp);
-}
-
-/* Use this as the function to call when adding unwind protects so we
-   don't need to know what free() returns. */
-void
-xfree (string)
-     PTR_T string;
-{
-  if (string)
-    free (string);
-}
-
-#ifdef USING_BASH_MALLOC
-#include <malloc/shmalloc.h>
-
-static void
-sh_allocerr (func, bytes, file, line)
-     const char *func;
-     size_t bytes;
-     char *file;
-     int line;
-{
-#if HAVE_SBRK
-      allocated = findbrk ();
-      fatal_error (_("%s: %s:%d: cannot allocate %lu bytes (%lu bytes allocated)"), func, file, line, (unsigned long)bytes, (unsigned long)allocated);
-#else
-      fatal_error (_("%s: %s:%d: cannot allocate %lu bytes"), func, file, line, (unsigned long)bytes);
-#endif /* !HAVE_SBRK */
-}
-
-PTR_T
-sh_xmalloc (bytes, file, line)
-     size_t bytes;
-     char *file;
-     int line;
-{
-  PTR_T temp;
-
-#if defined (DEBUG)
-  if (bytes == 0)
-    internal_warning("xmalloc: %s:%d: size argument is 0", file, line);
-#endif
-
-  FINDBRK();
-  temp = sh_malloc (bytes, file, line);
-
-  if (temp == 0)
-    sh_allocerr ("xmalloc", bytes, file, line);
-
-  return (temp);
-}
-
-PTR_T
-sh_xrealloc (pointer, bytes, file, line)
-     PTR_T pointer;
-     size_t bytes;
-     char *file;
-     int line;
-{
-  PTR_T temp;
-
-#if defined (DEBUG)
-  if (bytes == 0)
-    internal_warning("xrealloc: %s:%d: size argument is 0", file, line);
-#endif
-
-  FINDBRK();
-  temp = pointer ? sh_realloc (pointer, bytes, file, line) : sh_malloc (bytes, file, line);
-
-  if (temp == 0)
-    sh_allocerr ("xrealloc", bytes, file, line);
-
-  return (temp);
-}
-
-void
-sh_xfree (string, file, line)
-     PTR_T string;
-     char *file;
-     int line;
-{
-  if (string)
-    sh_free (string, file, line);
-}
-#endif
diff --git a/third_party/bash/xmalloc.h b/third_party/bash/xmalloc.h
deleted file mode 100644
index 55d2e3d04..000000000
--- a/third_party/bash/xmalloc.h
+++ /dev/null
@@ -1,66 +0,0 @@
-/* xmalloc.h -- defines for the `x' memory allocation functions */
-
-/* Copyright (C) 2001-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#if !defined (_XMALLOC_H_)
-#define _XMALLOC_H_
-
-#include "stdc.h"
-#include "bashansi.h"
-
-/* Generic pointer type. */
-#ifndef PTR_T
-
-#if defined (__STDC__)
-#  define PTR_T	void *
-#else
-#  define PTR_T char *
-#endif
-
-#endif /* PTR_T */
-
-/* Allocation functions in xmalloc.c */
-extern PTR_T xmalloc PARAMS((size_t));
-extern PTR_T xrealloc PARAMS((void *, size_t));
-extern void xfree PARAMS((void *));
-
-#if defined(USING_BASH_MALLOC) && !defined (DISABLE_MALLOC_WRAPPERS)
-extern PTR_T sh_xmalloc PARAMS((size_t, const char *, int));
-extern PTR_T sh_xrealloc PARAMS((void *, size_t, const char *, int));
-extern void sh_xfree PARAMS((void *, const char *, int));
-
-#define xmalloc(x)	sh_xmalloc((x), __FILE__, __LINE__)
-#define xrealloc(x, n)	sh_xrealloc((x), (n), __FILE__, __LINE__)
-#define xfree(x)	sh_xfree((x), __FILE__, __LINE__)
-
-#ifdef free
-#undef free
-#endif
-#define free(x)		sh_xfree((x), __FILE__, __LINE__)
-
-extern PTR_T sh_malloc PARAMS((size_t, const char *, int));
-
-#ifdef malloc
-#undef malloc
-#endif
-#define malloc(x)	sh_malloc((x), __FILE__, __LINE__)
-
-#endif	/* USING_BASH_MALLOC */
-
-#endif	/* _XMALLOC_H_ */
diff --git a/third_party/bash/xmbsrtowcs.c b/third_party/bash/xmbsrtowcs.c
deleted file mode 100644
index 688117885..000000000
--- a/third_party/bash/xmbsrtowcs.c
+++ /dev/null
@@ -1,523 +0,0 @@
-/* xmbsrtowcs.c -- replacement function for mbsrtowcs */
-
-/* Copyright (C) 2002-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* Ask for GNU extensions to get extern declaration for mbsnrtowcs if
-   available via glibc. */
-#ifndef _GNU_SOURCE
-#  define _GNU_SOURCE 1
-#endif
-
-#include "config.h"
-
-#include "bashansi.h"
-
-/* <wchar.h>, <wctype.h> and <stdlib.h> are included in "shmbutil.h".
-   If <wchar.h>, <wctype.h>, mbsrtowcs(), exist, HANDLE_MULTIBYTE
-   is defined as 1. */
-#include "shmbutil.h"
-
-#if HANDLE_MULTIBYTE
-
-#include <errno.h>
-#if !defined (errno)
-extern int errno;
-#endif
-
-#define WSBUF_INC 32
-
-#ifndef FREE
-#  define FREE(x)	do { if (x) free (x); } while (0)
-#endif
-
-#if ! HAVE_STRCHRNUL
-extern char *strchrnul PARAMS((const char *, int));
-#endif
-
-/* On some locales (ex. ja_JP.sjis), mbsrtowc doesn't convert 0x5c to U<0x5c>.
-   So, this function is made for converting 0x5c to U<0x5c>. */
-
-static mbstate_t local_state;
-static int local_state_use = 0;
-
-size_t
-xmbsrtowcs (dest, src, len, pstate)
-    wchar_t *dest;
-    const char **src;
-    size_t len;
-    mbstate_t *pstate;
-{
-  mbstate_t *ps;
-  size_t mblength, wclength, n;
-
-  ps = pstate;
-  if (pstate == NULL)
-    {
-      if (!local_state_use)
-	{
-	  memset (&local_state, '\0', sizeof(mbstate_t));
-	  local_state_use = 1;
-	}
-      ps = &local_state;
-    }
-
-  n = strlen (*src);
-
-  if (dest == NULL)
-    {
-      wchar_t *wsbuf;
-      const char *mbs;
-      mbstate_t psbuf;
-
-      /* It doesn't matter if malloc fails here, since mbsrtowcs should do
-	 the right thing with a NULL first argument. */
-      wsbuf = (wchar_t *) malloc ((n + 1) * sizeof(wchar_t));
-      mbs = *src;
-      psbuf = *ps;
-
-      wclength = mbsrtowcs (wsbuf, &mbs, n, &psbuf);
-
-      if (wsbuf)
-	free (wsbuf);
-      return wclength;
-    }
-      
-  for (wclength = 0; wclength < len; wclength++, dest++)
-    {
-      if (mbsinit(ps))
-	{
-	  if (**src == '\0')
-	    {
-	      *dest = L'\0';
-	      *src = NULL;
-	      return (wclength);
-	    }
-	  else if (**src == '\\')
-	    {
-	      *dest = L'\\';
-	      mblength = 1;
-	    }
-	  else
-	    mblength = mbrtowc(dest, *src, n, ps);
-	}
-      else
-	mblength = mbrtowc(dest, *src, n, ps);
-
-      /* Cannot convert multibyte character to wide character. */
-      if (mblength == (size_t)-1 || mblength == (size_t)-2)
-	return (size_t)-1;
-
-      *src += mblength;
-      n -= mblength;
-
-      /* The multibyte string  has  been  completely  converted,
-	 including  the terminating '\0'. */
-      if (*dest == L'\0')
-	{
-	  *src = NULL;
-	  break;
-	}
-    }
-
-    return (wclength);
-}
-
-#if HAVE_MBSNRTOWCS
-/* Convert a multibyte string to a wide character string. Memory for the
-   new wide character string is obtained with malloc.
-
-   Fast multiple-character version of xdupmbstowcs used when the indices are
-   not required and mbsnrtowcs is available. */
-
-static size_t
-xdupmbstowcs2 (destp, src)
-    wchar_t **destp;	/* Store the pointer to the wide character string */
-    const char *src;	/* Multibyte character string */
-{
-  const char *p;	/* Conversion start position of src */
-  wchar_t *wsbuf;	/* Buffer for wide characters. */
-  size_t wsbuf_size;	/* Size of WSBUF */
-  size_t wcnum;		/* Number of wide characters in WSBUF */
-  mbstate_t state;	/* Conversion State */
-  size_t n, wcslength;	/* Number of wide characters produced by the conversion. */
-  const char *end_or_backslash;
-  size_t nms;	/* Number of multibyte characters to convert at one time. */
-  mbstate_t tmp_state;
-  const char *tmp_p;
-
-  memset (&state, '\0', sizeof(mbstate_t));
-
-  wsbuf_size = 0;
-  wsbuf = NULL;
-
-  p = src;
-  wcnum = 0;
-  do
-    {
-      end_or_backslash = strchrnul(p, '\\');
-      nms = end_or_backslash - p;
-      if (*end_or_backslash == '\0')
-	nms++;
-
-      /* Compute the number of produced wide-characters. */
-      tmp_p = p;
-      tmp_state = state;
-
-      if (nms == 0 && *p == '\\')	/* special initial case */
-	nms = wcslength = 1;
-      else
-	wcslength = mbsnrtowcs (NULL, &tmp_p, nms, 0, &tmp_state);
-
-      if (wcslength == 0)
-	{
-	  tmp_p = p;		/* will need below */
-	  tmp_state = state;
-	  wcslength = 1;	/* take a single byte */
-	}
-
-      /* Conversion failed. */
-      if (wcslength == (size_t)-1)
-	{
-	  free (wsbuf);
-	  *destp = NULL;
-	  return (size_t)-1;
-	}
-
-      /* Resize the buffer if it is not large enough. */
-      if (wsbuf_size < wcnum+wcslength+1)	/* 1 for the L'\0' or the potential L'\\' */
-	{
-	  wchar_t *wstmp;
-
-	  while (wsbuf_size < wcnum+wcslength+1) /* 1 for the L'\0' or the potential L'\\' */
-	    wsbuf_size += WSBUF_INC;
-
-	  wstmp = (wchar_t *) realloc (wsbuf, wsbuf_size * sizeof (wchar_t));
-	  if (wstmp == NULL)
-	    {
-	      free (wsbuf);
-	      *destp = NULL;
-	      return (size_t)-1;
-	    }
-	  wsbuf = wstmp;
-	}
-
-      /* Perform the conversion. This is assumed to return 'wcslength'.
-	 It may set 'p' to NULL. */
-      n = mbsnrtowcs(wsbuf+wcnum, &p, nms, wsbuf_size-wcnum, &state);
-
-      if (n == 0 && p == 0)
-	{
-	  wsbuf[wcnum] = L'\0';
-	  break;
-	}
-
-      /* Compensate for taking single byte on wcs conversion failure above. */
-      if (wcslength == 1 && (n == 0 || n == (size_t)-1))
-	{
-	  state = tmp_state;
-	  p = tmp_p;
-	  wsbuf[wcnum] = *p;
-	  if (*p == 0)
-	    break;
-	  else
-	    {
-	      wcnum++; p++;
-	    }
-	}
-      else
-        wcnum += wcslength;
-
-      if (mbsinit (&state) && (p != NULL) && (*p == '\\'))
-	{
-	  wsbuf[wcnum++] = L'\\';
-	  p++;
-	}
-    }
-  while (p != NULL);
-
-  *destp = wsbuf;
-
-  /* Return the length of the wide character string, not including `\0'. */
-  return wcnum;
-}
-#endif /* HAVE_MBSNRTOWCS */
-
-/* Convert a multibyte string to a wide character string. Memory for the
-   new wide character string is obtained with malloc.
-
-   The return value is the length of the wide character string. Returns a
-   pointer to the wide character string in DESTP. If INDICESP is not NULL,
-   INDICESP stores the pointer to the pointer array. Each pointer is to
-   the first byte of each multibyte character. Memory for the pointer array
-   is obtained with malloc, too.
-   If conversion is failed, the return value is (size_t)-1 and the values
-   of DESTP and INDICESP are NULL. */
-
-size_t
-xdupmbstowcs (destp, indicesp, src)
-    wchar_t **destp;	/* Store the pointer to the wide character string */
-    char ***indicesp;	/* Store the pointer to the pointer array. */
-    const char *src;	/* Multibyte character string */
-{
-  const char *p;	/* Conversion start position of src */
-  wchar_t wc;		/* Created wide character by conversion */
-  wchar_t *wsbuf;	/* Buffer for wide characters. */
-  char **indices; 	/* Buffer for indices. */
-  size_t wsbuf_size;	/* Size of WSBUF */
-  size_t wcnum;		/* Number of wide characters in WSBUF */
-  mbstate_t state;	/* Conversion State */
-
-  /* In case SRC or DESP is NULL, conversion doesn't take place. */
-  if (src == NULL || destp == NULL)
-    {
-      if (destp)
-	*destp = NULL;
-      if (indicesp)
-	*indicesp = NULL;
-      return (size_t)-1;
-    }
-
-#if HAVE_MBSNRTOWCS
-  if (indicesp == NULL)
-    return (xdupmbstowcs2 (destp, src));
-#endif
-
-  memset (&state, '\0', sizeof(mbstate_t));
-  wsbuf_size = WSBUF_INC;
-
-  wsbuf = (wchar_t *) malloc (wsbuf_size * sizeof(wchar_t));
-  if (wsbuf == NULL)
-    {
-      *destp = NULL;
-      if (indicesp)
-        *indicesp = NULL;
-      return (size_t)-1;
-    }
-
-  indices = NULL;
-  if (indicesp)
-    {
-      indices = (char **) malloc (wsbuf_size * sizeof(char *));
-      if (indices == NULL)
-	{
-	  free (wsbuf);
-	  *destp = NULL;
-	  *indicesp = NULL;
-	  return (size_t)-1;
-	}
-    }
-
-  p = src;
-  wcnum = 0;
-  do
-    {
-      size_t mblength;	/* Byte length of one multibyte character. */
-
-      if (mbsinit (&state))
-	{
-	  if (*p == '\0')
-	    {
-	      wc = L'\0';
-	      mblength = 1;
-	    }
-	  else if (*p == '\\')
-	    {
-	      wc = L'\\';
-	      mblength = 1;
-	    }
-	  else
-	    mblength = mbrtowc(&wc, p, MB_LEN_MAX, &state);
-	}
-      else
-	mblength = mbrtowc(&wc, p, MB_LEN_MAX, &state);
-
-      /* Conversion failed. */
-      if (MB_INVALIDCH (mblength))
-	{
-	  free (wsbuf);
-	  FREE (indices);
-	  *destp = NULL;
-	  if (indicesp)
-	    *indicesp = NULL;
-	  return (size_t)-1;
-	}
-
-      ++wcnum;
-
-      /* Resize buffers when they are not large enough. */
-      if (wsbuf_size < wcnum)
-	{
-	  wchar_t *wstmp;
-	  char **idxtmp;
-
-	  wsbuf_size += WSBUF_INC;
-
-	  wstmp = (wchar_t *) realloc (wsbuf, wsbuf_size * sizeof (wchar_t));
-	  if (wstmp == NULL)
-	    {
-	      free (wsbuf);
-	      FREE (indices);
-	      *destp = NULL;
-	      if (indicesp)
-		*indicesp = NULL;
-	      return (size_t)-1;
-	    }
-	  wsbuf = wstmp;
-
-	  if (indicesp)
-	    {
-	      idxtmp = (char **) realloc (indices, wsbuf_size * sizeof (char *));
-	      if (idxtmp == NULL)
-		{
-		  free (wsbuf);
-		  free (indices);
-		  *destp = NULL;
-		  if (indicesp)
-		    *indicesp = NULL;
-		  return (size_t)-1;
-		}
-	      indices = idxtmp;
-	    }
-	}
-
-      wsbuf[wcnum - 1] = wc;
-      if (indices)
-        indices[wcnum - 1] = (char *)p;
-      p += mblength;
-    }
-  while (MB_NULLWCH (wc) == 0);
-
-  /* Return the length of the wide character string, not including `\0'. */
-  *destp = wsbuf;
-  if (indicesp != NULL)
-    *indicesp = indices;
-
-  return (wcnum - 1);
-}
-
-/* Convert wide character string to multibyte character string. Treat invalid
-   wide characters as bytes.  Used only in unusual circumstances.
-
-   Written by Bruno Haible <bruno@clisp.org>, 2008, adapted by Chet Ramey
-   for use in Bash. */
-
-/* Convert wide character string *SRCP to a multibyte character string and
-   store the result in DEST. Store at most LEN bytes in DEST. */
-size_t
-xwcsrtombs (char *dest, const wchar_t **srcp, size_t len, mbstate_t *ps)
-{
-  const wchar_t *src;
-  size_t cur_max;			/* XXX - locale_cur_max */
-  char buf[64], *destptr, *tmp_dest;
-  unsigned char uc;
-  mbstate_t prev_state;
-
-  cur_max = MB_CUR_MAX;
-  if (cur_max > sizeof (buf))		/* Holy cow. */
-    return (size_t)-1;
-
-  src = *srcp;
-
-  if (dest != NULL)
-    {
-      destptr = dest;
-
-      for (; len > 0; src++)
-	{
-	  wchar_t wc;
-	  size_t ret;
-
-	  wc = *src;
-	  /* If we have room, store directly into DEST. */
-	  tmp_dest = destptr;
-	  ret = wcrtomb (len >= cur_max ? destptr : buf, wc, ps);
-
-	  if (ret == (size_t)(-1))		/* XXX */
-	    {
-	      /* Since this is used for globbing and other uses of filenames,
-		 treat invalid wide character sequences as bytes.  This is
-		 intended to be symmetric with xdupmbstowcs2. */
-handle_byte:
-	      destptr = tmp_dest;	/* in case wcrtomb modified it */
-	      uc = wc;
-	      ret = 1;
-	      if (len >= cur_max)
-		*destptr = uc;
-	      else
-		buf[0] = uc;
-	      if (ps)
-		memset (ps, 0, sizeof (mbstate_t));
-	    }
-
-	  if (ret > cur_max)		/* Holy cow */
-	    goto bad_input;
-
-	  if (len < ret)
-	    break;
-
-	  if (len < cur_max)
-	    memcpy (destptr, buf, ret);
-
-	  if (wc == 0)
-	    {
-	      src = NULL;
-	      /* Here mbsinit (ps).  */
-	      break;
-	    }
-	  destptr += ret;
-	  len -= ret;
-	}
-      *srcp = src;
-      return destptr - dest;
-    }
-  else
-    {
-      /* Ignore dest and len, don't store *srcp at the end, and
-	 don't clobber *ps.  */
-      mbstate_t state = *ps;
-      size_t totalcount = 0;
-
-      for (;; src++)
-	{
-	  wchar_t wc;
-	  size_t ret;
-
-	  wc = *src;
-	  ret = wcrtomb (buf, wc, &state);
-
-	  if (ret == (size_t)(-1))
-	    goto bad_input2;
-	  if (wc == 0)
-	    {
-	      /* Here mbsinit (&state).  */
-	      break;
-	    }
-	  totalcount += ret;
-	}
-      return totalcount;
-    }
-
-bad_input:
-  *srcp = src;
-bad_input2:
-  errno = EILSEQ;
-  return (size_t)(-1);
-}
-
-#endif /* HANDLE_MULTIBYTE */
diff --git a/third_party/bash/y.tab.c b/third_party/bash/y.tab.c
deleted file mode 100644
index 968b4efc3..000000000
--- a/third_party/bash/y.tab.c
+++ /dev/null
@@ -1,9133 +0,0 @@
-/* A Bison parser, made by GNU Bison 3.8.2.  */
-
-/* Bison implementation for Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
-   Inc.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* C LALR(1) parser skeleton written by Richard Stallman, by
-   simplifying the original so-called "semantic" parser.  */
-
-/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
-   especially those whose name start with YY_ or yy_.  They are
-   private implementation details that can be changed or removed.  */
-
-/* All symbols defined below should begin with yy or YY, to avoid
-   infringing on user name space.  This should be done even for local
-   variables, as they might otherwise be expanded by user macros.
-   There are some unavoidable exceptions within include files to
-   define necessary library symbols; they are noted "INFRINGES ON
-   USER NAME SPACE" below.  */
-
-/* Identify Bison output, and Bison version.  */
-#define YYBISON 30802
-
-/* Bison version string.  */
-#define YYBISON_VERSION "3.8.2"
-
-/* Skeleton name.  */
-#define YYSKELETON_NAME "yacc.c"
-
-/* Pure parsers.  */
-#define YYPURE 0
-
-/* Push parsers.  */
-#define YYPUSH 0
-
-/* Pull parsers.  */
-#define YYPULL 1
-
-
-
-
-/* First part of user prologue.  */
-#line 21 "/usr/local/src/chet/src/bash/src/parse.y"
-
-#include "config.h"
-
-#include "bashtypes.h"
-#include "bashansi.h"
-
-#include "filecntl.h"
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#if defined (HAVE_LOCALE_H)
-#  include <locale.h>
-#endif
-
-#include <stdio.h>
-#include "chartypes.h"
-#include <signal.h>
-
-#include "memalloc.h"
-
-#include "bashintl.h"
-
-#define NEED_STRFTIME_DECL	/* used in externs.h */
-
-#include "shell.h"
-#include "execute_cmd.h"
-#include "typemax.h"		/* SIZE_MAX if needed */
-#include "trap.h"
-#include "flags.h"
-#include "parser.h"
-#include "mailcheck.h"
-#include "test.h"
-#include "builtins.h"
-#include "common.h"
-#include "builtext.h"
-
-#include "shmbutil.h"
-
-#if defined (READLINE)
-#  include "bashline.h"
-#  include "third_party/readline/readline.h"
-#endif /* READLINE */
-
-#if defined (HISTORY)
-#  include "bashhist.h"
-#  include "third_party/readline/history.h"
-#endif /* HISTORY */
-
-#if defined (JOB_CONTROL)
-#  include "jobs.h"
-#else
-extern int cleanup_dead_jobs PARAMS((void));
-#endif /* JOB_CONTROL */
-
-#if defined (ALIAS)
-#  include "alias.h"
-#else
-typedef void *alias_t;
-#endif /* ALIAS */
-
-#if defined (PROMPT_STRING_DECODE)
-#  ifndef _MINIX
-#    include <sys/param.h>
-#  endif
-#  include <time.h>
-#  if defined (TM_IN_SYS_TIME)
-#    include <sys/types.h>
-#    include <sys/time.h>
-#  endif /* TM_IN_SYS_TIME */
-#  include "maxpath.h"
-#endif /* PROMPT_STRING_DECODE */
-
-#define RE_READ_TOKEN	-99
-#define NO_EXPANSION	-100
-
-#define END_ALIAS	-2
-
-#ifdef DEBUG
-#  define YYDEBUG 1
-#else
-#  define YYDEBUG 0
-#endif
-
-#if defined (HANDLE_MULTIBYTE)
-#  define last_shell_getc_is_singlebyte \
-	((shell_input_line_index > 1) \
-		? shell_input_line_property[shell_input_line_index - 1] \
-		: 1)
-#  define MBTEST(x)	((x) && last_shell_getc_is_singlebyte)
-#else
-#  define last_shell_getc_is_singlebyte	1
-#  define MBTEST(x)	((x))
-#endif
-
-#define EXTEND_SHELL_INPUT_LINE_PROPERTY() \
-do { \
-    if (shell_input_line_len + 2 > shell_input_line_propsize) \
-      { \
-	shell_input_line_propsize = shell_input_line_len + 2; \
-	shell_input_line_property = (char *)xrealloc (shell_input_line_property, \
-				    shell_input_line_propsize); \
-      } \
-} while (0)
-
-#if defined (EXTENDED_GLOB)
-extern int extended_glob;
-#endif
-
-#if defined (TRANSLATABLE_STRINGS)
-extern int dump_translatable_strings, dump_po_strings;
-extern int singlequote_translations;
-#endif /* TRANSLATABLE_STRINGS */
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-/* **************************************************************** */
-/*								    */
-/*		    "Forward" declarations			    */
-/*								    */
-/* **************************************************************** */
-
-#ifdef DEBUG
-static void debug_parser PARAMS((int));
-#endif
-
-static int yy_getc PARAMS((void));
-static int yy_ungetc PARAMS((int));
-
-#if defined (READLINE)
-static int yy_readline_get PARAMS((void));
-static int yy_readline_unget PARAMS((int));
-#endif
-
-static int yy_string_get PARAMS((void));
-static int yy_string_unget PARAMS((int));
-static int yy_stream_get PARAMS((void));
-static int yy_stream_unget PARAMS((int));
-
-static int shell_getc PARAMS((int));
-static void shell_ungetc PARAMS((int));
-static void discard_until PARAMS((int));
-
-static void push_string PARAMS((char *, int, alias_t *));
-static void pop_string PARAMS((void));
-static void free_string_list PARAMS((void));
-
-static char *read_a_line PARAMS((int));
-
-static int reserved_word_acceptable PARAMS((int));
-static int yylex PARAMS((void));
-
-static void push_heredoc PARAMS((REDIRECT *));
-static char *mk_alexpansion PARAMS((char *));
-static int alias_expand_token PARAMS((char *));
-static int time_command_acceptable PARAMS((void));
-static int special_case_tokens PARAMS((char *));
-static int read_token PARAMS((int));
-static char *parse_matched_pair PARAMS((int, int, int, int *, int));
-static char *parse_comsub PARAMS((int, int, int, int *, int));
-#if defined (ARRAY_VARS)
-static char *parse_compound_assignment PARAMS((int *));
-#endif
-#if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
-static int parse_dparen PARAMS((int));
-static int parse_arith_cmd PARAMS((char **, int));
-#endif
-#if defined (COND_COMMAND)
-static void cond_error PARAMS((void));
-static COND_COM *cond_expr PARAMS((void));
-static COND_COM *cond_or PARAMS((void));
-static COND_COM *cond_and PARAMS((void));
-static COND_COM *cond_term PARAMS((void));
-static int cond_skip_newlines PARAMS((void));
-static COMMAND *parse_cond_command PARAMS((void));
-#endif
-#if defined (ARRAY_VARS)
-static int token_is_assignment PARAMS((char *, int));
-static int token_is_ident PARAMS((char *, int));
-#endif
-static int read_token_word PARAMS((int));
-static void discard_parser_constructs PARAMS((int));
-
-static char *error_token_from_token PARAMS((int));
-static char *error_token_from_text PARAMS((void));
-static void print_offending_line PARAMS((void));
-static void report_syntax_error PARAMS((char *));
-
-static void handle_eof_input_unit PARAMS((void));
-static void prompt_again PARAMS((int));
-#if 0
-static void reset_readline_prompt PARAMS((void));
-#endif
-static void print_prompt PARAMS((void));
-
-#if defined (HANDLE_MULTIBYTE)
-static void set_line_mbstate PARAMS((void));
-static char *shell_input_line_property = NULL;
-static size_t shell_input_line_propsize = 0;
-#else
-#  define set_line_mbstate()
-#endif
-
-extern int yyerror PARAMS((const char *));
-
-#ifdef DEBUG
-extern int yydebug;
-#endif
-
-/* Default prompt strings */
-char *primary_prompt = PPROMPT;
-char *secondary_prompt = SPROMPT;
-
-/* PROMPT_STRING_POINTER points to one of these, never to an actual string. */
-char *ps1_prompt, *ps2_prompt;
-
-/* Displayed after reading a command but before executing it in an interactive shell */
-char *ps0_prompt;
-
-/* Handle on the current prompt string.  Indirectly points through
-   ps1_ or ps2_prompt. */
-char **prompt_string_pointer = (char **)NULL;
-char *current_prompt_string;
-
-/* Non-zero means we expand aliases in commands. */
-int expand_aliases = 0;
-
-/* If non-zero, the decoded prompt string undergoes parameter and
-   variable substitution, command substitution, arithmetic substitution,
-   string expansion, process substitution, and quote removal in
-   decode_prompt_string. */
-int promptvars = 1;
-
-/* If non-zero, $'...' and $"..." are expanded when they appear within
-   a ${...} expansion, even when the expansion appears within double
-   quotes. */
-int extended_quote = 1;
-
-/* The number of lines read from input while creating the current command. */
-int current_command_line_count;
-
-/* The number of lines in a command saved while we run parse_and_execute */
-int saved_command_line_count;
-
-/* The token that currently denotes the end of parse. */
-int shell_eof_token;
-
-/* The token currently being read. */
-int current_token;
-
-/* The current parser state. */
-int parser_state;
-
-/* Variables to manage the task of reading here documents, because we need to
-   defer the reading until after a complete command has been collected. */
-static REDIRECT *redir_stack[HEREDOC_MAX];
-int need_here_doc;
-
-/* Where shell input comes from.  History expansion is performed on each
-   line when the shell is interactive. */
-static char *shell_input_line = (char *)NULL;
-static size_t shell_input_line_index;
-static size_t shell_input_line_size;	/* Amount allocated for shell_input_line. */
-static size_t shell_input_line_len;	/* strlen (shell_input_line) */
-
-/* Either zero or EOF. */
-static int shell_input_line_terminator;
-
-/* The line number in a script on which a function definition starts. */
-static int function_dstart;
-
-/* The line number in a script on which a function body starts. */
-static int function_bstart;
-
-/* The line number in a script at which an arithmetic for command starts. */
-static int arith_for_lineno;
-
-/* The decoded prompt string.  Used if READLINE is not defined or if
-   editing is turned off.  Analogous to current_readline_prompt. */
-static char *current_decoded_prompt;
-
-/* The last read token, or NULL.  read_token () uses this for context
-   checking. */
-static int last_read_token;
-
-/* The token read prior to last_read_token. */
-static int token_before_that;
-
-/* The token read prior to token_before_that. */
-static int two_tokens_ago;
-
-static int global_extglob;
-
-/* The line number in a script where the word in a `case WORD', `select WORD'
-   or `for WORD' begins.  This is a nested command maximum, since the array
-   index is decremented after a case, select, or for command is parsed. */
-#define MAX_CASE_NEST	128
-static int word_lineno[MAX_CASE_NEST+1];
-static int word_top = -1;
-
-/* If non-zero, it is the token that we want read_token to return
-   regardless of what text is (or isn't) present to be read.  This
-   is reset by read_token.  If token_to_read == WORD or
-   ASSIGNMENT_WORD, yylval.word should be set to word_desc_to_read. */
-static int token_to_read;
-static WORD_DESC *word_desc_to_read;
-
-static REDIRECTEE source;
-static REDIRECTEE redir;
-
-static FILE *yyoutstream;
-static FILE *yyerrstream;
-
-#line 388 "y.tab.c"
-
-# ifndef YY_CAST
-#  ifdef __cplusplus
-#   define YY_CAST(Type, Val) static_cast<Type> (Val)
-#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
-#  else
-#   define YY_CAST(Type, Val) ((Type) (Val))
-#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
-#  endif
-# endif
-# ifndef YY_NULLPTR
-#  if defined __cplusplus
-#   if 201103L <= __cplusplus
-#    define YY_NULLPTR nullptr
-#   else
-#    define YY_NULLPTR 0
-#   endif
-#  else
-#   define YY_NULLPTR ((void*)0)
-#  endif
-# endif
-
-/* Use api.header.include to #include this header
-   instead of duplicating it here.  */
-#ifndef YY_YY_Y_TAB_H_INCLUDED
-# define YY_YY_Y_TAB_H_INCLUDED
-/* Debug traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
-
-/* Token kinds.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-  enum yytokentype
-  {
-    YYEMPTY = -2,
-    YYEOF = 0,                     /* "end of file"  */
-    YYerror = 256,                 /* error  */
-    YYUNDEF = 257,                 /* "invalid token"  */
-    IF = 258,                      /* IF  */
-    THEN = 259,                    /* THEN  */
-    ELSE = 260,                    /* ELSE  */
-    ELIF = 261,                    /* ELIF  */
-    FI = 262,                      /* FI  */
-    CASE = 263,                    /* CASE  */
-    ESAC = 264,                    /* ESAC  */
-    FOR = 265,                     /* FOR  */
-    SELECT = 266,                  /* SELECT  */
-    WHILE = 267,                   /* WHILE  */
-    UNTIL = 268,                   /* UNTIL  */
-    DO = 269,                      /* DO  */
-    DONE = 270,                    /* DONE  */
-    FUNCTION = 271,                /* FUNCTION  */
-    COPROC = 272,                  /* COPROC  */
-    COND_START = 273,              /* COND_START  */
-    COND_END = 274,                /* COND_END  */
-    COND_ERROR = 275,              /* COND_ERROR  */
-    IN = 276,                      /* IN  */
-    BANG = 277,                    /* BANG  */
-    TIME = 278,                    /* TIME  */
-    TIMEOPT = 279,                 /* TIMEOPT  */
-    TIMEIGN = 280,                 /* TIMEIGN  */
-    WORD = 281,                    /* WORD  */
-    ASSIGNMENT_WORD = 282,         /* ASSIGNMENT_WORD  */
-    REDIR_WORD = 283,              /* REDIR_WORD  */
-    NUMBER = 284,                  /* NUMBER  */
-    ARITH_CMD = 285,               /* ARITH_CMD  */
-    ARITH_FOR_EXPRS = 286,         /* ARITH_FOR_EXPRS  */
-    COND_CMD = 287,                /* COND_CMD  */
-    AND_AND = 288,                 /* AND_AND  */
-    OR_OR = 289,                   /* OR_OR  */
-    GREATER_GREATER = 290,         /* GREATER_GREATER  */
-    LESS_LESS = 291,               /* LESS_LESS  */
-    LESS_AND = 292,                /* LESS_AND  */
-    LESS_LESS_LESS = 293,          /* LESS_LESS_LESS  */
-    GREATER_AND = 294,             /* GREATER_AND  */
-    SEMI_SEMI = 295,               /* SEMI_SEMI  */
-    SEMI_AND = 296,                /* SEMI_AND  */
-    SEMI_SEMI_AND = 297,           /* SEMI_SEMI_AND  */
-    LESS_LESS_MINUS = 298,         /* LESS_LESS_MINUS  */
-    AND_GREATER = 299,             /* AND_GREATER  */
-    AND_GREATER_GREATER = 300,     /* AND_GREATER_GREATER  */
-    LESS_GREATER = 301,            /* LESS_GREATER  */
-    GREATER_BAR = 302,             /* GREATER_BAR  */
-    BAR_AND = 303,                 /* BAR_AND  */
-    DOLPAREN = 304,                /* DOLPAREN  */
-    yacc_EOF = 305                 /* yacc_EOF  */
-  };
-  typedef enum yytokentype yytoken_kind_t;
-#endif
-/* Token kinds.  */
-#define YYEMPTY -2
-#define YYEOF 0
-#define YYerror 256
-#define YYUNDEF 257
-#define IF 258
-#define THEN 259
-#define ELSE 260
-#define ELIF 261
-#define FI 262
-#define CASE 263
-#define ESAC 264
-#define FOR 265
-#define SELECT 266
-#define WHILE 267
-#define UNTIL 268
-#define DO 269
-#define DONE 270
-#define FUNCTION 271
-#define COPROC 272
-#define COND_START 273
-#define COND_END 274
-#define COND_ERROR 275
-#define IN 276
-#define BANG 277
-#define TIME 278
-#define TIMEOPT 279
-#define TIMEIGN 280
-#define WORD 281
-#define ASSIGNMENT_WORD 282
-#define REDIR_WORD 283
-#define NUMBER 284
-#define ARITH_CMD 285
-#define ARITH_FOR_EXPRS 286
-#define COND_CMD 287
-#define AND_AND 288
-#define OR_OR 289
-#define GREATER_GREATER 290
-#define LESS_LESS 291
-#define LESS_AND 292
-#define LESS_LESS_LESS 293
-#define GREATER_AND 294
-#define SEMI_SEMI 295
-#define SEMI_AND 296
-#define SEMI_SEMI_AND 297
-#define LESS_LESS_MINUS 298
-#define AND_GREATER 299
-#define AND_GREATER_GREATER 300
-#define LESS_GREATER 301
-#define GREATER_BAR 302
-#define BAR_AND 303
-#define DOLPAREN 304
-#define yacc_EOF 305
-
-/* Value type.  */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-union YYSTYPE
-{
-#line 338 "/usr/local/src/chet/src/bash/src/parse.y"
-
-  WORD_DESC *word;		/* the word that we read. */
-  int number;			/* the number that we read. */
-  WORD_LIST *word_list;
-  COMMAND *command;
-  REDIRECT *redirect;
-  ELEMENT element;
-  PATTERN_LIST *pattern;
-
-#line 551 "y.tab.c"
-
-};
-typedef union YYSTYPE YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-
-extern YYSTYPE yylval;
-
-
-int yyparse (void);
-
-
-#endif /* !YY_YY_Y_TAB_H_INCLUDED  */
-/* Symbol kind.  */
-enum yysymbol_kind_t
-{
-  YYSYMBOL_YYEMPTY = -2,
-  YYSYMBOL_YYEOF = 0,                      /* "end of file"  */
-  YYSYMBOL_YYerror = 1,                    /* error  */
-  YYSYMBOL_YYUNDEF = 2,                    /* "invalid token"  */
-  YYSYMBOL_IF = 3,                         /* IF  */
-  YYSYMBOL_THEN = 4,                       /* THEN  */
-  YYSYMBOL_ELSE = 5,                       /* ELSE  */
-  YYSYMBOL_ELIF = 6,                       /* ELIF  */
-  YYSYMBOL_FI = 7,                         /* FI  */
-  YYSYMBOL_CASE = 8,                       /* CASE  */
-  YYSYMBOL_ESAC = 9,                       /* ESAC  */
-  YYSYMBOL_FOR = 10,                       /* FOR  */
-  YYSYMBOL_SELECT = 11,                    /* SELECT  */
-  YYSYMBOL_WHILE = 12,                     /* WHILE  */
-  YYSYMBOL_UNTIL = 13,                     /* UNTIL  */
-  YYSYMBOL_DO = 14,                        /* DO  */
-  YYSYMBOL_DONE = 15,                      /* DONE  */
-  YYSYMBOL_FUNCTION = 16,                  /* FUNCTION  */
-  YYSYMBOL_COPROC = 17,                    /* COPROC  */
-  YYSYMBOL_COND_START = 18,                /* COND_START  */
-  YYSYMBOL_COND_END = 19,                  /* COND_END  */
-  YYSYMBOL_COND_ERROR = 20,                /* COND_ERROR  */
-  YYSYMBOL_IN = 21,                        /* IN  */
-  YYSYMBOL_BANG = 22,                      /* BANG  */
-  YYSYMBOL_TIME = 23,                      /* TIME  */
-  YYSYMBOL_TIMEOPT = 24,                   /* TIMEOPT  */
-  YYSYMBOL_TIMEIGN = 25,                   /* TIMEIGN  */
-  YYSYMBOL_WORD = 26,                      /* WORD  */
-  YYSYMBOL_ASSIGNMENT_WORD = 27,           /* ASSIGNMENT_WORD  */
-  YYSYMBOL_REDIR_WORD = 28,                /* REDIR_WORD  */
-  YYSYMBOL_NUMBER = 29,                    /* NUMBER  */
-  YYSYMBOL_ARITH_CMD = 30,                 /* ARITH_CMD  */
-  YYSYMBOL_ARITH_FOR_EXPRS = 31,           /* ARITH_FOR_EXPRS  */
-  YYSYMBOL_COND_CMD = 32,                  /* COND_CMD  */
-  YYSYMBOL_AND_AND = 33,                   /* AND_AND  */
-  YYSYMBOL_OR_OR = 34,                     /* OR_OR  */
-  YYSYMBOL_GREATER_GREATER = 35,           /* GREATER_GREATER  */
-  YYSYMBOL_LESS_LESS = 36,                 /* LESS_LESS  */
-  YYSYMBOL_LESS_AND = 37,                  /* LESS_AND  */
-  YYSYMBOL_LESS_LESS_LESS = 38,            /* LESS_LESS_LESS  */
-  YYSYMBOL_GREATER_AND = 39,               /* GREATER_AND  */
-  YYSYMBOL_SEMI_SEMI = 40,                 /* SEMI_SEMI  */
-  YYSYMBOL_SEMI_AND = 41,                  /* SEMI_AND  */
-  YYSYMBOL_SEMI_SEMI_AND = 42,             /* SEMI_SEMI_AND  */
-  YYSYMBOL_LESS_LESS_MINUS = 43,           /* LESS_LESS_MINUS  */
-  YYSYMBOL_AND_GREATER = 44,               /* AND_GREATER  */
-  YYSYMBOL_AND_GREATER_GREATER = 45,       /* AND_GREATER_GREATER  */
-  YYSYMBOL_LESS_GREATER = 46,              /* LESS_GREATER  */
-  YYSYMBOL_GREATER_BAR = 47,               /* GREATER_BAR  */
-  YYSYMBOL_BAR_AND = 48,                   /* BAR_AND  */
-  YYSYMBOL_DOLPAREN = 49,                  /* DOLPAREN  */
-  YYSYMBOL_50_ = 50,                       /* '&'  */
-  YYSYMBOL_51_ = 51,                       /* ';'  */
-  YYSYMBOL_52_n_ = 52,                     /* '\n'  */
-  YYSYMBOL_yacc_EOF = 53,                  /* yacc_EOF  */
-  YYSYMBOL_54_ = 54,                       /* '|'  */
-  YYSYMBOL_55_ = 55,                       /* '>'  */
-  YYSYMBOL_56_ = 56,                       /* '<'  */
-  YYSYMBOL_57_ = 57,                       /* '-'  */
-  YYSYMBOL_58_ = 58,                       /* '{'  */
-  YYSYMBOL_59_ = 59,                       /* '}'  */
-  YYSYMBOL_60_ = 60,                       /* '('  */
-  YYSYMBOL_61_ = 61,                       /* ')'  */
-  YYSYMBOL_YYACCEPT = 62,                  /* $accept  */
-  YYSYMBOL_inputunit = 63,                 /* inputunit  */
-  YYSYMBOL_word_list = 64,                 /* word_list  */
-  YYSYMBOL_redirection = 65,               /* redirection  */
-  YYSYMBOL_simple_command_element = 66,    /* simple_command_element  */
-  YYSYMBOL_redirection_list = 67,          /* redirection_list  */
-  YYSYMBOL_simple_command = 68,            /* simple_command  */
-  YYSYMBOL_command = 69,                   /* command  */
-  YYSYMBOL_shell_command = 70,             /* shell_command  */
-  YYSYMBOL_for_command = 71,               /* for_command  */
-  YYSYMBOL_arith_for_command = 72,         /* arith_for_command  */
-  YYSYMBOL_select_command = 73,            /* select_command  */
-  YYSYMBOL_case_command = 74,              /* case_command  */
-  YYSYMBOL_function_def = 75,              /* function_def  */
-  YYSYMBOL_function_body = 76,             /* function_body  */
-  YYSYMBOL_subshell = 77,                  /* subshell  */
-  YYSYMBOL_comsub = 78,                    /* comsub  */
-  YYSYMBOL_coproc = 79,                    /* coproc  */
-  YYSYMBOL_if_command = 80,                /* if_command  */
-  YYSYMBOL_group_command = 81,             /* group_command  */
-  YYSYMBOL_arith_command = 82,             /* arith_command  */
-  YYSYMBOL_cond_command = 83,              /* cond_command  */
-  YYSYMBOL_elif_clause = 84,               /* elif_clause  */
-  YYSYMBOL_case_clause = 85,               /* case_clause  */
-  YYSYMBOL_pattern_list = 86,              /* pattern_list  */
-  YYSYMBOL_case_clause_sequence = 87,      /* case_clause_sequence  */
-  YYSYMBOL_pattern = 88,                   /* pattern  */
-  YYSYMBOL_compound_list = 89,             /* compound_list  */
-  YYSYMBOL_list0 = 90,                     /* list0  */
-  YYSYMBOL_list1 = 91,                     /* list1  */
-  YYSYMBOL_simple_list_terminator = 92,    /* simple_list_terminator  */
-  YYSYMBOL_list_terminator = 93,           /* list_terminator  */
-  YYSYMBOL_newline_list = 94,              /* newline_list  */
-  YYSYMBOL_simple_list = 95,               /* simple_list  */
-  YYSYMBOL_simple_list1 = 96,              /* simple_list1  */
-  YYSYMBOL_pipeline_command = 97,          /* pipeline_command  */
-  YYSYMBOL_pipeline = 98,                  /* pipeline  */
-  YYSYMBOL_timespec = 99                   /* timespec  */
-};
-typedef enum yysymbol_kind_t yysymbol_kind_t;
-
-
-
-
-#ifdef short
-# undef short
-#endif
-
-/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
-   <limits.h> and (if available) <stdint.h> are included
-   so that the code can choose integer types of a good width.  */
-
-#ifndef __PTRDIFF_MAX__
-# include <limits.h> /* INFRINGES ON USER NAME SPACE */
-# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
-#  include <stdint.h> /* INFRINGES ON USER NAME SPACE */
-#  define YY_STDINT_H
-# endif
-#endif
-
-/* Narrow types that promote to a signed type and that can represent a
-   signed or unsigned integer of at least N bits.  In tables they can
-   save space and decrease cache pressure.  Promoting to a signed type
-   helps avoid bugs in integer arithmetic.  */
-
-#ifdef __INT_LEAST8_MAX__
-typedef __INT_LEAST8_TYPE__ yytype_int8;
-#elif defined YY_STDINT_H
-typedef int_least8_t yytype_int8;
-#else
-typedef signed char yytype_int8;
-#endif
-
-#ifdef __INT_LEAST16_MAX__
-typedef __INT_LEAST16_TYPE__ yytype_int16;
-#elif defined YY_STDINT_H
-typedef int_least16_t yytype_int16;
-#else
-typedef short yytype_int16;
-#endif
-
-/* Work around bug in HP-UX 11.23, which defines these macros
-   incorrectly for preprocessor constants.  This workaround can likely
-   be removed in 2023, as HPE has promised support for HP-UX 11.23
-   (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
-   <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>.  */
-#ifdef __hpux
-# undef UINT_LEAST8_MAX
-# undef UINT_LEAST16_MAX
-# define UINT_LEAST8_MAX 255
-# define UINT_LEAST16_MAX 65535
-#endif
-
-#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
-typedef __UINT_LEAST8_TYPE__ yytype_uint8;
-#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
-       && UINT_LEAST8_MAX <= INT_MAX)
-typedef uint_least8_t yytype_uint8;
-#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
-typedef unsigned char yytype_uint8;
-#else
-typedef short yytype_uint8;
-#endif
-
-#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
-typedef __UINT_LEAST16_TYPE__ yytype_uint16;
-#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
-       && UINT_LEAST16_MAX <= INT_MAX)
-typedef uint_least16_t yytype_uint16;
-#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
-typedef unsigned short yytype_uint16;
-#else
-typedef int yytype_uint16;
-#endif
-
-#ifndef YYPTRDIFF_T
-# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
-#  define YYPTRDIFF_T __PTRDIFF_TYPE__
-#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
-# elif defined PTRDIFF_MAX
-#  ifndef ptrdiff_t
-#   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  endif
-#  define YYPTRDIFF_T ptrdiff_t
-#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
-# else
-#  define YYPTRDIFF_T long
-#  define YYPTRDIFF_MAXIMUM LONG_MAX
-# endif
-#endif
-
-#ifndef YYSIZE_T
-# ifdef __SIZE_TYPE__
-#  define YYSIZE_T __SIZE_TYPE__
-# elif defined size_t
-#  define YYSIZE_T size_t
-# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
-#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T size_t
-# else
-#  define YYSIZE_T unsigned
-# endif
-#endif
-
-#define YYSIZE_MAXIMUM                                  \
-  YY_CAST (YYPTRDIFF_T,                                 \
-           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
-            ? YYPTRDIFF_MAXIMUM                         \
-            : YY_CAST (YYSIZE_T, -1)))
-
-#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
-
-
-/* Stored state numbers (used for stacks). */
-typedef yytype_int16 yy_state_t;
-
-/* State numbers in computations.  */
-typedef int yy_state_fast_t;
-
-#ifndef YY_
-# if defined YYENABLE_NLS && YYENABLE_NLS
-#  if ENABLE_NLS
-#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
-#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
-#  endif
-# endif
-# ifndef YY_
-#  define YY_(Msgid) Msgid
-# endif
-#endif
-
-
-#ifndef YY_ATTRIBUTE_PURE
-# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
-#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
-# else
-#  define YY_ATTRIBUTE_PURE
-# endif
-#endif
-
-#ifndef YY_ATTRIBUTE_UNUSED
-# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
-#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
-# else
-#  define YY_ATTRIBUTE_UNUSED
-# endif
-#endif
-
-/* Suppress unused-variable warnings by "using" E.  */
-#if ! defined lint || defined __GNUC__
-# define YY_USE(E) ((void) (E))
-#else
-# define YY_USE(E) /* empty */
-#endif
-
-/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
-#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
-# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
-#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
-    _Pragma ("GCC diagnostic push")                                     \
-    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
-# else
-#  define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                           \
-    _Pragma ("GCC diagnostic push")                                     \
-    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
-    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
-# endif
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
-    _Pragma ("GCC diagnostic pop")
-#else
-# define YY_INITIAL_VALUE(Value) Value
-#endif
-#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-# define YY_IGNORE_MAYBE_UNINITIALIZED_END
-#endif
-#ifndef YY_INITIAL_VALUE
-# define YY_INITIAL_VALUE(Value) /* Nothing. */
-#endif
-
-#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
-# define YY_IGNORE_USELESS_CAST_BEGIN                          \
-    _Pragma ("GCC diagnostic push")                            \
-    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
-# define YY_IGNORE_USELESS_CAST_END            \
-    _Pragma ("GCC diagnostic pop")
-#endif
-#ifndef YY_IGNORE_USELESS_CAST_BEGIN
-# define YY_IGNORE_USELESS_CAST_BEGIN
-# define YY_IGNORE_USELESS_CAST_END
-#endif
-
-
-#define YY_ASSERT(E) ((void) (0 && (E)))
-
-#if !defined yyoverflow
-
-/* The parser invokes alloca or malloc; define the necessary symbols.  */
-
-# ifdef YYSTACK_USE_ALLOCA
-#  if YYSTACK_USE_ALLOCA
-#   ifdef __GNUC__
-#    define YYSTACK_ALLOC __builtin_alloca
-#   elif defined __BUILTIN_VA_ARG_INCR
-#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
-#   elif defined _AIX
-#    define YYSTACK_ALLOC __alloca
-#   elif defined _MSC_VER
-#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
-#    define alloca _alloca
-#   else
-#    define YYSTACK_ALLOC alloca
-#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
-#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
-#     ifndef EXIT_SUCCESS
-#      define EXIT_SUCCESS 0
-#     endif
-#    endif
-#   endif
-#  endif
-# endif
-
-# ifdef YYSTACK_ALLOC
-   /* Pacify GCC's 'empty if-body' warning.  */
-#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-    /* The OS might guarantee only one guard page at the bottom of the stack,
-       and a page size can be as small as 4096 bytes.  So we cannot safely
-       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
-       to allow for a few compiler-allocated temporary stack slots.  */
-#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
-#  endif
-# else
-#  define YYSTACK_ALLOC YYMALLOC
-#  define YYSTACK_FREE YYFREE
-#  ifndef YYSTACK_ALLOC_MAXIMUM
-#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
-#  endif
-#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
-       && ! ((defined YYMALLOC || defined malloc) \
-             && (defined YYFREE || defined free)))
-#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#   ifndef EXIT_SUCCESS
-#    define EXIT_SUCCESS 0
-#   endif
-#  endif
-#  ifndef YYMALLOC
-#   define YYMALLOC malloc
-#   if ! defined malloc && ! defined EXIT_SUCCESS
-void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-#  ifndef YYFREE
-#   define YYFREE free
-#   if ! defined free && ! defined EXIT_SUCCESS
-void free (void *); /* INFRINGES ON USER NAME SPACE */
-#   endif
-#  endif
-# endif
-#endif /* !defined yyoverflow */
-
-#if (! defined yyoverflow \
-     && (! defined __cplusplus \
-         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
-
-/* A type that is properly aligned for any stack member.  */
-union yyalloc
-{
-  yy_state_t yyss_alloc;
-  YYSTYPE yyvs_alloc;
-};
-
-/* The size of the maximum gap between one aligned stack and the next.  */
-# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
-
-/* The size of an array large to enough to hold all stacks, each with
-   N elements.  */
-# define YYSTACK_BYTES(N) \
-     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
-      + YYSTACK_GAP_MAXIMUM)
-
-# define YYCOPY_NEEDED 1
-
-/* Relocate STACK from its old location to the new one.  The
-   local variables YYSIZE and YYSTACKSIZE give the old and new number of
-   elements in the stack, and YYPTR gives the new location of the
-   stack.  Advance YYPTR to a properly aligned location for the next
-   stack.  */
-# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
-    do                                                                  \
-      {                                                                 \
-        YYPTRDIFF_T yynewbytes;                                         \
-        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
-        Stack = &yyptr->Stack_alloc;                                    \
-        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
-        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
-      }                                                                 \
-    while (0)
-
-#endif
-
-#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
-/* Copy COUNT objects from SRC to DST.  The source and destination do
-   not overlap.  */
-# ifndef YYCOPY
-#  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(Dst, Src, Count) \
-      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
-#  else
-#   define YYCOPY(Dst, Src, Count)              \
-      do                                        \
-        {                                       \
-          YYPTRDIFF_T yyi;                      \
-          for (yyi = 0; yyi < (Count); yyi++)   \
-            (Dst)[yyi] = (Src)[yyi];            \
-        }                                       \
-      while (0)
-#  endif
-# endif
-#endif /* !YYCOPY_NEEDED */
-
-/* YYFINAL -- State number of the termination state.  */
-#define YYFINAL  121
-/* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   740
-
-/* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  62
-/* YYNNTS -- Number of nonterminals.  */
-#define YYNNTS  38
-/* YYNRULES -- Number of rules.  */
-#define YYNRULES  174
-/* YYNSTATES -- Number of states.  */
-#define YYNSTATES  349
-
-/* YYMAXUTOK -- Last valid token kind.  */
-#define YYMAXUTOK   305
-
-
-/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
-   as returned by yylex, with out-of-bounds checking.  */
-#define YYTRANSLATE(YYX)                                \
-  (0 <= (YYX) && (YYX) <= YYMAXUTOK                     \
-   ? YY_CAST (yysymbol_kind_t, yytranslate[YYX])        \
-   : YYSYMBOL_YYUNDEF)
-
-/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
-   as returned by yylex.  */
-static const yytype_int8 yytranslate[] =
-{
-       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-      52,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,    50,     2,
-      60,    61,     2,     2,     2,    57,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,    51,
-      56,     2,    55,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,    58,    54,    59,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
-       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
-      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
-      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
-      45,    46,    47,    48,    49,    53
-};
-
-#if YYDEBUG
-/* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
-static const yytype_int16 yyrline[] =
-{
-       0,   395,   395,   406,   414,   423,   438,   455,   465,   467,
-     471,   477,   483,   489,   495,   501,   507,   513,   519,   525,
-     531,   537,   543,   549,   555,   561,   568,   575,   582,   589,
-     596,   603,   609,   615,   621,   627,   633,   639,   645,   651,
-     657,   663,   669,   675,   681,   687,   693,   699,   705,   711,
-     717,   723,   729,   735,   743,   745,   747,   751,   755,   766,
-     768,   772,   774,   776,   792,   794,   798,   800,   802,   804,
-     806,   808,   810,   812,   814,   816,   818,   822,   827,   832,
-     837,   842,   847,   852,   857,   864,   870,   876,   882,   890,
-     895,   900,   905,   910,   915,   920,   925,   932,   937,   942,
-     949,   951,   953,   955,   959,   961,   992,   999,  1003,  1009,
-    1014,  1031,  1036,  1053,  1060,  1062,  1064,  1069,  1073,  1077,
-    1081,  1083,  1085,  1089,  1090,  1094,  1096,  1098,  1100,  1104,
-    1106,  1108,  1110,  1112,  1114,  1118,  1120,  1129,  1135,  1141,
-    1142,  1149,  1153,  1155,  1157,  1164,  1166,  1173,  1177,  1178,
-    1181,  1183,  1185,  1189,  1190,  1199,  1214,  1232,  1249,  1251,
-    1253,  1260,  1263,  1267,  1269,  1275,  1281,  1301,  1324,  1326,
-    1349,  1353,  1355,  1357,  1359
-};
-#endif
-
-/** Accessing symbol of state STATE.  */
-#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
-
-#if YYDEBUG || 0
-/* The user-facing name of the symbol whose (internal) number is
-   YYSYMBOL.  No bounds checking.  */
-static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
-
-/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
-   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
-static const char *const yytname[] =
-{
-  "\"end of file\"", "error", "\"invalid token\"", "IF", "THEN", "ELSE",
-  "ELIF", "FI", "CASE", "ESAC", "FOR", "SELECT", "WHILE", "UNTIL", "DO",
-  "DONE", "FUNCTION", "COPROC", "COND_START", "COND_END", "COND_ERROR",
-  "IN", "BANG", "TIME", "TIMEOPT", "TIMEIGN", "WORD", "ASSIGNMENT_WORD",
-  "REDIR_WORD", "NUMBER", "ARITH_CMD", "ARITH_FOR_EXPRS", "COND_CMD",
-  "AND_AND", "OR_OR", "GREATER_GREATER", "LESS_LESS", "LESS_AND",
-  "LESS_LESS_LESS", "GREATER_AND", "SEMI_SEMI", "SEMI_AND",
-  "SEMI_SEMI_AND", "LESS_LESS_MINUS", "AND_GREATER", "AND_GREATER_GREATER",
-  "LESS_GREATER", "GREATER_BAR", "BAR_AND", "DOLPAREN", "'&'", "';'",
-  "'\\n'", "yacc_EOF", "'|'", "'>'", "'<'", "'-'", "'{'", "'}'", "'('",
-  "')'", "$accept", "inputunit", "word_list", "redirection",
-  "simple_command_element", "redirection_list", "simple_command",
-  "command", "shell_command", "for_command", "arith_for_command",
-  "select_command", "case_command", "function_def", "function_body",
-  "subshell", "comsub", "coproc", "if_command", "group_command",
-  "arith_command", "cond_command", "elif_clause", "case_clause",
-  "pattern_list", "case_clause_sequence", "pattern", "compound_list",
-  "list0", "list1", "simple_list_terminator", "list_terminator",
-  "newline_list", "simple_list", "simple_list1", "pipeline_command",
-  "pipeline", "timespec", YY_NULLPTR
-};
-
-static const char *
-yysymbol_name (yysymbol_kind_t yysymbol)
-{
-  return yytname[yysymbol];
-}
-#endif
-
-#define YYPACT_NINF (-152)
-
-#define yypact_value_is_default(Yyn) \
-  ((Yyn) == YYPACT_NINF)
-
-#define YYTABLE_NINF (-1)
-
-#define yytable_value_is_error(Yyn) \
-  0
-
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
-   STATE-NUM.  */
-static const yytype_int16 yypact[] =
-{
-     328,    80,  -152,   -11,    -1,     3,  -152,  -152,    15,   637,
-      -5,   433,   149,   -28,  -152,   187,   684,  -152,    18,    28,
-     130,    38,   139,    50,    52,    60,    65,    74,  -152,  -152,
-    -152,    89,   104,  -152,  -152,    97,  -152,  -152,   246,  -152,
-     670,  -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,
-    -152,  -152,  -152,   146,   211,  -152,     1,   433,  -152,  -152,
-     135,   484,  -152,    59,    61,    90,   167,   171,    10,    71,
-     246,   670,   144,  -152,  -152,  -152,  -152,  -152,   165,  -152,
-     142,   179,   192,   140,   194,   160,   227,   245,   252,   253,
-     260,   261,   262,   162,   269,   178,   270,   272,   273,   274,
-     277,  -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,
-    -152,  -152,  -152,  -152,  -152,   168,   379,  -152,  -152,   173,
-     244,  -152,  -152,  -152,  -152,   670,  -152,  -152,  -152,  -152,
-    -152,   535,   535,  -152,  -152,  -152,  -152,  -152,  -152,  -152,
-     205,  -152,    14,  -152,    36,  -152,  -152,  -152,  -152,    84,
-    -152,  -152,  -152,   249,   670,  -152,   670,   670,  -152,  -152,
-    -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,
-    -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,
-    -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,  -152,
-    -152,  -152,  -152,  -152,   484,   484,   203,   203,   586,   586,
-     145,  -152,  -152,  -152,  -152,  -152,  -152,     0,  -152,   119,
-    -152,   291,   248,    66,    88,  -152,   119,  -152,   296,   297,
-      35,  -152,   670,   670,    35,  -152,  -152,     1,     1,  -152,
-    -152,  -152,   306,   484,   484,   484,   484,   484,   305,   169,
-    -152,     7,  -152,  -152,   302,  -152,   131,  -152,   265,  -152,
-    -152,  -152,  -152,  -152,  -152,   304,   131,  -152,   266,  -152,
-    -152,  -152,    35,  -152,   313,   317,  -152,  -152,  -152,   225,
-     225,   225,  -152,  -152,  -152,  -152,   206,    25,  -152,  -152,
-     307,   -42,   319,   276,  -152,  -152,  -152,    95,  -152,   322,
-     283,   332,   284,  -152,  -152,   102,  -152,  -152,  -152,  -152,
-    -152,  -152,  -152,  -152,    45,   323,  -152,  -152,  -152,   106,
-    -152,  -152,  -152,  -152,  -152,  -152,   109,  -152,  -152,   264,
-    -152,  -152,  -152,   484,  -152,  -152,   333,   293,  -152,  -152,
-     338,   300,  -152,  -152,  -152,   484,   345,   303,  -152,  -152,
-     346,   309,  -152,  -152,  -152,  -152,  -152,  -152,  -152
-};
-
-/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
-   Performed when YYTABLE does not specify something else to do.  Zero
-   means the default is an error.  */
-static const yytype_uint8 yydefact[] =
-{
-       0,     0,   153,     0,     0,     0,   153,   153,     0,     0,
-       0,     0,   171,    54,    55,     0,     0,   118,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   153,     4,
-       7,     0,     0,   153,   153,     0,    56,    59,    61,   170,
-      62,    66,    76,    70,    67,    64,    72,     3,    65,    71,
-      73,    74,    75,     0,   155,   162,   163,     0,     5,     6,
-       0,     0,   153,   153,     0,   153,     0,     0,     0,    54,
-     113,   109,     0,   151,   150,   152,   167,   164,   172,   173,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    16,    25,    40,    34,    49,    31,    43,    37,    46,
-      28,    52,    53,    22,    19,     0,     0,    10,    11,     0,
-       0,     1,    54,    60,    57,    63,   148,   149,     2,   153,
-     153,   156,   157,   153,   153,   166,   165,   153,   154,   137,
-     138,   147,     0,   153,     0,   153,   153,   153,   153,     0,
-     153,   153,   153,   153,   104,   102,   111,   110,   119,   174,
-     153,    18,    27,    42,    36,    51,    33,    45,    39,    48,
-      30,    24,    21,    14,    15,    17,    26,    41,    35,    50,
-      32,    44,    38,    47,    29,    23,    20,    12,    13,   107,
-     108,   117,   106,    58,     0,     0,   160,   161,     0,     0,
-       0,   153,   153,   153,   153,   153,   153,     0,   153,     0,
-     153,     0,     0,     0,     0,   153,     0,   153,     0,     0,
-       0,   153,   105,   112,     0,   158,   159,   169,   168,   153,
-     153,   114,     0,     0,     0,   140,   141,   139,     0,   123,
-     153,     0,   153,   153,     0,     8,     0,   153,     0,    87,
-      88,   153,   153,   153,   153,     0,     0,   153,     0,    68,
-      69,   103,     0,   100,     0,     0,   116,   142,   143,   144,
-     145,   146,    99,   129,   131,   133,   124,     0,    97,   135,
-       0,     0,     0,     0,    77,     9,   153,     0,    78,     0,
-       0,     0,     0,    89,   153,     0,    90,   101,   115,   153,
-     130,   132,   134,    98,     0,     0,   153,    79,    80,     0,
-     153,   153,    85,    86,    91,    92,     0,   153,   153,   120,
-     153,   136,   125,   126,   153,   153,     0,     0,   153,   153,
-       0,     0,   153,   122,   127,   128,     0,     0,    83,    84,
-       0,     0,    95,    96,   121,    81,    82,    93,    94
-};
-
-/* YYPGOTO[NTERM-NUM].  */
-static const yytype_int16 yypgoto[] =
-{
-    -152,  -152,   112,   -29,   -14,   -64,   360,  -152,    -8,  -152,
-    -152,  -152,  -152,  -152,  -151,  -152,  -152,  -152,  -152,  -152,
-    -152,  -152,    13,  -152,   136,  -152,    98,    -2,  -152,    30,
-    -152,   -54,   -26,  -152,  -123,     6,    78,  -152
-};
-
-/* YYDEFGOTO[NTERM-NUM].  */
-static const yytype_int16 yydefgoto[] =
-{
-       0,    35,   246,    36,    37,   125,    38,    39,    40,    41,
-      42,    43,    44,    45,   155,    46,    47,    48,    49,    50,
-      51,    52,   232,   238,   239,   240,   281,   120,   139,   140,
-     128,    76,    61,    53,    54,   141,    56,    57
-};
-
-/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
-   positive, shift that token.  If negative, reduce the rule whose
-   number is the opposite.  If YYTABLE_NINF, syntax error.  */
-static const yytype_int16 yytable[] =
-{
-      60,    71,   116,   135,    66,    67,    55,   157,   196,   197,
-     147,   124,   305,     2,   242,    62,   278,    77,     3,   306,
-       4,     5,     6,     7,   123,    63,   115,    72,    10,    65,
-      64,   119,    80,   279,   303,   206,   142,   144,     2,   149,
-      17,    68,   124,     3,   101,     4,     5,     6,     7,   133,
-     208,   279,   138,    10,   102,   134,   123,   209,   243,   138,
-     154,   156,   152,   136,   106,    17,   138,   280,    33,   261,
-     153,   225,   226,   263,     2,   145,   110,   138,   111,     3,
-     251,     4,     5,     6,     7,   280,   112,   138,   138,    10,
-     222,   113,   223,    33,   210,    34,   193,   121,   215,   305,
-     114,    17,   253,   194,   195,   216,   320,   198,   199,   310,
-     143,   297,    73,    74,    75,   117,   317,   207,   138,   146,
-     324,   213,   214,   328,   252,   124,   220,   124,   193,    33,
-     118,    34,    58,    59,   224,   200,   138,    55,    55,   137,
-     138,   148,   217,   211,   212,   245,   254,   138,   218,   219,
-     229,   230,   231,   311,   138,   247,   103,   285,   138,   104,
-     318,   138,   257,   158,   325,   107,   163,   329,   108,   164,
-      73,    74,    75,    78,    79,   233,   234,   235,   236,   237,
-     241,   150,    73,    74,    75,   151,   167,   105,   177,   168,
-     159,   178,   286,   193,   193,   262,   109,   165,   126,   127,
-      55,    55,   294,   160,   181,   161,   244,   182,   248,   273,
-     274,   275,   154,   255,   277,   258,   154,   169,   162,   179,
-     166,   287,    81,    82,    83,    84,    85,   264,   265,   189,
-      86,   295,   191,    87,    88,   183,   129,   130,   201,   202,
-     282,   283,    89,    90,   129,   130,   300,   301,   302,   289,
-     290,   291,   292,   170,   154,   203,   204,   205,   201,   202,
-     309,   131,   132,   267,   268,   269,   270,   271,   316,   332,
-     230,   171,   122,    14,    15,    16,   227,   228,   172,   173,
-     323,    18,    19,    20,    21,    22,   174,   175,   176,    23,
-      24,    25,    26,    27,   335,   180,   184,   319,   185,   186,
-     187,    31,    32,   188,   322,   192,   249,   250,   326,   327,
-     221,   259,   260,   266,   272,   330,   331,   284,   334,   293,
-     298,   299,   336,   337,   288,   296,   340,   341,   256,     1,
-     344,     2,   333,   279,   307,   308,     3,   312,     4,     5,
-       6,     7,   313,   315,     8,     9,    10,   314,   338,   321,
-      11,    12,   339,   342,    13,    14,    15,    16,    17,   343,
-     345,   347,   346,    18,    19,    20,    21,    22,   348,    70,
-       0,    23,    24,    25,    26,    27,   276,    28,   304,     0,
-      29,    30,     2,    31,    32,     0,    33,     3,    34,     4,
-       5,     6,     7,     0,     0,     8,     9,    10,     0,     0,
-       0,    11,    12,     0,     0,    13,    14,    15,    16,    17,
-       0,     0,     0,     0,    18,    19,    20,    21,    22,     0,
-       0,     0,    23,    24,    25,    26,    27,     0,     0,     0,
-       0,   138,     0,     0,    31,    32,     2,    33,     0,    34,
-     190,     3,     0,     4,     5,     6,     7,     0,     0,     8,
-       9,    10,     0,     0,     0,    11,    12,     0,     0,    13,
-      14,    15,    16,    17,     0,     0,     0,     0,    18,    19,
-      20,    21,    22,     0,     0,     0,    23,    24,    25,    26,
-      27,     0,     0,     0,    73,    74,    75,     2,    31,    32,
-       0,    33,     3,    34,     4,     5,     6,     7,     0,     0,
-       8,     9,    10,     0,     0,     0,    11,    12,     0,     0,
-      13,    14,    15,    16,    17,     0,     0,     0,     0,    18,
-      19,    20,    21,    22,     0,     0,     0,    23,    24,    25,
-      26,    27,     0,     0,     0,     0,   138,     0,     2,    31,
-      32,     0,    33,     3,    34,     4,     5,     6,     7,     0,
-       0,     8,     9,    10,     0,     0,     0,    11,    12,     0,
-       0,    13,    14,    15,    16,    17,     0,     0,     0,     0,
-      18,    19,    20,    21,    22,     0,     0,     0,    23,    24,
-      25,    26,    27,     0,     0,     0,     0,     0,     0,     2,
-      31,    32,     0,    33,     3,    34,     4,     5,     6,     7,
-       0,     0,     8,     9,    10,     0,     0,     0,     0,     0,
-       0,     0,    13,    14,    15,    16,    17,     0,     0,     0,
-       0,    18,    19,    20,    21,    22,     0,     0,     0,    23,
-      24,    25,    26,    27,     0,     0,     0,     0,   138,     0,
-       2,    31,    32,     0,    33,     3,    34,     4,     5,     6,
-       7,     0,     0,     0,     0,    10,     0,     0,     0,     0,
-       0,     0,     0,    69,    14,    15,    16,    17,     0,     0,
-       0,     0,    18,    19,    20,    21,    22,     0,     0,     0,
-      23,    24,    25,    26,    27,     0,     0,     0,     0,     0,
-       0,     0,    31,    32,     0,    33,     0,    34,    15,    16,
-       0,     0,     0,     0,     0,    18,    19,    20,    21,    22,
-       0,     0,     0,    23,    24,    25,    26,    27,     0,    91,
-      92,    93,    94,    95,     0,    31,    32,    96,     0,     0,
-      97,    98,     0,     0,     0,     0,     0,     0,     0,    99,
-     100
-};
-
-static const yytype_int16 yycheck[] =
-{
-       2,     9,    28,    57,     6,     7,     0,    71,   131,   132,
-      64,    40,    54,     3,    14,    26,     9,    11,     8,    61,
-      10,    11,    12,    13,    38,    26,    28,    32,    18,    26,
-      31,    33,    60,    26,     9,    21,    62,    63,     3,    65,
-      30,    26,    71,     8,    26,    10,    11,    12,    13,    48,
-      14,    26,    52,    18,    26,    54,    70,    21,    58,    52,
-      68,    69,    52,    57,    26,    30,    52,    60,    58,   220,
-      60,   194,   195,   224,     3,    14,    26,    52,    26,     8,
-      14,    10,    11,    12,    13,    60,    26,    52,    52,    18,
-     154,    26,   156,    58,    58,    60,   125,     0,    14,    54,
-      26,    30,    14,   129,   130,    21,    61,   133,   134,    14,
-      51,   262,    51,    52,    53,    26,    14,   143,    52,    58,
-      14,   147,   148,    14,    58,   154,   152,   156,   157,    58,
-      26,    60,    52,    53,   160,   137,    52,   131,   132,     4,
-      52,    51,    58,   145,   146,    26,    58,    52,   150,   151,
-       5,     6,     7,    58,    52,   209,    26,    26,    52,    29,
-      58,    52,   216,    19,    58,    26,    26,    58,    29,    29,
-      51,    52,    53,    24,    25,   201,   202,   203,   204,   205,
-     206,    14,    51,    52,    53,    14,    26,    57,    26,    29,
-      25,    29,   246,   222,   223,   221,    57,    57,    52,    53,
-     194,   195,   256,    61,    26,    26,   208,    29,   210,    40,
-      41,    42,   220,   215,   240,   217,   224,    57,    26,    57,
-      26,   247,    35,    36,    37,    38,    39,   229,   230,    61,
-      43,   257,    59,    46,    47,    57,    33,    34,    33,    34,
-     242,   243,    55,    56,    33,    34,    40,    41,    42,   251,
-     252,   253,   254,    26,   262,    50,    51,    52,    33,    34,
-     286,    50,    51,   233,   234,   235,   236,   237,   294,     5,
-       6,    26,    26,    27,    28,    29,   198,   199,    26,    26,
-     306,    35,    36,    37,    38,    39,    26,    26,    26,    43,
-      44,    45,    46,    47,   320,    26,    26,   299,    26,    26,
-      26,    55,    56,    26,   306,    61,    15,    59,   310,   311,
-      61,    15,    15,     7,     9,   317,   318,    15,   320,    15,
-       7,     4,   324,   325,    59,    59,   328,   329,   216,     1,
-     332,     3,   319,    26,    15,    59,     8,    15,    10,    11,
-      12,    13,    59,    59,    16,    17,    18,    15,    15,    26,
-      22,    23,    59,    15,    26,    27,    28,    29,    30,    59,
-      15,    15,    59,    35,    36,    37,    38,    39,    59,     9,
-      -1,    43,    44,    45,    46,    47,   240,    49,   280,    -1,
-      52,    53,     3,    55,    56,    -1,    58,     8,    60,    10,
-      11,    12,    13,    -1,    -1,    16,    17,    18,    -1,    -1,
-      -1,    22,    23,    -1,    -1,    26,    27,    28,    29,    30,
-      -1,    -1,    -1,    -1,    35,    36,    37,    38,    39,    -1,
-      -1,    -1,    43,    44,    45,    46,    47,    -1,    -1,    -1,
-      -1,    52,    -1,    -1,    55,    56,     3,    58,    -1,    60,
-      61,     8,    -1,    10,    11,    12,    13,    -1,    -1,    16,
-      17,    18,    -1,    -1,    -1,    22,    23,    -1,    -1,    26,
-      27,    28,    29,    30,    -1,    -1,    -1,    -1,    35,    36,
-      37,    38,    39,    -1,    -1,    -1,    43,    44,    45,    46,
-      47,    -1,    -1,    -1,    51,    52,    53,     3,    55,    56,
-      -1,    58,     8,    60,    10,    11,    12,    13,    -1,    -1,
-      16,    17,    18,    -1,    -1,    -1,    22,    23,    -1,    -1,
-      26,    27,    28,    29,    30,    -1,    -1,    -1,    -1,    35,
-      36,    37,    38,    39,    -1,    -1,    -1,    43,    44,    45,
-      46,    47,    -1,    -1,    -1,    -1,    52,    -1,     3,    55,
-      56,    -1,    58,     8,    60,    10,    11,    12,    13,    -1,
-      -1,    16,    17,    18,    -1,    -1,    -1,    22,    23,    -1,
-      -1,    26,    27,    28,    29,    30,    -1,    -1,    -1,    -1,
-      35,    36,    37,    38,    39,    -1,    -1,    -1,    43,    44,
-      45,    46,    47,    -1,    -1,    -1,    -1,    -1,    -1,     3,
-      55,    56,    -1,    58,     8,    60,    10,    11,    12,    13,
-      -1,    -1,    16,    17,    18,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    26,    27,    28,    29,    30,    -1,    -1,    -1,
-      -1,    35,    36,    37,    38,    39,    -1,    -1,    -1,    43,
-      44,    45,    46,    47,    -1,    -1,    -1,    -1,    52,    -1,
-       3,    55,    56,    -1,    58,     8,    60,    10,    11,    12,
-      13,    -1,    -1,    -1,    -1,    18,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    26,    27,    28,    29,    30,    -1,    -1,
-      -1,    -1,    35,    36,    37,    38,    39,    -1,    -1,    -1,
-      43,    44,    45,    46,    47,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    55,    56,    -1,    58,    -1,    60,    28,    29,
-      -1,    -1,    -1,    -1,    -1,    35,    36,    37,    38,    39,
-      -1,    -1,    -1,    43,    44,    45,    46,    47,    -1,    35,
-      36,    37,    38,    39,    -1,    55,    56,    43,    -1,    -1,
-      46,    47,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    55,
-      56
-};
-
-/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
-   state STATE-NUM.  */
-static const yytype_int8 yystos[] =
-{
-       0,     1,     3,     8,    10,    11,    12,    13,    16,    17,
-      18,    22,    23,    26,    27,    28,    29,    30,    35,    36,
-      37,    38,    39,    43,    44,    45,    46,    47,    49,    52,
-      53,    55,    56,    58,    60,    63,    65,    66,    68,    69,
-      70,    71,    72,    73,    74,    75,    77,    78,    79,    80,
-      81,    82,    83,    95,    96,    97,    98,    99,    52,    53,
-      89,    94,    26,    26,    31,    26,    89,    89,    26,    26,
-      68,    70,    32,    51,    52,    53,    93,    97,    24,    25,
-      60,    35,    36,    37,    38,    39,    43,    46,    47,    55,
-      56,    35,    36,    37,    38,    39,    43,    46,    47,    55,
-      56,    26,    26,    26,    29,    57,    26,    26,    29,    57,
-      26,    26,    26,    26,    26,    89,    94,    26,    26,    89,
-      89,     0,    26,    66,    65,    67,    52,    53,    92,    33,
-      34,    50,    51,    48,    54,    93,    97,     4,    52,    90,
-      91,    97,    94,    51,    94,    14,    58,    93,    51,    94,
-      14,    14,    52,    60,    70,    76,    70,    67,    19,    25,
-      61,    26,    26,    26,    29,    57,    26,    26,    29,    57,
-      26,    26,    26,    26,    26,    26,    26,    26,    29,    57,
-      26,    26,    29,    57,    26,    26,    26,    26,    26,    61,
-      61,    59,    61,    65,    94,    94,    96,    96,    94,    94,
-      89,    33,    34,    50,    51,    52,    21,    94,    14,    21,
-      58,    89,    89,    94,    94,    14,    21,    58,    89,    89,
-      94,    61,    67,    67,    94,    96,    96,    98,    98,     5,
-       6,     7,    84,    94,    94,    94,    94,    94,    85,    86,
-      87,    94,    14,    58,    89,    26,    64,    93,    89,    15,
-      59,    14,    58,    14,    58,    89,    64,    93,    89,    15,
-      15,    76,    94,    76,    89,    89,     7,    91,    91,    91,
-      91,    91,     9,    40,    41,    42,    86,    94,     9,    26,
-      60,    88,    89,    89,    15,    26,    93,    94,    59,    89,
-      89,    89,    89,    15,    93,    94,    59,    76,     7,     4,
-      40,    41,    42,     9,    88,    54,    61,    15,    59,    94,
-      14,    58,    15,    59,    15,    59,    94,    14,    58,    89,
-      61,    26,    89,    94,    14,    58,    89,    89,    14,    58,
-      89,    89,     5,    84,    89,    94,    89,    89,    15,    59,
-      89,    89,    15,    59,    89,    15,    59,    15,    59
-};
-
-/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.  */
-static const yytype_int8 yyr1[] =
-{
-       0,    62,    63,    63,    63,    63,    63,    63,    64,    64,
-      65,    65,    65,    65,    65,    65,    65,    65,    65,    65,
-      65,    65,    65,    65,    65,    65,    65,    65,    65,    65,
-      65,    65,    65,    65,    65,    65,    65,    65,    65,    65,
-      65,    65,    65,    65,    65,    65,    65,    65,    65,    65,
-      65,    65,    65,    65,    66,    66,    66,    67,    67,    68,
-      68,    69,    69,    69,    69,    69,    70,    70,    70,    70,
-      70,    70,    70,    70,    70,    70,    70,    71,    71,    71,
-      71,    71,    71,    71,    71,    72,    72,    72,    72,    73,
-      73,    73,    73,    73,    73,    73,    73,    74,    74,    74,
-      75,    75,    75,    75,    76,    76,    77,    78,    78,    79,
-      79,    79,    79,    79,    80,    80,    80,    81,    82,    83,
-      84,    84,    84,    85,    85,    86,    86,    86,    86,    87,
-      87,    87,    87,    87,    87,    88,    88,    89,    89,    90,
-      90,    90,    91,    91,    91,    91,    91,    91,    92,    92,
-      93,    93,    93,    94,    94,    95,    95,    95,    96,    96,
-      96,    96,    96,    97,    97,    97,    97,    97,    98,    98,
-      98,    99,    99,    99,    99
-};
-
-/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.  */
-static const yytype_int8 yyr2[] =
-{
-       0,     2,     2,     1,     1,     2,     2,     1,     1,     2,
-       2,     2,     3,     3,     3,     3,     2,     3,     3,     2,
-       3,     3,     2,     3,     3,     2,     3,     3,     2,     3,
-       3,     2,     3,     3,     2,     3,     3,     2,     3,     3,
-       2,     3,     3,     2,     3,     3,     2,     3,     3,     2,
-       3,     3,     2,     2,     1,     1,     1,     1,     2,     1,
-       2,     1,     1,     2,     1,     1,     1,     1,     5,     5,
-       1,     1,     1,     1,     1,     1,     1,     6,     6,     7,
-       7,    10,    10,     9,     9,     7,     7,     5,     5,     6,
-       6,     7,     7,    10,    10,     9,     9,     6,     7,     6,
-       5,     6,     3,     5,     1,     2,     3,     3,     3,     2,
-       3,     3,     4,     2,     5,     7,     6,     3,     1,     3,
-       4,     6,     5,     1,     2,     4,     4,     5,     5,     2,
-       3,     2,     3,     2,     3,     1,     3,     2,     2,     3,
-       3,     3,     4,     4,     4,     4,     4,     1,     1,     1,
-       1,     1,     1,     0,     2,     1,     2,     2,     4,     4,
-       3,     3,     1,     1,     2,     2,     2,     2,     4,     4,
-       1,     1,     2,     2,     3
-};
-
-
-enum { YYENOMEM = -2 };
-
-#define yyerrok         (yyerrstatus = 0)
-#define yyclearin       (yychar = YYEMPTY)
-
-#define YYACCEPT        goto yyacceptlab
-#define YYABORT         goto yyabortlab
-#define YYERROR         goto yyerrorlab
-#define YYNOMEM         goto yyexhaustedlab
-
-
-#define YYRECOVERING()  (!!yyerrstatus)
-
-#define YYBACKUP(Token, Value)                                    \
-  do                                                              \
-    if (yychar == YYEMPTY)                                        \
-      {                                                           \
-        yychar = (Token);                                         \
-        yylval = (Value);                                         \
-        YYPOPSTACK (yylen);                                       \
-        yystate = *yyssp;                                         \
-        goto yybackup;                                            \
-      }                                                           \
-    else                                                          \
-      {                                                           \
-        yyerror (YY_("syntax error: cannot back up")); \
-        YYERROR;                                                  \
-      }                                                           \
-  while (0)
-
-/* Backward compatibility with an undocumented macro.
-   Use YYerror or YYUNDEF. */
-#define YYERRCODE YYUNDEF
-
-
-/* Enable debugging if requested.  */
-#if YYDEBUG
-
-# ifndef YYFPRINTF
-#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-#  define YYFPRINTF fprintf
-# endif
-
-# define YYDPRINTF(Args)                        \
-do {                                            \
-  if (yydebug)                                  \
-    YYFPRINTF Args;                             \
-} while (0)
-
-
-
-
-# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)                    \
-do {                                                                      \
-  if (yydebug)                                                            \
-    {                                                                     \
-      YYFPRINTF (stderr, "%s ", Title);                                   \
-      yy_symbol_print (stderr,                                            \
-                  Kind, Value); \
-      YYFPRINTF (stderr, "\n");                                           \
-    }                                                                     \
-} while (0)
-
-
-/*-----------------------------------.
-| Print this symbol's value on YYO.  |
-`-----------------------------------*/
-
-static void
-yy_symbol_value_print (FILE *yyo,
-                       yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
-{
-  FILE *yyoutput = yyo;
-  YY_USE (yyoutput);
-  if (!yyvaluep)
-    return;
-  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-  YY_USE (yykind);
-  YY_IGNORE_MAYBE_UNINITIALIZED_END
-}
-
-
-/*---------------------------.
-| Print this symbol on YYO.  |
-`---------------------------*/
-
-static void
-yy_symbol_print (FILE *yyo,
-                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
-{
-  YYFPRINTF (yyo, "%s %s (",
-             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
-
-  yy_symbol_value_print (yyo, yykind, yyvaluep);
-  YYFPRINTF (yyo, ")");
-}
-
-/*------------------------------------------------------------------.
-| yy_stack_print -- Print the state stack from its BOTTOM up to its |
-| TOP (included).                                                   |
-`------------------------------------------------------------------*/
-
-static void
-yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
-{
-  YYFPRINTF (stderr, "Stack now");
-  for (; yybottom <= yytop; yybottom++)
-    {
-      int yybot = *yybottom;
-      YYFPRINTF (stderr, " %d", yybot);
-    }
-  YYFPRINTF (stderr, "\n");
-}
-
-# define YY_STACK_PRINT(Bottom, Top)                            \
-do {                                                            \
-  if (yydebug)                                                  \
-    yy_stack_print ((Bottom), (Top));                           \
-} while (0)
-
-
-/*------------------------------------------------.
-| Report that the YYRULE is going to be reduced.  |
-`------------------------------------------------*/
-
-static void
-yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
-                 int yyrule)
-{
-  int yylno = yyrline[yyrule];
-  int yynrhs = yyr2[yyrule];
-  int yyi;
-  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
-             yyrule - 1, yylno);
-  /* The symbols being reduced.  */
-  for (yyi = 0; yyi < yynrhs; yyi++)
-    {
-      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
-      yy_symbol_print (stderr,
-                       YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
-                       &yyvsp[(yyi + 1) - (yynrhs)]);
-      YYFPRINTF (stderr, "\n");
-    }
-}
-
-# define YY_REDUCE_PRINT(Rule)          \
-do {                                    \
-  if (yydebug)                          \
-    yy_reduce_print (yyssp, yyvsp, Rule); \
-} while (0)
-
-/* Nonzero means print parse trace.  It is left uninitialized so that
-   multiple parsers can coexist.  */
-int yydebug;
-#else /* !YYDEBUG */
-# define YYDPRINTF(Args) ((void) 0)
-# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
-#endif /* !YYDEBUG */
-
-
-/* YYINITDEPTH -- initial size of the parser's stacks.  */
-#ifndef YYINITDEPTH
-# define YYINITDEPTH 200
-#endif
-
-/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
-   if the built-in stack extension method is used).
-
-   Do not make this value too large; the results are undefined if
-   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
-   evaluated with infinite-precision integer arithmetic.  */
-
-#ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
-#endif
-
-
-
-
-
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
-
-static void
-yydestruct (const char *yymsg,
-            yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
-{
-  YY_USE (yyvaluep);
-  if (!yymsg)
-    yymsg = "Deleting";
-  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
-
-  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-  YY_USE (yykind);
-  YY_IGNORE_MAYBE_UNINITIALIZED_END
-}
-
-
-/* Lookahead token kind.  */
-int yychar;
-
-/* The semantic value of the lookahead symbol.  */
-YYSTYPE yylval;
-/* Number of syntax errors so far.  */
-int yynerrs;
-
-
-
-
-/*----------.
-| yyparse.  |
-`----------*/
-
-int
-yyparse (void)
-{
-    yy_state_fast_t yystate = 0;
-    /* Number of tokens to shift before error messages enabled.  */
-    int yyerrstatus = 0;
-
-    /* Refer to the stacks through separate pointers, to allow yyoverflow
-       to reallocate them elsewhere.  */
-
-    /* Their size.  */
-    YYPTRDIFF_T yystacksize = YYINITDEPTH;
-
-    /* The state stack: array, bottom, top.  */
-    yy_state_t yyssa[YYINITDEPTH];
-    yy_state_t *yyss = yyssa;
-    yy_state_t *yyssp = yyss;
-
-    /* The semantic value stack: array, bottom, top.  */
-    YYSTYPE yyvsa[YYINITDEPTH];
-    YYSTYPE *yyvs = yyvsa;
-    YYSTYPE *yyvsp = yyvs;
-
-  int yyn;
-  /* The return value of yyparse.  */
-  int yyresult;
-  /* Lookahead symbol kind.  */
-  yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-
-
-
-#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
-
-  /* The number of symbols on the RHS of the reduced rule.
-     Keep to zero when no symbol should be popped.  */
-  int yylen = 0;
-
-  YYDPRINTF ((stderr, "Starting parse\n"));
-
-  yychar = YYEMPTY; /* Cause a token to be read.  */
-
-  goto yysetstate;
-
-
-/*------------------------------------------------------------.
-| yynewstate -- push a new state, which is found in yystate.  |
-`------------------------------------------------------------*/
-yynewstate:
-  /* In all cases, when you get here, the value and location stacks
-     have just been pushed.  So pushing a state here evens the stacks.  */
-  yyssp++;
-
-
-/*--------------------------------------------------------------------.
-| yysetstate -- set current state (the top of the stack) to yystate.  |
-`--------------------------------------------------------------------*/
-yysetstate:
-  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
-  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
-  YY_IGNORE_USELESS_CAST_BEGIN
-  *yyssp = YY_CAST (yy_state_t, yystate);
-  YY_IGNORE_USELESS_CAST_END
-  YY_STACK_PRINT (yyss, yyssp);
-
-  if (yyss + yystacksize - 1 <= yyssp)
-#if !defined yyoverflow && !defined YYSTACK_RELOCATE
-    YYNOMEM;
-#else
-    {
-      /* Get the current used size of the three stacks, in elements.  */
-      YYPTRDIFF_T yysize = yyssp - yyss + 1;
-
-# if defined yyoverflow
-      {
-        /* Give user a chance to reallocate the stack.  Use copies of
-           these so that the &'s don't force the real ones into
-           memory.  */
-        yy_state_t *yyss1 = yyss;
-        YYSTYPE *yyvs1 = yyvs;
-
-        /* Each stack pointer address is followed by the size of the
-           data in use in that stack, in bytes.  This used to be a
-           conditional around just the two extra args, but that might
-           be undefined if yyoverflow is a macro.  */
-        yyoverflow (YY_("memory exhausted"),
-                    &yyss1, yysize * YYSIZEOF (*yyssp),
-                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
-                    &yystacksize);
-        yyss = yyss1;
-        yyvs = yyvs1;
-      }
-# else /* defined YYSTACK_RELOCATE */
-      /* Extend the stack our own way.  */
-      if (YYMAXDEPTH <= yystacksize)
-        YYNOMEM;
-      yystacksize *= 2;
-      if (YYMAXDEPTH < yystacksize)
-        yystacksize = YYMAXDEPTH;
-
-      {
-        yy_state_t *yyss1 = yyss;
-        union yyalloc *yyptr =
-          YY_CAST (union yyalloc *,
-                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
-        if (! yyptr)
-          YYNOMEM;
-        YYSTACK_RELOCATE (yyss_alloc, yyss);
-        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
-#  undef YYSTACK_RELOCATE
-        if (yyss1 != yyssa)
-          YYSTACK_FREE (yyss1);
-      }
-# endif
-
-      yyssp = yyss + yysize - 1;
-      yyvsp = yyvs + yysize - 1;
-
-      YY_IGNORE_USELESS_CAST_BEGIN
-      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
-                  YY_CAST (long, yystacksize)));
-      YY_IGNORE_USELESS_CAST_END
-
-      if (yyss + yystacksize - 1 <= yyssp)
-        YYABORT;
-    }
-#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
-
-
-  if (yystate == YYFINAL)
-    YYACCEPT;
-
-  goto yybackup;
-
-
-/*-----------.
-| yybackup.  |
-`-----------*/
-yybackup:
-  /* Do appropriate processing given the current state.  Read a
-     lookahead token if we need one and don't already have one.  */
-
-  /* First try to decide what to do without reference to lookahead token.  */
-  yyn = yypact[yystate];
-  if (yypact_value_is_default (yyn))
-    goto yydefault;
-
-  /* Not known => get a lookahead token if don't already have one.  */
-
-  /* YYCHAR is either empty, or end-of-input, or a valid lookahead.  */
-  if (yychar == YYEMPTY)
-    {
-      YYDPRINTF ((stderr, "Reading a token\n"));
-      yychar = yylex ();
-    }
-
-  if (yychar <= YYEOF)
-    {
-      yychar = YYEOF;
-      yytoken = YYSYMBOL_YYEOF;
-      YYDPRINTF ((stderr, "Now at end of input.\n"));
-    }
-  else if (yychar == YYerror)
-    {
-      /* The scanner already issued an error message, process directly
-         to error recovery.  But do not keep the error token as
-         lookahead, it is too special and may lead us to an endless
-         loop in error recovery. */
-      yychar = YYUNDEF;
-      yytoken = YYSYMBOL_YYerror;
-      goto yyerrlab1;
-    }
-  else
-    {
-      yytoken = YYTRANSLATE (yychar);
-      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
-    }
-
-  /* If the proper action on seeing token YYTOKEN is to reduce or to
-     detect an error, take that action.  */
-  yyn += yytoken;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
-    goto yydefault;
-  yyn = yytable[yyn];
-  if (yyn <= 0)
-    {
-      if (yytable_value_is_error (yyn))
-        goto yyerrlab;
-      yyn = -yyn;
-      goto yyreduce;
-    }
-
-  /* Count tokens shifted since error; after three, turn off error
-     status.  */
-  if (yyerrstatus)
-    yyerrstatus--;
-
-  /* Shift the lookahead token.  */
-  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
-  yystate = yyn;
-  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-  *++yyvsp = yylval;
-  YY_IGNORE_MAYBE_UNINITIALIZED_END
-
-  /* Discard the shifted token.  */
-  yychar = YYEMPTY;
-  goto yynewstate;
-
-
-/*-----------------------------------------------------------.
-| yydefault -- do the default action for the current state.  |
-`-----------------------------------------------------------*/
-yydefault:
-  yyn = yydefact[yystate];
-  if (yyn == 0)
-    goto yyerrlab;
-  goto yyreduce;
-
-
-/*-----------------------------.
-| yyreduce -- do a reduction.  |
-`-----------------------------*/
-yyreduce:
-  /* yyn is the number of a rule to reduce with.  */
-  yylen = yyr2[yyn];
-
-  /* If YYLEN is nonzero, implement the default value of the action:
-     '$$ = $1'.
-
-     Otherwise, the following line sets YYVAL to garbage.
-     This behavior is undocumented and Bison
-     users should not rely upon it.  Assigning to YYVAL
-     unconditionally makes the parser a bit smaller, and it avoids a
-     GCC warning that YYVAL may be used uninitialized.  */
-  yyval = yyvsp[1-yylen];
-
-
-  YY_REDUCE_PRINT (yyn);
-  switch (yyn)
-    {
-  case 2: /* inputunit: simple_list simple_list_terminator  */
-#line 396 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  /* Case of regular command.  Discard the error
-			     safety net,and return the command just parsed. */
-			  global_command = (yyvsp[-1].command);
-			  eof_encountered = 0;
-			  /* discard_parser_constructs (0); */
-			  if (parser_state & PST_CMDSUBST)
-			    parser_state |= PST_EOFTOKEN;
-			  YYACCEPT;
-			}
-#line 1954 "y.tab.c"
-    break;
-
-  case 3: /* inputunit: comsub  */
-#line 407 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  /* This is special; look at the production and how
-			     parse_comsub sets token_to_read */
-			  global_command = (yyvsp[0].command);
-			  eof_encountered = 0;
-			  YYACCEPT;
-			}
-#line 1966 "y.tab.c"
-    break;
-
-  case 4: /* inputunit: '\n'  */
-#line 415 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  /* Case of regular command, but not a very
-			     interesting one.  Return a NULL command. */
-			  global_command = (COMMAND *)NULL;
-			  if (parser_state & PST_CMDSUBST)
-			    parser_state |= PST_EOFTOKEN;
-			  YYACCEPT;
-			}
-#line 1979 "y.tab.c"
-    break;
-
-  case 5: /* inputunit: error '\n'  */
-#line 424 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  /* Error during parsing.  Return NULL command. */
-			  global_command = (COMMAND *)NULL;
-			  eof_encountered = 0;
-			  /* discard_parser_constructs (1); */
-			  if (interactive && parse_and_execute_level == 0)
-			    {
-			      YYACCEPT;
-			    }
-			  else
-			    {
-			      YYABORT;
-			    }
-			}
-#line 1998 "y.tab.c"
-    break;
-
-  case 6: /* inputunit: error yacc_EOF  */
-#line 439 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  /* EOF after an error.  Do ignoreeof or not.  Really
-			     only interesting in non-interactive shells */
-			  global_command = (COMMAND *)NULL;
-			  if (last_command_exit_value == 0)
-			    last_command_exit_value = EX_BADUSAGE;	/* force error return */
-			  if (interactive && parse_and_execute_level == 0)
-			    {
-			      handle_eof_input_unit ();
-			      YYACCEPT;
-			    }
-			  else
-			    {
-			      YYABORT;
-			    }
-			}
-#line 2019 "y.tab.c"
-    break;
-
-  case 7: /* inputunit: yacc_EOF  */
-#line 456 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  /* Case of EOF seen by itself.  Do ignoreeof or
-			     not. */
-			  global_command = (COMMAND *)NULL;
-			  handle_eof_input_unit ();
-			  YYACCEPT;
-			}
-#line 2031 "y.tab.c"
-    break;
-
-  case 8: /* word_list: WORD  */
-#line 466 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.word_list) = make_word_list ((yyvsp[0].word), (WORD_LIST *)NULL); }
-#line 2037 "y.tab.c"
-    break;
-
-  case 9: /* word_list: word_list WORD  */
-#line 468 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.word_list) = make_word_list ((yyvsp[0].word), (yyvsp[-1].word_list)); }
-#line 2043 "y.tab.c"
-    break;
-
-  case 10: /* redirection: '>' WORD  */
-#line 472 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 1;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_output_direction, redir, 0);
-			}
-#line 2053 "y.tab.c"
-    break;
-
-  case 11: /* redirection: '<' WORD  */
-#line 478 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 0;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_input_direction, redir, 0);
-			}
-#line 2063 "y.tab.c"
-    break;
-
-  case 12: /* redirection: NUMBER '>' WORD  */
-#line 484 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_output_direction, redir, 0);
-			}
-#line 2073 "y.tab.c"
-    break;
-
-  case 13: /* redirection: NUMBER '<' WORD  */
-#line 490 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_input_direction, redir, 0);
-			}
-#line 2083 "y.tab.c"
-    break;
-
-  case 14: /* redirection: REDIR_WORD '>' WORD  */
-#line 496 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_output_direction, redir, REDIR_VARASSIGN);
-			}
-#line 2093 "y.tab.c"
-    break;
-
-  case 15: /* redirection: REDIR_WORD '<' WORD  */
-#line 502 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_input_direction, redir, REDIR_VARASSIGN);
-			}
-#line 2103 "y.tab.c"
-    break;
-
-  case 16: /* redirection: GREATER_GREATER WORD  */
-#line 508 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 1;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_appending_to, redir, 0);
-			}
-#line 2113 "y.tab.c"
-    break;
-
-  case 17: /* redirection: NUMBER GREATER_GREATER WORD  */
-#line 514 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_appending_to, redir, 0);
-			}
-#line 2123 "y.tab.c"
-    break;
-
-  case 18: /* redirection: REDIR_WORD GREATER_GREATER WORD  */
-#line 520 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_appending_to, redir, REDIR_VARASSIGN);
-			}
-#line 2133 "y.tab.c"
-    break;
-
-  case 19: /* redirection: GREATER_BAR WORD  */
-#line 526 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 1;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_output_force, redir, 0);
-			}
-#line 2143 "y.tab.c"
-    break;
-
-  case 20: /* redirection: NUMBER GREATER_BAR WORD  */
-#line 532 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_output_force, redir, 0);
-			}
-#line 2153 "y.tab.c"
-    break;
-
-  case 21: /* redirection: REDIR_WORD GREATER_BAR WORD  */
-#line 538 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_output_force, redir, REDIR_VARASSIGN);
-			}
-#line 2163 "y.tab.c"
-    break;
-
-  case 22: /* redirection: LESS_GREATER WORD  */
-#line 544 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 0;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_input_output, redir, 0);
-			}
-#line 2173 "y.tab.c"
-    break;
-
-  case 23: /* redirection: NUMBER LESS_GREATER WORD  */
-#line 550 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_input_output, redir, 0);
-			}
-#line 2183 "y.tab.c"
-    break;
-
-  case 24: /* redirection: REDIR_WORD LESS_GREATER WORD  */
-#line 556 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_input_output, redir, REDIR_VARASSIGN);
-			}
-#line 2193 "y.tab.c"
-    break;
-
-  case 25: /* redirection: LESS_LESS WORD  */
-#line 562 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 0;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_reading_until, redir, 0);
-			  push_heredoc ((yyval.redirect));
-			}
-#line 2204 "y.tab.c"
-    break;
-
-  case 26: /* redirection: NUMBER LESS_LESS WORD  */
-#line 569 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_reading_until, redir, 0);
-			  push_heredoc ((yyval.redirect));
-			}
-#line 2215 "y.tab.c"
-    break;
-
-  case 27: /* redirection: REDIR_WORD LESS_LESS WORD  */
-#line 576 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_reading_until, redir, REDIR_VARASSIGN);
-			  push_heredoc ((yyval.redirect));
-			}
-#line 2226 "y.tab.c"
-    break;
-
-  case 28: /* redirection: LESS_LESS_MINUS WORD  */
-#line 583 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 0;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_deblank_reading_until, redir, 0);
-			  push_heredoc ((yyval.redirect));
-			}
-#line 2237 "y.tab.c"
-    break;
-
-  case 29: /* redirection: NUMBER LESS_LESS_MINUS WORD  */
-#line 590 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_deblank_reading_until, redir, 0);
-			  push_heredoc ((yyval.redirect));
-			}
-#line 2248 "y.tab.c"
-    break;
-
-  case 30: /* redirection: REDIR_WORD LESS_LESS_MINUS WORD  */
-#line 597 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_deblank_reading_until, redir, REDIR_VARASSIGN);
-			  push_heredoc ((yyval.redirect));
-			}
-#line 2259 "y.tab.c"
-    break;
-
-  case 31: /* redirection: LESS_LESS_LESS WORD  */
-#line 604 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 0;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_reading_string, redir, 0);
-			}
-#line 2269 "y.tab.c"
-    break;
-
-  case 32: /* redirection: NUMBER LESS_LESS_LESS WORD  */
-#line 610 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_reading_string, redir, 0);
-			}
-#line 2279 "y.tab.c"
-    break;
-
-  case 33: /* redirection: REDIR_WORD LESS_LESS_LESS WORD  */
-#line 616 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_reading_string, redir, REDIR_VARASSIGN);
-			}
-#line 2289 "y.tab.c"
-    break;
-
-  case 34: /* redirection: LESS_AND NUMBER  */
-#line 622 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 0;
-			  redir.dest = (yyvsp[0].number);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_input, redir, 0);
-			}
-#line 2299 "y.tab.c"
-    break;
-
-  case 35: /* redirection: NUMBER LESS_AND NUMBER  */
-#line 628 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.dest = (yyvsp[0].number);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_input, redir, 0);
-			}
-#line 2309 "y.tab.c"
-    break;
-
-  case 36: /* redirection: REDIR_WORD LESS_AND NUMBER  */
-#line 634 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.dest = (yyvsp[0].number);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_input, redir, REDIR_VARASSIGN);
-			}
-#line 2319 "y.tab.c"
-    break;
-
-  case 37: /* redirection: GREATER_AND NUMBER  */
-#line 640 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 1;
-			  redir.dest = (yyvsp[0].number);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_output, redir, 0);
-			}
-#line 2329 "y.tab.c"
-    break;
-
-  case 38: /* redirection: NUMBER GREATER_AND NUMBER  */
-#line 646 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.dest = (yyvsp[0].number);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_output, redir, 0);
-			}
-#line 2339 "y.tab.c"
-    break;
-
-  case 39: /* redirection: REDIR_WORD GREATER_AND NUMBER  */
-#line 652 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.dest = (yyvsp[0].number);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_output, redir, REDIR_VARASSIGN);
-			}
-#line 2349 "y.tab.c"
-    break;
-
-  case 40: /* redirection: LESS_AND WORD  */
-#line 658 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 0;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_input_word, redir, 0);
-			}
-#line 2359 "y.tab.c"
-    break;
-
-  case 41: /* redirection: NUMBER LESS_AND WORD  */
-#line 664 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_input_word, redir, 0);
-			}
-#line 2369 "y.tab.c"
-    break;
-
-  case 42: /* redirection: REDIR_WORD LESS_AND WORD  */
-#line 670 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_input_word, redir, REDIR_VARASSIGN);
-			}
-#line 2379 "y.tab.c"
-    break;
-
-  case 43: /* redirection: GREATER_AND WORD  */
-#line 676 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 1;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_output_word, redir, 0);
-			}
-#line 2389 "y.tab.c"
-    break;
-
-  case 44: /* redirection: NUMBER GREATER_AND WORD  */
-#line 682 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_output_word, redir, 0);
-			}
-#line 2399 "y.tab.c"
-    break;
-
-  case 45: /* redirection: REDIR_WORD GREATER_AND WORD  */
-#line 688 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_duplicating_output_word, redir, REDIR_VARASSIGN);
-			}
-#line 2409 "y.tab.c"
-    break;
-
-  case 46: /* redirection: GREATER_AND '-'  */
-#line 694 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 1;
-			  redir.dest = 0;
-			  (yyval.redirect) = make_redirection (source, r_close_this, redir, 0);
-			}
-#line 2419 "y.tab.c"
-    break;
-
-  case 47: /* redirection: NUMBER GREATER_AND '-'  */
-#line 700 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.dest = 0;
-			  (yyval.redirect) = make_redirection (source, r_close_this, redir, 0);
-			}
-#line 2429 "y.tab.c"
-    break;
-
-  case 48: /* redirection: REDIR_WORD GREATER_AND '-'  */
-#line 706 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.dest = 0;
-			  (yyval.redirect) = make_redirection (source, r_close_this, redir, REDIR_VARASSIGN);
-			}
-#line 2439 "y.tab.c"
-    break;
-
-  case 49: /* redirection: LESS_AND '-'  */
-#line 712 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 0;
-			  redir.dest = 0;
-			  (yyval.redirect) = make_redirection (source, r_close_this, redir, 0);
-			}
-#line 2449 "y.tab.c"
-    break;
-
-  case 50: /* redirection: NUMBER LESS_AND '-'  */
-#line 718 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = (yyvsp[-2].number);
-			  redir.dest = 0;
-			  (yyval.redirect) = make_redirection (source, r_close_this, redir, 0);
-			}
-#line 2459 "y.tab.c"
-    break;
-
-  case 51: /* redirection: REDIR_WORD LESS_AND '-'  */
-#line 724 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.filename = (yyvsp[-2].word);
-			  redir.dest = 0;
-			  (yyval.redirect) = make_redirection (source, r_close_this, redir, REDIR_VARASSIGN);
-			}
-#line 2469 "y.tab.c"
-    break;
-
-  case 52: /* redirection: AND_GREATER WORD  */
-#line 730 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 1;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_err_and_out, redir, 0);
-			}
-#line 2479 "y.tab.c"
-    break;
-
-  case 53: /* redirection: AND_GREATER_GREATER WORD  */
-#line 736 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  source.dest = 1;
-			  redir.filename = (yyvsp[0].word);
-			  (yyval.redirect) = make_redirection (source, r_append_err_and_out, redir, 0);
-			}
-#line 2489 "y.tab.c"
-    break;
-
-  case 54: /* simple_command_element: WORD  */
-#line 744 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.element).word = (yyvsp[0].word); (yyval.element).redirect = 0; }
-#line 2495 "y.tab.c"
-    break;
-
-  case 55: /* simple_command_element: ASSIGNMENT_WORD  */
-#line 746 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.element).word = (yyvsp[0].word); (yyval.element).redirect = 0; }
-#line 2501 "y.tab.c"
-    break;
-
-  case 56: /* simple_command_element: redirection  */
-#line 748 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.element).redirect = (yyvsp[0].redirect); (yyval.element).word = 0; }
-#line 2507 "y.tab.c"
-    break;
-
-  case 57: /* redirection_list: redirection  */
-#line 752 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.redirect) = (yyvsp[0].redirect);
-			}
-#line 2515 "y.tab.c"
-    break;
-
-  case 58: /* redirection_list: redirection_list redirection  */
-#line 756 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  register REDIRECT *t;
-
-			  for (t = (yyvsp[-1].redirect); t->next; t = t->next)
-			    ;
-			  t->next = (yyvsp[0].redirect);
-			  (yyval.redirect) = (yyvsp[-1].redirect);
-			}
-#line 2528 "y.tab.c"
-    break;
-
-  case 59: /* simple_command: simple_command_element  */
-#line 767 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_simple_command ((yyvsp[0].element), (COMMAND *)NULL); }
-#line 2534 "y.tab.c"
-    break;
-
-  case 60: /* simple_command: simple_command simple_command_element  */
-#line 769 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_simple_command ((yyvsp[0].element), (yyvsp[-1].command)); }
-#line 2540 "y.tab.c"
-    break;
-
-  case 61: /* command: simple_command  */
-#line 773 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = clean_simple_command ((yyvsp[0].command)); }
-#line 2546 "y.tab.c"
-    break;
-
-  case 62: /* command: shell_command  */
-#line 775 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2552 "y.tab.c"
-    break;
-
-  case 63: /* command: shell_command redirection_list  */
-#line 777 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  COMMAND *tc;
-
-			  tc = (yyvsp[-1].command);
-			  if (tc && tc->redirects)
-			    {
-			      register REDIRECT *t;
-			      for (t = tc->redirects; t->next; t = t->next)
-				;
-			      t->next = (yyvsp[0].redirect);
-			    }
-			  else if (tc)
-			    tc->redirects = (yyvsp[0].redirect);
-			  (yyval.command) = (yyvsp[-1].command);
-			}
-#line 2572 "y.tab.c"
-    break;
-
-  case 64: /* command: function_def  */
-#line 793 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2578 "y.tab.c"
-    break;
-
-  case 65: /* command: coproc  */
-#line 795 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2584 "y.tab.c"
-    break;
-
-  case 66: /* shell_command: for_command  */
-#line 799 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2590 "y.tab.c"
-    break;
-
-  case 67: /* shell_command: case_command  */
-#line 801 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2596 "y.tab.c"
-    break;
-
-  case 68: /* shell_command: WHILE compound_list DO compound_list DONE  */
-#line 803 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_while_command ((yyvsp[-3].command), (yyvsp[-1].command)); }
-#line 2602 "y.tab.c"
-    break;
-
-  case 69: /* shell_command: UNTIL compound_list DO compound_list DONE  */
-#line 805 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_until_command ((yyvsp[-3].command), (yyvsp[-1].command)); }
-#line 2608 "y.tab.c"
-    break;
-
-  case 70: /* shell_command: select_command  */
-#line 807 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2614 "y.tab.c"
-    break;
-
-  case 71: /* shell_command: if_command  */
-#line 809 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2620 "y.tab.c"
-    break;
-
-  case 72: /* shell_command: subshell  */
-#line 811 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2626 "y.tab.c"
-    break;
-
-  case 73: /* shell_command: group_command  */
-#line 813 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2632 "y.tab.c"
-    break;
-
-  case 74: /* shell_command: arith_command  */
-#line 815 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2638 "y.tab.c"
-    break;
-
-  case 75: /* shell_command: cond_command  */
-#line 817 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2644 "y.tab.c"
-    break;
-
-  case 76: /* shell_command: arith_for_command  */
-#line 819 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2650 "y.tab.c"
-    break;
-
-  case 77: /* for_command: FOR WORD newline_list DO compound_list DONE  */
-#line 823 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_for_command ((yyvsp[-4].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2659 "y.tab.c"
-    break;
-
-  case 78: /* for_command: FOR WORD newline_list '{' compound_list '}'  */
-#line 828 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_for_command ((yyvsp[-4].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2668 "y.tab.c"
-    break;
-
-  case 79: /* for_command: FOR WORD ';' newline_list DO compound_list DONE  */
-#line 833 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_for_command ((yyvsp[-5].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2677 "y.tab.c"
-    break;
-
-  case 80: /* for_command: FOR WORD ';' newline_list '{' compound_list '}'  */
-#line 838 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_for_command ((yyvsp[-5].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2686 "y.tab.c"
-    break;
-
-  case 81: /* for_command: FOR WORD newline_list IN word_list list_terminator newline_list DO compound_list DONE  */
-#line 843 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_for_command ((yyvsp[-8].word), REVERSE_LIST ((yyvsp[-5].word_list), WORD_LIST *), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2695 "y.tab.c"
-    break;
-
-  case 82: /* for_command: FOR WORD newline_list IN word_list list_terminator newline_list '{' compound_list '}'  */
-#line 848 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_for_command ((yyvsp[-8].word), REVERSE_LIST ((yyvsp[-5].word_list), WORD_LIST *), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2704 "y.tab.c"
-    break;
-
-  case 83: /* for_command: FOR WORD newline_list IN list_terminator newline_list DO compound_list DONE  */
-#line 853 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_for_command ((yyvsp[-7].word), (WORD_LIST *)NULL, (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2713 "y.tab.c"
-    break;
-
-  case 84: /* for_command: FOR WORD newline_list IN list_terminator newline_list '{' compound_list '}'  */
-#line 858 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_for_command ((yyvsp[-7].word), (WORD_LIST *)NULL, (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2722 "y.tab.c"
-    break;
-
-  case 85: /* arith_for_command: FOR ARITH_FOR_EXPRS list_terminator newline_list DO compound_list DONE  */
-#line 865 "/usr/local/src/chet/src/bash/src/parse.y"
-                                {
-				  (yyval.command) = make_arith_for_command ((yyvsp[-5].word_list), (yyvsp[-1].command), arith_for_lineno);
-				  if ((yyval.command) == 0) YYERROR;
-				  if (word_top > 0) word_top--;
-				}
-#line 2732 "y.tab.c"
-    break;
-
-  case 86: /* arith_for_command: FOR ARITH_FOR_EXPRS list_terminator newline_list '{' compound_list '}'  */
-#line 871 "/usr/local/src/chet/src/bash/src/parse.y"
-                                {
-				  (yyval.command) = make_arith_for_command ((yyvsp[-5].word_list), (yyvsp[-1].command), arith_for_lineno);
-				  if ((yyval.command) == 0) YYERROR;
-				  if (word_top > 0) word_top--;
-				}
-#line 2742 "y.tab.c"
-    break;
-
-  case 87: /* arith_for_command: FOR ARITH_FOR_EXPRS DO compound_list DONE  */
-#line 877 "/usr/local/src/chet/src/bash/src/parse.y"
-                                {
-				  (yyval.command) = make_arith_for_command ((yyvsp[-3].word_list), (yyvsp[-1].command), arith_for_lineno);
-				  if ((yyval.command) == 0) YYERROR;
-				  if (word_top > 0) word_top--;
-				}
-#line 2752 "y.tab.c"
-    break;
-
-  case 88: /* arith_for_command: FOR ARITH_FOR_EXPRS '{' compound_list '}'  */
-#line 883 "/usr/local/src/chet/src/bash/src/parse.y"
-                                {
-				  (yyval.command) = make_arith_for_command ((yyvsp[-3].word_list), (yyvsp[-1].command), arith_for_lineno);
-				  if ((yyval.command) == 0) YYERROR;
-				  if (word_top > 0) word_top--;
-				}
-#line 2762 "y.tab.c"
-    break;
-
-  case 89: /* select_command: SELECT WORD newline_list DO compound_list DONE  */
-#line 891 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_select_command ((yyvsp[-4].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2771 "y.tab.c"
-    break;
-
-  case 90: /* select_command: SELECT WORD newline_list '{' compound_list '}'  */
-#line 896 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_select_command ((yyvsp[-4].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2780 "y.tab.c"
-    break;
-
-  case 91: /* select_command: SELECT WORD ';' newline_list DO compound_list DONE  */
-#line 901 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_select_command ((yyvsp[-5].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2789 "y.tab.c"
-    break;
-
-  case 92: /* select_command: SELECT WORD ';' newline_list '{' compound_list '}'  */
-#line 906 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_select_command ((yyvsp[-5].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2798 "y.tab.c"
-    break;
-
-  case 93: /* select_command: SELECT WORD newline_list IN word_list list_terminator newline_list DO compound_list DONE  */
-#line 911 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_select_command ((yyvsp[-8].word), REVERSE_LIST ((yyvsp[-5].word_list), WORD_LIST *), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2807 "y.tab.c"
-    break;
-
-  case 94: /* select_command: SELECT WORD newline_list IN word_list list_terminator newline_list '{' compound_list '}'  */
-#line 916 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_select_command ((yyvsp[-8].word), REVERSE_LIST ((yyvsp[-5].word_list), WORD_LIST *), (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2816 "y.tab.c"
-    break;
-
-  case 95: /* select_command: SELECT WORD newline_list IN list_terminator newline_list DO compound_list DONE  */
-#line 921 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_select_command ((yyvsp[-7].word), (WORD_LIST *)NULL, (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2825 "y.tab.c"
-    break;
-
-  case 96: /* select_command: SELECT WORD newline_list IN list_terminator newline_list '{' compound_list '}'  */
-#line 926 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_select_command ((yyvsp[-7].word), (WORD_LIST *)NULL, (yyvsp[-1].command), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2834 "y.tab.c"
-    break;
-
-  case 97: /* case_command: CASE WORD newline_list IN newline_list ESAC  */
-#line 933 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_case_command ((yyvsp[-4].word), (PATTERN_LIST *)NULL, word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2843 "y.tab.c"
-    break;
-
-  case 98: /* case_command: CASE WORD newline_list IN case_clause_sequence newline_list ESAC  */
-#line 938 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_case_command ((yyvsp[-5].word), (yyvsp[-2].pattern), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2852 "y.tab.c"
-    break;
-
-  case 99: /* case_command: CASE WORD newline_list IN case_clause ESAC  */
-#line 943 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_case_command ((yyvsp[-4].word), (yyvsp[-1].pattern), word_lineno[word_top]);
-			  if (word_top > 0) word_top--;
-			}
-#line 2861 "y.tab.c"
-    break;
-
-  case 100: /* function_def: WORD '(' ')' newline_list function_body  */
-#line 950 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_function_def ((yyvsp[-4].word), (yyvsp[0].command), function_dstart, function_bstart); }
-#line 2867 "y.tab.c"
-    break;
-
-  case 101: /* function_def: FUNCTION WORD '(' ')' newline_list function_body  */
-#line 952 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_function_def ((yyvsp[-4].word), (yyvsp[0].command), function_dstart, function_bstart); }
-#line 2873 "y.tab.c"
-    break;
-
-  case 102: /* function_def: FUNCTION WORD function_body  */
-#line 954 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_function_def ((yyvsp[-1].word), (yyvsp[0].command), function_dstart, function_bstart); }
-#line 2879 "y.tab.c"
-    break;
-
-  case 103: /* function_def: FUNCTION WORD '\n' newline_list function_body  */
-#line 956 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_function_def ((yyvsp[-3].word), (yyvsp[0].command), function_dstart, function_bstart); }
-#line 2885 "y.tab.c"
-    break;
-
-  case 104: /* function_body: shell_command  */
-#line 960 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 2891 "y.tab.c"
-    break;
-
-  case 105: /* function_body: shell_command redirection_list  */
-#line 962 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  COMMAND *tc;
-
-			  tc = (yyvsp[-1].command);
-			  /* According to Posix.2 3.9.5, redirections
-			     specified after the body of a function should
-			     be attached to the function and performed when
-			     the function is executed, not as part of the
-			     function definition command. */
-			  /* XXX - I don't think it matters, but we might
-			     want to change this in the future to avoid
-			     problems differentiating between a function
-			     definition with a redirection and a function
-			     definition containing a single command with a
-			     redirection.  The two are semantically equivalent,
-			     though -- the only difference is in how the
-			     command printing code displays the redirections. */
-			  if (tc && tc->redirects)
-			    {
-			      register REDIRECT *t;
-			      for (t = tc->redirects; t->next; t = t->next)
-				;
-			      t->next = (yyvsp[0].redirect);
-			    }
-			  else if (tc)
-			    tc->redirects = (yyvsp[0].redirect);
-			  (yyval.command) = (yyvsp[-1].command);
-			}
-#line 2924 "y.tab.c"
-    break;
-
-  case 106: /* subshell: '(' compound_list ')'  */
-#line 993 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_subshell_command ((yyvsp[-1].command));
-			  (yyval.command)->flags |= CMD_WANT_SUBSHELL;
-			}
-#line 2933 "y.tab.c"
-    break;
-
-  case 107: /* comsub: DOLPAREN compound_list ')'  */
-#line 1000 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = (yyvsp[-1].command);
-			}
-#line 2941 "y.tab.c"
-    break;
-
-  case 108: /* comsub: DOLPAREN newline_list ')'  */
-#line 1004 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = (COMMAND *)NULL;
-			}
-#line 2949 "y.tab.c"
-    break;
-
-  case 109: /* coproc: COPROC shell_command  */
-#line 1010 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_coproc_command ("COPROC", (yyvsp[0].command));
-			  (yyval.command)->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
-			}
-#line 2958 "y.tab.c"
-    break;
-
-  case 110: /* coproc: COPROC shell_command redirection_list  */
-#line 1015 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  COMMAND *tc;
-
-			  tc = (yyvsp[-1].command);
-			  if (tc && tc->redirects)
-			    {
-			      register REDIRECT *t;
-			      for (t = tc->redirects; t->next; t = t->next)
-				;
-			      t->next = (yyvsp[0].redirect);
-			    }
-			  else if (tc)
-			    tc->redirects = (yyvsp[0].redirect);
-			  (yyval.command) = make_coproc_command ("COPROC", (yyvsp[-1].command));
-			  (yyval.command)->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
-			}
-#line 2979 "y.tab.c"
-    break;
-
-  case 111: /* coproc: COPROC WORD shell_command  */
-#line 1032 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_coproc_command ((yyvsp[-1].word)->word, (yyvsp[0].command));
-			  (yyval.command)->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
-			}
-#line 2988 "y.tab.c"
-    break;
-
-  case 112: /* coproc: COPROC WORD shell_command redirection_list  */
-#line 1037 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  COMMAND *tc;
-
-			  tc = (yyvsp[-1].command);
-			  if (tc && tc->redirects)
-			    {
-			      register REDIRECT *t;
-			      for (t = tc->redirects; t->next; t = t->next)
-				;
-			      t->next = (yyvsp[0].redirect);
-			    }
-			  else if (tc)
-			    tc->redirects = (yyvsp[0].redirect);
-			  (yyval.command) = make_coproc_command ((yyvsp[-2].word)->word, (yyvsp[-1].command));
-			  (yyval.command)->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
-			}
-#line 3009 "y.tab.c"
-    break;
-
-  case 113: /* coproc: COPROC simple_command  */
-#line 1054 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = make_coproc_command ("COPROC", clean_simple_command ((yyvsp[0].command)));
-			  (yyval.command)->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
-			}
-#line 3018 "y.tab.c"
-    break;
-
-  case 114: /* if_command: IF compound_list THEN compound_list FI  */
-#line 1061 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_if_command ((yyvsp[-3].command), (yyvsp[-1].command), (COMMAND *)NULL); }
-#line 3024 "y.tab.c"
-    break;
-
-  case 115: /* if_command: IF compound_list THEN compound_list ELSE compound_list FI  */
-#line 1063 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_if_command ((yyvsp[-5].command), (yyvsp[-3].command), (yyvsp[-1].command)); }
-#line 3030 "y.tab.c"
-    break;
-
-  case 116: /* if_command: IF compound_list THEN compound_list elif_clause FI  */
-#line 1065 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_if_command ((yyvsp[-4].command), (yyvsp[-2].command), (yyvsp[-1].command)); }
-#line 3036 "y.tab.c"
-    break;
-
-  case 117: /* group_command: '{' compound_list '}'  */
-#line 1070 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_group_command ((yyvsp[-1].command)); }
-#line 3042 "y.tab.c"
-    break;
-
-  case 118: /* arith_command: ARITH_CMD  */
-#line 1074 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_arith_command ((yyvsp[0].word_list)); }
-#line 3048 "y.tab.c"
-    break;
-
-  case 119: /* cond_command: COND_START COND_CMD COND_END  */
-#line 1078 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[-1].command); }
-#line 3054 "y.tab.c"
-    break;
-
-  case 120: /* elif_clause: ELIF compound_list THEN compound_list  */
-#line 1082 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_if_command ((yyvsp[-2].command), (yyvsp[0].command), (COMMAND *)NULL); }
-#line 3060 "y.tab.c"
-    break;
-
-  case 121: /* elif_clause: ELIF compound_list THEN compound_list ELSE compound_list  */
-#line 1084 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_if_command ((yyvsp[-4].command), (yyvsp[-2].command), (yyvsp[0].command)); }
-#line 3066 "y.tab.c"
-    break;
-
-  case 122: /* elif_clause: ELIF compound_list THEN compound_list elif_clause  */
-#line 1086 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = make_if_command ((yyvsp[-3].command), (yyvsp[-1].command), (yyvsp[0].command)); }
-#line 3072 "y.tab.c"
-    break;
-
-  case 124: /* case_clause: case_clause_sequence pattern_list  */
-#line 1091 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyvsp[0].pattern)->next = (yyvsp[-1].pattern); (yyval.pattern) = (yyvsp[0].pattern); }
-#line 3078 "y.tab.c"
-    break;
-
-  case 125: /* pattern_list: newline_list pattern ')' compound_list  */
-#line 1095 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.pattern) = make_pattern_list ((yyvsp[-2].word_list), (yyvsp[0].command)); }
-#line 3084 "y.tab.c"
-    break;
-
-  case 126: /* pattern_list: newline_list pattern ')' newline_list  */
-#line 1097 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.pattern) = make_pattern_list ((yyvsp[-2].word_list), (COMMAND *)NULL); }
-#line 3090 "y.tab.c"
-    break;
-
-  case 127: /* pattern_list: newline_list '(' pattern ')' compound_list  */
-#line 1099 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.pattern) = make_pattern_list ((yyvsp[-2].word_list), (yyvsp[0].command)); }
-#line 3096 "y.tab.c"
-    break;
-
-  case 128: /* pattern_list: newline_list '(' pattern ')' newline_list  */
-#line 1101 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.pattern) = make_pattern_list ((yyvsp[-2].word_list), (COMMAND *)NULL); }
-#line 3102 "y.tab.c"
-    break;
-
-  case 129: /* case_clause_sequence: pattern_list SEMI_SEMI  */
-#line 1105 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.pattern) = (yyvsp[-1].pattern); }
-#line 3108 "y.tab.c"
-    break;
-
-  case 130: /* case_clause_sequence: case_clause_sequence pattern_list SEMI_SEMI  */
-#line 1107 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyvsp[-1].pattern)->next = (yyvsp[-2].pattern); (yyval.pattern) = (yyvsp[-1].pattern); }
-#line 3114 "y.tab.c"
-    break;
-
-  case 131: /* case_clause_sequence: pattern_list SEMI_AND  */
-#line 1109 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyvsp[-1].pattern)->flags |= CASEPAT_FALLTHROUGH; (yyval.pattern) = (yyvsp[-1].pattern); }
-#line 3120 "y.tab.c"
-    break;
-
-  case 132: /* case_clause_sequence: case_clause_sequence pattern_list SEMI_AND  */
-#line 1111 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyvsp[-1].pattern)->flags |= CASEPAT_FALLTHROUGH; (yyvsp[-1].pattern)->next = (yyvsp[-2].pattern); (yyval.pattern) = (yyvsp[-1].pattern); }
-#line 3126 "y.tab.c"
-    break;
-
-  case 133: /* case_clause_sequence: pattern_list SEMI_SEMI_AND  */
-#line 1113 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyvsp[-1].pattern)->flags |= CASEPAT_TESTNEXT; (yyval.pattern) = (yyvsp[-1].pattern); }
-#line 3132 "y.tab.c"
-    break;
-
-  case 134: /* case_clause_sequence: case_clause_sequence pattern_list SEMI_SEMI_AND  */
-#line 1115 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyvsp[-1].pattern)->flags |= CASEPAT_TESTNEXT; (yyvsp[-1].pattern)->next = (yyvsp[-2].pattern); (yyval.pattern) = (yyvsp[-1].pattern); }
-#line 3138 "y.tab.c"
-    break;
-
-  case 135: /* pattern: WORD  */
-#line 1119 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.word_list) = make_word_list ((yyvsp[0].word), (WORD_LIST *)NULL); }
-#line 3144 "y.tab.c"
-    break;
-
-  case 136: /* pattern: pattern '|' WORD  */
-#line 1121 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.word_list) = make_word_list ((yyvsp[0].word), (yyvsp[-2].word_list)); }
-#line 3150 "y.tab.c"
-    break;
-
-  case 137: /* compound_list: newline_list list0  */
-#line 1130 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = (yyvsp[0].command);
-			  if (need_here_doc && last_read_token == '\n')
-			    gather_here_documents ();
-			 }
-#line 3160 "y.tab.c"
-    break;
-
-  case 138: /* compound_list: newline_list list1  */
-#line 1136 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = (yyvsp[0].command);
-			}
-#line 3168 "y.tab.c"
-    break;
-
-  case 140: /* list0: list1 '&' newline_list  */
-#line 1143 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  if ((yyvsp[-2].command)->type == cm_connection)
-			    (yyval.command) = connect_async_list ((yyvsp[-2].command), (COMMAND *)NULL, '&');
-			  else
-			    (yyval.command) = command_connect ((yyvsp[-2].command), (COMMAND *)NULL, '&');
-			}
-#line 3179 "y.tab.c"
-    break;
-
-  case 142: /* list1: list1 AND_AND newline_list list1  */
-#line 1154 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = command_connect ((yyvsp[-3].command), (yyvsp[0].command), AND_AND); }
-#line 3185 "y.tab.c"
-    break;
-
-  case 143: /* list1: list1 OR_OR newline_list list1  */
-#line 1156 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = command_connect ((yyvsp[-3].command), (yyvsp[0].command), OR_OR); }
-#line 3191 "y.tab.c"
-    break;
-
-  case 144: /* list1: list1 '&' newline_list list1  */
-#line 1158 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  if ((yyvsp[-3].command)->type == cm_connection)
-			    (yyval.command) = connect_async_list ((yyvsp[-3].command), (yyvsp[0].command), '&');
-			  else
-			    (yyval.command) = command_connect ((yyvsp[-3].command), (yyvsp[0].command), '&');
-			}
-#line 3202 "y.tab.c"
-    break;
-
-  case 145: /* list1: list1 ';' newline_list list1  */
-#line 1165 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = command_connect ((yyvsp[-3].command), (yyvsp[0].command), ';'); }
-#line 3208 "y.tab.c"
-    break;
-
-  case 146: /* list1: list1 '\n' newline_list list1  */
-#line 1167 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  if (parser_state & PST_CMDSUBST)
-			    (yyval.command) = command_connect ((yyvsp[-3].command), (yyvsp[0].command), '\n');
-			  else
-			    (yyval.command) = command_connect ((yyvsp[-3].command), (yyvsp[0].command), ';');
-			}
-#line 3219 "y.tab.c"
-    break;
-
-  case 147: /* list1: pipeline_command  */
-#line 1174 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 3225 "y.tab.c"
-    break;
-
-  case 150: /* list_terminator: '\n'  */
-#line 1182 "/usr/local/src/chet/src/bash/src/parse.y"
-                { (yyval.number) = '\n'; }
-#line 3231 "y.tab.c"
-    break;
-
-  case 151: /* list_terminator: ';'  */
-#line 1184 "/usr/local/src/chet/src/bash/src/parse.y"
-                { (yyval.number) = ';'; }
-#line 3237 "y.tab.c"
-    break;
-
-  case 152: /* list_terminator: yacc_EOF  */
-#line 1186 "/usr/local/src/chet/src/bash/src/parse.y"
-                { (yyval.number) = yacc_EOF; }
-#line 3243 "y.tab.c"
-    break;
-
-  case 155: /* simple_list: simple_list1  */
-#line 1200 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = (yyvsp[0].command);
-			  if (need_here_doc)
-			    gather_here_documents ();	/* XXX */
-			  if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
-			    {
-INTERNAL_DEBUG (("LEGACY: parser: command substitution simple_list1 -> simple_list"));
-			      global_command = (yyvsp[0].command);
-			      eof_encountered = 0;
-			      if (bash_input.type == st_string)
-				rewind_input_string ();
-			      YYACCEPT;
-			    }
-			}
-#line 3262 "y.tab.c"
-    break;
-
-  case 156: /* simple_list: simple_list1 '&'  */
-#line 1215 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  if ((yyvsp[-1].command)->type == cm_connection)
-			    (yyval.command) = connect_async_list ((yyvsp[-1].command), (COMMAND *)NULL, '&');
-			  else
-			    (yyval.command) = command_connect ((yyvsp[-1].command), (COMMAND *)NULL, '&');
-			  if (need_here_doc)
-			    gather_here_documents (); /* XXX */
-			  if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
-			    {
-INTERNAL_DEBUG (("LEGACY: parser: command substitution simple_list1 '&' -> simple_list"));
-			      global_command = (yyvsp[-1].command);
-			      eof_encountered = 0;
-			      if (bash_input.type == st_string)
-				rewind_input_string ();
-			      YYACCEPT;
-			    }
-			}
-#line 3284 "y.tab.c"
-    break;
-
-  case 157: /* simple_list: simple_list1 ';'  */
-#line 1233 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  (yyval.command) = (yyvsp[-1].command);
-			  if (need_here_doc)
-			    gather_here_documents ();	/* XXX */
-			  if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
-			    {
-INTERNAL_DEBUG (("LEGACY: parser: command substitution simple_list1 ';' -> simple_list"));
-			      global_command = (yyvsp[-1].command);
-			      eof_encountered = 0;
-			      if (bash_input.type == st_string)
-				rewind_input_string ();
-			      YYACCEPT;
-			    }
-			}
-#line 3303 "y.tab.c"
-    break;
-
-  case 158: /* simple_list1: simple_list1 AND_AND newline_list simple_list1  */
-#line 1250 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = command_connect ((yyvsp[-3].command), (yyvsp[0].command), AND_AND); }
-#line 3309 "y.tab.c"
-    break;
-
-  case 159: /* simple_list1: simple_list1 OR_OR newline_list simple_list1  */
-#line 1252 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = command_connect ((yyvsp[-3].command), (yyvsp[0].command), OR_OR); }
-#line 3315 "y.tab.c"
-    break;
-
-  case 160: /* simple_list1: simple_list1 '&' simple_list1  */
-#line 1254 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  if ((yyvsp[-2].command)->type == cm_connection)
-			    (yyval.command) = connect_async_list ((yyvsp[-2].command), (yyvsp[0].command), '&');
-			  else
-			    (yyval.command) = command_connect ((yyvsp[-2].command), (yyvsp[0].command), '&');
-			}
-#line 3326 "y.tab.c"
-    break;
-
-  case 161: /* simple_list1: simple_list1 ';' simple_list1  */
-#line 1261 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = command_connect ((yyvsp[-2].command), (yyvsp[0].command), ';'); }
-#line 3332 "y.tab.c"
-    break;
-
-  case 162: /* simple_list1: pipeline_command  */
-#line 1264 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 3338 "y.tab.c"
-    break;
-
-  case 163: /* pipeline_command: pipeline  */
-#line 1268 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 3344 "y.tab.c"
-    break;
-
-  case 164: /* pipeline_command: BANG pipeline_command  */
-#line 1270 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  if ((yyvsp[0].command))
-			    (yyvsp[0].command)->flags ^= CMD_INVERT_RETURN;	/* toggle */
-			  (yyval.command) = (yyvsp[0].command);
-			}
-#line 3354 "y.tab.c"
-    break;
-
-  case 165: /* pipeline_command: timespec pipeline_command  */
-#line 1276 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  if ((yyvsp[0].command))
-			    (yyvsp[0].command)->flags |= (yyvsp[-1].number);
-			  (yyval.command) = (yyvsp[0].command);
-			}
-#line 3364 "y.tab.c"
-    break;
-
-  case 166: /* pipeline_command: timespec list_terminator  */
-#line 1282 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  ELEMENT x;
-
-			  /* Boy, this is unclean.  `time' by itself can
-			     time a null command.  We cheat and push a
-			     newline back if the list_terminator was a newline
-			     to avoid the double-newline problem (one to
-			     terminate this, one to terminate the command) */
-			  x.word = 0;
-			  x.redirect = 0;
-			  (yyval.command) = make_simple_command (x, (COMMAND *)NULL);
-			  (yyval.command)->flags |= (yyvsp[-1].number);
-			  /* XXX - let's cheat and push a newline back */
-			  if ((yyvsp[0].number) == '\n')
-			    token_to_read = '\n';
-			  else if ((yyvsp[0].number) == ';')
-			    token_to_read = ';';
-			  parser_state &= ~PST_REDIRLIST;	/* make_simple_command sets this */
-			}
-#line 3388 "y.tab.c"
-    break;
-
-  case 167: /* pipeline_command: BANG list_terminator  */
-#line 1302 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  ELEMENT x;
-
-			  /* This is just as unclean.  Posix says that `!'
-			     by itself should be equivalent to `false'.
-			     We cheat and push a
-			     newline back if the list_terminator was a newline
-			     to avoid the double-newline problem (one to
-			     terminate this, one to terminate the command) */
-			  x.word = 0;
-			  x.redirect = 0;
-			  (yyval.command) = make_simple_command (x, (COMMAND *)NULL);
-			  (yyval.command)->flags |= CMD_INVERT_RETURN;
-			  /* XXX - let's cheat and push a newline back */
-			  if ((yyvsp[0].number) == '\n')
-			    token_to_read = '\n';
-			  if ((yyvsp[0].number) == ';')
-			    token_to_read = ';';
-			  parser_state &= ~PST_REDIRLIST;	/* make_simple_command sets this */
-			}
-#line 3413 "y.tab.c"
-    break;
-
-  case 168: /* pipeline: pipeline '|' newline_list pipeline  */
-#line 1325 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = command_connect ((yyvsp[-3].command), (yyvsp[0].command), '|'); }
-#line 3419 "y.tab.c"
-    break;
-
-  case 169: /* pipeline: pipeline BAR_AND newline_list pipeline  */
-#line 1327 "/usr/local/src/chet/src/bash/src/parse.y"
-                        {
-			  /* Make cmd1 |& cmd2 equivalent to cmd1 2>&1 | cmd2 */
-			  COMMAND *tc;
-			  REDIRECTEE rd, sd;
-			  REDIRECT *r;
-
-			  tc = (yyvsp[-3].command)->type == cm_simple ? (COMMAND *)(yyvsp[-3].command)->value.Simple : (yyvsp[-3].command);
-			  sd.dest = 2;
-			  rd.dest = 1;
-			  r = make_redirection (sd, r_duplicating_output, rd, 0);
-			  if (tc->redirects)
-			    {
-			      register REDIRECT *t;
-			      for (t = tc->redirects; t->next; t = t->next)
-				;
-			      t->next = r;
-			    }
-			  else
-			    tc->redirects = r;
-
-			  (yyval.command) = command_connect ((yyvsp[-3].command), (yyvsp[0].command), '|');
-			}
-#line 3446 "y.tab.c"
-    break;
-
-  case 170: /* pipeline: command  */
-#line 1350 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.command) = (yyvsp[0].command); }
-#line 3452 "y.tab.c"
-    break;
-
-  case 171: /* timespec: TIME  */
-#line 1354 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.number) = CMD_TIME_PIPELINE; }
-#line 3458 "y.tab.c"
-    break;
-
-  case 172: /* timespec: TIME TIMEOPT  */
-#line 1356 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.number) = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
-#line 3464 "y.tab.c"
-    break;
-
-  case 173: /* timespec: TIME TIMEIGN  */
-#line 1358 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.number) = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
-#line 3470 "y.tab.c"
-    break;
-
-  case 174: /* timespec: TIME TIMEOPT TIMEIGN  */
-#line 1360 "/usr/local/src/chet/src/bash/src/parse.y"
-                        { (yyval.number) = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
-#line 3476 "y.tab.c"
-    break;
-
-
-#line 3480 "y.tab.c"
-
-      default: break;
-    }
-  /* User semantic actions sometimes alter yychar, and that requires
-     that yytoken be updated with the new translation.  We take the
-     approach of translating immediately before every use of yytoken.
-     One alternative is translating here after every semantic action,
-     but that translation would be missed if the semantic action invokes
-     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
-     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
-     incorrect destructor might then be invoked immediately.  In the
-     case of YYERROR or YYBACKUP, subsequent parser actions might lead
-     to an incorrect destructor call or verbose syntax error message
-     before the lookahead is translated.  */
-  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
-
-  YYPOPSTACK (yylen);
-  yylen = 0;
-
-  *++yyvsp = yyval;
-
-  /* Now 'shift' the result of the reduction.  Determine what state
-     that goes to, based on the state we popped back to and the rule
-     number reduced by.  */
-  {
-    const int yylhs = yyr1[yyn] - YYNTOKENS;
-    const int yyi = yypgoto[yylhs] + *yyssp;
-    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
-               ? yytable[yyi]
-               : yydefgoto[yylhs]);
-  }
-
-  goto yynewstate;
-
-
-/*--------------------------------------.
-| yyerrlab -- here on detecting error.  |
-`--------------------------------------*/
-yyerrlab:
-  /* Make sure we have latest lookahead translation.  See comments at
-     user semantic actions for why this is necessary.  */
-  yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
-  /* If not already recovering from an error, report this error.  */
-  if (!yyerrstatus)
-    {
-      ++yynerrs;
-      yyerror (YY_("syntax error"));
-    }
-
-  if (yyerrstatus == 3)
-    {
-      /* If just tried and failed to reuse lookahead token after an
-         error, discard it.  */
-
-      if (yychar <= YYEOF)
-        {
-          /* Return failure if at end of input.  */
-          if (yychar == YYEOF)
-            YYABORT;
-        }
-      else
-        {
-          yydestruct ("Error: discarding",
-                      yytoken, &yylval);
-          yychar = YYEMPTY;
-        }
-    }
-
-  /* Else will try to reuse lookahead token after shifting the error
-     token.  */
-  goto yyerrlab1;
-
-
-/*---------------------------------------------------.
-| yyerrorlab -- error raised explicitly by YYERROR.  |
-`---------------------------------------------------*/
-yyerrorlab:
-  /* Pacify compilers when the user code never invokes YYERROR and the
-     label yyerrorlab therefore never appears in user code.  */
-  if (0)
-    YYERROR;
-  ++yynerrs;
-
-  /* Do not reclaim the symbols of the rule whose action triggered
-     this YYERROR.  */
-  YYPOPSTACK (yylen);
-  yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
-  yystate = *yyssp;
-  goto yyerrlab1;
-
-
-/*-------------------------------------------------------------.
-| yyerrlab1 -- common code for both syntax error and YYERROR.  |
-`-------------------------------------------------------------*/
-yyerrlab1:
-  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
-
-  /* Pop stack until we find a state that shifts the error token.  */
-  for (;;)
-    {
-      yyn = yypact[yystate];
-      if (!yypact_value_is_default (yyn))
-        {
-          yyn += YYSYMBOL_YYerror;
-          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
-            {
-              yyn = yytable[yyn];
-              if (0 < yyn)
-                break;
-            }
-        }
-
-      /* Pop the current state because it cannot handle the error token.  */
-      if (yyssp == yyss)
-        YYABORT;
-
-
-      yydestruct ("Error: popping",
-                  YY_ACCESSING_SYMBOL (yystate), yyvsp);
-      YYPOPSTACK (1);
-      yystate = *yyssp;
-      YY_STACK_PRINT (yyss, yyssp);
-    }
-
-  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
-  *++yyvsp = yylval;
-  YY_IGNORE_MAYBE_UNINITIALIZED_END
-
-
-  /* Shift the error token.  */
-  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
-
-  yystate = yyn;
-  goto yynewstate;
-
-
-/*-------------------------------------.
-| yyacceptlab -- YYACCEPT comes here.  |
-`-------------------------------------*/
-yyacceptlab:
-  yyresult = 0;
-  goto yyreturnlab;
-
-
-/*-----------------------------------.
-| yyabortlab -- YYABORT comes here.  |
-`-----------------------------------*/
-yyabortlab:
-  yyresult = 1;
-  goto yyreturnlab;
-
-
-/*-----------------------------------------------------------.
-| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here.  |
-`-----------------------------------------------------------*/
-yyexhaustedlab:
-  yyerror (YY_("memory exhausted"));
-  yyresult = 2;
-  goto yyreturnlab;
-
-
-/*----------------------------------------------------------.
-| yyreturnlab -- parsing is finished, clean up and return.  |
-`----------------------------------------------------------*/
-yyreturnlab:
-  if (yychar != YYEMPTY)
-    {
-      /* Make sure we have latest lookahead translation.  See comments at
-         user semantic actions for why this is necessary.  */
-      yytoken = YYTRANSLATE (yychar);
-      yydestruct ("Cleanup: discarding lookahead",
-                  yytoken, &yylval);
-    }
-  /* Do not reclaim the symbols of the rule whose action triggered
-     this YYABORT or YYACCEPT.  */
-  YYPOPSTACK (yylen);
-  YY_STACK_PRINT (yyss, yyssp);
-  while (yyssp != yyss)
-    {
-      yydestruct ("Cleanup: popping",
-                  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
-      YYPOPSTACK (1);
-    }
-#ifndef yyoverflow
-  if (yyss != yyssa)
-    YYSTACK_FREE (yyss);
-#endif
-
-  return yyresult;
-}
-
-#line 1362 "/usr/local/src/chet/src/bash/src/parse.y"
-
-
-/* Initial size to allocate for tokens, and the
-   amount to grow them by. */
-#define TOKEN_DEFAULT_INITIAL_SIZE 496
-#define TOKEN_DEFAULT_GROW_SIZE 512
-
-/* Should we call prompt_again? */
-#define SHOULD_PROMPT() \
-  (interactive && (bash_input.type == st_stdin || bash_input.type == st_stream))
-
-#if defined (ALIAS)
-#  define expanding_alias() (pushed_string_list && pushed_string_list->expander)
-#else
-#  define expanding_alias() 0
-#endif
-
-/* Global var is non-zero when end of file has been reached. */
-int EOF_Reached = 0;
-
-#ifdef DEBUG
-static void
-debug_parser (i)
-     int i;
-{
-#if YYDEBUG != 0
-  yydebug = i;
-  yyoutstream = stdout;
-  yyerrstream = stderr;
-#endif
-}
-#endif
-
-/* yy_getc () returns the next available character from input or EOF.
-   yy_ungetc (c) makes `c' the next character to read.
-   init_yy_io (get, unget, type, location) makes the function GET the
-   installed function for getting the next character, makes UNGET the
-   installed function for un-getting a character, sets the type of stream
-   (either string or file) from TYPE, and makes LOCATION point to where
-   the input is coming from. */
-
-/* Unconditionally returns end-of-file. */
-int
-return_EOF ()
-{
-  return (EOF);
-}
-
-/* Variable containing the current get and unget functions.
-   See ./input.h for a clearer description. */
-BASH_INPUT bash_input;
-
-/* Set all of the fields in BASH_INPUT to NULL.  Free bash_input.name if it
-   is non-null, avoiding a memory leak. */
-void
-initialize_bash_input ()
-{
-  bash_input.type = st_none;
-  FREE (bash_input.name);
-  bash_input.name = (char *)NULL;
-  bash_input.location.file = (FILE *)NULL;
-  bash_input.location.string = (char *)NULL;
-  bash_input.getter = (sh_cget_func_t *)NULL;
-  bash_input.ungetter = (sh_cunget_func_t *)NULL;
-}
-
-/* Set the contents of the current bash input stream from
-   GET, UNGET, TYPE, NAME, and LOCATION. */
-void
-init_yy_io (get, unget, type, name, location)
-     sh_cget_func_t *get;
-     sh_cunget_func_t *unget;
-     enum stream_type type;
-     const char *name;
-     INPUT_STREAM location;
-{
-  bash_input.type = type;
-  FREE (bash_input.name);
-  bash_input.name = name ? savestring (name) : (char *)NULL;
-
-  /* XXX */
-#if defined (CRAY)
-  memcpy((char *)&bash_input.location.string, (char *)&location.string, sizeof(location));
-#else
-  bash_input.location = location;
-#endif
-  bash_input.getter = get;
-  bash_input.ungetter = unget;
-}
-
-char *
-yy_input_name ()
-{
-  return (bash_input.name ? bash_input.name : "stdin");
-}
-
-/* Call this to get the next character of input. */
-static int
-yy_getc ()
-{
-  return (*(bash_input.getter)) ();
-}
-
-/* Call this to unget C.  That is, to make C the next character
-   to be read. */
-static int
-yy_ungetc (c)
-     int c;
-{
-  return (*(bash_input.ungetter)) (c);
-}
-
-#if defined (BUFFERED_INPUT)
-#ifdef INCLUDE_UNUSED
-int
-input_file_descriptor ()
-{
-  switch (bash_input.type)
-    {
-    case st_stream:
-      return (fileno (bash_input.location.file));
-    case st_bstream:
-      return (bash_input.location.buffered_fd);
-    case st_stdin:
-    default:
-      return (fileno (stdin));
-    }
-}
-#endif
-#endif /* BUFFERED_INPUT */
-
-/* **************************************************************** */
-/*								    */
-/*		  Let input be read from readline ().		    */
-/*								    */
-/* **************************************************************** */
-
-#if defined (READLINE)
-char *current_readline_prompt = (char *)NULL;
-char *current_readline_line = (char *)NULL;
-int current_readline_line_index = 0;
-
-static int
-yy_readline_get ()
-{
-  SigHandler *old_sigint;
-  int line_len;
-  unsigned char c;
-
-  if (current_readline_line == 0)
-    {
-      if (bash_readline_initialized == 0)
-	initialize_readline ();
-
-#if defined (JOB_CONTROL)
-      if (job_control)
-	give_terminal_to (shell_pgrp, 0);
-#endif /* JOB_CONTROL */
-
-      old_sigint = IMPOSSIBLE_TRAP_HANDLER;
-      if (signal_is_ignored (SIGINT) == 0)
-	{
-	  old_sigint = (SigHandler *)set_signal_handler (SIGINT, sigint_sighandler);
-	}
-
-      sh_unset_nodelay_mode (fileno (rl_instream));	/* just in case */
-      current_readline_line = readline (current_readline_prompt ?
-      					  current_readline_prompt : "");
-
-      CHECK_TERMSIG;
-      if (signal_is_ignored (SIGINT) == 0)
-	{
-	  if (old_sigint != IMPOSSIBLE_TRAP_HANDLER)
-	    set_signal_handler (SIGINT, old_sigint);
-	}
-
-#if 0
-      /* Reset the prompt to the decoded value of prompt_string_pointer. */
-      reset_readline_prompt ();
-#endif
-
-      if (current_readline_line == 0)
-	return (EOF);
-
-      current_readline_line_index = 0;
-      line_len = strlen (current_readline_line);
-
-      current_readline_line = (char *)xrealloc (current_readline_line, 2 + line_len);
-      current_readline_line[line_len++] = '\n';
-      current_readline_line[line_len] = '\0';
-    }
-
-  if (current_readline_line[current_readline_line_index] == 0)
-    {
-      free (current_readline_line);
-      current_readline_line = (char *)NULL;
-      return (yy_readline_get ());
-    }
-  else
-    {
-      c = current_readline_line[current_readline_line_index++];
-      return (c);
-    }
-}
-
-static int
-yy_readline_unget (c)
-     int c;
-{
-  if (current_readline_line_index && current_readline_line)
-    current_readline_line[--current_readline_line_index] = c;
-  return (c);
-}
-
-void
-with_input_from_stdin ()
-{
-  INPUT_STREAM location;
-
-  if (bash_input.type != st_stdin && stream_on_stack (st_stdin) == 0)
-    {
-      location.string = current_readline_line;
-      init_yy_io (yy_readline_get, yy_readline_unget,
-		  st_stdin, "readline stdin", location);
-    }
-}
-
-/* Will we be collecting another input line and printing a prompt? This uses
-   different conditions than SHOULD_PROMPT(), since readline allows a user to
-   embed a newline in the middle of the line it collects, which the parser
-   will interpret as a line break and command delimiter. */
-int
-parser_will_prompt ()
-{
-  return (current_readline_line == 0 || current_readline_line[current_readline_line_index] == 0);
-}
-  
-#else  /* !READLINE */
-
-void
-with_input_from_stdin ()
-{
-  with_input_from_stream (stdin, "stdin");
-}
-#endif	/* !READLINE */
-
-/* **************************************************************** */
-/*								    */
-/*   Let input come from STRING.  STRING is zero terminated.	    */
-/*								    */
-/* **************************************************************** */
-
-static int
-yy_string_get ()
-{
-  register char *string;
-  register unsigned char c;
-
-  string = bash_input.location.string;
-
-  /* If the string doesn't exist, or is empty, EOF found. */
-  if (string && *string)
-    {
-      c = *string++;
-      bash_input.location.string = string;
-      return (c);
-    }
-  else
-    return (EOF);
-}
-
-static int
-yy_string_unget (c)
-     int c;
-{
-  *(--bash_input.location.string) = c;
-  return (c);
-}
-
-void
-with_input_from_string (string, name)
-     char *string;
-     const char *name;
-{
-  INPUT_STREAM location;
-
-  location.string = string;
-  init_yy_io (yy_string_get, yy_string_unget, st_string, name, location);
-}
-
-/* Count the number of characters we've consumed from bash_input.location.string
-   and read into shell_input_line, but have not returned from shell_getc.
-   That is the true input location.  Rewind bash_input.location.string by
-   that number of characters, so it points to the last character actually
-   consumed by the parser. */
-void
-rewind_input_string ()
-{
-  int xchars;
-
-  /* number of unconsumed characters in the input -- XXX need to take newlines
-     into account, e.g., $(...\n) */
-  xchars = shell_input_line_len - shell_input_line_index;
-  if (bash_input.location.string[-1] == '\n')
-    xchars++;
-
-  /* XXX - how to reflect bash_input.location.string back to string passed to
-     parse_and_execute or xparse_dolparen? xparse_dolparen needs to know how
-     far into the string we parsed.  parse_and_execute knows where bash_input.
-     location.string is, and how far from orig_string that is -- that's the
-     number of characters the command consumed. */
-
-  /* bash_input.location.string - xchars should be where we parsed to */
-  /* need to do more validation on xchars value for sanity -- test cases. */
-  bash_input.location.string -= xchars;
-}
-
-/* **************************************************************** */
-/*								    */
-/*		     Let input come from STREAM.		    */
-/*								    */
-/* **************************************************************** */
-
-/* These two functions used to test the value of the HAVE_RESTARTABLE_SYSCALLS
-   define, and just use getc/ungetc if it was defined, but since bash
-   installs most of its signal handlers without the SA_RESTART flag, some
-   signals received during a read(2) will not cause the read to be restarted.
-   We will need to restart it ourselves. */
-
-static int
-yy_stream_get ()
-{
-  int result;
-
-  result = EOF;
-  if (bash_input.location.file)
-    {
-      /* XXX - don't need terminate_immediately; getc_with_restart checks
-	 for terminating signals itself if read returns < 0 */
-      result = getc_with_restart (bash_input.location.file);
-    }
-  return (result);
-}
-
-static int
-yy_stream_unget (c)
-     int c;
-{
-  return (ungetc_with_restart (c, bash_input.location.file));
-}
-
-void
-with_input_from_stream (stream, name)
-     FILE *stream;
-     const char *name;
-{
-  INPUT_STREAM location;
-
-  location.file = stream;
-  init_yy_io (yy_stream_get, yy_stream_unget, st_stream, name, location);
-}
-
-typedef struct stream_saver {
-  struct stream_saver *next;
-  BASH_INPUT bash_input;
-  int line;
-#if defined (BUFFERED_INPUT)
-  BUFFERED_STREAM *bstream;
-#endif /* BUFFERED_INPUT */
-} STREAM_SAVER;
-
-/* The globally known line number. */
-int line_number = 0;
-
-/* The line number offset set by assigning to LINENO.  Not currently used. */
-int line_number_base = 0;
-
-#if defined (COND_COMMAND)
-static int cond_lineno;
-static int cond_token;
-#endif
-
-STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
-
-void
-push_stream (reset_lineno)
-     int reset_lineno;
-{
-  STREAM_SAVER *saver = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
-
-  xbcopy ((char *)&bash_input, (char *)&(saver->bash_input), sizeof (BASH_INPUT));
-
-#if defined (BUFFERED_INPUT)
-  saver->bstream = (BUFFERED_STREAM *)NULL;
-  /* If we have a buffered stream, clear out buffers[fd]. */
-  if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
-    saver->bstream = set_buffered_stream (bash_input.location.buffered_fd,
-    					  (BUFFERED_STREAM *)NULL);
-#endif /* BUFFERED_INPUT */
-
-  saver->line = line_number;
-  bash_input.name = (char *)NULL;
-  saver->next = stream_list;
-  stream_list = saver;
-  EOF_Reached = 0;
-  if (reset_lineno)
-    line_number = 0;
-}
-
-void
-pop_stream ()
-{
-  if (!stream_list)
-    EOF_Reached = 1;
-  else
-    {
-      STREAM_SAVER *saver = stream_list;
-
-      EOF_Reached = 0;
-      stream_list = stream_list->next;
-
-      init_yy_io (saver->bash_input.getter,
-		  saver->bash_input.ungetter,
-		  saver->bash_input.type,
-		  saver->bash_input.name,
-		  saver->bash_input.location);
-
-#if defined (BUFFERED_INPUT)
-      /* If we have a buffered stream, restore buffers[fd]. */
-      /* If the input file descriptor was changed while this was on the
-	 save stack, update the buffered fd to the new file descriptor and
-	 re-establish the buffer <-> bash_input fd correspondence. */
-      if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
-	{
-	  if (bash_input_fd_changed)
-	    {
-	      bash_input_fd_changed = 0;
-	      if (default_buffered_input >= 0)
-		{
-		  bash_input.location.buffered_fd = default_buffered_input;
-		  saver->bstream->b_fd = default_buffered_input;
-		  SET_CLOSE_ON_EXEC (default_buffered_input);
-		}
-	    }
-	  /* XXX could free buffered stream returned as result here. */
-	  set_buffered_stream (bash_input.location.buffered_fd, saver->bstream);
-	}
-#endif /* BUFFERED_INPUT */
-
-      line_number = saver->line;
-
-      FREE (saver->bash_input.name);
-      free (saver);
-    }
-}
-
-/* Return 1 if a stream of type TYPE is saved on the stack. */
-int
-stream_on_stack (type)
-     enum stream_type type;
-{
-  register STREAM_SAVER *s;
-
-  for (s = stream_list; s; s = s->next)
-    if (s->bash_input.type == type)
-      return 1;
-  return 0;
-}
-
-/* Save the current token state and return it in a malloced array. */
-int *
-save_token_state ()
-{
-  int *ret;
-
-  ret = (int *)xmalloc (4 * sizeof (int));
-  ret[0] = last_read_token;
-  ret[1] = token_before_that;
-  ret[2] = two_tokens_ago;
-  ret[3] = current_token;
-  return ret;
-}
-
-void
-restore_token_state (ts)
-     int *ts;
-{
-  if (ts == 0)
-    return;
-  last_read_token = ts[0];
-  token_before_that = ts[1];
-  two_tokens_ago = ts[2];
-  current_token = ts[3];
-}
-
-/*
- * This is used to inhibit alias expansion and reserved word recognition
- * inside case statement pattern lists.  A `case statement pattern list' is:
- *
- *	everything between the `in' in a `case word in' and the next ')'
- *	or `esac'
- *	everything between a `;;' and the next `)' or `esac'
- */
-
-#define END_OF_ALIAS 0
-
-/*
- * Pseudo-global variables used in implementing token-wise alias expansion.
- */
-
-/*
- * Pushing and popping strings.  This works together with shell_getc to
- * implement alias expansion on a per-token basis.
- */
-
-#define PSH_ALIAS	0x01
-#define PSH_DPAREN	0x02
-#define PSH_SOURCE	0x04
-#define PSH_ARRAY	0x08
-
-typedef struct string_saver {
-  struct string_saver *next;
-  int expand_alias;  /* Value to set expand_alias to when string is popped. */
-  char *saved_line;
-#if defined (ALIAS)
-  alias_t *expander;   /* alias that caused this line to be pushed. */
-#endif
-  size_t saved_line_size, saved_line_index, saved_line_len;
-  int saved_line_terminator;
-  int flags;
-} STRING_SAVER;
-
-STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
-
-/*
- * Push the current shell_input_line onto a stack of such lines and make S
- * the current input.  Used when expanding aliases.  EXPAND is used to set
- * the value of expand_next_token when the string is popped, so that the
- * word after the alias in the original line is handled correctly when the
- * alias expands to multiple words.  TOKEN is the token that was expanded
- * into S; it is saved and used to prevent infinite recursive expansion.
- */
-static void
-push_string (s, expand, ap)
-     char *s;
-     int expand;
-     alias_t *ap;
-{
-  STRING_SAVER *temp = (STRING_SAVER *)xmalloc (sizeof (STRING_SAVER));
-
-  temp->expand_alias = expand;
-  temp->saved_line = shell_input_line;
-  temp->saved_line_size = shell_input_line_size;
-  temp->saved_line_len = shell_input_line_len;
-  temp->saved_line_index = shell_input_line_index;
-  temp->saved_line_terminator = shell_input_line_terminator;
-  temp->flags = 0;
-#if defined (ALIAS)
-  temp->expander = ap;
-  if (ap)
-    temp->flags = PSH_ALIAS;
-#endif
-  temp->next = pushed_string_list;
-  pushed_string_list = temp;
-
-#if defined (ALIAS)
-  if (ap)
-    ap->flags |= AL_BEINGEXPANDED;
-#endif
-
-  shell_input_line = s;
-  shell_input_line_size = shell_input_line_len = STRLEN (s);
-  shell_input_line_index = 0;
-  shell_input_line_terminator = '\0';
-#if 0
-  parser_state &= ~PST_ALEXPNEXT;	/* XXX */
-#endif
-
-  set_line_mbstate ();
-}
-
-/*
- * Make the top of the pushed_string stack be the current shell input.
- * Only called when there is something on the stack.  Called from shell_getc
- * when it thinks it has consumed the string generated by an alias expansion
- * and needs to return to the original input line.
- */
-static void
-pop_string ()
-{
-  STRING_SAVER *t;
-
-  FREE (shell_input_line);
-  shell_input_line = pushed_string_list->saved_line;
-  shell_input_line_index = pushed_string_list->saved_line_index;
-  shell_input_line_size = pushed_string_list->saved_line_size;
-  shell_input_line_len = pushed_string_list->saved_line_len;
-  shell_input_line_terminator = pushed_string_list->saved_line_terminator;
-
-#if defined (ALIAS)
-  if (pushed_string_list->expand_alias)
-    parser_state |= PST_ALEXPNEXT;
-  else
-    parser_state &= ~PST_ALEXPNEXT;
-#endif
-
-  t = pushed_string_list;
-  pushed_string_list = pushed_string_list->next;
-
-#if defined (ALIAS)
-  if (t->expander)
-    t->expander->flags &= ~AL_BEINGEXPANDED;
-#endif
-
-  free ((char *)t);
-
-  set_line_mbstate ();
-}
-
-static void
-free_string_list ()
-{
-  register STRING_SAVER *t, *t1;
-
-  for (t = pushed_string_list; t; )
-    {
-      t1 = t->next;
-      FREE (t->saved_line);
-#if defined (ALIAS)
-      if (t->expander)
-	t->expander->flags &= ~AL_BEINGEXPANDED;
-#endif
-      free ((char *)t);
-      t = t1;
-    }
-  pushed_string_list = (STRING_SAVER *)NULL;
-}
-
-void
-free_pushed_string_input ()
-{
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  free_string_list ();
-#endif
-}
-
-int
-parser_expanding_alias ()
-{
-  return (expanding_alias ());
-}
-
-void
-parser_save_alias ()
-{
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  push_string ((char *)NULL, 0, (alias_t *)NULL);
-  pushed_string_list->flags = PSH_SOURCE;	/* XXX - for now */
-#else
-  ;
-#endif
-}
-
-void
-parser_restore_alias ()
-{
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  if (pushed_string_list)
-    pop_string ();
-#else
-  ;
-#endif
-}
-
-#if defined (ALIAS)
-/* Before freeing AP, make sure that there aren't any cases of pointer
-   aliasing that could cause us to reference freed memory later on. */
-void
-clear_string_list_expander (ap)
-     alias_t *ap;
-{
-  register STRING_SAVER *t;
-
-  for (t = pushed_string_list; t; t = t->next)
-    {
-      if (t->expander && t->expander == ap)
-	t->expander = 0;
-    }
-}
-#endif
-
-void
-clear_shell_input_line ()
-{
-  if (shell_input_line)
-    shell_input_line[shell_input_line_index = 0] = '\0';
-}
-
-/* Return a line of text, taken from wherever yylex () reads input.
-   If there is no more input, then we return NULL.  If REMOVE_QUOTED_NEWLINE
-   is non-zero, we remove unquoted \<newline> pairs.  This is used by
-   read_secondary_line to read here documents. */
-static char *
-read_a_line (remove_quoted_newline)
-     int remove_quoted_newline;
-{
-  static char *line_buffer = (char *)NULL;
-  static int buffer_size = 0;
-  int indx, c, peekc, pass_next;
-
-#if defined (READLINE)
-  if (no_line_editing && SHOULD_PROMPT ())
-#else
-  if (SHOULD_PROMPT ())
-#endif
-    print_prompt ();
-
-  pass_next = indx = 0;
-  while (1)
-    {
-      /* Allow immediate exit if interrupted during input. */
-      QUIT;
-
-      c = yy_getc ();
-
-      /* Ignore null bytes in input. */
-      if (c == 0)
-	continue;
-
-      /* If there is no more input, then we return NULL. */
-      if (c == EOF)
-	{
-	  if (interactive && bash_input.type == st_stream)
-	    clearerr (stdin);
-	  if (indx == 0)
-	    return ((char *)NULL);
-	  c = '\n';
-	}
-
-      /* `+2' in case the final character in the buffer is a newline or we
-	 have to handle CTLESC or CTLNUL. */
-      RESIZE_MALLOCED_BUFFER (line_buffer, indx, 2, buffer_size, 128);
-
-      /* IF REMOVE_QUOTED_NEWLINES is non-zero, we are reading a
-	 here document with an unquoted delimiter.  In this case,
-	 the line will be expanded as if it were in double quotes.
-	 We allow a backslash to escape the next character, but we
-	 need to treat the backslash specially only if a backslash
-	 quoting a backslash-newline pair appears in the line. */
-      if (pass_next)
-	{
-	  line_buffer[indx++] = c;
-	  pass_next = 0;
-	}
-      else if (c == '\\' && remove_quoted_newline)
-	{
-	  QUIT;
-	  peekc = yy_getc ();
-	  if (peekc == '\n')
-	    {
-	      line_number++;
-	      continue;	/* Make the unquoted \<newline> pair disappear. */
-	    }
-	  else
-	    {
-	      yy_ungetc (peekc);
-	      pass_next = 1;
-	      line_buffer[indx++] = c;		/* Preserve the backslash. */
-	    }
-	}
-      else
-	{
-	  /* remove_quoted_newline is non-zero if the here-document delimiter
-	     is unquoted. In this case, we will be expanding the lines and
-	     need to make sure CTLESC and CTLNUL in the input are quoted. */
-	  if (remove_quoted_newline && (c == CTLESC || c == CTLNUL))
-	    line_buffer[indx++] = CTLESC;
-	  line_buffer[indx++] = c;
-	}
-
-      if (c == '\n')
-	{
-	  line_buffer[indx] = '\0';
-	  return (line_buffer);
-	}
-    }
-}
-
-/* Return a line as in read_a_line (), but insure that the prompt is
-   the secondary prompt.  This is used to read the lines of a here
-   document.  REMOVE_QUOTED_NEWLINE is non-zero if we should remove
-   newlines quoted with backslashes while reading the line.  It is
-   non-zero unless the delimiter of the here document was quoted. */
-char *
-read_secondary_line (remove_quoted_newline)
-     int remove_quoted_newline;
-{
-  char *ret;
-  int n, c;
-
-  prompt_string_pointer = &ps2_prompt;
-  if (SHOULD_PROMPT ())
-    prompt_again (0);
-  ret = read_a_line (remove_quoted_newline);
-#if defined (HISTORY)
-  if (ret && remember_on_history && (parser_state & PST_HEREDOC))
-    {
-      /* To make adding the here-document body right, we need to rely on
-	 history_delimiting_chars() returning \n for the first line of the
-	 here-document body and the null string for the second and subsequent
-	 lines, so we avoid double newlines.
-	 current_command_line_count == 2 for the first line of the body. */
-
-      current_command_line_count++;
-      maybe_add_history (ret);
-    }
-#endif /* HISTORY */
-  return ret;
-}
-
-/* **************************************************************** */
-/*								    */
-/*				YYLEX ()			    */
-/*								    */
-/* **************************************************************** */
-
-/* Reserved words.  These are only recognized as the first word of a
-   command. */
-STRING_INT_ALIST word_token_alist[] = {
-  { "if", IF },
-  { "then", THEN },
-  { "else", ELSE },
-  { "elif", ELIF },
-  { "fi", FI },
-  { "case", CASE },
-  { "esac", ESAC },
-  { "for", FOR },
-#if defined (SELECT_COMMAND)
-  { "select", SELECT },
-#endif
-  { "while", WHILE },
-  { "until", UNTIL },
-  { "do", DO },
-  { "done", DONE },
-  { "in", IN },
-  { "function", FUNCTION },
-#if defined (COMMAND_TIMING)
-  { "time", TIME },
-#endif
-  { "{", '{' },
-  { "}", '}' },
-  { "!", BANG },
-#if defined (COND_COMMAND)
-  { "[[", COND_START },
-  { "]]", COND_END },
-#endif
-#if defined (COPROCESS_SUPPORT)
-  { "coproc", COPROC },
-#endif
-  { (char *)NULL, 0}
-};
-
-/* other tokens that can be returned by read_token() */
-STRING_INT_ALIST other_token_alist[] = {
-  /* Multiple-character tokens with special values */
-  { "--", TIMEIGN },
-  { "-p", TIMEOPT },
-  { "&&", AND_AND },
-  { "||", OR_OR },
-  { ">>", GREATER_GREATER },
-  { "<<", LESS_LESS },
-  { "<&", LESS_AND },
-  { ">&", GREATER_AND },
-  { ";;", SEMI_SEMI },
-  { ";&", SEMI_AND },
-  { ";;&", SEMI_SEMI_AND },
-  { "<<-", LESS_LESS_MINUS },
-  { "<<<", LESS_LESS_LESS },
-  { "&>", AND_GREATER },
-  { "&>>", AND_GREATER_GREATER },
-  { "<>", LESS_GREATER },
-  { ">|", GREATER_BAR },
-  { "|&", BAR_AND },
-  { "EOF", yacc_EOF },
-  /* Tokens whose value is the character itself */
-  { ">", '>' },
-  { "<", '<' },
-  { "-", '-' },
-  { "{", '{' },
-  { "}", '}' },
-  { ";", ';' },
-  { "(", '(' },
-  { ")", ')' },
-  { "|", '|' },
-  { "&", '&' },
-  { "newline", '\n' },
-  { (char *)NULL, 0}
-};
-
-/* others not listed here:
-	WORD			look at yylval.word
-	ASSIGNMENT_WORD		look at yylval.word
-	NUMBER			look at yylval.number
-	ARITH_CMD		look at yylval.word_list
-	ARITH_FOR_EXPRS		look at yylval.word_list
-	COND_CMD		look at yylval.command
-*/
-
-/* These are used by read_token_word, but appear up here so that shell_getc
-   can use them to decide when to add otherwise blank lines to the history. */
-
-/* The primary delimiter stack. */
-struct dstack dstack = {  (char *)NULL, 0, 0 };
-
-/* A temporary delimiter stack to be used when decoding prompt strings.
-   This is needed because command substitutions in prompt strings (e.g., PS2)
-   can screw up the parser's quoting state. */
-static struct dstack temp_dstack = { (char *)NULL, 0, 0 };
-
-/* Macro for accessing the top delimiter on the stack.  Returns the
-   delimiter or zero if none. */
-#define current_delimiter(ds) \
-  (ds.delimiter_depth ? ds.delimiters[ds.delimiter_depth - 1] : 0)
-
-#define push_delimiter(ds, character) \
-  do \
-    { \
-      if (ds.delimiter_depth + 2 > ds.delimiter_space) \
-	ds.delimiters = (char *)xrealloc \
-	  (ds.delimiters, (ds.delimiter_space += 10) * sizeof (char)); \
-      ds.delimiters[ds.delimiter_depth] = character; \
-      ds.delimiter_depth++; \
-    } \
-  while (0)
-
-#define pop_delimiter(ds)	ds.delimiter_depth--
-
-/* Return the next shell input character.  This always reads characters
-   from shell_input_line; when that line is exhausted, it is time to
-   read the next line.  This is called by read_token when the shell is
-   processing normal command input. */
-
-/* This implements one-character lookahead/lookbehind across physical input
-   lines, to avoid something being lost because it's pushed back with
-   shell_ungetc when we're at the start of a line. */
-static int eol_ungetc_lookahead = 0;
-
-static int unquoted_backslash = 0;
-
-static int
-shell_getc (remove_quoted_newline)
-     int remove_quoted_newline;
-{
-  register int i;
-  int c, truncating, last_was_backslash;
-  unsigned char uc;
-
-  QUIT;
-
-  last_was_backslash = 0;
-  if (sigwinch_received)
-    {
-      sigwinch_received = 0;
-      get_new_window_size (0, (int *)0, (int *)0);
-    }
-      
-  if (eol_ungetc_lookahead)
-    {
-      c = eol_ungetc_lookahead;
-      eol_ungetc_lookahead = 0;
-      return (c);
-    }
-
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  /* If shell_input_line[shell_input_line_index] == 0, but there is
-     something on the pushed list of strings, then we don't want to go
-     off and get another line.  We let the code down below handle it. */
-
-  if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
-			    (pushed_string_list == (STRING_SAVER *)NULL)))
-#else /* !ALIAS && !DPAREN_ARITHMETIC */
-  if (!shell_input_line || !shell_input_line[shell_input_line_index])
-#endif /* !ALIAS && !DPAREN_ARITHMETIC */
-    {
-      line_number++;
-
-      /* Let's not let one really really long line blow up memory allocation */
-      if (shell_input_line && shell_input_line_size >= 32768)
-	{
-	  free (shell_input_line);
-	  shell_input_line = 0;
-	  shell_input_line_size = 0;
-	}
-
-    restart_read:
-
-      /* Allow immediate exit if interrupted during input. */
-      QUIT;
-
-      i = truncating = 0;
-      shell_input_line_terminator = 0;
-
-      /* If the shell is interactive, but not currently printing a prompt
-         (interactive_shell && interactive == 0), we don't want to print
-         notifies or cleanup the jobs -- we want to defer it until we do
-         print the next prompt. */
-      if (interactive_shell == 0 || SHOULD_PROMPT())
-	{
-#if defined (JOB_CONTROL)
-      /* This can cause a problem when reading a command as the result
-	 of a trap, when the trap is called from flush_child.  This call
-	 had better not cause jobs to disappear from the job table in
-	 that case, or we will have big trouble. */
-	  notify_and_cleanup ();
-#else /* !JOB_CONTROL */
-	  cleanup_dead_jobs ();
-#endif /* !JOB_CONTROL */
-	}
-
-#if defined (READLINE)
-      if (no_line_editing && SHOULD_PROMPT())
-#else
-      if (SHOULD_PROMPT())
-#endif
-	print_prompt ();
-
-      if (bash_input.type == st_stream)
-	clearerr (stdin);
-
-      while (1)
-	{
-	  c = yy_getc ();
-
-	  /* Allow immediate exit if interrupted during input. */
-	  QUIT;
-
-	  if (c == '\0')
-	    {
-	      /* If we get EOS while parsing a string, treat it as EOF so we
-		 don't just keep looping. Happens very rarely */
-	      if (bash_input.type == st_string)
-		{
-		  if (i == 0)
-		    shell_input_line_terminator = EOF;
-		  shell_input_line[i] = '\0';
-		  c = EOF;
-		  break;
-		}
-	      continue;
-	    }
-
-	  /* Theoretical overflow */
-	  /* If we can't put 256 bytes more into the buffer, allocate
-	     everything we can and fill it as full as we can. */
-	  /* XXX - we ignore rest of line using `truncating' flag */
-	  if (shell_input_line_size > (SIZE_MAX - 256))
-	    {
-	      size_t n;
-
-	      n = SIZE_MAX - i;	/* how much more can we put into the buffer? */
-	      if (n <= 2)	/* we have to save 1 for the newline added below */
-		{
-		  if (truncating == 0)
-		    internal_warning(_("shell_getc: shell_input_line_size (%zu) exceeds SIZE_MAX (%lu): line truncated"), shell_input_line_size, (unsigned long)SIZE_MAX);
-		  shell_input_line[i] = '\0';
-		  truncating = 1;
-		}
-	      if (shell_input_line_size < SIZE_MAX)
-		{
-		  shell_input_line_size = SIZE_MAX;
-		  shell_input_line = xrealloc (shell_input_line, shell_input_line_size);
-		}
-	    }
-	  else
-	    RESIZE_MALLOCED_BUFFER (shell_input_line, i, 2, shell_input_line_size, 256);
-
-	  if (c == EOF)
-	    {
-	      if (bash_input.type == st_stream)
-		clearerr (stdin);
-
-	      if (i == 0)
-		shell_input_line_terminator = EOF;
-
-	      shell_input_line[i] = '\0';
-	      break;
-	    }
-
-	  if (truncating == 0 || c == '\n')
-	    shell_input_line[i++] = c;
-
-	  if (c == '\n')
-	    {
-	      shell_input_line[--i] = '\0';
-	      current_command_line_count++;
-	      break;
-	    }
-
-	  last_was_backslash = last_was_backslash == 0 && c == '\\';
-	}
-
-      shell_input_line_index = 0;
-      shell_input_line_len = i;		/* == strlen (shell_input_line) */
-
-      set_line_mbstate ();
-
-#if defined (HISTORY)
-      if (remember_on_history && shell_input_line && shell_input_line[0])
-	{
-	  char *expansions;
-#  if defined (BANG_HISTORY)
-	  /* If the current delimiter is a single quote, we should not be
-	     performing history expansion, even if we're on a different
-	     line from the original single quote. */
-	  if (current_delimiter (dstack) == '\'')
-	    history_quoting_state = '\'';
-	  else if (current_delimiter (dstack) == '"')
-	    history_quoting_state = '"';
-	  else
-	    history_quoting_state = 0;
-#  endif
-	  /* Calling with a third argument of 1 allows remember_on_history to
-	     determine whether or not the line is saved to the history list */
-	  expansions = pre_process_line (shell_input_line, 1, 1);
-#  if defined (BANG_HISTORY)
-	  history_quoting_state = 0;
-#  endif
-	  if (expansions != shell_input_line)
-	    {
-	      free (shell_input_line);
-	      shell_input_line = expansions;
-	      shell_input_line_len = shell_input_line ?
-					strlen (shell_input_line) : 0;
-	      if (shell_input_line_len == 0)
-		current_command_line_count--;
-
-	      /* We have to force the xrealloc below because we don't know
-		 the true allocated size of shell_input_line anymore. */
-	      shell_input_line_size = shell_input_line_len;
-
-	      set_line_mbstate ();
-	    }
-	}
-      /* Try to do something intelligent with blank lines encountered while
-	 entering multi-line commands.  XXX - this is grotesque */
-      else if (remember_on_history && shell_input_line &&
-	       shell_input_line[0] == '\0' &&
-	       current_command_line_count > 1)
-	{
-	  if (current_delimiter (dstack))
-	    /* We know shell_input_line[0] == 0 and we're reading some sort of
-	       quoted string.  This means we've got a line consisting of only
-	       a newline in a quoted string.  We want to make sure this line
-	       gets added to the history. */
-	    maybe_add_history (shell_input_line);
-	  else
-	    {
-	      char *hdcs;
-	      hdcs = history_delimiting_chars (shell_input_line);
-	      if (hdcs && hdcs[0] == ';')
-		maybe_add_history (shell_input_line);
-	    }
-	}
-
-#endif /* HISTORY */
-
-      if (shell_input_line)
-	{
-	  /* Lines that signify the end of the shell's input should not be
-	     echoed.  We should not echo lines while parsing command
-	     substitutions with recursive calls into the parsing engine; those
-	     should only be echoed once when we read the word.  That is the
-	     reason for the test against shell_eof_token, which is set to a
-	     right paren when parsing the contents of command substitutions. */
-	  if (echo_input_at_read && (shell_input_line[0] ||
-				       shell_input_line_terminator != EOF) &&
-				     shell_eof_token == 0)
-	    fprintf (stderr, "%s\n", shell_input_line);
-	}
-      else
-	{
-	  shell_input_line_size = 0;
-	  prompt_string_pointer = &current_prompt_string;
-	  if (SHOULD_PROMPT ())
-	    prompt_again (0);
-	  goto restart_read;
-	}
-
-      /* Add the newline to the end of this string, iff the string does
-	 not already end in an EOF character.  */
-      if (shell_input_line_terminator != EOF)
-	{
-	  if (shell_input_line_size < SIZE_MAX-3 && (shell_input_line_len+3 > shell_input_line_size))
-	    shell_input_line = (char *)xrealloc (shell_input_line,
-					1 + (shell_input_line_size += 2));
-
-	  /* Don't add a newline to a string that ends with a backslash if we're
-	     going to be removing quoted newlines, since that will eat the
-	     backslash.  Add another backslash instead (will be removed by
-	     word expansion). */
-	  if (bash_input.type == st_string && expanding_alias() == 0 && last_was_backslash && c == EOF && remove_quoted_newline)
-	    shell_input_line[shell_input_line_len] = '\\';
-	  else
-	    shell_input_line[shell_input_line_len] = '\n';
-	  shell_input_line[shell_input_line_len + 1] = '\0';
-
-#if defined (HANDLE_MULTIBYTE)
-	  /* This is kind of an abstraction violation, but there's no need to
-	     go through the entire shell_input_line again with a call to
-	     set_line_mbstate(). */
-	  EXTEND_SHELL_INPUT_LINE_PROPERTY();
-	  shell_input_line_property[shell_input_line_len] = 1;
-#endif
-	}
-    }
-
-next_alias_char:
-  if (shell_input_line_index == 0)
-    unquoted_backslash = 0;
-
-  uc = shell_input_line[shell_input_line_index];
-
-  if (uc)
-    {
-      unquoted_backslash = unquoted_backslash == 0 && uc == '\\';
-      shell_input_line_index++;
-    }
-
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  /* If UC is NULL, we have reached the end of the current input string.  If
-     pushed_string_list is non-empty, it's time to pop to the previous string
-     because we have fully consumed the result of the last alias expansion.
-     Do it transparently; just return the next character of the string popped
-     to. */
-  /* If pushed_string_list != 0 but pushed_string_list->expander == 0 (not
-     currently tested) and the flags value is not PSH_SOURCE, we are not
-     parsing an alias, we have just saved one (push_string, when called by
-     the parse_dparen code) In this case, just go on as well.  The PSH_SOURCE
-     case is handled below. */
-
-  /* If we're at the end of an alias expansion add a space to make sure that
-     the alias remains marked as being in use while we expand its last word.
-     This makes sure that pop_string doesn't mark the alias as not in use
-     before the string resulting from the alias expansion is tokenized and
-     checked for alias expansion, preventing recursion.  At this point, the
-     last character in shell_input_line is the last character of the alias
-     expansion.  We test that last character to determine whether or not to
-     return the space that will delimit the token and postpone the pop_string.
-     This set of conditions duplicates what used to be in mk_alexpansion ()
-     below, with the addition that we don't add a space if we're currently
-     reading a quoted string or in a shell comment. */
-#ifndef OLD_ALIAS_HACK
-  if (uc == 0 && pushed_string_list && pushed_string_list->flags != PSH_SOURCE &&
-      pushed_string_list->flags != PSH_DPAREN &&
-      (parser_state & PST_COMMENT) == 0 &&
-      (parser_state & PST_ENDALIAS) == 0 &&	/* only once */
-      shell_input_line_index > 0 &&
-      shellblank (shell_input_line[shell_input_line_index-1]) == 0 &&
-      shell_input_line[shell_input_line_index-1] != '\n' &&
-      unquoted_backslash == 0 &&
-      shellmeta (shell_input_line[shell_input_line_index-1]) == 0 &&
-      (current_delimiter (dstack) != '\'' && current_delimiter (dstack) != '"'))
-    {
-      parser_state |= PST_ENDALIAS;
-      /* We need to do this to make sure last_shell_getc_is_singlebyte returns
-	 true, since we are returning a single-byte space. */
-      if (shell_input_line_index == shell_input_line_len && last_shell_getc_is_singlebyte == 0)
-	{
-#if 0
-	  EXTEND_SHELL_INPUT_LINE_PROPERTY();
-	  shell_input_line_property[shell_input_line_len++] = 1;
-	  /* extend shell_input_line to accommodate the shell_ungetc that
-	     read_token_word() will perform, since we're extending the index */
-	  RESIZE_MALLOCED_BUFFER (shell_input_line, shell_input_line_index, 2, shell_input_line_size, 16);
-          shell_input_line[++shell_input_line_index] = '\0';	/* XXX */
-#else
-	  shell_input_line_property[shell_input_line_index - 1] = 1;
-#endif
-	}
-      return ' ';	/* END_ALIAS */
-    }
-#endif
-
-pop_alias:
-#endif /* ALIAS || DPAREN_ARITHMETIC */
-  /* This case works for PSH_DPAREN as well as the shell_ungets() case that uses
-     push_string */
-  if (uc == 0 && pushed_string_list && pushed_string_list->flags != PSH_SOURCE)
-    {
-      parser_state &= ~PST_ENDALIAS;
-      pop_string ();
-      uc = shell_input_line[shell_input_line_index];
-      if (uc)
-	shell_input_line_index++;
-    }
-
-  if MBTEST(uc == '\\' && remove_quoted_newline && shell_input_line[shell_input_line_index] == '\n')
-    {
-	if (SHOULD_PROMPT ())
-	  prompt_again (0);
-	line_number++;
-
-	/* What do we do here if we're expanding an alias whose definition
-	   includes an escaped newline?  If that's the last character in the
-	   alias expansion, we just pop the pushed string list (recall that
-	   we inhibit the appending of a space if newline is the last
-	   character).  If it's not the last character, we need to consume the
-	   quoted newline and move to the next character in the expansion. */
-#if defined (ALIAS)
-	if (expanding_alias () && shell_input_line[shell_input_line_index+1] == '\0')
-	  {
-	    uc = 0;
-	    goto pop_alias;
-	  }
-	else if (expanding_alias () && shell_input_line[shell_input_line_index+1] != '\0')
-	  {
-	    shell_input_line_index++;	/* skip newline */
-	    goto next_alias_char;	/* and get next character */
-	  }
-	else
-#endif 
-	  goto restart_read;
-    }
-
-  if (uc == 0 && shell_input_line_terminator == EOF)
-    return ((shell_input_line_index != 0) ? '\n' : EOF);
-
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  /* We already know that we are not parsing an alias expansion because of the
-     check for expanding_alias() above.  This knows how parse_and_execute
-     handles switching to st_string input while an alias is being expanded,
-     hence the check for pushed_string_list without pushed_string_list->expander
-     and the check for PSH_SOURCE as pushed_string_list->flags.
-     parse_and_execute and parse_string both change the input type to st_string
-     and place the string to be parsed and executed into location.string, so
-     we should not stop reading that until the pointer is '\0'.
-     The check for shell_input_line_terminator may be superfluous.
-
-     This solves the problem of `.' inside a multi-line alias with embedded
-     newlines executing things out of order. */
-  if (uc == 0 && bash_input.type == st_string && *bash_input.location.string &&
-      pushed_string_list && pushed_string_list->flags == PSH_SOURCE &&
-      shell_input_line_terminator == 0)
-    {
-      shell_input_line_index = 0;
-      goto restart_read;
-    }
-#endif
-
-  return (uc);
-}
-
-/* Put C back into the input for the shell.  This might need changes for
-   HANDLE_MULTIBYTE around EOLs.  Since we (currently) never push back a
-   character different than we read, shell_input_line_property doesn't need
-   to change when manipulating shell_input_line.  The define for
-   last_shell_getc_is_singlebyte should take care of it, though. */
-static void
-shell_ungetc (c)
-     int c;
-{
-  if (shell_input_line && shell_input_line_index)
-    shell_input_line[--shell_input_line_index] = c;
-  else
-    eol_ungetc_lookahead = c;
-}
-
-/* Push S back into shell_input_line; updating shell_input_line_index */
-void
-shell_ungets (s)
-     char *s;
-{
-  size_t slen, chars_left;
-
-  slen = strlen (s);
-
-  if (shell_input_line[shell_input_line_index] == '\0')
-    {
-      /* Easy, just overwrite shell_input_line. This is preferred because it
-	 saves on set_line_mbstate () and other overhead like push_string */
-      if (shell_input_line_size <= slen)
-	RESIZE_MALLOCED_BUFFER (shell_input_line, shell_input_line_index, slen + 1, shell_input_line_size, 64);
-      strcpy (shell_input_line, s);
-      shell_input_line_index = 0;
-      shell_input_line_len = slen;
-      shell_input_line_terminator = 0;
-    }
-  else if (shell_input_line_index >= slen)
-    {
-      /* Just as easy, just back up shell_input_line_index, but it means we
-	 will re-process some characters in set_line_mbstate(). Need to
-	 watch pushing back newlines here. */
-      while (slen > 0)
-        shell_input_line[--shell_input_line_index] = s[--slen];
-    }
-  else if (s[slen - 1] == '\n')
-    {
-      push_string (savestring (s), 0, (alias_t *)NULL);
-      /* push_string does set_line_mbstate () */
-      return;
-    }
-  else
-    {
-      /* Harder case: pushing back input string that's longer than what we've
-	 consumed from shell_input_line so far. */
-      INTERNAL_DEBUG (("shell_ungets: not at end of shell_input_line"));
-
-      chars_left = shell_input_line_len - shell_input_line_index;
-      if (shell_input_line_size <= (slen + chars_left))
-	RESIZE_MALLOCED_BUFFER (shell_input_line, shell_input_line_index, chars_left + slen + 1, shell_input_line_size, 64);
-      memmove (shell_input_line + slen, shell_input_line + shell_input_line_index, shell_input_line_len - shell_input_line_index);
-      strcpy (shell_input_line, s);
-      shell_input_line_index = 0;
-      shell_input_line_len = strlen (shell_input_line);	/* chars_left + slen? */
-    }
-
-#if defined (HANDLE_MULTIBYTE)
-  set_line_mbstate ();	/* XXX */
-#endif
-}
-
-char *
-parser_remaining_input ()
-{
-  if (shell_input_line == 0)
-    return 0;
-  if ((int)shell_input_line_index < 0 || shell_input_line_index >= shell_input_line_len)
-    return "";	/* XXX */
-  return (shell_input_line + shell_input_line_index);
-}
-
-#ifdef INCLUDE_UNUSED
-/* Back the input pointer up by one, effectively `ungetting' a character. */
-static void
-shell_ungetchar ()
-{
-  if (shell_input_line && shell_input_line_index)
-    shell_input_line_index--;
-}
-#endif
-
-/* Discard input until CHARACTER is seen, then push that character back
-   onto the input stream. */
-static void
-discard_until (character)
-     int character;
-{
-  int c;
-
-  while ((c = shell_getc (0)) != EOF && c != character)
-    ;
-
-  if (c != EOF)
-    shell_ungetc (c);
-}
-
-void
-execute_variable_command (command, vname)
-     char *command, *vname;
-{
-  char *last_lastarg;
-  sh_parser_state_t ps;
-
-  save_parser_state (&ps);
-  last_lastarg = get_string_value ("_");
-  if (last_lastarg)
-    last_lastarg = savestring (last_lastarg);
-
-  parse_and_execute (savestring (command), vname, SEVAL_NONINT|SEVAL_NOHIST);
-
-  restore_parser_state (&ps);
-  bind_variable ("_", last_lastarg, 0);
-  FREE (last_lastarg);
-
-  if (token_to_read == '\n')	/* reset_parser was called */
-    token_to_read = 0;
-}
-
-void
-push_token (x)
-     int x;
-{
-  two_tokens_ago = token_before_that;
-  token_before_that = last_read_token;
-  last_read_token = current_token;
-
-  current_token = x;
-}
-
-/* Place to remember the token.  We try to keep the buffer
-   at a reasonable size, but it can grow. */
-static char *token = (char *)NULL;
-
-/* Current size of the token buffer. */
-static size_t token_buffer_size;
-
-/* Command to read_token () explaining what we want it to do. */
-#define READ 0
-#define RESET 1
-#define prompt_is_ps1 \
-      (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
-
-/* Function for yyparse to call.  yylex keeps track of
-   the last two tokens read, and calls read_token.  */
-static int
-yylex ()
-{
-  if (interactive && (current_token == 0 || current_token == '\n'))
-    {
-      /* Before we print a prompt, we might have to check mailboxes.
-	 We do this only if it is time to do so. Notice that only here
-	 is the mail alarm reset; nothing takes place in check_mail ()
-	 except the checking of mail.  Please don't change this. */
-      if (prompt_is_ps1 && parse_and_execute_level == 0 && time_to_check_mail ())
-	{
-	  check_mail ();
-	  reset_mail_timer ();
-	}
-
-      /* Avoid printing a prompt if we're not going to read anything, e.g.
-	 after resetting the parser with read_token (RESET). */
-      if (token_to_read == 0 && SHOULD_PROMPT ())
-	prompt_again (0);
-    }
-
-  two_tokens_ago = token_before_that;
-  token_before_that = last_read_token;
-  last_read_token = current_token;
-  current_token = read_token (READ);
-
-  if ((parser_state & PST_EOFTOKEN) && current_token == shell_eof_token)
-    {
-      /* placeholder for any special handling. */
-      return (current_token);
-    }
-
-  if (current_token < 0)
-#if defined (YYERRCODE) && !defined (YYUNDEF)
-    current_token = YYERRCODE;
-#else
-    current_token = YYerror;
-#endif
-
-  return (current_token);
-}
-
-/* When non-zero, we have read the required tokens
-   which allow ESAC to be the next one read. */
-static int esacs_needed_count;
-
-/* When non-zero, we can read IN as an acceptable token, regardless of how
-   many newlines we read. */
-static int expecting_in_token;
-
-static void
-push_heredoc (r)
-     REDIRECT *r;
-{
-  if (need_here_doc >= HEREDOC_MAX)
-    {
-      last_command_exit_value = EX_BADUSAGE;
-      need_here_doc = 0;
-      report_syntax_error (_("maximum here-document count exceeded"));
-      reset_parser ();
-      exit_shell (last_command_exit_value);
-    }
-  redir_stack[need_here_doc++] = r;
-}
-
-void
-gather_here_documents ()
-{
-  int r;
-
-  r = 0;
-  here_doc_first_line = 1;
-  while (need_here_doc > 0)
-    {
-      parser_state |= PST_HEREDOC;
-      make_here_document (redir_stack[r++], line_number);
-      parser_state &= ~PST_HEREDOC;
-      need_here_doc--;
-      redir_stack[r - 1] = 0;		/* XXX */
-    }
-  here_doc_first_line = 0;		/* just in case */
-}
-
-/* When non-zero, an open-brace used to create a group is awaiting a close
-   brace partner. */
-static int open_brace_count;
-
-/* In the following three macros, `token' is always last_read_token */
-
-/* Are we in the middle of parsing a redirection where we are about to read
-   a word?  This is used to make sure alias expansion doesn't happen in the
-   middle of a redirection, even though we're parsing a simple command. */
-#define parsing_redirection(token) \
-  (token == '<' || token == '>' || \
-   token == GREATER_GREATER || token == GREATER_BAR || \
-   token == LESS_GREATER || token == LESS_LESS_MINUS || \
-   token == LESS_LESS || token == LESS_LESS_LESS || \
-   token == LESS_AND || token == GREATER_AND || token == AND_GREATER)
-
-/* Is `token' one that will allow a WORD to be read in a command position?
-   We can read a simple command name on which we should attempt alias expansion
-   or we can read an assignment statement. */
-#define command_token_position(token) \
-  (((token) == ASSIGNMENT_WORD) || \
-   ((parser_state&PST_REDIRLIST) && parsing_redirection(token) == 0) || \
-   ((token) != SEMI_SEMI && (token) != SEMI_AND && (token) != SEMI_SEMI_AND && reserved_word_acceptable(token)))
-
-/* Are we in a position where we can read an assignment statement? */
-#define assignment_acceptable(token) \
-  (command_token_position(token) && ((parser_state & PST_CASEPAT) == 0))
-
-/* Check to see if TOKEN is a reserved word and return the token
-   value if it is. */
-#define CHECK_FOR_RESERVED_WORD(tok) \
-  do { \
-    if (!dollar_present && !quoted && \
-	reserved_word_acceptable (last_read_token)) \
-      { \
-	int i; \
-	for (i = 0; word_token_alist[i].word != (char *)NULL; i++) \
-	  if (STREQ (tok, word_token_alist[i].word)) \
-	    { \
-	      if ((parser_state & PST_CASEPAT) && (word_token_alist[i].token != ESAC)) \
-		break; \
-	      if (word_token_alist[i].token == TIME && time_command_acceptable () == 0) \
-		break; \
-	      if ((parser_state & PST_CASEPAT) && last_read_token == '|' && word_token_alist[i].token == ESAC) \
-		break; /* Posix grammar rule 4 */ \
-	      if ((parser_state & PST_CASEPAT) && last_read_token == '(' && word_token_alist[i].token == ESAC) /*)*/ \
-		break; /* phantom Posix grammar rule 4 */ \
-	      if (word_token_alist[i].token == ESAC) { \
-		parser_state &= ~(PST_CASEPAT|PST_CASESTMT); \
-		esacs_needed_count--; \
-	      } else if (word_token_alist[i].token == CASE) \
-		parser_state |= PST_CASESTMT; \
-	      else if (word_token_alist[i].token == COND_END) \
-		parser_state &= ~(PST_CONDCMD|PST_CONDEXPR); \
-	      else if (word_token_alist[i].token == COND_START) \
-		parser_state |= PST_CONDCMD; \
-	      else if (word_token_alist[i].token == '{') \
-		open_brace_count++; \
-	      else if (word_token_alist[i].token == '}' && open_brace_count) \
-		open_brace_count--; \
-	      return (word_token_alist[i].token); \
-	    } \
-      } \
-  } while (0)
-
-#if defined (ALIAS)
-
-    /* OK, we have a token.  Let's try to alias expand it, if (and only if)
-       it's eligible.
-
-       It is eligible for expansion if EXPAND_ALIASES is set, and
-       the token is unquoted and the last token read was a command
-       separator (or expand_next_token is set), and we are currently
-       processing an alias (pushed_string_list is non-empty) and this
-       token is not the same as the current or any previously
-       processed alias.
-
-       Special cases that disqualify:
-	 In a pattern list in a case statement (parser_state & PST_CASEPAT). */
-
-static char *
-mk_alexpansion (s)
-     char *s;
-{
-  int l;
-  char *r;
-
-  l = strlen (s);
-  r = xmalloc (l + 2);
-  strcpy (r, s);
-#ifdef OLD_ALIAS_HACK
-  /* If the last character in the alias is a newline, don't add a trailing
-     space to the expansion.  Works with shell_getc above. */
-  /* Need to do something about the case where the alias expansion contains
-     an unmatched quoted string, since appending this space affects the
-     subsequent output. */
-  if (l > 0 && r[l - 1] != ' ' && r[l - 1] != '\n' && shellmeta(r[l - 1]) == 0)
-    r[l++] = ' ';
-#endif
-  r[l] = '\0';
-  return r;
-}
-
-static int
-alias_expand_token (tokstr)
-     char *tokstr;
-{
-  char *expanded;
-  alias_t *ap;
-
-#if 0
-  if (((parser_state & PST_ALEXPNEXT) || command_token_position (last_read_token)) &&
-	(parser_state & PST_CASEPAT) == 0)
-#else
-  if ((parser_state & PST_ALEXPNEXT) || assignment_acceptable (last_read_token))
-#endif
-    {
-      ap = find_alias (tokstr);
-
-      /* Currently expanding this token. */
-      if (ap && (ap->flags & AL_BEINGEXPANDED))
-	return (NO_EXPANSION);
-
-#ifdef OLD_ALIAS_HACK
-      /* mk_alexpansion puts an extra space on the end of the alias expansion,
-	 so the lookahead by the parser works right (the alias needs to remain
-	 `in use' while parsing its last word to avoid alias recursion for
-	 something like "alias echo=echo").  If this gets changed, make sure
-	 the code in shell_getc that deals with reaching the end of an
-	 expanded alias is changed with it. */
-#endif
-      expanded = ap ? mk_alexpansion (ap->value) : (char *)NULL;
-
-      if (expanded)
-	{
-	  push_string (expanded, ap->flags & AL_EXPANDNEXT, ap);
-	  return (RE_READ_TOKEN);
-	}
-      else
-	/* This is an eligible token that does not have an expansion. */
-	return (NO_EXPANSION);
-    }
-  return (NO_EXPANSION);
-}
-#endif /* ALIAS */
-
-static int
-time_command_acceptable ()
-{
-#if defined (COMMAND_TIMING)
-  int i;
-
-  if (posixly_correct && shell_compatibility_level > 41)
-    {
-      /* Quick check of the rest of the line to find the next token.  If it
-	 begins with a `-', Posix says to not return `time' as the token.
-	 This was interp 267. */
-      i = shell_input_line_index;
-      while (i < shell_input_line_len && (shell_input_line[i] == ' ' || shell_input_line[i] == '\t'))
-        i++;
-      if (shell_input_line[i] == '-')
-	return 0;
-    }
-
-  switch (last_read_token)
-    {
-    case 0:
-    case ';':
-    case '\n':
-      if (token_before_that == '|')
-	return (0);
-      /* FALLTHROUGH */
-    case AND_AND:
-    case OR_OR:
-    case '&':
-    case WHILE:
-    case DO:
-    case UNTIL:
-    case IF:
-    case THEN:
-    case ELIF:
-    case ELSE:
-    case '{':		/* } */
-    case '(':		/* )( */
-    case ')':		/* only valid in case statement */
-    case BANG:		/* ! time pipeline */
-    case TIME:		/* time time pipeline */
-    case TIMEOPT:	/* time -p time pipeline */
-    case TIMEIGN:	/* time -p -- ... */
-      return 1;
-    default:
-      return 0;
-    }
-#else
-  return 0;
-#endif /* COMMAND_TIMING */
-}
-
-/* Handle special cases of token recognition:
-	IN is recognized if the last token was WORD and the token
-	before that was FOR or CASE or SELECT.
-
-	DO is recognized if the last token was WORD and the token
-	before that was FOR or SELECT.
-
-	ESAC is recognized if the last token caused `esacs_needed_count'
-	to be set
-
-	`{' is recognized if the last token as WORD and the token
-	before that was FUNCTION, or if we just parsed an arithmetic
-	`for' command.
-
-	`}' is recognized if there is an unclosed `{' present.
-
-	`-p' is returned as TIMEOPT if the last read token was TIME.
-	`--' is returned as TIMEIGN if the last read token was TIME or TIMEOPT.
-
-	']]' is returned as COND_END if the parser is currently parsing
-	a conditional expression ((parser_state & PST_CONDEXPR) != 0)
-
-	`time' is returned as TIME if and only if it is immediately
-	preceded by one of `;', `\n', `||', `&&', or `&'.
-*/
-
-static int
-special_case_tokens (tokstr)
-     char *tokstr;
-{
-  /* Posix grammar rule 6 */
-  if ((last_read_token == WORD) &&
-#if defined (SELECT_COMMAND)
-      ((token_before_that == FOR) || (token_before_that == CASE) || (token_before_that == SELECT)) &&
-#else
-      ((token_before_that == FOR) || (token_before_that == CASE)) &&
-#endif
-      (tokstr[0] == 'i' && tokstr[1] == 'n' && tokstr[2] == 0))
-    {
-      if (token_before_that == CASE)
-	{
-	  parser_state |= PST_CASEPAT;
-	  esacs_needed_count++;
-	}
-      if (expecting_in_token)
-	expecting_in_token--;
-      return (IN);
-    }
-
-  /* XXX - leaving above code intact for now, but it should eventually be
-     removed in favor of this clause. */
-  /* Posix grammar rule 6 */
-  if (expecting_in_token && (last_read_token == WORD || last_read_token == '\n') &&
-      (tokstr[0] == 'i' && tokstr[1] == 'n' && tokstr[2] == 0))
-    {
-      if (parser_state & PST_CASESTMT)
-	{
-	  parser_state |= PST_CASEPAT;
-	  esacs_needed_count++;
-	}
-      expecting_in_token--;
-      return (IN);
-    }
-  /* Posix grammar rule 6, third word in FOR: for i; do command-list; done */
-  else if (expecting_in_token && (last_read_token == '\n' || last_read_token == ';') &&
-    (tokstr[0] == 'd' && tokstr[1] == 'o' && tokstr[2] == '\0'))
-    {
-      expecting_in_token--;
-      return (DO);
-    }
-
-  /* for i do; command-list; done */
-  if (last_read_token == WORD &&
-#if defined (SELECT_COMMAND)
-      (token_before_that == FOR || token_before_that == SELECT) &&
-#else
-      (token_before_that == FOR) &&
-#endif
-      (tokstr[0] == 'd' && tokstr[1] == 'o' && tokstr[2] == '\0'))
-    {
-      if (expecting_in_token)
-	expecting_in_token--;
-      return (DO);
-    }
-
-  /* Ditto for ESAC in the CASE case.
-     Specifically, this handles "case word in esac", which is a legal
-     construct, certainly because someone will pass an empty arg to the
-     case construct, and we don't want it to barf.  Of course, we should
-     insist that the case construct has at least one pattern in it, but
-     the designers disagree. */
-  if (esacs_needed_count)
-    {
-      if (last_read_token == IN && STREQ (tokstr, "esac"))
-	{
-	  esacs_needed_count--;
-	  parser_state &= ~PST_CASEPAT;
-	  return (ESAC);
-	}
-    }
-
-  /* The start of a shell function definition. */
-  if (parser_state & PST_ALLOWOPNBRC)
-    {
-      parser_state &= ~PST_ALLOWOPNBRC;
-      if (tokstr[0] == '{' && tokstr[1] == '\0')		/* } */
-	{
-	  open_brace_count++;
-	  function_bstart = line_number;
-	  return ('{');					/* } */
-	}
-    }
-
-  /* We allow a `do' after a for ((...)) without an intervening
-     list_terminator */
-  if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == 'd' && tokstr[1] == 'o' && !tokstr[2])
-    return (DO);
-  if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == '{' && tokstr[1] == '\0')	/* } */
-    {
-      open_brace_count++;
-      return ('{');			/* } */
-    }
-
-  if (open_brace_count && reserved_word_acceptable (last_read_token) && tokstr[0] == '}' && !tokstr[1])
-    {
-      open_brace_count--;		/* { */
-      return ('}');
-    }
-
-#if defined (COMMAND_TIMING)
-  /* Handle -p after `time'. */
-  if (last_read_token == TIME && tokstr[0] == '-' && tokstr[1] == 'p' && !tokstr[2])
-    return (TIMEOPT);
-  /* Handle -- after `time'. */
-  if (last_read_token == TIME && tokstr[0] == '-' && tokstr[1] == '-' && !tokstr[2])
-    return (TIMEIGN);
-  /* Handle -- after `time -p'. */
-  if (last_read_token == TIMEOPT && tokstr[0] == '-' && tokstr[1] == '-' && !tokstr[2])
-    return (TIMEIGN);
-#endif
-
-#if defined (COND_COMMAND) /* [[ */
-  if ((parser_state & PST_CONDEXPR) && tokstr[0] == ']' && tokstr[1] == ']' && tokstr[2] == '\0')
-    return (COND_END);
-#endif
-
-  return (-1);
-}
-
-/* Called from shell.c when Control-C is typed at top level.  Or
-   by the error rule at top level. */
-void
-reset_parser ()
-{
-  dstack.delimiter_depth = 0;	/* No delimiters found so far. */
-  open_brace_count = 0;
-
-#if defined (EXTENDED_GLOB)
-  /* Reset to global value of extended glob */
-  if (parser_state & (PST_EXTPAT|PST_CMDSUBST))
-    extended_glob = global_extglob;
-#endif
-
-  parser_state = 0;
-  here_doc_first_line = 0;
-
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  if (pushed_string_list)
-    free_string_list ();
-#endif /* ALIAS || DPAREN_ARITHMETIC */
-
-  /* This is where we resynchronize to the next newline on error/reset */
-  if (shell_input_line)
-    {
-      free (shell_input_line);
-      shell_input_line = (char *)NULL;
-      shell_input_line_size = shell_input_line_index = 0;
-    }
-
-  FREE (word_desc_to_read);
-  word_desc_to_read = (WORD_DESC *)NULL;
-
-  eol_ungetc_lookahead = 0;
-
-  /* added post-bash-5.1 */
-  need_here_doc = 0;
-  redir_stack[0] = 0;
-  esacs_needed_count = expecting_in_token = 0;
-
-  current_token = '\n';		/* XXX */
-  last_read_token = '\n';
-  token_to_read = '\n';
-}
-
-void
-reset_readahead_token ()
-{
-  if (token_to_read == '\n')
-    token_to_read = 0;
-}
-
-/* Read the next token.  Command can be READ (normal operation) or
-   RESET (to normalize state). */
-static int
-read_token (command)
-     int command;
-{
-  int character;		/* Current character. */
-  int peek_char;		/* Temporary look-ahead character. */
-  int result;			/* The thing to return. */
-
-  if (command == RESET)
-    {
-      reset_parser ();
-      return ('\n');
-    }
-
-  if (token_to_read)
-    {
-      result = token_to_read;
-      if (token_to_read == WORD || token_to_read == ASSIGNMENT_WORD)
-	{
-	  yylval.word = word_desc_to_read;
-	  word_desc_to_read = (WORD_DESC *)NULL;
-	}
-      token_to_read = 0;
-      return (result);
-    }
-
-#if defined (COND_COMMAND)
-  if ((parser_state & (PST_CONDCMD|PST_CONDEXPR)) == PST_CONDCMD)
-    {
-      cond_lineno = line_number;
-      parser_state |= PST_CONDEXPR;
-      yylval.command = parse_cond_command ();
-      if (cond_token != COND_END)
-	{
-	  cond_error ();
-	  return (-1);
-	}
-      token_to_read = COND_END;
-      parser_state &= ~(PST_CONDEXPR|PST_CONDCMD);
-      return (COND_CMD);
-    }
-#endif
-
-#if defined (ALIAS)
-  /* This is a place to jump back to once we have successfully expanded a
-     token with an alias and pushed the string with push_string () */
- re_read_token:
-#endif /* ALIAS */
-
-  /* Read a single word from input.  Start by skipping blanks. */
-  while ((character = shell_getc (1)) != EOF && shellblank (character))
-    ;
-
-  if (character == EOF)
-    {
-      EOF_Reached = 1;
-      return (yacc_EOF);
-    }
-
-  /* If we hit the end of the string and we're not expanding an alias (e.g.,
-     we are eval'ing a string that is an incomplete command), return EOF */
-  if (character == '\0' && bash_input.type == st_string && expanding_alias() == 0)
-    {
-      INTERNAL_DEBUG (("shell_getc: bash_input.location.string = `%s'", bash_input.location.string));
-      EOF_Reached = 1;
-      return (yacc_EOF);
-    }
-
-  if MBTEST(character == '#' && (!interactive || interactive_comments))
-    {
-      /* A comment.  Discard until EOL or EOF, and then return a newline. */
-      parser_state |= PST_COMMENT;
-      discard_until ('\n');
-      shell_getc (0);
-      parser_state &= ~PST_COMMENT;
-      character = '\n';	/* this will take the next if statement and return. */
-    }
-
-  if MBTEST(character == '\n')
-    {
-      /* If we're about to return an unquoted newline, we can go and collect
-	 the text of any pending here document. */
-      if (need_here_doc)
-	gather_here_documents ();
-
-#if defined (ALIAS)
-      parser_state &= ~PST_ALEXPNEXT;
-#endif /* ALIAS */
-
-      parser_state &= ~PST_ASSIGNOK;
-
-      return (character);
-    }
-
-  if (parser_state & PST_REGEXP)
-    goto tokword;
-
-  /* Shell meta-characters. */
-  if MBTEST(shellmeta (character))
-    {
-#if defined (ALIAS)
-      /* Turn off alias tokenization iff this character sequence would
-	 not leave us ready to read a command. */
-      if (character == '<' || character == '>')
-	parser_state &= ~PST_ALEXPNEXT;
-#endif /* ALIAS */
-
-      parser_state &= ~PST_ASSIGNOK;
-
-      /* If we are parsing a command substitution and we have read a character
-	 that marks the end of it, don't bother to skip over quoted newlines
-	 when we read the next token. We're just interested in a character
-	 that will turn this into a two-character token, so we let the higher
-	 layers deal with quoted newlines following the command substitution. */
-      if ((parser_state & PST_CMDSUBST) && character == shell_eof_token)
-	peek_char = shell_getc (0);
-      else
-	peek_char = shell_getc (1);
-
-      if MBTEST(character == peek_char)
-	{
-	  switch (character)
-	    {
-	    case '<':
-	      /* If '<' then we could be at "<<" or at "<<-".  We have to
-		 look ahead one more character. */
-	      peek_char = shell_getc (1);
-	      if MBTEST(peek_char == '-')
-		return (LESS_LESS_MINUS);
-	      else if MBTEST(peek_char == '<')
-		return (LESS_LESS_LESS);
-	      else
-		{
-		  shell_ungetc (peek_char);
-		  return (LESS_LESS);
-		}
-
-	    case '>':
-	      return (GREATER_GREATER);
-
-	    case ';':
-	      parser_state |= PST_CASEPAT;
-#if defined (ALIAS)
-	      parser_state &= ~PST_ALEXPNEXT;
-#endif /* ALIAS */
-
-	      peek_char = shell_getc (1);
-	      if MBTEST(peek_char == '&')
-		return (SEMI_SEMI_AND);
-	      else
-		{
-		  shell_ungetc (peek_char);
-		  return (SEMI_SEMI);
-		}
-
-	    case '&':
-	      return (AND_AND);
-
-	    case '|':
-	      return (OR_OR);
-
-#if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
-	    case '(':		/* ) */
-	      result = parse_dparen (character);
-	      if (result == -2)
-	        break;
-	      else
-	        return result;
-#endif
-	    }
-	}
-      else if MBTEST(character == '<' && peek_char == '&')
-	return (LESS_AND);
-      else if MBTEST(character == '>' && peek_char == '&')
-	return (GREATER_AND);
-      else if MBTEST(character == '<' && peek_char == '>')
-	return (LESS_GREATER);
-      else if MBTEST(character == '>' && peek_char == '|')
-	return (GREATER_BAR);
-      else if MBTEST(character == '&' && peek_char == '>')
-	{
-	  peek_char = shell_getc (1);
-	  if MBTEST(peek_char == '>')
-	    return (AND_GREATER_GREATER);
-	  else
-	    {
-	      shell_ungetc (peek_char);
-	      return (AND_GREATER);
-	    }
-	}
-      else if MBTEST(character == '|' && peek_char == '&')
-	return (BAR_AND);
-      else if MBTEST(character == ';' && peek_char == '&')
-	{
-	  parser_state |= PST_CASEPAT;
-#if defined (ALIAS)
-	  parser_state &= ~PST_ALEXPNEXT;
-#endif /* ALIAS */
-	  return (SEMI_AND);
-	}
-
-      shell_ungetc (peek_char);
-
-      /* If we look like we are reading the start of a function
-	 definition, then let the reader know about it so that
-	 we will do the right thing with `{'. */
-      if MBTEST(character == ')' && last_read_token == '(' && token_before_that == WORD)
-	{
-	  parser_state |= PST_ALLOWOPNBRC;
-#if defined (ALIAS)
-	  parser_state &= ~PST_ALEXPNEXT;
-#endif /* ALIAS */
-	  function_dstart = line_number;
-	}
-
-      /* case pattern lists may be preceded by an optional left paren.  If
-	 we're not trying to parse a case pattern list, the left paren
-	 indicates a subshell. */
-      if MBTEST(character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
-	parser_state |= PST_SUBSHELL;
-      /*(*/
-      else if MBTEST((parser_state & PST_CASEPAT) && character == ')')
-	parser_state &= ~PST_CASEPAT;
-      /*(*/
-      else if MBTEST((parser_state & PST_SUBSHELL) && character == ')')
-	parser_state &= ~PST_SUBSHELL;
-
-#if defined (PROCESS_SUBSTITUTION)
-      /* Check for the constructs which introduce process substitution.
-	 Shells running in `posix mode' don't do process substitution. */
-      if MBTEST((character != '>' && character != '<') || peek_char != '(') /*)*/
-#endif /* PROCESS_SUBSTITUTION */
-	return (character);
-    }
-
-  /* Hack <&- (close stdin) case.  Also <&N- (dup and close). */
-  if MBTEST(character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
-    return (character);
-
-tokword:
-  /* Okay, if we got this far, we have to read a word.  Read one,
-     and then check it against the known ones. */
-  result = read_token_word (character);
-#if defined (ALIAS)
-  if (result == RE_READ_TOKEN)
-    goto re_read_token;
-#endif
-  return result;
-}
-
-/*
- * Match a $(...) or other grouping construct.  This has to handle embedded
- * quoted strings ('', ``, "") and nested constructs.  It also must handle
- * reprompting the user, if necessary, after reading a newline, and returning
- * correct error values if it reads EOF.
- */
-#define P_FIRSTCLOSE	0x0001
-#define P_ALLOWESC	0x0002
-#define P_DQUOTE	0x0004
-#define P_COMMAND	0x0008	/* parsing a command, so look for comments */
-#define P_BACKQUOTE	0x0010	/* parsing a backquoted command substitution */
-#define P_ARRAYSUB	0x0020	/* parsing a [...] array subscript for assignment */
-#define P_DOLBRACE	0x0040	/* parsing a ${...} construct */
-
-/* Lexical state while parsing a grouping construct or $(...). */
-#define LEX_WASDOL	0x0001
-#define LEX_CKCOMMENT	0x0002
-#define LEX_INCOMMENT	0x0004
-#define LEX_PASSNEXT	0x0008
-#define LEX_RESWDOK	0x0010
-#define LEX_CKCASE	0x0020
-#define LEX_INCASE	0x0040
-#define LEX_INHEREDOC	0x0080
-#define LEX_HEREDELIM	0x0100		/* reading here-doc delimiter */
-#define LEX_STRIPDOC	0x0200		/* <<- strip tabs from here doc delim */
-#define LEX_QUOTEDDOC	0x0400		/* here doc with quoted delim */
-#define LEX_INWORD	0x0800
-#define LEX_GTLT	0x1000
-#define LEX_CKESAC	0x2000		/* check esac after in -- for later */
-#define LEX_CASEWD	0x4000		/* word after case */
-#define LEX_PATLIST	0x8000		/* case statement pattern list */
-
-#define COMSUB_META(ch)		((ch) == ';' || (ch) == '&' || (ch) == '|')
-
-#define CHECK_NESTRET_ERROR() \
-  do { \
-    if (nestret == &matched_pair_error) \
-      { \
-	free (ret); \
-	return &matched_pair_error; \
-      } \
-  } while (0)
-
-#define APPEND_NESTRET() \
-  do { \
-    if (nestlen) \
-      { \
-	RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64); \
-	strcpy (ret + retind, nestret); \
-	retind += nestlen; \
-      } \
-  } while (0)
-
-static char matched_pair_error;
-
-static char *
-parse_matched_pair (qc, open, close, lenp, flags)
-     int qc;	/* `"' if this construct is within double quotes */
-     int open, close;
-     int *lenp, flags;
-{
-  int count, ch, prevch, tflags;
-  int nestlen, ttranslen, start_lineno;
-  char *ret, *nestret, *ttrans;
-  int retind, retsize, rflags;
-  int dolbrace_state;
-
-  dolbrace_state = (flags & P_DOLBRACE) ? DOLBRACE_PARAM : 0;
-
-/*itrace("parse_matched_pair[%d]: open = %c close = %c flags = %d", line_number, open, close, flags);*/
-  count = 1;
-  tflags = 0;
-
-  if ((flags & P_COMMAND) && qc != '`' && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
-    tflags |= LEX_CKCOMMENT;
-
-  /* RFLAGS is the set of flags we want to pass to recursive calls. */
-  rflags = (qc == '"') ? P_DQUOTE : (flags & P_DQUOTE);
-
-  ret = (char *)xmalloc (retsize = 64);
-  retind = 0;
-
-  start_lineno = line_number;
-  ch = EOF;		/* just in case */
-  while (count)
-    {
-      prevch = ch;
-      ch = shell_getc (qc != '\'' && (tflags & (LEX_PASSNEXT)) == 0);
-
-      if (ch == EOF)
-	{
-	  free (ret);
-	  parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
-	  EOF_Reached = 1;	/* XXX */
-	  return (&matched_pair_error);
-	}
-
-      /* Possible reprompting. */
-      if MBTEST(ch == '\n' && SHOULD_PROMPT ())
-	prompt_again (0);
-
-      /* Don't bother counting parens or doing anything else if in a comment
-	 or part of a case statement */
-      if (tflags & LEX_INCOMMENT)
-	{
-	  /* Add this character. */
-	  RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
-	  ret[retind++] = ch;
-
-	  if MBTEST(ch == '\n')
-	    tflags &= ~LEX_INCOMMENT;
-
-	  continue;
-	}
-
-      /* Not exactly right yet, should handle shell metacharacters, too.  If
-	 any changes are made to this test, make analogous changes to subst.c:
-	 extract_delimited_string(). */
-      else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || shellblank (ret[retind - 1])))
-	tflags |= LEX_INCOMMENT;
-
-      if (tflags & LEX_PASSNEXT)		/* last char was backslash */
-	{
-	  tflags &= ~LEX_PASSNEXT;
-	  /* XXX - PST_NOEXPAND? */
-	  if MBTEST(qc != '\'' && ch == '\n')	/* double-quoted \<newline> disappears. */
-	    {
-	      if (retind > 0)
-		retind--;	/* swallow previously-added backslash */
-	      continue;
-	    }
-
-	  RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
-	  if MBTEST(ch == CTLESC)
-	    ret[retind++] = CTLESC;
-	  ret[retind++] = ch;
-	  continue;
-	}
-      /* If we're reparsing the input (e.g., from parse_string_to_word_list),
-	 we've already prepended CTLESC to single-quoted results of $'...'.
-	 We may want to do this for other CTLESC-quoted characters in
-	 reparse, too. */
-      else if MBTEST((parser_state & PST_REPARSE) && open == '\'' && (ch == CTLESC || ch == CTLNUL))
-	{
-	  RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
-	  ret[retind++] = ch;
-	  continue;
-	}
-      else if MBTEST(ch == CTLESC || ch == CTLNUL)	/* special shell escapes */
-	{
-	  RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
-	  ret[retind++] = CTLESC;
-	  ret[retind++] = ch;
-	  continue;
-	}
-      else if MBTEST(ch == close)		/* ending delimiter */
-	count--;
-      /* handle nested ${...} specially. */
-      else if MBTEST(open != close && (tflags & LEX_WASDOL) && open == '{' && ch == open) /* } */
-	count++;
-      else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && ch == open)	/* nested begin */
-	count++;
-
-      /* Add this character. */
-      RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
-      ret[retind++] = ch;
-
-      /* If we just read the ending character, don't bother continuing. */
-      if (count == 0)
-	break;
-
-      if (open == '\'')			/* '' inside grouping construct */
-	{
-	  if MBTEST((flags & P_ALLOWESC) && ch == '\\')
-	    tflags |= LEX_PASSNEXT;
-	  continue;
-	}
-
-      if MBTEST(ch == '\\')			/* backslashes */
-	tflags |= LEX_PASSNEXT;
-
-      /* Based on which dolstate is currently in (param, op, or word),
-	 decide what the op is.  We're really only concerned if it's % or
-	 #, so we can turn on a flag that says whether or not we should
-	 treat single quotes as special when inside a double-quoted
-	 ${...}. This logic must agree with subst.c:extract_dollar_brace_string
-	 since they share the same defines. */
-      /* FLAG POSIX INTERP 221 */
-      if (flags & P_DOLBRACE)
-        {
-          /* ${param%[%]word} */
-	  if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '%' && retind > 1)
-	    dolbrace_state = DOLBRACE_QUOTE;
-          /* ${param#[#]word} */
-	  else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '#' && retind > 1)
-	    dolbrace_state = DOLBRACE_QUOTE;
-          /* ${param/[/]pat/rep} */
-	  else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '/' && retind > 1)
-	    dolbrace_state = DOLBRACE_QUOTE2;	/* XXX */
-          /* ${param^[^]pat} */
-	  else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == '^' && retind > 1)
-	    dolbrace_state = DOLBRACE_QUOTE;
-          /* ${param,[,]pat} */
-	  else if MBTEST(dolbrace_state == DOLBRACE_PARAM && ch == ',' && retind > 1)
-	    dolbrace_state = DOLBRACE_QUOTE;
-	  else if MBTEST(dolbrace_state == DOLBRACE_PARAM && strchr ("#%^,~:-=?+/", ch) != 0)
-	    dolbrace_state = DOLBRACE_OP;
-	  else if MBTEST(dolbrace_state == DOLBRACE_OP && strchr ("#%^,~:-=?+/", ch) == 0)
-	    dolbrace_state = DOLBRACE_WORD;
-        }
-
-      /* The big hammer.  Single quotes aren't special in double quotes.  The
-         problem is that Posix used to say the single quotes are semi-special:
-         within a double-quoted ${...} construct "an even number of
-         unescaped double-quotes or single-quotes, if any, shall occur." */
-      /* This was changed in Austin Group Interp 221 */
-      if MBTEST(posixly_correct && shell_compatibility_level > 41 && dolbrace_state != DOLBRACE_QUOTE && dolbrace_state != DOLBRACE_QUOTE2 && (flags & P_DQUOTE) && (flags & P_DOLBRACE) && ch == '\'')
-	continue;
-
-      /* Could also check open == '`' if we want to parse grouping constructs
-	 inside old-style command substitution. */
-      if (open != close)		/* a grouping construct */
-	{
-	  if MBTEST(shellquote (ch))
-	    {
-	      /* '', ``, or "" inside $(...) or other grouping construct. */
-	      push_delimiter (dstack, ch);
-	      if MBTEST((tflags & LEX_WASDOL) && ch == '\'')	/* $'...' inside group */
-		nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
-	      else
-		nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
-	      pop_delimiter (dstack);
-	      CHECK_NESTRET_ERROR ();
-
-	      if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0 || dolbrace_state == DOLBRACE_QUOTE || dolbrace_state == DOLBRACE_QUOTE2))
-		{
-		  /* Translate $'...' here. */
-		  /* PST_NOEXPAND */
-		  ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
-		  free (nestret);
-
-		  /* If we're parsing a double-quoted brace expansion and we are
-		     not in a place where single quotes are treated specially,
-		     make sure we single-quote the results of the ansi
-		     expansion because quote removal should remove them later */
-		  /* FLAG POSIX INTERP 221 */
-		  if ((shell_compatibility_level > 42) && (rflags & P_DQUOTE) && (dolbrace_state == DOLBRACE_QUOTE2 || dolbrace_state == DOLBRACE_QUOTE) && (flags & P_DOLBRACE))
-		    {
-		      nestret = sh_single_quote (ttrans);
-		      free (ttrans);
-		      nestlen = strlen (nestret);
-		    }
-#if 0 /* TAG:bash-5.3 */
-		  /* This single-quotes PARAM in ${PARAM OP WORD} when PARAM
-		     contains a $'...' even when extended_quote is set. */
-		  else if ((rflags & P_DQUOTE) && (dolbrace_state == DOLBRACE_PARAM) && (flags & P_DOLBRACE))
-		    {
-		      nestret = sh_single_quote (ttrans);
-		      free (ttrans);
-		      nestlen = strlen (nestret);
-		    }
-#endif
-		  else if ((rflags & P_DQUOTE) == 0)
-		    {
-		      nestret = sh_single_quote (ttrans);
-		      free (ttrans);
-		      nestlen = strlen (nestret);
-		    }
-		  else
-		    {
-		      /* Should we quote CTLESC here? */
-		      nestret = ttrans;
-		      nestlen = ttranslen;
-		    }
-		  retind -= 2;		/* back up before the $' */
-		}
-#if defined (TRANSLATABLE_STRINGS)
-	      else if MBTEST((tflags & LEX_WASDOL) && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
-		{
-		  /* Locale expand $"..." here. */
-		  /* PST_NOEXPAND */
-		  ttrans = locale_expand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
-		  free (nestret);
-
-		  /* If we're supposed to single-quote translated strings,
-		     check whether the translated result is different from
-		     the original and single-quote the string if it is. */
-		  if (singlequote_translations &&
-		        ((nestlen - 1) != ttranslen || STREQN (nestret, ttrans, ttranslen) == 0))
-		    {
-		      if ((rflags & P_DQUOTE) == 0)
-			nestret = sh_single_quote (ttrans);
-		      else if ((rflags & P_DQUOTE) && (dolbrace_state == DOLBRACE_QUOTE2) && (flags & P_DOLBRACE))
-			nestret = sh_single_quote (ttrans);
-		      else
-			/* single quotes aren't special, use backslash instead */
-			nestret = sh_backslash_quote_for_double_quotes (ttrans, 0);
-		    }
-		  else
-		    nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
-		  free (ttrans);
-		  nestlen = strlen (nestret);
-		  retind -= 2;		/* back up before the $" */
-		}
-#endif /* TRANSLATABLE_STRINGS */
-
-	      APPEND_NESTRET ();
-	      FREE (nestret);
-	    }
-	  else if ((flags & (P_ARRAYSUB|P_DOLBRACE)) && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '['))	/* ) } ] */
-	    goto parse_dollar_word;
-#if defined (PROCESS_SUBSTITUTION)
-	  /* XXX - technically this should only be recognized at the start of
-	     a word */
-	  else if ((flags & (P_ARRAYSUB|P_DOLBRACE)) && (tflags & LEX_GTLT) && (ch == '('))	/* ) */
-	    goto parse_dollar_word;
-#endif
-	}
-      /* Parse an old-style command substitution within double quotes as a
-	 single word. */
-      /* XXX - sh and ksh93 don't do this - XXX */
-      else if MBTEST(open == '"' && ch == '`')
-	{
-	  nestret = parse_matched_pair (0, '`', '`', &nestlen, rflags);
-
-	  CHECK_NESTRET_ERROR ();
-	  APPEND_NESTRET ();
-
-	  FREE (nestret);
-	}
-      else if MBTEST(open != '`' && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '['))	/* ) } ] */
-	/* check for $(), $[], or ${} inside quoted string. */
-	{
-parse_dollar_word:
-	  if (open == ch)	/* undo previous increment */
-	    count--;
-	  if (ch == '(')		/* ) */
-	    nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
-	  else if (ch == '{')		/* } */
-	    nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|P_DOLBRACE|rflags);
-	  else if (ch == '[')		/* ] */
-	    nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
-
-	  CHECK_NESTRET_ERROR ();
-	  APPEND_NESTRET ();
-
-	  FREE (nestret);
-	}
-#if defined (PROCESS_SUBSTITUTION)
-      if MBTEST((ch == '<' || ch == '>') && (tflags & LEX_GTLT) == 0)
-	tflags |= LEX_GTLT;
-      else
-	tflags &= ~LEX_GTLT;
-#endif
-      if MBTEST(ch == '$' && (tflags & LEX_WASDOL) == 0)
-	tflags |= LEX_WASDOL;
-      else
-	tflags &= ~LEX_WASDOL;
-    }
-
-  ret[retind] = '\0';
-  if (lenp)
-    *lenp = retind;
-/*itrace("parse_matched_pair[%d]: returning %s", line_number, ret);*/
-  return ret;
-}
-
-#if defined (DEBUG)
-static void
-dump_tflags (flags)
-     int flags;
-{
-  int f;
-
-  f = flags;
-  fprintf (stderr, "%d -> ", f);
-  if (f & LEX_WASDOL)
-    {
-      f &= ~LEX_WASDOL;
-      fprintf (stderr, "LEX_WASDOL%s", f ? "|" : "");
-    }
-  if (f & LEX_CKCOMMENT)
-    {
-      f &= ~LEX_CKCOMMENT;
-      fprintf (stderr, "LEX_CKCOMMENT%s", f ? "|" : "");
-    }
-  if (f & LEX_INCOMMENT)
-    {
-      f &= ~LEX_INCOMMENT;
-      fprintf (stderr, "LEX_INCOMMENT%s", f ? "|" : "");
-    }
-  if (f & LEX_PASSNEXT)
-    {
-      f &= ~LEX_PASSNEXT;
-      fprintf (stderr, "LEX_PASSNEXT%s", f ? "|" : "");
-    }
-  if (f & LEX_RESWDOK)
-    {
-      f &= ~LEX_RESWDOK;
-      fprintf (stderr, "LEX_RESWDOK%s", f ? "|" : "");
-    }
-  if (f & LEX_CKCASE)
-    {
-      f &= ~LEX_CKCASE;
-      fprintf (stderr, "LEX_CKCASE%s", f ? "|" : "");
-    }
-  if (f & LEX_CKESAC)
-    {
-      f &= ~LEX_CKESAC;
-      fprintf (stderr, "LEX_CKESAC%s", f ? "|" : "");
-    }
-  if (f & LEX_INCASE)
-    {
-      f &= ~LEX_INCASE;
-      fprintf (stderr, "LEX_INCASE%s", f ? "|" : "");
-    }
-  if (f & LEX_CASEWD)
-    {
-      f &= ~LEX_CASEWD;
-      fprintf (stderr, "LEX_CASEWD%s", f ? "|" : "");
-    }
-  if (f & LEX_PATLIST)
-    {
-      f &= ~LEX_PATLIST;
-      fprintf (stderr, "LEX_PATLIST%s", f ? "|" : "");
-    }
-  if (f & LEX_INHEREDOC)
-    {
-      f &= ~LEX_INHEREDOC;
-      fprintf (stderr, "LEX_INHEREDOC%s", f ? "|" : "");
-    }
-  if (f & LEX_HEREDELIM)
-    {
-      f &= ~LEX_HEREDELIM;
-      fprintf (stderr, "LEX_HEREDELIM%s", f ? "|" : "");
-    }
-  if (f & LEX_STRIPDOC)
-    {
-      f &= ~LEX_STRIPDOC;
-      fprintf (stderr, "LEX_WASDOL%s", f ? "|" : "");
-    }
-  if (f & LEX_QUOTEDDOC)
-    {
-      f &= ~LEX_QUOTEDDOC;
-      fprintf (stderr, "LEX_QUOTEDDOC%s", f ? "|" : "");
-    }
-  if (f & LEX_INWORD)
-    {
-      f &= ~LEX_INWORD;
-      fprintf (stderr, "LEX_INWORD%s", f ? "|" : "");
-    }
-
-  fprintf (stderr, "\n");
-  fflush (stderr);
-}
-#endif
-
-/* Parse a $(...) command substitution.  This reads input from the current
-   input stream. */
-static char *
-parse_comsub (qc, open, close, lenp, flags)
-     int qc;	/* `"' if this construct is within double quotes */
-     int open, close;
-     int *lenp, flags;
-{
-  int peekc, r;
-  int start_lineno, local_extglob, was_extpat;
-  char *ret, *tcmd;
-  int retlen;
-  sh_parser_state_t ps;
-  STRING_SAVER *saved_strings;
-  COMMAND *saved_global, *parsed_command;
-
-  /* Posix interp 217 says arithmetic expressions have precedence, so
-     assume $(( introduces arithmetic expansion and parse accordingly. */
-  if (open == '(')		/*)*/
-    {
-      peekc = shell_getc (1);
-      shell_ungetc (peekc);
-      if (peekc == '(')		/*)*/
-	return (parse_matched_pair (qc, open, close, lenp, 0));
-    }
-
-/*itrace("parse_comsub: qc = `%c' open = %c close = %c", qc, open, close);*/
-
-  /*debug_parser(1);*/
-  start_lineno = line_number;
-
-  save_parser_state (&ps);
-
-  was_extpat = (parser_state & PST_EXTPAT);
-
-  /* State flags we don't want to persist into command substitutions. */
-  parser_state &= ~(PST_REGEXP|PST_EXTPAT|PST_CONDCMD|PST_CONDEXPR|PST_COMPASSIGN);
-  /* Could do PST_CASESTMT too, but that also affects history. Setting
-     expecting_in_token below should take care of the parsing requirements.
-     Unsetting PST_REDIRLIST isn't strictly necessary because of how we set
-     token_to_read below, but we do it anyway. */
-  parser_state &= ~(PST_CASEPAT|PST_ALEXPNEXT|PST_SUBSHELL|PST_REDIRLIST);
-  /* State flags we want to set for this run through the parser. */
-  parser_state |= PST_CMDSUBST|PST_EOFTOKEN|PST_NOEXPAND;
-
-  /* leave pushed_string_list alone, since we might need to consume characters
-     from it to satisfy this command substitution (in some perverse case). */
-  shell_eof_token = close;
-
-  saved_global = global_command;		/* might not be necessary */
-  global_command = (COMMAND *)NULL;
-
-  /* These are reset by reset_parser() */
-  need_here_doc = 0;
-  esacs_needed_count = expecting_in_token = 0;
-
-  /* We want to expand aliases on this pass if we're in posix mode, since the
-     standard says you have to take aliases into account when looking for the
-     terminating right paren. Otherwise, we defer until execution time for
-     backwards compatibility. */
-  if (expand_aliases)
-    expand_aliases = posixly_correct != 0;
-#if defined (EXTENDED_GLOB)
-  /* If (parser_state & PST_EXTPAT), we're parsing an extended pattern for a
-     conditional command and have already set global_extglob appropriately. */
-  if (shell_compatibility_level <= 51 && was_extpat == 0)
-    {
-      local_extglob = global_extglob = extended_glob;
-      extended_glob = 1;
-    }
-#endif
-
-  current_token = '\n';				/* XXX */
-  token_to_read = DOLPAREN;			/* let's trick the parser */
-
-  r = yyparse ();
-
-  if (need_here_doc > 0)
-    {
-      internal_warning ("command substitution: %d unterminated here-document%s", need_here_doc, (need_here_doc == 1) ? "" : "s");
-      gather_here_documents ();	/* XXX check compatibility level? */
-    }
-
-#if defined (EXTENDED_GLOB)
-  if (shell_compatibility_level <= 51 && was_extpat == 0)
-    extended_glob = local_extglob;
-#endif
-
-  parsed_command = global_command;
-
-  if (EOF_Reached)
-    {
-      shell_eof_token = ps.eof_token;
-      expand_aliases = ps.expand_aliases;
-
-      /* yyparse() has already called yyerror() and reset_parser() */
-      return (&matched_pair_error);
-    }
-  else if (r != 0)
-    {
-      /* parser_error (start_lineno, _("could not parse command substitution")); */
-      /* Non-interactive shells exit on parse error in a command substitution. */
-      if (last_command_exit_value == 0)
-	last_command_exit_value = EXECUTION_FAILURE;
-      set_exit_status (last_command_exit_value);
-      if (interactive_shell == 0)
-	jump_to_top_level (FORCE_EOF);	/* This is like reader_loop() */
-      else
-	{
-	  shell_eof_token = ps.eof_token;
-	  expand_aliases = ps.expand_aliases;
-
-	  jump_to_top_level (DISCARD);	/* XXX - return (&matched_pair_error)? */
-	}
-    }
-
-  if (current_token != shell_eof_token)
-    {
-INTERNAL_DEBUG(("current_token (%d) != shell_eof_token (%c)", current_token, shell_eof_token));
-      token_to_read = current_token;
-
-      /* If we get here we can check eof_encountered and if it's 1 but the
-	 previous EOF_Reached test didn't succeed, we can assume that the shell
-	 is interactive and ignoreeof is set. We might want to restore the
-	 parser state in this case. */
-      shell_eof_token = ps.eof_token;
-      expand_aliases = ps.expand_aliases;
-
-      return (&matched_pair_error);
-    }
-
-  /* We don't want to restore the old pushed string list, since we might have
-     used it to consume additional input from an alias while parsing this
-     command substitution. */
-  saved_strings = pushed_string_list;
-  restore_parser_state (&ps);
-  pushed_string_list = saved_strings;
-
-  tcmd = print_comsub (parsed_command);		/* returns static memory */
-  retlen = strlen (tcmd);
-  if (tcmd[0] == '(')			/* ) need a space to prevent arithmetic expansion */
-    retlen++;
-  ret = xmalloc (retlen + 2);
-  if (tcmd[0] == '(')			/* ) */
-    {
-      ret[0] = ' ';
-      strcpy (ret + 1, tcmd);
-    }
-  else
-    strcpy (ret, tcmd);
-  ret[retlen++] = ')';
-  ret[retlen] = '\0';
-
-  dispose_command (parsed_command);
-  global_command = saved_global;
-
-  if (lenp)
-    *lenp = retlen;
-
-/*itrace("parse_comsub:%d: returning `%s'", line_number, ret);*/
-  return ret;
-}
-
-/* Recursively call the parser to parse a $(...) command substitution. This is
-   called by the word expansion code and so does not have to reset as much
-   parser state before calling yyparse(). */
-char *
-xparse_dolparen (base, string, indp, flags)
-     char *base;
-     char *string;
-     int *indp;
-     int flags;
-{
-  sh_parser_state_t ps;
-  sh_input_line_state_t ls;
-  int orig_ind, nc, sflags, start_lineno;
-  char *ret, *ep, *ostring;
-
-/*debug_parser(1);*/
-  orig_ind = *indp;
-  ostring = string;
-  start_lineno = line_number;
-
-  if (*string == 0)
-    {
-      if (flags & SX_NOALLOC) 
-	return (char *)NULL;
-
-      ret = xmalloc (1);
-      ret[0] = '\0';
-      return ret;
-    }
-
-/*itrace("xparse_dolparen: size = %d shell_input_line = `%s' string=`%s'", shell_input_line_size, shell_input_line, string);*/
-
-  sflags = SEVAL_NONINT|SEVAL_NOHIST|SEVAL_NOFREE;
-  if (flags & SX_NOLONGJMP)
-    sflags |= SEVAL_NOLONGJMP;
-
-  save_parser_state (&ps);
-  save_input_line_state (&ls);
-
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  pushed_string_list = (STRING_SAVER *)NULL;
-#endif
-  /*(*/
-  parser_state |= PST_CMDSUBST|PST_EOFTOKEN;	/* allow instant ')' */ /*(*/
-  shell_eof_token = ')';
-  if (flags & SX_COMPLETE)
-    parser_state |= PST_NOERROR;
-
-  /* Don't expand aliases on this pass at all. Either parse_comsub() does it
-     at parse time, in which case this string already has aliases expanded,
-     or command_substitute() does it in the child process executing the
-     command substitution and we want to defer it completely until then. The
-     old value will be restored by restore_parser_state(). */
-  expand_aliases = 0;
-#if defined (EXTENDED_GLOB)
-  global_extglob = extended_glob;		/* for reset_parser() */
-#endif
-
-  token_to_read = DOLPAREN;			/* let's trick the parser */
-
-  nc = parse_string (string, "command substitution", sflags, (COMMAND **)NULL, &ep);
-
-  /* Should we save and restore the bison/yacc lookahead token (yychar) here?
-     Or only if it's not YYEMPTY? */
-  if (current_token == shell_eof_token)
-    yyclearin;		/* might want to clear lookahead token unconditionally */
-
-  reset_parser ();	/* resets extended_glob too */
-  /* reset_parser() clears shell_input_line and associated variables, including
-     parser_state, so we want to reset things, then restore what we need. */
-  restore_input_line_state (&ls);
-  restore_parser_state (&ps);
-
-  token_to_read = 0;
-
-  /* If parse_string returns < 0, we need to jump to top level with the
-     negative of the return value. We abandon the rest of this input line
-     first */
-  if (nc < 0)
-    {
-      clear_shell_input_line ();	/* XXX */
-      if (bash_input.type != st_string)	/* paranoia */
-	parser_state &= ~(PST_CMDSUBST|PST_EOFTOKEN);
-      if ((flags & SX_NOLONGJMP) == 0)
-	jump_to_top_level (-nc);	/* XXX */
-    }
-
-  /* Need to find how many characters parse_string() consumed, update
-     *indp, if flags != 0, copy the portion of the string parsed into RET
-     and return it.  If flags & 1 (SX_NOALLOC) we can return NULL. */
-
-  /*(*/
-  if (ep[-1] != ')')
-    {
-#if 0
-      if (ep[-1] != '\n')
-	itrace("xparse_dolparen:%d: ep[-1] != RPAREN (%d), ep = `%s'", line_number, ep[-1], ep);
-#endif
-
-      while (ep > ostring && ep[-1] == '\n') ep--;
-    }
-
-  nc = ep - ostring;
-  *indp = ep - base - 1;
-
-  /*((*/
-#if 0
-  if (base[*indp] != ')')
-    itrace("xparse_dolparen:%d: base[%d] != RPAREN (%d), base = `%s'", line_number, *indp, base[*indp], base);
-  if (*indp < orig_ind)
-    itrace("xparse_dolparen:%d: *indp (%d) < orig_ind (%d), orig_string = `%s'", line_number, *indp, orig_ind, ostring);
-#endif
-
-  if (base[*indp] != ')' && (flags & SX_NOLONGJMP) == 0)
-    {
-      /*(*/
-      if ((flags & SX_NOERROR) == 0)
-	parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), ')');
-      jump_to_top_level (DISCARD);
-    }
-
-  if (flags & SX_NOALLOC) 
-    return (char *)NULL;
-
-  if (nc == 0)
-    {
-      ret = xmalloc (1);
-      ret[0] = '\0';
-    }
-  else
-    ret = substring (ostring, 0, nc - 1);
-
-  return ret;
-}
-
-/* Recursively call the parser to parse the string from a $(...) command
-   substitution to a COMMAND *. This is called from command_substitute() and
-   has the same parser state constraints as xparse_dolparen(). */
-COMMAND *
-parse_string_to_command (string, flags)
-     char *string;
-     int flags;
-{
-  sh_parser_state_t ps;
-  sh_input_line_state_t ls;
-  int nc, sflags;
-  size_t slen;
-  char *ret, *ep;
-  COMMAND *cmd;
-
-  if (*string == 0)
-    return (COMMAND *)NULL;
-
-  ep = string;
-  slen = STRLEN (string);
-
-/*itrace("parse_string_to_command: size = %d shell_input_line = `%s' string=`%s'", shell_input_line_size, shell_input_line, string);*/
-
-  sflags = SEVAL_NONINT|SEVAL_NOHIST|SEVAL_NOFREE;
-  if (flags & SX_NOLONGJMP)
-    sflags |= SEVAL_NOLONGJMP;
-
-  save_parser_state (&ps);
-  save_input_line_state (&ls);
-
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  pushed_string_list = (STRING_SAVER *)NULL;
-#endif
-  if (flags & SX_COMPLETE)
-    parser_state |= PST_NOERROR;
-
-  expand_aliases = 0;
-
-  cmd = 0;
-  nc = parse_string (string, "command substitution", sflags, &cmd, &ep);
-
-  reset_parser ();
-  /* reset_parser() clears shell_input_line and associated variables, including
-     parser_state, so we want to reset things, then restore what we need. */
-  restore_input_line_state (&ls);
-  restore_parser_state (&ps);
-
-  /* If parse_string returns < 0, we need to jump to top level with the
-     negative of the return value. We abandon the rest of this input line
-     first */
-  if (nc < 0)
-    {
-      clear_shell_input_line ();	/* XXX */
-      if ((flags & SX_NOLONGJMP) == 0)
-        jump_to_top_level (-nc);	/* XXX */
-    }
-
-  /* Need to check how many characters parse_string() consumed, make sure it's
-     the entire string. */
-  if (nc < slen)
-    {
-      dispose_command (cmd);
-      return (COMMAND *)NULL;
-    }
-
-  return cmd;
-}
-
-#if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
-/* Parse a double-paren construct.  It can be either an arithmetic
-   command, an arithmetic `for' command, or a nested subshell.  Returns
-   the parsed token, -1 on error, or -2 if we didn't do anything and
-   should just go on. */
-static int
-parse_dparen (c)
-     int c;
-{
-  int cmdtyp, sline;
-  char *wval;
-  WORD_DESC *wd;
-
-#if defined (ARITH_FOR_COMMAND)
-  if (last_read_token == FOR)
-    {
-      if (word_top < MAX_CASE_NEST)
-	word_top++;
-      arith_for_lineno = word_lineno[word_top] = line_number;
-      cmdtyp = parse_arith_cmd (&wval, 0);
-      if (cmdtyp == 1)
-	{
-	  wd = alloc_word_desc ();
-	  wd->word = wval;
-	  yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
-	  return (ARITH_FOR_EXPRS);
-	}
-      else
-	return -1;		/* ERROR */
-    }
-#endif
-
-#if defined (DPAREN_ARITHMETIC)
-  if (reserved_word_acceptable (last_read_token))
-    {
-      sline = line_number;
-
-      cmdtyp = parse_arith_cmd (&wval, 0);
-      if (cmdtyp == 1)	/* arithmetic command */
-	{
-	  wd = alloc_word_desc ();
-	  wd->word = wval;
-	  wd->flags = W_QUOTED|W_NOSPLIT|W_NOGLOB|W_NOTILDE|W_NOPROCSUB;
-	  yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
-	  return (ARITH_CMD);
-	}
-      else if (cmdtyp == 0)	/* nested subshell */
-	{
-	  push_string (wval, 0, (alias_t *)NULL);
-	  pushed_string_list->flags = PSH_DPAREN;
-	  if ((parser_state & PST_CASEPAT) == 0)
-	    parser_state |= PST_SUBSHELL;
-	  return (c);
-	}
-      else			/* ERROR */
-	return -1;
-    }
-#endif
-
-  return -2;			/* XXX */
-}
-
-/* We've seen a `(('.  Look for the matching `))'.  If we get it, return 1.
-   If not, assume it's a nested subshell for backwards compatibility and
-   return 0.  In any case, put the characters we've consumed into a locally-
-   allocated buffer and make *ep point to that buffer.  Return -1 on an
-   error, for example EOF. */
-static int
-parse_arith_cmd (ep, adddq)
-     char **ep;
-     int adddq;
-{
-  int exp_lineno, rval, c;
-  char *ttok, *tokstr;
-  int ttoklen;
-
-  exp_lineno = line_number;
-  ttok = parse_matched_pair (0, '(', ')', &ttoklen, 0);
-  rval = 1;
-  if (ttok == &matched_pair_error)
-    return -1;
-  /* Check that the next character is the closing right paren.  If
-     not, this is a syntax error. ( */
-  c = shell_getc (0);
-  if MBTEST(c != ')')
-    rval = 0;
-
-  tokstr = (char *)xmalloc (ttoklen + 4);
-
-  /* if ADDDQ != 0 then (( ... )) -> "..." */
-  if (rval == 1 && adddq)	/* arith cmd, add double quotes */
-    {
-      tokstr[0] = '"';
-      strncpy (tokstr + 1, ttok, ttoklen - 1);
-      tokstr[ttoklen] = '"';
-      tokstr[ttoklen+1] = '\0';
-    }
-  else if (rval == 1)		/* arith cmd, don't add double quotes */
-    {
-      strncpy (tokstr, ttok, ttoklen - 1);
-      tokstr[ttoklen-1] = '\0';
-    }
-  else				/* nested subshell */
-    {
-      tokstr[0] = '(';
-      strncpy (tokstr + 1, ttok, ttoklen - 1);
-      tokstr[ttoklen] = ')';
-      tokstr[ttoklen+1] = c;
-      tokstr[ttoklen+2] = '\0';
-    }
-
-  *ep = tokstr;
-  FREE (ttok);
-  return rval;
-}
-#endif /* DPAREN_ARITHMETIC || ARITH_FOR_COMMAND */
-
-#if defined (COND_COMMAND)
-static void
-cond_error ()
-{
-  char *etext;
-
-  if (EOF_Reached && cond_token != COND_ERROR)		/* [[ */
-    parser_error (cond_lineno, _("unexpected EOF while looking for `]]'"));
-  else if (cond_token != COND_ERROR)
-    {
-      if (etext = error_token_from_token (cond_token))
-	{
-	  parser_error (cond_lineno, _("syntax error in conditional expression: unexpected token `%s'"), etext);
-	  free (etext);
-	}
-      else
-	parser_error (cond_lineno, _("syntax error in conditional expression"));
-    }
-}
-
-static COND_COM *
-cond_expr ()
-{
-  return (cond_or ());  
-}
-
-static COND_COM *
-cond_or ()
-{
-  COND_COM *l, *r;
-
-  l = cond_and ();
-  if (cond_token == OR_OR)
-    {
-      r = cond_or ();
-      l = make_cond_node (COND_OR, (WORD_DESC *)NULL, l, r);
-    }
-  return l;
-}
-
-static COND_COM *
-cond_and ()
-{
-  COND_COM *l, *r;
-
-  l = cond_term ();
-  if (cond_token == AND_AND)
-    {
-      r = cond_and ();
-      l = make_cond_node (COND_AND, (WORD_DESC *)NULL, l, r);
-    }
-  return l;
-}
-
-static int
-cond_skip_newlines ()
-{
-  while ((cond_token = read_token (READ)) == '\n')
-    {
-      if (SHOULD_PROMPT ())
-	prompt_again (0);
-    }
-  return (cond_token);
-}
-
-#define COND_RETURN_ERROR() \
-  do { cond_token = COND_ERROR; return ((COND_COM *)NULL); } while (0)
-
-static COND_COM *
-cond_term ()
-{
-  WORD_DESC *op;
-  COND_COM *term, *tleft, *tright;
-  int tok, lineno, local_extglob;
-  char *etext;
-
-  /* Read a token.  It can be a left paren, a `!', a unary operator, or a
-     word that should be the first argument of a binary operator.  Start by
-     skipping newlines, since this is a compound command. */
-  tok = cond_skip_newlines ();
-  lineno = line_number;
-  if (tok == COND_END)
-    {
-      COND_RETURN_ERROR ();
-    }
-  else if (tok == '(')
-    {
-      term = cond_expr ();
-      if (cond_token != ')')
-	{
-	  if (term)
-	    dispose_cond_node (term);		/* ( */
-	  if (etext = error_token_from_token (cond_token))
-	    {
-	      parser_error (lineno, _("unexpected token `%s', expected `)'"), etext);
-	      free (etext);
-	    }
-	  else
-	    parser_error (lineno, _("expected `)'"));
-	  COND_RETURN_ERROR ();
-	}
-      term = make_cond_node (COND_EXPR, (WORD_DESC *)NULL, term, (COND_COM *)NULL);
-      (void)cond_skip_newlines ();
-    }
-  else if (tok == BANG || (tok == WORD && (yylval.word->word[0] == '!' && yylval.word->word[1] == '\0')))
-    {
-      if (tok == WORD)
-	dispose_word (yylval.word);	/* not needed */
-      term = cond_term ();
-      if (term)
-	term->flags ^= CMD_INVERT_RETURN;
-    }
-  else if (tok == WORD && yylval.word->word[0] == '-' && yylval.word->word[1] && yylval.word->word[2] == 0 && test_unop (yylval.word->word))
-    {
-      op = yylval.word;
-      tok = read_token (READ);
-      if (tok == WORD)
-	{
-	  tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
-	  term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
-	}
-      else
-	{
-	  dispose_word (op);
-	  if (etext = error_token_from_token (tok))
-	    {
-	      parser_error (line_number, _("unexpected argument `%s' to conditional unary operator"), etext);
-	      free (etext);
-	    }
-	  else
-	    parser_error (line_number, _("unexpected argument to conditional unary operator"));
-	  COND_RETURN_ERROR ();
-	}
-
-      (void)cond_skip_newlines ();
-    }
-  else if (tok == WORD)		/* left argument to binary operator */
-    {
-      /* lhs */
-      tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
-
-      /* binop */
-      /* tok = cond_skip_newlines (); ? */
-      tok = read_token (READ);
-      if (tok == WORD && test_binop (yylval.word->word))
-	{
-	  op = yylval.word;
-	  if (op->word[0] == '=' && (op->word[1] == '\0' || (op->word[1] == '=' && op->word[2] == '\0')))
-	    parser_state |= PST_EXTPAT;
-	  else if (op->word[0] == '!' && op->word[1] == '=' && op->word[2] == '\0')
-	    parser_state |= PST_EXTPAT;
-	}
-#if defined (COND_REGEXP)
-      else if (tok == WORD && STREQ (yylval.word->word, "=~"))
-	{
-	  op = yylval.word;
-	  parser_state |= PST_REGEXP;
-	}
-#endif
-      else if (tok == '<' || tok == '>')
-	op = make_word_from_token (tok);  /* ( */
-      /* There should be a check before blindly accepting the `)' that we have
-	 seen the opening `('. */
-      else if (tok == COND_END || tok == AND_AND || tok == OR_OR || tok == ')')
-	{
-	  /* Special case.  [[ x ]] is equivalent to [[ -n x ]], just like
-	     the test command.  Similarly for [[ x && expr ]] or
-	     [[ x || expr ]] or [[ (x) ]]. */
-	  op = make_word ("-n");
-	  term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
-	  cond_token = tok;
-	  return (term);
-	}
-      else
-	{
-	  if (etext = error_token_from_token (tok))
-	    {
-	      parser_error (line_number, _("unexpected token `%s', conditional binary operator expected"), etext);
-	      free (etext);
-	    }
-	  else
-	    parser_error (line_number, _("conditional binary operator expected"));
-	  dispose_cond_node (tleft);
-	  COND_RETURN_ERROR ();
-	}
-
-      /* rhs */
-      local_extglob = extended_glob;
-      if (parser_state & PST_EXTPAT)
-	extended_glob = 1;
-      tok = read_token (READ);
-      if (parser_state & PST_EXTPAT)
-	extended_glob = local_extglob;
-      parser_state &= ~(PST_REGEXP|PST_EXTPAT);
-
-      if (tok == WORD)
-	{
-	  tright = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
-	  term = make_cond_node (COND_BINARY, op, tleft, tright);
-	}
-      else
-	{
-	  if (etext = error_token_from_token (tok))
-	    {
-	      parser_error (line_number, _("unexpected argument `%s' to conditional binary operator"), etext);
-	      free (etext);
-	    }
-	  else
-	    parser_error (line_number, _("unexpected argument to conditional binary operator"));
-	  dispose_cond_node (tleft);
-	  dispose_word (op);
-	  COND_RETURN_ERROR ();
-	}
-
-      (void)cond_skip_newlines ();
-    }
-  else
-    {
-      if (tok < 256)
-	parser_error (line_number, _("unexpected token `%c' in conditional command"), tok);
-      else if (etext = error_token_from_token (tok))
-	{
-	  parser_error (line_number, _("unexpected token `%s' in conditional command"), etext);
-	  free (etext);
-	}
-      else
-	parser_error (line_number, _("unexpected token %d in conditional command"), tok);
-      COND_RETURN_ERROR ();
-    }
-  return (term);
-}      
-
-/* This is kind of bogus -- we slip a mini recursive-descent parser in
-   here to handle the conditional statement syntax. */
-static COMMAND *
-parse_cond_command ()
-{
-  COND_COM *cexp;
-
-  global_extglob = extended_glob;
-  cexp = cond_expr ();
-  return (make_cond_command (cexp));
-}
-#endif
-
-#if defined (ARRAY_VARS)
-/* When this is called, it's guaranteed that we don't care about anything
-   in t beyond i.  We use a buffer with room for the characters we add just
-   in case assignment() ends up doing something like parsing a command
-   substitution that will reallocate atoken.  We don't want to write beyond
-   the end of an allocated buffer. */
-static int
-token_is_assignment (t, i)
-     char *t;
-     int i;
-{
-  int r;
-  char *atoken;
-
-  atoken = xmalloc (i + 3);
-  memcpy (atoken, t, i);
-  atoken[i] = '=';
-  atoken[i+1] = '\0';
-
-  r = assignment (atoken, (parser_state & PST_COMPASSIGN) != 0);
-
-  free (atoken);
-
-  /* XXX - check that r == i to avoid returning false positive for
-     t containing `=' before t[i]. */
-  return (r > 0 && r == i);
-}
-
-/* XXX - possible changes here for `+=' */
-static int
-token_is_ident (t, i)
-     char *t;
-     int i;
-{
-  unsigned char c;
-  int r;
-
-  c = t[i];
-  t[i] = '\0';
-  r = legal_identifier (t);
-  t[i] = c;
-  return r;
-}
-#endif
-
-static int
-read_token_word (character)
-     int character;
-{
-  /* The value for YYLVAL when a WORD is read. */
-  WORD_DESC *the_word;
-
-  /* Index into the token that we are building. */
-  int token_index;
-
-  /* ALL_DIGITS becomes zero when we see a non-digit. */
-  int all_digit_token;
-
-  /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
-  int dollar_present;
-
-  /* COMPOUND_ASSIGNMENT becomes non-zero if we are parsing a compound
-     assignment. */
-  int compound_assignment;
-
-  /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
-  int quoted;
-
-  /* Non-zero means to ignore the value of the next character, and just
-     to add it no matter what. */
-  int pass_next_character;
-
-  /* The current delimiting character. */
-  int cd;
-  int result, peek_char;
-  char *ttok, *ttrans;
-  int ttoklen, ttranslen;
-  intmax_t lvalue;
-
-  if (token_buffer_size < TOKEN_DEFAULT_INITIAL_SIZE)
-    token = (char *)xrealloc (token, token_buffer_size = TOKEN_DEFAULT_INITIAL_SIZE);
-
-  token_index = 0;
-  all_digit_token = DIGIT (character);
-  dollar_present = quoted = pass_next_character = compound_assignment = 0;
-
-  for (;;)
-    {
-      if (character == EOF)
-	goto got_token;
-
-      if (pass_next_character)
-	{
-	  pass_next_character = 0;
-	  goto got_escaped_character;
-	}
-
-      cd = current_delimiter (dstack);
-
-      /* Handle backslashes.  Quote lots of things when not inside of
-	 double-quotes, quote some things inside of double-quotes. */
-      if MBTEST(character == '\\')
-	{
-	  if (parser_state & PST_NOEXPAND)
-	    {
-	      pass_next_character++;
-	      quoted = 1;
-	      goto got_character;
-	    }
-	      
-	  peek_char = shell_getc (0);
-
-	  /* Backslash-newline is ignored in all cases except
-	     when quoted with single quotes. */
-	  if MBTEST(peek_char == '\n')
-	    {
-	      character = '\n';
-	      goto next_character;
-	    }
-	  else
-	    {
-	      shell_ungetc (peek_char);
-
-	      /* If the next character is to be quoted, note it now. */
-	      if MBTEST(cd == 0 || cd == '`' ||
-		  (cd == '"' && peek_char >= 0 && (sh_syntaxtab[peek_char] & CBSDQUOTE)))
-		pass_next_character++;
-
-	      quoted = 1;
-	      goto got_character;
-	    }
-	}
-
-      /* Parse a matched pair of quote characters. */
-      if MBTEST(shellquote (character))
-	{
-	  push_delimiter (dstack, character);
-	  ttok = parse_matched_pair (character, character, character, &ttoklen, (character == '`') ? P_COMMAND : 0);
-	  pop_delimiter (dstack);
-	  if (ttok == &matched_pair_error)
-	    return -1;		/* Bail immediately. */
-	  RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
-				  token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
-	  token[token_index++] = character;
-	  strcpy (token + token_index, ttok);
-	  token_index += ttoklen;
-	  all_digit_token = 0;
-	  if (character != '`')
-	    quoted = 1;
-	  dollar_present |= (character == '"' && strchr (ttok, '$') != 0);
-	  FREE (ttok);
-	  goto next_character;
-	}
-
-#ifdef COND_REGEXP
-      /* When parsing a regexp as a single word inside a conditional command,
-	 we need to special-case characters special to both the shell and
-	 regular expressions.  Right now, that is only '(' and '|'. */ /*)*/
-      if MBTEST((parser_state & PST_REGEXP) && (character == '(' || character == '|'))		/*)*/
-	{
-	  if (character == '|')
-	    goto got_character;
-
-	  push_delimiter (dstack, character);
-	  ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
-	  pop_delimiter (dstack);
-	  if (ttok == &matched_pair_error)
-	    return -1;		/* Bail immediately. */
-	  RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
-				  token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
-	  token[token_index++] = character;
-	  strcpy (token + token_index, ttok);
-	  token_index += ttoklen;
-	  FREE (ttok);
-	  dollar_present = all_digit_token = 0;
-	  goto next_character;
-	}
-#endif /* COND_REGEXP */
-
-#ifdef EXTENDED_GLOB
-      /* Parse a ksh-style extended pattern matching specification. */
-      if MBTEST(extended_glob && PATTERN_CHAR (character))
-	{
-	  peek_char = shell_getc (1);
-	  if MBTEST(peek_char == '(')		/* ) */
-	    {
-	      push_delimiter (dstack, peek_char);
-	      ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
-	      pop_delimiter (dstack);
-	      if (ttok == &matched_pair_error)
-		return -1;		/* Bail immediately. */
-	      RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 3,
-				      token_buffer_size,
-				      TOKEN_DEFAULT_GROW_SIZE);
-	      token[token_index++] = character;
-	      token[token_index++] = peek_char;
-	      strcpy (token + token_index, ttok);
-	      token_index += ttoklen;
-	      FREE (ttok);
-	      dollar_present = all_digit_token = 0;
-	      goto next_character;
-	    }
-	  else
-	    shell_ungetc (peek_char);
-	}
-#endif /* EXTENDED_GLOB */
-
-      /* If the delimiter character is not single quote, parse some of
-	 the shell expansions that must be read as a single word. */
-      if MBTEST(shellexp (character))
-	{
-	  peek_char = shell_getc (1);
-	  /* $(...), <(...), >(...), $((...)), ${...}, and $[...] constructs */
-	  if MBTEST(peek_char == '(' ||
-		((peek_char == '{' || peek_char == '[') && character == '$'))	/* ) ] } */
-	    {
-	      if (peek_char == '{')		/* } */
-		ttok = parse_matched_pair (cd, '{', '}', &ttoklen, P_FIRSTCLOSE|P_DOLBRACE);
-	      else if (peek_char == '(')		/* ) */
-		{
-		  /* XXX - push and pop the `(' as a delimiter for use by
-		     the command-oriented-history code.  This way newlines
-		     appearing in the $(...) string get added to the
-		     history literally rather than causing a possibly-
-		     incorrect `;' to be added. ) */
-		  push_delimiter (dstack, peek_char);
-		  ttok = parse_comsub (cd, '(', ')', &ttoklen, P_COMMAND);
-		  pop_delimiter (dstack);
-		}
-	      else
-		ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
-	      if (ttok == &matched_pair_error)
-		return -1;		/* Bail immediately. */
-	      RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 3,
-				      token_buffer_size,
-				      TOKEN_DEFAULT_GROW_SIZE);
-	      token[token_index++] = character;
-	      token[token_index++] = peek_char;
-	      strcpy (token + token_index, ttok);
-	      token_index += ttoklen;
-	      FREE (ttok);
-	      dollar_present = 1;
-	      all_digit_token = 0;
-	      goto next_character;
-	    }
-	  /* This handles $'...' and $"..." new-style quoted strings. */
-#if defined (TRANSLATABLE_STRINGS)
-	  else if MBTEST(character == '$' && (peek_char == '\'' || peek_char == '"'))
-#else
-	  else if MBTEST(character == '$' && peek_char == '\'')
-#endif
-	    {
-	      int first_line;
-
-	      first_line = line_number;
-	      push_delimiter (dstack, peek_char);
-	      ttok = parse_matched_pair (peek_char, peek_char, peek_char,
-					 &ttoklen,
-					 (peek_char == '\'') ? P_ALLOWESC : 0);
-	      pop_delimiter (dstack);
-	      if (ttok == &matched_pair_error)
-		return -1;
-	      if (peek_char == '\'')
-		{
-		  /* PST_NOEXPAND */
-		  ttrans = ansiexpand (ttok, 0, ttoklen - 1, &ttranslen);
-		  free (ttok);
-
-		  /* Insert the single quotes and correctly quote any
-		     embedded single quotes (allowed because P_ALLOWESC was
-		     passed to parse_matched_pair). */
-		  ttok = sh_single_quote (ttrans);
-		  free (ttrans);
-		  ttranslen = strlen (ttok);
-		  ttrans = ttok;
-		}
-#if defined (TRANSLATABLE_STRINGS)
-	      else
-		{
-		  /* PST_NOEXPAND */
-		  /* Try to locale-expand the converted string. */
-		  ttrans = locale_expand (ttok, 0, ttoklen - 1, first_line, &ttranslen);
-		  free (ttok);
-
-		  /* Add the double quotes back (or single quotes if the user
-		     has set that option). */
-		  if (singlequote_translations &&
-		        ((ttoklen - 1) != ttranslen || STREQN (ttok, ttrans, ttranslen) == 0))
-		    ttok = sh_single_quote (ttrans);
-		  else
-		    ttok = sh_mkdoublequoted (ttrans, ttranslen, 0);
-
-		  free (ttrans);
-		  ttrans = ttok;
-		  ttranslen = strlen (ttrans);
-		}
-#endif /* TRANSLATABLE_STRINGS */
-
-	      RESIZE_MALLOCED_BUFFER (token, token_index, ttranslen + 1,
-				      token_buffer_size,
-				      TOKEN_DEFAULT_GROW_SIZE);
-	      strcpy (token + token_index, ttrans);
-	      token_index += ttranslen;
-	      FREE (ttrans);
-	      quoted = 1;
-	      all_digit_token = 0;
-	      goto next_character;
-	    }
-	  /* This could eventually be extended to recognize all of the
-	     shell's single-character parameter expansions, and set flags.*/
-	  else if MBTEST(character == '$' && peek_char == '$')
-	    {
-	      RESIZE_MALLOCED_BUFFER (token, token_index, 3,
-				      token_buffer_size,
-				      TOKEN_DEFAULT_GROW_SIZE);
-	      token[token_index++] = '$';
-	      token[token_index++] = peek_char;
-	      dollar_present = 1;
-	      all_digit_token = 0;
-	      goto next_character;
-	    }
-	  else
-	    shell_ungetc (peek_char);
-	}
-
-#if defined (ARRAY_VARS)
-      /* Identify possible array subscript assignment; match [...].  If
-	 parser_state&PST_COMPASSIGN, we need to parse [sub]=words treating
-	 `sub' as if it were enclosed in double quotes. */
-      else if MBTEST(character == '[' &&		/* ] */
-		     ((token_index > 0 && assignment_acceptable (last_read_token) && token_is_ident (token, token_index)) ||
-		      (token_index == 0 && (parser_state&PST_COMPASSIGN))))
-        {
-	  ttok = parse_matched_pair (cd, '[', ']', &ttoklen, P_ARRAYSUB);
-	  if (ttok == &matched_pair_error)
-	    return -1;		/* Bail immediately. */
-	  RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
-				  token_buffer_size,
-				  TOKEN_DEFAULT_GROW_SIZE);
-	  token[token_index++] = character;
-	  strcpy (token + token_index, ttok);
-	  token_index += ttoklen;
-	  FREE (ttok);
-	  all_digit_token = 0;
-	  goto next_character;
-        }
-      /* Identify possible compound array variable assignment. */
-      else if MBTEST(character == '=' && token_index > 0 && (assignment_acceptable (last_read_token) || (parser_state & PST_ASSIGNOK)) && token_is_assignment (token, token_index))
-	{
-	  peek_char = shell_getc (1);
-	  if MBTEST(peek_char == '(')		/* ) */
-	    {
-	      ttok = parse_compound_assignment (&ttoklen);
-
-	      RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 4,
-				      token_buffer_size,
-				      TOKEN_DEFAULT_GROW_SIZE);
-
-	      token[token_index++] = '=';
-	      token[token_index++] = '(';
-	      if (ttok)
-		{
-		  strcpy (token + token_index, ttok);
-		  token_index += ttoklen;
-		}
-	      token[token_index++] = ')';
-	      FREE (ttok);
-	      all_digit_token = 0;
-	      compound_assignment = 1;
-#if 1
-	      goto next_character;
-#else
-	      goto got_token;		/* ksh93 seems to do this */
-#endif
-	    }
-	  else
-	    shell_ungetc (peek_char);
-	}
-#endif
-
-      /* When not parsing a multi-character word construct, shell meta-
-	 characters break words. */
-      if MBTEST(shellbreak (character))
-	{
-	  shell_ungetc (character);
-	  goto got_token;
-	}
-
-got_character:
-      if MBTEST(character == CTLESC || character == CTLNUL)
-	{
-	  RESIZE_MALLOCED_BUFFER (token, token_index, 2, token_buffer_size,
-				  TOKEN_DEFAULT_GROW_SIZE);
-	  token[token_index++] = CTLESC;
-	}
-      else
-got_escaped_character:
-	RESIZE_MALLOCED_BUFFER (token, token_index, 1, token_buffer_size,
-				TOKEN_DEFAULT_GROW_SIZE);
-
-      token[token_index++] = character;
-
-      all_digit_token &= DIGIT (character);
-      dollar_present |= character == '$';
-
-    next_character:
-      if (character == '\n' && SHOULD_PROMPT ())
-	prompt_again (0);
-
-      /* We want to remove quoted newlines (that is, a \<newline> pair)
-	 unless we are within single quotes or pass_next_character is
-	 set (the shell equivalent of literal-next). */
-      cd = current_delimiter (dstack);
-      character = shell_getc (cd != '\'' && pass_next_character == 0);
-    }	/* end for (;;) */
-
-got_token:
-
-  /* Calls to RESIZE_MALLOCED_BUFFER ensure there is sufficient room. */
-  token[token_index] = '\0';
-
-  /* Check to see what thing we should return.  If the last_read_token
-     is a `<', or a `&', or the character which ended this token is
-     a '>' or '<', then, and ONLY then, is this input token a NUMBER.
-     Otherwise, it is just a word, and should be returned as such. */
-  if MBTEST(all_digit_token && (character == '<' || character == '>' ||
-		    last_read_token == LESS_AND ||
-		    last_read_token == GREATER_AND))
-      {
-	if (legal_number (token, &lvalue) && (int)lvalue == lvalue)
-	  {
-	    yylval.number = lvalue;
-	    return (NUMBER);
-	  }
-      }
-
-  /* Check for special case tokens. */
-  result = (last_shell_getc_is_singlebyte) ? special_case_tokens (token) : -1;
-  if (result >= 0)
-    return result;
-
-#if defined (ALIAS)
-  /* Posix.2 does not allow reserved words to be aliased, so check for all
-     of them, including special cases, before expanding the current token
-     as an alias. */
-  if MBTEST(posixly_correct)
-    CHECK_FOR_RESERVED_WORD (token);
-
-  /* Aliases are expanded iff EXPAND_ALIASES is non-zero, and quoting
-     inhibits alias expansion. */
-  if (expand_aliases && quoted == 0)
-    {
-      result = alias_expand_token (token);
-      if (result == RE_READ_TOKEN)
-	return (RE_READ_TOKEN);
-      else if (result == NO_EXPANSION)
-	parser_state &= ~PST_ALEXPNEXT;
-    }
-
-  /* If not in Posix.2 mode, check for reserved words after alias
-     expansion. */
-  if MBTEST(posixly_correct == 0)
-#endif
-    CHECK_FOR_RESERVED_WORD (token);
-
-  the_word = alloc_word_desc ();
-  the_word->word = (char *)xmalloc (1 + token_index);
-  the_word->flags = 0;
-  strcpy (the_word->word, token);
-  if (dollar_present)
-    the_word->flags |= W_HASDOLLAR;
-  if (quoted)
-    the_word->flags |= W_QUOTED;		/*(*/
-  if (compound_assignment && token[token_index-1] == ')')
-    the_word->flags |= W_COMPASSIGN;
-  /* A word is an assignment if it appears at the beginning of a
-     simple command, or after another assignment word.  This is
-     context-dependent, so it cannot be handled in the grammar. */
-  if (assignment (token, (parser_state & PST_COMPASSIGN) != 0))
-    {
-      the_word->flags |= W_ASSIGNMENT;
-      /* Don't perform word splitting on assignment statements. */
-      if (assignment_acceptable (last_read_token) || (parser_state & PST_COMPASSIGN) != 0)
-	{
-	  the_word->flags |= W_NOSPLIT;
-	  if (parser_state & PST_COMPASSIGN)
-	    the_word->flags |= W_NOGLOB;	/* XXX - W_NOBRACE? */
-	}
-    }
-
-  if (command_token_position (last_read_token))
-    {
-      struct builtin *b;
-      b = builtin_address_internal (token, 0);
-      if (b && (b->flags & ASSIGNMENT_BUILTIN))
-	parser_state |= PST_ASSIGNOK;
-      else if (STREQ (token, "eval") || STREQ (token, "let"))
-	parser_state |= PST_ASSIGNOK;
-    }
-
-  yylval.word = the_word;
-
-  /* should we check that quoted == 0 as well? */
-  if MBTEST(token[0] == '{' && token[token_index-1] == '}' &&
-      (character == '<' || character == '>'))
-    {
-      /* can use token; already copied to the_word */
-      token[token_index-1] = '\0';
-#if defined (ARRAY_VARS)
-      if (legal_identifier (token+1) || valid_array_reference (token+1, 0))
-#else
-      if (legal_identifier (token+1))
-#endif
-	{
-	  strcpy (the_word->word, token+1);
-/* itrace("read_token_word: returning REDIR_WORD for %s", the_word->word); */
-	  yylval.word = the_word;	/* accommodate recursive call */
-	  return (REDIR_WORD);
-	}
-      else
-        /* valid_array_reference can call the parser recursively; need to
-	   make sure that yylval.word doesn't change if we are going to
-	   return WORD or ASSIGNMENT_WORD */
-        yylval.word = the_word;
-    }
-
-  result = ((the_word->flags & (W_ASSIGNMENT|W_NOSPLIT)) == (W_ASSIGNMENT|W_NOSPLIT))
-		? ASSIGNMENT_WORD : WORD;
-
-  switch (last_read_token)
-    {
-    case FUNCTION:
-      parser_state |= PST_ALLOWOPNBRC;
-      function_dstart = line_number;
-      break;
-    case CASE:
-    case SELECT:
-    case FOR:
-      if (word_top < MAX_CASE_NEST)
-	word_top++;
-      word_lineno[word_top] = line_number;
-      expecting_in_token++;
-      break;
-    }
-
-  return (result);
-}
-
-/* Return 1 if TOKSYM is a token that after being read would allow
-   a reserved word to be seen, else 0. */
-static int
-reserved_word_acceptable (toksym)
-     int toksym;
-{
-  switch (toksym)
-    {
-    case '\n':
-    case ';':
-    case '(':
-    case ')':
-    case '|':
-    case '&':
-    case '{':
-    case '}':		/* XXX */
-    case AND_AND:
-    case ARITH_CMD:
-    case BANG:
-    case BAR_AND:
-    case COND_END:
-    case DO:
-    case DONE:
-    case ELIF:
-    case ELSE:
-    case ESAC:
-    case FI:
-    case IF:
-    case OR_OR:
-    case SEMI_SEMI:
-    case SEMI_AND:
-    case SEMI_SEMI_AND:
-    case THEN:
-    case TIME:
-    case TIMEOPT:
-    case TIMEIGN:
-    case COPROC:
-    case UNTIL:
-    case WHILE:
-    case 0:
-    case DOLPAREN:
-      return 1;
-    default:
-#if defined (COPROCESS_SUPPORT)
-      if (last_read_token == WORD && token_before_that == COPROC)
-	return 1;
-#endif
-      if (last_read_token == WORD && token_before_that == FUNCTION)
-	return 1;
-      return 0;
-    }
-}
-    
-/* Return the index of TOKEN in the alist of reserved words, or -1 if
-   TOKEN is not a shell reserved word. */
-int
-find_reserved_word (tokstr)
-     char *tokstr;
-{
-  int i;
-  for (i = 0; word_token_alist[i].word; i++)
-    if (STREQ (tokstr, word_token_alist[i].word))
-      return i;
-  return -1;
-}
-
-/* An interface to let the rest of the shell (primarily the completion
-   system) know what the parser is expecting. */
-int
-parser_in_command_position ()
-{
-  return (command_token_position (last_read_token));
-}
-
-#if 0
-#if defined (READLINE)
-/* Called after each time readline is called.  This insures that whatever
-   the new prompt string is gets propagated to readline's local prompt
-   variable. */
-static void
-reset_readline_prompt ()
-{
-  char *temp_prompt;
-
-  if (prompt_string_pointer)
-    {
-      temp_prompt = (*prompt_string_pointer)
-			? decode_prompt_string (*prompt_string_pointer)
-			: (char *)NULL;
-
-      if (temp_prompt == 0)
-	{
-	  temp_prompt = (char *)xmalloc (1);
-	  temp_prompt[0] = '\0';
-	}
-
-      FREE (current_readline_prompt);
-      current_readline_prompt = temp_prompt;
-    }
-}
-#endif /* READLINE */
-#endif /* 0 */
-
-#if defined (HISTORY)
-/* A list of tokens which can be followed by newlines, but not by
-   semi-colons.  When concatenating multiple lines of history, the
-   newline separator for such tokens is replaced with a space. */
-static const int no_semi_successors[] = {
-  '\n', '{', '(', ')', ';', '&', '|',
-  CASE, DO, ELSE, IF, SEMI_SEMI, SEMI_AND, SEMI_SEMI_AND, THEN, UNTIL,
-  WHILE, AND_AND, OR_OR, IN,
-  0
-};
-
-/* If we are not within a delimited expression, try to be smart
-   about which separators can be semi-colons and which must be
-   newlines.  Returns the string that should be added into the
-   history entry.  LINE is the line we're about to add; it helps
-   make some more intelligent decisions in certain cases. */
-char *
-history_delimiting_chars (line)
-     const char *line;
-{
-  static int last_was_heredoc = 0;	/* was the last entry the start of a here document? */
-  register int i;
-
-  if ((parser_state & PST_HEREDOC) == 0)
-    last_was_heredoc = 0;
-
-  if (dstack.delimiter_depth != 0)
-    return ("\n");
-
-  /* We look for current_command_line_count == 2 because we are looking to
-     add the first line of the body of the here document (the second line
-     of the command).  We also keep LAST_WAS_HEREDOC as a private sentinel
-     variable to note when we think we added the first line of a here doc
-     (the one with a "<<" somewhere in it) */
-  if (parser_state & PST_HEREDOC)
-    {
-      if (last_was_heredoc)
-	{
-	  last_was_heredoc = 0;
-	  return "\n";
-	}
-      return (here_doc_first_line ? "\n" : "");
-    }
-
-  if (parser_state & PST_COMPASSIGN)
-    return (" ");
-
-  /* First, handle some special cases. */
-  /*(*/
-  /* If we just read `()', assume it's a function definition, and don't
-     add a semicolon.  If the token before the `)' was not `(', and we're
-     not in the midst of parsing a case statement, assume it's a
-     parenthesized command and add the semicolon. */
-  /*)(*/
-  if (token_before_that == ')')
-    {
-      if (two_tokens_ago == '(')	/*)*/	/* function def */
-	return " ";
-      /* This does not work for subshells inside case statement
-	 command lists.  It's a suboptimal solution. */
-      else if (parser_state & PST_CASESTMT)	/* case statement pattern */
-	return " ";
-      else
-	return "; ";				/* (...) subshell */
-    }
-  else if (token_before_that == WORD && two_tokens_ago == FUNCTION)
-    return " ";		/* function def using `function name' without `()' */
-
-  /* If we're not in a here document, but we think we're about to parse one,
-     and we would otherwise return a `;', return a newline to delimit the
-     line with the here-doc delimiter */
-  else if ((parser_state & PST_HEREDOC) == 0 && current_command_line_count > 1 && last_read_token == '\n' && strstr (line, "<<"))
-    {
-      last_was_heredoc = 1;
-      return "\n";
-    }
-  else if ((parser_state & PST_HEREDOC) == 0 && current_command_line_count > 1 && need_here_doc > 0)
-    return "\n";
-  else if (token_before_that == WORD && two_tokens_ago == FOR)
-    {
-      /* Tricky.  `for i\nin ...' should not have a semicolon, but
-	 `for i\ndo ...' should.  We do what we can. */
-      for (i = shell_input_line_index; whitespace (shell_input_line[i]); i++)
-	;
-      if (shell_input_line[i] && shell_input_line[i] == 'i' && shell_input_line[i+1] == 'n')
-	return " ";
-      return ";";
-    }
-  else if (two_tokens_ago == CASE && token_before_that == WORD && (parser_state & PST_CASESTMT))
-    return " ";
-
-  for (i = 0; no_semi_successors[i]; i++)
-    {
-      if (token_before_that == no_semi_successors[i])
-	return (" ");
-    }
-
-  /* Assume that by this point we are reading lines in a multi-line command.
-     If we have multiple consecutive blank lines we want to return only one
-     semicolon. */
-  if (line_isblank (line))
-    return (current_command_line_count > 1 && last_read_token == '\n' && token_before_that != '\n') ? "; " : "";
-
-  return ("; ");
-}
-#endif /* HISTORY */
-
-/* Issue a prompt, or prepare to issue a prompt when the next character
-   is read. */
-static void
-prompt_again (force)
-     int force;
-{
-  char *temp_prompt;
-
-  if (interactive == 0 || expanding_alias ())	/* XXX */
-    return;
-
-  ps1_prompt = get_string_value ("PS1");
-  ps2_prompt = get_string_value ("PS2");
-
-  ps0_prompt = get_string_value ("PS0");
-
-  if (!prompt_string_pointer)
-    prompt_string_pointer = &ps1_prompt;
-
-  temp_prompt = *prompt_string_pointer
-			? decode_prompt_string (*prompt_string_pointer)
-			: (char *)NULL;
-
-  if (temp_prompt == 0)
-    {
-      temp_prompt = (char *)xmalloc (1);
-      temp_prompt[0] = '\0';
-    }
-
-  current_prompt_string = *prompt_string_pointer;
-  prompt_string_pointer = &ps2_prompt;
-
-#if defined (READLINE)
-  if (!no_line_editing)
-    {
-      FREE (current_readline_prompt);
-      current_readline_prompt = temp_prompt;
-    }
-  else
-#endif	/* READLINE */
-    {
-      FREE (current_decoded_prompt);
-      current_decoded_prompt = temp_prompt;
-    }
-}
-
-int
-get_current_prompt_level ()
-{
-  return ((current_prompt_string && current_prompt_string == ps2_prompt) ? 2 : 1);
-}
-
-void
-set_current_prompt_level (x)
-     int x;
-{
-  prompt_string_pointer = (x == 2) ? &ps2_prompt : &ps1_prompt;
-  current_prompt_string = *prompt_string_pointer;
-}
-      
-static void
-print_prompt ()
-{
-  fprintf (stderr, "%s", current_decoded_prompt);
-  fflush (stderr);
-}
-
-#if defined (HISTORY)
-  /* The history library increments the history offset as soon as it stores
-     the first line of a potentially multi-line command, so we compensate
-     here by returning one fewer when appropriate. */
-static int
-prompt_history_number (pmt)
-     char *pmt;
-{
-  int ret;
-
-  ret = history_number ();
-  if (ret == 1)
-    return ret;
-
-  if (pmt == ps1_prompt)	/* are we expanding $PS1? */
-    return ret;
-  else if (pmt == ps2_prompt && command_oriented_history == 0)
-    return ret;			/* not command oriented history */
-  else if (pmt == ps2_prompt && command_oriented_history && current_command_first_line_saved)
-    return ret - 1;
-  else
-    return ret - 1;		/* PS0, PS4, ${var@P}, PS2 other cases */
-}
-#endif
-
-/* Return a string which will be printed as a prompt.  The string
-   may contain special characters which are decoded as follows:
-
-	\a	bell (ascii 07)
-	\d	the date in Day Mon Date format
-	\e	escape (ascii 033)
-	\h	the hostname up to the first `.'
-	\H	the hostname
-	\j	the number of active jobs
-	\l	the basename of the shell's tty device name
-	\n	CRLF
-	\r	CR
-	\s	the name of the shell
-	\t	the time in 24-hour hh:mm:ss format
-	\T	the time in 12-hour hh:mm:ss format
-	\@	the time in 12-hour hh:mm am/pm format
-	\A	the time in 24-hour hh:mm format
-	\D{fmt}	the result of passing FMT to strftime(3)
-	\u	your username
-	\v	the version of bash (e.g., 2.00)
-	\V	the release of bash, version + patchlevel (e.g., 2.00.0)
-	\w	the current working directory
-	\W	the last element of $PWD
-	\!	the history number of this command
-	\#	the command number of this command
-	\$	a $ or a # if you are root
-	\nnn	character code nnn in octal
-	\\	a backslash
-	\[	begin a sequence of non-printing chars
-	\]	end a sequence of non-printing chars
-*/
-#define PROMPT_GROWTH 48
-char *
-decode_prompt_string (string)
-     char *string;
-{
-  WORD_LIST *list;
-  char *result, *t, *orig_string;
-  struct dstack save_dstack;
-  int last_exit_value, last_comsub_pid;
-#if defined (PROMPT_STRING_DECODE)
-  size_t result_size;
-  size_t result_index;
-  int c, n, i;
-  char *temp, *t_host, octal_string[4];
-  struct tm *tm;  
-  time_t the_time;
-  char timebuf[128];
-  char *timefmt;
-
-  result = (char *)xmalloc (result_size = PROMPT_GROWTH);
-  result[result_index = 0] = 0;
-  temp = (char *)NULL;
-  orig_string = string;
-
-  while (c = *string++)
-    {
-      if (posixly_correct && c == '!')
-	{
-	  if (*string == '!')
-	    {
-	      temp = savestring ("!");
-	      goto add_string;
-	    }
-	  else
-	    {
-#if !defined (HISTORY)
-		temp = savestring ("1");
-#else /* HISTORY */
-		temp = itos (prompt_history_number (orig_string));
-#endif /* HISTORY */
-		string--;	/* add_string increments string again. */
-		goto add_string;
-	    }
-	}
-      if (c == '\\')
-	{
-	  c = *string;
-
-	  switch (c)
-	    {
-	    case '0':
-	    case '1':
-	    case '2':
-	    case '3':
-	    case '4':
-	    case '5':
-	    case '6':
-	    case '7':
-	      strncpy (octal_string, string, 3);
-	      octal_string[3] = '\0';
-
-	      n = read_octal (octal_string);
-	      temp = (char *)xmalloc (3);
-
-	      if (n == CTLESC || n == CTLNUL)
-		{
-		  temp[0] = CTLESC;
-		  temp[1] = n;
-		  temp[2] = '\0';
-		}
-	      else if (n == -1)
-		{
-		  temp[0] = '\\';
-		  temp[1] = '\0';
-		}
-	      else
-		{
-		  temp[0] = n;
-		  temp[1] = '\0';
-		}
-
-	      for (c = 0; n != -1 && c < 3 && ISOCTAL (*string); c++)
-		string++;
-
-	      c = 0;		/* tested at add_string: */
-	      goto add_string;
-
-	    case 'd':
-	    case 't':
-	    case 'T':
-	    case '@':
-	    case 'A':
-	      /* Make the current time/date into a string. */
-	      (void) time (&the_time);
-#if defined (HAVE_TZSET)
-	      sv_tz ("TZ");		/* XXX -- just make sure */
-#endif
-	      tm = localtime (&the_time);
-
-	      if (c == 'd')
-		n = strftime (timebuf, sizeof (timebuf), "%a %b %d", tm);
-	      else if (c == 't')
-		n = strftime (timebuf, sizeof (timebuf), "%H:%M:%S", tm);
-	      else if (c == 'T')
-		n = strftime (timebuf, sizeof (timebuf), "%I:%M:%S", tm);
-	      else if (c == '@')
-		n = strftime (timebuf, sizeof (timebuf), "%I:%M %p", tm);
-	      else if (c == 'A')
-		n = strftime (timebuf, sizeof (timebuf), "%H:%M", tm);
-
-	      if (n == 0)
-		timebuf[0] = '\0';
-	      else
-		timebuf[sizeof(timebuf) - 1] = '\0';
-
-	      temp = savestring (timebuf);
-	      goto add_string;
-
-	    case 'D':		/* strftime format */
-	      if (string[1] != '{')		/* } */
-		goto not_escape;
-
-	      (void) time (&the_time);
-	      tm = localtime (&the_time);
-	      string += 2;			/* skip { */
-	      timefmt = xmalloc (strlen (string) + 3);
-	      for (t = timefmt; *string && *string != '}'; )
-		*t++ = *string++;
-	      *t = '\0';
-	      c = *string;	/* tested at add_string */
-	      if (timefmt[0] == '\0')
-		{
-		  timefmt[0] = '%';
-		  timefmt[1] = 'X';	/* locale-specific current time */
-		  timefmt[2] = '\0';
-		}
-	      n = strftime (timebuf, sizeof (timebuf), timefmt, tm);
-	      free (timefmt);
-
-	      if (n == 0)
-		timebuf[0] = '\0';
-	      else
-		timebuf[sizeof(timebuf) - 1] = '\0';
-
-	      if (promptvars || posixly_correct)
-		/* Make sure that expand_prompt_string is called with a
-		   second argument of Q_DOUBLE_QUOTES if we use this
-		   function here. */
-		temp = sh_backslash_quote_for_double_quotes (timebuf, 0);
-	      else
-		temp = savestring (timebuf);
-	      goto add_string;
-	      
-	    case 'n':
-	      temp = (char *)xmalloc (3);
-	      temp[0] = no_line_editing ? '\n' : '\r';
-	      temp[1] = no_line_editing ? '\0' : '\n';
-	      temp[2] = '\0';
-	      goto add_string;
-
-	    case 's':
-	      temp = base_pathname (shell_name);
-	      /* Try to quote anything the user can set in the file system */
-	      if (promptvars || posixly_correct)
-		{
-		  char *t;
-		  t = sh_strvis (temp);
-		  temp = sh_backslash_quote_for_double_quotes (t, 0);
-		  free (t);
-		}
-	      else
-		temp = sh_strvis (temp);
-	      goto add_string;
-
-	    case 'v':
-	    case 'V':
-	      temp = (char *)xmalloc (16);
-	      if (c == 'v')
-		strcpy (temp, dist_version);
-	      else
-		sprintf (temp, "%s.%d", dist_version, patch_level);
-	      goto add_string;
-
-	    case 'w':
-	    case 'W':
-	      {
-		/* Use the value of PWD because it is much more efficient. */
-		char t_string[PATH_MAX];
-		int tlen;
-
-		temp = get_string_value ("PWD");
-
-		if (temp == 0)
-		  {
-		    if (getcwd (t_string, sizeof(t_string)) == 0)
-		      {
-			t_string[0] = '.';
-			tlen = 1;
-		      }
-		    else
-		      tlen = strlen (t_string);
-		  }
-		else
-		  {
-		    tlen = sizeof (t_string) - 1;
-		    strncpy (t_string, temp, tlen);
-		  }
-		t_string[tlen] = '\0';
-
-#if defined (MACOSX)
-		/* Convert from "fs" format to "input" format */
-		temp = fnx_fromfs (t_string, strlen (t_string));
-		if (temp != t_string)
-		  strcpy (t_string, temp);
-#endif
-
-#define ROOT_PATH(x)	((x)[0] == '/' && (x)[1] == 0)
-#define DOUBLE_SLASH_ROOT(x)	((x)[0] == '/' && (x)[1] == '/' && (x)[2] == 0)
-		/* Abbreviate \W as ~ if $PWD == $HOME */
-		if (c == 'W' && (((t = get_string_value ("HOME")) == 0) || STREQ (t, t_string) == 0))
-		  {
-		    if (ROOT_PATH (t_string) == 0 && DOUBLE_SLASH_ROOT (t_string) == 0)
-		      {
-			t = strrchr (t_string, '/');
-			if (t)
-			  memmove (t_string, t + 1, strlen (t));	/* strlen(t) to copy NULL */
-		      }
-		  }
-#undef ROOT_PATH
-#undef DOUBLE_SLASH_ROOT
-		else
-		  {
-		    /* polite_directory_format is guaranteed to return a string
-		       no longer than PATH_MAX - 1 characters. */
-		    temp = polite_directory_format (t_string);
-		    if (temp != t_string)
-		      strcpy (t_string, temp);
-		  }
-
-		temp = trim_pathname (t_string, PATH_MAX - 1);
-		/* If we're going to be expanding the prompt string later,
-		   quote the directory name. */
-		if (promptvars || posixly_correct)
-		  /* Make sure that expand_prompt_string is called with a
-		     second argument of Q_DOUBLE_QUOTES if we use this
-		     function here. */
-		  {
-		    char *t;
-		    t = sh_strvis (t_string);
-		    temp = sh_backslash_quote_for_double_quotes (t, 0);
-		    free (t);
-		  }
-		else
-		  temp = sh_strvis (t_string);
-
-		goto add_string;
-	      }
-
-	    case 'u':
-	      if (current_user.user_name == 0)
-		get_current_user_info ();
-	      temp = savestring (current_user.user_name);
-	      goto add_string;
-
-	    case 'h':
-	    case 'H':
-	      t_host = savestring (current_host_name);
-	      if (c == 'h' && (t = (char *)strchr (t_host, '.')))
-		*t = '\0';
-	      if (promptvars || posixly_correct)
-		/* Make sure that expand_prompt_string is called with a
-		   second argument of Q_DOUBLE_QUOTES if we use this
-		   function here. */
-		temp = sh_backslash_quote_for_double_quotes (t_host, 0);
-	      else
-		temp = savestring (t_host);
-	      free (t_host);
-	      goto add_string;
-
-	    case '#':
-	      n = current_command_number;
-	      /* If we have already incremented current_command_number (PS4,
-		 ${var@P}), compensate */
-	      if (orig_string != ps0_prompt && orig_string != ps1_prompt && orig_string != ps2_prompt)
-		n--;
-	      temp = itos (n);
-	      goto add_string;
-
-	    case '!':
-#if !defined (HISTORY)
-	      temp = savestring ("1");
-#else /* HISTORY */
-	      temp = itos (prompt_history_number (orig_string));
-#endif /* HISTORY */
-	      goto add_string;
-
-	    case '$':
-	      t = temp = (char *)xmalloc (3);
-	      if ((promptvars || posixly_correct) && (current_user.euid != 0))
-		*t++ = '\\';
-	      *t++ = current_user.euid == 0 ? '#' : '$';
-	      *t = '\0';
-	      goto add_string;
-
-	    case 'j':
-	      temp = itos (count_all_jobs ());
-	      goto add_string;
-
-	    case 'l':
-#if defined (HAVE_TTYNAME)
-	      temp = (char *)ttyname (fileno (stdin));
-	      t = temp ? base_pathname (temp) : "tty";
-	      temp = savestring (t);
-#else
-	      temp = savestring ("tty");
-#endif /* !HAVE_TTYNAME */
-	      goto add_string;
-
-#if defined (READLINE)
-	    case '[':
-	    case ']':
-	      if (no_line_editing)
-		{
-		  string++;
-		  break;
-		}
-	      temp = (char *)xmalloc (3);
-	      n = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
-	      i = 0;
-	      if (n == CTLESC || n == CTLNUL)
-		temp[i++] = CTLESC;
-	      temp[i++] = n;
-	      temp[i] = '\0';
-	      goto add_string;
-#endif /* READLINE */
-
-	    case '\\':
-	    case 'a':
-	    case 'e':
-	    case 'r':
-	      temp = (char *)xmalloc (2);
-	      if (c == 'a')
-		temp[0] = '\07';
-	      else if (c == 'e')
-		temp[0] = '\033';
-	      else if (c == 'r')
-		temp[0] = '\r';
-	      else			/* (c == '\\') */
-	        temp[0] = c;
-	      temp[1] = '\0';
-	      goto add_string;
-
-	    default:
-not_escape:
-	      temp = (char *)xmalloc (3);
-	      temp[0] = '\\';
-	      temp[1] = c;
-	      temp[2] = '\0';
-
-	    add_string:
-	      if (c)
-		string++;
-	      result =
-		sub_append_string (temp, result, &result_index, &result_size);
-	      temp = (char *)NULL; /* Freed in sub_append_string (). */
-	      result[result_index] = '\0';
-	      break;
-	    }
-	}
-      else
-	{
-	  RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, PROMPT_GROWTH);
-	  /* dequote_string should take care of removing this if we are not
-	     performing the rest of the word expansions. */
-	  if (c == CTLESC || c == CTLNUL)
-	    result[result_index++] = CTLESC;
-	  result[result_index++] = c;
-	  result[result_index] = '\0';
-	}
-    }
-#else /* !PROMPT_STRING_DECODE */
-  result = savestring (string);
-#endif /* !PROMPT_STRING_DECODE */
-
-  /* Save the delimiter stack and point `dstack' to temp space so any
-     command substitutions in the prompt string won't result in screwing
-     up the parser's quoting state. */
-  save_dstack = dstack;
-  dstack = temp_dstack;
-  dstack.delimiter_depth = 0;
-
-  /* Perform variable and parameter expansion and command substitution on
-     the prompt string. */
-  if (promptvars || posixly_correct)
-    {
-      last_exit_value = last_command_exit_value;
-      last_comsub_pid = last_command_subst_pid;
-      list = expand_prompt_string (result, Q_DOUBLE_QUOTES, 0);
-      free (result);
-      result = string_list (list);
-      dispose_words (list);
-      last_command_exit_value = last_exit_value;
-      last_command_subst_pid = last_comsub_pid;
-    }
-  else
-    {
-      t = dequote_string (result);
-      free (result);
-      result = t;
-    }
-
-  dstack = save_dstack;
-
-  return (result);
-}
-
-/************************************************
- *						*
- *		ERROR HANDLING			*
- *						*
- ************************************************/
-
-/* Report a syntax error, and restart the parser.  Call here for fatal
-   errors. */
-int
-yyerror (msg)
-     const char *msg;
-{
-  if ((parser_state & PST_NOERROR) == 0)
-    report_syntax_error ((char *)NULL);
-  reset_parser ();
-  return (0);
-}
-
-static char *
-error_token_from_token (tok)
-     int tok;
-{
-  char *t;
-
-  if (t = find_token_in_alist (tok, word_token_alist, 0))
-    return t;
-
-  if (t = find_token_in_alist (tok, other_token_alist, 0))
-    return t;
-
-  t = (char *)NULL;
-  /* This stuff is dicy and needs closer inspection */
-  switch (current_token)
-    {
-    case WORD:
-    case ASSIGNMENT_WORD:
-      if (yylval.word)
-	t = savestring (yylval.word->word);
-      break;
-    case NUMBER:
-      t = itos (yylval.number);
-      break;
-    case ARITH_CMD:
-      if (yylval.word_list)
-        t = string_list (yylval.word_list);
-      break;
-    case ARITH_FOR_EXPRS:
-      if (yylval.word_list)
-	t = string_list_internal (yylval.word_list, " ; ");
-      break;
-    case COND_CMD:
-      t = (char *)NULL;		/* punt */
-      break;
-    }
-
-  return t;
-}
-
-static char *
-error_token_from_text ()
-{
-  char *msg, *t;
-  int token_end, i;
-
-  t = shell_input_line;
-  i = shell_input_line_index;
-  token_end = 0;
-  msg = (char *)NULL;
-
-  if (i && t[i] == '\0')
-    i--;
-
-  while (i && (whitespace (t[i]) || t[i] == '\n'))
-    i--;
-
-  if (i)
-    token_end = i + 1;
-
-  while (i && (member (t[i], " \n\t;|&") == 0))
-    i--;
-
-  while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
-    i++;
-
-  /* Return our idea of the offending token. */
-  if (token_end || (i == 0 && token_end == 0))
-    {
-      if (token_end)
-	msg = substring (t, i, token_end);
-      else	/* one-character token */
-	{
-	  msg = (char *)xmalloc (2);
-	  msg[0] = t[i];
-	  msg[1] = '\0';
-	}
-    }
-
-  return (msg);
-}
-
-static void
-print_offending_line ()
-{
-  char *msg;
-  int token_end;
-
-  msg = savestring (shell_input_line);
-  token_end = strlen (msg);
-  while (token_end && msg[token_end - 1] == '\n')
-    msg[--token_end] = '\0';
-
-  parser_error (line_number, "`%s'", msg);
-  free (msg);
-}
-
-/* Report a syntax error with line numbers, etc.
-   Call here for recoverable errors.  If you have a message to print,
-   then place it in MESSAGE, otherwise pass NULL and this will figure
-   out an appropriate message for you. */
-static void
-report_syntax_error (message)
-     char *message;
-{
-  char *msg, *p;
-
-  if (message)
-    {
-      parser_error (line_number, "%s", message);
-      if (interactive && EOF_Reached)
-	EOF_Reached = 0;
-      last_command_exit_value = (executing_builtin && parse_and_execute_level) ? EX_BADSYNTAX : EX_BADUSAGE;
-      set_pipestatus_from_exit (last_command_exit_value);
-      return;
-    }
-
-  /* If the line of input we're reading is not null, try to find the
-     objectionable token.  First, try to figure out what token the
-     parser's complaining about by looking at current_token. */
-  if (current_token != 0 && EOF_Reached == 0 && (msg = error_token_from_token (current_token)))
-    {
-      if (ansic_shouldquote (msg))
-	{
-	  p = ansic_quote (msg, 0, NULL);
-	  free (msg);
-	  msg = p;
-	}
-      parser_error (line_number, _("syntax error near unexpected token `%s'"), msg);
-      free (msg);
-
-      if (interactive == 0)
-	print_offending_line ();
-
-      last_command_exit_value = (executing_builtin && parse_and_execute_level) ? EX_BADSYNTAX : EX_BADUSAGE;
-      set_pipestatus_from_exit (last_command_exit_value);
-      return;
-    }
-
-  /* If looking at the current token doesn't prove fruitful, try to find the
-     offending token by analyzing the text of the input line near the current
-     input line index and report what we find. */
-  if (shell_input_line && *shell_input_line)
-    {
-      msg = error_token_from_text ();
-      if (msg)
-	{
-	  parser_error (line_number, _("syntax error near `%s'"), msg);
-	  free (msg);
-	}
-
-      /* If not interactive, print the line containing the error. */
-      if (interactive == 0)
-        print_offending_line ();
-    }
-  else
-    {
-      if (EOF_Reached && shell_eof_token && current_token != shell_eof_token)
-	parser_error (line_number, _("unexpected EOF while looking for matching `%c'"), shell_eof_token);
-      else
-	{
-	  msg = EOF_Reached ? _("syntax error: unexpected end of file") : _("syntax error");
-	  parser_error (line_number, "%s", msg);
-	}
-
-      /* When the shell is interactive, this file uses EOF_Reached
-	 only for error reporting.  Other mechanisms are used to
-	 decide whether or not to exit. */
-      if (interactive && EOF_Reached)
-	EOF_Reached = 0;
-    }
-
-  last_command_exit_value = (executing_builtin && parse_and_execute_level) ? EX_BADSYNTAX : EX_BADUSAGE;
-  set_pipestatus_from_exit (last_command_exit_value);
-}
-
-/* ??? Needed function. ??? We have to be able to discard the constructs
-   created during parsing.  In the case of error, we want to return
-   allocated objects to the memory pool.  In the case of no error, we want
-   to throw away the information about where the allocated objects live.
-   (dispose_command () will actually free the command.) */
-static void
-discard_parser_constructs (error_p)
-     int error_p;
-{
-}
-
-/************************************************
- *						*
- *		EOF HANDLING			*
- *						*
- ************************************************/
-
-/* Do that silly `type "bye" to exit' stuff.  You know, "ignoreeof". */
-
-/* A flag denoting whether or not ignoreeof is set. */
-int ignoreeof = 0;
-
-/* The number of times that we have encountered an EOF character without
-   another character intervening.  When this gets above the limit, the
-   shell terminates. */
-int eof_encountered = 0;
-
-/* The limit for eof_encountered. */
-int eof_encountered_limit = 10;
-
-/* If we have EOF as the only input unit, this user wants to leave
-   the shell.  If the shell is not interactive, then just leave.
-   Otherwise, if ignoreeof is set, and we haven't done this the
-   required number of times in a row, print a message. */
-static void
-handle_eof_input_unit ()
-{
-  if (interactive)
-    {
-      /* shell.c may use this to decide whether or not to write out the
-	 history, among other things.  We use it only for error reporting
-	 in this file. */
-      if (EOF_Reached)
-	EOF_Reached = 0;
-
-      /* If the user wants to "ignore" eof, then let her do so, kind of. */
-      if (ignoreeof)
-	{
-	  if (eof_encountered < eof_encountered_limit)
-	    {
-	      fprintf (stderr, _("Use \"%s\" to leave the shell.\n"),
-		       login_shell ? "logout" : "exit");
-	      eof_encountered++;
-	      /* Reset the parsing state. */
-	      last_read_token = current_token = '\n';
-	      /* Reset the prompt string to be $PS1. */
-	      prompt_string_pointer = (char **)NULL;
-	      prompt_again (0);
-	      return;
-	    }
-	}
-
-      /* In this case EOF should exit the shell.  Do it now. */
-      reset_parser ();
-
-      last_shell_builtin = this_shell_builtin;
-      this_shell_builtin = exit_builtin;
-      exit_builtin ((WORD_LIST *)NULL);
-    }
-  else
-    {
-      /* We don't write history files, etc., for non-interactive shells. */
-      EOF_Reached = 1;
-    }
-}
-
-/************************************************
- *						*
- *	STRING PARSING FUNCTIONS		*
- *						*
- ************************************************/
-
-/* It's very important that these two functions treat the characters
-   between ( and ) identically. */
-
-static WORD_LIST parse_string_error;
-
-/* Take a string and run it through the shell parser, returning the
-   resultant word list.  Used by compound array assignment. */
-WORD_LIST *
-parse_string_to_word_list (s, flags, whom)
-     char *s;
-     int flags;
-     const char *whom;
-{
-  WORD_LIST *wl;
-  int tok, orig_current_token, orig_line_number;
-  int orig_parser_state;
-  sh_parser_state_t ps;
-  int ea;
-
-  orig_line_number = line_number;
-  save_parser_state (&ps);
-
-#if defined (HISTORY)
-  bash_history_disable ();
-#endif
-
-  push_stream (1);
-  if (ea = expanding_alias ())
-    parser_save_alias ();
-
-  /* WORD to avoid parsing reserved words as themselves and just parse them as
-     WORDs. */
-  last_read_token = WORD;
-
-  current_command_line_count = 0;
-  echo_input_at_read = expand_aliases = 0;
-
-  with_input_from_string (s, whom);
-  wl = (WORD_LIST *)NULL;
-
-  if (flags & 1)
-    {
-      orig_parser_state = parser_state;		/* XXX - not needed? */
-      /* State flags we don't want to persist into compound assignments. */
-      parser_state &= ~PST_NOEXPAND;	/* parse_comsub sentinel */
-      /* State flags we want to set for this run through the tokenizer. */
-      parser_state |= PST_COMPASSIGN|PST_REPARSE;
-    }
-
-  while ((tok = read_token (READ)) != yacc_EOF)
-    {
-      if (tok == '\n' && *bash_input.location.string == '\0')
-	break;
-      if (tok == '\n')		/* Allow newlines in compound assignments */
-	continue;
-      if (tok != WORD && tok != ASSIGNMENT_WORD)
-	{
-	  line_number = orig_line_number + line_number - 1;
-	  orig_current_token = current_token;
-	  current_token = tok;
-	  yyerror (NULL);	/* does the right thing */
-	  current_token = orig_current_token;
-	  if (wl)
-	    dispose_words (wl);
-	  wl = &parse_string_error;
-	  break;
-	}
-      wl = make_word_list (yylval.word, wl);
-    }
-  
-  last_read_token = '\n';
-  pop_stream ();
-
-  if (ea)
-    parser_restore_alias ();
-
-  restore_parser_state (&ps);
-
-  if (flags & 1)
-    parser_state = orig_parser_state;	/* XXX - not needed? */
-
-  if (wl == &parse_string_error)
-    {
-      set_exit_status (EXECUTION_FAILURE);
-      if (interactive_shell == 0 && posixly_correct)
-	jump_to_top_level (FORCE_EOF);
-      else
-	jump_to_top_level (DISCARD);
-    }
-
-  return (REVERSE_LIST (wl, WORD_LIST *));
-}
-
-static char *
-parse_compound_assignment (retlenp)
-     int *retlenp;
-{
-  WORD_LIST *wl, *rl;
-  int tok, orig_line_number, assignok;
-  sh_parser_state_t ps;
-  char *ret;
-
-  orig_line_number = line_number;
-  save_parser_state (&ps);
-
-  /* WORD to avoid parsing reserved words as themselves and just parse them as
-     WORDs. Plus it means we won't be in a command position and so alias
-     expansion won't happen. */
-  last_read_token = WORD;
-
-  token = (char *)NULL;
-  token_buffer_size = 0;
-  wl = (WORD_LIST *)NULL;	/* ( */
-
-  assignok = parser_state&PST_ASSIGNOK;		/* XXX */
-
-  /* State flags we don't want to persist into compound assignments. */
-  parser_state &= ~(PST_NOEXPAND|PST_CONDCMD|PST_CONDEXPR|PST_REGEXP|PST_EXTPAT);
-  /* State flags we want to set for this run through the tokenizer. */
-  parser_state |= PST_COMPASSIGN;
-
-  esacs_needed_count = expecting_in_token = 0;
-
-  while ((tok = read_token (READ)) != ')')
-    {
-      if (tok == '\n')			/* Allow newlines in compound assignments */
-	{
-	  if (SHOULD_PROMPT ())
-	    prompt_again (0);
-	  continue;
-	}
-      if (tok != WORD && tok != ASSIGNMENT_WORD)
-	{
-	  current_token = tok;	/* for error reporting */
-	  if (tok == yacc_EOF)	/* ( */
-	    parser_error (orig_line_number, _("unexpected EOF while looking for matching `)'"));
-	  else
-	    yyerror(NULL);	/* does the right thing */
-	  if (wl)
-	    dispose_words (wl);
-	  wl = &parse_string_error;
-	  break;
-	}
-      wl = make_word_list (yylval.word, wl);
-    }
-
-  restore_parser_state (&ps);
-
-  if (wl == &parse_string_error)
-    {
-      set_exit_status (EXECUTION_FAILURE);
-      last_read_token = '\n';	/* XXX */
-      if (interactive_shell == 0 && posixly_correct)
-	jump_to_top_level (FORCE_EOF);
-      else
-	jump_to_top_level (DISCARD);
-    }
-
-  if (wl)
-    {
-      rl = REVERSE_LIST (wl, WORD_LIST *);
-      ret = string_list (rl);
-      dispose_words (rl);
-    }
-  else
-    ret = (char *)NULL;
-
-  if (retlenp)
-    *retlenp = (ret && *ret) ? strlen (ret) : 0;
-
-  if (assignok)
-    parser_state |= PST_ASSIGNOK;
-
-  return ret;
-}
-
-/************************************************
- *						*
- *   SAVING AND RESTORING PARTIAL PARSE STATE   *
- *						*
- ************************************************/
-
-sh_parser_state_t *
-save_parser_state (ps)
-     sh_parser_state_t *ps;
-{
-  if (ps == 0)
-    ps = (sh_parser_state_t *)xmalloc (sizeof (sh_parser_state_t));
-  if (ps == 0)
-    return ((sh_parser_state_t *)NULL);
-
-  ps->parser_state = parser_state;
-  ps->token_state = save_token_state ();
-
-  ps->input_line_terminator = shell_input_line_terminator;
-  ps->eof_encountered = eof_encountered;
-  ps->eol_lookahead = eol_ungetc_lookahead;
-
-  ps->prompt_string_pointer = prompt_string_pointer;
-
-  ps->current_command_line_count = current_command_line_count;
-
-#if defined (HISTORY)
-  ps->remember_on_history = remember_on_history;
-#  if defined (BANG_HISTORY)
-  ps->history_expansion_inhibited = history_expansion_inhibited;
-#  endif
-#endif
-
-  ps->last_command_exit_value = last_command_exit_value;
-#if defined (ARRAY_VARS)
-  ps->pipestatus = save_pipestatus_array ();
-#endif
-    
-  ps->last_shell_builtin = last_shell_builtin;
-  ps->this_shell_builtin = this_shell_builtin;
-
-  ps->expand_aliases = expand_aliases;
-  ps->echo_input_at_read = echo_input_at_read;
-  ps->need_here_doc = need_here_doc;
-  ps->here_doc_first_line = here_doc_first_line;
-
-  ps->esacs_needed = esacs_needed_count;
-  ps->expecting_in = expecting_in_token;
-
-  if (need_here_doc == 0)
-    ps->redir_stack[0] = 0;
-  else
-    memcpy (ps->redir_stack, redir_stack, sizeof (redir_stack[0]) * HEREDOC_MAX);
-
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  ps->pushed_strings = pushed_string_list;
-#endif
-
-  ps->eof_token = shell_eof_token;
-  ps->token = token;
-  ps->token_buffer_size = token_buffer_size;
-  /* Force reallocation on next call to read_token_word */
-  token = 0;
-  token_buffer_size = 0;
-
-  return (ps);
-}
-
-void
-restore_parser_state (ps)
-     sh_parser_state_t *ps;
-{
-  int i;
-
-  if (ps == 0)
-    return;
-
-  parser_state = ps->parser_state;
-  if (ps->token_state)
-    {
-      restore_token_state (ps->token_state);
-      free (ps->token_state);
-    }
-
-  shell_input_line_terminator = ps->input_line_terminator;
-  eof_encountered = ps->eof_encountered;
-  eol_ungetc_lookahead = ps->eol_lookahead;
-
-  prompt_string_pointer = ps->prompt_string_pointer;
-
-  current_command_line_count = ps->current_command_line_count;
-
-#if defined (HISTORY)
-  remember_on_history = ps->remember_on_history;
-#  if defined (BANG_HISTORY)
-  history_expansion_inhibited = ps->history_expansion_inhibited;
-#  endif
-#endif
-
-  last_command_exit_value = ps->last_command_exit_value;
-#if defined (ARRAY_VARS)
-  restore_pipestatus_array (ps->pipestatus);
-#endif
-
-  last_shell_builtin = ps->last_shell_builtin;
-  this_shell_builtin = ps->this_shell_builtin;
-
-  expand_aliases = ps->expand_aliases;
-  echo_input_at_read = ps->echo_input_at_read;
-  need_here_doc = ps->need_here_doc;
-  here_doc_first_line = ps->here_doc_first_line;
-
-  esacs_needed_count = ps->esacs_needed;
-  expecting_in_token = ps->expecting_in;
-
-#if 0
-  for (i = 0; i < HEREDOC_MAX; i++)
-    redir_stack[i] = ps->redir_stack[i];
-#else
-  if (need_here_doc == 0)
-    redir_stack[0] = 0;
-  else
-    memcpy (redir_stack, ps->redir_stack, sizeof (redir_stack[0]) * HEREDOC_MAX);
-#endif
-
-#if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
-  pushed_string_list = (STRING_SAVER *)ps->pushed_strings;
-#endif
-
-  FREE (token);
-  token = ps->token;
-  token_buffer_size = ps->token_buffer_size;
-  shell_eof_token = ps->eof_token;
-}
-
-sh_input_line_state_t *
-save_input_line_state (ls)
-     sh_input_line_state_t *ls;
-{
-  if (ls == 0)
-    ls = (sh_input_line_state_t *)xmalloc (sizeof (sh_input_line_state_t));
-  if (ls == 0)
-    return ((sh_input_line_state_t *)NULL);
-
-  ls->input_line = shell_input_line;
-  ls->input_line_size = shell_input_line_size;
-  ls->input_line_len = shell_input_line_len;
-  ls->input_line_index = shell_input_line_index;
-
-#if defined (HANDLE_MULTIBYTE)
-  ls->input_property = shell_input_line_property;
-  ls->input_propsize = shell_input_line_propsize;
-#endif
-
-  /* force reallocation */
-  shell_input_line = 0;
-  shell_input_line_size = shell_input_line_len = shell_input_line_index = 0;
-
-#if defined (HANDLE_MULTIBYTE)
-  shell_input_line_property = 0;
-  shell_input_line_propsize = 0;
-#endif
-
-  return ls;
-}
-
-void
-restore_input_line_state (ls)
-     sh_input_line_state_t *ls;
-{
-  FREE (shell_input_line);
-  shell_input_line = ls->input_line;
-  shell_input_line_size = ls->input_line_size;
-  shell_input_line_len = ls->input_line_len;
-  shell_input_line_index = ls->input_line_index;
-
-#if defined (HANDLE_MULTIBYTE)
-  FREE (shell_input_line_property);
-  shell_input_line_property = ls->input_property;
-  shell_input_line_propsize = ls->input_propsize;
-#endif
-
-#if 0
-  set_line_mbstate ();
-#endif
-}
-
-/************************************************
- *						*
- *	MULTIBYTE CHARACTER HANDLING		*
- *						*
- ************************************************/
-
-#if defined (HANDLE_MULTIBYTE)
-
-/* We don't let the property buffer get larger than this unless the line is */
-#define MAX_PROPSIZE 32768
-
-static void
-set_line_mbstate ()
-{
-  int c;
-  size_t i, previ, len;
-  mbstate_t mbs, prevs;
-  size_t mbclen;
-  int ilen;
-
-  if (shell_input_line == NULL)
-    return;
-  len = STRLEN (shell_input_line);	/* XXX - shell_input_line_len ? */
-  if (len == 0)
-    return;
-  if (shell_input_line_propsize >= MAX_PROPSIZE && len < MAX_PROPSIZE>>1)
-    {
-      free (shell_input_line_property);
-      shell_input_line_property = 0;
-      shell_input_line_propsize = 0;
-    }
-  if (len+1 > shell_input_line_propsize)
-    {
-      shell_input_line_propsize = len + 1;
-      shell_input_line_property = (char *)xrealloc (shell_input_line_property, shell_input_line_propsize);
-    }
-
-  if (locale_mb_cur_max == 1)
-    {
-      memset (shell_input_line_property, 1, len);
-      return;
-    }
-
-  /* XXX - use whether or not we are in a UTF-8 locale to avoid calls to
-     mbrlen */
-  if (locale_utf8locale == 0)
-    memset (&prevs, '\0', sizeof (mbstate_t));
-
-  for (i = previ = 0; i < len; i++)
-    {
-      if (locale_utf8locale == 0)
-	mbs = prevs;
-
-      c = shell_input_line[i];
-      if (c == EOF)
-	{
-	  size_t j;
-	  for (j = i; j < len; j++)
-	    shell_input_line_property[j] = 1;
-	  break;
-	}
-
-      if (locale_utf8locale)
-	{
-	  if ((unsigned char)shell_input_line[previ] < 128)	/* i != previ */
-	    mbclen = 1;
-	  else
-	    {
-	      ilen = utf8_mblen (shell_input_line + previ, i - previ + 1);
-	      mbclen = (ilen == -1) ? (size_t)-1
-				    : ((ilen == -2) ? (size_t)-2 : (size_t)ilen);
-	    }
-	}
-      else
-	mbclen = mbrlen (shell_input_line + previ, i - previ + 1, &mbs);
-
-      if (mbclen == 1 || mbclen == (size_t)-1)
-	{
-	  mbclen = 1;
-	  previ = i + 1;
-	}
-      else if (mbclen == (size_t)-2)
-        mbclen = 0;
-      else if (mbclen > 1)
-	{
-	  mbclen = 0;
-	  previ = i + 1;
-	  if (locale_utf8locale == 0)
-	    prevs = mbs;
-	}
-      else
-	{
-	  size_t j;
-	  for (j = i; j < len; j++)
-	    shell_input_line_property[j] = 1;
-	  break;
-	}
-
-      shell_input_line_property[i] = mbclen;
-    }
-}
-#endif /* HANDLE_MULTIBYTE */
diff --git a/third_party/bash/y.tab.h b/third_party/bash/y.tab.h
deleted file mode 100644
index 3f3010777..000000000
--- a/third_party/bash/y.tab.h
+++ /dev/null
@@ -1,191 +0,0 @@
-/* A Bison parser, made by GNU Bison 3.8.2.  */
-
-/* Bison interface for Yacc-like parsers in C
-
-   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
-   Inc.
-
-   This program is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
-
-/* As a special exception, you may create a larger work that contains
-   part or all of the Bison parser skeleton and distribute that work
-   under terms of your choice, so long as that work isn't itself a
-   parser generator using the skeleton or a modified version thereof
-   as a parser skeleton.  Alternatively, if you modify or redistribute
-   the parser skeleton itself, you may (at your option) remove this
-   special exception, which will cause the skeleton and the resulting
-   Bison output files to be licensed under the GNU General Public
-   License without this special exception.
-
-   This special exception was added by the Free Software Foundation in
-   version 2.2 of Bison.  */
-
-/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
-   especially those whose name start with YY_ or yy_.  They are
-   private implementation details that can be changed or removed.  */
-
-#ifndef YY_YY_Y_TAB_H_INCLUDED
-# define YY_YY_Y_TAB_H_INCLUDED
-/* Debug traces.  */
-#ifndef YYDEBUG
-# define YYDEBUG 0
-#endif
-#if YYDEBUG
-extern int yydebug;
-#endif
-
-/* Token kinds.  */
-#ifndef YYTOKENTYPE
-# define YYTOKENTYPE
-  enum yytokentype
-  {
-    YYEMPTY = -2,
-    YYEOF = 0,                     /* "end of file"  */
-    YYerror = 256,                 /* error  */
-    YYUNDEF = 257,                 /* "invalid token"  */
-    IF = 258,                      /* IF  */
-    THEN = 259,                    /* THEN  */
-    ELSE = 260,                    /* ELSE  */
-    ELIF = 261,                    /* ELIF  */
-    FI = 262,                      /* FI  */
-    CASE = 263,                    /* CASE  */
-    ESAC = 264,                    /* ESAC  */
-    FOR = 265,                     /* FOR  */
-    SELECT = 266,                  /* SELECT  */
-    WHILE = 267,                   /* WHILE  */
-    UNTIL = 268,                   /* UNTIL  */
-    DO = 269,                      /* DO  */
-    DONE = 270,                    /* DONE  */
-    FUNCTION = 271,                /* FUNCTION  */
-    COPROC = 272,                  /* COPROC  */
-    COND_START = 273,              /* COND_START  */
-    COND_END = 274,                /* COND_END  */
-    COND_ERROR = 275,              /* COND_ERROR  */
-    IN = 276,                      /* IN  */
-    BANG = 277,                    /* BANG  */
-    TIME = 278,                    /* TIME  */
-    TIMEOPT = 279,                 /* TIMEOPT  */
-    TIMEIGN = 280,                 /* TIMEIGN  */
-    WORD = 281,                    /* WORD  */
-    ASSIGNMENT_WORD = 282,         /* ASSIGNMENT_WORD  */
-    REDIR_WORD = 283,              /* REDIR_WORD  */
-    NUMBER = 284,                  /* NUMBER  */
-    ARITH_CMD = 285,               /* ARITH_CMD  */
-    ARITH_FOR_EXPRS = 286,         /* ARITH_FOR_EXPRS  */
-    COND_CMD = 287,                /* COND_CMD  */
-    AND_AND = 288,                 /* AND_AND  */
-    OR_OR = 289,                   /* OR_OR  */
-    GREATER_GREATER = 290,         /* GREATER_GREATER  */
-    LESS_LESS = 291,               /* LESS_LESS  */
-    LESS_AND = 292,                /* LESS_AND  */
-    LESS_LESS_LESS = 293,          /* LESS_LESS_LESS  */
-    GREATER_AND = 294,             /* GREATER_AND  */
-    SEMI_SEMI = 295,               /* SEMI_SEMI  */
-    SEMI_AND = 296,                /* SEMI_AND  */
-    SEMI_SEMI_AND = 297,           /* SEMI_SEMI_AND  */
-    LESS_LESS_MINUS = 298,         /* LESS_LESS_MINUS  */
-    AND_GREATER = 299,             /* AND_GREATER  */
-    AND_GREATER_GREATER = 300,     /* AND_GREATER_GREATER  */
-    LESS_GREATER = 301,            /* LESS_GREATER  */
-    GREATER_BAR = 302,             /* GREATER_BAR  */
-    BAR_AND = 303,                 /* BAR_AND  */
-    DOLPAREN = 304,                /* DOLPAREN  */
-    yacc_EOF = 305                 /* yacc_EOF  */
-  };
-  typedef enum yytokentype yytoken_kind_t;
-#endif
-/* Token kinds.  */
-#define YYEMPTY -2
-#define YYEOF 0
-#define YYerror 256
-#define YYUNDEF 257
-#define IF 258
-#define THEN 259
-#define ELSE 260
-#define ELIF 261
-#define FI 262
-#define CASE 263
-#define ESAC 264
-#define FOR 265
-#define SELECT 266
-#define WHILE 267
-#define UNTIL 268
-#define DO 269
-#define DONE 270
-#define FUNCTION 271
-#define COPROC 272
-#define COND_START 273
-#define COND_END 274
-#define COND_ERROR 275
-#define IN 276
-#define BANG 277
-#define TIME 278
-#define TIMEOPT 279
-#define TIMEIGN 280
-#define WORD 281
-#define ASSIGNMENT_WORD 282
-#define REDIR_WORD 283
-#define NUMBER 284
-#define ARITH_CMD 285
-#define ARITH_FOR_EXPRS 286
-#define COND_CMD 287
-#define AND_AND 288
-#define OR_OR 289
-#define GREATER_GREATER 290
-#define LESS_LESS 291
-#define LESS_AND 292
-#define LESS_LESS_LESS 293
-#define GREATER_AND 294
-#define SEMI_SEMI 295
-#define SEMI_AND 296
-#define SEMI_SEMI_AND 297
-#define LESS_LESS_MINUS 298
-#define AND_GREATER 299
-#define AND_GREATER_GREATER 300
-#define LESS_GREATER 301
-#define GREATER_BAR 302
-#define BAR_AND 303
-#define DOLPAREN 304
-#define yacc_EOF 305
-
-/* Value type.  */
-#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-union YYSTYPE
-{
-#line 338 "/usr/local/src/chet/src/bash/src/parse.y"
-
-  WORD_DESC *word;		/* the word that we read. */
-  int number;			/* the number that we read. */
-  WORD_LIST *word_list;
-  COMMAND *command;
-  REDIRECT *redirect;
-  ELEMENT element;
-  PATTERN_LIST *pattern;
-
-#line 177 "y.tab.h"
-
-};
-typedef union YYSTYPE YYSTYPE;
-# define YYSTYPE_IS_TRIVIAL 1
-# define YYSTYPE_IS_DECLARED 1
-#endif
-
-
-extern YYSTYPE yylval;
-
-
-int yyparse (void);
-
-
-#endif /* !YY_YY_Y_TAB_H_INCLUDED  */
diff --git a/third_party/bash/zcatfd.c b/third_party/bash/zcatfd.c
deleted file mode 100644
index b172c1aa5..000000000
--- a/third_party/bash/zcatfd.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/* zcatfd - copy contents of file descriptor to another */
-
-/* Copyright (C) 2002-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <sys/types.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <errno.h>
-
-#include "stdc.h"
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#ifndef ZBUFSIZ
-#  define ZBUFSIZ 4096
-#endif
-
-extern ssize_t zread PARAMS((int, char *, size_t));
-extern int zwrite PARAMS((int, char *, ssize_t));
-
-/* Dump contents of file descriptor FD to OFD.  FN is the filename for
-   error messages (not used right now). */
-int
-zcatfd (fd, ofd, fn)
-     int fd, ofd;
-     char *fn;
-{
-  ssize_t nr;
-  int rval;
-  char lbuf[ZBUFSIZ];
-
-  rval = 0;
-  while (1)
-    {
-      nr = zread (fd, lbuf, sizeof (lbuf));
-      if (nr == 0)
-	break;
-      else if (nr < 0)
-	{
-	  rval = -1;
-	  break;
-	}
-      else if (zwrite (ofd, lbuf, nr) < 0)
-	{
-	  rval = -1;
-	  break;
-	}
-    }
-
-  return rval;
-}
diff --git a/third_party/bash/zgetline.c b/third_party/bash/zgetline.c
deleted file mode 100644
index 2b4801fc6..000000000
--- a/third_party/bash/zgetline.c
+++ /dev/null
@@ -1,126 +0,0 @@
-/* zgetline - read a line of input from a specified file descriptor and return
-	      a pointer to a newly-allocated buffer containing the data. */
-
-/* Copyright (C) 2008-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <sys/types.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <errno.h>
-#include "xmalloc.h"
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-extern ssize_t zread PARAMS((int, char *, size_t));
-extern ssize_t zreadc PARAMS((int, char *));
-extern ssize_t zreadintr PARAMS((int, char *, size_t));
-extern ssize_t zreadcintr PARAMS((int, char *));
-
-typedef ssize_t breadfunc_t PARAMS((int, char *, size_t));
-typedef ssize_t creadfunc_t PARAMS((int, char *));
-
-/* Initial memory allocation for automatic growing buffer in zreadlinec */
-#define GET_LINE_INITIAL_ALLOCATION 16
-
-/* Derived from GNU libc's getline.
-   The behavior is almost the same as getline. See man getline.
-   The differences are
-   	(1) using file descriptor instead of FILE *;
-	(2) the order of arguments: the file descriptor comes first;
-	(3) the addition of a fourth argument, DELIM; sets the delimiter to
-	    be something other than newline if desired.  If setting DELIM,
-	    the next argument should be 1; and
-	(4) the addition of a fifth argument, UNBUFFERED_READ; this argument
-	    controls whether get_line uses buffering or not to get a byte data
-	    from FD. get_line uses zreadc if UNBUFFERED_READ is zero; and
-	    uses zread if UNBUFFERED_READ is non-zero.
-
-   Returns number of bytes read or -1 on error. */
-
-ssize_t
-zgetline (fd, lineptr, n, delim, unbuffered_read)
-     int fd;
-     char **lineptr;
-     size_t *n;
-     int delim;
-     int unbuffered_read;
-{
-  int retval;
-  size_t nr;
-  char *line, c;
-
-  if (lineptr == 0 || n == 0 || (*lineptr == 0 && *n != 0))
-    return -1;
-
-  nr = 0;
-  line = *lineptr;
-  
-  while (1)
-    {
-      retval = unbuffered_read ? zread (fd, &c, 1) : zreadc(fd, &c);
-
-      if (retval <= 0)
-	{
-	  if (line && nr > 0)
-	    line[nr] = '\0';
-	  break;
-	}
-
-      if (nr + 2 >= *n)
-	{
-	  size_t new_size;
-
-	  new_size = (*n == 0) ? GET_LINE_INITIAL_ALLOCATION : *n * 2;
-	  line = (*n >= new_size) ? NULL : xrealloc (*lineptr, new_size);
-
-	  if (line)
-	    {
-	      *lineptr = line;
-	      *n = new_size;
-	    }
-	  else
-	    {
-	      if (*n > 0)
-		{
-		  (*lineptr)[*n - 1] = '\0';
-		  nr = *n - 2;
-		}
-	      break;
-	    }
-	}
-
-      line[nr] = c;
-      nr++;
-
-      if (c == delim)
-	{
-	  line[nr] = '\0';
-	  break;
-	}
-    }
-
-  return nr - 1;
-}
diff --git a/third_party/bash/zmapfd.c b/third_party/bash/zmapfd.c
deleted file mode 100644
index 19a861a62..000000000
--- a/third_party/bash/zmapfd.c
+++ /dev/null
@@ -1,93 +0,0 @@
-/* zmapfd - read contents of file descriptor into a newly-allocated buffer */
-
-/* Copyright (C) 2006-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <sys/types.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <errno.h>
-
-#include "bashansi.h"
-#include "command.h"
-#include "general.h"
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#ifndef ZBUFSIZ
-#  define ZBUFSIZ 4096
-#endif
-
-extern ssize_t zread PARAMS((int, char *, size_t));
-
-/* Dump contents of file descriptor FD to *OSTR.  FN is the filename for
-   error messages (not used right now). */
-int
-zmapfd (fd, ostr, fn)
-     int fd;
-     char **ostr;
-     char *fn;
-{
-  ssize_t nr;
-  int rval;
-  char lbuf[ZBUFSIZ];
-  char *result;
-  size_t rsize, rind;
-
-  rval = 0;
-  result = (char *)xmalloc (rsize = ZBUFSIZ);
-  rind = 0;
-
-  while (1)
-    {
-      nr = zread (fd, lbuf, sizeof (lbuf));
-      if (nr == 0)
-	{
-	  rval = rind;
-	  break;
-	}
-      else if (nr < 0)
-	{
-	  free (result);
-	  if (ostr)
-	    *ostr = (char *)NULL;
-	  return -1;
-	}
-
-      RESIZE_MALLOCED_BUFFER (result, rind, nr, rsize, ZBUFSIZ);
-      memcpy (result+rind, lbuf, nr);
-      rind += nr;
-    }
-
-  RESIZE_MALLOCED_BUFFER (result, rind, 1, rsize, 128);
-  result[rind] = '\0';
-
-  if (ostr)
-    *ostr = result;
-  else
-    free (result);
-
-  return rval;
-}
diff --git a/third_party/bash/zread.c b/third_party/bash/zread.c
deleted file mode 100644
index ea38f6690..000000000
--- a/third_party/bash/zread.c
+++ /dev/null
@@ -1,228 +0,0 @@
-/* zread - read data from file descriptor into buffer with retries */
-
-/* Copyright (C) 1999-2020 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <sys/types.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <signal.h>
-#include <errno.h>
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-#ifndef SEEK_CUR
-#  define SEEK_CUR 1
-#endif
-
-#ifndef ZBUFSIZ
-#  define ZBUFSIZ 4096
-#endif
-
-extern int executing_builtin;
-
-extern void check_signals_and_traps (void);
-extern void check_signals (void);
-extern int signal_is_trapped (int);
-extern int read_builtin_timeout (int);
-
-/* Read LEN bytes from FD into BUF.  Retry the read on EINTR.  Any other
-   error causes the loop to break. */
-ssize_t
-zread (fd, buf, len)
-     int fd;
-     char *buf;
-     size_t len;
-{
-  ssize_t r;
-
-  check_signals ();	/* check for signals before a blocking read */
-  /* should generalize into a mechanism where different parts of the shell can
-     `register' timeouts and have them checked here. */
-  while (((r = read_builtin_timeout (fd)) < 0 || (r = read (fd, buf, len)) < 0) &&
-	     errno == EINTR)
-    {
-      int t;
-      t = errno;
-      /* XXX - bash-5.0 */
-      /* We check executing_builtin and run traps here for backwards compatibility */
-      if (executing_builtin)
-	check_signals_and_traps ();	/* XXX - should it be check_signals()? */
-      else
-	check_signals ();
-      errno = t;
-    }
-
-  return r;
-}
-
-/* Read LEN bytes from FD into BUF.  Retry the read on EINTR, up to three
-   interrupts.  Any other error causes the loop to break. */
-
-#ifdef NUM_INTR
-#  undef NUM_INTR
-#endif
-#define NUM_INTR 3
-
-ssize_t
-zreadretry (fd, buf, len)
-     int fd;
-     char *buf;
-     size_t len;
-{
-  ssize_t r;
-  int nintr;
-
-  for (nintr = 0; ; )
-    {
-      r = read (fd, buf, len);
-      if (r >= 0)
-	return r;
-      if (r == -1 && errno == EINTR)
-	{
-	  if (++nintr >= NUM_INTR)
-	    return -1;
-	  continue;
-	}
-      return r;
-    }
-}
-
-/* Call read(2) and allow it to be interrupted.  Just a stub for now. */
-ssize_t
-zreadintr (fd, buf, len)
-     int fd;
-     char *buf;
-     size_t len;
-{
-  check_signals ();
-  return (read (fd, buf, len));
-}
-
-/* Read one character from FD and return it in CP.  Return values are as
-   in read(2).  This does some local buffering to avoid many one-character
-   calls to read(2), like those the `read' builtin performs. */
-
-static char lbuf[ZBUFSIZ];
-static size_t lind, lused;
-
-ssize_t
-zreadc (fd, cp)
-     int fd;
-     char *cp;
-{
-  ssize_t nr;
-
-  if (lind == lused || lused == 0)
-    {
-      nr = zread (fd, lbuf, sizeof (lbuf));
-      lind = 0;
-      if (nr <= 0)
-	{
-	  lused = 0;
-	  return nr;
-	}
-      lused = nr;
-    }
-  if (cp)
-    *cp = lbuf[lind++];
-  return 1;
-}
-
-/* Don't mix calls to zreadc and zreadcintr in the same function, since they
-   use the same local buffer. */
-ssize_t
-zreadcintr (fd, cp)
-     int fd;
-     char *cp;
-{
-  ssize_t nr;
-
-  if (lind == lused || lused == 0)
-    {
-      nr = zreadintr (fd, lbuf, sizeof (lbuf));
-      lind = 0;
-      if (nr <= 0)
-	{
-	  lused = 0;
-	  return nr;
-	}
-      lused = nr;
-    }
-  if (cp)
-    *cp = lbuf[lind++];
-  return 1;
-}
-
-/* Like zreadc, but read a specified number of characters at a time.  Used
-   for `read -N'. */
-ssize_t
-zreadn (fd, cp, len)
-     int fd;
-     char *cp;
-     size_t len;
-{
-  ssize_t nr;
-
-  if (lind == lused || lused == 0)
-    {
-      if (len > sizeof (lbuf))
-	len = sizeof (lbuf);
-      nr = zread (fd, lbuf, len);
-      lind = 0;
-      if (nr <= 0)
-	{
-	  lused = 0;
-	  return nr;
-	}
-      lused = nr;
-    }
-  if (cp)
-    *cp = lbuf[lind++];
-  return 1;
-}
-
-void
-zreset ()
-{
-  lind = lused = 0;
-}
-
-/* Sync the seek pointer for FD so that the kernel's idea of the last char
-   read is the last char returned by zreadc. */
-void
-zsyncfd (fd)
-     int fd;
-{
-  off_t off, r;
-
-  off = lused - lind;
-  r = 0;
-  if (off > 0)
-    r = lseek (fd, -off, SEEK_CUR);
-
-  if (r != -1)
-    lused = lind = 0;
-}
diff --git a/third_party/bash/zwrite.c b/third_party/bash/zwrite.c
deleted file mode 100644
index db04750d7..000000000
--- a/third_party/bash/zwrite.c
+++ /dev/null
@@ -1,64 +0,0 @@
-/* zwrite - write contents of buffer to file descriptor, retrying on error */
-
-/* Copyright (C) 1999-2002 Free Software Foundation, Inc.
-
-   This file is part of GNU Bash, the Bourne Again SHell.
-
-   Bash is free software: you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation, either version 3 of the License, or
-   (at your option) any later version.
-
-   Bash is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "config.h"
-
-#include <sys/types.h>
-
-#if defined (HAVE_UNISTD_H)
-#  include <unistd.h>
-#endif
-
-#include <errno.h>
-
-#if !defined (errno)
-extern int errno;
-#endif
-
-/* Write NB bytes from BUF to file descriptor FD, retrying the write if
-   it is interrupted.  We retry three times if we get a zero-length
-   write.  Any other signal causes this function to return prematurely. */
-int
-zwrite (fd, buf, nb)
-     int fd;
-     char *buf;
-     size_t nb;
-{
-  int n, i, nt;
-
-  for (n = nb, nt = 0;;)
-    {
-      i = write (fd, buf, n);
-      if (i > 0)
-	{
-	  n -= i;
-	  if (n <= 0)
-	    return nb;
-	  buf += i;
-	}
-      else if (i == 0)
-	{
-	  if (++nt > 3)
-	    return (nb - n);
-	}
-      else if (errno != EINTR)
-	return -1;
-    }
-}
diff --git a/third_party/bzip2/bzip2.c b/third_party/bzip2/bzip2.c
index d91483807..43d570ea1 100644
--- a/third_party/bzip2/bzip2.c
+++ b/third_party/bzip2/bzip2.c
@@ -14,6 +14,7 @@
 #include "libc/sysv/consts/sig.h"
 #include "libc/utime.h"
 #include "libc/time.h"
+#include "libc/ctype.h"
 #include "third_party/bzip2/bzlib.h"
 
 /*-----------------------------------------------------------*/
diff --git a/third_party/chibicc/BUILD.mk b/third_party/chibicc/BUILD.mk
index 8e3d9bb6d..30d9019f2 100644
--- a/third_party/chibicc/BUILD.mk
+++ b/third_party/chibicc/BUILD.mk
@@ -63,6 +63,7 @@ THIRD_PARTY_CHIBICC_A_DIRECTDEPS =					\
 	THIRD_PARTY_COMPILER_RT						\
 	THIRD_PARTY_DLMALLOC						\
 	THIRD_PARTY_GDTOA						\
+	THIRD_PARTY_MUSL						\
 	THIRD_PARTY_TZ							\
 	TOOL_BUILD_LIB
 
diff --git a/third_party/chibicc/as.c b/third_party/chibicc/as.c
index e4aa4b02c..2859df2b7 100644
--- a/third_party/chibicc/as.c
+++ b/third_party/chibicc/as.c
@@ -24,13 +24,13 @@
 #include "libc/intrin/popcnt.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/crc32.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/s.h"
 #include "libc/x/x.h"
@@ -38,6 +38,7 @@
 #include "third_party/chibicc/file.h"
 #include "third_party/gdtoa/gdtoa.h"
 #include "libc/serialize.h"
+#include "libc/ctype.h"
 #include "tool/build/lib/elfwriter.h"
 
 #define OSZ  0x66
diff --git a/third_party/chibicc/asm.c b/third_party/chibicc/asm.c
index 7a10b8631..5dd73b871 100644
--- a/third_party/chibicc/asm.c
+++ b/third_party/chibicc/asm.c
@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/intrin/bsf.h"
 #include "libc/intrin/bsr.h"
+#include "libc/ctype.h"
 #include "third_party/chibicc/chibicc.h"
 
 #define PRECIOUS 0b1111000000101000  // bx,bp,r12-r15
diff --git a/third_party/chibicc/chibicc.h b/third_party/chibicc/chibicc.h
index 25beb3469..aefe6592e 100644
--- a/third_party/chibicc/chibicc.h
+++ b/third_party/chibicc/chibicc.h
@@ -11,7 +11,7 @@
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/crc32.h"
 #include "libc/runtime/runtime.h"
diff --git a/third_party/chibicc/test/vla_test.c b/third_party/chibicc/test/vla_test.c
index b5010645d..870e04775 100644
--- a/third_party/chibicc/test/vla_test.c
+++ b/third_party/chibicc/test/vla_test.c
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "third_party/chibicc/test/test.h"
 
 int index1d(int xn, int p[xn], int x) {
diff --git a/third_party/chibicc/tokenize.c b/third_party/chibicc/tokenize.c
index 15ba6c6e5..ea12c8765 100644
--- a/third_party/chibicc/tokenize.c
+++ b/third_party/chibicc/tokenize.c
@@ -2,9 +2,10 @@
 #include "libc/log/log.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "third_party/chibicc/chibicc.h"
 #include "third_party/chibicc/file.h"
+#include "libc/ctype.h"
 #include "third_party/chibicc/kw.h"
 
 // Input file
diff --git a/third_party/compiler_rt/clear_cache.c b/third_party/compiler_rt/clear_cache.c
index 7486b0966..8f3cd9cb2 100644
--- a/third_party/compiler_rt/clear_cache.c
+++ b/third_party/compiler_rt/clear_cache.c
@@ -15,7 +15,7 @@
 // It is expected to invalidate the instruction cache for the
 // specified range.
 
-void __clear_cache(void *start, void *end) {
+privileged void __clear_cache(void *start, void *end) {
 
 #ifdef __aarch64__
   if (IsXnu()) {
@@ -59,6 +59,8 @@ void __clear_cache(void *start, void *end) {
   }
   __asm__ volatile("isync");
 
+#elif defined(__x86_64__)
+  // do nothing
 #else
   compilerrt_abort();
 #endif
diff --git a/third_party/compiler_rt/comprt.S b/third_party/compiler_rt/comprt.S
index 95060b658..d31861204 100644
--- a/third_party/compiler_rt/comprt.S
+++ b/third_party/compiler_rt/comprt.S
@@ -1,4 +1,4 @@
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Nop ref this to force pull the license into linkage.
 	.section .yoink
diff --git a/third_party/compiler_rt/extendhfdf2.c b/third_party/compiler_rt/extendhfdf2.c
deleted file mode 100644
index 729eb04c1..000000000
--- a/third_party/compiler_rt/extendhfdf2.c
+++ /dev/null
@@ -1,17 +0,0 @@
-//===-- lib/extendhfdf2.c - half -> dubble conversion -------------*- C -*-===//
-//
-//                The Cosmopolitan Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-
-#define SRC_HALF
-#define DST_DOUBLE
-#include "third_party/compiler_rt/fp16_extend_impl.inc"
-
-COMPILER_RT_ABI dst_t __extendhfdf2(src_t a) {
-    return __extendXfYf2__(a);
-}
diff --git a/third_party/compiler_rt/extendhfsf2.c b/third_party/compiler_rt/extendhfsf2.c
deleted file mode 100644
index f891d9542..000000000
--- a/third_party/compiler_rt/extendhfsf2.c
+++ /dev/null
@@ -1,27 +0,0 @@
-//===-- lib/extendhfsf2.c - half -> single conversion -------------*- C -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#define SRC_HALF
-#define DST_SINGLE
-#include "fp16_extend_impl.inc"
-
-// Use a forwarding definition and noinline to implement a poor man's alias,
-// as there isn't a good cross-platform way of defining one.
-COMPILER_RT_ABI NOINLINE float __extendhfsf2(src_t a) {
-  return __extendXfYf2__(a);
-}
-
-COMPILER_RT_ABI float __gnu_h2f_ieee(src_t a) { return __extendhfsf2(a); }
-
-#if defined(__ARM_EABI__)
-#if defined(COMPILER_RT_ARMHF_TARGET)
-AEABI_RTABI float __aeabi_h2f(src_t a) { return __extendhfsf2(a); }
-#else
-COMPILER_RT_ALIAS(__extendhfsf2, __aeabi_h2f)
-#endif
-#endif
diff --git a/third_party/compiler_rt/truncdfhf2.c b/third_party/compiler_rt/truncdfhf2.c
deleted file mode 100644
index 9a01e2c2e..000000000
--- a/third_party/compiler_rt/truncdfhf2.c
+++ /dev/null
@@ -1,21 +0,0 @@
-//===-- lib/truncdfhf2.c - double -> half conversion --------------*- C -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#define SRC_DOUBLE
-#define DST_HALF
-#include "fp16_trunc_impl.inc"
-
-COMPILER_RT_ABI dst_t __truncdfhf2(double a) { return __truncXfYf2__(a); }
-
-#if defined(__ARM_EABI__)
-#if defined(COMPILER_RT_ARMHF_TARGET)
-AEABI_RTABI dst_t __aeabi_d2h(double a) { return __truncdfhf2(a); }
-#else
-COMPILER_RT_ALIAS(__truncdfhf2, __aeabi_d2h)
-#endif
-#endif
diff --git a/third_party/compiler_rt/truncsfhf2.c b/third_party/compiler_rt/truncsfhf2.c
deleted file mode 100644
index d15e1884f..000000000
--- a/third_party/compiler_rt/truncsfhf2.c
+++ /dev/null
@@ -1,27 +0,0 @@
-//===-- lib/truncsfhf2.c - single -> half conversion --------------*- C -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#define SRC_SINGLE
-#define DST_HALF
-#include "fp16_trunc_impl.inc"
-
-// Use a forwarding definition and noinline to implement a poor man's alias,
-// as there isn't a good cross-platform way of defining one.
-COMPILER_RT_ABI NOINLINE dst_t __truncsfhf2(float a) {
-  return __truncXfYf2__(a);
-}
-
-COMPILER_RT_ABI dst_t __gnu_f2h_ieee(float a) { return __truncsfhf2(a); }
-
-#if defined(__ARM_EABI__)
-#if defined(COMPILER_RT_ARMHF_TARGET)
-AEABI_RTABI dst_t __aeabi_f2h(float a) { return __truncsfhf2(a); }
-#else
-COMPILER_RT_ALIAS(__truncsfhf2, __aeabi_f2h)
-#endif
-#endif
diff --git a/third_party/ctags/BUILD.mk b/third_party/ctags/BUILD.mk
index 826ceefe4..973ce3a02 100644
--- a/third_party/ctags/BUILD.mk
+++ b/third_party/ctags/BUILD.mk
@@ -19,13 +19,14 @@ THIRD_PARTY_CTAGS_DIRECTDEPS =				\
 	LIBC_LOG					\
 	LIBC_MEM					\
 	LIBC_NEXGEN32E					\
-	LIBC_RUNTIME					\
 	LIBC_PROC					\
+	LIBC_RUNTIME					\
 	LIBC_STDIO					\
 	LIBC_STR					\
+	LIBC_SYSTEM					\
 	LIBC_SYSV					\
 	THIRD_PARTY_MUSL				\
-	THIRD_PARTY_REGEX
+	THIRD_PARTY_REGEX				\
 
 THIRD_PARTY_CTAGS_DEPS :=				\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_CTAGS_DIRECTDEPS),$($(x))))
diff --git a/third_party/ctags/args.c b/third_party/ctags/args.c
index e8770d204..0dec366a6 100644
--- a/third_party/ctags/args.c
+++ b/third_party/ctags/args.c
@@ -13,6 +13,7 @@
 #include "libc/str/str.h"
 #include "third_party/ctags/args.h"
 #include "third_party/ctags/debug.h"
+#include "libc/ctype.h"
 #include "third_party/ctags/routines.h"
 
 /*
diff --git a/third_party/ctags/asm.c b/third_party/ctags/asm.c
index 3b3cc3a40..02069ca36 100644
--- a/third_party/ctags/asm.c
+++ b/third_party/ctags/asm.c
@@ -13,6 +13,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/asp.c b/third_party/ctags/asp.c
index fd8d1df75..8e90b4cfe 100644
--- a/third_party/ctags/asp.c
+++ b/third_party/ctags/asp.c
@@ -13,6 +13,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/awk.c b/third_party/ctags/awk.c
index ab4c17ca3..8a3fd2add 100644
--- a/third_party/ctags/awk.c
+++ b/third_party/ctags/awk.c
@@ -12,6 +12,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/basic.c b/third_party/ctags/basic.c
index b53b97b2b..89be4b8c2 100644
--- a/third_party/ctags/basic.c
+++ b/third_party/ctags/basic.c
@@ -15,6 +15,7 @@
 /*
  *   INCLUDE FILES
  */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h" /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/beta.c b/third_party/ctags/beta.c
index 08d1c3d4d..7fa63c2f4 100644
--- a/third_party/ctags/beta.c
+++ b/third_party/ctags/beta.c
@@ -15,6 +15,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"	/* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/eiffel.c b/third_party/ctags/eiffel.c
index 0a4d0042e..1f2a48da8 100644
--- a/third_party/ctags/eiffel.c
+++ b/third_party/ctags/eiffel.c
@@ -14,6 +14,7 @@
 *   INCLUDE FILES
 */
 #include "libc/fmt/conv.h"
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #ifdef TYPE_REFERENCE_TOOL
diff --git a/third_party/ctags/entry.c b/third_party/ctags/entry.c
index 13126d298..a60ab0a1c 100644
--- a/third_party/ctags/entry.c
+++ b/third_party/ctags/entry.c
@@ -13,6 +13,7 @@
 *   INCLUDE FILES
 */
 #include "libc/runtime/runtime.h"
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/erlang.c b/third_party/ctags/erlang.c
index c4844d5a7..570e883dd 100644
--- a/third_party/ctags/erlang.c
+++ b/third_party/ctags/erlang.c
@@ -13,6 +13,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/flex.c b/third_party/ctags/flex.c
index dd02cd75a..3676f0758 100644
--- a/third_party/ctags/flex.c
+++ b/third_party/ctags/flex.c
@@ -22,6 +22,8 @@
 #include "third_party/ctags/general.h"	/* must always come first */
 #include "libc/str/str.h"	/* to define isalpha () */
 #include "libc/runtime/runtime.h"
+#include "libc/ctype.h"
+
 #ifdef DEBUG
 #include "libc/calls/calls.h"
 #include "libc/stdio/dprintf.h"
diff --git a/third_party/ctags/general.h b/third_party/ctags/general.h
index ca8c0c515..15b9774c0 100644
--- a/third_party/ctags/general.h
+++ b/third_party/ctags/general.h
@@ -11,6 +11,7 @@
 #ifndef _GENERAL_H
 #define _GENERAL_H
 #include "third_party/ctags/config.h"
+#include "libc/ctype.h"
 
 /* Define standard error destination
  */
diff --git a/third_party/ctags/get.c b/third_party/ctags/get.c
index 7e938c98f..f8df96aea 100644
--- a/third_party/ctags/get.c
+++ b/third_party/ctags/get.c
@@ -13,6 +13,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/go.c b/third_party/ctags/go.c
index 6d2de2b46..bb55f22c4 100644
--- a/third_party/ctags/go.c
+++ b/third_party/ctags/go.c
@@ -2,6 +2,7 @@
 *   INCLUDE FILES
 */
 #include "third_party/ctags/general.h"        /* must always come first */
+#include "libc/ctype.h"
 #include "libc/runtime/runtime.h"
 
 #include "third_party/ctags/debug.h"
diff --git a/third_party/ctags/jscript.c b/third_party/ctags/jscript.c
index c8bf53917..bccd0c852 100644
--- a/third_party/ctags/jscript.c
+++ b/third_party/ctags/jscript.c
@@ -21,6 +21,8 @@
 #include "third_party/ctags/general.h"	/* must always come first */
 #include "libc/str/str.h"	/* to define isalpha () */
 #include "libc/runtime/runtime.h"
+#include "libc/ctype.h"
+
 #ifdef DEBUG
 #include "libc/calls/calls.h"
 #include "libc/stdio/dprintf.h"
diff --git a/third_party/ctags/lisp.c b/third_party/ctags/lisp.c
index 8a47e7b20..5041888a6 100644
--- a/third_party/ctags/lisp.c
+++ b/third_party/ctags/lisp.c
@@ -12,6 +12,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "third_party/ctags/parse.h"
diff --git a/third_party/ctags/lregex.c b/third_party/ctags/lregex.c
index 40a67907d..1f905e1e4 100644
--- a/third_party/ctags/lregex.c
+++ b/third_party/ctags/lregex.c
@@ -16,6 +16,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/lua.c b/third_party/ctags/lua.c
index 47c9d5893..d86ff839c 100644
--- a/third_party/ctags/lua.c
+++ b/third_party/ctags/lua.c
@@ -12,6 +12,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/make.c b/third_party/ctags/make.c
index 794560cbf..ec1360518 100644
--- a/third_party/ctags/make.c
+++ b/third_party/ctags/make.c
@@ -12,6 +12,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/parse.c b/third_party/ctags/parse.c
index 84cd8869f..d3dffd91b 100644
--- a/third_party/ctags/parse.c
+++ b/third_party/ctags/parse.c
@@ -13,6 +13,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/pascal.c b/third_party/ctags/pascal.c
index 9ffc2834f..d6b22e666 100644
--- a/third_party/ctags/pascal.c
+++ b/third_party/ctags/pascal.c
@@ -13,6 +13,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/perl.c b/third_party/ctags/perl.c
index 4fda42f3c..186cf7c8a 100644
--- a/third_party/ctags/perl.c
+++ b/third_party/ctags/perl.c
@@ -13,6 +13,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/python.c b/third_party/ctags/python.c
index 7bdf3baf2..cbe02d8ce 100644
--- a/third_party/ctags/python.c
+++ b/third_party/ctags/python.c
@@ -13,6 +13,7 @@
 *   INCLUDE FILES
 */
 #include "libc/mem/mem.h"
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/read.c b/third_party/ctags/read.c
index 521413fd6..3ddf7da58 100644
--- a/third_party/ctags/read.c
+++ b/third_party/ctags/read.c
@@ -13,6 +13,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/readtags.c b/third_party/ctags/readtags.c
index a6c56642d..dc069e522 100644
--- a/third_party/ctags/readtags.c
+++ b/third_party/ctags/readtags.c
@@ -14,6 +14,7 @@
 #include "libc/mem/mem.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
+#include "libc/ctype.h"
 #include "third_party/ctags/readtags.h"
 
 /*
diff --git a/third_party/ctags/routines.c b/third_party/ctags/routines.c
index f1b8cb2f3..10c39e470 100644
--- a/third_party/ctags/routines.c
+++ b/third_party/ctags/routines.c
@@ -19,6 +19,7 @@
 #include "libc/sysv/consts/s.h"
 #include "third_party/ctags/config.h"
 #include "third_party/ctags/debug.h"
+#include "libc/ctype.h"
 #include "third_party/ctags/routines.h"
 
 /*
diff --git a/third_party/ctags/ruby.c b/third_party/ctags/ruby.c
index 89569449f..956ac6dd3 100644
--- a/third_party/ctags/ruby.c
+++ b/third_party/ctags/ruby.c
@@ -15,6 +15,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/scheme.c b/third_party/ctags/scheme.c
index 152efcdbc..1d84e44db 100644
--- a/third_party/ctags/scheme.c
+++ b/third_party/ctags/scheme.c
@@ -13,6 +13,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/sh.c b/third_party/ctags/sh.c
index 130cca513..8409f62fd 100644
--- a/third_party/ctags/sh.c
+++ b/third_party/ctags/sh.c
@@ -13,6 +13,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/sml.c b/third_party/ctags/sml.c
index d9a460eac..b3f94d823 100644
--- a/third_party/ctags/sml.c
+++ b/third_party/ctags/sml.c
@@ -12,6 +12,7 @@
 /*
  *   INCLUDE FILES
  */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/tcl.c b/third_party/ctags/tcl.c
index 600a23742..d193ce2d4 100644
--- a/third_party/ctags/tcl.c
+++ b/third_party/ctags/tcl.c
@@ -12,6 +12,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/tex.c b/third_party/ctags/tex.c
index f881aee59..3ce844a73 100644
--- a/third_party/ctags/tex.c
+++ b/third_party/ctags/tex.c
@@ -18,6 +18,8 @@
 #include "third_party/ctags/general.h"	/* must always come first */
 #include "libc/str/str.h"	/* to define isalpha () */
 #include "libc/runtime/runtime.h"
+#include "libc/ctype.h"
+
 #ifdef DEBUG
 #include "libc/calls/calls.h"
 #include "libc/stdio/dprintf.h"
diff --git a/third_party/ctags/verilog.c b/third_party/ctags/verilog.c
index 705175d2f..737fdaee6 100644
--- a/third_party/ctags/verilog.c
+++ b/third_party/ctags/verilog.c
@@ -19,6 +19,7 @@
 /*
  *   INCLUDE FILES
  */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/vhdl.c b/third_party/ctags/vhdl.c
index a6c8016fa..1b970ce66 100644
--- a/third_party/ctags/vhdl.c
+++ b/third_party/ctags/vhdl.c
@@ -12,6 +12,7 @@
 /*
  *   INCLUDE FILES
  */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"	/* must always come first */
 
 #include "libc/str/str.h"	/* to define isalpha () */
diff --git a/third_party/ctags/vim.c b/third_party/ctags/vim.c
index d2c0009b1..e0cd9b0d9 100644
--- a/third_party/ctags/vim.c
+++ b/third_party/ctags/vim.c
@@ -15,6 +15,7 @@
 /*
 *	INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/mem/alg.h"
diff --git a/third_party/ctags/vstring.c b/third_party/ctags/vstring.c
index cc92117e6..01311d421 100644
--- a/third_party/ctags/vstring.c
+++ b/third_party/ctags/vstring.c
@@ -12,6 +12,7 @@
 /*
 *   INCLUDE FILES
 */
+#include "libc/ctype.h"
 #include "third_party/ctags/general.h"  /* must always come first */
 
 #include "libc/limits.h"
diff --git a/third_party/dlmalloc/BUILD.mk b/third_party/dlmalloc/BUILD.mk
index 8b7b9d6dc..70af0e364 100644
--- a/third_party/dlmalloc/BUILD.mk
+++ b/third_party/dlmalloc/BUILD.mk
@@ -58,6 +58,13 @@ $(THIRD_PARTY_DLMALLOC_A_OBJS): private				\
 			-Wframe-larger-than=4096		\
 			-Walloca-larger-than=4096
 
+# avoid the legacy sse decoding penalty on avx systems
+ifeq ($(MODE),)
+$(THIRD_PARTY_DLMALLOC_A_OBJS): private				\
+		COPTS +=					\
+			-mgeneral-regs-only
+endif
+
 THIRD_PARTY_DLMALLOC_LIBS = $(foreach x,$(THIRD_PARTY_DLMALLOC_ARTIFACTS),$($(x)))
 THIRD_PARTY_DLMALLOC_SRCS = $(foreach x,$(THIRD_PARTY_DLMALLOC_ARTIFACTS),$($(x)_SRCS))
 THIRD_PARTY_DLMALLOC_HDRS = $(foreach x,$(THIRD_PARTY_DLMALLOC_ARTIFACTS),$($(x)_HDRS))
diff --git a/third_party/dlmalloc/README.cosmo b/third_party/dlmalloc/README.cosmo
index 0db6ea937..097b9342a 100644
--- a/third_party/dlmalloc/README.cosmo
+++ b/third_party/dlmalloc/README.cosmo
@@ -9,6 +9,7 @@ LICENSE
 
 LOCAL CHANGES
 
+  - Fix MT-safety bugs in DEBUG mode
   - Fix bug in dlmalloc_inspect_all()
   - Define dlmalloc_requires_more_vespene_gas()
   - Make dlmalloc scalable using sched_getcpu()
diff --git a/third_party/dlmalloc/directmap.inc b/third_party/dlmalloc/directmap.inc
index 2e313e31e..e83348cea 100644
--- a/third_party/dlmalloc/directmap.inc
+++ b/third_party/dlmalloc/directmap.inc
@@ -57,7 +57,7 @@ static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb, int flags) {
     size_t newmmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
     char* cp = (char*)CALL_MREMAP((char*)oldp - offset,
                                   oldmmsize, newmmsize, flags);
-    if (cp != CMFAIL) {
+    if (cp != MAP_FAILED) {
       mchunkptr newp = (mchunkptr)(cp + offset);
       size_t psize = newmmsize - offset - MMAP_FOOT_PAD;
       newp->head = psize;
diff --git a/third_party/dlmalloc/dlmalloc.c b/third_party/dlmalloc/dlmalloc.c
index 4ec0983d3..b20e28cd9 100644
--- a/third_party/dlmalloc/dlmalloc.c
+++ b/third_party/dlmalloc/dlmalloc.c
@@ -8,7 +8,7 @@
 #include "libc/intrin/bsr.h"
 #include "libc/intrin/likely.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/runtime/internal.h"
@@ -24,31 +24,27 @@
 #include "libc/thread/tls.h"
 #include "third_party/dlmalloc/vespene.internal.h"
 #include "libc/thread/tls.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/intrin/kprintf.h"
+#include "libc/sysv/consts/mremap.h"
 #include "third_party/nsync/mu.h"
 
 #if !IsTiny()
 #define FOOTERS 1
 #define MSPACES 1
 #define ONLY_MSPACES 1 // enables scalable multi-threaded malloc
+#define USE_SPIN_LOCKS 0 // set to 0 to use scalable nsync locks
 #else
 #define INSECURE 1
 #define PROCEED_ON_ERROR 1
 #define FOOTERS 0
 #define MSPACES 0
 #define ONLY_MSPACES 0
+#define USE_SPIN_LOCKS 1
 #endif
 
-#define HAVE_MMAP 1
-#define HAVE_MREMAP 0
-#define HAVE_MORECORE 0
+#define HAVE_MREMAP 1
 #define USE_LOCKS 2
-#define USE_SPIN_LOCKS 1
-#define MORECORE_CONTIGUOUS 0
 #define MALLOC_INSPECT_ALL 1
 #define ABORT_ON_ASSERT_FAILURE 0
-#define LOCK_AT_FORK 1
 #define NO_MALLOC_STATS 1
 
 #if IsModeDbg()
@@ -66,11 +62,6 @@
 #include "locks.inc"
 #include "chunks.inc"
 #include "headfoot.inc"
-
-#if ONLY_MSPACES
-#include "threaded.inc"
-#endif
-
 #include "global.inc"
 #include "system.inc"
 #include "hooks.inc"
@@ -78,6 +69,11 @@
 #include "indexing.inc"
 #include "binmaps.inc"
 #include "runtimechecks.inc"
+
+#if ONLY_MSPACES
+#include "threaded.inc"
+#endif
+
 #include "init.inc"
 #include "debuglib.inc"
 #include "statistics.inc"
@@ -88,7 +84,7 @@
 
 /* -------------------------- System allocation -------------------------- */
 
-/* Get memory from system using MORECORE or MMAP */
+/* Get memory from system */
 static void* sys_alloc(mstate m, size_t nb) {
   char* tbase = CMFAIL;
   size_t tsize = 0;
@@ -113,91 +109,8 @@ static void* sys_alloc(mstate m, size_t nb) {
       return 0;
   }
 
-  /*
-    Try getting memory in any of three ways (in most-preferred to
-    least-preferred order):
-    1. A call to MORECORE that can normally contiguously extend memory.
-       (disabled if not MORECORE_CONTIGUOUS or not HAVE_MORECORE or
-       or main space is mmapped or a previous contiguous call failed)
-    2. A call to MMAP new space (disabled if not HAVE_MMAP).
-       Note that under the default settings, if MORECORE is unable to
-       fulfill a request, and HAVE_MMAP is true, then mmap is
-       used as a noncontiguous system allocator. This is a useful backup
-       strategy for systems with holes in address spaces -- in this case
-       sbrk cannot contiguously expand the heap, but mmap may be able to
-       find space.
-    3. A call to MORECORE that cannot usually contiguously extend memory.
-       (disabled if not HAVE_MORECORE)
-
-   In all cases, we need to request enough bytes from system to ensure
-   we can malloc nb bytes upon success, so pad with enough space for
-   top_foot, plus alignment-pad to make sure we don't lose bytes if
-   not on boundary, and round this up to a granularity unit.
-  */
-
-  if (MORECORE_CONTIGUOUS && !use_noncontiguous(m)) {
-    char* br = CMFAIL;
-    size_t ssize = asize; /* sbrk call size */
-    msegmentptr ss = (m->top == 0)? 0 : segment_holding(m, (char*)m->top);
-    ACQUIRE_MALLOC_GLOBAL_LOCK();
-
-    if (ss == 0) {  /* First time through or recovery */
-      char* base = (char*)CALL_MORECORE(0);
-      if (base != CMFAIL) {
-        size_t fp;
-        /* Adjust to end on a page boundary */
-        if (!is_page_aligned(base))
-          ssize += (page_align((size_t)base) - (size_t)base);
-        fp = m->footprint + ssize; /* recheck limits */
-        if (ssize > nb && ssize < HALF_MAX_SIZE_T &&
-            (m->footprint_limit == 0 ||
-             (fp > m->footprint && fp <= m->footprint_limit)) &&
-            (br = (char*)(CALL_MORECORE(ssize))) == base) {
-          tbase = base;
-          tsize = ssize;
-        }
-      }
-    }
-    else {
-      /* Subtract out existing available top space from MORECORE request. */
-      ssize = granularity_align(nb - m->topsize + SYS_ALLOC_PADDING);
-      /* Use mem here only if it did continuously extend old space */
-      if (ssize < HALF_MAX_SIZE_T &&
-          (br = (char*)(CALL_MORECORE(ssize))) == ss->base+ss->size) {
-        tbase = br;
-        tsize = ssize;
-      }
-    }
-
-    if (tbase == CMFAIL) {    /* Cope with partial failure */
-      if (br != CMFAIL) {    /* Try to use/extend the space we did get */
-        if (ssize < HALF_MAX_SIZE_T &&
-            ssize < nb + SYS_ALLOC_PADDING) {
-          size_t esize = granularity_align(nb + SYS_ALLOC_PADDING - ssize);
-          if (esize < HALF_MAX_SIZE_T) {
-            char* end = (char*)CALL_MORECORE(esize);
-            if (end != CMFAIL)
-              ssize += esize;
-            else {            /* Can't use; try to release */
-              (void) CALL_MORECORE(-ssize);
-              br = CMFAIL;
-            }
-          }
-        }
-      }
-      if (br != CMFAIL) {    /* Use the space we did get */
-        tbase = br;
-        tsize = ssize;
-      }
-      else
-        disable_contiguous(m); /* Don't try contiguous path in the future */
-    }
-
-    RELEASE_MALLOC_GLOBAL_LOCK();
-  }
-
-  if (HAVE_MMAP && tbase == CMFAIL) {  /* Try MMAP */
-    char* mp = (char*)(dlmalloc_requires_more_vespene_gas(asize));
+  if (tbase == CMFAIL) {  /* Try MMAP */
+    char* mp = dlmalloc_requires_more_vespene_gas(asize);
     if (mp != CMFAIL) {
       tbase = mp;
       tsize = asize;
@@ -205,24 +118,6 @@ static void* sys_alloc(mstate m, size_t nb) {
     }
   }
 
-  if (HAVE_MORECORE && tbase == CMFAIL) { /* Try noncontiguous MORECORE */
-    if (asize < HALF_MAX_SIZE_T) {
-      char* br = CMFAIL;
-      char* end = CMFAIL;
-      ACQUIRE_MALLOC_GLOBAL_LOCK();
-      br = (char*)(CALL_MORECORE(asize));
-      end = (char*)(CALL_MORECORE(0));
-      RELEASE_MALLOC_GLOBAL_LOCK();
-      if (br != CMFAIL && end != CMFAIL && br < end) {
-        size_t ssize = end - br;
-        if (ssize > nb + TOP_FOOT_SIZE) {
-          tbase = br;
-          tsize = ssize;
-        }
-      }
-    }
-  }
-
   if (tbase != CMFAIL) {
 
     if ((m->footprint += tsize) > m->max_footprint)
@@ -362,34 +257,17 @@ static int sys_trim(mstate m, size_t pad) {
 
       if (!is_extern_segment(sp)) {
         if (is_mmapped_segment(sp)) {
-          if (HAVE_MMAP &&
-              sp->size >= extra &&
+          if (sp->size >= extra &&
               !has_segment_link(m, sp)) { /* can't shrink if pinned */
             size_t newsize = sp->size - extra;
             (void)newsize; /* placate people compiling -Wunused-variable */
             /* Prefer mremap, fall back to munmap */
-            if (CALL_MREMAP(sp->base, sp->size, newsize, 0) != MFAIL ||
+            if (CALL_MREMAP(sp->base, sp->size, newsize, 0) != MAP_FAILED ||
                 (!extra || !CALL_MUNMAP(sp->base + newsize, extra))) {
               released = extra;
             }
           }
         }
-        else if (HAVE_MORECORE) {
-          if (extra >= HALF_MAX_SIZE_T) /* Avoid wrapping negative */
-            extra = (HALF_MAX_SIZE_T) + SIZE_T_ONE - unit;
-          ACQUIRE_MALLOC_GLOBAL_LOCK();
-          {
-            /* Make sure end of memory is where we last set it. */
-            char* old_br = (char*)(CALL_MORECORE(0));
-            if (old_br == sp->base + sp->size) {
-              char* rel_br = (char*)(CALL_MORECORE(-extra));
-              char* new_br = (char*)(CALL_MORECORE(0));
-              if (rel_br != CMFAIL && new_br < old_br)
-                released = old_br - new_br;
-            }
-          }
-          RELEASE_MALLOC_GLOBAL_LOCK();
-        }
       }
 
       if (released != 0) {
@@ -401,8 +279,7 @@ static int sys_trim(mstate m, size_t pad) {
     }
 
     /* Unmap any unused mmapped segments */
-    if (HAVE_MMAP)
-      released += release_unused_segments(m);
+    released += release_unused_segments(m);
 
     /* On failure, disable autotrim to avoid repeated failed future calls */
     if (released == 0 && m->topsize > m->trim_check)
@@ -1263,13 +1140,16 @@ void* dlrealloc_single(void* oldmem, size_t bytes) {
     }
 #endif /* FOOTERS */
     if (!PREACTION(m)) {
-      mchunkptr newp = try_realloc_chunk(m, oldp, nb, 1);
-      POSTACTION(m);
+      mchunkptr newp = try_realloc_chunk(m, oldp, nb, MREMAP_MAYMOVE);
       if (newp != 0) {
+        /* [jart] fix realloc MT bug in DEBUG mode
+                  https://github.com/intel/linux-sgx/issues/534 */
         check_inuse_chunk(m, newp);
+        POSTACTION(m);
         mem = chunk2mem(newp);
       }
       else {
+        POSTACTION(m);
         mem = internal_malloc(m, bytes);
         if (mem != 0) {
           size_t oc = chunksize(oldp) - overhead_for(oldp);
@@ -1302,11 +1182,13 @@ void* dlrealloc_in_place(void* oldmem, size_t bytes) {
 #endif /* FOOTERS */
       if (!PREACTION(m)) {
         mchunkptr newp = try_realloc_chunk(m, oldp, nb, 0);
-        POSTACTION(m);
         if (newp == oldp) {
+          /* [jart] fix realloc MT bug in DEBUG mode
+                    https://github.com/intel/linux-sgx/issues/534 */
           check_inuse_chunk(m, newp);
           mem = oldmem;
         }
+        POSTACTION(m);
       }
     }
   }
@@ -1320,13 +1202,6 @@ void* dlmemalign_single(size_t alignment, size_t bytes) {
   return internal_memalign(gm, alignment, bytes);
 }
 
-#if USE_LOCKS
-void dlmalloc_atfork(void) {
-  bzero(&gm->mutex, sizeof(gm->mutex));
-  bzero(&malloc_global_mutex, sizeof(malloc_global_mutex));
-}
-#endif
-
 void** dlindependent_calloc(size_t n_elements, size_t elem_size,
                             void* chunks[]) {
   size_t sz = elem_size; /* serves as 1-element array */
diff --git a/third_party/dlmalloc/dlmalloc.h b/third_party/dlmalloc/dlmalloc.h
index edb86f27a..5bbb9a179 100644
--- a/third_party/dlmalloc/dlmalloc.h
+++ b/third_party/dlmalloc/dlmalloc.h
@@ -9,7 +9,6 @@
 #define dlmallinfo                   __dlmallinfo
 #define dlmalloc                     __dlmalloc
 #define dlmalloc_abort               __dlmalloc_abort
-#define dlmalloc_atfork              __dlmalloc_atfork
 #define dlmalloc_footprint           __dlmalloc_footprint
 #define dlmalloc_footprint_limit     __dlmalloc_footprint_limit
 #define dlmalloc_inspect_all         __dlmalloc_inspect_all
@@ -527,7 +526,10 @@ void mspace_inspect_all(mspace msp,
                         void (*handler)(void*, void*, size_t, void*),
                         void* arg);
 
-void dlmalloc_atfork(void);
+void dlmalloc_pre_fork(void) libcesque;
+void dlmalloc_post_fork_parent(void) libcesque;
+void dlmalloc_post_fork_child(void) libcesque;
+
 void dlmalloc_abort(void) relegated wontreturn;
 
 COSMOPOLITAN_C_END_
diff --git a/third_party/dlmalloc/dlmalloc_abort.c b/third_party/dlmalloc/dlmalloc_abort.c
index 0ca5135be..ef3effcb4 100644
--- a/third_party/dlmalloc/dlmalloc_abort.c
+++ b/third_party/dlmalloc/dlmalloc_abort.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
-#include "libc/intrin/describebacktrace.internal.h"
+#include "libc/intrin/describebacktrace.h"
 #include "libc/runtime/runtime.h"
 #include "third_party/dlmalloc/dlmalloc.h"
 
diff --git a/third_party/dlmalloc/init.inc b/third_party/dlmalloc/init.inc
index 970bad026..ac7ce8edf 100644
--- a/third_party/dlmalloc/init.inc
+++ b/third_party/dlmalloc/init.inc
@@ -1,67 +1,51 @@
 #include "libc/sysv/consts/auxv.h"
 #include "libc/runtime/runtime.h"
+#include "libc/nexgen32e/rdtsc.h"
+#include "libc/runtime/runtime.h"
 
-/* ---------------------------- setting mparams -------------------------- */
-
-#if LOCK_AT_FORK
+void dlmalloc_pre_fork(void) {
 #if ONLY_MSPACES
-
-static void dlmalloc_pre_fork(void) {
   mstate h;
-  for (unsigned i = 0; i < ARRAYLEN(g_heaps); ++i)
+  for (unsigned i = ARRAYLEN(g_heaps); i--;)
     if ((h = atomic_load_explicit(&g_heaps[i], memory_order_acquire)))
       ACQUIRE_LOCK(&h->mutex);
+#else
+  ACQUIRE_LOCK(&(gm)->mutex);
+#endif
 }
 
-static void dlmalloc_post_fork_parent(void) {
+void dlmalloc_post_fork_parent(void) {
+#if ONLY_MSPACES
   mstate h;
   for (unsigned i = 0; i < ARRAYLEN(g_heaps); ++i)
     if ((h = atomic_load_explicit(&g_heaps[i], memory_order_acquire)))
       RELEASE_LOCK(&h->mutex);
+#else
+  RELEASE_LOCK(&(gm)->mutex);
+#endif
 }
 
-static void dlmalloc_post_fork_child(void) {
+void dlmalloc_post_fork_child(void) {
+#if ONLY_MSPACES
   mstate h;
   for (unsigned i = 0; i < ARRAYLEN(g_heaps); ++i)
     if ((h = atomic_load_explicit(&g_heaps[i], memory_order_acquire)))
-      (void)INITIAL_LOCK(&h->mutex);
-}
-
+      REFRESH_LOCK(&h->mutex);
 #else
-static void dlmalloc_pre_fork(void)         { ACQUIRE_LOCK(&(gm)->mutex); }
-static void dlmalloc_post_fork_parent(void) { RELEASE_LOCK(&(gm)->mutex); }
-static void dlmalloc_post_fork_child(void)  { (void)INITIAL_LOCK(&(gm)->mutex); }
-#endif /* ONLY_MSPACES */
-#endif /* LOCK_AT_FORK */
+  REFRESH_LOCK(&(gm)->mutex);
+#endif
+}
 
 /* Initialize mparams */
 __attribute__((__constructor__(49))) int init_mparams(void) {
-#ifdef NEED_GLOBAL_LOCK_INIT
-  if (malloc_global_mutex_status <= 0)
-    init_malloc_global_mutex();
-#endif
 
-  // ACQUIRE_MALLOC_GLOBAL_LOCK();
   if (mparams.magic == 0) {
     size_t magic;
     size_t psize;
     size_t gsize;
 
-#if defined(__COSMOPOLITAN__)
-    psize = getauxval(AT_PAGESZ);
+    psize = __pagesize;
     gsize = DEFAULT_GRANULARITY ? DEFAULT_GRANULARITY : psize;
-#elif !defined(WIN32)
-    psize = malloc_getpagesize;
-    gsize = ((DEFAULT_GRANULARITY != 0)? DEFAULT_GRANULARITY : psize);
-#else /* WIN32 */
-    {
-      SYSTEM_INFO system_info;
-      GetSystemInfo(&system_info);
-      psize = system_info.dwPageSize;
-      gsize = ((DEFAULT_GRANULARITY != 0)?
-               DEFAULT_GRANULARITY : system_info.dwAllocationGranularity);
-    }
-#endif /* WIN32 */
 
     /* Sanity-check configuration:
        size_t must be unsigned and as wide as pointer type.
@@ -82,11 +66,7 @@ __attribute__((__constructor__(49))) int init_mparams(void) {
     mparams.page_size = psize;
     mparams.mmap_threshold = DEFAULT_MMAP_THRESHOLD;
     mparams.trim_threshold = DEFAULT_TRIM_THRESHOLD;
-#if MORECORE_CONTIGUOUS
-    mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT;
-#else  /* MORECORE_CONTIGUOUS */
     mparams.default_mflags = USE_LOCK_BIT|USE_MMAP_BIT|USE_NONCONTIGUOUS_BIT;
-#endif /* MORECORE_CONTIGUOUS */
 
 #if !ONLY_MSPACES
     /* Set up lock for main malloc area */
@@ -94,12 +74,6 @@ __attribute__((__constructor__(49))) int init_mparams(void) {
     (void)INITIAL_LOCK(&gm->mutex);
 #endif
 
-#if LOCK_AT_FORK
-    pthread_atfork(&dlmalloc_pre_fork,
-                   &dlmalloc_post_fork_parent,
-                   &dlmalloc_post_fork_child);
-#endif
-
     {
 #if USE_DEV_RANDOM
       int fd;
@@ -112,7 +86,7 @@ __attribute__((__constructor__(49))) int init_mparams(void) {
       }
       else
 #endif /* USE_DEV_RANDOM */
-      magic = (size_t)(_rand64() ^ (size_t)0x55555555U);
+      magic = (size_t)(rdtsc() ^ (size_t)0x55555555U);
       magic |= (size_t)8U;    /* ensure nonzero */
       magic &= ~(size_t)7U;   /* improve chances of fault for bad values */
       /* Until memory modes commonly available, use volatile-write */
@@ -120,8 +94,6 @@ __attribute__((__constructor__(49))) int init_mparams(void) {
     }
   }
 
-  // RELEASE_MALLOC_GLOBAL_LOCK();
-
 #if ONLY_MSPACES
   threaded_dlmalloc();
 #endif
diff --git a/third_party/dlmalloc/locks.inc b/third_party/dlmalloc/locks.inc
index 037442ac5..ea962c778 100644
--- a/third_party/dlmalloc/locks.inc
+++ b/third_party/dlmalloc/locks.inc
@@ -1,3 +1,7 @@
+#include "libc/cosmo.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/maps.h"
+#include "libc/thread/thread.h"
 
 /* --------------------------- Lock preliminaries ------------------------ */
 
@@ -33,56 +37,94 @@
 
 #define MLOCK_T atomic_uint
 
+static int malloc_inlk(MLOCK_T *lk) {
+  atomic_store_explicit(lk, 0, memory_order_relaxed);
+  return 0;
+}
+
 static int malloc_wipe(MLOCK_T *lk) {
-  bzero(lk, sizeof(*lk));
+  atomic_store_explicit(lk, 0, memory_order_relaxed);
+  return 0;
+}
+
+static int malloc_kilk(MLOCK_T *lk) {
   return 0;
 }
 
 static int malloc_lock(MLOCK_T *lk) {
-  if (!__threaded) return 0;
-  while (atomic_exchange_explicit(lk, 1, memory_order_acquire)) {
-    pthread_pause_np();
+  for (;;) {
+    if (!atomic_exchange_explicit(lk, 1, memory_order_acquire))
+      break;
+    for (;;)
+      if (!atomic_load_explicit(lk, memory_order_relaxed))
+        break;
   }
   return 0;
 }
 
-static int malloc_unlock(MLOCK_T *lk) {
-  if (!__threaded) return 0;
+static int malloc_unlk(MLOCK_T *lk) {
   atomic_store_explicit(lk, 0, memory_order_release);
   return 0;
 }
 
 #else
 
-#define MLOCK_T nsync_mu
+#define MLOCK_T struct MallocLock
 
-static int malloc_wipe(MLOCK_T *lk) {
+struct MallocLock {
+#if DEBUG
+  void *edges;
+#endif
+  nsync_mu mu;
+};
+
+static int malloc_inlk(MLOCK_T *lk) {
   bzero(lk, sizeof(*lk));
   return 0;
 }
 
-static int malloc_lock(MLOCK_T *lk) {
-  if (!__threaded) return 0;
-  nsync_mu_lock(lk);
+static int malloc_wipe(MLOCK_T *lk) {
+  bzero(&lk->mu, sizeof(lk->mu));
   return 0;
 }
 
-static int malloc_unlock(MLOCK_T *lk) {
-  if (!__threaded) return 0;
-  nsync_mu_unlock(lk);
+static int malloc_kilk(MLOCK_T *lk) {
+  return 0;
+}
+
+static int malloc_lock(MLOCK_T *lk) {
+#if DEBUG
+  __deadlock_check(lk, 0);
+#endif
+  nsync_mu_lock(&lk->mu);
+#if DEBUG
+  __deadlock_record(lk, 0);
+  __deadlock_track(lk, 0);
+#endif
+  return 0;
+}
+
+static int malloc_unlk(MLOCK_T *lk) {
+#if DEBUG
+  if (__deadlock_tracked(lk) == 0) {
+    kprintf("error: unlock malloc mutex not owned by caller: %t\n", lk);
+    DebugBreak();
+  }
+#endif
+  nsync_mu_unlock(&lk->mu);
+#if DEBUG
+  __deadlock_untrack(lk);
+#endif
   return 0;
 }
 
 #endif
 
 #define ACQUIRE_LOCK(lk) malloc_lock(lk)
-#define RELEASE_LOCK(lk) malloc_unlock(lk)
-#define INITIAL_LOCK(lk) malloc_wipe(lk)
-#define DESTROY_LOCK(lk) malloc_wipe(lk)
-#define ACQUIRE_MALLOC_GLOBAL_LOCK() ACQUIRE_LOCK(&malloc_global_mutex);
-#define RELEASE_MALLOC_GLOBAL_LOCK() RELEASE_LOCK(&malloc_global_mutex);
-
-static MLOCK_T malloc_global_mutex;
+#define RELEASE_LOCK(lk) malloc_unlk(lk)
+#define INITIAL_LOCK(lk) malloc_inlk(lk)
+#define REFRESH_LOCK(lk) malloc_wipe(lk)
+#define DESTROY_LOCK(lk) malloc_kilk(lk)
 
 #define USE_LOCK_BIT               (2U)
 
diff --git a/third_party/dlmalloc/mspaces.inc b/third_party/dlmalloc/mspaces.inc
index 1f048d0eb..d17d96549 100644
--- a/third_party/dlmalloc/mspaces.inc
+++ b/third_party/dlmalloc/mspaces.inc
@@ -368,12 +368,15 @@ void* mspace_realloc(mspace msp, void* oldmem, size_t bytes) {
 #endif /* FOOTERS */
     if (!PREACTION(m)) {
       mchunkptr newp = try_realloc_chunk(m, oldp, nb, 1);
-      POSTACTION(m);
       if (newp != 0) {
+        /* [jart] fix realloc MT bug in DEBUG mode
+                  https://github.com/intel/linux-sgx/issues/534 */
         check_inuse_chunk(m, newp);
+        POSTACTION(m);
         mem = chunk2mem(newp);
       }
       else {
+        POSTACTION(m);
         mem = mspace_malloc(m, bytes);
         if (mem != 0) {
           size_t oc = chunksize(oldp) - overhead_for(oldp);
@@ -407,11 +410,13 @@ void* mspace_realloc_in_place(mspace msp, void* oldmem, size_t bytes) {
 #endif /* FOOTERS */
       if (!PREACTION(m)) {
         mchunkptr newp = try_realloc_chunk(m, oldp, nb, 0);
-        POSTACTION(m);
         if (newp == oldp) {
+          /* [jart] fix realloc_in_place MT bug in DEBUG mode
+                    https://github.com/intel/linux-sgx/issues/534 */
           check_inuse_chunk(m, newp);
           mem = oldmem;
         }
+        POSTACTION(m);
       }
     }
   }
diff --git a/third_party/dlmalloc/platform.inc b/third_party/dlmalloc/platform.inc
index 25c80f416..5385a7f88 100644
--- a/third_party/dlmalloc/platform.inc
+++ b/third_party/dlmalloc/platform.inc
@@ -75,9 +75,6 @@
 #ifndef MALLOC_INSPECT_ALL
 #define MALLOC_INSPECT_ALL 0
 #endif  /* MALLOC_INSPECT_ALL */
-#ifndef HAVE_MMAP
-#define HAVE_MMAP 1
-#endif  /* HAVE_MMAP */
 #ifndef MMAP_CLEARS
 #define MMAP_CLEARS 1
 #endif  /* MMAP_CLEARS */
@@ -92,48 +89,17 @@
 #ifndef MALLOC_FAILURE_ACTION
 #define MALLOC_FAILURE_ACTION  errno = ENOMEM;
 #endif  /* MALLOC_FAILURE_ACTION */
-#ifndef HAVE_MORECORE
-#if ONLY_MSPACES
-#define HAVE_MORECORE 0
-#else   /* ONLY_MSPACES */
-#define HAVE_MORECORE 1
-#endif  /* ONLY_MSPACES */
-#endif  /* HAVE_MORECORE */
-#if !HAVE_MORECORE
-#define MORECORE_CONTIGUOUS 0
-#else   /* !HAVE_MORECORE */
-#define MORECORE_DEFAULT sbrk
-#ifndef MORECORE_CONTIGUOUS
-#define MORECORE_CONTIGUOUS 1
-#endif  /* MORECORE_CONTIGUOUS */
-#endif  /* HAVE_MORECORE */
 #ifndef DEFAULT_GRANULARITY
-#if (MORECORE_CONTIGUOUS || defined(WIN32))
-#define DEFAULT_GRANULARITY (0)  /* 0 means to compute in init_mparams */
-#else   /* MORECORE_CONTIGUOUS */
 #define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U)
-#endif  /* MORECORE_CONTIGUOUS */
 #endif  /* DEFAULT_GRANULARITY */
 #ifndef DEFAULT_TRIM_THRESHOLD
-#ifndef MORECORE_CANNOT_TRIM
 #define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U)
-#else   /* MORECORE_CANNOT_TRIM */
-#define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T
-#endif  /* MORECORE_CANNOT_TRIM */
 #endif  /* DEFAULT_TRIM_THRESHOLD */
 #ifndef DEFAULT_MMAP_THRESHOLD
-#if HAVE_MMAP
 #define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)
-#else   /* HAVE_MMAP */
-#define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T
-#endif  /* HAVE_MMAP */
 #endif  /* DEFAULT_MMAP_THRESHOLD */
 #ifndef MAX_RELEASE_CHECK_RATE
-#if HAVE_MMAP
 #define MAX_RELEASE_CHECK_RATE 4095
-#else
-#define MAX_RELEASE_CHECK_RATE MAX_SIZE_T
-#endif /* HAVE_MMAP */
 #endif /* MAX_RELEASE_CHECK_RATE */
 #ifndef USE_BUILTIN_FFS
 #define USE_BUILTIN_FFS 0
@@ -185,165 +151,6 @@
   ========================================================================
 */
 
-/* #include "malloc.h" */
-
-/*------------------------------ internal #includes ---------------------- */
-
-#ifdef _MSC_VER
-#pragma warning( disable : 4146 ) /* no "unsigned" warnings */
-#endif /* _MSC_VER */
-#if !NO_MALLOC_STATS
-#endif /* NO_MALLOC_STATS */
-#ifndef LACKS_ERRNO_H
-#include <errno.h>       /* for MALLOC_FAILURE_ACTION */
-#endif /* LACKS_ERRNO_H */
-#ifdef DEBUG
-#if ABORT_ON_ASSERT_FAILURE
-#endif /* ABORT_ON_ASSERT_FAILURE */
-#else  /* DEBUG */
-#ifndef assert
-#define assert(x)
-#endif
-#define DEBUG 0
-#endif /* DEBUG */
-#if !defined(WIN32) && !defined(LACKS_TIME_H)
-#include <time.h>        /* for magic initialization */
-#endif /* WIN32 */
-#ifndef LACKS_STDLIB_H
-#include <stdlib.h>      /* for abort() */
-#endif /* LACKS_STDLIB_H */
-#ifndef LACKS_STRING_H
-#include <string.h>      /* for memset etc */
-#endif  /* LACKS_STRING_H */
-#if USE_BUILTIN_FFS
-#ifndef LACKS_STRINGS_H
-#include <strings.h>     /* for ffs */
-#endif /* LACKS_STRINGS_H */
-#endif /* USE_BUILTIN_FFS */
-#if HAVE_MMAP
-#ifndef LACKS_SYS_MMAN_H
-/* On some versions of linux, mremap decl in mman.h needs __USE_GNU set */
-#if (defined(linux) && !defined(__USE_GNU))
-#define __USE_GNU 1
-#include <sys/mman.h>    /* for mmap */
-#undef __USE_GNU
-#else
-#include <sys/mman.h>    /* for mmap */
-#endif /* linux */
-#endif /* LACKS_SYS_MMAN_H */
-#ifndef LACKS_FCNTL_H
-#include <fcntl.h>
-#endif /* LACKS_FCNTL_H */
-#endif /* HAVE_MMAP */
-#ifndef LACKS_UNISTD_H
-#include <unistd.h>     /* for sbrk, sysconf */
-#else /* LACKS_UNISTD_H */
-#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__) && !defined(__COSMOPOLITAN__)
-extern void*     sbrk(ptrdiff_t);
-#endif /* FreeBSD etc */
-#endif /* LACKS_UNISTD_H */
-
-/* Declarations for locking */
-#if USE_LOCKS
-#ifndef WIN32
-#if defined (__SVR4) && defined (__sun)  /* solaris */
-#elif !defined(LACKS_SCHED_H)
-#endif /* solaris or LACKS_SCHED_H */
-#if (defined(USE_RECURSIVE_LOCKS) && USE_RECURSIVE_LOCKS != 0) || !USE_SPIN_LOCKS
-#endif /* USE_RECURSIVE_LOCKS ... */
-#elif defined(_MSC_VER)
-#ifndef _M_AMD64
-/* These are already defined on AMD64 builds */
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-LONG __cdecl _InterlockedCompareExchange(LONG volatile *Dest, LONG Exchange, LONG Comp);
-LONG __cdecl _InterlockedExchange(LONG volatile *Target, LONG Value);
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-#endif /* _M_AMD64 */
-#pragma intrinsic (_InterlockedCompareExchange)
-#pragma intrinsic (_InterlockedExchange)
-#define interlockedcompareexchange _InterlockedCompareExchange
-#define interlockedexchange _InterlockedExchange
-#elif defined(WIN32) && defined(__GNUC__)
-#define interlockedcompareexchange(a, b, c) __sync_val_compare_and_swap(a, c, b)
-#define interlockedexchange __sync_lock_test_and_set
-#endif /* Win32 */
-#else /* USE_LOCKS */
-#endif /* USE_LOCKS */
-
-#ifndef LOCK_AT_FORK
-#define LOCK_AT_FORK 0
-#endif
-
-/* Declarations for bit scanning on win32 */
-#if defined(_MSC_VER) && _MSC_VER>=1300
-#ifndef BitScanForward /* Try to avoid pulling in WinNT.h */
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-unsigned char _BitScanForward(unsigned long *index, unsigned long mask);
-unsigned char _BitScanReverse(unsigned long *index, unsigned long mask);
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#define BitScanForward _BitScanForward
-#define BitScanReverse _BitScanReverse
-#pragma intrinsic(_BitScanForward)
-#pragma intrinsic(_BitScanReverse)
-#endif /* BitScanForward */
-#endif /* defined(_MSC_VER) && _MSC_VER>=1300 */
-
-#ifndef WIN32
-#ifndef malloc_getpagesize
-#  ifdef _SC_PAGESIZE         /* some SVR4 systems omit an underscore */
-#    ifndef _SC_PAGE_SIZE
-#      define _SC_PAGE_SIZE _SC_PAGESIZE
-#    endif
-#  endif
-#  ifdef _SC_PAGE_SIZE
-#    define malloc_getpagesize 4096 /*sysconf(_SC_PAGE_SIZE)*/
-#  else
-#    if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)
-       extern size_t getpagesize();
-#      define malloc_getpagesize getpagesize()
-#    else
-#      ifdef WIN32 /* use supplied emulation of getpagesize */
-#        define malloc_getpagesize getpagesize()
-#      else
-#        ifndef LACKS_SYS_PARAM_H
-#          include <sys/param.h>
-#        endif
-#        ifdef EXEC_PAGESIZE
-#          define malloc_getpagesize EXEC_PAGESIZE
-#        else
-#          ifdef NBPG
-#            ifndef CLSIZE
-#              define malloc_getpagesize NBPG
-#            else
-#              define malloc_getpagesize (NBPG * CLSIZE)
-#            endif
-#          else
-#            ifdef NBPC
-#              define malloc_getpagesize NBPC
-#            else
-#              ifdef PAGESIZE
-#                define malloc_getpagesize PAGESIZE
-#              else /* just guess */
-#                define malloc_getpagesize ((size_t)4096U)
-#              endif
-#            endif
-#          endif
-#        endif
-#      endif
-#    endif
-#  endif
-#endif
-#endif
-
 /* ------------------- size_t and alignment properties -------------------- */
 
 /* The byte and bit size of a size_t */
@@ -374,145 +181,53 @@ unsigned char _BitScanReverse(unsigned long *index, unsigned long mask);
 
 /* -------------------------- MMAP preliminaries ------------------------- */
 
-/*
-   If HAVE_MORECORE or HAVE_MMAP are false, we just define calls and
-   checks to fail so compiler optimizer can delete code rather than
-   using so many "#if"s.
-*/
-
-
 /* MORECORE and MMAP must return MFAIL on failure */
 #define MFAIL                NULL
 #define CMFAIL               ((char*)(MFAIL)) /* defined for convenience */
 
-#if HAVE_MMAP
-
-#ifndef WIN32
 #define MUNMAP_DEFAULT(a, s)  munmap((a), (s))
 #define MMAP_PROT            (PROT_READ|PROT_WRITE)
-#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
-#define MAP_ANONYMOUS        MAP_ANON
-#endif /* MAP_ANON */
-#ifdef MAP_ANONYMOUS
 #define MMAP_FLAGS           (MAP_PRIVATE|MAP_ANONYMOUS)
 #define MMAP_DEFAULT(s)       _mapanon(s)
-#else /* MAP_ANONYMOUS */
-/*
-   Nearly all versions of mmap support MAP_ANONYMOUS, so the following
-   is unlikely to be needed, but is supplied just in case.
-*/
-#define MMAP_FLAGS           (MAP_PRIVATE)
-static int dev_zero_fd = -1; /* Cached file descriptor for /dev/zero. */
-#define MMAP_DEFAULT(s) ((dev_zero_fd < 0) ? \
-           (dev_zero_fd = open("/dev/zero", O_RDWR), \
-            mmap_no(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0)) : \
-            mmap_no(0, (s), MMAP_PROT, MMAP_FLAGS, dev_zero_fd, 0))
-#endif /* MAP_ANONYMOUS */
-
 #define DIRECT_MMAP_DEFAULT(s) MMAP_DEFAULT(s)
 
-#else /* WIN32 */
-
-/* Win32 MMAP via VirtualAlloc */
-FORCEINLINE void* win32mmap(size_t size) {
-  void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
-  return (ptr != 0)? ptr: MFAIL;
-}
-
-/* For direct MMAP, use MEM_TOP_DOWN to minimize interference */
-FORCEINLINE void* win32direct_mmap(size_t size) {
-  void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN,
-                           PAGE_READWRITE);
-  return (ptr != 0)? ptr: MFAIL;
-}
-
-/* This function supports releasing coalesed segments */
-FORCEINLINE int win32munmap(void* ptr, size_t size) {
-  MEMORY_BASIC_INFORMATION minfo;
-  char* cptr = (char*)ptr;
-  while (size) {
-    if (VirtualQuery(cptr, &minfo, sizeof(minfo)) == 0)
-      return -1;
-    if (minfo.BaseAddress != cptr || minfo.AllocationBase != cptr ||
-        minfo.State != MEM_COMMIT || minfo.RegionSize > size)
-      return -1;
-    if (VirtualFree(cptr, 0, MEM_RELEASE) == 0)
-      return -1;
-    cptr += minfo.RegionSize;
-    size -= minfo.RegionSize;
-  }
-  return 0;
-}
-
-#define MMAP_DEFAULT(s)             win32mmap(s)
-#define MUNMAP_DEFAULT(a, s)        win32munmap((a), (s))
-#define DIRECT_MMAP_DEFAULT(s)      win32direct_mmap(s)
-#endif /* WIN32 */
-#endif /* HAVE_MMAP */
-
 #if HAVE_MREMAP
 #ifndef WIN32
 #define MREMAP_DEFAULT(addr, osz, nsz, mv) mremap((addr), (osz), (nsz), (mv))
 #endif /* WIN32 */
 #endif /* HAVE_MREMAP */
 
-/**
- * Define CALL_MORECORE
- */
-#if HAVE_MORECORE
-    #ifdef MORECORE
-        #define CALL_MORECORE(S)    MORECORE(S)
-    #else  /* MORECORE */
-        #define CALL_MORECORE(S)    MORECORE_DEFAULT(S)
-    #endif /* MORECORE */
-#else  /* HAVE_MORECORE */
-    #define CALL_MORECORE(S)        MFAIL
-#endif /* HAVE_MORECORE */
-
 /**
  * Define CALL_MMAP/CALL_MUNMAP/CALL_DIRECT_MMAP
  */
-#if HAVE_MMAP
-    #define USE_MMAP_BIT            (SIZE_T_ONE)
+#define USE_MMAP_BIT            (SIZE_T_ONE)
 
-    #ifdef MMAP
-        #define CALL_MMAP(s)        MMAP(s)
-    #else /* MMAP */
-        #define CALL_MMAP(s)        MMAP_DEFAULT(s)
-    #endif /* MMAP */
-    #ifdef MUNMAP
-        #define CALL_MUNMAP(a, s)   MUNMAP((a), (s))
-    #else /* MUNMAP */
-        #define CALL_MUNMAP(a, s)   MUNMAP_DEFAULT((a), (s))
-    #endif /* MUNMAP */
-    #ifdef DIRECT_MMAP
-        #define CALL_DIRECT_MMAP(s) DIRECT_MMAP(s)
-    #else /* DIRECT_MMAP */
-        #define CALL_DIRECT_MMAP(s) DIRECT_MMAP_DEFAULT(s)
-    #endif /* DIRECT_MMAP */
-#else  /* HAVE_MMAP */
-    #define USE_MMAP_BIT            (SIZE_T_ZERO)
+#ifdef MMAP
+#define CALL_MMAP(s)        MMAP(s)
+#else /* MMAP */
+#define CALL_MMAP(s)        MMAP_DEFAULT(s)
+#endif /* MMAP */
 
-    #define MMAP(s)                 MFAIL
-    #define MUNMAP(a, s)            (-1)
-    #define DIRECT_MMAP(s)          MFAIL
-    #define CALL_DIRECT_MMAP(s)     DIRECT_MMAP(s)
-    #define CALL_MMAP(s)            MMAP(s)
-    #define CALL_MUNMAP(a, s)       MUNMAP((a), (s))
-#endif /* HAVE_MMAP */
+#ifdef MUNMAP
+#define CALL_MUNMAP(a, s)   MUNMAP((a), (s))
+#else /* MUNMAP */
+#define CALL_MUNMAP(a, s)   MUNMAP_DEFAULT((a), (s))
+#endif /* MUNMAP */
+
+#ifdef DIRECT_MMAP
+#define CALL_DIRECT_MMAP(s) DIRECT_MMAP(s)
+#else /* DIRECT_MMAP */
+#define CALL_DIRECT_MMAP(s) DIRECT_MMAP_DEFAULT(s)
+#endif /* DIRECT_MMAP */
 
 /**
  * Define CALL_MREMAP
  */
-#if HAVE_MMAP && HAVE_MREMAP
-    #ifdef MREMAP
-        #define CALL_MREMAP(addr, osz, nsz, mv) MREMAP((addr), (osz), (nsz), (mv))
-    #else /* MREMAP */
-        #define CALL_MREMAP(addr, osz, nsz, mv) MREMAP_DEFAULT((addr), (osz), (nsz), (mv))
-    #endif /* MREMAP */
-#else  /* HAVE_MMAP && HAVE_MREMAP */
-    #define CALL_MREMAP(addr, osz, nsz, mv)     MFAIL
-#endif /* HAVE_MMAP && HAVE_MREMAP */
+#if HAVE_MREMAP
+    #define CALL_MREMAP(addr, osz, nsz, mv) ({ int olderr = errno; void *res = mremap((addr), (osz), (nsz), (mv)); if (res == MAP_FAILED) errno = olderr; res; })
+#else  /* HAVE_MREMAP */
+    #define CALL_MREMAP(addr, osz, nsz, mv)     MAP_FAILED
+#endif /* HAVE_MREMAP */
 
 /* mstate bit set if continguous morecore disabled or failed */
 #define USE_NONCONTIGUOUS_BIT (4U)
diff --git a/third_party/dlmalloc/runtimechecks.inc b/third_party/dlmalloc/runtimechecks.inc
index df3fd226c..dc86de808 100644
--- a/third_party/dlmalloc/runtimechecks.inc
+++ b/third_party/dlmalloc/runtimechecks.inc
@@ -28,7 +28,7 @@
 */
 
 #if !INSECURE
-/* Check if address a is at least as high as any from MORECORE or MMAP */
+/* Check if address a is at least as high as any from MMAP */
 #define ok_address(M, a) ((char*)(a) >= (M)->least_addr)
 /* Check if address of next chunk n is higher than base chunk p */
 #define ok_next(p, n)    ((char*)(p) < (char*)(n))
diff --git a/third_party/dlmalloc/system.inc b/third_party/dlmalloc/system.inc
index b8fc6ab79..443fdfac9 100644
--- a/third_party/dlmalloc/system.inc
+++ b/third_party/dlmalloc/system.inc
@@ -13,11 +13,7 @@
 
 #define use_mmap(M)           ((M)->mflags &   USE_MMAP_BIT)
 #define enable_mmap(M)        ((M)->mflags |=  USE_MMAP_BIT)
-#if HAVE_MMAP
 #define disable_mmap(M)       ((M)->mflags &= ~USE_MMAP_BIT)
-#else
-#define disable_mmap(M)
-#endif
 
 #define use_noncontiguous(M)  ((M)->mflags &   USE_NONCONTIGUOUS_BIT)
 #define disable_contiguous(M) ((M)->mflags |=  USE_NONCONTIGUOUS_BIT)
@@ -78,11 +74,7 @@ static int has_segment_link(mstate m, msegmentptr ss) {
   }
 }
 
-#ifndef MORECORE_CANNOT_TRIM
 #define should_trim(M,s)  ((s) > (M)->trim_check)
-#else  /* MORECORE_CANNOT_TRIM */
-#define should_trim(M,s)  (0)
-#endif /* MORECORE_CANNOT_TRIM */
 
 /*
   TOP_FOOT_SIZE is padding at the end of a segment, including space
diff --git a/third_party/dlmalloc/threaded.inc b/third_party/dlmalloc/threaded.inc
index 9b87934e8..3dbfb5b35 100644
--- a/third_party/dlmalloc/threaded.inc
+++ b/third_party/dlmalloc/threaded.inc
@@ -18,15 +18,14 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/intrin/magicu.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/intrin/weaken.h"
-#include "libc/macros.internal.h"
-#include "libc/nexgen32e/rdtscp.h"
-#include "libc/nexgen32e/x86feature.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/thread/thread.h"
-#include "libc/runtime/runtime.h"
-#include "libc/intrin/weaken.h"
+#include "libc/thread/threads.h"
+#include "libc/errno.h"
+#include "libc/calls/struct/cpuset.h"
 #include "third_party/dlmalloc/dlmalloc.h"
 
 #if !FOOTERS || !MSPACES
@@ -34,6 +33,7 @@
 #endif
 
 static struct magicu magiu;
+static unsigned g_cpucount;
 static unsigned g_heapslen;
 static mstate g_heaps[128];
 
@@ -61,8 +61,23 @@ int dlmalloc_trim(size_t pad) {
 }
 
 size_t dlbulk_free(void *array[], size_t nelem) {
-  for (size_t i = 0; i < nelem; ++i)
-    mspace_free(0, array[i]);
+  size_t j = 0;
+  mstate msp = (mstate)-1;
+  for (size_t i = 0; i < nelem; ++i) {
+    mstate next;
+    if (array[i]) {
+      next = get_mstate_for(mem2chunk(array[i]));
+      if (next != msp) {
+        if (j)
+          mspace_bulk_free(msp, array, j);
+        msp = next;
+        j = 0;
+      }
+      array[j++] = array[i];
+    }
+  }
+  if (j)
+    mspace_bulk_free(msp, array, j);
   return 0;
 }
 
@@ -90,18 +105,31 @@ void dlmalloc_inspect_all(void handler(void *start, void *end,
   }
 }
 
-forceinline mstate get_arena(void) {
-  unsigned cpu;
-#ifdef __x86_64__
-  unsigned tsc_aux;
-  rdtscp(&tsc_aux);
-  cpu = TSC_AUX_CORE(tsc_aux);
-#else
-  long tpidr_el0;
-  asm("mrs\t%0,tpidr_el0" : "=r"(tpidr_el0));
-  cpu = tpidr_el0 & 255;
-#endif
-  return g_heaps[__magicu_div(cpu, magiu) % g_heapslen];
+// we make malloc() scalable basically by
+//
+//     return g_heaps[sched_getcpu() / 2];
+//
+// except we cache the syscall result using thread-local storage. on
+// some platforms, it's not possible to use sched_getcpu() so we use
+// arbitrary assignments to help scalability, but may not be optimal
+static mstate get_arena(void) {
+  static atomic_uint assign;
+  static thread_local unsigned i;
+  static thread_local unsigned n;
+  if (n == 50)
+    n = 0;
+  if (!n) {
+    int e = errno;
+    i = sched_getcpu();
+    if (i == -1) {
+      errno = e;
+      i = atomic_fetch_add_explicit(&assign, 1, memory_order_relaxed);
+      i %= g_cpucount;
+    }
+    i = __magicu_div(i, magiu) % g_heapslen;
+  }
+  ++n;
+  return g_heaps[i];
 }
 
 static void *dlmalloc_single(size_t n) {
@@ -174,19 +202,18 @@ static void threaded_dlmalloc(void) {
   if (!_weaken(pthread_create))
     return use_single_heap(false);
 
-  if (!IsAarch64() && !X86_HAVE(RDTSCP))
-    return use_single_heap(true);
-
   // determine how many independent heaps we should install
   // by default we do an approximation of one heap per core
   // this code makes the c++ stl go 164x faster on my ryzen
-  cpus = __get_cpu_count();
-  if (cpus == -1)
+  g_cpucount = cpus = __get_cpu_count();
+  if (cpus == -1) {
     heaps = 1;
-  else if ((var = getenv("COSMOPOLITAN_HEAP_COUNT")))
+    g_cpucount = 1;
+  } else if ((var = getenv("COSMOPOLITAN_HEAP_COUNT"))) {
     heaps = dlmalloc_atoi(var);
-  else
+  } else {
     heaps = cpus >> 1;
+  }
   if (heaps <= 1)
     return use_single_heap(true);
   if (heaps > ARRAYLEN(g_heaps))
diff --git a/third_party/double-conversion/BUILD.mk b/third_party/double-conversion/BUILD.mk
index 10da7f072..847f02f5e 100644
--- a/third_party/double-conversion/BUILD.mk
+++ b/third_party/double-conversion/BUILD.mk
@@ -34,7 +34,8 @@ THIRD_PARTY_DOUBLECONVERSION_A_DIRECTDEPS =					\
 	LIBC_MEM								\
 	LIBC_STR								\
 	LIBC_TINYMATH								\
-	THIRD_PARTY_LIBCXXABI
+	THIRD_PARTY_LIBCXXABI							\
+	THIRD_PARTY_LIBUNWIND
 
 THIRD_PARTY_DOUBLECONVERSION_A_DEPS :=						\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_DOUBLECONVERSION_A_DIRECTDEPS),$($(x))))
diff --git a/third_party/finger/util.c b/third_party/finger/util.c
index 14a544d64..7de3544b9 100644
--- a/third_party/finger/util.c
+++ b/third_party/finger/util.c
@@ -43,6 +43,7 @@
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/o.h"
+#include "libc/ctype.h"
 #include "third_party/finger/finger.h"
 
 #ifndef lint
diff --git a/third_party/gdtoa/dmisc.c b/third_party/gdtoa/dmisc.c
index a0871ddec..8f5b55a84 100644
--- a/third_party/gdtoa/dmisc.c
+++ b/third_party/gdtoa/dmisc.c
@@ -49,6 +49,8 @@ __gdtoa_rv_alloc(int i, ThInfo **PTI)
 	     j <<= 1)
 		k++;
 	r = (int *)__gdtoa_Balloc(k, PTI);
+	if (r == NULL)
+		return NULL;
 	*r = k;
 	return (char *)(r + 1);
 }
diff --git a/third_party/gdtoa/dtoa.c b/third_party/gdtoa/dtoa.c
index 6982c73b0..a6eafc70e 100644
--- a/third_party/gdtoa/dtoa.c
+++ b/third_party/gdtoa/dtoa.c
@@ -246,6 +246,9 @@ dtoa(double d0, int mode, int ndigits, int *decpt, int *sign, char **rve)
 			i = 1;
 	}
 	s = s0 = __gdtoa_rv_alloc(i, &TI);
+	if (s0 == NULL)
+		goto ret1;
+
 	if (mode > 1 && Rounding != 1)
 		leftright = 0;
 	if (ilim >= 0 && ilim <= Quick_max && try_quick) {
@@ -614,7 +617,8 @@ retc:
 		--s;
 ret1:
 	__gdtoa_Bfree(b, &TI);
-	*s = 0;
+	if (s != NULL)
+		*s = 0;
 	*decpt = k + 1;
 	if (rve)
 		*rve = s;
diff --git a/third_party/gdtoa/gdtoa.c b/third_party/gdtoa/gdtoa.c
index 67199c53d..aba7358c2 100644
--- a/third_party/gdtoa/gdtoa.c
+++ b/third_party/gdtoa/gdtoa.c
@@ -286,12 +286,16 @@ gdtoa(const FPI *fpi, int be, ULong *bits, int *kindp, int mode, int ndigits, in
 			i = 1;
 	}
 	s = s0 = __gdtoa_rv_alloc(i, &TI);
+	if (s0 == NULL)
+		goto ret1;
 	if (mode <= 1)
 		rdir = 0;
 	else if ( (rdir = fpi->rounding - 1) !=0) {
 		if (rdir < 0)
 			rdir = 2;
-		if (kind & STRTOG_Neg)
+		// note that we check for fpi->rounding == 0 as in that case we
+		// must *always* round towards 0, i.e. downwards, with rdir = 2
+		if (kind & STRTOG_Neg && fpi->rounding != 0)
 			rdir = 3 - rdir;
 	}
 	/* Now rdir = 0 ==> round near, 1 ==> round up, 2 ==> round down. */
@@ -673,10 +677,12 @@ ret:
 		__gdtoa_Bfree(mhi, &TI);
 	}
 ret1:
-	while(s > s0 && s[-1] == '0')
-		--s;
+	if (s != NULL)
+		while(s > s0 && s[-1] == '0')
+			--s;
 	__gdtoa_Bfree(b, &TI);
-	*s = 0;
+	if (s != NULL)
+		*s = 0;
 	*decpt = k + 1;
 	if (rve)
 		*rve = s;
diff --git a/third_party/gdtoa/gethex.c b/third_party/gdtoa/gethex.c
index 36f5cf751..22fd02d23 100644
--- a/third_party/gdtoa/gethex.c
+++ b/third_party/gdtoa/gethex.c
@@ -169,7 +169,9 @@ pcheck:
 			L = 0;
 			n = 0;
 		}
-		L |= (__gdtoa_hexdig[*s1] & 0x0f) << n;
+		// We can shift in a way that changes the sign bit or overflows,
+		// so we need to cast to unsigned to avoid undefined behavior
+		L |= (unsigned)(__gdtoa_hexdig[*s1] & 0x0f) << n;
 		n += 4;
 	}
 	*x++ = L;
diff --git a/third_party/gdtoa/lock.c b/third_party/gdtoa/lock.c
new file mode 100644
index 000000000..1e5cc36de
--- /dev/null
+++ b/third_party/gdtoa/lock.c
@@ -0,0 +1,72 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  The author of this software is David M. Gay.                                │
+│  Please send bug reports to David M. Gay <dmg@acm.org>                       │
+│                          or Justine Tunney <jtunney@gmail.com>               │
+│                                                                              │
+│  Copyright (C) 1998, 1999 by Lucent Technologies                             │
+│  All Rights Reserved                                                         │
+│                                                                              │
+│  Permission to use, copy, modify, and distribute this software and           │
+│  its documentation for any purpose and without fee is hereby                 │
+│  granted, provided that the above copyright notice appear in all             │
+│  copies and that both that the copyright notice and this                     │
+│  permission notice and warranty disclaimer appear in supporting              │
+│  documentation, and that the name of Lucent or any of its entities           │
+│  not be used in advertising or publicity pertaining to                       │
+│  distribution of the software without specific, written prior                │
+│  permission.                                                                 │
+│                                                                              │
+│  LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,               │
+│  INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.            │
+│  IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY           │
+│  SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES                   │
+│  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER             │
+│  IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,              │
+│  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF              │
+│  THIS SOFTWARE.                                                              │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/thread/posixthread.internal.h"
+#include "third_party/gdtoa/lock.h"
+
+static pthread_mutex_t __gdtoa_lock_obj = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t __gdtoa_lock1_obj = PTHREAD_MUTEX_INITIALIZER;
+
+void
+__gdtoa_lock(void)
+{
+	_pthread_mutex_lock(&__gdtoa_lock_obj);
+}
+
+void
+__gdtoa_unlock(void)
+{
+	_pthread_mutex_unlock(&__gdtoa_lock_obj);
+}
+
+void
+__gdtoa_wipe(void)
+{
+	_pthread_mutex_wipe_np(&__gdtoa_lock_obj);
+}
+
+void
+__gdtoa_lock1(void)
+{
+	_pthread_mutex_lock(&__gdtoa_lock1_obj);
+}
+
+void
+__gdtoa_unlock1(void)
+{
+	_pthread_mutex_unlock(&__gdtoa_lock1_obj);
+}
+
+void
+__gdtoa_wipe1(void)
+{
+	_pthread_mutex_wipe_np(&__gdtoa_lock1_obj);
+}
diff --git a/third_party/gdtoa/lock.h b/third_party/gdtoa/lock.h
new file mode 100644
index 000000000..71af847aa
--- /dev/null
+++ b/third_party/gdtoa/lock.h
@@ -0,0 +1,15 @@
+#ifndef COSMOPOLITAN_THIRD_PARTY_GDTOA_LOCK_H_
+#define COSMOPOLITAN_THIRD_PARTY_GDTOA_LOCK_H_
+#include "libc/thread/thread.h"
+COSMOPOLITAN_C_START_
+
+void __gdtoa_lock(void);
+void __gdtoa_unlock(void);
+void __gdtoa_wipe(void);
+
+void __gdtoa_lock1(void);
+void __gdtoa_unlock1(void);
+void __gdtoa_wipe1(void);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_THIRD_PARTY_GDTOA_LOCK_H_ */
diff --git a/third_party/gdtoa/misc.c b/third_party/gdtoa/misc.c
index 75d3883d8..2d3809a9c 100644
--- a/third_party/gdtoa/misc.c
+++ b/third_party/gdtoa/misc.c
@@ -30,51 +30,14 @@
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 #include "third_party/gdtoa/gdtoa.internal.h"
+#include "third_party/gdtoa/lock.h"
 
 static ThInfo TI0;
-static pthread_mutex_t __gdtoa_lock_obj;
-static pthread_mutex_t __gdtoa_lock1_obj;
-
-static void
-__gdtoa_lock(void)
-{
-	pthread_mutex_lock(&__gdtoa_lock_obj);
-}
-
-static void
-__gdtoa_unlock(void)
-{
-	pthread_mutex_unlock(&__gdtoa_lock_obj);
-}
-
-static void
-__gdtoa_initlock(void)
-{
-	pthread_mutex_init(&__gdtoa_lock_obj, 0);
-}
-
-static void
-__gdtoa_lock1(void)
-{
-	pthread_mutex_lock(&__gdtoa_lock1_obj);
-}
-
-static void
-__gdtoa_unlock1(void)
-{
-	pthread_mutex_unlock(&__gdtoa_lock1_obj);
-}
-
-static void
-__gdtoa_initlock1(void)
-{
-	pthread_mutex_init(&__gdtoa_lock1_obj, 0);
-}
 
 static void
 __gdtoa_Brelease(Bigint *rv)
@@ -88,24 +51,20 @@ static void
 __gdtoa_Bclear(void)
 {
 	int i;
-	__gdtoa_lock();
+	__gdtoa_lock1();
 	for (i = 0; i < ARRAYLEN(TI0.Freelist); ++i)
 		__gdtoa_Brelease(TI0.Freelist[i]);
-	__gdtoa_lock1();
+	__gdtoa_lock();
 	__gdtoa_Brelease(TI0.P5s);
-	__gdtoa_unlock1();
-	bzero(&TI0, sizeof(TI0));
 	__gdtoa_unlock();
+	bzero(&TI0, sizeof(TI0));
+	__gdtoa_unlock1();
 }
 
 __attribute__((__constructor__(60))) static void
 __gdtoa_Binit(void)
 {
-	__gdtoa_initlock();
-	__gdtoa_initlock1();
 	atexit(__gdtoa_Bclear);
-	pthread_atfork(__gdtoa_lock1, __gdtoa_unlock1, __gdtoa_initlock1);
-	pthread_atfork(__gdtoa_lock, __gdtoa_unlock, __gdtoa_initlock);
 }
 
 static ThInfo *
@@ -129,12 +88,16 @@ __gdtoa_Balloc(int k, ThInfo **PTI)
 	} else {
 		x = 1 << k;
 		rv = malloc(sizeof(Bigint) + (x-1)*sizeof(ULong));
+		if (rv == NULL)
+			goto ret;
 		rv->k = k;
 		rv->maxwds = x;
 	}
+	rv->sign = rv->wds = 0;
+
+ret:
 	if (TI == &TI0)
 		__gdtoa_unlock();
-	rv->sign = rv->wds = 0;
 	return rv;
 }
 
diff --git a/third_party/hiredis/async.c b/third_party/hiredis/async.c
index b6c721d45..23220df77 100644
--- a/third_party/hiredis/async.c
+++ b/third_party/hiredis/async.c
@@ -56,6 +56,7 @@
 #include "third_party/hiredis/async.h"
 #include "third_party/hiredis/net.h"
 #include "third_party/hiredis/dict.c"
+#include "libc/ctype.h"
 #include "third_party/hiredis/sds.h"
 
 #include "third_party/hiredis/async_private.inc"
diff --git a/third_party/hiredis/hiredis.c b/third_party/hiredis/hiredis.c
index 372da65d9..67c2185ac 100644
--- a/third_party/hiredis/hiredis.c
+++ b/third_party/hiredis/hiredis.c
@@ -51,6 +51,7 @@
 #include "libc/assert.h"
 #include "libc/errno.h"
 #include "libc/mem/gc.h"
+#include "libc/ctype.h"
 #include "libc/str/str.h"
 
 #include "third_party/hiredis/hiredis.h"
diff --git a/third_party/hiredis/read.c b/third_party/hiredis/read.c
index a907520a5..86aa95920 100644
--- a/third_party/hiredis/read.c
+++ b/third_party/hiredis/read.c
@@ -73,6 +73,7 @@
 #include "libc/sysv/consts/limits.h"
 #include "libc/sysv/consts/xopen.h"
 #include "libc/thread/thread.h"
+#include "libc/ctype.h"
 #include "libc/math.h"
 
 #include "third_party/hiredis/alloc.h"
diff --git a/third_party/hiredis/sds.c b/third_party/hiredis/sds.c
index 1e7b108e9..75ab85089 100644
--- a/third_party/hiredis/sds.c
+++ b/third_party/hiredis/sds.c
@@ -62,6 +62,7 @@
 #include "libc/sysv/consts/xopen.h"
 #include "libc/thread/thread.h"
 #include "third_party/hiredis/sds.h"
+#include "libc/ctype.h"
 #include "third_party/hiredis/sdsalloc.h"
 
 #pragma GCC diagnostic ignored "-Wstringop-overflow"
diff --git a/third_party/intel/BUILD.mk b/third_party/intel/BUILD.mk
index fb82e1fbc..7c810ce96 100644
--- a/third_party/intel/BUILD.mk
+++ b/third_party/intel/BUILD.mk
@@ -3,4 +3,4 @@
 
 PKGS += THIRD_PARTY_INTEL
 THIRD_PARTY_INTEL_HDRS = $(filter %.h,$(THIRD_PARTY_INTEL_FILES))
-THIRD_PARTY_INTEL_FILES := $(wildcard third_party/intel/*)
+THIRD_PARTY_INTEL_FILES := $(wildcard third_party/intel/*) $(wildcard third_party/intel/clang/*)
diff --git a/third_party/intel/amxcomplexintrin.internal.h b/third_party/intel/amxcomplexintrin.internal.h
new file mode 100644
index 000000000..72f8bd383
--- /dev/null
+++ b/third_party/intel/amxcomplexintrin.internal.h
@@ -0,0 +1,23 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#if !defined _IMMINTRIN_H_INCLUDED
+#error "Never use <amxcomplexintrin.h> directly; include <immintrin.h> instead."
+#endif
+#ifndef _AMXCOMPLEXINTRIN_H_INCLUDED
+#define _AMXCOMPLEXINTRIN_H_INCLUDED
+#if !defined(__AMX_COMPLEX__)
+#pragma GCC push_options
+#pragma GCC target("amx-complex")
+#define __DISABLE_AMX_COMPLEX__
+#endif
+#if defined(__x86_64__)
+#define _tile_cmmimfp16ps_internal(src1_dst,src2,src3) __asm__ volatile ("{tcmmimfp16ps\t%%tmm"#src3", %%tmm"#src2", %%tmm"#src1_dst"|tcmmimfp16ps\t%%tmm"#src1_dst", %%tmm"#src2", %%tmm"#src3"}" ::)
+#define _tile_cmmrlfp16ps_internal(src1_dst,src2,src3) __asm__ volatile ("{tcmmrlfp16ps\t%%tmm"#src3", %%tmm"#src2", %%tmm"#src1_dst"|tcmmrlfp16ps\t%%tmm"#src1_dst", %%tmm"#src2", %%tmm"#src3"}" ::)
+#define _tile_cmmimfp16ps(src1_dst,src2,src3) _tile_cmmimfp16ps_internal (src1_dst, src2, src3)
+#define _tile_cmmrlfp16ps(src1_dst,src2,src3) _tile_cmmrlfp16ps_internal (src1_dst, src2, src3)
+#endif
+#ifdef __DISABLE_AMX_COMPLEX__
+#undef __DISABLE_AMX_COMPLEX__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/amxfp16intrin.internal.h b/third_party/intel/amxfp16intrin.internal.h
new file mode 100644
index 000000000..b9c3dfb51
--- /dev/null
+++ b/third_party/intel/amxfp16intrin.internal.h
@@ -0,0 +1,16 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#if !defined _IMMINTRIN_H_INCLUDED
+#error "Never use <amxfp16intrin.h> directly; include <immintrin.h> instead."
+#endif
+#ifndef _AMXFP16INTRIN_H_INCLUDED
+#define _AMXFP16INTRIN_H_INCLUDED
+#if defined(__x86_64__)
+#define _tile_dpfp16ps_internal(dst,src1,src2) __asm__ volatile ("{tdpfp16ps\t%%tmm"#src2", %%tmm"#src1", %%tmm"#dst"|tdpfp16ps\t%%tmm"#dst", %%tmm"#src1", %%tmm"#src2"}" ::)
+#define _tile_dpfp16ps(dst,src1,src2) _tile_dpfp16ps_internal (dst,src1,src2)
+#endif
+#ifdef __DISABLE_AMX_FP16__
+#undef __DISABLE_AMX_FP16__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/amxtileintrin.internal.h b/third_party/intel/amxtileintrin.internal.h
index 00e403118..37b49d3a2 100644
--- a/third_party/intel/amxtileintrin.internal.h
+++ b/third_party/intel/amxtileintrin.internal.h
@@ -14,13 +14,13 @@ extern __inline void
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _tile_loadconfig (const void *__config)
 {
-  __asm__ volatile ("ldtilecfg\t%X0" :: "m" (*((const void **)__config)));
+  __builtin_ia32_ldtilecfg (__config);
 }
 extern __inline void
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _tile_storeconfig (void *__config)
 {
-  __asm__ volatile ("sttilecfg\t%X0" : "=m" (*((void **)__config)));
+  __builtin_ia32_sttilecfg (__config);
 }
 extern __inline void
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -29,11 +29,11 @@ _tile_release (void)
   __asm__ volatile ("tilerelease" ::);
 }
 #define _tile_loadd(dst,base,stride) _tile_loadd_internal (dst, base, stride)
-#define _tile_loadd_internal(dst,base,stride) __asm__ volatile ("{tileloadd\t(%0,%1,1), %%tmm"#dst"|tileloadd\t%%tmm"#dst", [%0+%1*1]}" :: "r" ((const void*) (base)), "r" ((long) (stride)))
+#define _tile_loadd_internal(dst,base,stride) __asm__ volatile ("{tileloadd\t(%0,%1,1), %%tmm"#dst"|tileloadd\t%%tmm"#dst", [%0+%1*1]}" :: "r" ((const void*) (base)), "r" ((__PTRDIFF_TYPE__) (stride)))
 #define _tile_stream_loadd(dst,base,stride) _tile_stream_loadd_internal (dst, base, stride)
-#define _tile_stream_loadd_internal(dst,base,stride) __asm__ volatile ("{tileloaddt1\t(%0,%1,1), %%tmm"#dst"|tileloaddt1\t%%tmm"#dst", [%0+%1*1]}" :: "r" ((const void*) (base)), "r" ((long) (stride)))
+#define _tile_stream_loadd_internal(dst,base,stride) __asm__ volatile ("{tileloaddt1\t(%0,%1,1), %%tmm"#dst"|tileloaddt1\t%%tmm"#dst", [%0+%1*1]}" :: "r" ((const void*) (base)), "r" ((__PTRDIFF_TYPE__) (stride)))
 #define _tile_stored(dst,base,stride) _tile_stored_internal (dst, base, stride)
-#define _tile_stored_internal(src,base,stride) __asm__ volatile ("{tilestored\t%%tmm"#src", (%0,%1,1)|tilestored\t[%0+%1*1], %%tmm"#src"}" :: "r" ((void*) (base)), "r" ((long) (stride)) : "memory")
+#define _tile_stored_internal(src,base,stride) __asm__ volatile ("{tilestored\t%%tmm"#src", (%0,%1,1)|tilestored\t[%0+%1*1], %%tmm"#src"}" :: "r" ((void*) (base)), "r" ((__PTRDIFF_TYPE__) (stride)) : "memory")
 #define _tile_zero(dst) _tile_zero_internal (dst)
 #define _tile_zero_internal(dst) __asm__ volatile ("tilezero\t%%tmm"#dst ::)
 #endif
diff --git a/third_party/intel/avx2intrin.internal.h b/third_party/intel/avx2intrin.internal.h
index e323cf2fd..e84ddfcda 100644
--- a/third_party/intel/avx2intrin.internal.h
+++ b/third_party/intel/avx2intrin.internal.h
@@ -1443,6 +1443,206 @@ _mm256_mask_i64gather_epi32 (__m128i __src, int const *__base,
 #define _mm256_i64gather_epi32(BASE, INDEX, SCALE) (__m128i) __builtin_ia32_gatherdiv4si256 ((__v4si) _mm_setzero_si128 (), (int const *) (BASE), (__v4di)(__m256i) (INDEX), (__v4si)_mm_set1_epi32(-1), (int) (SCALE))
 #define _mm256_mask_i64gather_epi32(SRC, BASE, INDEX, MASK, SCALE) (__m128i) __builtin_ia32_gatherdiv4si256 ((__v4si)(__m128i) (SRC), (int const *) (BASE), (__v4di)(__m256i) (INDEX), (__v4si)(__m128i) (MASK), (int) (SCALE))
 #endif
+#define _MM_REDUCE_OPERATOR_BASIC_EPI16(op) __v8hi __T1 = (__v8hi)__W; __v8hi __T2 = __builtin_shufflevector (__T1, __T1, 4, 5, 6, 7, 4, 5, 6, 7); __v8hi __T3 = __T1 op __T2; __v8hi __T4 = __builtin_shufflevector (__T3, __T3, 2, 3, 2, 3, 4, 5, 6, 7); __v8hi __T5 = __T3 op __T4; __v8hi __T6 = __builtin_shufflevector (__T5, __T5, 1, 1, 2, 3, 4, 5, 6, 7); __v8hi __T7 = __T5 op __T6; return __T7[0]
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_add_epi16 (__m128i __W)
+{
+  _MM_REDUCE_OPERATOR_BASIC_EPI16 (+);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_mul_epi16 (__m128i __W)
+{
+  _MM_REDUCE_OPERATOR_BASIC_EPI16 (*);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_and_epi16 (__m128i __W)
+{
+  _MM_REDUCE_OPERATOR_BASIC_EPI16 (&);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_or_epi16 (__m128i __W)
+{
+  _MM_REDUCE_OPERATOR_BASIC_EPI16 (|);
+}
+#define _MM_REDUCE_OPERATOR_MAX_MIN_EP16(op) __m128i __T1 = (__m128i)__builtin_shufflevector ((__v8hi)__V, (__v8hi)__V, 4, 5, 6, 7, 4, 5, 6, 7); __m128i __T2 = _mm_##op (__V, __T1); __m128i __T3 = (__m128i)__builtin_shufflevector ((__v8hi)__T2, (__v8hi)__T2, 2, 3, 2, 3, 4, 5, 6, 7); __m128i __T4 = _mm_##op (__T2, __T3); __m128i __T5 = (__m128i)__builtin_shufflevector ((__v8hi)__T4, (__v8hi)__T4, 1, 1, 2, 3, 4, 5, 6, 7); __v8hi __T6 = (__v8hi)_mm_##op (__T4, __T5); return __T6[0]
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_max_epi16 (__m128i __V)
+{
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP16 (max_epi16);
+}
+extern __inline unsigned short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_max_epu16 (__m128i __V)
+{
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP16 (max_epu16);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_min_epi16 (__m128i __V)
+{
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP16 (min_epi16);
+}
+extern __inline unsigned short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_min_epu16 (__m128i __V)
+{
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP16 (min_epu16);
+}
+#define _MM256_REDUCE_OPERATOR_BASIC_EPI16(op) __v8hi __T1 = (__v8hi)_mm256_extracti128_si256 (__W, 0); __v8hi __T2 = (__v8hi)_mm256_extracti128_si256 (__W, 1); __v8hi __T3 = __T1 op __T2; __v8hi __T4 = __builtin_shufflevector (__T3, __T3, 4, 5, 6, 7, 4, 5, 6, 7); __v8hi __T5 = __T3 op __T4; __v8hi __T6 = __builtin_shufflevector (__T5, __T5, 2, 3, 2, 3, 4, 5, 6, 7); __v8hi __T7 = __T5 op __T6; __v8hi __T8 = __builtin_shufflevector (__T7, __T7, 1, 1, 2, 3, 4, 5, 6, 7); __v8hi __T9 = __T7 op __T8; return __T9[0]
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_add_epi16 (__m256i __W)
+{
+  _MM256_REDUCE_OPERATOR_BASIC_EPI16 (+);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_mul_epi16 (__m256i __W)
+{
+  _MM256_REDUCE_OPERATOR_BASIC_EPI16 (*);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_and_epi16 (__m256i __W)
+{
+  _MM256_REDUCE_OPERATOR_BASIC_EPI16 (&);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_or_epi16 (__m256i __W)
+{
+  _MM256_REDUCE_OPERATOR_BASIC_EPI16 (|);
+}
+#define _MM256_REDUCE_OPERATOR_MAX_MIN_EP16(op) __m128i __T1 = _mm256_extracti128_si256 (__V, 0); __m128i __T2 = _mm256_extracti128_si256 (__V, 1); __m128i __T3 = _mm_##op (__T1, __T2); __m128i __T4 = (__m128i)__builtin_shufflevector ((__v8hi)__T3, (__v8hi)__T3, 4, 5, 6, 7, 4, 5, 6, 7); __m128i __T5 = _mm_##op (__T3, __T4); __m128i __T6 = (__m128i)__builtin_shufflevector ((__v8hi)__T5, (__v8hi)__T5, 2, 3, 2, 3, 4, 5, 6, 7); __m128i __T7 = _mm_##op (__T5, __T6); __m128i __T8 = (__m128i)__builtin_shufflevector ((__v8hi)__T7, (__v8hi)__T7, 1, 1, 2, 3, 4, 5, 6, 7); __v8hi __T9 = (__v8hi)_mm_##op (__T7, __T8); return __T9[0]
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_max_epi16 (__m256i __V)
+{
+  _MM256_REDUCE_OPERATOR_MAX_MIN_EP16 (max_epi16);
+}
+extern __inline unsigned short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_max_epu16 (__m256i __V)
+{
+  _MM256_REDUCE_OPERATOR_MAX_MIN_EP16 (max_epu16);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_min_epi16 (__m256i __V)
+{
+  _MM256_REDUCE_OPERATOR_MAX_MIN_EP16 (min_epi16);
+}
+extern __inline unsigned short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_min_epu16 (__m256i __V)
+{
+  _MM256_REDUCE_OPERATOR_MAX_MIN_EP16 (min_epu16);
+}
+#define _MM_REDUCE_OPERATOR_BASIC_EPI8(op) __v16qi __T1 = (__v16qi)__W; __v16qi __T2 = __builtin_shufflevector (__T1, __T1, 8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T3 = __T1 op __T2; __v16qi __T4 = __builtin_shufflevector (__T3, __T3, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T5 = __T3 op __T4; __v16qi __T6 = __builtin_shufflevector (__T5, __T5, 2, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T7 = __T5 op __T6; __v16qi __T8 = __builtin_shufflevector (__T7, __T7, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T9 = __T7 op __T8; return __T9[0]
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_add_epi8 (__m128i __W)
+{
+  _MM_REDUCE_OPERATOR_BASIC_EPI8 (+);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_mul_epi8 (__m128i __W)
+{
+  _MM_REDUCE_OPERATOR_BASIC_EPI8 (*);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_and_epi8 (__m128i __W)
+{
+  _MM_REDUCE_OPERATOR_BASIC_EPI8 (&);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_or_epi8 (__m128i __W)
+{
+  _MM_REDUCE_OPERATOR_BASIC_EPI8 (|);
+}
+#define _MM_REDUCE_OPERATOR_MAX_MIN_EP8(op) __m128i __T1 = (__m128i)__builtin_shufflevector ((__v16qi)__V, (__v16qi)__V, 8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15); __m128i __T2 = _mm_##op (__V, __T1); __m128i __T3 = (__m128i)__builtin_shufflevector ((__v16qi)__T2, (__v16qi)__T2, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __m128i __T4 = _mm_##op (__T2, __T3); __m128i __T5 = (__m128i)__builtin_shufflevector ((__v16qi)__T4, (__v16qi)__T4, 2, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __m128i __T6 = _mm_##op (__T4, __T5); __m128i __T7 = (__m128i)__builtin_shufflevector ((__v16qi)__T6, (__v16qi)__T6, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T8 = (__v16qi)_mm_##op (__T6, __T7); return __T8[0]
+extern __inline signed char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_max_epi8 (__m128i __V)
+{
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP8 (max_epi8);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_max_epu8 (__m128i __V)
+{
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP8 (max_epu8);
+}
+extern __inline signed char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_min_epi8 (__m128i __V)
+{
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP8 (min_epi8);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_min_epu8 (__m128i __V)
+{
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP8 (min_epu8);
+}
+#define _MM256_REDUCE_OPERATOR_BASIC_EPI8(op) __v16qi __T1 = (__v16qi)_mm256_extracti128_si256 (__W, 0); __v16qi __T2 = (__v16qi)_mm256_extracti128_si256 (__W, 1); __v16qi __T3 = __T1 op __T2; __v16qi __T4 = __builtin_shufflevector (__T3, __T3, 8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T5 = __T3 op __T4; __v16qi __T6 = __builtin_shufflevector (__T5, __T5, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T7 = __T5 op __T6; __v16qi __T8 = __builtin_shufflevector (__T7, __T7, 2, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T9 = __T7 op __T8; __v16qi __T10 = __builtin_shufflevector (__T9, __T9, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T11 = __T9 op __T10; return __T11[0]
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_add_epi8 (__m256i __W)
+{
+  _MM256_REDUCE_OPERATOR_BASIC_EPI8 (+);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_mul_epi8 (__m256i __W)
+{
+  _MM256_REDUCE_OPERATOR_BASIC_EPI8 (*);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_and_epi8 (__m256i __W)
+{
+  _MM256_REDUCE_OPERATOR_BASIC_EPI8 (&);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_or_epi8 (__m256i __W)
+{
+  _MM256_REDUCE_OPERATOR_BASIC_EPI8 (|);
+}
+#define _MM256_REDUCE_OPERATOR_MAX_MIN_EP8(op) __m128i __T1 = _mm256_extracti128_si256 (__V, 0); __m128i __T2 = _mm256_extracti128_si256 (__V, 1); __m128i __T3 = _mm_##op (__T1, __T2); __m128i __T4 = (__m128i)__builtin_shufflevector ((__v16qi)__T3, (__v16qi)__T3, 8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15); __m128i __T5 = _mm_##op (__T3, __T4); __m128i __T6 = (__m128i)__builtin_shufflevector ((__v16qi)__T5, (__v16qi)__T5, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __m128i __T7 = _mm_##op (__T5, __T6); __m128i __T8 = (__m128i)__builtin_shufflevector ((__v16qi)__T7, (__v16qi)__T5, 2, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __m128i __T9 = _mm_##op (__T7, __T8); __m128i __T10 = (__m128i)__builtin_shufflevector ((__v16qi)__T9, (__v16qi)__T9, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T11 = (__v16qi)_mm_##op (__T9, __T10); return __T11[0]
+extern __inline signed char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_max_epi8 (__m256i __V)
+{
+  _MM256_REDUCE_OPERATOR_MAX_MIN_EP8 (max_epi8);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_max_epu8 (__m256i __V)
+{
+  _MM256_REDUCE_OPERATOR_MAX_MIN_EP8 (max_epu8);
+}
+extern __inline signed char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_min_epi8 (__m256i __V)
+{
+  _MM256_REDUCE_OPERATOR_MAX_MIN_EP8 (min_epi8);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_reduce_min_epu8 (__m256i __V)
+{
+  _MM256_REDUCE_OPERATOR_MAX_MIN_EP8 (min_epu8);
+}
 #ifdef __DISABLE_AVX2__
 #undef __DISABLE_AVX2__
 #pragma GCC pop_options
diff --git a/third_party/intel/avx5124fmapsintrin.internal.h b/third_party/intel/avx5124fmapsintrin.internal.h
index 7134f1227..acd03b5e6 100644
--- a/third_party/intel/avx5124fmapsintrin.internal.h
+++ b/third_party/intel/avx5124fmapsintrin.internal.h
@@ -6,7 +6,7 @@
 #define _AVX5124FMAPSINTRIN_H_INCLUDED
 #ifndef __AVX5124FMAPS__
 #pragma GCC push_options
-#pragma GCC target("avx5124fmaps")
+#pragma GCC target("avx5124fmaps,evex512")
 #define __DISABLE_AVX5124FMAPS__
 #endif
 extern __inline __m512
diff --git a/third_party/intel/avx5124vnniwintrin.internal.h b/third_party/intel/avx5124vnniwintrin.internal.h
index b94ca1d2f..247c0f633 100644
--- a/third_party/intel/avx5124vnniwintrin.internal.h
+++ b/third_party/intel/avx5124vnniwintrin.internal.h
@@ -6,7 +6,7 @@
 #define _AVX5124VNNIWINTRIN_H_INCLUDED
 #ifndef __AVX5124VNNIW__
 #pragma GCC push_options
-#pragma GCC target("avx5124vnniw")
+#pragma GCC target("avx5124vnniw,evex512")
 #define __DISABLE_AVX5124VNNIW__
 #endif
 extern __inline __m512i
diff --git a/third_party/intel/avx512bf16intrin.internal.h b/third_party/intel/avx512bf16intrin.internal.h
index 5bc3f8358..d4c79624d 100644
--- a/third_party/intel/avx512bf16intrin.internal.h
+++ b/third_party/intel/avx512bf16intrin.internal.h
@@ -4,38 +4,45 @@
 #endif
 #ifndef _AVX512BF16INTRIN_H_INCLUDED
 #define _AVX512BF16INTRIN_H_INCLUDED
-#ifndef __AVX512BF16__
+#if !defined (__AVX512BF16__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512bf16")
+#pragma GCC target("avx512bf16,no-evex512")
 #define __DISABLE_AVX512BF16__
 #endif
-typedef short __v32bh __attribute__ ((__vector_size__ (64)));
-typedef short __m512bh __attribute__ ((__vector_size__ (64), __may_alias__));
 extern __inline float
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsbh_ss (__bfloat16 __A)
+_mm_cvtsbh_ss (__bf16 __A)
 {
-  union{ float a; unsigned int b;} __tmp;
-  __tmp.b = ((unsigned int)(__A)) << 16;
-  return __tmp.a;
+  return __builtin_ia32_cvtbf2sf (__A);
 }
+#ifdef __DISABLE_AVX512BF16__
+#undef __DISABLE_AVX512BF16__
+#pragma GCC pop_options
+#endif
+#if !defined (__AVX512BF16__) || !defined (__EVEX512__)
+#pragma GCC push_options
+#pragma GCC target("avx512bf16,evex512")
+#define __DISABLE_AVX512BF16_512__
+#endif
+typedef __bf16 __v32bf __attribute__ ((__vector_size__ (64)));
+typedef __bf16 __m512bh __attribute__ ((__vector_size__ (64), __may_alias__));
 extern __inline __m512bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_cvtne2ps_pbh (__m512 __A, __m512 __B)
 {
-  return (__m512bh)__builtin_ia32_cvtne2ps2bf16_v32hi(__A, __B);
+  return (__m512bh)__builtin_ia32_cvtne2ps2bf16_v32bf(__A, __B);
 }
 extern __inline __m512bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mask_cvtne2ps_pbh (__m512bh __A, __mmask32 __B, __m512 __C, __m512 __D)
 {
-  return (__m512bh)__builtin_ia32_cvtne2ps2bf16_v32hi_mask(__C, __D, __A, __B);
+  return (__m512bh)__builtin_ia32_cvtne2ps2bf16_v32bf_mask(__C, __D, __A, __B);
 }
 extern __inline __m512bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_maskz_cvtne2ps_pbh (__mmask32 __A, __m512 __B, __m512 __C)
 {
-  return (__m512bh)__builtin_ia32_cvtne2ps2bf16_v32hi_maskz(__B, __C, __A);
+  return (__m512bh)__builtin_ia32_cvtne2ps2bf16_v32bf_maskz(__B, __C, __A);
 }
 extern __inline __m256bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -96,8 +103,8 @@ _mm512_mask_cvtpbh_ps (__m512 __S, __mmask16 __U, __m256bh __A)
   (__m512i)__S, (__mmask16)__U,
   (__m512i)_mm512_cvtepi16_epi32 ((__m256i)__A), 16)));
 }
-#ifdef __DISABLE_AVX512BF16__
-#undef __DISABLE_AVX512BF16__
+#ifdef __DISABLE_AVX512BF16_512__
+#undef __DISABLE_AVX512BF16_512__
 #pragma GCC pop_options
 #endif
 #endif
diff --git a/third_party/intel/avx512bf16vlintrin.internal.h b/third_party/intel/avx512bf16vlintrin.internal.h
index 216196fcf..5d441b6dd 100644
--- a/third_party/intel/avx512bf16vlintrin.internal.h
+++ b/third_party/intel/avx512bf16vlintrin.internal.h
@@ -4,57 +4,85 @@
 #endif
 #ifndef _AVX512BF16VLINTRIN_H_INCLUDED
 #define _AVX512BF16VLINTRIN_H_INCLUDED
-#if !defined(__AVX512VL__) || !defined(__AVX512BF16__)
+#if !defined(__AVX512VL__) || !defined(__AVX512BF16__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512bf16,avx512vl")
+#pragma GCC target("avx512bf16,avx512vl,no-evex512")
 #define __DISABLE_AVX512BF16VL__
 #endif
-typedef short __v16bh __attribute__ ((__vector_size__ (32)));
-typedef short __v8bh __attribute__ ((__vector_size__ (16)));
-typedef short __m256bh __attribute__ ((__vector_size__ (32), __may_alias__));
-typedef short __m128bh __attribute__ ((__vector_size__ (16), __may_alias__));
-typedef unsigned short __bfloat16;
+typedef __bf16 __v16bf __attribute__ ((__vector_size__ (32)));
+typedef __bf16 __v8bf __attribute__ ((__vector_size__ (16)));
+typedef __bf16 __m256bh __attribute__ ((__vector_size__ (32), __may_alias__));
+typedef __bf16 __m128bh __attribute__ ((__vector_size__ (16), __may_alias__));
+typedef __bf16 __bfloat16;
+extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_castsi128_ps(__m128i __A)
+{
+  return (__m128) __A;
+}
+extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_castsi256_ps (__m256i __A)
+{
+  return (__m256) __A;
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_slli_epi32 (__m128i __A, int __B)
+{
+  return (__m128i)__builtin_ia32_pslldi128 ((__v4si)__A, __B);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_slli_epi32 (__m256i __A, int __B)
+{
+  return (__m256i)__builtin_ia32_pslldi256 ((__v8si)__A, __B);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_cvtepi16_epi32 (__m128i __X)
+{
+  return (__m128i) __builtin_ia32_pmovsxwd128 ((__v8hi)__X);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_cvtepi16_epi32 (__m128i __X)
+{
+  return (__m256i) __builtin_ia32_pmovsxwd256 ((__v8hi)__X);
+}
+#define _mm256_cvtneps_pbh(A) (__m128bh) __builtin_ia32_cvtneps2bf16_v8sf (A)
+#define _mm_cvtneps_pbh(A) (__m128bh) __builtin_ia32_cvtneps2bf16_v4sf (A)
 extern __inline __m256bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvtne2ps_pbh (__m256 __A, __m256 __B)
 {
-  return (__m256bh)__builtin_ia32_cvtne2ps2bf16_v16hi(__A, __B);
+  return (__m256bh)__builtin_ia32_cvtne2ps2bf16_v16bf(__A, __B);
 }
 extern __inline __m256bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_cvtne2ps_pbh (__m256bh __A, __mmask16 __B, __m256 __C, __m256 __D)
 {
-  return (__m256bh)__builtin_ia32_cvtne2ps2bf16_v16hi_mask(__C, __D, __A, __B);
+  return (__m256bh)__builtin_ia32_cvtne2ps2bf16_v16bf_mask(__C, __D, __A, __B);
 }
 extern __inline __m256bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_cvtne2ps_pbh (__mmask16 __A, __m256 __B, __m256 __C)
 {
-  return (__m256bh)__builtin_ia32_cvtne2ps2bf16_v16hi_maskz(__B, __C, __A);
+  return (__m256bh)__builtin_ia32_cvtne2ps2bf16_v16bf_maskz(__B, __C, __A);
 }
 extern __inline __m128bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvtne2ps_pbh (__m128 __A, __m128 __B)
 {
-  return (__m128bh)__builtin_ia32_cvtne2ps2bf16_v8hi(__A, __B);
+  return (__m128bh)__builtin_ia32_cvtne2ps2bf16_v8bf(__A, __B);
 }
 extern __inline __m128bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_mask_cvtne2ps_pbh (__m128bh __A, __mmask8 __B, __m128 __C, __m128 __D)
 {
-  return (__m128bh)__builtin_ia32_cvtne2ps2bf16_v8hi_mask(__C, __D, __A, __B);
+  return (__m128bh)__builtin_ia32_cvtne2ps2bf16_v8bf_mask(__C, __D, __A, __B);
 }
 extern __inline __m128bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_cvtne2ps_pbh (__mmask8 __A, __m128 __B, __m128 __C)
 {
-  return (__m128bh)__builtin_ia32_cvtne2ps2bf16_v8hi_maskz(__B, __C, __A);
-}
-extern __inline __m128bh
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_cvtneps_pbh (__m256 __A)
-{
-  return (__m128bh)__builtin_ia32_cvtneps2bf16_v8sf(__A);
+  return (__m128bh)__builtin_ia32_cvtne2ps2bf16_v8bf_maskz(__B, __C, __A);
 }
 extern __inline __m128bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -70,12 +98,6 @@ _mm256_maskz_cvtneps_pbh (__mmask8 __A, __m256 __B)
 }
 extern __inline __m128bh
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtneps_pbh (__m128 __A)
-{
-  return (__m128bh)__builtin_ia32_cvtneps2bf16_v4sf(__A);
-}
-extern __inline __m128bh
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_mask_cvtneps_pbh (__m128bh __A, __mmask8 __B, __m128 __C)
 {
   return (__m128bh)__builtin_ia32_cvtneps2bf16_v4sf_mask(__C, __A, __B);
@@ -122,34 +144,34 @@ _mm_maskz_dpbf16_ps (__mmask8 __A, __m128 __B, __m128bh __C, __m128bh __D)
 {
   return (__m128)__builtin_ia32_dpbf16ps_v4sf_maskz(__B, __C, __D, __A);
 }
-extern __inline __bfloat16
+extern __inline __bf16
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvtness_sbh (float __A)
 {
   __v4sf __V = {__A, 0, 0, 0};
-  __v8hi __R = __builtin_ia32_cvtneps2bf16_v4sf_mask ((__v4sf)__V,
-        (__v8hi)_mm_undefined_si128 (), (__mmask8)-1);
+  __v8bf __R = __builtin_ia32_cvtneps2bf16_v4sf_mask ((__v4sf)__V,
+        (__v8bf)_mm_avx512_undefined_si128 (), (__mmask8)-1);
   return __R[0];
 }
 extern __inline __m128
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvtpbh_ps (__m128bh __A)
 {
-  return (__m128)_mm_castsi128_ps ((__m128i)_mm_slli_epi32 (
-  (__m128i)_mm_cvtepi16_epi32 ((__m128i)__A), 16));
+  return (__m128)_mm_avx512_castsi128_ps ((__m128i)_mm_avx512_slli_epi32 (
+  (__m128i)_mm_avx512_cvtepi16_epi32 ((__m128i)__A), 16));
 }
 extern __inline __m256
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvtpbh_ps (__m128bh __A)
 {
-  return (__m256)_mm256_castsi256_ps ((__m256i)_mm256_slli_epi32 (
-  (__m256i)_mm256_cvtepi16_epi32 ((__m128i)__A), 16));
+  return (__m256)_mm256_avx512_castsi256_ps ((__m256i)_mm256_avx512_slli_epi32 (
+  (__m256i)_mm256_avx512_cvtepi16_epi32 ((__m128i)__A), 16));
 }
 extern __inline __m128
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_cvtpbh_ps (__mmask8 __U, __m128bh __A)
 {
-  return (__m128)_mm_castsi128_ps ((__m128i)_mm_slli_epi32 (
+  return (__m128)_mm_avx512_castsi128_ps ((__m128i)_mm_avx512_slli_epi32 (
   (__m128i)_mm_maskz_cvtepi16_epi32 (
   (__mmask8)__U, (__m128i)__A), 16));
 }
@@ -157,7 +179,7 @@ extern __inline __m256
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_cvtpbh_ps (__mmask8 __U, __m128bh __A)
 {
-  return (__m256)_mm256_castsi256_ps ((__m256i)_mm256_slli_epi32 (
+  return (__m256)_mm256_avx512_castsi256_ps ((__m256i)_mm256_avx512_slli_epi32 (
   (__m256i)_mm256_maskz_cvtepi16_epi32 (
   (__mmask8)__U, (__m128i)__A), 16));
 }
@@ -165,16 +187,16 @@ extern __inline __m128
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_mask_cvtpbh_ps (__m128 __S, __mmask8 __U, __m128bh __A)
 {
-  return (__m128)_mm_castsi128_ps ((__m128i)_mm_mask_slli_epi32 (
-  (__m128i)__S, (__mmask8)__U, (__m128i)_mm_cvtepi16_epi32 (
+  return (__m128)_mm_avx512_castsi128_ps ((__m128i)_mm_mask_slli_epi32 (
+  (__m128i)__S, (__mmask8)__U, (__m128i)_mm_avx512_cvtepi16_epi32 (
   (__m128i)__A), 16));
 }
 extern __inline __m256
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_cvtpbh_ps (__m256 __S, __mmask8 __U, __m128bh __A)
 {
-  return (__m256)_mm256_castsi256_ps ((__m256i)_mm256_mask_slli_epi32 (
-  (__m256i)__S, (__mmask8)__U, (__m256i)_mm256_cvtepi16_epi32 (
+  return (__m256)_mm256_avx512_castsi256_ps ((__m256i)_mm256_mask_slli_epi32 (
+  (__m256i)__S, (__mmask8)__U, (__m256i)_mm256_avx512_cvtepi16_epi32 (
   (__m128i)__A), 16));
 }
 #ifdef __DISABLE_AVX512BF16VL__
diff --git a/third_party/intel/avx512bitalgintrin.internal.h b/third_party/intel/avx512bitalgintrin.internal.h
index aa7750fec..32b668185 100644
--- a/third_party/intel/avx512bitalgintrin.internal.h
+++ b/third_party/intel/avx512bitalgintrin.internal.h
@@ -1,12 +1,12 @@
 #if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
 #if !defined _IMMINTRIN_H_INCLUDED
-# error "Never use <avx512bitalgintrin.h> directly; include <x86intrin.h> instead."
+# error "Never use <avx512bitalgintrin.h> directly; include <immintrin.h> instead."
 #endif
 #ifndef _AVX512BITALGINTRIN_H_INCLUDED
 #define _AVX512BITALGINTRIN_H_INCLUDED
-#ifndef __AVX512BITALG__
+#if !defined (__AVX512BITALG__) || !defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512bitalg")
+#pragma GCC target("avx512bitalg,evex512")
 #define __DISABLE_AVX512BITALG__
 #endif
 extern __inline __m512i
@@ -21,15 +21,6 @@ _mm512_popcnt_epi16 (__m512i __A)
 {
   return (__m512i) __builtin_ia32_vpopcountw_v32hi ((__v32hi) __A);
 }
-#ifdef __DISABLE_AVX512BITALG__
-#undef __DISABLE_AVX512BITALG__
-#pragma GCC pop_options
-#endif
-#if !defined(__AVX512BITALG__) || !defined(__AVX512BW__)
-#pragma GCC push_options
-#pragma GCC target("avx512bitalg,avx512bw")
-#define __DISABLE_AVX512BITALGBW__
-#endif
 extern __inline __m512i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mask_popcnt_epi8 (__m512i __W, __mmask64 __U, __m512i __A)
@@ -80,150 +71,8 @@ _mm512_mask_bitshuffle_epi64_mask (__mmask64 __M, __m512i __A, __m512i __B)
        (__v64qi) __B,
        (__mmask64) __M);
 }
-#ifdef __DISABLE_AVX512BITALGBW__
-#undef __DISABLE_AVX512BITALGBW__
-#pragma GCC pop_options
-#endif
-#if !defined(__AVX512BITALG__) || !defined(__AVX512VL__) || !defined(__AVX512BW__)
-#pragma GCC push_options
-#pragma GCC target("avx512bitalg,avx512vl,avx512bw")
-#define __DISABLE_AVX512BITALGVLBW__
-#endif
-extern __inline __m256i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_popcnt_epi8 (__m256i __W, __mmask32 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpopcountb_v32qi_mask ((__v32qi) __A,
-        (__v32qi) __W,
-        (__mmask32) __U);
-}
-extern __inline __m256i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_popcnt_epi8 (__mmask32 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpopcountb_v32qi_mask ((__v32qi) __A,
-      (__v32qi)
-       _mm256_setzero_si256 (),
-      (__mmask32) __U);
-}
-extern __inline __mmask32
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_bitshuffle_epi64_mask (__m256i __A, __m256i __B)
-{
-  return (__mmask32) __builtin_ia32_vpshufbitqmb256_mask ((__v32qi) __A,
-       (__v32qi) __B,
-       (__mmask32) -1);
-}
-extern __inline __mmask32
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_bitshuffle_epi64_mask (__mmask32 __M, __m256i __A, __m256i __B)
-{
-  return (__mmask32) __builtin_ia32_vpshufbitqmb256_mask ((__v32qi) __A,
-       (__v32qi) __B,
-       (__mmask32) __M);
-}
-#ifdef __DISABLE_AVX512BITALGVLBW__
-#undef __DISABLE_AVX512BITALGVLBW__
-#pragma GCC pop_options
-#endif
-#if !defined(__AVX512BITALG__) || !defined(__AVX512VL__)
-#pragma GCC push_options
-#pragma GCC target("avx512bitalg,avx512vl")
-#define __DISABLE_AVX512BITALGVL__
-#endif
-extern __inline __mmask16
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_bitshuffle_epi64_mask (__m128i __A, __m128i __B)
-{
-  return (__mmask16) __builtin_ia32_vpshufbitqmb128_mask ((__v16qi) __A,
-       (__v16qi) __B,
-       (__mmask16) -1);
-}
-extern __inline __mmask16
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_bitshuffle_epi64_mask (__mmask16 __M, __m128i __A, __m128i __B)
-{
-  return (__mmask16) __builtin_ia32_vpshufbitqmb128_mask ((__v16qi) __A,
-       (__v16qi) __B,
-       (__mmask16) __M);
-}
-extern __inline __m256i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_popcnt_epi8 (__m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpopcountb_v32qi ((__v32qi) __A);
-}
-extern __inline __m256i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_popcnt_epi16 (__m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpopcountw_v16hi ((__v16hi) __A);
-}
-extern __inline __m128i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_popcnt_epi8 (__m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpopcountb_v16qi ((__v16qi) __A);
-}
-extern __inline __m128i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_popcnt_epi16 (__m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpopcountw_v8hi ((__v8hi) __A);
-}
-extern __inline __m256i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_popcnt_epi16 (__m256i __W, __mmask16 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpopcountw_v16hi_mask ((__v16hi) __A,
-       (__v16hi) __W,
-       (__mmask16) __U);
-}
-extern __inline __m256i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_popcnt_epi16 (__mmask16 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpopcountw_v16hi_mask ((__v16hi) __A,
-      (__v16hi)
-      _mm256_setzero_si256 (),
-      (__mmask16) __U);
-}
-extern __inline __m128i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_popcnt_epi8 (__m128i __W, __mmask16 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpopcountb_v16qi_mask ((__v16qi) __A,
-        (__v16qi) __W,
-        (__mmask16) __U);
-}
-extern __inline __m128i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_popcnt_epi8 (__mmask16 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpopcountb_v16qi_mask ((__v16qi) __A,
-        (__v16qi)
-        _mm_setzero_si128 (),
-        (__mmask16) __U);
-}
-extern __inline __m128i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_popcnt_epi16 (__m128i __W, __mmask8 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpopcountw_v8hi_mask ((__v8hi) __A,
-       (__v8hi) __W,
-       (__mmask8) __U);
-}
-extern __inline __m128i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_popcnt_epi16 (__mmask8 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpopcountw_v8hi_mask ((__v8hi) __A,
-       (__v8hi)
-       _mm_setzero_si128 (),
-       (__mmask8) __U);
-}
-#ifdef __DISABLE_AVX512BITALGVL__
-#undef __DISABLE_AVX512BITALGVL__
+#ifdef __DISABLE_AVX512BITALG__
+#undef __DISABLE_AVX512BITALG__
 #pragma GCC pop_options
 #endif
 #endif
diff --git a/third_party/intel/avx512bitalgvlintrin.internal.h b/third_party/intel/avx512bitalgvlintrin.internal.h
new file mode 100644
index 000000000..5a5d85e2f
--- /dev/null
+++ b/third_party/intel/avx512bitalgvlintrin.internal.h
@@ -0,0 +1,141 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#if !defined _IMMINTRIN_H_INCLUDED
+# error "Never use <avx512bitalgvlintrin.h> directly; include <immintrin.h> instead."
+#endif
+#ifndef _AVX512BITALGVLINTRIN_H_INCLUDED
+#define _AVX512BITALGVLINTRIN_H_INCLUDED
+#if !defined(__AVX512BITALG__) || !defined(__AVX512VL__) || defined (__EVEX512__)
+#pragma GCC push_options
+#pragma GCC target("avx512bitalg,avx512vl,no-evex512")
+#define __DISABLE_AVX512BITALGVL__
+#endif
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_popcnt_epi8 (__m256i __W, __mmask32 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpopcountb_v32qi_mask ((__v32qi) __A,
+        (__v32qi) __W,
+        (__mmask32) __U);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_maskz_popcnt_epi8 (__mmask32 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpopcountb_v32qi_mask ((__v32qi) __A,
+      (__v32qi)
+       _mm256_avx512_setzero_si256 (),
+      (__mmask32) __U);
+}
+extern __inline __mmask32
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_bitshuffle_epi64_mask (__m256i __A, __m256i __B)
+{
+  return (__mmask32) __builtin_ia32_vpshufbitqmb256_mask ((__v32qi) __A,
+       (__v32qi) __B,
+       (__mmask32) -1);
+}
+extern __inline __mmask32
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_bitshuffle_epi64_mask (__mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__mmask32) __builtin_ia32_vpshufbitqmb256_mask ((__v32qi) __A,
+       (__v32qi) __B,
+       (__mmask32) __M);
+}
+extern __inline __mmask16
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_bitshuffle_epi64_mask (__m128i __A, __m128i __B)
+{
+  return (__mmask16) __builtin_ia32_vpshufbitqmb128_mask ((__v16qi) __A,
+       (__v16qi) __B,
+       (__mmask16) -1);
+}
+extern __inline __mmask16
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_bitshuffle_epi64_mask (__mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__mmask16) __builtin_ia32_vpshufbitqmb128_mask ((__v16qi) __A,
+       (__v16qi) __B,
+       (__mmask16) __M);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_popcnt_epi8 (__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpopcountb_v32qi ((__v32qi) __A);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_popcnt_epi16 (__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpopcountw_v16hi ((__v16hi) __A);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_popcnt_epi8 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpopcountb_v16qi ((__v16qi) __A);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_popcnt_epi16 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpopcountw_v8hi ((__v8hi) __A);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_popcnt_epi16 (__m256i __W, __mmask16 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpopcountw_v16hi_mask ((__v16hi) __A,
+       (__v16hi) __W,
+       (__mmask16) __U);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_maskz_popcnt_epi16 (__mmask16 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpopcountw_v16hi_mask ((__v16hi) __A,
+      (__v16hi)
+      _mm256_avx512_setzero_si256 (),
+      (__mmask16) __U);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_popcnt_epi8 (__m128i __W, __mmask16 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpopcountb_v16qi_mask ((__v16qi) __A,
+        (__v16qi) __W,
+        (__mmask16) __U);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_popcnt_epi8 (__mmask16 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpopcountb_v16qi_mask ((__v16qi) __A,
+        (__v16qi)
+        _mm_avx512_setzero_si128 (),
+        (__mmask16) __U);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_popcnt_epi16 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpopcountw_v8hi_mask ((__v8hi) __A,
+       (__v8hi) __W,
+       (__mmask8) __U);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_popcnt_epi16 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpopcountw_v8hi_mask ((__v8hi) __A,
+       (__v8hi)
+       _mm_avx512_setzero_si128 (),
+       (__mmask8) __U);
+}
+#ifdef __DISABLE_AVX512BITALGVL__
+#undef __DISABLE_AVX512BITALGVL__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/avx512bwintrin.internal.h b/third_party/intel/avx512bwintrin.internal.h
index 27f94a612..a213e7c7d 100644
--- a/third_party/intel/avx512bwintrin.internal.h
+++ b/third_party/intel/avx512bwintrin.internal.h
@@ -4,16 +4,35 @@
 #endif
 #ifndef _AVX512BWINTRIN_H_INCLUDED
 #define _AVX512BWINTRIN_H_INCLUDED
-#ifndef __AVX512BW__
+#if !defined (__AVX512BW__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512bw")
+#pragma GCC target("avx512bw,no-evex512")
 #define __DISABLE_AVX512BW__
 #endif
-typedef short __v32hi __attribute__ ((__vector_size__ (64)));
-typedef short __v32hi_u __attribute__ ((__vector_size__ (64), __may_alias__, __aligned__ (1)));
-typedef char __v64qi __attribute__ ((__vector_size__ (64)));
-typedef char __v64qi_u __attribute__ ((__vector_size__ (64), __may_alias__, __aligned__ (1)));
 typedef unsigned long long __mmask64;
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_set_epi32 (int __q3, int __q2, int __q1, int __q0)
+{
+  return __extension__ (__m128i)(__v4si){ __q0, __q1, __q2, __q3 };
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_set_epi16 (short __q7, short __q6, short __q5, short __q4,
+        short __q3, short __q2, short __q1, short __q0)
+{
+  return __extension__ (__m128i)(__v8hi){
+    __q0, __q1, __q2, __q3, __q4, __q5, __q6, __q7 };
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_set_epi8 (char __q15, char __q14, char __q13, char __q12,
+       char __q11, char __q10, char __q09, char __q08,
+       char __q07, char __q06, char __q05, char __q04,
+       char __q03, char __q02, char __q01, char __q00)
+{
+  return __extension__ (__m128i)(__v16qi){
+    __q00, __q01, __q02, __q03, __q04, __q05, __q06, __q07,
+    __q08, __q09, __q10, __q11, __q12, __q13, __q14, __q15
+  };
+}
 extern __inline unsigned char
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _ktest_mask32_u8 (__mmask32 __A, __mmask32 __B, unsigned char *__CF)
@@ -23,37 +42,18 @@ _ktest_mask32_u8 (__mmask32 __A, __mmask32 __B, unsigned char *__CF)
 }
 extern __inline unsigned char
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_ktest_mask64_u8 (__mmask64 __A, __mmask64 __B, unsigned char *__CF)
-{
-  *__CF = (unsigned char) __builtin_ia32_ktestcdi (__A, __B);
-  return (unsigned char) __builtin_ia32_ktestzdi (__A, __B);
-}
-extern __inline unsigned char
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _ktestz_mask32_u8 (__mmask32 __A, __mmask32 __B)
 {
   return (unsigned char) __builtin_ia32_ktestzsi (__A, __B);
 }
 extern __inline unsigned char
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_ktestz_mask64_u8 (__mmask64 __A, __mmask64 __B)
-{
-  return (unsigned char) __builtin_ia32_ktestzdi (__A, __B);
-}
-extern __inline unsigned char
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _ktestc_mask32_u8 (__mmask32 __A, __mmask32 __B)
 {
   return (unsigned char) __builtin_ia32_ktestcsi (__A, __B);
 }
 extern __inline unsigned char
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_ktestc_mask64_u8 (__mmask64 __A, __mmask64 __B)
-{
-  return (unsigned char) __builtin_ia32_ktestcdi (__A, __B);
-}
-extern __inline unsigned char
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kortest_mask32_u8 (__mmask32 __A, __mmask32 __B, unsigned char *__CF)
 {
   *__CF = (unsigned char) __builtin_ia32_kortestcsi (__A, __B);
@@ -61,6 +61,136 @@ _kortest_mask32_u8 (__mmask32 __A, __mmask32 __B, unsigned char *__CF)
 }
 extern __inline unsigned char
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kortestz_mask32_u8 (__mmask32 __A, __mmask32 __B)
+{
+  return (unsigned char) __builtin_ia32_kortestzsi (__A, __B);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kortestc_mask32_u8 (__mmask32 __A, __mmask32 __B)
+{
+  return (unsigned char) __builtin_ia32_kortestcsi (__A, __B);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kadd_mask32 (__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32) __builtin_ia32_kaddsi ((__mmask32) __A, (__mmask32) __B);
+}
+extern __inline unsigned int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_cvtmask32_u32 (__mmask32 __A)
+{
+  return (unsigned int) __builtin_ia32_kmovd ((__mmask32) __A);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_cvtu32_mask32 (unsigned int __A)
+{
+  return (__mmask32) __builtin_ia32_kmovd ((__mmask32) __A);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_load_mask32 (__mmask32 *__A)
+{
+  return (__mmask32) __builtin_ia32_kmovd (*__A);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_store_mask32 (__mmask32 *__A, __mmask32 __B)
+{
+  *(__mmask32 *) __A = __builtin_ia32_kmovd (__B);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_knot_mask32 (__mmask32 __A)
+{
+  return (__mmask32) __builtin_ia32_knotsi ((__mmask32) __A);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kor_mask32 (__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32) __builtin_ia32_korsi ((__mmask32) __A, (__mmask32) __B);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kxnor_mask32 (__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32) __builtin_ia32_kxnorsi ((__mmask32) __A, (__mmask32) __B);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kxor_mask32 (__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32) __builtin_ia32_kxorsi ((__mmask32) __A, (__mmask32) __B);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kand_mask32 (__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32) __builtin_ia32_kandsi ((__mmask32) __A, (__mmask32) __B);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kandn_mask32 (__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32) __builtin_ia32_kandnsi ((__mmask32) __A, (__mmask32) __B);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm512_kunpackw (__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32) __builtin_ia32_kunpcksi ((__mmask32) __A,
+           (__mmask32) __B);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kunpackw_mask32 (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask32) __builtin_ia32_kunpcksi ((__mmask32) __A,
+           (__mmask32) __B);
+}
+#if __OPTIMIZE__
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kshiftli_mask32 (__mmask32 __A, unsigned int __B)
+{
+  return (__mmask32) __builtin_ia32_kshiftlisi ((__mmask32) __A,
+      (__mmask8) __B);
+}
+extern __inline __mmask32
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kshiftri_mask32 (__mmask32 __A, unsigned int __B)
+{
+  return (__mmask32) __builtin_ia32_kshiftrisi ((__mmask32) __A,
+      (__mmask8) __B);
+}
+#else
+#define _kshiftli_mask32(X, Y) ((__mmask32) __builtin_ia32_kshiftlisi ((__mmask32)(X), (__mmask8)(Y)))
+#define _kshiftri_mask32(X, Y) ((__mmask32) __builtin_ia32_kshiftrisi ((__mmask32)(X), (__mmask8)(Y)))
+#endif
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_ktest_mask64_u8 (__mmask64 __A, __mmask64 __B, unsigned char *__CF)
+{
+  *__CF = (unsigned char) __builtin_ia32_ktestcdi (__A, __B);
+  return (unsigned char) __builtin_ia32_ktestzdi (__A, __B);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_ktestz_mask64_u8 (__mmask64 __A, __mmask64 __B)
+{
+  return (unsigned char) __builtin_ia32_ktestzdi (__A, __B);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_ktestc_mask64_u8 (__mmask64 __A, __mmask64 __B)
+{
+  return (unsigned char) __builtin_ia32_ktestcdi (__A, __B);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kortest_mask64_u8 (__mmask64 __A, __mmask64 __B, unsigned char *__CF)
 {
   *__CF = (unsigned char) __builtin_ia32_kortestcdi (__A, __B);
@@ -68,70 +198,34 @@ _kortest_mask64_u8 (__mmask64 __A, __mmask64 __B, unsigned char *__CF)
 }
 extern __inline unsigned char
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kortestz_mask32_u8 (__mmask32 __A, __mmask32 __B)
-{
-  return (unsigned char) __builtin_ia32_kortestzsi (__A, __B);
-}
-extern __inline unsigned char
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kortestz_mask64_u8 (__mmask64 __A, __mmask64 __B)
 {
   return (unsigned char) __builtin_ia32_kortestzdi (__A, __B);
 }
 extern __inline unsigned char
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kortestc_mask32_u8 (__mmask32 __A, __mmask32 __B)
-{
-  return (unsigned char) __builtin_ia32_kortestcsi (__A, __B);
-}
-extern __inline unsigned char
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kortestc_mask64_u8 (__mmask64 __A, __mmask64 __B)
 {
   return (unsigned char) __builtin_ia32_kortestcdi (__A, __B);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kadd_mask32 (__mmask32 __A, __mmask32 __B)
-{
-  return (__mmask32) __builtin_ia32_kaddsi ((__mmask32) __A, (__mmask32) __B);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kadd_mask64 (__mmask64 __A, __mmask64 __B)
 {
   return (__mmask64) __builtin_ia32_kadddi ((__mmask64) __A, (__mmask64) __B);
 }
-extern __inline unsigned int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_cvtmask32_u32 (__mmask32 __A)
-{
-  return (unsigned int) __builtin_ia32_kmovd ((__mmask32) __A);
-}
 extern __inline unsigned long long
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _cvtmask64_u64 (__mmask64 __A)
 {
   return (unsigned long long) __builtin_ia32_kmovq ((__mmask64) __A);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_cvtu32_mask32 (unsigned int __A)
-{
-  return (__mmask32) __builtin_ia32_kmovd ((__mmask32) __A);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _cvtu64_mask64 (unsigned long long __A)
 {
   return (__mmask64) __builtin_ia32_kmovq ((__mmask64) __A);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_load_mask32 (__mmask32 *__A)
-{
-  return (__mmask32) __builtin_ia32_kmovd (*__A);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _load_mask64 (__mmask64 *__A)
@@ -140,88 +234,59 @@ _load_mask64 (__mmask64 *__A)
 }
 extern __inline void
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_store_mask32 (__mmask32 *__A, __mmask32 __B)
-{
-  *(__mmask32 *) __A = __builtin_ia32_kmovd (__B);
-}
-extern __inline void
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _store_mask64 (__mmask64 *__A, __mmask64 __B)
 {
   *(__mmask64 *) __A = __builtin_ia32_kmovq (__B);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_knot_mask32 (__mmask32 __A)
-{
-  return (__mmask32) __builtin_ia32_knotsi ((__mmask32) __A);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _knot_mask64 (__mmask64 __A)
 {
   return (__mmask64) __builtin_ia32_knotdi ((__mmask64) __A);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kor_mask32 (__mmask32 __A, __mmask32 __B)
-{
-  return (__mmask32) __builtin_ia32_korsi ((__mmask32) __A, (__mmask32) __B);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kor_mask64 (__mmask64 __A, __mmask64 __B)
 {
   return (__mmask64) __builtin_ia32_kordi ((__mmask64) __A, (__mmask64) __B);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kxnor_mask32 (__mmask32 __A, __mmask32 __B)
-{
-  return (__mmask32) __builtin_ia32_kxnorsi ((__mmask32) __A, (__mmask32) __B);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kxnor_mask64 (__mmask64 __A, __mmask64 __B)
 {
   return (__mmask64) __builtin_ia32_kxnordi ((__mmask64) __A, (__mmask64) __B);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kxor_mask32 (__mmask32 __A, __mmask32 __B)
-{
-  return (__mmask32) __builtin_ia32_kxorsi ((__mmask32) __A, (__mmask32) __B);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kxor_mask64 (__mmask64 __A, __mmask64 __B)
 {
   return (__mmask64) __builtin_ia32_kxordi ((__mmask64) __A, (__mmask64) __B);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kand_mask32 (__mmask32 __A, __mmask32 __B)
-{
-  return (__mmask32) __builtin_ia32_kandsi ((__mmask32) __A, (__mmask32) __B);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kand_mask64 (__mmask64 __A, __mmask64 __B)
 {
   return (__mmask64) __builtin_ia32_kanddi ((__mmask64) __A, (__mmask64) __B);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kandn_mask32 (__mmask32 __A, __mmask32 __B)
-{
-  return (__mmask32) __builtin_ia32_kandnsi ((__mmask32) __A, (__mmask32) __B);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kandn_mask64 (__mmask64 __A, __mmask64 __B)
 {
   return (__mmask64) __builtin_ia32_kandndi ((__mmask64) __A, (__mmask64) __B);
 }
+#ifdef __DISABLE_AVX512BW__
+#undef __DISABLE_AVX512BW__
+#pragma GCC pop_options
+#endif
+#if !defined (__AVX512BW__) || !defined (__EVEX512__)
+#pragma GCC push_options
+#pragma GCC target("avx512bw,evex512")
+#define __DISABLE_AVX512BW_512__
+#endif
+typedef short __v32hi __attribute__ ((__vector_size__ (64)));
+typedef short __v32hi_u __attribute__ ((__vector_size__ (64), __may_alias__, __aligned__ (1)));
+typedef char __v64qi __attribute__ ((__vector_size__ (64)));
+typedef char __v64qi_u __attribute__ ((__vector_size__ (64), __may_alias__, __aligned__ (1)));
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mask_mov_epi16 (__m512i __W, __mmask32 __U, __m512i __A)
@@ -293,20 +358,6 @@ _mm512_maskz_mov_epi8 (__mmask64 __U, __m512i __A)
           _mm512_setzero_si512 (),
           (__mmask64) __U);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm512_kunpackw (__mmask32 __A, __mmask32 __B)
-{
-  return (__mmask32) __builtin_ia32_kunpcksi ((__mmask32) __A,
-           (__mmask32) __B);
-}
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kunpackw_mask32 (__mmask16 __A, __mmask16 __B)
-{
-  return (__mmask32) __builtin_ia32_kunpcksi ((__mmask32) __A,
-           (__mmask32) __B);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_kunpackd (__mmask64 __A, __mmask64 __B)
@@ -2463,13 +2514,6 @@ _mm512_mask_packus_epi32 (__m512i __W, __mmask32 __M, __m512i __A,
           __M);
 }
 #ifdef __OPTIMIZE__
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kshiftli_mask32 (__mmask32 __A, unsigned int __B)
-{
-  return (__mmask32) __builtin_ia32_kshiftlisi ((__mmask32) __A,
-      (__mmask8) __B);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kshiftli_mask64 (__mmask64 __A, unsigned int __B)
@@ -2477,13 +2521,6 @@ _kshiftli_mask64 (__mmask64 __A, unsigned int __B)
   return (__mmask64) __builtin_ia32_kshiftlidi ((__mmask64) __A,
       (__mmask8) __B);
 }
-extern __inline __mmask32
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kshiftri_mask32 (__mmask32 __A, unsigned int __B)
-{
-  return (__mmask32) __builtin_ia32_kshiftrisi ((__mmask32) __A,
-      (__mmask8) __B);
-}
 extern __inline __mmask64
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _kshiftri_mask64 (__mmask64 __A, unsigned int __B)
@@ -2557,7 +2594,7 @@ _mm512_maskz_dbsad_epu8 (__mmask32 __U, __m512i __A, __m512i __B,
 }
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm512_srli_epi16 (__m512i __A, const int __imm)
+_mm512_srli_epi16 (__m512i __A, const unsigned int __imm)
 {
   return (__m512i) __builtin_ia32_psrlwi512_mask ((__v32hi) __A, __imm,
         (__v32hi)
@@ -2567,7 +2604,7 @@ _mm512_srli_epi16 (__m512i __A, const int __imm)
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mask_srli_epi16 (__m512i __W, __mmask32 __U, __m512i __A,
-   const int __imm)
+   const unsigned int __imm)
 {
   return (__m512i) __builtin_ia32_psrlwi512_mask ((__v32hi) __A, __imm,
         (__v32hi) __W,
@@ -2584,7 +2621,7 @@ _mm512_maskz_srli_epi16 (__mmask32 __U, __m512i __A, const int __imm)
 }
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm512_slli_epi16 (__m512i __A, const int __B)
+_mm512_slli_epi16 (__m512i __A, const unsigned int __B)
 {
   return (__m512i) __builtin_ia32_psllwi512_mask ((__v32hi) __A, __B,
         (__v32hi)
@@ -2594,7 +2631,7 @@ _mm512_slli_epi16 (__m512i __A, const int __B)
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mask_slli_epi16 (__m512i __W, __mmask32 __U, __m512i __A,
-   const int __B)
+   const unsigned int __B)
 {
   return (__m512i) __builtin_ia32_psllwi512_mask ((__v32hi) __A, __B,
         (__v32hi) __W,
@@ -2602,7 +2639,7 @@ _mm512_mask_slli_epi16 (__m512i __W, __mmask32 __U, __m512i __A,
 }
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm512_maskz_slli_epi16 (__mmask32 __U, __m512i __A, const int __B)
+_mm512_maskz_slli_epi16 (__mmask32 __U, __m512i __A, const unsigned int __B)
 {
   return (__m512i) __builtin_ia32_psllwi512_mask ((__v32hi) __A, __B,
         (__v32hi)
@@ -2673,7 +2710,7 @@ _mm512_maskz_shufflelo_epi16 (__mmask32 __U, __m512i __A,
 }
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm512_srai_epi16 (__m512i __A, const int __imm)
+_mm512_srai_epi16 (__m512i __A, const unsigned int __imm)
 {
   return (__m512i) __builtin_ia32_psrawi512_mask ((__v32hi) __A, __imm,
         (__v32hi)
@@ -2683,7 +2720,7 @@ _mm512_srai_epi16 (__m512i __A, const int __imm)
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mask_srai_epi16 (__m512i __W, __mmask32 __U, __m512i __A,
-   const int __imm)
+   const unsigned int __imm)
 {
   return (__m512i) __builtin_ia32_psrawi512_mask ((__v32hi) __A, __imm,
         (__v32hi) __W,
@@ -2691,7 +2728,7 @@ _mm512_mask_srai_epi16 (__m512i __W, __mmask32 __U, __m512i __A,
 }
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm512_maskz_srai_epi16 (__mmask32 __U, __m512i __A, const int __imm)
+_mm512_maskz_srai_epi16 (__mmask32 __U, __m512i __A, const unsigned int __imm)
 {
   return (__m512i) __builtin_ia32_psrawi512_mask ((__v32hi) __A, __imm,
         (__v32hi)
@@ -2795,9 +2832,7 @@ _mm512_bsrli_epi128 (__m512i __A, const int __N)
   return (__m512i) __builtin_ia32_psrldq512 (__A, __N * 8);
 }
 #else
-#define _kshiftli_mask32(X, Y) ((__mmask32) __builtin_ia32_kshiftlisi ((__mmask32)(X), (__mmask8)(Y)))
 #define _kshiftli_mask64(X, Y) ((__mmask64) __builtin_ia32_kshiftlidi ((__mmask64)(X), (__mmask8)(Y)))
-#define _kshiftri_mask32(X, Y) ((__mmask32) __builtin_ia32_kshiftrisi ((__mmask32)(X), (__mmask8)(Y)))
 #define _kshiftri_mask64(X, Y) ((__mmask64) __builtin_ia32_kshiftridi ((__mmask64)(X), (__mmask8)(Y)))
 #define _mm512_alignr_epi8(X, Y, N) ((__m512i) __builtin_ia32_palignr512 ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)((N) * 8)))
 #define _mm512_mask_alignr_epi8(W, U, X, Y, N) ((__m512i) __builtin_ia32_palignr512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)((N) * 8), (__v8di)(__m512i)(W), (__mmask64)(U)))
@@ -2805,21 +2840,21 @@ _mm512_bsrli_epi128 (__m512i __A, const int __N)
 #define _mm512_dbsad_epu8(X, Y, C) ((__m512i) __builtin_ia32_dbpsadbw512_mask ((__v64qi)(__m512i) (X), (__v64qi)(__m512i) (Y), (int) (C), (__v32hi)(__m512i) _mm512_setzero_si512 (), (__mmask32)-1))
 #define _mm512_mask_dbsad_epu8(W, U, X, Y, C) ((__m512i) __builtin_ia32_dbpsadbw512_mask ((__v64qi)(__m512i) (X), (__v64qi)(__m512i) (Y), (int) (C), (__v32hi)(__m512i)(W), (__mmask32)(U)))
 #define _mm512_maskz_dbsad_epu8(U, X, Y, C) ((__m512i) __builtin_ia32_dbpsadbw512_mask ((__v64qi)(__m512i) (X), (__v64qi)(__m512i) (Y), (int) (C), (__v32hi)(__m512i) _mm512_setzero_si512 (), (__mmask32)(U)))
-#define _mm512_srli_epi16(A, B) ((__m512i) __builtin_ia32_psrlwi512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)_mm512_setzero_si512 (), (__mmask32)-1))
-#define _mm512_mask_srli_epi16(W, U, A, B) ((__m512i) __builtin_ia32_psrlwi512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)(__m512i)(W), (__mmask32)(U)))
+#define _mm512_srli_epi16(A, B) ((__m512i) __builtin_ia32_psrlwi512_mask ((__v32hi)(__m512i)(A), (unsigned int)(B), (__v32hi)_mm512_setzero_si512 (), (__mmask32)-1))
+#define _mm512_mask_srli_epi16(W, U, A, B) ((__m512i) __builtin_ia32_psrlwi512_mask ((__v32hi)(__m512i)(A), (unsigned int)(B), (__v32hi)(__m512i)(W), (__mmask32)(U)))
 #define _mm512_maskz_srli_epi16(U, A, B) ((__m512i) __builtin_ia32_psrlwi512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)_mm512_setzero_si512 (), (__mmask32)(U)))
-#define _mm512_slli_epi16(X, C) ((__m512i)__builtin_ia32_psllwi512_mask ((__v32hi)(__m512i)(X), (int)(C), (__v32hi)(__m512i)_mm512_setzero_si512 (), (__mmask32)-1))
-#define _mm512_mask_slli_epi16(W, U, X, C) ((__m512i)__builtin_ia32_psllwi512_mask ((__v32hi)(__m512i)(X), (int)(C), (__v32hi)(__m512i)(W), (__mmask32)(U)))
-#define _mm512_maskz_slli_epi16(U, X, C) ((__m512i)__builtin_ia32_psllwi512_mask ((__v32hi)(__m512i)(X), (int)(C), (__v32hi)(__m512i)_mm512_setzero_si512 (), (__mmask32)(U)))
+#define _mm512_slli_epi16(X, C) ((__m512i)__builtin_ia32_psllwi512_mask ((__v32hi)(__m512i)(X), (unsigned int)(C), (__v32hi)(__m512i)_mm512_setzero_si512 (), (__mmask32)-1))
+#define _mm512_mask_slli_epi16(W, U, X, C) ((__m512i)__builtin_ia32_psllwi512_mask ((__v32hi)(__m512i)(X), (unsigned int)(C), (__v32hi)(__m512i)(W), (__mmask32)(U)))
+#define _mm512_maskz_slli_epi16(U, X, C) ((__m512i)__builtin_ia32_psllwi512_mask ((__v32hi)(__m512i)(X), (unsigned int)(C), (__v32hi)(__m512i)_mm512_setzero_si512 (), (__mmask32)(U)))
 #define _mm512_shufflehi_epi16(A, B) ((__m512i) __builtin_ia32_pshufhw512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)(__m512i) _mm512_setzero_si512 (), (__mmask32)-1))
 #define _mm512_mask_shufflehi_epi16(W, U, A, B) ((__m512i) __builtin_ia32_pshufhw512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)(__m512i)(W), (__mmask32)(U)))
 #define _mm512_maskz_shufflehi_epi16(U, A, B) ((__m512i) __builtin_ia32_pshufhw512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)(__m512i) _mm512_setzero_si512 (), (__mmask32)(U)))
 #define _mm512_shufflelo_epi16(A, B) ((__m512i) __builtin_ia32_pshuflw512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)(__m512i) _mm512_setzero_si512 (), (__mmask32)-1))
 #define _mm512_mask_shufflelo_epi16(W, U, A, B) ((__m512i) __builtin_ia32_pshuflw512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)(__m512i)(W), (__mmask32)(U)))
 #define _mm512_maskz_shufflelo_epi16(U, A, B) ((__m512i) __builtin_ia32_pshuflw512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)(__m512i) _mm512_setzero_si512 (), (__mmask32)(U)))
-#define _mm512_srai_epi16(A, B) ((__m512i) __builtin_ia32_psrawi512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)_mm512_setzero_si512 (), (__mmask32)-1))
-#define _mm512_mask_srai_epi16(W, U, A, B) ((__m512i) __builtin_ia32_psrawi512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)(__m512i)(W), (__mmask32)(U)))
-#define _mm512_maskz_srai_epi16(U, A, B) ((__m512i) __builtin_ia32_psrawi512_mask ((__v32hi)(__m512i)(A), (int)(B), (__v32hi)_mm512_setzero_si512 (), (__mmask32)(U)))
+#define _mm512_srai_epi16(A, B) ((__m512i) __builtin_ia32_psrawi512_mask ((__v32hi)(__m512i)(A), (unsigned int)(B), (__v32hi)_mm512_setzero_si512 (), (__mmask32)-1))
+#define _mm512_mask_srai_epi16(W, U, A, B) ((__m512i) __builtin_ia32_psrawi512_mask ((__v32hi)(__m512i)(A), (unsigned int)(B), (__v32hi)(__m512i)(W), (__mmask32)(U)))
+#define _mm512_maskz_srai_epi16(U, A, B) ((__m512i) __builtin_ia32_psrawi512_mask ((__v32hi)(__m512i)(A), (unsigned int)(B), (__v32hi)_mm512_setzero_si512 (), (__mmask32)(U)))
 #define _mm512_mask_blend_epi16(__U, __A, __W) ((__m512i) __builtin_ia32_blendmw_512_mask ((__v32hi) (__A), (__v32hi) (__W), (__mmask32) (__U)))
 #define _mm512_mask_blend_epi8(__U, __A, __W) ((__m512i) __builtin_ia32_blendmb_512_mask ((__v64qi) (__A), (__v64qi) (__W), (__mmask64) (__U)))
 #define _mm512_cmp_epi16_mask(X, Y, P) ((__mmask32) __builtin_ia32_cmpw512_mask ((__v32hi)(__m512i)(X), (__v32hi)(__m512i)(Y), (int)(P), (__mmask32)(-1)))
@@ -2833,8 +2868,8 @@ _mm512_bsrli_epi128 (__m512i __A, const int __N)
 #define _mm512_bslli_epi128(A, N) ((__m512i)__builtin_ia32_pslldq512 ((__m512i)(A), (int)(N) * 8))
 #define _mm512_bsrli_epi128(A, N) ((__m512i)__builtin_ia32_psrldq512 ((__m512i)(A), (int)(N) * 8))
 #endif
-#ifdef __DISABLE_AVX512BW__
-#undef __DISABLE_AVX512BW__
+#ifdef __DISABLE_AVX512BW_512__
+#undef __DISABLE_AVX512BW_512__
 #pragma GCC pop_options
 #endif
 #endif
diff --git a/third_party/intel/avx512cdintrin.internal.h b/third_party/intel/avx512cdintrin.internal.h
index 83b643edb..a5218487a 100644
--- a/third_party/intel/avx512cdintrin.internal.h
+++ b/third_party/intel/avx512cdintrin.internal.h
@@ -6,7 +6,7 @@
 #define _AVX512CDINTRIN_H_INCLUDED
 #ifndef __AVX512CD__
 #pragma GCC push_options
-#pragma GCC target("avx512cd")
+#pragma GCC target("avx512cd,evex512")
 #define __DISABLE_AVX512CD__
 #endif
 typedef long long __v8di __attribute__ ((__vector_size__ (64)));
diff --git a/third_party/intel/avx512dqintrin.internal.h b/third_party/intel/avx512dqintrin.internal.h
index 0cf6a7080..c32d7d877 100644
--- a/third_party/intel/avx512dqintrin.internal.h
+++ b/third_party/intel/avx512dqintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512DQINTRIN_H_INCLUDED
 #define _AVX512DQINTRIN_H_INCLUDED
-#ifndef __AVX512DQ__
+#if !defined (__AVX512DQ__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512dq")
+#pragma GCC target("avx512dq,no-evex512")
 #define __DISABLE_AVX512DQ__
 #endif
 extern __inline unsigned char
@@ -138,6 +138,330 @@ _kandn_mask8 (__mmask8 __A, __mmask8 __B)
 {
   return (__mmask8) __builtin_ia32_kandnqi ((__mmask8) __A, (__mmask8) __B);
 }
+#ifdef __OPTIMIZE__
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kshiftli_mask8 (__mmask8 __A, unsigned int __B)
+{
+  return (__mmask8) __builtin_ia32_kshiftliqi ((__mmask8) __A, (__mmask8) __B);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kshiftri_mask8 (__mmask8 __A, unsigned int __B)
+{
+  return (__mmask8) __builtin_ia32_kshiftriqi ((__mmask8) __A, (__mmask8) __B);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_sd (__m128d __A, __m128d __B, int __C)
+{
+  return (__m128d) __builtin_ia32_reducesd_mask ((__v2df) __A,
+       (__v2df) __B, __C,
+       (__v2df) _mm_avx512_setzero_pd (),
+       (__mmask8) -1);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_round_sd (__m128d __A, __m128d __B, int __C, const int __R)
+{
+  return (__m128d) __builtin_ia32_reducesd_mask_round ((__v2df) __A,
+             (__v2df) __B, __C,
+             (__v2df)
+             _mm_avx512_setzero_pd (),
+             (__mmask8) -1, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_sd (__m128d __W, __mmask8 __U, __m128d __A,
+      __m128d __B, int __C)
+{
+  return (__m128d) __builtin_ia32_reducesd_mask ((__v2df) __A,
+       (__v2df) __B, __C,
+       (__v2df) __W,
+       (__mmask8) __U);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
+     __m128d __B, int __C, const int __R)
+{
+  return (__m128d) __builtin_ia32_reducesd_mask_round ((__v2df) __A,
+             (__v2df) __B, __C,
+             (__v2df) __W,
+             __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_reduce_sd (__mmask8 __U, __m128d __A, __m128d __B, int __C)
+{
+  return (__m128d) __builtin_ia32_reducesd_mask ((__v2df) __A,
+       (__v2df) __B, __C,
+       (__v2df) _mm_avx512_setzero_pd (),
+       (__mmask8) __U);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_reduce_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+      int __C, const int __R)
+{
+  return (__m128d) __builtin_ia32_reducesd_mask_round ((__v2df) __A,
+             (__v2df) __B, __C,
+             (__v2df)
+             _mm_avx512_setzero_pd (),
+             __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_ss (__m128 __A, __m128 __B, int __C)
+{
+  return (__m128) __builtin_ia32_reducess_mask ((__v4sf) __A,
+      (__v4sf) __B, __C,
+      (__v4sf) _mm_avx512_setzero_ps (),
+      (__mmask8) -1);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_round_ss (__m128 __A, __m128 __B, int __C, const int __R)
+{
+  return (__m128) __builtin_ia32_reducess_mask_round ((__v4sf) __A,
+            (__v4sf) __B, __C,
+            (__v4sf)
+            _mm_avx512_setzero_ps (),
+            (__mmask8) -1, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_ss (__m128 __W, __mmask8 __U, __m128 __A,
+      __m128 __B, int __C)
+{
+  return (__m128) __builtin_ia32_reducess_mask ((__v4sf) __A,
+      (__v4sf) __B, __C,
+      (__v4sf) __W,
+      (__mmask8) __U);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
+     __m128 __B, int __C, const int __R)
+{
+  return (__m128) __builtin_ia32_reducess_mask_round ((__v4sf) __A,
+            (__v4sf) __B, __C,
+            (__v4sf) __W,
+            __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_reduce_ss (__mmask8 __U, __m128 __A, __m128 __B, int __C)
+{
+  return (__m128) __builtin_ia32_reducess_mask ((__v4sf) __A,
+      (__v4sf) __B, __C,
+      (__v4sf) _mm_avx512_setzero_ps (),
+      (__mmask8) __U);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_reduce_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
+      int __C, const int __R)
+{
+  return (__m128) __builtin_ia32_reducess_mask_round ((__v4sf) __A,
+            (__v4sf) __B, __C,
+            (__v4sf)
+            _mm_avx512_setzero_ps (),
+            __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_range_sd (__m128d __A, __m128d __B, int __C)
+{
+  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
+         (__v2df) __B, __C,
+         (__v2df)
+         _mm_avx512_setzero_pd (),
+         (__mmask8) -1,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_range_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B, int __C)
+{
+  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
+         (__v2df) __B, __C,
+         (__v2df) __W,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_range_sd (__mmask8 __U, __m128d __A, __m128d __B, int __C)
+{
+  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
+         (__v2df) __B, __C,
+         (__v2df)
+         _mm_avx512_setzero_pd (),
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_range_ss (__m128 __A, __m128 __B, int __C)
+{
+  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
+        (__v4sf) __B, __C,
+        (__v4sf)
+        _mm_avx512_setzero_ps (),
+        (__mmask8) -1,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_range_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B, int __C)
+{
+  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
+        (__v4sf) __B, __C,
+        (__v4sf) __W,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_range_ss (__mmask8 __U, __m128 __A, __m128 __B, int __C)
+{
+  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
+        (__v4sf) __B, __C,
+        (__v4sf)
+        _mm_avx512_setzero_ps (),
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_range_round_sd (__m128d __A, __m128d __B, int __C, const int __R)
+{
+  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
+         (__v2df) __B, __C,
+         (__v2df)
+         _mm_avx512_setzero_pd (),
+         (__mmask8) -1, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_range_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
+    int __C, const int __R)
+{
+  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
+         (__v2df) __B, __C,
+         (__v2df) __W,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_range_round_sd (__mmask8 __U, __m128d __A, __m128d __B, int __C,
+     const int __R)
+{
+  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
+         (__v2df) __B, __C,
+         (__v2df)
+         _mm_avx512_setzero_pd (),
+         (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_range_round_ss (__m128 __A, __m128 __B, int __C, const int __R)
+{
+  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
+        (__v4sf) __B, __C,
+        (__v4sf)
+        _mm_avx512_setzero_ps (),
+        (__mmask8) -1, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_range_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
+    int __C, const int __R)
+{
+  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
+        (__v4sf) __B, __C,
+        (__v4sf) __W,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_range_round_ss (__mmask8 __U, __m128 __A, __m128 __B, int __C,
+     const int __R)
+{
+  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
+        (__v4sf) __B, __C,
+        (__v4sf)
+        _mm_avx512_setzero_ps (),
+        (__mmask8) __U, __R);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fpclass_ss_mask (__m128 __A, const int __imm)
+{
+  return (__mmask8) __builtin_ia32_fpclassss_mask ((__v4sf) __A, __imm,
+         (__mmask8) -1);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fpclass_sd_mask (__m128d __A, const int __imm)
+{
+  return (__mmask8) __builtin_ia32_fpclasssd_mask ((__v2df) __A, __imm,
+         (__mmask8) -1);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fpclass_ss_mask (__mmask8 __U, __m128 __A, const int __imm)
+{
+  return (__mmask8) __builtin_ia32_fpclassss_mask ((__v4sf) __A, __imm, __U);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fpclass_sd_mask (__mmask8 __U, __m128d __A, const int __imm)
+{
+  return (__mmask8) __builtin_ia32_fpclasssd_mask ((__v2df) __A, __imm, __U);
+}
+#else
+#define _kshiftli_mask8(X, Y) ((__mmask8) __builtin_ia32_kshiftliqi ((__mmask8)(X), (__mmask8)(Y)))
+#define _kshiftri_mask8(X, Y) ((__mmask8) __builtin_ia32_kshiftriqi ((__mmask8)(X), (__mmask8)(Y)))
+#define _mm_range_sd(A, B, C) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_avx512_setzero_pd (), (__mmask8) -1, _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_range_sd(W, U, A, B, C) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_range_sd(U, A, B, C) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_avx512_setzero_pd (), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_range_ss(A, B, C) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8) -1, _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_range_ss(W, U, A, B, C) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_range_ss(U, A, B, C) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_range_round_sd(A, B, C, R) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_avx512_setzero_pd (), (__mmask8) -1, (R)))
+#define _mm_mask_range_round_sd(W, U, A, B, C, R) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U), (R)))
+#define _mm_maskz_range_round_sd(U, A, B, C, R) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_avx512_setzero_pd (), (__mmask8)(U), (R)))
+#define _mm_range_round_ss(A, B, C, R) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8) -1, (R)))
+#define _mm_mask_range_round_ss(W, U, A, B, C, R) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U), (R)))
+#define _mm_maskz_range_round_ss(U, A, B, C, R) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8)(U), (R)))
+#define _mm_fpclass_ss_mask(X, C) ((__mmask8) __builtin_ia32_fpclassss_mask ((__v4sf) (__m128) (X), (int) (C), (__mmask8) (-1)))
+#define _mm_fpclass_sd_mask(X, C) ((__mmask8) __builtin_ia32_fpclasssd_mask ((__v2df) (__m128d) (X), (int) (C), (__mmask8) (-1)))
+#define _mm_mask_fpclass_ss_mask(X, C, U) ((__mmask8) __builtin_ia32_fpclassss_mask ((__v4sf) (__m128) (X), (int) (C), (__mmask8) (U)))
+#define _mm_mask_fpclass_sd_mask(X, C, U) ((__mmask8) __builtin_ia32_fpclasssd_mask ((__v2df) (__m128d) (X), (int) (C), (__mmask8) (U)))
+#define _mm_reduce_sd(A, B, C) ((__m128d) __builtin_ia32_reducesd_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_avx512_setzero_pd (), (__mmask8)-1))
+#define _mm_mask_reduce_sd(W, U, A, B, C) ((__m128d) __builtin_ia32_reducesd_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U)))
+#define _mm_maskz_reduce_sd(U, A, B, C) ((__m128d) __builtin_ia32_reducesd_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_avx512_setzero_pd (), (__mmask8)(U)))
+#define _mm_reduce_round_sd(A, B, C, R) ((__m128d) __builtin_ia32_reducesd_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__mmask8)(U), (int)(R)))
+#define _mm_mask_reduce_round_sd(W, U, A, B, C, R) ((__m128d) __builtin_ia32_reducesd_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U), (int)(R)))
+#define _mm_maskz_reduce_round_sd(U, A, B, C, R) ((__m128d) __builtin_ia32_reducesd_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_avx512_setzero_pd (), (__mmask8)(U), (int)(R)))
+#define _mm_reduce_ss(A, B, C) ((__m128) __builtin_ia32_reducess_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8)-1))
+#define _mm_mask_reduce_ss(W, U, A, B, C) ((__m128) __builtin_ia32_reducess_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U)))
+#define _mm_maskz_reduce_ss(U, A, B, C) ((__m128) __builtin_ia32_reducess_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8)(U)))
+#define _mm_reduce_round_ss(A, B, C, R) ((__m128) __builtin_ia32_reducess_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__mmask8)(U), (int)(R)))
+#define _mm_mask_reduce_round_ss(W, U, A, B, C, R) ((__m128) __builtin_ia32_reducess_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U), (int)(R)))
+#define _mm_maskz_reduce_round_ss(U, A, B, C, R) ((__m128) __builtin_ia32_reducesd_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8)(U), (int)(R)))
+#endif
+#ifdef __DISABLE_AVX512DQ__
+#undef __DISABLE_AVX512DQ__
+#pragma GCC pop_options
+#endif
+#if !defined (__AVX512DQ__) || !defined (__EVEX512__)
+#pragma GCC push_options
+#pragma GCC target("avx512dq,evex512")
+#define __DISABLE_AVX512DQ_512__
+#endif
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_broadcast_f64x2 (__m128d __A)
@@ -939,18 +1263,6 @@ _mm512_maskz_cvtepu64_pd (__mmask8 __U, __m512i __A)
            _MM_FROUND_CUR_DIRECTION);
 }
 #ifdef __OPTIMIZE__
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kshiftli_mask8 (__mmask8 __A, unsigned int __B)
-{
-  return (__mmask8) __builtin_ia32_kshiftliqi ((__mmask8) __A, (__mmask8) __B);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kshiftri_mask8 (__mmask8 __A, unsigned int __B)
-{
-  return (__mmask8) __builtin_ia32_kshiftriqi ((__mmask8) __A, (__mmask8) __B);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_range_pd (__m512d __A, __m512d __B, int __C)
@@ -1017,276 +1329,6 @@ _mm512_maskz_range_ps (__mmask16 __U, __m512 __A, __m512 __B, int __C)
         (__mmask16) __U,
         _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_reduce_sd (__m128d __A, __m128d __B, int __C)
-{
-  return (__m128d) __builtin_ia32_reducesd_mask ((__v2df) __A,
-       (__v2df) __B, __C,
-       (__v2df) _mm_setzero_pd (),
-       (__mmask8) -1);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_reduce_round_sd (__m128d __A, __m128d __B, int __C, const int __R)
-{
-  return (__m128d) __builtin_ia32_reducesd_mask_round ((__v2df) __A,
-             (__v2df) __B, __C,
-             (__v2df)
-             _mm_setzero_pd (),
-             (__mmask8) -1, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_reduce_sd (__m128d __W, __mmask8 __U, __m128d __A,
-      __m128d __B, int __C)
-{
-  return (__m128d) __builtin_ia32_reducesd_mask ((__v2df) __A,
-       (__v2df) __B, __C,
-       (__v2df) __W,
-       (__mmask8) __U);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_reduce_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
-     __m128d __B, int __C, const int __R)
-{
-  return (__m128d) __builtin_ia32_reducesd_mask_round ((__v2df) __A,
-             (__v2df) __B, __C,
-             (__v2df) __W,
-             __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_reduce_sd (__mmask8 __U, __m128d __A, __m128d __B, int __C)
-{
-  return (__m128d) __builtin_ia32_reducesd_mask ((__v2df) __A,
-       (__v2df) __B, __C,
-       (__v2df) _mm_setzero_pd (),
-       (__mmask8) __U);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_reduce_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-      int __C, const int __R)
-{
-  return (__m128d) __builtin_ia32_reducesd_mask_round ((__v2df) __A,
-             (__v2df) __B, __C,
-             (__v2df)
-             _mm_setzero_pd (),
-             __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_reduce_ss (__m128 __A, __m128 __B, int __C)
-{
-  return (__m128) __builtin_ia32_reducess_mask ((__v4sf) __A,
-      (__v4sf) __B, __C,
-      (__v4sf) _mm_setzero_ps (),
-      (__mmask8) -1);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_reduce_round_ss (__m128 __A, __m128 __B, int __C, const int __R)
-{
-  return (__m128) __builtin_ia32_reducess_mask_round ((__v4sf) __A,
-            (__v4sf) __B, __C,
-            (__v4sf)
-            _mm_setzero_ps (),
-            (__mmask8) -1, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_reduce_ss (__m128 __W, __mmask8 __U, __m128 __A,
-      __m128 __B, int __C)
-{
-  return (__m128) __builtin_ia32_reducess_mask ((__v4sf) __A,
-      (__v4sf) __B, __C,
-      (__v4sf) __W,
-      (__mmask8) __U);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_reduce_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
-     __m128 __B, int __C, const int __R)
-{
-  return (__m128) __builtin_ia32_reducess_mask_round ((__v4sf) __A,
-            (__v4sf) __B, __C,
-            (__v4sf) __W,
-            __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_reduce_ss (__mmask8 __U, __m128 __A, __m128 __B, int __C)
-{
-  return (__m128) __builtin_ia32_reducess_mask ((__v4sf) __A,
-      (__v4sf) __B, __C,
-      (__v4sf) _mm_setzero_ps (),
-      (__mmask8) __U);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_reduce_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
-      int __C, const int __R)
-{
-  return (__m128) __builtin_ia32_reducess_mask_round ((__v4sf) __A,
-            (__v4sf) __B, __C,
-            (__v4sf)
-            _mm_setzero_ps (),
-            __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_range_sd (__m128d __A, __m128d __B, int __C)
-{
-  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
-         (__v2df) __B, __C,
-         (__v2df)
-         _mm_setzero_pd (),
-         (__mmask8) -1,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_range_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B, int __C)
-{
-  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
-         (__v2df) __B, __C,
-         (__v2df) __W,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_range_sd (__mmask8 __U, __m128d __A, __m128d __B, int __C)
-{
-  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
-         (__v2df) __B, __C,
-         (__v2df)
-         _mm_setzero_pd (),
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_range_ss (__m128 __A, __m128 __B, int __C)
-{
-  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
-        (__v4sf) __B, __C,
-        (__v4sf)
-        _mm_setzero_ps (),
-        (__mmask8) -1,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_range_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B, int __C)
-{
-  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
-        (__v4sf) __B, __C,
-        (__v4sf) __W,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_range_ss (__mmask8 __U, __m128 __A, __m128 __B, int __C)
-{
-  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
-        (__v4sf) __B, __C,
-        (__v4sf)
-        _mm_setzero_ps (),
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_range_round_sd (__m128d __A, __m128d __B, int __C, const int __R)
-{
-  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
-         (__v2df) __B, __C,
-         (__v2df)
-         _mm_setzero_pd (),
-         (__mmask8) -1, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_range_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
-    int __C, const int __R)
-{
-  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
-         (__v2df) __B, __C,
-         (__v2df) __W,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_range_round_sd (__mmask8 __U, __m128d __A, __m128d __B, int __C,
-     const int __R)
-{
-  return (__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df) __A,
-         (__v2df) __B, __C,
-         (__v2df)
-         _mm_setzero_pd (),
-         (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_range_round_ss (__m128 __A, __m128 __B, int __C, const int __R)
-{
-  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
-        (__v4sf) __B, __C,
-        (__v4sf)
-        _mm_setzero_ps (),
-        (__mmask8) -1, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_range_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
-    int __C, const int __R)
-{
-  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
-        (__v4sf) __B, __C,
-        (__v4sf) __W,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_range_round_ss (__mmask8 __U, __m128 __A, __m128 __B, int __C,
-     const int __R)
-{
-  return (__m128) __builtin_ia32_rangess128_mask_round ((__v4sf) __A,
-        (__v4sf) __B, __C,
-        (__v4sf)
-        _mm_setzero_ps (),
-        (__mmask8) __U, __R);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fpclass_ss_mask (__m128 __A, const int __imm)
-{
-  return (__mmask8) __builtin_ia32_fpclassss_mask ((__v4sf) __A, __imm,
-         (__mmask8) -1);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fpclass_sd_mask (__m128d __A, const int __imm)
-{
-  return (__mmask8) __builtin_ia32_fpclasssd_mask ((__v2df) __A, __imm,
-         (__mmask8) -1);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fpclass_ss_mask (__mmask8 __U, __m128 __A, const int __imm)
-{
-  return (__mmask8) __builtin_ia32_fpclassss_mask ((__v4sf) __A, __imm, __U);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fpclass_sd_mask (__mmask8 __U, __m128d __A, const int __imm)
-{
-  return (__mmask8) __builtin_ia32_fpclasssd_mask ((__v2df) __A, __imm, __U);
-}
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_cvtt_roundpd_epi64 (__m512d __A, const int __R)
@@ -2145,20 +2187,6 @@ _mm512_fpclass_ps_mask (__m512 __A, const int __imm)
              (__mmask16) -1);
 }
 #else
-#define _kshiftli_mask8(X, Y) ((__mmask8) __builtin_ia32_kshiftliqi ((__mmask8)(X), (__mmask8)(Y)))
-#define _kshiftri_mask8(X, Y) ((__mmask8) __builtin_ia32_kshiftriqi ((__mmask8)(X), (__mmask8)(Y)))
-#define _mm_range_sd(A, B, C) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_setzero_pd (), (__mmask8) -1, _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_range_sd(W, U, A, B, C) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_range_sd(U, A, B, C) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_setzero_pd (), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_range_ss(A, B, C) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_setzero_ps (), (__mmask8) -1, _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_range_ss(W, U, A, B, C) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_range_ss(U, A, B, C) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_setzero_ps (), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_range_round_sd(A, B, C, R) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_setzero_pd (), (__mmask8) -1, (R)))
-#define _mm_mask_range_round_sd(W, U, A, B, C, R) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U), (R)))
-#define _mm_maskz_range_round_sd(U, A, B, C, R) ((__m128d) __builtin_ia32_rangesd128_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_setzero_pd (), (__mmask8)(U), (R)))
-#define _mm_range_round_ss(A, B, C, R) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_setzero_ps (), (__mmask8) -1, (R)))
-#define _mm_mask_range_round_ss(W, U, A, B, C, R) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U), (R)))
-#define _mm_maskz_range_round_ss(U, A, B, C, R) ((__m128) __builtin_ia32_rangess128_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_setzero_ps (), (__mmask8)(U), (R)))
 #define _mm512_cvtt_roundpd_epi64(A, B) ((__m512i)__builtin_ia32_cvttpd2qq512_mask ((A), (__v8di) _mm512_setzero_si512 (), -1, (B)))
 #define _mm512_mask_cvtt_roundpd_epi64(W, U, A, B) ((__m512i)__builtin_ia32_cvttpd2qq512_mask ((A), (__v8di)(W), (U), (B)))
 #define _mm512_maskz_cvtt_roundpd_epi64(U, A, B) ((__m512i)__builtin_ia32_cvttpd2qq512_mask ((A), (__v8di)_mm512_setzero_si512 (), (U), (B)))
@@ -2243,29 +2271,13 @@ _mm512_fpclass_ps_mask (__m512 __A, const int __imm)
 #define _mm512_inserti32x8(X, Y, C) ((__m512i) __builtin_ia32_inserti32x8_mask ((__v16si)(__m512i) (X), (__v8si)(__m256i) (Y), (int) (C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)-1))
 #define _mm512_mask_inserti32x8(W, U, X, Y, C) ((__m512i) __builtin_ia32_inserti32x8_mask ((__v16si)(__m512i) (X), (__v8si)(__m256i) (Y), (int) (C), (__v16si)(__m512i)(W), (__mmask16)(U)))
 #define _mm512_maskz_inserti32x8(U, X, Y, C) ((__m512i) __builtin_ia32_inserti32x8_mask ((__v16si)(__m512i) (X), (__v8si)(__m256i) (Y), (int) (C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
-#define _mm_fpclass_ss_mask(X, C) ((__mmask8) __builtin_ia32_fpclassss_mask ((__v4sf) (__m128) (X), (int) (C), (__mmask8) (-1)))
-#define _mm_fpclass_sd_mask(X, C) ((__mmask8) __builtin_ia32_fpclasssd_mask ((__v2df) (__m128d) (X), (int) (C), (__mmask8) (-1)))
-#define _mm_mask_fpclass_ss_mask(X, C, U) ((__mmask8) __builtin_ia32_fpclassss_mask ((__v4sf) (__m128) (X), (int) (C), (__mmask8) (U)))
-#define _mm_mask_fpclass_sd_mask(X, C, U) ((__mmask8) __builtin_ia32_fpclasssd_mask ((__v2df) (__m128d) (X), (int) (C), (__mmask8) (U)))
 #define _mm512_mask_fpclass_pd_mask(u, X, C) ((__mmask8) __builtin_ia32_fpclasspd512_mask ((__v8df) (__m512d) (X), (int) (C), (__mmask8)(u)))
 #define _mm512_mask_fpclass_ps_mask(u, x, c) ((__mmask16) __builtin_ia32_fpclassps512_mask ((__v16sf) (__m512) (x), (int) (c),(__mmask16)(u)))
 #define _mm512_fpclass_pd_mask(X, C) ((__mmask8) __builtin_ia32_fpclasspd512_mask ((__v8df) (__m512d) (X), (int) (C), (__mmask8)-1))
 #define _mm512_fpclass_ps_mask(x, c) ((__mmask16) __builtin_ia32_fpclassps512_mask ((__v16sf) (__m512) (x), (int) (c),(__mmask16)-1))
-#define _mm_reduce_sd(A, B, C) ((__m128d) __builtin_ia32_reducesd_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_setzero_pd (), (__mmask8)-1))
-#define _mm_mask_reduce_sd(W, U, A, B, C) ((__m128d) __builtin_ia32_reducesd_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U)))
-#define _mm_maskz_reduce_sd(U, A, B, C) ((__m128d) __builtin_ia32_reducesd_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_setzero_pd (), (__mmask8)(U)))
-#define _mm_reduce_round_sd(A, B, C, R) ((__m128d) __builtin_ia32_reducesd_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__mmask8)(U), (int)(R)))
-#define _mm_mask_reduce_round_sd(W, U, A, B, C, R) ((__m128d) __builtin_ia32_reducesd_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U), (int)(R)))
-#define _mm_maskz_reduce_round_sd(U, A, B, C, R) ((__m128d) __builtin_ia32_reducesd_mask_round ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df) _mm_setzero_pd (), (__mmask8)(U), (int)(R)))
-#define _mm_reduce_ss(A, B, C) ((__m128) __builtin_ia32_reducess_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_setzero_ps (), (__mmask8)-1))
-#define _mm_mask_reduce_ss(W, U, A, B, C) ((__m128) __builtin_ia32_reducess_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U)))
-#define _mm_maskz_reduce_ss(U, A, B, C) ((__m128) __builtin_ia32_reducess_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_setzero_ps (), (__mmask8)(U)))
-#define _mm_reduce_round_ss(A, B, C, R) ((__m128) __builtin_ia32_reducess_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__mmask8)(U), (int)(R)))
-#define _mm_mask_reduce_round_ss(W, U, A, B, C, R) ((__m128) __builtin_ia32_reducess_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U), (int)(R)))
-#define _mm_maskz_reduce_round_ss(U, A, B, C, R) ((__m128) __builtin_ia32_reducesd_mask_round ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf) _mm_setzero_ps (), (__mmask8)(U), (int)(R)))
 #endif
-#ifdef __DISABLE_AVX512DQ__
-#undef __DISABLE_AVX512DQ__
+#ifdef __DISABLE_AVX512DQ_512__
+#undef __DISABLE_AVX512DQ_512__
 #pragma GCC pop_options
 #endif
 #endif
diff --git a/third_party/intel/avx512erintrin.internal.h b/third_party/intel/avx512erintrin.internal.h
index d50aba432..0422ce7c5 100644
--- a/third_party/intel/avx512erintrin.internal.h
+++ b/third_party/intel/avx512erintrin.internal.h
@@ -6,7 +6,7 @@
 #define _AVX512ERINTRIN_H_INCLUDED
 #ifndef __AVX512ER__
 #pragma GCC push_options
-#pragma GCC target("avx512er")
+#pragma GCC target("avx512er,evex512")
 #define __DISABLE_AVX512ER__
 #endif
 typedef double __v8df __attribute__ ((__vector_size__ (64)));
@@ -20,9 +20,8 @@ extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_exp2a23_round_pd (__m512d __A, int __R)
 {
-  __m512d __W;
   return (__m512d) __builtin_ia32_exp2pd_mask ((__v8df) __A,
-            (__v8df) __W,
+            (__v8df) _mm512_undefined_pd (),
             (__mmask8) -1, __R);
 }
 extern __inline __m512d
@@ -45,9 +44,8 @@ extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_exp2a23_round_ps (__m512 __A, int __R)
 {
-  __m512 __W;
   return (__m512) __builtin_ia32_exp2ps_mask ((__v16sf) __A,
-           (__v16sf) __W,
+           (__v16sf) _mm512_undefined_ps (),
            (__mmask16) -1, __R);
 }
 extern __inline __m512
@@ -70,9 +68,8 @@ extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_rcp28_round_pd (__m512d __A, int __R)
 {
-  __m512d __W;
   return (__m512d) __builtin_ia32_rcp28pd_mask ((__v8df) __A,
-      (__v8df) __W,
+      (__v8df) _mm512_undefined_pd (),
       (__mmask8) -1, __R);
 }
 extern __inline __m512d
@@ -95,9 +92,8 @@ extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_rcp28_round_ps (__m512 __A, int __R)
 {
-  __m512 __W;
   return (__m512) __builtin_ia32_rcp28ps_mask ((__v16sf) __A,
-            (__v16sf) __W,
+            (__v16sf) _mm512_undefined_ps (),
             (__mmask16) -1, __R);
 }
 extern __inline __m512
@@ -180,9 +176,8 @@ extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_rsqrt28_round_pd (__m512d __A, int __R)
 {
-  __m512d __W;
   return (__m512d) __builtin_ia32_rsqrt28pd_mask ((__v8df) __A,
-        (__v8df) __W,
+        (__v8df) _mm512_undefined_pd (),
         (__mmask8) -1, __R);
 }
 extern __inline __m512d
@@ -205,9 +200,8 @@ extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_rsqrt28_round_ps (__m512 __A, int __R)
 {
-  __m512 __W;
   return (__m512) __builtin_ia32_rsqrt28ps_mask ((__v16sf) __A,
-       (__v16sf) __W,
+       (__v16sf) _mm512_undefined_ps (),
        (__mmask16) -1, __R);
 }
 extern __inline __m512
diff --git a/third_party/intel/avx512fintrin.internal.h b/third_party/intel/avx512fintrin.internal.h
index a2c2c788c..b940a86ff 100644
--- a/third_party/intel/avx512fintrin.internal.h
+++ b/third_party/intel/avx512fintrin.internal.h
@@ -4,11 +4,2925 @@
 #endif
 #ifndef _AVX512FINTRIN_H_INCLUDED
 #define _AVX512FINTRIN_H_INCLUDED
-#ifndef __AVX512F__
+#if !defined (__AVX512F__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512f")
+#pragma GCC target("avx512f,no-evex512")
 #define __DISABLE_AVX512F__
 #endif
+typedef unsigned char __mmask8;
+typedef unsigned short __mmask16;
+typedef unsigned int __mmask32;
+typedef enum
+{
+  _MM_MANT_NORM_1_2,
+  _MM_MANT_NORM_p5_2,
+  _MM_MANT_NORM_p5_1,
+  _MM_MANT_NORM_p75_1p5
+} _MM_MANTISSA_NORM_ENUM;
+typedef enum
+{
+  _MM_MANT_SIGN_src,
+  _MM_MANT_SIGN_zero,
+  _MM_MANT_SIGN_nan
+} _MM_MANTISSA_SIGN_ENUM;
+extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_undefined_ps (void)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
+  __m128 __Y = __Y;
+#pragma GCC diagnostic pop
+  return __Y;
+}
+extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_undefined_pd (void)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
+  __m128d __Y = __Y;
+#pragma GCC diagnostic pop
+  return __Y;
+}
+extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_setzero_ps (void)
+{
+  return __extension__ (__m128){ 0.0f, 0.0f, 0.0f, 0.0f };
+}
+extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_setzero_pd (void)
+{
+  return __extension__ (__m128d){ 0.0, 0.0 };
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_add_round_sd (__m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_addsd_round ((__v2df) __A,
+            (__v2df) __B,
+            __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_add_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
+     __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_addsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_add_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+      const int __R)
+{
+  return (__m128d) __builtin_ia32_addsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_add_round_ss (__m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_addss_round ((__v4sf) __A,
+           (__v4sf) __B,
+           __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_add_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
+     __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_addss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_add_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
+      const int __R)
+{
+  return (__m128) __builtin_ia32_addss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sub_round_sd (__m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_subsd_round ((__v2df) __A,
+            (__v2df) __B,
+            __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_sub_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
+     __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_subsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_sub_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+      const int __R)
+{
+  return (__m128d) __builtin_ia32_subsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sub_round_ss (__m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_subss_round ((__v4sf) __A,
+           (__v4sf) __B,
+           __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_sub_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
+     __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_subss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_sub_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
+      const int __R)
+{
+  return (__m128) __builtin_ia32_subss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __U, __R);
+}
+#else
+#define _mm_add_round_sd(A, B, C) (__m128d)__builtin_ia32_addsd_round(A, B, C)
+#define _mm_mask_add_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_addsd_mask_round(A, B, W, U, C)
+#define _mm_maskz_add_round_sd(U, A, B, C) (__m128d)__builtin_ia32_addsd_mask_round(A, B, (__v2df)_mm_avx512_setzero_pd(), U, C)
+#define _mm_add_round_ss(A, B, C) (__m128)__builtin_ia32_addss_round(A, B, C)
+#define _mm_mask_add_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_addss_mask_round(A, B, W, U, C)
+#define _mm_maskz_add_round_ss(U, A, B, C) (__m128)__builtin_ia32_addss_mask_round(A, B, (__v4sf)_mm_avx512_setzero_ps(), U, C)
+#define _mm_sub_round_sd(A, B, C) (__m128d)__builtin_ia32_subsd_round(A, B, C)
+#define _mm_mask_sub_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_subsd_mask_round(A, B, W, U, C)
+#define _mm_maskz_sub_round_sd(U, A, B, C) (__m128d)__builtin_ia32_subsd_mask_round(A, B, (__v2df)_mm_avx512_setzero_pd(), U, C)
+#define _mm_sub_round_ss(A, B, C) (__m128)__builtin_ia32_subss_round(A, B, C)
+#define _mm_mask_sub_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_subss_mask_round(A, B, W, U, C)
+#define _mm_maskz_sub_round_ss(U, A, B, C) (__m128)__builtin_ia32_subss_mask_round(A, B, (__v4sf)_mm_avx512_setzero_ps(), U, C)
+#endif
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_rcp14_sd (__m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_rcp14sd ((__v2df) __B,
+        (__v2df) __A);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_rcp14_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_rcp14sd_mask ((__v2df) __B,
+      (__v2df) __A,
+      (__v2df) __W,
+      (__mmask8) __U);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_rcp14_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_rcp14sd_mask ((__v2df) __B,
+      (__v2df) __A,
+      (__v2df) _mm_avx512_setzero_ps (),
+      (__mmask8) __U);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_rcp14_ss (__m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_rcp14ss ((__v4sf) __B,
+       (__v4sf) __A);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_rcp14_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __B,
+      (__v4sf) __A,
+      (__v4sf) __W,
+      (__mmask8) __U);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_rcp14_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __B,
+      (__v4sf) __A,
+      (__v4sf) _mm_avx512_setzero_ps (),
+      (__mmask8) __U);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_rsqrt14_sd (__m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_rsqrt14sd ((__v2df) __B,
+          (__v2df) __A);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_rsqrt14_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_rsqrt14sd_mask ((__v2df) __B,
+       (__v2df) __A,
+       (__v2df) __W,
+       (__mmask8) __U);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_rsqrt14_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_rsqrt14sd_mask ((__v2df) __B,
+       (__v2df) __A,
+       (__v2df) _mm_avx512_setzero_pd (),
+       (__mmask8) __U);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_rsqrt14_ss (__m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_rsqrt14ss ((__v4sf) __B,
+         (__v4sf) __A);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_rsqrt14_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __B,
+       (__v4sf) __A,
+       (__v4sf) __W,
+       (__mmask8) __U);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_rsqrt14_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __B,
+      (__v4sf) __A,
+      (__v4sf) _mm_avx512_setzero_ps (),
+      (__mmask8) __U);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sqrt_round_sd (__m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_sqrtsd_mask_round ((__v2df) __B,
+           (__v2df) __A,
+           (__v2df)
+           _mm_avx512_setzero_pd (),
+           (__mmask8) -1, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_sqrt_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
+   const int __R)
+{
+  return (__m128d) __builtin_ia32_sqrtsd_mask_round ((__v2df) __B,
+           (__v2df) __A,
+           (__v2df) __W,
+           (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_sqrt_round_sd (__mmask8 __U, __m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_sqrtsd_mask_round ((__v2df) __B,
+           (__v2df) __A,
+           (__v2df)
+           _mm_avx512_setzero_pd (),
+           (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sqrt_round_ss (__m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_sqrtss_mask_round ((__v4sf) __B,
+          (__v4sf) __A,
+          (__v4sf)
+          _mm_avx512_setzero_ps (),
+          (__mmask8) -1, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_sqrt_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
+   const int __R)
+{
+  return (__m128) __builtin_ia32_sqrtss_mask_round ((__v4sf) __B,
+          (__v4sf) __A,
+          (__v4sf) __W,
+          (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_sqrt_round_ss (__mmask8 __U, __m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_sqrtss_mask_round ((__v4sf) __B,
+          (__v4sf) __A,
+          (__v4sf)
+          _mm_avx512_setzero_ps (),
+          (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mul_round_sd (__m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_mulsd_round ((__v2df) __A,
+            (__v2df) __B,
+            __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_mul_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
+     __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_mulsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_mul_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+      const int __R)
+{
+  return (__m128d) __builtin_ia32_mulsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mul_round_ss (__m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_mulss_round ((__v4sf) __A,
+           (__v4sf) __B,
+           __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_mul_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
+     __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_mulss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_mul_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
+      const int __R)
+{
+  return (__m128) __builtin_ia32_mulss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_div_round_sd (__m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_divsd_round ((__v2df) __A,
+            (__v2df) __B,
+            __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_div_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
+     __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_divsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_div_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+      const int __R)
+{
+  return (__m128d) __builtin_ia32_divsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_div_round_ss (__m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_divss_round ((__v4sf) __A,
+           (__v4sf) __B,
+           __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_div_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
+     __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_divss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_div_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
+      const int __R)
+{
+  return (__m128) __builtin_ia32_divss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_scalef_round_sd (__m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_scalefsd_mask_round ((__v2df) __A,
+             (__v2df) __B,
+             (__v2df)
+             _mm_avx512_setzero_pd (),
+             (__mmask8) -1, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_scalef_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
+     const int __R)
+{
+  return (__m128d) __builtin_ia32_scalefsd_mask_round ((__v2df) __A,
+             (__v2df) __B,
+             (__v2df) __W,
+             (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_scalef_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+      const int __R)
+{
+  return (__m128d) __builtin_ia32_scalefsd_mask_round ((__v2df) __A,
+             (__v2df) __B,
+             (__v2df)
+             _mm_avx512_setzero_pd (),
+             (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_scalef_round_ss (__m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_scalefss_mask_round ((__v4sf) __A,
+            (__v4sf) __B,
+            (__v4sf)
+            _mm_avx512_setzero_ps (),
+            (__mmask8) -1, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_scalef_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
+    const int __R)
+{
+  return (__m128) __builtin_ia32_scalefss_mask_round ((__v4sf) __A,
+            (__v4sf) __B,
+            (__v4sf) __W,
+            (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_scalef_round_ss (__mmask8 __U, __m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_scalefss_mask_round ((__v4sf) __A,
+            (__v4sf) __B,
+            (__v4sf)
+            _mm_avx512_setzero_ps (),
+            (__mmask8) __U, __R);
+}
+#else
+#define _mm_sqrt_round_sd(A, B, C) (__m128d)__builtin_ia32_sqrtsd_mask_round (B, A, (__v2df) _mm_avx512_setzero_pd (), -1, C)
+#define _mm_mask_sqrt_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_sqrtsd_mask_round (B, A, W, U, C)
+#define _mm_maskz_sqrt_round_sd(U, A, B, C) (__m128d)__builtin_ia32_sqrtsd_mask_round (B, A, (__v2df) _mm_avx512_setzero_pd (), U, C)
+#define _mm_sqrt_round_ss(A, B, C) (__m128)__builtin_ia32_sqrtss_mask_round (B, A, (__v4sf) _mm_avx512_setzero_ps (), -1, C)
+#define _mm_mask_sqrt_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_sqrtss_mask_round (B, A, W, U, C)
+#define _mm_maskz_sqrt_round_ss(U, A, B, C) (__m128)__builtin_ia32_sqrtss_mask_round (B, A, (__v4sf) _mm_avx512_setzero_ps (), U, C)
+#define _mm_mul_round_sd(A, B, C) (__m128d)__builtin_ia32_mulsd_round(A, B, C)
+#define _mm_mask_mul_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_mulsd_mask_round(A, B, W, U, C)
+#define _mm_maskz_mul_round_sd(U, A, B, C) (__m128d)__builtin_ia32_mulsd_mask_round(A, B, (__v2df)_mm_avx512_setzero_pd(), U, C)
+#define _mm_mul_round_ss(A, B, C) (__m128)__builtin_ia32_mulss_round(A, B, C)
+#define _mm_mask_mul_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_mulss_mask_round(A, B, W, U, C)
+#define _mm_maskz_mul_round_ss(U, A, B, C) (__m128)__builtin_ia32_mulss_mask_round(A, B, (__v4sf)_mm_avx512_setzero_ps(), U, C)
+#define _mm_div_round_sd(A, B, C) (__m128d)__builtin_ia32_divsd_round(A, B, C)
+#define _mm_mask_div_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_divsd_mask_round(A, B, W, U, C)
+#define _mm_maskz_div_round_sd(U, A, B, C) (__m128d)__builtin_ia32_divsd_mask_round(A, B, (__v2df)_mm_avx512_setzero_pd(), U, C)
+#define _mm_div_round_ss(A, B, C) (__m128)__builtin_ia32_divss_round(A, B, C)
+#define _mm_mask_div_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_divss_mask_round(A, B, W, U, C)
+#define _mm_maskz_div_round_ss(U, A, B, C) (__m128)__builtin_ia32_divss_mask_round(A, B, (__v4sf)_mm_avx512_setzero_ps(), U, C)
+#define _mm_scalef_round_sd(A, B, C) ((__m128d) __builtin_ia32_scalefsd_mask_round ((A), (B), (__v2df) _mm_avx512_undefined_pd (), -1, (C)))
+#define _mm_scalef_round_ss(A, B, C) ((__m128) __builtin_ia32_scalefss_mask_round ((A), (B), (__v4sf) _mm_avx512_undefined_ps (), -1, (C)))
+#define _mm_mask_scalef_round_sd(W, U, A, B, C) ((__m128d) __builtin_ia32_scalefsd_mask_round ((A), (B), (W), (U), (C)))
+#define _mm_mask_scalef_round_ss(W, U, A, B, C) ((__m128) __builtin_ia32_scalefss_mask_round ((A), (B), (W), (U), (C)))
+#define _mm_maskz_scalef_round_sd(U, A, B, C) ((__m128d) __builtin_ia32_scalefsd_mask_round ((A), (B), (__v2df) _mm_avx512_setzero_pd (), (U), (C)))
+#define _mm_maskz_scalef_round_ss(U, A, B, C) ((__m128) __builtin_ia32_scalefss_mask_round ((A), (B), (__v4sf) _mm_avx512_setzero_ps (), (U), (C)))
+#endif
+#define _mm_mask_sqrt_sd(W, U, A, B) _mm_mask_sqrt_round_sd ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#define _mm_maskz_sqrt_sd(U, A, B) _mm_maskz_sqrt_round_sd ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#define _mm_mask_sqrt_ss(W, U, A, B) _mm_mask_sqrt_round_ss ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#define _mm_maskz_sqrt_ss(U, A, B) _mm_maskz_sqrt_round_ss ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#define _mm_mask_scalef_sd(W, U, A, B) _mm_mask_scalef_round_sd ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#define _mm_maskz_scalef_sd(U, A, B) _mm_maskz_scalef_round_sd ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#define _mm_mask_scalef_ss(W, U, A, B) _mm_mask_scalef_round_ss ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#define _mm_maskz_scalef_ss(U, A, B) _mm_maskz_scalef_round_ss ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtu32_sd (__m128d __A, unsigned __B)
+{
+  return (__m128d) __builtin_ia32_cvtusi2sd32 ((__v2df) __A, __B);
+}
+#ifdef __x86_64__
+#ifdef __OPTIMIZE__
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundu64_sd (__m128d __A, unsigned long long __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_cvtusi2sd64 ((__v2df) __A, __B, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundi64_sd (__m128d __A, long long __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_cvtsi2sd64 ((__v2df) __A, __B, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsi64_sd (__m128d __A, long long __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_cvtsi2sd64 ((__v2df) __A, __B, __R);
+}
+#else
+#define _mm_cvt_roundu64_sd(A, B, C) (__m128d)__builtin_ia32_cvtusi2sd64(A, B, C)
+#define _mm_cvt_roundi64_sd(A, B, C) (__m128d)__builtin_ia32_cvtsi2sd64(A, B, C)
+#define _mm_cvt_roundsi64_sd(A, B, C) (__m128d)__builtin_ia32_cvtsi2sd64(A, B, C)
+#endif
+#endif
+#ifdef __OPTIMIZE__
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundu32_ss (__m128 __A, unsigned __B, const int __R)
+{
+  return (__m128) __builtin_ia32_cvtusi2ss32 ((__v4sf) __A, __B, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsi32_ss (__m128 __A, int __B, const int __R)
+{
+  return (__m128) __builtin_ia32_cvtsi2ss32 ((__v4sf) __A, __B, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundi32_ss (__m128 __A, int __B, const int __R)
+{
+  return (__m128) __builtin_ia32_cvtsi2ss32 ((__v4sf) __A, __B, __R);
+}
+#else
+#define _mm_cvt_roundu32_ss(A, B, C) (__m128)__builtin_ia32_cvtusi2ss32(A, B, C)
+#define _mm_cvt_roundi32_ss(A, B, C) (__m128)__builtin_ia32_cvtsi2ss32(A, B, C)
+#define _mm_cvt_roundsi32_ss(A, B, C) (__m128)__builtin_ia32_cvtsi2ss32(A, B, C)
+#endif
+#ifdef __x86_64__
+#ifdef __OPTIMIZE__
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundu64_ss (__m128 __A, unsigned long long __B, const int __R)
+{
+  return (__m128) __builtin_ia32_cvtusi2ss64 ((__v4sf) __A, __B, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsi64_ss (__m128 __A, long long __B, const int __R)
+{
+  return (__m128) __builtin_ia32_cvtsi2ss64 ((__v4sf) __A, __B, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundi64_ss (__m128 __A, long long __B, const int __R)
+{
+  return (__m128) __builtin_ia32_cvtsi2ss64 ((__v4sf) __A, __B, __R);
+}
+#else
+#define _mm_cvt_roundu64_ss(A, B, C) (__m128)__builtin_ia32_cvtusi2ss64(A, B, C)
+#define _mm_cvt_roundi64_ss(A, B, C) (__m128)__builtin_ia32_cvtsi2ss64(A, B, C)
+#define _mm_cvt_roundsi64_ss(A, B, C) (__m128)__builtin_ia32_cvtsi2ss64(A, B, C)
+#endif
+#endif
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_load_ss (__m128 __W, __mmask8 __U, const float *__P)
+{
+  return (__m128) __builtin_ia32_loadss_mask (__P, (__v4sf) __W, __U);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_load_ss (__mmask8 __U, const float *__P)
+{
+  return (__m128) __builtin_ia32_loadss_mask (__P, (__v4sf) _mm_avx512_setzero_ps (),
+           __U);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_load_sd (__m128d __W, __mmask8 __U, const double *__P)
+{
+  return (__m128d) __builtin_ia32_loadsd_mask (__P, (__v2df) __W, __U);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_load_sd (__mmask8 __U, const double *__P)
+{
+  return (__m128d) __builtin_ia32_loadsd_mask (__P, (__v2df) _mm_avx512_setzero_pd (),
+            __U);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_move_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_movess_mask ((__v4sf) __A, (__v4sf) __B,
+           (__v4sf) __W, __U);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_move_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_movess_mask ((__v4sf) __A, (__v4sf) __B,
+           (__v4sf) _mm_avx512_setzero_ps (), __U);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_move_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_movesd_mask ((__v2df) __A, (__v2df) __B,
+            (__v2df) __W, __U);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_move_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_movesd_mask ((__v2df) __A, (__v2df) __B,
+            (__v2df) _mm_avx512_setzero_pd (),
+            __U);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_store_ss (float *__P, __mmask8 __U, __m128 __A)
+{
+  __builtin_ia32_storess_mask (__P, (__v4sf) __A, (__mmask8) __U);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_store_sd (double *__P, __mmask8 __U, __m128d __A)
+{
+  __builtin_ia32_storesd_mask (__P, (__v2df) __A, (__mmask8) __U);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fixupimm_round_sd (__m128d __A, __m128d __B, __m128i __C,
+         const int __imm, const int __R)
+{
+  return (__m128d) __builtin_ia32_fixupimmsd_mask ((__v2df) __A,
+         (__v2df) __B,
+         (__v2di) __C, __imm,
+         (__mmask8) -1, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fixupimm_round_sd (__m128d __A, __mmask8 __U, __m128d __B,
+       __m128i __C, const int __imm, const int __R)
+{
+  return (__m128d) __builtin_ia32_fixupimmsd_mask ((__v2df) __A,
+         (__v2df) __B,
+         (__v2di) __C, __imm,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fixupimm_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+        __m128i __C, const int __imm, const int __R)
+{
+  return (__m128d) __builtin_ia32_fixupimmsd_maskz ((__v2df) __A,
+          (__v2df) __B,
+          (__v2di) __C,
+          __imm,
+          (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fixupimm_round_ss (__m128 __A, __m128 __B, __m128i __C,
+         const int __imm, const int __R)
+{
+  return (__m128) __builtin_ia32_fixupimmss_mask ((__v4sf) __A,
+        (__v4sf) __B,
+        (__v4si) __C, __imm,
+        (__mmask8) -1, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fixupimm_round_ss (__m128 __A, __mmask8 __U, __m128 __B,
+       __m128i __C, const int __imm, const int __R)
+{
+  return (__m128) __builtin_ia32_fixupimmss_mask ((__v4sf) __A,
+        (__v4sf) __B,
+        (__v4si) __C, __imm,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fixupimm_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
+        __m128i __C, const int __imm, const int __R)
+{
+  return (__m128) __builtin_ia32_fixupimmss_maskz ((__v4sf) __A,
+         (__v4sf) __B,
+         (__v4si) __C, __imm,
+         (__mmask8) __U, __R);
+}
+#else
+#define _mm_fixupimm_round_sd(X, Y, Z, C, R) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(-1), (R)))
+#define _mm_mask_fixupimm_round_sd(X, U, Y, Z, C, R) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
+#define _mm_maskz_fixupimm_round_sd(U, X, Y, Z, C, R) ((__m128d)__builtin_ia32_fixupimmsd_maskz ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
+#define _mm_fixupimm_round_ss(X, Y, Z, C, R) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1), (R)))
+#define _mm_mask_fixupimm_round_ss(X, U, Y, Z, C, R) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
+#define _mm_maskz_fixupimm_round_ss(U, X, Y, Z, C, R) ((__m128)__builtin_ia32_fixupimmss_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
+#endif
+#ifdef __x86_64__
+#ifdef __OPTIMIZE__
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundss_u64 (__m128 __A, const int __R)
+{
+  return (unsigned long long) __builtin_ia32_vcvtss2usi64 ((__v4sf) __A, __R);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundss_si64 (__m128 __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvtss2si64 ((__v4sf) __A, __R);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundss_i64 (__m128 __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvtss2si64 ((__v4sf) __A, __R);
+}
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundss_u64 (__m128 __A, const int __R)
+{
+  return (unsigned long long) __builtin_ia32_vcvttss2usi64 ((__v4sf) __A, __R);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundss_i64 (__m128 __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvttss2si64 ((__v4sf) __A, __R);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundss_si64 (__m128 __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvttss2si64 ((__v4sf) __A, __R);
+}
+#else
+#define _mm_cvt_roundss_u64(A, B) ((unsigned long long)__builtin_ia32_vcvtss2usi64(A, B))
+#define _mm_cvt_roundss_si64(A, B) ((long long)__builtin_ia32_vcvtss2si64(A, B))
+#define _mm_cvt_roundss_i64(A, B) ((long long)__builtin_ia32_vcvtss2si64(A, B))
+#define _mm_cvtt_roundss_u64(A, B) ((unsigned long long)__builtin_ia32_vcvttss2usi64(A, B))
+#define _mm_cvtt_roundss_i64(A, B) ((long long)__builtin_ia32_vcvttss2si64(A, B))
+#define _mm_cvtt_roundss_si64(A, B) ((long long)__builtin_ia32_vcvttss2si64(A, B))
+#endif
+#endif
+#ifdef __OPTIMIZE__
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundss_u32 (__m128 __A, const int __R)
+{
+  return (unsigned) __builtin_ia32_vcvtss2usi32 ((__v4sf) __A, __R);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundss_si32 (__m128 __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvtss2si32 ((__v4sf) __A, __R);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundss_i32 (__m128 __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvtss2si32 ((__v4sf) __A, __R);
+}
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundss_u32 (__m128 __A, const int __R)
+{
+  return (unsigned) __builtin_ia32_vcvttss2usi32 ((__v4sf) __A, __R);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundss_i32 (__m128 __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvttss2si32 ((__v4sf) __A, __R);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundss_si32 (__m128 __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvttss2si32 ((__v4sf) __A, __R);
+}
+#else
+#define _mm_cvt_roundss_u32(A, B) ((unsigned)__builtin_ia32_vcvtss2usi32(A, B))
+#define _mm_cvt_roundss_si32(A, B) ((int)__builtin_ia32_vcvtss2si32(A, B))
+#define _mm_cvt_roundss_i32(A, B) ((int)__builtin_ia32_vcvtss2si32(A, B))
+#define _mm_cvtt_roundss_u32(A, B) ((unsigned)__builtin_ia32_vcvttss2usi32(A, B))
+#define _mm_cvtt_roundss_si32(A, B) ((int)__builtin_ia32_vcvttss2si32(A, B))
+#define _mm_cvtt_roundss_i32(A, B) ((int)__builtin_ia32_vcvttss2si32(A, B))
+#endif
+#ifdef __x86_64__
+#ifdef __OPTIMIZE__
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsd_u64 (__m128d __A, const int __R)
+{
+  return (unsigned long long) __builtin_ia32_vcvtsd2usi64 ((__v2df) __A, __R);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsd_si64 (__m128d __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvtsd2si64 ((__v2df) __A, __R);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsd_i64 (__m128d __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvtsd2si64 ((__v2df) __A, __R);
+}
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundsd_u64 (__m128d __A, const int __R)
+{
+  return (unsigned long long) __builtin_ia32_vcvttsd2usi64 ((__v2df) __A, __R);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundsd_si64 (__m128d __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvttsd2si64 ((__v2df) __A, __R);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundsd_i64 (__m128d __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvttsd2si64 ((__v2df) __A, __R);
+}
+#else
+#define _mm_cvt_roundsd_u64(A, B) ((unsigned long long)__builtin_ia32_vcvtsd2usi64(A, B))
+#define _mm_cvt_roundsd_si64(A, B) ((long long)__builtin_ia32_vcvtsd2si64(A, B))
+#define _mm_cvt_roundsd_i64(A, B) ((long long)__builtin_ia32_vcvtsd2si64(A, B))
+#define _mm_cvtt_roundsd_u64(A, B) ((unsigned long long)__builtin_ia32_vcvttsd2usi64(A, B))
+#define _mm_cvtt_roundsd_si64(A, B) ((long long)__builtin_ia32_vcvttsd2si64(A, B))
+#define _mm_cvtt_roundsd_i64(A, B) ((long long)__builtin_ia32_vcvttsd2si64(A, B))
+#endif
+#endif
+#ifdef __OPTIMIZE__
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsd_u32 (__m128d __A, const int __R)
+{
+  return (unsigned) __builtin_ia32_vcvtsd2usi32 ((__v2df) __A, __R);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsd_si32 (__m128d __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvtsd2si32 ((__v2df) __A, __R);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsd_i32 (__m128d __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvtsd2si32 ((__v2df) __A, __R);
+}
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundsd_u32 (__m128d __A, const int __R)
+{
+  return (unsigned) __builtin_ia32_vcvttsd2usi32 ((__v2df) __A, __R);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundsd_i32 (__m128d __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvttsd2si32 ((__v2df) __A, __R);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundsd_si32 (__m128d __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvttsd2si32 ((__v2df) __A, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsd_ss (__m128 __A, __m128d __B, const int __R)
+{
+  return (__m128) __builtin_ia32_cvtsd2ss_round ((__v4sf) __A,
+       (__v2df) __B,
+       __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cvt_roundsd_ss (__m128 __W, __mmask8 __U, __m128 __A,
+    __m128d __B, const int __R)
+{
+  return (__m128) __builtin_ia32_cvtsd2ss_mask_round ((__v4sf) __A,
+            (__v2df) __B,
+            (__v4sf) __W,
+            __U,
+            __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_cvt_roundsd_ss (__mmask8 __U, __m128 __A,
+    __m128d __B, const int __R)
+{
+  return (__m128) __builtin_ia32_cvtsd2ss_mask_round ((__v4sf) __A,
+            (__v2df) __B,
+            _mm_avx512_setzero_ps (),
+            __U,
+            __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundss_sd (__m128d __A, __m128 __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_cvtss2sd_round ((__v2df) __A,
+        (__v4sf) __B,
+        __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cvt_roundss_sd (__m128d __W, __mmask8 __U, __m128d __A,
+    __m128 __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_cvtss2sd_mask_round ((__v2df) __A,
+             (__v4sf) __B,
+             (__v2df) __W,
+             __U,
+             __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_cvt_roundss_sd (__mmask8 __U, __m128d __A,
+     __m128 __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_cvtss2sd_mask_round ((__v2df) __A,
+             (__v4sf) __B,
+             _mm_avx512_setzero_pd (),
+             __U,
+             __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getexp_round_ss (__m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_getexpss128_round ((__v4sf) __A,
+          (__v4sf) __B,
+          __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getexp_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
+     __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_getexpss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getexp_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
+      const int __R)
+{
+  return (__m128) __builtin_ia32_getexpss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getexp_round_sd (__m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_getexpsd128_round ((__v2df) __A,
+           (__v2df) __B,
+           __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getexp_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
+     __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_getexpsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getexp_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+      const int __R)
+{
+  return (__m128d) __builtin_ia32_getexpsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getmant_round_sd (__m128d __A, __m128d __B,
+        _MM_MANTISSA_NORM_ENUM __C,
+        _MM_MANTISSA_SIGN_ENUM __D, const int __R)
+{
+  return (__m128d) __builtin_ia32_getmantsd_round ((__v2df) __A,
+        (__v2df) __B,
+        (__D << 2) | __C,
+         __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getmant_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
+         __m128d __B, _MM_MANTISSA_NORM_ENUM __C,
+         _MM_MANTISSA_SIGN_ENUM __D, const int __R)
+{
+  return (__m128d) __builtin_ia32_getmantsd_mask_round ((__v2df) __A,
+          (__v2df) __B,
+          (__D << 2) | __C,
+                                                    (__v2df) __W,
+           __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getmant_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+          _MM_MANTISSA_NORM_ENUM __C,
+          _MM_MANTISSA_SIGN_ENUM __D, const int __R)
+{
+  return (__m128d) __builtin_ia32_getmantsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+              (__D << 2) | __C,
+                                                        (__v2df)
+                                                        _mm_avx512_setzero_pd(),
+              __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getmant_round_ss (__m128 __A, __m128 __B,
+        _MM_MANTISSA_NORM_ENUM __C,
+        _MM_MANTISSA_SIGN_ENUM __D, const int __R)
+{
+  return (__m128) __builtin_ia32_getmantss_round ((__v4sf) __A,
+        (__v4sf) __B,
+        (__D << 2) | __C,
+        __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getmant_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
+         __m128 __B, _MM_MANTISSA_NORM_ENUM __C,
+         _MM_MANTISSA_SIGN_ENUM __D, const int __R)
+{
+  return (__m128) __builtin_ia32_getmantss_mask_round ((__v4sf) __A,
+          (__v4sf) __B,
+          (__D << 2) | __C,
+                                                    (__v4sf) __W,
+           __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getmant_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
+          _MM_MANTISSA_NORM_ENUM __C,
+          _MM_MANTISSA_SIGN_ENUM __D, const int __R)
+{
+  return (__m128) __builtin_ia32_getmantss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+              (__D << 2) | __C,
+                                                        (__v4sf)
+                                                        _mm_avx512_setzero_ps(),
+              __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_roundscale_round_ss (__m128 __A, __m128 __B, const int __imm,
+    const int __R)
+{
+  return (__m128)
+    __builtin_ia32_rndscaless_mask_round ((__v4sf) __A,
+       (__v4sf) __B, __imm,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) -1,
+       __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_roundscale_round_ss (__m128 __A, __mmask8 __B, __m128 __C,
+         __m128 __D, const int __imm, const int __R)
+{
+  return (__m128)
+    __builtin_ia32_rndscaless_mask_round ((__v4sf) __C,
+       (__v4sf) __D, __imm,
+       (__v4sf) __A,
+       (__mmask8) __B,
+       __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_roundscale_round_ss (__mmask8 __A, __m128 __B, __m128 __C,
+          const int __imm, const int __R)
+{
+  return (__m128)
+    __builtin_ia32_rndscaless_mask_round ((__v4sf) __B,
+       (__v4sf) __C, __imm,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __A,
+       __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_roundscale_round_sd (__m128d __A, __m128d __B, const int __imm,
+    const int __R)
+{
+  return (__m128d)
+    __builtin_ia32_rndscalesd_mask_round ((__v2df) __A,
+       (__v2df) __B, __imm,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) -1,
+       __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_roundscale_round_sd (__m128d __A, __mmask8 __B, __m128d __C,
+         __m128d __D, const int __imm, const int __R)
+{
+  return (__m128d)
+    __builtin_ia32_rndscalesd_mask_round ((__v2df) __C,
+       (__v2df) __D, __imm,
+       (__v2df) __A,
+       (__mmask8) __B,
+       __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_roundscale_round_sd (__mmask8 __A, __m128d __B, __m128d __C,
+          const int __imm, const int __R)
+{
+  return (__m128d)
+    __builtin_ia32_rndscalesd_mask_round ((__v2df) __B,
+       (__v2df) __C, __imm,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __A,
+       __R);
+}
+#else
+#define _mm_cvt_roundsd_u32(A, B) ((unsigned)__builtin_ia32_vcvtsd2usi32(A, B))
+#define _mm_cvt_roundsd_si32(A, B) ((int)__builtin_ia32_vcvtsd2si32(A, B))
+#define _mm_cvt_roundsd_i32(A, B) ((int)__builtin_ia32_vcvtsd2si32(A, B))
+#define _mm_cvtt_roundsd_u32(A, B) ((unsigned)__builtin_ia32_vcvttsd2usi32(A, B))
+#define _mm_cvtt_roundsd_si32(A, B) ((int)__builtin_ia32_vcvttsd2si32(A, B))
+#define _mm_cvtt_roundsd_i32(A, B) ((int)__builtin_ia32_vcvttsd2si32(A, B))
+#define _mm_cvt_roundsd_ss(A, B, C) (__m128)__builtin_ia32_cvtsd2ss_round(A, B, C)
+#define _mm_mask_cvt_roundsd_ss(W, U, A, B, C) (__m128)__builtin_ia32_cvtsd2ss_mask_round ((A), (B), (W), (U), (C))
+#define _mm_maskz_cvt_roundsd_ss(U, A, B, C) (__m128)__builtin_ia32_cvtsd2ss_mask_round ((A), (B), _mm_avx512_setzero_ps (), (U), (C))
+#define _mm_cvt_roundss_sd(A, B, C) (__m128d)__builtin_ia32_cvtss2sd_round(A, B, C)
+#define _mm_mask_cvt_roundss_sd(W, U, A, B, C) (__m128d)__builtin_ia32_cvtss2sd_mask_round ((A), (B), (W), (U), (C))
+#define _mm_maskz_cvt_roundss_sd(U, A, B, C) (__m128d)__builtin_ia32_cvtss2sd_mask_round ((A), (B), _mm_avx512_setzero_pd (), (U), (C))
+#define _mm_getmant_round_sd(X, Y, C, D, R) ((__m128d)__builtin_ia32_getmantsd_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (R)))
+#define _mm_mask_getmant_round_sd(W, U, X, Y, C, D, R) ((__m128d)__builtin_ia32_getmantsd_mask_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (__v2df)(__m128d)(W), (__mmask8)(U), (R)))
+#define _mm_maskz_getmant_round_sd(U, X, Y, C, D, R) ((__m128d)__builtin_ia32_getmantsd_mask_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (__v2df)(__m128d)_mm_avx512_setzero_pd(), (__mmask8)(U), (R)))
+#define _mm_getmant_round_ss(X, Y, C, D, R) ((__m128)__builtin_ia32_getmantss_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (R)))
+#define _mm_mask_getmant_round_ss(W, U, X, Y, C, D, R) ((__m128)__builtin_ia32_getmantss_mask_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (__v4sf)(__m128)(W), (__mmask8)(U), (R)))
+#define _mm_maskz_getmant_round_ss(U, X, Y, C, D, R) ((__m128)__builtin_ia32_getmantss_mask_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (__v4sf)(__m128)_mm_avx512_setzero_ps(), (__mmask8)(U), (R)))
+#define _mm_getexp_round_ss(A, B, R) ((__m128)__builtin_ia32_getexpss128_round((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), R))
+#define _mm_mask_getexp_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_getexpss_mask_round(A, B, W, U, C)
+#define _mm_maskz_getexp_round_ss(U, A, B, C) (__m128)__builtin_ia32_getexpss_mask_round(A, B, (__v4sf)_mm_avx512_setzero_ps(), U, C)
+#define _mm_getexp_round_sd(A, B, R) ((__m128d)__builtin_ia32_getexpsd128_round((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), R))
+#define _mm_mask_getexp_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_getexpsd_mask_round(A, B, W, U, C)
+#define _mm_maskz_getexp_round_sd(U, A, B, C) (__m128d)__builtin_ia32_getexpsd_mask_round(A, B, (__v2df)_mm_avx512_setzero_pd(), U, C)
+#define _mm_roundscale_round_ss(A, B, I, R) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (A), (__v4sf) (__m128) (B), (int) (I), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8) (-1), (int) (R)))
+#define _mm_mask_roundscale_round_ss(A, U, B, C, I, R) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (B), (__v4sf) (__m128) (C), (int) (I), (__v4sf) (__m128) (A), (__mmask8) (U), (int) (R)))
+#define _mm_maskz_roundscale_round_ss(U, A, B, I, R) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (A), (__v4sf) (__m128) (B), (int) (I), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8) (U), (int) (R)))
+#define _mm_roundscale_round_sd(A, B, I, R) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (A), (__v2df) (__m128d) (B), (int) (I), (__v2df) _mm_avx512_setzero_pd (), (__mmask8) (-1), (int) (R)))
+#define _mm_mask_roundscale_round_sd(A, U, B, C, I, R) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (B), (__v2df) (__m128d) (C), (int) (I), (__v2df) (__m128d) (A), (__mmask8) (U), (int) (R)))
+#define _mm_maskz_roundscale_round_sd(U, A, B, I, R) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (A), (__v2df) (__m128d) (B), (int) (I), (__v2df) _mm_avx512_setzero_pd (), (__mmask8) (U), (int) (R)))
+#endif
+#define _mm_mask_cvtss_sd(W, U, A, B) _mm_mask_cvt_roundss_sd ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#define _mm_maskz_cvtss_sd(U, A, B) _mm_maskz_cvt_roundss_sd ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#define _mm_mask_cvtsd_ss(W, U, A, B) _mm_mask_cvt_roundsd_ss ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#define _mm_maskz_cvtsd_ss(U, A, B) _mm_maskz_cvt_roundsd_ss ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
+#ifdef __OPTIMIZE__
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kshiftli_mask16 (__mmask16 __A, unsigned int __B)
+{
+  return (__mmask16) __builtin_ia32_kshiftlihi ((__mmask16) __A,
+      (__mmask8) __B);
+}
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kshiftri_mask16 (__mmask16 __A, unsigned int __B)
+{
+  return (__mmask16) __builtin_ia32_kshiftrihi ((__mmask16) __A,
+      (__mmask8) __B);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cmp_round_sd_mask (__m128d __X, __m128d __Y, const int __P, const int __R)
+{
+  return (__mmask8) __builtin_ia32_cmpsd_mask ((__v2df) __X,
+            (__v2df) __Y, __P,
+            (__mmask8) -1, __R);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cmp_round_sd_mask (__mmask8 __M, __m128d __X, __m128d __Y,
+       const int __P, const int __R)
+{
+  return (__mmask8) __builtin_ia32_cmpsd_mask ((__v2df) __X,
+            (__v2df) __Y, __P,
+            (__mmask8) __M, __R);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cmp_round_ss_mask (__m128 __X, __m128 __Y, const int __P, const int __R)
+{
+  return (__mmask8) __builtin_ia32_cmpss_mask ((__v4sf) __X,
+            (__v4sf) __Y, __P,
+            (__mmask8) -1, __R);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cmp_round_ss_mask (__mmask8 __M, __m128 __X, __m128 __Y,
+       const int __P, const int __R)
+{
+  return (__mmask8) __builtin_ia32_cmpss_mask ((__v4sf) __X,
+            (__v4sf) __Y, __P,
+            (__mmask8) __M, __R);
+}
+#else
+#define _kshiftli_mask16(X, Y) ((__mmask16) __builtin_ia32_kshiftlihi ((__mmask16)(X), (__mmask8)(Y)))
+#define _kshiftri_mask16(X, Y) ((__mmask16) __builtin_ia32_kshiftrihi ((__mmask16)(X), (__mmask8)(Y)))
+#define _mm_cmp_round_sd_mask(X, Y, P, R) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (__mmask8)-1, R))
+#define _mm_mask_cmp_round_sd_mask(M, X, Y, P, R) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (M), R))
+#define _mm_cmp_round_ss_mask(X, Y, P, R) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (__mmask8)-1, R))
+#define _mm_mask_cmp_round_ss_mask(M, X, Y, P, R) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (M), R))
+#endif
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kortest_mask16_u8 (__mmask16 __A, __mmask16 __B, unsigned char *__CF)
+{
+  *__CF = (unsigned char) __builtin_ia32_kortestchi (__A, __B);
+  return (unsigned char) __builtin_ia32_kortestzhi (__A, __B);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kortestz_mask16_u8 (__mmask16 __A, __mmask16 __B)
+{
+  return (unsigned char) __builtin_ia32_kortestzhi ((__mmask16) __A,
+          (__mmask16) __B);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kortestc_mask16_u8 (__mmask16 __A, __mmask16 __B)
+{
+  return (unsigned char) __builtin_ia32_kortestchi ((__mmask16) __A,
+          (__mmask16) __B);
+}
+extern __inline unsigned int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_cvtmask16_u32 (__mmask16 __A)
+{
+  return (unsigned int) __builtin_ia32_kmovw ((__mmask16 ) __A);
+}
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_cvtu32_mask16 (unsigned int __A)
+{
+  return (__mmask16) __builtin_ia32_kmovw ((__mmask16 ) __A);
+}
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_load_mask16 (__mmask16 *__A)
+{
+  return (__mmask16) __builtin_ia32_kmovw (*(__mmask16 *) __A);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_store_mask16 (__mmask16 *__A, __mmask16 __B)
+{
+  *(__mmask16 *) __A = __builtin_ia32_kmovw (__B);
+}
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kand_mask16 (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_kandhi ((__mmask16) __A, (__mmask16) __B);
+}
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kandn_mask16 (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_kandnhi ((__mmask16) __A,
+          (__mmask16) __B);
+}
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kor_mask16 (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_korhi ((__mmask16) __A, (__mmask16) __B);
+}
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kxnor_mask16 (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_kxnorhi ((__mmask16) __A, (__mmask16) __B);
+}
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kxor_mask16 (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_kxorhi ((__mmask16) __A, (__mmask16) __B);
+}
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_knot_mask16 (__mmask16 __A)
+{
+  return (__mmask16) __builtin_ia32_knothi ((__mmask16) __A);
+}
+extern __inline __mmask16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_kunpackb_mask16 (__mmask8 __A, __mmask8 __B)
+{
+  return (__mmask16) __builtin_ia32_kunpckhi ((__mmask16) __A, (__mmask16) __B);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_max_round_sd (__m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_maxsd_round ((__v2df) __A,
+            (__v2df) __B,
+            __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_max_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
+     __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_maxsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_max_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+      const int __R)
+{
+  return (__m128d) __builtin_ia32_maxsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_max_round_ss (__m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_maxss_round ((__v4sf) __A,
+           (__v4sf) __B,
+           __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_max_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
+     __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_maxss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_max_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
+      const int __R)
+{
+  return (__m128) __builtin_ia32_maxss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_min_round_sd (__m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_minsd_round ((__v2df) __A,
+            (__v2df) __B,
+            __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_min_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
+     __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_minsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_min_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
+      const int __R)
+{
+  return (__m128d) __builtin_ia32_minsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_min_round_ss (__m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_minss_round ((__v4sf) __A,
+           (__v4sf) __B,
+           __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_min_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
+     __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_minss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf) __W,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_min_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
+      const int __R)
+{
+  return (__m128) __builtin_ia32_minss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __U, __R);
+}
+#else
+#define _mm_max_round_sd(A, B, C) (__m128d)__builtin_ia32_maxsd_round(A, B, C)
+#define _mm_mask_max_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_maxsd_mask_round(A, B, W, U, C)
+#define _mm_maskz_max_round_sd(U, A, B, C) (__m128d)__builtin_ia32_maxsd_mask_round(A, B, (__v2df)_mm_avx512_setzero_pd(), U, C)
+#define _mm_max_round_ss(A, B, C) (__m128)__builtin_ia32_maxss_round(A, B, C)
+#define _mm_mask_max_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_maxss_mask_round(A, B, W, U, C)
+#define _mm_maskz_max_round_ss(U, A, B, C) (__m128)__builtin_ia32_maxss_mask_round(A, B, (__v4sf)_mm_avx512_setzero_ps(), U, C)
+#define _mm_min_round_sd(A, B, C) (__m128d)__builtin_ia32_minsd_round(A, B, C)
+#define _mm_mask_min_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_minsd_mask_round(A, B, W, U, C)
+#define _mm_maskz_min_round_sd(U, A, B, C) (__m128d)__builtin_ia32_minsd_mask_round(A, B, (__v2df)_mm_avx512_setzero_pd(), U, C)
+#define _mm_min_round_ss(A, B, C) (__m128)__builtin_ia32_minss_round(A, B, C)
+#define _mm_mask_min_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_minss_mask_round(A, B, W, U, C)
+#define _mm_maskz_min_round_ss(U, A, B, C) (__m128)__builtin_ia32_minss_mask_round(A, B, (__v4sf)_mm_avx512_setzero_ps(), U, C)
+#endif
+#ifdef __OPTIMIZE__
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmadd_round_sd (__m128d __W, __m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_round ((__v2df) __W,
+         (__v2df) __A,
+         (__v2df) __B,
+         __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmadd_round_ss (__m128 __W, __m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_round ((__v4sf) __W,
+        (__v4sf) __A,
+        (__v4sf) __B,
+        __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmsub_round_sd (__m128d __W, __m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_round ((__v2df) __W,
+         (__v2df) __A,
+         -(__v2df) __B,
+         __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmsub_round_ss (__m128 __W, __m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_round ((__v4sf) __W,
+        (__v4sf) __A,
+        -(__v4sf) __B,
+        __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fnmadd_round_sd (__m128d __W, __m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_round ((__v2df) __W,
+         -(__v2df) __A,
+         (__v2df) __B,
+         __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fnmadd_round_ss (__m128 __W, __m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_round ((__v4sf) __W,
+        -(__v4sf) __A,
+        (__v4sf) __B,
+        __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fnmsub_round_sd (__m128d __W, __m128d __A, __m128d __B, const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_round ((__v2df) __W,
+         -(__v2df) __A,
+         -(__v2df) __B,
+         __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fnmsub_round_ss (__m128 __W, __m128 __A, __m128 __B, const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_round ((__v4sf) __W,
+        -(__v4sf) __A,
+        -(__v4sf) __B,
+        __R);
+}
+#else
+#define _mm_fmadd_round_sd(A, B, C, R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, B, C, R)
+#define _mm_fmadd_round_ss(A, B, C, R) (__m128)__builtin_ia32_vfmaddss3_round(A, B, C, R)
+#define _mm_fmsub_round_sd(A, B, C, R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, B, -(C), R)
+#define _mm_fmsub_round_ss(A, B, C, R) (__m128)__builtin_ia32_vfmaddss3_round(A, B, -(C), R)
+#define _mm_fnmadd_round_sd(A, B, C, R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, -(B), C, R)
+#define _mm_fnmadd_round_ss(A, B, C, R) (__m128)__builtin_ia32_vfmaddss3_round(A, -(B), C, R)
+#define _mm_fnmsub_round_sd(A, B, C, R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, -(B), -(C), R)
+#define _mm_fnmsub_round_ss(A, B, C, R) (__m128)__builtin_ia32_vfmaddss3_round(A, -(B), -(C), R)
+#endif
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmadd_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
+        (__v2df) __A,
+        (__v2df) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmadd_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
+       (__v4sf) __A,
+       (__v4sf) __B,
+       (__mmask8) __U,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmadd_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask3 ((__v2df) __W,
+         (__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmadd_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask3 ((__v4sf) __W,
+        (__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmadd_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
+         (__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmadd_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
+        (__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmsub_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
+        (__v2df) __A,
+        -(__v2df) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmsub_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
+       (__v4sf) __A,
+       -(__v4sf) __B,
+       (__mmask8) __U,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmsub_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U)
+{
+  return (__m128d) __builtin_ia32_vfmsubsd3_mask3 ((__v2df) __W,
+         (__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmsub_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U)
+{
+  return (__m128) __builtin_ia32_vfmsubss3_mask3 ((__v4sf) __W,
+        (__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmsub_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
+         (__v2df) __A,
+         -(__v2df) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmsub_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
+        (__v4sf) __A,
+        -(__v4sf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmadd_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
+        -(__v2df) __A,
+        (__v2df) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmadd_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
+       -(__v4sf) __A,
+       (__v4sf) __B,
+       (__mmask8) __U,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmadd_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask3 ((__v2df) __W,
+         -(__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmadd_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask3 ((__v4sf) __W,
+        -(__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmadd_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
+         -(__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmadd_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
+        -(__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmsub_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
+        -(__v2df) __A,
+        -(__v2df) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmsub_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
+       -(__v4sf) __A,
+       -(__v4sf) __B,
+       (__mmask8) __U,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmsub_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U)
+{
+  return (__m128d) __builtin_ia32_vfmsubsd3_mask3 ((__v2df) __W,
+         -(__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmsub_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U)
+{
+  return (__m128) __builtin_ia32_vfmsubss3_mask3 ((__v4sf) __W,
+        -(__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmsub_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
+         -(__v2df) __A,
+         -(__v2df) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmsub_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
+        -(__v4sf) __A,
+        -(__v4sf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmadd_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
+    const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
+        (__v2df) __A,
+        (__v2df) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmadd_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
+    const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
+       (__v4sf) __A,
+       (__v4sf) __B,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmadd_round_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask3 ((__v2df) __W,
+         (__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmadd_round_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask3 ((__v4sf) __W,
+        (__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmadd_round_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B,
+     const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
+         (__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmadd_round_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B,
+     const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
+        (__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmsub_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
+    const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
+        (__v2df) __A,
+        -(__v2df) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmsub_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
+    const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
+       (__v4sf) __A,
+       -(__v4sf) __B,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmsub_round_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmsubsd3_mask3 ((__v2df) __W,
+         (__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmsub_round_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128) __builtin_ia32_vfmsubss3_mask3 ((__v4sf) __W,
+        (__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmsub_round_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B,
+     const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
+         (__v2df) __A,
+         -(__v2df) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmsub_round_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B,
+     const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
+        (__v4sf) __A,
+        -(__v4sf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmadd_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
+    const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
+        -(__v2df) __A,
+        (__v2df) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmadd_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
+    const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
+       -(__v4sf) __A,
+       (__v4sf) __B,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmadd_round_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask3 ((__v2df) __W,
+         -(__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmadd_round_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask3 ((__v4sf) __W,
+        -(__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmadd_round_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B,
+     const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
+         -(__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmadd_round_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B,
+     const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
+        -(__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmsub_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
+    const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
+        -(__v2df) __A,
+        -(__v2df) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmsub_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
+    const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
+       -(__v4sf) __A,
+       -(__v4sf) __B,
+       (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmsub_round_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmsubsd3_mask3 ((__v2df) __W,
+         -(__v2df) __A,
+         (__v2df) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmsub_round_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128) __builtin_ia32_vfmsubss3_mask3 ((__v4sf) __W,
+        -(__v4sf) __A,
+        (__v4sf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmsub_round_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B,
+     const int __R)
+{
+  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
+         -(__v2df) __A,
+         -(__v2df) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmsub_round_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B,
+     const int __R)
+{
+  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
+        -(__v4sf) __A,
+        -(__v4sf) __B,
+        (__mmask8) __U, __R);
+}
+#else
+#define _mm_mask_fmadd_round_sd(A, U, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_mask (A, B, C, U, R)
+#define _mm_mask_fmadd_round_ss(A, U, B, C, R) (__m128) __builtin_ia32_vfmaddss3_mask (A, B, C, U, R)
+#define _mm_mask3_fmadd_round_sd(A, B, C, U, R) (__m128d) __builtin_ia32_vfmaddsd3_mask3 (A, B, C, U, R)
+#define _mm_mask3_fmadd_round_ss(A, B, C, U, R) (__m128) __builtin_ia32_vfmaddss3_mask3 (A, B, C, U, R)
+#define _mm_maskz_fmadd_round_sd(U, A, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_maskz (A, B, C, U, R)
+#define _mm_maskz_fmadd_round_ss(U, A, B, C, R) (__m128) __builtin_ia32_vfmaddss3_maskz (A, B, C, U, R)
+#define _mm_mask_fmsub_round_sd(A, U, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_mask (A, B, -(C), U, R)
+#define _mm_mask_fmsub_round_ss(A, U, B, C, R) (__m128) __builtin_ia32_vfmaddss3_mask (A, B, -(C), U, R)
+#define _mm_mask3_fmsub_round_sd(A, B, C, U, R) (__m128d) __builtin_ia32_vfmsubsd3_mask3 (A, B, C, U, R)
+#define _mm_mask3_fmsub_round_ss(A, B, C, U, R) (__m128) __builtin_ia32_vfmsubss3_mask3 (A, B, C, U, R)
+#define _mm_maskz_fmsub_round_sd(U, A, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_maskz (A, B, -(C), U, R)
+#define _mm_maskz_fmsub_round_ss(U, A, B, C, R) (__m128) __builtin_ia32_vfmaddss3_maskz (A, B, -(C), U, R)
+#define _mm_mask_fnmadd_round_sd(A, U, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_mask (A, -(B), C, U, R)
+#define _mm_mask_fnmadd_round_ss(A, U, B, C, R) (__m128) __builtin_ia32_vfmaddss3_mask (A, -(B), C, U, R)
+#define _mm_mask3_fnmadd_round_sd(A, B, C, U, R) (__m128d) __builtin_ia32_vfmaddsd3_mask3 (A, -(B), C, U, R)
+#define _mm_mask3_fnmadd_round_ss(A, B, C, U, R) (__m128) __builtin_ia32_vfmaddss3_mask3 (A, -(B), C, U, R)
+#define _mm_maskz_fnmadd_round_sd(U, A, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_maskz (A, -(B), C, U, R)
+#define _mm_maskz_fnmadd_round_ss(U, A, B, C, R) (__m128) __builtin_ia32_vfmaddss3_maskz (A, -(B), C, U, R)
+#define _mm_mask_fnmsub_round_sd(A, U, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_mask (A, -(B), -(C), U, R)
+#define _mm_mask_fnmsub_round_ss(A, U, B, C, R) (__m128) __builtin_ia32_vfmaddss3_mask (A, -(B), -(C), U, R)
+#define _mm_mask3_fnmsub_round_sd(A, B, C, U, R) (__m128d) __builtin_ia32_vfmsubsd3_mask3 (A, -(B), C, U, R)
+#define _mm_mask3_fnmsub_round_ss(A, B, C, U, R) (__m128) __builtin_ia32_vfmsubss3_mask3 (A, -(B), C, U, R)
+#define _mm_maskz_fnmsub_round_sd(U, A, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_maskz (A, -(B), -(C), U, R)
+#define _mm_maskz_fnmsub_round_ss(U, A, B, C, R) (__m128) __builtin_ia32_vfmaddss3_maskz (A, -(B), -(C), U, R)
+#endif
+#ifdef __OPTIMIZE__
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_comi_round_ss (__m128 __A, __m128 __B, const int __P, const int __R)
+{
+  return __builtin_ia32_vcomiss ((__v4sf) __A, (__v4sf) __B, __P, __R);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_comi_round_sd (__m128d __A, __m128d __B, const int __P, const int __R)
+{
+  return __builtin_ia32_vcomisd ((__v2df) __A, (__v2df) __B, __P, __R);
+}
+#else
+#define _mm_comi_round_ss(A, B, C, D)__builtin_ia32_vcomiss(A, B, C, D)
+#define _mm_comi_round_sd(A, B, C, D)__builtin_ia32_vcomisd(A, B, C, D)
+#endif
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_add_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_addsd_mask_round ((__v2df) __A,
+      (__v2df) __B,
+      (__v2df) __W,
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_add_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_addsd_mask_round ((__v2df) __A,
+      (__v2df) __B,
+      (__v2df)
+      _mm_avx512_setzero_pd (),
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_add_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_addss_mask_round ((__v4sf) __A,
+      (__v4sf) __B,
+      (__v4sf) __W,
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_add_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_addss_mask_round ((__v4sf) __A,
+      (__v4sf) __B,
+      (__v4sf)
+      _mm_avx512_setzero_ps (),
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_sub_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_subsd_mask_round ((__v2df) __A,
+      (__v2df) __B,
+      (__v2df) __W,
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_sub_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_subsd_mask_round ((__v2df) __A,
+      (__v2df) __B,
+      (__v2df)
+      _mm_avx512_setzero_pd (),
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_sub_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_subss_mask_round ((__v4sf) __A,
+      (__v4sf) __B,
+      (__v4sf) __W,
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_sub_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_subss_mask_round ((__v4sf) __A,
+      (__v4sf) __B,
+      (__v4sf)
+      _mm_avx512_setzero_ps (),
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_mul_sd (__m128d __W, __mmask8 __U, __m128d __A,
+     __m128d __B)
+{
+  return (__m128d) __builtin_ia32_mulsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_mul_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_mulsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_mul_ss (__m128 __W, __mmask8 __U, __m128 __A,
+     __m128 __B)
+{
+  return (__m128) __builtin_ia32_mulss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf) __W,
+       (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_mul_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_mulss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_div_sd (__m128d __W, __mmask8 __U, __m128d __A,
+     __m128d __B)
+{
+  return (__m128d) __builtin_ia32_divsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_div_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_divsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_div_ss (__m128 __W, __mmask8 __U, __m128 __A,
+     __m128 __B)
+{
+  return (__m128) __builtin_ia32_divss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf) __W,
+       (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_div_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_divss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_max_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_maxsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_max_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_maxsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_max_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_maxss_mask_round ((__v4sf) __A,
+      (__v4sf) __B,
+      (__v4sf) __W,
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_max_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_maxss_mask_round ((__v4sf) __A,
+      (__v4sf) __B,
+      (__v4sf)
+      _mm_avx512_setzero_ps (),
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_min_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_minsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df) __W,
+       (__mmask8) __U,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_min_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_minsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __U,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_min_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_minss_mask_round ((__v4sf) __A,
+      (__v4sf) __B,
+      (__v4sf) __W,
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_min_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_minss_mask_round ((__v4sf) __A,
+      (__v4sf) __B,
+      (__v4sf)
+      _mm_avx512_setzero_ps (),
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_scalef_sd (__m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_scalefsd_mask_round ((__v2df) __A,
+          (__v2df) __B,
+          (__v2df)
+          _mm_avx512_setzero_pd (),
+          (__mmask8) -1,
+          _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_scalef_ss (__m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_scalefss_mask_round ((__v4sf) __A,
+         (__v4sf) __B,
+         (__v4sf)
+         _mm_avx512_setzero_ps (),
+         (__mmask8) -1,
+         _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __x86_64__
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtu64_ss (__m128 __A, unsigned long long __B)
+{
+  return (__m128) __builtin_ia32_cvtusi2ss64 ((__v4sf) __A, __B,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtu64_sd (__m128d __A, unsigned long long __B)
+{
+  return (__m128d) __builtin_ia32_cvtusi2sd64 ((__v2df) __A, __B,
+            _MM_FROUND_CUR_DIRECTION);
+}
+#endif
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtu32_ss (__m128 __A, unsigned __B)
+{
+  return (__m128) __builtin_ia32_cvtusi2ss32 ((__v4sf) __A, __B,
+           _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fixupimm_sd (__m128d __A, __m128d __B, __m128i __C, const int __imm)
+{
+  return (__m128d) __builtin_ia32_fixupimmsd_mask ((__v2df) __A,
+         (__v2df) __B,
+         (__v2di) __C, __imm,
+         (__mmask8) -1,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fixupimm_sd (__m128d __A, __mmask8 __U, __m128d __B,
+        __m128i __C, const int __imm)
+{
+  return (__m128d) __builtin_ia32_fixupimmsd_mask ((__v2df) __A,
+         (__v2df) __B,
+         (__v2di) __C, __imm,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fixupimm_sd (__mmask8 __U, __m128d __A, __m128d __B,
+         __m128i __C, const int __imm)
+{
+  return (__m128d) __builtin_ia32_fixupimmsd_maskz ((__v2df) __A,
+          (__v2df) __B,
+          (__v2di) __C,
+          __imm,
+          (__mmask8) __U,
+          _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fixupimm_ss (__m128 __A, __m128 __B, __m128i __C, const int __imm)
+{
+  return (__m128) __builtin_ia32_fixupimmss_mask ((__v4sf) __A,
+        (__v4sf) __B,
+        (__v4si) __C, __imm,
+        (__mmask8) -1,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fixupimm_ss (__m128 __A, __mmask8 __U, __m128 __B,
+        __m128i __C, const int __imm)
+{
+  return (__m128) __builtin_ia32_fixupimmss_mask ((__v4sf) __A,
+        (__v4sf) __B,
+        (__v4si) __C, __imm,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fixupimm_ss (__mmask8 __U, __m128 __A, __m128 __B,
+         __m128i __C, const int __imm)
+{
+  return (__m128) __builtin_ia32_fixupimmss_maskz ((__v4sf) __A,
+         (__v4sf) __B,
+         (__v4si) __C, __imm,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+#else
+#define _mm_fixupimm_sd(X, Y, Z, C) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_fixupimm_sd(X, U, Y, Z, C) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_fixupimm_sd(U, X, Y, Z, C) ((__m128d)__builtin_ia32_fixupimmsd_maskz ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_fixupimm_ss(X, Y, Z, C) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_fixupimm_ss(X, U, Y, Z, C) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_fixupimm_ss(U, X, Y, Z, C) ((__m128)__builtin_ia32_fixupimmss_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#endif
+#ifdef __x86_64__
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtss_u64 (__m128 __A)
+{
+  return (unsigned long long) __builtin_ia32_vcvtss2usi64 ((__v4sf)
+          __A,
+          _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttss_u64 (__m128 __A)
+{
+  return (unsigned long long) __builtin_ia32_vcvttss2usi64 ((__v4sf)
+           __A,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttss_i64 (__m128 __A)
+{
+  return (long long) __builtin_ia32_vcvttss2si64 ((__v4sf) __A,
+        _MM_FROUND_CUR_DIRECTION);
+}
+#endif
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtss_u32 (__m128 __A)
+{
+  return (unsigned) __builtin_ia32_vcvtss2usi32 ((__v4sf) __A,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttss_u32 (__m128 __A)
+{
+  return (unsigned) __builtin_ia32_vcvttss2usi32 ((__v4sf) __A,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttss_i32 (__m128 __A)
+{
+  return (int) __builtin_ia32_vcvttss2si32 ((__v4sf) __A,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsd_i32 (__m128d __A)
+{
+  return (int) __builtin_ia32_cvtsd2si ((__v2df) __A);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtss_i32 (__m128 __A)
+{
+  return (int) __builtin_ia32_cvtss2si ((__v4sf) __A);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvti32_sd (__m128d __A, int __B)
+{
+  return (__m128d) __builtin_ia32_cvtsi2sd ((__v2df) __A, __B);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvti32_ss (__m128 __A, int __B)
+{
+  return (__m128) __builtin_ia32_cvtsi2ss ((__v4sf) __A, __B);
+}
+#ifdef __x86_64__
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsd_u64 (__m128d __A)
+{
+  return (unsigned long long) __builtin_ia32_vcvtsd2usi64 ((__v2df)
+          __A,
+          _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttsd_u64 (__m128d __A)
+{
+  return (unsigned long long) __builtin_ia32_vcvttsd2usi64 ((__v2df)
+           __A,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttsd_i64 (__m128d __A)
+{
+  return (long long) __builtin_ia32_vcvttsd2si64 ((__v2df) __A,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsd_i64 (__m128d __A)
+{
+  return (long long) __builtin_ia32_cvtsd2si64 ((__v2df) __A);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtss_i64 (__m128 __A)
+{
+  return (long long) __builtin_ia32_cvtss2si64 ((__v4sf) __A);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvti64_sd (__m128d __A, long long __B)
+{
+  return (__m128d) __builtin_ia32_cvtsi642sd ((__v2df) __A, __B);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvti64_ss (__m128 __A, long long __B)
+{
+  return (__m128) __builtin_ia32_cvtsi642ss ((__v4sf) __A, __B);
+}
+#endif
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsd_u32 (__m128d __A)
+{
+  return (unsigned) __builtin_ia32_vcvtsd2usi32 ((__v2df) __A,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttsd_u32 (__m128d __A)
+{
+  return (unsigned) __builtin_ia32_vcvttsd2usi32 ((__v2df) __A,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttsd_i32 (__m128d __A)
+{
+  return (int) __builtin_ia32_vcvttsd2si32 ((__v2df) __A,
+         _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getexp_ss (__m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_getexpss128_round ((__v4sf) __A,
+          (__v4sf) __B,
+          _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getexp_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_getexpss_mask_round ((__v4sf) __A,
+      (__v4sf) __B,
+      (__v4sf) __W,
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getexp_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_getexpss_mask_round ((__v4sf) __A,
+      (__v4sf) __B,
+      (__v4sf)
+      _mm_avx512_setzero_ps (),
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getexp_sd (__m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_getexpsd128_round ((__v2df) __A,
+           (__v2df) __B,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getexp_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_getexpsd_mask_round ((__v2df) __A,
+      (__v2df) __B,
+      (__v2df) __W,
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getexp_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_getexpsd_mask_round ((__v2df) __A,
+      (__v2df) __B,
+      (__v2df)
+      _mm_avx512_setzero_pd (),
+      (__mmask8) __U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getmant_sd (__m128d __A, __m128d __B, _MM_MANTISSA_NORM_ENUM __C,
+  _MM_MANTISSA_SIGN_ENUM __D)
+{
+  return (__m128d) __builtin_ia32_getmantsd_round ((__v2df) __A,
+         (__v2df) __B,
+         (__D << 2) | __C,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getmant_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
+   _MM_MANTISSA_NORM_ENUM __C, _MM_MANTISSA_SIGN_ENUM __D)
+{
+  return (__m128d) __builtin_ia32_getmantsd_mask_round ((__v2df) __A,
+       (__v2df) __B,
+              (__D << 2) | __C,
+                                                        (__v2df) __W,
+             __U,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getmant_sd (__mmask8 __U, __m128d __A, __m128d __B,
+    _MM_MANTISSA_NORM_ENUM __C, _MM_MANTISSA_SIGN_ENUM __D)
+{
+  return (__m128d) __builtin_ia32_getmantsd_mask_round ((__v2df) __A,
+                                                        (__v2df) __B,
+              (__D << 2) | __C,
+                                                        (__v2df)
+       _mm_avx512_setzero_pd(),
+              __U,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getmant_ss (__m128 __A, __m128 __B, _MM_MANTISSA_NORM_ENUM __C,
+  _MM_MANTISSA_SIGN_ENUM __D)
+{
+  return (__m128) __builtin_ia32_getmantss_round ((__v4sf) __A,
+        (__v4sf) __B,
+        (__D << 2) | __C,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getmant_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
+   _MM_MANTISSA_NORM_ENUM __C, _MM_MANTISSA_SIGN_ENUM __D)
+{
+  return (__m128) __builtin_ia32_getmantss_mask_round ((__v4sf) __A,
+       (__v4sf) __B,
+              (__D << 2) | __C,
+                                                        (__v4sf) __W,
+             __U,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getmant_ss (__mmask8 __U, __m128 __A, __m128 __B,
+    _MM_MANTISSA_NORM_ENUM __C, _MM_MANTISSA_SIGN_ENUM __D)
+{
+  return (__m128) __builtin_ia32_getmantss_mask_round ((__v4sf) __A,
+                                                        (__v4sf) __B,
+              (__D << 2) | __C,
+                                                        (__v4sf)
+       _mm_avx512_setzero_ps(),
+              __U,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_roundscale_ss (__m128 __A, __m128 __B, const int __imm)
+{
+  return (__m128)
+    __builtin_ia32_rndscaless_mask_round ((__v4sf) __A,
+       (__v4sf) __B, __imm,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_roundscale_ss (__m128 __A, __mmask8 __B, __m128 __C, __m128 __D,
+   const int __imm)
+{
+  return (__m128)
+    __builtin_ia32_rndscaless_mask_round ((__v4sf) __C,
+       (__v4sf) __D, __imm,
+       (__v4sf) __A,
+       (__mmask8) __B,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_roundscale_ss (__mmask8 __A, __m128 __B, __m128 __C,
+    const int __imm)
+{
+  return (__m128)
+    __builtin_ia32_rndscaless_mask_round ((__v4sf) __B,
+       (__v4sf) __C, __imm,
+       (__v4sf)
+       _mm_avx512_setzero_ps (),
+       (__mmask8) __A,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_roundscale_sd (__m128d __A, __m128d __B, const int __imm)
+{
+  return (__m128d)
+    __builtin_ia32_rndscalesd_mask_round ((__v2df) __A,
+       (__v2df) __B, __imm,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_roundscale_sd (__m128d __A, __mmask8 __B, __m128d __C, __m128d __D,
+   const int __imm)
+{
+  return (__m128d)
+    __builtin_ia32_rndscalesd_mask_round ((__v2df) __C,
+       (__v2df) __D, __imm,
+       (__v2df) __A,
+       (__mmask8) __B,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_roundscale_sd (__mmask8 __A, __m128d __B, __m128d __C,
+    const int __imm)
+{
+  return (__m128d)
+    __builtin_ia32_rndscalesd_mask_round ((__v2df) __B,
+       (__v2df) __C, __imm,
+       (__v2df)
+       _mm_avx512_setzero_pd (),
+       (__mmask8) __A,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cmp_sd_mask (__m128d __X, __m128d __Y, const int __P)
+{
+  return (__mmask8) __builtin_ia32_cmpsd_mask ((__v2df) __X,
+            (__v2df) __Y, __P,
+            (__mmask8) -1,
+            _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cmp_sd_mask (__mmask8 __M, __m128d __X, __m128d __Y, const int __P)
+{
+  return (__mmask8) __builtin_ia32_cmpsd_mask ((__v2df) __X,
+            (__v2df) __Y, __P,
+            (__mmask8) __M,
+            _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cmp_ss_mask (__m128 __X, __m128 __Y, const int __P)
+{
+  return (__mmask8) __builtin_ia32_cmpss_mask ((__v4sf) __X,
+            (__v4sf) __Y, __P,
+            (__mmask8) -1,
+            _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cmp_ss_mask (__mmask8 __M, __m128 __X, __m128 __Y, const int __P)
+{
+  return (__mmask8) __builtin_ia32_cmpss_mask ((__v4sf) __X,
+            (__v4sf) __Y, __P,
+            (__mmask8) __M,
+            _MM_FROUND_CUR_DIRECTION);
+}
+#else
+#define _mm_getmant_sd(X, Y, C, D) ((__m128d)__builtin_ia32_getmantsd_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_getmant_sd(W, U, X, Y, C, D) ((__m128d)__builtin_ia32_getmantsd_mask_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (__v2df)(__m128d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_getmant_sd(U, X, Y, C, D) ((__m128d)__builtin_ia32_getmantsd_mask_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (__v2df)_mm_avx512_setzero_pd(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_getmant_ss(X, Y, C, D) ((__m128)__builtin_ia32_getmantss_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_getmant_ss(W, U, X, Y, C, D) ((__m128)__builtin_ia32_getmantss_mask_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (__v4sf)(__m128)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_getmant_ss(U, X, Y, C, D) ((__m128)__builtin_ia32_getmantss_mask_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (__v4sf)_mm_avx512_setzero_ps(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_getexp_ss(A, B) ((__m128)__builtin_ia32_getexpss128_round((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_getexp_ss(W, U, A, B) (__m128)__builtin_ia32_getexpss_mask_round(A, B, W, U, _MM_FROUND_CUR_DIRECTION)
+#define _mm_maskz_getexp_ss(U, A, B) (__m128)__builtin_ia32_getexpss_mask_round(A, B, (__v4sf)_mm_avx512_setzero_ps(), U, _MM_FROUND_CUR_DIRECTION)
+#define _mm_getexp_sd(A, B) ((__m128d)__builtin_ia32_getexpsd128_round((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_getexp_sd(W, U, A, B) (__m128d)__builtin_ia32_getexpsd_mask_round(A, B, W, U, _MM_FROUND_CUR_DIRECTION)
+#define _mm_maskz_getexp_sd(U, A, B) (__m128d)__builtin_ia32_getexpsd_mask_round(A, B, (__v2df)_mm_avx512_setzero_pd(), U, _MM_FROUND_CUR_DIRECTION)
+#define _mm_roundscale_ss(A, B, I) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (A), (__v4sf) (__m128) (B), (int) (I), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8) (-1), _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_roundscale_ss(A, U, B, C, I) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (B), (__v4sf) (__m128) (C), (int) (I), (__v4sf) (__m128) (A), (__mmask8) (U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_roundscale_ss(U, A, B, I) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (A), (__v4sf) (__m128) (B), (int) (I), (__v4sf) _mm_avx512_setzero_ps (), (__mmask8) (U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_roundscale_sd(A, B, I) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (A), (__v2df) (__m128d) (B), (int) (I), (__v2df) _mm_avx512_setzero_pd (), (__mmask8) (-1), _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_roundscale_sd(A, U, B, C, I) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (B), (__v2df) (__m128d) (C), (int) (I), (__v2df) (__m128d) (A), (__mmask8) (U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_roundscale_sd(U, A, B, I) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (A), (__v2df) (__m128d) (B), (int) (I), (__v2df) _mm_avx512_setzero_pd (), (__mmask8) (U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_cmp_sd_mask(X, Y, P) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_cmp_sd_mask(M, X, Y, P) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), M,_MM_FROUND_CUR_DIRECTION))
+#define _mm_cmp_ss_mask(X, Y, P) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_cmp_ss_mask(M, X, Y, P) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), M,_MM_FROUND_CUR_DIRECTION))
+#endif
+#ifdef __DISABLE_AVX512F__
+#undef __DISABLE_AVX512F__
+#pragma GCC pop_options
+#endif
+#if !defined (__AVX512F__) || !defined (__EVEX512__)
+#pragma GCC push_options
+#pragma GCC target("avx512f,evex512")
+#define __DISABLE_AVX512F_512__
+#endif
 typedef double __v8df __attribute__ ((__vector_size__ (64)));
 typedef float __v16sf __attribute__ ((__vector_size__ (64)));
 typedef long long __v8di __attribute__ ((__vector_size__ (64)));
@@ -25,8 +2939,6 @@ typedef double __m512d __attribute__ ((__vector_size__ (64), __may_alias__));
 typedef float __m512_u __attribute__ ((__vector_size__ (64), __may_alias__, __aligned__ (1)));
 typedef long long __m512i_u __attribute__ ((__vector_size__ (64), __may_alias__, __aligned__ (1)));
 typedef double __m512d_u __attribute__ ((__vector_size__ (64), __may_alias__, __aligned__ (1)));
-typedef unsigned char __mmask8;
-typedef unsigned short __mmask16;
 extern __inline __mmask16
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_int2mask (int __M)
@@ -134,7 +3046,10 @@ extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_undefined_ps (void)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
   __m512 __Y = __Y;
+#pragma GCC diagnostic pop
   return __Y;
 }
 #define _mm512_undefined _mm512_undefined_ps
@@ -142,14 +3057,20 @@ extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_undefined_pd (void)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
   __m512d __Y = __Y;
+#pragma GCC diagnostic pop
   return __Y;
 }
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_undefined_epi32 (void)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
   __m512i __Y = __Y;
+#pragma GCC diagnostic pop
   return __Y;
 }
 #define _mm512_undefined_si512 _mm512_undefined_epi32
@@ -877,9 +3798,9 @@ _mm512_maskz_slli_epi64 (__mmask8 __U, __m512i __A, unsigned int __B)
         (__mmask8) __U);
 }
 #else
-#define _mm512_slli_epi64(X, C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_epi32 (), (__mmask8)-1))
-#define _mm512_mask_slli_epi64(W, U, X, C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
-#define _mm512_maskz_slli_epi64(U, X, C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
+#define _mm512_slli_epi64(X, C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (unsigned int)(C), (__v8di)(__m512i)_mm512_undefined_epi32 (), (__mmask8)-1))
+#define _mm512_mask_slli_epi64(W, U, X, C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (unsigned int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
+#define _mm512_maskz_slli_epi64(U, X, C) ((__m512i) __builtin_ia32_psllqi512_mask ((__v8di)(__m512i)(X), (unsigned int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
 #endif
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -939,9 +3860,9 @@ _mm512_maskz_srli_epi64 (__mmask8 __U, __m512i __A, unsigned int __B)
         (__mmask8) __U);
 }
 #else
-#define _mm512_srli_epi64(X, C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_epi32 (), (__mmask8)-1))
-#define _mm512_mask_srli_epi64(W, U, X, C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
-#define _mm512_maskz_srli_epi64(U, X, C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
+#define _mm512_srli_epi64(X, C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (unsigned int)(C), (__v8di)(__m512i)_mm512_undefined_epi32 (), (__mmask8)-1))
+#define _mm512_mask_srli_epi64(W, U, X, C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (unsigned int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
+#define _mm512_maskz_srli_epi64(U, X, C) ((__m512i) __builtin_ia32_psrlqi512_mask ((__v8di)(__m512i)(X), (unsigned int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
 #endif
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -1001,9 +3922,9 @@ _mm512_maskz_srai_epi64 (__mmask8 __U, __m512i __A, unsigned int __B)
         (__mmask8) __U);
 }
 #else
-#define _mm512_srai_epi64(X, C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_undefined_epi32 (), (__mmask8)-1))
-#define _mm512_mask_srai_epi64(W, U, X, C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
-#define _mm512_maskz_srai_epi64(U, X, C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
+#define _mm512_srai_epi64(X, C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (unsigned int)(C), (__v8di)(__m512i)_mm512_undefined_epi32 (), (__mmask8)-1))
+#define _mm512_mask_srai_epi64(W, U, X, C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (unsigned int)(C), (__v8di)(__m512i)(W), (__mmask8)(U)))
+#define _mm512_maskz_srai_epi64(U, X, C) ((__m512i) __builtin_ia32_psraqi512_mask ((__v8di)(__m512i)(X), (unsigned int)(C), (__v8di)(__m512i)_mm512_setzero_si512 (), (__mmask8)(U)))
 #endif
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -1063,9 +3984,9 @@ _mm512_maskz_slli_epi32 (__mmask16 __U, __m512i __A, unsigned int __B)
         (__mmask16) __U);
 }
 #else
-#define _mm512_slli_epi32(X, C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_epi32 (), (__mmask16)-1))
-#define _mm512_mask_slli_epi32(W, U, X, C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
-#define _mm512_maskz_slli_epi32(U, X, C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
+#define _mm512_slli_epi32(X, C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (unsigned int)(C), (__v16si)(__m512i)_mm512_undefined_epi32 (), (__mmask16)-1))
+#define _mm512_mask_slli_epi32(W, U, X, C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (unsigned int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
+#define _mm512_maskz_slli_epi32(U, X, C) ((__m512i) __builtin_ia32_pslldi512_mask ((__v16si)(__m512i)(X), (unsigned int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
 #endif
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -1125,9 +4046,9 @@ _mm512_maskz_srli_epi32 (__mmask16 __U, __m512i __A, unsigned int __B)
         (__mmask16) __U);
 }
 #else
-#define _mm512_srli_epi32(X, C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_epi32 (), (__mmask16)-1))
-#define _mm512_mask_srli_epi32(W, U, X, C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
-#define _mm512_maskz_srli_epi32(U, X, C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
+#define _mm512_srli_epi32(X, C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (unsigned int)(C), (__v16si)(__m512i)_mm512_undefined_epi32 (), (__mmask16)-1))
+#define _mm512_mask_srli_epi32(W, U, X, C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (unsigned int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
+#define _mm512_maskz_srli_epi32(U, X, C) ((__m512i) __builtin_ia32_psrldi512_mask ((__v16si)(__m512i)(X), (unsigned int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
 #endif
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -1187,9 +4108,9 @@ _mm512_maskz_srai_epi32 (__mmask16 __U, __m512i __A, unsigned int __B)
         (__mmask16) __U);
 }
 #else
-#define _mm512_srai_epi32(X, C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_undefined_epi32 (), (__mmask16)-1))
-#define _mm512_mask_srai_epi32(W, U, X, C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
-#define _mm512_maskz_srai_epi32(U, X, C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
+#define _mm512_srai_epi32(X, C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (unsigned int)(C), (__v16si)(__m512i)_mm512_undefined_epi32 (), (__mmask16)-1))
+#define _mm512_mask_srai_epi32(W, U, X, C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (unsigned int)(C), (__v16si)(__m512i)(W), (__mmask16)(U)))
+#define _mm512_maskz_srai_epi32(U, X, C) ((__m512i) __builtin_ia32_psradi512_mask ((__v16si)(__m512i)(X), (unsigned int)(C), (__v16si)(__m512i)_mm512_setzero_si512 (), (__mmask16)(U)))
 #endif
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -1220,137 +4141,6 @@ _mm512_maskz_sra_epi32 (__mmask16 __U, __m512i __A, __m128i __B)
        _mm512_setzero_si512 (),
        (__mmask16) __U);
 }
-#ifdef __OPTIMIZE__
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_add_round_sd (__m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_addsd_round ((__v2df) __A,
-            (__v2df) __B,
-            __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_add_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
-     __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_addsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_add_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-      const int __R)
-{
-  return (__m128d) __builtin_ia32_addsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_add_round_ss (__m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_addss_round ((__v4sf) __A,
-           (__v4sf) __B,
-           __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_add_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
-     __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_addss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_add_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
-      const int __R)
-{
-  return (__m128) __builtin_ia32_addss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_sub_round_sd (__m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_subsd_round ((__v2df) __A,
-            (__v2df) __B,
-            __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_sub_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
-     __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_subsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_sub_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-      const int __R)
-{
-  return (__m128d) __builtin_ia32_subsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_sub_round_ss (__m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_subss_round ((__v4sf) __A,
-           (__v4sf) __B,
-           __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_sub_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
-     __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_subss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_sub_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
-      const int __R)
-{
-  return (__m128) __builtin_ia32_subss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __U, __R);
-}
-#else
-#define _mm_add_round_sd(A, B, C) (__m128d)__builtin_ia32_addsd_round(A, B, C)
-#define _mm_mask_add_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_addsd_mask_round(A, B, W, U, C)
-#define _mm_maskz_add_round_sd(U, A, B, C) (__m128d)__builtin_ia32_addsd_mask_round(A, B, (__v2df)_mm_setzero_pd(), U, C)
-#define _mm_add_round_ss(A, B, C) (__m128)__builtin_ia32_addss_round(A, B, C)
-#define _mm_mask_add_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_addss_mask_round(A, B, W, U, C)
-#define _mm_maskz_add_round_ss(U, A, B, C) (__m128)__builtin_ia32_addss_mask_round(A, B, (__v4sf)_mm_setzero_ps(), U, C)
-#define _mm_sub_round_sd(A, B, C) (__m128d)__builtin_ia32_subsd_round(A, B, C)
-#define _mm_mask_sub_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_subsd_mask_round(A, B, W, U, C)
-#define _mm_maskz_sub_round_sd(U, A, B, C) (__m128d)__builtin_ia32_subsd_mask_round(A, B, (__v2df)_mm_setzero_pd(), U, C)
-#define _mm_sub_round_ss(A, B, C) (__m128)__builtin_ia32_subss_round(A, B, C)
-#define _mm_mask_sub_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_subss_mask_round(A, B, W, U, C)
-#define _mm_maskz_sub_round_ss(U, A, B, C) (__m128)__builtin_ia32_subss_mask_round(A, B, (__v4sf)_mm_setzero_ps(), U, C)
-#endif
 typedef enum
 {
   _MM_TERNLOG_A = 0xF0,
@@ -1490,56 +4280,6 @@ _mm512_maskz_rcp14_ps (__mmask16 __U, __m512 __A)
         _mm512_setzero_ps (),
         (__mmask16) __U);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_rcp14_sd (__m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_rcp14sd ((__v2df) __B,
-        (__v2df) __A);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_rcp14_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_rcp14sd_mask ((__v2df) __B,
-      (__v2df) __A,
-      (__v2df) __W,
-      (__mmask8) __U);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_rcp14_sd (__mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_rcp14sd_mask ((__v2df) __B,
-      (__v2df) __A,
-      (__v2df) _mm_setzero_ps (),
-      (__mmask8) __U);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_rcp14_ss (__m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_rcp14ss ((__v4sf) __B,
-       (__v4sf) __A);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_rcp14_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __B,
-      (__v4sf) __A,
-      (__v4sf) __W,
-      (__mmask8) __U);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_rcp14_ss (__mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __B,
-      (__v4sf) __A,
-      (__v4sf) _mm_setzero_ps (),
-      (__mmask8) __U);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_rsqrt14_pd (__m512d __A)
@@ -1592,56 +4332,6 @@ _mm512_maskz_rsqrt14_ps (__mmask16 __U, __m512 __A)
           _mm512_setzero_ps (),
           (__mmask16) __U);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_rsqrt14_sd (__m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_rsqrt14sd ((__v2df) __B,
-          (__v2df) __A);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_rsqrt14_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_rsqrt14sd_mask ((__v2df) __B,
-       (__v2df) __A,
-       (__v2df) __W,
-       (__mmask8) __U);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_rsqrt14_sd (__mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_rsqrt14sd_mask ((__v2df) __B,
-       (__v2df) __A,
-       (__v2df) _mm_setzero_pd (),
-       (__mmask8) __U);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_rsqrt14_ss (__m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_rsqrt14ss ((__v4sf) __B,
-         (__v4sf) __A);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_rsqrt14_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __B,
-       (__v4sf) __A,
-       (__v4sf) __W,
-       (__mmask8) __U);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_rsqrt14_ss (__mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __B,
-      (__v4sf) __A,
-      (__v4sf) _mm_setzero_ps (),
-      (__mmask8) __U);
-}
 #ifdef __OPTIMIZE__
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -1696,66 +4386,6 @@ _mm512_maskz_sqrt_round_ps (__mmask16 __U, __m512 __A, const int __R)
        _mm512_setzero_ps (),
        (__mmask16) __U, __R);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_sqrt_round_sd (__m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_sqrtsd_mask_round ((__v2df) __B,
-           (__v2df) __A,
-           (__v2df)
-           _mm_setzero_pd (),
-           (__mmask8) -1, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_sqrt_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
-   const int __R)
-{
-  return (__m128d) __builtin_ia32_sqrtsd_mask_round ((__v2df) __B,
-           (__v2df) __A,
-           (__v2df) __W,
-           (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_sqrt_round_sd (__mmask8 __U, __m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_sqrtsd_mask_round ((__v2df) __B,
-           (__v2df) __A,
-           (__v2df)
-           _mm_setzero_pd (),
-           (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_sqrt_round_ss (__m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_sqrtss_mask_round ((__v4sf) __B,
-          (__v4sf) __A,
-          (__v4sf)
-          _mm_setzero_ps (),
-          (__mmask8) -1, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_sqrt_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
-   const int __R)
-{
-  return (__m128) __builtin_ia32_sqrtss_mask_round ((__v4sf) __B,
-          (__v4sf) __A,
-          (__v4sf) __W,
-          (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_sqrt_round_ss (__mmask8 __U, __m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_sqrtss_mask_round ((__v4sf) __B,
-          (__v4sf) __A,
-          (__v4sf)
-          _mm_setzero_ps (),
-          (__mmask8) __U, __R);
-}
 #else
 #define _mm512_sqrt_round_pd(A, C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, (__v8df)_mm512_undefined_pd(), -1, C)
 #define _mm512_mask_sqrt_round_pd(W, U, A, C) (__m512d)__builtin_ia32_sqrtpd512_mask(A, W, U, C)
@@ -1763,17 +4393,7 @@ _mm_maskz_sqrt_round_ss (__mmask8 __U, __m128 __A, __m128 __B, const int __R)
 #define _mm512_sqrt_round_ps(A, C) (__m512)__builtin_ia32_sqrtps512_mask(A, (__v16sf)_mm512_undefined_ps(), -1, C)
 #define _mm512_mask_sqrt_round_ps(W, U, A, C) (__m512)__builtin_ia32_sqrtps512_mask(A, W, U, C)
 #define _mm512_maskz_sqrt_round_ps(U, A, C) (__m512)__builtin_ia32_sqrtps512_mask(A, (__v16sf)_mm512_setzero_ps(), U, C)
-#define _mm_sqrt_round_sd(A, B, C) (__m128d)__builtin_ia32_sqrtsd_mask_round (B, A, (__v2df) _mm_setzero_pd (), -1, C)
-#define _mm_mask_sqrt_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_sqrtsd_mask_round (B, A, W, U, C)
-#define _mm_maskz_sqrt_round_sd(U, A, B, C) (__m128d)__builtin_ia32_sqrtsd_mask_round (B, A, (__v2df) _mm_setzero_pd (), U, C)
-#define _mm_sqrt_round_ss(A, B, C) (__m128)__builtin_ia32_sqrtss_mask_round (B, A, (__v4sf) _mm_setzero_ps (), -1, C)
-#define _mm_mask_sqrt_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_sqrtss_mask_round (B, A, W, U, C)
-#define _mm_maskz_sqrt_round_ss(U, A, B, C) (__m128)__builtin_ia32_sqrtss_mask_round (B, A, (__v4sf) _mm_setzero_ps (), U, C)
 #endif
-#define _mm_mask_sqrt_sd(W, U, A, B) _mm_mask_sqrt_round_sd ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
-#define _mm_maskz_sqrt_sd(U, A, B) _mm_maskz_sqrt_round_sd ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
-#define _mm_mask_sqrt_ss(W, U, A, B) _mm_mask_sqrt_round_ss ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
-#define _mm_maskz_sqrt_ss(U, A, B) _mm_maskz_sqrt_round_ss ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_cvtepi8_epi32 (__m128i __A)
@@ -2294,122 +4914,6 @@ _mm512_maskz_div_round_ps (__mmask16 __U, __m512 __A, __m512 __B, const int __R)
       _mm512_setzero_ps (),
       (__mmask16) __U, __R);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mul_round_sd (__m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_mulsd_round ((__v2df) __A,
-            (__v2df) __B,
-            __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_mul_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
-     __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_mulsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_mul_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-      const int __R)
-{
-  return (__m128d) __builtin_ia32_mulsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mul_round_ss (__m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_mulss_round ((__v4sf) __A,
-           (__v4sf) __B,
-           __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_mul_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
-     __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_mulss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_mul_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
-      const int __R)
-{
-  return (__m128) __builtin_ia32_mulss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_div_round_sd (__m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_divsd_round ((__v2df) __A,
-            (__v2df) __B,
-            __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_div_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
-     __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_divsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_div_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-      const int __R)
-{
-  return (__m128d) __builtin_ia32_divsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_div_round_ss (__m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_divss_round ((__v4sf) __A,
-           (__v4sf) __B,
-           __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_div_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
-     __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_divss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_div_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
-      const int __R)
-{
-  return (__m128) __builtin_ia32_divss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __U, __R);
-}
 #else
 #define _mm512_mul_round_pd(A, B, C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, (__v8df)_mm512_undefined_pd(), -1, C)
 #define _mm512_mask_mul_round_pd(W, U, A, B, C) (__m512d)__builtin_ia32_mulpd512_mask(A, B, W, U, C)
@@ -2423,18 +4927,6 @@ _mm_maskz_div_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
 #define _mm512_div_round_ps(A, B, C) (__m512)__builtin_ia32_divps512_mask(A, B, (__v16sf)_mm512_undefined_ps(), -1, C)
 #define _mm512_mask_div_round_ps(W, U, A, B, C) (__m512)__builtin_ia32_divps512_mask(A, B, W, U, C)
 #define _mm512_maskz_div_round_ps(U, A, B, C) (__m512)__builtin_ia32_divps512_mask(A, B, (__v16sf)_mm512_setzero_ps(), U, C)
-#define _mm_mul_round_sd(A, B, C) (__m128d)__builtin_ia32_mulsd_round(A, B, C)
-#define _mm_mask_mul_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_mulsd_mask_round(A, B, W, U, C)
-#define _mm_maskz_mul_round_sd(U, A, B, C) (__m128d)__builtin_ia32_mulsd_mask_round(A, B, (__v2df)_mm_setzero_pd(), U, C)
-#define _mm_mul_round_ss(A, B, C) (__m128)__builtin_ia32_mulss_round(A, B, C)
-#define _mm_mask_mul_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_mulss_mask_round(A, B, W, U, C)
-#define _mm_maskz_mul_round_ss(U, A, B, C) (__m128)__builtin_ia32_mulss_mask_round(A, B, (__v4sf)_mm_setzero_ps(), U, C)
-#define _mm_div_round_sd(A, B, C) (__m128d)__builtin_ia32_divsd_round(A, B, C)
-#define _mm_mask_div_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_divsd_mask_round(A, B, W, U, C)
-#define _mm_maskz_div_round_sd(U, A, B, C) (__m128d)__builtin_ia32_divsd_mask_round(A, B, (__v2df)_mm_setzero_pd(), U, C)
-#define _mm_div_round_ss(A, B, C) (__m128)__builtin_ia32_divss_round(A, B, C)
-#define _mm_mask_div_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_divss_mask_round(A, B, W, U, C)
-#define _mm_maskz_div_round_ss(U, A, B, C) (__m128)__builtin_ia32_divss_mask_round(A, B, (__v4sf)_mm_setzero_ps(), U, C)
 #endif
 #ifdef __OPTIMIZE__
 extern __inline __m512d
@@ -2636,67 +5128,6 @@ _mm512_maskz_scalef_round_ps (__mmask16 __U, __m512 __A, __m512 __B,
          _mm512_setzero_ps (),
          (__mmask16) __U, __R);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_scalef_round_sd (__m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_scalefsd_mask_round ((__v2df) __A,
-             (__v2df) __B,
-             (__v2df)
-             _mm_setzero_pd (),
-             (__mmask8) -1, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_scalef_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
-     const int __R)
-{
-  return (__m128d) __builtin_ia32_scalefsd_mask_round ((__v2df) __A,
-             (__v2df) __B,
-             (__v2df) __W,
-             (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_scalef_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-      const int __R)
-{
-  return (__m128d) __builtin_ia32_scalefsd_mask_round ((__v2df) __A,
-             (__v2df) __B,
-             (__v2df)
-             _mm_setzero_pd (),
-             (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_scalef_round_ss (__m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_scalefss_mask_round ((__v4sf) __A,
-            (__v4sf) __B,
-            (__v4sf)
-            _mm_setzero_ps (),
-            (__mmask8) -1, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_scalef_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
-    const int __R)
-{
-  return (__m128) __builtin_ia32_scalefss_mask_round ((__v4sf) __A,
-            (__v4sf) __B,
-            (__v4sf) __W,
-            (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_scalef_round_ss (__mmask8 __U, __m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_scalefss_mask_round ((__v4sf) __A,
-            (__v4sf) __B,
-            (__v4sf)
-            _mm_setzero_ps (),
-            (__mmask8) __U, __R);
-}
 #else
 #define _mm512_scalef_round_pd(A, B, C) ((__m512d) __builtin_ia32_scalefpd512_mask((A), (B), (__v8df) _mm512_undefined_pd(), -1, (C)))
 #define _mm512_mask_scalef_round_pd(W, U, A, B, C) ((__m512d) __builtin_ia32_scalefpd512_mask((A), (B), (W), (U), (C)))
@@ -2704,17 +5135,7 @@ _mm_maskz_scalef_round_ss (__mmask8 __U, __m128 __A, __m128 __B, const int __R)
 #define _mm512_scalef_round_ps(A, B, C) ((__m512) __builtin_ia32_scalefps512_mask((A), (B), (__v16sf) _mm512_undefined_ps(), -1, (C)))
 #define _mm512_mask_scalef_round_ps(W, U, A, B, C) ((__m512) __builtin_ia32_scalefps512_mask((A), (B), (W), (U), (C)))
 #define _mm512_maskz_scalef_round_ps(U, A, B, C) ((__m512) __builtin_ia32_scalefps512_mask((A), (B), (__v16sf) _mm512_setzero_ps(), (U), (C)))
-#define _mm_scalef_round_sd(A, B, C) ((__m128d) __builtin_ia32_scalefsd_mask_round ((A), (B), (__v2df) _mm_undefined_pd (), -1, (C)))
-#define _mm_scalef_round_ss(A, B, C) ((__m128) __builtin_ia32_scalefss_mask_round ((A), (B), (__v4sf) _mm_undefined_ps (), -1, (C)))
-#define _mm_mask_scalef_round_sd(W, U, A, B, C) ((__m128d) __builtin_ia32_scalefsd_mask_round ((A), (B), (W), (U), (C)))
-#define _mm_mask_scalef_round_ss(W, U, A, B, C) ((__m128) __builtin_ia32_scalefss_mask_round ((A), (B), (W), (U), (C)))
-#define _mm_maskz_scalef_round_sd(U, A, B, C) ((__m128d) __builtin_ia32_scalefsd_mask_round ((A), (B), (__v2df) _mm_setzero_pd (), (U), (C)))
-#define _mm_maskz_scalef_round_ss(U, A, B, C) ((__m128) __builtin_ia32_scalefss_mask_round ((A), (B), (__v4sf) _mm_setzero_ps (), (U), (C)))
 #endif
-#define _mm_mask_scalef_sd(W, U, A, B) _mm_mask_scalef_round_sd ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
-#define _mm_maskz_scalef_sd(U, A, B) _mm_maskz_scalef_round_sd ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
-#define _mm_mask_scalef_ss(W, U, A, B) _mm_mask_scalef_round_ss ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
-#define _mm_maskz_scalef_ss(U, A, B) _mm_maskz_scalef_round_ss ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
 #ifdef __OPTIMIZE__
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -4168,88 +6589,6 @@ _mm512_maskz_cvt_roundps_epu32 (__mmask16 __U, __m512 __A, const int __R)
 #define _mm512_mask_cvt_roundps_epu32(W, U, A, B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)(W), U, B))
 #define _mm512_maskz_cvt_roundps_epu32(U, A, B) ((__m512i)__builtin_ia32_cvtps2udq512_mask(A, (__v16si)_mm512_setzero_si512 (), U, B))
 #endif
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtu32_sd (__m128d __A, unsigned __B)
-{
-  return (__m128d) __builtin_ia32_cvtusi2sd32 ((__v2df) __A, __B);
-}
-#ifdef __x86_64__
-#ifdef __OPTIMIZE__
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundu64_sd (__m128d __A, unsigned long long __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_cvtusi2sd64 ((__v2df) __A, __B, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundi64_sd (__m128d __A, long long __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_cvtsi2sd64 ((__v2df) __A, __B, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsi64_sd (__m128d __A, long long __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_cvtsi2sd64 ((__v2df) __A, __B, __R);
-}
-#else
-#define _mm_cvt_roundu64_sd(A, B, C) (__m128d)__builtin_ia32_cvtusi2sd64(A, B, C)
-#define _mm_cvt_roundi64_sd(A, B, C) (__m128d)__builtin_ia32_cvtsi2sd64(A, B, C)
-#define _mm_cvt_roundsi64_sd(A, B, C) (__m128d)__builtin_ia32_cvtsi2sd64(A, B, C)
-#endif
-#endif
-#ifdef __OPTIMIZE__
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundu32_ss (__m128 __A, unsigned __B, const int __R)
-{
-  return (__m128) __builtin_ia32_cvtusi2ss32 ((__v4sf) __A, __B, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsi32_ss (__m128 __A, int __B, const int __R)
-{
-  return (__m128) __builtin_ia32_cvtsi2ss32 ((__v4sf) __A, __B, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundi32_ss (__m128 __A, int __B, const int __R)
-{
-  return (__m128) __builtin_ia32_cvtsi2ss32 ((__v4sf) __A, __B, __R);
-}
-#else
-#define _mm_cvt_roundu32_ss(A, B, C) (__m128)__builtin_ia32_cvtusi2ss32(A, B, C)
-#define _mm_cvt_roundi32_ss(A, B, C) (__m128)__builtin_ia32_cvtsi2ss32(A, B, C)
-#define _mm_cvt_roundsi32_ss(A, B, C) (__m128)__builtin_ia32_cvtsi2ss32(A, B, C)
-#endif
-#ifdef __x86_64__
-#ifdef __OPTIMIZE__
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundu64_ss (__m128 __A, unsigned long long __B, const int __R)
-{
-  return (__m128) __builtin_ia32_cvtusi2ss64 ((__v4sf) __A, __B, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsi64_ss (__m128 __A, long long __B, const int __R)
-{
-  return (__m128) __builtin_ia32_cvtsi2ss64 ((__v4sf) __A, __B, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundi64_ss (__m128 __A, long long __B, const int __R)
-{
-  return (__m128) __builtin_ia32_cvtsi2ss64 ((__v4sf) __A, __B, __R);
-}
-#else
-#define _mm_cvt_roundu64_ss(A, B, C) (__m128)__builtin_ia32_cvtusi2ss64(A, B, C)
-#define _mm_cvt_roundi64_ss(A, B, C) (__m128)__builtin_ia32_cvtsi2ss64(A, B, C)
-#define _mm_cvt_roundsi64_ss(A, B, C) (__m128)__builtin_ia32_cvtsi2ss64(A, B, C)
-#endif
-#endif
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_cvtepi32_epi8 (__m512i __A)
@@ -5138,73 +7477,6 @@ _mm512_mask_storeu_ps (void *__P, __mmask16 __U, __m512 __A)
   __builtin_ia32_storeups512_mask ((float *) __P, (__v16sf) __A,
        (__mmask16) __U);
 }
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_load_ss (__m128 __W, __mmask8 __U, const float *__P)
-{
-  return (__m128) __builtin_ia32_loadss_mask (__P, (__v4sf) __W, __U);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_load_ss (__mmask8 __U, const float *__P)
-{
-  return (__m128) __builtin_ia32_loadss_mask (__P, (__v4sf) _mm_setzero_ps (),
-           __U);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_load_sd (__m128d __W, __mmask8 __U, const double *__P)
-{
-  return (__m128d) __builtin_ia32_loadsd_mask (__P, (__v2df) __W, __U);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_load_sd (__mmask8 __U, const double *__P)
-{
-  return (__m128d) __builtin_ia32_loadsd_mask (__P, (__v2df) _mm_setzero_pd (),
-            __U);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_move_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_movess_mask ((__v4sf) __A, (__v4sf) __B,
-           (__v4sf) __W, __U);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_move_ss (__mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_movess_mask ((__v4sf) __A, (__v4sf) __B,
-           (__v4sf) _mm_setzero_ps (), __U);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_move_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_movesd_mask ((__v2df) __A, (__v2df) __B,
-            (__v2df) __W, __U);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_move_sd (__mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_movesd_mask ((__v2df) __A, (__v2df) __B,
-            (__v2df) _mm_setzero_pd (),
-            __U);
-}
-extern __inline void
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_store_ss (float *__P, __mmask8 __U, __m128 __A)
-{
-  __builtin_ia32_storess_mask (__P, (__v4sf) __A, (__mmask8) __U);
-}
-extern __inline void
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_store_sd (double *__P, __mmask8 __U, __m128d __A)
-{
-  __builtin_ia32_storesd_mask (__P, (__v2df) __A, (__mmask8) __U);
-}
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_loadu_epi64 (void const *__P)
@@ -5887,67 +8159,6 @@ _mm512_maskz_fixupimm_round_ps (__mmask16 __U, __m512 __A, __m512 __B,
             __imm,
             (__mmask16) __U, __R);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fixupimm_round_sd (__m128d __A, __m128d __B, __m128i __C,
-         const int __imm, const int __R)
-{
-  return (__m128d) __builtin_ia32_fixupimmsd_mask ((__v2df) __A,
-         (__v2df) __B,
-         (__v2di) __C, __imm,
-         (__mmask8) -1, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fixupimm_round_sd (__m128d __A, __mmask8 __U, __m128d __B,
-       __m128i __C, const int __imm, const int __R)
-{
-  return (__m128d) __builtin_ia32_fixupimmsd_mask ((__v2df) __A,
-         (__v2df) __B,
-         (__v2di) __C, __imm,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fixupimm_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-        __m128i __C, const int __imm, const int __R)
-{
-  return (__m128d) __builtin_ia32_fixupimmsd_maskz ((__v2df) __A,
-          (__v2df) __B,
-          (__v2di) __C,
-          __imm,
-          (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fixupimm_round_ss (__m128 __A, __m128 __B, __m128i __C,
-         const int __imm, const int __R)
-{
-  return (__m128) __builtin_ia32_fixupimmss_mask ((__v4sf) __A,
-        (__v4sf) __B,
-        (__v4si) __C, __imm,
-        (__mmask8) -1, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fixupimm_round_ss (__m128 __A, __mmask8 __U, __m128 __B,
-       __m128i __C, const int __imm, const int __R)
-{
-  return (__m128) __builtin_ia32_fixupimmss_mask ((__v4sf) __A,
-        (__v4sf) __B,
-        (__v4si) __C, __imm,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fixupimm_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
-        __m128i __C, const int __imm, const int __R)
-{
-  return (__m128) __builtin_ia32_fixupimmss_maskz ((__v4sf) __A,
-         (__v4sf) __B,
-         (__v4si) __C, __imm,
-         (__mmask8) __U, __R);
-}
 #else
 #define _mm512_shuffle_pd(X, Y, C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1))
 #define _mm512_mask_shuffle_pd(W, U, X, Y, C) ((__m512d)__builtin_ia32_shufpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(C), (__v8df)(__m512d)(W), (__mmask8)(U)))
@@ -5961,12 +8172,6 @@ _mm_maskz_fixupimm_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
 #define _mm512_fixupimm_round_ps(X, Y, Z, C, R) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(-1), (R)))
 #define _mm512_mask_fixupimm_round_ps(X, U, Y, Z, C, R) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), (R)))
 #define _mm512_maskz_fixupimm_round_ps(U, X, Y, Z, C, R) ((__m512)__builtin_ia32_fixupimmps512_maskz ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), (R)))
-#define _mm_fixupimm_round_sd(X, Y, Z, C, R) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(-1), (R)))
-#define _mm_mask_fixupimm_round_sd(X, U, Y, Z, C, R) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
-#define _mm_maskz_fixupimm_round_sd(U, X, Y, Z, C, R) ((__m128d)__builtin_ia32_fixupimmsd_maskz ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
-#define _mm_fixupimm_round_ss(X, Y, Z, C, R) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1), (R)))
-#define _mm_mask_fixupimm_round_ss(X, U, Y, Z, C, R) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
-#define _mm_maskz_fixupimm_round_ss(U, X, Y, Z, C, R) ((__m128)__builtin_ia32_fixupimmss_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), (R)))
 #endif
 extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -6579,190 +8784,6 @@ _mm512_maskz_unpacklo_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
             _mm512_setzero_si512 (),
             (__mmask8) __U);
 }
-#ifdef __x86_64__
-#ifdef __OPTIMIZE__
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundss_u64 (__m128 __A, const int __R)
-{
-  return (unsigned long long) __builtin_ia32_vcvtss2usi64 ((__v4sf) __A, __R);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundss_si64 (__m128 __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvtss2si64 ((__v4sf) __A, __R);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundss_i64 (__m128 __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvtss2si64 ((__v4sf) __A, __R);
-}
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundss_u64 (__m128 __A, const int __R)
-{
-  return (unsigned long long) __builtin_ia32_vcvttss2usi64 ((__v4sf) __A, __R);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundss_i64 (__m128 __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvttss2si64 ((__v4sf) __A, __R);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundss_si64 (__m128 __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvttss2si64 ((__v4sf) __A, __R);
-}
-#else
-#define _mm_cvt_roundss_u64(A, B) ((unsigned long long)__builtin_ia32_vcvtss2usi64(A, B))
-#define _mm_cvt_roundss_si64(A, B) ((long long)__builtin_ia32_vcvtss2si64(A, B))
-#define _mm_cvt_roundss_i64(A, B) ((long long)__builtin_ia32_vcvtss2si64(A, B))
-#define _mm_cvtt_roundss_u64(A, B) ((unsigned long long)__builtin_ia32_vcvttss2usi64(A, B))
-#define _mm_cvtt_roundss_i64(A, B) ((long long)__builtin_ia32_vcvttss2si64(A, B))
-#define _mm_cvtt_roundss_si64(A, B) ((long long)__builtin_ia32_vcvttss2si64(A, B))
-#endif
-#endif
-#ifdef __OPTIMIZE__
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundss_u32 (__m128 __A, const int __R)
-{
-  return (unsigned) __builtin_ia32_vcvtss2usi32 ((__v4sf) __A, __R);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundss_si32 (__m128 __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvtss2si32 ((__v4sf) __A, __R);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundss_i32 (__m128 __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvtss2si32 ((__v4sf) __A, __R);
-}
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundss_u32 (__m128 __A, const int __R)
-{
-  return (unsigned) __builtin_ia32_vcvttss2usi32 ((__v4sf) __A, __R);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundss_i32 (__m128 __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvttss2si32 ((__v4sf) __A, __R);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundss_si32 (__m128 __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvttss2si32 ((__v4sf) __A, __R);
-}
-#else
-#define _mm_cvt_roundss_u32(A, B) ((unsigned)__builtin_ia32_vcvtss2usi32(A, B))
-#define _mm_cvt_roundss_si32(A, B) ((int)__builtin_ia32_vcvtss2si32(A, B))
-#define _mm_cvt_roundss_i32(A, B) ((int)__builtin_ia32_vcvtss2si32(A, B))
-#define _mm_cvtt_roundss_u32(A, B) ((unsigned)__builtin_ia32_vcvttss2usi32(A, B))
-#define _mm_cvtt_roundss_si32(A, B) ((int)__builtin_ia32_vcvttss2si32(A, B))
-#define _mm_cvtt_roundss_i32(A, B) ((int)__builtin_ia32_vcvttss2si32(A, B))
-#endif
-#ifdef __x86_64__
-#ifdef __OPTIMIZE__
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsd_u64 (__m128d __A, const int __R)
-{
-  return (unsigned long long) __builtin_ia32_vcvtsd2usi64 ((__v2df) __A, __R);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsd_si64 (__m128d __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvtsd2si64 ((__v2df) __A, __R);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsd_i64 (__m128d __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvtsd2si64 ((__v2df) __A, __R);
-}
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundsd_u64 (__m128d __A, const int __R)
-{
-  return (unsigned long long) __builtin_ia32_vcvttsd2usi64 ((__v2df) __A, __R);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundsd_si64 (__m128d __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvttsd2si64 ((__v2df) __A, __R);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundsd_i64 (__m128d __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvttsd2si64 ((__v2df) __A, __R);
-}
-#else
-#define _mm_cvt_roundsd_u64(A, B) ((unsigned long long)__builtin_ia32_vcvtsd2usi64(A, B))
-#define _mm_cvt_roundsd_si64(A, B) ((long long)__builtin_ia32_vcvtsd2si64(A, B))
-#define _mm_cvt_roundsd_i64(A, B) ((long long)__builtin_ia32_vcvtsd2si64(A, B))
-#define _mm_cvtt_roundsd_u64(A, B) ((unsigned long long)__builtin_ia32_vcvttsd2usi64(A, B))
-#define _mm_cvtt_roundsd_si64(A, B) ((long long)__builtin_ia32_vcvttsd2si64(A, B))
-#define _mm_cvtt_roundsd_i64(A, B) ((long long)__builtin_ia32_vcvttsd2si64(A, B))
-#endif
-#endif
-#ifdef __OPTIMIZE__
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsd_u32 (__m128d __A, const int __R)
-{
-  return (unsigned) __builtin_ia32_vcvtsd2usi32 ((__v2df) __A, __R);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsd_si32 (__m128d __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvtsd2si32 ((__v2df) __A, __R);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsd_i32 (__m128d __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvtsd2si32 ((__v2df) __A, __R);
-}
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundsd_u32 (__m128d __A, const int __R)
-{
-  return (unsigned) __builtin_ia32_vcvttsd2usi32 ((__v2df) __A, __R);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundsd_i32 (__m128d __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvttsd2si32 ((__v2df) __A, __R);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundsd_si32 (__m128d __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvttsd2si32 ((__v2df) __A, __R);
-}
-#else
-#define _mm_cvt_roundsd_u32(A, B) ((unsigned)__builtin_ia32_vcvtsd2usi32(A, B))
-#define _mm_cvt_roundsd_si32(A, B) ((int)__builtin_ia32_vcvtsd2si32(A, B))
-#define _mm_cvt_roundsd_i32(A, B) ((int)__builtin_ia32_vcvtsd2si32(A, B))
-#define _mm_cvtt_roundsd_u32(A, B) ((unsigned)__builtin_ia32_vcvttsd2usi32(A, B))
-#define _mm_cvtt_roundsd_si32(A, B) ((int)__builtin_ia32_vcvttsd2si32(A, B))
-#define _mm_cvtt_roundsd_i32(A, B) ((int)__builtin_ia32_vcvttsd2si32(A, B))
-#endif
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_movedup_pd (__m512d __A)
@@ -7032,81 +9053,11 @@ _mm512_maskz_cvt_roundpd_ps (__mmask8 __U, __m512d __A, const int __R)
          _mm256_setzero_ps (),
          (__mmask8) __U, __R);
 }
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsd_ss (__m128 __A, __m128d __B, const int __R)
-{
-  return (__m128) __builtin_ia32_cvtsd2ss_round ((__v4sf) __A,
-       (__v2df) __B,
-       __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cvt_roundsd_ss (__m128 __W, __mmask8 __U, __m128 __A,
-    __m128d __B, const int __R)
-{
-  return (__m128) __builtin_ia32_cvtsd2ss_mask_round ((__v4sf) __A,
-            (__v2df) __B,
-            (__v4sf) __W,
-            __U,
-            __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_cvt_roundsd_ss (__mmask8 __U, __m128 __A,
-    __m128d __B, const int __R)
-{
-  return (__m128) __builtin_ia32_cvtsd2ss_mask_round ((__v4sf) __A,
-            (__v2df) __B,
-            _mm_setzero_ps (),
-            __U,
-            __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundss_sd (__m128d __A, __m128 __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_cvtss2sd_round ((__v2df) __A,
-        (__v4sf) __B,
-        __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cvt_roundss_sd (__m128d __W, __mmask8 __U, __m128d __A,
-    __m128 __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_cvtss2sd_mask_round ((__v2df) __A,
-             (__v4sf) __B,
-             (__v2df) __W,
-             __U,
-             __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_cvt_roundss_sd (__mmask8 __U, __m128d __A,
-     __m128 __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_cvtss2sd_mask_round ((__v2df) __A,
-             (__v4sf) __B,
-             _mm_setzero_pd (),
-             __U,
-             __R);
-}
 #else
 #define _mm512_cvt_roundpd_ps(A, B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)_mm256_undefined_ps(), -1, B)
 #define _mm512_mask_cvt_roundpd_ps(W, U, A, B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)(W), U, B)
 #define _mm512_maskz_cvt_roundpd_ps(U, A, B) (__m256)__builtin_ia32_cvtpd2ps512_mask(A, (__v8sf)_mm256_setzero_ps(), U, B)
-#define _mm_cvt_roundsd_ss(A, B, C) (__m128)__builtin_ia32_cvtsd2ss_round(A, B, C)
-#define _mm_mask_cvt_roundsd_ss(W, U, A, B, C) (__m128)__builtin_ia32_cvtsd2ss_mask_round ((A), (B), (W), (U), (C))
-#define _mm_maskz_cvt_roundsd_ss(U, A, B, C) (__m128)__builtin_ia32_cvtsd2ss_mask_round ((A), (B), _mm_setzero_ps (), (U), (C))
-#define _mm_cvt_roundss_sd(A, B, C) (__m128d)__builtin_ia32_cvtss2sd_round(A, B, C)
-#define _mm_mask_cvt_roundss_sd(W, U, A, B, C) (__m128d)__builtin_ia32_cvtss2sd_mask_round ((A), (B), (W), (U), (C))
-#define _mm_maskz_cvt_roundss_sd(U, A, B, C) (__m128d)__builtin_ia32_cvtss2sd_mask_round ((A), (B), _mm_setzero_pd (), (U), (C))
 #endif
-#define _mm_mask_cvtss_sd(W, U, A, B) _mm_mask_cvt_roundss_sd ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
-#define _mm_maskz_cvtss_sd(U, A, B) _mm_maskz_cvt_roundss_sd ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
-#define _mm_mask_cvtsd_ss(W, U, A, B) _mm_mask_cvt_roundsd_ss ((W), (U), (A), (B), _MM_FROUND_CUR_DIRECTION)
-#define _mm_maskz_cvtsd_ss(U, A, B) _mm_maskz_cvt_roundsd_ss ((U), (A), (B), _MM_FROUND_CUR_DIRECTION)
 extern __inline void
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_stream_si512 (__m512i * __P, __m512i __A)
@@ -7131,78 +9082,7 @@ _mm512_stream_load_si512 (void *__P)
 {
   return __builtin_ia32_movntdqa512 ((__v8di *)__P);
 }
-typedef enum
-{
-  _MM_MANT_NORM_1_2,
-  _MM_MANT_NORM_p5_2,
-  _MM_MANT_NORM_p5_1,
-  _MM_MANT_NORM_p75_1p5
-} _MM_MANTISSA_NORM_ENUM;
-typedef enum
-{
-  _MM_MANT_SIGN_src,
-  _MM_MANT_SIGN_zero,
-  _MM_MANT_SIGN_nan
-} _MM_MANTISSA_SIGN_ENUM;
 #ifdef __OPTIMIZE__
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getexp_round_ss (__m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_getexpss128_round ((__v4sf) __A,
-          (__v4sf) __B,
-          __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getexp_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
-     __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_getexpss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getexp_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
-      const int __R)
-{
-  return (__m128) __builtin_ia32_getexpss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getexp_round_sd (__m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_getexpsd128_round ((__v2df) __A,
-           (__v2df) __B,
-           __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getexp_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
-     __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_getexpsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getexp_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-      const int __R)
-{
-  return (__m128d) __builtin_ia32_getexpsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U, __R);
-}
 extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_getexp_round_ps (__m512 __A, const int __R)
@@ -7323,78 +9203,6 @@ _mm512_maskz_getmant_round_ps (__mmask16 __U, __m512 __A,
           _mm512_setzero_ps (),
           __U, __R);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getmant_round_sd (__m128d __A, __m128d __B,
-        _MM_MANTISSA_NORM_ENUM __C,
-        _MM_MANTISSA_SIGN_ENUM __D, const int __R)
-{
-  return (__m128d) __builtin_ia32_getmantsd_round ((__v2df) __A,
-        (__v2df) __B,
-        (__D << 2) | __C,
-         __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getmant_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
-         __m128d __B, _MM_MANTISSA_NORM_ENUM __C,
-         _MM_MANTISSA_SIGN_ENUM __D, const int __R)
-{
-  return (__m128d) __builtin_ia32_getmantsd_mask_round ((__v2df) __A,
-          (__v2df) __B,
-          (__D << 2) | __C,
-                                                    (__v2df) __W,
-           __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getmant_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-          _MM_MANTISSA_NORM_ENUM __C,
-          _MM_MANTISSA_SIGN_ENUM __D, const int __R)
-{
-  return (__m128d) __builtin_ia32_getmantsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-              (__D << 2) | __C,
-                                                        (__v2df)
-                                                        _mm_setzero_pd(),
-              __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getmant_round_ss (__m128 __A, __m128 __B,
-        _MM_MANTISSA_NORM_ENUM __C,
-        _MM_MANTISSA_SIGN_ENUM __D, const int __R)
-{
-  return (__m128) __builtin_ia32_getmantss_round ((__v4sf) __A,
-        (__v4sf) __B,
-        (__D << 2) | __C,
-        __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getmant_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
-         __m128 __B, _MM_MANTISSA_NORM_ENUM __C,
-         _MM_MANTISSA_SIGN_ENUM __D, const int __R)
-{
-  return (__m128) __builtin_ia32_getmantss_mask_round ((__v4sf) __A,
-          (__v4sf) __B,
-          (__D << 2) | __C,
-                                                    (__v4sf) __W,
-           __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getmant_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
-          _MM_MANTISSA_NORM_ENUM __C,
-          _MM_MANTISSA_SIGN_ENUM __D, const int __R)
-{
-  return (__m128) __builtin_ia32_getmantss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-              (__D << 2) | __C,
-                                                        (__v4sf)
-                                                        _mm_setzero_ps(),
-              __U, __R);
-}
 #else
 #define _mm512_getmant_round_pd(X, B, C, R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)_mm512_undefined_pd(), (__mmask8)-1, (R)))
 #define _mm512_mask_getmant_round_pd(W, U, X, B, C, R) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)(W), (__mmask8)(U), (R)))
@@ -7402,18 +9210,6 @@ _mm_maskz_getmant_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
 #define _mm512_getmant_round_ps(X, B, C, R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)_mm512_undefined_ps(), (__mmask16)-1, (R)))
 #define _mm512_mask_getmant_round_ps(W, U, X, B, C, R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)(W), (__mmask16)(U), (R)))
 #define _mm512_maskz_getmant_round_ps(U, X, B, C, R) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)_mm512_setzero_ps(), (__mmask16)(U), (R)))
-#define _mm_getmant_round_sd(X, Y, C, D, R) ((__m128d)__builtin_ia32_getmantsd_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (R)))
-#define _mm_mask_getmant_round_sd(W, U, X, Y, C, D, R) ((__m128d)__builtin_ia32_getmantsd_mask_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (__v2df)(__m128d)(W), (__mmask8)(U), (R)))
-#define _mm_maskz_getmant_round_sd(U, X, Y, C, D, R) ((__m128d)__builtin_ia32_getmantsd_mask_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (__v2df)(__m128d)_mm_setzero_pd(), (__mmask8)(U), (R)))
-#define _mm_getmant_round_ss(X, Y, C, D, R) ((__m128)__builtin_ia32_getmantss_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (R)))
-#define _mm_mask_getmant_round_ss(W, U, X, Y, C, D, R) ((__m128)__builtin_ia32_getmantss_mask_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (__v4sf)(__m128)(W), (__mmask8)(U), (R)))
-#define _mm_maskz_getmant_round_ss(U, X, Y, C, D, R) ((__m128)__builtin_ia32_getmantss_mask_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (__v4sf)(__m128)_mm_setzero_ps(), (__mmask8)(U), (R)))
-#define _mm_getexp_round_ss(A, B, R) ((__m128)__builtin_ia32_getexpss128_round((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), R))
-#define _mm_mask_getexp_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_getexpss_mask_round(A, B, W, U, C)
-#define _mm_maskz_getexp_round_ss(U, A, B, C) (__m128)__builtin_ia32_getexpss_mask_round(A, B, (__v4sf)_mm_setzero_ps(), U, C)
-#define _mm_getexp_round_sd(A, B, R) ((__m128d)__builtin_ia32_getexpsd128_round((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), R))
-#define _mm_mask_getexp_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_getexpsd_mask_round(A, B, W, U, C)
-#define _mm_maskz_getexp_round_sd(U, A, B, C) (__m128d)__builtin_ia32_getexpsd_mask_round(A, B, (__v2df)_mm_setzero_pd(), U, C)
 #define _mm512_getexp_round_ps(A, R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, R))
 #define _mm512_mask_getexp_round_ps(W, U, A, R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)(__m512)(W), (__mmask16)(U), R))
 #define _mm512_maskz_getexp_round_ps(U, A, R) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), R))
@@ -7480,82 +9276,6 @@ _mm512_maskz_roundscale_round_pd (__mmask8 __A, __m512d __B,
          _mm512_setzero_pd (),
          (__mmask8) __A, __R);
 }
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_roundscale_round_ss (__m128 __A, __m128 __B, const int __imm,
-    const int __R)
-{
-  return (__m128)
-    __builtin_ia32_rndscaless_mask_round ((__v4sf) __A,
-       (__v4sf) __B, __imm,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) -1,
-       __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_roundscale_round_ss (__m128 __A, __mmask8 __B, __m128 __C,
-         __m128 __D, const int __imm, const int __R)
-{
-  return (__m128)
-    __builtin_ia32_rndscaless_mask_round ((__v4sf) __C,
-       (__v4sf) __D, __imm,
-       (__v4sf) __A,
-       (__mmask8) __B,
-       __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_roundscale_round_ss (__mmask8 __A, __m128 __B, __m128 __C,
-          const int __imm, const int __R)
-{
-  return (__m128)
-    __builtin_ia32_rndscaless_mask_round ((__v4sf) __B,
-       (__v4sf) __C, __imm,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __A,
-       __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_roundscale_round_sd (__m128d __A, __m128d __B, const int __imm,
-    const int __R)
-{
-  return (__m128d)
-    __builtin_ia32_rndscalesd_mask_round ((__v2df) __A,
-       (__v2df) __B, __imm,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) -1,
-       __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_roundscale_round_sd (__m128d __A, __mmask8 __B, __m128d __C,
-         __m128d __D, const int __imm, const int __R)
-{
-  return (__m128d)
-    __builtin_ia32_rndscalesd_mask_round ((__v2df) __C,
-       (__v2df) __D, __imm,
-       (__v2df) __A,
-       (__mmask8) __B,
-       __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_roundscale_round_sd (__mmask8 __A, __m128d __B, __m128d __C,
-          const int __imm, const int __R)
-{
-  return (__m128d)
-    __builtin_ia32_rndscalesd_mask_round ((__v2df) __B,
-       (__v2df) __C, __imm,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __A,
-       __R);
-}
 #else
 #define _mm512_roundscale_round_ps(A, B, R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(A), (int)(B), (__v16sf)_mm512_undefined_ps(), (__mmask16)(-1), R))
 #define _mm512_mask_roundscale_round_ps(A, B, C, D, R) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(C), (int)(D), (__v16sf)(__m512)(A), (__mmask16)(B), R))
@@ -7563,12 +9283,6 @@ _mm_maskz_roundscale_round_sd (__mmask8 __A, __m128d __B, __m128d __C,
 #define _mm512_roundscale_round_pd(A, B, R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(A), (int)(B), (__v8df)_mm512_undefined_pd(), (__mmask8)(-1), R))
 #define _mm512_mask_roundscale_round_pd(A, B, C, D, R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(C), (int)(D), (__v8df)(__m512d)(A), (__mmask8)(B), R))
 #define _mm512_maskz_roundscale_round_pd(A, B, C, R) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(B), (int)(C), (__v8df)_mm512_setzero_pd(), (__mmask8)(A), R))
-#define _mm_roundscale_round_ss(A, B, I, R) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (A), (__v4sf) (__m128) (B), (int) (I), (__v4sf) _mm_setzero_ps (), (__mmask8) (-1), (int) (R)))
-#define _mm_mask_roundscale_round_ss(A, U, B, C, I, R) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (B), (__v4sf) (__m128) (C), (int) (I), (__v4sf) (__m128) (A), (__mmask8) (U), (int) (R)))
-#define _mm_maskz_roundscale_round_ss(U, A, B, I, R) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (A), (__v4sf) (__m128) (B), (int) (I), (__v4sf) _mm_setzero_ps (), (__mmask8) (U), (int) (R)))
-#define _mm_roundscale_round_sd(A, B, I, R) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (A), (__v2df) (__m128d) (B), (int) (I), (__v2df) _mm_setzero_pd (), (__mmask8) (-1), (int) (R)))
-#define _mm_mask_roundscale_round_sd(A, U, B, C, I, R) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (B), (__v2df) (__m128d) (C), (int) (I), (__v2df) (__m128d) (A), (__mmask8) (U), (int) (R)))
-#define _mm_maskz_roundscale_round_sd(U, A, B, I, R) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (A), (__v2df) (__m128d) (B), (int) (I), (__v2df) _mm_setzero_pd (), (__mmask8) (U), (int) (R)))
 #endif
 extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -8039,20 +9753,6 @@ _mm512_cmpneq_epu64_mask (__m512i __X, __m512i __Y)
 #define _MM_CMPINT_NLE 0x6
 #define _MM_CMPINT_GT 0x6
 #ifdef __OPTIMIZE__
-extern __inline __mmask16
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kshiftli_mask16 (__mmask16 __A, unsigned int __B)
-{
-  return (__mmask16) __builtin_ia32_kshiftlihi ((__mmask16) __A,
-      (__mmask8) __B);
-}
-extern __inline __mmask16
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kshiftri_mask16 (__mmask16 __A, unsigned int __B)
-{
-  return (__mmask16) __builtin_ia32_kshiftrihi ((__mmask16) __A,
-      (__mmask8) __B);
-}
 extern __inline __mmask8
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_cmp_epi64_mask (__m512i __X, __m512i __Y, const int __P)
@@ -8156,43 +9856,7 @@ _mm512_mask_cmp_round_ps_mask (__mmask16 __U, __m512 __X, __m512 __Y,
          (__v16sf) __Y, __P,
          (__mmask16) __U, __R);
 }
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cmp_round_sd_mask (__m128d __X, __m128d __Y, const int __P, const int __R)
-{
-  return (__mmask8) __builtin_ia32_cmpsd_mask ((__v2df) __X,
-            (__v2df) __Y, __P,
-            (__mmask8) -1, __R);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cmp_round_sd_mask (__mmask8 __M, __m128d __X, __m128d __Y,
-       const int __P, const int __R)
-{
-  return (__mmask8) __builtin_ia32_cmpsd_mask ((__v2df) __X,
-            (__v2df) __Y, __P,
-            (__mmask8) __M, __R);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cmp_round_ss_mask (__m128 __X, __m128 __Y, const int __P, const int __R)
-{
-  return (__mmask8) __builtin_ia32_cmpss_mask ((__v4sf) __X,
-            (__v4sf) __Y, __P,
-            (__mmask8) -1, __R);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cmp_round_ss_mask (__mmask8 __M, __m128 __X, __m128 __Y,
-       const int __P, const int __R)
-{
-  return (__mmask8) __builtin_ia32_cmpss_mask ((__v4sf) __X,
-            (__v4sf) __Y, __P,
-            (__mmask8) __M, __R);
-}
 #else
-#define _kshiftli_mask16(X, Y) ((__mmask16) __builtin_ia32_kshiftlihi ((__mmask16)(X), (__mmask8)(Y)))
-#define _kshiftri_mask16(X, Y) ((__mmask16) __builtin_ia32_kshiftrihi ((__mmask16)(X), (__mmask8)(Y)))
 #define _mm512_cmp_epi64_mask(X, Y, P) ((__mmask8) __builtin_ia32_cmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)-1))
 #define _mm512_cmp_epi32_mask(X, Y, P) ((__mmask16) __builtin_ia32_cmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)-1))
 #define _mm512_cmp_epu64_mask(X, Y, P) ((__mmask8) __builtin_ia32_ucmpq512_mask ((__v8di)(__m512i)(X), (__v8di)(__m512i)(Y), (int)(P), (__mmask8)-1))
@@ -8205,10 +9869,6 @@ _mm_mask_cmp_round_ss_mask (__mmask8 __M, __m128 __X, __m128 __Y,
 #define _mm512_mask_cmp_epu32_mask(M, X, Y, P) ((__mmask16) __builtin_ia32_ucmpd512_mask ((__v16si)(__m512i)(X), (__v16si)(__m512i)(Y), (int)(P), (__mmask16)(M)))
 #define _mm512_mask_cmp_round_pd_mask(M, X, Y, P, R) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)(M), R))
 #define _mm512_mask_cmp_round_ps_mask(M, X, Y, P, R) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)(M), R))
-#define _mm_cmp_round_sd_mask(X, Y, P, R) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (__mmask8)-1, R))
-#define _mm_mask_cmp_round_sd_mask(M, X, Y, P, R) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (M), R))
-#define _mm_cmp_round_ss_mask(X, Y, P, R) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (__mmask8)-1, R))
-#define _mm_mask_cmp_round_ss_mask(M, X, Y, P, R) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (M), R))
 #endif
 #ifdef __OPTIMIZE__
 extern __inline __m512
@@ -8774,57 +10434,6 @@ _mm512_maskz_expandloadu_epi32 (__mmask16 __U, void const *__P)
         _mm512_setzero_si512
         (), (__mmask16) __U);
 }
-#define _kand_mask16 _mm512_kand
-#define _kandn_mask16 _mm512_kandn
-#define _knot_mask16 _mm512_knot
-#define _kor_mask16 _mm512_kor
-#define _kxnor_mask16 _mm512_kxnor
-#define _kxor_mask16 _mm512_kxor
-extern __inline unsigned char
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kortest_mask16_u8 (__mmask16 __A, __mmask16 __B, unsigned char *__CF)
-{
-  *__CF = (unsigned char) __builtin_ia32_kortestchi (__A, __B);
-  return (unsigned char) __builtin_ia32_kortestzhi (__A, __B);
-}
-extern __inline unsigned char
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kortestz_mask16_u8 (__mmask16 __A, __mmask16 __B)
-{
-  return (unsigned char) __builtin_ia32_kortestzhi ((__mmask16) __A,
-          (__mmask16) __B);
-}
-extern __inline unsigned char
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kortestc_mask16_u8 (__mmask16 __A, __mmask16 __B)
-{
-  return (unsigned char) __builtin_ia32_kortestchi ((__mmask16) __A,
-          (__mmask16) __B);
-}
-extern __inline unsigned int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_cvtmask16_u32 (__mmask16 __A)
-{
-  return (unsigned int) __builtin_ia32_kmovw ((__mmask16 ) __A);
-}
-extern __inline __mmask16
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_cvtu32_mask16 (unsigned int __A)
-{
-  return (__mmask16) __builtin_ia32_kmovw ((__mmask16 ) __A);
-}
-extern __inline __mmask16
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_load_mask16 (__mmask16 *__A)
-{
-  return (__mmask16) __builtin_ia32_kmovw (*(__mmask16 *) __A);
-}
-extern __inline void
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_store_mask16 (__mmask16 *__A, __mmask16 __B)
-{
-  *(__mmask16 *) __A = __builtin_ia32_kmovw (__B);
-}
 extern __inline __mmask16
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_kand (__mmask16 __A, __mmask16 __B)
@@ -8882,12 +10491,6 @@ _mm512_kunpackb (__mmask16 __A, __mmask16 __B)
 {
   return (__mmask16) __builtin_ia32_kunpckhi ((__mmask16) __A, (__mmask16) __B);
 }
-extern __inline __mmask16
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_kunpackb_mask16 (__mmask8 __A, __mmask8 __B)
-{
-  return (__mmask16) __builtin_ia32_kunpckhi ((__mmask16) __A, (__mmask16) __B);
-}
 #ifdef __OPTIMIZE__
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -9192,137 +10795,6 @@ _mm512_maskz_unpacklo_ps (__mmask16 __U, __m512 __A, __m512 __B)
          _mm512_setzero_ps (),
          (__mmask16) __U);
 }
-#ifdef __OPTIMIZE__
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_max_round_sd (__m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_maxsd_round ((__v2df) __A,
-            (__v2df) __B,
-            __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_max_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
-     __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_maxsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_max_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-      const int __R)
-{
-  return (__m128d) __builtin_ia32_maxsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_max_round_ss (__m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_maxss_round ((__v4sf) __A,
-           (__v4sf) __B,
-           __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_max_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
-     __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_maxss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_max_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
-      const int __R)
-{
-  return (__m128) __builtin_ia32_maxss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_min_round_sd (__m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_minsd_round ((__v2df) __A,
-            (__v2df) __B,
-            __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_min_round_sd (__m128d __W, __mmask8 __U, __m128d __A,
-     __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_minsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_min_round_sd (__mmask8 __U, __m128d __A, __m128d __B,
-      const int __R)
-{
-  return (__m128d) __builtin_ia32_minsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_min_round_ss (__m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_minss_round ((__v4sf) __A,
-           (__v4sf) __B,
-           __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_min_round_ss (__m128 __W, __mmask8 __U, __m128 __A,
-     __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_minss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf) __W,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_min_round_ss (__mmask8 __U, __m128 __A, __m128 __B,
-      const int __R)
-{
-  return (__m128) __builtin_ia32_minss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __U, __R);
-}
-#else
-#define _mm_max_round_sd(A, B, C) (__m128d)__builtin_ia32_maxsd_round(A, B, C)
-#define _mm_mask_max_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_maxsd_mask_round(A, B, W, U, C)
-#define _mm_maskz_max_round_sd(U, A, B, C) (__m128d)__builtin_ia32_maxsd_mask_round(A, B, (__v2df)_mm_setzero_pd(), U, C)
-#define _mm_max_round_ss(A, B, C) (__m128)__builtin_ia32_maxss_round(A, B, C)
-#define _mm_mask_max_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_maxss_mask_round(A, B, W, U, C)
-#define _mm_maskz_max_round_ss(U, A, B, C) (__m128)__builtin_ia32_maxss_mask_round(A, B, (__v4sf)_mm_setzero_ps(), U, C)
-#define _mm_min_round_sd(A, B, C) (__m128d)__builtin_ia32_minsd_round(A, B, C)
-#define _mm_mask_min_round_sd(W, U, A, B, C) (__m128d)__builtin_ia32_minsd_mask_round(A, B, W, U, C)
-#define _mm_maskz_min_round_sd(U, A, B, C) (__m128d)__builtin_ia32_minsd_mask_round(A, B, (__v2df)_mm_setzero_pd(), U, C)
-#define _mm_min_round_ss(A, B, C) (__m128)__builtin_ia32_minss_round(A, B, C)
-#define _mm_mask_min_round_ss(W, U, A, B, C) (__m128)__builtin_ia32_minss_mask_round(A, B, W, U, C)
-#define _mm_maskz_min_round_ss(U, A, B, C) (__m128)__builtin_ia32_minss_mask_round(A, B, (__v4sf)_mm_setzero_ps(), U, C)
-#endif
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mask_blend_pd (__mmask8 __U, __m512d __A, __m512d __W)
@@ -9355,613 +10827,6 @@ _mm512_mask_blend_epi32 (__mmask16 __U, __m512i __A, __m512i __W)
           (__v16si) __W,
           (__mmask16) __U);
 }
-#ifdef __OPTIMIZE__
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmadd_round_sd (__m128d __W, __m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_round ((__v2df) __W,
-         (__v2df) __A,
-         (__v2df) __B,
-         __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmadd_round_ss (__m128 __W, __m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_round ((__v4sf) __W,
-        (__v4sf) __A,
-        (__v4sf) __B,
-        __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmsub_round_sd (__m128d __W, __m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_round ((__v2df) __W,
-         (__v2df) __A,
-         -(__v2df) __B,
-         __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmsub_round_ss (__m128 __W, __m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_round ((__v4sf) __W,
-        (__v4sf) __A,
-        -(__v4sf) __B,
-        __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fnmadd_round_sd (__m128d __W, __m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_round ((__v2df) __W,
-         -(__v2df) __A,
-         (__v2df) __B,
-         __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fnmadd_round_ss (__m128 __W, __m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_round ((__v4sf) __W,
-        -(__v4sf) __A,
-        (__v4sf) __B,
-        __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fnmsub_round_sd (__m128d __W, __m128d __A, __m128d __B, const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_round ((__v2df) __W,
-         -(__v2df) __A,
-         -(__v2df) __B,
-         __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fnmsub_round_ss (__m128 __W, __m128 __A, __m128 __B, const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_round ((__v4sf) __W,
-        -(__v4sf) __A,
-        -(__v4sf) __B,
-        __R);
-}
-#else
-#define _mm_fmadd_round_sd(A, B, C, R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, B, C, R)
-#define _mm_fmadd_round_ss(A, B, C, R) (__m128)__builtin_ia32_vfmaddss3_round(A, B, C, R)
-#define _mm_fmsub_round_sd(A, B, C, R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, B, -(C), R)
-#define _mm_fmsub_round_ss(A, B, C, R) (__m128)__builtin_ia32_vfmaddss3_round(A, B, -(C), R)
-#define _mm_fnmadd_round_sd(A, B, C, R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, -(B), C, R)
-#define _mm_fnmadd_round_ss(A, B, C, R) (__m128)__builtin_ia32_vfmaddss3_round(A, -(B), C, R)
-#define _mm_fnmsub_round_sd(A, B, C, R) (__m128d)__builtin_ia32_vfmaddsd3_round(A, -(B), -(C), R)
-#define _mm_fnmsub_round_ss(A, B, C, R) (__m128)__builtin_ia32_vfmaddss3_round(A, -(B), -(C), R)
-#endif
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmadd_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
-        (__v2df) __A,
-        (__v2df) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmadd_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
-       (__v4sf) __A,
-       (__v4sf) __B,
-       (__mmask8) __U,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmadd_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask3 ((__v2df) __W,
-         (__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmadd_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask3 ((__v4sf) __W,
-        (__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmadd_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
-         (__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmadd_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
-        (__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmsub_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
-        (__v2df) __A,
-        -(__v2df) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmsub_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
-       (__v4sf) __A,
-       -(__v4sf) __B,
-       (__mmask8) __U,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmsub_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U)
-{
-  return (__m128d) __builtin_ia32_vfmsubsd3_mask3 ((__v2df) __W,
-         (__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmsub_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U)
-{
-  return (__m128) __builtin_ia32_vfmsubss3_mask3 ((__v4sf) __W,
-        (__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmsub_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
-         (__v2df) __A,
-         -(__v2df) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmsub_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
-        (__v4sf) __A,
-        -(__v4sf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmadd_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
-        -(__v2df) __A,
-        (__v2df) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmadd_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
-       -(__v4sf) __A,
-       (__v4sf) __B,
-       (__mmask8) __U,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmadd_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask3 ((__v2df) __W,
-         -(__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmadd_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask3 ((__v4sf) __W,
-        -(__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmadd_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
-         -(__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmadd_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
-        -(__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmsub_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
-        -(__v2df) __A,
-        -(__v2df) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmsub_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
-       -(__v4sf) __A,
-       -(__v4sf) __B,
-       (__mmask8) __U,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmsub_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U)
-{
-  return (__m128d) __builtin_ia32_vfmsubsd3_mask3 ((__v2df) __W,
-         -(__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmsub_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U)
-{
-  return (__m128) __builtin_ia32_vfmsubss3_mask3 ((__v4sf) __W,
-        -(__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmsub_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
-         -(__v2df) __A,
-         -(__v2df) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmsub_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
-        -(__v4sf) __A,
-        -(__v4sf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmadd_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
-    const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
-        (__v2df) __A,
-        (__v2df) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmadd_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
-    const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
-       (__v4sf) __A,
-       (__v4sf) __B,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmadd_round_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask3 ((__v2df) __W,
-         (__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmadd_round_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask3 ((__v4sf) __W,
-        (__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmadd_round_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B,
-     const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
-         (__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmadd_round_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B,
-     const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
-        (__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmsub_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
-    const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
-        (__v2df) __A,
-        -(__v2df) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmsub_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
-    const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
-       (__v4sf) __A,
-       -(__v4sf) __B,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmsub_round_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmsubsd3_mask3 ((__v2df) __W,
-         (__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmsub_round_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128) __builtin_ia32_vfmsubss3_mask3 ((__v4sf) __W,
-        (__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmsub_round_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B,
-     const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
-         (__v2df) __A,
-         -(__v2df) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmsub_round_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B,
-     const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
-        (__v4sf) __A,
-        -(__v4sf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmadd_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
-    const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
-        -(__v2df) __A,
-        (__v2df) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmadd_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
-    const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
-       -(__v4sf) __A,
-       (__v4sf) __B,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmadd_round_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask3 ((__v2df) __W,
-         -(__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmadd_round_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask3 ((__v4sf) __W,
-        -(__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmadd_round_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B,
-     const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
-         -(__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmadd_round_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B,
-     const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
-        -(__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmsub_round_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
-    const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_mask ((__v2df) __W,
-        -(__v2df) __A,
-        -(__v2df) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmsub_round_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
-    const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_mask ((__v4sf) __W,
-       -(__v4sf) __A,
-       -(__v4sf) __B,
-       (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmsub_round_sd (__m128d __W, __m128d __A, __m128d __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmsubsd3_mask3 ((__v2df) __W,
-         -(__v2df) __A,
-         (__v2df) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmsub_round_ss (__m128 __W, __m128 __A, __m128 __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128) __builtin_ia32_vfmsubss3_mask3 ((__v4sf) __W,
-        -(__v4sf) __A,
-        (__v4sf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmsub_round_sd (__mmask8 __U, __m128d __W, __m128d __A, __m128d __B,
-     const int __R)
-{
-  return (__m128d) __builtin_ia32_vfmaddsd3_maskz ((__v2df) __W,
-         -(__v2df) __A,
-         -(__v2df) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmsub_round_ss (__mmask8 __U, __m128 __W, __m128 __A, __m128 __B,
-     const int __R)
-{
-  return (__m128) __builtin_ia32_vfmaddss3_maskz ((__v4sf) __W,
-        -(__v4sf) __A,
-        -(__v4sf) __B,
-        (__mmask8) __U, __R);
-}
-#else
-#define _mm_mask_fmadd_round_sd(A, U, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_mask (A, B, C, U, R)
-#define _mm_mask_fmadd_round_ss(A, U, B, C, R) (__m128) __builtin_ia32_vfmaddss3_mask (A, B, C, U, R)
-#define _mm_mask3_fmadd_round_sd(A, B, C, U, R) (__m128d) __builtin_ia32_vfmaddsd3_mask3 (A, B, C, U, R)
-#define _mm_mask3_fmadd_round_ss(A, B, C, U, R) (__m128) __builtin_ia32_vfmaddss3_mask3 (A, B, C, U, R)
-#define _mm_maskz_fmadd_round_sd(U, A, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_maskz (A, B, C, U, R)
-#define _mm_maskz_fmadd_round_ss(U, A, B, C, R) (__m128) __builtin_ia32_vfmaddss3_maskz (A, B, C, U, R)
-#define _mm_mask_fmsub_round_sd(A, U, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_mask (A, B, -(C), U, R)
-#define _mm_mask_fmsub_round_ss(A, U, B, C, R) (__m128) __builtin_ia32_vfmaddss3_mask (A, B, -(C), U, R)
-#define _mm_mask3_fmsub_round_sd(A, B, C, U, R) (__m128d) __builtin_ia32_vfmsubsd3_mask3 (A, B, C, U, R)
-#define _mm_mask3_fmsub_round_ss(A, B, C, U, R) (__m128) __builtin_ia32_vfmsubss3_mask3 (A, B, C, U, R)
-#define _mm_maskz_fmsub_round_sd(U, A, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_maskz (A, B, -(C), U, R)
-#define _mm_maskz_fmsub_round_ss(U, A, B, C, R) (__m128) __builtin_ia32_vfmaddss3_maskz (A, B, -(C), U, R)
-#define _mm_mask_fnmadd_round_sd(A, U, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_mask (A, -(B), C, U, R)
-#define _mm_mask_fnmadd_round_ss(A, U, B, C, R) (__m128) __builtin_ia32_vfmaddss3_mask (A, -(B), C, U, R)
-#define _mm_mask3_fnmadd_round_sd(A, B, C, U, R) (__m128d) __builtin_ia32_vfmaddsd3_mask3 (A, -(B), C, U, R)
-#define _mm_mask3_fnmadd_round_ss(A, B, C, U, R) (__m128) __builtin_ia32_vfmaddss3_mask3 (A, -(B), C, U, R)
-#define _mm_maskz_fnmadd_round_sd(U, A, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_maskz (A, -(B), C, U, R)
-#define _mm_maskz_fnmadd_round_ss(U, A, B, C, R) (__m128) __builtin_ia32_vfmaddss3_maskz (A, -(B), C, U, R)
-#define _mm_mask_fnmsub_round_sd(A, U, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_mask (A, -(B), -(C), U, R)
-#define _mm_mask_fnmsub_round_ss(A, U, B, C, R) (__m128) __builtin_ia32_vfmaddss3_mask (A, -(B), -(C), U, R)
-#define _mm_mask3_fnmsub_round_sd(A, B, C, U, R) (__m128d) __builtin_ia32_vfmsubsd3_mask3 (A, -(B), C, U, R)
-#define _mm_mask3_fnmsub_round_ss(A, B, C, U, R) (__m128) __builtin_ia32_vfmsubss3_mask3 (A, -(B), C, U, R)
-#define _mm_maskz_fnmsub_round_sd(U, A, B, C, R) (__m128d) __builtin_ia32_vfmaddsd3_maskz (A, -(B), -(C), U, R)
-#define _mm_maskz_fnmsub_round_ss(U, A, B, C, R) (__m128) __builtin_ia32_vfmaddss3_maskz (A, -(B), -(C), U, R)
-#endif
-#ifdef __OPTIMIZE__
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_comi_round_ss (__m128 __A, __m128 __B, const int __P, const int __R)
-{
-  return __builtin_ia32_vcomiss ((__v4sf) __A, (__v4sf) __B, __P, __R);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_comi_round_sd (__m128d __A, __m128d __B, const int __P, const int __R)
-{
-  return __builtin_ia32_vcomisd ((__v2df) __A, (__v2df) __B, __P, __R);
-}
-#else
-#define _mm_comi_round_ss(A, B, C, D)__builtin_ia32_vcomiss(A, B, C, D)
-#define _mm_comi_round_sd(A, B, C, D)__builtin_ia32_vcomisd(A, B, C, D)
-#endif
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_sqrt_pd (__m512d __A)
@@ -10074,48 +10939,6 @@ _mm512_maskz_add_ps (__mmask16 __U, __m512 __A, __m512 __B)
       (__mmask16) __U,
       _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_add_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_addsd_mask_round ((__v2df) __A,
-      (__v2df) __B,
-      (__v2df) __W,
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_add_sd (__mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_addsd_mask_round ((__v2df) __A,
-      (__v2df) __B,
-      (__v2df)
-      _mm_setzero_pd (),
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_add_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_addss_mask_round ((__v4sf) __A,
-      (__v4sf) __B,
-      (__v4sf) __W,
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_add_ss (__mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_addss_mask_round ((__v4sf) __A,
-      (__v4sf) __B,
-      (__v4sf)
-      _mm_setzero_ps (),
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_sub_pd (__m512d __A, __m512d __B)
@@ -10170,48 +10993,6 @@ _mm512_maskz_sub_ps (__mmask16 __U, __m512 __A, __m512 __B)
       (__mmask16) __U,
       _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_sub_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_subsd_mask_round ((__v2df) __A,
-      (__v2df) __B,
-      (__v2df) __W,
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_sub_sd (__mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_subsd_mask_round ((__v2df) __A,
-      (__v2df) __B,
-      (__v2df)
-      _mm_setzero_pd (),
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_sub_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_subss_mask_round ((__v4sf) __A,
-      (__v4sf) __B,
-      (__v4sf) __W,
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_sub_ss (__mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_subss_mask_round ((__v4sf) __A,
-      (__v4sf) __B,
-      (__v4sf)
-      _mm_setzero_ps (),
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mul_pd (__m512d __A, __m512d __B)
@@ -10266,50 +11047,6 @@ _mm512_maskz_mul_ps (__mmask16 __U, __m512 __A, __m512 __B)
       (__mmask16) __U,
       _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_mul_sd (__m128d __W, __mmask8 __U, __m128d __A,
-     __m128d __B)
-{
-  return (__m128d) __builtin_ia32_mulsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_mul_sd (__mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_mulsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_mul_ss (__m128 __W, __mmask8 __U, __m128 __A,
-     __m128 __B)
-{
-  return (__m128) __builtin_ia32_mulss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf) __W,
-       (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_mul_ss (__mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_mulss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_div_pd (__m512d __M, __m512d __V)
@@ -10364,50 +11101,6 @@ _mm512_maskz_div_ps (__mmask16 __U, __m512 __A, __m512 __B)
       (__mmask16) __U,
       _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_div_sd (__m128d __W, __mmask8 __U, __m128d __A,
-     __m128d __B)
-{
-  return (__m128d) __builtin_ia32_divsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_div_sd (__mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_divsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_div_ss (__m128 __W, __mmask8 __U, __m128 __A,
-     __m128 __B)
-{
-  return (__m128) __builtin_ia32_divss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf) __W,
-       (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_div_ss (__mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_divss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_max_pd (__m512d __A, __m512d __B)
@@ -10472,48 +11165,6 @@ _mm512_maskz_max_ps (__mmask16 __U, __m512 __A, __m512 __B)
       (__mmask16) __U,
       _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_max_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_maxsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_max_sd (__mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_maxsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_max_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_maxss_mask_round ((__v4sf) __A,
-      (__v4sf) __B,
-      (__v4sf) __W,
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_max_ss (__mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_maxss_mask_round ((__v4sf) __A,
-      (__v4sf) __B,
-      (__v4sf)
-      _mm_setzero_ps (),
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_min_pd (__m512d __A, __m512d __B)
@@ -10578,48 +11229,6 @@ _mm512_maskz_min_ps (__mmask16 __U, __m512 __A, __m512 __B)
       (__mmask16) __U,
       _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_min_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_minsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df) __W,
-       (__mmask8) __U,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_min_sd (__mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_minsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __U,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_min_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_minss_mask_round ((__v4sf) __A,
-      (__v4sf) __B,
-      (__v4sf) __W,
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_min_ss (__mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_minss_mask_round ((__v4sf) __A,
-      (__v4sf) __B,
-      (__v4sf)
-      _mm_setzero_ps (),
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_scalef_pd (__m512d __A, __m512d __B)
@@ -10684,28 +11293,6 @@ _mm512_maskz_scalef_ps (__mmask16 __U, __m512 __A, __m512 __B)
          (__mmask16) __U,
          _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_scalef_sd (__m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_scalefsd_mask_round ((__v2df) __A,
-          (__v2df) __B,
-          (__v2df)
-          _mm_setzero_pd (),
-          (__mmask8) -1,
-          _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_scalef_ss (__m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_scalefss_mask_round ((__v4sf) __A,
-         (__v4sf) __B,
-         (__v4sf)
-         _mm_setzero_ps (),
-         (__mmask8) -1,
-         _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_fmadd_pd (__m512d __A, __m512d __B, __m512d __C)
@@ -11430,29 +12017,6 @@ _mm512_cvtss_f32 (__m512 __A)
 {
   return __A[0];
 }
-#ifdef __x86_64__
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtu64_ss (__m128 __A, unsigned long long __B)
-{
-  return (__m128) __builtin_ia32_cvtusi2ss64 ((__v4sf) __A, __B,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtu64_sd (__m128d __A, unsigned long long __B)
-{
-  return (__m128d) __builtin_ia32_cvtusi2sd64 ((__v2df) __A, __B,
-            _MM_FROUND_CUR_DIRECTION);
-}
-#endif
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtu32_ss (__m128 __A, unsigned __B)
-{
-  return (__m128) __builtin_ia32_cvtusi2ss32 ((__v4sf) __A, __B,
-           _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_cvtepi32_ps (__m512i __A)
@@ -11582,71 +12146,6 @@ _mm512_maskz_fixupimm_ps (__mmask16 __U, __m512 __A, __m512 __B,
             (__mmask16) __U,
             _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fixupimm_sd (__m128d __A, __m128d __B, __m128i __C, const int __imm)
-{
-  return (__m128d) __builtin_ia32_fixupimmsd_mask ((__v2df) __A,
-         (__v2df) __B,
-         (__v2di) __C, __imm,
-         (__mmask8) -1,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fixupimm_sd (__m128d __A, __mmask8 __U, __m128d __B,
-        __m128i __C, const int __imm)
-{
-  return (__m128d) __builtin_ia32_fixupimmsd_mask ((__v2df) __A,
-         (__v2df) __B,
-         (__v2di) __C, __imm,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fixupimm_sd (__mmask8 __U, __m128d __A, __m128d __B,
-         __m128i __C, const int __imm)
-{
-  return (__m128d) __builtin_ia32_fixupimmsd_maskz ((__v2df) __A,
-          (__v2df) __B,
-          (__v2di) __C,
-          __imm,
-          (__mmask8) __U,
-          _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fixupimm_ss (__m128 __A, __m128 __B, __m128i __C, const int __imm)
-{
-  return (__m128) __builtin_ia32_fixupimmss_mask ((__v4sf) __A,
-        (__v4sf) __B,
-        (__v4si) __C, __imm,
-        (__mmask8) -1,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fixupimm_ss (__m128 __A, __mmask8 __U, __m128 __B,
-        __m128i __C, const int __imm)
-{
-  return (__m128) __builtin_ia32_fixupimmss_mask ((__v4sf) __A,
-        (__v4sf) __B,
-        (__v4si) __C, __imm,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fixupimm_ss (__mmask8 __U, __m128 __A, __m128 __B,
-         __m128i __C, const int __imm)
-{
-  return (__m128) __builtin_ia32_fixupimmss_maskz ((__v4sf) __A,
-         (__v4sf) __B,
-         (__v4si) __C, __imm,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
 #else
 #define _mm512_fixupimm_pd(X, Y, Z, C) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_mask_fixupimm_pd(X, U, Y, Z, C) ((__m512d)__builtin_ia32_fixupimmpd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (__v8di)(__m512i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
@@ -11654,37 +12153,6 @@ _mm_maskz_fixupimm_ss (__mmask8 __U, __m128 __A, __m128 __B,
 #define _mm512_fixupimm_ps(X, Y, Z, C) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(-1), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_mask_fixupimm_ps(X, U, Y, Z, C) ((__m512)__builtin_ia32_fixupimmps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_maskz_fixupimm_ps(U, X, Y, Z, C) ((__m512)__builtin_ia32_fixupimmps512_maskz ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (__v16si)(__m512i)(Z), (int)(C), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_fixupimm_sd(X, Y, Z, C) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_fixupimm_sd(X, U, Y, Z, C) ((__m128d)__builtin_ia32_fixupimmsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_fixupimm_sd(U, X, Y, Z, C) ((__m128d)__builtin_ia32_fixupimmsd_maskz ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (__v2di)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_fixupimm_ss(X, Y, Z, C) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_fixupimm_ss(X, U, Y, Z, C) ((__m128)__builtin_ia32_fixupimmss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_fixupimm_ss(U, X, Y, Z, C) ((__m128)__builtin_ia32_fixupimmss_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#endif
-#ifdef __x86_64__
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtss_u64 (__m128 __A)
-{
-  return (unsigned long long) __builtin_ia32_vcvtss2usi64 ((__v4sf)
-          __A,
-          _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttss_u64 (__m128 __A)
-{
-  return (unsigned long long) __builtin_ia32_vcvttss2usi64 ((__v4sf)
-           __A,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttss_i64 (__m128 __A)
-{
-  return (long long) __builtin_ia32_vcvttss2si64 ((__v4sf) __A,
-        _MM_FROUND_CUR_DIRECTION);
-}
 #endif
 extern __inline int
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -11693,121 +12161,6 @@ _mm512_cvtsi512_si32 (__m512i __A)
   __v16si __B = (__v16si) __A;
   return __B[0];
 }
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtss_u32 (__m128 __A)
-{
-  return (unsigned) __builtin_ia32_vcvtss2usi32 ((__v4sf) __A,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttss_u32 (__m128 __A)
-{
-  return (unsigned) __builtin_ia32_vcvttss2usi32 ((__v4sf) __A,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttss_i32 (__m128 __A)
-{
-  return (int) __builtin_ia32_vcvttss2si32 ((__v4sf) __A,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsd_i32 (__m128d __A)
-{
-  return (int) __builtin_ia32_cvtsd2si ((__v2df) __A);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtss_i32 (__m128 __A)
-{
-  return (int) __builtin_ia32_cvtss2si ((__v4sf) __A);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvti32_sd (__m128d __A, int __B)
-{
-  return (__m128d) __builtin_ia32_cvtsi2sd ((__v2df) __A, __B);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvti32_ss (__m128 __A, int __B)
-{
-  return (__m128) __builtin_ia32_cvtsi2ss ((__v4sf) __A, __B);
-}
-#ifdef __x86_64__
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsd_u64 (__m128d __A)
-{
-  return (unsigned long long) __builtin_ia32_vcvtsd2usi64 ((__v2df)
-          __A,
-          _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttsd_u64 (__m128d __A)
-{
-  return (unsigned long long) __builtin_ia32_vcvttsd2usi64 ((__v2df)
-           __A,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttsd_i64 (__m128d __A)
-{
-  return (long long) __builtin_ia32_vcvttsd2si64 ((__v2df) __A,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsd_i64 (__m128d __A)
-{
-  return (long long) __builtin_ia32_cvtsd2si64 ((__v2df) __A);
-}
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtss_i64 (__m128 __A)
-{
-  return (long long) __builtin_ia32_cvtss2si64 ((__v4sf) __A);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvti64_sd (__m128d __A, long long __B)
-{
-  return (__m128d) __builtin_ia32_cvtsi642sd ((__v2df) __A, __B);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvti64_ss (__m128 __A, long long __B)
-{
-  return (__m128) __builtin_ia32_cvtsi642ss ((__v4sf) __A, __B);
-}
-#endif
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsd_u32 (__m128d __A)
-{
-  return (unsigned) __builtin_ia32_vcvtsd2usi32 ((__v2df) __A,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttsd_u32 (__m128d __A)
-{
-  return (unsigned) __builtin_ia32_vcvttsd2usi32 ((__v2df) __A,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttsd_i32 (__m128d __A)
-{
-  return (int) __builtin_ia32_vcvttsd2si32 ((__v2df) __A,
-         _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_cvtps_pd (__m256 __A)
@@ -11954,64 +12307,6 @@ _mm512_maskz_getexp_pd (__mmask8 __U, __m512d __A)
           (__mmask8) __U,
           _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getexp_ss (__m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_getexpss128_round ((__v4sf) __A,
-          (__v4sf) __B,
-          _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getexp_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_getexpss_mask_round ((__v4sf) __A,
-      (__v4sf) __B,
-      (__v4sf) __W,
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getexp_ss (__mmask8 __U, __m128 __A, __m128 __B)
-{
-  return (__m128) __builtin_ia32_getexpss_mask_round ((__v4sf) __A,
-      (__v4sf) __B,
-      (__v4sf)
-      _mm_setzero_ps (),
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getexp_sd (__m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_getexpsd128_round ((__v2df) __A,
-           (__v2df) __B,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getexp_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_getexpsd_mask_round ((__v2df) __A,
-      (__v2df) __B,
-      (__v2df) __W,
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getexp_sd (__mmask8 __U, __m128d __A, __m128d __B)
-{
-  return (__m128d) __builtin_ia32_getexpsd_mask_round ((__v2df) __A,
-      (__v2df) __B,
-      (__v2df)
-      _mm_setzero_pd (),
-      (__mmask8) __U,
-      _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_getmant_pd (__m512d __A, _MM_MANTISSA_NORM_ENUM __B,
@@ -12078,76 +12373,6 @@ _mm512_maskz_getmant_ps (__mmask16 __U, __m512 __A,
           __U,
           _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getmant_sd (__m128d __A, __m128d __B, _MM_MANTISSA_NORM_ENUM __C,
-  _MM_MANTISSA_SIGN_ENUM __D)
-{
-  return (__m128d) __builtin_ia32_getmantsd_round ((__v2df) __A,
-         (__v2df) __B,
-         (__D << 2) | __C,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getmant_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B,
-   _MM_MANTISSA_NORM_ENUM __C, _MM_MANTISSA_SIGN_ENUM __D)
-{
-  return (__m128d) __builtin_ia32_getmantsd_mask_round ((__v2df) __A,
-       (__v2df) __B,
-              (__D << 2) | __C,
-                                                        (__v2df) __W,
-             __U,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getmant_sd (__mmask8 __U, __m128d __A, __m128d __B,
-    _MM_MANTISSA_NORM_ENUM __C, _MM_MANTISSA_SIGN_ENUM __D)
-{
-  return (__m128d) __builtin_ia32_getmantsd_mask_round ((__v2df) __A,
-                                                        (__v2df) __B,
-              (__D << 2) | __C,
-                                                        (__v2df)
-       _mm_setzero_pd(),
-              __U,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getmant_ss (__m128 __A, __m128 __B, _MM_MANTISSA_NORM_ENUM __C,
-  _MM_MANTISSA_SIGN_ENUM __D)
-{
-  return (__m128) __builtin_ia32_getmantss_round ((__v4sf) __A,
-        (__v4sf) __B,
-        (__D << 2) | __C,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getmant_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B,
-   _MM_MANTISSA_NORM_ENUM __C, _MM_MANTISSA_SIGN_ENUM __D)
-{
-  return (__m128) __builtin_ia32_getmantss_mask_round ((__v4sf) __A,
-       (__v4sf) __B,
-              (__D << 2) | __C,
-                                                        (__v4sf) __W,
-             __U,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getmant_ss (__mmask8 __U, __m128 __A, __m128 __B,
-    _MM_MANTISSA_NORM_ENUM __C, _MM_MANTISSA_SIGN_ENUM __D)
-{
-  return (__m128) __builtin_ia32_getmantss_mask_round ((__v4sf) __A,
-                                                        (__v4sf) __B,
-              (__D << 2) | __C,
-                                                        (__v4sf)
-       _mm_setzero_ps(),
-              __U,
-           _MM_FROUND_CUR_DIRECTION);
-}
 #else
 #define _mm512_getmant_pd(X, B, C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)_mm512_undefined_pd(), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
 #define _mm512_mask_getmant_pd(W, U, X, B, C) ((__m512d)__builtin_ia32_getmantpd512_mask ((__v8df)(__m512d)(X), (int)(((C)<<2) | (B)), (__v8df)(__m512d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
@@ -12155,18 +12380,6 @@ _mm_maskz_getmant_ss (__mmask8 __U, __m128 __A, __m128 __B,
 #define _mm512_getmant_ps(X, B, C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, _MM_FROUND_CUR_DIRECTION))
 #define _mm512_mask_getmant_ps(W, U, X, B, C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)(__m512)(W), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_maskz_getmant_ps(U, X, B, C) ((__m512)__builtin_ia32_getmantps512_mask ((__v16sf)(__m512)(X), (int)(((C)<<2) | (B)), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_getmant_sd(X, Y, C, D) ((__m128d)__builtin_ia32_getmantsd_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_getmant_sd(W, U, X, Y, C, D) ((__m128d)__builtin_ia32_getmantsd_mask_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (__v2df)(__m128d)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_getmant_sd(U, X, Y, C, D) ((__m128d)__builtin_ia32_getmantsd_mask_round ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(((D)<<2) | (C)), (__v2df)_mm_setzero_pd(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_getmant_ss(X, Y, C, D) ((__m128)__builtin_ia32_getmantss_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_getmant_ss(W, U, X, Y, C, D) ((__m128)__builtin_ia32_getmantss_mask_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (__v4sf)(__m128)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_getmant_ss(U, X, Y, C, D) ((__m128)__builtin_ia32_getmantss_mask_round ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(((D)<<2) | (C)), (__v4sf)_mm_setzero_ps(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_getexp_ss(A, B) ((__m128)__builtin_ia32_getexpss128_round((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_getexp_ss(W, U, A, B) (__m128)__builtin_ia32_getexpss_mask_round(A, B, W, U, _MM_FROUND_CUR_DIRECTION)
-#define _mm_maskz_getexp_ss(U, A, B) (__m128)__builtin_ia32_getexpss_mask_round(A, B, (__v4sf)_mm_setzero_ps(), U, _MM_FROUND_CUR_DIRECTION)
-#define _mm_getexp_sd(A, B) ((__m128d)__builtin_ia32_getexpsd128_round((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_getexp_sd(W, U, A, B) (__m128d)__builtin_ia32_getexpsd_mask_round(A, B, W, U, _MM_FROUND_CUR_DIRECTION)
-#define _mm_maskz_getexp_sd(U, A, B) (__m128d)__builtin_ia32_getexpsd_mask_round(A, B, (__v2df)_mm_setzero_pd(), U, _MM_FROUND_CUR_DIRECTION)
 #define _mm512_getexp_ps(A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_undefined_ps(), (__mmask16)-1, _MM_FROUND_CUR_DIRECTION))
 #define _mm512_mask_getexp_ps(W, U, A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)(__m512)(W), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_maskz_getexp_ps(U, A) ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), _MM_FROUND_CUR_DIRECTION))
@@ -12237,80 +12450,6 @@ _mm512_maskz_roundscale_pd (__mmask8 __A, __m512d __B, const int __imm)
          (__mmask8) __A,
          _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_roundscale_ss (__m128 __A, __m128 __B, const int __imm)
-{
-  return (__m128)
-    __builtin_ia32_rndscaless_mask_round ((__v4sf) __A,
-       (__v4sf) __B, __imm,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_roundscale_ss (__m128 __A, __mmask8 __B, __m128 __C, __m128 __D,
-   const int __imm)
-{
-  return (__m128)
-    __builtin_ia32_rndscaless_mask_round ((__v4sf) __C,
-       (__v4sf) __D, __imm,
-       (__v4sf) __A,
-       (__mmask8) __B,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_roundscale_ss (__mmask8 __A, __m128 __B, __m128 __C,
-    const int __imm)
-{
-  return (__m128)
-    __builtin_ia32_rndscaless_mask_round ((__v4sf) __B,
-       (__v4sf) __C, __imm,
-       (__v4sf)
-       _mm_setzero_ps (),
-       (__mmask8) __A,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_roundscale_sd (__m128d __A, __m128d __B, const int __imm)
-{
-  return (__m128d)
-    __builtin_ia32_rndscalesd_mask_round ((__v2df) __A,
-       (__v2df) __B, __imm,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_roundscale_sd (__m128d __A, __mmask8 __B, __m128d __C, __m128d __D,
-   const int __imm)
-{
-  return (__m128d)
-    __builtin_ia32_rndscalesd_mask_round ((__v2df) __C,
-       (__v2df) __D, __imm,
-       (__v2df) __A,
-       (__mmask8) __B,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_roundscale_sd (__mmask8 __A, __m128d __B, __m128d __C,
-    const int __imm)
-{
-  return (__m128d)
-    __builtin_ia32_rndscalesd_mask_round ((__v2df) __B,
-       (__v2df) __C, __imm,
-       (__v2df)
-       _mm_setzero_pd (),
-       (__mmask8) __A,
-       _MM_FROUND_CUR_DIRECTION);
-}
 #else
 #define _mm512_roundscale_ps(A, B) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(A), (int)(B), (__v16sf)_mm512_undefined_ps(), (__mmask16)(-1), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_mask_roundscale_ps(A, B, C, D) ((__m512) __builtin_ia32_rndscaleps_mask ((__v16sf)(__m512)(C), (int)(D), (__v16sf)(__m512)(A), (__mmask16)(B), _MM_FROUND_CUR_DIRECTION))
@@ -12318,12 +12457,6 @@ _mm_maskz_roundscale_sd (__mmask8 __A, __m128d __B, __m128d __C,
 #define _mm512_roundscale_pd(A, B) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(A), (int)(B), (__v8df)_mm512_undefined_pd(), (__mmask8)(-1), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_mask_roundscale_pd(A, B, C, D) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(C), (int)(D), (__v8df)(__m512d)(A), (__mmask8)(B), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_maskz_roundscale_pd(A, B, C) ((__m512d) __builtin_ia32_rndscalepd_mask ((__v8df)(__m512d)(B), (int)(C), (__v8df)_mm512_setzero_pd(), (__mmask8)(A), _MM_FROUND_CUR_DIRECTION))
-#define _mm_roundscale_ss(A, B, I) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (A), (__v4sf) (__m128) (B), (int) (I), (__v4sf) _mm_setzero_ps (), (__mmask8) (-1), _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_roundscale_ss(A, U, B, C, I) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (B), (__v4sf) (__m128) (C), (int) (I), (__v4sf) (__m128) (A), (__mmask8) (U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_roundscale_ss(U, A, B, I) ((__m128) __builtin_ia32_rndscaless_mask_round ((__v4sf) (__m128) (A), (__v4sf) (__m128) (B), (int) (I), (__v4sf) _mm_setzero_ps (), (__mmask8) (U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_roundscale_sd(A, B, I) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (A), (__v2df) (__m128d) (B), (int) (I), (__v2df) _mm_setzero_pd (), (__mmask8) (-1), _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_roundscale_sd(A, U, B, C, I) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (B), (__v2df) (__m128d) (C), (int) (I), (__v2df) (__m128d) (A), (__mmask8) (U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_roundscale_sd(U, A, B, I) ((__m128d) __builtin_ia32_rndscalesd_mask_round ((__v2df) (__m128d) (A), (__v2df) (__m128d) (B), (int) (I), (__v2df) _mm_setzero_pd (), (__mmask8) (U), _MM_FROUND_CUR_DIRECTION))
 #endif
 #ifdef __OPTIMIZE__
 extern __inline __mmask8
@@ -12362,51 +12495,11 @@ _mm512_mask_cmp_pd_mask (__mmask8 __U, __m512d __X, __m512d __Y, const int __P)
         (__mmask8) __U,
         _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cmp_sd_mask (__m128d __X, __m128d __Y, const int __P)
-{
-  return (__mmask8) __builtin_ia32_cmpsd_mask ((__v2df) __X,
-            (__v2df) __Y, __P,
-            (__mmask8) -1,
-            _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cmp_sd_mask (__mmask8 __M, __m128d __X, __m128d __Y, const int __P)
-{
-  return (__mmask8) __builtin_ia32_cmpsd_mask ((__v2df) __X,
-            (__v2df) __Y, __P,
-            (__mmask8) __M,
-            _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cmp_ss_mask (__m128 __X, __m128 __Y, const int __P)
-{
-  return (__mmask8) __builtin_ia32_cmpss_mask ((__v4sf) __X,
-            (__v4sf) __Y, __P,
-            (__mmask8) -1,
-            _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cmp_ss_mask (__mmask8 __M, __m128 __X, __m128 __Y, const int __P)
-{
-  return (__mmask8) __builtin_ia32_cmpss_mask ((__v4sf) __X,
-            (__v4sf) __Y, __P,
-            (__mmask8) __M,
-            _MM_FROUND_CUR_DIRECTION);
-}
 #else
 #define _mm512_cmp_pd_mask(X, Y, P) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
 #define _mm512_cmp_ps_mask(X, Y, P) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)-1,_MM_FROUND_CUR_DIRECTION))
 #define _mm512_mask_cmp_pd_mask(M, X, Y, P) ((__mmask8) __builtin_ia32_cmppd512_mask ((__v8df)(__m512d)(X), (__v8df)(__m512d)(Y), (int)(P), (__mmask8)(M), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_mask_cmp_ps_mask(M, X, Y, P) ((__mmask16) __builtin_ia32_cmpps512_mask ((__v16sf)(__m512)(X), (__v16sf)(__m512)(Y), (int)(P), (__mmask16)(M),_MM_FROUND_CUR_DIRECTION))
-#define _mm_cmp_sd_mask(X, Y, P) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_cmp_sd_mask(M, X, Y, P) ((__mmask8) __builtin_ia32_cmpsd_mask ((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), (int)(P), M,_MM_FROUND_CUR_DIRECTION))
-#define _mm_cmp_ss_mask(X, Y, P) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), (__mmask8)-1,_MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_cmp_ss_mask(M, X, Y, P) ((__mmask8) __builtin_ia32_cmpss_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (int)(P), M,_MM_FROUND_CUR_DIRECTION))
 #endif
 extern __inline __mmask8
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -13237,8 +13330,8 @@ _mm512_mask_reduce_max_pd (__mmask8 __U, __m512d __A)
   __MM512_REDUCE_OP (max_pd);
 }
 #undef __MM512_REDUCE_OP
-#ifdef __DISABLE_AVX512F__
-#undef __DISABLE_AVX512F__
+#ifdef __DISABLE_AVX512F_512__
+#undef __DISABLE_AVX512F_512__
 #pragma GCC pop_options
 #endif
 #endif
diff --git a/third_party/intel/avx512fp16intrin.internal.h b/third_party/intel/avx512fp16intrin.internal.h
index 4f249cc30..04868b7bc 100644
--- a/third_party/intel/avx512fp16intrin.internal.h
+++ b/third_party/intel/avx512fp16intrin.internal.h
@@ -2,22 +2,19 @@
 #ifndef _IMMINTRIN_H_INCLUDED
 #error "Never use <avx512fp16intrin.h> directly; include <immintrin.h> instead."
 #endif
-#ifndef __AVX512FP16INTRIN_H_INCLUDED
-#define __AVX512FP16INTRIN_H_INCLUDED
-#ifndef __AVX512FP16__
+#ifndef _AVX512FP16INTRIN_H_INCLUDED
+#define _AVX512FP16INTRIN_H_INCLUDED
+#if !defined (__AVX512FP16__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512fp16")
+#pragma GCC target("avx512fp16,no-evex512")
 #define __DISABLE_AVX512FP16__
 #endif
 typedef _Float16 __v8hf __attribute__ ((__vector_size__ (16)));
 typedef _Float16 __v16hf __attribute__ ((__vector_size__ (32)));
-typedef _Float16 __v32hf __attribute__ ((__vector_size__ (64)));
 typedef _Float16 __m128h __attribute__ ((__vector_size__ (16), __may_alias__));
 typedef _Float16 __m256h __attribute__ ((__vector_size__ (32), __may_alias__));
-typedef _Float16 __m512h __attribute__ ((__vector_size__ (64), __may_alias__));
 typedef _Float16 __m128h_u __attribute__ ((__vector_size__ (16), __may_alias__, __aligned__ (1)));
 typedef _Float16 __m256h_u __attribute__ ((__vector_size__ (32), __may_alias__, __aligned__ (1)));
-typedef _Float16 __m512h_u __attribute__ ((__vector_size__ (64), __may_alias__, __aligned__ (1)));
 extern __inline __m128h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_set_ph (_Float16 __A7, _Float16 __A6, _Float16 __A5,
@@ -41,6 +38,2159 @@ _mm256_set_ph (_Float16 __A15, _Float16 __A14, _Float16 __A13,
         __A8, __A9, __A10, __A11,
         __A12, __A13, __A14, __A15 };
 }
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_setr_ph (_Float16 __A0, _Float16 __A1, _Float16 __A2,
+      _Float16 __A3, _Float16 __A4, _Float16 __A5,
+      _Float16 __A6, _Float16 __A7)
+{
+  return _mm_set_ph (__A7, __A6, __A5, __A4, __A3, __A2, __A1, __A0);
+}
+extern __inline __m256h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_setr_ph (_Float16 __A0, _Float16 __A1, _Float16 __A2,
+  _Float16 __A3, _Float16 __A4, _Float16 __A5,
+  _Float16 __A6, _Float16 __A7, _Float16 __A8,
+  _Float16 __A9, _Float16 __A10, _Float16 __A11,
+  _Float16 __A12, _Float16 __A13, _Float16 __A14,
+  _Float16 __A15)
+{
+  return _mm256_set_ph (__A15, __A14, __A13, __A12, __A11, __A10, __A9,
+   __A8, __A7, __A6, __A5, __A4, __A3, __A2, __A1,
+   __A0);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_set1_ph (_Float16 __A)
+{
+  return _mm_set_ph (__A, __A, __A, __A, __A, __A, __A, __A);
+}
+extern __inline __m256h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_set1_ph (_Float16 __A)
+{
+  return _mm256_set_ph (__A, __A, __A, __A, __A, __A, __A, __A,
+   __A, __A, __A, __A, __A, __A, __A, __A);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_setzero_ph (void)
+{
+  return _mm_set1_ph (0.0f16);
+}
+extern __inline __m256h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_setzero_ph (void)
+{
+  return _mm256_set1_ph (0.0f16);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_undefined_ph (void)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
+  __m128h __Y = __Y;
+#pragma GCC diagnostic pop
+  return __Y;
+}
+extern __inline __m256h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_undefined_ph (void)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
+  __m256h __Y = __Y;
+#pragma GCC diagnostic pop
+  return __Y;
+}
+extern __inline _Float16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_cvtsh_h (__m256h __A)
+{
+  return __A[0];
+}
+extern __inline __m256h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_load_ph (void const *__P)
+{
+  return *(const __m256h *) __P;
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_load_ph (void const *__P)
+{
+  return *(const __m128h *) __P;
+}
+extern __inline __m256h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_loadu_ph (void const *__P)
+{
+  return *(const __m256h_u *) __P;
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_loadu_ph (void const *__P)
+{
+  return *(const __m128h_u *) __P;
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_store_ph (void *__P, __m256h __A)
+{
+   *(__m256h *) __P = __A;
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_store_ph (void *__P, __m128h __A)
+{
+   *(__m128h *) __P = __A;
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_storeu_ph (void *__P, __m256h __A)
+{
+   *(__m256h_u *) __P = __A;
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_storeu_ph (void *__P, __m128h __A)
+{
+   *(__m128h_u *) __P = __A;
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_set_sh (_Float16 __F)
+{
+  return _mm_set_ph (0.0f16, 0.0f16, 0.0f16, 0.0f16, 0.0f16, 0.0f16, 0.0f16,
+       __F);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_load_sh (void const *__P)
+{
+  return _mm_set_ph (0.0f16, 0.0f16, 0.0f16, 0.0f16, 0.0f16, 0.0f16, 0.0f16,
+       *(_Float16 const *) __P);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_store_sh (void *__P, __m128h __A)
+{
+  *(_Float16 *) __P = ((__v8hf)__A)[0];
+}
+extern __inline __m128h
+  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_add_sh (__m128h __A, __m128h __B)
+{
+  __A[0] += __B[0];
+  return __A;
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_add_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_addsh_mask (__C, __D, __A, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_add_sh (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_addsh_mask (__B, __C, _mm_setzero_ph (),
+        __A);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sub_sh (__m128h __A, __m128h __B)
+{
+  __A[0] -= __B[0];
+  return __A;
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_sub_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_subsh_mask (__C, __D, __A, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_sub_sh (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_subsh_mask (__B, __C, _mm_setzero_ph (),
+        __A);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mul_sh (__m128h __A, __m128h __B)
+{
+  __A[0] *= __B[0];
+  return __A;
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_mul_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_mulsh_mask (__C, __D, __A, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_mul_sh (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_mulsh_mask (__B, __C, _mm_setzero_ph (), __A);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_div_sh (__m128h __A, __m128h __B)
+{
+  __A[0] /= __B[0];
+  return __A;
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_div_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_divsh_mask (__C, __D, __A, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_div_sh (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_divsh_mask (__B, __C, _mm_setzero_ph (),
+        __A);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_add_round_sh (__m128h __A, __m128h __B, const int __C)
+{
+  return __builtin_ia32_addsh_mask_round (__A, __B,
+       _mm_setzero_ph (),
+       (__mmask8) -1, __C);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_add_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
+         __m128h __D, const int __E)
+{
+  return __builtin_ia32_addsh_mask_round (__C, __D, __A, __B, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_add_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
+   const int __D)
+{
+  return __builtin_ia32_addsh_mask_round (__B, __C,
+       _mm_setzero_ph (),
+       __A, __D);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sub_round_sh (__m128h __A, __m128h __B, const int __C)
+{
+  return __builtin_ia32_subsh_mask_round (__A, __B,
+       _mm_setzero_ph (),
+       (__mmask8) -1, __C);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_sub_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
+         __m128h __D, const int __E)
+{
+  return __builtin_ia32_subsh_mask_round (__C, __D, __A, __B, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_sub_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
+   const int __D)
+{
+  return __builtin_ia32_subsh_mask_round (__B, __C,
+       _mm_setzero_ph (),
+       __A, __D);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mul_round_sh (__m128h __A, __m128h __B, const int __C)
+{
+  return __builtin_ia32_mulsh_mask_round (__A, __B,
+       _mm_setzero_ph (),
+       (__mmask8) -1, __C);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_mul_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
+         __m128h __D, const int __E)
+{
+  return __builtin_ia32_mulsh_mask_round (__C, __D, __A, __B, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_mul_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
+   const int __D)
+{
+  return __builtin_ia32_mulsh_mask_round (__B, __C,
+       _mm_setzero_ph (),
+       __A, __D);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_div_round_sh (__m128h __A, __m128h __B, const int __C)
+{
+  return __builtin_ia32_divsh_mask_round (__A, __B,
+       _mm_setzero_ph (),
+       (__mmask8) -1, __C);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_div_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
+         __m128h __D, const int __E)
+{
+  return __builtin_ia32_divsh_mask_round (__C, __D, __A, __B, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_div_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
+   const int __D)
+{
+  return __builtin_ia32_divsh_mask_round (__B, __C,
+       _mm_setzero_ph (),
+       __A, __D);
+}
+#else
+#define _mm_add_round_sh(A, B, C) ((__m128h)__builtin_ia32_addsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
+#define _mm_mask_add_round_sh(A, B, C, D, E) ((__m128h)__builtin_ia32_addsh_mask_round ((C), (D), (A), (B), (E)))
+#define _mm_maskz_add_round_sh(A, B, C, D) ((__m128h)__builtin_ia32_addsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
+#define _mm_sub_round_sh(A, B, C) ((__m128h)__builtin_ia32_subsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
+#define _mm_mask_sub_round_sh(A, B, C, D, E) ((__m128h)__builtin_ia32_subsh_mask_round ((C), (D), (A), (B), (E)))
+#define _mm_maskz_sub_round_sh(A, B, C, D) ((__m128h)__builtin_ia32_subsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
+#define _mm_mul_round_sh(A, B, C) ((__m128h)__builtin_ia32_mulsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
+#define _mm_mask_mul_round_sh(A, B, C, D, E) ((__m128h)__builtin_ia32_mulsh_mask_round ((C), (D), (A), (B), (E)))
+#define _mm_maskz_mul_round_sh(A, B, C, D) ((__m128h)__builtin_ia32_mulsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
+#define _mm_div_round_sh(A, B, C) ((__m128h)__builtin_ia32_divsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
+#define _mm_mask_div_round_sh(A, B, C, D, E) ((__m128h)__builtin_ia32_divsh_mask_round ((C), (D), (A), (B), (E)))
+#define _mm_maskz_div_round_sh(A, B, C, D) ((__m128h)__builtin_ia32_divsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
+#endif
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_max_sh (__m128h __A, __m128h __B)
+{
+  __A[0] = __A[0] > __B[0] ? __A[0] : __B[0];
+  return __A;
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_max_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_maxsh_mask (__C, __D, __A, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_max_sh (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_maxsh_mask (__B, __C, _mm_setzero_ph (),
+        __A);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_min_sh (__m128h __A, __m128h __B)
+{
+  __A[0] = __A[0] < __B[0] ? __A[0] : __B[0];
+  return __A;
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_min_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_minsh_mask (__C, __D, __A, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_min_sh (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_minsh_mask (__B, __C, _mm_setzero_ph (),
+        __A);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_max_round_sh (__m128h __A, __m128h __B, const int __C)
+{
+  return __builtin_ia32_maxsh_mask_round (__A, __B,
+       _mm_setzero_ph (),
+       (__mmask8) -1, __C);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_max_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
+         __m128h __D, const int __E)
+{
+  return __builtin_ia32_maxsh_mask_round (__C, __D, __A, __B, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_max_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
+   const int __D)
+{
+  return __builtin_ia32_maxsh_mask_round (__B, __C,
+       _mm_setzero_ph (),
+       __A, __D);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_min_round_sh (__m128h __A, __m128h __B, const int __C)
+{
+  return __builtin_ia32_minsh_mask_round (__A, __B,
+       _mm_setzero_ph (),
+       (__mmask8) -1, __C);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_min_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
+         __m128h __D, const int __E)
+{
+  return __builtin_ia32_minsh_mask_round (__C, __D, __A, __B, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_min_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
+   const int __D)
+{
+  return __builtin_ia32_minsh_mask_round (__B, __C,
+       _mm_setzero_ph (),
+       __A, __D);
+}
+#else
+#define _mm_max_round_sh(A, B, C) (__builtin_ia32_maxsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
+#define _mm_mask_max_round_sh(A, B, C, D, E) (__builtin_ia32_maxsh_mask_round ((C), (D), (A), (B), (E)))
+#define _mm_maskz_max_round_sh(A, B, C, D) (__builtin_ia32_maxsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
+#define _mm_min_round_sh(A, B, C) (__builtin_ia32_minsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
+#define _mm_mask_min_round_sh(A, B, C, D, E) (__builtin_ia32_minsh_mask_round ((C), (D), (A), (B), (E)))
+#define _mm_maskz_min_round_sh(A, B, C, D) (__builtin_ia32_minsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
+#endif
+#ifdef __OPTIMIZE__
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cmp_sh_mask (__m128h __A, __m128h __B, const int __C)
+{
+  return (__mmask8)
+    __builtin_ia32_cmpsh_mask_round (__A, __B,
+         __C, (__mmask8) -1,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cmp_sh_mask (__mmask8 __A, __m128h __B, __m128h __C,
+        const int __D)
+{
+  return (__mmask8)
+    __builtin_ia32_cmpsh_mask_round (__B, __C,
+         __D, __A,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cmp_round_sh_mask (__m128h __A, __m128h __B, const int __C,
+         const int __D)
+{
+  return (__mmask8) __builtin_ia32_cmpsh_mask_round (__A, __B,
+           __C, (__mmask8) -1,
+           __D);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cmp_round_sh_mask (__mmask8 __A, __m128h __B, __m128h __C,
+       const int __D, const int __E)
+{
+  return (__mmask8) __builtin_ia32_cmpsh_mask_round (__B, __C,
+           __D, __A,
+           __E);
+}
+#else
+#define _mm_cmp_sh_mask(A, B, C) (__builtin_ia32_cmpsh_mask_round ((A), (B), (C), (-1), (_MM_FROUND_CUR_DIRECTION)))
+#define _mm_mask_cmp_sh_mask(A, B, C, D) (__builtin_ia32_cmpsh_mask_round ((B), (C), (D), (A), (_MM_FROUND_CUR_DIRECTION)))
+#define _mm_cmp_round_sh_mask(A, B, C, D) (__builtin_ia32_cmpsh_mask_round ((A), (B), (C), (-1), (D)))
+#define _mm_mask_cmp_round_sh_mask(A, B, C, D, E) (__builtin_ia32_cmpsh_mask_round ((B), (C), (D), (A), (E)))
+#endif
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_comieq_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_EQ_OS,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_comilt_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_LT_OS,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_comile_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_LE_OS,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_comigt_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_GT_OS,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_comige_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_GE_OS,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_comineq_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_NEQ_US,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_ucomieq_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_EQ_OQ,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_ucomilt_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_LT_OQ,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_ucomile_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_LE_OQ,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_ucomigt_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_GT_OQ,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_ucomige_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_GE_OQ,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_ucomineq_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_NEQ_UQ,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_comi_sh (__m128h __A, __m128h __B, const int __P)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, __P,
+       (__mmask8) -1,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_comi_round_sh (__m128h __A, __m128h __B, const int __P, const int __R)
+{
+  return __builtin_ia32_cmpsh_mask_round (__A, __B, __P,
+       (__mmask8) -1,__R);
+}
+#else
+#define _mm_comi_round_sh(A, B, P, R) (__builtin_ia32_cmpsh_mask_round ((A), (B), (P), (__mmask8) (-1), (R)))
+#define _mm_comi_sh(A, B, P) (__builtin_ia32_cmpsh_mask_round ((A), (B), (P), (__mmask8) (-1), _MM_FROUND_CUR_DIRECTION))
+#endif
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sqrt_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_sqrtsh_mask_round (__B, __A,
+        _mm_setzero_ph (),
+        (__mmask8) -1,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_sqrt_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_sqrtsh_mask_round (__D, __C, __A, __B,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_sqrt_sh (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_sqrtsh_mask_round (__C, __B,
+        _mm_setzero_ph (),
+        __A, _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sqrt_round_sh (__m128h __A, __m128h __B, const int __C)
+{
+  return __builtin_ia32_sqrtsh_mask_round (__B, __A,
+        _mm_setzero_ph (),
+        (__mmask8) -1, __C);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_sqrt_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
+   __m128h __D, const int __E)
+{
+  return __builtin_ia32_sqrtsh_mask_round (__D, __C, __A, __B,
+        __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_sqrt_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
+    const int __D)
+{
+  return __builtin_ia32_sqrtsh_mask_round (__C, __B,
+        _mm_setzero_ph (),
+        __A, __D);
+}
+#else
+#define _mm_sqrt_round_sh(A, B, C) (__builtin_ia32_sqrtsh_mask_round ((B), (A), _mm_setzero_ph (), (__mmask8)-1, (C)))
+#define _mm_mask_sqrt_round_sh(A, B, C, D, E) (__builtin_ia32_sqrtsh_mask_round ((D), (C), (A), (B), (E)))
+#define _mm_maskz_sqrt_round_sh(A, B, C, D) (__builtin_ia32_sqrtsh_mask_round ((C), (B), _mm_setzero_ph (), (A), (D)))
+#endif
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_rsqrt_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_rsqrtsh_mask (__B, __A, _mm_setzero_ph (),
+          (__mmask8) -1);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_rsqrt_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_rsqrtsh_mask (__D, __C, __A, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_rsqrt_sh (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_rsqrtsh_mask (__C, __B, _mm_setzero_ph (),
+          __A);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_rcp_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_rcpsh_mask (__B, __A, _mm_setzero_ph (),
+        (__mmask8) -1);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_rcp_sh (__m128h __A, __mmask32 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_rcpsh_mask (__D, __C, __A, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_rcp_sh (__mmask32 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_rcpsh_mask (__C, __B, _mm_setzero_ph (),
+        __A);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_scalef_sh (__m128h __A, __m128h __B)
+{
+  return __builtin_ia32_scalefsh_mask_round (__A, __B,
+          _mm_setzero_ph (),
+          (__mmask8) -1,
+          _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_scalef_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_scalefsh_mask_round (__C, __D, __A, __B,
+          _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_scalef_sh (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_scalefsh_mask_round (__B, __C,
+          _mm_setzero_ph (),
+          __A,
+          _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_scalef_round_sh (__m128h __A, __m128h __B, const int __C)
+{
+  return __builtin_ia32_scalefsh_mask_round (__A, __B,
+          _mm_setzero_ph (),
+          (__mmask8) -1, __C);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_scalef_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
+     __m128h __D, const int __E)
+{
+  return __builtin_ia32_scalefsh_mask_round (__C, __D, __A, __B,
+          __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_scalef_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
+      const int __D)
+{
+  return __builtin_ia32_scalefsh_mask_round (__B, __C,
+          _mm_setzero_ph (),
+          __A, __D);
+}
+#else
+#define _mm_scalef_round_sh(A, B, C) (__builtin_ia32_scalefsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
+#define _mm_mask_scalef_round_sh(A, B, C, D, E) (__builtin_ia32_scalefsh_mask_round ((C), (D), (A), (B), (E)))
+#define _mm_maskz_scalef_round_sh(A, B, C, D) (__builtin_ia32_scalefsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
+#endif
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_sh (__m128h __A, __m128h __B, int __C)
+{
+  return __builtin_ia32_reducesh_mask_round (__A, __B, __C,
+          _mm_setzero_ph (),
+          (__mmask8) -1,
+          _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_sh (__m128h __A, __mmask8 __B, __m128h __C,
+      __m128h __D, int __E)
+{
+  return __builtin_ia32_reducesh_mask_round (__C, __D, __E, __A, __B,
+          _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_reduce_sh (__mmask8 __A, __m128h __B, __m128h __C, int __D)
+{
+  return __builtin_ia32_reducesh_mask_round (__B, __C, __D,
+          _mm_setzero_ph (), __A,
+          _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_reduce_round_sh (__m128h __A, __m128h __B, int __C, const int __D)
+{
+  return __builtin_ia32_reducesh_mask_round (__A, __B, __C,
+          _mm_setzero_ph (),
+          (__mmask8) -1, __D);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
+     __m128h __D, int __E, const int __F)
+{
+  return __builtin_ia32_reducesh_mask_round (__C, __D, __E, __A,
+          __B, __F);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_reduce_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
+      int __D, const int __E)
+{
+  return __builtin_ia32_reducesh_mask_round (__B, __C, __D,
+          _mm_setzero_ph (),
+          __A, __E);
+}
+#else
+#define _mm_reduce_sh(A, B, C) (__builtin_ia32_reducesh_mask_round ((A), (B), (C), _mm_setzero_ph (), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_reduce_sh(A, B, C, D, E) (__builtin_ia32_reducesh_mask_round ((C), (D), (E), (A), (B), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_reduce_sh(A, B, C, D) (__builtin_ia32_reducesh_mask_round ((B), (C), (D), _mm_setzero_ph (), (A), _MM_FROUND_CUR_DIRECTION))
+#define _mm_reduce_round_sh(A, B, C, D) (__builtin_ia32_reducesh_mask_round ((A), (B), (C), _mm_setzero_ph (), (__mmask8)-1, (D)))
+#define _mm_mask_reduce_round_sh(A, B, C, D, E, F) (__builtin_ia32_reducesh_mask_round ((C), (D), (E), (A), (B), (F)))
+#define _mm_maskz_reduce_round_sh(A, B, C, D, E) (__builtin_ia32_reducesh_mask_round ((B), (C), (D), _mm_setzero_ph (), (A), (E)))
+#endif
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_roundscale_sh (__m128h __A, __m128h __B, int __C)
+{
+  return __builtin_ia32_rndscalesh_mask_round (__A, __B, __C,
+            _mm_setzero_ph (),
+            (__mmask8) -1,
+            _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_roundscale_sh (__m128h __A, __mmask8 __B, __m128h __C,
+   __m128h __D, int __E)
+{
+  return __builtin_ia32_rndscalesh_mask_round (__C, __D, __E, __A, __B,
+            _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_roundscale_sh (__mmask8 __A, __m128h __B, __m128h __C, int __D)
+{
+  return __builtin_ia32_rndscalesh_mask_round (__B, __C, __D,
+            _mm_setzero_ph (), __A,
+            _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_roundscale_round_sh (__m128h __A, __m128h __B, int __C, const int __D)
+{
+  return __builtin_ia32_rndscalesh_mask_round (__A, __B, __C,
+            _mm_setzero_ph (),
+            (__mmask8) -1,
+            __D);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_roundscale_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
+         __m128h __D, int __E, const int __F)
+{
+  return __builtin_ia32_rndscalesh_mask_round (__C, __D, __E,
+            __A, __B, __F);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_roundscale_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
+          int __D, const int __E)
+{
+  return __builtin_ia32_rndscalesh_mask_round (__B, __C, __D,
+            _mm_setzero_ph (),
+            __A, __E);
+}
+#else
+#define _mm_roundscale_sh(A, B, C) (__builtin_ia32_rndscalesh_mask_round ((A), (B), (C), _mm_setzero_ph (), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_roundscale_sh(A, B, C, D, E) (__builtin_ia32_rndscalesh_mask_round ((C), (D), (E), (A), (B), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_roundscale_sh(A, B, C, D) (__builtin_ia32_rndscalesh_mask_round ((B), (C), (D), _mm_setzero_ph (), (A), _MM_FROUND_CUR_DIRECTION))
+#define _mm_roundscale_round_sh(A, B, C, D) (__builtin_ia32_rndscalesh_mask_round ((A), (B), (C), _mm_setzero_ph (), (__mmask8)-1, (D)))
+#define _mm_mask_roundscale_round_sh(A, B, C, D, E, F) (__builtin_ia32_rndscalesh_mask_round ((C), (D), (E), (A), (B), (F)))
+#define _mm_maskz_roundscale_round_sh(A, B, C, D, E) (__builtin_ia32_rndscalesh_mask_round ((B), (C), (D), _mm_setzero_ph (), (A), (E)))
+#endif
+#ifdef __OPTIMIZE__
+extern __inline __mmask8
+  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fpclass_sh_mask (__m128h __A, const int __imm)
+{
+  return (__mmask8) __builtin_ia32_fpclasssh_mask ((__v8hf) __A, __imm,
+         (__mmask8) -1);
+}
+extern __inline __mmask8
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fpclass_sh_mask (__mmask8 __U, __m128h __A, const int __imm)
+{
+  return (__mmask8) __builtin_ia32_fpclasssh_mask ((__v8hf) __A, __imm, __U);
+}
+#else
+#define _mm_fpclass_sh_mask(X, C) ((__mmask8) __builtin_ia32_fpclasssh_mask ((__v8hf) (__m128h) (X), (int) (C), (__mmask8) (-1)))
+#define _mm_mask_fpclass_sh_mask(U, X, C) ((__mmask8) __builtin_ia32_fpclasssh_mask ((__v8hf) (__m128h) (X), (int) (C), (__mmask8) (U)))
+#endif
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getexp_sh (__m128h __A, __m128h __B)
+{
+  return (__m128h)
+    __builtin_ia32_getexpsh_mask_round ((__v8hf) __A, (__v8hf) __B,
+     (__v8hf) _mm_setzero_ph (),
+     (__mmask8) -1,
+     _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getexp_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B)
+{
+  return (__m128h)
+    __builtin_ia32_getexpsh_mask_round ((__v8hf) __A, (__v8hf) __B,
+     (__v8hf) __W, (__mmask8) __U,
+     _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getexp_sh (__mmask8 __U, __m128h __A, __m128h __B)
+{
+  return (__m128h)
+    __builtin_ia32_getexpsh_mask_round ((__v8hf) __A, (__v8hf) __B,
+     (__v8hf) _mm_setzero_ph (),
+     (__mmask8) __U,
+     _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getexp_round_sh (__m128h __A, __m128h __B, const int __R)
+{
+  return (__m128h) __builtin_ia32_getexpsh_mask_round ((__v8hf) __A,
+             (__v8hf) __B,
+             _mm_setzero_ph (),
+             (__mmask8) -1,
+             __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getexp_round_sh (__m128h __W, __mmask8 __U, __m128h __A,
+     __m128h __B, const int __R)
+{
+  return (__m128h) __builtin_ia32_getexpsh_mask_round ((__v8hf) __A,
+             (__v8hf) __B,
+             (__v8hf) __W,
+             (__mmask8) __U, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getexp_round_sh (__mmask8 __U, __m128h __A, __m128h __B,
+      const int __R)
+{
+  return (__m128h) __builtin_ia32_getexpsh_mask_round ((__v8hf) __A,
+             (__v8hf) __B,
+             (__v8hf)
+             _mm_setzero_ph (),
+             (__mmask8) __U, __R);
+}
+#else
+#define _mm_getexp_round_sh(A, B, R) ((__m128h)__builtin_ia32_getexpsh_mask_round((__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), (__mmask8)-1, R))
+#define _mm_mask_getexp_round_sh(W, U, A, B, C) (__m128h)__builtin_ia32_getexpsh_mask_round(A, B, W, U, C)
+#define _mm_maskz_getexp_round_sh(U, A, B, C) (__m128h)__builtin_ia32_getexpsh_mask_round(A, B, (__v8hf)_mm_setzero_ph(), U, C)
+#endif
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getmant_sh (__m128h __A, __m128h __B,
+  _MM_MANTISSA_NORM_ENUM __C,
+  _MM_MANTISSA_SIGN_ENUM __D)
+{
+  return (__m128h)
+    __builtin_ia32_getmantsh_mask_round ((__v8hf) __A, (__v8hf) __B,
+      (__D << 2) | __C, _mm_setzero_ph (),
+      (__mmask8) -1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getmant_sh (__m128h __W, __mmask8 __U, __m128h __A,
+       __m128h __B, _MM_MANTISSA_NORM_ENUM __C,
+       _MM_MANTISSA_SIGN_ENUM __D)
+{
+  return (__m128h)
+    __builtin_ia32_getmantsh_mask_round ((__v8hf) __A, (__v8hf) __B,
+      (__D << 2) | __C, (__v8hf) __W,
+      __U, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getmant_sh (__mmask8 __U, __m128h __A, __m128h __B,
+        _MM_MANTISSA_NORM_ENUM __C,
+        _MM_MANTISSA_SIGN_ENUM __D)
+{
+  return (__m128h)
+    __builtin_ia32_getmantsh_mask_round ((__v8hf) __A, (__v8hf) __B,
+      (__D << 2) | __C,
+      (__v8hf) _mm_setzero_ph(),
+      __U, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_getmant_round_sh (__m128h __A, __m128h __B,
+        _MM_MANTISSA_NORM_ENUM __C,
+        _MM_MANTISSA_SIGN_ENUM __D, const int __R)
+{
+  return (__m128h) __builtin_ia32_getmantsh_mask_round ((__v8hf) __A,
+       (__v8hf) __B,
+       (__D << 2) | __C,
+       _mm_setzero_ph (),
+       (__mmask8) -1,
+       __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_getmant_round_sh (__m128h __W, __mmask8 __U, __m128h __A,
+      __m128h __B, _MM_MANTISSA_NORM_ENUM __C,
+      _MM_MANTISSA_SIGN_ENUM __D, const int __R)
+{
+  return (__m128h) __builtin_ia32_getmantsh_mask_round ((__v8hf) __A,
+       (__v8hf) __B,
+       (__D << 2) | __C,
+       (__v8hf) __W,
+       __U, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_getmant_round_sh (__mmask8 __U, __m128h __A, __m128h __B,
+       _MM_MANTISSA_NORM_ENUM __C,
+       _MM_MANTISSA_SIGN_ENUM __D, const int __R)
+{
+  return (__m128h) __builtin_ia32_getmantsh_mask_round ((__v8hf) __A,
+       (__v8hf) __B,
+       (__D << 2) | __C,
+       (__v8hf)
+       _mm_setzero_ph(),
+       __U, __R);
+}
+#else
+#define _mm_getmant_sh(X, Y, C, D) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h) _mm_setzero_ph (), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
+#define _mm_mask_getmant_sh(W, U, X, Y, C, D) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_maskz_getmant_sh(U, X, Y, C, D) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h) _mm_setzero_ph(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+#define _mm_getmant_round_sh(X, Y, C, D, R) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h) _mm_setzero_ph (), (__mmask8)-1, (R)))
+#define _mm_mask_getmant_round_sh(W, U, X, Y, C, D, R) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h)(W), (__mmask8)(U), (R)))
+#define _mm_maskz_getmant_round_sh(U, X, Y, C, D, R) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h) _mm_setzero_ph(), (__mmask8)(U), (R)))
+#endif
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsi16_si128 (short __A)
+{
+  return _mm_avx512_set_epi16 (0, 0, 0, 0, 0, 0, 0, __A);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsi128_si16 (__m128i __A)
+{
+  return __builtin_ia32_vec_ext_v8hi ((__v8hi)__A, 0);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_load_sh (__m128h __A, __mmask8 __B, _Float16 const* __C)
+{
+  return __builtin_ia32_loadsh_mask (__C, __A, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_load_sh (__mmask8 __A, _Float16 const* __B)
+{
+  return __builtin_ia32_loadsh_mask (__B, _mm_setzero_ph (), __A);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_store_sh (_Float16 const* __A, __mmask8 __B, __m128h __C)
+{
+  __builtin_ia32_storesh_mask (__A, __C, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_move_sh (__m128h __A, __m128h __B)
+{
+  __A[0] = __B[0];
+  return __A;
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_move_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return __builtin_ia32_vmovsh_mask (__C, __D, __A, __B);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_move_sh (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return __builtin_ia32_vmovsh_mask (__B, __C, _mm_setzero_ph (), __A);
+}
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsh_i32 (__m128h __A)
+{
+  return (int) __builtin_ia32_vcvtsh2si32_round (__A, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsh_u32 (__m128h __A)
+{
+  return (int) __builtin_ia32_vcvtsh2usi32_round (__A,
+        _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsh_i32 (__m128h __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvtsh2si32_round (__A, __R);
+}
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsh_u32 (__m128h __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvtsh2usi32_round (__A, __R);
+}
+#else
+#define _mm_cvt_roundsh_i32(A, B) ((int)__builtin_ia32_vcvtsh2si32_round ((A), (B)))
+#define _mm_cvt_roundsh_u32(A, B) ((int)__builtin_ia32_vcvtsh2usi32_round ((A), (B)))
+#endif
+#ifdef __x86_64__
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsh_i64 (__m128h __A)
+{
+  return (long long)
+    __builtin_ia32_vcvtsh2si64_round (__A, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsh_u64 (__m128h __A)
+{
+  return (long long)
+    __builtin_ia32_vcvtsh2usi64_round (__A, _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsh_i64 (__m128h __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvtsh2si64_round (__A, __R);
+}
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsh_u64 (__m128h __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvtsh2usi64_round (__A, __R);
+}
+#else
+#define _mm_cvt_roundsh_i64(A, B) ((long long)__builtin_ia32_vcvtsh2si64_round ((A), (B)))
+#define _mm_cvt_roundsh_u64(A, B) ((long long)__builtin_ia32_vcvtsh2usi64_round ((A), (B)))
+#endif
+#endif
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvti32_sh (__m128h __A, int __B)
+{
+  return __builtin_ia32_vcvtsi2sh32_round (__A, __B, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtu32_sh (__m128h __A, unsigned int __B)
+{
+  return __builtin_ia32_vcvtusi2sh32_round (__A, __B, _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundi32_sh (__m128h __A, int __B, const int __R)
+{
+  return __builtin_ia32_vcvtsi2sh32_round (__A, __B, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundu32_sh (__m128h __A, unsigned int __B, const int __R)
+{
+  return __builtin_ia32_vcvtusi2sh32_round (__A, __B, __R);
+}
+#else
+#define _mm_cvt_roundi32_sh(A, B, C) (__builtin_ia32_vcvtsi2sh32_round ((A), (B), (C)))
+#define _mm_cvt_roundu32_sh(A, B, C) (__builtin_ia32_vcvtusi2sh32_round ((A), (B), (C)))
+#endif
+#ifdef __x86_64__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvti64_sh (__m128h __A, long long __B)
+{
+  return __builtin_ia32_vcvtsi2sh64_round (__A, __B, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtu64_sh (__m128h __A, unsigned long long __B)
+{
+  return __builtin_ia32_vcvtusi2sh64_round (__A, __B, _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundi64_sh (__m128h __A, long long __B, const int __R)
+{
+  return __builtin_ia32_vcvtsi2sh64_round (__A, __B, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundu64_sh (__m128h __A, unsigned long long __B, const int __R)
+{
+  return __builtin_ia32_vcvtusi2sh64_round (__A, __B, __R);
+}
+#else
+#define _mm_cvt_roundi64_sh(A, B, C) (__builtin_ia32_vcvtsi2sh64_round ((A), (B), (C)))
+#define _mm_cvt_roundu64_sh(A, B, C) (__builtin_ia32_vcvtusi2sh64_round ((A), (B), (C)))
+#endif
+#endif
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttsh_i32 (__m128h __A)
+{
+  return (int)
+    __builtin_ia32_vcvttsh2si32_round (__A, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttsh_u32 (__m128h __A)
+{
+  return (int)
+    __builtin_ia32_vcvttsh2usi32_round (__A, _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundsh_i32 (__m128h __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvttsh2si32_round (__A, __R);
+}
+extern __inline unsigned
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundsh_u32 (__m128h __A, const int __R)
+{
+  return (int) __builtin_ia32_vcvttsh2usi32_round (__A, __R);
+}
+#else
+#define _mm_cvtt_roundsh_i32(A, B) ((int)__builtin_ia32_vcvttsh2si32_round ((A), (B)))
+#define _mm_cvtt_roundsh_u32(A, B) ((int)__builtin_ia32_vcvttsh2usi32_round ((A), (B)))
+#endif
+#ifdef __x86_64__
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttsh_i64 (__m128h __A)
+{
+  return (long long)
+    __builtin_ia32_vcvttsh2si64_round (__A, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvttsh_u64 (__m128h __A)
+{
+  return (long long)
+    __builtin_ia32_vcvttsh2usi64_round (__A, _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundsh_i64 (__m128h __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvttsh2si64_round (__A, __R);
+}
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtt_roundsh_u64 (__m128h __A, const int __R)
+{
+  return (long long) __builtin_ia32_vcvttsh2usi64_round (__A, __R);
+}
+#else
+#define _mm_cvtt_roundsh_i64(A, B) ((long long)__builtin_ia32_vcvttsh2si64_round ((A), (B)))
+#define _mm_cvtt_roundsh_u64(A, B) ((long long)__builtin_ia32_vcvttsh2usi64_round ((A), (B)))
+#endif
+#endif
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsh_ss (__m128 __A, __m128h __B)
+{
+  return __builtin_ia32_vcvtsh2ss_mask_round (__B, __A,
+           _mm_avx512_setzero_ps (),
+           (__mmask8) -1,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cvtsh_ss (__m128 __A, __mmask8 __B, __m128 __C,
+    __m128h __D)
+{
+  return __builtin_ia32_vcvtsh2ss_mask_round (__D, __C, __A, __B,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_cvtsh_ss (__mmask8 __A, __m128 __B,
+     __m128h __C)
+{
+  return __builtin_ia32_vcvtsh2ss_mask_round (__C, __B,
+           _mm_avx512_setzero_ps (),
+           __A, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsh_sd (__m128d __A, __m128h __B)
+{
+  return __builtin_ia32_vcvtsh2sd_mask_round (__B, __A,
+           _mm_avx512_setzero_pd (),
+           (__mmask8) -1,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cvtsh_sd (__m128d __A, __mmask8 __B, __m128d __C,
+    __m128h __D)
+{
+  return __builtin_ia32_vcvtsh2sd_mask_round (__D, __C, __A, __B,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_cvtsh_sd (__mmask8 __A, __m128d __B, __m128h __C)
+{
+  return __builtin_ia32_vcvtsh2sd_mask_round (__C, __B,
+           _mm_avx512_setzero_pd (),
+           __A, _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsh_ss (__m128 __A, __m128h __B, const int __R)
+{
+  return __builtin_ia32_vcvtsh2ss_mask_round (__B, __A,
+           _mm_avx512_setzero_ps (),
+           (__mmask8) -1, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cvt_roundsh_ss (__m128 __A, __mmask8 __B, __m128 __C,
+    __m128h __D, const int __R)
+{
+  return __builtin_ia32_vcvtsh2ss_mask_round (__D, __C, __A, __B, __R);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_cvt_roundsh_ss (__mmask8 __A, __m128 __B,
+     __m128h __C, const int __R)
+{
+  return __builtin_ia32_vcvtsh2ss_mask_round (__C, __B,
+           _mm_avx512_setzero_ps (),
+           __A, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsh_sd (__m128d __A, __m128h __B, const int __R)
+{
+  return __builtin_ia32_vcvtsh2sd_mask_round (__B, __A,
+           _mm_avx512_setzero_pd (),
+           (__mmask8) -1, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cvt_roundsh_sd (__m128d __A, __mmask8 __B, __m128d __C,
+    __m128h __D, const int __R)
+{
+  return __builtin_ia32_vcvtsh2sd_mask_round (__D, __C, __A, __B, __R);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_cvt_roundsh_sd (__mmask8 __A, __m128d __B, __m128h __C, const int __R)
+{
+  return __builtin_ia32_vcvtsh2sd_mask_round (__C, __B,
+           _mm_avx512_setzero_pd (),
+           __A, __R);
+}
+#else
+#define _mm_cvt_roundsh_ss(A, B, R) (__builtin_ia32_vcvtsh2ss_mask_round ((B), (A), _mm_avx512_setzero_ps (), (__mmask8) -1, (R)))
+#define _mm_mask_cvt_roundsh_ss(A, B, C, D, R) (__builtin_ia32_vcvtsh2ss_mask_round ((D), (C), (A), (B), (R)))
+#define _mm_maskz_cvt_roundsh_ss(A, B, C, R) (__builtin_ia32_vcvtsh2ss_mask_round ((C), (B), _mm_avx512_setzero_ps (), (A), (R)))
+#define _mm_cvt_roundsh_sd(A, B, R) (__builtin_ia32_vcvtsh2sd_mask_round ((B), (A), _mm_avx512_setzero_pd (), (__mmask8) -1, (R)))
+#define _mm_mask_cvt_roundsh_sd(A, B, C, D, R) (__builtin_ia32_vcvtsh2sd_mask_round ((D), (C), (A), (B), (R)))
+#define _mm_maskz_cvt_roundsh_sd(A, B, C, R) (__builtin_ia32_vcvtsh2sd_mask_round ((C), (B), _mm_avx512_setzero_pd (), (A), (R)))
+#endif
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtss_sh (__m128h __A, __m128 __B)
+{
+  return __builtin_ia32_vcvtss2sh_mask_round (__B, __A,
+           _mm_setzero_ph (),
+           (__mmask8) -1,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cvtss_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128 __D)
+{
+  return __builtin_ia32_vcvtss2sh_mask_round (__D, __C, __A, __B,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_cvtss_sh (__mmask8 __A, __m128h __B, __m128 __C)
+{
+  return __builtin_ia32_vcvtss2sh_mask_round (__C, __B,
+           _mm_setzero_ph (),
+           __A, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsd_sh (__m128h __A, __m128d __B)
+{
+  return __builtin_ia32_vcvtsd2sh_mask_round (__B, __A,
+           _mm_setzero_ph (),
+           (__mmask8) -1,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cvtsd_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128d __D)
+{
+  return __builtin_ia32_vcvtsd2sh_mask_round (__D, __C, __A, __B,
+           _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_cvtsd_sh (__mmask8 __A, __m128h __B, __m128d __C)
+{
+  return __builtin_ia32_vcvtsd2sh_mask_round (__C, __B,
+           _mm_setzero_ph (),
+           __A, _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundss_sh (__m128h __A, __m128 __B, const int __R)
+{
+  return __builtin_ia32_vcvtss2sh_mask_round (__B, __A,
+           _mm_setzero_ph (),
+           (__mmask8) -1, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cvt_roundss_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128 __D,
+    const int __R)
+{
+  return __builtin_ia32_vcvtss2sh_mask_round (__D, __C, __A, __B, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_cvt_roundss_sh (__mmask8 __A, __m128h __B, __m128 __C,
+     const int __R)
+{
+  return __builtin_ia32_vcvtss2sh_mask_round (__C, __B,
+           _mm_setzero_ph (),
+           __A, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvt_roundsd_sh (__m128h __A, __m128d __B, const int __R)
+{
+  return __builtin_ia32_vcvtsd2sh_mask_round (__B, __A,
+           _mm_setzero_ph (),
+           (__mmask8) -1, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_cvt_roundsd_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128d __D,
+    const int __R)
+{
+  return __builtin_ia32_vcvtsd2sh_mask_round (__D, __C, __A, __B, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_cvt_roundsd_sh (__mmask8 __A, __m128h __B, __m128d __C,
+     const int __R)
+{
+  return __builtin_ia32_vcvtsd2sh_mask_round (__C, __B,
+           _mm_setzero_ph (),
+           __A, __R);
+}
+#else
+#define _mm_cvt_roundss_sh(A, B, R) (__builtin_ia32_vcvtss2sh_mask_round ((B), (A), _mm_setzero_ph (), (__mmask8) -1, R))
+#define _mm_mask_cvt_roundss_sh(A, B, C, D, R) (__builtin_ia32_vcvtss2sh_mask_round ((D), (C), (A), (B), (R)))
+#define _mm_maskz_cvt_roundss_sh(A, B, C, R) (__builtin_ia32_vcvtss2sh_mask_round ((C), (B), _mm_setzero_ph (), A, R))
+#define _mm_cvt_roundsd_sh(A, B, R) (__builtin_ia32_vcvtsd2sh_mask_round ((B), (A), _mm_setzero_ph (), (__mmask8) -1, R))
+#define _mm_mask_cvt_roundsd_sh(A, B, C, D, R) (__builtin_ia32_vcvtsd2sh_mask_round ((D), (C), (A), (B), (R)))
+#define _mm_maskz_cvt_roundsd_sh(A, B, C, R) (__builtin_ia32_vcvtsd2sh_mask_round ((C), (B), _mm_setzero_ph (), (A), (R)))
+#endif
+extern __inline _Float16
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtsh_h (__m128h __A)
+{
+  return __A[0];
+}
+extern __inline __m128h
+  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmadd_sh (__m128h __W, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        (__v8hf) __A,
+        (__v8hf) __B,
+        (__mmask8) -1,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmadd_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        (__v8hf) __A,
+        (__v8hf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmadd_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask3 ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmadd_sh (__mmask8 __U, __m128h __W, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmadd_round_sh (__m128h __W, __m128h __A, __m128h __B, const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        (__v8hf) __A,
+        (__v8hf) __B,
+        (__mmask8) -1,
+        __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmadd_round_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B,
+    const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        (__v8hf) __A,
+        (__v8hf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmadd_round_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask3 ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmadd_round_sh (__mmask8 __U, __m128h __W, __m128h __A,
+     __m128h __B, const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U, __R);
+}
+#else
+#define _mm_fmadd_round_sh(A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), (B), (C), (-1), (R)))
+#define _mm_mask_fmadd_round_sh(A, U, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), (B), (C), (U), (R)))
+#define _mm_mask3_fmadd_round_sh(A, B, C, U, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask3 ((A), (B), (C), (U), (R)))
+#define _mm_maskz_fmadd_round_sh(U, A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_maskz ((A), (B), (C), (U), (R)))
+#endif
+extern __inline __m128h
+  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fnmadd_sh (__m128h __W, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfnmaddsh3_mask ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) -1,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmadd_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfnmaddsh3_mask ((__v8hf) __W,
+        (__v8hf) __A,
+        (__v8hf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmadd_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U)
+{
+  return (__m128h) __builtin_ia32_vfnmaddsh3_mask3 ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmadd_sh (__mmask8 __U, __m128h __W, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfnmaddsh3_maskz ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fnmadd_round_sh (__m128h __W, __m128h __A, __m128h __B, const int __R)
+{
+  return (__m128h) __builtin_ia32_vfnmaddsh3_mask ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) -1,
+         __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmadd_round_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B,
+    const int __R)
+{
+  return (__m128h) __builtin_ia32_vfnmaddsh3_mask ((__v8hf) __W,
+        (__v8hf) __A,
+        (__v8hf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmadd_round_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128h) __builtin_ia32_vfnmaddsh3_mask3 ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmadd_round_sh (__mmask8 __U, __m128h __W, __m128h __A,
+     __m128h __B, const int __R)
+{
+  return (__m128h) __builtin_ia32_vfnmaddsh3_maskz ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U, __R);
+}
+#else
+#define _mm_fnmadd_round_sh(A, B, C, R) ((__m128h) __builtin_ia32_vfnmaddsh3_mask ((A), (B), (C), (-1), (R)))
+#define _mm_mask_fnmadd_round_sh(A, U, B, C, R) ((__m128h) __builtin_ia32_vfnmaddsh3_mask ((A), (B), (C), (U), (R)))
+#define _mm_mask3_fnmadd_round_sh(A, B, C, U, R) ((__m128h) __builtin_ia32_vfnmaddsh3_mask3 ((A), (B), (C), (U), (R)))
+#define _mm_maskz_fnmadd_round_sh(U, A, B, C, R) ((__m128h) __builtin_ia32_vfnmaddsh3_maskz ((A), (B), (C), (U), (R)))
+#endif
+extern __inline __m128h
+  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmsub_sh (__m128h __W, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        (__v8hf) __A,
+        -(__v8hf) __B,
+        (__mmask8) -1,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmsub_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        (__v8hf) __A,
+        -(__v8hf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmsub_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U)
+{
+  return (__m128h) __builtin_ia32_vfmsubsh3_mask3 ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmsub_sh (__mmask8 __U, __m128h __W, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
+         (__v8hf) __A,
+         -(__v8hf) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmsub_round_sh (__m128h __W, __m128h __A, __m128h __B, const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        (__v8hf) __A,
+        -(__v8hf) __B,
+        (__mmask8) -1,
+        __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmsub_round_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B,
+    const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        (__v8hf) __A,
+        -(__v8hf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmsub_round_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmsubsh3_mask3 ((__v8hf) __W,
+         (__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmsub_round_sh (__mmask8 __U, __m128h __W, __m128h __A,
+     __m128h __B, const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
+         (__v8hf) __A,
+         -(__v8hf) __B,
+         (__mmask8) __U, __R);
+}
+#else
+#define _mm_fmsub_round_sh(A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), (B), -(C), (-1), (R)))
+#define _mm_mask_fmsub_round_sh(A, U, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), (B), -(C), (U), (R)))
+#define _mm_mask3_fmsub_round_sh(A, B, C, U, R) ((__m128h) __builtin_ia32_vfmsubsh3_mask3 ((A), (B), (C), (U), (R)))
+#define _mm_maskz_fmsub_round_sh(U, A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_maskz ((A), (B), -(C), (U), (R)))
+#endif
+extern __inline __m128h
+  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fnmsub_sh (__m128h __W, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        -(__v8hf) __A,
+        -(__v8hf) __B,
+        (__mmask8) -1,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmsub_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        -(__v8hf) __A,
+        -(__v8hf) __B,
+        (__mmask8) __U,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmsub_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U)
+{
+  return (__m128h) __builtin_ia32_vfmsubsh3_mask3 ((__v8hf) __W,
+         -(__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmsub_sh (__mmask8 __U, __m128h __W, __m128h __A, __m128h __B)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
+         -(__v8hf) __A,
+         -(__v8hf) __B,
+         (__mmask8) __U,
+         _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fnmsub_round_sh (__m128h __W, __m128h __A, __m128h __B, const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        -(__v8hf) __A,
+        -(__v8hf) __B,
+        (__mmask8) -1,
+        __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fnmsub_round_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B,
+    const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
+        -(__v8hf) __A,
+        -(__v8hf) __B,
+        (__mmask8) __U, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fnmsub_round_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U,
+     const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmsubsh3_mask3 ((__v8hf) __W,
+         -(__v8hf) __A,
+         (__v8hf) __B,
+         (__mmask8) __U, __R);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fnmsub_round_sh (__mmask8 __U, __m128h __W, __m128h __A,
+     __m128h __B, const int __R)
+{
+  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
+         -(__v8hf) __A,
+         -(__v8hf) __B,
+         (__mmask8) __U, __R);
+}
+#else
+#define _mm_fnmsub_round_sh(A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), -(B), -(C), (-1), (R)))
+#define _mm_mask_fnmsub_round_sh(A, U, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), -(B), -(C), (U), (R)))
+#define _mm_mask3_fnmsub_round_sh(A, B, C, U, R) ((__m128h) __builtin_ia32_vfmsubsh3_mask3 ((A), -(B), (C), (U), (R)))
+#define _mm_maskz_fnmsub_round_sh(U, A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_maskz ((A), -(B), -(C), (U), (R)))
+#endif
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fcmadd_sch (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmaddcsh_mask_round ((__v8hf) __A,
+       (__v8hf) __C,
+       (__v8hf) __D, __B,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fcmadd_sch (__m128h __A, __m128h __B, __m128h __C, __mmask8 __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmaddcsh_mask3_round ((__v8hf) __A,
+        (__v8hf) __B,
+        (__v8hf) __C, __D,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fcmadd_sch (__mmask8 __A, __m128h __B, __m128h __C, __m128h __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmaddcsh_maskz_round ((__v8hf) __B,
+        (__v8hf) __C,
+        (__v8hf) __D,
+        __A, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fcmadd_sch (__m128h __A, __m128h __B, __m128h __C)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmaddcsh_round ((__v8hf) __A,
+         (__v8hf) __B,
+         (__v8hf) __C,
+         _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmadd_sch (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfmaddcsh_mask_round ((__v8hf) __A,
+      (__v8hf) __C,
+      (__v8hf) __D, __B,
+      _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmadd_sch (__m128h __A, __m128h __B, __m128h __C, __mmask8 __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfmaddcsh_mask3_round ((__v8hf) __A,
+       (__v8hf) __B,
+       (__v8hf) __C, __D,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmadd_sch (__mmask8 __A, __m128h __B, __m128h __C, __m128h __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfmaddcsh_maskz_round ((__v8hf) __B,
+       (__v8hf) __C,
+       (__v8hf) __D,
+       __A, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmadd_sch (__m128h __A, __m128h __B, __m128h __C)
+{
+  return (__m128h)
+    __builtin_ia32_vfmaddcsh_round ((__v8hf) __A,
+        (__v8hf) __B,
+        (__v8hf) __C,
+        _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fcmadd_round_sch (__m128h __A, __mmask8 __B, __m128h __C,
+      __m128h __D, const int __E)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmaddcsh_mask_round ((__v8hf) __A,
+       (__v8hf) __C,
+       (__v8hf) __D,
+       __B, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fcmadd_round_sch (__m128h __A, __m128h __B, __m128h __C,
+       __mmask8 __D, const int __E)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmaddcsh_mask3_round ((__v8hf) __A,
+        (__v8hf) __B,
+        (__v8hf) __C,
+        __D, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fcmadd_round_sch (__mmask8 __A, __m128h __B, __m128h __C,
+       __m128h __D, const int __E)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmaddcsh_maskz_round ((__v8hf) __B,
+        (__v8hf) __C,
+        (__v8hf) __D,
+        __A, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fcmadd_round_sch (__m128h __A, __m128h __B, __m128h __C, const int __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmaddcsh_round ((__v8hf) __A,
+         (__v8hf) __B,
+         (__v8hf) __C,
+         __D);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmadd_round_sch (__m128h __A, __mmask8 __B, __m128h __C,
+     __m128h __D, const int __E)
+{
+  return (__m128h)
+    __builtin_ia32_vfmaddcsh_mask_round ((__v8hf) __A,
+      (__v8hf) __C,
+      (__v8hf) __D,
+      __B, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask3_fmadd_round_sch (__m128h __A, __m128h __B, __m128h __C,
+      __mmask8 __D, const int __E)
+{
+  return (__m128h)
+    __builtin_ia32_vfmaddcsh_mask3_round ((__v8hf) __A,
+       (__v8hf) __B,
+       (__v8hf) __C,
+       __D, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmadd_round_sch (__mmask8 __A, __m128h __B, __m128h __C,
+      __m128h __D, const int __E)
+{
+  return (__m128h)
+    __builtin_ia32_vfmaddcsh_maskz_round ((__v8hf) __B,
+       (__v8hf) __C,
+       (__v8hf) __D,
+       __A, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmadd_round_sch (__m128h __A, __m128h __B, __m128h __C, const int __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfmaddcsh_round ((__v8hf) __A,
+        (__v8hf) __B,
+        (__v8hf) __C,
+        __D);
+}
+#else
+#define _mm_mask_fcmadd_round_sch(A, B, C, D, E) ((__m128h) __builtin_ia32_vfcmaddcsh_mask_round ((__v8hf) (A), (__v8hf) (C), (__v8hf) (D), (B), (E)))
+#define _mm_mask3_fcmadd_round_sch(A, B, C, D, E) ((__m128h) __builtin_ia32_vfcmaddcsh_mask3_round ((__v8hf) (A), (__v8hf) (B), (__v8hf) (C), (D), (E)))
+#define _mm_maskz_fcmadd_round_sch(A, B, C, D, E) __builtin_ia32_vfcmaddcsh_maskz_round ((B), (C), (D), (A), (E))
+#define _mm_fcmadd_round_sch(A, B, C, D) __builtin_ia32_vfcmaddcsh_round ((A), (B), (C), (D))
+#define _mm_mask_fmadd_round_sch(A, B, C, D, E) ((__m128h) __builtin_ia32_vfmaddcsh_mask_round ((__v8hf) (A), (__v8hf) (C), (__v8hf) (D), (B), (E)))
+#define _mm_mask3_fmadd_round_sch(A, B, C, D, E) ((__m128h) __builtin_ia32_vfmaddcsh_mask3_round ((__v8hf) (A), (__v8hf) (B), (__v8hf) (C), (D), (E)))
+#define _mm_maskz_fmadd_round_sch(A, B, C, D, E) __builtin_ia32_vfmaddcsh_maskz_round ((B), (C), (D), (A), (E))
+#define _mm_fmadd_round_sch(A, B, C, D) __builtin_ia32_vfmaddcsh_round ((A), (B), (C), (D))
+#endif
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fcmul_sch (__m128h __A, __m128h __B)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmulcsh_round ((__v8hf) __A,
+        (__v8hf) __B,
+        _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fcmul_sch (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __C,
+      (__v8hf) __D,
+      (__v8hf) __A,
+      __B, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fcmul_sch (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __B,
+      (__v8hf) __C,
+      _mm_setzero_ph (),
+      __A, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmul_sch (__m128h __A, __m128h __B)
+{
+  return (__m128h)
+    __builtin_ia32_vfmulcsh_round ((__v8hf) __A,
+       (__v8hf) __B,
+       _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmul_sch (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __C,
+     (__v8hf) __D,
+     (__v8hf) __A,
+     __B, _MM_FROUND_CUR_DIRECTION);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmul_sch (__mmask8 __A, __m128h __B, __m128h __C)
+{
+  return (__m128h)
+    __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __B,
+     (__v8hf) __C,
+     _mm_setzero_ph (),
+     __A, _MM_FROUND_CUR_DIRECTION);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fcmul_round_sch (__m128h __A, __m128h __B, const int __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmulcsh_round ((__v8hf) __A,
+        (__v8hf) __B,
+        __D);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fcmul_round_sch (__m128h __A, __mmask8 __B, __m128h __C,
+     __m128h __D, const int __E)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __C,
+      (__v8hf) __D,
+      (__v8hf) __A,
+      __B, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fcmul_round_sch (__mmask8 __A, __m128h __B, __m128h __C,
+      const int __E)
+{
+  return (__m128h)
+    __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __B,
+      (__v8hf) __C,
+      _mm_setzero_ph (),
+      __A, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_fmul_round_sch (__m128h __A, __m128h __B, const int __D)
+{
+  return (__m128h)
+    __builtin_ia32_vfmulcsh_round ((__v8hf) __A,
+       (__v8hf) __B, __D);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_fmul_round_sch (__m128h __A, __mmask8 __B, __m128h __C,
+    __m128h __D, const int __E)
+{
+  return (__m128h)
+    __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __C,
+     (__v8hf) __D,
+     (__v8hf) __A,
+     __B, __E);
+}
+extern __inline __m128h
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_fmul_round_sch (__mmask8 __A, __m128h __B, __m128h __C, const int __E)
+{
+  return (__m128h)
+    __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __B,
+     (__v8hf) __C,
+     _mm_setzero_ph (),
+     __A, __E);
+}
+#else
+#define _mm_fcmul_round_sch(__A, __B, __D) (__m128h) __builtin_ia32_vfcmulcsh_round ((__v8hf) __A, (__v8hf) __B, __D)
+#define _mm_mask_fcmul_round_sch(__A, __B, __C, __D, __E) (__m128h) __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __C, (__v8hf) __D, (__v8hf) __A, __B, __E)
+#define _mm_maskz_fcmul_round_sch(__A, __B, __C, __E) (__m128h) __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __B, (__v8hf) __C, _mm_setzero_ph (), __A, __E)
+#define _mm_fmul_round_sch(__A, __B, __D) (__m128h) __builtin_ia32_vfmulcsh_round ((__v8hf) __A, (__v8hf) __B, __D)
+#define _mm_mask_fmul_round_sch(__A, __B, __C, __D, __E) (__m128h) __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __C, (__v8hf) __D, (__v8hf) __A, __B, __E)
+#define _mm_maskz_fmul_round_sch(__A, __B, __C, __E) (__m128h) __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __B, (__v8hf) __C, _mm_setzero_ph (), __A, __E)
+#endif
+#define _mm_mul_sch(A, B) _mm_fmul_sch ((A), (B))
+#define _mm_mask_mul_sch(W, U, A, B) _mm_mask_fmul_sch ((W), (U), (A), (B))
+#define _mm_maskz_mul_sch(U, A, B) _mm_maskz_fmul_sch ((U), (A), (B))
+#define _mm_mul_round_sch(A, B, R) _mm_fmul_round_sch ((A), (B), (R))
+#define _mm_mask_mul_round_sch(W, U, A, B, R) _mm_mask_fmul_round_sch ((W), (U), (A), (B), (R))
+#define _mm_maskz_mul_round_sch(U, A, B, R) _mm_maskz_fmul_round_sch ((U), (A), (B), (R))
+#define _mm_cmul_sch(A, B) _mm_fcmul_sch ((A), (B))
+#define _mm_mask_cmul_sch(W, U, A, B) _mm_mask_fcmul_sch ((W), (U), (A), (B))
+#define _mm_maskz_cmul_sch(U, A, B) _mm_maskz_fcmul_sch ((U), (A), (B))
+#define _mm_cmul_round_sch(A, B, R) _mm_fcmul_round_sch ((A), (B), (R))
+#define _mm_mask_cmul_round_sch(W, U, A, B, R) _mm_mask_fcmul_round_sch ((W), (U), (A), (B), (R))
+#define _mm_maskz_cmul_round_sch(U, A, B, R) _mm_maskz_fcmul_round_sch ((U), (A), (B), (R))
+#ifdef __DISABLE_AVX512FP16__
+#undef __DISABLE_AVX512FP16__
+#pragma GCC pop_options
+#endif
+#if !defined (__AVX512FP16__) || !defined (__EVEX512__)
+#pragma GCC push_options
+#pragma GCC target("avx512fp16,evex512")
+#define __DISABLE_AVX512FP16_512__
+#endif
+typedef _Float16 __v32hf __attribute__ ((__vector_size__ (64)));
+typedef _Float16 __m512h __attribute__ ((__vector_size__ (64), __may_alias__));
+typedef _Float16 __m512h_u __attribute__ ((__vector_size__ (64), __may_alias__, __aligned__ (1)));
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_set_ph (_Float16 __A31, _Float16 __A30, _Float16 __A29,
@@ -64,27 +2214,6 @@ _mm512_set_ph (_Float16 __A31, _Float16 __A30, _Float16 __A29,
         __A24, __A25, __A26, __A27,
         __A28, __A29, __A30, __A31 };
 }
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_setr_ph (_Float16 __A0, _Float16 __A1, _Float16 __A2,
-      _Float16 __A3, _Float16 __A4, _Float16 __A5,
-      _Float16 __A6, _Float16 __A7)
-{
-  return _mm_set_ph (__A7, __A6, __A5, __A4, __A3, __A2, __A1, __A0);
-}
-extern __inline __m256h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_setr_ph (_Float16 __A0, _Float16 __A1, _Float16 __A2,
-  _Float16 __A3, _Float16 __A4, _Float16 __A5,
-  _Float16 __A6, _Float16 __A7, _Float16 __A8,
-  _Float16 __A9, _Float16 __A10, _Float16 __A11,
-  _Float16 __A12, _Float16 __A13, _Float16 __A14,
-  _Float16 __A15)
-{
-  return _mm256_set_ph (__A15, __A14, __A13, __A12, __A11, __A10, __A9,
-   __A8, __A7, __A6, __A5, __A4, __A3, __A2, __A1,
-   __A0);
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_setr_ph (_Float16 __A0, _Float16 __A1, _Float16 __A2,
@@ -105,19 +2234,6 @@ _mm512_setr_ph (_Float16 __A0, _Float16 __A1, _Float16 __A2,
    __A10, __A9, __A8, __A7, __A6, __A5, __A4, __A3,
    __A2, __A1, __A0);
 }
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_set1_ph (_Float16 __A)
-{
-  return _mm_set_ph (__A, __A, __A, __A, __A, __A, __A, __A);
-}
-extern __inline __m256h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_set1_ph (_Float16 __A)
-{
-  return _mm256_set_ph (__A, __A, __A, __A, __A, __A, __A, __A,
-   __A, __A, __A, __A, __A, __A, __A, __A);
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_set1_ph (_Float16 __A)
@@ -127,59 +2243,24 @@ _mm512_set1_ph (_Float16 __A)
    __A, __A, __A, __A, __A, __A, __A, __A,
    __A, __A, __A, __A, __A, __A, __A, __A);
 }
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_setzero_ph (void)
-{
-  return _mm_set1_ph (0.0f);
-}
-extern __inline __m256h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_setzero_ph (void)
-{
-  return _mm256_set1_ph (0.0f);
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_setzero_ph (void)
 {
-  return _mm512_set1_ph (0.0f);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_undefined_ph (void)
-{
-  __m128h __Y = __Y;
-  return __Y;
-}
-extern __inline __m256h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_undefined_ph (void)
-{
-  __m256h __Y = __Y;
-  return __Y;
+  return _mm512_set1_ph (0.0f16);
 }
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_undefined_ph (void)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
   __m512h __Y = __Y;
+#pragma GCC diagnostic pop
   return __Y;
 }
 extern __inline _Float16
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsh_h (__m128h __A)
-{
-  return __A[0];
-}
-extern __inline _Float16
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_cvtsh_h (__m256h __A)
-{
-  return __A[0];
-}
-extern __inline _Float16
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_cvtsh_h (__m512h __A)
 {
   return __A[0];
@@ -208,10 +2289,10 @@ _mm512_castph512_ph128 (__m512h __A)
 {
   union
   {
-    __m128h a[4];
-    __m512h v;
-  } u = { .v = __A };
-  return u.a[0];
+    __m128h __a[4];
+    __m512h __v;
+  } __u = { .__v = __A };
+  return __u.__a[0];
 }
 extern __inline __m256h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -219,10 +2300,10 @@ _mm512_castph512_ph256 (__m512h __A)
 {
   union
   {
-    __m256h a[2];
-    __m512h v;
-  } u = { .v = __A };
-  return u.a[0];
+    __m256h __a[2];
+    __m512h __v;
+  } __u = { .__v = __A };
+  return __u.__a[0];
 }
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -230,11 +2311,11 @@ _mm512_castph128_ph512 (__m128h __A)
 {
   union
   {
-    __m128h a[4];
-    __m512h v;
-  } u;
-  u.a[0] = __A;
-  return u.v;
+    __m128h __a[4];
+    __m512h __v;
+  } __u;
+  __u.__a[0] = __A;
+  return __u.__v;
 }
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -242,11 +2323,11 @@ _mm512_castph256_ph512 (__m256h __A)
 {
   union
   {
-    __m256h a[2];
-    __m512h v;
-  } u;
-  u.a[0] = __A;
-  return u.v;
+    __m256h __a[2];
+    __m512h __v;
+  } __u;
+  __u.__a[0] = __A;
+  return __u.__v;
 }
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -280,61 +2361,18 @@ _mm512_castsi512_ph (__m512i __a)
 {
   return (__m512h) __a;
 }
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_set_sh (_Float16 __F)
-{
-  return _mm_set_ph (0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, __F);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_load_sh (void const *__P)
-{
-  return _mm_set_ph (0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
-       *(_Float16 const *) __P);
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_load_ph (void const *__P)
 {
   return *(const __m512h *) __P;
 }
-extern __inline __m256h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_load_ph (void const *__P)
-{
-  return *(const __m256h *) __P;
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_load_ph (void const *__P)
-{
-  return *(const __m128h *) __P;
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_loadu_ph (void const *__P)
 {
   return *(const __m512h_u *) __P;
 }
-extern __inline __m256h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_loadu_ph (void const *__P)
-{
-  return *(const __m256h_u *) __P;
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_loadu_ph (void const *__P)
-{
-  return *(const __m128h_u *) __P;
-}
-extern __inline void
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_store_sh (void *__P, __m128h __A)
-{
-  *(_Float16 *) __P = ((__v8hf)__A)[0];
-}
 extern __inline void
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_store_ph (void *__P, __m512h __A)
@@ -343,34 +2381,10 @@ _mm512_store_ph (void *__P, __m512h __A)
 }
 extern __inline void
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_store_ph (void *__P, __m256h __A)
-{
-   *(__m256h *) __P = __A;
-}
-extern __inline void
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_store_ph (void *__P, __m128h __A)
-{
-   *(__m128h *) __P = __A;
-}
-extern __inline void
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_storeu_ph (void *__P, __m512h __A)
 {
    *(__m512h_u *) __P = __A;
 }
-extern __inline void
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_storeu_ph (void *__P, __m256h __A)
-{
-   *(__m256h_u *) __P = __A;
-}
-extern __inline void
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_storeu_ph (void *__P, __m128h __A)
-{
-   *(__m128h_u *) __P = __A;
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_abs_ph (__m512h __A)
@@ -589,196 +2603,6 @@ _mm512_maskz_conj_pch (__mmask16 __U, __m512h __A)
        (__v16sf) _mm512_setzero_ps (),
        (__mmask16) __U);
 }
-extern __inline __m128h
-  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_add_sh (__m128h __A, __m128h __B)
-{
-  __A[0] += __B[0];
-  return __A;
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_add_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_addsh_mask (__C, __D, __A, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_add_sh (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_addsh_mask (__B, __C, _mm_setzero_ph (),
-        __A);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_sub_sh (__m128h __A, __m128h __B)
-{
-  __A[0] -= __B[0];
-  return __A;
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_sub_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_subsh_mask (__C, __D, __A, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_sub_sh (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_subsh_mask (__B, __C, _mm_setzero_ph (),
-        __A);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mul_sh (__m128h __A, __m128h __B)
-{
-  __A[0] *= __B[0];
-  return __A;
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_mul_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_mulsh_mask (__C, __D, __A, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_mul_sh (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_mulsh_mask (__B, __C, _mm_setzero_ph (), __A);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_div_sh (__m128h __A, __m128h __B)
-{
-  __A[0] /= __B[0];
-  return __A;
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_div_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_divsh_mask (__C, __D, __A, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_div_sh (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_divsh_mask (__B, __C, _mm_setzero_ph (),
-        __A);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_add_round_sh (__m128h __A, __m128h __B, const int __C)
-{
-  return __builtin_ia32_addsh_mask_round (__A, __B,
-       _mm_setzero_ph (),
-       (__mmask8) -1, __C);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_add_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
-         __m128h __D, const int __E)
-{
-  return __builtin_ia32_addsh_mask_round (__C, __D, __A, __B, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_add_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
-   const int __D)
-{
-  return __builtin_ia32_addsh_mask_round (__B, __C,
-       _mm_setzero_ph (),
-       __A, __D);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_sub_round_sh (__m128h __A, __m128h __B, const int __C)
-{
-  return __builtin_ia32_subsh_mask_round (__A, __B,
-       _mm_setzero_ph (),
-       (__mmask8) -1, __C);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_sub_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
-         __m128h __D, const int __E)
-{
-  return __builtin_ia32_subsh_mask_round (__C, __D, __A, __B, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_sub_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
-   const int __D)
-{
-  return __builtin_ia32_subsh_mask_round (__B, __C,
-       _mm_setzero_ph (),
-       __A, __D);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mul_round_sh (__m128h __A, __m128h __B, const int __C)
-{
-  return __builtin_ia32_mulsh_mask_round (__A, __B,
-       _mm_setzero_ph (),
-       (__mmask8) -1, __C);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_mul_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
-         __m128h __D, const int __E)
-{
-  return __builtin_ia32_mulsh_mask_round (__C, __D, __A, __B, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_mul_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
-   const int __D)
-{
-  return __builtin_ia32_mulsh_mask_round (__B, __C,
-       _mm_setzero_ph (),
-       __A, __D);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_div_round_sh (__m128h __A, __m128h __B, const int __C)
-{
-  return __builtin_ia32_divsh_mask_round (__A, __B,
-       _mm_setzero_ph (),
-       (__mmask8) -1, __C);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_div_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
-         __m128h __D, const int __E)
-{
-  return __builtin_ia32_divsh_mask_round (__C, __D, __A, __B, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_div_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
-   const int __D)
-{
-  return __builtin_ia32_divsh_mask_round (__B, __C,
-       _mm_setzero_ph (),
-       __A, __D);
-}
-#else
-#define _mm_add_round_sh(A, B, C) ((__m128h)__builtin_ia32_addsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
-#define _mm_mask_add_round_sh(A, B, C, D, E) ((__m128h)__builtin_ia32_addsh_mask_round ((C), (D), (A), (B), (E)))
-#define _mm_maskz_add_round_sh(A, B, C, D) ((__m128h)__builtin_ia32_addsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
-#define _mm_sub_round_sh(A, B, C) ((__m128h)__builtin_ia32_subsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
-#define _mm_mask_sub_round_sh(A, B, C, D, E) ((__m128h)__builtin_ia32_subsh_mask_round ((C), (D), (A), (B), (E)))
-#define _mm_maskz_sub_round_sh(A, B, C, D) ((__m128h)__builtin_ia32_subsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
-#define _mm_mul_round_sh(A, B, C) ((__m128h)__builtin_ia32_mulsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
-#define _mm_mask_mul_round_sh(A, B, C, D, E) ((__m128h)__builtin_ia32_mulsh_mask_round ((C), (D), (A), (B), (E)))
-#define _mm_maskz_mul_round_sh(A, B, C, D) ((__m128h)__builtin_ia32_mulsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
-#define _mm_div_round_sh(A, B, C) ((__m128h)__builtin_ia32_divsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
-#define _mm_mask_div_round_sh(A, B, C, D, E) ((__m128h)__builtin_ia32_divsh_mask_round ((C), (D), (A), (B), (E)))
-#define _mm_maskz_div_round_sh(A, B, C, D) ((__m128h)__builtin_ia32_divsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
-#endif
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_max_ph (__m512h __A, __m512h __B)
@@ -878,103 +2702,6 @@ _mm512_maskz_min_round_ph (__mmask32 __A, __m512h __B, __m512h __C,
 #define _mm512_mask_min_round_ph(A, B, C, D, E) (__builtin_ia32_minph512_mask_round ((C), (D), (A), (B), (E)))
 #define _mm512_maskz_min_round_ph(A, B, C, D) (__builtin_ia32_minph512_mask_round ((B), (C), _mm512_setzero_ph (), (A), (D)))
 #endif
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_max_sh (__m128h __A, __m128h __B)
-{
-  __A[0] = __A[0] > __B[0] ? __A[0] : __B[0];
-  return __A;
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_max_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_maxsh_mask (__C, __D, __A, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_max_sh (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_maxsh_mask (__B, __C, _mm_setzero_ph (),
-        __A);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_min_sh (__m128h __A, __m128h __B)
-{
-  __A[0] = __A[0] < __B[0] ? __A[0] : __B[0];
-  return __A;
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_min_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_minsh_mask (__C, __D, __A, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_min_sh (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_minsh_mask (__B, __C, _mm_setzero_ph (),
-        __A);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_max_round_sh (__m128h __A, __m128h __B, const int __C)
-{
-  return __builtin_ia32_maxsh_mask_round (__A, __B,
-       _mm_setzero_ph (),
-       (__mmask8) -1, __C);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_max_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
-         __m128h __D, const int __E)
-{
-  return __builtin_ia32_maxsh_mask_round (__C, __D, __A, __B, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_max_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
-   const int __D)
-{
-  return __builtin_ia32_maxsh_mask_round (__B, __C,
-       _mm_setzero_ph (),
-       __A, __D);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_min_round_sh (__m128h __A, __m128h __B, const int __C)
-{
-  return __builtin_ia32_minsh_mask_round (__A, __B,
-       _mm_setzero_ph (),
-       (__mmask8) -1, __C);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_min_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
-         __m128h __D, const int __E)
-{
-  return __builtin_ia32_minsh_mask_round (__C, __D, __A, __B, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_min_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
-   const int __D)
-{
-  return __builtin_ia32_minsh_mask_round (__B, __C,
-       _mm_setzero_ph (),
-       __A, __D);
-}
-#else
-#define _mm_max_round_sh(A, B, C) (__builtin_ia32_maxsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
-#define _mm_mask_max_round_sh(A, B, C, D, E) (__builtin_ia32_maxsh_mask_round ((C), (D), (A), (B), (E)))
-#define _mm_maskz_max_round_sh(A, B, C, D) (__builtin_ia32_maxsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
-#define _mm_min_round_sh(A, B, C) (__builtin_ia32_minsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
-#define _mm_mask_min_round_sh(A, B, C, D, E) (__builtin_ia32_minsh_mask_round ((C), (D), (A), (B), (E)))
-#define _mm_maskz_min_round_sh(A, B, C, D) (__builtin_ia32_minsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
-#endif
 #ifdef __OPTIMIZE
 extern __inline __mmask32
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -1015,166 +2742,6 @@ _mm512_mask_cmp_round_ph_mask (__mmask32 __A, __m512h __B, __m512h __C,
 #define _mm512_cmp_round_ph_mask(A, B, C, D) (__builtin_ia32_cmpph512_mask_round ((A), (B), (C), (-1), (D)))
 #define _mm512_mask_cmp_round_ph_mask(A, B, C, D, E) (__builtin_ia32_cmpph512_mask_round ((B), (C), (D), (A), (E)))
 #endif
-#ifdef __OPTIMIZE__
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cmp_sh_mask (__m128h __A, __m128h __B, const int __C)
-{
-  return (__mmask8)
-    __builtin_ia32_cmpsh_mask_round (__A, __B,
-         __C, (__mmask8) -1,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cmp_sh_mask (__mmask8 __A, __m128h __B, __m128h __C,
-        const int __D)
-{
-  return (__mmask8)
-    __builtin_ia32_cmpsh_mask_round (__B, __C,
-         __D, __A,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cmp_round_sh_mask (__m128h __A, __m128h __B, const int __C,
-         const int __D)
-{
-  return (__mmask8) __builtin_ia32_cmpsh_mask_round (__A, __B,
-           __C, (__mmask8) -1,
-           __D);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cmp_round_sh_mask (__mmask8 __A, __m128h __B, __m128h __C,
-       const int __D, const int __E)
-{
-  return (__mmask8) __builtin_ia32_cmpsh_mask_round (__B, __C,
-           __D, __A,
-           __E);
-}
-#else
-#define _mm_cmp_sh_mask(A, B, C) (__builtin_ia32_cmpsh_mask_round ((A), (B), (C), (-1), (_MM_FROUND_CUR_DIRECTION)))
-#define _mm_mask_cmp_sh_mask(A, B, C, D) (__builtin_ia32_cmpsh_mask_round ((B), (C), (D), (A), (_MM_FROUND_CUR_DIRECTION)))
-#define _mm_cmp_round_sh_mask(A, B, C, D) (__builtin_ia32_cmpsh_mask_round ((A), (B), (C), (-1), (D)))
-#define _mm_mask_cmp_round_sh_mask(A, B, C, D, E) (__builtin_ia32_cmpsh_mask_round ((B), (C), (D), (A), (E)))
-#endif
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_comieq_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_EQ_OS,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_comilt_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_LT_OS,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_comile_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_LE_OS,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_comigt_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_GT_OS,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_comige_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_GE_OS,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_comineq_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_NEQ_US,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_ucomieq_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_EQ_OQ,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_ucomilt_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_LT_OQ,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_ucomile_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_LE_OQ,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_ucomigt_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_GT_OQ,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_ucomige_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_GE_OQ,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_ucomineq_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, _CMP_NEQ_UQ,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_comi_sh (__m128h __A, __m128h __B, const int __P)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, __P,
-       (__mmask8) -1,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_comi_round_sh (__m128h __A, __m128h __B, const int __P, const int __R)
-{
-  return __builtin_ia32_cmpsh_mask_round (__A, __B, __P,
-       (__mmask8) -1,__R);
-}
-#else
-#define _mm_comi_round_sh(A, B, P, R) (__builtin_ia32_cmpsh_mask_round ((A), (B), (P), (__mmask8) (-1), (R)))
-#define _mm_comi_sh(A, B, P) (__builtin_ia32_cmpsh_mask_round ((A), (B), (P), (__mmask8) (-1), _MM_FROUND_CUR_DIRECTION))
-#endif
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_sqrt_ph (__m512h __A)
@@ -1249,81 +2816,6 @@ _mm512_maskz_rsqrt_ph (__mmask32 __A, __m512h __B)
   return __builtin_ia32_rsqrtph512_mask (__B, _mm512_setzero_ph (),
       __A);
 }
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_rsqrt_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_rsqrtsh_mask (__B, __A, _mm_setzero_ph (),
-          (__mmask8) -1);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_rsqrt_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_rsqrtsh_mask (__D, __C, __A, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_rsqrt_sh (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_rsqrtsh_mask (__C, __B, _mm_setzero_ph (),
-          __A);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_sqrt_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_sqrtsh_mask_round (__B, __A,
-        _mm_setzero_ph (),
-        (__mmask8) -1,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_sqrt_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_sqrtsh_mask_round (__D, __C, __A, __B,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_sqrt_sh (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_sqrtsh_mask_round (__C, __B,
-        _mm_setzero_ph (),
-        __A, _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_sqrt_round_sh (__m128h __A, __m128h __B, const int __C)
-{
-  return __builtin_ia32_sqrtsh_mask_round (__B, __A,
-        _mm_setzero_ph (),
-        (__mmask8) -1, __C);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_sqrt_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
-   __m128h __D, const int __E)
-{
-  return __builtin_ia32_sqrtsh_mask_round (__D, __C, __A, __B,
-        __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_sqrt_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
-    const int __D)
-{
-  return __builtin_ia32_sqrtsh_mask_round (__C, __B,
-        _mm_setzero_ph (),
-        __A, __D);
-}
-#else
-#define _mm_sqrt_round_sh(A, B, C) (__builtin_ia32_sqrtsh_mask_round ((B), (A), _mm_setzero_ph (), (__mmask8)-1, (C)))
-#define _mm_mask_sqrt_round_sh(A, B, C, D, E) (__builtin_ia32_sqrtsh_mask_round ((D), (C), (A), (B), (E)))
-#define _mm_maskz_sqrt_round_sh(A, B, C, D) (__builtin_ia32_sqrtsh_mask_round ((C), (B), _mm_setzero_ph (), (A), (D)))
-#endif
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_rcp_ph (__m512h __A)
@@ -1344,26 +2836,6 @@ _mm512_maskz_rcp_ph (__mmask32 __A, __m512h __B)
   return __builtin_ia32_rcpph512_mask (__B, _mm512_setzero_ph (),
            __A);
 }
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_rcp_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_rcpsh_mask (__B, __A, _mm_setzero_ph (),
-        (__mmask8) -1);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_rcp_sh (__m128h __A, __mmask32 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_rcpsh_mask (__D, __C, __A, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_rcp_sh (__mmask32 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_rcpsh_mask (__C, __B, _mm_setzero_ph (),
-        __A);
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_scalef_ph (__m512h __A, __m512h __B)
@@ -1420,62 +2892,6 @@ _mm512_maskz_scalef_round_ph (__mmask32 __A, __m512h __B, __m512h __C,
 #define _mm512_mask_scalef_round_ph(A, B, C, D, E) (__builtin_ia32_scalefph512_mask_round ((C), (D), (A), (B), (E)))
 #define _mm512_maskz_scalef_round_ph(A, B, C, D) (__builtin_ia32_scalefph512_mask_round ((B), (C), _mm512_setzero_ph (), (A), (D)))
 #endif
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_scalef_sh (__m128h __A, __m128h __B)
-{
-  return __builtin_ia32_scalefsh_mask_round (__A, __B,
-          _mm_setzero_ph (),
-          (__mmask8) -1,
-          _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_scalef_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_scalefsh_mask_round (__C, __D, __A, __B,
-          _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_scalef_sh (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_scalefsh_mask_round (__B, __C,
-          _mm_setzero_ph (),
-          __A,
-          _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_scalef_round_sh (__m128h __A, __m128h __B, const int __C)
-{
-  return __builtin_ia32_scalefsh_mask_round (__A, __B,
-          _mm_setzero_ph (),
-          (__mmask8) -1, __C);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_scalef_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
-     __m128h __D, const int __E)
-{
-  return __builtin_ia32_scalefsh_mask_round (__C, __D, __A, __B,
-          __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_scalef_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
-      const int __D)
-{
-  return __builtin_ia32_scalefsh_mask_round (__B, __C,
-          _mm_setzero_ph (),
-          __A, __D);
-}
-#else
-#define _mm_scalef_round_sh(A, B, C) (__builtin_ia32_scalefsh_mask_round ((A), (B), _mm_setzero_ph (), (__mmask8)-1, (C)))
-#define _mm_mask_scalef_round_sh(A, B, C, D, E) (__builtin_ia32_scalefsh_mask_round ((C), (D), (A), (B), (E)))
-#define _mm_maskz_scalef_round_sh(A, B, C, D) (__builtin_ia32_scalefsh_mask_round ((B), (C), _mm_setzero_ph (), (A), (D)))
-#endif
 #ifdef __OPTIMIZE__
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -1536,65 +2952,6 @@ _mm512_maskz_reduce_round_ph (__mmask32 __A, __m512h __B, int __C,
 #define _mm512_maskz_reduce_round_ph(A, B, C, D) (__builtin_ia32_reduceph512_mask_round ((B), (C), _mm512_setzero_ph (), (A), (D)))
 #endif
 #ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_reduce_sh (__m128h __A, __m128h __B, int __C)
-{
-  return __builtin_ia32_reducesh_mask_round (__A, __B, __C,
-          _mm_setzero_ph (),
-          (__mmask8) -1,
-          _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_reduce_sh (__m128h __A, __mmask8 __B, __m128h __C,
-      __m128h __D, int __E)
-{
-  return __builtin_ia32_reducesh_mask_round (__C, __D, __E, __A, __B,
-          _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_reduce_sh (__mmask8 __A, __m128h __B, __m128h __C, int __D)
-{
-  return __builtin_ia32_reducesh_mask_round (__B, __C, __D,
-          _mm_setzero_ph (), __A,
-          _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_reduce_round_sh (__m128h __A, __m128h __B, int __C, const int __D)
-{
-  return __builtin_ia32_reducesh_mask_round (__A, __B, __C,
-          _mm_setzero_ph (),
-          (__mmask8) -1, __D);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_reduce_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
-     __m128h __D, int __E, const int __F)
-{
-  return __builtin_ia32_reducesh_mask_round (__C, __D, __E, __A,
-          __B, __F);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_reduce_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
-      int __D, const int __E)
-{
-  return __builtin_ia32_reducesh_mask_round (__B, __C, __D,
-          _mm_setzero_ph (),
-          __A, __E);
-}
-#else
-#define _mm_reduce_sh(A, B, C) (__builtin_ia32_reducesh_mask_round ((A), (B), (C), _mm_setzero_ph (), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_reduce_sh(A, B, C, D, E) (__builtin_ia32_reducesh_mask_round ((C), (D), (E), (A), (B), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_reduce_sh(A, B, C, D) (__builtin_ia32_reducesh_mask_round ((B), (C), (D), _mm_setzero_ph (), (A), _MM_FROUND_CUR_DIRECTION))
-#define _mm_reduce_round_sh(A, B, C, D) (__builtin_ia32_reducesh_mask_round ((A), (B), (C), _mm_setzero_ph (), (__mmask8)-1, (D)))
-#define _mm_mask_reduce_round_sh(A, B, C, D, E, F) (__builtin_ia32_reducesh_mask_round ((C), (D), (E), (A), (B), (F)))
-#define _mm_maskz_reduce_round_sh(A, B, C, D, E) (__builtin_ia32_reducesh_mask_round ((B), (C), (D), _mm_setzero_ph (), (A), (E)))
-#endif
-#ifdef __OPTIMIZE__
 extern __inline __m512h
   __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_roundscale_ph (__m512h __A, int __B)
@@ -1656,84 +3013,6 @@ _mm512_maskz_roundscale_round_ph (__mmask32 __A, __m512h __B, int __C,
 #define _mm512_maskz_roundscale_round_ph(A, B, C, D) (__builtin_ia32_rndscaleph512_mask_round ((B), (C), _mm512_setzero_ph (), (A), (D)))
 #endif
 #ifdef __OPTIMIZE__
-extern __inline __m128h
-  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_roundscale_sh (__m128h __A, __m128h __B, int __C)
-{
-  return __builtin_ia32_rndscalesh_mask_round (__A, __B, __C,
-            _mm_setzero_ph (),
-            (__mmask8) -1,
-            _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_roundscale_sh (__m128h __A, __mmask8 __B, __m128h __C,
-   __m128h __D, int __E)
-{
-  return __builtin_ia32_rndscalesh_mask_round (__C, __D, __E, __A, __B,
-            _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_roundscale_sh (__mmask8 __A, __m128h __B, __m128h __C, int __D)
-{
-  return __builtin_ia32_rndscalesh_mask_round (__B, __C, __D,
-            _mm_setzero_ph (), __A,
-            _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_roundscale_round_sh (__m128h __A, __m128h __B, int __C, const int __D)
-{
-  return __builtin_ia32_rndscalesh_mask_round (__A, __B, __C,
-            _mm_setzero_ph (),
-            (__mmask8) -1,
-            __D);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_roundscale_round_sh (__m128h __A, __mmask8 __B, __m128h __C,
-         __m128h __D, int __E, const int __F)
-{
-  return __builtin_ia32_rndscalesh_mask_round (__C, __D, __E,
-            __A, __B, __F);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_roundscale_round_sh (__mmask8 __A, __m128h __B, __m128h __C,
-          int __D, const int __E)
-{
-  return __builtin_ia32_rndscalesh_mask_round (__B, __C, __D,
-            _mm_setzero_ph (),
-            __A, __E);
-}
-#else
-#define _mm_roundscale_sh(A, B, C) (__builtin_ia32_rndscalesh_mask_round ((A), (B), (C), _mm_setzero_ph (), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_roundscale_sh(A, B, C, D, E) (__builtin_ia32_rndscalesh_mask_round ((C), (D), (E), (A), (B), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_roundscale_sh(A, B, C, D) (__builtin_ia32_rndscalesh_mask_round ((B), (C), (D), _mm_setzero_ph (), (A), _MM_FROUND_CUR_DIRECTION))
-#define _mm_roundscale_round_sh(A, B, C, D) (__builtin_ia32_rndscalesh_mask_round ((A), (B), (C), _mm_setzero_ph (), (__mmask8)-1, (D)))
-#define _mm_mask_roundscale_round_sh(A, B, C, D, E, F) (__builtin_ia32_rndscalesh_mask_round ((C), (D), (E), (A), (B), (F)))
-#define _mm_maskz_roundscale_round_sh(A, B, C, D, E) (__builtin_ia32_rndscalesh_mask_round ((B), (C), (D), _mm_setzero_ph (), (A), (E)))
-#endif
-#ifdef __OPTIMIZE__
-extern __inline __mmask8
-  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fpclass_sh_mask (__m128h __A, const int __imm)
-{
-  return (__mmask8) __builtin_ia32_fpclasssh_mask ((__v8hf) __A, __imm,
-         (__mmask8) -1);
-}
-extern __inline __mmask8
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fpclass_sh_mask (__mmask8 __U, __m128h __A, const int __imm)
-{
-  return (__mmask8) __builtin_ia32_fpclasssh_mask ((__v8hf) __A, __imm, __U);
-}
-#else
-#define _mm_fpclass_sh_mask(X, C) ((__mmask8) __builtin_ia32_fpclasssh_mask ((__v8hf) (__m128h) (X), (int) (C), (__mmask8) (-1)))
-#define _mm_mask_fpclass_sh_mask(U, X, C) ((__mmask8) __builtin_ia32_fpclasssh_mask ((__v8hf) (__m128h) (X), (int) (C), (__mmask8) (U)))
-#endif
-#ifdef __OPTIMIZE__
 extern __inline __mmask32
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mask_fpclass_ph_mask (__mmask32 __U, __m512h __A,
@@ -1754,35 +3033,6 @@ _mm512_fpclass_ph_mask (__m512h __A, const int __imm)
 #define _mm512_mask_fpclass_ph_mask(u, x, c) ((__mmask32) __builtin_ia32_fpclassph512_mask ((__v32hf) (__m512h) (x), (int) (c),(__mmask8)(u)))
 #define _mm512_fpclass_ph_mask(x, c) ((__mmask32) __builtin_ia32_fpclassph512_mask ((__v32hf) (__m512h) (x), (int) (c),(__mmask8)-1))
 #endif
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getexp_sh (__m128h __A, __m128h __B)
-{
-  return (__m128h)
-    __builtin_ia32_getexpsh_mask_round ((__v8hf) __A, (__v8hf) __B,
-     (__v8hf) _mm_setzero_ph (),
-     (__mmask8) -1,
-     _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getexp_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B)
-{
-  return (__m128h)
-    __builtin_ia32_getexpsh_mask_round ((__v8hf) __A, (__v8hf) __B,
-     (__v8hf) __W, (__mmask8) __U,
-     _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getexp_sh (__mmask8 __U, __m128h __A, __m128h __B)
-{
-  return (__m128h)
-    __builtin_ia32_getexpsh_mask_round ((__v8hf) __A, (__v8hf) __B,
-     (__v8hf) _mm_setzero_ph (),
-     (__mmask8) __U,
-     _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_getexp_ph (__m512h __A)
@@ -1810,37 +3060,6 @@ _mm512_maskz_getexp_ph (__mmask32 __U, __m512h __A)
          (__mmask32) __U, _MM_FROUND_CUR_DIRECTION);
 }
 #ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getexp_round_sh (__m128h __A, __m128h __B, const int __R)
-{
-  return (__m128h) __builtin_ia32_getexpsh_mask_round ((__v8hf) __A,
-             (__v8hf) __B,
-             _mm_setzero_ph (),
-             (__mmask8) -1,
-             __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getexp_round_sh (__m128h __W, __mmask8 __U, __m128h __A,
-     __m128h __B, const int __R)
-{
-  return (__m128h) __builtin_ia32_getexpsh_mask_round ((__v8hf) __A,
-             (__v8hf) __B,
-             (__v8hf) __W,
-             (__mmask8) __U, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getexp_round_sh (__mmask8 __U, __m128h __A, __m128h __B,
-      const int __R)
-{
-  return (__m128h) __builtin_ia32_getexpsh_mask_round ((__v8hf) __A,
-             (__v8hf) __B,
-             (__v8hf)
-             _mm_setzero_ph (),
-             (__mmask8) __U, __R);
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_getexp_round_ph (__m512h __A, const int __R)
@@ -1869,49 +3088,11 @@ _mm512_maskz_getexp_round_ph (__mmask32 __U, __m512h __A, const int __R)
           (__mmask32) __U, __R);
 }
 #else
-#define _mm_getexp_round_sh(A, B, R) ((__m128h)__builtin_ia32_getexpsh_mask_round((__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(), (__mmask8)-1, R))
-#define _mm_mask_getexp_round_sh(W, U, A, B, C) (__m128h)__builtin_ia32_getexpsh_mask_round(A, B, W, U, C)
-#define _mm_maskz_getexp_round_sh(U, A, B, C) (__m128h)__builtin_ia32_getexpsh_mask_round(A, B, (__v8hf)_mm_setzero_ph(), U, C)
 #define _mm512_getexp_round_ph(A, R) ((__m512h)__builtin_ia32_getexpph512_mask((__v32hf)(__m512h)(A), (__v32hf)_mm512_setzero_ph(), (__mmask32)-1, R))
 #define _mm512_mask_getexp_round_ph(W, U, A, R) ((__m512h)__builtin_ia32_getexpph512_mask((__v32hf)(__m512h)(A), (__v32hf)(__m512h)(W), (__mmask32)(U), R))
 #define _mm512_maskz_getexp_round_ph(U, A, R) ((__m512h)__builtin_ia32_getexpph512_mask((__v32hf)(__m512h)(A), (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), R))
 #endif
 #ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getmant_sh (__m128h __A, __m128h __B,
-  _MM_MANTISSA_NORM_ENUM __C,
-  _MM_MANTISSA_SIGN_ENUM __D)
-{
-  return (__m128h)
-    __builtin_ia32_getmantsh_mask_round ((__v8hf) __A, (__v8hf) __B,
-      (__D << 2) | __C, _mm_setzero_ph (),
-      (__mmask8) -1,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getmant_sh (__m128h __W, __mmask8 __U, __m128h __A,
-       __m128h __B, _MM_MANTISSA_NORM_ENUM __C,
-       _MM_MANTISSA_SIGN_ENUM __D)
-{
-  return (__m128h)
-    __builtin_ia32_getmantsh_mask_round ((__v8hf) __A, (__v8hf) __B,
-      (__D << 2) | __C, (__v8hf) __W,
-      __U, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getmant_sh (__mmask8 __U, __m128h __A, __m128h __B,
-        _MM_MANTISSA_NORM_ENUM __C,
-        _MM_MANTISSA_SIGN_ENUM __D)
-{
-  return (__m128h)
-    __builtin_ia32_getmantsh_mask_round ((__v8hf) __A, (__v8hf) __B,
-      (__D << 2) | __C,
-      (__v8hf) _mm_setzero_ph(),
-      __U, _MM_FROUND_CUR_DIRECTION);
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_getmant_ph (__m512h __A, _MM_MANTISSA_NORM_ENUM __B,
@@ -1947,44 +3128,6 @@ _mm512_maskz_getmant_ph (__mmask32 __U, __m512h __A,
            __U,
            _MM_FROUND_CUR_DIRECTION);
 }
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_getmant_round_sh (__m128h __A, __m128h __B,
-        _MM_MANTISSA_NORM_ENUM __C,
-        _MM_MANTISSA_SIGN_ENUM __D, const int __R)
-{
-  return (__m128h) __builtin_ia32_getmantsh_mask_round ((__v8hf) __A,
-       (__v8hf) __B,
-       (__D << 2) | __C,
-       _mm_setzero_ph (),
-       (__mmask8) -1,
-       __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_getmant_round_sh (__m128h __W, __mmask8 __U, __m128h __A,
-      __m128h __B, _MM_MANTISSA_NORM_ENUM __C,
-      _MM_MANTISSA_SIGN_ENUM __D, const int __R)
-{
-  return (__m128h) __builtin_ia32_getmantsh_mask_round ((__v8hf) __A,
-       (__v8hf) __B,
-       (__D << 2) | __C,
-       (__v8hf) __W,
-       __U, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_getmant_round_sh (__mmask8 __U, __m128h __A, __m128h __B,
-       _MM_MANTISSA_NORM_ENUM __C,
-       _MM_MANTISSA_SIGN_ENUM __D, const int __R)
-{
-  return (__m128h) __builtin_ia32_getmantsh_mask_round ((__v8hf) __A,
-       (__v8hf) __B,
-       (__D << 2) | __C,
-       (__v8hf)
-       _mm_setzero_ph(),
-       __U, __R);
-}
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_getmant_round_ph (__m512h __A, _MM_MANTISSA_NORM_ENUM __B,
@@ -2022,65 +3165,10 @@ _mm512_maskz_getmant_round_ph (__mmask32 __U, __m512h __A,
 #define _mm512_getmant_ph(X, B, C) ((__m512h)__builtin_ia32_getmantph512_mask ((__v32hf)(__m512h)(X), (int)(((C)<<2) | (B)), (__v32hf)(__m512h) _mm512_setzero_ph(), (__mmask32)-1, _MM_FROUND_CUR_DIRECTION))
 #define _mm512_mask_getmant_ph(W, U, X, B, C) ((__m512h)__builtin_ia32_getmantph512_mask ((__v32hf)(__m512h)(X), (int)(((C)<<2) | (B)), (__v32hf)(__m512h)(W), (__mmask32)(U), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_maskz_getmant_ph(U, X, B, C) ((__m512h)__builtin_ia32_getmantph512_mask ((__v32hf)(__m512h)(X), (int)(((C)<<2) | (B)), (__v32hf)(__m512h) _mm512_setzero_ph(), (__mmask32)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_getmant_sh(X, Y, C, D) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h) _mm_setzero_ph (), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
-#define _mm_mask_getmant_sh(W, U, X, Y, C, D) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
-#define _mm_maskz_getmant_sh(U, X, Y, C, D) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h) _mm_setzero_ph(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
 #define _mm512_getmant_round_ph(X, B, C, R) ((__m512h)__builtin_ia32_getmantph512_mask ((__v32hf)(__m512h)(X), (int)(((C)<<2) | (B)), (__v32hf)(__m512h) _mm512_setzero_ph(), (__mmask32)-1, (R)))
 #define _mm512_mask_getmant_round_ph(W, U, X, B, C, R) ((__m512h)__builtin_ia32_getmantph512_mask ((__v32hf)(__m512h)(X), (int)(((C)<<2) | (B)), (__v32hf)(__m512h)(W), (__mmask32)(U), (R)))
 #define _mm512_maskz_getmant_round_ph(U, X, B, C, R) ((__m512h)__builtin_ia32_getmantph512_mask ((__v32hf)(__m512h)(X), (int)(((C)<<2) | (B)), (__v32hf)(__m512h) _mm512_setzero_ph(), (__mmask32)(U), (R)))
-#define _mm_getmant_round_sh(X, Y, C, D, R) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h) _mm_setzero_ph (), (__mmask8)-1, (R)))
-#define _mm_mask_getmant_round_sh(W, U, X, Y, C, D, R) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h)(W), (__mmask8)(U), (R)))
-#define _mm_maskz_getmant_round_sh(U, X, Y, C, D, R) ((__m128h)__builtin_ia32_getmantsh_mask_round ((__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(((D)<<2) | (C)), (__v8hf)(__m128h) _mm_setzero_ph(), (__mmask8)(U), (R)))
 #endif
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsi16_si128 (short __A)
-{
-  return _mm_set_epi16 (0, 0, 0, 0, 0, 0, 0, __A);
-}
-extern __inline short
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsi128_si16 (__m128i __A)
-{
-  return __builtin_ia32_vec_ext_v8hi ((__v8hi)__A, 0);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_load_sh (__m128h __A, __mmask8 __B, _Float16 const* __C)
-{
-  return __builtin_ia32_loadsh_mask (__C, __A, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_load_sh (__mmask8 __A, _Float16 const* __B)
-{
-  return __builtin_ia32_loadsh_mask (__B, _mm_setzero_ph (), __A);
-}
-extern __inline void
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_store_sh (_Float16 const* __A, __mmask8 __B, __m128h __C)
-{
-  __builtin_ia32_storesh_mask (__A, __C, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_move_sh (__m128h __A, __m128h __B)
-{
-  __A[0] = __B[0];
-  return __A;
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_move_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return __builtin_ia32_vmovsh_mask (__C, __D, __A, __B);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_move_sh (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return __builtin_ia32_vmovsh_mask (__B, __C, _mm_setzero_ph (), __A);
-}
 extern __inline __m512i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_cvtph_epi32 (__m256h __A)
@@ -3220,193 +4308,6 @@ _mm512_maskz_cvt_roundepu16_ph (__mmask32 __A, __m512i __B, int __C)
 #define _mm512_mask_cvt_roundepu16_ph(A, B, C, D) (__builtin_ia32_vcvtuw2ph512_mask_round ((__v32hi)(C), (A), (B), (D)))
 #define _mm512_maskz_cvt_roundepu16_ph(A, B, C) (__builtin_ia32_vcvtuw2ph512_mask_round ((__v32hi)(B), _mm512_setzero_ph (), (A), (C)))
 #endif
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsh_i32 (__m128h __A)
-{
-  return (int) __builtin_ia32_vcvtsh2si32_round (__A, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsh_u32 (__m128h __A)
-{
-  return (int) __builtin_ia32_vcvtsh2usi32_round (__A,
-        _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsh_i32 (__m128h __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvtsh2si32_round (__A, __R);
-}
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsh_u32 (__m128h __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvtsh2usi32_round (__A, __R);
-}
-#else
-#define _mm_cvt_roundsh_i32(A, B) ((int)__builtin_ia32_vcvtsh2si32_round ((A), (B)))
-#define _mm_cvt_roundsh_u32(A, B) ((int)__builtin_ia32_vcvtsh2usi32_round ((A), (B)))
-#endif
-#ifdef __x86_64__
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsh_i64 (__m128h __A)
-{
-  return (long long)
-    __builtin_ia32_vcvtsh2si64_round (__A, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsh_u64 (__m128h __A)
-{
-  return (long long)
-    __builtin_ia32_vcvtsh2usi64_round (__A, _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsh_i64 (__m128h __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvtsh2si64_round (__A, __R);
-}
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsh_u64 (__m128h __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvtsh2usi64_round (__A, __R);
-}
-#else
-#define _mm_cvt_roundsh_i64(A, B) ((long long)__builtin_ia32_vcvtsh2si64_round ((A), (B)))
-#define _mm_cvt_roundsh_u64(A, B) ((long long)__builtin_ia32_vcvtsh2usi64_round ((A), (B)))
-#endif
-#endif
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttsh_i32 (__m128h __A)
-{
-  return (int)
-    __builtin_ia32_vcvttsh2si32_round (__A, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttsh_u32 (__m128h __A)
-{
-  return (int)
-    __builtin_ia32_vcvttsh2usi32_round (__A, _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline int
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundsh_i32 (__m128h __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvttsh2si32_round (__A, __R);
-}
-extern __inline unsigned
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundsh_u32 (__m128h __A, const int __R)
-{
-  return (int) __builtin_ia32_vcvttsh2usi32_round (__A, __R);
-}
-#else
-#define _mm_cvtt_roundsh_i32(A, B) ((int)__builtin_ia32_vcvttsh2si32_round ((A), (B)))
-#define _mm_cvtt_roundsh_u32(A, B) ((int)__builtin_ia32_vcvttsh2usi32_round ((A), (B)))
-#endif
-#ifdef __x86_64__
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttsh_i64 (__m128h __A)
-{
-  return (long long)
-    __builtin_ia32_vcvttsh2si64_round (__A, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvttsh_u64 (__m128h __A)
-{
-  return (long long)
-    __builtin_ia32_vcvttsh2usi64_round (__A, _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundsh_i64 (__m128h __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvttsh2si64_round (__A, __R);
-}
-extern __inline unsigned long long
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtt_roundsh_u64 (__m128h __A, const int __R)
-{
-  return (long long) __builtin_ia32_vcvttsh2usi64_round (__A, __R);
-}
-#else
-#define _mm_cvtt_roundsh_i64(A, B) ((long long)__builtin_ia32_vcvttsh2si64_round ((A), (B)))
-#define _mm_cvtt_roundsh_u64(A, B) ((long long)__builtin_ia32_vcvttsh2usi64_round ((A), (B)))
-#endif
-#endif
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvti32_sh (__m128h __A, int __B)
-{
-  return __builtin_ia32_vcvtsi2sh32_round (__A, __B, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtu32_sh (__m128h __A, unsigned int __B)
-{
-  return __builtin_ia32_vcvtusi2sh32_round (__A, __B, _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundi32_sh (__m128h __A, int __B, const int __R)
-{
-  return __builtin_ia32_vcvtsi2sh32_round (__A, __B, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundu32_sh (__m128h __A, unsigned int __B, const int __R)
-{
-  return __builtin_ia32_vcvtusi2sh32_round (__A, __B, __R);
-}
-#else
-#define _mm_cvt_roundi32_sh(A, B, C) (__builtin_ia32_vcvtsi2sh32_round ((A), (B), (C)))
-#define _mm_cvt_roundu32_sh(A, B, C) (__builtin_ia32_vcvtusi2sh32_round ((A), (B), (C)))
-#endif
-#ifdef __x86_64__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvti64_sh (__m128h __A, long long __B)
-{
-  return __builtin_ia32_vcvtsi2sh64_round (__A, __B, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtu64_sh (__m128h __A, unsigned long long __B)
-{
-  return __builtin_ia32_vcvtusi2sh64_round (__A, __B, _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundi64_sh (__m128h __A, long long __B, const int __R)
-{
-  return __builtin_ia32_vcvtsi2sh64_round (__A, __B, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundu64_sh (__m128h __A, unsigned long long __B, const int __R)
-{
-  return __builtin_ia32_vcvtusi2sh64_round (__A, __B, __R);
-}
-#else
-#define _mm_cvt_roundi64_sh(A, B, C) (__builtin_ia32_vcvtsi2sh64_round ((A), (B), (C)))
-#define _mm_cvt_roundu64_sh(A, B, C) (__builtin_ia32_vcvtusi2sh64_round ((A), (B), (C)))
-#endif
-#endif
 extern __inline __m512d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_cvtph_pd (__m128h __A)
@@ -3629,218 +4530,6 @@ _mm512_maskz_cvt_roundpd_ph (__mmask8 __A, __m512d __B, int __C)
 #define _mm512_mask_cvt_roundpd_ph(A, B, C, D) (__builtin_ia32_vcvtpd2ph512_mask_round ((__v8df)(C), (A), (B), (D)))
 #define _mm512_maskz_cvt_roundpd_ph(A, B, C) (__builtin_ia32_vcvtpd2ph512_mask_round ((__v8df)(B), _mm_setzero_ph (), (A), (C)))
 #endif
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsh_ss (__m128 __A, __m128h __B)
-{
-  return __builtin_ia32_vcvtsh2ss_mask_round (__B, __A,
-           _mm_setzero_ps (),
-           (__mmask8) -1,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cvtsh_ss (__m128 __A, __mmask8 __B, __m128 __C,
-    __m128h __D)
-{
-  return __builtin_ia32_vcvtsh2ss_mask_round (__D, __C, __A, __B,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_cvtsh_ss (__mmask8 __A, __m128 __B,
-     __m128h __C)
-{
-  return __builtin_ia32_vcvtsh2ss_mask_round (__C, __B,
-           _mm_setzero_ps (),
-           __A, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsh_sd (__m128d __A, __m128h __B)
-{
-  return __builtin_ia32_vcvtsh2sd_mask_round (__B, __A,
-           _mm_setzero_pd (),
-           (__mmask8) -1,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cvtsh_sd (__m128d __A, __mmask8 __B, __m128d __C,
-    __m128h __D)
-{
-  return __builtin_ia32_vcvtsh2sd_mask_round (__D, __C, __A, __B,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_cvtsh_sd (__mmask8 __A, __m128d __B, __m128h __C)
-{
-  return __builtin_ia32_vcvtsh2sd_mask_round (__C, __B,
-           _mm_setzero_pd (),
-           __A, _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsh_ss (__m128 __A, __m128h __B, const int __R)
-{
-  return __builtin_ia32_vcvtsh2ss_mask_round (__B, __A,
-           _mm_setzero_ps (),
-           (__mmask8) -1, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cvt_roundsh_ss (__m128 __A, __mmask8 __B, __m128 __C,
-    __m128h __D, const int __R)
-{
-  return __builtin_ia32_vcvtsh2ss_mask_round (__D, __C, __A, __B, __R);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_cvt_roundsh_ss (__mmask8 __A, __m128 __B,
-     __m128h __C, const int __R)
-{
-  return __builtin_ia32_vcvtsh2ss_mask_round (__C, __B,
-           _mm_setzero_ps (),
-           __A, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsh_sd (__m128d __A, __m128h __B, const int __R)
-{
-  return __builtin_ia32_vcvtsh2sd_mask_round (__B, __A,
-           _mm_setzero_pd (),
-           (__mmask8) -1, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cvt_roundsh_sd (__m128d __A, __mmask8 __B, __m128d __C,
-    __m128h __D, const int __R)
-{
-  return __builtin_ia32_vcvtsh2sd_mask_round (__D, __C, __A, __B, __R);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_cvt_roundsh_sd (__mmask8 __A, __m128d __B, __m128h __C, const int __R)
-{
-  return __builtin_ia32_vcvtsh2sd_mask_round (__C, __B,
-           _mm_setzero_pd (),
-           __A, __R);
-}
-#else
-#define _mm_cvt_roundsh_ss(A, B, R) (__builtin_ia32_vcvtsh2ss_mask_round ((B), (A), _mm_setzero_ps (), (__mmask8) -1, (R)))
-#define _mm_mask_cvt_roundsh_ss(A, B, C, D, R) (__builtin_ia32_vcvtsh2ss_mask_round ((D), (C), (A), (B), (R)))
-#define _mm_maskz_cvt_roundsh_ss(A, B, C, R) (__builtin_ia32_vcvtsh2ss_mask_round ((C), (B), _mm_setzero_ps (), (A), (R)))
-#define _mm_cvt_roundsh_sd(A, B, R) (__builtin_ia32_vcvtsh2sd_mask_round ((B), (A), _mm_setzero_pd (), (__mmask8) -1, (R)))
-#define _mm_mask_cvt_roundsh_sd(A, B, C, D, R) (__builtin_ia32_vcvtsh2sd_mask_round ((D), (C), (A), (B), (R)))
-#define _mm_maskz_cvt_roundsh_sd(A, B, C, R) (__builtin_ia32_vcvtsh2sd_mask_round ((C), (B), _mm_setzero_pd (), (A), (R)))
-#endif
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtss_sh (__m128h __A, __m128 __B)
-{
-  return __builtin_ia32_vcvtss2sh_mask_round (__B, __A,
-           _mm_setzero_ph (),
-           (__mmask8) -1,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cvtss_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128 __D)
-{
-  return __builtin_ia32_vcvtss2sh_mask_round (__D, __C, __A, __B,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_cvtss_sh (__mmask8 __A, __m128h __B, __m128 __C)
-{
-  return __builtin_ia32_vcvtss2sh_mask_round (__C, __B,
-           _mm_setzero_ph (),
-           __A, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvtsd_sh (__m128h __A, __m128d __B)
-{
-  return __builtin_ia32_vcvtsd2sh_mask_round (__B, __A,
-           _mm_setzero_ph (),
-           (__mmask8) -1,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cvtsd_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128d __D)
-{
-  return __builtin_ia32_vcvtsd2sh_mask_round (__D, __C, __A, __B,
-           _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_cvtsd_sh (__mmask8 __A, __m128h __B, __m128d __C)
-{
-  return __builtin_ia32_vcvtsd2sh_mask_round (__C, __B,
-           _mm_setzero_ph (),
-           __A, _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundss_sh (__m128h __A, __m128 __B, const int __R)
-{
-  return __builtin_ia32_vcvtss2sh_mask_round (__B, __A,
-           _mm_setzero_ph (),
-           (__mmask8) -1, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cvt_roundss_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128 __D,
-    const int __R)
-{
-  return __builtin_ia32_vcvtss2sh_mask_round (__D, __C, __A, __B, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_cvt_roundss_sh (__mmask8 __A, __m128h __B, __m128 __C,
-     const int __R)
-{
-  return __builtin_ia32_vcvtss2sh_mask_round (__C, __B,
-           _mm_setzero_ph (),
-           __A, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_cvt_roundsd_sh (__m128h __A, __m128d __B, const int __R)
-{
-  return __builtin_ia32_vcvtsd2sh_mask_round (__B, __A,
-           _mm_setzero_ph (),
-           (__mmask8) -1, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_cvt_roundsd_sh (__m128h __A, __mmask8 __B, __m128h __C, __m128d __D,
-    const int __R)
-{
-  return __builtin_ia32_vcvtsd2sh_mask_round (__D, __C, __A, __B, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_cvt_roundsd_sh (__mmask8 __A, __m128h __B, __m128d __C,
-     const int __R)
-{
-  return __builtin_ia32_vcvtsd2sh_mask_round (__C, __B,
-           _mm_setzero_ph (),
-           __A, __R);
-}
-#else
-#define _mm_cvt_roundss_sh(A, B, R) (__builtin_ia32_vcvtss2sh_mask_round ((B), (A), _mm_setzero_ph (), (__mmask8) -1, R))
-#define _mm_mask_cvt_roundss_sh(A, B, C, D, R) (__builtin_ia32_vcvtss2sh_mask_round ((D), (C), (A), (B), (R)))
-#define _mm_maskz_cvt_roundss_sh(A, B, C, R) (__builtin_ia32_vcvtss2sh_mask_round ((C), (B), _mm_setzero_ph (), A, R))
-#define _mm_cvt_roundsd_sh(A, B, R) (__builtin_ia32_vcvtsd2sh_mask_round ((B), (A), _mm_setzero_ph (), (__mmask8) -1, R))
-#define _mm_mask_cvt_roundsd_sh(A, B, C, D, R) (__builtin_ia32_vcvtsd2sh_mask_round ((D), (C), (A), (B), (R)))
-#define _mm_maskz_cvt_roundsd_sh(A, B, C, R) (__builtin_ia32_vcvtsd2sh_mask_round ((C), (B), _mm_setzero_ph (), (A), (R)))
-#endif
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_fmaddsub_ph (__m512h __A, __m512h __B, __m512h __C)
@@ -4393,354 +5082,6 @@ _mm512_maskz_fnmsub_round_ph (__mmask32 __U, __m512h __A, __m512h __B,
 #define _mm512_mask3_fnmsub_round_ph(A, B, C, U, R) ((__m512h)__builtin_ia32_vfnmsubph512_mask3 ((A), (B), (C), (U), (R)))
 #define _mm512_maskz_fnmsub_round_ph(U, A, B, C, R) ((__m512h)__builtin_ia32_vfnmsubph512_maskz ((A), (B), (C), (U), (R)))
 #endif
-extern __inline __m128h
-  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmadd_sh (__m128h __W, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        (__v8hf) __A,
-        (__v8hf) __B,
-        (__mmask8) -1,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmadd_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        (__v8hf) __A,
-        (__v8hf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmadd_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask3 ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmadd_sh (__mmask8 __U, __m128h __W, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmadd_round_sh (__m128h __W, __m128h __A, __m128h __B, const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        (__v8hf) __A,
-        (__v8hf) __B,
-        (__mmask8) -1,
-        __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmadd_round_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B,
-    const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        (__v8hf) __A,
-        (__v8hf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmadd_round_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask3 ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmadd_round_sh (__mmask8 __U, __m128h __W, __m128h __A,
-     __m128h __B, const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U, __R);
-}
-#else
-#define _mm_fmadd_round_sh(A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), (B), (C), (-1), (R)))
-#define _mm_mask_fmadd_round_sh(A, U, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), (B), (C), (U), (R)))
-#define _mm_mask3_fmadd_round_sh(A, B, C, U, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask3 ((A), (B), (C), (U), (R)))
-#define _mm_maskz_fmadd_round_sh(U, A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_maskz ((A), (B), (C), (U), (R)))
-#endif
-extern __inline __m128h
-  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fnmadd_sh (__m128h __W, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfnmaddsh3_mask ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) -1,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmadd_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfnmaddsh3_mask ((__v8hf) __W,
-        (__v8hf) __A,
-        (__v8hf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmadd_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U)
-{
-  return (__m128h) __builtin_ia32_vfnmaddsh3_mask3 ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmadd_sh (__mmask8 __U, __m128h __W, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfnmaddsh3_maskz ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fnmadd_round_sh (__m128h __W, __m128h __A, __m128h __B, const int __R)
-{
-  return (__m128h) __builtin_ia32_vfnmaddsh3_mask ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) -1,
-         __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmadd_round_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B,
-    const int __R)
-{
-  return (__m128h) __builtin_ia32_vfnmaddsh3_mask ((__v8hf) __W,
-        (__v8hf) __A,
-        (__v8hf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmadd_round_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128h) __builtin_ia32_vfnmaddsh3_mask3 ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmadd_round_sh (__mmask8 __U, __m128h __W, __m128h __A,
-     __m128h __B, const int __R)
-{
-  return (__m128h) __builtin_ia32_vfnmaddsh3_maskz ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U, __R);
-}
-#else
-#define _mm_fnmadd_round_sh(A, B, C, R) ((__m128h) __builtin_ia32_vfnmaddsh3_mask ((A), (B), (C), (-1), (R)))
-#define _mm_mask_fnmadd_round_sh(A, U, B, C, R) ((__m128h) __builtin_ia32_vfnmaddsh3_mask ((A), (B), (C), (U), (R)))
-#define _mm_mask3_fnmadd_round_sh(A, B, C, U, R) ((__m128h) __builtin_ia32_vfnmaddsh3_mask3 ((A), (B), (C), (U), (R)))
-#define _mm_maskz_fnmadd_round_sh(U, A, B, C, R) ((__m128h) __builtin_ia32_vfnmaddsh3_maskz ((A), (B), (C), (U), (R)))
-#endif
-extern __inline __m128h
-  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmsub_sh (__m128h __W, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        (__v8hf) __A,
-        -(__v8hf) __B,
-        (__mmask8) -1,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmsub_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        (__v8hf) __A,
-        -(__v8hf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmsub_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U)
-{
-  return (__m128h) __builtin_ia32_vfmsubsh3_mask3 ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmsub_sh (__mmask8 __U, __m128h __W, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
-         (__v8hf) __A,
-         -(__v8hf) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmsub_round_sh (__m128h __W, __m128h __A, __m128h __B, const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        (__v8hf) __A,
-        -(__v8hf) __B,
-        (__mmask8) -1,
-        __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmsub_round_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B,
-    const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        (__v8hf) __A,
-        -(__v8hf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmsub_round_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmsubsh3_mask3 ((__v8hf) __W,
-         (__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmsub_round_sh (__mmask8 __U, __m128h __W, __m128h __A,
-     __m128h __B, const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
-         (__v8hf) __A,
-         -(__v8hf) __B,
-         (__mmask8) __U, __R);
-}
-#else
-#define _mm_fmsub_round_sh(A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), (B), -(C), (-1), (R)))
-#define _mm_mask_fmsub_round_sh(A, U, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), (B), -(C), (U), (R)))
-#define _mm_mask3_fmsub_round_sh(A, B, C, U, R) ((__m128h) __builtin_ia32_vfmsubsh3_mask3 ((A), (B), (C), (U), (R)))
-#define _mm_maskz_fmsub_round_sh(U, A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_maskz ((A), (B), -(C), (U), (R)))
-#endif
-extern __inline __m128h
-  __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fnmsub_sh (__m128h __W, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        -(__v8hf) __A,
-        -(__v8hf) __B,
-        (__mmask8) -1,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmsub_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        -(__v8hf) __A,
-        -(__v8hf) __B,
-        (__mmask8) __U,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmsub_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U)
-{
-  return (__m128h) __builtin_ia32_vfmsubsh3_mask3 ((__v8hf) __W,
-         -(__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmsub_sh (__mmask8 __U, __m128h __W, __m128h __A, __m128h __B)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
-         -(__v8hf) __A,
-         -(__v8hf) __B,
-         (__mmask8) __U,
-         _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fnmsub_round_sh (__m128h __W, __m128h __A, __m128h __B, const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        -(__v8hf) __A,
-        -(__v8hf) __B,
-        (__mmask8) -1,
-        __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fnmsub_round_sh (__m128h __W, __mmask8 __U, __m128h __A, __m128h __B,
-    const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_mask ((__v8hf) __W,
-        -(__v8hf) __A,
-        -(__v8hf) __B,
-        (__mmask8) __U, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fnmsub_round_sh (__m128h __W, __m128h __A, __m128h __B, __mmask8 __U,
-     const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmsubsh3_mask3 ((__v8hf) __W,
-         -(__v8hf) __A,
-         (__v8hf) __B,
-         (__mmask8) __U, __R);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fnmsub_round_sh (__mmask8 __U, __m128h __W, __m128h __A,
-     __m128h __B, const int __R)
-{
-  return (__m128h) __builtin_ia32_vfmaddsh3_maskz ((__v8hf) __W,
-         -(__v8hf) __A,
-         -(__v8hf) __B,
-         (__mmask8) __U, __R);
-}
-#else
-#define _mm_fnmsub_round_sh(A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), -(B), -(C), (-1), (R)))
-#define _mm_mask_fnmsub_round_sh(A, U, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_mask ((A), -(B), -(C), (U), (R)))
-#define _mm_mask3_fnmsub_round_sh(A, B, C, U, R) ((__m128h) __builtin_ia32_vfmsubsh3_mask3 ((A), -(B), (C), (U), (R)))
-#define _mm_maskz_fnmsub_round_sh(U, A, B, C, R) ((__m128h) __builtin_ia32_vfmaddsh3_maskz ((A), -(B), -(C), (U), (R)))
-#endif
 extern __inline __m512h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_fcmadd_pch (__m512h __A, __m512h __B, __m512h __C)
@@ -5046,310 +5387,6 @@ _mm512_maskz_fmul_round_pch (__mmask16 __A, __m512h __B,
 #define _mm512_mask_fmul_round_pch(A, B, C, D, E) (__m512h) __builtin_ia32_vfmulcph512_mask_round ((C), (D), (A), (B), (E))
 #define _mm512_maskz_fmul_round_pch(A, B, C, E) (__m512h) __builtin_ia32_vfmulcph512_mask_round ((B), (C), (__v32hf) _mm512_setzero_ph (), (A), (E))
 #endif
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fcmadd_sch (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmaddcsh_mask_round ((__v8hf) __A,
-       (__v8hf) __C,
-       (__v8hf) __D, __B,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fcmadd_sch (__m128h __A, __m128h __B, __m128h __C, __mmask8 __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmaddcsh_mask3_round ((__v8hf) __A,
-        (__v8hf) __B,
-        (__v8hf) __C, __D,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fcmadd_sch (__mmask8 __A, __m128h __B, __m128h __C, __m128h __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmaddcsh_maskz_round ((__v8hf) __B,
-        (__v8hf) __C,
-        (__v8hf) __D,
-        __A, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fcmadd_sch (__m128h __A, __m128h __B, __m128h __C)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmaddcsh_round ((__v8hf) __A,
-         (__v8hf) __B,
-         (__v8hf) __C,
-         _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmadd_sch (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfmaddcsh_mask_round ((__v8hf) __A,
-      (__v8hf) __C,
-      (__v8hf) __D, __B,
-      _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmadd_sch (__m128h __A, __m128h __B, __m128h __C, __mmask8 __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfmaddcsh_mask3_round ((__v8hf) __A,
-       (__v8hf) __B,
-       (__v8hf) __C, __D,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmadd_sch (__mmask8 __A, __m128h __B, __m128h __C, __m128h __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfmaddcsh_maskz_round ((__v8hf) __B,
-       (__v8hf) __C,
-       (__v8hf) __D,
-       __A, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmadd_sch (__m128h __A, __m128h __B, __m128h __C)
-{
-  return (__m128h)
-    __builtin_ia32_vfmaddcsh_round ((__v8hf) __A,
-        (__v8hf) __B,
-        (__v8hf) __C,
-        _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fcmadd_round_sch (__m128h __A, __mmask8 __B, __m128h __C,
-      __m128h __D, const int __E)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmaddcsh_mask_round ((__v8hf) __A,
-       (__v8hf) __C,
-       (__v8hf) __D,
-       __B, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fcmadd_round_sch (__m128h __A, __m128h __B, __m128h __C,
-       __mmask8 __D, const int __E)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmaddcsh_mask3_round ((__v8hf) __A,
-        (__v8hf) __B,
-        (__v8hf) __C,
-        __D, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fcmadd_round_sch (__mmask8 __A, __m128h __B, __m128h __C,
-       __m128h __D, const int __E)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmaddcsh_maskz_round ((__v8hf) __B,
-        (__v8hf) __C,
-        (__v8hf) __D,
-        __A, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fcmadd_round_sch (__m128h __A, __m128h __B, __m128h __C, const int __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmaddcsh_round ((__v8hf) __A,
-         (__v8hf) __B,
-         (__v8hf) __C,
-         __D);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmadd_round_sch (__m128h __A, __mmask8 __B, __m128h __C,
-     __m128h __D, const int __E)
-{
-  return (__m128h)
-    __builtin_ia32_vfmaddcsh_mask_round ((__v8hf) __A,
-      (__v8hf) __C,
-      (__v8hf) __D,
-      __B, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask3_fmadd_round_sch (__m128h __A, __m128h __B, __m128h __C,
-      __mmask8 __D, const int __E)
-{
-  return (__m128h)
-    __builtin_ia32_vfmaddcsh_mask3_round ((__v8hf) __A,
-       (__v8hf) __B,
-       (__v8hf) __C,
-       __D, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmadd_round_sch (__mmask8 __A, __m128h __B, __m128h __C,
-      __m128h __D, const int __E)
-{
-  return (__m128h)
-    __builtin_ia32_vfmaddcsh_maskz_round ((__v8hf) __B,
-       (__v8hf) __C,
-       (__v8hf) __D,
-       __A, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmadd_round_sch (__m128h __A, __m128h __B, __m128h __C, const int __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfmaddcsh_round ((__v8hf) __A,
-        (__v8hf) __B,
-        (__v8hf) __C,
-        __D);
-}
-#else
-#define _mm_mask_fcmadd_round_sch(A, B, C, D, E) ((__m128h) __builtin_ia32_vfcmaddcsh_mask_round ((__v8hf) (A), (__v8hf) (C), (__v8hf) (D), (B), (E)))
-#define _mm_mask3_fcmadd_round_sch(A, B, C, D, E) ((__m128h) __builtin_ia32_vfcmaddcsh_mask3_round ((__v8hf) (A), (__v8hf) (B), (__v8hf) (C), (D), (E)))
-#define _mm_maskz_fcmadd_round_sch(A, B, C, D, E) __builtin_ia32_vfcmaddcsh_maskz_round ((B), (C), (D), (A), (E))
-#define _mm_fcmadd_round_sch(A, B, C, D) __builtin_ia32_vfcmaddcsh_round ((A), (B), (C), (D))
-#define _mm_mask_fmadd_round_sch(A, B, C, D, E) ((__m128h) __builtin_ia32_vfmaddcsh_mask_round ((__v8hf) (A), (__v8hf) (C), (__v8hf) (D), (B), (E)))
-#define _mm_mask3_fmadd_round_sch(A, B, C, D, E) ((__m128h) __builtin_ia32_vfmaddcsh_mask3_round ((__v8hf) (A), (__v8hf) (B), (__v8hf) (C), (D), (E)))
-#define _mm_maskz_fmadd_round_sch(A, B, C, D, E) __builtin_ia32_vfmaddcsh_maskz_round ((B), (C), (D), (A), (E))
-#define _mm_fmadd_round_sch(A, B, C, D) __builtin_ia32_vfmaddcsh_round ((A), (B), (C), (D))
-#endif
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fcmul_sch (__m128h __A, __m128h __B)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmulcsh_round ((__v8hf) __A,
-        (__v8hf) __B,
-        _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fcmul_sch (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __C,
-      (__v8hf) __D,
-      (__v8hf) __A,
-      __B, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fcmul_sch (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __B,
-      (__v8hf) __C,
-      _mm_setzero_ph (),
-      __A, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmul_sch (__m128h __A, __m128h __B)
-{
-  return (__m128h)
-    __builtin_ia32_vfmulcsh_round ((__v8hf) __A,
-       (__v8hf) __B,
-       _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmul_sch (__m128h __A, __mmask8 __B, __m128h __C, __m128h __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __C,
-     (__v8hf) __D,
-     (__v8hf) __A,
-     __B, _MM_FROUND_CUR_DIRECTION);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmul_sch (__mmask8 __A, __m128h __B, __m128h __C)
-{
-  return (__m128h)
-    __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __B,
-     (__v8hf) __C,
-     _mm_setzero_ph (),
-     __A, _MM_FROUND_CUR_DIRECTION);
-}
-#ifdef __OPTIMIZE__
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fcmul_round_sch (__m128h __A, __m128h __B, const int __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmulcsh_round ((__v8hf) __A,
-        (__v8hf) __B,
-        __D);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fcmul_round_sch (__m128h __A, __mmask8 __B, __m128h __C,
-     __m128h __D, const int __E)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __C,
-      (__v8hf) __D,
-      (__v8hf) __A,
-      __B, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fcmul_round_sch (__mmask8 __A, __m128h __B, __m128h __C,
-      const int __E)
-{
-  return (__m128h)
-    __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __B,
-      (__v8hf) __C,
-      _mm_setzero_ph (),
-      __A, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_fmul_round_sch (__m128h __A, __m128h __B, const int __D)
-{
-  return (__m128h)
-    __builtin_ia32_vfmulcsh_round ((__v8hf) __A,
-       (__v8hf) __B, __D);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_fmul_round_sch (__m128h __A, __mmask8 __B, __m128h __C,
-    __m128h __D, const int __E)
-{
-  return (__m128h)
-    __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __C,
-     (__v8hf) __D,
-     (__v8hf) __A,
-     __B, __E);
-}
-extern __inline __m128h
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_fmul_round_sch (__mmask8 __A, __m128h __B, __m128h __C, const int __E)
-{
-  return (__m128h)
-    __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __B,
-     (__v8hf) __C,
-     _mm_setzero_ph (),
-     __A, __E);
-}
-#else
-#define _mm_fcmul_round_sch(__A, __B, __D) (__m128h) __builtin_ia32_vfcmulcsh_round ((__v8hf) __A, (__v8hf) __B, __D)
-#define _mm_mask_fcmul_round_sch(__A, __B, __C, __D, __E) (__m128h) __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __C, (__v8hf) __D, (__v8hf) __A, __B, __E)
-#define _mm_maskz_fcmul_round_sch(__A, __B, __C, __E) (__m128h) __builtin_ia32_vfcmulcsh_mask_round ((__v8hf) __B, (__v8hf) __C, _mm_setzero_ph (), __A, __E)
-#define _mm_fmul_round_sch(__A, __B, __D) (__m128h) __builtin_ia32_vfmulcsh_round ((__v8hf) __A, (__v8hf) __B, __D)
-#define _mm_mask_fmul_round_sch(__A, __B, __C, __D, __E) (__m128h) __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __C, (__v8hf) __D, (__v8hf) __A, __B, __E)
-#define _mm_maskz_fmul_round_sch(__A, __B, __C, __E) (__m128h) __builtin_ia32_vfmulcsh_mask_round ((__v8hf) __B, (__v8hf) __C, _mm_setzero_ph (), __A, __E)
-#endif
 #define _MM512_REDUCE_OP(op) __m256h __T1 = (__m256h) _mm512_extractf64x4_pd ((__m512d) __A, 0); __m256h __T2 = (__m256h) _mm512_extractf64x4_pd ((__m512d) __A, 1); __m256h __T3 = (__T1 op __T2); __m128h __T4 = (__m128h) _mm256_extractf128_pd ((__m256d) __T3, 0); __m128h __T5 = (__m128h) _mm256_extractf128_pd ((__m256d) __T3, 1); __m128h __T6 = (__T4 op __T5); __m128h __T7 = (__m128h) __builtin_shuffle ((__m128h)__T6, (__v8hi) { 4, 5, 6, 7, 0, 1, 2, 3 }); __m128h __T8 = (__T6 op __T7); __m128h __T9 = (__m128h) __builtin_shuffle ((__m128h)__T8, (__v8hi) { 2, 3, 0, 1, 4, 5, 6, 7 }); __m128h __T10 = __T8 op __T9; return __T10[0] op __T10[1]
 extern __inline _Float16
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -5415,10 +5452,10 @@ _mm512_set1_pch (_Float16 _Complex __A)
 {
   union
   {
-    _Float16 _Complex a;
-    float b;
-  } u = { .a = __A};
-  return (__m512h) _mm512_set1_ps (u.b);
+    _Float16 _Complex __a;
+    float __b;
+  } __u = { .__a = __A};
+  return (__m512h) _mm512_set1_ps (__u.__b);
 }
 #define _mm512_mul_pch(A, B) _mm512_fmul_pch ((A), (B))
 #define _mm512_mask_mul_pch(W, U, A, B) _mm512_mask_fmul_pch ((W), (U), (A), (B))
@@ -5432,20 +5469,8 @@ _mm512_set1_pch (_Float16 _Complex __A)
 #define _mm512_cmul_round_pch(A, B, R) _mm512_fcmul_round_pch ((A), (B), (R))
 #define _mm512_mask_cmul_round_pch(W, U, A, B, R) _mm512_mask_fcmul_round_pch ((W), (U), (A), (B), (R))
 #define _mm512_maskz_cmul_round_pch(U, A, B, R) _mm512_maskz_fcmul_round_pch ((U), (A), (B), (R))
-#define _mm_mul_sch(A, B) _mm_fmul_sch ((A), (B))
-#define _mm_mask_mul_sch(W, U, A, B) _mm_mask_fmul_sch ((W), (U), (A), (B))
-#define _mm_maskz_mul_sch(U, A, B) _mm_maskz_fmul_sch ((U), (A), (B))
-#define _mm_mul_round_sch(A, B, R) _mm_fmul_round_sch ((A), (B), (R))
-#define _mm_mask_mul_round_sch(W, U, A, B, R) _mm_mask_fmul_round_sch ((W), (U), (A), (B), (R))
-#define _mm_maskz_mul_round_sch(U, A, B, R) _mm_maskz_fmul_round_sch ((U), (A), (B), (R))
-#define _mm_cmul_sch(A, B) _mm_fcmul_sch ((A), (B))
-#define _mm_mask_cmul_sch(W, U, A, B) _mm_mask_fcmul_sch ((W), (U), (A), (B))
-#define _mm_maskz_cmul_sch(U, A, B) _mm_maskz_fcmul_sch ((U), (A), (B))
-#define _mm_cmul_round_sch(A, B, R) _mm_fcmul_round_sch ((A), (B), (R))
-#define _mm_mask_cmul_round_sch(W, U, A, B, R) _mm_mask_fcmul_round_sch ((W), (U), (A), (B), (R))
-#define _mm_maskz_cmul_round_sch(U, A, B, R) _mm_maskz_fcmul_round_sch ((U), (A), (B), (R))
-#ifdef __DISABLE_AVX512FP16__
-#undef __DISABLE_AVX512FP16__
+#ifdef __DISABLE_AVX512FP16_512__
+#undef __DISABLE_AVX512FP16_512__
 #pragma GCC pop_options
 #endif
 #endif
diff --git a/third_party/intel/avx512fp16vlintrin.internal.h b/third_party/intel/avx512fp16vlintrin.internal.h
index d42a041a9..f994366a6 100644
--- a/third_party/intel/avx512fp16vlintrin.internal.h
+++ b/third_party/intel/avx512fp16vlintrin.internal.h
@@ -4,11 +4,33 @@
 #endif
 #ifndef __AVX512FP16VLINTRIN_H_INCLUDED
 #define __AVX512FP16VLINTRIN_H_INCLUDED
-#if !defined(__AVX512VL__) || !defined(__AVX512FP16__)
+#if !defined(__AVX512VL__) || !defined(__AVX512FP16__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512fp16,avx512vl")
+#pragma GCC target("avx512fp16,avx512vl,no-evex512")
 #define __DISABLE_AVX512FP16VL__
 #endif
+extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_set1_ps (float __F)
+{
+  return __extension__ (__m128)(__v4sf){ __F, __F, __F, __F };
+}
+extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_set1_ps (float __A)
+{
+  return __extension__ (__m256){ __A, __A, __A, __A,
+     __A, __A, __A, __A };
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_and_si128 (__m128i __A, __m128i __B)
+{
+  return (__m128i) ((__v2du)__A & (__v2du)__B);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_and_si256 (__m256i __A, __m256i __B)
+{
+  return (__m256i) ((__v4du)__A & (__v4du)__B);
+}
 extern __inline __m128
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_castph_ps (__m128h __a)
@@ -87,10 +109,10 @@ _mm256_castph256_ph128 (__m256h __A)
 {
   union
   {
-    __m128h a[2];
-    __m256h v;
-  } u = { .v = __A };
-  return u.a[0];
+    __m128h __a[2];
+    __m256h __v;
+  } __u = { .__v = __A };
+  return __u.__a[0];
 }
 extern __inline __m256h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -98,24 +120,24 @@ _mm256_castph128_ph256 (__m128h __A)
 {
   union
   {
-    __m128h a[2];
-    __m256h v;
-  } u;
-  u.a[0] = __A;
-  return u.v;
+    __m128h __a[2];
+    __m256h __v;
+  } __u;
+  __u.__a[0] = __A;
+  return __u.__v;
 }
 extern __inline __m256h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_zextph128_ph256 (__m128h __A)
 {
-  return (__m256h) _mm256_insertf128_ps (_mm256_setzero_ps (),
+  return (__m256h) _mm256_avx512_insertf128_ps (_mm256_avx512_setzero_ps (),
       (__m128) __A, 0);
 }
 extern __inline __m256h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_conj_pch (__m256h __A)
 {
-  return (__m256h) _mm256_xor_epi32 ((__m256i) __A, _mm256_set1_epi32 (1<<31));
+  return (__m256h) _mm256_xor_epi32 ((__m256i) __A, _mm256_avx512_set1_epi32 (1<<31));
 }
 extern __inline __m256h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -133,14 +155,14 @@ _mm256_maskz_conj_pch (__mmask8 __U, __m256h __A)
   return (__m256h) __builtin_ia32_movaps256_mask ((__v8sf)
          _mm256_conj_pch (__A),
         (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
         (__mmask8) __U);
 }
 extern __inline __m128h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_conj_pch (__m128h __A)
 {
-  return (__m128h) _mm_xor_epi32 ((__m128i) __A, _mm_set1_epi32 (1<<31));
+  return (__m128h) _mm_xor_epi32 ((__m128i) __A, _mm_avx512_set1_epi32 (1<<31));
 }
 extern __inline __m128h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -155,7 +177,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_conj_pch (__mmask8 __U, __m128h __A)
 {
   return (__m128h) __builtin_ia32_movaps128_mask ((__v4sf) _mm_conj_pch (__A),
-        (__v4sf) _mm_setzero_ps (),
+        (__v4sf) _mm_avx512_setzero_ps (),
         (__mmask8) __U);
 }
 extern __inline __m128h
@@ -398,15 +420,15 @@ extern __inline __m128h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_abs_ph (__m128h __A)
 {
-  return (__m128h) _mm_and_si128 ( _mm_set1_epi32 (0x7FFF7FFF),
-       (__m128i) __A);
+  return (__m128h) _mm_avx512_and_si128 (_mm_avx512_set1_epi32 (0x7FFF7FFF),
+      (__m128i) __A);
 }
 extern __inline __m256h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_abs_ph (__m256h __A)
 {
-  return (__m256h) _mm256_and_si256 ( _mm256_set1_epi32 (0x7FFF7FFF),
-          (__m256i) __A);
+  return (__m256h) _mm256_avx512_and_si256 (_mm256_avx512_set1_epi32 (0x7FFF7FFF),
+         (__m256i) __A);
 }
 #ifdef __OPTIMIZE
 extern __inline __mmask8
@@ -884,7 +906,7 @@ _mm_cvtph_epi32 (__m128h __A)
   return (__m128i)
     __builtin_ia32_vcvtph2dq128_mask (__A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) -1);
 }
 extern __inline __m128i
@@ -900,7 +922,7 @@ _mm_maskz_cvtph_epi32 (__mmask8 __A, __m128h __B)
 {
   return (__m128i)
     __builtin_ia32_vcvtph2dq128_mask (__B,
-          (__v4si) _mm_setzero_si128 (),
+          (__v4si) _mm_avx512_setzero_si128 (),
           __A);
 }
 extern __inline __m256i
@@ -910,7 +932,7 @@ _mm256_cvtph_epi32 (__m128h __A)
   return (__m256i)
     __builtin_ia32_vcvtph2dq256_mask (__A,
           (__v8si)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) -1);
 }
 extern __inline __m256i
@@ -927,7 +949,7 @@ _mm256_maskz_cvtph_epi32 (__mmask8 __A, __m128h __B)
   return (__m256i)
     __builtin_ia32_vcvtph2dq256_mask (__B,
           (__v8si)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __A);
 }
 extern __inline __m128i
@@ -937,7 +959,7 @@ _mm_cvtph_epu32 (__m128h __A)
   return (__m128i)
     __builtin_ia32_vcvtph2udq128_mask (__A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -954,7 +976,7 @@ _mm_maskz_cvtph_epu32 (__mmask8 __A, __m128h __B)
   return (__m128i)
     __builtin_ia32_vcvtph2udq128_mask (__B,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            __A);
 }
 extern __inline __m256i
@@ -964,7 +986,7 @@ _mm256_cvtph_epu32 (__m128h __A)
   return (__m256i)
     __builtin_ia32_vcvtph2udq256_mask (__A,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) -1);
 }
 extern __inline __m256i
@@ -980,7 +1002,7 @@ _mm256_maskz_cvtph_epu32 (__mmask8 __A, __m128h __B)
 {
   return (__m256i)
     __builtin_ia32_vcvtph2udq256_mask (__B,
-           (__v8si) _mm256_setzero_si256 (),
+           (__v8si) _mm256_avx512_setzero_si256 (),
            __A);
 }
 extern __inline __m128i
@@ -989,7 +1011,7 @@ _mm_cvttph_epi32 (__m128h __A)
 {
   return (__m128i)
     __builtin_ia32_vcvttph2dq128_mask (__A,
-           (__v4si) _mm_setzero_si128 (),
+           (__v4si) _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1006,7 +1028,7 @@ _mm_maskz_cvttph_epi32 (__mmask8 __A, __m128h __B)
 {
   return (__m128i)
     __builtin_ia32_vcvttph2dq128_mask (__B,
-           (__v4si) _mm_setzero_si128 (),
+           (__v4si) _mm_avx512_setzero_si128 (),
            __A);
 }
 extern __inline __m256i
@@ -1016,7 +1038,7 @@ _mm256_cvttph_epi32 (__m128h __A)
   return (__m256i)
     __builtin_ia32_vcvttph2dq256_mask (__A,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) -1);
 }
 extern __inline __m256i
@@ -1035,7 +1057,7 @@ _mm256_maskz_cvttph_epi32 (__mmask8 __A, __m128h __B)
   return (__m256i)
     __builtin_ia32_vcvttph2dq256_mask (__B,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            __A);
 }
 extern __inline __m128i
@@ -1045,7 +1067,7 @@ _mm_cvttph_epu32 (__m128h __A)
   return (__m128i)
     __builtin_ia32_vcvttph2udq128_mask (__A,
      (__v4si)
-     _mm_setzero_si128 (),
+     _mm_avx512_setzero_si128 (),
      (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1064,7 +1086,7 @@ _mm_maskz_cvttph_epu32 (__mmask8 __A, __m128h __B)
   return (__m128i)
     __builtin_ia32_vcvttph2udq128_mask (__B,
      (__v4si)
-     _mm_setzero_si128 (),
+     _mm_avx512_setzero_si128 (),
      __A);
 }
 extern __inline __m256i
@@ -1074,7 +1096,7 @@ _mm256_cvttph_epu32 (__m128h __A)
   return (__m256i)
     __builtin_ia32_vcvttph2udq256_mask (__A,
      (__v8si)
-     _mm256_setzero_si256 (), (__mmask8) -1);
+     _mm256_avx512_setzero_si256 (), (__mmask8) -1);
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -1092,7 +1114,7 @@ _mm256_maskz_cvttph_epu32 (__mmask8 __A, __m128h __B)
   return (__m256i)
     __builtin_ia32_vcvttph2udq256_mask (__B,
      (__v8si)
-     _mm256_setzero_si256 (),
+     _mm256_avx512_setzero_si256 (),
      __A);
 }
 extern __inline __m128h
@@ -1191,7 +1213,7 @@ _mm_cvtph_epi64 (__m128h __A)
 {
   return
     __builtin_ia32_vcvtph2qq128_mask (__A,
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1205,7 +1227,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_cvtph_epi64 (__mmask8 __A, __m128h __B)
 {
   return __builtin_ia32_vcvtph2qq128_mask (__B,
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __A);
 }
 extern __inline __m256i
@@ -1213,7 +1235,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvtph_epi64 (__m128h __A)
 {
   return __builtin_ia32_vcvtph2qq256_mask (__A,
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -1227,7 +1249,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_cvtph_epi64 (__mmask8 __A, __m128h __B)
 {
   return __builtin_ia32_vcvtph2qq256_mask (__B,
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __A);
 }
 extern __inline __m128i
@@ -1235,7 +1257,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvtph_epu64 (__m128h __A)
 {
   return __builtin_ia32_vcvtph2uqq128_mask (__A,
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1249,7 +1271,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_cvtph_epu64 (__mmask8 __A, __m128h __B)
 {
   return __builtin_ia32_vcvtph2uqq128_mask (__B,
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __A);
 }
 extern __inline __m256i
@@ -1257,7 +1279,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvtph_epu64 (__m128h __A)
 {
   return __builtin_ia32_vcvtph2uqq256_mask (__A,
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask8) -1);
 }
 extern __inline __m256i
@@ -1271,7 +1293,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_cvtph_epu64 (__mmask8 __A, __m128h __B)
 {
   return __builtin_ia32_vcvtph2uqq256_mask (__B,
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          __A);
 }
 extern __inline __m128i
@@ -1279,7 +1301,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvttph_epi64 (__m128h __A)
 {
   return __builtin_ia32_vcvttph2qq128_mask (__A,
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1295,7 +1317,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_cvttph_epi64 (__mmask8 __A, __m128h __B)
 {
   return __builtin_ia32_vcvttph2qq128_mask (__B,
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __A);
 }
 extern __inline __m256i
@@ -1303,7 +1325,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvttph_epi64 (__m128h __A)
 {
   return __builtin_ia32_vcvttph2qq256_mask (__A,
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask8) -1);
 }
 extern __inline __m256i
@@ -1319,7 +1341,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_cvttph_epi64 (__mmask8 __A, __m128h __B)
 {
   return __builtin_ia32_vcvttph2qq256_mask (__B,
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          __A);
 }
 extern __inline __m128i
@@ -1327,7 +1349,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvttph_epu64 (__m128h __A)
 {
   return __builtin_ia32_vcvttph2uqq128_mask (__A,
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1343,7 +1365,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_cvttph_epu64 (__mmask8 __A, __m128h __B)
 {
   return __builtin_ia32_vcvttph2uqq128_mask (__B,
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __A);
 }
 extern __inline __m256i
@@ -1351,7 +1373,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvttph_epu64 (__m128h __A)
 {
   return __builtin_ia32_vcvttph2uqq256_mask (__A,
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) -1);
 }
 extern __inline __m256i
@@ -1367,7 +1389,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_cvttph_epu64 (__mmask8 __A, __m128h __B)
 {
   return __builtin_ia32_vcvttph2uqq256_mask (__B,
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __A);
 }
 extern __inline __m128h
@@ -1465,7 +1487,7 @@ _mm_cvtph_epi16 (__m128h __A)
   return (__m128i)
     __builtin_ia32_vcvtph2w128_mask (__A,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1482,7 +1504,7 @@ _mm_maskz_cvtph_epi16 (__mmask8 __A, __m128h __B)
   return (__m128i)
     __builtin_ia32_vcvtph2w128_mask (__B,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __A);
 }
 extern __inline __m256i
@@ -1492,7 +1514,7 @@ _mm256_cvtph_epi16 (__m256h __A)
   return (__m256i)
     __builtin_ia32_vcvtph2w256_mask (__A,
          (__v16hi)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask16) -1);
 }
 extern __inline __m256i
@@ -1509,7 +1531,7 @@ _mm256_maskz_cvtph_epi16 (__mmask16 __A, __m256h __B)
   return (__m256i)
     __builtin_ia32_vcvtph2w256_mask (__B,
          (__v16hi)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          __A);
 }
 extern __inline __m128i
@@ -1519,7 +1541,7 @@ _mm_cvtph_epu16 (__m128h __A)
   return (__m128i)
     __builtin_ia32_vcvtph2uw128_mask (__A,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1536,7 +1558,7 @@ _mm_maskz_cvtph_epu16 (__mmask8 __A, __m128h __B)
   return (__m128i)
     __builtin_ia32_vcvtph2uw128_mask (__B,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __A);
 }
 extern __inline __m256i
@@ -1546,7 +1568,7 @@ _mm256_cvtph_epu16 (__m256h __A)
   return (__m256i)
     __builtin_ia32_vcvtph2uw256_mask (__A,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask16) -1);
 }
 extern __inline __m256i
@@ -1563,7 +1585,7 @@ _mm256_maskz_cvtph_epu16 (__mmask16 __A, __m256h __B)
   return (__m256i)
     __builtin_ia32_vcvtph2uw256_mask (__B,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __A);
 }
 extern __inline __m128i
@@ -1573,7 +1595,7 @@ _mm_cvttph_epi16 (__m128h __A)
   return (__m128i)
     __builtin_ia32_vcvttph2w128_mask (__A,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1592,7 +1614,7 @@ _mm_maskz_cvttph_epi16 (__mmask8 __A, __m128h __B)
   return (__m128i)
     __builtin_ia32_vcvttph2w128_mask (__B,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __A);
 }
 extern __inline __m256i
@@ -1602,7 +1624,7 @@ _mm256_cvttph_epi16 (__m256h __A)
   return (__m256i)
     __builtin_ia32_vcvttph2w256_mask (__A,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask16) -1);
 }
 extern __inline __m256i
@@ -1621,7 +1643,7 @@ _mm256_maskz_cvttph_epi16 (__mmask16 __A, __m256h __B)
   return (__m256i)
     __builtin_ia32_vcvttph2w256_mask (__B,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __A);
 }
 extern __inline __m128i
@@ -1631,7 +1653,7 @@ _mm_cvttph_epu16 (__m128h __A)
   return (__m128i)
     __builtin_ia32_vcvttph2uw128_mask (__A,
            (__v8hi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1650,7 +1672,7 @@ _mm_maskz_cvttph_epu16 (__mmask8 __A, __m128h __B)
   return (__m128i)
     __builtin_ia32_vcvttph2uw128_mask (__B,
            (__v8hi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            __A);
 }
 extern __inline __m256i
@@ -1660,7 +1682,7 @@ _mm256_cvttph_epu16 (__m256h __A)
   return (__m256i)
     __builtin_ia32_vcvttph2uw256_mask (__A,
            (__v16hi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask16) -1);
 }
 extern __inline __m256i
@@ -1678,7 +1700,7 @@ _mm256_maskz_cvttph_epu16 (__mmask16 __A, __m256h __B)
 {
   return (__m256i)
     __builtin_ia32_vcvttph2uw256_mask (__B,
-           (__v16hi) _mm256_setzero_si256 (),
+           (__v16hi) _mm256_avx512_setzero_si256 (),
            __A);
 }
 extern __inline __m128h
@@ -1778,7 +1800,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvtph_pd (__m128h __A)
 {
   return __builtin_ia32_vcvtph2pd128_mask (__A,
-        _mm_setzero_pd (),
+        _mm_avx512_setzero_pd (),
         (__mmask8) -1);
 }
 extern __inline __m128d
@@ -1791,14 +1813,14 @@ extern __inline __m128d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_cvtph_pd (__mmask8 __A, __m128h __B)
 {
-  return __builtin_ia32_vcvtph2pd128_mask (__B, _mm_setzero_pd (), __A);
+  return __builtin_ia32_vcvtph2pd128_mask (__B, _mm_avx512_setzero_pd (), __A);
 }
 extern __inline __m256d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvtph_pd (__m128h __A)
 {
   return __builtin_ia32_vcvtph2pd256_mask (__A,
-        _mm256_setzero_pd (),
+        _mm256_avx512_setzero_pd (),
         (__mmask8) -1);
 }
 extern __inline __m256d
@@ -1812,7 +1834,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_cvtph_pd (__mmask8 __A, __m128h __B)
 {
   return __builtin_ia32_vcvtph2pd256_mask (__B,
-        _mm256_setzero_pd (),
+        _mm256_avx512_setzero_pd (),
         __A);
 }
 extern __inline __m128
@@ -1820,7 +1842,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvtxph_ps (__m128h __A)
 {
   return __builtin_ia32_vcvtph2psx128_mask (__A,
-        _mm_setzero_ps (),
+        _mm_avx512_setzero_ps (),
         (__mmask8) -1);
 }
 extern __inline __m128
@@ -1833,14 +1855,14 @@ extern __inline __m128
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_cvtxph_ps (__mmask8 __A, __m128h __B)
 {
-  return __builtin_ia32_vcvtph2psx128_mask (__B, _mm_setzero_ps (), __A);
+  return __builtin_ia32_vcvtph2psx128_mask (__B, _mm_avx512_setzero_ps (), __A);
 }
 extern __inline __m256
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvtxph_ps (__m128h __A)
 {
   return __builtin_ia32_vcvtph2psx256_mask (__A,
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) -1);
 }
 extern __inline __m256
@@ -1854,7 +1876,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_cvtxph_ps (__mmask8 __A, __m128h __B)
 {
   return __builtin_ia32_vcvtph2psx256_mask (__B,
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          __A);
 }
 extern __inline __m128h
@@ -2667,7 +2689,7 @@ _mm256_maskz_fcmul_pch (__mmask8 __A, __m256h __B, __m256h __C)
            _mm256_setzero_ph (),
            __A);
 }
-#define _MM256_REDUCE_OP(op) __m128h __T1 = (__m128h) _mm256_extractf128_pd ((__m256d) __A, 0); __m128h __T2 = (__m128h) _mm256_extractf128_pd ((__m256d) __A, 1); __m128h __T3 = (__T1 op __T2); __m128h __T4 = (__m128h) __builtin_shuffle (__T3, (__v8hi) { 4, 5, 6, 7, 0, 1, 2, 3 }); __m128h __T5 = (__T3) op (__T4); __m128h __T6 = (__m128h) __builtin_shuffle (__T5, (__v8hi) { 2, 3, 0, 1, 4, 5, 6, 7 }); __m128h __T7 = __T5 op __T6; return __T7[0] op __T7[1]
+#define _MM256_REDUCE_OP(op) __m128h __T1 = (__m128h) _mm256_avx512_extractf128_pd ((__m256d) __A, 0); __m128h __T2 = (__m128h) _mm256_avx512_extractf128_pd ((__m256d) __A, 1); __m128h __T3 = (__T1 op __T2); __m128h __T4 = (__m128h) __builtin_shuffle (__T3, (__v8hi) { 4, 5, 6, 7, 0, 1, 2, 3 }); __m128h __T5 = (__T3) op (__T4); __m128h __T6 = (__m128h) __builtin_shuffle (__T5, (__v8hi) { 2, 3, 0, 1, 4, 5, 6, 7 }); __m128h __T7 = __T5 op __T6; return __T7[0] op __T7[1]
 extern __inline _Float16
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_reduce_add_ph (__m256h __A)
@@ -2681,7 +2703,7 @@ _mm256_reduce_mul_ph (__m256h __A)
   _MM256_REDUCE_OP (*);
 }
 #undef _MM256_REDUCE_OP
-#define _MM256_REDUCE_OP(op) __m128h __T1 = (__m128h) _mm256_extractf128_pd ((__m256d) __A, 0); __m128h __T2 = (__m128h) _mm256_extractf128_pd ((__m256d) __A, 1); __m128h __T3 = _mm_##op (__T1, __T2); __m128h __T4 = (__m128h) __builtin_shuffle (__T3, (__v8hi) { 2, 3, 0, 1, 6, 7, 4, 5 }); __m128h __T5 = _mm_##op (__T3, __T4); __m128h __T6 = (__m128h) __builtin_shuffle (__T5, (__v8hi) { 4, 5 }); __m128h __T7 = _mm_##op (__T5, __T6); __m128h __T8 = (__m128h) __builtin_shuffle (__T7, (__v8hi) { 1, 0 }); __m128h __T9 = _mm_##op (__T7, __T8); return __T9[0]
+#define _MM256_REDUCE_OP(op) __m128h __T1 = (__m128h) _mm256_avx512_extractf128_pd ((__m256d) __A, 0); __m128h __T2 = (__m128h) _mm256_avx512_extractf128_pd ((__m256d) __A, 1); __m128h __T3 = _mm_##op (__T1, __T2); __m128h __T4 = (__m128h) __builtin_shuffle (__T3, (__v8hi) { 2, 3, 0, 1, 6, 7, 4, 5 }); __m128h __T5 = _mm_##op (__T3, __T4); __m128h __T6 = (__m128h) __builtin_shuffle (__T5, (__v8hi) { 4, 5 }); __m128h __T7 = _mm_##op (__T5, __T6); __m128h __T8 = (__m128h) __builtin_shuffle (__T7, (__v8hi) { 1, 0 }); __m128h __T9 = _mm_##op (__T7, __T8); return __T9[0]
 extern __inline _Float16
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_reduce_min_ph (__m256h __A)
@@ -2783,10 +2805,10 @@ _mm256_set1_pch (_Float16 _Complex __A)
 {
   union
   {
-    _Float16 _Complex a;
-    float b;
-  } u = { .a = __A };
-  return (__m256h) _mm256_set1_ps (u.b);
+    _Float16 _Complex __a;
+    float __b;
+  } __u = { .__a = __A };
+  return (__m256h) _mm256_avx512_set1_ps (__u.__b);
 }
 extern __inline __m128h
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
@@ -2794,10 +2816,10 @@ _mm_set1_pch (_Float16 _Complex __A)
 {
   union
   {
-    _Float16 _Complex a;
-    float b;
-  } u = { .a = __A };
-  return (__m128h) _mm_set1_ps (u.b);
+    _Float16 _Complex __a;
+    float __b;
+  } __u = { .__a = __A };
+  return (__m128h) _mm_avx512_set1_ps (__u.__b);
 }
 #define _mm_mul_pch(A, B) _mm_fmul_pch ((A), (B))
 #define _mm_mask_mul_pch(W, U, A, B) _mm_mask_fmul_pch ((W), (U), (A), (B))
diff --git a/third_party/intel/avx512ifmaintrin.internal.h b/third_party/intel/avx512ifmaintrin.internal.h
index c26b71b24..64f167125 100644
--- a/third_party/intel/avx512ifmaintrin.internal.h
+++ b/third_party/intel/avx512ifmaintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512IFMAINTRIN_H_INCLUDED
 #define _AVX512IFMAINTRIN_H_INCLUDED
-#ifndef __AVX512IFMA__
+#if !defined (__AVX512IFMA__) || !defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512ifma")
+#pragma GCC target("avx512ifma,evex512")
 #define __DISABLE_AVX512IFMA__
 #endif
 extern __inline __m512i
diff --git a/third_party/intel/avx512ifmavlintrin.internal.h b/third_party/intel/avx512ifmavlintrin.internal.h
index 38dedfee7..56c548d9d 100644
--- a/third_party/intel/avx512ifmavlintrin.internal.h
+++ b/third_party/intel/avx512ifmavlintrin.internal.h
@@ -4,47 +4,15 @@
 #endif
 #ifndef _AVX512IFMAVLINTRIN_H_INCLUDED
 #define _AVX512IFMAVLINTRIN_H_INCLUDED
-#if !defined(__AVX512VL__) || !defined(__AVX512IFMA__)
+#if !defined(__AVX512VL__) || !defined(__AVX512IFMA__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512ifma,avx512vl")
+#pragma GCC target("avx512ifma,avx512vl,no-evex512")
 #define __DISABLE_AVX512IFMAVL__
 #endif
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_madd52lo_epu64 (__m128i __X, __m128i __Y, __m128i __Z)
-{
-  return (__m128i) __builtin_ia32_vpmadd52luq128_mask ((__v2di) __X,
-             (__v2di) __Y,
-             (__v2di) __Z,
-             (__mmask8) -1);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_madd52hi_epu64 (__m128i __X, __m128i __Y, __m128i __Z)
-{
-  return (__m128i) __builtin_ia32_vpmadd52huq128_mask ((__v2di) __X,
-             (__v2di) __Y,
-             (__v2di) __Z,
-             (__mmask8) -1);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_madd52lo_epu64 (__m256i __X, __m256i __Y, __m256i __Z)
-{
-  return (__m256i) __builtin_ia32_vpmadd52luq256_mask ((__v4di) __X,
-             (__v4di) __Y,
-             (__v4di) __Z,
-             (__mmask8) -1);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_madd52hi_epu64 (__m256i __X, __m256i __Y, __m256i __Z)
-{
-  return (__m256i) __builtin_ia32_vpmadd52huq256_mask ((__v4di) __X,
-             (__v4di) __Y,
-             (__v4di) __Z,
-             (__mmask8) -1);
-}
+#define _mm_madd52lo_epu64(A, B, C) ((__m128i) __builtin_ia32_vpmadd52luq128 ((__v2di) (A), (__v2di) (B), (__v2di) (C)))
+#define _mm_madd52hi_epu64(A, B, C) ((__m128i) __builtin_ia32_vpmadd52huq128 ((__v2di) (A), (__v2di) (B), (__v2di) (C)))
+#define _mm256_madd52lo_epu64(A, B, C) ((__m256i) __builtin_ia32_vpmadd52luq256 ((__v4di) (A), (__v4di) (B), (__v4di) (C)))
+#define _mm256_madd52hi_epu64(A, B, C) ((__m256i) __builtin_ia32_vpmadd52huq256 ((__v4di) (A), (__v4di) (B), (__v4di) (C)))
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_mask_madd52lo_epu64 (__m128i __W, __mmask8 __M, __m128i __X, __m128i __Y)
diff --git a/third_party/intel/avx512pfintrin.internal.h b/third_party/intel/avx512pfintrin.internal.h
index 4a9d538f4..bbb339c0a 100644
--- a/third_party/intel/avx512pfintrin.internal.h
+++ b/third_party/intel/avx512pfintrin.internal.h
@@ -6,7 +6,7 @@
 #define _AVX512PFINTRIN_H_INCLUDED
 #ifndef __AVX512PF__
 #pragma GCC push_options
-#pragma GCC target("avx512pf")
+#pragma GCC target("avx512pf,evex512")
 #define __DISABLE_AVX512PF__
 #endif
 typedef long long __v8di __attribute__ ((__vector_size__ (64)));
diff --git a/third_party/intel/avx512vbmi2intrin.internal.h b/third_party/intel/avx512vbmi2intrin.internal.h
index 71cee34b0..e8afb814c 100644
--- a/third_party/intel/avx512vbmi2intrin.internal.h
+++ b/third_party/intel/avx512vbmi2intrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef __AVX512VBMI2INTRIN_H_INCLUDED
 #define __AVX512VBMI2INTRIN_H_INCLUDED
-#if !defined(__AVX512VBMI2__)
+#if !defined(__AVX512VBMI2__) || !defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vbmi2")
+#pragma GCC target("avx512vbmi2,evex512")
 #define __DISABLE_AVX512VBMI2__
 #endif
 #ifdef __OPTIMIZE__
@@ -224,15 +224,6 @@ _mm512_maskz_shldv_epi64 (__mmask8 __A, __m512i __B, __m512i __C, __m512i __D)
   return (__m512i)__builtin_ia32_vpshldv_v8di_maskz ((__v8di)__B, (__v8di) __C,
       (__v8di) __D, (__mmask8)__A);
 }
-#ifdef __DISABLE_AVX512VBMI2__
-#undef __DISABLE_AVX512VBMI2__
-#pragma GCC pop_options
-#endif
-#if !defined(__AVX512VBMI2__) || !defined(__AVX512BW__)
-#pragma GCC push_options
-#pragma GCC target("avx512vbmi2,avx512bw")
-#define __DISABLE_AVX512VBMI2BW__
-#endif
 extern __inline __m512i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mask_compress_epi8 (__m512i __A, __mmask64 __B, __m512i __C)
@@ -398,8 +389,8 @@ _mm512_maskz_shldv_epi16 (__mmask32 __A, __m512i __B, __m512i __C, __m512i __D)
   return (__m512i)__builtin_ia32_vpshldv_v32hi_maskz ((__v32hi)__B,
     (__v32hi) __C, (__v32hi) __D, (__mmask32)__A);
 }
-#ifdef __DISABLE_AVX512VBMI2BW__
-#undef __DISABLE_AVX512VBMI2BW__
+#ifdef __DISABLE_AVX512VBMI2__
+#undef __DISABLE_AVX512VBMI2__
 #pragma GCC pop_options
 #endif
 #endif
diff --git a/third_party/intel/avx512vbmi2vlintrin.internal.h b/third_party/intel/avx512vbmi2vlintrin.internal.h
index 07f97fb52..515a28507 100644
--- a/third_party/intel/avx512vbmi2vlintrin.internal.h
+++ b/third_party/intel/avx512vbmi2vlintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512VBMI2VLINTRIN_H_INCLUDED
 #define _AVX512VBMI2VLINTRIN_H_INCLUDED
-#if !defined(__AVX512VL__) || !defined(__AVX512VBMI2__)
+#if !defined(__AVX512VL__) || !defined(__AVX512VBMI2__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vbmi2,avx512vl")
+#pragma GCC target("avx512vbmi2,avx512vl,no-evex512")
 #define __DISABLE_AVX512VBMI2VL__
 #endif
 extern __inline __m128i
@@ -21,7 +21,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_compress_epi8 (__mmask16 __A, __m128i __B)
 {
   return (__m128i) __builtin_ia32_compressqi128_mask ((__v16qi) __B,
-   (__v16qi) _mm_setzero_si128 (), (__mmask16) __A);
+   (__v16qi) _mm_avx512_setzero_si128 (), (__mmask16) __A);
 }
 extern __inline void
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -42,7 +42,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_compress_epi16 (__mmask8 __A, __m128i __B)
 {
   return (__m128i) __builtin_ia32_compresshi128_mask ((__v8hi) __B,
-    (__v8hi) _mm_setzero_si128 (), (__mmask8) __A);
+    (__v8hi) _mm_avx512_setzero_si128 (), (__mmask8) __A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -56,7 +56,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_compress_epi16 (__mmask16 __A, __m256i __B)
 {
   return (__m256i) __builtin_ia32_compresshi256_mask ((__v16hi) __B,
-   (__v16hi) _mm256_setzero_si256 (), (__mmask16) __A);
+   (__v16hi) _mm256_avx512_setzero_si256 (), (__mmask16) __A);
 }
 extern __inline void
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -85,7 +85,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_expand_epi8 (__mmask16 __A, __m128i __B)
 {
   return (__m128i) __builtin_ia32_expandqi128_maskz ((__v16qi) __B,
-   (__v16qi) _mm_setzero_si128 (), (__mmask16) __A);
+   (__v16qi) _mm_avx512_setzero_si128 (), (__mmask16) __A);
 }
 extern __inline __m128i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -99,7 +99,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_expandloadu_epi8 (__mmask16 __A, const void * __B)
 {
   return (__m128i) __builtin_ia32_expandloadqi128_maskz ((const __v16qi *) __B,
-   (__v16qi) _mm_setzero_si128 (), (__mmask16) __A);
+   (__v16qi) _mm_avx512_setzero_si128 (), (__mmask16) __A);
 }
 extern __inline __m128i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -114,7 +114,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_expand_epi16 (__mmask8 __A, __m128i __B)
 {
   return (__m128i) __builtin_ia32_expandhi128_maskz ((__v8hi) __B,
-    (__v8hi) _mm_setzero_si128 (), (__mmask8) __A);
+    (__v8hi) _mm_avx512_setzero_si128 (), (__mmask8) __A);
 }
 extern __inline __m128i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -128,7 +128,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_expandloadu_epi16 (__mmask8 __A, const void * __B)
 {
   return (__m128i) __builtin_ia32_expandloadhi128_maskz ((const __v8hi *) __B,
-    (__v8hi) _mm_setzero_si128 (), (__mmask8) __A);
+    (__v8hi) _mm_avx512_setzero_si128 (), (__mmask8) __A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -143,7 +143,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_expand_epi16 (__mmask16 __A, __m256i __B)
 {
   return (__m256i) __builtin_ia32_expandhi256_maskz ((__v16hi) __B,
-   (__v16hi) _mm256_setzero_si256 (), (__mmask16) __A);
+   (__v16hi) _mm256_avx512_setzero_si256 (), (__mmask16) __A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -157,7 +157,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_expandloadu_epi16 (__mmask16 __A, const void * __B)
 {
   return (__m256i) __builtin_ia32_expandloadhi256_maskz ((const __v16hi *) __B,
-   (__v16hi) _mm256_setzero_si256 (), (__mmask16) __A);
+   (__v16hi) _mm256_avx512_setzero_si256 (), (__mmask16) __A);
 }
 #ifdef __OPTIMIZE__
 extern __inline __m256i
@@ -180,7 +180,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_shrdi_epi16 (__mmask16 __A, __m256i __B, __m256i __C, int __D)
 {
   return (__m256i)__builtin_ia32_vpshrd_v16hi_mask ((__v16hi)__B,
- (__v16hi) __C, __D, (__v16hi) _mm256_setzero_si256 (), (__mmask16)__A);
+ (__v16hi) __C, __D, (__v16hi) _mm256_avx512_setzero_si256 (), (__mmask16)__A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -195,7 +195,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_shrdi_epi32 (__mmask8 __A, __m256i __B, __m256i __C, int __D)
 {
   return (__m256i)__builtin_ia32_vpshrd_v8si_mask ((__v8si)__B, (__v8si) __C,
-   __D, (__v8si) _mm256_setzero_si256 (), (__mmask8)__A);
+   __D, (__v8si) _mm256_avx512_setzero_si256 (), (__mmask8)__A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -216,7 +216,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_shrdi_epi64 (__mmask8 __A, __m256i __B, __m256i __C, int __D)
 {
   return (__m256i)__builtin_ia32_vpshrd_v4di_mask ((__v4di)__B, (__v4di) __C,
-   __D, (__v4di) _mm256_setzero_si256 (), (__mmask8)__A);
+   __D, (__v4di) _mm256_avx512_setzero_si256 (), (__mmask8)__A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -237,7 +237,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_shrdi_epi16 (__mmask8 __A, __m128i __B, __m128i __C, int __D)
 {
   return (__m128i)__builtin_ia32_vpshrd_v8hi_mask ((__v8hi)__B, (__v8hi) __C,
-   __D, (__v8hi) _mm_setzero_si128 (), (__mmask8)__A);
+   __D, (__v8hi) _mm_avx512_setzero_si128 (), (__mmask8)__A);
 }
 extern __inline __m128i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -258,7 +258,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_shrdi_epi32 (__mmask8 __A, __m128i __B, __m128i __C, int __D)
 {
   return (__m128i)__builtin_ia32_vpshrd_v4si_mask ((__v4si)__B, (__v4si) __C,
-   __D, (__v4si) _mm_setzero_si128 (), (__mmask8)__A);
+   __D, (__v4si) _mm_avx512_setzero_si128 (), (__mmask8)__A);
 }
 extern __inline __m128i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -279,7 +279,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_shrdi_epi64 (__mmask8 __A, __m128i __B, __m128i __C, int __D)
 {
   return (__m128i)__builtin_ia32_vpshrd_v2di_mask ((__v2di)__B, (__v2di) __C,
-   __D, (__v2di) _mm_setzero_si128 (), (__mmask8)__A);
+   __D, (__v2di) _mm_avx512_setzero_si128 (), (__mmask8)__A);
 }
 extern __inline __m128i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -307,7 +307,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_shldi_epi16 (__mmask16 __A, __m256i __B, __m256i __C, int __D)
 {
   return (__m256i)__builtin_ia32_vpshld_v16hi_mask ((__v16hi)__B,
- (__v16hi) __C, __D, (__v16hi) _mm256_setzero_si256 (), (__mmask16)__A);
+ (__v16hi) __C, __D, (__v16hi) _mm256_avx512_setzero_si256 (), (__mmask16)__A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -322,7 +322,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_shldi_epi32 (__mmask8 __A, __m256i __B, __m256i __C, int __D)
 {
   return (__m256i)__builtin_ia32_vpshld_v8si_mask ((__v8si)__B, (__v8si) __C,
-   __D, (__v8si) _mm256_setzero_si256 (), (__mmask8)__A);
+   __D, (__v8si) _mm256_avx512_setzero_si256 (), (__mmask8)__A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -343,7 +343,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_shldi_epi64 (__mmask8 __A, __m256i __B, __m256i __C, int __D)
 {
   return (__m256i)__builtin_ia32_vpshld_v4di_mask ((__v4di)__B, (__v4di) __C,
-   __D, (__v4di) _mm256_setzero_si256 (), (__mmask8)__A);
+   __D, (__v4di) _mm256_avx512_setzero_si256 (), (__mmask8)__A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -364,7 +364,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_shldi_epi16 (__mmask8 __A, __m128i __B, __m128i __C, int __D)
 {
   return (__m128i)__builtin_ia32_vpshld_v8hi_mask ((__v8hi)__B, (__v8hi) __C,
-   __D, (__v8hi) _mm_setzero_si128 (), (__mmask8)__A);
+   __D, (__v8hi) _mm_avx512_setzero_si128 (), (__mmask8)__A);
 }
 extern __inline __m128i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -385,7 +385,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_shldi_epi32 (__mmask8 __A, __m128i __B, __m128i __C, int __D)
 {
   return (__m128i)__builtin_ia32_vpshld_v4si_mask ((__v4si)__B, (__v4si) __C,
-   __D, (__v4si) _mm_setzero_si128 (), (__mmask8)__A);
+   __D, (__v4si) _mm_avx512_setzero_si128 (), (__mmask8)__A);
 }
 extern __inline __m128i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -406,7 +406,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_shldi_epi64 (__mmask8 __A, __m128i __B, __m128i __C, int __D)
 {
   return (__m128i)__builtin_ia32_vpshld_v2di_mask ((__v2di)__B, (__v2di) __C,
-   __D, (__v2di) _mm_setzero_si128 (), (__mmask8)__A);
+   __D, (__v2di) _mm_avx512_setzero_si128 (), (__mmask8)__A);
 }
 extern __inline __m128i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -417,40 +417,40 @@ _mm_shldi_epi64 (__m128i __A, __m128i __B, int __C)
 #else
 #define _mm256_shrdi_epi16(A, B, C) ((__m256i) __builtin_ia32_vpshrd_v16hi ((__v16hi)(__m256i)(A), (__v16hi)(__m256i)(B),(int)(C)))
 #define _mm256_mask_shrdi_epi16(A, B, C, D, E) ((__m256i) __builtin_ia32_vpshrd_v16hi_mask ((__v16hi)(__m256i)(C), (__v16hi)(__m256i)(D), (int)(E), (__v16hi)(__m256i)(A), (__mmask16)(B)))
-#define _mm256_maskz_shrdi_epi16(A, B, C, D) ((__m256i) __builtin_ia32_vpshrd_v16hi_mask ((__v16hi)(__m256i)(B), (__v16hi)(__m256i)(C),(int)(D), (__v16hi)(__m256i)_mm256_setzero_si256 (), (__mmask16)(A)))
+#define _mm256_maskz_shrdi_epi16(A, B, C, D) ((__m256i) __builtin_ia32_vpshrd_v16hi_mask ((__v16hi)(__m256i)(B), (__v16hi)(__m256i)(C),(int)(D), (__v16hi)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask16)(A)))
 #define _mm256_shrdi_epi32(A, B, C) ((__m256i) __builtin_ia32_vpshrd_v8si ((__v8si)(__m256i)(A), (__v8si)(__m256i)(B),(int)(C)))
 #define _mm256_mask_shrdi_epi32(A, B, C, D, E) ((__m256i) __builtin_ia32_vpshrd_v8si_mask ((__v8si)(__m256i)(C), (__v8si)(__m256i)(D), (int)(E), (__v8si)(__m256i)(A), (__mmask8)(B)))
-#define _mm256_maskz_shrdi_epi32(A, B, C, D) ((__m256i) __builtin_ia32_vpshrd_v8si_mask ((__v8si)(__m256i)(B), (__v8si)(__m256i)(C),(int)(D), (__v8si)(__m256i)_mm256_setzero_si256 (), (__mmask8)(A)))
+#define _mm256_maskz_shrdi_epi32(A, B, C, D) ((__m256i) __builtin_ia32_vpshrd_v8si_mask ((__v8si)(__m256i)(B), (__v8si)(__m256i)(C),(int)(D), (__v8si)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(A)))
 #define _mm256_shrdi_epi64(A, B, C) ((__m256i) __builtin_ia32_vpshrd_v4di ((__v4di)(__m256i)(A), (__v4di)(__m256i)(B),(int)(C)))
 #define _mm256_mask_shrdi_epi64(A, B, C, D, E) ((__m256i) __builtin_ia32_vpshrd_v4di_mask ((__v4di)(__m256i)(C), (__v4di)(__m256i)(D), (int)(E), (__v4di)(__m256i)(A), (__mmask8)(B)))
-#define _mm256_maskz_shrdi_epi64(A, B, C, D) ((__m256i) __builtin_ia32_vpshrd_v4di_mask ((__v4di)(__m256i)(B), (__v4di)(__m256i)(C),(int)(D), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(A)))
+#define _mm256_maskz_shrdi_epi64(A, B, C, D) ((__m256i) __builtin_ia32_vpshrd_v4di_mask ((__v4di)(__m256i)(B), (__v4di)(__m256i)(C),(int)(D), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(A)))
 #define _mm_shrdi_epi16(A, B, C) ((__m128i) __builtin_ia32_vpshrd_v8hi ((__v8hi)(__m128i)(A), (__v8hi)(__m128i)(B),(int)(C)))
 #define _mm_mask_shrdi_epi16(A, B, C, D, E) ((__m128i) __builtin_ia32_vpshrd_v8hi_mask ((__v8hi)(__m128i)(C), (__v8hi)(__m128i)(D), (int)(E), (__v8hi)(__m128i)(A), (__mmask8)(B)))
-#define _mm_maskz_shrdi_epi16(A, B, C, D) ((__m128i) __builtin_ia32_vpshrd_v8hi_mask ((__v8hi)(__m128i)(B), (__v8hi)(__m128i)(C),(int)(D), (__v8hi)(__m128i)_mm_setzero_si128 (), (__mmask8)(A)))
+#define _mm_maskz_shrdi_epi16(A, B, C, D) ((__m128i) __builtin_ia32_vpshrd_v8hi_mask ((__v8hi)(__m128i)(B), (__v8hi)(__m128i)(C),(int)(D), (__v8hi)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(A)))
 #define _mm_shrdi_epi32(A, B, C) ((__m128i) __builtin_ia32_vpshrd_v4si ((__v4si)(__m128i)(A), (__v4si)(__m128i)(B),(int)(C)))
 #define _mm_mask_shrdi_epi32(A, B, C, D, E) ((__m128i) __builtin_ia32_vpshrd_v4si_mask ((__v4si)(__m128i)(C), (__v4si)(__m128i)(D), (int)(E), (__v4si)(__m128i)(A), (__mmask8)(B)))
-#define _mm_maskz_shrdi_epi32(A, B, C, D) ((__m128i) __builtin_ia32_vpshrd_v4si_mask ((__v4si)(__m128i)(B), (__v4si)(__m128i)(C),(int)(D), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(A)))
+#define _mm_maskz_shrdi_epi32(A, B, C, D) ((__m128i) __builtin_ia32_vpshrd_v4si_mask ((__v4si)(__m128i)(B), (__v4si)(__m128i)(C),(int)(D), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(A)))
 #define _mm_shrdi_epi64(A, B, C) ((__m128i) __builtin_ia32_vpshrd_v2di ((__v2di)(__m128i)(A), (__v2di)(__m128i)(B),(int)(C)))
 #define _mm_mask_shrdi_epi64(A, B, C, D, E) ((__m128i) __builtin_ia32_vpshrd_v2di_mask ((__v2di)(__m128i)(C), (__v2di)(__m128i)(D), (int)(E), (__v2di)(__m128i)(A), (__mmask8)(B)))
-#define _mm_maskz_shrdi_epi64(A, B, C, D) ((__m128i) __builtin_ia32_vpshrd_v2di_mask ((__v2di)(__m128i)(B), (__v2di)(__m128i)(C),(int)(D), (__v2di)(__m128i)_mm_setzero_si128 (), (__mmask8)(A)))
+#define _mm_maskz_shrdi_epi64(A, B, C, D) ((__m128i) __builtin_ia32_vpshrd_v2di_mask ((__v2di)(__m128i)(B), (__v2di)(__m128i)(C),(int)(D), (__v2di)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(A)))
 #define _mm256_shldi_epi16(A, B, C) ((__m256i) __builtin_ia32_vpshld_v16hi ((__v16hi)(__m256i)(A), (__v16hi)(__m256i)(B),(int)(C)))
 #define _mm256_mask_shldi_epi16(A, B, C, D, E) ((__m256i) __builtin_ia32_vpshld_v16hi_mask ((__v16hi)(__m256i)(C), (__v16hi)(__m256i)(D), (int)(E), (__v16hi)(__m256i)(A), (__mmask16)(B)))
-#define _mm256_maskz_shldi_epi16(A, B, C, D) ((__m256i) __builtin_ia32_vpshld_v16hi_mask ((__v16hi)(__m256i)(B), (__v16hi)(__m256i)(C),(int)(D), (__v16hi)(__m256i)_mm256_setzero_si256 (), (__mmask16)(A)))
+#define _mm256_maskz_shldi_epi16(A, B, C, D) ((__m256i) __builtin_ia32_vpshld_v16hi_mask ((__v16hi)(__m256i)(B), (__v16hi)(__m256i)(C),(int)(D), (__v16hi)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask16)(A)))
 #define _mm256_shldi_epi32(A, B, C) ((__m256i) __builtin_ia32_vpshld_v8si ((__v8si)(__m256i)(A), (__v8si)(__m256i)(B),(int)(C)))
 #define _mm256_mask_shldi_epi32(A, B, C, D, E) ((__m256i) __builtin_ia32_vpshld_v8si_mask ((__v8si)(__m256i)(C), (__v8si)(__m256i)(D), (int)(E), (__v8si)(__m256i)(A), (__mmask8)(B)))
-#define _mm256_maskz_shldi_epi32(A, B, C, D) ((__m256i) __builtin_ia32_vpshld_v8si_mask ((__v8si)(__m256i)(B), (__v8si)(__m256i)(C),(int)(D), (__v8si)(__m256i)_mm256_setzero_si256 (), (__mmask8)(A)))
+#define _mm256_maskz_shldi_epi32(A, B, C, D) ((__m256i) __builtin_ia32_vpshld_v8si_mask ((__v8si)(__m256i)(B), (__v8si)(__m256i)(C),(int)(D), (__v8si)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(A)))
 #define _mm256_shldi_epi64(A, B, C) ((__m256i) __builtin_ia32_vpshld_v4di ((__v4di)(__m256i)(A), (__v4di)(__m256i)(B),(int)(C)))
 #define _mm256_mask_shldi_epi64(A, B, C, D, E) ((__m256i) __builtin_ia32_vpshld_v4di_mask ((__v4di)(__m256i)(C), (__v4di)(__m256i)(D), (int)(E), (__v4di)(__m256i)(A), (__mmask8)(B)))
-#define _mm256_maskz_shldi_epi64(A, B, C, D) ((__m256i) __builtin_ia32_vpshld_v4di_mask ((__v4di)(__m256i)(B), (__v4di)(__m256i)(C),(int)(D), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(A)))
+#define _mm256_maskz_shldi_epi64(A, B, C, D) ((__m256i) __builtin_ia32_vpshld_v4di_mask ((__v4di)(__m256i)(B), (__v4di)(__m256i)(C),(int)(D), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(A)))
 #define _mm_shldi_epi16(A, B, C) ((__m128i) __builtin_ia32_vpshld_v8hi ((__v8hi)(__m128i)(A), (__v8hi)(__m128i)(B),(int)(C)))
 #define _mm_mask_shldi_epi16(A, B, C, D, E) ((__m128i) __builtin_ia32_vpshld_v8hi_mask ((__v8hi)(__m128i)(C), (__v8hi)(__m128i)(D), (int)(E), (__v8hi)(__m128i)(A), (__mmask8)(B)))
-#define _mm_maskz_shldi_epi16(A, B, C, D) ((__m128i) __builtin_ia32_vpshld_v8hi_mask ((__v8hi)(__m128i)(B), (__v8hi)(__m128i)(C),(int)(D), (__v8hi)(__m128i)_mm_setzero_si128 (), (__mmask8)(A)))
+#define _mm_maskz_shldi_epi16(A, B, C, D) ((__m128i) __builtin_ia32_vpshld_v8hi_mask ((__v8hi)(__m128i)(B), (__v8hi)(__m128i)(C),(int)(D), (__v8hi)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(A)))
 #define _mm_shldi_epi32(A, B, C) ((__m128i) __builtin_ia32_vpshld_v4si ((__v4si)(__m128i)(A), (__v4si)(__m128i)(B),(int)(C)))
 #define _mm_mask_shldi_epi32(A, B, C, D, E) ((__m128i) __builtin_ia32_vpshld_v4si_mask ((__v4si)(__m128i)(C), (__v4si)(__m128i)(D), (int)(E), (__v4si)(__m128i)(A), (__mmask8)(B)))
-#define _mm_maskz_shldi_epi32(A, B, C, D) ((__m128i) __builtin_ia32_vpshld_v4si_mask ((__v4si)(__m128i)(B), (__v4si)(__m128i)(C),(int)(D), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(A)))
+#define _mm_maskz_shldi_epi32(A, B, C, D) ((__m128i) __builtin_ia32_vpshld_v4si_mask ((__v4si)(__m128i)(B), (__v4si)(__m128i)(C),(int)(D), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(A)))
 #define _mm_shldi_epi64(A, B, C) ((__m128i) __builtin_ia32_vpshld_v2di ((__v2di)(__m128i)(A), (__v2di)(__m128i)(B),(int)(C)))
 #define _mm_mask_shldi_epi64(A, B, C, D, E) ((__m128i) __builtin_ia32_vpshld_v2di_mask ((__v2di)(__m128i)(C), (__v2di)(__m128i)(D), (int)(E), (__v2di)(__m128i)(A), (__mmask8)(B)))
-#define _mm_maskz_shldi_epi64(A, B, C, D) ((__m128i) __builtin_ia32_vpshld_v2di_mask ((__v2di)(__m128i)(B), (__v2di)(__m128i)(C),(int)(D), (__v2di)(__m128i)_mm_setzero_si128 (), (__mmask8)(A)))
+#define _mm_maskz_shldi_epi64(A, B, C, D) ((__m128i) __builtin_ia32_vpshld_v2di_mask ((__v2di)(__m128i)(B), (__v2di)(__m128i)(C),(int)(D), (__v2di)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(A)))
 #endif
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -704,15 +704,6 @@ _mm_maskz_shldv_epi64 (__mmask8 __A, __m128i __B, __m128i __C, __m128i __D)
   return (__m128i)__builtin_ia32_vpshldv_v2di_maskz ((__v2di)__B, (__v2di) __C,
       (__v2di) __D, (__mmask8)__A);
 }
-#ifdef __DISABLE_AVX512VBMI2VL__
-#undef __DISABLE_AVX512VBMI2VL__
-#pragma GCC pop_options
-#endif
-#if !defined(__AVX512VL__) || !defined(__AVX512VBMI2__) || !defined(__AVX512BW__)
-#pragma GCC push_options
-#pragma GCC target("avx512vbmi2,avx512vl,avx512bw")
-#define __DISABLE_AVX512VBMI2VLBW__
-#endif
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_compress_epi8 (__m256i __A, __mmask32 __B, __m256i __C)
@@ -725,7 +716,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_compress_epi8 (__mmask32 __A, __m256i __B)
 {
   return (__m256i) __builtin_ia32_compressqi256_mask ((__v32qi) __B,
-   (__v32qi) _mm256_setzero_si256 (), (__mmask32) __A);
+   (__v32qi) _mm256_avx512_setzero_si256 (), (__mmask32) __A);
 }
 extern __inline void
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -747,7 +738,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_expand_epi8 (__mmask32 __A, __m256i __B)
 {
   return (__m256i) __builtin_ia32_expandqi256_maskz ((__v32qi) __B,
-   (__v32qi) _mm256_setzero_si256 (), (__mmask32) __A);
+   (__v32qi) _mm256_avx512_setzero_si256 (), (__mmask32) __A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -761,10 +752,10 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_expandloadu_epi8 (__mmask32 __A, const void * __B)
 {
   return (__m256i) __builtin_ia32_expandloadqi256_maskz ((const __v32qi *) __B,
-   (__v32qi) _mm256_setzero_si256 (), (__mmask32) __A);
+   (__v32qi) _mm256_avx512_setzero_si256 (), (__mmask32) __A);
 }
-#ifdef __DISABLE_AVX512VBMI2VLBW__
-#undef __DISABLE_AVX512VBMI2VLBW__
+#ifdef __DISABLE_AVX512VBMI2VL__
+#undef __DISABLE_AVX512VBMI2VL__
 #pragma GCC pop_options
 #endif
 #endif
diff --git a/third_party/intel/avx512vbmiintrin.internal.h b/third_party/intel/avx512vbmiintrin.internal.h
index 54ebf1fce..a8bec07f7 100644
--- a/third_party/intel/avx512vbmiintrin.internal.h
+++ b/third_party/intel/avx512vbmiintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512VBMIINTRIN_H_INCLUDED
 #define _AVX512VBMIINTRIN_H_INCLUDED
-#ifndef __AVX512VBMI__
+#if !defined (__AVX512VBMI__) || !defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vbmi")
+#pragma GCC target("avx512vbmi,evex512")
 #define __DISABLE_AVX512VBMI__
 #endif
 extern __inline __m512i
diff --git a/third_party/intel/avx512vbmivlintrin.internal.h b/third_party/intel/avx512vbmivlintrin.internal.h
index a61ec41d4..a77038635 100644
--- a/third_party/intel/avx512vbmivlintrin.internal.h
+++ b/third_party/intel/avx512vbmivlintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512VBMIVLINTRIN_H_INCLUDED
 #define _AVX512VBMIVLINTRIN_H_INCLUDED
-#if !defined(__AVX512VL__) || !defined(__AVX512VBMI__)
+#if !defined(__AVX512VL__) || !defined(__AVX512VBMI__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vbmi,avx512vl")
+#pragma GCC target("avx512vbmi,avx512vl,no-evex512")
 #define __DISABLE_AVX512VBMIVL__
 #endif
 extern __inline __m256i
@@ -25,7 +25,7 @@ _mm256_maskz_multishift_epi64_epi8 (__mmask32 __M, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_vpmultishiftqb256_mask ((__v32qi) __X,
          (__v32qi) __Y,
          (__v32qi)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask32) __M);
 }
 extern __inline __m256i
@@ -35,7 +35,7 @@ _mm256_multishift_epi64_epi8 (__m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_vpmultishiftqb256_mask ((__v32qi) __X,
          (__v32qi) __Y,
          (__v32qi)
-         _mm256_undefined_si256 (),
+         _mm256_avx512_undefined_si256 (),
          (__mmask32) -1);
 }
 extern __inline __m128i
@@ -54,7 +54,7 @@ _mm_maskz_multishift_epi64_epi8 (__mmask16 __M, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_vpmultishiftqb128_mask ((__v16qi) __X,
          (__v16qi) __Y,
          (__v16qi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask16) __M);
 }
 extern __inline __m128i
@@ -64,7 +64,7 @@ _mm_multishift_epi64_epi8 (__m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_vpmultishiftqb128_mask ((__v16qi) __X,
          (__v16qi) __Y,
          (__v16qi)
-         _mm_undefined_si128 (),
+         _mm_avx512_undefined_si128 (),
          (__mmask16) -1);
 }
 extern __inline __m256i
@@ -74,7 +74,7 @@ _mm256_permutexvar_epi8 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_permvarqi256_mask ((__v32qi) __B,
            (__v32qi) __A,
            (__v32qi)
-           _mm256_undefined_si256 (),
+           _mm256_avx512_undefined_si256 (),
            (__mmask32) -1);
 }
 extern __inline __m256i
@@ -85,7 +85,7 @@ _mm256_maskz_permutexvar_epi8 (__mmask32 __M, __m256i __A,
   return (__m256i) __builtin_ia32_permvarqi256_mask ((__v32qi) __B,
            (__v32qi) __A,
            (__v32qi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask32) __M);
 }
 extern __inline __m256i
@@ -105,7 +105,7 @@ _mm_permutexvar_epi8 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_permvarqi128_mask ((__v16qi) __B,
            (__v16qi) __A,
            (__v16qi)
-           _mm_undefined_si128 (),
+           _mm_avx512_undefined_si128 (),
            (__mmask16) -1);
 }
 extern __inline __m128i
@@ -115,7 +115,7 @@ _mm_maskz_permutexvar_epi8 (__mmask16 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_permvarqi128_mask ((__v16qi) __B,
            (__v16qi) __A,
            (__v16qi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask16) __M);
 }
 extern __inline __m128i
diff --git a/third_party/intel/avx512vlbwintrin.internal.h b/third_party/intel/avx512vlbwintrin.internal.h
index 03b3f5d04..f01024b9b 100644
--- a/third_party/intel/avx512vlbwintrin.internal.h
+++ b/third_party/intel/avx512vlbwintrin.internal.h
@@ -4,15 +4,119 @@
 #endif
 #ifndef _AVX512VLBWINTRIN_H_INCLUDED
 #define _AVX512VLBWINTRIN_H_INCLUDED
-#if !defined(__AVX512VL__) || !defined(__AVX512BW__)
+#if !defined(__AVX512VL__) || !defined(__AVX512BW__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vl,avx512bw")
+#pragma GCC target("avx512vl,avx512bw,no-evex512")
 #define __DISABLE_AVX512VLBW__
 #endif
 typedef short __v16hi_u __attribute__ ((__vector_size__ (32), __may_alias__, __aligned__ (1)));
 typedef short __v8hi_u __attribute__ ((__vector_size__ (16), __may_alias__, __aligned__ (1)));
 typedef char __v32qi_u __attribute__ ((__vector_size__ (32), __may_alias__, __aligned__ (1)));
 typedef char __v16qi_u __attribute__ ((__vector_size__ (16), __may_alias__, __aligned__ (1)));
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_set1_epi32 (int __A)
+{
+  return _mm_avx512_set_epi32 (__A, __A, __A, __A);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_set1_epi16 (short __A)
+{
+  return _mm_avx512_set_epi16 (__A, __A, __A, __A, __A, __A, __A, __A);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_set1_epi8 (char __A)
+{
+  return _mm_avx512_set_epi8 (__A, __A, __A, __A, __A, __A, __A, __A,
+         __A, __A, __A, __A, __A, __A, __A, __A);
+}
+extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_set_epi16 (short __q15, short __q14, short __q13, short __q12,
+    short __q11, short __q10, short __q09, short __q08,
+    short __q07, short __q06, short __q05, short __q04,
+    short __q03, short __q02, short __q01, short __q00)
+{
+  return __extension__ (__m256i)(__v16hi){
+    __q00, __q01, __q02, __q03, __q04, __q05, __q06, __q07,
+    __q08, __q09, __q10, __q11, __q12, __q13, __q14, __q15
+  };
+}
+extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_set_epi8 (char __q31, char __q30, char __q29, char __q28,
+    char __q27, char __q26, char __q25, char __q24,
+    char __q23, char __q22, char __q21, char __q20,
+    char __q19, char __q18, char __q17, char __q16,
+    char __q15, char __q14, char __q13, char __q12,
+    char __q11, char __q10, char __q09, char __q08,
+    char __q07, char __q06, char __q05, char __q04,
+    char __q03, char __q02, char __q01, char __q00)
+{
+  return __extension__ (__m256i)(__v32qi){
+    __q00, __q01, __q02, __q03, __q04, __q05, __q06, __q07,
+    __q08, __q09, __q10, __q11, __q12, __q13, __q14, __q15,
+    __q16, __q17, __q18, __q19, __q20, __q21, __q22, __q23,
+    __q24, __q25, __q26, __q27, __q28, __q29, __q30, __q31
+  };
+}
+extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_set1_epi16 (short __A)
+{
+  return _mm256_avx512_set_epi16 (__A, __A, __A, __A, __A, __A, __A, __A,
+      __A, __A, __A, __A, __A, __A, __A, __A);
+}
+extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_set1_epi32 (int __A)
+{
+  return __extension__ (__m256i)(__v8si){ __A, __A, __A, __A,
+       __A, __A, __A, __A };
+}
+extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_set1_epi8 (char __A)
+{
+  return _mm256_avx512_set_epi8 (__A, __A, __A, __A, __A, __A, __A, __A,
+     __A, __A, __A, __A, __A, __A, __A, __A,
+     __A, __A, __A, __A, __A, __A, __A, __A,
+     __A, __A, __A, __A, __A, __A, __A, __A);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_max_epi16 (__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_pmaxsw128 ((__v8hi)__A, (__v8hi)__B);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_min_epi16 (__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_pminsw128 ((__v8hi)__A, (__v8hi)__B);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_max_epu16 (__m128i __X, __m128i __Y)
+{
+  return (__m128i) __builtin_ia32_pmaxuw128 ((__v8hi)__X, (__v8hi)__Y);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_min_epu16 (__m128i __X, __m128i __Y)
+{
+  return (__m128i) __builtin_ia32_pminuw128 ((__v8hi)__X, (__v8hi)__Y);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_max_epi8 (__m128i __X, __m128i __Y)
+{
+  return (__m128i) __builtin_ia32_pmaxsb128 ((__v16qi)__X, (__v16qi)__Y);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_min_epi8 (__m128i __X, __m128i __Y)
+{
+  return (__m128i) __builtin_ia32_pminsb128 ((__v16qi)__X, (__v16qi)__Y);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_max_epu8 (__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_pmaxub128 ((__v16qi)__A, (__v16qi)__B);
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_min_epu8 (__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_pminub128 ((__v16qi)__A, (__v16qi)__B);
+}
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_mov_epi8 (__m256i __W, __mmask32 __U, __m256i __A)
@@ -23,11 +127,63 @@ _mm256_mask_mov_epi8 (__m256i __W, __mmask32 __U, __m256i __A)
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_max_epi16 (__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_pmaxsw256 ((__v16hi)__A, (__v16hi)__B);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_min_epi16 (__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_pminsw256 ((__v16hi)__A, (__v16hi)__B);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_max_epu16 (__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_pmaxuw256 ((__v16hi)__A, (__v16hi)__B);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_min_epu16 (__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_pminuw256 ((__v16hi)__A, (__v16hi)__B);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_insertf128_ps (__m256 __X, __m128 __Y, const int __O)
+{
+  return (__m256) __builtin_ia32_vinsertf128_ps256 ((__v8sf)__X,
+          (__v4sf)__Y,
+          __O);
+}
+extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_extractf128_pd (__m256d __X, const int __N)
+{
+  return (__m128d) __builtin_ia32_vextractf128_pd256 ((__v4df)__X, __N);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_extracti128_si256 (__m256i __X, const int __M)
+{
+  return (__m128i) __builtin_ia32_extract128i256 ((__v4di)__X, __M);
+}
+#else
+#define _mm256_avx512_insertf128_ps(X, Y, O) ((__m256) __builtin_ia32_vinsertf128_ps256 ((__v8sf)(__m256)(X), (__v4sf)(__m128)(Y), (int)(O)))
+#define _mm256_avx512_extractf128_pd(X, N) ((__m128d) __builtin_ia32_vextractf128_pd256 ((__v4df)(__m256d)(X), (int)(N)))
+#define _mm256_avx512_extracti128_si256(X, M) ((__m128i) __builtin_ia32_extract128i256 ((__v4di)(__m256i)(X), (int)(M)))
+#endif
+#define _MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI16(op) __v8hi __T1 = (__v8hi)_mm256_avx512_extracti128_si256 (__W, 0); __v8hi __T2 = (__v8hi)_mm256_avx512_extracti128_si256 (__W, 1); __v8hi __T3 = __T1 op __T2; __v8hi __T4 = __builtin_shufflevector (__T3, __T3, 4, 5, 6, 7, 4, 5, 6, 7); __v8hi __T5 = __T3 op __T4; __v8hi __T6 = __builtin_shufflevector (__T5, __T5, 2, 3, 2, 3, 4, 5, 6, 7); __v8hi __T7 = __T5 op __T6; __v8hi __T8 = __builtin_shufflevector (__T7, __T7, 1, 1, 2, 3, 4, 5, 6, 7); __v8hi __T9 = __T7 op __T8; return __T9[0]
+#define _MM256_AVX512_REDUCE_OPERATOR_MAX_MIN_EP16(op) __m128i __T1 = _mm256_avx512_extracti128_si256 (__V, 0); __m128i __T2 = _mm256_avx512_extracti128_si256 (__V, 1); __m128i __T3 = _mm_avx512_##op (__T1, __T2); __m128i __T4 = (__m128i)__builtin_shufflevector ((__v8hi)__T3, (__v8hi)__T3, 4, 5, 6, 7, 4, 5, 6, 7); __m128i __T5 = _mm_avx512_##op (__T3, __T4); __m128i __T6 = (__m128i)__builtin_shufflevector ((__v8hi)__T5, (__v8hi)__T5, 2, 3, 2, 3, 4, 5, 6, 7); __m128i __T7 = _mm_avx512_##op (__T5, __T6); __m128i __T8 = (__m128i)__builtin_shufflevector ((__v8hi)__T7, (__v8hi)__T7, 1, 1, 2, 3, 4, 5, 6, 7); __v8hi __T9 = (__v8hi)_mm_avx512_##op (__T7, __T8); return __T9[0]
+#define _MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI8(op) __v16qi __T1 = (__v16qi)_mm256_avx512_extracti128_si256 (__W, 0); __v16qi __T2 = (__v16qi)_mm256_avx512_extracti128_si256 (__W, 1); __v16qi __T3 = __T1 op __T2; __v16qi __T4 = __builtin_shufflevector (__T3, __T3, 8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T5 = __T3 op __T4; __v16qi __T6 = __builtin_shufflevector (__T5, __T5, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T7 = __T5 op __T6; __v16qi __T8 = __builtin_shufflevector (__T7, __T7, 2, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T9 = __T7 op __T8; __v16qi __T10 = __builtin_shufflevector (__T9, __T9, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T11 = __T9 op __T10; return __T11[0]
+#define _MM256_AVX512_REDUCE_OPERATOR_MAX_MIN_EP8(op) __m128i __T1 = _mm256_avx512_extracti128_si256 (__V, 0); __m128i __T2 = _mm256_avx512_extracti128_si256 (__V, 1); __m128i __T3 = _mm_avx512_##op (__T1, __T2); __m128i __T4 = (__m128i)__builtin_shufflevector ((__v16qi)__T3, (__v16qi)__T3, 8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15); __m128i __T5 = _mm_avx512_##op (__T3, __T4); __m128i __T6 = (__m128i)__builtin_shufflevector ((__v16qi)__T5, (__v16qi)__T5, 4, 5, 6, 7, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __m128i __T7 = _mm_avx512_##op (__T5, __T6); __m128i __T8 = (__m128i)__builtin_shufflevector ((__v16qi)__T7, (__v16qi)__T5, 2, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __m128i __T9 = _mm_avx512_##op (__T7, __T8); __m128i __T10 = (__m128i)__builtin_shufflevector ((__v16qi)__T9, (__v16qi)__T9, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); __v16qi __T11 = (__v16qi)_mm_avx512_##op (__T9, __T10); return __T11[0]
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_mov_epi8 (__mmask32 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_movdquqi256_mask ((__v32qi) __A,
           (__v32qi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask32) __U);
 }
 extern __inline __m128i
@@ -44,7 +200,7 @@ _mm_maskz_mov_epi8 (__mmask16 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_movdquqi128_mask ((__v16qi) __A,
           (__v16qi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask16) __U);
 }
 extern __inline void
@@ -95,7 +251,7 @@ _mm256_maskz_loadu_epi16 (__mmask16 __U, void const *__P)
 {
   return (__m256i) __builtin_ia32_loaddquhi256_mask ((const short *) __P,
            (__v16hi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask16) __U);
 }
 extern __inline __m128i
@@ -118,7 +274,7 @@ _mm_maskz_loadu_epi16 (__mmask8 __U, void const *__P)
 {
   return (__m128i) __builtin_ia32_loaddquhi128_mask ((const short *) __P,
            (__v8hi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -135,7 +291,7 @@ _mm256_maskz_mov_epi16 (__mmask16 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_movdquhi256_mask ((__v16hi) __A,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask16) __U);
 }
 extern __inline __m128i
@@ -152,7 +308,7 @@ _mm_maskz_mov_epi16 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_movdquhi128_mask ((__v8hi) __A,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -175,7 +331,7 @@ _mm256_maskz_loadu_epi8 (__mmask32 __U, void const *__P)
 {
   return (__m256i) __builtin_ia32_loaddquqi256_mask ((const char *) __P,
            (__v32qi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask32) __U);
 }
 extern __inline __m128i
@@ -198,15 +354,47 @@ _mm_maskz_loadu_epi8 (__mmask16 __U, void const *__P)
 {
   return (__m128i) __builtin_ia32_loaddquqi128_mask ((const char *) __P,
            (__v16qi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask16) __U);
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_blend_epi16 (__mmask8 __U, __m128i __A, __m128i __W)
+{
+  return (__m128i) __builtin_ia32_blendmw_128_mask ((__v8hi) __A,
+          (__v8hi) __W,
+          (__mmask8) __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_blend_epi8 (__mmask16 __U, __m128i __A, __m128i __W)
+{
+  return (__m128i) __builtin_ia32_blendmb_128_mask ((__v16qi) __A,
+          (__v16qi) __W,
+          (__mmask16) __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_blend_epi16 (__mmask16 __U, __m256i __A, __m256i __W)
+{
+  return (__m256i) __builtin_ia32_blendmw_256_mask ((__v16hi) __A,
+          (__v16hi) __W,
+          (__mmask16) __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_blend_epi8 (__mmask32 __U, __m256i __A, __m256i __W)
+{
+  return (__m256i) __builtin_ia32_blendmb_256_mask ((__v32qi) __A,
+          (__v32qi) __W,
+          (__mmask32) __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvtepi16_epi8 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovwb256_mask ((__v16hi) __A,
-        (__v16qi)_mm_undefined_si128(),
+        (__v16qi)_mm_avx512_undefined_si128(),
         (__mmask16) -1);
 }
 extern __inline void
@@ -228,7 +416,7 @@ _mm256_maskz_cvtepi16_epi8 (__mmask16 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovwb256_mask ((__v16hi) __A,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -236,7 +424,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvtsepi16_epi8 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovswb128_mask ((__v8hi) __A,
-         (__v16qi)_mm_undefined_si128(),
+         (__v16qi)_mm_avx512_undefined_si128(),
          (__mmask8) -1);
 }
 extern __inline void
@@ -258,7 +446,7 @@ _mm_maskz_cvtsepi16_epi8 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovswb128_mask ((__v8hi) __A,
          (__v16qi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -266,7 +454,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvtsepi16_epi8 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovswb256_mask ((__v16hi) __A,
-         (__v16qi)_mm_undefined_si128(),
+         (__v16qi)_mm_avx512_undefined_si128(),
          (__mmask16) -1);
 }
 extern __inline void
@@ -288,7 +476,7 @@ _mm256_maskz_cvtsepi16_epi8 (__mmask16 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovswb256_mask ((__v16hi) __A,
          (__v16qi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -296,7 +484,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvtusepi16_epi8 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovuswb128_mask ((__v8hi) __A,
-          (__v16qi)_mm_undefined_si128(),
+          (__v16qi)_mm_avx512_undefined_si128(),
           (__mmask8) -1);
 }
 extern __inline void
@@ -319,7 +507,7 @@ _mm_maskz_cvtusepi16_epi8 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovuswb128_mask ((__v8hi) __A,
           (__v16qi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -327,7 +515,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cvtusepi16_epi8 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovuswb256_mask ((__v16hi) __A,
-          (__v16qi)_mm_undefined_si128(),
+          (__v16qi)_mm_avx512_undefined_si128(),
           (__mmask16) -1);
 }
 extern __inline void
@@ -350,7 +538,7 @@ _mm256_maskz_cvtusepi16_epi8 (__mmask16 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovuswb256_mask ((__v16hi) __A,
           (__v16qi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m256i
@@ -367,7 +555,7 @@ _mm256_maskz_broadcastb_epi8 (__mmask32 __M, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pbroadcastb256_mask ((__v16qi) __A,
              (__v32qi)
-             _mm256_setzero_si256 (),
+             _mm256_avx512_setzero_si256 (),
              __M);
 }
 extern __inline __m256i
@@ -384,7 +572,7 @@ _mm256_maskz_set1_epi8 (__mmask32 __M, char __A)
 {
   return (__m256i) __builtin_ia32_pbroadcastb256_gpr_mask (__A,
           (__v32qi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m128i
@@ -401,7 +589,7 @@ _mm_maskz_broadcastb_epi8 (__mmask16 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pbroadcastb128_mask ((__v16qi) __A,
              (__v16qi)
-             _mm_setzero_si128 (),
+             _mm_avx512_setzero_si128 (),
              __M);
 }
 extern __inline __m128i
@@ -418,7 +606,7 @@ _mm_maskz_set1_epi8 (__mmask16 __M, char __A)
 {
   return (__m128i) __builtin_ia32_pbroadcastb128_gpr_mask (__A,
           (__v16qi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m256i
@@ -435,7 +623,7 @@ _mm256_maskz_broadcastw_epi16 (__mmask16 __M, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pbroadcastw256_mask ((__v8hi) __A,
              (__v16hi)
-             _mm256_setzero_si256 (),
+             _mm256_avx512_setzero_si256 (),
              __M);
 }
 extern __inline __m256i
@@ -452,7 +640,7 @@ _mm256_maskz_set1_epi16 (__mmask16 __M, short __A)
 {
   return (__m256i) __builtin_ia32_pbroadcastw256_gpr_mask (__A,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m128i
@@ -469,7 +657,7 @@ _mm_maskz_broadcastw_epi16 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pbroadcastw128_mask ((__v8hi) __A,
              (__v8hi)
-             _mm_setzero_si128 (),
+             _mm_avx512_setzero_si128 (),
              __M);
 }
 extern __inline __m128i
@@ -486,7 +674,7 @@ _mm_maskz_set1_epi16 (__mmask8 __M, short __A)
 {
   return (__m128i) __builtin_ia32_pbroadcastw128_gpr_mask (__A,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m256i
@@ -496,7 +684,7 @@ _mm256_permutexvar_epi16 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_permvarhi256_mask ((__v16hi) __B,
            (__v16hi) __A,
            (__v16hi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask16) -1);
 }
 extern __inline __m256i
@@ -507,7 +695,7 @@ _mm256_maskz_permutexvar_epi16 (__mmask16 __M, __m256i __A,
   return (__m256i) __builtin_ia32_permvarhi256_mask ((__v16hi) __B,
            (__v16hi) __A,
            (__v16hi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask16) __M);
 }
 extern __inline __m256i
@@ -527,7 +715,7 @@ _mm_permutexvar_epi16 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_permvarhi128_mask ((__v8hi) __B,
            (__v8hi) __A,
            (__v8hi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -537,7 +725,7 @@ _mm_maskz_permutexvar_epi16 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_permvarhi128_mask ((__v8hi) __B,
            (__v8hi) __A,
            (__v8hi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __M);
 }
 extern __inline __m128i
@@ -659,7 +847,7 @@ _mm256_maskz_maddubs_epi16 (__mmask16 __U, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_pmaddubsw256_mask ((__v32qi) __X,
            (__v32qi) __Y,
            (__v16hi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask16) __U);
 }
 extern __inline __m128i
@@ -679,7 +867,7 @@ _mm_maskz_maddubs_epi16 (__mmask8 __U, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_pmaddubsw128_mask ((__v16qi) __X,
            (__v16qi) __Y,
            (__v8hi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -699,7 +887,7 @@ _mm256_maskz_madd_epi16 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaddwd256_mask ((__v16hi) __A,
          (__v16hi) __B,
          (__v8si)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask8) __U);
 }
 extern __inline __m128i
@@ -719,7 +907,7 @@ _mm_maskz_madd_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaddwd128_mask ((__v8hi) __A,
          (__v8hi) __B,
          (__v4si)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask8) __U);
 }
 extern __inline __mmask16
@@ -837,7 +1025,7 @@ _mm256_maskz_min_epu16 (__mmask16 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pminuw256_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __M);
 }
 extern __inline __m256i
@@ -857,7 +1045,7 @@ _mm_maskz_min_epu16 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pminuw128_mask ((__v8hi) __A,
         (__v8hi) __B,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __M);
 }
 extern __inline __m128i
@@ -877,7 +1065,7 @@ _mm256_maskz_min_epi16 (__mmask16 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pminsw256_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __M);
 }
 extern __inline __m256i
@@ -897,7 +1085,7 @@ _mm256_maskz_max_epu8 (__mmask32 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaxub256_mask ((__v32qi) __A,
         (__v32qi) __B,
         (__v32qi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask32) __M);
 }
 extern __inline __m256i
@@ -917,7 +1105,7 @@ _mm_maskz_max_epu8 (__mmask16 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaxub128_mask ((__v16qi) __A,
         (__v16qi) __B,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask16) __M);
 }
 extern __inline __m128i
@@ -937,7 +1125,7 @@ _mm256_maskz_max_epi8 (__mmask32 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaxsb256_mask ((__v32qi) __A,
         (__v32qi) __B,
         (__v32qi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask32) __M);
 }
 extern __inline __m256i
@@ -957,7 +1145,7 @@ _mm_maskz_max_epi8 (__mmask16 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaxsb128_mask ((__v16qi) __A,
         (__v16qi) __B,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask16) __M);
 }
 extern __inline __m128i
@@ -977,7 +1165,7 @@ _mm256_maskz_min_epu8 (__mmask32 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pminub256_mask ((__v32qi) __A,
         (__v32qi) __B,
         (__v32qi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask32) __M);
 }
 extern __inline __m256i
@@ -997,7 +1185,7 @@ _mm_maskz_min_epu8 (__mmask16 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pminub128_mask ((__v16qi) __A,
         (__v16qi) __B,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask16) __M);
 }
 extern __inline __m128i
@@ -1017,7 +1205,7 @@ _mm256_maskz_min_epi8 (__mmask32 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pminsb256_mask ((__v32qi) __A,
         (__v32qi) __B,
         (__v32qi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask32) __M);
 }
 extern __inline __m256i
@@ -1037,7 +1225,7 @@ _mm_maskz_min_epi8 (__mmask16 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pminsb128_mask ((__v16qi) __A,
         (__v16qi) __B,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask16) __M);
 }
 extern __inline __m128i
@@ -1057,7 +1245,7 @@ _mm256_maskz_max_epi16 (__mmask16 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaxsw256_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __M);
 }
 extern __inline __m256i
@@ -1077,7 +1265,7 @@ _mm_maskz_max_epi16 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaxsw128_mask ((__v8hi) __A,
         (__v8hi) __B,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __M);
 }
 extern __inline __m128i
@@ -1097,7 +1285,7 @@ _mm256_maskz_max_epu16 (__mmask16 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaxuw256_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __M);
 }
 extern __inline __m256i
@@ -1117,7 +1305,7 @@ _mm_maskz_max_epu16 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaxuw128_mask ((__v8hi) __A,
         (__v8hi) __B,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __M);
 }
 extern __inline __m128i
@@ -1137,7 +1325,7 @@ _mm_maskz_min_epi16 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pminsw128_mask ((__v8hi) __A,
         (__v8hi) __B,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __M);
 }
 extern __inline __m128i
@@ -1171,7 +1359,7 @@ _mm256_maskz_alignr_epi8 (__mmask32 __U, __m256i __A, __m256i __B,
          (__v4di) __B,
          __N * 8,
          (__v4di)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask32) __U);
 }
 extern __inline __m128i
@@ -1194,7 +1382,7 @@ _mm_maskz_alignr_epi8 (__mmask16 __U, __m128i __A, __m128i __B,
          (__v2di) __B,
          __N * 8,
          (__v2di)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask16) __U);
 }
 extern __inline __m256i
@@ -1205,7 +1393,7 @@ _mm256_dbsad_epu8 (__m256i __A, __m256i __B, const int __imm)
           (__v32qi) __B,
           __imm,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask16) -1);
 }
 extern __inline __m256i
@@ -1228,7 +1416,7 @@ _mm256_maskz_dbsad_epu8 (__mmask16 __U, __m256i __A, __m256i __B,
           (__v32qi) __B,
           __imm,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask16) __U);
 }
 extern __inline __m128i
@@ -1239,7 +1427,7 @@ _mm_dbsad_epu8 (__m128i __A, __m128i __B, const int __imm)
           (__v16qi) __B,
           __imm,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1262,41 +1450,9 @@ _mm_maskz_dbsad_epu8 (__mmask8 __U, __m128i __A, __m128i __B,
           (__v16qi) __B,
           __imm,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_blend_epi16 (__mmask8 __U, __m128i __A, __m128i __W)
-{
-  return (__m128i) __builtin_ia32_blendmw_128_mask ((__v8hi) __A,
-          (__v8hi) __W,
-          (__mmask8) __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_blend_epi8 (__mmask16 __U, __m128i __A, __m128i __W)
-{
-  return (__m128i) __builtin_ia32_blendmb_128_mask ((__v16qi) __A,
-          (__v16qi) __W,
-          (__mmask16) __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_blend_epi16 (__mmask16 __U, __m256i __A, __m256i __W)
-{
-  return (__m256i) __builtin_ia32_blendmw_256_mask ((__v16hi) __A,
-          (__v16hi) __W,
-          (__mmask16) __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_blend_epi8 (__mmask32 __U, __m256i __A, __m256i __W)
-{
-  return (__m256i) __builtin_ia32_blendmb_256_mask ((__v32qi) __A,
-          (__v32qi) __W,
-          (__mmask32) __U);
-}
 extern __inline __mmask8
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_mask_cmp_epi16_mask (__mmask8 __U, __m128i __X, __m128i __Y,
@@ -1448,7 +1604,7 @@ _mm256_maskz_srli_epi16 (__mmask16 __U, __m256i __A, const int __imm)
 {
   return (__m256i) __builtin_ia32_psrlwi256_mask ((__v16hi) __A, __imm,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __U);
 }
 extern __inline __m128i
@@ -1466,7 +1622,7 @@ _mm_maskz_srli_epi16 (__mmask8 __U, __m128i __A, const int __imm)
 {
   return (__m128i) __builtin_ia32_psrlwi128_mask ((__v8hi) __A, __imm,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -1487,7 +1643,7 @@ _mm256_maskz_shufflehi_epi16 (__mmask16 __U, __m256i __A,
   return (__m256i) __builtin_ia32_pshufhw256_mask ((__v16hi) __A,
          __imm,
          (__v16hi)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask16) __U);
 }
 extern __inline __m128i
@@ -1505,7 +1661,7 @@ _mm_maskz_shufflehi_epi16 (__mmask8 __U, __m128i __A, const int __imm)
 {
   return (__m128i) __builtin_ia32_pshufhw128_mask ((__v8hi) __A, __imm,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask8) __U);
 }
 extern __inline __m256i
@@ -1526,7 +1682,7 @@ _mm256_maskz_shufflelo_epi16 (__mmask16 __U, __m256i __A,
   return (__m256i) __builtin_ia32_pshuflw256_mask ((__v16hi) __A,
          __imm,
          (__v16hi)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask16) __U);
 }
 extern __inline __m128i
@@ -1544,13 +1700,13 @@ _mm_maskz_shufflelo_epi16 (__mmask8 __U, __m128i __A, const int __imm)
 {
   return (__m128i) __builtin_ia32_pshuflw128_mask ((__v8hi) __A, __imm,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask8) __U);
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_srai_epi16 (__m256i __W, __mmask16 __U, __m256i __A,
-   const int __imm)
+   const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psrawi256_mask ((__v16hi) __A, __imm,
         (__v16hi) __W,
@@ -1558,17 +1714,17 @@ _mm256_mask_srai_epi16 (__m256i __W, __mmask16 __U, __m256i __A,
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_srai_epi16 (__mmask16 __U, __m256i __A, const int __imm)
+_mm256_maskz_srai_epi16 (__mmask16 __U, __m256i __A, const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psrawi256_mask ((__v16hi) __A, __imm,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __U);
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_mask_srai_epi16 (__m128i __W, __mmask8 __U, __m128i __A,
-       const int __imm)
+       const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psrawi128_mask ((__v8hi) __A, __imm,
         (__v8hi) __W,
@@ -1576,17 +1732,17 @@ _mm_mask_srai_epi16 (__m128i __W, __mmask8 __U, __m128i __A,
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_srai_epi16 (__mmask8 __U, __m128i __A, const int __imm)
+_mm_maskz_srai_epi16 (__mmask8 __U, __m128i __A, const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psrawi128_mask ((__v8hi) __A, __imm,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_slli_epi16 (__m256i __W, __mmask16 __U, __m256i __A,
-   int __B)
+   unsigned int __B)
 {
   return (__m256i) __builtin_ia32_psllwi256_mask ((__v16hi) __A, __B,
         (__v16hi) __W,
@@ -1594,16 +1750,16 @@ _mm256_mask_slli_epi16 (__m256i __W, __mmask16 __U, __m256i __A,
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_slli_epi16 (__mmask16 __U, __m256i __A, int __B)
+_mm256_maskz_slli_epi16 (__mmask16 __U, __m256i __A, unsigned int __B)
 {
   return (__m256i) __builtin_ia32_psllwi256_mask ((__v16hi) __A, __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __U);
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_slli_epi16 (__m128i __W, __mmask8 __U, __m128i __A, int __B)
+_mm_mask_slli_epi16 (__m128i __W, __mmask8 __U, __m128i __A, unsigned int __B)
 {
   return (__m128i) __builtin_ia32_psllwi128_mask ((__v8hi) __A, __B,
         (__v8hi) __W,
@@ -1611,48 +1767,44 @@ _mm_mask_slli_epi16 (__m128i __W, __mmask8 __U, __m128i __A, int __B)
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_slli_epi16 (__mmask8 __U, __m128i __A, int __B)
+_mm_maskz_slli_epi16 (__mmask8 __U, __m128i __A, unsigned int __B)
 {
   return (__m128i) __builtin_ia32_psllwi128_mask ((__v8hi) __A, __B,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 #else
 #define _mm256_mask_alignr_epi8(W, U, X, Y, N) ((__m256i) __builtin_ia32_palignr256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)((N) * 8), (__v4di)(__m256i)(X), (__mmask32)(U)))
 #define _mm256_mask_srli_epi16(W, U, A, B) ((__m256i) __builtin_ia32_psrlwi256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)(__m256i)(W), (__mmask16)(U)))
-#define _mm256_maskz_srli_epi16(U, A, B) ((__m256i) __builtin_ia32_psrlwi256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)_mm256_setzero_si256 (), (__mmask16)(U)))
+#define _mm256_maskz_srli_epi16(U, A, B) ((__m256i) __builtin_ia32_psrlwi256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)_mm256_avx512_setzero_si256 (), (__mmask16)(U)))
 #define _mm_mask_srli_epi16(W, U, A, B) ((__m128i) __builtin_ia32_psrlwi128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_srli_epi16(U, A, B) ((__m128i) __builtin_ia32_psrlwi128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)_mm_setzero_si128(), (__mmask8)(U)))
-#define _mm256_mask_srai_epi16(W, U, A, B) ((__m256i) __builtin_ia32_psrawi256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)(__m256i)(W), (__mmask16)(U)))
-#define _mm256_maskz_srai_epi16(U, A, B) ((__m256i) __builtin_ia32_psrawi256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)_mm256_setzero_si256 (), (__mmask16)(U)))
-#define _mm_mask_srai_epi16(W, U, A, B) ((__m128i) __builtin_ia32_psrawi128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_srai_epi16(U, A, B) ((__m128i) __builtin_ia32_psrawi128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)_mm_setzero_si128(), (__mmask8)(U)))
+#define _mm_maskz_srli_epi16(U, A, B) ((__m128i) __builtin_ia32_psrlwi128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_mask_srai_epi16(W, U, A, B) ((__m256i) __builtin_ia32_psrawi256_mask ((__v16hi)(__m256i)(A), (unsigned int)(B), (__v16hi)(__m256i)(W), (__mmask16)(U)))
+#define _mm256_maskz_srai_epi16(U, A, B) ((__m256i) __builtin_ia32_psrawi256_mask ((__v16hi)(__m256i)(A), (unsigned int)(B), (__v16hi)_mm256_avx512_setzero_si256 (), (__mmask16)(U)))
+#define _mm_mask_srai_epi16(W, U, A, B) ((__m128i) __builtin_ia32_psrawi128_mask ((__v8hi)(__m128i)(A), (unsigned int)(B), (__v8hi)(__m128i)(W), (__mmask8)(U)))
+#define _mm_maskz_srai_epi16(U, A, B) ((__m128i) __builtin_ia32_psrawi128_mask ((__v8hi)(__m128i)(A), (unsigned int)(B), (__v8hi)_mm_avx512_setzero_si128(), (__mmask8)(U)))
 #define _mm256_mask_shufflehi_epi16(W, U, A, B) ((__m256i) __builtin_ia32_pshufhw256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)(__m256i)(W), (__mmask16)(U)))
-#define _mm256_maskz_shufflehi_epi16(U, A, B) ((__m256i) __builtin_ia32_pshufhw256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)(__m256i)_mm256_setzero_si256 (), (__mmask16)(U)))
+#define _mm256_maskz_shufflehi_epi16(U, A, B) ((__m256i) __builtin_ia32_pshufhw256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask16)(U)))
 #define _mm_mask_shufflehi_epi16(W, U, A, B) ((__m128i) __builtin_ia32_pshufhw128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_shufflehi_epi16(U, A, B) ((__m128i) __builtin_ia32_pshufhw128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
+#define _mm_maskz_shufflehi_epi16(U, A, B) ((__m128i) __builtin_ia32_pshufhw128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
 #define _mm256_mask_shufflelo_epi16(W, U, A, B) ((__m256i) __builtin_ia32_pshuflw256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)(__m256i)(W), (__mmask16)(U)))
-#define _mm256_maskz_shufflelo_epi16(U, A, B) ((__m256i) __builtin_ia32_pshuflw256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)(__m256i)_mm256_setzero_si256 (), (__mmask16)(U)))
+#define _mm256_maskz_shufflelo_epi16(U, A, B) ((__m256i) __builtin_ia32_pshuflw256_mask ((__v16hi)(__m256i)(A), (int)(B), (__v16hi)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask16)(U)))
 #define _mm_mask_shufflelo_epi16(W, U, A, B) ((__m128i) __builtin_ia32_pshuflw128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_shufflelo_epi16(U, A, B) ((__m128i) __builtin_ia32_pshuflw128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm256_maskz_alignr_epi8(U, X, Y, N) ((__m256i) __builtin_ia32_palignr256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)((N) * 8), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask32)(U)))
+#define _mm_maskz_shufflelo_epi16(U, A, B) ((__m128i) __builtin_ia32_pshuflw128_mask ((__v8hi)(__m128i)(A), (int)(B), (__v8hi)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_maskz_alignr_epi8(U, X, Y, N) ((__m256i) __builtin_ia32_palignr256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)((N) * 8), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask32)(U)))
 #define _mm_mask_alignr_epi8(W, U, X, Y, N) ((__m128i) __builtin_ia32_palignr128_mask ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)((N) * 8), (__v2di)(__m128i)(X), (__mmask16)(U)))
-#define _mm_maskz_alignr_epi8(U, X, Y, N) ((__m128i) __builtin_ia32_palignr128_mask ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)((N) * 8), (__v2di)(__m128i)_mm_setzero_si128 (), (__mmask16)(U)))
-#define _mm_mask_slli_epi16(W, U, X, C) ((__m128i)__builtin_ia32_psllwi128_mask ((__v8hi)(__m128i)(X), (int)(C), (__v8hi)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_slli_epi16(U, X, C) ((__m128i)__builtin_ia32_psllwi128_mask ((__v8hi)(__m128i)(X), (int)(C), (__v8hi)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm256_dbsad_epu8(X, Y, C) ((__m256i) __builtin_ia32_dbpsadbw256_mask ((__v32qi)(__m256i) (X), (__v32qi)(__m256i) (Y), (int) (C), (__v16hi)(__m256i)_mm256_setzero_si256(), (__mmask16)-1))
-#define _mm256_mask_slli_epi16(W, U, X, C) ((__m256i)__builtin_ia32_psllwi256_mask ((__v16hi)(__m256i)(X), (int)(C), (__v16hi)(__m256i)(W), (__mmask16)(U)))
-#define _mm256_maskz_slli_epi16(U, X, C) ((__m256i)__builtin_ia32_psllwi256_mask ((__v16hi)(__m256i)(X), (int)(C), (__v16hi)(__m256i)_mm256_setzero_si256 (), (__mmask16)(U)))
+#define _mm_maskz_alignr_epi8(U, X, Y, N) ((__m128i) __builtin_ia32_palignr128_mask ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)((N) * 8), (__v2di)(__m128i)_mm_avx512_setzero_si128 (), (__mmask16)(U)))
+#define _mm_mask_slli_epi16(W, U, X, C) ((__m128i)__builtin_ia32_psllwi128_mask ((__v8hi)(__m128i)(X), (unsigned int)(C), (__v8hi)(__m128i)(W), (__mmask8)(U)))
+#define _mm_maskz_slli_epi16(U, X, C) ((__m128i)__builtin_ia32_psllwi128_mask ((__v8hi)(__m128i)(X), (unsigned int)(C), (__v8hi)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_dbsad_epu8(X, Y, C) ((__m256i) __builtin_ia32_dbpsadbw256_mask ((__v32qi)(__m256i) (X), (__v32qi)(__m256i) (Y), (int) (C), (__v16hi)(__m256i)_mm256_avx512_setzero_si256(), (__mmask16)-1))
+#define _mm256_mask_slli_epi16(W, U, X, C) ((__m256i)__builtin_ia32_psllwi256_mask ((__v16hi)(__m256i)(X), (unsigned int)(C), (__v16hi)(__m256i)(W), (__mmask16)(U)))
+#define _mm256_maskz_slli_epi16(U, X, C) ((__m256i)__builtin_ia32_psllwi256_mask ((__v16hi)(__m256i)(X), (unsigned int)(C), (__v16hi)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask16)(U)))
 #define _mm256_mask_dbsad_epu8(W, U, X, Y, C) ((__m256i) __builtin_ia32_dbpsadbw256_mask ((__v32qi)(__m256i) (X), (__v32qi)(__m256i) (Y), (int) (C), (__v16hi)(__m256i)(W), (__mmask16)(U)))
-#define _mm256_maskz_dbsad_epu8(U, X, Y, C) ((__m256i) __builtin_ia32_dbpsadbw256_mask ((__v32qi)(__m256i) (X), (__v32qi)(__m256i) (Y), (int) (C), (__v16hi)(__m256i)_mm256_setzero_si256(), (__mmask16)(U)))
-#define _mm_dbsad_epu8(X, Y, C) ((__m128i) __builtin_ia32_dbpsadbw128_mask ((__v16qi)(__m128i) (X), (__v16qi)(__m128i) (Y), (int) (C), (__v8hi)(__m128i)_mm_setzero_si128(), (__mmask8)-1))
+#define _mm256_maskz_dbsad_epu8(U, X, Y, C) ((__m256i) __builtin_ia32_dbpsadbw256_mask ((__v32qi)(__m256i) (X), (__v32qi)(__m256i) (Y), (int) (C), (__v16hi)(__m256i)_mm256_avx512_setzero_si256(), (__mmask16)(U)))
+#define _mm_dbsad_epu8(X, Y, C) ((__m128i) __builtin_ia32_dbpsadbw128_mask ((__v16qi)(__m128i) (X), (__v16qi)(__m128i) (Y), (int) (C), (__v8hi)(__m128i)_mm_avx512_setzero_si128(), (__mmask8)-1))
 #define _mm_mask_dbsad_epu8(W, U, X, Y, C) ((__m128i) __builtin_ia32_dbpsadbw128_mask ((__v16qi)(__m128i) (X), (__v16qi)(__m128i) (Y), (int) (C), (__v8hi)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_dbsad_epu8(U, X, Y, C) ((__m128i) __builtin_ia32_dbpsadbw128_mask ((__v16qi)(__m128i) (X), (__v16qi)(__m128i) (Y), (int) (C), (__v8hi)(__m128i)_mm_setzero_si128(), (__mmask8)(U)))
-#define _mm_mask_blend_epi16(__U, __A, __W) ((__m128i) __builtin_ia32_blendmw_128_mask ((__v8hi) (__A), (__v8hi) (__W), (__mmask8) (__U)))
-#define _mm_mask_blend_epi8(__U, __A, __W) ((__m128i) __builtin_ia32_blendmb_128_mask ((__v16qi) (__A), (__v16qi) (__W), (__mmask16) (__U)))
-#define _mm256_mask_blend_epi16(__U, __A, __W) ((__m256i) __builtin_ia32_blendmw_256_mask ((__v16hi) (__A), (__v16hi) (__W), (__mmask16) (__U)))
-#define _mm256_mask_blend_epi8(__U, __A, __W) ((__m256i) __builtin_ia32_blendmb_256_mask ((__v32qi) (__A), (__v32qi) (__W), (__mmask32) (__U)))
+#define _mm_maskz_dbsad_epu8(U, X, Y, C) ((__m128i) __builtin_ia32_dbpsadbw128_mask ((__v16qi)(__m128i) (X), (__v16qi)(__m128i) (Y), (int) (C), (__v8hi)(__m128i)_mm_avx512_setzero_si128(), (__mmask8)(U)))
 #define _mm_cmp_epi16_mask(X, Y, P) ((__mmask8) __builtin_ia32_cmpw128_mask ((__v8hi)(__m128i)(X), (__v8hi)(__m128i)(Y), (int)(P), (__mmask8)(-1)))
 #define _mm_cmp_epi8_mask(X, Y, P) ((__mmask16) __builtin_ia32_cmpb128_mask ((__v16qi)(__m128i)(X), (__v16qi)(__m128i)(Y), (int)(P), (__mmask16)(-1)))
 #define _mm256_cmp_epi16_mask(X, Y, P) ((__mmask16) __builtin_ia32_cmpw256_mask ((__v16hi)(__m256i)(X), (__v16hi)(__m256i)(Y), (int)(P), (__mmask16)(-1)))
@@ -1879,7 +2031,7 @@ _mm256_maskz_mulhrs_epi16 (__mmask16 __U, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_pmulhrsw256_mask ((__v16hi) __X,
           (__v16hi) __Y,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask16) __U);
 }
 extern __inline __m256i
@@ -1899,7 +2051,7 @@ _mm256_maskz_mulhi_epu16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmulhuw256_mask ((__v16hi) __A,
          (__v16hi) __B,
          (__v16hi)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask16) __U);
 }
 extern __inline __m256i
@@ -1919,7 +2071,7 @@ _mm256_maskz_mulhi_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmulhw256_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __U);
 }
 extern __inline __m128i
@@ -1939,7 +2091,7 @@ _mm_maskz_mulhi_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmulhw128_mask ((__v8hi) __A,
         (__v8hi) __B,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1959,7 +2111,7 @@ _mm_maskz_mulhi_epu16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmulhuw128_mask ((__v8hi) __A,
          (__v8hi) __B,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1979,7 +2131,7 @@ _mm_maskz_mulhrs_epi16 (__mmask8 __U, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_pmulhrsw128_mask ((__v8hi) __X,
           (__v8hi) __Y,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -1999,7 +2151,7 @@ _mm256_maskz_mullo_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmullw256_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __U);
 }
 extern __inline __m128i
@@ -2019,7 +2171,7 @@ _mm_maskz_mullo_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmullw128_mask ((__v8hi) __A,
         (__v8hi) __B,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2036,7 +2188,7 @@ _mm256_maskz_cvtepi8_epi16 (__mmask16 __U, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pmovsxbw256_mask ((__v16qi) __A,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask16) __U);
 }
 extern __inline __m128i
@@ -2053,7 +2205,7 @@ _mm_maskz_cvtepi8_epi16 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsxbw128_mask ((__v16qi) __A,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2070,7 +2222,7 @@ _mm256_maskz_cvtepu8_epi16 (__mmask16 __U, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pmovzxbw256_mask ((__v16qi) __A,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask16) __U);
 }
 extern __inline __m128i
@@ -2087,7 +2239,7 @@ _mm_maskz_cvtepu8_epi16 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovzxbw128_mask ((__v16qi) __A,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2107,7 +2259,7 @@ _mm256_maskz_avg_epu8 (__mmask32 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pavgb256_mask ((__v32qi) __A,
        (__v32qi) __B,
        (__v32qi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask32) __U);
 }
 extern __inline __m128i
@@ -2127,7 +2279,7 @@ _mm_maskz_avg_epu8 (__mmask16 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pavgb128_mask ((__v16qi) __A,
        (__v16qi) __B,
        (__v16qi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask16) __U);
 }
 extern __inline __m256i
@@ -2147,7 +2299,7 @@ _mm256_maskz_avg_epu16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pavgw256_mask ((__v16hi) __A,
        (__v16hi) __B,
        (__v16hi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask16) __U);
 }
 extern __inline __m128i
@@ -2167,7 +2319,7 @@ _mm_maskz_avg_epu16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pavgw128_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2187,7 +2339,7 @@ _mm256_maskz_add_epi8 (__mmask32 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_paddb256_mask ((__v32qi) __A,
        (__v32qi) __B,
        (__v32qi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask32) __U);
 }
 extern __inline __m256i
@@ -2207,7 +2359,7 @@ _mm256_maskz_add_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_paddw256_mask ((__v16hi) __A,
        (__v16hi) __B,
        (__v16hi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask16) __U);
 }
 extern __inline __m256i
@@ -2227,7 +2379,7 @@ _mm256_maskz_adds_epi8 (__mmask32 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_paddsb256_mask ((__v32qi) __A,
         (__v32qi) __B,
         (__v32qi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask32) __U);
 }
 extern __inline __m256i
@@ -2247,7 +2399,7 @@ _mm256_maskz_adds_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_paddsw256_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __U);
 }
 extern __inline __m256i
@@ -2267,7 +2419,7 @@ _mm256_maskz_adds_epu8 (__mmask32 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_paddusb256_mask ((__v32qi) __A,
          (__v32qi) __B,
          (__v32qi)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask32) __U);
 }
 extern __inline __m256i
@@ -2287,7 +2439,7 @@ _mm256_maskz_adds_epu16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_paddusw256_mask ((__v16hi) __A,
          (__v16hi) __B,
          (__v16hi)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask16) __U);
 }
 extern __inline __m256i
@@ -2307,7 +2459,7 @@ _mm256_maskz_sub_epi8 (__mmask32 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psubb256_mask ((__v32qi) __A,
        (__v32qi) __B,
        (__v32qi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask32) __U);
 }
 extern __inline __m256i
@@ -2327,7 +2479,7 @@ _mm256_maskz_sub_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psubw256_mask ((__v16hi) __A,
        (__v16hi) __B,
        (__v16hi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask16) __U);
 }
 extern __inline __m256i
@@ -2347,7 +2499,7 @@ _mm256_maskz_subs_epi8 (__mmask32 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psubsb256_mask ((__v32qi) __A,
         (__v32qi) __B,
         (__v32qi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask32) __U);
 }
 extern __inline __m256i
@@ -2367,7 +2519,7 @@ _mm256_maskz_subs_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psubsw256_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __U);
 }
 extern __inline __m256i
@@ -2387,7 +2539,7 @@ _mm256_maskz_subs_epu8 (__mmask32 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psubusb256_mask ((__v32qi) __A,
          (__v32qi) __B,
          (__v32qi)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask32) __U);
 }
 extern __inline __m256i
@@ -2407,7 +2559,7 @@ _mm256_maskz_subs_epu16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psubusw256_mask ((__v16hi) __A,
          (__v16hi) __B,
          (__v16hi)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          (__mmask16) __U);
 }
 extern __inline __m128i
@@ -2427,7 +2579,7 @@ _mm_maskz_add_epi8 (__mmask16 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_paddb128_mask ((__v16qi) __A,
        (__v16qi) __B,
        (__v16qi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask16) __U);
 }
 extern __inline __m128i
@@ -2447,7 +2599,7 @@ _mm_maskz_add_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_paddw128_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2467,7 +2619,7 @@ _mm256_maskz_unpackhi_epi8 (__mmask32 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_punpckhbw256_mask ((__v32qi) __A,
            (__v32qi) __B,
            (__v32qi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask32) __U);
 }
 extern __inline __m128i
@@ -2487,7 +2639,7 @@ _mm_maskz_unpackhi_epi8 (__mmask16 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_punpckhbw128_mask ((__v16qi) __A,
            (__v16qi) __B,
            (__v16qi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask16) __U);
 }
 extern __inline __m256i
@@ -2507,7 +2659,7 @@ _mm256_maskz_unpackhi_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_punpckhwd256_mask ((__v16hi) __A,
            (__v16hi) __B,
            (__v16hi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask16) __U);
 }
 extern __inline __m128i
@@ -2527,7 +2679,7 @@ _mm_maskz_unpackhi_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_punpckhwd128_mask ((__v8hi) __A,
            (__v8hi) __B,
            (__v8hi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2547,7 +2699,7 @@ _mm256_maskz_unpacklo_epi8 (__mmask32 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_punpcklbw256_mask ((__v32qi) __A,
            (__v32qi) __B,
            (__v32qi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask32) __U);
 }
 extern __inline __m128i
@@ -2567,7 +2719,7 @@ _mm_maskz_unpacklo_epi8 (__mmask16 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_punpcklbw128_mask ((__v16qi) __A,
            (__v16qi) __B,
            (__v16qi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask16) __U);
 }
 extern __inline __m256i
@@ -2587,7 +2739,7 @@ _mm256_maskz_unpacklo_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_punpcklwd256_mask ((__v16hi) __A,
            (__v16hi) __B,
            (__v16hi)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask16) __U);
 }
 extern __inline __m128i
@@ -2607,7 +2759,7 @@ _mm_maskz_unpacklo_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_punpcklwd128_mask ((__v8hi) __A,
            (__v8hi) __B,
            (__v8hi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __mmask16
@@ -2939,7 +3091,7 @@ _mm256_maskz_shuffle_epi8 (__mmask32 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pshufb256_mask ((__v32qi) __A,
         (__v32qi) __B,
         (__v32qi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask32) __U);
 }
 extern __inline __m128i
@@ -2959,7 +3111,7 @@ _mm_maskz_shuffle_epi8 (__mmask16 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pshufb128_mask ((__v16qi) __A,
         (__v16qi) __B,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask16) __U);
 }
 extern __inline __m256i
@@ -2969,7 +3121,7 @@ _mm256_maskz_packs_epi16 (__mmask32 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_packsswb256_mask ((__v16hi) __A,
           (__v16hi) __B,
           (__v32qi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m256i
@@ -2989,7 +3141,7 @@ _mm_maskz_packs_epi16 (__mmask16 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_packsswb128_mask ((__v8hi) __A,
           (__v8hi) __B,
           (__v16qi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -3009,7 +3161,7 @@ _mm256_maskz_packus_epi16 (__mmask32 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_packuswb256_mask ((__v16hi) __A,
           (__v16hi) __B,
           (__v32qi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m256i
@@ -3029,7 +3181,7 @@ _mm_maskz_packus_epi16 (__mmask16 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_packuswb128_mask ((__v8hi) __A,
           (__v8hi) __B,
           (__v16qi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -3056,7 +3208,7 @@ _mm256_maskz_abs_epi8 (__mmask32 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_pabsb256_mask ((__v32qi) __A,
        (__v32qi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask32) __U);
 }
 extern __inline __m128i
@@ -3073,7 +3225,7 @@ _mm_maskz_abs_epi8 (__mmask16 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pabsb128_mask ((__v16qi) __A,
        (__v16qi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask16) __U);
 }
 extern __inline __m256i
@@ -3090,7 +3242,7 @@ _mm256_maskz_abs_epi16 (__mmask16 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_pabsw256_mask ((__v16hi) __A,
        (__v16hi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3107,7 +3259,7 @@ _mm_maskz_abs_epi16 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pabsw128_mask ((__v8hi) __A,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __mmask32
@@ -3229,7 +3381,7 @@ _mm_maskz_subs_epi8 (__mmask16 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psubsb128_mask ((__v16qi) __A,
         (__v16qi) __B,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3249,7 +3401,7 @@ _mm_maskz_subs_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psubsw128_mask ((__v8hi) __A,
         (__v8hi) __B,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3269,7 +3421,7 @@ _mm_maskz_subs_epu8 (__mmask16 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psubusb128_mask ((__v16qi) __A,
          (__v16qi) __B,
          (__v16qi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3289,7 +3441,7 @@ _mm_maskz_subs_epu16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psubusw128_mask ((__v8hi) __A,
          (__v8hi) __B,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3309,7 +3461,7 @@ _mm256_maskz_srl_epi16 (__mmask16 __U, __m256i __A, __m128i __B)
   return (__m256i) __builtin_ia32_psrlw256_mask ((__v16hi) __A,
        (__v8hi) __B,
        (__v16hi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3329,7 +3481,7 @@ _mm_maskz_srl_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psrlw128_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3349,7 +3501,7 @@ _mm256_maskz_sra_epi16 (__mmask16 __U, __m256i __A, __m128i __B)
   return (__m256i) __builtin_ia32_psraw256_mask ((__v16hi) __A,
        (__v8hi) __B,
        (__v16hi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3369,7 +3521,7 @@ _mm_maskz_sra_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psraw128_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3379,7 +3531,7 @@ _mm_maskz_adds_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_paddsw128_mask ((__v8hi) __A,
         (__v8hi) __B,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3399,7 +3551,7 @@ _mm_maskz_adds_epu8 (__mmask16 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_paddusb128_mask ((__v16qi) __A,
          (__v16qi) __B,
          (__v16qi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3419,7 +3571,7 @@ _mm_maskz_adds_epu16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_paddusw128_mask ((__v8hi) __A,
          (__v8hi) __B,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3439,7 +3591,7 @@ _mm_maskz_sub_epi8 (__mmask16 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psubb128_mask ((__v16qi) __A,
        (__v16qi) __B,
        (__v16qi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3459,7 +3611,7 @@ _mm_maskz_sub_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psubw128_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3479,7 +3631,7 @@ _mm_maskz_adds_epi8 (__mmask16 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_paddsb128_mask ((__v16qi) __A,
         (__v16qi) __B,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3487,7 +3639,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_cvtepi16_epi8 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovwb128_mask ((__v8hi) __A,
-        (__v16qi)_mm_undefined_si128(),
+        (__v16qi)_mm_avx512_undefined_si128(),
         (__mmask8) -1);
 }
 extern __inline void
@@ -3509,7 +3661,7 @@ _mm_maskz_cvtepi16_epi8 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovwb128_mask ((__v8hi) __A,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m256i
@@ -3519,7 +3671,7 @@ _mm256_srav_epi16 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psrav16hi_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) -1);
 }
 extern __inline __m256i
@@ -3539,7 +3691,7 @@ _mm256_maskz_srav_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psrav16hi_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3549,7 +3701,7 @@ _mm_srav_epi16 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psrav8hi_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) -1);
 }
 extern __inline __m128i
@@ -3569,7 +3721,7 @@ _mm_maskz_srav_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psrav8hi_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3579,7 +3731,7 @@ _mm256_srlv_epi16 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psrlv16hi_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) -1);
 }
 extern __inline __m256i
@@ -3599,7 +3751,7 @@ _mm256_maskz_srlv_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psrlv16hi_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3609,7 +3761,7 @@ _mm_srlv_epi16 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psrlv8hi_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) -1);
 }
 extern __inline __m128i
@@ -3629,7 +3781,7 @@ _mm_maskz_srlv_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psrlv8hi_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3639,7 +3791,7 @@ _mm256_sllv_epi16 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psllv16hi_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) -1);
 }
 extern __inline __m256i
@@ -3659,7 +3811,7 @@ _mm256_maskz_sllv_epi16 (__mmask16 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psllv16hi_mask ((__v16hi) __A,
         (__v16hi) __B,
         (__v16hi)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask16) __U);
 }
 extern __inline __m128i
@@ -3669,7 +3821,7 @@ _mm_sllv_epi16 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psllv8hi_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) -1);
 }
 extern __inline __m128i
@@ -3689,7 +3841,7 @@ _mm_maskz_sllv_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psllv8hi_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3709,7 +3861,7 @@ _mm_maskz_sll_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psllw128_mask ((__v8hi) __A,
        (__v8hi) __B,
        (__v8hi)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3729,7 +3881,7 @@ _mm256_maskz_sll_epi16 (__mmask16 __U, __m256i __A, __m128i __B)
   return (__m256i) __builtin_ia32_psllw256_mask ((__v16hi) __A,
        (__v8hi) __B,
        (__v16hi)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask16) __U);
 }
 extern __inline __m256i
@@ -3739,7 +3891,7 @@ _mm256_maskz_packus_epi32 (__mmask16 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_packusdw256_mask ((__v8si) __A,
           (__v8si) __B,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m256i
@@ -3759,7 +3911,7 @@ _mm_maskz_packus_epi32 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_packusdw128_mask ((__v4si) __A,
           (__v4si) __B,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -3778,7 +3930,7 @@ _mm256_maskz_packs_epi32 (__mmask16 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_packssdw256_mask ((__v8si) __A,
           (__v8si) __B,
           (__v16hi)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m256i
@@ -3798,7 +3950,7 @@ _mm_maskz_packs_epi32 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_packssdw128_mask ((__v4si) __A,
           (__v4si) __B,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -4066,6 +4218,230 @@ _mm256_mask_cmple_epi16_mask (__mmask16 __M, __m256i __X, __m256i __Y)
         (__v16hi) __Y, 2,
         (__mmask16) __M);
 }
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_add_epi16 (__mmask8 __M, __m128i __W)
+{
+  __W = _mm_maskz_mov_epi16 (__M, __W);
+  _MM_REDUCE_OPERATOR_BASIC_EPI16 (+);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_mul_epi16 (__mmask8 __M, __m128i __W)
+{
+  __W = _mm_mask_mov_epi16 (_mm_avx512_set1_epi16 (1), __M, __W);
+  _MM_REDUCE_OPERATOR_BASIC_EPI16 (*);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_and_epi16 (__mmask8 __M, __m128i __W)
+{
+  __W = _mm_mask_mov_epi16 (_mm_avx512_set1_epi16 (-1), __M, __W);
+  _MM_REDUCE_OPERATOR_BASIC_EPI16 (&);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_or_epi16 (__mmask8 __M, __m128i __W)
+{
+  __W = _mm_maskz_mov_epi16 (__M, __W);
+  _MM_REDUCE_OPERATOR_BASIC_EPI16 (|);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_max_epi16 (__mmask16 __M, __m128i __V)
+{
+  __V = _mm_mask_mov_epi16 (_mm_avx512_set1_epi16 (-32767-1), __M, __V);
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP16 (avx512_max_epi16);
+}
+extern __inline unsigned short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_max_epu16 (__mmask16 __M, __m128i __V)
+{
+  __V = _mm_maskz_mov_epi16 (__M, __V);
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP16 (avx512_max_epu16);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_min_epi16 (__mmask16 __M, __m128i __V)
+{
+  __V = _mm_mask_mov_epi16 (_mm_avx512_set1_epi16 (32767), __M, __V);
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP16 (avx512_min_epi16);
+}
+extern __inline unsigned short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_min_epu16 (__mmask16 __M, __m128i __V)
+{
+  __V = _mm_mask_mov_epi16 (_mm_avx512_set1_epi16 (-1), __M, __V);
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP16 (avx512_min_epu16);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_add_epi16 (__mmask16 __M, __m256i __W)
+{
+  __W = _mm256_maskz_mov_epi16 (__M, __W);
+  _MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI16 (+);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_mul_epi16 (__mmask16 __M, __m256i __W)
+{
+  __W = _mm256_mask_mov_epi16 (_mm256_avx512_set1_epi16 (1), __M, __W);
+  _MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI16 (*);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_and_epi16 (__mmask16 __M, __m256i __W)
+{
+  __W = _mm256_mask_mov_epi16 (_mm256_avx512_set1_epi16 (-1), __M, __W);
+  _MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI16 (&);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_or_epi16 (__mmask16 __M, __m256i __W)
+{
+  __W = _mm256_maskz_mov_epi16 (__M, __W);
+  _MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI16 (|);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_max_epi16 (__mmask16 __M, __m256i __V)
+{
+  __V = _mm256_mask_mov_epi16 (_mm256_avx512_set1_epi16 (-32767-1), __M, __V);
+  _MM256_AVX512_REDUCE_OPERATOR_MAX_MIN_EP16 (max_epi16);
+}
+extern __inline unsigned short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_max_epu16 (__mmask16 __M, __m256i __V)
+{
+  __V = _mm256_maskz_mov_epi16 (__M, __V);
+  _MM256_AVX512_REDUCE_OPERATOR_MAX_MIN_EP16 (max_epu16);
+}
+extern __inline short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_min_epi16 (__mmask16 __M, __m256i __V)
+{
+  __V = _mm256_mask_mov_epi16 (_mm256_avx512_set1_epi16 (32767), __M, __V);
+  _MM256_AVX512_REDUCE_OPERATOR_MAX_MIN_EP16 (min_epi16);
+}
+extern __inline unsigned short
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_min_epu16 (__mmask16 __M, __m256i __V)
+{
+  __V = _mm256_mask_mov_epi16 (_mm256_avx512_set1_epi16 (-1), __M, __V);
+  _MM256_AVX512_REDUCE_OPERATOR_MAX_MIN_EP16 (min_epu16);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_add_epi8 (__mmask16 __M, __m128i __W)
+{
+  __W = _mm_maskz_mov_epi8 (__M, __W);
+  _MM_REDUCE_OPERATOR_BASIC_EPI8 (+);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_mul_epi8 (__mmask16 __M, __m128i __W)
+{
+  __W = _mm_mask_mov_epi8 (_mm_avx512_set1_epi8 (1), __M, __W);
+  _MM_REDUCE_OPERATOR_BASIC_EPI8 (*);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_and_epi8 (__mmask16 __M, __m128i __W)
+{
+  __W = _mm_mask_mov_epi8 (_mm_avx512_set1_epi8 (-1), __M, __W);
+  _MM_REDUCE_OPERATOR_BASIC_EPI8 (&);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_or_epi8 (__mmask16 __M, __m128i __W)
+{
+  __W = _mm_maskz_mov_epi8 (__M, __W);
+  _MM_REDUCE_OPERATOR_BASIC_EPI8 (|);
+}
+extern __inline signed char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_max_epi8 (__mmask16 __M, __m128i __V)
+{
+  __V = _mm_mask_mov_epi8 (_mm_avx512_set1_epi8 (-127-1), __M, __V);
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP8 (avx512_max_epi8);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_max_epu8 (__mmask16 __M, __m128i __V)
+{
+  __V = _mm_maskz_mov_epi8 (__M, __V);
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP8 (avx512_max_epu8);
+}
+extern __inline signed char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_min_epi8 (__mmask16 __M, __m128i __V)
+{
+  __V = _mm_mask_mov_epi8 (_mm_avx512_set1_epi8 (127), __M, __V);
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP8 (avx512_min_epi8);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_reduce_min_epu8 (__mmask16 __M, __m128i __V)
+{
+  __V = _mm_mask_mov_epi8 (_mm_avx512_set1_epi8 (-1), __M, __V);
+  _MM_REDUCE_OPERATOR_MAX_MIN_EP8 (avx512_min_epu8);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_add_epi8 (__mmask32 __M, __m256i __W)
+{
+  __W = _mm256_maskz_mov_epi8 (__M, __W);
+  _MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI8 (+);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_mul_epi8 (__mmask32 __M, __m256i __W)
+{
+  __W = _mm256_mask_mov_epi8 (_mm256_avx512_set1_epi8 (1), __M, __W);
+  _MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI8 (*);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_and_epi8 (__mmask32 __M, __m256i __W)
+{
+  __W = _mm256_mask_mov_epi8 (_mm256_avx512_set1_epi8 (-1), __M, __W);
+  _MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI8 (&);
+}
+extern __inline char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_or_epi8 (__mmask32 __M, __m256i __W)
+{
+  __W = _mm256_maskz_mov_epi8 (__M, __W);
+  _MM256_AVX512_REDUCE_OPERATOR_BASIC_EPI8 (|);
+}
+extern __inline signed char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_max_epi8 (__mmask32 __M, __m256i __V)
+{
+  __V = _mm256_mask_mov_epi8 (_mm256_avx512_set1_epi8 (-127-1), __M, __V);
+  _MM256_AVX512_REDUCE_OPERATOR_MAX_MIN_EP8 (max_epi8);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_max_epu8 (__mmask32 __M, __m256i __V)
+{
+  __V = _mm256_maskz_mov_epi8 (__M, __V);
+  _MM256_AVX512_REDUCE_OPERATOR_MAX_MIN_EP8 (max_epu8);
+}
+extern __inline signed char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_min_epi8 (__mmask32 __M, __m256i __V)
+{
+  __V = _mm256_mask_mov_epi8 (_mm256_avx512_set1_epi8 (127), __M, __V);
+  _MM256_AVX512_REDUCE_OPERATOR_MAX_MIN_EP8 (min_epi8);
+}
+extern __inline unsigned char
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_reduce_min_epu8 (__mmask32 __M, __m256i __V)
+{
+  __V = _mm256_mask_mov_epi8 (_mm256_avx512_set1_epi8 (-1), __M, __V);
+  _MM256_AVX512_REDUCE_OPERATOR_MAX_MIN_EP8 (min_epu8);
+}
 #ifdef __DISABLE_AVX512VLBW__
 #undef __DISABLE_AVX512VLBW__
 #pragma GCC pop_options
diff --git a/third_party/intel/avx512vldqintrin.internal.h b/third_party/intel/avx512vldqintrin.internal.h
index a3e0ba447..7d9c282a2 100644
--- a/third_party/intel/avx512vldqintrin.internal.h
+++ b/third_party/intel/avx512vldqintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512VLDQINTRIN_H_INCLUDED
 #define _AVX512VLDQINTRIN_H_INCLUDED
-#if !defined(__AVX512VL__) || !defined(__AVX512DQ__)
+#if !defined(__AVX512VL__) || !defined(__AVX512DQ__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vl,avx512dq")
+#pragma GCC target("avx512vl,avx512dq,no-evex512")
 #define __DISABLE_AVX512VLDQ__
 #endif
 extern __inline __m256i
@@ -15,7 +15,7 @@ _mm256_cvttpd_epi64 (__m256d __A)
 {
   return (__m256i) __builtin_ia32_cvttpd2qq256_mask ((__v4df) __A,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) -1);
 }
 extern __inline __m256i
@@ -32,7 +32,7 @@ _mm256_maskz_cvttpd_epi64 (__mmask8 __U, __m256d __A)
 {
   return (__m256i) __builtin_ia32_cvttpd2qq256_mask ((__v4df) __A,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -41,7 +41,7 @@ _mm_cvttpd_epi64 (__m128d __A)
 {
   return (__m128i) __builtin_ia32_cvttpd2qq128_mask ((__v2df) __A,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -58,7 +58,7 @@ _mm_maskz_cvttpd_epi64 (__mmask8 __U, __m128d __A)
 {
   return (__m128i) __builtin_ia32_cvttpd2qq128_mask ((__v2df) __A,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -67,7 +67,7 @@ _mm256_cvttpd_epu64 (__m256d __A)
 {
   return (__m256i) __builtin_ia32_cvttpd2uqq256_mask ((__v4df) __A,
             (__v4di)
-            _mm256_setzero_si256 (),
+            _mm256_avx512_setzero_si256 (),
             (__mmask8) -1);
 }
 extern __inline __m256i
@@ -84,7 +84,7 @@ _mm256_maskz_cvttpd_epu64 (__mmask8 __U, __m256d __A)
 {
   return (__m256i) __builtin_ia32_cvttpd2uqq256_mask ((__v4df) __A,
             (__v4di)
-            _mm256_setzero_si256 (),
+            _mm256_avx512_setzero_si256 (),
             (__mmask8) __U);
 }
 extern __inline __m128i
@@ -93,7 +93,7 @@ _mm_cvttpd_epu64 (__m128d __A)
 {
   return (__m128i) __builtin_ia32_cvttpd2uqq128_mask ((__v2df) __A,
             (__v2di)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) -1);
 }
 extern __inline __m128i
@@ -110,7 +110,7 @@ _mm_maskz_cvttpd_epu64 (__mmask8 __U, __m128d __A)
 {
   return (__m128i) __builtin_ia32_cvttpd2uqq128_mask ((__v2df) __A,
             (__v2di)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) __U);
 }
 extern __inline __m256i
@@ -119,7 +119,7 @@ _mm256_cvtpd_epi64 (__m256d __A)
 {
   return (__m256i) __builtin_ia32_cvtpd2qq256_mask ((__v4df) __A,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) -1);
 }
 extern __inline __m256i
@@ -136,7 +136,7 @@ _mm256_maskz_cvtpd_epi64 (__mmask8 __U, __m256d __A)
 {
   return (__m256i) __builtin_ia32_cvtpd2qq256_mask ((__v4df) __A,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -145,7 +145,7 @@ _mm_cvtpd_epi64 (__m128d __A)
 {
   return (__m128i) __builtin_ia32_cvtpd2qq128_mask ((__v2df) __A,
           (__v2di)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) -1);
 }
 extern __inline __m128i
@@ -162,7 +162,7 @@ _mm_maskz_cvtpd_epi64 (__mmask8 __U, __m128d __A)
 {
   return (__m128i) __builtin_ia32_cvtpd2qq128_mask ((__v2df) __A,
           (__v2di)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -171,7 +171,7 @@ _mm256_cvtpd_epu64 (__m256d __A)
 {
   return (__m256i) __builtin_ia32_cvtpd2uqq256_mask ((__v4df) __A,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) -1);
 }
 extern __inline __m256i
@@ -188,7 +188,7 @@ _mm256_maskz_cvtpd_epu64 (__mmask8 __U, __m256d __A)
 {
   return (__m256i) __builtin_ia32_cvtpd2uqq256_mask ((__v4df) __A,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -197,7 +197,7 @@ _mm_cvtpd_epu64 (__m128d __A)
 {
   return (__m128i) __builtin_ia32_cvtpd2uqq128_mask ((__v2df) __A,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -214,7 +214,7 @@ _mm_maskz_cvtpd_epu64 (__mmask8 __U, __m128d __A)
 {
   return (__m128i) __builtin_ia32_cvtpd2uqq128_mask ((__v2df) __A,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -223,7 +223,7 @@ _mm256_cvttps_epi64 (__m128 __A)
 {
   return (__m256i) __builtin_ia32_cvttps2qq256_mask ((__v4sf) __A,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) -1);
 }
 extern __inline __m256i
@@ -240,7 +240,7 @@ _mm256_maskz_cvttps_epi64 (__mmask8 __U, __m128 __A)
 {
   return (__m256i) __builtin_ia32_cvttps2qq256_mask ((__v4sf) __A,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -249,7 +249,7 @@ _mm_cvttps_epi64 (__m128 __A)
 {
   return (__m128i) __builtin_ia32_cvttps2qq128_mask ((__v4sf) __A,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -266,7 +266,7 @@ _mm_maskz_cvttps_epi64 (__mmask8 __U, __m128 __A)
 {
   return (__m128i) __builtin_ia32_cvttps2qq128_mask ((__v4sf) __A,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -275,7 +275,7 @@ _mm256_cvttps_epu64 (__m128 __A)
 {
   return (__m256i) __builtin_ia32_cvttps2uqq256_mask ((__v4sf) __A,
             (__v4di)
-            _mm256_setzero_si256 (),
+            _mm256_avx512_setzero_si256 (),
             (__mmask8) -1);
 }
 extern __inline __m256i
@@ -292,7 +292,7 @@ _mm256_maskz_cvttps_epu64 (__mmask8 __U, __m128 __A)
 {
   return (__m256i) __builtin_ia32_cvttps2uqq256_mask ((__v4sf) __A,
             (__v4di)
-            _mm256_setzero_si256 (),
+            _mm256_avx512_setzero_si256 (),
             (__mmask8) __U);
 }
 extern __inline __m128i
@@ -301,7 +301,7 @@ _mm_cvttps_epu64 (__m128 __A)
 {
   return (__m128i) __builtin_ia32_cvttps2uqq128_mask ((__v4sf) __A,
             (__v2di)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) -1);
 }
 extern __inline __m128i
@@ -318,7 +318,7 @@ _mm_maskz_cvttps_epu64 (__mmask8 __U, __m128 __A)
 {
   return (__m128i) __builtin_ia32_cvttps2uqq128_mask ((__v4sf) __A,
             (__v2di)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) __U);
 }
 extern __inline __m256d
@@ -327,7 +327,7 @@ _mm256_broadcast_f64x2 (__m128d __A)
 {
   return (__m256d) __builtin_ia32_broadcastf64x2_256_mask ((__v2df)
           __A,
-                 (__v4df)_mm256_undefined_pd(),
+                 (__v4df)_mm256_avx512_undefined_pd(),
           (__mmask8) -1);
 }
 extern __inline __m256d
@@ -346,7 +346,7 @@ _mm256_maskz_broadcast_f64x2 (__mmask8 __M, __m128d __A)
   return (__m256d) __builtin_ia32_broadcastf64x2_256_mask ((__v2df)
           __A,
           (__v4df)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           __M);
 }
 extern __inline __m256i
@@ -355,7 +355,7 @@ _mm256_broadcast_i64x2 (__m128i __A)
 {
   return (__m256i) __builtin_ia32_broadcasti64x2_256_mask ((__v2di)
           __A,
-                 (__v4di)_mm256_undefined_si256(),
+                 (__v4di)_mm256_avx512_undefined_si256(),
           (__mmask8) -1);
 }
 extern __inline __m256i
@@ -374,7 +374,7 @@ _mm256_maskz_broadcast_i64x2 (__mmask8 __M, __m128i __A)
   return (__m256i) __builtin_ia32_broadcasti64x2_256_mask ((__v2di)
           __A,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m256
@@ -382,7 +382,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_broadcast_f32x2 (__m128 __A)
 {
   return (__m256) __builtin_ia32_broadcastf32x2_256_mask ((__v4sf) __A,
-                (__v8sf)_mm256_undefined_ps(),
+                (__v8sf)_mm256_avx512_undefined_ps(),
          (__mmask8) -1);
 }
 extern __inline __m256
@@ -399,7 +399,7 @@ _mm256_maskz_broadcast_f32x2 (__mmask8 __M, __m128 __A)
 {
   return (__m256) __builtin_ia32_broadcastf32x2_256_mask ((__v4sf) __A,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          __M);
 }
 extern __inline __m256i
@@ -408,7 +408,7 @@ _mm256_broadcast_i32x2 (__m128i __A)
 {
   return (__m256i) __builtin_ia32_broadcasti32x2_256_mask ((__v4si)
           __A,
-                (__v8si)_mm256_undefined_si256(),
+                (__v8si)_mm256_avx512_undefined_si256(),
           (__mmask8) -1);
 }
 extern __inline __m256i
@@ -427,7 +427,7 @@ _mm256_maskz_broadcast_i32x2 (__mmask8 __M, __m128i __A)
   return (__m256i) __builtin_ia32_broadcasti32x2_256_mask ((__v4si)
           __A,
           (__v8si)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m128i
@@ -436,7 +436,7 @@ _mm_broadcast_i32x2 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_broadcasti32x2_128_mask ((__v4si)
           __A,
-                (__v4si)_mm_undefined_si128(),
+                (__v4si)_mm_avx512_undefined_si128(),
           (__mmask8) -1);
 }
 extern __inline __m128i
@@ -455,7 +455,7 @@ _mm_maskz_broadcast_i32x2 (__mmask8 __M, __m128i __A)
   return (__m128i) __builtin_ia32_broadcasti32x2_128_mask ((__v4si)
           __A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m256i
@@ -481,7 +481,7 @@ _mm256_maskz_mullo_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmullq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -507,7 +507,7 @@ _mm_maskz_mullo_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmullq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256d
@@ -527,7 +527,7 @@ _mm256_maskz_andnot_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_andnpd256_mask ((__v4df) __A,
         (__v4df) __B,
         (__v4df)
-        _mm256_setzero_pd (),
+        _mm256_avx512_setzero_pd (),
         (__mmask8) __U);
 }
 extern __inline __m128d
@@ -547,7 +547,7 @@ _mm_maskz_andnot_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_andnpd128_mask ((__v2df) __A,
         (__v2df) __B,
         (__v2df)
-        _mm_setzero_pd (),
+        _mm_avx512_setzero_pd (),
         (__mmask8) __U);
 }
 extern __inline __m256
@@ -567,7 +567,7 @@ _mm256_maskz_andnot_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_andnps256_mask ((__v8sf) __A,
        (__v8sf) __B,
        (__v8sf)
-       _mm256_setzero_ps (),
+       _mm256_avx512_setzero_ps (),
        (__mmask8) __U);
 }
 extern __inline __m128
@@ -586,7 +586,7 @@ _mm_maskz_andnot_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_andnps128_mask ((__v4sf) __A,
        (__v4sf) __B,
        (__v4sf)
-       _mm_setzero_ps (),
+       _mm_avx512_setzero_ps (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -595,7 +595,7 @@ _mm256_cvtps_epi64 (__m128 __A)
 {
   return (__m256i) __builtin_ia32_cvtps2qq256_mask ((__v4sf) __A,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) -1);
 }
 extern __inline __m256i
@@ -612,7 +612,7 @@ _mm256_maskz_cvtps_epi64 (__mmask8 __U, __m128 __A)
 {
   return (__m256i) __builtin_ia32_cvtps2qq256_mask ((__v4sf) __A,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -621,7 +621,7 @@ _mm_cvtps_epi64 (__m128 __A)
 {
   return (__m128i) __builtin_ia32_cvtps2qq128_mask ((__v4sf) __A,
           (__v2di)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) -1);
 }
 extern __inline __m128i
@@ -638,7 +638,7 @@ _mm_maskz_cvtps_epi64 (__mmask8 __U, __m128 __A)
 {
   return (__m128i) __builtin_ia32_cvtps2qq128_mask ((__v4sf) __A,
           (__v2di)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -647,7 +647,7 @@ _mm256_cvtps_epu64 (__m128 __A)
 {
   return (__m256i) __builtin_ia32_cvtps2uqq256_mask ((__v4sf) __A,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) -1);
 }
 extern __inline __m256i
@@ -664,7 +664,7 @@ _mm256_maskz_cvtps_epu64 (__mmask8 __U, __m128 __A)
 {
   return (__m256i) __builtin_ia32_cvtps2uqq256_mask ((__v4sf) __A,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -673,7 +673,7 @@ _mm_cvtps_epu64 (__m128 __A)
 {
   return (__m128i) __builtin_ia32_cvtps2uqq128_mask ((__v4sf) __A,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -690,7 +690,7 @@ _mm_maskz_cvtps_epu64 (__mmask8 __U, __m128 __A)
 {
   return (__m128i) __builtin_ia32_cvtps2uqq128_mask ((__v4sf) __A,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m128
@@ -699,7 +699,7 @@ _mm256_cvtepi64_ps (__m256i __A)
 {
   return (__m128) __builtin_ia32_cvtqq2ps256_mask ((__v4di) __A,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) -1);
 }
 extern __inline __m128
@@ -716,7 +716,7 @@ _mm256_maskz_cvtepi64_ps (__mmask8 __U, __m256i __A)
 {
   return (__m128) __builtin_ia32_cvtqq2ps256_mask ((__v4di) __A,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128
@@ -725,7 +725,7 @@ _mm_cvtepi64_ps (__m128i __A)
 {
   return (__m128) __builtin_ia32_cvtqq2ps128_mask ((__v2di) __A,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) -1);
 }
 extern __inline __m128
@@ -742,7 +742,7 @@ _mm_maskz_cvtepi64_ps (__mmask8 __U, __m128i __A)
 {
   return (__m128) __builtin_ia32_cvtqq2ps128_mask ((__v2di) __A,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128
@@ -751,7 +751,7 @@ _mm256_cvtepu64_ps (__m256i __A)
 {
   return (__m128) __builtin_ia32_cvtuqq2ps256_mask ((__v4di) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) -1);
 }
 extern __inline __m128
@@ -768,7 +768,7 @@ _mm256_maskz_cvtepu64_ps (__mmask8 __U, __m256i __A)
 {
   return (__m128) __builtin_ia32_cvtuqq2ps256_mask ((__v4di) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -777,7 +777,7 @@ _mm_cvtepu64_ps (__m128i __A)
 {
   return (__m128) __builtin_ia32_cvtuqq2ps128_mask ((__v2di) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) -1);
 }
 extern __inline __m128
@@ -794,7 +794,7 @@ _mm_maskz_cvtepu64_ps (__mmask8 __U, __m128i __A)
 {
   return (__m128) __builtin_ia32_cvtuqq2ps128_mask ((__v2di) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m256d
@@ -803,7 +803,7 @@ _mm256_cvtepi64_pd (__m256i __A)
 {
   return (__m256d) __builtin_ia32_cvtqq2pd256_mask ((__v4di) __A,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) -1);
 }
 extern __inline __m256d
@@ -820,7 +820,7 @@ _mm256_maskz_cvtepi64_pd (__mmask8 __U, __m256i __A)
 {
   return (__m256d) __builtin_ia32_cvtqq2pd256_mask ((__v4di) __A,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m128d
@@ -829,7 +829,7 @@ _mm_cvtepi64_pd (__m128i __A)
 {
   return (__m128d) __builtin_ia32_cvtqq2pd128_mask ((__v2di) __A,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) -1);
 }
 extern __inline __m128d
@@ -846,7 +846,7 @@ _mm_maskz_cvtepi64_pd (__mmask8 __U, __m128i __A)
 {
   return (__m128d) __builtin_ia32_cvtqq2pd128_mask ((__v2di) __A,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m256d
@@ -855,7 +855,7 @@ _mm256_cvtepu64_pd (__m256i __A)
 {
   return (__m256d) __builtin_ia32_cvtuqq2pd256_mask ((__v4di) __A,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m256d
@@ -872,7 +872,7 @@ _mm256_maskz_cvtepu64_pd (__mmask8 __U, __m256i __A)
 {
   return (__m256d) __builtin_ia32_cvtuqq2pd256_mask ((__v4di) __A,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m256d
@@ -892,7 +892,7 @@ _mm256_maskz_and_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_andpd256_mask ((__v4df) __A,
        (__v4df) __B,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m128d
@@ -911,7 +911,7 @@ _mm_maskz_and_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_andpd128_mask ((__v2df) __A,
        (__v2df) __B,
        (__v2df)
-       _mm_setzero_pd (),
+       _mm_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m256
@@ -930,7 +930,7 @@ _mm256_maskz_and_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_andps256_mask ((__v8sf) __A,
       (__v8sf) __B,
       (__v8sf)
-      _mm256_setzero_ps (),
+      _mm256_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m128
@@ -949,7 +949,7 @@ _mm_maskz_and_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_andps128_mask ((__v4sf) __A,
       (__v4sf) __B,
       (__v4sf)
-      _mm_setzero_ps (),
+      _mm_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m128d
@@ -958,7 +958,7 @@ _mm_cvtepu64_pd (__m128i __A)
 {
   return (__m128d) __builtin_ia32_cvtuqq2pd128_mask ((__v2di) __A,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m128d
@@ -975,7 +975,7 @@ _mm_maskz_cvtepu64_pd (__mmask8 __U, __m128i __A)
 {
   return (__m128d) __builtin_ia32_cvtuqq2pd128_mask ((__v2di) __A,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m256d
@@ -995,7 +995,7 @@ _mm256_maskz_xor_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_xorpd256_mask ((__v4df) __A,
        (__v4df) __B,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m128d
@@ -1014,7 +1014,7 @@ _mm_maskz_xor_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_xorpd128_mask ((__v2df) __A,
        (__v2df) __B,
        (__v2df)
-       _mm_setzero_pd (),
+       _mm_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m256
@@ -1033,7 +1033,7 @@ _mm256_maskz_xor_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_xorps256_mask ((__v8sf) __A,
       (__v8sf) __B,
       (__v8sf)
-      _mm256_setzero_ps (),
+      _mm256_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m128
@@ -1052,7 +1052,7 @@ _mm_maskz_xor_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_xorps128_mask ((__v4sf) __A,
       (__v4sf) __B,
       (__v4sf)
-      _mm_setzero_ps (),
+      _mm_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m256d
@@ -1071,7 +1071,7 @@ _mm256_maskz_or_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_orpd256_mask ((__v4df) __A,
       (__v4df) __B,
       (__v4df)
-      _mm256_setzero_pd (),
+      _mm256_avx512_setzero_pd (),
       (__mmask8) __U);
 }
 extern __inline __m128d
@@ -1090,7 +1090,7 @@ _mm_maskz_or_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_orpd128_mask ((__v2df) __A,
       (__v2df) __B,
       (__v2df)
-      _mm_setzero_pd (),
+      _mm_avx512_setzero_pd (),
       (__mmask8) __U);
 }
 extern __inline __m256
@@ -1109,7 +1109,7 @@ _mm256_maskz_or_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_orps256_mask ((__v8sf) __A,
             (__v8sf) __B,
             (__v8sf)
-            _mm256_setzero_ps (),
+            _mm256_avx512_setzero_ps (),
             (__mmask8) __U);
 }
 extern __inline __m128
@@ -1128,7 +1128,7 @@ _mm_maskz_or_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_orps128_mask ((__v4sf) __A,
             (__v4sf) __B,
             (__v4sf)
-            _mm_setzero_ps (),
+            _mm_avx512_setzero_ps (),
             (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1187,7 +1187,7 @@ _mm256_extractf64x2_pd (__m256d __A, const int __imm)
   return (__m128d) __builtin_ia32_extractf64x2_256_mask ((__v4df) __A,
         __imm,
         (__v2df)
-        _mm_setzero_pd (),
+        _mm_avx512_setzero_pd (),
         (__mmask8) -1);
 }
 extern __inline __m128d
@@ -1209,7 +1209,7 @@ _mm256_maskz_extractf64x2_pd (__mmask8 __U, __m256d __A,
   return (__m128d) __builtin_ia32_extractf64x2_256_mask ((__v4df) __A,
         __imm,
         (__v2df)
-        _mm_setzero_pd (),
+        _mm_avx512_setzero_pd (),
         (__mmask8)
         __U);
 }
@@ -1220,7 +1220,7 @@ _mm256_extracti64x2_epi64 (__m256i __A, const int __imm)
   return (__m128i) __builtin_ia32_extracti64x2_256_mask ((__v4di) __A,
         __imm,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1242,7 +1242,7 @@ _mm256_maskz_extracti64x2_epi64 (__mmask8 __U, __m256i __A,
   return (__m128i) __builtin_ia32_extracti64x2_256_mask ((__v4di) __A,
         __imm,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8)
         __U);
 }
@@ -1252,7 +1252,7 @@ _mm256_reduce_pd (__m256d __A, int __B)
 {
   return (__m256d) __builtin_ia32_reducepd256_mask ((__v4df) __A, __B,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) -1);
 }
 extern __inline __m256d
@@ -1269,7 +1269,7 @@ _mm256_maskz_reduce_pd (__mmask8 __U, __m256d __A, int __B)
 {
   return (__m256d) __builtin_ia32_reducepd256_mask ((__v4df) __A, __B,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m128d
@@ -1278,7 +1278,7 @@ _mm_reduce_pd (__m128d __A, int __B)
 {
   return (__m128d) __builtin_ia32_reducepd128_mask ((__v2df) __A, __B,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) -1);
 }
 extern __inline __m128d
@@ -1295,7 +1295,7 @@ _mm_maskz_reduce_pd (__mmask8 __U, __m128d __A, int __B)
 {
   return (__m128d) __builtin_ia32_reducepd128_mask ((__v2df) __A, __B,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m256
@@ -1304,7 +1304,7 @@ _mm256_reduce_ps (__m256 __A, int __B)
 {
   return (__m256) __builtin_ia32_reduceps256_mask ((__v8sf) __A, __B,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) -1);
 }
 extern __inline __m256
@@ -1321,7 +1321,7 @@ _mm256_maskz_reduce_ps (__mmask8 __U, __m256 __A, int __B)
 {
   return (__m256) __builtin_ia32_reduceps256_mask ((__v8sf) __A, __B,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128
@@ -1330,7 +1330,7 @@ _mm_reduce_ps (__m128 __A, int __B)
 {
   return (__m128) __builtin_ia32_reduceps128_mask ((__v4sf) __A, __B,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) -1);
 }
 extern __inline __m128
@@ -1347,7 +1347,7 @@ _mm_maskz_reduce_ps (__mmask8 __U, __m128 __A, int __B)
 {
   return (__m128) __builtin_ia32_reduceps128_mask ((__v4sf) __A, __B,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m256d
@@ -1357,7 +1357,7 @@ _mm256_range_pd (__m256d __A, __m256d __B, int __C)
   return (__m256d) __builtin_ia32_rangepd256_mask ((__v4df) __A,
          (__v4df) __B, __C,
          (__v4df)
-         _mm256_setzero_pd (),
+         _mm256_avx512_setzero_pd (),
          (__mmask8) -1);
 }
 extern __inline __m256d
@@ -1377,7 +1377,7 @@ _mm256_maskz_range_pd (__mmask8 __U, __m256d __A, __m256d __B, int __C)
   return (__m256d) __builtin_ia32_rangepd256_mask ((__v4df) __A,
          (__v4df) __B, __C,
          (__v4df)
-         _mm256_setzero_pd (),
+         _mm256_avx512_setzero_pd (),
          (__mmask8) __U);
 }
 extern __inline __m128d
@@ -1387,7 +1387,7 @@ _mm_range_pd (__m128d __A, __m128d __B, int __C)
   return (__m128d) __builtin_ia32_rangepd128_mask ((__v2df) __A,
          (__v2df) __B, __C,
          (__v2df)
-         _mm_setzero_pd (),
+         _mm_avx512_setzero_pd (),
          (__mmask8) -1);
 }
 extern __inline __m128d
@@ -1407,7 +1407,7 @@ _mm_maskz_range_pd (__mmask8 __U, __m128d __A, __m128d __B, int __C)
   return (__m128d) __builtin_ia32_rangepd128_mask ((__v2df) __A,
          (__v2df) __B, __C,
          (__v2df)
-         _mm_setzero_pd (),
+         _mm_avx512_setzero_pd (),
          (__mmask8) __U);
 }
 extern __inline __m256
@@ -1417,7 +1417,7 @@ _mm256_range_ps (__m256 __A, __m256 __B, int __C)
   return (__m256) __builtin_ia32_rangeps256_mask ((__v8sf) __A,
         (__v8sf) __B, __C,
         (__v8sf)
-        _mm256_setzero_ps (),
+        _mm256_avx512_setzero_ps (),
         (__mmask8) -1);
 }
 extern __inline __m256
@@ -1437,7 +1437,7 @@ _mm256_maskz_range_ps (__mmask8 __U, __m256 __A, __m256 __B, int __C)
   return (__m256) __builtin_ia32_rangeps256_mask ((__v8sf) __A,
         (__v8sf) __B, __C,
         (__v8sf)
-        _mm256_setzero_ps (),
+        _mm256_avx512_setzero_ps (),
         (__mmask8) __U);
 }
 extern __inline __m128
@@ -1447,7 +1447,7 @@ _mm_range_ps (__m128 __A, __m128 __B, int __C)
   return (__m128) __builtin_ia32_rangeps128_mask ((__v4sf) __A,
         (__v4sf) __B, __C,
         (__v4sf)
-        _mm_setzero_ps (),
+        _mm_avx512_setzero_ps (),
         (__mmask8) -1);
 }
 extern __inline __m128
@@ -1467,7 +1467,7 @@ _mm_maskz_range_ps (__mmask8 __U, __m128 __A, __m128 __B, int __C)
   return (__m128) __builtin_ia32_rangeps128_mask ((__v4sf) __A,
         (__v4sf) __B, __C,
         (__v4sf)
-        _mm_setzero_ps (),
+        _mm_avx512_setzero_ps (),
         (__mmask8) __U);
 }
 extern __inline __mmask8
@@ -1539,7 +1539,7 @@ _mm256_inserti64x2 (__m256i __A, __m128i __B, const int __imm)
        (__v2di) __B,
        __imm,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) -1);
 }
 extern __inline __m256i
@@ -1563,7 +1563,7 @@ _mm256_maskz_inserti64x2 (__mmask8 __U, __m256i __A, __m128i __B,
        (__v2di) __B,
        __imm,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8)
        __U);
 }
@@ -1575,7 +1575,7 @@ _mm256_insertf64x2 (__m256d __A, __m128d __B, const int __imm)
        (__v2df) __B,
        __imm,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8) -1);
 }
 extern __inline __m256d
@@ -1599,47 +1599,47 @@ _mm256_maskz_insertf64x2 (__mmask8 __U, __m256d __A, __m128d __B,
        (__v2df) __B,
        __imm,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8)
        __U);
 }
 #else
-#define _mm256_insertf64x2(X, Y, C) ((__m256d) __builtin_ia32_insertf64x2_256_mask ((__v4df)(__m256d) (X), (__v2df)(__m128d) (Y), (int) (C), (__v4df)(__m256d)_mm256_setzero_pd(), (__mmask8)-1))
+#define _mm256_insertf64x2(X, Y, C) ((__m256d) __builtin_ia32_insertf64x2_256_mask ((__v4df)(__m256d) (X), (__v2df)(__m128d) (Y), (int) (C), (__v4df)(__m256d)_mm256_avx512_setzero_pd(), (__mmask8)-1))
 #define _mm256_mask_insertf64x2(W, U, X, Y, C) ((__m256d) __builtin_ia32_insertf64x2_256_mask ((__v4df)(__m256d) (X), (__v2df)(__m128d) (Y), (int) (C), (__v4df)(__m256d)(W), (__mmask8)(U)))
-#define _mm256_maskz_insertf64x2(U, X, Y, C) ((__m256d) __builtin_ia32_insertf64x2_256_mask ((__v4df)(__m256d) (X), (__v2df)(__m128d) (Y), (int) (C), (__v4df)(__m256d)_mm256_setzero_pd(), (__mmask8)(U)))
-#define _mm256_inserti64x2(X, Y, C) ((__m256i) __builtin_ia32_inserti64x2_256_mask ((__v4di)(__m256i) (X), (__v2di)(__m128i) (Y), (int) (C), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)-1))
+#define _mm256_maskz_insertf64x2(U, X, Y, C) ((__m256d) __builtin_ia32_insertf64x2_256_mask ((__v4df)(__m256d) (X), (__v2df)(__m128d) (Y), (int) (C), (__v4df)(__m256d)_mm256_avx512_setzero_pd(), (__mmask8)(U)))
+#define _mm256_inserti64x2(X, Y, C) ((__m256i) __builtin_ia32_inserti64x2_256_mask ((__v4di)(__m256i) (X), (__v2di)(__m128i) (Y), (int) (C), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)-1))
 #define _mm256_mask_inserti64x2(W, U, X, Y, C) ((__m256i) __builtin_ia32_inserti64x2_256_mask ((__v4di)(__m256i) (X), (__v2di)(__m128i) (Y), (int) (C), (__v4di)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_inserti64x2(U, X, Y, C) ((__m256i) __builtin_ia32_inserti64x2_256_mask ((__v4di)(__m256i) (X), (__v2di)(__m128i) (Y), (int) (C), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm256_extractf64x2_pd(X, C) ((__m128d) __builtin_ia32_extractf64x2_256_mask ((__v4df)(__m256d) (X), (int) (C), (__v2df)(__m128d) _mm_setzero_pd(), (__mmask8)-1))
+#define _mm256_maskz_inserti64x2(U, X, Y, C) ((__m256i) __builtin_ia32_inserti64x2_256_mask ((__v4di)(__m256i) (X), (__v2di)(__m128i) (Y), (int) (C), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm256_extractf64x2_pd(X, C) ((__m128d) __builtin_ia32_extractf64x2_256_mask ((__v4df)(__m256d) (X), (int) (C), (__v2df)(__m128d) _mm_avx512_setzero_pd(), (__mmask8)-1))
 #define _mm256_mask_extractf64x2_pd(W, U, X, C) ((__m128d) __builtin_ia32_extractf64x2_256_mask ((__v4df)(__m256d) (X), (int) (C), (__v2df)(__m128d) (W), (__mmask8) (U)))
-#define _mm256_maskz_extractf64x2_pd(U, X, C) ((__m128d) __builtin_ia32_extractf64x2_256_mask ((__v4df)(__m256d) (X), (int) (C), (__v2df)(__m128d) _mm_setzero_pd(), (__mmask8) (U)))
-#define _mm256_extracti64x2_epi64(X, C) ((__m128i) __builtin_ia32_extracti64x2_256_mask ((__v4di)(__m256i) (X), (int) (C), (__v2di)(__m128i) _mm_setzero_si128 (), (__mmask8)-1))
+#define _mm256_maskz_extractf64x2_pd(U, X, C) ((__m128d) __builtin_ia32_extractf64x2_256_mask ((__v4df)(__m256d) (X), (int) (C), (__v2df)(__m128d) _mm_avx512_setzero_pd(), (__mmask8) (U)))
+#define _mm256_extracti64x2_epi64(X, C) ((__m128i) __builtin_ia32_extracti64x2_256_mask ((__v4di)(__m256i) (X), (int) (C), (__v2di)(__m128i) _mm_avx512_setzero_si128 (), (__mmask8)-1))
 #define _mm256_mask_extracti64x2_epi64(W, U, X, C) ((__m128i) __builtin_ia32_extracti64x2_256_mask ((__v4di)(__m256i) (X), (int) (C), (__v2di)(__m128i) (W), (__mmask8) (U)))
-#define _mm256_maskz_extracti64x2_epi64(U, X, C) ((__m128i) __builtin_ia32_extracti64x2_256_mask ((__v4di)(__m256i) (X), (int) (C), (__v2di)(__m128i) _mm_setzero_si128 (), (__mmask8) (U)))
-#define _mm256_reduce_pd(A, B) ((__m256d) __builtin_ia32_reducepd256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)_mm256_setzero_pd(), (__mmask8)-1))
+#define _mm256_maskz_extracti64x2_epi64(U, X, C) ((__m128i) __builtin_ia32_extracti64x2_256_mask ((__v4di)(__m256i) (X), (int) (C), (__v2di)(__m128i) _mm_avx512_setzero_si128 (), (__mmask8) (U)))
+#define _mm256_reduce_pd(A, B) ((__m256d) __builtin_ia32_reducepd256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)_mm256_avx512_setzero_pd(), (__mmask8)-1))
 #define _mm256_mask_reduce_pd(W, U, A, B) ((__m256d) __builtin_ia32_reducepd256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)(__m256d)(W), (__mmask8)(U)))
-#define _mm256_maskz_reduce_pd(U, A, B) ((__m256d) __builtin_ia32_reducepd256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)_mm256_setzero_pd(), (__mmask8)(U)))
-#define _mm_reduce_pd(A, B) ((__m128d) __builtin_ia32_reducepd128_mask ((__v2df)(__m128d)(A), (int)(B), (__v2df)_mm_setzero_pd(), (__mmask8)-1))
+#define _mm256_maskz_reduce_pd(U, A, B) ((__m256d) __builtin_ia32_reducepd256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)_mm256_avx512_setzero_pd(), (__mmask8)(U)))
+#define _mm_reduce_pd(A, B) ((__m128d) __builtin_ia32_reducepd128_mask ((__v2df)(__m128d)(A), (int)(B), (__v2df)_mm_avx512_setzero_pd(), (__mmask8)-1))
 #define _mm_mask_reduce_pd(W, U, A, B) ((__m128d) __builtin_ia32_reducepd128_mask ((__v2df)(__m128d)(A), (int)(B), (__v2df)(__m128d)(W), (__mmask8)(U)))
-#define _mm_maskz_reduce_pd(U, A, B) ((__m128d) __builtin_ia32_reducepd128_mask ((__v2df)(__m128d)(A), (int)(B), (__v2df)_mm_setzero_pd(), (__mmask8)(U)))
-#define _mm256_reduce_ps(A, B) ((__m256) __builtin_ia32_reduceps256_mask ((__v8sf)(__m256)(A), (int)(B), (__v8sf)_mm256_setzero_ps(), (__mmask8)-1))
+#define _mm_maskz_reduce_pd(U, A, B) ((__m128d) __builtin_ia32_reducepd128_mask ((__v2df)(__m128d)(A), (int)(B), (__v2df)_mm_avx512_setzero_pd(), (__mmask8)(U)))
+#define _mm256_reduce_ps(A, B) ((__m256) __builtin_ia32_reduceps256_mask ((__v8sf)(__m256)(A), (int)(B), (__v8sf)_mm256_avx512_setzero_ps(), (__mmask8)-1))
 #define _mm256_mask_reduce_ps(W, U, A, B) ((__m256) __builtin_ia32_reduceps256_mask ((__v8sf)(__m256)(A), (int)(B), (__v8sf)(__m256)(W), (__mmask8)(U)))
-#define _mm256_maskz_reduce_ps(U, A, B) ((__m256) __builtin_ia32_reduceps256_mask ((__v8sf)(__m256)(A), (int)(B), (__v8sf)_mm256_setzero_ps(), (__mmask8)(U)))
-#define _mm_reduce_ps(A, B) ((__m128) __builtin_ia32_reduceps128_mask ((__v4sf)(__m128)(A), (int)(B), (__v4sf)_mm_setzero_ps(), (__mmask8)-1))
+#define _mm256_maskz_reduce_ps(U, A, B) ((__m256) __builtin_ia32_reduceps256_mask ((__v8sf)(__m256)(A), (int)(B), (__v8sf)_mm256_avx512_setzero_ps(), (__mmask8)(U)))
+#define _mm_reduce_ps(A, B) ((__m128) __builtin_ia32_reduceps128_mask ((__v4sf)(__m128)(A), (int)(B), (__v4sf)_mm_avx512_setzero_ps(), (__mmask8)-1))
 #define _mm_mask_reduce_ps(W, U, A, B) ((__m128) __builtin_ia32_reduceps128_mask ((__v4sf)(__m128)(A), (int)(B), (__v4sf)(__m128)(W), (__mmask8)(U)))
-#define _mm_maskz_reduce_ps(U, A, B) ((__m128) __builtin_ia32_reduceps128_mask ((__v4sf)(__m128)(A), (int)(B), (__v4sf)_mm_setzero_ps(), (__mmask8)(U)))
-#define _mm256_range_pd(A, B, C) ((__m256d) __builtin_ia32_rangepd256_mask ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(C), (__v4df)_mm256_setzero_pd(), (__mmask8)-1))
-#define _mm256_maskz_range_pd(U, A, B, C) ((__m256d) __builtin_ia32_rangepd256_mask ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(C), (__v4df)_mm256_setzero_pd(), (__mmask8)(U)))
-#define _mm_range_pd(A, B, C) ((__m128d) __builtin_ia32_rangepd128_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)_mm_setzero_pd(), (__mmask8)-1))
-#define _mm256_range_ps(A, B, C) ((__m256) __builtin_ia32_rangeps256_mask ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(C), (__v8sf)_mm256_setzero_ps(), (__mmask8)-1))
+#define _mm_maskz_reduce_ps(U, A, B) ((__m128) __builtin_ia32_reduceps128_mask ((__v4sf)(__m128)(A), (int)(B), (__v4sf)_mm_avx512_setzero_ps(), (__mmask8)(U)))
+#define _mm256_range_pd(A, B, C) ((__m256d) __builtin_ia32_rangepd256_mask ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(C), (__v4df)_mm256_avx512_setzero_pd(), (__mmask8)-1))
+#define _mm256_maskz_range_pd(U, A, B, C) ((__m256d) __builtin_ia32_rangepd256_mask ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(C), (__v4df)_mm256_avx512_setzero_pd(), (__mmask8)(U)))
+#define _mm_range_pd(A, B, C) ((__m128d) __builtin_ia32_rangepd128_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)_mm_avx512_setzero_pd(), (__mmask8)-1))
+#define _mm256_range_ps(A, B, C) ((__m256) __builtin_ia32_rangeps256_mask ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(C), (__v8sf)_mm256_avx512_setzero_ps(), (__mmask8)-1))
 #define _mm256_mask_range_ps(W, U, A, B, C) ((__m256) __builtin_ia32_rangeps256_mask ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(C), (__v8sf)(__m256)(W), (__mmask8)(U)))
-#define _mm256_maskz_range_ps(U, A, B, C) ((__m256) __builtin_ia32_rangeps256_mask ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(C), (__v8sf)_mm256_setzero_ps(), (__mmask8)(U)))
-#define _mm_range_ps(A, B, C) ((__m128) __builtin_ia32_rangeps128_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)_mm_setzero_ps(), (__mmask8)-1))
+#define _mm256_maskz_range_ps(U, A, B, C) ((__m256) __builtin_ia32_rangeps256_mask ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(C), (__v8sf)_mm256_avx512_setzero_ps(), (__mmask8)(U)))
+#define _mm_range_ps(A, B, C) ((__m128) __builtin_ia32_rangeps128_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)_mm_avx512_setzero_ps(), (__mmask8)-1))
 #define _mm_mask_range_ps(W, U, A, B, C) ((__m128) __builtin_ia32_rangeps128_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U)))
-#define _mm_maskz_range_ps(U, A, B, C) ((__m128) __builtin_ia32_rangeps128_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)_mm_setzero_ps(), (__mmask8)(U)))
+#define _mm_maskz_range_ps(U, A, B, C) ((__m128) __builtin_ia32_rangeps128_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)_mm_avx512_setzero_ps(), (__mmask8)(U)))
 #define _mm256_mask_range_pd(W, U, A, B, C) ((__m256d) __builtin_ia32_rangepd256_mask ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(C), (__v4df)(__m256d)(W), (__mmask8)(U)))
 #define _mm_mask_range_pd(W, U, A, B, C) ((__m128d) __builtin_ia32_rangepd128_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U)))
-#define _mm_maskz_range_pd(U, A, B, C) ((__m128d) __builtin_ia32_rangepd128_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)_mm_setzero_pd(), (__mmask8)(U)))
+#define _mm_maskz_range_pd(U, A, B, C) ((__m128d) __builtin_ia32_rangepd128_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)_mm_avx512_setzero_pd(), (__mmask8)(U)))
 #define _mm256_mask_fpclass_pd_mask(u, X, C) ((__mmask8) __builtin_ia32_fpclasspd256_mask ((__v4df) (__m256d) (X), (int) (C),(__mmask8)(u)))
 #define _mm256_mask_fpclass_ps_mask(u, X, C) ((__mmask8) __builtin_ia32_fpclassps256_mask ((__v8sf) (__m256) (X), (int) (C),(__mmask8)(u)))
 #define _mm_mask_fpclass_pd_mask(u, X, C) ((__mmask8) __builtin_ia32_fpclasspd128_mask ((__v2df) (__m128d) (X), (int) (C),(__mmask8)(u)))
diff --git a/third_party/intel/avx512vlintrin.internal.h b/third_party/intel/avx512vlintrin.internal.h
index 493f80abb..5610d7143 100644
--- a/third_party/intel/avx512vlintrin.internal.h
+++ b/third_party/intel/avx512vlintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512VLINTRIN_H_INCLUDED
 #define _AVX512VLINTRIN_H_INCLUDED
-#ifndef __AVX512VL__
+#if !defined (__AVX512VL__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vl")
+#pragma GCC target("avx512vl,no-evex512")
 #define __DISABLE_AVX512VL__
 #endif
 typedef unsigned int __mmask32;
@@ -14,6 +14,63 @@ typedef int __v4si_u __attribute__ ((__vector_size__ (16), __may_alias__, __alig
 typedef int __v8si_u __attribute__ ((__vector_size__ (32), __may_alias__, __aligned__ (1)));
 typedef long long __v2di_u __attribute__ ((__vector_size__ (16), __may_alias__, __aligned__ (1)));
 typedef long long __v4di_u __attribute__ ((__vector_size__ (32), __may_alias__, __aligned__ (1)));
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_undefined_si128 (void)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
+  __m128i __Y = __Y;
+#pragma GCC diagnostic pop
+  return __Y;
+}
+extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_undefined_ps (void)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
+  __m256 __Y = __Y;
+#pragma GCC diagnostic pop
+  return __Y;
+}
+extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_undefined_pd (void)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
+  __m256d __Y = __Y;
+#pragma GCC diagnostic pop
+  return __Y;
+}
+extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_undefined_si256 (void)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
+  __m256i __Y = __Y;
+#pragma GCC diagnostic pop
+  return __Y;
+}
+extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_avx512_setzero_si128 (void)
+{
+  return __extension__ (__m128i)(__v4si){ 0, 0, 0, 0 };
+}
+extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_setzero_ps (void)
+{
+  return __extension__ (__m256){ 0.0, 0.0, 0.0, 0.0,
+     0.0, 0.0, 0.0, 0.0 };
+}
+extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_setzero_pd (void)
+{
+  return __extension__ (__m256d){ 0.0, 0.0, 0.0, 0.0 };
+}
+extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_avx512_setzero_si256 (void)
+{
+  return __extension__ (__m256i)(__v4di){ 0, 0, 0, 0 };
+}
 extern __inline __m256d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_mov_pd (__m256d __W, __mmask8 __U, __m256d __A)
@@ -28,7 +85,7 @@ _mm256_maskz_mov_pd (__mmask8 __U, __m256d __A)
 {
   return (__m256d) __builtin_ia32_movapd256_mask ((__v4df) __A,
         (__v4df)
-        _mm256_setzero_pd (),
+        _mm256_avx512_setzero_pd (),
         (__mmask8) __U);
 }
 extern __inline __m128d
@@ -45,7 +102,7 @@ _mm_maskz_mov_pd (__mmask8 __U, __m128d __A)
 {
   return (__m128d) __builtin_ia32_movapd128_mask ((__v2df) __A,
         (__v2df)
-        _mm_setzero_pd (),
+        _mm_avx512_setzero_pd (),
         (__mmask8) __U);
 }
 extern __inline __m256d
@@ -62,7 +119,7 @@ _mm256_maskz_load_pd (__mmask8 __U, void const *__P)
 {
   return (__m256d) __builtin_ia32_loadapd256_mask ((__v4df *) __P,
          (__v4df)
-         _mm256_setzero_pd (),
+         _mm256_avx512_setzero_pd (),
          (__mmask8) __U);
 }
 extern __inline __m128d
@@ -79,7 +136,7 @@ _mm_maskz_load_pd (__mmask8 __U, void const *__P)
 {
   return (__m128d) __builtin_ia32_loadapd128_mask ((__v2df *) __P,
          (__v2df)
-         _mm_setzero_pd (),
+         _mm_avx512_setzero_pd (),
          (__mmask8) __U);
 }
 extern __inline void
@@ -112,7 +169,7 @@ _mm256_maskz_mov_ps (__mmask8 __U, __m256 __A)
 {
   return (__m256) __builtin_ia32_movaps256_mask ((__v8sf) __A,
        (__v8sf)
-       _mm256_setzero_ps (),
+       _mm256_avx512_setzero_ps (),
        (__mmask8) __U);
 }
 extern __inline __m128
@@ -129,7 +186,7 @@ _mm_maskz_mov_ps (__mmask8 __U, __m128 __A)
 {
   return (__m128) __builtin_ia32_movaps128_mask ((__v4sf) __A,
        (__v4sf)
-       _mm_setzero_ps (),
+       _mm_avx512_setzero_ps (),
        (__mmask8) __U);
 }
 extern __inline __m256
@@ -146,7 +203,7 @@ _mm256_maskz_load_ps (__mmask8 __U, void const *__P)
 {
   return (__m256) __builtin_ia32_loadaps256_mask ((__v8sf *) __P,
         (__v8sf)
-        _mm256_setzero_ps (),
+        _mm256_avx512_setzero_ps (),
         (__mmask8) __U);
 }
 extern __inline __m128
@@ -163,7 +220,7 @@ _mm_maskz_load_ps (__mmask8 __U, void const *__P)
 {
   return (__m128) __builtin_ia32_loadaps128_mask ((__v4sf *) __P,
         (__v4sf)
-        _mm_setzero_ps (),
+        _mm_avx512_setzero_ps (),
         (__mmask8) __U);
 }
 extern __inline void
@@ -196,7 +253,7 @@ _mm256_maskz_mov_epi64 (__mmask8 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_movdqa64_256_mask ((__v4di) __A,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -213,7 +270,7 @@ _mm_maskz_mov_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_movdqa64_128_mask ((__v2di) __A,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -237,7 +294,7 @@ _mm256_maskz_load_epi64 (__mmask8 __U, void const *__P)
 {
   return (__m256i) __builtin_ia32_movdqa64load256_mask ((__v4di *) __P,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8)
        __U);
 }
@@ -262,7 +319,7 @@ _mm_maskz_load_epi64 (__mmask8 __U, void const *__P)
 {
   return (__m128i) __builtin_ia32_movdqa64load128_mask ((__v2di *) __P,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8)
        __U);
 }
@@ -296,7 +353,7 @@ _mm256_maskz_mov_epi32 (__mmask8 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_movdqa32_256_mask ((__v8si) __A,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -313,7 +370,7 @@ _mm_maskz_mov_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_movdqa32_128_mask ((__v4si) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -337,7 +394,7 @@ _mm256_maskz_load_epi32 (__mmask8 __U, void const *__P)
 {
   return (__m256i) __builtin_ia32_movdqa32load256_mask ((__v8si *) __P,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8)
        __U);
 }
@@ -362,7 +419,7 @@ _mm_maskz_load_epi32 (__mmask8 __U, void const *__P)
 {
   return (__m128i) __builtin_ia32_movdqa32load128_mask ((__v4si *) __P,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8)
        __U);
 }
@@ -410,7 +467,7 @@ _mm_maskz_add_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_addpd128_mask ((__v2df) __A,
        (__v2df) __B,
        (__v2df)
-       _mm_setzero_pd (),
+       _mm_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m256d
@@ -430,7 +487,7 @@ _mm256_maskz_add_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_addpd256_mask ((__v4df) __A,
        (__v4df) __B,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m128
@@ -449,7 +506,7 @@ _mm_maskz_add_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_addps128_mask ((__v4sf) __A,
       (__v4sf) __B,
       (__v4sf)
-      _mm_setzero_ps (),
+      _mm_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m256
@@ -468,7 +525,7 @@ _mm256_maskz_add_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_addps256_mask ((__v8sf) __A,
       (__v8sf) __B,
       (__v8sf)
-      _mm256_setzero_ps (),
+      _mm256_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m128d
@@ -487,7 +544,7 @@ _mm_maskz_sub_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_subpd128_mask ((__v2df) __A,
        (__v2df) __B,
        (__v2df)
-       _mm_setzero_pd (),
+       _mm_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m256d
@@ -507,7 +564,7 @@ _mm256_maskz_sub_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_subpd256_mask ((__v4df) __A,
        (__v4df) __B,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m128
@@ -526,7 +583,7 @@ _mm_maskz_sub_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_subps128_mask ((__v4sf) __A,
       (__v4sf) __B,
       (__v4sf)
-      _mm_setzero_ps (),
+      _mm_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m256
@@ -545,7 +602,7 @@ _mm256_maskz_sub_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_subps256_mask ((__v8sf) __A,
       (__v8sf) __B,
       (__v8sf)
-      _mm256_setzero_ps (),
+      _mm256_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline void
@@ -574,7 +631,7 @@ _mm256_maskz_loadu_pd (__mmask8 __U, void const *__P)
 {
   return (__m256d) __builtin_ia32_loadupd256_mask ((const double *) __P,
          (__v4df)
-         _mm256_setzero_pd (),
+         _mm256_avx512_setzero_pd (),
          (__mmask8) __U);
 }
 extern __inline __m128d
@@ -591,7 +648,7 @@ _mm_maskz_loadu_pd (__mmask8 __U, void const *__P)
 {
   return (__m128d) __builtin_ia32_loadupd128_mask ((const double *) __P,
          (__v2df)
-         _mm_setzero_pd (),
+         _mm_avx512_setzero_pd (),
          (__mmask8) __U);
 }
 extern __inline void
@@ -624,7 +681,7 @@ _mm256_maskz_loadu_ps (__mmask8 __U, void const *__P)
 {
   return (__m256) __builtin_ia32_loadups256_mask ((const float *) __P,
         (__v8sf)
-        _mm256_setzero_ps (),
+        _mm256_avx512_setzero_ps (),
         (__mmask8) __U);
 }
 extern __inline __m128
@@ -641,7 +698,7 @@ _mm_maskz_loadu_ps (__mmask8 __U, void const *__P)
 {
   return (__m128) __builtin_ia32_loadups128_mask ((const float *) __P,
         (__v4sf)
-        _mm_setzero_ps (),
+        _mm_avx512_setzero_ps (),
         (__mmask8) __U);
 }
 extern __inline void
@@ -680,7 +737,7 @@ _mm256_maskz_loadu_epi64 (__mmask8 __U, void const *__P)
 {
   return (__m256i) __builtin_ia32_loaddqudi256_mask ((const long long *) __P,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -703,7 +760,7 @@ _mm_maskz_loadu_epi64 (__mmask8 __U, void const *__P)
 {
   return (__m128i) __builtin_ia32_loaddqudi128_mask ((const long long *) __P,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline void
@@ -754,7 +811,7 @@ _mm256_maskz_loadu_epi32 (__mmask8 __U, void const *__P)
 {
   return (__m256i) __builtin_ia32_loaddqusi256_mask ((const int *) __P,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -777,7 +834,7 @@ _mm_maskz_loadu_epi32 (__mmask8 __U, void const *__P)
 {
   return (__m128i) __builtin_ia32_loaddqusi128_mask ((const int *) __P,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline void
@@ -808,6 +865,70 @@ _mm_mask_storeu_epi32 (void *__P, __mmask8 __U, __m128i __A)
          (__v4si) __A,
          (__mmask8) __U);
 }
+extern __inline __m256d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_blend_pd (__mmask8 __U, __m256d __A, __m256d __W)
+{
+  return (__m256d) __builtin_ia32_blendmpd_256_mask ((__v4df) __A,
+           (__v4df) __W,
+           (__mmask8) __U);
+}
+extern __inline __m256
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_blend_ps (__mmask8 __U, __m256 __A, __m256 __W)
+{
+  return (__m256) __builtin_ia32_blendmps_256_mask ((__v8sf) __A,
+          (__v8sf) __W,
+          (__mmask8) __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_blend_epi64 (__mmask8 __U, __m256i __A, __m256i __W)
+{
+  return (__m256i) __builtin_ia32_blendmq_256_mask ((__v4di) __A,
+          (__v4di) __W,
+          (__mmask8) __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_blend_epi32 (__mmask8 __U, __m256i __A, __m256i __W)
+{
+  return (__m256i) __builtin_ia32_blendmd_256_mask ((__v8si) __A,
+          (__v8si) __W,
+          (__mmask8) __U);
+}
+extern __inline __m128d
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_blend_pd (__mmask8 __U, __m128d __A, __m128d __W)
+{
+  return (__m128d) __builtin_ia32_blendmpd_128_mask ((__v2df) __A,
+           (__v2df) __W,
+           (__mmask8) __U);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_blend_ps (__mmask8 __U, __m128 __A, __m128 __W)
+{
+  return (__m128) __builtin_ia32_blendmps_128_mask ((__v4sf) __A,
+          (__v4sf) __W,
+          (__mmask8) __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_blend_epi64 (__mmask8 __U, __m128i __A, __m128i __W)
+{
+  return (__m128i) __builtin_ia32_blendmq_128_mask ((__v2di) __A,
+          (__v2di) __W,
+          (__mmask8) __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_blend_epi32 (__mmask8 __U, __m128i __A, __m128i __W)
+{
+  return (__m128i) __builtin_ia32_blendmd_128_mask ((__v4si) __A,
+          (__v4si) __W,
+          (__mmask8) __U);
+}
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_abs_epi32 (__m256i __W, __mmask8 __U, __m256i __A)
@@ -822,7 +943,7 @@ _mm256_maskz_abs_epi32 (__mmask8 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_pabsd256_mask ((__v8si) __A,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -839,7 +960,7 @@ _mm_maskz_abs_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pabsd128_mask ((__v4si) __A,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -848,7 +969,7 @@ _mm256_abs_epi64 (__m256i __A)
 {
   return (__m256i) __builtin_ia32_pabsq256_mask ((__v4di) __A,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) -1);
 }
 extern __inline __m256i
@@ -865,7 +986,7 @@ _mm256_maskz_abs_epi64 (__mmask8 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_pabsq256_mask ((__v4di) __A,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -874,7 +995,7 @@ _mm_abs_epi64 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pabsq128_mask ((__v2di) __A,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) -1);
 }
 extern __inline __m128i
@@ -891,7 +1012,7 @@ _mm_maskz_abs_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pabsq128_mask ((__v2di) __A,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -900,7 +1021,7 @@ _mm256_cvtpd_epu32 (__m256d __A)
 {
   return (__m128i) __builtin_ia32_cvtpd2udq256_mask ((__v4df) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -917,7 +1038,7 @@ _mm256_maskz_cvtpd_epu32 (__mmask8 __U, __m256d __A)
 {
   return (__m128i) __builtin_ia32_cvtpd2udq256_mask ((__v4df) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -926,7 +1047,7 @@ _mm_cvtpd_epu32 (__m128d __A)
 {
   return (__m128i) __builtin_ia32_cvtpd2udq128_mask ((__v2df) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -943,7 +1064,7 @@ _mm_maskz_cvtpd_epu32 (__mmask8 __U, __m128d __A)
 {
   return (__m128i) __builtin_ia32_cvtpd2udq128_mask ((__v2df) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -960,7 +1081,7 @@ _mm256_maskz_cvttps_epi32 (__mmask8 __U, __m256 __A)
 {
   return (__m256i) __builtin_ia32_cvttps2dq256_mask ((__v8sf) __A,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -977,7 +1098,7 @@ _mm_maskz_cvttps_epi32 (__mmask8 __U, __m128 __A)
 {
   return (__m128i) __builtin_ia32_cvttps2dq128_mask ((__v4sf) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -986,7 +1107,7 @@ _mm256_cvttps_epu32 (__m256 __A)
 {
   return (__m256i) __builtin_ia32_cvttps2udq256_mask ((__v8sf) __A,
             (__v8si)
-            _mm256_setzero_si256 (),
+            _mm256_avx512_setzero_si256 (),
             (__mmask8) -1);
 }
 extern __inline __m256i
@@ -1003,7 +1124,7 @@ _mm256_maskz_cvttps_epu32 (__mmask8 __U, __m256 __A)
 {
   return (__m256i) __builtin_ia32_cvttps2udq256_mask ((__v8sf) __A,
             (__v8si)
-            _mm256_setzero_si256 (),
+            _mm256_avx512_setzero_si256 (),
             (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1012,7 +1133,7 @@ _mm_cvttps_epu32 (__m128 __A)
 {
   return (__m128i) __builtin_ia32_cvttps2udq128_mask ((__v4sf) __A,
             (__v4si)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1029,7 +1150,7 @@ _mm_maskz_cvttps_epu32 (__mmask8 __U, __m128 __A)
 {
   return (__m128i) __builtin_ia32_cvttps2udq128_mask ((__v4sf) __A,
             (__v4si)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1046,7 +1167,7 @@ _mm256_maskz_cvttpd_epi32 (__mmask8 __U, __m256d __A)
 {
   return (__m128i) __builtin_ia32_cvttpd2dq256_mask ((__v4df) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1063,7 +1184,7 @@ _mm_maskz_cvttpd_epi32 (__mmask8 __U, __m128d __A)
 {
   return (__m128i) __builtin_ia32_cvttpd2dq128_mask ((__v2df) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1072,7 +1193,7 @@ _mm256_cvttpd_epu32 (__m256d __A)
 {
   return (__m128i) __builtin_ia32_cvttpd2udq256_mask ((__v4df) __A,
             (__v4si)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1089,7 +1210,7 @@ _mm256_maskz_cvttpd_epu32 (__mmask8 __U, __m256d __A)
 {
   return (__m128i) __builtin_ia32_cvttpd2udq256_mask ((__v4df) __A,
             (__v4si)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1098,7 +1219,7 @@ _mm_cvttpd_epu32 (__m128d __A)
 {
   return (__m128i) __builtin_ia32_cvttpd2udq128_mask ((__v2df) __A,
             (__v4si)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1115,7 +1236,7 @@ _mm_maskz_cvttpd_epu32 (__mmask8 __U, __m128d __A)
 {
   return (__m128i) __builtin_ia32_cvttpd2udq128_mask ((__v2df) __A,
             (__v4si)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1132,7 +1253,7 @@ _mm256_maskz_cvtpd_epi32 (__mmask8 __U, __m256d __A)
 {
   return (__m128i) __builtin_ia32_cvtpd2dq256_mask ((__v4df) __A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1149,7 +1270,7 @@ _mm_maskz_cvtpd_epi32 (__mmask8 __U, __m128d __A)
 {
   return (__m128i) __builtin_ia32_cvtpd2dq128_mask ((__v2df) __A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256d
@@ -1166,7 +1287,7 @@ _mm256_maskz_cvtepi32_pd (__mmask8 __U, __m128i __A)
 {
   return (__m256d) __builtin_ia32_cvtdq2pd256_mask ((__v4si) __A,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m128d
@@ -1183,7 +1304,7 @@ _mm_maskz_cvtepi32_pd (__mmask8 __U, __m128i __A)
 {
   return (__m128d) __builtin_ia32_cvtdq2pd128_mask ((__v4si) __A,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m256d
@@ -1192,7 +1313,7 @@ _mm256_cvtepu32_pd (__m128i __A)
 {
   return (__m256d) __builtin_ia32_cvtudq2pd256_mask ((__v4si) __A,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m256d
@@ -1209,7 +1330,7 @@ _mm256_maskz_cvtepu32_pd (__mmask8 __U, __m128i __A)
 {
   return (__m256d) __builtin_ia32_cvtudq2pd256_mask ((__v4si) __A,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m128d
@@ -1218,7 +1339,7 @@ _mm_cvtepu32_pd (__m128i __A)
 {
   return (__m128d) __builtin_ia32_cvtudq2pd128_mask ((__v4si) __A,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m128d
@@ -1235,7 +1356,7 @@ _mm_maskz_cvtepu32_pd (__mmask8 __U, __m128i __A)
 {
   return (__m128d) __builtin_ia32_cvtudq2pd128_mask ((__v4si) __A,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m256
@@ -1252,7 +1373,7 @@ _mm256_maskz_cvtepi32_ps (__mmask8 __U, __m256i __A)
 {
   return (__m256) __builtin_ia32_cvtdq2ps256_mask ((__v8si) __A,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128
@@ -1269,7 +1390,7 @@ _mm_maskz_cvtepi32_ps (__mmask8 __U, __m128i __A)
 {
   return (__m128) __builtin_ia32_cvtdq2ps128_mask ((__v4si) __A,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m256
@@ -1278,7 +1399,7 @@ _mm256_cvtepu32_ps (__m256i __A)
 {
   return (__m256) __builtin_ia32_cvtudq2ps256_mask ((__v8si) __A,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) -1);
 }
 extern __inline __m256
@@ -1295,7 +1416,7 @@ _mm256_maskz_cvtepu32_ps (__mmask8 __U, __m256i __A)
 {
   return (__m256) __builtin_ia32_cvtudq2ps256_mask ((__v8si) __A,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -1304,7 +1425,7 @@ _mm_cvtepu32_ps (__m128i __A)
 {
   return (__m128) __builtin_ia32_cvtudq2ps128_mask ((__v4si) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) -1);
 }
 extern __inline __m128
@@ -1321,7 +1442,7 @@ _mm_maskz_cvtepu32_ps (__mmask8 __U, __m128i __A)
 {
   return (__m128) __builtin_ia32_cvtudq2ps128_mask ((__v4si) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m256d
@@ -1338,7 +1459,7 @@ _mm256_maskz_cvtps_pd (__mmask8 __U, __m128 __A)
 {
   return (__m256d) __builtin_ia32_cvtps2pd256_mask ((__v4sf) __A,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m128d
@@ -1355,7 +1476,7 @@ _mm_maskz_cvtps_pd (__mmask8 __U, __m128 __A)
 {
   return (__m128d) __builtin_ia32_cvtps2pd128_mask ((__v4sf) __A,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -1364,7 +1485,7 @@ _mm_cvtepi32_epi8 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovdb128_mask ((__v4si) __A,
         (__v16qi)
-        _mm_undefined_si128 (),
+        _mm_avx512_undefined_si128 (),
         (__mmask8) -1);
 }
 extern __inline void
@@ -1386,7 +1507,7 @@ _mm_maskz_cvtepi32_epi8 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovdb128_mask ((__v4si) __A,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -1395,7 +1516,7 @@ _mm256_cvtepi32_epi8 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovdb256_mask ((__v8si) __A,
         (__v16qi)
-        _mm_undefined_si128 (),
+        _mm_avx512_undefined_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -1417,7 +1538,7 @@ _mm256_maskz_cvtepi32_epi8 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovdb256_mask ((__v8si) __A,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -1426,7 +1547,7 @@ _mm_cvtsepi32_epi8 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsdb128_mask ((__v4si) __A,
          (__v16qi)
-         _mm_undefined_si128 (),
+         _mm_avx512_undefined_si128 (),
          (__mmask8) -1);
 }
 extern __inline void
@@ -1448,7 +1569,7 @@ _mm_maskz_cvtsepi32_epi8 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsdb128_mask ((__v4si) __A,
          (__v16qi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -1457,7 +1578,7 @@ _mm256_cvtsepi32_epi8 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovsdb256_mask ((__v8si) __A,
          (__v16qi)
-         _mm_undefined_si128 (),
+         _mm_avx512_undefined_si128 (),
          (__mmask8) -1);
 }
 extern __inline void
@@ -1479,7 +1600,7 @@ _mm256_maskz_cvtsepi32_epi8 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovsdb256_mask ((__v8si) __A,
          (__v16qi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -1488,7 +1609,7 @@ _mm_cvtusepi32_epi8 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovusdb128_mask ((__v4si) __A,
           (__v16qi)
-          _mm_undefined_si128 (),
+          _mm_avx512_undefined_si128 (),
           (__mmask8) -1);
 }
 extern __inline void
@@ -1511,7 +1632,7 @@ _mm_maskz_cvtusepi32_epi8 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovusdb128_mask ((__v4si) __A,
           (__v16qi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -1520,7 +1641,7 @@ _mm256_cvtusepi32_epi8 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovusdb256_mask ((__v8si) __A,
           (__v16qi)
-          _mm_undefined_si128 (),
+          _mm_avx512_undefined_si128 (),
           (__mmask8) -1);
 }
 extern __inline void
@@ -1543,7 +1664,7 @@ _mm256_maskz_cvtusepi32_epi8 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovusdb256_mask ((__v8si) __A,
           (__v16qi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -1552,7 +1673,7 @@ _mm_cvtepi32_epi16 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovdw128_mask ((__v4si) __A,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline void
@@ -1574,7 +1695,7 @@ _mm_maskz_cvtepi32_epi16 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovdw128_mask ((__v4si) __A,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -1583,7 +1704,7 @@ _mm256_cvtepi32_epi16 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovdw256_mask ((__v8si) __A,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline void
@@ -1605,7 +1726,7 @@ _mm256_maskz_cvtepi32_epi16 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovdw256_mask ((__v8si) __A,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -1614,7 +1735,7 @@ _mm_cvtsepi32_epi16 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsdw128_mask ((__v4si) __A,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          (__mmask8) -1);
 }
 extern __inline void
@@ -1637,7 +1758,7 @@ _mm_maskz_cvtsepi32_epi16 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsdw128_mask ((__v4si) __A,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -1646,7 +1767,7 @@ _mm256_cvtsepi32_epi16 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovsdw256_mask ((__v8si) __A,
          (__v8hi)
-         _mm_undefined_si128 (),
+         _mm_avx512_undefined_si128 (),
          (__mmask8) -1);
 }
 extern __inline void
@@ -1668,7 +1789,7 @@ _mm256_maskz_cvtsepi32_epi16 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovsdw256_mask ((__v8si) __A,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -1677,7 +1798,7 @@ _mm_cvtusepi32_epi16 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovusdw128_mask ((__v4si) __A,
           (__v8hi)
-          _mm_undefined_si128 (),
+          _mm_avx512_undefined_si128 (),
           (__mmask8) -1);
 }
 extern __inline void
@@ -1699,7 +1820,7 @@ _mm_maskz_cvtusepi32_epi16 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovusdw128_mask ((__v4si) __A,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -1708,7 +1829,7 @@ _mm256_cvtusepi32_epi16 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovusdw256_mask ((__v8si) __A,
           (__v8hi)
-          _mm_undefined_si128 (),
+          _mm_avx512_undefined_si128 (),
           (__mmask8) -1);
 }
 extern __inline void
@@ -1730,7 +1851,7 @@ _mm256_maskz_cvtusepi32_epi16 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovusdw256_mask ((__v8si) __A,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -1739,7 +1860,7 @@ _mm_cvtepi64_epi8 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovqb128_mask ((__v2di) __A,
         (__v16qi)
-        _mm_undefined_si128 (),
+        _mm_avx512_undefined_si128 (),
         (__mmask8) -1);
 }
 extern __inline void
@@ -1761,7 +1882,7 @@ _mm_maskz_cvtepi64_epi8 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovqb128_mask ((__v2di) __A,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -1770,7 +1891,7 @@ _mm256_cvtepi64_epi8 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovqb256_mask ((__v4di) __A,
         (__v16qi)
-        _mm_undefined_si128 (),
+        _mm_avx512_undefined_si128 (),
         (__mmask8) -1);
 }
 extern __inline void
@@ -1792,7 +1913,7 @@ _mm256_maskz_cvtepi64_epi8 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovqb256_mask ((__v4di) __A,
         (__v16qi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -1801,7 +1922,7 @@ _mm_cvtsepi64_epi8 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqb128_mask ((__v2di) __A,
          (__v16qi)
-         _mm_undefined_si128 (),
+         _mm_avx512_undefined_si128 (),
          (__mmask8) -1);
 }
 extern __inline void
@@ -1823,7 +1944,7 @@ _mm_maskz_cvtsepi64_epi8 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqb128_mask ((__v2di) __A,
          (__v16qi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -1832,7 +1953,7 @@ _mm256_cvtsepi64_epi8 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqb256_mask ((__v4di) __A,
          (__v16qi)
-         _mm_undefined_si128 (),
+         _mm_avx512_undefined_si128 (),
          (__mmask8) -1);
 }
 extern __inline void
@@ -1854,7 +1975,7 @@ _mm256_maskz_cvtsepi64_epi8 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqb256_mask ((__v4di) __A,
          (__v16qi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -1863,7 +1984,7 @@ _mm_cvtusepi64_epi8 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqb128_mask ((__v2di) __A,
           (__v16qi)
-          _mm_undefined_si128 (),
+          _mm_avx512_undefined_si128 (),
           (__mmask8) -1);
 }
 extern __inline void
@@ -1886,7 +2007,7 @@ _mm_maskz_cvtusepi64_epi8 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqb128_mask ((__v2di) __A,
           (__v16qi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -1895,7 +2016,7 @@ _mm256_cvtusepi64_epi8 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqb256_mask ((__v4di) __A,
           (__v16qi)
-          _mm_undefined_si128 (),
+          _mm_avx512_undefined_si128 (),
           (__mmask8) -1);
 }
 extern __inline void
@@ -1918,7 +2039,7 @@ _mm256_maskz_cvtusepi64_epi8 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqb256_mask ((__v4di) __A,
           (__v16qi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -1927,7 +2048,7 @@ _mm_cvtepi64_epi16 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovqw128_mask ((__v2di) __A,
         (__v8hi)
-        _mm_undefined_si128 (),
+        _mm_avx512_undefined_si128 (),
         (__mmask8) -1);
 }
 extern __inline void
@@ -1950,7 +2071,7 @@ _mm_maskz_cvtepi64_epi16 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovqw128_mask ((__v2di) __A,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -1959,7 +2080,7 @@ _mm256_cvtepi64_epi16 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovqw256_mask ((__v4di) __A,
         (__v8hi)
-        _mm_undefined_si128 (),
+        _mm_avx512_undefined_si128 (),
         (__mmask8) -1);
 }
 extern __inline void
@@ -1981,7 +2102,7 @@ _mm256_maskz_cvtepi64_epi16 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovqw256_mask ((__v4di) __A,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -1990,7 +2111,7 @@ _mm_cvtsepi64_epi16 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqw128_mask ((__v2di) __A,
          (__v8hi)
-         _mm_undefined_si128 (),
+         _mm_avx512_undefined_si128 (),
          (__mmask8) -1);
 }
 extern __inline void
@@ -2012,7 +2133,7 @@ _mm_maskz_cvtsepi64_epi16 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqw128_mask ((__v2di) __A,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -2021,7 +2142,7 @@ _mm256_cvtsepi64_epi16 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqw256_mask ((__v4di) __A,
          (__v8hi)
-         _mm_undefined_si128 (),
+         _mm_avx512_undefined_si128 (),
          (__mmask8) -1);
 }
 extern __inline void
@@ -2043,7 +2164,7 @@ _mm256_maskz_cvtsepi64_epi16 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqw256_mask ((__v4di) __A,
          (__v8hi)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -2052,7 +2173,7 @@ _mm_cvtusepi64_epi16 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqw128_mask ((__v2di) __A,
           (__v8hi)
-          _mm_undefined_si128 (),
+          _mm_avx512_undefined_si128 (),
           (__mmask8) -1);
 }
 extern __inline void
@@ -2074,7 +2195,7 @@ _mm_maskz_cvtusepi64_epi16 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqw128_mask ((__v2di) __A,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -2083,7 +2204,7 @@ _mm256_cvtusepi64_epi16 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqw256_mask ((__v4di) __A,
           (__v8hi)
-          _mm_undefined_si128 (),
+          _mm_avx512_undefined_si128 (),
           (__mmask8) -1);
 }
 extern __inline void
@@ -2105,7 +2226,7 @@ _mm256_maskz_cvtusepi64_epi16 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqw256_mask ((__v4di) __A,
           (__v8hi)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -2114,7 +2235,7 @@ _mm_cvtepi64_epi32 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovqd128_mask ((__v2di) __A,
         (__v4si)
-        _mm_undefined_si128 (),
+        _mm_avx512_undefined_si128 (),
         (__mmask8) -1);
 }
 extern __inline void
@@ -2137,7 +2258,7 @@ _mm_maskz_cvtepi64_epi32 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovqd128_mask ((__v2di) __A,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -2146,7 +2267,7 @@ _mm256_cvtepi64_epi32 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovqd256_mask ((__v4di) __A,
         (__v4si)
-        _mm_undefined_si128 (),
+        _mm_avx512_undefined_si128 (),
         (__mmask8) -1);
 }
 extern __inline void
@@ -2168,7 +2289,7 @@ _mm256_maskz_cvtepi64_epi32 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovqd256_mask ((__v4di) __A,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -2177,7 +2298,7 @@ _mm_cvtsepi64_epi32 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqd128_mask ((__v2di) __A,
          (__v4si)
-         _mm_undefined_si128 (),
+         _mm_avx512_undefined_si128 (),
          (__mmask8) -1);
 }
 extern __inline void
@@ -2199,7 +2320,7 @@ _mm_maskz_cvtsepi64_epi32 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqd128_mask ((__v2di) __A,
          (__v4si)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -2208,7 +2329,7 @@ _mm256_cvtsepi64_epi32 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqd256_mask ((__v4di) __A,
          (__v4si)
-         _mm_undefined_si128 (),
+         _mm_avx512_undefined_si128 (),
          (__mmask8) -1);
 }
 extern __inline void
@@ -2231,7 +2352,7 @@ _mm256_maskz_cvtsepi64_epi32 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovsqd256_mask ((__v4di) __A,
          (__v4si)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m128i
@@ -2240,7 +2361,7 @@ _mm_cvtusepi64_epi32 (__m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqd128_mask ((__v2di) __A,
           (__v4si)
-          _mm_undefined_si128 (),
+          _mm_avx512_undefined_si128 (),
           (__mmask8) -1);
 }
 extern __inline void
@@ -2262,7 +2383,7 @@ _mm_maskz_cvtusepi64_epi32 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqd128_mask ((__v2di) __A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m128i
@@ -2271,7 +2392,7 @@ _mm256_cvtusepi64_epi32 (__m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqd256_mask ((__v4di) __A,
           (__v4si)
-          _mm_undefined_si128 (),
+          _mm_avx512_undefined_si128 (),
           (__mmask8) -1);
 }
 extern __inline void
@@ -2293,7 +2414,7 @@ _mm256_maskz_cvtusepi64_epi32 (__mmask8 __M, __m256i __A)
 {
   return (__m128i) __builtin_ia32_pmovusqd256_mask ((__v4di) __A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           __M);
 }
 extern __inline __m256
@@ -2310,7 +2431,7 @@ _mm256_maskz_broadcastss_ps (__mmask8 __M, __m128 __A)
 {
   return (__m256) __builtin_ia32_broadcastss256_mask ((__v4sf) __A,
             (__v8sf)
-            _mm256_setzero_ps (),
+            _mm256_avx512_setzero_ps (),
             __M);
 }
 extern __inline __m128
@@ -2327,7 +2448,7 @@ _mm_maskz_broadcastss_ps (__mmask8 __M, __m128 __A)
 {
   return (__m128) __builtin_ia32_broadcastss128_mask ((__v4sf) __A,
             (__v4sf)
-            _mm_setzero_ps (),
+            _mm_avx512_setzero_ps (),
             __M);
 }
 extern __inline __m256d
@@ -2344,7 +2465,7 @@ _mm256_maskz_broadcastsd_pd (__mmask8 __M, __m128d __A)
 {
   return (__m256d) __builtin_ia32_broadcastsd256_mask ((__v2df) __A,
              (__v4df)
-             _mm256_setzero_pd (),
+             _mm256_avx512_setzero_pd (),
              __M);
 }
 extern __inline __m256i
@@ -2361,7 +2482,7 @@ _mm256_maskz_broadcastd_epi32 (__mmask8 __M, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pbroadcastd256_mask ((__v4si) __A,
              (__v8si)
-             _mm256_setzero_si256 (),
+             _mm256_avx512_setzero_si256 (),
              __M);
 }
 extern __inline __m256i
@@ -2377,7 +2498,7 @@ _mm256_maskz_set1_epi32 (__mmask8 __M, int __A)
 {
   return (__m256i) __builtin_ia32_pbroadcastd256_gpr_mask (__A,
           (__v8si)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m128i
@@ -2394,7 +2515,7 @@ _mm_maskz_broadcastd_epi32 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pbroadcastd128_mask ((__v4si) __A,
              (__v4si)
-             _mm_setzero_si128 (),
+             _mm_avx512_setzero_si128 (),
              __M);
 }
 extern __inline __m128i
@@ -2410,7 +2531,7 @@ _mm_maskz_set1_epi32 (__mmask8 __M, int __A)
 {
   return (__m128i)
   __builtin_ia32_pbroadcastd128_gpr_mask (__A,
-       (__v4si) _mm_setzero_si128 (),
+       (__v4si) _mm_avx512_setzero_si128 (),
        __M);
 }
 extern __inline __m256i
@@ -2427,7 +2548,7 @@ _mm256_maskz_broadcastq_epi64 (__mmask8 __M, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pbroadcastq256_mask ((__v2di) __A,
              (__v4di)
-             _mm256_setzero_si256 (),
+             _mm256_avx512_setzero_si256 (),
              __M);
 }
 extern __inline __m256i
@@ -2443,7 +2564,7 @@ _mm256_maskz_set1_epi64 (__mmask8 __M, long long __A)
 {
   return (__m256i) __builtin_ia32_pbroadcastq256_gpr_mask (__A,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m128i
@@ -2460,7 +2581,7 @@ _mm_maskz_broadcastq_epi64 (__mmask8 __M, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pbroadcastq128_mask ((__v2di) __A,
              (__v2di)
-             _mm_setzero_si128 (),
+             _mm_avx512_setzero_si128 (),
              __M);
 }
 extern __inline __m128i
@@ -2476,7 +2597,7 @@ _mm_maskz_set1_epi64 (__mmask8 __M, long long __A)
 {
   return (__m128i)
   __builtin_ia32_pbroadcastq128_gpr_mask (__A,
-       (__v2di) _mm_setzero_si128 (),
+       (__v2di) _mm_avx512_setzero_si128 (),
        __M);
 }
 extern __inline __m256
@@ -2484,7 +2605,7 @@ __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_broadcast_f32x4 (__m128 __A)
 {
   return (__m256) __builtin_ia32_broadcastf32x4_256_mask ((__v4sf) __A,
-                (__v8sf)_mm256_undefined_pd (),
+                (__v8sf)_mm256_avx512_undefined_pd (),
          (__mmask8) -1);
 }
 extern __inline __m256
@@ -2501,7 +2622,7 @@ _mm256_maskz_broadcast_f32x4 (__mmask8 __M, __m128 __A)
 {
   return (__m256) __builtin_ia32_broadcastf32x4_256_mask ((__v4sf) __A,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          __M);
 }
 extern __inline __m256i
@@ -2510,7 +2631,7 @@ _mm256_broadcast_i32x4 (__m128i __A)
 {
   return (__m256i) __builtin_ia32_broadcasti32x4_256_mask ((__v4si)
           __A,
-                 (__v8si)_mm256_undefined_si256 (),
+                 (__v8si)_mm256_avx512_undefined_si256 (),
           (__mmask8) -1);
 }
 extern __inline __m256i
@@ -2529,7 +2650,7 @@ _mm256_maskz_broadcast_i32x4 (__mmask8 __M, __m128i __A)
   return (__m256i) __builtin_ia32_broadcasti32x4_256_mask ((__v4si)
           __A,
           (__v8si)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           __M);
 }
 extern __inline __m256i
@@ -2546,7 +2667,7 @@ _mm256_maskz_cvtepi8_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pmovsxbd256_mask ((__v16qi) __A,
           (__v8si)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -2563,7 +2684,7 @@ _mm_maskz_cvtepi8_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsxbd128_mask ((__v16qi) __A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2580,7 +2701,7 @@ _mm256_maskz_cvtepi8_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pmovsxbq256_mask ((__v16qi) __A,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -2597,7 +2718,7 @@ _mm_maskz_cvtepi8_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsxbq128_mask ((__v16qi) __A,
           (__v2di)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2614,7 +2735,7 @@ _mm256_maskz_cvtepi16_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pmovsxwd256_mask ((__v8hi) __A,
           (__v8si)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -2631,7 +2752,7 @@ _mm_maskz_cvtepi16_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsxwd128_mask ((__v8hi) __A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2648,7 +2769,7 @@ _mm256_maskz_cvtepi16_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pmovsxwq256_mask ((__v8hi) __A,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -2665,7 +2786,7 @@ _mm_maskz_cvtepi16_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovsxwq128_mask ((__v8hi) __A,
           (__v2di)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2682,7 +2803,7 @@ _mm256_maskz_cvtepi32_epi64 (__mmask8 __U, __m128i __X)
 {
   return (__m256i) __builtin_ia32_pmovsxdq256_mask ((__v4si) __X,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -2699,7 +2820,7 @@ _mm_maskz_cvtepi32_epi64 (__mmask8 __U, __m128i __X)
 {
   return (__m128i) __builtin_ia32_pmovsxdq128_mask ((__v4si) __X,
           (__v2di)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2716,7 +2837,7 @@ _mm256_maskz_cvtepu8_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pmovzxbd256_mask ((__v16qi) __A,
           (__v8si)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -2733,7 +2854,7 @@ _mm_maskz_cvtepu8_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovzxbd128_mask ((__v16qi) __A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2750,7 +2871,7 @@ _mm256_maskz_cvtepu8_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pmovzxbq256_mask ((__v16qi) __A,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -2767,7 +2888,7 @@ _mm_maskz_cvtepu8_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovzxbq128_mask ((__v16qi) __A,
           (__v2di)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2784,7 +2905,7 @@ _mm256_maskz_cvtepu16_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pmovzxwd256_mask ((__v8hi) __A,
           (__v8si)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -2801,7 +2922,7 @@ _mm_maskz_cvtepu16_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovzxwd128_mask ((__v8hi) __A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2818,7 +2939,7 @@ _mm256_maskz_cvtepu16_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m256i) __builtin_ia32_pmovzxwq256_mask ((__v8hi) __A,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -2835,7 +2956,7 @@ _mm_maskz_cvtepu16_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_pmovzxwq128_mask ((__v8hi) __A,
           (__v2di)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -2852,7 +2973,7 @@ _mm256_maskz_cvtepu32_epi64 (__mmask8 __U, __m128i __X)
 {
   return (__m256i) __builtin_ia32_pmovzxdq256_mask ((__v4si) __X,
           (__v4di)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -2869,7 +2990,7 @@ _mm_maskz_cvtepu32_epi64 (__mmask8 __U, __m128i __X)
 {
   return (__m128i) __builtin_ia32_pmovzxdq128_mask ((__v4si) __X,
           (__v2di)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256d
@@ -2878,7 +2999,7 @@ _mm256_rcp14_pd (__m256d __A)
 {
   return (__m256d) __builtin_ia32_rcp14pd256_mask ((__v4df) __A,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m256d
@@ -2895,7 +3016,7 @@ _mm256_maskz_rcp14_pd (__mmask8 __U, __m256d __A)
 {
   return (__m256d) __builtin_ia32_rcp14pd256_mask ((__v4df) __A,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m128d
@@ -2904,7 +3025,7 @@ _mm_rcp14_pd (__m128d __A)
 {
   return (__m128d) __builtin_ia32_rcp14pd128_mask ((__v2df) __A,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m128d
@@ -2921,7 +3042,7 @@ _mm_maskz_rcp14_pd (__mmask8 __U, __m128d __A)
 {
   return (__m128d) __builtin_ia32_rcp14pd128_mask ((__v2df) __A,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m256
@@ -2930,7 +3051,7 @@ _mm256_rcp14_ps (__m256 __A)
 {
   return (__m256) __builtin_ia32_rcp14ps256_mask ((__v8sf) __A,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) -1);
 }
 extern __inline __m256
@@ -2947,7 +3068,7 @@ _mm256_maskz_rcp14_ps (__mmask8 __U, __m256 __A)
 {
   return (__m256) __builtin_ia32_rcp14ps256_mask ((__v8sf) __A,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -2956,7 +3077,7 @@ _mm_rcp14_ps (__m128 __A)
 {
   return (__m128) __builtin_ia32_rcp14ps128_mask ((__v4sf) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) -1);
 }
 extern __inline __m128
@@ -2973,7 +3094,7 @@ _mm_maskz_rcp14_ps (__mmask8 __U, __m128 __A)
 {
   return (__m128) __builtin_ia32_rcp14ps128_mask ((__v4sf) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m256d
@@ -2982,7 +3103,7 @@ _mm256_rsqrt14_pd (__m256d __A)
 {
   return (__m256d) __builtin_ia32_rsqrt14pd256_mask ((__v4df) __A,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m256d
@@ -2999,7 +3120,7 @@ _mm256_maskz_rsqrt14_pd (__mmask8 __U, __m256d __A)
 {
   return (__m256d) __builtin_ia32_rsqrt14pd256_mask ((__v4df) __A,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m128d
@@ -3008,7 +3129,7 @@ _mm_rsqrt14_pd (__m128d __A)
 {
   return (__m128d) __builtin_ia32_rsqrt14pd128_mask ((__v2df) __A,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m128d
@@ -3025,7 +3146,7 @@ _mm_maskz_rsqrt14_pd (__mmask8 __U, __m128d __A)
 {
   return (__m128d) __builtin_ia32_rsqrt14pd128_mask ((__v2df) __A,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m256
@@ -3034,7 +3155,7 @@ _mm256_rsqrt14_ps (__m256 __A)
 {
   return (__m256) __builtin_ia32_rsqrt14ps256_mask ((__v8sf) __A,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) -1);
 }
 extern __inline __m256
@@ -3051,7 +3172,7 @@ _mm256_maskz_rsqrt14_ps (__mmask8 __U, __m256 __A)
 {
   return (__m256) __builtin_ia32_rsqrt14ps256_mask ((__v8sf) __A,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -3060,7 +3181,7 @@ _mm_rsqrt14_ps (__m128 __A)
 {
   return (__m128) __builtin_ia32_rsqrt14ps128_mask ((__v4sf) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) -1);
 }
 extern __inline __m128
@@ -3077,7 +3198,7 @@ _mm_maskz_rsqrt14_ps (__mmask8 __U, __m128 __A)
 {
   return (__m128) __builtin_ia32_rsqrt14ps128_mask ((__v4sf) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m256d
@@ -3094,7 +3215,7 @@ _mm256_maskz_sqrt_pd (__mmask8 __U, __m256d __A)
 {
   return (__m256d) __builtin_ia32_sqrtpd256_mask ((__v4df) __A,
         (__v4df)
-        _mm256_setzero_pd (),
+        _mm256_avx512_setzero_pd (),
         (__mmask8) __U);
 }
 extern __inline __m128d
@@ -3111,7 +3232,7 @@ _mm_maskz_sqrt_pd (__mmask8 __U, __m128d __A)
 {
   return (__m128d) __builtin_ia32_sqrtpd128_mask ((__v2df) __A,
         (__v2df)
-        _mm_setzero_pd (),
+        _mm_avx512_setzero_pd (),
         (__mmask8) __U);
 }
 extern __inline __m256
@@ -3128,7 +3249,7 @@ _mm256_maskz_sqrt_ps (__mmask8 __U, __m256 __A)
 {
   return (__m256) __builtin_ia32_sqrtps256_mask ((__v8sf) __A,
        (__v8sf)
-       _mm256_setzero_ps (),
+       _mm256_avx512_setzero_ps (),
        (__mmask8) __U);
 }
 extern __inline __m128
@@ -3145,7 +3266,7 @@ _mm_maskz_sqrt_ps (__mmask8 __U, __m128 __A)
 {
   return (__m128) __builtin_ia32_sqrtps128_mask ((__v4sf) __A,
        (__v4sf)
-       _mm_setzero_ps (),
+       _mm_avx512_setzero_ps (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3165,7 +3286,7 @@ _mm256_maskz_add_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_paddd256_mask ((__v8si) __A,
        (__v8si) __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3185,7 +3306,7 @@ _mm256_maskz_add_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_paddq256_mask ((__v4di) __A,
        (__v4di) __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3205,7 +3326,7 @@ _mm256_maskz_sub_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psubd256_mask ((__v8si) __A,
        (__v8si) __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3225,7 +3346,7 @@ _mm256_maskz_sub_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_psubq256_mask ((__v4di) __A,
        (__v4di) __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3245,7 +3366,7 @@ _mm_maskz_add_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_paddd128_mask ((__v4si) __A,
        (__v4si) __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3265,7 +3386,7 @@ _mm_maskz_add_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_paddq128_mask ((__v2di) __A,
        (__v2di) __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3285,7 +3406,7 @@ _mm_maskz_sub_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psubd128_mask ((__v4si) __A,
        (__v4si) __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3305,7 +3426,7 @@ _mm_maskz_sub_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psubq128_mask ((__v2di) __A,
        (__v2di) __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256
@@ -3314,7 +3435,7 @@ _mm256_getexp_ps (__m256 __A)
 {
   return (__m256) __builtin_ia32_getexpps256_mask ((__v8sf) __A,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) -1);
 }
 extern __inline __m256
@@ -3331,7 +3452,7 @@ _mm256_maskz_getexp_ps (__mmask8 __U, __m256 __A)
 {
   return (__m256) __builtin_ia32_getexpps256_mask ((__v8sf) __A,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m256d
@@ -3340,7 +3461,7 @@ _mm256_getexp_pd (__m256d __A)
 {
   return (__m256d) __builtin_ia32_getexppd256_mask ((__v4df) __A,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) -1);
 }
 extern __inline __m256d
@@ -3357,7 +3478,7 @@ _mm256_maskz_getexp_pd (__mmask8 __U, __m256d __A)
 {
   return (__m256d) __builtin_ia32_getexppd256_mask ((__v4df) __A,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -3366,7 +3487,7 @@ _mm_getexp_ps (__m128 __A)
 {
   return (__m128) __builtin_ia32_getexpps128_mask ((__v4sf) __A,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) -1);
 }
 extern __inline __m128
@@ -3383,7 +3504,7 @@ _mm_maskz_getexp_ps (__mmask8 __U, __m128 __A)
 {
   return (__m128) __builtin_ia32_getexpps128_mask ((__v4sf) __A,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128d
@@ -3392,7 +3513,7 @@ _mm_getexp_pd (__m128d __A)
 {
   return (__m128d) __builtin_ia32_getexppd128_mask ((__v2df) __A,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) -1);
 }
 extern __inline __m128d
@@ -3409,7 +3530,7 @@ _mm_maskz_getexp_pd (__mmask8 __U, __m128d __A)
 {
   return (__m128d) __builtin_ia32_getexppd128_mask ((__v2df) __A,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3429,7 +3550,7 @@ _mm256_maskz_srl_epi32 (__mmask8 __U, __m256i __A, __m128i __B)
   return (__m256i) __builtin_ia32_psrld256_mask ((__v8si) __A,
        (__v4si) __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3449,7 +3570,7 @@ _mm_maskz_srl_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psrld128_mask ((__v4si) __A,
        (__v4si) __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3469,7 +3590,7 @@ _mm256_maskz_srl_epi64 (__mmask8 __U, __m256i __A, __m128i __B)
   return (__m256i) __builtin_ia32_psrlq256_mask ((__v4di) __A,
        (__v2di) __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -3489,7 +3610,7 @@ _mm_maskz_srl_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psrlq128_mask ((__v2di) __A,
        (__v2di) __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -3509,7 +3630,7 @@ _mm256_maskz_and_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pandd256_mask ((__v8si) __A,
        (__v8si) __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m256d
@@ -3519,7 +3640,7 @@ _mm256_scalef_pd (__m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_scalefpd256_mask ((__v4df) __A,
           (__v4df) __B,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) -1);
 }
 extern __inline __m256d
@@ -3539,7 +3660,7 @@ _mm256_maskz_scalef_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_scalefpd256_mask ((__v4df) __A,
           (__v4df) __B,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m256
@@ -3549,7 +3670,7 @@ _mm256_scalef_ps (__m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_scalefps256_mask ((__v8sf) __A,
          (__v8sf) __B,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) -1);
 }
 extern __inline __m256
@@ -3569,7 +3690,7 @@ _mm256_maskz_scalef_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_scalefps256_mask ((__v8sf) __A,
          (__v8sf) __B,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128d
@@ -3579,7 +3700,7 @@ _mm_scalef_pd (__m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_scalefpd128_mask ((__v2df) __A,
           (__v2df) __B,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) -1);
 }
 extern __inline __m128d
@@ -3599,7 +3720,7 @@ _mm_maskz_scalef_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_scalefpd128_mask ((__v2df) __A,
           (__v2df) __B,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -3609,7 +3730,7 @@ _mm_scalef_ps (__m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_scalefps128_mask ((__v4sf) __A,
          (__v4sf) __B,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) -1);
 }
 extern __inline __m128
@@ -3628,7 +3749,7 @@ _mm_maskz_scalef_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_scalefps128_mask ((__v4sf) __A,
          (__v4sf) __B,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m256d
@@ -4358,7 +4479,7 @@ _mm_maskz_and_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pandd128_mask ((__v4si) __A,
        (__v4si) __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -4378,7 +4499,7 @@ _mm256_maskz_andnot_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pandnd256_mask ((__v8si) __A,
         (__v8si) __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -4398,7 +4519,7 @@ _mm_maskz_andnot_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pandnd128_mask ((__v4si) __A,
         (__v4si) __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -4418,7 +4539,7 @@ _mm256_maskz_or_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pord256_mask ((__v8si) __A,
       (__v8si) __B,
       (__v8si)
-      _mm256_setzero_si256 (),
+      _mm256_avx512_setzero_si256 (),
       (__mmask8) __U);
 }
 extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -4442,7 +4563,7 @@ _mm_maskz_or_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pord128_mask ((__v4si) __A,
       (__v4si) __B,
       (__v4si)
-      _mm_setzero_si128 (),
+      _mm_avx512_setzero_si128 (),
       (__mmask8) __U);
 }
 extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -4467,7 +4588,7 @@ _mm256_maskz_xor_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pxord256_mask ((__v8si) __A,
        (__v8si) __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -4492,7 +4613,7 @@ _mm_maskz_xor_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pxord128_mask ((__v4si) __A,
        (__v4si) __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -4514,7 +4635,7 @@ _mm_maskz_cvtpd_ps (__mmask8 __U, __m128d __A)
 {
   return (__m128) __builtin_ia32_cvtpd2ps_mask ((__v2df) __A,
       (__v4sf)
-      _mm_setzero_ps (),
+      _mm_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m128
@@ -4531,7 +4652,7 @@ _mm256_maskz_cvtpd_ps (__mmask8 __U, __m256d __A)
 {
   return (__m128) __builtin_ia32_cvtpd2ps256_mask ((__v4df) __A,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m256i
@@ -4548,7 +4669,7 @@ _mm256_maskz_cvtps_epi32 (__mmask8 __U, __m256 __A)
 {
   return (__m256i) __builtin_ia32_cvtps2dq256_mask ((__v8sf) __A,
           (__v8si)
-          _mm256_setzero_si256 (),
+          _mm256_avx512_setzero_si256 (),
           (__mmask8) __U);
 }
 extern __inline __m128i
@@ -4565,7 +4686,7 @@ _mm_maskz_cvtps_epi32 (__mmask8 __U, __m128 __A)
 {
   return (__m128i) __builtin_ia32_cvtps2dq128_mask ((__v4sf) __A,
           (__v4si)
-          _mm_setzero_si128 (),
+          _mm_avx512_setzero_si128 (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -4574,7 +4695,7 @@ _mm256_cvtps_epu32 (__m256 __A)
 {
   return (__m256i) __builtin_ia32_cvtps2udq256_mask ((__v8sf) __A,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) -1);
 }
 extern __inline __m256i
@@ -4591,7 +4712,7 @@ _mm256_maskz_cvtps_epu32 (__mmask8 __U, __m256 __A)
 {
   return (__m256i) __builtin_ia32_cvtps2udq256_mask ((__v8sf) __A,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -4600,7 +4721,7 @@ _mm_cvtps_epu32 (__m128 __A)
 {
   return (__m128i) __builtin_ia32_cvtps2udq128_mask ((__v4sf) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) -1);
 }
 extern __inline __m128i
@@ -4617,7 +4738,7 @@ _mm_maskz_cvtps_epu32 (__mmask8 __U, __m128 __A)
 {
   return (__m128i) __builtin_ia32_cvtps2udq128_mask ((__v4sf) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256d
@@ -4634,7 +4755,7 @@ _mm256_maskz_movedup_pd (__mmask8 __U, __m256d __A)
 {
   return (__m256d) __builtin_ia32_movddup256_mask ((__v4df) __A,
          (__v4df)
-         _mm256_setzero_pd (),
+         _mm256_avx512_setzero_pd (),
          (__mmask8) __U);
 }
 extern __inline __m128d
@@ -4651,7 +4772,7 @@ _mm_maskz_movedup_pd (__mmask8 __U, __m128d __A)
 {
   return (__m128d) __builtin_ia32_movddup128_mask ((__v2df) __A,
          (__v2df)
-         _mm_setzero_pd (),
+         _mm_avx512_setzero_pd (),
          (__mmask8) __U);
 }
 extern __inline __m256
@@ -4668,7 +4789,7 @@ _mm256_maskz_movehdup_ps (__mmask8 __U, __m256 __A)
 {
   return (__m256) __builtin_ia32_movshdup256_mask ((__v8sf) __A,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128
@@ -4685,7 +4806,7 @@ _mm_maskz_movehdup_ps (__mmask8 __U, __m128 __A)
 {
   return (__m128) __builtin_ia32_movshdup128_mask ((__v4sf) __A,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m256
@@ -4702,7 +4823,7 @@ _mm256_maskz_moveldup_ps (__mmask8 __U, __m256 __A)
 {
   return (__m256) __builtin_ia32_movsldup256_mask ((__v8sf) __A,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128
@@ -4719,7 +4840,7 @@ _mm_maskz_moveldup_ps (__mmask8 __U, __m128 __A)
 {
   return (__m128) __builtin_ia32_movsldup128_mask ((__v4sf) __A,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128i
@@ -4739,7 +4860,7 @@ _mm_maskz_unpackhi_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_punpckhdq128_mask ((__v4si) __A,
            (__v4si) __B,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -4759,7 +4880,7 @@ _mm256_maskz_unpackhi_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_punpckhdq256_mask ((__v8si) __A,
            (__v8si) __B,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -4779,7 +4900,7 @@ _mm_maskz_unpackhi_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_punpckhqdq128_mask ((__v2di) __A,
             (__v2di) __B,
             (__v2di)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) __U);
 }
 extern __inline __m256i
@@ -4799,7 +4920,7 @@ _mm256_maskz_unpackhi_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_punpckhqdq256_mask ((__v4di) __A,
             (__v4di) __B,
             (__v4di)
-            _mm256_setzero_si256 (),
+            _mm256_avx512_setzero_si256 (),
             (__mmask8) __U);
 }
 extern __inline __m128i
@@ -4819,7 +4940,7 @@ _mm_maskz_unpacklo_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_punpckldq128_mask ((__v4si) __A,
            (__v4si) __B,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -4839,7 +4960,7 @@ _mm256_maskz_unpacklo_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_punpckldq256_mask ((__v8si) __A,
            (__v8si) __B,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -4859,7 +4980,7 @@ _mm_maskz_unpacklo_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_punpcklqdq128_mask ((__v2di) __A,
             (__v2di) __B,
             (__v2di)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) __U);
 }
 extern __inline __m256i
@@ -4879,7 +5000,7 @@ _mm256_maskz_unpacklo_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_punpcklqdq256_mask ((__v4di) __A,
             (__v4di) __B,
             (__v4di)
-            _mm256_setzero_si256 (),
+            _mm256_avx512_setzero_si256 (),
             (__mmask8) __U);
 }
 extern __inline __mmask8
@@ -5256,7 +5377,7 @@ _mm256_maskz_compress_pd (__mmask8 __U, __m256d __A)
 {
   return (__m256d) __builtin_ia32_compressdf256_mask ((__v4df) __A,
             (__v4df)
-            _mm256_setzero_pd (),
+            _mm256_avx512_setzero_pd (),
             (__mmask8) __U);
 }
 extern __inline void
@@ -5281,7 +5402,7 @@ _mm_maskz_compress_pd (__mmask8 __U, __m128d __A)
 {
   return (__m128d) __builtin_ia32_compressdf128_mask ((__v2df) __A,
             (__v2df)
-            _mm_setzero_pd (),
+            _mm_avx512_setzero_pd (),
             (__mmask8) __U);
 }
 extern __inline void
@@ -5306,7 +5427,7 @@ _mm256_maskz_compress_ps (__mmask8 __U, __m256 __A)
 {
   return (__m256) __builtin_ia32_compresssf256_mask ((__v8sf) __A,
            (__v8sf)
-           _mm256_setzero_ps (),
+           _mm256_avx512_setzero_ps (),
            (__mmask8) __U);
 }
 extern __inline void
@@ -5331,7 +5452,7 @@ _mm_maskz_compress_ps (__mmask8 __U, __m128 __A)
 {
   return (__m128) __builtin_ia32_compresssf128_mask ((__v4sf) __A,
            (__v4sf)
-           _mm_setzero_ps (),
+           _mm_avx512_setzero_ps (),
            (__mmask8) __U);
 }
 extern __inline void
@@ -5356,7 +5477,7 @@ _mm256_maskz_compress_epi64 (__mmask8 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_compressdi256_mask ((__v4di) __A,
             (__v4di)
-            _mm256_setzero_si256 (),
+            _mm256_avx512_setzero_si256 (),
             (__mmask8) __U);
 }
 extern __inline void
@@ -5381,7 +5502,7 @@ _mm_maskz_compress_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_compressdi128_mask ((__v2di) __A,
             (__v2di)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) __U);
 }
 extern __inline void
@@ -5406,7 +5527,7 @@ _mm256_maskz_compress_epi32 (__mmask8 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_compresssi256_mask ((__v8si) __A,
             (__v8si)
-            _mm256_setzero_si256 (),
+            _mm256_avx512_setzero_si256 (),
             (__mmask8) __U);
 }
 extern __inline void
@@ -5431,7 +5552,7 @@ _mm_maskz_compress_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_compresssi128_mask ((__v4si) __A,
             (__v4si)
-            _mm_setzero_si128 (),
+            _mm_avx512_setzero_si128 (),
             (__mmask8) __U);
 }
 extern __inline void
@@ -5456,7 +5577,7 @@ _mm256_maskz_expand_pd (__mmask8 __U, __m256d __A)
 {
   return (__m256d) __builtin_ia32_expanddf256_maskz ((__v4df) __A,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m256d
@@ -5474,7 +5595,7 @@ _mm256_maskz_expandloadu_pd (__mmask8 __U, void const *__P)
 {
   return (__m256d) __builtin_ia32_expandloaddf256_maskz ((__v4df *) __P,
         (__v4df)
-        _mm256_setzero_pd (),
+        _mm256_avx512_setzero_pd (),
         (__mmask8)
         __U);
 }
@@ -5492,7 +5613,7 @@ _mm_maskz_expand_pd (__mmask8 __U, __m128d __A)
 {
   return (__m128d) __builtin_ia32_expanddf128_maskz ((__v2df) __A,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m128d
@@ -5510,7 +5631,7 @@ _mm_maskz_expandloadu_pd (__mmask8 __U, void const *__P)
 {
   return (__m128d) __builtin_ia32_expandloaddf128_maskz ((__v2df *) __P,
         (__v2df)
-        _mm_setzero_pd (),
+        _mm_avx512_setzero_pd (),
         (__mmask8)
         __U);
 }
@@ -5528,7 +5649,7 @@ _mm256_maskz_expand_ps (__mmask8 __U, __m256 __A)
 {
   return (__m256) __builtin_ia32_expandsf256_maskz ((__v8sf) __A,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m256
@@ -5545,7 +5666,7 @@ _mm256_maskz_expandloadu_ps (__mmask8 __U, void const *__P)
 {
   return (__m256) __builtin_ia32_expandloadsf256_maskz ((__v8sf *) __P,
        (__v8sf)
-       _mm256_setzero_ps (),
+       _mm256_avx512_setzero_ps (),
        (__mmask8)
        __U);
 }
@@ -5563,7 +5684,7 @@ _mm_maskz_expand_ps (__mmask8 __U, __m128 __A)
 {
   return (__m128) __builtin_ia32_expandsf128_maskz ((__v4sf) __A,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -5580,7 +5701,7 @@ _mm_maskz_expandloadu_ps (__mmask8 __U, void const *__P)
 {
   return (__m128) __builtin_ia32_expandloadsf128_maskz ((__v4sf *) __P,
        (__v4sf)
-       _mm_setzero_ps (),
+       _mm_avx512_setzero_ps (),
        (__mmask8)
        __U);
 }
@@ -5598,7 +5719,7 @@ _mm256_maskz_expand_epi64 (__mmask8 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_expanddi256_maskz ((__v4di) __A,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -5617,7 +5738,7 @@ _mm256_maskz_expandloadu_epi64 (__mmask8 __U, void const *__P)
 {
   return (__m256i) __builtin_ia32_expandloaddi256_maskz ((__v4di *) __P,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8)
         __U);
 }
@@ -5635,7 +5756,7 @@ _mm_maskz_expand_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_expanddi128_maskz ((__v2di) __A,
            (__v2di)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -5653,7 +5774,7 @@ _mm_maskz_expandloadu_epi64 (__mmask8 __U, void const *__P)
 {
   return (__m128i) __builtin_ia32_expandloaddi128_maskz ((__v2di *) __P,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8)
         __U);
 }
@@ -5671,7 +5792,7 @@ _mm256_maskz_expand_epi32 (__mmask8 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_expandsi256_maskz ((__v8si) __A,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
@@ -5690,7 +5811,7 @@ _mm256_maskz_expandloadu_epi32 (__mmask8 __U, void const *__P)
 {
   return (__m256i) __builtin_ia32_expandloadsi256_maskz ((__v8si *) __P,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8)
         __U);
 }
@@ -5708,7 +5829,7 @@ _mm_maskz_expand_epi32 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_expandsi128_maskz ((__v4si) __A,
            (__v4si)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m128i
@@ -5726,7 +5847,7 @@ _mm_maskz_expandloadu_epi32 (__mmask8 __U, void const *__P)
 {
   return (__m128i) __builtin_ia32_expandloadsi128_maskz ((__v4si *) __P,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8)
         __U);
 }
@@ -6093,7 +6214,7 @@ _mm_srav_epi64 (__m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_psravq128_mask ((__v2di) __X,
         (__v2di) __Y,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -6113,7 +6234,7 @@ _mm_maskz_srav_epi64 (__mmask8 __U, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_psravq128_mask ((__v2di) __X,
         (__v2di) __Y,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6133,7 +6254,7 @@ _mm256_maskz_sllv_epi32 (__mmask8 __U, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_psllv8si_mask ((__v8si) __X,
        (__v8si) __Y,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -6153,7 +6274,7 @@ _mm_maskz_sllv_epi32 (__mmask8 __U, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_psllv4si_mask ((__v4si) __X,
        (__v4si) __Y,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6173,7 +6294,7 @@ _mm256_maskz_sllv_epi64 (__mmask8 __U, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_psllv4di_mask ((__v4di) __X,
        (__v4di) __Y,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -6193,7 +6314,7 @@ _mm_maskz_sllv_epi64 (__mmask8 __U, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_psllv2di_mask ((__v2di) __X,
        (__v2di) __Y,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6213,7 +6334,7 @@ _mm256_maskz_srav_epi32 (__mmask8 __U, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_psrav8si_mask ((__v8si) __X,
        (__v8si) __Y,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -6233,7 +6354,7 @@ _mm_maskz_srav_epi32 (__mmask8 __U, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_psrav4si_mask ((__v4si) __X,
        (__v4si) __Y,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6253,7 +6374,7 @@ _mm256_maskz_srlv_epi32 (__mmask8 __U, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_psrlv8si_mask ((__v8si) __X,
        (__v8si) __Y,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -6273,7 +6394,7 @@ _mm_maskz_srlv_epi32 (__mmask8 __U, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_psrlv4si_mask ((__v4si) __X,
        (__v4si) __Y,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6293,7 +6414,7 @@ _mm256_maskz_srlv_epi64 (__mmask8 __U, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_psrlv4di_mask ((__v4di) __X,
        (__v4di) __Y,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -6313,7 +6434,7 @@ _mm_maskz_srlv_epi64 (__mmask8 __U, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_psrlv2di_mask ((__v2di) __X,
        (__v2di) __Y,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6323,7 +6444,7 @@ _mm256_rolv_epi32 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_prolvd256_mask ((__v8si) __A,
         (__v8si) __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -6343,7 +6464,7 @@ _mm256_maskz_rolv_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_prolvd256_mask ((__v8si) __A,
         (__v8si) __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -6353,7 +6474,7 @@ _mm_rolv_epi32 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_prolvd128_mask ((__v4si) __A,
         (__v4si) __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -6373,7 +6494,7 @@ _mm_maskz_rolv_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_prolvd128_mask ((__v4si) __A,
         (__v4si) __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6383,7 +6504,7 @@ _mm256_rorv_epi32 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_prorvd256_mask ((__v8si) __A,
         (__v8si) __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -6403,7 +6524,7 @@ _mm256_maskz_rorv_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_prorvd256_mask ((__v8si) __A,
         (__v8si) __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -6413,7 +6534,7 @@ _mm_rorv_epi32 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_prorvd128_mask ((__v4si) __A,
         (__v4si) __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -6433,7 +6554,7 @@ _mm_maskz_rorv_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_prorvd128_mask ((__v4si) __A,
         (__v4si) __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6443,7 +6564,7 @@ _mm256_rolv_epi64 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_prolvq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -6463,7 +6584,7 @@ _mm256_maskz_rolv_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_prolvq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -6473,7 +6594,7 @@ _mm_rolv_epi64 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_prolvq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -6493,7 +6614,7 @@ _mm_maskz_rolv_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_prolvq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6503,7 +6624,7 @@ _mm256_rorv_epi64 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_prorvq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -6523,7 +6644,7 @@ _mm256_maskz_rorv_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_prorvq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -6533,7 +6654,7 @@ _mm_rorv_epi64 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_prorvq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -6553,7 +6674,7 @@ _mm_maskz_rorv_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_prorvq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6563,7 +6684,7 @@ _mm256_srav_epi64 (__m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_psravq256_mask ((__v4di) __X,
         (__v4di) __Y,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -6583,7 +6704,7 @@ _mm256_maskz_srav_epi64 (__mmask8 __U, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_psravq256_mask ((__v4di) __X,
         (__v4di) __Y,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -6602,7 +6723,7 @@ _mm256_maskz_and_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pandq256_mask ((__v4di) __A,
        (__v4di) __B,
        (__v4di)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        __U);
 }
 extern __inline __m128i
@@ -6621,7 +6742,7 @@ _mm_maskz_and_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pandq128_mask ((__v2di) __A,
        (__v2di) __B,
        (__v2di)
-       _mm_setzero_pd (),
+       _mm_avx512_setzero_pd (),
        __U);
 }
 extern __inline __m256i
@@ -6640,7 +6761,7 @@ _mm256_maskz_andnot_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pandnq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_pd (),
+        _mm256_avx512_setzero_pd (),
         __U);
 }
 extern __inline __m128i
@@ -6659,7 +6780,7 @@ _mm_maskz_andnot_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pandnq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_pd (),
+        _mm_avx512_setzero_pd (),
         __U);
 }
 extern __inline __m256i
@@ -6679,7 +6800,7 @@ _mm256_maskz_or_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_porq256_mask ((__v4di) __A,
       (__v4di) __B,
       (__v4di)
-      _mm256_setzero_si256 (),
+      _mm256_avx512_setzero_si256 (),
       (__mmask8) __U);
 }
 extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -6703,7 +6824,7 @@ _mm_maskz_or_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_porq128_mask ((__v2di) __A,
       (__v2di) __B,
       (__v2di)
-      _mm_setzero_si128 (),
+      _mm_avx512_setzero_si128 (),
       (__mmask8) __U);
 }
 extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -6728,7 +6849,7 @@ _mm256_maskz_xor_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pxorq256_mask ((__v4di) __A,
        (__v4di) __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -6753,7 +6874,7 @@ _mm_maskz_xor_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pxorq128_mask ((__v2di) __A,
        (__v2di) __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -6778,7 +6899,7 @@ _mm256_maskz_max_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_maxpd256_mask ((__v4df) __A,
        (__v4df) __B,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m256
@@ -6797,7 +6918,7 @@ _mm256_maskz_max_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_maxps256_mask ((__v8sf) __A,
       (__v8sf) __B,
       (__v8sf)
-      _mm256_setzero_ps (),
+      _mm256_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m128
@@ -6816,7 +6937,7 @@ _mm_maskz_div_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_divps_mask ((__v4sf) __A,
           (__v4sf) __B,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128d
@@ -6835,7 +6956,7 @@ _mm_maskz_div_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_divpd_mask ((__v2df) __A,
            (__v2df) __B,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m256d
@@ -6865,7 +6986,7 @@ _mm256_maskz_min_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_minpd256_mask ((__v4df) __A,
        (__v4df) __B,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m256
@@ -6884,7 +7005,7 @@ _mm256_maskz_div_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_divpd256_mask ((__v4df) __A,
        (__v4df) __B,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m256
@@ -6903,7 +7024,7 @@ _mm256_maskz_min_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_minps256_mask ((__v8sf) __A,
       (__v8sf) __B,
       (__v8sf)
-      _mm256_setzero_ps (),
+      _mm256_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m256
@@ -6913,7 +7034,7 @@ _mm256_maskz_div_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_divps256_mask ((__v8sf) __A,
       (__v8sf) __B,
       (__v8sf)
-      _mm256_setzero_ps (),
+      _mm256_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m128
@@ -6941,7 +7062,7 @@ _mm_maskz_min_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_minps_mask ((__v4sf) __A,
           (__v4sf) __B,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -6951,7 +7072,7 @@ _mm_maskz_mul_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_mulps_mask ((__v4sf) __A,
           (__v4sf) __B,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -6970,7 +7091,7 @@ _mm_maskz_max_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_maxps_mask ((__v4sf) __A,
           (__v4sf) __B,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128d
@@ -6989,7 +7110,7 @@ _mm_maskz_min_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_minpd_mask ((__v2df) __A,
            (__v2df) __B,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m128d
@@ -7008,7 +7129,7 @@ _mm_maskz_max_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_maxpd_mask ((__v2df) __A,
            (__v2df) __B,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m128d
@@ -7027,7 +7148,7 @@ _mm_maskz_mul_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_mulpd_mask ((__v2df) __A,
            (__v2df) __B,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m256
@@ -7046,7 +7167,7 @@ _mm256_maskz_mul_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_mulps256_mask ((__v8sf) __A,
       (__v8sf) __B,
       (__v8sf)
-      _mm256_setzero_ps (),
+      _mm256_avx512_setzero_ps (),
       (__mmask8) __U);
 }
 extern __inline __m256d
@@ -7066,7 +7187,7 @@ _mm256_maskz_mul_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_mulpd256_mask ((__v4df) __A,
        (__v4df) __B,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -7076,7 +7197,7 @@ _mm256_maskz_max_epi64 (__mmask8 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaxsq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __M);
 }
 extern __inline __m256i
@@ -7095,7 +7216,7 @@ _mm256_min_epi64 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pminsq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -7114,7 +7235,7 @@ _mm256_maskz_min_epi64 (__mmask8 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pminsq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __M);
 }
 extern __inline __m256i
@@ -7124,7 +7245,7 @@ _mm256_maskz_max_epu64 (__mmask8 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaxuq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __M);
 }
 extern __inline __m256i
@@ -7134,7 +7255,7 @@ _mm256_max_epi64 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaxsq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -7144,7 +7265,7 @@ _mm256_max_epu64 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaxuq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -7163,7 +7284,7 @@ _mm256_min_epu64 (__m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pminuq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -7182,7 +7303,7 @@ _mm256_maskz_min_epu64 (__mmask8 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pminuq256_mask ((__v4di) __A,
         (__v4di) __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __M);
 }
 extern __inline __m256i
@@ -7192,7 +7313,7 @@ _mm256_maskz_max_epi32 (__mmask8 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaxsd256_mask ((__v8si) __A,
         (__v8si) __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __M);
 }
 extern __inline __m256i
@@ -7211,7 +7332,7 @@ _mm256_maskz_min_epi32 (__mmask8 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pminsd256_mask ((__v8si) __A,
         (__v8si) __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __M);
 }
 extern __inline __m256i
@@ -7230,7 +7351,7 @@ _mm256_maskz_max_epu32 (__mmask8 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmaxud256_mask ((__v8si) __A,
         (__v8si) __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __M);
 }
 extern __inline __m256i
@@ -7249,7 +7370,7 @@ _mm256_maskz_min_epu32 (__mmask8 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pminud256_mask ((__v8si) __A,
         (__v8si) __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __M);
 }
 extern __inline __m256i
@@ -7268,7 +7389,7 @@ _mm_maskz_max_epi64 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaxsq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -7287,7 +7408,7 @@ _mm_min_epi64 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pminsq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -7306,7 +7427,7 @@ _mm_maskz_min_epi64 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pminsq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -7316,7 +7437,7 @@ _mm_maskz_max_epu64 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaxuq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -7326,7 +7447,7 @@ _mm_max_epi64 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaxsq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -7336,7 +7457,7 @@ _mm_max_epu64 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaxuq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -7355,7 +7476,7 @@ _mm_min_epu64 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pminuq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -7374,7 +7495,7 @@ _mm_maskz_min_epu64 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pminuq128_mask ((__v2di) __A,
         (__v2di) __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -7384,7 +7505,7 @@ _mm_maskz_max_epi32 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaxsd128_mask ((__v4si) __A,
         (__v4si) __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -7403,7 +7524,7 @@ _mm_maskz_min_epi32 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pminsd128_mask ((__v4si) __A,
         (__v4si) __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -7422,7 +7543,7 @@ _mm_maskz_max_epu32 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmaxud128_mask ((__v4si) __A,
         (__v4si) __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -7441,7 +7562,7 @@ _mm_maskz_min_epu32 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pminud128_mask ((__v4si) __A,
         (__v4si) __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -7453,254 +7574,6 @@ _mm_mask_min_epu32 (__m128i __W, __mmask8 __M, __m128i __A,
         (__v4si) __B,
         (__v4si) __W, __M);
 }
-#ifndef __AVX512CD__
-#pragma GCC push_options
-#pragma GCC target("avx512vl,avx512cd")
-#define __DISABLE_AVX512VLCD__
-#endif
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_broadcastmb_epi64 (__mmask8 __A)
-{
-  return (__m128i) __builtin_ia32_broadcastmb128 (__A);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_broadcastmb_epi64 (__mmask8 __A)
-{
-  return (__m256i) __builtin_ia32_broadcastmb256 (__A);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_broadcastmw_epi32 (__mmask16 __A)
-{
-  return (__m128i) __builtin_ia32_broadcastmw128 (__A);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_broadcastmw_epi32 (__mmask16 __A)
-{
-  return (__m256i) __builtin_ia32_broadcastmw256 (__A);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_lzcnt_epi32 (__m256i __A)
-{
-  return (__m256i) __builtin_ia32_vplzcntd_256_mask ((__v8si) __A,
-           (__v8si)
-           _mm256_setzero_si256 (),
-           (__mmask8) -1);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_lzcnt_epi32 (__m256i __W, __mmask8 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vplzcntd_256_mask ((__v8si) __A,
-           (__v8si) __W,
-           (__mmask8) __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_lzcnt_epi32 (__mmask8 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vplzcntd_256_mask ((__v8si) __A,
-           (__v8si)
-           _mm256_setzero_si256 (),
-           (__mmask8) __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_lzcnt_epi64 (__m256i __A)
-{
-  return (__m256i) __builtin_ia32_vplzcntq_256_mask ((__v4di) __A,
-           (__v4di)
-           _mm256_setzero_si256 (),
-           (__mmask8) -1);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_lzcnt_epi64 (__m256i __W, __mmask8 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vplzcntq_256_mask ((__v4di) __A,
-           (__v4di) __W,
-           (__mmask8) __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_lzcnt_epi64 (__mmask8 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vplzcntq_256_mask ((__v4di) __A,
-           (__v4di)
-           _mm256_setzero_si256 (),
-           (__mmask8) __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_conflict_epi64 (__m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpconflictdi_256_mask ((__v4di) __A,
-        (__v4di)
-        _mm256_setzero_si256 (),
-        (__mmask8) -1);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_conflict_epi64 (__m256i __W, __mmask8 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpconflictdi_256_mask ((__v4di) __A,
-        (__v4di) __W,
-        (__mmask8)
-        __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_conflict_epi64 (__mmask8 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpconflictdi_256_mask ((__v4di) __A,
-        (__v4di)
-        _mm256_setzero_si256 (),
-        (__mmask8)
-        __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_conflict_epi32 (__m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpconflictsi_256_mask ((__v8si) __A,
-        (__v8si)
-        _mm256_setzero_si256 (),
-        (__mmask8) -1);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_conflict_epi32 (__m256i __W, __mmask8 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpconflictsi_256_mask ((__v8si) __A,
-        (__v8si) __W,
-        (__mmask8)
-        __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_conflict_epi32 (__mmask8 __U, __m256i __A)
-{
-  return (__m256i) __builtin_ia32_vpconflictsi_256_mask ((__v8si) __A,
-        (__v8si)
-        _mm256_setzero_si256 (),
-        (__mmask8)
-        __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_lzcnt_epi32 (__m128i __A)
-{
-  return (__m128i) __builtin_ia32_vplzcntd_128_mask ((__v4si) __A,
-           (__v4si)
-           _mm_setzero_si128 (),
-           (__mmask8) -1);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_lzcnt_epi32 (__m128i __W, __mmask8 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vplzcntd_128_mask ((__v4si) __A,
-           (__v4si) __W,
-           (__mmask8) __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_lzcnt_epi32 (__mmask8 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vplzcntd_128_mask ((__v4si) __A,
-           (__v4si)
-           _mm_setzero_si128 (),
-           (__mmask8) __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_lzcnt_epi64 (__m128i __A)
-{
-  return (__m128i) __builtin_ia32_vplzcntq_128_mask ((__v2di) __A,
-           (__v2di)
-           _mm_setzero_si128 (),
-           (__mmask8) -1);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_lzcnt_epi64 (__m128i __W, __mmask8 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vplzcntq_128_mask ((__v2di) __A,
-           (__v2di) __W,
-           (__mmask8) __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_lzcnt_epi64 (__mmask8 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vplzcntq_128_mask ((__v2di) __A,
-           (__v2di)
-           _mm_setzero_si128 (),
-           (__mmask8) __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_conflict_epi64 (__m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpconflictdi_128_mask ((__v2di) __A,
-        (__v2di)
-        _mm_setzero_si128 (),
-        (__mmask8) -1);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_conflict_epi64 (__m128i __W, __mmask8 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpconflictdi_128_mask ((__v2di) __A,
-        (__v2di) __W,
-        (__mmask8)
-        __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_conflict_epi64 (__mmask8 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpconflictdi_128_mask ((__v2di) __A,
-        (__v2di)
-        _mm_setzero_si128 (),
-        (__mmask8)
-        __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_conflict_epi32 (__m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpconflictsi_128_mask ((__v4si) __A,
-        (__v4si)
-        _mm_setzero_si128 (),
-        (__mmask8) -1);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_conflict_epi32 (__m128i __W, __mmask8 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpconflictsi_128_mask ((__v4si) __A,
-        (__v4si) __W,
-        (__mmask8)
-        __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_conflict_epi32 (__mmask8 __U, __m128i __A)
-{
-  return (__m128i) __builtin_ia32_vpconflictsi_128_mask ((__v4si) __A,
-        (__v4si)
-        _mm_setzero_si128 (),
-        (__mmask8)
-        __U);
-}
-#ifdef __DISABLE_AVX512VLCD__
-#pragma GCC pop_options
-#endif
 extern __inline __m256d
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_unpacklo_pd (__m256d __W, __mmask8 __U, __m256d __A,
@@ -7718,7 +7591,7 @@ _mm256_maskz_unpacklo_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_unpcklpd256_mask ((__v4df) __A,
           (__v4df) __B,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m128d
@@ -7738,7 +7611,7 @@ _mm_maskz_unpacklo_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_unpcklpd128_mask ((__v2df) __A,
           (__v2df) __B,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m256
@@ -7768,7 +7641,7 @@ _mm256_maskz_unpackhi_pd (__mmask8 __U, __m256d __A, __m256d __B)
   return (__m256d) __builtin_ia32_unpckhpd256_mask ((__v4df) __A,
           (__v4df) __B,
           (__v4df)
-          _mm256_setzero_pd (),
+          _mm256_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m128d
@@ -7788,7 +7661,7 @@ _mm_maskz_unpackhi_pd (__mmask8 __U, __m128d __A, __m128d __B)
   return (__m128d) __builtin_ia32_unpckhpd128_mask ((__v2df) __A,
           (__v2df) __B,
           (__v2df)
-          _mm_setzero_pd (),
+          _mm_avx512_setzero_pd (),
           (__mmask8) __U);
 }
 extern __inline __m256
@@ -7808,7 +7681,7 @@ _mm256_maskz_unpackhi_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_unpckhps256_mask ((__v8sf) __A,
          (__v8sf) __B,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128
@@ -7827,7 +7700,7 @@ _mm_maskz_unpackhi_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_unpckhps128_mask ((__v4sf) __A,
          (__v4sf) __B,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m128
@@ -7844,7 +7717,7 @@ _mm_maskz_cvtph_ps (__mmask8 __U, __m128i __A)
 {
   return (__m128) __builtin_ia32_vcvtph2ps_mask ((__v8hi) __A,
        (__v4sf)
-       _mm_setzero_ps (),
+       _mm_avx512_setzero_ps (),
        (__mmask8) __U);
 }
 extern __inline __m256
@@ -7854,7 +7727,7 @@ _mm256_maskz_unpacklo_ps (__mmask8 __U, __m256 __A, __m256 __B)
   return (__m256) __builtin_ia32_unpcklps256_mask ((__v8sf) __A,
          (__v8sf) __B,
          (__v8sf)
-         _mm256_setzero_ps (),
+         _mm256_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m256
@@ -7871,7 +7744,7 @@ _mm256_maskz_cvtph_ps (__mmask8 __U, __m128i __A)
 {
   return (__m256) __builtin_ia32_vcvtph2ps256_mask ((__v8hi) __A,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -7890,7 +7763,7 @@ _mm_maskz_unpacklo_ps (__mmask8 __U, __m128 __A, __m128 __B)
   return (__m128) __builtin_ia32_unpcklps128_mask ((__v4sf) __A,
          (__v4sf) __B,
          (__v4sf)
-         _mm_setzero_ps (),
+         _mm_avx512_setzero_ps (),
          (__mmask8) __U);
 }
 extern __inline __m256i
@@ -7910,7 +7783,7 @@ _mm256_maskz_sra_epi32 (__mmask8 __U, __m256i __A, __m128i __B)
   return (__m256i) __builtin_ia32_psrad256_mask ((__v8si) __A,
        (__v4si) __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -7930,7 +7803,7 @@ _mm_maskz_sra_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psrad128_mask ((__v4si) __A,
        (__v4si) __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -7940,7 +7813,7 @@ _mm256_sra_epi64 (__m256i __A, __m128i __B)
   return (__m256i) __builtin_ia32_psraq256_mask ((__v4di) __A,
        (__v2di) __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) -1);
 }
 extern __inline __m256i
@@ -7960,7 +7833,7 @@ _mm256_maskz_sra_epi64 (__mmask8 __U, __m256i __A, __m128i __B)
   return (__m256i) __builtin_ia32_psraq256_mask ((__v4di) __A,
        (__v2di) __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -7970,7 +7843,7 @@ _mm_sra_epi64 (__m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psraq128_mask ((__v2di) __A,
        (__v2di) __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) -1);
 }
 extern __inline __m128i
@@ -7990,7 +7863,7 @@ _mm_maskz_sra_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psraq128_mask ((__v2di) __A,
        (__v2di) __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -8010,7 +7883,7 @@ _mm_maskz_sll_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pslld128_mask ((__v4si) __A,
        (__v4si) __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -8030,7 +7903,7 @@ _mm_maskz_sll_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_psllq128_mask ((__v2di) __A,
        (__v2di) __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -8050,7 +7923,7 @@ _mm256_maskz_sll_epi32 (__mmask8 __U, __m256i __A, __m128i __B)
   return (__m256i) __builtin_ia32_pslld256_mask ((__v8si) __A,
        (__v4si) __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -8070,7 +7943,7 @@ _mm256_maskz_sll_epi64 (__mmask8 __U, __m256i __A, __m128i __B)
   return (__m256i) __builtin_ia32_psllq256_mask ((__v4di) __A,
        (__v2di) __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m256
@@ -8090,7 +7963,7 @@ _mm256_maskz_permutexvar_ps (__mmask8 __U, __m256i __X, __m256 __Y)
   return (__m256) __builtin_ia32_permvarsf256_mask ((__v8sf) __Y,
           (__v8si) __X,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m256d
@@ -8100,7 +7973,7 @@ _mm256_permutexvar_pd (__m256i __X, __m256d __Y)
   return (__m256d) __builtin_ia32_permvardf256_mask ((__v4df) __Y,
            (__v4di) __X,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m256d
@@ -8120,7 +7993,7 @@ _mm256_maskz_permutexvar_pd (__mmask8 __U, __m256i __X, __m256d __Y)
   return (__m256d) __builtin_ia32_permvardf256_mask ((__v4df) __Y,
            (__v4di) __X,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m256d
@@ -8141,7 +8014,7 @@ _mm256_maskz_permutevar_pd (__mmask8 __U, __m256d __A, __m256i __C)
   return (__m256d) __builtin_ia32_vpermilvarpd256_mask ((__v4df) __A,
        (__v4di) __C,
        (__v4df)
-       _mm256_setzero_pd (),
+       _mm256_avx512_setzero_pd (),
        (__mmask8)
        __U);
 }
@@ -8162,7 +8035,7 @@ _mm256_maskz_permutevar_ps (__mmask8 __U, __m256 __A, __m256i __C)
   return (__m256) __builtin_ia32_vpermilvarps256_mask ((__v8sf) __A,
              (__v8si) __C,
              (__v8sf)
-             _mm256_setzero_ps (),
+             _mm256_avx512_setzero_ps (),
              (__mmask8) __U);
 }
 extern __inline __m128d
@@ -8182,7 +8055,7 @@ _mm_maskz_permutevar_pd (__mmask8 __U, __m128d __A, __m128i __C)
   return (__m128d) __builtin_ia32_vpermilvarpd_mask ((__v2df) __A,
            (__v2di) __C,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m128
@@ -8202,7 +8075,7 @@ _mm_maskz_permutevar_ps (__mmask8 __U, __m128 __A, __m128i __C)
   return (__m128) __builtin_ia32_vpermilvarps_mask ((__v4sf) __A,
           (__v4si) __C,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m256i
@@ -8212,7 +8085,7 @@ _mm256_maskz_mullo_epi32 (__mmask8 __M, __m256i __A, __m256i __B)
   return (__m256i) __builtin_ia32_pmulld256_mask ((__v8si) __A,
         (__v8si) __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __M);
 }
 extern __inline __m256i
@@ -8222,7 +8095,7 @@ _mm256_maskz_permutexvar_epi64 (__mmask8 __M, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_permvardi256_mask ((__v4di) __Y,
            (__v4di) __X,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            __M);
 }
 extern __inline __m256i
@@ -8241,7 +8114,7 @@ _mm_maskz_mullo_epi32 (__mmask8 __M, __m128i __A, __m128i __B)
   return (__m128i) __builtin_ia32_pmulld128_mask ((__v4si) __A,
         (__v4si) __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m128i
@@ -8269,7 +8142,7 @@ _mm256_maskz_mul_epi32 (__mmask8 __M, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_pmuldq256_mask ((__v8si) __X,
         (__v8si) __Y,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         __M);
 }
 extern __inline __m128i
@@ -8288,7 +8161,7 @@ _mm_maskz_mul_epi32 (__mmask8 __M, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_pmuldq128_mask ((__v4si) __X,
         (__v4si) __Y,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         __M);
 }
 extern __inline __m256i
@@ -8298,7 +8171,7 @@ _mm256_permutexvar_epi64 (__m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_permvardi256_mask ((__v4di) __Y,
            (__v4di) __X,
            (__v4di)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) -1);
 }
 extern __inline __m256i
@@ -8327,7 +8200,7 @@ _mm256_maskz_permutexvar_epi32 (__mmask8 __M, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_permvarsi256_mask ((__v8si) __Y,
            (__v8si) __X,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            __M);
 }
 extern __inline __m256i
@@ -8337,7 +8210,7 @@ _mm256_maskz_mul_epu32 (__mmask8 __M, __m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_pmuludq256_mask ((__v8si) __X,
          (__v8si) __Y,
          (__v4di)
-         _mm256_setzero_si256 (),
+         _mm256_avx512_setzero_si256 (),
          __M);
 }
 extern __inline __m128i
@@ -8356,7 +8229,7 @@ _mm_maskz_mul_epu32 (__mmask8 __M, __m128i __X, __m128i __Y)
   return (__m128i) __builtin_ia32_pmuludq128_mask ((__v4si) __X,
          (__v4si) __Y,
          (__v2di)
-         _mm_setzero_si128 (),
+         _mm_avx512_setzero_si128 (),
          __M);
 }
 extern __inline __m256i
@@ -8366,7 +8239,7 @@ _mm256_permutexvar_epi32 (__m256i __X, __m256i __Y)
   return (__m256i) __builtin_ia32_permvarsi256_mask ((__v8si) __Y,
            (__v8si) __X,
            (__v8si)
-           _mm256_setzero_si256 (),
+           _mm256_avx512_setzero_si256 (),
            (__mmask8) -1);
 }
 extern __inline __m256i
@@ -8899,7 +8772,7 @@ _mm256_permutex_epi64 (__m256i __X, const int __I)
   return (__m256i) __builtin_ia32_permdi256_mask ((__v4di) __X,
            __I,
            (__v4di)
-           _mm256_setzero_si256(),
+           _mm256_avx512_setzero_si256(),
            (__mmask8) -1);
 }
 extern __inline __m256i
@@ -8919,7 +8792,7 @@ _mm256_maskz_permutex_epi64 (__mmask8 __M, __m256i __X, const int __I)
   return (__m256i) __builtin_ia32_permdi256_mask ((__v4di) __X,
         __I,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __M);
 }
 extern __inline __m256d
@@ -8940,7 +8813,7 @@ _mm256_maskz_shuffle_pd (__mmask8 __U, __m256d __A, __m256d __B,
   return (__m256d) __builtin_ia32_shufpd256_mask ((__v4df) __A,
         (__v4df) __B, __imm,
         (__v4df)
-        _mm256_setzero_pd (),
+        _mm256_avx512_setzero_pd (),
         (__mmask8) __U);
 }
 extern __inline __m128d
@@ -8961,7 +8834,7 @@ _mm_maskz_shuffle_pd (__mmask8 __U, __m128d __A, __m128d __B,
   return (__m128d) __builtin_ia32_shufpd128_mask ((__v2df) __A,
         (__v2df) __B, __imm,
         (__v2df)
-        _mm_setzero_pd (),
+        _mm_avx512_setzero_pd (),
         (__mmask8) __U);
 }
 extern __inline __m256
@@ -8982,7 +8855,7 @@ _mm256_maskz_shuffle_ps (__mmask8 __U, __m256 __A, __m256 __B,
   return (__m256) __builtin_ia32_shufps256_mask ((__v8sf) __A,
        (__v8sf) __B, __imm,
        (__v8sf)
-       _mm256_setzero_ps (),
+       _mm256_avx512_setzero_ps (),
        (__mmask8) __U);
 }
 extern __inline __m128
@@ -9003,7 +8876,7 @@ _mm_maskz_shuffle_ps (__mmask8 __U, __m128 __A, __m128 __B,
   return (__m128) __builtin_ia32_shufps128_mask ((__v4sf) __A,
        (__v4sf) __B, __imm,
        (__v4sf)
-       _mm_setzero_ps (),
+       _mm_avx512_setzero_ps (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -9014,7 +8887,7 @@ _mm256_inserti32x4 (__m256i __A, __m128i __B, const int __imm)
        (__v4si) __B,
        __imm,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) -1);
 }
 extern __inline __m256i
@@ -9038,7 +8911,7 @@ _mm256_maskz_inserti32x4 (__mmask8 __U, __m256i __A, __m128i __B,
        (__v4si) __B,
        __imm,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8)
        __U);
 }
@@ -9050,7 +8923,7 @@ _mm256_insertf32x4 (__m256 __A, __m128 __B, const int __imm)
              (__v4sf) __B,
              __imm,
              (__v8sf)
-             _mm256_setzero_ps (),
+             _mm256_avx512_setzero_ps (),
              (__mmask8) -1);
 }
 extern __inline __m256
@@ -9073,7 +8946,7 @@ _mm256_maskz_insertf32x4 (__mmask8 __U, __m256 __A, __m128 __B,
              (__v4sf) __B,
              __imm,
              (__v8sf)
-             _mm256_setzero_ps (),
+             _mm256_avx512_setzero_ps (),
              (__mmask8) __U);
 }
 extern __inline __m128i
@@ -9083,7 +8956,7 @@ _mm256_extracti32x4_epi32 (__m256i __A, const int __imm)
   return (__m128i) __builtin_ia32_extracti32x4_256_mask ((__v8si) __A,
         __imm,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -9105,7 +8978,7 @@ _mm256_maskz_extracti32x4_epi32 (__mmask8 __U, __m256i __A,
   return (__m128i) __builtin_ia32_extracti32x4_256_mask ((__v8si) __A,
         __imm,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8)
         __U);
 }
@@ -9116,7 +8989,7 @@ _mm256_extractf32x4_ps (__m256 __A, const int __imm)
   return (__m128) __builtin_ia32_extractf32x4_256_mask ((__v8sf) __A,
        __imm,
        (__v4sf)
-       _mm_setzero_ps (),
+       _mm_avx512_setzero_ps (),
        (__mmask8) -1);
 }
 extern __inline __m128
@@ -9138,7 +9011,7 @@ _mm256_maskz_extractf32x4_ps (__mmask8 __U, __m256 __A,
   return (__m128) __builtin_ia32_extractf32x4_256_mask ((__v8sf) __A,
        __imm,
        (__v4sf)
-       _mm_setzero_ps (),
+       _mm_avx512_setzero_ps (),
        (__mmask8)
        __U);
 }
@@ -9150,7 +9023,7 @@ _mm256_shuffle_i64x2 (__m256i __A, __m256i __B, const int __imm)
              (__v4di) __B,
              __imm,
              (__v4di)
-             _mm256_setzero_si256 (),
+             _mm256_avx512_setzero_si256 (),
              (__mmask8) -1);
 }
 extern __inline __m256i
@@ -9173,7 +9046,7 @@ _mm256_maskz_shuffle_i64x2 (__mmask8 __U, __m256i __A, __m256i __B,
              (__v4di) __B,
              __imm,
              (__v4di)
-             _mm256_setzero_si256 (),
+             _mm256_avx512_setzero_si256 (),
              (__mmask8) __U);
 }
 extern __inline __m256i
@@ -9184,7 +9057,7 @@ _mm256_shuffle_i32x4 (__m256i __A, __m256i __B, const int __imm)
              (__v8si) __B,
              __imm,
              (__v8si)
-             _mm256_setzero_si256 (),
+             _mm256_avx512_setzero_si256 (),
              (__mmask8) -1);
 }
 extern __inline __m256i
@@ -9207,7 +9080,7 @@ _mm256_maskz_shuffle_i32x4 (__mmask8 __U, __m256i __A, __m256i __B,
              (__v8si) __B,
              __imm,
              (__v8si)
-             _mm256_setzero_si256 (),
+             _mm256_avx512_setzero_si256 (),
              (__mmask8) __U);
 }
 extern __inline __m256d
@@ -9218,7 +9091,7 @@ _mm256_shuffle_f64x2 (__m256d __A, __m256d __B, const int __imm)
              (__v4df) __B,
              __imm,
              (__v4df)
-             _mm256_setzero_pd (),
+             _mm256_avx512_setzero_pd (),
              (__mmask8) -1);
 }
 extern __inline __m256d
@@ -9241,7 +9114,7 @@ _mm256_maskz_shuffle_f64x2 (__mmask8 __U, __m256d __A, __m256d __B,
              (__v4df) __B,
              __imm,
              (__v4df)
-             _mm256_setzero_pd (),
+             _mm256_avx512_setzero_pd (),
              (__mmask8) __U);
 }
 extern __inline __m256
@@ -9252,7 +9125,7 @@ _mm256_shuffle_f32x4 (__m256 __A, __m256 __B, const int __imm)
             (__v8sf) __B,
             __imm,
             (__v8sf)
-            _mm256_setzero_ps (),
+            _mm256_avx512_setzero_ps (),
             (__mmask8) -1);
 }
 extern __inline __m256
@@ -9275,7 +9148,7 @@ _mm256_maskz_shuffle_f32x4 (__mmask8 __U, __m256 __A, __m256 __B,
             (__v8sf) __B,
             __imm,
             (__v8sf)
-            _mm256_setzero_ps (),
+            _mm256_avx512_setzero_ps (),
             (__mmask8) __U);
 }
 extern __inline __m256d
@@ -9412,7 +9285,7 @@ _mm_maskz_fixupimm_ps (__mmask8 __U, __m128 __A, __m128 __B,
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_srli_epi32 (__m256i __W, __mmask8 __U, __m256i __A,
-   const int __imm)
+   const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psrldi256_mask ((__v8si) __A, __imm,
         (__v8si) __W,
@@ -9420,17 +9293,17 @@ _mm256_mask_srli_epi32 (__m256i __W, __mmask8 __U, __m256i __A,
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_srli_epi32 (__mmask8 __U, __m256i __A, const int __imm)
+_mm256_maskz_srli_epi32 (__mmask8 __U, __m256i __A, const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psrldi256_mask ((__v8si) __A, __imm,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_mask_srli_epi32 (__m128i __W, __mmask8 __U, __m128i __A,
-       const int __imm)
+       const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psrldi128_mask ((__v4si) __A, __imm,
         (__v4si) __W,
@@ -9438,17 +9311,17 @@ _mm_mask_srli_epi32 (__m128i __W, __mmask8 __U, __m128i __A,
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_srli_epi32 (__mmask8 __U, __m128i __A, const int __imm)
+_mm_maskz_srli_epi32 (__mmask8 __U, __m128i __A, const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psrldi128_mask ((__v4si) __A, __imm,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_srli_epi64 (__m256i __W, __mmask8 __U, __m256i __A,
-   const int __imm)
+   const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psrlqi256_mask ((__v4di) __A, __imm,
         (__v4di) __W,
@@ -9456,17 +9329,17 @@ _mm256_mask_srli_epi64 (__m256i __W, __mmask8 __U, __m256i __A,
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_srli_epi64 (__mmask8 __U, __m256i __A, const int __imm)
+_mm256_maskz_srli_epi64 (__mmask8 __U, __m256i __A, const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psrlqi256_mask ((__v4di) __A, __imm,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_mask_srli_epi64 (__m128i __W, __mmask8 __U, __m128i __A,
-       const int __imm)
+       const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psrlqi128_mask ((__v2di) __A, __imm,
         (__v2di) __W,
@@ -9474,11 +9347,11 @@ _mm_mask_srli_epi64 (__m128i __W, __mmask8 __U, __m128i __A,
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_srli_epi64 (__mmask8 __U, __m128i __A, const int __imm)
+_mm_maskz_srli_epi64 (__mmask8 __U, __m128i __A, const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psrlqi128_mask ((__v2di) __A, __imm,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -9640,7 +9513,7 @@ _mm256_roundscale_ps (__m256 __A, const int __imm)
   return (__m256) __builtin_ia32_rndscaleps_256_mask ((__v8sf) __A,
             __imm,
             (__v8sf)
-            _mm256_setzero_ps (),
+            _mm256_avx512_setzero_ps (),
             (__mmask8) -1);
 }
 extern __inline __m256
@@ -9660,7 +9533,7 @@ _mm256_maskz_roundscale_ps (__mmask8 __U, __m256 __A, const int __imm)
   return (__m256) __builtin_ia32_rndscaleps_256_mask ((__v8sf) __A,
             __imm,
             (__v8sf)
-            _mm256_setzero_ps (),
+            _mm256_avx512_setzero_ps (),
             (__mmask8) __U);
 }
 extern __inline __m256d
@@ -9670,7 +9543,7 @@ _mm256_roundscale_pd (__m256d __A, const int __imm)
   return (__m256d) __builtin_ia32_rndscalepd_256_mask ((__v4df) __A,
              __imm,
              (__v4df)
-             _mm256_setzero_pd (),
+             _mm256_avx512_setzero_pd (),
              (__mmask8) -1);
 }
 extern __inline __m256d
@@ -9690,7 +9563,7 @@ _mm256_maskz_roundscale_pd (__mmask8 __U, __m256d __A, const int __imm)
   return (__m256d) __builtin_ia32_rndscalepd_256_mask ((__v4df) __A,
              __imm,
              (__v4df)
-             _mm256_setzero_pd (),
+             _mm256_avx512_setzero_pd (),
              (__mmask8) __U);
 }
 extern __inline __m128
@@ -9700,7 +9573,7 @@ _mm_roundscale_ps (__m128 __A, const int __imm)
   return (__m128) __builtin_ia32_rndscaleps_128_mask ((__v4sf) __A,
             __imm,
             (__v4sf)
-            _mm_setzero_ps (),
+            _mm_avx512_setzero_ps (),
             (__mmask8) -1);
 }
 extern __inline __m128
@@ -9720,7 +9593,7 @@ _mm_maskz_roundscale_ps (__mmask8 __U, __m128 __A, const int __imm)
   return (__m128) __builtin_ia32_rndscaleps_128_mask ((__v4sf) __A,
             __imm,
             (__v4sf)
-            _mm_setzero_ps (),
+            _mm_avx512_setzero_ps (),
             (__mmask8) __U);
 }
 extern __inline __m128d
@@ -9730,7 +9603,7 @@ _mm_roundscale_pd (__m128d __A, const int __imm)
   return (__m128d) __builtin_ia32_rndscalepd_128_mask ((__v2df) __A,
              __imm,
              (__v2df)
-             _mm_setzero_pd (),
+             _mm_avx512_setzero_pd (),
              (__mmask8) -1);
 }
 extern __inline __m128d
@@ -9750,7 +9623,7 @@ _mm_maskz_roundscale_pd (__mmask8 __U, __m128d __A, const int __imm)
   return (__m128d) __builtin_ia32_rndscalepd_128_mask ((__v2df) __A,
              __imm,
              (__v2df)
-             _mm_setzero_pd (),
+             _mm_avx512_setzero_pd (),
              (__mmask8) __U);
 }
 extern __inline __m256
@@ -9761,7 +9634,7 @@ _mm256_getmant_ps (__m256 __A, _MM_MANTISSA_NORM_ENUM __B,
   return (__m256) __builtin_ia32_getmantps256_mask ((__v8sf) __A,
           (__C << 2) | __B,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) -1);
 }
 extern __inline __m256
@@ -9784,7 +9657,7 @@ _mm256_maskz_getmant_ps (__mmask8 __U, __m256 __A,
   return (__m256) __builtin_ia32_getmantps256_mask ((__v8sf) __A,
           (__C << 2) | __B,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -9795,7 +9668,7 @@ _mm_getmant_ps (__m128 __A, _MM_MANTISSA_NORM_ENUM __B,
   return (__m128) __builtin_ia32_getmantps128_mask ((__v4sf) __A,
           (__C << 2) | __B,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) -1);
 }
 extern __inline __m128
@@ -9818,7 +9691,7 @@ _mm_maskz_getmant_ps (__mmask8 __U, __m128 __A,
   return (__m128) __builtin_ia32_getmantps128_mask ((__v4sf) __A,
           (__C << 2) | __B,
           (__v4sf)
-          _mm_setzero_ps (),
+          _mm_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m256d
@@ -9829,7 +9702,7 @@ _mm256_getmant_pd (__m256d __A, _MM_MANTISSA_NORM_ENUM __B,
   return (__m256d) __builtin_ia32_getmantpd256_mask ((__v4df) __A,
            (__C << 2) | __B,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m256d
@@ -9852,7 +9725,7 @@ _mm256_maskz_getmant_pd (__mmask8 __U, __m256d __A,
   return (__m256d) __builtin_ia32_getmantpd256_mask ((__v4df) __A,
            (__C << 2) | __B,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m128d
@@ -9863,7 +9736,7 @@ _mm_getmant_pd (__m128d __A, _MM_MANTISSA_NORM_ENUM __B,
   return (__m128d) __builtin_ia32_getmantpd128_mask ((__v2df) __A,
            (__C << 2) | __B,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) -1);
 }
 extern __inline __m128d
@@ -9886,7 +9759,7 @@ _mm_maskz_getmant_pd (__mmask8 __U, __m128d __A,
   return (__m128d) __builtin_ia32_getmantpd128_mask ((__v2df) __A,
            (__C << 2) | __B,
            (__v2df)
-           _mm_setzero_pd (),
+           _mm_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m256
@@ -10369,7 +10242,7 @@ _mm256_maskz_shuffle_epi32 (__mmask8 __U, __m256i __A,
 {
   return (__m256i) __builtin_ia32_pshufd256_mask ((__v8si) __A, __mask,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -10388,7 +10261,7 @@ _mm_maskz_shuffle_epi32 (__mmask8 __U, __m128i __A,
 {
   return (__m128i) __builtin_ia32_pshufd128_mask ((__v4si) __A, __mask,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -10397,7 +10270,7 @@ _mm256_rol_epi32 (__m256i __A, const int __B)
 {
   return (__m256i) __builtin_ia32_prold256_mask ((__v8si) __A, __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) -1);
 }
 extern __inline __m256i
@@ -10415,7 +10288,7 @@ _mm256_maskz_rol_epi32 (__mmask8 __U, __m256i __A, const int __B)
 {
   return (__m256i) __builtin_ia32_prold256_mask ((__v8si) __A, __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -10424,7 +10297,7 @@ _mm_rol_epi32 (__m128i __A, const int __B)
 {
   return (__m128i) __builtin_ia32_prold128_mask ((__v4si) __A, __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) -1);
 }
 extern __inline __m128i
@@ -10442,7 +10315,7 @@ _mm_maskz_rol_epi32 (__mmask8 __U, __m128i __A, const int __B)
 {
   return (__m128i) __builtin_ia32_prold128_mask ((__v4si) __A, __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -10451,7 +10324,7 @@ _mm256_ror_epi32 (__m256i __A, const int __B)
 {
   return (__m256i) __builtin_ia32_prord256_mask ((__v8si) __A, __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) -1);
 }
 extern __inline __m256i
@@ -10469,7 +10342,7 @@ _mm256_maskz_ror_epi32 (__mmask8 __U, __m256i __A, const int __B)
 {
   return (__m256i) __builtin_ia32_prord256_mask ((__v8si) __A, __B,
        (__v8si)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -10478,7 +10351,7 @@ _mm_ror_epi32 (__m128i __A, const int __B)
 {
   return (__m128i) __builtin_ia32_prord128_mask ((__v4si) __A, __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) -1);
 }
 extern __inline __m128i
@@ -10496,7 +10369,7 @@ _mm_maskz_ror_epi32 (__mmask8 __U, __m128i __A, const int __B)
 {
   return (__m128i) __builtin_ia32_prord128_mask ((__v4si) __A, __B,
        (__v4si)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -10505,7 +10378,7 @@ _mm256_rol_epi64 (__m256i __A, const int __B)
 {
   return (__m256i) __builtin_ia32_prolq256_mask ((__v4di) __A, __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) -1);
 }
 extern __inline __m256i
@@ -10523,7 +10396,7 @@ _mm256_maskz_rol_epi64 (__mmask8 __U, __m256i __A, const int __B)
 {
   return (__m256i) __builtin_ia32_prolq256_mask ((__v4di) __A, __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -10532,7 +10405,7 @@ _mm_rol_epi64 (__m128i __A, const int __B)
 {
   return (__m128i) __builtin_ia32_prolq128_mask ((__v2di) __A, __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) -1);
 }
 extern __inline __m128i
@@ -10550,7 +10423,7 @@ _mm_maskz_rol_epi64 (__mmask8 __U, __m128i __A, const int __B)
 {
   return (__m128i) __builtin_ia32_prolq128_mask ((__v2di) __A, __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -10559,7 +10432,7 @@ _mm256_ror_epi64 (__m256i __A, const int __B)
 {
   return (__m256i) __builtin_ia32_prorq256_mask ((__v4di) __A, __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) -1);
 }
 extern __inline __m256i
@@ -10577,7 +10450,7 @@ _mm256_maskz_ror_epi64 (__mmask8 __U, __m256i __A, const int __B)
 {
   return (__m256i) __builtin_ia32_prorq256_mask ((__v4di) __A, __B,
        (__v4di)
-       _mm256_setzero_si256 (),
+       _mm256_avx512_setzero_si256 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -10586,7 +10459,7 @@ _mm_ror_epi64 (__m128i __A, const int __B)
 {
   return (__m128i) __builtin_ia32_prorq128_mask ((__v2di) __A, __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) -1);
 }
 extern __inline __m128i
@@ -10604,7 +10477,7 @@ _mm_maskz_ror_epi64 (__mmask8 __U, __m128i __A, const int __B)
 {
   return (__m128i) __builtin_ia32_prorq128_mask ((__v2di) __A, __B,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m128i
@@ -10614,7 +10487,7 @@ _mm_alignr_epi32 (__m128i __A, __m128i __B, const int __imm)
   return (__m128i) __builtin_ia32_alignd128_mask ((__v4si) __A,
         (__v4si) __B, __imm,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -10635,7 +10508,7 @@ _mm_maskz_alignr_epi32 (__mmask8 __U, __m128i __A, __m128i __B,
   return (__m128i) __builtin_ia32_alignd128_mask ((__v4si) __A,
         (__v4si) __B, __imm,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -10645,7 +10518,7 @@ _mm_alignr_epi64 (__m128i __A, __m128i __B, const int __imm)
   return (__m128i) __builtin_ia32_alignq128_mask ((__v2di) __A,
         (__v2di) __B, __imm,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
@@ -10666,7 +10539,7 @@ _mm_maskz_alignr_epi64 (__mmask8 __U, __m128i __A, __m128i __B,
   return (__m128i) __builtin_ia32_alignq128_mask ((__v2di) __A,
         (__v2di) __B, __imm,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -10676,7 +10549,7 @@ _mm256_alignr_epi32 (__m256i __A, __m256i __B, const int __imm)
   return (__m256i) __builtin_ia32_alignd256_mask ((__v8si) __A,
         (__v8si) __B, __imm,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -10697,7 +10570,7 @@ _mm256_maskz_alignr_epi32 (__mmask8 __U, __m256i __A, __m256i __B,
   return (__m256i) __builtin_ia32_alignd256_mask ((__v8si) __A,
         (__v8si) __B, __imm,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
@@ -10707,7 +10580,7 @@ _mm256_alignr_epi64 (__m256i __A, __m256i __B, const int __imm)
   return (__m256i) __builtin_ia32_alignq256_mask ((__v4di) __A,
         (__v4di) __B, __imm,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
@@ -10728,7 +10601,7 @@ _mm256_maskz_alignr_epi64 (__mmask8 __U, __m256i __A, __m256i __B,
   return (__m256i) __builtin_ia32_alignq256_mask ((__v4di) __A,
         (__v4di) __B, __imm,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -10746,7 +10619,7 @@ _mm_maskz_cvtps_ph (__mmask8 __U, __m128 __A, const int __I)
 {
   return (__m128i) __builtin_ia32_vcvtps2ph_mask ((__v4sf) __A, __I,
         (__v8hi)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
@@ -10764,13 +10637,13 @@ _mm256_maskz_cvtps_ph (__mmask8 __U, __m256 __A, const int __I)
 {
   return (__m128i) __builtin_ia32_vcvtps2ph256_mask ((__v8sf) __A, __I,
            (__v8hi)
-           _mm_setzero_si128 (),
+           _mm_avx512_setzero_si128 (),
            (__mmask8) __U);
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_srai_epi32 (__m256i __W, __mmask8 __U, __m256i __A,
-   const int __imm)
+   const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psradi256_mask ((__v8si) __A, __imm,
         (__v8si) __W,
@@ -10778,17 +10651,17 @@ _mm256_mask_srai_epi32 (__m256i __W, __mmask8 __U, __m256i __A,
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_srai_epi32 (__mmask8 __U, __m256i __A, const int __imm)
+_mm256_maskz_srai_epi32 (__mmask8 __U, __m256i __A, const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psradi256_mask ((__v8si) __A, __imm,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_mask_srai_epi32 (__m128i __W, __mmask8 __U, __m128i __A,
-       const int __imm)
+       const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psradi128_mask ((__v4si) __A, __imm,
         (__v4si) __W,
@@ -10796,26 +10669,26 @@ _mm_mask_srai_epi32 (__m128i __W, __mmask8 __U, __m128i __A,
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_srai_epi32 (__mmask8 __U, __m128i __A, const int __imm)
+_mm_maskz_srai_epi32 (__mmask8 __U, __m128i __A, const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psradi128_mask ((__v4si) __A, __imm,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_srai_epi64 (__m256i __A, const int __imm)
+_mm256_srai_epi64 (__m256i __A, const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psraqi256_mask ((__v4di) __A, __imm,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) -1);
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_srai_epi64 (__m256i __W, __mmask8 __U, __m256i __A,
-   const int __imm)
+   const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psraqi256_mask ((__v4di) __A, __imm,
         (__v4di) __W,
@@ -10823,26 +10696,26 @@ _mm256_mask_srai_epi64 (__m256i __W, __mmask8 __U, __m256i __A,
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_srai_epi64 (__mmask8 __U, __m256i __A, const int __imm)
+_mm256_maskz_srai_epi64 (__mmask8 __U, __m256i __A, const unsigned int __imm)
 {
   return (__m256i) __builtin_ia32_psraqi256_mask ((__v4di) __A, __imm,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_srai_epi64 (__m128i __A, const int __imm)
+_mm_srai_epi64 (__m128i __A, const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psraqi128_mask ((__v2di) __A, __imm,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) -1);
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm_mask_srai_epi64 (__m128i __W, __mmask8 __U, __m128i __A,
-       const int __imm)
+       const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psraqi128_mask ((__v2di) __A, __imm,
         (__v2di) __W,
@@ -10850,16 +10723,16 @@ _mm_mask_srai_epi64 (__m128i __W, __mmask8 __U, __m128i __A,
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_srai_epi64 (__mmask8 __U, __m128i __A, const int __imm)
+_mm_maskz_srai_epi64 (__mmask8 __U, __m128i __A, const unsigned int __imm)
 {
   return (__m128i) __builtin_ia32_psraqi128_mask ((__v2di) __A, __imm,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_slli_epi32 (__m128i __W, __mmask8 __U, __m128i __A, int __B)
+_mm_mask_slli_epi32 (__m128i __W, __mmask8 __U, __m128i __A, unsigned int __B)
 {
   return (__m128i) __builtin_ia32_pslldi128_mask ((__v4si) __A, __B,
         (__v4si) __W,
@@ -10867,16 +10740,16 @@ _mm_mask_slli_epi32 (__m128i __W, __mmask8 __U, __m128i __A, int __B)
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_slli_epi32 (__mmask8 __U, __m128i __A, int __B)
+_mm_maskz_slli_epi32 (__mmask8 __U, __m128i __A, unsigned int __B)
 {
   return (__m128i) __builtin_ia32_pslldi128_mask ((__v4si) __A, __B,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_slli_epi64 (__m128i __W, __mmask8 __U, __m128i __A, int __B)
+_mm_mask_slli_epi64 (__m128i __W, __mmask8 __U, __m128i __A, unsigned int __B)
 {
   return (__m128i) __builtin_ia32_psllqi128_mask ((__v2di) __A, __B,
         (__v2di) __W,
@@ -10884,17 +10757,17 @@ _mm_mask_slli_epi64 (__m128i __W, __mmask8 __U, __m128i __A, int __B)
 }
 extern __inline __m128i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_maskz_slli_epi64 (__mmask8 __U, __m128i __A, int __B)
+_mm_maskz_slli_epi64 (__mmask8 __U, __m128i __A, unsigned int __B)
 {
   return (__m128i) __builtin_ia32_psllqi128_mask ((__v2di) __A, __B,
         (__v2di)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_slli_epi32 (__m256i __W, __mmask8 __U, __m256i __A,
-   int __B)
+   unsigned int __B)
 {
   return (__m256i) __builtin_ia32_pslldi256_mask ((__v8si) __A, __B,
         (__v8si) __W,
@@ -10902,17 +10775,17 @@ _mm256_mask_slli_epi32 (__m256i __W, __mmask8 __U, __m256i __A,
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_slli_epi32 (__mmask8 __U, __m256i __A, int __B)
+_mm256_maskz_slli_epi32 (__mmask8 __U, __m256i __A, unsigned int __B)
 {
   return (__m256i) __builtin_ia32_pslldi256_mask ((__v8si) __A, __B,
         (__v8si)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_mask_slli_epi64 (__m256i __W, __mmask8 __U, __m256i __A,
-   int __B)
+   unsigned int __B)
 {
   return (__m256i) __builtin_ia32_psllqi256_mask ((__v4di) __A, __B,
         (__v4di) __W,
@@ -10920,11 +10793,11 @@ _mm256_mask_slli_epi64 (__m256i __W, __mmask8 __U, __m256i __A,
 }
 extern __inline __m256i
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_maskz_slli_epi64 (__mmask8 __U, __m256i __A, int __B)
+_mm256_maskz_slli_epi64 (__mmask8 __U, __m256i __A, unsigned int __B)
 {
   return (__m256i) __builtin_ia32_psllqi256_mask ((__v4di) __A, __B,
         (__v4di)
-        _mm256_setzero_si256 (),
+        _mm256_avx512_setzero_si256 (),
         (__mmask8) __U);
 }
 extern __inline __m256d
@@ -10942,7 +10815,7 @@ _mm256_maskz_permutex_pd (__mmask8 __U, __m256d __X, const int __imm)
 {
   return (__m256d) __builtin_ia32_permdf256_mask ((__v4df) __X, __imm,
         (__v4df)
-        _mm256_setzero_pd (),
+        _mm256_avx512_setzero_pd (),
         (__mmask8) __U);
 }
 extern __inline __m256d
@@ -10960,7 +10833,7 @@ _mm256_maskz_permute_pd (__mmask8 __U, __m256d __X, const int __C)
 {
   return (__m256d) __builtin_ia32_vpermilpd256_mask ((__v4df) __X, __C,
            (__v4df)
-           _mm256_setzero_pd (),
+           _mm256_avx512_setzero_pd (),
            (__mmask8) __U);
 }
 extern __inline __m128d
@@ -10978,7 +10851,7 @@ _mm_maskz_permute_pd (__mmask8 __U, __m128d __X, const int __C)
 {
   return (__m128d) __builtin_ia32_vpermilpd_mask ((__v2df) __X, __C,
         (__v2df)
-        _mm_setzero_pd (),
+        _mm_avx512_setzero_pd (),
         (__mmask8) __U);
 }
 extern __inline __m256
@@ -10996,7 +10869,7 @@ _mm256_maskz_permute_ps (__mmask8 __U, __m256 __X, const int __C)
 {
   return (__m256) __builtin_ia32_vpermilps256_mask ((__v8sf) __X, __C,
           (__v8sf)
-          _mm256_setzero_ps (),
+          _mm256_avx512_setzero_ps (),
           (__mmask8) __U);
 }
 extern __inline __m128
@@ -11014,73 +10887,9 @@ _mm_maskz_permute_ps (__mmask8 __U, __m128 __X, const int __C)
 {
   return (__m128) __builtin_ia32_vpermilps_mask ((__v4sf) __X, __C,
        (__v4sf)
-       _mm_setzero_ps (),
+       _mm_avx512_setzero_ps (),
        (__mmask8) __U);
 }
-extern __inline __m256d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_blend_pd (__mmask8 __U, __m256d __A, __m256d __W)
-{
-  return (__m256d) __builtin_ia32_blendmpd_256_mask ((__v4df) __A,
-           (__v4df) __W,
-           (__mmask8) __U);
-}
-extern __inline __m256
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_blend_ps (__mmask8 __U, __m256 __A, __m256 __W)
-{
-  return (__m256) __builtin_ia32_blendmps_256_mask ((__v8sf) __A,
-          (__v8sf) __W,
-          (__mmask8) __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_blend_epi64 (__mmask8 __U, __m256i __A, __m256i __W)
-{
-  return (__m256i) __builtin_ia32_blendmq_256_mask ((__v4di) __A,
-          (__v4di) __W,
-          (__mmask8) __U);
-}
-extern __inline __m256i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm256_mask_blend_epi32 (__mmask8 __U, __m256i __A, __m256i __W)
-{
-  return (__m256i) __builtin_ia32_blendmd_256_mask ((__v8si) __A,
-          (__v8si) __W,
-          (__mmask8) __U);
-}
-extern __inline __m128d
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_blend_pd (__mmask8 __U, __m128d __A, __m128d __W)
-{
-  return (__m128d) __builtin_ia32_blendmpd_128_mask ((__v2df) __A,
-           (__v2df) __W,
-           (__mmask8) __U);
-}
-extern __inline __m128
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_blend_ps (__mmask8 __U, __m128 __A, __m128 __W)
-{
-  return (__m128) __builtin_ia32_blendmps_128_mask ((__v4sf) __A,
-          (__v4sf) __W,
-          (__mmask8) __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_blend_epi64 (__mmask8 __U, __m128i __A, __m128i __W)
-{
-  return (__m128i) __builtin_ia32_blendmq_128_mask ((__v2di) __A,
-          (__v2di) __W,
-          (__mmask8) __U);
-}
-extern __inline __m128i
-__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
-_mm_mask_blend_epi32 (__mmask8 __U, __m128i __A, __m128i __W)
-{
-  return (__m128i) __builtin_ia32_blendmd_128_mask ((__v4si) __A,
-          (__v4si) __W,
-          (__mmask8) __U);
-}
 extern __inline __mmask8
 __attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_cmp_epi64_mask (__m256i __X, __m256i __Y, const int __P)
@@ -11291,46 +11100,46 @@ _mm256_permutex_pd (__m256d __X, const int __M)
 {
   return (__m256d) __builtin_ia32_permdf256_mask ((__v4df) __X, __M,
         (__v4df)
-        _mm256_undefined_pd (),
+        _mm256_avx512_undefined_pd (),
         (__mmask8) -1);
 }
 #else
-#define _mm256_permutex_pd(X, M) ((__m256d) __builtin_ia32_permdf256_mask ((__v4df)(__m256d)(X), (int)(M), (__v4df)(__m256d) _mm256_undefined_pd (), (__mmask8)-1))
-#define _mm256_permutex_epi64(X, I) ((__m256i) __builtin_ia32_permdi256_mask ((__v4di)(__m256i)(X), (int)(I), (__v4di)(__m256i) (_mm256_setzero_si256 ()), (__mmask8) -1))
-#define _mm256_maskz_permutex_epi64(M, X, I) ((__m256i) __builtin_ia32_permdi256_mask ((__v4di)(__m256i)(X), (int)(I), (__v4di)(__m256i) (_mm256_setzero_si256 ()), (__mmask8)(M)))
+#define _mm256_permutex_pd(X, M) ((__m256d) __builtin_ia32_permdf256_mask ((__v4df)(__m256d)(X), (int)(M), (__v4df)(__m256d) _mm256_avx512_undefined_pd (), (__mmask8)-1))
+#define _mm256_permutex_epi64(X, I) ((__m256i) __builtin_ia32_permdi256_mask ((__v4di)(__m256i)(X), (int)(I), (__v4di)(__m256i) (_mm256_avx512_setzero_si256 ()), (__mmask8) -1))
+#define _mm256_maskz_permutex_epi64(M, X, I) ((__m256i) __builtin_ia32_permdi256_mask ((__v4di)(__m256i)(X), (int)(I), (__v4di)(__m256i) (_mm256_avx512_setzero_si256 ()), (__mmask8)(M)))
 #define _mm256_mask_permutex_epi64(W, M, X, I) ((__m256i) __builtin_ia32_permdi256_mask ((__v4di)(__m256i)(X), (int)(I), (__v4di)(__m256i)(W), (__mmask8)(M)))
-#define _mm256_insertf32x4(X, Y, C) ((__m256) __builtin_ia32_insertf32x4_256_mask ((__v8sf)(__m256) (X), (__v4sf)(__m128) (Y), (int) (C), (__v8sf)(__m256)_mm256_setzero_ps (), (__mmask8)-1))
+#define _mm256_insertf32x4(X, Y, C) ((__m256) __builtin_ia32_insertf32x4_256_mask ((__v8sf)(__m256) (X), (__v4sf)(__m128) (Y), (int) (C), (__v8sf)(__m256)_mm256_avx512_setzero_ps (), (__mmask8)-1))
 #define _mm256_mask_insertf32x4(W, U, X, Y, C) ((__m256) __builtin_ia32_insertf32x4_256_mask ((__v8sf)(__m256) (X), (__v4sf)(__m128) (Y), (int) (C), (__v8sf)(__m256)(W), (__mmask8)(U)))
-#define _mm256_maskz_insertf32x4(U, X, Y, C) ((__m256) __builtin_ia32_insertf32x4_256_mask ((__v8sf)(__m256) (X), (__v4sf)(__m128) (Y), (int) (C), (__v8sf)(__m256)_mm256_setzero_ps (), (__mmask8)(U)))
-#define _mm256_inserti32x4(X, Y, C) ((__m256i) __builtin_ia32_inserti32x4_256_mask ((__v8si)(__m256i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v8si)(__m256i)_mm256_setzero_si256 (), (__mmask8)-1))
+#define _mm256_maskz_insertf32x4(U, X, Y, C) ((__m256) __builtin_ia32_insertf32x4_256_mask ((__v8sf)(__m256) (X), (__v4sf)(__m128) (Y), (int) (C), (__v8sf)(__m256)_mm256_avx512_setzero_ps (), (__mmask8)(U)))
+#define _mm256_inserti32x4(X, Y, C) ((__m256i) __builtin_ia32_inserti32x4_256_mask ((__v8si)(__m256i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v8si)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)-1))
 #define _mm256_mask_inserti32x4(W, U, X, Y, C) ((__m256i) __builtin_ia32_inserti32x4_256_mask ((__v8si)(__m256i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v8si)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_inserti32x4(U, X, Y, C) ((__m256i) __builtin_ia32_inserti32x4_256_mask ((__v8si)(__m256i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v8si)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm256_extractf32x4_ps(X, C) ((__m128) __builtin_ia32_extractf32x4_256_mask ((__v8sf)(__m256) (X), (int) (C), (__v4sf)(__m128)_mm_setzero_ps (), (__mmask8)-1))
+#define _mm256_maskz_inserti32x4(U, X, Y, C) ((__m256i) __builtin_ia32_inserti32x4_256_mask ((__v8si)(__m256i) (X), (__v4si)(__m128i) (Y), (int) (C), (__v8si)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm256_extractf32x4_ps(X, C) ((__m128) __builtin_ia32_extractf32x4_256_mask ((__v8sf)(__m256) (X), (int) (C), (__v4sf)(__m128)_mm_avx512_setzero_ps (), (__mmask8)-1))
 #define _mm256_mask_extractf32x4_ps(W, U, X, C) ((__m128) __builtin_ia32_extractf32x4_256_mask ((__v8sf)(__m256) (X), (int) (C), (__v4sf)(__m128)(W), (__mmask8)(U)))
-#define _mm256_maskz_extractf32x4_ps(U, X, C) ((__m128) __builtin_ia32_extractf32x4_256_mask ((__v8sf)(__m256) (X), (int) (C), (__v4sf)(__m128)_mm_setzero_ps (), (__mmask8)(U)))
-#define _mm256_extracti32x4_epi32(X, C) ((__m128i) __builtin_ia32_extracti32x4_256_mask ((__v8si)(__m256i) (X), (int) (C), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)-1))
+#define _mm256_maskz_extractf32x4_ps(U, X, C) ((__m128) __builtin_ia32_extractf32x4_256_mask ((__v8sf)(__m256) (X), (int) (C), (__v4sf)(__m128)_mm_avx512_setzero_ps (), (__mmask8)(U)))
+#define _mm256_extracti32x4_epi32(X, C) ((__m128i) __builtin_ia32_extracti32x4_256_mask ((__v8si)(__m256i) (X), (int) (C), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)-1))
 #define _mm256_mask_extracti32x4_epi32(W, U, X, C) ((__m128i) __builtin_ia32_extracti32x4_256_mask ((__v8si)(__m256i) (X), (int) (C), (__v4si)(__m128i)(W), (__mmask8)(U)))
-#define _mm256_maskz_extracti32x4_epi32(U, X, C) ((__m128i) __builtin_ia32_extracti32x4_256_mask ((__v8si)(__m256i) (X), (int) (C), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm256_shuffle_i64x2(X, Y, C) ((__m256i) __builtin_ia32_shuf_i64x2_256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(C), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)-1))
+#define _mm256_maskz_extracti32x4_epi32(U, X, C) ((__m128i) __builtin_ia32_extracti32x4_256_mask ((__v8si)(__m256i) (X), (int) (C), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_shuffle_i64x2(X, Y, C) ((__m256i) __builtin_ia32_shuf_i64x2_256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(C), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)-1))
 #define _mm256_mask_shuffle_i64x2(W, U, X, Y, C) ((__m256i) __builtin_ia32_shuf_i64x2_256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(C), (__v4di)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_shuffle_i64x2(U, X, Y, C) ((__m256i) __builtin_ia32_shuf_i64x2_256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(C), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm256_shuffle_i32x4(X, Y, C) ((__m256i) __builtin_ia32_shuf_i32x4_256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C), (__v8si)(__m256i) _mm256_setzero_si256 (), (__mmask8)-1))
+#define _mm256_maskz_shuffle_i64x2(U, X, Y, C) ((__m256i) __builtin_ia32_shuf_i64x2_256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(C), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm256_shuffle_i32x4(X, Y, C) ((__m256i) __builtin_ia32_shuf_i32x4_256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C), (__v8si)(__m256i) _mm256_avx512_setzero_si256 (), (__mmask8)-1))
 #define _mm256_mask_shuffle_i32x4(W, U, X, Y, C) ((__m256i) __builtin_ia32_shuf_i32x4_256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C), (__v8si)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_shuffle_i32x4(U, X, Y, C) ((__m256i) __builtin_ia32_shuf_i32x4_256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C), (__v8si)(__m256i) _mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm256_shuffle_f64x2(X, Y, C) ((__m256d) __builtin_ia32_shuf_f64x2_256_mask ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(C), (__v4df)(__m256d)_mm256_setzero_pd (), (__mmask8)-1))
+#define _mm256_maskz_shuffle_i32x4(U, X, Y, C) ((__m256i) __builtin_ia32_shuf_i32x4_256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C), (__v8si)(__m256i) _mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm256_shuffle_f64x2(X, Y, C) ((__m256d) __builtin_ia32_shuf_f64x2_256_mask ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(C), (__v4df)(__m256d)_mm256_avx512_setzero_pd (), (__mmask8)-1))
 #define _mm256_mask_shuffle_f64x2(W, U, X, Y, C) ((__m256d) __builtin_ia32_shuf_f64x2_256_mask ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(C), (__v4df)(__m256d)(W), (__mmask8)(U)))
-#define _mm256_maskz_shuffle_f64x2(U, X, Y, C) ((__m256d) __builtin_ia32_shuf_f64x2_256_mask ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(C), (__v4df)(__m256d)_mm256_setzero_pd( ), (__mmask8)(U)))
-#define _mm256_shuffle_f32x4(X, Y, C) ((__m256) __builtin_ia32_shuf_f32x4_256_mask ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(C), (__v8sf)(__m256)_mm256_setzero_ps (), (__mmask8)-1))
+#define _mm256_maskz_shuffle_f64x2(U, X, Y, C) ((__m256d) __builtin_ia32_shuf_f64x2_256_mask ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (int)(C), (__v4df)(__m256d)_mm256_avx512_setzero_pd( ), (__mmask8)(U)))
+#define _mm256_shuffle_f32x4(X, Y, C) ((__m256) __builtin_ia32_shuf_f32x4_256_mask ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(C), (__v8sf)(__m256)_mm256_avx512_setzero_ps (), (__mmask8)-1))
 #define _mm256_mask_shuffle_f32x4(W, U, X, Y, C) ((__m256) __builtin_ia32_shuf_f32x4_256_mask ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(C), (__v8sf)(__m256)(W), (__mmask8)(U)))
-#define _mm256_maskz_shuffle_f32x4(U, X, Y, C) ((__m256) __builtin_ia32_shuf_f32x4_256_mask ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(C), (__v8sf)(__m256)_mm256_setzero_ps (), (__mmask8)(U)))
+#define _mm256_maskz_shuffle_f32x4(U, X, Y, C) ((__m256) __builtin_ia32_shuf_f32x4_256_mask ((__v8sf)(__m256)(X), (__v8sf)(__m256)(Y), (int)(C), (__v8sf)(__m256)_mm256_avx512_setzero_ps (), (__mmask8)(U)))
 #define _mm256_mask_shuffle_pd(W, U, A, B, C) ((__m256d)__builtin_ia32_shufpd256_mask ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(C), (__v4df)(__m256d)(W), (__mmask8)(U)))
-#define _mm256_maskz_shuffle_pd(U, A, B, C) ((__m256d)__builtin_ia32_shufpd256_mask ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(C), (__v4df)(__m256d) _mm256_setzero_pd (), (__mmask8)(U)))
+#define _mm256_maskz_shuffle_pd(U, A, B, C) ((__m256d)__builtin_ia32_shufpd256_mask ((__v4df)(__m256d)(A), (__v4df)(__m256d)(B), (int)(C), (__v4df)(__m256d) _mm256_avx512_setzero_pd (), (__mmask8)(U)))
 #define _mm_mask_shuffle_pd(W, U, A, B, C) ((__m128d)__builtin_ia32_shufpd128_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U)))
-#define _mm_maskz_shuffle_pd(U, A, B, C) ((__m128d)__builtin_ia32_shufpd128_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)_mm_setzero_pd (), (__mmask8)(U)))
+#define _mm_maskz_shuffle_pd(U, A, B, C) ((__m128d)__builtin_ia32_shufpd128_mask ((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), (int)(C), (__v2df)(__m128d)_mm_avx512_setzero_pd (), (__mmask8)(U)))
 #define _mm256_mask_shuffle_ps(W, U, A, B, C) ((__m256) __builtin_ia32_shufps256_mask ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(C), (__v8sf)(__m256)(W), (__mmask8)(U)))
-#define _mm256_maskz_shuffle_ps(U, A, B, C) ((__m256) __builtin_ia32_shufps256_mask ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(C), (__v8sf)(__m256)_mm256_setzero_ps (), (__mmask8)(U)))
+#define _mm256_maskz_shuffle_ps(U, A, B, C) ((__m256) __builtin_ia32_shufps256_mask ((__v8sf)(__m256)(A), (__v8sf)(__m256)(B), (int)(C), (__v8sf)(__m256)_mm256_avx512_setzero_ps (), (__mmask8)(U)))
 #define _mm_mask_shuffle_ps(W, U, A, B, C) ((__m128) __builtin_ia32_shufps128_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U)))
-#define _mm_maskz_shuffle_ps(U, A, B, C) ((__m128) __builtin_ia32_shufps128_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)_mm_setzero_ps (), (__mmask8)(U)))
+#define _mm_maskz_shuffle_ps(U, A, B, C) ((__m128) __builtin_ia32_shufps128_mask ((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), (int)(C), (__v4sf)(__m128)_mm_avx512_setzero_ps (), (__mmask8)(U)))
 #define _mm256_fixupimm_pd(X, Y, Z, C) ((__m256d)__builtin_ia32_fixupimmpd256_mask ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (__v4di)(__m256i)(Z), (int)(C), (__mmask8)(-1)))
 #define _mm256_mask_fixupimm_pd(X, U, Y, Z, C) ((__m256d)__builtin_ia32_fixupimmpd256_mask ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (__v4di)(__m256i)(Z), (int)(C), (__mmask8)(U)))
 #define _mm256_maskz_fixupimm_pd(U, X, Y, Z, C) ((__m256d)__builtin_ia32_fixupimmpd256_maskz ((__v4df)(__m256d)(X), (__v4df)(__m256d)(Y), (__v4di)(__m256i)(Z), (int)(C), (__mmask8)(U)))
@@ -11343,22 +11152,22 @@ _mm256_permutex_pd (__m256d __X, const int __M)
 #define _mm_fixupimm_ps(X, Y, Z, C) ((__m128)__builtin_ia32_fixupimmps128_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(-1)))
 #define _mm_mask_fixupimm_ps(X, U, Y, Z, C) ((__m128)__builtin_ia32_fixupimmps128_mask ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U)))
 #define _mm_maskz_fixupimm_ps(U, X, Y, Z, C) ((__m128)__builtin_ia32_fixupimmps128_maskz ((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (__v4si)(__m128i)(Z), (int)(C), (__mmask8)(U)))
-#define _mm256_mask_srli_epi32(W, U, A, B) ((__m256i) __builtin_ia32_psrldi256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_srli_epi32(U, A, B) ((__m256i) __builtin_ia32_psrldi256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm_mask_srli_epi32(W, U, A, B) ((__m128i) __builtin_ia32_psrldi128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_srli_epi32(U, A, B) ((__m128i) __builtin_ia32_psrldi128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm256_mask_srli_epi64(W, U, A, B) ((__m256i) __builtin_ia32_psrlqi256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_srli_epi64(U, A, B) ((__m256i) __builtin_ia32_psrlqi256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm_mask_srli_epi64(W, U, A, B) ((__m128i) __builtin_ia32_psrlqi128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_srli_epi64(U, A, B) ((__m128i) __builtin_ia32_psrlqi128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm256_mask_slli_epi32(W, U, X, C) ((__m256i)__builtin_ia32_pslldi256_mask ((__v8si)(__m256i)(X), (int)(C), (__v8si)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_slli_epi32(U, X, C) ((__m256i)__builtin_ia32_pslldi256_mask ((__v8si)(__m256i)(X), (int)(C), (__v8si)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm256_mask_slli_epi64(W, U, X, C) ((__m256i)__builtin_ia32_psllqi256_mask ((__v4di)(__m256i)(X), (int)(C), (__v4di)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_slli_epi64(U, X, C) ((__m256i)__builtin_ia32_psllqi256_mask ((__v4di)(__m256i)(X), (int)(C), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm_mask_slli_epi32(W, U, X, C) ((__m128i)__builtin_ia32_pslldi128_mask ((__v4si)(__m128i)(X), (int)(C), (__v4si)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_slli_epi32(U, X, C) ((__m128i)__builtin_ia32_pslldi128_mask ((__v4si)(__m128i)(X), (int)(C), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm_mask_slli_epi64(W, U, X, C) ((__m128i)__builtin_ia32_psllqi128_mask ((__v2di)(__m128i)(X), (int)(C), (__v2di)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_slli_epi64(U, X, C) ((__m128i)__builtin_ia32_psllqi128_mask ((__v2di)(__m128i)(X), (int)(C), (__v2di)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_mask_srli_epi32(W, U, A, B) ((__m256i) __builtin_ia32_psrldi256_mask ((__v8si)(__m256i)(A), (unsigned int)(B), (__v8si)(__m256i)(W), (__mmask8)(U)))
+#define _mm256_maskz_srli_epi32(U, A, B) ((__m256i) __builtin_ia32_psrldi256_mask ((__v8si)(__m256i)(A), (unsigned int)(B), (__v8si)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm_mask_srli_epi32(W, U, A, B) ((__m128i) __builtin_ia32_psrldi128_mask ((__v4si)(__m128i)(A), (unsigned int)(B), (__v4si)(__m128i)(W), (__mmask8)(U)))
+#define _mm_maskz_srli_epi32(U, A, B) ((__m128i) __builtin_ia32_psrldi128_mask ((__v4si)(__m128i)(A), (unsigned int)(B), (__v4si)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_mask_srli_epi64(W, U, A, B) ((__m256i) __builtin_ia32_psrlqi256_mask ((__v4di)(__m256i)(A), (unsigned int)(B), (__v4di)(__m256i)(W), (__mmask8)(U)))
+#define _mm256_maskz_srli_epi64(U, A, B) ((__m256i) __builtin_ia32_psrlqi256_mask ((__v4di)(__m256i)(A), (unsigned int)(B), (__v4di)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm_mask_srli_epi64(W, U, A, B) ((__m128i) __builtin_ia32_psrlqi128_mask ((__v2di)(__m128i)(A), (unsigned int)(B), (__v2di)(__m128i)(W), (__mmask8)(U)))
+#define _mm_maskz_srli_epi64(U, A, B) ((__m128i) __builtin_ia32_psrlqi128_mask ((__v2di)(__m128i)(A), (unsigned int)(B), (__v2di)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_mask_slli_epi32(W, U, X, C) ((__m256i)__builtin_ia32_pslldi256_mask ((__v8si)(__m256i)(X), (unsigned int)(C), (__v8si)(__m256i)(W), (__mmask8)(U)))
+#define _mm256_maskz_slli_epi32(U, X, C) ((__m256i)__builtin_ia32_pslldi256_mask ((__v8si)(__m256i)(X), (unsigned int)(C), (__v8si)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm256_mask_slli_epi64(W, U, X, C) ((__m256i)__builtin_ia32_psllqi256_mask ((__v4di)(__m256i)(X), (unsigned int)(C), (__v4di)(__m256i)(W), (__mmask8)(U)))
+#define _mm256_maskz_slli_epi64(U, X, C) ((__m256i)__builtin_ia32_psllqi256_mask ((__v4di)(__m256i)(X), (unsigned int)(C), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm_mask_slli_epi32(W, U, X, C) ((__m128i)__builtin_ia32_pslldi128_mask ((__v4si)(__m128i)(X), (unsigned int)(C), (__v4si)(__m128i)(W), (__mmask8)(U)))
+#define _mm_maskz_slli_epi32(U, X, C) ((__m128i)__builtin_ia32_pslldi128_mask ((__v4si)(__m128i)(X), (unsigned int)(C), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm_mask_slli_epi64(W, U, X, C) ((__m128i)__builtin_ia32_psllqi128_mask ((__v2di)(__m128i)(X), (unsigned int)(C), (__v2di)(__m128i)(W), (__mmask8)(U)))
+#define _mm_maskz_slli_epi64(U, X, C) ((__m128i)__builtin_ia32_psllqi128_mask ((__v2di)(__m128i)(X), (unsigned int)(C), (__v2di)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
 #define _mm256_ternarylogic_epi64(A, B, C, I) ((__m256i) __builtin_ia32_pternlogq256_mask ((__v4di) (__m256i) (A), (__v4di) (__m256i) (B), (__v4di) (__m256i) (C), (unsigned char) (I), (__mmask8) -1))
 #define _mm256_mask_ternarylogic_epi64(A, U, B, C, I) ((__m256i) __builtin_ia32_pternlogq256_mask ((__v4di) (__m256i) (A), (__v4di) (__m256i) (B), (__v4di) (__m256i) (C), (unsigned char) (I), (__mmask8) (U)))
 #define _mm256_maskz_ternarylogic_epi64(U, A, B, C, I) ((__m256i) __builtin_ia32_pternlogq256_maskz ((__v4di) (__m256i) (A), (__v4di) (__m256i) (B), (__v4di) (__m256i) (C), (unsigned char) (I), (__mmask8) (U)))
@@ -11371,30 +11180,30 @@ _mm256_permutex_pd (__m256d __X, const int __M)
 #define _mm_ternarylogic_epi32(A, B, C, I) ((__m128i) __builtin_ia32_pternlogd128_mask ((__v4si) (__m128i) (A), (__v4si) (__m128i) (B), (__v4si) (__m128i) (C), (unsigned char) (I), (__mmask8) -1))
 #define _mm_mask_ternarylogic_epi32(A, U, B, C, I) ((__m128i) __builtin_ia32_pternlogd128_mask ((__v4si) (__m128i) (A), (__v4si) (__m128i) (B), (__v4si) (__m128i) (C), (unsigned char) (I), (__mmask8) (U)))
 #define _mm_maskz_ternarylogic_epi32(U, A, B, C, I) ((__m128i) __builtin_ia32_pternlogd128_maskz ((__v4si) (__m128i) (A), (__v4si) (__m128i) (B), (__v4si) (__m128i) (C), (unsigned char) (I), (__mmask8) (U)))
-#define _mm256_roundscale_ps(A, B) ((__m256) __builtin_ia32_rndscaleps_256_mask ((__v8sf)(__m256)(A), (int)(B), (__v8sf)(__m256)_mm256_setzero_ps (), (__mmask8)-1))
+#define _mm256_roundscale_ps(A, B) ((__m256) __builtin_ia32_rndscaleps_256_mask ((__v8sf)(__m256)(A), (int)(B), (__v8sf)(__m256)_mm256_avx512_setzero_ps (), (__mmask8)-1))
 #define _mm256_mask_roundscale_ps(W, U, A, B) ((__m256) __builtin_ia32_rndscaleps_256_mask ((__v8sf)(__m256)(A), (int)(B), (__v8sf)(__m256)(W), (__mmask8)(U)))
-#define _mm256_maskz_roundscale_ps(U, A, B) ((__m256) __builtin_ia32_rndscaleps_256_mask ((__v8sf)(__m256)(A), (int)(B), (__v8sf)(__m256)_mm256_setzero_ps (), (__mmask8)(U)))
-#define _mm256_roundscale_pd(A, B) ((__m256d) __builtin_ia32_rndscalepd_256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)(__m256d)_mm256_setzero_pd (), (__mmask8)-1))
+#define _mm256_maskz_roundscale_ps(U, A, B) ((__m256) __builtin_ia32_rndscaleps_256_mask ((__v8sf)(__m256)(A), (int)(B), (__v8sf)(__m256)_mm256_avx512_setzero_ps (), (__mmask8)(U)))
+#define _mm256_roundscale_pd(A, B) ((__m256d) __builtin_ia32_rndscalepd_256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)(__m256d)_mm256_avx512_setzero_pd (), (__mmask8)-1))
 #define _mm256_mask_roundscale_pd(W, U, A, B) ((__m256d) __builtin_ia32_rndscalepd_256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)(__m256d)(W), (__mmask8)(U)))
-#define _mm256_maskz_roundscale_pd(U, A, B) ((__m256d) __builtin_ia32_rndscalepd_256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)(__m256d)_mm256_setzero_pd (), (__mmask8)(U)))
-#define _mm_roundscale_ps(A, B) ((__m128) __builtin_ia32_rndscaleps_128_mask ((__v4sf)(__m128)(A), (int)(B), (__v4sf)(__m128)_mm_setzero_ps (), (__mmask8)-1))
+#define _mm256_maskz_roundscale_pd(U, A, B) ((__m256d) __builtin_ia32_rndscalepd_256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)(__m256d)_mm256_avx512_setzero_pd (), (__mmask8)(U)))
+#define _mm_roundscale_ps(A, B) ((__m128) __builtin_ia32_rndscaleps_128_mask ((__v4sf)(__m128)(A), (int)(B), (__v4sf)(__m128)_mm_avx512_setzero_ps (), (__mmask8)-1))
 #define _mm_mask_roundscale_ps(W, U, A, B) ((__m128) __builtin_ia32_rndscaleps_128_mask ((__v4sf)(__m128)(A), (int)(B), (__v4sf)(__m128)(W), (__mmask8)(U)))
-#define _mm_maskz_roundscale_ps(U, A, B) ((__m128) __builtin_ia32_rndscaleps_128_mask ((__v4sf)(__m128)(A), (int)(B), (__v4sf)(__m128)_mm_setzero_ps (), (__mmask8)(U)))
-#define _mm_roundscale_pd(A, B) ((__m128d) __builtin_ia32_rndscalepd_128_mask ((__v2df)(__m128d)(A), (int)(B), (__v2df)(__m128d)_mm_setzero_pd (), (__mmask8)-1))
+#define _mm_maskz_roundscale_ps(U, A, B) ((__m128) __builtin_ia32_rndscaleps_128_mask ((__v4sf)(__m128)(A), (int)(B), (__v4sf)(__m128)_mm_avx512_setzero_ps (), (__mmask8)(U)))
+#define _mm_roundscale_pd(A, B) ((__m128d) __builtin_ia32_rndscalepd_128_mask ((__v2df)(__m128d)(A), (int)(B), (__v2df)(__m128d)_mm_avx512_setzero_pd (), (__mmask8)-1))
 #define _mm_mask_roundscale_pd(W, U, A, B) ((__m128d) __builtin_ia32_rndscalepd_128_mask ((__v2df)(__m128d)(A), (int)(B), (__v2df)(__m128d)(W), (__mmask8)(U)))
-#define _mm_maskz_roundscale_pd(U, A, B) ((__m128d) __builtin_ia32_rndscalepd_128_mask ((__v2df)(__m128d)(A), (int)(B), (__v2df)(__m128d)_mm_setzero_pd (), (__mmask8)(U)))
-#define _mm256_getmant_ps(X, B, C) ((__m256) __builtin_ia32_getmantps256_mask ((__v8sf)(__m256) (X), (int)(((C)<<2) | (B)), (__v8sf)(__m256)_mm256_setzero_ps (), (__mmask8)-1))
+#define _mm_maskz_roundscale_pd(U, A, B) ((__m128d) __builtin_ia32_rndscalepd_128_mask ((__v2df)(__m128d)(A), (int)(B), (__v2df)(__m128d)_mm_avx512_setzero_pd (), (__mmask8)(U)))
+#define _mm256_getmant_ps(X, B, C) ((__m256) __builtin_ia32_getmantps256_mask ((__v8sf)(__m256) (X), (int)(((C)<<2) | (B)), (__v8sf)(__m256)_mm256_avx512_setzero_ps (), (__mmask8)-1))
 #define _mm256_mask_getmant_ps(W, U, X, B, C) ((__m256) __builtin_ia32_getmantps256_mask ((__v8sf)(__m256) (X), (int)(((C)<<2) | (B)), (__v8sf)(__m256)(W), (__mmask8)(U)))
-#define _mm256_maskz_getmant_ps(U, X, B, C) ((__m256) __builtin_ia32_getmantps256_mask ((__v8sf)(__m256) (X), (int)(((C)<<2) | (B)), (__v8sf)(__m256)_mm256_setzero_ps (), (__mmask8)(U)))
-#define _mm_getmant_ps(X, B, C) ((__m128) __builtin_ia32_getmantps128_mask ((__v4sf)(__m128) (X), (int)(((C)<<2) | (B)), (__v4sf)(__m128)_mm_setzero_ps (), (__mmask8)-1))
+#define _mm256_maskz_getmant_ps(U, X, B, C) ((__m256) __builtin_ia32_getmantps256_mask ((__v8sf)(__m256) (X), (int)(((C)<<2) | (B)), (__v8sf)(__m256)_mm256_avx512_setzero_ps (), (__mmask8)(U)))
+#define _mm_getmant_ps(X, B, C) ((__m128) __builtin_ia32_getmantps128_mask ((__v4sf)(__m128) (X), (int)(((C)<<2) | (B)), (__v4sf)(__m128)_mm_avx512_setzero_ps (), (__mmask8)-1))
 #define _mm_mask_getmant_ps(W, U, X, B, C) ((__m128) __builtin_ia32_getmantps128_mask ((__v4sf)(__m128) (X), (int)(((C)<<2) | (B)), (__v4sf)(__m128)(W), (__mmask8)(U)))
-#define _mm_maskz_getmant_ps(U, X, B, C) ((__m128) __builtin_ia32_getmantps128_mask ((__v4sf)(__m128) (X), (int)(((C)<<2) | (B)), (__v4sf)(__m128)_mm_setzero_ps (), (__mmask8)(U)))
-#define _mm256_getmant_pd(X, B, C) ((__m256d) __builtin_ia32_getmantpd256_mask ((__v4df)(__m256d) (X), (int)(((C)<<2) | (B)), (__v4df)(__m256d)_mm256_setzero_pd (), (__mmask8)-1))
+#define _mm_maskz_getmant_ps(U, X, B, C) ((__m128) __builtin_ia32_getmantps128_mask ((__v4sf)(__m128) (X), (int)(((C)<<2) | (B)), (__v4sf)(__m128)_mm_avx512_setzero_ps (), (__mmask8)(U)))
+#define _mm256_getmant_pd(X, B, C) ((__m256d) __builtin_ia32_getmantpd256_mask ((__v4df)(__m256d) (X), (int)(((C)<<2) | (B)), (__v4df)(__m256d)_mm256_avx512_setzero_pd (), (__mmask8)-1))
 #define _mm256_mask_getmant_pd(W, U, X, B, C) ((__m256d) __builtin_ia32_getmantpd256_mask ((__v4df)(__m256d) (X), (int)(((C)<<2) | (B)), (__v4df)(__m256d)(W), (__mmask8)(U)))
-#define _mm256_maskz_getmant_pd(U, X, B, C) ((__m256d) __builtin_ia32_getmantpd256_mask ((__v4df)(__m256d) (X), (int)(((C)<<2) | (B)), (__v4df)(__m256d)_mm256_setzero_pd (), (__mmask8)(U)))
-#define _mm_getmant_pd(X, B, C) ((__m128d) __builtin_ia32_getmantpd128_mask ((__v2df)(__m128d) (X), (int)(((C)<<2) | (B)), (__v2df)(__m128d)_mm_setzero_pd (), (__mmask8)-1))
+#define _mm256_maskz_getmant_pd(U, X, B, C) ((__m256d) __builtin_ia32_getmantpd256_mask ((__v4df)(__m256d) (X), (int)(((C)<<2) | (B)), (__v4df)(__m256d)_mm256_avx512_setzero_pd (), (__mmask8)(U)))
+#define _mm_getmant_pd(X, B, C) ((__m128d) __builtin_ia32_getmantpd128_mask ((__v2df)(__m128d) (X), (int)(((C)<<2) | (B)), (__v2df)(__m128d)_mm_avx512_setzero_pd (), (__mmask8)-1))
 #define _mm_mask_getmant_pd(W, U, X, B, C) ((__m128d) __builtin_ia32_getmantpd128_mask ((__v2df)(__m128d) (X), (int)(((C)<<2) | (B)), (__v2df)(__m128d)(W), (__mmask8)(U)))
-#define _mm_maskz_getmant_pd(U, X, B, C) ((__m128d) __builtin_ia32_getmantpd128_mask ((__v2df)(__m128d) (X), (int)(((C)<<2) | (B)), (__v2df)(__m128d)_mm_setzero_pd (), (__mmask8)(U)))
+#define _mm_maskz_getmant_pd(U, X, B, C) ((__m128d) __builtin_ia32_getmantpd128_mask ((__v2df)(__m128d) (X), (int)(((C)<<2) | (B)), (__v2df)(__m128d)_mm_avx512_setzero_pd (), (__mmask8)(U)))
 #define _mm256_mmask_i32gather_ps(V1OLD, MASK, INDEX, ADDR, SCALE) (__m256) __builtin_ia32_gather3siv8sf ((__v8sf)(__m256) (V1OLD), (void const *) (ADDR), (__v8si)(__m256i) (INDEX), (__mmask8) (MASK), (int) (SCALE))
 #define _mm_mmask_i32gather_ps(V1OLD, MASK, INDEX, ADDR, SCALE) (__m128) __builtin_ia32_gather3siv4sf ((__v4sf)(__m128) (V1OLD), (void const *) (ADDR), (__v4si)(__m128i) (INDEX), (__mmask8) (MASK), (int) (SCALE))
 #define _mm256_mmask_i32gather_pd(V1OLD, MASK, INDEX, ADDR, SCALE) (__m256d) __builtin_ia32_gather3siv4df ((__v4df)(__m256d) (V1OLD), (void const *) (ADDR), (__v4si)(__m128i) (INDEX), (__mmask8) (MASK), (int) (SCALE))
@@ -11444,77 +11253,69 @@ _mm256_permutex_pd (__m256d __X, const int __M)
 #define _mm_i64scatter_epi64(ADDR, INDEX, V1, SCALE) __builtin_ia32_scatterdiv2di ((void *) (ADDR), (__mmask8)0xFF, (__v2di)(__m128i) (INDEX), (__v2di)(__m128i) (V1), (int) (SCALE))
 #define _mm_mask_i64scatter_epi64(ADDR, MASK, INDEX, V1, SCALE) __builtin_ia32_scatterdiv2di ((void *) (ADDR), (__mmask8) (MASK), (__v2di)(__m128i) (INDEX), (__v2di)(__m128i) (V1), (int) (SCALE))
 #define _mm256_mask_shuffle_epi32(W, U, X, C) ((__m256i) __builtin_ia32_pshufd256_mask ((__v8si)(__m256i)(X), (int)(C), (__v8si)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_shuffle_epi32(U, X, C) ((__m256i) __builtin_ia32_pshufd256_mask ((__v8si)(__m256i)(X), (int)(C), (__v8si)(__m256i) _mm256_setzero_si256 (), (__mmask8)(U)))
+#define _mm256_maskz_shuffle_epi32(U, X, C) ((__m256i) __builtin_ia32_pshufd256_mask ((__v8si)(__m256i)(X), (int)(C), (__v8si)(__m256i) _mm256_avx512_setzero_si256 (), (__mmask8)(U)))
 #define _mm_mask_shuffle_epi32(W, U, X, C) ((__m128i) __builtin_ia32_pshufd128_mask ((__v4si)(__m128i)(X), (int)(C), (__v4si)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_shuffle_epi32(U, X, C) ((__m128i) __builtin_ia32_pshufd128_mask ((__v4si)(__m128i)(X), (int)(C), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm256_rol_epi64(A, B) ((__m256i)__builtin_ia32_prolq256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)-1))
+#define _mm_maskz_shuffle_epi32(U, X, C) ((__m128i) __builtin_ia32_pshufd128_mask ((__v4si)(__m128i)(X), (int)(C), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_rol_epi64(A, B) ((__m256i)__builtin_ia32_prolq256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)-1))
 #define _mm256_mask_rol_epi64(W, U, A, B) ((__m256i)__builtin_ia32_prolq256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_rol_epi64(U, A, B) ((__m256i)__builtin_ia32_prolq256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm_rol_epi64(A, B) ((__m128i)__builtin_ia32_prolq128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)_mm_setzero_si128 (), (__mmask8)-1))
+#define _mm256_maskz_rol_epi64(U, A, B) ((__m256i)__builtin_ia32_prolq256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm_rol_epi64(A, B) ((__m128i)__builtin_ia32_prolq128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)-1))
 #define _mm_mask_rol_epi64(W, U, A, B) ((__m128i)__builtin_ia32_prolq128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_rol_epi64(U, A, B) ((__m128i)__builtin_ia32_prolq128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm256_ror_epi64(A, B) ((__m256i)__builtin_ia32_prorq256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)-1))
+#define _mm_maskz_rol_epi64(U, A, B) ((__m128i)__builtin_ia32_prolq128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_ror_epi64(A, B) ((__m256i)__builtin_ia32_prorq256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)-1))
 #define _mm256_mask_ror_epi64(W, U, A, B) ((__m256i)__builtin_ia32_prorq256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_ror_epi64(U, A, B) ((__m256i)__builtin_ia32_prorq256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm_ror_epi64(A, B) ((__m128i)__builtin_ia32_prorq128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)_mm_setzero_si128 (), (__mmask8)-1))
+#define _mm256_maskz_ror_epi64(U, A, B) ((__m256i)__builtin_ia32_prorq256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm_ror_epi64(A, B) ((__m128i)__builtin_ia32_prorq128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)-1))
 #define _mm_mask_ror_epi64(W, U, A, B) ((__m128i)__builtin_ia32_prorq128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_ror_epi64(U, A, B) ((__m128i)__builtin_ia32_prorq128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm256_rol_epi32(A, B) ((__m256i)__builtin_ia32_prold256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i)_mm256_setzero_si256 (), (__mmask8)-1))
+#define _mm_maskz_ror_epi64(U, A, B) ((__m128i)__builtin_ia32_prorq128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_rol_epi32(A, B) ((__m256i)__builtin_ia32_prold256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)-1))
 #define _mm256_mask_rol_epi32(W, U, A, B) ((__m256i)__builtin_ia32_prold256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_rol_epi32(U, A, B) ((__m256i)__builtin_ia32_prold256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm_rol_epi32(A, B) ((__m128i)__builtin_ia32_prold128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)-1))
+#define _mm256_maskz_rol_epi32(U, A, B) ((__m256i)__builtin_ia32_prold256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm_rol_epi32(A, B) ((__m128i)__builtin_ia32_prold128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)-1))
 #define _mm_mask_rol_epi32(W, U, A, B) ((__m128i)__builtin_ia32_prold128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_rol_epi32(U, A, B) ((__m128i)__builtin_ia32_prold128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm256_ror_epi32(A, B) ((__m256i)__builtin_ia32_prord256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i)_mm256_setzero_si256 (), (__mmask8)-1))
+#define _mm_maskz_rol_epi32(U, A, B) ((__m128i)__builtin_ia32_prold128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_ror_epi32(A, B) ((__m256i)__builtin_ia32_prord256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)-1))
 #define _mm256_mask_ror_epi32(W, U, A, B) ((__m256i)__builtin_ia32_prord256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_ror_epi32(U, A, B) ((__m256i)__builtin_ia32_prord256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i) _mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm_ror_epi32(A, B) ((__m128i)__builtin_ia32_prord128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)-1))
+#define _mm256_maskz_ror_epi32(U, A, B) ((__m256i)__builtin_ia32_prord256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i) _mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm_ror_epi32(A, B) ((__m128i)__builtin_ia32_prord128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)-1))
 #define _mm_mask_ror_epi32(W, U, A, B) ((__m128i)__builtin_ia32_prord128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_ror_epi32(U, A, B) ((__m128i)__builtin_ia32_prord128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
+#define _mm_maskz_ror_epi32(U, A, B) ((__m128i)__builtin_ia32_prord128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
 #define _mm256_alignr_epi32(X, Y, C) ((__m256i)__builtin_ia32_alignd256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C), (__v8si)(__m256i)(X), (__mmask8)-1))
 #define _mm256_mask_alignr_epi32(W, U, X, Y, C) ((__m256i)__builtin_ia32_alignd256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C), (__v8si)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_alignr_epi32(U, X, Y, C) ((__m256i)__builtin_ia32_alignd256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C), (__v8si)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
+#define _mm256_maskz_alignr_epi32(U, X, Y, C) ((__m256i)__builtin_ia32_alignd256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(C), (__v8si)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
 #define _mm256_alignr_epi64(X, Y, C) ((__m256i)__builtin_ia32_alignq256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(C), (__v4di)(__m256i)(X), (__mmask8)-1))
 #define _mm256_mask_alignr_epi64(W, U, X, Y, C) ((__m256i)__builtin_ia32_alignq256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(C), (__v4di)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_alignr_epi64(U, X, Y, C) ((__m256i)__builtin_ia32_alignq256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(C), (__v4di)(__m256i)_mm256_setzero_si256 (), (__mmask8)(U)))
+#define _mm256_maskz_alignr_epi64(U, X, Y, C) ((__m256i)__builtin_ia32_alignq256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(C), (__v4di)(__m256i)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
 #define _mm_alignr_epi32(X, Y, C) ((__m128i)__builtin_ia32_alignd128_mask ((__v4si)(__m128i)(X), (__v4si)(__m128i)(Y), (int)(C), (__v4si)(__m128i)(X), (__mmask8)-1))
 #define _mm_mask_alignr_epi32(W, U, X, Y, C) ((__m128i)__builtin_ia32_alignd128_mask ((__v4si)(__m128i)(X), (__v4si)(__m128i)(Y), (int)(C), (__v4si)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_alignr_epi32(U, X, Y, C) ((__m128i)__builtin_ia32_alignd128_mask ((__v4si)(__m128i)(X), (__v4si)(__m128i)(Y), (int)(C), (__v4si)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
+#define _mm_maskz_alignr_epi32(U, X, Y, C) ((__m128i)__builtin_ia32_alignd128_mask ((__v4si)(__m128i)(X), (__v4si)(__m128i)(Y), (int)(C), (__v4si)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
 #define _mm_alignr_epi64(X, Y, C) ((__m128i)__builtin_ia32_alignq128_mask ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)(C), (__v2di)(__m128i)(X), (__mmask8)-1))
 #define _mm_mask_alignr_epi64(W, U, X, Y, C) ((__m128i)__builtin_ia32_alignq128_mask ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)(C), (__v2di)(__m128i)(X), (__mmask8)-1))
-#define _mm_maskz_alignr_epi64(U, X, Y, C) ((__m128i)__builtin_ia32_alignq128_mask ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)(C), (__v2di)(__m128i)_mm_setzero_si128 (), (__mmask8)(U)))
+#define _mm_maskz_alignr_epi64(U, X, Y, C) ((__m128i)__builtin_ia32_alignq128_mask ((__v2di)(__m128i)(X), (__v2di)(__m128i)(Y), (int)(C), (__v2di)(__m128i)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
 #define _mm_mask_cvtps_ph(W, U, A, I) ((__m128i) __builtin_ia32_vcvtps2ph_mask ((__v4sf)(__m128) (A), (int) (I), (__v8hi)(__m128i) (W), (__mmask8) (U)))
-#define _mm_maskz_cvtps_ph(U, A, I) ((__m128i) __builtin_ia32_vcvtps2ph_mask ((__v4sf)(__m128) (A), (int) (I), (__v8hi)(__m128i) _mm_setzero_si128 (), (__mmask8) (U)))
+#define _mm_maskz_cvtps_ph(U, A, I) ((__m128i) __builtin_ia32_vcvtps2ph_mask ((__v4sf)(__m128) (A), (int) (I), (__v8hi)(__m128i) _mm_avx512_setzero_si128 (), (__mmask8) (U)))
 #define _mm256_mask_cvtps_ph(W, U, A, I) ((__m128i) __builtin_ia32_vcvtps2ph256_mask ((__v8sf)(__m256) (A), (int) (I), (__v8hi)(__m128i) (W), (__mmask8) (U)))
-#define _mm256_maskz_cvtps_ph(U, A, I) ((__m128i) __builtin_ia32_vcvtps2ph256_mask ((__v8sf)(__m256) (A), (int) (I), (__v8hi)(__m128i) _mm_setzero_si128 (), (__mmask8) (U)))
-#define _mm256_mask_srai_epi32(W, U, A, B) ((__m256i) __builtin_ia32_psradi256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_srai_epi32(U, A, B) ((__m256i) __builtin_ia32_psradi256_mask ((__v8si)(__m256i)(A), (int)(B), (__v8si)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm_mask_srai_epi32(W, U, A, B) ((__m128i) __builtin_ia32_psradi128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_srai_epi32(U, A, B) ((__m128i) __builtin_ia32_psradi128_mask ((__v4si)(__m128i)(A), (int)(B), (__v4si)_mm_setzero_si128 (), (__mmask8)(U)))
-#define _mm256_srai_epi64(A, B) ((__m256i) __builtin_ia32_psraqi256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)_mm256_setzero_si256 (), (__mmask8)-1))
-#define _mm256_mask_srai_epi64(W, U, A, B) ((__m256i) __builtin_ia32_psraqi256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)(__m256i)(W), (__mmask8)(U)))
-#define _mm256_maskz_srai_epi64(U, A, B) ((__m256i) __builtin_ia32_psraqi256_mask ((__v4di)(__m256i)(A), (int)(B), (__v4di)_mm256_setzero_si256 (), (__mmask8)(U)))
-#define _mm_srai_epi64(A, B) ((__m128i) __builtin_ia32_psraqi128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)_mm_setzero_si128 (), (__mmask8)-1))
-#define _mm_mask_srai_epi64(W, U, A, B) ((__m128i) __builtin_ia32_psraqi128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)(__m128i)(W), (__mmask8)(U)))
-#define _mm_maskz_srai_epi64(U, A, B) ((__m128i) __builtin_ia32_psraqi128_mask ((__v2di)(__m128i)(A), (int)(B), (__v2di)_mm_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_maskz_cvtps_ph(U, A, I) ((__m128i) __builtin_ia32_vcvtps2ph256_mask ((__v8sf)(__m256) (A), (int) (I), (__v8hi)(__m128i) _mm_avx512_setzero_si128 (), (__mmask8) (U)))
+#define _mm256_mask_srai_epi32(W, U, A, B) ((__m256i) __builtin_ia32_psradi256_mask ((__v8si)(__m256i)(A), (unsigned int)(B), (__v8si)(__m256i)(W), (__mmask8)(U)))
+#define _mm256_maskz_srai_epi32(U, A, B) ((__m256i) __builtin_ia32_psradi256_mask ((__v8si)(__m256i)(A), (unsigned int)(B), (__v8si)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm_mask_srai_epi32(W, U, A, B) ((__m128i) __builtin_ia32_psradi128_mask ((__v4si)(__m128i)(A), (unsigned int)(B), (__v4si)(__m128i)(W), (__mmask8)(U)))
+#define _mm_maskz_srai_epi32(U, A, B) ((__m128i) __builtin_ia32_psradi128_mask ((__v4si)(__m128i)(A), (unsigned int)(B), (__v4si)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
+#define _mm256_srai_epi64(A, B) ((__m256i) __builtin_ia32_psraqi256_mask ((__v4di)(__m256i)(A), (unsigned int)(B), (__v4di)_mm256_avx512_setzero_si256 (), (__mmask8)-1))
+#define _mm256_mask_srai_epi64(W, U, A, B) ((__m256i) __builtin_ia32_psraqi256_mask ((__v4di)(__m256i)(A), (unsigned int)(B), (__v4di)(__m256i)(W), (__mmask8)(U)))
+#define _mm256_maskz_srai_epi64(U, A, B) ((__m256i) __builtin_ia32_psraqi256_mask ((__v4di)(__m256i)(A), (unsigned int)(B), (__v4di)_mm256_avx512_setzero_si256 (), (__mmask8)(U)))
+#define _mm_srai_epi64(A, B) ((__m128i) __builtin_ia32_psraqi128_mask ((__v2di)(__m128i)(A), (unsigned int)(B), (__v2di)_mm_avx512_setzero_si128 (), (__mmask8)-1))
+#define _mm_mask_srai_epi64(W, U, A, B) ((__m128i) __builtin_ia32_psraqi128_mask ((__v2di)(__m128i)(A), (unsigned int)(B), (__v2di)(__m128i)(W), (__mmask8)(U)))
+#define _mm_maskz_srai_epi64(U, A, B) ((__m128i) __builtin_ia32_psraqi128_mask ((__v2di)(__m128i)(A), (unsigned int)(B), (__v2di)_mm_avx512_setzero_si128 (), (__mmask8)(U)))
 #define _mm256_mask_permutex_pd(W, U, A, B) ((__m256d) __builtin_ia32_permdf256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)(__m256d)(W), (__mmask8)(U)))
-#define _mm256_maskz_permutex_pd(U, A, B) ((__m256d) __builtin_ia32_permdf256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)(__m256d)_mm256_setzero_pd (), (__mmask8)(U)))
+#define _mm256_maskz_permutex_pd(U, A, B) ((__m256d) __builtin_ia32_permdf256_mask ((__v4df)(__m256d)(A), (int)(B), (__v4df)(__m256d)_mm256_avx512_setzero_pd (), (__mmask8)(U)))
 #define _mm256_mask_permute_pd(W, U, X, C) ((__m256d) __builtin_ia32_vpermilpd256_mask ((__v4df)(__m256d)(X), (int)(C), (__v4df)(__m256d)(W), (__mmask8)(U)))
-#define _mm256_maskz_permute_pd(U, X, C) ((__m256d) __builtin_ia32_vpermilpd256_mask ((__v4df)(__m256d)(X), (int)(C), (__v4df)(__m256d)_mm256_setzero_pd (), (__mmask8)(U)))
+#define _mm256_maskz_permute_pd(U, X, C) ((__m256d) __builtin_ia32_vpermilpd256_mask ((__v4df)(__m256d)(X), (int)(C), (__v4df)(__m256d)_mm256_avx512_setzero_pd (), (__mmask8)(U)))
 #define _mm256_mask_permute_ps(W, U, X, C) ((__m256) __builtin_ia32_vpermilps256_mask ((__v8sf)(__m256)(X), (int)(C), (__v8sf)(__m256)(W), (__mmask8)(U)))
-#define _mm256_maskz_permute_ps(U, X, C) ((__m256) __builtin_ia32_vpermilps256_mask ((__v8sf)(__m256)(X), (int)(C), (__v8sf)(__m256)_mm256_setzero_ps (), (__mmask8)(U)))
+#define _mm256_maskz_permute_ps(U, X, C) ((__m256) __builtin_ia32_vpermilps256_mask ((__v8sf)(__m256)(X), (int)(C), (__v8sf)(__m256)_mm256_avx512_setzero_ps (), (__mmask8)(U)))
 #define _mm_mask_permute_pd(W, U, X, C) ((__m128d) __builtin_ia32_vpermilpd_mask ((__v2df)(__m128d)(X), (int)(C), (__v2df)(__m128d)(W), (__mmask8)(U)))
-#define _mm_maskz_permute_pd(U, X, C) ((__m128d) __builtin_ia32_vpermilpd_mask ((__v2df)(__m128d)(X), (int)(C), (__v2df)(__m128d)_mm_setzero_pd (), (__mmask8)(U)))
+#define _mm_maskz_permute_pd(U, X, C) ((__m128d) __builtin_ia32_vpermilpd_mask ((__v2df)(__m128d)(X), (int)(C), (__v2df)(__m128d)_mm_avx512_setzero_pd (), (__mmask8)(U)))
 #define _mm_mask_permute_ps(W, U, X, C) ((__m128) __builtin_ia32_vpermilps_mask ((__v4sf)(__m128)(X), (int)(C), (__v4sf)(__m128)(W), (__mmask8)(U)))
-#define _mm_maskz_permute_ps(U, X, C) ((__m128) __builtin_ia32_vpermilps_mask ((__v4sf)(__m128)(X), (int)(C), (__v4sf)(__m128)_mm_setzero_ps (), (__mmask8)(U)))
-#define _mm256_mask_blend_pd(__U, __A, __W) ((__m256d) __builtin_ia32_blendmpd_256_mask ((__v4df) (__A), (__v4df) (__W), (__mmask8) (__U)))
-#define _mm256_mask_blend_ps(__U, __A, __W) ((__m256) __builtin_ia32_blendmps_256_mask ((__v8sf) (__A), (__v8sf) (__W), (__mmask8) (__U)))
-#define _mm256_mask_blend_epi64(__U, __A, __W) ((__m256i) __builtin_ia32_blendmq_256_mask ((__v4di) (__A), (__v4di) (__W), (__mmask8) (__U)))
-#define _mm256_mask_blend_epi32(__U, __A, __W) ((__m256i) __builtin_ia32_blendmd_256_mask ((__v8si) (__A), (__v8si) (__W), (__mmask8) (__U)))
-#define _mm_mask_blend_pd(__U, __A, __W) ((__m128d) __builtin_ia32_blendmpd_128_mask ((__v2df) (__A), (__v2df) (__W), (__mmask8) (__U)))
-#define _mm_mask_blend_ps(__U, __A, __W) ((__m128) __builtin_ia32_blendmps_128_mask ((__v4sf) (__A), (__v4sf) (__W), (__mmask8) (__U)))
-#define _mm_mask_blend_epi64(__U, __A, __W) ((__m128i) __builtin_ia32_blendmq_128_mask ((__v2di) (__A), (__v2di) (__W), (__mmask8) (__U)))
-#define _mm_mask_blend_epi32(__U, __A, __W) ((__m128i) __builtin_ia32_blendmd_128_mask ((__v4si) (__A), (__v4si) (__W), (__mmask8) (__U)))
+#define _mm_maskz_permute_ps(U, X, C) ((__m128) __builtin_ia32_vpermilps_mask ((__v4sf)(__m128)(X), (int)(C), (__v4sf)(__m128)_mm_avx512_setzero_ps (), (__mmask8)(U)))
 #define _mm256_cmp_epu32_mask(X, Y, P) ((__mmask8) __builtin_ia32_ucmpd256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(P), (__mmask8)-1))
 #define _mm256_cmp_epi64_mask(X, Y, P) ((__mmask8) __builtin_ia32_cmpq256_mask ((__v4di)(__m256i)(X), (__v4di)(__m256i)(Y), (int)(P), (__mmask8)-1))
 #define _mm256_cmp_epi32_mask(X, Y, P) ((__mmask8) __builtin_ia32_cmpd256_mask ((__v8si)(__m256i)(X), (__v8si)(__m256i)(Y), (int)(P), (__mmask8)-1))
@@ -11549,5 +11350,253 @@ _mm256_permutex_pd (__m256d __X, const int __M)
 #undef __DISABLE_AVX512VL__
 #pragma GCC pop_options
 #endif
+#if !defined (__AVX512CD__) || !defined (__AVX512VL__)
+#pragma GCC push_options
+#pragma GCC target("avx512vl,avx512cd,no-evex512")
+#define __DISABLE_AVX512VLCD__
+#endif
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_broadcastmb_epi64 (__mmask8 __A)
+{
+  return (__m128i) __builtin_ia32_broadcastmb128 (__A);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_broadcastmb_epi64 (__mmask8 __A)
+{
+  return (__m256i) __builtin_ia32_broadcastmb256 (__A);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_broadcastmw_epi32 (__mmask16 __A)
+{
+  return (__m128i) __builtin_ia32_broadcastmw128 (__A);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_broadcastmw_epi32 (__mmask16 __A)
+{
+  return (__m256i) __builtin_ia32_broadcastmw256 (__A);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_lzcnt_epi32 (__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vplzcntd_256_mask ((__v8si) __A,
+           (__v8si)
+           _mm256_avx512_setzero_si256 (),
+           (__mmask8) -1);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_lzcnt_epi32 (__m256i __W, __mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vplzcntd_256_mask ((__v8si) __A,
+           (__v8si) __W,
+           (__mmask8) __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_maskz_lzcnt_epi32 (__mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vplzcntd_256_mask ((__v8si) __A,
+           (__v8si)
+           _mm256_avx512_setzero_si256 (),
+           (__mmask8) __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_lzcnt_epi64 (__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vplzcntq_256_mask ((__v4di) __A,
+           (__v4di)
+           _mm256_avx512_setzero_si256 (),
+           (__mmask8) -1);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_lzcnt_epi64 (__m256i __W, __mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vplzcntq_256_mask ((__v4di) __A,
+           (__v4di) __W,
+           (__mmask8) __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_maskz_lzcnt_epi64 (__mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vplzcntq_256_mask ((__v4di) __A,
+           (__v4di)
+           _mm256_avx512_setzero_si256 (),
+           (__mmask8) __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_conflict_epi64 (__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpconflictdi_256_mask ((__v4di) __A,
+        (__v4di)
+        _mm256_avx512_setzero_si256 (),
+        (__mmask8) -1);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_conflict_epi64 (__m256i __W, __mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpconflictdi_256_mask ((__v4di) __A,
+        (__v4di) __W,
+        (__mmask8)
+        __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_maskz_conflict_epi64 (__mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpconflictdi_256_mask ((__v4di) __A,
+        (__v4di)
+        _mm256_avx512_setzero_si256 (),
+        (__mmask8)
+        __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_conflict_epi32 (__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpconflictsi_256_mask ((__v8si) __A,
+        (__v8si)
+        _mm256_avx512_setzero_si256 (),
+        (__mmask8) -1);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_mask_conflict_epi32 (__m256i __W, __mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpconflictsi_256_mask ((__v8si) __A,
+        (__v8si) __W,
+        (__mmask8)
+        __U);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_maskz_conflict_epi32 (__mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpconflictsi_256_mask ((__v8si) __A,
+        (__v8si)
+        _mm256_avx512_setzero_si256 (),
+        (__mmask8)
+        __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_lzcnt_epi32 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vplzcntd_128_mask ((__v4si) __A,
+           (__v4si)
+           _mm_avx512_setzero_si128 (),
+           (__mmask8) -1);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_lzcnt_epi32 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vplzcntd_128_mask ((__v4si) __A,
+           (__v4si) __W,
+           (__mmask8) __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_lzcnt_epi32 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vplzcntd_128_mask ((__v4si) __A,
+           (__v4si)
+           _mm_avx512_setzero_si128 (),
+           (__mmask8) __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_lzcnt_epi64 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vplzcntq_128_mask ((__v2di) __A,
+           (__v2di)
+           _mm_avx512_setzero_si128 (),
+           (__mmask8) -1);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_lzcnt_epi64 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vplzcntq_128_mask ((__v2di) __A,
+           (__v2di) __W,
+           (__mmask8) __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_lzcnt_epi64 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vplzcntq_128_mask ((__v2di) __A,
+           (__v2di)
+           _mm_avx512_setzero_si128 (),
+           (__mmask8) __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_conflict_epi64 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpconflictdi_128_mask ((__v2di) __A,
+        (__v2di)
+        _mm_avx512_setzero_si128 (),
+        (__mmask8) -1);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_conflict_epi64 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpconflictdi_128_mask ((__v2di) __A,
+        (__v2di) __W,
+        (__mmask8)
+        __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_conflict_epi64 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpconflictdi_128_mask ((__v2di) __A,
+        (__v2di)
+        _mm_avx512_setzero_si128 (),
+        (__mmask8)
+        __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_conflict_epi32 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpconflictsi_128_mask ((__v4si) __A,
+        (__v4si)
+        _mm_avx512_setzero_si128 (),
+        (__mmask8) -1);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_mask_conflict_epi32 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpconflictsi_128_mask ((__v4si) __A,
+        (__v4si) __W,
+        (__mmask8)
+        __U);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_maskz_conflict_epi32 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpconflictsi_128_mask ((__v4si) __A,
+        (__v4si)
+        _mm_avx512_setzero_si128 (),
+        (__mmask8)
+        __U);
+}
+#ifdef __DISABLE_AVX512VLCD__
+#pragma GCC pop_options
+#endif
 #endif
 #endif
diff --git a/third_party/intel/avx512vnniintrin.internal.h b/third_party/intel/avx512vnniintrin.internal.h
index a9c41879b..cbc7da1cc 100644
--- a/third_party/intel/avx512vnniintrin.internal.h
+++ b/third_party/intel/avx512vnniintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef __AVX512VNNIINTRIN_H_INCLUDED
 #define __AVX512VNNIINTRIN_H_INCLUDED
-#if !defined(__AVX512VNNI__)
+#if !defined(__AVX512VNNI__) || !defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vnni")
+#pragma GCC target("avx512vnni,evex512")
 #define __DISABLE_AVX512VNNI__
 #endif
 extern __inline __m512i
diff --git a/third_party/intel/avx512vnnivlintrin.internal.h b/third_party/intel/avx512vnnivlintrin.internal.h
index f403563b8..411ebcc57 100644
--- a/third_party/intel/avx512vnnivlintrin.internal.h
+++ b/third_party/intel/avx512vnnivlintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512VNNIVLINTRIN_H_INCLUDED
 #define _AVX512VNNIVLINTRIN_H_INCLUDED
-#if !defined(__AVX512VL__) || !defined(__AVX512VNNI__)
+#if !defined(__AVX512VL__) || !defined(__AVX512VNNI__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vnni,avx512vl")
+#pragma GCC target("avx512vnni,avx512vl,no-evex512")
 #define __DISABLE_AVX512VNNIVL__
 #endif
 #define _mm256_dpbusd_epi32(A, B, C) ((__m256i) __builtin_ia32_vpdpbusd_v8si ((__v8si) (A), (__v8si) (B), (__v8si) (C)))
diff --git a/third_party/intel/avx512vp2intersectintrin.internal.h b/third_party/intel/avx512vp2intersectintrin.internal.h
index 189aa37b2..09ada18c5 100644
--- a/third_party/intel/avx512vp2intersectintrin.internal.h
+++ b/third_party/intel/avx512vp2intersectintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512VP2INTERSECTINTRIN_H_INCLUDED
 #define _AVX512VP2INTERSECTINTRIN_H_INCLUDED
-#if !defined(__AVX512VP2INTERSECT__)
+#if !defined(__AVX512VP2INTERSECT__) || !defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vp2intersect")
+#pragma GCC target("avx512vp2intersect,evex512")
 #define __DISABLE_AVX512VP2INTERSECT__
 #endif
 extern __inline void
diff --git a/third_party/intel/avx512vp2intersectvlintrin.internal.h b/third_party/intel/avx512vp2intersectvlintrin.internal.h
index e38624ebf..dad5b821b 100644
--- a/third_party/intel/avx512vp2intersectvlintrin.internal.h
+++ b/third_party/intel/avx512vp2intersectvlintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512VP2INTERSECTVLINTRIN_H_INCLUDED
 #define _AVX512VP2INTERSECTVLINTRIN_H_INCLUDED
-#if !defined(__AVX512VP2INTERSECT__) || !defined(__AVX512VL__)
+#if !defined(__AVX512VP2INTERSECT__) || !defined(__AVX512VL__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vp2intersect,avx512vl")
+#pragma GCC target("avx512vp2intersect,avx512vl,no-evex512")
 #define __DISABLE_AVX512VP2INTERSECTVL__
 #endif
 extern __inline void
diff --git a/third_party/intel/avx512vpopcntdqintrin.internal.h b/third_party/intel/avx512vpopcntdqintrin.internal.h
index fe4d5c834..93ff9cce8 100644
--- a/third_party/intel/avx512vpopcntdqintrin.internal.h
+++ b/third_party/intel/avx512vpopcntdqintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512VPOPCNTDQINTRIN_H_INCLUDED
 #define _AVX512VPOPCNTDQINTRIN_H_INCLUDED
-#ifndef __AVX512VPOPCNTDQ__
+#if !defined (__AVX512VPOPCNTDQ__) || !defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vpopcntdq")
+#pragma GCC target("avx512vpopcntdq,evex512")
 #define __DISABLE_AVX512VPOPCNTDQ__
 #endif
 extern __inline __m512i
diff --git a/third_party/intel/avx512vpopcntdqvlintrin.internal.h b/third_party/intel/avx512vpopcntdqvlintrin.internal.h
index a86d84ce3..c2ff8e24a 100644
--- a/third_party/intel/avx512vpopcntdqvlintrin.internal.h
+++ b/third_party/intel/avx512vpopcntdqvlintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _AVX512VPOPCNTDQVLINTRIN_H_INCLUDED
 #define _AVX512VPOPCNTDQVLINTRIN_H_INCLUDED
-#if !defined(__AVX512VPOPCNTDQ__) || !defined(__AVX512VL__)
+#if !defined(__AVX512VPOPCNTDQ__) || !defined(__AVX512VL__) || defined (__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("avx512vpopcntdq,avx512vl")
+#pragma GCC target("avx512vpopcntdq,avx512vl,no-evex512")
 #define __DISABLE_AVX512VPOPCNTDQVL__
 #endif
 extern __inline __m128i
@@ -29,7 +29,7 @@ _mm_maskz_popcnt_epi32 (__mmask16 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_vpopcountd_v4si_mask ((__v4si) __A,
         (__v4si)
-        _mm_setzero_si128 (),
+        _mm_avx512_setzero_si128 (),
         (__mmask16) __U);
 }
 extern __inline __m256i
@@ -52,7 +52,7 @@ _mm256_maskz_popcnt_epi32 (__mmask16 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_vpopcountd_v8si_mask ((__v8si) __A,
       (__v8si)
-      _mm256_setzero_si256 (),
+      _mm256_avx512_setzero_si256 (),
       (__mmask16) __U);
 }
 extern __inline __m128i
@@ -75,7 +75,7 @@ _mm_maskz_popcnt_epi64 (__mmask8 __U, __m128i __A)
 {
   return (__m128i) __builtin_ia32_vpopcountq_v2di_mask ((__v2di) __A,
        (__v2di)
-       _mm_setzero_si128 (),
+       _mm_avx512_setzero_si128 (),
        (__mmask8) __U);
 }
 extern __inline __m256i
@@ -98,7 +98,7 @@ _mm256_maskz_popcnt_epi64 (__mmask8 __U, __m256i __A)
 {
   return (__m256i) __builtin_ia32_vpopcountq_v4di_mask ((__v4di) __A,
       (__v4di)
-      _mm256_setzero_si256 (),
+      _mm256_avx512_setzero_si256 (),
       (__mmask8) __U);
 }
 #ifdef __DISABLE_AVX512VPOPCNTDQVL__
diff --git a/third_party/intel/avxifmaintrin.internal.h b/third_party/intel/avxifmaintrin.internal.h
new file mode 100644
index 000000000..283bd9800
--- /dev/null
+++ b/third_party/intel/avxifmaintrin.internal.h
@@ -0,0 +1,49 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#ifndef _IMMINTRIN_H_INCLUDED
+#error "Never use <avxifmaintrin.h> directly; include <immintrin.h> instead."
+#endif
+#ifndef _AVXIFMAINTRIN_H_INCLUDED
+#define _AVXIFMAINTRIN_H_INCLUDED
+#ifndef __AVXIFMA__
+#pragma GCC push_options
+#pragma GCC target("avxifma")
+#define __DISABLE_AVXIFMA__
+#endif
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_madd52lo_avx_epu64 (__m128i __X, __m128i __Y, __m128i __Z)
+{
+  return (__m128i) __builtin_ia32_vpmadd52luq128 ((__v2di) __X,
+        (__v2di) __Y,
+        (__v2di) __Z);
+}
+extern __inline __m128i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_madd52hi_avx_epu64 (__m128i __X, __m128i __Y, __m128i __Z)
+{
+  return (__m128i) __builtin_ia32_vpmadd52huq128 ((__v2di) __X,
+        (__v2di) __Y,
+        (__v2di) __Z);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_madd52lo_avx_epu64 (__m256i __X, __m256i __Y, __m256i __Z)
+{
+  return (__m256i) __builtin_ia32_vpmadd52luq256 ((__v4di) __X,
+        (__v4di) __Y,
+        (__v4di) __Z);
+}
+extern __inline __m256i
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_madd52hi_avx_epu64 (__m256i __X, __m256i __Y, __m256i __Z)
+{
+  return (__m256i) __builtin_ia32_vpmadd52huq256 ((__v4di) __X,
+        (__v4di) __Y,
+        (__v4di) __Z);
+}
+#ifdef __DISABLE_AVXIFMA__
+#undef __DISABLE_AVXIFMA__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/avxintrin.internal.h b/third_party/intel/avxintrin.internal.h
index f2c84ef94..79b38ff59 100644
--- a/third_party/intel/avxintrin.internal.h
+++ b/third_party/intel/avxintrin.internal.h
@@ -872,19 +872,28 @@ _mm256_movemask_ps (__m256 __A)
 extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_undefined_pd (void)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
   __m256d __Y = __Y;
+#pragma GCC diagnostic pop
   return __Y;
 }
 extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_undefined_ps (void)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
   __m256 __Y = __Y;
+#pragma GCC diagnostic pop
   return __Y;
 }
 extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_undefined_si256 (void)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
   __m256i __Y = __Y;
+#pragma GCC diagnostic pop
   return __Y;
 }
 extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
diff --git a/third_party/intel/avxneconvertintrin.internal.h b/third_party/intel/avxneconvertintrin.internal.h
new file mode 100644
index 000000000..30e99da75
--- /dev/null
+++ b/third_party/intel/avxneconvertintrin.internal.h
@@ -0,0 +1,101 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#ifndef _IMMINTRIN_H_INCLUDED
+#error "Never use <avxneconvertintrin.h> directly; include <immintrin.h> instead."
+#endif
+#ifndef _AVXNECONVERTINTRIN_H_INCLUDED
+#define _AVXNECONVERTINTRIN_H_INCLUDED
+#ifndef __AVXNECONVERT__
+#pragma GCC push_options
+#pragma GCC target ("avxneconvert")
+#define __DISABLE_AVXNECONVERT__
+#endif
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_bcstnebf16_ps (const void *__P)
+{
+  return (__m128) __builtin_ia32_vbcstnebf162ps128 ((const __bf16 *) __P);
+}
+extern __inline __m256
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_bcstnebf16_ps (const void *__P)
+{
+  return (__m256) __builtin_ia32_vbcstnebf162ps256 ((const __bf16 *) __P);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_bcstnesh_ps (const void *__P)
+{
+  return (__m128) __builtin_ia32_vbcstnesh2ps128 ((const _Float16 *) __P);
+}
+extern __inline __m256
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_bcstnesh_ps (const void *__P)
+{
+  return (__m256) __builtin_ia32_vbcstnesh2ps256 ((const _Float16 *) __P);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtneebf16_ps (const __m128bh *__A)
+{
+  return (__m128) __builtin_ia32_vcvtneebf162ps128 ((const __v8bf *) __A);
+}
+extern __inline __m256
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_cvtneebf16_ps (const __m256bh *__A)
+{
+  return (__m256) __builtin_ia32_vcvtneebf162ps256 ((const __v16bf *) __A);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtneeph_ps (const __m128h *__A)
+{
+  return (__m128) __builtin_ia32_vcvtneeph2ps128 ((const __v8hf *) __A);
+}
+extern __inline __m256
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_cvtneeph_ps (const __m256h *__A)
+{
+  return (__m256) __builtin_ia32_vcvtneeph2ps256 ((const __v16hf *) __A);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtneobf16_ps (const __m128bh *__A)
+{
+  return (__m128) __builtin_ia32_vcvtneobf162ps128 ((const __v8bf *) __A);
+}
+extern __inline __m256
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_cvtneobf16_ps (const __m256bh *__A)
+{
+  return (__m256) __builtin_ia32_vcvtneobf162ps256 ((const __v16bf *) __A);
+}
+extern __inline __m128
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtneoph_ps (const __m128h *__A)
+{
+  return (__m128) __builtin_ia32_vcvtneoph2ps128 ((const __v8hf *) __A);
+}
+extern __inline __m256
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_cvtneoph_ps (const __m256h *__A)
+{
+  return (__m256) __builtin_ia32_vcvtneoph2ps256 ((const __v16hf *) __A);
+}
+extern __inline __m128bh
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm_cvtneps_avx_pbh (__m128 __A)
+{
+  return (__m128bh) __builtin_ia32_cvtneps2bf16_v4sf (__A);
+}
+extern __inline __m128bh
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_cvtneps_avx_pbh (__m256 __A)
+{
+  return (__m128bh) __builtin_ia32_cvtneps2bf16_v8sf (__A);
+}
+#ifdef __DISABLE_AVXNECONVERT__
+#undef __DISABLE_AVXNECONVERT__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/avxvnniint16intrin.internal.h b/third_party/intel/avxvnniint16intrin.internal.h
new file mode 100644
index 000000000..feec58128
--- /dev/null
+++ b/third_party/intel/avxvnniint16intrin.internal.h
@@ -0,0 +1,101 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#if !defined _IMMINTRIN_H_INCLUDED
+#error "Never use <avxvnniint16intrin.h> directly; include <immintrin.h> instead."
+#endif
+#ifndef _AVXVNNIINT16INTRIN_H_INCLUDED
+#define _AVXVNNIINT16INTRIN_H_INCLUDED
+#if !defined(__AVXVNNIINT16__)
+#pragma GCC push_options
+#pragma GCC target("avxvnniint16")
+#define __DISABLE_AVXVNNIINT16__
+#endif
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpwsud_avx_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpwsud128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpwsuds_avx_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpwsuds128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpwusd_avx_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpwusd128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpwusds_avx_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpwusds128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpwuud_avx_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpwuud128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpwuuds_avx_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpwuuds128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpwsud_avx_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpwsud256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpwsuds_avx_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpwsuds256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpwusd_avx_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpwusd256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpwusds_avx_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpwusds256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpwuud_avx_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpwuud256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpwuuds_avx_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpwuuds256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+#ifdef __DISABLE_AVXVNNIINT16__
+#undef __DISABLE_AVXVNNIINT16__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/avxvnniint8intrin.internal.h b/third_party/intel/avxvnniint8intrin.internal.h
new file mode 100644
index 000000000..7e933ed06
--- /dev/null
+++ b/third_party/intel/avxvnniint8intrin.internal.h
@@ -0,0 +1,101 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#if !defined _IMMINTRIN_H_INCLUDED
+#error "Never use <avxvnniint8vlintrin.h> directly; include <immintrin.h> instead."
+#endif
+#ifndef _AVXVNNIINT8INTRIN_H_INCLUDED
+#define _AVXVNNIINT8INTRIN_H_INCLUDED
+#if !defined(__AVXVNNIINT8__)
+#pragma GCC push_options
+#pragma GCC target("avxvnniint8")
+#define __DISABLE_AVXVNNIINT8__
+#endif
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpbssd_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpbssd128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpbssds_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpbssds128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpbsud_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpbsud128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpbsuds_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpbsuds128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpbuud_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpbuud128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_dpbuuds_epi32 (__m128i __W, __m128i __A, __m128i __B)
+{
+  return (__m128i)
+    __builtin_ia32_vpdpbuuds128 ((__v4si) __W, (__v4si) __A, (__v4si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpbssd_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpbssd256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpbssds_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpbssds256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpbsud_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpbsud256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpbsuds_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpbsuds256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpbuud_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpbuud256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_dpbuuds_epi32 (__m256i __W, __m256i __A, __m256i __B)
+{
+  return (__m256i)
+    __builtin_ia32_vpdpbuuds256 ((__v8si) __W, (__v8si) __A, (__v8si) __B);
+}
+#ifdef __DISABLE_AVXVNNIINT8__
+#undef __DISABLE_AVXVNNIINT8__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/bmmintrin.internal.h b/third_party/intel/bmmintrin.internal.h
new file mode 100644
index 000000000..5394598c7
--- /dev/null
+++ b/third_party/intel/bmmintrin.internal.h
@@ -0,0 +1,6 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#ifndef _BMMINTRIN_H_INCLUDED
+#define _BMMINTRIN_H_INCLUDED
+# error "SSE5 instruction set removed from compiler"
+#endif
+#endif
diff --git a/third_party/intel/clang/__wmmintrin_aes.h b/third_party/intel/clang/__wmmintrin_aes.h
new file mode 100644
index 000000000..3010b3871
--- /dev/null
+++ b/third_party/intel/clang/__wmmintrin_aes.h
@@ -0,0 +1,140 @@
+/*===---- __wmmintrin_aes.h - AES intrinsics -------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __WMMINTRIN_H
+#error "Never use <__wmmintrin_aes.h> directly; include <wmmintrin.h> instead."
+#endif
+
+#ifndef __WMMINTRIN_AES_H
+#define __WMMINTRIN_AES_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("aes"), __min_vector_width__(128)))
+
+/// Performs a single round of AES encryption using the Equivalent
+///    Inverse Cipher, transforming the state value from the first source
+///    operand using a 128-bit round key value contained in the second source
+///    operand, and writes the result to the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VAESENC </c> instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the state value.
+/// \param __R
+///    A 128-bit integer vector containing the round key value.
+/// \returns A 128-bit integer vector containing the encrypted value.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_aesenc_si128(__m128i __V, __m128i __R)
+{
+  return (__m128i)__builtin_ia32_aesenc128((__v2di)__V, (__v2di)__R);
+}
+
+/// Performs the final round of AES encryption using the Equivalent
+///    Inverse Cipher, transforming the state value from the first source
+///    operand using a 128-bit round key value contained in the second source
+///    operand, and writes the result to the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VAESENCLAST </c> instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the state value.
+/// \param __R
+///    A 128-bit integer vector containing the round key value.
+/// \returns A 128-bit integer vector containing the encrypted value.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_aesenclast_si128(__m128i __V, __m128i __R)
+{
+  return (__m128i)__builtin_ia32_aesenclast128((__v2di)__V, (__v2di)__R);
+}
+
+/// Performs a single round of AES decryption using the Equivalent
+///    Inverse Cipher, transforming the state value from the first source
+///    operand using a 128-bit round key value contained in the second source
+///    operand, and writes the result to the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VAESDEC </c> instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the state value.
+/// \param __R
+///    A 128-bit integer vector containing the round key value.
+/// \returns A 128-bit integer vector containing the decrypted value.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_aesdec_si128(__m128i __V, __m128i __R)
+{
+  return (__m128i)__builtin_ia32_aesdec128((__v2di)__V, (__v2di)__R);
+}
+
+/// Performs the final round of AES decryption using the Equivalent
+///    Inverse Cipher, transforming the state value from the first source
+///    operand using a 128-bit round key value contained in the second source
+///    operand, and writes the result to the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VAESDECLAST </c> instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the state value.
+/// \param __R
+///    A 128-bit integer vector containing the round key value.
+/// \returns A 128-bit integer vector containing the decrypted value.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_aesdeclast_si128(__m128i __V, __m128i __R)
+{
+  return (__m128i)__builtin_ia32_aesdeclast128((__v2di)__V, (__v2di)__R);
+}
+
+/// Applies the AES InvMixColumns() transformation to an expanded key
+///    contained in the source operand, and writes the result to the
+///    destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VAESIMC </c> instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the expanded key.
+/// \returns A 128-bit integer vector containing the transformed value.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_aesimc_si128(__m128i __V)
+{
+  return (__m128i)__builtin_ia32_aesimc128((__v2di)__V);
+}
+
+/// Generates a round key for AES encryption, operating on 128-bit data
+///    specified in the first source operand and using an 8-bit round constant
+///    specified by the second source operand, and writes the result to the
+///    destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_aeskeygenassist_si128(__m128i C, const int R);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> AESKEYGENASSIST </c> instruction.
+///
+/// \param C
+///    A 128-bit integer vector that is used to generate the AES encryption key.
+/// \param R
+///    An 8-bit round constant used to generate the AES encryption key.
+/// \returns A 128-bit round key for AES encryption.
+#define _mm_aeskeygenassist_si128(C, R) \
+  ((__m128i)__builtin_ia32_aeskeygenassist128((__v2di)(__m128i)(C), (int)(R)))
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif  /* __WMMINTRIN_AES_H */
diff --git a/third_party/intel/clang/__wmmintrin_pclmul.h b/third_party/intel/clang/__wmmintrin_pclmul.h
new file mode 100644
index 000000000..c9a6d50bd
--- /dev/null
+++ b/third_party/intel/clang/__wmmintrin_pclmul.h
@@ -0,0 +1,48 @@
+/*===---- __wmmintrin_pclmul.h - PCMUL intrinsics ---------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __WMMINTRIN_H
+#error "Never use <__wmmintrin_pclmul.h> directly; include <wmmintrin.h> instead."
+#endif
+
+#ifndef __WMMINTRIN_PCLMUL_H
+#define __WMMINTRIN_PCLMUL_H
+
+/// Multiplies two 64-bit integer values, which are selected from source
+///    operands using the immediate-value operand. The multiplication is a
+///    carry-less multiplication, and the 128-bit integer product is stored in
+///    the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_clmulepi64_si128(__m128i X, __m128i Y, const int I);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCLMULQDQ </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [2 x i64] containing one of the source operands.
+/// \param Y
+///    A 128-bit vector of [2 x i64] containing one of the source operands.
+/// \param I
+///    An immediate value specifying which 64-bit values to select from the
+///    operands. Bit 0 is used to select a value from operand \a X, and bit
+///    4 is used to select a value from operand \a Y: \n
+///    Bit[0]=0 indicates that bits[63:0] of operand \a X are used. \n
+///    Bit[0]=1 indicates that bits[127:64] of operand \a X are used. \n
+///    Bit[4]=0 indicates that bits[63:0] of operand \a Y are used. \n
+///    Bit[4]=1 indicates that bits[127:64] of operand \a Y are used.
+/// \returns The 128-bit integer vector containing the result of the carry-less
+///    multiplication of the selected 64-bit values.
+#define _mm_clmulepi64_si128(X, Y, I) \
+  ((__m128i)__builtin_ia32_pclmulqdq128((__v2di)(__m128i)(X), \
+                                        (__v2di)(__m128i)(Y), (char)(I)))
+
+#endif /* __WMMINTRIN_PCLMUL_H */
diff --git a/third_party/intel/clang/adcintrin.h b/third_party/intel/clang/adcintrin.h
new file mode 100644
index 000000000..0065a1b54
--- /dev/null
+++ b/third_party/intel/clang/adcintrin.h
@@ -0,0 +1,160 @@
+/*===---- adcintrin.h - ADC intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __ADCINTRIN_H
+#define __ADCINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__))
+
+/* Use C++ inline semantics in C++, GNU inline for C mode. */
+#if defined(__cplusplus)
+#define __INLINE __inline
+#else
+#define __INLINE static __inline
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/// Adds unsigned 32-bit integers \a __x and \a __y, plus 0 or 1 as indicated
+///    by the carry flag \a __cf. Stores the unsigned 32-bit sum in the memory
+///    at \a __p, and returns the 8-bit carry-out (carry flag).
+///
+/// \code{.operation}
+/// temp := (__cf == 0) ? 0 : 1
+/// Store32(__p, __x + __y + temp)
+/// result := CF
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c ADC instruction.
+///
+/// \param __cf
+///    The 8-bit unsigned carry flag; any non-zero value indicates carry.
+/// \param __x
+///    A 32-bit unsigned addend.
+/// \param __y
+///    A 32-bit unsigned addend.
+/// \param __p
+///    Pointer to memory for storing the sum.
+/// \returns The 8-bit unsigned carry-out value.
+__INLINE unsigned char __DEFAULT_FN_ATTRS _addcarry_u32(unsigned char __cf,
+                                                        unsigned int __x,
+                                                        unsigned int __y,
+                                                        unsigned int *__p) {
+  return __builtin_ia32_addcarryx_u32(__cf, __x, __y, __p);
+}
+
+/// Adds unsigned 32-bit integer \a __y to 0 or 1 as indicated by the carry
+///    flag \a __cf, and subtracts the result from unsigned 32-bit integer
+///    \a __x. Stores the unsigned 32-bit difference in the memory at \a __p,
+///    and returns the 8-bit carry-out (carry or overflow flag).
+///
+/// \code{.operation}
+/// temp := (__cf == 0) ? 0 : 1
+/// Store32(__p, __x - (__y + temp))
+/// result := CF
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c SBB instruction.
+///
+/// \param __cf
+///    The 8-bit unsigned carry flag; any non-zero value indicates carry.
+/// \param __x
+///    The 32-bit unsigned minuend.
+/// \param __y
+///    The 32-bit unsigned subtrahend.
+/// \param __p
+///    Pointer to memory for storing the difference.
+/// \returns The 8-bit unsigned carry-out value.
+__INLINE unsigned char __DEFAULT_FN_ATTRS _subborrow_u32(unsigned char __cf,
+                                                         unsigned int __x,
+                                                         unsigned int __y,
+                                                         unsigned int *__p) {
+  return __builtin_ia32_subborrow_u32(__cf, __x, __y, __p);
+}
+
+#ifdef __x86_64__
+/// Adds unsigned 64-bit integers \a __x and \a __y, plus 0 or 1 as indicated
+///    by the carry flag \a __cf. Stores the unsigned 64-bit sum in the memory
+///    at \a __p, and returns the 8-bit carry-out (carry flag).
+///
+/// \code{.operation}
+/// temp := (__cf == 0) ? 0 : 1
+/// Store64(__p, __x + __y + temp)
+/// result := CF
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c ADC instruction.
+///
+/// \param __cf
+///    The 8-bit unsigned carry flag; any non-zero value indicates carry.
+/// \param __x
+///    A 64-bit unsigned addend.
+/// \param __y
+///    A 64-bit unsigned addend.
+/// \param __p
+///    Pointer to memory for storing the sum.
+/// \returns The 8-bit unsigned carry-out value.
+__INLINE unsigned char __DEFAULT_FN_ATTRS
+_addcarry_u64(unsigned char __cf, unsigned long long __x,
+              unsigned long long __y, unsigned long long *__p) {
+  return __builtin_ia32_addcarryx_u64(__cf, __x, __y, __p);
+}
+
+/// Adds unsigned 64-bit integer \a __y to 0 or 1 as indicated by the carry
+///    flag \a __cf, and subtracts the result from unsigned 64-bit integer
+///    \a __x. Stores the unsigned 64-bit difference in the memory at \a __p,
+///    and returns the 8-bit carry-out (carry or overflow flag).
+///
+/// \code{.operation}
+/// temp := (__cf == 0) ? 0 : 1
+/// Store64(__p, __x - (__y + temp))
+/// result := CF
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c ADC instruction.
+///
+/// \param __cf
+///    The 8-bit unsigned carry flag; any non-zero value indicates carry.
+/// \param __x
+///    The 64-bit unsigned minuend.
+/// \param __y
+///    The 64-bit unsigned subtrahend.
+/// \param __p
+///    Pointer to memory for storing the difference.
+/// \returns The 8-bit unsigned carry-out value.
+__INLINE unsigned char __DEFAULT_FN_ATTRS
+_subborrow_u64(unsigned char __cf, unsigned long long __x,
+               unsigned long long __y, unsigned long long *__p) {
+  return __builtin_ia32_subborrow_u64(__cf, __x, __y, __p);
+}
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#undef __INLINE
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __ADCINTRIN_H */
diff --git a/third_party/intel/clang/adxintrin.h b/third_party/intel/clang/adxintrin.h
new file mode 100644
index 000000000..bc6a4caf3
--- /dev/null
+++ b/third_party/intel/clang/adxintrin.h
@@ -0,0 +1,102 @@
+/*===---- adxintrin.h - ADX intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <adxintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __ADXINTRIN_H
+#define __ADXINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__, __target__("adx")))
+
+/* Use C++ inline semantics in C++, GNU inline for C mode. */
+#if defined(__cplusplus)
+#define __INLINE __inline
+#else
+#define __INLINE static __inline
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* Intrinsics that are available only if __ADX__ is defined. */
+
+/// Adds unsigned 32-bit integers \a __x and \a __y, plus 0 or 1 as indicated
+///    by the carry flag \a __cf. Stores the unsigned 32-bit sum in the memory
+///    at \a __p, and returns the 8-bit carry-out (carry flag).
+///
+/// \code{.operation}
+/// temp := (__cf == 0) ? 0 : 1
+/// Store32(__p, __x + __y + temp)
+/// result := CF
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c ADCX instruction.
+///
+/// \param __cf
+///    The 8-bit unsigned carry flag; any non-zero value indicates carry.
+/// \param __x
+///    A 32-bit unsigned addend.
+/// \param __y
+///    A 32-bit unsigned addend.
+/// \param __p
+///    Pointer to memory for storing the sum.
+/// \returns The 8-bit unsigned carry-out value.
+__INLINE unsigned char __DEFAULT_FN_ATTRS _addcarryx_u32(unsigned char __cf,
+                                                         unsigned int __x,
+                                                         unsigned int __y,
+                                                         unsigned int *__p) {
+  return __builtin_ia32_addcarryx_u32(__cf, __x, __y, __p);
+}
+
+#ifdef __x86_64__
+/// Adds unsigned 64-bit integers \a __x and \a __y, plus 0 or 1 as indicated
+///    by the carry flag \a __cf. Stores the unsigned 64-bit sum in the memory
+///    at \a __p, and returns the 8-bit carry-out (carry flag).
+///
+/// \code{.operation}
+/// temp := (__cf == 0) ? 0 : 1
+/// Store64(__p, __x + __y + temp)
+/// result := CF
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c ADCX instruction.
+///
+/// \param __cf
+///    The 8-bit unsigned carry flag; any non-zero value indicates carry.
+/// \param __x
+///    A 64-bit unsigned addend.
+/// \param __y
+///    A 64-bit unsigned addend.
+/// \param __p
+///    Pointer to memory for storing the sum.
+/// \returns The 8-bit unsigned carry-out value.
+__INLINE unsigned char __DEFAULT_FN_ATTRS
+_addcarryx_u64(unsigned char __cf, unsigned long long __x,
+               unsigned long long __y, unsigned long long *__p) {
+  return __builtin_ia32_addcarryx_u64(__cf, __x, __y, __p);
+}
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#undef __INLINE
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __ADXINTRIN_H */
diff --git a/third_party/intel/clang/ammintrin.h b/third_party/intel/clang/ammintrin.h
new file mode 100644
index 000000000..edf08e8c5
--- /dev/null
+++ b/third_party/intel/clang/ammintrin.h
@@ -0,0 +1,183 @@
+/*===---- ammintrin.h - SSE4a intrinsics -----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __AMMINTRIN_H
+#define __AMMINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+#include "pmmintrin.h"
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse4a"), __min_vector_width__(128)))
+
+/// Extracts the specified bits from the lower 64 bits of the 128-bit
+///    integer vector operand at the index \a idx and of the length \a len.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_extracti_si64(__m128i x, const int len, const int idx);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> EXTRQ </c> instruction.
+///
+/// \param x
+///    The value from which bits are extracted.
+/// \param len
+///    Bits [5:0] specify the length; the other bits are ignored. If bits [5:0]
+///    are zero, the length is interpreted as 64.
+/// \param idx
+///    Bits [5:0] specify the index of the least significant bit; the other
+///    bits are ignored. If the sum of the index and length is greater than 64,
+///    the result is undefined. If the length and index are both zero, bits
+///    [63:0] of parameter \a x are extracted. If the length is zero but the
+///    index is non-zero, the result is undefined.
+/// \returns A 128-bit integer vector whose lower 64 bits contain the bits
+///    extracted from the source operand.
+#define _mm_extracti_si64(x, len, idx) \
+  ((__m128i)__builtin_ia32_extrqi((__v2di)(__m128i)(x), \
+                                  (char)(len), (char)(idx)))
+
+/// Extracts the specified bits from the lower 64 bits of the 128-bit
+///    integer vector operand at the index and of the length specified by
+///    \a __y.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> EXTRQ </c> instruction.
+///
+/// \param __x
+///    The value from which bits are extracted.
+/// \param __y
+///    Specifies the index of the least significant bit at [13:8] and the
+///    length at [5:0]; all other bits are ignored. If bits [5:0] are zero, the
+///    length is interpreted as 64. If the sum of the index and length is
+///    greater than 64, the result is undefined. If the length and index are
+///    both zero, bits [63:0] of parameter \a __x are extracted. If the length
+///    is zero but the index is non-zero, the result is undefined.
+/// \returns A 128-bit vector whose lower 64 bits contain the bits extracted
+///    from the source operand.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_extract_si64(__m128i __x, __m128i __y)
+{
+  return (__m128i)__builtin_ia32_extrq((__v2di)__x, (__v16qi)__y);
+}
+
+/// Inserts bits of a specified length from the source integer vector
+///    \a y into the lower 64 bits of the destination integer vector \a x at
+///    the index \a idx and of the length \a len.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_inserti_si64(__m128i x, __m128i y, const int len,
+/// const int idx);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> INSERTQ </c> instruction.
+///
+/// \param x
+///    The destination operand where bits will be inserted. The inserted bits
+///    are defined by the length \a len and by the index \a idx specifying the
+///    least significant bit.
+/// \param y
+///    The source operand containing the bits to be extracted. The extracted
+///    bits are the least significant bits of operand \a y of length \a len.
+/// \param len
+///    Bits [5:0] specify the length; the other bits are ignored. If bits [5:0]
+///    are zero, the length is interpreted as 64.
+/// \param idx
+///    Bits [5:0] specify the index of the least significant bit; the other
+///    bits are ignored. If the sum of the index and length is greater than 64,
+///    the result is undefined. If the length and index are both zero, bits
+///    [63:0] of parameter \a y are inserted into parameter \a x. If the length
+///    is zero but the index is non-zero, the result is undefined.
+/// \returns A 128-bit integer vector containing the original lower 64-bits of
+///    destination operand \a x with the specified bitfields replaced by the
+///    lower bits of source operand \a y. The upper 64 bits of the return value
+///    are undefined.
+#define _mm_inserti_si64(x, y, len, idx) \
+  ((__m128i)__builtin_ia32_insertqi((__v2di)(__m128i)(x), \
+                                    (__v2di)(__m128i)(y), \
+                                    (char)(len), (char)(idx)))
+
+/// Inserts bits of a specified length from the source integer vector
+///    \a __y into the lower 64 bits of the destination integer vector \a __x
+///    at the index and of the length specified by \a __y.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> INSERTQ </c> instruction.
+///
+/// \param __x
+///    The destination operand where bits will be inserted. The inserted bits
+///    are defined by the length and by the index of the least significant bit
+///    specified by operand \a __y.
+/// \param __y
+///    The source operand containing the bits to be extracted. The extracted
+///    bits are the least significant bits of operand \a __y with length
+///    specified by bits [69:64]. These are inserted into the destination at the
+///    index specified by bits [77:72]; all other bits are ignored. If bits
+///    [69:64] are zero, the length is interpreted as 64. If the sum of the
+///    index and length is greater than 64, the result is undefined. If the
+///    length and index are both zero, bits [63:0] of parameter \a __y are
+///    inserted into parameter \a __x. If the length is zero but the index is
+///    non-zero, the result is undefined.
+/// \returns A 128-bit integer vector containing the original lower 64-bits of
+///    destination operand \a __x with the specified bitfields replaced by the
+///    lower bits of source operand \a __y. The upper 64 bits of the return
+///    value are undefined.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_insert_si64(__m128i __x, __m128i __y)
+{
+  return (__m128i)__builtin_ia32_insertq((__v2di)__x, (__v2di)__y);
+}
+
+/// Stores a 64-bit double-precision value in a 64-bit memory location.
+///    To minimize caching, the data is flagged as non-temporal (unlikely to be
+///    used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVNTSD </c> instruction.
+///
+/// \param __p
+///    The 64-bit memory location used to store the register value.
+/// \param __a
+///    The 64-bit double-precision floating-point register value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_stream_sd(void *__p, __m128d __a)
+{
+  __builtin_ia32_movntsd((double *)__p, (__v2df)__a);
+}
+
+/// Stores a 32-bit single-precision floating-point value in a 32-bit
+///    memory location. To minimize caching, the data is flagged as
+///    non-temporal (unlikely to be used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVNTSS </c> instruction.
+///
+/// \param __p
+///    The 32-bit memory location used to store the register value.
+/// \param __a
+///    The 32-bit single-precision floating-point register value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_stream_ss(void *__p, __m128 __a)
+{
+  __builtin_ia32_movntss((float *)__p, (__v4sf)__a);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __AMMINTRIN_H */
diff --git a/third_party/intel/clang/amxcomplexintrin.h b/third_party/intel/clang/amxcomplexintrin.h
new file mode 100644
index 000000000..84ef972fc
--- /dev/null
+++ b/third_party/intel/clang/amxcomplexintrin.h
@@ -0,0 +1,169 @@
+/*===--------- amxcomplexintrin.h - AMXCOMPLEX intrinsics -*- C++ -*---------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===------------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <amxcomplexintrin.h> directly; include <immintrin.h> instead."
+#endif // __IMMINTRIN_H
+
+#ifndef __AMX_COMPLEXINTRIN_H
+#define __AMX_COMPLEXINTRIN_H
+#ifdef __x86_64__
+
+#define __DEFAULT_FN_ATTRS_COMPLEX                                             \
+  __attribute__((__always_inline__, __nodebug__, __target__("amx-complex")))
+
+/// Perform matrix multiplication of two tiles containing complex elements and
+///    accumulate the results into a packed single precision tile. Each dword
+///    element in input tiles \a a and \a b is interpreted as a complex number
+///    with FP16 real part and FP16 imaginary part.
+/// Calculates the imaginary part of the result. For each possible combination
+///    of (row of \a a, column of \a b), it performs a set of multiplication
+///    and accumulations on all corresponding complex numbers (one from \a a
+///    and one from \a b). The imaginary part of the \a a element is multiplied
+///    with the real part of the corresponding \a b element, and the real part
+///    of the \a a element is multiplied with the imaginary part of the
+///    corresponding \a b elements. The two accumulated results are added, and
+///    then accumulated into the corresponding row and column of \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// void _tile_cmmimfp16ps(__tile dst, __tile a, __tile b);
+/// \endcode
+///
+/// \code{.operation}
+/// FOR m := 0 TO dst.rows - 1
+///	tmp := dst.row[m]
+///	FOR k := 0 TO (a.colsb / 4) - 1
+///		FOR n := 0 TO (dst.colsb / 4) - 1
+///			tmp.fp32[n] += FP32(a.row[m].fp16[2*k+0]) * FP32(b.row[k].fp16[2*n+1])
+///			tmp.fp32[n] += FP32(a.row[m].fp16[2*k+1]) * FP32(b.row[k].fp16[2*n+0])
+///		ENDFOR
+///	ENDFOR
+///	write_row_and_zero(dst, m, tmp, dst.colsb)
+/// ENDFOR
+/// zero_upper_rows(dst, dst.rows)
+/// zero_tileconfig_start()
+/// \endcode
+///
+/// This intrinsic corresponds to the \c TCMMIMFP16PS instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param a
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param b
+///    The 2nd source tile. Max size is 1024 Bytes.
+#define _tile_cmmimfp16ps(dst, a, b) __builtin_ia32_tcmmimfp16ps(dst, a, b)
+
+/// Perform matrix multiplication of two tiles containing complex elements and
+///    accumulate the results into a packed single precision tile. Each dword
+///    element in input tiles \a a and \a b is interpreted as a complex number
+///    with FP16 real part and FP16 imaginary part.
+/// Calculates the real part of the result. For each possible combination
+///    of (row of \a a, column of \a b), it performs a set of multiplication
+///    and accumulations on all corresponding complex numbers (one from \a a
+///    and one from \a b). The real part of the \a a element is multiplied
+///    with the real part of the corresponding \a b element, and the negated
+///    imaginary part of the \a a element is multiplied with the imaginary
+///    part of the corresponding \a b elements. The two accumulated results
+///    are added, and then accumulated into the corresponding row and column
+///    of \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// void _tile_cmmrlfp16ps(__tile dst, __tile a, __tile b);
+/// \endcode
+///
+/// \code{.operation}
+/// FOR m := 0 TO dst.rows - 1
+///	tmp := dst.row[m]
+///	FOR k := 0 TO (a.colsb / 4) - 1
+///		FOR n := 0 TO (dst.colsb / 4) - 1
+///			tmp.fp32[n] += FP32(a.row[m].fp16[2*k+0]) * FP32(b.row[k].fp16[2*n+0])
+///			tmp.fp32[n] += FP32(-a.row[m].fp16[2*k+1]) * FP32(b.row[k].fp16[2*n+1])
+///		ENDFOR
+///	ENDFOR
+///	write_row_and_zero(dst, m, tmp, dst.colsb)
+/// ENDFOR
+/// zero_upper_rows(dst, dst.rows)
+/// zero_tileconfig_start()
+/// \endcode
+///
+/// This intrinsic corresponds to the \c TCMMIMFP16PS instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param a
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param b
+///    The 2nd source tile. Max size is 1024 Bytes.
+#define _tile_cmmrlfp16ps(dst, a, b) __builtin_ia32_tcmmrlfp16ps(dst, a, b)
+
+static __inline__ _tile1024i __DEFAULT_FN_ATTRS_COMPLEX
+_tile_cmmimfp16ps_internal(unsigned short m, unsigned short n, unsigned short k,
+                           _tile1024i dst, _tile1024i src1, _tile1024i src2) {
+  return __builtin_ia32_tcmmimfp16ps_internal(m, n, k, dst, src1, src2);
+}
+
+static __inline__ _tile1024i __DEFAULT_FN_ATTRS_COMPLEX
+_tile_cmmrlfp16ps_internal(unsigned short m, unsigned short n, unsigned short k,
+                           _tile1024i dst, _tile1024i src1, _tile1024i src2) {
+  return __builtin_ia32_tcmmrlfp16ps_internal(m, n, k, dst, src1, src2);
+}
+
+/// Perform matrix multiplication of two tiles containing complex elements and
+/// accumulate the results into a packed single precision tile. Each dword
+/// element in input tiles src0 and src1 is interpreted as a complex number with
+/// FP16 real part and FP16 imaginary part.
+/// This function calculates the imaginary part of the result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TCMMIMFP16PS </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+__DEFAULT_FN_ATTRS_COMPLEX
+static void __tile_cmmimfp16ps(__tile1024i *dst, __tile1024i src0,
+                               __tile1024i src1) {
+  dst->tile = _tile_cmmimfp16ps_internal(src0.row, src1.col, src0.col,
+                                         dst->tile, src0.tile, src1.tile);
+}
+
+/// Perform matrix multiplication of two tiles containing complex elements and
+/// accumulate the results into a packed single precision tile. Each dword
+/// element in input tiles src0 and src1 is interpreted as a complex number with
+/// FP16 real part and FP16 imaginary part.
+/// This function calculates the real part of the result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TCMMRLFP16PS </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+__DEFAULT_FN_ATTRS_COMPLEX
+static void __tile_cmmrlfp16ps(__tile1024i *dst, __tile1024i src0,
+                               __tile1024i src1) {
+  dst->tile = _tile_cmmrlfp16ps_internal(src0.row, src1.col, src0.col,
+                                         dst->tile, src0.tile, src1.tile);
+}
+
+#endif // __x86_64__
+#endif // __AMX_COMPLEXINTRIN_H
diff --git a/third_party/intel/clang/amxfp16intrin.h b/third_party/intel/clang/amxfp16intrin.h
new file mode 100644
index 000000000..ed798245d
--- /dev/null
+++ b/third_party/intel/clang/amxfp16intrin.h
@@ -0,0 +1,58 @@
+/*===------------- amxfp16intrin.h - AMX_FP16 intrinsics -*- C++ -*---------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===------------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <amxfp16intrin.h> directly; use <immintrin.h> instead."
+#endif /* __IMMINTRIN_H */
+
+#ifndef __AMX_FP16INTRIN_H
+#define __AMX_FP16INTRIN_H
+#ifdef __x86_64__
+
+/// Compute dot-product of FP16 (16-bit) floating-point pairs in tiles \a a
+///    and \a b, accumulating the intermediate single-precision (32-bit)
+///    floating-point elements with elements in \a dst, and store the 32-bit
+///    result back to tile \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// void _tile_dpfp16ps (__tile dst, __tile a, __tile b)
+/// \endcode
+///
+/// \code{.operation}
+/// FOR m := 0 TO dst.rows - 1
+///	tmp := dst.row[m]
+///	FOR k := 0 TO (a.colsb / 4) - 1
+///		FOR n := 0 TO (dst.colsb / 4) - 1
+///			tmp.fp32[n] += FP32(a.row[m].fp16[2*k+0]) *
+///					FP32(b.row[k].fp16[2*n+0])
+///			tmp.fp32[n] += FP32(a.row[m].fp16[2*k+1]) *
+///					FP32(b.row[k].fp16[2*n+1])
+///		ENDFOR
+///	ENDFOR
+///	write_row_and_zero(dst, m, tmp, dst.colsb)
+/// ENDFOR
+/// zero_upper_rows(dst, dst.rows)
+/// zero_tileconfig_start()
+/// \endcode
+///
+/// This intrinsic corresponds to the \c TDPFP16PS instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param a
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param b
+///    The 2nd source tile. Max size is 1024 Bytes.
+#define _tile_dpfp16ps(dst, a, b)                                \
+  __builtin_ia32_tdpfp16ps(dst, a, b)
+
+#endif /* __x86_64__ */
+#endif /* __AMX_FP16INTRIN_H */
diff --git a/third_party/intel/clang/amxintrin.h b/third_party/intel/clang/amxintrin.h
new file mode 100644
index 000000000..baa56f5b2
--- /dev/null
+++ b/third_party/intel/clang/amxintrin.h
@@ -0,0 +1,524 @@
+/*===--------------- amxintrin.h - AMX intrinsics -*- C/C++ -*---------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===------------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <amxintrin.h> directly; include <immintrin.h> instead."
+#endif /* __IMMINTRIN_H */
+
+#ifndef __AMXINTRIN_H
+#define __AMXINTRIN_H
+#ifdef __x86_64__
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS_TILE                                                \
+  __attribute__((__always_inline__, __nodebug__, __target__("amx-tile")))
+#define __DEFAULT_FN_ATTRS_INT8                                                \
+  __attribute__((__always_inline__, __nodebug__, __target__("amx-int8")))
+#define __DEFAULT_FN_ATTRS_BF16                                                \
+  __attribute__((__always_inline__, __nodebug__, __target__("amx-bf16")))
+#define __DEFAULT_FN_ATTRS_FP16                                                \
+  __attribute__((__always_inline__, __nodebug__, __target__("amx-fp16")))
+
+/// Load tile configuration from a 64-byte memory location specified by
+/// "mem_addr". The tile configuration includes the tile type palette, the
+/// number of bytes per row, and the number of rows. If the specified
+/// palette_id is zero, that signifies the init state for both the tile
+/// config and the tile data, and the tiles are zeroed. Any invalid
+/// configurations will result in #GP fault.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> LDTILECFG </c> instruction.
+///
+/// \param __config
+///    A pointer to 512-bits configuration
+static __inline__ void __DEFAULT_FN_ATTRS_TILE
+_tile_loadconfig(const void *__config) {
+  __builtin_ia32_tile_loadconfig(__config);
+}
+
+/// Stores the current tile configuration to a 64-byte memory location
+/// specified by "mem_addr". The tile configuration includes the tile type
+/// palette, the number of bytes per row, and the number of rows. If tiles
+/// are not configured, all zeroes will be stored to memory.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> STTILECFG </c> instruction.
+///
+/// \param __config
+///    A pointer to 512-bits configuration
+static __inline__ void __DEFAULT_FN_ATTRS_TILE
+_tile_storeconfig(void *__config) {
+  __builtin_ia32_tile_storeconfig(__config);
+}
+
+/// Release the tile configuration to return to the init state, which
+/// releases all storage it currently holds.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TILERELEASE </c> instruction.
+static __inline__ void __DEFAULT_FN_ATTRS_TILE _tile_release(void) {
+  __builtin_ia32_tilerelease();
+}
+
+/// Load tile rows from memory specifieid by "base" address and "stride" into
+/// destination tile "dst" using the tile configuration previously configured
+/// via "_tile_loadconfig".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TILELOADD </c> instruction.
+///
+/// \param dst
+///    A destination tile. Max size is 1024 Bytes.
+/// \param base
+///    A pointer to base address.
+/// \param stride
+///    The stride between the rows' data to be loaded in memory.
+#define _tile_loadd(dst, base, stride)                                         \
+  __builtin_ia32_tileloadd64((dst), ((const void *)(base)),                    \
+                             (__SIZE_TYPE__)(stride))
+
+/// Load tile rows from memory specifieid by "base" address and "stride" into
+/// destination tile "dst" using the tile configuration previously configured
+/// via "_tile_loadconfig". This intrinsic provides a hint to the implementation
+/// that the data will likely not be reused in the near future and the data
+/// caching can be optimized accordingly.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TILELOADDT1 </c> instruction.
+///
+/// \param dst
+///    A destination tile. Max size is 1024 Bytes.
+/// \param base
+///    A pointer to base address.
+/// \param stride
+///    The stride between the rows' data to be loaded in memory.
+#define _tile_stream_loadd(dst, base, stride)                                  \
+  __builtin_ia32_tileloaddt164((dst), ((const void *)(base)),                  \
+                               (__SIZE_TYPE__)(stride))
+
+/// Store the tile specified by "src" to memory specifieid by "base" address and
+/// "stride" using the tile configuration previously configured via
+/// "_tile_loadconfig".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TILESTORED </c> instruction.
+///
+/// \param dst
+///    A destination tile. Max size is 1024 Bytes.
+/// \param base
+///    A pointer to base address.
+/// \param stride
+///    The stride between the rows' data to be stored in memory.
+#define _tile_stored(dst, base, stride)                                        \
+  __builtin_ia32_tilestored64((dst), ((void *)(base)), (__SIZE_TYPE__)(stride))
+
+/// Zero the tile specified by "tdest".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TILEZERO </c> instruction.
+///
+/// \param tile
+///    The destination tile to be zero. Max size is 1024 Bytes.
+#define _tile_zero(tile) __builtin_ia32_tilezero((tile))
+
+/// Compute dot-product of bytes in tiles with a source/destination accumulator.
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in src0 with
+/// corresponding signed 8-bit integers in src1, producing 4 intermediate 32-bit
+/// results. Sum these 4 results with the corresponding 32-bit integer in "dst",
+/// and store the 32-bit result back to tile "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPBSSD </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+#define _tile_dpbssd(dst, src0, src1)                                          \
+  __builtin_ia32_tdpbssd((dst), (src0), (src1))
+
+/// Compute dot-product of bytes in tiles with a source/destination accumulator.
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in src0 with
+/// corresponding unsigned 8-bit integers in src1, producing 4 intermediate
+/// 32-bit results. Sum these 4 results with the corresponding 32-bit integer
+/// in "dst", and store the 32-bit result back to tile "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPBSUD </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+#define _tile_dpbsud(dst, src0, src1)                                          \
+  __builtin_ia32_tdpbsud((dst), (src0), (src1))
+
+/// Compute dot-product of bytes in tiles with a source/destination accumulator.
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in src0 with
+/// corresponding signed 8-bit integers in src1, producing 4 intermediate 32-bit
+/// results. Sum these 4 results with the corresponding 32-bit integer in "dst",
+/// and store the 32-bit result back to tile "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPBUSD </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+#define _tile_dpbusd(dst, src0, src1)                                          \
+  __builtin_ia32_tdpbusd((dst), (src0), (src1))
+
+/// Compute dot-product of bytes in tiles with a source/destination accumulator.
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in src0 with
+/// corresponding unsigned 8-bit integers in src1, producing 4 intermediate
+/// 32-bit results. Sum these 4 results with the corresponding 32-bit integer in
+/// "dst", and store the 32-bit result back to tile "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPBUUD </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+#define _tile_dpbuud(dst, src0, src1)                                          \
+  __builtin_ia32_tdpbuud((dst), (src0), (src1))
+
+/// Compute dot-product of BF16 (16-bit) floating-point pairs in tiles src0 and
+/// src1, accumulating the intermediate single-precision (32-bit) floating-point
+/// elements with elements in "dst", and store the 32-bit result back to tile
+/// "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPBF16PS </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+#define _tile_dpbf16ps(dst, src0, src1)                                        \
+  __builtin_ia32_tdpbf16ps((dst), (src0), (src1))
+
+/// AMX tile register size can be configured, the maximum size is 16x64=1024
+/// bytes. Since there is no 2D type in llvm IR, we use vector type to
+/// represent 2D tile and the fixed size is maximum amx tile register size.
+typedef int _tile1024i __attribute__((__vector_size__(1024), __aligned__(64)));
+
+/// This is internal intrinsic. C/C++ user should avoid calling it directly.
+static __inline__ _tile1024i __DEFAULT_FN_ATTRS_INT8
+_tile_loadd_internal(unsigned short m, unsigned short n, const void *base,
+                     __SIZE_TYPE__ stride) {
+  return __builtin_ia32_tileloadd64_internal(m, n, base,
+                                             (__SIZE_TYPE__)(stride));
+}
+
+/// This is internal intrinsic. C/C++ user should avoid calling it directly.
+static __inline__ _tile1024i __DEFAULT_FN_ATTRS_INT8
+_tile_loaddt1_internal(unsigned short m, unsigned short n, const void *base,
+                       __SIZE_TYPE__ stride) {
+  return __builtin_ia32_tileloaddt164_internal(m, n, base,
+                                               (__SIZE_TYPE__)(stride));
+}
+
+/// This is internal intrinsic. C/C++ user should avoid calling it directly.
+static __inline__ _tile1024i __DEFAULT_FN_ATTRS_INT8
+_tile_dpbssd_internal(unsigned short m, unsigned short n, unsigned short k,
+                      _tile1024i dst, _tile1024i src1, _tile1024i src2) {
+  return __builtin_ia32_tdpbssd_internal(m, n, k, dst, src1, src2);
+}
+
+/// This is internal intrinsic. C/C++ user should avoid calling it directly.
+static __inline__ _tile1024i __DEFAULT_FN_ATTRS_INT8
+_tile_dpbsud_internal(unsigned short m, unsigned short n, unsigned short k,
+                      _tile1024i dst, _tile1024i src1, _tile1024i src2) {
+  return __builtin_ia32_tdpbsud_internal(m, n, k, dst, src1, src2);
+}
+
+/// This is internal intrinsic. C/C++ user should avoid calling it directly.
+static __inline__ _tile1024i __DEFAULT_FN_ATTRS_INT8
+_tile_dpbusd_internal(unsigned short m, unsigned short n, unsigned short k,
+                      _tile1024i dst, _tile1024i src1, _tile1024i src2) {
+  return __builtin_ia32_tdpbusd_internal(m, n, k, dst, src1, src2);
+}
+
+/// This is internal intrinsic. C/C++ user should avoid calling it directly.
+static __inline__ _tile1024i __DEFAULT_FN_ATTRS_INT8
+_tile_dpbuud_internal(unsigned short m, unsigned short n, unsigned short k,
+                      _tile1024i dst, _tile1024i src1, _tile1024i src2) {
+  return __builtin_ia32_tdpbuud_internal(m, n, k, dst, src1, src2);
+}
+
+/// This is internal intrinsic. C/C++ user should avoid calling it directly.
+static __inline__ void __DEFAULT_FN_ATTRS_INT8
+_tile_stored_internal(unsigned short m, unsigned short n, void *base,
+                      __SIZE_TYPE__ stride, _tile1024i tile) {
+  return __builtin_ia32_tilestored64_internal(m, n, base,
+                                              (__SIZE_TYPE__)(stride), tile);
+}
+
+/// This is internal intrinsic. C/C++ user should avoid calling it directly.
+static __inline__ _tile1024i __DEFAULT_FN_ATTRS_BF16
+_tile_dpbf16ps_internal(unsigned short m, unsigned short n, unsigned short k,
+                        _tile1024i dst, _tile1024i src1, _tile1024i src2) {
+  return __builtin_ia32_tdpbf16ps_internal(m, n, k, dst, src1, src2);
+}
+
+/// This is internal intrinsic. C/C++ user should avoid calling it directly.
+static __inline__ _tile1024i __DEFAULT_FN_ATTRS_FP16
+_tile_dpfp16ps_internal(unsigned short m, unsigned short n, unsigned short k,
+                        _tile1024i dst, _tile1024i src1, _tile1024i src2) {
+  return __builtin_ia32_tdpfp16ps_internal(m, n, k, dst, src1, src2);
+}
+
+/// This struct pack the shape and tile data together for user. We suggest
+/// initializing the struct as early as possible, because compiler depends
+/// on the shape information to do configure. The constant value is preferred
+/// for optimization by compiler.
+typedef struct __tile1024i_str {
+  const unsigned short row;
+  const unsigned short col;
+  _tile1024i tile;
+} __tile1024i;
+
+/// Load tile rows from memory specifieid by "base" address and "stride" into
+/// destination tile "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TILELOADD </c> instruction.
+///
+/// \param dst
+///    A destination tile. Max size is 1024 Bytes.
+/// \param base
+///    A pointer to base address.
+/// \param stride
+///    The stride between the rows' data to be loaded in memory.
+__DEFAULT_FN_ATTRS_TILE
+static __inline__ void __tile_loadd(__tile1024i *dst, const void *base,
+                                    __SIZE_TYPE__ stride) {
+  dst->tile = _tile_loadd_internal(dst->row, dst->col, base, stride);
+}
+
+/// Load tile rows from memory specifieid by "base" address and "stride" into
+/// destination tile "dst". This intrinsic provides a hint to the implementation
+/// that the data will likely not be reused in the near future and the data
+/// caching can be optimized accordingly.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TILELOADDT1 </c> instruction.
+///
+/// \param dst
+///    A destination tile. Max size is 1024 Bytes.
+/// \param base
+///    A pointer to base address.
+/// \param stride
+///    The stride between the rows' data to be loaded in memory.
+__DEFAULT_FN_ATTRS_TILE
+static __inline__ void __tile_stream_loadd(__tile1024i *dst, const void *base,
+                                           __SIZE_TYPE__ stride) {
+  dst->tile = _tile_loaddt1_internal(dst->row, dst->col, base, stride);
+}
+
+/// Compute dot-product of bytes in tiles with a source/destination accumulator.
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in src0 with
+/// corresponding signed 8-bit integers in src1, producing 4 intermediate 32-bit
+/// results. Sum these 4 results with the corresponding 32-bit integer in "dst",
+/// and store the 32-bit result back to tile "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPBSSD </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+__DEFAULT_FN_ATTRS_INT8
+static __inline__ void __tile_dpbssd(__tile1024i *dst, __tile1024i src0,
+                                     __tile1024i src1) {
+  dst->tile = _tile_dpbssd_internal(src0.row, src1.col, src0.col, dst->tile,
+                                    src0.tile, src1.tile);
+}
+
+/// Compute dot-product of bytes in tiles with a source/destination accumulator.
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in src0 with
+/// corresponding unsigned 8-bit integers in src1, producing 4 intermediate
+/// 32-bit results. Sum these 4 results with the corresponding 32-bit integer
+/// in "dst", and store the 32-bit result back to tile "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPBSUD </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+__DEFAULT_FN_ATTRS_INT8
+static __inline__ void __tile_dpbsud(__tile1024i *dst, __tile1024i src0,
+                                     __tile1024i src1) {
+  dst->tile = _tile_dpbsud_internal(src0.row, src1.col, src0.col, dst->tile,
+                                    src0.tile, src1.tile);
+}
+
+/// Compute dot-product of bytes in tiles with a source/destination accumulator.
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in src0 with
+/// corresponding signed 8-bit integers in src1, producing 4 intermediate 32-bit
+/// results. Sum these 4 results with the corresponding 32-bit integer in "dst",
+/// and store the 32-bit result back to tile "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPBUSD </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+__DEFAULT_FN_ATTRS_INT8
+static __inline__ void __tile_dpbusd(__tile1024i *dst, __tile1024i src0,
+                                     __tile1024i src1) {
+  dst->tile = _tile_dpbusd_internal(src0.row, src1.col, src0.col, dst->tile,
+                                    src0.tile, src1.tile);
+}
+
+/// Compute dot-product of bytes in tiles with a source/destination accumulator.
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in src0 with
+/// corresponding unsigned 8-bit integers in src1, producing 4 intermediate
+/// 32-bit results. Sum these 4 results with the corresponding 32-bit integer in
+/// "dst", and store the 32-bit result back to tile "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPBUUD </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+__DEFAULT_FN_ATTRS_INT8
+static __inline__ void __tile_dpbuud(__tile1024i *dst, __tile1024i src0,
+                                     __tile1024i src1) {
+  dst->tile = _tile_dpbuud_internal(src0.row, src1.col, src0.col, dst->tile,
+                                    src0.tile, src1.tile);
+}
+
+/// Store the tile specified by "src" to memory specifieid by "base" address and
+/// "stride".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TILESTORED </c> instruction.
+///
+/// \param base
+///    A pointer to base address.
+/// \param stride
+///    The stride between the rows' data to be stored in memory.
+__DEFAULT_FN_ATTRS_TILE
+static __inline__ void __tile_stored(void *base, __SIZE_TYPE__ stride,
+                                     __tile1024i src) {
+  _tile_stored_internal(src.row, src.col, base, stride, src.tile);
+}
+
+/// Zero the tile specified by "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TILEZERO </c> instruction.
+///
+/// \param dst
+///    The destination tile to be zero. Max size is 1024 Bytes.
+__DEFAULT_FN_ATTRS_TILE
+static __inline__ void __tile_zero(__tile1024i *dst) {
+  dst->tile = __builtin_ia32_tilezero_internal(dst->row, dst->col);
+}
+
+/// Compute dot-product of BF16 (16-bit) floating-point pairs in tiles src0 and
+/// src1, accumulating the intermediate single-precision (32-bit) floating-point
+/// elements with elements in "dst", and store the 32-bit result back to tile
+/// "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPBF16PS </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+__DEFAULT_FN_ATTRS_BF16
+static __inline__ void __tile_dpbf16ps(__tile1024i *dst, __tile1024i src0,
+                                       __tile1024i src1) {
+  dst->tile = _tile_dpbf16ps_internal(src0.row, src1.col, src0.col, dst->tile,
+                                      src0.tile, src1.tile);
+}
+
+/// Compute dot-product of FP16 (16-bit) floating-point pairs in tiles src0 and
+/// src1, accumulating the intermediate single-precision (32-bit) floating-point
+/// elements with elements in "dst", and store the 32-bit result back to tile
+/// "dst".
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> TDPFP16PS </c> instruction.
+///
+/// \param dst
+///    The destination tile. Max size is 1024 Bytes.
+/// \param src0
+///    The 1st source tile. Max size is 1024 Bytes.
+/// \param src1
+///    The 2nd source tile. Max size is 1024 Bytes.
+__DEFAULT_FN_ATTRS_FP16
+static __inline__ void __tile_dpfp16ps(__tile1024i *dst, __tile1024i src0,
+                                       __tile1024i src1) {
+  dst->tile = _tile_dpfp16ps_internal(src0.row, src1.col, src0.col, dst->tile,
+                                      src0.tile, src1.tile);
+}
+
+#undef __DEFAULT_FN_ATTRS_TILE
+#undef __DEFAULT_FN_ATTRS_INT8
+#undef __DEFAULT_FN_ATTRS_BF16
+#undef __DEFAULT_FN_ATTRS_FP16
+
+#endif /* __x86_64__ */
+#endif /* __AMXINTRIN_H */
diff --git a/third_party/intel/clang/avx2intrin.h b/third_party/intel/clang/avx2intrin.h
new file mode 100644
index 000000000..096cae01b
--- /dev/null
+++ b/third_party/intel/clang/avx2intrin.h
@@ -0,0 +1,5284 @@
+/*===---- avx2intrin.h - AVX2 intrinsics -----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <avx2intrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX2INTRIN_H
+#define __AVX2INTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx2,no-evex512"), __min_vector_width__(256)))
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx2,no-evex512"), __min_vector_width__(128)))
+
+/* SSE4 Multiple Packed Sums of Absolute Difference.  */
+/// Computes sixteen sum of absolute difference (SAD) operations on sets of
+///    four unsigned 8-bit integers from the 256-bit integer vectors \a X and
+///    \a Y.
+///
+///    Eight SAD results are computed using the lower half of the input
+///    vectors, and another eight using the upper half. These 16-bit values
+///    are returned in the lower and upper halves of the 256-bit result,
+///    respectively.
+///
+///    A single SAD operation selects four bytes from \a X and four bytes from
+///    \a Y as input. It computes the differences between each \a X byte and
+///    the corresponding \a Y byte, takes the absolute value of each
+///    difference, and sums these four values to form one 16-bit result. The
+///    intrinsic computes 16 of these results with different sets of input
+///    bytes.
+///
+///    For each set of eight results, the SAD operations use the same four
+///    bytes from \a Y; the starting bit position for these four bytes is
+///    specified by \a M[1:0] times 32. The eight operations use successive
+///    sets of four bytes from \a X; the starting bit position for the first
+///    set of four bytes is specified by \a M[2] times 32. These bit positions
+///    are all relative to the 128-bit lane for each set of eight operations.
+///
+/// \code{.operation}
+/// r := 0
+/// FOR i := 0 TO 1
+///   j := i*3
+///   Ybase := M[j+1:j]*32 + i*128
+///   Xbase := M[j+2]*32 + i*128
+///   FOR k := 0 TO 3
+///     temp0 := ABS(X[Xbase+7:Xbase] - Y[Ybase+7:Ybase])
+///     temp1 := ABS(X[Xbase+15:Xbase+8] - Y[Ybase+15:Ybase+8])
+///     temp2 := ABS(X[Xbase+23:Xbase+16] - Y[Ybase+23:Ybase+16])
+///     temp3 := ABS(X[Xbase+31:Xbase+24] - Y[Ybase+31:Ybase+24])
+///     result[r+15:r] := temp0 + temp1 + temp2 + temp3
+///     Xbase := Xbase + 8
+///     r := r + 16
+///   ENDFOR
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_mpsadbw_epu8(__m256i X, __m256i Y, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VMPSADBW instruction.
+///
+/// \param X
+///    A 256-bit integer vector containing one of the inputs.
+/// \param Y
+///    A 256-bit integer vector containing one of the inputs.
+/// \param M
+///     An unsigned immediate value specifying the starting positions of the
+///     bytes to operate on.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+#define _mm256_mpsadbw_epu8(X, Y, M) \
+  ((__m256i)__builtin_ia32_mpsadbw256((__v32qi)(__m256i)(X), \
+                                      (__v32qi)(__m256i)(Y), (int)(M)))
+
+/// Computes the absolute value of each signed byte in the 256-bit integer
+///    vector \a __a and returns each value in the corresponding byte of
+///    the result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPABSB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_abs_epi8(__m256i __a)
+{
+    return (__m256i)__builtin_elementwise_abs((__v32qs)__a);
+}
+
+/// Computes the absolute value of each signed 16-bit element in the 256-bit
+///    vector of [16 x i16] in \a __a and returns each value in the
+///    corresponding element of the result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPABSW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16].
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_abs_epi16(__m256i __a)
+{
+    return (__m256i)__builtin_elementwise_abs((__v16hi)__a);
+}
+
+/// Computes the absolute value of each signed 32-bit element in the 256-bit
+///    vector of [8 x i32] in \a __a and returns each value in the
+///    corresponding element of the result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPABSD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32].
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_abs_epi32(__m256i __a)
+{
+    return (__m256i)__builtin_elementwise_abs((__v8si)__a);
+}
+
+/// Converts the elements of two 256-bit vectors of [16 x i16] to 8-bit
+///    integers using signed saturation, and returns the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*16
+///   k := i*8
+///   result[7+k:k] := SATURATE8(__a[15+j:j])
+///   result[71+k:64+k] := SATURATE8(__b[15+j:j])
+///   result[135+k:128+k] := SATURATE8(__a[143+j:128+j])
+///   result[199+k:192+k] := SATURATE8(__b[143+j:128+j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPACKSSWB instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] used to generate result[63:0] and
+///    result[191:128].
+/// \param __b
+///    A 256-bit vector of [16 x i16] used to generate result[127:64] and
+///    result[255:192].
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_packs_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_packsswb256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Converts the elements of two 256-bit vectors of [8 x i32] to 16-bit
+///    integers using signed saturation, and returns the resulting 256-bit
+///    vector of [16 x i16].
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*32
+///   k := i*16
+///   result[15+k:k] := SATURATE16(__a[31+j:j])
+///   result[79+k:64+k] := SATURATE16(__b[31+j:j])
+///   result[143+k:128+k] := SATURATE16(__a[159+j:128+j])
+///   result[207+k:192+k] := SATURATE16(__b[159+j:128+j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPACKSSDW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] used to generate result[63:0] and
+///    result[191:128].
+/// \param __b
+///    A 256-bit vector of [8 x i32] used to generate result[127:64] and
+///    result[255:192].
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_packs_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_packssdw256((__v8si)__a, (__v8si)__b);
+}
+
+/// Converts elements from two 256-bit vectors of [16 x i16] to 8-bit integers
+///    using unsigned saturation, and returns the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*16
+///   k := i*8
+///   result[7+k:k] := SATURATE8U(__a[15+j:j])
+///   result[71+k:64+k] := SATURATE8U(__b[15+j:j])
+///   result[135+k:128+k] := SATURATE8U(__a[143+j:128+j])
+///   result[199+k:192+k] := SATURATE8U(__b[143+j:128+j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPACKUSWB instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] used to generate result[63:0] and
+///    result[191:128].
+/// \param __b
+///    A 256-bit vector of [16 x i16] used to generate result[127:64] and
+///    result[255:192].
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_packus_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_packuswb256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Converts elements from two 256-bit vectors of [8 x i32] to 16-bit integers
+///    using unsigned saturation, and returns the resulting 256-bit vector of
+///    [16 x i16].
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*32
+///   k := i*16
+///   result[15+k:k] := SATURATE16U(__V1[31+j:j])
+///   result[79+k:64+k] := SATURATE16U(__V2[31+j:j])
+///   result[143+k:128+k] := SATURATE16U(__V1[159+j:128+j])
+///   result[207+k:192+k] := SATURATE16U(__V2[159+j:128+j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPACKUSDW instruction.
+///
+/// \param __V1
+///    A 256-bit vector of [8 x i32] used to generate result[63:0] and
+///    result[191:128].
+/// \param __V2
+///    A 256-bit vector of [8 x i32] used to generate result[127:64] and
+///    result[255:192].
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_packus_epi32(__m256i __V1, __m256i __V2)
+{
+  return (__m256i) __builtin_ia32_packusdw256((__v8si)__V1, (__v8si)__V2);
+}
+
+/// Adds 8-bit integers from corresponding bytes of two 256-bit integer
+///    vectors and returns the lower 8 bits of each sum in the corresponding
+///    byte of the 256-bit integer vector result (overflow is ignored).
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPADDB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 256-bit integer vector containing one of the source operands.
+/// \returns A 256-bit integer vector containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_add_epi8(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v32qu)__a + (__v32qu)__b);
+}
+
+/// Adds 16-bit integers from corresponding elements of two 256-bit vectors of
+///    [16 x i16] and returns the lower 16 bits of each sum in the
+///    corresponding element of the [16 x i16] result (overflow is ignored).
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPADDW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_add_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v16hu)__a + (__v16hu)__b);
+}
+
+/// Adds 32-bit integers from corresponding elements of two 256-bit vectors of
+///    [8 x i32] and returns the lower 32 bits of each sum in the corresponding
+///    element of the [8 x i32] result (overflow is ignored).
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPADDD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \returns A 256-bit vector of [8 x i32] containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_add_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v8su)__a + (__v8su)__b);
+}
+
+/// Adds 64-bit integers from corresponding elements of two 256-bit vectors of
+///    [4 x i64] and returns the lower 64 bits of each sum in the corresponding
+///    element of the [4 x i64] result (overflow is ignored).
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPADDQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [4 x i64] containing one of the source operands.
+/// \returns A 256-bit vector of [4 x i64] containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_add_epi64(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v4du)__a + (__v4du)__b);
+}
+
+/// Adds 8-bit integers from corresponding bytes of two 256-bit integer
+///    vectors using signed saturation, and returns each sum in the
+///    corresponding byte of the 256-bit integer vector result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPADDSB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 256-bit integer vector containing one of the source operands.
+/// \returns A 256-bit integer vector containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_adds_epi8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_add_sat((__v32qs)__a, (__v32qs)__b);
+}
+
+/// Adds 16-bit integers from corresponding elements of two 256-bit vectors of
+///    [16 x i16] using signed saturation, and returns the [16 x i16] result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPADDSW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_adds_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_add_sat((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Adds 8-bit integers from corresponding bytes of two 256-bit integer
+///    vectors using unsigned saturation, and returns each sum in the
+///    corresponding byte of the 256-bit integer vector result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPADDUSB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 256-bit integer vector containing one of the source operands.
+/// \returns A 256-bit integer vector containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_adds_epu8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_add_sat((__v32qu)__a, (__v32qu)__b);
+}
+
+/// Adds 16-bit integers from corresponding elements of two 256-bit vectors of
+///    [16 x i16] using unsigned saturation, and returns the [16 x i16] result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPADDUSW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_adds_epu16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_add_sat((__v16hu)__a, (__v16hu)__b);
+}
+
+/// Uses the lower half of the 256-bit vector \a a as the upper half of a
+///    temporary 256-bit value, and the lower half of the 256-bit vector \a b
+///    as the lower half of the temporary value. Right-shifts the temporary
+///    value by \a n bytes, and uses the lower 16 bytes of the shifted value
+///    as the lower 16 bytes of the result. Uses the upper halves of \a a and
+///    \a b to make another temporary value, right shifts by \a n, and uses
+///    the lower 16 bytes of the shifted value as the upper 16 bytes of the
+///    result.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_alignr_epi8(__m256i a, __m256i b, const int n);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPALIGNR instruction.
+///
+/// \param a
+///    A 256-bit integer vector containing source values.
+/// \param b
+///    A 256-bit integer vector containing source values.
+/// \param n
+///    An immediate value specifying the number of bytes to shift.
+/// \returns A 256-bit integer vector containing the result.
+#define _mm256_alignr_epi8(a, b, n) \
+  ((__m256i)__builtin_ia32_palignr256((__v32qi)(__m256i)(a), \
+                                      (__v32qi)(__m256i)(b), (n)))
+
+/// Computes the bitwise AND of the 256-bit integer vectors in \a __a and
+///    \a __b.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPAND instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_and_si256(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v4du)__a & (__v4du)__b);
+}
+
+/// Computes the bitwise AND of the 256-bit integer vector in \a __b with
+///    the bitwise NOT of the 256-bit integer vector in \a __a.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPANDN instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_andnot_si256(__m256i __a, __m256i __b)
+{
+  return (__m256i)(~(__v4du)__a & (__v4du)__b);
+}
+
+/// Computes the averages of the corresponding unsigned bytes in the two
+///    256-bit integer vectors in \a __a and \a __b and returns each
+///    average in the corresponding byte of the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 31
+///   j := i*8
+///   result[j+7:j] := (__a[j+7:j] + __b[j+7:j] + 1) >> 1
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPAVGB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_avg_epu8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_pavgb256((__v32qi)__a, (__v32qi)__b);
+}
+
+/// Computes the averages of the corresponding unsigned 16-bit integers in
+///    the two 256-bit vectors of [16 x i16] in \a __a and \a __b and returns
+///    each average in the corresponding element of the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 15
+///   j := i*16
+///   result[j+15:j] := (__a[j+15:j] + __b[j+15:j] + 1) >> 1
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPAVGW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16].
+/// \param __b
+///    A 256-bit vector of [16 x i16].
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_avg_epu16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_pavgw256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Merges 8-bit integer values from either of the two 256-bit vectors
+///    \a __V1 or \a __V2, as specified by the 256-bit mask \a __M and returns
+///    the resulting 256-bit integer vector.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 31
+///   j := i*8
+///   IF __M[7+i] == 0
+///     result[7+j:j] := __V1[7+j:j]
+///   ELSE
+///     result[7+j:j] := __V2[7+j:j]
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPBLENDVB instruction.
+///
+/// \param __V1
+///    A 256-bit integer vector containing source values.
+/// \param __V2
+///    A 256-bit integer vector containing source values.
+/// \param __M
+///    A 256-bit integer vector, with bit [7] of each byte specifying the
+///    source for each corresponding byte of the result. When the mask bit
+///    is 0, the byte is copied from \a __V1; otherwise, it is copied from
+///    \a __V2.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_blendv_epi8(__m256i __V1, __m256i __V2, __m256i __M)
+{
+  return (__m256i)__builtin_ia32_pblendvb256((__v32qi)__V1, (__v32qi)__V2,
+                                              (__v32qi)__M);
+}
+
+/// Merges 16-bit integer values from either of the two 256-bit vectors
+///    \a V1 or \a V2, as specified by the immediate integer operand \a M,
+///    and returns the resulting 256-bit vector of [16 x i16].
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*16
+///   IF M[i] == 0
+///     result[7+j:j] := V1[7+j:j]
+///     result[135+j:128+j] := V1[135+j:128+j]
+///   ELSE
+///     result[7+j:j] := V2[7+j:j]
+///     result[135+j:128+j] := V2[135+j:128+j]
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_blend_epi16(__m256i V1, __m256i V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPBLENDW instruction.
+///
+/// \param V1
+///    A 256-bit vector of [16 x i16] containing source values.
+/// \param V2
+///    A 256-bit vector of [16 x i16] containing source values.
+/// \param M
+///    An immediate 8-bit integer operand, with bits [7:0] specifying the
+///    source for each element of the result. The position of the mask bit
+///    corresponds to the index of a copied value. When a mask bit is 0, the
+///    element is copied from \a V1; otherwise, it is copied from \a V2.
+///    \a M[0] determines the source for elements 0 and 8, \a M[1] for
+///    elements 1 and 9, and so forth.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+#define _mm256_blend_epi16(V1, V2, M) \
+  ((__m256i)__builtin_ia32_pblendw256((__v16hi)(__m256i)(V1), \
+                                      (__v16hi)(__m256i)(V2), (int)(M)))
+
+/// Compares corresponding bytes in the 256-bit integer vectors in \a __a and
+///    \a __b for equality and returns the outcomes in the corresponding
+///    bytes of the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 31
+///   j := i*8
+///   result[j+7:j] := (__a[j+7:j] == __b[j+7:j]) ? 0xFF : 0
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPCMPEQB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector containing one of the inputs.
+/// \param __b
+///    A 256-bit integer vector containing one of the inputs.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cmpeq_epi8(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v32qi)__a == (__v32qi)__b);
+}
+
+/// Compares corresponding elements in the 256-bit vectors of [16 x i16] in
+///    \a __a and \a __b for equality and returns the outcomes in the
+///    corresponding elements of the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 15
+///   j := i*16
+///   result[j+15:j] := (__a[j+15:j] == __b[j+15:j]) ? 0xFFFF : 0
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPCMPEQW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the inputs.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the inputs.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cmpeq_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v16hi)__a == (__v16hi)__b);
+}
+
+/// Compares corresponding elements in the 256-bit vectors of [8 x i32] in
+///    \a __a and \a __b for equality and returns the outcomes in the
+///    corresponding elements of the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*32
+///   result[j+31:j] := (__a[j+31:j] == __b[j+31:j]) ? 0xFFFFFFFF : 0
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPCMPEQD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] containing one of the inputs.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing one of the inputs.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cmpeq_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v8si)__a == (__v8si)__b);
+}
+
+/// Compares corresponding elements in the 256-bit vectors of [4 x i64] in
+///    \a __a and \a __b for equality and returns the outcomes in the
+///    corresponding elements of the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*64
+///   result[j+63:j] := (__a[j+63:j] == __b[j+63:j]) ? 0xFFFFFFFFFFFFFFFF : 0
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPCMPEQQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64] containing one of the inputs.
+/// \param __b
+///    A 256-bit vector of [4 x i64] containing one of the inputs.
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cmpeq_epi64(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v4di)__a == (__v4di)__b);
+}
+
+/// Compares corresponding signed bytes in the 256-bit integer vectors in
+///    \a __a and \a __b for greater-than and returns the outcomes in the
+///    corresponding bytes of the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 31
+///   j := i*8
+///   result[j+7:j] := (__a[j+7:j] > __b[j+7:j]) ? 0xFF : 0
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPCMPGTB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector containing one of the inputs.
+/// \param __b
+///    A 256-bit integer vector containing one of the inputs.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cmpgt_epi8(__m256i __a, __m256i __b)
+{
+  /* This function always performs a signed comparison, but __v32qi is a char
+     which may be signed or unsigned, so use __v32qs. */
+  return (__m256i)((__v32qs)__a > (__v32qs)__b);
+}
+
+/// Compares corresponding signed elements in the 256-bit vectors of
+///    [16 x i16] in \a __a and \a __b for greater-than and returns the
+///    outcomes in the corresponding elements of the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 15
+///   j := i*16
+///   result[j+15:j] := (__a[j+15:j] > __b[j+15:j]) ? 0xFFFF : 0
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPCMPGTW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the inputs.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the inputs.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cmpgt_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v16hi)__a > (__v16hi)__b);
+}
+
+/// Compares corresponding signed elements in the 256-bit vectors of
+///    [8 x i32] in \a __a and \a __b for greater-than and returns the
+///    outcomes in the corresponding elements of the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*32
+///   result[j+31:j] := (__a[j+31:j] > __b[j+31:j]) ? 0xFFFFFFFF : 0
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPCMPGTD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] containing one of the inputs.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing one of the inputs.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cmpgt_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v8si)__a > (__v8si)__b);
+}
+
+/// Compares corresponding signed elements in the 256-bit vectors of
+///    [4 x i64] in \a __a and \a __b for greater-than and returns the
+///    outcomes in the corresponding elements of the 256-bit result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*64
+///   result[j+63:j] := (__a[j+63:j] > __b[j+63:j]) ? 0xFFFFFFFFFFFFFFFF : 0
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPCMPGTQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64] containing one of the inputs.
+/// \param __b
+///    A 256-bit vector of [4 x i64] containing one of the inputs.
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cmpgt_epi64(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v4di)__a > (__v4di)__b);
+}
+
+/// Horizontally adds the adjacent pairs of 16-bit integers from two 256-bit
+///    vectors of [16 x i16] and returns the lower 16 bits of each sum in an
+///    element of the [16 x i16] result (overflow is ignored). Sums from
+///    \a __a are returned in the lower 64 bits of each 128-bit half of the
+///    result; sums from \a __b are returned in the upper 64 bits of each
+///    128-bit half of the result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 1
+///   j := i*128
+///   result[j+15:j] := __a[j+15:j] + __a[j+31:j+16]
+///   result[j+31:j+16] := __a[j+47:j+32] + __a[j+63:j+48]
+///   result[j+47:j+32] := __a[j+79:j+64] + __a[j+95:j+80]
+///   result[j+63:j+48] := __a[j+111:j+96] + __a[j+127:j+112]
+///   result[j+79:j+64] := __b[j+15:j] + __b[j+31:j+16]
+///   result[j+95:j+80] := __b[j+47:j+32] + __b[j+63:j+48]
+///   result[j+111:j+96] := __b[j+79:j+64] + __b[j+95:j+80]
+///   result[j+127:j+112] := __b[j+111:j+96] + __b[j+127:j+112]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPHADDW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_hadd_epi16(__m256i __a, __m256i __b)
+{
+    return (__m256i)__builtin_ia32_phaddw256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Horizontally adds the adjacent pairs of 32-bit integers from two 256-bit
+///    vectors of [8 x i32] and returns the lower 32 bits of each sum in an
+///    element of the [8 x i32] result (overflow is ignored). Sums from \a __a
+///    are returned in the lower 64 bits of each 128-bit half of the result;
+///    sums from \a __b are returned in the upper 64 bits of each 128-bit half
+///    of the result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 1
+///   j := i*128
+///   result[j+31:j] := __a[j+31:j] + __a[j+63:j+32]
+///   result[j+63:j+32] := __a[j+95:j+64] + __a[j+127:j+96]
+///   result[j+95:j+64] := __b[j+31:j] + __b[j+63:j+32]
+///   result[j+127:j+96] := __b[j+95:j+64] + __b[j+127:j+96]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPHADDD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \returns A 256-bit vector of [8 x i32] containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_hadd_epi32(__m256i __a, __m256i __b)
+{
+    return (__m256i)__builtin_ia32_phaddd256((__v8si)__a, (__v8si)__b);
+}
+
+/// Horizontally adds the adjacent pairs of 16-bit integers from two 256-bit
+///    vectors of [16 x i16] using signed saturation and returns each sum in
+///    an element of the [16 x i16] result. Sums from \a __a are returned in
+///    the lower 64 bits of each 128-bit half of the result; sums from \a __b
+///    are returned in the upper 64 bits of each 128-bit half of the result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 1
+///   j := i*128
+///   result[j+15:j] := SATURATE16(__a[j+15:j] + __a[j+31:j+16])
+///   result[j+31:j+16] := SATURATE16(__a[j+47:j+32] + __a[j+63:j+48])
+///   result[j+47:j+32] := SATURATE16(__a[j+79:j+64] + __a[j+95:j+80])
+///   result[j+63:j+48] := SATURATE16(__a[j+111:j+96] + __a[j+127:j+112])
+///   result[j+79:j+64] := SATURATE16(__b[j+15:j] + __b[j+31:j+16])
+///   result[j+95:j+80] := SATURATE16(__b[j+47:j+32] + __b[j+63:j+48])
+///   result[j+111:j+96] := SATURATE16(__b[j+79:j+64] + __b[j+95:j+80])
+///   result[j+127:j+112] := SATURATE16(__b[j+111:j+96] + __b[j+127:j+112])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPHADDSW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the sums.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_hadds_epi16(__m256i __a, __m256i __b)
+{
+    return (__m256i)__builtin_ia32_phaddsw256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Horizontally subtracts adjacent pairs of 16-bit integers from two 256-bit
+///    vectors of [16 x i16] and returns the lower 16 bits of each difference
+///    in an element of the [16 x i16] result (overflow is ignored).
+///    Differences from \a __a are returned in the lower 64 bits of each
+///    128-bit half of the result; differences from \a __b are returned in the
+///    upper 64 bits of each 128-bit half of the result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 1
+///   j := i*128
+///   result[j+15:j] := __a[j+15:j] - __a[j+31:j+16]
+///   result[j+31:j+16] := __a[j+47:j+32] - __a[j+63:j+48]
+///   result[j+47:j+32] := __a[j+79:j+64] - __a[j+95:j+80]
+///   result[j+63:j+48] := __a[j+111:j+96] - __a[j+127:j+112]
+///   result[j+79:j+64] := __b[j+15:j] - __b[j+31:j+16]
+///   result[j+95:j+80] := __b[j+47:j+32] - __b[j+63:j+48]
+///   result[j+111:j+96] := __b[j+79:j+64] - __b[j+95:j+80]
+///   result[j+127:j+112] := __b[j+111:j+96] - __b[j+127:j+112]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPHSUBW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_hsub_epi16(__m256i __a, __m256i __b)
+{
+    return (__m256i)__builtin_ia32_phsubw256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Horizontally subtracts adjacent pairs of 32-bit integers from two 256-bit
+///    vectors of [8 x i32] and returns the lower 32 bits of each difference in
+///    an element of the [8 x i32] result (overflow is ignored). Differences
+///    from \a __a are returned in the lower 64 bits of each 128-bit half of
+///    the result; differences from \a __b are returned in the upper 64 bits
+///    of each 128-bit half of the result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 1
+///   j := i*128
+///   result[j+31:j] := __a[j+31:j] - __a[j+63:j+32]
+///   result[j+63:j+32] := __a[j+95:j+64] - __a[j+127:j+96]
+///   result[j+95:j+64] := __b[j+31:j] - __b[j+63:j+32]
+///   result[j+127:j+96] := __b[j+95:j+64] - __b[j+127:j+96]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPHSUBD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \returns A 256-bit vector of [8 x i32] containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_hsub_epi32(__m256i __a, __m256i __b)
+{
+    return (__m256i)__builtin_ia32_phsubd256((__v8si)__a, (__v8si)__b);
+}
+
+/// Horizontally subtracts adjacent pairs of 16-bit integers from two 256-bit
+///    vectors of [16 x i16] using signed saturation and returns each sum in
+///    an element of the [16 x i16] result. Differences from \a __a are
+///    returned in the lower 64 bits of each 128-bit half of the result;
+///    differences from \a __b are returned in the upper 64 bits of each
+///    128-bit half of the result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 1
+///   j := i*128
+///   result[j+15:j] := SATURATE16(__a[j+15:j] - __a[j+31:j+16])
+///   result[j+31:j+16] := SATURATE16(__a[j+47:j+32] - __a[j+63:j+48])
+///   result[j+47:j+32] := SATURATE16(__a[j+79:j+64] - __a[j+95:j+80])
+///   result[j+63:j+48] := SATURATE16(__a[j+111:j+96] - __a[j+127:j+112])
+///   result[j+79:j+64] := SATURATE16(__b[j+15:j] - __b[j+31:j+16])
+///   result[j+95:j+80] := SATURATE16(__b[j+47:j+32] - __b[j+63:j+48])
+///   result[j+111:j+96] := SATURATE16(__b[j+79:j+64] - __b[j+95:j+80])
+///   result[j+127:j+112] := SATURATE16(__b[j+111:j+96] - __b[j+127:j+112])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPHSUBSW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_hsubs_epi16(__m256i __a, __m256i __b)
+{
+    return (__m256i)__builtin_ia32_phsubsw256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Multiplies each unsigned byte from the 256-bit integer vector in \a __a
+///    with the corresponding signed byte from the 256-bit integer vector in
+///    \a __b, forming signed 16-bit intermediate products. Adds adjacent
+///    pairs of those products using signed saturation to form 16-bit sums
+///    returned as elements of the [16 x i16] result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 15
+///   j := i*16
+///   temp1 := __a[j+7:j] * __b[j+7:j]
+///   temp2 := __a[j+15:j+8] * __b[j+15:j+8]
+///   result[j+15:j] := SATURATE16(temp1 + temp2)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMADDUBSW instruction.
+///
+/// \param __a
+///    A 256-bit vector containing one of the source operands.
+/// \param __b
+///    A 256-bit vector containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maddubs_epi16(__m256i __a, __m256i __b)
+{
+    return (__m256i)__builtin_ia32_pmaddubsw256((__v32qi)__a, (__v32qi)__b);
+}
+
+/// Multiplies corresponding 16-bit elements of two 256-bit vectors of
+///    [16 x i16], forming 32-bit intermediate products, and adds pairs of
+///    those products to form 32-bit sums returned as elements of the
+///    [8 x i32] result.
+///
+///    There is only one wraparound case: when all four of the 16-bit sources
+///    are \c 0x8000, the result will be \c 0x80000000.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*32
+///   temp1 := __a[j+15:j] * __b[j+15:j]
+///   temp2 := __a[j+31:j+16] * __b[j+31:j+16]
+///   result[j+31:j] := temp1 + temp2
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMADDWD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_madd_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_pmaddwd256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Compares the corresponding signed bytes in the two 256-bit integer vectors
+///     in \a __a and \a __b and returns the larger of each pair in the
+///     corresponding byte of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMAXSB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_max_epi8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_max((__v32qs)__a, (__v32qs)__b);
+}
+
+/// Compares the corresponding signed 16-bit integers in the two 256-bit
+///    vectors of [16 x i16] in \a __a and \a __b and returns the larger of
+///    each pair in the corresponding element of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMAXSW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16].
+/// \param __b
+///    A 256-bit vector of [16 x i16].
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_max_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_max((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Compares the corresponding signed 32-bit integers in the two 256-bit
+///    vectors of [8 x i32] in \a __a and \a __b and returns the larger of
+///    each pair in the corresponding element of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMAXSD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32].
+/// \param __b
+///    A 256-bit vector of [8 x i32].
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_max_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_max((__v8si)__a, (__v8si)__b);
+}
+
+/// Compares the corresponding unsigned bytes in the two 256-bit integer
+///     vectors in \a __a and \a __b and returns the larger of each pair in
+///     the corresponding byte of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMAXUB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_max_epu8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_max((__v32qu)__a, (__v32qu)__b);
+}
+
+/// Compares the corresponding unsigned 16-bit integers in the two 256-bit
+///    vectors of [16 x i16] in \a __a and \a __b and returns the larger of
+///    each pair in the corresponding element of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMAXUW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16].
+/// \param __b
+///    A 256-bit vector of [16 x i16].
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_max_epu16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_max((__v16hu)__a, (__v16hu)__b);
+}
+
+/// Compares the corresponding unsigned 32-bit integers in the two 256-bit
+///    vectors of [8 x i32] in \a __a and \a __b and returns the larger of
+///    each pair in the corresponding element of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMAXUD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32].
+/// \param __b
+///    A 256-bit vector of [8 x i32].
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_max_epu32(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_max((__v8su)__a, (__v8su)__b);
+}
+
+/// Compares the corresponding signed bytes in the two 256-bit integer vectors
+///     in \a __a and \a __b and returns the smaller of each pair in the
+///     corresponding byte of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMINSB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_min_epi8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_min((__v32qs)__a, (__v32qs)__b);
+}
+
+/// Compares the corresponding signed 16-bit integers in the two 256-bit
+///    vectors of [16 x i16] in \a __a and \a __b and returns the smaller of
+///    each pair in the corresponding element of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMINSW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16].
+/// \param __b
+///    A 256-bit vector of [16 x i16].
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_min_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_min((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Compares the corresponding signed 32-bit integers in the two 256-bit
+///    vectors of [8 x i32] in \a __a and \a __b and returns the smaller of
+///    each pair in the corresponding element of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMINSD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32].
+/// \param __b
+///    A 256-bit vector of [8 x i32].
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_min_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_min((__v8si)__a, (__v8si)__b);
+}
+
+/// Compares the corresponding unsigned bytes in the two 256-bit integer
+///     vectors in \a __a and \a __b and returns the smaller of each pair in
+///     the corresponding byte of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMINUB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_min_epu8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_min((__v32qu)__a, (__v32qu)__b);
+}
+
+/// Compares the corresponding unsigned 16-bit integers in the two 256-bit
+///    vectors of [16 x i16] in \a __a and \a __b and returns the smaller of
+///    each pair in the corresponding element of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMINUW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16].
+/// \param __b
+///    A 256-bit vector of [16 x i16].
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_min_epu16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_min((__v16hu)__a, (__v16hu)__b);
+}
+
+/// Compares the corresponding unsigned 32-bit integers in the two 256-bit
+///    vectors of [8 x i32] in \a __a and \a __b and returns the smaller of
+///    each pair in the corresponding element of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMINUD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32].
+/// \param __b
+///    A 256-bit vector of [8 x i32].
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_min_epu32(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_min((__v8su)__a, (__v8su)__b);
+}
+
+/// Creates a 32-bit integer mask from the most significant bit of each byte
+///    in the 256-bit integer vector in \a __a and returns the result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 31
+///   j := i*8
+///   result[i] := __a[j+7]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVMSKB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector containing the source bytes.
+/// \returns The 32-bit integer mask.
+static __inline__ int __DEFAULT_FN_ATTRS256
+_mm256_movemask_epi8(__m256i __a)
+{
+  return __builtin_ia32_pmovmskb256((__v32qi)__a);
+}
+
+/// Sign-extends bytes from the 128-bit integer vector in \a __V and returns
+///    the 16-bit values in the corresponding elements of a 256-bit vector
+///    of [16 x i16].
+///
+/// \code{.operation}
+/// FOR i := 0 TO 15
+///   j := i*8
+///   k := i*16
+///   result[k+15:k] := SignExtend(__V[j+7:j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSXBW instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the source bytes.
+/// \returns A 256-bit vector of [16 x i16] containing the sign-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi8_epi16(__m128i __V)
+{
+  /* This function always performs a signed extension, but __v16qi is a char
+     which may be signed or unsigned, so use __v16qs. */
+  return (__m256i)__builtin_convertvector((__v16qs)__V, __v16hi);
+}
+
+/// Sign-extends bytes from the lower half of the 128-bit integer vector in
+///    \a __V and returns the 32-bit values in the corresponding elements of a
+///    256-bit vector of [8 x i32].
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*8
+///   k := i*32
+///   result[k+31:k] := SignExtend(__V[j+7:j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSXBD instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the source bytes.
+/// \returns A 256-bit vector of [8 x i32] containing the sign-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi8_epi32(__m128i __V)
+{
+  /* This function always performs a signed extension, but __v16qi is a char
+     which may be signed or unsigned, so use __v16qs. */
+  return (__m256i)__builtin_convertvector(__builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1, 2, 3, 4, 5, 6, 7), __v8si);
+}
+
+/// Sign-extends the first four bytes from the 128-bit integer vector in
+///    \a __V and returns the 64-bit values in the corresponding elements of a
+///    256-bit vector of [4 x i64].
+///
+/// \code{.operation}
+/// result[63:0] := SignExtend(__V[7:0])
+/// result[127:64] := SignExtend(__V[15:8])
+/// result[191:128] := SignExtend(__V[23:16])
+/// result[255:192] := SignExtend(__V[31:24])
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSXBQ instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the source bytes.
+/// \returns A 256-bit vector of [4 x i64] containing the sign-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi8_epi64(__m128i __V)
+{
+  /* This function always performs a signed extension, but __v16qi is a char
+     which may be signed or unsigned, so use __v16qs. */
+  return (__m256i)__builtin_convertvector(__builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1, 2, 3), __v4di);
+}
+
+/// Sign-extends 16-bit elements from the 128-bit vector of [8 x i16] in
+///    \a __V and returns the 32-bit values in the corresponding elements of a
+///    256-bit vector of [8 x i32].
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*16
+///   k := i*32
+///   result[k+31:k] := SignExtend(__V[j+15:j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSXWD instruction.
+///
+/// \param __V
+///    A 128-bit vector of [8 x i16] containing the source values.
+/// \returns A 256-bit vector of [8 x i32] containing the sign-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi16_epi32(__m128i __V)
+{
+  return (__m256i)__builtin_convertvector((__v8hi)__V, __v8si);
+}
+
+/// Sign-extends 16-bit elements from the lower half of the 128-bit vector of
+///    [8 x i16] in \a __V and returns the 64-bit values in the corresponding
+///    elements of a 256-bit vector of [4 x i64].
+///
+/// \code{.operation}
+/// result[63:0] := SignExtend(__V[15:0])
+/// result[127:64] := SignExtend(__V[31:16])
+/// result[191:128] := SignExtend(__V[47:32])
+/// result[255:192] := SignExtend(__V[64:48])
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSXWQ instruction.
+///
+/// \param __V
+///    A 128-bit vector of [8 x i16] containing the source values.
+/// \returns A 256-bit vector of [4 x i64] containing the sign-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi16_epi64(__m128i __V)
+{
+  return (__m256i)__builtin_convertvector(__builtin_shufflevector((__v8hi)__V, (__v8hi)__V, 0, 1, 2, 3), __v4di);
+}
+
+/// Sign-extends 32-bit elements from the 128-bit vector of [4 x i32] in
+///    \a __V and returns the 64-bit values in the corresponding elements of a
+///    256-bit vector of [4 x i64].
+///
+/// \code{.operation}
+/// result[63:0] := SignExtend(__V[31:0])
+/// result[127:64] := SignExtend(__V[63:32])
+/// result[191:128] := SignExtend(__V[95:64])
+/// result[255:192] := SignExtend(__V[127:96])
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSXDQ instruction.
+///
+/// \param __V
+///    A 128-bit vector of [4 x i32] containing the source values.
+/// \returns A 256-bit vector of [4 x i64] containing the sign-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi32_epi64(__m128i __V)
+{
+  return (__m256i)__builtin_convertvector((__v4si)__V, __v4di);
+}
+
+/// Zero-extends bytes from the 128-bit integer vector in \a __V and returns
+///    the 16-bit values in the corresponding elements of a 256-bit vector
+///    of [16 x i16].
+///
+/// \code{.operation}
+/// FOR i := 0 TO 15
+///   j := i*8
+///   k := i*16
+///   result[k+15:k] := ZeroExtend(__V[j+7:j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVZXBW instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the source bytes.
+/// \returns A 256-bit vector of [16 x i16] containing the zero-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepu8_epi16(__m128i __V)
+{
+  return (__m256i)__builtin_convertvector((__v16qu)__V, __v16hi);
+}
+
+/// Zero-extends bytes from the lower half of the 128-bit integer vector in
+///    \a __V and returns the 32-bit values in the corresponding elements of a
+///    256-bit vector of [8 x i32].
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*8
+///   k := i*32
+///   result[k+31:k] := ZeroExtend(__V[j+7:j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVZXBD instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the source bytes.
+/// \returns A 256-bit vector of [8 x i32] containing the zero-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepu8_epi32(__m128i __V)
+{
+  return (__m256i)__builtin_convertvector(__builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1, 2, 3, 4, 5, 6, 7), __v8si);
+}
+
+/// Zero-extends the first four bytes from the 128-bit integer vector in
+///    \a __V and returns the 64-bit values in the corresponding elements of a
+///    256-bit vector of [4 x i64].
+///
+/// \code{.operation}
+/// result[63:0] := ZeroExtend(__V[7:0])
+/// result[127:64] := ZeroExtend(__V[15:8])
+/// result[191:128] := ZeroExtend(__V[23:16])
+/// result[255:192] := ZeroExtend(__V[31:24])
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVZXBQ instruction.
+///
+/// \param __V
+///    A 128-bit integer vector containing the source bytes.
+/// \returns A 256-bit vector of [4 x i64] containing the zero-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepu8_epi64(__m128i __V)
+{
+  return (__m256i)__builtin_convertvector(__builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1, 2, 3), __v4di);
+}
+
+/// Zero-extends 16-bit elements from the 128-bit vector of [8 x i16] in
+///    \a __V and returns the 32-bit values in the corresponding elements of a
+///    256-bit vector of [8 x i32].
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*16
+///   k := i*32
+///   result[k+31:k] := ZeroExtend(__V[j+15:j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVZXWD instruction.
+///
+/// \param __V
+///    A 128-bit vector of [8 x i16] containing the source values.
+/// \returns A 256-bit vector of [8 x i32] containing the zero-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepu16_epi32(__m128i __V)
+{
+  return (__m256i)__builtin_convertvector((__v8hu)__V, __v8si);
+}
+
+/// Zero-extends 16-bit elements from the lower half of the 128-bit vector of
+///    [8 x i16] in \a __V and returns the 64-bit values in the corresponding
+///    elements of a 256-bit vector of [4 x i64].
+///
+/// \code{.operation}
+/// result[63:0] := ZeroExtend(__V[15:0])
+/// result[127:64] := ZeroExtend(__V[31:16])
+/// result[191:128] := ZeroExtend(__V[47:32])
+/// result[255:192] := ZeroExtend(__V[64:48])
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVSXWQ instruction.
+///
+/// \param __V
+///    A 128-bit vector of [8 x i16] containing the source values.
+/// \returns A 256-bit vector of [4 x i64] containing the zero-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepu16_epi64(__m128i __V)
+{
+  return (__m256i)__builtin_convertvector(__builtin_shufflevector((__v8hu)__V, (__v8hu)__V, 0, 1, 2, 3), __v4di);
+}
+
+/// Zero-extends 32-bit elements from the 128-bit vector of [4 x i32] in
+///    \a __V and returns the 64-bit values in the corresponding elements of a
+///    256-bit vector of [4 x i64].
+///
+/// \code{.operation}
+/// result[63:0] := ZeroExtend(__V[31:0])
+/// result[127:64] := ZeroExtend(__V[63:32])
+/// result[191:128] := ZeroExtend(__V[95:64])
+/// result[255:192] := ZeroExtend(__V[127:96])
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMOVZXDQ instruction.
+///
+/// \param __V
+///    A 128-bit vector of [4 x i32] containing the source values.
+/// \returns A 256-bit vector of [4 x i64] containing the zero-extended
+///    values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtepu32_epi64(__m128i __V)
+{
+  return (__m256i)__builtin_convertvector((__v4su)__V, __v4di);
+}
+
+/// Multiplies signed 32-bit integers from even-numbered elements of two
+///    256-bit vectors of [8 x i32] and returns the 64-bit products in the
+///    [4 x i64] result.
+///
+/// \code{.operation}
+/// result[63:0] := __a[31:0] * __b[31:0]
+/// result[127:64] := __a[95:64] * __b[95:64]
+/// result[191:128] := __a[159:128] * __b[159:128]
+/// result[255:192] := __a[223:192] * __b[223:192]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMULDQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \returns A 256-bit vector of [4 x i64] containing the products.
+static __inline__  __m256i __DEFAULT_FN_ATTRS256
+_mm256_mul_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_pmuldq256((__v8si)__a, (__v8si)__b);
+}
+
+/// Multiplies signed 16-bit integer elements of two 256-bit vectors of
+///    [16 x i16], truncates the 32-bit results to the most significant 18
+///    bits, rounds by adding 1, and returns bits [16:1] of each rounded
+///    product in the [16 x i16] result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 15
+///   j := i*16
+///   temp := ((__a[j+15:j] * __b[j+15:j]) >> 14) + 1
+///   result[j+15:j] := temp[16:1]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMULHRSW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the rounded products.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mulhrs_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_pmulhrsw256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Multiplies unsigned 16-bit integer elements of two 256-bit vectors of
+///    [16 x i16], and returns the upper 16 bits of each 32-bit product in the
+///    [16 x i16] result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMULHUW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the products.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mulhi_epu16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_pmulhuw256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Multiplies signed 16-bit integer elements of two 256-bit vectors of
+///    [16 x i16], and returns the upper 16 bits of each 32-bit product in the
+///    [16 x i16] result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMULHW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the products.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mulhi_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_pmulhw256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Multiplies signed 16-bit integer elements of two 256-bit vectors of
+///    [16 x i16], and returns the lower 16 bits of each 32-bit product in the
+///    [16 x i16] result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMULLW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing one of the source operands.
+/// \returns A 256-bit vector of [16 x i16] containing the products.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mullo_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v16hu)__a * (__v16hu)__b);
+}
+
+/// Multiplies signed 32-bit integer elements of two 256-bit vectors of
+///    [8 x i32], and returns the lower 32 bits of each 64-bit product in the
+///    [8 x i32] result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMULLD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \returns A 256-bit vector of [8 x i32] containing the products.
+static __inline__  __m256i __DEFAULT_FN_ATTRS256
+_mm256_mullo_epi32 (__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v8su)__a * (__v8su)__b);
+}
+
+/// Multiplies unsigned 32-bit integers from even-numered elements of two
+///    256-bit vectors of [8 x i32] and returns the 64-bit products in the
+///    [4 x i64] result.
+///
+/// \code{.operation}
+/// result[63:0] := __a[31:0] * __b[31:0]
+/// result[127:64] := __a[95:64] * __b[95:64]
+/// result[191:128] := __a[159:128] * __b[159:128]
+/// result[255:192] := __a[223:192] * __b[223:192]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMULUDQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing one of the source operands.
+/// \returns A 256-bit vector of [4 x i64] containing the products.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mul_epu32(__m256i __a, __m256i __b)
+{
+  return __builtin_ia32_pmuludq256((__v8si)__a, (__v8si)__b);
+}
+
+/// Computes the bitwise OR of the 256-bit integer vectors in \a __a and
+///    \a __b.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPOR instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_or_si256(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v4du)__a | (__v4du)__b);
+}
+
+/// Computes four sum of absolute difference (SAD) operations on sets of eight
+///    unsigned 8-bit integers from the 256-bit integer vectors \a __a and
+///    \a __b.
+///
+///    One SAD result is computed for each set of eight bytes from \a __a and
+///    eight bytes from \a __b. The zero-extended SAD value is returned in the
+///    corresponding 64-bit element of the result.
+///
+///    A single SAD operation takes the differences between the corresponding
+///    bytes of \a __a and \a __b, takes the absolute value of each difference,
+///    and sums these eight values to form one 16-bit result. This operation
+///    is repeated four times with successive sets of eight bytes.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*64
+///   temp0 := ABS(__a[j+7:j] - __b[j+7:j])
+///   temp1 := ABS(__a[j+15:j+8] - __b[j+15:j+8])
+///   temp2 := ABS(__a[j+23:j+16] - __b[j+23:j+16])
+///   temp3 := ABS(__a[j+31:j+24] - __b[j+31:j+24])
+///   temp4 := ABS(__a[j+39:j+32] - __b[j+39:j+32])
+///   temp5 := ABS(__a[j+47:j+40] - __b[j+47:j+40])
+///   temp6 := ABS(__a[j+55:j+48] - __b[j+55:j+48])
+///   temp7 := ABS(__a[j+63:j+56] - __b[j+63:j+56])
+///   result[j+15:j] := temp0 + temp1 + temp2 + temp3 +
+///                     temp4 + temp5 + temp6 + temp7
+///   result[j+63:j+16] := 0
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSADBW instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sad_epu8(__m256i __a, __m256i __b)
+{
+  return __builtin_ia32_psadbw256((__v32qi)__a, (__v32qi)__b);
+}
+
+/// Shuffles 8-bit integers in the 256-bit integer vector \a __a according
+///    to control information in the 256-bit integer vector \a __b, and
+///    returns the 256-bit result. In effect there are two separate 128-bit
+///    shuffles in the lower and upper halves.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 31
+///   j := i*8
+///   IF __b[j+7] == 1
+///     result[j+7:j] := 0
+///   ELSE
+///     k := __b[j+3:j] * 8
+///     IF i > 15
+///       k := k + 128
+///     FI
+///     result[j+7:j] := __a[k+7:k]
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSHUFB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector containing source values.
+/// \param __b
+///    A 256-bit integer vector containing control information to determine
+///    what goes into the corresponding byte of the result. If bit 7 of the
+///    control byte is 1, the result byte is 0; otherwise, bits 3:0 of the
+///    control byte specify the index (within the same 128-bit half) of \a __a
+///    to copy to the result byte.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_shuffle_epi8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_pshufb256((__v32qi)__a, (__v32qi)__b);
+}
+
+/// Shuffles 32-bit integers from the 256-bit vector of [8 x i32] in \a a
+///    according to control information in the integer literal \a imm, and
+///    returns the 256-bit result. In effect there are two parallel 128-bit
+///    shuffles in the lower and upper halves.
+///
+/// \code{.operation}
+/// FOR i := 0 to 3
+///   j := i*32
+///   k := (imm >> i*2)[1:0] * 32
+///   result[j+31:j] := a[k+31:k]
+///   result[128+j+31:128+j] := a[128+k+31:128+k]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_shuffle_epi32(__m256i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPSHUFB instruction.
+///
+/// \param a
+///    A 256-bit vector of [8 x i32] containing source values.
+/// \param imm
+///    An immediate 8-bit value specifying which elements to copy from \a a.
+///    \a imm[1:0] specifies the index in \a a for elements 0 and 4 of the
+///    result, \a imm[3:2] specifies the index for elements 1 and 5, and so
+///    forth.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+#define _mm256_shuffle_epi32(a, imm) \
+  ((__m256i)__builtin_ia32_pshufd256((__v8si)(__m256i)(a), (int)(imm)))
+
+/// Shuffles 16-bit integers from the 256-bit vector of [16 x i16] in \a a
+///    according to control information in the integer literal \a imm, and
+///    returns the 256-bit result. The upper 64 bits of each 128-bit half
+///    are shuffled in parallel; the lower 64 bits of each 128-bit half are
+///    copied from \a a unchanged.
+///
+/// \code{.operation}
+/// result[63:0] := a[63:0]
+/// result[191:128] := a[191:128]
+/// FOR i := 0 TO 3
+///   j := i * 16 + 64
+///   k := (imm >> i*2)[1:0] * 16 + 64
+///   result[j+15:j] := a[k+15:k]
+///   result[128+j+15:128+j] := a[128+k+15:128+k]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_shufflehi_epi16(__m256i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPSHUFHW instruction.
+///
+/// \param a
+///    A 256-bit vector of [16 x i16] containing source values.
+/// \param imm
+///    An immediate 8-bit value specifying which elements to copy from \a a.
+///    \a imm[1:0] specifies the index in \a a for elements 4 and 8 of the
+///    result, \a imm[3:2] specifies the index for elements 5 and 9, and so
+///    forth. Indexes are offset by 4 (so 0 means index 4, and so forth).
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+#define _mm256_shufflehi_epi16(a, imm) \
+  ((__m256i)__builtin_ia32_pshufhw256((__v16hi)(__m256i)(a), (int)(imm)))
+
+/// Shuffles 16-bit integers from the 256-bit vector of [16 x i16] \a a
+///    according to control information in the integer literal \a imm, and
+///    returns the 256-bit [16 x i16] result. The lower 64 bits of each
+///    128-bit half are shuffled; the upper 64 bits of each 128-bit half are
+///    copied from \a a unchanged.
+///
+/// \code{.operation}
+/// result[127:64] := a[127:64]
+/// result[255:192] := a[255:192]
+/// FOR i := 0 TO 3
+///   j := i * 16
+///   k := (imm >> i*2)[1:0] * 16
+///   result[j+15:j] := a[k+15:k]
+///   result[128+j+15:128+j] := a[128+k+15:128+k]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_shufflelo_epi16(__m256i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPSHUFLW instruction.
+///
+/// \param a
+///    A 256-bit vector of [16 x i16] to use as a source of data for the
+///    result.
+/// \param imm
+///    An immediate 8-bit value specifying which elements to copy from \a a.
+///    \a imm[1:0] specifies the index in \a a for elements 0 and 8 of the
+///    result, \a imm[3:2] specifies the index for elements 1 and 9, and so
+///    forth.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+#define _mm256_shufflelo_epi16(a, imm) \
+  ((__m256i)__builtin_ia32_pshuflw256((__v16hi)(__m256i)(a), (int)(imm)))
+
+/// Sets each byte of the result to the corresponding byte of the 256-bit
+///    integer vector in \a __a, the negative of that byte, or zero, depending
+///    on whether the corresponding byte of the 256-bit integer vector in
+///    \a __b is greater than zero, less than zero, or equal to zero,
+///    respectively.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSIGNB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector].
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sign_epi8(__m256i __a, __m256i __b)
+{
+    return (__m256i)__builtin_ia32_psignb256((__v32qi)__a, (__v32qi)__b);
+}
+
+/// Sets each element of the result to the corresponding element of the
+///    256-bit vector of [16 x i16] in \a __a, the negative of that element,
+///    or zero, depending on whether the corresponding element of the 256-bit
+///    vector of [16 x i16] in \a __b is greater than zero, less than zero, or
+///    equal to zero, respectively.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSIGNW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16].
+/// \param __b
+///    A 256-bit vector of [16 x i16].
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sign_epi16(__m256i __a, __m256i __b)
+{
+    return (__m256i)__builtin_ia32_psignw256((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Sets each element of the result to the corresponding element of the
+///    256-bit vector of [8 x i32] in \a __a, the negative of that element, or
+///    zero, depending on whether the corresponding element of the 256-bit
+///    vector of [8 x i32] in \a __b is greater than zero, less than zero, or
+///    equal to zero, respectively.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSIGND instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32].
+/// \param __b
+///    A 256-bit vector of [8 x i32].
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sign_epi32(__m256i __a, __m256i __b)
+{
+    return (__m256i)__builtin_ia32_psignd256((__v8si)__a, (__v8si)__b);
+}
+
+/// Shifts each 128-bit half of the 256-bit integer vector \a a left by
+///    \a imm bytes, shifting in zero bytes, and returns the result. If \a imm
+///    is greater than 15, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_slli_si256(__m256i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPSLLDQ instruction.
+///
+/// \param a
+///    A 256-bit integer vector to be shifted.
+/// \param imm
+///     An unsigned immediate value specifying the shift count (in bytes).
+/// \returns A 256-bit integer vector containing the result.
+#define _mm256_slli_si256(a, imm) \
+  ((__m256i)__builtin_ia32_pslldqi256_byteshift((__v4di)(__m256i)(a), (int)(imm)))
+
+/// Shifts each 128-bit half of the 256-bit integer vector \a a left by
+///    \a imm bytes, shifting in zero bytes, and returns the result. If \a imm
+///    is greater than 15, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_bslli_epi128(__m256i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPSLLDQ instruction.
+///
+/// \param a
+///    A 256-bit integer vector to be shifted.
+/// \param imm
+///    An unsigned immediate value specifying the shift count (in bytes).
+/// \returns A 256-bit integer vector containing the result.
+#define _mm256_bslli_epi128(a, imm) \
+  ((__m256i)__builtin_ia32_pslldqi256_byteshift((__v4di)(__m256i)(a), (int)(imm)))
+
+/// Shifts each 16-bit element of the 256-bit vector of [16 x i16] in \a __a
+///    left by \a __count bits, shifting in zero bits, and returns the result.
+///    If \a __count is greater than 15, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSLLW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] to be shifted.
+/// \param __count
+///    An unsigned integer value specifying the shift count (in bits).
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_slli_epi16(__m256i __a, int __count)
+{
+  return (__m256i)__builtin_ia32_psllwi256((__v16hi)__a, __count);
+}
+
+/// Shifts each 16-bit element of the 256-bit vector of [16 x i16] in \a __a
+///    left by the number of bits specified by the lower 64 bits of \a __count,
+///    shifting in zero bits, and returns the result. If \a __count is greater
+///    than 15, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSLLW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] to be shifted.
+/// \param __count
+///    A 128-bit vector of [2 x i64] whose lower element gives the unsigned
+///    shift count (in bits). The upper element is ignored.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sll_epi16(__m256i __a, __m128i __count)
+{
+  return (__m256i)__builtin_ia32_psllw256((__v16hi)__a, (__v8hi)__count);
+}
+
+/// Shifts each 32-bit element of the 256-bit vector of [8 x i32] in \a __a
+///    left by \a __count bits, shifting in zero bits, and returns the result.
+///    If \a __count is greater than 31, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSLLD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] to be shifted.
+/// \param __count
+///    An unsigned integer value specifying the shift count (in bits).
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_slli_epi32(__m256i __a, int __count)
+{
+  return (__m256i)__builtin_ia32_pslldi256((__v8si)__a, __count);
+}
+
+/// Shifts each 32-bit element of the 256-bit vector of [8 x i32] in \a __a
+///    left by the number of bits given in the lower 64 bits of \a __count,
+///    shifting in zero bits, and returns the result. If \a __count is greater
+///    than 31, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSLLD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] to be shifted.
+/// \param __count
+///    A 128-bit vector of [2 x i64] whose lower element gives the unsigned
+///    shift count (in bits). The upper element is ignored.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sll_epi32(__m256i __a, __m128i __count)
+{
+  return (__m256i)__builtin_ia32_pslld256((__v8si)__a, (__v4si)__count);
+}
+
+/// Shifts each 64-bit element of the 256-bit vector of [4 x i64] in \a __a
+///    left by \a __count bits, shifting in zero bits, and returns the result.
+///    If \a __count is greater than 63, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSLLQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64] to be shifted.
+/// \param __count
+///    An unsigned integer value specifying the shift count (in bits).
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_slli_epi64(__m256i __a, int __count)
+{
+  return __builtin_ia32_psllqi256((__v4di)__a, __count);
+}
+
+/// Shifts each 64-bit element of the 256-bit vector of [4 x i64] in \a __a
+///    left by the number of bits given in the lower 64 bits of \a __count,
+///    shifting in zero bits, and returns the result. If \a __count is greater
+///    than 63, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSLLQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64] to be shifted.
+/// \param __count
+///    A 128-bit vector of [2 x i64] whose lower element gives the unsigned
+///    shift count (in bits). The upper element is ignored.
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sll_epi64(__m256i __a, __m128i __count)
+{
+  return __builtin_ia32_psllq256((__v4di)__a, __count);
+}
+
+/// Shifts each 16-bit element of the 256-bit vector of [16 x i16] in \a __a
+///    right by \a __count bits, shifting in sign bits, and returns the result.
+///    If \a __count is greater than 15, each element of the result is either
+///    0 or -1 according to the corresponding input sign bit.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRAW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] to be shifted.
+/// \param __count
+///    An unsigned integer value specifying the shift count (in bits).
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srai_epi16(__m256i __a, int __count)
+{
+  return (__m256i)__builtin_ia32_psrawi256((__v16hi)__a, __count);
+}
+
+/// Shifts each 16-bit element of the 256-bit vector of [16 x i16] in \a __a
+///    right by the number of bits given in the lower 64 bits of \a __count,
+///    shifting in sign bits, and returns the result. If \a __count is greater
+///    than 15, each element of the result is either 0 or -1 according to the
+///    corresponding input sign bit.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRAW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] to be shifted.
+/// \param __count
+///    A 128-bit vector of [2 x i64] whose lower element gives the unsigned
+///    shift count (in bits). The upper element is ignored.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sra_epi16(__m256i __a, __m128i __count)
+{
+  return (__m256i)__builtin_ia32_psraw256((__v16hi)__a, (__v8hi)__count);
+}
+
+/// Shifts each 32-bit element of the 256-bit vector of [8 x i32] in \a __a
+///    right by \a __count bits, shifting in sign bits, and returns the result.
+///    If \a __count is greater than 31, each element of the result is either
+///    0 or -1 according to the corresponding input sign bit.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRAD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] to be shifted.
+/// \param __count
+///    An unsigned integer value specifying the shift count (in bits).
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srai_epi32(__m256i __a, int __count)
+{
+  return (__m256i)__builtin_ia32_psradi256((__v8si)__a, __count);
+}
+
+/// Shifts each 32-bit element of the 256-bit vector of [8 x i32] in \a __a
+///    right by the number of bits given in the lower 64 bits of \a __count,
+///    shifting in sign bits, and returns the result. If \a __count is greater
+///    than 31, each element of the result is either 0 or -1 according to the
+///    corresponding input sign bit.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRAD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] to be shifted.
+/// \param __count
+///    A 128-bit vector of [2 x i64] whose lower element gives the unsigned
+///    shift count (in bits). The upper element is ignored.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sra_epi32(__m256i __a, __m128i __count)
+{
+  return (__m256i)__builtin_ia32_psrad256((__v8si)__a, (__v4si)__count);
+}
+
+/// Shifts each 128-bit half of the 256-bit integer vector in \a a right by
+///    \a imm bytes, shifting in zero bytes, and returns the result. If
+///    \a imm is greater than 15, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_srli_si256(__m256i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPSRLDQ instruction.
+///
+/// \param a
+///    A 256-bit integer vector to be shifted.
+/// \param imm
+///    An unsigned immediate value specifying the shift count (in bytes).
+/// \returns A 256-bit integer vector containing the result.
+#define _mm256_srli_si256(a, imm) \
+  ((__m256i)__builtin_ia32_psrldqi256_byteshift((__m256i)(a), (int)(imm)))
+
+/// Shifts each 128-bit half of the 256-bit integer vector in \a a right by
+///    \a imm bytes, shifting in zero bytes, and returns the result. If
+///    \a imm is greater than 15, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_bsrli_epi128(__m256i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPSRLDQ instruction.
+///
+/// \param a
+///    A 256-bit integer vector to be shifted.
+/// \param imm
+///     An unsigned immediate value specifying the shift count (in bytes).
+/// \returns A 256-bit integer vector containing the result.
+#define _mm256_bsrli_epi128(a, imm) \
+  ((__m256i)__builtin_ia32_psrldqi256_byteshift((__m256i)(a), (int)(imm)))
+
+/// Shifts each 16-bit element of the 256-bit vector of [16 x i16] in \a __a
+///    right by \a __count bits, shifting in zero bits, and returns the result.
+///    If \a __count is greater than 15, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRLW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] to be shifted.
+/// \param __count
+///    An unsigned integer value specifying the shift count (in bits).
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srli_epi16(__m256i __a, int __count)
+{
+  return (__m256i)__builtin_ia32_psrlwi256((__v16hi)__a, __count);
+}
+
+/// Shifts each 16-bit element of the 256-bit vector of [16 x i16] in \a __a
+///    right by the number of bits given in the lower 64 bits of \a __count,
+///    shifting in zero bits, and returns the result. If \a __count is greater
+///    than 15, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRLW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] to be shifted.
+/// \param __count
+///    A 128-bit vector of [2 x i64] whose lower element gives the unsigned
+///    shift count (in bits). The upper element is ignored.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srl_epi16(__m256i __a, __m128i __count)
+{
+  return (__m256i)__builtin_ia32_psrlw256((__v16hi)__a, (__v8hi)__count);
+}
+
+/// Shifts each 32-bit element of the 256-bit vector of [8 x i32] in \a __a
+///    right by \a __count bits, shifting in zero bits, and returns the result.
+///    If \a __count is greater than 31, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRLD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] to be shifted.
+/// \param __count
+///    An unsigned integer value specifying the shift count (in bits).
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srli_epi32(__m256i __a, int __count)
+{
+  return (__m256i)__builtin_ia32_psrldi256((__v8si)__a, __count);
+}
+
+/// Shifts each 32-bit element of the 256-bit vector of [8 x i32] in \a __a
+///    right by the number of bits given in the lower 64 bits of \a __count,
+///    shifting in zero bits, and returns the result. If \a __count is greater
+///    than 31, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRLD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] to be shifted.
+/// \param __count
+///    A 128-bit vector of [2 x i64] whose lower element gives the unsigned
+///    shift count (in bits). The upper element is ignored.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srl_epi32(__m256i __a, __m128i __count)
+{
+  return (__m256i)__builtin_ia32_psrld256((__v8si)__a, (__v4si)__count);
+}
+
+/// Shifts each 64-bit element of the 256-bit vector of [4 x i64] in \a __a
+///    right by \a __count bits, shifting in zero bits, and returns the result.
+///    If \a __count is greater than 63, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRLQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64] to be shifted.
+/// \param __count
+///    An unsigned integer value specifying the shift count (in bits).
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srli_epi64(__m256i __a, int __count)
+{
+  return __builtin_ia32_psrlqi256((__v4di)__a, __count);
+}
+
+/// Shifts each 64-bit element of the 256-bit vector of [4 x i64] in \a __a
+///    right by the number of bits given in the lower 64 bits of \a __count,
+///    shifting in zero bits, and returns the result. If \a __count is greater
+///    than 63, the returned result is all zeroes.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRLQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64] to be shifted.
+/// \param __count
+///    A 128-bit vector of [2 x i64] whose lower element gives the unsigned
+///    shift count (in bits). The upper element is ignored.
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srl_epi64(__m256i __a, __m128i __count)
+{
+  return __builtin_ia32_psrlq256((__v4di)__a, __count);
+}
+
+/// Subtracts 8-bit integers from corresponding bytes of two 256-bit integer
+///    vectors. Returns the lower 8 bits of each difference in the
+///    corresponding byte of the 256-bit integer vector result (overflow is
+///    ignored).
+///
+/// \code{.operation}
+/// FOR i := 0 TO 31
+///   j := i*8
+///   result[j+7:j] := __a[j+7:j] - __b[j+7:j]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSUBB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector containing the minuends.
+/// \param __b
+///    A 256-bit integer vector containing the subtrahends.
+/// \returns A 256-bit integer vector containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sub_epi8(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v32qu)__a - (__v32qu)__b);
+}
+
+/// Subtracts 16-bit integers from corresponding elements of two 256-bit
+///    vectors of [16 x i16]. Returns the lower 16 bits of each difference in
+///    the corresponding element of the [16 x i16] result (overflow is
+///    ignored).
+///
+/// \code{.operation}
+/// FOR i := 0 TO 15
+///   j := i*16
+///   result[j+15:j] := __a[j+15:j] - __b[j+15:j]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSUBW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing the minuends.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing the subtrahends.
+/// \returns A 256-bit vector of [16 x i16] containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sub_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v16hu)__a - (__v16hu)__b);
+}
+
+/// Subtracts 32-bit integers from corresponding elements of two 256-bit
+///    vectors of [8 x i32]. Returns the lower 32 bits of each difference in
+///    the corresponding element of the [8 x i32] result (overflow is ignored).
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*32
+///   result[j+31:j] := __a[j+31:j] - __b[j+31:j]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSUBD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] containing the minuends.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing the subtrahends.
+/// \returns A 256-bit vector of [8 x i32] containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sub_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v8su)__a - (__v8su)__b);
+}
+
+/// Subtracts 64-bit integers from corresponding elements of two 256-bit
+///    vectors of [4 x i64]. Returns the lower 64 bits of each difference in
+///    the corresponding element of the [4 x i64] result (overflow is ignored).
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*64
+///   result[j+63:j] := __a[j+63:j] - __b[j+63:j]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSUBQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64] containing the minuends.
+/// \param __b
+///    A 256-bit vector of [4 x i64] containing the subtrahends.
+/// \returns A 256-bit vector of [4 x i64] containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sub_epi64(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v4du)__a - (__v4du)__b);
+}
+
+/// Subtracts 8-bit integers from corresponding bytes of two 256-bit integer
+///    vectors using signed saturation, and returns each differences in the
+///    corresponding byte of the 256-bit integer vector result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 31
+///   j := i*8
+///   result[j+7:j] := SATURATE8(__a[j+7:j] - __b[j+7:j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSUBSB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector containing the minuends.
+/// \param __b
+///    A 256-bit integer vector containing the subtrahends.
+/// \returns A 256-bit integer vector containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_subs_epi8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_sub_sat((__v32qs)__a, (__v32qs)__b);
+}
+
+/// Subtracts 16-bit integers from corresponding elements of two 256-bit
+///    vectors of [16 x i16] using signed saturation, and returns each
+///    difference in the corresponding element of the [16 x i16] result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 15
+///   j := i*16
+///   result[j+7:j] := SATURATE16(__a[j+7:j] - __b[j+7:j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSUBSW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing the minuends.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing the subtrahends.
+/// \returns A 256-bit vector of [16 x i16] containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_subs_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_sub_sat((__v16hi)__a, (__v16hi)__b);
+}
+
+/// Subtracts 8-bit integers from corresponding bytes of two 256-bit integer
+///    vectors using unsigned saturation, and returns each difference in the
+///    corresponding byte of the 256-bit integer vector result. For each byte,
+///    computes <c> result = __a - __b </c>.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 31
+///   j := i*8
+///   result[j+7:j] := SATURATE8U(__a[j+7:j] - __b[j+7:j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSUBUSB instruction.
+///
+/// \param __a
+///    A 256-bit integer vector containing the minuends.
+/// \param __b
+///    A 256-bit integer vector containing the subtrahends.
+/// \returns A 256-bit integer vector containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_subs_epu8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_sub_sat((__v32qu)__a, (__v32qu)__b);
+}
+
+/// Subtracts 16-bit integers from corresponding elements of two 256-bit
+///    vectors of [16 x i16] using unsigned saturation, and returns each
+///    difference in the corresponding element of the [16 x i16] result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 15
+///   j := i*16
+///   result[j+15:j] := SATURATE16U(__a[j+15:j] - __b[j+15:j])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSUBUSW instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] containing the minuends.
+/// \param __b
+///    A 256-bit vector of [16 x i16] containing the subtrahends.
+/// \returns A 256-bit vector of [16 x i16] containing the differences.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_subs_epu16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_elementwise_sub_sat((__v16hu)__a, (__v16hu)__b);
+}
+
+/// Unpacks and interleaves 8-bit integers from parts of the 256-bit integer
+///    vectors in \a __a and \a __b to form the 256-bit result. Specifically,
+///    uses the upper 64 bits of each 128-bit half of \a __a and \a __b as
+///    input; other bits in these parameters are ignored.
+///
+/// \code{.operation}
+/// result[7:0] := __a[71:64]
+/// result[15:8] := __b[71:64]
+/// result[23:16] := __a[79:72]
+/// result[31:24] := __b[79:72]
+/// . . .
+/// result[127:120] := __b[127:120]
+/// result[135:128] := __a[199:192]
+/// . . .
+/// result[255:248] := __b[255:248]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPUNPCKHBW instruction.
+///
+/// \param __a
+///    A 256-bit integer vector used as the source for the even-numbered bytes
+///    of the result.
+/// \param __b
+///    A 256-bit integer vector used as the source for the odd-numbered bytes
+///    of the result.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_unpackhi_epi8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_shufflevector((__v32qi)__a, (__v32qi)__b, 8, 32+8, 9, 32+9, 10, 32+10, 11, 32+11, 12, 32+12, 13, 32+13, 14, 32+14, 15, 32+15, 24, 32+24, 25, 32+25, 26, 32+26, 27, 32+27, 28, 32+28, 29, 32+29, 30, 32+30, 31, 32+31);
+}
+
+/// Unpacks and interleaves 16-bit integers from parts of the 256-bit vectors
+///    of [16 x i16] in \a __a and \a __b to return the resulting 256-bit
+///    vector of [16 x i16]. Specifically, uses the upper 64 bits of each
+///    128-bit half of \a __a and \a __b as input; other bits in these
+///    parameters are ignored.
+///
+/// \code{.operation}
+/// result[15:0] := __a[79:64]
+/// result[31:16] := __b[79:64]
+/// result[47:32] := __a[95:80]
+/// result[63:48] := __b[95:80]
+/// . . .
+/// result[127:112] := __b[127:112]
+/// result[143:128] := __a[211:196]
+/// . . .
+/// result[255:240] := __b[255:240]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPUNPCKHWD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] used as the source for the even-numbered
+///    elements of the result.
+/// \param __b
+///    A 256-bit vector of [16 x i16] used as the source for the odd-numbered
+///    elements of the result.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_unpackhi_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_shufflevector((__v16hi)__a, (__v16hi)__b, 4, 16+4, 5, 16+5, 6, 16+6, 7, 16+7, 12, 16+12, 13, 16+13, 14, 16+14, 15, 16+15);
+}
+
+/// Unpacks and interleaves 32-bit integers from parts of the 256-bit vectors
+///    of [8 x i32] in \a __a and \a __b to return the resulting 256-bit vector
+///    of [8 x i32]. Specifically, uses the upper 64 bits of each 128-bit half
+///    of \a __a and \a __b as input; other bits in these parameters are
+///    ignored.
+///
+/// \code{.operation}
+/// result[31:0] := __a[95:64]
+/// result[63:32] := __b[95:64]
+/// result[95:64] := __a[127:96]
+/// result[127:96] := __b[127:96]
+/// result[159:128] := __a[223:192]
+/// result[191:160] := __b[223:192]
+/// result[223:192] := __a[255:224]
+/// result[255:224] := __b[255:224]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPUNPCKHDQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] used as the source for the even-numbered
+///    elements of the result.
+/// \param __b
+///    A 256-bit vector of [8 x i32] used as the source for the odd-numbered
+///    elements of the result.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_unpackhi_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_shufflevector((__v8si)__a, (__v8si)__b, 2, 8+2, 3, 8+3, 6, 8+6, 7, 8+7);
+}
+
+/// Unpacks and interleaves 64-bit integers from parts of the 256-bit vectors
+///    of [4 x i64] in \a __a and \a __b to return the resulting 256-bit vector
+///    of [4 x i64]. Specifically, uses the upper 64 bits of each 128-bit half
+///    of \a __a and \a __b as input; other bits in these parameters are
+///    ignored.
+///
+/// \code{.operation}
+/// result[63:0] := __a[127:64]
+/// result[127:64] := __b[127:64]
+/// result[191:128] := __a[255:192]
+/// result[255:192] := __b[255:192]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPUNPCKHQDQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64] used as the source for the even-numbered
+///    elements of the result.
+/// \param __b
+///    A 256-bit vector of [4 x i64] used as the source for the odd-numbered
+///    elements of the result.
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_unpackhi_epi64(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_shufflevector((__v4di)__a, (__v4di)__b, 1, 4+1, 3, 4+3);
+}
+
+/// Unpacks and interleaves 8-bit integers from parts of the 256-bit integer
+///    vectors in \a __a and \a __b to form the 256-bit result. Specifically,
+///    uses the lower 64 bits of each 128-bit half of \a __a and \a __b as
+///    input; other bits in these parameters are ignored.
+///
+/// \code{.operation}
+/// result[7:0] := __a[7:0]
+/// result[15:8] := __b[7:0]
+/// result[23:16] := __a[15:8]
+/// result[31:24] := __b[15:8]
+/// . . .
+/// result[127:120] := __b[63:56]
+/// result[135:128] := __a[135:128]
+/// . . .
+/// result[255:248] := __b[191:184]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPUNPCKLBW instruction.
+///
+/// \param __a
+///    A 256-bit integer vector used as the source for the even-numbered bytes
+///    of the result.
+/// \param __b
+///    A 256-bit integer vector used as the source for the odd-numbered bytes
+///    of the result.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_unpacklo_epi8(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_shufflevector((__v32qi)__a, (__v32qi)__b, 0, 32+0, 1, 32+1, 2, 32+2, 3, 32+3, 4, 32+4, 5, 32+5, 6, 32+6, 7, 32+7, 16, 32+16, 17, 32+17, 18, 32+18, 19, 32+19, 20, 32+20, 21, 32+21, 22, 32+22, 23, 32+23);
+}
+
+/// Unpacks and interleaves 16-bit integers from parts of the 256-bit vectors
+///    of [16 x i16] in \a __a and \a __b to return the resulting 256-bit
+///    vector of [16 x i16]. Specifically, uses the lower 64 bits of each
+///    128-bit half of \a __a and \a __b as input; other bits in these
+///    parameters are ignored.
+///
+/// \code{.operation}
+/// result[15:0] := __a[15:0]
+/// result[31:16] := __b[15:0]
+/// result[47:32] := __a[31:16]
+/// result[63:48] := __b[31:16]
+/// . . .
+/// result[127:112] := __b[63:48]
+/// result[143:128] := __a[143:128]
+/// . . .
+/// result[255:239] := __b[191:176]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPUNPCKLWD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x i16] used as the source for the even-numbered
+///    elements of the result.
+/// \param __b
+///    A 256-bit vector of [16 x i16] used as the source for the odd-numbered
+///    elements of the result.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_unpacklo_epi16(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_shufflevector((__v16hi)__a, (__v16hi)__b, 0, 16+0, 1, 16+1, 2, 16+2, 3, 16+3, 8, 16+8, 9, 16+9, 10, 16+10, 11, 16+11);
+}
+
+/// Unpacks and interleaves 32-bit integers from parts of the 256-bit vectors
+///    of [8 x i32] in \a __a and \a __b to return the resulting 256-bit vector
+///    of [8 x i32]. Specifically, uses the lower 64 bits of each 128-bit half
+///    of \a __a and \a __b as input; other bits in these parameters are
+///    ignored.
+///
+/// \code{.operation}
+/// result[31:0] := __a[31:0]
+/// result[63:32] := __b[31:0]
+/// result[95:64] := __a[63:32]
+/// result[127:96] := __b[63:32]
+/// result[159:128] := __a[159:128]
+/// result[191:160] := __b[159:128]
+/// result[223:192] := __a[191:160]
+/// result[255:224] := __b[191:190]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPUNPCKLDQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] used as the source for the even-numbered
+///    elements of the result.
+/// \param __b
+///    A 256-bit vector of [8 x i32] used as the source for the odd-numbered
+///    elements of the result.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_unpacklo_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_shufflevector((__v8si)__a, (__v8si)__b, 0, 8+0, 1, 8+1, 4, 8+4, 5, 8+5);
+}
+
+/// Unpacks and interleaves 64-bit integers from parts of the 256-bit vectors
+///    of [4 x i64] in \a __a and \a __b to return the resulting 256-bit vector
+///    of [4 x i64]. Specifically, uses the lower 64 bits of each 128-bit half
+///    of \a __a and \a __b as input; other bits in these parameters are
+///    ignored.
+///
+/// \code{.operation}
+/// result[63:0] := __a[63:0]
+/// result[127:64] := __b[63:0]
+/// result[191:128] := __a[191:128]
+/// result[255:192] := __b[191:128]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPUNPCKLQDQ instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64] used as the source for the even-numbered
+///    elements of the result.
+/// \param __b
+///    A 256-bit vector of [4 x i64] used as the source for the odd-numbered
+///    elements of the result.
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_unpacklo_epi64(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_shufflevector((__v4di)__a, (__v4di)__b, 0, 4+0, 2, 4+2);
+}
+
+/// Computes the bitwise XOR of the 256-bit integer vectors in \a __a and
+///    \a __b.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPXOR instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_xor_si256(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v4du)__a ^ (__v4du)__b);
+}
+
+/// Loads the 256-bit integer vector from memory \a __V using a non-temporal
+///   memory hint and returns the vector. \a __V must be aligned on a 32-byte
+///   boundary.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VMOVNTDQA instruction.
+///
+/// \param __V
+///    A pointer to the 32-byte aligned memory containing the vector to load.
+/// \returns A 256-bit integer vector loaded from memory.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_stream_load_si256(const void *__V)
+{
+  typedef __v4di __v4di_aligned __attribute__((aligned(32)));
+  return (__m256i)__builtin_nontemporal_load((const __v4di_aligned *)__V);
+}
+
+/// Broadcasts the 32-bit floating-point value from the low element of the
+///    128-bit vector of [4 x float] in \a __X to all elements of the result's
+///    128-bit vector of [4 x float].
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VBROADCASTSS instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x float] whose low element will be broadcast.
+/// \returns A 128-bit vector of [4 x float] containing the result.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_broadcastss_ps(__m128 __X)
+{
+  return (__m128)__builtin_shufflevector((__v4sf)__X, (__v4sf)__X, 0, 0, 0, 0);
+}
+
+/// Broadcasts the 64-bit floating-point value from the low element of the
+///    128-bit vector of [2 x double] in \a __a to both elements of the
+///    result's 128-bit vector of [2 x double].
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c MOVDDUP instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] whose low element will be broadcast.
+/// \returns A 128-bit vector of [2 x double] containing the result.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_broadcastsd_pd(__m128d __a)
+{
+  return __builtin_shufflevector((__v2df)__a, (__v2df)__a, 0, 0);
+}
+
+/// Broadcasts the 32-bit floating-point value from the low element of the
+///    128-bit vector of [4 x float] in \a __X to all elements of the
+///    result's 256-bit vector of [8 x float].
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VBROADCASTSS instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x float] whose low element will be broadcast.
+/// \returns A 256-bit vector of [8 x float] containing the result.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_broadcastss_ps(__m128 __X)
+{
+  return (__m256)__builtin_shufflevector((__v4sf)__X, (__v4sf)__X, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+/// Broadcasts the 64-bit floating-point value from the low element of the
+///    128-bit vector of [2 x double] in \a __X to all elements of the
+///    result's 256-bit vector of [4 x double].
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VBROADCASTSD instruction.
+///
+/// \param __X
+///    A 128-bit vector of [2 x double] whose low element will be broadcast.
+/// \returns A 256-bit vector of [4 x double] containing the result.
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_broadcastsd_pd(__m128d __X)
+{
+  return (__m256d)__builtin_shufflevector((__v2df)__X, (__v2df)__X, 0, 0, 0, 0);
+}
+
+/// Broadcasts the 128-bit integer data from \a __X to both the lower and
+///    upper halves of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VBROADCASTI128 instruction.
+///
+/// \param __X
+///    A 128-bit integer vector to be broadcast.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_broadcastsi128_si256(__m128i __X)
+{
+  return (__m256i)__builtin_shufflevector((__v2di)__X, (__v2di)__X, 0, 1, 0, 1);
+}
+
+#define _mm_broadcastsi128_si256(X) _mm256_broadcastsi128_si256(X)
+
+/// Merges 32-bit integer elements from either of the two 128-bit vectors of
+///    [4 x i32] in \a V1 or \a V2 to the result's 128-bit vector of [4 x i32],
+///    as specified by the immediate integer operand \a M.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*32
+///   IF M[i] == 0
+///     result[31+j:j] := V1[31+j:j]
+///   ELSE
+///     result[31+j:j] := V2[32+j:j]
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_blend_epi32(__m128i V1, __m128i V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPBLENDDD instruction.
+///
+/// \param V1
+///    A 128-bit vector of [4 x i32] containing source values.
+/// \param V2
+///    A 128-bit vector of [4 x i32] containing source values.
+/// \param M
+///    An immediate 8-bit integer operand, with bits [3:0] specifying the
+///    source for each element of the result. The position of the mask bit
+///    corresponds to the index of a copied value. When a mask bit is 0, the
+///    element is copied from \a V1; otherwise, it is copied from \a V2.
+/// \returns A 128-bit vector of [4 x i32] containing the result.
+#define _mm_blend_epi32(V1, V2, M) \
+  ((__m128i)__builtin_ia32_pblendd128((__v4si)(__m128i)(V1), \
+                                      (__v4si)(__m128i)(V2), (int)(M)))
+
+/// Merges 32-bit integer elements from either of the two 256-bit vectors of
+///    [8 x i32] in \a V1 or \a V2 to return a 256-bit vector of [8 x i32],
+///    as specified by the immediate integer operand \a M.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*32
+///   IF M[i] == 0
+///     result[31+j:j] := V1[31+j:j]
+///   ELSE
+///     result[31+j:j] := V2[32+j:j]
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_blend_epi32(__m256i V1, __m256i V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPBLENDDD instruction.
+///
+/// \param V1
+///    A 256-bit vector of [8 x i32] containing source values.
+/// \param V2
+///    A 256-bit vector of [8 x i32] containing source values.
+/// \param M
+///    An immediate 8-bit integer operand, with bits [7:0] specifying the
+///    source for each element of the result. The position of the mask bit
+///    corresponds to the index of a copied value. When a mask bit is 0, the
+///    element is copied from \a V1; otherwise, it is is copied from \a V2.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+#define _mm256_blend_epi32(V1, V2, M) \
+  ((__m256i)__builtin_ia32_pblendd256((__v8si)(__m256i)(V1), \
+                                      (__v8si)(__m256i)(V2), (int)(M)))
+
+/// Broadcasts the low byte from the 128-bit integer vector in \a __X to all
+///    bytes of the 256-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPBROADCASTB instruction.
+///
+/// \param __X
+///    A 128-bit integer vector whose low byte will be broadcast.
+/// \returns A 256-bit integer vector containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_broadcastb_epi8(__m128i __X)
+{
+  return (__m256i)__builtin_shufflevector((__v16qi)__X, (__v16qi)__X, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+/// Broadcasts the low element from the 128-bit vector of [8 x i16] in \a __X
+///    to all elements of the result's 256-bit vector of [16 x i16].
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPBROADCASTW instruction.
+///
+/// \param __X
+///    A 128-bit vector of [8 x i16] whose low element will be broadcast.
+/// \returns A 256-bit vector of [16 x i16] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_broadcastw_epi16(__m128i __X)
+{
+  return (__m256i)__builtin_shufflevector((__v8hi)__X, (__v8hi)__X, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+/// Broadcasts the low element from the 128-bit vector of [4 x i32] in \a __X
+///    to all elements of the result's 256-bit vector of [8 x i32].
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPBROADCASTD instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] whose low element will be broadcast.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_broadcastd_epi32(__m128i __X)
+{
+  return (__m256i)__builtin_shufflevector((__v4si)__X, (__v4si)__X, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+/// Broadcasts the low element from the 128-bit vector of [2 x i64] in \a __X
+///    to all elements of the result's 256-bit vector of [4 x i64].
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPBROADCASTQ instruction.
+///
+/// \param __X
+///    A 128-bit vector of [2 x i64] whose low element will be broadcast.
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_broadcastq_epi64(__m128i __X)
+{
+  return (__m256i)__builtin_shufflevector((__v2di)__X, (__v2di)__X, 0, 0, 0, 0);
+}
+
+/// Broadcasts the low byte from the 128-bit integer vector in \a __X to all
+///    bytes of the 128-bit result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPBROADCASTB instruction.
+///
+/// \param __X
+///    A 128-bit integer vector whose low byte will be broadcast.
+/// \returns A 128-bit integer vector containing the result.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_broadcastb_epi8(__m128i __X)
+{
+  return (__m128i)__builtin_shufflevector((__v16qi)__X, (__v16qi)__X, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+/// Broadcasts the low element from the 128-bit vector of [8 x i16] in
+///    \a __X to all elements of the result's 128-bit vector of [8 x i16].
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPBROADCASTW instruction.
+///
+/// \param __X
+///    A 128-bit vector of [8 x i16] whose low element will be broadcast.
+/// \returns A 128-bit vector of [8 x i16] containing the result.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_broadcastw_epi16(__m128i __X)
+{
+  return (__m128i)__builtin_shufflevector((__v8hi)__X, (__v8hi)__X, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+/// Broadcasts the low element from the 128-bit vector of [4 x i32] in \a __X
+///    to all elements of the result's vector of [4 x i32].
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPBROADCASTD instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] whose low element will be broadcast.
+/// \returns A 128-bit vector of [4 x i32] containing the result.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_broadcastd_epi32(__m128i __X)
+{
+  return (__m128i)__builtin_shufflevector((__v4si)__X, (__v4si)__X, 0, 0, 0, 0);
+}
+
+/// Broadcasts the low element from the 128-bit vector of [2 x i64] in \a __X
+///    to both elements of the result's 128-bit vector of [2 x i64].
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPBROADCASTQ instruction.
+///
+/// \param __X
+///    A 128-bit vector of [2 x i64] whose low element will be broadcast.
+/// \returns A 128-bit vector of [2 x i64] containing the result.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_broadcastq_epi64(__m128i __X)
+{
+  return (__m128i)__builtin_shufflevector((__v2di)__X, (__v2di)__X, 0, 0);
+}
+
+/// Sets the result's 256-bit vector of [8 x i32] to copies of elements of the
+///    256-bit vector of [8 x i32] in \a __a as specified by indexes in the
+///    elements of the 256-bit vector of [8 x i32] in \a __b.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*32
+///   k := __b[j+2:j] * 32
+///   result[j+31:j] := __a[k+31:k]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPERMD instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32] containing the source values.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing indexes of values to use from
+///    \a __a.
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_permutevar8x32_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)__builtin_ia32_permvarsi256((__v8si)__a, (__v8si)__b);
+}
+
+/// Sets the result's 256-bit vector of [4 x double] to copies of elements of
+///    the 256-bit vector of [4 x double] in \a V as specified by the
+///    immediate value \a M.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*64
+///   k := (M >> i*2)[1:0] * 64
+///   result[j+63:j] := V[k+63:k]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256d _mm256_permute4x64_pd(__m256d V, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPERMPD instruction.
+///
+/// \param V
+///    A 256-bit vector of [4 x double] containing the source values.
+/// \param M
+///    An immediate 8-bit value specifying which elements to copy from \a V.
+///    \a M[1:0] specifies the index in \a a for element 0 of the result,
+///    \a M[3:2] specifies the index for element 1, and so forth.
+/// \returns A 256-bit vector of [4 x double] containing the result.
+#define _mm256_permute4x64_pd(V, M) \
+  ((__m256d)__builtin_ia32_permdf256((__v4df)(__m256d)(V), (int)(M)))
+
+/// Sets the result's 256-bit vector of [8 x float] to copies of elements of
+///    the 256-bit vector of [8 x float] in \a __a as specified by indexes in
+///    the elements of the 256-bit vector of [8 x i32] in \a __b.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*32
+///   k := __b[j+2:j] * 32
+///   result[j+31:j] := __a[k+31:k]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPERMPS instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing the source values.
+/// \param __b
+///    A 256-bit vector of [8 x i32] containing indexes of values to use from
+///    \a __a.
+/// \returns A 256-bit vector of [8 x float] containing the result.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_permutevar8x32_ps(__m256 __a, __m256i __b)
+{
+  return (__m256)__builtin_ia32_permvarsf256((__v8sf)__a, (__v8si)__b);
+}
+
+/// Sets the result's 256-bit vector of [4 x i64] result to copies of elements
+///    of the 256-bit vector of [4 x i64] in \a V as specified by the
+///    immediate value \a M.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*64
+///   k := (M >> i*2)[1:0] * 64
+///   result[j+63:j] := V[k+63:k]
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_permute4x64_epi64(__m256i V, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPERMQ instruction.
+///
+/// \param V
+///    A 256-bit vector of [4 x i64] containing the source values.
+/// \param M
+///    An immediate 8-bit value specifying which elements to copy from \a V.
+///    \a M[1:0] specifies the index in \a a for element 0 of the result,
+///    \a M[3:2] specifies the index for element 1, and so forth.
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+#define _mm256_permute4x64_epi64(V, M) \
+  ((__m256i)__builtin_ia32_permdi256((__v4di)(__m256i)(V), (int)(M)))
+
+/// Sets each half of the 256-bit result either to zero or to one of the
+///    four possible 128-bit halves of the 256-bit vectors \a V1 and \a V2,
+///    as specified by the immediate value \a M.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 1
+///   j := i*128
+///   k := M >> (i*4)
+///   IF k[3] == 0
+///     CASE (k[1:0]) OF
+///     0: result[127+j:j] := V1[127:0]
+///     1: result[127+j:j] := V1[255:128]
+///     2: result[127+j:j] := V2[127:0]
+///     3: result[127+j:j] := V2[255:128]
+///     ESAC
+///   ELSE
+///     result[127+j:j] := 0
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_permute2x128_si256(__m256i V1, __m256i V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPERM2I128 instruction.
+///
+/// \param V1
+///    A 256-bit integer vector containing source values.
+/// \param V2
+///    A 256-bit integer vector containing source values.
+/// \param M
+///    An immediate value specifying how to form the result. Bits [3:0]
+///    control the lower half of the result, bits [7:4] control the upper half.
+///    Within each 4-bit control value, if bit 3 is 1, the result is zero,
+///    otherwise bits [1:0] determine the source as follows. \n
+///    0: the lower half of \a V1 \n
+///    1: the upper half of \a V1 \n
+///    2: the lower half of \a V2 \n
+///    3: the upper half of \a V2
+/// \returns A 256-bit integer vector containing the result.
+#define _mm256_permute2x128_si256(V1, V2, M) \
+  ((__m256i)__builtin_ia32_permti256((__m256i)(V1), (__m256i)(V2), (int)(M)))
+
+/// Extracts half of the 256-bit vector \a V to the 128-bit result. If bit 0
+///     of the immediate \a M is zero, extracts the lower half of the result;
+///     otherwise, extracts the upper half.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm256_extracti128_si256(__m256i V, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VEXTRACTI128 instruction.
+///
+/// \param V
+///    A 256-bit integer vector containing the source values.
+/// \param M
+///    An immediate value specifying which half of \a V to extract.
+/// \returns A 128-bit integer vector containing the result.
+#define _mm256_extracti128_si256(V, M) \
+  ((__m128i)__builtin_ia32_extract128i256((__v4di)(__m256i)(V), (int)(M)))
+
+/// Copies the 256-bit vector \a V1 to the result, then overwrites half of the
+///     result with the 128-bit vector \a V2. If bit 0 of the immediate \a M
+///     is zero, overwrites the lower half of the result; otherwise,
+///     overwrites the upper half.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_inserti128_si256(__m256i V1, __m128i V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VINSERTI128 instruction.
+///
+/// \param V1
+///    A 256-bit integer vector containing a source value.
+/// \param V2
+///    A 128-bit integer vector containing a source value.
+/// \param M
+///    An immediate value specifying where to put \a V2 in the result.
+/// \returns A 256-bit integer vector containing the result.
+#define _mm256_inserti128_si256(V1, V2, M) \
+  ((__m256i)__builtin_ia32_insert128i256((__v4di)(__m256i)(V1), \
+                                         (__v2di)(__m128i)(V2), (int)(M)))
+
+/// Conditionally loads eight 32-bit integer elements from memory \a __X, if
+///    the most significant bit of the corresponding element in the mask
+///    \a __M is set; otherwise, sets that element of the result to zero.
+///    Returns the 256-bit [8 x i32] result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*32
+///   IF __M[j+31] == 1
+///     result[j+31:j] := Load32(__X+(i*4))
+///   ELSE
+///     result[j+31:j] := 0
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMASKMOVD instruction.
+///
+/// \param __X
+///    A pointer to the memory used for loading values.
+/// \param __M
+///    A 256-bit vector of [8 x i32] containing the mask bits.
+/// \returns A 256-bit vector of [8 x i32] containing the loaded or zeroed
+///    elements.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskload_epi32(int const *__X, __m256i __M)
+{
+  return (__m256i)__builtin_ia32_maskloadd256((const __v8si *)__X, (__v8si)__M);
+}
+
+/// Conditionally loads four 64-bit integer elements from memory \a __X, if
+///    the most significant bit of the corresponding element in the mask
+///    \a __M is set; otherwise, sets that element of the result to zero.
+///    Returns the 256-bit [4 x i64] result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*64
+///   IF __M[j+63] == 1
+///     result[j+63:j] := Load64(__X+(i*8))
+///   ELSE
+///     result[j+63:j] := 0
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMASKMOVQ instruction.
+///
+/// \param __X
+///    A pointer to the memory used for loading values.
+/// \param __M
+///    A 256-bit vector of [4 x i64] containing the mask bits.
+/// \returns A 256-bit vector of [4 x i64] containing the loaded or zeroed
+///    elements.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskload_epi64(long long const *__X, __m256i __M)
+{
+  return (__m256i)__builtin_ia32_maskloadq256((const __v4di *)__X, (__v4di)__M);
+}
+
+/// Conditionally loads four 32-bit integer elements from memory \a __X, if
+///    the most significant bit of the corresponding element in the mask
+///    \a __M is set; otherwise, sets that element of the result to zero.
+///    Returns the 128-bit [4 x i32] result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*32
+///   IF __M[j+31] == 1
+///     result[j+31:j] := Load32(__X+(i*4))
+///   ELSE
+///     result[j+31:j] := 0
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMASKMOVD instruction.
+///
+/// \param __X
+///    A pointer to the memory used for loading values.
+/// \param __M
+///    A 128-bit vector of [4 x i32] containing the mask bits.
+/// \returns A 128-bit vector of [4 x i32] containing the loaded or zeroed
+///    elements.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskload_epi32(int const *__X, __m128i __M)
+{
+  return (__m128i)__builtin_ia32_maskloadd((const __v4si *)__X, (__v4si)__M);
+}
+
+/// Conditionally loads two 64-bit integer elements from memory \a __X, if
+///    the most significant bit of the corresponding element in the mask
+///    \a __M is set; otherwise, sets that element of the result to zero.
+///    Returns the 128-bit [2 x i64] result.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 1
+///   j := i*64
+///   IF __M[j+63] == 1
+///     result[j+63:j] := Load64(__X+(i*8))
+///   ELSE
+///     result[j+63:j] := 0
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMASKMOVQ instruction.
+///
+/// \param __X
+///    A pointer to the memory used for loading values.
+/// \param __M
+///    A 128-bit vector of [2 x i64] containing the mask bits.
+/// \returns A 128-bit vector of [2 x i64] containing the loaded or zeroed
+///    elements.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskload_epi64(long long const *__X, __m128i __M)
+{
+  return (__m128i)__builtin_ia32_maskloadq((const __v2di *)__X, (__v2di)__M);
+}
+
+/// Conditionally stores eight 32-bit integer elements from the 256-bit vector
+///    of [8 x i32] in \a __Y to memory \a __X, if the most significant bit of
+///    the corresponding element in the mask \a __M is set; otherwise, the
+///    memory element is unchanged.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 7
+///   j := i*32
+///   IF __M[j+31] == 1
+///     Store32(__X+(i*4), __Y[j+31:j])
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMASKMOVD instruction.
+///
+/// \param __X
+///    A pointer to the memory used for storing values.
+/// \param __M
+///    A 256-bit vector of [8 x i32] containing the mask bits.
+/// \param __Y
+///    A 256-bit vector of [8 x i32] containing the values to store.
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_maskstore_epi32(int *__X, __m256i __M, __m256i __Y)
+{
+  __builtin_ia32_maskstored256((__v8si *)__X, (__v8si)__M, (__v8si)__Y);
+}
+
+/// Conditionally stores four 64-bit integer elements from the 256-bit vector
+///    of [4 x i64] in \a __Y to memory \a __X, if the most significant bit of
+///    the corresponding element in the mask \a __M is set; otherwise, the
+///    memory element is unchanged.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*64
+///   IF __M[j+63] == 1
+///     Store64(__X+(i*8), __Y[j+63:j])
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMASKMOVQ instruction.
+///
+/// \param __X
+///    A pointer to the memory used for storing values.
+/// \param __M
+///    A 256-bit vector of [4 x i64] containing the mask bits.
+/// \param __Y
+///    A 256-bit vector of [4 x i64] containing the values to store.
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_maskstore_epi64(long long *__X, __m256i __M, __m256i __Y)
+{
+  __builtin_ia32_maskstoreq256((__v4di *)__X, (__v4di)__M, (__v4di)__Y);
+}
+
+/// Conditionally stores four 32-bit integer elements from the 128-bit vector
+///    of [4 x i32] in \a __Y to memory \a __X, if the most significant bit of
+///    the corresponding element in the mask \a __M is set; otherwise, the
+///    memory element is unchanged.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 3
+///   j := i*32
+///   IF __M[j+31] == 1
+///     Store32(__X+(i*4), __Y[j+31:j])
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMASKMOVD instruction.
+///
+/// \param __X
+///    A pointer to the memory used for storing values.
+/// \param __M
+///    A 128-bit vector of [4 x i32] containing the mask bits.
+/// \param __Y
+///    A 128-bit vector of [4 x i32] containing the values to store.
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_maskstore_epi32(int *__X, __m128i __M, __m128i __Y)
+{
+  __builtin_ia32_maskstored((__v4si *)__X, (__v4si)__M, (__v4si)__Y);
+}
+
+/// Conditionally stores two 64-bit integer elements from the 128-bit vector
+///    of [2 x i64] in \a __Y to memory \a __X, if the most significant bit of
+///    the corresponding element in the mask \a __M is set; otherwise, the
+///    memory element is unchanged.
+///
+/// \code{.operation}
+/// FOR i := 0 TO 1
+///   j := i*64
+///   IF __M[j+63] == 1
+///     Store64(__X+(i*8), __Y[j+63:j])
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPMASKMOVQ instruction.
+///
+/// \param __X
+///    A pointer to the memory used for storing values.
+/// \param __M
+///    A 128-bit vector of [2 x i64] containing the mask bits.
+/// \param __Y
+///    A 128-bit vector of [2 x i64] containing the values to store.
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_maskstore_epi64(long long *__X, __m128i __M, __m128i __Y)
+{
+  __builtin_ia32_maskstoreq(( __v2di *)__X, (__v2di)__M, (__v2di)__Y);
+}
+
+/// Shifts each 32-bit element of the 256-bit vector of [8 x i32] in \a __X
+///    left by the number of bits given in the corresponding element of the
+///    256-bit vector of [8 x i32] in \a __Y, shifting in zero bits, and
+///    returns the result. If the shift count for any element is greater than
+///    31, the result for that element is zero.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSLLVD instruction.
+///
+/// \param __X
+///    A 256-bit vector of [8 x i32] to be shifted.
+/// \param __Y
+///    A 256-bit vector of [8 x i32] containing the unsigned shift counts (in
+///    bits).
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sllv_epi32(__m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_psllv8si((__v8si)__X, (__v8si)__Y);
+}
+
+/// Shifts each 32-bit element of the 128-bit vector of [4 x i32] in \a __X
+///    left by the number of bits given in the corresponding element of the
+///    128-bit vector of [4 x i32] in \a __Y, shifting in zero bits, and
+///    returns the result. If the shift count for any element is greater than
+///    31, the result for that element is zero.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSLLVD instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] to be shifted.
+/// \param __Y
+///    A 128-bit vector of [4 x i32] containing the unsigned shift counts (in
+///    bits).
+/// \returns A 128-bit vector of [4 x i32] containing the result.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_sllv_epi32(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_psllv4si((__v4si)__X, (__v4si)__Y);
+}
+
+/// Shifts each 64-bit element of the 256-bit vector of [4 x i64] in \a __X
+///    left by the number of bits given in the corresponding element of the
+///    128-bit vector of [4 x i64] in \a __Y, shifting in zero bits, and
+///    returns the result. If the shift count for any element is greater than
+///    63, the result for that element is zero.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSLLVQ instruction.
+///
+/// \param __X
+///    A 256-bit vector of [4 x i64] to be shifted.
+/// \param __Y
+///    A 256-bit vector of [4 x i64] containing the unsigned shift counts (in
+///    bits).
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sllv_epi64(__m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_psllv4di((__v4di)__X, (__v4di)__Y);
+}
+
+/// Shifts each 64-bit element of the 128-bit vector of [2 x i64] in \a __X
+///    left by the number of bits given in the corresponding element of the
+///    128-bit vector of [2 x i64] in \a __Y, shifting in zero bits, and
+///    returns the result. If the shift count for any element is greater than
+///    63, the result for that element is zero.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSLLVQ instruction.
+///
+/// \param __X
+///    A 128-bit vector of [2 x i64] to be shifted.
+/// \param __Y
+///    A 128-bit vector of [2 x i64] containing the unsigned shift counts (in
+///    bits).
+/// \returns A 128-bit vector of [2 x i64] containing the result.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_sllv_epi64(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_psllv2di((__v2di)__X, (__v2di)__Y);
+}
+
+/// Shifts each 32-bit element of the 256-bit vector of [8 x i32] in \a __X
+///    right by the number of bits given in the corresponding element of the
+///    256-bit vector of [8 x i32] in \a __Y, shifting in sign bits, and
+///    returns the result. If the shift count for any element is greater than
+///    31, the result for that element is 0 or -1 according to the sign bit
+///    for that element.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRAVD instruction.
+///
+/// \param __X
+///    A 256-bit vector of [8 x i32] to be shifted.
+/// \param __Y
+///    A 256-bit vector of [8 x i32] containing the unsigned shift counts (in
+///    bits).
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srav_epi32(__m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_psrav8si((__v8si)__X, (__v8si)__Y);
+}
+
+/// Shifts each 32-bit element of the 128-bit vector of [4 x i32] in \a __X
+///    right by the number of bits given in the corresponding element of the
+///    128-bit vector of [4 x i32] in \a __Y, shifting in sign bits, and
+///    returns the result. If the shift count for any element is greater than
+///    31, the result for that element is 0 or -1 according to the sign bit
+///    for that element.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRAVD instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] to be shifted.
+/// \param __Y
+///    A 128-bit vector of [4 x i32] containing the unsigned shift counts (in
+///    bits).
+/// \returns A 128-bit vector of [4 x i32] containing the result.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_srav_epi32(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_psrav4si((__v4si)__X, (__v4si)__Y);
+}
+
+/// Shifts each 32-bit element of the 256-bit vector of [8 x i32] in \a __X
+///    right by the number of bits given in the corresponding element of the
+///    256-bit vector of [8 x i32] in \a __Y, shifting in zero bits, and
+///    returns the result. If the shift count for any element is greater than
+///    31, the result for that element is zero.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRLVD instruction.
+///
+/// \param __X
+///    A 256-bit vector of [8 x i32] to be shifted.
+/// \param __Y
+///    A 256-bit vector of [8 x i32] containing the unsigned shift counts (in
+///    bits).
+/// \returns A 256-bit vector of [8 x i32] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srlv_epi32(__m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_psrlv8si((__v8si)__X, (__v8si)__Y);
+}
+
+/// Shifts each 32-bit element of the 128-bit vector of [4 x i32] in \a __X
+///    right by the number of bits given in the corresponding element of the
+///    128-bit vector of [4 x i32] in \a __Y, shifting in zero bits, and
+///    returns the result. If the shift count for any element is greater than
+///    31, the result for that element is zero.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRLVD instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] to be shifted.
+/// \param __Y
+///    A 128-bit vector of [4 x i32] containing the unsigned shift counts (in
+///    bits).
+/// \returns A 128-bit vector of [4 x i32] containing the result.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_srlv_epi32(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_psrlv4si((__v4si)__X, (__v4si)__Y);
+}
+
+/// Shifts each 64-bit element of the 256-bit vector of [4 x i64] in \a __X
+///    right by the number of bits given in the corresponding element of the
+///    128-bit vector of [4 x i64] in \a __Y, shifting in zero bits, and
+///    returns the result. If the shift count for any element is greater than
+///    63, the result for that element is zero.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRLVQ instruction.
+///
+/// \param __X
+///    A 256-bit vector of [4 x i64] to be shifted.
+/// \param __Y
+///    A 256-bit vector of [4 x i64] containing the unsigned shift counts (in
+///    bits).
+/// \returns A 256-bit vector of [4 x i64] containing the result.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srlv_epi64(__m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_psrlv4di((__v4di)__X, (__v4di)__Y);
+}
+
+/// Shifts each 64-bit element of the 128-bit vector of [2 x i64] in \a __X
+///    right by the number of bits given in the corresponding element of the
+///    128-bit vector of [2 x i64] in \a __Y, shifting in zero bits, and
+///    returns the result. If the shift count for any element is greater than
+///    63, the result for that element is zero.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VPSRLVQ instruction.
+///
+/// \param __X
+///    A 128-bit vector of [2 x i64] to be shifted.
+/// \param __Y
+///    A 128-bit vector of [2 x i64] containing the unsigned shift counts (in
+///    bits).
+/// \returns A 128-bit vector of [2 x i64] containing the result.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_srlv_epi64(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_psrlv2di((__v2di)__X, (__v2di)__Y);
+}
+
+/// Conditionally gathers two 64-bit floating-point values, either from the
+///    128-bit vector of [2 x double] in \a a, or from memory \a m using scaled
+///    indexes from the 128-bit vector of [4 x i32] in \a i. The 128-bit vector
+///    of [2 x double] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*64
+///   k := element*32
+///   IF mask[j+63] == 0
+///     result[j+63:j] := a[j+63:j]
+///   ELSE
+///     result[j+63:j] := Load64(m + SignExtend(i[k+31:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128d _mm_mask_i32gather_pd(__m128d a, const double *m, __m128i i,
+///                               __m128d mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERDPD instruction.
+///
+/// \param a
+///    A 128-bit vector of [2 x double] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m. Only
+///    the first two elements are used.
+/// \param mask
+///    A 128-bit vector of [2 x double] containing the mask. The most
+///    significant bit of each element in the mask vector represents the mask
+///    bits. If a mask bit is zero, the corresponding value from vector \a a
+///    is gathered; otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [2 x double] containing the gathered values.
+#define _mm_mask_i32gather_pd(a, m, i, mask, s) \
+  ((__m128d)__builtin_ia32_gatherd_pd((__v2df)(__m128i)(a), \
+                                      (double const *)(m), \
+                                      (__v4si)(__m128i)(i), \
+                                      (__v2df)(__m128d)(mask), (s)))
+
+/// Conditionally gathers four 64-bit floating-point values, either from the
+///    256-bit vector of [4 x double] in \a a, or from memory \a m using scaled
+///    indexes from the 128-bit vector of [4 x i32] in \a i. The 256-bit vector
+///    of [4 x double] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*64
+///   k := element*32
+///   IF mask[j+63] == 0
+///     result[j+63:j] := a[j+63:j]
+///   ELSE
+///     result[j+63:j] := Load64(m + SignExtend(i[k+31:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256d _mm256_mask_i32gather_pd(__m256d a, const double *m, __m128i i,
+///                                  __m256d mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERDPD instruction.
+///
+/// \param a
+///    A 256-bit vector of [4 x double] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m.
+/// \param mask
+///    A 256-bit vector of [4 x double] containing the mask. The most
+///    significant bit of each element in the mask vector represents the mask
+///    bits. If a mask bit is zero, the corresponding value from vector \a a
+///    is gathered; otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [4 x double] containing the gathered values.
+#define _mm256_mask_i32gather_pd(a, m, i, mask, s) \
+  ((__m256d)__builtin_ia32_gatherd_pd256((__v4df)(__m256d)(a), \
+                                         (double const *)(m), \
+                                         (__v4si)(__m128i)(i), \
+                                         (__v4df)(__m256d)(mask), (s)))
+
+/// Conditionally gathers two 64-bit floating-point values, either from the
+///    128-bit vector of [2 x double] in \a a, or from memory \a m using scaled
+///    indexes from the 128-bit vector of [2 x i64] in \a i. The 128-bit vector
+///    of [2 x double] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*64
+///   k := element*64
+///   IF mask[j+63] == 0
+///     result[j+63:j] := a[j+63:j]
+///   ELSE
+///     result[j+63:j] := Load64(m + SignExtend(i[k+63:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128d _mm_mask_i64gather_pd(__m128d a, const double *m, __m128i i,
+///                               __m128d mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERQPD instruction.
+///
+/// \param a
+///    A 128-bit vector of [2 x double] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [2 x i64] containing signed indexes into \a m.
+/// \param mask
+///    A 128-bit vector of [2 x double] containing the mask. The most
+///    significant bit of each element in the mask vector represents the mask
+///    bits. If a mask bit is zero, the corresponding value from vector \a a
+///    is gathered; otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [2 x double] containing the gathered values.
+#define _mm_mask_i64gather_pd(a, m, i, mask, s) \
+  ((__m128d)__builtin_ia32_gatherq_pd((__v2df)(__m128d)(a), \
+                                      (double const *)(m), \
+                                      (__v2di)(__m128i)(i), \
+                                      (__v2df)(__m128d)(mask), (s)))
+
+/// Conditionally gathers four 64-bit floating-point values, either from the
+///    256-bit vector of [4 x double] in \a a, or from memory \a m using scaled
+///    indexes from the 256-bit vector of [4 x i64] in \a i. The 256-bit vector
+///    of [4 x double] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*64
+///   k := element*64
+///   IF mask[j+63] == 0
+///     result[j+63:j] := a[j+63:j]
+///   ELSE
+///     result[j+63:j] := Load64(m + SignExtend(i[k+63:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256d _mm256_mask_i64gather_pd(__m256d a, const double *m, __m256i i,
+///                                  __m256d mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERQPD instruction.
+///
+/// \param a
+///    A 256-bit vector of [4 x double] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [4 x i64] containing signed indexes into \a m.
+/// \param mask
+///    A 256-bit vector of [4 x double] containing the mask. The most
+///    significant bit of each element in the mask vector represents the mask
+///    bits. If a mask bit is zero, the corresponding value from vector \a a
+///    is gathered; otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [4 x double] containing the gathered values.
+#define _mm256_mask_i64gather_pd(a, m, i, mask, s) \
+  ((__m256d)__builtin_ia32_gatherq_pd256((__v4df)(__m256d)(a), \
+                                         (double const *)(m), \
+                                         (__v4di)(__m256i)(i), \
+                                         (__v4df)(__m256d)(mask), (s)))
+
+/// Conditionally gathers four 32-bit floating-point values, either from the
+///    128-bit vector of [4 x float] in \a a, or from memory \a m using scaled
+///    indexes from the 128-bit vector of [4 x i32] in \a i. The 128-bit vector
+///    of [4 x float] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*32
+///   k := element*32
+///   IF mask[j+31] == 0
+///     result[j+31:j] := a[j+31:j]
+///   ELSE
+///     result[j+31:j] := Load32(m + SignExtend(i[k+31:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128 _mm_mask_i32gather_ps(__m128 a, const float *m, __m128i i,
+///                              __m128 mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERDPS instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x float] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m.
+/// \param mask
+///    A 128-bit vector of [4 x float] containing the mask. The most
+///    significant bit of each element in the mask vector represents the mask
+///    bits. If a mask bit is zero, the corresponding value from vector \a a
+///    is gathered; otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x float] containing the gathered values.
+#define _mm_mask_i32gather_ps(a, m, i, mask, s) \
+  ((__m128)__builtin_ia32_gatherd_ps((__v4sf)(__m128)(a), \
+                                     (float const *)(m), \
+                                     (__v4si)(__m128i)(i), \
+                                     (__v4sf)(__m128)(mask), (s)))
+
+/// Conditionally gathers eight 32-bit floating-point values, either from the
+///    256-bit vector of [8 x float] in \a a, or from memory \a m using scaled
+///    indexes from the 256-bit vector of [8 x i32] in \a i. The 256-bit vector
+///    of [8 x float] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 7
+///   j := element*32
+///   k := element*32
+///   IF mask[j+31] == 0
+///     result[j+31:j] := a[j+31:j]
+///   ELSE
+///     result[j+31:j] := Load32(m + SignExtend(i[k+31:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256 _mm256_mask_i32gather_ps(__m256 a, const float *m, __m256i i,
+///                                 __m256 mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERDPS instruction.
+///
+/// \param a
+///    A 256-bit vector of [8 x float] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [8 x i32] containing signed indexes into \a m.
+/// \param mask
+///    A 256-bit vector of [8 x float] containing the mask. The most
+///    significant bit of each element in the mask vector represents the mask
+///    bits. If a mask bit is zero, the corresponding value from vector \a a
+///    is gathered; otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [8 x float] containing the gathered values.
+#define _mm256_mask_i32gather_ps(a, m, i, mask, s) \
+  ((__m256)__builtin_ia32_gatherd_ps256((__v8sf)(__m256)(a), \
+                                        (float const *)(m), \
+                                        (__v8si)(__m256i)(i), \
+                                        (__v8sf)(__m256)(mask), (s)))
+
+/// Conditionally gathers two 32-bit floating-point values, either from the
+///    128-bit vector of [4 x float] in \a a, or from memory \a m using scaled
+///    indexes from the 128-bit vector of [2 x i64] in \a i. The 128-bit vector
+///    of [4 x float] in \a mask determines the source for the lower two
+///    elements. The upper two elements of the result are zeroed.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*32
+///   k := element*64
+///   IF mask[j+31] == 0
+///     result[j+31:j] := a[j+31:j]
+///   ELSE
+///     result[j+31:j] := Load32(m + SignExtend(i[k+63:k])*s)
+///   FI
+/// ENDFOR
+/// result[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128 _mm_mask_i64gather_ps(__m128 a, const float *m, __m128i i,
+///                              __m128 mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERQPS instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x float] used as the source when a mask bit is
+///    zero. Only the first two elements are used.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [2 x i64] containing signed indexes into \a m.
+/// \param mask
+///    A 128-bit vector of [4 x float] containing the mask. The most
+///    significant bit of each element in the mask vector represents the mask
+///    bits. If a mask bit is zero, the corresponding value from vector \a a
+///    is gathered; otherwise the value is loaded from memory. Only the first
+///    two elements are used.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x float] containing the gathered values.
+#define _mm_mask_i64gather_ps(a, m, i, mask, s) \
+  ((__m128)__builtin_ia32_gatherq_ps((__v4sf)(__m128)(a), \
+                                     (float const *)(m), \
+                                     (__v2di)(__m128i)(i), \
+                                     (__v4sf)(__m128)(mask), (s)))
+
+/// Conditionally gathers four 32-bit floating-point values, either from the
+///    128-bit vector of [4 x float] in \a a, or from memory \a m using scaled
+///    indexes from the 256-bit vector of [4 x i64] in \a i. The 128-bit vector
+///    of [4 x float] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*32
+///   k := element*64
+///   IF mask[j+31] == 0
+///     result[j+31:j] := a[j+31:j]
+///   ELSE
+///     result[j+31:j] := Load32(m + SignExtend(i[k+63:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128 _mm256_mask_i64gather_ps(__m128 a, const float *m, __m256i i,
+///                                 __m128 mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERQPS instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x float] used as the source when a mask bit is
+///   zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [4 x i64] containing signed indexes into \a m.
+/// \param mask
+///    A 128-bit vector of [4 x float] containing the mask. The most
+///    significant bit of each element in the mask vector represents the mask
+///    bits. If a mask bit is zero, the corresponding value from vector \a a
+///    is gathered; otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x float] containing the gathered values.
+#define _mm256_mask_i64gather_ps(a, m, i, mask, s) \
+  ((__m128)__builtin_ia32_gatherq_ps256((__v4sf)(__m128)(a), \
+                                        (float const *)(m), \
+                                        (__v4di)(__m256i)(i), \
+                                        (__v4sf)(__m128)(mask), (s)))
+
+/// Conditionally gathers four 32-bit integer values, either from the
+///    128-bit vector of [4 x i32] in \a a, or from memory \a m using scaled
+///    indexes from the 128-bit vector of [4 x i32] in \a i. The 128-bit vector
+///    of [4 x i32] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*32
+///   k := element*32
+///   IF mask[j+31] == 0
+///     result[j+31:j] := a[j+31:j]
+///   ELSE
+///     result[j+31:j] := Load32(m + SignExtend(i[k+31:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_mask_i32gather_epi32(__m128i a, const int *m, __m128i i,
+///                                  __m128i mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERDD instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x i32] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m.
+/// \param mask
+///    A 128-bit vector of [4 x i32] containing the mask. The most significant
+///    bit of each element in the mask vector represents the mask bits. If a
+///    mask bit is zero, the corresponding value from vector \a a is gathered;
+///    otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x i32] containing the gathered values.
+#define _mm_mask_i32gather_epi32(a, m, i, mask, s) \
+  ((__m128i)__builtin_ia32_gatherd_d((__v4si)(__m128i)(a), \
+                                     (int const *)(m), \
+                                     (__v4si)(__m128i)(i), \
+                                     (__v4si)(__m128i)(mask), (s)))
+
+/// Conditionally gathers eight 32-bit integer values, either from the
+///    256-bit vector of [8 x i32] in \a a, or from memory \a m using scaled
+///    indexes from the 256-bit vector of [8 x i32] in \a i. The 256-bit vector
+///    of [8 x i32] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 7
+///   j := element*32
+///   k := element*32
+///   IF mask[j+31] == 0
+///     result[j+31:j] := a[j+31:j]
+///   ELSE
+///     result[j+31:j] := Load32(m + SignExtend(i[k+31:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_mask_i32gather_epi32(__m256i a, const int *m, __m256i i,
+///                                     __m256i mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERDD instruction.
+///
+/// \param a
+///    A 256-bit vector of [8 x i32] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [8 x i32] containing signed indexes into \a m.
+/// \param mask
+///    A 256-bit vector of [8 x i32] containing the mask. The most significant
+///    bit of each element in the mask vector represents the mask bits. If a
+///    mask bit is zero, the corresponding value from vector \a a is gathered;
+///    otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [8 x i32] containing the gathered values.
+#define _mm256_mask_i32gather_epi32(a, m, i, mask, s) \
+  ((__m256i)__builtin_ia32_gatherd_d256((__v8si)(__m256i)(a), \
+                                        (int const *)(m), \
+                                        (__v8si)(__m256i)(i), \
+                                        (__v8si)(__m256i)(mask), (s)))
+
+/// Conditionally gathers two 32-bit integer values, either from the
+///    128-bit vector of [4 x i32] in \a a, or from memory \a m using scaled
+///    indexes from the 128-bit vector of [2 x i64] in \a i. The 128-bit vector
+///    of [4 x i32] in \a mask determines the source for the lower two
+///    elements. The upper two elements of the result are zeroed.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*32
+///   k := element*64
+///   IF mask[j+31] == 0
+///     result[j+31:j] := a[j+31:j]
+///   ELSE
+///     result[j+31:j] := Load32(m + SignExtend(i[k+63:k])*s)
+///   FI
+/// ENDFOR
+/// result[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_mask_i64gather_epi32(__m128i a, const int *m, __m128i i,
+///                                  __m128i mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERQD instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x i32] used as the source when a mask bit is
+///   zero. Only the first two elements are used.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [2 x i64] containing indexes into \a m.
+/// \param mask
+///    A 128-bit vector of [4 x i32] containing the mask. The most significant
+///    bit of each element in the mask vector represents the mask bits. If a
+///    mask bit is zero, the corresponding value from vector \a a is gathered;
+///    otherwise the value is loaded from memory. Only the first two elements
+///    are used.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x i32] containing the gathered values.
+#define _mm_mask_i64gather_epi32(a, m, i, mask, s) \
+  ((__m128i)__builtin_ia32_gatherq_d((__v4si)(__m128i)(a), \
+                                     (int const *)(m), \
+                                     (__v2di)(__m128i)(i), \
+                                     (__v4si)(__m128i)(mask), (s)))
+
+/// Conditionally gathers four 32-bit integer values, either from the
+///    128-bit vector of [4 x i32] in \a a, or from memory \a m using scaled
+///    indexes from the 256-bit vector of [4 x i64] in \a i. The 128-bit vector
+///    of [4 x i32] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*32
+///   k := element*64
+///   IF mask[j+31] == 0
+///     result[j+31:j] := a[j+31:j]
+///   ELSE
+///     result[j+31:j] := Load32(m + SignExtend(i[k+63:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm256_mask_i64gather_epi32(__m128i a, const int *m, __m256i i,
+///                                     __m128i mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERQD instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x i32] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [4 x i64] containing signed indexes into \a m.
+/// \param mask
+///    A 128-bit vector of [4 x i32] containing the mask. The most significant
+///    bit of each element in the mask vector represents the mask bits. If a
+///    mask bit is zero, the corresponding value from vector \a a is gathered;
+///    otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x i32] containing the gathered values.
+#define _mm256_mask_i64gather_epi32(a, m, i, mask, s) \
+  ((__m128i)__builtin_ia32_gatherq_d256((__v4si)(__m128i)(a), \
+                                        (int const *)(m), \
+                                        (__v4di)(__m256i)(i), \
+                                        (__v4si)(__m128i)(mask), (s)))
+
+/// Conditionally gathers two 64-bit integer values, either from the
+///    128-bit vector of [2 x i64] in \a a, or from memory \a m using scaled
+///    indexes from the 128-bit vector of [4 x i32] in \a i. The 128-bit vector
+///    of [2 x i64] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*64
+///   k := element*32
+///   IF mask[j+63] == 0
+///     result[j+63:j] := a[j+63:j]
+///   ELSE
+///     result[j+63:j] := Load64(m + SignExtend(i[k+31:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_mask_i32gather_epi64(__m128i a, const long long *m, __m128i i,
+///                                  __m128i mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERDQ instruction.
+///
+/// \param a
+///    A 128-bit vector of [2 x i64] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m. Only
+///    the first two elements are used.
+/// \param mask
+///    A 128-bit vector of [2 x i64] containing the mask. The most significant
+///    bit of each element in the mask vector represents the mask bits. If a
+///    mask bit is zero, the corresponding value from vector \a a is gathered;
+///    otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [2 x i64] containing the gathered values.
+#define _mm_mask_i32gather_epi64(a, m, i, mask, s) \
+  ((__m128i)__builtin_ia32_gatherd_q((__v2di)(__m128i)(a), \
+                                     (long long const *)(m), \
+                                     (__v4si)(__m128i)(i), \
+                                     (__v2di)(__m128i)(mask), (s)))
+
+/// Conditionally gathers four 64-bit integer values, either from the
+///    256-bit vector of [4 x i64] in \a a, or from memory \a m using scaled
+///    indexes from the 128-bit vector of [4 x i32] in \a i. The 256-bit vector
+///    of [4 x i64] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*64
+///   k := element*32
+///   IF mask[j+63] == 0
+///     result[j+63:j] := a[j+63:j]
+///   ELSE
+///     result[j+63:j] := Load64(m + SignExtend(i[k+31:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_mask_i32gather_epi64(__m256i a, const long long *m,
+///                                     __m128i i, __m256i mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERDQ instruction.
+///
+/// \param a
+///    A 256-bit vector of [4 x i64] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m.
+/// \param mask
+///    A 256-bit vector of [4 x i64] containing the mask. The most significant
+///    bit of each element in the mask vector represents the mask bits. If a
+///    mask bit is zero, the corresponding value from vector \a a is gathered;
+///    otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [4 x i64] containing the gathered values.
+#define _mm256_mask_i32gather_epi64(a, m, i, mask, s) \
+  ((__m256i)__builtin_ia32_gatherd_q256((__v4di)(__m256i)(a), \
+                                        (long long const *)(m), \
+                                        (__v4si)(__m128i)(i), \
+                                        (__v4di)(__m256i)(mask), (s)))
+
+/// Conditionally gathers two 64-bit integer values, either from the
+///    128-bit vector of [2 x i64] in \a a, or from memory \a m using scaled
+///    indexes from the 128-bit vector of [2 x i64] in \a i. The 128-bit vector
+///    of [2 x i64] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*64
+///   k := element*64
+///   IF mask[j+63] == 0
+///     result[j+63:j] := a[j+63:j]
+///   ELSE
+///     result[j+63:j] := Load64(m + SignExtend(i[k+63:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_mask_i64gather_epi64(__m128i a, const long long *m, __m128i i,
+///                                  __m128i mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERQQ instruction.
+///
+/// \param a
+///    A 128-bit vector of [2 x i64] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [2 x i64] containing signed indexes into \a m.
+/// \param mask
+///    A 128-bit vector of [2 x i64] containing the mask. The most significant
+///    bit of each element in the mask vector represents the mask bits. If a
+///    mask bit is zero, the corresponding value from vector \a a is gathered;
+///    otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [2 x i64] containing the gathered values.
+#define _mm_mask_i64gather_epi64(a, m, i, mask, s) \
+  ((__m128i)__builtin_ia32_gatherq_q((__v2di)(__m128i)(a), \
+                                     (long long const *)(m), \
+                                     (__v2di)(__m128i)(i), \
+                                     (__v2di)(__m128i)(mask), (s)))
+
+/// Conditionally gathers four 64-bit integer values, either from the
+///    256-bit vector of [4 x i64] in \a a, or from memory \a m using scaled
+///    indexes from the 256-bit vector of [4 x i64] in \a i. The 256-bit vector
+///    of [4 x i64] in \a mask determines the source for each element.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*64
+///   k := element*64
+///   IF mask[j+63] == 0
+///     result[j+63:j] := a[j+63:j]
+///   ELSE
+///     result[j+63:j] := Load64(m + SignExtend(i[k+63:k])*s)
+///   FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_mask_i64gather_epi64(__m256i a, const long long *m,
+///                                     __m256i i, __m256i mask, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERQQ instruction.
+///
+/// \param a
+///    A 256-bit vector of [4 x i64] used as the source when a mask bit is
+///    zero.
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [4 x i64] containing signed indexes into \a m.
+/// \param mask
+///    A 256-bit vector of [4 x i64] containing the mask. The most significant
+///    bit of each element in the mask vector represents the mask bits. If a
+///    mask bit is zero, the corresponding value from vector \a a is gathered;
+///    otherwise the value is loaded from memory.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [4 x i64] containing the gathered values.
+#define _mm256_mask_i64gather_epi64(a, m, i, mask, s) \
+  ((__m256i)__builtin_ia32_gatherq_q256((__v4di)(__m256i)(a), \
+                                        (long long const *)(m), \
+                                        (__v4di)(__m256i)(i), \
+                                        (__v4di)(__m256i)(mask), (s)))
+
+/// Gathers two 64-bit floating-point values from memory \a m using scaled
+///    indexes from the 128-bit vector of [4 x i32] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*64
+///   k := element*32
+///   result[j+63:j] := Load64(m + SignExtend(i[k+31:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128d _mm_i32gather_pd(const double *m, __m128i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERDPD instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m. Only
+///    the first two elements are used.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [2 x double] containing the gathered values.
+#define _mm_i32gather_pd(m, i, s) \
+  ((__m128d)__builtin_ia32_gatherd_pd((__v2df)_mm_undefined_pd(), \
+                                      (double const *)(m), \
+                                      (__v4si)(__m128i)(i), \
+                                      (__v2df)_mm_cmpeq_pd(_mm_setzero_pd(), \
+                                                           _mm_setzero_pd()), \
+                                      (s)))
+
+/// Gathers four 64-bit floating-point values from memory \a m using scaled
+///    indexes from the 128-bit vector of [4 x i32] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*64
+///   k := element*32
+///   result[j+63:j] := Load64(m + SignExtend(i[k+31:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256d _mm256_i32gather_pd(const double *m, __m128i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERDPD instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [4 x double] containing the gathered values.
+#define _mm256_i32gather_pd(m, i, s) \
+  ((__m256d)__builtin_ia32_gatherd_pd256((__v4df)_mm256_undefined_pd(), \
+                                         (double const *)(m), \
+                                         (__v4si)(__m128i)(i), \
+                                         (__v4df)_mm256_cmp_pd(_mm256_setzero_pd(), \
+                                                               _mm256_setzero_pd(), \
+                                                               _CMP_EQ_OQ), \
+                                         (s)))
+
+/// Gathers two 64-bit floating-point values from memory \a m using scaled
+///    indexes from the 128-bit vector of [2 x i64] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*64
+///   k := element*64
+///   result[j+63:j] := Load64(m + SignExtend(i[k+63:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128d _mm_i64gather_pd(const double *m, __m128i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERQPD instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [2 x i64] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [2 x double] containing the gathered values.
+#define _mm_i64gather_pd(m, i, s) \
+  ((__m128d)__builtin_ia32_gatherq_pd((__v2df)_mm_undefined_pd(), \
+                                      (double const *)(m), \
+                                      (__v2di)(__m128i)(i), \
+                                      (__v2df)_mm_cmpeq_pd(_mm_setzero_pd(), \
+                                                           _mm_setzero_pd()), \
+                                      (s)))
+
+/// Gathers four 64-bit floating-point values from memory \a m using scaled
+///    indexes from the 256-bit vector of [4 x i64] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*64
+///   k := element*64
+///   result[j+63:j] := Load64(m + SignExtend(i[k+63:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256d _mm256_i64gather_pd(const double *m, __m256i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERQPD instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [4 x i64] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [4 x double] containing the gathered values.
+#define _mm256_i64gather_pd(m, i, s) \
+  ((__m256d)__builtin_ia32_gatherq_pd256((__v4df)_mm256_undefined_pd(), \
+                                         (double const *)(m), \
+                                         (__v4di)(__m256i)(i), \
+                                         (__v4df)_mm256_cmp_pd(_mm256_setzero_pd(), \
+                                                               _mm256_setzero_pd(), \
+                                                               _CMP_EQ_OQ), \
+                                         (s)))
+
+/// Gathers four 32-bit floating-point values from memory \a m using scaled
+///    indexes from the 128-bit vector of [4 x i32] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*32
+///   k := element*32
+///   result[j+31:j] := Load32(m + SignExtend(i[k+31:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128 _mm_i32gather_ps(const float *m, __m128i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERDPS instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x float] containing the gathered values.
+#define _mm_i32gather_ps(m, i, s) \
+  ((__m128)__builtin_ia32_gatherd_ps((__v4sf)_mm_undefined_ps(), \
+                                     (float const *)(m), \
+                                     (__v4si)(__m128i)(i), \
+                                     (__v4sf)_mm_cmpeq_ps(_mm_setzero_ps(), \
+                                                          _mm_setzero_ps()), \
+                                     (s)))
+
+/// Gathers eight 32-bit floating-point values from memory \a m using scaled
+///    indexes from the 256-bit vector of [8 x i32] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 7
+///   j := element*32
+///   k := element*32
+///   result[j+31:j] := Load32(m + SignExtend(i[k+31:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256 _mm256_i32gather_ps(const float *m, __m256i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERDPS instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [8 x i32] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [8 x float] containing the gathered values.
+#define _mm256_i32gather_ps(m, i, s) \
+  ((__m256)__builtin_ia32_gatherd_ps256((__v8sf)_mm256_undefined_ps(), \
+                                        (float const *)(m), \
+                                        (__v8si)(__m256i)(i), \
+                                        (__v8sf)_mm256_cmp_ps(_mm256_setzero_ps(), \
+                                                              _mm256_setzero_ps(), \
+                                                              _CMP_EQ_OQ), \
+                                        (s)))
+
+/// Gathers two 32-bit floating-point values from memory \a m using scaled
+///    indexes from the 128-bit vector of [2 x i64] in \a i. The upper two
+///    elements of the result are zeroed.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*32
+///   k := element*64
+///   result[j+31:j] := Load32(m + SignExtend(i[k+63:k])*s)
+/// ENDFOR
+/// result[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128 _mm_i64gather_ps(const float *m, __m128i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERQPS instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [2 x i64] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x float] containing the gathered values.
+#define _mm_i64gather_ps(m, i, s) \
+  ((__m128)__builtin_ia32_gatherq_ps((__v4sf)_mm_undefined_ps(), \
+                                     (float const *)(m), \
+                                     (__v2di)(__m128i)(i), \
+                                     (__v4sf)_mm_cmpeq_ps(_mm_setzero_ps(), \
+                                                          _mm_setzero_ps()), \
+                                     (s)))
+
+/// Gathers four 32-bit floating-point values from memory \a m using scaled
+///    indexes from the 256-bit vector of [4 x i64] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*32
+///   k := element*64
+///   result[j+31:j] := Load32(m + SignExtend(i[k+64:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128 _mm256_i64gather_ps(const float *m, __m256i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VGATHERQPS instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [4 x i64] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x float] containing the gathered values.
+#define _mm256_i64gather_ps(m, i, s) \
+  ((__m128)__builtin_ia32_gatherq_ps256((__v4sf)_mm_undefined_ps(), \
+                                        (float const *)(m), \
+                                        (__v4di)(__m256i)(i), \
+                                        (__v4sf)_mm_cmpeq_ps(_mm_setzero_ps(), \
+                                                             _mm_setzero_ps()), \
+                                        (s)))
+
+/// Gathers four 32-bit floating-point values from memory \a m using scaled
+///    indexes from the 128-bit vector of [4 x i32] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*32
+///   k := element*32
+///   result[j+31:j] := Load32(m + SignExtend(i[k+31:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_i32gather_epi32(const int *m, __m128i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERDD instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x i32] containing the gathered values.
+#define _mm_i32gather_epi32(m, i, s) \
+  ((__m128i)__builtin_ia32_gatherd_d((__v4si)_mm_undefined_si128(), \
+                                     (int const *)(m), (__v4si)(__m128i)(i), \
+                                     (__v4si)_mm_set1_epi32(-1), (s)))
+
+/// Gathers eight 32-bit floating-point values from memory \a m using scaled
+///    indexes from the 256-bit vector of [8 x i32] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 7
+///   j := element*32
+///   k := element*32
+///   result[j+31:j] := Load32(m + SignExtend(i[k+31:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_i32gather_epi32(const int *m, __m256i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERDD instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [8 x i32] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [8 x i32] containing the gathered values.
+#define _mm256_i32gather_epi32(m, i, s) \
+  ((__m256i)__builtin_ia32_gatherd_d256((__v8si)_mm256_undefined_si256(), \
+                                        (int const *)(m), (__v8si)(__m256i)(i), \
+                                        (__v8si)_mm256_set1_epi32(-1), (s)))
+
+/// Gathers two 32-bit integer values from memory \a m using scaled indexes
+///    from the 128-bit vector of [2 x i64] in \a i. The upper two elements
+///    of the result are zeroed.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*32
+///   k := element*64
+///   result[j+31:j] := Load32(m + SignExtend(i[k+63:k])*s)
+/// ENDFOR
+/// result[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_i64gather_epi32(const int *m, __m128i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERQD instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [2 x i64] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x i32] containing the gathered values.
+#define _mm_i64gather_epi32(m, i, s) \
+  ((__m128i)__builtin_ia32_gatherq_d((__v4si)_mm_undefined_si128(), \
+                                     (int const *)(m), (__v2di)(__m128i)(i), \
+                                     (__v4si)_mm_set1_epi32(-1), (s)))
+
+/// Gathers four 32-bit integer values from memory \a m using scaled indexes
+///    from the 256-bit vector of [4 x i64] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*32
+///   k := element*64
+///   result[j+31:j] := Load32(m + SignExtend(i[k+63:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm256_i64gather_epi32(const int *m, __m256i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERQD instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [4 x i64] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [4 x i32] containing the gathered values.
+#define _mm256_i64gather_epi32(m, i, s) \
+  ((__m128i)__builtin_ia32_gatherq_d256((__v4si)_mm_undefined_si128(), \
+                                        (int const *)(m), (__v4di)(__m256i)(i), \
+                                        (__v4si)_mm_set1_epi32(-1), (s)))
+
+/// Gathers two 64-bit integer values from memory \a m using scaled indexes
+///    from the 128-bit vector of [4 x i32] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*64
+///   k := element*32
+///   result[j+63:j] := Load64(m + SignExtend(i[k+31:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_i32gather_epi64(const long long *m, __m128i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERDQ instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m. Only
+///    the first two elements are used.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [2 x i64] containing the gathered values.
+#define _mm_i32gather_epi64(m, i, s) \
+  ((__m128i)__builtin_ia32_gatherd_q((__v2di)_mm_undefined_si128(), \
+                                     (long long const *)(m), \
+                                     (__v4si)(__m128i)(i), \
+                                     (__v2di)_mm_set1_epi64x(-1), (s)))
+
+/// Gathers four 64-bit integer values from memory \a m using scaled indexes
+///    from the 128-bit vector of [4 x i32] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*64
+///   k := element*32
+///   result[j+63:j] := Load64(m + SignExtend(i[k+31:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_i32gather_epi64(const long long *m, __m128i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERDQ instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [4 x i32] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [4 x i64] containing the gathered values.
+#define _mm256_i32gather_epi64(m, i, s) \
+  ((__m256i)__builtin_ia32_gatherd_q256((__v4di)_mm256_undefined_si256(), \
+                                        (long long const *)(m), \
+                                        (__v4si)(__m128i)(i), \
+                                        (__v4di)_mm256_set1_epi64x(-1), (s)))
+
+/// Gathers two 64-bit integer values from memory \a m using scaled indexes
+///    from the 128-bit vector of [2 x i64] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 1
+///   j := element*64
+///   k := element*64
+///   result[j+63:j] := Load64(m + SignExtend(i[k+63:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_i64gather_epi64(const long long *m, __m128i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERQQ instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 128-bit vector of [2 x i64] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 128-bit vector of [2 x i64] containing the gathered values.
+#define _mm_i64gather_epi64(m, i, s) \
+  ((__m128i)__builtin_ia32_gatherq_q((__v2di)_mm_undefined_si128(), \
+                                     (long long const *)(m), \
+                                     (__v2di)(__m128i)(i), \
+                                     (__v2di)_mm_set1_epi64x(-1), (s)))
+
+/// Gathers four 64-bit integer values from memory \a m using scaled indexes
+///    from the 256-bit vector of [4 x i64] in \a i.
+///
+/// \code{.operation}
+/// FOR element := 0 to 3
+///   j := element*64
+///   k := element*64
+///   result[j+63:j] := Load64(m + SignExtend(i[k+63:k])*s)
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_i64gather_epi64(const long long *m, __m256i i, const int s);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPGATHERQQ instruction.
+///
+/// \param m
+///    A pointer to the memory used for loading values.
+/// \param i
+///    A 256-bit vector of [4 x i64] containing signed indexes into \a m.
+/// \param s
+///    A literal constant scale factor for the indexes in \a i. Must be
+///    1, 2, 4, or 8.
+/// \returns A 256-bit vector of [4 x i64] containing the gathered values.
+#define _mm256_i64gather_epi64(m, i, s) \
+  ((__m256i)__builtin_ia32_gatherq_q256((__v4di)_mm256_undefined_si256(), \
+                                        (long long const *)(m), \
+                                        (__v4di)(__m256i)(i), \
+                                        (__v4di)_mm256_set1_epi64x(-1), (s)))
+
+#undef __DEFAULT_FN_ATTRS256
+#undef __DEFAULT_FN_ATTRS128
+
+#endif /* __AVX2INTRIN_H */
diff --git a/third_party/intel/clang/avx512bf16intrin.h b/third_party/intel/clang/avx512bf16intrin.h
new file mode 100644
index 000000000..b28d2e243
--- /dev/null
+++ b/third_party/intel/clang/avx512bf16intrin.h
@@ -0,0 +1,283 @@
+/*===------------ avx512bf16intrin.h - AVX512_BF16 intrinsics --------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512bf16intrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifdef __SSE2__
+
+#ifndef __AVX512BF16INTRIN_H
+#define __AVX512BF16INTRIN_H
+
+typedef __bf16 __v32bf __attribute__((__vector_size__(64), __aligned__(64)));
+typedef __bf16 __m512bh __attribute__((__vector_size__(64), __aligned__(64)));
+typedef __bf16 __bfloat16 __attribute__((deprecated("use __bf16 instead")));
+
+#define __DEFAULT_FN_ATTRS512 \
+  __attribute__((__always_inline__, __nodebug__, __target__("avx512bf16,evex512"), \
+                 __min_vector_width__(512)))
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512bf16,no-evex512")))
+
+/// Convert One BF16 Data to One Single Float Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic does not correspond to a specific instruction.
+///
+/// \param __A
+///    A bfloat data.
+/// \returns A float data whose sign field and exponent field keep unchanged,
+///    and fraction field is extended to 23 bits.
+static __inline__ float __DEFAULT_FN_ATTRS _mm_cvtsbh_ss(__bf16 __A) {
+  return __builtin_ia32_cvtsbf162ss_32(__A);
+}
+
+/// Convert Two Packed Single Data to One Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNE2PS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 512-bit vector of [16 x float].
+/// \param __B
+///    A 512-bit vector of [16 x float].
+/// \returns A 512-bit vector of [32 x bfloat] whose lower 256 bits come from
+///    conversion of __B, and higher 256 bits come from conversion of __A.
+static __inline__ __m512bh __DEFAULT_FN_ATTRS512
+_mm512_cvtne2ps_pbh(__m512 __A, __m512 __B) {
+  return (__m512bh)__builtin_ia32_cvtne2ps2bf16_512((__v16sf) __A,
+                                                    (__v16sf) __B);
+}
+
+/// Convert Two Packed Single Data to One Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNE2PS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 512-bit vector of [16 x float].
+/// \param __B
+///    A 512-bit vector of [16 x float].
+/// \param __W
+///    A 512-bit vector of [32 x bfloat].
+/// \param __U
+///    A 32-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A or __B. A 0 means element from __W.
+/// \returns A 512-bit vector of [32 x bfloat] whose lower 256 bits come from
+///    conversion of __B, and higher 256 bits come from conversion of __A.
+static __inline__ __m512bh __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtne2ps_pbh(__m512bh __W, __mmask32 __U, __m512 __A, __m512 __B) {
+  return (__m512bh)__builtin_ia32_selectpbf_512((__mmask32)__U,
+                                        (__v32bf)_mm512_cvtne2ps_pbh(__A, __B),
+                                        (__v32bf)__W);
+}
+
+/// Convert Two Packed Single Data to One Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNE2PS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 512-bit vector of [16 x float].
+/// \param __B
+///    A 512-bit vector of [16 x float].
+/// \param __U
+///    A 32-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A or __B. A 0 means element is zero.
+/// \returns A 512-bit vector of [32 x bfloat] whose lower 256 bits come from
+///    conversion of __B, and higher 256 bits come from conversion of __A.
+static __inline__ __m512bh __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtne2ps_pbh(__mmask32 __U, __m512 __A, __m512 __B) {
+  return (__m512bh)__builtin_ia32_selectpbf_512((__mmask32)__U,
+                                        (__v32bf)_mm512_cvtne2ps_pbh(__A, __B),
+                                        (__v32bf)_mm512_setzero_si512());
+}
+
+/// Convert Packed Single Data to Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNEPS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 512-bit vector of [16 x float].
+/// \returns A 256-bit vector of [16 x bfloat] come from conversion of __A.
+static __inline__ __m256bh __DEFAULT_FN_ATTRS512
+_mm512_cvtneps_pbh(__m512 __A) {
+  return (__m256bh)__builtin_ia32_cvtneps2bf16_512_mask((__v16sf)__A,
+                                              (__v16bf)_mm256_undefined_si256(),
+                                              (__mmask16)-1);
+}
+
+/// Convert Packed Single Data to Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNEPS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 512-bit vector of [16 x float].
+/// \param __W
+///    A 256-bit vector of [16 x bfloat].
+/// \param __U
+///    A 16-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A. A 0 means element from __W.
+/// \returns A 256-bit vector of [16 x bfloat] come from conversion of __A.
+static __inline__ __m256bh __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtneps_pbh(__m256bh __W, __mmask16 __U, __m512 __A) {
+  return (__m256bh)__builtin_ia32_cvtneps2bf16_512_mask((__v16sf)__A,
+                                                        (__v16bf)__W,
+                                                        (__mmask16)__U);
+}
+
+/// Convert Packed Single Data to Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNEPS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 512-bit vector of [16 x float].
+/// \param __U
+///    A 16-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A. A 0 means element is zero.
+/// \returns A 256-bit vector of [16 x bfloat] come from conversion of __A.
+static __inline__ __m256bh __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtneps_pbh(__mmask16 __U, __m512 __A) {
+  return (__m256bh)__builtin_ia32_cvtneps2bf16_512_mask((__v16sf)__A,
+                                                (__v16bf)_mm256_setzero_si256(),
+                                                (__mmask16)__U);
+}
+
+/// Dot Product of BF16 Pairs Accumulated into Packed Single Precision.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDPBF16PS </c> instructions.
+///
+/// \param __A
+///    A 512-bit vector of [32 x bfloat].
+/// \param __B
+///    A 512-bit vector of [32 x bfloat].
+/// \param __D
+///    A 512-bit vector of [16 x float].
+/// \returns A 512-bit vector of [16 x float] comes from  Dot Product of
+///  __A, __B and __D
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_dpbf16_ps(__m512 __D, __m512bh __A, __m512bh __B) {
+  return (__m512)__builtin_ia32_dpbf16ps_512((__v16sf) __D,
+                                             (__v32bf) __A,
+                                             (__v32bf) __B);
+}
+
+/// Dot Product of BF16 Pairs Accumulated into Packed Single Precision.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDPBF16PS </c> instructions.
+///
+/// \param __A
+///    A 512-bit vector of [32 x bfloat].
+/// \param __B
+///    A 512-bit vector of [32 x bfloat].
+/// \param __D
+///    A 512-bit vector of [16 x float].
+/// \param __U
+///    A 16-bit mask value specifying what is chosen for each element.
+///    A 1 means __A and __B's dot product accumulated with __D. A 0 means __D.
+/// \returns A 512-bit vector of [16 x float] comes from  Dot Product of
+///  __A, __B and __D
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_dpbf16_ps(__m512 __D, __mmask16 __U, __m512bh __A, __m512bh __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                       (__v16sf)_mm512_dpbf16_ps(__D, __A, __B),
+                                       (__v16sf)__D);
+}
+
+/// Dot Product of BF16 Pairs Accumulated into Packed Single Precision.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDPBF16PS </c> instructions.
+///
+/// \param __A
+///    A 512-bit vector of [32 x bfloat].
+/// \param __B
+///    A 512-bit vector of [32 x bfloat].
+/// \param __D
+///    A 512-bit vector of [16 x float].
+/// \param __U
+///    A 16-bit mask value specifying what is chosen for each element.
+///    A 1 means __A and __B's dot product accumulated with __D. A 0 means 0.
+/// \returns A 512-bit vector of [16 x float] comes from  Dot Product of
+///  __A, __B and __D
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_dpbf16_ps(__mmask16 __U, __m512 __D, __m512bh __A, __m512bh __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                       (__v16sf)_mm512_dpbf16_ps(__D, __A, __B),
+                                       (__v16sf)_mm512_setzero_si512());
+}
+
+/// Convert Packed BF16 Data to Packed float Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \param __A
+///    A 256-bit vector of [16 x bfloat].
+/// \returns A 512-bit vector of [16 x float] come from conversion of __A
+static __inline__ __m512 __DEFAULT_FN_ATTRS512 _mm512_cvtpbh_ps(__m256bh __A) {
+  return _mm512_castsi512_ps((__m512i)_mm512_slli_epi32(
+      (__m512i)_mm512_cvtepi16_epi32((__m256i)__A), 16));
+}
+
+/// Convert Packed BF16 Data to Packed float Data using zeroing mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \param __U
+///    A 16-bit mask. Elements are zeroed out when the corresponding mask
+///    bit is not set.
+/// \param __A
+///    A 256-bit vector of [16 x bfloat].
+/// \returns A 512-bit vector of [16 x float] come from conversion of __A
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtpbh_ps(__mmask16 __U, __m256bh __A) {
+  return _mm512_castsi512_ps((__m512i)_mm512_slli_epi32(
+      (__m512i)_mm512_maskz_cvtepi16_epi32((__mmask16)__U, (__m256i)__A), 16));
+}
+
+/// Convert Packed BF16 Data to Packed float Data using merging mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \param __S
+///    A 512-bit vector of [16 x float]. Elements are copied from __S when
+///     the corresponding mask bit is not set.
+/// \param __U
+///    A 16-bit mask.
+/// \param __A
+///    A 256-bit vector of [16 x bfloat].
+/// \returns A 512-bit vector of [16 x float] come from conversion of __A
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtpbh_ps(__m512 __S, __mmask16 __U, __m256bh __A) {
+  return _mm512_castsi512_ps((__m512i)_mm512_mask_slli_epi32(
+      (__m512i)__S, (__mmask16)__U,
+      (__m512i)_mm512_cvtepi16_epi32((__m256i)__A), 16));
+}
+
+#undef __DEFAULT_FN_ATTRS
+#undef __DEFAULT_FN_ATTRS512
+
+#endif
+#endif
diff --git a/third_party/intel/clang/avx512bitalgintrin.h b/third_party/intel/clang/avx512bitalgintrin.h
new file mode 100644
index 000000000..bad265ceb
--- /dev/null
+++ b/third_party/intel/clang/avx512bitalgintrin.h
@@ -0,0 +1,86 @@
+/*===------------- avx512bitalgintrin.h - BITALG intrinsics ------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512bitalgintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512BITALGINTRIN_H
+#define __AVX512BITALGINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512bitalg,evex512"),                           \
+                 __min_vector_width__(512)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_popcnt_epi16(__m512i __A)
+{
+  return (__m512i) __builtin_ia32_vpopcntw_512((__v32hi) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_popcnt_epi16(__m512i __A, __mmask32 __U, __m512i __B)
+{
+  return (__m512i) __builtin_ia32_selectw_512((__mmask32) __U,
+              (__v32hi) _mm512_popcnt_epi16(__B),
+              (__v32hi) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_popcnt_epi16(__mmask32 __U, __m512i __B)
+{
+  return _mm512_mask_popcnt_epi16((__m512i) _mm512_setzero_si512(),
+              __U,
+              __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_popcnt_epi8(__m512i __A)
+{
+  return (__m512i) __builtin_ia32_vpopcntb_512((__v64qi) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_popcnt_epi8(__m512i __A, __mmask64 __U, __m512i __B)
+{
+  return (__m512i) __builtin_ia32_selectb_512((__mmask64) __U,
+              (__v64qi) _mm512_popcnt_epi8(__B),
+              (__v64qi) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_popcnt_epi8(__mmask64 __U, __m512i __B)
+{
+  return _mm512_mask_popcnt_epi8((__m512i) _mm512_setzero_si512(),
+              __U,
+              __B);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS
+_mm512_mask_bitshuffle_epi64_mask(__mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__mmask64) __builtin_ia32_vpshufbitqmb512_mask((__v64qi) __A,
+              (__v64qi) __B,
+              __U);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS
+_mm512_bitshuffle_epi64_mask(__m512i __A, __m512i __B)
+{
+  return _mm512_mask_bitshuffle_epi64_mask((__mmask64) -1,
+              __A,
+              __B);
+}
+
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/avx512bwintrin.h b/third_party/intel/clang/avx512bwintrin.h
new file mode 100644
index 000000000..c854720de
--- /dev/null
+++ b/third_party/intel/clang/avx512bwintrin.h
@@ -0,0 +1,2014 @@
+/*===------------- avx512bwintrin.h - AVX512BW intrinsics ------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512bwintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512BWINTRIN_H
+#define __AVX512BWINTRIN_H
+
+typedef unsigned int __mmask32;
+typedef unsigned long long __mmask64;
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS512                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512bw,evex512"), __min_vector_width__(512)))
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512bw,no-evex512")))
+
+static __inline __mmask32 __DEFAULT_FN_ATTRS
+_knot_mask32(__mmask32 __M)
+{
+  return __builtin_ia32_knotsi(__M);
+}
+
+static __inline __mmask64 __DEFAULT_FN_ATTRS _knot_mask64(__mmask64 __M) {
+  return __builtin_ia32_knotdi(__M);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS
+_kand_mask32(__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32)__builtin_ia32_kandsi((__mmask32)__A, (__mmask32)__B);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS _kand_mask64(__mmask64 __A,
+                                                            __mmask64 __B) {
+  return (__mmask64)__builtin_ia32_kanddi((__mmask64)__A, (__mmask64)__B);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS
+_kandn_mask32(__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32)__builtin_ia32_kandnsi((__mmask32)__A, (__mmask32)__B);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS _kandn_mask64(__mmask64 __A,
+                                                             __mmask64 __B) {
+  return (__mmask64)__builtin_ia32_kandndi((__mmask64)__A, (__mmask64)__B);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS
+_kor_mask32(__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32)__builtin_ia32_korsi((__mmask32)__A, (__mmask32)__B);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS _kor_mask64(__mmask64 __A,
+                                                           __mmask64 __B) {
+  return (__mmask64)__builtin_ia32_kordi((__mmask64)__A, (__mmask64)__B);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS
+_kxnor_mask32(__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32)__builtin_ia32_kxnorsi((__mmask32)__A, (__mmask32)__B);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS _kxnor_mask64(__mmask64 __A,
+                                                             __mmask64 __B) {
+  return (__mmask64)__builtin_ia32_kxnordi((__mmask64)__A, (__mmask64)__B);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS
+_kxor_mask32(__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32)__builtin_ia32_kxorsi((__mmask32)__A, (__mmask32)__B);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS _kxor_mask64(__mmask64 __A,
+                                                            __mmask64 __B) {
+  return (__mmask64)__builtin_ia32_kxordi((__mmask64)__A, (__mmask64)__B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortestc_mask32_u8(__mmask32 __A, __mmask32 __B)
+{
+  return (unsigned char)__builtin_ia32_kortestcsi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortestz_mask32_u8(__mmask32 __A, __mmask32 __B)
+{
+  return (unsigned char)__builtin_ia32_kortestzsi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortest_mask32_u8(__mmask32 __A, __mmask32 __B, unsigned char *__C) {
+  *__C = (unsigned char)__builtin_ia32_kortestcsi(__A, __B);
+  return (unsigned char)__builtin_ia32_kortestzsi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortestc_mask64_u8(__mmask64 __A, __mmask64 __B) {
+  return (unsigned char)__builtin_ia32_kortestcdi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortestz_mask64_u8(__mmask64 __A, __mmask64 __B) {
+  return (unsigned char)__builtin_ia32_kortestzdi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortest_mask64_u8(__mmask64 __A, __mmask64 __B, unsigned char *__C) {
+  *__C = (unsigned char)__builtin_ia32_kortestcdi(__A, __B);
+  return (unsigned char)__builtin_ia32_kortestzdi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktestc_mask32_u8(__mmask32 __A, __mmask32 __B)
+{
+  return (unsigned char)__builtin_ia32_ktestcsi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktestz_mask32_u8(__mmask32 __A, __mmask32 __B)
+{
+  return (unsigned char)__builtin_ia32_ktestzsi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktest_mask32_u8(__mmask32 __A, __mmask32 __B, unsigned char *__C) {
+  *__C = (unsigned char)__builtin_ia32_ktestcsi(__A, __B);
+  return (unsigned char)__builtin_ia32_ktestzsi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktestc_mask64_u8(__mmask64 __A, __mmask64 __B) {
+  return (unsigned char)__builtin_ia32_ktestcdi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktestz_mask64_u8(__mmask64 __A, __mmask64 __B) {
+  return (unsigned char)__builtin_ia32_ktestzdi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktest_mask64_u8(__mmask64 __A, __mmask64 __B, unsigned char *__C) {
+  *__C = (unsigned char)__builtin_ia32_ktestcdi(__A, __B);
+  return (unsigned char)__builtin_ia32_ktestzdi(__A, __B);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS
+_kadd_mask32(__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32)__builtin_ia32_kaddsi((__mmask32)__A, (__mmask32)__B);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS _kadd_mask64(__mmask64 __A,
+                                                            __mmask64 __B) {
+  return (__mmask64)__builtin_ia32_kadddi((__mmask64)__A, (__mmask64)__B);
+}
+
+#define _kshiftli_mask32(A, I) \
+  ((__mmask32)__builtin_ia32_kshiftlisi((__mmask32)(A), (unsigned int)(I)))
+
+#define _kshiftri_mask32(A, I) \
+  ((__mmask32)__builtin_ia32_kshiftrisi((__mmask32)(A), (unsigned int)(I)))
+
+#define _kshiftli_mask64(A, I) \
+  ((__mmask64)__builtin_ia32_kshiftlidi((__mmask64)(A), (unsigned int)(I)))
+
+#define _kshiftri_mask64(A, I) \
+  ((__mmask64)__builtin_ia32_kshiftridi((__mmask64)(A), (unsigned int)(I)))
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_cvtmask32_u32(__mmask32 __A) {
+  return (unsigned int)__builtin_ia32_kmovd((__mmask32)__A);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+_cvtmask64_u64(__mmask64 __A) {
+  return (unsigned long long)__builtin_ia32_kmovq((__mmask64)__A);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS
+_cvtu32_mask32(unsigned int __A) {
+  return (__mmask32)__builtin_ia32_kmovd((__mmask32)__A);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS
+_cvtu64_mask64(unsigned long long __A) {
+  return (__mmask64)__builtin_ia32_kmovq((__mmask64)__A);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS
+_load_mask32(__mmask32 *__A) {
+  return (__mmask32)__builtin_ia32_kmovd(*(__mmask32 *)__A);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS _load_mask64(__mmask64 *__A) {
+  return (__mmask64)__builtin_ia32_kmovq(*(__mmask64 *)__A);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_store_mask32(__mmask32 *__A, __mmask32 __B) {
+  *(__mmask32 *)__A = __builtin_ia32_kmovd((__mmask32)__B);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS _store_mask64(__mmask64 *__A,
+                                                        __mmask64 __B) {
+  *(__mmask64 *)__A = __builtin_ia32_kmovq((__mmask64)__B);
+}
+
+/* Integer compare */
+
+#define _mm512_cmp_epi8_mask(a, b, p) \
+  ((__mmask64)__builtin_ia32_cmpb512_mask((__v64qi)(__m512i)(a), \
+                                          (__v64qi)(__m512i)(b), (int)(p), \
+                                          (__mmask64)-1))
+
+#define _mm512_mask_cmp_epi8_mask(m, a, b, p) \
+  ((__mmask64)__builtin_ia32_cmpb512_mask((__v64qi)(__m512i)(a), \
+                                          (__v64qi)(__m512i)(b), (int)(p), \
+                                          (__mmask64)(m)))
+
+#define _mm512_cmp_epu8_mask(a, b, p) \
+  ((__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)(__m512i)(a), \
+                                           (__v64qi)(__m512i)(b), (int)(p), \
+                                           (__mmask64)-1))
+
+#define _mm512_mask_cmp_epu8_mask(m, a, b, p) \
+  ((__mmask64)__builtin_ia32_ucmpb512_mask((__v64qi)(__m512i)(a), \
+                                           (__v64qi)(__m512i)(b), (int)(p), \
+                                           (__mmask64)(m)))
+
+#define _mm512_cmp_epi16_mask(a, b, p) \
+  ((__mmask32)__builtin_ia32_cmpw512_mask((__v32hi)(__m512i)(a), \
+                                          (__v32hi)(__m512i)(b), (int)(p), \
+                                          (__mmask32)-1))
+
+#define _mm512_mask_cmp_epi16_mask(m, a, b, p) \
+  ((__mmask32)__builtin_ia32_cmpw512_mask((__v32hi)(__m512i)(a), \
+                                          (__v32hi)(__m512i)(b), (int)(p), \
+                                          (__mmask32)(m)))
+
+#define _mm512_cmp_epu16_mask(a, b, p) \
+  ((__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)(__m512i)(a), \
+                                           (__v32hi)(__m512i)(b), (int)(p), \
+                                           (__mmask32)-1))
+
+#define _mm512_mask_cmp_epu16_mask(m, a, b, p) \
+  ((__mmask32)__builtin_ia32_ucmpw512_mask((__v32hi)(__m512i)(a), \
+                                           (__v32hi)(__m512i)(b), (int)(p), \
+                                           (__mmask32)(m)))
+
+#define _mm512_cmpeq_epi8_mask(A, B) \
+    _mm512_cmp_epi8_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm512_mask_cmpeq_epi8_mask(k, A, B) \
+    _mm512_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm512_cmpge_epi8_mask(A, B) \
+    _mm512_cmp_epi8_mask((A), (B), _MM_CMPINT_GE)
+#define _mm512_mask_cmpge_epi8_mask(k, A, B) \
+    _mm512_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm512_cmpgt_epi8_mask(A, B) \
+    _mm512_cmp_epi8_mask((A), (B), _MM_CMPINT_GT)
+#define _mm512_mask_cmpgt_epi8_mask(k, A, B) \
+    _mm512_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm512_cmple_epi8_mask(A, B) \
+    _mm512_cmp_epi8_mask((A), (B), _MM_CMPINT_LE)
+#define _mm512_mask_cmple_epi8_mask(k, A, B) \
+    _mm512_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm512_cmplt_epi8_mask(A, B) \
+    _mm512_cmp_epi8_mask((A), (B), _MM_CMPINT_LT)
+#define _mm512_mask_cmplt_epi8_mask(k, A, B) \
+    _mm512_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm512_cmpneq_epi8_mask(A, B) \
+    _mm512_cmp_epi8_mask((A), (B), _MM_CMPINT_NE)
+#define _mm512_mask_cmpneq_epi8_mask(k, A, B) \
+    _mm512_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm512_cmpeq_epu8_mask(A, B) \
+    _mm512_cmp_epu8_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm512_mask_cmpeq_epu8_mask(k, A, B) \
+    _mm512_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm512_cmpge_epu8_mask(A, B) \
+    _mm512_cmp_epu8_mask((A), (B), _MM_CMPINT_GE)
+#define _mm512_mask_cmpge_epu8_mask(k, A, B) \
+    _mm512_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm512_cmpgt_epu8_mask(A, B) \
+    _mm512_cmp_epu8_mask((A), (B), _MM_CMPINT_GT)
+#define _mm512_mask_cmpgt_epu8_mask(k, A, B) \
+    _mm512_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm512_cmple_epu8_mask(A, B) \
+    _mm512_cmp_epu8_mask((A), (B), _MM_CMPINT_LE)
+#define _mm512_mask_cmple_epu8_mask(k, A, B) \
+    _mm512_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm512_cmplt_epu8_mask(A, B) \
+    _mm512_cmp_epu8_mask((A), (B), _MM_CMPINT_LT)
+#define _mm512_mask_cmplt_epu8_mask(k, A, B) \
+    _mm512_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm512_cmpneq_epu8_mask(A, B) \
+    _mm512_cmp_epu8_mask((A), (B), _MM_CMPINT_NE)
+#define _mm512_mask_cmpneq_epu8_mask(k, A, B) \
+    _mm512_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm512_cmpeq_epi16_mask(A, B) \
+    _mm512_cmp_epi16_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm512_mask_cmpeq_epi16_mask(k, A, B) \
+    _mm512_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm512_cmpge_epi16_mask(A, B) \
+    _mm512_cmp_epi16_mask((A), (B), _MM_CMPINT_GE)
+#define _mm512_mask_cmpge_epi16_mask(k, A, B) \
+    _mm512_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm512_cmpgt_epi16_mask(A, B) \
+    _mm512_cmp_epi16_mask((A), (B), _MM_CMPINT_GT)
+#define _mm512_mask_cmpgt_epi16_mask(k, A, B) \
+    _mm512_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm512_cmple_epi16_mask(A, B) \
+    _mm512_cmp_epi16_mask((A), (B), _MM_CMPINT_LE)
+#define _mm512_mask_cmple_epi16_mask(k, A, B) \
+    _mm512_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm512_cmplt_epi16_mask(A, B) \
+    _mm512_cmp_epi16_mask((A), (B), _MM_CMPINT_LT)
+#define _mm512_mask_cmplt_epi16_mask(k, A, B) \
+    _mm512_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm512_cmpneq_epi16_mask(A, B) \
+    _mm512_cmp_epi16_mask((A), (B), _MM_CMPINT_NE)
+#define _mm512_mask_cmpneq_epi16_mask(k, A, B) \
+    _mm512_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm512_cmpeq_epu16_mask(A, B) \
+    _mm512_cmp_epu16_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm512_mask_cmpeq_epu16_mask(k, A, B) \
+    _mm512_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm512_cmpge_epu16_mask(A, B) \
+    _mm512_cmp_epu16_mask((A), (B), _MM_CMPINT_GE)
+#define _mm512_mask_cmpge_epu16_mask(k, A, B) \
+    _mm512_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm512_cmpgt_epu16_mask(A, B) \
+    _mm512_cmp_epu16_mask((A), (B), _MM_CMPINT_GT)
+#define _mm512_mask_cmpgt_epu16_mask(k, A, B) \
+    _mm512_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm512_cmple_epu16_mask(A, B) \
+    _mm512_cmp_epu16_mask((A), (B), _MM_CMPINT_LE)
+#define _mm512_mask_cmple_epu16_mask(k, A, B) \
+    _mm512_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm512_cmplt_epu16_mask(A, B) \
+    _mm512_cmp_epu16_mask((A), (B), _MM_CMPINT_LT)
+#define _mm512_mask_cmplt_epu16_mask(k, A, B) \
+    _mm512_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm512_cmpneq_epu16_mask(A, B) \
+    _mm512_cmp_epu16_mask((A), (B), _MM_CMPINT_NE)
+#define _mm512_mask_cmpneq_epu16_mask(k, A, B) \
+    _mm512_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_NE)
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_add_epi8 (__m512i __A, __m512i __B) {
+  return (__m512i) ((__v64qu) __A + (__v64qu) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_add_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                             (__v64qi)_mm512_add_epi8(__A, __B),
+                                             (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_add_epi8(__mmask64 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                             (__v64qi)_mm512_add_epi8(__A, __B),
+                                             (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sub_epi8 (__m512i __A, __m512i __B) {
+  return (__m512i) ((__v64qu) __A - (__v64qu) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sub_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                             (__v64qi)_mm512_sub_epi8(__A, __B),
+                                             (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sub_epi8(__mmask64 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                             (__v64qi)_mm512_sub_epi8(__A, __B),
+                                             (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_add_epi16 (__m512i __A, __m512i __B) {
+  return (__m512i) ((__v32hu) __A + (__v32hu) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_add_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_add_epi16(__A, __B),
+                                             (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_add_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_add_epi16(__A, __B),
+                                             (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sub_epi16 (__m512i __A, __m512i __B) {
+  return (__m512i) ((__v32hu) __A - (__v32hu) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sub_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_sub_epi16(__A, __B),
+                                             (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sub_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_sub_epi16(__A, __B),
+                                             (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mullo_epi16 (__m512i __A, __m512i __B) {
+  return (__m512i) ((__v32hu) __A * (__v32hu) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mullo_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_mullo_epi16(__A, __B),
+                                             (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mullo_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_mullo_epi16(__A, __B),
+                                             (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_blend_epi8 (__mmask64 __U, __m512i __A, __m512i __W)
+{
+  return (__m512i) __builtin_ia32_selectb_512 ((__mmask64) __U,
+              (__v64qi) __W,
+              (__v64qi) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_blend_epi16 (__mmask32 __U, __m512i __A, __m512i __W)
+{
+  return (__m512i) __builtin_ia32_selectw_512 ((__mmask32) __U,
+              (__v32hi) __W,
+              (__v32hi) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_abs_epi8 (__m512i __A)
+{
+  return (__m512i)__builtin_elementwise_abs((__v64qs)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_abs_epi8 (__m512i __W, __mmask64 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                             (__v64qi)_mm512_abs_epi8(__A),
+                                             (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_abs_epi8 (__mmask64 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                             (__v64qi)_mm512_abs_epi8(__A),
+                                             (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_abs_epi16 (__m512i __A)
+{
+  return (__m512i)__builtin_elementwise_abs((__v32hi)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_abs_epi16 (__m512i __W, __mmask32 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_abs_epi16(__A),
+                                             (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_abs_epi16 (__mmask32 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_abs_epi16(__A),
+                                             (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_packs_epi32(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_packssdw512((__v16si)__A, (__v16si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_packs_epi32(__mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                       (__v32hi)_mm512_packs_epi32(__A, __B),
+                                       (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_packs_epi32(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                       (__v32hi)_mm512_packs_epi32(__A, __B),
+                                       (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_packs_epi16(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_packsswb512((__v32hi)__A, (__v32hi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_packs_epi16(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                        (__v64qi)_mm512_packs_epi16(__A, __B),
+                                        (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_packs_epi16(__mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                        (__v64qi)_mm512_packs_epi16(__A, __B),
+                                        (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_packus_epi32(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_packusdw512((__v16si) __A, (__v16si) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_packus_epi32(__mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                       (__v32hi)_mm512_packus_epi32(__A, __B),
+                                       (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_packus_epi32(__m512i __W, __mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                       (__v32hi)_mm512_packus_epi32(__A, __B),
+                                       (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_packus_epi16(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_packuswb512((__v32hi) __A, (__v32hi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_packus_epi16(__m512i __W, __mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                        (__v64qi)_mm512_packus_epi16(__A, __B),
+                                        (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_packus_epi16(__mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                        (__v64qi)_mm512_packus_epi16(__A, __B),
+                                        (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_adds_epi8 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_add_sat((__v64qs)__A, (__v64qs)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_adds_epi8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_adds_epi8(__A, __B),
+                                        (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_adds_epi8 (__mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_adds_epi8(__A, __B),
+                                        (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_adds_epi16 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_add_sat((__v32hi)__A, (__v32hi)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_adds_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                        (__v32hi)_mm512_adds_epi16(__A, __B),
+                                        (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_adds_epi16 (__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                        (__v32hi)_mm512_adds_epi16(__A, __B),
+                                        (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_adds_epu8 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_add_sat((__v64qu) __A, (__v64qu) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_adds_epu8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_adds_epu8(__A, __B),
+                                        (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_adds_epu8 (__mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_adds_epu8(__A, __B),
+                                        (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_adds_epu16 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_add_sat((__v32hu) __A, (__v32hu) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_adds_epu16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                        (__v32hi)_mm512_adds_epu16(__A, __B),
+                                        (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_adds_epu16 (__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                        (__v32hi)_mm512_adds_epu16(__A, __B),
+                                        (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_avg_epu8 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_pavgb512((__v64qi)__A, (__v64qi)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_avg_epu8 (__m512i __W, __mmask64 __U, __m512i __A,
+          __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+              (__v64qi)_mm512_avg_epu8(__A, __B),
+              (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_avg_epu8 (__mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+              (__v64qi)_mm512_avg_epu8(__A, __B),
+              (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_avg_epu16 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_pavgw512((__v32hi)__A, (__v32hi)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_avg_epu16 (__m512i __W, __mmask32 __U, __m512i __A,
+           __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+              (__v32hi)_mm512_avg_epu16(__A, __B),
+              (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_avg_epu16 (__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+              (__v32hi)_mm512_avg_epu16(__A, __B),
+              (__v32hi) _mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_max_epi8 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_max((__v64qs) __A, (__v64qs) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_epi8 (__mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                             (__v64qi)_mm512_max_epi8(__A, __B),
+                                             (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_max_epi8 (__m512i __W, __mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                             (__v64qi)_mm512_max_epi8(__A, __B),
+                                             (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_max_epi16 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_max((__v32hi) __A, (__v32hi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_epi16 (__mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                            (__v32hi)_mm512_max_epi16(__A, __B),
+                                            (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_max_epi16 (__m512i __W, __mmask32 __M, __m512i __A,
+           __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                            (__v32hi)_mm512_max_epi16(__A, __B),
+                                            (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_max_epu8 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_max((__v64qu)__A, (__v64qu)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_epu8 (__mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                             (__v64qi)_mm512_max_epu8(__A, __B),
+                                             (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_max_epu8 (__m512i __W, __mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                             (__v64qi)_mm512_max_epu8(__A, __B),
+                                             (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_max_epu16 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_max((__v32hu)__A, (__v32hu)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_epu16 (__mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                            (__v32hi)_mm512_max_epu16(__A, __B),
+                                            (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_max_epu16 (__m512i __W, __mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                            (__v32hi)_mm512_max_epu16(__A, __B),
+                                            (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_min_epi8 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_min((__v64qs) __A, (__v64qs) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_epi8 (__mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                             (__v64qi)_mm512_min_epi8(__A, __B),
+                                             (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_min_epi8 (__m512i __W, __mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                             (__v64qi)_mm512_min_epi8(__A, __B),
+                                             (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_min_epi16 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_min((__v32hi) __A, (__v32hi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_epi16 (__mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                            (__v32hi)_mm512_min_epi16(__A, __B),
+                                            (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_min_epi16 (__m512i __W, __mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                            (__v32hi)_mm512_min_epi16(__A, __B),
+                                            (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_min_epu8 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_min((__v64qu)__A, (__v64qu)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_epu8 (__mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                             (__v64qi)_mm512_min_epu8(__A, __B),
+                                             (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_min_epu8 (__m512i __W, __mmask64 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                             (__v64qi)_mm512_min_epu8(__A, __B),
+                                             (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_min_epu16 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_min((__v32hu)__A, (__v32hu)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_epu16 (__mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                            (__v32hi)_mm512_min_epu16(__A, __B),
+                                            (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_min_epu16 (__m512i __W, __mmask32 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                            (__v32hi)_mm512_min_epu16(__A, __B),
+                                            (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_shuffle_epi8(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_pshufb512((__v64qi)__A,(__v64qi)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_shuffle_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                         (__v64qi)_mm512_shuffle_epi8(__A, __B),
+                                         (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_shuffle_epi8(__mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                         (__v64qi)_mm512_shuffle_epi8(__A, __B),
+                                         (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_subs_epi8 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_sub_sat((__v64qs)__A, (__v64qs)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_subs_epi8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_subs_epi8(__A, __B),
+                                        (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_subs_epi8 (__mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_subs_epi8(__A, __B),
+                                        (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_subs_epi16 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_sub_sat((__v32hi)__A, (__v32hi)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_subs_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                        (__v32hi)_mm512_subs_epi16(__A, __B),
+                                        (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_subs_epi16 (__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                        (__v32hi)_mm512_subs_epi16(__A, __B),
+                                        (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_subs_epu8 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_sub_sat((__v64qu) __A, (__v64qu) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_subs_epu8 (__m512i __W, __mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_subs_epu8(__A, __B),
+                                        (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_subs_epu8 (__mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_subs_epu8(__A, __B),
+                                        (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_subs_epu16 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_sub_sat((__v32hu) __A, (__v32hu) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_subs_epu16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                        (__v32hi)_mm512_subs_epu16(__A, __B),
+                                        (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_subs_epu16 (__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                        (__v32hi)_mm512_subs_epu16(__A, __B),
+                                        (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_permutex2var_epi16(__m512i __A, __m512i __I, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_vpermi2varhi512((__v32hi)__A, (__v32hi)__I,
+                                                 (__v32hi)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_permutex2var_epi16(__m512i __A, __mmask32 __U, __m512i __I,
+                               __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512(__U,
+                              (__v32hi)_mm512_permutex2var_epi16(__A, __I, __B),
+                              (__v32hi)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask2_permutex2var_epi16(__m512i __A, __m512i __I, __mmask32 __U,
+                                __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512(__U,
+                              (__v32hi)_mm512_permutex2var_epi16(__A, __I, __B),
+                              (__v32hi)__I);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutex2var_epi16(__mmask32 __U, __m512i __A, __m512i __I,
+                                __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512(__U,
+                              (__v32hi)_mm512_permutex2var_epi16(__A, __I, __B),
+                              (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mulhrs_epi16(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_pmulhrsw512((__v32hi)__A, (__v32hi)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mulhrs_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                         (__v32hi)_mm512_mulhrs_epi16(__A, __B),
+                                         (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mulhrs_epi16(__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                         (__v32hi)_mm512_mulhrs_epi16(__A, __B),
+                                         (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mulhi_epi16(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_pmulhw512((__v32hi) __A, (__v32hi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mulhi_epi16(__m512i __W, __mmask32 __U, __m512i __A,
+       __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                          (__v32hi)_mm512_mulhi_epi16(__A, __B),
+                                          (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mulhi_epi16(__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                          (__v32hi)_mm512_mulhi_epi16(__A, __B),
+                                          (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mulhi_epu16(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_pmulhuw512((__v32hi) __A, (__v32hi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mulhi_epu16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                          (__v32hi)_mm512_mulhi_epu16(__A, __B),
+                                          (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mulhi_epu16 (__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                          (__v32hi)_mm512_mulhi_epu16(__A, __B),
+                                          (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maddubs_epi16(__m512i __X, __m512i __Y) {
+  return (__m512i)__builtin_ia32_pmaddubsw512((__v64qi)__X, (__v64qi)__Y);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_maddubs_epi16(__m512i __W, __mmask32 __U, __m512i __X,
+                          __m512i __Y) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32) __U,
+                                        (__v32hi)_mm512_maddubs_epi16(__X, __Y),
+                                        (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_maddubs_epi16(__mmask32 __U, __m512i __X, __m512i __Y) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32) __U,
+                                        (__v32hi)_mm512_maddubs_epi16(__X, __Y),
+                                        (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_madd_epi16(__m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_pmaddwd512((__v32hi)__A, (__v32hi)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_madd_epi16(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                           (__v16si)_mm512_madd_epi16(__A, __B),
+                                           (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_madd_epi16(__mmask16 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                           (__v16si)_mm512_madd_epi16(__A, __B),
+                                           (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtsepi16_epi8 (__m512i __A) {
+  return (__m256i) __builtin_ia32_pmovswb512_mask ((__v32hi) __A,
+               (__v32qi)_mm256_setzero_si256(),
+               (__mmask32) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi16_epi8 (__m256i __O, __mmask32 __M, __m512i __A) {
+  return (__m256i) __builtin_ia32_pmovswb512_mask ((__v32hi) __A,
+               (__v32qi)__O,
+               __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtsepi16_epi8 (__mmask32 __M, __m512i __A) {
+  return (__m256i) __builtin_ia32_pmovswb512_mask ((__v32hi) __A,
+               (__v32qi) _mm256_setzero_si256(),
+               __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtusepi16_epi8 (__m512i __A) {
+  return (__m256i) __builtin_ia32_pmovuswb512_mask ((__v32hi) __A,
+                (__v32qi) _mm256_setzero_si256(),
+                (__mmask32) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi16_epi8 (__m256i __O, __mmask32 __M, __m512i __A) {
+  return (__m256i) __builtin_ia32_pmovuswb512_mask ((__v32hi) __A,
+                (__v32qi) __O,
+                __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtusepi16_epi8 (__mmask32 __M, __m512i __A) {
+  return (__m256i) __builtin_ia32_pmovuswb512_mask ((__v32hi) __A,
+                (__v32qi) _mm256_setzero_si256(),
+                __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi16_epi8 (__m512i __A) {
+  return (__m256i) __builtin_ia32_pmovwb512_mask ((__v32hi) __A,
+              (__v32qi) _mm256_undefined_si256(),
+              (__mmask32) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi16_epi8 (__m256i __O, __mmask32 __M, __m512i __A) {
+  return (__m256i) __builtin_ia32_pmovwb512_mask ((__v32hi) __A,
+              (__v32qi) __O,
+              __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi16_epi8 (__mmask32 __M, __m512i __A) {
+  return (__m256i) __builtin_ia32_pmovwb512_mask ((__v32hi) __A,
+              (__v32qi) _mm256_setzero_si256(),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi16_storeu_epi8 (void * __P, __mmask32 __M, __m512i __A)
+{
+  __builtin_ia32_pmovwb512mem_mask ((__v32qi *) __P, (__v32hi) __A, __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi16_storeu_epi8 (void * __P, __mmask32 __M, __m512i __A)
+{
+  __builtin_ia32_pmovswb512mem_mask ((__v32qi *) __P, (__v32hi) __A, __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi16_storeu_epi8 (void * __P, __mmask32 __M, __m512i __A)
+{
+  __builtin_ia32_pmovuswb512mem_mask ((__v32qi *) __P, (__v32hi) __A, __M);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_unpackhi_epi8(__m512i __A, __m512i __B) {
+  return (__m512i)__builtin_shufflevector((__v64qi)__A, (__v64qi)__B,
+                                          8,  64+8,   9, 64+9,
+                                          10, 64+10, 11, 64+11,
+                                          12, 64+12, 13, 64+13,
+                                          14, 64+14, 15, 64+15,
+                                          24, 64+24, 25, 64+25,
+                                          26, 64+26, 27, 64+27,
+                                          28, 64+28, 29, 64+29,
+                                          30, 64+30, 31, 64+31,
+                                          40, 64+40, 41, 64+41,
+                                          42, 64+42, 43, 64+43,
+                                          44, 64+44, 45, 64+45,
+                                          46, 64+46, 47, 64+47,
+                                          56, 64+56, 57, 64+57,
+                                          58, 64+58, 59, 64+59,
+                                          60, 64+60, 61, 64+61,
+                                          62, 64+62, 63, 64+63);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_unpackhi_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_unpackhi_epi8(__A, __B),
+                                        (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpackhi_epi8(__mmask64 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_unpackhi_epi8(__A, __B),
+                                        (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_unpackhi_epi16(__m512i __A, __m512i __B) {
+  return (__m512i)__builtin_shufflevector((__v32hi)__A, (__v32hi)__B,
+                                          4,  32+4,   5, 32+5,
+                                          6,  32+6,   7, 32+7,
+                                          12, 32+12, 13, 32+13,
+                                          14, 32+14, 15, 32+15,
+                                          20, 32+20, 21, 32+21,
+                                          22, 32+22, 23, 32+23,
+                                          28, 32+28, 29, 32+29,
+                                          30, 32+30, 31, 32+31);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_unpackhi_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                       (__v32hi)_mm512_unpackhi_epi16(__A, __B),
+                                       (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpackhi_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                       (__v32hi)_mm512_unpackhi_epi16(__A, __B),
+                                       (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_unpacklo_epi8(__m512i __A, __m512i __B) {
+  return (__m512i)__builtin_shufflevector((__v64qi)__A, (__v64qi)__B,
+                                          0,  64+0,   1, 64+1,
+                                          2,  64+2,   3, 64+3,
+                                          4,  64+4,   5, 64+5,
+                                          6,  64+6,   7, 64+7,
+                                          16, 64+16, 17, 64+17,
+                                          18, 64+18, 19, 64+19,
+                                          20, 64+20, 21, 64+21,
+                                          22, 64+22, 23, 64+23,
+                                          32, 64+32, 33, 64+33,
+                                          34, 64+34, 35, 64+35,
+                                          36, 64+36, 37, 64+37,
+                                          38, 64+38, 39, 64+39,
+                                          48, 64+48, 49, 64+49,
+                                          50, 64+50, 51, 64+51,
+                                          52, 64+52, 53, 64+53,
+                                          54, 64+54, 55, 64+55);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_unpacklo_epi8(__m512i __W, __mmask64 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_unpacklo_epi8(__A, __B),
+                                        (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpacklo_epi8(__mmask64 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__U,
+                                        (__v64qi)_mm512_unpacklo_epi8(__A, __B),
+                                        (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_unpacklo_epi16(__m512i __A, __m512i __B) {
+  return (__m512i)__builtin_shufflevector((__v32hi)__A, (__v32hi)__B,
+                                          0,  32+0,   1, 32+1,
+                                          2,  32+2,   3, 32+3,
+                                          8,  32+8,   9, 32+9,
+                                          10, 32+10, 11, 32+11,
+                                          16, 32+16, 17, 32+17,
+                                          18, 32+18, 19, 32+19,
+                                          24, 32+24, 25, 32+25,
+                                          26, 32+26, 27, 32+27);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_unpacklo_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                       (__v32hi)_mm512_unpacklo_epi16(__A, __B),
+                                       (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpacklo_epi16(__mmask32 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                       (__v32hi)_mm512_unpacklo_epi16(__A, __B),
+                                       (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi8_epi16(__m256i __A)
+{
+  /* This function always performs a signed extension, but __v32qi is a char
+     which may be signed or unsigned, so use __v32qs. */
+  return (__m512i)__builtin_convertvector((__v32qs)__A, __v32hi);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi8_epi16(__m512i __W, __mmask32 __U, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_cvtepi8_epi16(__A),
+                                             (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi8_epi16(__mmask32 __U, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_cvtepi8_epi16(__A),
+                                             (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepu8_epi16(__m256i __A)
+{
+  return (__m512i)__builtin_convertvector((__v32qu)__A, __v32hi);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu8_epi16(__m512i __W, __mmask32 __U, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_cvtepu8_epi16(__A),
+                                             (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu8_epi16(__mmask32 __U, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                             (__v32hi)_mm512_cvtepu8_epi16(__A),
+                                             (__v32hi)_mm512_setzero_si512());
+}
+
+
+#define _mm512_shufflehi_epi16(A, imm) \
+  ((__m512i)__builtin_ia32_pshufhw512((__v32hi)(__m512i)(A), (int)(imm)))
+
+#define _mm512_mask_shufflehi_epi16(W, U, A, imm) \
+  ((__m512i)__builtin_ia32_selectw_512((__mmask32)(U), \
+                                       (__v32hi)_mm512_shufflehi_epi16((A), \
+                                                                       (imm)), \
+                                       (__v32hi)(__m512i)(W)))
+
+#define _mm512_maskz_shufflehi_epi16(U, A, imm) \
+  ((__m512i)__builtin_ia32_selectw_512((__mmask32)(U), \
+                                       (__v32hi)_mm512_shufflehi_epi16((A), \
+                                                                       (imm)), \
+                                       (__v32hi)_mm512_setzero_si512()))
+
+#define _mm512_shufflelo_epi16(A, imm) \
+  ((__m512i)__builtin_ia32_pshuflw512((__v32hi)(__m512i)(A), (int)(imm)))
+
+
+#define _mm512_mask_shufflelo_epi16(W, U, A, imm) \
+  ((__m512i)__builtin_ia32_selectw_512((__mmask32)(U), \
+                                       (__v32hi)_mm512_shufflelo_epi16((A), \
+                                                                       (imm)), \
+                                       (__v32hi)(__m512i)(W)))
+
+
+#define _mm512_maskz_shufflelo_epi16(U, A, imm) \
+  ((__m512i)__builtin_ia32_selectw_512((__mmask32)(U), \
+                                       (__v32hi)_mm512_shufflelo_epi16((A), \
+                                                                       (imm)), \
+                                       (__v32hi)_mm512_setzero_si512()))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sllv_epi16(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_psllv32hi((__v32hi) __A, (__v32hi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sllv_epi16 (__m512i __W, __mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                           (__v32hi)_mm512_sllv_epi16(__A, __B),
+                                           (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sllv_epi16(__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                           (__v32hi)_mm512_sllv_epi16(__A, __B),
+                                           (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sll_epi16(__m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_psllw512((__v32hi) __A, (__v8hi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sll_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                          (__v32hi)_mm512_sll_epi16(__A, __B),
+                                          (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sll_epi16(__mmask32 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                          (__v32hi)_mm512_sll_epi16(__A, __B),
+                                          (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_slli_epi16(__m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_psllwi512((__v32hi)__A, (int)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_slli_epi16(__m512i __W, __mmask32 __U, __m512i __A,
+                       unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                         (__v32hi)_mm512_slli_epi16(__A, __B),
+                                         (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_slli_epi16(__mmask32 __U, __m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                         (__v32hi)_mm512_slli_epi16(__A, __B),
+                                         (__v32hi)_mm512_setzero_si512());
+}
+
+#define _mm512_bslli_epi128(a, imm) \
+  ((__m512i)__builtin_ia32_pslldqi512_byteshift((__v8di)(__m512i)(a), (int)(imm)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srlv_epi16(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_psrlv32hi((__v32hi)__A, (__v32hi)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srlv_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                           (__v32hi)_mm512_srlv_epi16(__A, __B),
+                                           (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srlv_epi16(__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                           (__v32hi)_mm512_srlv_epi16(__A, __B),
+                                           (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srav_epi16(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_psrav32hi((__v32hi)__A, (__v32hi)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srav_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                           (__v32hi)_mm512_srav_epi16(__A, __B),
+                                           (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srav_epi16(__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                           (__v32hi)_mm512_srav_epi16(__A, __B),
+                                           (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sra_epi16(__m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_psraw512((__v32hi) __A, (__v8hi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sra_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                          (__v32hi)_mm512_sra_epi16(__A, __B),
+                                          (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sra_epi16(__mmask32 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                          (__v32hi)_mm512_sra_epi16(__A, __B),
+                                          (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srai_epi16(__m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_psrawi512((__v32hi)__A, (int)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srai_epi16(__m512i __W, __mmask32 __U, __m512i __A,
+                       unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                         (__v32hi)_mm512_srai_epi16(__A, __B),
+                                         (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srai_epi16(__mmask32 __U, __m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                         (__v32hi)_mm512_srai_epi16(__A, __B),
+                                         (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srl_epi16(__m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_psrlw512((__v32hi) __A, (__v8hi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srl_epi16(__m512i __W, __mmask32 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                          (__v32hi)_mm512_srl_epi16(__A, __B),
+                                          (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srl_epi16(__mmask32 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                          (__v32hi)_mm512_srl_epi16(__A, __B),
+                                          (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srli_epi16(__m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_psrlwi512((__v32hi)__A, (int)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srli_epi16(__m512i __W, __mmask32 __U, __m512i __A,
+                       unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                         (__v32hi)_mm512_srli_epi16(__A, __B),
+                                         (__v32hi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srli_epi16(__mmask32 __U, __m512i __A, int __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__U,
+                                         (__v32hi)_mm512_srli_epi16(__A, (unsigned int)__B),
+                                         (__v32hi)_mm512_setzero_si512());
+}
+
+#define _mm512_bsrli_epi128(a, imm) \
+  ((__m512i)__builtin_ia32_psrldqi512_byteshift((__v8di)(__m512i)(a), (int)(imm)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mov_epi16 (__m512i __W, __mmask32 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_selectw_512 ((__mmask32) __U,
+                (__v32hi) __A,
+                (__v32hi) __W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mov_epi16 (__mmask32 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_selectw_512 ((__mmask32) __U,
+                (__v32hi) __A,
+                (__v32hi) _mm512_setzero_si512 ());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mov_epi8 (__m512i __W, __mmask64 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_selectb_512 ((__mmask64) __U,
+                (__v64qi) __A,
+                (__v64qi) __W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mov_epi8 (__mmask64 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_selectb_512 ((__mmask64) __U,
+                (__v64qi) __A,
+                (__v64qi) _mm512_setzero_si512 ());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_set1_epi8 (__m512i __O, __mmask64 __M, char __A)
+{
+  return (__m512i) __builtin_ia32_selectb_512(__M,
+                                              (__v64qi)_mm512_set1_epi8(__A),
+                                              (__v64qi) __O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_set1_epi8 (__mmask64 __M, char __A)
+{
+  return (__m512i) __builtin_ia32_selectb_512(__M,
+                                              (__v64qi) _mm512_set1_epi8(__A),
+                                              (__v64qi) _mm512_setzero_si512());
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS _mm512_kunpackd(__mmask64 __A,
+                                                               __mmask64 __B) {
+  return (__mmask64) __builtin_ia32_kunpckdi ((__mmask64) __A,
+                (__mmask64) __B);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS
+_mm512_kunpackw (__mmask32 __A, __mmask32 __B)
+{
+  return (__mmask32) __builtin_ia32_kunpcksi ((__mmask32) __A,
+                (__mmask32) __B);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_loadu_epi16 (void const *__P)
+{
+  struct __loadu_epi16 {
+    __m512i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi16*)__P)->__v;
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_loadu_epi16 (__m512i __W, __mmask32 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_loaddquhi512_mask ((const __v32hi *) __P,
+                 (__v32hi) __W,
+                 (__mmask32) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_loadu_epi16 (__mmask32 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_loaddquhi512_mask ((const __v32hi *) __P,
+                 (__v32hi)
+                 _mm512_setzero_si512 (),
+                 (__mmask32) __U);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_loadu_epi8 (void const *__P)
+{
+  struct __loadu_epi8 {
+    __m512i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi8*)__P)->__v;
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_loadu_epi8 (__m512i __W, __mmask64 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_loaddquqi512_mask ((const __v64qi *) __P,
+                 (__v64qi) __W,
+                 (__mmask64) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_loadu_epi8 (__mmask64 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_loaddquqi512_mask ((const __v64qi *) __P,
+                 (__v64qi)
+                 _mm512_setzero_si512 (),
+                 (__mmask64) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_storeu_epi16 (void *__P, __m512i __A)
+{
+  struct __storeu_epi16 {
+    __m512i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi16*)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_storeu_epi16 (void *__P, __mmask32 __U, __m512i __A)
+{
+  __builtin_ia32_storedquhi512_mask ((__v32hi *) __P,
+             (__v32hi) __A,
+             (__mmask32) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_storeu_epi8 (void *__P, __m512i __A)
+{
+  struct __storeu_epi8 {
+    __m512i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi8*)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_storeu_epi8 (void *__P, __mmask64 __U, __m512i __A)
+{
+  __builtin_ia32_storedquqi512_mask ((__v64qi *) __P,
+             (__v64qi) __A,
+             (__mmask64) __U);
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS512
+_mm512_test_epi8_mask (__m512i __A, __m512i __B)
+{
+  return _mm512_cmpneq_epi8_mask (_mm512_and_epi32 (__A, __B),
+                                  _mm512_setzero_si512());
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS512
+_mm512_mask_test_epi8_mask (__mmask64 __U, __m512i __A, __m512i __B)
+{
+  return _mm512_mask_cmpneq_epi8_mask (__U, _mm512_and_epi32 (__A, __B),
+                                       _mm512_setzero_si512());
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS512
+_mm512_test_epi16_mask (__m512i __A, __m512i __B)
+{
+  return _mm512_cmpneq_epi16_mask (_mm512_and_epi32 (__A, __B),
+                                   _mm512_setzero_si512());
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS512
+_mm512_mask_test_epi16_mask (__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return _mm512_mask_cmpneq_epi16_mask (__U, _mm512_and_epi32 (__A, __B),
+                                        _mm512_setzero_si512());
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS512
+_mm512_testn_epi8_mask (__m512i __A, __m512i __B)
+{
+  return _mm512_cmpeq_epi8_mask (_mm512_and_epi32 (__A, __B), _mm512_setzero_si512());
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS512
+_mm512_mask_testn_epi8_mask (__mmask64 __U, __m512i __A, __m512i __B)
+{
+  return _mm512_mask_cmpeq_epi8_mask (__U, _mm512_and_epi32 (__A, __B),
+                                      _mm512_setzero_si512());
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS512
+_mm512_testn_epi16_mask (__m512i __A, __m512i __B)
+{
+  return _mm512_cmpeq_epi16_mask (_mm512_and_epi32 (__A, __B),
+                                  _mm512_setzero_si512());
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS512
+_mm512_mask_testn_epi16_mask (__mmask32 __U, __m512i __A, __m512i __B)
+{
+  return _mm512_mask_cmpeq_epi16_mask (__U, _mm512_and_epi32 (__A, __B),
+                                       _mm512_setzero_si512());
+}
+
+static __inline__ __mmask64 __DEFAULT_FN_ATTRS512
+_mm512_movepi8_mask (__m512i __A)
+{
+  return (__mmask64) __builtin_ia32_cvtb2mask512 ((__v64qi) __A);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS512
+_mm512_movepi16_mask (__m512i __A)
+{
+  return (__mmask32) __builtin_ia32_cvtw2mask512 ((__v32hi) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_movm_epi8 (__mmask64 __A)
+{
+  return (__m512i) __builtin_ia32_cvtmask2b512 (__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_movm_epi16 (__mmask32 __A)
+{
+  return (__m512i) __builtin_ia32_cvtmask2w512 (__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_broadcastb_epi8 (__m128i __A)
+{
+  return (__m512i)__builtin_shufflevector((__v16qi) __A, (__v16qi) __A,
+                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcastb_epi8 (__m512i __O, __mmask64 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectb_512(__M,
+                                             (__v64qi) _mm512_broadcastb_epi8(__A),
+                                             (__v64qi) __O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcastb_epi8 (__mmask64 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectb_512(__M,
+                                             (__v64qi) _mm512_broadcastb_epi8(__A),
+                                             (__v64qi) _mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_set1_epi16 (__m512i __O, __mmask32 __M, short __A)
+{
+  return (__m512i) __builtin_ia32_selectw_512(__M,
+                                              (__v32hi) _mm512_set1_epi16(__A),
+                                              (__v32hi) __O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_set1_epi16 (__mmask32 __M, short __A)
+{
+  return (__m512i) __builtin_ia32_selectw_512(__M,
+                                              (__v32hi) _mm512_set1_epi16(__A),
+                                              (__v32hi) _mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_broadcastw_epi16 (__m128i __A)
+{
+  return (__m512i)__builtin_shufflevector((__v8hi) __A, (__v8hi) __A,
+                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcastw_epi16 (__m512i __O, __mmask32 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectw_512(__M,
+                                             (__v32hi) _mm512_broadcastw_epi16(__A),
+                                             (__v32hi) __O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcastw_epi16 (__mmask32 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectw_512(__M,
+                                             (__v32hi) _mm512_broadcastw_epi16(__A),
+                                             (__v32hi) _mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_permutexvar_epi16 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_permvarhi512((__v32hi)__B, (__v32hi)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutexvar_epi16 (__mmask32 __M, __m512i __A,
+        __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                    (__v32hi)_mm512_permutexvar_epi16(__A, __B),
+                                    (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_permutexvar_epi16 (__m512i __W, __mmask32 __M, __m512i __A,
+             __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectw_512((__mmask32)__M,
+                                    (__v32hi)_mm512_permutexvar_epi16(__A, __B),
+                                    (__v32hi)__W);
+}
+
+#define _mm512_alignr_epi8(A, B, N) \
+  ((__m512i)__builtin_ia32_palignr512((__v64qi)(__m512i)(A), \
+                                      (__v64qi)(__m512i)(B), (int)(N)))
+
+#define _mm512_mask_alignr_epi8(W, U, A, B, N) \
+  ((__m512i)__builtin_ia32_selectb_512((__mmask64)(U), \
+                              (__v64qi)_mm512_alignr_epi8((A), (B), (int)(N)), \
+                              (__v64qi)(__m512i)(W)))
+
+#define _mm512_maskz_alignr_epi8(U, A, B, N) \
+  ((__m512i)__builtin_ia32_selectb_512((__mmask64)(U), \
+                              (__v64qi)_mm512_alignr_epi8((A), (B), (int)(N)), \
+                              (__v64qi)(__m512i)_mm512_setzero_si512()))
+
+#define _mm512_dbsad_epu8(A, B, imm) \
+  ((__m512i)__builtin_ia32_dbpsadbw512((__v64qi)(__m512i)(A), \
+                                       (__v64qi)(__m512i)(B), (int)(imm)))
+
+#define _mm512_mask_dbsad_epu8(W, U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectw_512((__mmask32)(U), \
+                                  (__v32hi)_mm512_dbsad_epu8((A), (B), (imm)), \
+                                  (__v32hi)(__m512i)(W)))
+
+#define _mm512_maskz_dbsad_epu8(U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectw_512((__mmask32)(U), \
+                                  (__v32hi)_mm512_dbsad_epu8((A), (B), (imm)), \
+                                  (__v32hi)_mm512_setzero_si512()))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sad_epu8 (__m512i __A, __m512i __B)
+{
+ return (__m512i) __builtin_ia32_psadbw512 ((__v64qi) __A,
+               (__v64qi) __B);
+}
+
+#undef __DEFAULT_FN_ATTRS512
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/avx512cdintrin.h b/third_party/intel/clang/avx512cdintrin.h
new file mode 100644
index 000000000..33b552f6f
--- /dev/null
+++ b/third_party/intel/clang/avx512cdintrin.h
@@ -0,0 +1,125 @@
+/*===------------- avx512cdintrin.h - AVX512CD intrinsics ------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512cdintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512CDINTRIN_H
+#define __AVX512CDINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512cd,evex512"), __min_vector_width__(512)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_conflict_epi64 (__m512i __A)
+{
+  return (__m512i) __builtin_ia32_vpconflictdi_512 ((__v8di) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_conflict_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_conflict_epi64(__A),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_conflict_epi64 (__mmask8 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_conflict_epi64(__A),
+                                             (__v8di)_mm512_setzero_si512 ());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_conflict_epi32 (__m512i __A)
+{
+  return (__m512i) __builtin_ia32_vpconflictsi_512 ((__v16si) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_conflict_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                            (__v16si)_mm512_conflict_epi32(__A),
+                                            (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_conflict_epi32 (__mmask16 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                            (__v16si)_mm512_conflict_epi32(__A),
+                                            (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_lzcnt_epi32 (__m512i __A)
+{
+  return (__m512i) __builtin_ia32_vplzcntd_512 ((__v16si) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_lzcnt_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                             (__v16si)_mm512_lzcnt_epi32(__A),
+                                             (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_lzcnt_epi32 (__mmask16 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                             (__v16si)_mm512_lzcnt_epi32(__A),
+                                             (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_lzcnt_epi64 (__m512i __A)
+{
+  return (__m512i) __builtin_ia32_vplzcntq_512 ((__v8di) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_lzcnt_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_lzcnt_epi64(__A),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_lzcnt_epi64 (__mmask8 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_lzcnt_epi64(__A),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_broadcastmb_epi64 (__mmask8 __A)
+{
+  return (__m512i) _mm512_set1_epi64((long long) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_broadcastmw_epi32 (__mmask16 __A)
+{
+  return (__m512i) _mm512_set1_epi32((int) __A);
+
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/avx512dqintrin.h b/third_party/intel/clang/avx512dqintrin.h
new file mode 100644
index 000000000..88b48e3a3
--- /dev/null
+++ b/third_party/intel/clang/avx512dqintrin.h
@@ -0,0 +1,1379 @@
+/*===---- avx512dqintrin.h - AVX512DQ intrinsics ---------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512dqintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512DQINTRIN_H
+#define __AVX512DQINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS512 __attribute__((__always_inline__, __nodebug__, __target__("avx512dq,evex512"), __min_vector_width__(512)))
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512dq,no-evex512")))
+
+static __inline __mmask8 __DEFAULT_FN_ATTRS
+_knot_mask8(__mmask8 __M)
+{
+  return __builtin_ia32_knotqi(__M);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_kand_mask8(__mmask8 __A, __mmask8 __B)
+{
+  return (__mmask8)__builtin_ia32_kandqi((__mmask8)__A, (__mmask8)__B);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_kandn_mask8(__mmask8 __A, __mmask8 __B)
+{
+  return (__mmask8)__builtin_ia32_kandnqi((__mmask8)__A, (__mmask8)__B);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_kor_mask8(__mmask8 __A, __mmask8 __B)
+{
+  return (__mmask8)__builtin_ia32_korqi((__mmask8)__A, (__mmask8)__B);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_kxnor_mask8(__mmask8 __A, __mmask8 __B)
+{
+  return (__mmask8)__builtin_ia32_kxnorqi((__mmask8)__A, (__mmask8)__B);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_kxor_mask8(__mmask8 __A, __mmask8 __B)
+{
+  return (__mmask8)__builtin_ia32_kxorqi((__mmask8)__A, (__mmask8)__B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortestc_mask8_u8(__mmask8 __A, __mmask8 __B)
+{
+  return (unsigned char)__builtin_ia32_kortestcqi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortestz_mask8_u8(__mmask8 __A, __mmask8 __B)
+{
+  return (unsigned char)__builtin_ia32_kortestzqi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortest_mask8_u8(__mmask8 __A, __mmask8 __B, unsigned char *__C) {
+  *__C = (unsigned char)__builtin_ia32_kortestcqi(__A, __B);
+  return (unsigned char)__builtin_ia32_kortestzqi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktestc_mask8_u8(__mmask8 __A, __mmask8 __B)
+{
+  return (unsigned char)__builtin_ia32_ktestcqi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktestz_mask8_u8(__mmask8 __A, __mmask8 __B)
+{
+  return (unsigned char)__builtin_ia32_ktestzqi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktest_mask8_u8(__mmask8 __A, __mmask8 __B, unsigned char *__C) {
+  *__C = (unsigned char)__builtin_ia32_ktestcqi(__A, __B);
+  return (unsigned char)__builtin_ia32_ktestzqi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktestc_mask16_u8(__mmask16 __A, __mmask16 __B)
+{
+  return (unsigned char)__builtin_ia32_ktestchi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktestz_mask16_u8(__mmask16 __A, __mmask16 __B)
+{
+  return (unsigned char)__builtin_ia32_ktestzhi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_ktest_mask16_u8(__mmask16 __A, __mmask16 __B, unsigned char *__C) {
+  *__C = (unsigned char)__builtin_ia32_ktestchi(__A, __B);
+  return (unsigned char)__builtin_ia32_ktestzhi(__A, __B);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_kadd_mask8(__mmask8 __A, __mmask8 __B)
+{
+  return (__mmask8)__builtin_ia32_kaddqi((__mmask8)__A, (__mmask8)__B);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_kadd_mask16(__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16)__builtin_ia32_kaddhi((__mmask16)__A, (__mmask16)__B);
+}
+
+#define _kshiftli_mask8(A, I) \
+  ((__mmask8)__builtin_ia32_kshiftliqi((__mmask8)(A), (unsigned int)(I)))
+
+#define _kshiftri_mask8(A, I) \
+  ((__mmask8)__builtin_ia32_kshiftriqi((__mmask8)(A), (unsigned int)(I)))
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_cvtmask8_u32(__mmask8 __A) {
+  return (unsigned int)__builtin_ia32_kmovb((__mmask8)__A);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_cvtu32_mask8(unsigned int __A) {
+  return (__mmask8)__builtin_ia32_kmovb((__mmask8)__A);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS
+_load_mask8(__mmask8 *__A) {
+  return (__mmask8)__builtin_ia32_kmovb(*(__mmask8 *)__A);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_store_mask8(__mmask8 *__A, __mmask8 __B) {
+  *(__mmask8 *)__A = __builtin_ia32_kmovb((__mmask8)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mullo_epi64 (__m512i __A, __m512i __B) {
+  return (__m512i) ((__v8du) __A * (__v8du) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mullo_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_mullo_epi64(__A, __B),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mullo_epi64(__mmask8 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_mullo_epi64(__A, __B),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_xor_pd(__m512d __A, __m512d __B) {
+  return (__m512d)((__v8du)__A ^ (__v8du)__B);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_xor_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_xor_pd(__A, __B),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_xor_pd(__mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_xor_pd(__A, __B),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_xor_ps (__m512 __A, __m512 __B) {
+  return (__m512)((__v16su)__A ^ (__v16su)__B);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_xor_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_xor_ps(__A, __B),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_xor_ps(__mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_xor_ps(__A, __B),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_or_pd(__m512d __A, __m512d __B) {
+  return (__m512d)((__v8du)__A | (__v8du)__B);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_or_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_or_pd(__A, __B),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_or_pd(__mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_or_pd(__A, __B),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_or_ps(__m512 __A, __m512 __B) {
+  return (__m512)((__v16su)__A | (__v16su)__B);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_or_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_or_ps(__A, __B),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_or_ps(__mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_or_ps(__A, __B),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_and_pd(__m512d __A, __m512d __B) {
+  return (__m512d)((__v8du)__A & (__v8du)__B);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_and_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_and_pd(__A, __B),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_and_pd(__mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_and_pd(__A, __B),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_and_ps(__m512 __A, __m512 __B) {
+  return (__m512)((__v16su)__A & (__v16su)__B);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_and_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_and_ps(__A, __B),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_and_ps(__mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_and_ps(__A, __B),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_andnot_pd(__m512d __A, __m512d __B) {
+  return (__m512d)(~(__v8du)__A & (__v8du)__B);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_andnot_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_andnot_pd(__A, __B),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_andnot_pd(__mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_andnot_pd(__A, __B),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_andnot_ps(__m512 __A, __m512 __B) {
+  return (__m512)(~(__v16su)__A & (__v16su)__B);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_andnot_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_andnot_ps(__A, __B),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_andnot_ps(__mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_andnot_ps(__A, __B),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtpd_epi64 (__m512d __A) {
+  return (__m512i) __builtin_ia32_cvtpd2qq512_mask ((__v8df) __A,
+                (__v8di) _mm512_setzero_si512(),
+                (__mmask8) -1,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtpd_epi64 (__m512i __W, __mmask8 __U, __m512d __A) {
+  return (__m512i) __builtin_ia32_cvtpd2qq512_mask ((__v8df) __A,
+                (__v8di) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtpd_epi64 (__mmask8 __U, __m512d __A) {
+  return (__m512i) __builtin_ia32_cvtpd2qq512_mask ((__v8df) __A,
+                (__v8di) _mm512_setzero_si512(),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundpd_epi64(A, R) \
+  ((__m512i)__builtin_ia32_cvtpd2qq512_mask((__v8df)(__m512d)(A), \
+                                            (__v8di)_mm512_setzero_si512(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundpd_epi64(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvtpd2qq512_mask((__v8df)(__m512d)(A), \
+                                            (__v8di)(__m512i)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundpd_epi64(U, A, R) \
+  ((__m512i)__builtin_ia32_cvtpd2qq512_mask((__v8df)(__m512d)(A), \
+                                            (__v8di)_mm512_setzero_si512(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtpd_epu64 (__m512d __A) {
+  return (__m512i) __builtin_ia32_cvtpd2uqq512_mask ((__v8df) __A,
+                 (__v8di) _mm512_setzero_si512(),
+                 (__mmask8) -1,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtpd_epu64 (__m512i __W, __mmask8 __U, __m512d __A) {
+  return (__m512i) __builtin_ia32_cvtpd2uqq512_mask ((__v8df) __A,
+                 (__v8di) __W,
+                 (__mmask8) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtpd_epu64 (__mmask8 __U, __m512d __A) {
+  return (__m512i) __builtin_ia32_cvtpd2uqq512_mask ((__v8df) __A,
+                 (__v8di) _mm512_setzero_si512(),
+                 (__mmask8) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundpd_epu64(A, R) \
+  ((__m512i)__builtin_ia32_cvtpd2uqq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8di)_mm512_setzero_si512(), \
+                                             (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundpd_epu64(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvtpd2uqq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8di)(__m512i)(W), \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundpd_epu64(U, A, R) \
+  ((__m512i)__builtin_ia32_cvtpd2uqq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8di)_mm512_setzero_si512(), \
+                                             (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtps_epi64 (__m256 __A) {
+  return (__m512i) __builtin_ia32_cvtps2qq512_mask ((__v8sf) __A,
+                (__v8di) _mm512_setzero_si512(),
+                (__mmask8) -1,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtps_epi64 (__m512i __W, __mmask8 __U, __m256 __A) {
+  return (__m512i) __builtin_ia32_cvtps2qq512_mask ((__v8sf) __A,
+                (__v8di) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtps_epi64 (__mmask8 __U, __m256 __A) {
+  return (__m512i) __builtin_ia32_cvtps2qq512_mask ((__v8sf) __A,
+                (__v8di) _mm512_setzero_si512(),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundps_epi64(A, R) \
+  ((__m512i)__builtin_ia32_cvtps2qq512_mask((__v8sf)(__m256)(A), \
+                                            (__v8di)_mm512_setzero_si512(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundps_epi64(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvtps2qq512_mask((__v8sf)(__m256)(A), \
+                                            (__v8di)(__m512i)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundps_epi64(U, A, R) \
+  ((__m512i)__builtin_ia32_cvtps2qq512_mask((__v8sf)(__m256)(A), \
+                                            (__v8di)_mm512_setzero_si512(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtps_epu64 (__m256 __A) {
+  return (__m512i) __builtin_ia32_cvtps2uqq512_mask ((__v8sf) __A,
+                 (__v8di) _mm512_setzero_si512(),
+                 (__mmask8) -1,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtps_epu64 (__m512i __W, __mmask8 __U, __m256 __A) {
+  return (__m512i) __builtin_ia32_cvtps2uqq512_mask ((__v8sf) __A,
+                 (__v8di) __W,
+                 (__mmask8) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtps_epu64 (__mmask8 __U, __m256 __A) {
+  return (__m512i) __builtin_ia32_cvtps2uqq512_mask ((__v8sf) __A,
+                 (__v8di) _mm512_setzero_si512(),
+                 (__mmask8) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundps_epu64(A, R) \
+  ((__m512i)__builtin_ia32_cvtps2uqq512_mask((__v8sf)(__m256)(A), \
+                                             (__v8di)_mm512_setzero_si512(), \
+                                             (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundps_epu64(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvtps2uqq512_mask((__v8sf)(__m256)(A), \
+                                             (__v8di)(__m512i)(W), \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundps_epu64(U, A, R) \
+  ((__m512i)__builtin_ia32_cvtps2uqq512_mask((__v8sf)(__m256)(A), \
+                                             (__v8di)_mm512_setzero_si512(), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_cvtepi64_pd (__m512i __A) {
+  return (__m512d)__builtin_convertvector((__v8di)__A, __v8df);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi64_pd (__m512d __W, __mmask8 __U, __m512i __A) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_cvtepi64_pd(__A),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi64_pd (__mmask8 __U, __m512i __A) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_cvtepi64_pd(__A),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+#define _mm512_cvt_roundepi64_pd(A, R) \
+  ((__m512d)__builtin_ia32_cvtqq2pd512_mask((__v8di)(__m512i)(A), \
+                                            (__v8df)_mm512_setzero_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundepi64_pd(W, U, A, R) \
+  ((__m512d)__builtin_ia32_cvtqq2pd512_mask((__v8di)(__m512i)(A), \
+                                            (__v8df)(__m512d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundepi64_pd(U, A, R) \
+  ((__m512d)__builtin_ia32_cvtqq2pd512_mask((__v8di)(__m512i)(A), \
+                                            (__v8df)_mm512_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS512
+_mm512_cvtepi64_ps (__m512i __A) {
+  return (__m256) __builtin_ia32_cvtqq2ps512_mask ((__v8di) __A,
+               (__v8sf) _mm256_setzero_ps(),
+               (__mmask8) -1,
+               _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi64_ps (__m256 __W, __mmask8 __U, __m512i __A) {
+  return (__m256) __builtin_ia32_cvtqq2ps512_mask ((__v8di) __A,
+               (__v8sf) __W,
+               (__mmask8) __U,
+               _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi64_ps (__mmask8 __U, __m512i __A) {
+  return (__m256) __builtin_ia32_cvtqq2ps512_mask ((__v8di) __A,
+               (__v8sf) _mm256_setzero_ps(),
+               (__mmask8) __U,
+               _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundepi64_ps(A, R) \
+  ((__m256)__builtin_ia32_cvtqq2ps512_mask((__v8di)(__m512i)(A), \
+                                           (__v8sf)_mm256_setzero_ps(), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundepi64_ps(W, U, A, R) \
+  ((__m256)__builtin_ia32_cvtqq2ps512_mask((__v8di)(__m512i)(A), \
+                                           (__v8sf)(__m256)(W), (__mmask8)(U), \
+                                           (int)(R)))
+
+#define _mm512_maskz_cvt_roundepi64_ps(U, A, R) \
+  ((__m256)__builtin_ia32_cvtqq2ps512_mask((__v8di)(__m512i)(A), \
+                                           (__v8sf)_mm256_setzero_ps(), \
+                                           (__mmask8)(U), (int)(R)))
+
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttpd_epi64 (__m512d __A) {
+  return (__m512i) __builtin_ia32_cvttpd2qq512_mask ((__v8df) __A,
+                 (__v8di) _mm512_setzero_si512(),
+                 (__mmask8) -1,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttpd_epi64 (__m512i __W, __mmask8 __U, __m512d __A) {
+  return (__m512i) __builtin_ia32_cvttpd2qq512_mask ((__v8df) __A,
+                 (__v8di) __W,
+                 (__mmask8) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttpd_epi64 (__mmask8 __U, __m512d __A) {
+  return (__m512i) __builtin_ia32_cvttpd2qq512_mask ((__v8df) __A,
+                 (__v8di) _mm512_setzero_si512(),
+                 (__mmask8) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundpd_epi64(A, R) \
+  ((__m512i)__builtin_ia32_cvttpd2qq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8di)_mm512_setzero_si512(), \
+                                             (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvtt_roundpd_epi64(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvttpd2qq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8di)(__m512i)(W), \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundpd_epi64(U, A, R) \
+  ((__m512i)__builtin_ia32_cvttpd2qq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8di)_mm512_setzero_si512(), \
+                                             (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttpd_epu64 (__m512d __A) {
+  return (__m512i) __builtin_ia32_cvttpd2uqq512_mask ((__v8df) __A,
+                  (__v8di) _mm512_setzero_si512(),
+                  (__mmask8) -1,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttpd_epu64 (__m512i __W, __mmask8 __U, __m512d __A) {
+  return (__m512i) __builtin_ia32_cvttpd2uqq512_mask ((__v8df) __A,
+                  (__v8di) __W,
+                  (__mmask8) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttpd_epu64 (__mmask8 __U, __m512d __A) {
+  return (__m512i) __builtin_ia32_cvttpd2uqq512_mask ((__v8df) __A,
+                  (__v8di) _mm512_setzero_si512(),
+                  (__mmask8) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundpd_epu64(A, R) \
+  ((__m512i)__builtin_ia32_cvttpd2uqq512_mask((__v8df)(__m512d)(A), \
+                                              (__v8di)_mm512_setzero_si512(), \
+                                              (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvtt_roundpd_epu64(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvttpd2uqq512_mask((__v8df)(__m512d)(A), \
+                                              (__v8di)(__m512i)(W), \
+                                              (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundpd_epu64(U, A, R) \
+  ((__m512i)__builtin_ia32_cvttpd2uqq512_mask((__v8df)(__m512d)(A), \
+                                              (__v8di)_mm512_setzero_si512(), \
+                                              (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttps_epi64 (__m256 __A) {
+  return (__m512i) __builtin_ia32_cvttps2qq512_mask ((__v8sf) __A,
+                 (__v8di) _mm512_setzero_si512(),
+                 (__mmask8) -1,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttps_epi64 (__m512i __W, __mmask8 __U, __m256 __A) {
+  return (__m512i) __builtin_ia32_cvttps2qq512_mask ((__v8sf) __A,
+                 (__v8di) __W,
+                 (__mmask8) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttps_epi64 (__mmask8 __U, __m256 __A) {
+  return (__m512i) __builtin_ia32_cvttps2qq512_mask ((__v8sf) __A,
+                 (__v8di) _mm512_setzero_si512(),
+                 (__mmask8) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundps_epi64(A, R) \
+  ((__m512i)__builtin_ia32_cvttps2qq512_mask((__v8sf)(__m256)(A), \
+                                             (__v8di)_mm512_setzero_si512(), \
+                                             (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvtt_roundps_epi64(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvttps2qq512_mask((__v8sf)(__m256)(A), \
+                                             (__v8di)(__m512i)(W), \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundps_epi64(U, A, R) \
+  ((__m512i)__builtin_ia32_cvttps2qq512_mask((__v8sf)(__m256)(A), \
+                                             (__v8di)_mm512_setzero_si512(), \
+                                             (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttps_epu64 (__m256 __A) {
+  return (__m512i) __builtin_ia32_cvttps2uqq512_mask ((__v8sf) __A,
+                  (__v8di) _mm512_setzero_si512(),
+                  (__mmask8) -1,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttps_epu64 (__m512i __W, __mmask8 __U, __m256 __A) {
+  return (__m512i) __builtin_ia32_cvttps2uqq512_mask ((__v8sf) __A,
+                  (__v8di) __W,
+                  (__mmask8) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttps_epu64 (__mmask8 __U, __m256 __A) {
+  return (__m512i) __builtin_ia32_cvttps2uqq512_mask ((__v8sf) __A,
+                  (__v8di) _mm512_setzero_si512(),
+                  (__mmask8) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundps_epu64(A, R) \
+  ((__m512i)__builtin_ia32_cvttps2uqq512_mask((__v8sf)(__m256)(A), \
+                                              (__v8di)_mm512_setzero_si512(), \
+                                              (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvtt_roundps_epu64(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvttps2uqq512_mask((__v8sf)(__m256)(A), \
+                                              (__v8di)(__m512i)(W), \
+                                              (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundps_epu64(U, A, R) \
+  ((__m512i)__builtin_ia32_cvttps2uqq512_mask((__v8sf)(__m256)(A), \
+                                              (__v8di)_mm512_setzero_si512(), \
+                                              (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_cvtepu64_pd (__m512i __A) {
+  return (__m512d)__builtin_convertvector((__v8du)__A, __v8df);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu64_pd (__m512d __W, __mmask8 __U, __m512i __A) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_cvtepu64_pd(__A),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu64_pd (__mmask8 __U, __m512i __A) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_cvtepu64_pd(__A),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+#define _mm512_cvt_roundepu64_pd(A, R) \
+  ((__m512d)__builtin_ia32_cvtuqq2pd512_mask((__v8di)(__m512i)(A), \
+                                             (__v8df)_mm512_setzero_pd(), \
+                                             (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundepu64_pd(W, U, A, R) \
+  ((__m512d)__builtin_ia32_cvtuqq2pd512_mask((__v8di)(__m512i)(A), \
+                                             (__v8df)(__m512d)(W), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_maskz_cvt_roundepu64_pd(U, A, R) \
+  ((__m512d)__builtin_ia32_cvtuqq2pd512_mask((__v8di)(__m512i)(A), \
+                                             (__v8df)_mm512_setzero_pd(), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS512
+_mm512_cvtepu64_ps (__m512i __A) {
+  return (__m256) __builtin_ia32_cvtuqq2ps512_mask ((__v8di) __A,
+                (__v8sf) _mm256_setzero_ps(),
+                (__mmask8) -1,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu64_ps (__m256 __W, __mmask8 __U, __m512i __A) {
+  return (__m256) __builtin_ia32_cvtuqq2ps512_mask ((__v8di) __A,
+                (__v8sf) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu64_ps (__mmask8 __U, __m512i __A) {
+  return (__m256) __builtin_ia32_cvtuqq2ps512_mask ((__v8di) __A,
+                (__v8sf) _mm256_setzero_ps(),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundepu64_ps(A, R) \
+  ((__m256)__builtin_ia32_cvtuqq2ps512_mask((__v8di)(__m512i)(A), \
+                                            (__v8sf)_mm256_setzero_ps(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundepu64_ps(W, U, A, R) \
+  ((__m256)__builtin_ia32_cvtuqq2ps512_mask((__v8di)(__m512i)(A), \
+                                            (__v8sf)(__m256)(W), (__mmask8)(U), \
+                                            (int)(R)))
+
+#define _mm512_maskz_cvt_roundepu64_ps(U, A, R) \
+  ((__m256)__builtin_ia32_cvtuqq2ps512_mask((__v8di)(__m512i)(A), \
+                                            (__v8sf)_mm256_setzero_ps(), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm512_range_pd(A, B, C) \
+  ((__m512d)__builtin_ia32_rangepd512_mask((__v8df)(__m512d)(A), \
+                                           (__v8df)(__m512d)(B), (int)(C), \
+                                           (__v8df)_mm512_setzero_pd(), \
+                                           (__mmask8)-1, \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_range_pd(W, U, A, B, C) \
+  ((__m512d)__builtin_ia32_rangepd512_mask((__v8df)(__m512d)(A), \
+                                           (__v8df)(__m512d)(B), (int)(C), \
+                                           (__v8df)(__m512d)(W), (__mmask8)(U), \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_range_pd(U, A, B, C) \
+  ((__m512d)__builtin_ia32_rangepd512_mask((__v8df)(__m512d)(A), \
+                                           (__v8df)(__m512d)(B), (int)(C), \
+                                           (__v8df)_mm512_setzero_pd(), \
+                                           (__mmask8)(U), \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_range_round_pd(A, B, C, R) \
+  ((__m512d)__builtin_ia32_rangepd512_mask((__v8df)(__m512d)(A), \
+                                           (__v8df)(__m512d)(B), (int)(C), \
+                                           (__v8df)_mm512_setzero_pd(), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_range_round_pd(W, U, A, B, C, R) \
+  ((__m512d)__builtin_ia32_rangepd512_mask((__v8df)(__m512d)(A), \
+                                           (__v8df)(__m512d)(B), (int)(C), \
+                                           (__v8df)(__m512d)(W), (__mmask8)(U), \
+                                           (int)(R)))
+
+#define _mm512_maskz_range_round_pd(U, A, B, C, R) \
+  ((__m512d)__builtin_ia32_rangepd512_mask((__v8df)(__m512d)(A), \
+                                           (__v8df)(__m512d)(B), (int)(C), \
+                                           (__v8df)_mm512_setzero_pd(), \
+                                           (__mmask8)(U), (int)(R)))
+
+#define _mm512_range_ps(A, B, C) \
+  ((__m512)__builtin_ia32_rangeps512_mask((__v16sf)(__m512)(A), \
+                                          (__v16sf)(__m512)(B), (int)(C), \
+                                          (__v16sf)_mm512_setzero_ps(), \
+                                          (__mmask16)-1, \
+                                          _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_range_ps(W, U, A, B, C) \
+  ((__m512)__builtin_ia32_rangeps512_mask((__v16sf)(__m512)(A), \
+                                          (__v16sf)(__m512)(B), (int)(C), \
+                                          (__v16sf)(__m512)(W), (__mmask16)(U), \
+                                          _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_range_ps(U, A, B, C) \
+  ((__m512)__builtin_ia32_rangeps512_mask((__v16sf)(__m512)(A), \
+                                          (__v16sf)(__m512)(B), (int)(C), \
+                                          (__v16sf)_mm512_setzero_ps(), \
+                                          (__mmask16)(U), \
+                                          _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_range_round_ps(A, B, C, R) \
+  ((__m512)__builtin_ia32_rangeps512_mask((__v16sf)(__m512)(A), \
+                                          (__v16sf)(__m512)(B), (int)(C), \
+                                          (__v16sf)_mm512_setzero_ps(), \
+                                          (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_range_round_ps(W, U, A, B, C, R) \
+  ((__m512)__builtin_ia32_rangeps512_mask((__v16sf)(__m512)(A), \
+                                          (__v16sf)(__m512)(B), (int)(C), \
+                                          (__v16sf)(__m512)(W), (__mmask16)(U), \
+                                          (int)(R)))
+
+#define _mm512_maskz_range_round_ps(U, A, B, C, R) \
+  ((__m512)__builtin_ia32_rangeps512_mask((__v16sf)(__m512)(A), \
+                                          (__v16sf)(__m512)(B), (int)(C), \
+                                          (__v16sf)_mm512_setzero_ps(), \
+                                          (__mmask16)(U), (int)(R)))
+
+#define _mm_range_round_ss(A, B, C, R) \
+  ((__m128)__builtin_ia32_rangess128_round_mask((__v4sf)(__m128)(A), \
+                                                (__v4sf)(__m128)(B), \
+                                                (__v4sf)_mm_setzero_ps(), \
+                                                (__mmask8) -1, (int)(C),\
+                                                (int)(R)))
+
+#define _mm_range_ss(A ,B , C) _mm_range_round_ss(A, B, C ,_MM_FROUND_CUR_DIRECTION)
+
+#define _mm_mask_range_round_ss(W, U, A, B, C, R) \
+  ((__m128)__builtin_ia32_rangess128_round_mask((__v4sf)(__m128)(A), \
+                                                (__v4sf)(__m128)(B), \
+                                                (__v4sf)(__m128)(W),\
+                                                (__mmask8)(U), (int)(C),\
+                                                (int)(R)))
+
+#define _mm_mask_range_ss(W , U, A, B, C) _mm_mask_range_round_ss(W, U, A, B, C , _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_maskz_range_round_ss(U, A, B, C, R) \
+  ((__m128)__builtin_ia32_rangess128_round_mask((__v4sf)(__m128)(A), \
+                                                (__v4sf)(__m128)(B), \
+                                                (__v4sf)_mm_setzero_ps(), \
+                                                (__mmask8)(U), (int)(C),\
+                                                (int)(R)))
+
+#define _mm_maskz_range_ss(U, A ,B , C) _mm_maskz_range_round_ss(U, A, B, C ,_MM_FROUND_CUR_DIRECTION)
+
+#define _mm_range_round_sd(A, B, C, R) \
+  ((__m128d)__builtin_ia32_rangesd128_round_mask((__v2df)(__m128d)(A), \
+                                                 (__v2df)(__m128d)(B), \
+                                                 (__v2df)_mm_setzero_pd(), \
+                                                 (__mmask8) -1, (int)(C),\
+                                                 (int)(R)))
+
+#define _mm_range_sd(A ,B , C) _mm_range_round_sd(A, B, C ,_MM_FROUND_CUR_DIRECTION)
+
+#define _mm_mask_range_round_sd(W, U, A, B, C, R) \
+  ((__m128d)__builtin_ia32_rangesd128_round_mask((__v2df)(__m128d)(A), \
+                                                 (__v2df)(__m128d)(B), \
+                                                 (__v2df)(__m128d)(W),\
+                                                 (__mmask8)(U), (int)(C),\
+                                                 (int)(R)))
+
+#define _mm_mask_range_sd(W, U, A, B, C) _mm_mask_range_round_sd(W, U, A, B, C ,_MM_FROUND_CUR_DIRECTION)
+
+#define _mm_maskz_range_round_sd(U, A, B, C, R) \
+  ((__m128d)__builtin_ia32_rangesd128_round_mask((__v2df)(__m128d)(A), \
+                                                 (__v2df)(__m128d)(B), \
+                                                 (__v2df)_mm_setzero_pd(), \
+                                                 (__mmask8)(U), (int)(C),\
+                                                 (int)(R)))
+
+#define _mm_maskz_range_sd(U, A, B, C) _mm_maskz_range_round_sd(U, A, B, C ,_MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_reduce_pd(A, B) \
+  ((__m512d)__builtin_ia32_reducepd512_mask((__v8df)(__m512d)(A), (int)(B), \
+                                            (__v8df)_mm512_setzero_pd(), \
+                                            (__mmask8)-1, \
+                                            _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_reduce_pd(W, U, A, B) \
+  ((__m512d)__builtin_ia32_reducepd512_mask((__v8df)(__m512d)(A), (int)(B), \
+                                            (__v8df)(__m512d)(W), \
+                                            (__mmask8)(U), \
+                                            _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_reduce_pd(U, A, B) \
+  ((__m512d)__builtin_ia32_reducepd512_mask((__v8df)(__m512d)(A), (int)(B), \
+                                            (__v8df)_mm512_setzero_pd(), \
+                                            (__mmask8)(U), \
+                                            _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_reduce_ps(A, B) \
+  ((__m512)__builtin_ia32_reduceps512_mask((__v16sf)(__m512)(A), (int)(B), \
+                                           (__v16sf)_mm512_setzero_ps(), \
+                                           (__mmask16)-1, \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_reduce_ps(W, U, A, B) \
+  ((__m512)__builtin_ia32_reduceps512_mask((__v16sf)(__m512)(A), (int)(B), \
+                                           (__v16sf)(__m512)(W), \
+                                           (__mmask16)(U), \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_reduce_ps(U, A, B) \
+  ((__m512)__builtin_ia32_reduceps512_mask((__v16sf)(__m512)(A), (int)(B), \
+                                           (__v16sf)_mm512_setzero_ps(), \
+                                           (__mmask16)(U), \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_reduce_round_pd(A, B, R) \
+  ((__m512d)__builtin_ia32_reducepd512_mask((__v8df)(__m512d)(A), (int)(B), \
+                                            (__v8df)_mm512_setzero_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_reduce_round_pd(W, U, A, B, R) \
+  ((__m512d)__builtin_ia32_reducepd512_mask((__v8df)(__m512d)(A), (int)(B), \
+                                            (__v8df)(__m512d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_reduce_round_pd(U, A, B, R) \
+  ((__m512d)__builtin_ia32_reducepd512_mask((__v8df)(__m512d)(A), (int)(B), \
+                                            (__v8df)_mm512_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm512_reduce_round_ps(A, B, R) \
+  ((__m512)__builtin_ia32_reduceps512_mask((__v16sf)(__m512)(A), (int)(B), \
+                                           (__v16sf)_mm512_setzero_ps(), \
+                                           (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_reduce_round_ps(W, U, A, B, R) \
+  ((__m512)__builtin_ia32_reduceps512_mask((__v16sf)(__m512)(A), (int)(B), \
+                                           (__v16sf)(__m512)(W), \
+                                           (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_reduce_round_ps(U, A, B, R) \
+  ((__m512)__builtin_ia32_reduceps512_mask((__v16sf)(__m512)(A), (int)(B), \
+                                           (__v16sf)_mm512_setzero_ps(), \
+                                           (__mmask16)(U), (int)(R)))
+
+#define _mm_reduce_ss(A, B, C) \
+  ((__m128)__builtin_ia32_reducess_mask((__v4sf)(__m128)(A), \
+                                        (__v4sf)(__m128)(B), \
+                                        (__v4sf)_mm_setzero_ps(), (__mmask8)-1, \
+                                        (int)(C), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_reduce_ss(W, U, A, B, C) \
+  ((__m128)__builtin_ia32_reducess_mask((__v4sf)(__m128)(A), \
+                                        (__v4sf)(__m128)(B), \
+                                        (__v4sf)(__m128)(W), (__mmask8)(U), \
+                                        (int)(C), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_reduce_ss(U, A, B, C) \
+  ((__m128)__builtin_ia32_reducess_mask((__v4sf)(__m128)(A), \
+                                        (__v4sf)(__m128)(B), \
+                                        (__v4sf)_mm_setzero_ps(), \
+                                        (__mmask8)(U), (int)(C), \
+                                        _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_reduce_round_ss(A, B, C, R) \
+  ((__m128)__builtin_ia32_reducess_mask((__v4sf)(__m128)(A), \
+                                        (__v4sf)(__m128)(B), \
+                                        (__v4sf)_mm_setzero_ps(), (__mmask8)-1, \
+                                        (int)(C), (int)(R)))
+
+#define _mm_mask_reduce_round_ss(W, U, A, B, C, R) \
+  ((__m128)__builtin_ia32_reducess_mask((__v4sf)(__m128)(A), \
+                                        (__v4sf)(__m128)(B), \
+                                        (__v4sf)(__m128)(W), (__mmask8)(U), \
+                                        (int)(C), (int)(R)))
+
+#define _mm_maskz_reduce_round_ss(U, A, B, C, R) \
+  ((__m128)__builtin_ia32_reducess_mask((__v4sf)(__m128)(A), \
+                                        (__v4sf)(__m128)(B), \
+                                        (__v4sf)_mm_setzero_ps(), \
+                                        (__mmask8)(U), (int)(C), (int)(R)))
+
+#define _mm_reduce_sd(A, B, C) \
+  ((__m128d)__builtin_ia32_reducesd_mask((__v2df)(__m128d)(A), \
+                                         (__v2df)(__m128d)(B), \
+                                         (__v2df)_mm_setzero_pd(), \
+                                         (__mmask8)-1, (int)(C), \
+                                         _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_reduce_sd(W, U, A, B, C) \
+  ((__m128d)__builtin_ia32_reducesd_mask((__v2df)(__m128d)(A), \
+                                         (__v2df)(__m128d)(B), \
+                                         (__v2df)(__m128d)(W), (__mmask8)(U), \
+                                         (int)(C), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_reduce_sd(U, A, B, C) \
+  ((__m128d)__builtin_ia32_reducesd_mask((__v2df)(__m128d)(A), \
+                                         (__v2df)(__m128d)(B), \
+                                         (__v2df)_mm_setzero_pd(), \
+                                         (__mmask8)(U), (int)(C), \
+                                         _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_reduce_round_sd(A, B, C, R) \
+  ((__m128d)__builtin_ia32_reducesd_mask((__v2df)(__m128d)(A), \
+                                         (__v2df)(__m128d)(B), \
+                                         (__v2df)_mm_setzero_pd(), \
+                                         (__mmask8)-1, (int)(C), (int)(R)))
+
+#define _mm_mask_reduce_round_sd(W, U, A, B, C, R) \
+  ((__m128d)__builtin_ia32_reducesd_mask((__v2df)(__m128d)(A), \
+                                         (__v2df)(__m128d)(B), \
+                                         (__v2df)(__m128d)(W), (__mmask8)(U), \
+                                         (int)(C), (int)(R)))
+
+#define _mm_maskz_reduce_round_sd(U, A, B, C, R) \
+  ((__m128d)__builtin_ia32_reducesd_mask((__v2df)(__m128d)(A), \
+                                         (__v2df)(__m128d)(B), \
+                                         (__v2df)_mm_setzero_pd(), \
+                                         (__mmask8)(U), (int)(C), (int)(R)))
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS512
+_mm512_movepi32_mask (__m512i __A)
+{
+  return (__mmask16) __builtin_ia32_cvtd2mask512 ((__v16si) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_movm_epi32 (__mmask16 __A)
+{
+  return (__m512i) __builtin_ia32_cvtmask2d512 (__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_movm_epi64 (__mmask8 __A)
+{
+  return (__m512i) __builtin_ia32_cvtmask2q512 (__A);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS512
+_mm512_movepi64_mask (__m512i __A)
+{
+  return (__mmask8) __builtin_ia32_cvtq2mask512 ((__v8di) __A);
+}
+
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_broadcast_f32x2 (__m128 __A)
+{
+  return (__m512)__builtin_shufflevector((__v4sf)__A, (__v4sf)__A,
+                                         0, 1, 0, 1, 0, 1, 0, 1,
+                                         0, 1, 0, 1, 0, 1, 0, 1);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcast_f32x2 (__m512 __O, __mmask16 __M, __m128 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__M,
+                                             (__v16sf)_mm512_broadcast_f32x2(__A),
+                                             (__v16sf)__O);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcast_f32x2 (__mmask16 __M, __m128 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__M,
+                                             (__v16sf)_mm512_broadcast_f32x2(__A),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_broadcast_f32x8(__m256 __A)
+{
+  return (__m512)__builtin_shufflevector((__v8sf)__A, (__v8sf)__A,
+                                         0, 1, 2, 3, 4, 5, 6, 7,
+                                         0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcast_f32x8(__m512 __O, __mmask16 __M, __m256 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__M,
+                                           (__v16sf)_mm512_broadcast_f32x8(__A),
+                                           (__v16sf)__O);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcast_f32x8(__mmask16 __M, __m256 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__M,
+                                           (__v16sf)_mm512_broadcast_f32x8(__A),
+                                           (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_broadcast_f64x2(__m128d __A)
+{
+  return (__m512d)__builtin_shufflevector((__v2df)__A, (__v2df)__A,
+                                          0, 1, 0, 1, 0, 1, 0, 1);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcast_f64x2(__m512d __O, __mmask8 __M, __m128d __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__M,
+                                            (__v8df)_mm512_broadcast_f64x2(__A),
+                                            (__v8df)__O);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcast_f64x2(__mmask8 __M, __m128d __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__M,
+                                            (__v8df)_mm512_broadcast_f64x2(__A),
+                                            (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_broadcast_i32x2 (__m128i __A)
+{
+  return (__m512i)__builtin_shufflevector((__v4si)__A, (__v4si)__A,
+                                          0, 1, 0, 1, 0, 1, 0, 1,
+                                          0, 1, 0, 1, 0, 1, 0, 1);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcast_i32x2 (__m512i __O, __mmask16 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                             (__v16si)_mm512_broadcast_i32x2(__A),
+                                             (__v16si)__O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcast_i32x2 (__mmask16 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                             (__v16si)_mm512_broadcast_i32x2(__A),
+                                             (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_broadcast_i32x8(__m256i __A)
+{
+  return (__m512i)__builtin_shufflevector((__v8si)__A, (__v8si)__A,
+                                          0, 1, 2, 3, 4, 5, 6, 7,
+                                          0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcast_i32x8(__m512i __O, __mmask16 __M, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                           (__v16si)_mm512_broadcast_i32x8(__A),
+                                           (__v16si)__O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcast_i32x8(__mmask16 __M, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                           (__v16si)_mm512_broadcast_i32x8(__A),
+                                           (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_broadcast_i64x2(__m128i __A)
+{
+  return (__m512i)__builtin_shufflevector((__v2di)__A, (__v2di)__A,
+                                          0, 1, 0, 1, 0, 1, 0, 1);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcast_i64x2(__m512i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                            (__v8di)_mm512_broadcast_i64x2(__A),
+                                            (__v8di)__O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcast_i64x2(__mmask8 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                            (__v8di)_mm512_broadcast_i64x2(__A),
+                                            (__v8di)_mm512_setzero_si512());
+}
+
+#define _mm512_extractf32x8_ps(A, imm) \
+  ((__m256)__builtin_ia32_extractf32x8_mask((__v16sf)(__m512)(A), (int)(imm), \
+                                            (__v8sf)_mm256_undefined_ps(), \
+                                            (__mmask8)-1))
+
+#define _mm512_mask_extractf32x8_ps(W, U, A, imm) \
+  ((__m256)__builtin_ia32_extractf32x8_mask((__v16sf)(__m512)(A), (int)(imm), \
+                                            (__v8sf)(__m256)(W), \
+                                            (__mmask8)(U)))
+
+#define _mm512_maskz_extractf32x8_ps(U, A, imm) \
+  ((__m256)__builtin_ia32_extractf32x8_mask((__v16sf)(__m512)(A), (int)(imm), \
+                                            (__v8sf)_mm256_setzero_ps(), \
+                                            (__mmask8)(U)))
+
+#define _mm512_extractf64x2_pd(A, imm) \
+  ((__m128d)__builtin_ia32_extractf64x2_512_mask((__v8df)(__m512d)(A), \
+                                                 (int)(imm), \
+                                                 (__v2df)_mm_undefined_pd(), \
+                                                 (__mmask8)-1))
+
+#define _mm512_mask_extractf64x2_pd(W, U, A, imm) \
+  ((__m128d)__builtin_ia32_extractf64x2_512_mask((__v8df)(__m512d)(A), \
+                                                 (int)(imm), \
+                                                 (__v2df)(__m128d)(W), \
+                                                 (__mmask8)(U)))
+
+#define _mm512_maskz_extractf64x2_pd(U, A, imm) \
+  ((__m128d)__builtin_ia32_extractf64x2_512_mask((__v8df)(__m512d)(A), \
+                                                 (int)(imm), \
+                                                 (__v2df)_mm_setzero_pd(), \
+                                                 (__mmask8)(U)))
+
+#define _mm512_extracti32x8_epi32(A, imm) \
+  ((__m256i)__builtin_ia32_extracti32x8_mask((__v16si)(__m512i)(A), (int)(imm), \
+                                             (__v8si)_mm256_undefined_si256(), \
+                                             (__mmask8)-1))
+
+#define _mm512_mask_extracti32x8_epi32(W, U, A, imm) \
+  ((__m256i)__builtin_ia32_extracti32x8_mask((__v16si)(__m512i)(A), (int)(imm), \
+                                             (__v8si)(__m256i)(W), \
+                                             (__mmask8)(U)))
+
+#define _mm512_maskz_extracti32x8_epi32(U, A, imm) \
+  ((__m256i)__builtin_ia32_extracti32x8_mask((__v16si)(__m512i)(A), (int)(imm), \
+                                             (__v8si)_mm256_setzero_si256(), \
+                                             (__mmask8)(U)))
+
+#define _mm512_extracti64x2_epi64(A, imm) \
+  ((__m128i)__builtin_ia32_extracti64x2_512_mask((__v8di)(__m512i)(A), \
+                                                (int)(imm), \
+                                                (__v2di)_mm_undefined_si128(), \
+                                                (__mmask8)-1))
+
+#define _mm512_mask_extracti64x2_epi64(W, U, A, imm) \
+  ((__m128i)__builtin_ia32_extracti64x2_512_mask((__v8di)(__m512i)(A), \
+                                                 (int)(imm), \
+                                                 (__v2di)(__m128i)(W), \
+                                                 (__mmask8)(U)))
+
+#define _mm512_maskz_extracti64x2_epi64(U, A, imm) \
+  ((__m128i)__builtin_ia32_extracti64x2_512_mask((__v8di)(__m512i)(A), \
+                                                 (int)(imm), \
+                                                 (__v2di)_mm_setzero_si128(), \
+                                                 (__mmask8)(U)))
+
+#define _mm512_insertf32x8(A, B, imm) \
+  ((__m512)__builtin_ia32_insertf32x8((__v16sf)(__m512)(A), \
+                                      (__v8sf)(__m256)(B), (int)(imm)))
+
+#define _mm512_mask_insertf32x8(W, U, A, B, imm) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                 (__v16sf)_mm512_insertf32x8((A), (B), (imm)), \
+                                 (__v16sf)(__m512)(W)))
+
+#define _mm512_maskz_insertf32x8(U, A, B, imm) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                 (__v16sf)_mm512_insertf32x8((A), (B), (imm)), \
+                                 (__v16sf)_mm512_setzero_ps()))
+
+#define _mm512_insertf64x2(A, B, imm) \
+  ((__m512d)__builtin_ia32_insertf64x2_512((__v8df)(__m512d)(A), \
+                                           (__v2df)(__m128d)(B), (int)(imm)))
+
+#define _mm512_mask_insertf64x2(W, U, A, B, imm) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                  (__v8df)_mm512_insertf64x2((A), (B), (imm)), \
+                                  (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_insertf64x2(U, A, B, imm) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                  (__v8df)_mm512_insertf64x2((A), (B), (imm)), \
+                                  (__v8df)_mm512_setzero_pd()))
+
+#define _mm512_inserti32x8(A, B, imm) \
+  ((__m512i)__builtin_ia32_inserti32x8((__v16si)(__m512i)(A), \
+                                       (__v8si)(__m256i)(B), (int)(imm)))
+
+#define _mm512_mask_inserti32x8(W, U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                 (__v16si)_mm512_inserti32x8((A), (B), (imm)), \
+                                 (__v16si)(__m512i)(W)))
+
+#define _mm512_maskz_inserti32x8(U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                 (__v16si)_mm512_inserti32x8((A), (B), (imm)), \
+                                 (__v16si)_mm512_setzero_si512()))
+
+#define _mm512_inserti64x2(A, B, imm) \
+  ((__m512i)__builtin_ia32_inserti64x2_512((__v8di)(__m512i)(A), \
+                                           (__v2di)(__m128i)(B), (int)(imm)))
+
+#define _mm512_mask_inserti64x2(W, U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                  (__v8di)_mm512_inserti64x2((A), (B), (imm)), \
+                                  (__v8di)(__m512i)(W)))
+
+#define _mm512_maskz_inserti64x2(U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                  (__v8di)_mm512_inserti64x2((A), (B), (imm)), \
+                                  (__v8di)_mm512_setzero_si512()))
+
+#define _mm512_mask_fpclass_ps_mask(U, A, imm) \
+  ((__mmask16)__builtin_ia32_fpclassps512_mask((__v16sf)(__m512)(A), \
+                                               (int)(imm), (__mmask16)(U)))
+
+#define _mm512_fpclass_ps_mask(A, imm) \
+  ((__mmask16)__builtin_ia32_fpclassps512_mask((__v16sf)(__m512)(A), \
+                                               (int)(imm), (__mmask16)-1))
+
+#define _mm512_mask_fpclass_pd_mask(U, A, imm) \
+  ((__mmask8)__builtin_ia32_fpclasspd512_mask((__v8df)(__m512d)(A), (int)(imm), \
+                                              (__mmask8)(U)))
+
+#define _mm512_fpclass_pd_mask(A, imm) \
+  ((__mmask8)__builtin_ia32_fpclasspd512_mask((__v8df)(__m512d)(A), (int)(imm), \
+                                              (__mmask8)-1))
+
+#define _mm_fpclass_sd_mask(A, imm) \
+  ((__mmask8)__builtin_ia32_fpclasssd_mask((__v2df)(__m128d)(A), (int)(imm), \
+                                           (__mmask8)-1))
+
+#define _mm_mask_fpclass_sd_mask(U, A, imm) \
+  ((__mmask8)__builtin_ia32_fpclasssd_mask((__v2df)(__m128d)(A), (int)(imm), \
+                                           (__mmask8)(U)))
+
+#define _mm_fpclass_ss_mask(A, imm) \
+  ((__mmask8)__builtin_ia32_fpclassss_mask((__v4sf)(__m128)(A), (int)(imm), \
+                                           (__mmask8)-1))
+
+#define _mm_mask_fpclass_ss_mask(U, A, imm) \
+  ((__mmask8)__builtin_ia32_fpclassss_mask((__v4sf)(__m128)(A), (int)(imm), \
+                                           (__mmask8)(U)))
+
+#undef __DEFAULT_FN_ATTRS512
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/avx512erintrin.h b/third_party/intel/clang/avx512erintrin.h
new file mode 100644
index 000000000..1c5a2d2d2
--- /dev/null
+++ b/third_party/intel/clang/avx512erintrin.h
@@ -0,0 +1,271 @@
+/*===---- avx512erintrin.h - AVX512ER intrinsics ---------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512erintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512ERINTRIN_H
+#define __AVX512ERINTRIN_H
+
+/* exp2a23 */
+#define _mm512_exp2a23_round_pd(A, R) \
+  ((__m512d)__builtin_ia32_exp2pd_mask((__v8df)(__m512d)(A), \
+                                       (__v8df)_mm512_setzero_pd(), \
+                                       (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_exp2a23_round_pd(S, M, A, R) \
+  ((__m512d)__builtin_ia32_exp2pd_mask((__v8df)(__m512d)(A), \
+                                       (__v8df)(__m512d)(S), (__mmask8)(M), \
+                                       (int)(R)))
+
+#define _mm512_maskz_exp2a23_round_pd(M, A, R) \
+  ((__m512d)__builtin_ia32_exp2pd_mask((__v8df)(__m512d)(A), \
+                                       (__v8df)_mm512_setzero_pd(), \
+                                       (__mmask8)(M), (int)(R)))
+
+#define _mm512_exp2a23_pd(A) \
+  _mm512_exp2a23_round_pd((A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_mask_exp2a23_pd(S, M, A) \
+  _mm512_mask_exp2a23_round_pd((S), (M), (A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_maskz_exp2a23_pd(M, A) \
+  _mm512_maskz_exp2a23_round_pd((M), (A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_exp2a23_round_ps(A, R) \
+  ((__m512)__builtin_ia32_exp2ps_mask((__v16sf)(__m512)(A), \
+                                      (__v16sf)_mm512_setzero_ps(), \
+                                      (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_exp2a23_round_ps(S, M, A, R) \
+  ((__m512)__builtin_ia32_exp2ps_mask((__v16sf)(__m512)(A), \
+                                      (__v16sf)(__m512)(S), (__mmask16)(M), \
+                                      (int)(R)))
+
+#define _mm512_maskz_exp2a23_round_ps(M, A, R) \
+  ((__m512)__builtin_ia32_exp2ps_mask((__v16sf)(__m512)(A), \
+                                      (__v16sf)_mm512_setzero_ps(), \
+                                      (__mmask16)(M), (int)(R)))
+
+#define _mm512_exp2a23_ps(A) \
+  _mm512_exp2a23_round_ps((A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_mask_exp2a23_ps(S, M, A) \
+  _mm512_mask_exp2a23_round_ps((S), (M), (A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_maskz_exp2a23_ps(M, A) \
+  _mm512_maskz_exp2a23_round_ps((M), (A), _MM_FROUND_CUR_DIRECTION)
+
+/* rsqrt28 */
+#define _mm512_rsqrt28_round_pd(A, R) \
+  ((__m512d)__builtin_ia32_rsqrt28pd_mask((__v8df)(__m512d)(A), \
+                                          (__v8df)_mm512_setzero_pd(), \
+                                          (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_rsqrt28_round_pd(S, M, A, R) \
+  ((__m512d)__builtin_ia32_rsqrt28pd_mask((__v8df)(__m512d)(A), \
+                                          (__v8df)(__m512d)(S), (__mmask8)(M), \
+                                          (int)(R)))
+
+#define _mm512_maskz_rsqrt28_round_pd(M, A, R) \
+  ((__m512d)__builtin_ia32_rsqrt28pd_mask((__v8df)(__m512d)(A), \
+                                          (__v8df)_mm512_setzero_pd(), \
+                                          (__mmask8)(M), (int)(R)))
+
+#define _mm512_rsqrt28_pd(A) \
+  _mm512_rsqrt28_round_pd((A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_mask_rsqrt28_pd(S, M, A) \
+  _mm512_mask_rsqrt28_round_pd((S), (M), (A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_maskz_rsqrt28_pd(M, A) \
+  _mm512_maskz_rsqrt28_round_pd((M), (A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_rsqrt28_round_ps(A, R) \
+  ((__m512)__builtin_ia32_rsqrt28ps_mask((__v16sf)(__m512)(A), \
+                                         (__v16sf)_mm512_setzero_ps(), \
+                                         (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_rsqrt28_round_ps(S, M, A, R) \
+  ((__m512)__builtin_ia32_rsqrt28ps_mask((__v16sf)(__m512)(A), \
+                                         (__v16sf)(__m512)(S), (__mmask16)(M), \
+                                         (int)(R)))
+
+#define _mm512_maskz_rsqrt28_round_ps(M, A, R) \
+  ((__m512)__builtin_ia32_rsqrt28ps_mask((__v16sf)(__m512)(A), \
+                                         (__v16sf)_mm512_setzero_ps(), \
+                                         (__mmask16)(M), (int)(R)))
+
+#define _mm512_rsqrt28_ps(A) \
+  _mm512_rsqrt28_round_ps((A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_mask_rsqrt28_ps(S, M, A) \
+  _mm512_mask_rsqrt28_round_ps((S), (M), A, _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_maskz_rsqrt28_ps(M, A) \
+  _mm512_maskz_rsqrt28_round_ps((M), (A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_rsqrt28_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_rsqrt28ss_round_mask((__v4sf)(__m128)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (__v4sf)_mm_setzero_ps(), \
+                                               (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_rsqrt28_round_ss(S, M, A, B, R) \
+  ((__m128)__builtin_ia32_rsqrt28ss_round_mask((__v4sf)(__m128)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (__v4sf)(__m128)(S), \
+                                               (__mmask8)(M), (int)(R)))
+
+#define _mm_maskz_rsqrt28_round_ss(M, A, B, R) \
+  ((__m128)__builtin_ia32_rsqrt28ss_round_mask((__v4sf)(__m128)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (__v4sf)_mm_setzero_ps(), \
+                                               (__mmask8)(M), (int)(R)))
+
+#define _mm_rsqrt28_ss(A, B) \
+  _mm_rsqrt28_round_ss((A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_mask_rsqrt28_ss(S, M, A, B) \
+  _mm_mask_rsqrt28_round_ss((S), (M), (A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_maskz_rsqrt28_ss(M, A, B) \
+  _mm_maskz_rsqrt28_round_ss((M), (A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_rsqrt28_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_rsqrt28sd_round_mask((__v2df)(__m128d)(A), \
+                                                (__v2df)(__m128d)(B), \
+                                                (__v2df)_mm_setzero_pd(), \
+                                                (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_rsqrt28_round_sd(S, M, A, B, R) \
+  ((__m128d)__builtin_ia32_rsqrt28sd_round_mask((__v2df)(__m128d)(A), \
+                                                (__v2df)(__m128d)(B), \
+                                                (__v2df)(__m128d)(S), \
+                                                (__mmask8)(M), (int)(R)))
+
+#define _mm_maskz_rsqrt28_round_sd(M, A, B, R) \
+  ((__m128d)__builtin_ia32_rsqrt28sd_round_mask((__v2df)(__m128d)(A), \
+                                                (__v2df)(__m128d)(B), \
+                                                (__v2df)_mm_setzero_pd(), \
+                                                (__mmask8)(M), (int)(R)))
+
+#define _mm_rsqrt28_sd(A, B) \
+  _mm_rsqrt28_round_sd((A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_mask_rsqrt28_sd(S, M, A, B) \
+  _mm_mask_rsqrt28_round_sd((S), (M), (A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_maskz_rsqrt28_sd(M, A, B) \
+  _mm_maskz_rsqrt28_round_sd((M), (A), (B), _MM_FROUND_CUR_DIRECTION)
+
+/* rcp28 */
+#define _mm512_rcp28_round_pd(A, R) \
+  ((__m512d)__builtin_ia32_rcp28pd_mask((__v8df)(__m512d)(A), \
+                                        (__v8df)_mm512_setzero_pd(), \
+                                        (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_rcp28_round_pd(S, M, A, R) \
+  ((__m512d)__builtin_ia32_rcp28pd_mask((__v8df)(__m512d)(A), \
+                                        (__v8df)(__m512d)(S), (__mmask8)(M), \
+                                        (int)(R)))
+
+#define _mm512_maskz_rcp28_round_pd(M, A, R) \
+  ((__m512d)__builtin_ia32_rcp28pd_mask((__v8df)(__m512d)(A), \
+                                        (__v8df)_mm512_setzero_pd(), \
+                                        (__mmask8)(M), (int)(R)))
+
+#define _mm512_rcp28_pd(A) \
+  _mm512_rcp28_round_pd((A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_mask_rcp28_pd(S, M, A) \
+  _mm512_mask_rcp28_round_pd((S), (M), (A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_maskz_rcp28_pd(M, A) \
+  _mm512_maskz_rcp28_round_pd((M), (A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_rcp28_round_ps(A, R) \
+  ((__m512)__builtin_ia32_rcp28ps_mask((__v16sf)(__m512)(A), \
+                                       (__v16sf)_mm512_setzero_ps(), \
+                                       (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_rcp28_round_ps(S, M, A, R) \
+  ((__m512)__builtin_ia32_rcp28ps_mask((__v16sf)(__m512)(A), \
+                                       (__v16sf)(__m512)(S), (__mmask16)(M), \
+                                       (int)(R)))
+
+#define _mm512_maskz_rcp28_round_ps(M, A, R) \
+  ((__m512)__builtin_ia32_rcp28ps_mask((__v16sf)(__m512)(A), \
+                                       (__v16sf)_mm512_setzero_ps(), \
+                                       (__mmask16)(M), (int)(R)))
+
+#define _mm512_rcp28_ps(A) \
+  _mm512_rcp28_round_ps((A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_mask_rcp28_ps(S, M, A) \
+  _mm512_mask_rcp28_round_ps((S), (M), (A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_maskz_rcp28_ps(M, A) \
+  _mm512_maskz_rcp28_round_ps((M), (A), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_rcp28_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_rcp28ss_round_mask((__v4sf)(__m128)(A), \
+                                             (__v4sf)(__m128)(B), \
+                                             (__v4sf)_mm_setzero_ps(), \
+                                             (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_rcp28_round_ss(S, M, A, B, R) \
+  ((__m128)__builtin_ia32_rcp28ss_round_mask((__v4sf)(__m128)(A), \
+                                             (__v4sf)(__m128)(B), \
+                                             (__v4sf)(__m128)(S), \
+                                             (__mmask8)(M), (int)(R)))
+
+#define _mm_maskz_rcp28_round_ss(M, A, B, R) \
+  ((__m128)__builtin_ia32_rcp28ss_round_mask((__v4sf)(__m128)(A), \
+                                             (__v4sf)(__m128)(B), \
+                                             (__v4sf)_mm_setzero_ps(), \
+                                             (__mmask8)(M), (int)(R)))
+
+#define _mm_rcp28_ss(A, B) \
+  _mm_rcp28_round_ss((A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_mask_rcp28_ss(S, M, A, B) \
+  _mm_mask_rcp28_round_ss((S), (M), (A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_maskz_rcp28_ss(M, A, B) \
+  _mm_maskz_rcp28_round_ss((M), (A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_rcp28_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_rcp28sd_round_mask((__v2df)(__m128d)(A), \
+                                              (__v2df)(__m128d)(B), \
+                                              (__v2df)_mm_setzero_pd(), \
+                                              (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_rcp28_round_sd(S, M, A, B, R) \
+  ((__m128d)__builtin_ia32_rcp28sd_round_mask((__v2df)(__m128d)(A), \
+                                              (__v2df)(__m128d)(B), \
+                                              (__v2df)(__m128d)(S), \
+                                              (__mmask8)(M), (int)(R)))
+
+#define _mm_maskz_rcp28_round_sd(M, A, B, R) \
+  ((__m128d)__builtin_ia32_rcp28sd_round_mask((__v2df)(__m128d)(A), \
+                                              (__v2df)(__m128d)(B), \
+                                              (__v2df)_mm_setzero_pd(), \
+                                              (__mmask8)(M), (int)(R)))
+
+#define _mm_rcp28_sd(A, B) \
+  _mm_rcp28_round_sd((A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_mask_rcp28_sd(S, M, A, B) \
+  _mm_mask_rcp28_round_sd((S), (M), (A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_maskz_rcp28_sd(M, A, B) \
+  _mm_maskz_rcp28_round_sd((M), (A), (B), _MM_FROUND_CUR_DIRECTION)
+
+#endif /* __AVX512ERINTRIN_H */
diff --git a/third_party/intel/clang/avx512fintrin.h b/third_party/intel/clang/avx512fintrin.h
new file mode 100644
index 000000000..4f172c74b
--- /dev/null
+++ b/third_party/intel/clang/avx512fintrin.h
@@ -0,0 +1,9779 @@
+/*===---- avx512fintrin.h - AVX512F intrinsics -----------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512fintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512FINTRIN_H
+#define __AVX512FINTRIN_H
+
+typedef char __v64qi __attribute__((__vector_size__(64)));
+typedef short __v32hi __attribute__((__vector_size__(64)));
+typedef double __v8df __attribute__((__vector_size__(64)));
+typedef float __v16sf __attribute__((__vector_size__(64)));
+typedef long long __v8di __attribute__((__vector_size__(64)));
+typedef int __v16si __attribute__((__vector_size__(64)));
+
+/* Unsigned types */
+typedef unsigned char __v64qu __attribute__((__vector_size__(64)));
+typedef unsigned short __v32hu __attribute__((__vector_size__(64)));
+typedef unsigned long long __v8du __attribute__((__vector_size__(64)));
+typedef unsigned int __v16su __attribute__((__vector_size__(64)));
+
+/* We need an explicitly signed variant for char. Note that this shouldn't
+ * appear in the interface though. */
+typedef signed char __v64qs __attribute__((__vector_size__(64)));
+
+typedef float __m512 __attribute__((__vector_size__(64), __aligned__(64)));
+typedef double __m512d __attribute__((__vector_size__(64), __aligned__(64)));
+typedef long long __m512i __attribute__((__vector_size__(64), __aligned__(64)));
+
+typedef float __m512_u __attribute__((__vector_size__(64), __aligned__(1)));
+typedef double __m512d_u __attribute__((__vector_size__(64), __aligned__(1)));
+typedef long long __m512i_u __attribute__((__vector_size__(64), __aligned__(1)));
+
+typedef unsigned char __mmask8;
+typedef unsigned short __mmask16;
+
+/* Rounding mode macros.  */
+#define _MM_FROUND_TO_NEAREST_INT   0x00
+#define _MM_FROUND_TO_NEG_INF       0x01
+#define _MM_FROUND_TO_POS_INF       0x02
+#define _MM_FROUND_TO_ZERO          0x03
+#define _MM_FROUND_CUR_DIRECTION    0x04
+
+/* Constants for integer comparison predicates */
+typedef enum {
+    _MM_CMPINT_EQ,      /* Equal */
+    _MM_CMPINT_LT,      /* Less than */
+    _MM_CMPINT_LE,      /* Less than or Equal */
+    _MM_CMPINT_UNUSED,
+    _MM_CMPINT_NE,      /* Not Equal */
+    _MM_CMPINT_NLT,     /* Not Less than */
+#define _MM_CMPINT_GE   _MM_CMPINT_NLT  /* Greater than or Equal */
+    _MM_CMPINT_NLE      /* Not Less than or Equal */
+#define _MM_CMPINT_GT   _MM_CMPINT_NLE  /* Greater than */
+} _MM_CMPINT_ENUM;
+
+typedef enum
+{
+  _MM_PERM_AAAA = 0x00, _MM_PERM_AAAB = 0x01, _MM_PERM_AAAC = 0x02,
+  _MM_PERM_AAAD = 0x03, _MM_PERM_AABA = 0x04, _MM_PERM_AABB = 0x05,
+  _MM_PERM_AABC = 0x06, _MM_PERM_AABD = 0x07, _MM_PERM_AACA = 0x08,
+  _MM_PERM_AACB = 0x09, _MM_PERM_AACC = 0x0A, _MM_PERM_AACD = 0x0B,
+  _MM_PERM_AADA = 0x0C, _MM_PERM_AADB = 0x0D, _MM_PERM_AADC = 0x0E,
+  _MM_PERM_AADD = 0x0F, _MM_PERM_ABAA = 0x10, _MM_PERM_ABAB = 0x11,
+  _MM_PERM_ABAC = 0x12, _MM_PERM_ABAD = 0x13, _MM_PERM_ABBA = 0x14,
+  _MM_PERM_ABBB = 0x15, _MM_PERM_ABBC = 0x16, _MM_PERM_ABBD = 0x17,
+  _MM_PERM_ABCA = 0x18, _MM_PERM_ABCB = 0x19, _MM_PERM_ABCC = 0x1A,
+  _MM_PERM_ABCD = 0x1B, _MM_PERM_ABDA = 0x1C, _MM_PERM_ABDB = 0x1D,
+  _MM_PERM_ABDC = 0x1E, _MM_PERM_ABDD = 0x1F, _MM_PERM_ACAA = 0x20,
+  _MM_PERM_ACAB = 0x21, _MM_PERM_ACAC = 0x22, _MM_PERM_ACAD = 0x23,
+  _MM_PERM_ACBA = 0x24, _MM_PERM_ACBB = 0x25, _MM_PERM_ACBC = 0x26,
+  _MM_PERM_ACBD = 0x27, _MM_PERM_ACCA = 0x28, _MM_PERM_ACCB = 0x29,
+  _MM_PERM_ACCC = 0x2A, _MM_PERM_ACCD = 0x2B, _MM_PERM_ACDA = 0x2C,
+  _MM_PERM_ACDB = 0x2D, _MM_PERM_ACDC = 0x2E, _MM_PERM_ACDD = 0x2F,
+  _MM_PERM_ADAA = 0x30, _MM_PERM_ADAB = 0x31, _MM_PERM_ADAC = 0x32,
+  _MM_PERM_ADAD = 0x33, _MM_PERM_ADBA = 0x34, _MM_PERM_ADBB = 0x35,
+  _MM_PERM_ADBC = 0x36, _MM_PERM_ADBD = 0x37, _MM_PERM_ADCA = 0x38,
+  _MM_PERM_ADCB = 0x39, _MM_PERM_ADCC = 0x3A, _MM_PERM_ADCD = 0x3B,
+  _MM_PERM_ADDA = 0x3C, _MM_PERM_ADDB = 0x3D, _MM_PERM_ADDC = 0x3E,
+  _MM_PERM_ADDD = 0x3F, _MM_PERM_BAAA = 0x40, _MM_PERM_BAAB = 0x41,
+  _MM_PERM_BAAC = 0x42, _MM_PERM_BAAD = 0x43, _MM_PERM_BABA = 0x44,
+  _MM_PERM_BABB = 0x45, _MM_PERM_BABC = 0x46, _MM_PERM_BABD = 0x47,
+  _MM_PERM_BACA = 0x48, _MM_PERM_BACB = 0x49, _MM_PERM_BACC = 0x4A,
+  _MM_PERM_BACD = 0x4B, _MM_PERM_BADA = 0x4C, _MM_PERM_BADB = 0x4D,
+  _MM_PERM_BADC = 0x4E, _MM_PERM_BADD = 0x4F, _MM_PERM_BBAA = 0x50,
+  _MM_PERM_BBAB = 0x51, _MM_PERM_BBAC = 0x52, _MM_PERM_BBAD = 0x53,
+  _MM_PERM_BBBA = 0x54, _MM_PERM_BBBB = 0x55, _MM_PERM_BBBC = 0x56,
+  _MM_PERM_BBBD = 0x57, _MM_PERM_BBCA = 0x58, _MM_PERM_BBCB = 0x59,
+  _MM_PERM_BBCC = 0x5A, _MM_PERM_BBCD = 0x5B, _MM_PERM_BBDA = 0x5C,
+  _MM_PERM_BBDB = 0x5D, _MM_PERM_BBDC = 0x5E, _MM_PERM_BBDD = 0x5F,
+  _MM_PERM_BCAA = 0x60, _MM_PERM_BCAB = 0x61, _MM_PERM_BCAC = 0x62,
+  _MM_PERM_BCAD = 0x63, _MM_PERM_BCBA = 0x64, _MM_PERM_BCBB = 0x65,
+  _MM_PERM_BCBC = 0x66, _MM_PERM_BCBD = 0x67, _MM_PERM_BCCA = 0x68,
+  _MM_PERM_BCCB = 0x69, _MM_PERM_BCCC = 0x6A, _MM_PERM_BCCD = 0x6B,
+  _MM_PERM_BCDA = 0x6C, _MM_PERM_BCDB = 0x6D, _MM_PERM_BCDC = 0x6E,
+  _MM_PERM_BCDD = 0x6F, _MM_PERM_BDAA = 0x70, _MM_PERM_BDAB = 0x71,
+  _MM_PERM_BDAC = 0x72, _MM_PERM_BDAD = 0x73, _MM_PERM_BDBA = 0x74,
+  _MM_PERM_BDBB = 0x75, _MM_PERM_BDBC = 0x76, _MM_PERM_BDBD = 0x77,
+  _MM_PERM_BDCA = 0x78, _MM_PERM_BDCB = 0x79, _MM_PERM_BDCC = 0x7A,
+  _MM_PERM_BDCD = 0x7B, _MM_PERM_BDDA = 0x7C, _MM_PERM_BDDB = 0x7D,
+  _MM_PERM_BDDC = 0x7E, _MM_PERM_BDDD = 0x7F, _MM_PERM_CAAA = 0x80,
+  _MM_PERM_CAAB = 0x81, _MM_PERM_CAAC = 0x82, _MM_PERM_CAAD = 0x83,
+  _MM_PERM_CABA = 0x84, _MM_PERM_CABB = 0x85, _MM_PERM_CABC = 0x86,
+  _MM_PERM_CABD = 0x87, _MM_PERM_CACA = 0x88, _MM_PERM_CACB = 0x89,
+  _MM_PERM_CACC = 0x8A, _MM_PERM_CACD = 0x8B, _MM_PERM_CADA = 0x8C,
+  _MM_PERM_CADB = 0x8D, _MM_PERM_CADC = 0x8E, _MM_PERM_CADD = 0x8F,
+  _MM_PERM_CBAA = 0x90, _MM_PERM_CBAB = 0x91, _MM_PERM_CBAC = 0x92,
+  _MM_PERM_CBAD = 0x93, _MM_PERM_CBBA = 0x94, _MM_PERM_CBBB = 0x95,
+  _MM_PERM_CBBC = 0x96, _MM_PERM_CBBD = 0x97, _MM_PERM_CBCA = 0x98,
+  _MM_PERM_CBCB = 0x99, _MM_PERM_CBCC = 0x9A, _MM_PERM_CBCD = 0x9B,
+  _MM_PERM_CBDA = 0x9C, _MM_PERM_CBDB = 0x9D, _MM_PERM_CBDC = 0x9E,
+  _MM_PERM_CBDD = 0x9F, _MM_PERM_CCAA = 0xA0, _MM_PERM_CCAB = 0xA1,
+  _MM_PERM_CCAC = 0xA2, _MM_PERM_CCAD = 0xA3, _MM_PERM_CCBA = 0xA4,
+  _MM_PERM_CCBB = 0xA5, _MM_PERM_CCBC = 0xA6, _MM_PERM_CCBD = 0xA7,
+  _MM_PERM_CCCA = 0xA8, _MM_PERM_CCCB = 0xA9, _MM_PERM_CCCC = 0xAA,
+  _MM_PERM_CCCD = 0xAB, _MM_PERM_CCDA = 0xAC, _MM_PERM_CCDB = 0xAD,
+  _MM_PERM_CCDC = 0xAE, _MM_PERM_CCDD = 0xAF, _MM_PERM_CDAA = 0xB0,
+  _MM_PERM_CDAB = 0xB1, _MM_PERM_CDAC = 0xB2, _MM_PERM_CDAD = 0xB3,
+  _MM_PERM_CDBA = 0xB4, _MM_PERM_CDBB = 0xB5, _MM_PERM_CDBC = 0xB6,
+  _MM_PERM_CDBD = 0xB7, _MM_PERM_CDCA = 0xB8, _MM_PERM_CDCB = 0xB9,
+  _MM_PERM_CDCC = 0xBA, _MM_PERM_CDCD = 0xBB, _MM_PERM_CDDA = 0xBC,
+  _MM_PERM_CDDB = 0xBD, _MM_PERM_CDDC = 0xBE, _MM_PERM_CDDD = 0xBF,
+  _MM_PERM_DAAA = 0xC0, _MM_PERM_DAAB = 0xC1, _MM_PERM_DAAC = 0xC2,
+  _MM_PERM_DAAD = 0xC3, _MM_PERM_DABA = 0xC4, _MM_PERM_DABB = 0xC5,
+  _MM_PERM_DABC = 0xC6, _MM_PERM_DABD = 0xC7, _MM_PERM_DACA = 0xC8,
+  _MM_PERM_DACB = 0xC9, _MM_PERM_DACC = 0xCA, _MM_PERM_DACD = 0xCB,
+  _MM_PERM_DADA = 0xCC, _MM_PERM_DADB = 0xCD, _MM_PERM_DADC = 0xCE,
+  _MM_PERM_DADD = 0xCF, _MM_PERM_DBAA = 0xD0, _MM_PERM_DBAB = 0xD1,
+  _MM_PERM_DBAC = 0xD2, _MM_PERM_DBAD = 0xD3, _MM_PERM_DBBA = 0xD4,
+  _MM_PERM_DBBB = 0xD5, _MM_PERM_DBBC = 0xD6, _MM_PERM_DBBD = 0xD7,
+  _MM_PERM_DBCA = 0xD8, _MM_PERM_DBCB = 0xD9, _MM_PERM_DBCC = 0xDA,
+  _MM_PERM_DBCD = 0xDB, _MM_PERM_DBDA = 0xDC, _MM_PERM_DBDB = 0xDD,
+  _MM_PERM_DBDC = 0xDE, _MM_PERM_DBDD = 0xDF, _MM_PERM_DCAA = 0xE0,
+  _MM_PERM_DCAB = 0xE1, _MM_PERM_DCAC = 0xE2, _MM_PERM_DCAD = 0xE3,
+  _MM_PERM_DCBA = 0xE4, _MM_PERM_DCBB = 0xE5, _MM_PERM_DCBC = 0xE6,
+  _MM_PERM_DCBD = 0xE7, _MM_PERM_DCCA = 0xE8, _MM_PERM_DCCB = 0xE9,
+  _MM_PERM_DCCC = 0xEA, _MM_PERM_DCCD = 0xEB, _MM_PERM_DCDA = 0xEC,
+  _MM_PERM_DCDB = 0xED, _MM_PERM_DCDC = 0xEE, _MM_PERM_DCDD = 0xEF,
+  _MM_PERM_DDAA = 0xF0, _MM_PERM_DDAB = 0xF1, _MM_PERM_DDAC = 0xF2,
+  _MM_PERM_DDAD = 0xF3, _MM_PERM_DDBA = 0xF4, _MM_PERM_DDBB = 0xF5,
+  _MM_PERM_DDBC = 0xF6, _MM_PERM_DDBD = 0xF7, _MM_PERM_DDCA = 0xF8,
+  _MM_PERM_DDCB = 0xF9, _MM_PERM_DDCC = 0xFA, _MM_PERM_DDCD = 0xFB,
+  _MM_PERM_DDDA = 0xFC, _MM_PERM_DDDB = 0xFD, _MM_PERM_DDDC = 0xFE,
+  _MM_PERM_DDDD = 0xFF
+} _MM_PERM_ENUM;
+
+typedef enum
+{
+  _MM_MANT_NORM_1_2,    /* interval [1, 2)      */
+  _MM_MANT_NORM_p5_2,   /* interval [0.5, 2)    */
+  _MM_MANT_NORM_p5_1,   /* interval [0.5, 1)    */
+  _MM_MANT_NORM_p75_1p5   /* interval [0.75, 1.5) */
+} _MM_MANTISSA_NORM_ENUM;
+
+typedef enum
+{
+  _MM_MANT_SIGN_src,    /* sign = sign(SRC)     */
+  _MM_MANT_SIGN_zero,   /* sign = 0             */
+  _MM_MANT_SIGN_nan   /* DEST = NaN if sign(SRC) = 1 */
+} _MM_MANTISSA_SIGN_ENUM;
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS512 __attribute__((__always_inline__, __nodebug__, __target__("avx512f,evex512"), __min_vector_width__(512)))
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512f,no-evex512"), __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512f,no-evex512")))
+
+/* Create vectors with repeated elements */
+
+static  __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_setzero_si512(void)
+{
+  return __extension__ (__m512i)(__v8di){ 0, 0, 0, 0, 0, 0, 0, 0 };
+}
+
+#define _mm512_setzero_epi32 _mm512_setzero_si512
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_undefined_pd(void)
+{
+  return (__m512d)__builtin_ia32_undef512();
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_undefined(void)
+{
+  return (__m512)__builtin_ia32_undef512();
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_undefined_ps(void)
+{
+  return (__m512)__builtin_ia32_undef512();
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_undefined_epi32(void)
+{
+  return (__m512i)__builtin_ia32_undef512();
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_broadcastd_epi32 (__m128i __A)
+{
+  return (__m512i)__builtin_shufflevector((__v4si) __A, (__v4si) __A,
+                                          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcastd_epi32 (__m512i __O, __mmask16 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__M,
+                                             (__v16si) _mm512_broadcastd_epi32(__A),
+                                             (__v16si) __O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcastd_epi32 (__mmask16 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__M,
+                                             (__v16si) _mm512_broadcastd_epi32(__A),
+                                             (__v16si) _mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_broadcastq_epi64 (__m128i __A)
+{
+  return (__m512i)__builtin_shufflevector((__v2di) __A, (__v2di) __A,
+                                          0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcastq_epi64 (__m512i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__M,
+                                             (__v8di) _mm512_broadcastq_epi64(__A),
+                                             (__v8di) __O);
+
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcastq_epi64 (__mmask8 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__M,
+                                             (__v8di) _mm512_broadcastq_epi64(__A),
+                                             (__v8di) _mm512_setzero_si512());
+}
+
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_setzero_ps(void)
+{
+  return __extension__ (__m512){ 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
+                                 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+}
+
+#define _mm512_setzero _mm512_setzero_ps
+
+static  __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_setzero_pd(void)
+{
+  return __extension__ (__m512d){ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_set1_ps(float __w)
+{
+  return __extension__ (__m512){ __w, __w, __w, __w, __w, __w, __w, __w,
+                                 __w, __w, __w, __w, __w, __w, __w, __w  };
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_set1_pd(double __w)
+{
+  return __extension__ (__m512d){ __w, __w, __w, __w, __w, __w, __w, __w };
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_set1_epi8(char __w)
+{
+  return __extension__ (__m512i)(__v64qi){
+    __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w, __w, __w  };
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_set1_epi16(short __w)
+{
+  return __extension__ (__m512i)(__v32hi){
+    __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w, __w, __w,
+    __w, __w, __w, __w, __w, __w, __w, __w };
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_set1_epi32(int __s)
+{
+  return __extension__ (__m512i)(__v16si){
+    __s, __s, __s, __s, __s, __s, __s, __s,
+    __s, __s, __s, __s, __s, __s, __s, __s };
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_set1_epi32(__mmask16 __M, int __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__M,
+                                             (__v16si)_mm512_set1_epi32(__A),
+                                             (__v16si)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_set1_epi64(long long __d)
+{
+  return __extension__(__m512i)(__v8di){ __d, __d, __d, __d, __d, __d, __d, __d };
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_set1_epi64(__mmask8 __M, long long __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__M,
+                                             (__v8di)_mm512_set1_epi64(__A),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_broadcastss_ps(__m128 __A)
+{
+  return (__m512)__builtin_shufflevector((__v4sf) __A, (__v4sf) __A,
+                                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_set4_epi32 (int __A, int __B, int __C, int __D)
+{
+  return __extension__ (__m512i)(__v16si)
+   { __D, __C, __B, __A, __D, __C, __B, __A,
+     __D, __C, __B, __A, __D, __C, __B, __A };
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_set4_epi64 (long long __A, long long __B, long long __C,
+       long long __D)
+{
+  return __extension__ (__m512i) (__v8di)
+   { __D, __C, __B, __A, __D, __C, __B, __A };
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_set4_pd (double __A, double __B, double __C, double __D)
+{
+  return __extension__ (__m512d)
+   { __D, __C, __B, __A, __D, __C, __B, __A };
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_set4_ps (float __A, float __B, float __C, float __D)
+{
+  return __extension__ (__m512)
+   { __D, __C, __B, __A, __D, __C, __B, __A,
+     __D, __C, __B, __A, __D, __C, __B, __A };
+}
+
+#define _mm512_setr4_epi32(e0,e1,e2,e3)               \
+  _mm512_set4_epi32((e3),(e2),(e1),(e0))
+
+#define _mm512_setr4_epi64(e0,e1,e2,e3)               \
+  _mm512_set4_epi64((e3),(e2),(e1),(e0))
+
+#define _mm512_setr4_pd(e0,e1,e2,e3)                \
+  _mm512_set4_pd((e3),(e2),(e1),(e0))
+
+#define _mm512_setr4_ps(e0,e1,e2,e3)                \
+  _mm512_set4_ps((e3),(e2),(e1),(e0))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_broadcastsd_pd(__m128d __A)
+{
+  return (__m512d)__builtin_shufflevector((__v2df) __A, (__v2df) __A,
+                                          0, 0, 0, 0, 0, 0, 0, 0);
+}
+
+/* Cast between vector types */
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_castpd256_pd512(__m256d __a)
+{
+  return __builtin_shufflevector(__a, __builtin_nondeterministic_value(__a), 0,
+                                 1, 2, 3, 4, 5, 6, 7);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_castps256_ps512(__m256 __a)
+{
+  return __builtin_shufflevector(__a, __builtin_nondeterministic_value(__a), 0,
+                                 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+
+static __inline __m128d __DEFAULT_FN_ATTRS512
+_mm512_castpd512_pd128(__m512d __a)
+{
+  return __builtin_shufflevector(__a, __a, 0, 1);
+}
+
+static __inline __m256d __DEFAULT_FN_ATTRS512
+_mm512_castpd512_pd256 (__m512d __A)
+{
+  return __builtin_shufflevector(__A, __A, 0, 1, 2, 3);
+}
+
+static __inline __m128 __DEFAULT_FN_ATTRS512
+_mm512_castps512_ps128(__m512 __a)
+{
+  return __builtin_shufflevector(__a, __a, 0, 1, 2, 3);
+}
+
+static __inline __m256 __DEFAULT_FN_ATTRS512
+_mm512_castps512_ps256 (__m512 __A)
+{
+  return __builtin_shufflevector(__A, __A, 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_castpd_ps (__m512d __A)
+{
+  return (__m512) (__A);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_castpd_si512 (__m512d __A)
+{
+  return (__m512i) (__A);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_castpd128_pd512 (__m128d __A)
+{
+  __m256d __B = __builtin_nondeterministic_value(__B);
+  return __builtin_shufflevector(
+      __builtin_shufflevector(__A, __builtin_nondeterministic_value(__A), 0, 1, 2, 3),
+      __B, 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_castps_pd (__m512 __A)
+{
+  return (__m512d) (__A);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_castps_si512 (__m512 __A)
+{
+  return (__m512i) (__A);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_castps128_ps512 (__m128 __A)
+{
+  __m256 __B = __builtin_nondeterministic_value(__B);
+  return __builtin_shufflevector(
+      __builtin_shufflevector(__A, __builtin_nondeterministic_value(__A), 0, 1, 2, 3, 4, 5, 6, 7),
+      __B, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_castsi128_si512 (__m128i __A)
+{
+  __m256i __B = __builtin_nondeterministic_value(__B);
+  return __builtin_shufflevector(
+      __builtin_shufflevector(__A, __builtin_nondeterministic_value(__A), 0, 1, 2, 3),
+      __B, 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_castsi256_si512 (__m256i __A)
+{
+   return  __builtin_shufflevector( __A, __builtin_nondeterministic_value(__A), 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_castsi512_ps (__m512i __A)
+{
+  return (__m512) (__A);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_castsi512_pd (__m512i __A)
+{
+  return (__m512d) (__A);
+}
+
+static __inline __m128i __DEFAULT_FN_ATTRS512
+_mm512_castsi512_si128 (__m512i __A)
+{
+  return (__m128i)__builtin_shufflevector(__A, __A , 0, 1);
+}
+
+static __inline __m256i __DEFAULT_FN_ATTRS512
+_mm512_castsi512_si256 (__m512i __A)
+{
+  return (__m256i)__builtin_shufflevector(__A, __A , 0, 1, 2, 3);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_int2mask(int __a)
+{
+  return (__mmask16)__a;
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm512_mask2int(__mmask16 __a)
+{
+  return (int)__a;
+}
+
+/// Constructs a 512-bit floating-point vector of [8 x double] from a
+///    128-bit floating-point vector of [2 x double]. The lower 128 bits
+///    contain the value of the source vector. The upper 384 bits are set
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 512-bit floating-point vector of [8 x double]. The lower 128 bits
+///    contain the value of the parameter. The upper 384 bits are set to zero.
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_zextpd128_pd512(__m128d __a)
+{
+  return __builtin_shufflevector((__v2df)__a, (__v2df)_mm_setzero_pd(), 0, 1, 2, 3, 2, 3, 2, 3);
+}
+
+/// Constructs a 512-bit floating-point vector of [8 x double] from a
+///    256-bit floating-point vector of [4 x double]. The lower 256 bits
+///    contain the value of the source vector. The upper 256 bits are set
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \returns A 512-bit floating-point vector of [8 x double]. The lower 256 bits
+///    contain the value of the parameter. The upper 256 bits are set to zero.
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_zextpd256_pd512(__m256d __a)
+{
+  return __builtin_shufflevector((__v4df)__a, (__v4df)_mm256_setzero_pd(), 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+/// Constructs a 512-bit floating-point vector of [16 x float] from a
+///    128-bit floating-point vector of [4 x float]. The lower 128 bits contain
+///    the value of the source vector. The upper 384 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 512-bit floating-point vector of [16 x float]. The lower 128 bits
+///    contain the value of the parameter. The upper 384 bits are set to zero.
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_zextps128_ps512(__m128 __a)
+{
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)_mm_setzero_ps(), 0, 1, 2, 3, 4, 5, 6, 7, 4, 5, 6, 7, 4, 5, 6, 7);
+}
+
+/// Constructs a 512-bit floating-point vector of [16 x float] from a
+///    256-bit floating-point vector of [8 x float]. The lower 256 bits contain
+///    the value of the source vector. The upper 256 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \returns A 512-bit floating-point vector of [16 x float]. The lower 256 bits
+///    contain the value of the parameter. The upper 256 bits are set to zero.
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_zextps256_ps512(__m256 __a)
+{
+  return __builtin_shufflevector((__v8sf)__a, (__v8sf)_mm256_setzero_ps(), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+
+/// Constructs a 512-bit integer vector from a 128-bit integer vector.
+///    The lower 128 bits contain the value of the source vector. The upper
+///    384 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \returns A 512-bit integer vector. The lower 128 bits contain the value of
+///    the parameter. The upper 384 bits are set to zero.
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_zextsi128_si512(__m128i __a)
+{
+  return __builtin_shufflevector((__v2di)__a, (__v2di)_mm_setzero_si128(), 0, 1, 2, 3, 2, 3, 2, 3);
+}
+
+/// Constructs a 512-bit integer vector from a 256-bit integer vector.
+///    The lower 256 bits contain the value of the source vector. The upper
+///    256 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \returns A 512-bit integer vector. The lower 256 bits contain the value of
+///    the parameter. The upper 256 bits are set to zero.
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_zextsi256_si512(__m256i __a)
+{
+  return __builtin_shufflevector((__v4di)__a, (__v4di)_mm256_setzero_si256(), 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+/* Bitwise operators */
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_and_epi32(__m512i __a, __m512i __b)
+{
+  return (__m512i)((__v16su)__a & (__v16su)__b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_and_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__k,
+                (__v16si) _mm512_and_epi32(__a, __b),
+                (__v16si) __src);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_and_epi32(__mmask16 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i) _mm512_mask_and_epi32(_mm512_setzero_si512 (),
+                                         __k, __a, __b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_and_epi64(__m512i __a, __m512i __b)
+{
+  return (__m512i)((__v8du)__a & (__v8du)__b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_and_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b)
+{
+    return (__m512i) __builtin_ia32_selectq_512 ((__mmask8) __k,
+                (__v8di) _mm512_and_epi64(__a, __b),
+                (__v8di) __src);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_and_epi64(__mmask8 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i) _mm512_mask_and_epi64(_mm512_setzero_si512 (),
+                                         __k, __a, __b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_andnot_si512 (__m512i __A, __m512i __B)
+{
+  return (__m512i)(~(__v8du)__A & (__v8du)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_andnot_epi32 (__m512i __A, __m512i __B)
+{
+  return (__m512i)(~(__v16su)__A & (__v16su)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_andnot_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                         (__v16si)_mm512_andnot_epi32(__A, __B),
+                                         (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_andnot_epi32(__mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)_mm512_mask_andnot_epi32(_mm512_setzero_si512(),
+                                           __U, __A, __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_andnot_epi64(__m512i __A, __m512i __B)
+{
+  return (__m512i)(~(__v8du)__A & (__v8du)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_andnot_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                          (__v8di)_mm512_andnot_epi64(__A, __B),
+                                          (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_andnot_epi64(__mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)_mm512_mask_andnot_epi64(_mm512_setzero_si512(),
+                                           __U, __A, __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_or_epi32(__m512i __a, __m512i __b)
+{
+  return (__m512i)((__v16su)__a | (__v16su)__b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_or_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__k,
+                                             (__v16si)_mm512_or_epi32(__a, __b),
+                                             (__v16si)__src);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_or_epi32(__mmask16 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i)_mm512_mask_or_epi32(_mm512_setzero_si512(), __k, __a, __b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_or_epi64(__m512i __a, __m512i __b)
+{
+  return (__m512i)((__v8du)__a | (__v8du)__b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_or_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__k,
+                                             (__v8di)_mm512_or_epi64(__a, __b),
+                                             (__v8di)__src);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_or_epi64(__mmask8 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i)_mm512_mask_or_epi64(_mm512_setzero_si512(), __k, __a, __b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_xor_epi32(__m512i __a, __m512i __b)
+{
+  return (__m512i)((__v16su)__a ^ (__v16su)__b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_xor_epi32(__m512i __src, __mmask16 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__k,
+                                            (__v16si)_mm512_xor_epi32(__a, __b),
+                                            (__v16si)__src);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_xor_epi32(__mmask16 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i)_mm512_mask_xor_epi32(_mm512_setzero_si512(), __k, __a, __b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_xor_epi64(__m512i __a, __m512i __b)
+{
+  return (__m512i)((__v8du)__a ^ (__v8du)__b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_xor_epi64(__m512i __src, __mmask8 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__k,
+                                             (__v8di)_mm512_xor_epi64(__a, __b),
+                                             (__v8di)__src);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_xor_epi64(__mmask8 __k, __m512i __a, __m512i __b)
+{
+  return (__m512i)_mm512_mask_xor_epi64(_mm512_setzero_si512(), __k, __a, __b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_and_si512(__m512i __a, __m512i __b)
+{
+  return (__m512i)((__v8du)__a & (__v8du)__b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_or_si512(__m512i __a, __m512i __b)
+{
+  return (__m512i)((__v8du)__a | (__v8du)__b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_xor_si512(__m512i __a, __m512i __b)
+{
+  return (__m512i)((__v8du)__a ^ (__v8du)__b);
+}
+
+/* Arithmetic */
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_add_pd(__m512d __a, __m512d __b)
+{
+  return (__m512d)((__v8df)__a + (__v8df)__b);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_add_ps(__m512 __a, __m512 __b)
+{
+  return (__m512)((__v16sf)__a + (__v16sf)__b);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_mul_pd(__m512d __a, __m512d __b)
+{
+  return (__m512d)((__v8df)__a * (__v8df)__b);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_mul_ps(__m512 __a, __m512 __b)
+{
+  return (__m512)((__v16sf)__a * (__v16sf)__b);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_sub_pd(__m512d __a, __m512d __b)
+{
+  return (__m512d)((__v8df)__a - (__v8df)__b);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_sub_ps(__m512 __a, __m512 __b)
+{
+  return (__m512)((__v16sf)__a - (__v16sf)__b);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_add_epi64 (__m512i __A, __m512i __B)
+{
+  return (__m512i) ((__v8du) __A + (__v8du) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_add_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_add_epi64(__A, __B),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_add_epi64(__mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_add_epi64(__A, __B),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sub_epi64 (__m512i __A, __m512i __B)
+{
+  return (__m512i) ((__v8du) __A - (__v8du) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sub_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_sub_epi64(__A, __B),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sub_epi64(__mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_sub_epi64(__A, __B),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_add_epi32 (__m512i __A, __m512i __B)
+{
+  return (__m512i) ((__v16su) __A + (__v16su) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_add_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                             (__v16si)_mm512_add_epi32(__A, __B),
+                                             (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_add_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                             (__v16si)_mm512_add_epi32(__A, __B),
+                                             (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sub_epi32 (__m512i __A, __m512i __B)
+{
+  return (__m512i) ((__v16su) __A - (__v16su) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sub_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                             (__v16si)_mm512_sub_epi32(__A, __B),
+                                             (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sub_epi32(__mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                             (__v16si)_mm512_sub_epi32(__A, __B),
+                                             (__v16si)_mm512_setzero_si512());
+}
+
+#define _mm512_max_round_pd(A, B, R) \
+  ((__m512d)__builtin_ia32_maxpd512((__v8df)(__m512d)(A), \
+                                    (__v8df)(__m512d)(B), (int)(R)))
+
+#define _mm512_mask_max_round_pd(W, U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_max_round_pd((A), (B), (R)), \
+                                   (__v8df)(W)))
+
+#define _mm512_maskz_max_round_pd(U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_max_round_pd((A), (B), (R)), \
+                                   (__v8df)_mm512_setzero_pd()))
+
+static  __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_max_pd(__m512d __A, __m512d __B)
+{
+  return (__m512d) __builtin_ia32_maxpd512((__v8df) __A, (__v8df) __B,
+                                           _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_max_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__U,
+                                              (__v8df)_mm512_max_pd(__A, __B),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_pd (__mmask8 __U, __m512d __A, __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__U,
+                                              (__v8df)_mm512_max_pd(__A, __B),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+#define _mm512_max_round_ps(A, B, R) \
+  ((__m512)__builtin_ia32_maxps512((__v16sf)(__m512)(A), \
+                                   (__v16sf)(__m512)(B), (int)(R)))
+
+#define _mm512_mask_max_round_ps(W, U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_max_round_ps((A), (B), (R)), \
+                                  (__v16sf)(W)))
+
+#define _mm512_maskz_max_round_ps(U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_max_round_ps((A), (B), (R)), \
+                                  (__v16sf)_mm512_setzero_ps()))
+
+static  __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_max_ps(__m512 __A, __m512 __B)
+{
+  return (__m512) __builtin_ia32_maxps512((__v16sf) __A, (__v16sf) __B,
+                                          _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_max_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512(__U,
+                                             (__v16sf)_mm512_max_ps(__A, __B),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_ps (__mmask16 __U, __m512 __A, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512(__U,
+                                             (__v16sf)_mm512_max_ps(__A, __B),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_max_ss(__m128 __W, __mmask8 __U,__m128 __A, __m128 __B) {
+  return (__m128) __builtin_ia32_maxss_round_mask ((__v4sf) __A,
+                (__v4sf) __B,
+                (__v4sf) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_max_ss(__mmask8 __U,__m128 __A, __m128 __B) {
+  return (__m128) __builtin_ia32_maxss_round_mask ((__v4sf) __A,
+                (__v4sf) __B,
+                (__v4sf)  _mm_setzero_ps (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_max_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_maxss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_max_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_maxss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)(__m128)(W), (__mmask8)(U), \
+                                           (int)(R)))
+
+#define _mm_maskz_max_round_ss(U, A, B, R) \
+  ((__m128)__builtin_ia32_maxss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_max_sd(__m128d __W, __mmask8 __U,__m128d __A, __m128d __B) {
+  return (__m128d) __builtin_ia32_maxsd_round_mask ((__v2df) __A,
+                (__v2df) __B,
+                (__v2df) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_max_sd(__mmask8 __U,__m128d __A, __m128d __B) {
+  return (__m128d) __builtin_ia32_maxsd_round_mask ((__v2df) __A,
+                (__v2df) __B,
+                (__v2df)  _mm_setzero_pd (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_max_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_maxsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_max_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_maxsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)(__m128d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_max_round_sd(U, A, B, R) \
+  ((__m128d)__builtin_ia32_maxsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline __m512i
+__DEFAULT_FN_ATTRS512
+_mm512_max_epi32(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_max((__v16si)__A, (__v16si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_max_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                            (__v16si)_mm512_max_epi32(__A, __B),
+                                            (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                            (__v16si)_mm512_max_epi32(__A, __B),
+                                            (__v16si)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_max_epu32(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_max((__v16su)__A, (__v16su)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_max_epu32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                            (__v16si)_mm512_max_epu32(__A, __B),
+                                            (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_epu32 (__mmask16 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                            (__v16si)_mm512_max_epu32(__A, __B),
+                                            (__v16si)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_max_epi64(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_max((__v8di)__A, (__v8di)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_max_epi64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_max_epi64(__A, __B),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_epi64 (__mmask8 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_max_epi64(__A, __B),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_max_epu64(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_max((__v8du)__A, (__v8du)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_max_epu64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_max_epu64(__A, __B),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_epu64 (__mmask8 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_max_epu64(__A, __B),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+#define _mm512_min_round_pd(A, B, R) \
+  ((__m512d)__builtin_ia32_minpd512((__v8df)(__m512d)(A), \
+                                    (__v8df)(__m512d)(B), (int)(R)))
+
+#define _mm512_mask_min_round_pd(W, U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_min_round_pd((A), (B), (R)), \
+                                   (__v8df)(W)))
+
+#define _mm512_maskz_min_round_pd(U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_min_round_pd((A), (B), (R)), \
+                                   (__v8df)_mm512_setzero_pd()))
+
+static  __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_min_pd(__m512d __A, __m512d __B)
+{
+  return (__m512d) __builtin_ia32_minpd512((__v8df) __A, (__v8df) __B,
+                                           _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_min_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__U,
+                                              (__v8df)_mm512_min_pd(__A, __B),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_pd (__mmask8 __U, __m512d __A, __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__U,
+                                              (__v8df)_mm512_min_pd(__A, __B),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+#define _mm512_min_round_ps(A, B, R) \
+  ((__m512)__builtin_ia32_minps512((__v16sf)(__m512)(A), \
+                                   (__v16sf)(__m512)(B), (int)(R)))
+
+#define _mm512_mask_min_round_ps(W, U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_min_round_ps((A), (B), (R)), \
+                                  (__v16sf)(W)))
+
+#define _mm512_maskz_min_round_ps(U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_min_round_ps((A), (B), (R)), \
+                                  (__v16sf)_mm512_setzero_ps()))
+
+static  __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_min_ps(__m512 __A, __m512 __B)
+{
+  return (__m512) __builtin_ia32_minps512((__v16sf) __A, (__v16sf) __B,
+                                          _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_min_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512(__U,
+                                             (__v16sf)_mm512_min_ps(__A, __B),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_ps (__mmask16 __U, __m512 __A, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512(__U,
+                                             (__v16sf)_mm512_min_ps(__A, __B),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_min_ss(__m128 __W, __mmask8 __U,__m128 __A, __m128 __B) {
+  return (__m128) __builtin_ia32_minss_round_mask ((__v4sf) __A,
+                (__v4sf) __B,
+                (__v4sf) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_min_ss(__mmask8 __U,__m128 __A, __m128 __B) {
+  return (__m128) __builtin_ia32_minss_round_mask ((__v4sf) __A,
+                (__v4sf) __B,
+                (__v4sf)  _mm_setzero_ps (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_min_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_minss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_min_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_minss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)(__m128)(W), (__mmask8)(U), \
+                                           (int)(R)))
+
+#define _mm_maskz_min_round_ss(U, A, B, R) \
+  ((__m128)__builtin_ia32_minss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_min_sd(__m128d __W, __mmask8 __U,__m128d __A, __m128d __B) {
+  return (__m128d) __builtin_ia32_minsd_round_mask ((__v2df) __A,
+                (__v2df) __B,
+                (__v2df) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_min_sd(__mmask8 __U,__m128d __A, __m128d __B) {
+  return (__m128d) __builtin_ia32_minsd_round_mask ((__v2df) __A,
+                (__v2df) __B,
+                (__v2df)  _mm_setzero_pd (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_min_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_minsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_min_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_minsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)(__m128d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_min_round_sd(U, A, B, R) \
+  ((__m128d)__builtin_ia32_minsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline __m512i
+__DEFAULT_FN_ATTRS512
+_mm512_min_epi32(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_min((__v16si)__A, (__v16si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_min_epi32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                            (__v16si)_mm512_min_epi32(__A, __B),
+                                            (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_epi32 (__mmask16 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                            (__v16si)_mm512_min_epi32(__A, __B),
+                                            (__v16si)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_min_epu32(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_min((__v16su)__A, (__v16su)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_min_epu32 (__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                            (__v16si)_mm512_min_epu32(__A, __B),
+                                            (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_epu32 (__mmask16 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                            (__v16si)_mm512_min_epu32(__A, __B),
+                                            (__v16si)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_min_epi64(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_min((__v8di)__A, (__v8di)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_min_epi64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_min_epi64(__A, __B),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_epi64 (__mmask8 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_min_epi64(__A, __B),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_min_epu64(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_elementwise_min((__v8du)__A, (__v8du)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_min_epu64 (__m512i __W, __mmask8 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_min_epu64(__A, __B),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_epu64 (__mmask8 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_min_epu64(__A, __B),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_mul_epi32(__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_pmuldq512((__v16si)__X, (__v16si) __Y);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mul_epi32(__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_mul_epi32(__X, __Y),
+                                             (__v8di)__W);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mul_epi32(__mmask8 __M, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_mul_epi32(__X, __Y),
+                                             (__v8di)_mm512_setzero_si512 ());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_mul_epu32(__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_pmuludq512((__v16si)__X, (__v16si)__Y);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mul_epu32(__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_mul_epu32(__X, __Y),
+                                             (__v8di)__W);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mul_epu32(__mmask8 __M, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                             (__v8di)_mm512_mul_epu32(__X, __Y),
+                                             (__v8di)_mm512_setzero_si512 ());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_mullo_epi32 (__m512i __A, __m512i __B)
+{
+  return (__m512i) ((__v16su) __A * (__v16su) __B);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mullo_epi32(__mmask16 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                             (__v16si)_mm512_mullo_epi32(__A, __B),
+                                             (__v16si)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mullo_epi32(__m512i __W, __mmask16 __M, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                             (__v16si)_mm512_mullo_epi32(__A, __B),
+                                             (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mullox_epi64 (__m512i __A, __m512i __B) {
+  return (__m512i) ((__v8du) __A * (__v8du) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mullox_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B) {
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_mullox_epi64(__A, __B),
+                                             (__v8di)__W);
+}
+
+#define _mm512_sqrt_round_pd(A, R) \
+  ((__m512d)__builtin_ia32_sqrtpd512((__v8df)(__m512d)(A), (int)(R)))
+
+#define _mm512_mask_sqrt_round_pd(W, U, A, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                       (__v8df)_mm512_sqrt_round_pd((A), (R)), \
+                                       (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_sqrt_round_pd(U, A, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                       (__v8df)_mm512_sqrt_round_pd((A), (R)), \
+                                       (__v8df)_mm512_setzero_pd()))
+
+static  __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_sqrt_pd(__m512d __A)
+{
+  return (__m512d)__builtin_ia32_sqrtpd512((__v8df)__A,
+                                           _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_sqrt_pd (__m512d __W, __mmask8 __U, __m512d __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__U,
+                                              (__v8df)_mm512_sqrt_pd(__A),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_sqrt_pd (__mmask8 __U, __m512d __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__U,
+                                              (__v8df)_mm512_sqrt_pd(__A),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+#define _mm512_sqrt_round_ps(A, R) \
+  ((__m512)__builtin_ia32_sqrtps512((__v16sf)(__m512)(A), (int)(R)))
+
+#define _mm512_mask_sqrt_round_ps(W, U, A, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                      (__v16sf)_mm512_sqrt_round_ps((A), (R)), \
+                                      (__v16sf)(__m512)(W)))
+
+#define _mm512_maskz_sqrt_round_ps(U, A, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                      (__v16sf)_mm512_sqrt_round_ps((A), (R)), \
+                                      (__v16sf)_mm512_setzero_ps()))
+
+static  __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_sqrt_ps(__m512 __A)
+{
+  return (__m512)__builtin_ia32_sqrtps512((__v16sf)__A,
+                                          _MM_FROUND_CUR_DIRECTION);
+}
+
+static  __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_sqrt_ps(__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512(__U,
+                                             (__v16sf)_mm512_sqrt_ps(__A),
+                                             (__v16sf)__W);
+}
+
+static  __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_sqrt_ps( __mmask16 __U, __m512 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512(__U,
+                                             (__v16sf)_mm512_sqrt_ps(__A),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static  __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_rsqrt14_pd(__m512d __A)
+{
+  return (__m512d) __builtin_ia32_rsqrt14pd512_mask ((__v8df) __A,
+                 (__v8df)
+                 _mm512_setzero_pd (),
+                 (__mmask8) -1);}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_rsqrt14_pd (__m512d __W, __mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_rsqrt14pd512_mask ((__v8df) __A,
+                  (__v8df) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_rsqrt14_pd (__mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_rsqrt14pd512_mask ((__v8df) __A,
+                  (__v8df)
+                  _mm512_setzero_pd (),
+                  (__mmask8) __U);
+}
+
+static  __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_rsqrt14_ps(__m512 __A)
+{
+  return (__m512) __builtin_ia32_rsqrt14ps512_mask ((__v16sf) __A,
+                (__v16sf)
+                _mm512_setzero_ps (),
+                (__mmask16) -1);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_rsqrt14_ps (__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_rsqrt14ps512_mask ((__v16sf) __A,
+                 (__v16sf) __W,
+                 (__mmask16) __U);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_rsqrt14_ps (__mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_rsqrt14ps512_mask ((__v16sf) __A,
+                 (__v16sf)
+                 _mm512_setzero_ps (),
+                 (__mmask16) __U);
+}
+
+static  __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_rsqrt14_ss(__m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __A,
+             (__v4sf) __B,
+             (__v4sf)
+             _mm_setzero_ps (),
+             (__mmask8) -1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_rsqrt14_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+ return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __A,
+          (__v4sf) __B,
+          (__v4sf) __W,
+          (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_rsqrt14_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+ return (__m128) __builtin_ia32_rsqrt14ss_mask ((__v4sf) __A,
+          (__v4sf) __B,
+          (__v4sf) _mm_setzero_ps (),
+          (__mmask8) __U);
+}
+
+static  __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_rsqrt14_sd(__m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_rsqrt14sd_mask ((__v2df) __A,
+              (__v2df) __B,
+              (__v2df)
+              _mm_setzero_pd (),
+              (__mmask8) -1);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_rsqrt14_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+ return (__m128d) __builtin_ia32_rsqrt14sd_mask ( (__v2df) __A,
+          (__v2df) __B,
+          (__v2df) __W,
+          (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_rsqrt14_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+ return (__m128d) __builtin_ia32_rsqrt14sd_mask ( (__v2df) __A,
+          (__v2df) __B,
+          (__v2df) _mm_setzero_pd (),
+          (__mmask8) __U);
+}
+
+static  __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_rcp14_pd(__m512d __A)
+{
+  return (__m512d) __builtin_ia32_rcp14pd512_mask ((__v8df) __A,
+               (__v8df)
+               _mm512_setzero_pd (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_rcp14_pd (__m512d __W, __mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_rcp14pd512_mask ((__v8df) __A,
+                (__v8df) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_rcp14_pd (__mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_rcp14pd512_mask ((__v8df) __A,
+                (__v8df)
+                _mm512_setzero_pd (),
+                (__mmask8) __U);
+}
+
+static  __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_rcp14_ps(__m512 __A)
+{
+  return (__m512) __builtin_ia32_rcp14ps512_mask ((__v16sf) __A,
+              (__v16sf)
+              _mm512_setzero_ps (),
+              (__mmask16) -1);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_rcp14_ps (__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_rcp14ps512_mask ((__v16sf) __A,
+                   (__v16sf) __W,
+                   (__mmask16) __U);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_rcp14_ps (__mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_rcp14ps512_mask ((__v16sf) __A,
+                   (__v16sf)
+                   _mm512_setzero_ps (),
+                   (__mmask16) __U);
+}
+
+static  __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_rcp14_ss(__m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __A,
+                 (__v4sf) __B,
+                 (__v4sf)
+                 _mm_setzero_ps (),
+                 (__mmask8) -1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_rcp14_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+ return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __A,
+          (__v4sf) __B,
+          (__v4sf) __W,
+          (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_rcp14_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+ return (__m128) __builtin_ia32_rcp14ss_mask ((__v4sf) __A,
+          (__v4sf) __B,
+          (__v4sf) _mm_setzero_ps (),
+          (__mmask8) __U);
+}
+
+static  __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_rcp14_sd(__m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_rcp14sd_mask ((__v2df) __A,
+            (__v2df) __B,
+            (__v2df)
+            _mm_setzero_pd (),
+            (__mmask8) -1);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_rcp14_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+ return (__m128d) __builtin_ia32_rcp14sd_mask ( (__v2df) __A,
+          (__v2df) __B,
+          (__v2df) __W,
+          (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_rcp14_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+ return (__m128d) __builtin_ia32_rcp14sd_mask ( (__v2df) __A,
+          (__v2df) __B,
+          (__v2df) _mm_setzero_pd (),
+          (__mmask8) __U);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_floor_ps(__m512 __A)
+{
+  return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A,
+                                                  _MM_FROUND_FLOOR,
+                                                  (__v16sf) __A, (unsigned short)-1,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_floor_ps (__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A,
+                   _MM_FROUND_FLOOR,
+                   (__v16sf) __W, __U,
+                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_floor_pd(__m512d __A)
+{
+  return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A,
+                                                   _MM_FROUND_FLOOR,
+                                                   (__v8df) __A, (unsigned char)-1,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_floor_pd (__m512d __W, __mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A,
+                _MM_FROUND_FLOOR,
+                (__v8df) __W, __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_ceil_ps (__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A,
+                   _MM_FROUND_CEIL,
+                   (__v16sf) __W, __U,
+                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_ceil_ps(__m512 __A)
+{
+  return (__m512) __builtin_ia32_rndscaleps_mask ((__v16sf) __A,
+                                                  _MM_FROUND_CEIL,
+                                                  (__v16sf) __A, (unsigned short)-1,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_ceil_pd(__m512d __A)
+{
+  return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A,
+                                                   _MM_FROUND_CEIL,
+                                                   (__v8df) __A, (unsigned char)-1,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_ceil_pd (__m512d __W, __mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_rndscalepd_mask ((__v8df) __A,
+                _MM_FROUND_CEIL,
+                (__v8df) __W, __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_abs_epi64(__m512i __A)
+{
+  return (__m512i)__builtin_elementwise_abs((__v8di)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_abs_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_abs_epi64(__A),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_abs_epi64 (__mmask8 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_abs_epi64(__A),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_abs_epi32(__m512i __A)
+{
+  return (__m512i)__builtin_elementwise_abs((__v16si) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_abs_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                             (__v16si)_mm512_abs_epi32(__A),
+                                             (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_abs_epi32 (__mmask16 __U, __m512i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                             (__v16si)_mm512_abs_epi32(__A),
+                                             (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_add_ss(__m128 __W, __mmask8 __U,__m128 __A, __m128 __B) {
+  __A = _mm_add_ss(__A, __B);
+  return __builtin_ia32_selectss_128(__U, __A, __W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_add_ss(__mmask8 __U,__m128 __A, __m128 __B) {
+  __A = _mm_add_ss(__A, __B);
+  return __builtin_ia32_selectss_128(__U, __A, _mm_setzero_ps());
+}
+
+#define _mm_add_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_addss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_add_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_addss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)(__m128)(W), (__mmask8)(U), \
+                                           (int)(R)))
+
+#define _mm_maskz_add_round_ss(U, A, B, R) \
+  ((__m128)__builtin_ia32_addss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_add_sd(__m128d __W, __mmask8 __U,__m128d __A, __m128d __B) {
+  __A = _mm_add_sd(__A, __B);
+  return __builtin_ia32_selectsd_128(__U, __A, __W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_add_sd(__mmask8 __U,__m128d __A, __m128d __B) {
+  __A = _mm_add_sd(__A, __B);
+  return __builtin_ia32_selectsd_128(__U, __A, _mm_setzero_pd());
+}
+#define _mm_add_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_addsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_add_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_addsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)(__m128d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_add_round_sd(U, A, B, R) \
+  ((__m128d)__builtin_ia32_addsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_add_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_add_pd(__A, __B),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_add_pd(__mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_add_pd(__A, __B),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_add_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_add_ps(__A, __B),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_add_ps(__mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_add_ps(__A, __B),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+#define _mm512_add_round_pd(A, B, R) \
+  ((__m512d)__builtin_ia32_addpd512((__v8df)(__m512d)(A), \
+                                    (__v8df)(__m512d)(B), (int)(R)))
+
+#define _mm512_mask_add_round_pd(W, U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_add_round_pd((A), (B), (R)), \
+                                   (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_add_round_pd(U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_add_round_pd((A), (B), (R)), \
+                                   (__v8df)_mm512_setzero_pd()))
+
+#define _mm512_add_round_ps(A, B, R) \
+  ((__m512)__builtin_ia32_addps512((__v16sf)(__m512)(A), \
+                                   (__v16sf)(__m512)(B), (int)(R)))
+
+#define _mm512_mask_add_round_ps(W, U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_add_round_ps((A), (B), (R)), \
+                                  (__v16sf)(__m512)(W)))
+
+#define _mm512_maskz_add_round_ps(U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_add_round_ps((A), (B), (R)), \
+                                  (__v16sf)_mm512_setzero_ps()))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_sub_ss(__m128 __W, __mmask8 __U,__m128 __A, __m128 __B) {
+  __A = _mm_sub_ss(__A, __B);
+  return __builtin_ia32_selectss_128(__U, __A, __W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_sub_ss(__mmask8 __U,__m128 __A, __m128 __B) {
+  __A = _mm_sub_ss(__A, __B);
+  return __builtin_ia32_selectss_128(__U, __A, _mm_setzero_ps());
+}
+#define _mm_sub_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_subss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_sub_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_subss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)(__m128)(W), (__mmask8)(U), \
+                                           (int)(R)))
+
+#define _mm_maskz_sub_round_ss(U, A, B, R) \
+  ((__m128)__builtin_ia32_subss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_sub_sd(__m128d __W, __mmask8 __U,__m128d __A, __m128d __B) {
+  __A = _mm_sub_sd(__A, __B);
+  return __builtin_ia32_selectsd_128(__U, __A, __W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_sub_sd(__mmask8 __U,__m128d __A, __m128d __B) {
+  __A = _mm_sub_sd(__A, __B);
+  return __builtin_ia32_selectsd_128(__U, __A, _mm_setzero_pd());
+}
+
+#define _mm_sub_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_subsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_sub_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_subsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)(__m128d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_sub_round_sd(U, A, B, R) \
+  ((__m128d)__builtin_ia32_subsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_sub_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_sub_pd(__A, __B),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_sub_pd(__mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_sub_pd(__A, __B),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_sub_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_sub_ps(__A, __B),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_sub_ps(__mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_sub_ps(__A, __B),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+#define _mm512_sub_round_pd(A, B, R) \
+  ((__m512d)__builtin_ia32_subpd512((__v8df)(__m512d)(A), \
+                                    (__v8df)(__m512d)(B), (int)(R)))
+
+#define _mm512_mask_sub_round_pd(W, U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_sub_round_pd((A), (B), (R)), \
+                                   (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_sub_round_pd(U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_sub_round_pd((A), (B), (R)), \
+                                   (__v8df)_mm512_setzero_pd()))
+
+#define _mm512_sub_round_ps(A, B, R) \
+  ((__m512)__builtin_ia32_subps512((__v16sf)(__m512)(A), \
+                                   (__v16sf)(__m512)(B), (int)(R)))
+
+#define _mm512_mask_sub_round_ps(W, U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_sub_round_ps((A), (B), (R)), \
+                                  (__v16sf)(__m512)(W)))
+
+#define _mm512_maskz_sub_round_ps(U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_sub_round_ps((A), (B), (R)), \
+                                  (__v16sf)_mm512_setzero_ps()))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_mul_ss(__m128 __W, __mmask8 __U,__m128 __A, __m128 __B) {
+  __A = _mm_mul_ss(__A, __B);
+  return __builtin_ia32_selectss_128(__U, __A, __W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_mul_ss(__mmask8 __U,__m128 __A, __m128 __B) {
+  __A = _mm_mul_ss(__A, __B);
+  return __builtin_ia32_selectss_128(__U, __A, _mm_setzero_ps());
+}
+#define _mm_mul_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_mulss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_mul_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_mulss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)(__m128)(W), (__mmask8)(U), \
+                                           (int)(R)))
+
+#define _mm_maskz_mul_round_ss(U, A, B, R) \
+  ((__m128)__builtin_ia32_mulss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_mul_sd(__m128d __W, __mmask8 __U,__m128d __A, __m128d __B) {
+  __A = _mm_mul_sd(__A, __B);
+  return __builtin_ia32_selectsd_128(__U, __A, __W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_mul_sd(__mmask8 __U,__m128d __A, __m128d __B) {
+  __A = _mm_mul_sd(__A, __B);
+  return __builtin_ia32_selectsd_128(__U, __A, _mm_setzero_pd());
+}
+
+#define _mm_mul_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_mulsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_mul_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_mulsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)(__m128d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_mul_round_sd(U, A, B, R) \
+  ((__m128d)__builtin_ia32_mulsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_mul_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_mul_pd(__A, __B),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_mul_pd(__mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_mul_pd(__A, __B),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_mul_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_mul_ps(__A, __B),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_mul_ps(__mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_mul_ps(__A, __B),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+#define _mm512_mul_round_pd(A, B, R) \
+  ((__m512d)__builtin_ia32_mulpd512((__v8df)(__m512d)(A), \
+                                    (__v8df)(__m512d)(B), (int)(R)))
+
+#define _mm512_mask_mul_round_pd(W, U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_mul_round_pd((A), (B), (R)), \
+                                   (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_mul_round_pd(U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_mul_round_pd((A), (B), (R)), \
+                                   (__v8df)_mm512_setzero_pd()))
+
+#define _mm512_mul_round_ps(A, B, R) \
+  ((__m512)__builtin_ia32_mulps512((__v16sf)(__m512)(A), \
+                                  (__v16sf)(__m512)(B), (int)(R)))
+
+#define _mm512_mask_mul_round_ps(W, U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_mul_round_ps((A), (B), (R)), \
+                                  (__v16sf)(__m512)(W)))
+
+#define _mm512_maskz_mul_round_ps(U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_mul_round_ps((A), (B), (R)), \
+                                  (__v16sf)_mm512_setzero_ps()))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_div_ss(__m128 __W, __mmask8 __U,__m128 __A, __m128 __B) {
+  __A = _mm_div_ss(__A, __B);
+  return __builtin_ia32_selectss_128(__U, __A, __W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_div_ss(__mmask8 __U,__m128 __A, __m128 __B) {
+  __A = _mm_div_ss(__A, __B);
+  return __builtin_ia32_selectss_128(__U, __A, _mm_setzero_ps());
+}
+
+#define _mm_div_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_divss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_div_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_divss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)(__m128)(W), (__mmask8)(U), \
+                                           (int)(R)))
+
+#define _mm_maskz_div_round_ss(U, A, B, R) \
+  ((__m128)__builtin_ia32_divss_round_mask((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_div_sd(__m128d __W, __mmask8 __U,__m128d __A, __m128d __B) {
+  __A = _mm_div_sd(__A, __B);
+  return __builtin_ia32_selectsd_128(__U, __A, __W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_div_sd(__mmask8 __U,__m128d __A, __m128d __B) {
+  __A = _mm_div_sd(__A, __B);
+  return __builtin_ia32_selectsd_128(__U, __A, _mm_setzero_pd());
+}
+
+#define _mm_div_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_divsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_div_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_divsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)(__m128d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_div_round_sd(U, A, B, R) \
+  ((__m128d)__builtin_ia32_divsd_round_mask((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_div_pd(__m512d __a, __m512d __b)
+{
+  return (__m512d)((__v8df)__a/(__v8df)__b);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_div_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_div_pd(__A, __B),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_div_pd(__mmask8 __U, __m512d __A, __m512d __B) {
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_div_pd(__A, __B),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_div_ps(__m512 __a, __m512 __b)
+{
+  return (__m512)((__v16sf)__a/(__v16sf)__b);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_div_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_div_ps(__A, __B),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_div_ps(__mmask16 __U, __m512 __A, __m512 __B) {
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_div_ps(__A, __B),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+#define _mm512_div_round_pd(A, B, R) \
+  ((__m512d)__builtin_ia32_divpd512((__v8df)(__m512d)(A), \
+                                    (__v8df)(__m512d)(B), (int)(R)))
+
+#define _mm512_mask_div_round_pd(W, U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_div_round_pd((A), (B), (R)), \
+                                   (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_div_round_pd(U, A, B, R) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_div_round_pd((A), (B), (R)), \
+                                   (__v8df)_mm512_setzero_pd()))
+
+#define _mm512_div_round_ps(A, B, R) \
+  ((__m512)__builtin_ia32_divps512((__v16sf)(__m512)(A), \
+                                   (__v16sf)(__m512)(B), (int)(R)))
+
+#define _mm512_mask_div_round_ps(W, U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_div_round_ps((A), (B), (R)), \
+                                  (__v16sf)(__m512)(W)))
+
+#define _mm512_maskz_div_round_ps(U, A, B, R) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_div_round_ps((A), (B), (R)), \
+                                  (__v16sf)_mm512_setzero_ps()))
+
+#define _mm512_roundscale_ps(A, B) \
+  ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(A), (int)(B), \
+                                          (__v16sf)_mm512_undefined_ps(), \
+                                          (__mmask16)-1, \
+                                          _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_roundscale_ps(A, B, C, imm) \
+  ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(C), (int)(imm), \
+                                         (__v16sf)(__m512)(A), (__mmask16)(B), \
+                                         _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_roundscale_ps(A, B, imm) \
+  ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(B), (int)(imm), \
+                                          (__v16sf)_mm512_setzero_ps(), \
+                                          (__mmask16)(A), \
+                                          _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_roundscale_round_ps(A, B, C, imm, R) \
+  ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(C), (int)(imm), \
+                                         (__v16sf)(__m512)(A), (__mmask16)(B), \
+                                         (int)(R)))
+
+#define _mm512_maskz_roundscale_round_ps(A, B, imm, R) \
+  ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(B), (int)(imm), \
+                                          (__v16sf)_mm512_setzero_ps(), \
+                                          (__mmask16)(A), (int)(R)))
+
+#define _mm512_roundscale_round_ps(A, imm, R) \
+  ((__m512)__builtin_ia32_rndscaleps_mask((__v16sf)(__m512)(A), (int)(imm), \
+                                          (__v16sf)_mm512_undefined_ps(), \
+                                          (__mmask16)-1, (int)(R)))
+
+#define _mm512_roundscale_pd(A, B) \
+  ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(A), (int)(B), \
+                                           (__v8df)_mm512_undefined_pd(), \
+                                           (__mmask8)-1, \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_roundscale_pd(A, B, C, imm) \
+  ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(C), (int)(imm), \
+                                          (__v8df)(__m512d)(A), (__mmask8)(B), \
+                                          _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_roundscale_pd(A, B, imm) \
+  ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(B), (int)(imm), \
+                                           (__v8df)_mm512_setzero_pd(), \
+                                           (__mmask8)(A), \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_roundscale_round_pd(A, B, C, imm, R) \
+  ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(C), (int)(imm), \
+                                          (__v8df)(__m512d)(A), (__mmask8)(B), \
+                                          (int)(R)))
+
+#define _mm512_maskz_roundscale_round_pd(A, B, imm, R) \
+  ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(B), (int)(imm), \
+                                           (__v8df)_mm512_setzero_pd(), \
+                                           (__mmask8)(A), (int)(R)))
+
+#define _mm512_roundscale_round_pd(A, imm, R) \
+  ((__m512d)__builtin_ia32_rndscalepd_mask((__v8df)(__m512d)(A), (int)(imm), \
+                                           (__v8df)_mm512_undefined_pd(), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm512_fmadd_round_pd(A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \
+                                            (__v8df)(__m512d)(B), \
+                                            (__v8df)(__m512d)(C), \
+                                            (__mmask8)-1, (int)(R)))
+
+
+#define _mm512_mask_fmadd_round_pd(A, U, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \
+                                            (__v8df)(__m512d)(B), \
+                                            (__v8df)(__m512d)(C), \
+                                            (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_mask3_fmadd_round_pd(A, B, C, U, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_mask3((__v8df)(__m512d)(A), \
+                                             (__v8df)(__m512d)(B), \
+                                             (__v8df)(__m512d)(C), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_maskz_fmadd_round_pd(U, A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_maskz((__v8df)(__m512d)(A), \
+                                             (__v8df)(__m512d)(B), \
+                                             (__v8df)(__m512d)(C), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_fmsub_round_pd(A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \
+                                            (__v8df)(__m512d)(B), \
+                                            -(__v8df)(__m512d)(C), \
+                                            (__mmask8)-1, (int)(R)))
+
+
+#define _mm512_mask_fmsub_round_pd(A, U, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \
+                                            (__v8df)(__m512d)(B), \
+                                            -(__v8df)(__m512d)(C), \
+                                            (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_maskz_fmsub_round_pd(U, A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_maskz((__v8df)(__m512d)(A), \
+                                             (__v8df)(__m512d)(B), \
+                                             -(__v8df)(__m512d)(C), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_fnmadd_round_pd(A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_mask(-(__v8df)(__m512d)(A), \
+                                            (__v8df)(__m512d)(B), \
+                                            (__v8df)(__m512d)(C), \
+                                            (__mmask8)-1, (int)(R)))
+
+
+#define _mm512_mask3_fnmadd_round_pd(A, B, C, U, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_mask3(-(__v8df)(__m512d)(A), \
+                                             (__v8df)(__m512d)(B), \
+                                             (__v8df)(__m512d)(C), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_maskz_fnmadd_round_pd(U, A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_maskz(-(__v8df)(__m512d)(A), \
+                                             (__v8df)(__m512d)(B), \
+                                             (__v8df)(__m512d)(C), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_fnmsub_round_pd(A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_mask(-(__v8df)(__m512d)(A), \
+                                            (__v8df)(__m512d)(B), \
+                                            -(__v8df)(__m512d)(C), \
+                                            (__mmask8)-1, (int)(R)))
+
+
+#define _mm512_maskz_fnmsub_round_pd(U, A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_maskz(-(__v8df)(__m512d)(A), \
+                                             (__v8df)(__m512d)(B), \
+                                             -(__v8df)(__m512d)(C), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_fmadd_pd(__m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A,
+                                                    (__v8df) __B,
+                                                    (__v8df) __C,
+                                                    (__mmask8) -1,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_fmadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A,
+                                                    (__v8df) __B,
+                                                    (__v8df) __C,
+                                                    (__mmask8) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_mask3 ((__v8df) __A,
+                                                     (__v8df) __B,
+                                                     (__v8df) __C,
+                                                     (__mmask8) __U,
+                                                     _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_maskz ((__v8df) __A,
+                                                     (__v8df) __B,
+                                                     (__v8df) __C,
+                                                     (__mmask8) __U,
+                                                     _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_fmsub_pd(__m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A,
+                                                    (__v8df) __B,
+                                                    -(__v8df) __C,
+                                                    (__mmask8) -1,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_fmsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A,
+                                                    (__v8df) __B,
+                                                    -(__v8df) __C,
+                                                    (__mmask8) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_maskz ((__v8df) __A,
+                                                     (__v8df) __B,
+                                                     -(__v8df) __C,
+                                                     (__mmask8) __U,
+                                                     _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A,
+                                                    -(__v8df) __B,
+                                                    (__v8df) __C,
+                                                    (__mmask8) -1,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask3_fnmadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_mask3 (-(__v8df) __A,
+                                                     (__v8df) __B,
+                                                     (__v8df) __C,
+                                                     (__mmask8) __U,
+                                                     _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_fnmadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_maskz (-(__v8df) __A,
+                                                     (__v8df) __B,
+                                                     (__v8df) __C,
+                                                     (__mmask8) __U,
+                                                     _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_fnmsub_pd(__m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A,
+                                                    -(__v8df) __B,
+                                                    -(__v8df) __C,
+                                                    (__mmask8) -1,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_fnmsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_maskz (-(__v8df) __A,
+                                                     (__v8df) __B,
+                                                     -(__v8df) __C,
+                                                     (__mmask8) __U,
+                                                     _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_fmadd_round_ps(A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)(__m512)(B), \
+                                           (__v16sf)(__m512)(C), \
+                                           (__mmask16)-1, (int)(R)))
+
+
+#define _mm512_mask_fmadd_round_ps(A, U, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)(__m512)(B), \
+                                           (__v16sf)(__m512)(C), \
+                                           (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_mask3_fmadd_round_ps(A, B, C, U, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_mask3((__v16sf)(__m512)(A), \
+                                            (__v16sf)(__m512)(B), \
+                                            (__v16sf)(__m512)(C), \
+                                            (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_maskz_fmadd_round_ps(U, A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_maskz((__v16sf)(__m512)(A), \
+                                            (__v16sf)(__m512)(B), \
+                                            (__v16sf)(__m512)(C), \
+                                            (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_fmsub_round_ps(A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)(__m512)(B), \
+                                           -(__v16sf)(__m512)(C), \
+                                           (__mmask16)-1, (int)(R)))
+
+
+#define _mm512_mask_fmsub_round_ps(A, U, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)(__m512)(B), \
+                                           -(__v16sf)(__m512)(C), \
+                                           (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_maskz_fmsub_round_ps(U, A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_maskz((__v16sf)(__m512)(A), \
+                                            (__v16sf)(__m512)(B), \
+                                            -(__v16sf)(__m512)(C), \
+                                            (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_fnmadd_round_ps(A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \
+                                           -(__v16sf)(__m512)(B), \
+                                           (__v16sf)(__m512)(C), \
+                                           (__mmask16)-1, (int)(R)))
+
+
+#define _mm512_mask3_fnmadd_round_ps(A, B, C, U, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_mask3(-(__v16sf)(__m512)(A), \
+                                            (__v16sf)(__m512)(B), \
+                                            (__v16sf)(__m512)(C), \
+                                            (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_maskz_fnmadd_round_ps(U, A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_maskz(-(__v16sf)(__m512)(A), \
+                                            (__v16sf)(__m512)(B), \
+                                            (__v16sf)(__m512)(C), \
+                                            (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_fnmsub_round_ps(A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \
+                                           -(__v16sf)(__m512)(B), \
+                                           -(__v16sf)(__m512)(C), \
+                                           (__mmask16)-1, (int)(R)))
+
+
+#define _mm512_maskz_fnmsub_round_ps(U, A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_maskz(-(__v16sf)(__m512)(A), \
+                                            (__v16sf)(__m512)(B), \
+                                            -(__v16sf)(__m512)(C), \
+                                            (__mmask16)(U), (int)(R)))
+
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_fmadd_ps(__m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A,
+                                                   (__v16sf) __B,
+                                                   (__v16sf) __C,
+                                                   (__mmask16) -1,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_fmadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A,
+                                                   (__v16sf) __B,
+                                                   (__v16sf) __C,
+                                                   (__mmask16) __U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_mask3 ((__v16sf) __A,
+                                                    (__v16sf) __B,
+                                                    (__v16sf) __C,
+                                                    (__mmask16) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_maskz ((__v16sf) __A,
+                                                    (__v16sf) __B,
+                                                    (__v16sf) __C,
+                                                    (__mmask16) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_fmsub_ps(__m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A,
+                                                   (__v16sf) __B,
+                                                   -(__v16sf) __C,
+                                                   (__mmask16) -1,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_fmsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A,
+                                                   (__v16sf) __B,
+                                                   -(__v16sf) __C,
+                                                   (__mmask16) __U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_maskz ((__v16sf) __A,
+                                                    (__v16sf) __B,
+                                                    -(__v16sf) __C,
+                                                    (__mmask16) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A,
+                                                   -(__v16sf) __B,
+                                                   (__v16sf) __C,
+                                                   (__mmask16) -1,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask3_fnmadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_mask3 (-(__v16sf) __A,
+                                                    (__v16sf) __B,
+                                                    (__v16sf) __C,
+                                                    (__mmask16) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_fnmadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_maskz (-(__v16sf) __A,
+                                                    (__v16sf) __B,
+                                                    (__v16sf) __C,
+                                                    (__mmask16) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A,
+                                                   -(__v16sf) __B,
+                                                   -(__v16sf) __C,
+                                                   (__mmask16) -1,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_fnmsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_maskz (-(__v16sf) __A,
+                                                    (__v16sf) __B,
+                                                    -(__v16sf) __C,
+                                                    (__mmask16) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_fmaddsub_round_pd(A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddsubpd512_mask((__v8df)(__m512d)(A), \
+                                               (__v8df)(__m512d)(B), \
+                                               (__v8df)(__m512d)(C), \
+                                               (__mmask8)-1, (int)(R)))
+
+
+#define _mm512_mask_fmaddsub_round_pd(A, U, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddsubpd512_mask((__v8df)(__m512d)(A), \
+                                               (__v8df)(__m512d)(B), \
+                                               (__v8df)(__m512d)(C), \
+                                               (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_mask3_fmaddsub_round_pd(A, B, C, U, R) \
+  ((__m512d)__builtin_ia32_vfmaddsubpd512_mask3((__v8df)(__m512d)(A), \
+                                                (__v8df)(__m512d)(B), \
+                                                (__v8df)(__m512d)(C), \
+                                                (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_maskz_fmaddsub_round_pd(U, A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddsubpd512_maskz((__v8df)(__m512d)(A), \
+                                                (__v8df)(__m512d)(B), \
+                                                (__v8df)(__m512d)(C), \
+                                                (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_fmsubadd_round_pd(A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddsubpd512_mask((__v8df)(__m512d)(A), \
+                                               (__v8df)(__m512d)(B), \
+                                               -(__v8df)(__m512d)(C), \
+                                               (__mmask8)-1, (int)(R)))
+
+
+#define _mm512_mask_fmsubadd_round_pd(A, U, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddsubpd512_mask((__v8df)(__m512d)(A), \
+                                               (__v8df)(__m512d)(B), \
+                                               -(__v8df)(__m512d)(C), \
+                                               (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_maskz_fmsubadd_round_pd(U, A, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddsubpd512_maskz((__v8df)(__m512d)(A), \
+                                                (__v8df)(__m512d)(B), \
+                                                -(__v8df)(__m512d)(C), \
+                                                (__mmask8)(U), (int)(R)))
+
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_fmaddsub_pd(__m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A,
+                                                      (__v8df) __B,
+                                                      (__v8df) __C,
+                                                      (__mmask8) -1,
+                                                      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_fmaddsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A,
+                                                      (__v8df) __B,
+                                                      (__v8df) __C,
+                                                      (__mmask8) __U,
+                                                      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmaddsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
+{
+  return (__m512d) __builtin_ia32_vfmaddsubpd512_mask3 ((__v8df) __A,
+                                                       (__v8df) __B,
+                                                       (__v8df) __C,
+                                                       (__mmask8) __U,
+                                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmaddsub_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddsubpd512_maskz ((__v8df) __A,
+                                                       (__v8df) __B,
+                                                       (__v8df) __C,
+                                                       (__mmask8) __U,
+                                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_fmsubadd_pd(__m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A,
+                                                       (__v8df) __B,
+                                                       -(__v8df) __C,
+                                                       (__mmask8) -1,
+                                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_fmsubadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddsubpd512_mask ((__v8df) __A,
+                                                       (__v8df) __B,
+                                                       -(__v8df) __C,
+                                                       (__mmask8) __U,
+                                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmsubadd_pd(__mmask8 __U, __m512d __A, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddsubpd512_maskz ((__v8df) __A,
+                                                        (__v8df) __B,
+                                                        -(__v8df) __C,
+                                                        (__mmask8) __U,
+                                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_fmaddsub_round_ps(A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddsubps512_mask((__v16sf)(__m512)(A), \
+                                              (__v16sf)(__m512)(B), \
+                                              (__v16sf)(__m512)(C), \
+                                              (__mmask16)-1, (int)(R)))
+
+
+#define _mm512_mask_fmaddsub_round_ps(A, U, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddsubps512_mask((__v16sf)(__m512)(A), \
+                                              (__v16sf)(__m512)(B), \
+                                              (__v16sf)(__m512)(C), \
+                                              (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_mask3_fmaddsub_round_ps(A, B, C, U, R) \
+  ((__m512)__builtin_ia32_vfmaddsubps512_mask3((__v16sf)(__m512)(A), \
+                                               (__v16sf)(__m512)(B), \
+                                               (__v16sf)(__m512)(C), \
+                                               (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_maskz_fmaddsub_round_ps(U, A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddsubps512_maskz((__v16sf)(__m512)(A), \
+                                               (__v16sf)(__m512)(B), \
+                                               (__v16sf)(__m512)(C), \
+                                               (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_fmsubadd_round_ps(A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddsubps512_mask((__v16sf)(__m512)(A), \
+                                              (__v16sf)(__m512)(B), \
+                                              -(__v16sf)(__m512)(C), \
+                                              (__mmask16)-1, (int)(R)))
+
+
+#define _mm512_mask_fmsubadd_round_ps(A, U, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddsubps512_mask((__v16sf)(__m512)(A), \
+                                              (__v16sf)(__m512)(B), \
+                                              -(__v16sf)(__m512)(C), \
+                                              (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_maskz_fmsubadd_round_ps(U, A, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddsubps512_maskz((__v16sf)(__m512)(A), \
+                                               (__v16sf)(__m512)(B), \
+                                               -(__v16sf)(__m512)(C), \
+                                               (__mmask16)(U), (int)(R)))
+
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_fmaddsub_ps(__m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A,
+                                                      (__v16sf) __B,
+                                                      (__v16sf) __C,
+                                                      (__mmask16) -1,
+                                                      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_fmaddsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A,
+                                                      (__v16sf) __B,
+                                                      (__v16sf) __C,
+                                                      (__mmask16) __U,
+                                                      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmaddsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
+{
+  return (__m512) __builtin_ia32_vfmaddsubps512_mask3 ((__v16sf) __A,
+                                                       (__v16sf) __B,
+                                                       (__v16sf) __C,
+                                                       (__mmask16) __U,
+                                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmaddsub_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddsubps512_maskz ((__v16sf) __A,
+                                                       (__v16sf) __B,
+                                                       (__v16sf) __C,
+                                                       (__mmask16) __U,
+                                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_fmsubadd_ps(__m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A,
+                                                      (__v16sf) __B,
+                                                      -(__v16sf) __C,
+                                                      (__mmask16) -1,
+                                                      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_fmsubadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddsubps512_mask ((__v16sf) __A,
+                                                      (__v16sf) __B,
+                                                      -(__v16sf) __C,
+                                                      (__mmask16) __U,
+                                                      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmsubadd_ps(__mmask16 __U, __m512 __A, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddsubps512_maskz ((__v16sf) __A,
+                                                       (__v16sf) __B,
+                                                       -(__v16sf) __C,
+                                                       (__mmask16) __U,
+                                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask3_fmsub_round_pd(A, B, C, U, R) \
+  ((__m512d)__builtin_ia32_vfmsubpd512_mask3((__v8df)(__m512d)(A), \
+                                             (__v8df)(__m512d)(B), \
+                                             (__v8df)(__m512d)(C), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
+{
+  return (__m512d)__builtin_ia32_vfmsubpd512_mask3 ((__v8df) __A,
+                                                    (__v8df) __B,
+                                                    (__v8df) __C,
+                                                    (__mmask8) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask3_fmsub_round_ps(A, B, C, U, R) \
+  ((__m512)__builtin_ia32_vfmsubps512_mask3((__v16sf)(__m512)(A), \
+                                            (__v16sf)(__m512)(B), \
+                                            (__v16sf)(__m512)(C), \
+                                            (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
+{
+  return (__m512)__builtin_ia32_vfmsubps512_mask3 ((__v16sf) __A,
+                                                   (__v16sf) __B,
+                                                   (__v16sf) __C,
+                                                   (__mmask16) __U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask3_fmsubadd_round_pd(A, B, C, U, R) \
+  ((__m512d)__builtin_ia32_vfmsubaddpd512_mask3((__v8df)(__m512d)(A), \
+                                                (__v8df)(__m512d)(B), \
+                                                (__v8df)(__m512d)(C), \
+                                                (__mmask8)(U), (int)(R)))
+
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmsubadd_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
+{
+  return (__m512d)__builtin_ia32_vfmsubaddpd512_mask3 ((__v8df) __A,
+                                                       (__v8df) __B,
+                                                       (__v8df) __C,
+                                                       (__mmask8) __U,
+                                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask3_fmsubadd_round_ps(A, B, C, U, R) \
+  ((__m512)__builtin_ia32_vfmsubaddps512_mask3((__v16sf)(__m512)(A), \
+                                               (__v16sf)(__m512)(B), \
+                                               (__v16sf)(__m512)(C), \
+                                               (__mmask16)(U), (int)(R)))
+
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmsubadd_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
+{
+  return (__m512)__builtin_ia32_vfmsubaddps512_mask3 ((__v16sf) __A,
+                                                      (__v16sf) __B,
+                                                      (__v16sf) __C,
+                                                      (__mmask16) __U,
+                                                      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask_fnmadd_round_pd(A, U, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \
+                                            -(__v8df)(__m512d)(B), \
+                                            (__v8df)(__m512d)(C), \
+                                            (__mmask8)(U), (int)(R)))
+
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_fnmadd_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A,
+                                                    -(__v8df) __B,
+                                                    (__v8df) __C,
+                                                    (__mmask8) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask_fnmadd_round_ps(A, U, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \
+                                           -(__v16sf)(__m512)(B), \
+                                           (__v16sf)(__m512)(C), \
+                                           (__mmask16)(U), (int)(R)))
+
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_fnmadd_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A,
+                                                   -(__v16sf) __B,
+                                                   (__v16sf) __C,
+                                                   (__mmask16) __U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask_fnmsub_round_pd(A, U, B, C, R) \
+  ((__m512d)__builtin_ia32_vfmaddpd512_mask((__v8df)(__m512d)(A), \
+                                            -(__v8df)(__m512d)(B), \
+                                            -(__v8df)(__m512d)(C), \
+                                            (__mmask8)(U), (int)(R)))
+
+
+#define _mm512_mask3_fnmsub_round_pd(A, B, C, U, R) \
+  ((__m512d)__builtin_ia32_vfmsubpd512_mask3(-(__v8df)(__m512d)(A), \
+                                             (__v8df)(__m512d)(B), \
+                                             (__v8df)(__m512d)(C), \
+                                             (__mmask8)(U), (int)(R)))
+
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_fnmsub_pd(__m512d __A, __mmask8 __U, __m512d __B, __m512d __C)
+{
+  return (__m512d) __builtin_ia32_vfmaddpd512_mask ((__v8df) __A,
+                                                    -(__v8df) __B,
+                                                    -(__v8df) __C,
+                                                    (__mmask8) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask3_fnmsub_pd(__m512d __A, __m512d __B, __m512d __C, __mmask8 __U)
+{
+  return (__m512d) __builtin_ia32_vfmsubpd512_mask3 (-(__v8df) __A,
+                                                     (__v8df) __B,
+                                                     (__v8df) __C,
+                                                     (__mmask8) __U,
+                                                     _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask_fnmsub_round_ps(A, U, B, C, R) \
+  ((__m512)__builtin_ia32_vfmaddps512_mask((__v16sf)(__m512)(A), \
+                                           -(__v16sf)(__m512)(B), \
+                                           -(__v16sf)(__m512)(C), \
+                                           (__mmask16)(U), (int)(R)))
+
+
+#define _mm512_mask3_fnmsub_round_ps(A, B, C, U, R) \
+  ((__m512)__builtin_ia32_vfmsubps512_mask3(-(__v16sf)(__m512)(A), \
+                                            (__v16sf)(__m512)(B), \
+                                            (__v16sf)(__m512)(C), \
+                                            (__mmask16)(U), (int)(R)))
+
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_fnmsub_ps(__m512 __A, __mmask16 __U, __m512 __B, __m512 __C)
+{
+  return (__m512) __builtin_ia32_vfmaddps512_mask ((__v16sf) __A,
+                                                   -(__v16sf) __B,
+                                                   -(__v16sf) __C,
+                                                   (__mmask16) __U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask3_fnmsub_ps(__m512 __A, __m512 __B, __m512 __C, __mmask16 __U)
+{
+  return (__m512) __builtin_ia32_vfmsubps512_mask3 (-(__v16sf) __A,
+                                                    (__v16sf) __B,
+                                                    (__v16sf) __C,
+                                                    (__mmask16) __U,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+
+
+/* Vector permutations */
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_permutex2var_epi32(__m512i __A, __m512i __I, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_vpermi2vard512((__v16si)__A, (__v16si) __I,
+                                                (__v16si) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_permutex2var_epi32(__m512i __A, __mmask16 __U, __m512i __I,
+                               __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                              (__v16si)_mm512_permutex2var_epi32(__A, __I, __B),
+                              (__v16si)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask2_permutex2var_epi32(__m512i __A, __m512i __I, __mmask16 __U,
+                                __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                              (__v16si)_mm512_permutex2var_epi32(__A, __I, __B),
+                              (__v16si)__I);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutex2var_epi32(__mmask16 __U, __m512i __A, __m512i __I,
+                                __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                              (__v16si)_mm512_permutex2var_epi32(__A, __I, __B),
+                              (__v16si)_mm512_setzero_si512());
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_permutex2var_epi64(__m512i __A, __m512i __I, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_vpermi2varq512((__v8di)__A, (__v8di) __I,
+                                                (__v8di) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_permutex2var_epi64(__m512i __A, __mmask8 __U, __m512i __I,
+                               __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                               (__v8di)_mm512_permutex2var_epi64(__A, __I, __B),
+                               (__v8di)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask2_permutex2var_epi64(__m512i __A, __m512i __I, __mmask8 __U,
+                                __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                               (__v8di)_mm512_permutex2var_epi64(__A, __I, __B),
+                               (__v8di)__I);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutex2var_epi64(__mmask8 __U, __m512i __A, __m512i __I,
+                                __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                               (__v8di)_mm512_permutex2var_epi64(__A, __I, __B),
+                               (__v8di)_mm512_setzero_si512());
+}
+
+#define _mm512_alignr_epi64(A, B, I) \
+  ((__m512i)__builtin_ia32_alignq512((__v8di)(__m512i)(A), \
+                                     (__v8di)(__m512i)(B), (int)(I)))
+
+#define _mm512_mask_alignr_epi64(W, U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                  (__v8di)_mm512_alignr_epi64((A), (B), (imm)), \
+                                  (__v8di)(__m512i)(W)))
+
+#define _mm512_maskz_alignr_epi64(U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                  (__v8di)_mm512_alignr_epi64((A), (B), (imm)), \
+                                  (__v8di)_mm512_setzero_si512()))
+
+#define _mm512_alignr_epi32(A, B, I) \
+  ((__m512i)__builtin_ia32_alignd512((__v16si)(__m512i)(A), \
+                                     (__v16si)(__m512i)(B), (int)(I)))
+
+#define _mm512_mask_alignr_epi32(W, U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                 (__v16si)_mm512_alignr_epi32((A), (B), (imm)), \
+                                 (__v16si)(__m512i)(W)))
+
+#define _mm512_maskz_alignr_epi32(U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                 (__v16si)_mm512_alignr_epi32((A), (B), (imm)), \
+                                 (__v16si)_mm512_setzero_si512()))
+/* Vector Extract */
+
+#define _mm512_extractf64x4_pd(A, I) \
+  ((__m256d)__builtin_ia32_extractf64x4_mask((__v8df)(__m512d)(A), (int)(I), \
+                                             (__v4df)_mm256_undefined_pd(), \
+                                             (__mmask8)-1))
+
+#define _mm512_mask_extractf64x4_pd(W, U, A, imm) \
+  ((__m256d)__builtin_ia32_extractf64x4_mask((__v8df)(__m512d)(A), (int)(imm), \
+                                             (__v4df)(__m256d)(W), \
+                                             (__mmask8)(U)))
+
+#define _mm512_maskz_extractf64x4_pd(U, A, imm) \
+  ((__m256d)__builtin_ia32_extractf64x4_mask((__v8df)(__m512d)(A), (int)(imm), \
+                                             (__v4df)_mm256_setzero_pd(), \
+                                             (__mmask8)(U)))
+
+#define _mm512_extractf32x4_ps(A, I) \
+  ((__m128)__builtin_ia32_extractf32x4_mask((__v16sf)(__m512)(A), (int)(I), \
+                                            (__v4sf)_mm_undefined_ps(), \
+                                            (__mmask8)-1))
+
+#define _mm512_mask_extractf32x4_ps(W, U, A, imm) \
+  ((__m128)__builtin_ia32_extractf32x4_mask((__v16sf)(__m512)(A), (int)(imm), \
+                                            (__v4sf)(__m128)(W), \
+                                            (__mmask8)(U)))
+
+#define _mm512_maskz_extractf32x4_ps(U, A, imm) \
+  ((__m128)__builtin_ia32_extractf32x4_mask((__v16sf)(__m512)(A), (int)(imm), \
+                                            (__v4sf)_mm_setzero_ps(), \
+                                            (__mmask8)(U)))
+
+/* Vector Blend */
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_blend_pd(__mmask8 __U, __m512d __A, __m512d __W)
+{
+  return (__m512d) __builtin_ia32_selectpd_512 ((__mmask8) __U,
+                 (__v8df) __W,
+                 (__v8df) __A);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_blend_ps(__mmask16 __U, __m512 __A, __m512 __W)
+{
+  return (__m512) __builtin_ia32_selectps_512 ((__mmask16) __U,
+                (__v16sf) __W,
+                (__v16sf) __A);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_blend_epi64(__mmask8 __U, __m512i __A, __m512i __W)
+{
+  return (__m512i) __builtin_ia32_selectq_512 ((__mmask8) __U,
+                (__v8di) __W,
+                (__v8di) __A);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_blend_epi32(__mmask16 __U, __m512i __A, __m512i __W)
+{
+  return (__m512i) __builtin_ia32_selectd_512 ((__mmask16) __U,
+                (__v16si) __W,
+                (__v16si) __A);
+}
+
+/* Compare */
+
+#define _mm512_cmp_round_ps_mask(A, B, P, R) \
+  ((__mmask16)__builtin_ia32_cmpps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)(__m512)(B), (int)(P), \
+                                           (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_cmp_round_ps_mask(U, A, B, P, R) \
+  ((__mmask16)__builtin_ia32_cmpps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)(__m512)(B), (int)(P), \
+                                           (__mmask16)(U), (int)(R)))
+
+#define _mm512_cmp_ps_mask(A, B, P) \
+  _mm512_cmp_round_ps_mask((A), (B), (P), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_mask_cmp_ps_mask(U, A, B, P) \
+  _mm512_mask_cmp_round_ps_mask((U), (A), (B), (P), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_cmpeq_ps_mask(A, B) \
+    _mm512_cmp_ps_mask((A), (B), _CMP_EQ_OQ)
+#define _mm512_mask_cmpeq_ps_mask(k, A, B) \
+    _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_EQ_OQ)
+
+#define _mm512_cmplt_ps_mask(A, B) \
+    _mm512_cmp_ps_mask((A), (B), _CMP_LT_OS)
+#define _mm512_mask_cmplt_ps_mask(k, A, B) \
+    _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_LT_OS)
+
+#define _mm512_cmple_ps_mask(A, B) \
+    _mm512_cmp_ps_mask((A), (B), _CMP_LE_OS)
+#define _mm512_mask_cmple_ps_mask(k, A, B) \
+    _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_LE_OS)
+
+#define _mm512_cmpunord_ps_mask(A, B) \
+    _mm512_cmp_ps_mask((A), (B), _CMP_UNORD_Q)
+#define _mm512_mask_cmpunord_ps_mask(k, A, B) \
+    _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_UNORD_Q)
+
+#define _mm512_cmpneq_ps_mask(A, B) \
+    _mm512_cmp_ps_mask((A), (B), _CMP_NEQ_UQ)
+#define _mm512_mask_cmpneq_ps_mask(k, A, B) \
+    _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_NEQ_UQ)
+
+#define _mm512_cmpnlt_ps_mask(A, B) \
+    _mm512_cmp_ps_mask((A), (B), _CMP_NLT_US)
+#define _mm512_mask_cmpnlt_ps_mask(k, A, B) \
+    _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_NLT_US)
+
+#define _mm512_cmpnle_ps_mask(A, B) \
+    _mm512_cmp_ps_mask((A), (B), _CMP_NLE_US)
+#define _mm512_mask_cmpnle_ps_mask(k, A, B) \
+    _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_NLE_US)
+
+#define _mm512_cmpord_ps_mask(A, B) \
+    _mm512_cmp_ps_mask((A), (B), _CMP_ORD_Q)
+#define _mm512_mask_cmpord_ps_mask(k, A, B) \
+    _mm512_mask_cmp_ps_mask((k), (A), (B), _CMP_ORD_Q)
+
+#define _mm512_cmp_round_pd_mask(A, B, P, R) \
+  ((__mmask8)__builtin_ia32_cmppd512_mask((__v8df)(__m512d)(A), \
+                                          (__v8df)(__m512d)(B), (int)(P), \
+                                          (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cmp_round_pd_mask(U, A, B, P, R) \
+  ((__mmask8)__builtin_ia32_cmppd512_mask((__v8df)(__m512d)(A), \
+                                          (__v8df)(__m512d)(B), (int)(P), \
+                                          (__mmask8)(U), (int)(R)))
+
+#define _mm512_cmp_pd_mask(A, B, P) \
+  _mm512_cmp_round_pd_mask((A), (B), (P), _MM_FROUND_CUR_DIRECTION)
+#define _mm512_mask_cmp_pd_mask(U, A, B, P) \
+  _mm512_mask_cmp_round_pd_mask((U), (A), (B), (P), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_cmpeq_pd_mask(A, B) \
+    _mm512_cmp_pd_mask((A), (B), _CMP_EQ_OQ)
+#define _mm512_mask_cmpeq_pd_mask(k, A, B) \
+    _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_EQ_OQ)
+
+#define _mm512_cmplt_pd_mask(A, B) \
+    _mm512_cmp_pd_mask((A), (B), _CMP_LT_OS)
+#define _mm512_mask_cmplt_pd_mask(k, A, B) \
+    _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_LT_OS)
+
+#define _mm512_cmple_pd_mask(A, B) \
+    _mm512_cmp_pd_mask((A), (B), _CMP_LE_OS)
+#define _mm512_mask_cmple_pd_mask(k, A, B) \
+    _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_LE_OS)
+
+#define _mm512_cmpunord_pd_mask(A, B) \
+    _mm512_cmp_pd_mask((A), (B), _CMP_UNORD_Q)
+#define _mm512_mask_cmpunord_pd_mask(k, A, B) \
+    _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_UNORD_Q)
+
+#define _mm512_cmpneq_pd_mask(A, B) \
+    _mm512_cmp_pd_mask((A), (B), _CMP_NEQ_UQ)
+#define _mm512_mask_cmpneq_pd_mask(k, A, B) \
+    _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_NEQ_UQ)
+
+#define _mm512_cmpnlt_pd_mask(A, B) \
+    _mm512_cmp_pd_mask((A), (B), _CMP_NLT_US)
+#define _mm512_mask_cmpnlt_pd_mask(k, A, B) \
+    _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_NLT_US)
+
+#define _mm512_cmpnle_pd_mask(A, B) \
+    _mm512_cmp_pd_mask((A), (B), _CMP_NLE_US)
+#define _mm512_mask_cmpnle_pd_mask(k, A, B) \
+    _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_NLE_US)
+
+#define _mm512_cmpord_pd_mask(A, B) \
+    _mm512_cmp_pd_mask((A), (B), _CMP_ORD_Q)
+#define _mm512_mask_cmpord_pd_mask(k, A, B) \
+    _mm512_mask_cmp_pd_mask((k), (A), (B), _CMP_ORD_Q)
+
+/* Conversion */
+
+#define _mm512_cvtt_roundps_epu32(A, R) \
+  ((__m512i)__builtin_ia32_cvttps2udq512_mask((__v16sf)(__m512)(A), \
+                                              (__v16si)_mm512_undefined_epi32(), \
+                                              (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_cvtt_roundps_epu32(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvttps2udq512_mask((__v16sf)(__m512)(A), \
+                                              (__v16si)(__m512i)(W), \
+                                              (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundps_epu32(U, A, R) \
+  ((__m512i)__builtin_ia32_cvttps2udq512_mask((__v16sf)(__m512)(A), \
+                                              (__v16si)_mm512_setzero_si512(), \
+                                              (__mmask16)(U), (int)(R)))
+
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttps_epu32(__m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvttps2udq512_mask ((__v16sf) __A,
+                  (__v16si)
+                  _mm512_setzero_si512 (),
+                  (__mmask16) -1,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttps_epu32 (__m512i __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvttps2udq512_mask ((__v16sf) __A,
+                   (__v16si) __W,
+                   (__mmask16) __U,
+                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttps_epu32 (__mmask16 __U, __m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvttps2udq512_mask ((__v16sf) __A,
+                   (__v16si) _mm512_setzero_si512 (),
+                   (__mmask16) __U,
+                   _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundepi32_ps(A, R) \
+  ((__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(__m512i)(A), \
+                                           (__v16sf)_mm512_setzero_ps(), \
+                                           (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundepi32_ps(W, U, A, R) \
+  ((__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(__m512i)(A), \
+                                           (__v16sf)(__m512)(W), \
+                                           (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundepi32_ps(U, A, R) \
+  ((__m512)__builtin_ia32_cvtdq2ps512_mask((__v16si)(__m512i)(A), \
+                                           (__v16sf)_mm512_setzero_ps(), \
+                                           (__mmask16)(U), (int)(R)))
+
+#define _mm512_cvt_roundepu32_ps(A, R) \
+  ((__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(__m512i)(A), \
+                                            (__v16sf)_mm512_setzero_ps(), \
+                                            (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundepu32_ps(W, U, A, R) \
+  ((__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(__m512i)(A), \
+                                            (__v16sf)(__m512)(W), \
+                                            (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundepu32_ps(U, A, R) \
+  ((__m512)__builtin_ia32_cvtudq2ps512_mask((__v16si)(__m512i)(A), \
+                                            (__v16sf)_mm512_setzero_ps(), \
+                                            (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_cvtepu32_ps (__m512i __A)
+{
+  return (__m512)__builtin_convertvector((__v16su)__A, __v16sf);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu32_ps (__m512 __W, __mmask16 __U, __m512i __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_cvtepu32_ps(__A),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu32_ps (__mmask16 __U, __m512i __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_cvtepu32_ps(__A),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_cvtepi32_pd(__m256i __A)
+{
+  return (__m512d)__builtin_convertvector((__v8si)__A, __v8df);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi32_pd (__m512d __W, __mmask8 __U, __m256i __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U,
+                                              (__v8df)_mm512_cvtepi32_pd(__A),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi32_pd (__mmask8 __U, __m256i __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U,
+                                              (__v8df)_mm512_cvtepi32_pd(__A),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_cvtepi32lo_pd(__m512i __A)
+{
+  return (__m512d) _mm512_cvtepi32_pd(_mm512_castsi512_si256(__A));
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi32lo_pd(__m512d __W, __mmask8 __U,__m512i __A)
+{
+  return (__m512d) _mm512_mask_cvtepi32_pd(__W, __U, _mm512_castsi512_si256(__A));
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_cvtepi32_ps (__m512i __A)
+{
+  return (__m512)__builtin_convertvector((__v16si)__A, __v16sf);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi32_ps (__m512 __W, __mmask16 __U, __m512i __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_cvtepi32_ps(__A),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi32_ps (__mmask16 __U, __m512i __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_cvtepi32_ps(__A),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_cvtepu32_pd(__m256i __A)
+{
+  return (__m512d)__builtin_convertvector((__v8su)__A, __v8df);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu32_pd (__m512d __W, __mmask8 __U, __m256i __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U,
+                                              (__v8df)_mm512_cvtepu32_pd(__A),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu32_pd (__mmask8 __U, __m256i __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U,
+                                              (__v8df)_mm512_cvtepu32_pd(__A),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_cvtepu32lo_pd(__m512i __A)
+{
+  return (__m512d) _mm512_cvtepu32_pd(_mm512_castsi512_si256(__A));
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu32lo_pd(__m512d __W, __mmask8 __U,__m512i __A)
+{
+  return (__m512d) _mm512_mask_cvtepu32_pd(__W, __U, _mm512_castsi512_si256(__A));
+}
+
+#define _mm512_cvt_roundpd_ps(A, R) \
+  ((__m256)__builtin_ia32_cvtpd2ps512_mask((__v8df)(__m512d)(A), \
+                                           (__v8sf)_mm256_setzero_ps(), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundpd_ps(W, U, A, R) \
+  ((__m256)__builtin_ia32_cvtpd2ps512_mask((__v8df)(__m512d)(A), \
+                                           (__v8sf)(__m256)(W), (__mmask8)(U), \
+                                           (int)(R)))
+
+#define _mm512_maskz_cvt_roundpd_ps(U, A, R) \
+  ((__m256)__builtin_ia32_cvtpd2ps512_mask((__v8df)(__m512d)(A), \
+                                           (__v8sf)_mm256_setzero_ps(), \
+                                           (__mmask8)(U), (int)(R)))
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS512
+_mm512_cvtpd_ps (__m512d __A)
+{
+  return (__m256) __builtin_ia32_cvtpd2ps512_mask ((__v8df) __A,
+                (__v8sf) _mm256_undefined_ps (),
+                (__mmask8) -1,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtpd_ps (__m256 __W, __mmask8 __U, __m512d __A)
+{
+  return (__m256) __builtin_ia32_cvtpd2ps512_mask ((__v8df) __A,
+                (__v8sf) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtpd_ps (__mmask8 __U, __m512d __A)
+{
+  return (__m256) __builtin_ia32_cvtpd2ps512_mask ((__v8df) __A,
+                (__v8sf) _mm256_setzero_ps (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_cvtpd_pslo (__m512d __A)
+{
+  return (__m512) __builtin_shufflevector((__v8sf) _mm512_cvtpd_ps(__A),
+                (__v8sf) _mm256_setzero_ps (),
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtpd_pslo (__m512 __W, __mmask8 __U,__m512d __A)
+{
+  return (__m512) __builtin_shufflevector (
+                (__v8sf) _mm512_mask_cvtpd_ps (_mm512_castps512_ps256(__W),
+                                               __U, __A),
+                (__v8sf) _mm256_setzero_ps (),
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+
+#define _mm512_cvt_roundps_ph(A, I) \
+  ((__m256i)__builtin_ia32_vcvtps2ph512_mask((__v16sf)(__m512)(A), (int)(I), \
+                                             (__v16hi)_mm256_undefined_si256(), \
+                                             (__mmask16)-1))
+
+#define _mm512_mask_cvt_roundps_ph(U, W, A, I) \
+  ((__m256i)__builtin_ia32_vcvtps2ph512_mask((__v16sf)(__m512)(A), (int)(I), \
+                                             (__v16hi)(__m256i)(U), \
+                                             (__mmask16)(W)))
+
+#define _mm512_maskz_cvt_roundps_ph(W, A, I) \
+  ((__m256i)__builtin_ia32_vcvtps2ph512_mask((__v16sf)(__m512)(A), (int)(I), \
+                                             (__v16hi)_mm256_setzero_si256(), \
+                                             (__mmask16)(W)))
+
+#define _mm512_cvtps_ph       _mm512_cvt_roundps_ph
+#define _mm512_mask_cvtps_ph  _mm512_mask_cvt_roundps_ph
+#define _mm512_maskz_cvtps_ph _mm512_maskz_cvt_roundps_ph
+
+#define _mm512_cvt_roundph_ps(A, R) \
+  ((__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(__m256i)(A), \
+                                            (__v16sf)_mm512_undefined_ps(), \
+                                            (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundph_ps(W, U, A, R) \
+  ((__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(__m256i)(A), \
+                                            (__v16sf)(__m512)(W), \
+                                            (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundph_ps(U, A, R) \
+  ((__m512)__builtin_ia32_vcvtph2ps512_mask((__v16hi)(__m256i)(A), \
+                                            (__v16sf)_mm512_setzero_ps(), \
+                                            (__mmask16)(U), (int)(R)))
+
+
+static  __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_cvtph_ps(__m256i __A)
+{
+  return (__m512) __builtin_ia32_vcvtph2ps512_mask ((__v16hi) __A,
+                (__v16sf)
+                _mm512_setzero_ps (),
+                (__mmask16) -1,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtph_ps (__m512 __W, __mmask16 __U, __m256i __A)
+{
+  return (__m512) __builtin_ia32_vcvtph2ps512_mask ((__v16hi) __A,
+                 (__v16sf) __W,
+                 (__mmask16) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtph_ps (__mmask16 __U, __m256i __A)
+{
+  return (__m512) __builtin_ia32_vcvtph2ps512_mask ((__v16hi) __A,
+                 (__v16sf) _mm512_setzero_ps (),
+                 (__mmask16) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundpd_epi32(A, R) \
+  ((__m256i)__builtin_ia32_cvttpd2dq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8si)_mm256_setzero_si256(), \
+                                             (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvtt_roundpd_epi32(W, U, A, R) \
+  ((__m256i)__builtin_ia32_cvttpd2dq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8si)(__m256i)(W), \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundpd_epi32(U, A, R) \
+  ((__m256i)__builtin_ia32_cvttpd2dq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8si)_mm256_setzero_si256(), \
+                                             (__mmask8)(U), (int)(R)))
+
+static __inline __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvttpd_epi32(__m512d __a)
+{
+  return (__m256i)__builtin_ia32_cvttpd2dq512_mask((__v8df) __a,
+                                                   (__v8si)_mm256_setzero_si256(),
+                                                   (__mmask8) -1,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvttpd2dq512_mask ((__v8df) __A,
+                  (__v8si) __W,
+                  (__mmask8) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttpd_epi32 (__mmask8 __U, __m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvttpd2dq512_mask ((__v8df) __A,
+                  (__v8si) _mm256_setzero_si256 (),
+                  (__mmask8) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundps_epi32(A, R) \
+  ((__m512i)__builtin_ia32_cvttps2dq512_mask((__v16sf)(__m512)(A), \
+                                             (__v16si)_mm512_setzero_si512(), \
+                                             (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_cvtt_roundps_epi32(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvttps2dq512_mask((__v16sf)(__m512)(A), \
+                                             (__v16si)(__m512i)(W), \
+                                             (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundps_epi32(U, A, R) \
+  ((__m512i)__builtin_ia32_cvttps2dq512_mask((__v16sf)(__m512)(A), \
+                                             (__v16si)_mm512_setzero_si512(), \
+                                             (__mmask16)(U), (int)(R)))
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttps_epi32(__m512 __a)
+{
+  return (__m512i)
+    __builtin_ia32_cvttps2dq512_mask((__v16sf) __a,
+                                     (__v16si) _mm512_setzero_si512 (),
+                                     (__mmask16) -1, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttps_epi32 (__m512i __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvttps2dq512_mask ((__v16sf) __A,
+                  (__v16si) __W,
+                  (__mmask16) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttps_epi32 (__mmask16 __U, __m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvttps2dq512_mask ((__v16sf) __A,
+                  (__v16si) _mm512_setzero_si512 (),
+                  (__mmask16) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundps_epi32(A, R) \
+  ((__m512i)__builtin_ia32_cvtps2dq512_mask((__v16sf)(__m512)(A), \
+                                            (__v16si)_mm512_setzero_si512(), \
+                                            (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundps_epi32(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvtps2dq512_mask((__v16sf)(__m512)(A), \
+                                            (__v16si)(__m512i)(W), \
+                                            (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundps_epi32(U, A, R) \
+  ((__m512i)__builtin_ia32_cvtps2dq512_mask((__v16sf)(__m512)(A), \
+                                            (__v16si)_mm512_setzero_si512(), \
+                                            (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtps_epi32 (__m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvtps2dq512_mask ((__v16sf) __A,
+                 (__v16si) _mm512_undefined_epi32 (),
+                 (__mmask16) -1,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtps_epi32 (__m512i __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvtps2dq512_mask ((__v16sf) __A,
+                 (__v16si) __W,
+                 (__mmask16) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtps_epi32 (__mmask16 __U, __m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvtps2dq512_mask ((__v16sf) __A,
+                 (__v16si)
+                 _mm512_setzero_si512 (),
+                 (__mmask16) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundpd_epi32(A, R) \
+  ((__m256i)__builtin_ia32_cvtpd2dq512_mask((__v8df)(__m512d)(A), \
+                                            (__v8si)_mm256_setzero_si256(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundpd_epi32(W, U, A, R) \
+  ((__m256i)__builtin_ia32_cvtpd2dq512_mask((__v8df)(__m512d)(A), \
+                                            (__v8si)(__m256i)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundpd_epi32(U, A, R) \
+  ((__m256i)__builtin_ia32_cvtpd2dq512_mask((__v8df)(__m512d)(A), \
+                                            (__v8si)_mm256_setzero_si256(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtpd_epi32 (__m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvtpd2dq512_mask ((__v8df) __A,
+                 (__v8si)
+                 _mm256_undefined_si256 (),
+                 (__mmask8) -1,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtpd_epi32 (__m256i __W, __mmask8 __U, __m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvtpd2dq512_mask ((__v8df) __A,
+                 (__v8si) __W,
+                 (__mmask8) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtpd_epi32 (__mmask8 __U, __m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvtpd2dq512_mask ((__v8df) __A,
+                 (__v8si)
+                 _mm256_setzero_si256 (),
+                 (__mmask8) __U,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundps_epu32(A, R) \
+  ((__m512i)__builtin_ia32_cvtps2udq512_mask((__v16sf)(__m512)(A), \
+                                             (__v16si)_mm512_setzero_si512(), \
+                                             (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundps_epu32(W, U, A, R) \
+  ((__m512i)__builtin_ia32_cvtps2udq512_mask((__v16sf)(__m512)(A), \
+                                             (__v16si)(__m512i)(W), \
+                                             (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundps_epu32(U, A, R) \
+  ((__m512i)__builtin_ia32_cvtps2udq512_mask((__v16sf)(__m512)(A), \
+                                             (__v16si)_mm512_setzero_si512(), \
+                                             (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtps_epu32 ( __m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvtps2udq512_mask ((__v16sf) __A,\
+                  (__v16si)\
+                  _mm512_undefined_epi32 (),
+                  (__mmask16) -1,\
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtps_epu32 (__m512i __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvtps2udq512_mask ((__v16sf) __A,
+                  (__v16si) __W,
+                  (__mmask16) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtps_epu32 ( __mmask16 __U, __m512 __A)
+{
+  return (__m512i) __builtin_ia32_cvtps2udq512_mask ((__v16sf) __A,
+                  (__v16si)
+                  _mm512_setzero_si512 (),
+                  (__mmask16) __U ,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundpd_epu32(A, R) \
+  ((__m256i)__builtin_ia32_cvtpd2udq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8si)_mm256_setzero_si256(), \
+                                             (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundpd_epu32(W, U, A, R) \
+  ((__m256i)__builtin_ia32_cvtpd2udq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8si)(__m256i)(W), \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundpd_epu32(U, A, R) \
+  ((__m256i)__builtin_ia32_cvtpd2udq512_mask((__v8df)(__m512d)(A), \
+                                             (__v8si)_mm256_setzero_si256(), \
+                                             (__mmask8)(U), (int)(R)))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtpd_epu32 (__m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvtpd2udq512_mask ((__v8df) __A,
+                  (__v8si)
+                  _mm256_undefined_si256 (),
+                  (__mmask8) -1,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtpd_epu32 (__m256i __W, __mmask8 __U, __m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvtpd2udq512_mask ((__v8df) __A,
+                  (__v8si) __W,
+                  (__mmask8) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtpd_epu32 (__mmask8 __U, __m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvtpd2udq512_mask ((__v8df) __A,
+                  (__v8si)
+                  _mm256_setzero_si256 (),
+                  (__mmask8) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ double __DEFAULT_FN_ATTRS512
+_mm512_cvtsd_f64(__m512d __a)
+{
+  return __a[0];
+}
+
+static __inline__ float __DEFAULT_FN_ATTRS512
+_mm512_cvtss_f32(__m512 __a)
+{
+  return __a[0];
+}
+
+/* Unpack and Interleave */
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_unpackhi_pd(__m512d __a, __m512d __b)
+{
+  return (__m512d)__builtin_shufflevector((__v8df)__a, (__v8df)__b,
+                                          1, 9, 1+2, 9+2, 1+4, 9+4, 1+6, 9+6);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_unpackhi_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U,
+                                           (__v8df)_mm512_unpackhi_pd(__A, __B),
+                                           (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpackhi_pd(__mmask8 __U, __m512d __A, __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U,
+                                           (__v8df)_mm512_unpackhi_pd(__A, __B),
+                                           (__v8df)_mm512_setzero_pd());
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_unpacklo_pd(__m512d __a, __m512d __b)
+{
+  return (__m512d)__builtin_shufflevector((__v8df)__a, (__v8df)__b,
+                                          0, 8, 0+2, 8+2, 0+4, 8+4, 0+6, 8+6);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_unpacklo_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U,
+                                           (__v8df)_mm512_unpacklo_pd(__A, __B),
+                                           (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpacklo_pd (__mmask8 __U, __m512d __A, __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8) __U,
+                                           (__v8df)_mm512_unpacklo_pd(__A, __B),
+                                           (__v8df)_mm512_setzero_pd());
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_unpackhi_ps(__m512 __a, __m512 __b)
+{
+  return (__m512)__builtin_shufflevector((__v16sf)__a, (__v16sf)__b,
+                                         2,    18,    3,    19,
+                                         2+4,  18+4,  3+4,  19+4,
+                                         2+8,  18+8,  3+8,  19+8,
+                                         2+12, 18+12, 3+12, 19+12);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_unpackhi_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16) __U,
+                                          (__v16sf)_mm512_unpackhi_ps(__A, __B),
+                                          (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpackhi_ps (__mmask16 __U, __m512 __A, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16) __U,
+                                          (__v16sf)_mm512_unpackhi_ps(__A, __B),
+                                          (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_unpacklo_ps(__m512 __a, __m512 __b)
+{
+  return (__m512)__builtin_shufflevector((__v16sf)__a, (__v16sf)__b,
+                                         0,    16,    1,    17,
+                                         0+4,  16+4,  1+4,  17+4,
+                                         0+8,  16+8,  1+8,  17+8,
+                                         0+12, 16+12, 1+12, 17+12);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_unpacklo_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16) __U,
+                                          (__v16sf)_mm512_unpacklo_ps(__A, __B),
+                                          (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpacklo_ps (__mmask16 __U, __m512 __A, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16) __U,
+                                          (__v16sf)_mm512_unpacklo_ps(__A, __B),
+                                          (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_unpackhi_epi32(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_shufflevector((__v16si)__A, (__v16si)__B,
+                                          2,    18,    3,    19,
+                                          2+4,  18+4,  3+4,  19+4,
+                                          2+8,  18+8,  3+8,  19+8,
+                                          2+12, 18+12, 3+12, 19+12);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_unpackhi_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16) __U,
+                                       (__v16si)_mm512_unpackhi_epi32(__A, __B),
+                                       (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpackhi_epi32(__mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16) __U,
+                                       (__v16si)_mm512_unpackhi_epi32(__A, __B),
+                                       (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_unpacklo_epi32(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_shufflevector((__v16si)__A, (__v16si)__B,
+                                          0,    16,    1,    17,
+                                          0+4,  16+4,  1+4,  17+4,
+                                          0+8,  16+8,  1+8,  17+8,
+                                          0+12, 16+12, 1+12, 17+12);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_unpacklo_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16) __U,
+                                       (__v16si)_mm512_unpacklo_epi32(__A, __B),
+                                       (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpacklo_epi32(__mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16) __U,
+                                       (__v16si)_mm512_unpacklo_epi32(__A, __B),
+                                       (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_unpackhi_epi64(__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_shufflevector((__v8di)__A, (__v8di)__B,
+                                          1, 9, 1+2, 9+2, 1+4, 9+4, 1+6, 9+6);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_unpackhi_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8) __U,
+                                        (__v8di)_mm512_unpackhi_epi64(__A, __B),
+                                        (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpackhi_epi64(__mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8) __U,
+                                        (__v8di)_mm512_unpackhi_epi64(__A, __B),
+                                        (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_unpacklo_epi64 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_shufflevector((__v8di)__A, (__v8di)__B,
+                                          0, 8, 0+2, 8+2, 0+4, 8+4, 0+6, 8+6);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_unpacklo_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8) __U,
+                                        (__v8di)_mm512_unpacklo_epi64(__A, __B),
+                                        (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_unpacklo_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8) __U,
+                                        (__v8di)_mm512_unpacklo_epi64(__A, __B),
+                                        (__v8di)_mm512_setzero_si512());
+}
+
+
+/* SIMD load ops */
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_loadu_si512 (void const *__P)
+{
+  struct __loadu_si512 {
+    __m512i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_si512*)__P)->__v;
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_loadu_epi32 (void const *__P)
+{
+  struct __loadu_epi32 {
+    __m512i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi32*)__P)->__v;
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_loadu_epi32 (__m512i __W, __mmask16 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_loaddqusi512_mask ((const int *) __P,
+                  (__v16si) __W,
+                  (__mmask16) __U);
+}
+
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_loadu_epi32(__mmask16 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_loaddqusi512_mask ((const int *)__P,
+                                                     (__v16si)
+                                                     _mm512_setzero_si512 (),
+                                                     (__mmask16) __U);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_loadu_epi64 (void const *__P)
+{
+  struct __loadu_epi64 {
+    __m512i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi64*)__P)->__v;
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_loadu_epi64 (__m512i __W, __mmask8 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_loaddqudi512_mask ((const long long *) __P,
+                  (__v8di) __W,
+                  (__mmask8) __U);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_loadu_epi64(__mmask8 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_loaddqudi512_mask ((const long long *)__P,
+                                                     (__v8di)
+                                                     _mm512_setzero_si512 (),
+                                                     (__mmask8) __U);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_loadu_ps (__m512 __W, __mmask16 __U, void const *__P)
+{
+  return (__m512) __builtin_ia32_loadups512_mask ((const float *) __P,
+                   (__v16sf) __W,
+                   (__mmask16) __U);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_loadu_ps(__mmask16 __U, void const *__P)
+{
+  return (__m512) __builtin_ia32_loadups512_mask ((const float *)__P,
+                                                  (__v16sf)
+                                                  _mm512_setzero_ps (),
+                                                  (__mmask16) __U);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_loadu_pd (__m512d __W, __mmask8 __U, void const *__P)
+{
+  return (__m512d) __builtin_ia32_loadupd512_mask ((const double *) __P,
+                (__v8df) __W,
+                (__mmask8) __U);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_loadu_pd(__mmask8 __U, void const *__P)
+{
+  return (__m512d) __builtin_ia32_loadupd512_mask ((const double *)__P,
+                                                   (__v8df)
+                                                   _mm512_setzero_pd (),
+                                                   (__mmask8) __U);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_loadu_pd(void const *__p)
+{
+  struct __loadu_pd {
+    __m512d_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_pd*)__p)->__v;
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_loadu_ps(void const *__p)
+{
+  struct __loadu_ps {
+    __m512_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_ps*)__p)->__v;
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_load_ps(void const *__p)
+{
+  return *(const __m512*)__p;
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_load_ps (__m512 __W, __mmask16 __U, void const *__P)
+{
+  return (__m512) __builtin_ia32_loadaps512_mask ((const __v16sf *) __P,
+                   (__v16sf) __W,
+                   (__mmask16) __U);
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_load_ps(__mmask16 __U, void const *__P)
+{
+  return (__m512) __builtin_ia32_loadaps512_mask ((const __v16sf *)__P,
+                                                  (__v16sf)
+                                                  _mm512_setzero_ps (),
+                                                  (__mmask16) __U);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_load_pd(void const *__p)
+{
+  return *(const __m512d*)__p;
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_load_pd (__m512d __W, __mmask8 __U, void const *__P)
+{
+  return (__m512d) __builtin_ia32_loadapd512_mask ((const __v8df *) __P,
+                          (__v8df) __W,
+                          (__mmask8) __U);
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_load_pd(__mmask8 __U, void const *__P)
+{
+  return (__m512d) __builtin_ia32_loadapd512_mask ((const __v8df *)__P,
+                                                   (__v8df)
+                                                   _mm512_setzero_pd (),
+                                                   (__mmask8) __U);
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_load_si512 (void const *__P)
+{
+  return *(const __m512i *) __P;
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_load_epi32 (void const *__P)
+{
+  return *(const __m512i *) __P;
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_load_epi64 (void const *__P)
+{
+  return *(const __m512i *) __P;
+}
+
+/* SIMD store ops */
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_storeu_epi64 (void *__P, __m512i __A)
+{
+  struct __storeu_epi64 {
+    __m512i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi64*)__P)->__v = __A;
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_mask_storeu_epi64(void *__P, __mmask8 __U, __m512i __A)
+{
+  __builtin_ia32_storedqudi512_mask ((long long *)__P, (__v8di) __A,
+                                     (__mmask8) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_storeu_si512 (void *__P, __m512i __A)
+{
+  struct __storeu_si512 {
+    __m512i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_si512*)__P)->__v = __A;
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_storeu_epi32 (void *__P, __m512i __A)
+{
+  struct __storeu_epi32 {
+    __m512i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi32*)__P)->__v = __A;
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_mask_storeu_epi32(void *__P, __mmask16 __U, __m512i __A)
+{
+  __builtin_ia32_storedqusi512_mask ((int *)__P, (__v16si) __A,
+                                     (__mmask16) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_mask_storeu_pd(void *__P, __mmask8 __U, __m512d __A)
+{
+  __builtin_ia32_storeupd512_mask ((double *)__P, (__v8df) __A, (__mmask8) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_storeu_pd(void *__P, __m512d __A)
+{
+  struct __storeu_pd {
+    __m512d_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_pd*)__P)->__v = __A;
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_mask_storeu_ps(void *__P, __mmask16 __U, __m512 __A)
+{
+  __builtin_ia32_storeups512_mask ((float *)__P, (__v16sf) __A,
+                                   (__mmask16) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_storeu_ps(void *__P, __m512 __A)
+{
+  struct __storeu_ps {
+    __m512_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_ps*)__P)->__v = __A;
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_mask_store_pd(void *__P, __mmask8 __U, __m512d __A)
+{
+  __builtin_ia32_storeapd512_mask ((__v8df *)__P, (__v8df) __A, (__mmask8) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_store_pd(void *__P, __m512d __A)
+{
+  *(__m512d*)__P = __A;
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_mask_store_ps(void *__P, __mmask16 __U, __m512 __A)
+{
+  __builtin_ia32_storeaps512_mask ((__v16sf *)__P, (__v16sf) __A,
+                                   (__mmask16) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_store_ps(void *__P, __m512 __A)
+{
+  *(__m512*)__P = __A;
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_store_si512 (void *__P, __m512i __A)
+{
+  *(__m512i *) __P = __A;
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_store_epi32 (void *__P, __m512i __A)
+{
+  *(__m512i *) __P = __A;
+}
+
+static __inline void __DEFAULT_FN_ATTRS512
+_mm512_store_epi64 (void *__P, __m512i __A)
+{
+  *(__m512i *) __P = __A;
+}
+
+/* Mask ops */
+
+static __inline __mmask16 __DEFAULT_FN_ATTRS
+_mm512_knot(__mmask16 __M)
+{
+  return __builtin_ia32_knothi(__M);
+}
+
+/* Integer compare */
+
+#define _mm512_cmpeq_epi32_mask(A, B) \
+    _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm512_mask_cmpeq_epi32_mask(k, A, B) \
+    _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm512_cmpge_epi32_mask(A, B) \
+    _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_GE)
+#define _mm512_mask_cmpge_epi32_mask(k, A, B) \
+    _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm512_cmpgt_epi32_mask(A, B) \
+    _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_GT)
+#define _mm512_mask_cmpgt_epi32_mask(k, A, B) \
+    _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm512_cmple_epi32_mask(A, B) \
+    _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_LE)
+#define _mm512_mask_cmple_epi32_mask(k, A, B) \
+    _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm512_cmplt_epi32_mask(A, B) \
+    _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_LT)
+#define _mm512_mask_cmplt_epi32_mask(k, A, B) \
+    _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm512_cmpneq_epi32_mask(A, B) \
+    _mm512_cmp_epi32_mask((A), (B), _MM_CMPINT_NE)
+#define _mm512_mask_cmpneq_epi32_mask(k, A, B) \
+    _mm512_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm512_cmpeq_epu32_mask(A, B) \
+    _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm512_mask_cmpeq_epu32_mask(k, A, B) \
+    _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm512_cmpge_epu32_mask(A, B) \
+    _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_GE)
+#define _mm512_mask_cmpge_epu32_mask(k, A, B) \
+    _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm512_cmpgt_epu32_mask(A, B) \
+    _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_GT)
+#define _mm512_mask_cmpgt_epu32_mask(k, A, B) \
+    _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm512_cmple_epu32_mask(A, B) \
+    _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_LE)
+#define _mm512_mask_cmple_epu32_mask(k, A, B) \
+    _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm512_cmplt_epu32_mask(A, B) \
+    _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_LT)
+#define _mm512_mask_cmplt_epu32_mask(k, A, B) \
+    _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm512_cmpneq_epu32_mask(A, B) \
+    _mm512_cmp_epu32_mask((A), (B), _MM_CMPINT_NE)
+#define _mm512_mask_cmpneq_epu32_mask(k, A, B) \
+    _mm512_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm512_cmpeq_epi64_mask(A, B) \
+    _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm512_mask_cmpeq_epi64_mask(k, A, B) \
+    _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm512_cmpge_epi64_mask(A, B) \
+    _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_GE)
+#define _mm512_mask_cmpge_epi64_mask(k, A, B) \
+    _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm512_cmpgt_epi64_mask(A, B) \
+    _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_GT)
+#define _mm512_mask_cmpgt_epi64_mask(k, A, B) \
+    _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm512_cmple_epi64_mask(A, B) \
+    _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_LE)
+#define _mm512_mask_cmple_epi64_mask(k, A, B) \
+    _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm512_cmplt_epi64_mask(A, B) \
+    _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_LT)
+#define _mm512_mask_cmplt_epi64_mask(k, A, B) \
+    _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm512_cmpneq_epi64_mask(A, B) \
+    _mm512_cmp_epi64_mask((A), (B), _MM_CMPINT_NE)
+#define _mm512_mask_cmpneq_epi64_mask(k, A, B) \
+    _mm512_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm512_cmpeq_epu64_mask(A, B) \
+    _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm512_mask_cmpeq_epu64_mask(k, A, B) \
+    _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm512_cmpge_epu64_mask(A, B) \
+    _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_GE)
+#define _mm512_mask_cmpge_epu64_mask(k, A, B) \
+    _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm512_cmpgt_epu64_mask(A, B) \
+    _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_GT)
+#define _mm512_mask_cmpgt_epu64_mask(k, A, B) \
+    _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm512_cmple_epu64_mask(A, B) \
+    _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_LE)
+#define _mm512_mask_cmple_epu64_mask(k, A, B) \
+    _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm512_cmplt_epu64_mask(A, B) \
+    _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_LT)
+#define _mm512_mask_cmplt_epu64_mask(k, A, B) \
+    _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm512_cmpneq_epu64_mask(A, B) \
+    _mm512_cmp_epu64_mask((A), (B), _MM_CMPINT_NE)
+#define _mm512_mask_cmpneq_epu64_mask(k, A, B) \
+    _mm512_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_NE)
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi8_epi32(__m128i __A)
+{
+  /* This function always performs a signed extension, but __v16qi is a char
+     which may be signed or unsigned, so use __v16qs. */
+  return (__m512i)__builtin_convertvector((__v16qs)__A, __v16si);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi8_epi32(__m512i __W, __mmask16 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                             (__v16si)_mm512_cvtepi8_epi32(__A),
+                                             (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi8_epi32(__mmask16 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                             (__v16si)_mm512_cvtepi8_epi32(__A),
+                                             (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi8_epi64(__m128i __A)
+{
+  /* This function always performs a signed extension, but __v16qi is a char
+     which may be signed or unsigned, so use __v16qs. */
+  return (__m512i)__builtin_convertvector(__builtin_shufflevector((__v16qs)__A, (__v16qs)__A, 0, 1, 2, 3, 4, 5, 6, 7), __v8di);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi8_epi64(__m512i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepi8_epi64(__A),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi8_epi64(__mmask8 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepi8_epi64(__A),
+                                             (__v8di)_mm512_setzero_si512 ());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi32_epi64(__m256i __X)
+{
+  return (__m512i)__builtin_convertvector((__v8si)__X, __v8di);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi32_epi64(__m512i __W, __mmask8 __U, __m256i __X)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepi32_epi64(__X),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi32_epi64(__mmask8 __U, __m256i __X)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepi32_epi64(__X),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi16_epi32(__m256i __A)
+{
+  return (__m512i)__builtin_convertvector((__v16hi)__A, __v16si);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi16_epi32(__m512i __W, __mmask16 __U, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                            (__v16si)_mm512_cvtepi16_epi32(__A),
+                                            (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi16_epi32(__mmask16 __U, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                            (__v16si)_mm512_cvtepi16_epi32(__A),
+                                            (__v16si)_mm512_setzero_si512 ());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi16_epi64(__m128i __A)
+{
+  return (__m512i)__builtin_convertvector((__v8hi)__A, __v8di);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi16_epi64(__m512i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepi16_epi64(__A),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi16_epi64(__mmask8 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepi16_epi64(__A),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepu8_epi32(__m128i __A)
+{
+  return (__m512i)__builtin_convertvector((__v16qu)__A, __v16si);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu8_epi32(__m512i __W, __mmask16 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                             (__v16si)_mm512_cvtepu8_epi32(__A),
+                                             (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu8_epi32(__mmask16 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                             (__v16si)_mm512_cvtepu8_epi32(__A),
+                                             (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepu8_epi64(__m128i __A)
+{
+  return (__m512i)__builtin_convertvector(__builtin_shufflevector((__v16qu)__A, (__v16qu)__A, 0, 1, 2, 3, 4, 5, 6, 7), __v8di);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu8_epi64(__m512i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepu8_epi64(__A),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu8_epi64(__mmask8 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepu8_epi64(__A),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepu32_epi64(__m256i __X)
+{
+  return (__m512i)__builtin_convertvector((__v8su)__X, __v8di);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu32_epi64(__m512i __W, __mmask8 __U, __m256i __X)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepu32_epi64(__X),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu32_epi64(__mmask8 __U, __m256i __X)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepu32_epi64(__X),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepu16_epi32(__m256i __A)
+{
+  return (__m512i)__builtin_convertvector((__v16hu)__A, __v16si);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu16_epi32(__m512i __W, __mmask16 __U, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                            (__v16si)_mm512_cvtepu16_epi32(__A),
+                                            (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu16_epi32(__mmask16 __U, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                            (__v16si)_mm512_cvtepu16_epi32(__A),
+                                            (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtepu16_epi64(__m128i __A)
+{
+  return (__m512i)__builtin_convertvector((__v8hu)__A, __v8di);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu16_epi64(__m512i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepu16_epi64(__A),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu16_epi64(__mmask8 __U, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_cvtepu16_epi64(__A),
+                                             (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_rorv_epi32 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_prorvd512((__v16si)__A, (__v16si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_rorv_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                           (__v16si)_mm512_rorv_epi32(__A, __B),
+                                           (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_rorv_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                           (__v16si)_mm512_rorv_epi32(__A, __B),
+                                           (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_rorv_epi64 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_prorvq512((__v8di)__A, (__v8di)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_rorv_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                                            (__v8di)_mm512_rorv_epi64(__A, __B),
+                                            (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_rorv_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                                            (__v8di)_mm512_rorv_epi64(__A, __B),
+                                            (__v8di)_mm512_setzero_si512());
+}
+
+
+
+#define _mm512_cmp_epi32_mask(a, b, p) \
+  ((__mmask16)__builtin_ia32_cmpd512_mask((__v16si)(__m512i)(a), \
+                                          (__v16si)(__m512i)(b), (int)(p), \
+                                          (__mmask16)-1))
+
+#define _mm512_cmp_epu32_mask(a, b, p) \
+  ((__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)(__m512i)(a), \
+                                           (__v16si)(__m512i)(b), (int)(p), \
+                                           (__mmask16)-1))
+
+#define _mm512_cmp_epi64_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpq512_mask((__v8di)(__m512i)(a), \
+                                         (__v8di)(__m512i)(b), (int)(p), \
+                                         (__mmask8)-1))
+
+#define _mm512_cmp_epu64_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)(__m512i)(a), \
+                                          (__v8di)(__m512i)(b), (int)(p), \
+                                          (__mmask8)-1))
+
+#define _mm512_mask_cmp_epi32_mask(m, a, b, p) \
+  ((__mmask16)__builtin_ia32_cmpd512_mask((__v16si)(__m512i)(a), \
+                                          (__v16si)(__m512i)(b), (int)(p), \
+                                          (__mmask16)(m)))
+
+#define _mm512_mask_cmp_epu32_mask(m, a, b, p) \
+  ((__mmask16)__builtin_ia32_ucmpd512_mask((__v16si)(__m512i)(a), \
+                                           (__v16si)(__m512i)(b), (int)(p), \
+                                           (__mmask16)(m)))
+
+#define _mm512_mask_cmp_epi64_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpq512_mask((__v8di)(__m512i)(a), \
+                                         (__v8di)(__m512i)(b), (int)(p), \
+                                         (__mmask8)(m)))
+
+#define _mm512_mask_cmp_epu64_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpq512_mask((__v8di)(__m512i)(a), \
+                                          (__v8di)(__m512i)(b), (int)(p), \
+                                          (__mmask8)(m)))
+
+#define _mm512_rol_epi32(a, b) \
+  ((__m512i)__builtin_ia32_prold512((__v16si)(__m512i)(a), (int)(b)))
+
+#define _mm512_mask_rol_epi32(W, U, a, b) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                       (__v16si)_mm512_rol_epi32((a), (b)), \
+                                       (__v16si)(__m512i)(W)))
+
+#define _mm512_maskz_rol_epi32(U, a, b) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                       (__v16si)_mm512_rol_epi32((a), (b)), \
+                                       (__v16si)_mm512_setzero_si512()))
+
+#define _mm512_rol_epi64(a, b) \
+  ((__m512i)__builtin_ia32_prolq512((__v8di)(__m512i)(a), (int)(b)))
+
+#define _mm512_mask_rol_epi64(W, U, a, b) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                       (__v8di)_mm512_rol_epi64((a), (b)), \
+                                       (__v8di)(__m512i)(W)))
+
+#define _mm512_maskz_rol_epi64(U, a, b) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                       (__v8di)_mm512_rol_epi64((a), (b)), \
+                                       (__v8di)_mm512_setzero_si512()))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_rolv_epi32 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_prolvd512((__v16si)__A, (__v16si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_rolv_epi32 (__m512i __W, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                           (__v16si)_mm512_rolv_epi32(__A, __B),
+                                           (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_rolv_epi32 (__mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                           (__v16si)_mm512_rolv_epi32(__A, __B),
+                                           (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_rolv_epi64 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_prolvq512((__v8di)__A, (__v8di)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_rolv_epi64 (__m512i __W, __mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                                            (__v8di)_mm512_rolv_epi64(__A, __B),
+                                            (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_rolv_epi64 (__mmask8 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                                            (__v8di)_mm512_rolv_epi64(__A, __B),
+                                            (__v8di)_mm512_setzero_si512());
+}
+
+#define _mm512_ror_epi32(A, B) \
+  ((__m512i)__builtin_ia32_prord512((__v16si)(__m512i)(A), (int)(B)))
+
+#define _mm512_mask_ror_epi32(W, U, A, B) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                       (__v16si)_mm512_ror_epi32((A), (B)), \
+                                       (__v16si)(__m512i)(W)))
+
+#define _mm512_maskz_ror_epi32(U, A, B) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                       (__v16si)_mm512_ror_epi32((A), (B)), \
+                                       (__v16si)_mm512_setzero_si512()))
+
+#define _mm512_ror_epi64(A, B) \
+  ((__m512i)__builtin_ia32_prorq512((__v8di)(__m512i)(A), (int)(B)))
+
+#define _mm512_mask_ror_epi64(W, U, A, B) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                       (__v8di)_mm512_ror_epi64((A), (B)), \
+                                       (__v8di)(__m512i)(W)))
+
+#define _mm512_maskz_ror_epi64(U, A, B) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                       (__v8di)_mm512_ror_epi64((A), (B)), \
+                                       (__v8di)_mm512_setzero_si512()))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_slli_epi32(__m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_pslldi512((__v16si)__A, (int)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_slli_epi32(__m512i __W, __mmask16 __U, __m512i __A,
+                       unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                         (__v16si)_mm512_slli_epi32(__A, __B),
+                                         (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_slli_epi32(__mmask16 __U, __m512i __A, unsigned int __B) {
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                         (__v16si)_mm512_slli_epi32(__A, __B),
+                                         (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_slli_epi64(__m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_psllqi512((__v8di)__A, (int)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_slli_epi64(__m512i __W, __mmask8 __U, __m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                          (__v8di)_mm512_slli_epi64(__A, __B),
+                                          (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_slli_epi64(__mmask8 __U, __m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                          (__v8di)_mm512_slli_epi64(__A, __B),
+                                          (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srli_epi32(__m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_psrldi512((__v16si)__A, (int)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srli_epi32(__m512i __W, __mmask16 __U, __m512i __A,
+                       unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                         (__v16si)_mm512_srli_epi32(__A, __B),
+                                         (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srli_epi32(__mmask16 __U, __m512i __A, unsigned int __B) {
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                         (__v16si)_mm512_srli_epi32(__A, __B),
+                                         (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srli_epi64(__m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_psrlqi512((__v8di)__A, (int)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srli_epi64(__m512i __W, __mmask8 __U, __m512i __A,
+                       unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                          (__v8di)_mm512_srli_epi64(__A, __B),
+                                          (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srli_epi64(__mmask8 __U, __m512i __A,
+                        unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                          (__v8di)_mm512_srli_epi64(__A, __B),
+                                          (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_load_epi32 (__m512i __W, __mmask16 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_movdqa32load512_mask ((const __v16si *) __P,
+              (__v16si) __W,
+              (__mmask16) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_load_epi32 (__mmask16 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_movdqa32load512_mask ((const __v16si *) __P,
+              (__v16si)
+              _mm512_setzero_si512 (),
+              (__mmask16) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_store_epi32 (void *__P, __mmask16 __U, __m512i __A)
+{
+  __builtin_ia32_movdqa32store512_mask ((__v16si *) __P, (__v16si) __A,
+          (__mmask16) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mov_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_selectd_512 ((__mmask16) __U,
+                 (__v16si) __A,
+                 (__v16si) __W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mov_epi32 (__mmask16 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_selectd_512 ((__mmask16) __U,
+                 (__v16si) __A,
+                 (__v16si) _mm512_setzero_si512 ());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_mov_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_selectq_512 ((__mmask8) __U,
+                 (__v8di) __A,
+                 (__v8di) __W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_mov_epi64 (__mmask8 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_selectq_512 ((__mmask8) __U,
+                 (__v8di) __A,
+                 (__v8di) _mm512_setzero_si512 ());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_load_epi64 (__m512i __W, __mmask8 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_movdqa64load512_mask ((const __v8di *) __P,
+              (__v8di) __W,
+              (__mmask8) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_load_epi64 (__mmask8 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_movdqa64load512_mask ((const __v8di *) __P,
+              (__v8di)
+              _mm512_setzero_si512 (),
+              (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_store_epi64 (void *__P, __mmask8 __U, __m512i __A)
+{
+  __builtin_ia32_movdqa64store512_mask ((__v8di *) __P, (__v8di) __A,
+          (__mmask8) __U);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_movedup_pd (__m512d __A)
+{
+  return (__m512d)__builtin_shufflevector((__v8df)__A, (__v8df)__A,
+                                          0, 0, 2, 2, 4, 4, 6, 6);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_movedup_pd (__m512d __W, __mmask8 __U, __m512d __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_movedup_pd(__A),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_movedup_pd (__mmask8 __U, __m512d __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_movedup_pd(__A),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+#define _mm512_fixupimm_round_pd(A, B, C, imm, R) \
+  ((__m512d)__builtin_ia32_fixupimmpd512_mask((__v8df)(__m512d)(A), \
+                                              (__v8df)(__m512d)(B), \
+                                              (__v8di)(__m512i)(C), (int)(imm), \
+                                              (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_fixupimm_round_pd(A, U, B, C, imm, R) \
+  ((__m512d)__builtin_ia32_fixupimmpd512_mask((__v8df)(__m512d)(A), \
+                                              (__v8df)(__m512d)(B), \
+                                              (__v8di)(__m512i)(C), (int)(imm), \
+                                              (__mmask8)(U), (int)(R)))
+
+#define _mm512_fixupimm_pd(A, B, C, imm) \
+  ((__m512d)__builtin_ia32_fixupimmpd512_mask((__v8df)(__m512d)(A), \
+                                              (__v8df)(__m512d)(B), \
+                                              (__v8di)(__m512i)(C), (int)(imm), \
+                                              (__mmask8)-1, \
+                                              _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_fixupimm_pd(A, U, B, C, imm) \
+  ((__m512d)__builtin_ia32_fixupimmpd512_mask((__v8df)(__m512d)(A), \
+                                              (__v8df)(__m512d)(B), \
+                                              (__v8di)(__m512i)(C), (int)(imm), \
+                                              (__mmask8)(U), \
+                                              _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_fixupimm_round_pd(U, A, B, C, imm, R) \
+  ((__m512d)__builtin_ia32_fixupimmpd512_maskz((__v8df)(__m512d)(A), \
+                                               (__v8df)(__m512d)(B), \
+                                               (__v8di)(__m512i)(C), \
+                                               (int)(imm), (__mmask8)(U), \
+                                               (int)(R)))
+
+#define _mm512_maskz_fixupimm_pd(U, A, B, C, imm) \
+  ((__m512d)__builtin_ia32_fixupimmpd512_maskz((__v8df)(__m512d)(A), \
+                                               (__v8df)(__m512d)(B), \
+                                               (__v8di)(__m512i)(C), \
+                                               (int)(imm), (__mmask8)(U), \
+                                               _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_fixupimm_round_ps(A, B, C, imm, R) \
+  ((__m512)__builtin_ia32_fixupimmps512_mask((__v16sf)(__m512)(A), \
+                                             (__v16sf)(__m512)(B), \
+                                             (__v16si)(__m512i)(C), (int)(imm), \
+                                             (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_fixupimm_round_ps(A, U, B, C, imm, R) \
+  ((__m512)__builtin_ia32_fixupimmps512_mask((__v16sf)(__m512)(A), \
+                                             (__v16sf)(__m512)(B), \
+                                             (__v16si)(__m512i)(C), (int)(imm), \
+                                             (__mmask16)(U), (int)(R)))
+
+#define _mm512_fixupimm_ps(A, B, C, imm) \
+  ((__m512)__builtin_ia32_fixupimmps512_mask((__v16sf)(__m512)(A), \
+                                             (__v16sf)(__m512)(B), \
+                                             (__v16si)(__m512i)(C), (int)(imm), \
+                                             (__mmask16)-1, \
+                                             _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_fixupimm_ps(A, U, B, C, imm) \
+  ((__m512)__builtin_ia32_fixupimmps512_mask((__v16sf)(__m512)(A), \
+                                             (__v16sf)(__m512)(B), \
+                                             (__v16si)(__m512i)(C), (int)(imm), \
+                                             (__mmask16)(U), \
+                                             _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_fixupimm_round_ps(U, A, B, C, imm, R) \
+  ((__m512)__builtin_ia32_fixupimmps512_maskz((__v16sf)(__m512)(A), \
+                                              (__v16sf)(__m512)(B), \
+                                              (__v16si)(__m512i)(C), \
+                                              (int)(imm), (__mmask16)(U), \
+                                              (int)(R)))
+
+#define _mm512_maskz_fixupimm_ps(U, A, B, C, imm) \
+  ((__m512)__builtin_ia32_fixupimmps512_maskz((__v16sf)(__m512)(A), \
+                                              (__v16sf)(__m512)(B), \
+                                              (__v16si)(__m512i)(C), \
+                                              (int)(imm), (__mmask16)(U), \
+                                              _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_fixupimm_round_sd(A, B, C, imm, R) \
+  ((__m128d)__builtin_ia32_fixupimmsd_mask((__v2df)(__m128d)(A), \
+                                           (__v2df)(__m128d)(B), \
+                                           (__v2di)(__m128i)(C), (int)(imm), \
+                                           (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_fixupimm_round_sd(A, U, B, C, imm, R) \
+  ((__m128d)__builtin_ia32_fixupimmsd_mask((__v2df)(__m128d)(A), \
+                                           (__v2df)(__m128d)(B), \
+                                           (__v2di)(__m128i)(C), (int)(imm), \
+                                           (__mmask8)(U), (int)(R)))
+
+#define _mm_fixupimm_sd(A, B, C, imm) \
+  ((__m128d)__builtin_ia32_fixupimmsd_mask((__v2df)(__m128d)(A), \
+                                           (__v2df)(__m128d)(B), \
+                                           (__v2di)(__m128i)(C), (int)(imm), \
+                                           (__mmask8)-1, \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_fixupimm_sd(A, U, B, C, imm) \
+  ((__m128d)__builtin_ia32_fixupimmsd_mask((__v2df)(__m128d)(A), \
+                                           (__v2df)(__m128d)(B), \
+                                           (__v2di)(__m128i)(C), (int)(imm), \
+                                           (__mmask8)(U), \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_fixupimm_round_sd(U, A, B, C, imm, R) \
+  ((__m128d)__builtin_ia32_fixupimmsd_maskz((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2di)(__m128i)(C), (int)(imm), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_fixupimm_sd(U, A, B, C, imm) \
+  ((__m128d)__builtin_ia32_fixupimmsd_maskz((__v2df)(__m128d)(A), \
+                                            (__v2df)(__m128d)(B), \
+                                            (__v2di)(__m128i)(C), (int)(imm), \
+                                            (__mmask8)(U), \
+                                            _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_fixupimm_round_ss(A, B, C, imm, R) \
+  ((__m128)__builtin_ia32_fixupimmss_mask((__v4sf)(__m128)(A), \
+                                          (__v4sf)(__m128)(B), \
+                                          (__v4si)(__m128i)(C), (int)(imm), \
+                                          (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_fixupimm_round_ss(A, U, B, C, imm, R) \
+  ((__m128)__builtin_ia32_fixupimmss_mask((__v4sf)(__m128)(A), \
+                                          (__v4sf)(__m128)(B), \
+                                          (__v4si)(__m128i)(C), (int)(imm), \
+                                          (__mmask8)(U), (int)(R)))
+
+#define _mm_fixupimm_ss(A, B, C, imm) \
+  ((__m128)__builtin_ia32_fixupimmss_mask((__v4sf)(__m128)(A), \
+                                          (__v4sf)(__m128)(B), \
+                                          (__v4si)(__m128i)(C), (int)(imm), \
+                                          (__mmask8)-1, \
+                                          _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_fixupimm_ss(A, U, B, C, imm) \
+  ((__m128)__builtin_ia32_fixupimmss_mask((__v4sf)(__m128)(A), \
+                                          (__v4sf)(__m128)(B), \
+                                          (__v4si)(__m128i)(C), (int)(imm), \
+                                          (__mmask8)(U), \
+                                          _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_fixupimm_round_ss(U, A, B, C, imm, R) \
+  ((__m128)__builtin_ia32_fixupimmss_maskz((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4si)(__m128i)(C), (int)(imm), \
+                                           (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_fixupimm_ss(U, A, B, C, imm) \
+  ((__m128)__builtin_ia32_fixupimmss_maskz((__v4sf)(__m128)(A), \
+                                           (__v4sf)(__m128)(B), \
+                                           (__v4si)(__m128i)(C), (int)(imm), \
+                                           (__mmask8)(U), \
+                                           _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_getexp_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_getexpsd128_round_mask((__v2df)(__m128d)(A), \
+                                                  (__v2df)(__m128d)(B), \
+                                                  (__v2df)_mm_setzero_pd(), \
+                                                  (__mmask8)-1, (int)(R)))
+
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_getexp_sd (__m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_getexpsd128_round_mask ((__v2df) __A,
+                 (__v2df) __B, (__v2df) _mm_setzero_pd(), (__mmask8) -1, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_getexp_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+ return (__m128d) __builtin_ia32_getexpsd128_round_mask ( (__v2df) __A,
+          (__v2df) __B,
+          (__v2df) __W,
+          (__mmask8) __U,
+          _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask_getexp_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_getexpsd128_round_mask((__v2df)(__m128d)(A), \
+                                                  (__v2df)(__m128d)(B), \
+                                                  (__v2df)(__m128d)(W), \
+                                                  (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_getexp_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+ return (__m128d) __builtin_ia32_getexpsd128_round_mask ( (__v2df) __A,
+          (__v2df) __B,
+          (__v2df) _mm_setzero_pd (),
+          (__mmask8) __U,
+          _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_getexp_round_sd(U, A, B, R) \
+  ((__m128d)__builtin_ia32_getexpsd128_round_mask((__v2df)(__m128d)(A), \
+                                                  (__v2df)(__m128d)(B), \
+                                                  (__v2df)_mm_setzero_pd(), \
+                                                  (__mmask8)(U), (int)(R)))
+
+#define _mm_getexp_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_getexpss128_round_mask((__v4sf)(__m128)(A), \
+                                                 (__v4sf)(__m128)(B), \
+                                                 (__v4sf)_mm_setzero_ps(), \
+                                                 (__mmask8)-1, (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_getexp_ss (__m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_getexpss128_round_mask ((__v4sf) __A,
+                (__v4sf) __B, (__v4sf)  _mm_setzero_ps(), (__mmask8) -1, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_getexp_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+ return (__m128) __builtin_ia32_getexpss128_round_mask ((__v4sf) __A,
+          (__v4sf) __B,
+          (__v4sf) __W,
+          (__mmask8) __U,
+          _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask_getexp_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_getexpss128_round_mask((__v4sf)(__m128)(A), \
+                                                 (__v4sf)(__m128)(B), \
+                                                 (__v4sf)(__m128)(W), \
+                                                 (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_getexp_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+ return (__m128) __builtin_ia32_getexpss128_round_mask ((__v4sf) __A,
+          (__v4sf) __B,
+          (__v4sf) _mm_setzero_ps (),
+          (__mmask8) __U,
+          _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_getexp_round_ss(U, A, B, R) \
+  ((__m128)__builtin_ia32_getexpss128_round_mask((__v4sf)(__m128)(A), \
+                                                 (__v4sf)(__m128)(B), \
+                                                 (__v4sf)_mm_setzero_ps(), \
+                                                 (__mmask8)(U), (int)(R)))
+
+#define _mm_getmant_round_sd(A, B, C, D, R) \
+  ((__m128d)__builtin_ia32_getmantsd_round_mask((__v2df)(__m128d)(A), \
+                                                (__v2df)(__m128d)(B), \
+                                                (int)(((D)<<2) | (C)), \
+                                                (__v2df)_mm_setzero_pd(), \
+                                                (__mmask8)-1, (int)(R)))
+
+#define _mm_getmant_sd(A, B, C, D)  \
+  ((__m128d)__builtin_ia32_getmantsd_round_mask((__v2df)(__m128d)(A), \
+                                                (__v2df)(__m128d)(B), \
+                                                (int)(((D)<<2) | (C)), \
+                                                (__v2df)_mm_setzero_pd(), \
+                                                (__mmask8)-1, \
+                                                _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_getmant_sd(W, U, A, B, C, D) \
+  ((__m128d)__builtin_ia32_getmantsd_round_mask((__v2df)(__m128d)(A), \
+                                                (__v2df)(__m128d)(B), \
+                                                (int)(((D)<<2) | (C)), \
+                                                (__v2df)(__m128d)(W), \
+                                                (__mmask8)(U), \
+                                                _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_getmant_round_sd(W, U, A, B, C, D, R) \
+  ((__m128d)__builtin_ia32_getmantsd_round_mask((__v2df)(__m128d)(A), \
+                                                (__v2df)(__m128d)(B), \
+                                                (int)(((D)<<2) | (C)), \
+                                                (__v2df)(__m128d)(W), \
+                                                (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_getmant_sd(U, A, B, C, D) \
+  ((__m128d)__builtin_ia32_getmantsd_round_mask((__v2df)(__m128d)(A), \
+                                                (__v2df)(__m128d)(B), \
+                                                (int)(((D)<<2) | (C)), \
+                                                (__v2df)_mm_setzero_pd(), \
+                                                (__mmask8)(U), \
+                                                _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_getmant_round_sd(U, A, B, C, D, R) \
+  ((__m128d)__builtin_ia32_getmantsd_round_mask((__v2df)(__m128d)(A), \
+                                                (__v2df)(__m128d)(B), \
+                                                (int)(((D)<<2) | (C)), \
+                                                (__v2df)_mm_setzero_pd(), \
+                                                (__mmask8)(U), (int)(R)))
+
+#define _mm_getmant_round_ss(A, B, C, D, R) \
+  ((__m128)__builtin_ia32_getmantss_round_mask((__v4sf)(__m128)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (int)(((D)<<2) | (C)), \
+                                               (__v4sf)_mm_setzero_ps(), \
+                                               (__mmask8)-1, (int)(R)))
+
+#define _mm_getmant_ss(A, B, C, D) \
+  ((__m128)__builtin_ia32_getmantss_round_mask((__v4sf)(__m128)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (int)(((D)<<2) | (C)), \
+                                               (__v4sf)_mm_setzero_ps(), \
+                                               (__mmask8)-1, \
+                                               _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_getmant_ss(W, U, A, B, C, D) \
+  ((__m128)__builtin_ia32_getmantss_round_mask((__v4sf)(__m128)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (int)(((D)<<2) | (C)), \
+                                               (__v4sf)(__m128)(W), \
+                                               (__mmask8)(U), \
+                                               _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_getmant_round_ss(W, U, A, B, C, D, R) \
+  ((__m128)__builtin_ia32_getmantss_round_mask((__v4sf)(__m128)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (int)(((D)<<2) | (C)), \
+                                               (__v4sf)(__m128)(W), \
+                                               (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_getmant_ss(U, A, B, C, D) \
+  ((__m128)__builtin_ia32_getmantss_round_mask((__v4sf)(__m128)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (int)(((D)<<2) | (C)), \
+                                               (__v4sf)_mm_setzero_ps(), \
+                                               (__mmask8)(U), \
+                                               _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_getmant_round_ss(U, A, B, C, D, R) \
+  ((__m128)__builtin_ia32_getmantss_round_mask((__v4sf)(__m128)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (int)(((D)<<2) | (C)), \
+                                               (__v4sf)_mm_setzero_ps(), \
+                                               (__mmask8)(U), (int)(R)))
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_kmov (__mmask16 __A)
+{
+  return  __A;
+}
+
+#define _mm_comi_round_sd(A, B, P, R) \
+  ((int)__builtin_ia32_vcomisd((__v2df)(__m128d)(A), (__v2df)(__m128d)(B), \
+                               (int)(P), (int)(R)))
+
+#define _mm_comi_round_ss(A, B, P, R) \
+  ((int)__builtin_ia32_vcomiss((__v4sf)(__m128)(A), (__v4sf)(__m128)(B), \
+                               (int)(P), (int)(R)))
+
+#ifdef __x86_64__
+#define _mm_cvt_roundsd_si64(A, R) \
+  ((long long)__builtin_ia32_vcvtsd2si64((__v2df)(__m128d)(A), (int)(R)))
+#endif
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sll_epi32(__m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_pslld512((__v16si) __A, (__v4si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sll_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                          (__v16si)_mm512_sll_epi32(__A, __B),
+                                          (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sll_epi32(__mmask16 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                          (__v16si)_mm512_sll_epi32(__A, __B),
+                                          (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sll_epi64(__m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_psllq512((__v8di)__A, (__v2di)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sll_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                             (__v8di)_mm512_sll_epi64(__A, __B),
+                                             (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sll_epi64(__mmask8 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                           (__v8di)_mm512_sll_epi64(__A, __B),
+                                           (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sllv_epi32(__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_psllv16si((__v16si)__X, (__v16si)__Y);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sllv_epi32(__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                           (__v16si)_mm512_sllv_epi32(__X, __Y),
+                                           (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sllv_epi32(__mmask16 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                           (__v16si)_mm512_sllv_epi32(__X, __Y),
+                                           (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sllv_epi64(__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_psllv8di((__v8di)__X, (__v8di)__Y);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sllv_epi64(__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                            (__v8di)_mm512_sllv_epi64(__X, __Y),
+                                            (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sllv_epi64(__mmask8 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                            (__v8di)_mm512_sllv_epi64(__X, __Y),
+                                            (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sra_epi32(__m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_psrad512((__v16si) __A, (__v4si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sra_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                          (__v16si)_mm512_sra_epi32(__A, __B),
+                                          (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sra_epi32(__mmask16 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                          (__v16si)_mm512_sra_epi32(__A, __B),
+                                          (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_sra_epi64(__m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_psraq512((__v8di)__A, (__v2di)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_sra_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                           (__v8di)_mm512_sra_epi64(__A, __B),
+                                           (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_sra_epi64(__mmask8 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                           (__v8di)_mm512_sra_epi64(__A, __B),
+                                           (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srav_epi32(__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_psrav16si((__v16si)__X, (__v16si)__Y);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srav_epi32(__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                           (__v16si)_mm512_srav_epi32(__X, __Y),
+                                           (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srav_epi32(__mmask16 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                           (__v16si)_mm512_srav_epi32(__X, __Y),
+                                           (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srav_epi64(__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_psrav8di((__v8di)__X, (__v8di)__Y);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srav_epi64(__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                            (__v8di)_mm512_srav_epi64(__X, __Y),
+                                            (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srav_epi64(__mmask8 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                            (__v8di)_mm512_srav_epi64(__X, __Y),
+                                            (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srl_epi32(__m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_psrld512((__v16si) __A, (__v4si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srl_epi32(__m512i __W, __mmask16 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                          (__v16si)_mm512_srl_epi32(__A, __B),
+                                          (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srl_epi32(__mmask16 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                          (__v16si)_mm512_srl_epi32(__A, __B),
+                                          (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srl_epi64(__m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_psrlq512((__v8di)__A, (__v2di)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srl_epi64(__m512i __W, __mmask8 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                           (__v8di)_mm512_srl_epi64(__A, __B),
+                                           (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srl_epi64(__mmask8 __U, __m512i __A, __m128i __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                           (__v8di)_mm512_srl_epi64(__A, __B),
+                                           (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srlv_epi32(__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_psrlv16si((__v16si)__X, (__v16si)__Y);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srlv_epi32(__m512i __W, __mmask16 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                           (__v16si)_mm512_srlv_epi32(__X, __Y),
+                                           (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srlv_epi32(__mmask16 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                           (__v16si)_mm512_srlv_epi32(__X, __Y),
+                                           (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srlv_epi64 (__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_psrlv8di((__v8di)__X, (__v8di)__Y);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srlv_epi64(__m512i __W, __mmask8 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                            (__v8di)_mm512_srlv_epi64(__X, __Y),
+                                            (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srlv_epi64(__mmask8 __U, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                            (__v8di)_mm512_srlv_epi64(__X, __Y),
+                                            (__v8di)_mm512_setzero_si512());
+}
+
+/// \enum _MM_TERNLOG_ENUM
+///    A helper to represent the ternary logic operations among vector \a A,
+///    \a B and \a C. The representation is passed to \a imm.
+typedef enum {
+  _MM_TERNLOG_A = 0xF0,
+  _MM_TERNLOG_B = 0xCC,
+  _MM_TERNLOG_C = 0xAA
+} _MM_TERNLOG_ENUM;
+
+#define _mm512_ternarylogic_epi32(A, B, C, imm)                                \
+  ((__m512i)__builtin_ia32_pternlogd512_mask(                                  \
+      (__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C),     \
+      (unsigned char)(imm), (__mmask16)-1))
+
+#define _mm512_mask_ternarylogic_epi32(A, U, B, C, imm)                        \
+  ((__m512i)__builtin_ia32_pternlogd512_mask(                                  \
+      (__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C),     \
+      (unsigned char)(imm), (__mmask16)(U)))
+
+#define _mm512_maskz_ternarylogic_epi32(U, A, B, C, imm)                       \
+  ((__m512i)__builtin_ia32_pternlogd512_maskz(                                 \
+      (__v16si)(__m512i)(A), (__v16si)(__m512i)(B), (__v16si)(__m512i)(C),     \
+      (unsigned char)(imm), (__mmask16)(U)))
+
+#define _mm512_ternarylogic_epi64(A, B, C, imm)                                \
+  ((__m512i)__builtin_ia32_pternlogq512_mask(                                  \
+      (__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C),        \
+      (unsigned char)(imm), (__mmask8)-1))
+
+#define _mm512_mask_ternarylogic_epi64(A, U, B, C, imm)                        \
+  ((__m512i)__builtin_ia32_pternlogq512_mask(                                  \
+      (__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C),        \
+      (unsigned char)(imm), (__mmask8)(U)))
+
+#define _mm512_maskz_ternarylogic_epi64(U, A, B, C, imm)                       \
+  ((__m512i)__builtin_ia32_pternlogq512_maskz(                                 \
+      (__v8di)(__m512i)(A), (__v8di)(__m512i)(B), (__v8di)(__m512i)(C),        \
+      (unsigned char)(imm), (__mmask8)(U)))
+
+#ifdef __x86_64__
+#define _mm_cvt_roundsd_i64(A, R) \
+  ((long long)__builtin_ia32_vcvtsd2si64((__v2df)(__m128d)(A), (int)(R)))
+#endif
+
+#define _mm_cvt_roundsd_si32(A, R) \
+  ((int)__builtin_ia32_vcvtsd2si32((__v2df)(__m128d)(A), (int)(R)))
+
+#define _mm_cvt_roundsd_i32(A, R) \
+  ((int)__builtin_ia32_vcvtsd2si32((__v2df)(__m128d)(A), (int)(R)))
+
+#define _mm_cvt_roundsd_u32(A, R) \
+  ((unsigned int)__builtin_ia32_vcvtsd2usi32((__v2df)(__m128d)(A), (int)(R)))
+
+static __inline__ unsigned __DEFAULT_FN_ATTRS128
+_mm_cvtsd_u32 (__m128d __A)
+{
+  return (unsigned) __builtin_ia32_vcvtsd2usi32 ((__v2df) __A,
+             _MM_FROUND_CUR_DIRECTION);
+}
+
+#ifdef __x86_64__
+#define _mm_cvt_roundsd_u64(A, R) \
+  ((unsigned long long)__builtin_ia32_vcvtsd2usi64((__v2df)(__m128d)(A), \
+                                                   (int)(R)))
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS128
+_mm_cvtsd_u64 (__m128d __A)
+{
+  return (unsigned long long) __builtin_ia32_vcvtsd2usi64 ((__v2df)
+                 __A,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+#endif
+
+#define _mm_cvt_roundss_si32(A, R) \
+  ((int)__builtin_ia32_vcvtss2si32((__v4sf)(__m128)(A), (int)(R)))
+
+#define _mm_cvt_roundss_i32(A, R) \
+  ((int)__builtin_ia32_vcvtss2si32((__v4sf)(__m128)(A), (int)(R)))
+
+#ifdef __x86_64__
+#define _mm_cvt_roundss_si64(A, R) \
+  ((long long)__builtin_ia32_vcvtss2si64((__v4sf)(__m128)(A), (int)(R)))
+
+#define _mm_cvt_roundss_i64(A, R) \
+  ((long long)__builtin_ia32_vcvtss2si64((__v4sf)(__m128)(A), (int)(R)))
+#endif
+
+#define _mm_cvt_roundss_u32(A, R) \
+  ((unsigned int)__builtin_ia32_vcvtss2usi32((__v4sf)(__m128)(A), (int)(R)))
+
+static __inline__ unsigned __DEFAULT_FN_ATTRS128
+_mm_cvtss_u32 (__m128 __A)
+{
+  return (unsigned) __builtin_ia32_vcvtss2usi32 ((__v4sf) __A,
+             _MM_FROUND_CUR_DIRECTION);
+}
+
+#ifdef __x86_64__
+#define _mm_cvt_roundss_u64(A, R) \
+  ((unsigned long long)__builtin_ia32_vcvtss2usi64((__v4sf)(__m128)(A), \
+                                                   (int)(R)))
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS128
+_mm_cvtss_u64 (__m128 __A)
+{
+  return (unsigned long long) __builtin_ia32_vcvtss2usi64 ((__v4sf)
+                 __A,
+                 _MM_FROUND_CUR_DIRECTION);
+}
+#endif
+
+#define _mm_cvtt_roundsd_i32(A, R) \
+  ((int)__builtin_ia32_vcvttsd2si32((__v2df)(__m128d)(A), (int)(R)))
+
+#define _mm_cvtt_roundsd_si32(A, R) \
+  ((int)__builtin_ia32_vcvttsd2si32((__v2df)(__m128d)(A), (int)(R)))
+
+static __inline__ int __DEFAULT_FN_ATTRS128
+_mm_cvttsd_i32 (__m128d __A)
+{
+  return (int) __builtin_ia32_vcvttsd2si32 ((__v2df) __A,
+              _MM_FROUND_CUR_DIRECTION);
+}
+
+#ifdef __x86_64__
+#define _mm_cvtt_roundsd_si64(A, R) \
+  ((long long)__builtin_ia32_vcvttsd2si64((__v2df)(__m128d)(A), (int)(R)))
+
+#define _mm_cvtt_roundsd_i64(A, R) \
+  ((long long)__builtin_ia32_vcvttsd2si64((__v2df)(__m128d)(A), (int)(R)))
+
+static __inline__ long long __DEFAULT_FN_ATTRS128
+_mm_cvttsd_i64 (__m128d __A)
+{
+  return (long long) __builtin_ia32_vcvttsd2si64 ((__v2df) __A,
+              _MM_FROUND_CUR_DIRECTION);
+}
+#endif
+
+#define _mm_cvtt_roundsd_u32(A, R) \
+  ((unsigned int)__builtin_ia32_vcvttsd2usi32((__v2df)(__m128d)(A), (int)(R)))
+
+static __inline__ unsigned __DEFAULT_FN_ATTRS128
+_mm_cvttsd_u32 (__m128d __A)
+{
+  return (unsigned) __builtin_ia32_vcvttsd2usi32 ((__v2df) __A,
+              _MM_FROUND_CUR_DIRECTION);
+}
+
+#ifdef __x86_64__
+#define _mm_cvtt_roundsd_u64(A, R) \
+  ((unsigned long long)__builtin_ia32_vcvttsd2usi64((__v2df)(__m128d)(A), \
+                                                    (int)(R)))
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS128
+_mm_cvttsd_u64 (__m128d __A)
+{
+  return (unsigned long long) __builtin_ia32_vcvttsd2usi64 ((__v2df)
+                  __A,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+#endif
+
+#define _mm_cvtt_roundss_i32(A, R) \
+  ((int)__builtin_ia32_vcvttss2si32((__v4sf)(__m128)(A), (int)(R)))
+
+#define _mm_cvtt_roundss_si32(A, R) \
+  ((int)__builtin_ia32_vcvttss2si32((__v4sf)(__m128)(A), (int)(R)))
+
+static __inline__ int __DEFAULT_FN_ATTRS128
+_mm_cvttss_i32 (__m128 __A)
+{
+  return (int) __builtin_ia32_vcvttss2si32 ((__v4sf) __A,
+              _MM_FROUND_CUR_DIRECTION);
+}
+
+#ifdef __x86_64__
+#define _mm_cvtt_roundss_i64(A, R) \
+  ((long long)__builtin_ia32_vcvttss2si64((__v4sf)(__m128)(A), (int)(R)))
+
+#define _mm_cvtt_roundss_si64(A, R) \
+  ((long long)__builtin_ia32_vcvttss2si64((__v4sf)(__m128)(A), (int)(R)))
+
+static __inline__ long long __DEFAULT_FN_ATTRS128
+_mm_cvttss_i64 (__m128 __A)
+{
+  return (long long) __builtin_ia32_vcvttss2si64 ((__v4sf) __A,
+              _MM_FROUND_CUR_DIRECTION);
+}
+#endif
+
+#define _mm_cvtt_roundss_u32(A, R) \
+  ((unsigned int)__builtin_ia32_vcvttss2usi32((__v4sf)(__m128)(A), (int)(R)))
+
+static __inline__ unsigned __DEFAULT_FN_ATTRS128
+_mm_cvttss_u32 (__m128 __A)
+{
+  return (unsigned) __builtin_ia32_vcvttss2usi32 ((__v4sf) __A,
+              _MM_FROUND_CUR_DIRECTION);
+}
+
+#ifdef __x86_64__
+#define _mm_cvtt_roundss_u64(A, R) \
+  ((unsigned long long)__builtin_ia32_vcvttss2usi64((__v4sf)(__m128)(A), \
+                                                    (int)(R)))
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS128
+_mm_cvttss_u64 (__m128 __A)
+{
+  return (unsigned long long) __builtin_ia32_vcvttss2usi64 ((__v4sf)
+                  __A,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+#endif
+
+#define _mm512_permute_pd(X, C) \
+  ((__m512d)__builtin_ia32_vpermilpd512((__v8df)(__m512d)(X), (int)(C)))
+
+#define _mm512_mask_permute_pd(W, U, X, C) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                        (__v8df)_mm512_permute_pd((X), (C)), \
+                                        (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_permute_pd(U, X, C) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                        (__v8df)_mm512_permute_pd((X), (C)), \
+                                        (__v8df)_mm512_setzero_pd()))
+
+#define _mm512_permute_ps(X, C) \
+  ((__m512)__builtin_ia32_vpermilps512((__v16sf)(__m512)(X), (int)(C)))
+
+#define _mm512_mask_permute_ps(W, U, X, C) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                       (__v16sf)_mm512_permute_ps((X), (C)), \
+                                       (__v16sf)(__m512)(W)))
+
+#define _mm512_maskz_permute_ps(U, X, C) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                       (__v16sf)_mm512_permute_ps((X), (C)), \
+                                       (__v16sf)_mm512_setzero_ps()))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_permutevar_pd(__m512d __A, __m512i __C)
+{
+  return (__m512d)__builtin_ia32_vpermilvarpd512((__v8df)__A, (__v8di)__C);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_permutevar_pd(__m512d __W, __mmask8 __U, __m512d __A, __m512i __C)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                         (__v8df)_mm512_permutevar_pd(__A, __C),
+                                         (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutevar_pd(__mmask8 __U, __m512d __A, __m512i __C)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                         (__v8df)_mm512_permutevar_pd(__A, __C),
+                                         (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_permutevar_ps(__m512 __A, __m512i __C)
+{
+  return (__m512)__builtin_ia32_vpermilvarps512((__v16sf)__A, (__v16si)__C);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_permutevar_ps(__m512 __W, __mmask16 __U, __m512 __A, __m512i __C)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                        (__v16sf)_mm512_permutevar_ps(__A, __C),
+                                        (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutevar_ps(__mmask16 __U, __m512 __A, __m512i __C)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                        (__v16sf)_mm512_permutevar_ps(__A, __C),
+                                        (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline __m512d __DEFAULT_FN_ATTRS512
+_mm512_permutex2var_pd(__m512d __A, __m512i __I, __m512d __B)
+{
+  return (__m512d)__builtin_ia32_vpermi2varpd512((__v8df)__A, (__v8di)__I,
+                                                 (__v8df)__B);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_permutex2var_pd(__m512d __A, __mmask8 __U, __m512i __I, __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__U,
+                                  (__v8df)_mm512_permutex2var_pd(__A, __I, __B),
+                                  (__v8df)__A);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask2_permutex2var_pd(__m512d __A, __m512i __I, __mmask8 __U,
+                             __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__U,
+                                  (__v8df)_mm512_permutex2var_pd(__A, __I, __B),
+                                  (__v8df)(__m512d)__I);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutex2var_pd(__mmask8 __U, __m512d __A, __m512i __I,
+                             __m512d __B)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__U,
+                                  (__v8df)_mm512_permutex2var_pd(__A, __I, __B),
+                                  (__v8df)_mm512_setzero_pd());
+}
+
+static __inline __m512 __DEFAULT_FN_ATTRS512
+_mm512_permutex2var_ps(__m512 __A, __m512i __I, __m512 __B)
+{
+  return (__m512)__builtin_ia32_vpermi2varps512((__v16sf)__A, (__v16si)__I,
+                                                (__v16sf) __B);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_permutex2var_ps(__m512 __A, __mmask16 __U, __m512i __I, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512(__U,
+                                 (__v16sf)_mm512_permutex2var_ps(__A, __I, __B),
+                                 (__v16sf)__A);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask2_permutex2var_ps(__m512 __A, __m512i __I, __mmask16 __U, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512(__U,
+                                 (__v16sf)_mm512_permutex2var_ps(__A, __I, __B),
+                                 (__v16sf)(__m512)__I);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutex2var_ps(__mmask16 __U, __m512 __A, __m512i __I, __m512 __B)
+{
+  return (__m512)__builtin_ia32_selectps_512(__U,
+                                 (__v16sf)_mm512_permutex2var_ps(__A, __I, __B),
+                                 (__v16sf)_mm512_setzero_ps());
+}
+
+
+#define _mm512_cvtt_roundpd_epu32(A, R) \
+  ((__m256i)__builtin_ia32_cvttpd2udq512_mask((__v8df)(__m512d)(A), \
+                                              (__v8si)_mm256_undefined_si256(), \
+                                              (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvtt_roundpd_epu32(W, U, A, R) \
+  ((__m256i)__builtin_ia32_cvttpd2udq512_mask((__v8df)(__m512d)(A), \
+                                              (__v8si)(__m256i)(W), \
+                                              (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundpd_epu32(U, A, R) \
+  ((__m256i)__builtin_ia32_cvttpd2udq512_mask((__v8df)(__m512d)(A), \
+                                              (__v8si)_mm256_setzero_si256(), \
+                                              (__mmask8)(U), (int)(R)))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvttpd_epu32 (__m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvttpd2udq512_mask ((__v8df) __A,
+                  (__v8si)
+                  _mm256_undefined_si256 (),
+                  (__mmask8) -1,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttpd_epu32 (__m256i __W, __mmask8 __U, __m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvttpd2udq512_mask ((__v8df) __A,
+                  (__v8si) __W,
+                  (__mmask8) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttpd_epu32 (__mmask8 __U, __m512d __A)
+{
+  return (__m256i) __builtin_ia32_cvttpd2udq512_mask ((__v8df) __A,
+                  (__v8si)
+                  _mm256_setzero_si256 (),
+                  (__mmask8) __U,
+                  _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_roundscale_round_sd(A, B, imm, R) \
+  ((__m128d)__builtin_ia32_rndscalesd_round_mask((__v2df)(__m128d)(A), \
+                                                 (__v2df)(__m128d)(B), \
+                                                 (__v2df)_mm_setzero_pd(), \
+                                                 (__mmask8)-1, (int)(imm), \
+                                                 (int)(R)))
+
+#define _mm_roundscale_sd(A, B, imm) \
+  ((__m128d)__builtin_ia32_rndscalesd_round_mask((__v2df)(__m128d)(A), \
+                                                 (__v2df)(__m128d)(B), \
+                                                 (__v2df)_mm_setzero_pd(), \
+                                                 (__mmask8)-1, (int)(imm), \
+                                                 _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_roundscale_sd(W, U, A, B, imm) \
+  ((__m128d)__builtin_ia32_rndscalesd_round_mask((__v2df)(__m128d)(A), \
+                                                 (__v2df)(__m128d)(B), \
+                                                 (__v2df)(__m128d)(W), \
+                                                 (__mmask8)(U), (int)(imm), \
+                                                 _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_roundscale_round_sd(W, U, A, B, I, R) \
+  ((__m128d)__builtin_ia32_rndscalesd_round_mask((__v2df)(__m128d)(A), \
+                                                 (__v2df)(__m128d)(B), \
+                                                 (__v2df)(__m128d)(W), \
+                                                 (__mmask8)(U), (int)(I), \
+                                                 (int)(R)))
+
+#define _mm_maskz_roundscale_sd(U, A, B, I) \
+  ((__m128d)__builtin_ia32_rndscalesd_round_mask((__v2df)(__m128d)(A), \
+                                                 (__v2df)(__m128d)(B), \
+                                                 (__v2df)_mm_setzero_pd(), \
+                                                 (__mmask8)(U), (int)(I), \
+                                                 _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_roundscale_round_sd(U, A, B, I, R) \
+  ((__m128d)__builtin_ia32_rndscalesd_round_mask((__v2df)(__m128d)(A), \
+                                                 (__v2df)(__m128d)(B), \
+                                                 (__v2df)_mm_setzero_pd(), \
+                                                 (__mmask8)(U), (int)(I), \
+                                                 (int)(R)))
+
+#define _mm_roundscale_round_ss(A, B, imm, R) \
+  ((__m128)__builtin_ia32_rndscaless_round_mask((__v4sf)(__m128)(A), \
+                                                (__v4sf)(__m128)(B), \
+                                                (__v4sf)_mm_setzero_ps(), \
+                                                (__mmask8)-1, (int)(imm), \
+                                                (int)(R)))
+
+#define _mm_roundscale_ss(A, B, imm) \
+  ((__m128)__builtin_ia32_rndscaless_round_mask((__v4sf)(__m128)(A), \
+                                                (__v4sf)(__m128)(B), \
+                                                (__v4sf)_mm_setzero_ps(), \
+                                                (__mmask8)-1, (int)(imm), \
+                                                _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_roundscale_ss(W, U, A, B, I) \
+  ((__m128)__builtin_ia32_rndscaless_round_mask((__v4sf)(__m128)(A), \
+                                                (__v4sf)(__m128)(B), \
+                                                (__v4sf)(__m128)(W), \
+                                                (__mmask8)(U), (int)(I), \
+                                                _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_roundscale_round_ss(W, U, A, B, I, R) \
+  ((__m128)__builtin_ia32_rndscaless_round_mask((__v4sf)(__m128)(A), \
+                                                (__v4sf)(__m128)(B), \
+                                                (__v4sf)(__m128)(W), \
+                                                (__mmask8)(U), (int)(I), \
+                                                (int)(R)))
+
+#define _mm_maskz_roundscale_ss(U, A, B, I) \
+  ((__m128)__builtin_ia32_rndscaless_round_mask((__v4sf)(__m128)(A), \
+                                                (__v4sf)(__m128)(B), \
+                                                (__v4sf)_mm_setzero_ps(), \
+                                                (__mmask8)(U), (int)(I), \
+                                                _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_roundscale_round_ss(U, A, B, I, R) \
+  ((__m128)__builtin_ia32_rndscaless_round_mask((__v4sf)(__m128)(A), \
+                                                (__v4sf)(__m128)(B), \
+                                                (__v4sf)_mm_setzero_ps(), \
+                                                (__mmask8)(U), (int)(I), \
+                                                (int)(R)))
+
+#define _mm512_scalef_round_pd(A, B, R) \
+  ((__m512d)__builtin_ia32_scalefpd512_mask((__v8df)(__m512d)(A), \
+                                            (__v8df)(__m512d)(B), \
+                                            (__v8df)_mm512_undefined_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_scalef_round_pd(W, U, A, B, R) \
+  ((__m512d)__builtin_ia32_scalefpd512_mask((__v8df)(__m512d)(A), \
+                                            (__v8df)(__m512d)(B), \
+                                            (__v8df)(__m512d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_scalef_round_pd(U, A, B, R) \
+  ((__m512d)__builtin_ia32_scalefpd512_mask((__v8df)(__m512d)(A), \
+                                            (__v8df)(__m512d)(B), \
+                                            (__v8df)_mm512_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_scalef_pd (__m512d __A, __m512d __B)
+{
+  return (__m512d) __builtin_ia32_scalefpd512_mask ((__v8df) __A,
+                (__v8df) __B,
+                (__v8df)
+                _mm512_undefined_pd (),
+                (__mmask8) -1,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_scalef_pd (__m512d __W, __mmask8 __U, __m512d __A, __m512d __B)
+{
+  return (__m512d) __builtin_ia32_scalefpd512_mask ((__v8df) __A,
+                (__v8df) __B,
+                (__v8df) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_scalef_pd (__mmask8 __U, __m512d __A, __m512d __B)
+{
+  return (__m512d) __builtin_ia32_scalefpd512_mask ((__v8df) __A,
+                (__v8df) __B,
+                (__v8df)
+                _mm512_setzero_pd (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_scalef_round_ps(A, B, R) \
+  ((__m512)__builtin_ia32_scalefps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)(__m512)(B), \
+                                           (__v16sf)_mm512_undefined_ps(), \
+                                           (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_scalef_round_ps(W, U, A, B, R) \
+  ((__m512)__builtin_ia32_scalefps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)(__m512)(B), \
+                                           (__v16sf)(__m512)(W), \
+                                           (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_scalef_round_ps(U, A, B, R) \
+  ((__m512)__builtin_ia32_scalefps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)(__m512)(B), \
+                                           (__v16sf)_mm512_setzero_ps(), \
+                                           (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_scalef_ps (__m512 __A, __m512 __B)
+{
+  return (__m512) __builtin_ia32_scalefps512_mask ((__v16sf) __A,
+               (__v16sf) __B,
+               (__v16sf)
+               _mm512_undefined_ps (),
+               (__mmask16) -1,
+               _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_scalef_ps (__m512 __W, __mmask16 __U, __m512 __A, __m512 __B)
+{
+  return (__m512) __builtin_ia32_scalefps512_mask ((__v16sf) __A,
+               (__v16sf) __B,
+               (__v16sf) __W,
+               (__mmask16) __U,
+               _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_scalef_ps (__mmask16 __U, __m512 __A, __m512 __B)
+{
+  return (__m512) __builtin_ia32_scalefps512_mask ((__v16sf) __A,
+               (__v16sf) __B,
+               (__v16sf)
+               _mm512_setzero_ps (),
+               (__mmask16) __U,
+               _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_scalef_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_scalefsd_round_mask((__v2df)(__m128d)(A), \
+                                               (__v2df)(__m128d)(B), \
+                                               (__v2df)_mm_setzero_pd(), \
+                                               (__mmask8)-1, (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_scalef_sd (__m128d __A, __m128d __B)
+{
+  return (__m128d) __builtin_ia32_scalefsd_round_mask ((__v2df) __A,
+              (__v2df)( __B), (__v2df) _mm_setzero_pd(),
+              (__mmask8) -1,
+              _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_scalef_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+ return (__m128d) __builtin_ia32_scalefsd_round_mask ( (__v2df) __A,
+                 (__v2df) __B,
+                (__v2df) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask_scalef_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_scalefsd_round_mask((__v2df)(__m128d)(A), \
+                                               (__v2df)(__m128d)(B), \
+                                               (__v2df)(__m128d)(W), \
+                                               (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_scalef_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+ return (__m128d) __builtin_ia32_scalefsd_round_mask ( (__v2df) __A,
+                 (__v2df) __B,
+                (__v2df) _mm_setzero_pd (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_scalef_round_sd(U, A, B, R) \
+  ((__m128d)__builtin_ia32_scalefsd_round_mask((__v2df)(__m128d)(A), \
+                                               (__v2df)(__m128d)(B), \
+                                               (__v2df)_mm_setzero_pd(), \
+                                               (__mmask8)(U), (int)(R)))
+
+#define _mm_scalef_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_scalefss_round_mask((__v4sf)(__m128)(A), \
+                                              (__v4sf)(__m128)(B), \
+                                              (__v4sf)_mm_setzero_ps(), \
+                                              (__mmask8)-1, (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_scalef_ss (__m128 __A, __m128 __B)
+{
+  return (__m128) __builtin_ia32_scalefss_round_mask ((__v4sf) __A,
+             (__v4sf)( __B), (__v4sf) _mm_setzero_ps(),
+             (__mmask8) -1,
+             _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_scalef_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+ return (__m128) __builtin_ia32_scalefss_round_mask ( (__v4sf) __A,
+                (__v4sf) __B,
+                (__v4sf) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask_scalef_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_scalefss_round_mask((__v4sf)(__m128)(A), \
+                                              (__v4sf)(__m128)(B), \
+                                              (__v4sf)(__m128)(W), \
+                                              (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_scalef_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+ return (__m128) __builtin_ia32_scalefss_round_mask ( (__v4sf) __A,
+                 (__v4sf) __B,
+                (__v4sf) _mm_setzero_ps (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_scalef_round_ss(U, A, B, R) \
+  ((__m128)__builtin_ia32_scalefss_round_mask((__v4sf)(__m128)(A), \
+                                              (__v4sf)(__m128)(B), \
+                                              (__v4sf)_mm_setzero_ps(), \
+                                              (__mmask8)(U), \
+                                              (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srai_epi32(__m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_psradi512((__v16si)__A, (int)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srai_epi32(__m512i __W, __mmask16 __U, __m512i __A,
+                       unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                         (__v16si)_mm512_srai_epi32(__A, __B),
+                                         (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srai_epi32(__mmask16 __U, __m512i __A,
+                        unsigned int __B) {
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__U,
+                                         (__v16si)_mm512_srai_epi32(__A, __B),
+                                         (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_srai_epi64(__m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_psraqi512((__v8di)__A, (int)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_srai_epi64(__m512i __W, __mmask8 __U, __m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                          (__v8di)_mm512_srai_epi64(__A, __B),
+                                          (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_srai_epi64(__mmask8 __U, __m512i __A, unsigned int __B)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__U,
+                                          (__v8di)_mm512_srai_epi64(__A, __B),
+                                          (__v8di)_mm512_setzero_si512());
+}
+
+#define _mm512_shuffle_f32x4(A, B, imm) \
+  ((__m512)__builtin_ia32_shuf_f32x4((__v16sf)(__m512)(A), \
+                                     (__v16sf)(__m512)(B), (int)(imm)))
+
+#define _mm512_mask_shuffle_f32x4(W, U, A, B, imm) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                       (__v16sf)_mm512_shuffle_f32x4((A), (B), (imm)), \
+                                       (__v16sf)(__m512)(W)))
+
+#define _mm512_maskz_shuffle_f32x4(U, A, B, imm) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                       (__v16sf)_mm512_shuffle_f32x4((A), (B), (imm)), \
+                                       (__v16sf)_mm512_setzero_ps()))
+
+#define _mm512_shuffle_f64x2(A, B, imm) \
+  ((__m512d)__builtin_ia32_shuf_f64x2((__v8df)(__m512d)(A), \
+                                      (__v8df)(__m512d)(B), (int)(imm)))
+
+#define _mm512_mask_shuffle_f64x2(W, U, A, B, imm) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                        (__v8df)_mm512_shuffle_f64x2((A), (B), (imm)), \
+                                        (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_shuffle_f64x2(U, A, B, imm) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                        (__v8df)_mm512_shuffle_f64x2((A), (B), (imm)), \
+                                        (__v8df)_mm512_setzero_pd()))
+
+#define _mm512_shuffle_i32x4(A, B, imm) \
+  ((__m512i)__builtin_ia32_shuf_i32x4((__v16si)(__m512i)(A), \
+                                      (__v16si)(__m512i)(B), (int)(imm)))
+
+#define _mm512_mask_shuffle_i32x4(W, U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                       (__v16si)_mm512_shuffle_i32x4((A), (B), (imm)), \
+                                       (__v16si)(__m512i)(W)))
+
+#define _mm512_maskz_shuffle_i32x4(U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                       (__v16si)_mm512_shuffle_i32x4((A), (B), (imm)), \
+                                       (__v16si)_mm512_setzero_si512()))
+
+#define _mm512_shuffle_i64x2(A, B, imm) \
+  ((__m512i)__builtin_ia32_shuf_i64x2((__v8di)(__m512i)(A), \
+                                      (__v8di)(__m512i)(B), (int)(imm)))
+
+#define _mm512_mask_shuffle_i64x2(W, U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                       (__v8di)_mm512_shuffle_i64x2((A), (B), (imm)), \
+                                       (__v8di)(__m512i)(W)))
+
+#define _mm512_maskz_shuffle_i64x2(U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                       (__v8di)_mm512_shuffle_i64x2((A), (B), (imm)), \
+                                       (__v8di)_mm512_setzero_si512()))
+
+#define _mm512_shuffle_pd(A, B, M) \
+  ((__m512d)__builtin_ia32_shufpd512((__v8df)(__m512d)(A), \
+                                     (__v8df)(__m512d)(B), (int)(M)))
+
+#define _mm512_mask_shuffle_pd(W, U, A, B, M) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                        (__v8df)_mm512_shuffle_pd((A), (B), (M)), \
+                                        (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_shuffle_pd(U, A, B, M) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                        (__v8df)_mm512_shuffle_pd((A), (B), (M)), \
+                                        (__v8df)_mm512_setzero_pd()))
+
+#define _mm512_shuffle_ps(A, B, M) \
+  ((__m512)__builtin_ia32_shufps512((__v16sf)(__m512)(A), \
+                                    (__v16sf)(__m512)(B), (int)(M)))
+
+#define _mm512_mask_shuffle_ps(W, U, A, B, M) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                       (__v16sf)_mm512_shuffle_ps((A), (B), (M)), \
+                                       (__v16sf)(__m512)(W)))
+
+#define _mm512_maskz_shuffle_ps(U, A, B, M) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                       (__v16sf)_mm512_shuffle_ps((A), (B), (M)), \
+                                       (__v16sf)_mm512_setzero_ps()))
+
+#define _mm_sqrt_round_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_sqrtsd_round_mask((__v2df)(__m128d)(A), \
+                                             (__v2df)(__m128d)(B), \
+                                             (__v2df)_mm_setzero_pd(), \
+                                             (__mmask8)-1, (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_sqrt_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+ return (__m128d) __builtin_ia32_sqrtsd_round_mask ( (__v2df) __A,
+                 (__v2df) __B,
+                (__v2df) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask_sqrt_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_sqrtsd_round_mask((__v2df)(__m128d)(A), \
+                                             (__v2df)(__m128d)(B), \
+                                             (__v2df)(__m128d)(W), \
+                                             (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_sqrt_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+ return (__m128d) __builtin_ia32_sqrtsd_round_mask ( (__v2df) __A,
+                 (__v2df) __B,
+                (__v2df) _mm_setzero_pd (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_sqrt_round_sd(U, A, B, R) \
+  ((__m128d)__builtin_ia32_sqrtsd_round_mask((__v2df)(__m128d)(A), \
+                                             (__v2df)(__m128d)(B), \
+                                             (__v2df)_mm_setzero_pd(), \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm_sqrt_round_ss(A, B, R) \
+  ((__m128)__builtin_ia32_sqrtss_round_mask((__v4sf)(__m128)(A), \
+                                            (__v4sf)(__m128)(B), \
+                                            (__v4sf)_mm_setzero_ps(), \
+                                            (__mmask8)-1, (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_sqrt_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+ return (__m128) __builtin_ia32_sqrtss_round_mask ( (__v4sf) __A,
+                 (__v4sf) __B,
+                (__v4sf) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask_sqrt_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_sqrtss_round_mask((__v4sf)(__m128)(A), \
+                                            (__v4sf)(__m128)(B), \
+                                            (__v4sf)(__m128)(W), (__mmask8)(U), \
+                                            (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_sqrt_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+ return (__m128) __builtin_ia32_sqrtss_round_mask ( (__v4sf) __A,
+                 (__v4sf) __B,
+                (__v4sf) _mm_setzero_ps (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_sqrt_round_ss(U, A, B, R) \
+  ((__m128)__builtin_ia32_sqrtss_round_mask((__v4sf)(__m128)(A), \
+                                            (__v4sf)(__m128)(B), \
+                                            (__v4sf)_mm_setzero_ps(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_broadcast_f32x4(__m128 __A)
+{
+  return (__m512)__builtin_shufflevector((__v4sf)__A, (__v4sf)__A,
+                                         0, 1, 2, 3, 0, 1, 2, 3,
+                                         0, 1, 2, 3, 0, 1, 2, 3);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcast_f32x4(__m512 __O, __mmask16 __M, __m128 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__M,
+                                           (__v16sf)_mm512_broadcast_f32x4(__A),
+                                           (__v16sf)__O);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcast_f32x4(__mmask16 __M, __m128 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__M,
+                                           (__v16sf)_mm512_broadcast_f32x4(__A),
+                                           (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_broadcast_f64x4(__m256d __A)
+{
+  return (__m512d)__builtin_shufflevector((__v4df)__A, (__v4df)__A,
+                                          0, 1, 2, 3, 0, 1, 2, 3);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcast_f64x4(__m512d __O, __mmask8 __M, __m256d __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__M,
+                                            (__v8df)_mm512_broadcast_f64x4(__A),
+                                            (__v8df)__O);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcast_f64x4(__mmask8 __M, __m256d __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__M,
+                                            (__v8df)_mm512_broadcast_f64x4(__A),
+                                            (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_broadcast_i32x4(__m128i __A)
+{
+  return (__m512i)__builtin_shufflevector((__v4si)__A, (__v4si)__A,
+                                          0, 1, 2, 3, 0, 1, 2, 3,
+                                          0, 1, 2, 3, 0, 1, 2, 3);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcast_i32x4(__m512i __O, __mmask16 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                           (__v16si)_mm512_broadcast_i32x4(__A),
+                                           (__v16si)__O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcast_i32x4(__mmask16 __M, __m128i __A)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                           (__v16si)_mm512_broadcast_i32x4(__A),
+                                           (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_broadcast_i64x4(__m256i __A)
+{
+  return (__m512i)__builtin_shufflevector((__v4di)__A, (__v4di)__A,
+                                          0, 1, 2, 3, 0, 1, 2, 3);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcast_i64x4(__m512i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                            (__v8di)_mm512_broadcast_i64x4(__A),
+                                            (__v8di)__O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcast_i64x4(__mmask8 __M, __m256i __A)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                            (__v8di)_mm512_broadcast_i64x4(__A),
+                                            (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcastsd_pd (__m512d __O, __mmask8 __M, __m128d __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__M,
+                                              (__v8df) _mm512_broadcastsd_pd(__A),
+                                              (__v8df) __O);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcastsd_pd (__mmask8 __M, __m128d __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512(__M,
+                                              (__v8df) _mm512_broadcastsd_pd(__A),
+                                              (__v8df) _mm512_setzero_pd());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_broadcastss_ps (__m512 __O, __mmask16 __M, __m128 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512(__M,
+                                             (__v16sf) _mm512_broadcastss_ps(__A),
+                                             (__v16sf) __O);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_broadcastss_ps (__mmask16 __M, __m128 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512(__M,
+                                             (__v16sf) _mm512_broadcastss_ps(__A),
+                                             (__v16sf) _mm512_setzero_ps());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_cvtsepi32_epi8 (__m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdb512_mask ((__v16si) __A,
+               (__v16qi) _mm_undefined_si128 (),
+               (__mmask16) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdb512_mask ((__v16si) __A,
+               (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtsepi32_epi8 (__mmask16 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdb512_mask ((__v16si) __A,
+               (__v16qi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
+{
+  __builtin_ia32_pmovsdb512mem_mask ((__v16qi *) __P, (__v16si) __A, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtsepi32_epi16 (__m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovsdw512_mask ((__v16si) __A,
+               (__v16hi) _mm256_undefined_si256 (),
+               (__mmask16) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovsdw512_mask ((__v16si) __A,
+               (__v16hi) __O, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtsepi32_epi16 (__mmask16 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovsdw512_mask ((__v16si) __A,
+               (__v16hi) _mm256_setzero_si256 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi32_storeu_epi16 (void *__P, __mmask16 __M, __m512i __A)
+{
+  __builtin_ia32_pmovsdw512mem_mask ((__v16hi*) __P, (__v16si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_cvtsepi64_epi8 (__m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqb512_mask ((__v8di) __A,
+               (__v16qi) _mm_undefined_si128 (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqb512_mask ((__v8di) __A,
+               (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtsepi64_epi8 (__mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqb512_mask ((__v8di) __A,
+               (__v16qi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
+{
+  __builtin_ia32_pmovsqb512mem_mask ((__v16qi *) __P, (__v8di) __A, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtsepi64_epi32 (__m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovsqd512_mask ((__v8di) __A,
+               (__v8si) _mm256_undefined_si256 (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovsqd512_mask ((__v8di) __A,
+               (__v8si) __O, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtsepi64_epi32 (__mmask8 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovsqd512_mask ((__v8di) __A,
+               (__v8si) _mm256_setzero_si256 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi64_storeu_epi32 (void *__P, __mmask8 __M, __m512i __A)
+{
+  __builtin_ia32_pmovsqd512mem_mask ((__v8si *) __P, (__v8di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_cvtsepi64_epi16 (__m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqw512_mask ((__v8di) __A,
+               (__v8hi) _mm_undefined_si128 (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqw512_mask ((__v8di) __A,
+               (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtsepi64_epi16 (__mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqw512_mask ((__v8di) __A,
+               (__v8hi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtsepi64_storeu_epi16 (void * __P, __mmask8 __M, __m512i __A)
+{
+  __builtin_ia32_pmovsqw512mem_mask ((__v8hi *) __P, (__v8di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_cvtusepi32_epi8 (__m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdb512_mask ((__v16si) __A,
+                (__v16qi) _mm_undefined_si128 (),
+                (__mmask16) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdb512_mask ((__v16si) __A,
+                (__v16qi) __O,
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtusepi32_epi8 (__mmask16 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdb512_mask ((__v16si) __A,
+                (__v16qi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
+{
+  __builtin_ia32_pmovusdb512mem_mask ((__v16qi *) __P, (__v16si) __A, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtusepi32_epi16 (__m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovusdw512_mask ((__v16si) __A,
+                (__v16hi) _mm256_undefined_si256 (),
+                (__mmask16) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovusdw512_mask ((__v16si) __A,
+                (__v16hi) __O,
+                __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtusepi32_epi16 (__mmask16 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovusdw512_mask ((__v16si) __A,
+                (__v16hi) _mm256_setzero_si256 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi32_storeu_epi16 (void *__P, __mmask16 __M, __m512i __A)
+{
+  __builtin_ia32_pmovusdw512mem_mask ((__v16hi*) __P, (__v16si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_cvtusepi64_epi8 (__m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqb512_mask ((__v8di) __A,
+                (__v16qi) _mm_undefined_si128 (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqb512_mask ((__v8di) __A,
+                (__v16qi) __O,
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtusepi64_epi8 (__mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqb512_mask ((__v8di) __A,
+                (__v16qi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
+{
+  __builtin_ia32_pmovusqb512mem_mask ((__v16qi *) __P, (__v8di) __A, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtusepi64_epi32 (__m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovusqd512_mask ((__v8di) __A,
+                (__v8si) _mm256_undefined_si256 (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovusqd512_mask ((__v8di) __A,
+                (__v8si) __O, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtusepi64_epi32 (__mmask8 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovusqd512_mask ((__v8di) __A,
+                (__v8si) _mm256_setzero_si256 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi64_storeu_epi32 (void* __P, __mmask8 __M, __m512i __A)
+{
+  __builtin_ia32_pmovusqd512mem_mask ((__v8si*) __P, (__v8di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_cvtusepi64_epi16 (__m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqw512_mask ((__v8di) __A,
+                (__v8hi) _mm_undefined_si128 (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqw512_mask ((__v8di) __A,
+                (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtusepi64_epi16 (__mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqw512_mask ((__v8di) __A,
+                (__v8hi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtusepi64_storeu_epi16 (void *__P, __mmask8 __M, __m512i __A)
+{
+  __builtin_ia32_pmovusqw512mem_mask ((__v8hi*) __P, (__v8di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi32_epi8 (__m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdb512_mask ((__v16si) __A,
+              (__v16qi) _mm_undefined_si128 (),
+              (__mmask16) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi32_epi8 (__m128i __O, __mmask16 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdb512_mask ((__v16si) __A,
+              (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi32_epi8 (__mmask16 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdb512_mask ((__v16si) __A,
+              (__v16qi) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi32_storeu_epi8 (void * __P, __mmask16 __M, __m512i __A)
+{
+  __builtin_ia32_pmovdb512mem_mask ((__v16qi *) __P, (__v16si) __A, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi32_epi16 (__m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovdw512_mask ((__v16si) __A,
+              (__v16hi) _mm256_undefined_si256 (),
+              (__mmask16) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi32_epi16 (__m256i __O, __mmask16 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovdw512_mask ((__v16si) __A,
+              (__v16hi) __O, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi32_epi16 (__mmask16 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovdw512_mask ((__v16si) __A,
+              (__v16hi) _mm256_setzero_si256 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi32_storeu_epi16 (void * __P, __mmask16 __M, __m512i __A)
+{
+  __builtin_ia32_pmovdw512mem_mask ((__v16hi *) __P, (__v16si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi64_epi8 (__m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqb512_mask ((__v8di) __A,
+              (__v16qi) _mm_undefined_si128 (),
+              (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi64_epi8 (__m128i __O, __mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqb512_mask ((__v8di) __A,
+              (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi64_epi8 (__mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqb512_mask ((__v8di) __A,
+              (__v16qi) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi64_storeu_epi8 (void * __P, __mmask8 __M, __m512i __A)
+{
+  __builtin_ia32_pmovqb512mem_mask ((__v16qi *) __P, (__v8di) __A, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi64_epi32 (__m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovqd512_mask ((__v8di) __A,
+              (__v8si) _mm256_undefined_si256 (),
+              (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi64_epi32 (__m256i __O, __mmask8 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovqd512_mask ((__v8di) __A,
+              (__v8si) __O, __M);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi64_epi32 (__mmask8 __M, __m512i __A)
+{
+  return (__m256i) __builtin_ia32_pmovqd512_mask ((__v8di) __A,
+              (__v8si) _mm256_setzero_si256 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi64_storeu_epi32 (void* __P, __mmask8 __M, __m512i __A)
+{
+  __builtin_ia32_pmovqd512mem_mask ((__v8si *) __P, (__v8di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_cvtepi64_epi16 (__m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqw512_mask ((__v8di) __A,
+              (__v8hi) _mm_undefined_si128 (),
+              (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi64_epi16 (__m128i __O, __mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqw512_mask ((__v8di) __A,
+              (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi64_epi16 (__mmask8 __M, __m512i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqw512_mask ((__v8di) __A,
+              (__v8hi) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi64_storeu_epi16 (void *__P, __mmask8 __M, __m512i __A)
+{
+  __builtin_ia32_pmovqw512mem_mask ((__v8hi *) __P, (__v8di) __A, __M);
+}
+
+#define _mm512_extracti32x4_epi32(A, imm) \
+  ((__m128i)__builtin_ia32_extracti32x4_mask((__v16si)(__m512i)(A), (int)(imm), \
+                                             (__v4si)_mm_undefined_si128(), \
+                                             (__mmask8)-1))
+
+#define _mm512_mask_extracti32x4_epi32(W, U, A, imm) \
+  ((__m128i)__builtin_ia32_extracti32x4_mask((__v16si)(__m512i)(A), (int)(imm), \
+                                             (__v4si)(__m128i)(W), \
+                                             (__mmask8)(U)))
+
+#define _mm512_maskz_extracti32x4_epi32(U, A, imm) \
+  ((__m128i)__builtin_ia32_extracti32x4_mask((__v16si)(__m512i)(A), (int)(imm), \
+                                             (__v4si)_mm_setzero_si128(), \
+                                             (__mmask8)(U)))
+
+#define _mm512_extracti64x4_epi64(A, imm) \
+  ((__m256i)__builtin_ia32_extracti64x4_mask((__v8di)(__m512i)(A), (int)(imm), \
+                                             (__v4di)_mm256_undefined_si256(), \
+                                             (__mmask8)-1))
+
+#define _mm512_mask_extracti64x4_epi64(W, U, A, imm) \
+  ((__m256i)__builtin_ia32_extracti64x4_mask((__v8di)(__m512i)(A), (int)(imm), \
+                                             (__v4di)(__m256i)(W), \
+                                             (__mmask8)(U)))
+
+#define _mm512_maskz_extracti64x4_epi64(U, A, imm) \
+  ((__m256i)__builtin_ia32_extracti64x4_mask((__v8di)(__m512i)(A), (int)(imm), \
+                                             (__v4di)_mm256_setzero_si256(), \
+                                             (__mmask8)(U)))
+
+#define _mm512_insertf64x4(A, B, imm) \
+  ((__m512d)__builtin_ia32_insertf64x4((__v8df)(__m512d)(A), \
+                                       (__v4df)(__m256d)(B), (int)(imm)))
+
+#define _mm512_mask_insertf64x4(W, U, A, B, imm) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_insertf64x4((A), (B), (imm)), \
+                                   (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_insertf64x4(U, A, B, imm) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                   (__v8df)_mm512_insertf64x4((A), (B), (imm)), \
+                                   (__v8df)_mm512_setzero_pd()))
+
+#define _mm512_inserti64x4(A, B, imm) \
+  ((__m512i)__builtin_ia32_inserti64x4((__v8di)(__m512i)(A), \
+                                       (__v4di)(__m256i)(B), (int)(imm)))
+
+#define _mm512_mask_inserti64x4(W, U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                   (__v8di)_mm512_inserti64x4((A), (B), (imm)), \
+                                   (__v8di)(__m512i)(W)))
+
+#define _mm512_maskz_inserti64x4(U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                   (__v8di)_mm512_inserti64x4((A), (B), (imm)), \
+                                   (__v8di)_mm512_setzero_si512()))
+
+#define _mm512_insertf32x4(A, B, imm) \
+  ((__m512)__builtin_ia32_insertf32x4((__v16sf)(__m512)(A), \
+                                      (__v4sf)(__m128)(B), (int)(imm)))
+
+#define _mm512_mask_insertf32x4(W, U, A, B, imm) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_insertf32x4((A), (B), (imm)), \
+                                  (__v16sf)(__m512)(W)))
+
+#define _mm512_maskz_insertf32x4(U, A, B, imm) \
+  ((__m512)__builtin_ia32_selectps_512((__mmask16)(U), \
+                                  (__v16sf)_mm512_insertf32x4((A), (B), (imm)), \
+                                  (__v16sf)_mm512_setzero_ps()))
+
+#define _mm512_inserti32x4(A, B, imm) \
+  ((__m512i)__builtin_ia32_inserti32x4((__v16si)(__m512i)(A), \
+                                       (__v4si)(__m128i)(B), (int)(imm)))
+
+#define _mm512_mask_inserti32x4(W, U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                  (__v16si)_mm512_inserti32x4((A), (B), (imm)), \
+                                  (__v16si)(__m512i)(W)))
+
+#define _mm512_maskz_inserti32x4(U, A, B, imm) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                  (__v16si)_mm512_inserti32x4((A), (B), (imm)), \
+                                  (__v16si)_mm512_setzero_si512()))
+
+#define _mm512_getmant_round_pd(A, B, C, R) \
+  ((__m512d)__builtin_ia32_getmantpd512_mask((__v8df)(__m512d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v8df)_mm512_undefined_pd(), \
+                                             (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_getmant_round_pd(W, U, A, B, C, R) \
+  ((__m512d)__builtin_ia32_getmantpd512_mask((__v8df)(__m512d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v8df)(__m512d)(W), \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_getmant_round_pd(U, A, B, C, R) \
+  ((__m512d)__builtin_ia32_getmantpd512_mask((__v8df)(__m512d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v8df)_mm512_setzero_pd(), \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_getmant_pd(A, B, C) \
+  ((__m512d)__builtin_ia32_getmantpd512_mask((__v8df)(__m512d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v8df)_mm512_setzero_pd(), \
+                                             (__mmask8)-1, \
+                                             _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_getmant_pd(W, U, A, B, C) \
+  ((__m512d)__builtin_ia32_getmantpd512_mask((__v8df)(__m512d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v8df)(__m512d)(W), \
+                                             (__mmask8)(U), \
+                                             _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_getmant_pd(U, A, B, C) \
+  ((__m512d)__builtin_ia32_getmantpd512_mask((__v8df)(__m512d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v8df)_mm512_setzero_pd(), \
+                                             (__mmask8)(U), \
+                                             _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_getmant_round_ps(A, B, C, R) \
+  ((__m512)__builtin_ia32_getmantps512_mask((__v16sf)(__m512)(A), \
+                                            (int)(((C)<<2) | (B)), \
+                                            (__v16sf)_mm512_undefined_ps(), \
+                                            (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_getmant_round_ps(W, U, A, B, C, R) \
+  ((__m512)__builtin_ia32_getmantps512_mask((__v16sf)(__m512)(A), \
+                                            (int)(((C)<<2) | (B)), \
+                                            (__v16sf)(__m512)(W), \
+                                            (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_getmant_round_ps(U, A, B, C, R) \
+  ((__m512)__builtin_ia32_getmantps512_mask((__v16sf)(__m512)(A), \
+                                            (int)(((C)<<2) | (B)), \
+                                            (__v16sf)_mm512_setzero_ps(), \
+                                            (__mmask16)(U), (int)(R)))
+
+#define _mm512_getmant_ps(A, B, C) \
+  ((__m512)__builtin_ia32_getmantps512_mask((__v16sf)(__m512)(A), \
+                                            (int)(((C)<<2)|(B)), \
+                                            (__v16sf)_mm512_undefined_ps(), \
+                                            (__mmask16)-1, \
+                                            _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_getmant_ps(W, U, A, B, C) \
+  ((__m512)__builtin_ia32_getmantps512_mask((__v16sf)(__m512)(A), \
+                                            (int)(((C)<<2)|(B)), \
+                                            (__v16sf)(__m512)(W), \
+                                            (__mmask16)(U), \
+                                            _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_getmant_ps(U, A, B, C) \
+  ((__m512)__builtin_ia32_getmantps512_mask((__v16sf)(__m512)(A), \
+                                            (int)(((C)<<2)|(B)), \
+                                            (__v16sf)_mm512_setzero_ps(), \
+                                            (__mmask16)(U), \
+                                            _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_getexp_round_pd(A, R) \
+  ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), \
+                                            (__v8df)_mm512_undefined_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_getexp_round_pd(W, U, A, R) \
+  ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), \
+                                            (__v8df)(__m512d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_getexp_round_pd(U, A, R) \
+  ((__m512d)__builtin_ia32_getexppd512_mask((__v8df)(__m512d)(A), \
+                                            (__v8df)_mm512_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_getexp_pd (__m512d __A)
+{
+  return (__m512d) __builtin_ia32_getexppd512_mask ((__v8df) __A,
+                (__v8df) _mm512_undefined_pd (),
+                (__mmask8) -1,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_getexp_pd (__m512d __W, __mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_getexppd512_mask ((__v8df) __A,
+                (__v8df) __W,
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_getexp_pd (__mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_getexppd512_mask ((__v8df) __A,
+                (__v8df) _mm512_setzero_pd (),
+                (__mmask8) __U,
+                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_getexp_round_ps(A, R) \
+  ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)_mm512_undefined_ps(), \
+                                           (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_getexp_round_ps(W, U, A, R) \
+  ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)(__m512)(W), \
+                                           (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_getexp_round_ps(U, A, R) \
+  ((__m512)__builtin_ia32_getexpps512_mask((__v16sf)(__m512)(A), \
+                                           (__v16sf)_mm512_setzero_ps(), \
+                                           (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_getexp_ps (__m512 __A)
+{
+  return (__m512) __builtin_ia32_getexpps512_mask ((__v16sf) __A,
+               (__v16sf) _mm512_undefined_ps (),
+               (__mmask16) -1,
+               _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_getexp_ps (__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_getexpps512_mask ((__v16sf) __A,
+               (__v16sf) __W,
+               (__mmask16) __U,
+               _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_getexp_ps (__mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_getexpps512_mask ((__v16sf) __A,
+               (__v16sf) _mm512_setzero_ps (),
+               (__mmask16) __U,
+               _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_i64gather_ps(index, addr, scale) \
+  ((__m256)__builtin_ia32_gatherdiv16sf((__v8sf)_mm256_undefined_ps(), \
+                                        (void const *)(addr), \
+                                        (__v8di)(__m512i)(index), (__mmask8)-1, \
+                                        (int)(scale)))
+
+#define _mm512_mask_i64gather_ps(v1_old, mask, index, addr, scale) \
+  ((__m256)__builtin_ia32_gatherdiv16sf((__v8sf)(__m256)(v1_old),\
+                                        (void const *)(addr), \
+                                        (__v8di)(__m512i)(index), \
+                                        (__mmask8)(mask), (int)(scale)))
+
+#define _mm512_i64gather_epi32(index, addr, scale) \
+  ((__m256i)__builtin_ia32_gatherdiv16si((__v8si)_mm256_undefined_si256(), \
+                                         (void const *)(addr), \
+                                         (__v8di)(__m512i)(index), \
+                                         (__mmask8)-1, (int)(scale)))
+
+#define _mm512_mask_i64gather_epi32(v1_old, mask, index, addr, scale) \
+  ((__m256i)__builtin_ia32_gatherdiv16si((__v8si)(__m256i)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v8di)(__m512i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm512_i64gather_pd(index, addr, scale) \
+  ((__m512d)__builtin_ia32_gatherdiv8df((__v8df)_mm512_undefined_pd(), \
+                                        (void const *)(addr), \
+                                        (__v8di)(__m512i)(index), (__mmask8)-1, \
+                                        (int)(scale)))
+
+#define _mm512_mask_i64gather_pd(v1_old, mask, index, addr, scale) \
+  ((__m512d)__builtin_ia32_gatherdiv8df((__v8df)(__m512d)(v1_old), \
+                                        (void const *)(addr), \
+                                        (__v8di)(__m512i)(index), \
+                                        (__mmask8)(mask), (int)(scale)))
+
+#define _mm512_i64gather_epi64(index, addr, scale) \
+  ((__m512i)__builtin_ia32_gatherdiv8di((__v8di)_mm512_undefined_epi32(), \
+                                        (void const *)(addr), \
+                                        (__v8di)(__m512i)(index), (__mmask8)-1, \
+                                        (int)(scale)))
+
+#define _mm512_mask_i64gather_epi64(v1_old, mask, index, addr, scale) \
+  ((__m512i)__builtin_ia32_gatherdiv8di((__v8di)(__m512i)(v1_old), \
+                                        (void const *)(addr), \
+                                        (__v8di)(__m512i)(index), \
+                                        (__mmask8)(mask), (int)(scale)))
+
+#define _mm512_i32gather_ps(index, addr, scale) \
+  ((__m512)__builtin_ia32_gathersiv16sf((__v16sf)_mm512_undefined_ps(), \
+                                        (void const *)(addr), \
+                                        (__v16si)(__m512)(index), \
+                                        (__mmask16)-1, (int)(scale)))
+
+#define _mm512_mask_i32gather_ps(v1_old, mask, index, addr, scale) \
+  ((__m512)__builtin_ia32_gathersiv16sf((__v16sf)(__m512)(v1_old), \
+                                        (void const *)(addr), \
+                                        (__v16si)(__m512)(index), \
+                                        (__mmask16)(mask), (int)(scale)))
+
+#define _mm512_i32gather_epi32(index, addr, scale) \
+  ((__m512i)__builtin_ia32_gathersiv16si((__v16si)_mm512_undefined_epi32(), \
+                                         (void const *)(addr), \
+                                         (__v16si)(__m512i)(index), \
+                                         (__mmask16)-1, (int)(scale)))
+
+#define _mm512_mask_i32gather_epi32(v1_old, mask, index, addr, scale) \
+  ((__m512i)__builtin_ia32_gathersiv16si((__v16si)(__m512i)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v16si)(__m512i)(index), \
+                                         (__mmask16)(mask), (int)(scale)))
+
+#define _mm512_i32gather_pd(index, addr, scale) \
+  ((__m512d)__builtin_ia32_gathersiv8df((__v8df)_mm512_undefined_pd(), \
+                                        (void const *)(addr), \
+                                        (__v8si)(__m256i)(index), (__mmask8)-1, \
+                                        (int)(scale)))
+
+#define _mm512_mask_i32gather_pd(v1_old, mask, index, addr, scale) \
+  ((__m512d)__builtin_ia32_gathersiv8df((__v8df)(__m512d)(v1_old), \
+                                        (void const *)(addr), \
+                                        (__v8si)(__m256i)(index), \
+                                        (__mmask8)(mask), (int)(scale)))
+
+#define _mm512_i32gather_epi64(index, addr, scale) \
+  ((__m512i)__builtin_ia32_gathersiv8di((__v8di)_mm512_undefined_epi32(), \
+                                        (void const *)(addr), \
+                                        (__v8si)(__m256i)(index), (__mmask8)-1, \
+                                        (int)(scale)))
+
+#define _mm512_mask_i32gather_epi64(v1_old, mask, index, addr, scale) \
+  ((__m512i)__builtin_ia32_gathersiv8di((__v8di)(__m512i)(v1_old), \
+                                        (void const *)(addr), \
+                                        (__v8si)(__m256i)(index), \
+                                        (__mmask8)(mask), (int)(scale)))
+
+#define _mm512_i64scatter_ps(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv16sf((void *)(addr), (__mmask8)-1, \
+                                (__v8di)(__m512i)(index), \
+                                (__v8sf)(__m256)(v1), (int)(scale))
+
+#define _mm512_mask_i64scatter_ps(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv16sf((void *)(addr), (__mmask8)(mask), \
+                                (__v8di)(__m512i)(index), \
+                                (__v8sf)(__m256)(v1), (int)(scale))
+
+#define _mm512_i64scatter_epi32(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv16si((void *)(addr), (__mmask8)-1, \
+                                (__v8di)(__m512i)(index), \
+                                (__v8si)(__m256i)(v1), (int)(scale))
+
+#define _mm512_mask_i64scatter_epi32(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv16si((void *)(addr), (__mmask8)(mask), \
+                                (__v8di)(__m512i)(index), \
+                                (__v8si)(__m256i)(v1), (int)(scale))
+
+#define _mm512_i64scatter_pd(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv8df((void *)(addr), (__mmask8)-1, \
+                               (__v8di)(__m512i)(index), \
+                               (__v8df)(__m512d)(v1), (int)(scale))
+
+#define _mm512_mask_i64scatter_pd(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv8df((void *)(addr), (__mmask8)(mask), \
+                               (__v8di)(__m512i)(index), \
+                               (__v8df)(__m512d)(v1), (int)(scale))
+
+#define _mm512_i64scatter_epi64(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv8di((void *)(addr), (__mmask8)-1, \
+                               (__v8di)(__m512i)(index), \
+                               (__v8di)(__m512i)(v1), (int)(scale))
+
+#define _mm512_mask_i64scatter_epi64(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv8di((void *)(addr), (__mmask8)(mask), \
+                               (__v8di)(__m512i)(index), \
+                               (__v8di)(__m512i)(v1), (int)(scale))
+
+#define _mm512_i32scatter_ps(addr, index, v1, scale) \
+  __builtin_ia32_scattersiv16sf((void *)(addr), (__mmask16)-1, \
+                                (__v16si)(__m512i)(index), \
+                                (__v16sf)(__m512)(v1), (int)(scale))
+
+#define _mm512_mask_i32scatter_ps(addr, mask, index, v1, scale) \
+  __builtin_ia32_scattersiv16sf((void *)(addr), (__mmask16)(mask), \
+                                (__v16si)(__m512i)(index), \
+                                (__v16sf)(__m512)(v1), (int)(scale))
+
+#define _mm512_i32scatter_epi32(addr, index, v1, scale) \
+  __builtin_ia32_scattersiv16si((void *)(addr), (__mmask16)-1, \
+                                (__v16si)(__m512i)(index), \
+                                (__v16si)(__m512i)(v1), (int)(scale))
+
+#define _mm512_mask_i32scatter_epi32(addr, mask, index, v1, scale) \
+  __builtin_ia32_scattersiv16si((void *)(addr), (__mmask16)(mask), \
+                                (__v16si)(__m512i)(index), \
+                                (__v16si)(__m512i)(v1), (int)(scale))
+
+#define _mm512_i32scatter_pd(addr, index, v1, scale) \
+  __builtin_ia32_scattersiv8df((void *)(addr), (__mmask8)-1, \
+                               (__v8si)(__m256i)(index), \
+                               (__v8df)(__m512d)(v1), (int)(scale))
+
+#define _mm512_mask_i32scatter_pd(addr, mask, index, v1, scale) \
+  __builtin_ia32_scattersiv8df((void *)(addr), (__mmask8)(mask), \
+                               (__v8si)(__m256i)(index), \
+                               (__v8df)(__m512d)(v1), (int)(scale))
+
+#define _mm512_i32scatter_epi64(addr, index, v1, scale) \
+  __builtin_ia32_scattersiv8di((void *)(addr), (__mmask8)-1, \
+                               (__v8si)(__m256i)(index), \
+                               (__v8di)(__m512i)(v1), (int)(scale))
+
+#define _mm512_mask_i32scatter_epi64(addr, mask, index, v1, scale) \
+  __builtin_ia32_scattersiv8di((void *)(addr), (__mmask8)(mask), \
+                               (__v8si)(__m256i)(index), \
+                               (__v8di)(__m512i)(v1), (int)(scale))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_fmadd_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return __builtin_ia32_vfmaddss3_mask((__v4sf)__W,
+                                       (__v4sf)__A,
+                                       (__v4sf)__B,
+                                       (__mmask8)__U,
+                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fmadd_round_ss(A, B, C, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_mask((__v4sf)(__m128)(A), \
+                                         (__v4sf)(__m128)(B), \
+                                         (__v4sf)(__m128)(C), (__mmask8)-1, \
+                                         (int)(R)))
+
+#define _mm_mask_fmadd_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_mask((__v4sf)(__m128)(W), \
+                                         (__v4sf)(__m128)(A), \
+                                         (__v4sf)(__m128)(B), (__mmask8)(U), \
+                                         (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_fmadd_ss (__mmask8 __U, __m128 __A, __m128 __B, __m128 __C)
+{
+  return __builtin_ia32_vfmaddss3_maskz((__v4sf)__A,
+                                        (__v4sf)__B,
+                                        (__v4sf)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fmadd_round_ss(U, A, B, C, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_maskz((__v4sf)(__m128)(A), \
+                                          (__v4sf)(__m128)(B), \
+                                          (__v4sf)(__m128)(C), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask3_fmadd_ss (__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U)
+{
+  return __builtin_ia32_vfmaddss3_mask3((__v4sf)__W,
+                                        (__v4sf)__X,
+                                        (__v4sf)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fmadd_round_ss(W, X, Y, U, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_mask3((__v4sf)(__m128)(W), \
+                                          (__v4sf)(__m128)(X), \
+                                          (__v4sf)(__m128)(Y), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_fmsub_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return __builtin_ia32_vfmaddss3_mask((__v4sf)__W,
+                                       (__v4sf)__A,
+                                       -(__v4sf)__B,
+                                       (__mmask8)__U,
+                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fmsub_round_ss(A, B, C, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_mask((__v4sf)(__m128)(A), \
+                                         (__v4sf)(__m128)(B), \
+                                         -(__v4sf)(__m128)(C), (__mmask8)-1, \
+                                         (int)(R)))
+
+#define _mm_mask_fmsub_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_mask((__v4sf)(__m128)(W), \
+                                         (__v4sf)(__m128)(A), \
+                                         -(__v4sf)(__m128)(B), (__mmask8)(U), \
+                                         (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_fmsub_ss (__mmask8 __U, __m128 __A, __m128 __B, __m128 __C)
+{
+  return __builtin_ia32_vfmaddss3_maskz((__v4sf)__A,
+                                        (__v4sf)__B,
+                                        -(__v4sf)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fmsub_round_ss(U, A, B, C, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_maskz((__v4sf)(__m128)(A), \
+                                          (__v4sf)(__m128)(B), \
+                                          -(__v4sf)(__m128)(C), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask3_fmsub_ss (__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U)
+{
+  return __builtin_ia32_vfmsubss3_mask3((__v4sf)__W,
+                                        (__v4sf)__X,
+                                        (__v4sf)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fmsub_round_ss(W, X, Y, U, R) \
+  ((__m128)__builtin_ia32_vfmsubss3_mask3((__v4sf)(__m128)(W), \
+                                          (__v4sf)(__m128)(X), \
+                                          (__v4sf)(__m128)(Y), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_fnmadd_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return __builtin_ia32_vfmaddss3_mask((__v4sf)__W,
+                                       -(__v4sf)__A,
+                                       (__v4sf)__B,
+                                       (__mmask8)__U,
+                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fnmadd_round_ss(A, B, C, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_mask((__v4sf)(__m128)(A), \
+                                         -(__v4sf)(__m128)(B), \
+                                         (__v4sf)(__m128)(C), (__mmask8)-1, \
+                                         (int)(R)))
+
+#define _mm_mask_fnmadd_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_mask((__v4sf)(__m128)(W), \
+                                         -(__v4sf)(__m128)(A), \
+                                         (__v4sf)(__m128)(B), (__mmask8)(U), \
+                                         (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmadd_ss (__mmask8 __U, __m128 __A, __m128 __B, __m128 __C)
+{
+  return __builtin_ia32_vfmaddss3_maskz((__v4sf)__A,
+                                        -(__v4sf)__B,
+                                        (__v4sf)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fnmadd_round_ss(U, A, B, C, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_maskz((__v4sf)(__m128)(A), \
+                                          -(__v4sf)(__m128)(B), \
+                                          (__v4sf)(__m128)(C), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmadd_ss (__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U)
+{
+  return __builtin_ia32_vfmaddss3_mask3((__v4sf)__W,
+                                        -(__v4sf)__X,
+                                        (__v4sf)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fnmadd_round_ss(W, X, Y, U, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_mask3((__v4sf)(__m128)(W), \
+                                          -(__v4sf)(__m128)(X), \
+                                          (__v4sf)(__m128)(Y), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_fnmsub_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return __builtin_ia32_vfmaddss3_mask((__v4sf)__W,
+                                       -(__v4sf)__A,
+                                       -(__v4sf)__B,
+                                       (__mmask8)__U,
+                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fnmsub_round_ss(A, B, C, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_mask((__v4sf)(__m128)(A), \
+                                         -(__v4sf)(__m128)(B), \
+                                         -(__v4sf)(__m128)(C), (__mmask8)-1, \
+                                         (int)(R)))
+
+#define _mm_mask_fnmsub_round_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_mask((__v4sf)(__m128)(W), \
+                                         -(__v4sf)(__m128)(A), \
+                                         -(__v4sf)(__m128)(B), (__mmask8)(U), \
+                                         (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmsub_ss (__mmask8 __U, __m128 __A, __m128 __B, __m128 __C)
+{
+  return __builtin_ia32_vfmaddss3_maskz((__v4sf)__A,
+                                        -(__v4sf)__B,
+                                        -(__v4sf)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fnmsub_round_ss(U, A, B, C, R) \
+  ((__m128)__builtin_ia32_vfmaddss3_maskz((__v4sf)(__m128)(A), \
+                                          -(__v4sf)(__m128)(B), \
+                                          -(__v4sf)(__m128)(C), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmsub_ss (__m128 __W, __m128 __X, __m128 __Y, __mmask8 __U)
+{
+  return __builtin_ia32_vfmsubss3_mask3((__v4sf)__W,
+                                        -(__v4sf)__X,
+                                        (__v4sf)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fnmsub_round_ss(W, X, Y, U, R) \
+  ((__m128)__builtin_ia32_vfmsubss3_mask3((__v4sf)(__m128)(W), \
+                                          -(__v4sf)(__m128)(X), \
+                                          (__v4sf)(__m128)(Y), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_fmadd_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return __builtin_ia32_vfmaddsd3_mask((__v2df)__W,
+                                       (__v2df)__A,
+                                       (__v2df)__B,
+                                       (__mmask8)__U,
+                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fmadd_round_sd(A, B, C, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_mask((__v2df)(__m128d)(A), \
+                                          (__v2df)(__m128d)(B), \
+                                          (__v2df)(__m128d)(C), (__mmask8)-1, \
+                                          (int)(R)))
+
+#define _mm_mask_fmadd_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_mask((__v2df)(__m128d)(W), \
+                                          (__v2df)(__m128d)(A), \
+                                          (__v2df)(__m128d)(B), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_fmadd_sd (__mmask8 __U, __m128d __A, __m128d __B, __m128d __C)
+{
+  return __builtin_ia32_vfmaddsd3_maskz((__v2df)__A,
+                                        (__v2df)__B,
+                                        (__v2df)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fmadd_round_sd(U, A, B, C, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_maskz((__v2df)(__m128d)(A), \
+                                           (__v2df)(__m128d)(B), \
+                                           (__v2df)(__m128d)(C), (__mmask8)(U), \
+                                           (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask3_fmadd_sd (__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U)
+{
+  return __builtin_ia32_vfmaddsd3_mask3((__v2df)__W,
+                                        (__v2df)__X,
+                                        (__v2df)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fmadd_round_sd(W, X, Y, U, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_mask3((__v2df)(__m128d)(W), \
+                                           (__v2df)(__m128d)(X), \
+                                           (__v2df)(__m128d)(Y), (__mmask8)(U), \
+                                           (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_fmsub_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return __builtin_ia32_vfmaddsd3_mask((__v2df)__W,
+                                       (__v2df)__A,
+                                       -(__v2df)__B,
+                                       (__mmask8)__U,
+                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fmsub_round_sd(A, B, C, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_mask((__v2df)(__m128d)(A), \
+                                          (__v2df)(__m128d)(B), \
+                                          -(__v2df)(__m128d)(C), (__mmask8)-1, \
+                                          (int)(R)))
+
+#define _mm_mask_fmsub_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_mask((__v2df)(__m128d)(W), \
+                                          (__v2df)(__m128d)(A), \
+                                          -(__v2df)(__m128d)(B), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_fmsub_sd (__mmask8 __U, __m128d __A, __m128d __B, __m128d __C)
+{
+  return __builtin_ia32_vfmaddsd3_maskz((__v2df)__A,
+                                        (__v2df)__B,
+                                        -(__v2df)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fmsub_round_sd(U, A, B, C, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_maskz((__v2df)(__m128d)(A), \
+                                           (__v2df)(__m128d)(B), \
+                                           -(__v2df)(__m128d)(C), \
+                                           (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask3_fmsub_sd (__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U)
+{
+  return __builtin_ia32_vfmsubsd3_mask3((__v2df)__W,
+                                        (__v2df)__X,
+                                        (__v2df)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fmsub_round_sd(W, X, Y, U, R) \
+  ((__m128d)__builtin_ia32_vfmsubsd3_mask3((__v2df)(__m128d)(W), \
+                                           (__v2df)(__m128d)(X), \
+                                           (__v2df)(__m128d)(Y), \
+                                           (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_fnmadd_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return __builtin_ia32_vfmaddsd3_mask((__v2df)__W,
+                                       -(__v2df)__A,
+                                       (__v2df)__B,
+                                       (__mmask8)__U,
+                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fnmadd_round_sd(A, B, C, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_mask((__v2df)(__m128d)(A), \
+                                          -(__v2df)(__m128d)(B), \
+                                          (__v2df)(__m128d)(C), (__mmask8)-1, \
+                                          (int)(R)))
+
+#define _mm_mask_fnmadd_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_mask((__v2df)(__m128d)(W), \
+                                          -(__v2df)(__m128d)(A), \
+                                          (__v2df)(__m128d)(B), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmadd_sd (__mmask8 __U, __m128d __A, __m128d __B, __m128d __C)
+{
+  return __builtin_ia32_vfmaddsd3_maskz((__v2df)__A,
+                                        -(__v2df)__B,
+                                        (__v2df)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fnmadd_round_sd(U, A, B, C, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_maskz((__v2df)(__m128d)(A), \
+                                           -(__v2df)(__m128d)(B), \
+                                           (__v2df)(__m128d)(C), (__mmask8)(U), \
+                                           (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmadd_sd (__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U)
+{
+  return __builtin_ia32_vfmaddsd3_mask3((__v2df)__W,
+                                        -(__v2df)__X,
+                                        (__v2df)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fnmadd_round_sd(W, X, Y, U, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_mask3((__v2df)(__m128d)(W), \
+                                           -(__v2df)(__m128d)(X), \
+                                           (__v2df)(__m128d)(Y), (__mmask8)(U), \
+                                           (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_fnmsub_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return __builtin_ia32_vfmaddsd3_mask((__v2df)__W,
+                                       -(__v2df)__A,
+                                       -(__v2df)__B,
+                                       (__mmask8)__U,
+                                       _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fnmsub_round_sd(A, B, C, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_mask((__v2df)(__m128d)(A), \
+                                          -(__v2df)(__m128d)(B), \
+                                          -(__v2df)(__m128d)(C), (__mmask8)-1, \
+                                          (int)(R)))
+
+#define _mm_mask_fnmsub_round_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_mask((__v2df)(__m128d)(W), \
+                                          -(__v2df)(__m128d)(A), \
+                                          -(__v2df)(__m128d)(B), (__mmask8)(U), \
+                                          (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmsub_sd (__mmask8 __U, __m128d __A, __m128d __B, __m128d __C)
+{
+  return __builtin_ia32_vfmaddsd3_maskz((__v2df)__A,
+                                        -(__v2df)__B,
+                                        -(__v2df)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fnmsub_round_sd(U, A, B, C, R) \
+  ((__m128d)__builtin_ia32_vfmaddsd3_maskz((__v2df)(__m128d)(A), \
+                                           -(__v2df)(__m128d)(B), \
+                                           -(__v2df)(__m128d)(C), \
+                                           (__mmask8)(U), \
+                                           (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmsub_sd (__m128d __W, __m128d __X, __m128d __Y, __mmask8 __U)
+{
+  return __builtin_ia32_vfmsubsd3_mask3((__v2df)__W,
+                                        -(__v2df)__X,
+                                        (__v2df)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fnmsub_round_sd(W, X, Y, U, R) \
+  ((__m128d)__builtin_ia32_vfmsubsd3_mask3((__v2df)(__m128d)(W), \
+                                           -(__v2df)(__m128d)(X), \
+                                           (__v2df)(__m128d)(Y), \
+                                           (__mmask8)(U), (int)(R)))
+
+#define _mm512_permutex_pd(X, C) \
+  ((__m512d)__builtin_ia32_permdf512((__v8df)(__m512d)(X), (int)(C)))
+
+#define _mm512_mask_permutex_pd(W, U, X, C) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                        (__v8df)_mm512_permutex_pd((X), (C)), \
+                                        (__v8df)(__m512d)(W)))
+
+#define _mm512_maskz_permutex_pd(U, X, C) \
+  ((__m512d)__builtin_ia32_selectpd_512((__mmask8)(U), \
+                                        (__v8df)_mm512_permutex_pd((X), (C)), \
+                                        (__v8df)_mm512_setzero_pd()))
+
+#define _mm512_permutex_epi64(X, C) \
+  ((__m512i)__builtin_ia32_permdi512((__v8di)(__m512i)(X), (int)(C)))
+
+#define _mm512_mask_permutex_epi64(W, U, X, C) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                       (__v8di)_mm512_permutex_epi64((X), (C)), \
+                                       (__v8di)(__m512i)(W)))
+
+#define _mm512_maskz_permutex_epi64(U, X, C) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                       (__v8di)_mm512_permutex_epi64((X), (C)), \
+                                       (__v8di)_mm512_setzero_si512()))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_permutexvar_pd (__m512i __X, __m512d __Y)
+{
+  return (__m512d)__builtin_ia32_permvardf512((__v8df) __Y, (__v8di) __X);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_permutexvar_pd (__m512d __W, __mmask8 __U, __m512i __X, __m512d __Y)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                        (__v8df)_mm512_permutexvar_pd(__X, __Y),
+                                        (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutexvar_pd (__mmask8 __U, __m512i __X, __m512d __Y)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                        (__v8df)_mm512_permutexvar_pd(__X, __Y),
+                                        (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_permutexvar_epi64 (__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_permvardi512((__v8di)__Y, (__v8di)__X);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutexvar_epi64 (__mmask8 __M, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                     (__v8di)_mm512_permutexvar_epi64(__X, __Y),
+                                     (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_permutexvar_epi64 (__m512i __W, __mmask8 __M, __m512i __X,
+             __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512((__mmask8)__M,
+                                     (__v8di)_mm512_permutexvar_epi64(__X, __Y),
+                                     (__v8di)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_permutexvar_ps (__m512i __X, __m512 __Y)
+{
+  return (__m512)__builtin_ia32_permvarsf512((__v16sf)__Y, (__v16si)__X);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_permutexvar_ps (__m512 __W, __mmask16 __U, __m512i __X, __m512 __Y)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                       (__v16sf)_mm512_permutexvar_ps(__X, __Y),
+                                       (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutexvar_ps (__mmask16 __U, __m512i __X, __m512 __Y)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                       (__v16sf)_mm512_permutexvar_ps(__X, __Y),
+                                       (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_permutexvar_epi32 (__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_permvarsi512((__v16si)__Y, (__v16si)__X);
+}
+
+#define _mm512_permutevar_epi32 _mm512_permutexvar_epi32
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_permutexvar_epi32 (__mmask16 __M, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                    (__v16si)_mm512_permutexvar_epi32(__X, __Y),
+                                    (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_permutexvar_epi32 (__m512i __W, __mmask16 __M, __m512i __X,
+             __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectd_512((__mmask16)__M,
+                                    (__v16si)_mm512_permutexvar_epi32(__X, __Y),
+                                    (__v16si)__W);
+}
+
+#define _mm512_mask_permutevar_epi32 _mm512_mask_permutexvar_epi32
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_kand (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_kandhi ((__mmask16) __A, (__mmask16) __B);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_kandn (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_kandnhi ((__mmask16) __A, (__mmask16) __B);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_kor (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_korhi ((__mmask16) __A, (__mmask16) __B);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm512_kortestc (__mmask16 __A, __mmask16 __B)
+{
+  return __builtin_ia32_kortestchi ((__mmask16) __A, (__mmask16) __B);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm512_kortestz (__mmask16 __A, __mmask16 __B)
+{
+  return __builtin_ia32_kortestzhi ((__mmask16) __A, (__mmask16) __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortestc_mask16_u8(__mmask16 __A, __mmask16 __B)
+{
+  return (unsigned char)__builtin_ia32_kortestchi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortestz_mask16_u8(__mmask16 __A, __mmask16 __B)
+{
+  return (unsigned char)__builtin_ia32_kortestzhi(__A, __B);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_kortest_mask16_u8(__mmask16 __A, __mmask16 __B, unsigned char *__C) {
+  *__C = (unsigned char)__builtin_ia32_kortestchi(__A, __B);
+  return (unsigned char)__builtin_ia32_kortestzhi(__A, __B);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_kunpackb (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_kunpckhi ((__mmask16) __A, (__mmask16) __B);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_kxnor (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_kxnorhi ((__mmask16) __A, (__mmask16) __B);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_mm512_kxor (__mmask16 __A, __mmask16 __B)
+{
+  return (__mmask16) __builtin_ia32_kxorhi ((__mmask16) __A, (__mmask16) __B);
+}
+
+#define _kand_mask16 _mm512_kand
+#define _kandn_mask16 _mm512_kandn
+#define _knot_mask16 _mm512_knot
+#define _kor_mask16 _mm512_kor
+#define _kxnor_mask16 _mm512_kxnor
+#define _kxor_mask16 _mm512_kxor
+
+#define _kshiftli_mask16(A, I) \
+  ((__mmask16)__builtin_ia32_kshiftlihi((__mmask16)(A), (unsigned int)(I)))
+
+#define _kshiftri_mask16(A, I) \
+  ((__mmask16)__builtin_ia32_kshiftrihi((__mmask16)(A), (unsigned int)(I)))
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_cvtmask16_u32(__mmask16 __A) {
+  return (unsigned int)__builtin_ia32_kmovw((__mmask16)__A);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_cvtu32_mask16(unsigned int __A) {
+  return (__mmask16)__builtin_ia32_kmovw((__mmask16)__A);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS
+_load_mask16(__mmask16 *__A) {
+  return (__mmask16)__builtin_ia32_kmovw(*(__mmask16 *)__A);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_store_mask16(__mmask16 *__A, __mmask16 __B) {
+  *(__mmask16 *)__A = __builtin_ia32_kmovw((__mmask16)__B);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_stream_si512 (void * __P, __m512i __A)
+{
+  typedef __v8di __v8di_aligned __attribute__((aligned(64)));
+  __builtin_nontemporal_store((__v8di_aligned)__A, (__v8di_aligned*)__P);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_stream_load_si512 (void const *__P)
+{
+  typedef __v8di __v8di_aligned __attribute__((aligned(64)));
+  return (__m512i) __builtin_nontemporal_load((const __v8di_aligned *)__P);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_stream_pd (void *__P, __m512d __A)
+{
+  typedef __v8df __v8df_aligned __attribute__((aligned(64)));
+  __builtin_nontemporal_store((__v8df_aligned)__A, (__v8df_aligned*)__P);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_stream_ps (void *__P, __m512 __A)
+{
+  typedef __v16sf __v16sf_aligned __attribute__((aligned(64)));
+  __builtin_nontemporal_store((__v16sf_aligned)__A, (__v16sf_aligned*)__P);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_compress_pd (__m512d __W, __mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_compressdf512_mask ((__v8df) __A,
+                  (__v8df) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_compress_pd (__mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_compressdf512_mask ((__v8df) __A,
+                  (__v8df)
+                  _mm512_setzero_pd (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_compress_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_compressdi512_mask ((__v8di) __A,
+                  (__v8di) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_compress_epi64 (__mmask8 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_compressdi512_mask ((__v8di) __A,
+                  (__v8di)
+                  _mm512_setzero_si512 (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_compress_ps (__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_compresssf512_mask ((__v16sf) __A,
+                 (__v16sf) __W,
+                 (__mmask16) __U);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_compress_ps (__mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_compresssf512_mask ((__v16sf) __A,
+                 (__v16sf)
+                 _mm512_setzero_ps (),
+                 (__mmask16) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_compress_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_compresssi512_mask ((__v16si) __A,
+                  (__v16si) __W,
+                  (__mmask16) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_compress_epi32 (__mmask16 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_compresssi512_mask ((__v16si) __A,
+                  (__v16si)
+                  _mm512_setzero_si512 (),
+                  (__mmask16) __U);
+}
+
+#define _mm_cmp_round_ss_mask(X, Y, P, R) \
+  ((__mmask8)__builtin_ia32_cmpss_mask((__v4sf)(__m128)(X), \
+                                       (__v4sf)(__m128)(Y), (int)(P), \
+                                       (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_cmp_round_ss_mask(M, X, Y, P, R) \
+  ((__mmask8)__builtin_ia32_cmpss_mask((__v4sf)(__m128)(X), \
+                                       (__v4sf)(__m128)(Y), (int)(P), \
+                                       (__mmask8)(M), (int)(R)))
+
+#define _mm_cmp_ss_mask(X, Y, P) \
+  ((__mmask8)__builtin_ia32_cmpss_mask((__v4sf)(__m128)(X), \
+                                       (__v4sf)(__m128)(Y), (int)(P), \
+                                       (__mmask8)-1, \
+                                       _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_cmp_ss_mask(M, X, Y, P) \
+  ((__mmask8)__builtin_ia32_cmpss_mask((__v4sf)(__m128)(X), \
+                                       (__v4sf)(__m128)(Y), (int)(P), \
+                                       (__mmask8)(M), \
+                                       _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_cmp_round_sd_mask(X, Y, P, R) \
+  ((__mmask8)__builtin_ia32_cmpsd_mask((__v2df)(__m128d)(X), \
+                                       (__v2df)(__m128d)(Y), (int)(P), \
+                                       (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_cmp_round_sd_mask(M, X, Y, P, R) \
+  ((__mmask8)__builtin_ia32_cmpsd_mask((__v2df)(__m128d)(X), \
+                                       (__v2df)(__m128d)(Y), (int)(P), \
+                                       (__mmask8)(M), (int)(R)))
+
+#define _mm_cmp_sd_mask(X, Y, P) \
+  ((__mmask8)__builtin_ia32_cmpsd_mask((__v2df)(__m128d)(X), \
+                                       (__v2df)(__m128d)(Y), (int)(P), \
+                                       (__mmask8)-1, \
+                                       _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_cmp_sd_mask(M, X, Y, P) \
+  ((__mmask8)__builtin_ia32_cmpsd_mask((__v2df)(__m128d)(X), \
+                                       (__v2df)(__m128d)(Y), (int)(P), \
+                                       (__mmask8)(M), \
+                                       _MM_FROUND_CUR_DIRECTION))
+
+/* Bit Test */
+
+static __inline __mmask16 __DEFAULT_FN_ATTRS512
+_mm512_test_epi32_mask (__m512i __A, __m512i __B)
+{
+  return _mm512_cmpneq_epi32_mask (_mm512_and_epi32(__A, __B),
+                                   _mm512_setzero_si512());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS512
+_mm512_mask_test_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
+{
+  return _mm512_mask_cmpneq_epi32_mask (__U, _mm512_and_epi32 (__A, __B),
+                                        _mm512_setzero_si512());
+}
+
+static __inline __mmask8 __DEFAULT_FN_ATTRS512
+_mm512_test_epi64_mask (__m512i __A, __m512i __B)
+{
+  return _mm512_cmpneq_epi64_mask (_mm512_and_epi32 (__A, __B),
+                                   _mm512_setzero_si512());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS512
+_mm512_mask_test_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
+{
+  return _mm512_mask_cmpneq_epi64_mask (__U, _mm512_and_epi32 (__A, __B),
+                                        _mm512_setzero_si512());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS512
+_mm512_testn_epi32_mask (__m512i __A, __m512i __B)
+{
+  return _mm512_cmpeq_epi32_mask (_mm512_and_epi32 (__A, __B),
+                                  _mm512_setzero_si512());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS512
+_mm512_mask_testn_epi32_mask (__mmask16 __U, __m512i __A, __m512i __B)
+{
+  return _mm512_mask_cmpeq_epi32_mask (__U, _mm512_and_epi32 (__A, __B),
+                                       _mm512_setzero_si512());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS512
+_mm512_testn_epi64_mask (__m512i __A, __m512i __B)
+{
+  return _mm512_cmpeq_epi64_mask (_mm512_and_epi32 (__A, __B),
+                                  _mm512_setzero_si512());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS512
+_mm512_mask_testn_epi64_mask (__mmask8 __U, __m512i __A, __m512i __B)
+{
+  return _mm512_mask_cmpeq_epi64_mask (__U, _mm512_and_epi32 (__A, __B),
+                                       _mm512_setzero_si512());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_movehdup_ps (__m512 __A)
+{
+  return (__m512)__builtin_shufflevector((__v16sf)__A, (__v16sf)__A,
+                         1, 1, 3, 3, 5, 5, 7, 7, 9, 9, 11, 11, 13, 13, 15, 15);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_movehdup_ps (__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_movehdup_ps(__A),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_movehdup_ps (__mmask16 __U, __m512 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_movehdup_ps(__A),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_moveldup_ps (__m512 __A)
+{
+  return (__m512)__builtin_shufflevector((__v16sf)__A, (__v16sf)__A,
+                         0, 0, 2, 2, 4, 4, 6, 6, 8, 8, 10, 10, 12, 12, 14, 14);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_moveldup_ps (__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_moveldup_ps(__A),
+                                             (__v16sf)__W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_moveldup_ps (__mmask16 __U, __m512 __A)
+{
+  return (__m512)__builtin_ia32_selectps_512((__mmask16)__U,
+                                             (__v16sf)_mm512_moveldup_ps(__A),
+                                             (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_move_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return __builtin_ia32_selectss_128(__U, _mm_move_ss(__A, __B), __W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_move_ss (__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return __builtin_ia32_selectss_128(__U, _mm_move_ss(__A, __B),
+                                     _mm_setzero_ps());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_move_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return __builtin_ia32_selectsd_128(__U, _mm_move_sd(__A, __B), __W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_move_sd (__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return __builtin_ia32_selectsd_128(__U, _mm_move_sd(__A, __B),
+                                     _mm_setzero_pd());
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_store_ss (float * __W, __mmask8 __U, __m128 __A)
+{
+  __builtin_ia32_storess128_mask ((__v4sf *)__W, __A, __U & 1);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_store_sd (double * __W, __mmask8 __U, __m128d __A)
+{
+  __builtin_ia32_storesd128_mask ((__v2df *)__W, __A, __U & 1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_load_ss (__m128 __W, __mmask8 __U, const float* __A)
+{
+  __m128 src = (__v4sf) __builtin_shufflevector((__v4sf) __W,
+                                                (__v4sf)_mm_setzero_ps(),
+                                                0, 4, 4, 4);
+
+  return (__m128) __builtin_ia32_loadss128_mask ((const __v4sf *) __A, src, __U & 1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_load_ss (__mmask8 __U, const float* __A)
+{
+  return (__m128)__builtin_ia32_loadss128_mask ((const __v4sf *) __A,
+                                                (__v4sf) _mm_setzero_ps(),
+                                                __U & 1);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_load_sd (__m128d __W, __mmask8 __U, const double* __A)
+{
+  __m128d src = (__v2df) __builtin_shufflevector((__v2df) __W,
+                                                 (__v2df)_mm_setzero_pd(),
+                                                 0, 2);
+
+  return (__m128d) __builtin_ia32_loadsd128_mask ((const __v2df *) __A, src, __U & 1);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_load_sd (__mmask8 __U, const double* __A)
+{
+  return (__m128d) __builtin_ia32_loadsd128_mask ((const __v2df *) __A,
+                                                  (__v2df) _mm_setzero_pd(),
+                                                  __U & 1);
+}
+
+#define _mm512_shuffle_epi32(A, I) \
+  ((__m512i)__builtin_ia32_pshufd512((__v16si)(__m512i)(A), (int)(I)))
+
+#define _mm512_mask_shuffle_epi32(W, U, A, I) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                       (__v16si)_mm512_shuffle_epi32((A), (I)), \
+                                       (__v16si)(__m512i)(W)))
+
+#define _mm512_maskz_shuffle_epi32(U, A, I) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                       (__v16si)_mm512_shuffle_epi32((A), (I)), \
+                                       (__v16si)_mm512_setzero_si512()))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_expand_pd (__m512d __W, __mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_expanddf512_mask ((__v8df) __A,
+                (__v8df) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_expand_pd (__mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_expanddf512_mask ((__v8df) __A,
+                (__v8df) _mm512_setzero_pd (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_expand_epi64 (__m512i __W, __mmask8 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_expanddi512_mask ((__v8di) __A,
+                (__v8di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_expand_epi64 ( __mmask8 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_expanddi512_mask ((__v8di) __A,
+                (__v8di) _mm512_setzero_si512 (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_expandloadu_pd(__m512d __W, __mmask8 __U, void const *__P)
+{
+  return (__m512d) __builtin_ia32_expandloaddf512_mask ((const __v8df *)__P,
+              (__v8df) __W,
+              (__mmask8) __U);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_expandloadu_pd(__mmask8 __U, void const *__P)
+{
+  return (__m512d) __builtin_ia32_expandloaddf512_mask ((const __v8df *)__P,
+              (__v8df) _mm512_setzero_pd(),
+              (__mmask8) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_expandloadu_epi64(__m512i __W, __mmask8 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_expandloaddi512_mask ((const __v8di *)__P,
+              (__v8di) __W,
+              (__mmask8) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_expandloadu_epi64(__mmask8 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_expandloaddi512_mask ((const __v8di *)__P,
+              (__v8di) _mm512_setzero_si512(),
+              (__mmask8) __U);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_expandloadu_ps(__m512 __W, __mmask16 __U, void const *__P)
+{
+  return (__m512) __builtin_ia32_expandloadsf512_mask ((const __v16sf *)__P,
+                   (__v16sf) __W,
+                   (__mmask16) __U);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_expandloadu_ps(__mmask16 __U, void const *__P)
+{
+  return (__m512) __builtin_ia32_expandloadsf512_mask ((const __v16sf *)__P,
+                   (__v16sf) _mm512_setzero_ps(),
+                   (__mmask16) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_expandloadu_epi32(__m512i __W, __mmask16 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_expandloadsi512_mask ((const __v16si *)__P,
+              (__v16si) __W,
+              (__mmask16) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_expandloadu_epi32(__mmask16 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_expandloadsi512_mask ((const __v16si *)__P,
+              (__v16si) _mm512_setzero_si512(),
+              (__mmask16) __U);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_expand_ps (__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_expandsf512_mask ((__v16sf) __A,
+               (__v16sf) __W,
+               (__mmask16) __U);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_expand_ps (__mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_expandsf512_mask ((__v16sf) __A,
+               (__v16sf) _mm512_setzero_ps(),
+               (__mmask16) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_expand_epi32 (__m512i __W, __mmask16 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_expandsi512_mask ((__v16si) __A,
+                (__v16si) __W,
+                (__mmask16) __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_expand_epi32 (__mmask16 __U, __m512i __A)
+{
+  return (__m512i) __builtin_ia32_expandsi512_mask ((__v16si) __A,
+                (__v16si) _mm512_setzero_si512(),
+                (__mmask16) __U);
+}
+
+#define _mm512_cvt_roundps_pd(A, R) \
+  ((__m512d)__builtin_ia32_cvtps2pd512_mask((__v8sf)(__m256)(A), \
+                                            (__v8df)_mm512_undefined_pd(), \
+                                            (__mmask8)-1, (int)(R)))
+
+#define _mm512_mask_cvt_roundps_pd(W, U, A, R) \
+  ((__m512d)__builtin_ia32_cvtps2pd512_mask((__v8sf)(__m256)(A), \
+                                            (__v8df)(__m512d)(W), \
+                                            (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundps_pd(U, A, R) \
+  ((__m512d)__builtin_ia32_cvtps2pd512_mask((__v8sf)(__m256)(A), \
+                                            (__v8df)_mm512_setzero_pd(), \
+                                            (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_cvtps_pd (__m256 __A)
+{
+  return (__m512d) __builtin_convertvector((__v8sf)__A, __v8df);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtps_pd (__m512d __W, __mmask8 __U, __m256 __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_cvtps_pd(__A),
+                                              (__v8df)__W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtps_pd (__mmask8 __U, __m256 __A)
+{
+  return (__m512d)__builtin_ia32_selectpd_512((__mmask8)__U,
+                                              (__v8df)_mm512_cvtps_pd(__A),
+                                              (__v8df)_mm512_setzero_pd());
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_cvtpslo_pd (__m512 __A)
+{
+  return (__m512d) _mm512_cvtps_pd(_mm512_castps512_ps256(__A));
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtpslo_pd (__m512d __W, __mmask8 __U, __m512 __A)
+{
+  return (__m512d) _mm512_mask_cvtps_pd(__W, __U, _mm512_castps512_ps256(__A));
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_mov_pd (__m512d __W, __mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_selectpd_512 ((__mmask8) __U,
+              (__v8df) __A,
+              (__v8df) __W);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_mov_pd (__mmask8 __U, __m512d __A)
+{
+  return (__m512d) __builtin_ia32_selectpd_512 ((__mmask8) __U,
+              (__v8df) __A,
+              (__v8df) _mm512_setzero_pd ());
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_mov_ps (__m512 __W, __mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_selectps_512 ((__mmask16) __U,
+             (__v16sf) __A,
+             (__v16sf) __W);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_mov_ps (__mmask16 __U, __m512 __A)
+{
+  return (__m512) __builtin_ia32_selectps_512 ((__mmask16) __U,
+             (__v16sf) __A,
+             (__v16sf) _mm512_setzero_ps ());
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_compressstoreu_pd (void *__P, __mmask8 __U, __m512d __A)
+{
+  __builtin_ia32_compressstoredf512_mask ((__v8df *) __P, (__v8df) __A,
+            (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_compressstoreu_epi64 (void *__P, __mmask8 __U, __m512i __A)
+{
+  __builtin_ia32_compressstoredi512_mask ((__v8di *) __P, (__v8di) __A,
+            (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_compressstoreu_ps (void *__P, __mmask16 __U, __m512 __A)
+{
+  __builtin_ia32_compressstoresf512_mask ((__v16sf *) __P, (__v16sf) __A,
+            (__mmask16) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512
+_mm512_mask_compressstoreu_epi32 (void *__P, __mmask16 __U, __m512i __A)
+{
+  __builtin_ia32_compressstoresi512_mask ((__v16si *) __P, (__v16si) __A,
+            (__mmask16) __U);
+}
+
+#define _mm_cvt_roundsd_ss(A, B, R) \
+  ((__m128)__builtin_ia32_cvtsd2ss_round_mask((__v4sf)(__m128)(A), \
+                                              (__v2df)(__m128d)(B), \
+                                              (__v4sf)_mm_undefined_ps(), \
+                                              (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_cvt_roundsd_ss(W, U, A, B, R) \
+  ((__m128)__builtin_ia32_cvtsd2ss_round_mask((__v4sf)(__m128)(A), \
+                                              (__v2df)(__m128d)(B), \
+                                              (__v4sf)(__m128)(W), \
+                                              (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_cvt_roundsd_ss(U, A, B, R) \
+  ((__m128)__builtin_ia32_cvtsd2ss_round_mask((__v4sf)(__m128)(A), \
+                                              (__v2df)(__m128d)(B), \
+                                              (__v4sf)_mm_setzero_ps(), \
+                                              (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsd_ss (__m128 __W, __mmask8 __U, __m128 __A, __m128d __B)
+{
+  return __builtin_ia32_cvtsd2ss_round_mask ((__v4sf)__A,
+                                             (__v2df)__B,
+                                             (__v4sf)__W,
+                                             (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtsd_ss (__mmask8 __U, __m128 __A, __m128d __B)
+{
+  return __builtin_ia32_cvtsd2ss_round_mask ((__v4sf)__A,
+                                             (__v2df)__B,
+                                             (__v4sf)_mm_setzero_ps(),
+                                             (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_cvtss_i32 _mm_cvtss_si32
+#define _mm_cvtsd_i32 _mm_cvtsd_si32
+#define _mm_cvti32_sd _mm_cvtsi32_sd
+#define _mm_cvti32_ss _mm_cvtsi32_ss
+#ifdef __x86_64__
+#define _mm_cvtss_i64 _mm_cvtss_si64
+#define _mm_cvtsd_i64 _mm_cvtsd_si64
+#define _mm_cvti64_sd _mm_cvtsi64_sd
+#define _mm_cvti64_ss _mm_cvtsi64_ss
+#endif
+
+#ifdef __x86_64__
+#define _mm_cvt_roundi64_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_cvtsi2sd64((__v2df)(__m128d)(A), (long long)(B), \
+                                      (int)(R)))
+
+#define _mm_cvt_roundsi64_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_cvtsi2sd64((__v2df)(__m128d)(A), (long long)(B), \
+                                      (int)(R)))
+#endif
+
+#define _mm_cvt_roundsi32_ss(A, B, R) \
+  ((__m128)__builtin_ia32_cvtsi2ss32((__v4sf)(__m128)(A), (int)(B), (int)(R)))
+
+#define _mm_cvt_roundi32_ss(A, B, R) \
+  ((__m128)__builtin_ia32_cvtsi2ss32((__v4sf)(__m128)(A), (int)(B), (int)(R)))
+
+#ifdef __x86_64__
+#define _mm_cvt_roundsi64_ss(A, B, R) \
+  ((__m128)__builtin_ia32_cvtsi2ss64((__v4sf)(__m128)(A), (long long)(B), \
+                                     (int)(R)))
+
+#define _mm_cvt_roundi64_ss(A, B, R) \
+  ((__m128)__builtin_ia32_cvtsi2ss64((__v4sf)(__m128)(A), (long long)(B), \
+                                     (int)(R)))
+#endif
+
+#define _mm_cvt_roundss_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_cvtss2sd_round_mask((__v2df)(__m128d)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (__v2df)_mm_undefined_pd(), \
+                                               (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_cvt_roundss_sd(W, U, A, B, R) \
+  ((__m128d)__builtin_ia32_cvtss2sd_round_mask((__v2df)(__m128d)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (__v2df)(__m128d)(W), \
+                                               (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_cvt_roundss_sd(U, A, B, R) \
+  ((__m128d)__builtin_ia32_cvtss2sd_round_mask((__v2df)(__m128d)(A), \
+                                               (__v4sf)(__m128)(B), \
+                                               (__v2df)_mm_setzero_pd(), \
+                                               (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_cvtss_sd (__m128d __W, __mmask8 __U, __m128d __A, __m128 __B)
+{
+  return __builtin_ia32_cvtss2sd_round_mask((__v2df)__A,
+                                            (__v4sf)__B,
+                                            (__v2df)__W,
+                                            (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtss_sd (__mmask8 __U, __m128d __A, __m128 __B)
+{
+  return __builtin_ia32_cvtss2sd_round_mask((__v2df)__A,
+                                            (__v4sf)__B,
+                                            (__v2df)_mm_setzero_pd(),
+                                            (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_cvtu32_sd (__m128d __A, unsigned __B)
+{
+  __A[0] = __B;
+  return __A;
+}
+
+#ifdef __x86_64__
+#define _mm_cvt_roundu64_sd(A, B, R) \
+  ((__m128d)__builtin_ia32_cvtusi2sd64((__v2df)(__m128d)(A), \
+                                       (unsigned long long)(B), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_cvtu64_sd (__m128d __A, unsigned long long __B)
+{
+  __A[0] = __B;
+  return __A;
+}
+#endif
+
+#define _mm_cvt_roundu32_ss(A, B, R) \
+  ((__m128)__builtin_ia32_cvtusi2ss32((__v4sf)(__m128)(A), (unsigned int)(B), \
+                                      (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_cvtu32_ss (__m128 __A, unsigned __B)
+{
+  __A[0] = __B;
+  return __A;
+}
+
+#ifdef __x86_64__
+#define _mm_cvt_roundu64_ss(A, B, R) \
+  ((__m128)__builtin_ia32_cvtusi2ss64((__v4sf)(__m128)(A), \
+                                      (unsigned long long)(B), (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_cvtu64_ss (__m128 __A, unsigned long long __B)
+{
+  __A[0] = __B;
+  return __A;
+}
+#endif
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_set1_epi32 (__m512i __O, __mmask16 __M, int __A)
+{
+  return (__m512i) __builtin_ia32_selectd_512(__M,
+                                              (__v16si) _mm512_set1_epi32(__A),
+                                              (__v16si) __O);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_set1_epi64 (__m512i __O, __mmask8 __M, long long __A)
+{
+  return (__m512i) __builtin_ia32_selectq_512(__M,
+                                              (__v8di) _mm512_set1_epi64(__A),
+                                              (__v8di) __O);
+}
+
+static  __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_set_epi8 (char __e63, char __e62, char __e61, char __e60, char __e59,
+    char __e58, char __e57, char __e56, char __e55, char __e54, char __e53,
+    char __e52, char __e51, char __e50, char __e49, char __e48, char __e47,
+    char __e46, char __e45, char __e44, char __e43, char __e42, char __e41,
+    char __e40, char __e39, char __e38, char __e37, char __e36, char __e35,
+    char __e34, char __e33, char __e32, char __e31, char __e30, char __e29,
+    char __e28, char __e27, char __e26, char __e25, char __e24, char __e23,
+    char __e22, char __e21, char __e20, char __e19, char __e18, char __e17,
+    char __e16, char __e15, char __e14, char __e13, char __e12, char __e11,
+    char __e10, char __e9, char __e8, char __e7, char __e6, char __e5,
+    char __e4, char __e3, char __e2, char __e1, char __e0) {
+
+  return __extension__ (__m512i)(__v64qi)
+    {__e0, __e1, __e2, __e3, __e4, __e5, __e6, __e7,
+     __e8, __e9, __e10, __e11, __e12, __e13, __e14, __e15,
+     __e16, __e17, __e18, __e19, __e20, __e21, __e22, __e23,
+     __e24, __e25, __e26, __e27, __e28, __e29, __e30, __e31,
+     __e32, __e33, __e34, __e35, __e36, __e37, __e38, __e39,
+     __e40, __e41, __e42, __e43, __e44, __e45, __e46, __e47,
+     __e48, __e49, __e50, __e51, __e52, __e53, __e54, __e55,
+     __e56, __e57, __e58, __e59, __e60, __e61, __e62, __e63};
+}
+
+static  __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_set_epi16(short __e31, short __e30, short __e29, short __e28,
+    short __e27, short __e26, short __e25, short __e24, short __e23,
+    short __e22, short __e21, short __e20, short __e19, short __e18,
+    short __e17, short __e16, short __e15, short __e14, short __e13,
+    short __e12, short __e11, short __e10, short __e9, short __e8,
+    short __e7, short __e6, short __e5, short __e4, short __e3,
+    short __e2, short __e1, short __e0) {
+  return __extension__ (__m512i)(__v32hi)
+    {__e0, __e1, __e2, __e3, __e4, __e5, __e6, __e7,
+     __e8, __e9, __e10, __e11, __e12, __e13, __e14, __e15,
+     __e16, __e17, __e18, __e19, __e20, __e21, __e22, __e23,
+     __e24, __e25, __e26, __e27, __e28, __e29, __e30, __e31 };
+}
+
+static __inline __m512i __DEFAULT_FN_ATTRS512
+_mm512_set_epi32 (int __A, int __B, int __C, int __D,
+     int __E, int __F, int __G, int __H,
+     int __I, int __J, int __K, int __L,
+     int __M, int __N, int __O, int __P)
+{
+  return __extension__ (__m512i)(__v16si)
+  { __P, __O, __N, __M, __L, __K, __J, __I,
+    __H, __G, __F, __E, __D, __C, __B, __A };
+}
+
+#define _mm512_setr_epi32(e0,e1,e2,e3,e4,e5,e6,e7,           \
+       e8,e9,e10,e11,e12,e13,e14,e15)          \
+  _mm512_set_epi32((e15),(e14),(e13),(e12),(e11),(e10),(e9),(e8),(e7),(e6), \
+                   (e5),(e4),(e3),(e2),(e1),(e0))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_set_epi64 (long long __A, long long __B, long long __C,
+     long long __D, long long __E, long long __F,
+     long long __G, long long __H)
+{
+  return __extension__ (__m512i) (__v8di)
+  { __H, __G, __F, __E, __D, __C, __B, __A };
+}
+
+#define _mm512_setr_epi64(e0,e1,e2,e3,e4,e5,e6,e7)           \
+  _mm512_set_epi64((e7),(e6),(e5),(e4),(e3),(e2),(e1),(e0))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_set_pd (double __A, double __B, double __C, double __D,
+        double __E, double __F, double __G, double __H)
+{
+  return __extension__ (__m512d)
+  { __H, __G, __F, __E, __D, __C, __B, __A };
+}
+
+#define _mm512_setr_pd(e0,e1,e2,e3,e4,e5,e6,e7)              \
+  _mm512_set_pd((e7),(e6),(e5),(e4),(e3),(e2),(e1),(e0))
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_set_ps (float __A, float __B, float __C, float __D,
+        float __E, float __F, float __G, float __H,
+        float __I, float __J, float __K, float __L,
+        float __M, float __N, float __O, float __P)
+{
+  return __extension__ (__m512)
+  { __P, __O, __N, __M, __L, __K, __J, __I,
+    __H, __G, __F, __E, __D, __C, __B, __A };
+}
+
+#define _mm512_setr_ps(e0,e1,e2,e3,e4,e5,e6,e7,e8,e9,e10,e11,e12,e13,e14,e15) \
+  _mm512_set_ps((e15),(e14),(e13),(e12),(e11),(e10),(e9),(e8),(e7),(e6),(e5), \
+                (e4),(e3),(e2),(e1),(e0))
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_abs_ps(__m512 __A)
+{
+  return (__m512)_mm512_and_epi32(_mm512_set1_epi32(0x7FFFFFFF),(__m512i)__A) ;
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_abs_ps(__m512 __W, __mmask16 __K, __m512 __A)
+{
+  return (__m512)_mm512_mask_and_epi32((__m512i)__W, __K, _mm512_set1_epi32(0x7FFFFFFF),(__m512i)__A) ;
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_abs_pd(__m512d __A)
+{
+  return (__m512d)_mm512_and_epi64(_mm512_set1_epi64(0x7FFFFFFFFFFFFFFF),(__v8di)__A) ;
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_abs_pd(__m512d __W, __mmask8 __K, __m512d __A)
+{
+  return (__m512d)_mm512_mask_and_epi64((__v8di)__W, __K, _mm512_set1_epi64(0x7FFFFFFFFFFFFFFF),(__v8di)__A);
+}
+
+/* Vector-reduction arithmetic accepts vectors as inputs and produces scalars as
+ * outputs. This class of vector operation forms the basis of many scientific
+ * computations. In vector-reduction arithmetic, the evaluation order is
+ * independent of the order of the input elements of V.
+
+ * For floating-point intrinsics:
+ * 1. When using fadd/fmul intrinsics, the order of operations within the
+ * vector is unspecified (associative math).
+ * 2. When using fmin/fmax intrinsics, NaN or -0.0 elements within the vector
+ * produce unspecified results.
+
+ * Used bisection method. At each step, we partition the vector with previous
+ * step in half, and the operation is performed on its two halves.
+ * This takes log2(n) steps where n is the number of elements in the vector.
+ */
+
+static __inline__ long long __DEFAULT_FN_ATTRS512 _mm512_reduce_add_epi64(__m512i __W) {
+  return __builtin_reduce_add((__v8di)__W);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512 _mm512_reduce_mul_epi64(__m512i __W) {
+  return __builtin_reduce_mul((__v8di)__W);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512 _mm512_reduce_and_epi64(__m512i __W) {
+  return __builtin_reduce_and((__v8di)__W);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512 _mm512_reduce_or_epi64(__m512i __W) {
+  return __builtin_reduce_or((__v8di)__W);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_add_epi64(__mmask8 __M, __m512i __W) {
+  __W = _mm512_maskz_mov_epi64(__M, __W);
+  return __builtin_reduce_add((__v8di)__W);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_mul_epi64(__mmask8 __M, __m512i __W) {
+  __W = _mm512_mask_mov_epi64(_mm512_set1_epi64(1), __M, __W);
+  return __builtin_reduce_mul((__v8di)__W);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_and_epi64(__mmask8 __M, __m512i __W) {
+  __W = _mm512_mask_mov_epi64(_mm512_set1_epi64(-1LL), __M, __W);
+  return __builtin_reduce_and((__v8di)__W);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_or_epi64(__mmask8 __M, __m512i __W) {
+  __W = _mm512_maskz_mov_epi64(__M, __W);
+  return __builtin_reduce_or((__v8di)__W);
+}
+
+// -0.0 is used to ignore the start value since it is the neutral value of
+// floating point addition. For more information, please refer to
+// https://llvm.org/docs/LangRef.html#llvm-vector-reduce-fadd-intrinsic
+static __inline__ double __DEFAULT_FN_ATTRS512 _mm512_reduce_add_pd(__m512d __W) {
+  return __builtin_ia32_reduce_fadd_pd512(-0.0, __W);
+}
+
+static __inline__ double __DEFAULT_FN_ATTRS512 _mm512_reduce_mul_pd(__m512d __W) {
+  return __builtin_ia32_reduce_fmul_pd512(1.0, __W);
+}
+
+static __inline__ double __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_add_pd(__mmask8 __M, __m512d __W) {
+  __W = _mm512_maskz_mov_pd(__M, __W);
+  return __builtin_ia32_reduce_fadd_pd512(-0.0, __W);
+}
+
+static __inline__ double __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_mul_pd(__mmask8 __M, __m512d __W) {
+  __W = _mm512_mask_mov_pd(_mm512_set1_pd(1.0), __M, __W);
+  return __builtin_ia32_reduce_fmul_pd512(1.0, __W);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_reduce_add_epi32(__m512i __W) {
+  return __builtin_reduce_add((__v16si)__W);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_reduce_mul_epi32(__m512i __W) {
+  return __builtin_reduce_mul((__v16si)__W);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_reduce_and_epi32(__m512i __W) {
+  return __builtin_reduce_and((__v16si)__W);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_reduce_or_epi32(__m512i __W) {
+  return __builtin_reduce_or((__v16si)__W);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_add_epi32( __mmask16 __M, __m512i __W) {
+  __W = _mm512_maskz_mov_epi32(__M, __W);
+  return __builtin_reduce_add((__v16si)__W);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_mul_epi32( __mmask16 __M, __m512i __W) {
+  __W = _mm512_mask_mov_epi32(_mm512_set1_epi32(1), __M, __W);
+  return __builtin_reduce_mul((__v16si)__W);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_and_epi32( __mmask16 __M, __m512i __W) {
+  __W = _mm512_mask_mov_epi32(_mm512_set1_epi32(-1), __M, __W);
+  return __builtin_reduce_and((__v16si)__W);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_or_epi32(__mmask16 __M, __m512i __W) {
+  __W = _mm512_maskz_mov_epi32(__M, __W);
+  return __builtin_reduce_or((__v16si)__W);
+}
+
+static __inline__ float __DEFAULT_FN_ATTRS512
+_mm512_reduce_add_ps(__m512 __W) {
+  return __builtin_ia32_reduce_fadd_ps512(-0.0f, __W);
+}
+
+static __inline__ float __DEFAULT_FN_ATTRS512
+_mm512_reduce_mul_ps(__m512 __W) {
+  return __builtin_ia32_reduce_fmul_ps512(1.0f, __W);
+}
+
+static __inline__ float __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_add_ps(__mmask16 __M, __m512 __W) {
+  __W = _mm512_maskz_mov_ps(__M, __W);
+  return __builtin_ia32_reduce_fadd_ps512(-0.0f, __W);
+}
+
+static __inline__ float __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_mul_ps(__mmask16 __M, __m512 __W) {
+  __W = _mm512_mask_mov_ps(_mm512_set1_ps(1.0f), __M, __W);
+  return __builtin_ia32_reduce_fmul_ps512(1.0f, __W);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512
+_mm512_reduce_max_epi64(__m512i __V) {
+  return __builtin_reduce_max((__v8di)__V);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS512
+_mm512_reduce_max_epu64(__m512i __V) {
+  return __builtin_reduce_max((__v8du)__V);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512
+_mm512_reduce_min_epi64(__m512i __V) {
+  return __builtin_reduce_min((__v8di)__V);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS512
+_mm512_reduce_min_epu64(__m512i __V) {
+  return __builtin_reduce_min((__v8du)__V);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_max_epi64(__mmask8 __M, __m512i __V) {
+  __V = _mm512_mask_mov_epi64(_mm512_set1_epi64(-__LONG_LONG_MAX__ - 1LL), __M, __V);
+  return __builtin_reduce_max((__v8di)__V);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_max_epu64(__mmask8 __M, __m512i __V) {
+  __V = _mm512_maskz_mov_epi64(__M, __V);
+  return __builtin_reduce_max((__v8du)__V);
+}
+
+static __inline__ long long __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_min_epi64(__mmask8 __M, __m512i __V) {
+  __V = _mm512_mask_mov_epi64(_mm512_set1_epi64(__LONG_LONG_MAX__), __M, __V);
+  return __builtin_reduce_min((__v8di)__V);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_min_epu64(__mmask8 __M, __m512i __V) {
+  __V = _mm512_mask_mov_epi64(_mm512_set1_epi64(-1LL), __M, __V);
+  return __builtin_reduce_min((__v8du)__V);
+}
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_reduce_max_epi32(__m512i __V) {
+  return __builtin_reduce_max((__v16si)__V);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS512
+_mm512_reduce_max_epu32(__m512i __V) {
+  return __builtin_reduce_max((__v16su)__V);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_reduce_min_epi32(__m512i __V) {
+  return __builtin_reduce_min((__v16si)__V);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS512
+_mm512_reduce_min_epu32(__m512i __V) {
+  return __builtin_reduce_min((__v16su)__V);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_max_epi32(__mmask16 __M, __m512i __V) {
+  __V = _mm512_mask_mov_epi32(_mm512_set1_epi32(-__INT_MAX__ - 1), __M, __V);
+  return __builtin_reduce_max((__v16si)__V);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_max_epu32(__mmask16 __M, __m512i __V) {
+  __V = _mm512_maskz_mov_epi32(__M, __V);
+  return __builtin_reduce_max((__v16su)__V);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_min_epi32(__mmask16 __M, __m512i __V) {
+  __V = _mm512_mask_mov_epi32(_mm512_set1_epi32(__INT_MAX__), __M, __V);
+  return __builtin_reduce_min((__v16si)__V);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_min_epu32(__mmask16 __M, __m512i __V) {
+  __V = _mm512_mask_mov_epi32(_mm512_set1_epi32(-1), __M, __V);
+  return __builtin_reduce_min((__v16su)__V);
+}
+
+static __inline__ double __DEFAULT_FN_ATTRS512
+_mm512_reduce_max_pd(__m512d __V) {
+  return __builtin_ia32_reduce_fmax_pd512(__V);
+}
+
+static __inline__ double __DEFAULT_FN_ATTRS512
+_mm512_reduce_min_pd(__m512d __V) {
+  return __builtin_ia32_reduce_fmin_pd512(__V);
+}
+
+static __inline__ double __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_max_pd(__mmask8 __M, __m512d __V) {
+  __V = _mm512_mask_mov_pd(_mm512_set1_pd(-__builtin_inf()), __M, __V);
+  return __builtin_ia32_reduce_fmax_pd512(__V);
+}
+
+static __inline__ double __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_min_pd(__mmask8 __M, __m512d __V) {
+  __V = _mm512_mask_mov_pd(_mm512_set1_pd(__builtin_inf()), __M, __V);
+  return __builtin_ia32_reduce_fmin_pd512(__V);
+}
+
+static __inline__ float __DEFAULT_FN_ATTRS512
+_mm512_reduce_max_ps(__m512 __V) {
+  return __builtin_ia32_reduce_fmax_ps512(__V);
+}
+
+static __inline__ float __DEFAULT_FN_ATTRS512
+_mm512_reduce_min_ps(__m512 __V) {
+  return __builtin_ia32_reduce_fmin_ps512(__V);
+}
+
+static __inline__ float __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_max_ps(__mmask16 __M, __m512 __V) {
+  __V = _mm512_mask_mov_ps(_mm512_set1_ps(-__builtin_inff()), __M, __V);
+  return __builtin_ia32_reduce_fmax_ps512(__V);
+}
+
+static __inline__ float __DEFAULT_FN_ATTRS512
+_mm512_mask_reduce_min_ps(__mmask16 __M, __m512 __V) {
+  __V = _mm512_mask_mov_ps(_mm512_set1_ps(__builtin_inff()), __M, __V);
+  return __builtin_ia32_reduce_fmin_ps512(__V);
+}
+
+/// Moves the least significant 32 bits of a vector of [16 x i32] to a
+///    32-bit signed integer value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVD / MOVD </c> instruction.
+///
+/// \param __A
+///    A vector of [16 x i32]. The least significant 32 bits are moved to the
+///    destination.
+/// \returns A 32-bit signed integer containing the moved value.
+static __inline__ int __DEFAULT_FN_ATTRS512
+_mm512_cvtsi512_si32(__m512i __A) {
+  __v16si __b = (__v16si)__A;
+  return __b[0];
+}
+
+/// Loads 8 double-precision (64-bit) floating-point elements stored at memory
+/// locations starting at location \a base_addr at packed 32-bit integer indices
+/// stored in the lower half of \a vindex scaled by \a scale them in dst.
+///
+/// This intrinsic corresponds to the <c> VGATHERDPD </c> instructions.
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+///   i := j*64
+///   m := j*32
+///   addr := base_addr + SignExtend64(vindex[m+31:m]) * ZeroExtend64(scale) * 8
+///   dst[i+63:i] := MEM[addr+63:addr]
+/// ENDFOR
+/// dst[MAX:512] := 0
+/// \endcode
+#define _mm512_i32logather_pd(vindex, base_addr, scale)                        \
+  _mm512_i32gather_pd(_mm512_castsi512_si256(vindex), (base_addr), (scale))
+
+/// Loads 8 double-precision (64-bit) floating-point elements from memory
+/// starting at location \a base_addr at packed 32-bit integer indices stored in
+/// the lower half of \a vindex scaled by \a scale into dst using writemask
+/// \a mask (elements are copied from \a src when the corresponding mask bit is
+/// not set).
+///
+/// This intrinsic corresponds to the <c> VGATHERDPD </c> instructions.
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+///   i := j*64
+///   m := j*32
+///   IF mask[j]
+///     addr := base_addr + SignExtend64(vindex[m+31:m]) * ZeroExtend64(scale) * 8
+///     dst[i+63:i] := MEM[addr+63:addr]
+///   ELSE
+///     dst[i+63:i] := src[i+63:i]
+///   FI
+/// ENDFOR
+/// dst[MAX:512] := 0
+/// \endcode
+#define _mm512_mask_i32logather_pd(src, mask, vindex, base_addr, scale)        \
+  _mm512_mask_i32gather_pd((src), (mask), _mm512_castsi512_si256(vindex),      \
+                           (base_addr), (scale))
+
+/// Loads 8 64-bit integer elements from memory starting at location \a base_addr
+/// at packed 32-bit integer indices stored in the lower half of \a vindex
+/// scaled by \a scale and stores them in dst.
+///
+/// This intrinsic corresponds to the <c> VPGATHERDQ </c> instructions.
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+///   i := j*64
+///   m := j*32
+///   addr := base_addr + SignExtend64(vindex[m+31:m]) * ZeroExtend64(scale) * 8
+///   dst[i+63:i] := MEM[addr+63:addr]
+/// ENDFOR
+/// dst[MAX:512] := 0
+/// \endcode
+#define _mm512_i32logather_epi64(vindex, base_addr, scale)                     \
+  _mm512_i32gather_epi64(_mm512_castsi512_si256(vindex), (base_addr), (scale))
+
+/// Loads 8 64-bit integer elements from memory starting at location \a base_addr
+/// at packed 32-bit integer indices stored in the lower half of \a vindex
+/// scaled by \a scale and stores them in dst using writemask \a mask (elements
+/// are copied from \a src when the corresponding mask bit is not set).
+///
+/// This intrinsic corresponds to the <c> VPGATHERDQ </c> instructions.
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+///   i := j*64
+///   m := j*32
+///   IF mask[j]
+///     addr := base_addr + SignExtend64(vindex[m+31:m]) * ZeroExtend64(scale) * 8
+///     dst[i+63:i] := MEM[addr+63:addr]
+///   ELSE
+///     dst[i+63:i] := src[i+63:i]
+///   FI
+/// ENDFOR
+/// dst[MAX:512] := 0
+/// \endcode
+#define _mm512_mask_i32logather_epi64(src, mask, vindex, base_addr, scale)     \
+  _mm512_mask_i32gather_epi64((src), (mask), _mm512_castsi512_si256(vindex),   \
+                              (base_addr), (scale))
+
+/// Stores 8 packed double-precision (64-bit) floating-point elements in \a v1
+/// and to memory locations starting at location \a base_addr at packed 32-bit
+/// integer indices stored in \a vindex scaled by \a scale.
+///
+/// This intrinsic corresponds to the <c> VSCATTERDPD </c> instructions.
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+///   i := j*64
+///   m := j*32
+///   addr := base_addr + SignExtend64(vindex[m+31:m]) * ZeroExtend64(scale) * 8
+///   MEM[addr+63:addr] := v1[i+63:i]
+/// ENDFOR
+/// \endcode
+#define _mm512_i32loscatter_pd(base_addr, vindex, v1, scale)                   \
+  _mm512_i32scatter_pd((base_addr), _mm512_castsi512_si256(vindex), (v1), (scale))
+
+/// Stores 8 packed double-precision (64-bit) floating-point elements in \a v1
+/// to memory locations starting at location \a base_addr at packed 32-bit
+/// integer indices stored in \a vindex scaled by \a scale. Only those elements
+/// whose corresponding mask bit is set in writemask \a mask are written to
+/// memory.
+///
+/// This intrinsic corresponds to the <c> VSCATTERDPD </c> instructions.
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+///   i := j*64
+///   m := j*32
+///   IF mask[j]
+///     addr := base_addr + SignExtend64(vindex[m+31:m]) * ZeroExtend64(scale) * 8
+///     MEM[addr+63:addr] := a[i+63:i]
+///   FI
+/// ENDFOR
+/// \endcode
+#define _mm512_mask_i32loscatter_pd(base_addr, mask, vindex, v1, scale)        \
+  _mm512_mask_i32scatter_pd((base_addr), (mask),                               \
+                            _mm512_castsi512_si256(vindex), (v1), (scale))
+
+/// Stores 8 packed 64-bit integer elements located in \a v1 and stores them in
+/// memory locations starting at location \a base_addr at packed 32-bit integer
+/// indices stored in \a vindex scaled by \a scale.
+///
+/// This intrinsic corresponds to the <c> VPSCATTERDQ </c> instructions.
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+///   i := j*64
+///   m := j*32
+///   addr := base_addr + SignExtend64(vindex[m+31:m]) * ZeroExtend64(scale) * 8
+///   MEM[addr+63:addr] := a[i+63:i]
+/// ENDFOR
+/// \endcode
+#define _mm512_i32loscatter_epi64(base_addr, vindex, v1, scale)                \
+  _mm512_i32scatter_epi64((base_addr),                                         \
+                          _mm512_castsi512_si256(vindex), (v1), (scale))
+
+/// Stores 8 packed 64-bit integer elements located in a and stores them in
+/// memory locations starting at location \a base_addr at packed 32-bit integer
+/// indices stored in \a vindex scaled by scale using writemask \a mask (elements
+/// whose corresponding mask bit is not set are not written to memory).
+///
+/// This intrinsic corresponds to the <c> VPSCATTERDQ </c> instructions.
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+///   i := j*64
+///   m := j*32
+///   IF mask[j]
+///     addr := base_addr + SignExtend64(vindex[m+31:m]) * ZeroExtend64(scale) * 8
+///     MEM[addr+63:addr] := a[i+63:i]
+///   FI
+/// ENDFOR
+/// \endcode
+#define _mm512_mask_i32loscatter_epi64(base_addr, mask, vindex, v1, scale)     \
+  _mm512_mask_i32scatter_epi64((base_addr), (mask),                            \
+                               _mm512_castsi512_si256(vindex), (v1), (scale))
+
+#undef __DEFAULT_FN_ATTRS512
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __AVX512FINTRIN_H */
diff --git a/third_party/intel/clang/avx512fp16intrin.h b/third_party/intel/clang/avx512fp16intrin.h
new file mode 100644
index 000000000..e136aa14a
--- /dev/null
+++ b/third_party/intel/clang/avx512fp16intrin.h
@@ -0,0 +1,3352 @@
+/*===----------- avx512fp16intrin.h - AVX512-FP16 intrinsics ---------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512fp16intrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifdef __SSE2__
+
+#ifndef __AVX512FP16INTRIN_H
+#define __AVX512FP16INTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+typedef _Float16 __v32hf __attribute__((__vector_size__(64), __aligned__(64)));
+typedef _Float16 __m512h __attribute__((__vector_size__(64), __aligned__(64)));
+typedef _Float16 __m512h_u __attribute__((__vector_size__(64), __aligned__(1)));
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS512                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512fp16,evex512"), __min_vector_width__(512)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512fp16,no-evex512"),                          \
+                 __min_vector_width__(256)))
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512fp16,no-evex512"),                          \
+                 __min_vector_width__(128)))
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS512 _mm512_cvtsh_h(__m512h __a) {
+  return __a[0];
+}
+
+static __inline __m128h __DEFAULT_FN_ATTRS128 _mm_setzero_ph(void) {
+  return (__m128h){0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+}
+
+static __inline __m256h __DEFAULT_FN_ATTRS256 _mm256_setzero_ph(void) {
+  return (__m256h){0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+                   0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_undefined_ph(void) {
+  return (__m256h)__builtin_ia32_undef256();
+}
+
+static __inline __m512h __DEFAULT_FN_ATTRS512 _mm512_setzero_ph(void) {
+  return (__m512h){0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+                   0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
+                   0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_undefined_ph(void) {
+  return (__m128h)__builtin_ia32_undef128();
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_undefined_ph(void) {
+  return (__m512h)__builtin_ia32_undef512();
+}
+
+static __inline __m512h __DEFAULT_FN_ATTRS512 _mm512_set1_ph(_Float16 __h) {
+  return (__m512h)(__v32hf){__h, __h, __h, __h, __h, __h, __h, __h,
+                            __h, __h, __h, __h, __h, __h, __h, __h,
+                            __h, __h, __h, __h, __h, __h, __h, __h,
+                            __h, __h, __h, __h, __h, __h, __h, __h};
+}
+
+static __inline __m512h __DEFAULT_FN_ATTRS512
+_mm512_set_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
+              _Float16 __h5, _Float16 __h6, _Float16 __h7, _Float16 __h8,
+              _Float16 __h9, _Float16 __h10, _Float16 __h11, _Float16 __h12,
+              _Float16 __h13, _Float16 __h14, _Float16 __h15, _Float16 __h16,
+              _Float16 __h17, _Float16 __h18, _Float16 __h19, _Float16 __h20,
+              _Float16 __h21, _Float16 __h22, _Float16 __h23, _Float16 __h24,
+              _Float16 __h25, _Float16 __h26, _Float16 __h27, _Float16 __h28,
+              _Float16 __h29, _Float16 __h30, _Float16 __h31, _Float16 __h32) {
+  return (__m512h)(__v32hf){__h32, __h31, __h30, __h29, __h28, __h27, __h26,
+                            __h25, __h24, __h23, __h22, __h21, __h20, __h19,
+                            __h18, __h17, __h16, __h15, __h14, __h13, __h12,
+                            __h11, __h10, __h9,  __h8,  __h7,  __h6,  __h5,
+                            __h4,  __h3,  __h2,  __h1};
+}
+
+#define _mm512_setr_ph(h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11, h12, h13, \
+                       h14, h15, h16, h17, h18, h19, h20, h21, h22, h23, h24,  \
+                       h25, h26, h27, h28, h29, h30, h31, h32)                 \
+  _mm512_set_ph((h32), (h31), (h30), (h29), (h28), (h27), (h26), (h25), (h24), \
+                (h23), (h22), (h21), (h20), (h19), (h18), (h17), (h16), (h15), \
+                (h14), (h13), (h12), (h11), (h10), (h9), (h8), (h7), (h6),     \
+                (h5), (h4), (h3), (h2), (h1))
+
+static __inline __m512h __DEFAULT_FN_ATTRS512
+_mm512_set1_pch(_Float16 _Complex __h) {
+  return (__m512h)_mm512_set1_ps(__builtin_bit_cast(float, __h));
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_castph_ps(__m128h __a) {
+  return (__m128)__a;
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256 _mm256_castph_ps(__m256h __a) {
+  return (__m256)__a;
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512 _mm512_castph_ps(__m512h __a) {
+  return (__m512)__a;
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_castph_pd(__m128h __a) {
+  return (__m128d)__a;
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256 _mm256_castph_pd(__m256h __a) {
+  return (__m256d)__a;
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512 _mm512_castph_pd(__m512h __a) {
+  return (__m512d)__a;
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_castph_si128(__m128h __a) {
+  return (__m128i)__a;
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_castph_si256(__m256h __a) {
+  return (__m256i)__a;
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_castph_si512(__m512h __a) {
+  return (__m512i)__a;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_castps_ph(__m128 __a) {
+  return (__m128h)__a;
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_castps_ph(__m256 __a) {
+  return (__m256h)__a;
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_castps_ph(__m512 __a) {
+  return (__m512h)__a;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_castpd_ph(__m128d __a) {
+  return (__m128h)__a;
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_castpd_ph(__m256d __a) {
+  return (__m256h)__a;
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_castpd_ph(__m512d __a) {
+  return (__m512h)__a;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_castsi128_ph(__m128i __a) {
+  return (__m128h)__a;
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_castsi256_ph(__m256i __a) {
+  return (__m256h)__a;
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_castsi512_ph(__m512i __a) {
+  return (__m512h)__a;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_castph256_ph128(__m256h __a) {
+  return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS512
+_mm512_castph512_ph128(__m512h __a) {
+  return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS512
+_mm512_castph512_ph256(__m512h __a) {
+  return __builtin_shufflevector(__a, __a, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+                                 12, 13, 14, 15);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_castph128_ph256(__m128h __a) {
+  return __builtin_shufflevector(__a, __builtin_nondeterministic_value(__a),
+                                  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_castph128_ph512(__m128h __a) {
+  __m256h __b = __builtin_nondeterministic_value(__b);
+  return __builtin_shufflevector(
+      __builtin_shufflevector(__a, __builtin_nondeterministic_value(__a),
+                              0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15),
+      __b, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+      20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_castph256_ph512(__m256h __a) {
+  return __builtin_shufflevector(__a, __builtin_nondeterministic_value(__a), 0,
+                                 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+                                 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+                                 27, 28, 29, 30, 31);
+}
+
+/// Constructs a 256-bit floating-point vector of [16 x half] from a
+///    128-bit floating-point vector of [8 x half]. The lower 128 bits
+///    contain the value of the source vector. The upper 384 bits are set
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x half].
+/// \returns A 512-bit floating-point vector of [16 x half]. The lower 128 bits
+///    contain the value of the parameter. The upper 384 bits are set to zero.
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_zextph128_ph256(__m128h __a) {
+  return __builtin_shufflevector(__a, (__v8hf)_mm_setzero_ph(), 0, 1, 2, 3, 4,
+                                 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+
+/// Constructs a 512-bit floating-point vector of [32 x half] from a
+///    128-bit floating-point vector of [8 x half]. The lower 128 bits
+///    contain the value of the source vector. The upper 384 bits are set
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x half].
+/// \returns A 512-bit floating-point vector of [32 x half]. The lower 128 bits
+///    contain the value of the parameter. The upper 384 bits are set to zero.
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_zextph128_ph512(__m128h __a) {
+  return __builtin_shufflevector(
+      __a, (__v8hf)_mm_setzero_ph(), 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+      13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15, 8, 9, 10, 11, 12, 13, 14, 15);
+}
+
+/// Constructs a 512-bit floating-point vector of [32 x half] from a
+///    256-bit floating-point vector of [16 x half]. The lower 256 bits
+///    contain the value of the source vector. The upper 256 bits are set
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit vector of [16 x half].
+/// \returns A 512-bit floating-point vector of [32 x half]. The lower 256 bits
+///    contain the value of the parameter. The upper 256 bits are set to zero.
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_zextph256_ph512(__m256h __a) {
+  return __builtin_shufflevector(__a, (__v16hf)_mm256_setzero_ph(), 0, 1, 2, 3,
+                                 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+                                 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
+                                 29, 30, 31);
+}
+
+#define _mm_comi_round_sh(A, B, P, R)                                          \
+  __builtin_ia32_vcomish((__v8hf)A, (__v8hf)B, (int)(P), (int)(R))
+
+#define _mm_comi_sh(A, B, pred)                                                \
+  _mm_comi_round_sh((A), (B), (pred), _MM_FROUND_CUR_DIRECTION)
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comieq_sh(__m128h __A,
+                                                          __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_EQ_OS,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comilt_sh(__m128h __A,
+                                                          __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_LT_OS,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comile_sh(__m128h __A,
+                                                          __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_LE_OS,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comigt_sh(__m128h __A,
+                                                          __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_GT_OS,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comige_sh(__m128h __A,
+                                                          __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_GE_OS,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_comineq_sh(__m128h __A,
+                                                           __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_NEQ_US,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomieq_sh(__m128h __A,
+                                                           __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_EQ_OQ,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomilt_sh(__m128h __A,
+                                                           __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_LT_OQ,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomile_sh(__m128h __A,
+                                                           __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_LE_OQ,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomigt_sh(__m128h __A,
+                                                           __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_GT_OQ,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomige_sh(__m128h __A,
+                                                           __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_GE_OQ,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_ucomineq_sh(__m128h __A,
+                                                            __m128h __B) {
+  return __builtin_ia32_vcomish((__v8hf)__A, (__v8hf)__B, _CMP_NEQ_UQ,
+                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_add_ph(__m512h __A,
+                                                              __m512h __B) {
+  return (__m512h)((__v32hf)__A + (__v32hf)__B);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_add_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512(
+      (__mmask32)__U, (__v32hf)_mm512_add_ph(__A, __B), (__v32hf)__W);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_add_ph(__mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
+                                              (__v32hf)_mm512_add_ph(__A, __B),
+                                              (__v32hf)_mm512_setzero_ph());
+}
+
+#define _mm512_add_round_ph(A, B, R)                                           \
+  ((__m512h)__builtin_ia32_addph512((__v32hf)(__m512h)(A),                     \
+                                    (__v32hf)(__m512h)(B), (int)(R)))
+
+#define _mm512_mask_add_round_ph(W, U, A, B, R)                                \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_add_round_ph((A), (B), (R)),             \
+      (__v32hf)(__m512h)(W)))
+
+#define _mm512_maskz_add_round_ph(U, A, B, R)                                  \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_add_round_ph((A), (B), (R)),             \
+      (__v32hf)_mm512_setzero_ph()))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_sub_ph(__m512h __A,
+                                                              __m512h __B) {
+  return (__m512h)((__v32hf)__A - (__v32hf)__B);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_sub_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512(
+      (__mmask32)__U, (__v32hf)_mm512_sub_ph(__A, __B), (__v32hf)__W);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_sub_ph(__mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
+                                              (__v32hf)_mm512_sub_ph(__A, __B),
+                                              (__v32hf)_mm512_setzero_ph());
+}
+
+#define _mm512_sub_round_ph(A, B, R)                                           \
+  ((__m512h)__builtin_ia32_subph512((__v32hf)(__m512h)(A),                     \
+                                    (__v32hf)(__m512h)(B), (int)(R)))
+
+#define _mm512_mask_sub_round_ph(W, U, A, B, R)                                \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_sub_round_ph((A), (B), (R)),             \
+      (__v32hf)(__m512h)(W)))
+
+#define _mm512_maskz_sub_round_ph(U, A, B, R)                                  \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_sub_round_ph((A), (B), (R)),             \
+      (__v32hf)_mm512_setzero_ph()))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_mul_ph(__m512h __A,
+                                                              __m512h __B) {
+  return (__m512h)((__v32hf)__A * (__v32hf)__B);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_mul_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512(
+      (__mmask32)__U, (__v32hf)_mm512_mul_ph(__A, __B), (__v32hf)__W);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_mul_ph(__mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
+                                              (__v32hf)_mm512_mul_ph(__A, __B),
+                                              (__v32hf)_mm512_setzero_ph());
+}
+
+#define _mm512_mul_round_ph(A, B, R)                                           \
+  ((__m512h)__builtin_ia32_mulph512((__v32hf)(__m512h)(A),                     \
+                                    (__v32hf)(__m512h)(B), (int)(R)))
+
+#define _mm512_mask_mul_round_ph(W, U, A, B, R)                                \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_mul_round_ph((A), (B), (R)),             \
+      (__v32hf)(__m512h)(W)))
+
+#define _mm512_maskz_mul_round_ph(U, A, B, R)                                  \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_mul_round_ph((A), (B), (R)),             \
+      (__v32hf)_mm512_setzero_ph()))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_div_ph(__m512h __A,
+                                                              __m512h __B) {
+  return (__m512h)((__v32hf)__A / (__v32hf)__B);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_div_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512(
+      (__mmask32)__U, (__v32hf)_mm512_div_ph(__A, __B), (__v32hf)__W);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_div_ph(__mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
+                                              (__v32hf)_mm512_div_ph(__A, __B),
+                                              (__v32hf)_mm512_setzero_ph());
+}
+
+#define _mm512_div_round_ph(A, B, R)                                           \
+  ((__m512h)__builtin_ia32_divph512((__v32hf)(__m512h)(A),                     \
+                                    (__v32hf)(__m512h)(B), (int)(R)))
+
+#define _mm512_mask_div_round_ph(W, U, A, B, R)                                \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_div_round_ph((A), (B), (R)),             \
+      (__v32hf)(__m512h)(W)))
+
+#define _mm512_maskz_div_round_ph(U, A, B, R)                                  \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_div_round_ph((A), (B), (R)),             \
+      (__v32hf)_mm512_setzero_ph()))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_min_ph(__m512h __A,
+                                                              __m512h __B) {
+  return (__m512h)__builtin_ia32_minph512((__v32hf)__A, (__v32hf)__B,
+                                          _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_min_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512(
+      (__mmask32)__U, (__v32hf)_mm512_min_ph(__A, __B), (__v32hf)__W);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_min_ph(__mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
+                                              (__v32hf)_mm512_min_ph(__A, __B),
+                                              (__v32hf)_mm512_setzero_ph());
+}
+
+#define _mm512_min_round_ph(A, B, R)                                           \
+  ((__m512h)__builtin_ia32_minph512((__v32hf)(__m512h)(A),                     \
+                                    (__v32hf)(__m512h)(B), (int)(R)))
+
+#define _mm512_mask_min_round_ph(W, U, A, B, R)                                \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_min_round_ph((A), (B), (R)),             \
+      (__v32hf)(__m512h)(W)))
+
+#define _mm512_maskz_min_round_ph(U, A, B, R)                                  \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_min_round_ph((A), (B), (R)),             \
+      (__v32hf)_mm512_setzero_ph()))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_max_ph(__m512h __A,
+                                                              __m512h __B) {
+  return (__m512h)__builtin_ia32_maxph512((__v32hf)__A, (__v32hf)__B,
+                                          _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_max_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512(
+      (__mmask32)__U, (__v32hf)_mm512_max_ph(__A, __B), (__v32hf)__W);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_max_ph(__mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U,
+                                              (__v32hf)_mm512_max_ph(__A, __B),
+                                              (__v32hf)_mm512_setzero_ph());
+}
+
+#define _mm512_max_round_ph(A, B, R)                                           \
+  ((__m512h)__builtin_ia32_maxph512((__v32hf)(__m512h)(A),                     \
+                                    (__v32hf)(__m512h)(B), (int)(R)))
+
+#define _mm512_mask_max_round_ph(W, U, A, B, R)                                \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_max_round_ph((A), (B), (R)),             \
+      (__v32hf)(__m512h)(W)))
+
+#define _mm512_maskz_max_round_ph(U, A, B, R)                                  \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_max_round_ph((A), (B), (R)),             \
+      (__v32hf)_mm512_setzero_ph()))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_abs_ph(__m512h __A) {
+  return (__m512h)_mm512_and_epi32(_mm512_set1_epi32(0x7FFF7FFF), (__m512i)__A);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_conj_pch(__m512h __A) {
+  return (__m512h)_mm512_xor_ps((__m512)__A, _mm512_set1_ps(-0.0f));
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_conj_pch(__m512h __W, __mmask16 __U, __m512h __A) {
+  return (__m512h)__builtin_ia32_selectps_512(
+      (__mmask16)__U, (__v16sf)_mm512_conj_pch(__A), (__v16sf)__W);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_conj_pch(__mmask16 __U, __m512h __A) {
+  return (__m512h)__builtin_ia32_selectps_512((__mmask16)__U,
+                                              (__v16sf)_mm512_conj_pch(__A),
+                                              (__v16sf)_mm512_setzero_ps());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_add_sh(__m128h __A,
+                                                           __m128h __B) {
+  __A[0] += __B[0];
+  return __A;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_add_sh(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  __A = _mm_add_sh(__A, __B);
+  return __builtin_ia32_selectsh_128(__U, __A, __W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_add_sh(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  __A = _mm_add_sh(__A, __B);
+  return __builtin_ia32_selectsh_128(__U, __A, _mm_setzero_ph());
+}
+
+#define _mm_add_round_sh(A, B, R)                                              \
+  ((__m128h)__builtin_ia32_addsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_add_round_sh(W, U, A, B, R)                                   \
+  ((__m128h)__builtin_ia32_addsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_add_round_sh(U, A, B, R)                                     \
+  ((__m128h)__builtin_ia32_addsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_sub_sh(__m128h __A,
+                                                           __m128h __B) {
+  __A[0] -= __B[0];
+  return __A;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_sub_sh(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  __A = _mm_sub_sh(__A, __B);
+  return __builtin_ia32_selectsh_128(__U, __A, __W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_sub_sh(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  __A = _mm_sub_sh(__A, __B);
+  return __builtin_ia32_selectsh_128(__U, __A, _mm_setzero_ph());
+}
+
+#define _mm_sub_round_sh(A, B, R)                                              \
+  ((__m128h)__builtin_ia32_subsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_sub_round_sh(W, U, A, B, R)                                   \
+  ((__m128h)__builtin_ia32_subsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_sub_round_sh(U, A, B, R)                                     \
+  ((__m128h)__builtin_ia32_subsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mul_sh(__m128h __A,
+                                                           __m128h __B) {
+  __A[0] *= __B[0];
+  return __A;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_mul_sh(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  __A = _mm_mul_sh(__A, __B);
+  return __builtin_ia32_selectsh_128(__U, __A, __W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_mul_sh(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  __A = _mm_mul_sh(__A, __B);
+  return __builtin_ia32_selectsh_128(__U, __A, _mm_setzero_ph());
+}
+
+#define _mm_mul_round_sh(A, B, R)                                              \
+  ((__m128h)__builtin_ia32_mulsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_mul_round_sh(W, U, A, B, R)                                   \
+  ((__m128h)__builtin_ia32_mulsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_mul_round_sh(U, A, B, R)                                     \
+  ((__m128h)__builtin_ia32_mulsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_div_sh(__m128h __A,
+                                                           __m128h __B) {
+  __A[0] /= __B[0];
+  return __A;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_div_sh(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  __A = _mm_div_sh(__A, __B);
+  return __builtin_ia32_selectsh_128(__U, __A, __W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_div_sh(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  __A = _mm_div_sh(__A, __B);
+  return __builtin_ia32_selectsh_128(__U, __A, _mm_setzero_ph());
+}
+
+#define _mm_div_round_sh(A, B, R)                                              \
+  ((__m128h)__builtin_ia32_divsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_div_round_sh(W, U, A, B, R)                                   \
+  ((__m128h)__builtin_ia32_divsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_div_round_sh(U, A, B, R)                                     \
+  ((__m128h)__builtin_ia32_divsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_min_sh(__m128h __A,
+                                                           __m128h __B) {
+  return (__m128h)__builtin_ia32_minsh_round_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_min_sh(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  return (__m128h)__builtin_ia32_minsh_round_mask((__v8hf)__A, (__v8hf)__B,
+                                                  (__v8hf)__W, (__mmask8)__U,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_min_sh(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return (__m128h)__builtin_ia32_minsh_round_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_min_round_sh(A, B, R)                                              \
+  ((__m128h)__builtin_ia32_minsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_min_round_sh(W, U, A, B, R)                                   \
+  ((__m128h)__builtin_ia32_minsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_min_round_sh(U, A, B, R)                                     \
+  ((__m128h)__builtin_ia32_minsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_max_sh(__m128h __A,
+                                                           __m128h __B) {
+  return (__m128h)__builtin_ia32_maxsh_round_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_max_sh(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  return (__m128h)__builtin_ia32_maxsh_round_mask((__v8hf)__A, (__v8hf)__B,
+                                                  (__v8hf)__W, (__mmask8)__U,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_max_sh(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return (__m128h)__builtin_ia32_maxsh_round_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_max_round_sh(A, B, R)                                              \
+  ((__m128h)__builtin_ia32_maxsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_max_round_sh(W, U, A, B, R)                                   \
+  ((__m128h)__builtin_ia32_maxsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_max_round_sh(U, A, B, R)                                     \
+  ((__m128h)__builtin_ia32_maxsh_round_mask(                                   \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm512_cmp_round_ph_mask(A, B, P, R)                                   \
+  ((__mmask32)__builtin_ia32_cmpph512_mask((__v32hf)(__m512h)(A),              \
+                                           (__v32hf)(__m512h)(B), (int)(P),    \
+                                           (__mmask32)-1, (int)(R)))
+
+#define _mm512_mask_cmp_round_ph_mask(U, A, B, P, R)                           \
+  ((__mmask32)__builtin_ia32_cmpph512_mask((__v32hf)(__m512h)(A),              \
+                                           (__v32hf)(__m512h)(B), (int)(P),    \
+                                           (__mmask32)(U), (int)(R)))
+
+#define _mm512_cmp_ph_mask(A, B, P)                                            \
+  _mm512_cmp_round_ph_mask((A), (B), (P), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm512_mask_cmp_ph_mask(U, A, B, P)                                    \
+  _mm512_mask_cmp_round_ph_mask((U), (A), (B), (P), _MM_FROUND_CUR_DIRECTION)
+
+#define _mm_cmp_round_sh_mask(X, Y, P, R)                                      \
+  ((__mmask8)__builtin_ia32_cmpsh_mask((__v8hf)(__m128h)(X),                   \
+                                       (__v8hf)(__m128h)(Y), (int)(P),         \
+                                       (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_cmp_round_sh_mask(M, X, Y, P, R)                              \
+  ((__mmask8)__builtin_ia32_cmpsh_mask((__v8hf)(__m128h)(X),                   \
+                                       (__v8hf)(__m128h)(Y), (int)(P),         \
+                                       (__mmask8)(M), (int)(R)))
+
+#define _mm_cmp_sh_mask(X, Y, P)                                               \
+  ((__mmask8)__builtin_ia32_cmpsh_mask(                                        \
+      (__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(P), (__mmask8)-1,      \
+      _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_cmp_sh_mask(M, X, Y, P)                                       \
+  ((__mmask8)__builtin_ia32_cmpsh_mask(                                        \
+      (__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y), (int)(P), (__mmask8)(M),     \
+      _MM_FROUND_CUR_DIRECTION))
+// loads with vmovsh:
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_load_sh(void const *__dp) {
+  struct __mm_load_sh_struct {
+    _Float16 __u;
+  } __attribute__((__packed__, __may_alias__));
+  _Float16 __u = ((const struct __mm_load_sh_struct *)__dp)->__u;
+  return (__m128h){__u, 0, 0, 0, 0, 0, 0, 0};
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_load_sh(__m128h __W, __mmask8 __U, const void *__A) {
+  __m128h src = (__v8hf)__builtin_shufflevector(
+      (__v8hf)__W, (__v8hf)_mm_setzero_ph(), 0, 8, 8, 8, 8, 8, 8, 8);
+
+  return (__m128h)__builtin_ia32_loadsh128_mask((const __v8hf *)__A, src, __U & 1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_load_sh(__mmask8 __U, const void *__A) {
+  return (__m128h)__builtin_ia32_loadsh128_mask(
+      (const __v8hf *)__A, (__v8hf)_mm_setzero_ph(), __U & 1);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_load_ph(void const *__p) {
+  return *(const __m512h *)__p;
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_load_ph(void const *__p) {
+  return *(const __m256h *)__p;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_load_ph(void const *__p) {
+  return *(const __m128h *)__p;
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_loadu_ph(void const *__p) {
+  struct __loadu_ph {
+    __m512h_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_ph *)__p)->__v;
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_loadu_ph(void const *__p) {
+  struct __loadu_ph {
+    __m256h_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_ph *)__p)->__v;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_loadu_ph(void const *__p) {
+  struct __loadu_ph {
+    __m128h_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_ph *)__p)->__v;
+}
+
+// stores with vmovsh:
+static __inline__ void __DEFAULT_FN_ATTRS128 _mm_store_sh(void *__dp,
+                                                          __m128h __a) {
+  struct __mm_store_sh_struct {
+    _Float16 __u;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __mm_store_sh_struct *)__dp)->__u = __a[0];
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128 _mm_mask_store_sh(void *__W,
+                                                               __mmask8 __U,
+                                                               __m128h __A) {
+  __builtin_ia32_storesh128_mask((__v8hf *)__W, __A, __U & 1);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512 _mm512_store_ph(void *__P,
+                                                             __m512h __A) {
+  *(__m512h *)__P = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256 _mm256_store_ph(void *__P,
+                                                             __m256h __A) {
+  *(__m256h *)__P = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128 _mm_store_ph(void *__P,
+                                                          __m128h __A) {
+  *(__m128h *)__P = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS512 _mm512_storeu_ph(void *__P,
+                                                              __m512h __A) {
+  struct __storeu_ph {
+    __m512h_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_ph *)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256 _mm256_storeu_ph(void *__P,
+                                                              __m256h __A) {
+  struct __storeu_ph {
+    __m256h_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_ph *)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128 _mm_storeu_ph(void *__P,
+                                                           __m128h __A) {
+  struct __storeu_ph {
+    __m128h_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_ph *)__P)->__v = __A;
+}
+
+// moves with vmovsh:
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_move_sh(__m128h __a,
+                                                            __m128h __b) {
+  __a[0] = __b[0];
+  return __a;
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_move_sh(__m128h __W,
+                                                                 __mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return __builtin_ia32_selectsh_128(__U, _mm_move_sh(__A, __B), __W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_move_sh(__mmask8 __U,
+                                                                  __m128h __A,
+                                                                  __m128h __B) {
+  return __builtin_ia32_selectsh_128(__U, _mm_move_sh(__A, __B),
+                                     _mm_setzero_ph());
+}
+
+// vmovw:
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtsi16_si128(short __a) {
+  return (__m128i)(__v8hi){__a, 0, 0, 0, 0, 0, 0, 0};
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128 _mm_cvtsi128_si16(__m128i __a) {
+  __v8hi __b = (__v8hi)__a;
+  return __b[0];
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_rcp_ph(__m512h __A) {
+  return (__m512h)__builtin_ia32_rcpph512_mask(
+      (__v32hf)__A, (__v32hf)_mm512_undefined_ph(), (__mmask32)-1);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_rcp_ph(__m512h __W, __mmask32 __U, __m512h __A) {
+  return (__m512h)__builtin_ia32_rcpph512_mask((__v32hf)__A, (__v32hf)__W,
+                                               (__mmask32)__U);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_rcp_ph(__mmask32 __U, __m512h __A) {
+  return (__m512h)__builtin_ia32_rcpph512_mask(
+      (__v32hf)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_rsqrt_ph(__m512h __A) {
+  return (__m512h)__builtin_ia32_rsqrtph512_mask(
+      (__v32hf)__A, (__v32hf)_mm512_undefined_ph(), (__mmask32)-1);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_rsqrt_ph(__m512h __W, __mmask32 __U, __m512h __A) {
+  return (__m512h)__builtin_ia32_rsqrtph512_mask((__v32hf)__A, (__v32hf)__W,
+                                                 (__mmask32)__U);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_rsqrt_ph(__mmask32 __U, __m512h __A) {
+  return (__m512h)__builtin_ia32_rsqrtph512_mask(
+      (__v32hf)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U);
+}
+
+#define _mm512_getmant_ph(A, B, C)                                             \
+  ((__m512h)__builtin_ia32_getmantph512_mask(                                  \
+      (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)),                          \
+      (__v32hf)_mm512_undefined_ph(), (__mmask32)-1,                           \
+      _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_getmant_ph(W, U, A, B, C)                                  \
+  ((__m512h)__builtin_ia32_getmantph512_mask(                                  \
+      (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)), (__v32hf)(__m512h)(W),   \
+      (__mmask32)(U), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_getmant_ph(U, A, B, C)                                    \
+  ((__m512h)__builtin_ia32_getmantph512_mask(                                  \
+      (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)),                          \
+      (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_getmant_round_ph(A, B, C, R)                                    \
+  ((__m512h)__builtin_ia32_getmantph512_mask(                                  \
+      (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)),                          \
+      (__v32hf)_mm512_undefined_ph(), (__mmask32)-1, (int)(R)))
+
+#define _mm512_mask_getmant_round_ph(W, U, A, B, C, R)                         \
+  ((__m512h)__builtin_ia32_getmantph512_mask(                                  \
+      (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)), (__v32hf)(__m512h)(W),   \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_getmant_round_ph(U, A, B, C, R)                           \
+  ((__m512h)__builtin_ia32_getmantph512_mask(                                  \
+      (__v32hf)(__m512h)(A), (int)(((C) << 2) | (B)),                          \
+      (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_getexp_ph(__m512h __A) {
+  return (__m512h)__builtin_ia32_getexpph512_mask(
+      (__v32hf)__A, (__v32hf)_mm512_undefined_ph(), (__mmask32)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_getexp_ph(__m512h __W, __mmask32 __U, __m512h __A) {
+  return (__m512h)__builtin_ia32_getexpph512_mask(
+      (__v32hf)__A, (__v32hf)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_getexp_ph(__mmask32 __U, __m512h __A) {
+  return (__m512h)__builtin_ia32_getexpph512_mask(
+      (__v32hf)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_getexp_round_ph(A, R)                                           \
+  ((__m512h)__builtin_ia32_getexpph512_mask((__v32hf)(__m512h)(A),             \
+                                            (__v32hf)_mm512_undefined_ph(),    \
+                                            (__mmask32)-1, (int)(R)))
+
+#define _mm512_mask_getexp_round_ph(W, U, A, R)                                \
+  ((__m512h)__builtin_ia32_getexpph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(W), (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_getexp_round_ph(U, A, R)                                  \
+  ((__m512h)__builtin_ia32_getexpph512_mask((__v32hf)(__m512h)(A),             \
+                                            (__v32hf)_mm512_setzero_ph(),      \
+                                            (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_scalef_ph(__m512h __A,
+                                                                 __m512h __B) {
+  return (__m512h)__builtin_ia32_scalefph512_mask(
+      (__v32hf)__A, (__v32hf)__B, (__v32hf)_mm512_undefined_ph(), (__mmask32)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_scalef_ph(__m512h __W, __mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_scalefph512_mask((__v32hf)__A, (__v32hf)__B,
+                                                  (__v32hf)__W, (__mmask32)__U,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_scalef_ph(__mmask32 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_scalefph512_mask(
+      (__v32hf)__A, (__v32hf)__B, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_scalef_round_ph(A, B, R)                                        \
+  ((__m512h)__builtin_ia32_scalefph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B),                            \
+      (__v32hf)_mm512_undefined_ph(), (__mmask32)-1, (int)(R)))
+
+#define _mm512_mask_scalef_round_ph(W, U, A, B, R)                             \
+  ((__m512h)__builtin_ia32_scalefph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(W),     \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_scalef_round_ph(U, A, B, R)                               \
+  ((__m512h)__builtin_ia32_scalefph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B),                            \
+      (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), (int)(R)))
+
+#define _mm512_roundscale_ph(A, B)                                             \
+  ((__m512h)__builtin_ia32_rndscaleph_mask(                                    \
+      (__v32hf)(__m512h)(A), (int)(B), (__v32hf)(__m512h)(A), (__mmask32)-1,   \
+      _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_roundscale_ph(A, B, C, imm)                                \
+  ((__m512h)__builtin_ia32_rndscaleph_mask(                                    \
+      (__v32hf)(__m512h)(C), (int)(imm), (__v32hf)(__m512h)(A),                \
+      (__mmask32)(B), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_roundscale_ph(A, B, imm)                                  \
+  ((__m512h)__builtin_ia32_rndscaleph_mask(                                    \
+      (__v32hf)(__m512h)(B), (int)(imm), (__v32hf)_mm512_setzero_ph(),         \
+      (__mmask32)(A), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_roundscale_round_ph(A, B, C, imm, R)                       \
+  ((__m512h)__builtin_ia32_rndscaleph_mask((__v32hf)(__m512h)(C), (int)(imm),  \
+                                           (__v32hf)(__m512h)(A),              \
+                                           (__mmask32)(B), (int)(R)))
+
+#define _mm512_maskz_roundscale_round_ph(A, B, imm, R)                         \
+  ((__m512h)__builtin_ia32_rndscaleph_mask((__v32hf)(__m512h)(B), (int)(imm),  \
+                                           (__v32hf)_mm512_setzero_ph(),       \
+                                           (__mmask32)(A), (int)(R)))
+
+#define _mm512_roundscale_round_ph(A, imm, R)                                  \
+  ((__m512h)__builtin_ia32_rndscaleph_mask((__v32hf)(__m512h)(A), (int)(imm),  \
+                                           (__v32hf)_mm512_undefined_ph(),     \
+                                           (__mmask32)-1, (int)(R)))
+
+#define _mm512_reduce_ph(A, imm)                                               \
+  ((__m512h)__builtin_ia32_reduceph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (int)(imm), (__v32hf)_mm512_undefined_ph(),       \
+      (__mmask32)-1, _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_reduce_ph(W, U, A, imm)                                    \
+  ((__m512h)__builtin_ia32_reduceph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (int)(imm), (__v32hf)(__m512h)(W),                \
+      (__mmask32)(U), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_maskz_reduce_ph(U, A, imm)                                      \
+  ((__m512h)__builtin_ia32_reduceph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (int)(imm), (__v32hf)_mm512_setzero_ph(),         \
+      (__mmask32)(U), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm512_mask_reduce_round_ph(W, U, A, imm, R)                           \
+  ((__m512h)__builtin_ia32_reduceph512_mask((__v32hf)(__m512h)(A), (int)(imm), \
+                                            (__v32hf)(__m512h)(W),             \
+                                            (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_reduce_round_ph(U, A, imm, R)                             \
+  ((__m512h)__builtin_ia32_reduceph512_mask((__v32hf)(__m512h)(A), (int)(imm), \
+                                            (__v32hf)_mm512_setzero_ph(),      \
+                                            (__mmask32)(U), (int)(R)))
+
+#define _mm512_reduce_round_ph(A, imm, R)                                      \
+  ((__m512h)__builtin_ia32_reduceph512_mask((__v32hf)(__m512h)(A), (int)(imm), \
+                                            (__v32hf)_mm512_undefined_ph(),    \
+                                            (__mmask32)-1, (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_rcp_sh(__m128h __A,
+                                                           __m128h __B) {
+  return (__m128h)__builtin_ia32_rcpsh_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_rcp_sh(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  return (__m128h)__builtin_ia32_rcpsh_mask((__v8hf)__A, (__v8hf)__B,
+                                            (__v8hf)__W, (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_rcp_sh(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return (__m128h)__builtin_ia32_rcpsh_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_rsqrt_sh(__m128h __A,
+                                                             __m128h __B) {
+  return (__m128h)__builtin_ia32_rsqrtsh_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_rsqrt_sh(__m128h __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A,
+                                                                  __m128h __B) {
+  return (__m128h)__builtin_ia32_rsqrtsh_mask((__v8hf)__A, (__v8hf)__B,
+                                              (__v8hf)__W, (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_rsqrt_sh(__mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_rsqrtsh_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+#define _mm_getmant_round_sh(A, B, C, D, R)                                    \
+  ((__m128h)__builtin_ia32_getmantsh_round_mask(                               \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)),     \
+      (__v8hf)_mm_setzero_ph(), (__mmask8)-1, (int)(R)))
+
+#define _mm_getmant_sh(A, B, C, D)                                             \
+  ((__m128h)__builtin_ia32_getmantsh_round_mask(                               \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)),     \
+      (__v8hf)_mm_setzero_ph(), (__mmask8)-1, _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_getmant_sh(W, U, A, B, C, D)                                  \
+  ((__m128h)__builtin_ia32_getmantsh_round_mask(                               \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)),     \
+      (__v8hf)(__m128h)(W), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_getmant_round_sh(W, U, A, B, C, D, R)                         \
+  ((__m128h)__builtin_ia32_getmantsh_round_mask(                               \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)),     \
+      (__v8hf)(__m128h)(W), (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_getmant_sh(U, A, B, C, D)                                    \
+  ((__m128h)__builtin_ia32_getmantsh_round_mask(                               \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)),     \
+      (__v8hf)_mm_setzero_ph(), (__mmask8)(U), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_getmant_round_sh(U, A, B, C, D, R)                           \
+  ((__m128h)__builtin_ia32_getmantsh_round_mask(                               \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (int)(((D) << 2) | (C)),     \
+      (__v8hf)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
+
+#define _mm_getexp_round_sh(A, B, R)                                           \
+  ((__m128h)__builtin_ia32_getexpsh128_round_mask(                             \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_getexp_sh(__m128h __A,
+                                                              __m128h __B) {
+  return (__m128h)__builtin_ia32_getexpsh128_round_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_getexp_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_getexpsh128_round_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)__W, (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask_getexp_round_sh(W, U, A, B, R)                                \
+  ((__m128h)__builtin_ia32_getexpsh128_round_mask(                             \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_getexp_sh(__mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_getexpsh128_round_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_getexp_round_sh(U, A, B, R)                                  \
+  ((__m128h)__builtin_ia32_getexpsh128_round_mask(                             \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_scalef_round_sh(A, B, R)                                           \
+  ((__m128h)__builtin_ia32_scalefsh_round_mask(                                \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_scalef_sh(__m128h __A,
+                                                              __m128h __B) {
+  return (__m128h)__builtin_ia32_scalefsh_round_mask(
+      (__v8hf)__A, (__v8hf)(__B), (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_scalef_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_scalefsh_round_mask((__v8hf)__A, (__v8hf)__B,
+                                                     (__v8hf)__W, (__mmask8)__U,
+                                                     _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask_scalef_round_sh(W, U, A, B, R)                                \
+  ((__m128h)__builtin_ia32_scalefsh_round_mask(                                \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_scalef_sh(__mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_scalefsh_round_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_scalef_round_sh(U, A, B, R)                                  \
+  ((__m128h)__builtin_ia32_scalefsh_round_mask(                                \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_roundscale_round_sh(A, B, imm, R)                                  \
+  ((__m128h)__builtin_ia32_rndscalesh_round_mask(                              \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(imm), (int)(R)))
+
+#define _mm_roundscale_sh(A, B, imm)                                           \
+  ((__m128h)__builtin_ia32_rndscalesh_round_mask(                              \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(imm), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_roundscale_sh(W, U, A, B, I)                                  \
+  ((__m128h)__builtin_ia32_rndscalesh_round_mask(                              \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(I), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_roundscale_round_sh(W, U, A, B, I, R)                         \
+  ((__m128h)__builtin_ia32_rndscalesh_round_mask(                              \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(I), (int)(R)))
+
+#define _mm_maskz_roundscale_sh(U, A, B, I)                                    \
+  ((__m128h)__builtin_ia32_rndscalesh_round_mask(                              \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(I), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_roundscale_round_sh(U, A, B, I, R)                           \
+  ((__m128h)__builtin_ia32_rndscalesh_round_mask(                              \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(I), (int)(R)))
+
+#define _mm_reduce_sh(A, B, C)                                                 \
+  ((__m128h)__builtin_ia32_reducesh_mask(                                      \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(C), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_mask_reduce_sh(W, U, A, B, C)                                      \
+  ((__m128h)__builtin_ia32_reducesh_mask(                                      \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(C), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_maskz_reduce_sh(U, A, B, C)                                        \
+  ((__m128h)__builtin_ia32_reducesh_mask(                                      \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(C), _MM_FROUND_CUR_DIRECTION))
+
+#define _mm_reduce_round_sh(A, B, C, R)                                        \
+  ((__m128h)__builtin_ia32_reducesh_mask(                                      \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(C), (int)(R)))
+
+#define _mm_mask_reduce_round_sh(W, U, A, B, C, R)                             \
+  ((__m128h)__builtin_ia32_reducesh_mask(                                      \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(C), (int)(R)))
+
+#define _mm_maskz_reduce_round_sh(U, A, B, C, R)                               \
+  ((__m128h)__builtin_ia32_reducesh_mask(                                      \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(C), (int)(R)))
+
+#define _mm512_sqrt_round_ph(A, R)                                             \
+  ((__m512h)__builtin_ia32_sqrtph512((__v32hf)(__m512h)(A), (int)(R)))
+
+#define _mm512_mask_sqrt_round_ph(W, U, A, R)                                  \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_sqrt_round_ph((A), (R)),                 \
+      (__v32hf)(__m512h)(W)))
+
+#define _mm512_maskz_sqrt_round_ph(U, A, R)                                    \
+  ((__m512h)__builtin_ia32_selectph_512(                                       \
+      (__mmask32)(U), (__v32hf)_mm512_sqrt_round_ph((A), (R)),                 \
+      (__v32hf)_mm512_setzero_ph()))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_sqrt_ph(__m512h __A) {
+  return (__m512h)__builtin_ia32_sqrtph512((__v32hf)__A,
+                                           _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_sqrt_ph(__m512h __W, __mmask32 __U, __m512h __A) {
+  return (__m512h)__builtin_ia32_selectph_512(
+      (__mmask32)(__U),
+      (__v32hf)__builtin_ia32_sqrtph512((__A), (_MM_FROUND_CUR_DIRECTION)),
+      (__v32hf)(__m512h)(__W));
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_sqrt_ph(__mmask32 __U, __m512h __A) {
+  return (__m512h)__builtin_ia32_selectph_512(
+      (__mmask32)(__U),
+      (__v32hf)__builtin_ia32_sqrtph512((__A), (_MM_FROUND_CUR_DIRECTION)),
+      (__v32hf)_mm512_setzero_ph());
+}
+
+#define _mm_sqrt_round_sh(A, B, R)                                             \
+  ((__m128h)__builtin_ia32_sqrtsh_round_mask(                                  \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_sqrt_round_sh(W, U, A, B, R)                                  \
+  ((__m128h)__builtin_ia32_sqrtsh_round_mask(                                  \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_sqrt_round_sh(U, A, B, R)                                    \
+  ((__m128h)__builtin_ia32_sqrtsh_round_mask(                                  \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)_mm_setzero_ph(),    \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_sqrt_sh(__m128h __A,
+                                                            __m128h __B) {
+  return (__m128h)__builtin_ia32_sqrtsh_round_mask(
+      (__v8hf)(__m128h)(__A), (__v8hf)(__m128h)(__B), (__v8hf)_mm_setzero_ph(),
+      (__mmask8)-1, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_sqrt_sh(__m128h __W,
+                                                                 __mmask32 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return (__m128h)__builtin_ia32_sqrtsh_round_mask(
+      (__v8hf)(__m128h)(__A), (__v8hf)(__m128h)(__B), (__v8hf)(__m128h)(__W),
+      (__mmask8)(__U), _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_sqrt_sh(__mmask32 __U,
+                                                                  __m128h __A,
+                                                                  __m128h __B) {
+  return (__m128h)__builtin_ia32_sqrtsh_round_mask(
+      (__v8hf)(__m128h)(__A), (__v8hf)(__m128h)(__B), (__v8hf)_mm_setzero_ph(),
+      (__mmask8)(__U), _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask_fpclass_ph_mask(U, A, imm)                                 \
+  ((__mmask32)__builtin_ia32_fpclassph512_mask((__v32hf)(__m512h)(A),          \
+                                               (int)(imm), (__mmask32)(U)))
+
+#define _mm512_fpclass_ph_mask(A, imm)                                         \
+  ((__mmask32)__builtin_ia32_fpclassph512_mask((__v32hf)(__m512h)(A),          \
+                                               (int)(imm), (__mmask32)-1))
+
+#define _mm_fpclass_sh_mask(A, imm)                                            \
+  ((__mmask8)__builtin_ia32_fpclasssh_mask((__v8hf)(__m128h)(A), (int)(imm),   \
+                                           (__mmask8)-1))
+
+#define _mm_mask_fpclass_sh_mask(U, A, imm)                                    \
+  ((__mmask8)__builtin_ia32_fpclasssh_mask((__v8hf)(__m128h)(A), (int)(imm),   \
+                                           (__mmask8)(U)))
+
+#define _mm512_cvt_roundpd_ph(A, R)                                            \
+  ((__m128h)__builtin_ia32_vcvtpd2ph512_mask(                                  \
+      (__v8df)(A), (__v8hf)_mm_undefined_ph(), (__mmask8)(-1), (int)(R)))
+
+#define _mm512_mask_cvt_roundpd_ph(W, U, A, R)                                 \
+  ((__m128h)__builtin_ia32_vcvtpd2ph512_mask((__v8df)(A), (__v8hf)(W),         \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundpd_ph(U, A, R)                                   \
+  ((__m128h)__builtin_ia32_vcvtpd2ph512_mask(                                  \
+      (__v8df)(A), (__v8hf)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS512 _mm512_cvtpd_ph(__m512d __A) {
+  return (__m128h)__builtin_ia32_vcvtpd2ph512_mask(
+      (__v8df)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtpd_ph(__m128h __W, __mmask8 __U, __m512d __A) {
+  return (__m128h)__builtin_ia32_vcvtpd2ph512_mask(
+      (__v8df)__A, (__v8hf)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtpd_ph(__mmask8 __U, __m512d __A) {
+  return (__m128h)__builtin_ia32_vcvtpd2ph512_mask(
+      (__v8df)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundph_pd(A, R)                                            \
+  ((__m512d)__builtin_ia32_vcvtph2pd512_mask(                                  \
+      (__v8hf)(A), (__v8df)_mm512_undefined_pd(), (__mmask8)(-1), (int)(R)))
+
+#define _mm512_mask_cvt_roundph_pd(W, U, A, R)                                 \
+  ((__m512d)__builtin_ia32_vcvtph2pd512_mask((__v8hf)(A), (__v8df)(W),         \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundph_pd(U, A, R)                                   \
+  ((__m512d)__builtin_ia32_vcvtph2pd512_mask(                                  \
+      (__v8hf)(A), (__v8df)_mm512_setzero_pd(), (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512 _mm512_cvtph_pd(__m128h __A) {
+  return (__m512d)__builtin_ia32_vcvtph2pd512_mask(
+      (__v8hf)__A, (__v8df)_mm512_setzero_pd(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtph_pd(__m512d __W, __mmask8 __U, __m128h __A) {
+  return (__m512d)__builtin_ia32_vcvtph2pd512_mask(
+      (__v8hf)__A, (__v8df)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512d __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtph_pd(__mmask8 __U, __m128h __A) {
+  return (__m512d)__builtin_ia32_vcvtph2pd512_mask(
+      (__v8hf)__A, (__v8df)_mm512_setzero_pd(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_cvt_roundsh_ss(A, B, R)                                            \
+  ((__m128)__builtin_ia32_vcvtsh2ss_round_mask((__v4sf)(A), (__v8hf)(B),       \
+                                               (__v4sf)_mm_undefined_ps(),     \
+                                               (__mmask8)(-1), (int)(R)))
+
+#define _mm_mask_cvt_roundsh_ss(W, U, A, B, R)                                 \
+  ((__m128)__builtin_ia32_vcvtsh2ss_round_mask(                                \
+      (__v4sf)(A), (__v8hf)(B), (__v4sf)(W), (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_cvt_roundsh_ss(U, A, B, R)                                   \
+  ((__m128)__builtin_ia32_vcvtsh2ss_round_mask((__v4sf)(A), (__v8hf)(B),       \
+                                               (__v4sf)_mm_setzero_ps(),       \
+                                               (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_cvtsh_ss(__m128 __A,
+                                                            __m128h __B) {
+  return (__m128)__builtin_ia32_vcvtsh2ss_round_mask(
+      (__v4sf)__A, (__v8hf)__B, (__v4sf)_mm_undefined_ps(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_mask_cvtsh_ss(__m128 __W,
+                                                                 __mmask8 __U,
+                                                                 __m128 __A,
+                                                                 __m128h __B) {
+  return (__m128)__builtin_ia32_vcvtsh2ss_round_mask((__v4sf)__A, (__v8hf)__B,
+                                                     (__v4sf)__W, (__mmask8)__U,
+                                                     _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_maskz_cvtsh_ss(__mmask8 __U,
+                                                                  __m128 __A,
+                                                                  __m128h __B) {
+  return (__m128)__builtin_ia32_vcvtsh2ss_round_mask(
+      (__v4sf)__A, (__v8hf)__B, (__v4sf)_mm_setzero_ps(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_cvt_roundss_sh(A, B, R)                                            \
+  ((__m128h)__builtin_ia32_vcvtss2sh_round_mask((__v8hf)(A), (__v4sf)(B),      \
+                                                (__v8hf)_mm_undefined_ph(),    \
+                                                (__mmask8)(-1), (int)(R)))
+
+#define _mm_mask_cvt_roundss_sh(W, U, A, B, R)                                 \
+  ((__m128h)__builtin_ia32_vcvtss2sh_round_mask(                               \
+      (__v8hf)(A), (__v4sf)(B), (__v8hf)(W), (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_cvt_roundss_sh(U, A, B, R)                                   \
+  ((__m128h)__builtin_ia32_vcvtss2sh_round_mask((__v8hf)(A), (__v4sf)(B),      \
+                                                (__v8hf)_mm_setzero_ph(),      \
+                                                (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtss_sh(__m128h __A,
+                                                             __m128 __B) {
+  return (__m128h)__builtin_ia32_vcvtss2sh_round_mask(
+      (__v8hf)__A, (__v4sf)__B, (__v8hf)_mm_undefined_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_cvtss_sh(__m128h __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A,
+                                                                  __m128 __B) {
+  return (__m128h)__builtin_ia32_vcvtss2sh_round_mask(
+      (__v8hf)__A, (__v4sf)__B, (__v8hf)__W, (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_cvtss_sh(__mmask8 __U,
+                                                                   __m128h __A,
+                                                                   __m128 __B) {
+  return (__m128h)__builtin_ia32_vcvtss2sh_round_mask(
+      (__v8hf)__A, (__v4sf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_cvt_roundsd_sh(A, B, R)                                            \
+  ((__m128h)__builtin_ia32_vcvtsd2sh_round_mask((__v8hf)(A), (__v2df)(B),      \
+                                                (__v8hf)_mm_undefined_ph(),    \
+                                                (__mmask8)(-1), (int)(R)))
+
+#define _mm_mask_cvt_roundsd_sh(W, U, A, B, R)                                 \
+  ((__m128h)__builtin_ia32_vcvtsd2sh_round_mask(                               \
+      (__v8hf)(A), (__v2df)(B), (__v8hf)(W), (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_cvt_roundsd_sh(U, A, B, R)                                   \
+  ((__m128h)__builtin_ia32_vcvtsd2sh_round_mask((__v8hf)(A), (__v2df)(B),      \
+                                                (__v8hf)_mm_setzero_ph(),      \
+                                                (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtsd_sh(__m128h __A,
+                                                             __m128d __B) {
+  return (__m128h)__builtin_ia32_vcvtsd2sh_round_mask(
+      (__v8hf)__A, (__v2df)__B, (__v8hf)_mm_undefined_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_cvtsd_sh(__m128h __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A,
+                                                                  __m128d __B) {
+  return (__m128h)__builtin_ia32_vcvtsd2sh_round_mask(
+      (__v8hf)__A, (__v2df)__B, (__v8hf)__W, (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtsd_sh(__mmask8 __U, __m128h __A, __m128d __B) {
+  return (__m128h)__builtin_ia32_vcvtsd2sh_round_mask(
+      (__v8hf)__A, (__v2df)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_cvt_roundsh_sd(A, B, R)                                            \
+  ((__m128d)__builtin_ia32_vcvtsh2sd_round_mask((__v2df)(A), (__v8hf)(B),      \
+                                                (__v2df)_mm_undefined_pd(),    \
+                                                (__mmask8)(-1), (int)(R)))
+
+#define _mm_mask_cvt_roundsh_sd(W, U, A, B, R)                                 \
+  ((__m128d)__builtin_ia32_vcvtsh2sd_round_mask(                               \
+      (__v2df)(A), (__v8hf)(B), (__v2df)(W), (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_cvt_roundsh_sd(U, A, B, R)                                   \
+  ((__m128d)__builtin_ia32_vcvtsh2sd_round_mask((__v2df)(A), (__v8hf)(B),      \
+                                                (__v2df)_mm_setzero_pd(),      \
+                                                (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_cvtsh_sd(__m128d __A,
+                                                             __m128h __B) {
+  return (__m128d)__builtin_ia32_vcvtsh2sd_round_mask(
+      (__v2df)__A, (__v8hf)__B, (__v2df)_mm_undefined_pd(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_mask_cvtsh_sd(__m128d __W,
+                                                                  __mmask8 __U,
+                                                                  __m128d __A,
+                                                                  __m128h __B) {
+  return (__m128d)__builtin_ia32_vcvtsh2sd_round_mask(
+      (__v2df)__A, (__v8hf)__B, (__v2df)__W, (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtsh_sd(__mmask8 __U, __m128d __A, __m128h __B) {
+  return (__m128d)__builtin_ia32_vcvtsh2sd_round_mask(
+      (__v2df)__A, (__v8hf)__B, (__v2df)_mm_setzero_pd(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundph_epi16(A, R)                                         \
+  ((__m512i)__builtin_ia32_vcvtph2w512_mask((__v32hf)(A),                      \
+                                            (__v32hi)_mm512_undefined_epi32(), \
+                                            (__mmask32)(-1), (int)(R)))
+
+#define _mm512_mask_cvt_roundph_epi16(W, U, A, R)                              \
+  ((__m512i)__builtin_ia32_vcvtph2w512_mask((__v32hf)(A), (__v32hi)(W),        \
+                                            (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundph_epi16(U, A, R)                                \
+  ((__m512i)__builtin_ia32_vcvtph2w512_mask((__v32hf)(A),                      \
+                                            (__v32hi)_mm512_setzero_epi32(),   \
+                                            (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtph_epi16(__m512h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2w512_mask(
+      (__v32hf)__A, (__v32hi)_mm512_setzero_epi32(), (__mmask32)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtph_epi16(__m512i __W, __mmask32 __U, __m512h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2w512_mask(
+      (__v32hf)__A, (__v32hi)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtph_epi16(__mmask32 __U, __m512h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2w512_mask(
+      (__v32hf)__A, (__v32hi)_mm512_setzero_epi32(), (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundph_epi16(A, R)                                        \
+  ((__m512i)__builtin_ia32_vcvttph2w512_mask(                                  \
+      (__v32hf)(A), (__v32hi)_mm512_undefined_epi32(), (__mmask32)(-1),        \
+      (int)(R)))
+
+#define _mm512_mask_cvtt_roundph_epi16(W, U, A, R)                             \
+  ((__m512i)__builtin_ia32_vcvttph2w512_mask((__v32hf)(A), (__v32hi)(W),       \
+                                             (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundph_epi16(U, A, R)                               \
+  ((__m512i)__builtin_ia32_vcvttph2w512_mask((__v32hf)(A),                     \
+                                             (__v32hi)_mm512_setzero_epi32(),  \
+                                             (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttph_epi16(__m512h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2w512_mask(
+      (__v32hf)__A, (__v32hi)_mm512_setzero_epi32(), (__mmask32)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttph_epi16(__m512i __W, __mmask32 __U, __m512h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2w512_mask(
+      (__v32hf)__A, (__v32hi)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttph_epi16(__mmask32 __U, __m512h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2w512_mask(
+      (__v32hf)__A, (__v32hi)_mm512_setzero_epi32(), (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundepi16_ph(A, R)                                         \
+  ((__m512h)__builtin_ia32_vcvtw2ph512_mask((__v32hi)(A),                      \
+                                            (__v32hf)_mm512_undefined_ph(),    \
+                                            (__mmask32)(-1), (int)(R)))
+
+#define _mm512_mask_cvt_roundepi16_ph(W, U, A, R)                              \
+  ((__m512h)__builtin_ia32_vcvtw2ph512_mask((__v32hi)(A), (__v32hf)(W),        \
+                                            (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundepi16_ph(U, A, R)                                \
+  ((__m512h)__builtin_ia32_vcvtw2ph512_mask(                                   \
+      (__v32hi)(A), (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_cvtepi16_ph(__m512i __A) {
+  return (__m512h)__builtin_ia32_vcvtw2ph512_mask(
+      (__v32hi)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi16_ph(__m512h __W, __mmask32 __U, __m512i __A) {
+  return (__m512h)__builtin_ia32_vcvtw2ph512_mask(
+      (__v32hi)__A, (__v32hf)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi16_ph(__mmask32 __U, __m512i __A) {
+  return (__m512h)__builtin_ia32_vcvtw2ph512_mask(
+      (__v32hi)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundph_epu16(A, R)                                         \
+  ((__m512i)__builtin_ia32_vcvtph2uw512_mask(                                  \
+      (__v32hf)(A), (__v32hu)_mm512_undefined_epi32(), (__mmask32)(-1),        \
+      (int)(R)))
+
+#define _mm512_mask_cvt_roundph_epu16(W, U, A, R)                              \
+  ((__m512i)__builtin_ia32_vcvtph2uw512_mask((__v32hf)(A), (__v32hu)(W),       \
+                                             (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundph_epu16(U, A, R)                                \
+  ((__m512i)__builtin_ia32_vcvtph2uw512_mask((__v32hf)(A),                     \
+                                             (__v32hu)_mm512_setzero_epi32(),  \
+                                             (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtph_epu16(__m512h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2uw512_mask(
+      (__v32hf)__A, (__v32hu)_mm512_setzero_epi32(), (__mmask32)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtph_epu16(__m512i __W, __mmask32 __U, __m512h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2uw512_mask(
+      (__v32hf)__A, (__v32hu)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtph_epu16(__mmask32 __U, __m512h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2uw512_mask(
+      (__v32hf)__A, (__v32hu)_mm512_setzero_epi32(), (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundph_epu16(A, R)                                        \
+  ((__m512i)__builtin_ia32_vcvttph2uw512_mask(                                 \
+      (__v32hf)(A), (__v32hu)_mm512_undefined_epi32(), (__mmask32)(-1),        \
+      (int)(R)))
+
+#define _mm512_mask_cvtt_roundph_epu16(W, U, A, R)                             \
+  ((__m512i)__builtin_ia32_vcvttph2uw512_mask((__v32hf)(A), (__v32hu)(W),      \
+                                              (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundph_epu16(U, A, R)                               \
+  ((__m512i)__builtin_ia32_vcvttph2uw512_mask((__v32hf)(A),                    \
+                                              (__v32hu)_mm512_setzero_epi32(), \
+                                              (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttph_epu16(__m512h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2uw512_mask(
+      (__v32hf)__A, (__v32hu)_mm512_setzero_epi32(), (__mmask32)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttph_epu16(__m512i __W, __mmask32 __U, __m512h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2uw512_mask(
+      (__v32hf)__A, (__v32hu)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttph_epu16(__mmask32 __U, __m512h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2uw512_mask(
+      (__v32hf)__A, (__v32hu)_mm512_setzero_epi32(), (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundepu16_ph(A, R)                                         \
+  ((__m512h)__builtin_ia32_vcvtuw2ph512_mask((__v32hu)(A),                     \
+                                             (__v32hf)_mm512_undefined_ph(),   \
+                                             (__mmask32)(-1), (int)(R)))
+
+#define _mm512_mask_cvt_roundepu16_ph(W, U, A, R)                              \
+  ((__m512h)__builtin_ia32_vcvtuw2ph512_mask((__v32hu)(A), (__v32hf)(W),       \
+                                             (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundepu16_ph(U, A, R)                                \
+  ((__m512h)__builtin_ia32_vcvtuw2ph512_mask(                                  \
+      (__v32hu)(A), (__v32hf)_mm512_setzero_ph(), (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_cvtepu16_ph(__m512i __A) {
+  return (__m512h)__builtin_ia32_vcvtuw2ph512_mask(
+      (__v32hu)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu16_ph(__m512h __W, __mmask32 __U, __m512i __A) {
+  return (__m512h)__builtin_ia32_vcvtuw2ph512_mask(
+      (__v32hu)__A, (__v32hf)__W, (__mmask32)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu16_ph(__mmask32 __U, __m512i __A) {
+  return (__m512h)__builtin_ia32_vcvtuw2ph512_mask(
+      (__v32hu)__A, (__v32hf)_mm512_setzero_ph(), (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundph_epi32(A, R)                                         \
+  ((__m512i)__builtin_ia32_vcvtph2dq512_mask(                                  \
+      (__v16hf)(A), (__v16si)_mm512_undefined_epi32(), (__mmask16)(-1),        \
+      (int)(R)))
+
+#define _mm512_mask_cvt_roundph_epi32(W, U, A, R)                              \
+  ((__m512i)__builtin_ia32_vcvtph2dq512_mask((__v16hf)(A), (__v16si)(W),       \
+                                             (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundph_epi32(U, A, R)                                \
+  ((__m512i)__builtin_ia32_vcvtph2dq512_mask((__v16hf)(A),                     \
+                                             (__v16si)_mm512_setzero_epi32(),  \
+                                             (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtph_epi32(__m256h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2dq512_mask(
+      (__v16hf)__A, (__v16si)_mm512_setzero_epi32(), (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtph_epi32(__m512i __W, __mmask16 __U, __m256h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2dq512_mask(
+      (__v16hf)__A, (__v16si)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtph_epi32(__mmask16 __U, __m256h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2dq512_mask(
+      (__v16hf)__A, (__v16si)_mm512_setzero_epi32(), (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundph_epu32(A, R)                                         \
+  ((__m512i)__builtin_ia32_vcvtph2udq512_mask(                                 \
+      (__v16hf)(A), (__v16su)_mm512_undefined_epi32(), (__mmask16)(-1),        \
+      (int)(R)))
+
+#define _mm512_mask_cvt_roundph_epu32(W, U, A, R)                              \
+  ((__m512i)__builtin_ia32_vcvtph2udq512_mask((__v16hf)(A), (__v16su)(W),      \
+                                              (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundph_epu32(U, A, R)                                \
+  ((__m512i)__builtin_ia32_vcvtph2udq512_mask((__v16hf)(A),                    \
+                                              (__v16su)_mm512_setzero_epi32(), \
+                                              (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtph_epu32(__m256h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2udq512_mask(
+      (__v16hf)__A, (__v16su)_mm512_setzero_epi32(), (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtph_epu32(__m512i __W, __mmask16 __U, __m256h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2udq512_mask(
+      (__v16hf)__A, (__v16su)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtph_epu32(__mmask16 __U, __m256h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2udq512_mask(
+      (__v16hf)__A, (__v16su)_mm512_setzero_epi32(), (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundepi32_ph(A, R)                                         \
+  ((__m256h)__builtin_ia32_vcvtdq2ph512_mask((__v16si)(A),                     \
+                                             (__v16hf)_mm256_undefined_ph(),   \
+                                             (__mmask16)(-1), (int)(R)))
+
+#define _mm512_mask_cvt_roundepi32_ph(W, U, A, R)                              \
+  ((__m256h)__builtin_ia32_vcvtdq2ph512_mask((__v16si)(A), (__v16hf)(W),       \
+                                             (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundepi32_ph(U, A, R)                                \
+  ((__m256h)__builtin_ia32_vcvtdq2ph512_mask(                                  \
+      (__v16si)(A), (__v16hf)_mm256_setzero_ph(), (__mmask16)(U), (int)(R)))
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS512
+_mm512_cvtepi32_ph(__m512i __A) {
+  return (__m256h)__builtin_ia32_vcvtdq2ph512_mask(
+      (__v16si)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi32_ph(__m256h __W, __mmask16 __U, __m512i __A) {
+  return (__m256h)__builtin_ia32_vcvtdq2ph512_mask(
+      (__v16si)__A, (__v16hf)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi32_ph(__mmask16 __U, __m512i __A) {
+  return (__m256h)__builtin_ia32_vcvtdq2ph512_mask(
+      (__v16si)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundepu32_ph(A, R)                                         \
+  ((__m256h)__builtin_ia32_vcvtudq2ph512_mask((__v16su)(A),                    \
+                                              (__v16hf)_mm256_undefined_ph(),  \
+                                              (__mmask16)(-1), (int)(R)))
+
+#define _mm512_mask_cvt_roundepu32_ph(W, U, A, R)                              \
+  ((__m256h)__builtin_ia32_vcvtudq2ph512_mask((__v16su)(A), (__v16hf)(W),      \
+                                              (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundepu32_ph(U, A, R)                                \
+  ((__m256h)__builtin_ia32_vcvtudq2ph512_mask(                                 \
+      (__v16su)(A), (__v16hf)_mm256_setzero_ph(), (__mmask16)(U), (int)(R)))
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS512
+_mm512_cvtepu32_ph(__m512i __A) {
+  return (__m256h)__builtin_ia32_vcvtudq2ph512_mask(
+      (__v16su)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu32_ph(__m256h __W, __mmask16 __U, __m512i __A) {
+  return (__m256h)__builtin_ia32_vcvtudq2ph512_mask(
+      (__v16su)__A, (__v16hf)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu32_ph(__mmask16 __U, __m512i __A) {
+  return (__m256h)__builtin_ia32_vcvtudq2ph512_mask(
+      (__v16su)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundph_epi32(A, R)                                        \
+  ((__m512i)__builtin_ia32_vcvttph2dq512_mask(                                 \
+      (__v16hf)(A), (__v16si)_mm512_undefined_epi32(), (__mmask16)(-1),        \
+      (int)(R)))
+
+#define _mm512_mask_cvtt_roundph_epi32(W, U, A, R)                             \
+  ((__m512i)__builtin_ia32_vcvttph2dq512_mask((__v16hf)(A), (__v16si)(W),      \
+                                              (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundph_epi32(U, A, R)                               \
+  ((__m512i)__builtin_ia32_vcvttph2dq512_mask((__v16hf)(A),                    \
+                                              (__v16si)_mm512_setzero_epi32(), \
+                                              (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttph_epi32(__m256h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2dq512_mask(
+      (__v16hf)__A, (__v16si)_mm512_setzero_epi32(), (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttph_epi32(__m512i __W, __mmask16 __U, __m256h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2dq512_mask(
+      (__v16hf)__A, (__v16si)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttph_epi32(__mmask16 __U, __m256h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2dq512_mask(
+      (__v16hf)__A, (__v16si)_mm512_setzero_epi32(), (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundph_epu32(A, R)                                        \
+  ((__m512i)__builtin_ia32_vcvttph2udq512_mask(                                \
+      (__v16hf)(A), (__v16su)_mm512_undefined_epi32(), (__mmask16)(-1),        \
+      (int)(R)))
+
+#define _mm512_mask_cvtt_roundph_epu32(W, U, A, R)                             \
+  ((__m512i)__builtin_ia32_vcvttph2udq512_mask((__v16hf)(A), (__v16su)(W),     \
+                                               (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundph_epu32(U, A, R)                               \
+  ((__m512i)__builtin_ia32_vcvttph2udq512_mask(                                \
+      (__v16hf)(A), (__v16su)_mm512_setzero_epi32(), (__mmask16)(U),           \
+      (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttph_epu32(__m256h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2udq512_mask(
+      (__v16hf)__A, (__v16su)_mm512_setzero_epi32(), (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttph_epu32(__m512i __W, __mmask16 __U, __m256h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2udq512_mask(
+      (__v16hf)__A, (__v16su)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttph_epu32(__mmask16 __U, __m256h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2udq512_mask(
+      (__v16hf)__A, (__v16su)_mm512_setzero_epi32(), (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundepi64_ph(A, R)                                         \
+  ((__m128h)__builtin_ia32_vcvtqq2ph512_mask(                                  \
+      (__v8di)(A), (__v8hf)_mm_undefined_ph(), (__mmask8)(-1), (int)(R)))
+
+#define _mm512_mask_cvt_roundepi64_ph(W, U, A, R)                              \
+  ((__m128h)__builtin_ia32_vcvtqq2ph512_mask((__v8di)(A), (__v8hf)(W),         \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundepi64_ph(U, A, R)                                \
+  ((__m128h)__builtin_ia32_vcvtqq2ph512_mask(                                  \
+      (__v8di)(A), (__v8hf)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS512
+_mm512_cvtepi64_ph(__m512i __A) {
+  return (__m128h)__builtin_ia32_vcvtqq2ph512_mask(
+      (__v8di)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepi64_ph(__m128h __W, __mmask8 __U, __m512i __A) {
+  return (__m128h)__builtin_ia32_vcvtqq2ph512_mask(
+      (__v8di)__A, (__v8hf)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepi64_ph(__mmask8 __U, __m512i __A) {
+  return (__m128h)__builtin_ia32_vcvtqq2ph512_mask(
+      (__v8di)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundph_epi64(A, R)                                         \
+  ((__m512i)__builtin_ia32_vcvtph2qq512_mask((__v8hf)(A),                      \
+                                             (__v8di)_mm512_undefined_epi32(), \
+                                             (__mmask8)(-1), (int)(R)))
+
+#define _mm512_mask_cvt_roundph_epi64(W, U, A, R)                              \
+  ((__m512i)__builtin_ia32_vcvtph2qq512_mask((__v8hf)(A), (__v8di)(W),         \
+                                             (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundph_epi64(U, A, R)                                \
+  ((__m512i)__builtin_ia32_vcvtph2qq512_mask(                                  \
+      (__v8hf)(A), (__v8di)_mm512_setzero_epi32(), (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtph_epi64(__m128h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2qq512_mask(
+      (__v8hf)__A, (__v8di)_mm512_setzero_epi32(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtph_epi64(__m512i __W, __mmask8 __U, __m128h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2qq512_mask(
+      (__v8hf)__A, (__v8di)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtph_epi64(__mmask8 __U, __m128h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2qq512_mask(
+      (__v8hf)__A, (__v8di)_mm512_setzero_epi32(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundepu64_ph(A, R)                                         \
+  ((__m128h)__builtin_ia32_vcvtuqq2ph512_mask(                                 \
+      (__v8du)(A), (__v8hf)_mm_undefined_ph(), (__mmask8)(-1), (int)(R)))
+
+#define _mm512_mask_cvt_roundepu64_ph(W, U, A, R)                              \
+  ((__m128h)__builtin_ia32_vcvtuqq2ph512_mask((__v8du)(A), (__v8hf)(W),        \
+                                              (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundepu64_ph(U, A, R)                                \
+  ((__m128h)__builtin_ia32_vcvtuqq2ph512_mask(                                 \
+      (__v8du)(A), (__v8hf)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS512
+_mm512_cvtepu64_ph(__m512i __A) {
+  return (__m128h)__builtin_ia32_vcvtuqq2ph512_mask(
+      (__v8du)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtepu64_ph(__m128h __W, __mmask8 __U, __m512i __A) {
+  return (__m128h)__builtin_ia32_vcvtuqq2ph512_mask(
+      (__v8du)__A, (__v8hf)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtepu64_ph(__mmask8 __U, __m512i __A) {
+  return (__m128h)__builtin_ia32_vcvtuqq2ph512_mask(
+      (__v8du)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvt_roundph_epu64(A, R)                                         \
+  ((__m512i)__builtin_ia32_vcvtph2uqq512_mask(                                 \
+      (__v8hf)(A), (__v8du)_mm512_undefined_epi32(), (__mmask8)(-1),           \
+      (int)(R)))
+
+#define _mm512_mask_cvt_roundph_epu64(W, U, A, R)                              \
+  ((__m512i)__builtin_ia32_vcvtph2uqq512_mask((__v8hf)(A), (__v8du)(W),        \
+                                              (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvt_roundph_epu64(U, A, R)                                \
+  ((__m512i)__builtin_ia32_vcvtph2uqq512_mask(                                 \
+      (__v8hf)(A), (__v8du)_mm512_setzero_epi32(), (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvtph_epu64(__m128h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2uqq512_mask(
+      (__v8hf)__A, (__v8du)_mm512_setzero_epi32(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtph_epu64(__m512i __W, __mmask8 __U, __m128h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2uqq512_mask(
+      (__v8hf)__A, (__v8du)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtph_epu64(__mmask8 __U, __m128h __A) {
+  return (__m512i)__builtin_ia32_vcvtph2uqq512_mask(
+      (__v8hf)__A, (__v8du)_mm512_setzero_epi32(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundph_epi64(A, R)                                        \
+  ((__m512i)__builtin_ia32_vcvttph2qq512_mask(                                 \
+      (__v8hf)(A), (__v8di)_mm512_undefined_epi32(), (__mmask8)(-1),           \
+      (int)(R)))
+
+#define _mm512_mask_cvtt_roundph_epi64(W, U, A, R)                             \
+  ((__m512i)__builtin_ia32_vcvttph2qq512_mask((__v8hf)(A), (__v8di)(W),        \
+                                              (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundph_epi64(U, A, R)                               \
+  ((__m512i)__builtin_ia32_vcvttph2qq512_mask(                                 \
+      (__v8hf)(A), (__v8di)_mm512_setzero_epi32(), (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttph_epi64(__m128h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2qq512_mask(
+      (__v8hf)__A, (__v8di)_mm512_setzero_epi32(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttph_epi64(__m512i __W, __mmask8 __U, __m128h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2qq512_mask(
+      (__v8hf)__A, (__v8di)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttph_epi64(__mmask8 __U, __m128h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2qq512_mask(
+      (__v8hf)__A, (__v8di)_mm512_setzero_epi32(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtt_roundph_epu64(A, R)                                        \
+  ((__m512i)__builtin_ia32_vcvttph2uqq512_mask(                                \
+      (__v8hf)(A), (__v8du)_mm512_undefined_epi32(), (__mmask8)(-1),           \
+      (int)(R)))
+
+#define _mm512_mask_cvtt_roundph_epu64(W, U, A, R)                             \
+  ((__m512i)__builtin_ia32_vcvttph2uqq512_mask((__v8hf)(A), (__v8du)(W),       \
+                                               (__mmask8)(U), (int)(R)))
+
+#define _mm512_maskz_cvtt_roundph_epu64(U, A, R)                               \
+  ((__m512i)__builtin_ia32_vcvttph2uqq512_mask(                                \
+      (__v8hf)(A), (__v8du)_mm512_setzero_epi32(), (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_cvttph_epu64(__m128h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2uqq512_mask(
+      (__v8hf)__A, (__v8du)_mm512_setzero_epi32(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_mask_cvttph_epu64(__m512i __W, __mmask8 __U, __m128h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2uqq512_mask(
+      (__v8hf)__A, (__v8du)__W, (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvttph_epu64(__mmask8 __U, __m128h __A) {
+  return (__m512i)__builtin_ia32_vcvttph2uqq512_mask(
+      (__v8hf)__A, (__v8du)_mm512_setzero_epi32(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_cvt_roundsh_i32(A, R)                                              \
+  ((int)__builtin_ia32_vcvtsh2si32((__v8hf)(A), (int)(R)))
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_cvtsh_i32(__m128h __A) {
+  return (int)__builtin_ia32_vcvtsh2si32((__v8hf)__A, _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_cvt_roundsh_u32(A, R)                                              \
+  ((unsigned int)__builtin_ia32_vcvtsh2usi32((__v8hf)(A), (int)(R)))
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS128
+_mm_cvtsh_u32(__m128h __A) {
+  return (unsigned int)__builtin_ia32_vcvtsh2usi32((__v8hf)__A,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+#ifdef __x86_64__
+#define _mm_cvt_roundsh_i64(A, R)                                              \
+  ((long long)__builtin_ia32_vcvtsh2si64((__v8hf)(A), (int)(R)))
+
+static __inline__ long long __DEFAULT_FN_ATTRS128 _mm_cvtsh_i64(__m128h __A) {
+  return (long long)__builtin_ia32_vcvtsh2si64((__v8hf)__A,
+                                               _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_cvt_roundsh_u64(A, R)                                              \
+  ((unsigned long long)__builtin_ia32_vcvtsh2usi64((__v8hf)(A), (int)(R)))
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS128
+_mm_cvtsh_u64(__m128h __A) {
+  return (unsigned long long)__builtin_ia32_vcvtsh2usi64(
+      (__v8hf)__A, _MM_FROUND_CUR_DIRECTION);
+}
+#endif // __x86_64__
+
+#define _mm_cvt_roundu32_sh(A, B, R)                                           \
+  ((__m128h)__builtin_ia32_vcvtusi2sh((__v8hf)(A), (unsigned int)(B), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_cvtu32_sh(__m128h __A, unsigned int __B) {
+  __A[0] = __B;
+  return __A;
+}
+
+#ifdef __x86_64__
+#define _mm_cvt_roundu64_sh(A, B, R)                                           \
+  ((__m128h)__builtin_ia32_vcvtusi642sh((__v8hf)(A), (unsigned long long)(B),  \
+                                        (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_cvtu64_sh(__m128h __A, unsigned long long __B) {
+  __A[0] = __B;
+  return __A;
+}
+#endif
+
+#define _mm_cvt_roundi32_sh(A, B, R)                                           \
+  ((__m128h)__builtin_ia32_vcvtsi2sh((__v8hf)(A), (int)(B), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvti32_sh(__m128h __A,
+                                                              int __B) {
+  __A[0] = __B;
+  return __A;
+}
+
+#ifdef __x86_64__
+#define _mm_cvt_roundi64_sh(A, B, R)                                           \
+  ((__m128h)__builtin_ia32_vcvtsi642sh((__v8hf)(A), (long long)(B), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvti64_sh(__m128h __A,
+                                                              long long __B) {
+  __A[0] = __B;
+  return __A;
+}
+#endif
+
+#define _mm_cvtt_roundsh_i32(A, R)                                             \
+  ((int)__builtin_ia32_vcvttsh2si32((__v8hf)(A), (int)(R)))
+
+static __inline__ int __DEFAULT_FN_ATTRS128 _mm_cvttsh_i32(__m128h __A) {
+  return (int)__builtin_ia32_vcvttsh2si32((__v8hf)__A,
+                                          _MM_FROUND_CUR_DIRECTION);
+}
+
+#ifdef __x86_64__
+#define _mm_cvtt_roundsh_i64(A, R)                                             \
+  ((long long)__builtin_ia32_vcvttsh2si64((__v8hf)(A), (int)(R)))
+
+static __inline__ long long __DEFAULT_FN_ATTRS128 _mm_cvttsh_i64(__m128h __A) {
+  return (long long)__builtin_ia32_vcvttsh2si64((__v8hf)__A,
+                                                _MM_FROUND_CUR_DIRECTION);
+}
+#endif
+
+#define _mm_cvtt_roundsh_u32(A, R)                                             \
+  ((unsigned int)__builtin_ia32_vcvttsh2usi32((__v8hf)(A), (int)(R)))
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS128
+_mm_cvttsh_u32(__m128h __A) {
+  return (unsigned int)__builtin_ia32_vcvttsh2usi32((__v8hf)__A,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+#ifdef __x86_64__
+#define _mm_cvtt_roundsh_u64(A, R)                                             \
+  ((unsigned long long)__builtin_ia32_vcvttsh2usi64((__v8hf)(A), (int)(R)))
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS128
+_mm_cvttsh_u64(__m128h __A) {
+  return (unsigned long long)__builtin_ia32_vcvttsh2usi64(
+      (__v8hf)__A, _MM_FROUND_CUR_DIRECTION);
+}
+#endif
+
+#define _mm512_cvtx_roundph_ps(A, R)                                           \
+  ((__m512)__builtin_ia32_vcvtph2psx512_mask((__v16hf)(A),                     \
+                                             (__v16sf)_mm512_undefined_ps(),   \
+                                             (__mmask16)(-1), (int)(R)))
+
+#define _mm512_mask_cvtx_roundph_ps(W, U, A, R)                                \
+  ((__m512)__builtin_ia32_vcvtph2psx512_mask((__v16hf)(A), (__v16sf)(W),       \
+                                             (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvtx_roundph_ps(U, A, R)                                  \
+  ((__m512)__builtin_ia32_vcvtph2psx512_mask(                                  \
+      (__v16hf)(A), (__v16sf)_mm512_setzero_ps(), (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512 _mm512_cvtxph_ps(__m256h __A) {
+  return (__m512)__builtin_ia32_vcvtph2psx512_mask(
+      (__v16hf)__A, (__v16sf)_mm512_setzero_ps(), (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtxph_ps(__m512 __W, __mmask16 __U, __m256h __A) {
+  return (__m512)__builtin_ia32_vcvtph2psx512_mask(
+      (__v16hf)__A, (__v16sf)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512 __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtxph_ps(__mmask16 __U, __m256h __A) {
+  return (__m512)__builtin_ia32_vcvtph2psx512_mask(
+      (__v16hf)__A, (__v16sf)_mm512_setzero_ps(), (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_cvtx_roundps_ph(A, R)                                           \
+  ((__m256h)__builtin_ia32_vcvtps2phx512_mask((__v16sf)(A),                    \
+                                              (__v16hf)_mm256_undefined_ph(),  \
+                                              (__mmask16)(-1), (int)(R)))
+
+#define _mm512_mask_cvtx_roundps_ph(W, U, A, R)                                \
+  ((__m256h)__builtin_ia32_vcvtps2phx512_mask((__v16sf)(A), (__v16hf)(W),      \
+                                              (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_cvtx_roundps_ph(U, A, R)                                  \
+  ((__m256h)__builtin_ia32_vcvtps2phx512_mask(                                 \
+      (__v16sf)(A), (__v16hf)_mm256_setzero_ph(), (__mmask16)(U), (int)(R)))
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS512 _mm512_cvtxps_ph(__m512 __A) {
+  return (__m256h)__builtin_ia32_vcvtps2phx512_mask(
+      (__v16sf)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS512
+_mm512_mask_cvtxps_ph(__m256h __W, __mmask16 __U, __m512 __A) {
+  return (__m256h)__builtin_ia32_vcvtps2phx512_mask(
+      (__v16sf)__A, (__v16hf)__W, (__mmask16)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS512
+_mm512_maskz_cvtxps_ph(__mmask16 __U, __m512 __A) {
+  return (__m256h)__builtin_ia32_vcvtps2phx512_mask(
+      (__v16sf)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_fmadd_round_ph(A, B, C, R)                                      \
+  ((__m512h)__builtin_ia32_vfmaddph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),     \
+      (__mmask32)-1, (int)(R)))
+
+#define _mm512_mask_fmadd_round_ph(A, U, B, C, R)                              \
+  ((__m512h)__builtin_ia32_vfmaddph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),     \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_mask3_fmadd_round_ph(A, B, C, U, R)                             \
+  ((__m512h)__builtin_ia32_vfmaddph512_mask3(                                  \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),     \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_fmadd_round_ph(U, A, B, C, R)                             \
+  ((__m512h)__builtin_ia32_vfmaddph512_maskz(                                  \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),     \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_fmsub_round_ph(A, B, C, R)                                      \
+  ((__m512h)__builtin_ia32_vfmaddph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C),    \
+      (__mmask32)-1, (int)(R)))
+
+#define _mm512_mask_fmsub_round_ph(A, U, B, C, R)                              \
+  ((__m512h)__builtin_ia32_vfmaddph512_mask(                                   \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C),    \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_fmsub_round_ph(U, A, B, C, R)                             \
+  ((__m512h)__builtin_ia32_vfmaddph512_maskz(                                  \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C),    \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_fnmadd_round_ph(A, B, C, R)                                     \
+  ((__m512h)__builtin_ia32_vfmaddph512_mask(                                   \
+      (__v32hf)(__m512h)(A), -(__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),    \
+      (__mmask32)-1, (int)(R)))
+
+#define _mm512_mask3_fnmadd_round_ph(A, B, C, U, R)                            \
+  ((__m512h)__builtin_ia32_vfmaddph512_mask3(                                  \
+      -(__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),    \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_fnmadd_round_ph(U, A, B, C, R)                            \
+  ((__m512h)__builtin_ia32_vfmaddph512_maskz(                                  \
+      -(__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),    \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_fnmsub_round_ph(A, B, C, R)                                     \
+  ((__m512h)__builtin_ia32_vfmaddph512_mask(                                   \
+      (__v32hf)(__m512h)(A), -(__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C),   \
+      (__mmask32)-1, (int)(R)))
+
+#define _mm512_maskz_fnmsub_round_ph(U, A, B, C, R)                            \
+  ((__m512h)__builtin_ia32_vfmaddph512_maskz(                                  \
+      -(__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C),   \
+      (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fmadd_ph(__m512h __A,
+                                                                __m512h __B,
+                                                                __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, (__v32hf)__B,
+                                                  (__v32hf)__C, (__mmask32)-1,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_fmadd_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, (__v32hf)__B,
+                                                  (__v32hf)__C, (__mmask32)__U,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmadd_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
+  return (__m512h)__builtin_ia32_vfmaddph512_mask3((__v32hf)__A, (__v32hf)__B,
+                                                   (__v32hf)__C, (__mmask32)__U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmadd_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_maskz((__v32hf)__A, (__v32hf)__B,
+                                                   (__v32hf)__C, (__mmask32)__U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fmsub_ph(__m512h __A,
+                                                                __m512h __B,
+                                                                __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, (__v32hf)__B,
+                                                  -(__v32hf)__C, (__mmask32)-1,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_fmsub_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, (__v32hf)__B,
+                                                  -(__v32hf)__C, (__mmask32)__U,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmsub_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_maskz(
+      (__v32hf)__A, (__v32hf)__B, -(__v32hf)__C, (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fnmadd_ph(__m512h __A,
+                                                                 __m512h __B,
+                                                                 __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, -(__v32hf)__B,
+                                                  (__v32hf)__C, (__mmask32)-1,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask3_fnmadd_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
+  return (__m512h)__builtin_ia32_vfmaddph512_mask3(-(__v32hf)__A, (__v32hf)__B,
+                                                   (__v32hf)__C, (__mmask32)__U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_fnmadd_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_maskz(-(__v32hf)__A, (__v32hf)__B,
+                                                   (__v32hf)__C, (__mmask32)__U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fnmsub_ph(__m512h __A,
+                                                                 __m512h __B,
+                                                                 __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, -(__v32hf)__B,
+                                                  -(__v32hf)__C, (__mmask32)-1,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_fnmsub_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_maskz(
+      -(__v32hf)__A, (__v32hf)__B, -(__v32hf)__C, (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_fmaddsub_round_ph(A, B, C, R)                                   \
+  ((__m512h)__builtin_ia32_vfmaddsubph512_mask(                                \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),     \
+      (__mmask32)-1, (int)(R)))
+
+#define _mm512_mask_fmaddsub_round_ph(A, U, B, C, R)                           \
+  ((__m512h)__builtin_ia32_vfmaddsubph512_mask(                                \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),     \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_mask3_fmaddsub_round_ph(A, B, C, U, R)                          \
+  ((__m512h)__builtin_ia32_vfmaddsubph512_mask3(                               \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),     \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_fmaddsub_round_ph(U, A, B, C, R)                          \
+  ((__m512h)__builtin_ia32_vfmaddsubph512_maskz(                               \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),     \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_fmsubadd_round_ph(A, B, C, R)                                   \
+  ((__m512h)__builtin_ia32_vfmaddsubph512_mask(                                \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C),    \
+      (__mmask32)-1, (int)(R)))
+
+#define _mm512_mask_fmsubadd_round_ph(A, U, B, C, R)                           \
+  ((__m512h)__builtin_ia32_vfmaddsubph512_mask(                                \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C),    \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_maskz_fmsubadd_round_ph(U, A, B, C, R)                          \
+  ((__m512h)__builtin_ia32_vfmaddsubph512_maskz(                               \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C),    \
+      (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_fmaddsub_ph(__m512h __A, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddsubph512_mask(
+      (__v32hf)__A, (__v32hf)__B, (__v32hf)__C, (__mmask32)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_fmaddsub_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddsubph512_mask(
+      (__v32hf)__A, (__v32hf)__B, (__v32hf)__C, (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmaddsub_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
+  return (__m512h)__builtin_ia32_vfmaddsubph512_mask3(
+      (__v32hf)__A, (__v32hf)__B, (__v32hf)__C, (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmaddsub_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddsubph512_maskz(
+      (__v32hf)__A, (__v32hf)__B, (__v32hf)__C, (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_fmsubadd_ph(__m512h __A, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddsubph512_mask(
+      (__v32hf)__A, (__v32hf)__B, -(__v32hf)__C, (__mmask32)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_fmsubadd_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddsubph512_mask(
+      (__v32hf)__A, (__v32hf)__B, -(__v32hf)__C, (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmsubadd_ph(__mmask32 __U, __m512h __A, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddsubph512_maskz(
+      (__v32hf)__A, (__v32hf)__B, -(__v32hf)__C, (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask3_fmsub_round_ph(A, B, C, U, R)                             \
+  ((__m512h)__builtin_ia32_vfmsubph512_mask3(                                  \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),     \
+      (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmsub_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
+  return (__m512h)__builtin_ia32_vfmsubph512_mask3((__v32hf)__A, (__v32hf)__B,
+                                                   (__v32hf)__C, (__mmask32)__U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask3_fmsubadd_round_ph(A, B, C, U, R)                          \
+  ((__m512h)__builtin_ia32_vfmsubaddph512_mask3(                               \
+      (__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),     \
+      (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmsubadd_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
+  return (__m512h)__builtin_ia32_vfmsubaddph512_mask3(
+      (__v32hf)__A, (__v32hf)__B, (__v32hf)__C, (__mmask32)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask_fnmadd_round_ph(A, U, B, C, R)                             \
+  ((__m512h)__builtin_ia32_vfmaddph512_mask(                                   \
+      (__v32hf)(__m512h)(A), -(__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),    \
+      (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_fnmadd_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, -(__v32hf)__B,
+                                                  (__v32hf)__C, (__mmask32)__U,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_mask_fnmsub_round_ph(A, U, B, C, R)                             \
+  ((__m512h)__builtin_ia32_vfmaddph512_mask(                                   \
+      (__v32hf)(__m512h)(A), -(__v32hf)(__m512h)(B), -(__v32hf)(__m512h)(C),   \
+      (__mmask32)(U), (int)(R)))
+
+#define _mm512_mask3_fnmsub_round_ph(A, B, C, U, R)                            \
+  ((__m512h)__builtin_ia32_vfmsubph512_mask3(                                  \
+      -(__v32hf)(__m512h)(A), (__v32hf)(__m512h)(B), (__v32hf)(__m512h)(C),    \
+      (__mmask32)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_fnmsub_ph(__m512h __A, __mmask32 __U, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddph512_mask((__v32hf)__A, -(__v32hf)__B,
+                                                  -(__v32hf)__C, (__mmask32)__U,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask3_fnmsub_ph(__m512h __A, __m512h __B, __m512h __C, __mmask32 __U) {
+  return (__m512h)__builtin_ia32_vfmsubph512_mask3(-(__v32hf)__A, (__v32hf)__B,
+                                                   (__v32hf)__C, (__mmask32)__U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmadd_sh(__m128h __W,
+                                                             __m128h __A,
+                                                             __m128h __B) {
+  return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, (__v8hf)__A, (__v8hf)__B,
+                                       (__mmask8)-1, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_fmadd_sh(__m128h __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A,
+                                                                  __m128h __B) {
+  return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, (__v8hf)__A, (__v8hf)__B,
+                                       (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fmadd_round_sh(A, B, C, R)                                         \
+  ((__m128h)__builtin_ia32_vfmaddsh3_mask(                                     \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(C),        \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_fmadd_round_sh(W, U, A, B, R)                                 \
+  ((__m128h)__builtin_ia32_vfmaddsh3_mask(                                     \
+      (__v8hf)(__m128h)(W), (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B),        \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fmadd_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return __builtin_ia32_vfmaddsh3_maskz((__v8hf)__A, (__v8hf)__B, (__v8hf)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fmadd_round_sh(U, A, B, C, R)                                \
+  ((__m128h)__builtin_ia32_vfmaddsh3_maskz(                                    \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), (__v8hf)(__m128h)(C),        \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fmadd_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
+  return __builtin_ia32_vfmaddsh3_mask3((__v8hf)__W, (__v8hf)__X, (__v8hf)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fmadd_round_sh(W, X, Y, U, R)                                \
+  ((__m128h)__builtin_ia32_vfmaddsh3_mask3(                                    \
+      (__v8hf)(__m128h)(W), (__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y),        \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmsub_sh(__m128h __W,
+                                                             __m128h __A,
+                                                             __m128h __B) {
+  return (__m128h)__builtin_ia32_vfmaddsh3_mask((__v8hf)__W, (__v8hf)__A,
+                                                -(__v8hf)__B, (__mmask8)-1,
+                                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_fmsub_sh(__m128h __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A,
+                                                                  __m128h __B) {
+  return (__m128h)__builtin_ia32_vfmaddsh3_mask((__v8hf)__W, (__v8hf)__A,
+                                                -(__v8hf)__B, (__mmask8)__U,
+                                                _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fmsub_round_sh(A, B, C, R)                                         \
+  ((__m128h)__builtin_ia32_vfmaddsh3_mask(                                     \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), -(__v8hf)(__m128h)(C),       \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_fmsub_round_sh(W, U, A, B, R)                                 \
+  ((__m128h)__builtin_ia32_vfmaddsh3_mask(                                     \
+      (__v8hf)(__m128h)(W), (__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B),       \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fmsub_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddsh3_maskz((__v8hf)__A, (__v8hf)__B,
+                                                 -(__v8hf)__C, (__mmask8)__U,
+                                                 _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fmsub_round_sh(U, A, B, C, R)                                \
+  ((__m128h)__builtin_ia32_vfmaddsh3_maskz(                                    \
+      (__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B), -(__v8hf)(__m128h)(C),       \
+      (__mmask8)(U), (int)R))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fmsub_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
+  return __builtin_ia32_vfmsubsh3_mask3((__v8hf)__W, (__v8hf)__X, (__v8hf)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fmsub_round_sh(W, X, Y, U, R)                                \
+  ((__m128h)__builtin_ia32_vfmsubsh3_mask3(                                    \
+      (__v8hf)(__m128h)(W), (__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y),        \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fnmadd_sh(__m128h __W,
+                                                              __m128h __A,
+                                                              __m128h __B) {
+  return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, -(__v8hf)__A, (__v8hf)__B,
+                                       (__mmask8)-1, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fnmadd_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
+  return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, -(__v8hf)__A, (__v8hf)__B,
+                                       (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fnmadd_round_sh(A, B, C, R)                                        \
+  ((__m128h)__builtin_ia32_vfmaddsh3_mask(                                     \
+      (__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B), (__v8hf)(__m128h)(C),       \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_fnmadd_round_sh(W, U, A, B, R)                                \
+  ((__m128h)__builtin_ia32_vfmaddsh3_mask(                                     \
+      (__v8hf)(__m128h)(W), -(__v8hf)(__m128h)(A), (__v8hf)(__m128h)(B),       \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmadd_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return __builtin_ia32_vfmaddsh3_maskz((__v8hf)__A, -(__v8hf)__B, (__v8hf)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fnmadd_round_sh(U, A, B, C, R)                               \
+  ((__m128h)__builtin_ia32_vfmaddsh3_maskz(                                    \
+      (__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B), (__v8hf)(__m128h)(C),       \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmadd_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
+  return __builtin_ia32_vfmaddsh3_mask3((__v8hf)__W, -(__v8hf)__X, (__v8hf)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fnmadd_round_sh(W, X, Y, U, R)                               \
+  ((__m128h)__builtin_ia32_vfmaddsh3_mask3(                                    \
+      (__v8hf)(__m128h)(W), -(__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y),       \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fnmsub_sh(__m128h __W,
+                                                              __m128h __A,
+                                                              __m128h __B) {
+  return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, -(__v8hf)__A, -(__v8hf)__B,
+                                       (__mmask8)-1, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fnmsub_sh(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
+  return __builtin_ia32_vfmaddsh3_mask((__v8hf)__W, -(__v8hf)__A, -(__v8hf)__B,
+                                       (__mmask8)__U, _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fnmsub_round_sh(A, B, C, R)                                        \
+  ((__m128h)__builtin_ia32_vfmaddsh3_mask(                                     \
+      (__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B), -(__v8hf)(__m128h)(C),      \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_fnmsub_round_sh(W, U, A, B, R)                                \
+  ((__m128h)__builtin_ia32_vfmaddsh3_mask(                                     \
+      (__v8hf)(__m128h)(W), -(__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B),      \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmsub_sh(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return __builtin_ia32_vfmaddsh3_maskz((__v8hf)__A, -(__v8hf)__B, -(__v8hf)__C,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_maskz_fnmsub_round_sh(U, A, B, C, R)                               \
+  ((__m128h)__builtin_ia32_vfmaddsh3_maskz(                                    \
+      (__v8hf)(__m128h)(A), -(__v8hf)(__m128h)(B), -(__v8hf)(__m128h)(C),      \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmsub_sh(__m128h __W, __m128h __X, __m128h __Y, __mmask8 __U) {
+  return __builtin_ia32_vfmsubsh3_mask3((__v8hf)__W, -(__v8hf)__X, (__v8hf)__Y,
+                                        (__mmask8)__U,
+                                        _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_mask3_fnmsub_round_sh(W, X, Y, U, R)                               \
+  ((__m128h)__builtin_ia32_vfmsubsh3_mask3(                                    \
+      (__v8hf)(__m128h)(W), -(__v8hf)(__m128h)(X), (__v8hf)(__m128h)(Y),       \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fcmadd_sch(__m128h __A,
+                                                               __m128h __B,
+                                                               __m128h __C) {
+  return (__m128h)__builtin_ia32_vfcmaddcsh_mask((__v4sf)__A, (__v4sf)__B,
+                                                 (__v4sf)__C, (__mmask8)-1,
+                                                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fcmadd_sch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_vfcmaddcsh_round_mask(
+      (__v4sf)__A, (__v4sf)(__B), (__v4sf)(__C), __U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fcmadd_sch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_vfcmaddcsh_maskz((__v4sf)__A, (__v4sf)__B,
+                                                  (__v4sf)__C, (__mmask8)__U,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fcmadd_sch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
+  return (__m128h)__builtin_ia32_vfcmaddcsh_round_mask3(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)__C, __U, _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fcmadd_round_sch(A, B, C, R)                                       \
+  ((__m128h)__builtin_ia32_vfcmaddcsh_mask(                                    \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C),        \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_fcmadd_round_sch(A, U, B, C, R)                               \
+  ((__m128h)__builtin_ia32_vfcmaddcsh_round_mask(                              \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_fcmadd_round_sch(U, A, B, C, R)                              \
+  ((__m128h)__builtin_ia32_vfcmaddcsh_maskz(                                   \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_mask3_fcmadd_round_sch(A, B, C, U, R)                              \
+  ((__m128h)__builtin_ia32_vfcmaddcsh_round_mask3(                             \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C),        \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmadd_sch(__m128h __A,
+                                                              __m128h __B,
+                                                              __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddcsh_mask((__v4sf)__A, (__v4sf)__B,
+                                                (__v4sf)__C, (__mmask8)-1,
+                                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fmadd_sch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddcsh_round_mask(
+      (__v4sf)__A, (__v4sf)(__B), (__v4sf)(__C), __U, _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fmadd_sch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddcsh_maskz((__v4sf)__A, (__v4sf)__B,
+                                                 (__v4sf)__C, (__mmask8)__U,
+                                                 _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fmadd_sch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
+  return (__m128h)__builtin_ia32_vfmaddcsh_round_mask3(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)__C, __U, _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fmadd_round_sch(A, B, C, R)                                        \
+  ((__m128h)__builtin_ia32_vfmaddcsh_mask(                                     \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C),        \
+      (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_fmadd_round_sch(A, U, B, C, R)                                \
+  ((__m128h)__builtin_ia32_vfmaddcsh_round_mask(                               \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_fmadd_round_sch(U, A, B, C, R)                               \
+  ((__m128h)__builtin_ia32_vfmaddcsh_maskz(                                    \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_mask3_fmadd_round_sch(A, B, C, U, R)                               \
+  ((__m128h)__builtin_ia32_vfmaddcsh_round_mask3(                              \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(C),        \
+      (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fcmul_sch(__m128h __A,
+                                                              __m128h __B) {
+  return (__m128h)__builtin_ia32_vfcmulcsh_mask(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_undefined_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fcmul_sch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_vfcmulcsh_mask((__v4sf)__A, (__v4sf)__B,
+                                                (__v4sf)__W, (__mmask8)__U,
+                                                _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fcmul_sch(__mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_vfcmulcsh_mask(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fcmul_round_sch(A, B, R)                                           \
+  ((__m128h)__builtin_ia32_vfcmulcsh_mask(                                     \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B),                              \
+      (__v4sf)(__m128h)_mm_undefined_ph(), (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_fcmul_round_sch(W, U, A, B, R)                                \
+  ((__m128h)__builtin_ia32_vfcmulcsh_mask(                                     \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_fcmul_round_sch(U, A, B, R)                                  \
+  ((__m128h)__builtin_ia32_vfcmulcsh_mask(                                     \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B),                              \
+      (__v4sf)(__m128h)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmul_sch(__m128h __A,
+                                                             __m128h __B) {
+  return (__m128h)__builtin_ia32_vfmulcsh_mask(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_undefined_ph(), (__mmask8)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_fmul_sch(__m128h __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A,
+                                                                  __m128h __B) {
+  return (__m128h)__builtin_ia32_vfmulcsh_mask((__v4sf)__A, (__v4sf)__B,
+                                               (__v4sf)__W, (__mmask8)__U,
+                                               _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fmul_sch(__mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_vfmulcsh_mask(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_setzero_ph(), (__mmask8)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm_fmul_round_sch(A, B, R)                                            \
+  ((__m128h)__builtin_ia32_vfmulcsh_mask(                                      \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B),                              \
+      (__v4sf)(__m128h)_mm_undefined_ph(), (__mmask8)-1, (int)(R)))
+
+#define _mm_mask_fmul_round_sch(W, U, A, B, R)                                 \
+  ((__m128h)__builtin_ia32_vfmulcsh_mask(                                      \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B), (__v4sf)(__m128h)(W),        \
+      (__mmask8)(U), (int)(R)))
+
+#define _mm_maskz_fmul_round_sch(U, A, B, R)                                   \
+  ((__m128h)__builtin_ia32_vfmulcsh_mask(                                      \
+      (__v4sf)(__m128h)(A), (__v4sf)(__m128h)(B),                              \
+      (__v4sf)(__m128h)_mm_setzero_ph(), (__mmask8)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fcmul_pch(__m512h __A,
+                                                                 __m512h __B) {
+  return (__m512h)__builtin_ia32_vfcmulcph512_mask(
+      (__v16sf)__A, (__v16sf)__B, (__v16sf)_mm512_undefined_ph(), (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_fcmul_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_vfcmulcph512_mask((__v16sf)__A, (__v16sf)__B,
+                                                   (__v16sf)__W, (__mmask16)__U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_fcmul_pch(__mmask16 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_vfcmulcph512_mask(
+      (__v16sf)__A, (__v16sf)__B, (__v16sf)_mm512_setzero_ph(), (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_fcmul_round_pch(A, B, R)                                        \
+  ((__m512h)__builtin_ia32_vfcmulcph512_mask(                                  \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B),                            \
+      (__v16sf)(__m512h)_mm512_undefined_ph(), (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_fcmul_round_pch(W, U, A, B, R)                             \
+  ((__m512h)__builtin_ia32_vfcmulcph512_mask(                                  \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(W),     \
+      (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_fcmul_round_pch(U, A, B, R)                               \
+  ((__m512h)__builtin_ia32_vfcmulcph512_mask(                                  \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B),                            \
+      (__v16sf)(__m512h)_mm512_setzero_ph(), (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fmul_pch(__m512h __A,
+                                                                __m512h __B) {
+  return (__m512h)__builtin_ia32_vfmulcph512_mask(
+      (__v16sf)__A, (__v16sf)__B, (__v16sf)_mm512_undefined_ph(), (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_fmul_pch(__m512h __W, __mmask16 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_vfmulcph512_mask((__v16sf)__A, (__v16sf)__B,
+                                                  (__v16sf)__W, (__mmask16)__U,
+                                                  _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmul_pch(__mmask16 __U, __m512h __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_vfmulcph512_mask(
+      (__v16sf)__A, (__v16sf)__B, (__v16sf)_mm512_setzero_ph(), (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_fmul_round_pch(A, B, R)                                         \
+  ((__m512h)__builtin_ia32_vfmulcph512_mask(                                   \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B),                            \
+      (__v16sf)(__m512h)_mm512_undefined_ph(), (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_fmul_round_pch(W, U, A, B, R)                              \
+  ((__m512h)__builtin_ia32_vfmulcph512_mask(                                   \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(W),     \
+      (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_fmul_round_pch(U, A, B, R)                                \
+  ((__m512h)__builtin_ia32_vfmulcph512_mask(                                   \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B),                            \
+      (__v16sf)(__m512h)_mm512_setzero_ph(), (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fcmadd_pch(__m512h __A,
+                                                                  __m512h __B,
+                                                                  __m512h __C) {
+  return (__m512h)__builtin_ia32_vfcmaddcph512_mask3(
+      (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)-1,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_fcmadd_pch(__m512h __A, __mmask16 __U, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfcmaddcph512_mask(
+      (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask3_fcmadd_pch(__m512h __A, __m512h __B, __m512h __C, __mmask16 __U) {
+  return (__m512h)__builtin_ia32_vfcmaddcph512_mask3(
+      (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_fcmadd_pch(__mmask16 __U, __m512h __A, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfcmaddcph512_maskz(
+      (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_fcmadd_round_pch(A, B, C, R)                                    \
+  ((__m512h)__builtin_ia32_vfcmaddcph512_mask3(                                \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C),     \
+      (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_fcmadd_round_pch(A, U, B, C, R)                            \
+  ((__m512h)__builtin_ia32_vfcmaddcph512_mask(                                 \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C),     \
+      (__mmask16)(U), (int)(R)))
+
+#define _mm512_mask3_fcmadd_round_pch(A, B, C, U, R)                           \
+  ((__m512h)__builtin_ia32_vfcmaddcph512_mask3(                                \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C),     \
+      (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_fcmadd_round_pch(U, A, B, C, R)                           \
+  ((__m512h)__builtin_ia32_vfcmaddcph512_maskz(                                \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C),     \
+      (__mmask16)(U), (int)(R)))
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512 _mm512_fmadd_pch(__m512h __A,
+                                                                 __m512h __B,
+                                                                 __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddcph512_mask3((__v16sf)__A, (__v16sf)__B,
+                                                    (__v16sf)__C, (__mmask16)-1,
+                                                    _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_fmadd_pch(__m512h __A, __mmask16 __U, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddcph512_mask((__v16sf)__A, (__v16sf)__B,
+                                                   (__v16sf)__C, (__mmask16)__U,
+                                                   _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask3_fmadd_pch(__m512h __A, __m512h __B, __m512h __C, __mmask16 __U) {
+  return (__m512h)__builtin_ia32_vfmaddcph512_mask3(
+      (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_maskz_fmadd_pch(__mmask16 __U, __m512h __A, __m512h __B, __m512h __C) {
+  return (__m512h)__builtin_ia32_vfmaddcph512_maskz(
+      (__v16sf)__A, (__v16sf)__B, (__v16sf)__C, (__mmask16)__U,
+      _MM_FROUND_CUR_DIRECTION);
+}
+
+#define _mm512_fmadd_round_pch(A, B, C, R)                                     \
+  ((__m512h)__builtin_ia32_vfmaddcph512_mask3(                                 \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C),     \
+      (__mmask16)-1, (int)(R)))
+
+#define _mm512_mask_fmadd_round_pch(A, U, B, C, R)                             \
+  ((__m512h)__builtin_ia32_vfmaddcph512_mask(                                  \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C),     \
+      (__mmask16)(U), (int)(R)))
+
+#define _mm512_mask3_fmadd_round_pch(A, B, C, U, R)                            \
+  ((__m512h)__builtin_ia32_vfmaddcph512_mask3(                                 \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C),     \
+      (__mmask16)(U), (int)(R)))
+
+#define _mm512_maskz_fmadd_round_pch(U, A, B, C, R)                            \
+  ((__m512h)__builtin_ia32_vfmaddcph512_maskz(                                 \
+      (__v16sf)(__m512h)(A), (__v16sf)(__m512h)(B), (__v16sf)(__m512h)(C),     \
+      (__mmask16)(U), (int)(R)))
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS512
+_mm512_reduce_add_ph(__m512h __W) {
+  return __builtin_ia32_reduce_fadd_ph512(-0.0f16, __W);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS512
+_mm512_reduce_mul_ph(__m512h __W) {
+  return __builtin_ia32_reduce_fmul_ph512(1.0f16, __W);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS512
+_mm512_reduce_max_ph(__m512h __V) {
+  return __builtin_ia32_reduce_fmax_ph512(__V);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS512
+_mm512_reduce_min_ph(__m512h __V) {
+  return __builtin_ia32_reduce_fmin_ph512(__V);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_mask_blend_ph(__mmask32 __U, __m512h __A, __m512h __W) {
+  return (__m512h)__builtin_ia32_selectph_512((__mmask32)__U, (__v32hf)__W,
+                                              (__v32hf)__A);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_permutex2var_ph(__m512h __A, __m512i __I, __m512h __B) {
+  return (__m512h)__builtin_ia32_vpermi2varhi512((__v32hi)__A, (__v32hi)__I,
+                                                 (__v32hi)__B);
+}
+
+static __inline__ __m512h __DEFAULT_FN_ATTRS512
+_mm512_permutexvar_ph(__m512i __A, __m512h __B) {
+  return (__m512h)__builtin_ia32_permvarhi512((__v32hi)__B, (__v32hi)__A);
+}
+
+// intrinsics below are alias for f*mul_*ch
+#define _mm512_mul_pch(A, B) _mm512_fmul_pch(A, B)
+#define _mm512_mask_mul_pch(W, U, A, B) _mm512_mask_fmul_pch(W, U, A, B)
+#define _mm512_maskz_mul_pch(U, A, B) _mm512_maskz_fmul_pch(U, A, B)
+#define _mm512_mul_round_pch(A, B, R) _mm512_fmul_round_pch(A, B, R)
+#define _mm512_mask_mul_round_pch(W, U, A, B, R)                               \
+  _mm512_mask_fmul_round_pch(W, U, A, B, R)
+#define _mm512_maskz_mul_round_pch(U, A, B, R)                                 \
+  _mm512_maskz_fmul_round_pch(U, A, B, R)
+
+#define _mm512_cmul_pch(A, B) _mm512_fcmul_pch(A, B)
+#define _mm512_mask_cmul_pch(W, U, A, B) _mm512_mask_fcmul_pch(W, U, A, B)
+#define _mm512_maskz_cmul_pch(U, A, B) _mm512_maskz_fcmul_pch(U, A, B)
+#define _mm512_cmul_round_pch(A, B, R) _mm512_fcmul_round_pch(A, B, R)
+#define _mm512_mask_cmul_round_pch(W, U, A, B, R)                              \
+  _mm512_mask_fcmul_round_pch(W, U, A, B, R)
+#define _mm512_maskz_cmul_round_pch(U, A, B, R)                                \
+  _mm512_maskz_fcmul_round_pch(U, A, B, R)
+
+#define _mm_mul_sch(A, B) _mm_fmul_sch(A, B)
+#define _mm_mask_mul_sch(W, U, A, B) _mm_mask_fmul_sch(W, U, A, B)
+#define _mm_maskz_mul_sch(U, A, B) _mm_maskz_fmul_sch(U, A, B)
+#define _mm_mul_round_sch(A, B, R) _mm_fmul_round_sch(A, B, R)
+#define _mm_mask_mul_round_sch(W, U, A, B, R)                                  \
+  _mm_mask_fmul_round_sch(W, U, A, B, R)
+#define _mm_maskz_mul_round_sch(U, A, B, R) _mm_maskz_fmul_round_sch(U, A, B, R)
+
+#define _mm_cmul_sch(A, B) _mm_fcmul_sch(A, B)
+#define _mm_mask_cmul_sch(W, U, A, B) _mm_mask_fcmul_sch(W, U, A, B)
+#define _mm_maskz_cmul_sch(U, A, B) _mm_maskz_fcmul_sch(U, A, B)
+#define _mm_cmul_round_sch(A, B, R) _mm_fcmul_round_sch(A, B, R)
+#define _mm_mask_cmul_round_sch(W, U, A, B, R)                                 \
+  _mm_mask_fcmul_round_sch(W, U, A, B, R)
+#define _mm_maskz_cmul_round_sch(U, A, B, R)                                   \
+  _mm_maskz_fcmul_round_sch(U, A, B, R)
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+#undef __DEFAULT_FN_ATTRS512
+
+#endif
+#endif
diff --git a/third_party/intel/clang/avx512ifmaintrin.h b/third_party/intel/clang/avx512ifmaintrin.h
new file mode 100644
index 000000000..9468d1755
--- /dev/null
+++ b/third_party/intel/clang/avx512ifmaintrin.h
@@ -0,0 +1,70 @@
+/*===------------- avx512ifmaintrin.h - IFMA intrinsics ------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512ifmaintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __IFMAINTRIN_H
+#define __IFMAINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512ifma,evex512"), __min_vector_width__(512)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_madd52hi_epu64 (__m512i __X, __m512i __Y, __m512i __Z)
+{
+  return (__m512i)__builtin_ia32_vpmadd52huq512((__v8di) __X, (__v8di) __Y,
+                                                (__v8di) __Z);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_madd52hi_epu64 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__M,
+                                   (__v8di)_mm512_madd52hi_epu64(__W, __X, __Y),
+                                   (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_madd52hi_epu64 (__mmask8 __M, __m512i __X, __m512i __Y, __m512i __Z)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__M,
+                                   (__v8di)_mm512_madd52hi_epu64(__X, __Y, __Z),
+                                   (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_madd52lo_epu64 (__m512i __X, __m512i __Y, __m512i __Z)
+{
+  return (__m512i)__builtin_ia32_vpmadd52luq512((__v8di) __X, (__v8di) __Y,
+                                                (__v8di) __Z);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_madd52lo_epu64 (__m512i __W, __mmask8 __M, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__M,
+                                   (__v8di)_mm512_madd52lo_epu64(__W, __X, __Y),
+                                   (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_madd52lo_epu64 (__mmask8 __M, __m512i __X, __m512i __Y, __m512i __Z)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__M,
+                                   (__v8di)_mm512_madd52lo_epu64(__X, __Y, __Z),
+                                   (__v8di)_mm512_setzero_si512());
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/avx512ifmavlintrin.h b/third_party/intel/clang/avx512ifmavlintrin.h
new file mode 100644
index 000000000..8787cd471
--- /dev/null
+++ b/third_party/intel/clang/avx512ifmavlintrin.h
@@ -0,0 +1,111 @@
+/*===------------- avx512ifmavlintrin.h - IFMA intrinsics ------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512ifmavlintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __IFMAVLINTRIN_H
+#define __IFMAVLINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512ifma,avx512vl,no-evex512"),                 \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512ifma,avx512vl,no-evex512"),                 \
+                 __min_vector_width__(256)))
+
+#define _mm_madd52hi_epu64(X, Y, Z)                                            \
+  ((__m128i)__builtin_ia32_vpmadd52huq128((__v2di)(X), (__v2di)(Y),            \
+                                          (__v2di)(Z)))
+
+#define _mm256_madd52hi_epu64(X, Y, Z)                                         \
+  ((__m256i)__builtin_ia32_vpmadd52huq256((__v4di)(X), (__v4di)(Y),            \
+                                          (__v4di)(Z)))
+
+#define _mm_madd52lo_epu64(X, Y, Z)                                            \
+  ((__m128i)__builtin_ia32_vpmadd52luq128((__v2di)(X), (__v2di)(Y),            \
+                                          (__v2di)(Z)))
+
+#define _mm256_madd52lo_epu64(X, Y, Z)                                         \
+  ((__m256i)__builtin_ia32_vpmadd52luq256((__v4di)(X), (__v4di)(Y),            \
+                                          (__v4di)(Z)))
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_madd52hi_epu64 (__m128i __W, __mmask8 __M, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__M,
+                                      (__v2di)_mm_madd52hi_epu64(__W, __X, __Y),
+                                      (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_madd52hi_epu64 (__mmask8 __M, __m128i __X, __m128i __Y, __m128i __Z)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__M,
+                                      (__v2di)_mm_madd52hi_epu64(__X, __Y, __Z),
+                                      (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_madd52hi_epu64 (__m256i __W, __mmask8 __M, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__M,
+                                   (__v4di)_mm256_madd52hi_epu64(__W, __X, __Y),
+                                   (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_madd52hi_epu64 (__mmask8 __M, __m256i __X, __m256i __Y, __m256i __Z)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__M,
+                                   (__v4di)_mm256_madd52hi_epu64(__X, __Y, __Z),
+                                   (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_madd52lo_epu64 (__m128i __W, __mmask8 __M, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__M,
+                                      (__v2di)_mm_madd52lo_epu64(__W, __X, __Y),
+                                      (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_madd52lo_epu64 (__mmask8 __M, __m128i __X, __m128i __Y, __m128i __Z)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__M,
+                                      (__v2di)_mm_madd52lo_epu64(__X, __Y, __Z),
+                                      (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_madd52lo_epu64 (__m256i __W, __mmask8 __M, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__M,
+                                   (__v4di)_mm256_madd52lo_epu64(__W, __X, __Y),
+                                   (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_madd52lo_epu64 (__mmask8 __M, __m256i __X, __m256i __Y, __m256i __Z)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__M,
+                                   (__v4di)_mm256_madd52lo_epu64(__X, __Y, __Z),
+                                   (__v4di)_mm256_setzero_si256());
+}
+
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif
diff --git a/third_party/intel/clang/avx512pfintrin.h b/third_party/intel/clang/avx512pfintrin.h
new file mode 100644
index 000000000..f853be021
--- /dev/null
+++ b/third_party/intel/clang/avx512pfintrin.h
@@ -0,0 +1,92 @@
+/*===------------- avx512pfintrin.h - PF intrinsics ------------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512pfintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512PFINTRIN_H
+#define __AVX512PFINTRIN_H
+
+#define _mm512_mask_prefetch_i32gather_pd(index, mask, addr, scale, hint) \
+  __builtin_ia32_gatherpfdpd((__mmask8)(mask), (__v8si)(__m256i)(index), \
+                             (void const *)(addr), (int)(scale), \
+                             (int)(hint))
+
+#define _mm512_prefetch_i32gather_pd(index, addr, scale, hint) \
+  __builtin_ia32_gatherpfdpd((__mmask8) -1, (__v8si)(__m256i)(index), \
+                             (void const *)(addr), (int)(scale), \
+                             (int)(hint))
+
+#define _mm512_mask_prefetch_i32gather_ps(index, mask, addr, scale, hint) \
+  __builtin_ia32_gatherpfdps((__mmask16)(mask), \
+                             (__v16si)(__m512i)(index), (void const *)(addr), \
+                             (int)(scale), (int)(hint))
+
+#define _mm512_prefetch_i32gather_ps(index, addr, scale, hint) \
+  __builtin_ia32_gatherpfdps((__mmask16) -1, \
+                             (__v16si)(__m512i)(index), (void const *)(addr), \
+                             (int)(scale), (int)(hint))
+
+#define _mm512_mask_prefetch_i64gather_pd(index, mask, addr, scale, hint) \
+  __builtin_ia32_gatherpfqpd((__mmask8)(mask), (__v8di)(__m512i)(index), \
+                             (void const *)(addr), (int)(scale), \
+                             (int)(hint))
+
+#define _mm512_prefetch_i64gather_pd(index, addr, scale, hint) \
+  __builtin_ia32_gatherpfqpd((__mmask8) -1, (__v8di)(__m512i)(index), \
+                             (void const *)(addr), (int)(scale), \
+                             (int)(hint))
+
+#define _mm512_mask_prefetch_i64gather_ps(index, mask, addr, scale, hint) \
+  __builtin_ia32_gatherpfqps((__mmask8)(mask), (__v8di)(__m512i)(index), \
+                             (void const *)(addr), (int)(scale), (int)(hint))
+
+#define _mm512_prefetch_i64gather_ps(index, addr, scale, hint) \
+  __builtin_ia32_gatherpfqps((__mmask8) -1, (__v8di)(__m512i)(index), \
+                             (void const *)(addr), (int)(scale), (int)(hint))
+
+#define _mm512_prefetch_i32scatter_pd(addr, index, scale, hint) \
+  __builtin_ia32_scatterpfdpd((__mmask8)-1, (__v8si)(__m256i)(index), \
+                              (void *)(addr), (int)(scale), \
+                              (int)(hint))
+
+#define _mm512_mask_prefetch_i32scatter_pd(addr, mask, index, scale, hint) \
+  __builtin_ia32_scatterpfdpd((__mmask8)(mask), (__v8si)(__m256i)(index), \
+                              (void *)(addr), (int)(scale), \
+                              (int)(hint))
+
+#define _mm512_prefetch_i32scatter_ps(addr, index, scale, hint) \
+  __builtin_ia32_scatterpfdps((__mmask16)-1, (__v16si)(__m512i)(index), \
+                              (void *)(addr), (int)(scale), (int)(hint))
+
+#define _mm512_mask_prefetch_i32scatter_ps(addr, mask, index, scale, hint) \
+  __builtin_ia32_scatterpfdps((__mmask16)(mask), \
+                              (__v16si)(__m512i)(index), (void *)(addr), \
+                              (int)(scale), (int)(hint))
+
+#define _mm512_prefetch_i64scatter_pd(addr, index, scale, hint) \
+  __builtin_ia32_scatterpfqpd((__mmask8)-1, (__v8di)(__m512i)(index), \
+                              (void *)(addr), (int)(scale), \
+                              (int)(hint))
+
+#define _mm512_mask_prefetch_i64scatter_pd(addr, mask, index, scale, hint) \
+  __builtin_ia32_scatterpfqpd((__mmask8)(mask), (__v8di)(__m512i)(index), \
+                              (void *)(addr), (int)(scale), \
+                              (int)(hint))
+
+#define _mm512_prefetch_i64scatter_ps(addr, index, scale, hint) \
+  __builtin_ia32_scatterpfqps((__mmask8)-1, (__v8di)(__m512i)(index), \
+                              (void *)(addr), (int)(scale), (int)(hint))
+
+#define _mm512_mask_prefetch_i64scatter_ps(addr, mask, index, scale, hint) \
+  __builtin_ia32_scatterpfqps((__mmask8)(mask), (__v8di)(__m512i)(index), \
+                              (void *)(addr), (int)(scale), (int)(hint))
+
+#endif
diff --git a/third_party/intel/clang/avx512vbmi2intrin.h b/third_party/intel/clang/avx512vbmi2intrin.h
new file mode 100644
index 000000000..11598c888
--- /dev/null
+++ b/third_party/intel/clang/avx512vbmi2intrin.h
@@ -0,0 +1,357 @@
+/*===------------- avx512vbmi2intrin.h - VBMI2 intrinsics ------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vbmi2intrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VBMI2INTRIN_H
+#define __AVX512VBMI2INTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("avx512vbmi2,evex512"), __min_vector_width__(512)))
+
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_compress_epi16(__m512i __S, __mmask32 __U, __m512i __D)
+{
+  return (__m512i) __builtin_ia32_compresshi512_mask ((__v32hi) __D,
+              (__v32hi) __S,
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_compress_epi16(__mmask32 __U, __m512i __D)
+{
+  return (__m512i) __builtin_ia32_compresshi512_mask ((__v32hi) __D,
+              (__v32hi) _mm512_setzero_si512(),
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_compress_epi8(__m512i __S, __mmask64 __U, __m512i __D)
+{
+  return (__m512i) __builtin_ia32_compressqi512_mask ((__v64qi) __D,
+              (__v64qi) __S,
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_compress_epi8(__mmask64 __U, __m512i __D)
+{
+  return (__m512i) __builtin_ia32_compressqi512_mask ((__v64qi) __D,
+              (__v64qi) _mm512_setzero_si512(),
+              __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm512_mask_compressstoreu_epi16(void *__P, __mmask32 __U, __m512i __D)
+{
+  __builtin_ia32_compressstorehi512_mask ((__v32hi *) __P, (__v32hi) __D,
+              __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm512_mask_compressstoreu_epi8(void *__P, __mmask64 __U, __m512i __D)
+{
+  __builtin_ia32_compressstoreqi512_mask ((__v64qi *) __P, (__v64qi) __D,
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_expand_epi16(__m512i __S, __mmask32 __U, __m512i __D)
+{
+  return (__m512i) __builtin_ia32_expandhi512_mask ((__v32hi) __D,
+              (__v32hi) __S,
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_expand_epi16(__mmask32 __U, __m512i __D)
+{
+  return (__m512i) __builtin_ia32_expandhi512_mask ((__v32hi) __D,
+              (__v32hi) _mm512_setzero_si512(),
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_expand_epi8(__m512i __S, __mmask64 __U, __m512i __D)
+{
+  return (__m512i) __builtin_ia32_expandqi512_mask ((__v64qi) __D,
+              (__v64qi) __S,
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_expand_epi8(__mmask64 __U, __m512i __D)
+{
+  return (__m512i) __builtin_ia32_expandqi512_mask ((__v64qi) __D,
+              (__v64qi) _mm512_setzero_si512(),
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_expandloadu_epi16(__m512i __S, __mmask32 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_expandloadhi512_mask ((const __v32hi *)__P,
+              (__v32hi) __S,
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_expandloadu_epi16(__mmask32 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_expandloadhi512_mask ((const __v32hi *)__P,
+              (__v32hi) _mm512_setzero_si512(),
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_expandloadu_epi8(__m512i __S, __mmask64 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_expandloadqi512_mask ((const __v64qi *)__P,
+              (__v64qi) __S,
+              __U);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_expandloadu_epi8(__mmask64 __U, void const *__P)
+{
+  return (__m512i) __builtin_ia32_expandloadqi512_mask ((const __v64qi *)__P,
+              (__v64qi) _mm512_setzero_si512(),
+              __U);
+}
+
+#define _mm512_shldi_epi64(A, B, I) \
+  ((__m512i)__builtin_ia32_vpshldq512((__v8di)(__m512i)(A), \
+                                      (__v8di)(__m512i)(B), (int)(I)))
+
+#define _mm512_mask_shldi_epi64(S, U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                     (__v8di)_mm512_shldi_epi64((A), (B), (I)), \
+                                     (__v8di)(__m512i)(S)))
+
+#define _mm512_maskz_shldi_epi64(U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                     (__v8di)_mm512_shldi_epi64((A), (B), (I)), \
+                                     (__v8di)_mm512_setzero_si512()))
+
+#define _mm512_shldi_epi32(A, B, I) \
+  ((__m512i)__builtin_ia32_vpshldd512((__v16si)(__m512i)(A), \
+                                      (__v16si)(__m512i)(B), (int)(I)))
+
+#define _mm512_mask_shldi_epi32(S, U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                    (__v16si)_mm512_shldi_epi32((A), (B), (I)), \
+                                    (__v16si)(__m512i)(S)))
+
+#define _mm512_maskz_shldi_epi32(U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                    (__v16si)_mm512_shldi_epi32((A), (B), (I)), \
+                                    (__v16si)_mm512_setzero_si512()))
+
+#define _mm512_shldi_epi16(A, B, I) \
+  ((__m512i)__builtin_ia32_vpshldw512((__v32hi)(__m512i)(A), \
+                                      (__v32hi)(__m512i)(B), (int)(I)))
+
+#define _mm512_mask_shldi_epi16(S, U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectw_512((__mmask32)(U), \
+                                    (__v32hi)_mm512_shldi_epi16((A), (B), (I)), \
+                                    (__v32hi)(__m512i)(S)))
+
+#define _mm512_maskz_shldi_epi16(U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectw_512((__mmask32)(U), \
+                                    (__v32hi)_mm512_shldi_epi16((A), (B), (I)), \
+                                    (__v32hi)_mm512_setzero_si512()))
+
+#define _mm512_shrdi_epi64(A, B, I) \
+  ((__m512i)__builtin_ia32_vpshrdq512((__v8di)(__m512i)(A), \
+                                      (__v8di)(__m512i)(B), (int)(I)))
+
+#define _mm512_mask_shrdi_epi64(S, U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                     (__v8di)_mm512_shrdi_epi64((A), (B), (I)), \
+                                     (__v8di)(__m512i)(S)))
+
+#define _mm512_maskz_shrdi_epi64(U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectq_512((__mmask8)(U), \
+                                     (__v8di)_mm512_shrdi_epi64((A), (B), (I)), \
+                                     (__v8di)_mm512_setzero_si512()))
+
+#define _mm512_shrdi_epi32(A, B, I) \
+  ((__m512i)__builtin_ia32_vpshrdd512((__v16si)(__m512i)(A), \
+                                      (__v16si)(__m512i)(B), (int)(I)))
+
+#define _mm512_mask_shrdi_epi32(S, U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                    (__v16si)_mm512_shrdi_epi32((A), (B), (I)), \
+                                    (__v16si)(__m512i)(S)))
+
+#define _mm512_maskz_shrdi_epi32(U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectd_512((__mmask16)(U), \
+                                    (__v16si)_mm512_shrdi_epi32((A), (B), (I)), \
+                                    (__v16si)_mm512_setzero_si512()))
+
+#define _mm512_shrdi_epi16(A, B, I) \
+  ((__m512i)__builtin_ia32_vpshrdw512((__v32hi)(__m512i)(A), \
+                                      (__v32hi)(__m512i)(B), (int)(I)))
+
+#define _mm512_mask_shrdi_epi16(S, U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectw_512((__mmask32)(U), \
+                                    (__v32hi)_mm512_shrdi_epi16((A), (B), (I)), \
+                                    (__v32hi)(__m512i)(S)))
+
+#define _mm512_maskz_shrdi_epi16(U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectw_512((__mmask32)(U), \
+                                    (__v32hi)_mm512_shrdi_epi16((A), (B), (I)), \
+                                    (__v32hi)_mm512_setzero_si512()))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_shldv_epi64(__m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_vpshldvq512((__v8di)__A, (__v8di)__B,
+                                             (__v8di)__C);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_shldv_epi64(__m512i __A, __mmask8 __U, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                                      (__v8di)_mm512_shldv_epi64(__A, __B, __C),
+                                      (__v8di)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_shldv_epi64(__mmask8 __U, __m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                                      (__v8di)_mm512_shldv_epi64(__A, __B, __C),
+                                      (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_shldv_epi32(__m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_vpshldvd512((__v16si)__A, (__v16si)__B,
+                                             (__v16si)__C);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_shldv_epi32(__m512i __A, __mmask16 __U, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                     (__v16si)_mm512_shldv_epi32(__A, __B, __C),
+                                     (__v16si)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_shldv_epi32(__mmask16 __U, __m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                     (__v16si)_mm512_shldv_epi32(__A, __B, __C),
+                                     (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_shldv_epi16(__m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_vpshldvw512((__v32hi)__A, (__v32hi)__B,
+                                             (__v32hi)__C);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_shldv_epi16(__m512i __A, __mmask32 __U, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_selectw_512(__U,
+                                     (__v32hi)_mm512_shldv_epi16(__A, __B, __C),
+                                     (__v32hi)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_shldv_epi16(__mmask32 __U, __m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_selectw_512(__U,
+                                     (__v32hi)_mm512_shldv_epi16(__A, __B, __C),
+                                     (__v32hi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_shrdv_epi64(__m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_vpshrdvq512((__v8di)__A, (__v8di)__B,
+                                             (__v8di)__C);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_shrdv_epi64(__m512i __A, __mmask8 __U, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                                      (__v8di)_mm512_shrdv_epi64(__A, __B, __C),
+                                      (__v8di)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_shrdv_epi64(__mmask8 __U, __m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_selectq_512(__U,
+                                      (__v8di)_mm512_shrdv_epi64(__A, __B, __C),
+                                      (__v8di)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_shrdv_epi32(__m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_vpshrdvd512((__v16si)__A, (__v16si)__B,
+                                             (__v16si)__C);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_shrdv_epi32(__m512i __A, __mmask16 __U, __m512i __B, __m512i __C)
+{
+  return (__m512i) __builtin_ia32_selectd_512(__U,
+                                     (__v16si)_mm512_shrdv_epi32(__A, __B, __C),
+                                     (__v16si)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_shrdv_epi32(__mmask16 __U, __m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i) __builtin_ia32_selectd_512(__U,
+                                     (__v16si)_mm512_shrdv_epi32(__A, __B, __C),
+                                     (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_shrdv_epi16(__m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_vpshrdvw512((__v32hi)__A, (__v32hi)__B,
+                                             (__v32hi)__C);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_shrdv_epi16(__m512i __A, __mmask32 __U, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_selectw_512(__U,
+                                     (__v32hi)_mm512_shrdv_epi16(__A, __B, __C),
+                                     (__v32hi)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_shrdv_epi16(__mmask32 __U, __m512i __A, __m512i __B, __m512i __C)
+{
+  return (__m512i)__builtin_ia32_selectw_512(__U,
+                                     (__v32hi)_mm512_shrdv_epi16(__A, __B, __C),
+                                     (__v32hi)_mm512_setzero_si512());
+}
+
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
+
diff --git a/third_party/intel/clang/avx512vbmiintrin.h b/third_party/intel/clang/avx512vbmiintrin.h
new file mode 100644
index 000000000..e47cd5cad
--- /dev/null
+++ b/third_party/intel/clang/avx512vbmiintrin.h
@@ -0,0 +1,106 @@
+/*===------------- avx512vbmiintrin.h - VBMI intrinsics ------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vbmiintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __VBMIINTRIN_H
+#define __VBMIINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vbmi,evex512"), __min_vector_width__(512)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_permutex2var_epi8(__m512i __A, __m512i __I, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_vpermi2varqi512((__v64qi)__A, (__v64qi)__I,
+                                                 (__v64qi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_permutex2var_epi8(__m512i __A, __mmask64 __U, __m512i __I,
+                              __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512(__U,
+                               (__v64qi)_mm512_permutex2var_epi8(__A, __I, __B),
+                               (__v64qi)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask2_permutex2var_epi8(__m512i __A, __m512i __I, __mmask64 __U,
+                               __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512(__U,
+                               (__v64qi)_mm512_permutex2var_epi8(__A, __I, __B),
+                               (__v64qi)__I);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_permutex2var_epi8(__mmask64 __U, __m512i __A, __m512i __I,
+                               __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512(__U,
+                               (__v64qi)_mm512_permutex2var_epi8(__A, __I, __B),
+                               (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_permutexvar_epi8 (__m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_permvarqi512((__v64qi) __B, (__v64qi) __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_permutexvar_epi8 (__mmask64 __M, __m512i __A,
+        __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                     (__v64qi)_mm512_permutexvar_epi8(__A, __B),
+                                     (__v64qi)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_permutexvar_epi8 (__m512i __W, __mmask64 __M, __m512i __A,
+             __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                     (__v64qi)_mm512_permutexvar_epi8(__A, __B),
+                                     (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_multishift_epi64_epi8(__m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_vpmultishiftqb512((__v64qi)__X, (__v64qi) __Y);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_multishift_epi64_epi8(__m512i __W, __mmask64 __M, __m512i __X,
+                                  __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                (__v64qi)_mm512_multishift_epi64_epi8(__X, __Y),
+                                (__v64qi)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_multishift_epi64_epi8(__mmask64 __M, __m512i __X, __m512i __Y)
+{
+  return (__m512i)__builtin_ia32_selectb_512((__mmask64)__M,
+                                (__v64qi)_mm512_multishift_epi64_epi8(__X, __Y),
+                                (__v64qi)_mm512_setzero_si512());
+}
+
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/avx512vbmivlintrin.h b/third_party/intel/clang/avx512vbmivlintrin.h
new file mode 100644
index 000000000..848ca2d18
--- /dev/null
+++ b/third_party/intel/clang/avx512vbmivlintrin.h
@@ -0,0 +1,193 @@
+/*===------------- avx512vbmivlintrin.h - VBMI intrinsics ------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vbmivlintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __VBMIVLINTRIN_H
+#define __VBMIVLINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vbmi,avx512vl,no-evex512"),                 \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vbmi,avx512vl,no-evex512"),                 \
+                 __min_vector_width__(256)))
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_permutex2var_epi8(__m128i __A, __m128i __I, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpermi2varqi128((__v16qi)__A,
+                                                 (__v16qi)__I,
+                                                 (__v16qi)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_permutex2var_epi8(__m128i __A, __mmask16 __U, __m128i __I,
+                           __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128(__U,
+                                  (__v16qi)_mm_permutex2var_epi8(__A, __I, __B),
+                                  (__v16qi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask2_permutex2var_epi8(__m128i __A, __m128i __I, __mmask16 __U,
+                            __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128(__U,
+                                  (__v16qi)_mm_permutex2var_epi8(__A, __I, __B),
+                                  (__v16qi)__I);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_permutex2var_epi8(__mmask16 __U, __m128i __A, __m128i __I,
+                            __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128(__U,
+                                  (__v16qi)_mm_permutex2var_epi8(__A, __I, __B),
+                                  (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_permutex2var_epi8(__m256i __A, __m256i __I, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_vpermi2varqi256((__v32qi)__A, (__v32qi)__I,
+                                                 (__v32qi)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_permutex2var_epi8(__m256i __A, __mmask32 __U, __m256i __I,
+                              __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256(__U,
+                               (__v32qi)_mm256_permutex2var_epi8(__A, __I, __B),
+                               (__v32qi)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask2_permutex2var_epi8(__m256i __A, __m256i __I, __mmask32 __U,
+                               __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256(__U,
+                               (__v32qi)_mm256_permutex2var_epi8(__A, __I, __B),
+                               (__v32qi)__I);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_permutex2var_epi8(__mmask32 __U, __m256i __A, __m256i __I,
+                               __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256(__U,
+                               (__v32qi)_mm256_permutex2var_epi8(__A, __I, __B),
+                               (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_permutexvar_epi8 (__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_permvarqi128((__v16qi)__B, (__v16qi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_permutexvar_epi8 (__mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                        (__v16qi)_mm_permutexvar_epi8(__A, __B),
+                                        (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_permutexvar_epi8 (__m128i __W, __mmask16 __M, __m128i __A,
+          __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                        (__v16qi)_mm_permutexvar_epi8(__A, __B),
+                                        (__v16qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_permutexvar_epi8 (__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_permvarqi256((__v32qi) __B, (__v32qi) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_permutexvar_epi8 (__mmask32 __M, __m256i __A,
+        __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                     (__v32qi)_mm256_permutexvar_epi8(__A, __B),
+                                     (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_permutexvar_epi8 (__m256i __W, __mmask32 __M, __m256i __A,
+             __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                     (__v32qi)_mm256_permutexvar_epi8(__A, __B),
+                                     (__v32qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_multishift_epi64_epi8(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_vpmultishiftqb128((__v16qi)__X, (__v16qi)__Y);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_multishift_epi64_epi8(__m128i __W, __mmask16 __M, __m128i __X,
+                               __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                   (__v16qi)_mm_multishift_epi64_epi8(__X, __Y),
+                                   (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_multishift_epi64_epi8(__mmask16 __M, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                   (__v16qi)_mm_multishift_epi64_epi8(__X, __Y),
+                                   (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_multishift_epi64_epi8(__m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_vpmultishiftqb256((__v32qi)__X, (__v32qi)__Y);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_multishift_epi64_epi8(__m256i __W, __mmask32 __M, __m256i __X,
+                                  __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                (__v32qi)_mm256_multishift_epi64_epi8(__X, __Y),
+                                (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_multishift_epi64_epi8(__mmask32 __M, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                (__v32qi)_mm256_multishift_epi64_epi8(__X, __Y),
+                                (__v32qi)_mm256_setzero_si256());
+}
+
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif
diff --git a/third_party/intel/clang/avx512vlbf16intrin.h b/third_party/intel/clang/avx512vlbf16intrin.h
new file mode 100644
index 000000000..89c9f49c7
--- /dev/null
+++ b/third_party/intel/clang/avx512vlbf16intrin.h
@@ -0,0 +1,517 @@
+/*===--------- avx512vlbf16intrin.h - AVX512_BF16 intrinsics ---------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vlbf16intrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifdef __SSE2__
+
+#ifndef __AVX512VLBF16INTRIN_H
+#define __AVX512VLBF16INTRIN_H
+
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512bf16,no-evex512"),                 \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512bf16,no-evex512"),                 \
+                 __min_vector_width__(256)))
+
+/// Convert Two Packed Single Data to One Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNE2PS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [8 x bfloat] whose lower 64 bits come from
+///    conversion of __B, and higher 64 bits come from conversion of __A.
+static __inline__ __m128bh __DEFAULT_FN_ATTRS128
+_mm_cvtne2ps_pbh(__m128 __A, __m128 __B) {
+  return (__m128bh)__builtin_ia32_cvtne2ps2bf16_128((__v4sf) __A,
+                                                    (__v4sf) __B);
+}
+
+/// Convert Two Packed Single Data to One Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNE2PS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \param __W
+///    A 128-bit vector of [8 x bfloat].
+/// \param __U
+///    A 8-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A or __B. A 0 means element from __W.
+/// \returns A 128-bit vector of [8 x bfloat] whose lower 64 bits come from
+///    conversion of __B, and higher 64 bits come from conversion of __A.
+static __inline__ __m128bh __DEFAULT_FN_ATTRS128
+_mm_mask_cvtne2ps_pbh(__m128bh __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128bh)__builtin_ia32_selectpbf_128((__mmask8)__U,
+                                             (__v8bf)_mm_cvtne2ps_pbh(__A, __B),
+                                             (__v8bf)__W);
+}
+
+/// Convert Two Packed Single Data to One Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNE2PS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \param __B
+///    A 128-bit vector of [4 x float].
+/// \param __U
+///    A 8-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A or __B. A 0 means element is zero.
+/// \returns A 128-bit vector of [8 x bfloat] whose lower 64 bits come from
+///    conversion of __B, and higher 64 bits come from conversion of __A.
+static __inline__ __m128bh __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtne2ps_pbh(__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128bh)__builtin_ia32_selectpbf_128((__mmask8)__U,
+                                             (__v8bf)_mm_cvtne2ps_pbh(__A, __B),
+                                             (__v8bf)_mm_setzero_si128());
+}
+
+/// Convert Two Packed Single Data to One Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNE2PS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \returns A 256-bit vector of [16 x bfloat] whose lower 128 bits come from
+///    conversion of __B, and higher 128 bits come from conversion of __A.
+static __inline__ __m256bh __DEFAULT_FN_ATTRS256
+_mm256_cvtne2ps_pbh(__m256 __A, __m256 __B) {
+  return (__m256bh)__builtin_ia32_cvtne2ps2bf16_256((__v8sf) __A,
+                                                    (__v8sf) __B);
+}
+
+/// Convert Two Packed Single Data to One Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNE2PS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \param __W
+///    A 256-bit vector of [16 x bfloat].
+/// \param __U
+///    A 16-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A or __B. A 0 means element from __W.
+/// \returns A 256-bit vector of [16 x bfloat] whose lower 128 bits come from
+///    conversion of __B, and higher 128 bits come from conversion of __A.
+static __inline__ __m256bh __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtne2ps_pbh(__m256bh __W, __mmask16 __U, __m256 __A, __m256 __B) {
+  return (__m256bh)__builtin_ia32_selectpbf_256((__mmask16)__U,
+                                         (__v16bf)_mm256_cvtne2ps_pbh(__A, __B),
+                                         (__v16bf)__W);
+}
+
+/// Convert Two Packed Single Data to One Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNE2PS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \param __B
+///    A 256-bit vector of [8 x float].
+/// \param __U
+///    A 16-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A or __B. A 0 means element is zero.
+/// \returns A 256-bit vector of [16 x bfloat] whose lower 128 bits come from
+///    conversion of __B, and higher 128 bits come from conversion of __A.
+static __inline__ __m256bh __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtne2ps_pbh(__mmask16 __U, __m256 __A, __m256 __B) {
+  return (__m256bh)__builtin_ia32_selectpbf_256((__mmask16)__U,
+                                         (__v16bf)_mm256_cvtne2ps_pbh(__A, __B),
+                                         (__v16bf)_mm256_setzero_si256());
+}
+
+/// Convert Packed Single Data to Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNEPS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [8 x bfloat] whose lower 64 bits come from
+///    conversion of __A, and higher 64 bits are 0.
+#define _mm_cvtneps_pbh(A)                                                     \
+  ((__m128bh)__builtin_ia32_vcvtneps2bf16128((__v4sf)(A)))
+
+/// Convert Packed Single Data to Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNEPS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \param __W
+///    A 128-bit vector of [8 x bfloat].
+/// \param __U
+///    A 4-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A. A 0 means element from __W.
+/// \returns A 128-bit vector of [8 x bfloat] whose lower 64 bits come from
+///    conversion of __A, and higher 64 bits are 0.
+static __inline__ __m128bh __DEFAULT_FN_ATTRS128
+_mm_mask_cvtneps_pbh(__m128bh __W, __mmask8 __U, __m128 __A) {
+  return (__m128bh)__builtin_ia32_cvtneps2bf16_128_mask((__v4sf) __A,
+                                                        (__v8bf)__W,
+                                                        (__mmask8)__U);
+}
+
+/// Convert Packed Single Data to Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNEPS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \param __U
+///    A 4-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A. A 0 means element is zero.
+/// \returns A 128-bit vector of [8 x bfloat] whose lower 64 bits come from
+///    conversion of __A, and higher 64 bits are 0.
+static __inline__ __m128bh __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtneps_pbh(__mmask8 __U, __m128 __A) {
+  return (__m128bh)__builtin_ia32_cvtneps2bf16_128_mask((__v4sf) __A,
+                                                    (__v8bf)_mm_setzero_si128(),
+                                                    (__mmask8)__U);
+}
+
+/// Convert Packed Single Data to Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNEPS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns A 128-bit vector of [8 x bfloat] comes from conversion of __A.
+#define _mm256_cvtneps_pbh(A)                                                  \
+  ((__m128bh)__builtin_ia32_vcvtneps2bf16256((__v8sf)(A)))
+
+/// Convert Packed Single Data to Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNEPS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \param __W
+///    A 256-bit vector of [8 x bfloat].
+/// \param __U
+///    A 8-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A. A 0 means element from __W.
+/// \returns A 128-bit vector of [8 x bfloat] comes from conversion of __A.
+static __inline__ __m128bh __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtneps_pbh(__m128bh __W, __mmask8 __U, __m256 __A) {
+  return (__m128bh)__builtin_ia32_cvtneps2bf16_256_mask((__v8sf)__A,
+                                                        (__v8bf)__W,
+                                                        (__mmask8)__U);
+}
+
+/// Convert Packed Single Data to Packed BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNEPS2BF16 </c> instructions.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \param __U
+///    A 8-bit mask value specifying what is chosen for each element.
+///    A 1 means conversion of __A. A 0 means element is zero.
+/// \returns A 128-bit vector of [8 x bfloat] comes from conversion of __A.
+static __inline__ __m128bh __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtneps_pbh(__mmask8 __U, __m256 __A) {
+  return (__m128bh)__builtin_ia32_cvtneps2bf16_256_mask((__v8sf)__A,
+                                                    (__v8bf)_mm_setzero_si128(),
+                                                    (__mmask8)__U);
+}
+
+/// Dot Product of BF16 Pairs Accumulated into Packed Single Precision.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDPBF16PS </c> instructions.
+///
+/// \param __A
+///    A 128-bit vector of [8 x bfloat].
+/// \param __B
+///    A 128-bit vector of [8 x bfloat].
+/// \param __D
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] comes from  Dot Product of
+///  __A, __B and __D
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_dpbf16_ps(__m128 __D, __m128bh __A, __m128bh __B) {
+  return (__m128)__builtin_ia32_dpbf16ps_128((__v4sf)__D,
+                                             (__v8bf)__A,
+                                             (__v8bf)__B);
+}
+
+/// Dot Product of BF16 Pairs Accumulated into Packed Single Precision.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDPBF16PS </c> instructions.
+///
+/// \param __A
+///    A 128-bit vector of [8 x bfloat].
+/// \param __B
+///    A 128-bit vector of [8 x bfloat].
+/// \param __D
+///    A 128-bit vector of [4 x float].
+/// \param __U
+///    A 8-bit mask value specifying what is chosen for each element.
+///    A 1 means __A and __B's dot product accumulated with __D. A 0 means __D.
+/// \returns A 128-bit vector of [4 x float] comes from  Dot Product of
+///  __A, __B and __D
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_dpbf16_ps(__m128 __D, __mmask8 __U, __m128bh __A, __m128bh __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                           (__v4sf)_mm_dpbf16_ps(__D, __A, __B),
+                                           (__v4sf)__D);
+}
+
+/// Dot Product of BF16 Pairs Accumulated into Packed Single Precision.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDPBF16PS </c> instructions.
+///
+/// \param __A
+///    A 128-bit vector of [8 x bfloat].
+/// \param __B
+///    A 128-bit vector of [8 x bfloat].
+/// \param __D
+///    A 128-bit vector of [4 x float].
+/// \param __U
+///    A 8-bit mask value specifying what is chosen for each element.
+///    A 1 means __A and __B's dot product accumulated with __D. A 0 means 0.
+/// \returns A 128-bit vector of [4 x float] comes from  Dot Product of
+///  __A, __B and __D
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_dpbf16_ps(__mmask8 __U, __m128 __D, __m128bh __A, __m128bh __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                           (__v4sf)_mm_dpbf16_ps(__D, __A, __B),
+                                           (__v4sf)_mm_setzero_si128());
+}
+
+/// Dot Product of BF16 Pairs Accumulated into Packed Single Precision.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDPBF16PS </c> instructions.
+///
+/// \param __A
+///    A 256-bit vector of [16 x bfloat].
+/// \param __B
+///    A 256-bit vector of [16 x bfloat].
+/// \param __D
+///    A 256-bit vector of [8 x float].
+/// \returns A 256-bit vector of [8 x float] comes from  Dot Product of
+///  __A, __B and __D
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_dpbf16_ps(__m256 __D, __m256bh __A, __m256bh __B) {
+  return (__m256)__builtin_ia32_dpbf16ps_256((__v8sf)__D,
+                                             (__v16bf)__A,
+                                             (__v16bf)__B);
+}
+
+/// Dot Product of BF16 Pairs Accumulated into Packed Single Precision.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDPBF16PS </c> instructions.
+///
+/// \param __A
+///    A 256-bit vector of [16 x bfloat].
+/// \param __B
+///    A 256-bit vector of [16 x bfloat].
+/// \param __D
+///    A 256-bit vector of [8 x float].
+/// \param __U
+///    A 16-bit mask value specifying what is chosen for each element.
+///    A 1 means __A and __B's dot product accumulated with __D. A 0 means __D.
+/// \returns A 256-bit vector of [8 x float] comes from  Dot Product of
+///  __A, __B and __D
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_dpbf16_ps(__m256 __D, __mmask8 __U, __m256bh __A, __m256bh __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                        (__v8sf)_mm256_dpbf16_ps(__D, __A, __B),
+                                        (__v8sf)__D);
+}
+
+/// Dot Product of BF16 Pairs Accumulated into Packed Single Precision.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDPBF16PS </c> instructions.
+///
+/// \param __A
+///    A 256-bit vector of [16 x bfloat].
+/// \param __B
+///    A 256-bit vector of [16 x bfloat].
+/// \param __D
+///    A 256-bit vector of [8 x float].
+/// \param __U
+///    A 8-bit mask value specifying what is chosen for each element.
+///    A 1 means __A and __B's dot product accumulated with __D. A 0 means 0.
+/// \returns A 256-bit vector of [8 x float] comes from  Dot Product of
+///  __A, __B and __D
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_dpbf16_ps(__mmask8 __U, __m256 __D, __m256bh __A, __m256bh __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                        (__v8sf)_mm256_dpbf16_ps(__D, __A, __B),
+                                        (__v8sf)_mm256_setzero_si256());
+}
+
+/// Convert One Single float Data to One BF16 Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTNEPS2BF16 </c> instructions.
+///
+/// \param __A
+///    A float data.
+/// \returns A bf16 data whose sign field and exponent field keep unchanged,
+///    and fraction field is truncated to 7 bits.
+static __inline__ __bf16 __DEFAULT_FN_ATTRS128 _mm_cvtness_sbh(float __A) {
+  __v4sf __V = {__A, 0, 0, 0};
+  __v8bf __R = __builtin_ia32_cvtneps2bf16_128_mask(
+      (__v4sf)__V, (__v8bf)_mm_undefined_si128(), (__mmask8)-1);
+  return (__bf16)__R[0];
+}
+
+/// Convert Packed BF16 Data to Packed float Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \param __A
+///    A 128-bit vector of [4 x bfloat].
+/// \returns A 128-bit vector of [4 x float] come from conversion of __A
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_cvtpbh_ps(__m128bh __A) {
+  return _mm_castsi128_ps(
+      (__m128i)_mm_slli_epi32((__m128i)_mm_cvtepi16_epi32((__m128i)__A), 16));
+}
+
+/// Convert Packed BF16 Data to Packed float Data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \param __A
+///    A 128-bit vector of [8 x bfloat].
+/// \returns A 256-bit vector of [8 x float] come from conversion of __A
+static __inline__ __m256 __DEFAULT_FN_ATTRS256 _mm256_cvtpbh_ps(__m128bh __A) {
+  return _mm256_castsi256_ps((__m256i)_mm256_slli_epi32(
+      (__m256i)_mm256_cvtepi16_epi32((__m128i)__A), 16));
+}
+
+/// Convert Packed BF16 Data to Packed float Data using zeroing mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \param __U
+///    A 4-bit mask. Elements are zeroed out when the corresponding mask
+///    bit is not set.
+/// \param __A
+///    A 128-bit vector of [4 x bfloat].
+/// \returns A 128-bit vector of [4 x float] come from conversion of __A
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtpbh_ps(__mmask8 __U, __m128bh __A) {
+  return _mm_castsi128_ps((__m128i)_mm_slli_epi32(
+      (__m128i)_mm_maskz_cvtepi16_epi32((__mmask8)__U, (__m128i)__A), 16));
+}
+
+/// Convert Packed BF16 Data to Packed float Data using zeroing mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \param __U
+///    A 8-bit mask. Elements are zeroed out when the corresponding mask
+///    bit is not set.
+/// \param __A
+///    A 128-bit vector of [8 x bfloat].
+/// \returns A 256-bit vector of [8 x float] come from conversion of __A
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtpbh_ps(__mmask8 __U, __m128bh __A) {
+  return _mm256_castsi256_ps((__m256i)_mm256_slli_epi32(
+      (__m256i)_mm256_maskz_cvtepi16_epi32((__mmask8)__U, (__m128i)__A), 16));
+}
+
+/// Convert Packed BF16 Data to Packed float Data using merging mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \param __S
+///    A 128-bit vector of [4 x float]. Elements are copied from __S when
+///     the corresponding mask bit is not set.
+/// \param __U
+///    A 4-bit mask. Elements are zeroed out when the corresponding mask
+///    bit is not set.
+/// \param __A
+///    A 128-bit vector of [4 x bfloat].
+/// \returns A 128-bit vector of [4 x float] come from conversion of __A
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_cvtpbh_ps(__m128 __S, __mmask8 __U, __m128bh __A) {
+  return _mm_castsi128_ps((__m128i)_mm_mask_slli_epi32(
+      (__m128i)__S, (__mmask8)__U, (__m128i)_mm_cvtepi16_epi32((__m128i)__A),
+      16));
+}
+
+/// Convert Packed BF16 Data to Packed float Data using merging mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \param __S
+///    A 256-bit vector of [8 x float]. Elements are copied from __S when
+///     the corresponding mask bit is not set.
+/// \param __U
+///    A 8-bit mask. Elements are zeroed out when the corresponding mask
+///    bit is not set.
+/// \param __A
+///    A 128-bit vector of [8 x bfloat].
+/// \returns A 256-bit vector of [8 x float] come from conversion of __A
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtpbh_ps(__m256 __S, __mmask8 __U, __m128bh __A) {
+  return _mm256_castsi256_ps((__m256i)_mm256_mask_slli_epi32(
+      (__m256i)__S, (__mmask8)__U, (__m256i)_mm256_cvtepi16_epi32((__m128i)__A),
+      16));
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif
+#endif
diff --git a/third_party/intel/clang/avx512vlbitalgintrin.h b/third_party/intel/clang/avx512vlbitalgintrin.h
new file mode 100644
index 000000000..377e3a5ea
--- /dev/null
+++ b/third_party/intel/clang/avx512vlbitalgintrin.h
@@ -0,0 +1,151 @@
+/*===---- avx512vlbitalgintrin.h - BITALG intrinsics -----------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vlbitalgintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VLBITALGINTRIN_H
+#define __AVX512VLBITALGINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512bitalg,no-evex512"),               \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512bitalg,no-evex512"),               \
+                 __min_vector_width__(256)))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_popcnt_epi16(__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpopcntw_256((__v16hi) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_popcnt_epi16(__m256i __A, __mmask16 __U, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_selectw_256((__mmask16) __U,
+              (__v16hi) _mm256_popcnt_epi16(__B),
+              (__v16hi) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_popcnt_epi16(__mmask16 __U, __m256i __B)
+{
+  return _mm256_mask_popcnt_epi16((__m256i) _mm256_setzero_si256(),
+              __U,
+              __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_popcnt_epi16(__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpopcntw_128((__v8hi) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_popcnt_epi16(__m128i __A, __mmask8 __U, __m128i __B)
+{
+  return (__m128i) __builtin_ia32_selectw_128((__mmask8) __U,
+              (__v8hi) _mm_popcnt_epi16(__B),
+              (__v8hi) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_popcnt_epi16(__mmask8 __U, __m128i __B)
+{
+  return _mm_mask_popcnt_epi16((__m128i) _mm_setzero_si128(),
+              __U,
+              __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_popcnt_epi8(__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpopcntb_256((__v32qi) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_popcnt_epi8(__m256i __A, __mmask32 __U, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_selectb_256((__mmask32) __U,
+              (__v32qi) _mm256_popcnt_epi8(__B),
+              (__v32qi) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_popcnt_epi8(__mmask32 __U, __m256i __B)
+{
+  return _mm256_mask_popcnt_epi8((__m256i) _mm256_setzero_si256(),
+              __U,
+              __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_popcnt_epi8(__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpopcntb_128((__v16qi) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_popcnt_epi8(__m128i __A, __mmask16 __U, __m128i __B)
+{
+  return (__m128i) __builtin_ia32_selectb_128((__mmask16) __U,
+              (__v16qi) _mm_popcnt_epi8(__B),
+              (__v16qi) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_popcnt_epi8(__mmask16 __U, __m128i __B)
+{
+  return _mm_mask_popcnt_epi8((__m128i) _mm_setzero_si128(),
+              __U,
+              __B);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS256
+_mm256_mask_bitshuffle_epi64_mask(__mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__mmask32) __builtin_ia32_vpshufbitqmb256_mask((__v32qi) __A,
+              (__v32qi) __B,
+              __U);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS256
+_mm256_bitshuffle_epi64_mask(__m256i __A, __m256i __B)
+{
+  return _mm256_mask_bitshuffle_epi64_mask((__mmask32) -1,
+              __A,
+              __B);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS128
+_mm_mask_bitshuffle_epi64_mask(__mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__mmask16) __builtin_ia32_vpshufbitqmb128_mask((__v16qi) __A,
+              (__v16qi) __B,
+              __U);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS128
+_mm_bitshuffle_epi64_mask(__m128i __A, __m128i __B)
+{
+  return _mm_mask_bitshuffle_epi64_mask((__mmask16) -1,
+              __A,
+              __B);
+}
+
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif
diff --git a/third_party/intel/clang/avx512vlbwintrin.h b/third_party/intel/clang/avx512vlbwintrin.h
new file mode 100644
index 000000000..9aedba066
--- /dev/null
+++ b/third_party/intel/clang/avx512vlbwintrin.h
@@ -0,0 +1,3167 @@
+/*===---- avx512vlbwintrin.h - AVX512VL and AVX512BW intrinsics ------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vlbwintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VLBWINTRIN_H
+#define __AVX512VLBWINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512bw,no-evex512"),                   \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512bw,no-evex512"),                   \
+                 __min_vector_width__(256)))
+
+/* Integer compare */
+
+#define _mm_cmp_epi8_mask(a, b, p) \
+  ((__mmask16)__builtin_ia32_cmpb128_mask((__v16qi)(__m128i)(a), \
+                                          (__v16qi)(__m128i)(b), (int)(p), \
+                                          (__mmask16)-1))
+
+#define _mm_mask_cmp_epi8_mask(m, a, b, p) \
+  ((__mmask16)__builtin_ia32_cmpb128_mask((__v16qi)(__m128i)(a), \
+                                          (__v16qi)(__m128i)(b), (int)(p), \
+                                          (__mmask16)(m)))
+
+#define _mm_cmp_epu8_mask(a, b, p) \
+  ((__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)(__m128i)(a), \
+                                           (__v16qi)(__m128i)(b), (int)(p), \
+                                           (__mmask16)-1))
+
+#define _mm_mask_cmp_epu8_mask(m, a, b, p) \
+  ((__mmask16)__builtin_ia32_ucmpb128_mask((__v16qi)(__m128i)(a), \
+                                           (__v16qi)(__m128i)(b), (int)(p), \
+                                           (__mmask16)(m)))
+
+#define _mm256_cmp_epi8_mask(a, b, p) \
+  ((__mmask32)__builtin_ia32_cmpb256_mask((__v32qi)(__m256i)(a), \
+                                          (__v32qi)(__m256i)(b), (int)(p), \
+                                          (__mmask32)-1))
+
+#define _mm256_mask_cmp_epi8_mask(m, a, b, p) \
+  ((__mmask32)__builtin_ia32_cmpb256_mask((__v32qi)(__m256i)(a), \
+                                          (__v32qi)(__m256i)(b), (int)(p), \
+                                          (__mmask32)(m)))
+
+#define _mm256_cmp_epu8_mask(a, b, p) \
+  ((__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)(__m256i)(a), \
+                                           (__v32qi)(__m256i)(b), (int)(p), \
+                                           (__mmask32)-1))
+
+#define _mm256_mask_cmp_epu8_mask(m, a, b, p) \
+  ((__mmask32)__builtin_ia32_ucmpb256_mask((__v32qi)(__m256i)(a), \
+                                           (__v32qi)(__m256i)(b), (int)(p), \
+                                           (__mmask32)(m)))
+
+#define _mm_cmp_epi16_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpw128_mask((__v8hi)(__m128i)(a), \
+                                         (__v8hi)(__m128i)(b), (int)(p), \
+                                         (__mmask8)-1))
+
+#define _mm_mask_cmp_epi16_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpw128_mask((__v8hi)(__m128i)(a), \
+                                         (__v8hi)(__m128i)(b), (int)(p), \
+                                         (__mmask8)(m)))
+
+#define _mm_cmp_epu16_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)(__m128i)(a), \
+                                          (__v8hi)(__m128i)(b), (int)(p), \
+                                          (__mmask8)-1))
+
+#define _mm_mask_cmp_epu16_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpw128_mask((__v8hi)(__m128i)(a), \
+                                          (__v8hi)(__m128i)(b), (int)(p), \
+                                          (__mmask8)(m)))
+
+#define _mm256_cmp_epi16_mask(a, b, p) \
+  ((__mmask16)__builtin_ia32_cmpw256_mask((__v16hi)(__m256i)(a), \
+                                          (__v16hi)(__m256i)(b), (int)(p), \
+                                          (__mmask16)-1))
+
+#define _mm256_mask_cmp_epi16_mask(m, a, b, p) \
+  ((__mmask16)__builtin_ia32_cmpw256_mask((__v16hi)(__m256i)(a), \
+                                          (__v16hi)(__m256i)(b), (int)(p), \
+                                          (__mmask16)(m)))
+
+#define _mm256_cmp_epu16_mask(a, b, p) \
+  ((__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)(__m256i)(a), \
+                                           (__v16hi)(__m256i)(b), (int)(p), \
+                                           (__mmask16)-1))
+
+#define _mm256_mask_cmp_epu16_mask(m, a, b, p) \
+  ((__mmask16)__builtin_ia32_ucmpw256_mask((__v16hi)(__m256i)(a), \
+                                           (__v16hi)(__m256i)(b), (int)(p), \
+                                           (__mmask16)(m)))
+
+#define _mm_cmpeq_epi8_mask(A, B) \
+    _mm_cmp_epi8_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm_mask_cmpeq_epi8_mask(k, A, B) \
+    _mm_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm_cmpge_epi8_mask(A, B) \
+    _mm_cmp_epi8_mask((A), (B), _MM_CMPINT_GE)
+#define _mm_mask_cmpge_epi8_mask(k, A, B) \
+    _mm_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm_cmpgt_epi8_mask(A, B) \
+    _mm_cmp_epi8_mask((A), (B), _MM_CMPINT_GT)
+#define _mm_mask_cmpgt_epi8_mask(k, A, B) \
+    _mm_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm_cmple_epi8_mask(A, B) \
+    _mm_cmp_epi8_mask((A), (B), _MM_CMPINT_LE)
+#define _mm_mask_cmple_epi8_mask(k, A, B) \
+    _mm_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm_cmplt_epi8_mask(A, B) \
+    _mm_cmp_epi8_mask((A), (B), _MM_CMPINT_LT)
+#define _mm_mask_cmplt_epi8_mask(k, A, B) \
+    _mm_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm_cmpneq_epi8_mask(A, B) \
+    _mm_cmp_epi8_mask((A), (B), _MM_CMPINT_NE)
+#define _mm_mask_cmpneq_epi8_mask(k, A, B) \
+    _mm_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm256_cmpeq_epi8_mask(A, B) \
+    _mm256_cmp_epi8_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm256_mask_cmpeq_epi8_mask(k, A, B) \
+    _mm256_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm256_cmpge_epi8_mask(A, B) \
+    _mm256_cmp_epi8_mask((A), (B), _MM_CMPINT_GE)
+#define _mm256_mask_cmpge_epi8_mask(k, A, B) \
+    _mm256_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm256_cmpgt_epi8_mask(A, B) \
+    _mm256_cmp_epi8_mask((A), (B), _MM_CMPINT_GT)
+#define _mm256_mask_cmpgt_epi8_mask(k, A, B) \
+    _mm256_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm256_cmple_epi8_mask(A, B) \
+    _mm256_cmp_epi8_mask((A), (B), _MM_CMPINT_LE)
+#define _mm256_mask_cmple_epi8_mask(k, A, B) \
+    _mm256_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm256_cmplt_epi8_mask(A, B) \
+    _mm256_cmp_epi8_mask((A), (B), _MM_CMPINT_LT)
+#define _mm256_mask_cmplt_epi8_mask(k, A, B) \
+    _mm256_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm256_cmpneq_epi8_mask(A, B) \
+    _mm256_cmp_epi8_mask((A), (B), _MM_CMPINT_NE)
+#define _mm256_mask_cmpneq_epi8_mask(k, A, B) \
+    _mm256_mask_cmp_epi8_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm_cmpeq_epu8_mask(A, B) \
+    _mm_cmp_epu8_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm_mask_cmpeq_epu8_mask(k, A, B) \
+    _mm_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm_cmpge_epu8_mask(A, B) \
+    _mm_cmp_epu8_mask((A), (B), _MM_CMPINT_GE)
+#define _mm_mask_cmpge_epu8_mask(k, A, B) \
+    _mm_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm_cmpgt_epu8_mask(A, B) \
+    _mm_cmp_epu8_mask((A), (B), _MM_CMPINT_GT)
+#define _mm_mask_cmpgt_epu8_mask(k, A, B) \
+    _mm_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm_cmple_epu8_mask(A, B) \
+    _mm_cmp_epu8_mask((A), (B), _MM_CMPINT_LE)
+#define _mm_mask_cmple_epu8_mask(k, A, B) \
+    _mm_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm_cmplt_epu8_mask(A, B) \
+    _mm_cmp_epu8_mask((A), (B), _MM_CMPINT_LT)
+#define _mm_mask_cmplt_epu8_mask(k, A, B) \
+    _mm_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm_cmpneq_epu8_mask(A, B) \
+    _mm_cmp_epu8_mask((A), (B), _MM_CMPINT_NE)
+#define _mm_mask_cmpneq_epu8_mask(k, A, B) \
+    _mm_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm256_cmpeq_epu8_mask(A, B) \
+    _mm256_cmp_epu8_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm256_mask_cmpeq_epu8_mask(k, A, B) \
+    _mm256_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm256_cmpge_epu8_mask(A, B) \
+    _mm256_cmp_epu8_mask((A), (B), _MM_CMPINT_GE)
+#define _mm256_mask_cmpge_epu8_mask(k, A, B) \
+    _mm256_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm256_cmpgt_epu8_mask(A, B) \
+    _mm256_cmp_epu8_mask((A), (B), _MM_CMPINT_GT)
+#define _mm256_mask_cmpgt_epu8_mask(k, A, B) \
+    _mm256_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm256_cmple_epu8_mask(A, B) \
+    _mm256_cmp_epu8_mask((A), (B), _MM_CMPINT_LE)
+#define _mm256_mask_cmple_epu8_mask(k, A, B) \
+    _mm256_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm256_cmplt_epu8_mask(A, B) \
+    _mm256_cmp_epu8_mask((A), (B), _MM_CMPINT_LT)
+#define _mm256_mask_cmplt_epu8_mask(k, A, B) \
+    _mm256_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm256_cmpneq_epu8_mask(A, B) \
+    _mm256_cmp_epu8_mask((A), (B), _MM_CMPINT_NE)
+#define _mm256_mask_cmpneq_epu8_mask(k, A, B) \
+    _mm256_mask_cmp_epu8_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm_cmpeq_epi16_mask(A, B) \
+    _mm_cmp_epi16_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm_mask_cmpeq_epi16_mask(k, A, B) \
+    _mm_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm_cmpge_epi16_mask(A, B) \
+    _mm_cmp_epi16_mask((A), (B), _MM_CMPINT_GE)
+#define _mm_mask_cmpge_epi16_mask(k, A, B) \
+    _mm_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm_cmpgt_epi16_mask(A, B) \
+    _mm_cmp_epi16_mask((A), (B), _MM_CMPINT_GT)
+#define _mm_mask_cmpgt_epi16_mask(k, A, B) \
+    _mm_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm_cmple_epi16_mask(A, B) \
+    _mm_cmp_epi16_mask((A), (B), _MM_CMPINT_LE)
+#define _mm_mask_cmple_epi16_mask(k, A, B) \
+    _mm_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm_cmplt_epi16_mask(A, B) \
+    _mm_cmp_epi16_mask((A), (B), _MM_CMPINT_LT)
+#define _mm_mask_cmplt_epi16_mask(k, A, B) \
+    _mm_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm_cmpneq_epi16_mask(A, B) \
+    _mm_cmp_epi16_mask((A), (B), _MM_CMPINT_NE)
+#define _mm_mask_cmpneq_epi16_mask(k, A, B) \
+    _mm_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm256_cmpeq_epi16_mask(A, B) \
+    _mm256_cmp_epi16_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm256_mask_cmpeq_epi16_mask(k, A, B) \
+    _mm256_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm256_cmpge_epi16_mask(A, B) \
+    _mm256_cmp_epi16_mask((A), (B), _MM_CMPINT_GE)
+#define _mm256_mask_cmpge_epi16_mask(k, A, B) \
+    _mm256_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm256_cmpgt_epi16_mask(A, B) \
+    _mm256_cmp_epi16_mask((A), (B), _MM_CMPINT_GT)
+#define _mm256_mask_cmpgt_epi16_mask(k, A, B) \
+    _mm256_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm256_cmple_epi16_mask(A, B) \
+    _mm256_cmp_epi16_mask((A), (B), _MM_CMPINT_LE)
+#define _mm256_mask_cmple_epi16_mask(k, A, B) \
+    _mm256_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm256_cmplt_epi16_mask(A, B) \
+    _mm256_cmp_epi16_mask((A), (B), _MM_CMPINT_LT)
+#define _mm256_mask_cmplt_epi16_mask(k, A, B) \
+    _mm256_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm256_cmpneq_epi16_mask(A, B) \
+    _mm256_cmp_epi16_mask((A), (B), _MM_CMPINT_NE)
+#define _mm256_mask_cmpneq_epi16_mask(k, A, B) \
+    _mm256_mask_cmp_epi16_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm_cmpeq_epu16_mask(A, B) \
+    _mm_cmp_epu16_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm_mask_cmpeq_epu16_mask(k, A, B) \
+    _mm_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm_cmpge_epu16_mask(A, B) \
+    _mm_cmp_epu16_mask((A), (B), _MM_CMPINT_GE)
+#define _mm_mask_cmpge_epu16_mask(k, A, B) \
+    _mm_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm_cmpgt_epu16_mask(A, B) \
+    _mm_cmp_epu16_mask((A), (B), _MM_CMPINT_GT)
+#define _mm_mask_cmpgt_epu16_mask(k, A, B) \
+    _mm_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm_cmple_epu16_mask(A, B) \
+    _mm_cmp_epu16_mask((A), (B), _MM_CMPINT_LE)
+#define _mm_mask_cmple_epu16_mask(k, A, B) \
+    _mm_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm_cmplt_epu16_mask(A, B) \
+    _mm_cmp_epu16_mask((A), (B), _MM_CMPINT_LT)
+#define _mm_mask_cmplt_epu16_mask(k, A, B) \
+    _mm_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm_cmpneq_epu16_mask(A, B) \
+    _mm_cmp_epu16_mask((A), (B), _MM_CMPINT_NE)
+#define _mm_mask_cmpneq_epu16_mask(k, A, B) \
+    _mm_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm256_cmpeq_epu16_mask(A, B) \
+    _mm256_cmp_epu16_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm256_mask_cmpeq_epu16_mask(k, A, B) \
+    _mm256_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm256_cmpge_epu16_mask(A, B) \
+    _mm256_cmp_epu16_mask((A), (B), _MM_CMPINT_GE)
+#define _mm256_mask_cmpge_epu16_mask(k, A, B) \
+    _mm256_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm256_cmpgt_epu16_mask(A, B) \
+    _mm256_cmp_epu16_mask((A), (B), _MM_CMPINT_GT)
+#define _mm256_mask_cmpgt_epu16_mask(k, A, B) \
+    _mm256_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm256_cmple_epu16_mask(A, B) \
+    _mm256_cmp_epu16_mask((A), (B), _MM_CMPINT_LE)
+#define _mm256_mask_cmple_epu16_mask(k, A, B) \
+    _mm256_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm256_cmplt_epu16_mask(A, B) \
+    _mm256_cmp_epu16_mask((A), (B), _MM_CMPINT_LT)
+#define _mm256_mask_cmplt_epu16_mask(k, A, B) \
+    _mm256_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm256_cmpneq_epu16_mask(A, B) \
+    _mm256_cmp_epu16_mask((A), (B), _MM_CMPINT_NE)
+#define _mm256_mask_cmpneq_epu16_mask(k, A, B) \
+    _mm256_mask_cmp_epu16_mask((k), (A), (B), _MM_CMPINT_NE)
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_add_epi8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B){
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                             (__v32qi)_mm256_add_epi8(__A, __B),
+                                             (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_add_epi8(__mmask32 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                             (__v32qi)_mm256_add_epi8(__A, __B),
+                                             (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_add_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_add_epi16(__A, __B),
+                                             (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_add_epi16(__mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_add_epi16(__A, __B),
+                                             (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sub_epi8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                             (__v32qi)_mm256_sub_epi8(__A, __B),
+                                             (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sub_epi8(__mmask32 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                             (__v32qi)_mm256_sub_epi8(__A, __B),
+                                             (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sub_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_sub_epi16(__A, __B),
+                                             (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sub_epi16(__mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_sub_epi16(__A, __B),
+                                             (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_add_epi8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_add_epi8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_add_epi8(__mmask16 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_add_epi8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_add_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_add_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_add_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_add_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sub_epi8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_sub_epi8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sub_epi8(__mmask16 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_sub_epi8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sub_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_sub_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sub_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_sub_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mullo_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_mullo_epi16(__A, __B),
+                                             (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mullo_epi16(__mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_mullo_epi16(__A, __B),
+                                             (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mullo_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_mullo_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mullo_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_mullo_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_blend_epi8 (__mmask16 __U, __m128i __A, __m128i __W)
+{
+  return (__m128i) __builtin_ia32_selectb_128 ((__mmask16) __U,
+              (__v16qi) __W,
+              (__v16qi) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_blend_epi8 (__mmask32 __U, __m256i __A, __m256i __W)
+{
+  return (__m256i) __builtin_ia32_selectb_256 ((__mmask32) __U,
+               (__v32qi) __W,
+               (__v32qi) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_blend_epi16 (__mmask8 __U, __m128i __A, __m128i __W)
+{
+  return (__m128i) __builtin_ia32_selectw_128 ((__mmask8) __U,
+               (__v8hi) __W,
+               (__v8hi) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_blend_epi16 (__mmask16 __U, __m256i __A, __m256i __W)
+{
+  return (__m256i) __builtin_ia32_selectw_256 ((__mmask16) __U,
+               (__v16hi) __W,
+               (__v16hi) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_abs_epi8(__m128i __W, __mmask16 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_abs_epi8(__A),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_abs_epi8(__mmask16 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_abs_epi8(__A),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_abs_epi8(__m256i __W, __mmask32 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                             (__v32qi)_mm256_abs_epi8(__A),
+                                             (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_abs_epi8 (__mmask32 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                             (__v32qi)_mm256_abs_epi8(__A),
+                                             (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_abs_epi16(__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_abs_epi16(__A),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_abs_epi16(__mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_abs_epi16(__A),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_abs_epi16(__m256i __W, __mmask16 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_abs_epi16(__A),
+                                             (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_abs_epi16(__mmask16 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_abs_epi16(__A),
+                                             (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_packs_epi32(__mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_packs_epi32(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_packs_epi32(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_packs_epi32(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_packs_epi32(__mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                          (__v16hi)_mm256_packs_epi32(__A, __B),
+                                          (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_packs_epi32(__m256i __W, __mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                          (__v16hi)_mm256_packs_epi32(__A, __B),
+                                          (__v16hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_packs_epi16(__mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm_packs_epi16(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_packs_epi16(__m128i __W, __mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm_packs_epi16(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_packs_epi16(__mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                          (__v32qi)_mm256_packs_epi16(__A, __B),
+                                          (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_packs_epi16(__m256i __W, __mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                          (__v32qi)_mm256_packs_epi16(__A, __B),
+                                          (__v32qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_packus_epi32(__mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_packus_epi32(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_packus_epi32(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_packus_epi32(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_packus_epi32(__mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                         (__v16hi)_mm256_packus_epi32(__A, __B),
+                                         (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_packus_epi32(__m256i __W, __mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                         (__v16hi)_mm256_packus_epi32(__A, __B),
+                                         (__v16hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_packus_epi16(__mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                            (__v16qi)_mm_packus_epi16(__A, __B),
+                                            (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_packus_epi16(__m128i __W, __mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                            (__v16qi)_mm_packus_epi16(__A, __B),
+                                            (__v16qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_packus_epi16(__mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                         (__v32qi)_mm256_packus_epi16(__A, __B),
+                                         (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_packus_epi16(__m256i __W, __mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                         (__v32qi)_mm256_packus_epi16(__A, __B),
+                                         (__v32qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_adds_epi8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_adds_epi8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_adds_epi8(__mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_adds_epi8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_adds_epi8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                            (__v32qi)_mm256_adds_epi8(__A, __B),
+                                            (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_adds_epi8(__mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                            (__v32qi)_mm256_adds_epi8(__A, __B),
+                                            (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_adds_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_adds_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_adds_epi16(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_adds_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_adds_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_adds_epi16(__A, __B),
+                                           (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_adds_epi16(__mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_adds_epi16(__A, __B),
+                                           (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_adds_epu8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_adds_epu8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_adds_epu8(__mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_adds_epu8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_adds_epu8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                            (__v32qi)_mm256_adds_epu8(__A, __B),
+                                            (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_adds_epu8(__mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                            (__v32qi)_mm256_adds_epu8(__A, __B),
+                                            (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_adds_epu16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_adds_epu16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_adds_epu16(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_adds_epu16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_adds_epu16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_adds_epu16(__A, __B),
+                                           (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_adds_epu16(__mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_adds_epu16(__A, __B),
+                                           (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_avg_epu8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_avg_epu8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_avg_epu8(__mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_avg_epu8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_avg_epu8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                             (__v32qi)_mm256_avg_epu8(__A, __B),
+                                             (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_avg_epu8(__mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                             (__v32qi)_mm256_avg_epu8(__A, __B),
+                                             (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_avg_epu16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_avg_epu16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_avg_epu16(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_avg_epu16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_avg_epu16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                            (__v16hi)_mm256_avg_epu16(__A, __B),
+                                            (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_avg_epu16(__mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                            (__v16hi)_mm256_avg_epu16(__A, __B),
+                                            (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_max_epi8(__mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm_max_epi8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_max_epi8(__m128i __W, __mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm_max_epi8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_epi8(__mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                             (__v32qi)_mm256_max_epi8(__A, __B),
+                                             (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_max_epi8(__m256i __W, __mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                             (__v32qi)_mm256_max_epi8(__A, __B),
+                                             (__v32qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_max_epi16(__mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_max_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_max_epi16(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_max_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_epi16(__mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                            (__v16hi)_mm256_max_epi16(__A, __B),
+                                            (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_max_epi16(__m256i __W, __mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                            (__v16hi)_mm256_max_epi16(__A, __B),
+                                            (__v16hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_max_epu8(__mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm_max_epu8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_max_epu8(__m128i __W, __mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm_max_epu8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_epu8 (__mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                             (__v32qi)_mm256_max_epu8(__A, __B),
+                                             (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_max_epu8(__m256i __W, __mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                             (__v32qi)_mm256_max_epu8(__A, __B),
+                                             (__v32qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_max_epu16(__mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_max_epu16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_max_epu16(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_max_epu16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_epu16(__mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                            (__v16hi)_mm256_max_epu16(__A, __B),
+                                            (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_max_epu16(__m256i __W, __mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                            (__v16hi)_mm256_max_epu16(__A, __B),
+                                            (__v16hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_min_epi8(__mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm_min_epi8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_min_epi8(__m128i __W, __mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm_min_epi8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_epi8(__mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                             (__v32qi)_mm256_min_epi8(__A, __B),
+                                             (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_min_epi8(__m256i __W, __mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                             (__v32qi)_mm256_min_epi8(__A, __B),
+                                             (__v32qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_min_epi16(__mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_min_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_min_epi16(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_min_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_epi16(__mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                            (__v16hi)_mm256_min_epi16(__A, __B),
+                                            (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_min_epi16(__m256i __W, __mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                            (__v16hi)_mm256_min_epi16(__A, __B),
+                                            (__v16hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_min_epu8(__mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm_min_epu8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_min_epu8(__m128i __W, __mmask16 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm_min_epu8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_epu8 (__mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                             (__v32qi)_mm256_min_epu8(__A, __B),
+                                             (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_min_epu8(__m256i __W, __mmask32 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__M,
+                                             (__v32qi)_mm256_min_epu8(__A, __B),
+                                             (__v32qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_min_epu16(__mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_min_epu16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_min_epu16(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                             (__v8hi)_mm_min_epu16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_epu16(__mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                            (__v16hi)_mm256_min_epu16(__A, __B),
+                                            (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_min_epu16(__m256i __W, __mmask16 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                            (__v16hi)_mm256_min_epu16(__A, __B),
+                                            (__v16hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_shuffle_epi8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                            (__v16qi)_mm_shuffle_epi8(__A, __B),
+                                            (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_shuffle_epi8(__mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                            (__v16qi)_mm_shuffle_epi8(__A, __B),
+                                            (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_shuffle_epi8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                         (__v32qi)_mm256_shuffle_epi8(__A, __B),
+                                         (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_shuffle_epi8(__mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                         (__v32qi)_mm256_shuffle_epi8(__A, __B),
+                                         (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_subs_epi8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_subs_epi8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_subs_epi8(__mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_subs_epi8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_subs_epi8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                            (__v32qi)_mm256_subs_epi8(__A, __B),
+                                            (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_subs_epi8(__mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                            (__v32qi)_mm256_subs_epi8(__A, __B),
+                                            (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_subs_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_subs_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_subs_epi16(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_subs_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_subs_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_subs_epi16(__A, __B),
+                                           (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_subs_epi16(__mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_subs_epi16(__A, __B),
+                                           (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_subs_epu8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_subs_epu8(__A, __B),
+                                             (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_subs_epu8(__mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                             (__v16qi)_mm_subs_epu8(__A, __B),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_subs_epu8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                            (__v32qi)_mm256_subs_epu8(__A, __B),
+                                            (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_subs_epu8(__mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                            (__v32qi)_mm256_subs_epu8(__A, __B),
+                                            (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_subs_epu16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_subs_epu16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_subs_epu16(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_subs_epu16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_subs_epu16(__m256i __W, __mmask16 __U, __m256i __A,
+      __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_subs_epu16(__A, __B),
+                                           (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_subs_epu16(__mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_subs_epu16(__A, __B),
+                                           (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_permutex2var_epi16(__m128i __A, __m128i __I, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpermi2varhi128((__v8hi)__A, (__v8hi)__I,
+                                                 (__v8hi) __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_permutex2var_epi16(__m128i __A, __mmask8 __U, __m128i __I,
+                            __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128(__U,
+                                  (__v8hi)_mm_permutex2var_epi16(__A, __I, __B),
+                                  (__v8hi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask2_permutex2var_epi16(__m128i __A, __m128i __I, __mmask8 __U,
+                             __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128(__U,
+                                  (__v8hi)_mm_permutex2var_epi16(__A, __I, __B),
+                                  (__v8hi)__I);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_permutex2var_epi16 (__mmask8 __U, __m128i __A, __m128i __I,
+            __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128(__U,
+                                  (__v8hi)_mm_permutex2var_epi16(__A, __I, __B),
+                                  (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_permutex2var_epi16(__m256i __A, __m256i __I, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_vpermi2varhi256((__v16hi)__A, (__v16hi)__I,
+                                                 (__v16hi)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_permutex2var_epi16(__m256i __A, __mmask16 __U, __m256i __I,
+                               __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256(__U,
+                              (__v16hi)_mm256_permutex2var_epi16(__A, __I, __B),
+                              (__v16hi)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask2_permutex2var_epi16(__m256i __A, __m256i __I, __mmask16 __U,
+                                __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256(__U,
+                              (__v16hi)_mm256_permutex2var_epi16(__A, __I, __B),
+                              (__v16hi)__I);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_permutex2var_epi16 (__mmask16 __U, __m256i __A, __m256i __I,
+                                 __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256(__U,
+                              (__v16hi)_mm256_permutex2var_epi16(__A, __I, __B),
+                              (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_maddubs_epi16(__m128i __W, __mmask8 __U, __m128i __X, __m128i __Y) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                            (__v8hi)_mm_maddubs_epi16(__X, __Y),
+                                            (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_maddubs_epi16(__mmask8 __U, __m128i __X, __m128i __Y) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                            (__v8hi)_mm_maddubs_epi16(__X, __Y),
+                                            (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_maddubs_epi16(__m256i __W, __mmask16 __U, __m256i __X,
+                          __m256i __Y) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                        (__v16hi)_mm256_maddubs_epi16(__X, __Y),
+                                        (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_maddubs_epi16(__mmask16 __U, __m256i __X, __m256i __Y) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                        (__v16hi)_mm256_maddubs_epi16(__X, __Y),
+                                        (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_madd_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_madd_epi16(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_madd_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_madd_epi16(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_madd_epi16(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                            (__v8si)_mm256_madd_epi16(__A, __B),
+                                            (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_madd_epi16(__mmask8 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                            (__v8si)_mm256_madd_epi16(__A, __B),
+                                            (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtsepi16_epi8 (__m128i __A) {
+  return (__m128i) __builtin_ia32_pmovswb128_mask ((__v8hi) __A,
+               (__v16qi) _mm_setzero_si128(),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi16_epi8 (__m128i __O, __mmask8 __M, __m128i __A) {
+  return (__m128i) __builtin_ia32_pmovswb128_mask ((__v8hi) __A,
+               (__v16qi) __O,
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtsepi16_epi8 (__mmask8 __M, __m128i __A) {
+  return (__m128i) __builtin_ia32_pmovswb128_mask ((__v8hi) __A,
+               (__v16qi) _mm_setzero_si128(),
+               __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtsepi16_epi8 (__m256i __A) {
+  return (__m128i) __builtin_ia32_pmovswb256_mask ((__v16hi) __A,
+               (__v16qi) _mm_setzero_si128(),
+               (__mmask16) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi16_epi8 (__m128i __O, __mmask16 __M, __m256i __A) {
+  return (__m128i) __builtin_ia32_pmovswb256_mask ((__v16hi) __A,
+               (__v16qi) __O,
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtsepi16_epi8 (__mmask16 __M, __m256i __A) {
+  return (__m128i) __builtin_ia32_pmovswb256_mask ((__v16hi) __A,
+               (__v16qi) _mm_setzero_si128(),
+               __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtusepi16_epi8 (__m128i __A) {
+  return (__m128i) __builtin_ia32_pmovuswb128_mask ((__v8hi) __A,
+                (__v16qi) _mm_setzero_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi16_epi8 (__m128i __O, __mmask8 __M, __m128i __A) {
+  return (__m128i) __builtin_ia32_pmovuswb128_mask ((__v8hi) __A,
+                (__v16qi) __O,
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtusepi16_epi8 (__mmask8 __M, __m128i __A) {
+  return (__m128i) __builtin_ia32_pmovuswb128_mask ((__v8hi) __A,
+                (__v16qi) _mm_setzero_si128(),
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtusepi16_epi8 (__m256i __A) {
+  return (__m128i) __builtin_ia32_pmovuswb256_mask ((__v16hi) __A,
+                (__v16qi) _mm_setzero_si128(),
+                (__mmask16) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi16_epi8 (__m128i __O, __mmask16 __M, __m256i __A) {
+  return (__m128i) __builtin_ia32_pmovuswb256_mask ((__v16hi) __A,
+                (__v16qi) __O,
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtusepi16_epi8 (__mmask16 __M, __m256i __A) {
+  return (__m128i) __builtin_ia32_pmovuswb256_mask ((__v16hi) __A,
+                (__v16qi) _mm_setzero_si128(),
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtepi16_epi8 (__m128i __A) {
+  return (__m128i)__builtin_shufflevector(
+      __builtin_convertvector((__v8hi)__A, __v8qi),
+      (__v8qi){0, 0, 0, 0, 0, 0, 0, 0}, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+      12, 13, 14, 15);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi16_epi8 (__m128i __O, __mmask8 __M, __m128i __A) {
+  return (__m128i) __builtin_ia32_pmovwb128_mask ((__v8hi) __A,
+               (__v16qi) __O,
+               __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi16_epi8 (__mmask8 __M, __m128i __A) {
+  return (__m128i) __builtin_ia32_pmovwb128_mask ((__v8hi) __A,
+               (__v16qi) _mm_setzero_si128(),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi16_storeu_epi8 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovwb128mem_mask ((__v16qi *) __P, (__v8hi) __A, __M);
+}
+
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi16_storeu_epi8 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovswb128mem_mask ((__v16qi *) __P, (__v8hi) __A, __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi16_storeu_epi8 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovuswb128mem_mask ((__v16qi *) __P, (__v8hi) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi16_epi8 (__m256i __A) {
+  return (__m128i)__builtin_convertvector((__v16hi) __A, __v16qi);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi16_epi8 (__m128i __O, __mmask16 __M, __m256i __A) {
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm256_cvtepi16_epi8(__A),
+                                             (__v16qi)__O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi16_epi8 (__mmask16 __M, __m256i __A) {
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__M,
+                                             (__v16qi)_mm256_cvtepi16_epi8(__A),
+                                             (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi16_storeu_epi8 (void * __P, __mmask16 __M, __m256i __A)
+{
+  __builtin_ia32_pmovwb256mem_mask ((__v16qi *) __P, (__v16hi) __A, __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi16_storeu_epi8 (void * __P, __mmask16 __M, __m256i __A)
+{
+  __builtin_ia32_pmovswb256mem_mask ((__v16qi *) __P, (__v16hi) __A, __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi16_storeu_epi8 (void * __P, __mmask16 __M, __m256i __A)
+{
+  __builtin_ia32_pmovuswb256mem_mask ((__v16qi*) __P, (__v16hi) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mulhrs_epi16(__m128i __W, __mmask8 __U, __m128i __X, __m128i __Y) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_mulhrs_epi16(__X, __Y),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mulhrs_epi16(__mmask8 __U, __m128i __X, __m128i __Y) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_mulhrs_epi16(__X, __Y),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mulhrs_epi16(__m256i __W, __mmask16 __U, __m256i __X, __m256i __Y) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                         (__v16hi)_mm256_mulhrs_epi16(__X, __Y),
+                                         (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mulhrs_epi16(__mmask16 __U, __m256i __X, __m256i __Y) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                         (__v16hi)_mm256_mulhrs_epi16(__X, __Y),
+                                         (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mulhi_epu16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_mulhi_epu16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mulhi_epu16(__mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_mulhi_epu16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mulhi_epu16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                          (__v16hi)_mm256_mulhi_epu16(__A, __B),
+                                          (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mulhi_epu16(__mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                          (__v16hi)_mm256_mulhi_epu16(__A, __B),
+                                          (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mulhi_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_mulhi_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mulhi_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_mulhi_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mulhi_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                          (__v16hi)_mm256_mulhi_epi16(__A, __B),
+                                          (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mulhi_epi16(__mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                          (__v16hi)_mm256_mulhi_epi16(__A, __B),
+                                          (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_unpackhi_epi8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                           (__v16qi)_mm_unpackhi_epi8(__A, __B),
+                                           (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_unpackhi_epi8(__mmask16 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                           (__v16qi)_mm_unpackhi_epi8(__A, __B),
+                                           (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_unpackhi_epi8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                        (__v32qi)_mm256_unpackhi_epi8(__A, __B),
+                                        (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpackhi_epi8(__mmask32 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                        (__v32qi)_mm256_unpackhi_epi8(__A, __B),
+                                        (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_unpackhi_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                           (__v8hi)_mm_unpackhi_epi16(__A, __B),
+                                           (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_unpackhi_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                           (__v8hi)_mm_unpackhi_epi16(__A, __B),
+                                           (__v8hi) _mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_unpackhi_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                       (__v16hi)_mm256_unpackhi_epi16(__A, __B),
+                                       (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpackhi_epi16(__mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                       (__v16hi)_mm256_unpackhi_epi16(__A, __B),
+                                       (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_unpacklo_epi8(__m128i __W, __mmask16 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                           (__v16qi)_mm_unpacklo_epi8(__A, __B),
+                                           (__v16qi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_unpacklo_epi8(__mmask16 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectb_128((__mmask16)__U,
+                                           (__v16qi)_mm_unpacklo_epi8(__A, __B),
+                                           (__v16qi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_unpacklo_epi8(__m256i __W, __mmask32 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                        (__v32qi)_mm256_unpacklo_epi8(__A, __B),
+                                        (__v32qi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpacklo_epi8(__mmask32 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectb_256((__mmask32)__U,
+                                        (__v32qi)_mm256_unpacklo_epi8(__A, __B),
+                                        (__v32qi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_unpacklo_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                           (__v8hi)_mm_unpacklo_epi16(__A, __B),
+                                           (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_unpacklo_epi16(__mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                           (__v8hi)_mm_unpacklo_epi16(__A, __B),
+                                           (__v8hi) _mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_unpacklo_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                       (__v16hi)_mm256_unpacklo_epi16(__A, __B),
+                                       (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpacklo_epi16(__mmask16 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                       (__v16hi)_mm256_unpacklo_epi16(__A, __B),
+                                       (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi8_epi16(__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_cvtepi8_epi16(__A),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi8_epi16(__mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_cvtepi8_epi16(__A),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi8_epi16(__m256i __W, __mmask16 __U, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_cvtepi8_epi16(__A),
+                                             (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi8_epi16(__mmask16 __U, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_cvtepi8_epi16(__A),
+                                             (__v16hi)_mm256_setzero_si256());
+}
+
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepu8_epi16(__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_cvtepu8_epi16(__A),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepu8_epi16(__mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_cvtepu8_epi16(__A),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepu8_epi16(__m256i __W, __mmask16 __U, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_cvtepu8_epi16(__A),
+                                             (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepu8_epi16 (__mmask16 __U, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                             (__v16hi)_mm256_cvtepu8_epi16(__A),
+                                             (__v16hi)_mm256_setzero_si256());
+}
+
+
+#define _mm_mask_shufflehi_epi16(W, U, A, imm) \
+  ((__m128i)__builtin_ia32_selectw_128((__mmask8)(U), \
+                                       (__v8hi)_mm_shufflehi_epi16((A), (imm)), \
+                                       (__v8hi)(__m128i)(W)))
+
+#define _mm_maskz_shufflehi_epi16(U, A, imm) \
+  ((__m128i)__builtin_ia32_selectw_128((__mmask8)(U), \
+                                       (__v8hi)_mm_shufflehi_epi16((A), (imm)), \
+                                       (__v8hi)_mm_setzero_si128()))
+
+#define _mm256_mask_shufflehi_epi16(W, U, A, imm) \
+  ((__m256i)__builtin_ia32_selectw_256((__mmask16)(U), \
+                                       (__v16hi)_mm256_shufflehi_epi16((A), (imm)), \
+                                       (__v16hi)(__m256i)(W)))
+
+#define _mm256_maskz_shufflehi_epi16(U, A, imm) \
+  ((__m256i)__builtin_ia32_selectw_256((__mmask16)(U), \
+                                       (__v16hi)_mm256_shufflehi_epi16((A), (imm)), \
+                                       (__v16hi)_mm256_setzero_si256()))
+
+#define _mm_mask_shufflelo_epi16(W, U, A, imm) \
+  ((__m128i)__builtin_ia32_selectw_128((__mmask8)(U), \
+                                       (__v8hi)_mm_shufflelo_epi16((A), (imm)), \
+                                       (__v8hi)(__m128i)(W)))
+
+#define _mm_maskz_shufflelo_epi16(U, A, imm) \
+  ((__m128i)__builtin_ia32_selectw_128((__mmask8)(U), \
+                                       (__v8hi)_mm_shufflelo_epi16((A), (imm)), \
+                                       (__v8hi)_mm_setzero_si128()))
+
+#define _mm256_mask_shufflelo_epi16(W, U, A, imm) \
+  ((__m256i)__builtin_ia32_selectw_256((__mmask16)(U), \
+                                       (__v16hi)_mm256_shufflelo_epi16((A), \
+                                                                       (imm)), \
+                                       (__v16hi)(__m256i)(W)))
+
+#define _mm256_maskz_shufflelo_epi16(U, A, imm) \
+  ((__m256i)__builtin_ia32_selectw_256((__mmask16)(U), \
+                                       (__v16hi)_mm256_shufflelo_epi16((A), \
+                                                                       (imm)), \
+                                       (__v16hi)_mm256_setzero_si256()))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sllv_epi16(__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_psllv16hi((__v16hi)__A, (__v16hi)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sllv_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_sllv_epi16(__A, __B),
+                                           (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sllv_epi16(__mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_sllv_epi16(__A, __B),
+                                           (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_sllv_epi16(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_psllv8hi((__v8hi)__A, (__v8hi)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sllv_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_sllv_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sllv_epi16(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_sllv_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sll_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_sll_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sll_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_sll_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sll_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                          (__v16hi)_mm256_sll_epi16(__A, __B),
+                                          (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sll_epi16(__mmask16 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                          (__v16hi)_mm256_sll_epi16(__A, __B),
+                                          (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_slli_epi16(__m128i __W, __mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_slli_epi16(__A, (int)__B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_slli_epi16 (__mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_slli_epi16(__A, (int)__B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_slli_epi16(__m256i __W, __mmask16 __U, __m256i __A,
+                       unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                         (__v16hi)_mm256_slli_epi16(__A, (int)__B),
+                                         (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_slli_epi16(__mmask16 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                         (__v16hi)_mm256_slli_epi16(__A, (int)__B),
+                                         (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srlv_epi16(__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_psrlv16hi((__v16hi)__A, (__v16hi)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srlv_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_srlv_epi16(__A, __B),
+                                           (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srlv_epi16(__mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_srlv_epi16(__A, __B),
+                                           (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_srlv_epi16(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_psrlv8hi((__v8hi)__A, (__v8hi)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srlv_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_srlv_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srlv_epi16(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_srlv_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srav_epi16(__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_psrav16hi((__v16hi)__A, (__v16hi)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srav_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_srav_epi16(__A, __B),
+                                           (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srav_epi16(__mmask16 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                           (__v16hi)_mm256_srav_epi16(__A, __B),
+                                           (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_srav_epi16(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_psrav8hi((__v8hi)__A, (__v8hi)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srav_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_srav_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srav_epi16(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_srav_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sra_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_sra_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sra_epi16(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_sra_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sra_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                          (__v16hi)_mm256_sra_epi16(__A, __B),
+                                          (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sra_epi16(__mmask16 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                          (__v16hi)_mm256_sra_epi16(__A, __B),
+                                          (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srai_epi16(__m128i __W, __mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_srai_epi16(__A, (int)__B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srai_epi16(__mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_srai_epi16(__A, (int)__B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srai_epi16(__m256i __W, __mmask16 __U, __m256i __A,
+                       unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                         (__v16hi)_mm256_srai_epi16(__A, (int)__B),
+                                         (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srai_epi16(__mmask16 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                         (__v16hi)_mm256_srai_epi16(__A, (int)__B),
+                                         (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srl_epi16(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_srl_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srl_epi16 (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_srl_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srl_epi16(__m256i __W, __mmask16 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                          (__v16hi)_mm256_srl_epi16(__A, __B),
+                                          (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srl_epi16(__mmask16 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                          (__v16hi)_mm256_srl_epi16(__A, __B),
+                                          (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srli_epi16(__m128i __W, __mmask8 __U, __m128i __A, int __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_srli_epi16(__A, __B),
+                                             (__v8hi)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srli_epi16 (__mmask8 __U, __m128i __A, int __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__U,
+                                             (__v8hi)_mm_srli_epi16(__A, __B),
+                                             (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srli_epi16(__m256i __W, __mmask16 __U, __m256i __A, int __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                         (__v16hi)_mm256_srli_epi16(__A, __B),
+                                         (__v16hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srli_epi16(__mmask16 __U, __m256i __A, int __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__U,
+                                         (__v16hi)_mm256_srli_epi16(__A, __B),
+                                         (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mov_epi16 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_selectw_128 ((__mmask8) __U,
+                (__v8hi) __A,
+                (__v8hi) __W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mov_epi16 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_selectw_128 ((__mmask8) __U,
+                (__v8hi) __A,
+                (__v8hi) _mm_setzero_si128 ());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mov_epi16 (__m256i __W, __mmask16 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_selectw_256 ((__mmask16) __U,
+                (__v16hi) __A,
+                (__v16hi) __W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mov_epi16 (__mmask16 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_selectw_256 ((__mmask16) __U,
+                (__v16hi) __A,
+                (__v16hi) _mm256_setzero_si256 ());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mov_epi8 (__m128i __W, __mmask16 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_selectb_128 ((__mmask16) __U,
+                (__v16qi) __A,
+                (__v16qi) __W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mov_epi8 (__mmask16 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_selectb_128 ((__mmask16) __U,
+                (__v16qi) __A,
+                (__v16qi) _mm_setzero_si128 ());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mov_epi8 (__m256i __W, __mmask32 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_selectb_256 ((__mmask32) __U,
+                (__v32qi) __A,
+                (__v32qi) __W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mov_epi8 (__mmask32 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_selectb_256 ((__mmask32) __U,
+                (__v32qi) __A,
+                (__v32qi) _mm256_setzero_si256 ());
+}
+
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_set1_epi8 (__m128i __O, __mmask16 __M, char __A)
+{
+  return (__m128i) __builtin_ia32_selectb_128(__M,
+                                              (__v16qi) _mm_set1_epi8(__A),
+                                              (__v16qi) __O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_set1_epi8 (__mmask16 __M, char __A)
+{
+ return (__m128i) __builtin_ia32_selectb_128(__M,
+                                             (__v16qi) _mm_set1_epi8(__A),
+                                             (__v16qi) _mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_set1_epi8 (__m256i __O, __mmask32 __M, char __A)
+{
+  return (__m256i) __builtin_ia32_selectb_256(__M,
+                                              (__v32qi) _mm256_set1_epi8(__A),
+                                              (__v32qi) __O);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_set1_epi8 (__mmask32 __M, char __A)
+{
+  return (__m256i) __builtin_ia32_selectb_256(__M,
+                                              (__v32qi) _mm256_set1_epi8(__A),
+                                              (__v32qi) _mm256_setzero_si256());
+}
+
+static __inline __m128i __DEFAULT_FN_ATTRS128
+_mm_loadu_epi16 (void const *__P)
+{
+  struct __loadu_epi16 {
+    __m128i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi16*)__P)->__v;
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_loadu_epi16 (__m128i __W, __mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_loaddquhi128_mask ((const __v8hi *) __P,
+                 (__v8hi) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_loadu_epi16 (__mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_loaddquhi128_mask ((const __v8hi *) __P,
+                 (__v8hi)
+                 _mm_setzero_si128 (),
+                 (__mmask8) __U);
+}
+
+static __inline __m256i __DEFAULT_FN_ATTRS256
+_mm256_loadu_epi16 (void const *__P)
+{
+  struct __loadu_epi16 {
+    __m256i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi16*)__P)->__v;
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_loadu_epi16 (__m256i __W, __mmask16 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_loaddquhi256_mask ((const __v16hi *) __P,
+                 (__v16hi) __W,
+                 (__mmask16) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_loadu_epi16 (__mmask16 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_loaddquhi256_mask ((const __v16hi *) __P,
+                 (__v16hi)
+                 _mm256_setzero_si256 (),
+                 (__mmask16) __U);
+}
+
+static __inline __m128i __DEFAULT_FN_ATTRS128
+_mm_loadu_epi8 (void const *__P)
+{
+  struct __loadu_epi8 {
+    __m128i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi8*)__P)->__v;
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_loadu_epi8 (__m128i __W, __mmask16 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_loaddquqi128_mask ((const __v16qi *) __P,
+                 (__v16qi) __W,
+                 (__mmask16) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_loadu_epi8 (__mmask16 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_loaddquqi128_mask ((const __v16qi *) __P,
+                 (__v16qi)
+                 _mm_setzero_si128 (),
+                 (__mmask16) __U);
+}
+
+static __inline __m256i __DEFAULT_FN_ATTRS256
+_mm256_loadu_epi8 (void const *__P)
+{
+  struct __loadu_epi8 {
+    __m256i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi8*)__P)->__v;
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_loadu_epi8 (__m256i __W, __mmask32 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_loaddquqi256_mask ((const __v32qi *) __P,
+                 (__v32qi) __W,
+                 (__mmask32) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_loadu_epi8 (__mmask32 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_loaddquqi256_mask ((const __v32qi *) __P,
+                 (__v32qi)
+                 _mm256_setzero_si256 (),
+                 (__mmask32) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS128
+_mm_storeu_epi16 (void *__P, __m128i __A)
+{
+  struct __storeu_epi16 {
+    __m128i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi16*)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_storeu_epi16 (void *__P, __mmask8 __U, __m128i __A)
+{
+  __builtin_ia32_storedquhi128_mask ((__v8hi *) __P,
+             (__v8hi) __A,
+             (__mmask8) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS256
+_mm256_storeu_epi16 (void *__P, __m256i __A)
+{
+  struct __storeu_epi16 {
+    __m256i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi16*)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_storeu_epi16 (void *__P, __mmask16 __U, __m256i __A)
+{
+  __builtin_ia32_storedquhi256_mask ((__v16hi *) __P,
+             (__v16hi) __A,
+             (__mmask16) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS128
+_mm_storeu_epi8 (void *__P, __m128i __A)
+{
+  struct __storeu_epi8 {
+    __m128i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi8*)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_storeu_epi8 (void *__P, __mmask16 __U, __m128i __A)
+{
+  __builtin_ia32_storedquqi128_mask ((__v16qi *) __P,
+             (__v16qi) __A,
+             (__mmask16) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS256
+_mm256_storeu_epi8 (void *__P, __m256i __A)
+{
+  struct __storeu_epi8 {
+    __m256i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi8*)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_storeu_epi8 (void *__P, __mmask32 __U, __m256i __A)
+{
+  __builtin_ia32_storedquqi256_mask ((__v32qi *) __P,
+             (__v32qi) __A,
+             (__mmask32) __U);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS128
+_mm_test_epi8_mask (__m128i __A, __m128i __B)
+{
+  return _mm_cmpneq_epi8_mask (_mm_and_si128(__A, __B), _mm_setzero_si128());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS128
+_mm_mask_test_epi8_mask (__mmask16 __U, __m128i __A, __m128i __B)
+{
+  return _mm_mask_cmpneq_epi8_mask (__U, _mm_and_si128 (__A, __B),
+                                    _mm_setzero_si128());
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS256
+_mm256_test_epi8_mask (__m256i __A, __m256i __B)
+{
+  return _mm256_cmpneq_epi8_mask (_mm256_and_si256(__A, __B),
+                                  _mm256_setzero_si256());
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS256
+_mm256_mask_test_epi8_mask (__mmask32 __U, __m256i __A, __m256i __B)
+{
+  return _mm256_mask_cmpneq_epi8_mask (__U, _mm256_and_si256(__A, __B),
+                                       _mm256_setzero_si256());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_test_epi16_mask (__m128i __A, __m128i __B)
+{
+  return _mm_cmpneq_epi16_mask (_mm_and_si128 (__A, __B), _mm_setzero_si128());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_mask_test_epi16_mask (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return _mm_mask_cmpneq_epi16_mask (__U, _mm_and_si128 (__A, __B),
+                                     _mm_setzero_si128());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS256
+_mm256_test_epi16_mask (__m256i __A, __m256i __B)
+{
+  return _mm256_cmpneq_epi16_mask (_mm256_and_si256 (__A, __B),
+                                   _mm256_setzero_si256 ());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS256
+_mm256_mask_test_epi16_mask (__mmask16 __U, __m256i __A, __m256i __B)
+{
+  return _mm256_mask_cmpneq_epi16_mask (__U, _mm256_and_si256(__A, __B),
+                                        _mm256_setzero_si256());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS128
+_mm_testn_epi8_mask (__m128i __A, __m128i __B)
+{
+  return _mm_cmpeq_epi8_mask (_mm_and_si128 (__A, __B), _mm_setzero_si128());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS128
+_mm_mask_testn_epi8_mask (__mmask16 __U, __m128i __A, __m128i __B)
+{
+  return _mm_mask_cmpeq_epi8_mask (__U, _mm_and_si128 (__A, __B),
+                                  _mm_setzero_si128());
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS256
+_mm256_testn_epi8_mask (__m256i __A, __m256i __B)
+{
+  return _mm256_cmpeq_epi8_mask (_mm256_and_si256 (__A, __B),
+                                 _mm256_setzero_si256());
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS256
+_mm256_mask_testn_epi8_mask (__mmask32 __U, __m256i __A, __m256i __B)
+{
+  return _mm256_mask_cmpeq_epi8_mask (__U, _mm256_and_si256 (__A, __B),
+                                      _mm256_setzero_si256());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_testn_epi16_mask (__m128i __A, __m128i __B)
+{
+  return _mm_cmpeq_epi16_mask (_mm_and_si128 (__A, __B), _mm_setzero_si128());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_mask_testn_epi16_mask (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return _mm_mask_cmpeq_epi16_mask (__U, _mm_and_si128(__A, __B), _mm_setzero_si128());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS256
+_mm256_testn_epi16_mask (__m256i __A, __m256i __B)
+{
+  return _mm256_cmpeq_epi16_mask (_mm256_and_si256(__A, __B),
+                                  _mm256_setzero_si256());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS256
+_mm256_mask_testn_epi16_mask (__mmask16 __U, __m256i __A, __m256i __B)
+{
+  return _mm256_mask_cmpeq_epi16_mask (__U, _mm256_and_si256 (__A, __B),
+                                       _mm256_setzero_si256());
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS128
+_mm_movepi8_mask (__m128i __A)
+{
+  return (__mmask16) __builtin_ia32_cvtb2mask128 ((__v16qi) __A);
+}
+
+static __inline__ __mmask32 __DEFAULT_FN_ATTRS256
+_mm256_movepi8_mask (__m256i __A)
+{
+  return (__mmask32) __builtin_ia32_cvtb2mask256 ((__v32qi) __A);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_movepi16_mask (__m128i __A)
+{
+  return (__mmask8) __builtin_ia32_cvtw2mask128 ((__v8hi) __A);
+}
+
+static __inline__ __mmask16 __DEFAULT_FN_ATTRS256
+_mm256_movepi16_mask (__m256i __A)
+{
+  return (__mmask16) __builtin_ia32_cvtw2mask256 ((__v16hi) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_movm_epi8 (__mmask16 __A)
+{
+  return (__m128i) __builtin_ia32_cvtmask2b128 (__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_movm_epi8 (__mmask32 __A)
+{
+  return (__m256i) __builtin_ia32_cvtmask2b256 (__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_movm_epi16 (__mmask8 __A)
+{
+  return (__m128i) __builtin_ia32_cvtmask2w128 (__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_movm_epi16 (__mmask16 __A)
+{
+  return (__m256i) __builtin_ia32_cvtmask2w256 (__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_broadcastb_epi8 (__m128i __O, __mmask16 __M, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectb_128(__M,
+                                             (__v16qi) _mm_broadcastb_epi8(__A),
+                                             (__v16qi) __O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_broadcastb_epi8 (__mmask16 __M, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectb_128(__M,
+                                             (__v16qi) _mm_broadcastb_epi8(__A),
+                                             (__v16qi) _mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcastb_epi8 (__m256i __O, __mmask32 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectb_256(__M,
+                                             (__v32qi) _mm256_broadcastb_epi8(__A),
+                                             (__v32qi) __O);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcastb_epi8 (__mmask32 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectb_256(__M,
+                                             (__v32qi) _mm256_broadcastb_epi8(__A),
+                                             (__v32qi) _mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_broadcastw_epi16 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectw_128(__M,
+                                             (__v8hi) _mm_broadcastw_epi16(__A),
+                                             (__v8hi) __O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_broadcastw_epi16 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectw_128(__M,
+                                             (__v8hi) _mm_broadcastw_epi16(__A),
+                                             (__v8hi) _mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcastw_epi16 (__m256i __O, __mmask16 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectw_256(__M,
+                                             (__v16hi) _mm256_broadcastw_epi16(__A),
+                                             (__v16hi) __O);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcastw_epi16 (__mmask16 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectw_256(__M,
+                                             (__v16hi) _mm256_broadcastw_epi16(__A),
+                                             (__v16hi) _mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_set1_epi16 (__m256i __O, __mmask16 __M, short __A)
+{
+  return (__m256i) __builtin_ia32_selectw_256 (__M,
+                                               (__v16hi) _mm256_set1_epi16(__A),
+                                               (__v16hi) __O);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_set1_epi16 (__mmask16 __M, short __A)
+{
+  return (__m256i) __builtin_ia32_selectw_256(__M,
+                                              (__v16hi)_mm256_set1_epi16(__A),
+                                              (__v16hi) _mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_set1_epi16 (__m128i __O, __mmask8 __M, short __A)
+{
+  return (__m128i) __builtin_ia32_selectw_128(__M,
+                                              (__v8hi) _mm_set1_epi16(__A),
+                                              (__v8hi) __O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_set1_epi16 (__mmask8 __M, short __A)
+{
+  return (__m128i) __builtin_ia32_selectw_128(__M,
+                                              (__v8hi) _mm_set1_epi16(__A),
+                                              (__v8hi) _mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_permutexvar_epi16 (__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_permvarhi128((__v8hi) __B, (__v8hi) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_permutexvar_epi16 (__mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                        (__v8hi)_mm_permutexvar_epi16(__A, __B),
+                                        (__v8hi) _mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_permutexvar_epi16 (__m128i __W, __mmask8 __M, __m128i __A,
+          __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectw_128((__mmask8)__M,
+                                        (__v8hi)_mm_permutexvar_epi16(__A, __B),
+                                        (__v8hi)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_permutexvar_epi16 (__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_permvarhi256((__v16hi) __B, (__v16hi) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_permutexvar_epi16 (__mmask16 __M, __m256i __A,
+        __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                    (__v16hi)_mm256_permutexvar_epi16(__A, __B),
+                                    (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_permutexvar_epi16 (__m256i __W, __mmask16 __M, __m256i __A,
+             __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectw_256((__mmask16)__M,
+                                    (__v16hi)_mm256_permutexvar_epi16(__A, __B),
+                                    (__v16hi)__W);
+}
+
+#define _mm_mask_alignr_epi8(W, U, A, B, N) \
+  ((__m128i)__builtin_ia32_selectb_128((__mmask16)(U), \
+                                 (__v16qi)_mm_alignr_epi8((A), (B), (int)(N)), \
+                                 (__v16qi)(__m128i)(W)))
+
+#define _mm_maskz_alignr_epi8(U, A, B, N) \
+  ((__m128i)__builtin_ia32_selectb_128((__mmask16)(U), \
+                                 (__v16qi)_mm_alignr_epi8((A), (B), (int)(N)), \
+                                 (__v16qi)_mm_setzero_si128()))
+
+#define _mm256_mask_alignr_epi8(W, U, A, B, N) \
+  ((__m256i)__builtin_ia32_selectb_256((__mmask32)(U), \
+                              (__v32qi)_mm256_alignr_epi8((A), (B), (int)(N)), \
+                              (__v32qi)(__m256i)(W)))
+
+#define _mm256_maskz_alignr_epi8(U, A, B, N) \
+  ((__m256i)__builtin_ia32_selectb_256((__mmask32)(U), \
+                              (__v32qi)_mm256_alignr_epi8((A), (B), (int)(N)), \
+                              (__v32qi)_mm256_setzero_si256()))
+
+#define _mm_dbsad_epu8(A, B, imm) \
+  ((__m128i)__builtin_ia32_dbpsadbw128((__v16qi)(__m128i)(A), \
+                                       (__v16qi)(__m128i)(B), (int)(imm)))
+
+#define _mm_mask_dbsad_epu8(W, U, A, B, imm) \
+  ((__m128i)__builtin_ia32_selectw_128((__mmask8)(U), \
+                                      (__v8hi)_mm_dbsad_epu8((A), (B), (imm)), \
+                                      (__v8hi)(__m128i)(W)))
+
+#define _mm_maskz_dbsad_epu8(U, A, B, imm) \
+  ((__m128i)__builtin_ia32_selectw_128((__mmask8)(U), \
+                                      (__v8hi)_mm_dbsad_epu8((A), (B), (imm)), \
+                                      (__v8hi)_mm_setzero_si128()))
+
+#define _mm256_dbsad_epu8(A, B, imm) \
+  ((__m256i)__builtin_ia32_dbpsadbw256((__v32qi)(__m256i)(A), \
+                                       (__v32qi)(__m256i)(B), (int)(imm)))
+
+#define _mm256_mask_dbsad_epu8(W, U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectw_256((__mmask16)(U), \
+                                  (__v16hi)_mm256_dbsad_epu8((A), (B), (imm)), \
+                                  (__v16hi)(__m256i)(W)))
+
+#define _mm256_maskz_dbsad_epu8(U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectw_256((__mmask16)(U), \
+                                  (__v16hi)_mm256_dbsad_epu8((A), (B), (imm)), \
+                                  (__v16hi)_mm256_setzero_si256()))
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_reduce_add_epi16(__m128i __W) {
+  return __builtin_reduce_add((__v8hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_reduce_mul_epi16(__m128i __W) {
+  return __builtin_reduce_mul((__v8hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_reduce_and_epi16(__m128i __W) {
+  return __builtin_reduce_and((__v8hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_reduce_or_epi16(__m128i __W) {
+  return __builtin_reduce_or((__v8hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_add_epi16( __mmask8 __M, __m128i __W) {
+  __W = _mm_maskz_mov_epi16(__M, __W);
+  return __builtin_reduce_add((__v8hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_mul_epi16( __mmask8 __M, __m128i __W) {
+  __W = _mm_mask_mov_epi16(_mm_set1_epi16(1), __M, __W);
+  return __builtin_reduce_mul((__v8hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_and_epi16( __mmask8 __M, __m128i __W) {
+  __W = _mm_mask_mov_epi16(_mm_set1_epi16(-1), __M, __W);
+  return __builtin_reduce_and((__v8hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_or_epi16(__mmask8 __M, __m128i __W) {
+  __W = _mm_maskz_mov_epi16(__M, __W);
+  return __builtin_reduce_or((__v8hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_reduce_max_epi16(__m128i __V) {
+  return __builtin_reduce_max((__v8hi)__V);
+}
+
+static __inline__ unsigned short __DEFAULT_FN_ATTRS128
+_mm_reduce_max_epu16(__m128i __V) {
+  return __builtin_reduce_max((__v8hu)__V);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_reduce_min_epi16(__m128i __V) {
+  return __builtin_reduce_min((__v8hi)__V);
+}
+
+static __inline__ unsigned short __DEFAULT_FN_ATTRS128
+_mm_reduce_min_epu16(__m128i __V) {
+  return __builtin_reduce_min((__v8hu)__V);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_max_epi16(__mmask16 __M, __m128i __V) {
+  __V = _mm_mask_mov_epi16(_mm_set1_epi16(-32767-1), __M, __V);
+  return __builtin_reduce_max((__v8hi)__V);
+}
+
+static __inline__ unsigned short __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_max_epu16(__mmask16 __M, __m128i __V) {
+  __V = _mm_maskz_mov_epi16(__M, __V);
+  return __builtin_reduce_max((__v8hu)__V);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_min_epi16(__mmask16 __M, __m128i __V) {
+  __V = _mm_mask_mov_epi16(_mm_set1_epi16(32767), __M, __V);
+  return __builtin_reduce_min((__v8hi)__V);
+}
+
+static __inline__ unsigned short __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_min_epu16(__mmask16 __M, __m128i __V) {
+  __V = _mm_mask_mov_epi16(_mm_set1_epi16(-1), __M, __V);
+  return __builtin_reduce_min((__v8hu)__V);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_reduce_add_epi16(__m256i __W) {
+  return __builtin_reduce_add((__v16hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_reduce_mul_epi16(__m256i __W) {
+  return __builtin_reduce_mul((__v16hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_reduce_and_epi16(__m256i __W) {
+  return __builtin_reduce_and((__v16hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_reduce_or_epi16(__m256i __W) {
+  return __builtin_reduce_or((__v16hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_add_epi16( __mmask16 __M, __m256i __W) {
+  __W = _mm256_maskz_mov_epi16(__M, __W);
+  return __builtin_reduce_add((__v16hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_mul_epi16( __mmask16 __M, __m256i __W) {
+  __W = _mm256_mask_mov_epi16(_mm256_set1_epi16(1), __M, __W);
+  return __builtin_reduce_mul((__v16hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_and_epi16( __mmask16 __M, __m256i __W) {
+  __W = _mm256_mask_mov_epi16(_mm256_set1_epi16(-1), __M, __W);
+  return __builtin_reduce_and((__v16hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_or_epi16(__mmask16 __M, __m256i __W) {
+  __W = _mm256_maskz_mov_epi16(__M, __W);
+  return __builtin_reduce_or((__v16hi)__W);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_reduce_max_epi16(__m256i __V) {
+  return __builtin_reduce_max((__v16hi)__V);
+}
+
+static __inline__ unsigned short __DEFAULT_FN_ATTRS256
+_mm256_reduce_max_epu16(__m256i __V) {
+  return __builtin_reduce_max((__v16hu)__V);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_reduce_min_epi16(__m256i __V) {
+  return __builtin_reduce_min((__v16hi)__V);
+}
+
+static __inline__ unsigned short __DEFAULT_FN_ATTRS256
+_mm256_reduce_min_epu16(__m256i __V) {
+  return __builtin_reduce_min((__v16hu)__V);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_max_epi16(__mmask16 __M, __m256i __V) {
+  __V = _mm256_mask_mov_epi16(_mm256_set1_epi16(-32767-1), __M, __V);
+  return __builtin_reduce_max((__v16hi)__V);
+}
+
+static __inline__ unsigned short __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_max_epu16(__mmask16 __M, __m256i __V) {
+  __V = _mm256_maskz_mov_epi16(__M, __V);
+  return __builtin_reduce_max((__v16hu)__V);
+}
+
+static __inline__ short __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_min_epi16(__mmask16 __M, __m256i __V) {
+  __V = _mm256_mask_mov_epi16(_mm256_set1_epi16(32767), __M, __V);
+  return __builtin_reduce_min((__v16hi)__V);
+}
+
+static __inline__ unsigned short __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_min_epu16(__mmask16 __M, __m256i __V) {
+  __V = _mm256_mask_mov_epi16(_mm256_set1_epi16(-1), __M, __V);
+  return __builtin_reduce_min((__v16hu)__V);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_reduce_add_epi8(__m128i __W) {
+  return __builtin_reduce_add((__v16qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_reduce_mul_epi8(__m128i __W) {
+  return __builtin_reduce_mul((__v16qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_reduce_and_epi8(__m128i __W) {
+  return __builtin_reduce_and((__v16qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_reduce_or_epi8(__m128i __W) {
+  return __builtin_reduce_or((__v16qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_add_epi8(__mmask16 __M, __m128i __W) {
+  __W = _mm_maskz_mov_epi8(__M, __W);
+  return __builtin_reduce_add((__v16qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_mul_epi8(__mmask16 __M, __m128i __W) {
+  __W = _mm_mask_mov_epi8(_mm_set1_epi8(1), __M, __W);
+  return __builtin_reduce_mul((__v16qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_and_epi8(__mmask16 __M, __m128i __W) {
+  __W = _mm_mask_mov_epi8(_mm_set1_epi8(-1), __M, __W);
+  return __builtin_reduce_and((__v16qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_or_epi8(__mmask16 __M, __m128i __W) {
+  __W = _mm_maskz_mov_epi8(__M, __W);
+  return __builtin_reduce_or((__v16qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_reduce_max_epi8(__m128i __V) {
+  return __builtin_reduce_max((__v16qs)__V);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS128
+_mm_reduce_max_epu8(__m128i __V) {
+  return __builtin_reduce_max((__v16qu)__V);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_reduce_min_epi8(__m128i __V) {
+  return __builtin_reduce_min((__v16qs)__V);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS128
+_mm_reduce_min_epu8(__m128i __V) {
+  return __builtin_reduce_min((__v16qu)__V);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_max_epi8(__mmask16 __M, __m128i __V) {
+  __V = _mm_mask_mov_epi8(_mm_set1_epi8(-127-1), __M, __V);
+  return __builtin_reduce_max((__v16qs)__V);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_max_epu8(__mmask16 __M, __m128i __V) {
+  __V = _mm_maskz_mov_epi8(__M, __V);
+  return __builtin_reduce_max((__v16qu)__V);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_min_epi8(__mmask16 __M, __m128i __V) {
+  __V = _mm_mask_mov_epi8(_mm_set1_epi8(127), __M, __V);
+  return __builtin_reduce_min((__v16qs)__V);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS128
+_mm_mask_reduce_min_epu8(__mmask16 __M, __m128i __V) {
+  __V = _mm_mask_mov_epi8(_mm_set1_epi8(-1), __M, __V);
+  return __builtin_reduce_min((__v16qu)__V);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_reduce_add_epi8(__m256i __W) {
+  return __builtin_reduce_add((__v32qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_reduce_mul_epi8(__m256i __W) {
+  return __builtin_reduce_mul((__v32qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_reduce_and_epi8(__m256i __W) {
+  return __builtin_reduce_and((__v32qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_reduce_or_epi8(__m256i __W) {
+  return __builtin_reduce_or((__v32qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_add_epi8(__mmask32 __M, __m256i __W) {
+  __W = _mm256_maskz_mov_epi8(__M, __W);
+  return __builtin_reduce_add((__v32qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_mul_epi8(__mmask32 __M, __m256i __W) {
+  __W = _mm256_mask_mov_epi8(_mm256_set1_epi8(1), __M, __W);
+  return __builtin_reduce_mul((__v32qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_and_epi8(__mmask32 __M, __m256i __W) {
+  __W = _mm256_mask_mov_epi8(_mm256_set1_epi8(-1), __M, __W);
+  return __builtin_reduce_and((__v32qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_or_epi8(__mmask32 __M, __m256i __W) {
+  __W = _mm256_maskz_mov_epi8(__M, __W);
+  return __builtin_reduce_or((__v32qs)__W);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_reduce_max_epi8(__m256i __V) {
+  return __builtin_reduce_max((__v32qs)__V);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS256
+_mm256_reduce_max_epu8(__m256i __V) {
+  return __builtin_reduce_max((__v32qu)__V);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_reduce_min_epi8(__m256i __V) {
+  return __builtin_reduce_min((__v32qs)__V);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS256
+_mm256_reduce_min_epu8(__m256i __V) {
+  return __builtin_reduce_min((__v32qu)__V);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_max_epi8(__mmask32 __M, __m256i __V) {
+  __V = _mm256_mask_mov_epi8(_mm256_set1_epi8(-127-1), __M, __V);
+  return __builtin_reduce_max((__v32qs)__V);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_max_epu8(__mmask32 __M, __m256i __V) {
+  __V = _mm256_maskz_mov_epi8(__M, __V);
+  return __builtin_reduce_max((__v32qu)__V);
+}
+
+static __inline__ signed char __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_min_epi8(__mmask32 __M, __m256i __V) {
+  __V = _mm256_mask_mov_epi8(_mm256_set1_epi8(127), __M, __V);
+  return __builtin_reduce_min((__v32qs)__V);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS256
+_mm256_mask_reduce_min_epu8(__mmask32 __M, __m256i __V) {
+  __V = _mm256_mask_mov_epi8(_mm256_set1_epi8(-1), __M, __V);
+  return __builtin_reduce_min((__v32qu)__V);
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif /* __AVX512VLBWINTRIN_H */
diff --git a/third_party/intel/clang/avx512vlcdintrin.h b/third_party/intel/clang/avx512vlcdintrin.h
new file mode 100644
index 000000000..923e2c551
--- /dev/null
+++ b/third_party/intel/clang/avx512vlcdintrin.h
@@ -0,0 +1,230 @@
+/*===---- avx512vlcdintrin.h - AVX512VL and AVX512CD intrinsics ------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vlcdintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VLCDINTRIN_H
+#define __AVX512VLCDINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512cd,no-evex512"),                   \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512cd,no-evex512"),                   \
+                 __min_vector_width__(256)))
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_broadcastmb_epi64 (__mmask8 __A)
+{
+  return (__m128i) _mm_set1_epi64x((long long) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_broadcastmb_epi64 (__mmask8 __A)
+{
+  return (__m256i) _mm256_set1_epi64x((long long)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_broadcastmw_epi32 (__mmask16 __A)
+{
+  return (__m128i) _mm_set1_epi32((int)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_broadcastmw_epi32 (__mmask16 __A)
+{
+  return (__m256i) _mm256_set1_epi32((int)__A);
+}
+
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_conflict_epi64 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpconflictdi_128 ((__v2di) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_conflict_epi64 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_conflict_epi64(__A),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_conflict_epi64 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_conflict_epi64(__A),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_conflict_epi64 (__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpconflictdi_256 ((__v4di) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_conflict_epi64 (__m256i __W, __mmask8 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_conflict_epi64(__A),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_conflict_epi64 (__mmask8 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_conflict_epi64(__A),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_conflict_epi32 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vpconflictsi_128 ((__v4si) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_conflict_epi32 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_conflict_epi32(__A),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_conflict_epi32 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_conflict_epi32(__A),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_conflict_epi32 (__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vpconflictsi_256 ((__v8si) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_conflict_epi32 (__m256i __W, __mmask8 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_conflict_epi32(__A),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_conflict_epi32 (__mmask8 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_conflict_epi32(__A),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_lzcnt_epi32 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vplzcntd_128 ((__v4si) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_lzcnt_epi32 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_lzcnt_epi32(__A),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_lzcnt_epi32 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_lzcnt_epi32(__A),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_lzcnt_epi32 (__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vplzcntd_256 ((__v8si) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_lzcnt_epi32 (__m256i __W, __mmask8 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_lzcnt_epi32(__A),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_lzcnt_epi32 (__mmask8 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_lzcnt_epi32(__A),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_lzcnt_epi64 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_vplzcntq_128 ((__v2di) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_lzcnt_epi64 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_lzcnt_epi64(__A),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_lzcnt_epi64 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_lzcnt_epi64(__A),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_lzcnt_epi64 (__m256i __A)
+{
+  return (__m256i) __builtin_ia32_vplzcntq_256 ((__v4di) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_lzcnt_epi64 (__m256i __W, __mmask8 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_lzcnt_epi64(__A),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_lzcnt_epi64 (__mmask8 __U, __m256i __A)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_lzcnt_epi64(__A),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif /* __AVX512VLCDINTRIN_H */
diff --git a/third_party/intel/clang/avx512vldqintrin.h b/third_party/intel/clang/avx512vldqintrin.h
new file mode 100644
index 000000000..272cdd89e
--- /dev/null
+++ b/third_party/intel/clang/avx512vldqintrin.h
@@ -0,0 +1,1173 @@
+/*===---- avx512vldqintrin.h - AVX512VL and AVX512DQ intrinsics ------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vldqintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VLDQINTRIN_H
+#define __AVX512VLDQINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512dq,no-evex512"),                   \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512dq,no-evex512"),                   \
+                 __min_vector_width__(256)))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mullo_epi64 (__m256i __A, __m256i __B) {
+  return (__m256i) ((__v4du) __A * (__v4du) __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mullo_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_mullo_epi64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mullo_epi64(__mmask8 __U, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_mullo_epi64(__A, __B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mullo_epi64 (__m128i __A, __m128i __B) {
+  return (__m128i) ((__v2du) __A * (__v2du) __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mullo_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_mullo_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mullo_epi64(__mmask8 __U, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_mullo_epi64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_andnot_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_andnot_pd(__A, __B),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_andnot_pd(__mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_andnot_pd(__A, __B),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_andnot_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_andnot_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_andnot_pd(__mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_andnot_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_andnot_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_andnot_ps(__A, __B),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_andnot_ps(__mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_andnot_ps(__A, __B),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_andnot_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_andnot_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_andnot_ps(__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_andnot_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_and_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_and_pd(__A, __B),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_and_pd(__mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_and_pd(__A, __B),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_and_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_and_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_and_pd(__mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_and_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_and_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_and_ps(__A, __B),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_and_ps(__mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_and_ps(__A, __B),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_and_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_and_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_and_ps(__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_and_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_xor_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_xor_pd(__A, __B),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_xor_pd(__mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_xor_pd(__A, __B),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_xor_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_xor_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_xor_pd (__mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_xor_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_xor_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_xor_ps(__A, __B),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_xor_ps(__mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_xor_ps(__A, __B),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_xor_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_xor_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_xor_ps(__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_xor_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_or_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_or_pd(__A, __B),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_or_pd(__mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_or_pd(__A, __B),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_or_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_or_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_or_pd(__mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_or_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_or_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_or_ps(__A, __B),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_or_ps(__mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_or_ps(__A, __B),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_or_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_or_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_or_ps(__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_or_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtpd_epi64 (__m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2qq128_mask ((__v2df) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtpd_epi64 (__m128i __W, __mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2qq128_mask ((__v2df) __A,
+                (__v2di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtpd_epi64 (__mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2qq128_mask ((__v2df) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtpd_epi64 (__m256d __A) {
+  return (__m256i) __builtin_ia32_cvtpd2qq256_mask ((__v4df) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtpd_epi64 (__m256i __W, __mmask8 __U, __m256d __A) {
+  return (__m256i) __builtin_ia32_cvtpd2qq256_mask ((__v4df) __A,
+                (__v4di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtpd_epi64 (__mmask8 __U, __m256d __A) {
+  return (__m256i) __builtin_ia32_cvtpd2qq256_mask ((__v4df) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtpd_epu64 (__m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2uqq128_mask ((__v2df) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtpd_epu64 (__m128i __W, __mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2uqq128_mask ((__v2df) __A,
+                (__v2di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtpd_epu64 (__mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2uqq128_mask ((__v2df) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtpd_epu64 (__m256d __A) {
+  return (__m256i) __builtin_ia32_cvtpd2uqq256_mask ((__v4df) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtpd_epu64 (__m256i __W, __mmask8 __U, __m256d __A) {
+  return (__m256i) __builtin_ia32_cvtpd2uqq256_mask ((__v4df) __A,
+                (__v4di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtpd_epu64 (__mmask8 __U, __m256d __A) {
+  return (__m256i) __builtin_ia32_cvtpd2uqq256_mask ((__v4df) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtps_epi64 (__m128 __A) {
+  return (__m128i) __builtin_ia32_cvtps2qq128_mask ((__v4sf) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtps_epi64 (__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvtps2qq128_mask ((__v4sf) __A,
+                (__v2di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtps_epi64 (__mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvtps2qq128_mask ((__v4sf) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtps_epi64 (__m128 __A) {
+  return (__m256i) __builtin_ia32_cvtps2qq256_mask ((__v4sf) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtps_epi64 (__m256i __W, __mmask8 __U, __m128 __A) {
+  return (__m256i) __builtin_ia32_cvtps2qq256_mask ((__v4sf) __A,
+                (__v4di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtps_epi64 (__mmask8 __U, __m128 __A) {
+  return (__m256i) __builtin_ia32_cvtps2qq256_mask ((__v4sf) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtps_epu64 (__m128 __A) {
+  return (__m128i) __builtin_ia32_cvtps2uqq128_mask ((__v4sf) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtps_epu64 (__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvtps2uqq128_mask ((__v4sf) __A,
+                (__v2di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtps_epu64 (__mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvtps2uqq128_mask ((__v4sf) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtps_epu64 (__m128 __A) {
+  return (__m256i) __builtin_ia32_cvtps2uqq256_mask ((__v4sf) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtps_epu64 (__m256i __W, __mmask8 __U, __m128 __A) {
+  return (__m256i) __builtin_ia32_cvtps2uqq256_mask ((__v4sf) __A,
+                (__v4di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtps_epu64 (__mmask8 __U, __m128 __A) {
+  return (__m256i) __builtin_ia32_cvtps2uqq256_mask ((__v4sf) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_cvtepi64_pd (__m128i __A) {
+  return (__m128d)__builtin_convertvector((__v2di)__A, __v2df);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi64_pd (__m128d __W, __mmask8 __U, __m128i __A) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_cvtepi64_pd(__A),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi64_pd (__mmask8 __U, __m128i __A) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_cvtepi64_pd(__A),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_cvtepi64_pd (__m256i __A) {
+  return (__m256d)__builtin_convertvector((__v4di)__A, __v4df);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi64_pd (__m256d __W, __mmask8 __U, __m256i __A) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_cvtepi64_pd(__A),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi64_pd (__mmask8 __U, __m256i __A) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_cvtepi64_pd(__A),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_cvtepi64_ps (__m128i __A) {
+  return (__m128) __builtin_ia32_cvtqq2ps128_mask ((__v2di) __A,
+                (__v4sf) _mm_setzero_ps(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi64_ps (__m128 __W, __mmask8 __U, __m128i __A) {
+  return (__m128) __builtin_ia32_cvtqq2ps128_mask ((__v2di) __A,
+                (__v4sf) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi64_ps (__mmask8 __U, __m128i __A) {
+  return (__m128) __builtin_ia32_cvtqq2ps128_mask ((__v2di) __A,
+                (__v4sf) _mm_setzero_ps(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS256
+_mm256_cvtepi64_ps (__m256i __A) {
+  return (__m128)__builtin_convertvector((__v4di)__A, __v4sf);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi64_ps (__m128 __W, __mmask8 __U, __m256i __A) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm256_cvtepi64_ps(__A),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi64_ps (__mmask8 __U, __m256i __A) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm256_cvtepi64_ps(__A),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvttpd_epi64 (__m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2qq128_mask ((__v2df) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttpd_epi64 (__m128i __W, __mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2qq128_mask ((__v2df) __A,
+                (__v2di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttpd_epi64 (__mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2qq128_mask ((__v2df) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttpd_epi64 (__m256d __A) {
+  return (__m256i) __builtin_ia32_cvttpd2qq256_mask ((__v4df) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttpd_epi64 (__m256i __W, __mmask8 __U, __m256d __A) {
+  return (__m256i) __builtin_ia32_cvttpd2qq256_mask ((__v4df) __A,
+                (__v4di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttpd_epi64 (__mmask8 __U, __m256d __A) {
+  return (__m256i) __builtin_ia32_cvttpd2qq256_mask ((__v4df) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvttpd_epu64 (__m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2uqq128_mask ((__v2df) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttpd_epu64 (__m128i __W, __mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2uqq128_mask ((__v2df) __A,
+                (__v2di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttpd_epu64 (__mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2uqq128_mask ((__v2df) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttpd_epu64 (__m256d __A) {
+  return (__m256i) __builtin_ia32_cvttpd2uqq256_mask ((__v4df) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttpd_epu64 (__m256i __W, __mmask8 __U, __m256d __A) {
+  return (__m256i) __builtin_ia32_cvttpd2uqq256_mask ((__v4df) __A,
+                (__v4di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttpd_epu64 (__mmask8 __U, __m256d __A) {
+  return (__m256i) __builtin_ia32_cvttpd2uqq256_mask ((__v4df) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvttps_epi64 (__m128 __A) {
+  return (__m128i) __builtin_ia32_cvttps2qq128_mask ((__v4sf) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttps_epi64 (__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvttps2qq128_mask ((__v4sf) __A,
+                (__v2di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttps_epi64 (__mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvttps2qq128_mask ((__v4sf) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttps_epi64 (__m128 __A) {
+  return (__m256i) __builtin_ia32_cvttps2qq256_mask ((__v4sf) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttps_epi64 (__m256i __W, __mmask8 __U, __m128 __A) {
+  return (__m256i) __builtin_ia32_cvttps2qq256_mask ((__v4sf) __A,
+                (__v4di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttps_epi64 (__mmask8 __U, __m128 __A) {
+  return (__m256i) __builtin_ia32_cvttps2qq256_mask ((__v4sf) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvttps_epu64 (__m128 __A) {
+  return (__m128i) __builtin_ia32_cvttps2uqq128_mask ((__v4sf) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttps_epu64 (__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvttps2uqq128_mask ((__v4sf) __A,
+                (__v2di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttps_epu64 (__mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvttps2uqq128_mask ((__v4sf) __A,
+                (__v2di) _mm_setzero_si128(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttps_epu64 (__m128 __A) {
+  return (__m256i) __builtin_ia32_cvttps2uqq256_mask ((__v4sf) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttps_epu64 (__m256i __W, __mmask8 __U, __m128 __A) {
+  return (__m256i) __builtin_ia32_cvttps2uqq256_mask ((__v4sf) __A,
+                (__v4di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttps_epu64 (__mmask8 __U, __m128 __A) {
+  return (__m256i) __builtin_ia32_cvttps2uqq256_mask ((__v4sf) __A,
+                (__v4di) _mm256_setzero_si256(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_cvtepu64_pd (__m128i __A) {
+  return (__m128d)__builtin_convertvector((__v2du)__A, __v2df);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepu64_pd (__m128d __W, __mmask8 __U, __m128i __A) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_cvtepu64_pd(__A),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepu64_pd (__mmask8 __U, __m128i __A) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_cvtepu64_pd(__A),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_cvtepu64_pd (__m256i __A) {
+  return (__m256d)__builtin_convertvector((__v4du)__A, __v4df);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepu64_pd (__m256d __W, __mmask8 __U, __m256i __A) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_cvtepu64_pd(__A),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepu64_pd (__mmask8 __U, __m256i __A) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_cvtepu64_pd(__A),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_cvtepu64_ps (__m128i __A) {
+  return (__m128) __builtin_ia32_cvtuqq2ps128_mask ((__v2di) __A,
+                (__v4sf) _mm_setzero_ps(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepu64_ps (__m128 __W, __mmask8 __U, __m128i __A) {
+  return (__m128) __builtin_ia32_cvtuqq2ps128_mask ((__v2di) __A,
+                (__v4sf) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepu64_ps (__mmask8 __U, __m128i __A) {
+  return (__m128) __builtin_ia32_cvtuqq2ps128_mask ((__v2di) __A,
+                (__v4sf) _mm_setzero_ps(),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS256
+_mm256_cvtepu64_ps (__m256i __A) {
+  return (__m128)__builtin_convertvector((__v4du)__A, __v4sf);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepu64_ps (__m128 __W, __mmask8 __U, __m256i __A) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm256_cvtepu64_ps(__A),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepu64_ps (__mmask8 __U, __m256i __A) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm256_cvtepu64_ps(__A),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+#define _mm_range_pd(A, B, C) \
+  ((__m128d)__builtin_ia32_rangepd128_mask((__v2df)(__m128d)(A), \
+                                           (__v2df)(__m128d)(B), (int)(C), \
+                                           (__v2df)_mm_setzero_pd(), \
+                                           (__mmask8)-1))
+
+#define _mm_mask_range_pd(W, U, A, B, C) \
+  ((__m128d)__builtin_ia32_rangepd128_mask((__v2df)(__m128d)(A), \
+                                           (__v2df)(__m128d)(B), (int)(C), \
+                                           (__v2df)(__m128d)(W), \
+                                           (__mmask8)(U)))
+
+#define _mm_maskz_range_pd(U, A, B, C) \
+  ((__m128d)__builtin_ia32_rangepd128_mask((__v2df)(__m128d)(A), \
+                                           (__v2df)(__m128d)(B), (int)(C), \
+                                           (__v2df)_mm_setzero_pd(), \
+                                           (__mmask8)(U)))
+
+#define _mm256_range_pd(A, B, C) \
+  ((__m256d)__builtin_ia32_rangepd256_mask((__v4df)(__m256d)(A), \
+                                           (__v4df)(__m256d)(B), (int)(C), \
+                                           (__v4df)_mm256_setzero_pd(), \
+                                           (__mmask8)-1))
+
+#define _mm256_mask_range_pd(W, U, A, B, C) \
+  ((__m256d)__builtin_ia32_rangepd256_mask((__v4df)(__m256d)(A), \
+                                           (__v4df)(__m256d)(B), (int)(C), \
+                                           (__v4df)(__m256d)(W), \
+                                           (__mmask8)(U)))
+
+#define _mm256_maskz_range_pd(U, A, B, C) \
+  ((__m256d)__builtin_ia32_rangepd256_mask((__v4df)(__m256d)(A), \
+                                           (__v4df)(__m256d)(B), (int)(C), \
+                                           (__v4df)_mm256_setzero_pd(), \
+                                           (__mmask8)(U)))
+
+#define _mm_range_ps(A, B, C) \
+  ((__m128)__builtin_ia32_rangeps128_mask((__v4sf)(__m128)(A), \
+                                          (__v4sf)(__m128)(B), (int)(C), \
+                                          (__v4sf)_mm_setzero_ps(), \
+                                          (__mmask8)-1))
+
+#define _mm_mask_range_ps(W, U, A, B, C) \
+  ((__m128)__builtin_ia32_rangeps128_mask((__v4sf)(__m128)(A), \
+                                          (__v4sf)(__m128)(B), (int)(C), \
+                                          (__v4sf)(__m128)(W), (__mmask8)(U)))
+
+#define _mm_maskz_range_ps(U, A, B, C) \
+  ((__m128)__builtin_ia32_rangeps128_mask((__v4sf)(__m128)(A), \
+                                          (__v4sf)(__m128)(B), (int)(C), \
+                                          (__v4sf)_mm_setzero_ps(), \
+                                          (__mmask8)(U)))
+
+#define _mm256_range_ps(A, B, C) \
+  ((__m256)__builtin_ia32_rangeps256_mask((__v8sf)(__m256)(A), \
+                                          (__v8sf)(__m256)(B), (int)(C), \
+                                          (__v8sf)_mm256_setzero_ps(), \
+                                          (__mmask8)-1))
+
+#define _mm256_mask_range_ps(W, U, A, B, C) \
+  ((__m256)__builtin_ia32_rangeps256_mask((__v8sf)(__m256)(A), \
+                                          (__v8sf)(__m256)(B), (int)(C), \
+                                          (__v8sf)(__m256)(W), (__mmask8)(U)))
+
+#define _mm256_maskz_range_ps(U, A, B, C) \
+  ((__m256)__builtin_ia32_rangeps256_mask((__v8sf)(__m256)(A), \
+                                          (__v8sf)(__m256)(B), (int)(C), \
+                                          (__v8sf)_mm256_setzero_ps(), \
+                                          (__mmask8)(U)))
+
+#define _mm_reduce_pd(A, B) \
+  ((__m128d)__builtin_ia32_reducepd128_mask((__v2df)(__m128d)(A), (int)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)-1))
+
+#define _mm_mask_reduce_pd(W, U, A, B) \
+  ((__m128d)__builtin_ia32_reducepd128_mask((__v2df)(__m128d)(A), (int)(B), \
+                                            (__v2df)(__m128d)(W), \
+                                            (__mmask8)(U)))
+
+#define _mm_maskz_reduce_pd(U, A, B) \
+  ((__m128d)__builtin_ia32_reducepd128_mask((__v2df)(__m128d)(A), (int)(B), \
+                                            (__v2df)_mm_setzero_pd(), \
+                                            (__mmask8)(U)))
+
+#define _mm256_reduce_pd(A, B) \
+  ((__m256d)__builtin_ia32_reducepd256_mask((__v4df)(__m256d)(A), (int)(B), \
+                                            (__v4df)_mm256_setzero_pd(), \
+                                            (__mmask8)-1))
+
+#define _mm256_mask_reduce_pd(W, U, A, B) \
+  ((__m256d)__builtin_ia32_reducepd256_mask((__v4df)(__m256d)(A), (int)(B), \
+                                            (__v4df)(__m256d)(W), \
+                                            (__mmask8)(U)))
+
+#define _mm256_maskz_reduce_pd(U, A, B) \
+  ((__m256d)__builtin_ia32_reducepd256_mask((__v4df)(__m256d)(A), (int)(B), \
+                                            (__v4df)_mm256_setzero_pd(), \
+                                            (__mmask8)(U)))
+
+#define _mm_reduce_ps(A, B) \
+  ((__m128)__builtin_ia32_reduceps128_mask((__v4sf)(__m128)(A), (int)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)-1))
+
+#define _mm_mask_reduce_ps(W, U, A, B) \
+  ((__m128)__builtin_ia32_reduceps128_mask((__v4sf)(__m128)(A), (int)(B), \
+                                           (__v4sf)(__m128)(W), \
+                                           (__mmask8)(U)))
+
+#define _mm_maskz_reduce_ps(U, A, B) \
+  ((__m128)__builtin_ia32_reduceps128_mask((__v4sf)(__m128)(A), (int)(B), \
+                                           (__v4sf)_mm_setzero_ps(), \
+                                           (__mmask8)(U)))
+
+#define _mm256_reduce_ps(A, B) \
+  ((__m256)__builtin_ia32_reduceps256_mask((__v8sf)(__m256)(A), (int)(B), \
+                                           (__v8sf)_mm256_setzero_ps(), \
+                                           (__mmask8)-1))
+
+#define _mm256_mask_reduce_ps(W, U, A, B) \
+  ((__m256)__builtin_ia32_reduceps256_mask((__v8sf)(__m256)(A), (int)(B), \
+                                           (__v8sf)(__m256)(W), \
+                                           (__mmask8)(U)))
+
+#define _mm256_maskz_reduce_ps(U, A, B) \
+  ((__m256)__builtin_ia32_reduceps256_mask((__v8sf)(__m256)(A), (int)(B), \
+                                           (__v8sf)_mm256_setzero_ps(), \
+                                           (__mmask8)(U)))
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_movepi32_mask (__m128i __A)
+{
+  return (__mmask8) __builtin_ia32_cvtd2mask128 ((__v4si) __A);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS256
+_mm256_movepi32_mask (__m256i __A)
+{
+  return (__mmask8) __builtin_ia32_cvtd2mask256 ((__v8si) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_movm_epi32 (__mmask8 __A)
+{
+  return (__m128i) __builtin_ia32_cvtmask2d128 (__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_movm_epi32 (__mmask8 __A)
+{
+  return (__m256i) __builtin_ia32_cvtmask2d256 (__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_movm_epi64 (__mmask8 __A)
+{
+  return (__m128i) __builtin_ia32_cvtmask2q128 (__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_movm_epi64 (__mmask8 __A)
+{
+  return (__m256i) __builtin_ia32_cvtmask2q256 (__A);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_movepi64_mask (__m128i __A)
+{
+  return (__mmask8) __builtin_ia32_cvtq2mask128 ((__v2di) __A);
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS256
+_mm256_movepi64_mask (__m256i __A)
+{
+  return (__mmask8) __builtin_ia32_cvtq2mask256 ((__v4di) __A);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_broadcast_f32x2 (__m128 __A)
+{
+  return (__m256)__builtin_shufflevector((__v4sf)__A, (__v4sf)__A,
+                                         0, 1, 0, 1, 0, 1, 0, 1);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcast_f32x2 (__m256 __O, __mmask8 __M, __m128 __A)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__M,
+                                             (__v8sf)_mm256_broadcast_f32x2(__A),
+                                             (__v8sf)__O);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcast_f32x2 (__mmask8 __M, __m128 __A)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__M,
+                                             (__v8sf)_mm256_broadcast_f32x2(__A),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_broadcast_f64x2(__m128d __A)
+{
+  return (__m256d)__builtin_shufflevector((__v2df)__A, (__v2df)__A,
+                                          0, 1, 0, 1);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcast_f64x2(__m256d __O, __mmask8 __M, __m128d __A)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__M,
+                                            (__v4df)_mm256_broadcast_f64x2(__A),
+                                            (__v4df)__O);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcast_f64x2 (__mmask8 __M, __m128d __A)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__M,
+                                            (__v4df)_mm256_broadcast_f64x2(__A),
+                                            (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_broadcast_i32x2 (__m128i __A)
+{
+  return (__m128i)__builtin_shufflevector((__v4si)__A, (__v4si)__A,
+                                          0, 1, 0, 1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_broadcast_i32x2 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_broadcast_i32x2(__A),
+                                             (__v4si)__O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_broadcast_i32x2 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_broadcast_i32x2(__A),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_broadcast_i32x2 (__m128i __A)
+{
+  return (__m256i)__builtin_shufflevector((__v4si)__A, (__v4si)__A,
+                                          0, 1, 0, 1, 0, 1, 0, 1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcast_i32x2 (__m256i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_broadcast_i32x2(__A),
+                                             (__v8si)__O);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcast_i32x2 (__mmask8 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_broadcast_i32x2(__A),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_broadcast_i64x2(__m128i __A)
+{
+  return (__m256i)__builtin_shufflevector((__v2di)__A, (__v2di)__A,
+                                          0, 1, 0, 1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcast_i64x2(__m256i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                            (__v4di)_mm256_broadcast_i64x2(__A),
+                                            (__v4di)__O);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcast_i64x2 (__mmask8 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                            (__v4di)_mm256_broadcast_i64x2(__A),
+                                            (__v4di)_mm256_setzero_si256());
+}
+
+#define _mm256_extractf64x2_pd(A, imm) \
+  ((__m128d)__builtin_ia32_extractf64x2_256_mask((__v4df)(__m256d)(A), \
+                                                 (int)(imm), \
+                                                 (__v2df)_mm_undefined_pd(), \
+                                                 (__mmask8)-1))
+
+#define _mm256_mask_extractf64x2_pd(W, U, A, imm) \
+  ((__m128d)__builtin_ia32_extractf64x2_256_mask((__v4df)(__m256d)(A), \
+                                                 (int)(imm), \
+                                                 (__v2df)(__m128d)(W), \
+                                                 (__mmask8)(U)))
+
+#define _mm256_maskz_extractf64x2_pd(U, A, imm) \
+  ((__m128d)__builtin_ia32_extractf64x2_256_mask((__v4df)(__m256d)(A), \
+                                                 (int)(imm), \
+                                                 (__v2df)_mm_setzero_pd(), \
+                                                 (__mmask8)(U)))
+
+#define _mm256_extracti64x2_epi64(A, imm) \
+  ((__m128i)__builtin_ia32_extracti64x2_256_mask((__v4di)(__m256i)(A), \
+                                                (int)(imm), \
+                                                (__v2di)_mm_undefined_si128(), \
+                                                (__mmask8)-1))
+
+#define _mm256_mask_extracti64x2_epi64(W, U, A, imm) \
+  ((__m128i)__builtin_ia32_extracti64x2_256_mask((__v4di)(__m256i)(A), \
+                                                 (int)(imm), \
+                                                 (__v2di)(__m128i)(W), \
+                                                 (__mmask8)(U)))
+
+#define _mm256_maskz_extracti64x2_epi64(U, A, imm) \
+  ((__m128i)__builtin_ia32_extracti64x2_256_mask((__v4di)(__m256i)(A), \
+                                                 (int)(imm), \
+                                                 (__v2di)_mm_setzero_si128(), \
+                                                 (__mmask8)(U)))
+
+#define _mm256_insertf64x2(A, B, imm) \
+  ((__m256d)__builtin_ia32_insertf64x2_256((__v4df)(__m256d)(A), \
+                                           (__v2df)(__m128d)(B), (int)(imm)))
+
+#define _mm256_mask_insertf64x2(W, U, A, B, imm) \
+  ((__m256d)__builtin_ia32_selectpd_256((__mmask8)(U), \
+                                  (__v4df)_mm256_insertf64x2((A), (B), (imm)), \
+                                  (__v4df)(__m256d)(W)))
+
+#define _mm256_maskz_insertf64x2(U, A, B, imm) \
+  ((__m256d)__builtin_ia32_selectpd_256((__mmask8)(U), \
+                                  (__v4df)_mm256_insertf64x2((A), (B), (imm)), \
+                                  (__v4df)_mm256_setzero_pd()))
+
+#define _mm256_inserti64x2(A, B, imm) \
+  ((__m256i)__builtin_ia32_inserti64x2_256((__v4di)(__m256i)(A), \
+                                           (__v2di)(__m128i)(B), (int)(imm)))
+
+#define _mm256_mask_inserti64x2(W, U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                   (__v4di)_mm256_inserti64x2((A), (B), (imm)), \
+                                   (__v4di)(__m256i)(W)))
+
+#define _mm256_maskz_inserti64x2(U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                   (__v4di)_mm256_inserti64x2((A), (B), (imm)), \
+                                   (__v4di)_mm256_setzero_si256()))
+
+#define _mm_mask_fpclass_pd_mask(U, A, imm) \
+  ((__mmask8)__builtin_ia32_fpclasspd128_mask((__v2df)(__m128d)(A), (int)(imm), \
+                                              (__mmask8)(U)))
+
+#define _mm_fpclass_pd_mask(A, imm) \
+  ((__mmask8)__builtin_ia32_fpclasspd128_mask((__v2df)(__m128d)(A), (int)(imm), \
+                                              (__mmask8)-1))
+
+#define _mm256_mask_fpclass_pd_mask(U, A, imm) \
+  ((__mmask8)__builtin_ia32_fpclasspd256_mask((__v4df)(__m256d)(A), (int)(imm), \
+                                              (__mmask8)(U)))
+
+#define _mm256_fpclass_pd_mask(A, imm) \
+  ((__mmask8)__builtin_ia32_fpclasspd256_mask((__v4df)(__m256d)(A), (int)(imm), \
+                                              (__mmask8)-1))
+
+#define _mm_mask_fpclass_ps_mask(U, A, imm) \
+  ((__mmask8)__builtin_ia32_fpclassps128_mask((__v4sf)(__m128)(A), (int)(imm), \
+                                              (__mmask8)(U)))
+
+#define _mm_fpclass_ps_mask(A, imm) \
+  ((__mmask8)__builtin_ia32_fpclassps128_mask((__v4sf)(__m128)(A), (int)(imm), \
+                                              (__mmask8)-1))
+
+#define _mm256_mask_fpclass_ps_mask(U, A, imm) \
+  ((__mmask8)__builtin_ia32_fpclassps256_mask((__v8sf)(__m256)(A), (int)(imm), \
+                                              (__mmask8)(U)))
+
+#define _mm256_fpclass_ps_mask(A, imm) \
+  ((__mmask8)__builtin_ia32_fpclassps256_mask((__v8sf)(__m256)(A), (int)(imm), \
+                                              (__mmask8)-1))
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif
diff --git a/third_party/intel/clang/avx512vlfp16intrin.h b/third_party/intel/clang/avx512vlfp16intrin.h
new file mode 100644
index 000000000..a12acb7d9
--- /dev/null
+++ b/third_party/intel/clang/avx512vlfp16intrin.h
@@ -0,0 +1,2071 @@
+/*===---------- avx512vlfp16intrin.h - AVX512-FP16 intrinsics --------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error                                                                         \
+    "Never use <avx512vlfp16intrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifdef __SSE2__
+
+#ifndef __AVX512VLFP16INTRIN_H
+#define __AVX512VLFP16INTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512fp16,avx512vl,no-evex512"),                 \
+                 __min_vector_width__(256)))
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512fp16,avx512vl,no-evex512"),                 \
+                 __min_vector_width__(128)))
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS128 _mm_cvtsh_h(__m128h __a) {
+  return __a[0];
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS256 _mm256_cvtsh_h(__m256h __a) {
+  return __a[0];
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_set_sh(_Float16 __h) {
+  return __extension__(__m128h){__h, 0, 0, 0, 0, 0, 0, 0};
+}
+
+static __inline __m128h __DEFAULT_FN_ATTRS128 _mm_set1_ph(_Float16 __h) {
+  return (__m128h)(__v8hf){__h, __h, __h, __h, __h, __h, __h, __h};
+}
+
+static __inline __m256h __DEFAULT_FN_ATTRS256 _mm256_set1_ph(_Float16 __h) {
+  return (__m256h)(__v16hf){__h, __h, __h, __h, __h, __h, __h, __h,
+                            __h, __h, __h, __h, __h, __h, __h, __h};
+}
+
+static __inline __m128h __DEFAULT_FN_ATTRS128
+_mm_set_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
+           _Float16 __h5, _Float16 __h6, _Float16 __h7, _Float16 __h8) {
+  return (__m128h)(__v8hf){__h8, __h7, __h6, __h5, __h4, __h3, __h2, __h1};
+}
+
+static __inline __m256h __DEFAULT_FN_ATTRS256
+_mm256_set1_pch(_Float16 _Complex h) {
+  return (__m256h)_mm256_set1_ps(__builtin_bit_cast(float, h));
+}
+
+static __inline __m128h __DEFAULT_FN_ATTRS128
+_mm_set1_pch(_Float16 _Complex h) {
+  return (__m128h)_mm_set1_ps(__builtin_bit_cast(float, h));
+}
+
+static __inline __m256h __DEFAULT_FN_ATTRS256
+_mm256_set_ph(_Float16 __h1, _Float16 __h2, _Float16 __h3, _Float16 __h4,
+              _Float16 __h5, _Float16 __h6, _Float16 __h7, _Float16 __h8,
+              _Float16 __h9, _Float16 __h10, _Float16 __h11, _Float16 __h12,
+              _Float16 __h13, _Float16 __h14, _Float16 __h15, _Float16 __h16) {
+  return (__m256h)(__v16hf){__h16, __h15, __h14, __h13, __h12, __h11,
+                            __h10, __h9,  __h8,  __h7,  __h6,  __h5,
+                            __h4,  __h3,  __h2,  __h1};
+}
+
+#define _mm_setr_ph(h1, h2, h3, h4, h5, h6, h7, h8)                            \
+  _mm_set_ph((h8), (h7), (h6), (h5), (h4), (h3), (h2), (h1))
+
+#define _mm256_setr_ph(h1, h2, h3, h4, h5, h6, h7, h8, h9, h10, h11, h12, h13, \
+                       h14, h15, h16)                                          \
+  _mm256_set_ph((h16), (h15), (h14), (h13), (h12), (h11), (h10), (h9), (h8),   \
+                (h7), (h6), (h5), (h4), (h3), (h2), (h1))
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_add_ph(__m256h __A,
+                                                              __m256h __B) {
+  return (__m256h)((__v16hf)__A + (__v16hf)__B);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_add_ph(__m256h __W, __mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      __U, (__v16hf)_mm256_add_ph(__A, __B), (__v16hf)__W);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_add_ph(__mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      __U, (__v16hf)_mm256_add_ph(__A, __B), (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_add_ph(__m128h __A,
+                                                           __m128h __B) {
+  return (__m128h)((__v8hf)__A + (__v8hf)__B);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_add_ph(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(__U, (__v8hf)_mm_add_ph(__A, __B),
+                                              (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_add_ph(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(__U, (__v8hf)_mm_add_ph(__A, __B),
+                                              (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_sub_ph(__m256h __A,
+                                                              __m256h __B) {
+  return (__m256h)((__v16hf)__A - (__v16hf)__B);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_sub_ph(__m256h __W, __mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      __U, (__v16hf)_mm256_sub_ph(__A, __B), (__v16hf)__W);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_sub_ph(__mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      __U, (__v16hf)_mm256_sub_ph(__A, __B), (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_sub_ph(__m128h __A,
+                                                           __m128h __B) {
+  return (__m128h)((__v8hf)__A - (__v8hf)__B);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_sub_ph(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(__U, (__v8hf)_mm_sub_ph(__A, __B),
+                                              (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_sub_ph(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(__U, (__v8hf)_mm_sub_ph(__A, __B),
+                                              (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_mul_ph(__m256h __A,
+                                                              __m256h __B) {
+  return (__m256h)((__v16hf)__A * (__v16hf)__B);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_mul_ph(__m256h __W, __mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      __U, (__v16hf)_mm256_mul_ph(__A, __B), (__v16hf)__W);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_mul_ph(__mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      __U, (__v16hf)_mm256_mul_ph(__A, __B), (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mul_ph(__m128h __A,
+                                                           __m128h __B) {
+  return (__m128h)((__v8hf)__A * (__v8hf)__B);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_mul_ph(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(__U, (__v8hf)_mm_mul_ph(__A, __B),
+                                              (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_mul_ph(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(__U, (__v8hf)_mm_mul_ph(__A, __B),
+                                              (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_div_ph(__m256h __A,
+                                                              __m256h __B) {
+  return (__m256h)((__v16hf)__A / (__v16hf)__B);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_div_ph(__m256h __W, __mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      __U, (__v16hf)_mm256_div_ph(__A, __B), (__v16hf)__W);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_div_ph(__mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      __U, (__v16hf)_mm256_div_ph(__A, __B), (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_div_ph(__m128h __A,
+                                                           __m128h __B) {
+  return (__m128h)((__v8hf)__A / (__v8hf)__B);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_div_ph(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(__U, (__v8hf)_mm_div_ph(__A, __B),
+                                              (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_div_ph(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(__U, (__v8hf)_mm_div_ph(__A, __B),
+                                              (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_min_ph(__m256h __A,
+                                                              __m256h __B) {
+  return (__m256h)__builtin_ia32_minph256((__v16hf)__A, (__v16hf)__B);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_min_ph(__m256h __W, __mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      (__v16hf)__builtin_ia32_minph256((__v16hf)__A, (__v16hf)__B),
+      (__v16hf)__W);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_ph(__mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      (__v16hf)__builtin_ia32_minph256((__v16hf)__A, (__v16hf)__B),
+      (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_min_ph(__m128h __A,
+                                                           __m128h __B) {
+  return (__m128h)__builtin_ia32_minph128((__v8hf)__A, (__v8hf)__B);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_min_ph(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)__builtin_ia32_minph128((__v8hf)__A, (__v8hf)__B),
+      (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_min_ph(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)__builtin_ia32_minph128((__v8hf)__A, (__v8hf)__B),
+      (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_max_ph(__m256h __A,
+                                                              __m256h __B) {
+  return (__m256h)__builtin_ia32_maxph256((__v16hf)__A, (__v16hf)__B);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_max_ph(__m256h __W, __mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      (__v16hf)__builtin_ia32_maxph256((__v16hf)__A, (__v16hf)__B),
+      (__v16hf)__W);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_ph(__mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      (__v16hf)__builtin_ia32_maxph256((__v16hf)__A, (__v16hf)__B),
+      (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_max_ph(__m128h __A,
+                                                           __m128h __B) {
+  return (__m128h)__builtin_ia32_maxph128((__v8hf)__A, (__v8hf)__B);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_max_ph(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A,
+                                                                __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)__builtin_ia32_maxph128((__v8hf)__A, (__v8hf)__B),
+      (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_max_ph(__mmask8 __U,
+                                                                 __m128h __A,
+                                                                 __m128h __B) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)__builtin_ia32_maxph128((__v8hf)__A, (__v8hf)__B),
+      (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_abs_ph(__m256h __A) {
+  return (__m256h)_mm256_and_epi32(_mm256_set1_epi32(0x7FFF7FFF), (__m256i)__A);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_abs_ph(__m128h __A) {
+  return (__m128h)_mm_and_epi32(_mm_set1_epi32(0x7FFF7FFF), (__m128i)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_conj_pch(__m256h __A) {
+  return (__m256h)_mm256_xor_ps((__m256)__A, _mm256_set1_ps(-0.0f));
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_conj_pch(__m256h __W, __mmask8 __U, __m256h __A) {
+  return (__m256h)__builtin_ia32_selectps_256(
+      (__mmask8)__U, (__v8sf)_mm256_conj_pch(__A), (__v8sf)__W);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_conj_pch(__mmask8 __U, __m256h __A) {
+  return (__m256h)__builtin_ia32_selectps_256(
+      (__mmask8)__U, (__v8sf)_mm256_conj_pch(__A), (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_conj_pch(__m128h __A) {
+  return (__m128h)_mm_xor_ps((__m128)__A, _mm_set1_ps(-0.0f));
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_conj_pch(__m128h __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A) {
+  return (__m128h)__builtin_ia32_selectps_128(
+      (__mmask8)__U, (__v4sf)_mm_conj_pch(__A), (__v4sf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_conj_pch(__mmask8 __U, __m128h __A) {
+  return (__m128h)__builtin_ia32_selectps_128(
+      (__mmask8)__U, (__v4sf)_mm_conj_pch(__A), (__v4sf)_mm_setzero_ps());
+}
+
+#define _mm256_cmp_ph_mask(a, b, p)                                            \
+  ((__mmask16)__builtin_ia32_cmpph256_mask(                                    \
+      (__v16hf)(__m256h)(a), (__v16hf)(__m256h)(b), (int)(p), (__mmask16)-1))
+
+#define _mm256_mask_cmp_ph_mask(m, a, b, p)                                    \
+  ((__mmask16)__builtin_ia32_cmpph256_mask(                                    \
+      (__v16hf)(__m256h)(a), (__v16hf)(__m256h)(b), (int)(p), (__mmask16)(m)))
+
+#define _mm_cmp_ph_mask(a, b, p)                                               \
+  ((__mmask8)__builtin_ia32_cmpph128_mask(                                     \
+      (__v8hf)(__m128h)(a), (__v8hf)(__m128h)(b), (int)(p), (__mmask8)-1))
+
+#define _mm_mask_cmp_ph_mask(m, a, b, p)                                       \
+  ((__mmask8)__builtin_ia32_cmpph128_mask(                                     \
+      (__v8hf)(__m128h)(a), (__v8hf)(__m128h)(b), (int)(p), (__mmask8)(m)))
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_rcp_ph(__m256h __A) {
+  return (__m256h)__builtin_ia32_rcpph256_mask(
+      (__v16hf)__A, (__v16hf)_mm256_undefined_ph(), (__mmask16)-1);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_rcp_ph(__m256h __W, __mmask16 __U, __m256h __A) {
+  return (__m256h)__builtin_ia32_rcpph256_mask((__v16hf)__A, (__v16hf)__W,
+                                               (__mmask16)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_rcp_ph(__mmask16 __U, __m256h __A) {
+  return (__m256h)__builtin_ia32_rcpph256_mask(
+      (__v16hf)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_rcp_ph(__m128h __A) {
+  return (__m128h)__builtin_ia32_rcpph128_mask(
+      (__v8hf)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_rcp_ph(__m128h __W,
+                                                                __mmask8 __U,
+                                                                __m128h __A) {
+  return (__m128h)__builtin_ia32_rcpph128_mask((__v8hf)__A, (__v8hf)__W,
+                                               (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_rcp_ph(__mmask8 __U,
+                                                                 __m128h __A) {
+  return (__m128h)__builtin_ia32_rcpph128_mask(
+      (__v8hf)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_rsqrt_ph(__m256h __A) {
+  return (__m256h)__builtin_ia32_rsqrtph256_mask(
+      (__v16hf)__A, (__v16hf)_mm256_undefined_ph(), (__mmask16)-1);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_rsqrt_ph(__m256h __W, __mmask16 __U, __m256h __A) {
+  return (__m256h)__builtin_ia32_rsqrtph256_mask((__v16hf)__A, (__v16hf)__W,
+                                                 (__mmask16)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_rsqrt_ph(__mmask16 __U, __m256h __A) {
+  return (__m256h)__builtin_ia32_rsqrtph256_mask(
+      (__v16hf)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_rsqrt_ph(__m128h __A) {
+  return (__m128h)__builtin_ia32_rsqrtph128_mask(
+      (__v8hf)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_rsqrt_ph(__m128h __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A) {
+  return (__m128h)__builtin_ia32_rsqrtph128_mask((__v8hf)__A, (__v8hf)__W,
+                                                 (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_rsqrt_ph(__mmask8 __U, __m128h __A) {
+  return (__m128h)__builtin_ia32_rsqrtph128_mask(
+      (__v8hf)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_getexp_ph(__m128h __A) {
+  return (__m128h)__builtin_ia32_getexpph128_mask(
+      (__v8hf)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_getexp_ph(__m128h __W, __mmask8 __U, __m128h __A) {
+  return (__m128h)__builtin_ia32_getexpph128_mask((__v8hf)__A, (__v8hf)__W,
+                                                  (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_getexp_ph(__mmask8 __U, __m128h __A) {
+  return (__m128h)__builtin_ia32_getexpph128_mask(
+      (__v8hf)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_getexp_ph(__m256h __A) {
+  return (__m256h)__builtin_ia32_getexpph256_mask(
+      (__v16hf)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)-1);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_getexp_ph(__m256h __W, __mmask16 __U, __m256h __A) {
+  return (__m256h)__builtin_ia32_getexpph256_mask((__v16hf)__A, (__v16hf)__W,
+                                                  (__mmask16)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_getexp_ph(__mmask16 __U, __m256h __A) {
+  return (__m256h)__builtin_ia32_getexpph256_mask(
+      (__v16hf)__A, (__v16hf)_mm256_setzero_ph(), (__mmask16)__U);
+}
+
+#define _mm_getmant_ph(A, B, C)                                                \
+  ((__m128h)__builtin_ia32_getmantph128_mask(                                  \
+      (__v8hf)(__m128h)(A), (int)(((C) << 2) | (B)), (__v8hf)_mm_setzero_ph(), \
+      (__mmask8)-1))
+
+#define _mm_mask_getmant_ph(W, U, A, B, C)                                     \
+  ((__m128h)__builtin_ia32_getmantph128_mask(                                  \
+      (__v8hf)(__m128h)(A), (int)(((C) << 2) | (B)), (__v8hf)(__m128h)(W),     \
+      (__mmask8)(U)))
+
+#define _mm_maskz_getmant_ph(U, A, B, C)                                       \
+  ((__m128h)__builtin_ia32_getmantph128_mask(                                  \
+      (__v8hf)(__m128h)(A), (int)(((C) << 2) | (B)), (__v8hf)_mm_setzero_ph(), \
+      (__mmask8)(U)))
+
+#define _mm256_getmant_ph(A, B, C)                                             \
+  ((__m256h)__builtin_ia32_getmantph256_mask(                                  \
+      (__v16hf)(__m256h)(A), (int)(((C) << 2) | (B)),                          \
+      (__v16hf)_mm256_setzero_ph(), (__mmask16)-1))
+
+#define _mm256_mask_getmant_ph(W, U, A, B, C)                                  \
+  ((__m256h)__builtin_ia32_getmantph256_mask(                                  \
+      (__v16hf)(__m256h)(A), (int)(((C) << 2) | (B)), (__v16hf)(__m256h)(W),   \
+      (__mmask16)(U)))
+
+#define _mm256_maskz_getmant_ph(U, A, B, C)                                    \
+  ((__m256h)__builtin_ia32_getmantph256_mask(                                  \
+      (__v16hf)(__m256h)(A), (int)(((C) << 2) | (B)),                          \
+      (__v16hf)_mm256_setzero_ph(), (__mmask16)(U)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_scalef_ph(__m128h __A,
+                                                              __m128h __B) {
+  return (__m128h)__builtin_ia32_scalefph128_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_scalef_ph(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_scalefph128_mask((__v8hf)__A, (__v8hf)__B,
+                                                  (__v8hf)__W, (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_scalef_ph(__mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_scalefph128_mask(
+      (__v8hf)__A, (__v8hf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_scalef_ph(__m256h __A,
+                                                                 __m256h __B) {
+  return (__m256h)__builtin_ia32_scalefph256_mask(
+      (__v16hf)__A, (__v16hf)__B, (__v16hf)_mm256_setzero_ph(), (__mmask16)-1);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_scalef_ph(__m256h __W, __mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_scalefph256_mask((__v16hf)__A, (__v16hf)__B,
+                                                  (__v16hf)__W, (__mmask16)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_scalef_ph(__mmask16 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_scalefph256_mask(
+      (__v16hf)__A, (__v16hf)__B, (__v16hf)_mm256_setzero_ph(), (__mmask16)__U);
+}
+
+#define _mm_roundscale_ph(A, imm)                                              \
+  ((__m128h)__builtin_ia32_rndscaleph_128_mask(                                \
+      (__v8hf)(__m128h)(A), (int)(imm), (__v8hf)_mm_setzero_ph(),              \
+      (__mmask8)-1))
+
+#define _mm_mask_roundscale_ph(W, U, A, imm)                                   \
+  ((__m128h)__builtin_ia32_rndscaleph_128_mask(                                \
+      (__v8hf)(__m128h)(A), (int)(imm), (__v8hf)(__m128h)(W), (__mmask8)(U)))
+
+#define _mm_maskz_roundscale_ph(U, A, imm)                                     \
+  ((__m128h)__builtin_ia32_rndscaleph_128_mask(                                \
+      (__v8hf)(__m128h)(A), (int)(imm), (__v8hf)_mm_setzero_ph(),              \
+      (__mmask8)(U)))
+
+#define _mm256_roundscale_ph(A, imm)                                           \
+  ((__m256h)__builtin_ia32_rndscaleph_256_mask(                                \
+      (__v16hf)(__m256h)(A), (int)(imm), (__v16hf)_mm256_setzero_ph(),         \
+      (__mmask16)-1))
+
+#define _mm256_mask_roundscale_ph(W, U, A, imm)                                \
+  ((__m256h)__builtin_ia32_rndscaleph_256_mask(                                \
+      (__v16hf)(__m256h)(A), (int)(imm), (__v16hf)(__m256h)(W),                \
+      (__mmask16)(U)))
+
+#define _mm256_maskz_roundscale_ph(U, A, imm)                                  \
+  ((__m256h)__builtin_ia32_rndscaleph_256_mask(                                \
+      (__v16hf)(__m256h)(A), (int)(imm), (__v16hf)_mm256_setzero_ph(),         \
+      (__mmask16)(U)))
+
+#define _mm_reduce_ph(A, imm)                                                  \
+  ((__m128h)__builtin_ia32_reduceph128_mask((__v8hf)(__m128h)(A), (int)(imm),  \
+                                            (__v8hf)_mm_setzero_ph(),          \
+                                            (__mmask8)-1))
+
+#define _mm_mask_reduce_ph(W, U, A, imm)                                       \
+  ((__m128h)__builtin_ia32_reduceph128_mask(                                   \
+      (__v8hf)(__m128h)(A), (int)(imm), (__v8hf)(__m128h)(W), (__mmask8)(U)))
+
+#define _mm_maskz_reduce_ph(U, A, imm)                                         \
+  ((__m128h)__builtin_ia32_reduceph128_mask((__v8hf)(__m128h)(A), (int)(imm),  \
+                                            (__v8hf)_mm_setzero_ph(),          \
+                                            (__mmask8)(U)))
+
+#define _mm256_reduce_ph(A, imm)                                               \
+  ((__m256h)__builtin_ia32_reduceph256_mask((__v16hf)(__m256h)(A), (int)(imm), \
+                                            (__v16hf)_mm256_setzero_ph(),      \
+                                            (__mmask16)-1))
+
+#define _mm256_mask_reduce_ph(W, U, A, imm)                                    \
+  ((__m256h)__builtin_ia32_reduceph256_mask((__v16hf)(__m256h)(A), (int)(imm), \
+                                            (__v16hf)(__m256h)(W),             \
+                                            (__mmask16)(U)))
+
+#define _mm256_maskz_reduce_ph(U, A, imm)                                      \
+  ((__m256h)__builtin_ia32_reduceph256_mask((__v16hf)(__m256h)(A), (int)(imm), \
+                                            (__v16hf)_mm256_setzero_ph(),      \
+                                            (__mmask16)(U)))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_sqrt_ph(__m128h __a) {
+  return __builtin_ia32_sqrtph((__v8hf)__a);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_sqrt_ph(__m128h __W,
+                                                                 __mmask8 __U,
+                                                                 __m128h __A) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)_mm_sqrt_ph(__A), (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_maskz_sqrt_ph(__mmask8 __U,
+                                                                  __m128h __A) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)_mm_sqrt_ph(__A), (__v8hf)_mm_setzero_ph());
+}
+
+static __inline __m256h __DEFAULT_FN_ATTRS256 _mm256_sqrt_ph(__m256h __a) {
+  return (__m256h)__builtin_ia32_sqrtph256((__v16hf)__a);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_sqrt_ph(__m256h __W, __mmask16 __U, __m256h __A) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U, (__v16hf)_mm256_sqrt_ph(__A), (__v16hf)__W);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_sqrt_ph(__mmask16 __U, __m256h __A) {
+  return (__m256h)__builtin_ia32_selectph_256((__mmask16)__U,
+                                              (__v16hf)_mm256_sqrt_ph(__A),
+                                              (__v16hf)_mm256_setzero_ph());
+}
+
+#define _mm_mask_fpclass_ph_mask(U, A, imm)                                    \
+  ((__mmask8)__builtin_ia32_fpclassph128_mask((__v8hf)(__m128h)(A),            \
+                                              (int)(imm), (__mmask8)(U)))
+
+#define _mm_fpclass_ph_mask(A, imm)                                            \
+  ((__mmask8)__builtin_ia32_fpclassph128_mask((__v8hf)(__m128h)(A),            \
+                                              (int)(imm), (__mmask8)-1))
+
+#define _mm256_mask_fpclass_ph_mask(U, A, imm)                                 \
+  ((__mmask16)__builtin_ia32_fpclassph256_mask((__v16hf)(__m256h)(A),          \
+                                               (int)(imm), (__mmask16)(U)))
+
+#define _mm256_fpclass_ph_mask(A, imm)                                         \
+  ((__mmask16)__builtin_ia32_fpclassph256_mask((__v16hf)(__m256h)(A),          \
+                                               (int)(imm), (__mmask16)-1))
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtpd_ph(__m128d __A) {
+  return (__m128h)__builtin_ia32_vcvtpd2ph128_mask(
+      (__v2df)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_cvtpd_ph(__m128h __W,
+                                                                  __mmask8 __U,
+                                                                  __m128d __A) {
+  return (__m128h)__builtin_ia32_vcvtpd2ph128_mask((__v2df)__A, (__v8hf)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtpd_ph(__mmask8 __U, __m128d __A) {
+  return (__m128h)__builtin_ia32_vcvtpd2ph128_mask(
+      (__v2df)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256 _mm256_cvtpd_ph(__m256d __A) {
+  return (__m128h)__builtin_ia32_vcvtpd2ph256_mask(
+      (__v4df)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtpd_ph(__m128h __W, __mmask8 __U, __m256d __A) {
+  return (__m128h)__builtin_ia32_vcvtpd2ph256_mask((__v4df)__A, (__v8hf)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtpd_ph(__mmask8 __U, __m256d __A) {
+  return (__m128h)__builtin_ia32_vcvtpd2ph256_mask(
+      (__v4df)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_cvtph_pd(__m128h __A) {
+  return (__m128d)__builtin_ia32_vcvtph2pd128_mask(
+      (__v8hf)__A, (__v2df)_mm_undefined_pd(), (__mmask8)-1);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128 _mm_mask_cvtph_pd(__m128d __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A) {
+  return (__m128d)__builtin_ia32_vcvtph2pd128_mask((__v8hf)__A, (__v2df)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtph_pd(__mmask8 __U, __m128h __A) {
+  return (__m128d)__builtin_ia32_vcvtph2pd128_mask(
+      (__v8hf)__A, (__v2df)_mm_setzero_pd(), (__mmask8)__U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256 _mm256_cvtph_pd(__m128h __A) {
+  return (__m256d)__builtin_ia32_vcvtph2pd256_mask(
+      (__v8hf)__A, (__v4df)_mm256_undefined_pd(), (__mmask8)-1);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtph_pd(__m256d __W, __mmask8 __U, __m128h __A) {
+  return (__m256d)__builtin_ia32_vcvtph2pd256_mask((__v8hf)__A, (__v4df)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtph_pd(__mmask8 __U, __m128h __A) {
+  return (__m256d)__builtin_ia32_vcvtph2pd256_mask(
+      (__v8hf)__A, (__v4df)_mm256_setzero_pd(), (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtph_epi16(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2w128_mask(
+      (__v8hf)__A, (__v8hi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtph_epi16(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2w128_mask((__v8hf)__A, (__v8hi)__W,
+                                                  (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtph_epi16(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2w128_mask(
+      (__v8hf)__A, (__v8hi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtph_epi16(__m256h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2w256_mask(
+      (__v16hf)__A, (__v16hi)_mm256_undefined_si256(), (__mmask16)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtph_epi16(__m256i __W, __mmask16 __U, __m256h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2w256_mask((__v16hf)__A, (__v16hi)__W,
+                                                  (__mmask16)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtph_epi16(__mmask16 __U, __m256h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2w256_mask(
+      (__v16hf)__A, (__v16hi)_mm256_setzero_si256(), (__mmask16)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvttph_epi16(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2w128_mask(
+      (__v8hf)__A, (__v8hi)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttph_epi16(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2w128_mask((__v8hf)__A, (__v8hi)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttph_epi16(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2w128_mask(
+      (__v8hf)__A, (__v8hi)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttph_epi16(__m256h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2w256_mask(
+      (__v16hf)__A, (__v16hi)_mm256_undefined_si256(), (__mmask16)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttph_epi16(__m256i __W, __mmask16 __U, __m256h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2w256_mask((__v16hf)__A, (__v16hi)__W,
+                                                   (__mmask16)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttph_epi16(__mmask16 __U, __m256h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2w256_mask(
+      (__v16hf)__A, (__v16hi)_mm256_setzero_si256(), (__mmask16)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtepi16_ph(__m128i __A) {
+  return (__m128h) __builtin_convertvector((__v8hi)__A, __v8hf);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi16_ph(__m128h __W, __mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)_mm_cvtepi16_ph(__A), (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi16_ph(__mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)_mm_cvtepi16_ph(__A), (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_cvtepi16_ph(__m256i __A) {
+  return (__m256h) __builtin_convertvector((__v16hi)__A, __v16hf);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi16_ph(__m256h __W, __mmask16 __U, __m256i __A) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U, (__v16hf)_mm256_cvtepi16_ph(__A), (__v16hf)__W);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi16_ph(__mmask16 __U, __m256i __A) {
+  return (__m256h)__builtin_ia32_selectph_256((__mmask16)__U,
+                                              (__v16hf)_mm256_cvtepi16_ph(__A),
+                                              (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtph_epu16(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2uw128_mask(
+      (__v8hf)__A, (__v8hu)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtph_epu16(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2uw128_mask((__v8hf)__A, (__v8hu)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtph_epu16(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2uw128_mask(
+      (__v8hf)__A, (__v8hu)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtph_epu16(__m256h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2uw256_mask(
+      (__v16hf)__A, (__v16hu)_mm256_undefined_si256(), (__mmask16)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtph_epu16(__m256i __W, __mmask16 __U, __m256h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2uw256_mask((__v16hf)__A, (__v16hu)__W,
+                                                   (__mmask16)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtph_epu16(__mmask16 __U, __m256h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2uw256_mask(
+      (__v16hf)__A, (__v16hu)_mm256_setzero_si256(), (__mmask16)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvttph_epu16(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2uw128_mask(
+      (__v8hf)__A, (__v8hu)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttph_epu16(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2uw128_mask((__v8hf)__A, (__v8hu)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttph_epu16(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2uw128_mask(
+      (__v8hf)__A, (__v8hu)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttph_epu16(__m256h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2uw256_mask(
+      (__v16hf)__A, (__v16hu)_mm256_undefined_si256(), (__mmask16)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttph_epu16(__m256i __W, __mmask16 __U, __m256h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2uw256_mask((__v16hf)__A, (__v16hu)__W,
+                                                    (__mmask16)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttph_epu16(__mmask16 __U, __m256h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2uw256_mask(
+      (__v16hf)__A, (__v16hu)_mm256_setzero_si256(), (__mmask16)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtepu16_ph(__m128i __A) {
+  return (__m128h) __builtin_convertvector((__v8hu)__A, __v8hf);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepu16_ph(__m128h __W, __mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)_mm_cvtepu16_ph(__A), (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepu16_ph(__mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)_mm_cvtepu16_ph(__A), (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_cvtepu16_ph(__m256i __A) {
+  return (__m256h) __builtin_convertvector((__v16hu)__A, __v16hf);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepu16_ph(__m256h __W, __mmask16 __U, __m256i __A) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U, (__v16hf)_mm256_cvtepu16_ph(__A), (__v16hf)__W);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepu16_ph(__mmask16 __U, __m256i __A) {
+  return (__m256h)__builtin_ia32_selectph_256((__mmask16)__U,
+                                              (__v16hf)_mm256_cvtepu16_ph(__A),
+                                              (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtph_epi32(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2dq128_mask(
+      (__v8hf)__A, (__v4si)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtph_epi32(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2dq128_mask((__v8hf)__A, (__v4si)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtph_epi32(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2dq128_mask(
+      (__v8hf)__A, (__v4si)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtph_epi32(__m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2dq256_mask(
+      (__v8hf)__A, (__v8si)_mm256_undefined_si256(), (__mmask8)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtph_epi32(__m256i __W, __mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2dq256_mask((__v8hf)__A, (__v8si)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtph_epi32(__mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2dq256_mask(
+      (__v8hf)__A, (__v8si)_mm256_setzero_si256(), (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtph_epu32(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2udq128_mask(
+      (__v8hf)__A, (__v4su)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtph_epu32(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2udq128_mask((__v8hf)__A, (__v4su)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtph_epu32(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2udq128_mask(
+      (__v8hf)__A, (__v4su)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtph_epu32(__m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2udq256_mask(
+      (__v8hf)__A, (__v8su)_mm256_undefined_si256(), (__mmask8)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtph_epu32(__m256i __W, __mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2udq256_mask((__v8hf)__A, (__v8su)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtph_epu32(__mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2udq256_mask(
+      (__v8hf)__A, (__v8su)_mm256_setzero_si256(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtepi32_ph(__m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtdq2ph128_mask(
+      (__v4si)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi32_ph(__m128h __W, __mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtdq2ph128_mask((__v4si)__A, (__v8hf)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi32_ph(__mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtdq2ph128_mask(
+      (__v4si)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_cvtepi32_ph(__m256i __A) {
+  return (__m128h) __builtin_convertvector((__v8si)__A, __v8hf);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi32_ph(__m128h __W, __mmask8 __U, __m256i __A) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)_mm256_cvtepi32_ph(__A), (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi32_ph(__mmask8 __U, __m256i __A) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)_mm256_cvtepi32_ph(__A), (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtepu32_ph(__m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtudq2ph128_mask(
+      (__v4su)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepu32_ph(__m128h __W, __mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtudq2ph128_mask((__v4su)__A, (__v8hf)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepu32_ph(__mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtudq2ph128_mask(
+      (__v4su)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_cvtepu32_ph(__m256i __A) {
+  return (__m128h) __builtin_convertvector((__v8su)__A, __v8hf);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepu32_ph(__m128h __W, __mmask8 __U, __m256i __A) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)_mm256_cvtepu32_ph(__A), (__v8hf)__W);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepu32_ph(__mmask8 __U, __m256i __A) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, (__v8hf)_mm256_cvtepu32_ph(__A), (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvttph_epi32(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2dq128_mask(
+      (__v8hf)__A, (__v4si)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttph_epi32(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2dq128_mask((__v8hf)__A, (__v4si)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttph_epi32(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2dq128_mask(
+      (__v8hf)__A, (__v4si)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttph_epi32(__m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2dq256_mask(
+      (__v8hf)__A, (__v8si)_mm256_undefined_si256(), (__mmask8)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttph_epi32(__m256i __W, __mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2dq256_mask((__v8hf)__A, (__v8si)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttph_epi32(__mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2dq256_mask(
+      (__v8hf)__A, (__v8si)_mm256_setzero_si256(), (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvttph_epu32(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2udq128_mask(
+      (__v8hf)__A, (__v4su)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttph_epu32(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2udq128_mask((__v8hf)__A, (__v4su)__W,
+                                                     (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttph_epu32(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2udq128_mask(
+      (__v8hf)__A, (__v4su)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttph_epu32(__m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2udq256_mask(
+      (__v8hf)__A, (__v8su)_mm256_undefined_si256(), (__mmask8)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttph_epu32(__m256i __W, __mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2udq256_mask((__v8hf)__A, (__v8su)__W,
+                                                     (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttph_epu32(__mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2udq256_mask(
+      (__v8hf)__A, (__v8su)_mm256_setzero_si256(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtepi64_ph(__m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtqq2ph128_mask(
+      (__v2di)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi64_ph(__m128h __W, __mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtqq2ph128_mask((__v2di)__A, (__v8hf)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi64_ph(__mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtqq2ph128_mask(
+      (__v2di)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_cvtepi64_ph(__m256i __A) {
+  return (__m128h)__builtin_ia32_vcvtqq2ph256_mask(
+      (__v4di)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi64_ph(__m128h __W, __mmask8 __U, __m256i __A) {
+  return (__m128h)__builtin_ia32_vcvtqq2ph256_mask((__v4di)__A, (__v8hf)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi64_ph(__mmask8 __U, __m256i __A) {
+  return (__m128h)__builtin_ia32_vcvtqq2ph256_mask(
+      (__v4di)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtph_epi64(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2qq128_mask(
+      (__v8hf)__A, (__v2di)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtph_epi64(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2qq128_mask((__v8hf)__A, (__v2di)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtph_epi64(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2qq128_mask(
+      (__v8hf)__A, (__v2di)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtph_epi64(__m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2qq256_mask(
+      (__v8hf)__A, (__v4di)_mm256_undefined_si256(), (__mmask8)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtph_epi64(__m256i __W, __mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2qq256_mask((__v8hf)__A, (__v4di)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtph_epi64(__mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2qq256_mask(
+      (__v8hf)__A, (__v4di)_mm256_setzero_si256(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtepu64_ph(__m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtuqq2ph128_mask(
+      (__v2du)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepu64_ph(__m128h __W, __mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtuqq2ph128_mask((__v2du)__A, (__v8hf)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepu64_ph(__mmask8 __U, __m128i __A) {
+  return (__m128h)__builtin_ia32_vcvtuqq2ph128_mask(
+      (__v2du)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_cvtepu64_ph(__m256i __A) {
+  return (__m128h)__builtin_ia32_vcvtuqq2ph256_mask(
+      (__v4du)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepu64_ph(__m128h __W, __mmask8 __U, __m256i __A) {
+  return (__m128h)__builtin_ia32_vcvtuqq2ph256_mask((__v4du)__A, (__v8hf)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepu64_ph(__mmask8 __U, __m256i __A) {
+  return (__m128h)__builtin_ia32_vcvtuqq2ph256_mask(
+      (__v4du)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtph_epu64(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2uqq128_mask(
+      (__v8hf)__A, (__v2du)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtph_epu64(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2uqq128_mask((__v8hf)__A, (__v2du)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtph_epu64(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvtph2uqq128_mask(
+      (__v8hf)__A, (__v2du)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtph_epu64(__m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2uqq256_mask(
+      (__v8hf)__A, (__v4du)_mm256_undefined_si256(), (__mmask8)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtph_epu64(__m256i __W, __mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2uqq256_mask((__v8hf)__A, (__v4du)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtph_epu64(__mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvtph2uqq256_mask(
+      (__v8hf)__A, (__v4du)_mm256_setzero_si256(), (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvttph_epi64(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2qq128_mask(
+      (__v8hf)__A, (__v2di)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttph_epi64(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2qq128_mask((__v8hf)__A, (__v2di)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttph_epi64(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2qq128_mask(
+      (__v8hf)__A, (__v2di)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttph_epi64(__m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2qq256_mask(
+      (__v8hf)__A, (__v4di)_mm256_undefined_si256(), (__mmask8)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttph_epi64(__m256i __W, __mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2qq256_mask((__v8hf)__A, (__v4di)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttph_epi64(__mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2qq256_mask(
+      (__v8hf)__A, (__v4di)_mm256_setzero_si256(), (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvttph_epu64(__m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2uqq128_mask(
+      (__v8hf)__A, (__v2du)_mm_undefined_si128(), (__mmask8)-1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttph_epu64(__m128i __W, __mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2uqq128_mask((__v8hf)__A, (__v2du)__W,
+                                                     (__mmask8)__U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttph_epu64(__mmask8 __U, __m128h __A) {
+  return (__m128i)__builtin_ia32_vcvttph2uqq128_mask(
+      (__v8hf)__A, (__v2du)_mm_setzero_si128(), (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttph_epu64(__m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2uqq256_mask(
+      (__v8hf)__A, (__v4du)_mm256_undefined_si256(), (__mmask8)-1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttph_epu64(__m256i __W, __mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2uqq256_mask((__v8hf)__A, (__v4du)__W,
+                                                     (__mmask8)__U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttph_epu64(__mmask8 __U, __m128h __A) {
+  return (__m256i)__builtin_ia32_vcvttph2uqq256_mask(
+      (__v8hf)__A, (__v4du)_mm256_setzero_si256(), (__mmask8)__U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_cvtxph_ps(__m128h __A) {
+  return (__m128)__builtin_ia32_vcvtph2psx128_mask(
+      (__v8hf)__A, (__v4sf)_mm_undefined_ps(), (__mmask8)-1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128 _mm_mask_cvtxph_ps(__m128 __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A) {
+  return (__m128)__builtin_ia32_vcvtph2psx128_mask((__v8hf)__A, (__v4sf)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtxph_ps(__mmask8 __U, __m128h __A) {
+  return (__m128)__builtin_ia32_vcvtph2psx128_mask(
+      (__v8hf)__A, (__v4sf)_mm_setzero_ps(), (__mmask8)__U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256 _mm256_cvtxph_ps(__m128h __A) {
+  return (__m256)__builtin_ia32_vcvtph2psx256_mask(
+      (__v8hf)__A, (__v8sf)_mm256_undefined_ps(), (__mmask8)-1);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtxph_ps(__m256 __W, __mmask8 __U, __m128h __A) {
+  return (__m256)__builtin_ia32_vcvtph2psx256_mask((__v8hf)__A, (__v8sf)__W,
+                                                   (__mmask8)__U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtxph_ps(__mmask8 __U, __m128h __A) {
+  return (__m256)__builtin_ia32_vcvtph2psx256_mask(
+      (__v8hf)__A, (__v8sf)_mm256_setzero_ps(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtxps_ph(__m128 __A) {
+  return (__m128h)__builtin_ia32_vcvtps2phx128_mask(
+      (__v4sf)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_cvtxps_ph(__m128h __W,
+                                                                   __mmask8 __U,
+                                                                   __m128 __A) {
+  return (__m128h)__builtin_ia32_vcvtps2phx128_mask((__v4sf)__A, (__v8hf)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtxps_ph(__mmask8 __U, __m128 __A) {
+  return (__m128h)__builtin_ia32_vcvtps2phx128_mask(
+      (__v4sf)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256 _mm256_cvtxps_ph(__m256 __A) {
+  return (__m128h)__builtin_ia32_vcvtps2phx256_mask(
+      (__v8sf)__A, (__v8hf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtxps_ph(__m128h __W, __mmask8 __U, __m256 __A) {
+  return (__m128h)__builtin_ia32_vcvtps2phx256_mask((__v8sf)__A, (__v8hf)__W,
+                                                    (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtxps_ph(__mmask8 __U, __m256 __A) {
+  return (__m128h)__builtin_ia32_vcvtps2phx256_mask(
+      (__v8sf)__A, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmadd_ph(__m128h __A,
+                                                             __m128h __B,
+                                                             __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddph((__v8hf)__A, (__v8hf)__B,
+                                          (__v8hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_fmadd_ph(__m128h __A,
+                                                                  __mmask8 __U,
+                                                                  __m128h __B,
+                                                                  __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddph((__v8hf)__A, (__v8hf)__B, (__v8hf)__C),
+      (__v8hf)__A);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fmadd_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddph((__v8hf)__A, (__v8hf)__B, (__v8hf)__C),
+      (__v8hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fmadd_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddph((__v8hf)__A, (__v8hf)__B, (__v8hf)__C),
+      (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmsub_ph(__m128h __A,
+                                                             __m128h __B,
+                                                             __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddph((__v8hf)__A, (__v8hf)__B,
+                                          -(__v8hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_fmsub_ph(__m128h __A,
+                                                                  __mmask8 __U,
+                                                                  __m128h __B,
+                                                                  __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, _mm_fmsub_ph((__v8hf)__A, (__v8hf)__B, (__v8hf)__C),
+      (__v8hf)__A);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fmsub_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U, _mm_fmsub_ph((__v8hf)__A, (__v8hf)__B, (__v8hf)__C),
+      (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmadd_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddph(-(__v8hf)__A, (__v8hf)__B, (__v8hf)__C),
+      (__v8hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmadd_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddph(-(__v8hf)__A, (__v8hf)__B, (__v8hf)__C),
+      (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmsub_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddph(-(__v8hf)__A, (__v8hf)__B, -(__v8hf)__C),
+      (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_fmadd_ph(__m256h __A,
+                                                                __m256h __B,
+                                                                __m256h __C) {
+  return (__m256h)__builtin_ia32_vfmaddph256((__v16hf)__A, (__v16hf)__B,
+                                             (__v16hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_fmadd_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256((__v16hf)__A, (__v16hf)__B, (__v16hf)__C),
+      (__v16hf)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmadd_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256((__v16hf)__A, (__v16hf)__B, (__v16hf)__C),
+      (__v16hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmadd_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256((__v16hf)__A, (__v16hf)__B, (__v16hf)__C),
+      (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_fmsub_ph(__m256h __A,
+                                                                __m256h __B,
+                                                                __m256h __C) {
+  return (__m256h)__builtin_ia32_vfmaddph256((__v16hf)__A, (__v16hf)__B,
+                                             -(__v16hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_fmsub_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256((__v16hf)__A, (__v16hf)__B, -(__v16hf)__C),
+      (__v16hf)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmsub_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256((__v16hf)__A, (__v16hf)__B, -(__v16hf)__C),
+      (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask3_fnmadd_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256(-(__v16hf)__A, (__v16hf)__B, (__v16hf)__C),
+      (__v16hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_fnmadd_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256(-(__v16hf)__A, (__v16hf)__B, (__v16hf)__C),
+      (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_fnmsub_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256(-(__v16hf)__A, (__v16hf)__B, -(__v16hf)__C),
+      (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmaddsub_ph(__m128h __A,
+                                                                __m128h __B,
+                                                                __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddsubph((__v8hf)__A, (__v8hf)__B,
+                                             (__v8hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fmaddsub_ph(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddsubph((__v8hf)__A, (__v8hf)__B, (__v8hf)__C),
+      (__v8hf)__A);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fmaddsub_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddsubph((__v8hf)__A, (__v8hf)__B, (__v8hf)__C),
+      (__v8hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fmaddsub_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddsubph((__v8hf)__A, (__v8hf)__B, (__v8hf)__C),
+      (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmsubadd_ph(__m128h __A,
+                                                                __m128h __B,
+                                                                __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddsubph((__v8hf)__A, (__v8hf)__B,
+                                             -(__v8hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fmsubadd_ph(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddsubph((__v8hf)__A, (__v8hf)__B, -(__v8hf)__C),
+      (__v8hf)__A);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fmsubadd_ph(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddsubph((__v8hf)__A, (__v8hf)__B, -(__v8hf)__C),
+      (__v8hf)_mm_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_fmaddsub_ph(__m256h __A, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_vfmaddsubph256((__v16hf)__A, (__v16hf)__B,
+                                                (__v16hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_fmaddsub_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddsubph256((__v16hf)__A, (__v16hf)__B, (__v16hf)__C),
+      (__v16hf)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmaddsub_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddsubph256((__v16hf)__A, (__v16hf)__B, (__v16hf)__C),
+      (__v16hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmaddsub_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddsubph256((__v16hf)__A, (__v16hf)__B, (__v16hf)__C),
+      (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_fmsubadd_ph(__m256h __A, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_vfmaddsubph256((__v16hf)__A, (__v16hf)__B,
+                                                -(__v16hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_fmsubadd_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddsubph256((__v16hf)__A, (__v16hf)__B, -(__v16hf)__C),
+      (__v16hf)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmsubadd_ph(__mmask16 __U, __m256h __A, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddsubph256((__v16hf)__A, (__v16hf)__B, -(__v16hf)__C),
+      (__v16hf)_mm256_setzero_ph());
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fmsub_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddph((__v8hf)__A, (__v8hf)__B, -(__v8hf)__C),
+      (__v8hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmsub_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256((__v16hf)__A, (__v16hf)__B, -(__v16hf)__C),
+      (__v16hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fmsubadd_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddsubph((__v8hf)__A, (__v8hf)__B, -(__v8hf)__C),
+      (__v8hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmsubadd_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddsubph256((__v16hf)__A, (__v16hf)__B, -(__v16hf)__C),
+      (__v16hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fnmadd_ph(__m128h __A,
+                                                              __m128h __B,
+                                                              __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddph((__v8hf)__A, -(__v8hf)__B,
+                                          (__v8hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fnmadd_ph(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddph((__v8hf)__A, -(__v8hf)__B, (__v8hf)__C),
+      (__v8hf)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_fnmadd_ph(__m256h __A,
+                                                                 __m256h __B,
+                                                                 __m256h __C) {
+  return (__m256h)__builtin_ia32_vfmaddph256((__v16hf)__A, -(__v16hf)__B,
+                                             (__v16hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_fnmadd_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256((__v16hf)__A, -(__v16hf)__B, (__v16hf)__C),
+      (__v16hf)__A);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fnmsub_ph(__m128h __A,
+                                                              __m128h __B,
+                                                              __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddph((__v8hf)__A, -(__v8hf)__B,
+                                          -(__v8hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fnmsub_ph(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddph((__v8hf)__A, -(__v8hf)__B, -(__v8hf)__C),
+      (__v8hf)__A);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmsub_ph(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
+  return (__m128h)__builtin_ia32_selectph_128(
+      (__mmask8)__U,
+      __builtin_ia32_vfmaddph((__v8hf)__A, -(__v8hf)__B, -(__v8hf)__C),
+      (__v8hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_fnmsub_ph(__m256h __A,
+                                                                 __m256h __B,
+                                                                 __m256h __C) {
+  return (__m256h)__builtin_ia32_vfmaddph256((__v16hf)__A, -(__v16hf)__B,
+                                             -(__v16hf)__C);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_fnmsub_ph(__m256h __A, __mmask16 __U, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256((__v16hf)__A, -(__v16hf)__B, -(__v16hf)__C),
+      (__v16hf)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask3_fnmsub_ph(__m256h __A, __m256h __B, __m256h __C, __mmask16 __U) {
+  return (__m256h)__builtin_ia32_selectph_256(
+      (__mmask16)__U,
+      __builtin_ia32_vfmaddph256((__v16hf)__A, -(__v16hf)__B, -(__v16hf)__C),
+      (__v16hf)__C);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fcmul_pch(__m128h __A,
+                                                              __m128h __B) {
+  return (__m128h)__builtin_ia32_vfcmulcph128_mask(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fcmul_pch(__m128h __W, __mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_vfcmulcph128_mask((__v4sf)__A, (__v4sf)__B,
+                                                   (__v4sf)__W, (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fcmul_pch(__mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_vfcmulcph128_mask(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS128 _mm256_fcmul_pch(__m256h __A,
+                                                                 __m256h __B) {
+  return (__m256h)__builtin_ia32_vfcmulcph256_mask(
+      (__v8sf)__A, (__v8sf)__B, (__v8sf)_mm256_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_fcmul_pch(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_vfcmulcph256_mask((__v8sf)__A, (__v8sf)__B,
+                                                   (__v8sf)__W, (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_fcmul_pch(__mmask8 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_vfcmulcph256_mask(
+      (__v8sf)__A, (__v8sf)__B, (__v8sf)_mm256_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fcmadd_pch(__m128h __A,
+                                                               __m128h __B,
+                                                               __m128h __C) {
+  return (__m128h)__builtin_ia32_vfcmaddcph128_mask((__v4sf)__A, (__v4sf)__B,
+                                                    (__v4sf)__C, (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fcmadd_pch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectps_128(
+      __U,
+      __builtin_ia32_vfcmaddcph128_mask((__v4sf)__A, (__v4sf)(__m128h)__B,
+                                        (__v4sf)__C, (__mmask8)__U),
+      (__v4sf)__A);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fcmadd_pch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
+  return (__m128h)__builtin_ia32_vfcmaddcph128_mask((__v4sf)__A, (__v4sf)__B,
+                                                    (__v4sf)__C, (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fcmadd_pch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_vfcmaddcph128_maskz(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)__C, (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_fcmadd_pch(__m256h __A,
+                                                                  __m256h __B,
+                                                                  __m256h __C) {
+  return (__m256h)__builtin_ia32_vfcmaddcph256_mask((__v8sf)__A, (__v8sf)__B,
+                                                    (__v8sf)__C, (__mmask8)-1);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_fcmadd_pch(__m256h __A, __mmask8 __U, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectps_256(
+      __U,
+      __builtin_ia32_vfcmaddcph256_mask((__v8sf)__A, (__v8sf)__B, (__v8sf)__C,
+                                        (__mmask8)__U),
+      (__v8sf)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask3_fcmadd_pch(__m256h __A, __m256h __B, __m256h __C, __mmask8 __U) {
+  return (__m256h)__builtin_ia32_vfcmaddcph256_mask((__v8sf)__A, (__v8sf)__B,
+                                                    (__v8sf)__C, (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_fcmadd_pch(__mmask8 __U, __m256h __A, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_vfcmaddcph256_maskz(
+      (__v8sf)__A, (__v8sf)__B, (__v8sf)__C, (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmul_pch(__m128h __A,
+                                                             __m128h __B) {
+  return (__m128h)__builtin_ia32_vfmulcph128_mask(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_fmul_pch(__m128h __W,
+                                                                  __mmask8 __U,
+                                                                  __m128h __A,
+                                                                  __m128h __B) {
+  return (__m128h)__builtin_ia32_vfmulcph128_mask((__v4sf)__A, (__v4sf)__B,
+                                                  (__v4sf)__W, (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fmul_pch(__mmask8 __U, __m128h __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_vfmulcph128_mask(
+      (__v4sf)__A, (__v4sf)__B, (__v4sf)_mm_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_fmul_pch(__m256h __A,
+                                                                __m256h __B) {
+  return (__m256h)__builtin_ia32_vfmulcph256_mask(
+      (__v8sf)__A, (__v8sf)__B, (__v8sf)_mm256_undefined_ph(), (__mmask8)-1);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_fmul_pch(__m256h __W, __mmask8 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_vfmulcph256_mask((__v8sf)__A, (__v8sf)__B,
+                                                  (__v8sf)__W, (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmul_pch(__mmask8 __U, __m256h __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_vfmulcph256_mask(
+      (__v8sf)__A, (__v8sf)__B, (__v8sf)_mm256_setzero_ph(), (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_fmadd_pch(__m128h __A,
+                                                              __m128h __B,
+                                                              __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddcph128_mask((__v4sf)__A, (__v4sf)__B,
+                                                   (__v4sf)__C, (__mmask8)-1);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask_fmadd_pch(__m128h __A, __mmask8 __U, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_selectps_128(
+      __U,
+      __builtin_ia32_vfmaddcph128_mask((__v4sf)__A, (__v4sf)__B, (__v4sf)__C,
+                                       (__mmask8)__U),
+      (__v4sf)__A);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_mask3_fmadd_pch(__m128h __A, __m128h __B, __m128h __C, __mmask8 __U) {
+  return (__m128h)__builtin_ia32_vfmaddcph128_mask((__v4sf)__A, (__v4sf)__B,
+                                                   (__v4sf)__C, (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_maskz_fmadd_pch(__mmask8 __U, __m128h __A, __m128h __B, __m128h __C) {
+  return (__m128h)__builtin_ia32_vfmaddcph128_maskz((__v4sf)__A, (__v4sf)__B,
+                                                    (__v4sf)__C, (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_fmadd_pch(__m256h __A,
+                                                                 __m256h __B,
+                                                                 __m256h __C) {
+  return (__m256h)__builtin_ia32_vfmaddcph256_mask((__v8sf)__A, (__v8sf)__B,
+                                                   (__v8sf)__C, (__mmask8)-1);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_fmadd_pch(__m256h __A, __mmask8 __U, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_selectps_256(
+      __U,
+      __builtin_ia32_vfmaddcph256_mask((__v8sf)__A, (__v8sf)__B, (__v8sf)__C,
+                                       (__mmask8)__U),
+      (__v8sf)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmadd_pch(__m256h __A, __m256h __B, __m256h __C, __mmask8 __U) {
+  return (__m256h)__builtin_ia32_vfmaddcph256_mask((__v8sf)__A, (__v8sf)__B,
+                                                   (__v8sf)__C, (__mmask8)__U);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmadd_pch(__mmask8 __U, __m256h __A, __m256h __B, __m256h __C) {
+  return (__m256h)__builtin_ia32_vfmaddcph256_maskz((__v8sf)__A, (__v8sf)__B,
+                                                    (__v8sf)__C, (__mmask8)__U);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_mask_blend_ph(__mmask8 __U,
+                                                                  __m128h __A,
+                                                                  __m128h __W) {
+  return (__m128h)__builtin_ia32_selectph_128((__mmask8)__U, (__v8hf)__W,
+                                              (__v8hf)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_mask_blend_ph(__mmask16 __U, __m256h __A, __m256h __W) {
+  return (__m256h)__builtin_ia32_selectph_256((__mmask16)__U, (__v16hf)__W,
+                                              (__v16hf)__A);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_permutex2var_ph(__m128h __A, __m128i __I, __m128h __B) {
+  return (__m128h)__builtin_ia32_vpermi2varhi128((__v8hi)__A, (__v8hi)__I,
+                                                 (__v8hi)__B);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_permutex2var_ph(__m256h __A, __m256i __I, __m256h __B) {
+  return (__m256h)__builtin_ia32_vpermi2varhi256((__v16hi)__A, (__v16hi)__I,
+                                                 (__v16hi)__B);
+}
+
+static __inline__ __m128h __DEFAULT_FN_ATTRS128
+_mm_permutexvar_ph(__m128i __A, __m128h __B) {
+  return (__m128h)__builtin_ia32_permvarhi128((__v8hi)__B, (__v8hi)__A);
+}
+
+static __inline__ __m256h __DEFAULT_FN_ATTRS256
+_mm256_permutexvar_ph(__m256i __A, __m256h __B) {
+  return (__m256h)__builtin_ia32_permvarhi256((__v16hi)__B, (__v16hi)__A);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS256
+_mm256_reduce_add_ph(__m256h __W) {
+  return __builtin_ia32_reduce_fadd_ph256(-0.0f16, __W);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS256
+_mm256_reduce_mul_ph(__m256h __W) {
+  return __builtin_ia32_reduce_fmul_ph256(1.0f16, __W);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS256
+_mm256_reduce_max_ph(__m256h __V) {
+  return __builtin_ia32_reduce_fmax_ph256(__V);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS256
+_mm256_reduce_min_ph(__m256h __V) {
+  return __builtin_ia32_reduce_fmin_ph256(__V);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS128
+_mm_reduce_add_ph(__m128h __W) {
+  return __builtin_ia32_reduce_fadd_ph128(-0.0f16, __W);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS128
+_mm_reduce_mul_ph(__m128h __W) {
+  return __builtin_ia32_reduce_fmul_ph128(1.0f16, __W);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS128
+_mm_reduce_max_ph(__m128h __V) {
+  return __builtin_ia32_reduce_fmax_ph128(__V);
+}
+
+static __inline__ _Float16 __DEFAULT_FN_ATTRS128
+_mm_reduce_min_ph(__m128h __V) {
+  return __builtin_ia32_reduce_fmin_ph128(__V);
+}
+
+// intrinsics below are alias for f*mul_*ch
+#define _mm_mul_pch(A, B) _mm_fmul_pch(A, B)
+#define _mm_mask_mul_pch(W, U, A, B) _mm_mask_fmul_pch(W, U, A, B)
+#define _mm_maskz_mul_pch(U, A, B) _mm_maskz_fmul_pch(U, A, B)
+#define _mm256_mul_pch(A, B) _mm256_fmul_pch(A, B)
+#define _mm256_mask_mul_pch(W, U, A, B) _mm256_mask_fmul_pch(W, U, A, B)
+#define _mm256_maskz_mul_pch(U, A, B) _mm256_maskz_fmul_pch(U, A, B)
+
+#define _mm_cmul_pch(A, B) _mm_fcmul_pch(A, B)
+#define _mm_mask_cmul_pch(W, U, A, B) _mm_mask_fcmul_pch(W, U, A, B)
+#define _mm_maskz_cmul_pch(U, A, B) _mm_maskz_fcmul_pch(U, A, B)
+#define _mm256_cmul_pch(A, B) _mm256_fcmul_pch(A, B)
+#define _mm256_mask_cmul_pch(W, U, A, B) _mm256_mask_fcmul_pch(W, U, A, B)
+#define _mm256_maskz_cmul_pch(U, A, B) _mm256_maskz_fcmul_pch(U, A, B)
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif
+#endif
diff --git a/third_party/intel/clang/avx512vlintrin.h b/third_party/intel/clang/avx512vlintrin.h
new file mode 100644
index 000000000..2a5f7b43f
--- /dev/null
+++ b/third_party/intel/clang/avx512vlintrin.h
@@ -0,0 +1,8437 @@
+/*===---- avx512vlintrin.h - AVX512VL intrinsics ---------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vlintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VLINTRIN_H
+#define __AVX512VLINTRIN_H
+
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,no-evex512"),                            \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,no-evex512"),                            \
+                 __min_vector_width__(256)))
+
+typedef short __v2hi __attribute__((__vector_size__(4)));
+typedef char __v4qi __attribute__((__vector_size__(4)));
+typedef char __v2qi __attribute__((__vector_size__(2)));
+
+/* Integer compare */
+
+#define _mm_cmpeq_epi32_mask(A, B) \
+    _mm_cmp_epi32_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm_mask_cmpeq_epi32_mask(k, A, B) \
+    _mm_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm_cmpge_epi32_mask(A, B) \
+    _mm_cmp_epi32_mask((A), (B), _MM_CMPINT_GE)
+#define _mm_mask_cmpge_epi32_mask(k, A, B) \
+    _mm_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm_cmpgt_epi32_mask(A, B) \
+    _mm_cmp_epi32_mask((A), (B), _MM_CMPINT_GT)
+#define _mm_mask_cmpgt_epi32_mask(k, A, B) \
+    _mm_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm_cmple_epi32_mask(A, B) \
+    _mm_cmp_epi32_mask((A), (B), _MM_CMPINT_LE)
+#define _mm_mask_cmple_epi32_mask(k, A, B) \
+    _mm_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm_cmplt_epi32_mask(A, B) \
+    _mm_cmp_epi32_mask((A), (B), _MM_CMPINT_LT)
+#define _mm_mask_cmplt_epi32_mask(k, A, B) \
+    _mm_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm_cmpneq_epi32_mask(A, B) \
+    _mm_cmp_epi32_mask((A), (B), _MM_CMPINT_NE)
+#define _mm_mask_cmpneq_epi32_mask(k, A, B) \
+    _mm_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm256_cmpeq_epi32_mask(A, B) \
+    _mm256_cmp_epi32_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm256_mask_cmpeq_epi32_mask(k, A, B) \
+    _mm256_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm256_cmpge_epi32_mask(A, B) \
+    _mm256_cmp_epi32_mask((A), (B), _MM_CMPINT_GE)
+#define _mm256_mask_cmpge_epi32_mask(k, A, B) \
+    _mm256_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm256_cmpgt_epi32_mask(A, B) \
+    _mm256_cmp_epi32_mask((A), (B), _MM_CMPINT_GT)
+#define _mm256_mask_cmpgt_epi32_mask(k, A, B) \
+    _mm256_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm256_cmple_epi32_mask(A, B) \
+    _mm256_cmp_epi32_mask((A), (B), _MM_CMPINT_LE)
+#define _mm256_mask_cmple_epi32_mask(k, A, B) \
+    _mm256_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm256_cmplt_epi32_mask(A, B) \
+    _mm256_cmp_epi32_mask((A), (B), _MM_CMPINT_LT)
+#define _mm256_mask_cmplt_epi32_mask(k, A, B) \
+    _mm256_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm256_cmpneq_epi32_mask(A, B) \
+    _mm256_cmp_epi32_mask((A), (B), _MM_CMPINT_NE)
+#define _mm256_mask_cmpneq_epi32_mask(k, A, B) \
+    _mm256_mask_cmp_epi32_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm_cmpeq_epu32_mask(A, B) \
+    _mm_cmp_epu32_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm_mask_cmpeq_epu32_mask(k, A, B) \
+    _mm_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm_cmpge_epu32_mask(A, B) \
+    _mm_cmp_epu32_mask((A), (B), _MM_CMPINT_GE)
+#define _mm_mask_cmpge_epu32_mask(k, A, B) \
+    _mm_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm_cmpgt_epu32_mask(A, B) \
+    _mm_cmp_epu32_mask((A), (B), _MM_CMPINT_GT)
+#define _mm_mask_cmpgt_epu32_mask(k, A, B) \
+    _mm_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm_cmple_epu32_mask(A, B) \
+    _mm_cmp_epu32_mask((A), (B), _MM_CMPINT_LE)
+#define _mm_mask_cmple_epu32_mask(k, A, B) \
+    _mm_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm_cmplt_epu32_mask(A, B) \
+    _mm_cmp_epu32_mask((A), (B), _MM_CMPINT_LT)
+#define _mm_mask_cmplt_epu32_mask(k, A, B) \
+    _mm_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm_cmpneq_epu32_mask(A, B) \
+    _mm_cmp_epu32_mask((A), (B), _MM_CMPINT_NE)
+#define _mm_mask_cmpneq_epu32_mask(k, A, B) \
+    _mm_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm256_cmpeq_epu32_mask(A, B) \
+    _mm256_cmp_epu32_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm256_mask_cmpeq_epu32_mask(k, A, B) \
+    _mm256_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm256_cmpge_epu32_mask(A, B) \
+    _mm256_cmp_epu32_mask((A), (B), _MM_CMPINT_GE)
+#define _mm256_mask_cmpge_epu32_mask(k, A, B) \
+    _mm256_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm256_cmpgt_epu32_mask(A, B) \
+    _mm256_cmp_epu32_mask((A), (B), _MM_CMPINT_GT)
+#define _mm256_mask_cmpgt_epu32_mask(k, A, B) \
+    _mm256_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm256_cmple_epu32_mask(A, B) \
+    _mm256_cmp_epu32_mask((A), (B), _MM_CMPINT_LE)
+#define _mm256_mask_cmple_epu32_mask(k, A, B) \
+    _mm256_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm256_cmplt_epu32_mask(A, B) \
+    _mm256_cmp_epu32_mask((A), (B), _MM_CMPINT_LT)
+#define _mm256_mask_cmplt_epu32_mask(k, A, B) \
+    _mm256_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm256_cmpneq_epu32_mask(A, B) \
+    _mm256_cmp_epu32_mask((A), (B), _MM_CMPINT_NE)
+#define _mm256_mask_cmpneq_epu32_mask(k, A, B) \
+    _mm256_mask_cmp_epu32_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm_cmpeq_epi64_mask(A, B) \
+    _mm_cmp_epi64_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm_mask_cmpeq_epi64_mask(k, A, B) \
+    _mm_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm_cmpge_epi64_mask(A, B) \
+    _mm_cmp_epi64_mask((A), (B), _MM_CMPINT_GE)
+#define _mm_mask_cmpge_epi64_mask(k, A, B) \
+    _mm_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm_cmpgt_epi64_mask(A, B) \
+    _mm_cmp_epi64_mask((A), (B), _MM_CMPINT_GT)
+#define _mm_mask_cmpgt_epi64_mask(k, A, B) \
+    _mm_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm_cmple_epi64_mask(A, B) \
+    _mm_cmp_epi64_mask((A), (B), _MM_CMPINT_LE)
+#define _mm_mask_cmple_epi64_mask(k, A, B) \
+    _mm_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm_cmplt_epi64_mask(A, B) \
+    _mm_cmp_epi64_mask((A), (B), _MM_CMPINT_LT)
+#define _mm_mask_cmplt_epi64_mask(k, A, B) \
+    _mm_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm_cmpneq_epi64_mask(A, B) \
+    _mm_cmp_epi64_mask((A), (B), _MM_CMPINT_NE)
+#define _mm_mask_cmpneq_epi64_mask(k, A, B) \
+    _mm_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm256_cmpeq_epi64_mask(A, B) \
+    _mm256_cmp_epi64_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm256_mask_cmpeq_epi64_mask(k, A, B) \
+    _mm256_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm256_cmpge_epi64_mask(A, B) \
+    _mm256_cmp_epi64_mask((A), (B), _MM_CMPINT_GE)
+#define _mm256_mask_cmpge_epi64_mask(k, A, B) \
+    _mm256_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm256_cmpgt_epi64_mask(A, B) \
+    _mm256_cmp_epi64_mask((A), (B), _MM_CMPINT_GT)
+#define _mm256_mask_cmpgt_epi64_mask(k, A, B) \
+    _mm256_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm256_cmple_epi64_mask(A, B) \
+    _mm256_cmp_epi64_mask((A), (B), _MM_CMPINT_LE)
+#define _mm256_mask_cmple_epi64_mask(k, A, B) \
+    _mm256_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm256_cmplt_epi64_mask(A, B) \
+    _mm256_cmp_epi64_mask((A), (B), _MM_CMPINT_LT)
+#define _mm256_mask_cmplt_epi64_mask(k, A, B) \
+    _mm256_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm256_cmpneq_epi64_mask(A, B) \
+    _mm256_cmp_epi64_mask((A), (B), _MM_CMPINT_NE)
+#define _mm256_mask_cmpneq_epi64_mask(k, A, B) \
+    _mm256_mask_cmp_epi64_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm_cmpeq_epu64_mask(A, B) \
+    _mm_cmp_epu64_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm_mask_cmpeq_epu64_mask(k, A, B) \
+    _mm_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm_cmpge_epu64_mask(A, B) \
+    _mm_cmp_epu64_mask((A), (B), _MM_CMPINT_GE)
+#define _mm_mask_cmpge_epu64_mask(k, A, B) \
+    _mm_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm_cmpgt_epu64_mask(A, B) \
+    _mm_cmp_epu64_mask((A), (B), _MM_CMPINT_GT)
+#define _mm_mask_cmpgt_epu64_mask(k, A, B) \
+    _mm_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm_cmple_epu64_mask(A, B) \
+    _mm_cmp_epu64_mask((A), (B), _MM_CMPINT_LE)
+#define _mm_mask_cmple_epu64_mask(k, A, B) \
+    _mm_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm_cmplt_epu64_mask(A, B) \
+    _mm_cmp_epu64_mask((A), (B), _MM_CMPINT_LT)
+#define _mm_mask_cmplt_epu64_mask(k, A, B) \
+    _mm_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm_cmpneq_epu64_mask(A, B) \
+    _mm_cmp_epu64_mask((A), (B), _MM_CMPINT_NE)
+#define _mm_mask_cmpneq_epu64_mask(k, A, B) \
+    _mm_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_NE)
+
+#define _mm256_cmpeq_epu64_mask(A, B) \
+    _mm256_cmp_epu64_mask((A), (B), _MM_CMPINT_EQ)
+#define _mm256_mask_cmpeq_epu64_mask(k, A, B) \
+    _mm256_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_EQ)
+#define _mm256_cmpge_epu64_mask(A, B) \
+    _mm256_cmp_epu64_mask((A), (B), _MM_CMPINT_GE)
+#define _mm256_mask_cmpge_epu64_mask(k, A, B) \
+    _mm256_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_GE)
+#define _mm256_cmpgt_epu64_mask(A, B) \
+    _mm256_cmp_epu64_mask((A), (B), _MM_CMPINT_GT)
+#define _mm256_mask_cmpgt_epu64_mask(k, A, B) \
+    _mm256_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_GT)
+#define _mm256_cmple_epu64_mask(A, B) \
+    _mm256_cmp_epu64_mask((A), (B), _MM_CMPINT_LE)
+#define _mm256_mask_cmple_epu64_mask(k, A, B) \
+    _mm256_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_LE)
+#define _mm256_cmplt_epu64_mask(A, B) \
+    _mm256_cmp_epu64_mask((A), (B), _MM_CMPINT_LT)
+#define _mm256_mask_cmplt_epu64_mask(k, A, B) \
+    _mm256_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_LT)
+#define _mm256_cmpneq_epu64_mask(A, B) \
+    _mm256_cmp_epu64_mask((A), (B), _MM_CMPINT_NE)
+#define _mm256_mask_cmpneq_epu64_mask(k, A, B) \
+    _mm256_mask_cmp_epu64_mask((k), (A), (B), _MM_CMPINT_NE)
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_add_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_add_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_add_epi32(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_add_epi32(__A, __B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_add_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_add_epi64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_add_epi64(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_add_epi64(__A, __B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sub_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_sub_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sub_epi32(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_sub_epi32(__A, __B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sub_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_sub_epi64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sub_epi64(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_sub_epi64(__A, __B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_add_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_add_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_add_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_add_epi32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_add_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_add_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_add_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_add_epi64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sub_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_sub_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sub_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_sub_epi32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sub_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_sub_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sub_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_sub_epi64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mul_epi32(__m256i __W, __mmask8 __M, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_mul_epi32(__X, __Y),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mul_epi32(__mmask8 __M, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_mul_epi32(__X, __Y),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mul_epi32(__m128i __W, __mmask8 __M, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_mul_epi32(__X, __Y),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mul_epi32(__mmask8 __M, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_mul_epi32(__X, __Y),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mul_epu32(__m256i __W, __mmask8 __M, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_mul_epu32(__X, __Y),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mul_epu32(__mmask8 __M, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_mul_epu32(__X, __Y),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mul_epu32(__m128i __W, __mmask8 __M, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_mul_epu32(__X, __Y),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mul_epu32(__mmask8 __M, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_mul_epu32(__X, __Y),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mullo_epi32(__mmask8 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_mullo_epi32(__A, __B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mullo_epi32(__m256i __W, __mmask8 __M, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_mullo_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mullo_epi32(__mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_mullo_epi32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mullo_epi32(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_mullo_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_and_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v8su)__a & (__v8su)__b);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_and_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_and_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_and_epi32(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)_mm256_mask_and_epi32(_mm256_setzero_si256(), __U, __A, __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_and_epi32(__m128i __a, __m128i __b)
+{
+  return (__m128i)((__v4su)__a & (__v4su)__b);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_and_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_and_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_and_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)_mm_mask_and_epi32(_mm_setzero_si128(), __U, __A, __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_andnot_epi32(__m256i __A, __m256i __B)
+{
+  return (__m256i)(~(__v8su)__A & (__v8su)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_andnot_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                          (__v8si)_mm256_andnot_epi32(__A, __B),
+                                          (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_andnot_epi32(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)_mm256_mask_andnot_epi32(_mm256_setzero_si256(),
+                                           __U, __A, __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_andnot_epi32(__m128i __A, __m128i __B)
+{
+  return (__m128i)(~(__v4su)__A & (__v4su)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_andnot_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_andnot_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_andnot_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)_mm_mask_andnot_epi32(_mm_setzero_si128(), __U, __A, __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_or_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v8su)__a | (__v8su)__b);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_or_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_or_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_or_epi32(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)_mm256_mask_or_epi32(_mm256_setzero_si256(), __U, __A, __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_or_epi32(__m128i __a, __m128i __b)
+{
+  return (__m128i)((__v4su)__a | (__v4su)__b);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_or_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_or_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_or_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)_mm_mask_or_epi32(_mm_setzero_si128(), __U, __A, __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_xor_epi32(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v8su)__a ^ (__v8su)__b);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_xor_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_xor_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_xor_epi32(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)_mm256_mask_xor_epi32(_mm256_setzero_si256(), __U, __A, __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_xor_epi32(__m128i __a, __m128i __b)
+{
+  return (__m128i)((__v4su)__a ^ (__v4su)__b);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_xor_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_xor_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_xor_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)_mm_mask_xor_epi32(_mm_setzero_si128(), __U, __A, __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_and_epi64(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v4du)__a & (__v4du)__b);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_and_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_and_epi64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_and_epi64(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)_mm256_mask_and_epi64(_mm256_setzero_si256(), __U, __A, __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_and_epi64(__m128i __a, __m128i __b)
+{
+  return (__m128i)((__v2du)__a & (__v2du)__b);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_and_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_and_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_and_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)_mm_mask_and_epi64(_mm_setzero_si128(), __U, __A, __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_andnot_epi64(__m256i __A, __m256i __B)
+{
+  return (__m256i)(~(__v4du)__A & (__v4du)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_andnot_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                          (__v4di)_mm256_andnot_epi64(__A, __B),
+                                          (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_andnot_epi64(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)_mm256_mask_andnot_epi64(_mm256_setzero_si256(),
+                                           __U, __A, __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_andnot_epi64(__m128i __A, __m128i __B)
+{
+  return (__m128i)(~(__v2du)__A & (__v2du)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_andnot_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_andnot_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_andnot_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)_mm_mask_andnot_epi64(_mm_setzero_si128(), __U, __A, __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_or_epi64(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v4du)__a | (__v4du)__b);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_or_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_or_epi64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_or_epi64(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)_mm256_mask_or_epi64(_mm256_setzero_si256(), __U, __A, __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_or_epi64(__m128i __a, __m128i __b)
+{
+  return (__m128i)((__v2du)__a | (__v2du)__b);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_or_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_or_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_or_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)_mm_mask_or_epi64(_mm_setzero_si128(), __U, __A, __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_xor_epi64(__m256i __a, __m256i __b)
+{
+  return (__m256i)((__v4du)__a ^ (__v4du)__b);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_xor_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_xor_epi64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_xor_epi64(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)_mm256_mask_xor_epi64(_mm256_setzero_si256(), __U, __A, __B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_xor_epi64(__m128i __a, __m128i __b)
+{
+  return (__m128i)((__v2du)__a ^ (__v2du)__b);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_xor_epi64(__m128i __W, __mmask8 __U, __m128i __A,
+        __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_xor_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_xor_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)_mm_mask_xor_epi64(_mm_setzero_si128(), __U, __A, __B);
+}
+
+#define _mm_cmp_epi32_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpd128_mask((__v4si)(__m128i)(a), \
+                                         (__v4si)(__m128i)(b), (int)(p), \
+                                         (__mmask8)-1))
+
+#define _mm_mask_cmp_epi32_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpd128_mask((__v4si)(__m128i)(a), \
+                                         (__v4si)(__m128i)(b), (int)(p), \
+                                         (__mmask8)(m)))
+
+#define _mm_cmp_epu32_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)(__m128i)(a), \
+                                          (__v4si)(__m128i)(b), (int)(p), \
+                                          (__mmask8)-1))
+
+#define _mm_mask_cmp_epu32_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpd128_mask((__v4si)(__m128i)(a), \
+                                          (__v4si)(__m128i)(b), (int)(p), \
+                                          (__mmask8)(m)))
+
+#define _mm256_cmp_epi32_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpd256_mask((__v8si)(__m256i)(a), \
+                                         (__v8si)(__m256i)(b), (int)(p), \
+                                         (__mmask8)-1))
+
+#define _mm256_mask_cmp_epi32_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpd256_mask((__v8si)(__m256i)(a), \
+                                         (__v8si)(__m256i)(b), (int)(p), \
+                                         (__mmask8)(m)))
+
+#define _mm256_cmp_epu32_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)(__m256i)(a), \
+                                          (__v8si)(__m256i)(b), (int)(p), \
+                                          (__mmask8)-1))
+
+#define _mm256_mask_cmp_epu32_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpd256_mask((__v8si)(__m256i)(a), \
+                                          (__v8si)(__m256i)(b), (int)(p), \
+                                          (__mmask8)(m)))
+
+#define _mm_cmp_epi64_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpq128_mask((__v2di)(__m128i)(a), \
+                                         (__v2di)(__m128i)(b), (int)(p), \
+                                         (__mmask8)-1))
+
+#define _mm_mask_cmp_epi64_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpq128_mask((__v2di)(__m128i)(a), \
+                                         (__v2di)(__m128i)(b), (int)(p), \
+                                         (__mmask8)(m)))
+
+#define _mm_cmp_epu64_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)(__m128i)(a), \
+                                          (__v2di)(__m128i)(b), (int)(p), \
+                                          (__mmask8)-1))
+
+#define _mm_mask_cmp_epu64_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpq128_mask((__v2di)(__m128i)(a), \
+                                          (__v2di)(__m128i)(b), (int)(p), \
+                                          (__mmask8)(m)))
+
+#define _mm256_cmp_epi64_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpq256_mask((__v4di)(__m256i)(a), \
+                                         (__v4di)(__m256i)(b), (int)(p), \
+                                         (__mmask8)-1))
+
+#define _mm256_mask_cmp_epi64_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_cmpq256_mask((__v4di)(__m256i)(a), \
+                                         (__v4di)(__m256i)(b), (int)(p), \
+                                         (__mmask8)(m)))
+
+#define _mm256_cmp_epu64_mask(a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)(__m256i)(a), \
+                                          (__v4di)(__m256i)(b), (int)(p), \
+                                          (__mmask8)-1))
+
+#define _mm256_mask_cmp_epu64_mask(m, a, b, p) \
+  ((__mmask8)__builtin_ia32_ucmpq256_mask((__v4di)(__m256i)(a), \
+                                          (__v4di)(__m256i)(b), (int)(p), \
+                                          (__mmask8)(m)))
+
+#define _mm256_cmp_ps_mask(a, b, p)  \
+  ((__mmask8)__builtin_ia32_cmpps256_mask((__v8sf)(__m256)(a), \
+                                          (__v8sf)(__m256)(b), (int)(p), \
+                                          (__mmask8)-1))
+
+#define _mm256_mask_cmp_ps_mask(m, a, b, p)  \
+  ((__mmask8)__builtin_ia32_cmpps256_mask((__v8sf)(__m256)(a), \
+                                          (__v8sf)(__m256)(b), (int)(p), \
+                                          (__mmask8)(m)))
+
+#define _mm256_cmp_pd_mask(a, b, p)  \
+  ((__mmask8)__builtin_ia32_cmppd256_mask((__v4df)(__m256d)(a), \
+                                          (__v4df)(__m256d)(b), (int)(p), \
+                                          (__mmask8)-1))
+
+#define _mm256_mask_cmp_pd_mask(m, a, b, p)  \
+  ((__mmask8)__builtin_ia32_cmppd256_mask((__v4df)(__m256d)(a), \
+                                          (__v4df)(__m256d)(b), (int)(p), \
+                                          (__mmask8)(m)))
+
+#define _mm_cmp_ps_mask(a, b, p)  \
+  ((__mmask8)__builtin_ia32_cmpps128_mask((__v4sf)(__m128)(a), \
+                                          (__v4sf)(__m128)(b), (int)(p), \
+                                          (__mmask8)-1))
+
+#define _mm_mask_cmp_ps_mask(m, a, b, p)  \
+  ((__mmask8)__builtin_ia32_cmpps128_mask((__v4sf)(__m128)(a), \
+                                          (__v4sf)(__m128)(b), (int)(p), \
+                                          (__mmask8)(m)))
+
+#define _mm_cmp_pd_mask(a, b, p)  \
+  ((__mmask8)__builtin_ia32_cmppd128_mask((__v2df)(__m128d)(a), \
+                                          (__v2df)(__m128d)(b), (int)(p), \
+                                          (__mmask8)-1))
+
+#define _mm_mask_cmp_pd_mask(m, a, b, p)  \
+  ((__mmask8)__builtin_ia32_cmppd128_mask((__v2df)(__m128d)(a), \
+                                          (__v2df)(__m128d)(b), (int)(p), \
+                                          (__mmask8)(m)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_fmadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd ((__v2df) __A,
+                                             (__v2df) __B,
+                                             (__v2df) __C),
+                    (__v2df) __A);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask3_fmadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd ((__v2df) __A,
+                                             (__v2df) __B,
+                                             (__v2df) __C),
+                    (__v2df) __C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_fmadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd ((__v2df) __A,
+                                             (__v2df) __B,
+                                             (__v2df) __C),
+                    (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_fmsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd ((__v2df) __A,
+                                             (__v2df) __B,
+                                             -(__v2df) __C),
+                    (__v2df) __A);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_fmsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd ((__v2df) __A,
+                                             (__v2df) __B,
+                                             -(__v2df) __C),
+                    (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd (-(__v2df) __A,
+                                             (__v2df) __B,
+                                             (__v2df) __C),
+                    (__v2df) __C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd (-(__v2df) __A,
+                                             (__v2df) __B,
+                                             (__v2df) __C),
+                    (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd (-(__v2df) __A,
+                                             (__v2df) __B,
+                                             -(__v2df) __C),
+                    (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_fmadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 ((__v4df) __A,
+                                                (__v4df) __B,
+                                                (__v4df) __C),
+                    (__v4df) __A);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 ((__v4df) __A,
+                                                (__v4df) __B,
+                                                (__v4df) __C),
+                    (__v4df) __C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 ((__v4df) __A,
+                                                (__v4df) __B,
+                                                (__v4df) __C),
+                    (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_fmsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 ((__v4df) __A,
+                                                (__v4df) __B,
+                                                -(__v4df) __C),
+                    (__v4df) __A);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 ((__v4df) __A,
+                                                (__v4df) __B,
+                                                -(__v4df) __C),
+                    (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask3_fnmadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 (-(__v4df) __A,
+                                                (__v4df) __B,
+                                                (__v4df) __C),
+                    (__v4df) __C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_fnmadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 (-(__v4df) __A,
+                                                (__v4df) __B,
+                                                (__v4df) __C),
+                    (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_fnmsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 (-(__v4df) __A,
+                                                (__v4df) __B,
+                                                -(__v4df) __C),
+                    (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_fmadd_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps ((__v4sf) __A,
+                                             (__v4sf) __B,
+                                             (__v4sf) __C),
+                    (__v4sf) __A);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask3_fmadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps ((__v4sf) __A,
+                                             (__v4sf) __B,
+                                             (__v4sf) __C),
+                    (__v4sf) __C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_fmadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps ((__v4sf) __A,
+                                             (__v4sf) __B,
+                                             (__v4sf) __C),
+                    (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_fmsub_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps ((__v4sf) __A,
+                                             (__v4sf) __B,
+                                             -(__v4sf) __C),
+                    (__v4sf) __A);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_fmsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps ((__v4sf) __A,
+                                             (__v4sf) __B,
+                                             -(__v4sf) __C),
+                    (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps (-(__v4sf) __A,
+                                             (__v4sf) __B,
+                                             (__v4sf) __C),
+                    (__v4sf) __C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps (-(__v4sf) __A,
+                                             (__v4sf) __B,
+                                             (__v4sf) __C),
+                    (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_fnmsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps (-(__v4sf) __A,
+                                             (__v4sf) __B,
+                                             -(__v4sf) __C),
+                    (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_fmadd_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 ((__v8sf) __A,
+                                                (__v8sf) __B,
+                                                (__v8sf) __C),
+                    (__v8sf) __A);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 ((__v8sf) __A,
+                                                (__v8sf) __B,
+                                                (__v8sf) __C),
+                    (__v8sf) __C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 ((__v8sf) __A,
+                                                (__v8sf) __B,
+                                                (__v8sf) __C),
+                    (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_fmsub_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 ((__v8sf) __A,
+                                                (__v8sf) __B,
+                                                -(__v8sf) __C),
+                    (__v8sf) __A);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 ((__v8sf) __A,
+                                                (__v8sf) __B,
+                                                -(__v8sf) __C),
+                    (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask3_fnmadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 (-(__v8sf) __A,
+                                                (__v8sf) __B,
+                                                (__v8sf) __C),
+                    (__v8sf) __C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_fnmadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 (-(__v8sf) __A,
+                                                (__v8sf) __B,
+                                                (__v8sf) __C),
+                    (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_fnmsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 (-(__v8sf) __A,
+                                                (__v8sf) __B,
+                                                -(__v8sf) __C),
+                    (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_fmaddsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd ((__v2df) __A,
+                                                (__v2df) __B,
+                                                (__v2df) __C),
+                    (__v2df) __A);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask3_fmaddsub_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd ((__v2df) __A,
+                                                (__v2df) __B,
+                                                (__v2df) __C),
+                    (__v2df) __C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_fmaddsub_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd ((__v2df) __A,
+                                                (__v2df) __B,
+                                                (__v2df) __C),
+                    (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_fmsubadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd ((__v2df) __A,
+                                                (__v2df) __B,
+                                                -(__v2df) __C),
+                    (__v2df) __A);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_fmsubadd_pd(__mmask8 __U, __m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd ((__v2df) __A,
+                                                (__v2df) __B,
+                                                -(__v2df) __C),
+                    (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_fmaddsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd256 ((__v4df) __A,
+                                                   (__v4df) __B,
+                                                   (__v4df) __C),
+                    (__v4df) __A);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmaddsub_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd256 ((__v4df) __A,
+                                                   (__v4df) __B,
+                                                   (__v4df) __C),
+                    (__v4df) __C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmaddsub_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd256 ((__v4df) __A,
+                                                   (__v4df) __B,
+                                                   (__v4df) __C),
+                    (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_fmsubadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd256 ((__v4df) __A,
+                                                   (__v4df) __B,
+                                                   -(__v4df) __C),
+                    (__v4df) __A);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmsubadd_pd(__mmask8 __U, __m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd256 ((__v4df) __A,
+                                                   (__v4df) __B,
+                                                   -(__v4df) __C),
+                    (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_fmaddsub_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps ((__v4sf) __A,
+                                                (__v4sf) __B,
+                                                (__v4sf) __C),
+                    (__v4sf) __A);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask3_fmaddsub_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps ((__v4sf) __A,
+                                                (__v4sf) __B,
+                                                (__v4sf) __C),
+                    (__v4sf) __C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_fmaddsub_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps ((__v4sf) __A,
+                                                (__v4sf) __B,
+                                                (__v4sf) __C),
+                    (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_fmsubadd_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps ((__v4sf) __A,
+                                                (__v4sf) __B,
+                                                -(__v4sf) __C),
+                    (__v4sf) __A);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_fmsubadd_ps(__mmask8 __U, __m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps ((__v4sf) __A,
+                                                (__v4sf) __B,
+                                                -(__v4sf) __C),
+                    (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_fmaddsub_ps(__m256 __A, __mmask8 __U, __m256 __B,
+                         __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps256 ((__v8sf) __A,
+                                                   (__v8sf) __B,
+                                                   (__v8sf) __C),
+                    (__v8sf) __A);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmaddsub_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps256 ((__v8sf) __A,
+                                                   (__v8sf) __B,
+                                                   (__v8sf) __C),
+                    (__v8sf) __C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmaddsub_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps256 ((__v8sf) __A,
+                                                   (__v8sf) __B,
+                                                   (__v8sf) __C),
+                    (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_fmsubadd_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps256 ((__v8sf) __A,
+                                                   (__v8sf) __B,
+                                                   -(__v8sf) __C),
+                    (__v8sf) __A);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_fmsubadd_ps(__mmask8 __U, __m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps256 ((__v8sf) __A,
+                                                   (__v8sf) __B,
+                                                   -(__v8sf) __C),
+                    (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask3_fmsub_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd ((__v2df) __A,
+                                             (__v2df) __B,
+                                             -(__v2df) __C),
+                    (__v2df) __C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmsub_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 ((__v4df) __A,
+                                                (__v4df) __B,
+                                                -(__v4df) __C),
+                    (__v4df) __C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask3_fmsub_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps ((__v4sf) __A,
+                                             (__v4sf) __B,
+                                             -(__v4sf) __C),
+                    (__v4sf) __C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmsub_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 ((__v8sf) __A,
+                                                (__v8sf) __B,
+                                                -(__v8sf) __C),
+                    (__v8sf) __C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask3_fmsubadd_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd ((__v2df) __A,
+                                                (__v2df) __B,
+                                                -(__v2df) __C),
+                    (__v2df) __C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmsubadd_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubpd256 ((__v4df) __A,
+                                                   (__v4df) __B,
+                                                   -(__v4df) __C),
+                    (__v4df) __C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask3_fmsubadd_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps ((__v4sf) __A,
+                                                (__v4sf) __B,
+                                                -(__v4sf) __C),
+                    (__v4sf) __C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask3_fmsubadd_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddsubps256 ((__v8sf) __A,
+                                                   (__v8sf) __B,
+                                                   -(__v8sf) __C),
+                    (__v8sf) __C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_fnmadd_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd ((__v2df) __A,
+                                             -(__v2df) __B,
+                                             (__v2df) __C),
+                    (__v2df) __A);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_fnmadd_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 ((__v4df) __A,
+                                                -(__v4df) __B,
+                                                (__v4df) __C),
+                    (__v4df) __A);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_fnmadd_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps ((__v4sf) __A,
+                                             -(__v4sf) __B,
+                                             (__v4sf) __C),
+                    (__v4sf) __A);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_fnmadd_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 ((__v8sf) __A,
+                                                -(__v8sf) __B,
+                                                (__v8sf) __C),
+                    (__v8sf) __A);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_fnmsub_pd(__m128d __A, __mmask8 __U, __m128d __B, __m128d __C)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd ((__v2df) __A,
+                                             -(__v2df) __B,
+                                             -(__v2df) __C),
+                    (__v2df) __A);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmsub_pd(__m128d __A, __m128d __B, __m128d __C, __mmask8 __U)
+{
+  return (__m128d) __builtin_ia32_selectpd_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd ((__v2df) __A,
+                                             -(__v2df) __B,
+                                             -(__v2df) __C),
+                    (__v2df) __C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_fnmsub_pd(__m256d __A, __mmask8 __U, __m256d __B, __m256d __C)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 ((__v4df) __A,
+                                                -(__v4df) __B,
+                                                -(__v4df) __C),
+                    (__v4df) __A);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask3_fnmsub_pd(__m256d __A, __m256d __B, __m256d __C, __mmask8 __U)
+{
+  return (__m256d) __builtin_ia32_selectpd_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddpd256 ((__v4df) __A,
+                                                -(__v4df) __B,
+                                                -(__v4df) __C),
+                    (__v4df) __C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_fnmsub_ps(__m128 __A, __mmask8 __U, __m128 __B, __m128 __C)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps ((__v4sf) __A,
+                                             -(__v4sf) __B,
+                                             -(__v4sf) __C),
+                    (__v4sf) __A);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask3_fnmsub_ps(__m128 __A, __m128 __B, __m128 __C, __mmask8 __U)
+{
+  return (__m128) __builtin_ia32_selectps_128((__mmask8) __U,
+                    __builtin_ia32_vfmaddps ((__v4sf) __A,
+                                             -(__v4sf) __B,
+                                             -(__v4sf) __C),
+                    (__v4sf) __C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_fnmsub_ps(__m256 __A, __mmask8 __U, __m256 __B, __m256 __C)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 ((__v8sf) __A,
+                                                -(__v8sf) __B,
+                                                -(__v8sf) __C),
+                    (__v8sf) __A);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask3_fnmsub_ps(__m256 __A, __m256 __B, __m256 __C, __mmask8 __U)
+{
+  return (__m256) __builtin_ia32_selectps_256((__mmask8) __U,
+                    __builtin_ia32_vfmaddps256 ((__v8sf) __A,
+                                                -(__v8sf) __B,
+                                                -(__v8sf) __C),
+                    (__v8sf) __C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_add_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_add_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_add_pd(__mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_add_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_add_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_add_pd(__A, __B),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_add_pd(__mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_add_pd(__A, __B),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_add_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_add_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_add_ps(__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_add_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_add_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_add_ps(__A, __B),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_add_ps(__mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_add_ps(__A, __B),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_blend_epi32 (__mmask8 __U, __m128i __A, __m128i __W) {
+  return (__m128i) __builtin_ia32_selectd_128 ((__mmask8) __U,
+                (__v4si) __W,
+                (__v4si) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_blend_epi32 (__mmask8 __U, __m256i __A, __m256i __W) {
+  return (__m256i) __builtin_ia32_selectd_256 ((__mmask8) __U,
+                (__v8si) __W,
+                (__v8si) __A);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_blend_pd (__mmask8 __U, __m128d __A, __m128d __W) {
+  return (__m128d) __builtin_ia32_selectpd_128 ((__mmask8) __U,
+                 (__v2df) __W,
+                 (__v2df) __A);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_blend_pd (__mmask8 __U, __m256d __A, __m256d __W) {
+  return (__m256d) __builtin_ia32_selectpd_256 ((__mmask8) __U,
+                 (__v4df) __W,
+                 (__v4df) __A);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_blend_ps (__mmask8 __U, __m128 __A, __m128 __W) {
+  return (__m128) __builtin_ia32_selectps_128 ((__mmask8) __U,
+                (__v4sf) __W,
+                (__v4sf) __A);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_blend_ps (__mmask8 __U, __m256 __A, __m256 __W) {
+  return (__m256) __builtin_ia32_selectps_256 ((__mmask8) __U,
+                (__v8sf) __W,
+                (__v8sf) __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_blend_epi64 (__mmask8 __U, __m128i __A, __m128i __W) {
+  return (__m128i) __builtin_ia32_selectq_128 ((__mmask8) __U,
+                (__v2di) __W,
+                (__v2di) __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_blend_epi64 (__mmask8 __U, __m256i __A, __m256i __W) {
+  return (__m256i) __builtin_ia32_selectq_256 ((__mmask8) __U,
+                (__v4di) __W,
+                (__v4di) __A);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_compress_pd (__m128d __W, __mmask8 __U, __m128d __A) {
+  return (__m128d) __builtin_ia32_compressdf128_mask ((__v2df) __A,
+                  (__v2df) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_compress_pd (__mmask8 __U, __m128d __A) {
+  return (__m128d) __builtin_ia32_compressdf128_mask ((__v2df) __A,
+                  (__v2df)
+                  _mm_setzero_pd (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_compress_pd (__m256d __W, __mmask8 __U, __m256d __A) {
+  return (__m256d) __builtin_ia32_compressdf256_mask ((__v4df) __A,
+                  (__v4df) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_compress_pd (__mmask8 __U, __m256d __A) {
+  return (__m256d) __builtin_ia32_compressdf256_mask ((__v4df) __A,
+                  (__v4df)
+                  _mm256_setzero_pd (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_compress_epi64 (__m128i __W, __mmask8 __U, __m128i __A) {
+  return (__m128i) __builtin_ia32_compressdi128_mask ((__v2di) __A,
+                  (__v2di) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_compress_epi64 (__mmask8 __U, __m128i __A) {
+  return (__m128i) __builtin_ia32_compressdi128_mask ((__v2di) __A,
+                  (__v2di)
+                  _mm_setzero_si128 (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_compress_epi64 (__m256i __W, __mmask8 __U, __m256i __A) {
+  return (__m256i) __builtin_ia32_compressdi256_mask ((__v4di) __A,
+                  (__v4di) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_compress_epi64 (__mmask8 __U, __m256i __A) {
+  return (__m256i) __builtin_ia32_compressdi256_mask ((__v4di) __A,
+                  (__v4di)
+                  _mm256_setzero_si256 (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_compress_ps (__m128 __W, __mmask8 __U, __m128 __A) {
+  return (__m128) __builtin_ia32_compresssf128_mask ((__v4sf) __A,
+                 (__v4sf) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_compress_ps (__mmask8 __U, __m128 __A) {
+  return (__m128) __builtin_ia32_compresssf128_mask ((__v4sf) __A,
+                 (__v4sf)
+                 _mm_setzero_ps (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_compress_ps (__m256 __W, __mmask8 __U, __m256 __A) {
+  return (__m256) __builtin_ia32_compresssf256_mask ((__v8sf) __A,
+                 (__v8sf) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_compress_ps (__mmask8 __U, __m256 __A) {
+  return (__m256) __builtin_ia32_compresssf256_mask ((__v8sf) __A,
+                 (__v8sf)
+                 _mm256_setzero_ps (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_compress_epi32 (__m128i __W, __mmask8 __U, __m128i __A) {
+  return (__m128i) __builtin_ia32_compresssi128_mask ((__v4si) __A,
+                  (__v4si) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_compress_epi32 (__mmask8 __U, __m128i __A) {
+  return (__m128i) __builtin_ia32_compresssi128_mask ((__v4si) __A,
+                  (__v4si)
+                  _mm_setzero_si128 (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_compress_epi32 (__m256i __W, __mmask8 __U, __m256i __A) {
+  return (__m256i) __builtin_ia32_compresssi256_mask ((__v8si) __A,
+                  (__v8si) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_compress_epi32 (__mmask8 __U, __m256i __A) {
+  return (__m256i) __builtin_ia32_compresssi256_mask ((__v8si) __A,
+                  (__v8si)
+                  _mm256_setzero_si256 (),
+                  (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_compressstoreu_pd (void *__P, __mmask8 __U, __m128d __A) {
+  __builtin_ia32_compressstoredf128_mask ((__v2df *) __P,
+            (__v2df) __A,
+            (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_compressstoreu_pd (void *__P, __mmask8 __U, __m256d __A) {
+  __builtin_ia32_compressstoredf256_mask ((__v4df *) __P,
+            (__v4df) __A,
+            (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_compressstoreu_epi64 (void *__P, __mmask8 __U, __m128i __A) {
+  __builtin_ia32_compressstoredi128_mask ((__v2di *) __P,
+            (__v2di) __A,
+            (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_compressstoreu_epi64 (void *__P, __mmask8 __U, __m256i __A) {
+  __builtin_ia32_compressstoredi256_mask ((__v4di *) __P,
+            (__v4di) __A,
+            (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_compressstoreu_ps (void *__P, __mmask8 __U, __m128 __A) {
+  __builtin_ia32_compressstoresf128_mask ((__v4sf *) __P,
+            (__v4sf) __A,
+            (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_compressstoreu_ps (void *__P, __mmask8 __U, __m256 __A) {
+  __builtin_ia32_compressstoresf256_mask ((__v8sf *) __P,
+            (__v8sf) __A,
+            (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_compressstoreu_epi32 (void *__P, __mmask8 __U, __m128i __A) {
+  __builtin_ia32_compressstoresi128_mask ((__v4si *) __P,
+            (__v4si) __A,
+            (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_compressstoreu_epi32 (void *__P, __mmask8 __U, __m256i __A) {
+  __builtin_ia32_compressstoresi256_mask ((__v8si *) __P,
+            (__v8si) __A,
+            (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi32_pd (__m128d __W, __mmask8 __U, __m128i __A) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8) __U,
+                                              (__v2df)_mm_cvtepi32_pd(__A),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi32_pd (__mmask8 __U, __m128i __A) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8) __U,
+                                              (__v2df)_mm_cvtepi32_pd(__A),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi32_pd (__m256d __W, __mmask8 __U, __m128i __A) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8) __U,
+                                              (__v4df)_mm256_cvtepi32_pd(__A),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi32_pd (__mmask8 __U, __m128i __A) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8) __U,
+                                              (__v4df)_mm256_cvtepi32_pd(__A),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi32_ps (__m128 __W, __mmask8 __U, __m128i __A) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_cvtepi32_ps(__A),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi32_ps (__mmask8 __U, __m128i __A) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_cvtepi32_ps(__A),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi32_ps (__m256 __W, __mmask8 __U, __m256i __A) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_cvtepi32_ps(__A),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi32_ps (__mmask8 __U, __m256i __A) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_cvtepi32_ps(__A),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtpd_epi32 (__m128i __W, __mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2dq128_mask ((__v2df) __A,
+                (__v4si) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtpd_epi32 (__mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2dq128_mask ((__v2df) __A,
+                (__v4si)
+                _mm_setzero_si128 (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtpd_epi32 (__m128i __W, __mmask8 __U, __m256d __A) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm256_cvtpd_epi32(__A),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtpd_epi32 (__mmask8 __U, __m256d __A) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm256_cvtpd_epi32(__A),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_cvtpd_ps (__m128 __W, __mmask8 __U, __m128d __A) {
+  return (__m128) __builtin_ia32_cvtpd2ps_mask ((__v2df) __A,
+            (__v4sf) __W,
+            (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtpd_ps (__mmask8 __U, __m128d __A) {
+  return (__m128) __builtin_ia32_cvtpd2ps_mask ((__v2df) __A,
+            (__v4sf)
+            _mm_setzero_ps (),
+            (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtpd_ps (__m128 __W, __mmask8 __U, __m256d __A) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm256_cvtpd_ps(__A),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtpd_ps (__mmask8 __U, __m256d __A) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm256_cvtpd_ps(__A),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtpd_epu32 (__m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2udq128_mask ((__v2df) __A,
+                 (__v4si)
+                 _mm_setzero_si128 (),
+                 (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtpd_epu32 (__m128i __W, __mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2udq128_mask ((__v2df) __A,
+                 (__v4si) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtpd_epu32 (__mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2udq128_mask ((__v2df) __A,
+                 (__v4si)
+                 _mm_setzero_si128 (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtpd_epu32 (__m256d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2udq256_mask ((__v4df) __A,
+                 (__v4si)
+                 _mm_setzero_si128 (),
+                 (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtpd_epu32 (__m128i __W, __mmask8 __U, __m256d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2udq256_mask ((__v4df) __A,
+                 (__v4si) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtpd_epu32 (__mmask8 __U, __m256d __A) {
+  return (__m128i) __builtin_ia32_cvtpd2udq256_mask ((__v4df) __A,
+                 (__v4si)
+                 _mm_setzero_si128 (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtps_epi32 (__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_cvtps_epi32(__A),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtps_epi32 (__mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_cvtps_epi32(__A),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtps_epi32 (__m256i __W, __mmask8 __U, __m256 __A) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_cvtps_epi32(__A),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtps_epi32 (__mmask8 __U, __m256 __A) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_cvtps_epi32(__A),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_cvtps_pd (__m128d __W, __mmask8 __U, __m128 __A) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_cvtps_pd(__A),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtps_pd (__mmask8 __U, __m128 __A) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_cvtps_pd(__A),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtps_pd (__m256d __W, __mmask8 __U, __m128 __A) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_cvtps_pd(__A),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtps_pd (__mmask8 __U, __m128 __A) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_cvtps_pd(__A),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtps_epu32 (__m128 __A) {
+  return (__m128i) __builtin_ia32_cvtps2udq128_mask ((__v4sf) __A,
+                 (__v4si)
+                 _mm_setzero_si128 (),
+                 (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtps_epu32 (__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvtps2udq128_mask ((__v4sf) __A,
+                 (__v4si) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtps_epu32 (__mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvtps2udq128_mask ((__v4sf) __A,
+                 (__v4si)
+                 _mm_setzero_si128 (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtps_epu32 (__m256 __A) {
+  return (__m256i) __builtin_ia32_cvtps2udq256_mask ((__v8sf) __A,
+                 (__v8si)
+                 _mm256_setzero_si256 (),
+                 (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtps_epu32 (__m256i __W, __mmask8 __U, __m256 __A) {
+  return (__m256i) __builtin_ia32_cvtps2udq256_mask ((__v8sf) __A,
+                 (__v8si) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtps_epu32 (__mmask8 __U, __m256 __A) {
+  return (__m256i) __builtin_ia32_cvtps2udq256_mask ((__v8sf) __A,
+                 (__v8si)
+                 _mm256_setzero_si256 (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttpd_epi32 (__m128i __W, __mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2dq128_mask ((__v2df) __A,
+                 (__v4si) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttpd_epi32 (__mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2dq128_mask ((__v2df) __A,
+                 (__v4si)
+                 _mm_setzero_si128 (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttpd_epi32 (__m128i __W, __mmask8 __U, __m256d __A) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm256_cvttpd_epi32(__A),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttpd_epi32 (__mmask8 __U, __m256d __A) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm256_cvttpd_epi32(__A),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvttpd_epu32 (__m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2udq128_mask ((__v2df) __A,
+                  (__v4si)
+                  _mm_setzero_si128 (),
+                  (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttpd_epu32 (__m128i __W, __mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2udq128_mask ((__v2df) __A,
+                  (__v4si) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttpd_epu32 (__mmask8 __U, __m128d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2udq128_mask ((__v2df) __A,
+                  (__v4si)
+                  _mm_setzero_si128 (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvttpd_epu32 (__m256d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2udq256_mask ((__v4df) __A,
+                  (__v4si)
+                  _mm_setzero_si128 (),
+                  (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttpd_epu32 (__m128i __W, __mmask8 __U, __m256d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2udq256_mask ((__v4df) __A,
+                  (__v4si) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttpd_epu32 (__mmask8 __U, __m256d __A) {
+  return (__m128i) __builtin_ia32_cvttpd2udq256_mask ((__v4df) __A,
+                  (__v4si)
+                  _mm_setzero_si128 (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttps_epi32 (__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_cvttps_epi32(__A),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttps_epi32 (__mmask8 __U, __m128 __A) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_cvttps_epi32(__A),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttps_epi32 (__m256i __W, __mmask8 __U, __m256 __A) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_cvttps_epi32(__A),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttps_epi32 (__mmask8 __U, __m256 __A) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_cvttps_epi32(__A),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvttps_epu32 (__m128 __A) {
+  return (__m128i) __builtin_ia32_cvttps2udq128_mask ((__v4sf) __A,
+                  (__v4si)
+                  _mm_setzero_si128 (),
+                  (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvttps_epu32 (__m128i __W, __mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvttps2udq128_mask ((__v4sf) __A,
+                  (__v4si) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvttps_epu32 (__mmask8 __U, __m128 __A) {
+  return (__m128i) __builtin_ia32_cvttps2udq128_mask ((__v4sf) __A,
+                  (__v4si)
+                  _mm_setzero_si128 (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvttps_epu32 (__m256 __A) {
+  return (__m256i) __builtin_ia32_cvttps2udq256_mask ((__v8sf) __A,
+                  (__v8si)
+                  _mm256_setzero_si256 (),
+                  (__mmask8) -1);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvttps_epu32 (__m256i __W, __mmask8 __U, __m256 __A) {
+  return (__m256i) __builtin_ia32_cvttps2udq256_mask ((__v8sf) __A,
+                  (__v8si) __W,
+                  (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvttps_epu32 (__mmask8 __U, __m256 __A) {
+  return (__m256i) __builtin_ia32_cvttps2udq256_mask ((__v8sf) __A,
+                  (__v8si)
+                  _mm256_setzero_si256 (),
+                  (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_cvtepu32_pd (__m128i __A) {
+  return (__m128d) __builtin_convertvector(
+      __builtin_shufflevector((__v4su)__A, (__v4su)__A, 0, 1), __v2df);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepu32_pd (__m128d __W, __mmask8 __U, __m128i __A) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8) __U,
+                                              (__v2df)_mm_cvtepu32_pd(__A),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepu32_pd (__mmask8 __U, __m128i __A) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8) __U,
+                                              (__v2df)_mm_cvtepu32_pd(__A),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_cvtepu32_pd (__m128i __A) {
+  return (__m256d)__builtin_convertvector((__v4su)__A, __v4df);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepu32_pd (__m256d __W, __mmask8 __U, __m128i __A) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8) __U,
+                                              (__v4df)_mm256_cvtepu32_pd(__A),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepu32_pd (__mmask8 __U, __m128i __A) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8) __U,
+                                              (__v4df)_mm256_cvtepu32_pd(__A),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_cvtepu32_ps (__m128i __A) {
+  return (__m128)__builtin_convertvector((__v4su)__A, __v4sf);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepu32_ps (__m128 __W, __mmask8 __U, __m128i __A) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_cvtepu32_ps(__A),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepu32_ps (__mmask8 __U, __m128i __A) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_cvtepu32_ps(__A),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_cvtepu32_ps (__m256i __A) {
+  return (__m256)__builtin_convertvector((__v8su)__A, __v8sf);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepu32_ps (__m256 __W, __mmask8 __U, __m256i __A) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_cvtepu32_ps(__A),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepu32_ps (__mmask8 __U, __m256i __A) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_cvtepu32_ps(__A),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_div_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_div_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_div_pd(__mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_div_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_div_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_div_pd(__A, __B),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_div_pd(__mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_div_pd(__A, __B),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_div_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_div_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_div_ps(__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_div_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_div_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_div_ps(__A, __B),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_div_ps(__mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_div_ps(__A, __B),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_expand_pd (__m128d __W, __mmask8 __U, __m128d __A) {
+  return (__m128d) __builtin_ia32_expanddf128_mask ((__v2df) __A,
+                (__v2df) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_expand_pd (__mmask8 __U, __m128d __A) {
+  return (__m128d) __builtin_ia32_expanddf128_mask ((__v2df) __A,
+                 (__v2df)
+                 _mm_setzero_pd (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_expand_pd (__m256d __W, __mmask8 __U, __m256d __A) {
+  return (__m256d) __builtin_ia32_expanddf256_mask ((__v4df) __A,
+                (__v4df) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_expand_pd (__mmask8 __U, __m256d __A) {
+  return (__m256d) __builtin_ia32_expanddf256_mask ((__v4df) __A,
+                 (__v4df)
+                 _mm256_setzero_pd (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_expand_epi64 (__m128i __W, __mmask8 __U, __m128i __A) {
+  return (__m128i) __builtin_ia32_expanddi128_mask ((__v2di) __A,
+                (__v2di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_expand_epi64 (__mmask8 __U, __m128i __A) {
+  return (__m128i) __builtin_ia32_expanddi128_mask ((__v2di) __A,
+                 (__v2di)
+                 _mm_setzero_si128 (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_expand_epi64 (__m256i __W, __mmask8 __U, __m256i __A) {
+  return (__m256i) __builtin_ia32_expanddi256_mask ((__v4di) __A,
+                (__v4di) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_expand_epi64 (__mmask8 __U, __m256i __A) {
+  return (__m256i) __builtin_ia32_expanddi256_mask ((__v4di) __A,
+                 (__v4di)
+                 _mm256_setzero_si256 (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_expandloadu_pd (__m128d __W, __mmask8 __U, void const *__P) {
+  return (__m128d) __builtin_ia32_expandloaddf128_mask ((const __v2df *) __P,
+              (__v2df) __W,
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_expandloadu_pd (__mmask8 __U, void const *__P) {
+  return (__m128d) __builtin_ia32_expandloaddf128_mask ((const __v2df *) __P,
+               (__v2df)
+               _mm_setzero_pd (),
+               (__mmask8)
+               __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_expandloadu_pd (__m256d __W, __mmask8 __U, void const *__P) {
+  return (__m256d) __builtin_ia32_expandloaddf256_mask ((const __v4df *) __P,
+              (__v4df) __W,
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_expandloadu_pd (__mmask8 __U, void const *__P) {
+  return (__m256d) __builtin_ia32_expandloaddf256_mask ((const __v4df *) __P,
+               (__v4df)
+               _mm256_setzero_pd (),
+               (__mmask8)
+               __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_expandloadu_epi64 (__m128i __W, __mmask8 __U, void const *__P) {
+  return (__m128i) __builtin_ia32_expandloaddi128_mask ((const __v2di *) __P,
+              (__v2di) __W,
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_expandloadu_epi64 (__mmask8 __U, void const *__P) {
+  return (__m128i) __builtin_ia32_expandloaddi128_mask ((const __v2di *) __P,
+               (__v2di)
+               _mm_setzero_si128 (),
+               (__mmask8)
+               __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_expandloadu_epi64 (__m256i __W, __mmask8 __U,
+             void const *__P) {
+  return (__m256i) __builtin_ia32_expandloaddi256_mask ((const __v4di *) __P,
+              (__v4di) __W,
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_expandloadu_epi64 (__mmask8 __U, void const *__P) {
+  return (__m256i) __builtin_ia32_expandloaddi256_mask ((const __v4di *) __P,
+               (__v4di)
+               _mm256_setzero_si256 (),
+               (__mmask8)
+               __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_expandloadu_ps (__m128 __W, __mmask8 __U, void const *__P) {
+  return (__m128) __builtin_ia32_expandloadsf128_mask ((const __v4sf *) __P,
+                   (__v4sf) __W,
+                   (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_expandloadu_ps (__mmask8 __U, void const *__P) {
+  return (__m128) __builtin_ia32_expandloadsf128_mask ((const __v4sf *) __P,
+              (__v4sf)
+              _mm_setzero_ps (),
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_expandloadu_ps (__m256 __W, __mmask8 __U, void const *__P) {
+  return (__m256) __builtin_ia32_expandloadsf256_mask ((const __v8sf *) __P,
+                   (__v8sf) __W,
+                   (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_expandloadu_ps (__mmask8 __U, void const *__P) {
+  return (__m256) __builtin_ia32_expandloadsf256_mask ((const __v8sf *) __P,
+              (__v8sf)
+              _mm256_setzero_ps (),
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_expandloadu_epi32 (__m128i __W, __mmask8 __U, void const *__P) {
+  return (__m128i) __builtin_ia32_expandloadsi128_mask ((const __v4si *) __P,
+              (__v4si) __W,
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_expandloadu_epi32 (__mmask8 __U, void const *__P) {
+  return (__m128i) __builtin_ia32_expandloadsi128_mask ((const __v4si *) __P,
+               (__v4si)
+               _mm_setzero_si128 (),
+               (__mmask8)     __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_expandloadu_epi32 (__m256i __W, __mmask8 __U,
+             void const *__P) {
+  return (__m256i) __builtin_ia32_expandloadsi256_mask ((const __v8si *) __P,
+              (__v8si) __W,
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_expandloadu_epi32 (__mmask8 __U, void const *__P) {
+  return (__m256i) __builtin_ia32_expandloadsi256_mask ((const __v8si *) __P,
+               (__v8si)
+               _mm256_setzero_si256 (),
+               (__mmask8)
+               __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_expand_ps (__m128 __W, __mmask8 __U, __m128 __A) {
+  return (__m128) __builtin_ia32_expandsf128_mask ((__v4sf) __A,
+               (__v4sf) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_expand_ps (__mmask8 __U, __m128 __A) {
+  return (__m128) __builtin_ia32_expandsf128_mask ((__v4sf) __A,
+                (__v4sf)
+                _mm_setzero_ps (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_expand_ps (__m256 __W, __mmask8 __U, __m256 __A) {
+  return (__m256) __builtin_ia32_expandsf256_mask ((__v8sf) __A,
+               (__v8sf) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_expand_ps (__mmask8 __U, __m256 __A) {
+  return (__m256) __builtin_ia32_expandsf256_mask ((__v8sf) __A,
+                (__v8sf)
+                _mm256_setzero_ps (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_expand_epi32 (__m128i __W, __mmask8 __U, __m128i __A) {
+  return (__m128i) __builtin_ia32_expandsi128_mask ((__v4si) __A,
+                (__v4si) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_expand_epi32 (__mmask8 __U, __m128i __A) {
+  return (__m128i) __builtin_ia32_expandsi128_mask ((__v4si) __A,
+                 (__v4si)
+                 _mm_setzero_si128 (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_expand_epi32 (__m256i __W, __mmask8 __U, __m256i __A) {
+  return (__m256i) __builtin_ia32_expandsi256_mask ((__v8si) __A,
+                (__v8si) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_expand_epi32 (__mmask8 __U, __m256i __A) {
+  return (__m256i) __builtin_ia32_expandsi256_mask ((__v8si) __A,
+                 (__v8si)
+                 _mm256_setzero_si256 (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_getexp_pd (__m128d __A) {
+  return (__m128d) __builtin_ia32_getexppd128_mask ((__v2df) __A,
+                (__v2df)
+                _mm_setzero_pd (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_getexp_pd (__m128d __W, __mmask8 __U, __m128d __A) {
+  return (__m128d) __builtin_ia32_getexppd128_mask ((__v2df) __A,
+                (__v2df) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_getexp_pd (__mmask8 __U, __m128d __A) {
+  return (__m128d) __builtin_ia32_getexppd128_mask ((__v2df) __A,
+                (__v2df)
+                _mm_setzero_pd (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_getexp_pd (__m256d __A) {
+  return (__m256d) __builtin_ia32_getexppd256_mask ((__v4df) __A,
+                (__v4df)
+                _mm256_setzero_pd (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_getexp_pd (__m256d __W, __mmask8 __U, __m256d __A) {
+  return (__m256d) __builtin_ia32_getexppd256_mask ((__v4df) __A,
+                (__v4df) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_getexp_pd (__mmask8 __U, __m256d __A) {
+  return (__m256d) __builtin_ia32_getexppd256_mask ((__v4df) __A,
+                (__v4df)
+                _mm256_setzero_pd (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_getexp_ps (__m128 __A) {
+  return (__m128) __builtin_ia32_getexpps128_mask ((__v4sf) __A,
+               (__v4sf)
+               _mm_setzero_ps (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_getexp_ps (__m128 __W, __mmask8 __U, __m128 __A) {
+  return (__m128) __builtin_ia32_getexpps128_mask ((__v4sf) __A,
+               (__v4sf) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_getexp_ps (__mmask8 __U, __m128 __A) {
+  return (__m128) __builtin_ia32_getexpps128_mask ((__v4sf) __A,
+               (__v4sf)
+               _mm_setzero_ps (),
+               (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_getexp_ps (__m256 __A) {
+  return (__m256) __builtin_ia32_getexpps256_mask ((__v8sf) __A,
+               (__v8sf)
+               _mm256_setzero_ps (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_getexp_ps (__m256 __W, __mmask8 __U, __m256 __A) {
+  return (__m256) __builtin_ia32_getexpps256_mask ((__v8sf) __A,
+               (__v8sf) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_getexp_ps (__mmask8 __U, __m256 __A) {
+  return (__m256) __builtin_ia32_getexpps256_mask ((__v8sf) __A,
+               (__v8sf)
+               _mm256_setzero_ps (),
+               (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_max_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_max_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_max_pd(__mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_max_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_max_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_max_pd(__A, __B),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_pd(__mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_max_pd(__A, __B),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_max_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_max_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_max_ps(__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_max_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_max_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_max_ps(__A, __B),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_ps(__mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_max_ps(__A, __B),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_min_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_min_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_min_pd(__mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_min_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_min_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_min_pd(__A, __B),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_pd(__mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_min_pd(__A, __B),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_min_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_min_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_min_ps(__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_min_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_min_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_min_ps(__A, __B),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_ps(__mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_min_ps(__A, __B),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_mul_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_mul_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_mul_pd(__mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_mul_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_mul_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_mul_pd(__A, __B),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_mul_pd(__mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_mul_pd(__A, __B),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_mul_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_mul_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_mul_ps(__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_mul_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_mul_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_mul_ps(__A, __B),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_mul_ps(__mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_mul_ps(__A, __B),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_abs_epi32(__m128i __W, __mmask8 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_abs_epi32(__A),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_abs_epi32(__mmask8 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_abs_epi32(__A),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_abs_epi32(__m256i __W, __mmask8 __U, __m256i __A) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_abs_epi32(__A),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_abs_epi32(__mmask8 __U, __m256i __A) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_abs_epi32(__A),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_abs_epi64 (__m128i __A) {
+  return (__m128i)__builtin_elementwise_abs((__v2di)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_abs_epi64 (__m128i __W, __mmask8 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_abs_epi64(__A),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_abs_epi64 (__mmask8 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_abs_epi64(__A),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_abs_epi64 (__m256i __A) {
+  return (__m256i)__builtin_elementwise_abs((__v4di)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_abs_epi64 (__m256i __W, __mmask8 __U, __m256i __A) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_abs_epi64(__A),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_abs_epi64 (__mmask8 __U, __m256i __A) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_abs_epi64(__A),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_max_epi32(__mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_max_epi32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_max_epi32(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_max_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_epi32(__mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_max_epi32(__A, __B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_max_epi32(__m256i __W, __mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_max_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_max_epi64 (__m128i __A, __m128i __B) {
+  return (__m128i)__builtin_elementwise_max((__v2di)__A, (__v2di)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_max_epi64 (__mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_max_epi64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_max_epi64 (__m128i __W, __mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_max_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_max_epi64 (__m256i __A, __m256i __B) {
+  return (__m256i)__builtin_elementwise_max((__v4di)__A, (__v4di)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_epi64 (__mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_max_epi64(__A, __B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_max_epi64 (__m256i __W, __mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_max_epi64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_max_epu32(__mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_max_epu32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_max_epu32(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_max_epu32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_epu32(__mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_max_epu32(__A, __B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_max_epu32(__m256i __W, __mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_max_epu32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_max_epu64 (__m128i __A, __m128i __B) {
+  return (__m128i)__builtin_elementwise_max((__v2du)__A, (__v2du)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_max_epu64 (__mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_max_epu64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_max_epu64 (__m128i __W, __mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_max_epu64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_max_epu64 (__m256i __A, __m256i __B) {
+  return (__m256i)__builtin_elementwise_max((__v4du)__A, (__v4du)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_max_epu64 (__mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_max_epu64(__A, __B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_max_epu64 (__m256i __W, __mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_max_epu64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_min_epi32(__mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_min_epi32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_min_epi32(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_min_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_epi32(__mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_min_epi32(__A, __B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_min_epi32(__m256i __W, __mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_min_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_min_epi64 (__m128i __A, __m128i __B) {
+  return (__m128i)__builtin_elementwise_min((__v2di)__A, (__v2di)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_min_epi64 (__m128i __W, __mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_min_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_min_epi64 (__mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_min_epi64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_min_epi64 (__m256i __A, __m256i __B) {
+  return (__m256i)__builtin_elementwise_min((__v4di)__A, (__v4di)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_min_epi64 (__m256i __W, __mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_min_epi64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_epi64 (__mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_min_epi64(__A, __B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_min_epu32(__mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_min_epu32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_min_epu32(__m128i __W, __mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm_min_epu32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_epu32(__mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_min_epu32(__A, __B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_min_epu32(__m256i __W, __mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                             (__v8si)_mm256_min_epu32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_min_epu64 (__m128i __A, __m128i __B) {
+  return (__m128i)__builtin_elementwise_min((__v2du)__A, (__v2du)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_min_epu64 (__m128i __W, __mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_min_epu64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_min_epu64 (__mmask8 __M, __m128i __A, __m128i __B) {
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__M,
+                                             (__v2di)_mm_min_epu64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_min_epu64 (__m256i __A, __m256i __B) {
+  return (__m256i)__builtin_elementwise_min((__v4du)__A, (__v4du)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_min_epu64 (__m256i __W, __mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_min_epu64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_min_epu64 (__mmask8 __M, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                             (__v4di)_mm256_min_epu64(__A, __B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+#define _mm_roundscale_pd(A, imm) \
+  ((__m128d)__builtin_ia32_rndscalepd_128_mask((__v2df)(__m128d)(A), \
+                                               (int)(imm), \
+                                               (__v2df)_mm_setzero_pd(), \
+                                               (__mmask8)-1))
+
+
+#define _mm_mask_roundscale_pd(W, U, A, imm) \
+  ((__m128d)__builtin_ia32_rndscalepd_128_mask((__v2df)(__m128d)(A), \
+                                               (int)(imm), \
+                                               (__v2df)(__m128d)(W), \
+                                               (__mmask8)(U)))
+
+
+#define _mm_maskz_roundscale_pd(U, A, imm) \
+  ((__m128d)__builtin_ia32_rndscalepd_128_mask((__v2df)(__m128d)(A), \
+                                               (int)(imm), \
+                                               (__v2df)_mm_setzero_pd(), \
+                                               (__mmask8)(U)))
+
+
+#define _mm256_roundscale_pd(A, imm) \
+  ((__m256d)__builtin_ia32_rndscalepd_256_mask((__v4df)(__m256d)(A), \
+                                               (int)(imm), \
+                                               (__v4df)_mm256_setzero_pd(), \
+                                               (__mmask8)-1))
+
+
+#define _mm256_mask_roundscale_pd(W, U, A, imm) \
+  ((__m256d)__builtin_ia32_rndscalepd_256_mask((__v4df)(__m256d)(A), \
+                                               (int)(imm), \
+                                               (__v4df)(__m256d)(W), \
+                                               (__mmask8)(U)))
+
+
+#define _mm256_maskz_roundscale_pd(U, A, imm)  \
+  ((__m256d)__builtin_ia32_rndscalepd_256_mask((__v4df)(__m256d)(A), \
+                                               (int)(imm), \
+                                               (__v4df)_mm256_setzero_pd(), \
+                                               (__mmask8)(U)))
+
+#define _mm_roundscale_ps(A, imm)  \
+  ((__m128)__builtin_ia32_rndscaleps_128_mask((__v4sf)(__m128)(A), (int)(imm), \
+                                              (__v4sf)_mm_setzero_ps(), \
+                                              (__mmask8)-1))
+
+
+#define _mm_mask_roundscale_ps(W, U, A, imm)  \
+  ((__m128)__builtin_ia32_rndscaleps_128_mask((__v4sf)(__m128)(A), (int)(imm), \
+                                              (__v4sf)(__m128)(W), \
+                                              (__mmask8)(U)))
+
+
+#define _mm_maskz_roundscale_ps(U, A, imm)  \
+  ((__m128)__builtin_ia32_rndscaleps_128_mask((__v4sf)(__m128)(A), (int)(imm), \
+                                              (__v4sf)_mm_setzero_ps(), \
+                                              (__mmask8)(U)))
+
+#define _mm256_roundscale_ps(A, imm)  \
+  ((__m256)__builtin_ia32_rndscaleps_256_mask((__v8sf)(__m256)(A), (int)(imm), \
+                                              (__v8sf)_mm256_setzero_ps(), \
+                                              (__mmask8)-1))
+
+#define _mm256_mask_roundscale_ps(W, U, A, imm)  \
+  ((__m256)__builtin_ia32_rndscaleps_256_mask((__v8sf)(__m256)(A), (int)(imm), \
+                                              (__v8sf)(__m256)(W), \
+                                              (__mmask8)(U)))
+
+
+#define _mm256_maskz_roundscale_ps(U, A, imm)  \
+  ((__m256)__builtin_ia32_rndscaleps_256_mask((__v8sf)(__m256)(A), (int)(imm), \
+                                              (__v8sf)_mm256_setzero_ps(), \
+                                              (__mmask8)(U)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_scalef_pd (__m128d __A, __m128d __B) {
+  return (__m128d) __builtin_ia32_scalefpd128_mask ((__v2df) __A,
+                (__v2df) __B,
+                (__v2df)
+                _mm_setzero_pd (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_scalef_pd (__m128d __W, __mmask8 __U, __m128d __A,
+        __m128d __B) {
+  return (__m128d) __builtin_ia32_scalefpd128_mask ((__v2df) __A,
+                (__v2df) __B,
+                (__v2df) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_scalef_pd (__mmask8 __U, __m128d __A, __m128d __B) {
+  return (__m128d) __builtin_ia32_scalefpd128_mask ((__v2df) __A,
+                (__v2df) __B,
+                (__v2df)
+                _mm_setzero_pd (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_scalef_pd (__m256d __A, __m256d __B) {
+  return (__m256d) __builtin_ia32_scalefpd256_mask ((__v4df) __A,
+                (__v4df) __B,
+                (__v4df)
+                _mm256_setzero_pd (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_scalef_pd (__m256d __W, __mmask8 __U, __m256d __A,
+           __m256d __B) {
+  return (__m256d) __builtin_ia32_scalefpd256_mask ((__v4df) __A,
+                (__v4df) __B,
+                (__v4df) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_scalef_pd (__mmask8 __U, __m256d __A, __m256d __B) {
+  return (__m256d) __builtin_ia32_scalefpd256_mask ((__v4df) __A,
+                (__v4df) __B,
+                (__v4df)
+                _mm256_setzero_pd (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_scalef_ps (__m128 __A, __m128 __B) {
+  return (__m128) __builtin_ia32_scalefps128_mask ((__v4sf) __A,
+               (__v4sf) __B,
+               (__v4sf)
+               _mm_setzero_ps (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_scalef_ps (__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128) __builtin_ia32_scalefps128_mask ((__v4sf) __A,
+               (__v4sf) __B,
+               (__v4sf) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_scalef_ps (__mmask8 __U, __m128 __A, __m128 __B) {
+  return (__m128) __builtin_ia32_scalefps128_mask ((__v4sf) __A,
+               (__v4sf) __B,
+               (__v4sf)
+               _mm_setzero_ps (),
+               (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_scalef_ps (__m256 __A, __m256 __B) {
+  return (__m256) __builtin_ia32_scalefps256_mask ((__v8sf) __A,
+               (__v8sf) __B,
+               (__v8sf)
+               _mm256_setzero_ps (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_scalef_ps (__m256 __W, __mmask8 __U, __m256 __A,
+           __m256 __B) {
+  return (__m256) __builtin_ia32_scalefps256_mask ((__v8sf) __A,
+               (__v8sf) __B,
+               (__v8sf) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_scalef_ps (__mmask8 __U, __m256 __A, __m256 __B) {
+  return (__m256) __builtin_ia32_scalefps256_mask ((__v8sf) __A,
+               (__v8sf) __B,
+               (__v8sf)
+               _mm256_setzero_ps (),
+               (__mmask8) __U);
+}
+
+#define _mm_i64scatter_pd(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv2df((void *)(addr), (__mmask8)-1, \
+                               (__v2di)(__m128i)(index), \
+                               (__v2df)(__m128d)(v1), (int)(scale))
+
+#define _mm_mask_i64scatter_pd(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv2df((void *)(addr), (__mmask8)(mask), \
+                               (__v2di)(__m128i)(index), \
+                               (__v2df)(__m128d)(v1), (int)(scale))
+
+#define _mm_i64scatter_epi64(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv2di((void *)(addr), (__mmask8)-1, \
+                               (__v2di)(__m128i)(index), \
+                               (__v2di)(__m128i)(v1), (int)(scale))
+
+#define _mm_mask_i64scatter_epi64(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv2di((void *)(addr), (__mmask8)(mask), \
+                               (__v2di)(__m128i)(index), \
+                               (__v2di)(__m128i)(v1), (int)(scale))
+
+#define _mm256_i64scatter_pd(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv4df((void *)(addr), (__mmask8)-1, \
+                               (__v4di)(__m256i)(index), \
+                               (__v4df)(__m256d)(v1), (int)(scale))
+
+#define _mm256_mask_i64scatter_pd(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv4df((void *)(addr), (__mmask8)(mask), \
+                               (__v4di)(__m256i)(index), \
+                               (__v4df)(__m256d)(v1), (int)(scale))
+
+#define _mm256_i64scatter_epi64(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv4di((void *)(addr), (__mmask8)-1, \
+                               (__v4di)(__m256i)(index), \
+                               (__v4di)(__m256i)(v1), (int)(scale))
+
+#define _mm256_mask_i64scatter_epi64(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv4di((void *)(addr), (__mmask8)(mask), \
+                               (__v4di)(__m256i)(index), \
+                               (__v4di)(__m256i)(v1), (int)(scale))
+
+#define _mm_i64scatter_ps(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv4sf((void *)(addr), (__mmask8)-1, \
+                               (__v2di)(__m128i)(index), (__v4sf)(__m128)(v1), \
+                               (int)(scale))
+
+#define _mm_mask_i64scatter_ps(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv4sf((void *)(addr), (__mmask8)(mask), \
+                               (__v2di)(__m128i)(index), (__v4sf)(__m128)(v1), \
+                               (int)(scale))
+
+#define _mm_i64scatter_epi32(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv4si((void *)(addr), (__mmask8)-1, \
+                               (__v2di)(__m128i)(index), \
+                               (__v4si)(__m128i)(v1), (int)(scale))
+
+#define _mm_mask_i64scatter_epi32(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv4si((void *)(addr), (__mmask8)(mask), \
+                               (__v2di)(__m128i)(index), \
+                               (__v4si)(__m128i)(v1), (int)(scale))
+
+#define _mm256_i64scatter_ps(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv8sf((void *)(addr), (__mmask8)-1, \
+                               (__v4di)(__m256i)(index), (__v4sf)(__m128)(v1), \
+                               (int)(scale))
+
+#define _mm256_mask_i64scatter_ps(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv8sf((void *)(addr), (__mmask8)(mask), \
+                               (__v4di)(__m256i)(index), (__v4sf)(__m128)(v1), \
+                               (int)(scale))
+
+#define _mm256_i64scatter_epi32(addr, index, v1, scale) \
+  __builtin_ia32_scatterdiv8si((void *)(addr), (__mmask8)-1, \
+                               (__v4di)(__m256i)(index), \
+                               (__v4si)(__m128i)(v1), (int)(scale))
+
+#define _mm256_mask_i64scatter_epi32(addr, mask, index, v1, scale) \
+  __builtin_ia32_scatterdiv8si((void *)(addr), (__mmask8)(mask), \
+                               (__v4di)(__m256i)(index), \
+                               (__v4si)(__m128i)(v1), (int)(scale))
+
+#define _mm_i32scatter_pd(addr, index, v1, scale) \
+  __builtin_ia32_scattersiv2df((void *)(addr), (__mmask8)-1, \
+                               (__v4si)(__m128i)(index), \
+                               (__v2df)(__m128d)(v1), (int)(scale))
+
+#define _mm_mask_i32scatter_pd(addr, mask, index, v1, scale) \
+    __builtin_ia32_scattersiv2df((void *)(addr), (__mmask8)(mask), \
+                                 (__v4si)(__m128i)(index), \
+                                 (__v2df)(__m128d)(v1), (int)(scale))
+
+#define _mm_i32scatter_epi64(addr, index, v1, scale) \
+    __builtin_ia32_scattersiv2di((void *)(addr), (__mmask8)-1, \
+                                 (__v4si)(__m128i)(index), \
+                                 (__v2di)(__m128i)(v1), (int)(scale))
+
+#define _mm_mask_i32scatter_epi64(addr, mask, index, v1, scale) \
+    __builtin_ia32_scattersiv2di((void *)(addr), (__mmask8)(mask), \
+                                 (__v4si)(__m128i)(index), \
+                                 (__v2di)(__m128i)(v1), (int)(scale))
+
+#define _mm256_i32scatter_pd(addr, index, v1, scale) \
+    __builtin_ia32_scattersiv4df((void *)(addr), (__mmask8)-1, \
+                                 (__v4si)(__m128i)(index), \
+                                 (__v4df)(__m256d)(v1), (int)(scale))
+
+#define _mm256_mask_i32scatter_pd(addr, mask, index, v1, scale) \
+    __builtin_ia32_scattersiv4df((void *)(addr), (__mmask8)(mask), \
+                                 (__v4si)(__m128i)(index), \
+                                 (__v4df)(__m256d)(v1), (int)(scale))
+
+#define _mm256_i32scatter_epi64(addr, index, v1, scale) \
+    __builtin_ia32_scattersiv4di((void *)(addr), (__mmask8)-1, \
+                                 (__v4si)(__m128i)(index), \
+                                 (__v4di)(__m256i)(v1), (int)(scale))
+
+#define _mm256_mask_i32scatter_epi64(addr, mask, index, v1, scale) \
+    __builtin_ia32_scattersiv4di((void *)(addr), (__mmask8)(mask), \
+                                 (__v4si)(__m128i)(index), \
+                                 (__v4di)(__m256i)(v1), (int)(scale))
+
+#define _mm_i32scatter_ps(addr, index, v1, scale) \
+    __builtin_ia32_scattersiv4sf((void *)(addr), (__mmask8)-1, \
+                                 (__v4si)(__m128i)(index), (__v4sf)(__m128)(v1), \
+                                 (int)(scale))
+
+#define _mm_mask_i32scatter_ps(addr, mask, index, v1, scale) \
+    __builtin_ia32_scattersiv4sf((void *)(addr), (__mmask8)(mask), \
+                                 (__v4si)(__m128i)(index), (__v4sf)(__m128)(v1), \
+                                 (int)(scale))
+
+#define _mm_i32scatter_epi32(addr, index, v1, scale) \
+    __builtin_ia32_scattersiv4si((void *)(addr), (__mmask8)-1, \
+                                 (__v4si)(__m128i)(index), \
+                                 (__v4si)(__m128i)(v1), (int)(scale))
+
+#define _mm_mask_i32scatter_epi32(addr, mask, index, v1, scale) \
+    __builtin_ia32_scattersiv4si((void *)(addr), (__mmask8)(mask), \
+                                 (__v4si)(__m128i)(index), \
+                                 (__v4si)(__m128i)(v1), (int)(scale))
+
+#define _mm256_i32scatter_ps(addr, index, v1, scale) \
+    __builtin_ia32_scattersiv8sf((void *)(addr), (__mmask8)-1, \
+                                 (__v8si)(__m256i)(index), (__v8sf)(__m256)(v1), \
+                                 (int)(scale))
+
+#define _mm256_mask_i32scatter_ps(addr, mask, index, v1, scale) \
+    __builtin_ia32_scattersiv8sf((void *)(addr), (__mmask8)(mask), \
+                                 (__v8si)(__m256i)(index), (__v8sf)(__m256)(v1), \
+                                 (int)(scale))
+
+#define _mm256_i32scatter_epi32(addr, index, v1, scale) \
+    __builtin_ia32_scattersiv8si((void *)(addr), (__mmask8)-1, \
+                                 (__v8si)(__m256i)(index), \
+                                 (__v8si)(__m256i)(v1), (int)(scale))
+
+#define _mm256_mask_i32scatter_epi32(addr, mask, index, v1, scale) \
+    __builtin_ia32_scattersiv8si((void *)(addr), (__mmask8)(mask), \
+                                 (__v8si)(__m256i)(index), \
+                                 (__v8si)(__m256i)(v1), (int)(scale))
+
+  static __inline__ __m128d __DEFAULT_FN_ATTRS128
+  _mm_mask_sqrt_pd(__m128d __W, __mmask8 __U, __m128d __A) {
+    return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                                (__v2df)_mm_sqrt_pd(__A),
+                                                (__v2df)__W);
+  }
+
+  static __inline__ __m128d __DEFAULT_FN_ATTRS128
+  _mm_maskz_sqrt_pd(__mmask8 __U, __m128d __A) {
+    return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                                (__v2df)_mm_sqrt_pd(__A),
+                                                (__v2df)_mm_setzero_pd());
+  }
+
+  static __inline__ __m256d __DEFAULT_FN_ATTRS256
+  _mm256_mask_sqrt_pd(__m256d __W, __mmask8 __U, __m256d __A) {
+    return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                                (__v4df)_mm256_sqrt_pd(__A),
+                                                (__v4df)__W);
+  }
+
+  static __inline__ __m256d __DEFAULT_FN_ATTRS256
+  _mm256_maskz_sqrt_pd(__mmask8 __U, __m256d __A) {
+    return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                                (__v4df)_mm256_sqrt_pd(__A),
+                                                (__v4df)_mm256_setzero_pd());
+  }
+
+  static __inline__ __m128 __DEFAULT_FN_ATTRS128
+  _mm_mask_sqrt_ps(__m128 __W, __mmask8 __U, __m128 __A) {
+    return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                               (__v4sf)_mm_sqrt_ps(__A),
+                                               (__v4sf)__W);
+  }
+
+  static __inline__ __m128 __DEFAULT_FN_ATTRS128
+  _mm_maskz_sqrt_ps(__mmask8 __U, __m128 __A) {
+    return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                               (__v4sf)_mm_sqrt_ps(__A),
+                                               (__v4sf)_mm_setzero_ps());
+  }
+
+  static __inline__ __m256 __DEFAULT_FN_ATTRS256
+  _mm256_mask_sqrt_ps(__m256 __W, __mmask8 __U, __m256 __A) {
+    return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                               (__v8sf)_mm256_sqrt_ps(__A),
+                                               (__v8sf)__W);
+  }
+
+  static __inline__ __m256 __DEFAULT_FN_ATTRS256
+  _mm256_maskz_sqrt_ps(__mmask8 __U, __m256 __A) {
+    return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                               (__v8sf)_mm256_sqrt_ps(__A),
+                                               (__v8sf)_mm256_setzero_ps());
+  }
+
+  static __inline__ __m128d __DEFAULT_FN_ATTRS128
+  _mm_mask_sub_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B) {
+    return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                                (__v2df)_mm_sub_pd(__A, __B),
+                                                (__v2df)__W);
+  }
+
+  static __inline__ __m128d __DEFAULT_FN_ATTRS128
+  _mm_maskz_sub_pd(__mmask8 __U, __m128d __A, __m128d __B) {
+    return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                                (__v2df)_mm_sub_pd(__A, __B),
+                                                (__v2df)_mm_setzero_pd());
+  }
+
+  static __inline__ __m256d __DEFAULT_FN_ATTRS256
+  _mm256_mask_sub_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B) {
+    return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                                (__v4df)_mm256_sub_pd(__A, __B),
+                                                (__v4df)__W);
+  }
+
+  static __inline__ __m256d __DEFAULT_FN_ATTRS256
+  _mm256_maskz_sub_pd(__mmask8 __U, __m256d __A, __m256d __B) {
+    return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                                (__v4df)_mm256_sub_pd(__A, __B),
+                                                (__v4df)_mm256_setzero_pd());
+  }
+
+  static __inline__ __m128 __DEFAULT_FN_ATTRS128
+  _mm_mask_sub_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B) {
+    return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                               (__v4sf)_mm_sub_ps(__A, __B),
+                                               (__v4sf)__W);
+  }
+
+  static __inline__ __m128 __DEFAULT_FN_ATTRS128
+  _mm_maskz_sub_ps(__mmask8 __U, __m128 __A, __m128 __B) {
+    return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                               (__v4sf)_mm_sub_ps(__A, __B),
+                                               (__v4sf)_mm_setzero_ps());
+  }
+
+  static __inline__ __m256 __DEFAULT_FN_ATTRS256
+  _mm256_mask_sub_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B) {
+    return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                               (__v8sf)_mm256_sub_ps(__A, __B),
+                                               (__v8sf)__W);
+  }
+
+  static __inline__ __m256 __DEFAULT_FN_ATTRS256
+  _mm256_maskz_sub_ps(__mmask8 __U, __m256 __A, __m256 __B) {
+    return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                               (__v8sf)_mm256_sub_ps(__A, __B),
+                                               (__v8sf)_mm256_setzero_ps());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_permutex2var_epi32(__m128i __A, __m128i __I, __m128i __B) {
+    return (__m128i)__builtin_ia32_vpermi2vard128((__v4si) __A, (__v4si)__I,
+                                                  (__v4si)__B);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_permutex2var_epi32(__m128i __A, __mmask8 __U, __m128i __I,
+                              __m128i __B) {
+    return (__m128i)__builtin_ia32_selectd_128(__U,
+                                    (__v4si)_mm_permutex2var_epi32(__A, __I, __B),
+                                    (__v4si)__A);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask2_permutex2var_epi32(__m128i __A, __m128i __I, __mmask8 __U,
+                               __m128i __B) {
+    return (__m128i)__builtin_ia32_selectd_128(__U,
+                                    (__v4si)_mm_permutex2var_epi32(__A, __I, __B),
+                                    (__v4si)__I);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_permutex2var_epi32(__mmask8 __U, __m128i __A, __m128i __I,
+                               __m128i __B) {
+    return (__m128i)__builtin_ia32_selectd_128(__U,
+                                    (__v4si)_mm_permutex2var_epi32(__A, __I, __B),
+                                    (__v4si)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_permutex2var_epi32(__m256i __A, __m256i __I, __m256i __B) {
+    return (__m256i)__builtin_ia32_vpermi2vard256((__v8si)__A, (__v8si) __I,
+                                                  (__v8si) __B);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_permutex2var_epi32(__m256i __A, __mmask8 __U, __m256i __I,
+                                 __m256i __B) {
+    return (__m256i)__builtin_ia32_selectd_256(__U,
+                                 (__v8si)_mm256_permutex2var_epi32(__A, __I, __B),
+                                 (__v8si)__A);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask2_permutex2var_epi32(__m256i __A, __m256i __I, __mmask8 __U,
+                                  __m256i __B) {
+    return (__m256i)__builtin_ia32_selectd_256(__U,
+                                 (__v8si)_mm256_permutex2var_epi32(__A, __I, __B),
+                                 (__v8si)__I);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_permutex2var_epi32(__mmask8 __U, __m256i __A, __m256i __I,
+                                  __m256i __B) {
+    return (__m256i)__builtin_ia32_selectd_256(__U,
+                                 (__v8si)_mm256_permutex2var_epi32(__A, __I, __B),
+                                 (__v8si)_mm256_setzero_si256());
+  }
+
+  static __inline__ __m128d __DEFAULT_FN_ATTRS128
+  _mm_permutex2var_pd(__m128d __A, __m128i __I, __m128d __B) {
+    return (__m128d)__builtin_ia32_vpermi2varpd128((__v2df)__A, (__v2di)__I,
+                                                   (__v2df)__B);
+  }
+
+  static __inline__ __m128d __DEFAULT_FN_ATTRS128
+  _mm_mask_permutex2var_pd(__m128d __A, __mmask8 __U, __m128i __I, __m128d __B) {
+    return (__m128d)__builtin_ia32_selectpd_128(__U,
+                                       (__v2df)_mm_permutex2var_pd(__A, __I, __B),
+                                       (__v2df)__A);
+  }
+
+  static __inline__ __m128d __DEFAULT_FN_ATTRS128
+  _mm_mask2_permutex2var_pd(__m128d __A, __m128i __I, __mmask8 __U, __m128d __B) {
+    return (__m128d)__builtin_ia32_selectpd_128(__U,
+                                       (__v2df)_mm_permutex2var_pd(__A, __I, __B),
+                                       (__v2df)(__m128d)__I);
+  }
+
+  static __inline__ __m128d __DEFAULT_FN_ATTRS128
+  _mm_maskz_permutex2var_pd(__mmask8 __U, __m128d __A, __m128i __I, __m128d __B) {
+    return (__m128d)__builtin_ia32_selectpd_128(__U,
+                                       (__v2df)_mm_permutex2var_pd(__A, __I, __B),
+                                       (__v2df)_mm_setzero_pd());
+  }
+
+  static __inline__ __m256d __DEFAULT_FN_ATTRS256
+  _mm256_permutex2var_pd(__m256d __A, __m256i __I, __m256d __B) {
+    return (__m256d)__builtin_ia32_vpermi2varpd256((__v4df)__A, (__v4di)__I,
+                                                   (__v4df)__B);
+  }
+
+  static __inline__ __m256d __DEFAULT_FN_ATTRS256
+  _mm256_mask_permutex2var_pd(__m256d __A, __mmask8 __U, __m256i __I,
+                              __m256d __B) {
+    return (__m256d)__builtin_ia32_selectpd_256(__U,
+                                    (__v4df)_mm256_permutex2var_pd(__A, __I, __B),
+                                    (__v4df)__A);
+  }
+
+  static __inline__ __m256d __DEFAULT_FN_ATTRS256
+  _mm256_mask2_permutex2var_pd(__m256d __A, __m256i __I, __mmask8 __U,
+                               __m256d __B) {
+    return (__m256d)__builtin_ia32_selectpd_256(__U,
+                                    (__v4df)_mm256_permutex2var_pd(__A, __I, __B),
+                                    (__v4df)(__m256d)__I);
+  }
+
+  static __inline__ __m256d __DEFAULT_FN_ATTRS256
+  _mm256_maskz_permutex2var_pd(__mmask8 __U, __m256d __A, __m256i __I,
+                               __m256d __B) {
+    return (__m256d)__builtin_ia32_selectpd_256(__U,
+                                    (__v4df)_mm256_permutex2var_pd(__A, __I, __B),
+                                    (__v4df)_mm256_setzero_pd());
+  }
+
+  static __inline__ __m128 __DEFAULT_FN_ATTRS128
+  _mm_permutex2var_ps(__m128 __A, __m128i __I, __m128 __B) {
+    return (__m128)__builtin_ia32_vpermi2varps128((__v4sf)__A, (__v4si)__I,
+                                                  (__v4sf)__B);
+  }
+
+  static __inline__ __m128 __DEFAULT_FN_ATTRS128
+  _mm_mask_permutex2var_ps(__m128 __A, __mmask8 __U, __m128i __I, __m128 __B) {
+    return (__m128)__builtin_ia32_selectps_128(__U,
+                                       (__v4sf)_mm_permutex2var_ps(__A, __I, __B),
+                                       (__v4sf)__A);
+  }
+
+  static __inline__ __m128 __DEFAULT_FN_ATTRS128
+  _mm_mask2_permutex2var_ps(__m128 __A, __m128i __I, __mmask8 __U, __m128 __B) {
+    return (__m128)__builtin_ia32_selectps_128(__U,
+                                       (__v4sf)_mm_permutex2var_ps(__A, __I, __B),
+                                       (__v4sf)(__m128)__I);
+  }
+
+  static __inline__ __m128 __DEFAULT_FN_ATTRS128
+  _mm_maskz_permutex2var_ps(__mmask8 __U, __m128 __A, __m128i __I, __m128 __B) {
+    return (__m128)__builtin_ia32_selectps_128(__U,
+                                       (__v4sf)_mm_permutex2var_ps(__A, __I, __B),
+                                       (__v4sf)_mm_setzero_ps());
+  }
+
+  static __inline__ __m256 __DEFAULT_FN_ATTRS256
+  _mm256_permutex2var_ps(__m256 __A, __m256i __I, __m256 __B) {
+    return (__m256)__builtin_ia32_vpermi2varps256((__v8sf)__A, (__v8si)__I,
+                                                  (__v8sf) __B);
+  }
+
+  static __inline__ __m256 __DEFAULT_FN_ATTRS256
+  _mm256_mask_permutex2var_ps(__m256 __A, __mmask8 __U, __m256i __I, __m256 __B) {
+    return (__m256)__builtin_ia32_selectps_256(__U,
+                                    (__v8sf)_mm256_permutex2var_ps(__A, __I, __B),
+                                    (__v8sf)__A);
+  }
+
+  static __inline__ __m256 __DEFAULT_FN_ATTRS256
+  _mm256_mask2_permutex2var_ps(__m256 __A, __m256i __I, __mmask8 __U,
+                               __m256 __B) {
+    return (__m256)__builtin_ia32_selectps_256(__U,
+                                    (__v8sf)_mm256_permutex2var_ps(__A, __I, __B),
+                                    (__v8sf)(__m256)__I);
+  }
+
+  static __inline__ __m256 __DEFAULT_FN_ATTRS256
+  _mm256_maskz_permutex2var_ps(__mmask8 __U, __m256 __A, __m256i __I,
+                               __m256 __B) {
+    return (__m256)__builtin_ia32_selectps_256(__U,
+                                    (__v8sf)_mm256_permutex2var_ps(__A, __I, __B),
+                                    (__v8sf)_mm256_setzero_ps());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_permutex2var_epi64(__m128i __A, __m128i __I, __m128i __B) {
+    return (__m128i)__builtin_ia32_vpermi2varq128((__v2di)__A, (__v2di)__I,
+                                                  (__v2di)__B);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_permutex2var_epi64(__m128i __A, __mmask8 __U, __m128i __I,
+                              __m128i __B) {
+    return (__m128i)__builtin_ia32_selectq_128(__U,
+                                    (__v2di)_mm_permutex2var_epi64(__A, __I, __B),
+                                    (__v2di)__A);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask2_permutex2var_epi64(__m128i __A, __m128i __I, __mmask8 __U,
+                               __m128i __B) {
+    return (__m128i)__builtin_ia32_selectq_128(__U,
+                                    (__v2di)_mm_permutex2var_epi64(__A, __I, __B),
+                                    (__v2di)__I);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_permutex2var_epi64(__mmask8 __U, __m128i __A, __m128i __I,
+                               __m128i __B) {
+    return (__m128i)__builtin_ia32_selectq_128(__U,
+                                    (__v2di)_mm_permutex2var_epi64(__A, __I, __B),
+                                    (__v2di)_mm_setzero_si128());
+  }
+
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_permutex2var_epi64(__m256i __A, __m256i __I, __m256i __B) {
+    return (__m256i)__builtin_ia32_vpermi2varq256((__v4di)__A, (__v4di) __I,
+                                                  (__v4di) __B);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_permutex2var_epi64(__m256i __A, __mmask8 __U, __m256i __I,
+                                 __m256i __B) {
+    return (__m256i)__builtin_ia32_selectq_256(__U,
+                                 (__v4di)_mm256_permutex2var_epi64(__A, __I, __B),
+                                 (__v4di)__A);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask2_permutex2var_epi64(__m256i __A, __m256i __I, __mmask8 __U,
+                                  __m256i __B) {
+    return (__m256i)__builtin_ia32_selectq_256(__U,
+                                 (__v4di)_mm256_permutex2var_epi64(__A, __I, __B),
+                                 (__v4di)__I);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_permutex2var_epi64(__mmask8 __U, __m256i __A, __m256i __I,
+                                  __m256i __B) {
+    return (__m256i)__builtin_ia32_selectq_256(__U,
+                                 (__v4di)_mm256_permutex2var_epi64(__A, __I, __B),
+                                 (__v4di)_mm256_setzero_si256());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_cvtepi8_epi32(__m128i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                               (__v4si)_mm_cvtepi8_epi32(__A),
+                                               (__v4si)__W);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_cvtepi8_epi32(__mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                               (__v4si)_mm_cvtepi8_epi32(__A),
+                                               (__v4si)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_cvtepi8_epi32 (__m256i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                               (__v8si)_mm256_cvtepi8_epi32(__A),
+                                               (__v8si)__W);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_cvtepi8_epi32 (__mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                               (__v8si)_mm256_cvtepi8_epi32(__A),
+                                               (__v8si)_mm256_setzero_si256());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_cvtepi8_epi64(__m128i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepi8_epi64(__A),
+                                               (__v2di)__W);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_cvtepi8_epi64(__mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepi8_epi64(__A),
+                                               (__v2di)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_cvtepi8_epi64(__m256i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepi8_epi64(__A),
+                                               (__v4di)__W);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_cvtepi8_epi64(__mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepi8_epi64(__A),
+                                               (__v4di)_mm256_setzero_si256());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_cvtepi32_epi64(__m128i __W, __mmask8 __U, __m128i __X)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepi32_epi64(__X),
+                                               (__v2di)__W);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_cvtepi32_epi64(__mmask8 __U, __m128i __X)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepi32_epi64(__X),
+                                               (__v2di)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_cvtepi32_epi64(__m256i __W, __mmask8 __U, __m128i __X)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepi32_epi64(__X),
+                                               (__v4di)__W);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_cvtepi32_epi64(__mmask8 __U, __m128i __X)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepi32_epi64(__X),
+                                               (__v4di)_mm256_setzero_si256());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_cvtepi16_epi32(__m128i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                               (__v4si)_mm_cvtepi16_epi32(__A),
+                                               (__v4si)__W);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_cvtepi16_epi32(__mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                               (__v4si)_mm_cvtepi16_epi32(__A),
+                                               (__v4si)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_cvtepi16_epi32(__m256i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                               (__v8si)_mm256_cvtepi16_epi32(__A),
+                                               (__v8si)__W);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_cvtepi16_epi32 (__mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                               (__v8si)_mm256_cvtepi16_epi32(__A),
+                                               (__v8si)_mm256_setzero_si256());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_cvtepi16_epi64(__m128i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepi16_epi64(__A),
+                                               (__v2di)__W);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_cvtepi16_epi64(__mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepi16_epi64(__A),
+                                               (__v2di)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_cvtepi16_epi64(__m256i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepi16_epi64(__A),
+                                               (__v4di)__W);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_cvtepi16_epi64(__mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepi16_epi64(__A),
+                                               (__v4di)_mm256_setzero_si256());
+  }
+
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_cvtepu8_epi32(__m128i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                               (__v4si)_mm_cvtepu8_epi32(__A),
+                                               (__v4si)__W);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_cvtepu8_epi32(__mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                               (__v4si)_mm_cvtepu8_epi32(__A),
+                                               (__v4si)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_cvtepu8_epi32(__m256i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                               (__v8si)_mm256_cvtepu8_epi32(__A),
+                                               (__v8si)__W);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_cvtepu8_epi32(__mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                               (__v8si)_mm256_cvtepu8_epi32(__A),
+                                               (__v8si)_mm256_setzero_si256());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_cvtepu8_epi64(__m128i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepu8_epi64(__A),
+                                               (__v2di)__W);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_cvtepu8_epi64(__mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepu8_epi64(__A),
+                                               (__v2di)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_cvtepu8_epi64(__m256i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepu8_epi64(__A),
+                                               (__v4di)__W);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_cvtepu8_epi64 (__mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepu8_epi64(__A),
+                                               (__v4di)_mm256_setzero_si256());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_cvtepu32_epi64(__m128i __W, __mmask8 __U, __m128i __X)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepu32_epi64(__X),
+                                               (__v2di)__W);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_cvtepu32_epi64(__mmask8 __U, __m128i __X)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepu32_epi64(__X),
+                                               (__v2di)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_cvtepu32_epi64(__m256i __W, __mmask8 __U, __m128i __X)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepu32_epi64(__X),
+                                               (__v4di)__W);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_cvtepu32_epi64(__mmask8 __U, __m128i __X)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepu32_epi64(__X),
+                                               (__v4di)_mm256_setzero_si256());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_cvtepu16_epi32(__m128i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                               (__v4si)_mm_cvtepu16_epi32(__A),
+                                               (__v4si)__W);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_cvtepu16_epi32(__mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                               (__v4si)_mm_cvtepu16_epi32(__A),
+                                               (__v4si)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_cvtepu16_epi32(__m256i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                               (__v8si)_mm256_cvtepu16_epi32(__A),
+                                               (__v8si)__W);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_cvtepu16_epi32(__mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                               (__v8si)_mm256_cvtepu16_epi32(__A),
+                                               (__v8si)_mm256_setzero_si256());
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_mask_cvtepu16_epi64(__m128i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepu16_epi64(__A),
+                                               (__v2di)__W);
+  }
+
+  static __inline__ __m128i __DEFAULT_FN_ATTRS128
+  _mm_maskz_cvtepu16_epi64(__mmask8 __U, __m128i __A)
+  {
+    return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                               (__v2di)_mm_cvtepu16_epi64(__A),
+                                               (__v2di)_mm_setzero_si128());
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_mask_cvtepu16_epi64(__m256i __W, __mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepu16_epi64(__A),
+                                               (__v4di)__W);
+  }
+
+  static __inline__ __m256i __DEFAULT_FN_ATTRS256
+  _mm256_maskz_cvtepu16_epi64(__mmask8 __U, __m128i __A)
+  {
+    return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                               (__v4di)_mm256_cvtepu16_epi64(__A),
+                                               (__v4di)_mm256_setzero_si256());
+  }
+
+
+#define _mm_rol_epi32(a, b) \
+  ((__m128i)__builtin_ia32_prold128((__v4si)(__m128i)(a), (int)(b)))
+
+#define _mm_mask_rol_epi32(w, u, a, b) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(u), \
+                                       (__v4si)_mm_rol_epi32((a), (b)), \
+                                       (__v4si)(__m128i)(w)))
+
+#define _mm_maskz_rol_epi32(u, a, b) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(u), \
+                                       (__v4si)_mm_rol_epi32((a), (b)), \
+                                       (__v4si)_mm_setzero_si128()))
+
+#define _mm256_rol_epi32(a, b) \
+  ((__m256i)__builtin_ia32_prold256((__v8si)(__m256i)(a), (int)(b)))
+
+#define _mm256_mask_rol_epi32(w, u, a, b) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(u), \
+                                       (__v8si)_mm256_rol_epi32((a), (b)), \
+                                       (__v8si)(__m256i)(w)))
+
+#define _mm256_maskz_rol_epi32(u, a, b) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(u), \
+                                       (__v8si)_mm256_rol_epi32((a), (b)), \
+                                       (__v8si)_mm256_setzero_si256()))
+
+#define _mm_rol_epi64(a, b) \
+  ((__m128i)__builtin_ia32_prolq128((__v2di)(__m128i)(a), (int)(b)))
+
+#define _mm_mask_rol_epi64(w, u, a, b) \
+  ((__m128i)__builtin_ia32_selectq_128((__mmask8)(u), \
+                                       (__v2di)_mm_rol_epi64((a), (b)), \
+                                       (__v2di)(__m128i)(w)))
+
+#define _mm_maskz_rol_epi64(u, a, b) \
+  ((__m128i)__builtin_ia32_selectq_128((__mmask8)(u), \
+                                       (__v2di)_mm_rol_epi64((a), (b)), \
+                                       (__v2di)_mm_setzero_si128()))
+
+#define _mm256_rol_epi64(a, b) \
+  ((__m256i)__builtin_ia32_prolq256((__v4di)(__m256i)(a), (int)(b)))
+
+#define _mm256_mask_rol_epi64(w, u, a, b) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(u), \
+                                       (__v4di)_mm256_rol_epi64((a), (b)), \
+                                       (__v4di)(__m256i)(w)))
+
+#define _mm256_maskz_rol_epi64(u, a, b) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(u), \
+                                       (__v4di)_mm256_rol_epi64((a), (b)), \
+                                       (__v4di)_mm256_setzero_si256()))
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_rolv_epi32 (__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_prolvd128((__v4si)__A, (__v4si)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_rolv_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                             (__v4si)_mm_rolv_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_rolv_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                             (__v4si)_mm_rolv_epi32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_rolv_epi32 (__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_prolvd256((__v8si)__A, (__v8si)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_rolv_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                            (__v8si)_mm256_rolv_epi32(__A, __B),
+                                            (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_rolv_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                            (__v8si)_mm256_rolv_epi32(__A, __B),
+                                            (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_rolv_epi64 (__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_prolvq128((__v2di)__A, (__v2di)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_rolv_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__U,
+                                             (__v2di)_mm_rolv_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_rolv_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__U,
+                                             (__v2di)_mm_rolv_epi64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_rolv_epi64 (__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_prolvq256((__v4di)__A, (__v4di)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_rolv_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__U,
+                                            (__v4di)_mm256_rolv_epi64(__A, __B),
+                                            (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_rolv_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__U,
+                                            (__v4di)_mm256_rolv_epi64(__A, __B),
+                                            (__v4di)_mm256_setzero_si256());
+}
+
+#define _mm_ror_epi32(a, b) \
+  ((__m128i)__builtin_ia32_prord128((__v4si)(__m128i)(a), (int)(b)))
+
+#define _mm_mask_ror_epi32(w, u, a, b) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(u), \
+                                       (__v4si)_mm_ror_epi32((a), (b)), \
+                                       (__v4si)(__m128i)(w)))
+
+#define _mm_maskz_ror_epi32(u, a, b) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(u), \
+                                       (__v4si)_mm_ror_epi32((a), (b)), \
+                                       (__v4si)_mm_setzero_si128()))
+
+#define _mm256_ror_epi32(a, b) \
+  ((__m256i)__builtin_ia32_prord256((__v8si)(__m256i)(a), (int)(b)))
+
+#define _mm256_mask_ror_epi32(w, u, a, b) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(u), \
+                                       (__v8si)_mm256_ror_epi32((a), (b)), \
+                                       (__v8si)(__m256i)(w)))
+
+#define _mm256_maskz_ror_epi32(u, a, b) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(u), \
+                                       (__v8si)_mm256_ror_epi32((a), (b)), \
+                                       (__v8si)_mm256_setzero_si256()))
+
+#define _mm_ror_epi64(a, b) \
+  ((__m128i)__builtin_ia32_prorq128((__v2di)(__m128i)(a), (int)(b)))
+
+#define _mm_mask_ror_epi64(w, u, a, b) \
+  ((__m128i)__builtin_ia32_selectq_128((__mmask8)(u), \
+                                       (__v2di)_mm_ror_epi64((a), (b)), \
+                                       (__v2di)(__m128i)(w)))
+
+#define _mm_maskz_ror_epi64(u, a, b) \
+  ((__m128i)__builtin_ia32_selectq_128((__mmask8)(u), \
+                                       (__v2di)_mm_ror_epi64((a), (b)), \
+                                       (__v2di)_mm_setzero_si128()))
+
+#define _mm256_ror_epi64(a, b) \
+  ((__m256i)__builtin_ia32_prorq256((__v4di)(__m256i)(a), (int)(b)))
+
+#define _mm256_mask_ror_epi64(w, u, a, b) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(u), \
+                                       (__v4di)_mm256_ror_epi64((a), (b)), \
+                                       (__v4di)(__m256i)(w)))
+
+#define _mm256_maskz_ror_epi64(u, a, b) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(u), \
+                                       (__v4di)_mm256_ror_epi64((a), (b)), \
+                                       (__v4di)_mm256_setzero_si256()))
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sll_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_sll_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sll_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_sll_epi32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sll_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_sll_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sll_epi32(__mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_sll_epi32(__A, __B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_slli_epi32(__m128i __W, __mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_slli_epi32(__A, (int)__B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_slli_epi32(__mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_slli_epi32(__A, (int)__B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_slli_epi32(__m256i __W, __mmask8 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_slli_epi32(__A, (int)__B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_slli_epi32(__mmask8 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_slli_epi32(__A, (int)__B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sll_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_sll_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sll_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_sll_epi64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sll_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_sll_epi64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sll_epi64(__mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_sll_epi64(__A, __B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_slli_epi64(__m128i __W, __mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_slli_epi64(__A, (int)__B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_slli_epi64(__mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_slli_epi64(__A, (int)__B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_slli_epi64(__m256i __W, __mmask8 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_slli_epi64(__A, (int)__B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_slli_epi64(__mmask8 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_slli_epi64(__A, (int)__B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_rorv_epi32 (__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_prorvd128((__v4si)__A, (__v4si)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_rorv_epi32 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                             (__v4si)_mm_rorv_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_rorv_epi32 (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                             (__v4si)_mm_rorv_epi32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_rorv_epi32 (__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_prorvd256((__v8si)__A, (__v8si)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_rorv_epi32 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                            (__v8si)_mm256_rorv_epi32(__A, __B),
+                                            (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_rorv_epi32 (__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                            (__v8si)_mm256_rorv_epi32(__A, __B),
+                                            (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_rorv_epi64 (__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_prorvq128((__v2di)__A, (__v2di)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_rorv_epi64 (__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__U,
+                                             (__v2di)_mm_rorv_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_rorv_epi64 (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__U,
+                                             (__v2di)_mm_rorv_epi64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_rorv_epi64 (__m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_prorvq256((__v4di)__A, (__v4di)__B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_rorv_epi64 (__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__U,
+                                            (__v4di)_mm256_rorv_epi64(__A, __B),
+                                            (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_rorv_epi64 (__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__U,
+                                            (__v4di)_mm256_rorv_epi64(__A, __B),
+                                            (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sllv_epi64(__m128i __W, __mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_sllv_epi64(__X, __Y),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sllv_epi64(__mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_sllv_epi64(__X, __Y),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sllv_epi64(__m256i __W, __mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                            (__v4di)_mm256_sllv_epi64(__X, __Y),
+                                            (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sllv_epi64(__mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                            (__v4di)_mm256_sllv_epi64(__X, __Y),
+                                            (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sllv_epi32(__m128i __W, __mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_sllv_epi32(__X, __Y),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sllv_epi32(__mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_sllv_epi32(__X, __Y),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sllv_epi32(__m256i __W, __mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                            (__v8si)_mm256_sllv_epi32(__X, __Y),
+                                            (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sllv_epi32(__mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                            (__v8si)_mm256_sllv_epi32(__X, __Y),
+                                            (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srlv_epi64(__m128i __W, __mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_srlv_epi64(__X, __Y),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srlv_epi64(__mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_srlv_epi64(__X, __Y),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srlv_epi64(__m256i __W, __mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                            (__v4di)_mm256_srlv_epi64(__X, __Y),
+                                            (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srlv_epi64(__mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                            (__v4di)_mm256_srlv_epi64(__X, __Y),
+                                            (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srlv_epi32(__m128i __W, __mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                            (__v4si)_mm_srlv_epi32(__X, __Y),
+                                            (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srlv_epi32(__mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                            (__v4si)_mm_srlv_epi32(__X, __Y),
+                                            (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srlv_epi32(__m256i __W, __mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                            (__v8si)_mm256_srlv_epi32(__X, __Y),
+                                            (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srlv_epi32(__mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                            (__v8si)_mm256_srlv_epi32(__X, __Y),
+                                            (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srl_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_srl_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srl_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_srl_epi32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srl_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_srl_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srl_epi32(__mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_srl_epi32(__A, __B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srli_epi32(__m128i __W, __mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_srli_epi32(__A, (int)__B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srli_epi32(__mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_srli_epi32(__A, (int)__B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srli_epi32(__m256i __W, __mmask8 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_srli_epi32(__A, (int)__B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srli_epi32(__mmask8 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_srli_epi32(__A, (int)__B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srl_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_srl_epi64(__A, __B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srl_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_srl_epi64(__A, __B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srl_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_srl_epi64(__A, __B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srl_epi64(__mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_srl_epi64(__A, __B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srli_epi64(__m128i __W, __mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_srli_epi64(__A, (int)__B),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srli_epi64(__mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_srli_epi64(__A, (int)__B),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srli_epi64(__m256i __W, __mmask8 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_srli_epi64(__A, (int)__B),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srli_epi64(__mmask8 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_srli_epi64(__A, (int)__B),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srav_epi32(__m128i __W, __mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                            (__v4si)_mm_srav_epi32(__X, __Y),
+                                            (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srav_epi32(__mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                            (__v4si)_mm_srav_epi32(__X, __Y),
+                                            (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srav_epi32(__m256i __W, __mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                            (__v8si)_mm256_srav_epi32(__X, __Y),
+                                            (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srav_epi32(__mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                            (__v8si)_mm256_srav_epi32(__X, __Y),
+                                            (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_srav_epi64(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_psravq128((__v2di)__X, (__v2di)__Y);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srav_epi64(__m128i __W, __mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_srav_epi64(__X, __Y),
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srav_epi64(__mmask8 __U, __m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                             (__v2di)_mm_srav_epi64(__X, __Y),
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srav_epi64(__m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_psravq256((__v4di)__X, (__v4di) __Y);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srav_epi64(__m256i __W, __mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_srav_epi64(__X, __Y),
+                                             (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srav_epi64 (__mmask8 __U, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                             (__v4di)_mm256_srav_epi64(__X, __Y),
+                                             (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mov_epi32 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_selectd_128 ((__mmask8) __U,
+                 (__v4si) __A,
+                 (__v4si) __W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mov_epi32 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_selectd_128 ((__mmask8) __U,
+                 (__v4si) __A,
+                 (__v4si) _mm_setzero_si128 ());
+}
+
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mov_epi32 (__m256i __W, __mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_selectd_256 ((__mmask8) __U,
+                 (__v8si) __A,
+                 (__v8si) __W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mov_epi32 (__mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_selectd_256 ((__mmask8) __U,
+                 (__v8si) __A,
+                 (__v8si) _mm256_setzero_si256 ());
+}
+
+static __inline __m128i __DEFAULT_FN_ATTRS128
+_mm_load_epi32 (void const *__P)
+{
+  return *(const __m128i *) __P;
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_load_epi32 (__m128i __W, __mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_movdqa32load128_mask ((const __v4si *) __P,
+              (__v4si) __W,
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_load_epi32 (__mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_movdqa32load128_mask ((const __v4si *) __P,
+              (__v4si)
+              _mm_setzero_si128 (),
+              (__mmask8)
+              __U);
+}
+
+static __inline __m256i __DEFAULT_FN_ATTRS256
+_mm256_load_epi32 (void const *__P)
+{
+  return *(const __m256i *) __P;
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_load_epi32 (__m256i __W, __mmask8 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_movdqa32load256_mask ((const __v8si *) __P,
+              (__v8si) __W,
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_load_epi32 (__mmask8 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_movdqa32load256_mask ((const __v8si *) __P,
+              (__v8si)
+              _mm256_setzero_si256 (),
+              (__mmask8)
+              __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS128
+_mm_store_epi32 (void *__P, __m128i __A)
+{
+  *(__m128i *) __P = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_store_epi32 (void *__P, __mmask8 __U, __m128i __A)
+{
+  __builtin_ia32_movdqa32store128_mask ((__v4si *) __P,
+          (__v4si) __A,
+          (__mmask8) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS256
+_mm256_store_epi32 (void *__P, __m256i __A)
+{
+  *(__m256i *) __P = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_store_epi32 (void *__P, __mmask8 __U, __m256i __A)
+{
+  __builtin_ia32_movdqa32store256_mask ((__v8si *) __P,
+          (__v8si) __A,
+          (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_mov_epi64 (__m128i __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_selectq_128 ((__mmask8) __U,
+                 (__v2di) __A,
+                 (__v2di) __W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_mov_epi64 (__mmask8 __U, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_selectq_128 ((__mmask8) __U,
+                 (__v2di) __A,
+                 (__v2di) _mm_setzero_si128 ());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_mov_epi64 (__m256i __W, __mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_selectq_256 ((__mmask8) __U,
+                 (__v4di) __A,
+                 (__v4di) __W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_mov_epi64 (__mmask8 __U, __m256i __A)
+{
+  return (__m256i) __builtin_ia32_selectq_256 ((__mmask8) __U,
+                 (__v4di) __A,
+                 (__v4di) _mm256_setzero_si256 ());
+}
+
+static __inline __m128i __DEFAULT_FN_ATTRS128
+_mm_load_epi64 (void const *__P)
+{
+  return *(const __m128i *) __P;
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_load_epi64 (__m128i __W, __mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_movdqa64load128_mask ((const __v2di *) __P,
+              (__v2di) __W,
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_load_epi64 (__mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_movdqa64load128_mask ((const __v2di *) __P,
+              (__v2di)
+              _mm_setzero_si128 (),
+              (__mmask8)
+              __U);
+}
+
+static __inline __m256i __DEFAULT_FN_ATTRS256
+_mm256_load_epi64 (void const *__P)
+{
+  return *(const __m256i *) __P;
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_load_epi64 (__m256i __W, __mmask8 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_movdqa64load256_mask ((const __v4di *) __P,
+              (__v4di) __W,
+              (__mmask8)
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_load_epi64 (__mmask8 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_movdqa64load256_mask ((const __v4di *) __P,
+              (__v4di)
+              _mm256_setzero_si256 (),
+              (__mmask8)
+              __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS128
+_mm_store_epi64 (void *__P, __m128i __A)
+{
+  *(__m128i *) __P = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_store_epi64 (void *__P, __mmask8 __U, __m128i __A)
+{
+  __builtin_ia32_movdqa64store128_mask ((__v2di *) __P,
+          (__v2di) __A,
+          (__mmask8) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS256
+_mm256_store_epi64 (void *__P, __m256i __A)
+{
+  *(__m256i *) __P = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_store_epi64 (void *__P, __mmask8 __U, __m256i __A)
+{
+  __builtin_ia32_movdqa64store256_mask ((__v4di *) __P,
+          (__v4di) __A,
+          (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_movedup_pd (__m128d __W, __mmask8 __U, __m128d __A)
+{
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_movedup_pd(__A),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_movedup_pd (__mmask8 __U, __m128d __A)
+{
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_movedup_pd(__A),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_movedup_pd (__m256d __W, __mmask8 __U, __m256d __A)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_movedup_pd(__A),
+                                              (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_movedup_pd (__mmask8 __U, __m256d __A)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                              (__v4df)_mm256_movedup_pd(__A),
+                                              (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_set1_epi32(__m128i __O, __mmask8 __M, int __A)
+{
+   return (__m128i)__builtin_ia32_selectd_128(__M,
+                                              (__v4si) _mm_set1_epi32(__A),
+                                              (__v4si)__O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_set1_epi32( __mmask8 __M, int __A)
+{
+   return (__m128i)__builtin_ia32_selectd_128(__M,
+                                              (__v4si) _mm_set1_epi32(__A),
+                                              (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_set1_epi32(__m256i __O, __mmask8 __M, int __A)
+{
+   return (__m256i)__builtin_ia32_selectd_256(__M,
+                                              (__v8si) _mm256_set1_epi32(__A),
+                                              (__v8si)__O);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_set1_epi32( __mmask8 __M, int __A)
+{
+   return (__m256i)__builtin_ia32_selectd_256(__M,
+                                              (__v8si) _mm256_set1_epi32(__A),
+                                              (__v8si)_mm256_setzero_si256());
+}
+
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_set1_epi64 (__m128i __O, __mmask8 __M, long long __A)
+{
+  return (__m128i) __builtin_ia32_selectq_128(__M,
+                                              (__v2di) _mm_set1_epi64x(__A),
+                                              (__v2di) __O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_set1_epi64 (__mmask8 __M, long long __A)
+{
+  return (__m128i) __builtin_ia32_selectq_128(__M,
+                                              (__v2di) _mm_set1_epi64x(__A),
+                                              (__v2di) _mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_set1_epi64 (__m256i __O, __mmask8 __M, long long __A)
+{
+  return (__m256i) __builtin_ia32_selectq_256(__M,
+                                              (__v4di) _mm256_set1_epi64x(__A),
+                                              (__v4di) __O) ;
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_set1_epi64 (__mmask8 __M, long long __A)
+{
+   return (__m256i) __builtin_ia32_selectq_256(__M,
+                                               (__v4di) _mm256_set1_epi64x(__A),
+                                               (__v4di) _mm256_setzero_si256());
+}
+
+#define _mm_fixupimm_pd(A, B, C, imm) \
+  ((__m128d)__builtin_ia32_fixupimmpd128_mask((__v2df)(__m128d)(A), \
+                                              (__v2df)(__m128d)(B), \
+                                              (__v2di)(__m128i)(C), (int)(imm), \
+                                              (__mmask8)-1))
+
+#define _mm_mask_fixupimm_pd(A, U, B, C, imm) \
+  ((__m128d)__builtin_ia32_fixupimmpd128_mask((__v2df)(__m128d)(A), \
+                                              (__v2df)(__m128d)(B), \
+                                              (__v2di)(__m128i)(C), (int)(imm), \
+                                              (__mmask8)(U)))
+
+#define _mm_maskz_fixupimm_pd(U, A, B, C, imm) \
+  ((__m128d)__builtin_ia32_fixupimmpd128_maskz((__v2df)(__m128d)(A), \
+                                               (__v2df)(__m128d)(B), \
+                                               (__v2di)(__m128i)(C), \
+                                               (int)(imm), (__mmask8)(U)))
+
+#define _mm256_fixupimm_pd(A, B, C, imm) \
+  ((__m256d)__builtin_ia32_fixupimmpd256_mask((__v4df)(__m256d)(A), \
+                                              (__v4df)(__m256d)(B), \
+                                              (__v4di)(__m256i)(C), (int)(imm), \
+                                              (__mmask8)-1))
+
+#define _mm256_mask_fixupimm_pd(A, U, B, C, imm) \
+  ((__m256d)__builtin_ia32_fixupimmpd256_mask((__v4df)(__m256d)(A), \
+                                              (__v4df)(__m256d)(B), \
+                                              (__v4di)(__m256i)(C), (int)(imm), \
+                                              (__mmask8)(U)))
+
+#define _mm256_maskz_fixupimm_pd(U, A, B, C, imm) \
+  ((__m256d)__builtin_ia32_fixupimmpd256_maskz((__v4df)(__m256d)(A), \
+                                               (__v4df)(__m256d)(B), \
+                                               (__v4di)(__m256i)(C), \
+                                               (int)(imm), (__mmask8)(U)))
+
+#define _mm_fixupimm_ps(A, B, C, imm) \
+  ((__m128)__builtin_ia32_fixupimmps128_mask((__v4sf)(__m128)(A), \
+                                             (__v4sf)(__m128)(B), \
+                                             (__v4si)(__m128i)(C), (int)(imm), \
+                                             (__mmask8)-1))
+
+#define _mm_mask_fixupimm_ps(A, U, B, C, imm) \
+  ((__m128)__builtin_ia32_fixupimmps128_mask((__v4sf)(__m128)(A), \
+                                             (__v4sf)(__m128)(B), \
+                                             (__v4si)(__m128i)(C), (int)(imm), \
+                                             (__mmask8)(U)))
+
+#define _mm_maskz_fixupimm_ps(U, A, B, C, imm) \
+  ((__m128)__builtin_ia32_fixupimmps128_maskz((__v4sf)(__m128)(A), \
+                                              (__v4sf)(__m128)(B), \
+                                              (__v4si)(__m128i)(C), (int)(imm), \
+                                              (__mmask8)(U)))
+
+#define _mm256_fixupimm_ps(A, B, C, imm) \
+  ((__m256)__builtin_ia32_fixupimmps256_mask((__v8sf)(__m256)(A), \
+                                             (__v8sf)(__m256)(B), \
+                                             (__v8si)(__m256i)(C), (int)(imm), \
+                                             (__mmask8)-1))
+
+#define _mm256_mask_fixupimm_ps(A, U, B, C, imm) \
+  ((__m256)__builtin_ia32_fixupimmps256_mask((__v8sf)(__m256)(A), \
+                                             (__v8sf)(__m256)(B), \
+                                             (__v8si)(__m256i)(C), (int)(imm), \
+                                             (__mmask8)(U)))
+
+#define _mm256_maskz_fixupimm_ps(U, A, B, C, imm) \
+  ((__m256)__builtin_ia32_fixupimmps256_maskz((__v8sf)(__m256)(A), \
+                                              (__v8sf)(__m256)(B), \
+                                              (__v8si)(__m256i)(C), (int)(imm), \
+                                              (__mmask8)(U)))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_load_pd (__m128d __W, __mmask8 __U, void const *__P)
+{
+  return (__m128d) __builtin_ia32_loadapd128_mask ((const __v2df *) __P,
+               (__v2df) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_load_pd (__mmask8 __U, void const *__P)
+{
+  return (__m128d) __builtin_ia32_loadapd128_mask ((const __v2df *) __P,
+               (__v2df)
+               _mm_setzero_pd (),
+               (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_load_pd (__m256d __W, __mmask8 __U, void const *__P)
+{
+  return (__m256d) __builtin_ia32_loadapd256_mask ((const __v4df *) __P,
+               (__v4df) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_load_pd (__mmask8 __U, void const *__P)
+{
+  return (__m256d) __builtin_ia32_loadapd256_mask ((const __v4df *) __P,
+               (__v4df)
+               _mm256_setzero_pd (),
+               (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_load_ps (__m128 __W, __mmask8 __U, void const *__P)
+{
+  return (__m128) __builtin_ia32_loadaps128_mask ((const __v4sf *) __P,
+              (__v4sf) __W,
+              (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_load_ps (__mmask8 __U, void const *__P)
+{
+  return (__m128) __builtin_ia32_loadaps128_mask ((const __v4sf *) __P,
+              (__v4sf)
+              _mm_setzero_ps (),
+              (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_load_ps (__m256 __W, __mmask8 __U, void const *__P)
+{
+  return (__m256) __builtin_ia32_loadaps256_mask ((const __v8sf *) __P,
+              (__v8sf) __W,
+              (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_load_ps (__mmask8 __U, void const *__P)
+{
+  return (__m256) __builtin_ia32_loadaps256_mask ((const __v8sf *) __P,
+              (__v8sf)
+              _mm256_setzero_ps (),
+              (__mmask8) __U);
+}
+
+static __inline __m128i __DEFAULT_FN_ATTRS128
+_mm_loadu_epi64 (void const *__P)
+{
+  struct __loadu_epi64 {
+    __m128i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi64*)__P)->__v;
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_loadu_epi64 (__m128i __W, __mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_loaddqudi128_mask ((const __v2di *) __P,
+                 (__v2di) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_loadu_epi64 (__mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_loaddqudi128_mask ((const __v2di *) __P,
+                 (__v2di)
+                 _mm_setzero_si128 (),
+                 (__mmask8) __U);
+}
+
+static __inline __m256i __DEFAULT_FN_ATTRS256
+_mm256_loadu_epi64 (void const *__P)
+{
+  struct __loadu_epi64 {
+    __m256i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi64*)__P)->__v;
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_loadu_epi64 (__m256i __W, __mmask8 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_loaddqudi256_mask ((const __v4di *) __P,
+                 (__v4di) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_loadu_epi64 (__mmask8 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_loaddqudi256_mask ((const __v4di *) __P,
+                 (__v4di)
+                 _mm256_setzero_si256 (),
+                 (__mmask8) __U);
+}
+
+static __inline __m128i __DEFAULT_FN_ATTRS128
+_mm_loadu_epi32 (void const *__P)
+{
+  struct __loadu_epi32 {
+    __m128i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi32*)__P)->__v;
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_loadu_epi32 (__m128i __W, __mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_loaddqusi128_mask ((const __v4si *) __P,
+                 (__v4si) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_loadu_epi32 (__mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_loaddqusi128_mask ((const __v4si *) __P,
+                 (__v4si)
+                 _mm_setzero_si128 (),
+                 (__mmask8) __U);
+}
+
+static __inline __m256i __DEFAULT_FN_ATTRS256
+_mm256_loadu_epi32 (void const *__P)
+{
+  struct __loadu_epi32 {
+    __m256i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_epi32*)__P)->__v;
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_loadu_epi32 (__m256i __W, __mmask8 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_loaddqusi256_mask ((const __v8si *) __P,
+                 (__v8si) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_loadu_epi32 (__mmask8 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_loaddqusi256_mask ((const __v8si *) __P,
+                 (__v8si)
+                 _mm256_setzero_si256 (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_loadu_pd (__m128d __W, __mmask8 __U, void const *__P)
+{
+  return (__m128d) __builtin_ia32_loadupd128_mask ((const __v2df *) __P,
+               (__v2df) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_loadu_pd (__mmask8 __U, void const *__P)
+{
+  return (__m128d) __builtin_ia32_loadupd128_mask ((const __v2df *) __P,
+               (__v2df)
+               _mm_setzero_pd (),
+               (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_loadu_pd (__m256d __W, __mmask8 __U, void const *__P)
+{
+  return (__m256d) __builtin_ia32_loadupd256_mask ((const __v4df *) __P,
+               (__v4df) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_loadu_pd (__mmask8 __U, void const *__P)
+{
+  return (__m256d) __builtin_ia32_loadupd256_mask ((const __v4df *) __P,
+               (__v4df)
+               _mm256_setzero_pd (),
+               (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_loadu_ps (__m128 __W, __mmask8 __U, void const *__P)
+{
+  return (__m128) __builtin_ia32_loadups128_mask ((const __v4sf *) __P,
+              (__v4sf) __W,
+              (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_loadu_ps (__mmask8 __U, void const *__P)
+{
+  return (__m128) __builtin_ia32_loadups128_mask ((const __v4sf *) __P,
+              (__v4sf)
+              _mm_setzero_ps (),
+              (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_loadu_ps (__m256 __W, __mmask8 __U, void const *__P)
+{
+  return (__m256) __builtin_ia32_loadups256_mask ((const __v8sf *) __P,
+              (__v8sf) __W,
+              (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_loadu_ps (__mmask8 __U, void const *__P)
+{
+  return (__m256) __builtin_ia32_loadups256_mask ((const __v8sf *) __P,
+              (__v8sf)
+              _mm256_setzero_ps (),
+              (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_store_pd (void *__P, __mmask8 __U, __m128d __A)
+{
+  __builtin_ia32_storeapd128_mask ((__v2df *) __P,
+           (__v2df) __A,
+           (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_store_pd (void *__P, __mmask8 __U, __m256d __A)
+{
+  __builtin_ia32_storeapd256_mask ((__v4df *) __P,
+           (__v4df) __A,
+           (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_store_ps (void *__P, __mmask8 __U, __m128 __A)
+{
+  __builtin_ia32_storeaps128_mask ((__v4sf *) __P,
+           (__v4sf) __A,
+           (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_store_ps (void *__P, __mmask8 __U, __m256 __A)
+{
+  __builtin_ia32_storeaps256_mask ((__v8sf *) __P,
+           (__v8sf) __A,
+           (__mmask8) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS128
+_mm_storeu_epi64 (void *__P, __m128i __A)
+{
+  struct __storeu_epi64 {
+    __m128i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi64*)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_storeu_epi64 (void *__P, __mmask8 __U, __m128i __A)
+{
+  __builtin_ia32_storedqudi128_mask ((__v2di *) __P,
+             (__v2di) __A,
+             (__mmask8) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS256
+_mm256_storeu_epi64 (void *__P, __m256i __A)
+{
+  struct __storeu_epi64 {
+    __m256i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi64*)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_storeu_epi64 (void *__P, __mmask8 __U, __m256i __A)
+{
+  __builtin_ia32_storedqudi256_mask ((__v4di *) __P,
+             (__v4di) __A,
+             (__mmask8) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS128
+_mm_storeu_epi32 (void *__P, __m128i __A)
+{
+  struct __storeu_epi32 {
+    __m128i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi32*)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_storeu_epi32 (void *__P, __mmask8 __U, __m128i __A)
+{
+  __builtin_ia32_storedqusi128_mask ((__v4si *) __P,
+             (__v4si) __A,
+             (__mmask8) __U);
+}
+
+static __inline void __DEFAULT_FN_ATTRS256
+_mm256_storeu_epi32 (void *__P, __m256i __A)
+{
+  struct __storeu_epi32 {
+    __m256i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_epi32*)__P)->__v = __A;
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_storeu_epi32 (void *__P, __mmask8 __U, __m256i __A)
+{
+  __builtin_ia32_storedqusi256_mask ((__v8si *) __P,
+             (__v8si) __A,
+             (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_storeu_pd (void *__P, __mmask8 __U, __m128d __A)
+{
+  __builtin_ia32_storeupd128_mask ((__v2df *) __P,
+           (__v2df) __A,
+           (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_storeu_pd (void *__P, __mmask8 __U, __m256d __A)
+{
+  __builtin_ia32_storeupd256_mask ((__v4df *) __P,
+           (__v4df) __A,
+           (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_storeu_ps (void *__P, __mmask8 __U, __m128 __A)
+{
+  __builtin_ia32_storeups128_mask ((__v4sf *) __P,
+           (__v4sf) __A,
+           (__mmask8) __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_storeu_ps (void *__P, __mmask8 __U, __m256 __A)
+{
+  __builtin_ia32_storeups256_mask ((__v8sf *) __P,
+           (__v8sf) __A,
+           (__mmask8) __U);
+}
+
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_unpackhi_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_unpackhi_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_unpackhi_pd(__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_unpackhi_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_unpackhi_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                           (__v4df)_mm256_unpackhi_pd(__A, __B),
+                                           (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpackhi_pd(__mmask8 __U, __m256d __A, __m256d __B)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                           (__v4df)_mm256_unpackhi_pd(__A, __B),
+                                           (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_unpackhi_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_unpackhi_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_unpackhi_ps(__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_unpackhi_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_unpackhi_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                           (__v8sf)_mm256_unpackhi_ps(__A, __B),
+                                           (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpackhi_ps(__mmask8 __U, __m256 __A, __m256 __B)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                           (__v8sf)_mm256_unpackhi_ps(__A, __B),
+                                           (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_unpacklo_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_unpacklo_pd(__A, __B),
+                                              (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_unpacklo_pd(__mmask8 __U, __m128d __A, __m128d __B)
+{
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                              (__v2df)_mm_unpacklo_pd(__A, __B),
+                                              (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_unpacklo_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256d __B)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                           (__v4df)_mm256_unpacklo_pd(__A, __B),
+                                           (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpacklo_pd(__mmask8 __U, __m256d __A, __m256d __B)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                           (__v4df)_mm256_unpacklo_pd(__A, __B),
+                                           (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_unpacklo_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_unpacklo_ps(__A, __B),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_unpacklo_ps(__mmask8 __U, __m128 __A, __m128 __B)
+{
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_unpacklo_ps(__A, __B),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_unpacklo_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256 __B)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                           (__v8sf)_mm256_unpacklo_ps(__A, __B),
+                                           (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpacklo_ps(__mmask8 __U, __m256 __A, __m256 __B)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                           (__v8sf)_mm256_unpacklo_ps(__A, __B),
+                                           (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_rcp14_pd (__m128d __A)
+{
+  return (__m128d) __builtin_ia32_rcp14pd128_mask ((__v2df) __A,
+                (__v2df)
+                _mm_setzero_pd (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_rcp14_pd (__m128d __W, __mmask8 __U, __m128d __A)
+{
+  return (__m128d) __builtin_ia32_rcp14pd128_mask ((__v2df) __A,
+                (__v2df) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_rcp14_pd (__mmask8 __U, __m128d __A)
+{
+  return (__m128d) __builtin_ia32_rcp14pd128_mask ((__v2df) __A,
+                (__v2df)
+                _mm_setzero_pd (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_rcp14_pd (__m256d __A)
+{
+  return (__m256d) __builtin_ia32_rcp14pd256_mask ((__v4df) __A,
+                (__v4df)
+                _mm256_setzero_pd (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_rcp14_pd (__m256d __W, __mmask8 __U, __m256d __A)
+{
+  return (__m256d) __builtin_ia32_rcp14pd256_mask ((__v4df) __A,
+                (__v4df) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_rcp14_pd (__mmask8 __U, __m256d __A)
+{
+  return (__m256d) __builtin_ia32_rcp14pd256_mask ((__v4df) __A,
+                (__v4df)
+                _mm256_setzero_pd (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_rcp14_ps (__m128 __A)
+{
+  return (__m128) __builtin_ia32_rcp14ps128_mask ((__v4sf) __A,
+               (__v4sf)
+               _mm_setzero_ps (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_rcp14_ps (__m128 __W, __mmask8 __U, __m128 __A)
+{
+  return (__m128) __builtin_ia32_rcp14ps128_mask ((__v4sf) __A,
+               (__v4sf) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_rcp14_ps (__mmask8 __U, __m128 __A)
+{
+  return (__m128) __builtin_ia32_rcp14ps128_mask ((__v4sf) __A,
+               (__v4sf)
+               _mm_setzero_ps (),
+               (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_rcp14_ps (__m256 __A)
+{
+  return (__m256) __builtin_ia32_rcp14ps256_mask ((__v8sf) __A,
+               (__v8sf)
+               _mm256_setzero_ps (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_rcp14_ps (__m256 __W, __mmask8 __U, __m256 __A)
+{
+  return (__m256) __builtin_ia32_rcp14ps256_mask ((__v8sf) __A,
+               (__v8sf) __W,
+               (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_rcp14_ps (__mmask8 __U, __m256 __A)
+{
+  return (__m256) __builtin_ia32_rcp14ps256_mask ((__v8sf) __A,
+               (__v8sf)
+               _mm256_setzero_ps (),
+               (__mmask8) __U);
+}
+
+#define _mm_mask_permute_pd(W, U, X, C) \
+  ((__m128d)__builtin_ia32_selectpd_128((__mmask8)(U), \
+                                        (__v2df)_mm_permute_pd((X), (C)), \
+                                        (__v2df)(__m128d)(W)))
+
+#define _mm_maskz_permute_pd(U, X, C) \
+  ((__m128d)__builtin_ia32_selectpd_128((__mmask8)(U), \
+                                        (__v2df)_mm_permute_pd((X), (C)), \
+                                        (__v2df)_mm_setzero_pd()))
+
+#define _mm256_mask_permute_pd(W, U, X, C) \
+  ((__m256d)__builtin_ia32_selectpd_256((__mmask8)(U), \
+                                        (__v4df)_mm256_permute_pd((X), (C)), \
+                                        (__v4df)(__m256d)(W)))
+
+#define _mm256_maskz_permute_pd(U, X, C) \
+  ((__m256d)__builtin_ia32_selectpd_256((__mmask8)(U), \
+                                        (__v4df)_mm256_permute_pd((X), (C)), \
+                                        (__v4df)_mm256_setzero_pd()))
+
+#define _mm_mask_permute_ps(W, U, X, C) \
+  ((__m128)__builtin_ia32_selectps_128((__mmask8)(U), \
+                                       (__v4sf)_mm_permute_ps((X), (C)), \
+                                       (__v4sf)(__m128)(W)))
+
+#define _mm_maskz_permute_ps(U, X, C) \
+  ((__m128)__builtin_ia32_selectps_128((__mmask8)(U), \
+                                       (__v4sf)_mm_permute_ps((X), (C)), \
+                                       (__v4sf)_mm_setzero_ps()))
+
+#define _mm256_mask_permute_ps(W, U, X, C) \
+  ((__m256)__builtin_ia32_selectps_256((__mmask8)(U), \
+                                       (__v8sf)_mm256_permute_ps((X), (C)), \
+                                       (__v8sf)(__m256)(W)))
+
+#define _mm256_maskz_permute_ps(U, X, C) \
+  ((__m256)__builtin_ia32_selectps_256((__mmask8)(U), \
+                                       (__v8sf)_mm256_permute_ps((X), (C)), \
+                                       (__v8sf)_mm256_setzero_ps()))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_permutevar_pd(__m128d __W, __mmask8 __U, __m128d __A, __m128i __C)
+{
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                            (__v2df)_mm_permutevar_pd(__A, __C),
+                                            (__v2df)__W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_permutevar_pd(__mmask8 __U, __m128d __A, __m128i __C)
+{
+  return (__m128d)__builtin_ia32_selectpd_128((__mmask8)__U,
+                                            (__v2df)_mm_permutevar_pd(__A, __C),
+                                            (__v2df)_mm_setzero_pd());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_permutevar_pd(__m256d __W, __mmask8 __U, __m256d __A, __m256i __C)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                         (__v4df)_mm256_permutevar_pd(__A, __C),
+                                         (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_permutevar_pd(__mmask8 __U, __m256d __A, __m256i __C)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                         (__v4df)_mm256_permutevar_pd(__A, __C),
+                                         (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_permutevar_ps(__m128 __W, __mmask8 __U, __m128 __A, __m128i __C)
+{
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                            (__v4sf)_mm_permutevar_ps(__A, __C),
+                                            (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_permutevar_ps(__mmask8 __U, __m128 __A, __m128i __C)
+{
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                            (__v4sf)_mm_permutevar_ps(__A, __C),
+                                            (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_permutevar_ps(__m256 __W, __mmask8 __U, __m256 __A, __m256i __C)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                          (__v8sf)_mm256_permutevar_ps(__A, __C),
+                                          (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_permutevar_ps(__mmask8 __U, __m256 __A, __m256i __C)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                          (__v8sf)_mm256_permutevar_ps(__A, __C),
+                                          (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_test_epi32_mask (__m128i __A, __m128i __B)
+{
+  return _mm_cmpneq_epi32_mask (_mm_and_si128 (__A, __B), _mm_setzero_si128());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_mask_test_epi32_mask (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return _mm_mask_cmpneq_epi32_mask (__U, _mm_and_si128 (__A, __B),
+                                     _mm_setzero_si128());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS256
+_mm256_test_epi32_mask (__m256i __A, __m256i __B)
+{
+  return _mm256_cmpneq_epi32_mask (_mm256_and_si256 (__A, __B),
+                                   _mm256_setzero_si256());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS256
+_mm256_mask_test_epi32_mask (__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return _mm256_mask_cmpneq_epi32_mask (__U, _mm256_and_si256 (__A, __B),
+                                        _mm256_setzero_si256());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_test_epi64_mask (__m128i __A, __m128i __B)
+{
+  return _mm_cmpneq_epi64_mask (_mm_and_si128 (__A, __B), _mm_setzero_si128());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_mask_test_epi64_mask (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return _mm_mask_cmpneq_epi64_mask (__U, _mm_and_si128 (__A, __B),
+                                     _mm_setzero_si128());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS256
+_mm256_test_epi64_mask (__m256i __A, __m256i __B)
+{
+  return _mm256_cmpneq_epi64_mask (_mm256_and_si256 (__A, __B),
+                                   _mm256_setzero_si256());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS256
+_mm256_mask_test_epi64_mask (__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return _mm256_mask_cmpneq_epi64_mask (__U, _mm256_and_si256 (__A, __B),
+                                        _mm256_setzero_si256());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_testn_epi32_mask (__m128i __A, __m128i __B)
+{
+  return _mm_cmpeq_epi32_mask (_mm_and_si128 (__A, __B), _mm_setzero_si128());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_mask_testn_epi32_mask (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return _mm_mask_cmpeq_epi32_mask (__U, _mm_and_si128 (__A, __B),
+                                    _mm_setzero_si128());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS256
+_mm256_testn_epi32_mask (__m256i __A, __m256i __B)
+{
+  return _mm256_cmpeq_epi32_mask (_mm256_and_si256 (__A, __B),
+                                  _mm256_setzero_si256());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS256
+_mm256_mask_testn_epi32_mask (__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return _mm256_mask_cmpeq_epi32_mask (__U, _mm256_and_si256 (__A, __B),
+                                       _mm256_setzero_si256());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_testn_epi64_mask (__m128i __A, __m128i __B)
+{
+  return _mm_cmpeq_epi64_mask (_mm_and_si128 (__A, __B), _mm_setzero_si128());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS128
+_mm_mask_testn_epi64_mask (__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return _mm_mask_cmpeq_epi64_mask (__U, _mm_and_si128 (__A, __B),
+                                    _mm_setzero_si128());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS256
+_mm256_testn_epi64_mask (__m256i __A, __m256i __B)
+{
+  return _mm256_cmpeq_epi64_mask (_mm256_and_si256 (__A, __B),
+                                  _mm256_setzero_si256());
+}
+
+static __inline__ __mmask8 __DEFAULT_FN_ATTRS256
+_mm256_mask_testn_epi64_mask (__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return _mm256_mask_cmpeq_epi64_mask (__U, _mm256_and_si256 (__A, __B),
+                                       _mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_unpackhi_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                           (__v4si)_mm_unpackhi_epi32(__A, __B),
+                                           (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_unpackhi_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                           (__v4si)_mm_unpackhi_epi32(__A, __B),
+                                           (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_unpackhi_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                        (__v8si)_mm256_unpackhi_epi32(__A, __B),
+                                        (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpackhi_epi32(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                        (__v8si)_mm256_unpackhi_epi32(__A, __B),
+                                        (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_unpackhi_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                           (__v2di)_mm_unpackhi_epi64(__A, __B),
+                                           (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_unpackhi_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                           (__v2di)_mm_unpackhi_epi64(__A, __B),
+                                           (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_unpackhi_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                        (__v4di)_mm256_unpackhi_epi64(__A, __B),
+                                        (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpackhi_epi64(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                        (__v4di)_mm256_unpackhi_epi64(__A, __B),
+                                        (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_unpacklo_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                           (__v4si)_mm_unpacklo_epi32(__A, __B),
+                                           (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_unpacklo_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                           (__v4si)_mm_unpacklo_epi32(__A, __B),
+                                           (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_unpacklo_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                        (__v8si)_mm256_unpacklo_epi32(__A, __B),
+                                        (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpacklo_epi32(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                        (__v8si)_mm256_unpacklo_epi32(__A, __B),
+                                        (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_unpacklo_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                           (__v2di)_mm_unpacklo_epi64(__A, __B),
+                                           (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_unpacklo_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U,
+                                           (__v2di)_mm_unpacklo_epi64(__A, __B),
+                                           (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_unpacklo_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                        (__v4di)_mm256_unpacklo_epi64(__A, __B),
+                                        (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_unpacklo_epi64(__mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U,
+                                        (__v4di)_mm256_unpacklo_epi64(__A, __B),
+                                        (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sra_epi32(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_sra_epi32(__A, __B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sra_epi32(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_sra_epi32(__A, __B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sra_epi32(__m256i __W, __mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_sra_epi32(__A, __B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sra_epi32(__mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_sra_epi32(__A, __B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srai_epi32(__m128i __W, __mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_srai_epi32(__A, (int)__B),
+                                             (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srai_epi32(__mmask8 __U, __m128i __A, unsigned int __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__U,
+                                             (__v4si)_mm_srai_epi32(__A, (int)__B),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srai_epi32(__m256i __W, __mmask8 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_srai_epi32(__A, (int)__B),
+                                             (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srai_epi32(__mmask8 __U, __m256i __A, unsigned int __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__U,
+                                             (__v8si)_mm256_srai_epi32(__A, (int)__B),
+                                             (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_sra_epi64(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_psraq128((__v2di)__A, (__v2di)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_sra_epi64(__m128i __W, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U, \
+                                             (__v2di)_mm_sra_epi64(__A, __B), \
+                                             (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_sra_epi64(__mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U, \
+                                             (__v2di)_mm_sra_epi64(__A, __B), \
+                                             (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sra_epi64(__m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_psraq256((__v4di) __A, (__v2di) __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_sra_epi64(__m256i __W, __mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U, \
+                                           (__v4di)_mm256_sra_epi64(__A, __B), \
+                                           (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_sra_epi64(__mmask8 __U, __m256i __A, __m128i __B)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U, \
+                                           (__v4di)_mm256_sra_epi64(__A, __B), \
+                                           (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_srai_epi64(__m128i __A, unsigned int __imm)
+{
+  return (__m128i)__builtin_ia32_psraqi128((__v2di)__A, (int)__imm);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_srai_epi64(__m128i __W, __mmask8 __U, __m128i __A, unsigned int __imm)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U, \
+                                           (__v2di)_mm_srai_epi64(__A, __imm), \
+                                           (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_srai_epi64(__mmask8 __U, __m128i __A, unsigned int __imm)
+{
+  return (__m128i)__builtin_ia32_selectq_128((__mmask8)__U, \
+                                           (__v2di)_mm_srai_epi64(__A, __imm), \
+                                           (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_srai_epi64(__m256i __A, unsigned int __imm)
+{
+  return (__m256i)__builtin_ia32_psraqi256((__v4di)__A, (int)__imm);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_srai_epi64(__m256i __W, __mmask8 __U, __m256i __A,
+                       unsigned int __imm)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U, \
+                                        (__v4di)_mm256_srai_epi64(__A, __imm), \
+                                        (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_srai_epi64(__mmask8 __U, __m256i __A, unsigned int __imm)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__U, \
+                                        (__v4di)_mm256_srai_epi64(__A, __imm), \
+                                        (__v4di)_mm256_setzero_si256());
+}
+
+#define _mm_ternarylogic_epi32(A, B, C, imm)                                   \
+  ((__m128i)__builtin_ia32_pternlogd128_mask(                                  \
+      (__v4si)(__m128i)(A), (__v4si)(__m128i)(B), (__v4si)(__m128i)(C),        \
+      (unsigned char)(imm), (__mmask8)-1))
+
+#define _mm_mask_ternarylogic_epi32(A, U, B, C, imm)                           \
+  ((__m128i)__builtin_ia32_pternlogd128_mask(                                  \
+      (__v4si)(__m128i)(A), (__v4si)(__m128i)(B), (__v4si)(__m128i)(C),        \
+      (unsigned char)(imm), (__mmask8)(U)))
+
+#define _mm_maskz_ternarylogic_epi32(U, A, B, C, imm)                          \
+  ((__m128i)__builtin_ia32_pternlogd128_maskz(                                 \
+      (__v4si)(__m128i)(A), (__v4si)(__m128i)(B), (__v4si)(__m128i)(C),        \
+      (unsigned char)(imm), (__mmask8)(U)))
+
+#define _mm256_ternarylogic_epi32(A, B, C, imm)                                \
+  ((__m256i)__builtin_ia32_pternlogd256_mask(                                  \
+      (__v8si)(__m256i)(A), (__v8si)(__m256i)(B), (__v8si)(__m256i)(C),        \
+      (unsigned char)(imm), (__mmask8)-1))
+
+#define _mm256_mask_ternarylogic_epi32(A, U, B, C, imm)                        \
+  ((__m256i)__builtin_ia32_pternlogd256_mask(                                  \
+      (__v8si)(__m256i)(A), (__v8si)(__m256i)(B), (__v8si)(__m256i)(C),        \
+      (unsigned char)(imm), (__mmask8)(U)))
+
+#define _mm256_maskz_ternarylogic_epi32(U, A, B, C, imm)                       \
+  ((__m256i)__builtin_ia32_pternlogd256_maskz(                                 \
+      (__v8si)(__m256i)(A), (__v8si)(__m256i)(B), (__v8si)(__m256i)(C),        \
+      (unsigned char)(imm), (__mmask8)(U)))
+
+#define _mm_ternarylogic_epi64(A, B, C, imm)                                   \
+  ((__m128i)__builtin_ia32_pternlogq128_mask(                                  \
+      (__v2di)(__m128i)(A), (__v2di)(__m128i)(B), (__v2di)(__m128i)(C),        \
+      (unsigned char)(imm), (__mmask8)-1))
+
+#define _mm_mask_ternarylogic_epi64(A, U, B, C, imm)                           \
+  ((__m128i)__builtin_ia32_pternlogq128_mask(                                  \
+      (__v2di)(__m128i)(A), (__v2di)(__m128i)(B), (__v2di)(__m128i)(C),        \
+      (unsigned char)(imm), (__mmask8)(U)))
+
+#define _mm_maskz_ternarylogic_epi64(U, A, B, C, imm)                          \
+  ((__m128i)__builtin_ia32_pternlogq128_maskz(                                 \
+      (__v2di)(__m128i)(A), (__v2di)(__m128i)(B), (__v2di)(__m128i)(C),        \
+      (unsigned char)(imm), (__mmask8)(U)))
+
+#define _mm256_ternarylogic_epi64(A, B, C, imm)                                \
+  ((__m256i)__builtin_ia32_pternlogq256_mask(                                  \
+      (__v4di)(__m256i)(A), (__v4di)(__m256i)(B), (__v4di)(__m256i)(C),        \
+      (unsigned char)(imm), (__mmask8)-1))
+
+#define _mm256_mask_ternarylogic_epi64(A, U, B, C, imm)                        \
+  ((__m256i)__builtin_ia32_pternlogq256_mask(                                  \
+      (__v4di)(__m256i)(A), (__v4di)(__m256i)(B), (__v4di)(__m256i)(C),        \
+      (unsigned char)(imm), (__mmask8)(U)))
+
+#define _mm256_maskz_ternarylogic_epi64(U, A, B, C, imm)                       \
+  ((__m256i)__builtin_ia32_pternlogq256_maskz(                                 \
+      (__v4di)(__m256i)(A), (__v4di)(__m256i)(B), (__v4di)(__m256i)(C),        \
+      (unsigned char)(imm), (__mmask8)(U)))
+
+#define _mm256_shuffle_f32x4(A, B, imm) \
+  ((__m256)__builtin_ia32_shuf_f32x4_256((__v8sf)(__m256)(A), \
+                                         (__v8sf)(__m256)(B), (int)(imm)))
+
+#define _mm256_mask_shuffle_f32x4(W, U, A, B, imm) \
+  ((__m256)__builtin_ia32_selectps_256((__mmask8)(U), \
+                                       (__v8sf)_mm256_shuffle_f32x4((A), (B), (imm)), \
+                                       (__v8sf)(__m256)(W)))
+
+#define _mm256_maskz_shuffle_f32x4(U, A, B, imm) \
+  ((__m256)__builtin_ia32_selectps_256((__mmask8)(U), \
+                                       (__v8sf)_mm256_shuffle_f32x4((A), (B), (imm)), \
+                                       (__v8sf)_mm256_setzero_ps()))
+
+#define _mm256_shuffle_f64x2(A, B, imm) \
+  ((__m256d)__builtin_ia32_shuf_f64x2_256((__v4df)(__m256d)(A), \
+                                          (__v4df)(__m256d)(B), (int)(imm)))
+
+#define _mm256_mask_shuffle_f64x2(W, U, A, B, imm) \
+  ((__m256d)__builtin_ia32_selectpd_256((__mmask8)(U), \
+                                       (__v4df)_mm256_shuffle_f64x2((A), (B), (imm)), \
+                                       (__v4df)(__m256d)(W)))
+
+#define _mm256_maskz_shuffle_f64x2(U, A, B, imm) \
+  ((__m256d)__builtin_ia32_selectpd_256((__mmask8)(U), \
+                                       (__v4df)_mm256_shuffle_f64x2((A), (B), (imm)), \
+                                       (__v4df)_mm256_setzero_pd()))
+
+#define _mm256_shuffle_i32x4(A, B, imm) \
+  ((__m256i)__builtin_ia32_shuf_i32x4_256((__v8si)(__m256i)(A), \
+                                          (__v8si)(__m256i)(B), (int)(imm)))
+
+#define _mm256_mask_shuffle_i32x4(W, U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                       (__v8si)_mm256_shuffle_i32x4((A), (B), (imm)), \
+                                       (__v8si)(__m256i)(W)))
+
+#define _mm256_maskz_shuffle_i32x4(U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                       (__v8si)_mm256_shuffle_i32x4((A), (B), (imm)), \
+                                       (__v8si)_mm256_setzero_si256()))
+
+#define _mm256_shuffle_i64x2(A, B, imm) \
+  ((__m256i)__builtin_ia32_shuf_i64x2_256((__v4di)(__m256i)(A), \
+                                          (__v4di)(__m256i)(B), (int)(imm)))
+
+#define _mm256_mask_shuffle_i64x2(W, U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                       (__v4di)_mm256_shuffle_i64x2((A), (B), (imm)), \
+                                       (__v4di)(__m256i)(W)))
+
+
+#define _mm256_maskz_shuffle_i64x2(U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                       (__v4di)_mm256_shuffle_i64x2((A), (B), (imm)), \
+                                       (__v4di)_mm256_setzero_si256()))
+
+#define _mm_mask_shuffle_pd(W, U, A, B, M) \
+  ((__m128d)__builtin_ia32_selectpd_128((__mmask8)(U), \
+                                        (__v2df)_mm_shuffle_pd((A), (B), (M)), \
+                                        (__v2df)(__m128d)(W)))
+
+#define _mm_maskz_shuffle_pd(U, A, B, M) \
+  ((__m128d)__builtin_ia32_selectpd_128((__mmask8)(U), \
+                                        (__v2df)_mm_shuffle_pd((A), (B), (M)), \
+                                        (__v2df)_mm_setzero_pd()))
+
+#define _mm256_mask_shuffle_pd(W, U, A, B, M) \
+  ((__m256d)__builtin_ia32_selectpd_256((__mmask8)(U), \
+                                        (__v4df)_mm256_shuffle_pd((A), (B), (M)), \
+                                        (__v4df)(__m256d)(W)))
+
+#define _mm256_maskz_shuffle_pd(U, A, B, M) \
+  ((__m256d)__builtin_ia32_selectpd_256((__mmask8)(U), \
+                                        (__v4df)_mm256_shuffle_pd((A), (B), (M)), \
+                                        (__v4df)_mm256_setzero_pd()))
+
+#define _mm_mask_shuffle_ps(W, U, A, B, M) \
+  ((__m128)__builtin_ia32_selectps_128((__mmask8)(U), \
+                                       (__v4sf)_mm_shuffle_ps((A), (B), (M)), \
+                                       (__v4sf)(__m128)(W)))
+
+#define _mm_maskz_shuffle_ps(U, A, B, M) \
+  ((__m128)__builtin_ia32_selectps_128((__mmask8)(U), \
+                                       (__v4sf)_mm_shuffle_ps((A), (B), (M)), \
+                                       (__v4sf)_mm_setzero_ps()))
+
+#define _mm256_mask_shuffle_ps(W, U, A, B, M) \
+  ((__m256)__builtin_ia32_selectps_256((__mmask8)(U), \
+                                       (__v8sf)_mm256_shuffle_ps((A), (B), (M)), \
+                                       (__v8sf)(__m256)(W)))
+
+#define _mm256_maskz_shuffle_ps(U, A, B, M) \
+  ((__m256)__builtin_ia32_selectps_256((__mmask8)(U), \
+                                       (__v8sf)_mm256_shuffle_ps((A), (B), (M)), \
+                                       (__v8sf)_mm256_setzero_ps()))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_rsqrt14_pd (__m128d __A)
+{
+  return (__m128d) __builtin_ia32_rsqrt14pd128_mask ((__v2df) __A,
+                 (__v2df)
+                 _mm_setzero_pd (),
+                 (__mmask8) -1);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_rsqrt14_pd (__m128d __W, __mmask8 __U, __m128d __A)
+{
+  return (__m128d) __builtin_ia32_rsqrt14pd128_mask ((__v2df) __A,
+                 (__v2df) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_rsqrt14_pd (__mmask8 __U, __m128d __A)
+{
+  return (__m128d) __builtin_ia32_rsqrt14pd128_mask ((__v2df) __A,
+                 (__v2df)
+                 _mm_setzero_pd (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_rsqrt14_pd (__m256d __A)
+{
+  return (__m256d) __builtin_ia32_rsqrt14pd256_mask ((__v4df) __A,
+                 (__v4df)
+                 _mm256_setzero_pd (),
+                 (__mmask8) -1);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_rsqrt14_pd (__m256d __W, __mmask8 __U, __m256d __A)
+{
+  return (__m256d) __builtin_ia32_rsqrt14pd256_mask ((__v4df) __A,
+                 (__v4df) __W,
+                 (__mmask8) __U);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_rsqrt14_pd (__mmask8 __U, __m256d __A)
+{
+  return (__m256d) __builtin_ia32_rsqrt14pd256_mask ((__v4df) __A,
+                 (__v4df)
+                 _mm256_setzero_pd (),
+                 (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_rsqrt14_ps (__m128 __A)
+{
+  return (__m128) __builtin_ia32_rsqrt14ps128_mask ((__v4sf) __A,
+                (__v4sf)
+                _mm_setzero_ps (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_rsqrt14_ps (__m128 __W, __mmask8 __U, __m128 __A)
+{
+  return (__m128) __builtin_ia32_rsqrt14ps128_mask ((__v4sf) __A,
+                (__v4sf) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_rsqrt14_ps (__mmask8 __U, __m128 __A)
+{
+  return (__m128) __builtin_ia32_rsqrt14ps128_mask ((__v4sf) __A,
+                (__v4sf)
+                _mm_setzero_ps (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_rsqrt14_ps (__m256 __A)
+{
+  return (__m256) __builtin_ia32_rsqrt14ps256_mask ((__v8sf) __A,
+                (__v8sf)
+                _mm256_setzero_ps (),
+                (__mmask8) -1);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_rsqrt14_ps (__m256 __W, __mmask8 __U, __m256 __A)
+{
+  return (__m256) __builtin_ia32_rsqrt14ps256_mask ((__v8sf) __A,
+                (__v8sf) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_rsqrt14_ps (__mmask8 __U, __m256 __A)
+{
+  return (__m256) __builtin_ia32_rsqrt14ps256_mask ((__v8sf) __A,
+                (__v8sf)
+                _mm256_setzero_ps (),
+                (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_broadcast_f32x4(__m128 __A)
+{
+  return (__m256)__builtin_shufflevector((__v4sf)__A, (__v4sf)__A,
+                                         0, 1, 2, 3, 0, 1, 2, 3);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcast_f32x4(__m256 __O, __mmask8 __M, __m128 __A)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__M,
+                                            (__v8sf)_mm256_broadcast_f32x4(__A),
+                                            (__v8sf)__O);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcast_f32x4 (__mmask8 __M, __m128 __A)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__M,
+                                            (__v8sf)_mm256_broadcast_f32x4(__A),
+                                            (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_broadcast_i32x4(__m128i __A)
+{
+  return (__m256i)__builtin_shufflevector((__v4si)__A, (__v4si)__A,
+                                          0, 1, 2, 3, 0, 1, 2, 3);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcast_i32x4(__m256i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                            (__v8si)_mm256_broadcast_i32x4(__A),
+                                            (__v8si)__O);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcast_i32x4(__mmask8 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                            (__v8si)_mm256_broadcast_i32x4(__A),
+                                            (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcastsd_pd (__m256d __O, __mmask8 __M, __m128d __A)
+{
+  return (__m256d)__builtin_ia32_selectpd_256(__M,
+                                              (__v4df) _mm256_broadcastsd_pd(__A),
+                                              (__v4df) __O);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcastsd_pd (__mmask8 __M, __m128d __A)
+{
+  return (__m256d)__builtin_ia32_selectpd_256(__M,
+                                              (__v4df) _mm256_broadcastsd_pd(__A),
+                                              (__v4df) _mm256_setzero_pd());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_broadcastss_ps (__m128 __O, __mmask8 __M, __m128 __A)
+{
+  return (__m128)__builtin_ia32_selectps_128(__M,
+                                             (__v4sf) _mm_broadcastss_ps(__A),
+                                             (__v4sf) __O);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_broadcastss_ps (__mmask8 __M, __m128 __A)
+{
+  return (__m128)__builtin_ia32_selectps_128(__M,
+                                             (__v4sf) _mm_broadcastss_ps(__A),
+                                             (__v4sf) _mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcastss_ps (__m256 __O, __mmask8 __M, __m128 __A)
+{
+  return (__m256)__builtin_ia32_selectps_256(__M,
+                                             (__v8sf) _mm256_broadcastss_ps(__A),
+                                             (__v8sf) __O);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcastss_ps (__mmask8 __M, __m128 __A)
+{
+  return (__m256)__builtin_ia32_selectps_256(__M,
+                                             (__v8sf) _mm256_broadcastss_ps(__A),
+                                             (__v8sf) _mm256_setzero_ps());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_broadcastd_epi32 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__M,
+                                             (__v4si) _mm_broadcastd_epi32(__A),
+                                             (__v4si) __O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_broadcastd_epi32 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__M,
+                                             (__v4si) _mm_broadcastd_epi32(__A),
+                                             (__v4si) _mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcastd_epi32 (__m256i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__M,
+                                             (__v8si) _mm256_broadcastd_epi32(__A),
+                                             (__v8si) __O);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcastd_epi32 (__mmask8 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__M,
+                                             (__v8si) _mm256_broadcastd_epi32(__A),
+                                             (__v8si) _mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_broadcastq_epi64 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__M,
+                                             (__v2di) _mm_broadcastq_epi64(__A),
+                                             (__v2di) __O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_broadcastq_epi64 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__M,
+                                             (__v2di) _mm_broadcastq_epi64(__A),
+                                             (__v2di) _mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_broadcastq_epi64 (__m256i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__M,
+                                             (__v4di) _mm256_broadcastq_epi64(__A),
+                                             (__v4di) __O);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_broadcastq_epi64 (__mmask8 __M, __m128i __A)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__M,
+                                             (__v4di) _mm256_broadcastq_epi64(__A),
+                                             (__v4di) _mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtsepi32_epi8 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdb128_mask ((__v4si) __A,
+               (__v16qi)_mm_undefined_si128(),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi32_epi8 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdb128_mask ((__v4si) __A,
+               (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtsepi32_epi8 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdb128_mask ((__v4si) __A,
+               (__v16qi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi32_storeu_epi8 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovsdb128mem_mask ((__v16qi *) __P, (__v4si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtsepi32_epi8 (__m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdb256_mask ((__v8si) __A,
+               (__v16qi)_mm_undefined_si128(),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi32_epi8 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdb256_mask ((__v8si) __A,
+               (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtsepi32_epi8 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdb256_mask ((__v8si) __A,
+               (__v16qi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi32_storeu_epi8 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovsdb256mem_mask ((__v16qi *) __P, (__v8si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtsepi32_epi16 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdw128_mask ((__v4si) __A,
+               (__v8hi)_mm_setzero_si128 (),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi32_epi16 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdw128_mask ((__v4si) __A,
+               (__v8hi)__O,
+               __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtsepi32_epi16 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdw128_mask ((__v4si) __A,
+               (__v8hi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi32_storeu_epi16 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovsdw128mem_mask ((__v8hi *) __P, (__v4si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtsepi32_epi16 (__m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdw256_mask ((__v8si) __A,
+               (__v8hi)_mm_undefined_si128(),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi32_epi16 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdw256_mask ((__v8si) __A,
+               (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtsepi32_epi16 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsdw256_mask ((__v8si) __A,
+               (__v8hi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi32_storeu_epi16 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovsdw256mem_mask ((__v8hi *) __P, (__v8si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtsepi64_epi8 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqb128_mask ((__v2di) __A,
+               (__v16qi)_mm_undefined_si128(),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi64_epi8 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqb128_mask ((__v2di) __A,
+               (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtsepi64_epi8 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqb128_mask ((__v2di) __A,
+               (__v16qi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi64_storeu_epi8 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovsqb128mem_mask ((__v16qi *) __P, (__v2di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtsepi64_epi8 (__m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqb256_mask ((__v4di) __A,
+               (__v16qi)_mm_undefined_si128(),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi64_epi8 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqb256_mask ((__v4di) __A,
+               (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtsepi64_epi8 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqb256_mask ((__v4di) __A,
+               (__v16qi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi64_storeu_epi8 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovsqb256mem_mask ((__v16qi *) __P, (__v4di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtsepi64_epi32 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqd128_mask ((__v2di) __A,
+               (__v4si)_mm_undefined_si128(),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi64_epi32 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqd128_mask ((__v2di) __A,
+               (__v4si) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtsepi64_epi32 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqd128_mask ((__v2di) __A,
+               (__v4si) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi64_storeu_epi32 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovsqd128mem_mask ((__v4si *) __P, (__v2di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtsepi64_epi32 (__m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqd256_mask ((__v4di) __A,
+               (__v4si)_mm_undefined_si128(),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi64_epi32 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqd256_mask ((__v4di) __A,
+               (__v4si)__O,
+               __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtsepi64_epi32 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqd256_mask ((__v4di) __A,
+               (__v4si) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi64_storeu_epi32 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovsqd256mem_mask ((__v4si *) __P, (__v4di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtsepi64_epi16 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqw128_mask ((__v2di) __A,
+               (__v8hi)_mm_undefined_si128(),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi64_epi16 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqw128_mask ((__v2di) __A,
+               (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtsepi64_epi16 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqw128_mask ((__v2di) __A,
+               (__v8hi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtsepi64_storeu_epi16 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovsqw128mem_mask ((__v8hi *) __P, (__v2di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtsepi64_epi16 (__m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqw256_mask ((__v4di) __A,
+               (__v8hi)_mm_undefined_si128(),
+               (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi64_epi16 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqw256_mask ((__v4di) __A,
+               (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtsepi64_epi16 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovsqw256_mask ((__v4di) __A,
+               (__v8hi) _mm_setzero_si128 (),
+               __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtsepi64_storeu_epi16 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovsqw256mem_mask ((__v8hi *) __P, (__v4di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtusepi32_epi8 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdb128_mask ((__v4si) __A,
+                (__v16qi)_mm_undefined_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi32_epi8 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdb128_mask ((__v4si) __A,
+                (__v16qi) __O,
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtusepi32_epi8 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdb128_mask ((__v4si) __A,
+                (__v16qi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi32_storeu_epi8 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovusdb128mem_mask ((__v16qi *) __P, (__v4si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtusepi32_epi8 (__m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdb256_mask ((__v8si) __A,
+                (__v16qi)_mm_undefined_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi32_epi8 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdb256_mask ((__v8si) __A,
+                (__v16qi) __O,
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtusepi32_epi8 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdb256_mask ((__v8si) __A,
+                (__v16qi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi32_storeu_epi8 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovusdb256mem_mask ((__v16qi*) __P, (__v8si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtusepi32_epi16 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdw128_mask ((__v4si) __A,
+                (__v8hi)_mm_undefined_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi32_epi16 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdw128_mask ((__v4si) __A,
+                (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtusepi32_epi16 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdw128_mask ((__v4si) __A,
+                (__v8hi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi32_storeu_epi16 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovusdw128mem_mask ((__v8hi *) __P, (__v4si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtusepi32_epi16 (__m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdw256_mask ((__v8si) __A,
+                (__v8hi) _mm_undefined_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi32_epi16 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdw256_mask ((__v8si) __A,
+                (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtusepi32_epi16 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusdw256_mask ((__v8si) __A,
+                (__v8hi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi32_storeu_epi16 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovusdw256mem_mask ((__v8hi *) __P, (__v8si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtusepi64_epi8 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqb128_mask ((__v2di) __A,
+                (__v16qi)_mm_undefined_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi64_epi8 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqb128_mask ((__v2di) __A,
+                (__v16qi) __O,
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtusepi64_epi8 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqb128_mask ((__v2di) __A,
+                (__v16qi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi64_storeu_epi8 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovusqb128mem_mask ((__v16qi *) __P, (__v2di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtusepi64_epi8 (__m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqb256_mask ((__v4di) __A,
+                (__v16qi)_mm_undefined_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi64_epi8 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqb256_mask ((__v4di) __A,
+                (__v16qi) __O,
+                __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtusepi64_epi8 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqb256_mask ((__v4di) __A,
+                (__v16qi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi64_storeu_epi8 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovusqb256mem_mask ((__v16qi *) __P, (__v4di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtusepi64_epi32 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqd128_mask ((__v2di) __A,
+                (__v4si)_mm_undefined_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi64_epi32 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqd128_mask ((__v2di) __A,
+                (__v4si) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtusepi64_epi32 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqd128_mask ((__v2di) __A,
+                (__v4si) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi64_storeu_epi32 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovusqd128mem_mask ((__v4si *) __P, (__v2di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtusepi64_epi32 (__m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqd256_mask ((__v4di) __A,
+                (__v4si)_mm_undefined_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi64_epi32 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqd256_mask ((__v4di) __A,
+                (__v4si) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtusepi64_epi32 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqd256_mask ((__v4di) __A,
+                (__v4si) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi64_storeu_epi32 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovusqd256mem_mask ((__v4si *) __P, (__v4di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtusepi64_epi16 (__m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqw128_mask ((__v2di) __A,
+                (__v8hi)_mm_undefined_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi64_epi16 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqw128_mask ((__v2di) __A,
+                (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtusepi64_epi16 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqw128_mask ((__v2di) __A,
+                (__v8hi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtusepi64_storeu_epi16 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovusqw128mem_mask ((__v8hi *) __P, (__v2di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtusepi64_epi16 (__m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqw256_mask ((__v4di) __A,
+                (__v8hi)_mm_undefined_si128(),
+                (__mmask8) -1);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi64_epi16 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqw256_mask ((__v4di) __A,
+                (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtusepi64_epi16 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovusqw256_mask ((__v4di) __A,
+                (__v8hi) _mm_setzero_si128 (),
+                __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtusepi64_storeu_epi16 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovusqw256mem_mask ((__v8hi *) __P, (__v4di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtepi32_epi8 (__m128i __A)
+{
+  return (__m128i)__builtin_shufflevector(
+      __builtin_convertvector((__v4si)__A, __v4qi), (__v4qi){0, 0, 0, 0}, 0, 1,
+      2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi32_epi8 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdb128_mask ((__v4si) __A,
+              (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi32_epi8 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdb128_mask ((__v4si) __A,
+              (__v16qi)
+              _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi32_storeu_epi8 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovdb128mem_mask ((__v16qi *) __P, (__v4si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi32_epi8 (__m256i __A)
+{
+  return (__m128i)__builtin_shufflevector(
+      __builtin_convertvector((__v8si)__A, __v8qi),
+      (__v8qi){0, 0, 0, 0, 0, 0, 0, 0}, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+      12, 13, 14, 15);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi32_epi8 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdb256_mask ((__v8si) __A,
+              (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi32_epi8 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdb256_mask ((__v8si) __A,
+              (__v16qi) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi32_storeu_epi8 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovdb256mem_mask ((__v16qi *) __P, (__v8si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtepi32_epi16 (__m128i __A)
+{
+  return (__m128i)__builtin_shufflevector(
+      __builtin_convertvector((__v4si)__A, __v4hi), (__v4hi){0, 0, 0, 0}, 0, 1,
+      2, 3, 4, 5, 6, 7);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi32_epi16 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdw128_mask ((__v4si) __A,
+              (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi32_epi16 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdw128_mask ((__v4si) __A,
+              (__v8hi) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi32_storeu_epi16 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovdw128mem_mask ((__v8hi *) __P, (__v4si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi32_epi16 (__m256i __A)
+{
+  return (__m128i)__builtin_convertvector((__v8si)__A, __v8hi);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi32_epi16 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdw256_mask ((__v8si) __A,
+              (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi32_epi16 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovdw256_mask ((__v8si) __A,
+              (__v8hi) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi32_storeu_epi16 (void *  __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovdw256mem_mask ((__v8hi *) __P, (__v8si) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtepi64_epi8 (__m128i __A)
+{
+  return (__m128i)__builtin_shufflevector(
+      __builtin_convertvector((__v2di)__A, __v2qi), (__v2qi){0, 0}, 0, 1, 2, 3,
+      3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi64_epi8 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqb128_mask ((__v2di) __A,
+              (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi64_epi8 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqb128_mask ((__v2di) __A,
+              (__v16qi) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi64_storeu_epi8 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovqb128mem_mask ((__v16qi *) __P, (__v2di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi64_epi8 (__m256i __A)
+{
+  return (__m128i)__builtin_shufflevector(
+      __builtin_convertvector((__v4di)__A, __v4qi), (__v4qi){0, 0, 0, 0}, 0, 1,
+      2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi64_epi8 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqb256_mask ((__v4di) __A,
+              (__v16qi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi64_epi8 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqb256_mask ((__v4di) __A,
+              (__v16qi) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi64_storeu_epi8 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovqb256mem_mask ((__v16qi *) __P, (__v4di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtepi64_epi32 (__m128i __A)
+{
+  return (__m128i)__builtin_shufflevector(
+      __builtin_convertvector((__v2di)__A, __v2si), (__v2si){0, 0}, 0, 1, 2, 3);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi64_epi32 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqd128_mask ((__v2di) __A,
+              (__v4si) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi64_epi32 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqd128_mask ((__v2di) __A,
+              (__v4si) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi64_storeu_epi32 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovqd128mem_mask ((__v4si *) __P, (__v2di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi64_epi32 (__m256i __A)
+{
+  return (__m128i)__builtin_convertvector((__v4di)__A, __v4si);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi64_epi32 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm256_cvtepi64_epi32(__A),
+                                             (__v4si)__O);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi64_epi32 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i)__builtin_ia32_selectd_128((__mmask8)__M,
+                                             (__v4si)_mm256_cvtepi64_epi32(__A),
+                                             (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi64_storeu_epi32 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovqd256mem_mask ((__v4si *) __P, (__v4di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_cvtepi64_epi16 (__m128i __A)
+{
+  return (__m128i)__builtin_shufflevector(
+      __builtin_convertvector((__v2di)__A, __v2hi), (__v2hi){0, 0}, 0, 1, 2, 3,
+      3, 3, 3, 3);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi64_epi16 (__m128i __O, __mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqw128_mask ((__v2di) __A,
+              (__v8hi)__O,
+              __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtepi64_epi16 (__mmask8 __M, __m128i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqw128_mask ((__v2di) __A,
+              (__v8hi) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_cvtepi64_storeu_epi16 (void * __P, __mmask8 __M, __m128i __A)
+{
+  __builtin_ia32_pmovqw128mem_mask ((__v8hi *) __P, (__v2di) __A, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_cvtepi64_epi16 (__m256i __A)
+{
+  return (__m128i)__builtin_shufflevector(
+      __builtin_convertvector((__v4di)__A, __v4hi), (__v4hi){0, 0, 0, 0}, 0, 1,
+      2, 3, 4, 5, 6, 7);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi64_epi16 (__m128i __O, __mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqw256_mask ((__v4di) __A,
+              (__v8hi) __O, __M);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtepi64_epi16 (__mmask8 __M, __m256i __A)
+{
+  return (__m128i) __builtin_ia32_pmovqw256_mask ((__v4di) __A,
+              (__v8hi) _mm_setzero_si128 (),
+              __M);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtepi64_storeu_epi16 (void * __P, __mmask8 __M, __m256i __A)
+{
+  __builtin_ia32_pmovqw256mem_mask ((__v8hi *) __P, (__v4di) __A, __M);
+}
+
+#define _mm256_extractf32x4_ps(A, imm) \
+  ((__m128)__builtin_ia32_extractf32x4_256_mask((__v8sf)(__m256)(A), \
+                                                (int)(imm), \
+                                                (__v4sf)_mm_undefined_ps(), \
+                                                (__mmask8)-1))
+
+#define _mm256_mask_extractf32x4_ps(W, U, A, imm) \
+  ((__m128)__builtin_ia32_extractf32x4_256_mask((__v8sf)(__m256)(A), \
+                                                (int)(imm), \
+                                                (__v4sf)(__m128)(W), \
+                                                (__mmask8)(U)))
+
+#define _mm256_maskz_extractf32x4_ps(U, A, imm) \
+  ((__m128)__builtin_ia32_extractf32x4_256_mask((__v8sf)(__m256)(A), \
+                                                (int)(imm), \
+                                                (__v4sf)_mm_setzero_ps(), \
+                                                (__mmask8)(U)))
+
+#define _mm256_extracti32x4_epi32(A, imm) \
+  ((__m128i)__builtin_ia32_extracti32x4_256_mask((__v8si)(__m256i)(A), \
+                                                 (int)(imm), \
+                                                 (__v4si)_mm_undefined_si128(), \
+                                                 (__mmask8)-1))
+
+#define _mm256_mask_extracti32x4_epi32(W, U, A, imm) \
+  ((__m128i)__builtin_ia32_extracti32x4_256_mask((__v8si)(__m256i)(A), \
+                                                 (int)(imm), \
+                                                 (__v4si)(__m128i)(W), \
+                                                 (__mmask8)(U)))
+
+#define _mm256_maskz_extracti32x4_epi32(U, A, imm) \
+  ((__m128i)__builtin_ia32_extracti32x4_256_mask((__v8si)(__m256i)(A), \
+                                                 (int)(imm), \
+                                                 (__v4si)_mm_setzero_si128(), \
+                                                 (__mmask8)(U)))
+
+#define _mm256_insertf32x4(A, B, imm) \
+  ((__m256)__builtin_ia32_insertf32x4_256((__v8sf)(__m256)(A), \
+                                          (__v4sf)(__m128)(B), (int)(imm)))
+
+#define _mm256_mask_insertf32x4(W, U, A, B, imm) \
+  ((__m256)__builtin_ia32_selectps_256((__mmask8)(U), \
+                                  (__v8sf)_mm256_insertf32x4((A), (B), (imm)), \
+                                  (__v8sf)(__m256)(W)))
+
+#define _mm256_maskz_insertf32x4(U, A, B, imm) \
+  ((__m256)__builtin_ia32_selectps_256((__mmask8)(U), \
+                                  (__v8sf)_mm256_insertf32x4((A), (B), (imm)), \
+                                  (__v8sf)_mm256_setzero_ps()))
+
+#define _mm256_inserti32x4(A, B, imm) \
+  ((__m256i)__builtin_ia32_inserti32x4_256((__v8si)(__m256i)(A), \
+                                           (__v4si)(__m128i)(B), (int)(imm)))
+
+#define _mm256_mask_inserti32x4(W, U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                  (__v8si)_mm256_inserti32x4((A), (B), (imm)), \
+                                  (__v8si)(__m256i)(W)))
+
+#define _mm256_maskz_inserti32x4(U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                  (__v8si)_mm256_inserti32x4((A), (B), (imm)), \
+                                  (__v8si)_mm256_setzero_si256()))
+
+#define _mm_getmant_pd(A, B, C) \
+  ((__m128d)__builtin_ia32_getmantpd128_mask((__v2df)(__m128d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v2df)_mm_setzero_pd(), \
+                                             (__mmask8)-1))
+
+#define _mm_mask_getmant_pd(W, U, A, B, C) \
+  ((__m128d)__builtin_ia32_getmantpd128_mask((__v2df)(__m128d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v2df)(__m128d)(W), \
+                                             (__mmask8)(U)))
+
+#define _mm_maskz_getmant_pd(U, A, B, C) \
+  ((__m128d)__builtin_ia32_getmantpd128_mask((__v2df)(__m128d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v2df)_mm_setzero_pd(), \
+                                             (__mmask8)(U)))
+
+#define _mm256_getmant_pd(A, B, C) \
+  ((__m256d)__builtin_ia32_getmantpd256_mask((__v4df)(__m256d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v4df)_mm256_setzero_pd(), \
+                                             (__mmask8)-1))
+
+#define _mm256_mask_getmant_pd(W, U, A, B, C) \
+  ((__m256d)__builtin_ia32_getmantpd256_mask((__v4df)(__m256d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v4df)(__m256d)(W), \
+                                             (__mmask8)(U)))
+
+#define _mm256_maskz_getmant_pd(U, A, B, C) \
+  ((__m256d)__builtin_ia32_getmantpd256_mask((__v4df)(__m256d)(A), \
+                                             (int)(((C)<<2) | (B)), \
+                                             (__v4df)_mm256_setzero_pd(), \
+                                             (__mmask8)(U)))
+
+#define _mm_getmant_ps(A, B, C) \
+  ((__m128)__builtin_ia32_getmantps128_mask((__v4sf)(__m128)(A), \
+                                            (int)(((C)<<2) | (B)), \
+                                            (__v4sf)_mm_setzero_ps(), \
+                                            (__mmask8)-1))
+
+#define _mm_mask_getmant_ps(W, U, A, B, C) \
+  ((__m128)__builtin_ia32_getmantps128_mask((__v4sf)(__m128)(A), \
+                                            (int)(((C)<<2) | (B)), \
+                                            (__v4sf)(__m128)(W), \
+                                            (__mmask8)(U)))
+
+#define _mm_maskz_getmant_ps(U, A, B, C) \
+  ((__m128)__builtin_ia32_getmantps128_mask((__v4sf)(__m128)(A), \
+                                            (int)(((C)<<2) | (B)), \
+                                            (__v4sf)_mm_setzero_ps(), \
+                                            (__mmask8)(U)))
+
+#define _mm256_getmant_ps(A, B, C) \
+  ((__m256)__builtin_ia32_getmantps256_mask((__v8sf)(__m256)(A), \
+                                            (int)(((C)<<2) | (B)), \
+                                            (__v8sf)_mm256_setzero_ps(), \
+                                            (__mmask8)-1))
+
+#define _mm256_mask_getmant_ps(W, U, A, B, C) \
+  ((__m256)__builtin_ia32_getmantps256_mask((__v8sf)(__m256)(A), \
+                                            (int)(((C)<<2) | (B)), \
+                                            (__v8sf)(__m256)(W), \
+                                            (__mmask8)(U)))
+
+#define _mm256_maskz_getmant_ps(U, A, B, C) \
+  ((__m256)__builtin_ia32_getmantps256_mask((__v8sf)(__m256)(A), \
+                                            (int)(((C)<<2) | (B)), \
+                                            (__v8sf)_mm256_setzero_ps(), \
+                                            (__mmask8)(U)))
+
+#define _mm_mmask_i64gather_pd(v1_old, mask, index, addr, scale) \
+  ((__m128d)__builtin_ia32_gather3div2df((__v2df)(__m128d)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v2di)(__m128i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm_mmask_i64gather_epi64(v1_old, mask, index, addr, scale) \
+  ((__m128i)__builtin_ia32_gather3div2di((__v2di)(__m128i)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v2di)(__m128i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm256_mmask_i64gather_pd(v1_old, mask, index, addr, scale) \
+  ((__m256d)__builtin_ia32_gather3div4df((__v4df)(__m256d)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v4di)(__m256i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm256_mmask_i64gather_epi64(v1_old, mask, index, addr, scale) \
+  ((__m256i)__builtin_ia32_gather3div4di((__v4di)(__m256i)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v4di)(__m256i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm_mmask_i64gather_ps(v1_old, mask, index, addr, scale) \
+  ((__m128)__builtin_ia32_gather3div4sf((__v4sf)(__m128)(v1_old), \
+                                        (void const *)(addr), \
+                                        (__v2di)(__m128i)(index), \
+                                        (__mmask8)(mask), (int)(scale)))
+
+#define _mm_mmask_i64gather_epi32(v1_old, mask, index, addr, scale) \
+  ((__m128i)__builtin_ia32_gather3div4si((__v4si)(__m128i)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v2di)(__m128i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm256_mmask_i64gather_ps(v1_old, mask, index, addr, scale) \
+  ((__m128)__builtin_ia32_gather3div8sf((__v4sf)(__m128)(v1_old), \
+                                        (void const *)(addr), \
+                                        (__v4di)(__m256i)(index), \
+                                        (__mmask8)(mask), (int)(scale)))
+
+#define _mm256_mmask_i64gather_epi32(v1_old, mask, index, addr, scale) \
+  ((__m128i)__builtin_ia32_gather3div8si((__v4si)(__m128i)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v4di)(__m256i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm_mmask_i32gather_pd(v1_old, mask, index, addr, scale) \
+  ((__m128d)__builtin_ia32_gather3siv2df((__v2df)(__m128d)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v4si)(__m128i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm_mmask_i32gather_epi64(v1_old, mask, index, addr, scale) \
+  ((__m128i)__builtin_ia32_gather3siv2di((__v2di)(__m128i)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v4si)(__m128i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm256_mmask_i32gather_pd(v1_old, mask, index, addr, scale) \
+  ((__m256d)__builtin_ia32_gather3siv4df((__v4df)(__m256d)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v4si)(__m128i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm256_mmask_i32gather_epi64(v1_old, mask, index, addr, scale) \
+  ((__m256i)__builtin_ia32_gather3siv4di((__v4di)(__m256i)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v4si)(__m128i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm_mmask_i32gather_ps(v1_old, mask, index, addr, scale) \
+  ((__m128)__builtin_ia32_gather3siv4sf((__v4sf)(__m128)(v1_old), \
+                                        (void const *)(addr), \
+                                        (__v4si)(__m128i)(index), \
+                                        (__mmask8)(mask), (int)(scale)))
+
+#define _mm_mmask_i32gather_epi32(v1_old, mask, index, addr, scale) \
+  ((__m128i)__builtin_ia32_gather3siv4si((__v4si)(__m128i)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v4si)(__m128i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm256_mmask_i32gather_ps(v1_old, mask, index, addr, scale) \
+  ((__m256)__builtin_ia32_gather3siv8sf((__v8sf)(__m256)(v1_old), \
+                                        (void const *)(addr), \
+                                        (__v8si)(__m256i)(index), \
+                                        (__mmask8)(mask), (int)(scale)))
+
+#define _mm256_mmask_i32gather_epi32(v1_old, mask, index, addr, scale) \
+  ((__m256i)__builtin_ia32_gather3siv8si((__v8si)(__m256i)(v1_old), \
+                                         (void const *)(addr), \
+                                         (__v8si)(__m256i)(index), \
+                                         (__mmask8)(mask), (int)(scale)))
+
+#define _mm256_permutex_pd(X, C) \
+  ((__m256d)__builtin_ia32_permdf256((__v4df)(__m256d)(X), (int)(C)))
+
+#define _mm256_mask_permutex_pd(W, U, X, C) \
+  ((__m256d)__builtin_ia32_selectpd_256((__mmask8)(U), \
+                                       (__v4df)_mm256_permutex_pd((X), (C)), \
+                                       (__v4df)(__m256d)(W)))
+
+#define _mm256_maskz_permutex_pd(U, X, C) \
+  ((__m256d)__builtin_ia32_selectpd_256((__mmask8)(U), \
+                                        (__v4df)_mm256_permutex_pd((X), (C)), \
+                                        (__v4df)_mm256_setzero_pd()))
+
+#define _mm256_permutex_epi64(X, C) \
+  ((__m256i)__builtin_ia32_permdi256((__v4di)(__m256i)(X), (int)(C)))
+
+#define _mm256_mask_permutex_epi64(W, U, X, C) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                      (__v4di)_mm256_permutex_epi64((X), (C)), \
+                                      (__v4di)(__m256i)(W)))
+
+#define _mm256_maskz_permutex_epi64(U, X, C) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                      (__v4di)_mm256_permutex_epi64((X), (C)), \
+                                      (__v4di)_mm256_setzero_si256()))
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_permutexvar_pd (__m256i __X, __m256d __Y)
+{
+  return (__m256d)__builtin_ia32_permvardf256((__v4df)__Y, (__v4di)__X);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_permutexvar_pd (__m256d __W, __mmask8 __U, __m256i __X,
+          __m256d __Y)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                        (__v4df)_mm256_permutexvar_pd(__X, __Y),
+                                        (__v4df)__W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_permutexvar_pd (__mmask8 __U, __m256i __X, __m256d __Y)
+{
+  return (__m256d)__builtin_ia32_selectpd_256((__mmask8)__U,
+                                        (__v4df)_mm256_permutexvar_pd(__X, __Y),
+                                        (__v4df)_mm256_setzero_pd());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_permutexvar_epi64 ( __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_permvardi256((__v4di) __Y, (__v4di) __X);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_permutexvar_epi64 (__mmask8 __M, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                     (__v4di)_mm256_permutexvar_epi64(__X, __Y),
+                                     (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_permutexvar_epi64 (__m256i __W, __mmask8 __M, __m256i __X,
+             __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectq_256((__mmask8)__M,
+                                     (__v4di)_mm256_permutexvar_epi64(__X, __Y),
+                                     (__v4di)__W);
+}
+
+#define _mm256_permutexvar_ps(A, B) _mm256_permutevar8x32_ps((B), (A))
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_permutexvar_ps(__m256 __W, __mmask8 __U, __m256i __X, __m256 __Y)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                        (__v8sf)_mm256_permutexvar_ps(__X, __Y),
+                                        (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_permutexvar_ps(__mmask8 __U, __m256i __X, __m256 __Y)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                        (__v8sf)_mm256_permutexvar_ps(__X, __Y),
+                                        (__v8sf)_mm256_setzero_ps());
+}
+
+#define _mm256_permutexvar_epi32(A, B) _mm256_permutevar8x32_epi32((B), (A))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_permutexvar_epi32(__m256i __W, __mmask8 __M, __m256i __X,
+                              __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                     (__v8si)_mm256_permutexvar_epi32(__X, __Y),
+                                     (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_permutexvar_epi32(__mmask8 __M, __m256i __X, __m256i __Y)
+{
+  return (__m256i)__builtin_ia32_selectd_256((__mmask8)__M,
+                                     (__v8si)_mm256_permutexvar_epi32(__X, __Y),
+                                     (__v8si)_mm256_setzero_si256());
+}
+
+#define _mm_alignr_epi32(A, B, imm) \
+  ((__m128i)__builtin_ia32_alignd128((__v4si)(__m128i)(A), \
+                                     (__v4si)(__m128i)(B), (int)(imm)))
+
+#define _mm_mask_alignr_epi32(W, U, A, B, imm) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(U), \
+                                    (__v4si)_mm_alignr_epi32((A), (B), (imm)), \
+                                    (__v4si)(__m128i)(W)))
+
+#define _mm_maskz_alignr_epi32(U, A, B, imm) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(U), \
+                                    (__v4si)_mm_alignr_epi32((A), (B), (imm)), \
+                                    (__v4si)_mm_setzero_si128()))
+
+#define _mm256_alignr_epi32(A, B, imm) \
+  ((__m256i)__builtin_ia32_alignd256((__v8si)(__m256i)(A), \
+                                     (__v8si)(__m256i)(B), (int)(imm)))
+
+#define _mm256_mask_alignr_epi32(W, U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                 (__v8si)_mm256_alignr_epi32((A), (B), (imm)), \
+                                 (__v8si)(__m256i)(W)))
+
+#define _mm256_maskz_alignr_epi32(U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                 (__v8si)_mm256_alignr_epi32((A), (B), (imm)), \
+                                 (__v8si)_mm256_setzero_si256()))
+
+#define _mm_alignr_epi64(A, B, imm) \
+  ((__m128i)__builtin_ia32_alignq128((__v2di)(__m128i)(A), \
+                                     (__v2di)(__m128i)(B), (int)(imm)))
+
+#define _mm_mask_alignr_epi64(W, U, A, B, imm) \
+  ((__m128i)__builtin_ia32_selectq_128((__mmask8)(U), \
+                                    (__v2di)_mm_alignr_epi64((A), (B), (imm)), \
+                                    (__v2di)(__m128i)(W)))
+
+#define _mm_maskz_alignr_epi64(U, A, B, imm) \
+  ((__m128i)__builtin_ia32_selectq_128((__mmask8)(U), \
+                                    (__v2di)_mm_alignr_epi64((A), (B), (imm)), \
+                                    (__v2di)_mm_setzero_si128()))
+
+#define _mm256_alignr_epi64(A, B, imm) \
+  ((__m256i)__builtin_ia32_alignq256((__v4di)(__m256i)(A), \
+                                     (__v4di)(__m256i)(B), (int)(imm)))
+
+#define _mm256_mask_alignr_epi64(W, U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                 (__v4di)_mm256_alignr_epi64((A), (B), (imm)), \
+                                 (__v4di)(__m256i)(W)))
+
+#define _mm256_maskz_alignr_epi64(U, A, B, imm) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                 (__v4di)_mm256_alignr_epi64((A), (B), (imm)), \
+                                 (__v4di)_mm256_setzero_si256()))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_movehdup_ps (__m128 __W, __mmask8 __U, __m128 __A)
+{
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_movehdup_ps(__A),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_movehdup_ps (__mmask8 __U, __m128 __A)
+{
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_movehdup_ps(__A),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_movehdup_ps (__m256 __W, __mmask8 __U, __m256 __A)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_movehdup_ps(__A),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_movehdup_ps (__mmask8 __U, __m256 __A)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_movehdup_ps(__A),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_moveldup_ps (__m128 __W, __mmask8 __U, __m128 __A)
+{
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_moveldup_ps(__A),
+                                             (__v4sf)__W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_moveldup_ps (__mmask8 __U, __m128 __A)
+{
+  return (__m128)__builtin_ia32_selectps_128((__mmask8)__U,
+                                             (__v4sf)_mm_moveldup_ps(__A),
+                                             (__v4sf)_mm_setzero_ps());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_moveldup_ps (__m256 __W, __mmask8 __U, __m256 __A)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_moveldup_ps(__A),
+                                             (__v8sf)__W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_moveldup_ps (__mmask8 __U, __m256 __A)
+{
+  return (__m256)__builtin_ia32_selectps_256((__mmask8)__U,
+                                             (__v8sf)_mm256_moveldup_ps(__A),
+                                             (__v8sf)_mm256_setzero_ps());
+}
+
+#define _mm256_mask_shuffle_epi32(W, U, A, I) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                       (__v8si)_mm256_shuffle_epi32((A), (I)), \
+                                       (__v8si)(__m256i)(W)))
+
+#define _mm256_maskz_shuffle_epi32(U, A, I) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                       (__v8si)_mm256_shuffle_epi32((A), (I)), \
+                                       (__v8si)_mm256_setzero_si256()))
+
+#define _mm_mask_shuffle_epi32(W, U, A, I) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(U), \
+                                       (__v4si)_mm_shuffle_epi32((A), (I)), \
+                                       (__v4si)(__m128i)(W)))
+
+#define _mm_maskz_shuffle_epi32(U, A, I) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(U), \
+                                       (__v4si)_mm_shuffle_epi32((A), (I)), \
+                                       (__v4si)_mm_setzero_si128()))
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_mask_mov_pd (__m128d __W, __mmask8 __U, __m128d __A)
+{
+  return (__m128d) __builtin_ia32_selectpd_128 ((__mmask8) __U,
+              (__v2df) __A,
+              (__v2df) __W);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maskz_mov_pd (__mmask8 __U, __m128d __A)
+{
+  return (__m128d) __builtin_ia32_selectpd_128 ((__mmask8) __U,
+              (__v2df) __A,
+              (__v2df) _mm_setzero_pd ());
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_mask_mov_pd (__m256d __W, __mmask8 __U, __m256d __A)
+{
+  return (__m256d) __builtin_ia32_selectpd_256 ((__mmask8) __U,
+              (__v4df) __A,
+              (__v4df) __W);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maskz_mov_pd (__mmask8 __U, __m256d __A)
+{
+  return (__m256d) __builtin_ia32_selectpd_256 ((__mmask8) __U,
+              (__v4df) __A,
+              (__v4df) _mm256_setzero_pd ());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_mov_ps (__m128 __W, __mmask8 __U, __m128 __A)
+{
+  return (__m128) __builtin_ia32_selectps_128 ((__mmask8) __U,
+             (__v4sf) __A,
+             (__v4sf) __W);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_mov_ps (__mmask8 __U, __m128 __A)
+{
+  return (__m128) __builtin_ia32_selectps_128 ((__mmask8) __U,
+             (__v4sf) __A,
+             (__v4sf) _mm_setzero_ps ());
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_mov_ps (__m256 __W, __mmask8 __U, __m256 __A)
+{
+  return (__m256) __builtin_ia32_selectps_256 ((__mmask8) __U,
+             (__v8sf) __A,
+             (__v8sf) __W);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_mov_ps (__mmask8 __U, __m256 __A)
+{
+  return (__m256) __builtin_ia32_selectps_256 ((__mmask8) __U,
+             (__v8sf) __A,
+             (__v8sf) _mm256_setzero_ps ());
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_mask_cvtph_ps (__m128 __W, __mmask8 __U, __m128i __A)
+{
+  return (__m128) __builtin_ia32_vcvtph2ps_mask ((__v8hi) __A,
+             (__v4sf) __W,
+             (__mmask8) __U);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtph_ps (__mmask8 __U, __m128i __A)
+{
+  return (__m128) __builtin_ia32_vcvtph2ps_mask ((__v8hi) __A,
+             (__v4sf)
+             _mm_setzero_ps (),
+             (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_mask_cvtph_ps (__m256 __W, __mmask8 __U, __m128i __A)
+{
+  return (__m256) __builtin_ia32_vcvtph2ps256_mask ((__v8hi) __A,
+                (__v8sf) __W,
+                (__mmask8) __U);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maskz_cvtph_ps (__mmask8 __U, __m128i __A)
+{
+  return (__m256) __builtin_ia32_vcvtph2ps256_mask ((__v8hi) __A,
+                (__v8sf)
+                _mm256_setzero_ps (),
+                (__mmask8) __U);
+}
+
+#define _mm_mask_cvt_roundps_ph(W, U, A, I) \
+  ((__m128i)__builtin_ia32_vcvtps2ph_mask((__v4sf)(__m128)(A), (int)(I), \
+                                          (__v8hi)(__m128i)(W), \
+                                          (__mmask8)(U)))
+
+#define _mm_maskz_cvt_roundps_ph(U, A, I) \
+  ((__m128i)__builtin_ia32_vcvtps2ph_mask((__v4sf)(__m128)(A), (int)(I), \
+                                          (__v8hi)_mm_setzero_si128(), \
+                                          (__mmask8)(U)))
+
+#define _mm_mask_cvtps_ph  _mm_mask_cvt_roundps_ph
+#define _mm_maskz_cvtps_ph _mm_maskz_cvt_roundps_ph
+
+#define _mm256_mask_cvt_roundps_ph(W, U, A, I) \
+  ((__m128i)__builtin_ia32_vcvtps2ph256_mask((__v8sf)(__m256)(A), (int)(I), \
+                                             (__v8hi)(__m128i)(W), \
+                                             (__mmask8)(U)))
+
+#define _mm256_maskz_cvt_roundps_ph(U, A, I) \
+  ((__m128i)__builtin_ia32_vcvtps2ph256_mask((__v8sf)(__m256)(A), (int)(I), \
+                                             (__v8hi)_mm_setzero_si128(), \
+                                             (__mmask8)(U)))
+
+#define _mm256_mask_cvtps_ph  _mm256_mask_cvt_roundps_ph
+#define _mm256_maskz_cvtps_ph _mm256_maskz_cvt_roundps_ph
+
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif /* __AVX512VLINTRIN_H */
diff --git a/third_party/intel/clang/avx512vlvbmi2intrin.h b/third_party/intel/clang/avx512vlvbmi2intrin.h
new file mode 100644
index 000000000..77af2d5cb
--- /dev/null
+++ b/third_party/intel/clang/avx512vlvbmi2intrin.h
@@ -0,0 +1,695 @@
+/*===------------- avx512vlvbmi2intrin.h - VBMI2 intrinsics -----------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vlvbmi2intrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VLVBMI2INTRIN_H
+#define __AVX512VLVBMI2INTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512vbmi2,no-evex512"),                \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512vbmi2,no-evex512"),                \
+                 __min_vector_width__(256)))
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_compress_epi16(__m128i __S, __mmask8 __U, __m128i __D)
+{
+  return (__m128i) __builtin_ia32_compresshi128_mask ((__v8hi) __D,
+              (__v8hi) __S,
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_compress_epi16(__mmask8 __U, __m128i __D)
+{
+  return (__m128i) __builtin_ia32_compresshi128_mask ((__v8hi) __D,
+              (__v8hi) _mm_setzero_si128(),
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_compress_epi8(__m128i __S, __mmask16 __U, __m128i __D)
+{
+  return (__m128i) __builtin_ia32_compressqi128_mask ((__v16qi) __D,
+              (__v16qi) __S,
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_compress_epi8(__mmask16 __U, __m128i __D)
+{
+  return (__m128i) __builtin_ia32_compressqi128_mask ((__v16qi) __D,
+              (__v16qi) _mm_setzero_si128(),
+              __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_compressstoreu_epi16(void *__P, __mmask8 __U, __m128i __D)
+{
+  __builtin_ia32_compressstorehi128_mask ((__v8hi *) __P, (__v8hi) __D,
+              __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_mask_compressstoreu_epi8(void *__P, __mmask16 __U, __m128i __D)
+{
+  __builtin_ia32_compressstoreqi128_mask ((__v16qi *) __P, (__v16qi) __D,
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_expand_epi16(__m128i __S, __mmask8 __U, __m128i __D)
+{
+  return (__m128i) __builtin_ia32_expandhi128_mask ((__v8hi) __D,
+              (__v8hi) __S,
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_expand_epi16(__mmask8 __U, __m128i __D)
+{
+  return (__m128i) __builtin_ia32_expandhi128_mask ((__v8hi) __D,
+              (__v8hi) _mm_setzero_si128(),
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_expand_epi8(__m128i __S, __mmask16 __U, __m128i __D)
+{
+  return (__m128i) __builtin_ia32_expandqi128_mask ((__v16qi) __D,
+              (__v16qi) __S,
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_expand_epi8(__mmask16 __U, __m128i __D)
+{
+  return (__m128i) __builtin_ia32_expandqi128_mask ((__v16qi) __D,
+              (__v16qi) _mm_setzero_si128(),
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_expandloadu_epi16(__m128i __S, __mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_expandloadhi128_mask ((const __v8hi *)__P,
+              (__v8hi) __S,
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_expandloadu_epi16(__mmask8 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_expandloadhi128_mask ((const __v8hi *)__P,
+              (__v8hi) _mm_setzero_si128(),
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_expandloadu_epi8(__m128i __S, __mmask16 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_expandloadqi128_mask ((const __v16qi *)__P,
+              (__v16qi) __S,
+              __U);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_expandloadu_epi8(__mmask16 __U, void const *__P)
+{
+  return (__m128i) __builtin_ia32_expandloadqi128_mask ((const __v16qi *)__P,
+              (__v16qi) _mm_setzero_si128(),
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_compress_epi16(__m256i __S, __mmask16 __U, __m256i __D)
+{
+  return (__m256i) __builtin_ia32_compresshi256_mask ((__v16hi) __D,
+              (__v16hi) __S,
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_compress_epi16(__mmask16 __U, __m256i __D)
+{
+  return (__m256i) __builtin_ia32_compresshi256_mask ((__v16hi) __D,
+              (__v16hi) _mm256_setzero_si256(),
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_compress_epi8(__m256i __S, __mmask32 __U, __m256i __D)
+{
+  return (__m256i) __builtin_ia32_compressqi256_mask ((__v32qi) __D,
+              (__v32qi) __S,
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_compress_epi8(__mmask32 __U, __m256i __D)
+{
+  return (__m256i) __builtin_ia32_compressqi256_mask ((__v32qi) __D,
+              (__v32qi) _mm256_setzero_si256(),
+              __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_compressstoreu_epi16(void *__P, __mmask16 __U, __m256i __D)
+{
+  __builtin_ia32_compressstorehi256_mask ((__v16hi *) __P, (__v16hi) __D,
+              __U);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_mask_compressstoreu_epi8(void *__P, __mmask32 __U, __m256i __D)
+{
+  __builtin_ia32_compressstoreqi256_mask ((__v32qi *) __P, (__v32qi) __D,
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_expand_epi16(__m256i __S, __mmask16 __U, __m256i __D)
+{
+  return (__m256i) __builtin_ia32_expandhi256_mask ((__v16hi) __D,
+              (__v16hi) __S,
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_expand_epi16(__mmask16 __U, __m256i __D)
+{
+  return (__m256i) __builtin_ia32_expandhi256_mask ((__v16hi) __D,
+              (__v16hi) _mm256_setzero_si256(),
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_expand_epi8(__m256i __S, __mmask32 __U, __m256i __D)
+{
+  return (__m256i) __builtin_ia32_expandqi256_mask ((__v32qi) __D,
+              (__v32qi) __S,
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_expand_epi8(__mmask32 __U, __m256i __D)
+{
+  return (__m256i) __builtin_ia32_expandqi256_mask ((__v32qi) __D,
+              (__v32qi) _mm256_setzero_si256(),
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_expandloadu_epi16(__m256i __S, __mmask16 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_expandloadhi256_mask ((const __v16hi *)__P,
+              (__v16hi) __S,
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_expandloadu_epi16(__mmask16 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_expandloadhi256_mask ((const __v16hi *)__P,
+              (__v16hi) _mm256_setzero_si256(),
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_expandloadu_epi8(__m256i __S, __mmask32 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_expandloadqi256_mask ((const __v32qi *)__P,
+              (__v32qi) __S,
+              __U);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_expandloadu_epi8(__mmask32 __U, void const *__P)
+{
+  return (__m256i) __builtin_ia32_expandloadqi256_mask ((const __v32qi *)__P,
+              (__v32qi) _mm256_setzero_si256(),
+              __U);
+}
+
+#define _mm256_shldi_epi64(A, B, I) \
+  ((__m256i)__builtin_ia32_vpshldq256((__v4di)(__m256i)(A), \
+                                      (__v4di)(__m256i)(B), (int)(I)))
+
+#define _mm256_mask_shldi_epi64(S, U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                     (__v4di)_mm256_shldi_epi64((A), (B), (I)), \
+                                     (__v4di)(__m256i)(S)))
+
+#define _mm256_maskz_shldi_epi64(U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                     (__v4di)_mm256_shldi_epi64((A), (B), (I)), \
+                                     (__v4di)_mm256_setzero_si256()))
+
+#define _mm_shldi_epi64(A, B, I) \
+  ((__m128i)__builtin_ia32_vpshldq128((__v2di)(__m128i)(A), \
+                                      (__v2di)(__m128i)(B), (int)(I)))
+
+#define _mm_mask_shldi_epi64(S, U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectq_128((__mmask8)(U), \
+                                       (__v2di)_mm_shldi_epi64((A), (B), (I)), \
+                                       (__v2di)(__m128i)(S)))
+
+#define _mm_maskz_shldi_epi64(U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectq_128((__mmask8)(U), \
+                                       (__v2di)_mm_shldi_epi64((A), (B), (I)), \
+                                       (__v2di)_mm_setzero_si128()))
+
+#define _mm256_shldi_epi32(A, B, I) \
+  ((__m256i)__builtin_ia32_vpshldd256((__v8si)(__m256i)(A), \
+                                      (__v8si)(__m256i)(B), (int)(I)))
+
+#define _mm256_mask_shldi_epi32(S, U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                     (__v8si)_mm256_shldi_epi32((A), (B), (I)), \
+                                     (__v8si)(__m256i)(S)))
+
+#define _mm256_maskz_shldi_epi32(U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                     (__v8si)_mm256_shldi_epi32((A), (B), (I)), \
+                                     (__v8si)_mm256_setzero_si256()))
+
+#define _mm_shldi_epi32(A, B, I) \
+  ((__m128i)__builtin_ia32_vpshldd128((__v4si)(__m128i)(A), \
+                                      (__v4si)(__m128i)(B), (int)(I)))
+
+#define _mm_mask_shldi_epi32(S, U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(U), \
+                                       (__v4si)_mm_shldi_epi32((A), (B), (I)), \
+                                       (__v4si)(__m128i)(S)))
+
+#define _mm_maskz_shldi_epi32(U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(U), \
+                                       (__v4si)_mm_shldi_epi32((A), (B), (I)), \
+                                       (__v4si)_mm_setzero_si128()))
+
+#define _mm256_shldi_epi16(A, B, I) \
+  ((__m256i)__builtin_ia32_vpshldw256((__v16hi)(__m256i)(A), \
+                                      (__v16hi)(__m256i)(B), (int)(I)))
+
+#define _mm256_mask_shldi_epi16(S, U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectw_256((__mmask16)(U), \
+                                    (__v16hi)_mm256_shldi_epi16((A), (B), (I)), \
+                                    (__v16hi)(__m256i)(S)))
+
+#define _mm256_maskz_shldi_epi16(U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectw_256((__mmask16)(U), \
+                                    (__v16hi)_mm256_shldi_epi16((A), (B), (I)), \
+                                    (__v16hi)_mm256_setzero_si256()))
+
+#define _mm_shldi_epi16(A, B, I) \
+  ((__m128i)__builtin_ia32_vpshldw128((__v8hi)(__m128i)(A), \
+                                      (__v8hi)(__m128i)(B), (int)(I)))
+
+#define _mm_mask_shldi_epi16(S, U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectw_128((__mmask8)(U), \
+                                       (__v8hi)_mm_shldi_epi16((A), (B), (I)), \
+                                       (__v8hi)(__m128i)(S)))
+
+#define _mm_maskz_shldi_epi16(U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectw_128((__mmask8)(U), \
+                                       (__v8hi)_mm_shldi_epi16((A), (B), (I)), \
+                                       (__v8hi)_mm_setzero_si128()))
+
+#define _mm256_shrdi_epi64(A, B, I) \
+  ((__m256i)__builtin_ia32_vpshrdq256((__v4di)(__m256i)(A), \
+                                      (__v4di)(__m256i)(B), (int)(I)))
+
+#define _mm256_mask_shrdi_epi64(S, U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                     (__v4di)_mm256_shrdi_epi64((A), (B), (I)), \
+                                     (__v4di)(__m256i)(S)))
+
+#define _mm256_maskz_shrdi_epi64(U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectq_256((__mmask8)(U), \
+                                     (__v4di)_mm256_shrdi_epi64((A), (B), (I)), \
+                                     (__v4di)_mm256_setzero_si256()))
+
+#define _mm_shrdi_epi64(A, B, I) \
+  ((__m128i)__builtin_ia32_vpshrdq128((__v2di)(__m128i)(A), \
+                                      (__v2di)(__m128i)(B), (int)(I)))
+
+#define _mm_mask_shrdi_epi64(S, U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectq_128((__mmask8)(U), \
+                                       (__v2di)_mm_shrdi_epi64((A), (B), (I)), \
+                                       (__v2di)(__m128i)(S)))
+
+#define _mm_maskz_shrdi_epi64(U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectq_128((__mmask8)(U), \
+                                       (__v2di)_mm_shrdi_epi64((A), (B), (I)), \
+                                       (__v2di)_mm_setzero_si128()))
+
+#define _mm256_shrdi_epi32(A, B, I) \
+  ((__m256i)__builtin_ia32_vpshrdd256((__v8si)(__m256i)(A), \
+                                      (__v8si)(__m256i)(B), (int)(I)))
+
+#define _mm256_mask_shrdi_epi32(S, U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                     (__v8si)_mm256_shrdi_epi32((A), (B), (I)), \
+                                     (__v8si)(__m256i)(S)))
+
+#define _mm256_maskz_shrdi_epi32(U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectd_256((__mmask8)(U), \
+                                     (__v8si)_mm256_shrdi_epi32((A), (B), (I)), \
+                                     (__v8si)_mm256_setzero_si256()))
+
+#define _mm_shrdi_epi32(A, B, I) \
+  ((__m128i)__builtin_ia32_vpshrdd128((__v4si)(__m128i)(A), \
+                                      (__v4si)(__m128i)(B), (int)(I)))
+
+#define _mm_mask_shrdi_epi32(S, U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(U), \
+                                       (__v4si)_mm_shrdi_epi32((A), (B), (I)), \
+                                       (__v4si)(__m128i)(S)))
+
+#define _mm_maskz_shrdi_epi32(U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectd_128((__mmask8)(U), \
+                                       (__v4si)_mm_shrdi_epi32((A), (B), (I)), \
+                                       (__v4si)_mm_setzero_si128()))
+
+#define _mm256_shrdi_epi16(A, B, I) \
+  ((__m256i)__builtin_ia32_vpshrdw256((__v16hi)(__m256i)(A), \
+                                      (__v16hi)(__m256i)(B), (int)(I)))
+
+#define _mm256_mask_shrdi_epi16(S, U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectw_256((__mmask16)(U), \
+                                    (__v16hi)_mm256_shrdi_epi16((A), (B), (I)), \
+                                    (__v16hi)(__m256i)(S)))
+
+#define _mm256_maskz_shrdi_epi16(U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectw_256((__mmask16)(U), \
+                                    (__v16hi)_mm256_shrdi_epi16((A), (B), (I)), \
+                                    (__v16hi)_mm256_setzero_si256()))
+
+#define _mm_shrdi_epi16(A, B, I) \
+  ((__m128i)__builtin_ia32_vpshrdw128((__v8hi)(__m128i)(A), \
+                                      (__v8hi)(__m128i)(B), (int)(I)))
+
+#define _mm_mask_shrdi_epi16(S, U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectw_128((__mmask8)(U), \
+                                       (__v8hi)_mm_shrdi_epi16((A), (B), (I)), \
+                                       (__v8hi)(__m128i)(S)))
+
+#define _mm_maskz_shrdi_epi16(U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectw_128((__mmask8)(U), \
+                                       (__v8hi)_mm_shrdi_epi16((A), (B), (I)), \
+                                       (__v8hi)_mm_setzero_si128()))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_shldv_epi64(__m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_vpshldvq256((__v4di)__A, (__v4di)__B,
+                                             (__v4di)__C);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_shldv_epi64(__m256i __A, __mmask8 __U, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__U,
+                                      (__v4di)_mm256_shldv_epi64(__A, __B, __C),
+                                      (__v4di)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_shldv_epi64(__mmask8 __U, __m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__U,
+                                      (__v4di)_mm256_shldv_epi64(__A, __B, __C),
+                                      (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_shldv_epi64(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpshldvq128((__v2di)__A, (__v2di)__B,
+                                             (__v2di)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_shldv_epi64(__m128i __A, __mmask8 __U, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__U,
+                                         (__v2di)_mm_shldv_epi64(__A, __B, __C),
+                                         (__v2di)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_shldv_epi64(__mmask8 __U, __m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__U,
+                                         (__v2di)_mm_shldv_epi64(__A, __B, __C),
+                                         (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_shldv_epi32(__m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_vpshldvd256((__v8si)__A, (__v8si)__B,
+                                             (__v8si)__C);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_shldv_epi32(__m256i __A, __mmask8 __U, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                      (__v8si)_mm256_shldv_epi32(__A, __B, __C),
+                                      (__v8si)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_shldv_epi32(__mmask8 __U, __m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                      (__v8si)_mm256_shldv_epi32(__A, __B, __C),
+                                      (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_shldv_epi32(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpshldvd128((__v4si)__A, (__v4si)__B,
+                                             (__v4si)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_shldv_epi32(__m128i __A, __mmask8 __U, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                         (__v4si)_mm_shldv_epi32(__A, __B, __C),
+                                         (__v4si)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_shldv_epi32(__mmask8 __U, __m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                         (__v4si)_mm_shldv_epi32(__A, __B, __C),
+                                         (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_shldv_epi16(__m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_vpshldvw256((__v16hi)__A, (__v16hi)__B,
+                                             (__v16hi)__C);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_shldv_epi16(__m256i __A, __mmask16 __U, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectw_256(__U,
+                                      (__v16hi)_mm256_shldv_epi16(__A, __B, __C),
+                                      (__v16hi)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_shldv_epi16(__mmask16 __U, __m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectw_256(__U,
+                                      (__v16hi)_mm256_shldv_epi16(__A, __B, __C),
+                                      (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_shldv_epi16(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpshldvw128((__v8hi)__A, (__v8hi)__B,
+                                             (__v8hi)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_shldv_epi16(__m128i __A, __mmask8 __U, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectw_128(__U,
+                                         (__v8hi)_mm_shldv_epi16(__A, __B, __C),
+                                         (__v8hi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_shldv_epi16(__mmask8 __U, __m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectw_128(__U,
+                                         (__v8hi)_mm_shldv_epi16(__A, __B, __C),
+                                         (__v8hi)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_shrdv_epi64(__m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_vpshrdvq256((__v4di)__A, (__v4di)__B,
+                                             (__v4di)__C);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_shrdv_epi64(__m256i __A, __mmask8 __U, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__U,
+                                      (__v4di)_mm256_shrdv_epi64(__A, __B, __C),
+                                      (__v4di)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_shrdv_epi64(__mmask8 __U, __m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectq_256(__U,
+                                      (__v4di)_mm256_shrdv_epi64(__A, __B, __C),
+                                      (__v4di)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_shrdv_epi64(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpshrdvq128((__v2di)__A, (__v2di)__B,
+                                             (__v2di)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_shrdv_epi64(__m128i __A, __mmask8 __U, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__U,
+                                         (__v2di)_mm_shrdv_epi64(__A, __B, __C),
+                                         (__v2di)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_shrdv_epi64(__mmask8 __U, __m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectq_128(__U,
+                                         (__v2di)_mm_shrdv_epi64(__A, __B, __C),
+                                         (__v2di)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_shrdv_epi32(__m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_vpshrdvd256((__v8si)__A, (__v8si)__B,
+                                             (__v8si)__C);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_shrdv_epi32(__m256i __A, __mmask8 __U, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                      (__v8si)_mm256_shrdv_epi32(__A, __B, __C),
+                                      (__v8si)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_shrdv_epi32(__mmask8 __U, __m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                      (__v8si)_mm256_shrdv_epi32(__A, __B, __C),
+                                      (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_shrdv_epi32(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpshrdvd128((__v4si)__A, (__v4si)__B,
+                                             (__v4si)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_shrdv_epi32(__m128i __A, __mmask8 __U, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                         (__v4si)_mm_shrdv_epi32(__A, __B, __C),
+                                         (__v4si)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_shrdv_epi32(__mmask8 __U, __m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                         (__v4si)_mm_shrdv_epi32(__A, __B, __C),
+                                         (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_shrdv_epi16(__m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_vpshrdvw256((__v16hi)__A, (__v16hi)__B,
+                                             (__v16hi)__C);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_shrdv_epi16(__m256i __A, __mmask16 __U, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectw_256(__U,
+                                     (__v16hi)_mm256_shrdv_epi16(__A, __B, __C),
+                                     (__v16hi)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_shrdv_epi16(__mmask16 __U, __m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)__builtin_ia32_selectw_256(__U,
+                                     (__v16hi)_mm256_shrdv_epi16(__A, __B, __C),
+                                     (__v16hi)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_shrdv_epi16(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpshrdvw128((__v8hi)__A, (__v8hi)__B,
+                                             (__v8hi)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_shrdv_epi16(__m128i __A, __mmask8 __U, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectw_128(__U,
+                                         (__v8hi)_mm_shrdv_epi16(__A, __B, __C),
+                                         (__v8hi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_shrdv_epi16(__mmask8 __U, __m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_selectw_128(__U,
+                                         (__v8hi)_mm_shrdv_epi16(__A, __B, __C),
+                                         (__v8hi)_mm_setzero_si128());
+}
+
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif
diff --git a/third_party/intel/clang/avx512vlvnniintrin.h b/third_party/intel/clang/avx512vlvnniintrin.h
new file mode 100644
index 000000000..d1e5cd9d6
--- /dev/null
+++ b/third_party/intel/clang/avx512vlvnniintrin.h
@@ -0,0 +1,310 @@
+/*===------------- avx512vlvnniintrin.h - VNNI intrinsics ------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vlvnniintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VLVNNIINTRIN_H
+#define __AVX512VLVNNIINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512vnni,no-evex512"),                 \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512vnni,no-evex512"),                 \
+                 __min_vector_width__(256)))
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a A with
+/// corresponding signed 8-bit integers in \a B, producing 4 intermediate signed
+/// 16-bit results. Sum these 4 results with the corresponding 32-bit integer
+/// in \a S, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPBUSD </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 7
+///      tmp1.word := Signed(ZeroExtend16(A.byte[4*j]) * SignExtend16(B.byte[4*j]))
+///      tmp2.word := Signed(ZeroExtend16(A.byte[4*j+1]) * SignExtend16(B.byte[4*j+1]))
+///      tmp3.word := Signed(ZeroExtend16(A.byte[4*j+2]) * SignExtend16(B.byte[4*j+2]))
+///      tmp4.word := Signed(ZeroExtend16(A.byte[4*j+3]) * SignExtend16(B.byte[4*j+3]))
+///      DST.dword[j] := S.dword[j] + tmp1 + tmp2 + tmp3 + tmp4
+///    ENDFOR
+///    DST[MAX:256] := 0
+/// \endcode
+#define _mm256_dpbusd_epi32(S, A, B) \
+  ((__m256i)__builtin_ia32_vpdpbusd256((__v8si)(S), (__v8si)(A), (__v8si)(B)))
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a A with
+/// corresponding signed 8-bit integers in \a B, producing 4 intermediate signed
+/// 16-bit results. Sum these 4 results with the corresponding 32-bit integer
+/// in \a S using signed saturation, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPBUSDS </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 7
+///      tmp1.word := Signed(ZeroExtend16(A.byte[4*j]) * SignExtend16(B.byte[4*j]))
+///      tmp2.word := Signed(ZeroExtend16(A.byte[4*j+1]) * SignExtend16(B.byte[4*j+1]))
+///      tmp3.word := Signed(ZeroExtend16(A.byte[4*j+2]) * SignExtend16(B.byte[4*j+2]))
+///      tmp4.word := Signed(ZeroExtend16(A.byte[4*j+3]) * SignExtend16(B.byte[4*j+3]))
+///      DST.dword[j] := Saturate32(S.dword[j] + tmp1 + tmp2 + tmp3 + tmp4)
+///    ENDFOR
+///    DST[MAX:256] := 0
+/// \endcode
+#define _mm256_dpbusds_epi32(S, A, B) \
+  ((__m256i)__builtin_ia32_vpdpbusds256((__v8si)(S), (__v8si)(A), (__v8si)(B)))
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a A with
+/// corresponding 16-bit integers in \a B, producing 2 intermediate signed 32-bit
+/// results. Sum these 2 results with the corresponding 32-bit integer in \a S,
+///  and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPWSSD </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 7
+///      tmp1.dword := SignExtend32(A.word[2*j]) * SignExtend32(B.word[2*j])
+///      tmp2.dword := SignExtend32(A.word[2*j+1]) * SignExtend32(B.word[2*j+1])
+///      DST.dword[j] := S.dword[j] + tmp1 + tmp2
+///    ENDFOR
+///    DST[MAX:256] := 0
+/// \endcode
+#define _mm256_dpwssd_epi32(S, A, B) \
+  ((__m256i)__builtin_ia32_vpdpwssd256((__v8si)(S), (__v8si)(A), (__v8si)(B)))
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a A with
+/// corresponding 16-bit integers in \a B, producing 2 intermediate signed 32-bit
+/// results. Sum these 2 results with the corresponding 32-bit integer in \a S
+/// using signed saturation, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPWSSDS </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 7
+///      tmp1.dword := SignExtend32(A.word[2*j]) * SignExtend32(B.word[2*j])
+///      tmp2.dword := SignExtend32(A.word[2*j+1]) * SignExtend32(B.word[2*j+1])
+///      DST.dword[j] := Saturate32(S.dword[j] + tmp1 + tmp2)
+///    ENDFOR
+///    DST[MAX:256] := 0
+/// \endcode
+#define _mm256_dpwssds_epi32(S, A, B) \
+  ((__m256i)__builtin_ia32_vpdpwssds256((__v8si)(S), (__v8si)(A), (__v8si)(B)))
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a A with
+/// corresponding signed 8-bit integers in \a B, producing 4 intermediate signed
+/// 16-bit results. Sum these 4 results with the corresponding 32-bit integer
+/// in \a S, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPBUSD </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 3
+///      tmp1.word := Signed(ZeroExtend16(A.byte[4*j]) * SignExtend16(B.byte[4*j]))
+///      tmp2.word := Signed(ZeroExtend16(A.byte[4*j+1]) * SignExtend16(B.byte[4*j+1]))
+///      tmp3.word := Signed(ZeroExtend16(A.byte[4*j+2]) * SignExtend16(B.byte[4*j+2]))
+///      tmp4.word := Signed(ZeroExtend16(A.byte[4*j+3]) * SignExtend16(B.byte[4*j+3]))
+///      DST.dword[j] := S.dword[j] + tmp1 + tmp2 + tmp3 + tmp4
+///    ENDFOR
+///    DST[MAX:128] := 0
+/// \endcode
+#define _mm_dpbusd_epi32(S, A, B) \
+  ((__m128i)__builtin_ia32_vpdpbusd128((__v4si)(S), (__v4si)(A), (__v4si)(B)))
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a A with
+/// corresponding signed 8-bit integers in \a B, producing 4 intermediate signed
+/// 16-bit results. Sum these 4 results with the corresponding 32-bit integer
+/// in \a S using signed saturation, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPBUSDS </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 3
+///      tmp1.word := Signed(ZeroExtend16(A.byte[4*j]) * SignExtend16(B.byte[4*j]))
+///      tmp2.word := Signed(ZeroExtend16(A.byte[4*j+1]) * SignExtend16(B.byte[4*j+1]))
+///      tmp3.word := Signed(ZeroExtend16(A.byte[4*j+2]) * SignExtend16(B.byte[4*j+2]))
+///      tmp4.word := Signed(ZeroExtend16(A.byte[4*j+3]) * SignExtend16(B.byte[4*j+3]))
+///      DST.dword[j] := Saturate32(S.dword[j] + tmp1 + tmp2 + tmp3 + tmp4)
+///    ENDFOR
+///    DST[MAX:128] := 0
+/// \endcode
+#define _mm_dpbusds_epi32(S, A, B) \
+  ((__m128i)__builtin_ia32_vpdpbusds128((__v4si)(S), (__v4si)(A), (__v4si)(B)))
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a A with
+/// corresponding 16-bit integers in \a B, producing 2 intermediate signed 32-bit
+/// results. Sum these 2 results with the corresponding 32-bit integer in \a S,
+/// and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPWSSD </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 3
+///      tmp1.dword := SignExtend32(A.word[2*j]) * SignExtend32(B.word[2*j])
+///      tmp2.dword := SignExtend32(A.word[2*j+1]) * SignExtend32(B.word[2*j+1])
+///      DST.dword[j] := S.dword[j] + tmp1 + tmp2
+///    ENDFOR
+///    DST[MAX:128] := 0
+/// \endcode
+#define _mm_dpwssd_epi32(S, A, B) \
+  ((__m128i)__builtin_ia32_vpdpwssd128((__v4si)(S), (__v4si)(A), (__v4si)(B)))
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a A with
+/// corresponding 16-bit integers in \a B, producing 2 intermediate signed 32-bit
+/// results. Sum these 2 results with the corresponding 32-bit integer in \a S
+/// using signed saturation, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPWSSDS </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 3
+///      tmp1.dword := SignExtend32(A.word[2*j]) * SignExtend32(B.word[2*j])
+///      tmp2.dword := SignExtend32(A.word[2*j+1]) * SignExtend32(B.word[2*j+1])
+///      DST.dword[j] := Saturate32(S.dword[j] + tmp1 + tmp2)
+///    ENDFOR
+///    DST[MAX:128] := 0
+/// \endcode
+#define _mm_dpwssds_epi32(S, A, B) \
+  ((__m128i)__builtin_ia32_vpdpwssds128((__v4si)(S), (__v4si)(A), (__v4si)(B)))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_dpbusd_epi32(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                     (__v8si)_mm256_dpbusd_epi32(__S, __A, __B),
+                                     (__v8si)__S);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_dpbusd_epi32(__mmask8 __U, __m256i __S, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                     (__v8si)_mm256_dpbusd_epi32(__S, __A, __B),
+                                     (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_dpbusds_epi32(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                    (__v8si)_mm256_dpbusds_epi32(__S, __A, __B),
+                                    (__v8si)__S);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_dpbusds_epi32(__mmask8 __U, __m256i __S, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                     (__v8si)_mm256_dpbusds_epi32(__S, __A, __B),
+                                     (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_dpwssd_epi32(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                     (__v8si)_mm256_dpwssd_epi32(__S, __A, __B),
+                                     (__v8si)__S);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_dpwssd_epi32(__mmask8 __U, __m256i __S, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                     (__v8si)_mm256_dpwssd_epi32(__S, __A, __B),
+                                     (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_dpwssds_epi32(__m256i __S, __mmask8 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                    (__v8si)_mm256_dpwssds_epi32(__S, __A, __B),
+                                    (__v8si)__S);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_dpwssds_epi32(__mmask8 __U, __m256i __S, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_selectd_256(__U,
+                                    (__v8si)_mm256_dpwssds_epi32(__S, __A, __B),
+                                    (__v8si)_mm256_setzero_si256());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_dpbusd_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                        (__v4si)_mm_dpbusd_epi32(__S, __A, __B),
+                                        (__v4si)__S);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_dpbusd_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                        (__v4si)_mm_dpbusd_epi32(__S, __A, __B),
+                                        (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_dpbusds_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                       (__v4si)_mm_dpbusds_epi32(__S, __A, __B),
+                                       (__v4si)__S);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_dpbusds_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                       (__v4si)_mm_dpbusds_epi32(__S, __A, __B),
+                                       (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_dpwssd_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                        (__v4si)_mm_dpwssd_epi32(__S, __A, __B),
+                                        (__v4si)__S);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_dpwssd_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                        (__v4si)_mm_dpwssd_epi32(__S, __A, __B),
+                                        (__v4si)_mm_setzero_si128());
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_dpwssds_epi32(__m128i __S, __mmask8 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                       (__v4si)_mm_dpwssds_epi32(__S, __A, __B),
+                                       (__v4si)__S);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_dpwssds_epi32(__mmask8 __U, __m128i __S, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_selectd_128(__U,
+                                       (__v4si)_mm_dpwssds_epi32(__S, __A, __B),
+                                       (__v4si)_mm_setzero_si128());
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif
diff --git a/third_party/intel/clang/avx512vlvp2intersectintrin.h b/third_party/intel/clang/avx512vlvp2intersectintrin.h
new file mode 100644
index 000000000..63a31241a
--- /dev/null
+++ b/third_party/intel/clang/avx512vlvp2intersectintrin.h
@@ -0,0 +1,123 @@
+/*===------ avx512vlvp2intersectintrin.h - VL VP2INTERSECT intrinsics ------===
+ *
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vlvp2intersectintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef _AVX512VLVP2INTERSECT_H
+#define _AVX512VLVP2INTERSECT_H
+
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512vp2intersect,no-evex512"),         \
+                 __min_vector_width__(128)))
+
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vl,avx512vp2intersect,no-evex512"),         \
+                 __min_vector_width__(256)))
+/// Store, in an even/odd pair of mask registers, the indicators of the
+/// locations of value matches between dwords in operands __a and __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VP2INTERSECTD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32].
+/// \param __b
+///    A 256-bit vector of [8 x i32]
+/// \param __m0
+///    A pointer point to 8-bit mask
+/// \param __m1
+///    A pointer point to 8-bit mask
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_2intersect_epi32(__m256i __a, __m256i __b, __mmask8 *__m0, __mmask8 *__m1) {
+  __builtin_ia32_vp2intersect_d_256((__v8si)__a, (__v8si)__b, __m0, __m1);
+}
+
+/// Store, in an even/odd pair of mask registers, the indicators of the
+/// locations of value matches between quadwords in operands __a and __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VP2INTERSECTQ </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x i64].
+/// \param __b
+///    A 256-bit vector of [4 x i64]
+/// \param __m0
+///    A pointer point to 8-bit mask
+/// \param __m1
+///    A pointer point to 8-bit mask
+static __inline__ void __DEFAULT_FN_ATTRS256
+_mm256_2intersect_epi64(__m256i __a, __m256i __b, __mmask8 *__m0, __mmask8 *__m1) {
+  __builtin_ia32_vp2intersect_q_256((__v4di)__a, (__v4di)__b, __m0, __m1);
+}
+
+/// Store, in an even/odd pair of mask registers, the indicators of the
+/// locations of value matches between dwords in operands __a and __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VP2INTERSECTD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x i32].
+/// \param __b
+///    A 128-bit vector of [4 x i32]
+/// \param __m0
+///    A pointer point to 8-bit mask
+/// \param __m1
+///    A pointer point to 8-bit mask
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_2intersect_epi32(__m128i __a, __m128i __b, __mmask8 *__m0, __mmask8 *__m1) {
+  __builtin_ia32_vp2intersect_d_128((__v4si)__a, (__v4si)__b, __m0, __m1);
+}
+
+/// Store, in an even/odd pair of mask registers, the indicators of the
+/// locations of value matches between quadwords in operands __a and __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VP2INTERSECTQ </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x i64].
+/// \param __b
+///    A 128-bit vector of [2 x i64]
+/// \param __m0
+///    A pointer point to 8-bit mask
+/// \param __m1
+///    A pointer point to 8-bit mask
+static __inline__ void __DEFAULT_FN_ATTRS128
+_mm_2intersect_epi64(__m128i __a, __m128i __b, __mmask8 *__m0, __mmask8 *__m1) {
+  __builtin_ia32_vp2intersect_q_128((__v2di)__a, (__v2di)__b, __m0, __m1);
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif
diff --git a/third_party/intel/clang/avx512vnniintrin.h b/third_party/intel/clang/avx512vnniintrin.h
new file mode 100644
index 000000000..0fb381a12
--- /dev/null
+++ b/third_party/intel/clang/avx512vnniintrin.h
@@ -0,0 +1,116 @@
+/*===------------- avx512vnniintrin.h - VNNI intrinsics ------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vnniintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VNNIINTRIN_H
+#define __AVX512VNNIINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vnni,evex512"), __min_vector_width__(512)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_dpbusd_epi32(__m512i __S, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_vpdpbusd512((__v16si)__S, (__v16si)__A,
+                                             (__v16si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_dpbusd_epi32(__m512i __S, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                    (__v16si)_mm512_dpbusd_epi32(__S, __A, __B),
+                                    (__v16si)__S);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_dpbusd_epi32(__mmask16 __U, __m512i __S, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                    (__v16si)_mm512_dpbusd_epi32(__S, __A, __B),
+                                    (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_dpbusds_epi32(__m512i __S, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_vpdpbusds512((__v16si)__S, (__v16si)__A,
+                                              (__v16si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_dpbusds_epi32(__m512i __S, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                   (__v16si)_mm512_dpbusds_epi32(__S, __A, __B),
+                                   (__v16si)__S);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_dpbusds_epi32(__mmask16 __U, __m512i __S, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                   (__v16si)_mm512_dpbusds_epi32(__S, __A, __B),
+                                   (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_dpwssd_epi32(__m512i __S, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_vpdpwssd512((__v16si)__S, (__v16si)__A,
+                                             (__v16si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_dpwssd_epi32(__m512i __S, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                    (__v16si)_mm512_dpwssd_epi32(__S, __A, __B),
+                                    (__v16si)__S);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_dpwssd_epi32(__mmask16 __U, __m512i __S, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                    (__v16si)_mm512_dpwssd_epi32(__S, __A, __B),
+                                    (__v16si)_mm512_setzero_si512());
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_dpwssds_epi32(__m512i __S, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_vpdpwssds512((__v16si)__S, (__v16si)__A,
+                                              (__v16si)__B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_dpwssds_epi32(__m512i __S, __mmask16 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                   (__v16si)_mm512_dpwssds_epi32(__S, __A, __B),
+                                   (__v16si)__S);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_dpwssds_epi32(__mmask16 __U, __m512i __S, __m512i __A, __m512i __B)
+{
+  return (__m512i)__builtin_ia32_selectd_512(__U,
+                                   (__v16si)_mm512_dpwssds_epi32(__S, __A, __B),
+                                   (__v16si)_mm512_setzero_si512());
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/avx512vp2intersectintrin.h b/third_party/intel/clang/avx512vp2intersectintrin.h
new file mode 100644
index 000000000..16552cae3
--- /dev/null
+++ b/third_party/intel/clang/avx512vp2intersectintrin.h
@@ -0,0 +1,78 @@
+/*===------- avx512vpintersectintrin.h - VP2INTERSECT intrinsics ------------===
+ *
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avx512vp2intersect.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef _AVX512VP2INTERSECT_H
+#define _AVX512VP2INTERSECT_H
+
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vp2intersect,evex512"),                     \
+                 __min_vector_width__(512)))
+
+/// Store, in an even/odd pair of mask registers, the indicators of the
+/// locations of value matches between dwords in operands __a and __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VP2INTERSECTD </c> instruction.
+///
+/// \param __a
+///    A 512-bit vector of [16 x i32].
+/// \param __b
+///    A 512-bit vector of [16 x i32]
+/// \param __m0
+///    A pointer point to 16-bit mask
+/// \param __m1
+///    A pointer point to 16-bit mask
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm512_2intersect_epi32(__m512i __a, __m512i __b, __mmask16 *__m0, __mmask16 *__m1) {
+  __builtin_ia32_vp2intersect_d_512((__v16si)__a, (__v16si)__b, __m0, __m1);
+}
+
+/// Store, in an even/odd pair of mask registers, the indicators of the
+/// locations of value matches between quadwords in operands __a and __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VP2INTERSECTQ </c> instruction.
+///
+/// \param __a
+///    A 512-bit vector of [8 x i64].
+/// \param __b
+///    A 512-bit vector of [8 x i64]
+/// \param __m0
+///    A pointer point to 8-bit mask
+/// \param __m1
+///    A pointer point to 8-bit mask
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm512_2intersect_epi64(__m512i __a, __m512i __b, __mmask8 *__m0, __mmask8 *__m1) {
+  __builtin_ia32_vp2intersect_q_512((__v8di)__a, (__v8di)__b, __m0, __m1);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/avx512vpopcntdqintrin.h b/third_party/intel/clang/avx512vpopcntdqintrin.h
new file mode 100644
index 000000000..e73e7e4f7
--- /dev/null
+++ b/third_party/intel/clang/avx512vpopcntdqintrin.h
@@ -0,0 +1,56 @@
+/*===----- avx512vpopcntdqintrin.h - AVX512VPOPCNTDQ intrinsics-------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error                                                                         \
+    "Never use <avx512vpopcntdqintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VPOPCNTDQINTRIN_H
+#define __AVX512VPOPCNTDQINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vpopcntdq,evex512"),                        \
+                 __min_vector_width__(512)))
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_popcnt_epi64(__m512i __A) {
+  return (__m512i)__builtin_ia32_vpopcntq_512((__v8di)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_popcnt_epi64(__m512i __W, __mmask8 __U, __m512i __A) {
+  return (__m512i)__builtin_ia32_selectq_512(
+      (__mmask8)__U, (__v8di)_mm512_popcnt_epi64(__A), (__v8di)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_popcnt_epi64(__mmask8 __U, __m512i __A) {
+  return _mm512_mask_popcnt_epi64((__m512i)_mm512_setzero_si512(), __U, __A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS _mm512_popcnt_epi32(__m512i __A) {
+  return (__m512i)__builtin_ia32_vpopcntd_512((__v16si)__A);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_mask_popcnt_epi32(__m512i __W, __mmask16 __U, __m512i __A) {
+  return (__m512i)__builtin_ia32_selectd_512(
+      (__mmask16)__U, (__v16si)_mm512_popcnt_epi32(__A), (__v16si)__W);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS
+_mm512_maskz_popcnt_epi32(__mmask16 __U, __m512i __A) {
+  return _mm512_mask_popcnt_epi32((__m512i)_mm512_setzero_si512(), __U, __A);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/avx512vpopcntdqvlintrin.h b/third_party/intel/clang/avx512vpopcntdqvlintrin.h
new file mode 100644
index 000000000..b2df2e84d
--- /dev/null
+++ b/third_party/intel/clang/avx512vpopcntdqvlintrin.h
@@ -0,0 +1,95 @@
+/*===---- avx512vpopcntdqintrin.h - AVX512VPOPCNTDQ intrinsics -------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error                                                                         \
+    "Never use <avx512vpopcntdqvlintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVX512VPOPCNTDQVLINTRIN_H
+#define __AVX512VPOPCNTDQVLINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vpopcntdq,avx512vl,no-evex512"),            \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512vpopcntdq,avx512vl,no-evex512"),            \
+                 __min_vector_width__(256)))
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_popcnt_epi64(__m128i __A) {
+  return (__m128i)__builtin_ia32_vpopcntq_128((__v2di)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_popcnt_epi64(__m128i __W, __mmask8 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectq_128(
+      (__mmask8)__U, (__v2di)_mm_popcnt_epi64(__A), (__v2di)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_popcnt_epi64(__mmask8 __U, __m128i __A) {
+  return _mm_mask_popcnt_epi64((__m128i)_mm_setzero_si128(), __U, __A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_popcnt_epi32(__m128i __A) {
+  return (__m128i)__builtin_ia32_vpopcntd_128((__v4si)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_popcnt_epi32(__m128i __W, __mmask8 __U, __m128i __A) {
+  return (__m128i)__builtin_ia32_selectd_128(
+      (__mmask8)__U, (__v4si)_mm_popcnt_epi32(__A), (__v4si)__W);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_popcnt_epi32(__mmask8 __U, __m128i __A) {
+  return _mm_mask_popcnt_epi32((__m128i)_mm_setzero_si128(), __U, __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_popcnt_epi64(__m256i __A) {
+  return (__m256i)__builtin_ia32_vpopcntq_256((__v4di)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_popcnt_epi64(__m256i __W, __mmask8 __U, __m256i __A) {
+  return (__m256i)__builtin_ia32_selectq_256(
+      (__mmask8)__U, (__v4di)_mm256_popcnt_epi64(__A), (__v4di)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_popcnt_epi64(__mmask8 __U, __m256i __A) {
+  return _mm256_mask_popcnt_epi64((__m256i)_mm256_setzero_si256(), __U, __A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_popcnt_epi32(__m256i __A) {
+  return (__m256i)__builtin_ia32_vpopcntd_256((__v8si)__A);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_mask_popcnt_epi32(__m256i __W, __mmask8 __U, __m256i __A) {
+  return (__m256i)__builtin_ia32_selectd_256(
+      (__mmask8)__U, (__v8si)_mm256_popcnt_epi32(__A), (__v8si)__W);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_maskz_popcnt_epi32(__mmask8 __U, __m256i __A) {
+  return _mm256_mask_popcnt_epi32((__m256i)_mm256_setzero_si256(), __U, __A);
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif
diff --git a/third_party/intel/clang/avxifmaintrin.h b/third_party/intel/clang/avxifmaintrin.h
new file mode 100644
index 000000000..5c782d2a5
--- /dev/null
+++ b/third_party/intel/clang/avxifmaintrin.h
@@ -0,0 +1,177 @@
+/*===----------------- avxifmaintrin.h - IFMA intrinsics -------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <avxifmaintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVXIFMAINTRIN_H
+#define __AVXIFMAINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avxifma"),        \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avxifma"),        \
+                 __min_vector_width__(256)))
+
+// must vex-encoding
+
+/// Multiply packed unsigned 52-bit integers in each 64-bit element of \a __Y
+/// and \a __Z to form a 104-bit intermediate result. Add the high 52-bit
+/// unsigned integer from the intermediate result with the corresponding
+/// unsigned 64-bit integer in \a __X, and store the results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i
+/// _mm_madd52hi_avx_epu64 (__m128i __X, __m128i __Y, __m128i __Z)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPMADD52HUQ instruction.
+///
+/// \return
+/// 	return __m128i dst.
+/// \param __X
+/// 	A 128-bit vector of [2 x i64]
+/// \param __Y
+/// 	A 128-bit vector of [2 x i64]
+/// \param __Z
+/// 	A 128-bit vector of [2 x i64]
+///
+/// \code{.operation}
+/// FOR j := 0 to 1
+/// 	i := j*64
+/// 	tmp[127:0] := ZeroExtend64(__Y[i+51:i]) * ZeroExtend64(__Z[i+51:i])
+/// 	dst[i+63:i] := __X[i+63:i] + ZeroExtend64(tmp[103:52])
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_madd52hi_avx_epu64(__m128i __X, __m128i __Y, __m128i __Z) {
+  return (__m128i)__builtin_ia32_vpmadd52huq128((__v2di)__X, (__v2di)__Y,
+                                                (__v2di)__Z);
+}
+
+/// Multiply packed unsigned 52-bit integers in each 64-bit element of \a __Y
+/// and \a __Z to form a 104-bit intermediate result. Add the high 52-bit
+/// unsigned integer from the intermediate result with the corresponding
+/// unsigned 64-bit integer in \a __X, and store the results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i
+/// _mm256_madd52hi_avx_epu64 (__m256i __X, __m256i __Y, __m256i __Z)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPMADD52HUQ instruction.
+///
+/// \return
+/// 	return __m256i dst.
+/// \param __X
+/// 	A 256-bit vector of [4 x i64]
+/// \param __Y
+/// 	A 256-bit vector of [4 x i64]
+/// \param __Z
+/// 	A 256-bit vector of [4 x i64]
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	i := j*64
+/// 	tmp[127:0] := ZeroExtend64(__Y[i+51:i]) * ZeroExtend64(__Z[i+51:i])
+/// 	dst[i+63:i] := __X[i+63:i] + ZeroExtend64(tmp[103:52])
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_madd52hi_avx_epu64(__m256i __X, __m256i __Y, __m256i __Z) {
+  return (__m256i)__builtin_ia32_vpmadd52huq256((__v4di)__X, (__v4di)__Y,
+                                                (__v4di)__Z);
+}
+
+/// Multiply packed unsigned 52-bit integers in each 64-bit element of \a __Y
+/// and \a __Z to form a 104-bit intermediate result. Add the low 52-bit
+/// unsigned integer from the intermediate result with the corresponding
+/// unsigned 64-bit integer in \a __X, and store the results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i
+/// _mm_madd52lo_avx_epu64 (__m128i __X, __m128i __Y, __m128i __Z)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPMADD52LUQ instruction.
+///
+/// \return
+/// 	return __m128i dst.
+/// \param __X
+/// 	A 128-bit vector of [2 x i64]
+/// \param __Y
+/// 	A 128-bit vector of [2 x i64]
+/// \param __Z
+/// 	A 128-bit vector of [2 x i64]
+///
+/// \code{.operation}
+/// FOR j := 0 to 1
+/// 	i := j*64
+/// 	tmp[127:0] := ZeroExtend64(__Y[i+51:i]) * ZeroExtend64(__Z[i+51:i])
+/// 	dst[i+63:i] := __X[i+63:i] + ZeroExtend64(tmp[51:0])
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_madd52lo_avx_epu64(__m128i __X, __m128i __Y, __m128i __Z) {
+  return (__m128i)__builtin_ia32_vpmadd52luq128((__v2di)__X, (__v2di)__Y,
+                                                (__v2di)__Z);
+}
+
+/// Multiply packed unsigned 52-bit integers in each 64-bit element of \a __Y
+/// and \a __Z to form a 104-bit intermediate result. Add the low 52-bit
+/// unsigned integer from the intermediate result with the corresponding
+/// unsigned 64-bit integer in \a __X, and store the results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i
+/// _mm256_madd52lo_avx_epu64 (__m256i __X, __m256i __Y, __m256i __Z)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPMADD52LUQ instruction.
+///
+/// \return
+/// 	return __m256i dst.
+/// \param __X
+/// 	A 256-bit vector of [4 x i64]
+/// \param __Y
+/// 	A 256-bit vector of [4 x i64]
+/// \param __Z
+/// 	A 256-bit vector of [4 x i64]
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	i := j*64
+/// 	tmp[127:0] := ZeroExtend64(__Y[i+51:i]) * ZeroExtend64(__Z[i+51:i])
+/// 	dst[i+63:i] := __X[i+63:i] + ZeroExtend64(tmp[51:0])
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_madd52lo_avx_epu64(__m256i __X, __m256i __Y, __m256i __Z) {
+  return (__m256i)__builtin_ia32_vpmadd52luq256((__v4di)__X, (__v4di)__Y,
+                                                (__v4di)__Z);
+}
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif // __AVXIFMAINTRIN_H
diff --git a/third_party/intel/clang/avxintrin.h b/third_party/intel/clang/avxintrin.h
new file mode 100644
index 000000000..4983f3311
--- /dev/null
+++ b/third_party/intel/clang/avxintrin.h
@@ -0,0 +1,5126 @@
+/*===---- avxintrin.h - AVX intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <avxintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVXINTRIN_H
+#define __AVXINTRIN_H
+
+typedef double __v4df __attribute__ ((__vector_size__ (32)));
+typedef float __v8sf __attribute__ ((__vector_size__ (32)));
+typedef long long __v4di __attribute__ ((__vector_size__ (32)));
+typedef int __v8si __attribute__ ((__vector_size__ (32)));
+typedef short __v16hi __attribute__ ((__vector_size__ (32)));
+typedef char __v32qi __attribute__ ((__vector_size__ (32)));
+
+/* Unsigned types */
+typedef unsigned long long __v4du __attribute__ ((__vector_size__ (32)));
+typedef unsigned int __v8su __attribute__ ((__vector_size__ (32)));
+typedef unsigned short __v16hu __attribute__ ((__vector_size__ (32)));
+typedef unsigned char __v32qu __attribute__ ((__vector_size__ (32)));
+
+/* We need an explicitly signed variant for char. Note that this shouldn't
+ * appear in the interface though. */
+typedef signed char __v32qs __attribute__((__vector_size__(32)));
+
+typedef float __m256 __attribute__ ((__vector_size__ (32), __aligned__(32)));
+typedef double __m256d __attribute__((__vector_size__(32), __aligned__(32)));
+typedef long long __m256i __attribute__((__vector_size__(32), __aligned__(32)));
+
+typedef float __m256_u __attribute__ ((__vector_size__ (32), __aligned__(1)));
+typedef double __m256d_u __attribute__((__vector_size__(32), __aligned__(1)));
+typedef long long __m256i_u __attribute__((__vector_size__(32), __aligned__(1)));
+
+#ifdef __SSE2__
+/* Both _Float16 and __bf16 require SSE2 being enabled. */
+typedef _Float16 __v16hf __attribute__((__vector_size__(32), __aligned__(32)));
+typedef _Float16 __m256h __attribute__((__vector_size__(32), __aligned__(32)));
+typedef _Float16 __m256h_u __attribute__((__vector_size__(32), __aligned__(1)));
+
+typedef __bf16 __v16bf __attribute__((__vector_size__(32), __aligned__(32)));
+typedef __bf16 __m256bh __attribute__((__vector_size__(32), __aligned__(32)));
+#endif
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__, __target__("avx,no-evex512"), \
+                 __min_vector_width__(256)))
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avx,no-evex512"), \
+                 __min_vector_width__(128)))
+
+/* Arithmetic */
+/// Adds two 256-bit vectors of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VADDPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+/// \returns A 256-bit vector of [4 x double] containing the sums of both
+///    operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_add_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)((__v4df)__a+(__v4df)__b);
+}
+
+/// Adds two 256-bit vectors of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VADDPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+/// \returns A 256-bit vector of [8 x float] containing the sums of both
+///    operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_add_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)((__v8sf)__a+(__v8sf)__b);
+}
+
+/// Subtracts two 256-bit vectors of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSUBPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing the minuend.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing the subtrahend.
+/// \returns A 256-bit vector of [4 x double] containing the differences between
+///    both operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_sub_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)((__v4df)__a-(__v4df)__b);
+}
+
+/// Subtracts two 256-bit vectors of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSUBPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing the minuend.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing the subtrahend.
+/// \returns A 256-bit vector of [8 x float] containing the differences between
+///    both operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_sub_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)((__v8sf)__a-(__v8sf)__b);
+}
+
+/// Adds the even-indexed values and subtracts the odd-indexed values of
+///    two 256-bit vectors of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VADDSUBPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing the left source operand.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing the right source operand.
+/// \returns A 256-bit vector of [4 x double] containing the alternating sums
+///    and differences between both operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_addsub_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)__builtin_ia32_addsubpd256((__v4df)__a, (__v4df)__b);
+}
+
+/// Adds the even-indexed values and subtracts the odd-indexed values of
+///    two 256-bit vectors of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VADDSUBPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing the left source operand.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing the right source operand.
+/// \returns A 256-bit vector of [8 x float] containing the alternating sums and
+///    differences between both operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_addsub_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)__builtin_ia32_addsubps256((__v8sf)__a, (__v8sf)__b);
+}
+
+/// Divides two 256-bit vectors of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDIVPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing the dividend.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing the divisor.
+/// \returns A 256-bit vector of [4 x double] containing the quotients of both
+///    operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_div_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)((__v4df)__a/(__v4df)__b);
+}
+
+/// Divides two 256-bit vectors of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDIVPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing the dividend.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing the divisor.
+/// \returns A 256-bit vector of [8 x float] containing the quotients of both
+///    operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_div_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)((__v8sf)__a/(__v8sf)__b);
+}
+
+/// Compares two 256-bit vectors of [4 x double] and returns the greater
+///    of each pair of values.
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMAXPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing one of the operands.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing one of the operands.
+/// \returns A 256-bit vector of [4 x double] containing the maximum values
+///    between both operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_max_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)__builtin_ia32_maxpd256((__v4df)__a, (__v4df)__b);
+}
+
+/// Compares two 256-bit vectors of [8 x float] and returns the greater
+///    of each pair of values.
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMAXPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing one of the operands.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing one of the operands.
+/// \returns A 256-bit vector of [8 x float] containing the maximum values
+///    between both operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_max_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)__builtin_ia32_maxps256((__v8sf)__a, (__v8sf)__b);
+}
+
+/// Compares two 256-bit vectors of [4 x double] and returns the lesser
+///    of each pair of values.
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMINPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing one of the operands.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing one of the operands.
+/// \returns A 256-bit vector of [4 x double] containing the minimum values
+///    between both operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_min_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)__builtin_ia32_minpd256((__v4df)__a, (__v4df)__b);
+}
+
+/// Compares two 256-bit vectors of [8 x float] and returns the lesser
+///    of each pair of values.
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMINPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing one of the operands.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing one of the operands.
+/// \returns A 256-bit vector of [8 x float] containing the minimum values
+///    between both operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_min_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)__builtin_ia32_minps256((__v8sf)__a, (__v8sf)__b);
+}
+
+/// Multiplies two 256-bit vectors of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMULPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing one of the operands.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing one of the operands.
+/// \returns A 256-bit vector of [4 x double] containing the products of both
+///    operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_mul_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)((__v4df)__a * (__v4df)__b);
+}
+
+/// Multiplies two 256-bit vectors of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMULPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing one of the operands.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing one of the operands.
+/// \returns A 256-bit vector of [8 x float] containing the products of both
+///    operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_mul_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)((__v8sf)__a * (__v8sf)__b);
+}
+
+/// Calculates the square roots of the values in a 256-bit vector of
+///    [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSQRTPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \returns A 256-bit vector of [4 x double] containing the square roots of the
+///    values in the operand.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_sqrt_pd(__m256d __a)
+{
+  return (__m256d)__builtin_ia32_sqrtpd256((__v4df)__a);
+}
+
+/// Calculates the square roots of the values in a 256-bit vector of
+///    [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSQRTPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \returns A 256-bit vector of [8 x float] containing the square roots of the
+///    values in the operand.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_sqrt_ps(__m256 __a)
+{
+  return (__m256)__builtin_ia32_sqrtps256((__v8sf)__a);
+}
+
+/// Calculates the reciprocal square roots of the values in a 256-bit
+///    vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VRSQRTPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \returns A 256-bit vector of [8 x float] containing the reciprocal square
+///    roots of the values in the operand.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_rsqrt_ps(__m256 __a)
+{
+  return (__m256)__builtin_ia32_rsqrtps256((__v8sf)__a);
+}
+
+/// Calculates the reciprocals of the values in a 256-bit vector of
+///    [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VRCPPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \returns A 256-bit vector of [8 x float] containing the reciprocals of the
+///    values in the operand.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_rcp_ps(__m256 __a)
+{
+  return (__m256)__builtin_ia32_rcpps256((__v8sf)__a);
+}
+
+/// Rounds the values in a 256-bit vector of [4 x double] as specified
+///    by the byte operand. The source values are rounded to integer values and
+///    returned as 64-bit double-precision floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256d _mm256_round_pd(__m256d V, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPD </c> instruction.
+///
+/// \param V
+///    A 256-bit vector of [4 x double].
+/// \param M
+///    An integer value that specifies the rounding operation. \n
+///    Bits [7:4] are reserved. \n
+///    Bit [3] is a precision exception value: \n
+///      0: A normal PE exception is used. \n
+///      1: The PE field is not updated. \n
+///    Bit [2] is the rounding control source: \n
+///      0: Use bits [1:0] of \a M. \n
+///      1: Use the current MXCSR setting. \n
+///    Bits [1:0] contain the rounding control definition: \n
+///      00: Nearest. \n
+///      01: Downward (toward negative infinity). \n
+///      10: Upward (toward positive infinity). \n
+///      11: Truncated.
+/// \returns A 256-bit vector of [4 x double] containing the rounded values.
+#define _mm256_round_pd(V, M) \
+  ((__m256d)__builtin_ia32_roundpd256((__v4df)(__m256d)(V), (M)))
+
+/// Rounds the values stored in a 256-bit vector of [8 x float] as
+///    specified by the byte operand. The source values are rounded to integer
+///    values and returned as floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256 _mm256_round_ps(__m256 V, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPS </c> instruction.
+///
+/// \param V
+///    A 256-bit vector of [8 x float].
+/// \param M
+///    An integer value that specifies the rounding operation. \n
+///    Bits [7:4] are reserved. \n
+///    Bit [3] is a precision exception value: \n
+///      0: A normal PE exception is used. \n
+///      1: The PE field is not updated. \n
+///    Bit [2] is the rounding control source: \n
+///      0: Use bits [1:0] of \a M. \n
+///      1: Use the current MXCSR setting. \n
+///    Bits [1:0] contain the rounding control definition: \n
+///      00: Nearest. \n
+///      01: Downward (toward negative infinity). \n
+///      10: Upward (toward positive infinity). \n
+///      11: Truncated.
+/// \returns A 256-bit vector of [8 x float] containing the rounded values.
+#define _mm256_round_ps(V, M) \
+  ((__m256)__builtin_ia32_roundps256((__v8sf)(__m256)(V), (M)))
+
+/// Rounds up the values stored in a 256-bit vector of [4 x double]. The
+///    source values are rounded up to integer values and returned as 64-bit
+///    double-precision floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256d _mm256_ceil_pd(__m256d V);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPD </c> instruction.
+///
+/// \param V
+///    A 256-bit vector of [4 x double].
+/// \returns A 256-bit vector of [4 x double] containing the rounded up values.
+#define _mm256_ceil_pd(V)  _mm256_round_pd((V), _MM_FROUND_CEIL)
+
+/// Rounds down the values stored in a 256-bit vector of [4 x double].
+///    The source values are rounded down to integer values and returned as
+///    64-bit double-precision floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256d _mm256_floor_pd(__m256d V);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPD </c> instruction.
+///
+/// \param V
+///    A 256-bit vector of [4 x double].
+/// \returns A 256-bit vector of [4 x double] containing the rounded down
+///    values.
+#define _mm256_floor_pd(V) _mm256_round_pd((V), _MM_FROUND_FLOOR)
+
+/// Rounds up the values stored in a 256-bit vector of [8 x float]. The
+///    source values are rounded up to integer values and returned as
+///    floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256 _mm256_ceil_ps(__m256 V);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPS </c> instruction.
+///
+/// \param V
+///    A 256-bit vector of [8 x float].
+/// \returns A 256-bit vector of [8 x float] containing the rounded up values.
+#define _mm256_ceil_ps(V)  _mm256_round_ps((V), _MM_FROUND_CEIL)
+
+/// Rounds down the values stored in a 256-bit vector of [8 x float]. The
+///    source values are rounded down to integer values and returned as
+///    floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256 _mm256_floor_ps(__m256 V);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPS </c> instruction.
+///
+/// \param V
+///    A 256-bit vector of [8 x float].
+/// \returns A 256-bit vector of [8 x float] containing the rounded down values.
+#define _mm256_floor_ps(V) _mm256_round_ps((V), _MM_FROUND_FLOOR)
+
+/* Logical */
+/// Performs a bitwise AND of two 256-bit vectors of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VANDPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+/// \returns A 256-bit vector of [4 x double] containing the bitwise AND of the
+///    values between both operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_and_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)((__v4du)__a & (__v4du)__b);
+}
+
+/// Performs a bitwise AND of two 256-bit vectors of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VANDPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+/// \returns A 256-bit vector of [8 x float] containing the bitwise AND of the
+///    values between both operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_and_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)((__v8su)__a & (__v8su)__b);
+}
+
+/// Performs a bitwise AND of two 256-bit vectors of [4 x double], using
+///    the one's complement of the values contained in the first source operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VANDNPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing the left source operand. The
+///    one's complement of this value is used in the bitwise AND.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing the right source operand.
+/// \returns A 256-bit vector of [4 x double] containing the bitwise AND of the
+///    values of the second operand and the one's complement of the first
+///    operand.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_andnot_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)(~(__v4du)__a & (__v4du)__b);
+}
+
+/// Performs a bitwise AND of two 256-bit vectors of [8 x float], using
+///    the one's complement of the values contained in the first source operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VANDNPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing the left source operand. The
+///    one's complement of this value is used in the bitwise AND.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing the right source operand.
+/// \returns A 256-bit vector of [8 x float] containing the bitwise AND of the
+///    values of the second operand and the one's complement of the first
+///    operand.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_andnot_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)(~(__v8su)__a & (__v8su)__b);
+}
+
+/// Performs a bitwise OR of two 256-bit vectors of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VORPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+/// \returns A 256-bit vector of [4 x double] containing the bitwise OR of the
+///    values between both operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_or_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)((__v4du)__a | (__v4du)__b);
+}
+
+/// Performs a bitwise OR of two 256-bit vectors of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VORPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+/// \returns A 256-bit vector of [8 x float] containing the bitwise OR of the
+///    values between both operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_or_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)((__v8su)__a | (__v8su)__b);
+}
+
+/// Performs a bitwise XOR of two 256-bit vectors of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VXORPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+/// \returns A 256-bit vector of [4 x double] containing the bitwise XOR of the
+///    values between both operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_xor_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)((__v4du)__a ^ (__v4du)__b);
+}
+
+/// Performs a bitwise XOR of two 256-bit vectors of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VXORPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+/// \param __b
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+/// \returns A 256-bit vector of [8 x float] containing the bitwise XOR of the
+///    values between both operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_xor_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)((__v8su)__a ^ (__v8su)__b);
+}
+
+/* Horizontal arithmetic */
+/// Horizontally adds the adjacent pairs of values contained in two
+///    256-bit vectors of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VHADDPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+///    The horizontal sums of the values are returned in the even-indexed
+///    elements of a vector of [4 x double].
+/// \param __b
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+///    The horizontal sums of the values are returned in the odd-indexed
+///    elements of a vector of [4 x double].
+/// \returns A 256-bit vector of [4 x double] containing the horizontal sums of
+///    both operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_hadd_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)__builtin_ia32_haddpd256((__v4df)__a, (__v4df)__b);
+}
+
+/// Horizontally adds the adjacent pairs of values contained in two
+///    256-bit vectors of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VHADDPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+///    The horizontal sums of the values are returned in the elements with
+///    index 0, 1, 4, 5 of a vector of [8 x float].
+/// \param __b
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+///    The horizontal sums of the values are returned in the elements with
+///    index 2, 3, 6, 7 of a vector of [8 x float].
+/// \returns A 256-bit vector of [8 x float] containing the horizontal sums of
+///    both operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_hadd_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)__builtin_ia32_haddps256((__v8sf)__a, (__v8sf)__b);
+}
+
+/// Horizontally subtracts the adjacent pairs of values contained in two
+///    256-bit vectors of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VHSUBPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+///    The horizontal differences between the values are returned in the
+///    even-indexed elements of a vector of [4 x double].
+/// \param __b
+///    A 256-bit vector of [4 x double] containing one of the source operands.
+///    The horizontal differences between the values are returned in the
+///    odd-indexed elements of a vector of [4 x double].
+/// \returns A 256-bit vector of [4 x double] containing the horizontal
+///    differences of both operands.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_hsub_pd(__m256d __a, __m256d __b)
+{
+  return (__m256d)__builtin_ia32_hsubpd256((__v4df)__a, (__v4df)__b);
+}
+
+/// Horizontally subtracts the adjacent pairs of values contained in two
+///    256-bit vectors of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VHSUBPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+///    The horizontal differences between the values are returned in the
+///    elements with index 0, 1, 4, 5 of a vector of [8 x float].
+/// \param __b
+///    A 256-bit vector of [8 x float] containing one of the source operands.
+///    The horizontal differences between the values are returned in the
+///    elements with index 2, 3, 6, 7 of a vector of [8 x float].
+/// \returns A 256-bit vector of [8 x float] containing the horizontal
+///    differences of both operands.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_hsub_ps(__m256 __a, __m256 __b)
+{
+  return (__m256)__builtin_ia32_hsubps256((__v8sf)__a, (__v8sf)__b);
+}
+
+/* Vector permutations */
+/// Copies the values in a 128-bit vector of [2 x double] as specified
+///    by the 128-bit integer vector operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPERMILPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __c
+///    A 128-bit integer vector operand specifying how the values are to be
+///    copied. \n
+///    Bit [1]: \n
+///      0: Bits [63:0] of the source are copied to bits [63:0] of the returned
+///         vector. \n
+///      1: Bits [127:64] of the source are copied to bits [63:0] of the
+///         returned vector. \n
+///    Bit [65]: \n
+///      0: Bits [63:0] of the source are copied to bits [127:64] of the
+///         returned vector. \n
+///      1: Bits [127:64] of the source are copied to bits [127:64] of the
+///         returned vector.
+/// \returns A 128-bit vector of [2 x double] containing the copied values.
+static __inline __m128d __DEFAULT_FN_ATTRS128
+_mm_permutevar_pd(__m128d __a, __m128i __c)
+{
+  return (__m128d)__builtin_ia32_vpermilvarpd((__v2df)__a, (__v2di)__c);
+}
+
+/// Copies the values in a 256-bit vector of [4 x double] as specified
+///    by the 256-bit integer vector operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPERMILPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \param __c
+///    A 256-bit integer vector operand specifying how the values are to be
+///    copied. \n
+///    Bit [1]: \n
+///      0: Bits [63:0] of the source are copied to bits [63:0] of the returned
+///         vector. \n
+///      1: Bits [127:64] of the source are copied to bits [63:0] of the
+///         returned vector. \n
+///    Bit [65]: \n
+///      0: Bits [63:0] of the source are copied to bits [127:64] of the
+///         returned vector. \n
+///      1: Bits [127:64] of the source are copied to bits [127:64] of the
+///         returned vector. \n
+///    Bit [129]: \n
+///      0: Bits [191:128] of the source are copied to bits [191:128] of the
+///         returned vector. \n
+///      1: Bits [255:192] of the source are copied to bits [191:128] of the
+///         returned vector. \n
+///    Bit [193]: \n
+///      0: Bits [191:128] of the source are copied to bits [255:192] of the
+///         returned vector. \n
+///      1: Bits [255:192] of the source are copied to bits [255:192] of the
+///    returned vector.
+/// \returns A 256-bit vector of [4 x double] containing the copied values.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_permutevar_pd(__m256d __a, __m256i __c)
+{
+  return (__m256d)__builtin_ia32_vpermilvarpd256((__v4df)__a, (__v4di)__c);
+}
+
+/// Copies the values stored in a 128-bit vector of [4 x float] as
+///    specified by the 128-bit integer vector operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPERMILPS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __c
+///    A 128-bit integer vector operand specifying how the values are to be
+///    copied. \n
+///    Bits [1:0]: \n
+///      00: Bits [31:0] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///    Bits [33:32]: \n
+///      00: Bits [31:0] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///    Bits [65:64]: \n
+///      00: Bits [31:0] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///    Bits [97:96]: \n
+///      00: Bits [31:0] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [127:96] of the
+///          returned vector.
+/// \returns A 128-bit vector of [4 x float] containing the copied values.
+static __inline __m128 __DEFAULT_FN_ATTRS128
+_mm_permutevar_ps(__m128 __a, __m128i __c)
+{
+  return (__m128)__builtin_ia32_vpermilvarps((__v4sf)__a, (__v4si)__c);
+}
+
+/// Copies the values stored in a 256-bit vector of [8 x float] as
+///    specified by the 256-bit integer vector operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPERMILPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \param __c
+///    A 256-bit integer vector operand specifying how the values are to be
+///    copied. \n
+///    Bits [1:0]: \n
+///      00: Bits [31:0] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///    Bits [33:32]: \n
+///      00: Bits [31:0] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///    Bits [65:64]: \n
+///      00: Bits [31:0] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///    Bits [97:96]: \n
+///      00: Bits [31:0] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///    Bits [129:128]: \n
+///      00: Bits [159:128] of the source are copied to bits [159:128] of the
+///          returned vector. \n
+///      01: Bits [191:160] of the source are copied to bits [159:128] of the
+///          returned vector. \n
+///      10: Bits [223:192] of the source are copied to bits [159:128] of the
+///          returned vector. \n
+///      11: Bits [255:224] of the source are copied to bits [159:128] of the
+///          returned vector. \n
+///    Bits [161:160]: \n
+///      00: Bits [159:128] of the source are copied to bits [191:160] of the
+///          returned vector. \n
+///      01: Bits [191:160] of the source are copied to bits [191:160] of the
+///          returned vector. \n
+///      10: Bits [223:192] of the source are copied to bits [191:160] of the
+///          returned vector. \n
+///      11: Bits [255:224] of the source are copied to bits [191:160] of the
+///          returned vector. \n
+///    Bits [193:192]: \n
+///      00: Bits [159:128] of the source are copied to bits [223:192] of the
+///          returned vector. \n
+///      01: Bits [191:160] of the source are copied to bits [223:192] of the
+///          returned vector. \n
+///      10: Bits [223:192] of the source are copied to bits [223:192] of the
+///          returned vector. \n
+///      11: Bits [255:224] of the source are copied to bits [223:192] of the
+///          returned vector. \n
+///    Bits [225:224]: \n
+///      00: Bits [159:128] of the source are copied to bits [255:224] of the
+///          returned vector. \n
+///      01: Bits [191:160] of the source are copied to bits [255:224] of the
+///          returned vector. \n
+///      10: Bits [223:192] of the source are copied to bits [255:224] of the
+///          returned vector. \n
+///      11: Bits [255:224] of the source are copied to bits [255:224] of the
+///          returned vector.
+/// \returns A 256-bit vector of [8 x float] containing the copied values.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_permutevar_ps(__m256 __a, __m256i __c)
+{
+  return (__m256)__builtin_ia32_vpermilvarps256((__v8sf)__a, (__v8si)__c);
+}
+
+/// Copies the values in a 128-bit vector of [2 x double] as specified
+///    by the immediate integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_permute_pd(__m128d A, const int C);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPERMILPD </c> instruction.
+///
+/// \param A
+///    A 128-bit vector of [2 x double].
+/// \param C
+///    An immediate integer operand specifying how the values are to be
+///    copied. \n
+///    Bit [0]: \n
+///      0: Bits [63:0] of the source are copied to bits [63:0] of the returned
+///         vector. \n
+///      1: Bits [127:64] of the source are copied to bits [63:0] of the
+///         returned vector. \n
+///    Bit [1]: \n
+///      0: Bits [63:0] of the source are copied to bits [127:64] of the
+///         returned vector. \n
+///      1: Bits [127:64] of the source are copied to bits [127:64] of the
+///         returned vector.
+/// \returns A 128-bit vector of [2 x double] containing the copied values.
+#define _mm_permute_pd(A, C) \
+  ((__m128d)__builtin_ia32_vpermilpd((__v2df)(__m128d)(A), (int)(C)))
+
+/// Copies the values in a 256-bit vector of [4 x double] as specified by
+///    the immediate integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256d _mm256_permute_pd(__m256d A, const int C);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPERMILPD </c> instruction.
+///
+/// \param A
+///    A 256-bit vector of [4 x double].
+/// \param C
+///    An immediate integer operand specifying how the values are to be
+///    copied. \n
+///    Bit [0]: \n
+///      0: Bits [63:0] of the source are copied to bits [63:0] of the returned
+///         vector. \n
+///      1: Bits [127:64] of the source are copied to bits [63:0] of the
+///         returned vector. \n
+///    Bit [1]: \n
+///      0: Bits [63:0] of the source are copied to bits [127:64] of the
+///         returned vector. \n
+///      1: Bits [127:64] of the source are copied to bits [127:64] of the
+///         returned vector. \n
+///    Bit [2]: \n
+///      0: Bits [191:128] of the source are copied to bits [191:128] of the
+///         returned vector. \n
+///      1: Bits [255:192] of the source are copied to bits [191:128] of the
+///         returned vector. \n
+///    Bit [3]: \n
+///      0: Bits [191:128] of the source are copied to bits [255:192] of the
+///         returned vector. \n
+///      1: Bits [255:192] of the source are copied to bits [255:192] of the
+///         returned vector.
+/// \returns A 256-bit vector of [4 x double] containing the copied values.
+#define _mm256_permute_pd(A, C) \
+  ((__m256d)__builtin_ia32_vpermilpd256((__v4df)(__m256d)(A), (int)(C)))
+
+/// Copies the values in a 128-bit vector of [4 x float] as specified by
+///    the immediate integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_permute_ps(__m128 A, const int C);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPERMILPS </c> instruction.
+///
+/// \param A
+///    A 128-bit vector of [4 x float].
+/// \param C
+///    An immediate integer operand specifying how the values are to be
+///    copied. \n
+///    Bits [1:0]: \n
+///      00: Bits [31:0] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///    Bits [3:2]: \n
+///      00: Bits [31:0] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///    Bits [5:4]: \n
+///      00: Bits [31:0] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///    Bits [7:6]: \n
+///      00: Bits [31:0] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [127:96] of the
+///          returned vector.
+/// \returns A 128-bit vector of [4 x float] containing the copied values.
+#define _mm_permute_ps(A, C) \
+  ((__m128)__builtin_ia32_vpermilps((__v4sf)(__m128)(A), (int)(C)))
+
+/// Copies the values in a 256-bit vector of [8 x float] as specified by
+///    the immediate integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256 _mm256_permute_ps(__m256 A, const int C);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPERMILPS </c> instruction.
+///
+/// \param A
+///    A 256-bit vector of [8 x float].
+/// \param C
+///    An immediate integer operand specifying how the values are to be
+///    copied. \n
+///    Bits [1:0]: \n
+///      00: Bits [31:0] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [31:0] of the
+///          returned vector. \n
+///    Bits [3:2]: \n
+///      00: Bits [31:0] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [63:32] of the
+///          returned vector. \n
+///    Bits [5:4]: \n
+///      00: Bits [31:0] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [95:64] of the
+///          returned vector. \n
+///    Bits [7:6]: \n
+///      00: Bits [31:0] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      01: Bits [63:32] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      10: Bits [95:64] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///      11: Bits [127:96] of the source are copied to bits [127:96] of the
+///          returned vector. \n
+///    Bits [1:0]: \n
+///      00: Bits [159:128] of the source are copied to bits [159:128] of the
+///          returned vector. \n
+///      01: Bits [191:160] of the source are copied to bits [159:128] of the
+///          returned vector. \n
+///      10: Bits [223:192] of the source are copied to bits [159:128] of the
+///          returned vector. \n
+///      11: Bits [255:224] of the source are copied to bits [159:128] of the
+///          returned vector. \n
+///    Bits [3:2]: \n
+///      00: Bits [159:128] of the source are copied to bits [191:160] of the
+///          returned vector. \n
+///      01: Bits [191:160] of the source are copied to bits [191:160] of the
+///          returned vector. \n
+///      10: Bits [223:192] of the source are copied to bits [191:160] of the
+///          returned vector. \n
+///      11: Bits [255:224] of the source are copied to bits [191:160] of the
+///          returned vector. \n
+///    Bits [5:4]: \n
+///      00: Bits [159:128] of the source are copied to bits [223:192] of the
+///          returned vector. \n
+///      01: Bits [191:160] of the source are copied to bits [223:192] of the
+///          returned vector. \n
+///      10: Bits [223:192] of the source are copied to bits [223:192] of the
+///          returned vector. \n
+///      11: Bits [255:224] of the source are copied to bits [223:192] of the
+///          returned vector. \n
+///    Bits [7:6]: \n
+///      00: Bits [159:128] of the source are copied to bits [255:224] of the
+///          returned vector. \n
+///      01: Bits [191:160] of the source are copied to bits [255:224] of the
+///          returned vector. \n
+///      10: Bits [223:192] of the source are copied to bits [255:224] of the
+///          returned vector. \n
+///      11: Bits [255:224] of the source are copied to bits [255:224] of the
+///          returned vector.
+/// \returns A 256-bit vector of [8 x float] containing the copied values.
+#define _mm256_permute_ps(A, C) \
+  ((__m256)__builtin_ia32_vpermilps256((__v8sf)(__m256)(A), (int)(C)))
+
+/// Permutes 128-bit data values stored in two 256-bit vectors of
+///    [4 x double], as specified by the immediate integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256d _mm256_permute2f128_pd(__m256d V1, __m256d V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPERM2F128 </c> instruction.
+///
+/// \param V1
+///    A 256-bit vector of [4 x double].
+/// \param V2
+///    A 256-bit vector of [4 x double.
+/// \param M
+///    An immediate integer operand specifying how the values are to be
+///    permuted. \n
+///    Bits [1:0]: \n
+///      00: Bits [127:0] of operand \a V1 are copied to bits [127:0] of the
+///          destination. \n
+///      01: Bits [255:128] of operand \a V1 are copied to bits [127:0] of the
+///          destination. \n
+///      10: Bits [127:0] of operand \a V2 are copied to bits [127:0] of the
+///          destination. \n
+///      11: Bits [255:128] of operand \a V2 are copied to bits [127:0] of the
+///          destination. \n
+///    Bits [5:4]: \n
+///      00: Bits [127:0] of operand \a V1 are copied to bits [255:128] of the
+///          destination. \n
+///      01: Bits [255:128] of operand \a V1 are copied to bits [255:128] of the
+///          destination. \n
+///      10: Bits [127:0] of operand \a V2 are copied to bits [255:128] of the
+///          destination. \n
+///      11: Bits [255:128] of operand \a V2 are copied to bits [255:128] of the
+///          destination.
+/// \returns A 256-bit vector of [4 x double] containing the copied values.
+#define _mm256_permute2f128_pd(V1, V2, M) \
+  ((__m256d)__builtin_ia32_vperm2f128_pd256((__v4df)(__m256d)(V1), \
+                                            (__v4df)(__m256d)(V2), (int)(M)))
+
+/// Permutes 128-bit data values stored in two 256-bit vectors of
+///    [8 x float], as specified by the immediate integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256 _mm256_permute2f128_ps(__m256 V1, __m256 V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPERM2F128 </c> instruction.
+///
+/// \param V1
+///    A 256-bit vector of [8 x float].
+/// \param V2
+///    A 256-bit vector of [8 x float].
+/// \param M
+///    An immediate integer operand specifying how the values are to be
+///    permuted. \n
+///    Bits [1:0]: \n
+///    00: Bits [127:0] of operand \a V1 are copied to bits [127:0] of the
+///    destination. \n
+///    01: Bits [255:128] of operand \a V1 are copied to bits [127:0] of the
+///    destination. \n
+///    10: Bits [127:0] of operand \a V2 are copied to bits [127:0] of the
+///    destination. \n
+///    11: Bits [255:128] of operand \a V2 are copied to bits [127:0] of the
+///    destination. \n
+///    Bits [5:4]: \n
+///    00: Bits [127:0] of operand \a V1 are copied to bits [255:128] of the
+///    destination. \n
+///    01: Bits [255:128] of operand \a V1 are copied to bits [255:128] of the
+///    destination. \n
+///    10: Bits [127:0] of operand \a V2 are copied to bits [255:128] of the
+///    destination. \n
+///    11: Bits [255:128] of operand \a V2 are copied to bits [255:128] of the
+///    destination.
+/// \returns A 256-bit vector of [8 x float] containing the copied values.
+#define _mm256_permute2f128_ps(V1, V2, M) \
+  ((__m256)__builtin_ia32_vperm2f128_ps256((__v8sf)(__m256)(V1), \
+                                           (__v8sf)(__m256)(V2), (int)(M)))
+
+/// Permutes 128-bit data values stored in two 256-bit integer vectors,
+///    as specified by the immediate integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256i _mm256_permute2f128_si256(__m256i V1, __m256i V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPERM2F128 </c> instruction.
+///
+/// \param V1
+///    A 256-bit integer vector.
+/// \param V2
+///    A 256-bit integer vector.
+/// \param M
+///    An immediate integer operand specifying how the values are to be copied.
+///    Bits [1:0]: \n
+///    00: Bits [127:0] of operand \a V1 are copied to bits [127:0] of the
+///    destination. \n
+///    01: Bits [255:128] of operand \a V1 are copied to bits [127:0] of the
+///    destination. \n
+///    10: Bits [127:0] of operand \a V2 are copied to bits [127:0] of the
+///    destination. \n
+///    11: Bits [255:128] of operand \a V2 are copied to bits [127:0] of the
+///    destination. \n
+///    Bits [5:4]: \n
+///    00: Bits [127:0] of operand \a V1 are copied to bits [255:128] of the
+///    destination. \n
+///    01: Bits [255:128] of operand \a V1 are copied to bits [255:128] of the
+///    destination. \n
+///    10: Bits [127:0] of operand \a V2 are copied to bits [255:128] of the
+///    destination. \n
+///    11: Bits [255:128] of operand \a V2 are copied to bits [255:128] of the
+///    destination.
+/// \returns A 256-bit integer vector containing the copied values.
+#define _mm256_permute2f128_si256(V1, V2, M) \
+  ((__m256i)__builtin_ia32_vperm2f128_si256((__v8si)(__m256i)(V1), \
+                                            (__v8si)(__m256i)(V2), (int)(M)))
+
+/* Vector Blend */
+/// Merges 64-bit double-precision data values stored in either of the
+///    two 256-bit vectors of [4 x double], as specified by the immediate
+///    integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256d _mm256_blend_pd(__m256d V1, __m256d V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VBLENDPD </c> instruction.
+///
+/// \param V1
+///    A 256-bit vector of [4 x double].
+/// \param V2
+///    A 256-bit vector of [4 x double].
+/// \param M
+///    An immediate integer operand, with mask bits [3:0] specifying how the
+///    values are to be copied. The position of the mask bit corresponds to the
+///    index of a copied value. When a mask bit is 0, the corresponding 64-bit
+///    element in operand \a V1 is copied to the same position in the
+///    destination. When a mask bit is 1, the corresponding 64-bit element in
+///    operand \a V2 is copied to the same position in the destination.
+/// \returns A 256-bit vector of [4 x double] containing the copied values.
+#define _mm256_blend_pd(V1, V2, M) \
+  ((__m256d)__builtin_ia32_blendpd256((__v4df)(__m256d)(V1), \
+                                      (__v4df)(__m256d)(V2), (int)(M)))
+
+/// Merges 32-bit single-precision data values stored in either of the
+///    two 256-bit vectors of [8 x float], as specified by the immediate
+///    integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256 _mm256_blend_ps(__m256 V1, __m256 V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VBLENDPS </c> instruction.
+///
+/// \param V1
+///    A 256-bit vector of [8 x float].
+/// \param V2
+///    A 256-bit vector of [8 x float].
+/// \param M
+///    An immediate integer operand, with mask bits [7:0] specifying how the
+///    values are to be copied. The position of the mask bit corresponds to the
+///    index of a copied value. When a mask bit is 0, the corresponding 32-bit
+///    element in operand \a V1 is copied to the same position in the
+///    destination. When a mask bit is 1, the corresponding 32-bit element in
+///    operand \a V2 is copied to the same position in the destination.
+/// \returns A 256-bit vector of [8 x float] containing the copied values.
+#define _mm256_blend_ps(V1, V2, M) \
+  ((__m256)__builtin_ia32_blendps256((__v8sf)(__m256)(V1), \
+                                     (__v8sf)(__m256)(V2), (int)(M)))
+
+/// Merges 64-bit double-precision data values stored in either of the
+///    two 256-bit vectors of [4 x double], as specified by the 256-bit vector
+///    operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBLENDVPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \param __b
+///    A 256-bit vector of [4 x double].
+/// \param __c
+///    A 256-bit vector operand, with mask bits 255, 191, 127, and 63 specifying
+///    how the values are to be copied. The position of the mask bit corresponds
+///    to the most significant bit of a copied value. When a mask bit is 0, the
+///    corresponding 64-bit element in operand \a __a is copied to the same
+///    position in the destination. When a mask bit is 1, the corresponding
+///    64-bit element in operand \a __b is copied to the same position in the
+///    destination.
+/// \returns A 256-bit vector of [4 x double] containing the copied values.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_blendv_pd(__m256d __a, __m256d __b, __m256d __c)
+{
+  return (__m256d)__builtin_ia32_blendvpd256(
+    (__v4df)__a, (__v4df)__b, (__v4df)__c);
+}
+
+/// Merges 32-bit single-precision data values stored in either of the
+///    two 256-bit vectors of [8 x float], as specified by the 256-bit vector
+///    operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBLENDVPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \param __b
+///    A 256-bit vector of [8 x float].
+/// \param __c
+///    A 256-bit vector operand, with mask bits 255, 223, 191, 159, 127, 95, 63,
+///    and 31 specifying how the values are to be copied. The position of the
+///    mask bit corresponds to the most significant bit of a copied value. When
+///    a mask bit is 0, the corresponding 32-bit element in operand \a __a is
+///    copied to the same position in the destination. When a mask bit is 1, the
+///    corresponding 32-bit element in operand \a __b is copied to the same
+///    position in the destination.
+/// \returns A 256-bit vector of [8 x float] containing the copied values.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_blendv_ps(__m256 __a, __m256 __b, __m256 __c)
+{
+  return (__m256)__builtin_ia32_blendvps256(
+    (__v8sf)__a, (__v8sf)__b, (__v8sf)__c);
+}
+
+/* Vector Dot Product */
+/// Computes two dot products in parallel, using the lower and upper
+///    halves of two [8 x float] vectors as input to the two computations, and
+///    returning the two dot products in the lower and upper halves of the
+///    [8 x float] result.
+///
+///    The immediate integer operand controls which input elements will
+///    contribute to the dot product, and where the final results are returned.
+///    In general, for each dot product, the four corresponding elements of the
+///    input vectors are multiplied; the first two and second two products are
+///    summed, then the two sums are added to form the final result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256 _mm256_dp_ps(__m256 V1, __m256 V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VDPPS </c> instruction.
+///
+/// \param V1
+///    A vector of [8 x float] values, treated as two [4 x float] vectors.
+/// \param V2
+///    A vector of [8 x float] values, treated as two [4 x float] vectors.
+/// \param M
+///    An immediate integer argument. Bits [7:4] determine which elements of
+///    the input vectors are used, with bit [4] corresponding to the lowest
+///    element and bit [7] corresponding to the highest element of each [4 x
+///    float] subvector. If a bit is set, the corresponding elements from the
+///    two input vectors are used as an input for dot product; otherwise that
+///    input is treated as zero. Bits [3:0] determine which elements of the
+///    result will receive a copy of the final dot product, with bit [0]
+///    corresponding to the lowest element and bit [3] corresponding to the
+///    highest element of each [4 x float] subvector. If a bit is set, the dot
+///    product is returned in the corresponding element; otherwise that element
+///    is set to zero. The bitmask is applied in the same way to each of the
+///    two parallel dot product computations.
+/// \returns A 256-bit vector of [8 x float] containing the two dot products.
+#define _mm256_dp_ps(V1, V2, M) \
+  ((__m256)__builtin_ia32_dpps256((__v8sf)(__m256)(V1), \
+                                  (__v8sf)(__m256)(V2), (M)))
+
+/* Vector shuffle */
+/// Selects 8 float values from the 256-bit operands of [8 x float], as
+///    specified by the immediate value operand.
+///
+///    The four selected elements in each operand are copied to the destination
+///    according to the bits specified in the immediate operand. The selected
+///    elements from the first 256-bit operand are copied to bits [63:0] and
+///    bits [191:128] of the destination, and the selected elements from the
+///    second 256-bit operand are copied to bits [127:64] and bits [255:192] of
+///    the destination. For example, if bits [7:0] of the immediate operand
+///    contain a value of 0xFF, the 256-bit destination vector would contain the
+///    following values: b[7], b[7], a[7], a[7], b[3], b[3], a[3], a[3].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256 _mm256_shuffle_ps(__m256 a, __m256 b, const int mask);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VSHUFPS </c> instruction.
+///
+/// \param a
+///    A 256-bit vector of [8 x float]. The four selected elements in this
+///    operand are copied to bits [63:0] and bits [191:128] in the destination,
+///    according to the bits specified in the immediate operand.
+/// \param b
+///    A 256-bit vector of [8 x float]. The four selected elements in this
+///    operand are copied to bits [127:64] and bits [255:192] in the
+///    destination, according to the bits specified in the immediate operand.
+/// \param mask
+///    An immediate value containing an 8-bit value specifying which elements to
+///    copy from \a a and \a b \n.
+///    Bits [3:0] specify the values copied from operand \a a. \n
+///    Bits [7:4] specify the values copied from operand \a b. \n
+///    The destinations within the 256-bit destination are assigned values as
+///    follows, according to the bit value assignments described below: \n
+///    Bits [1:0] are used to assign values to bits [31:0] and [159:128] in the
+///    destination. \n
+///    Bits [3:2] are used to assign values to bits [63:32] and [191:160] in the
+///    destination. \n
+///    Bits [5:4] are used to assign values to bits [95:64] and [223:192] in the
+///    destination. \n
+///    Bits [7:6] are used to assign values to bits [127:96] and [255:224] in
+///    the destination. \n
+///    Bit value assignments: \n
+///    00: Bits [31:0] and [159:128] are copied from the selected operand. \n
+///    01: Bits [63:32] and [191:160] are copied from the selected operand. \n
+///    10: Bits [95:64] and [223:192] are copied from the selected operand. \n
+///    11: Bits [127:96] and [255:224] are copied from the selected operand. \n
+///    Note: To generate a mask, you can use the \c _MM_SHUFFLE macro.
+///    <c>_MM_SHUFFLE(b6, b4, b2, b0)</c> can create an 8-bit mask of the form
+///    <c>[b6, b4, b2, b0]</c>.
+/// \returns A 256-bit vector of [8 x float] containing the shuffled values.
+#define _mm256_shuffle_ps(a, b, mask) \
+  ((__m256)__builtin_ia32_shufps256((__v8sf)(__m256)(a), \
+                                    (__v8sf)(__m256)(b), (int)(mask)))
+
+/// Selects four double-precision values from the 256-bit operands of
+///    [4 x double], as specified by the immediate value operand.
+///
+///    The selected elements from the first 256-bit operand are copied to bits
+///    [63:0] and bits [191:128] in the destination, and the selected elements
+///    from the second 256-bit operand are copied to bits [127:64] and bits
+///    [255:192] in the destination. For example, if bits [3:0] of the immediate
+///    operand contain a value of 0xF, the 256-bit destination vector would
+///    contain the following values: b[3], a[3], b[1], a[1].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256d _mm256_shuffle_pd(__m256d a, __m256d b, const int mask);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VSHUFPD </c> instruction.
+///
+/// \param a
+///    A 256-bit vector of [4 x double].
+/// \param b
+///    A 256-bit vector of [4 x double].
+/// \param mask
+///    An immediate value containing 8-bit values specifying which elements to
+///    copy from \a a and \a b: \n
+///    Bit [0]=0: Bits [63:0] are copied from \a a to bits [63:0] of the
+///    destination. \n
+///    Bit [0]=1: Bits [127:64] are copied from \a a to bits [63:0] of the
+///    destination. \n
+///    Bit [1]=0: Bits [63:0] are copied from \a b to bits [127:64] of the
+///    destination. \n
+///    Bit [1]=1: Bits [127:64] are copied from \a b to bits [127:64] of the
+///    destination. \n
+///    Bit [2]=0: Bits [191:128] are copied from \a a to bits [191:128] of the
+///    destination. \n
+///    Bit [2]=1: Bits [255:192] are copied from \a a to bits [191:128] of the
+///    destination. \n
+///    Bit [3]=0: Bits [191:128] are copied from \a b to bits [255:192] of the
+///    destination. \n
+///    Bit [3]=1: Bits [255:192] are copied from \a b to bits [255:192] of the
+///    destination.
+/// \returns A 256-bit vector of [4 x double] containing the shuffled values.
+#define _mm256_shuffle_pd(a, b, mask) \
+  ((__m256d)__builtin_ia32_shufpd256((__v4df)(__m256d)(a), \
+                                     (__v4df)(__m256d)(b), (int)(mask)))
+
+/* Compare */
+#define _CMP_EQ_UQ    0x08 /* Equal (unordered, non-signaling)  */
+#define _CMP_NGE_US   0x09 /* Not-greater-than-or-equal (unordered, signaling)  */
+#define _CMP_NGT_US   0x0a /* Not-greater-than (unordered, signaling)  */
+#define _CMP_FALSE_OQ 0x0b /* False (ordered, non-signaling)  */
+#define _CMP_NEQ_OQ   0x0c /* Not-equal (ordered, non-signaling)  */
+#define _CMP_GE_OS    0x0d /* Greater-than-or-equal (ordered, signaling)  */
+#define _CMP_GT_OS    0x0e /* Greater-than (ordered, signaling)  */
+#define _CMP_TRUE_UQ  0x0f /* True (unordered, non-signaling)  */
+#define _CMP_EQ_OS    0x10 /* Equal (ordered, signaling)  */
+#define _CMP_LT_OQ    0x11 /* Less-than (ordered, non-signaling)  */
+#define _CMP_LE_OQ    0x12 /* Less-than-or-equal (ordered, non-signaling)  */
+#define _CMP_UNORD_S  0x13 /* Unordered (signaling)  */
+#define _CMP_NEQ_US   0x14 /* Not-equal (unordered, signaling)  */
+#define _CMP_NLT_UQ   0x15 /* Not-less-than (unordered, non-signaling)  */
+#define _CMP_NLE_UQ   0x16 /* Not-less-than-or-equal (unordered, non-signaling)  */
+#define _CMP_ORD_S    0x17 /* Ordered (signaling)  */
+#define _CMP_EQ_US    0x18 /* Equal (unordered, signaling)  */
+#define _CMP_NGE_UQ   0x19 /* Not-greater-than-or-equal (unordered, non-signaling)  */
+#define _CMP_NGT_UQ   0x1a /* Not-greater-than (unordered, non-signaling)  */
+#define _CMP_FALSE_OS 0x1b /* False (ordered, signaling)  */
+#define _CMP_NEQ_OS   0x1c /* Not-equal (ordered, signaling)  */
+#define _CMP_GE_OQ    0x1d /* Greater-than-or-equal (ordered, non-signaling)  */
+#define _CMP_GT_OQ    0x1e /* Greater-than (ordered, non-signaling)  */
+#define _CMP_TRUE_US  0x1f /* True (unordered, signaling)  */
+
+/* Below intrinsic defined in emmintrin.h can be used for AVX */
+/// Compares each of the corresponding double-precision values of two
+///    128-bit vectors of [2 x double], using the operation specified by the
+///    immediate integer operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, comparisons that are ordered
+///    return false, and comparisons that are unordered return true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_cmp_pd(__m128d a, __m128d b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VCMPPD </c> instruction.
+///
+/// \param a
+///    A 128-bit vector of [2 x double].
+/// \param b
+///    A 128-bit vector of [2 x double].
+/// \param c
+///    An immediate integer operand, with bits [4:0] specifying which comparison
+///    operation to use: \n
+///    0x00: Equal (ordered, non-signaling) \n
+///    0x01: Less-than (ordered, signaling) \n
+///    0x02: Less-than-or-equal (ordered, signaling) \n
+///    0x03: Unordered (non-signaling) \n
+///    0x04: Not-equal (unordered, non-signaling) \n
+///    0x05: Not-less-than (unordered, signaling) \n
+///    0x06: Not-less-than-or-equal (unordered, signaling) \n
+///    0x07: Ordered (non-signaling) \n
+///    0x08: Equal (unordered, non-signaling) \n
+///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
+///    0x0A: Not-greater-than (unordered, signaling) \n
+///    0x0B: False (ordered, non-signaling) \n
+///    0x0C: Not-equal (ordered, non-signaling) \n
+///    0x0D: Greater-than-or-equal (ordered, signaling) \n
+///    0x0E: Greater-than (ordered, signaling) \n
+///    0x0F: True (unordered, non-signaling) \n
+///    0x10: Equal (ordered, signaling) \n
+///    0x11: Less-than (ordered, non-signaling) \n
+///    0x12: Less-than-or-equal (ordered, non-signaling) \n
+///    0x13: Unordered (signaling) \n
+///    0x14: Not-equal (unordered, signaling) \n
+///    0x15: Not-less-than (unordered, non-signaling) \n
+///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
+///    0x17: Ordered (signaling) \n
+///    0x18: Equal (unordered, signaling) \n
+///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    0x1A: Not-greater-than (unordered, non-signaling) \n
+///    0x1B: False (ordered, signaling) \n
+///    0x1C: Not-equal (ordered, signaling) \n
+///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
+///    0x1E: Greater-than (ordered, non-signaling) \n
+///    0x1F: True (unordered, signaling)
+/// \returns A 128-bit vector of [2 x double] containing the comparison results.
+/// \fn __m128d _mm_cmp_pd(__m128d a, __m128d b, const int c)
+
+/* Below intrinsic defined in xmmintrin.h can be used for AVX */
+/// Compares each of the corresponding values of two 128-bit vectors of
+///    [4 x float], using the operation specified by the immediate integer
+///    operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, comparisons that are ordered
+///    return false, and comparisons that are unordered return true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_cmp_ps(__m128 a, __m128 b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VCMPPS </c> instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x float].
+/// \param b
+///    A 128-bit vector of [4 x float].
+/// \param c
+///    An immediate integer operand, with bits [4:0] specifying which comparison
+///    operation to use: \n
+///    0x00: Equal (ordered, non-signaling) \n
+///    0x01: Less-than (ordered, signaling) \n
+///    0x02: Less-than-or-equal (ordered, signaling) \n
+///    0x03: Unordered (non-signaling) \n
+///    0x04: Not-equal (unordered, non-signaling) \n
+///    0x05: Not-less-than (unordered, signaling) \n
+///    0x06: Not-less-than-or-equal (unordered, signaling) \n
+///    0x07: Ordered (non-signaling) \n
+///    0x08: Equal (unordered, non-signaling) \n
+///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
+///    0x0A: Not-greater-than (unordered, signaling) \n
+///    0x0B: False (ordered, non-signaling) \n
+///    0x0C: Not-equal (ordered, non-signaling) \n
+///    0x0D: Greater-than-or-equal (ordered, signaling) \n
+///    0x0E: Greater-than (ordered, signaling) \n
+///    0x0F: True (unordered, non-signaling) \n
+///    0x10: Equal (ordered, signaling) \n
+///    0x11: Less-than (ordered, non-signaling) \n
+///    0x12: Less-than-or-equal (ordered, non-signaling) \n
+///    0x13: Unordered (signaling) \n
+///    0x14: Not-equal (unordered, signaling) \n
+///    0x15: Not-less-than (unordered, non-signaling) \n
+///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
+///    0x17: Ordered (signaling) \n
+///    0x18: Equal (unordered, signaling) \n
+///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    0x1A: Not-greater-than (unordered, non-signaling) \n
+///    0x1B: False (ordered, signaling) \n
+///    0x1C: Not-equal (ordered, signaling) \n
+///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
+///    0x1E: Greater-than (ordered, non-signaling) \n
+///    0x1F: True (unordered, signaling)
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+/// \fn __m128 _mm_cmp_ps(__m128 a, __m128 b, const int c)
+
+/// Compares each of the corresponding double-precision values of two
+///    256-bit vectors of [4 x double], using the operation specified by the
+///    immediate integer operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, comparisons that are ordered
+///    return false, and comparisons that are unordered return true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256d _mm256_cmp_pd(__m256d a, __m256d b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VCMPPD </c> instruction.
+///
+/// \param a
+///    A 256-bit vector of [4 x double].
+/// \param b
+///    A 256-bit vector of [4 x double].
+/// \param c
+///    An immediate integer operand, with bits [4:0] specifying which comparison
+///    operation to use: \n
+///    0x00: Equal (ordered, non-signaling) \n
+///    0x01: Less-than (ordered, signaling) \n
+///    0x02: Less-than-or-equal (ordered, signaling) \n
+///    0x03: Unordered (non-signaling) \n
+///    0x04: Not-equal (unordered, non-signaling) \n
+///    0x05: Not-less-than (unordered, signaling) \n
+///    0x06: Not-less-than-or-equal (unordered, signaling) \n
+///    0x07: Ordered (non-signaling) \n
+///    0x08: Equal (unordered, non-signaling) \n
+///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
+///    0x0A: Not-greater-than (unordered, signaling) \n
+///    0x0B: False (ordered, non-signaling) \n
+///    0x0C: Not-equal (ordered, non-signaling) \n
+///    0x0D: Greater-than-or-equal (ordered, signaling) \n
+///    0x0E: Greater-than (ordered, signaling) \n
+///    0x0F: True (unordered, non-signaling) \n
+///    0x10: Equal (ordered, signaling) \n
+///    0x11: Less-than (ordered, non-signaling) \n
+///    0x12: Less-than-or-equal (ordered, non-signaling) \n
+///    0x13: Unordered (signaling) \n
+///    0x14: Not-equal (unordered, signaling) \n
+///    0x15: Not-less-than (unordered, non-signaling) \n
+///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
+///    0x17: Ordered (signaling) \n
+///    0x18: Equal (unordered, signaling) \n
+///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    0x1A: Not-greater-than (unordered, non-signaling) \n
+///    0x1B: False (ordered, signaling) \n
+///    0x1C: Not-equal (ordered, signaling) \n
+///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
+///    0x1E: Greater-than (ordered, non-signaling) \n
+///    0x1F: True (unordered, signaling)
+/// \returns A 256-bit vector of [4 x double] containing the comparison results.
+#define _mm256_cmp_pd(a, b, c) \
+  ((__m256d)__builtin_ia32_cmppd256((__v4df)(__m256d)(a), \
+                                    (__v4df)(__m256d)(b), (c)))
+
+/// Compares each of the corresponding values of two 256-bit vectors of
+///    [8 x float], using the operation specified by the immediate integer
+///    operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, comparisons that are ordered
+///    return false, and comparisons that are unordered return true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256 _mm256_cmp_ps(__m256 a, __m256 b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VCMPPS </c> instruction.
+///
+/// \param a
+///    A 256-bit vector of [8 x float].
+/// \param b
+///    A 256-bit vector of [8 x float].
+/// \param c
+///    An immediate integer operand, with bits [4:0] specifying which comparison
+///    operation to use: \n
+///    0x00: Equal (ordered, non-signaling) \n
+///    0x01: Less-than (ordered, signaling) \n
+///    0x02: Less-than-or-equal (ordered, signaling) \n
+///    0x03: Unordered (non-signaling) \n
+///    0x04: Not-equal (unordered, non-signaling) \n
+///    0x05: Not-less-than (unordered, signaling) \n
+///    0x06: Not-less-than-or-equal (unordered, signaling) \n
+///    0x07: Ordered (non-signaling) \n
+///    0x08: Equal (unordered, non-signaling) \n
+///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
+///    0x0A: Not-greater-than (unordered, signaling) \n
+///    0x0B: False (ordered, non-signaling) \n
+///    0x0C: Not-equal (ordered, non-signaling) \n
+///    0x0D: Greater-than-or-equal (ordered, signaling) \n
+///    0x0E: Greater-than (ordered, signaling) \n
+///    0x0F: True (unordered, non-signaling) \n
+///    0x10: Equal (ordered, signaling) \n
+///    0x11: Less-than (ordered, non-signaling) \n
+///    0x12: Less-than-or-equal (ordered, non-signaling) \n
+///    0x13: Unordered (signaling) \n
+///    0x14: Not-equal (unordered, signaling) \n
+///    0x15: Not-less-than (unordered, non-signaling) \n
+///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
+///    0x17: Ordered (signaling) \n
+///    0x18: Equal (unordered, signaling) \n
+///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    0x1A: Not-greater-than (unordered, non-signaling) \n
+///    0x1B: False (ordered, signaling) \n
+///    0x1C: Not-equal (ordered, signaling) \n
+///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
+///    0x1E: Greater-than (ordered, non-signaling) \n
+///    0x1F: True (unordered, signaling)
+/// \returns A 256-bit vector of [8 x float] containing the comparison results.
+#define _mm256_cmp_ps(a, b, c) \
+  ((__m256)__builtin_ia32_cmpps256((__v8sf)(__m256)(a), \
+                                   (__v8sf)(__m256)(b), (c)))
+
+/* Below intrinsic defined in emmintrin.h can be used for AVX */
+/// Compares each of the corresponding scalar double-precision values of
+///    two 128-bit vectors of [2 x double], using the operation specified by the
+///    immediate integer operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, comparisons that are ordered
+///    return false, and comparisons that are unordered return true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_cmp_sd(__m128d a, __m128d b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VCMPSD </c> instruction.
+///
+/// \param a
+///    A 128-bit vector of [2 x double].
+/// \param b
+///    A 128-bit vector of [2 x double].
+/// \param c
+///    An immediate integer operand, with bits [4:0] specifying which comparison
+///    operation to use: \n
+///    0x00: Equal (ordered, non-signaling) \n
+///    0x01: Less-than (ordered, signaling) \n
+///    0x02: Less-than-or-equal (ordered, signaling) \n
+///    0x03: Unordered (non-signaling) \n
+///    0x04: Not-equal (unordered, non-signaling) \n
+///    0x05: Not-less-than (unordered, signaling) \n
+///    0x06: Not-less-than-or-equal (unordered, signaling) \n
+///    0x07: Ordered (non-signaling) \n
+///    0x08: Equal (unordered, non-signaling) \n
+///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
+///    0x0A: Not-greater-than (unordered, signaling) \n
+///    0x0B: False (ordered, non-signaling) \n
+///    0x0C: Not-equal (ordered, non-signaling) \n
+///    0x0D: Greater-than-or-equal (ordered, signaling) \n
+///    0x0E: Greater-than (ordered, signaling) \n
+///    0x0F: True (unordered, non-signaling) \n
+///    0x10: Equal (ordered, signaling) \n
+///    0x11: Less-than (ordered, non-signaling) \n
+///    0x12: Less-than-or-equal (ordered, non-signaling) \n
+///    0x13: Unordered (signaling) \n
+///    0x14: Not-equal (unordered, signaling) \n
+///    0x15: Not-less-than (unordered, non-signaling) \n
+///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
+///    0x17: Ordered (signaling) \n
+///    0x18: Equal (unordered, signaling) \n
+///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    0x1A: Not-greater-than (unordered, non-signaling) \n
+///    0x1B: False (ordered, signaling) \n
+///    0x1C: Not-equal (ordered, signaling) \n
+///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
+///    0x1E: Greater-than (ordered, non-signaling) \n
+///    0x1F: True (unordered, signaling)
+/// \returns A 128-bit vector of [2 x double] containing the comparison results.
+/// \fn __m128d _mm_cmp_sd(__m128d a, __m128d b, const int c)
+
+/* Below intrinsic defined in xmmintrin.h can be used for AVX */
+/// Compares each of the corresponding scalar values of two 128-bit
+///    vectors of [4 x float], using the operation specified by the immediate
+///    integer operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, comparisons that are ordered
+///    return false, and comparisons that are unordered return true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_cmp_ss(__m128 a, __m128 b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VCMPSS </c> instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x float].
+/// \param b
+///    A 128-bit vector of [4 x float].
+/// \param c
+///    An immediate integer operand, with bits [4:0] specifying which comparison
+///    operation to use: \n
+///    0x00: Equal (ordered, non-signaling) \n
+///    0x01: Less-than (ordered, signaling) \n
+///    0x02: Less-than-or-equal (ordered, signaling) \n
+///    0x03: Unordered (non-signaling) \n
+///    0x04: Not-equal (unordered, non-signaling) \n
+///    0x05: Not-less-than (unordered, signaling) \n
+///    0x06: Not-less-than-or-equal (unordered, signaling) \n
+///    0x07: Ordered (non-signaling) \n
+///    0x08: Equal (unordered, non-signaling) \n
+///    0x09: Not-greater-than-or-equal (unordered, signaling) \n
+///    0x0A: Not-greater-than (unordered, signaling) \n
+///    0x0B: False (ordered, non-signaling) \n
+///    0x0C: Not-equal (ordered, non-signaling) \n
+///    0x0D: Greater-than-or-equal (ordered, signaling) \n
+///    0x0E: Greater-than (ordered, signaling) \n
+///    0x0F: True (unordered, non-signaling) \n
+///    0x10: Equal (ordered, signaling) \n
+///    0x11: Less-than (ordered, non-signaling) \n
+///    0x12: Less-than-or-equal (ordered, non-signaling) \n
+///    0x13: Unordered (signaling) \n
+///    0x14: Not-equal (unordered, signaling) \n
+///    0x15: Not-less-than (unordered, non-signaling) \n
+///    0x16: Not-less-than-or-equal (unordered, non-signaling) \n
+///    0x17: Ordered (signaling) \n
+///    0x18: Equal (unordered, signaling) \n
+///    0x19: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    0x1A: Not-greater-than (unordered, non-signaling) \n
+///    0x1B: False (ordered, signaling) \n
+///    0x1C: Not-equal (ordered, signaling) \n
+///    0x1D: Greater-than-or-equal (ordered, non-signaling) \n
+///    0x1E: Greater-than (ordered, non-signaling) \n
+///    0x1F: True (unordered, signaling)
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+/// \fn __m128 _mm_cmp_ss(__m128 a, __m128 b, const int c)
+
+/// Takes a [8 x i32] vector and returns the vector element value
+///    indexed by the immediate constant operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm256_extract_epi32(__m256i X, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VEXTRACTF128+COMPOSITE </c>
+///   instruction.
+///
+/// \param X
+///    A 256-bit vector of [8 x i32].
+/// \param N
+///    An immediate integer operand with bits [2:0] determining which vector
+///    element is extracted and returned.
+/// \returns A 32-bit integer containing the extracted 32 bits of extended
+///    packed data.
+#define _mm256_extract_epi32(X, N) \
+  ((int)__builtin_ia32_vec_ext_v8si((__v8si)(__m256i)(X), (int)(N)))
+
+/// Takes a [16 x i16] vector and returns the vector element value
+///    indexed by the immediate constant operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm256_extract_epi16(__m256i X, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VEXTRACTF128+COMPOSITE </c>
+///   instruction.
+///
+/// \param X
+///    A 256-bit integer vector of [16 x i16].
+/// \param N
+///    An immediate integer operand with bits [3:0] determining which vector
+///    element is extracted and returned.
+/// \returns A 32-bit integer containing the extracted 16 bits of zero extended
+///    packed data.
+#define _mm256_extract_epi16(X, N) \
+  ((int)(unsigned short)__builtin_ia32_vec_ext_v16hi((__v16hi)(__m256i)(X), \
+                                                     (int)(N)))
+
+/// Takes a [32 x i8] vector and returns the vector element value
+///    indexed by the immediate constant operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm256_extract_epi8(__m256i X, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VEXTRACTF128+COMPOSITE </c>
+///   instruction.
+///
+/// \param X
+///    A 256-bit integer vector of [32 x i8].
+/// \param N
+///    An immediate integer operand with bits [4:0] determining which vector
+///    element is extracted and returned.
+/// \returns A 32-bit integer containing the extracted 8 bits of zero extended
+///    packed data.
+#define _mm256_extract_epi8(X, N) \
+  ((int)(unsigned char)__builtin_ia32_vec_ext_v32qi((__v32qi)(__m256i)(X), \
+                                                    (int)(N)))
+
+#ifdef __x86_64__
+/// Takes a [4 x i64] vector and returns the vector element value
+///    indexed by the immediate constant operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// long long _mm256_extract_epi64(__m256i X, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VEXTRACTF128+COMPOSITE </c>
+///   instruction.
+///
+/// \param X
+///    A 256-bit integer vector of [4 x i64].
+/// \param N
+///    An immediate integer operand with bits [1:0] determining which vector
+///    element is extracted and returned.
+/// \returns A 64-bit integer containing the extracted 64 bits of extended
+///    packed data.
+#define _mm256_extract_epi64(X, N) \
+  ((long long)__builtin_ia32_vec_ext_v4di((__v4di)(__m256i)(X), (int)(N)))
+#endif
+
+/// Takes a [8 x i32] vector and replaces the vector element value
+///    indexed by the immediate constant operand by a new value. Returns the
+///    modified vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256i _mm256_insert_epi32(__m256i X, int I, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VINSERTF128+COMPOSITE </c>
+///   instruction.
+///
+/// \param X
+///    A vector of [8 x i32] to be used by the insert operation.
+/// \param I
+///    An integer value. The replacement value for the insert operation.
+/// \param N
+///    An immediate integer specifying the index of the vector element to be
+///    replaced.
+/// \returns A copy of vector \a X, after replacing its element indexed by
+///    \a N with \a I.
+#define _mm256_insert_epi32(X, I, N) \
+  ((__m256i)__builtin_ia32_vec_set_v8si((__v8si)(__m256i)(X), \
+                                        (int)(I), (int)(N)))
+
+
+/// Takes a [16 x i16] vector and replaces the vector element value
+///    indexed by the immediate constant operand with a new value. Returns the
+///    modified vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256i _mm256_insert_epi16(__m256i X, int I, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VINSERTF128+COMPOSITE </c>
+///   instruction.
+///
+/// \param X
+///    A vector of [16 x i16] to be used by the insert operation.
+/// \param I
+///    An i16 integer value. The replacement value for the insert operation.
+/// \param N
+///    An immediate integer specifying the index of the vector element to be
+///    replaced.
+/// \returns A copy of vector \a X, after replacing its element indexed by
+///    \a N with \a I.
+#define _mm256_insert_epi16(X, I, N) \
+  ((__m256i)__builtin_ia32_vec_set_v16hi((__v16hi)(__m256i)(X), \
+                                         (int)(I), (int)(N)))
+
+/// Takes a [32 x i8] vector and replaces the vector element value
+///    indexed by the immediate constant operand with a new value. Returns the
+///    modified vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256i _mm256_insert_epi8(__m256i X, int I, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VINSERTF128+COMPOSITE </c>
+///   instruction.
+///
+/// \param X
+///    A vector of [32 x i8] to be used by the insert operation.
+/// \param I
+///    An i8 integer value. The replacement value for the insert operation.
+/// \param N
+///    An immediate integer specifying the index of the vector element to be
+///    replaced.
+/// \returns A copy of vector \a X, after replacing its element indexed by
+///    \a N with \a I.
+#define _mm256_insert_epi8(X, I, N) \
+  ((__m256i)__builtin_ia32_vec_set_v32qi((__v32qi)(__m256i)(X), \
+                                         (int)(I), (int)(N)))
+
+#ifdef __x86_64__
+/// Takes a [4 x i64] vector and replaces the vector element value
+///    indexed by the immediate constant operand with a new value. Returns the
+///    modified vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256i _mm256_insert_epi64(__m256i X, int I, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VINSERTF128+COMPOSITE </c>
+///   instruction.
+///
+/// \param X
+///    A vector of [4 x i64] to be used by the insert operation.
+/// \param I
+///    A 64-bit integer value. The replacement value for the insert operation.
+/// \param N
+///    An immediate integer specifying the index of the vector element to be
+///    replaced.
+/// \returns A copy of vector \a X, after replacing its element indexed by
+///     \a N with \a I.
+#define _mm256_insert_epi64(X, I, N) \
+  ((__m256i)__builtin_ia32_vec_set_v4di((__v4di)(__m256i)(X), \
+                                        (long long)(I), (int)(N)))
+#endif
+
+/* Conversion */
+/// Converts a vector of [4 x i32] into a vector of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTDQ2PD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector of [4 x i32].
+/// \returns A 256-bit vector of [4 x double] containing the converted values.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_cvtepi32_pd(__m128i __a)
+{
+  return (__m256d)__builtin_convertvector((__v4si)__a, __v4df);
+}
+
+/// Converts a vector of [8 x i32] into a vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTDQ2PS </c> instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \returns A 256-bit vector of [8 x float] containing the converted values.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_cvtepi32_ps(__m256i __a)
+{
+  return (__m256)__builtin_convertvector((__v8si)__a, __v8sf);
+}
+
+/// Converts a 256-bit vector of [4 x double] into a 128-bit vector of
+///    [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPD2PS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \returns A 128-bit vector of [4 x float] containing the converted values.
+static __inline __m128 __DEFAULT_FN_ATTRS
+_mm256_cvtpd_ps(__m256d __a)
+{
+  return (__m128)__builtin_ia32_cvtpd2ps256((__v4df) __a);
+}
+
+/// Converts a vector of [8 x float] into a vector of [8 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPS2DQ </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \returns A 256-bit integer vector containing the converted values.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_cvtps_epi32(__m256 __a)
+{
+  return (__m256i)__builtin_ia32_cvtps2dq256((__v8sf) __a);
+}
+
+/// Converts a 128-bit vector of [4 x float] into a 256-bit vector of [4
+///    x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPS2PD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 256-bit vector of [4 x double] containing the converted values.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_cvtps_pd(__m128 __a)
+{
+  return (__m256d)__builtin_convertvector((__v4sf)__a, __v4df);
+}
+
+/// Converts a 256-bit vector of [4 x double] into four signed truncated
+///    (rounded toward zero) 32-bit integers returned in a 128-bit vector of
+///    [4 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTTPD2DQ </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \returns A 128-bit integer vector containing the converted values.
+static __inline __m128i __DEFAULT_FN_ATTRS
+_mm256_cvttpd_epi32(__m256d __a)
+{
+  return (__m128i)__builtin_ia32_cvttpd2dq256((__v4df) __a);
+}
+
+/// Converts a 256-bit vector of [4 x double] into a 128-bit vector of
+///    [4 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPD2DQ </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \returns A 128-bit integer vector containing the converted values.
+static __inline __m128i __DEFAULT_FN_ATTRS
+_mm256_cvtpd_epi32(__m256d __a)
+{
+  return (__m128i)__builtin_ia32_cvtpd2dq256((__v4df) __a);
+}
+
+/// Converts a vector of [8 x float] into eight signed truncated (rounded
+///    toward zero) 32-bit integers returned in a vector of [8 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTTPS2DQ </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \returns A 256-bit integer vector containing the converted values.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_cvttps_epi32(__m256 __a)
+{
+  return (__m256i)__builtin_ia32_cvttps2dq256((__v8sf) __a);
+}
+
+/// Returns the first element of the input vector of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \returns A 64 bit double containing the first element of the input vector.
+static __inline double __DEFAULT_FN_ATTRS
+_mm256_cvtsd_f64(__m256d __a)
+{
+ return __a[0];
+}
+
+/// Returns the first element of the input vector of [8 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x i32].
+/// \returns A 32 bit integer containing the first element of the input vector.
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_cvtsi256_si32(__m256i __a)
+{
+ __v8si __b = (__v8si)__a;
+ return __b[0];
+}
+
+/// Returns the first element of the input vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \returns A 32 bit float containing the first element of the input vector.
+static __inline float __DEFAULT_FN_ATTRS
+_mm256_cvtss_f32(__m256 __a)
+{
+ return __a[0];
+}
+
+/* Vector replicate */
+/// Moves and duplicates odd-indexed values from a 256-bit vector of
+///    [8 x float] to float values in a 256-bit vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVSHDUP </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float]. \n
+///    Bits [255:224] of \a __a are written to bits [255:224] and [223:192] of
+///    the return value. \n
+///    Bits [191:160] of \a __a are written to bits [191:160] and [159:128] of
+///    the return value. \n
+///    Bits [127:96] of \a __a are written to bits [127:96] and [95:64] of the
+///    return value. \n
+///    Bits [63:32] of \a __a are written to bits [63:32] and [31:0] of the
+///    return value.
+/// \returns A 256-bit vector of [8 x float] containing the moved and duplicated
+///    values.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_movehdup_ps(__m256 __a)
+{
+  return __builtin_shufflevector((__v8sf)__a, (__v8sf)__a, 1, 1, 3, 3, 5, 5, 7, 7);
+}
+
+/// Moves and duplicates even-indexed values from a 256-bit vector of
+///    [8 x float] to float values in a 256-bit vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVSLDUP </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float]. \n
+///    Bits [223:192] of \a __a are written to bits [255:224] and [223:192] of
+///    the return value. \n
+///    Bits [159:128] of \a __a are written to bits [191:160] and [159:128] of
+///    the return value. \n
+///    Bits [95:64] of \a __a are written to bits [127:96] and [95:64] of the
+///    return value. \n
+///    Bits [31:0] of \a __a are written to bits [63:32] and [31:0] of the
+///    return value.
+/// \returns A 256-bit vector of [8 x float] containing the moved and duplicated
+///    values.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_moveldup_ps(__m256 __a)
+{
+  return __builtin_shufflevector((__v8sf)__a, (__v8sf)__a, 0, 0, 2, 2, 4, 4, 6, 6);
+}
+
+/// Moves and duplicates double-precision floating point values from a
+///    256-bit vector of [4 x double] to double-precision values in a 256-bit
+///    vector of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDDUP </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double]. \n
+///    Bits [63:0] of \a __a are written to bits [127:64] and [63:0] of the
+///    return value. \n
+///    Bits [191:128] of \a __a are written to bits [255:192] and [191:128] of
+///    the return value.
+/// \returns A 256-bit vector of [4 x double] containing the moved and
+///    duplicated values.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_movedup_pd(__m256d __a)
+{
+  return __builtin_shufflevector((__v4df)__a, (__v4df)__a, 0, 0, 2, 2);
+}
+
+/* Unpack and Interleave */
+/// Unpacks the odd-indexed vector elements from two 256-bit vectors of
+///    [4 x double] and interleaves them into a 256-bit vector of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKHPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit floating-point vector of [4 x double]. \n
+///    Bits [127:64] are written to bits [63:0] of the return value. \n
+///    Bits [255:192] are written to bits [191:128] of the return value. \n
+/// \param __b
+///    A 256-bit floating-point vector of [4 x double]. \n
+///    Bits [127:64] are written to bits [127:64] of the return value. \n
+///    Bits [255:192] are written to bits [255:192] of the return value. \n
+/// \returns A 256-bit vector of [4 x double] containing the interleaved values.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_unpackhi_pd(__m256d __a, __m256d __b)
+{
+  return __builtin_shufflevector((__v4df)__a, (__v4df)__b, 1, 5, 1+2, 5+2);
+}
+
+/// Unpacks the even-indexed vector elements from two 256-bit vectors of
+///    [4 x double] and interleaves them into a 256-bit vector of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKLPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit floating-point vector of [4 x double]. \n
+///    Bits [63:0] are written to bits [63:0] of the return value. \n
+///    Bits [191:128] are written to bits [191:128] of the return value.
+/// \param __b
+///    A 256-bit floating-point vector of [4 x double]. \n
+///    Bits [63:0] are written to bits [127:64] of the return value. \n
+///    Bits [191:128] are written to bits [255:192] of the return value. \n
+/// \returns A 256-bit vector of [4 x double] containing the interleaved values.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_unpacklo_pd(__m256d __a, __m256d __b)
+{
+  return __builtin_shufflevector((__v4df)__a, (__v4df)__b, 0, 4, 0+2, 4+2);
+}
+
+/// Unpacks the 32-bit vector elements 2, 3, 6 and 7 from each of the
+///    two 256-bit vectors of [8 x float] and interleaves them into a 256-bit
+///    vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKHPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float]. \n
+///    Bits [95:64] are written to bits [31:0] of the return value. \n
+///    Bits [127:96] are written to bits [95:64] of the return value. \n
+///    Bits [223:192] are written to bits [159:128] of the return value. \n
+///    Bits [255:224] are written to bits [223:192] of the return value.
+/// \param __b
+///    A 256-bit vector of [8 x float]. \n
+///    Bits [95:64] are written to bits [63:32] of the return value. \n
+///    Bits [127:96] are written to bits [127:96] of the return value. \n
+///    Bits [223:192] are written to bits [191:160] of the return value. \n
+///    Bits [255:224] are written to bits [255:224] of the return value.
+/// \returns A 256-bit vector of [8 x float] containing the interleaved values.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_unpackhi_ps(__m256 __a, __m256 __b)
+{
+  return __builtin_shufflevector((__v8sf)__a, (__v8sf)__b, 2, 10, 2+1, 10+1, 6, 14, 6+1, 14+1);
+}
+
+/// Unpacks the 32-bit vector elements 0, 1, 4 and 5 from each of the
+///    two 256-bit vectors of [8 x float] and interleaves them into a 256-bit
+///    vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKLPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float]. \n
+///    Bits [31:0] are written to bits [31:0] of the return value. \n
+///    Bits [63:32] are written to bits [95:64] of the return value. \n
+///    Bits [159:128] are written to bits [159:128] of the return value. \n
+///    Bits [191:160] are written to bits [223:192] of the return value.
+/// \param __b
+///    A 256-bit vector of [8 x float]. \n
+///    Bits [31:0] are written to bits [63:32] of the return value. \n
+///    Bits [63:32] are written to bits [127:96] of the return value. \n
+///    Bits [159:128] are written to bits [191:160] of the return value. \n
+///    Bits [191:160] are written to bits [255:224] of the return value.
+/// \returns A 256-bit vector of [8 x float] containing the interleaved values.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_unpacklo_ps(__m256 __a, __m256 __b)
+{
+  return __builtin_shufflevector((__v8sf)__a, (__v8sf)__b, 0, 8, 0+1, 8+1, 4, 12, 4+1, 12+1);
+}
+
+/* Bit Test */
+/// Given two 128-bit floating-point vectors of [2 x double], perform an
+///    element-by-element comparison of the double-precision element in the
+///    first source vector and the corresponding element in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns the value of the ZF flag.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns the ZF flag in the EFLAGS register.
+static __inline int __DEFAULT_FN_ATTRS128
+_mm_testz_pd(__m128d __a, __m128d __b)
+{
+  return __builtin_ia32_vtestzpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Given two 128-bit floating-point vectors of [2 x double], perform an
+///    element-by-element comparison of the double-precision element in the
+///    first source vector and the corresponding element in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns the value of the CF flag.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns the CF flag in the EFLAGS register.
+static __inline int __DEFAULT_FN_ATTRS128
+_mm_testc_pd(__m128d __a, __m128d __b)
+{
+  return __builtin_ia32_vtestcpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Given two 128-bit floating-point vectors of [2 x double], perform an
+///    element-by-element comparison of the double-precision element in the
+///    first source vector and the corresponding element in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns 1 if both the ZF and CF flags are set to 0,
+///    otherwise it returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns 1 if both the ZF and CF flags are set to 0, otherwise returns 0.
+static __inline int __DEFAULT_FN_ATTRS128
+_mm_testnzc_pd(__m128d __a, __m128d __b)
+{
+  return __builtin_ia32_vtestnzcpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Given two 128-bit floating-point vectors of [4 x float], perform an
+///    element-by-element comparison of the single-precision element in the
+///    first source vector and the corresponding element in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns the value of the ZF flag.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns the ZF flag.
+static __inline int __DEFAULT_FN_ATTRS128
+_mm_testz_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_vtestzps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Given two 128-bit floating-point vectors of [4 x float], perform an
+///    element-by-element comparison of the single-precision element in the
+///    first source vector and the corresponding element in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns the value of the CF flag.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns the CF flag.
+static __inline int __DEFAULT_FN_ATTRS128
+_mm_testc_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_vtestcps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Given two 128-bit floating-point vectors of [4 x float], perform an
+///    element-by-element comparison of the single-precision element in the
+///    first source vector and the corresponding element in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns 1 if both the ZF and CF flags are set to 0,
+///    otherwise it returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns 1 if both the ZF and CF flags are set to 0, otherwise returns 0.
+static __inline int __DEFAULT_FN_ATTRS128
+_mm_testnzc_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_vtestnzcps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Given two 256-bit floating-point vectors of [4 x double], perform an
+///    element-by-element comparison of the double-precision elements in the
+///    first source vector and the corresponding elements in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns the value of the ZF flag.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \param __b
+///    A 256-bit vector of [4 x double].
+/// \returns the ZF flag.
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_testz_pd(__m256d __a, __m256d __b)
+{
+  return __builtin_ia32_vtestzpd256((__v4df)__a, (__v4df)__b);
+}
+
+/// Given two 256-bit floating-point vectors of [4 x double], perform an
+///    element-by-element comparison of the double-precision elements in the
+///    first source vector and the corresponding elements in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns the value of the CF flag.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \param __b
+///    A 256-bit vector of [4 x double].
+/// \returns the CF flag.
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_testc_pd(__m256d __a, __m256d __b)
+{
+  return __builtin_ia32_vtestcpd256((__v4df)__a, (__v4df)__b);
+}
+
+/// Given two 256-bit floating-point vectors of [4 x double], perform an
+///    element-by-element comparison of the double-precision elements in the
+///    first source vector and the corresponding elements in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of double-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns 1 if both the ZF and CF flags are set to 0,
+///    otherwise it returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double].
+/// \param __b
+///    A 256-bit vector of [4 x double].
+/// \returns 1 if both the ZF and CF flags are set to 0, otherwise returns 0.
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_testnzc_pd(__m256d __a, __m256d __b)
+{
+  return __builtin_ia32_vtestnzcpd256((__v4df)__a, (__v4df)__b);
+}
+
+/// Given two 256-bit floating-point vectors of [8 x float], perform an
+///    element-by-element comparison of the single-precision element in the
+///    first source vector and the corresponding element in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns the value of the ZF flag.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \param __b
+///    A 256-bit vector of [8 x float].
+/// \returns the ZF flag.
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_testz_ps(__m256 __a, __m256 __b)
+{
+  return __builtin_ia32_vtestzps256((__v8sf)__a, (__v8sf)__b);
+}
+
+/// Given two 256-bit floating-point vectors of [8 x float], perform an
+///    element-by-element comparison of the single-precision element in the
+///    first source vector and the corresponding element in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns the value of the CF flag.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \param __b
+///    A 256-bit vector of [8 x float].
+/// \returns the CF flag.
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_testc_ps(__m256 __a, __m256 __b)
+{
+  return __builtin_ia32_vtestcps256((__v8sf)__a, (__v8sf)__b);
+}
+
+/// Given two 256-bit floating-point vectors of [8 x float], perform an
+///    element-by-element comparison of the single-precision elements in the
+///    first source vector and the corresponding elements in the second source
+///    vector.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bits of both elements are 1, the ZF flag is set to 0. Otherwise the
+///    ZF flag is set to 1. \n
+///    If there is at least one pair of single-precision elements where the
+///    sign-bit of the first element is 0 and the sign-bit of the second element
+///    is 1, the CF flag is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns 1 if both the ZF and CF flags are set to 0,
+///    otherwise it returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VTESTPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float].
+/// \param __b
+///    A 256-bit vector of [8 x float].
+/// \returns 1 if both the ZF and CF flags are set to 0, otherwise returns 0.
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_testnzc_ps(__m256 __a, __m256 __b)
+{
+  return __builtin_ia32_vtestnzcps256((__v8sf)__a, (__v8sf)__b);
+}
+
+/// Given two 256-bit integer vectors, perform a bit-by-bit comparison
+///    of the two source vectors.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of bits where both bits are 1, the ZF flag
+///    is set to 0. Otherwise the ZF flag is set to 1. \n
+///    If there is at least one pair of bits where the bit from the first source
+///    vector is 0 and the bit from the second source vector is 1, the CF flag
+///    is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns the value of the ZF flag.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPTEST </c> instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns the ZF flag.
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_testz_si256(__m256i __a, __m256i __b)
+{
+  return __builtin_ia32_ptestz256((__v4di)__a, (__v4di)__b);
+}
+
+/// Given two 256-bit integer vectors, perform a bit-by-bit comparison
+///    of the two source vectors.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of bits where both bits are 1, the ZF flag
+///    is set to 0. Otherwise the ZF flag is set to 1. \n
+///    If there is at least one pair of bits where the bit from the first source
+///    vector is 0 and the bit from the second source vector is 1, the CF flag
+///    is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns the value of the CF flag.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPTEST </c> instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns the CF flag.
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_testc_si256(__m256i __a, __m256i __b)
+{
+  return __builtin_ia32_ptestc256((__v4di)__a, (__v4di)__b);
+}
+
+/// Given two 256-bit integer vectors, perform a bit-by-bit comparison
+///    of the two source vectors.
+///
+///    The EFLAGS register is updated as follows: \n
+///    If there is at least one pair of bits where both bits are 1, the ZF flag
+///    is set to 0. Otherwise the ZF flag is set to 1. \n
+///    If there is at least one pair of bits where the bit from the first source
+///    vector is 0 and the bit from the second source vector is 1, the CF flag
+///    is set to 0. Otherwise the CF flag is set to 1. \n
+///    This intrinsic returns 1 if both the ZF and CF flags are set to 0,
+///    otherwise it returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPTEST </c> instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \param __b
+///    A 256-bit integer vector.
+/// \returns 1 if both the ZF and CF flags are set to 0, otherwise returns 0.
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_testnzc_si256(__m256i __a, __m256i __b)
+{
+  return __builtin_ia32_ptestnzc256((__v4di)__a, (__v4di)__b);
+}
+
+/* Vector extract sign mask */
+/// Extracts the sign bits of double-precision floating point elements
+///    in a 256-bit vector of [4 x double] and writes them to the lower order
+///    bits of the return value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVMSKPD </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [4 x double] containing the double-precision
+///    floating point values with sign bits to be extracted.
+/// \returns The sign bits from the operand, written to bits [3:0].
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_movemask_pd(__m256d __a)
+{
+  return __builtin_ia32_movmskpd256((__v4df)__a);
+}
+
+/// Extracts the sign bits of single-precision floating point elements
+///    in a 256-bit vector of [8 x float] and writes them to the lower order
+///    bits of the return value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVMSKPS </c> instruction.
+///
+/// \param __a
+///    A 256-bit vector of [8 x float] containing the single-precision floating
+///    point values with sign bits to be extracted.
+/// \returns The sign bits from the operand, written to bits [7:0].
+static __inline int __DEFAULT_FN_ATTRS
+_mm256_movemask_ps(__m256 __a)
+{
+  return __builtin_ia32_movmskps256((__v8sf)__a);
+}
+
+/* Vector __zero */
+/// Zeroes the contents of all XMM or YMM registers.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VZEROALL </c> instruction.
+static __inline void __attribute__((__always_inline__, __nodebug__, __target__("avx")))
+_mm256_zeroall(void)
+{
+  __builtin_ia32_vzeroall();
+}
+
+/// Zeroes the upper 128 bits (bits 255:128) of all YMM registers.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VZEROUPPER </c> instruction.
+static __inline void __attribute__((__always_inline__, __nodebug__, __target__("avx")))
+_mm256_zeroupper(void)
+{
+  __builtin_ia32_vzeroupper();
+}
+
+/* Vector load with broadcast */
+/// Loads a scalar single-precision floating point value from the
+///    specified address pointed to by \a __a and broadcasts it to the elements
+///    of a [4 x float] vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBROADCASTSS </c> instruction.
+///
+/// \param __a
+///    The single-precision floating point value to be broadcast.
+/// \returns A 128-bit vector of [4 x float] whose 32-bit elements are set
+///    equal to the broadcast value.
+static __inline __m128 __DEFAULT_FN_ATTRS128
+_mm_broadcast_ss(float const *__a)
+{
+  struct __mm_broadcast_ss_struct {
+    float __f;
+  } __attribute__((__packed__, __may_alias__));
+  float __f = ((const struct __mm_broadcast_ss_struct*)__a)->__f;
+  return __extension__ (__m128){ __f, __f, __f, __f };
+}
+
+/// Loads a scalar double-precision floating point value from the
+///    specified address pointed to by \a __a and broadcasts it to the elements
+///    of a [4 x double] vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBROADCASTSD </c> instruction.
+///
+/// \param __a
+///    The double-precision floating point value to be broadcast.
+/// \returns A 256-bit vector of [4 x double] whose 64-bit elements are set
+///    equal to the broadcast value.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_broadcast_sd(double const *__a)
+{
+  struct __mm256_broadcast_sd_struct {
+    double __d;
+  } __attribute__((__packed__, __may_alias__));
+  double __d = ((const struct __mm256_broadcast_sd_struct*)__a)->__d;
+  return __extension__ (__m256d)(__v4df){ __d, __d, __d, __d };
+}
+
+/// Loads a scalar single-precision floating point value from the
+///    specified address pointed to by \a __a and broadcasts it to the elements
+///    of a [8 x float] vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBROADCASTSS </c> instruction.
+///
+/// \param __a
+///    The single-precision floating point value to be broadcast.
+/// \returns A 256-bit vector of [8 x float] whose 32-bit elements are set
+///    equal to the broadcast value.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_broadcast_ss(float const *__a)
+{
+  struct __mm256_broadcast_ss_struct {
+    float __f;
+  } __attribute__((__packed__, __may_alias__));
+  float __f = ((const struct __mm256_broadcast_ss_struct*)__a)->__f;
+  return __extension__ (__m256)(__v8sf){ __f, __f, __f, __f, __f, __f, __f, __f };
+}
+
+/// Loads the data from a 128-bit vector of [2 x double] from the
+///    specified address pointed to by \a __a and broadcasts it to 128-bit
+///    elements in a 256-bit vector of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBROADCASTF128 </c> instruction.
+///
+/// \param __a
+///    The 128-bit vector of [2 x double] to be broadcast.
+/// \returns A 256-bit vector of [4 x double] whose 128-bit elements are set
+///    equal to the broadcast value.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_broadcast_pd(__m128d const *__a)
+{
+  __m128d __b = _mm_loadu_pd((const double *)__a);
+  return (__m256d)__builtin_shufflevector((__v2df)__b, (__v2df)__b,
+                                          0, 1, 0, 1);
+}
+
+/// Loads the data from a 128-bit vector of [4 x float] from the
+///    specified address pointed to by \a __a and broadcasts it to 128-bit
+///    elements in a 256-bit vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBROADCASTF128 </c> instruction.
+///
+/// \param __a
+///    The 128-bit vector of [4 x float] to be broadcast.
+/// \returns A 256-bit vector of [8 x float] whose 128-bit elements are set
+///    equal to the broadcast value.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_broadcast_ps(__m128 const *__a)
+{
+  __m128 __b = _mm_loadu_ps((const float *)__a);
+  return (__m256)__builtin_shufflevector((__v4sf)__b, (__v4sf)__b,
+                                         0, 1, 2, 3, 0, 1, 2, 3);
+}
+
+/* SIMD load ops */
+/// Loads 4 double-precision floating point values from a 32-byte aligned
+///    memory location pointed to by \a __p into a vector of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPD </c> instruction.
+///
+/// \param __p
+///    A 32-byte aligned pointer to a memory location containing
+///    double-precision floating point values.
+/// \returns A 256-bit vector of [4 x double] containing the moved values.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_load_pd(double const *__p)
+{
+  return *(const __m256d *)__p;
+}
+
+/// Loads 8 single-precision floating point values from a 32-byte aligned
+///    memory location pointed to by \a __p into a vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPS </c> instruction.
+///
+/// \param __p
+///    A 32-byte aligned pointer to a memory location containing float values.
+/// \returns A 256-bit vector of [8 x float] containing the moved values.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_load_ps(float const *__p)
+{
+  return *(const __m256 *)__p;
+}
+
+/// Loads 4 double-precision floating point values from an unaligned
+///    memory location pointed to by \a __p into a vector of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVUPD </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location containing double-precision floating
+///    point values.
+/// \returns A 256-bit vector of [4 x double] containing the moved values.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_loadu_pd(double const *__p)
+{
+  struct __loadu_pd {
+    __m256d_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_pd*)__p)->__v;
+}
+
+/// Loads 8 single-precision floating point values from an unaligned
+///    memory location pointed to by \a __p into a vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVUPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location containing single-precision floating
+///    point values.
+/// \returns A 256-bit vector of [8 x float] containing the moved values.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_loadu_ps(float const *__p)
+{
+  struct __loadu_ps {
+    __m256_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_ps*)__p)->__v;
+}
+
+/// Loads 256 bits of integer data from a 32-byte aligned memory
+///    location pointed to by \a __p into elements of a 256-bit integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDQA </c> instruction.
+///
+/// \param __p
+///    A 32-byte aligned pointer to a 256-bit integer vector containing integer
+///    values.
+/// \returns A 256-bit integer vector containing the moved values.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_load_si256(__m256i const *__p)
+{
+  return *__p;
+}
+
+/// Loads 256 bits of integer data from an unaligned memory location
+///    pointed to by \a __p into a 256-bit integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDQU </c> instruction.
+///
+/// \param __p
+///    A pointer to a 256-bit integer vector containing integer values.
+/// \returns A 256-bit integer vector containing the moved values.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_loadu_si256(__m256i_u const *__p)
+{
+  struct __loadu_si256 {
+    __m256i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_si256*)__p)->__v;
+}
+
+/// Loads 256 bits of integer data from an unaligned memory location
+///    pointed to by \a __p into a 256-bit integer vector. This intrinsic may
+///    perform better than \c _mm256_loadu_si256 when the data crosses a cache
+///    line boundary.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VLDDQU </c> instruction.
+///
+/// \param __p
+///    A pointer to a 256-bit integer vector containing integer values.
+/// \returns A 256-bit integer vector containing the moved values.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_lddqu_si256(__m256i_u const *__p)
+{
+  return (__m256i)__builtin_ia32_lddqu256((char const *)__p);
+}
+
+/* SIMD store ops */
+/// Stores double-precision floating point values from a 256-bit vector
+///    of [4 x double] to a 32-byte aligned memory location pointed to by
+///    \a __p.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPD </c> instruction.
+///
+/// \param __p
+///    A 32-byte aligned pointer to a memory location that will receive the
+///    double-precision floaing point values.
+/// \param __a
+///    A 256-bit vector of [4 x double] containing the values to be moved.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_store_pd(double *__p, __m256d __a)
+{
+  *(__m256d *)__p = __a;
+}
+
+/// Stores single-precision floating point values from a 256-bit vector
+///    of [8 x float] to a 32-byte aligned memory location pointed to by \a __p.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPS </c> instruction.
+///
+/// \param __p
+///    A 32-byte aligned pointer to a memory location that will receive the
+///    float values.
+/// \param __a
+///    A 256-bit vector of [8 x float] containing the values to be moved.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_store_ps(float *__p, __m256 __a)
+{
+  *(__m256 *)__p = __a;
+}
+
+/// Stores double-precision floating point values from a 256-bit vector
+///    of [4 x double] to an unaligned memory location pointed to by \a __p.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVUPD </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that will receive the double-precision
+///    floating point values.
+/// \param __a
+///    A 256-bit vector of [4 x double] containing the values to be moved.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_storeu_pd(double *__p, __m256d __a)
+{
+  struct __storeu_pd {
+    __m256d_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_pd*)__p)->__v = __a;
+}
+
+/// Stores single-precision floating point values from a 256-bit vector
+///    of [8 x float] to an unaligned memory location pointed to by \a __p.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVUPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that will receive the float values.
+/// \param __a
+///    A 256-bit vector of [8 x float] containing the values to be moved.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_storeu_ps(float *__p, __m256 __a)
+{
+  struct __storeu_ps {
+    __m256_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_ps*)__p)->__v = __a;
+}
+
+/// Stores integer values from a 256-bit integer vector to a 32-byte
+///    aligned memory location pointed to by \a __p.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDQA </c> instruction.
+///
+/// \param __p
+///    A 32-byte aligned pointer to a memory location that will receive the
+///    integer values.
+/// \param __a
+///    A 256-bit integer vector containing the values to be moved.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_store_si256(__m256i *__p, __m256i __a)
+{
+  *__p = __a;
+}
+
+/// Stores integer values from a 256-bit integer vector to an unaligned
+///    memory location pointed to by \a __p.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDQU </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that will receive the integer values.
+/// \param __a
+///    A 256-bit integer vector containing the values to be moved.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_storeu_si256(__m256i_u *__p, __m256i __a)
+{
+  struct __storeu_si256 {
+    __m256i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_si256*)__p)->__v = __a;
+}
+
+/* Conditional load ops */
+/// Conditionally loads double-precision floating point elements from a
+///    memory location pointed to by \a __p into a 128-bit vector of
+///    [2 x double], depending on the mask bits associated with each data
+///    element.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMASKMOVPD </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that contains the double-precision
+///    floating point values.
+/// \param __m
+///    A 128-bit integer vector containing the mask. The most significant bit of
+///    each data element represents the mask bits. If a mask bit is zero, the
+///    corresponding value in the memory location is not loaded and the
+///    corresponding field in the return value is set to zero.
+/// \returns A 128-bit vector of [2 x double] containing the loaded values.
+static __inline __m128d __DEFAULT_FN_ATTRS128
+_mm_maskload_pd(double const *__p, __m128i __m)
+{
+  return (__m128d)__builtin_ia32_maskloadpd((const __v2df *)__p, (__v2di)__m);
+}
+
+/// Conditionally loads double-precision floating point elements from a
+///    memory location pointed to by \a __p into a 256-bit vector of
+///    [4 x double], depending on the mask bits associated with each data
+///    element.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMASKMOVPD </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that contains the double-precision
+///    floating point values.
+/// \param __m
+///    A 256-bit integer vector of [4 x quadword] containing the mask. The most
+///    significant bit of each quadword element represents the mask bits. If a
+///    mask bit is zero, the corresponding value in the memory location is not
+///    loaded and the corresponding field in the return value is set to zero.
+/// \returns A 256-bit vector of [4 x double] containing the loaded values.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_maskload_pd(double const *__p, __m256i __m)
+{
+  return (__m256d)__builtin_ia32_maskloadpd256((const __v4df *)__p,
+                                               (__v4di)__m);
+}
+
+/// Conditionally loads single-precision floating point elements from a
+///    memory location pointed to by \a __p into a 128-bit vector of
+///    [4 x float], depending on the mask bits associated with each data
+///    element.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMASKMOVPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that contains the single-precision
+///    floating point values.
+/// \param __m
+///    A 128-bit integer vector containing the mask. The most significant bit of
+///    each data element represents the mask bits. If a mask bit is zero, the
+///    corresponding value in the memory location is not loaded and the
+///    corresponding field in the return value is set to zero.
+/// \returns A 128-bit vector of [4 x float] containing the loaded values.
+static __inline __m128 __DEFAULT_FN_ATTRS128
+_mm_maskload_ps(float const *__p, __m128i __m)
+{
+  return (__m128)__builtin_ia32_maskloadps((const __v4sf *)__p, (__v4si)__m);
+}
+
+/// Conditionally loads single-precision floating point elements from a
+///    memory location pointed to by \a __p into a 256-bit vector of
+///    [8 x float], depending on the mask bits associated with each data
+///    element.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMASKMOVPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that contains the single-precision
+///    floating point values.
+/// \param __m
+///    A 256-bit integer vector of [8 x dword] containing the mask. The most
+///    significant bit of each dword element represents the mask bits. If a mask
+///    bit is zero, the corresponding value in the memory location is not loaded
+///    and the corresponding field in the return value is set to zero.
+/// \returns A 256-bit vector of [8 x float] containing the loaded values.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_maskload_ps(float const *__p, __m256i __m)
+{
+  return (__m256)__builtin_ia32_maskloadps256((const __v8sf *)__p, (__v8si)__m);
+}
+
+/* Conditional store ops */
+/// Moves single-precision floating point values from a 256-bit vector
+///    of [8 x float] to a memory location pointed to by \a __p, according to
+///    the specified mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMASKMOVPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that will receive the float values.
+/// \param __m
+///    A 256-bit integer vector of [8 x dword] containing the mask. The most
+///    significant bit of each dword element in the mask vector represents the
+///    mask bits. If a mask bit is zero, the corresponding value from vector
+///    \a __a is not stored and the corresponding field in the memory location
+///    pointed to by \a __p is not changed.
+/// \param __a
+///    A 256-bit vector of [8 x float] containing the values to be stored.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_maskstore_ps(float *__p, __m256i __m, __m256 __a)
+{
+  __builtin_ia32_maskstoreps256((__v8sf *)__p, (__v8si)__m, (__v8sf)__a);
+}
+
+/// Moves double-precision values from a 128-bit vector of [2 x double]
+///    to a memory location pointed to by \a __p, according to the specified
+///    mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMASKMOVPD </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that will receive the float values.
+/// \param __m
+///    A 128-bit integer vector containing the mask. The most significant bit of
+///    each field in the mask vector represents the mask bits. If a mask bit is
+///    zero, the corresponding value from vector \a __a is not stored and the
+///    corresponding field in the memory location pointed to by \a __p is not
+///    changed.
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the values to be stored.
+static __inline void __DEFAULT_FN_ATTRS128
+_mm_maskstore_pd(double *__p, __m128i __m, __m128d __a)
+{
+  __builtin_ia32_maskstorepd((__v2df *)__p, (__v2di)__m, (__v2df)__a);
+}
+
+/// Moves double-precision values from a 256-bit vector of [4 x double]
+///    to a memory location pointed to by \a __p, according to the specified
+///    mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMASKMOVPD </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that will receive the float values.
+/// \param __m
+///    A 256-bit integer vector of [4 x quadword] containing the mask. The most
+///    significant bit of each quadword element in the mask vector represents
+///    the mask bits. If a mask bit is zero, the corresponding value from vector
+///    __a is not stored and the corresponding field in the memory location
+///    pointed to by \a __p is not changed.
+/// \param __a
+///    A 256-bit vector of [4 x double] containing the values to be stored.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_maskstore_pd(double *__p, __m256i __m, __m256d __a)
+{
+  __builtin_ia32_maskstorepd256((__v4df *)__p, (__v4di)__m, (__v4df)__a);
+}
+
+/// Moves single-precision floating point values from a 128-bit vector
+///    of [4 x float] to a memory location pointed to by \a __p, according to
+///    the specified mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMASKMOVPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that will receive the float values.
+/// \param __m
+///    A 128-bit integer vector containing the mask. The most significant bit of
+///    each field in the mask vector represents the mask bits. If a mask bit is
+///    zero, the corresponding value from vector __a is not stored and the
+///    corresponding field in the memory location pointed to by \a __p is not
+///    changed.
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the values to be stored.
+static __inline void __DEFAULT_FN_ATTRS128
+_mm_maskstore_ps(float *__p, __m128i __m, __m128 __a)
+{
+  __builtin_ia32_maskstoreps((__v4sf *)__p, (__v4si)__m, (__v4sf)__a);
+}
+
+/* Cacheability support ops */
+/// Moves integer data from a 256-bit integer vector to a 32-byte
+///    aligned memory location. To minimize caching, the data is flagged as
+///    non-temporal (unlikely to be used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVNTDQ </c> instruction.
+///
+/// \param __a
+///    A pointer to a 32-byte aligned memory location that will receive the
+///    integer values.
+/// \param __b
+///    A 256-bit integer vector containing the values to be moved.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_stream_si256(void *__a, __m256i __b)
+{
+  typedef __v4di __v4di_aligned __attribute__((aligned(32)));
+  __builtin_nontemporal_store((__v4di_aligned)__b, (__v4di_aligned*)__a);
+}
+
+/// Moves double-precision values from a 256-bit vector of [4 x double]
+///    to a 32-byte aligned memory location. To minimize caching, the data is
+///    flagged as non-temporal (unlikely to be used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVNTPD </c> instruction.
+///
+/// \param __a
+///    A pointer to a 32-byte aligned memory location that will receive the
+///    double-precision floating-point values.
+/// \param __b
+///    A 256-bit vector of [4 x double] containing the values to be moved.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_stream_pd(void *__a, __m256d __b)
+{
+  typedef __v4df __v4df_aligned __attribute__((aligned(32)));
+  __builtin_nontemporal_store((__v4df_aligned)__b, (__v4df_aligned*)__a);
+}
+
+/// Moves single-precision floating point values from a 256-bit vector
+///    of [8 x float] to a 32-byte aligned memory location. To minimize
+///    caching, the data is flagged as non-temporal (unlikely to be used again
+///    soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVNTPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a 32-byte aligned memory location that will receive the
+///    single-precision floating point values.
+/// \param __a
+///    A 256-bit vector of [8 x float] containing the values to be moved.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_stream_ps(void *__p, __m256 __a)
+{
+  typedef __v8sf __v8sf_aligned __attribute__((aligned(32)));
+  __builtin_nontemporal_store((__v8sf_aligned)__a, (__v8sf_aligned*)__p);
+}
+
+/* Create vectors */
+/// Create a 256-bit vector of [4 x double] with undefined values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \returns A 256-bit vector of [4 x double] containing undefined values.
+static __inline__ __m256d __DEFAULT_FN_ATTRS
+_mm256_undefined_pd(void)
+{
+  return (__m256d)__builtin_ia32_undef256();
+}
+
+/// Create a 256-bit vector of [8 x float] with undefined values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \returns A 256-bit vector of [8 x float] containing undefined values.
+static __inline__ __m256 __DEFAULT_FN_ATTRS
+_mm256_undefined_ps(void)
+{
+  return (__m256)__builtin_ia32_undef256();
+}
+
+/// Create a 256-bit integer vector with undefined values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \returns A 256-bit integer vector containing undefined values.
+static __inline__ __m256i __DEFAULT_FN_ATTRS
+_mm256_undefined_si256(void)
+{
+  return (__m256i)__builtin_ia32_undef256();
+}
+
+/// Constructs a 256-bit floating-point vector of [4 x double]
+///    initialized with the specified double-precision floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKLPD+VINSERTF128 </c>
+///   instruction.
+///
+/// \param __a
+///    A double-precision floating-point value used to initialize bits [255:192]
+///    of the result.
+/// \param __b
+///    A double-precision floating-point value used to initialize bits [191:128]
+///    of the result.
+/// \param __c
+///    A double-precision floating-point value used to initialize bits [127:64]
+///    of the result.
+/// \param __d
+///    A double-precision floating-point value used to initialize bits [63:0]
+///    of the result.
+/// \returns An initialized 256-bit floating-point vector of [4 x double].
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_set_pd(double __a, double __b, double __c, double __d)
+{
+  return __extension__ (__m256d){ __d, __c, __b, __a };
+}
+
+/// Constructs a 256-bit floating-point vector of [8 x float] initialized
+///    with the specified single-precision floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///   instruction.
+///
+/// \param __a
+///    A single-precision floating-point value used to initialize bits [255:224]
+///    of the result.
+/// \param __b
+///    A single-precision floating-point value used to initialize bits [223:192]
+///    of the result.
+/// \param __c
+///    A single-precision floating-point value used to initialize bits [191:160]
+///    of the result.
+/// \param __d
+///    A single-precision floating-point value used to initialize bits [159:128]
+///    of the result.
+/// \param __e
+///    A single-precision floating-point value used to initialize bits [127:96]
+///    of the result.
+/// \param __f
+///    A single-precision floating-point value used to initialize bits [95:64]
+///    of the result.
+/// \param __g
+///    A single-precision floating-point value used to initialize bits [63:32]
+///    of the result.
+/// \param __h
+///    A single-precision floating-point value used to initialize bits [31:0]
+///    of the result.
+/// \returns An initialized 256-bit floating-point vector of [8 x float].
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_set_ps(float __a, float __b, float __c, float __d,
+              float __e, float __f, float __g, float __h)
+{
+  return __extension__ (__m256){ __h, __g, __f, __e, __d, __c, __b, __a };
+}
+
+/// Constructs a 256-bit integer vector initialized with the specified
+///    32-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///   instruction.
+///
+/// \param __i0
+///    A 32-bit integral value used to initialize bits [255:224] of the result.
+/// \param __i1
+///    A 32-bit integral value used to initialize bits [223:192] of the result.
+/// \param __i2
+///    A 32-bit integral value used to initialize bits [191:160] of the result.
+/// \param __i3
+///    A 32-bit integral value used to initialize bits [159:128] of the result.
+/// \param __i4
+///    A 32-bit integral value used to initialize bits [127:96] of the result.
+/// \param __i5
+///    A 32-bit integral value used to initialize bits [95:64] of the result.
+/// \param __i6
+///    A 32-bit integral value used to initialize bits [63:32] of the result.
+/// \param __i7
+///    A 32-bit integral value used to initialize bits [31:0] of the result.
+/// \returns An initialized 256-bit integer vector.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_set_epi32(int __i0, int __i1, int __i2, int __i3,
+                 int __i4, int __i5, int __i6, int __i7)
+{
+  return __extension__ (__m256i)(__v8si){ __i7, __i6, __i5, __i4, __i3, __i2, __i1, __i0 };
+}
+
+/// Constructs a 256-bit integer vector initialized with the specified
+///    16-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///   instruction.
+///
+/// \param __w15
+///    A 16-bit integral value used to initialize bits [255:240] of the result.
+/// \param __w14
+///    A 16-bit integral value used to initialize bits [239:224] of the result.
+/// \param __w13
+///    A 16-bit integral value used to initialize bits [223:208] of the result.
+/// \param __w12
+///    A 16-bit integral value used to initialize bits [207:192] of the result.
+/// \param __w11
+///    A 16-bit integral value used to initialize bits [191:176] of the result.
+/// \param __w10
+///    A 16-bit integral value used to initialize bits [175:160] of the result.
+/// \param __w09
+///    A 16-bit integral value used to initialize bits [159:144] of the result.
+/// \param __w08
+///    A 16-bit integral value used to initialize bits [143:128] of the result.
+/// \param __w07
+///    A 16-bit integral value used to initialize bits [127:112] of the result.
+/// \param __w06
+///    A 16-bit integral value used to initialize bits [111:96] of the result.
+/// \param __w05
+///    A 16-bit integral value used to initialize bits [95:80] of the result.
+/// \param __w04
+///    A 16-bit integral value used to initialize bits [79:64] of the result.
+/// \param __w03
+///    A 16-bit integral value used to initialize bits [63:48] of the result.
+/// \param __w02
+///    A 16-bit integral value used to initialize bits [47:32] of the result.
+/// \param __w01
+///    A 16-bit integral value used to initialize bits [31:16] of the result.
+/// \param __w00
+///    A 16-bit integral value used to initialize bits [15:0] of the result.
+/// \returns An initialized 256-bit integer vector.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_set_epi16(short __w15, short __w14, short __w13, short __w12,
+                 short __w11, short __w10, short __w09, short __w08,
+                 short __w07, short __w06, short __w05, short __w04,
+                 short __w03, short __w02, short __w01, short __w00)
+{
+  return __extension__ (__m256i)(__v16hi){ __w00, __w01, __w02, __w03, __w04, __w05, __w06,
+    __w07, __w08, __w09, __w10, __w11, __w12, __w13, __w14, __w15 };
+}
+
+/// Constructs a 256-bit integer vector initialized with the specified
+///    8-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///   instruction.
+///
+/// \param __b31
+///    An 8-bit integral value used to initialize bits [255:248] of the result.
+/// \param __b30
+///    An 8-bit integral value used to initialize bits [247:240] of the result.
+/// \param __b29
+///    An 8-bit integral value used to initialize bits [239:232] of the result.
+/// \param __b28
+///    An 8-bit integral value used to initialize bits [231:224] of the result.
+/// \param __b27
+///    An 8-bit integral value used to initialize bits [223:216] of the result.
+/// \param __b26
+///    An 8-bit integral value used to initialize bits [215:208] of the result.
+/// \param __b25
+///    An 8-bit integral value used to initialize bits [207:200] of the result.
+/// \param __b24
+///    An 8-bit integral value used to initialize bits [199:192] of the result.
+/// \param __b23
+///    An 8-bit integral value used to initialize bits [191:184] of the result.
+/// \param __b22
+///    An 8-bit integral value used to initialize bits [183:176] of the result.
+/// \param __b21
+///    An 8-bit integral value used to initialize bits [175:168] of the result.
+/// \param __b20
+///    An 8-bit integral value used to initialize bits [167:160] of the result.
+/// \param __b19
+///    An 8-bit integral value used to initialize bits [159:152] of the result.
+/// \param __b18
+///    An 8-bit integral value used to initialize bits [151:144] of the result.
+/// \param __b17
+///    An 8-bit integral value used to initialize bits [143:136] of the result.
+/// \param __b16
+///    An 8-bit integral value used to initialize bits [135:128] of the result.
+/// \param __b15
+///    An 8-bit integral value used to initialize bits [127:120] of the result.
+/// \param __b14
+///    An 8-bit integral value used to initialize bits [119:112] of the result.
+/// \param __b13
+///    An 8-bit integral value used to initialize bits [111:104] of the result.
+/// \param __b12
+///    An 8-bit integral value used to initialize bits [103:96] of the result.
+/// \param __b11
+///    An 8-bit integral value used to initialize bits [95:88] of the result.
+/// \param __b10
+///    An 8-bit integral value used to initialize bits [87:80] of the result.
+/// \param __b09
+///    An 8-bit integral value used to initialize bits [79:72] of the result.
+/// \param __b08
+///    An 8-bit integral value used to initialize bits [71:64] of the result.
+/// \param __b07
+///    An 8-bit integral value used to initialize bits [63:56] of the result.
+/// \param __b06
+///    An 8-bit integral value used to initialize bits [55:48] of the result.
+/// \param __b05
+///    An 8-bit integral value used to initialize bits [47:40] of the result.
+/// \param __b04
+///    An 8-bit integral value used to initialize bits [39:32] of the result.
+/// \param __b03
+///    An 8-bit integral value used to initialize bits [31:24] of the result.
+/// \param __b02
+///    An 8-bit integral value used to initialize bits [23:16] of the result.
+/// \param __b01
+///    An 8-bit integral value used to initialize bits [15:8] of the result.
+/// \param __b00
+///    An 8-bit integral value used to initialize bits [7:0] of the result.
+/// \returns An initialized 256-bit integer vector.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_set_epi8(char __b31, char __b30, char __b29, char __b28,
+                char __b27, char __b26, char __b25, char __b24,
+                char __b23, char __b22, char __b21, char __b20,
+                char __b19, char __b18, char __b17, char __b16,
+                char __b15, char __b14, char __b13, char __b12,
+                char __b11, char __b10, char __b09, char __b08,
+                char __b07, char __b06, char __b05, char __b04,
+                char __b03, char __b02, char __b01, char __b00)
+{
+  return __extension__ (__m256i)(__v32qi){
+    __b00, __b01, __b02, __b03, __b04, __b05, __b06, __b07,
+    __b08, __b09, __b10, __b11, __b12, __b13, __b14, __b15,
+    __b16, __b17, __b18, __b19, __b20, __b21, __b22, __b23,
+    __b24, __b25, __b26, __b27, __b28, __b29, __b30, __b31
+  };
+}
+
+/// Constructs a 256-bit integer vector initialized with the specified
+///    64-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPUNPCKLQDQ+VINSERTF128 </c>
+///   instruction.
+///
+/// \param __a
+///    A 64-bit integral value used to initialize bits [255:192] of the result.
+/// \param __b
+///    A 64-bit integral value used to initialize bits [191:128] of the result.
+/// \param __c
+///    A 64-bit integral value used to initialize bits [127:64] of the result.
+/// \param __d
+///    A 64-bit integral value used to initialize bits [63:0] of the result.
+/// \returns An initialized 256-bit integer vector.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_set_epi64x(long long __a, long long __b, long long __c, long long __d)
+{
+  return __extension__ (__m256i)(__v4di){ __d, __c, __b, __a };
+}
+
+/* Create vectors with elements in reverse order */
+/// Constructs a 256-bit floating-point vector of [4 x double],
+///    initialized in reverse order with the specified double-precision
+///    floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKLPD+VINSERTF128 </c>
+///   instruction.
+///
+/// \param __a
+///    A double-precision floating-point value used to initialize bits [63:0]
+///    of the result.
+/// \param __b
+///    A double-precision floating-point value used to initialize bits [127:64]
+///    of the result.
+/// \param __c
+///    A double-precision floating-point value used to initialize bits [191:128]
+///    of the result.
+/// \param __d
+///    A double-precision floating-point value used to initialize bits [255:192]
+///    of the result.
+/// \returns An initialized 256-bit floating-point vector of [4 x double].
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_setr_pd(double __a, double __b, double __c, double __d)
+{
+  return _mm256_set_pd(__d, __c, __b, __a);
+}
+
+/// Constructs a 256-bit floating-point vector of [8 x float],
+///    initialized in reverse order with the specified single-precision
+///    float-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///   instruction.
+///
+/// \param __a
+///    A single-precision floating-point value used to initialize bits [31:0]
+///    of the result.
+/// \param __b
+///    A single-precision floating-point value used to initialize bits [63:32]
+///    of the result.
+/// \param __c
+///    A single-precision floating-point value used to initialize bits [95:64]
+///    of the result.
+/// \param __d
+///    A single-precision floating-point value used to initialize bits [127:96]
+///    of the result.
+/// \param __e
+///    A single-precision floating-point value used to initialize bits [159:128]
+///    of the result.
+/// \param __f
+///    A single-precision floating-point value used to initialize bits [191:160]
+///    of the result.
+/// \param __g
+///    A single-precision floating-point value used to initialize bits [223:192]
+///    of the result.
+/// \param __h
+///    A single-precision floating-point value used to initialize bits [255:224]
+///    of the result.
+/// \returns An initialized 256-bit floating-point vector of [8 x float].
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_setr_ps(float __a, float __b, float __c, float __d,
+               float __e, float __f, float __g, float __h)
+{
+  return _mm256_set_ps(__h, __g, __f, __e, __d, __c, __b, __a);
+}
+
+/// Constructs a 256-bit integer vector, initialized in reverse order
+///    with the specified 32-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///   instruction.
+///
+/// \param __i0
+///    A 32-bit integral value used to initialize bits [31:0] of the result.
+/// \param __i1
+///    A 32-bit integral value used to initialize bits [63:32] of the result.
+/// \param __i2
+///    A 32-bit integral value used to initialize bits [95:64] of the result.
+/// \param __i3
+///    A 32-bit integral value used to initialize bits [127:96] of the result.
+/// \param __i4
+///    A 32-bit integral value used to initialize bits [159:128] of the result.
+/// \param __i5
+///    A 32-bit integral value used to initialize bits [191:160] of the result.
+/// \param __i6
+///    A 32-bit integral value used to initialize bits [223:192] of the result.
+/// \param __i7
+///    A 32-bit integral value used to initialize bits [255:224] of the result.
+/// \returns An initialized 256-bit integer vector.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_setr_epi32(int __i0, int __i1, int __i2, int __i3,
+                  int __i4, int __i5, int __i6, int __i7)
+{
+  return _mm256_set_epi32(__i7, __i6, __i5, __i4, __i3, __i2, __i1, __i0);
+}
+
+/// Constructs a 256-bit integer vector, initialized in reverse order
+///    with the specified 16-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///   instruction.
+///
+/// \param __w15
+///    A 16-bit integral value used to initialize bits [15:0] of the result.
+/// \param __w14
+///    A 16-bit integral value used to initialize bits [31:16] of the result.
+/// \param __w13
+///    A 16-bit integral value used to initialize bits [47:32] of the result.
+/// \param __w12
+///    A 16-bit integral value used to initialize bits [63:48] of the result.
+/// \param __w11
+///    A 16-bit integral value used to initialize bits [79:64] of the result.
+/// \param __w10
+///    A 16-bit integral value used to initialize bits [95:80] of the result.
+/// \param __w09
+///    A 16-bit integral value used to initialize bits [111:96] of the result.
+/// \param __w08
+///    A 16-bit integral value used to initialize bits [127:112] of the result.
+/// \param __w07
+///    A 16-bit integral value used to initialize bits [143:128] of the result.
+/// \param __w06
+///    A 16-bit integral value used to initialize bits [159:144] of the result.
+/// \param __w05
+///    A 16-bit integral value used to initialize bits [175:160] of the result.
+/// \param __w04
+///    A 16-bit integral value used to initialize bits [191:176] of the result.
+/// \param __w03
+///    A 16-bit integral value used to initialize bits [207:192] of the result.
+/// \param __w02
+///    A 16-bit integral value used to initialize bits [223:208] of the result.
+/// \param __w01
+///    A 16-bit integral value used to initialize bits [239:224] of the result.
+/// \param __w00
+///    A 16-bit integral value used to initialize bits [255:240] of the result.
+/// \returns An initialized 256-bit integer vector.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_setr_epi16(short __w15, short __w14, short __w13, short __w12,
+       short __w11, short __w10, short __w09, short __w08,
+       short __w07, short __w06, short __w05, short __w04,
+       short __w03, short __w02, short __w01, short __w00)
+{
+  return _mm256_set_epi16(__w00, __w01, __w02, __w03,
+                          __w04, __w05, __w06, __w07,
+                          __w08, __w09, __w10, __w11,
+                          __w12, __w13, __w14, __w15);
+}
+
+/// Constructs a 256-bit integer vector, initialized in reverse order
+///    with the specified 8-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///   instruction.
+///
+/// \param __b31
+///    An 8-bit integral value used to initialize bits [7:0] of the result.
+/// \param __b30
+///    An 8-bit integral value used to initialize bits [15:8] of the result.
+/// \param __b29
+///    An 8-bit integral value used to initialize bits [23:16] of the result.
+/// \param __b28
+///    An 8-bit integral value used to initialize bits [31:24] of the result.
+/// \param __b27
+///    An 8-bit integral value used to initialize bits [39:32] of the result.
+/// \param __b26
+///    An 8-bit integral value used to initialize bits [47:40] of the result.
+/// \param __b25
+///    An 8-bit integral value used to initialize bits [55:48] of the result.
+/// \param __b24
+///    An 8-bit integral value used to initialize bits [63:56] of the result.
+/// \param __b23
+///    An 8-bit integral value used to initialize bits [71:64] of the result.
+/// \param __b22
+///    An 8-bit integral value used to initialize bits [79:72] of the result.
+/// \param __b21
+///    An 8-bit integral value used to initialize bits [87:80] of the result.
+/// \param __b20
+///    An 8-bit integral value used to initialize bits [95:88] of the result.
+/// \param __b19
+///    An 8-bit integral value used to initialize bits [103:96] of the result.
+/// \param __b18
+///    An 8-bit integral value used to initialize bits [111:104] of the result.
+/// \param __b17
+///    An 8-bit integral value used to initialize bits [119:112] of the result.
+/// \param __b16
+///    An 8-bit integral value used to initialize bits [127:120] of the result.
+/// \param __b15
+///    An 8-bit integral value used to initialize bits [135:128] of the result.
+/// \param __b14
+///    An 8-bit integral value used to initialize bits [143:136] of the result.
+/// \param __b13
+///    An 8-bit integral value used to initialize bits [151:144] of the result.
+/// \param __b12
+///    An 8-bit integral value used to initialize bits [159:152] of the result.
+/// \param __b11
+///    An 8-bit integral value used to initialize bits [167:160] of the result.
+/// \param __b10
+///    An 8-bit integral value used to initialize bits [175:168] of the result.
+/// \param __b09
+///    An 8-bit integral value used to initialize bits [183:176] of the result.
+/// \param __b08
+///    An 8-bit integral value used to initialize bits [191:184] of the result.
+/// \param __b07
+///    An 8-bit integral value used to initialize bits [199:192] of the result.
+/// \param __b06
+///    An 8-bit integral value used to initialize bits [207:200] of the result.
+/// \param __b05
+///    An 8-bit integral value used to initialize bits [215:208] of the result.
+/// \param __b04
+///    An 8-bit integral value used to initialize bits [223:216] of the result.
+/// \param __b03
+///    An 8-bit integral value used to initialize bits [231:224] of the result.
+/// \param __b02
+///    An 8-bit integral value used to initialize bits [239:232] of the result.
+/// \param __b01
+///    An 8-bit integral value used to initialize bits [247:240] of the result.
+/// \param __b00
+///    An 8-bit integral value used to initialize bits [255:248] of the result.
+/// \returns An initialized 256-bit integer vector.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_setr_epi8(char __b31, char __b30, char __b29, char __b28,
+                 char __b27, char __b26, char __b25, char __b24,
+                 char __b23, char __b22, char __b21, char __b20,
+                 char __b19, char __b18, char __b17, char __b16,
+                 char __b15, char __b14, char __b13, char __b12,
+                 char __b11, char __b10, char __b09, char __b08,
+                 char __b07, char __b06, char __b05, char __b04,
+                 char __b03, char __b02, char __b01, char __b00)
+{
+  return _mm256_set_epi8(__b00, __b01, __b02, __b03, __b04, __b05, __b06, __b07,
+                         __b08, __b09, __b10, __b11, __b12, __b13, __b14, __b15,
+                         __b16, __b17, __b18, __b19, __b20, __b21, __b22, __b23,
+                         __b24, __b25, __b26, __b27, __b28, __b29, __b30, __b31);
+}
+
+/// Constructs a 256-bit integer vector, initialized in reverse order
+///    with the specified 64-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPUNPCKLQDQ+VINSERTF128 </c>
+///   instruction.
+///
+/// \param __a
+///    A 64-bit integral value used to initialize bits [63:0] of the result.
+/// \param __b
+///    A 64-bit integral value used to initialize bits [127:64] of the result.
+/// \param __c
+///    A 64-bit integral value used to initialize bits [191:128] of the result.
+/// \param __d
+///    A 64-bit integral value used to initialize bits [255:192] of the result.
+/// \returns An initialized 256-bit integer vector.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_setr_epi64x(long long __a, long long __b, long long __c, long long __d)
+{
+  return _mm256_set_epi64x(__d, __c, __b, __a);
+}
+
+/* Create vectors with repeated elements */
+/// Constructs a 256-bit floating-point vector of [4 x double], with each
+///    of the four double-precision floating-point vector elements set to the
+///    specified double-precision floating-point value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDDUP+VINSERTF128 </c> instruction.
+///
+/// \param __w
+///    A double-precision floating-point value used to initialize each vector
+///    element of the result.
+/// \returns An initialized 256-bit floating-point vector of [4 x double].
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_set1_pd(double __w)
+{
+  return _mm256_set_pd(__w, __w, __w, __w);
+}
+
+/// Constructs a 256-bit floating-point vector of [8 x float], with each
+///    of the eight single-precision floating-point vector elements set to the
+///    specified single-precision floating-point value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPERMILPS+VINSERTF128 </c>
+///   instruction.
+///
+/// \param __w
+///    A single-precision floating-point value used to initialize each vector
+///    element of the result.
+/// \returns An initialized 256-bit floating-point vector of [8 x float].
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_set1_ps(float __w)
+{
+  return _mm256_set_ps(__w, __w, __w, __w, __w, __w, __w, __w);
+}
+
+/// Constructs a 256-bit integer vector of [8 x i32], with each of the
+///    32-bit integral vector elements set to the specified 32-bit integral
+///    value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPERMILPS+VINSERTF128 </c>
+///   instruction.
+///
+/// \param __i
+///    A 32-bit integral value used to initialize each vector element of the
+///    result.
+/// \returns An initialized 256-bit integer vector of [8 x i32].
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_set1_epi32(int __i)
+{
+  return _mm256_set_epi32(__i, __i, __i, __i, __i, __i, __i, __i);
+}
+
+/// Constructs a 256-bit integer vector of [16 x i16], with each of the
+///    16-bit integral vector elements set to the specified 16-bit integral
+///    value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSHUFB+VINSERTF128 </c> instruction.
+///
+/// \param __w
+///    A 16-bit integral value used to initialize each vector element of the
+///    result.
+/// \returns An initialized 256-bit integer vector of [16 x i16].
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_set1_epi16(short __w)
+{
+  return _mm256_set_epi16(__w, __w, __w, __w, __w, __w, __w, __w,
+                          __w, __w, __w, __w, __w, __w, __w, __w);
+}
+
+/// Constructs a 256-bit integer vector of [32 x i8], with each of the
+///    8-bit integral vector elements set to the specified 8-bit integral value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSHUFB+VINSERTF128 </c> instruction.
+///
+/// \param __b
+///    An 8-bit integral value used to initialize each vector element of the
+///    result.
+/// \returns An initialized 256-bit integer vector of [32 x i8].
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_set1_epi8(char __b)
+{
+  return _mm256_set_epi8(__b, __b, __b, __b, __b, __b, __b, __b,
+                         __b, __b, __b, __b, __b, __b, __b, __b,
+                         __b, __b, __b, __b, __b, __b, __b, __b,
+                         __b, __b, __b, __b, __b, __b, __b, __b);
+}
+
+/// Constructs a 256-bit integer vector of [4 x i64], with each of the
+///    64-bit integral vector elements set to the specified 64-bit integral
+///    value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDDUP+VINSERTF128 </c> instruction.
+///
+/// \param __q
+///    A 64-bit integral value used to initialize each vector element of the
+///    result.
+/// \returns An initialized 256-bit integer vector of [4 x i64].
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_set1_epi64x(long long __q)
+{
+  return _mm256_set_epi64x(__q, __q, __q, __q);
+}
+
+/* Create __zeroed vectors */
+/// Constructs a 256-bit floating-point vector of [4 x double] with all
+///    vector elements initialized to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VXORPS </c> instruction.
+///
+/// \returns A 256-bit vector of [4 x double] with all elements set to zero.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_setzero_pd(void)
+{
+  return __extension__ (__m256d){ 0.0, 0.0, 0.0, 0.0 };
+}
+
+/// Constructs a 256-bit floating-point vector of [8 x float] with all
+///    vector elements initialized to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VXORPS </c> instruction.
+///
+/// \returns A 256-bit vector of [8 x float] with all elements set to zero.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_setzero_ps(void)
+{
+  return __extension__ (__m256){ 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+}
+
+/// Constructs a 256-bit integer vector initialized to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VXORPS </c> instruction.
+///
+/// \returns A 256-bit integer vector initialized to zero.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_setzero_si256(void)
+{
+  return __extension__ (__m256i)(__v4di){ 0, 0, 0, 0 };
+}
+
+/* Cast between vector types */
+/// Casts a 256-bit floating-point vector of [4 x double] into a 256-bit
+///    floating-point vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit floating-point vector of [4 x double].
+/// \returns A 256-bit floating-point vector of [8 x float] containing the same
+///    bitwise pattern as the parameter.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_castpd_ps(__m256d __a)
+{
+  return (__m256)__a;
+}
+
+/// Casts a 256-bit floating-point vector of [4 x double] into a 256-bit
+///    integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit floating-point vector of [4 x double].
+/// \returns A 256-bit integer vector containing the same bitwise pattern as the
+///    parameter.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_castpd_si256(__m256d __a)
+{
+  return (__m256i)__a;
+}
+
+/// Casts a 256-bit floating-point vector of [8 x float] into a 256-bit
+///    floating-point vector of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit floating-point vector of [8 x float].
+/// \returns A 256-bit floating-point vector of [4 x double] containing the same
+///    bitwise pattern as the parameter.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_castps_pd(__m256 __a)
+{
+  return (__m256d)__a;
+}
+
+/// Casts a 256-bit floating-point vector of [8 x float] into a 256-bit
+///    integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit floating-point vector of [8 x float].
+/// \returns A 256-bit integer vector containing the same bitwise pattern as the
+///    parameter.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_castps_si256(__m256 __a)
+{
+  return (__m256i)__a;
+}
+
+/// Casts a 256-bit integer vector into a 256-bit floating-point vector
+///    of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \returns A 256-bit floating-point vector of [8 x float] containing the same
+///    bitwise pattern as the parameter.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_castsi256_ps(__m256i __a)
+{
+  return (__m256)__a;
+}
+
+/// Casts a 256-bit integer vector into a 256-bit floating-point vector
+///    of [4 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \returns A 256-bit floating-point vector of [4 x double] containing the same
+///    bitwise pattern as the parameter.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_castsi256_pd(__m256i __a)
+{
+  return (__m256d)__a;
+}
+
+/// Returns the lower 128 bits of a 256-bit floating-point vector of
+///    [4 x double] as a 128-bit floating-point vector of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit floating-point vector of [4 x double].
+/// \returns A 128-bit floating-point vector of [2 x double] containing the
+///    lower 128 bits of the parameter.
+static __inline __m128d __DEFAULT_FN_ATTRS
+_mm256_castpd256_pd128(__m256d __a)
+{
+  return __builtin_shufflevector((__v4df)__a, (__v4df)__a, 0, 1);
+}
+
+/// Returns the lower 128 bits of a 256-bit floating-point vector of
+///    [8 x float] as a 128-bit floating-point vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit floating-point vector of [8 x float].
+/// \returns A 128-bit floating-point vector of [4 x float] containing the
+///    lower 128 bits of the parameter.
+static __inline __m128 __DEFAULT_FN_ATTRS
+_mm256_castps256_ps128(__m256 __a)
+{
+  return __builtin_shufflevector((__v8sf)__a, (__v8sf)__a, 0, 1, 2, 3);
+}
+
+/// Truncates a 256-bit integer vector into a 128-bit integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 256-bit integer vector.
+/// \returns A 128-bit integer vector containing the lower 128 bits of the
+///    parameter.
+static __inline __m128i __DEFAULT_FN_ATTRS
+_mm256_castsi256_si128(__m256i __a)
+{
+  return __builtin_shufflevector((__v4di)__a, (__v4di)__a, 0, 1);
+}
+
+/// Constructs a 256-bit floating-point vector of [4 x double] from a
+///    128-bit floating-point vector of [2 x double].
+///
+///    The lower 128 bits contain the value of the source vector. The contents
+///    of the upper 128 bits are undefined.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 256-bit floating-point vector of [4 x double]. The lower 128 bits
+///    contain the value of the parameter. The contents of the upper 128 bits
+///    are undefined.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_castpd128_pd256(__m128d __a)
+{
+  return __builtin_shufflevector(
+      (__v2df)__a, (__v2df)__builtin_nondeterministic_value(__a), 0, 1, 2, 3);
+}
+
+/// Constructs a 256-bit floating-point vector of [8 x float] from a
+///    128-bit floating-point vector of [4 x float].
+///
+///    The lower 128 bits contain the value of the source vector. The contents
+///    of the upper 128 bits are undefined.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 256-bit floating-point vector of [8 x float]. The lower 128 bits
+///    contain the value of the parameter. The contents of the upper 128 bits
+///    are undefined.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_castps128_ps256(__m128 __a)
+{
+  return __builtin_shufflevector((__v4sf)__a,
+                                 (__v4sf)__builtin_nondeterministic_value(__a),
+                                 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+/// Constructs a 256-bit integer vector from a 128-bit integer vector.
+///
+///    The lower 128 bits contain the value of the source vector. The contents
+///    of the upper 128 bits are undefined.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \returns A 256-bit integer vector. The lower 128 bits contain the value of
+///    the parameter. The contents of the upper 128 bits are undefined.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_castsi128_si256(__m128i __a)
+{
+  return __builtin_shufflevector(
+      (__v2di)__a, (__v2di)__builtin_nondeterministic_value(__a), 0, 1, 2, 3);
+}
+
+/// Constructs a 256-bit floating-point vector of [4 x double] from a
+///    128-bit floating-point vector of [2 x double]. The lower 128 bits
+///    contain the value of the source vector. The upper 128 bits are set
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 256-bit floating-point vector of [4 x double]. The lower 128 bits
+///    contain the value of the parameter. The upper 128 bits are set to zero.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_zextpd128_pd256(__m128d __a)
+{
+  return __builtin_shufflevector((__v2df)__a, (__v2df)_mm_setzero_pd(), 0, 1, 2, 3);
+}
+
+/// Constructs a 256-bit floating-point vector of [8 x float] from a
+///    128-bit floating-point vector of [4 x float]. The lower 128 bits contain
+///    the value of the source vector. The upper 128 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 256-bit floating-point vector of [8 x float]. The lower 128 bits
+///    contain the value of the parameter. The upper 128 bits are set to zero.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_zextps128_ps256(__m128 __a)
+{
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)_mm_setzero_ps(), 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+/// Constructs a 256-bit integer vector from a 128-bit integer vector.
+///    The lower 128 bits contain the value of the source vector. The upper
+///    128 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \returns A 256-bit integer vector. The lower 128 bits contain the value of
+///    the parameter. The upper 128 bits are set to zero.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_zextsi128_si256(__m128i __a)
+{
+  return __builtin_shufflevector((__v2di)__a, (__v2di)_mm_setzero_si128(), 0, 1, 2, 3);
+}
+
+/*
+   Vector insert.
+   We use macros rather than inlines because we only want to accept
+   invocations where the immediate M is a constant expression.
+*/
+/// Constructs a new 256-bit vector of [8 x float] by first duplicating
+///    a 256-bit vector of [8 x float] given in the first parameter, and then
+///    replacing either the upper or the lower 128 bits with the contents of a
+///    128-bit vector of [4 x float] in the second parameter.
+///
+///    The immediate integer parameter determines between the upper or the lower
+///    128 bits.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256 _mm256_insertf128_ps(__m256 V1, __m128 V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VINSERTF128 </c> instruction.
+///
+/// \param V1
+///    A 256-bit vector of [8 x float]. This vector is copied to the result
+///    first, and then either the upper or the lower 128 bits of the result will
+///    be replaced by the contents of \a V2.
+/// \param V2
+///    A 128-bit vector of [4 x float]. The contents of this parameter are
+///    written to either the upper or the lower 128 bits of the result depending
+///    on the value of parameter \a M.
+/// \param M
+///    An immediate integer. The least significant bit determines how the values
+///    from the two parameters are interleaved: \n
+///    If bit [0] of \a M is 0, \a V2 are copied to bits [127:0] of the result,
+///    and bits [255:128] of \a V1 are copied to bits [255:128] of the
+///    result. \n
+///    If bit [0] of \a M is 1, \a V2 are copied to bits [255:128] of the
+///    result, and bits [127:0] of \a V1 are copied to bits [127:0] of the
+///    result.
+/// \returns A 256-bit vector of [8 x float] containing the interleaved values.
+#define _mm256_insertf128_ps(V1, V2, M) \
+  ((__m256)__builtin_ia32_vinsertf128_ps256((__v8sf)(__m256)(V1), \
+                                            (__v4sf)(__m128)(V2), (int)(M)))
+
+/// Constructs a new 256-bit vector of [4 x double] by first duplicating
+///    a 256-bit vector of [4 x double] given in the first parameter, and then
+///    replacing either the upper or the lower 128 bits with the contents of a
+///    128-bit vector of [2 x double] in the second parameter.
+///
+///    The immediate integer parameter determines between the upper or the lower
+///    128 bits.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256d _mm256_insertf128_pd(__m256d V1, __m128d V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VINSERTF128 </c> instruction.
+///
+/// \param V1
+///    A 256-bit vector of [4 x double]. This vector is copied to the result
+///    first, and then either the upper or the lower 128 bits of the result will
+///    be replaced by the contents of \a V2.
+/// \param V2
+///    A 128-bit vector of [2 x double]. The contents of this parameter are
+///    written to either the upper or the lower 128 bits of the result depending
+///    on the value of parameter \a M.
+/// \param M
+///    An immediate integer. The least significant bit determines how the values
+///    from the two parameters are interleaved: \n
+///    If bit [0] of \a M is 0, \a V2 are copied to bits [127:0] of the result,
+///    and bits [255:128] of \a V1 are copied to bits [255:128] of the
+///    result. \n
+///    If bit [0] of \a M is 1, \a V2 are copied to bits [255:128] of the
+///    result, and bits [127:0] of \a V1 are copied to bits [127:0] of the
+///    result.
+/// \returns A 256-bit vector of [4 x double] containing the interleaved values.
+#define _mm256_insertf128_pd(V1, V2, M) \
+  ((__m256d)__builtin_ia32_vinsertf128_pd256((__v4df)(__m256d)(V1), \
+                                             (__v2df)(__m128d)(V2), (int)(M)))
+
+/// Constructs a new 256-bit integer vector by first duplicating a
+///    256-bit integer vector given in the first parameter, and then replacing
+///    either the upper or the lower 128 bits with the contents of a 128-bit
+///    integer vector in the second parameter.
+///
+///    The immediate integer parameter determines between the upper or the lower
+///    128 bits.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m256i _mm256_insertf128_si256(__m256i V1, __m128i V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VINSERTF128 </c> instruction.
+///
+/// \param V1
+///    A 256-bit integer vector. This vector is copied to the result first, and
+///    then either the upper or the lower 128 bits of the result will be
+///    replaced by the contents of \a V2.
+/// \param V2
+///    A 128-bit integer vector. The contents of this parameter are written to
+///    either the upper or the lower 128 bits of the result depending on the
+///     value of parameter \a M.
+/// \param M
+///    An immediate integer. The least significant bit determines how the values
+///    from the two parameters are interleaved: \n
+///    If bit [0] of \a M is 0, \a V2 are copied to bits [127:0] of the result,
+///    and bits [255:128] of \a V1 are copied to bits [255:128] of the
+///    result. \n
+///    If bit [0] of \a M is 1, \a V2 are copied to bits [255:128] of the
+///    result, and bits [127:0] of \a V1 are copied to bits [127:0] of the
+///    result.
+/// \returns A 256-bit integer vector containing the interleaved values.
+#define _mm256_insertf128_si256(V1, V2, M) \
+  ((__m256i)__builtin_ia32_vinsertf128_si256((__v8si)(__m256i)(V1), \
+                                             (__v4si)(__m128i)(V2), (int)(M)))
+
+/*
+   Vector extract.
+   We use macros rather than inlines because we only want to accept
+   invocations where the immediate M is a constant expression.
+*/
+/// Extracts either the upper or the lower 128 bits from a 256-bit vector
+///    of [8 x float], as determined by the immediate integer parameter, and
+///    returns the extracted bits as a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm256_extractf128_ps(__m256 V, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VEXTRACTF128 </c> instruction.
+///
+/// \param V
+///    A 256-bit vector of [8 x float].
+/// \param M
+///    An immediate integer. The least significant bit determines which bits are
+///    extracted from the first parameter: \n
+///    If bit [0] of \a M is 0, bits [127:0] of \a V are copied to the
+///    result. \n
+///    If bit [0] of \a M is 1, bits [255:128] of \a V are copied to the result.
+/// \returns A 128-bit vector of [4 x float] containing the extracted bits.
+#define _mm256_extractf128_ps(V, M) \
+  ((__m128)__builtin_ia32_vextractf128_ps256((__v8sf)(__m256)(V), (int)(M)))
+
+/// Extracts either the upper or the lower 128 bits from a 256-bit vector
+///    of [4 x double], as determined by the immediate integer parameter, and
+///    returns the extracted bits as a 128-bit vector of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm256_extractf128_pd(__m256d V, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VEXTRACTF128 </c> instruction.
+///
+/// \param V
+///    A 256-bit vector of [4 x double].
+/// \param M
+///    An immediate integer. The least significant bit determines which bits are
+///    extracted from the first parameter: \n
+///    If bit [0] of \a M is 0, bits [127:0] of \a V are copied to the
+///    result. \n
+///    If bit [0] of \a M is 1, bits [255:128] of \a V are copied to the result.
+/// \returns A 128-bit vector of [2 x double] containing the extracted bits.
+#define _mm256_extractf128_pd(V, M) \
+  ((__m128d)__builtin_ia32_vextractf128_pd256((__v4df)(__m256d)(V), (int)(M)))
+
+/// Extracts either the upper or the lower 128 bits from a 256-bit
+///    integer vector, as determined by the immediate integer parameter, and
+///    returns the extracted bits as a 128-bit integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm256_extractf128_si256(__m256i V, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VEXTRACTF128 </c> instruction.
+///
+/// \param V
+///    A 256-bit integer vector.
+/// \param M
+///    An immediate integer. The least significant bit determines which bits are
+///    extracted from the first parameter:  \n
+///    If bit [0] of \a M is 0, bits [127:0] of \a V are copied to the
+///    result. \n
+///    If bit [0] of \a M is 1, bits [255:128] of \a V are copied to the result.
+/// \returns A 128-bit integer vector containing the extracted bits.
+#define _mm256_extractf128_si256(V, M) \
+  ((__m128i)__builtin_ia32_vextractf128_si256((__v8si)(__m256i)(V), (int)(M)))
+
+/// Constructs a 256-bit floating-point vector of [8 x float] by
+///    concatenating two 128-bit floating-point vectors of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VINSERTF128 </c> instruction.
+///
+/// \param __hi
+///    A 128-bit floating-point vector of [4 x float] to be copied to the upper
+///    128 bits of the result.
+/// \param __lo
+///    A 128-bit floating-point vector of [4 x float] to be copied to the lower
+///    128 bits of the result.
+/// \returns A 256-bit floating-point vector of [8 x float] containing the
+///    concatenated result.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_set_m128 (__m128 __hi, __m128 __lo)
+{
+  return (__m256) __builtin_shufflevector((__v4sf)__lo, (__v4sf)__hi, 0, 1, 2, 3, 4, 5, 6, 7);
+}
+
+/// Constructs a 256-bit floating-point vector of [4 x double] by
+///    concatenating two 128-bit floating-point vectors of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VINSERTF128 </c> instruction.
+///
+/// \param __hi
+///    A 128-bit floating-point vector of [2 x double] to be copied to the upper
+///    128 bits of the result.
+/// \param __lo
+///    A 128-bit floating-point vector of [2 x double] to be copied to the lower
+///    128 bits of the result.
+/// \returns A 256-bit floating-point vector of [4 x double] containing the
+///    concatenated result.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_set_m128d (__m128d __hi, __m128d __lo)
+{
+  return (__m256d) __builtin_shufflevector((__v2df)__lo, (__v2df)__hi, 0, 1, 2, 3);
+}
+
+/// Constructs a 256-bit integer vector by concatenating two 128-bit
+///    integer vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VINSERTF128 </c> instruction.
+///
+/// \param __hi
+///    A 128-bit integer vector to be copied to the upper 128 bits of the
+///    result.
+/// \param __lo
+///    A 128-bit integer vector to be copied to the lower 128 bits of the
+///    result.
+/// \returns A 256-bit integer vector containing the concatenated result.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_set_m128i (__m128i __hi, __m128i __lo)
+{
+  return (__m256i) __builtin_shufflevector((__v2di)__lo, (__v2di)__hi, 0, 1, 2, 3);
+}
+
+/// Constructs a 256-bit floating-point vector of [8 x float] by
+///    concatenating two 128-bit floating-point vectors of [4 x float]. This is
+///    similar to _mm256_set_m128, but the order of the input parameters is
+///    swapped.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VINSERTF128 </c> instruction.
+///
+/// \param __lo
+///    A 128-bit floating-point vector of [4 x float] to be copied to the lower
+///    128 bits of the result.
+/// \param __hi
+///    A 128-bit floating-point vector of [4 x float] to be copied to the upper
+///    128 bits of the result.
+/// \returns A 256-bit floating-point vector of [8 x float] containing the
+///    concatenated result.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_setr_m128 (__m128 __lo, __m128 __hi)
+{
+  return _mm256_set_m128(__hi, __lo);
+}
+
+/// Constructs a 256-bit floating-point vector of [4 x double] by
+///    concatenating two 128-bit floating-point vectors of [2 x double]. This is
+///    similar to _mm256_set_m128d, but the order of the input parameters is
+///    swapped.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VINSERTF128 </c> instruction.
+///
+/// \param __lo
+///    A 128-bit floating-point vector of [2 x double] to be copied to the lower
+///    128 bits of the result.
+/// \param __hi
+///    A 128-bit floating-point vector of [2 x double] to be copied to the upper
+///    128 bits of the result.
+/// \returns A 256-bit floating-point vector of [4 x double] containing the
+///    concatenated result.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_setr_m128d (__m128d __lo, __m128d __hi)
+{
+  return (__m256d)_mm256_set_m128d(__hi, __lo);
+}
+
+/// Constructs a 256-bit integer vector by concatenating two 128-bit
+///    integer vectors. This is similar to _mm256_set_m128i, but the order of
+///    the input parameters is swapped.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VINSERTF128 </c> instruction.
+///
+/// \param __lo
+///    A 128-bit integer vector to be copied to the lower 128 bits of the
+///    result.
+/// \param __hi
+///    A 128-bit integer vector to be copied to the upper 128 bits of the
+///    result.
+/// \returns A 256-bit integer vector containing the concatenated result.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_setr_m128i (__m128i __lo, __m128i __hi)
+{
+  return (__m256i)_mm256_set_m128i(__hi, __lo);
+}
+
+/* SIMD load ops (unaligned) */
+/// Loads two 128-bit floating-point vectors of [4 x float] from
+///    unaligned memory locations and constructs a 256-bit floating-point vector
+///    of [8 x float] by concatenating the two 128-bit vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to load instructions followed by the
+///   <c> VINSERTF128 </c> instruction.
+///
+/// \param __addr_hi
+///    A pointer to a 128-bit memory location containing 4 consecutive
+///    single-precision floating-point values. These values are to be copied to
+///    bits[255:128] of the result. The address of the memory location does not
+///    have to be aligned.
+/// \param __addr_lo
+///    A pointer to a 128-bit memory location containing 4 consecutive
+///    single-precision floating-point values. These values are to be copied to
+///    bits[127:0] of the result. The address of the memory location does not
+///    have to be aligned.
+/// \returns A 256-bit floating-point vector of [8 x float] containing the
+///    concatenated result.
+static __inline __m256 __DEFAULT_FN_ATTRS
+_mm256_loadu2_m128(float const *__addr_hi, float const *__addr_lo)
+{
+  return _mm256_set_m128(_mm_loadu_ps(__addr_hi), _mm_loadu_ps(__addr_lo));
+}
+
+/// Loads two 128-bit floating-point vectors of [2 x double] from
+///    unaligned memory locations and constructs a 256-bit floating-point vector
+///    of [4 x double] by concatenating the two 128-bit vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to load instructions followed by the
+///   <c> VINSERTF128 </c> instruction.
+///
+/// \param __addr_hi
+///    A pointer to a 128-bit memory location containing two consecutive
+///    double-precision floating-point values. These values are to be copied to
+///    bits[255:128] of the result. The address of the memory location does not
+///    have to be aligned.
+/// \param __addr_lo
+///    A pointer to a 128-bit memory location containing two consecutive
+///    double-precision floating-point values. These values are to be copied to
+///    bits[127:0] of the result. The address of the memory location does not
+///    have to be aligned.
+/// \returns A 256-bit floating-point vector of [4 x double] containing the
+///    concatenated result.
+static __inline __m256d __DEFAULT_FN_ATTRS
+_mm256_loadu2_m128d(double const *__addr_hi, double const *__addr_lo)
+{
+  return _mm256_set_m128d(_mm_loadu_pd(__addr_hi), _mm_loadu_pd(__addr_lo));
+}
+
+/// Loads two 128-bit integer vectors from unaligned memory locations and
+///    constructs a 256-bit integer vector by concatenating the two 128-bit
+///    vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to load instructions followed by the
+///   <c> VINSERTF128 </c> instruction.
+///
+/// \param __addr_hi
+///    A pointer to a 128-bit memory location containing a 128-bit integer
+///    vector. This vector is to be copied to bits[255:128] of the result. The
+///    address of the memory location does not have to be aligned.
+/// \param __addr_lo
+///    A pointer to a 128-bit memory location containing a 128-bit integer
+///    vector. This vector is to be copied to bits[127:0] of the result. The
+///    address of the memory location does not have to be aligned.
+/// \returns A 256-bit integer vector containing the concatenated result.
+static __inline __m256i __DEFAULT_FN_ATTRS
+_mm256_loadu2_m128i(__m128i_u const *__addr_hi, __m128i_u const *__addr_lo)
+{
+   return _mm256_set_m128i(_mm_loadu_si128(__addr_hi), _mm_loadu_si128(__addr_lo));
+}
+
+/* SIMD store ops (unaligned) */
+/// Stores the upper and lower 128 bits of a 256-bit floating-point
+///    vector of [8 x float] into two different unaligned memory locations.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VEXTRACTF128 </c> instruction and the
+///   store instructions.
+///
+/// \param __addr_hi
+///    A pointer to a 128-bit memory location. Bits[255:128] of \a __a are to be
+///    copied to this memory location. The address of this memory location does
+///    not have to be aligned.
+/// \param __addr_lo
+///    A pointer to a 128-bit memory location. Bits[127:0] of \a __a are to be
+///    copied to this memory location. The address of this memory location does
+///    not have to be aligned.
+/// \param __a
+///    A 256-bit floating-point vector of [8 x float].
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_storeu2_m128(float *__addr_hi, float *__addr_lo, __m256 __a)
+{
+  __m128 __v128;
+
+  __v128 = _mm256_castps256_ps128(__a);
+  _mm_storeu_ps(__addr_lo, __v128);
+  __v128 = _mm256_extractf128_ps(__a, 1);
+  _mm_storeu_ps(__addr_hi, __v128);
+}
+
+/// Stores the upper and lower 128 bits of a 256-bit floating-point
+///    vector of [4 x double] into two different unaligned memory locations.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VEXTRACTF128 </c> instruction and the
+///   store instructions.
+///
+/// \param __addr_hi
+///    A pointer to a 128-bit memory location. Bits[255:128] of \a __a are to be
+///    copied to this memory location. The address of this memory location does
+///    not have to be aligned.
+/// \param __addr_lo
+///    A pointer to a 128-bit memory location. Bits[127:0] of \a __a are to be
+///    copied to this memory location. The address of this memory location does
+///    not have to be aligned.
+/// \param __a
+///    A 256-bit floating-point vector of [4 x double].
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_storeu2_m128d(double *__addr_hi, double *__addr_lo, __m256d __a)
+{
+  __m128d __v128;
+
+  __v128 = _mm256_castpd256_pd128(__a);
+  _mm_storeu_pd(__addr_lo, __v128);
+  __v128 = _mm256_extractf128_pd(__a, 1);
+  _mm_storeu_pd(__addr_hi, __v128);
+}
+
+/// Stores the upper and lower 128 bits of a 256-bit integer vector into
+///    two different unaligned memory locations.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VEXTRACTF128 </c> instruction and the
+///   store instructions.
+///
+/// \param __addr_hi
+///    A pointer to a 128-bit memory location. Bits[255:128] of \a __a are to be
+///    copied to this memory location. The address of this memory location does
+///    not have to be aligned.
+/// \param __addr_lo
+///    A pointer to a 128-bit memory location. Bits[127:0] of \a __a are to be
+///    copied to this memory location. The address of this memory location does
+///    not have to be aligned.
+/// \param __a
+///    A 256-bit integer vector.
+static __inline void __DEFAULT_FN_ATTRS
+_mm256_storeu2_m128i(__m128i_u *__addr_hi, __m128i_u *__addr_lo, __m256i __a)
+{
+  __m128i __v128;
+
+  __v128 = _mm256_castsi256_si128(__a);
+  _mm_storeu_si128(__addr_lo, __v128);
+  __v128 = _mm256_extractf128_si256(__a, 1);
+  _mm_storeu_si128(__addr_hi, __v128);
+}
+
+#undef __DEFAULT_FN_ATTRS
+#undef __DEFAULT_FN_ATTRS128
+
+#endif /* __AVXINTRIN_H */
diff --git a/third_party/intel/clang/avxneconvertintrin.h b/third_party/intel/clang/avxneconvertintrin.h
new file mode 100644
index 000000000..1bef1c893
--- /dev/null
+++ b/third_party/intel/clang/avxneconvertintrin.h
@@ -0,0 +1,484 @@
+/*===-------------- avxneconvertintrin.h - AVXNECONVERT --------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error                                                                         \
+    "Never use <avxneconvertintrin.h> directly; include <immintrin.h> instead."
+#endif // __IMMINTRIN_H
+
+#ifdef __SSE2__
+
+#ifndef __AVXNECONVERTINTRIN_H
+#define __AVXNECONVERTINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avxneconvert"),   \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avxneconvert"),   \
+                 __min_vector_width__(256)))
+
+/// Convert scalar BF16 (16-bit) floating-point element
+/// stored at memory locations starting at location \a __A to a
+/// single-precision (32-bit) floating-point, broadcast it to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_bcstnebf16_ps(const void *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VBCSTNEBF162PS instruction.
+///
+/// \param __A
+///    A pointer to a 16-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \returns
+///    A 128-bit vector of [4 x float].
+///
+/// \code{.operation}
+/// b := Convert_BF16_To_FP32(MEM[__A+15:__A])
+/// FOR j := 0 to 3
+///   m := j*32
+///   dst[m+31:m] := b
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_bcstnebf16_ps(const void *__A) {
+  return (__m128)__builtin_ia32_vbcstnebf162ps128((const __bf16 *)__A);
+}
+
+/// Convert scalar BF16 (16-bit) floating-point element
+/// stored at memory locations starting at location \a __A to a
+/// single-precision (32-bit) floating-point, broadcast it to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_bcstnebf16_ps(const void *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VBCSTNEBF162PS instruction.
+///
+/// \param __A
+///    A pointer to a 16-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \returns
+///    A 256-bit vector of [8 x float].
+///
+/// \code{.operation}
+/// b := Convert_BF16_To_FP32(MEM[__A+15:__A])
+/// FOR j := 0 to 7
+///   m := j*32
+///   dst[m+31:m] := b
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_bcstnebf16_ps(const void *__A) {
+  return (__m256)__builtin_ia32_vbcstnebf162ps256((const __bf16 *)__A);
+}
+
+/// Convert scalar half-precision (16-bit) floating-point element
+/// stored at memory locations starting at location \a __A to a
+/// single-precision (32-bit) floating-point, broadcast it to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_bcstnesh_ps(const void *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VBCSTNESH2PS instruction.
+///
+/// \param __A
+///    A pointer to a 16-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \returns
+///    A 128-bit vector of [4 x float].
+///
+/// \code{.operation}
+/// b := Convert_FP16_To_FP32(MEM[__A+15:__A])
+/// FOR j := 0 to 3
+///   m := j*32
+///   dst[m+31:m] := b
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_bcstnesh_ps(const void *__A) {
+  return (__m128)__builtin_ia32_vbcstnesh2ps128((const _Float16 *)__A);
+}
+
+/// Convert scalar half-precision (16-bit) floating-point element
+/// stored at memory locations starting at location \a __A to a
+/// single-precision (32-bit) floating-point, broadcast it to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_bcstnesh_ps(const void *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VBCSTNESH2PS instruction.
+///
+/// \param __A
+///    A pointer to a 16-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \returns
+///    A 256-bit vector of [8 x float].
+///
+/// \code{.operation}
+/// b := Convert_FP16_To_FP32(MEM[__A+15:__A])
+/// FOR j := 0 to 7
+///   m := j*32
+///   dst[m+31:m] := b
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_bcstnesh_ps(const void *__A) {
+  return (__m256)__builtin_ia32_vbcstnesh2ps256((const _Float16 *)__A);
+}
+
+/// Convert packed BF16 (16-bit) floating-point even-indexed elements
+/// stored at memory locations starting at location \a __A to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_cvtneebf16_ps(const __m128bh *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VCVTNEEBF162PS instruction.
+///
+/// \param __A
+///    A pointer to a 128-bit memory location containing 8 consecutive
+///    BF16 (16-bit) floating-point values.
+/// \returns
+///    A 128-bit vector of [4 x float].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	k := j*2
+/// 	i := k*16
+/// 	m := j*32
+/// 	dst[m+31:m] := Convert_BF16_To_FP32(MEM[__A+i+15:__A+i])
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_cvtneebf16_ps(const __m128bh *__A) {
+  return (__m128)__builtin_ia32_vcvtneebf162ps128((const __v8bf *)__A);
+}
+
+/// Convert packed BF16 (16-bit) floating-point even-indexed elements
+/// stored at memory locations starting at location \a __A to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_cvtneebf16_ps(const __m256bh *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VCVTNEEBF162PS instruction.
+///
+/// \param __A
+///    A pointer to a 256-bit memory location containing 16 consecutive
+///    BF16 (16-bit) floating-point values.
+/// \returns
+///    A 256-bit vector of [8 x float].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	k := j*2
+/// 	i := k*16
+/// 	m := j*32
+/// 	dst[m+31:m] := Convert_BF16_To_FP32(MEM[__A+i+15:__A+i])
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_cvtneebf16_ps(const __m256bh *__A) {
+  return (__m256)__builtin_ia32_vcvtneebf162ps256((const __v16bf *)__A);
+}
+
+/// Convert packed half-precision (16-bit) floating-point even-indexed elements
+/// stored at memory locations starting at location \a __A to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_cvtneeph_ps(const __m128h *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VCVTNEEPH2PS instruction.
+///
+/// \param __A
+///    A pointer to a 128-bit memory location containing 8 consecutive
+///    half-precision (16-bit) floating-point values.
+/// \returns
+///    A 128-bit vector of [4 x float].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	k := j*2
+/// 	i := k*16
+/// 	m := j*32
+/// 	dst[m+31:m] := Convert_FP16_To_FP32(MEM[__A+i+15:__A+i])
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_cvtneeph_ps(const __m128h *__A) {
+  return (__m128)__builtin_ia32_vcvtneeph2ps128((const __v8hf *)__A);
+}
+
+/// Convert packed half-precision (16-bit) floating-point even-indexed elements
+/// stored at memory locations starting at location \a __A to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_cvtneeph_ps(const __m256h *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VCVTNEEPH2PS instruction.
+///
+/// \param __A
+///    A pointer to a 256-bit memory location containing 16 consecutive
+///    half-precision (16-bit) floating-point values.
+/// \returns
+///    A 256-bit vector of [8 x float].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	k := j*2
+/// 	i := k*16
+/// 	m := j*32
+/// 	dst[m+31:m] := Convert_FP16_To_FP32(MEM[__A+i+15:__A+i])
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_cvtneeph_ps(const __m256h *__A) {
+  return (__m256)__builtin_ia32_vcvtneeph2ps256((const __v16hf *)__A);
+}
+
+/// Convert packed BF16 (16-bit) floating-point odd-indexed elements
+/// stored at memory locations starting at location \a __A to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_cvtneobf16_ps(const __m128bh *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VCVTNEOBF162PS instruction.
+///
+/// \param __A
+///    A pointer to a 128-bit memory location containing 8 consecutive
+///    BF16 (16-bit) floating-point values.
+/// \returns
+///    A 128-bit vector of [4 x float].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	k := j*2+1
+/// 	i := k*16
+/// 	m := j*32
+/// 	dst[m+31:m] := Convert_BF16_To_FP32(MEM[__A+i+15:__A+i])
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_cvtneobf16_ps(const __m128bh *__A) {
+  return (__m128)__builtin_ia32_vcvtneobf162ps128((const __v8bf *)__A);
+}
+
+/// Convert packed BF16 (16-bit) floating-point odd-indexed elements
+/// stored at memory locations starting at location \a __A to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_cvtneobf16_ps(const __m256bh *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VCVTNEOBF162PS instruction.
+///
+/// \param __A
+///    A pointer to a 256-bit memory location containing 16 consecutive
+///    BF16 (16-bit) floating-point values.
+/// \returns
+///    A 256-bit vector of [8 x float].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	k := j*2+1
+/// 	i := k*16
+/// 	m := j*32
+/// 	dst[m+31:m] := Convert_BF16_To_FP32(MEM[__A+i+15:__A+i])
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_cvtneobf16_ps(const __m256bh *__A) {
+  return (__m256)__builtin_ia32_vcvtneobf162ps256((const __v16bf *)__A);
+}
+
+/// Convert packed half-precision (16-bit) floating-point odd-indexed elements
+/// stored at memory locations starting at location \a __A to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_cvtneoph_ps(const __m128h *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VCVTNEOPH2PS instruction.
+///
+/// \param __A
+///    A pointer to a 128-bit memory location containing 8 consecutive
+///    half-precision (16-bit) floating-point values.
+/// \returns
+///    A 128-bit vector of [4 x float].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	k := j*2+1
+/// 	i := k*16
+/// 	m := j*32
+/// 	dst[m+31:m] := Convert_FP16_To_FP32(MEM[__A+i+15:__A+i])
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_cvtneoph_ps(const __m128h *__A) {
+  return (__m128)__builtin_ia32_vcvtneoph2ps128((const __v8hf *)__A);
+}
+
+/// Convert packed half-precision (16-bit) floating-point odd-indexed elements
+/// stored at memory locations starting at location \a __A to packed
+/// single-precision (32-bit) floating-point elements, and store the results in
+/// \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_cvtneoph_ps(const __m256h *__A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VCVTNEOPH2PS instruction.
+///
+/// \param __A
+///    A pointer to a 256-bit memory location containing 16 consecutive
+///    half-precision (16-bit) floating-point values.
+/// \returns
+///    A 256-bit vector of [8 x float].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	k := j*2+1
+/// 	i := k*16
+/// 	m := j*32
+/// 	dst[m+31:m] := Convert_FP16_To_FP32(MEM[__A+i+15:__A+i])
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_cvtneoph_ps(const __m256h *__A) {
+  return (__m256)__builtin_ia32_vcvtneoph2ps256((const __v16hf *)__A);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+/// to packed BF16 (16-bit) floating-point elements, and store the results in \a
+/// dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_cvtneps_avx_pbh(__m128 __A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VCVTNEPS2BF16 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float].
+/// \returns
+///    A 128-bit vector of [8 x bfloat].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	dst.word[j] := Convert_FP32_To_BF16(__A.fp32[j])
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128bh __DEFAULT_FN_ATTRS128
+_mm_cvtneps_avx_pbh(__m128 __A) {
+  return (__m128bh)__builtin_ia32_vcvtneps2bf16128((__v4sf)__A);
+}
+
+/// Convert packed single-precision (32-bit) floating-point elements in \a __A
+/// to packed BF16 (16-bit) floating-point elements, and store the results in \a
+/// dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_cvtneps_avx_pbh(__m256 __A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VCVTNEPS2BF16 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float].
+/// \returns
+///    A 128-bit vector of [8 x bfloat].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	dst.word[j] := Convert_FP32_To_BF16(a.fp32[j])
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128bh __DEFAULT_FN_ATTRS256
+_mm256_cvtneps_avx_pbh(__m256 __A) {
+  return (__m128bh)__builtin_ia32_vcvtneps2bf16256((__v8sf)__A);
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif // __AVXNECONVERTINTRIN_H
+#endif // __SSE2__
diff --git a/third_party/intel/clang/avxvnniint16intrin.h b/third_party/intel/clang/avxvnniint16intrin.h
new file mode 100644
index 000000000..e4d342a8b
--- /dev/null
+++ b/third_party/intel/clang/avxvnniint16intrin.h
@@ -0,0 +1,473 @@
+/*===----------- avxvnniint16intrin.h - AVXVNNIINT16 intrinsics-------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error                                                                         \
+    "Never use <avxvnniint16intrin.h> directly; include <immintrin.h> instead."
+#endif // __IMMINTRIN_H
+
+#ifndef __AVXVNNIINT16INTRIN_H
+#define __AVXVNNIINT16INTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avxvnniint16"),   \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avxvnniint16"),   \
+                 __min_vector_width__(256)))
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a __A with
+///    corresponding unsigned 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_dpwsud_epi32(__m128i __W, __m128i __A, __m128i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWSUD instruction.
+///
+/// \param __W
+///    A 128-bit vector of [4 x int].
+/// \param __A
+///    A 128-bit vector of [8 x short].
+/// \param __B
+///    A 128-bit vector of [8 x unsigned short].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.dword := SignExtend32(__A.word[2*j]) * ZeroExtend32(__B.word[2*j])
+/// 	tmp2.dword := SignExtend32(__A.word[2*j+1]) * ZeroExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpwsud_epi32(__m128i __W,
+                                                                 __m128i __A,
+                                                                 __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpwsud128((__v4si)__W, (__v4si)__A,
+                                             (__v4si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a __A with
+///    corresponding unsigned 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_dpwsud_epi32(__m256i __W, __m256i __A, __m256i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWSUD instruction.
+///
+/// \param __W
+///    A 256-bit vector of [8 x int].
+/// \param __A
+///    A 256-bit vector of [16 x short].
+/// \param __B
+///    A 256-bit vector of [16 x unsigned short].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.dword := SignExtend32(__A.word[2*j]) * ZeroExtend32(__B.word[2*j])
+/// 	tmp2.dword := SignExtend32(__A.word[2*j+1]) * ZeroExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpwsud_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpwsud256((__v8si)__W, (__v8si)__A,
+                                             (__v8si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a __A with
+///    corresponding unsigned 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_dpwsuds_epi32(__m128i __W, __m128i __A, __m128i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWSUDS instruction.
+///
+/// \param __W
+///    A 128-bit vector of [4 x int].
+/// \param __A
+///    A 128-bit vector of [8 x short].
+/// \param __B
+///    A 128-bit vector of [8 x unsigned short].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.dword := SignExtend32(__A.word[2*j]) * ZeroExtend32(__B.word[2*j])
+/// 	tmp2.dword := SignExtend32(__A.word[2*j+1]) * ZeroExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := SIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2)
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpwsuds_epi32(__m128i __W,
+                                                                  __m128i __A,
+                                                                  __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpwsuds128((__v4si)__W, (__v4si)__A,
+                                              (__v4si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a __A with
+///    corresponding unsigned 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_dpwsuds_epi32(__m256i __W, __m256i __A, __m256i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWSUDS instruction.
+///
+/// \param __W
+///    A 256-bit vector of [8 x int].
+/// \param __A
+///    A 256-bit vector of [16 x short].
+/// \param __B
+///    A 256-bit vector of [16 x unsigned short].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.dword := SignExtend32(__A.word[2*j]) * ZeroExtend32(__B.word[2*j])
+/// 	tmp2.dword := SignExtend32(__A.word[2*j+1]) * ZeroExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := SIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2)
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpwsuds_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpwsuds256((__v8si)__W, (__v8si)__A,
+                                              (__v8si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of unsigned 16-bit integers in \a __A with
+///    corresponding signed 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_dpbusd_epi32(__m128i __W, __m128i __A, __m128i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWUSD instruction.
+///
+/// \param __W
+///    A 128-bit vector of [4 x int].
+/// \param __A
+///    A 128-bit vector of [8 x unsigned short].
+/// \param __B
+///    A 128-bit vector of [8 x short].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.dword := ZeroExtend32(__A.word[2*j]) * SignExtend32(__B.word[2*j])
+/// 	tmp2.dword := ZeroExtend32(__A.word[2*j+1]) * SignExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpwusd_epi32(__m128i __W,
+                                                                 __m128i __A,
+                                                                 __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpwusd128((__v4si)__W, (__v4si)__A,
+                                             (__v4si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of unsigned 16-bit integers in \a __A with
+///    corresponding signed 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_dpwusd_epi32(__m256i __W, __m256i __A, __m256i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWUSD instruction.
+///
+/// \param __W
+///    A 256-bit vector of [8 x int].
+/// \param __A
+///    A 256-bit vector of [16 x unsigned short].
+/// \param __B
+///    A 256-bit vector of [16 x short].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.dword := ZeroExtend32(__A.word[2*j]) * SignExtend32(__B.word[2*j])
+/// 	tmp2.dword := ZeroExtend32(__A.word[2*j+1]) * SignExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpwusd_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpwusd256((__v8si)__W, (__v8si)__A,
+                                             (__v8si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of unsigned 16-bit integers in \a __A with
+///    corresponding signed 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_dpwusds_epi32(__m128i __W, __m128i __A, __m128i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWSUDS instruction.
+///
+/// \param __W
+///    A 128-bit vector of [4 x int].
+/// \param __A
+///    A 128-bit vector of [8 x unsigned short].
+/// \param __B
+///    A 128-bit vector of [8 x short].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.dword := ZeroExtend32(__A.word[2*j]) * SignExtend32(__B.word[2*j])
+/// 	tmp2.dword := ZeroExtend32(__A.word[2*j+1]) * SignExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := SIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2)
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpwusds_epi32(__m128i __W,
+                                                                  __m128i __A,
+                                                                  __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpwusds128((__v4si)__W, (__v4si)__A,
+                                              (__v4si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of unsigned 16-bit integers in \a __A with
+///    corresponding signed 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_dpwsuds_epi32(__m256i __W, __m256i __A, __m256i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWSUDS instruction.
+///
+/// \param __W
+///    A 256-bit vector of [8 x int].
+/// \param __A
+///    A 256-bit vector of [16 x unsigned short].
+/// \param __B
+///    A 256-bit vector of [16 x short].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.dword := ZeroExtend32(__A.word[2*j]) * SignExtend32(__B.word[2*j])
+/// 	tmp2.dword := ZeroExtend32(__A.word[2*j+1]) * SignExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := SIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2)
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpwusds_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpwusds256((__v8si)__W, (__v8si)__A,
+                                              (__v8si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of unsigned 16-bit integers in \a __A with
+///    corresponding unsigned 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_dpwuud_epi32(__m128i __W, __m128i __A, __m128i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWUUD instruction.
+///
+/// \param __W
+///    A 128-bit vector of [4 x unsigned int].
+/// \param __A
+///    A 128-bit vector of [8 x unsigned short].
+/// \param __B
+///    A 128-bit vector of [8 x unsigned short].
+/// \returns
+///    A 128-bit vector of [4 x unsigned int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.dword := ZeroExtend32(__A.word[2*j]) * ZeroExtend32(__B.word[2*j])
+/// 	tmp2.dword := ZeroExtend32(__A.word[2*j+1]) * ZeroExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpwuud_epi32(__m128i __W,
+                                                                 __m128i __A,
+                                                                 __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpwuud128((__v4si)__W, (__v4si)__A,
+                                             (__v4si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of unsigned 16-bit integers in \a __A with
+///    corresponding unsigned 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_dpwuud_epi32(__m256i __W, __m256i __A, __m256i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWUUD instruction.
+///
+/// \param __W
+///    A 256-bit vector of [8 x unsigned int].
+/// \param __A
+///    A 256-bit vector of [16 x unsigned short].
+/// \param __B
+///    A 256-bit vector of [16 x unsigned short].
+/// \returns
+///    A 256-bit vector of [8 x unsigned int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.dword := ZeroExtend32(__A.word[2*j]) * ZeroExtend32(__B.word[2*j])
+/// 	tmp2.dword := ZeroExtend32(__A.word[2*j+1]) * ZeroExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpwuud_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpwuud256((__v8si)__W, (__v8si)__A,
+                                             (__v8si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of unsigned 16-bit integers in \a __A with
+///    corresponding unsigned 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_dpwsuds_epi32(__m128i __W, __m128i __A, __m128i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWSUDS instruction.
+///
+/// \param __W
+///    A 128-bit vector of [4 x unsigned int].
+/// \param __A
+///    A 128-bit vector of [8 x unsigned short].
+/// \param __B
+///    A 128-bit vector of [8 x unsigned short].
+/// \returns
+///    A 128-bit vector of [4 x unsigned int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.dword := ZeroExtend32(__A.word[2*j]) * ZeroExtend32(__B.word[2*j])
+/// 	tmp2.dword := ZeroExtend32(__A.word[2*j+1]) * ZeroExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := UNSIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2)
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpwuuds_epi32(__m128i __W,
+                                                                  __m128i __A,
+                                                                  __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpwuuds128((__v4si)__W, (__v4si)__A,
+                                              (__v4si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of unsigned 16-bit integers in \a __A with
+///    corresponding unsigned 16-bit integers in \a __B, producing 2 intermediate
+///    signed 16-bit results. Sum these 2 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_dpwuuds_epi32(__m256i __W, __m256i __A, __m256i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPWSUDS instruction.
+///
+/// \param __W
+///    A 256-bit vector of [8 x unsigned int].
+/// \param __A
+///    A 256-bit vector of [16 x unsigned short].
+/// \param __B
+///    A 256-bit vector of [16 x unsigned short].
+/// \returns
+///    A 256-bit vector of [8 x unsigned int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.dword := ZeroExtend32(__A.word[2*j]) * ZeroExtend32(__B.word[2*j])
+/// 	tmp2.dword := ZeroExtend32(__A.word[2*j+1]) * ZeroExtend32(__B.word[2*j+1])
+/// 	dst.dword[j] := UNSIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2)
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpwuuds_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpwuuds256((__v8si)__W, (__v8si)__A,
+                                              (__v8si)__B);
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif // __AVXVNNIINT16INTRIN_H
diff --git a/third_party/intel/clang/avxvnniint8intrin.h b/third_party/intel/clang/avxvnniint8intrin.h
new file mode 100644
index 000000000..b0b6cb853
--- /dev/null
+++ b/third_party/intel/clang/avxvnniint8intrin.h
@@ -0,0 +1,471 @@
+/*===-------- avxvnniint8intrin.h - AVXVNNIINT8 intrinsics -----------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error                                                                         \
+    "Never use <avxvnniint8intrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVXVNNIINT8INTRIN_H
+#define __AVXVNNIINT8INTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avxvnniint8"),    \
+                 __min_vector_width__(256)))
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("avxvnniint8"),    \
+                 __min_vector_width__(128)))
+
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in \a __A with
+///    corresponding signed 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_dpbssd_epi32(__m128i __W, __m128i __A, __m128i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBSSD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x char].
+/// \param __B
+///    A 128-bit vector of [16 x char].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.word := SignExtend16(__A.byte[4*j]) * SignExtend16(__B.byte[4*j])
+/// 	tmp2.word := SignExtend16(__A.byte[4*j+1]) * SignExtend16(__B.byte[4*j+1])
+/// 	tmp3.word := SignExtend16(__A.byte[4*j+2]) * SignExtend16(__B.byte[4*j+2])
+/// 	tmp4.word := SignExtend16(__A.byte[4*j+3]) * SignExtend16(__B.byte[4*j+3])
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpbssd_epi32(__m128i __W,
+                                                                 __m128i __A,
+                                                                 __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpbssd128((__v4si)__W, (__v4si)__A,
+                                             (__v4si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in \a __A with
+///    corresponding signed 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_dpbssd_epi32(__m256i __W, __m256i __A, __m256i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBSSD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [32 x char].
+/// \param __B
+///    A 256-bit vector of [32 x char].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.word := SignExtend16(__A.byte[4*j]) * SignExtend16(__B.byte[4*j])
+/// 	tmp2.word := SignExtend16(__A.byte[4*j+1]) * SignExtend16(__B.byte[4*j+1])
+/// 	tmp3.word := SignExtend16(__A.byte[4*j+2]) * SignExtend16(__B.byte[4*j+2])
+/// 	tmp4.word := SignExtend16(__A.byte[4*j+3]) * SignExtend16(__B.byte[4*j+3])
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpbssd_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpbssd256((__v8si)__W, (__v8si)__A,
+                                             (__v8si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in \a __A with
+///    corresponding signed 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_dpbssds_epi32( __m128i __W, __m128i __A, __m128i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBSSD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x char].
+/// \param __B
+///    A 128-bit vector of [16 x char].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.word := SignExtend16(__A.byte[4*j]) * SignExtend16(__B.byte[4*j])
+/// 	tmp2.word := SignExtend16(__A.byte[4*j+1]) * SignExtend16(__B.byte[4*j+1])
+/// 	tmp3.word := SignExtend16(__A.byte[4*j+2]) * SignExtend16(__B.byte[4*j+2])
+/// 	tmp4.word := SignExtend16(__A.byte[4*j+3]) * SignExtend16(__B.byte[4*j+3])
+/// 	dst.dword[j] := SIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4)
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpbssds_epi32(__m128i __W,
+                                                                  __m128i __A,
+                                                                  __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpbssds128((__v4si)__W, (__v4si)__A,
+                                              (__v4si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in \a __A with
+///    corresponding signed 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_dpbssds_epi32(__m256i __W, __m256i __A, __m256i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBSSD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [32 x char].
+/// \param __B
+///    A 256-bit vector of [32 x char].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.word := SignExtend16(__A.byte[4*j]) * SignExtend16(__B.byte[4*j])
+/// 	tmp2.word := SignExtend16(__A.byte[4*j+1]) * SignExtend16(__B.byte[4*j+1])
+/// 	tmp3.word := SignExtend16(__A.byte[4*j+2]) * SignExtend16(__B.byte[4*j+2])
+/// 	tmp4.word := SignExtend16(__A.byte[4*j+3]) * SignExtend16(__B.byte[4*j+3])
+/// 	dst.dword[j] := SIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4)
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpbssds_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpbssds256((__v8si)__W, (__v8si)__A,
+                                              (__v8si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in \a __A with
+///    corresponding unsigned 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_dpbsud_epi32(__m128i __W, __m128i __A, __m128i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBSSD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x char].
+/// \param __B
+///    A 128-bit vector of [16 x unsigned char].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.word := Signed(SignExtend16(__A.byte[4*j]) * ZeroExtend16(__B.byte[4*j]))
+/// 	tmp2.word := Signed(SignExtend16(__A.byte[4*j+1]) * ZeroExtend16(__B.byte[4*j+1]))
+/// 	tmp3.word := Signed(SignExtend16(__A.byte[4*j+2]) * ZeroExtend16(__B.byte[4*j+2]))
+/// 	tmp4.word := Signed(SignExtend16(__A.byte[4*j+3]) * ZeroExtend16(__B.byte[4*j+3]))
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpbsud_epi32(__m128i __W,
+                                                                 __m128i __A,
+                                                                 __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpbsud128((__v4si)__W, (__v4si)__A,
+                                             (__v4si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in \a __A with
+///    corresponding unsigned 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_dpbsud_epi32(__m256i __W, __m256i __A, __m256i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBSSD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [32 x char].
+/// \param __B
+///    A 256-bit vector of [32 x unsigned char].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.word := Signed(SignExtend16(__A.byte[4*j]) * ZeroExtend16(__B.byte[4*j]))
+/// 	tmp2.word := Signed(SignExtend16(__A.byte[4*j+1]) * ZeroExtend16(__B.byte[4*j+1]))
+/// 	tmp3.word := Signed(SignExtend16(__A.byte[4*j+2]) * ZeroExtend16(__B.byte[4*j+2]))
+/// 	tmp4.word := Signed(SignExtend16(__A.byte[4*j+3]) * ZeroExtend16(__B.byte[4*j+3]))
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpbsud_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpbsud256((__v8si)__W, (__v8si)__A,
+                                             (__v8si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in \a __A with
+///    corresponding unsigned 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_dpbsuds_epi32( __m128i __W, __m128i __A, __m128i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBSSD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x char].
+/// \param __B
+///    A 128-bit vector of [16 x unsigned char].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.word := Signed(SignExtend16(__A.byte[4*j]) * ZeroExtend16(__B.byte[4*j]))
+/// 	tmp2.word := Signed(SignExtend16(__A.byte[4*j+1]) * ZeroExtend16(__B.byte[4*j+1]))
+/// 	tmp3.word := Signed(SignExtend16(__A.byte[4*j+2]) * ZeroExtend16(__B.byte[4*j+2]))
+/// 	tmp4.word := Signed(SignExtend16(__A.byte[4*j+3]) * ZeroExtend16(__B.byte[4*j+3]))
+/// 	dst.dword[j] := SIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4)
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpbsuds_epi32(__m128i __W,
+                                                                  __m128i __A,
+                                                                  __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpbsuds128((__v4si)__W, (__v4si)__A,
+                                              (__v4si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in \a __A with
+///    corresponding unsigned 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_dpbsuds_epi32(__m256i __W, __m256i __A, __m256i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBSSD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [32 x char].
+/// \param __B
+///    A 256-bit vector of [32 x unsigned char].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.word := Signed(SignExtend16(__A.byte[4*j]) * ZeroExtend16(__B.byte[4*j]))
+/// 	tmp2.word := Signed(SignExtend16(__A.byte[4*j+1]) * ZeroExtend16(__B.byte[4*j+1]))
+/// 	tmp3.word := Signed(SignExtend16(__A.byte[4*j+2]) * ZeroExtend16(__B.byte[4*j+2]))
+/// 	tmp4.word := Signed(SignExtend16(__A.byte[4*j+3]) * ZeroExtend16(__B.byte[4*j+3]))
+/// 	dst.dword[j] := SIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4)
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpbsuds_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpbsuds256((__v8si)__W, (__v8si)__A,
+                                              (__v8si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a __A with
+///    corresponding unsigned 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_dpbuud_epi32(__m128i __W, __m128i __A, __m128i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBSSD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x unsigned char].
+/// \param __B
+///    A 128-bit vector of [16 x unsigned char].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.word := ZeroExtend16(__A.byte[4*j]) * ZeroExtend16(__B.byte[4*j])
+/// 	tmp2.word := ZeroExtend16(__A.byte[4*j+1]) * ZeroExtend16(__B.byte[4*j+1])
+/// 	tmp3.word := ZeroExtend16(__A.byte[4*j+2]) * ZeroExtend16(__B.byte[4*j+2])
+/// 	tmp4.word := ZeroExtend16(__A.byte[4*j+3]) * ZeroExtend16(__B.byte[4*j+3])
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpbuud_epi32(__m128i __W,
+                                                                 __m128i __A,
+                                                                 __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpbuud128((__v4si)__W, (__v4si)__A,
+                                             (__v4si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a __A with
+///    corresponding unsigned 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W, and store the packed 32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_dpbuud_epi32(__m256i __W, __m256i __A, __m256i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBSSD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [32 x unsigned char].
+/// \param __B
+///    A 256-bit vector of [32 x unsigned char].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.word := ZeroExtend16(__A.byte[4*j]) * ZeroExtend16(__B.byte[4*j])
+/// 	tmp2.word := ZeroExtend16(__A.byte[4*j+1]) * ZeroExtend16(__B.byte[4*j+1])
+/// 	tmp3.word := ZeroExtend16(__A.byte[4*j+2]) * ZeroExtend16(__B.byte[4*j+2])
+/// 	tmp4.word := ZeroExtend16(__A.byte[4*j+3]) * ZeroExtend16(__B.byte[4*j+3])
+/// 	dst.dword[j] := __W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpbuud_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpbuud256((__v8si)__W, (__v8si)__A,
+                                             (__v8si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a __A with
+///    corresponding unsigned 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm_dpbuuds_epi32( __m128i __W, __m128i __A, __m128i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBUUDS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [16 x unsigned char].
+/// \param __B
+///    A 128-bit vector of [16 x unsigned char].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 3
+/// 	tmp1.word := ZeroExtend16(__A.byte[4*j]) * ZeroExtend16(__B.byte[4*j])
+/// 	tmp2.word := ZeroExtend16(__A.byte[4*j+1]) * ZeroExtend16(__B.byte[4*j+1])
+/// 	tmp3.word := ZeroExtend16(__A.byte[4*j+2]) * ZeroExtend16(__B.byte[4*j+2])
+/// 	tmp4.word := ZeroExtend16(__A.byte[4*j+3]) * ZeroExtend16(__B.byte[4*j+3])
+/// 	dst.dword[j] := UNSIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4)
+/// ENDFOR
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_dpbuuds_epi32(__m128i __W,
+                                                                  __m128i __A,
+                                                                  __m128i __B) {
+  return (__m128i)__builtin_ia32_vpdpbuuds128((__v4si)__W, (__v4si)__A,
+                                              (__v4si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of signed 8-bit integers in \a __A with
+///    corresponding unsigned 8-bit integers in \a __B, producing 4 intermediate
+///    signed 16-bit results. Sum these 4 results with the corresponding
+///    32-bit integer in \a __W with signed saturation, and store the packed
+///    32-bit results in \a dst.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// _mm256_dpbuuds_epi32(__m256i __W, __m256i __A, __m256i __B);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VPDPBUUDS instruction.
+///
+/// \param __A
+///    A 256-bit vector of [32 x unsigned char].
+/// \param __B
+///    A 256-bit vector of [32 x unsigned char].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// FOR j := 0 to 7
+/// 	tmp1.word := ZeroExtend16(__A.byte[4*j]) * ZeroExtend16(__B.byte[4*j])
+/// 	tmp2.word := ZeroExtend16(__A.byte[4*j+1]) * ZeroExtend16(__B.byte[4*j+1])
+/// 	tmp3.word := ZeroExtend16(__A.byte[4*j+2]) * ZeroExtend16(__B.byte[4*j+2])
+/// 	tmp4.word := ZeroExtend16(__A.byte[4*j+3]) * ZeroExtend16(__B.byte[4*j+3])
+/// 	dst.dword[j] := UNSIGNED_DWORD_SATURATE(__W.dword[j] + tmp1 + tmp2 + tmp3 + tmp4)
+/// ENDFOR
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpbuuds_epi32(__m256i __W, __m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vpdpbuuds256((__v8si)__W, (__v8si)__A,
+                                              (__v8si)__B);
+}
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif // __AVXVNNIINT8INTRIN_H
diff --git a/third_party/intel/clang/avxvnniintrin.h b/third_party/intel/clang/avxvnniintrin.h
new file mode 100644
index 000000000..b7de562b5
--- /dev/null
+++ b/third_party/intel/clang/avxvnniintrin.h
@@ -0,0 +1,225 @@
+/*===--------------- avxvnniintrin.h - VNNI intrinsics --------------------===
+ *
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <avxvnniintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __AVXVNNIINTRIN_H
+#define __AVXVNNIINTRIN_H
+
+/* Below intrinsics defined in avx512vlvnniintrin.h can be used for AVXVNNI */
+/// \fn __m256i _mm256_dpbusd_epi32(__m256i __S, __m256i __A, __m256i __B)
+/// \fn __m256i _mm256_dpbusds_epi32(__m256i __S, __m256i __A, __m256i __B)
+/// \fn __m256i _mm256_dpwssd_epi32(__m256i __S, __m256i __A, __m256i __B)
+/// \fn __m256i _mm256_dpwssds_epi32(__m256i __S, __m256i __A, __m256i __B)
+/// \fn __m128i _mm_dpbusd_epi32(__m128i __S, __m128i __A, __m128i __B)
+/// \fn __m128i _mm_dpbusds_epi32(__m128i __S, __m128i __A, __m128i __B)
+/// \fn __m128i _mm_dpwssd_epi32(__m128i __S, __m128i __A, __m128i __B)
+/// \fn __m128i _mm_dpwssds_epi32(__m128i __S, __m128i __A, __m128i __B)
+
+/* Intrinsics with _avx_ prefix are for compatibility with msvc. */
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS256 __attribute__((__always_inline__, __nodebug__, __target__("avxvnni"), __min_vector_width__(256)))
+#define __DEFAULT_FN_ATTRS128 __attribute__((__always_inline__, __nodebug__, __target__("avxvnni"), __min_vector_width__(128)))
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a __A with
+/// corresponding signed 8-bit integers in \a __B, producing 4 intermediate signed
+/// 16-bit results. Sum these 4 results with the corresponding 32-bit integer
+/// in \a __S, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPBUSD </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 7
+///      tmp1.word := Signed(ZeroExtend16(__A.byte[4*j]) * SignExtend16(__B.byte[4*j]))
+///      tmp2.word := Signed(ZeroExtend16(__A.byte[4*j+1]) * SignExtend16(__B.byte[4*j+1]))
+///      tmp3.word := Signed(ZeroExtend16(__A.byte[4*j+2]) * SignExtend16(__B.byte[4*j+2]))
+///      tmp4.word := Signed(ZeroExtend16(__A.byte[4*j+3]) * SignExtend16(__B.byte[4*j+3]))
+///      DST.dword[j] := __S.dword[j] + tmp1 + tmp2 + tmp3 + tmp4
+///    ENDFOR
+///    DST[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpbusd_avx_epi32(__m256i __S, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_vpdpbusd256((__v8si)__S, (__v8si)__A, (__v8si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a __A with
+/// corresponding signed 8-bit integers in \a __B, producing 4 intermediate signed
+/// 16-bit results. Sum these 4 results with the corresponding 32-bit integer
+/// in \a __S using signed saturation, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPBUSDS </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 7
+///      tmp1.word := Signed(ZeroExtend16(__A.byte[4*j]) * SignExtend16(__B.byte[4*j]))
+///      tmp2.word := Signed(ZeroExtend16(__A.byte[4*j+1]) * SignExtend16(__B.byte[4*j+1]))
+///      tmp3.word := Signed(ZeroExtend16(__A.byte[4*j+2]) * SignExtend16(__B.byte[4*j+2]))
+///      tmp4.word := Signed(ZeroExtend16(__A.byte[4*j+3]) * SignExtend16(__B.byte[4*j+3]))
+///      DST.dword[j] := Saturate32(__S.dword[j] + tmp1 + tmp2 + tmp3 + tmp4)
+///    ENDFOR
+///    DST[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpbusds_avx_epi32(__m256i __S, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_vpdpbusds256((__v8si)__S, (__v8si)__A, (__v8si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a __A with
+/// corresponding 16-bit integers in \a __B, producing 2 intermediate signed 32-bit
+/// results. Sum these 2 results with the corresponding 32-bit integer in \a __S,
+///  and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPWSSD </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 7
+///      tmp1.dword := SignExtend32(__A.word[2*j]) * SignExtend32(__B.word[2*j])
+///      tmp2.dword := SignExtend32(__A.word[2*j+1]) * SignExtend32(__B.word[2*j+1])
+///      DST.dword[j] := __S.dword[j] + tmp1 + tmp2
+///    ENDFOR
+///    DST[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpwssd_avx_epi32(__m256i __S, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_vpdpwssd256((__v8si)__S, (__v8si)__A, (__v8si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a __A with
+/// corresponding 16-bit integers in \a __B, producing 2 intermediate signed 32-bit
+/// results. Sum these 2 results with the corresponding 32-bit integer in \a __S
+/// using signed saturation, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPWSSDS </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 7
+///      tmp1.dword := SignExtend32(__A.word[2*j]) * SignExtend32(__B.word[2*j])
+///      tmp2.dword := SignExtend32(__A.word[2*j+1]) * SignExtend32(__B.word[2*j+1])
+///      DST.dword[j] := Saturate32(__S.dword[j] + tmp1 + tmp2)
+///    ENDFOR
+///    DST[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_dpwssds_avx_epi32(__m256i __S, __m256i __A, __m256i __B)
+{
+  return (__m256i)__builtin_ia32_vpdpwssds256((__v8si)__S, (__v8si)__A, (__v8si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a __A with
+/// corresponding signed 8-bit integers in \a __B, producing 4 intermediate signed
+/// 16-bit results. Sum these 4 results with the corresponding 32-bit integer
+/// in \a __S, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPBUSD </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 3
+///      tmp1.word := Signed(ZeroExtend16(__A.byte[4*j]) * SignExtend16(__B.byte[4*j]))
+///      tmp2.word := Signed(ZeroExtend16(__A.byte[4*j+1]) * SignExtend16(__B.byte[4*j+1]))
+///      tmp3.word := Signed(ZeroExtend16(__A.byte[4*j+2]) * SignExtend16(__B.byte[4*j+2]))
+///      tmp4.word := Signed(ZeroExtend16(__A.byte[4*j+3]) * SignExtend16(__B.byte[4*j+3]))
+///      DST.dword[j] := __S.dword[j] + tmp1 + tmp2 + tmp3 + tmp4
+///    ENDFOR
+///    DST[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_dpbusd_avx_epi32(__m128i __S, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpdpbusd128((__v4si)__S, (__v4si)__A, (__v4si)__B);
+}
+
+/// Multiply groups of 4 adjacent pairs of unsigned 8-bit integers in \a __A with
+/// corresponding signed 8-bit integers in \a __B, producing 4 intermediate signed
+/// 16-bit results. Sum these 4 results with the corresponding 32-bit integer
+/// in \a __S using signed saturation, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPBUSDS </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 3
+///      tmp1.word := Signed(ZeroExtend16(__A.byte[4*j]) * SignExtend16(__B.byte[4*j]))
+///      tmp2.word := Signed(ZeroExtend16(__A.byte[4*j+1]) * SignExtend16(__B.byte[4*j+1]))
+///      tmp3.word := Signed(ZeroExtend16(__A.byte[4*j+2]) * SignExtend16(__B.byte[4*j+2]))
+///      tmp4.word := Signed(ZeroExtend16(__A.byte[4*j+3]) * SignExtend16(__B.byte[4*j+3]))
+///      DST.dword[j] := Saturate32(__S.dword[j] + tmp1 + tmp2 + tmp3 + tmp4)
+///    ENDFOR
+///    DST[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_dpbusds_avx_epi32(__m128i __S, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpdpbusds128((__v4si)__S, (__v4si)__A, (__v4si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a __A with
+/// corresponding 16-bit integers in \a __B, producing 2 intermediate signed 32-bit
+/// results. Sum these 2 results with the corresponding 32-bit integer in \a __S,
+/// and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPWSSD </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 3
+///      tmp1.dword := SignExtend32(__A.word[2*j]) * SignExtend32(__B.word[2*j])
+///      tmp2.dword := SignExtend32(__A.word[2*j+1]) * SignExtend32(__B.word[2*j+1])
+///      DST.dword[j] := __S.dword[j] + tmp1 + tmp2
+///    ENDFOR
+///    DST[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_dpwssd_avx_epi32(__m128i __S, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpdpwssd128((__v4si)__S, (__v4si)__A, (__v4si)__B);
+}
+
+/// Multiply groups of 2 adjacent pairs of signed 16-bit integers in \a __A with
+/// corresponding 16-bit integers in \a __B, producing 2 intermediate signed 32-bit
+/// results. Sum these 2 results with the corresponding 32-bit integer in \a __S
+/// using signed saturation, and store the packed 32-bit results in DST.
+///
+/// This intrinsic corresponds to the <c> VPDPWSSDS </c> instructions.
+///
+/// \code{.operation}
+///    FOR j := 0 to 3
+///      tmp1.dword := SignExtend32(__A.word[2*j]) * SignExtend32(__B.word[2*j])
+///      tmp2.dword := SignExtend32(__A.word[2*j+1]) * SignExtend32(__B.word[2*j+1])
+///      DST.dword[j] := Saturate32(__S.dword[j] + tmp1 + tmp2)
+///    ENDFOR
+///    DST[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_dpwssds_avx_epi32(__m128i __S, __m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpdpwssds128((__v4si)__S, (__v4si)__A, (__v4si)__B);
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif // __AVXVNNIINTRIN_H
diff --git a/third_party/intel/clang/bmi2intrin.h b/third_party/intel/clang/bmi2intrin.h
new file mode 100644
index 000000000..f0a3343be
--- /dev/null
+++ b/third_party/intel/clang/bmi2intrin.h
@@ -0,0 +1,255 @@
+/*===---- bmi2intrin.h - BMI2 intrinsics -----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <bmi2intrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __BMI2INTRIN_H
+#define __BMI2INTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi2")))
+
+/// Copies the unsigned 32-bit integer \a __X and zeroes the upper bits
+///    starting at bit number \a __Y.
+///
+/// \code{.operation}
+/// i := __Y[7:0]
+/// result := __X
+/// IF i < 32
+///   result[31:i] := 0
+/// FI
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c BZHI instruction.
+///
+/// \param __X
+///    The 32-bit source value to copy.
+/// \param __Y
+///    The lower 8 bits specify the bit number of the lowest bit to zero.
+/// \returns The partially zeroed 32-bit value.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_bzhi_u32(unsigned int __X, unsigned int __Y)
+{
+  return __builtin_ia32_bzhi_si(__X, __Y);
+}
+
+/// Deposit (scatter) low-order bits from the unsigned 32-bit integer \a __X
+///    into the 32-bit result, according to the mask in the unsigned 32-bit
+///    integer \a __Y. All other bits of the result are zero.
+///
+/// \code{.operation}
+/// i := 0
+/// result := 0
+/// FOR m := 0 TO 31
+///   IF __Y[m] == 1
+///     result[m] := __X[i]
+///     i := i + 1
+///   ENDIF
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c PDEP instruction.
+///
+/// \param __X
+///    The 32-bit source value to copy.
+/// \param __Y
+///    The 32-bit mask specifying where to deposit source bits.
+/// \returns The 32-bit result.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_pdep_u32(unsigned int __X, unsigned int __Y)
+{
+  return __builtin_ia32_pdep_si(__X, __Y);
+}
+
+/// Extract (gather) bits from the unsigned 32-bit integer \a __X into the
+///    low-order bits of the 32-bit result, according to the mask in the
+///    unsigned 32-bit integer \a __Y. All other bits of the result are zero.
+///
+/// \code{.operation}
+/// i := 0
+/// result := 0
+/// FOR m := 0 TO 31
+///   IF __Y[m] == 1
+///     result[i] := __X[m]
+///     i := i + 1
+///   ENDIF
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c PEXT instruction.
+///
+/// \param __X
+///    The 32-bit source value to copy.
+/// \param __Y
+///    The 32-bit mask specifying which source bits to extract.
+/// \returns The 32-bit result.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_pext_u32(unsigned int __X, unsigned int __Y)
+{
+  return __builtin_ia32_pext_si(__X, __Y);
+}
+
+/// Multiplies the unsigned 32-bit integers \a __X and \a __Y to form a
+///    64-bit product. Stores the upper 32 bits of the product in the
+///    memory at \a __P and returns the lower 32 bits.
+///
+/// \code{.operation}
+/// Store32(__P, (__X * __Y)[63:32])
+/// result := (__X * __Y)[31:0]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c MULX instruction.
+///
+/// \param __X
+///    An unsigned 32-bit multiplicand.
+/// \param __Y
+///    An unsigned 32-bit multiplicand.
+/// \param __P
+///    A pointer to memory for storing the upper half of the product.
+/// \returns The lower half of the product.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_mulx_u32(unsigned int __X, unsigned int __Y, unsigned int *__P)
+{
+  unsigned long long __res = (unsigned long long) __X * __Y;
+  *__P = (unsigned int)(__res >> 32);
+  return (unsigned int)__res;
+}
+
+#ifdef  __x86_64__
+
+/// Copies the unsigned 64-bit integer \a __X and zeroes the upper bits
+///    starting at bit number \a __Y.
+///
+/// \code{.operation}
+/// i := __Y[7:0]
+/// result := __X
+/// IF i < 64
+///   result[63:i] := 0
+/// FI
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c BZHI instruction.
+///
+/// \param __X
+///    The 64-bit source value to copy.
+/// \param __Y
+///    The lower 8 bits specify the bit number of the lowest bit to zero.
+/// \returns The partially zeroed 64-bit value.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+_bzhi_u64(unsigned long long __X, unsigned long long __Y)
+{
+  return __builtin_ia32_bzhi_di(__X, __Y);
+}
+
+/// Deposit (scatter) low-order bits from the unsigned 64-bit integer \a __X
+///    into the 64-bit result, according to the mask in the unsigned 64-bit
+///    integer \a __Y. All other bits of the result are zero.
+///
+/// \code{.operation}
+/// i := 0
+/// result := 0
+/// FOR m := 0 TO 63
+///   IF __Y[m] == 1
+///     result[m] := __X[i]
+///     i := i + 1
+///   ENDIF
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c PDEP instruction.
+///
+/// \param __X
+///    The 64-bit source value to copy.
+/// \param __Y
+///    The 64-bit mask specifying where to deposit source bits.
+/// \returns The 64-bit result.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+_pdep_u64(unsigned long long __X, unsigned long long __Y)
+{
+  return __builtin_ia32_pdep_di(__X, __Y);
+}
+
+/// Extract (gather) bits from the unsigned 64-bit integer \a __X into the
+///    low-order bits of the 64-bit result, according to the mask in the
+///    unsigned 64-bit integer \a __Y. All other bits of the result are zero.
+///
+/// \code{.operation}
+/// i := 0
+/// result := 0
+/// FOR m := 0 TO 63
+///   IF __Y[m] == 1
+///     result[i] := __X[m]
+///     i := i + 1
+///   ENDIF
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c PEXT instruction.
+///
+/// \param __X
+///    The 64-bit source value to copy.
+/// \param __Y
+///    The 64-bit mask specifying which source bits to extract.
+/// \returns The 64-bit result.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+_pext_u64(unsigned long long __X, unsigned long long __Y)
+{
+  return __builtin_ia32_pext_di(__X, __Y);
+}
+
+/// Multiplies the unsigned 64-bit integers \a __X and \a __Y to form a
+///    128-bit product. Stores the upper 64 bits of the product to the
+///    memory addressed by \a __P and returns the lower 64 bits.
+///
+/// \code{.operation}
+/// Store64(__P, (__X * __Y)[127:64])
+/// result := (__X * __Y)[63:0]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c MULX instruction.
+///
+/// \param __X
+///    An unsigned 64-bit multiplicand.
+/// \param __Y
+///    An unsigned 64-bit multiplicand.
+/// \param __P
+///    A pointer to memory for storing the upper half of the product.
+/// \returns The lower half of the product.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+_mulx_u64 (unsigned long long __X, unsigned long long __Y,
+	   unsigned long long *__P)
+{
+  unsigned __int128 __res = (unsigned __int128) __X * __Y;
+  *__P = (unsigned long long) (__res >> 64);
+  return (unsigned long long) __res;
+}
+
+#endif /* __x86_64__  */
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __BMI2INTRIN_H */
diff --git a/third_party/intel/clang/bmiintrin.h b/third_party/intel/clang/bmiintrin.h
new file mode 100644
index 000000000..78bffe68e
--- /dev/null
+++ b/third_party/intel/clang/bmiintrin.h
@@ -0,0 +1,614 @@
+/*===---- bmiintrin.h - BMI intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
+#error "Never use <bmiintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __BMIINTRIN_H
+#define __BMIINTRIN_H
+
+/* Allow using the tzcnt intrinsics even for non-BMI targets. Since the TZCNT
+   instruction behaves as BSF on non-BMI targets, there is code that expects
+   to use it as a potentially faster version of BSF. */
+#define __RELAXED_FN_ATTRS __attribute__((__always_inline__, __nodebug__))
+
+/// Counts the number of trailing zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c TZCNT instruction.
+///
+/// \param __X
+///    An unsigned 16-bit integer whose trailing zeros are to be counted.
+/// \returns An unsigned 16-bit integer containing the number of trailing zero
+///    bits in the operand.
+/// \see _tzcnt_u16
+static __inline__ unsigned short __RELAXED_FN_ATTRS
+__tzcnt_u16(unsigned short __X)
+{
+  return __builtin_ia32_tzcnt_u16(__X);
+}
+
+/// Counts the number of trailing zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned short _tzcnt_u16(unsigned short __X);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c TZCNT instruction.
+///
+/// \param __X
+///    An unsigned 16-bit integer whose trailing zeros are to be counted.
+/// \returns An unsigned 16-bit integer containing the number of trailing zero
+///    bits in the operand.
+/// \see __tzcnt_u16
+#define _tzcnt_u16 __tzcnt_u16
+
+/// Counts the number of trailing zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c TZCNT instruction.
+///
+/// \param __X
+///    An unsigned 32-bit integer whose trailing zeros are to be counted.
+/// \returns An unsigned 32-bit integer containing the number of trailing zero
+///    bits in the operand.
+/// \see { _mm_tzcnt_32 _tzcnt_u32 }
+static __inline__ unsigned int __RELAXED_FN_ATTRS
+__tzcnt_u32(unsigned int __X)
+{
+  return __builtin_ia32_tzcnt_u32(__X);
+}
+
+/// Counts the number of trailing zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c TZCNT instruction.
+///
+/// \param __X
+///    An unsigned 32-bit integer whose trailing zeros are to be counted.
+/// \returns A 32-bit integer containing the number of trailing zero bits in
+///    the operand.
+/// \see { __tzcnt_u32 _tzcnt_u32 }
+static __inline__ int __RELAXED_FN_ATTRS
+_mm_tzcnt_32(unsigned int __X)
+{
+  return (int)__builtin_ia32_tzcnt_u32(__X);
+}
+
+/// Counts the number of trailing zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned int _tzcnt_u32(unsigned int __X);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c TZCNT instruction.
+///
+/// \param __X
+///    An unsigned 32-bit integer whose trailing zeros are to be counted.
+/// \returns An unsigned 32-bit integer containing the number of trailing zero
+///    bits in the operand.
+/// \see { _mm_tzcnt_32 __tzcnt_u32 }
+#define _tzcnt_u32 __tzcnt_u32
+
+#ifdef __x86_64__
+
+/// Counts the number of trailing zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c TZCNT instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer whose trailing zeros are to be counted.
+/// \returns An unsigned 64-bit integer containing the number of trailing zero
+///    bits in the operand.
+/// \see { _mm_tzcnt_64 _tzcnt_u64 }
+static __inline__ unsigned long long __RELAXED_FN_ATTRS
+__tzcnt_u64(unsigned long long __X)
+{
+  return __builtin_ia32_tzcnt_u64(__X);
+}
+
+/// Counts the number of trailing zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c TZCNT instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer whose trailing zeros are to be counted.
+/// \returns An 64-bit integer containing the number of trailing zero bits in
+///    the operand.
+/// \see { __tzcnt_u64 _tzcnt_u64 }
+static __inline__ long long __RELAXED_FN_ATTRS
+_mm_tzcnt_64(unsigned long long __X)
+{
+  return (long long)__builtin_ia32_tzcnt_u64(__X);
+}
+
+/// Counts the number of trailing zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned long long _tzcnt_u64(unsigned long long __X);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c TZCNT instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer whose trailing zeros are to be counted.
+/// \returns An unsigned 64-bit integer containing the number of trailing zero
+///    bits in the operand.
+/// \see { _mm_tzcnt_64 __tzcnt_u64
+#define _tzcnt_u64 __tzcnt_u64
+
+#endif /* __x86_64__ */
+
+#undef __RELAXED_FN_ATTRS
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__BMI__)
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi")))
+
+/// Performs a bitwise AND of the second operand with the one's
+///    complement of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c ANDN instruction.
+///
+/// \param __X
+///    An unsigned integer containing one of the operands.
+/// \param __Y
+///    An unsigned integer containing one of the operands.
+/// \returns An unsigned integer containing the bitwise AND of the second
+///    operand with the one's complement of the first operand.
+/// \see _andn_u32
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__andn_u32(unsigned int __X, unsigned int __Y)
+{
+  return ~__X & __Y;
+}
+
+/// Performs a bitwise AND of the second operand with the one's
+///    complement of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned int _andn_u32(unsigned int __X, unsigned int __Y);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c ANDN instruction.
+///
+/// \param __X
+///    An unsigned integer containing one of the operands.
+/// \param __Y
+///    An unsigned integer containing one of the operands.
+/// \returns An unsigned integer containing the bitwise AND of the second
+///    operand with the one's complement of the first operand.
+/// \see __andn_u32
+#define _andn_u32 __andn_u32
+
+/* AMD-specified, double-leading-underscore version of BEXTR */
+/// Extracts the specified bits from the first operand and returns them
+///    in the least significant bits of the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BEXTR instruction.
+///
+/// \param __X
+///    An unsigned integer whose bits are to be extracted.
+/// \param __Y
+///    An unsigned integer used to specify which bits are extracted. Bits [7:0]
+///    specify the index of the least significant bit. Bits [15:8] specify the
+///    number of bits to be extracted.
+/// \returns An unsigned integer whose least significant bits contain the
+///    extracted bits.
+/// \see _bextr_u32
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__bextr_u32(unsigned int __X, unsigned int __Y)
+{
+  return __builtin_ia32_bextr_u32(__X, __Y);
+}
+
+/* Intel-specified, single-leading-underscore version of BEXTR */
+/// Extracts the specified bits from the first operand and returns them
+///    in the least significant bits of the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BEXTR instruction.
+///
+/// \param __X
+///    An unsigned integer whose bits are to be extracted.
+/// \param __Y
+///    An unsigned integer used to specify the index of the least significant
+///    bit for the bits to be extracted. Bits [7:0] specify the index.
+/// \param __Z
+///    An unsigned integer used to specify the number of bits to be extracted.
+///    Bits [7:0] specify the number of bits.
+/// \returns An unsigned integer whose least significant bits contain the
+///    extracted bits.
+/// \see __bextr_u32
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_bextr_u32(unsigned int __X, unsigned int __Y, unsigned int __Z)
+{
+  return __builtin_ia32_bextr_u32 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
+}
+
+/* Intel-specified, single-leading-underscore version of BEXTR2 */
+/// Extracts the specified bits from the first operand and returns them
+///    in the least significant bits of the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BEXTR instruction.
+///
+/// \param __X
+///    An unsigned integer whose bits are to be extracted.
+/// \param __Y
+///    An unsigned integer used to specify which bits are extracted. Bits [7:0]
+///    specify the index of the least significant bit. Bits [15:8] specify the
+///    number of bits to be extracted.
+/// \returns An unsigned integer whose least significant bits contain the
+///    extracted bits.
+/// \see __bextr_u32
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_bextr2_u32(unsigned int __X, unsigned int __Y) {
+  return __builtin_ia32_bextr_u32(__X, __Y);
+}
+
+/// Clears all bits in the source except for the least significant bit
+///    containing a value of 1 and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BLSI instruction.
+///
+/// \param __X
+///    An unsigned integer whose bits are to be cleared.
+/// \returns An unsigned integer containing the result of clearing the bits from
+///    the source operand.
+/// \see _blsi_u32
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__blsi_u32(unsigned int __X)
+{
+  return __X & -__X;
+}
+
+/// Clears all bits in the source except for the least significant bit
+///    containing a value of 1 and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned int _blsi_u32(unsigned int __X);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c BLSI instruction.
+///
+/// \param __X
+///    An unsigned integer whose bits are to be cleared.
+/// \returns An unsigned integer containing the result of clearing the bits from
+///    the source operand.
+/// \see __blsi_u32
+#define _blsi_u32 __blsi_u32
+
+/// Creates a mask whose bits are set to 1, using bit 0 up to and
+///    including the least significant bit that is set to 1 in the source
+///    operand and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BLSMSK instruction.
+///
+/// \param __X
+///    An unsigned integer used to create the mask.
+/// \returns An unsigned integer containing the newly created mask.
+/// \see _blsmsk_u32
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__blsmsk_u32(unsigned int __X)
+{
+  return __X ^ (__X - 1);
+}
+
+/// Creates a mask whose bits are set to 1, using bit 0 up to and
+///    including the least significant bit that is set to 1 in the source
+///    operand and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned int _blsmsk_u32(unsigned int __X);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c BLSMSK instruction.
+///
+/// \param __X
+///    An unsigned integer used to create the mask.
+/// \returns An unsigned integer containing the newly created mask.
+/// \see __blsmsk_u32
+#define _blsmsk_u32 __blsmsk_u32
+
+/// Clears the least significant bit that is set to 1 in the source
+///    operand and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BLSR instruction.
+///
+/// \param __X
+///    An unsigned integer containing the operand to be cleared.
+/// \returns An unsigned integer containing the result of clearing the source
+///    operand.
+/// \see _blsr_u32
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__blsr_u32(unsigned int __X)
+{
+  return __X & (__X - 1);
+}
+
+/// Clears the least significant bit that is set to 1 in the source
+///    operand and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned int _bls4_u32(unsigned int __X);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c BLSR instruction.
+///
+/// \param __X
+///    An unsigned integer containing the operand to be cleared.
+/// \returns An unsigned integer containing the result of clearing the source
+///    operand.
+/// \see __blsr_u32
+#define _blsr_u32 __blsr_u32
+
+#ifdef __x86_64__
+
+/// Performs a bitwise AND of the second operand with the one's
+///    complement of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c ANDN instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer containing one of the operands.
+/// \param __Y
+///    An unsigned 64-bit integer containing one of the operands.
+/// \returns An unsigned 64-bit integer containing the bitwise AND of the second
+///    operand with the one's complement of the first operand.
+/// \see _andn_u64
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__andn_u64 (unsigned long long __X, unsigned long long __Y)
+{
+  return ~__X & __Y;
+}
+
+/// Performs a bitwise AND of the second operand with the one's
+///    complement of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned long long _andn_u64(unsigned long long __X,
+///                              unsigned long long __Y);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c ANDN instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer containing one of the operands.
+/// \param __Y
+///    An unsigned 64-bit integer containing one of the operands.
+/// \returns An unsigned 64-bit integer containing the bitwise AND of the second
+///    operand with the one's complement of the first operand.
+/// \see __andn_u64
+#define _andn_u64 __andn_u64
+
+/* AMD-specified, double-leading-underscore version of BEXTR */
+/// Extracts the specified bits from the first operand and returns them
+///    in the least significant bits of the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BEXTR instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer whose bits are to be extracted.
+/// \param __Y
+///    An unsigned 64-bit integer used to specify which bits are extracted. Bits
+///    [7:0] specify the index of the least significant bit. Bits [15:8] specify
+///    the number of bits to be extracted.
+/// \returns An unsigned 64-bit integer whose least significant bits contain the
+///    extracted bits.
+/// \see _bextr_u64
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__bextr_u64(unsigned long long __X, unsigned long long __Y)
+{
+  return __builtin_ia32_bextr_u64(__X, __Y);
+}
+
+/* Intel-specified, single-leading-underscore version of BEXTR */
+/// Extracts the specified bits from the first operand and returns them
+///     in the least significant bits of the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BEXTR instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer whose bits are to be extracted.
+/// \param __Y
+///    An unsigned integer used to specify the index of the least significant
+///    bit for the bits to be extracted. Bits [7:0] specify the index.
+/// \param __Z
+///    An unsigned integer used to specify the number of bits to be extracted.
+///    Bits [7:0] specify the number of bits.
+/// \returns An unsigned 64-bit integer whose least significant bits contain the
+///    extracted bits.
+/// \see __bextr_u64
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+_bextr_u64(unsigned long long __X, unsigned int __Y, unsigned int __Z)
+{
+  return __builtin_ia32_bextr_u64 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
+}
+
+/* Intel-specified, single-leading-underscore version of BEXTR2 */
+/// Extracts the specified bits from the first operand and returns them
+///    in the least significant bits of the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BEXTR instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer whose bits are to be extracted.
+/// \param __Y
+///    An unsigned 64-bit integer used to specify which bits are extracted. Bits
+///    [7:0] specify the index of the least significant bit. Bits [15:8] specify
+///    the number of bits to be extracted.
+/// \returns An unsigned 64-bit integer whose least significant bits contain the
+///    extracted bits.
+/// \see __bextr_u64
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+_bextr2_u64(unsigned long long __X, unsigned long long __Y) {
+  return __builtin_ia32_bextr_u64(__X, __Y);
+}
+
+/// Clears all bits in the source except for the least significant bit
+///    containing a value of 1 and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BLSI instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer whose bits are to be cleared.
+/// \returns An unsigned 64-bit integer containing the result of clearing the
+///    bits from the source operand.
+/// \see _blsi_u64
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__blsi_u64(unsigned long long __X)
+{
+  return __X & -__X;
+}
+
+/// Clears all bits in the source except for the least significant bit
+///    containing a value of 1 and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned long long _blsi_u64(unsigned long long __X);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c BLSI instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer whose bits are to be cleared.
+/// \returns An unsigned 64-bit integer containing the result of clearing the
+///    bits from the source operand.
+/// \see __blsi_u64
+#define _blsi_u64 __blsi_u64
+
+/// Creates a mask whose bits are set to 1, using bit 0 up to and
+///    including the least significant bit that is set to 1 in the source
+///    operand and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BLSMSK instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer used to create the mask.
+/// \returns An unsigned 64-bit integer containing the newly created mask.
+/// \see _blsmsk_u64
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__blsmsk_u64(unsigned long long __X)
+{
+  return __X ^ (__X - 1);
+}
+
+/// Creates a mask whose bits are set to 1, using bit 0 up to and
+///    including the least significant bit that is set to 1 in the source
+///    operand and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned long long _blsmsk_u64(unsigned long long __X);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c BLSMSK instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer used to create the mask.
+/// \returns An unsigned 64-bit integer containing the newly created mask.
+/// \see __blsmsk_u64
+#define _blsmsk_u64 __blsmsk_u64
+
+/// Clears the least significant bit that is set to 1 in the source
+///    operand and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BLSR instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer containing the operand to be cleared.
+/// \returns An unsigned 64-bit integer containing the result of clearing the
+///    source operand.
+/// \see _blsr_u64
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__blsr_u64(unsigned long long __X)
+{
+  return __X & (__X - 1);
+}
+
+/// Clears the least significant bit that is set to 1 in the source
+///    operand and returns the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned long long _blsr_u64(unsigned long long __X);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c BLSR instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer containing the operand to be cleared.
+/// \returns An unsigned 64-bit integer containing the result of clearing the
+///    source operand.
+/// \see __blsr_u64
+#define _blsr_u64 __blsr_u64
+
+#endif /* __x86_64__ */
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* !defined(__SCE__) || __has_feature(modules) || defined(__BMI__) */
+
+#endif /* __BMIINTRIN_H */
diff --git a/third_party/intel/clang/cetintrin.h b/third_party/intel/clang/cetintrin.h
new file mode 100644
index 000000000..a68df5b1d
--- /dev/null
+++ b/third_party/intel/clang/cetintrin.h
@@ -0,0 +1,115 @@
+/*===---- cetintrin.h - CET intrinsic --------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <cetintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __CETINTRIN_H
+#define __CETINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__, __target__("shstk")))
+
+static __inline__ void __DEFAULT_FN_ATTRS _incsspd(int __a) {
+  __builtin_ia32_incsspd((unsigned int)__a);
+}
+
+#ifdef __x86_64__
+static __inline__ void __DEFAULT_FN_ATTRS _incsspq(unsigned long long __a) {
+  __builtin_ia32_incsspq(__a);
+}
+#endif /* __x86_64__ */
+
+#ifdef __x86_64__
+static __inline__ void __DEFAULT_FN_ATTRS _inc_ssp(unsigned int __a) {
+  __builtin_ia32_incsspq(__a);
+}
+#else /* __x86_64__ */
+static __inline__ void __DEFAULT_FN_ATTRS _inc_ssp(unsigned int __a) {
+  __builtin_ia32_incsspd(__a);
+}
+#endif /* __x86_64__ */
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS _rdsspd(unsigned int __a) {
+  return __builtin_ia32_rdsspd(__a);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS _rdsspd_i32(void) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wuninitialized"
+  unsigned int t;
+  return __builtin_ia32_rdsspd(t);
+#pragma clang diagnostic pop
+}
+
+#ifdef __x86_64__
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS _rdsspq(unsigned long long __a) {
+  return __builtin_ia32_rdsspq(__a);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS _rdsspq_i64(void) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wuninitialized"
+  unsigned long long t;
+  return __builtin_ia32_rdsspq(t);
+#pragma clang diagnostic pop
+}
+#endif /* __x86_64__ */
+
+#ifdef __x86_64__
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS _get_ssp(void) {
+  return __builtin_ia32_rdsspq(0);
+}
+#else /* __x86_64__ */
+static __inline__ unsigned int __DEFAULT_FN_ATTRS _get_ssp(void) {
+  return __builtin_ia32_rdsspd(0);
+}
+#endif /* __x86_64__ */
+
+static __inline__ void __DEFAULT_FN_ATTRS _saveprevssp(void) {
+  __builtin_ia32_saveprevssp();
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS _rstorssp(void * __p) {
+  __builtin_ia32_rstorssp(__p);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS _wrssd(unsigned int __a, void * __p) {
+  __builtin_ia32_wrssd(__a, __p);
+}
+
+#ifdef __x86_64__
+static __inline__ void __DEFAULT_FN_ATTRS _wrssq(unsigned long long __a, void * __p) {
+  __builtin_ia32_wrssq(__a, __p);
+}
+#endif /* __x86_64__ */
+
+static __inline__ void __DEFAULT_FN_ATTRS _wrussd(unsigned int __a, void * __p) {
+  __builtin_ia32_wrussd(__a, __p);
+}
+
+#ifdef __x86_64__
+static __inline__ void __DEFAULT_FN_ATTRS _wrussq(unsigned long long __a, void * __p) {
+  __builtin_ia32_wrussq(__a, __p);
+}
+#endif /* __x86_64__ */
+
+static __inline__ void __DEFAULT_FN_ATTRS _setssbsy(void) {
+  __builtin_ia32_setssbsy();
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS _clrssbsy(void * __p) {
+  __builtin_ia32_clrssbsy(__p);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __CETINTRIN_H */
diff --git a/third_party/intel/clang/cldemoteintrin.h b/third_party/intel/clang/cldemoteintrin.h
new file mode 100644
index 000000000..cfb951c1b
--- /dev/null
+++ b/third_party/intel/clang/cldemoteintrin.h
@@ -0,0 +1,36 @@
+/*===---- cldemoteintrin.h - CLDEMOTE intrinsic ----------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
+#error "Never use <cldemoteintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __CLDEMOTEINTRIN_H
+#define __CLDEMOTEINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__,  __target__("cldemote")))
+
+/// Hint to hardware that the cache line that contains \p __P should be demoted
+/// from the cache closest to the processor core to a level more distant from
+/// the processor core.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CLDEMOTE </c> instruction.
+static __inline__ void __DEFAULT_FN_ATTRS
+_cldemote(const void * __P) {
+  __builtin_ia32_cldemote(__P);
+}
+
+#define _mm_cldemote(p) _cldemote(p)
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/clflushoptintrin.h b/third_party/intel/clang/clflushoptintrin.h
new file mode 100644
index 000000000..ae0a0244c
--- /dev/null
+++ b/third_party/intel/clang/clflushoptintrin.h
@@ -0,0 +1,36 @@
+/*===---- clflushoptintrin.h - CLFLUSHOPT intrinsic ------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <clflushoptintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __CLFLUSHOPTINTRIN_H
+#define __CLFLUSHOPTINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__,  __target__("clflushopt")))
+
+/// Invalidates all levels of the cache hierarchy and flushes modified data to
+///    memory for the cache line specified by the address \a __m.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c CLFLUSHOPT instruction.
+///
+/// \param __m
+///    An address within the cache line to flush and invalidate.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_clflushopt(void const * __m) {
+  __builtin_ia32_clflushopt(__m);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/clwbintrin.h b/third_party/intel/clang/clwbintrin.h
new file mode 100644
index 000000000..3360d203f
--- /dev/null
+++ b/third_party/intel/clang/clwbintrin.h
@@ -0,0 +1,38 @@
+/*===---- clwbintrin.h - CLWB intrinsic ------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <clwbintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __CLWBINTRIN_H
+#define __CLWBINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__,  __target__("clwb")))
+
+/// Writes back to memory the cache line (if modified) that contains the
+/// linear address specified in \a __p from any level of the cache hierarchy in
+/// the cache coherence domain
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> CLWB </c> instruction.
+///
+/// \param __p
+///    A pointer to the memory location used to identify the cache line to be
+///    written back.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_clwb(void const *__p) {
+  __builtin_ia32_clwb(__p);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/clzerointrin.h b/third_party/intel/clang/clzerointrin.h
new file mode 100644
index 000000000..acccfe94f
--- /dev/null
+++ b/third_party/intel/clang/clzerointrin.h
@@ -0,0 +1,38 @@
+/*===----------------------- clzerointrin.h - CLZERO ----------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __X86INTRIN_H
+#error "Never use <clzerointrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __CLZEROINTRIN_H
+#define __CLZEROINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__,  __target__("clzero")))
+
+/// Zeroes out the cache line for the address \a __line. This uses a
+///    non-temporal store. Calling \c _mm_sfence() afterward might be needed
+///    to enforce ordering.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c CLZERO instruction.
+///
+/// \param __line
+///    An address within the cache line to zero out.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_clzero (void * __line)
+{
+  __builtin_ia32_clzero ((void *)__line);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __CLZEROINTRIN_H */
diff --git a/third_party/intel/clang/cmpccxaddintrin.h b/third_party/intel/clang/cmpccxaddintrin.h
new file mode 100644
index 000000000..695749899
--- /dev/null
+++ b/third_party/intel/clang/cmpccxaddintrin.h
@@ -0,0 +1,70 @@
+/*===--------------- cmpccxaddintrin.h - CMPCCXADD intrinsics--------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __X86GPRINTRIN_H
+#error                                                                         \
+    "Never use <cmpccxaddintrin.h> directly; include <x86gprintrin.h> instead."
+#endif // __X86GPRINTRIN_H
+
+#ifndef __CMPCCXADDINTRIN_H
+#define __CMPCCXADDINTRIN_H
+#ifdef __x86_64__
+
+typedef enum {
+  _CMPCCX_O,   /* Overflow.  */
+  _CMPCCX_NO,  /* No overflow.  */
+  _CMPCCX_B,   /* Below.  */
+  _CMPCCX_NB,  /* Not below.  */
+  _CMPCCX_Z,   /* Zero.  */
+  _CMPCCX_NZ,  /* Not zero.  */
+  _CMPCCX_BE,  /* Below or equal.  */
+  _CMPCCX_NBE, /* Neither below nor equal.  */
+  _CMPCCX_S,   /* Sign.  */
+  _CMPCCX_NS,  /* No sign.  */
+  _CMPCCX_P,   /* Parity.  */
+  _CMPCCX_NP,  /* No parity.  */
+  _CMPCCX_L,   /* Less.  */
+  _CMPCCX_NL,  /* Not less.  */
+  _CMPCCX_LE,  /* Less or equal.  */
+  _CMPCCX_NLE, /* Neither less nor equal.  */
+} _CMPCCX_ENUM;
+
+/// Compares the value from the memory __A with the value of __B. If the
+/// specified condition __D is met, then add the third operand __C to the
+/// __A and write it into __A, else the value of __A is unchanged. The return
+/// value is the original value of __A.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c CMPCCXADD instructions.
+///
+/// \param __A
+///    __A pointer specifying the memory address.
+///
+/// \param __B
+///   A integer operand.
+///
+/// \param __C
+///   A integer operand.
+///
+/// \param __D
+///   The specified condition.
+///
+/// \returns a integer which is the original value of first operand.
+
+#define _cmpccxadd_epi32(__A, __B, __C, __D)                                   \
+  ((int)(__builtin_ia32_cmpccxadd32((void *)(__A), (int)(__B), (int)(__C),     \
+                                    (int)(__D))))
+
+#define _cmpccxadd_epi64(__A, __B, __C, __D)                                   \
+  ((long long)(__builtin_ia32_cmpccxadd64((void *)(__A), (long long)(__B),     \
+                                          (long long)(__C), (int)(__D))))
+
+#endif // __x86_64__
+#endif // __CMPCCXADDINTRIN_H
diff --git a/third_party/intel/clang/crc32intrin.h b/third_party/intel/clang/crc32intrin.h
new file mode 100644
index 000000000..a0bd99d1b
--- /dev/null
+++ b/third_party/intel/clang/crc32intrin.h
@@ -0,0 +1,100 @@
+/*===---- crc32intrin.h - SSE4.2 Accumulate CRC32 intrinsics ---------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __CRC32INTRIN_H
+#define __CRC32INTRIN_H
+
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__, __target__("crc32")))
+
+/// Adds the unsigned integer operand to the CRC-32C checksum of the
+///    unsigned char operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CRC32B </c> instruction.
+///
+/// \param __C
+///    An unsigned integer operand to add to the CRC-32C checksum of operand
+///    \a  __D.
+/// \param __D
+///    An unsigned 8-bit integer operand used to compute the CRC-32C checksum.
+/// \returns The result of adding operand \a __C to the CRC-32C checksum of
+///    operand \a __D.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_mm_crc32_u8(unsigned int __C, unsigned char __D)
+{
+  return __builtin_ia32_crc32qi(__C, __D);
+}
+
+/// Adds the unsigned integer operand to the CRC-32C checksum of the
+///    unsigned short operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CRC32W </c> instruction.
+///
+/// \param __C
+///    An unsigned integer operand to add to the CRC-32C checksum of operand
+///    \a __D.
+/// \param __D
+///    An unsigned 16-bit integer operand used to compute the CRC-32C checksum.
+/// \returns The result of adding operand \a __C to the CRC-32C checksum of
+///    operand \a __D.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_mm_crc32_u16(unsigned int __C, unsigned short __D)
+{
+  return __builtin_ia32_crc32hi(__C, __D);
+}
+
+/// Adds the first unsigned integer operand to the CRC-32C checksum of
+///    the second unsigned integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CRC32L </c> instruction.
+///
+/// \param __C
+///    An unsigned integer operand to add to the CRC-32C checksum of operand
+///    \a __D.
+/// \param __D
+///    An unsigned 32-bit integer operand used to compute the CRC-32C checksum.
+/// \returns The result of adding operand \a __C to the CRC-32C checksum of
+///    operand \a __D.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_mm_crc32_u32(unsigned int __C, unsigned int __D)
+{
+  return __builtin_ia32_crc32si(__C, __D);
+}
+
+#ifdef __x86_64__
+/// Adds the unsigned integer operand to the CRC-32C checksum of the
+///    unsigned 64-bit integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CRC32Q </c> instruction.
+///
+/// \param __C
+///    An unsigned integer operand to add to the CRC-32C checksum of operand
+///    \a __D.
+/// \param __D
+///    An unsigned 64-bit integer operand used to compute the CRC-32C checksum.
+/// \returns The result of adding operand \a __C to the CRC-32C checksum of
+///    operand \a __D.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+_mm_crc32_u64(unsigned long long __C, unsigned long long __D)
+{
+  return __builtin_ia32_crc32di(__C, __D);
+}
+#endif /* __x86_64__ */
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __CRC32INTRIN_H */
diff --git a/third_party/intel/clang/emmintrin.h b/third_party/intel/clang/emmintrin.h
new file mode 100644
index 000000000..16ac07eaa
--- /dev/null
+++ b/third_party/intel/clang/emmintrin.h
@@ -0,0 +1,4906 @@
+/*===---- emmintrin.h - SSE2 intrinsics ------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __EMMINTRIN_H
+#define __EMMINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+#include "xmmintrin.h"
+
+typedef double __m128d __attribute__((__vector_size__(16), __aligned__(16)));
+typedef long long __m128i __attribute__((__vector_size__(16), __aligned__(16)));
+
+typedef double __m128d_u __attribute__((__vector_size__(16), __aligned__(1)));
+typedef long long __m128i_u
+    __attribute__((__vector_size__(16), __aligned__(1)));
+
+/* Type defines.  */
+typedef double __v2df __attribute__((__vector_size__(16)));
+typedef long long __v2di __attribute__((__vector_size__(16)));
+typedef short __v8hi __attribute__((__vector_size__(16)));
+typedef char __v16qi __attribute__((__vector_size__(16)));
+
+/* Unsigned types */
+typedef unsigned long long __v2du __attribute__((__vector_size__(16)));
+typedef unsigned short __v8hu __attribute__((__vector_size__(16)));
+typedef unsigned char __v16qu __attribute__((__vector_size__(16)));
+
+/* We need an explicitly signed variant for char. Note that this shouldn't
+ * appear in the interface though. */
+typedef signed char __v16qs __attribute__((__vector_size__(16)));
+
+#ifdef __SSE2__
+/* Both _Float16 and __bf16 require SSE2 being enabled. */
+typedef _Float16 __v8hf __attribute__((__vector_size__(16), __aligned__(16)));
+typedef _Float16 __m128h __attribute__((__vector_size__(16), __aligned__(16)));
+typedef _Float16 __m128h_u __attribute__((__vector_size__(16), __aligned__(1)));
+
+typedef __bf16 __v8bf __attribute__((__vector_size__(16), __aligned__(16)));
+typedef __bf16 __m128bh __attribute__((__vector_size__(16), __aligned__(16)));
+#endif
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("sse2,no-evex512"), __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS_MMX                                                 \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("mmx,sse2,no-evex512"), __min_vector_width__(64)))
+
+/// Adds lower double-precision values in both operands and returns the
+///    sum in the lower 64 bits of the result. The upper 64 bits of the result
+///    are copied from the upper double-precision value of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VADDSD / ADDSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \returns A 128-bit vector of [2 x double] whose lower 64 bits contain the
+///    sum of the lower 64 bits of both operands. The upper 64 bits are copied
+///    from the upper 64 bits of the first source operand.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_add_sd(__m128d __a,
+                                                        __m128d __b) {
+  __a[0] += __b[0];
+  return __a;
+}
+
+/// Adds two 128-bit vectors of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VADDPD / ADDPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \returns A 128-bit vector of [2 x double] containing the sums of both
+///    operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_add_pd(__m128d __a,
+                                                        __m128d __b) {
+  return (__m128d)((__v2df)__a + (__v2df)__b);
+}
+
+/// Subtracts the lower double-precision value of the second operand
+///    from the lower double-precision value of the first operand and returns
+///    the difference in the lower 64 bits of the result. The upper 64 bits of
+///    the result are copied from the upper double-precision value of the first
+///    operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSUBSD / SUBSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the minuend.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing the subtrahend.
+/// \returns A 128-bit vector of [2 x double] whose lower 64 bits contain the
+///    difference of the lower 64 bits of both operands. The upper 64 bits are
+///    copied from the upper 64 bits of the first source operand.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_sub_sd(__m128d __a,
+                                                        __m128d __b) {
+  __a[0] -= __b[0];
+  return __a;
+}
+
+/// Subtracts two 128-bit vectors of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSUBPD / SUBPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the minuend.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing the subtrahend.
+/// \returns A 128-bit vector of [2 x double] containing the differences between
+///    both operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_sub_pd(__m128d __a,
+                                                        __m128d __b) {
+  return (__m128d)((__v2df)__a - (__v2df)__b);
+}
+
+/// Multiplies lower double-precision values in both operands and returns
+///    the product in the lower 64 bits of the result. The upper 64 bits of the
+///    result are copied from the upper double-precision value of the first
+///    operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMULSD / MULSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \returns A 128-bit vector of [2 x double] whose lower 64 bits contain the
+///    product of the lower 64 bits of both operands. The upper 64 bits are
+///    copied from the upper 64 bits of the first source operand.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_mul_sd(__m128d __a,
+                                                        __m128d __b) {
+  __a[0] *= __b[0];
+  return __a;
+}
+
+/// Multiplies two 128-bit vectors of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMULPD / MULPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the operands.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the operands.
+/// \returns A 128-bit vector of [2 x double] containing the products of both
+///    operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_mul_pd(__m128d __a,
+                                                        __m128d __b) {
+  return (__m128d)((__v2df)__a * (__v2df)__b);
+}
+
+/// Divides the lower double-precision value of the first operand by the
+///    lower double-precision value of the second operand and returns the
+///    quotient in the lower 64 bits of the result. The upper 64 bits of the
+///    result are copied from the upper double-precision value of the first
+///    operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDIVSD / DIVSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the dividend.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing divisor.
+/// \returns A 128-bit vector of [2 x double] whose lower 64 bits contain the
+///    quotient of the lower 64 bits of both operands. The upper 64 bits are
+///    copied from the upper 64 bits of the first source operand.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_div_sd(__m128d __a,
+                                                        __m128d __b) {
+  __a[0] /= __b[0];
+  return __a;
+}
+
+/// Performs an element-by-element division of two 128-bit vectors of
+///    [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDIVPD / DIVPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the dividend.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing the divisor.
+/// \returns A 128-bit vector of [2 x double] containing the quotients of both
+///    operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_div_pd(__m128d __a,
+                                                        __m128d __b) {
+  return (__m128d)((__v2df)__a / (__v2df)__b);
+}
+
+/// Calculates the square root of the lower double-precision value of
+///    the second operand and returns it in the lower 64 bits of the result.
+///    The upper 64 bits of the result are copied from the upper
+///    double-precision value of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSQRTSD / SQRTSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the operands. The
+///    upper 64 bits of this operand are copied to the upper 64 bits of the
+///    result.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the operands. The
+///    square root is calculated using the lower 64 bits of this operand.
+/// \returns A 128-bit vector of [2 x double] whose lower 64 bits contain the
+///    square root of the lower 64 bits of operand \a __b, and whose upper 64
+///    bits are copied from the upper 64 bits of operand \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_sqrt_sd(__m128d __a,
+                                                         __m128d __b) {
+  __m128d __c = __builtin_ia32_sqrtsd((__v2df)__b);
+  return __extension__(__m128d){__c[0], __a[1]};
+}
+
+/// Calculates the square root of the each of two values stored in a
+///    128-bit vector of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSQRTPD / SQRTPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector of [2 x double] containing the square roots of the
+///    values in the operand.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_sqrt_pd(__m128d __a) {
+  return __builtin_ia32_sqrtpd((__v2df)__a);
+}
+
+/// Compares lower 64-bit double-precision values of both operands, and
+///    returns the lesser of the pair of values in the lower 64-bits of the
+///    result. The upper 64 bits of the result are copied from the upper
+///    double-precision value of the first operand.
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMINSD / MINSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the operands. The
+///    lower 64 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the operands. The
+///    lower 64 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [2 x double] whose lower 64 bits contain the
+///    minimum value between both operands. The upper 64 bits are copied from
+///    the upper 64 bits of the first source operand.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_min_sd(__m128d __a,
+                                                        __m128d __b) {
+  return __builtin_ia32_minsd((__v2df)__a, (__v2df)__b);
+}
+
+/// Performs element-by-element comparison of the two 128-bit vectors of
+///    [2 x double] and returns a vector containing the lesser of each pair of
+///    values.
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMINPD / MINPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the operands.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the operands.
+/// \returns A 128-bit vector of [2 x double] containing the minimum values
+///    between both operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_min_pd(__m128d __a,
+                                                        __m128d __b) {
+  return __builtin_ia32_minpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares lower 64-bit double-precision values of both operands, and
+///    returns the greater of the pair of values in the lower 64-bits of the
+///    result. The upper 64 bits of the result are copied from the upper
+///    double-precision value of the first operand.
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMAXSD / MAXSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the operands. The
+///    lower 64 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the operands. The
+///    lower 64 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [2 x double] whose lower 64 bits contain the
+///    maximum value between both operands. The upper 64 bits are copied from
+///    the upper 64 bits of the first source operand.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_max_sd(__m128d __a,
+                                                        __m128d __b) {
+  return __builtin_ia32_maxsd((__v2df)__a, (__v2df)__b);
+}
+
+/// Performs element-by-element comparison of the two 128-bit vectors of
+///    [2 x double] and returns a vector containing the greater of each pair
+///    of values.
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMAXPD / MAXPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the operands.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the operands.
+/// \returns A 128-bit vector of [2 x double] containing the maximum values
+///    between both operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_max_pd(__m128d __a,
+                                                        __m128d __b) {
+  return __builtin_ia32_maxpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Performs a bitwise AND of two 128-bit vectors of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPAND / PAND </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \returns A 128-bit vector of [2 x double] containing the bitwise AND of the
+///    values between both operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_and_pd(__m128d __a,
+                                                        __m128d __b) {
+  return (__m128d)((__v2du)__a & (__v2du)__b);
+}
+
+/// Performs a bitwise AND of two 128-bit vectors of [2 x double], using
+///    the one's complement of the values contained in the first source operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPANDN / PANDN </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the left source operand. The
+///    one's complement of this value is used in the bitwise AND.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing the right source operand.
+/// \returns A 128-bit vector of [2 x double] containing the bitwise AND of the
+///    values in the second operand and the one's complement of the first
+///    operand.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_andnot_pd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)(~(__v2du)__a & (__v2du)__b);
+}
+
+/// Performs a bitwise OR of two 128-bit vectors of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPOR / POR </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \returns A 128-bit vector of [2 x double] containing the bitwise OR of the
+///    values between both operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_or_pd(__m128d __a,
+                                                       __m128d __b) {
+  return (__m128d)((__v2du)__a | (__v2du)__b);
+}
+
+/// Performs a bitwise XOR of two 128-bit vectors of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPXOR / PXOR </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+/// \returns A 128-bit vector of [2 x double] containing the bitwise XOR of the
+///    values between both operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_xor_pd(__m128d __a,
+                                                        __m128d __b) {
+  return (__m128d)((__v2du)__a ^ (__v2du)__b);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] for equality.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPEQPD / CMPEQPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpeq_pd(__m128d __a,
+                                                          __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpeqpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are less than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLTPD / CMPLTPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmplt_pd(__m128d __a,
+                                                          __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpltpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are less than or equal to those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLEPD / CMPLEPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmple_pd(__m128d __a,
+                                                          __m128d __b) {
+  return (__m128d)__builtin_ia32_cmplepd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are greater than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLTPD / CMPLTPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpgt_pd(__m128d __a,
+                                                          __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpltpd((__v2df)__b, (__v2df)__a);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are greater than or equal to those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLEPD / CMPLEPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpge_pd(__m128d __a,
+                                                          __m128d __b) {
+  return (__m128d)__builtin_ia32_cmplepd((__v2df)__b, (__v2df)__a);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are ordered with respect to those in the second operand.
+///
+///    A pair of double-precision values are ordered with respect to each
+///    other if neither value is a NaN. Each comparison returns 0x0 for false,
+///    0xFFFFFFFFFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPORDPD / CMPORDPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpord_pd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpordpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are unordered with respect to those in the second operand.
+///
+///    A pair of double-precision values are unordered with respect to each
+///    other if one or both values are NaN. Each comparison returns 0x0 for
+///    false, 0xFFFFFFFFFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPUNORDPD / CMPUNORDPD </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpunord_pd(__m128d __a,
+                                                             __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpunordpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are unequal to those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNEQPD / CMPNEQPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpneq_pd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpneqpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are not less than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLTPD / CMPNLTPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnlt_pd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpnltpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are not less than or equal to those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLEPD / CMPNLEPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnle_pd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpnlepd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are not greater than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLTPD / CMPNLTPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpngt_pd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpnltpd((__v2df)__b, (__v2df)__a);
+}
+
+/// Compares each of the corresponding double-precision values of the
+///    128-bit vectors of [2 x double] to determine if the values in the first
+///    operand are not greater than or equal to those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLEPD / CMPNLEPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \param __b
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector containing the comparison results.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnge_pd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpnlepd((__v2df)__b, (__v2df)__a);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] for equality.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPEQSD / CMPEQSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpeq_sd(__m128d __a,
+                                                          __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpeqsd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is less than the corresponding value in
+///    the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLTSD / CMPLTSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmplt_sd(__m128d __a,
+                                                          __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpltsd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is less than or equal to the
+///    corresponding value in the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLESD / CMPLESD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmple_sd(__m128d __a,
+                                                          __m128d __b) {
+  return (__m128d)__builtin_ia32_cmplesd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is greater than the corresponding value
+///    in the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLTSD / CMPLTSD </c> instruction.
+///
+/// \param __a
+///     A 128-bit vector of [2 x double]. The lower double-precision value is
+///     compared to the lower double-precision value of \a __b.
+/// \param __b
+///     A 128-bit vector of [2 x double]. The lower double-precision value is
+///     compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///     results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpgt_sd(__m128d __a,
+                                                          __m128d __b) {
+  __m128d __c = __builtin_ia32_cmpltsd((__v2df)__b, (__v2df)__a);
+  return __extension__(__m128d){__c[0], __a[1]};
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is greater than or equal to the
+///    corresponding value in the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLESD / CMPLESD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpge_sd(__m128d __a,
+                                                          __m128d __b) {
+  __m128d __c = __builtin_ia32_cmplesd((__v2df)__b, (__v2df)__a);
+  return __extension__(__m128d){__c[0], __a[1]};
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is ordered with respect to the
+///    corresponding value in the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true. A pair
+///    of double-precision values are ordered with respect to each other if
+///    neither value is a NaN.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPORDSD / CMPORDSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpord_sd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpordsd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is unordered with respect to the
+///    corresponding value in the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true. A pair
+///    of double-precision values are unordered with respect to each other if
+///    one or both values are NaN.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPUNORDSD / CMPUNORDSD </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpunord_sd(__m128d __a,
+                                                             __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpunordsd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is unequal to the corresponding value in
+///    the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNEQSD / CMPNEQSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpneq_sd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpneqsd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is not less than the corresponding
+///    value in the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLTSD / CMPNLTSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnlt_sd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpnltsd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is not less than or equal to the
+///    corresponding value in the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLESD / CMPNLESD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns  A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnle_sd(__m128d __a,
+                                                           __m128d __b) {
+  return (__m128d)__builtin_ia32_cmpnlesd((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is not greater than the corresponding
+///    value in the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLTSD / CMPNLTSD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpngt_sd(__m128d __a,
+                                                           __m128d __b) {
+  __m128d __c = __builtin_ia32_cmpnltsd((__v2df)__b, (__v2df)__a);
+  return __extension__(__m128d){__c[0], __a[1]};
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is not greater than or equal to the
+///    corresponding value in the second parameter.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLESD / CMPNLESD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns A 128-bit vector. The lower 64 bits contains the comparison
+///    results. The upper 64 bits are copied from the upper 64 bits of \a __a.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cmpnge_sd(__m128d __a,
+                                                           __m128d __b) {
+  __m128d __c = __builtin_ia32_cmpnlesd((__v2df)__b, (__v2df)__a);
+  return __extension__(__m128d){__c[0], __a[1]};
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] for equality.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISD / COMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_comieq_sd(__m128d __a,
+                                                       __m128d __b) {
+  return __builtin_ia32_comisdeq((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is less than the corresponding value in
+///    the second parameter.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISD / COMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_comilt_sd(__m128d __a,
+                                                       __m128d __b) {
+  return __builtin_ia32_comisdlt((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is less than or equal to the
+///    corresponding value in the second parameter.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISD / COMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///     A 128-bit vector of [2 x double]. The lower double-precision value is
+///     compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_comile_sd(__m128d __a,
+                                                       __m128d __b) {
+  return __builtin_ia32_comisdle((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is greater than the corresponding value
+///    in the second parameter.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISD / COMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_comigt_sd(__m128d __a,
+                                                       __m128d __b) {
+  return __builtin_ia32_comisdgt((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is greater than or equal to the
+///    corresponding value in the second parameter.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISD / COMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_comige_sd(__m128d __a,
+                                                       __m128d __b) {
+  return __builtin_ia32_comisdge((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is unequal to the corresponding value in
+///    the second parameter.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 1.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISD / COMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_comineq_sd(__m128d __a,
+                                                        __m128d __b) {
+  return __builtin_ia32_comisdneq((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] for equality.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISD / UCOMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomieq_sd(__m128d __a,
+                                                        __m128d __b) {
+  return __builtin_ia32_ucomisdeq((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is less than the corresponding value in
+///    the second parameter.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISD / UCOMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomilt_sd(__m128d __a,
+                                                        __m128d __b) {
+  return __builtin_ia32_ucomisdlt((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is less than or equal to the
+///    corresponding value in the second parameter.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISD / UCOMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///     A 128-bit vector of [2 x double]. The lower double-precision value is
+///     compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomile_sd(__m128d __a,
+                                                        __m128d __b) {
+  return __builtin_ia32_ucomisdle((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is greater than the corresponding value
+///    in the second parameter.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISD / UCOMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///     A 128-bit vector of [2 x double]. The lower double-precision value is
+///     compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomigt_sd(__m128d __a,
+                                                        __m128d __b) {
+  return __builtin_ia32_ucomisdgt((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is greater than or equal to the
+///    corresponding value in the second parameter.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISD / UCOMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomige_sd(__m128d __a,
+                                                        __m128d __b) {
+  return __builtin_ia32_ucomisdge((__v2df)__a, (__v2df)__b);
+}
+
+/// Compares the lower double-precision floating-point values in each of
+///    the two 128-bit floating-point vectors of [2 x double] to determine if
+///    the value in the first parameter is unequal to the corresponding value in
+///    the second parameter.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 1.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISD / UCOMISD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __b.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision value is
+///    compared to the lower double-precision value of \a __a.
+/// \returns An integer containing the comparison result.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_ucomineq_sd(__m128d __a,
+                                                         __m128d __b) {
+  return __builtin_ia32_ucomisdneq((__v2df)__a, (__v2df)__b);
+}
+
+/// Converts the two double-precision floating-point elements of a
+///    128-bit vector of [2 x double] into two single-precision floating-point
+///    values, returned in the lower 64 bits of a 128-bit vector of [4 x float].
+///    The upper 64 bits of the result vector are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPD2PS / CVTPD2PS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector of [4 x float] whose lower 64 bits contain the
+///    converted values. The upper 64 bits are set to zero.
+static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtpd_ps(__m128d __a) {
+  return __builtin_ia32_cvtpd2ps((__v2df)__a);
+}
+
+/// Converts the lower two single-precision floating-point elements of a
+///    128-bit vector of [4 x float] into two double-precision floating-point
+///    values, returned in a 128-bit vector of [2 x double]. The upper two
+///    elements of the input vector are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPS2PD / CVTPS2PD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower two single-precision
+///    floating-point elements are converted to double-precision values. The
+///    upper two elements are unused.
+/// \returns A 128-bit vector of [2 x double] containing the converted values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtps_pd(__m128 __a) {
+  return (__m128d) __builtin_convertvector(
+      __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 0, 1), __v2df);
+}
+
+/// Converts the lower two integer elements of a 128-bit vector of
+///    [4 x i32] into two double-precision floating-point values, returned in a
+///    128-bit vector of [2 x double].
+///
+///    The upper two elements of the input vector are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTDQ2PD / CVTDQ2PD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector of [4 x i32]. The lower two integer elements are
+///    converted to double-precision values.
+///
+///    The upper two elements are unused.
+/// \returns A 128-bit vector of [2 x double] containing the converted values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtepi32_pd(__m128i __a) {
+  return (__m128d) __builtin_convertvector(
+      __builtin_shufflevector((__v4si)__a, (__v4si)__a, 0, 1), __v2df);
+}
+
+/// Converts the two double-precision floating-point elements of a
+///    128-bit vector of [2 x double] into two signed 32-bit integer values,
+///    returned in the lower 64 bits of a 128-bit vector of [4 x i32]. The upper
+///    64 bits of the result vector are set to zero.
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPD2DQ / CVTPD2DQ </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector of [4 x i32] whose lower 64 bits contain the
+///    converted values. The upper 64 bits are set to zero.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtpd_epi32(__m128d __a) {
+  return __builtin_ia32_cvtpd2dq((__v2df)__a);
+}
+
+/// Converts the low-order element of a 128-bit vector of [2 x double]
+///    into a 32-bit signed integer value.
+///
+///    If the converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSD2SI / CVTSD2SI </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower 64 bits are used in the
+///    conversion.
+/// \returns A 32-bit signed integer containing the converted value.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_cvtsd_si32(__m128d __a) {
+  return __builtin_ia32_cvtsd2si((__v2df)__a);
+}
+
+/// Converts the lower double-precision floating-point element of a
+///    128-bit vector of [2 x double], in the second parameter, into a
+///    single-precision floating-point value, returned in the lower 32 bits of a
+///    128-bit vector of [4 x float]. The upper 96 bits of the result vector are
+///    copied from the upper 96 bits of the first parameter.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSD2SS / CVTSD2SS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The upper 96 bits of this parameter are
+///    copied to the upper 96 bits of the result.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower double-precision
+///    floating-point element is used in the conversion.
+/// \returns A 128-bit vector of [4 x float]. The lower 32 bits contain the
+///    converted value from the second parameter. The upper 96 bits are copied
+///    from the upper 96 bits of the first parameter.
+static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtsd_ss(__m128 __a,
+                                                         __m128d __b) {
+  return (__m128)__builtin_ia32_cvtsd2ss((__v4sf)__a, (__v2df)__b);
+}
+
+/// Converts a 32-bit signed integer value, in the second parameter, into
+///    a double-precision floating-point value, returned in the lower 64 bits of
+///    a 128-bit vector of [2 x double]. The upper 64 bits of the result vector
+///    are copied from the upper 64 bits of the first parameter.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSI2SD / CVTSI2SD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The upper 64 bits of this parameter are
+///    copied to the upper 64 bits of the result.
+/// \param __b
+///    A 32-bit signed integer containing the value to be converted.
+/// \returns A 128-bit vector of [2 x double]. The lower 64 bits contain the
+///    converted value from the second parameter. The upper 64 bits are copied
+///    from the upper 64 bits of the first parameter.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtsi32_sd(__m128d __a,
+                                                            int __b) {
+  __a[0] = __b;
+  return __a;
+}
+
+/// Converts the lower single-precision floating-point element of a
+///    128-bit vector of [4 x float], in the second parameter, into a
+///    double-precision floating-point value, returned in the lower 64 bits of
+///    a 128-bit vector of [2 x double]. The upper 64 bits of the result vector
+///    are copied from the upper 64 bits of the first parameter.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSS2SD / CVTSS2SD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The upper 64 bits of this parameter are
+///    copied to the upper 64 bits of the result.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower single-precision
+///    floating-point element is used in the conversion.
+/// \returns A 128-bit vector of [2 x double]. The lower 64 bits contain the
+///    converted value from the second parameter. The upper 64 bits are copied
+///    from the upper 64 bits of the first parameter.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtss_sd(__m128d __a,
+                                                          __m128 __b) {
+  __a[0] = __b[0];
+  return __a;
+}
+
+/// Converts the two double-precision floating-point elements of a
+///    128-bit vector of [2 x double] into two signed truncated (rounded
+///    toward zero) 32-bit integer values, returned in the lower 64 bits
+///    of a 128-bit vector of [4 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTTPD2DQ / CVTTPD2DQ </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector of [4 x i32] whose lower 64 bits contain the
+///    converted values. The upper 64 bits are set to zero.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvttpd_epi32(__m128d __a) {
+  return (__m128i)__builtin_ia32_cvttpd2dq((__v2df)__a);
+}
+
+/// Converts the low-order element of a [2 x double] vector into a 32-bit
+///    signed truncated (rounded toward zero) integer value.
+///
+///    If the converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTTSD2SI / CVTTSD2SI </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower 64 bits are used in the
+///    conversion.
+/// \returns A 32-bit signed integer containing the converted value.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_cvttsd_si32(__m128d __a) {
+  return __builtin_ia32_cvttsd2si((__v2df)__a);
+}
+
+/// Converts the two double-precision floating-point elements of a
+///    128-bit vector of [2 x double] into two signed 32-bit integer values,
+///    returned in a 64-bit vector of [2 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPD2PI </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 64-bit vector of [2 x i32] containing the converted values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX _mm_cvtpd_pi32(__m128d __a) {
+  return (__m64)__builtin_ia32_cvtpd2pi((__v2df)__a);
+}
+
+/// Converts the two double-precision floating-point elements of a
+///    128-bit vector of [2 x double] into two signed truncated (rounded toward
+///    zero) 32-bit integer values, returned in a 64-bit vector of [2 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTTPD2PI </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double].
+/// \returns A 64-bit vector of [2 x i32] containing the converted values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX _mm_cvttpd_pi32(__m128d __a) {
+  return (__m64)__builtin_ia32_cvttpd2pi((__v2df)__a);
+}
+
+/// Converts the two signed 32-bit integer elements of a 64-bit vector of
+///    [2 x i32] into two double-precision floating-point values, returned in a
+///    128-bit vector of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPI2PD </c> instruction.
+///
+/// \param __a
+///    A 64-bit vector of [2 x i32].
+/// \returns A 128-bit vector of [2 x double] containing the converted values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS_MMX _mm_cvtpi32_pd(__m64 __a) {
+  return __builtin_ia32_cvtpi2pd((__v2si)__a);
+}
+
+/// Returns the low-order element of a 128-bit vector of [2 x double] as
+///    a double-precision floating-point value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower 64 bits are returned.
+/// \returns A double-precision floating-point value copied from the lower 64
+///    bits of \a __a.
+static __inline__ double __DEFAULT_FN_ATTRS _mm_cvtsd_f64(__m128d __a) {
+  return __a[0];
+}
+
+/// Loads a 128-bit floating-point vector of [2 x double] from an aligned
+///    memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPD / MOVAPD </c> instruction.
+///
+/// \param __dp
+///    A pointer to a 128-bit memory location. The address of the memory
+///    location has to be 16-byte aligned.
+/// \returns A 128-bit vector of [2 x double] containing the loaded values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_load_pd(double const *__dp) {
+  return *(const __m128d *)__dp;
+}
+
+/// Loads a double-precision floating-point value from a specified memory
+///    location and duplicates it to both vector elements of a 128-bit vector of
+///    [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDDUP / MOVDDUP </c> instruction.
+///
+/// \param __dp
+///    A pointer to a memory location containing a double-precision value.
+/// \returns A 128-bit vector of [2 x double] containing the loaded and
+///    duplicated values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_load1_pd(double const *__dp) {
+  struct __mm_load1_pd_struct {
+    double __u;
+  } __attribute__((__packed__, __may_alias__));
+  double __u = ((const struct __mm_load1_pd_struct *)__dp)->__u;
+  return __extension__(__m128d){__u, __u};
+}
+
+#define _mm_load_pd1(dp) _mm_load1_pd(dp)
+
+/// Loads two double-precision values, in reverse order, from an aligned
+///    memory location into a 128-bit vector of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPD / MOVAPD </c> instruction +
+/// needed shuffling instructions. In AVX mode, the shuffling may be combined
+/// with the \c VMOVAPD, resulting in only a \c VPERMILPD instruction.
+///
+/// \param __dp
+///    A 16-byte aligned pointer to an array of double-precision values to be
+///    loaded in reverse order.
+/// \returns A 128-bit vector of [2 x double] containing the reversed loaded
+///    values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_loadr_pd(double const *__dp) {
+  __m128d __u = *(const __m128d *)__dp;
+  return __builtin_shufflevector((__v2df)__u, (__v2df)__u, 1, 0);
+}
+
+/// Loads a 128-bit floating-point vector of [2 x double] from an
+///    unaligned memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVUPD / MOVUPD </c> instruction.
+///
+/// \param __dp
+///    A pointer to a 128-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \returns A 128-bit vector of [2 x double] containing the loaded values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_loadu_pd(double const *__dp) {
+  struct __loadu_pd {
+    __m128d_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_pd *)__dp)->__v;
+}
+
+/// Loads a 64-bit integer value to the low element of a 128-bit integer
+///    vector and clears the upper element.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVQ / MOVQ </c> instruction.
+///
+/// \param __a
+///    A pointer to a 64-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \returns A 128-bit vector of [2 x i64] containing the loaded value.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_loadu_si64(void const *__a) {
+  struct __loadu_si64 {
+    long long __v;
+  } __attribute__((__packed__, __may_alias__));
+  long long __u = ((const struct __loadu_si64 *)__a)->__v;
+  return __extension__(__m128i)(__v2di){__u, 0LL};
+}
+
+/// Loads a 32-bit integer value to the low element of a 128-bit integer
+///    vector and clears the upper element.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVD / MOVD </c> instruction.
+///
+/// \param __a
+///    A pointer to a 32-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \returns A 128-bit vector of [4 x i32] containing the loaded value.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_loadu_si32(void const *__a) {
+  struct __loadu_si32 {
+    int __v;
+  } __attribute__((__packed__, __may_alias__));
+  int __u = ((const struct __loadu_si32 *)__a)->__v;
+  return __extension__(__m128i)(__v4si){__u, 0, 0, 0};
+}
+
+/// Loads a 16-bit integer value to the low element of a 128-bit integer
+///    vector and clears the upper element.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic does not correspond to a specific instruction.
+///
+/// \param __a
+///    A pointer to a 16-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \returns A 128-bit vector of [8 x i16] containing the loaded value.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_loadu_si16(void const *__a) {
+  struct __loadu_si16 {
+    short __v;
+  } __attribute__((__packed__, __may_alias__));
+  short __u = ((const struct __loadu_si16 *)__a)->__v;
+  return __extension__(__m128i)(__v8hi){__u, 0, 0, 0, 0, 0, 0, 0};
+}
+
+/// Loads a 64-bit double-precision value to the low element of a
+///    128-bit integer vector and clears the upper element.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVSD / MOVSD </c> instruction.
+///
+/// \param __dp
+///    A pointer to a memory location containing a double-precision value.
+///    The address of the memory location does not have to be aligned.
+/// \returns A 128-bit vector of [2 x double] containing the loaded value.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_load_sd(double const *__dp) {
+  struct __mm_load_sd_struct {
+    double __u;
+  } __attribute__((__packed__, __may_alias__));
+  double __u = ((const struct __mm_load_sd_struct *)__dp)->__u;
+  return __extension__(__m128d){__u, 0};
+}
+
+/// Loads a double-precision value into the high-order bits of a 128-bit
+///    vector of [2 x double]. The low-order bits are copied from the low-order
+///    bits of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVHPD / MOVHPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. \n
+///    Bits [63:0] are written to bits [63:0] of the result.
+/// \param __dp
+///    A pointer to a 64-bit memory location containing a double-precision
+///    floating-point value that is loaded. The loaded value is written to bits
+///    [127:64] of the result. The address of the memory location does not have
+///    to be aligned.
+/// \returns A 128-bit vector of [2 x double] containing the moved values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_loadh_pd(__m128d __a,
+                                                          double const *__dp) {
+  struct __mm_loadh_pd_struct {
+    double __u;
+  } __attribute__((__packed__, __may_alias__));
+  double __u = ((const struct __mm_loadh_pd_struct *)__dp)->__u;
+  return __extension__(__m128d){__a[0], __u};
+}
+
+/// Loads a double-precision value into the low-order bits of a 128-bit
+///    vector of [2 x double]. The high-order bits are copied from the
+///    high-order bits of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVLPD / MOVLPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. \n
+///    Bits [127:64] are written to bits [127:64] of the result.
+/// \param __dp
+///    A pointer to a 64-bit memory location containing a double-precision
+///    floating-point value that is loaded. The loaded value is written to bits
+///    [63:0] of the result. The address of the memory location does not have to
+///    be aligned.
+/// \returns A 128-bit vector of [2 x double] containing the moved values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_loadl_pd(__m128d __a,
+                                                          double const *__dp) {
+  struct __mm_loadl_pd_struct {
+    double __u;
+  } __attribute__((__packed__, __may_alias__));
+  double __u = ((const struct __mm_loadl_pd_struct *)__dp)->__u;
+  return __extension__(__m128d){__u, __a[1]};
+}
+
+/// Constructs a 128-bit floating-point vector of [2 x double] with
+///    unspecified content. This could be used as an argument to another
+///    intrinsic function where the argument is required but the value is not
+///    actually used.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \returns A 128-bit floating-point vector of [2 x double] with unspecified
+///    content.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_undefined_pd(void) {
+  return (__m128d)__builtin_ia32_undef128();
+}
+
+/// Constructs a 128-bit floating-point vector of [2 x double]. The lower
+///    64 bits of the vector are initialized with the specified double-precision
+///    floating-point value. The upper 64 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVQ / MOVQ </c> instruction.
+///
+/// \param __w
+///    A double-precision floating-point value used to initialize the lower 64
+///    bits of the result.
+/// \returns An initialized 128-bit floating-point vector of [2 x double]. The
+///    lower 64 bits contain the value of the parameter. The upper 64 bits are
+///    set to zero.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_set_sd(double __w) {
+  return __extension__(__m128d){__w, 0};
+}
+
+/// Constructs a 128-bit floating-point vector of [2 x double], with each
+///    of the two double-precision floating-point vector elements set to the
+///    specified double-precision floating-point value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDDUP / MOVLHPS </c> instruction.
+///
+/// \param __w
+///    A double-precision floating-point value used to initialize each vector
+///    element of the result.
+/// \returns An initialized 128-bit floating-point vector of [2 x double].
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_set1_pd(double __w) {
+  return __extension__(__m128d){__w, __w};
+}
+
+/// Constructs a 128-bit floating-point vector of [2 x double], with each
+///    of the two double-precision floating-point vector elements set to the
+///    specified double-precision floating-point value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDDUP / MOVLHPS </c> instruction.
+///
+/// \param __w
+///    A double-precision floating-point value used to initialize each vector
+///    element of the result.
+/// \returns An initialized 128-bit floating-point vector of [2 x double].
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_set_pd1(double __w) {
+  return _mm_set1_pd(__w);
+}
+
+/// Constructs a 128-bit floating-point vector of [2 x double]
+///    initialized with the specified double-precision floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKLPD / UNPCKLPD </c> instruction.
+///
+/// \param __w
+///    A double-precision floating-point value used to initialize the upper 64
+///    bits of the result.
+/// \param __x
+///    A double-precision floating-point value used to initialize the lower 64
+///    bits of the result.
+/// \returns An initialized 128-bit floating-point vector of [2 x double].
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_set_pd(double __w,
+                                                        double __x) {
+  return __extension__(__m128d){__x, __w};
+}
+
+/// Constructs a 128-bit floating-point vector of [2 x double],
+///    initialized in reverse order with the specified double-precision
+///    floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKLPD / UNPCKLPD </c> instruction.
+///
+/// \param __w
+///    A double-precision floating-point value used to initialize the lower 64
+///    bits of the result.
+/// \param __x
+///    A double-precision floating-point value used to initialize the upper 64
+///    bits of the result.
+/// \returns An initialized 128-bit floating-point vector of [2 x double].
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_setr_pd(double __w,
+                                                         double __x) {
+  return __extension__(__m128d){__w, __x};
+}
+
+/// Constructs a 128-bit floating-point vector of [2 x double]
+///    initialized to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VXORPS / XORPS </c> instruction.
+///
+/// \returns An initialized 128-bit floating-point vector of [2 x double] with
+///    all elements set to zero.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_setzero_pd(void) {
+  return __extension__(__m128d){0.0, 0.0};
+}
+
+/// Constructs a 128-bit floating-point vector of [2 x double]. The lower
+///    64 bits are set to the lower 64 bits of the second parameter. The upper
+///    64 bits are set to the upper 64 bits of the first parameter.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBLENDPD / BLENDPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The upper 64 bits are written to the
+///    upper 64 bits of the result.
+/// \param __b
+///    A 128-bit vector of [2 x double]. The lower 64 bits are written to the
+///    lower 64 bits of the result.
+/// \returns A 128-bit vector of [2 x double] containing the moved values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_move_sd(__m128d __a,
+                                                         __m128d __b) {
+  __a[0] = __b[0];
+  return __a;
+}
+
+/// Stores the lower 64 bits of a 128-bit vector of [2 x double] to a
+///    memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVSD / MOVSD </c> instruction.
+///
+/// \param __dp
+///    A pointer to a 64-bit memory location.
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_store_sd(double *__dp,
+                                                       __m128d __a) {
+  struct __mm_store_sd_struct {
+    double __u;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __mm_store_sd_struct *)__dp)->__u = __a[0];
+}
+
+/// Moves packed double-precision values from a 128-bit vector of
+///    [2 x double] to a memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c>VMOVAPD / MOVAPS</c> instruction.
+///
+/// \param __dp
+///    A pointer to an aligned memory location that can store two
+///    double-precision values.
+/// \param __a
+///    A packed 128-bit vector of [2 x double] containing the values to be
+///    moved.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_store_pd(double *__dp,
+                                                       __m128d __a) {
+  *(__m128d *)__dp = __a;
+}
+
+/// Moves the lower 64 bits of a 128-bit vector of [2 x double] twice to
+///    the upper and lower 64 bits of a memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the
+///   <c> VMOVDDUP + VMOVAPD / MOVLHPS + MOVAPS </c> instruction.
+///
+/// \param __dp
+///    A pointer to a memory location that can store two double-precision
+///    values.
+/// \param __a
+///    A 128-bit vector of [2 x double] whose lower 64 bits are copied to each
+///    of the values in \a __dp.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_store1_pd(double *__dp,
+                                                        __m128d __a) {
+  __a = __builtin_shufflevector((__v2df)__a, (__v2df)__a, 0, 0);
+  _mm_store_pd(__dp, __a);
+}
+
+/// Moves the lower 64 bits of a 128-bit vector of [2 x double] twice to
+///    the upper and lower 64 bits of a memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the
+///   <c> VMOVDDUP + VMOVAPD / MOVLHPS + MOVAPS </c> instruction.
+///
+/// \param __dp
+///    A pointer to a memory location that can store two double-precision
+///    values.
+/// \param __a
+///    A 128-bit vector of [2 x double] whose lower 64 bits are copied to each
+///    of the values in \a __dp.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_store_pd1(double *__dp,
+                                                        __m128d __a) {
+  _mm_store1_pd(__dp, __a);
+}
+
+/// Stores a 128-bit vector of [2 x double] into an unaligned memory
+///    location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVUPD / MOVUPD </c> instruction.
+///
+/// \param __dp
+///    A pointer to a 128-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the values to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_storeu_pd(double *__dp,
+                                                        __m128d __a) {
+  struct __storeu_pd {
+    __m128d_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_pd *)__dp)->__v = __a;
+}
+
+/// Stores two double-precision values, in reverse order, from a 128-bit
+///    vector of [2 x double] to a 16-byte aligned memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to a shuffling instruction followed by a
+/// <c> VMOVAPD / MOVAPD </c> instruction.
+///
+/// \param __dp
+///    A pointer to a 16-byte aligned memory location that can store two
+///    double-precision values.
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the values to be reversed and
+///    stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_storer_pd(double *__dp,
+                                                        __m128d __a) {
+  __a = __builtin_shufflevector((__v2df)__a, (__v2df)__a, 1, 0);
+  *(__m128d *)__dp = __a;
+}
+
+/// Stores the upper 64 bits of a 128-bit vector of [2 x double] to a
+///    memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVHPD / MOVHPD </c> instruction.
+///
+/// \param __dp
+///    A pointer to a 64-bit memory location.
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_storeh_pd(double *__dp,
+                                                        __m128d __a) {
+  struct __mm_storeh_pd_struct {
+    double __u;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __mm_storeh_pd_struct *)__dp)->__u = __a[1];
+}
+
+/// Stores the lower 64 bits of a 128-bit vector of [2 x double] to a
+///    memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVLPD / MOVLPD </c> instruction.
+///
+/// \param __dp
+///    A pointer to a 64-bit memory location.
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_storel_pd(double *__dp,
+                                                        __m128d __a) {
+  struct __mm_storeh_pd_struct {
+    double __u;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __mm_storeh_pd_struct *)__dp)->__u = __a[0];
+}
+
+/// Adds the corresponding elements of two 128-bit vectors of [16 x i8],
+///    saving the lower 8 bits of each sum in the corresponding element of a
+///    128-bit result vector of [16 x i8].
+///
+///    The integer elements of both parameters can be either signed or unsigned.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPADDB / PADDB </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [16 x i8].
+/// \param __b
+///    A 128-bit vector of [16 x i8].
+/// \returns A 128-bit vector of [16 x i8] containing the sums of both
+///    parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_add_epi8(__m128i __a,
+                                                          __m128i __b) {
+  return (__m128i)((__v16qu)__a + (__v16qu)__b);
+}
+
+/// Adds the corresponding elements of two 128-bit vectors of [8 x i16],
+///    saving the lower 16 bits of each sum in the corresponding element of a
+///    128-bit result vector of [8 x i16].
+///
+///    The integer elements of both parameters can be either signed or unsigned.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPADDW / PADDW </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x i16].
+/// \param __b
+///    A 128-bit vector of [8 x i16].
+/// \returns A 128-bit vector of [8 x i16] containing the sums of both
+///    parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_add_epi16(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)((__v8hu)__a + (__v8hu)__b);
+}
+
+/// Adds the corresponding elements of two 128-bit vectors of [4 x i32],
+///    saving the lower 32 bits of each sum in the corresponding element of a
+///    128-bit result vector of [4 x i32].
+///
+///    The integer elements of both parameters can be either signed or unsigned.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPADDD / PADDD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x i32].
+/// \param __b
+///    A 128-bit vector of [4 x i32].
+/// \returns A 128-bit vector of [4 x i32] containing the sums of both
+///    parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_add_epi32(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)((__v4su)__a + (__v4su)__b);
+}
+
+/// Adds two signed or unsigned 64-bit integer values, returning the
+///    lower 64 bits of the sum.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PADDQ </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer.
+/// \param __b
+///    A 64-bit integer.
+/// \returns A 64-bit integer containing the sum of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX _mm_add_si64(__m64 __a,
+                                                            __m64 __b) {
+  return (__m64)__builtin_ia32_paddq((__v1di)__a, (__v1di)__b);
+}
+
+/// Adds the corresponding elements of two 128-bit vectors of [2 x i64],
+///    saving the lower 64 bits of each sum in the corresponding element of a
+///    128-bit result vector of [2 x i64].
+///
+///    The integer elements of both parameters can be either signed or unsigned.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPADDQ / PADDQ </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x i64].
+/// \param __b
+///    A 128-bit vector of [2 x i64].
+/// \returns A 128-bit vector of [2 x i64] containing the sums of both
+///    parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_add_epi64(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)((__v2du)__a + (__v2du)__b);
+}
+
+/// Adds, with saturation, the corresponding elements of two 128-bit
+///    signed [16 x i8] vectors, saving each sum in the corresponding element
+///    of a 128-bit result vector of [16 x i8].
+///
+///    Positive sums greater than 0x7F are saturated to 0x7F. Negative sums
+///    less than 0x80 are saturated to 0x80.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPADDSB / PADDSB </c> instruction.
+///
+/// \param __a
+///    A 128-bit signed [16 x i8] vector.
+/// \param __b
+///    A 128-bit signed [16 x i8] vector.
+/// \returns A 128-bit signed [16 x i8] vector containing the saturated sums of
+///    both parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_adds_epi8(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)__builtin_elementwise_add_sat((__v16qs)__a, (__v16qs)__b);
+}
+
+/// Adds, with saturation, the corresponding elements of two 128-bit
+///    signed [8 x i16] vectors, saving each sum in the corresponding element
+///    of a 128-bit result vector of [8 x i16].
+///
+///    Positive sums greater than 0x7FFF are saturated to 0x7FFF. Negative sums
+///    less than 0x8000 are saturated to 0x8000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPADDSW / PADDSW </c> instruction.
+///
+/// \param __a
+///    A 128-bit signed [8 x i16] vector.
+/// \param __b
+///    A 128-bit signed [8 x i16] vector.
+/// \returns A 128-bit signed [8 x i16] vector containing the saturated sums of
+///    both parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_adds_epi16(__m128i __a,
+                                                            __m128i __b) {
+  return (__m128i)__builtin_elementwise_add_sat((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Adds, with saturation, the corresponding elements of two 128-bit
+///    unsigned [16 x i8] vectors, saving each sum in the corresponding element
+///    of a 128-bit result vector of [16 x i8].
+///
+///    Positive sums greater than 0xFF are saturated to 0xFF. Negative sums are
+///    saturated to 0x00.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPADDUSB / PADDUSB </c> instruction.
+///
+/// \param __a
+///    A 128-bit unsigned [16 x i8] vector.
+/// \param __b
+///    A 128-bit unsigned [16 x i8] vector.
+/// \returns A 128-bit unsigned [16 x i8] vector containing the saturated sums
+///    of both parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_adds_epu8(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)__builtin_elementwise_add_sat((__v16qu)__a, (__v16qu)__b);
+}
+
+/// Adds, with saturation, the corresponding elements of two 128-bit
+///    unsigned [8 x i16] vectors, saving each sum in the corresponding element
+///    of a 128-bit result vector of [8 x i16].
+///
+///    Positive sums greater than 0xFFFF are saturated to 0xFFFF. Negative sums
+///    are saturated to 0x0000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPADDUSB / PADDUSB </c> instruction.
+///
+/// \param __a
+///    A 128-bit unsigned [8 x i16] vector.
+/// \param __b
+///    A 128-bit unsigned [8 x i16] vector.
+/// \returns A 128-bit unsigned [8 x i16] vector containing the saturated sums
+///    of both parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_adds_epu16(__m128i __a,
+                                                            __m128i __b) {
+  return (__m128i)__builtin_elementwise_add_sat((__v8hu)__a, (__v8hu)__b);
+}
+
+/// Computes the rounded averages of corresponding elements of two
+///    128-bit unsigned [16 x i8] vectors, saving each result in the
+///    corresponding element of a 128-bit result vector of [16 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPAVGB / PAVGB </c> instruction.
+///
+/// \param __a
+///    A 128-bit unsigned [16 x i8] vector.
+/// \param __b
+///    A 128-bit unsigned [16 x i8] vector.
+/// \returns A 128-bit unsigned [16 x i8] vector containing the rounded
+///    averages of both parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_avg_epu8(__m128i __a,
+                                                          __m128i __b) {
+  return (__m128i)__builtin_ia32_pavgb128((__v16qi)__a, (__v16qi)__b);
+}
+
+/// Computes the rounded averages of corresponding elements of two
+///    128-bit unsigned [8 x i16] vectors, saving each result in the
+///    corresponding element of a 128-bit result vector of [8 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPAVGW / PAVGW </c> instruction.
+///
+/// \param __a
+///    A 128-bit unsigned [8 x i16] vector.
+/// \param __b
+///    A 128-bit unsigned [8 x i16] vector.
+/// \returns A 128-bit unsigned [8 x i16] vector containing the rounded
+///    averages of both parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_avg_epu16(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)__builtin_ia32_pavgw128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Multiplies the corresponding elements of two 128-bit signed [8 x i16]
+///    vectors, producing eight intermediate 32-bit signed integer products, and
+///    adds the consecutive pairs of 32-bit products to form a 128-bit signed
+///    [4 x i32] vector.
+///
+///    For example, bits [15:0] of both parameters are multiplied producing a
+///    32-bit product, bits [31:16] of both parameters are multiplied producing
+///    a 32-bit product, and the sum of those two products becomes bits [31:0]
+///    of the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMADDWD / PMADDWD </c> instruction.
+///
+/// \param __a
+///    A 128-bit signed [8 x i16] vector.
+/// \param __b
+///    A 128-bit signed [8 x i16] vector.
+/// \returns A 128-bit signed [4 x i32] vector containing the sums of products
+///    of both parameters.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_madd_epi16(__m128i __a,
+                                                            __m128i __b) {
+  return (__m128i)__builtin_ia32_pmaddwd128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Compares corresponding elements of two 128-bit signed [8 x i16]
+///    vectors, saving the greater value from each comparison in the
+///    corresponding element of a 128-bit result vector of [8 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMAXSW / PMAXSW </c> instruction.
+///
+/// \param __a
+///    A 128-bit signed [8 x i16] vector.
+/// \param __b
+///    A 128-bit signed [8 x i16] vector.
+/// \returns A 128-bit signed [8 x i16] vector containing the greater value of
+///    each comparison.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epi16(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)__builtin_elementwise_max((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Compares corresponding elements of two 128-bit unsigned [16 x i8]
+///    vectors, saving the greater value from each comparison in the
+///    corresponding element of a 128-bit result vector of [16 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMAXUB / PMAXUB </c> instruction.
+///
+/// \param __a
+///    A 128-bit unsigned [16 x i8] vector.
+/// \param __b
+///    A 128-bit unsigned [16 x i8] vector.
+/// \returns A 128-bit unsigned [16 x i8] vector containing the greater value of
+///    each comparison.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epu8(__m128i __a,
+                                                          __m128i __b) {
+  return (__m128i)__builtin_elementwise_max((__v16qu)__a, (__v16qu)__b);
+}
+
+/// Compares corresponding elements of two 128-bit signed [8 x i16]
+///    vectors, saving the smaller value from each comparison in the
+///    corresponding element of a 128-bit result vector of [8 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMINSW / PMINSW </c> instruction.
+///
+/// \param __a
+///    A 128-bit signed [8 x i16] vector.
+/// \param __b
+///    A 128-bit signed [8 x i16] vector.
+/// \returns A 128-bit signed [8 x i16] vector containing the smaller value of
+///    each comparison.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epi16(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)__builtin_elementwise_min((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Compares corresponding elements of two 128-bit unsigned [16 x i8]
+///    vectors, saving the smaller value from each comparison in the
+///    corresponding element of a 128-bit result vector of [16 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMINUB / PMINUB </c> instruction.
+///
+/// \param __a
+///    A 128-bit unsigned [16 x i8] vector.
+/// \param __b
+///    A 128-bit unsigned [16 x i8] vector.
+/// \returns A 128-bit unsigned [16 x i8] vector containing the smaller value of
+///    each comparison.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epu8(__m128i __a,
+                                                          __m128i __b) {
+  return (__m128i)__builtin_elementwise_min((__v16qu)__a, (__v16qu)__b);
+}
+
+/// Multiplies the corresponding elements of two signed [8 x i16]
+///    vectors, saving the upper 16 bits of each 32-bit product in the
+///    corresponding element of a 128-bit signed [8 x i16] result vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMULHW / PMULHW </c> instruction.
+///
+/// \param __a
+///    A 128-bit signed [8 x i16] vector.
+/// \param __b
+///    A 128-bit signed [8 x i16] vector.
+/// \returns A 128-bit signed [8 x i16] vector containing the upper 16 bits of
+///    each of the eight 32-bit products.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mulhi_epi16(__m128i __a,
+                                                             __m128i __b) {
+  return (__m128i)__builtin_ia32_pmulhw128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Multiplies the corresponding elements of two unsigned [8 x i16]
+///    vectors, saving the upper 16 bits of each 32-bit product in the
+///    corresponding element of a 128-bit unsigned [8 x i16] result vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMULHUW / PMULHUW </c> instruction.
+///
+/// \param __a
+///    A 128-bit unsigned [8 x i16] vector.
+/// \param __b
+///    A 128-bit unsigned [8 x i16] vector.
+/// \returns A 128-bit unsigned [8 x i16] vector containing the upper 16 bits
+///    of each of the eight 32-bit products.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mulhi_epu16(__m128i __a,
+                                                             __m128i __b) {
+  return (__m128i)__builtin_ia32_pmulhuw128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Multiplies the corresponding elements of two signed [8 x i16]
+///    vectors, saving the lower 16 bits of each 32-bit product in the
+///    corresponding element of a 128-bit signed [8 x i16] result vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMULLW / PMULLW </c> instruction.
+///
+/// \param __a
+///    A 128-bit signed [8 x i16] vector.
+/// \param __b
+///    A 128-bit signed [8 x i16] vector.
+/// \returns A 128-bit signed [8 x i16] vector containing the lower 16 bits of
+///    each of the eight 32-bit products.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mullo_epi16(__m128i __a,
+                                                             __m128i __b) {
+  return (__m128i)((__v8hu)__a * (__v8hu)__b);
+}
+
+/// Multiplies 32-bit unsigned integer values contained in the lower bits
+///    of the two 64-bit integer vectors and returns the 64-bit unsigned
+///    product.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PMULUDQ </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer containing one of the source operands.
+/// \param __b
+///    A 64-bit integer containing one of the source operands.
+/// \returns A 64-bit integer vector containing the product of both operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX _mm_mul_su32(__m64 __a,
+                                                            __m64 __b) {
+  return __builtin_ia32_pmuludq((__v2si)__a, (__v2si)__b);
+}
+
+/// Multiplies 32-bit unsigned integer values contained in the lower
+///    bits of the corresponding elements of two [2 x i64] vectors, and returns
+///    the 64-bit products in the corresponding elements of a [2 x i64] vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMULUDQ / PMULUDQ </c> instruction.
+///
+/// \param __a
+///    A [2 x i64] vector containing one of the source operands.
+/// \param __b
+///    A [2 x i64] vector containing one of the source operands.
+/// \returns A [2 x i64] vector containing the product of both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mul_epu32(__m128i __a,
+                                                           __m128i __b) {
+  return __builtin_ia32_pmuludq128((__v4si)__a, (__v4si)__b);
+}
+
+/// Computes the absolute differences of corresponding 8-bit integer
+///    values in two 128-bit vectors. Sums the first 8 absolute differences, and
+///    separately sums the second 8 absolute differences. Packs these two
+///    unsigned 16-bit integer sums into the upper and lower elements of a
+///    [2 x i64] vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSADBW / PSADBW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 128-bit integer vector containing one of the source operands.
+/// \returns A [2 x i64] vector containing the sums of the sets of absolute
+///    differences between both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sad_epu8(__m128i __a,
+                                                          __m128i __b) {
+  return __builtin_ia32_psadbw128((__v16qi)__a, (__v16qi)__b);
+}
+
+/// Subtracts the corresponding 8-bit integer values in the operands.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSUBB / PSUBB </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the minuends.
+/// \param __b
+///    A 128-bit integer vector containing the subtrahends.
+/// \returns A 128-bit integer vector containing the differences of the values
+///    in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sub_epi8(__m128i __a,
+                                                          __m128i __b) {
+  return (__m128i)((__v16qu)__a - (__v16qu)__b);
+}
+
+/// Subtracts the corresponding 16-bit integer values in the operands.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSUBW / PSUBW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the minuends.
+/// \param __b
+///    A 128-bit integer vector containing the subtrahends.
+/// \returns A 128-bit integer vector containing the differences of the values
+///    in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sub_epi16(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)((__v8hu)__a - (__v8hu)__b);
+}
+
+/// Subtracts the corresponding 32-bit integer values in the operands.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSUBD / PSUBD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the minuends.
+/// \param __b
+///    A 128-bit integer vector containing the subtrahends.
+/// \returns A 128-bit integer vector containing the differences of the values
+///    in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sub_epi32(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)((__v4su)__a - (__v4su)__b);
+}
+
+/// Subtracts signed or unsigned 64-bit integer values and writes the
+///    difference to the corresponding bits in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSUBQ </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing the minuend.
+/// \param __b
+///    A 64-bit integer vector containing the subtrahend.
+/// \returns A 64-bit integer vector containing the difference of the values in
+///    the operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX _mm_sub_si64(__m64 __a,
+                                                            __m64 __b) {
+  return (__m64)__builtin_ia32_psubq((__v1di)__a, (__v1di)__b);
+}
+
+/// Subtracts the corresponding elements of two [2 x i64] vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSUBQ / PSUBQ </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the minuends.
+/// \param __b
+///    A 128-bit integer vector containing the subtrahends.
+/// \returns A 128-bit integer vector containing the differences of the values
+///    in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sub_epi64(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)((__v2du)__a - (__v2du)__b);
+}
+
+/// Subtracts, with saturation, corresponding 8-bit signed integer values in
+///    the input and returns the differences in the corresponding bytes in the
+///    destination.
+///
+///    Differences greater than 0x7F are saturated to 0x7F, and differences
+///    less than 0x80 are saturated to 0x80.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSUBSB / PSUBSB </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the minuends.
+/// \param __b
+///    A 128-bit integer vector containing the subtrahends.
+/// \returns A 128-bit integer vector containing the differences of the values
+///    in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_subs_epi8(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)__builtin_elementwise_sub_sat((__v16qs)__a, (__v16qs)__b);
+}
+
+/// Subtracts, with saturation, corresponding 16-bit signed integer values in
+///    the input and returns the differences in the corresponding bytes in the
+///    destination.
+///
+///    Differences greater than 0x7FFF are saturated to 0x7FFF, and values less
+///    than 0x8000 are saturated to 0x8000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSUBSW / PSUBSW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the minuends.
+/// \param __b
+///    A 128-bit integer vector containing the subtrahends.
+/// \returns A 128-bit integer vector containing the differences of the values
+///    in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_subs_epi16(__m128i __a,
+                                                            __m128i __b) {
+  return (__m128i)__builtin_elementwise_sub_sat((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Subtracts, with saturation, corresponding 8-bit unsigned integer values in
+///    the input and returns the differences in the corresponding bytes in the
+///    destination.
+///
+///    Differences less than 0x00 are saturated to 0x00.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSUBUSB / PSUBUSB </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the minuends.
+/// \param __b
+///    A 128-bit integer vector containing the subtrahends.
+/// \returns A 128-bit integer vector containing the unsigned integer
+///    differences of the values in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_subs_epu8(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)__builtin_elementwise_sub_sat((__v16qu)__a, (__v16qu)__b);
+}
+
+/// Subtracts, with saturation, corresponding 16-bit unsigned integer values in
+///    the input and returns the differences in the corresponding bytes in the
+///    destination.
+///
+///    Differences less than 0x0000 are saturated to 0x0000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSUBUSW / PSUBUSW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the minuends.
+/// \param __b
+///    A 128-bit integer vector containing the subtrahends.
+/// \returns A 128-bit integer vector containing the unsigned integer
+///    differences of the values in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_subs_epu16(__m128i __a,
+                                                            __m128i __b) {
+  return (__m128i)__builtin_elementwise_sub_sat((__v8hu)__a, (__v8hu)__b);
+}
+
+/// Performs a bitwise AND of two 128-bit integer vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPAND / PAND </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 128-bit integer vector containing one of the source operands.
+/// \returns A 128-bit integer vector containing the bitwise AND of the values
+///    in both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_and_si128(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)((__v2du)__a & (__v2du)__b);
+}
+
+/// Performs a bitwise AND of two 128-bit integer vectors, using the
+///    one's complement of the values contained in the first source operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPANDN / PANDN </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector containing the left source operand. The one's complement
+///    of this value is used in the bitwise AND.
+/// \param __b
+///    A 128-bit vector containing the right source operand.
+/// \returns A 128-bit integer vector containing the bitwise AND of the one's
+///    complement of the first operand and the values in the second operand.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_andnot_si128(__m128i __a,
+                                                              __m128i __b) {
+  return (__m128i)(~(__v2du)__a & (__v2du)__b);
+}
+/// Performs a bitwise OR of two 128-bit integer vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPOR / POR </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 128-bit integer vector containing one of the source operands.
+/// \returns A 128-bit integer vector containing the bitwise OR of the values
+///    in both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_or_si128(__m128i __a,
+                                                          __m128i __b) {
+  return (__m128i)((__v2du)__a | (__v2du)__b);
+}
+
+/// Performs a bitwise exclusive OR of two 128-bit integer vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPXOR / PXOR </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 128-bit integer vector containing one of the source operands.
+/// \returns A 128-bit integer vector containing the bitwise exclusive OR of the
+///    values in both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_xor_si128(__m128i __a,
+                                                           __m128i __b) {
+  return (__m128i)((__v2du)__a ^ (__v2du)__b);
+}
+
+/// Left-shifts the 128-bit integer vector operand by the specified
+///    number of bytes. Low-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_slli_si128(__m128i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPSLLDQ / PSLLDQ </c> instruction.
+///
+/// \param a
+///    A 128-bit integer vector containing the source operand.
+/// \param imm
+///    An immediate value specifying the number of bytes to left-shift operand
+///    \a a.
+/// \returns A 128-bit integer vector containing the left-shifted value.
+#define _mm_slli_si128(a, imm)                                                 \
+  ((__m128i)__builtin_ia32_pslldqi128_byteshift((__v2di)(__m128i)(a),          \
+                                                (int)(imm)))
+
+#define _mm_bslli_si128(a, imm)                                                \
+  ((__m128i)__builtin_ia32_pslldqi128_byteshift((__v2di)(__m128i)(a),          \
+                                                (int)(imm)))
+
+/// Left-shifts each 16-bit value in the 128-bit integer vector operand
+///    by the specified number of bits. Low-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSLLW / PSLLW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    An integer value specifying the number of bits to left-shift each value
+///    in operand \a __a.
+/// \returns A 128-bit integer vector containing the left-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_slli_epi16(__m128i __a,
+                                                            int __count) {
+  return (__m128i)__builtin_ia32_psllwi128((__v8hi)__a, __count);
+}
+
+/// Left-shifts each 16-bit value in the 128-bit integer vector operand
+///    by the specified number of bits. Low-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSLLW / PSLLW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    A 128-bit integer vector in which bits [63:0] specify the number of bits
+///    to left-shift each value in operand \a __a.
+/// \returns A 128-bit integer vector containing the left-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sll_epi16(__m128i __a,
+                                                           __m128i __count) {
+  return (__m128i)__builtin_ia32_psllw128((__v8hi)__a, (__v8hi)__count);
+}
+
+/// Left-shifts each 32-bit value in the 128-bit integer vector operand
+///    by the specified number of bits. Low-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSLLD / PSLLD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    An integer value specifying the number of bits to left-shift each value
+///    in operand \a __a.
+/// \returns A 128-bit integer vector containing the left-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_slli_epi32(__m128i __a,
+                                                            int __count) {
+  return (__m128i)__builtin_ia32_pslldi128((__v4si)__a, __count);
+}
+
+/// Left-shifts each 32-bit value in the 128-bit integer vector operand
+///    by the specified number of bits. Low-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSLLD / PSLLD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    A 128-bit integer vector in which bits [63:0] specify the number of bits
+///    to left-shift each value in operand \a __a.
+/// \returns A 128-bit integer vector containing the left-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sll_epi32(__m128i __a,
+                                                           __m128i __count) {
+  return (__m128i)__builtin_ia32_pslld128((__v4si)__a, (__v4si)__count);
+}
+
+/// Left-shifts each 64-bit value in the 128-bit integer vector operand
+///    by the specified number of bits. Low-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSLLQ / PSLLQ </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    An integer value specifying the number of bits to left-shift each value
+///    in operand \a __a.
+/// \returns A 128-bit integer vector containing the left-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_slli_epi64(__m128i __a,
+                                                            int __count) {
+  return __builtin_ia32_psllqi128((__v2di)__a, __count);
+}
+
+/// Left-shifts each 64-bit value in the 128-bit integer vector operand
+///    by the specified number of bits. Low-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSLLQ / PSLLQ </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    A 128-bit integer vector in which bits [63:0] specify the number of bits
+///    to left-shift each value in operand \a __a.
+/// \returns A 128-bit integer vector containing the left-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sll_epi64(__m128i __a,
+                                                           __m128i __count) {
+  return __builtin_ia32_psllq128((__v2di)__a, (__v2di)__count);
+}
+
+/// Right-shifts each 16-bit value in the 128-bit integer vector operand
+///    by the specified number of bits. High-order bits are filled with the sign
+///    bit of the initial value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSRAW / PSRAW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    An integer value specifying the number of bits to right-shift each value
+///    in operand \a __a.
+/// \returns A 128-bit integer vector containing the right-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srai_epi16(__m128i __a,
+                                                            int __count) {
+  return (__m128i)__builtin_ia32_psrawi128((__v8hi)__a, __count);
+}
+
+/// Right-shifts each 16-bit value in the 128-bit integer vector operand
+///    by the specified number of bits. High-order bits are filled with the sign
+///    bit of the initial value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSRAW / PSRAW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    A 128-bit integer vector in which bits [63:0] specify the number of bits
+///    to right-shift each value in operand \a __a.
+/// \returns A 128-bit integer vector containing the right-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sra_epi16(__m128i __a,
+                                                           __m128i __count) {
+  return (__m128i)__builtin_ia32_psraw128((__v8hi)__a, (__v8hi)__count);
+}
+
+/// Right-shifts each 32-bit value in the 128-bit integer vector operand
+///    by the specified number of bits. High-order bits are filled with the sign
+///    bit of the initial value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSRAD / PSRAD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    An integer value specifying the number of bits to right-shift each value
+///    in operand \a __a.
+/// \returns A 128-bit integer vector containing the right-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srai_epi32(__m128i __a,
+                                                            int __count) {
+  return (__m128i)__builtin_ia32_psradi128((__v4si)__a, __count);
+}
+
+/// Right-shifts each 32-bit value in the 128-bit integer vector operand
+///    by the specified number of bits. High-order bits are filled with the sign
+///    bit of the initial value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSRAD / PSRAD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    A 128-bit integer vector in which bits [63:0] specify the number of bits
+///    to right-shift each value in operand \a __a.
+/// \returns A 128-bit integer vector containing the right-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_sra_epi32(__m128i __a,
+                                                           __m128i __count) {
+  return (__m128i)__builtin_ia32_psrad128((__v4si)__a, (__v4si)__count);
+}
+
+/// Right-shifts the 128-bit integer vector operand by the specified
+///    number of bytes. High-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_srli_si128(__m128i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPSRLDQ / PSRLDQ </c> instruction.
+///
+/// \param a
+///    A 128-bit integer vector containing the source operand.
+/// \param imm
+///    An immediate value specifying the number of bytes to right-shift operand
+///    \a a.
+/// \returns A 128-bit integer vector containing the right-shifted value.
+#define _mm_srli_si128(a, imm)                                                 \
+  ((__m128i)__builtin_ia32_psrldqi128_byteshift((__v2di)(__m128i)(a),          \
+                                                (int)(imm)))
+
+#define _mm_bsrli_si128(a, imm)                                                \
+  ((__m128i)__builtin_ia32_psrldqi128_byteshift((__v2di)(__m128i)(a),          \
+                                                (int)(imm)))
+
+/// Right-shifts each of 16-bit values in the 128-bit integer vector
+///    operand by the specified number of bits. High-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSRLW / PSRLW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    An integer value specifying the number of bits to right-shift each value
+///    in operand \a __a.
+/// \returns A 128-bit integer vector containing the right-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srli_epi16(__m128i __a,
+                                                            int __count) {
+  return (__m128i)__builtin_ia32_psrlwi128((__v8hi)__a, __count);
+}
+
+/// Right-shifts each of 16-bit values in the 128-bit integer vector
+///    operand by the specified number of bits. High-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSRLW / PSRLW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    A 128-bit integer vector in which bits [63:0] specify the number of bits
+///    to right-shift each value in operand \a __a.
+/// \returns A 128-bit integer vector containing the right-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srl_epi16(__m128i __a,
+                                                           __m128i __count) {
+  return (__m128i)__builtin_ia32_psrlw128((__v8hi)__a, (__v8hi)__count);
+}
+
+/// Right-shifts each of 32-bit values in the 128-bit integer vector
+///    operand by the specified number of bits. High-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSRLD / PSRLD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    An integer value specifying the number of bits to right-shift each value
+///    in operand \a __a.
+/// \returns A 128-bit integer vector containing the right-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srli_epi32(__m128i __a,
+                                                            int __count) {
+  return (__m128i)__builtin_ia32_psrldi128((__v4si)__a, __count);
+}
+
+/// Right-shifts each of 32-bit values in the 128-bit integer vector
+///    operand by the specified number of bits. High-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSRLD / PSRLD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    A 128-bit integer vector in which bits [63:0] specify the number of bits
+///    to right-shift each value in operand \a __a.
+/// \returns A 128-bit integer vector containing the right-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srl_epi32(__m128i __a,
+                                                           __m128i __count) {
+  return (__m128i)__builtin_ia32_psrld128((__v4si)__a, (__v4si)__count);
+}
+
+/// Right-shifts each of 64-bit values in the 128-bit integer vector
+///    operand by the specified number of bits. High-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSRLQ / PSRLQ </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    An integer value specifying the number of bits to right-shift each value
+///    in operand \a __a.
+/// \returns A 128-bit integer vector containing the right-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srli_epi64(__m128i __a,
+                                                            int __count) {
+  return __builtin_ia32_psrlqi128((__v2di)__a, __count);
+}
+
+/// Right-shifts each of 64-bit values in the 128-bit integer vector
+///    operand by the specified number of bits. High-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPSRLQ / PSRLQ </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the source operand.
+/// \param __count
+///    A 128-bit integer vector in which bits [63:0] specify the number of bits
+///    to right-shift each value in operand \a __a.
+/// \returns A 128-bit integer vector containing the right-shifted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_srl_epi64(__m128i __a,
+                                                           __m128i __count) {
+  return __builtin_ia32_psrlq128((__v2di)__a, (__v2di)__count);
+}
+
+/// Compares each of the corresponding 8-bit values of the 128-bit
+///    integer vectors for equality.
+///
+///    Each comparison returns 0x0 for false, 0xFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPEQB / PCMPEQB </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \param __b
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi8(__m128i __a,
+                                                            __m128i __b) {
+  return (__m128i)((__v16qi)__a == (__v16qi)__b);
+}
+
+/// Compares each of the corresponding 16-bit values of the 128-bit
+///    integer vectors for equality.
+///
+///    Each comparison returns 0x0 for false, 0xFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPEQW / PCMPEQW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \param __b
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi16(__m128i __a,
+                                                             __m128i __b) {
+  return (__m128i)((__v8hi)__a == (__v8hi)__b);
+}
+
+/// Compares each of the corresponding 32-bit values of the 128-bit
+///    integer vectors for equality.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPEQD / PCMPEQD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \param __b
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi32(__m128i __a,
+                                                             __m128i __b) {
+  return (__m128i)((__v4si)__a == (__v4si)__b);
+}
+
+/// Compares each of the corresponding signed 8-bit values of the 128-bit
+///    integer vectors to determine if the values in the first operand are
+///    greater than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPGTB / PCMPGTB </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \param __b
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi8(__m128i __a,
+                                                            __m128i __b) {
+  /* This function always performs a signed comparison, but __v16qi is a char
+     which may be signed or unsigned, so use __v16qs. */
+  return (__m128i)((__v16qs)__a > (__v16qs)__b);
+}
+
+/// Compares each of the corresponding signed 16-bit values of the
+///    128-bit integer vectors to determine if the values in the first operand
+///    are greater than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPGTW / PCMPGTW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \param __b
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi16(__m128i __a,
+                                                             __m128i __b) {
+  return (__m128i)((__v8hi)__a > (__v8hi)__b);
+}
+
+/// Compares each of the corresponding signed 32-bit values of the
+///    128-bit integer vectors to determine if the values in the first operand
+///    are greater than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPGTD / PCMPGTD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \param __b
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi32(__m128i __a,
+                                                             __m128i __b) {
+  return (__m128i)((__v4si)__a > (__v4si)__b);
+}
+
+/// Compares each of the corresponding signed 8-bit values of the 128-bit
+///    integer vectors to determine if the values in the first operand are less
+///    than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPGTB / PCMPGTB </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \param __b
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmplt_epi8(__m128i __a,
+                                                            __m128i __b) {
+  return _mm_cmpgt_epi8(__b, __a);
+}
+
+/// Compares each of the corresponding signed 16-bit values of the
+///    128-bit integer vectors to determine if the values in the first operand
+///    are less than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPGTW / PCMPGTW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \param __b
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmplt_epi16(__m128i __a,
+                                                             __m128i __b) {
+  return _mm_cmpgt_epi16(__b, __a);
+}
+
+/// Compares each of the corresponding signed 32-bit values of the
+///    128-bit integer vectors to determine if the values in the first operand
+///    are less than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPGTD / PCMPGTD </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \param __b
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmplt_epi32(__m128i __a,
+                                                             __m128i __b) {
+  return _mm_cmpgt_epi32(__b, __a);
+}
+
+#ifdef __x86_64__
+/// Converts a 64-bit signed integer value from the second operand into a
+///    double-precision value and returns it in the lower element of a [2 x
+///    double] vector; the upper element of the returned vector is copied from
+///    the upper element of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSI2SD / CVTSI2SD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The upper 64 bits of this operand are
+///    copied to the upper 64 bits of the destination.
+/// \param __b
+///    A 64-bit signed integer operand containing the value to be converted.
+/// \returns A 128-bit vector of [2 x double] whose lower 64 bits contain the
+///    converted value of the second operand. The upper 64 bits are copied from
+///    the upper 64 bits of the first operand.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_cvtsi64_sd(__m128d __a,
+                                                            long long __b) {
+  __a[0] = __b;
+  return __a;
+}
+
+/// Converts the first (lower) element of a vector of [2 x double] into a
+///    64-bit signed integer value.
+///
+///    If the converted value does not fit in a 64-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSD2SI / CVTSD2SI </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower 64 bits are used in the
+///    conversion.
+/// \returns A 64-bit signed integer containing the converted value.
+static __inline__ long long __DEFAULT_FN_ATTRS _mm_cvtsd_si64(__m128d __a) {
+  return __builtin_ia32_cvtsd2si64((__v2df)__a);
+}
+
+/// Converts the first (lower) element of a vector of [2 x double] into a
+///    64-bit signed truncated (rounded toward zero) integer value.
+///
+///    If a converted value does not fit in a 64-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTTSD2SI / CVTTSD2SI </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. The lower 64 bits are used in the
+///    conversion.
+/// \returns A 64-bit signed integer containing the converted value.
+static __inline__ long long __DEFAULT_FN_ATTRS _mm_cvttsd_si64(__m128d __a) {
+  return __builtin_ia32_cvttsd2si64((__v2df)__a);
+}
+#endif
+
+/// Converts a vector of [4 x i32] into a vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTDQ2PS / CVTDQ2PS </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \returns A 128-bit vector of [4 x float] containing the converted values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_cvtepi32_ps(__m128i __a) {
+  return (__m128) __builtin_convertvector((__v4si)__a, __v4sf);
+}
+
+/// Converts a vector of [4 x float] into a vector of [4 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPS2DQ / CVTPS2DQ </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit integer vector of [4 x i32] containing the converted
+///    values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtps_epi32(__m128 __a) {
+  return (__m128i)__builtin_ia32_cvtps2dq((__v4sf)__a);
+}
+
+/// Converts a vector of [4 x float] into four signed truncated (rounded toward
+///    zero) 32-bit integers, returned in a vector of [4 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTTPS2DQ / CVTTPS2DQ </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x i32] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvttps_epi32(__m128 __a) {
+  return (__m128i)__builtin_ia32_cvttps2dq((__v4sf)__a);
+}
+
+/// Returns a vector of [4 x i32] where the lowest element is the input
+///    operand and the remaining elements are zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVD / MOVD </c> instruction.
+///
+/// \param __a
+///    A 32-bit signed integer operand.
+/// \returns A 128-bit vector of [4 x i32].
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtsi32_si128(int __a) {
+  return __extension__(__m128i)(__v4si){__a, 0, 0, 0};
+}
+
+/// Returns a vector of [2 x i64] where the lower element is the input
+///    operand and the upper element is zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVQ / MOVQ </c> instruction
+/// in 64-bit mode.
+///
+/// \param __a
+///    A 64-bit signed integer operand containing the value to be converted.
+/// \returns A 128-bit vector of [2 x i64] containing the converted value.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtsi64_si128(long long __a) {
+  return __extension__(__m128i)(__v2di){__a, 0};
+}
+
+/// Moves the least significant 32 bits of a vector of [4 x i32] to a
+///    32-bit signed integer value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVD / MOVD </c> instruction.
+///
+/// \param __a
+///    A vector of [4 x i32]. The least significant 32 bits are moved to the
+///    destination.
+/// \returns A 32-bit signed integer containing the moved value.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_cvtsi128_si32(__m128i __a) {
+  __v4si __b = (__v4si)__a;
+  return __b[0];
+}
+
+/// Moves the least significant 64 bits of a vector of [2 x i64] to a
+///    64-bit signed integer value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVQ / MOVQ </c> instruction.
+///
+/// \param __a
+///    A vector of [2 x i64]. The least significant 64 bits are moved to the
+///    destination.
+/// \returns A 64-bit signed integer containing the moved value.
+static __inline__ long long __DEFAULT_FN_ATTRS _mm_cvtsi128_si64(__m128i __a) {
+  return __a[0];
+}
+
+/// Moves packed integer values from an aligned 128-bit memory location
+///    to elements in a 128-bit integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDQA / MOVDQA </c> instruction.
+///
+/// \param __p
+///    An aligned pointer to a memory location containing integer values.
+/// \returns A 128-bit integer vector containing the moved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_load_si128(__m128i const *__p) {
+  return *__p;
+}
+
+/// Moves packed integer values from an unaligned 128-bit memory location
+///    to elements in a 128-bit integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDQU / MOVDQU </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location containing integer values.
+/// \returns A 128-bit integer vector containing the moved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_loadu_si128(__m128i_u const *__p) {
+  struct __loadu_si128 {
+    __m128i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_si128 *)__p)->__v;
+}
+
+/// Returns a vector of [2 x i64] where the lower element is taken from
+///    the lower element of the operand, and the upper element is zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVQ / MOVQ </c> instruction.
+///
+/// \param __p
+///    A 128-bit vector of [2 x i64]. Bits [63:0] are written to bits [63:0] of
+///    the destination.
+/// \returns A 128-bit vector of [2 x i64]. The lower order bits contain the
+///    moved value. The higher order bits are cleared.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_loadl_epi64(__m128i_u const *__p) {
+  struct __mm_loadl_epi64_struct {
+    long long __u;
+  } __attribute__((__packed__, __may_alias__));
+  return __extension__(__m128i){
+      ((const struct __mm_loadl_epi64_struct *)__p)->__u, 0};
+}
+
+/// Generates a 128-bit vector of [4 x i32] with unspecified content.
+///    This could be used as an argument to another intrinsic function where the
+///    argument is required but the value is not actually used.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \returns A 128-bit vector of [4 x i32] with unspecified content.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_undefined_si128(void) {
+  return (__m128i)__builtin_ia32_undef128();
+}
+
+/// Initializes both 64-bit values in a 128-bit vector of [2 x i64] with
+///    the specified 64-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __q1
+///    A 64-bit integer value used to initialize the upper 64 bits of the
+///    destination vector of [2 x i64].
+/// \param __q0
+///    A 64-bit integer value used to initialize the lower 64 bits of the
+///    destination vector of [2 x i64].
+/// \returns An initialized 128-bit vector of [2 x i64] containing the values
+///    provided in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set_epi64x(long long __q1,
+                                                            long long __q0) {
+  return __extension__(__m128i)(__v2di){__q0, __q1};
+}
+
+/// Initializes both 64-bit values in a 128-bit vector of [2 x i64] with
+///    the specified 64-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __q1
+///    A 64-bit integer value used to initialize the upper 64 bits of the
+///    destination vector of [2 x i64].
+/// \param __q0
+///    A 64-bit integer value used to initialize the lower 64 bits of the
+///    destination vector of [2 x i64].
+/// \returns An initialized 128-bit vector of [2 x i64] containing the values
+///    provided in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set_epi64(__m64 __q1,
+                                                           __m64 __q0) {
+  return _mm_set_epi64x((long long)__q1, (long long)__q0);
+}
+
+/// Initializes the 32-bit values in a 128-bit vector of [4 x i32] with
+///    the specified 32-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __i3
+///    A 32-bit integer value used to initialize bits [127:96] of the
+///    destination vector.
+/// \param __i2
+///    A 32-bit integer value used to initialize bits [95:64] of the destination
+///    vector.
+/// \param __i1
+///    A 32-bit integer value used to initialize bits [63:32] of the destination
+///    vector.
+/// \param __i0
+///    A 32-bit integer value used to initialize bits [31:0] of the destination
+///    vector.
+/// \returns An initialized 128-bit vector of [4 x i32] containing the values
+///    provided in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set_epi32(int __i3, int __i2,
+                                                           int __i1, int __i0) {
+  return __extension__(__m128i)(__v4si){__i0, __i1, __i2, __i3};
+}
+
+/// Initializes the 16-bit values in a 128-bit vector of [8 x i16] with
+///    the specified 16-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __w7
+///    A 16-bit integer value used to initialize bits [127:112] of the
+///    destination vector.
+/// \param __w6
+///    A 16-bit integer value used to initialize bits [111:96] of the
+///    destination vector.
+/// \param __w5
+///    A 16-bit integer value used to initialize bits [95:80] of the destination
+///    vector.
+/// \param __w4
+///    A 16-bit integer value used to initialize bits [79:64] of the destination
+///    vector.
+/// \param __w3
+///    A 16-bit integer value used to initialize bits [63:48] of the destination
+///    vector.
+/// \param __w2
+///    A 16-bit integer value used to initialize bits [47:32] of the destination
+///    vector.
+/// \param __w1
+///    A 16-bit integer value used to initialize bits [31:16] of the destination
+///    vector.
+/// \param __w0
+///    A 16-bit integer value used to initialize bits [15:0] of the destination
+///    vector.
+/// \returns An initialized 128-bit vector of [8 x i16] containing the values
+///    provided in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_set_epi16(short __w7, short __w6, short __w5, short __w4, short __w3,
+              short __w2, short __w1, short __w0) {
+  return __extension__(__m128i)(__v8hi){__w0, __w1, __w2, __w3,
+                                        __w4, __w5, __w6, __w7};
+}
+
+/// Initializes the 8-bit values in a 128-bit vector of [16 x i8] with
+///    the specified 8-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __b15
+///    Initializes bits [127:120] of the destination vector.
+/// \param __b14
+///    Initializes bits [119:112] of the destination vector.
+/// \param __b13
+///    Initializes bits [111:104] of the destination vector.
+/// \param __b12
+///    Initializes bits [103:96] of the destination vector.
+/// \param __b11
+///    Initializes bits [95:88] of the destination vector.
+/// \param __b10
+///    Initializes bits [87:80] of the destination vector.
+/// \param __b9
+///    Initializes bits [79:72] of the destination vector.
+/// \param __b8
+///    Initializes bits [71:64] of the destination vector.
+/// \param __b7
+///    Initializes bits [63:56] of the destination vector.
+/// \param __b6
+///    Initializes bits [55:48] of the destination vector.
+/// \param __b5
+///    Initializes bits [47:40] of the destination vector.
+/// \param __b4
+///    Initializes bits [39:32] of the destination vector.
+/// \param __b3
+///    Initializes bits [31:24] of the destination vector.
+/// \param __b2
+///    Initializes bits [23:16] of the destination vector.
+/// \param __b1
+///    Initializes bits [15:8] of the destination vector.
+/// \param __b0
+///    Initializes bits [7:0] of the destination vector.
+/// \returns An initialized 128-bit vector of [16 x i8] containing the values
+///    provided in the operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_set_epi8(char __b15, char __b14, char __b13, char __b12, char __b11,
+             char __b10, char __b9, char __b8, char __b7, char __b6, char __b5,
+             char __b4, char __b3, char __b2, char __b1, char __b0) {
+  return __extension__(__m128i)(__v16qi){
+      __b0, __b1, __b2,  __b3,  __b4,  __b5,  __b6,  __b7,
+      __b8, __b9, __b10, __b11, __b12, __b13, __b14, __b15};
+}
+
+/// Initializes both values in a 128-bit integer vector with the
+///    specified 64-bit integer value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __q
+///    Integer value used to initialize the elements of the destination integer
+///    vector.
+/// \returns An initialized 128-bit integer vector of [2 x i64] with both
+///    elements containing the value provided in the operand.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set1_epi64x(long long __q) {
+  return _mm_set_epi64x(__q, __q);
+}
+
+/// Initializes both values in a 128-bit vector of [2 x i64] with the
+///    specified 64-bit value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __q
+///    A 64-bit value used to initialize the elements of the destination integer
+///    vector.
+/// \returns An initialized 128-bit vector of [2 x i64] with all elements
+///    containing the value provided in the operand.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set1_epi64(__m64 __q) {
+  return _mm_set_epi64(__q, __q);
+}
+
+/// Initializes all values in a 128-bit vector of [4 x i32] with the
+///    specified 32-bit value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __i
+///    A 32-bit value used to initialize the elements of the destination integer
+///    vector.
+/// \returns An initialized 128-bit vector of [4 x i32] with all elements
+///    containing the value provided in the operand.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set1_epi32(int __i) {
+  return _mm_set_epi32(__i, __i, __i, __i);
+}
+
+/// Initializes all values in a 128-bit vector of [8 x i16] with the
+///    specified 16-bit value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __w
+///    A 16-bit value used to initialize the elements of the destination integer
+///    vector.
+/// \returns An initialized 128-bit vector of [8 x i16] with all elements
+///    containing the value provided in the operand.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set1_epi16(short __w) {
+  return _mm_set_epi16(__w, __w, __w, __w, __w, __w, __w, __w);
+}
+
+/// Initializes all values in a 128-bit vector of [16 x i8] with the
+///    specified 8-bit value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __b
+///    An 8-bit value used to initialize the elements of the destination integer
+///    vector.
+/// \returns An initialized 128-bit vector of [16 x i8] with all elements
+///    containing the value provided in the operand.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_set1_epi8(char __b) {
+  return _mm_set_epi8(__b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b,
+                      __b, __b, __b, __b, __b);
+}
+
+/// Constructs a 128-bit integer vector, initialized in reverse order
+///     with the specified 64-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic does not correspond to a specific instruction.
+///
+/// \param __q0
+///    A 64-bit integral value used to initialize the lower 64 bits of the
+///    result.
+/// \param __q1
+///    A 64-bit integral value used to initialize the upper 64 bits of the
+///    result.
+/// \returns An initialized 128-bit integer vector.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_setr_epi64(__m64 __q0,
+                                                            __m64 __q1) {
+  return _mm_set_epi64(__q1, __q0);
+}
+
+/// Constructs a 128-bit integer vector, initialized in reverse order
+///     with the specified 32-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __i0
+///    A 32-bit integral value used to initialize bits [31:0] of the result.
+/// \param __i1
+///    A 32-bit integral value used to initialize bits [63:32] of the result.
+/// \param __i2
+///    A 32-bit integral value used to initialize bits [95:64] of the result.
+/// \param __i3
+///    A 32-bit integral value used to initialize bits [127:96] of the result.
+/// \returns An initialized 128-bit integer vector.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_setr_epi32(int __i0, int __i1,
+                                                            int __i2,
+                                                            int __i3) {
+  return _mm_set_epi32(__i3, __i2, __i1, __i0);
+}
+
+/// Constructs a 128-bit integer vector, initialized in reverse order
+///     with the specified 16-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __w0
+///    A 16-bit integral value used to initialize bits [15:0] of the result.
+/// \param __w1
+///    A 16-bit integral value used to initialize bits [31:16] of the result.
+/// \param __w2
+///    A 16-bit integral value used to initialize bits [47:32] of the result.
+/// \param __w3
+///    A 16-bit integral value used to initialize bits [63:48] of the result.
+/// \param __w4
+///    A 16-bit integral value used to initialize bits [79:64] of the result.
+/// \param __w5
+///    A 16-bit integral value used to initialize bits [95:80] of the result.
+/// \param __w6
+///    A 16-bit integral value used to initialize bits [111:96] of the result.
+/// \param __w7
+///    A 16-bit integral value used to initialize bits [127:112] of the result.
+/// \returns An initialized 128-bit integer vector.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_setr_epi16(short __w0, short __w1, short __w2, short __w3, short __w4,
+               short __w5, short __w6, short __w7) {
+  return _mm_set_epi16(__w7, __w6, __w5, __w4, __w3, __w2, __w1, __w0);
+}
+
+/// Constructs a 128-bit integer vector, initialized in reverse order
+///     with the specified 8-bit integral values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __b0
+///    An 8-bit integral value used to initialize bits [7:0] of the result.
+/// \param __b1
+///    An 8-bit integral value used to initialize bits [15:8] of the result.
+/// \param __b2
+///    An 8-bit integral value used to initialize bits [23:16] of the result.
+/// \param __b3
+///    An 8-bit integral value used to initialize bits [31:24] of the result.
+/// \param __b4
+///    An 8-bit integral value used to initialize bits [39:32] of the result.
+/// \param __b5
+///    An 8-bit integral value used to initialize bits [47:40] of the result.
+/// \param __b6
+///    An 8-bit integral value used to initialize bits [55:48] of the result.
+/// \param __b7
+///    An 8-bit integral value used to initialize bits [63:56] of the result.
+/// \param __b8
+///    An 8-bit integral value used to initialize bits [71:64] of the result.
+/// \param __b9
+///    An 8-bit integral value used to initialize bits [79:72] of the result.
+/// \param __b10
+///    An 8-bit integral value used to initialize bits [87:80] of the result.
+/// \param __b11
+///    An 8-bit integral value used to initialize bits [95:88] of the result.
+/// \param __b12
+///    An 8-bit integral value used to initialize bits [103:96] of the result.
+/// \param __b13
+///    An 8-bit integral value used to initialize bits [111:104] of the result.
+/// \param __b14
+///    An 8-bit integral value used to initialize bits [119:112] of the result.
+/// \param __b15
+///    An 8-bit integral value used to initialize bits [127:120] of the result.
+/// \returns An initialized 128-bit integer vector.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_setr_epi8(char __b0, char __b1, char __b2, char __b3, char __b4, char __b5,
+              char __b6, char __b7, char __b8, char __b9, char __b10,
+              char __b11, char __b12, char __b13, char __b14, char __b15) {
+  return _mm_set_epi8(__b15, __b14, __b13, __b12, __b11, __b10, __b9, __b8,
+                      __b7, __b6, __b5, __b4, __b3, __b2, __b1, __b0);
+}
+
+/// Creates a 128-bit integer vector initialized to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VXORPS / XORPS </c> instruction.
+///
+/// \returns An initialized 128-bit integer vector with all elements set to
+///    zero.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_setzero_si128(void) {
+  return __extension__(__m128i)(__v2di){0LL, 0LL};
+}
+
+/// Stores a 128-bit integer vector to a memory location aligned on a
+///    128-bit boundary.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPS / MOVAPS </c> instruction.
+///
+/// \param __p
+///    A pointer to an aligned memory location that will receive the integer
+///    values.
+/// \param __b
+///    A 128-bit integer vector containing the values to be moved.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_store_si128(__m128i *__p,
+                                                          __m128i __b) {
+  *__p = __b;
+}
+
+/// Stores a 128-bit integer vector to an unaligned memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVUPS / MOVUPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that will receive the integer values.
+/// \param __b
+///    A 128-bit integer vector containing the values to be moved.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_storeu_si128(__m128i_u *__p,
+                                                           __m128i __b) {
+  struct __storeu_si128 {
+    __m128i_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_si128 *)__p)->__v = __b;
+}
+
+/// Stores a 64-bit integer value from the low element of a 128-bit integer
+///    vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVQ / MOVQ </c> instruction.
+///
+/// \param __p
+///    A pointer to a 64-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \param __b
+///    A 128-bit integer vector containing the value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_storeu_si64(void *__p,
+                                                          __m128i __b) {
+  struct __storeu_si64 {
+    long long __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_si64 *)__p)->__v = ((__v2di)__b)[0];
+}
+
+/// Stores a 32-bit integer value from the low element of a 128-bit integer
+///    vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVD / MOVD </c> instruction.
+///
+/// \param __p
+///    A pointer to a 32-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \param __b
+///    A 128-bit integer vector containing the value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_storeu_si32(void *__p,
+                                                          __m128i __b) {
+  struct __storeu_si32 {
+    int __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_si32 *)__p)->__v = ((__v4si)__b)[0];
+}
+
+/// Stores a 16-bit integer value from the low element of a 128-bit integer
+///    vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic does not correspond to a specific instruction.
+///
+/// \param __p
+///    A pointer to a 16-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \param __b
+///    A 128-bit integer vector containing the value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_storeu_si16(void *__p,
+                                                          __m128i __b) {
+  struct __storeu_si16 {
+    short __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_si16 *)__p)->__v = ((__v8hi)__b)[0];
+}
+
+/// Moves bytes selected by the mask from the first operand to the
+///    specified unaligned memory location. When a mask bit is 1, the
+///    corresponding byte is written, otherwise it is not written.
+///
+///    To minimize caching, the data is flagged as non-temporal (unlikely to be
+///    used again soon). Exception and trap behavior for elements not selected
+///    for storage to memory are implementation dependent.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMASKMOVDQU / MASKMOVDQU </c>
+///   instruction.
+///
+/// \param __d
+///    A 128-bit integer vector containing the values to be moved.
+/// \param __n
+///    A 128-bit integer vector containing the mask. The most significant bit of
+///    each byte represents the mask bits.
+/// \param __p
+///    A pointer to an unaligned 128-bit memory location where the specified
+///    values are moved.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_maskmoveu_si128(__m128i __d,
+                                                              __m128i __n,
+                                                              char *__p) {
+  __builtin_ia32_maskmovdqu((__v16qi)__d, (__v16qi)__n, __p);
+}
+
+/// Stores the lower 64 bits of a 128-bit integer vector of [2 x i64] to
+///    a memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVLPS / MOVLPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a 64-bit memory location that will receive the lower 64 bits
+///    of the integer vector parameter.
+/// \param __a
+///    A 128-bit integer vector of [2 x i64]. The lower 64 bits contain the
+///    value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_storel_epi64(__m128i_u *__p,
+                                                           __m128i __a) {
+  struct __mm_storel_epi64_struct {
+    long long __u;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __mm_storel_epi64_struct *)__p)->__u = __a[0];
+}
+
+/// Stores a 128-bit floating point vector of [2 x double] to a 128-bit
+///    aligned memory location.
+///
+///    To minimize caching, the data is flagged as non-temporal (unlikely to be
+///    used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVNTPS / MOVNTPS </c> instruction.
+///
+/// \param __p
+///    A pointer to the 128-bit aligned memory location used to store the value.
+/// \param __a
+///    A vector of [2 x double] containing the 64-bit values to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_pd(void *__p,
+                                                        __m128d __a) {
+  __builtin_nontemporal_store((__v2df)__a, (__v2df *)__p);
+}
+
+/// Stores a 128-bit integer vector to a 128-bit aligned memory location.
+///
+///    To minimize caching, the data is flagged as non-temporal (unlikely to be
+///    used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVNTPS / MOVNTPS </c> instruction.
+///
+/// \param __p
+///    A pointer to the 128-bit aligned memory location used to store the value.
+/// \param __a
+///    A 128-bit integer vector containing the values to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS _mm_stream_si128(void *__p,
+                                                           __m128i __a) {
+  __builtin_nontemporal_store((__v2di)__a, (__v2di *)__p);
+}
+
+/// Stores a 32-bit integer value in the specified memory location.
+///
+///    To minimize caching, the data is flagged as non-temporal (unlikely to be
+///    used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVNTI </c> instruction.
+///
+/// \param __p
+///    A pointer to the 32-bit memory location used to store the value.
+/// \param __a
+///    A 32-bit integer containing the value to be stored.
+static __inline__ void
+    __attribute__((__always_inline__, __nodebug__, __target__("sse2")))
+    _mm_stream_si32(void *__p, int __a) {
+  __builtin_ia32_movnti((int *)__p, __a);
+}
+
+#ifdef __x86_64__
+/// Stores a 64-bit integer value in the specified memory location.
+///
+///    To minimize caching, the data is flagged as non-temporal (unlikely to be
+///    used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVNTIQ </c> instruction.
+///
+/// \param __p
+///    A pointer to the 64-bit memory location used to store the value.
+/// \param __a
+///    A 64-bit integer containing the value to be stored.
+static __inline__ void
+    __attribute__((__always_inline__, __nodebug__, __target__("sse2")))
+    _mm_stream_si64(void *__p, long long __a) {
+  __builtin_ia32_movnti64((long long *)__p, __a);
+}
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/// The cache line containing \a __p is flushed and invalidated from all
+///    caches in the coherency domain.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CLFLUSH </c> instruction.
+///
+/// \param __p
+///    A pointer to the memory location used to identify the cache line to be
+///    flushed.
+void _mm_clflush(void const *__p);
+
+/// Forces strong memory ordering (serialization) between load
+///    instructions preceding this instruction and load instructions following
+///    this instruction, ensuring the system completes all previous loads before
+///    executing subsequent loads.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> LFENCE </c> instruction.
+///
+void _mm_lfence(void);
+
+/// Forces strong memory ordering (serialization) between load and store
+///    instructions preceding this instruction and load and store instructions
+///    following this instruction, ensuring that the system completes all
+///    previous memory accesses before executing subsequent memory accesses.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MFENCE </c> instruction.
+///
+void _mm_mfence(void);
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+/// Converts, with saturation, 16-bit signed integers from both 128-bit integer
+///    vector operands into 8-bit signed integers, and packs the results into
+///    the destination.
+///
+///    Positive values greater than 0x7F are saturated to 0x7F. Negative values
+///    less than 0x80 are saturated to 0x80.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPACKSSWB / PACKSSWB </c> instruction.
+///
+/// \param __a
+///   A 128-bit integer vector of [8 x i16]. The converted [8 x i8] values are
+///   written to the lower 64 bits of the result.
+/// \param __b
+///   A 128-bit integer vector of [8 x i16]. The converted [8 x i8] values are
+///   written to the higher 64 bits of the result.
+/// \returns A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packs_epi16(__m128i __a,
+                                                             __m128i __b) {
+  return (__m128i)__builtin_ia32_packsswb128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Converts, with saturation, 32-bit signed integers from both 128-bit integer
+///    vector operands into 16-bit signed integers, and packs the results into
+///    the destination.
+///
+///    Positive values greater than 0x7FFF are saturated to 0x7FFF. Negative
+///    values less than 0x8000 are saturated to 0x8000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPACKSSDW / PACKSSDW </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector of [4 x i32]. The converted [4 x i16] values
+///    are written to the lower 64 bits of the result.
+/// \param __b
+///    A 128-bit integer vector of [4 x i32]. The converted [4 x i16] values
+///    are written to the higher 64 bits of the result.
+/// \returns A 128-bit vector of [8 x i16] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packs_epi32(__m128i __a,
+                                                             __m128i __b) {
+  return (__m128i)__builtin_ia32_packssdw128((__v4si)__a, (__v4si)__b);
+}
+
+/// Converts, with saturation, 16-bit signed integers from both 128-bit integer
+///    vector operands into 8-bit unsigned integers, and packs the results into
+///    the destination.
+///
+///    Values greater than 0xFF are saturated to 0xFF. Values less than 0x00
+///    are saturated to 0x00.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPACKUSWB / PACKUSWB </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector of [8 x i16]. The converted [8 x i8] values are
+///    written to the lower 64 bits of the result.
+/// \param __b
+///    A 128-bit integer vector of [8 x i16]. The converted [8 x i8] values are
+///    written to the higher 64 bits of the result.
+/// \returns A 128-bit vector of [16 x i8] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packus_epi16(__m128i __a,
+                                                              __m128i __b) {
+  return (__m128i)__builtin_ia32_packuswb128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Extracts 16 bits from a 128-bit integer vector of [8 x i16], using
+///    the immediate-value parameter as a selector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_extract_epi16(__m128i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPEXTRW / PEXTRW </c> instruction.
+///
+/// \param a
+///    A 128-bit integer vector.
+/// \param imm
+///    An immediate value. Bits [2:0] selects values from \a a to be assigned
+///    to bits[15:0] of the result. \n
+///    000: assign values from bits [15:0] of \a a. \n
+///    001: assign values from bits [31:16] of \a a. \n
+///    010: assign values from bits [47:32] of \a a. \n
+///    011: assign values from bits [63:48] of \a a. \n
+///    100: assign values from bits [79:64] of \a a. \n
+///    101: assign values from bits [95:80] of \a a. \n
+///    110: assign values from bits [111:96] of \a a. \n
+///    111: assign values from bits [127:112] of \a a.
+/// \returns An integer, whose lower 16 bits are selected from the 128-bit
+///    integer vector parameter and the remaining bits are assigned zeros.
+#define _mm_extract_epi16(a, imm)                                              \
+  ((int)(unsigned short)__builtin_ia32_vec_ext_v8hi((__v8hi)(__m128i)(a),      \
+                                                    (int)(imm)))
+
+/// Constructs a 128-bit integer vector by first making a copy of the
+///    128-bit integer vector parameter, and then inserting the lower 16 bits
+///    of an integer parameter into an offset specified by the immediate-value
+///    parameter.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_insert_epi16(__m128i a, int b, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPINSRW / PINSRW </c> instruction.
+///
+/// \param a
+///    A 128-bit integer vector of [8 x i16]. This vector is copied to the
+///    result and then one of the eight elements in the result is replaced by
+///    the lower 16 bits of \a b.
+/// \param b
+///    An integer. The lower 16 bits of this parameter are written to the
+///    result beginning at an offset specified by \a imm.
+/// \param imm
+///    An immediate value specifying the bit offset in the result at which the
+///    lower 16 bits of \a b are written.
+/// \returns A 128-bit integer vector containing the constructed values.
+#define _mm_insert_epi16(a, b, imm)                                            \
+  ((__m128i)__builtin_ia32_vec_set_v8hi((__v8hi)(__m128i)(a), (int)(b),        \
+                                        (int)(imm)))
+
+/// Copies the values of the most significant bits from each 8-bit
+///    element in a 128-bit integer vector of [16 x i8] to create a 16-bit mask
+///    value, zero-extends the value, and writes it to the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVMSKB / PMOVMSKB </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the values with bits to be extracted.
+/// \returns The most significant bits from each 8-bit element in \a __a,
+///    written to bits [15:0]. The other bits are assigned zeros.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_movemask_epi8(__m128i __a) {
+  return __builtin_ia32_pmovmskb128((__v16qi)__a);
+}
+
+/// Constructs a 128-bit integer vector by shuffling four 32-bit
+///    elements of a 128-bit integer vector parameter, using the immediate-value
+///    parameter as a specifier.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_shuffle_epi32(__m128i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPSHUFD / PSHUFD </c> instruction.
+///
+/// \param a
+///    A 128-bit integer vector containing the values to be copied.
+/// \param imm
+///    An immediate value containing an 8-bit value specifying which elements to
+///    copy from a. The destinations within the 128-bit destination are assigned
+///    values as follows: \n
+///    Bits [1:0] are used to assign values to bits [31:0] of the result. \n
+///    Bits [3:2] are used to assign values to bits [63:32] of the result. \n
+///    Bits [5:4] are used to assign values to bits [95:64] of the result. \n
+///    Bits [7:6] are used to assign values to bits [127:96] of the result. \n
+///    Bit value assignments: \n
+///    00: assign values from bits [31:0] of \a a. \n
+///    01: assign values from bits [63:32] of \a a. \n
+///    10: assign values from bits [95:64] of \a a. \n
+///    11: assign values from bits [127:96] of \a a. \n
+///    Note: To generate a mask, you can use the \c _MM_SHUFFLE macro.
+///    <c>_MM_SHUFFLE(b6, b4, b2, b0)</c> can create an 8-bit mask of the form
+///    <c>[b6, b4, b2, b0]</c>.
+/// \returns A 128-bit integer vector containing the shuffled values.
+#define _mm_shuffle_epi32(a, imm)                                              \
+  ((__m128i)__builtin_ia32_pshufd((__v4si)(__m128i)(a), (int)(imm)))
+
+/// Constructs a 128-bit integer vector by shuffling four lower 16-bit
+///    elements of a 128-bit integer vector of [8 x i16], using the immediate
+///    value parameter as a specifier.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_shufflelo_epi16(__m128i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPSHUFLW / PSHUFLW </c> instruction.
+///
+/// \param a
+///    A 128-bit integer vector of [8 x i16]. Bits [127:64] are copied to bits
+///    [127:64] of the result.
+/// \param imm
+///    An 8-bit immediate value specifying which elements to copy from \a a. \n
+///    Bits[1:0] are used to assign values to bits [15:0] of the result. \n
+///    Bits[3:2] are used to assign values to bits [31:16] of the result. \n
+///    Bits[5:4] are used to assign values to bits [47:32] of the result. \n
+///    Bits[7:6] are used to assign values to bits [63:48] of the result. \n
+///    Bit value assignments: \n
+///    00: assign values from bits [15:0] of \a a. \n
+///    01: assign values from bits [31:16] of \a a. \n
+///    10: assign values from bits [47:32] of \a a. \n
+///    11: assign values from bits [63:48] of \a a. \n
+///    Note: To generate a mask, you can use the \c _MM_SHUFFLE macro.
+///    <c>_MM_SHUFFLE(b6, b4, b2, b0)</c> can create an 8-bit mask of the form
+///    <c>[b6, b4, b2, b0]</c>.
+/// \returns A 128-bit integer vector containing the shuffled values.
+#define _mm_shufflelo_epi16(a, imm)                                            \
+  ((__m128i)__builtin_ia32_pshuflw((__v8hi)(__m128i)(a), (int)(imm)))
+
+/// Constructs a 128-bit integer vector by shuffling four upper 16-bit
+///    elements of a 128-bit integer vector of [8 x i16], using the immediate
+///    value parameter as a specifier.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_shufflehi_epi16(__m128i a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPSHUFHW / PSHUFHW </c> instruction.
+///
+/// \param a
+///    A 128-bit integer vector of [8 x i16]. Bits [63:0] are copied to bits
+///    [63:0] of the result.
+/// \param imm
+///    An 8-bit immediate value specifying which elements to copy from \a a. \n
+///    Bits[1:0] are used to assign values to bits [79:64] of the result. \n
+///    Bits[3:2] are used to assign values to bits [95:80] of the result. \n
+///    Bits[5:4] are used to assign values to bits [111:96] of the result. \n
+///    Bits[7:6] are used to assign values to bits [127:112] of the result. \n
+///    Bit value assignments: \n
+///    00: assign values from bits [79:64] of \a a. \n
+///    01: assign values from bits [95:80] of \a a. \n
+///    10: assign values from bits [111:96] of \a a. \n
+///    11: assign values from bits [127:112] of \a a. \n
+///    Note: To generate a mask, you can use the \c _MM_SHUFFLE macro.
+///    <c>_MM_SHUFFLE(b6, b4, b2, b0)</c> can create an 8-bit mask of the form
+///    <c>[b6, b4, b2, b0]</c>.
+/// \returns A 128-bit integer vector containing the shuffled values.
+#define _mm_shufflehi_epi16(a, imm)                                            \
+  ((__m128i)__builtin_ia32_pshufhw((__v8hi)(__m128i)(a), (int)(imm)))
+
+/// Unpacks the high-order (index 8-15) values from two 128-bit vectors
+///    of [16 x i8] and interleaves them into a 128-bit vector of [16 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPUNPCKHBW / PUNPCKHBW </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [16 x i8].
+///    Bits [71:64] are written to bits [7:0] of the result. \n
+///    Bits [79:72] are written to bits [23:16] of the result. \n
+///    Bits [87:80] are written to bits [39:32] of the result. \n
+///    Bits [95:88] are written to bits [55:48] of the result. \n
+///    Bits [103:96] are written to bits [71:64] of the result. \n
+///    Bits [111:104] are written to bits [87:80] of the result. \n
+///    Bits [119:112] are written to bits [103:96] of the result. \n
+///    Bits [127:120] are written to bits [119:112] of the result.
+/// \param __b
+///    A 128-bit vector of [16 x i8]. \n
+///    Bits [71:64] are written to bits [15:8] of the result. \n
+///    Bits [79:72] are written to bits [31:24] of the result. \n
+///    Bits [87:80] are written to bits [47:40] of the result. \n
+///    Bits [95:88] are written to bits [63:56] of the result. \n
+///    Bits [103:96] are written to bits [79:72] of the result. \n
+///    Bits [111:104] are written to bits [95:88] of the result. \n
+///    Bits [119:112] are written to bits [111:104] of the result. \n
+///    Bits [127:120] are written to bits [127:120] of the result.
+/// \returns A 128-bit vector of [16 x i8] containing the interleaved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_unpackhi_epi8(__m128i __a,
+                                                               __m128i __b) {
+  return (__m128i)__builtin_shufflevector(
+      (__v16qi)__a, (__v16qi)__b, 8, 16 + 8, 9, 16 + 9, 10, 16 + 10, 11,
+      16 + 11, 12, 16 + 12, 13, 16 + 13, 14, 16 + 14, 15, 16 + 15);
+}
+
+/// Unpacks the high-order (index 4-7) values from two 128-bit vectors of
+///    [8 x i16] and interleaves them into a 128-bit vector of [8 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPUNPCKHWD / PUNPCKHWD </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x i16].
+///    Bits [79:64] are written to bits [15:0] of the result. \n
+///    Bits [95:80] are written to bits [47:32] of the result. \n
+///    Bits [111:96] are written to bits [79:64] of the result. \n
+///    Bits [127:112] are written to bits [111:96] of the result.
+/// \param __b
+///    A 128-bit vector of [8 x i16].
+///    Bits [79:64] are written to bits [31:16] of the result. \n
+///    Bits [95:80] are written to bits [63:48] of the result. \n
+///    Bits [111:96] are written to bits [95:80] of the result. \n
+///    Bits [127:112] are written to bits [127:112] of the result.
+/// \returns A 128-bit vector of [8 x i16] containing the interleaved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_unpackhi_epi16(__m128i __a,
+                                                                __m128i __b) {
+  return (__m128i)__builtin_shufflevector((__v8hi)__a, (__v8hi)__b, 4, 8 + 4, 5,
+                                          8 + 5, 6, 8 + 6, 7, 8 + 7);
+}
+
+/// Unpacks the high-order (index 2,3) values from two 128-bit vectors of
+///    [4 x i32] and interleaves them into a 128-bit vector of [4 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPUNPCKHDQ / PUNPCKHDQ </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x i32]. \n
+///    Bits [95:64] are written to bits [31:0] of the destination. \n
+///    Bits [127:96] are written to bits [95:64] of the destination.
+/// \param __b
+///    A 128-bit vector of [4 x i32]. \n
+///    Bits [95:64] are written to bits [64:32] of the destination. \n
+///    Bits [127:96] are written to bits [127:96] of the destination.
+/// \returns A 128-bit vector of [4 x i32] containing the interleaved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_unpackhi_epi32(__m128i __a,
+                                                                __m128i __b) {
+  return (__m128i)__builtin_shufflevector((__v4si)__a, (__v4si)__b, 2, 4 + 2, 3,
+                                          4 + 3);
+}
+
+/// Unpacks the high-order 64-bit elements from two 128-bit vectors of
+///    [2 x i64] and interleaves them into a 128-bit vector of [2 x i64].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPUNPCKHQDQ / PUNPCKHQDQ </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x i64]. \n
+///    Bits [127:64] are written to bits [63:0] of the destination.
+/// \param __b
+///    A 128-bit vector of [2 x i64]. \n
+///    Bits [127:64] are written to bits [127:64] of the destination.
+/// \returns A 128-bit vector of [2 x i64] containing the interleaved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_unpackhi_epi64(__m128i __a,
+                                                                __m128i __b) {
+  return (__m128i)__builtin_shufflevector((__v2di)__a, (__v2di)__b, 1, 2 + 1);
+}
+
+/// Unpacks the low-order (index 0-7) values from two 128-bit vectors of
+///    [16 x i8] and interleaves them into a 128-bit vector of [16 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPUNPCKLBW / PUNPCKLBW </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [16 x i8]. \n
+///    Bits [7:0] are written to bits [7:0] of the result. \n
+///    Bits [15:8] are written to bits [23:16] of the result. \n
+///    Bits [23:16] are written to bits [39:32] of the result. \n
+///    Bits [31:24] are written to bits [55:48] of the result. \n
+///    Bits [39:32] are written to bits [71:64] of the result. \n
+///    Bits [47:40] are written to bits [87:80] of the result. \n
+///    Bits [55:48] are written to bits [103:96] of the result. \n
+///    Bits [63:56] are written to bits [119:112] of the result.
+/// \param __b
+///    A 128-bit vector of [16 x i8].
+///    Bits [7:0] are written to bits [15:8] of the result. \n
+///    Bits [15:8] are written to bits [31:24] of the result. \n
+///    Bits [23:16] are written to bits [47:40] of the result. \n
+///    Bits [31:24] are written to bits [63:56] of the result. \n
+///    Bits [39:32] are written to bits [79:72] of the result. \n
+///    Bits [47:40] are written to bits [95:88] of the result. \n
+///    Bits [55:48] are written to bits [111:104] of the result. \n
+///    Bits [63:56] are written to bits [127:120] of the result.
+/// \returns A 128-bit vector of [16 x i8] containing the interleaved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_unpacklo_epi8(__m128i __a,
+                                                               __m128i __b) {
+  return (__m128i)__builtin_shufflevector(
+      (__v16qi)__a, (__v16qi)__b, 0, 16 + 0, 1, 16 + 1, 2, 16 + 2, 3, 16 + 3, 4,
+      16 + 4, 5, 16 + 5, 6, 16 + 6, 7, 16 + 7);
+}
+
+/// Unpacks the low-order (index 0-3) values from each of the two 128-bit
+///    vectors of [8 x i16] and interleaves them into a 128-bit vector of
+///    [8 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPUNPCKLWD / PUNPCKLWD </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x i16].
+///    Bits [15:0] are written to bits [15:0] of the result. \n
+///    Bits [31:16] are written to bits [47:32] of the result. \n
+///    Bits [47:32] are written to bits [79:64] of the result. \n
+///    Bits [63:48] are written to bits [111:96] of the result.
+/// \param __b
+///    A 128-bit vector of [8 x i16].
+///    Bits [15:0] are written to bits [31:16] of the result. \n
+///    Bits [31:16] are written to bits [63:48] of the result. \n
+///    Bits [47:32] are written to bits [95:80] of the result. \n
+///    Bits [63:48] are written to bits [127:112] of the result.
+/// \returns A 128-bit vector of [8 x i16] containing the interleaved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_unpacklo_epi16(__m128i __a,
+                                                                __m128i __b) {
+  return (__m128i)__builtin_shufflevector((__v8hi)__a, (__v8hi)__b, 0, 8 + 0, 1,
+                                          8 + 1, 2, 8 + 2, 3, 8 + 3);
+}
+
+/// Unpacks the low-order (index 0,1) values from two 128-bit vectors of
+///    [4 x i32] and interleaves them into a 128-bit vector of [4 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPUNPCKLDQ / PUNPCKLDQ </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x i32]. \n
+///    Bits [31:0] are written to bits [31:0] of the destination. \n
+///    Bits [63:32] are written to bits [95:64] of the destination.
+/// \param __b
+///    A 128-bit vector of [4 x i32]. \n
+///    Bits [31:0] are written to bits [64:32] of the destination. \n
+///    Bits [63:32] are written to bits [127:96] of the destination.
+/// \returns A 128-bit vector of [4 x i32] containing the interleaved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_unpacklo_epi32(__m128i __a,
+                                                                __m128i __b) {
+  return (__m128i)__builtin_shufflevector((__v4si)__a, (__v4si)__b, 0, 4 + 0, 1,
+                                          4 + 1);
+}
+
+/// Unpacks the low-order 64-bit elements from two 128-bit vectors of
+///    [2 x i64] and interleaves them into a 128-bit vector of [2 x i64].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPUNPCKLQDQ / PUNPCKLQDQ </c>
+///   instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x i64]. \n
+///    Bits [63:0] are written to bits [63:0] of the destination. \n
+/// \param __b
+///    A 128-bit vector of [2 x i64]. \n
+///    Bits [63:0] are written to bits [127:64] of the destination. \n
+/// \returns A 128-bit vector of [2 x i64] containing the interleaved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_unpacklo_epi64(__m128i __a,
+                                                                __m128i __b) {
+  return (__m128i)__builtin_shufflevector((__v2di)__a, (__v2di)__b, 0, 2 + 0);
+}
+
+/// Returns the lower 64 bits of a 128-bit integer vector as a 64-bit
+///    integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVDQ2Q </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector operand. The lower 64 bits are moved to the
+///    destination.
+/// \returns A 64-bit integer containing the lower 64 bits of the parameter.
+static __inline__ __m64 __DEFAULT_FN_ATTRS _mm_movepi64_pi64(__m128i __a) {
+  return (__m64)__a[0];
+}
+
+/// Moves the 64-bit operand to a 128-bit integer vector, zeroing the
+///    upper bits.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVD+VMOVQ </c> instruction.
+///
+/// \param __a
+///    A 64-bit value.
+/// \returns A 128-bit integer vector. The lower 64 bits contain the value from
+///    the operand. The upper 64 bits are assigned zeros.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_movpi64_epi64(__m64 __a) {
+  return __extension__(__m128i)(__v2di){(long long)__a, 0};
+}
+
+/// Moves the lower 64 bits of a 128-bit integer vector to a 128-bit
+///    integer vector, zeroing the upper bits.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVQ / MOVQ </c> instruction.
+///
+/// \param __a
+///    A 128-bit integer vector operand. The lower 64 bits are moved to the
+///    destination.
+/// \returns A 128-bit integer vector. The lower 64 bits contain the value from
+///    the operand. The upper 64 bits are assigned zeros.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_move_epi64(__m128i __a) {
+  return __builtin_shufflevector((__v2di)__a, _mm_setzero_si128(), 0, 2);
+}
+
+/// Unpacks the high-order 64-bit elements from two 128-bit vectors of
+///    [2 x double] and interleaves them into a 128-bit vector of [2 x
+///    double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKHPD / UNPCKHPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. \n
+///    Bits [127:64] are written to bits [63:0] of the destination.
+/// \param __b
+///    A 128-bit vector of [2 x double]. \n
+///    Bits [127:64] are written to bits [127:64] of the destination.
+/// \returns A 128-bit vector of [2 x double] containing the interleaved values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_unpackhi_pd(__m128d __a,
+                                                             __m128d __b) {
+  return __builtin_shufflevector((__v2df)__a, (__v2df)__b, 1, 2 + 1);
+}
+
+/// Unpacks the low-order 64-bit elements from two 128-bit vectors
+///    of [2 x double] and interleaves them into a 128-bit vector of [2 x
+///    double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKLPD / UNPCKLPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. \n
+///    Bits [63:0] are written to bits [63:0] of the destination.
+/// \param __b
+///    A 128-bit vector of [2 x double]. \n
+///    Bits [63:0] are written to bits [127:64] of the destination.
+/// \returns A 128-bit vector of [2 x double] containing the interleaved values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_unpacklo_pd(__m128d __a,
+                                                             __m128d __b) {
+  return __builtin_shufflevector((__v2df)__a, (__v2df)__b, 0, 2 + 0);
+}
+
+/// Extracts the sign bits of the double-precision values in the 128-bit
+///    vector of [2 x double], zero-extends the value, and writes it to the
+///    low-order bits of the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVMSKPD / MOVMSKPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the values with sign bits to
+///    be extracted.
+/// \returns The sign bits from each of the double-precision elements in \a __a,
+///    written to bits [1:0]. The remaining bits are assigned values of zero.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_movemask_pd(__m128d __a) {
+  return __builtin_ia32_movmskpd((__v2df)__a);
+}
+
+/// Constructs a 128-bit floating-point vector of [2 x double] from two
+///    128-bit vector parameters of [2 x double], using the immediate-value
+///     parameter as a specifier.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_shuffle_pd(__m128d a, __m128d b, const int i);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VSHUFPD / SHUFPD </c> instruction.
+///
+/// \param a
+///    A 128-bit vector of [2 x double].
+/// \param b
+///    A 128-bit vector of [2 x double].
+/// \param i
+///    An 8-bit immediate value. The least significant two bits specify which
+///    elements to copy from \a a and \a b: \n
+///    Bit[0] = 0: lower element of \a a copied to lower element of result. \n
+///    Bit[0] = 1: upper element of \a a copied to lower element of result. \n
+///    Bit[1] = 0: lower element of \a b copied to upper element of result. \n
+///    Bit[1] = 1: upper element of \a b copied to upper element of result. \n
+///    Note: To generate a mask, you can use the \c _MM_SHUFFLE2 macro.
+///    <c>_MM_SHUFFLE2(b1, b0)</c> can create a 2-bit mask of the form
+///    <c>[b1, b0]</c>.
+/// \returns A 128-bit vector of [2 x double] containing the shuffled values.
+#define _mm_shuffle_pd(a, b, i)                                                \
+  ((__m128d)__builtin_ia32_shufpd((__v2df)(__m128d)(a), (__v2df)(__m128d)(b),  \
+                                  (int)(i)))
+
+/// Casts a 128-bit floating-point vector of [2 x double] into a 128-bit
+///    floating-point vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit floating-point vector of [2 x double].
+/// \returns A 128-bit floating-point vector of [4 x float] containing the same
+///    bitwise pattern as the parameter.
+static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_castpd_ps(__m128d __a) {
+  return (__m128)__a;
+}
+
+/// Casts a 128-bit floating-point vector of [2 x double] into a 128-bit
+///    integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit floating-point vector of [2 x double].
+/// \returns A 128-bit integer vector containing the same bitwise pattern as the
+///    parameter.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_castpd_si128(__m128d __a) {
+  return (__m128i)__a;
+}
+
+/// Casts a 128-bit floating-point vector of [4 x float] into a 128-bit
+///    floating-point vector of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit floating-point vector of [4 x float].
+/// \returns A 128-bit floating-point vector of [2 x double] containing the same
+///    bitwise pattern as the parameter.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_castps_pd(__m128 __a) {
+  return (__m128d)__a;
+}
+
+/// Casts a 128-bit floating-point vector of [4 x float] into a 128-bit
+///    integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit floating-point vector of [4 x float].
+/// \returns A 128-bit integer vector containing the same bitwise pattern as the
+///    parameter.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_castps_si128(__m128 __a) {
+  return (__m128i)__a;
+}
+
+/// Casts a 128-bit integer vector into a 128-bit floating-point vector
+///    of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \returns A 128-bit floating-point vector of [4 x float] containing the same
+///    bitwise pattern as the parameter.
+static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_castsi128_ps(__m128i __a) {
+  return (__m128)__a;
+}
+
+/// Casts a 128-bit integer vector into a 128-bit floating-point vector
+///    of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit integer vector.
+/// \returns A 128-bit floating-point vector of [2 x double] containing the same
+///    bitwise pattern as the parameter.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_castsi128_pd(__m128i __a) {
+  return (__m128d)__a;
+}
+
+/// Compares each of the corresponding double-precision values of two
+///    128-bit vectors of [2 x double], using the operation specified by the
+///    immediate integer operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, comparisons that are ordered
+///    return false, and comparisons that are unordered return true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_cmp_pd(__m128d a, __m128d b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> (V)CMPPD </c> instruction.
+///
+/// \param a
+///    A 128-bit vector of [2 x double].
+/// \param b
+///    A 128-bit vector of [2 x double].
+/// \param c
+///    An immediate integer operand, with bits [4:0] specifying which comparison
+///    operation to use: \n
+///    0x00: Equal (ordered, non-signaling) \n
+///    0x01: Less-than (ordered, signaling) \n
+///    0x02: Less-than-or-equal (ordered, signaling) \n
+///    0x03: Unordered (non-signaling) \n
+///    0x04: Not-equal (unordered, non-signaling) \n
+///    0x05: Not-less-than (unordered, signaling) \n
+///    0x06: Not-less-than-or-equal (unordered, signaling) \n
+///    0x07: Ordered (non-signaling) \n
+/// \returns A 128-bit vector of [2 x double] containing the comparison results.
+#define _mm_cmp_pd(a, b, c)                                                    \
+  ((__m128d)__builtin_ia32_cmppd((__v2df)(__m128d)(a), (__v2df)(__m128d)(b),   \
+                                 (c)))
+
+/// Compares each of the corresponding scalar double-precision values of
+///    two 128-bit vectors of [2 x double], using the operation specified by the
+///    immediate integer operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, comparisons that are ordered
+///    return false, and comparisons that are unordered return true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_cmp_sd(__m128d a, __m128d b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> (V)CMPSD </c> instruction.
+///
+/// \param a
+///    A 128-bit vector of [2 x double].
+/// \param b
+///    A 128-bit vector of [2 x double].
+/// \param c
+///    An immediate integer operand, with bits [4:0] specifying which comparison
+///    operation to use: \n
+///    0x00: Equal (ordered, non-signaling) \n
+///    0x01: Less-than (ordered, signaling) \n
+///    0x02: Less-than-or-equal (ordered, signaling) \n
+///    0x03: Unordered (non-signaling) \n
+///    0x04: Not-equal (unordered, non-signaling) \n
+///    0x05: Not-less-than (unordered, signaling) \n
+///    0x06: Not-less-than-or-equal (unordered, signaling) \n
+///    0x07: Ordered (non-signaling) \n
+/// \returns A 128-bit vector of [2 x double] containing the comparison results.
+#define _mm_cmp_sd(a, b, c)                                                    \
+  ((__m128d)__builtin_ia32_cmpsd((__v2df)(__m128d)(a), (__v2df)(__m128d)(b),   \
+                                 (c)))
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/// Indicates that a spin loop is being executed for the purposes of
+///    optimizing power consumption during the loop.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PAUSE </c> instruction.
+///
+void _mm_pause(void);
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+#undef __DEFAULT_FN_ATTRS
+#undef __DEFAULT_FN_ATTRS_MMX
+
+#define _MM_SHUFFLE2(x, y) (((x) << 1) | (y))
+
+#define _MM_DENORMALS_ZERO_ON (0x0040U)
+#define _MM_DENORMALS_ZERO_OFF (0x0000U)
+
+#define _MM_DENORMALS_ZERO_MASK (0x0040U)
+
+#define _MM_GET_DENORMALS_ZERO_MODE() (_mm_getcsr() & _MM_DENORMALS_ZERO_MASK)
+#define _MM_SET_DENORMALS_ZERO_MODE(x)                                         \
+  (_mm_setcsr((_mm_getcsr() & ~_MM_DENORMALS_ZERO_MASK) | (x)))
+
+#endif /* __EMMINTRIN_H */
diff --git a/third_party/intel/clang/enqcmdintrin.h b/third_party/intel/clang/enqcmdintrin.h
new file mode 100644
index 000000000..30af67f6b
--- /dev/null
+++ b/third_party/intel/clang/enqcmdintrin.h
@@ -0,0 +1,63 @@
+/*===------------------ enqcmdintrin.h - enqcmd intrinsics -----------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <enqcmdintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __ENQCMDINTRIN_H
+#define __ENQCMDINTRIN_H
+
+/* Define the default attributes for the functions in this file */
+#define _DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__, __target__("enqcmd")))
+
+/// Reads 64-byte command pointed by \a __src, formats 64-byte enqueue store
+///    data, and performs 64-byte enqueue store to memory pointed by \a __dst.
+///    This intrinsics may only be used in User mode.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsics corresponds to the <c> ENQCMD </c> instruction.
+///
+/// \param __dst
+///    Pointer to the destination of the enqueue store.
+/// \param __src
+///    Pointer to 64-byte command data.
+/// \returns If the command data is successfully written to \a __dst then 0 is
+///    returned. Otherwise 1 is returned.
+static __inline__ int _DEFAULT_FN_ATTRS
+_enqcmd (void *__dst, const void *__src)
+{
+  return __builtin_ia32_enqcmd(__dst, __src);
+}
+
+/// Reads 64-byte command pointed by \a __src, formats 64-byte enqueue store
+///    data, and performs 64-byte enqueue store to memory pointed by \a __dst
+///    This intrinsic may only be used in Privileged mode.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsics corresponds to the <c> ENQCMDS </c> instruction.
+///
+/// \param __dst
+///    Pointer to the destination of the enqueue store.
+/// \param __src
+///    Pointer to 64-byte command data.
+/// \returns If the command data is successfully written to \a __dst then 0 is
+///    returned. Otherwise 1 is returned.
+static __inline__ int _DEFAULT_FN_ATTRS
+_enqcmds (void *__dst, const void *__src)
+{
+  return __builtin_ia32_enqcmds(__dst, __src);
+}
+
+#undef _DEFAULT_FN_ATTRS
+
+#endif /* __ENQCMDINTRIN_H */
diff --git a/third_party/intel/clang/f16cintrin.h b/third_party/intel/clang/f16cintrin.h
new file mode 100644
index 000000000..94a662c1d
--- /dev/null
+++ b/third_party/intel/clang/f16cintrin.h
@@ -0,0 +1,162 @@
+/*===---- f16cintrin.h - F16C intrinsics -----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined __IMMINTRIN_H
+#error "Never use <f16cintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __F16CINTRIN_H
+#define __F16CINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128 \
+  __attribute__((__always_inline__, __nodebug__, __target__("f16c"), __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256 \
+  __attribute__((__always_inline__, __nodebug__, __target__("f16c"), __min_vector_width__(256)))
+
+/* NOTE: Intel documents the 128-bit versions of these as being in emmintrin.h,
+ * but that's because icc can emulate these without f16c using a library call.
+ * Since we don't do that let's leave these in f16cintrin.h.
+ */
+
+/// Converts a 16-bit half-precision float value into a 32-bit float
+///    value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPH2PS </c> instruction.
+///
+/// \param __a
+///    A 16-bit half-precision float value.
+/// \returns The converted 32-bit float value.
+static __inline float __DEFAULT_FN_ATTRS128
+_cvtsh_ss(unsigned short __a)
+{
+  __v8hi __v = {(short)__a, 0, 0, 0, 0, 0, 0, 0};
+  __v4sf __r = __builtin_ia32_vcvtph2ps(__v);
+  return __r[0];
+}
+
+/// Converts a 32-bit single-precision float value to a 16-bit
+///    half-precision float value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned short _cvtss_sh(float a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VCVTPS2PH </c> instruction.
+///
+/// \param a
+///    A 32-bit single-precision float value to be converted to a 16-bit
+///    half-precision float value.
+/// \param imm
+///    An immediate value controlling rounding using bits [2:0]: \n
+///    000: Nearest \n
+///    001: Down \n
+///    010: Up \n
+///    011: Truncate \n
+///    1XX: Use MXCSR.RC for rounding
+/// \returns The converted 16-bit half-precision float value.
+#define _cvtss_sh(a, imm) __extension__ ({ \
+  (unsigned short)(((__v8hi)__builtin_ia32_vcvtps2ph((__v4sf){a, 0, 0, 0}, \
+                                                     (imm)))[0]); })
+
+/// Converts a 128-bit vector containing 32-bit float values into a
+///    128-bit vector containing 16-bit half-precision float values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_cvtps_ph(__m128 a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VCVTPS2PH </c> instruction.
+///
+/// \param a
+///    A 128-bit vector containing 32-bit float values.
+/// \param imm
+///    An immediate value controlling rounding using bits [2:0]: \n
+///    000: Nearest \n
+///    001: Down \n
+///    010: Up \n
+///    011: Truncate \n
+///    1XX: Use MXCSR.RC for rounding
+/// \returns A 128-bit vector containing converted 16-bit half-precision float
+///    values. The lower 64 bits are used to store the converted 16-bit
+///    half-precision floating-point values.
+#define _mm_cvtps_ph(a, imm) \
+  ((__m128i)__builtin_ia32_vcvtps2ph((__v4sf)(__m128)(a), (imm)))
+
+/// Converts a 128-bit vector containing 16-bit half-precision float
+///    values into a 128-bit vector containing 32-bit float values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPH2PS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector containing 16-bit half-precision float values. The lower
+///    64 bits are used in the conversion.
+/// \returns A 128-bit vector of [4 x float] containing converted float values.
+static __inline __m128 __DEFAULT_FN_ATTRS128
+_mm_cvtph_ps(__m128i __a)
+{
+  return (__m128)__builtin_ia32_vcvtph2ps((__v8hi)__a);
+}
+
+/// Converts a 256-bit vector of [8 x float] into a 128-bit vector
+///    containing 16-bit half-precision float values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm256_cvtps_ph(__m256 a, const int imm);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VCVTPS2PH </c> instruction.
+///
+/// \param a
+///    A 256-bit vector containing 32-bit single-precision float values to be
+///    converted to 16-bit half-precision float values.
+/// \param imm
+///    An immediate value controlling rounding using bits [2:0]: \n
+///    000: Nearest \n
+///    001: Down \n
+///    010: Up \n
+///    011: Truncate \n
+///    1XX: Use MXCSR.RC for rounding
+/// \returns A 128-bit vector containing the converted 16-bit half-precision
+///    float values.
+#define _mm256_cvtps_ph(a, imm) \
+ ((__m128i)__builtin_ia32_vcvtps2ph256((__v8sf)(__m256)(a), (imm)))
+
+/// Converts a 128-bit vector containing 16-bit half-precision float
+///    values into a 256-bit vector of [8 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTPH2PS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector containing 16-bit half-precision float values to be
+///    converted to 32-bit single-precision float values.
+/// \returns A vector of [8 x float] containing the converted 32-bit
+///    single-precision float values.
+static __inline __m256 __DEFAULT_FN_ATTRS256
+_mm256_cvtph_ps(__m128i __a)
+{
+  return (__m256)__builtin_ia32_vcvtph2ps256((__v8hi)__a);
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif /* __F16CINTRIN_H */
diff --git a/third_party/intel/clang/fma4intrin.h b/third_party/intel/clang/fma4intrin.h
new file mode 100644
index 000000000..7ff69d96d
--- /dev/null
+++ b/third_party/intel/clang/fma4intrin.h
@@ -0,0 +1,218 @@
+/*===---- fma4intrin.h - FMA4 intrinsics -----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __X86INTRIN_H
+#error "Never use <fma4intrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __FMA4INTRIN_H
+#define __FMA4INTRIN_H
+
+#include "pmmintrin.h"
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128 __attribute__((__always_inline__, __nodebug__, __target__("fma4"), __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256 __attribute__((__always_inline__, __nodebug__, __target__("fma4"), __min_vector_width__(256)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_macc_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddps((__v4sf)__A, (__v4sf)__B, (__v4sf)__C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_macc_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddpd((__v2df)__A, (__v2df)__B, (__v2df)__C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_macc_ss(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddss((__v4sf)__A, (__v4sf)__B, (__v4sf)__C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_macc_sd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsd((__v2df)__A, (__v2df)__B, (__v2df)__C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_msub_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddps((__v4sf)__A, (__v4sf)__B, -(__v4sf)__C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_msub_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddpd((__v2df)__A, (__v2df)__B, -(__v2df)__C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_msub_ss(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddss((__v4sf)__A, (__v4sf)__B, -(__v4sf)__C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_msub_sd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsd((__v2df)__A, (__v2df)__B, -(__v2df)__C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_nmacc_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddps(-(__v4sf)__A, (__v4sf)__B, (__v4sf)__C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_nmacc_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddpd(-(__v2df)__A, (__v2df)__B, (__v2df)__C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_nmacc_ss(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddss(-(__v4sf)__A, (__v4sf)__B, (__v4sf)__C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_nmacc_sd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsd(-(__v2df)__A, (__v2df)__B, (__v2df)__C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_nmsub_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddps(-(__v4sf)__A, (__v4sf)__B, -(__v4sf)__C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_nmsub_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddpd(-(__v2df)__A, (__v2df)__B, -(__v2df)__C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_nmsub_ss(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddss(-(__v4sf)__A, (__v4sf)__B, -(__v4sf)__C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_nmsub_sd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsd(-(__v2df)__A, (__v2df)__B, -(__v2df)__C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_maddsub_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddsubps((__v4sf)__A, (__v4sf)__B, (__v4sf)__C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_maddsub_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsubpd((__v2df)__A, (__v2df)__B, (__v2df)__C);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_msubadd_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddsubps((__v4sf)__A, (__v4sf)__B, -(__v4sf)__C);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_msubadd_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsubpd((__v2df)__A, (__v2df)__B, -(__v2df)__C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_macc_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddps256((__v8sf)__A, (__v8sf)__B, (__v8sf)__C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_macc_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddpd256((__v4df)__A, (__v4df)__B, (__v4df)__C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_msub_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddps256((__v8sf)__A, (__v8sf)__B, -(__v8sf)__C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_msub_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddpd256((__v4df)__A, (__v4df)__B, -(__v4df)__C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_nmacc_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddps256(-(__v8sf)__A, (__v8sf)__B, (__v8sf)__C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_nmacc_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddpd256(-(__v4df)__A, (__v4df)__B, (__v4df)__C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_nmsub_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddps256(-(__v8sf)__A, (__v8sf)__B, -(__v8sf)__C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_nmsub_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddpd256(-(__v4df)__A, (__v4df)__B, -(__v4df)__C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_maddsub_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddsubps256((__v8sf)__A, (__v8sf)__B, (__v8sf)__C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_maddsub_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddsubpd256((__v4df)__A, (__v4df)__B, (__v4df)__C);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_msubadd_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddsubps256((__v8sf)__A, (__v8sf)__B, -(__v8sf)__C);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_msubadd_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddsubpd256((__v4df)__A, (__v4df)__B, -(__v4df)__C);
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif /* __FMA4INTRIN_H */
diff --git a/third_party/intel/clang/fmaintrin.h b/third_party/intel/clang/fmaintrin.h
new file mode 100644
index 000000000..22d1a780b
--- /dev/null
+++ b/third_party/intel/clang/fmaintrin.h
@@ -0,0 +1,796 @@
+/*===---- fmaintrin.h - FMA intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <fmaintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __FMAINTRIN_H
+#define __FMAINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS128 __attribute__((__always_inline__, __nodebug__, __target__("fma"), __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256 __attribute__((__always_inline__, __nodebug__, __target__("fma"), __min_vector_width__(256)))
+
+/// Computes a multiply-add of 128-bit vectors of [4 x float].
+///    For each element, computes <c> (__A * __B) + __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADD213PS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [4 x float] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [4 x float] containing the addend.
+/// \returns A 128-bit vector of [4 x float] containing the result.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_fmadd_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddps((__v4sf)__A, (__v4sf)__B, (__v4sf)__C);
+}
+
+/// Computes a multiply-add of 128-bit vectors of [2 x double].
+///    For each element, computes <c> (__A * __B) + __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADD213PD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [2 x double] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [2 x double] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [2 x double] containing the addend.
+/// \returns A 128-bit [2 x double] vector containing the result.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_fmadd_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddpd((__v2df)__A, (__v2df)__B, (__v2df)__C);
+}
+
+/// Computes a scalar multiply-add of the single-precision values in the
+///    low 32 bits of 128-bit vectors of [4 x float].
+///
+/// \code{.operation}
+/// result[31:0] = (__A[31:0] * __B[31:0]) + __C[31:0]
+/// result[127:32] = __A[127:32]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADD213SS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float] containing the multiplicand in the low
+///    32 bits.
+/// \param __B
+///    A 128-bit vector of [4 x float] containing the multiplier in the low
+///    32 bits.
+/// \param __C
+///    A 128-bit vector of [4 x float] containing the addend in the low
+///    32 bits.
+/// \returns A 128-bit vector of [4 x float] containing the result in the low
+///    32 bits and a copy of \a __A[127:32] in the upper 96 bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_fmadd_ss(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddss3((__v4sf)__A, (__v4sf)__B, (__v4sf)__C);
+}
+
+/// Computes a scalar multiply-add of the double-precision values in the
+///    low 64 bits of 128-bit vectors of [2 x double].
+///
+/// \code{.operation}
+/// result[63:0] = (__A[63:0] * __B[63:0]) + __C[63:0]
+/// result[127:64] = __A[127:64]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADD213SD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [2 x double] containing the multiplicand in the low
+///    64 bits.
+/// \param __B
+///    A 128-bit vector of [2 x double] containing the multiplier in the low
+///    64 bits.
+/// \param __C
+///    A 128-bit vector of [2 x double] containing the addend in the low
+///    64 bits.
+/// \returns A 128-bit vector of [2 x double] containing the result in the low
+///    64 bits and a copy of \a __A[127:64] in the upper 64 bits.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_fmadd_sd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsd3((__v2df)__A, (__v2df)__B, (__v2df)__C);
+}
+
+/// Computes a multiply-subtract of 128-bit vectors of [4 x float].
+///    For each element, computes <c> (__A * __B) - __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMSUB213PS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [4 x float] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [4 x float] containing the subtrahend.
+/// \returns A 128-bit vector of [4 x float] containing the result.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_fmsub_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddps((__v4sf)__A, (__v4sf)__B, -(__v4sf)__C);
+}
+
+/// Computes a multiply-subtract of 128-bit vectors of [2 x double].
+///    For each element, computes <c> (__A * __B) - __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMSUB213PD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [2 x double] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [2 x double] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [2 x double] containing the addend.
+/// \returns A 128-bit vector of [2 x double] containing the result.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_fmsub_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddpd((__v2df)__A, (__v2df)__B, -(__v2df)__C);
+}
+
+/// Computes a scalar multiply-subtract of the single-precision values in
+///    the low 32 bits of 128-bit vectors of [4 x float].
+///
+/// \code{.operation}
+/// result[31:0] = (__A[31:0] * __B[31:0]) - __C[31:0]
+/// result[127:32] = __A[127:32]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMSUB213SS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float] containing the multiplicand in the low
+///    32 bits.
+/// \param __B
+///    A 128-bit vector of [4 x float] containing the multiplier in the low
+///    32 bits.
+/// \param __C
+///    A 128-bit vector of [4 x float] containing the subtrahend in the low
+///   32 bits.
+/// \returns A 128-bit vector of [4 x float] containing the result in the low
+///    32 bits, and a copy of \a __A[127:32] in the upper 96 bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_fmsub_ss(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddss3((__v4sf)__A, (__v4sf)__B, -(__v4sf)__C);
+}
+
+/// Computes a scalar multiply-subtract of the double-precision values in
+///    the low 64 bits of 128-bit vectors of [2 x double].
+///
+/// \code{.operation}
+/// result[63:0] = (__A[63:0] * __B[63:0]) - __C[63:0]
+/// result[127:64] = __A[127:64]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMSUB213SD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [2 x double] containing the multiplicand in the low
+///    64 bits.
+/// \param __B
+///    A 128-bit vector of [2 x double] containing the multiplier in the low
+///    64 bits.
+/// \param __C
+///    A 128-bit vector of [2 x double] containing the subtrahend in the low
+///    64 bits.
+/// \returns A 128-bit vector of [2 x double] containing the result in the low
+///    64 bits, and a copy of \a __A[127:64] in the upper 64 bits.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_fmsub_sd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsd3((__v2df)__A, (__v2df)__B, -(__v2df)__C);
+}
+
+/// Computes a negated multiply-add of 128-bit vectors of [4 x float].
+///    For each element, computes <c> -(__A * __B) + __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMADD213DPS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [4 x float] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [4 x float] containing the addend.
+/// \returns A 128-bit [4 x float] vector containing the result.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_fnmadd_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddps(-(__v4sf)__A, (__v4sf)__B, (__v4sf)__C);
+}
+
+/// Computes a negated multiply-add of 128-bit vectors of [2 x double].
+///    For each element, computes <c> -(__A * __B) + __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMADD213PD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [2 x double] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [2 x double] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [2 x double] containing the addend.
+/// \returns A 128-bit vector of [2 x double] containing the result.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_fnmadd_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddpd(-(__v2df)__A, (__v2df)__B, (__v2df)__C);
+}
+
+/// Computes a scalar negated multiply-add of the single-precision values in
+///    the low 32 bits of 128-bit vectors of [4 x float].
+///
+/// \code{.operation}
+/// result[31:0] = -(__A[31:0] * __B[31:0]) + __C[31:0]
+/// result[127:32] = __A[127:32]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMADD213SS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float] containing the multiplicand in the low
+///    32 bits.
+/// \param __B
+///    A 128-bit vector of [4 x float] containing the multiplier in the low
+///    32 bits.
+/// \param __C
+///    A 128-bit vector of [4 x float] containing the addend in the low
+///    32 bits.
+/// \returns A 128-bit vector of [4 x float] containing the result in the low
+///    32 bits, and a copy of \a __A[127:32] in the upper 96 bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_fnmadd_ss(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddss3((__v4sf)__A, -(__v4sf)__B, (__v4sf)__C);
+}
+
+/// Computes a scalar negated multiply-add of the double-precision values
+///    in the low 64 bits of 128-bit vectors of [2 x double].
+///
+/// \code{.operation}
+/// result[63:0] = -(__A[63:0] * __B[63:0]) + __C[63:0]
+/// result[127:64] = __A[127:64]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMADD213SD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [2 x double] containing the multiplicand in the low
+///    64 bits.
+/// \param __B
+///    A 128-bit vector of [2 x double] containing the multiplier in the low
+///    64 bits.
+/// \param __C
+///    A 128-bit vector of [2 x double] containing the addend in the low
+///    64 bits.
+/// \returns A 128-bit vector of [2 x double] containing the result in the low
+///    64 bits, and a copy of \a __A[127:64] in the upper 64 bits.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_fnmadd_sd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsd3((__v2df)__A, -(__v2df)__B, (__v2df)__C);
+}
+
+/// Computes a negated multiply-subtract of 128-bit vectors of [4 x float].
+///    For each element, computes <c> -(__A * __B) - __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMSUB213PS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [4 x float] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [4 x float] containing the subtrahend.
+/// \returns A 128-bit vector of [4 x float] containing the result.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_fnmsub_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddps(-(__v4sf)__A, (__v4sf)__B, -(__v4sf)__C);
+}
+
+/// Computes a negated multiply-subtract of 128-bit vectors of [2 x double].
+///    For each element, computes <c> -(__A * __B) - __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMSUB213PD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [2 x double] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [2 x double] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [2 x double] containing the subtrahend.
+/// \returns A 128-bit vector of [2 x double] containing the result.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_fnmsub_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddpd(-(__v2df)__A, (__v2df)__B, -(__v2df)__C);
+}
+
+/// Computes a scalar negated multiply-subtract of the single-precision
+///    values in the low 32 bits of 128-bit vectors of [4 x float].
+///
+/// \code{.operation}
+/// result[31:0] = -(__A[31:0] * __B[31:0]) - __C[31:0]
+/// result[127:32] = __A[127:32]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMSUB213SS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float] containing the multiplicand in the low
+///    32 bits.
+/// \param __B
+///    A 128-bit vector of [4 x float] containing the multiplier in the low
+///    32 bits.
+/// \param __C
+///    A 128-bit vector of [4 x float] containing the subtrahend in the low
+///    32 bits.
+/// \returns A 128-bit vector of [4 x float] containing the result in the low
+///    32 bits, and a copy of \a __A[127:32] in the upper 96 bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_fnmsub_ss(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddss3((__v4sf)__A, -(__v4sf)__B, -(__v4sf)__C);
+}
+
+/// Computes a scalar negated multiply-subtract of the double-precision
+///    values in the low 64 bits of 128-bit vectors of [2 x double].
+///
+/// \code{.operation}
+/// result[63:0] = -(__A[63:0] * __B[63:0]) - __C[63:0]
+/// result[127:64] = __A[127:64]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMSUB213SD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [2 x double] containing the multiplicand in the low
+///    64 bits.
+/// \param __B
+///    A 128-bit vector of [2 x double] containing the multiplier in the low
+///    64 bits.
+/// \param __C
+///    A 128-bit vector of [2 x double] containing the subtrahend in the low
+///    64 bits.
+/// \returns A 128-bit vector of [2 x double] containing the result in the low
+///    64 bits, and a copy of \a __A[127:64] in the upper 64 bits.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_fnmsub_sd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsd3((__v2df)__A, -(__v2df)__B, -(__v2df)__C);
+}
+
+/// Computes a multiply with alternating add/subtract of 128-bit vectors of
+///    [4 x float].
+///
+/// \code{.operation}
+/// result[31:0]  = (__A[31:0] * __B[31:0]) - __C[31:0]
+/// result[63:32] = (__A[63:32] * __B[63:32]) + __C[63:32]
+/// result[95:64] = (__A[95:64] * __B[95:64]) - __C[95:64]
+/// result[127:96] = (__A[127:96] * __B[127:96]) + __C[127:96]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADDSUB213PS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [4 x float] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [4 x float] containing the addend/subtrahend.
+/// \returns A 128-bit vector of [4 x float] containing the result.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_fmaddsub_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddsubps((__v4sf)__A, (__v4sf)__B, (__v4sf)__C);
+}
+
+/// Computes a multiply with alternating add/subtract of 128-bit vectors of
+///    [2 x double].
+///
+/// \code{.operation}
+/// result[63:0]  = (__A[63:0] * __B[63:0]) - __C[63:0]
+/// result[127:64] = (__A[127:64] * __B[127:64]) + __C[127:64]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADDSUB213PD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [2 x double] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [2 x double] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [2 x double] containing the addend/subtrahend.
+/// \returns A 128-bit vector of [2 x double] containing the result.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_fmaddsub_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsubpd((__v2df)__A, (__v2df)__B, (__v2df)__C);
+}
+
+/// Computes a multiply with alternating add/subtract of 128-bit vectors of
+///    [4 x float].
+///
+/// \code{.operation}
+/// result[31:0]  = (__A[31:0] * __B[31:0]) + __C[31:0]
+/// result[63:32] = (__A[63:32] * __B[63:32]) - __C[63:32]
+/// result[95:64] = (__A[95:64] * __B[95:64]) + __C[95:64]
+/// result[127:96 = (__A[127:96] * __B[127:96]) - __C[127:96]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMSUBADD213PS instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x float] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [4 x float] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [4 x float] containing the addend/subtrahend.
+/// \returns A 128-bit vector of [4 x float] containing the result.
+static __inline__ __m128 __DEFAULT_FN_ATTRS128
+_mm_fmsubadd_ps(__m128 __A, __m128 __B, __m128 __C)
+{
+  return (__m128)__builtin_ia32_vfmaddsubps((__v4sf)__A, (__v4sf)__B, -(__v4sf)__C);
+}
+
+/// Computes a multiply with alternating add/subtract of 128-bit vectors of
+///    [2 x double].
+///
+/// \code{.operation}
+/// result[63:0]  = (__A[63:0] * __B[63:0]) + __C[63:0]
+/// result[127:64] = (__A[127:64] * __B[127:64]) - __C[127:64]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADDSUB213PD instruction.
+///
+/// \param __A
+///    A 128-bit vector of [2 x double] containing the multiplicand.
+/// \param __B
+///    A 128-bit vector of [2 x double] containing the multiplier.
+/// \param __C
+///    A 128-bit vector of [2 x double] containing the addend/subtrahend.
+/// \returns A 128-bit vector of [2 x double] containing the result.
+static __inline__ __m128d __DEFAULT_FN_ATTRS128
+_mm_fmsubadd_pd(__m128d __A, __m128d __B, __m128d __C)
+{
+  return (__m128d)__builtin_ia32_vfmaddsubpd((__v2df)__A, (__v2df)__B, -(__v2df)__C);
+}
+
+/// Computes a multiply-add of 256-bit vectors of [8 x float].
+///    For each element, computes <c> (__A * __B) + __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADD213PS instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [8 x float] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [8 x float] containing the addend.
+/// \returns A 256-bit vector of [8 x float] containing the result.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_fmadd_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddps256((__v8sf)__A, (__v8sf)__B, (__v8sf)__C);
+}
+
+/// Computes a multiply-add of 256-bit vectors of [4 x double].
+///    For each element, computes <c> (__A * __B) + __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADD213PD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [4 x double] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [4 x double] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [4 x double] containing the addend.
+/// \returns A 256-bit vector of [4 x double] containing the result.
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_fmadd_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddpd256((__v4df)__A, (__v4df)__B, (__v4df)__C);
+}
+
+/// Computes a multiply-subtract of 256-bit vectors of [8 x float].
+///    For each element, computes <c> (__A * __B) - __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMSUB213PS instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [8 x float] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [8 x float] containing the subtrahend.
+/// \returns A 256-bit vector of [8 x float] containing the result.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_fmsub_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddps256((__v8sf)__A, (__v8sf)__B, -(__v8sf)__C);
+}
+
+/// Computes a multiply-subtract of 256-bit vectors of [4 x double].
+///    For each element, computes <c> (__A * __B) - __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMSUB213PD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [4 x double] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [4 x double] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [4 x double] containing the subtrahend.
+/// \returns A 256-bit vector of [4 x double] containing the result.
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_fmsub_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddpd256((__v4df)__A, (__v4df)__B, -(__v4df)__C);
+}
+
+/// Computes a negated multiply-add of 256-bit vectors of [8 x float].
+///    For each element, computes <c> -(__A * __B) + __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMADD213PS instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [8 x float] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [8 x float] containing the addend.
+/// \returns A 256-bit vector of [8 x float] containing the result.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_fnmadd_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddps256(-(__v8sf)__A, (__v8sf)__B, (__v8sf)__C);
+}
+
+/// Computes a negated multiply-add of 256-bit vectors of [4 x double].
+///    For each element, computes <c> -(__A * __B) + __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMADD213PD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [4 x double] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [4 x double] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [4 x double] containing the addend.
+/// \returns A 256-bit vector of [4 x double] containing the result.
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_fnmadd_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddpd256(-(__v4df)__A, (__v4df)__B, (__v4df)__C);
+}
+
+/// Computes a negated multiply-subtract of 256-bit vectors of [8 x float].
+///    For each element, computes <c> -(__A * __B) - __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMSUB213PS instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [8 x float] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [8 x float] containing the subtrahend.
+/// \returns A 256-bit vector of [8 x float] containing the result.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_fnmsub_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddps256(-(__v8sf)__A, (__v8sf)__B, -(__v8sf)__C);
+}
+
+/// Computes a negated multiply-subtract of 256-bit vectors of [4 x double].
+///    For each element, computes <c> -(__A * __B) - __C </c>.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFNMSUB213PD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [4 x double] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [4 x double] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [4 x double] containing the subtrahend.
+/// \returns A 256-bit vector of [4 x double] containing the result.
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_fnmsub_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddpd256(-(__v4df)__A, (__v4df)__B, -(__v4df)__C);
+}
+
+/// Computes a multiply with alternating add/subtract of 256-bit vectors of
+///    [8 x float].
+///
+/// \code{.operation}
+/// result[31:0] = (__A[31:0] * __B[31:0]) - __C[31:0]
+/// result[63:32] = (__A[63:32] * __B[63:32]) + __C[63:32]
+/// result[95:64] = (__A[95:64] * __B[95:64]) - __C[95:64]
+/// result[127:96] = (__A[127:96] * __B[127:96]) + __C[127:96]
+/// result[159:128] = (__A[159:128] * __B[159:128]) - __C[159:128]
+/// result[191:160] = (__A[191:160] * __B[191:160]) + __C[191:160]
+/// result[223:192] = (__A[223:192] * __B[223:192]) - __C[223:192]
+/// result[255:224] = (__A[255:224] * __B[255:224]) + __C[255:224]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADDSUB213PS instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [8 x float] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [8 x float] containing the addend/subtrahend.
+/// \returns A 256-bit vector of [8 x float] containing the result.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_fmaddsub_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddsubps256((__v8sf)__A, (__v8sf)__B, (__v8sf)__C);
+}
+
+/// Computes a multiply with alternating add/subtract of 256-bit vectors of
+///    [4 x double].
+///
+/// \code{.operation}
+/// result[63:0] = (__A[63:0] * __B[63:0]) - __C[63:0]
+/// result[127:64] = (__A[127:64] * __B[127:64]) + __C[127:64]
+/// result[191:128] = (__A[191:128] * __B[191:128]) - __C[191:128]
+/// result[255:192] = (__A[255:192] * __B[255:192]) + __C[255:192]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMADDSUB213PD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [4 x double] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [4 x double] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [4 x double] containing the addend/subtrahend.
+/// \returns A 256-bit vector of [4 x double] containing the result.
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_fmaddsub_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddsubpd256((__v4df)__A, (__v4df)__B, (__v4df)__C);
+}
+
+/// Computes a vector multiply with alternating add/subtract of 256-bit
+///    vectors of [8 x float].
+///
+/// \code{.operation}
+/// result[31:0] = (__A[31:0] * __B[31:0]) + __C[31:0]
+/// result[63:32] = (__A[63:32] * __B[63:32]) - __C[63:32]
+/// result[95:64] = (__A[95:64] * __B[95:64]) + __C[95:64]
+/// result[127:96] = (__A[127:96] * __B[127:96]) - __C[127:96]
+/// result[159:128] = (__A[159:128] * __B[159:128]) + __C[159:128]
+/// result[191:160] = (__A[191:160] * __B[191:160]) - __C[191:160]
+/// result[223:192] = (__A[223:192] * __B[223:192]) + __C[223:192]
+/// result[255:224] = (__A[255:224] * __B[255:224]) - __C[255:224]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMSUBADD213PS instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x float] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [8 x float] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [8 x float] containing the addend/subtrahend.
+/// \returns A 256-bit vector of [8 x float] containing the result.
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_fmsubadd_ps(__m256 __A, __m256 __B, __m256 __C)
+{
+  return (__m256)__builtin_ia32_vfmaddsubps256((__v8sf)__A, (__v8sf)__B, -(__v8sf)__C);
+}
+
+/// Computes a vector multiply with alternating add/subtract of 256-bit
+///    vectors of [4 x double].
+///
+/// \code{.operation}
+/// result[63:0] = (__A[63:0] * __B[63:0]) + __C[63:0]
+/// result[127:64] = (__A[127:64] * __B[127:64]) - __C[127:64]
+/// result[191:128] = (__A[191:128] * __B[191:128]) + __C[191:128]
+/// result[255:192] = (__A[255:192] * __B[255:192]) - __C[255:192]
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VFMSUBADD213PD instruction.
+///
+/// \param __A
+///    A 256-bit vector of [4 x double] containing the multiplicand.
+/// \param __B
+///    A 256-bit vector of [4 x double] containing the multiplier.
+/// \param __C
+///    A 256-bit vector of [4 x double] containing the addend/subtrahend.
+/// \returns A 256-bit vector of [4 x double] containing the result.
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_fmsubadd_pd(__m256d __A, __m256d __B, __m256d __C)
+{
+  return (__m256d)__builtin_ia32_vfmaddsubpd256((__v4df)__A, (__v4df)__B, -(__v4df)__C);
+}
+
+#undef __DEFAULT_FN_ATTRS128
+#undef __DEFAULT_FN_ATTRS256
+
+#endif /* __FMAINTRIN_H */
diff --git a/third_party/intel/clang/fxsrintrin.h b/third_party/intel/clang/fxsrintrin.h
new file mode 100644
index 000000000..afee6aa97
--- /dev/null
+++ b/third_party/intel/clang/fxsrintrin.h
@@ -0,0 +1,91 @@
+/*===---- fxsrintrin.h - FXSR intrinsic ------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <fxsrintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __FXSRINTRIN_H
+#define __FXSRINTRIN_H
+
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__,  __target__("fxsr")))
+
+/// Saves the XMM, MMX, MXCSR and x87 FPU registers into a 512-byte
+///    memory region pointed to by the input parameter \a __p.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> FXSAVE </c> instruction.
+///
+/// \param __p
+///    A pointer to a 512-byte memory region. The beginning of this memory
+///    region should be aligned on a 16-byte boundary.
+static __inline__ void __DEFAULT_FN_ATTRS
+_fxsave(void *__p)
+{
+  __builtin_ia32_fxsave(__p);
+}
+
+/// Restores the XMM, MMX, MXCSR and x87 FPU registers from the 512-byte
+///    memory region pointed to by the input parameter \a __p. The contents of
+///    this memory region should have been written to by a previous \c _fxsave
+///    or \c _fxsave64 intrinsic.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> FXRSTOR </c> instruction.
+///
+/// \param __p
+///    A pointer to a 512-byte memory region. The beginning of this memory
+///    region should be aligned on a 16-byte boundary.
+static __inline__ void __DEFAULT_FN_ATTRS
+_fxrstor(void *__p)
+{
+  __builtin_ia32_fxrstor(__p);
+}
+
+#ifdef __x86_64__
+/// Saves the XMM, MMX, MXCSR and x87 FPU registers into a 512-byte
+///    memory region pointed to by the input parameter \a __p.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> FXSAVE64 </c> instruction.
+///
+/// \param __p
+///    A pointer to a 512-byte memory region. The beginning of this memory
+///    region should be aligned on a 16-byte boundary.
+static __inline__ void __DEFAULT_FN_ATTRS
+_fxsave64(void *__p)
+{
+  __builtin_ia32_fxsave64(__p);
+}
+
+/// Restores the XMM, MMX, MXCSR and x87 FPU registers from the 512-byte
+///    memory region pointed to by the input parameter \a __p. The contents of
+///    this memory region should have been written to by a previous \c _fxsave
+///    or \c _fxsave64 intrinsic.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> FXRSTOR64 </c> instruction.
+///
+/// \param __p
+///    A pointer to a 512-byte memory region. The beginning of this memory
+///    region should be aligned on a 16-byte boundary.
+static __inline__ void __DEFAULT_FN_ATTRS
+_fxrstor64(void *__p)
+{
+  __builtin_ia32_fxrstor64(__p);
+}
+#endif
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/gfniintrin.h b/third_party/intel/clang/gfniintrin.h
new file mode 100644
index 000000000..73b04a824
--- /dev/null
+++ b/third_party/intel/clang/gfniintrin.h
@@ -0,0 +1,211 @@
+/*===----------------- gfniintrin.h - GFNI intrinsics ----------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <gfniintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __GFNIINTRIN_H
+#define __GFNIINTRIN_H
+
+/* Default attributes for simple form (no masking). */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("gfni,no-evex512"), __min_vector_width__(128)))
+
+/* Default attributes for YMM unmasked form. */
+#define __DEFAULT_FN_ATTRS_Y                                                   \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx,gfni,no-evex512"),                            \
+                 __min_vector_width__(256)))
+
+/* Default attributes for ZMM unmasked forms. */
+#define __DEFAULT_FN_ATTRS_Z                                                   \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512f,evex512,gfni"),                           \
+                 __min_vector_width__(512)))
+/* Default attributes for ZMM masked forms. */
+#define __DEFAULT_FN_ATTRS_Z_MASK                                              \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512bw,evex512,gfni"),                          \
+                 __min_vector_width__(512)))
+
+/* Default attributes for VLX masked forms. */
+#define __DEFAULT_FN_ATTRS_VL128                                               \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512bw,avx512vl,gfni,no-evex512"),              \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS_VL256                                               \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512bw,avx512vl,gfni,no-evex512"),              \
+                 __min_vector_width__(256)))
+
+#define _mm_gf2p8affineinv_epi64_epi8(A, B, I) \
+  ((__m128i)__builtin_ia32_vgf2p8affineinvqb_v16qi((__v16qi)(__m128i)(A), \
+                                                   (__v16qi)(__m128i)(B), \
+                                                   (char)(I)))
+
+#define _mm_gf2p8affine_epi64_epi8(A, B, I) \
+  ((__m128i)__builtin_ia32_vgf2p8affineqb_v16qi((__v16qi)(__m128i)(A), \
+                                                   (__v16qi)(__m128i)(B), \
+                                                   (char)(I)))
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_gf2p8mul_epi8(__m128i __A, __m128i __B)
+{
+  return (__m128i) __builtin_ia32_vgf2p8mulb_v16qi((__v16qi) __A,
+              (__v16qi) __B);
+}
+
+#ifdef __AVXINTRIN_H
+#define _mm256_gf2p8affineinv_epi64_epi8(A, B, I) \
+  ((__m256i)__builtin_ia32_vgf2p8affineinvqb_v32qi((__v32qi)(__m256i)(A), \
+                                                   (__v32qi)(__m256i)(B), \
+                                                   (char)(I)))
+
+#define _mm256_gf2p8affine_epi64_epi8(A, B, I) \
+  ((__m256i)__builtin_ia32_vgf2p8affineqb_v32qi((__v32qi)(__m256i)(A), \
+                                                   (__v32qi)(__m256i)(B), \
+                                                   (char)(I)))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS_Y
+_mm256_gf2p8mul_epi8(__m256i __A, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_vgf2p8mulb_v32qi((__v32qi) __A,
+              (__v32qi) __B);
+}
+#endif /* __AVXINTRIN_H */
+
+#ifdef __AVX512BWINTRIN_H
+#define _mm512_gf2p8affineinv_epi64_epi8(A, B, I) \
+  ((__m512i)__builtin_ia32_vgf2p8affineinvqb_v64qi((__v64qi)(__m512i)(A), \
+                                                   (__v64qi)(__m512i)(B), \
+                                                   (char)(I)))
+
+#define _mm512_mask_gf2p8affineinv_epi64_epi8(S, U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectb_512((__mmask64)(U), \
+         (__v64qi)_mm512_gf2p8affineinv_epi64_epi8(A, B, I), \
+         (__v64qi)(__m512i)(S)))
+
+#define _mm512_maskz_gf2p8affineinv_epi64_epi8(U, A, B, I) \
+  _mm512_mask_gf2p8affineinv_epi64_epi8((__m512i)_mm512_setzero_si512(), \
+         U, A, B, I)
+
+#define _mm512_gf2p8affine_epi64_epi8(A, B, I) \
+  ((__m512i)__builtin_ia32_vgf2p8affineqb_v64qi((__v64qi)(__m512i)(A), \
+                                                   (__v64qi)(__m512i)(B), \
+                                                   (char)(I)))
+
+#define _mm512_mask_gf2p8affine_epi64_epi8(S, U, A, B, I) \
+  ((__m512i)__builtin_ia32_selectb_512((__mmask64)(U), \
+         (__v64qi)_mm512_gf2p8affine_epi64_epi8((A), (B), (I)), \
+         (__v64qi)(__m512i)(S)))
+
+#define _mm512_maskz_gf2p8affine_epi64_epi8(U, A, B, I) \
+  _mm512_mask_gf2p8affine_epi64_epi8((__m512i)_mm512_setzero_si512(), \
+         U, A, B, I)
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS_Z
+_mm512_gf2p8mul_epi8(__m512i __A, __m512i __B)
+{
+  return (__m512i) __builtin_ia32_vgf2p8mulb_v64qi((__v64qi) __A,
+              (__v64qi) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS_Z_MASK
+_mm512_mask_gf2p8mul_epi8(__m512i __S, __mmask64 __U, __m512i __A, __m512i __B)
+{
+  return (__m512i) __builtin_ia32_selectb_512(__U,
+              (__v64qi) _mm512_gf2p8mul_epi8(__A, __B),
+              (__v64qi) __S);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS_Z_MASK
+_mm512_maskz_gf2p8mul_epi8(__mmask64 __U, __m512i __A, __m512i __B)
+{
+  return _mm512_mask_gf2p8mul_epi8((__m512i)_mm512_setzero_si512(),
+              __U, __A, __B);
+}
+#endif /* __AVX512BWINTRIN_H */
+
+#ifdef __AVX512VLBWINTRIN_H
+#define _mm_mask_gf2p8affineinv_epi64_epi8(S, U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectb_128((__mmask16)(U), \
+         (__v16qi)_mm_gf2p8affineinv_epi64_epi8(A, B, I), \
+         (__v16qi)(__m128i)(S)))
+
+#define _mm_maskz_gf2p8affineinv_epi64_epi8(U, A, B, I) \
+  _mm_mask_gf2p8affineinv_epi64_epi8((__m128i)_mm_setzero_si128(), \
+         U, A, B, I)
+
+#define _mm256_mask_gf2p8affineinv_epi64_epi8(S, U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectb_256((__mmask32)(U), \
+         (__v32qi)_mm256_gf2p8affineinv_epi64_epi8(A, B, I), \
+         (__v32qi)(__m256i)(S)))
+
+#define _mm256_maskz_gf2p8affineinv_epi64_epi8(U, A, B, I) \
+  _mm256_mask_gf2p8affineinv_epi64_epi8((__m256i)_mm256_setzero_si256(), \
+         U, A, B, I)
+
+#define _mm_mask_gf2p8affine_epi64_epi8(S, U, A, B, I) \
+  ((__m128i)__builtin_ia32_selectb_128((__mmask16)(U), \
+         (__v16qi)_mm_gf2p8affine_epi64_epi8(A, B, I), \
+         (__v16qi)(__m128i)(S)))
+
+#define _mm_maskz_gf2p8affine_epi64_epi8(U, A, B, I) \
+  _mm_mask_gf2p8affine_epi64_epi8((__m128i)_mm_setzero_si128(), U, A, B, I)
+
+#define _mm256_mask_gf2p8affine_epi64_epi8(S, U, A, B, I) \
+  ((__m256i)__builtin_ia32_selectb_256((__mmask32)(U), \
+         (__v32qi)_mm256_gf2p8affine_epi64_epi8(A, B, I), \
+         (__v32qi)(__m256i)(S)))
+
+#define _mm256_maskz_gf2p8affine_epi64_epi8(U, A, B, I) \
+  _mm256_mask_gf2p8affine_epi64_epi8((__m256i)_mm256_setzero_si256(), \
+         U, A, B, I)
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS_VL128
+_mm_mask_gf2p8mul_epi8(__m128i __S, __mmask16 __U, __m128i __A, __m128i __B)
+{
+  return (__m128i) __builtin_ia32_selectb_128(__U,
+              (__v16qi) _mm_gf2p8mul_epi8(__A, __B),
+              (__v16qi) __S);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS_VL128
+_mm_maskz_gf2p8mul_epi8(__mmask16 __U, __m128i __A, __m128i __B)
+{
+  return _mm_mask_gf2p8mul_epi8((__m128i)_mm_setzero_si128(),
+              __U, __A, __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS_VL256
+_mm256_mask_gf2p8mul_epi8(__m256i __S, __mmask32 __U, __m256i __A, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_selectb_256(__U,
+              (__v32qi) _mm256_gf2p8mul_epi8(__A, __B),
+              (__v32qi) __S);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS_VL256
+_mm256_maskz_gf2p8mul_epi8(__mmask32 __U, __m256i __A, __m256i __B)
+{
+  return _mm256_mask_gf2p8mul_epi8((__m256i)_mm256_setzero_si256(),
+              __U, __A, __B);
+}
+#endif /* __AVX512VLBWINTRIN_H */
+
+#undef __DEFAULT_FN_ATTRS
+#undef __DEFAULT_FN_ATTRS_Y
+#undef __DEFAULT_FN_ATTRS_Z
+#undef __DEFAULT_FN_ATTRS_VL128
+#undef __DEFAULT_FN_ATTRS_VL256
+
+#endif /* __GFNIINTRIN_H */
+
diff --git a/third_party/intel/clang/hresetintrin.h b/third_party/intel/clang/hresetintrin.h
new file mode 100644
index 000000000..646f6c130
--- /dev/null
+++ b/third_party/intel/clang/hresetintrin.h
@@ -0,0 +1,49 @@
+/*===---------------- hresetintrin.h - HRESET intrinsics -------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __X86GPRINTRIN_H
+#error "Never use <hresetintrin.h> directly; include <x86gprintrin.h> instead."
+#endif
+
+#ifndef __HRESETINTRIN_H
+#define __HRESETINTRIN_H
+
+#if __has_extension(gnu_asm)
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__, __target__("hreset")))
+
+/// Provides a hint to the processor to selectively reset the prediction
+///    history of the current logical processor specified by a 32-bit integer
+///    value \a __eax.
+///
+/// This intrinsic corresponds to the <c> HRESET </c> instruction.
+///
+/// \code{.operation}
+///    IF __eax == 0
+///      // nop
+///    ELSE
+///      FOR i := 0 to 31
+///        IF __eax[i]
+///          ResetPredictionFeature(i)
+///        FI
+///      ENDFOR
+///    FI
+/// \endcode
+static __inline void __DEFAULT_FN_ATTRS
+_hreset(int __eax)
+{
+  __asm__ ("hreset $0" :: "a"(__eax));
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __has_extension(gnu_asm) */
+
+#endif /* __HRESETINTRIN_H */
diff --git a/third_party/intel/clang/ia32intrin.h b/third_party/intel/clang/ia32intrin.h
new file mode 100644
index 000000000..8e65f232a
--- /dev/null
+++ b/third_party/intel/clang/ia32intrin.h
@@ -0,0 +1,863 @@
+/* ===-------- ia32intrin.h ---------------------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __X86INTRIN_H
+#error "Never use <ia32intrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __IA32INTRIN_H
+#define __IA32INTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__))
+#define __DEFAULT_FN_ATTRS_CRC32 __attribute__((__always_inline__, __nodebug__, __target__("crc32")))
+
+#if defined(__cplusplus) && (__cplusplus >= 201103L)
+#define __DEFAULT_FN_ATTRS_CAST __attribute__((__always_inline__)) constexpr
+#define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS constexpr
+#else
+#define __DEFAULT_FN_ATTRS_CAST __attribute__((__always_inline__))
+#define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS
+#endif
+
+/// Finds the first set bit starting from the least significant bit. The result
+///    is undefined if the input is 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BSF instruction or the
+///    \c TZCNT instruction.
+///
+/// \param __A
+///    A 32-bit integer operand.
+/// \returns A 32-bit integer containing the bit number.
+/// \see _bit_scan_forward
+static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
+__bsfd(int __A) {
+  return __builtin_ctz((unsigned int)__A);
+}
+
+/// Finds the first set bit starting from the most significant bit. The result
+///    is undefined if the input is 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BSR instruction or the
+///    \c LZCNT instruction and an \c XOR.
+///
+/// \param __A
+///    A 32-bit integer operand.
+/// \returns A 32-bit integer containing the bit number.
+/// \see _bit_scan_reverse
+static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
+__bsrd(int __A) {
+  return 31 - __builtin_clz((unsigned int)__A);
+}
+
+/// Swaps the bytes in the input, converting little endian to big endian or
+///    vice versa.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BSWAP instruction.
+///
+/// \param __A
+///    A 32-bit integer operand.
+/// \returns A 32-bit integer containing the swapped bytes.
+static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
+__bswapd(int __A) {
+  return (int)__builtin_bswap32((unsigned int)__A);
+}
+
+/// Swaps the bytes in the input, converting little endian to big endian or
+///    vice versa.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BSWAP instruction.
+///
+/// \param __A
+///    A 32-bit integer operand.
+/// \returns A 32-bit integer containing the swapped bytes.
+static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
+_bswap(int __A) {
+  return (int)__builtin_bswap32((unsigned int)__A);
+}
+
+/// Finds the first set bit starting from the least significant bit. The result
+///    is undefined if the input is 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _bit_scan_forward(int A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c BSF instruction or the
+///    \c TZCNT instruction.
+///
+/// \param A
+///    A 32-bit integer operand.
+/// \returns A 32-bit integer containing the bit number.
+/// \see __bsfd
+#define _bit_scan_forward(A) __bsfd((A))
+
+/// Finds the first set bit starting from the most significant bit. The result
+///    is undefined if the input is 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _bit_scan_reverse(int A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c BSR instruction or the
+///    \c LZCNT instruction and an \c XOR.
+///
+/// \param A
+///    A 32-bit integer operand.
+/// \returns A 32-bit integer containing the bit number.
+/// \see __bsrd
+#define _bit_scan_reverse(A) __bsrd((A))
+
+#ifdef __x86_64__
+/// Finds the first set bit starting from the least significant bit. The result
+///    is undefined if the input is 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BSF instruction or the
+///    \c TZCNT instruction.
+///
+/// \param __A
+///    A 64-bit integer operand.
+/// \returns A 32-bit integer containing the bit number.
+static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
+__bsfq(long long __A) {
+  return (long long)__builtin_ctzll((unsigned long long)__A);
+}
+
+/// Finds the first set bit starting from the most significant bit. The result
+///    is undefined if input is 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BSR instruction or the
+///    \c LZCNT instruction and an \c XOR.
+///
+/// \param __A
+///    A 64-bit integer operand.
+/// \returns A 32-bit integer containing the bit number.
+static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
+__bsrq(long long __A) {
+  return 63 - __builtin_clzll((unsigned long long)__A);
+}
+
+/// Swaps the bytes in the input, converting little endian to big endian or
+///    vice versa.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c BSWAP instruction.
+///
+/// \param __A
+///    A 64-bit integer operand.
+/// \returns A 64-bit integer containing the swapped bytes.
+/// \see _bswap64
+static __inline__ long long __DEFAULT_FN_ATTRS_CONSTEXPR
+__bswapq(long long __A) {
+  return (long long)__builtin_bswap64((unsigned long long)__A);
+}
+
+/// Swaps the bytes in the input, converting little endian to big endian or
+///    vice versa.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// long long _bswap64(long long A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c BSWAP instruction.
+///
+/// \param A
+///    A 64-bit integer operand.
+/// \returns A 64-bit integer containing the swapped bytes.
+/// \see __bswapq
+#define _bswap64(A) __bswapq((A))
+#endif /* __x86_64__ */
+
+/// Counts the number of bits in the source operand having a value of 1.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c POPCNT instruction or a
+///    sequence of arithmetic and logic operations to calculate it.
+///
+/// \param __A
+///    An unsigned 32-bit integer operand.
+/// \returns A 32-bit integer containing the number of bits with value 1 in the
+///    source operand.
+/// \see _popcnt32
+static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
+__popcntd(unsigned int __A)
+{
+  return __builtin_popcount(__A);
+}
+
+/// Counts the number of bits in the source operand having a value of 1.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _popcnt32(int A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c POPCNT instruction or a
+///    sequence of arithmetic and logic operations to calculate it.
+///
+/// \param A
+///    An unsigned 32-bit integer operand.
+/// \returns A 32-bit integer containing the number of bits with value 1 in the
+///    source operand.
+/// \see __popcntd
+#define _popcnt32(A) __popcntd((A))
+
+#ifdef __x86_64__
+/// Counts the number of bits in the source operand having a value of 1.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c POPCNT instruction or a
+///    sequence of arithmetic and logic operations to calculate it.
+///
+/// \param __A
+///    An unsigned 64-bit integer operand.
+/// \returns A 64-bit integer containing the number of bits with value 1 in the
+///    source operand.
+/// \see _popcnt64
+static __inline__ long long __DEFAULT_FN_ATTRS_CONSTEXPR
+__popcntq(unsigned long long __A)
+{
+  return __builtin_popcountll(__A);
+}
+
+/// Counts the number of bits in the source operand having a value of 1.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// long long _popcnt64(unsigned long long A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c POPCNT instruction or a
+///    sequence of arithmetic and logic operations to calculate it.
+///
+/// \param A
+///    An unsigned 64-bit integer operand.
+/// \returns A 64-bit integer containing the number of bits with value 1 in the
+///    source operand.
+/// \see __popcntq
+#define _popcnt64(A) __popcntq((A))
+#endif /* __x86_64__ */
+
+#ifdef __x86_64__
+/// Returns the program status-and-control \c RFLAGS register with the \c VM
+///    and \c RF flags cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PUSHFQ + \c POP instruction sequence.
+///
+/// \returns The 64-bit value of the RFLAGS register.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__readeflags(void)
+{
+  return __builtin_ia32_readeflags_u64();
+}
+
+/// Writes the specified value to the program status-and-control \c RFLAGS
+///    register. Reserved bits are not affected.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PUSH + \c POPFQ instruction sequence.
+///
+/// \param __f
+///    The 64-bit value to write to \c RFLAGS.
+static __inline__ void __DEFAULT_FN_ATTRS
+__writeeflags(unsigned long long __f)
+{
+  __builtin_ia32_writeeflags_u64(__f);
+}
+
+#else /* !__x86_64__ */
+/// Returns the program status-and-control \c EFLAGS register with the \c VM
+///    and \c RF flags cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PUSHFD + \c POP instruction sequence.
+///
+/// \returns The 32-bit value of the EFLAGS register.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__readeflags(void)
+{
+  return __builtin_ia32_readeflags_u32();
+}
+
+/// Writes the specified value to the program status-and-control \c EFLAGS
+///    register. Reserved bits are not affected.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PUSH + \c POPFD instruction sequence.
+///
+/// \param __f
+///    The 32-bit value to write to \c EFLAGS.
+static __inline__ void __DEFAULT_FN_ATTRS
+__writeeflags(unsigned int __f)
+{
+  __builtin_ia32_writeeflags_u32(__f);
+}
+#endif /* !__x86_64__ */
+
+/// Casts a 32-bit float value to a 32-bit unsigned integer value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VMOVD / \c MOVD instruction in x86_64,
+///    and corresponds to the \c VMOVL / \c MOVL instruction in ia32.
+///
+/// \param __A
+///    A 32-bit float value.
+/// \returns A 32-bit unsigned integer containing the converted value.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS_CAST
+_castf32_u32(float __A) {
+  return __builtin_bit_cast(unsigned int, __A);
+}
+
+/// Casts a 64-bit float value to a 64-bit unsigned integer value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VMOVQ / \c MOVQ instruction in x86_64,
+///    and corresponds to the \c VMOVL / \c MOVL instruction in ia32.
+///
+/// \param __A
+///    A 64-bit float value.
+/// \returns A 64-bit unsigned integer containing the converted value.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CAST
+_castf64_u64(double __A) {
+  return __builtin_bit_cast(unsigned long long, __A);
+}
+
+/// Casts a 32-bit unsigned integer value to a 32-bit float value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VMOVQ / \c MOVQ instruction in x86_64,
+///    and corresponds to the \c FLDS instruction in ia32.
+///
+/// \param __A
+///    A 32-bit unsigned integer value.
+/// \returns A 32-bit float value containing the converted value.
+static __inline__ float __DEFAULT_FN_ATTRS_CAST
+_castu32_f32(unsigned int __A) {
+  return __builtin_bit_cast(float, __A);
+}
+
+/// Casts a 64-bit unsigned integer value to a 64-bit float value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VMOVQ / \c MOVQ instruction in x86_64,
+///    and corresponds to the \c FLDL instruction in ia32.
+///
+/// \param __A
+///    A 64-bit unsigned integer value.
+/// \returns A 64-bit float value containing the converted value.
+static __inline__ double __DEFAULT_FN_ATTRS_CAST
+_castu64_f64(unsigned long long __A) {
+  return __builtin_bit_cast(double, __A);
+}
+
+/// Adds the unsigned integer operand to the CRC-32C checksum of the
+///     unsigned char operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c CRC32B instruction.
+///
+/// \param __C
+///    An unsigned integer operand to add to the CRC-32C checksum of operand
+///    \a  __D.
+/// \param __D
+///    An unsigned 8-bit integer operand used to compute the CRC-32C checksum.
+/// \returns The result of adding operand \a __C to the CRC-32C checksum of
+///    operand \a __D.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS_CRC32
+__crc32b(unsigned int __C, unsigned char __D)
+{
+  return __builtin_ia32_crc32qi(__C, __D);
+}
+
+/// Adds the unsigned integer operand to the CRC-32C checksum of the
+///    unsigned short operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c CRC32W instruction.
+///
+/// \param __C
+///    An unsigned integer operand to add to the CRC-32C checksum of operand
+///    \a  __D.
+/// \param __D
+///    An unsigned 16-bit integer operand used to compute the CRC-32C checksum.
+/// \returns The result of adding operand \a __C to the CRC-32C checksum of
+///    operand \a __D.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS_CRC32
+__crc32w(unsigned int __C, unsigned short __D)
+{
+  return __builtin_ia32_crc32hi(__C, __D);
+}
+
+/// Adds the unsigned integer operand to the CRC-32C checksum of the
+///    second unsigned integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c CRC32D instruction.
+///
+/// \param __C
+///    An unsigned integer operand to add to the CRC-32C checksum of operand
+///    \a  __D.
+/// \param __D
+///    An unsigned 32-bit integer operand used to compute the CRC-32C checksum.
+/// \returns The result of adding operand \a __C to the CRC-32C checksum of
+///    operand \a __D.
+static __inline__ unsigned int __DEFAULT_FN_ATTRS_CRC32
+__crc32d(unsigned int __C, unsigned int __D)
+{
+  return __builtin_ia32_crc32si(__C, __D);
+}
+
+#ifdef __x86_64__
+/// Adds the unsigned integer operand to the CRC-32C checksum of the
+///    unsigned 64-bit integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c CRC32Q instruction.
+///
+/// \param __C
+///    An unsigned integer operand to add to the CRC-32C checksum of operand
+///    \a  __D.
+/// \param __D
+///    An unsigned 64-bit integer operand used to compute the CRC-32C checksum.
+/// \returns The result of adding operand \a __C to the CRC-32C checksum of
+///    operand \a __D.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CRC32
+__crc32q(unsigned long long __C, unsigned long long __D)
+{
+  return __builtin_ia32_crc32di(__C, __D);
+}
+#endif /* __x86_64__ */
+
+/// Reads the specified performance-monitoring counter. Refer to your
+///    processor's documentation to determine which performance counters are
+///    supported.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c RDPMC instruction.
+///
+/// \param __A
+///    The performance counter to read.
+/// \returns The 64-bit value read from the performance counter.
+/// \see _rdpmc
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__rdpmc(int __A) {
+  return __builtin_ia32_rdpmc(__A);
+}
+
+/// Reads the processor's time-stamp counter and the \c IA32_TSC_AUX MSR
+///    \c (0xc0000103).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c RDTSCP instruction.
+///
+/// \param __A
+///    The address of where to store the 32-bit \c IA32_TSC_AUX value.
+/// \returns The 64-bit value of the time-stamp counter.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__rdtscp(unsigned int *__A) {
+  return __builtin_ia32_rdtscp(__A);
+}
+
+/// Reads the processor's time-stamp counter.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned long long _rdtsc();
+/// \endcode
+///
+/// This intrinsic corresponds to the \c RDTSC instruction.
+///
+/// \returns The 64-bit value of the time-stamp counter.
+#define _rdtsc() __rdtsc()
+
+/// Reads the specified performance monitoring counter. Refer to your
+///    processor's documentation to determine which performance counters are
+///    supported.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned long long _rdpmc(int A);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c RDPMC instruction.
+///
+/// \param A
+///    The performance counter to read.
+/// \returns The 64-bit value read from the performance counter.
+/// \see __rdpmc
+#define _rdpmc(A) __rdpmc(A)
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_wbinvd(void) {
+  __builtin_ia32_wbinvd();
+}
+
+/// Rotates an 8-bit value to the left by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c ROL instruction.
+///
+/// \param __X
+///    The unsigned 8-bit value to be rotated.
+/// \param __C
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+static __inline__ unsigned char __DEFAULT_FN_ATTRS_CONSTEXPR
+__rolb(unsigned char __X, int __C) {
+  return __builtin_rotateleft8(__X, __C);
+}
+
+/// Rotates an 8-bit value to the right by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c ROR instruction.
+///
+/// \param __X
+///    The unsigned 8-bit value to be rotated.
+/// \param __C
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+static __inline__ unsigned char __DEFAULT_FN_ATTRS_CONSTEXPR
+__rorb(unsigned char __X, int __C) {
+  return __builtin_rotateright8(__X, __C);
+}
+
+/// Rotates a 16-bit value to the left by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c ROL instruction.
+///
+/// \param __X
+///    The unsigned 16-bit value to be rotated.
+/// \param __C
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see _rotwl
+static __inline__ unsigned short __DEFAULT_FN_ATTRS_CONSTEXPR
+__rolw(unsigned short __X, int __C) {
+  return __builtin_rotateleft16(__X, __C);
+}
+
+/// Rotates a 16-bit value to the right by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c ROR instruction.
+///
+/// \param __X
+///    The unsigned 16-bit value to be rotated.
+/// \param __C
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see _rotwr
+static __inline__ unsigned short __DEFAULT_FN_ATTRS_CONSTEXPR
+__rorw(unsigned short __X, int __C) {
+  return __builtin_rotateright16(__X, __C);
+}
+
+/// Rotates a 32-bit value to the left by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c ROL instruction.
+///
+/// \param __X
+///    The unsigned 32-bit value to be rotated.
+/// \param __C
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see _rotl
+static __inline__ unsigned int __DEFAULT_FN_ATTRS_CONSTEXPR
+__rold(unsigned int __X, int __C) {
+  return __builtin_rotateleft32(__X, (unsigned int)__C);
+}
+
+/// Rotates a 32-bit value to the right by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c ROR instruction.
+///
+/// \param __X
+///    The unsigned 32-bit value to be rotated.
+/// \param __C
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see _rotr
+static __inline__ unsigned int __DEFAULT_FN_ATTRS_CONSTEXPR
+__rord(unsigned int __X, int __C) {
+  return __builtin_rotateright32(__X, (unsigned int)__C);
+}
+
+#ifdef __x86_64__
+/// Rotates a 64-bit value to the left by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c ROL instruction.
+///
+/// \param __X
+///    The unsigned 64-bit value to be rotated.
+/// \param __C
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CONSTEXPR
+__rolq(unsigned long long __X, int __C) {
+  return __builtin_rotateleft64(__X, (unsigned long long)__C);
+}
+
+/// Rotates a 64-bit value to the right by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c ROR instruction.
+///
+/// \param __X
+///    The unsigned 64-bit value to be rotated.
+/// \param __C
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS_CONSTEXPR
+__rorq(unsigned long long __X, int __C) {
+  return __builtin_rotateright64(__X, (unsigned long long)__C);
+}
+#endif /* __x86_64__ */
+
+#ifndef _MSC_VER
+/* These are already provided as builtins for MSVC. */
+/* Select the correct function based on the size of long. */
+#ifdef __LP64__
+/// Rotates a 64-bit value to the left by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned long long _lrotl(unsigned long long a, int b);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c ROL instruction.
+///
+/// \param a
+///    The unsigned 64-bit value to be rotated.
+/// \param b
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see __rolq
+#define _lrotl(a,b) __rolq((a), (b))
+
+/// Rotates a 64-bit value to the right by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned long long _lrotr(unsigned long long a, int b);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c ROR instruction.
+///
+/// \param a
+///    The unsigned 64-bit value to be rotated.
+/// \param b
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see __rorq
+#define _lrotr(a,b) __rorq((a), (b))
+#else // __LP64__
+/// Rotates a 32-bit value to the left by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned int _lrotl(unsigned int a, int b);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c ROL instruction.
+///
+/// \param a
+///    The unsigned 32-bit value to be rotated.
+/// \param b
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see __rold
+#define _lrotl(a,b) __rold((a), (b))
+
+/// Rotates a 32-bit value to the right by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned int _lrotr(unsigned int a, int b);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c ROR instruction.
+///
+/// \param a
+///    The unsigned 32-bit value to be rotated.
+/// \param b
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see __rord
+#define _lrotr(a,b) __rord((a), (b))
+#endif // __LP64__
+
+/// Rotates a 32-bit value to the left by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned int _rotl(unsigned int a, int b);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c ROL instruction.
+///
+/// \param a
+///    The unsigned 32-bit value to be rotated.
+/// \param b
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see __rold
+#define _rotl(a,b) __rold((a), (b))
+
+/// Rotates a 32-bit value to the right by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned int _rotr(unsigned int a, int b);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c ROR instruction.
+///
+/// \param a
+///    The unsigned 32-bit value to be rotated.
+/// \param b
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see __rord
+#define _rotr(a,b) __rord((a), (b))
+#endif // _MSC_VER
+
+/* These are not builtins so need to be provided in all modes. */
+/// Rotates a 16-bit value to the left by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned short _rotwl(unsigned short a, int b);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c ROL instruction.
+///
+/// \param a
+///    The unsigned 16-bit value to be rotated.
+/// \param b
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see __rolw
+#define _rotwl(a,b) __rolw((a), (b))
+
+/// Rotates a 16-bit value to the right by the specified number of bits.
+///    This operation is undefined if the number of bits exceeds the size of
+///    the value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// unsigned short _rotwr(unsigned short a, int b);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c ROR instruction.
+///
+/// \param a
+///    The unsigned 16-bit value to be rotated.
+/// \param b
+///    The number of bits to rotate the value.
+/// \returns The rotated value.
+/// \see __rorw
+#define _rotwr(a,b) __rorw((a), (b))
+
+#undef __DEFAULT_FN_ATTRS
+#undef __DEFAULT_FN_ATTRS_CAST
+#undef __DEFAULT_FN_ATTRS_CRC32
+#undef __DEFAULT_FN_ATTRS_CONSTEXPR
+
+#endif /* __IA32INTRIN_H */
diff --git a/third_party/intel/clang/immintrin.h b/third_party/intel/clang/immintrin.h
new file mode 100644
index 000000000..a0b08a1e2
--- /dev/null
+++ b/third_party/intel/clang/immintrin.h
@@ -0,0 +1,747 @@
+/*===---- immintrin.h - Intel intrinsics -----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#define __IMMINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+#include "x86gprintrin.h"
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__MMX__)
+#include "mmintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SSE__)
+#include "xmmintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SSE2__)
+#include "emmintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SSE3__)
+#include "pmmintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SSSE3__)
+#include "tmmintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__SSE4_2__) || defined(__SSE4_1__))
+#include "smmintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AES__) || defined(__PCLMUL__))
+#include "wmmintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__CLFLUSHOPT__)
+#include "clflushoptintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__CLWB__)
+#include "clwbintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX__)
+#include "avxintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX2__)
+#include "avx2intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__F16C__)
+#include "f16cintrin.h"
+#endif
+
+/* No feature check desired due to internal checks */
+#include "bmiintrin.h"
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__BMI2__)
+#include "bmi2intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__LZCNT__)
+#include "lzcntintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__POPCNT__)
+#include "popcntintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__FMA__)
+#include "fmaintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512F__)
+#include "avx512fintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512VL__)
+#include "avx512vlintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512BW__)
+#include "avx512bwintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512BITALG__)
+#include "avx512bitalgintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512CD__)
+#include "avx512cdintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512VPOPCNTDQ__)
+#include "avx512vpopcntdqintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VL__) && defined(__AVX512VPOPCNTDQ__))
+#include "avx512vpopcntdqvlintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512VNNI__)
+#include "avx512vnniintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VL__) && defined(__AVX512VNNI__))
+#include "avx512vlvnniintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVXVNNI__)
+#include "avxvnniintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512DQ__)
+#include "avx512dqintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VL__) && defined(__AVX512BITALG__))
+#include "avx512vlbitalgintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VL__) && defined(__AVX512BW__))
+#include "avx512vlbwintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VL__) && defined(__AVX512CD__))
+#include "avx512vlcdintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VL__) && defined(__AVX512DQ__))
+#include "avx512vldqintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512IFMA__)
+#include "avx512ifmaintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512IFMA__) && defined(__AVX512VL__))
+#include "avx512ifmavlintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVXIFMA__)
+#include "avxifmaintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512VBMI__)
+#include "avx512vbmiintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VBMI__) && defined(__AVX512VL__))
+#include "avx512vbmivlintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512VBMI2__)
+#include "avx512vbmi2intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VBMI2__) && defined(__AVX512VL__))
+#include "avx512vlvbmi2intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512FP16__)
+#include "avx512fp16intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VL__) && defined(__AVX512FP16__))
+#include "avx512vlfp16intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVX512BF16__)
+#include "avx512bf16intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VL__) && defined(__AVX512BF16__))
+#include "avx512vlbf16intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__PKU__)
+#include "pkuintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__VPCLMULQDQ__)
+#include "vpclmulqdqintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__VAES__)
+#include "vaesintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__GFNI__)
+#include "gfniintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVXVNNIINT8__)
+#include "avxvnniint8intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVXNECONVERT__)
+#include "avxneconvertintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SHA512__)
+#include "sha512intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SM3__)
+#include "sm3intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SM4__)
+#include "sm4intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AVXVNNIINT16__)
+#include "avxvnniint16intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__RDPID__)
+/// Reads the value of the IA32_TSC_AUX MSR (0xc0000103).
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> RDPID </c> instruction.
+///
+/// \returns The 32-bit contents of the MSR.
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__, __target__("rdpid")))
+_rdpid_u32(void) {
+  return __builtin_ia32_rdpid();
+}
+#endif // __RDPID__
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__RDRND__)
+/// Returns a 16-bit hardware-generated random value.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> RDRAND </c> instruction.
+///
+/// \param __p
+///    A pointer to a 16-bit memory location to place the random value.
+/// \returns 1 if the value was successfully generated, 0 otherwise.
+static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("rdrnd")))
+_rdrand16_step(unsigned short *__p)
+{
+  return (int)__builtin_ia32_rdrand16_step(__p);
+}
+
+/// Returns a 32-bit hardware-generated random value.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> RDRAND </c> instruction.
+///
+/// \param __p
+///    A pointer to a 32-bit memory location to place the random value.
+/// \returns 1 if the value was successfully generated, 0 otherwise.
+static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("rdrnd")))
+_rdrand32_step(unsigned int *__p)
+{
+  return (int)__builtin_ia32_rdrand32_step(__p);
+}
+
+/// Returns a 64-bit hardware-generated random value.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> RDRAND </c> instruction.
+///
+/// \param __p
+///    A pointer to a 64-bit memory location to place the random value.
+/// \returns 1 if the value was successfully generated, 0 otherwise.
+static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("rdrnd")))
+_rdrand64_step(unsigned long long *__p)
+{
+#ifdef __x86_64__
+  return (int)__builtin_ia32_rdrand64_step(__p);
+#else
+  // We need to emulate the functionality of 64-bit rdrand with 2 32-bit
+  // rdrand instructions.
+  unsigned int __lo, __hi;
+  unsigned int __res_lo = __builtin_ia32_rdrand32_step(&__lo);
+  unsigned int __res_hi = __builtin_ia32_rdrand32_step(&__hi);
+  if (__res_lo && __res_hi) {
+    *__p = ((unsigned long long)__hi << 32) | (unsigned long long)__lo;
+    return 1;
+  } else {
+    *__p = 0;
+    return 0;
+  }
+#endif
+}
+#endif /* __RDRND__ */
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__FSGSBASE__)
+#ifdef __x86_64__
+/// Reads the FS base register.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> RDFSBASE </c> instruction.
+///
+/// \returns The lower 32 bits of the FS base register.
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
+_readfsbase_u32(void)
+{
+  return __builtin_ia32_rdfsbase32();
+}
+
+/// Reads the FS base register.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> RDFSBASE </c> instruction.
+///
+/// \returns The contents of the FS base register.
+static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
+_readfsbase_u64(void)
+{
+  return __builtin_ia32_rdfsbase64();
+}
+
+/// Reads the GS base register.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> RDGSBASE </c> instruction.
+///
+/// \returns The lower 32 bits of the GS base register.
+static __inline__ unsigned int __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
+_readgsbase_u32(void)
+{
+  return __builtin_ia32_rdgsbase32();
+}
+
+/// Reads the GS base register.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> RDGSBASE </c> instruction.
+///
+/// \returns The contents of the GS base register.
+static __inline__ unsigned long long __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
+_readgsbase_u64(void)
+{
+  return __builtin_ia32_rdgsbase64();
+}
+
+/// Modifies the FS base register.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> WRFSBASE </c> instruction.
+///
+/// \param __V
+///    Value to use for the lower 32 bits of the FS base register.
+static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
+_writefsbase_u32(unsigned int __V)
+{
+  __builtin_ia32_wrfsbase32(__V);
+}
+
+/// Modifies the FS base register.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> WRFSBASE </c> instruction.
+///
+/// \param __V
+///    Value to use for the FS base register.
+static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
+_writefsbase_u64(unsigned long long __V)
+{
+  __builtin_ia32_wrfsbase64(__V);
+}
+
+/// Modifies the GS base register.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> WRGSBASE </c> instruction.
+///
+/// \param __V
+///    Value to use for the lower 32 bits of the GS base register.
+static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
+_writegsbase_u32(unsigned int __V)
+{
+  __builtin_ia32_wrgsbase32(__V);
+}
+
+/// Modifies the GS base register.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the <c> WRFSBASE </c> instruction.
+///
+/// \param __V
+///    Value to use for GS base register.
+static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("fsgsbase")))
+_writegsbase_u64(unsigned long long __V)
+{
+  __builtin_ia32_wrgsbase64(__V);
+}
+
+#endif
+#endif /* __FSGSBASE__ */
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__MOVBE__)
+
+/* The structs used below are to force the load/store to be unaligned. This
+ * is accomplished with the __packed__ attribute. The __may_alias__ prevents
+ * tbaa metadata from being generated based on the struct and the type of the
+ * field inside of it.
+ */
+
+/// Load a 16-bit value from memory and swap its bytes.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the MOVBE instruction.
+///
+/// \param __P
+///    A pointer to the 16-bit value to load.
+/// \returns The byte-swapped value.
+static __inline__ short __attribute__((__always_inline__, __nodebug__, __target__("movbe")))
+_loadbe_i16(void const * __P) {
+  struct __loadu_i16 {
+    unsigned short __v;
+  } __attribute__((__packed__, __may_alias__));
+  return (short)__builtin_bswap16(((const struct __loadu_i16*)__P)->__v);
+}
+
+/// Swap the bytes of a 16-bit value and store it to memory.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the MOVBE instruction.
+///
+/// \param __P
+///    A pointer to the memory for storing the swapped value.
+/// \param __D
+///    The 16-bit value to be byte-swapped.
+static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("movbe")))
+_storebe_i16(void * __P, short __D) {
+  struct __storeu_i16 {
+    unsigned short __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_i16*)__P)->__v = __builtin_bswap16((unsigned short)__D);
+}
+
+/// Load a 32-bit value from memory and swap its bytes.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the MOVBE instruction.
+///
+/// \param __P
+///    A pointer to the 32-bit value to load.
+/// \returns The byte-swapped value.
+static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("movbe")))
+_loadbe_i32(void const * __P) {
+  struct __loadu_i32 {
+    unsigned int __v;
+  } __attribute__((__packed__, __may_alias__));
+  return (int)__builtin_bswap32(((const struct __loadu_i32*)__P)->__v);
+}
+
+/// Swap the bytes of a 32-bit value and store it to memory.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the MOVBE instruction.
+///
+/// \param __P
+///    A pointer to the memory for storing the swapped value.
+/// \param __D
+///    The 32-bit value to be byte-swapped.
+static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("movbe")))
+_storebe_i32(void * __P, int __D) {
+  struct __storeu_i32 {
+    unsigned int __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_i32*)__P)->__v = __builtin_bswap32((unsigned int)__D);
+}
+
+#ifdef __x86_64__
+/// Load a 64-bit value from memory and swap its bytes.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the MOVBE instruction.
+///
+/// \param __P
+///    A pointer to the 64-bit value to load.
+/// \returns The byte-swapped value.
+static __inline__ long long __attribute__((__always_inline__, __nodebug__, __target__("movbe")))
+_loadbe_i64(void const * __P) {
+  struct __loadu_i64 {
+    unsigned long long __v;
+  } __attribute__((__packed__, __may_alias__));
+  return (long long)__builtin_bswap64(((const struct __loadu_i64*)__P)->__v);
+}
+
+/// Swap the bytes of a 64-bit value and store it to memory.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the MOVBE instruction.
+///
+/// \param __P
+///    A pointer to the memory for storing the swapped value.
+/// \param __D
+///    The 64-bit value to be byte-swapped.
+static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("movbe")))
+_storebe_i64(void * __P, long long __D) {
+  struct __storeu_i64 {
+    unsigned long long __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_i64*)__P)->__v = __builtin_bswap64((unsigned long long)__D);
+}
+#endif
+#endif /* __MOVBE */
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__RTM__)
+#include "rtmintrin.h"
+#include "xtestintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SHA__)
+#include "shaintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__FXSR__)
+#include "fxsrintrin.h"
+#endif
+
+/* No feature check desired due to internal MSC_VER checks */
+#include "xsaveintrin.h"
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__XSAVEOPT__)
+#include "xsaveoptintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__XSAVEC__)
+#include "xsavecintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__XSAVES__)
+#include "xsavesintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SHSTK__)
+#include "cetintrin.h"
+#endif
+
+/* Intrinsics inside adcintrin.h are available at all times. */
+#include "adcintrin.h"
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__ADX__)
+#include "adxintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__RDSEED__)
+#include "rdseedintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__WBNOINVD__)
+#include "wbnoinvdintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__CLDEMOTE__)
+#include "cldemoteintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__WAITPKG__)
+#include "waitpkgintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__MOVDIRI__) ||     \
+    defined(__MOVDIR64B__)
+#include "movdirintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__PCONFIG__)
+#include "pconfigintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SGX__)
+#include "sgxintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__PTWRITE__)
+#include "ptwriteintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__INVPCID__)
+#include "invpcidintrin.h"
+#endif
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AMX_FP16__)
+#include "amxfp16intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__KL__) ||          \
+    defined(__WIDEKL__)
+#include "keylockerintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AMX_TILE__) ||    \
+    defined(__AMX_INT8__) || defined(__AMX_BF16__)
+#include "amxintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__AMX_COMPLEX__)
+#include "amxcomplexintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    defined(__AVX512VP2INTERSECT__)
+#include "avx512vp2intersectintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) ||                             \
+    (defined(__AVX512VL__) && defined(__AVX512VP2INTERSECT__))
+#include "avx512vlvp2intersectintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__ENQCMD__)
+#include "enqcmdintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SERIALIZE__)
+#include "serializeintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__TSXLDTRK__)
+#include "tsxldtrkintrin.h"
+#endif
+
+#if defined(_MSC_VER) && __has_extension(gnu_asm)
+/* Define the default attributes for these intrinsics */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__))
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*----------------------------------------------------------------------------*\
+|* Interlocked Exchange HLE
+\*----------------------------------------------------------------------------*/
+#if defined(__i386__) || defined(__x86_64__)
+static __inline__ long __DEFAULT_FN_ATTRS
+_InterlockedExchange_HLEAcquire(long volatile *_Target, long _Value) {
+  __asm__ __volatile__(".byte 0xf2 ; lock ; xchg {%0, %1|%1, %0}"
+                       : "+r" (_Value), "+m" (*_Target) :: "memory");
+  return _Value;
+}
+static __inline__ long __DEFAULT_FN_ATTRS
+_InterlockedExchange_HLERelease(long volatile *_Target, long _Value) {
+  __asm__ __volatile__(".byte 0xf3 ; lock ; xchg {%0, %1|%1, %0}"
+                       : "+r" (_Value), "+m" (*_Target) :: "memory");
+  return _Value;
+}
+#endif
+#if defined(__x86_64__)
+static __inline__ __int64 __DEFAULT_FN_ATTRS
+_InterlockedExchange64_HLEAcquire(__int64 volatile *_Target, __int64 _Value) {
+  __asm__ __volatile__(".byte 0xf2 ; lock ; xchg {%0, %1|%1, %0}"
+                       : "+r" (_Value), "+m" (*_Target) :: "memory");
+  return _Value;
+}
+static __inline__ __int64 __DEFAULT_FN_ATTRS
+_InterlockedExchange64_HLERelease(__int64 volatile *_Target, __int64 _Value) {
+  __asm__ __volatile__(".byte 0xf3 ; lock ; xchg {%0, %1|%1, %0}"
+                       : "+r" (_Value), "+m" (*_Target) :: "memory");
+  return _Value;
+}
+#endif
+/*----------------------------------------------------------------------------*\
+|* Interlocked Compare Exchange HLE
+\*----------------------------------------------------------------------------*/
+#if defined(__i386__) || defined(__x86_64__)
+static __inline__ long __DEFAULT_FN_ATTRS
+_InterlockedCompareExchange_HLEAcquire(long volatile *_Destination,
+                              long _Exchange, long _Comparand) {
+  __asm__ __volatile__(".byte 0xf2 ; lock ; cmpxchg {%2, %1|%1, %2}"
+                       : "+a" (_Comparand), "+m" (*_Destination)
+                       : "r" (_Exchange) : "memory");
+  return _Comparand;
+}
+static __inline__ long __DEFAULT_FN_ATTRS
+_InterlockedCompareExchange_HLERelease(long volatile *_Destination,
+                              long _Exchange, long _Comparand) {
+  __asm__ __volatile__(".byte 0xf3 ; lock ; cmpxchg {%2, %1|%1, %2}"
+                       : "+a" (_Comparand), "+m" (*_Destination)
+                       : "r" (_Exchange) : "memory");
+  return _Comparand;
+}
+#endif
+#if defined(__x86_64__)
+static __inline__ __int64 __DEFAULT_FN_ATTRS
+_InterlockedCompareExchange64_HLEAcquire(__int64 volatile *_Destination,
+                              __int64 _Exchange, __int64 _Comparand) {
+  __asm__ __volatile__(".byte 0xf2 ; lock ; cmpxchg {%2, %1|%1, %2}"
+                       : "+a" (_Comparand), "+m" (*_Destination)
+                       : "r" (_Exchange) : "memory");
+  return _Comparand;
+}
+static __inline__ __int64 __DEFAULT_FN_ATTRS
+_InterlockedCompareExchange64_HLERelease(__int64 volatile *_Destination,
+                              __int64 _Exchange, __int64 _Comparand) {
+  __asm__ __volatile__(".byte 0xf3 ; lock ; cmpxchg {%2, %1|%1, %2}"
+                       : "+a" (_Comparand), "+m" (*_Destination)
+                       : "r" (_Exchange) : "memory");
+  return _Comparand;
+}
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* defined(_MSC_VER) && __has_extension(gnu_asm) */
+
+#endif /* __IMMINTRIN_H */
diff --git a/third_party/intel/clang/invpcidintrin.h b/third_party/intel/clang/invpcidintrin.h
new file mode 100644
index 000000000..48dae0a86
--- /dev/null
+++ b/third_party/intel/clang/invpcidintrin.h
@@ -0,0 +1,23 @@
+/*===------------- invpcidintrin.h - INVPCID intrinsic ---------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <invpcidintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __INVPCIDINTRIN_H
+#define __INVPCIDINTRIN_H
+
+static __inline__ void
+  __attribute__((__always_inline__, __nodebug__,  __target__("invpcid")))
+_invpcid(unsigned int __type, void *__descriptor) {
+  __builtin_ia32_invpcid(__type, __descriptor);
+}
+
+#endif /* __INVPCIDINTRIN_H */
diff --git a/third_party/intel/clang/keylockerintrin.h b/third_party/intel/clang/keylockerintrin.h
new file mode 100644
index 000000000..f76e91b4d
--- /dev/null
+++ b/third_party/intel/clang/keylockerintrin.h
@@ -0,0 +1,527 @@
+/*===----------------- keylockerintrin.h - KL Intrinsics -------------------===
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <keylockerintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef _KEYLOCKERINTRIN_H
+#define _KEYLOCKERINTRIN_H
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__KL__)
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__, __target__("kl"),\
+                 __min_vector_width__(128)))
+
+/// Load internal wrapping key from __intkey, __enkey_lo and __enkey_hi. __ctl
+/// will assigned to EAX, whch specifies the KeySource and whether backing up
+/// the key is permitted. The 256-bit encryption key is loaded from the two
+/// explicit operands (__enkey_lo and __enkey_hi). The 128-bit integrity key is
+/// loaded from the implicit operand XMM0 which assigned by __intkey.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> LOADIWKEY </c> instructions.
+///
+/// \code{.operation}
+/// IF CPL > 0 // LOADKWKEY only allowed at ring 0 (supervisor mode)
+///   GP (0)
+/// FI
+/// IF “LOADIWKEY exiting” VM execution control set
+///   VMexit
+/// FI
+/// IF __ctl[4:1] > 1 // Reserved KeySource encoding used
+///   GP (0)
+/// FI
+/// IF __ctl[31:5] != 0 // Reserved bit in __ctl is set
+///   GP (0)
+/// FI
+/// IF __ctl[0] AND (CPUID.19H.ECX[0] == 0) // NoBackup is not supported on this part
+///   GP (0)
+/// FI
+/// IF (__ctl[4:1] == 1) AND (CPUID.19H.ECX[1] == 0) // KeySource of 1 is not supported on this part
+///   GP (0)
+/// FI
+/// IF (__ctl[4:1] == 0) // KeySource of 0.
+///   IWKey.Encryption Key[127:0] := __enkey_hi[127:0]:
+///   IWKey.Encryption Key[255:128] := __enkey_lo[127:0]
+///   IWKey.IntegrityKey[127:0] := __intkey[127:0]
+///   IWKey.NoBackup := __ctl[0]
+///   IWKey.KeySource := __ctl[4:1]
+///   ZF := 0
+/// ELSE // KeySource of 1. See RDSEED definition for details of randomness
+///   IF HW_NRND_GEN.ready == 1 // Full-entropy random data from RDSEED was received
+///     IWKey.Encryption Key[127:0] := __enkey_hi[127:0] XOR HW_NRND_GEN.data[127:0]
+///     IWKey.Encryption Key[255:128] := __enkey_lo[127:0] XOR HW_NRND_GEN.data[255:128]
+///     IWKey.Encryption Key[255:0] := __enkey_hi[127:0]:__enkey_lo[127:0] XOR HW_NRND_GEN.data[255:0]
+///     IWKey.IntegrityKey[127:0] := __intkey[127:0] XOR HW_NRND_GEN.data[383:256]
+///     IWKey.NoBackup := __ctl[0]
+///     IWKey.KeySource := __ctl[4:1]
+///     ZF := 0
+///   ELSE // Random data was not returned from RDSEED. IWKey was not loaded
+///     ZF := 1
+///   FI
+/// FI
+/// dst := ZF
+/// OF := 0
+/// SF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_loadiwkey (unsigned int __ctl, __m128i __intkey,
+               __m128i __enkey_lo, __m128i __enkey_hi) {
+  __builtin_ia32_loadiwkey (__intkey, __enkey_lo, __enkey_hi, __ctl);
+}
+
+/// Wrap a 128-bit AES key from __key into a key handle and output in
+/// ((__m128i*)__h) to ((__m128i*)__h) + 2  and a 32-bit value as return.
+/// The explicit source operand __htype specifies handle restrictions.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> ENCODEKEY128 </c> instructions.
+///
+/// \code{.operation}
+/// InputKey[127:0] := __key[127:0]
+/// KeyMetadata[2:0] := __htype[2:0]
+/// KeyMetadata[23:3] := 0 // Reserved for future usage
+/// KeyMetadata[27:24] := 0 // KeyType is AES-128 (value of 0)
+/// KeyMetadata[127:28] := 0 // Reserved for future usage
+/// Handle[383:0] := WrapKey128(InputKey[127:0], KeyMetadata[127:0],
+///                  IWKey.Integrity Key[127:0], IWKey.Encryption Key[255:0])
+/// dst[0] := IWKey.NoBackup
+/// dst[4:1] := IWKey.KeySource[3:0]
+/// dst[31:5] := 0
+/// MEM[__h+127:__h] := Handle[127:0]   // AAD
+/// MEM[__h+255:__h+128] := Handle[255:128] // Integrity Tag
+/// MEM[__h+383:__h+256] := Handle[383:256] // CipherText
+/// OF := 0
+/// SF := 0
+/// ZF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_mm_encodekey128_u32(unsigned int __htype, __m128i __key, void *__h) {
+  return __builtin_ia32_encodekey128_u32(__htype, (__v2di)__key, __h);
+}
+
+/// Wrap a 256-bit AES key from __key_hi:__key_lo into a key handle, then
+/// output handle in ((__m128i*)__h) to ((__m128i*)__h) + 3 and
+/// a 32-bit value as return.
+/// The explicit source operand __htype specifies handle restrictions.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> ENCODEKEY256 </c> instructions.
+///
+/// \code{.operation}
+/// InputKey[127:0] := __key_lo[127:0]
+/// InputKey[255:128] := __key_hi[255:128]
+/// KeyMetadata[2:0] := __htype[2:0]
+/// KeyMetadata[23:3] := 0 // Reserved for future usage
+/// KeyMetadata[27:24] := 1 // KeyType is AES-256 (value of 1)
+/// KeyMetadata[127:28] := 0 // Reserved for future usage
+/// Handle[511:0] := WrapKey256(InputKey[255:0], KeyMetadata[127:0],
+///                  IWKey.Integrity Key[127:0], IWKey.Encryption Key[255:0])
+/// dst[0] := IWKey.NoBackup
+/// dst[4:1] := IWKey.KeySource[3:0]
+/// dst[31:5] := 0
+/// MEM[__h+127:__h]   := Handle[127:0] // AAD
+/// MEM[__h+255:__h+128] := Handle[255:128] // Tag
+/// MEM[__h+383:__h+256] := Handle[383:256] // CipherText[127:0]
+/// MEM[__h+511:__h+384] := Handle[511:384] // CipherText[255:128]
+/// OF := 0
+/// SF := 0
+/// ZF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_mm_encodekey256_u32(unsigned int __htype, __m128i __key_lo, __m128i __key_hi,
+                     void *__h) {
+  return __builtin_ia32_encodekey256_u32(__htype, (__v2di)__key_lo,
+                                         (__v2di)__key_hi, __h);
+}
+
+/// The AESENC128KL performs 10 rounds of AES to encrypt the __idata using
+/// the 128-bit key in the handle from the __h. It stores the result in the
+/// __odata. And return the affected ZF flag status.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> AESENC128KL </c> instructions.
+///
+/// \code{.operation}
+/// Handle[383:0] := MEM[__h+383:__h] // Load is not guaranteed to be atomic.
+/// IllegalHandle := ( HandleReservedBitSet (Handle[383:0]) ||
+///                    (Handle[127:0] AND (CPL > 0)) ||
+///                    Handle[383:256] ||
+///                    HandleKeyType (Handle[383:0]) != HANDLE_KEY_TYPE_AES128 )
+/// IF (IllegalHandle)
+///   ZF := 1
+/// ELSE
+///   (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey)
+///   IF (Authentic == 0)
+///     ZF := 1
+///   ELSE
+///     MEM[__odata+127:__odata] := AES128Encrypt (__idata[127:0], UnwrappedKey)
+///     ZF := 0
+///   FI
+/// FI
+/// dst := ZF
+/// OF := 0
+/// SF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_mm_aesenc128kl_u8(__m128i* __odata, __m128i __idata, const void *__h) {
+  return __builtin_ia32_aesenc128kl_u8((__v2di *)__odata, (__v2di)__idata, __h);
+}
+
+/// The AESENC256KL performs 14 rounds of AES to encrypt the __idata using
+/// the 256-bit key in the handle from the __h. It stores the result in the
+/// __odata. And return the affected ZF flag status.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> AESENC256KL </c> instructions.
+///
+/// \code{.operation}
+/// Handle[511:0] := MEM[__h+511:__h] // Load is not guaranteed to be atomic.
+/// IllegalHandle := ( HandleReservedBitSet (Handle[511:0]) ||
+///                    (Handle[127:0] AND (CPL > 0)) ||
+///                    Handle[255:128] ||
+///                    HandleKeyType (Handle[511:0]) != HANDLE_KEY_TYPE_AES256 )
+/// IF (IllegalHandle)
+///   ZF := 1
+///   MEM[__odata+127:__odata] := 0
+/// ELSE
+///   (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey)
+///   IF (Authentic == 0)
+///     ZF := 1
+///     MEM[__odata+127:__odata] := 0
+///   ELSE
+///     MEM[__odata+127:__odata] := AES256Encrypt (__idata[127:0], UnwrappedKey)
+///     ZF := 0
+///   FI
+/// FI
+/// dst := ZF
+/// OF := 0
+/// SF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_mm_aesenc256kl_u8(__m128i* __odata, __m128i __idata, const void *__h) {
+  return __builtin_ia32_aesenc256kl_u8((__v2di *)__odata, (__v2di)__idata, __h);
+}
+
+/// The AESDEC128KL performs 10 rounds of AES to decrypt the __idata using
+/// the 128-bit key in the handle from the __h. It stores the result in the
+/// __odata. And return the affected ZF flag status.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> AESDEC128KL </c> instructions.
+///
+/// \code{.operation}
+/// Handle[383:0] := MEM[__h+383:__h] // Load is not guaranteed to be atomic.
+/// IllegalHandle := (HandleReservedBitSet (Handle[383:0]) ||
+///                  (Handle[127:0] AND (CPL > 0)) ||
+///                  Handle[383:256] ||
+///                  HandleKeyType (Handle[383:0]) != HANDLE_KEY_TYPE_AES128)
+/// IF (IllegalHandle)
+///   ZF := 1
+///   MEM[__odata+127:__odata] := 0
+/// ELSE
+///   (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey)
+///   IF (Authentic == 0)
+///     ZF := 1
+///     MEM[__odata+127:__odata] := 0
+///   ELSE
+///     MEM[__odata+127:__odata] := AES128Decrypt (__idata[127:0], UnwrappedKey)
+///     ZF := 0
+///   FI
+/// FI
+/// dst := ZF
+/// OF := 0
+/// SF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_mm_aesdec128kl_u8(__m128i* __odata, __m128i __idata, const void *__h) {
+  return __builtin_ia32_aesdec128kl_u8((__v2di *)__odata, (__v2di)__idata, __h);
+}
+
+/// The AESDEC256KL performs 10 rounds of AES to decrypt the __idata using
+/// the 256-bit key in the handle from the __h. It stores the result in the
+/// __odata. And return the affected ZF flag status.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> AESDEC256KL </c> instructions.
+///
+/// \code{.operation}
+/// Handle[511:0] := MEM[__h+511:__h]
+/// IllegalHandle := (HandleReservedBitSet (Handle[511:0]) ||
+///                   (Handle[127:0] AND (CPL > 0)) ||
+///                   Handle[383:256] ||
+///                   HandleKeyType (Handle[511:0]) != HANDLE_KEY_TYPE_AES256)
+/// IF (IllegalHandle)
+///   ZF := 1
+///   MEM[__odata+127:__odata] := 0
+/// ELSE
+///   (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey)
+///   IF (Authentic == 0)
+///     ZF := 1
+///     MEM[__odata+127:__odata] := 0
+///   ELSE
+///     MEM[__odata+127:__odata] := AES256Decrypt (__idata[127:0], UnwrappedKey)
+///     ZF := 0
+///   FI
+/// FI
+/// dst := ZF
+/// OF := 0
+/// SF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_mm_aesdec256kl_u8(__m128i* __odata, __m128i __idata, const void *__h) {
+  return __builtin_ia32_aesdec256kl_u8((__v2di *)__odata, (__v2di)__idata, __h);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* !defined(__SCE__ || __has_feature(modules) || defined(__KL__) */
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__WIDEKL__)
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__, __target__("kl,widekl"),\
+                 __min_vector_width__(128)))
+
+/// Encrypt __idata[0] to __idata[7] using 128-bit AES key indicated by handle
+/// at __h and store each resultant block back from __odata to __odata+7. And
+/// return the affected ZF flag status.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> AESENCWIDE128KL </c> instructions.
+///
+/// \code{.operation}
+/// Handle := MEM[__h+383:__h]
+/// IllegalHandle := ( HandleReservedBitSet (Handle[383:0]) ||
+///                    (Handle[127:0] AND (CPL > 0)) ||
+///                    Handle[255:128] ||
+///                    HandleKeyType (Handle[383:0]) != HANDLE_KEY_TYPE_AES128 )
+/// IF (IllegalHandle)
+///   ZF := 1
+///   FOR i := 0 to 7
+///     __odata[i] := 0
+///   ENDFOR
+/// ELSE
+///   (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey)
+///   IF Authentic == 0
+///     ZF := 1
+///     FOR i := 0 to 7
+///       __odata[i] := 0
+///     ENDFOR
+///   ELSE
+///     FOR i := 0 to 7
+///       __odata[i] := AES128Encrypt (__idata[i], UnwrappedKey)
+///     ENDFOR
+///     ZF := 0
+///   FI
+/// FI
+/// dst := ZF
+/// OF := 0
+/// SF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_mm_aesencwide128kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) {
+  return __builtin_ia32_aesencwide128kl_u8((__v2di *)__odata,
+                                           (const __v2di *)__idata, __h);
+}
+
+/// Encrypt __idata[0] to __idata[7] using 256-bit AES key indicated by handle
+/// at __h and store each resultant block back from __odata to __odata+7. And
+/// return the affected ZF flag status.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> AESENCWIDE256KL </c> instructions.
+///
+/// \code{.operation}
+/// Handle[511:0] := MEM[__h+511:__h]
+/// IllegalHandle := ( HandleReservedBitSet (Handle[511:0]) ||
+///                    (Handle[127:0] AND (CPL > 0)) ||
+///                    Handle[255:128] ||
+///                    HandleKeyType (Handle[511:0]) != HANDLE_KEY_TYPE_AES512 )
+/// IF (IllegalHandle)
+///   ZF := 1
+///   FOR i := 0 to 7
+///     __odata[i] := 0
+///   ENDFOR
+/// ELSE
+///   (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey)
+///   IF Authentic == 0
+///     ZF := 1
+///     FOR i := 0 to 7
+///       __odata[i] := 0
+///     ENDFOR
+///   ELSE
+///     FOR i := 0 to 7
+///       __odata[i] := AES256Encrypt (__idata[i], UnwrappedKey)
+///     ENDFOR
+///     ZF := 0
+///   FI
+/// FI
+/// dst := ZF
+/// OF := 0
+/// SF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_mm_aesencwide256kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) {
+  return __builtin_ia32_aesencwide256kl_u8((__v2di *)__odata,
+                                           (const __v2di *)__idata, __h);
+}
+
+/// Decrypt __idata[0] to __idata[7] using 128-bit AES key indicated by handle
+/// at __h and store each resultant block back from __odata to __odata+7. And
+/// return the affected ZF flag status.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> AESDECWIDE128KL </c> instructions.
+///
+/// \code{.operation}
+/// Handle[383:0] := MEM[__h+383:__h]
+/// IllegalHandle := ( HandleReservedBitSet (Handle[383:0]) ||
+///                    (Handle[127:0] AND (CPL > 0)) ||
+///                    Handle[255:128] ||
+///                    HandleKeyType (Handle) != HANDLE_KEY_TYPE_AES128 )
+/// IF (IllegalHandle)
+///   ZF := 1
+///   FOR i := 0 to 7
+///     __odata[i] := 0
+///   ENDFOR
+/// ELSE
+///   (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey)
+///   IF Authentic == 0
+///     ZF := 1
+///     FOR i := 0 to 7
+///       __odata[i] := 0
+///     ENDFOR
+///   ELSE
+///     FOR i := 0 to 7
+///       __odata[i] := AES128Decrypt (__idata[i], UnwrappedKey)
+///     ENDFOR
+///     ZF := 0
+///   FI
+/// FI
+/// dst := ZF
+/// OF := 0
+/// SF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_mm_aesdecwide128kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) {
+  return __builtin_ia32_aesdecwide128kl_u8((__v2di *)__odata,
+                                           (const __v2di *)__idata, __h);
+}
+
+/// Decrypt __idata[0] to __idata[7] using 256-bit AES key indicated by handle
+/// at __h and store each resultant block back from __odata to __odata+7. And
+/// return the affected ZF flag status.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> AESDECWIDE256KL </c> instructions.
+///
+/// \code{.operation}
+/// Handle[511:0] := MEM[__h+511:__h]
+/// IllegalHandle = ( HandleReservedBitSet (Handle[511:0]) ||
+///                   (Handle[127:0] AND (CPL > 0)) ||
+///                   Handle[255:128] ||
+///                   HandleKeyType (Handle) != HANDLE_KEY_TYPE_AES512 )
+/// If (IllegalHandle)
+///   ZF := 1
+///   FOR i := 0 to 7
+///     __odata[i] := 0
+///   ENDFOR
+/// ELSE
+///   (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey)
+///   IF Authentic == 0
+///     ZF := 1
+///     FOR i := 0 to 7
+///       __odata[i] := 0
+///     ENDFOR
+///   ELSE
+///     FOR i := 0 to 7
+///       __odata[i] := AES256Decrypt (__idata[i], UnwrappedKey)
+///     ENDFOR
+///     ZF := 0
+///   FI
+/// FI
+/// dst := ZF
+/// OF := 0
+/// SF := 0
+/// AF := 0
+/// PF := 0
+/// CF := 0
+/// \endcode
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_mm_aesdecwide256kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) {
+  return __builtin_ia32_aesdecwide256kl_u8((__v2di *)__odata,
+                                           (const __v2di *)__idata, __h);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* !defined(__SCE__) || __has_feature(modules) || defined(__WIDEKL__)   \
+        */
+
+#endif /* _KEYLOCKERINTRIN_H */
diff --git a/third_party/intel/clang/lwpintrin.h b/third_party/intel/clang/lwpintrin.h
new file mode 100644
index 000000000..d8ab0db03
--- /dev/null
+++ b/third_party/intel/clang/lwpintrin.h
@@ -0,0 +1,136 @@
+/*===---- lwpintrin.h - LWP intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __X86INTRIN_H
+#error "Never use <lwpintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __LWPINTRIN_H
+#define __LWPINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("lwp")))
+
+/// Parses the LWPCB at the specified address and enables
+///        profiling if valid.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> LLWPCB </c> instruction.
+///
+/// \param __addr
+///    Address to the new Lightweight Profiling Control Block (LWPCB). If the
+///    LWPCB is valid, writes the address into the LWP_CBADDR MSR and enables
+///    Lightweight Profiling.
+static __inline__ void __DEFAULT_FN_ATTRS
+__llwpcb (void *__addr)
+{
+  __builtin_ia32_llwpcb(__addr);
+}
+
+/// Flushes the LWP state to memory and returns the address of the LWPCB.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> SLWPCB </c> instruction.
+///
+/// \return
+///    Address to the current Lightweight Profiling Control Block (LWPCB).
+///    If LWP is not currently enabled, returns NULL.
+static __inline__ void* __DEFAULT_FN_ATTRS
+__slwpcb (void)
+{
+  return __builtin_ia32_slwpcb();
+}
+
+/// Inserts programmed event record into the LWP event ring buffer
+///        and advances the ring buffer pointer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> LWPINS </c> instruction.
+///
+/// \param DATA2
+///    A 32-bit value is zero-extended and inserted into the 64-bit Data2 field.
+/// \param DATA1
+///    A 32-bit value is inserted into the 32-bit Data1 field.
+/// \param FLAGS
+///    A 32-bit immediate value is inserted into the 32-bit Flags field.
+/// \returns If the ring buffer is full and LWP is running in Synchronized Mode,
+///    the event record overwrites the last record in the buffer, the MissedEvents
+///    counter in the LWPCB is incremented, the head pointer is not advanced, and
+///    1 is returned. Otherwise 0 is returned.
+#define __lwpins32(DATA2, DATA1, FLAGS) \
+  (__builtin_ia32_lwpins32((unsigned int) (DATA2), (unsigned int) (DATA1), \
+                           (unsigned int) (FLAGS)))
+
+/// Decrements the LWP programmed value sample event counter. If the result is
+///        negative, inserts an event record into the LWP event ring buffer in memory
+///        and advances the ring buffer pointer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> LWPVAL </c> instruction.
+///
+/// \param DATA2
+///    A 32-bit value is zero-extended and inserted into the 64-bit Data2 field.
+/// \param DATA1
+///    A 32-bit value is inserted into the 32-bit Data1 field.
+/// \param FLAGS
+///    A 32-bit immediate value is inserted into the 32-bit Flags field.
+#define __lwpval32(DATA2, DATA1, FLAGS) \
+  (__builtin_ia32_lwpval32((unsigned int) (DATA2), (unsigned int) (DATA1), \
+                           (unsigned int) (FLAGS)))
+
+#ifdef __x86_64__
+
+/// Inserts programmed event record into the LWP event ring buffer
+///        and advances the ring buffer pointer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> LWPINS </c> instruction.
+///
+/// \param DATA2
+///    A 64-bit value is inserted into the 64-bit Data2 field.
+/// \param DATA1
+///    A 32-bit value is inserted into the 32-bit Data1 field.
+/// \param FLAGS
+///    A 32-bit immediate value is inserted into the 32-bit Flags field.
+/// \returns If the ring buffer is full and LWP is running in Synchronized Mode,
+///    the event record overwrites the last record in the buffer, the MissedEvents
+///    counter in the LWPCB is incremented, the head pointer is not advanced, and
+///    1 is returned. Otherwise 0 is returned.
+#define __lwpins64(DATA2, DATA1, FLAGS) \
+  (__builtin_ia32_lwpins64((unsigned long long) (DATA2), (unsigned int) (DATA1), \
+                           (unsigned int) (FLAGS)))
+
+/// Decrements the LWP programmed value sample event counter. If the result is
+///        negative, inserts an event record into the LWP event ring buffer in memory
+///        and advances the ring buffer pointer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> LWPVAL </c> instruction.
+///
+/// \param DATA2
+///    A 64-bit value is and inserted into the 64-bit Data2 field.
+/// \param DATA1
+///    A 32-bit value is inserted into the 32-bit Data1 field.
+/// \param FLAGS
+///    A 32-bit immediate value is inserted into the 32-bit Flags field.
+#define __lwpval64(DATA2, DATA1, FLAGS) \
+  (__builtin_ia32_lwpval64((unsigned long long) (DATA2), (unsigned int) (DATA1), \
+                           (unsigned int) (FLAGS)))
+
+#endif
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __LWPINTRIN_H */
diff --git a/third_party/intel/clang/lzcntintrin.h b/third_party/intel/clang/lzcntintrin.h
new file mode 100644
index 000000000..f4ddce9d0
--- /dev/null
+++ b/third_party/intel/clang/lzcntintrin.h
@@ -0,0 +1,104 @@
+/*===---- lzcntintrin.h - LZCNT intrinsics ---------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
+#error "Never use <lzcntintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __LZCNTINTRIN_H
+#define __LZCNTINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("lzcnt")))
+
+#ifndef _MSC_VER
+/// Counts the number of leading zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c LZCNT instruction.
+///
+/// \param __X
+///    An unsigned 16-bit integer whose leading zeros are to be counted.
+/// \returns An unsigned 16-bit integer containing the number of leading zero
+///    bits in the operand.
+#define __lzcnt16(X) __builtin_ia32_lzcnt_u16((unsigned short)(X))
+#endif // _MSC_VER
+
+/// Counts the number of leading zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c LZCNT instruction.
+///
+/// \param __X
+///    An unsigned 32-bit integer whose leading zeros are to be counted.
+/// \returns An unsigned 32-bit integer containing the number of leading zero
+///    bits in the operand.
+/// \see _lzcnt_u32
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__lzcnt32(unsigned int __X)
+{
+  return __builtin_ia32_lzcnt_u32(__X);
+}
+
+/// Counts the number of leading zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c LZCNT instruction.
+///
+/// \param __X
+///    An unsigned 32-bit integer whose leading zeros are to be counted.
+/// \returns An unsigned 32-bit integer containing the number of leading zero
+///    bits in the operand.
+/// \see __lzcnt32
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_lzcnt_u32(unsigned int __X)
+{
+  return __builtin_ia32_lzcnt_u32(__X);
+}
+
+#ifdef __x86_64__
+#ifndef _MSC_VER
+/// Counts the number of leading zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c LZCNT instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer whose leading zeros are to be counted.
+/// \returns An unsigned 64-bit integer containing the number of leading zero
+///    bits in the operand.
+/// \see _lzcnt_u64
+#define __lzcnt64(X) __builtin_ia32_lzcnt_u64((unsigned long long)(X))
+#endif // _MSC_VER
+
+/// Counts the number of leading zero bits in the operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c LZCNT instruction.
+///
+/// \param __X
+///    An unsigned 64-bit integer whose leading zeros are to be counted.
+/// \returns An unsigned 64-bit integer containing the number of leading zero
+///    bits in the operand.
+/// \see __lzcnt64
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+_lzcnt_u64(unsigned long long __X)
+{
+  return __builtin_ia32_lzcnt_u64(__X);
+}
+#endif
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __LZCNTINTRIN_H */
diff --git a/third_party/intel/clang/mm_malloc.h b/third_party/intel/clang/mm_malloc.h
new file mode 100644
index 000000000..d32fe5941
--- /dev/null
+++ b/third_party/intel/clang/mm_malloc.h
@@ -0,0 +1,67 @@
+/*===---- mm_malloc.h - Allocating and Freeing Aligned Memory Blocks -------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __MM_MALLOC_H
+#define __MM_MALLOC_H
+
+#include <stdlib.h>
+
+#ifdef _WIN32
+#include <malloc.h>
+#else
+#ifndef __cplusplus
+extern int posix_memalign(void **__memptr, size_t __alignment, size_t __size);
+#else
+// Some systems (e.g. those with GNU libc) declare posix_memalign with an
+// exception specifier. Via an "egregious workaround" in
+// Sema::CheckEquivalentExceptionSpec, Clang accepts the following as a valid
+// redeclaration of glibc's declaration.
+extern "C" int posix_memalign(void **__memptr, size_t __alignment, size_t __size);
+#endif
+#endif
+
+#if !(defined(_WIN32) && defined(_mm_malloc))
+static __inline__ void *__attribute__((__always_inline__, __nodebug__,
+                                       __malloc__, __alloc_size__(1),
+                                       __alloc_align__(2)))
+_mm_malloc(size_t __size, size_t __align) {
+  if (__align == 1) {
+    return malloc(__size);
+  }
+
+  if (!(__align & (__align - 1)) && __align < sizeof(void *))
+    __align = sizeof(void *);
+
+  void *__mallocedMemory;
+#if defined(__MINGW32__)
+  __mallocedMemory = __mingw_aligned_malloc(__size, __align);
+#elif defined(_WIN32)
+  __mallocedMemory = _aligned_malloc(__size, __align);
+#else
+  if (posix_memalign(&__mallocedMemory, __align, __size))
+    return 0;
+#endif
+
+  return __mallocedMemory;
+}
+
+static __inline__ void __attribute__((__always_inline__, __nodebug__))
+_mm_free(void *__p)
+{
+#if defined(__MINGW32__)
+  __mingw_aligned_free(__p);
+#elif defined(_WIN32)
+  _aligned_free(__p);
+#else
+  free(__p);
+#endif
+}
+#endif
+
+#endif /* __MM_MALLOC_H */
diff --git a/third_party/intel/clang/mmintrin.h b/third_party/intel/clang/mmintrin.h
new file mode 100644
index 000000000..4e154e2d8
--- /dev/null
+++ b/third_party/intel/clang/mmintrin.h
@@ -0,0 +1,1556 @@
+/*===---- mmintrin.h - MMX intrinsics --------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __MMINTRIN_H
+#define __MMINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+typedef long long __m64 __attribute__((__vector_size__(8), __aligned__(8)));
+
+typedef long long __v1di __attribute__((__vector_size__(8)));
+typedef int __v2si __attribute__((__vector_size__(8)));
+typedef short __v4hi __attribute__((__vector_size__(8)));
+typedef char __v8qi __attribute__((__vector_size__(8)));
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), \
+                 __min_vector_width__(64)))
+
+/// Clears the MMX state by setting the state of the x87 stack registers
+///    to empty.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> EMMS </c> instruction.
+///
+static __inline__ void __attribute__((__always_inline__, __nodebug__,
+                                      __target__("mmx,no-evex512")))
+_mm_empty(void) {
+  __builtin_ia32_emms();
+}
+
+/// Constructs a 64-bit integer vector, setting the lower 32 bits to the
+///    value of the 32-bit integer parameter and setting the upper 32 bits to 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVD </c> instruction.
+///
+/// \param __i
+///    A 32-bit integer value.
+/// \returns A 64-bit integer vector. The lower 32 bits contain the value of the
+///    parameter. The upper 32 bits are set to 0.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_cvtsi32_si64(int __i)
+{
+    return (__m64)__builtin_ia32_vec_init_v2si(__i, 0);
+}
+
+/// Returns the lower 32 bits of a 64-bit integer vector as a 32-bit
+///    signed integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVD </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector.
+/// \returns A 32-bit signed integer value containing the lower 32 bits of the
+///    parameter.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_cvtsi64_si32(__m64 __m)
+{
+    return __builtin_ia32_vec_ext_v2si((__v2si)__m, 0);
+}
+
+/// Casts a 64-bit signed integer value into a 64-bit integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVQ </c> instruction.
+///
+/// \param __i
+///    A 64-bit signed integer.
+/// \returns A 64-bit integer vector containing the same bitwise pattern as the
+///    parameter.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_cvtsi64_m64(long long __i)
+{
+    return (__m64)__i;
+}
+
+/// Casts a 64-bit integer vector into a 64-bit signed integer value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVQ </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector.
+/// \returns A 64-bit signed integer containing the same bitwise pattern as the
+///    parameter.
+static __inline__ long long __DEFAULT_FN_ATTRS
+_mm_cvtm64_si64(__m64 __m)
+{
+    return (long long)__m;
+}
+
+/// Converts, with saturation, 16-bit signed integers from both 64-bit integer
+///    vector parameters of [4 x i16] into 8-bit signed integer values, and
+///    constructs a 64-bit integer vector of [8 x i8] as the result.
+///
+///    Positive values greater than 0x7F are saturated to 0x7F. Negative values
+///    less than 0x80 are saturated to 0x80.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PACKSSWB </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16]. The converted [4 x i8] values are
+///    written to the lower 32 bits of the result.
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16]. The converted [4 x i8] values are
+///    written to the upper 32 bits of the result.
+/// \returns A 64-bit integer vector of [8 x i8] containing the converted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_packs_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_packsswb((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Converts, with saturation, 32-bit signed integers from both 64-bit integer
+///    vector parameters of [2 x i32] into 16-bit signed integer values, and
+///    constructs a 64-bit integer vector of [4 x i16] as the result.
+///
+///    Positive values greater than 0x7FFF are saturated to 0x7FFF. Negative
+///    values less than 0x8000 are saturated to 0x8000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PACKSSDW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [2 x i32]. The converted [2 x i16] values are
+///    written to the lower 32 bits of the result.
+/// \param __m2
+///    A 64-bit integer vector of [2 x i32]. The converted [2 x i16] values are
+///    written to the upper 32 bits of the result.
+/// \returns A 64-bit integer vector of [4 x i16] containing the converted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_packs_pi32(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_packssdw((__v2si)__m1, (__v2si)__m2);
+}
+
+/// Converts, with saturation, 16-bit signed integers from both 64-bit integer
+///    vector parameters of [4 x i16] into 8-bit unsigned integer values, and
+///    constructs a 64-bit integer vector of [8 x i8] as the result.
+///
+///    Values greater than 0xFF are saturated to 0xFF. Values less than 0 are
+///    saturated to 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PACKUSWB </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16]. The converted [4 x i8] values are
+///    written to the lower 32 bits of the result.
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16]. The converted [4 x i8] values are
+///    written to the upper 32 bits of the result.
+/// \returns A 64-bit integer vector of [8 x i8] containing the converted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_packs_pu16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_packuswb((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Unpacks the upper 32 bits from two 64-bit integer vectors of [8 x i8]
+///    and interleaves them into a 64-bit integer vector of [8 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PUNPCKHBW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [8 x i8]. \n
+///    Bits [39:32] are written to bits [7:0] of the result. \n
+///    Bits [47:40] are written to bits [23:16] of the result. \n
+///    Bits [55:48] are written to bits [39:32] of the result. \n
+///    Bits [63:56] are written to bits [55:48] of the result.
+/// \param __m2
+///    A 64-bit integer vector of [8 x i8].
+///    Bits [39:32] are written to bits [15:8] of the result. \n
+///    Bits [47:40] are written to bits [31:24] of the result. \n
+///    Bits [55:48] are written to bits [47:40] of the result. \n
+///    Bits [63:56] are written to bits [63:56] of the result.
+/// \returns A 64-bit integer vector of [8 x i8] containing the interleaved
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_unpackhi_pi8(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_punpckhbw((__v8qi)__m1, (__v8qi)__m2);
+}
+
+/// Unpacks the upper 32 bits from two 64-bit integer vectors of
+///    [4 x i16] and interleaves them into a 64-bit integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PUNPCKHWD </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16].
+///    Bits [47:32] are written to bits [15:0] of the result. \n
+///    Bits [63:48] are written to bits [47:32] of the result.
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16].
+///    Bits [47:32] are written to bits [31:16] of the result. \n
+///    Bits [63:48] are written to bits [63:48] of the result.
+/// \returns A 64-bit integer vector of [4 x i16] containing the interleaved
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_unpackhi_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_punpckhwd((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Unpacks the upper 32 bits from two 64-bit integer vectors of
+///    [2 x i32] and interleaves them into a 64-bit integer vector of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PUNPCKHDQ </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [2 x i32]. The upper 32 bits are written to
+///    the lower 32 bits of the result.
+/// \param __m2
+///    A 64-bit integer vector of [2 x i32]. The upper 32 bits are written to
+///    the upper 32 bits of the result.
+/// \returns A 64-bit integer vector of [2 x i32] containing the interleaved
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_unpackhi_pi32(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_punpckhdq((__v2si)__m1, (__v2si)__m2);
+}
+
+/// Unpacks the lower 32 bits from two 64-bit integer vectors of [8 x i8]
+///    and interleaves them into a 64-bit integer vector of [8 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PUNPCKLBW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [8 x i8].
+///    Bits [7:0] are written to bits [7:0] of the result. \n
+///    Bits [15:8] are written to bits [23:16] of the result. \n
+///    Bits [23:16] are written to bits [39:32] of the result. \n
+///    Bits [31:24] are written to bits [55:48] of the result.
+/// \param __m2
+///    A 64-bit integer vector of [8 x i8].
+///    Bits [7:0] are written to bits [15:8] of the result. \n
+///    Bits [15:8] are written to bits [31:24] of the result. \n
+///    Bits [23:16] are written to bits [47:40] of the result. \n
+///    Bits [31:24] are written to bits [63:56] of the result.
+/// \returns A 64-bit integer vector of [8 x i8] containing the interleaved
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_unpacklo_pi8(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_punpcklbw((__v8qi)__m1, (__v8qi)__m2);
+}
+
+/// Unpacks the lower 32 bits from two 64-bit integer vectors of
+///    [4 x i16] and interleaves them into a 64-bit integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PUNPCKLWD </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16].
+///    Bits [15:0] are written to bits [15:0] of the result. \n
+///    Bits [31:16] are written to bits [47:32] of the result.
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16].
+///    Bits [15:0] are written to bits [31:16] of the result. \n
+///    Bits [31:16] are written to bits [63:48] of the result.
+/// \returns A 64-bit integer vector of [4 x i16] containing the interleaved
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_unpacklo_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_punpcklwd((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Unpacks the lower 32 bits from two 64-bit integer vectors of
+///    [2 x i32] and interleaves them into a 64-bit integer vector of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PUNPCKLDQ </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [2 x i32]. The lower 32 bits are written to
+///    the lower 32 bits of the result.
+/// \param __m2
+///    A 64-bit integer vector of [2 x i32]. The lower 32 bits are written to
+///    the upper 32 bits of the result.
+/// \returns A 64-bit integer vector of [2 x i32] containing the interleaved
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_unpacklo_pi32(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_punpckldq((__v2si)__m1, (__v2si)__m2);
+}
+
+/// Adds each 8-bit integer element of the first 64-bit integer vector
+///    of [8 x i8] to the corresponding 8-bit integer element of the second
+///    64-bit integer vector of [8 x i8]. The lower 8 bits of the results are
+///    packed into a 64-bit integer vector of [8 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PADDB </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [8 x i8].
+/// \param __m2
+///    A 64-bit integer vector of [8 x i8].
+/// \returns A 64-bit integer vector of [8 x i8] containing the sums of both
+///    parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_add_pi8(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_paddb((__v8qi)__m1, (__v8qi)__m2);
+}
+
+/// Adds each 16-bit integer element of the first 64-bit integer vector
+///    of [4 x i16] to the corresponding 16-bit integer element of the second
+///    64-bit integer vector of [4 x i16]. The lower 16 bits of the results are
+///    packed into a 64-bit integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PADDW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16].
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16].
+/// \returns A 64-bit integer vector of [4 x i16] containing the sums of both
+///    parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_add_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_paddw((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Adds each 32-bit integer element of the first 64-bit integer vector
+///    of [2 x i32] to the corresponding 32-bit integer element of the second
+///    64-bit integer vector of [2 x i32]. The lower 32 bits of the results are
+///    packed into a 64-bit integer vector of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PADDD </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [2 x i32].
+/// \param __m2
+///    A 64-bit integer vector of [2 x i32].
+/// \returns A 64-bit integer vector of [2 x i32] containing the sums of both
+///    parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_add_pi32(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_paddd((__v2si)__m1, (__v2si)__m2);
+}
+
+/// Adds, with saturation, each 8-bit signed integer element of the first
+///    64-bit integer vector of [8 x i8] to the corresponding 8-bit signed
+///    integer element of the second 64-bit integer vector of [8 x i8].
+///
+///    Positive sums greater than 0x7F are saturated to 0x7F. Negative sums
+///    less than 0x80 are saturated to 0x80. The results are packed into a
+///    64-bit integer vector of [8 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PADDSB </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [8 x i8].
+/// \param __m2
+///    A 64-bit integer vector of [8 x i8].
+/// \returns A 64-bit integer vector of [8 x i8] containing the saturated sums
+///    of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_adds_pi8(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_paddsb((__v8qi)__m1, (__v8qi)__m2);
+}
+
+/// Adds, with saturation, each 16-bit signed integer element of the first
+///    64-bit integer vector of [4 x i16] to the corresponding 16-bit signed
+///    integer element of the second 64-bit integer vector of [4 x i16].
+///
+///    Positive sums greater than 0x7FFF are saturated to 0x7FFF. Negative sums
+///    less than 0x8000 are saturated to 0x8000. The results are packed into a
+///    64-bit integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PADDSW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16].
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16].
+/// \returns A 64-bit integer vector of [4 x i16] containing the saturated sums
+///    of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_adds_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_paddsw((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Adds, with saturation, each 8-bit unsigned integer element of the first
+///    64-bit integer vector of [8 x i8] to the corresponding 8-bit unsigned
+///    integer element of the second 64-bit integer vector of [8 x i8].
+///
+///    Sums greater than 0xFF are saturated to 0xFF. The results are packed
+///    into a 64-bit integer vector of [8 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PADDUSB </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [8 x i8].
+/// \param __m2
+///    A 64-bit integer vector of [8 x i8].
+/// \returns A 64-bit integer vector of [8 x i8] containing the saturated
+///    unsigned sums of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_adds_pu8(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_paddusb((__v8qi)__m1, (__v8qi)__m2);
+}
+
+/// Adds, with saturation, each 16-bit unsigned integer element of the first
+///    64-bit integer vector of [4 x i16] to the corresponding 16-bit unsigned
+///    integer element of the second 64-bit integer vector of [4 x i16].
+///
+///    Sums greater than 0xFFFF are saturated to 0xFFFF. The results are packed
+///    into a 64-bit integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PADDUSW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16].
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16].
+/// \returns A 64-bit integer vector of [4 x i16] containing the saturated
+///    unsigned sums of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_adds_pu16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_paddusw((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Subtracts each 8-bit integer element of the second 64-bit integer
+///    vector of [8 x i8] from the corresponding 8-bit integer element of the
+///    first 64-bit integer vector of [8 x i8]. The lower 8 bits of the results
+///    are packed into a 64-bit integer vector of [8 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSUBB </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [8 x i8] containing the minuends.
+/// \param __m2
+///    A 64-bit integer vector of [8 x i8] containing the subtrahends.
+/// \returns A 64-bit integer vector of [8 x i8] containing the differences of
+///    both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_sub_pi8(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_psubb((__v8qi)__m1, (__v8qi)__m2);
+}
+
+/// Subtracts each 16-bit integer element of the second 64-bit integer
+///    vector of [4 x i16] from the corresponding 16-bit integer element of the
+///    first 64-bit integer vector of [4 x i16]. The lower 16 bits of the
+///    results are packed into a 64-bit integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSUBW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16] containing the minuends.
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16] containing the subtrahends.
+/// \returns A 64-bit integer vector of [4 x i16] containing the differences of
+///    both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_sub_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_psubw((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Subtracts each 32-bit integer element of the second 64-bit integer
+///    vector of [2 x i32] from the corresponding 32-bit integer element of the
+///    first 64-bit integer vector of [2 x i32]. The lower 32 bits of the
+///    results are packed into a 64-bit integer vector of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSUBD </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [2 x i32] containing the minuends.
+/// \param __m2
+///    A 64-bit integer vector of [2 x i32] containing the subtrahends.
+/// \returns A 64-bit integer vector of [2 x i32] containing the differences of
+///    both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_sub_pi32(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_psubd((__v2si)__m1, (__v2si)__m2);
+}
+
+/// Subtracts, with saturation, each 8-bit signed integer element of the second
+///    64-bit integer vector of [8 x i8] from the corresponding 8-bit signed
+///    integer element of the first 64-bit integer vector of [8 x i8].
+///
+///    Positive results greater than 0x7F are saturated to 0x7F. Negative
+///    results less than 0x80 are saturated to 0x80. The results are packed
+///    into a 64-bit integer vector of [8 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSUBSB </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [8 x i8] containing the minuends.
+/// \param __m2
+///    A 64-bit integer vector of [8 x i8] containing the subtrahends.
+/// \returns A 64-bit integer vector of [8 x i8] containing the saturated
+///    differences of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_subs_pi8(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_psubsb((__v8qi)__m1, (__v8qi)__m2);
+}
+
+/// Subtracts, with saturation, each 16-bit signed integer element of the
+///    second 64-bit integer vector of [4 x i16] from the corresponding 16-bit
+///    signed integer element of the first 64-bit integer vector of [4 x i16].
+///
+///    Positive results greater than 0x7FFF are saturated to 0x7FFF. Negative
+///    results less than 0x8000 are saturated to 0x8000. The results are packed
+///    into a 64-bit integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSUBSW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16] containing the minuends.
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16] containing the subtrahends.
+/// \returns A 64-bit integer vector of [4 x i16] containing the saturated
+///    differences of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_subs_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_psubsw((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Subtracts each 8-bit unsigned integer element of the second 64-bit
+///    integer vector of [8 x i8] from the corresponding 8-bit unsigned integer
+///    element of the first 64-bit integer vector of [8 x i8].
+///
+///    If an element of the first vector is less than the corresponding element
+///    of the second vector, the result is saturated to 0. The results are
+///    packed into a 64-bit integer vector of [8 x i8].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSUBUSB </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [8 x i8] containing the minuends.
+/// \param __m2
+///    A 64-bit integer vector of [8 x i8] containing the subtrahends.
+/// \returns A 64-bit integer vector of [8 x i8] containing the saturated
+///    differences of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_subs_pu8(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_psubusb((__v8qi)__m1, (__v8qi)__m2);
+}
+
+/// Subtracts each 16-bit unsigned integer element of the second 64-bit
+///    integer vector of [4 x i16] from the corresponding 16-bit unsigned
+///    integer element of the first 64-bit integer vector of [4 x i16].
+///
+///    If an element of the first vector is less than the corresponding element
+///    of the second vector, the result is saturated to 0. The results are
+///    packed into a 64-bit integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSUBUSW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16] containing the minuends.
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16] containing the subtrahends.
+/// \returns A 64-bit integer vector of [4 x i16] containing the saturated
+///    differences of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_subs_pu16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_psubusw((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Multiplies each 16-bit signed integer element of the first 64-bit
+///    integer vector of [4 x i16] by the corresponding 16-bit signed integer
+///    element of the second 64-bit integer vector of [4 x i16] and get four
+///    32-bit products. Adds adjacent pairs of products to get two 32-bit sums.
+///    The lower 32 bits of these two sums are packed into a 64-bit integer
+///    vector of [2 x i32].
+///
+///    For example, bits [15:0] of both parameters are multiplied, bits [31:16]
+///    of both parameters are multiplied, and the sum of both results is written
+///    to bits [31:0] of the result.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PMADDWD </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16].
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16].
+/// \returns A 64-bit integer vector of [2 x i32] containing the sums of
+///    products of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_madd_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_pmaddwd((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Multiplies each 16-bit signed integer element of the first 64-bit
+///    integer vector of [4 x i16] by the corresponding 16-bit signed integer
+///    element of the second 64-bit integer vector of [4 x i16]. Packs the upper
+///    16 bits of the 32-bit products into a 64-bit integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PMULHW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16].
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16].
+/// \returns A 64-bit integer vector of [4 x i16] containing the upper 16 bits
+///    of the products of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_mulhi_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_pmulhw((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Multiplies each 16-bit signed integer element of the first 64-bit
+///    integer vector of [4 x i16] by the corresponding 16-bit signed integer
+///    element of the second 64-bit integer vector of [4 x i16]. Packs the lower
+///    16 bits of the 32-bit products into a 64-bit integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PMULLW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16].
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16].
+/// \returns A 64-bit integer vector of [4 x i16] containing the lower 16 bits
+///    of the products of both parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_mullo_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_pmullw((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Left-shifts each 16-bit signed integer element of the first
+///    parameter, which is a 64-bit integer vector of [4 x i16], by the number
+///    of bits specified by the second parameter, which is a 64-bit integer. The
+///    lower 16 bits of the results are packed into a 64-bit integer vector of
+///    [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSLLW </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [4 x i16].
+/// \param __count
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \returns A 64-bit integer vector of [4 x i16] containing the left-shifted
+///    values. If \a __count is greater or equal to 16, the result is set to all
+///    0.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_sll_pi16(__m64 __m, __m64 __count)
+{
+    return (__m64)__builtin_ia32_psllw((__v4hi)__m, __count);
+}
+
+/// Left-shifts each 16-bit signed integer element of a 64-bit integer
+///    vector of [4 x i16] by the number of bits specified by a 32-bit integer.
+///    The lower 16 bits of the results are packed into a 64-bit integer vector
+///    of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSLLW </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [4 x i16].
+/// \param __count
+///    A 32-bit integer value.
+/// \returns A 64-bit integer vector of [4 x i16] containing the left-shifted
+///    values. If \a __count is greater or equal to 16, the result is set to all
+///    0.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_slli_pi16(__m64 __m, int __count)
+{
+    return (__m64)__builtin_ia32_psllwi((__v4hi)__m, __count);
+}
+
+/// Left-shifts each 32-bit signed integer element of the first
+///    parameter, which is a 64-bit integer vector of [2 x i32], by the number
+///    of bits specified by the second parameter, which is a 64-bit integer. The
+///    lower 32 bits of the results are packed into a 64-bit integer vector of
+///    [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSLLD </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [2 x i32].
+/// \param __count
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \returns A 64-bit integer vector of [2 x i32] containing the left-shifted
+///    values. If \a __count is greater or equal to 32, the result is set to all
+///    0.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_sll_pi32(__m64 __m, __m64 __count)
+{
+    return (__m64)__builtin_ia32_pslld((__v2si)__m, __count);
+}
+
+/// Left-shifts each 32-bit signed integer element of a 64-bit integer
+///    vector of [2 x i32] by the number of bits specified by a 32-bit integer.
+///    The lower 32 bits of the results are packed into a 64-bit integer vector
+///    of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSLLD </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [2 x i32].
+/// \param __count
+///    A 32-bit integer value.
+/// \returns A 64-bit integer vector of [2 x i32] containing the left-shifted
+///    values. If \a __count is greater or equal to 32, the result is set to all
+///    0.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_slli_pi32(__m64 __m, int __count)
+{
+    return (__m64)__builtin_ia32_pslldi((__v2si)__m, __count);
+}
+
+/// Left-shifts the first 64-bit integer parameter by the number of bits
+///    specified by the second 64-bit integer parameter. The lower 64 bits of
+///    result are returned.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSLLQ </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \param __count
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \returns A 64-bit integer vector containing the left-shifted value. If
+///     \a __count is greater or equal to 64, the result is set to 0.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_sll_si64(__m64 __m, __m64 __count)
+{
+    return (__m64)__builtin_ia32_psllq((__v1di)__m, __count);
+}
+
+/// Left-shifts the first parameter, which is a 64-bit integer, by the
+///    number of bits specified by the second parameter, which is a 32-bit
+///    integer. The lower 64 bits of result are returned.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSLLQ </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \param __count
+///    A 32-bit integer value.
+/// \returns A 64-bit integer vector containing the left-shifted value. If
+///     \a __count is greater or equal to 64, the result is set to 0.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_slli_si64(__m64 __m, int __count)
+{
+    return (__m64)__builtin_ia32_psllqi((__v1di)__m, __count);
+}
+
+/// Right-shifts each 16-bit integer element of the first parameter,
+///    which is a 64-bit integer vector of [4 x i16], by the number of bits
+///    specified by the second parameter, which is a 64-bit integer.
+///
+///    High-order bits are filled with the sign bit of the initial value of each
+///    16-bit element. The 16-bit results are packed into a 64-bit integer
+///    vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSRAW </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [4 x i16].
+/// \param __count
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \returns A 64-bit integer vector of [4 x i16] containing the right-shifted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_sra_pi16(__m64 __m, __m64 __count)
+{
+    return (__m64)__builtin_ia32_psraw((__v4hi)__m, __count);
+}
+
+/// Right-shifts each 16-bit integer element of a 64-bit integer vector
+///    of [4 x i16] by the number of bits specified by a 32-bit integer.
+///
+///    High-order bits are filled with the sign bit of the initial value of each
+///    16-bit element. The 16-bit results are packed into a 64-bit integer
+///    vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSRAW </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [4 x i16].
+/// \param __count
+///    A 32-bit integer value.
+/// \returns A 64-bit integer vector of [4 x i16] containing the right-shifted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_srai_pi16(__m64 __m, int __count)
+{
+    return (__m64)__builtin_ia32_psrawi((__v4hi)__m, __count);
+}
+
+/// Right-shifts each 32-bit integer element of the first parameter,
+///    which is a 64-bit integer vector of [2 x i32], by the number of bits
+///    specified by the second parameter, which is a 64-bit integer.
+///
+///    High-order bits are filled with the sign bit of the initial value of each
+///    32-bit element. The 32-bit results are packed into a 64-bit integer
+///    vector of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSRAD </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [2 x i32].
+/// \param __count
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \returns A 64-bit integer vector of [2 x i32] containing the right-shifted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_sra_pi32(__m64 __m, __m64 __count)
+{
+    return (__m64)__builtin_ia32_psrad((__v2si)__m, __count);
+}
+
+/// Right-shifts each 32-bit integer element of a 64-bit integer vector
+///    of [2 x i32] by the number of bits specified by a 32-bit integer.
+///
+///    High-order bits are filled with the sign bit of the initial value of each
+///    32-bit element. The 32-bit results are packed into a 64-bit integer
+///    vector of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSRAD </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [2 x i32].
+/// \param __count
+///    A 32-bit integer value.
+/// \returns A 64-bit integer vector of [2 x i32] containing the right-shifted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_srai_pi32(__m64 __m, int __count)
+{
+    return (__m64)__builtin_ia32_psradi((__v2si)__m, __count);
+}
+
+/// Right-shifts each 16-bit integer element of the first parameter,
+///    which is a 64-bit integer vector of [4 x i16], by the number of bits
+///    specified by the second parameter, which is a 64-bit integer.
+///
+///    High-order bits are cleared. The 16-bit results are packed into a 64-bit
+///    integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSRLW </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [4 x i16].
+/// \param __count
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \returns A 64-bit integer vector of [4 x i16] containing the right-shifted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_srl_pi16(__m64 __m, __m64 __count)
+{
+    return (__m64)__builtin_ia32_psrlw((__v4hi)__m, __count);
+}
+
+/// Right-shifts each 16-bit integer element of a 64-bit integer vector
+///    of [4 x i16] by the number of bits specified by a 32-bit integer.
+///
+///    High-order bits are cleared. The 16-bit results are packed into a 64-bit
+///    integer vector of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSRLW </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [4 x i16].
+/// \param __count
+///    A 32-bit integer value.
+/// \returns A 64-bit integer vector of [4 x i16] containing the right-shifted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_srli_pi16(__m64 __m, int __count)
+{
+    return (__m64)__builtin_ia32_psrlwi((__v4hi)__m, __count);
+}
+
+/// Right-shifts each 32-bit integer element of the first parameter,
+///    which is a 64-bit integer vector of [2 x i32], by the number of bits
+///    specified by the second parameter, which is a 64-bit integer.
+///
+///    High-order bits are cleared. The 32-bit results are packed into a 64-bit
+///    integer vector of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSRLD </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [2 x i32].
+/// \param __count
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \returns A 64-bit integer vector of [2 x i32] containing the right-shifted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_srl_pi32(__m64 __m, __m64 __count)
+{
+    return (__m64)__builtin_ia32_psrld((__v2si)__m, __count);
+}
+
+/// Right-shifts each 32-bit integer element of a 64-bit integer vector
+///    of [2 x i32] by the number of bits specified by a 32-bit integer.
+///
+///    High-order bits are cleared. The 32-bit results are packed into a 64-bit
+///    integer vector of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSRLD </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector of [2 x i32].
+/// \param __count
+///    A 32-bit integer value.
+/// \returns A 64-bit integer vector of [2 x i32] containing the right-shifted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_srli_pi32(__m64 __m, int __count)
+{
+    return (__m64)__builtin_ia32_psrldi((__v2si)__m, __count);
+}
+
+/// Right-shifts the first 64-bit integer parameter by the number of bits
+///    specified by the second 64-bit integer parameter.
+///
+///    High-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSRLQ </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \param __count
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \returns A 64-bit integer vector containing the right-shifted value.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_srl_si64(__m64 __m, __m64 __count)
+{
+    return (__m64)__builtin_ia32_psrlq((__v1di)__m, __count);
+}
+
+/// Right-shifts the first parameter, which is a 64-bit integer, by the
+///    number of bits specified by the second parameter, which is a 32-bit
+///    integer.
+///
+///    High-order bits are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSRLQ </c> instruction.
+///
+/// \param __m
+///    A 64-bit integer vector interpreted as a single 64-bit integer.
+/// \param __count
+///    A 32-bit integer value.
+/// \returns A 64-bit integer vector containing the right-shifted value.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_srli_si64(__m64 __m, int __count)
+{
+    return (__m64)__builtin_ia32_psrlqi((__v1di)__m, __count);
+}
+
+/// Performs a bitwise AND of two 64-bit integer vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PAND </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector.
+/// \param __m2
+///    A 64-bit integer vector.
+/// \returns A 64-bit integer vector containing the bitwise AND of both
+///    parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_and_si64(__m64 __m1, __m64 __m2)
+{
+    return __builtin_ia32_pand((__v1di)__m1, (__v1di)__m2);
+}
+
+/// Performs a bitwise NOT of the first 64-bit integer vector, and then
+///    performs a bitwise AND of the intermediate result and the second 64-bit
+///    integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PANDN </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector. The one's complement of this parameter is used
+///    in the bitwise AND.
+/// \param __m2
+///    A 64-bit integer vector.
+/// \returns A 64-bit integer vector containing the bitwise AND of the second
+///    parameter and the one's complement of the first parameter.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_andnot_si64(__m64 __m1, __m64 __m2)
+{
+    return __builtin_ia32_pandn((__v1di)__m1, (__v1di)__m2);
+}
+
+/// Performs a bitwise OR of two 64-bit integer vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> POR </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector.
+/// \param __m2
+///    A 64-bit integer vector.
+/// \returns A 64-bit integer vector containing the bitwise OR of both
+///    parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_or_si64(__m64 __m1, __m64 __m2)
+{
+    return __builtin_ia32_por((__v1di)__m1, (__v1di)__m2);
+}
+
+/// Performs a bitwise exclusive OR of two 64-bit integer vectors.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PXOR </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector.
+/// \param __m2
+///    A 64-bit integer vector.
+/// \returns A 64-bit integer vector containing the bitwise exclusive OR of both
+///    parameters.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_xor_si64(__m64 __m1, __m64 __m2)
+{
+    return __builtin_ia32_pxor((__v1di)__m1, (__v1di)__m2);
+}
+
+/// Compares the 8-bit integer elements of two 64-bit integer vectors of
+///    [8 x i8] to determine if the element of the first vector is equal to the
+///    corresponding element of the second vector.
+///
+///    Each comparison returns 0 for false, 0xFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PCMPEQB </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [8 x i8].
+/// \param __m2
+///    A 64-bit integer vector of [8 x i8].
+/// \returns A 64-bit integer vector of [8 x i8] containing the comparison
+///    results.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_cmpeq_pi8(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_pcmpeqb((__v8qi)__m1, (__v8qi)__m2);
+}
+
+/// Compares the 16-bit integer elements of two 64-bit integer vectors of
+///    [4 x i16] to determine if the element of the first vector is equal to the
+///    corresponding element of the second vector.
+///
+///    Each comparison returns 0 for false, 0xFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PCMPEQW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16].
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16].
+/// \returns A 64-bit integer vector of [4 x i16] containing the comparison
+///    results.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_cmpeq_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_pcmpeqw((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Compares the 32-bit integer elements of two 64-bit integer vectors of
+///    [2 x i32] to determine if the element of the first vector is equal to the
+///    corresponding element of the second vector.
+///
+///    Each comparison returns 0 for false, 0xFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PCMPEQD </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [2 x i32].
+/// \param __m2
+///    A 64-bit integer vector of [2 x i32].
+/// \returns A 64-bit integer vector of [2 x i32] containing the comparison
+///    results.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_cmpeq_pi32(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_pcmpeqd((__v2si)__m1, (__v2si)__m2);
+}
+
+/// Compares the 8-bit integer elements of two 64-bit integer vectors of
+///    [8 x i8] to determine if the element of the first vector is greater than
+///    the corresponding element of the second vector.
+///
+///    Each comparison returns 0 for false, 0xFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PCMPGTB </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [8 x i8].
+/// \param __m2
+///    A 64-bit integer vector of [8 x i8].
+/// \returns A 64-bit integer vector of [8 x i8] containing the comparison
+///    results.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_cmpgt_pi8(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_pcmpgtb((__v8qi)__m1, (__v8qi)__m2);
+}
+
+/// Compares the 16-bit integer elements of two 64-bit integer vectors of
+///    [4 x i16] to determine if the element of the first vector is greater than
+///    the corresponding element of the second vector.
+///
+///    Each comparison returns 0 for false, 0xFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PCMPGTW </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [4 x i16].
+/// \param __m2
+///    A 64-bit integer vector of [4 x i16].
+/// \returns A 64-bit integer vector of [4 x i16] containing the comparison
+///    results.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_cmpgt_pi16(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_pcmpgtw((__v4hi)__m1, (__v4hi)__m2);
+}
+
+/// Compares the 32-bit integer elements of two 64-bit integer vectors of
+///    [2 x i32] to determine if the element of the first vector is greater than
+///    the corresponding element of the second vector.
+///
+///    Each comparison returns 0 for false, 0xFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PCMPGTD </c> instruction.
+///
+/// \param __m1
+///    A 64-bit integer vector of [2 x i32].
+/// \param __m2
+///    A 64-bit integer vector of [2 x i32].
+/// \returns A 64-bit integer vector of [2 x i32] containing the comparison
+///    results.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_cmpgt_pi32(__m64 __m1, __m64 __m2)
+{
+    return (__m64)__builtin_ia32_pcmpgtd((__v2si)__m1, (__v2si)__m2);
+}
+
+/// Constructs a 64-bit integer vector initialized to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PXOR </c> instruction.
+///
+/// \returns An initialized 64-bit integer vector with all elements set to zero.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_setzero_si64(void)
+{
+    return __extension__ (__m64){ 0LL };
+}
+
+/// Constructs a 64-bit integer vector initialized with the specified
+///    32-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __i1
+///    A 32-bit integer value used to initialize the upper 32 bits of the
+///    result.
+/// \param __i0
+///    A 32-bit integer value used to initialize the lower 32 bits of the
+///    result.
+/// \returns An initialized 64-bit integer vector.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_set_pi32(int __i1, int __i0)
+{
+    return (__m64)__builtin_ia32_vec_init_v2si(__i0, __i1);
+}
+
+/// Constructs a 64-bit integer vector initialized with the specified
+///    16-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __s3
+///    A 16-bit integer value used to initialize bits [63:48] of the result.
+/// \param __s2
+///    A 16-bit integer value used to initialize bits [47:32] of the result.
+/// \param __s1
+///    A 16-bit integer value used to initialize bits [31:16] of the result.
+/// \param __s0
+///    A 16-bit integer value used to initialize bits [15:0] of the result.
+/// \returns An initialized 64-bit integer vector.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_set_pi16(short __s3, short __s2, short __s1, short __s0)
+{
+    return (__m64)__builtin_ia32_vec_init_v4hi(__s0, __s1, __s2, __s3);
+}
+
+/// Constructs a 64-bit integer vector initialized with the specified
+///    8-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __b7
+///    An 8-bit integer value used to initialize bits [63:56] of the result.
+/// \param __b6
+///    An 8-bit integer value used to initialize bits [55:48] of the result.
+/// \param __b5
+///    An 8-bit integer value used to initialize bits [47:40] of the result.
+/// \param __b4
+///    An 8-bit integer value used to initialize bits [39:32] of the result.
+/// \param __b3
+///    An 8-bit integer value used to initialize bits [31:24] of the result.
+/// \param __b2
+///    An 8-bit integer value used to initialize bits [23:16] of the result.
+/// \param __b1
+///    An 8-bit integer value used to initialize bits [15:8] of the result.
+/// \param __b0
+///    An 8-bit integer value used to initialize bits [7:0] of the result.
+/// \returns An initialized 64-bit integer vector.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_set_pi8(char __b7, char __b6, char __b5, char __b4, char __b3, char __b2,
+            char __b1, char __b0)
+{
+    return (__m64)__builtin_ia32_vec_init_v8qi(__b0, __b1, __b2, __b3,
+                                               __b4, __b5, __b6, __b7);
+}
+
+/// Constructs a 64-bit integer vector of [2 x i32], with each of the
+///    32-bit integer vector elements set to the specified 32-bit integer
+///    value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __i
+///    A 32-bit integer value used to initialize each vector element of the
+///    result.
+/// \returns An initialized 64-bit integer vector of [2 x i32].
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_set1_pi32(int __i)
+{
+    return _mm_set_pi32(__i, __i);
+}
+
+/// Constructs a 64-bit integer vector of [4 x i16], with each of the
+///    16-bit integer vector elements set to the specified 16-bit integer
+///    value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __w
+///    A 16-bit integer value used to initialize each vector element of the
+///    result.
+/// \returns An initialized 64-bit integer vector of [4 x i16].
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_set1_pi16(short __w)
+{
+    return _mm_set_pi16(__w, __w, __w, __w);
+}
+
+/// Constructs a 64-bit integer vector of [8 x i8], with each of the
+///    8-bit integer vector elements set to the specified 8-bit integer value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __b
+///    An 8-bit integer value used to initialize each vector element of the
+///    result.
+/// \returns An initialized 64-bit integer vector of [8 x i8].
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_set1_pi8(char __b)
+{
+    return _mm_set_pi8(__b, __b, __b, __b, __b, __b, __b, __b);
+}
+
+/// Constructs a 64-bit integer vector, initialized in reverse order with
+///    the specified 32-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __i0
+///    A 32-bit integer value used to initialize the lower 32 bits of the
+///    result.
+/// \param __i1
+///    A 32-bit integer value used to initialize the upper 32 bits of the
+///    result.
+/// \returns An initialized 64-bit integer vector.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_setr_pi32(int __i0, int __i1)
+{
+    return _mm_set_pi32(__i1, __i0);
+}
+
+/// Constructs a 64-bit integer vector, initialized in reverse order with
+///    the specified 16-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __w0
+///    A 16-bit integer value used to initialize bits [15:0] of the result.
+/// \param __w1
+///    A 16-bit integer value used to initialize bits [31:16] of the result.
+/// \param __w2
+///    A 16-bit integer value used to initialize bits [47:32] of the result.
+/// \param __w3
+///    A 16-bit integer value used to initialize bits [63:48] of the result.
+/// \returns An initialized 64-bit integer vector.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_setr_pi16(short __w0, short __w1, short __w2, short __w3)
+{
+    return _mm_set_pi16(__w3, __w2, __w1, __w0);
+}
+
+/// Constructs a 64-bit integer vector, initialized in reverse order with
+///    the specified 8-bit integer values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __b0
+///    An 8-bit integer value used to initialize bits [7:0] of the result.
+/// \param __b1
+///    An 8-bit integer value used to initialize bits [15:8] of the result.
+/// \param __b2
+///    An 8-bit integer value used to initialize bits [23:16] of the result.
+/// \param __b3
+///    An 8-bit integer value used to initialize bits [31:24] of the result.
+/// \param __b4
+///    An 8-bit integer value used to initialize bits [39:32] of the result.
+/// \param __b5
+///    An 8-bit integer value used to initialize bits [47:40] of the result.
+/// \param __b6
+///    An 8-bit integer value used to initialize bits [55:48] of the result.
+/// \param __b7
+///    An 8-bit integer value used to initialize bits [63:56] of the result.
+/// \returns An initialized 64-bit integer vector.
+static __inline__ __m64 __DEFAULT_FN_ATTRS
+_mm_setr_pi8(char __b0, char __b1, char __b2, char __b3, char __b4, char __b5,
+             char __b6, char __b7)
+{
+    return _mm_set_pi8(__b7, __b6, __b5, __b4, __b3, __b2, __b1, __b0);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+/* Aliases for compatibility. */
+#define _m_empty _mm_empty
+#define _m_from_int _mm_cvtsi32_si64
+#define _m_from_int64 _mm_cvtsi64_m64
+#define _m_to_int _mm_cvtsi64_si32
+#define _m_to_int64 _mm_cvtm64_si64
+#define _m_packsswb _mm_packs_pi16
+#define _m_packssdw _mm_packs_pi32
+#define _m_packuswb _mm_packs_pu16
+#define _m_punpckhbw _mm_unpackhi_pi8
+#define _m_punpckhwd _mm_unpackhi_pi16
+#define _m_punpckhdq _mm_unpackhi_pi32
+#define _m_punpcklbw _mm_unpacklo_pi8
+#define _m_punpcklwd _mm_unpacklo_pi16
+#define _m_punpckldq _mm_unpacklo_pi32
+#define _m_paddb _mm_add_pi8
+#define _m_paddw _mm_add_pi16
+#define _m_paddd _mm_add_pi32
+#define _m_paddsb _mm_adds_pi8
+#define _m_paddsw _mm_adds_pi16
+#define _m_paddusb _mm_adds_pu8
+#define _m_paddusw _mm_adds_pu16
+#define _m_psubb _mm_sub_pi8
+#define _m_psubw _mm_sub_pi16
+#define _m_psubd _mm_sub_pi32
+#define _m_psubsb _mm_subs_pi8
+#define _m_psubsw _mm_subs_pi16
+#define _m_psubusb _mm_subs_pu8
+#define _m_psubusw _mm_subs_pu16
+#define _m_pmaddwd _mm_madd_pi16
+#define _m_pmulhw _mm_mulhi_pi16
+#define _m_pmullw _mm_mullo_pi16
+#define _m_psllw _mm_sll_pi16
+#define _m_psllwi _mm_slli_pi16
+#define _m_pslld _mm_sll_pi32
+#define _m_pslldi _mm_slli_pi32
+#define _m_psllq _mm_sll_si64
+#define _m_psllqi _mm_slli_si64
+#define _m_psraw _mm_sra_pi16
+#define _m_psrawi _mm_srai_pi16
+#define _m_psrad _mm_sra_pi32
+#define _m_psradi _mm_srai_pi32
+#define _m_psrlw _mm_srl_pi16
+#define _m_psrlwi _mm_srli_pi16
+#define _m_psrld _mm_srl_pi32
+#define _m_psrldi _mm_srli_pi32
+#define _m_psrlq _mm_srl_si64
+#define _m_psrlqi _mm_srli_si64
+#define _m_pand _mm_and_si64
+#define _m_pandn _mm_andnot_si64
+#define _m_por _mm_or_si64
+#define _m_pxor _mm_xor_si64
+#define _m_pcmpeqb _mm_cmpeq_pi8
+#define _m_pcmpeqw _mm_cmpeq_pi16
+#define _m_pcmpeqd _mm_cmpeq_pi32
+#define _m_pcmpgtb _mm_cmpgt_pi8
+#define _m_pcmpgtw _mm_cmpgt_pi16
+#define _m_pcmpgtd _mm_cmpgt_pi32
+
+#endif /* __MMINTRIN_H */
+
diff --git a/third_party/intel/clang/movdirintrin.h b/third_party/intel/clang/movdirintrin.h
new file mode 100644
index 000000000..30c4d02c8
--- /dev/null
+++ b/third_party/intel/clang/movdirintrin.h
@@ -0,0 +1,49 @@
+/*===------------------------- movdirintrin.h ------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
+#error "Never use <movdirintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef _MOVDIRINTRIN_H
+#define _MOVDIRINTRIN_H
+
+/* Move doubleword as direct store */
+static __inline__ void
+__attribute__((__always_inline__, __nodebug__,  __target__("movdiri")))
+_directstoreu_u32 (void *__dst, unsigned int  __value)
+{
+  __builtin_ia32_directstore_u32((unsigned int *)__dst, (unsigned int)__value);
+}
+
+#ifdef __x86_64__
+
+/* Move quadword as direct store */
+static __inline__ void
+__attribute__((__always_inline__, __nodebug__,  __target__("movdiri")))
+_directstoreu_u64 (void *__dst, unsigned long __value)
+{
+  __builtin_ia32_directstore_u64((unsigned long *)__dst, __value);
+}
+
+#endif /* __x86_64__ */
+
+/*
+ * movdir64b - Move 64 bytes as direct store.
+ * The destination must be 64 byte aligned, and the store is atomic.
+ * The source address has no alignment requirement, and the load from
+ * the source address is not atomic.
+ */
+static __inline__ void
+__attribute__((__always_inline__, __nodebug__,  __target__("movdir64b")))
+_movdir64b (void *__dst __attribute__((align_value(64))), const void *__src)
+{
+  __builtin_ia32_movdir64b(__dst, __src);
+}
+
+#endif /* _MOVDIRINTRIN_H */
diff --git a/third_party/intel/clang/mwaitxintrin.h b/third_party/intel/clang/mwaitxintrin.h
new file mode 100644
index 000000000..65f427105
--- /dev/null
+++ b/third_party/intel/clang/mwaitxintrin.h
@@ -0,0 +1,62 @@
+/*===---- mwaitxintrin.h - MONITORX/MWAITX intrinsics ----------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __X86INTRIN_H
+#error "Never use <mwaitxintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __MWAITXINTRIN_H
+#define __MWAITXINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__,  __target__("mwaitx")))
+
+/// Establishes a linear address memory range to be monitored and puts
+///    the processor in the monitor event pending state. Data stored in the
+///    monitored address range causes the processor to exit the pending state.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c MONITORX instruction.
+///
+/// \param __p
+///    The memory range to be monitored. The size of the range is determined by
+///    CPUID function 0000_0005h.
+/// \param __extensions
+///    Optional extensions for the monitoring state.
+/// \param __hints
+///    Optional hints for the monitoring state.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_monitorx(void * __p, unsigned __extensions, unsigned __hints)
+{
+  __builtin_ia32_monitorx(__p, __extensions, __hints);
+}
+
+/// Used with the \c MONITORX instruction to wait while the processor is in
+///    the monitor event pending state. Data stored in the monitored address
+///    range, or an interrupt, causes the processor to exit the pending state.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c MWAITX instruction.
+///
+/// \param __extensions
+///    Optional extensions for the monitoring state, which can vary by
+///    processor.
+/// \param __hints
+///    Optional hints for the monitoring state, which can vary by processor.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_mwaitx(unsigned __extensions, unsigned __hints, unsigned __clock)
+{
+  __builtin_ia32_mwaitx(__extensions, __hints, __clock);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __MWAITXINTRIN_H */
diff --git a/third_party/intel/clang/nmmintrin.h b/third_party/intel/clang/nmmintrin.h
new file mode 100644
index 000000000..d26d58eab
--- /dev/null
+++ b/third_party/intel/clang/nmmintrin.h
@@ -0,0 +1,20 @@
+/*===---- nmmintrin.h - SSE4 intrinsics ------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __NMMINTRIN_H
+#define __NMMINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+/* To match expectations of gcc we put the sse4.2 definitions into smmintrin.h,
+   just include it now then.  */
+#include "smmintrin.h"
+#endif /* __NMMINTRIN_H */
diff --git a/third_party/intel/clang/pconfigintrin.h b/third_party/intel/clang/pconfigintrin.h
new file mode 100644
index 000000000..d2014b026
--- /dev/null
+++ b/third_party/intel/clang/pconfigintrin.h
@@ -0,0 +1,40 @@
+/*===---- pconfigintrin.h - X86 platform configuration ---------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
+#error "Never use <pconfigintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __PCONFIGINTRIN_H
+#define __PCONFIGINTRIN_H
+
+#define __PCONFIG_KEY_PROGRAM 0x00000001
+
+#if __has_extension(gnu_asm)
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__,  __target__("pconfig")))
+
+static __inline unsigned int __DEFAULT_FN_ATTRS
+_pconfig_u32(unsigned int __leaf, __SIZE_TYPE__ __d[])
+{
+  unsigned int __result;
+  __asm__ ("pconfig"
+           : "=a" (__result), "=b" (__d[0]), "=c" (__d[1]), "=d" (__d[2])
+           : "a" (__leaf), "b" (__d[0]), "c" (__d[1]), "d" (__d[2])
+           : "cc");
+  return __result;
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __has_extension(gnu_asm) */
+
+#endif
diff --git a/third_party/intel/clang/pkuintrin.h b/third_party/intel/clang/pkuintrin.h
new file mode 100644
index 000000000..c62080bec
--- /dev/null
+++ b/third_party/intel/clang/pkuintrin.h
@@ -0,0 +1,34 @@
+/*===---- pkuintrin.h - PKU intrinsics -------------------------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <pkuintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __PKUINTRIN_H
+#define __PKUINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("pku")))
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_rdpkru_u32(void)
+{
+  return __builtin_ia32_rdpkru();
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_wrpkru(unsigned int __val)
+{
+  __builtin_ia32_wrpkru(__val);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/pmmintrin.h b/third_party/intel/clang/pmmintrin.h
new file mode 100644
index 000000000..6414e9e0c
--- /dev/null
+++ b/third_party/intel/clang/pmmintrin.h
@@ -0,0 +1,301 @@
+/*===---- pmmintrin.h - SSE3 intrinsics ------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __PMMINTRIN_H
+#define __PMMINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+#include "emmintrin.h"
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("sse3,no-evex512"), __min_vector_width__(128)))
+
+/// Loads data from an unaligned memory location to elements in a 128-bit
+///    vector.
+///
+///    If the address of the data is not 16-byte aligned, the instruction may
+///    read two adjacent aligned blocks of memory to retrieve the requested
+///    data.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VLDDQU </c> instruction.
+///
+/// \param __p
+///    A pointer to a 128-bit integer vector containing integer values.
+/// \returns A 128-bit vector containing the moved values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_lddqu_si128(__m128i_u const *__p)
+{
+  return (__m128i)__builtin_ia32_lddqu((char const *)__p);
+}
+
+/// Adds the even-indexed values and subtracts the odd-indexed values of
+///    two 128-bit vectors of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VADDSUBPS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the left source operand.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing the right source operand.
+/// \returns A 128-bit vector of [4 x float] containing the alternating sums and
+///    differences of both operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_addsub_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_addsubps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Horizontally adds the adjacent pairs of values contained in two
+///    128-bit vectors of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VHADDPS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+///    The horizontal sums of the values are stored in the lower bits of the
+///    destination.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+///    The horizontal sums of the values are stored in the upper bits of the
+///    destination.
+/// \returns A 128-bit vector of [4 x float] containing the horizontal sums of
+///    both operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_hadd_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_haddps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Horizontally subtracts the adjacent pairs of values contained in two
+///    128-bit vectors of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VHSUBPS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+///    The horizontal differences between the values are stored in the lower
+///    bits of the destination.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+///    The horizontal differences between the values are stored in the upper
+///    bits of the destination.
+/// \returns A 128-bit vector of [4 x float] containing the horizontal
+///    differences of both operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_hsub_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_hsubps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Moves and duplicates odd-indexed values from a 128-bit vector
+///    of [4 x float] to float values stored in a 128-bit vector of
+///    [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVSHDUP </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. \n
+///    Bits [127:96] of the source are written to bits [127:96] and [95:64] of
+///    the destination. \n
+///    Bits [63:32] of the source are written to bits [63:32] and [31:0] of the
+///    destination.
+/// \returns A 128-bit vector of [4 x float] containing the moved and duplicated
+///    values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_movehdup_ps(__m128 __a)
+{
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 1, 1, 3, 3);
+}
+
+/// Duplicates even-indexed values from a 128-bit vector of
+///    [4 x float] to float values stored in a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVSLDUP </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] \n
+///    Bits [95:64] of the source are written to bits [127:96] and [95:64] of
+///    the destination. \n
+///    Bits [31:0] of the source are written to bits [63:32] and [31:0] of the
+///    destination.
+/// \returns A 128-bit vector of [4 x float] containing the moved and duplicated
+///    values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_moveldup_ps(__m128 __a)
+{
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 0, 0, 2, 2);
+}
+
+/// Adds the even-indexed values and subtracts the odd-indexed values of
+///    two 128-bit vectors of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VADDSUBPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing the left source operand.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing the right source operand.
+/// \returns A 128-bit vector of [2 x double] containing the alternating sums
+///    and differences of both operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS
+_mm_addsub_pd(__m128d __a, __m128d __b)
+{
+  return __builtin_ia32_addsubpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Horizontally adds the pairs of values contained in two 128-bit
+///    vectors of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VHADDPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+///    The horizontal sum of the values is stored in the lower bits of the
+///    destination.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+///    The horizontal sum of the values is stored in the upper bits of the
+///    destination.
+/// \returns A 128-bit vector of [2 x double] containing the horizontal sums of
+///    both operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS
+_mm_hadd_pd(__m128d __a, __m128d __b)
+{
+  return __builtin_ia32_haddpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Horizontally subtracts the pairs of values contained in two 128-bit
+///    vectors of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VHSUBPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+///    The horizontal difference of the values is stored in the lower bits of
+///    the destination.
+/// \param __b
+///    A 128-bit vector of [2 x double] containing one of the source operands.
+///    The horizontal difference of the values is stored in the upper bits of
+///    the destination.
+/// \returns A 128-bit vector of [2 x double] containing the horizontal
+///    differences of both operands.
+static __inline__ __m128d __DEFAULT_FN_ATTRS
+_mm_hsub_pd(__m128d __a, __m128d __b)
+{
+  return __builtin_ia32_hsubpd((__v2df)__a, (__v2df)__b);
+}
+
+/// Moves and duplicates one double-precision value to double-precision
+///    values stored in a 128-bit vector of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_loaddup_pd(double const *dp);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VMOVDDUP </c> instruction.
+///
+/// \param dp
+///    A pointer to a double-precision value to be moved and duplicated.
+/// \returns A 128-bit vector of [2 x double] containing the moved and
+///    duplicated values.
+#define        _mm_loaddup_pd(dp)        _mm_load1_pd(dp)
+
+/// Moves and duplicates the double-precision value in the lower bits of
+///    a 128-bit vector of [2 x double] to double-precision values stored in a
+///    128-bit vector of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVDDUP </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [2 x double]. Bits [63:0] are written to bits
+///    [127:64] and [63:0] of the destination.
+/// \returns A 128-bit vector of [2 x double] containing the moved and
+///    duplicated values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS
+_mm_movedup_pd(__m128d __a)
+{
+  return __builtin_shufflevector((__v2df)__a, (__v2df)__a, 0, 0);
+}
+
+/// Establishes a linear address memory range to be monitored and puts
+///    the processor in the monitor event pending state. Data stored in the
+///    monitored address range causes the processor to exit the pending state.
+///
+/// The \c MONITOR instruction can be used in kernel mode, and in other modes
+/// if MSR <c> C001_0015h[MonMwaitUserEn] </c> is set.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c MONITOR instruction.
+///
+/// \param __p
+///    The memory range to be monitored. The size of the range is determined by
+///    CPUID function 0000_0005h.
+/// \param __extensions
+///    Optional extensions for the monitoring state.
+/// \param __hints
+///    Optional hints for the monitoring state.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_monitor(void const *__p, unsigned __extensions, unsigned __hints)
+{
+  __builtin_ia32_monitor(__p, __extensions, __hints);
+}
+
+/// Used with the \c MONITOR instruction to wait while the processor is in
+///    the monitor event pending state. Data stored in the monitored address
+///    range, or an interrupt, causes the processor to exit the pending state.
+///
+/// The \c MWAIT instruction can be used in kernel mode, and in other modes if
+/// MSR <c> C001_0015h[MonMwaitUserEn] </c> is set.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c MWAIT instruction.
+///
+/// \param __extensions
+///    Optional extensions for the monitoring state, which can vary by
+///    processor.
+/// \param __hints
+///    Optional hints for the monitoring state, which can vary by processor.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_mwait(unsigned __extensions, unsigned __hints)
+{
+  __builtin_ia32_mwait(__extensions, __hints);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __PMMINTRIN_H */
diff --git a/third_party/intel/clang/popcntintrin.h b/third_party/intel/clang/popcntintrin.h
new file mode 100644
index 000000000..0aa94aecd
--- /dev/null
+++ b/third_party/intel/clang/popcntintrin.h
@@ -0,0 +1,59 @@
+/*===---- popcntintrin.h - POPCNT intrinsics -------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __POPCNTINTRIN_H
+#define __POPCNTINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("popcnt")))
+
+#if defined(__cplusplus) && (__cplusplus >= 201103L)
+#define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS constexpr
+#else
+#define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS
+#endif
+
+/// Counts the number of bits in the source operand having a value of 1.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> POPCNT </c> instruction.
+///
+/// \param __A
+///    An unsigned 32-bit integer operand.
+/// \returns A 32-bit integer containing the number of bits with value 1 in the
+///    source operand.
+static __inline__ int __DEFAULT_FN_ATTRS_CONSTEXPR
+_mm_popcnt_u32(unsigned int __A)
+{
+  return __builtin_popcount(__A);
+}
+
+#ifdef __x86_64__
+/// Counts the number of bits in the source operand having a value of 1.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> POPCNT </c> instruction.
+///
+/// \param __A
+///    An unsigned 64-bit integer operand.
+/// \returns A 64-bit integer containing the number of bits with value 1 in the
+///    source operand.
+static __inline__ long long __DEFAULT_FN_ATTRS_CONSTEXPR
+_mm_popcnt_u64(unsigned long long __A)
+{
+  return __builtin_popcountll(__A);
+}
+#endif /* __x86_64__ */
+
+#undef __DEFAULT_FN_ATTRS
+#undef __DEFAULT_FN_ATTRS_CONSTEXPR
+
+#endif /* __POPCNTINTRIN_H */
diff --git a/third_party/intel/clang/prfchiintrin.h b/third_party/intel/clang/prfchiintrin.h
new file mode 100644
index 000000000..36600b25a
--- /dev/null
+++ b/third_party/intel/clang/prfchiintrin.h
@@ -0,0 +1,61 @@
+/*===---- prfchiintrin.h - PREFETCHI intrinsic -----------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __PRFCHIINTRIN_H
+#define __PRFCHIINTRIN_H
+
+#ifdef __x86_64__
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__, __target__("prefetchi")))
+
+/// Loads an instruction sequence containing the specified memory address into
+///    all level cache.
+///
+///    Note that the effect of this intrinsic is dependent on the processor
+///    implementation.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PREFETCHIT0 instruction.
+///
+/// \param __P
+///    A pointer specifying the memory address to be prefetched.
+static __inline__ void __DEFAULT_FN_ATTRS
+_m_prefetchit0(volatile const void *__P) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcast-qual"
+  __builtin_ia32_prefetchi((const void *)__P, 3 /* _MM_HINT_T0 */);
+#pragma clang diagnostic pop
+}
+
+/// Loads an instruction sequence containing the specified memory address into
+///    all but the first-level cache.
+///
+///    Note that the effect of this intrinsic is dependent on the processor
+///    implementation.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PREFETCHIT1 instruction.
+///
+/// \param __P
+///    A pointer specifying the memory address to be prefetched.
+static __inline__ void __DEFAULT_FN_ATTRS
+_m_prefetchit1(volatile const void *__P) {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcast-qual"
+  __builtin_ia32_prefetchi((const void *)__P, 2 /* _MM_HINT_T1 */);
+#pragma clang diagnostic pop
+}
+#endif /* __x86_64__ */
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __PRFCHWINTRIN_H */
diff --git a/third_party/intel/clang/prfchwintrin.h b/third_party/intel/clang/prfchwintrin.h
new file mode 100644
index 000000000..eaea5f3cf
--- /dev/null
+++ b/third_party/intel/clang/prfchwintrin.h
@@ -0,0 +1,60 @@
+/*===---- prfchwintrin.h - PREFETCHW intrinsic -----------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined(__X86INTRIN_H) && !defined(_MM3DNOW_H_INCLUDED)
+#error "Never use <prfchwintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __PRFCHWINTRIN_H
+#define __PRFCHWINTRIN_H
+
+/// Loads a memory sequence containing the specified memory address into
+///    all data cache levels.
+///
+///    The cache-coherency state is set to exclusive. Data can be read from
+///    and written to the cache line without additional delay.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PREFETCHT0 instruction.
+///
+/// \param __P
+///    A pointer specifying the memory address to be prefetched.
+static __inline__ void __attribute__((__always_inline__, __nodebug__))
+_m_prefetch(void *__P)
+{
+  __builtin_prefetch (__P, 0, 3 /* _MM_HINT_T0 */);
+}
+
+/// Loads a memory sequence containing the specified memory address into
+///    the L1 data cache and sets the cache-coherency state to modified.
+///
+///    This provides a hint to the processor that the cache line will be
+///    modified. It is intended for use when the cache line will be written to
+///    shortly after the prefetch is performed.
+///
+///    Note that the effect of this intrinsic is dependent on the processor
+///    implementation.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PREFETCHW instruction.
+///
+/// \param __P
+///    A pointer specifying the memory address to be prefetched.
+static __inline__ void __attribute__((__always_inline__, __nodebug__))
+_m_prefetchw(volatile const void *__P)
+{
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcast-qual"
+  __builtin_prefetch ((const void*)__P, 1, 3 /* _MM_HINT_T0 */);
+#pragma clang diagnostic pop
+}
+
+#endif /* __PRFCHWINTRIN_H */
diff --git a/third_party/intel/clang/ptwriteintrin.h b/third_party/intel/clang/ptwriteintrin.h
new file mode 100644
index 000000000..0a04f7c1d
--- /dev/null
+++ b/third_party/intel/clang/ptwriteintrin.h
@@ -0,0 +1,37 @@
+/*===------------ ptwriteintrin.h - PTWRITE intrinsic --------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
+#error "Never use <ptwriteintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __PTWRITEINTRIN_H
+#define __PTWRITEINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__,  __target__("ptwrite")))
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_ptwrite32(unsigned int __value) {
+  __builtin_ia32_ptwrite32(__value);
+}
+
+#ifdef __x86_64__
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_ptwrite64(unsigned long long __value) {
+  __builtin_ia32_ptwrite64(__value);
+}
+
+#endif /* __x86_64__ */
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __PTWRITEINTRIN_H */
diff --git a/third_party/intel/clang/raointintrin.h b/third_party/intel/clang/raointintrin.h
new file mode 100644
index 000000000..d3290eb62
--- /dev/null
+++ b/third_party/intel/clang/raointintrin.h
@@ -0,0 +1,203 @@
+/*===----------------------- raointintrin.h - RAOINT ------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __X86GPRINTRIN_H
+#error "Never use <raointintrin.h> directly; include <x86gprintrin.h> instead."
+#endif // __X86GPRINTRIN_H
+
+#ifndef __RAOINTINTRIN_H
+#define __RAOINTINTRIN_H
+
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__, __target__("raoint")))
+
+/// Atomically add a 32-bit value at memory operand \a __A and a 32-bit \a __B,
+///    and store the result to the same memory location.
+///
+///    This intrinsic should be used for contention or weak ordering. It may
+///    result in bad performance for hot data used by single thread only.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c AADD instruction.
+///
+/// \param __A
+///    A pointer to a 32-bit memory location.
+/// \param __B
+///    A 32-bit integer value.
+///
+/// \code{.operation}
+/// MEM[__A+31:__A] := MEM[__A+31:__A] + __B[31:0]
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS _aadd_i32(int *__A, int __B) {
+  __builtin_ia32_aadd32((int *)__A, __B);
+}
+
+/// Atomically and a 32-bit value at memory operand \a __A and a 32-bit \a __B,
+///    and store the result to the same memory location.
+///
+///    This intrinsic should be used for contention or weak ordering. It may
+///    result in bad performance for hot data used by single thread only.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c AAND instruction.
+///
+/// \param __A
+///    A pointer to a 32-bit memory location.
+/// \param __B
+///    A 32-bit integer value.
+///
+/// \code{.operation}
+/// MEM[__A+31:__A] := MEM[__A+31:__A] AND __B[31:0]
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS _aand_i32(int *__A, int __B) {
+  __builtin_ia32_aand32((int *)__A, __B);
+}
+
+/// Atomically or a 32-bit value at memory operand \a __A and a 32-bit \a __B,
+///    and store the result to the same memory location.
+///
+///    This intrinsic should be used for contention or weak ordering. It may
+///    result in bad performance for hot data used by single thread only.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c AOR instruction.
+///
+/// \param __A
+///    A pointer to a 32-bit memory location.
+/// \param __B
+///    A 32-bit integer value.
+///
+/// \code{.operation}
+/// MEM[__A+31:__A] := MEM[__A+31:__A] OR __B[31:0]
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS _aor_i32(int *__A, int __B) {
+  __builtin_ia32_aor32((int *)__A, __B);
+}
+
+/// Atomically xor a 32-bit value at memory operand \a __A and a 32-bit \a __B,
+///    and store the result to the same memory location.
+///
+///    This intrinsic should be used for contention or weak ordering. It may
+///    result in bad performance for hot data used by single thread only.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c AXOR instruction.
+///
+/// \param __A
+///    A pointer to a 32-bit memory location.
+/// \param __B
+///    A 32-bit integer value.
+///
+/// \code{.operation}
+/// MEM[__A+31:__A] := MEM[__A+31:__A] XOR __B[31:0]
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS _axor_i32(int *__A, int __B) {
+  __builtin_ia32_axor32((int *)__A, __B);
+}
+
+#ifdef __x86_64__
+/// Atomically add a 64-bit value at memory operand \a __A and a 64-bit \a __B,
+///    and store the result to the same memory location.
+///
+///    This intrinsic should be used for contention or weak ordering. It may
+///    result in bad performance for hot data used by single thread only.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c AADD instruction.
+///
+/// \param __A
+///    A pointer to a 64-bit memory location.
+/// \param __B
+///    A 64-bit integer value.
+///
+/// \code{.operation}
+/// MEM[__A+63:__A] := MEM[__A+63:__A] + __B[63:0]
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS _aadd_i64(long long *__A,
+                                                    long long __B) {
+  __builtin_ia32_aadd64((long long *)__A, __B);
+}
+
+/// Atomically and a 64-bit value at memory operand \a __A and a 64-bit \a __B,
+///    and store the result to the same memory location.
+///
+///    This intrinsic should be used for contention or weak ordering. It may
+///    result in bad performance for hot data used by single thread only.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c AAND instruction.
+///
+/// \param __A
+///    A pointer to a 64-bit memory location.
+/// \param __B
+///    A 64-bit integer value.
+///
+/// \code{.operation}
+/// MEM[__A+63:__A] := MEM[__A+63:__A] AND __B[63:0]
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS _aand_i64(long long *__A,
+                                                    long long __B) {
+  __builtin_ia32_aand64((long long *)__A, __B);
+}
+
+/// Atomically or a 64-bit value at memory operand \a __A and a 64-bit \a __B,
+///    and store the result to the same memory location.
+///
+///    This intrinsic should be used for contention or weak ordering. It may
+///    result in bad performance for hot data used by single thread only.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c AOR instruction.
+///
+/// \param __A
+///    A pointer to a 64-bit memory location.
+/// \param __B
+///    A 64-bit integer value.
+///
+/// \code{.operation}
+/// MEM[__A+63:__A] := MEM[__A+63:__A] OR __B[63:0]
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS _aor_i64(long long *__A,
+                                                   long long __B) {
+  __builtin_ia32_aor64((long long *)__A, __B);
+}
+
+/// Atomically xor a 64-bit value at memory operand \a __A and a 64-bit \a __B,
+///    and store the result to the same memory location.
+///
+///    This intrinsic should be used for contention or weak ordering. It may
+///    result in bad performance for hot data used by single thread only.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c AXOR instruction.
+///
+/// \param __A
+///    A pointer to a 64-bit memory location.
+/// \param __B
+///    A 64-bit integer value.
+///
+/// \code{.operation}
+/// MEM[__A+63:__A] := MEM[__A+63:__A] XOR __B[63:0]
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS _axor_i64(long long *__A,
+                                                    long long __B) {
+  __builtin_ia32_axor64((long long *)__A, __B);
+}
+#endif // __x86_64__
+
+#undef __DEFAULT_FN_ATTRS
+#endif // __RAOINTINTRIN_H
diff --git a/third_party/intel/clang/rdpruintrin.h b/third_party/intel/clang/rdpruintrin.h
new file mode 100644
index 000000000..89732bb8b
--- /dev/null
+++ b/third_party/intel/clang/rdpruintrin.h
@@ -0,0 +1,57 @@
+/*===---- rdpruintrin.h - RDPRU intrinsics ---------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined __X86INTRIN_H
+#error "Never use <rdpruintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __RDPRUINTRIN_H
+#define __RDPRUINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__,  __target__("rdpru")))
+
+
+/// Reads the content of a processor register.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> RDPRU </c> instruction.
+///
+/// \param reg_id
+///    A processor register identifier.
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__rdpru (int reg_id)
+{
+  return __builtin_ia32_rdpru(reg_id);
+}
+
+#define __RDPRU_MPERF 0
+#define __RDPRU_APERF 1
+
+/// Reads the content of processor register MPERF.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic generates instruction <c> RDPRU </c> to read the value of
+/// register MPERF.
+#define __mperf() __builtin_ia32_rdpru(__RDPRU_MPERF)
+
+/// Reads the content of processor register APERF.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic generates instruction <c> RDPRU </c> to read the value of
+/// register APERF.
+#define __aperf() __builtin_ia32_rdpru(__RDPRU_APERF)
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __RDPRUINTRIN_H */
diff --git a/third_party/intel/clang/rdseedintrin.h b/third_party/intel/clang/rdseedintrin.h
new file mode 100644
index 000000000..8a4fe0930
--- /dev/null
+++ b/third_party/intel/clang/rdseedintrin.h
@@ -0,0 +1,105 @@
+/*===---- rdseedintrin.h - RDSEED intrinsics -------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <rdseedintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __RDSEEDINTRIN_H
+#define __RDSEEDINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("rdseed")))
+
+/// Stores a hardware-generated 16-bit random value in the memory at \a __p.
+///
+///    The random number generator complies with NIST SP800-90B and SP800-90C.
+///
+/// \code{.operation}
+/// IF HW_NRND_GEN.ready == 1
+///   Store16(__p, HW_NRND_GEN.data)
+///   result := 1
+/// ELSE
+///   Store16(__p, 0)
+///   result := 0
+/// END
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c RDSEED instruction.
+///
+/// \param __p
+///    Pointer to memory for storing the 16-bit random number.
+/// \returns 1 if a random number was generated, 0 if not.
+static __inline__ int __DEFAULT_FN_ATTRS
+_rdseed16_step(unsigned short *__p)
+{
+  return (int) __builtin_ia32_rdseed16_step(__p);
+}
+
+/// Stores a hardware-generated 32-bit random value in the memory at \a __p.
+///
+///    The random number generator complies with NIST SP800-90B and SP800-90C.
+///
+/// \code{.operation}
+/// IF HW_NRND_GEN.ready == 1
+///   Store32(__p, HW_NRND_GEN.data)
+///   result := 1
+/// ELSE
+///   Store32(__p, 0)
+///   result := 0
+/// END
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c RDSEED instruction.
+///
+/// \param __p
+///    Pointer to memory for storing the 32-bit random number.
+/// \returns 1 if a random number was generated, 0 if not.
+static __inline__ int __DEFAULT_FN_ATTRS
+_rdseed32_step(unsigned int *__p)
+{
+  return (int) __builtin_ia32_rdseed32_step(__p);
+}
+
+#ifdef __x86_64__
+/// Stores a hardware-generated 64-bit random value in the memory at \a __p.
+///
+///    The random number generator complies with NIST SP800-90B and SP800-90C.
+///
+/// \code{.operation}
+/// IF HW_NRND_GEN.ready == 1
+///   Store64(__p, HW_NRND_GEN.data)
+///   result := 1
+/// ELSE
+///   Store64(__p, 0)
+///   result := 0
+/// END
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c RDSEED instruction.
+///
+/// \param __p
+///    Pointer to memory for storing the 64-bit random number.
+/// \returns 1 if a random number was generated, 0 if not.
+static __inline__ int __DEFAULT_FN_ATTRS
+_rdseed64_step(unsigned long long *__p)
+{
+  return (int) __builtin_ia32_rdseed64_step(__p);
+}
+#endif
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __RDSEEDINTRIN_H */
diff --git a/third_party/intel/clang/rtmintrin.h b/third_party/intel/clang/rtmintrin.h
new file mode 100644
index 000000000..a3ec81e3f
--- /dev/null
+++ b/third_party/intel/clang/rtmintrin.h
@@ -0,0 +1,45 @@
+/*===---- rtmintrin.h - RTM intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <rtmintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __RTMINTRIN_H
+#define __RTMINTRIN_H
+
+#define _XBEGIN_STARTED   (~0u)
+#define _XABORT_EXPLICIT  (1 << 0)
+#define _XABORT_RETRY     (1 << 1)
+#define _XABORT_CONFLICT  (1 << 2)
+#define _XABORT_CAPACITY  (1 << 3)
+#define _XABORT_DEBUG     (1 << 4)
+#define _XABORT_NESTED    (1 << 5)
+#define _XABORT_CODE(x)   (((x) >> 24) & 0xFF)
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("rtm")))
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+_xbegin(void)
+{
+  return (unsigned int)__builtin_ia32_xbegin();
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_xend(void)
+{
+  __builtin_ia32_xend();
+}
+
+#define _xabort(imm) __builtin_ia32_xabort((imm))
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __RTMINTRIN_H */
diff --git a/third_party/intel/clang/serializeintrin.h b/third_party/intel/clang/serializeintrin.h
new file mode 100644
index 000000000..b774e5a24
--- /dev/null
+++ b/third_party/intel/clang/serializeintrin.h
@@ -0,0 +1,30 @@
+/*===--------------- serializeintrin.h - serialize intrinsics --------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <serializeintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __SERIALIZEINTRIN_H
+#define __SERIALIZEINTRIN_H
+
+/// Serialize instruction fetch and execution.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> SERIALIZE </c> instruction.
+///
+static __inline__ void
+__attribute__((__always_inline__, __nodebug__, __target__("serialize")))
+_serialize (void)
+{
+  __builtin_ia32_serialize ();
+}
+
+#endif /* __SERIALIZEINTRIN_H */
diff --git a/third_party/intel/clang/sgxintrin.h b/third_party/intel/clang/sgxintrin.h
new file mode 100644
index 000000000..303a21f6b
--- /dev/null
+++ b/third_party/intel/clang/sgxintrin.h
@@ -0,0 +1,60 @@
+/*===---- sgxintrin.h - X86 SGX intrinsics configuration -------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
+#error "Never use <sgxintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __SGXINTRIN_H
+#define __SGXINTRIN_H
+
+#if __has_extension(gnu_asm)
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__,  __target__("sgx")))
+
+static __inline unsigned int __DEFAULT_FN_ATTRS
+_enclu_u32(unsigned int __leaf, __SIZE_TYPE__ __d[])
+{
+  unsigned int __result;
+  __asm__ ("enclu"
+           : "=a" (__result), "=b" (__d[0]), "=c" (__d[1]), "=d" (__d[2])
+           : "a" (__leaf), "b" (__d[0]), "c" (__d[1]), "d" (__d[2])
+           : "cc");
+  return __result;
+}
+
+static __inline unsigned int __DEFAULT_FN_ATTRS
+_encls_u32(unsigned int __leaf, __SIZE_TYPE__ __d[])
+{
+  unsigned int __result;
+  __asm__ ("encls"
+           : "=a" (__result), "=b" (__d[0]), "=c" (__d[1]), "=d" (__d[2])
+           : "a" (__leaf), "b" (__d[0]), "c" (__d[1]), "d" (__d[2])
+           : "cc");
+  return __result;
+}
+
+static __inline unsigned int __DEFAULT_FN_ATTRS
+_enclv_u32(unsigned int __leaf, __SIZE_TYPE__ __d[])
+{
+  unsigned int __result;
+  __asm__ ("enclv"
+           : "=a" (__result), "=b" (__d[0]), "=c" (__d[1]), "=d" (__d[2])
+           : "a" (__leaf), "b" (__d[0]), "c" (__d[1]), "d" (__d[2])
+           : "cc");
+  return __result;
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __has_extension(gnu_asm) */
+
+#endif
diff --git a/third_party/intel/clang/sha512intrin.h b/third_party/intel/clang/sha512intrin.h
new file mode 100644
index 000000000..065ef5dac
--- /dev/null
+++ b/third_party/intel/clang/sha512intrin.h
@@ -0,0 +1,200 @@
+/*===--------------- sha512intrin.h - SHA512 intrinsics -----------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <sha512intrin.h> directly; include <immintrin.h> instead."
+#endif // __IMMINTRIN_H
+
+#ifndef __SHA512INTRIN_H
+#define __SHA512INTRIN_H
+
+#define __DEFAULT_FN_ATTRS256                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("sha512"),         \
+                 __min_vector_width__(256)))
+
+/// This intrinisc is one of the two SHA512 message scheduling instructions.
+///    The intrinsic performs an intermediate calculation for the next four
+///    SHA512 message qwords. The calculated results are stored in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_sha512msg1_epi64(__m256i __A, __m128i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VSHA512MSG1 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [4 x long long].
+/// \param __B
+///    A 128-bit vector of [2 x long long].
+/// \returns
+///    A 256-bit vector of [4 x long long].
+///
+/// \code{.operation}
+/// DEFINE ROR64(qword, n) {
+/// 	count := n % 64
+/// 	dest := (qword >> count) | (qword << (64 - count))
+/// 	RETURN dest
+/// }
+/// DEFINE SHR64(qword, n) {
+/// 	RETURN qword >> n
+/// }
+/// DEFINE s0(qword):
+/// 	RETURN ROR64(qword,1) ^ ROR64(qword, 8) ^ SHR64(qword, 7)
+/// }
+/// W[4] := __B.qword[0]
+/// W[3] := __A.qword[3]
+/// W[2] := __A.qword[2]
+/// W[1] := __A.qword[1]
+/// W[0] := __A.qword[0]
+/// dst.qword[3] := W[3] + s0(W[4])
+/// dst.qword[2] := W[2] + s0(W[3])
+/// dst.qword[1] := W[1] + s0(W[2])
+/// dst.qword[0] := W[0] + s0(W[1])
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sha512msg1_epi64(__m256i __A, __m128i __B) {
+  return (__m256i)__builtin_ia32_vsha512msg1((__v4du)__A, (__v2du)__B);
+}
+
+/// This intrinisc is one of the two SHA512 message scheduling instructions.
+///    The intrinsic performs the final calculation for the next four SHA512
+///    message qwords. The calculated results are stored in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_sha512msg2_epi64(__m256i __A, __m256i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VSHA512MSG2 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [4 x long long].
+/// \param __B
+///    A 256-bit vector of [4 x long long].
+/// \returns
+///    A 256-bit vector of [4 x long long].
+///
+/// \code{.operation}
+/// DEFINE ROR64(qword, n) {
+/// 	count := n % 64
+/// 	dest := (qword >> count) | (qword << (64 - count))
+/// 	RETURN dest
+/// }
+/// DEFINE SHR64(qword, n) {
+/// 	RETURN qword >> n
+/// }
+/// DEFINE s1(qword) {
+/// 	RETURN ROR64(qword,19) ^ ROR64(qword, 61) ^ SHR64(qword, 6)
+/// }
+/// W[14] := __B.qword[2]
+/// W[15] := __B.qword[3]
+/// W[16] := __A.qword[0] + s1(W[14])
+/// W[17] := __A.qword[1] + s1(W[15])
+/// W[18] := __A.qword[2] + s1(W[16])
+/// W[19] := __A.qword[3] + s1(W[17])
+/// dst.qword[3] := W[19]
+/// dst.qword[2] := W[18]
+/// dst.qword[1] := W[17]
+/// dst.qword[0] := W[16]
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sha512msg2_epi64(__m256i __A, __m256i __B) {
+  return (__m256i)__builtin_ia32_vsha512msg2((__v4du)__A, (__v4du)__B);
+}
+
+/// This intrinisc performs two rounds of SHA512 operation using initial SHA512
+///    state (C,D,G,H) from \a __A, an initial SHA512 state (A,B,E,F) from
+///    \a __A, and a pre-computed sum of the next two round message qwords and
+///    the corresponding round constants from \a __C (only the two lower qwords
+///    of the third operand). The updated SHA512 state (A,B,E,F) is written to
+///    \a __A, and \a __A can be used as the updated state (C,D,G,H) in later
+///    rounds.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_sha512rnds2_epi64(__m256i __A, __m256i __B, __m128i __C)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VSHA512RNDS2 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [4 x long long].
+/// \param __B
+///    A 256-bit vector of [4 x long long].
+/// \param __C
+///    A 128-bit vector of [2 x long long].
+/// \returns
+///    A 256-bit vector of [4 x long long].
+///
+/// \code{.operation}
+/// DEFINE ROR64(qword, n) {
+/// 	count := n % 64
+/// 	dest := (qword >> count) | (qword << (64 - count))
+/// 	RETURN dest
+/// }
+/// DEFINE SHR64(qword, n) {
+/// 	RETURN qword >> n
+/// }
+/// DEFINE cap_sigma0(qword) {
+/// 	RETURN ROR64(qword,28) ^ ROR64(qword, 34) ^ ROR64(qword, 39)
+/// }
+/// DEFINE cap_sigma1(qword) {
+/// 	RETURN ROR64(qword,14) ^ ROR64(qword, 18) ^ ROR64(qword, 41)
+/// }
+/// DEFINE MAJ(a,b,c) {
+/// 	RETURN (a & b) ^ (a & c) ^ (b & c)
+/// }
+/// DEFINE CH(e,f,g) {
+/// 	RETURN (e & f) ^ (g & ~e)
+/// }
+/// A[0] := __B.qword[3]
+/// B[0] := __B.qword[2]
+/// C[0] := __C.qword[3]
+/// D[0] := __C.qword[2]
+/// E[0] := __B.qword[1]
+/// F[0] := __B.qword[0]
+/// G[0] := __C.qword[1]
+/// H[0] := __C.qword[0]
+/// WK[0]:= __A.qword[0]
+/// WK[1]:= __A.qword[1]
+/// FOR i := 0 to 1:
+/// 	A[i+1] := CH(E[i], F[i], G[i]) +
+/// 	cap_sigma1(E[i]) + WK[i] + H[i] +
+/// 	MAJ(A[i], B[i], C[i]) +
+/// 	cap_sigma0(A[i])
+/// 	B[i+1] := A[i]
+/// 	C[i+1] := B[i]
+/// 	D[i+1] := C[i]
+/// 	E[i+1] := CH(E[i], F[i], G[i]) +
+/// 	cap_sigma1(E[i]) + WK[i] + H[i] + D[i]
+/// 	F[i+1] := E[i]
+/// 	G[i+1] := F[i]
+/// 	H[i+1] := G[i]
+/// ENDFOR
+/// dst.qword[3] := A[2]
+/// dst.qword[2] := B[2]
+/// dst.qword[1] := E[2]
+/// dst.qword[0] := F[2]
+/// dst[MAX:256] := 0
+/// \endcode
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_sha512rnds2_epi64(__m256i __A, __m256i __B, __m128i __C) {
+  return (__m256i)__builtin_ia32_vsha512rnds2((__v4du)__A, (__v4du)__B,
+                                              (__v2du)__C);
+}
+
+#undef __DEFAULT_FN_ATTRS256
+
+#endif // __SHA512INTRIN_H
diff --git a/third_party/intel/clang/shaintrin.h b/third_party/intel/clang/shaintrin.h
new file mode 100644
index 000000000..232e1fa29
--- /dev/null
+++ b/third_party/intel/clang/shaintrin.h
@@ -0,0 +1,189 @@
+/*===---- shaintrin.h - SHA intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <shaintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __SHAINTRIN_H
+#define __SHAINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sha"), __min_vector_width__(128)))
+
+/// Performs four iterations of the inner loop of the SHA-1 message digest
+///    algorithm using the starting SHA-1 state (A, B, C, D) from the 128-bit
+///    vector of [4 x i32] in \a V1 and the next four 32-bit elements of the
+///    message from the 128-bit vector of [4 x i32] in \a V2. Note that the
+///    SHA-1 state variable E must have already been added to \a V2
+///    (\c _mm_sha1nexte_epu32() can perform this step). Returns the updated
+///    SHA-1 state (A, B, C, D) as a 128-bit vector of [4 x i32].
+///
+///    The SHA-1 algorithm has an inner loop of 80 iterations, twenty each
+///    with a different combining function and rounding constant. This
+///    intrinsic performs four iterations using a combining function and
+///    rounding constant selected by \a M[1:0].
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_sha1rnds4_epu32(__m128i V1, __m128i V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c SHA1RNDS4 instruction.
+///
+/// \param V1
+///    A 128-bit vector of [4 x i32] containing the initial SHA-1 state.
+/// \param V2
+///    A 128-bit vector of [4 x i32] containing the next four elements of
+///    the message, plus SHA-1 state variable E.
+/// \param M
+///    An immediate value where bits [1:0] select among four possible
+///    combining functions and rounding constants (not specified here).
+/// \returns A 128-bit vector of [4 x i32] containing the updated SHA-1 state.
+#define _mm_sha1rnds4_epu32(V1, V2, M) \
+  __builtin_ia32_sha1rnds4((__v4si)(__m128i)(V1), (__v4si)(__m128i)(V2), (M))
+
+/// Calculates the SHA-1 state variable E from the SHA-1 state variables in
+///    the 128-bit vector of [4 x i32] in \a __X, adds that to the next set of
+///    four message elements in the 128-bit vector of [4 x i32] in \a __Y, and
+///    returns the result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c SHA1NEXTE instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] containing the current SHA-1 state.
+/// \param __Y
+///    A 128-bit vector of [4 x i32] containing the next four elements of the
+///    message.
+/// \returns A 128-bit vector of [4 x i32] containing the updated SHA-1
+///    values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sha1nexte_epu32(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_sha1nexte((__v4si)__X, (__v4si)__Y);
+}
+
+/// Performs an intermediate calculation for deriving the next four SHA-1
+///    message elements using previous message elements from the 128-bit
+///    vectors of [4 x i32] in \a __X and \a __Y, and returns the result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c SHA1MSG1 instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] containing previous message elements.
+/// \param __Y
+///    A 128-bit vector of [4 x i32] containing previous message elements.
+/// \returns A 128-bit vector of [4 x i32] containing the derived SHA-1
+///    elements.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sha1msg1_epu32(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_sha1msg1((__v4si)__X, (__v4si)__Y);
+}
+
+/// Performs the final calculation for deriving the next four SHA-1 message
+///    elements using previous message elements from the 128-bit vectors of
+///    [4 x i32] in \a __X and \a __Y, and returns the result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c SHA1MSG2 instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] containing an intermediate result.
+/// \param __Y
+///    A 128-bit vector of [4 x i32] containing previous message values.
+/// \returns A 128-bit vector of [4 x i32] containing the updated SHA-1
+///    values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sha1msg2_epu32(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_sha1msg2((__v4si)__X, (__v4si)__Y);
+}
+
+/// Performs two rounds of SHA-256 operation using the following inputs: a
+///    starting SHA-256 state (C, D, G, H) from the 128-bit vector of
+///    [4 x i32] in \a __X; a starting SHA-256 state (A, B, E, F) from the
+///    128-bit vector of [4 x i32] in \a __Y; and a pre-computed sum of the
+///    next two message elements (unsigned 32-bit integers) and corresponding
+///    rounding constants from the 128-bit vector of [4 x i32] in \a __Z.
+///    Returns the updated SHA-256 state (A, B, E, F) as a 128-bit vector of
+///    [4 x i32].
+///
+///    The SHA-256 algorithm has a core loop of 64 iterations. This intrinsic
+///    performs two of those iterations.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c SHA256RNDS2 instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] containing part of the initial SHA-256
+///    state.
+/// \param __Y
+///    A 128-bit vector of [4 x i32] containing part of the initial SHA-256
+///    state.
+/// \param __Z
+///    A 128-bit vector of [4 x i32] containing additional input to the
+///    SHA-256 operation.
+/// \returns A 128-bit vector of [4 x i32] containing the updated SHA-1 state.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sha256rnds2_epu32(__m128i __X, __m128i __Y, __m128i __Z)
+{
+  return (__m128i)__builtin_ia32_sha256rnds2((__v4si)__X, (__v4si)__Y, (__v4si)__Z);
+}
+
+/// Performs an intermediate calculation for deriving the next four SHA-256
+///    message elements using previous message elements from the 128-bit
+///    vectors of [4 x i32] in \a __X and \a __Y, and returns the result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c SHA256MSG1 instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] containing previous message elements.
+/// \param __Y
+///    A 128-bit vector of [4 x i32] containing previous message elements.
+/// \returns A 128-bit vector of [4 x i32] containing the updated SHA-256
+///    values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sha256msg1_epu32(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_sha256msg1((__v4si)__X, (__v4si)__Y);
+}
+
+/// Performs the final calculation for deriving the next four SHA-256 message
+///    elements using previous message elements from the 128-bit vectors of
+///    [4 x i32] in \a __X and \a __Y, and returns the result.
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c SHA256MSG2 instruction.
+///
+/// \param __X
+///    A 128-bit vector of [4 x i32] containing an intermediate result.
+/// \param __Y
+///    A 128-bit vector of [4 x i32] containing previous message values.
+/// \returns A 128-bit vector of [4 x i32] containing the updated SHA-256
+///    values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sha256msg2_epu32(__m128i __X, __m128i __Y)
+{
+  return (__m128i)__builtin_ia32_sha256msg2((__v4si)__X, (__v4si)__Y);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __SHAINTRIN_H */
diff --git a/third_party/intel/clang/sm3intrin.h b/third_party/intel/clang/sm3intrin.h
new file mode 100644
index 000000000..8a3d8bc9e
--- /dev/null
+++ b/third_party/intel/clang/sm3intrin.h
@@ -0,0 +1,238 @@
+/*===-------------------- sm3intrin.h - SM3 intrinsics ---------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <sm3intrin.h> directly; include <immintrin.h> instead."
+#endif // __IMMINTRIN_H
+
+#ifndef __SM3INTRIN_H
+#define __SM3INTRIN_H
+
+#define __DEFAULT_FN_ATTRS128                                                  \
+  __attribute__((__always_inline__, __nodebug__, __target__("sm3"),            \
+                 __min_vector_width__(128)))
+
+/// This intrinisc is one of the two SM3 message scheduling intrinsics. The
+///    intrinsic performs an initial calculation for the next four SM3 message
+///    words. The calculated results are stored in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_sm3msg1_epi32(__m128i __A, __m128i __B, __m128i __C)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VSM3MSG1 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x int].
+/// \param __B
+///    A 128-bit vector of [4 x int].
+/// \param __C
+///    A 128-bit vector of [4 x int].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// DEFINE ROL32(dword, n) {
+/// 	count := n % 32
+/// 	dest := (dword << count) | (dword >> (32 - count))
+/// 	RETURN dest
+/// }
+/// DEFINE P1(x) {
+/// 	RETURN x ^ ROL32(x, 15) ^ ROL32(x, 23)
+/// }
+/// W[0] := __C.dword[0]
+/// W[1] := __C.dword[1]
+/// W[2] := __C.dword[2]
+/// W[3] := __C.dword[3]
+/// W[7] := __A.dword[0]
+/// W[8] := __A.dword[1]
+/// W[9] := __A.dword[2]
+/// W[10] := __A.dword[3]
+/// W[13] := __B.dword[0]
+/// W[14] := __B.dword[1]
+/// W[15] := __B.dword[2]
+/// TMP0 := W[7] ^ W[0] ^ ROL32(W[13], 15)
+/// TMP1 := W[8] ^ W[1] ^ ROL32(W[14], 15)
+/// TMP2 := W[9] ^ W[2] ^ ROL32(W[15], 15)
+/// TMP3 := W[10] ^ W[3]
+/// dst.dword[0] := P1(TMP0)
+/// dst.dword[1] := P1(TMP1)
+/// dst.dword[2] := P1(TMP2)
+/// dst.dword[3] := P1(TMP3)
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_sm3msg1_epi32(__m128i __A,
+                                                                  __m128i __B,
+                                                                  __m128i __C) {
+  return (__m128i)__builtin_ia32_vsm3msg1((__v4su)__A, (__v4su)__B,
+                                          (__v4su)__C);
+}
+
+/// This intrinisc is one of the two SM3 message scheduling intrinsics. The
+///    intrinsic performs the final calculation for the next four SM3 message
+///    words. The calculated results are stored in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_sm3msg2_epi32(__m128i __A, __m128i __B, __m128i __C)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VSM3MSG2 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x int].
+/// \param __B
+///    A 128-bit vector of [4 x int].
+/// \param __C
+///    A 128-bit vector of [4 x int].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// DEFINE ROL32(dword, n) {
+/// 	count := n % 32
+/// 	dest := (dword << count) | (dword >> (32-count))
+/// 	RETURN dest
+/// }
+/// WTMP[0] := __A.dword[0]
+/// WTMP[1] := __A.dword[1]
+/// WTMP[2] := __A.dword[2]
+/// WTMP[3] := __A.dword[3]
+/// W[3] := __B.dword[0]
+/// W[4] := __B.dword[1]
+/// W[5] := __B.dword[2]
+/// W[6] := __B.dword[3]
+/// W[10] := __C.dword[0]
+/// W[11] := __C.dword[1]
+/// W[12] := __C.dword[2]
+/// W[13] := __C.dword[3]
+/// W[16] := ROL32(W[3], 7) ^ W[10] ^ WTMP[0]
+/// W[17] := ROL32(W[4], 7) ^ W[11] ^ WTMP[1]
+/// W[18] := ROL32(W[5], 7) ^ W[12] ^ WTMP[2]
+/// W[19] := ROL32(W[6], 7) ^ W[13] ^ WTMP[3]
+/// W[19] := W[19] ^ ROL32(W[16], 6) ^ ROL32(W[16], 15) ^ ROL32(W[16], 30)
+/// dst.dword[0] := W[16]
+/// dst.dword[1] := W[17]
+/// dst.dword[2] := W[18]
+/// dst.dword[3] := W[19]
+/// dst[MAX:128] := 0
+/// \endcode
+static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_sm3msg2_epi32(__m128i __A,
+                                                                  __m128i __B,
+                                                                  __m128i __C) {
+  return (__m128i)__builtin_ia32_vsm3msg2((__v4su)__A, (__v4su)__B,
+                                          (__v4su)__C);
+}
+
+/// This intrinsic performs two rounds of SM3 operation using initial SM3 state
+///    (C, D, G, H) from \a __A, an initial SM3 states (A, B, E, F)
+///    from \a __B and a pre-computed words from the \a __C. \a __A with
+///    initial SM3 state of (C, D, G, H) assumes input of non-rotated left
+///    variables from previous state. The updated SM3 state (A, B, E, F) is
+///    written to \a __A. The \a imm8 should contain the even round number
+///    for the first of the two rounds computed by this instruction. The
+///    computation masks the \a imm8 value by AND’ing it with 0x3E so that only
+///    even round numbers from 0 through 62 are used for this operation. The
+///    calculated results are stored in \a dst.
+///
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_sm3rnds2_epi32(__m128i __A, __m128i __B, __m128i __C, const int
+/// imm8) \endcode
+///
+/// This intrinsic corresponds to the \c VSM3RNDS2 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x int].
+/// \param __B
+///    A 128-bit vector of [4 x int].
+/// \param __C
+///    A 128-bit vector of [4 x int].
+/// \param imm8
+///    A 8-bit constant integer.
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// DEFINE ROL32(dword, n) {
+/// 	count := n % 32
+/// 	dest := (dword << count) | (dword >> (32-count))
+/// 	RETURN dest
+/// }
+/// DEFINE P0(dword) {
+/// 	RETURN dword ^ ROL32(dword, 9) ^ ROL32(dword, 17)
+/// }
+/// DEFINE FF(x,y,z, round){
+/// 	IF round < 16
+/// 		RETURN (x ^ y ^ z)
+/// 	ELSE
+/// 		RETURN (x & y) | (x & z) | (y & z)
+/// 	FI
+/// }
+/// DEFINE GG(x, y, z, round){
+///   IF round < 16
+///   	RETURN (x ^ y ^ z)
+///   ELSE
+///   	RETURN (x & y) | (~x & z)
+///   FI
+/// }
+/// A[0] := __B.dword[3]
+/// B[0] := __B.dword[2]
+/// C[0] := __A.dword[3]
+/// D[0] := __A.dword[2]
+/// E[0] := __B.dword[1]
+/// F[0] := __B.dword[0]
+/// G[0] := __A.dword[1]
+/// H[0] := __A.dword[0]
+/// W[0] := __C.dword[0]
+/// W[1] := __C.dword[1]
+/// W[4] := __C.dword[2]
+/// W[5] := __C.dword[3]
+/// C[0] := ROL32(C[0], 9)
+/// D[0] := ROL32(D[0], 9)
+/// G[0] := ROL32(G[0], 19)
+/// H[0] := ROL32(H[0], 19)
+/// ROUND := __D & 0x3E
+/// IF ROUND < 16
+/// 	CONST := 0x79CC4519
+/// ELSE
+/// 	CONST := 0x7A879D8A
+/// FI
+/// CONST := ROL32(CONST,ROUND)
+/// FOR i:= 0 to 1
+/// 	S1 := ROL32((ROL32(A[i], 12) + E[i] + CONST), 7)
+/// 	S2 := S1 ^ ROL32(A[i], 12)
+/// 	T1 := FF(A[i], B[i], C[i], ROUND) + D[i] + S2 + (W[i] ^ W[i+4])
+/// 	T2 := GG(E[i], F[i], G[i], ROUND) + H[i] + S1 + W[i]
+/// 	D[i+1] := C[i]
+/// 	C[i+1] := ROL32(B[i],9)
+/// 	B[i+1] := A[i]
+/// 	A[i+1] := T1
+/// 	H[i+1] := G[i]
+/// 	G[i+1] := ROL32(F[i], 19)
+/// 	F[i+1] := E[i]
+/// 	E[i+1] := P0(T2)
+/// 	CONST := ROL32(CONST, 1)
+/// ENDFOR
+/// dst.dword[3] := A[2]
+/// dst.dword[2] := B[2]
+/// dst.dword[1] := E[2]
+/// dst.dword[0] := F[2]
+/// dst[MAX:128] := 0
+/// \endcode
+#define _mm_sm3rnds2_epi32(A, B, C, D)                                         \
+  (__m128i) __builtin_ia32_vsm3rnds2((__v4su)A, (__v4su)B, (__v4su)C, (int)D)
+
+#undef __DEFAULT_FN_ATTRS128
+
+#endif // __SM3INTRIN_H
diff --git a/third_party/intel/clang/sm4intrin.h b/third_party/intel/clang/sm4intrin.h
new file mode 100644
index 000000000..47aeec46a
--- /dev/null
+++ b/third_party/intel/clang/sm4intrin.h
@@ -0,0 +1,269 @@
+/*===--------------- sm4intrin.h - SM4 intrinsics -----------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <sm4intrin.h> directly; include <immintrin.h> instead."
+#endif // __IMMINTRIN_H
+
+#ifndef __SM4INTRIN_H
+#define __SM4INTRIN_H
+
+/// This intrinsic performs four rounds of SM4 key expansion. The intrinsic
+///    operates on independent 128-bit lanes. The calculated results are
+///    stored in \a dst.
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_sm4key4_epi32(__m128i __A, __m128i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VSM4KEY4 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x int].
+/// \param __B
+///    A 128-bit vector of [4 x int].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// DEFINE ROL32(dword, n) {
+/// 	count := n % 32
+/// 	dest := (dword << count) | (dword >> (32-count))
+/// 	RETURN dest
+/// }
+/// DEFINE SBOX_BYTE(dword, i) {
+/// 	RETURN sbox[dword.byte[i]]
+/// }
+/// DEFINE lower_t(dword) {
+/// 	tmp.byte[0] := SBOX_BYTE(dword, 0)
+/// 	tmp.byte[1] := SBOX_BYTE(dword, 1)
+/// 	tmp.byte[2] := SBOX_BYTE(dword, 2)
+/// 	tmp.byte[3] := SBOX_BYTE(dword, 3)
+/// 	RETURN tmp
+/// }
+/// DEFINE L_KEY(dword) {
+/// 	RETURN dword ^ ROL32(dword, 13) ^ ROL32(dword, 23)
+/// }
+/// DEFINE T_KEY(dword) {
+/// 	RETURN L_KEY(lower_t(dword))
+/// }
+/// DEFINE F_KEY(X0, X1, X2, X3, round_key) {
+/// 	RETURN X0 ^ T_KEY(X1 ^ X2 ^ X3 ^ round_key)
+/// }
+/// FOR i:= 0 to 0
+/// 	P[0] := __B.xmm[i].dword[0]
+/// 	P[1] := __B.xmm[i].dword[1]
+/// 	P[2] := __B.xmm[i].dword[2]
+/// 	P[3] := __B.xmm[i].dword[3]
+/// 	C[0] := F_KEY(P[0], P[1], P[2], P[3], __A.xmm[i].dword[0])
+/// 	C[1] := F_KEY(P[1], P[2], P[3], C[0], __A.xmm[i].dword[1])
+/// 	C[2] := F_KEY(P[2], P[3], C[0], C[1], __A.xmm[i].dword[2])
+/// 	C[3] := F_KEY(P[3], C[0], C[1], C[2], __A.xmm[i].dword[3])
+/// 	DEST.xmm[i].dword[0] := C[0]
+/// 	DEST.xmm[i].dword[1] := C[1]
+/// 	DEST.xmm[i].dword[2] := C[2]
+/// 	DEST.xmm[i].dword[3] := C[3]
+/// ENDFOR
+/// DEST[MAX:128] := 0
+/// \endcode
+#define _mm_sm4key4_epi32(A, B)                                                \
+  (__m128i) __builtin_ia32_vsm4key4128((__v4su)A, (__v4su)B)
+
+/// This intrinsic performs four rounds of SM4 key expansion. The intrinsic
+///    operates on independent 128-bit lanes. The calculated results are
+///    stored in \a dst.
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_sm4key4_epi32(__m256i __A, __m256i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VSM4KEY4 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x int].
+/// \param __B
+///    A 256-bit vector of [8 x int].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// DEFINE ROL32(dword, n) {
+/// 	count := n % 32
+/// 	dest := (dword << count) | (dword >> (32-count))
+/// 	RETURN dest
+/// }
+/// DEFINE SBOX_BYTE(dword, i) {
+/// 	RETURN sbox[dword.byte[i]]
+/// }
+/// DEFINE lower_t(dword) {
+/// 	tmp.byte[0] := SBOX_BYTE(dword, 0)
+/// 	tmp.byte[1] := SBOX_BYTE(dword, 1)
+/// 	tmp.byte[2] := SBOX_BYTE(dword, 2)
+/// 	tmp.byte[3] := SBOX_BYTE(dword, 3)
+/// 	RETURN tmp
+/// }
+/// DEFINE L_KEY(dword) {
+/// 	RETURN dword ^ ROL32(dword, 13) ^ ROL32(dword, 23)
+/// }
+/// DEFINE T_KEY(dword) {
+/// 	RETURN L_KEY(lower_t(dword))
+/// }
+/// DEFINE F_KEY(X0, X1, X2, X3, round_key) {
+/// 	RETURN X0 ^ T_KEY(X1 ^ X2 ^ X3 ^ round_key)
+/// }
+/// FOR i:= 0 to 1
+/// 	P[0] := __B.xmm[i].dword[0]
+/// 	P[1] := __B.xmm[i].dword[1]
+/// 	P[2] := __B.xmm[i].dword[2]
+/// 	P[3] := __B.xmm[i].dword[3]
+/// 	C[0] := F_KEY(P[0], P[1], P[2], P[3], __A.xmm[i].dword[0])
+/// 	C[1] := F_KEY(P[1], P[2], P[3], C[0], __A.xmm[i].dword[1])
+/// 	C[2] := F_KEY(P[2], P[3], C[0], C[1], __A.xmm[i].dword[2])
+/// 	C[3] := F_KEY(P[3], C[0], C[1], C[2], __A.xmm[i].dword[3])
+/// 	DEST.xmm[i].dword[0] := C[0]
+/// 	DEST.xmm[i].dword[1] := C[1]
+/// 	DEST.xmm[i].dword[2] := C[2]
+/// 	DEST.xmm[i].dword[3] := C[3]
+/// ENDFOR
+/// DEST[MAX:256] := 0
+/// \endcode
+#define _mm256_sm4key4_epi32(A, B)                                             \
+  (__m256i) __builtin_ia32_vsm4key4256((__v8su)A, (__v8su)B)
+
+/// This intrinisc performs four rounds of SM4 encryption. The intrinisc
+///    operates on independent 128-bit lanes. The calculated results are
+///    stored in \a dst.
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m128i _mm_sm4rnds4_epi32(__m128i __A, __m128i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VSM4RNDS4 instruction.
+///
+/// \param __A
+///    A 128-bit vector of [4 x int].
+/// \param __B
+///    A 128-bit vector of [4 x int].
+/// \returns
+///    A 128-bit vector of [4 x int].
+///
+/// \code{.operation}
+/// DEFINE ROL32(dword, n) {
+/// 	count := n % 32
+/// 	dest := (dword << count) | (dword >> (32-count))
+/// 	RETURN dest
+/// }
+/// DEFINE lower_t(dword) {
+/// 	tmp.byte[0] := SBOX_BYTE(dword, 0)
+/// 	tmp.byte[1] := SBOX_BYTE(dword, 1)
+/// 	tmp.byte[2] := SBOX_BYTE(dword, 2)
+/// 	tmp.byte[3] := SBOX_BYTE(dword, 3)
+/// 	RETURN tmp
+/// }
+/// DEFINE L_RND(dword) {
+/// 	tmp := dword
+/// 	tmp := tmp ^ ROL32(dword, 2)
+/// 	tmp := tmp ^ ROL32(dword, 10)
+/// 	tmp := tmp ^ ROL32(dword, 18)
+/// 	tmp := tmp ^ ROL32(dword, 24)
+///   RETURN tmp
+/// }
+/// DEFINE T_RND(dword) {
+/// 	RETURN L_RND(lower_t(dword))
+/// }
+/// DEFINE F_RND(X0, X1, X2, X3, round_key) {
+/// 	RETURN X0 ^ T_RND(X1 ^ X2 ^ X3 ^ round_key)
+/// }
+/// FOR i:= 0 to 0
+/// 	P[0] := __B.xmm[i].dword[0]
+/// 	P[1] := __B.xmm[i].dword[1]
+/// 	P[2] := __B.xmm[i].dword[2]
+/// 	P[3] := __B.xmm[i].dword[3]
+/// 	C[0] := F_RND(P[0], P[1], P[2], P[3], __A.xmm[i].dword[0])
+/// 	C[1] := F_RND(P[1], P[2], P[3], C[0], __A.xmm[i].dword[1])
+/// 	C[2] := F_RND(P[2], P[3], C[0], C[1], __A.xmm[i].dword[2])
+/// 	C[3] := F_RND(P[3], C[0], C[1], C[2], __A.xmm[i].dword[3])
+/// 	DEST.xmm[i].dword[0] := C[0]
+/// 	DEST.xmm[i].dword[1] := C[1]
+/// 	DEST.xmm[i].dword[2] := C[2]
+/// 	DEST.xmm[i].dword[3] := C[3]
+/// ENDFOR
+/// DEST[MAX:128] := 0
+/// \endcode
+#define _mm_sm4rnds4_epi32(A, B)                                               \
+  (__m128i) __builtin_ia32_vsm4rnds4128((__v4su)A, (__v4su)B)
+
+/// This intrinisc performs four rounds of SM4 encryption. The intrinisc
+///    operates on independent 128-bit lanes. The calculated results are
+///    stored in \a dst.
+/// \headerfile <immintrin.h>
+///
+/// \code
+/// __m256i _mm256_sm4rnds4_epi32(__m256i __A, __m256i __B)
+/// \endcode
+///
+/// This intrinsic corresponds to the \c VSM4RNDS4 instruction.
+///
+/// \param __A
+///    A 256-bit vector of [8 x int].
+/// \param __B
+///    A 256-bit vector of [8 x int].
+/// \returns
+///    A 256-bit vector of [8 x int].
+///
+/// \code{.operation}
+/// DEFINE ROL32(dword, n) {
+/// 	count := n % 32
+/// 	dest := (dword << count) | (dword >> (32-count))
+/// 	RETURN dest
+/// }
+/// DEFINE lower_t(dword) {
+/// 	tmp.byte[0] := SBOX_BYTE(dword, 0)
+/// 	tmp.byte[1] := SBOX_BYTE(dword, 1)
+/// 	tmp.byte[2] := SBOX_BYTE(dword, 2)
+/// 	tmp.byte[3] := SBOX_BYTE(dword, 3)
+/// 	RETURN tmp
+/// }
+/// DEFINE L_RND(dword) {
+/// 	tmp := dword
+/// 	tmp := tmp ^ ROL32(dword, 2)
+/// 	tmp := tmp ^ ROL32(dword, 10)
+/// 	tmp := tmp ^ ROL32(dword, 18)
+/// 	tmp := tmp ^ ROL32(dword, 24)
+///   RETURN tmp
+/// }
+/// DEFINE T_RND(dword) {
+/// 	RETURN L_RND(lower_t(dword))
+/// }
+/// DEFINE F_RND(X0, X1, X2, X3, round_key) {
+/// 	RETURN X0 ^ T_RND(X1 ^ X2 ^ X3 ^ round_key)
+/// }
+/// FOR i:= 0 to 0
+/// 	P[0] := __B.xmm[i].dword[0]
+/// 	P[1] := __B.xmm[i].dword[1]
+/// 	P[2] := __B.xmm[i].dword[2]
+/// 	P[3] := __B.xmm[i].dword[3]
+/// 	C[0] := F_RND(P[0], P[1], P[2], P[3], __A.xmm[i].dword[0])
+/// 	C[1] := F_RND(P[1], P[2], P[3], C[0], __A.xmm[i].dword[1])
+/// 	C[2] := F_RND(P[2], P[3], C[0], C[1], __A.xmm[i].dword[2])
+/// 	C[3] := F_RND(P[3], C[0], C[1], C[2], __A.xmm[i].dword[3])
+/// 	DEST.xmm[i].dword[0] := C[0]
+/// 	DEST.xmm[i].dword[1] := C[1]
+/// 	DEST.xmm[i].dword[2] := C[2]
+/// 	DEST.xmm[i].dword[3] := C[3]
+/// ENDFOR
+/// DEST[MAX:256] := 0
+/// \endcode
+#define _mm256_sm4rnds4_epi32(A, B)                                            \
+  (__m256i) __builtin_ia32_vsm4rnds4256((__v8su)A, (__v8su)B)
+
+#endif // __SM4INTRIN_H
diff --git a/third_party/intel/clang/smmintrin.h b/third_party/intel/clang/smmintrin.h
new file mode 100644
index 000000000..6f7f586dc
--- /dev/null
+++ b/third_party/intel/clang/smmintrin.h
@@ -0,0 +1,2328 @@
+/*===---- smmintrin.h - SSE4 intrinsics ------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __SMMINTRIN_H
+#define __SMMINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+#include "tmmintrin.h"
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("sse4.1,no-evex512"), __min_vector_width__(128)))
+
+/* SSE4 Rounding macros. */
+#define _MM_FROUND_TO_NEAREST_INT 0x00
+#define _MM_FROUND_TO_NEG_INF 0x01
+#define _MM_FROUND_TO_POS_INF 0x02
+#define _MM_FROUND_TO_ZERO 0x03
+#define _MM_FROUND_CUR_DIRECTION 0x04
+
+#define _MM_FROUND_RAISE_EXC 0x00
+#define _MM_FROUND_NO_EXC 0x08
+
+#define _MM_FROUND_NINT (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_NEAREST_INT)
+#define _MM_FROUND_FLOOR (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_NEG_INF)
+#define _MM_FROUND_CEIL (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_POS_INF)
+#define _MM_FROUND_TRUNC (_MM_FROUND_RAISE_EXC | _MM_FROUND_TO_ZERO)
+#define _MM_FROUND_RINT (_MM_FROUND_RAISE_EXC | _MM_FROUND_CUR_DIRECTION)
+#define _MM_FROUND_NEARBYINT (_MM_FROUND_NO_EXC | _MM_FROUND_CUR_DIRECTION)
+
+/// Rounds up each element of the 128-bit vector of [4 x float] to an
+///    integer and returns the rounded values in a 128-bit vector of
+///    [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_ceil_ps(__m128 X);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPS / ROUNDPS </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [4 x float] values to be rounded up.
+/// \returns A 128-bit vector of [4 x float] containing the rounded values.
+#define _mm_ceil_ps(X) _mm_round_ps((X), _MM_FROUND_CEIL)
+
+/// Rounds up each element of the 128-bit vector of [2 x double] to an
+///    integer and returns the rounded values in a 128-bit vector of
+///    [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_ceil_pd(__m128d X);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPD / ROUNDPD </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [2 x double] values to be rounded up.
+/// \returns A 128-bit vector of [2 x double] containing the rounded values.
+#define _mm_ceil_pd(X) _mm_round_pd((X), _MM_FROUND_CEIL)
+
+/// Copies three upper elements of the first 128-bit vector operand to
+///    the corresponding three upper elements of the 128-bit result vector of
+///    [4 x float]. Rounds up the lowest element of the second 128-bit vector
+///    operand to an integer and copies it to the lowest element of the 128-bit
+///    result vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_ceil_ss(__m128 X, __m128 Y);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDSS / ROUNDSS </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [4 x float]. The values stored in bits [127:32] are
+///    copied to the corresponding bits of the result.
+/// \param Y
+///    A 128-bit vector of [4 x float]. The value stored in bits [31:0] is
+///    rounded up to the nearest integer and copied to the corresponding bits
+///    of the result.
+/// \returns A 128-bit vector of [4 x float] containing the copied and rounded
+///    values.
+#define _mm_ceil_ss(X, Y) _mm_round_ss((X), (Y), _MM_FROUND_CEIL)
+
+/// Copies the upper element of the first 128-bit vector operand to the
+///    corresponding upper element of the 128-bit result vector of [2 x double].
+///    Rounds up the lower element of the second 128-bit vector operand to an
+///    integer and copies it to the lower element of the 128-bit result vector
+///    of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_ceil_sd(__m128d X, __m128d Y);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDSD / ROUNDSD </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [2 x double]. The value stored in bits [127:64] is
+///    copied to the corresponding bits of the result.
+/// \param Y
+///    A 128-bit vector of [2 x double]. The value stored in bits [63:0] is
+///    rounded up to the nearest integer and copied to the corresponding bits
+///    of the result.
+/// \returns A 128-bit vector of [2 x double] containing the copied and rounded
+///    values.
+#define _mm_ceil_sd(X, Y) _mm_round_sd((X), (Y), _MM_FROUND_CEIL)
+
+/// Rounds down each element of the 128-bit vector of [4 x float] to an
+///    an integer and returns the rounded values in a 128-bit vector of
+///    [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_floor_ps(__m128 X);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPS / ROUNDPS </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [4 x float] values to be rounded down.
+/// \returns A 128-bit vector of [4 x float] containing the rounded values.
+#define _mm_floor_ps(X) _mm_round_ps((X), _MM_FROUND_FLOOR)
+
+/// Rounds down each element of the 128-bit vector of [2 x double] to an
+///    integer and returns the rounded values in a 128-bit vector of
+///    [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_floor_pd(__m128d X);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPD / ROUNDPD </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [2 x double].
+/// \returns A 128-bit vector of [2 x double] containing the rounded values.
+#define _mm_floor_pd(X) _mm_round_pd((X), _MM_FROUND_FLOOR)
+
+/// Copies three upper elements of the first 128-bit vector operand to
+///    the corresponding three upper elements of the 128-bit result vector of
+///    [4 x float]. Rounds down the lowest element of the second 128-bit vector
+///    operand to an integer and copies it to the lowest element of the 128-bit
+///    result vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_floor_ss(__m128 X, __m128 Y);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDSS / ROUNDSS </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [4 x float]. The values stored in bits [127:32] are
+///    copied to the corresponding bits of the result.
+/// \param Y
+///    A 128-bit vector of [4 x float]. The value stored in bits [31:0] is
+///    rounded down to the nearest integer and copied to the corresponding bits
+///    of the result.
+/// \returns A 128-bit vector of [4 x float] containing the copied and rounded
+///    values.
+#define _mm_floor_ss(X, Y) _mm_round_ss((X), (Y), _MM_FROUND_FLOOR)
+
+/// Copies the upper element of the first 128-bit vector operand to the
+///    corresponding upper element of the 128-bit result vector of [2 x double].
+///    Rounds down the lower element of the second 128-bit vector operand to an
+///    integer and copies it to the lower element of the 128-bit result vector
+///    of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_floor_sd(__m128d X, __m128d Y);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDSD / ROUNDSD </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [2 x double]. The value stored in bits [127:64] is
+///    copied to the corresponding bits of the result.
+/// \param Y
+///    A 128-bit vector of [2 x double]. The value stored in bits [63:0] is
+///    rounded down to the nearest integer and copied to the corresponding bits
+///    of the result.
+/// \returns A 128-bit vector of [2 x double] containing the copied and rounded
+///    values.
+#define _mm_floor_sd(X, Y) _mm_round_sd((X), (Y), _MM_FROUND_FLOOR)
+
+/// Rounds each element of the 128-bit vector of [4 x float] to an
+///    integer value according to the rounding control specified by the second
+///    argument and returns the rounded values in a 128-bit vector of
+///    [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_round_ps(__m128 X, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPS / ROUNDPS </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [4 x float].
+/// \param M
+///    An integer value that specifies the rounding operation. \n
+///    Bits [7:4] are reserved. \n
+///    Bit [3] is a precision exception value: \n
+///      0: A normal PE exception is used \n
+///      1: The PE field is not updated \n
+///    Bit [2] is the rounding control source: \n
+///      0: Use bits [1:0] of \a M \n
+///      1: Use the current MXCSR setting \n
+///    Bits [1:0] contain the rounding control definition: \n
+///      00: Nearest \n
+///      01: Downward (toward negative infinity) \n
+///      10: Upward (toward positive infinity) \n
+///      11: Truncated
+/// \returns A 128-bit vector of [4 x float] containing the rounded values.
+#define _mm_round_ps(X, M)                                                     \
+  ((__m128)__builtin_ia32_roundps((__v4sf)(__m128)(X), (M)))
+
+/// Copies three upper elements of the first 128-bit vector operand to
+///    the corresponding three upper elements of the 128-bit result vector of
+///    [4 x float]. Rounds the lowest element of the second 128-bit vector
+///    operand to an integer value according to the rounding control specified
+///    by the third argument and copies it to the lowest element of the 128-bit
+///    result vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_round_ss(__m128 X, __m128 Y, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDSS / ROUNDSS </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [4 x float]. The values stored in bits [127:32] are
+///    copied to the corresponding bits of the result.
+/// \param Y
+///    A 128-bit vector of [4 x float]. The value stored in bits [31:0] is
+///    rounded to the nearest integer using the specified rounding control and
+///    copied to the corresponding bits of the result.
+/// \param M
+///    An integer value that specifies the rounding operation. \n
+///    Bits [7:4] are reserved. \n
+///    Bit [3] is a precision exception value: \n
+///      0: A normal PE exception is used \n
+///      1: The PE field is not updated \n
+///    Bit [2] is the rounding control source: \n
+///      0: Use bits [1:0] of \a M \n
+///      1: Use the current MXCSR setting \n
+///    Bits [1:0] contain the rounding control definition: \n
+///      00: Nearest \n
+///      01: Downward (toward negative infinity) \n
+///      10: Upward (toward positive infinity) \n
+///      11: Truncated
+/// \returns A 128-bit vector of [4 x float] containing the copied and rounded
+///    values.
+#define _mm_round_ss(X, Y, M)                                                  \
+  ((__m128)__builtin_ia32_roundss((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y),    \
+                                  (M)))
+
+/// Rounds each element of the 128-bit vector of [2 x double] to an
+///    integer value according to the rounding control specified by the second
+///    argument and returns the rounded values in a 128-bit vector of
+///    [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_round_pd(__m128d X, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDPD / ROUNDPD </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [2 x double].
+/// \param M
+///    An integer value that specifies the rounding operation. \n
+///    Bits [7:4] are reserved. \n
+///    Bit [3] is a precision exception value: \n
+///      0: A normal PE exception is used \n
+///      1: The PE field is not updated \n
+///    Bit [2] is the rounding control source: \n
+///      0: Use bits [1:0] of \a M \n
+///      1: Use the current MXCSR setting \n
+///    Bits [1:0] contain the rounding control definition: \n
+///      00: Nearest \n
+///      01: Downward (toward negative infinity) \n
+///      10: Upward (toward positive infinity) \n
+///      11: Truncated
+/// \returns A 128-bit vector of [2 x double] containing the rounded values.
+#define _mm_round_pd(X, M)                                                     \
+  ((__m128d)__builtin_ia32_roundpd((__v2df)(__m128d)(X), (M)))
+
+/// Copies the upper element of the first 128-bit vector operand to the
+///    corresponding upper element of the 128-bit result vector of [2 x double].
+///    Rounds the lower element of the second 128-bit vector operand to an
+///    integer value according to the rounding control specified by the third
+///    argument and copies it to the lower element of the 128-bit result vector
+///    of [2 x double].
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_round_sd(__m128d X, __m128d Y, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VROUNDSD / ROUNDSD </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [2 x double]. The value stored in bits [127:64] is
+///    copied to the corresponding bits of the result.
+/// \param Y
+///    A 128-bit vector of [2 x double]. The value stored in bits [63:0] is
+///    rounded to the nearest integer using the specified rounding control and
+///    copied to the corresponding bits of the result.
+/// \param M
+///    An integer value that specifies the rounding operation. \n
+///    Bits [7:4] are reserved. \n
+///    Bit [3] is a precision exception value: \n
+///      0: A normal PE exception is used \n
+///      1: The PE field is not updated \n
+///    Bit [2] is the rounding control source: \n
+///      0: Use bits [1:0] of \a M \n
+///      1: Use the current MXCSR setting \n
+///    Bits [1:0] contain the rounding control definition: \n
+///      00: Nearest \n
+///      01: Downward (toward negative infinity) \n
+///      10: Upward (toward positive infinity) \n
+///      11: Truncated
+/// \returns A 128-bit vector of [2 x double] containing the copied and rounded
+///    values.
+#define _mm_round_sd(X, Y, M)                                                  \
+  ((__m128d)__builtin_ia32_roundsd((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y), \
+                                   (M)))
+
+/* SSE4 Packed Blending Intrinsics.  */
+/// Returns a 128-bit vector of [2 x double] where the values are
+///    selected from either the first or second operand as specified by the
+///    third operand, the control mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_blend_pd(__m128d V1, __m128d V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VBLENDPD / BLENDPD </c> instruction.
+///
+/// \param V1
+///    A 128-bit vector of [2 x double].
+/// \param V2
+///    A 128-bit vector of [2 x double].
+/// \param M
+///    An immediate integer operand, with mask bits [1:0] specifying how the
+///    values are to be copied. The position of the mask bit corresponds to the
+///    index of a copied value. When a mask bit is 0, the corresponding 64-bit
+///    element in operand \a V1 is copied to the same position in the result.
+///    When a mask bit is 1, the corresponding 64-bit element in operand \a V2
+///    is copied to the same position in the result.
+/// \returns A 128-bit vector of [2 x double] containing the copied values.
+#define _mm_blend_pd(V1, V2, M)                                                \
+  ((__m128d)__builtin_ia32_blendpd((__v2df)(__m128d)(V1),                      \
+                                   (__v2df)(__m128d)(V2), (int)(M)))
+
+/// Returns a 128-bit vector of [4 x float] where the values are selected
+///    from either the first or second operand as specified by the third
+///    operand, the control mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_blend_ps(__m128 V1, __m128 V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VBLENDPS / BLENDPS </c> instruction.
+///
+/// \param V1
+///    A 128-bit vector of [4 x float].
+/// \param V2
+///    A 128-bit vector of [4 x float].
+/// \param M
+///    An immediate integer operand, with mask bits [3:0] specifying how the
+///    values are to be copied. The position of the mask bit corresponds to the
+///    index of a copied value. When a mask bit is 0, the corresponding 32-bit
+///    element in operand \a V1 is copied to the same position in the result.
+///    When a mask bit is 1, the corresponding 32-bit element in operand \a V2
+///    is copied to the same position in the result.
+/// \returns A 128-bit vector of [4 x float] containing the copied values.
+#define _mm_blend_ps(V1, V2, M)                                                \
+  ((__m128)__builtin_ia32_blendps((__v4sf)(__m128)(V1), (__v4sf)(__m128)(V2),  \
+                                  (int)(M)))
+
+/// Returns a 128-bit vector of [2 x double] where the values are
+///    selected from either the first or second operand as specified by the
+///    third operand, the control mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBLENDVPD / BLENDVPD </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [2 x double].
+/// \param __V2
+///    A 128-bit vector of [2 x double].
+/// \param __M
+///    A 128-bit vector operand, with mask bits 127 and 63 specifying how the
+///    values are to be copied. The position of the mask bit corresponds to the
+///    most significant bit of a copied value. When a mask bit is 0, the
+///    corresponding 64-bit element in operand \a __V1 is copied to the same
+///    position in the result. When a mask bit is 1, the corresponding 64-bit
+///    element in operand \a __V2 is copied to the same position in the result.
+/// \returns A 128-bit vector of [2 x double] containing the copied values.
+static __inline__ __m128d __DEFAULT_FN_ATTRS _mm_blendv_pd(__m128d __V1,
+                                                           __m128d __V2,
+                                                           __m128d __M) {
+  return (__m128d)__builtin_ia32_blendvpd((__v2df)__V1, (__v2df)__V2,
+                                          (__v2df)__M);
+}
+
+/// Returns a 128-bit vector of [4 x float] where the values are
+///    selected from either the first or second operand as specified by the
+///    third operand, the control mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBLENDVPS / BLENDVPS </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [4 x float].
+/// \param __V2
+///    A 128-bit vector of [4 x float].
+/// \param __M
+///    A 128-bit vector operand, with mask bits 127, 95, 63, and 31 specifying
+///    how the values are to be copied. The position of the mask bit corresponds
+///    to the most significant bit of a copied value. When a mask bit is 0, the
+///    corresponding 32-bit element in operand \a __V1 is copied to the same
+///    position in the result. When a mask bit is 1, the corresponding 32-bit
+///    element in operand \a __V2 is copied to the same position in the result.
+/// \returns A 128-bit vector of [4 x float] containing the copied values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS _mm_blendv_ps(__m128 __V1,
+                                                          __m128 __V2,
+                                                          __m128 __M) {
+  return (__m128)__builtin_ia32_blendvps((__v4sf)__V1, (__v4sf)__V2,
+                                         (__v4sf)__M);
+}
+
+/// Returns a 128-bit vector of [16 x i8] where the values are selected
+///    from either of the first or second operand as specified by the third
+///    operand, the control mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPBLENDVB / PBLENDVB </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [16 x i8].
+/// \param __V2
+///    A 128-bit vector of [16 x i8].
+/// \param __M
+///    A 128-bit vector operand, with mask bits 127, 119, 111...7 specifying
+///    how the values are to be copied. The position of the mask bit corresponds
+///    to the most significant bit of a copied value. When a mask bit is 0, the
+///    corresponding 8-bit element in operand \a __V1 is copied to the same
+///    position in the result. When a mask bit is 1, the corresponding 8-bit
+///    element in operand \a __V2 is copied to the same position in the result.
+/// \returns A 128-bit vector of [16 x i8] containing the copied values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_blendv_epi8(__m128i __V1,
+                                                             __m128i __V2,
+                                                             __m128i __M) {
+  return (__m128i)__builtin_ia32_pblendvb128((__v16qi)__V1, (__v16qi)__V2,
+                                             (__v16qi)__M);
+}
+
+/// Returns a 128-bit vector of [8 x i16] where the values are selected
+///    from either of the first or second operand as specified by the third
+///    operand, the control mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_blend_epi16(__m128i V1, __m128i V2, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPBLENDW / PBLENDW </c> instruction.
+///
+/// \param V1
+///    A 128-bit vector of [8 x i16].
+/// \param V2
+///    A 128-bit vector of [8 x i16].
+/// \param M
+///    An immediate integer operand, with mask bits [7:0] specifying how the
+///    values are to be copied. The position of the mask bit corresponds to the
+///    index of a copied value. When a mask bit is 0, the corresponding 16-bit
+///    element in operand \a V1 is copied to the same position in the result.
+///    When a mask bit is 1, the corresponding 16-bit element in operand \a V2
+///    is copied to the same position in the result.
+/// \returns A 128-bit vector of [8 x i16] containing the copied values.
+#define _mm_blend_epi16(V1, V2, M)                                             \
+  ((__m128i)__builtin_ia32_pblendw128((__v8hi)(__m128i)(V1),                   \
+                                      (__v8hi)(__m128i)(V2), (int)(M)))
+
+/* SSE4 Dword Multiply Instructions.  */
+/// Multiples corresponding elements of two 128-bit vectors of [4 x i32]
+///    and returns the lower 32 bits of the each product in a 128-bit vector of
+///    [4 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMULLD / PMULLD </c> instruction.
+///
+/// \param __V1
+///    A 128-bit integer vector.
+/// \param __V2
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the products of both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mullo_epi32(__m128i __V1,
+                                                             __m128i __V2) {
+  return (__m128i)((__v4su)__V1 * (__v4su)__V2);
+}
+
+/// Multiplies corresponding even-indexed elements of two 128-bit
+///    vectors of [4 x i32] and returns a 128-bit vector of [2 x i64]
+///    containing the products.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMULDQ / PMULDQ </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [4 x i32].
+/// \param __V2
+///    A 128-bit vector of [4 x i32].
+/// \returns A 128-bit vector of [2 x i64] containing the products of both
+///    operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_mul_epi32(__m128i __V1,
+                                                           __m128i __V2) {
+  return (__m128i)__builtin_ia32_pmuldq128((__v4si)__V1, (__v4si)__V2);
+}
+
+/* SSE4 Floating Point Dot Product Instructions.  */
+/// Computes the dot product of the two 128-bit vectors of [4 x float]
+///    and returns it in the elements of the 128-bit result vector of
+///    [4 x float].
+///
+///    The immediate integer operand controls which input elements
+///    will contribute to the dot product, and where the final results are
+///    returned.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_dp_ps(__m128 X, __m128 Y, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VDPPS / DPPS </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [4 x float].
+/// \param Y
+///    A 128-bit vector of [4 x float].
+/// \param M
+///    An immediate integer operand. Mask bits [7:4] determine which elements
+///    of the input vectors are used, with bit [4] corresponding to the lowest
+///    element and bit [7] corresponding to the highest element of each [4 x
+///    float] vector. If a bit is set, the corresponding elements from the two
+///    input vectors are used as an input for dot product; otherwise that input
+///    is treated as zero. Bits [3:0] determine which elements of the result
+///    will receive a copy of the final dot product, with bit [0] corresponding
+///    to the lowest element and bit [3] corresponding to the highest element of
+///    each [4 x float] subvector. If a bit is set, the dot product is returned
+///    in the corresponding element; otherwise that element is set to zero.
+/// \returns A 128-bit vector of [4 x float] containing the dot product.
+#define _mm_dp_ps(X, Y, M)                                                     \
+  ((__m128)__builtin_ia32_dpps((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), (M)))
+
+/// Computes the dot product of the two 128-bit vectors of [2 x double]
+///    and returns it in the elements of the 128-bit result vector of
+///    [2 x double].
+///
+///    The immediate integer operand controls which input
+///    elements will contribute to the dot product, and where the final results
+///    are returned.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128d _mm_dp_pd(__m128d X, __m128d Y, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VDPPD / DPPD </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [2 x double].
+/// \param Y
+///    A 128-bit vector of [2 x double].
+/// \param M
+///    An immediate integer operand. Mask bits [5:4] determine which elements
+///    of the input vectors are used, with bit [4] corresponding to the lowest
+///    element and bit [5] corresponding to the highest element of each of [2 x
+///    double] vector. If a bit is set, the corresponding elements from the two
+///    input vectors are used as an input for dot product; otherwise that input
+///    is treated as zero. Bits [1:0] determine which elements of the result
+///    will receive a copy of the final dot product, with bit [0] corresponding
+///    to the lowest element and bit [1] corresponding to the highest element of
+///    each [2 x double] vector. If a bit is set, the dot product is returned in
+///    the corresponding element; otherwise that element is set to zero.
+#define _mm_dp_pd(X, Y, M)                                                     \
+  ((__m128d)__builtin_ia32_dppd((__v2df)(__m128d)(X), (__v2df)(__m128d)(Y),    \
+                                (M)))
+
+/* SSE4 Streaming Load Hint Instruction.  */
+/// Loads integer values from a 128-bit aligned memory location to a
+///    128-bit integer vector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVNTDQA / MOVNTDQA </c> instruction.
+///
+/// \param __V
+///    A pointer to a 128-bit aligned memory location that contains the integer
+///    values.
+/// \returns A 128-bit integer vector containing the data stored at the
+///    specified memory location.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_stream_load_si128(const void *__V) {
+  return (__m128i)__builtin_nontemporal_load((const __v2di *)__V);
+}
+
+/* SSE4 Packed Integer Min/Max Instructions.  */
+/// Compares the corresponding elements of two 128-bit vectors of
+///    [16 x i8] and returns a 128-bit vector of [16 x i8] containing the lesser
+///    of the two values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMINSB / PMINSB </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [16 x i8].
+/// \param __V2
+///    A 128-bit vector of [16 x i8]
+/// \returns A 128-bit vector of [16 x i8] containing the lesser values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epi8(__m128i __V1,
+                                                          __m128i __V2) {
+  return (__m128i)__builtin_elementwise_min((__v16qs)__V1, (__v16qs)__V2);
+}
+
+/// Compares the corresponding elements of two 128-bit vectors of
+///    [16 x i8] and returns a 128-bit vector of [16 x i8] containing the
+///    greater value of the two.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMAXSB / PMAXSB </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [16 x i8].
+/// \param __V2
+///    A 128-bit vector of [16 x i8].
+/// \returns A 128-bit vector of [16 x i8] containing the greater values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epi8(__m128i __V1,
+                                                          __m128i __V2) {
+  return (__m128i)__builtin_elementwise_max((__v16qs)__V1, (__v16qs)__V2);
+}
+
+/// Compares the corresponding elements of two 128-bit vectors of
+///    [8 x u16] and returns a 128-bit vector of [8 x u16] containing the lesser
+///    value of the two.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMINUW / PMINUW </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [8 x u16].
+/// \param __V2
+///    A 128-bit vector of [8 x u16].
+/// \returns A 128-bit vector of [8 x u16] containing the lesser values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epu16(__m128i __V1,
+                                                           __m128i __V2) {
+  return (__m128i)__builtin_elementwise_min((__v8hu)__V1, (__v8hu)__V2);
+}
+
+/// Compares the corresponding elements of two 128-bit vectors of
+///    [8 x u16] and returns a 128-bit vector of [8 x u16] containing the
+///    greater value of the two.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMAXUW / PMAXUW </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [8 x u16].
+/// \param __V2
+///    A 128-bit vector of [8 x u16].
+/// \returns A 128-bit vector of [8 x u16] containing the greater values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epu16(__m128i __V1,
+                                                           __m128i __V2) {
+  return (__m128i)__builtin_elementwise_max((__v8hu)__V1, (__v8hu)__V2);
+}
+
+/// Compares the corresponding elements of two 128-bit vectors of
+///    [4 x i32] and returns a 128-bit vector of [4 x i32] containing the lesser
+///    value of the two.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMINSD / PMINSD </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [4 x i32].
+/// \param __V2
+///    A 128-bit vector of [4 x i32].
+/// \returns A 128-bit vector of [4 x i32] containing the lesser values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epi32(__m128i __V1,
+                                                           __m128i __V2) {
+  return (__m128i)__builtin_elementwise_min((__v4si)__V1, (__v4si)__V2);
+}
+
+/// Compares the corresponding elements of two 128-bit vectors of
+///    [4 x i32] and returns a 128-bit vector of [4 x i32] containing the
+///    greater value of the two.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMAXSD / PMAXSD </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [4 x i32].
+/// \param __V2
+///    A 128-bit vector of [4 x i32].
+/// \returns A 128-bit vector of [4 x i32] containing the greater values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epi32(__m128i __V1,
+                                                           __m128i __V2) {
+  return (__m128i)__builtin_elementwise_max((__v4si)__V1, (__v4si)__V2);
+}
+
+/// Compares the corresponding elements of two 128-bit vectors of
+///    [4 x u32] and returns a 128-bit vector of [4 x u32] containing the lesser
+///    value of the two.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMINUD / PMINUD </c>  instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [4 x u32].
+/// \param __V2
+///    A 128-bit vector of [4 x u32].
+/// \returns A 128-bit vector of [4 x u32] containing the lesser values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_min_epu32(__m128i __V1,
+                                                           __m128i __V2) {
+  return (__m128i)__builtin_elementwise_min((__v4su)__V1, (__v4su)__V2);
+}
+
+/// Compares the corresponding elements of two 128-bit vectors of
+///    [4 x u32] and returns a 128-bit vector of [4 x u32] containing the
+///    greater value of the two.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMAXUD / PMAXUD </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [4 x u32].
+/// \param __V2
+///    A 128-bit vector of [4 x u32].
+/// \returns A 128-bit vector of [4 x u32] containing the greater values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_max_epu32(__m128i __V1,
+                                                           __m128i __V2) {
+  return (__m128i)__builtin_elementwise_max((__v4su)__V1, (__v4su)__V2);
+}
+
+/* SSE4 Insertion and Extraction from XMM Register Instructions.  */
+/// Takes the first argument \a X and inserts an element from the second
+///    argument \a Y as selected by the third argument \a N. That result then
+///    has elements zeroed out also as selected by the third argument \a N. The
+///    resulting 128-bit vector of [4 x float] is then returned.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_insert_ps(__m128 X, __m128 Y, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VINSERTPS </c> instruction.
+///
+/// \param X
+///    A 128-bit vector source operand of [4 x float]. With the exception of
+///    those bits in the result copied from parameter \a Y and zeroed by bits
+///    [3:0] of \a N, all bits from this parameter are copied to the result.
+/// \param Y
+///    A 128-bit vector source operand of [4 x float]. One single-precision
+///    floating-point element from this source, as determined by the immediate
+///    parameter, is copied to the result.
+/// \param N
+///    Specifies which bits from operand \a Y will be copied, which bits in the
+///    result they will be copied to, and which bits in the result will be
+///    cleared. The following assignments are made: \n
+///    Bits [7:6] specify the bits to copy from operand \a Y: \n
+///      00: Selects bits [31:0] from operand \a Y. \n
+///      01: Selects bits [63:32] from operand \a Y. \n
+///      10: Selects bits [95:64] from operand \a Y. \n
+///      11: Selects bits [127:96] from operand \a Y. \n
+///    Bits [5:4] specify the bits in the result to which the selected bits
+///    from operand \a Y are copied: \n
+///      00: Copies the selected bits from \a Y to result bits [31:0]. \n
+///      01: Copies the selected bits from \a Y to result bits [63:32]. \n
+///      10: Copies the selected bits from \a Y to result bits [95:64]. \n
+///      11: Copies the selected bits from \a Y to result bits [127:96]. \n
+///    Bits[3:0]: If any of these bits are set, the corresponding result
+///    element is cleared.
+/// \returns A 128-bit vector of [4 x float] containing the copied
+///    single-precision floating point elements from the operands.
+#define _mm_insert_ps(X, Y, N) __builtin_ia32_insertps128((X), (Y), (N))
+
+/// Extracts a 32-bit integer from a 128-bit vector of [4 x float] and
+///    returns it, using the immediate value parameter \a N as a selector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_extract_ps(__m128 X, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VEXTRACTPS / EXTRACTPS </c>
+/// instruction.
+///
+/// \param X
+///    A 128-bit vector of [4 x float].
+/// \param N
+///    An immediate value. Bits [1:0] determines which bits from the argument
+///    \a X are extracted and returned: \n
+///    00: Bits [31:0] of parameter \a X are returned. \n
+///    01: Bits [63:32] of parameter \a X are returned. \n
+///    10: Bits [95:64] of parameter \a X are returned. \n
+///    11: Bits [127:96] of parameter \a X are returned.
+/// \returns A 32-bit integer containing the extracted 32 bits of float data.
+#define _mm_extract_ps(X, N)                                                   \
+  __builtin_bit_cast(                                                          \
+      int, __builtin_ia32_vec_ext_v4sf((__v4sf)(__m128)(X), (int)(N)))
+
+/* Miscellaneous insert and extract macros.  */
+/* Extract a single-precision float from X at index N into D.  */
+#define _MM_EXTRACT_FLOAT(D, X, N)                                             \
+  do {                                                                         \
+    (D) = __builtin_ia32_vec_ext_v4sf((__v4sf)(__m128)(X), (int)(N));          \
+  } while (0)
+
+/* Or together 2 sets of indexes (X and Y) with the zeroing bits (Z) to create
+   an index suitable for _mm_insert_ps.  */
+#define _MM_MK_INSERTPS_NDX(X, Y, Z) (((X) << 6) | ((Y) << 4) | (Z))
+
+/* Extract a float from X at index N into the first index of the return.  */
+#define _MM_PICK_OUT_PS(X, N)                                                  \
+  _mm_insert_ps(_mm_setzero_ps(), (X), _MM_MK_INSERTPS_NDX((N), 0, 0x0e))
+
+/* Insert int into packed integer array at index.  */
+/// Constructs a 128-bit vector of [16 x i8] by first making a copy of
+///    the 128-bit integer vector parameter, and then inserting the lower 8 bits
+///    of an integer parameter \a I into an offset specified by the immediate
+///    value parameter \a N.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_insert_epi8(__m128i X, int I, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPINSRB / PINSRB </c> instruction.
+///
+/// \param X
+///    A 128-bit integer vector of [16 x i8]. This vector is copied to the
+///    result and then one of the sixteen elements in the result vector is
+///    replaced by the lower 8 bits of \a I.
+/// \param I
+///    An integer. The lower 8 bits of this operand are written to the result
+///    beginning at the offset specified by \a N.
+/// \param N
+///    An immediate value. Bits [3:0] specify the bit offset in the result at
+///    which the lower 8 bits of \a I are written. \n
+///    0000: Bits [7:0] of the result are used for insertion. \n
+///    0001: Bits [15:8] of the result are used for insertion. \n
+///    0010: Bits [23:16] of the result are used for insertion. \n
+///    0011: Bits [31:24] of the result are used for insertion. \n
+///    0100: Bits [39:32] of the result are used for insertion. \n
+///    0101: Bits [47:40] of the result are used for insertion. \n
+///    0110: Bits [55:48] of the result are used for insertion. \n
+///    0111: Bits [63:56] of the result are used for insertion. \n
+///    1000: Bits [71:64] of the result are used for insertion. \n
+///    1001: Bits [79:72] of the result are used for insertion. \n
+///    1010: Bits [87:80] of the result are used for insertion. \n
+///    1011: Bits [95:88] of the result are used for insertion. \n
+///    1100: Bits [103:96] of the result are used for insertion. \n
+///    1101: Bits [111:104] of the result are used for insertion. \n
+///    1110: Bits [119:112] of the result are used for insertion. \n
+///    1111: Bits [127:120] of the result are used for insertion.
+/// \returns A 128-bit integer vector containing the constructed values.
+#define _mm_insert_epi8(X, I, N)                                               \
+  ((__m128i)__builtin_ia32_vec_set_v16qi((__v16qi)(__m128i)(X), (int)(I),      \
+                                         (int)(N)))
+
+/// Constructs a 128-bit vector of [4 x i32] by first making a copy of
+///    the 128-bit integer vector parameter, and then inserting the 32-bit
+///    integer parameter \a I at the offset specified by the immediate value
+///    parameter \a N.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_insert_epi32(__m128i X, int I, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPINSRD / PINSRD </c> instruction.
+///
+/// \param X
+///    A 128-bit integer vector of [4 x i32]. This vector is copied to the
+///    result and then one of the four elements in the result vector is
+///    replaced by \a I.
+/// \param I
+///    A 32-bit integer that is written to the result beginning at the offset
+///    specified by \a N.
+/// \param N
+///    An immediate value. Bits [1:0] specify the bit offset in the result at
+///    which the integer \a I is written. \n
+///    00: Bits [31:0] of the result are used for insertion. \n
+///    01: Bits [63:32] of the result are used for insertion. \n
+///    10: Bits [95:64] of the result are used for insertion. \n
+///    11: Bits [127:96] of the result are used for insertion.
+/// \returns A 128-bit integer vector containing the constructed values.
+#define _mm_insert_epi32(X, I, N)                                              \
+  ((__m128i)__builtin_ia32_vec_set_v4si((__v4si)(__m128i)(X), (int)(I),        \
+                                        (int)(N)))
+
+#ifdef __x86_64__
+/// Constructs a 128-bit vector of [2 x i64] by first making a copy of
+///    the 128-bit integer vector parameter, and then inserting the 64-bit
+///    integer parameter \a I, using the immediate value parameter \a N as an
+///    insertion location selector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_insert_epi64(__m128i X, long long I, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPINSRQ / PINSRQ </c> instruction.
+///
+/// \param X
+///    A 128-bit integer vector of [2 x i64]. This vector is copied to the
+///    result and then one of the two elements in the result vector is replaced
+///    by \a I.
+/// \param I
+///    A 64-bit integer that is written to the result beginning at the offset
+///    specified by \a N.
+/// \param N
+///    An immediate value. Bit [0] specifies the bit offset in the result at
+///    which the integer \a I is written. \n
+///    0: Bits [63:0] of the result are used for insertion. \n
+///    1: Bits [127:64] of the result are used for insertion. \n
+/// \returns A 128-bit integer vector containing the constructed values.
+#define _mm_insert_epi64(X, I, N)                                              \
+  ((__m128i)__builtin_ia32_vec_set_v2di((__v2di)(__m128i)(X), (long long)(I),  \
+                                        (int)(N)))
+#endif /* __x86_64__ */
+
+/* Extract int from packed integer array at index.  This returns the element
+ * as a zero extended value, so it is unsigned.
+ */
+/// Extracts an 8-bit element from the 128-bit integer vector of
+///    [16 x i8], using the immediate value parameter \a N as a selector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_extract_epi8(__m128i X, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPEXTRB / PEXTRB </c> instruction.
+///
+/// \param X
+///    A 128-bit integer vector.
+/// \param N
+///    An immediate value. Bits [3:0] specify which 8-bit vector element from
+///    the argument \a X to extract and copy to the result. \n
+///    0000: Bits [7:0] of parameter \a X are extracted. \n
+///    0001: Bits [15:8] of the parameter \a X are extracted. \n
+///    0010: Bits [23:16] of the parameter \a X are extracted. \n
+///    0011: Bits [31:24] of the parameter \a X are extracted. \n
+///    0100: Bits [39:32] of the parameter \a X are extracted. \n
+///    0101: Bits [47:40] of the parameter \a X are extracted. \n
+///    0110: Bits [55:48] of the parameter \a X are extracted. \n
+///    0111: Bits [63:56] of the parameter \a X are extracted. \n
+///    1000: Bits [71:64] of the parameter \a X are extracted. \n
+///    1001: Bits [79:72] of the parameter \a X are extracted. \n
+///    1010: Bits [87:80] of the parameter \a X are extracted. \n
+///    1011: Bits [95:88] of the parameter \a X are extracted. \n
+///    1100: Bits [103:96] of the parameter \a X are extracted. \n
+///    1101: Bits [111:104] of the parameter \a X are extracted. \n
+///    1110: Bits [119:112] of the parameter \a X are extracted. \n
+///    1111: Bits [127:120] of the parameter \a X are extracted.
+/// \returns  An unsigned integer, whose lower 8 bits are selected from the
+///    128-bit integer vector parameter and the remaining bits are assigned
+///    zeros.
+#define _mm_extract_epi8(X, N)                                                 \
+  ((int)(unsigned char)__builtin_ia32_vec_ext_v16qi((__v16qi)(__m128i)(X),     \
+                                                    (int)(N)))
+
+/// Extracts a 32-bit element from the 128-bit integer vector of
+///    [4 x i32], using the immediate value parameter \a N as a selector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_extract_epi32(__m128i X, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPEXTRD / PEXTRD </c> instruction.
+///
+/// \param X
+///    A 128-bit integer vector.
+/// \param N
+///    An immediate value. Bits [1:0] specify which 32-bit vector element from
+///    the argument \a X to extract and copy to the result. \n
+///    00: Bits [31:0] of the parameter \a X are extracted. \n
+///    01: Bits [63:32] of the parameter \a X are extracted. \n
+///    10: Bits [95:64] of the parameter \a X are extracted. \n
+///    11: Bits [127:96] of the parameter \a X are exracted.
+/// \returns  An integer, whose lower 32 bits are selected from the 128-bit
+///    integer vector parameter and the remaining bits are assigned zeros.
+#define _mm_extract_epi32(X, N)                                                \
+  ((int)__builtin_ia32_vec_ext_v4si((__v4si)(__m128i)(X), (int)(N)))
+
+/// Extracts a 64-bit element from the 128-bit integer vector of
+///    [2 x i64], using the immediate value parameter \a N as a selector.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// long long _mm_extract_epi64(__m128i X, const int N);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPEXTRQ / PEXTRQ </c> instruction
+/// in 64-bit mode.
+///
+/// \param X
+///    A 128-bit integer vector.
+/// \param N
+///    An immediate value. Bit [0] specifies which 64-bit vector element from
+///    the argument \a X to return. \n
+///    0: Bits [63:0] are returned. \n
+///    1: Bits [127:64] are returned. \n
+/// \returns  A 64-bit integer.
+#define _mm_extract_epi64(X, N)                                                \
+  ((long long)__builtin_ia32_vec_ext_v2di((__v2di)(__m128i)(X), (int)(N)))
+
+/* SSE4 128-bit Packed Integer Comparisons.  */
+/// Tests whether the specified bits in a 128-bit integer vector are all
+///    zeros.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
+///
+/// \param __M
+///    A 128-bit integer vector containing the bits to be tested.
+/// \param __V
+///    A 128-bit integer vector selecting which bits to test in operand \a __M.
+/// \returns TRUE if the specified bits are all zeros; FALSE otherwise.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_testz_si128(__m128i __M,
+                                                         __m128i __V) {
+  return __builtin_ia32_ptestz128((__v2di)__M, (__v2di)__V);
+}
+
+/// Tests whether the specified bits in a 128-bit integer vector are all
+///    ones.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
+///
+/// \param __M
+///    A 128-bit integer vector containing the bits to be tested.
+/// \param __V
+///    A 128-bit integer vector selecting which bits to test in operand \a __M.
+/// \returns TRUE if the specified bits are all ones; FALSE otherwise.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_testc_si128(__m128i __M,
+                                                         __m128i __V) {
+  return __builtin_ia32_ptestc128((__v2di)__M, (__v2di)__V);
+}
+
+/// Tests whether the specified bits in a 128-bit integer vector are
+///    neither all zeros nor all ones.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
+///
+/// \param __M
+///    A 128-bit integer vector containing the bits to be tested.
+/// \param __V
+///    A 128-bit integer vector selecting which bits to test in operand \a __M.
+/// \returns TRUE if the specified bits are neither all zeros nor all ones;
+///    FALSE otherwise.
+static __inline__ int __DEFAULT_FN_ATTRS _mm_testnzc_si128(__m128i __M,
+                                                           __m128i __V) {
+  return __builtin_ia32_ptestnzc128((__v2di)__M, (__v2di)__V);
+}
+
+/// Tests whether the specified bits in a 128-bit integer vector are all
+///    ones.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_test_all_ones(__m128i V);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
+///
+/// \param V
+///    A 128-bit integer vector containing the bits to be tested.
+/// \returns TRUE if the bits specified in the operand are all set to 1; FALSE
+///    otherwise.
+#define _mm_test_all_ones(V) _mm_testc_si128((V), _mm_set1_epi32(-1))
+
+/// Tests whether the specified bits in a 128-bit integer vector are
+///    neither all zeros nor all ones.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_test_mix_ones_zeros(__m128i M, __m128i V);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
+///
+/// \param M
+///    A 128-bit integer vector containing the bits to be tested.
+/// \param V
+///    A 128-bit integer vector selecting which bits to test in operand \a M.
+/// \returns TRUE if the specified bits are neither all zeros nor all ones;
+///    FALSE otherwise.
+#define _mm_test_mix_ones_zeros(M, V) _mm_testnzc_si128((M), (V))
+
+/// Tests whether the specified bits in a 128-bit integer vector are all
+///    zeros.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_test_all_zeros(__m128i M, __m128i V);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPTEST / PTEST </c> instruction.
+///
+/// \param M
+///    A 128-bit integer vector containing the bits to be tested.
+/// \param V
+///    A 128-bit integer vector selecting which bits to test in operand \a M.
+/// \returns TRUE if the specified bits are all zeros; FALSE otherwise.
+#define _mm_test_all_zeros(M, V) _mm_testz_si128((M), (V))
+
+/* SSE4 64-bit Packed Integer Comparisons.  */
+/// Compares each of the corresponding 64-bit values of the 128-bit
+///    integer vectors for equality.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPEQQ / PCMPEQQ </c> instruction.
+///
+/// \param __V1
+///    A 128-bit integer vector.
+/// \param __V2
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpeq_epi64(__m128i __V1,
+                                                             __m128i __V2) {
+  return (__m128i)((__v2di)__V1 == (__v2di)__V2);
+}
+
+/* SSE4 Packed Integer Sign-Extension.  */
+/// Sign-extends each of the lower eight 8-bit integer elements of a
+///    128-bit vector of [16 x i8] to 16-bit values and returns them in a
+///    128-bit vector of [8 x i16]. The upper eight elements of the input vector
+///    are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVSXBW / PMOVSXBW </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [16 x i8]. The lower eight 8-bit elements are
+///    sign-extended to 16-bit values.
+/// \returns A 128-bit vector of [8 x i16] containing the sign-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi16(__m128i __V) {
+  /* This function always performs a signed extension, but __v16qi is a char
+     which may be signed or unsigned, so use __v16qs. */
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1, 2, 3, 4, 5, 6,
+                              7),
+      __v8hi);
+}
+
+/// Sign-extends each of the lower four 8-bit integer elements of a
+///    128-bit vector of [16 x i8] to 32-bit values and returns them in a
+///    128-bit vector of [4 x i32]. The upper twelve elements of the input
+///    vector are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVSXBD / PMOVSXBD </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [16 x i8]. The lower four 8-bit elements are
+///    sign-extended to 32-bit values.
+/// \returns A 128-bit vector of [4 x i32] containing the sign-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi32(__m128i __V) {
+  /* This function always performs a signed extension, but __v16qi is a char
+     which may be signed or unsigned, so use __v16qs. */
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1, 2, 3), __v4si);
+}
+
+/// Sign-extends each of the lower two 8-bit integer elements of a
+///    128-bit integer vector of [16 x i8] to 64-bit values and returns them in
+///    a 128-bit vector of [2 x i64]. The upper fourteen elements of the input
+///    vector are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVSXBQ / PMOVSXBQ </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [16 x i8]. The lower two 8-bit elements are
+///    sign-extended to 64-bit values.
+/// \returns A 128-bit vector of [2 x i64] containing the sign-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi8_epi64(__m128i __V) {
+  /* This function always performs a signed extension, but __v16qi is a char
+     which may be signed or unsigned, so use __v16qs. */
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v16qs)__V, (__v16qs)__V, 0, 1), __v2di);
+}
+
+/// Sign-extends each of the lower four 16-bit integer elements of a
+///    128-bit integer vector of [8 x i16] to 32-bit values and returns them in
+///    a 128-bit vector of [4 x i32]. The upper four elements of the input
+///    vector are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVSXWD / PMOVSXWD </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [8 x i16]. The lower four 16-bit elements are
+///    sign-extended to 32-bit values.
+/// \returns A 128-bit vector of [4 x i32] containing the sign-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi16_epi32(__m128i __V) {
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v8hi)__V, (__v8hi)__V, 0, 1, 2, 3), __v4si);
+}
+
+/// Sign-extends each of the lower two 16-bit integer elements of a
+///    128-bit integer vector of [8 x i16] to 64-bit values and returns them in
+///    a 128-bit vector of [2 x i64]. The upper six elements of the input
+///    vector are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVSXWQ / PMOVSXWQ </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [8 x i16]. The lower two 16-bit elements are
+///     sign-extended to 64-bit values.
+/// \returns A 128-bit vector of [2 x i64] containing the sign-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi16_epi64(__m128i __V) {
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v8hi)__V, (__v8hi)__V, 0, 1), __v2di);
+}
+
+/// Sign-extends each of the lower two 32-bit integer elements of a
+///    128-bit integer vector of [4 x i32] to 64-bit values and returns them in
+///    a 128-bit vector of [2 x i64]. The upper two elements of the input vector
+///    are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVSXDQ / PMOVSXDQ </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [4 x i32]. The lower two 32-bit elements are
+///    sign-extended to 64-bit values.
+/// \returns A 128-bit vector of [2 x i64] containing the sign-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepi32_epi64(__m128i __V) {
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v4si)__V, (__v4si)__V, 0, 1), __v2di);
+}
+
+/* SSE4 Packed Integer Zero-Extension.  */
+/// Zero-extends each of the lower eight 8-bit integer elements of a
+///    128-bit vector of [16 x i8] to 16-bit values and returns them in a
+///    128-bit vector of [8 x i16]. The upper eight elements of the input vector
+///    are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVZXBW / PMOVZXBW </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [16 x i8]. The lower eight 8-bit elements are
+///    zero-extended to 16-bit values.
+/// \returns A 128-bit vector of [8 x i16] containing the zero-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi16(__m128i __V) {
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1, 2, 3, 4, 5, 6,
+                              7),
+      __v8hi);
+}
+
+/// Zero-extends each of the lower four 8-bit integer elements of a
+///    128-bit vector of [16 x i8] to 32-bit values and returns them in a
+///    128-bit vector of [4 x i32]. The upper twelve elements of the input
+///    vector are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVZXBD / PMOVZXBD </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [16 x i8]. The lower four 8-bit elements are
+///    zero-extended to 32-bit values.
+/// \returns A 128-bit vector of [4 x i32] containing the zero-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi32(__m128i __V) {
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1, 2, 3), __v4si);
+}
+
+/// Zero-extends each of the lower two 8-bit integer elements of a
+///    128-bit integer vector of [16 x i8] to 64-bit values and returns them in
+///    a 128-bit vector of [2 x i64]. The upper fourteen elements of the input
+///    vector are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVZXBQ / PMOVZXBQ </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [16 x i8]. The lower two 8-bit elements are
+///    zero-extended to 64-bit values.
+/// \returns A 128-bit vector of [2 x i64] containing the zero-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu8_epi64(__m128i __V) {
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v16qu)__V, (__v16qu)__V, 0, 1), __v2di);
+}
+
+/// Zero-extends each of the lower four 16-bit integer elements of a
+///    128-bit integer vector of [8 x i16] to 32-bit values and returns them in
+///    a 128-bit vector of [4 x i32]. The upper four elements of the input
+///    vector are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVZXWD / PMOVZXWD </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [8 x i16]. The lower four 16-bit elements are
+///    zero-extended to 32-bit values.
+/// \returns A 128-bit vector of [4 x i32] containing the zero-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu16_epi32(__m128i __V) {
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v8hu)__V, (__v8hu)__V, 0, 1, 2, 3), __v4si);
+}
+
+/// Zero-extends each of the lower two 16-bit integer elements of a
+///    128-bit integer vector of [8 x i16] to 64-bit values and returns them in
+///    a 128-bit vector of [2 x i64]. The upper six elements of the input vector
+///    are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVZXWQ / PMOVZXWQ </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [8 x i16]. The lower two 16-bit elements are
+///    zero-extended to 64-bit values.
+/// \returns A 128-bit vector of [2 x i64] containing the zero-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu16_epi64(__m128i __V) {
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v8hu)__V, (__v8hu)__V, 0, 1), __v2di);
+}
+
+/// Zero-extends each of the lower two 32-bit integer elements of a
+///    128-bit integer vector of [4 x i32] to 64-bit values and returns them in
+///    a 128-bit vector of [2 x i64]. The upper two elements of the input vector
+///    are unused.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPMOVZXDQ / PMOVZXDQ </c> instruction.
+///
+/// \param __V
+///    A 128-bit vector of [4 x i32]. The lower two 32-bit elements are
+///    zero-extended to 64-bit values.
+/// \returns A 128-bit vector of [2 x i64] containing the zero-extended values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cvtepu32_epi64(__m128i __V) {
+  return (__m128i) __builtin_convertvector(
+      __builtin_shufflevector((__v4su)__V, (__v4su)__V, 0, 1), __v2di);
+}
+
+/* SSE4 Pack with Unsigned Saturation.  */
+/// Converts, with saturation, 32-bit signed integers from both 128-bit integer
+///    vector operands into 16-bit unsigned integers, and returns the packed
+///    result.
+///
+///    Values greater than 0xFFFF are saturated to 0xFFFF. Values less than
+///    0x0000 are saturated to 0x0000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPACKUSDW / PACKUSDW </c> instruction.
+///
+/// \param __V1
+///    A 128-bit vector of [4 x i32]. The converted [4 x i16] values are
+///    written to the lower 64 bits of the result.
+/// \param __V2
+///    A 128-bit vector of [4 x i32]. The converted [4 x i16] values are
+///    written to the higher 64 bits of the result.
+/// \returns A 128-bit vector of [8 x i16] containing the converted values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_packus_epi32(__m128i __V1,
+                                                              __m128i __V2) {
+  return (__m128i)__builtin_ia32_packusdw128((__v4si)__V1, (__v4si)__V2);
+}
+
+/* SSE4 Multiple Packed Sums of Absolute Difference.  */
+/// Subtracts 8-bit unsigned integer values and computes the absolute
+///    values of the differences to the corresponding bits in the destination.
+///    Then sums of the absolute differences are returned according to the bit
+///    fields in the immediate operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_mpsadbw_epu8(__m128i X, __m128i Y, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VMPSADBW / MPSADBW </c> instruction.
+///
+/// \param X
+///    A 128-bit vector of [16 x i8].
+/// \param Y
+///    A 128-bit vector of [16 x i8].
+/// \param M
+///    An 8-bit immediate operand specifying how the absolute differences are to
+///    be calculated, according to the following algorithm:
+///    \code
+///    // M2 represents bit 2 of the immediate operand
+///    // M10 represents bits [1:0] of the immediate operand
+///    i = M2 * 4;
+///    j = M10 * 4;
+///    for (k = 0; k < 8; k = k + 1) {
+///      d0 = abs(X[i + k + 0] - Y[j + 0]);
+///      d1 = abs(X[i + k + 1] - Y[j + 1]);
+///      d2 = abs(X[i + k + 2] - Y[j + 2]);
+///      d3 = abs(X[i + k + 3] - Y[j + 3]);
+///      r[k] = d0 + d1 + d2 + d3;
+///    }
+///    \endcode
+/// \returns A 128-bit integer vector containing the sums of the sets of
+///    absolute differences between both operands.
+#define _mm_mpsadbw_epu8(X, Y, M)                                              \
+  ((__m128i)__builtin_ia32_mpsadbw128((__v16qi)(__m128i)(X),                   \
+                                      (__v16qi)(__m128i)(Y), (M)))
+
+/// Finds the minimum unsigned 16-bit element in the input 128-bit
+///    vector of [8 x u16] and returns it and along with its index.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPHMINPOSUW / PHMINPOSUW </c>
+/// instruction.
+///
+/// \param __V
+///    A 128-bit vector of [8 x u16].
+/// \returns A 128-bit value where bits [15:0] contain the minimum value found
+///    in parameter \a __V, bits [18:16] contain the index of the minimum value
+///    and the remaining bits are set to 0.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_minpos_epu16(__m128i __V) {
+  return (__m128i)__builtin_ia32_phminposuw128((__v8hi)__V);
+}
+
+/* Handle the sse4.2 definitions here. */
+
+/* These definitions are normally in nmmintrin.h, but gcc puts them in here
+   so we'll do the same.  */
+
+#undef __DEFAULT_FN_ATTRS
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__, __target__("sse4.2")))
+
+/* These specify the type of data that we're comparing.  */
+#define _SIDD_UBYTE_OPS 0x00
+#define _SIDD_UWORD_OPS 0x01
+#define _SIDD_SBYTE_OPS 0x02
+#define _SIDD_SWORD_OPS 0x03
+
+/* These specify the type of comparison operation.  */
+#define _SIDD_CMP_EQUAL_ANY 0x00
+#define _SIDD_CMP_RANGES 0x04
+#define _SIDD_CMP_EQUAL_EACH 0x08
+#define _SIDD_CMP_EQUAL_ORDERED 0x0c
+
+/* These macros specify the polarity of the operation.  */
+#define _SIDD_POSITIVE_POLARITY 0x00
+#define _SIDD_NEGATIVE_POLARITY 0x10
+#define _SIDD_MASKED_POSITIVE_POLARITY 0x20
+#define _SIDD_MASKED_NEGATIVE_POLARITY 0x30
+
+/* These macros are used in _mm_cmpXstri() to specify the return.  */
+#define _SIDD_LEAST_SIGNIFICANT 0x00
+#define _SIDD_MOST_SIGNIFICANT 0x40
+
+/* These macros are used in _mm_cmpXstri() to specify the return.  */
+#define _SIDD_BIT_MASK 0x00
+#define _SIDD_UNIT_MASK 0x40
+
+/* SSE4.2 Packed Comparison Intrinsics.  */
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with implicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns a 128-bit integer vector representing the result
+///    mask of the comparison.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_cmpistrm(__m128i A, __m128i B, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPISTRM / PCMPISTRM </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words, the type of comparison to perform, and the format of the return
+///    value. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search \a B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B. \n
+///    Bit [6]: Determines whether the result is zero-extended or expanded to 16
+///             bytes. \n
+///      0: The result is zero-extended to 16 bytes. \n
+///      1: The result is expanded to 16 bytes (this expansion is performed by
+///         repeating each bit 8 or 16 times).
+/// \returns Returns a 128-bit integer vector representing the result mask of
+///    the comparison.
+#define _mm_cmpistrm(A, B, M)                                                  \
+  ((__m128i)__builtin_ia32_pcmpistrm128((__v16qi)(__m128i)(A),                 \
+                                        (__v16qi)(__m128i)(B), (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with implicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns an integer representing the result index of the
+///    comparison.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpistri(__m128i A, __m128i B, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words, the type of comparison to perform, and the format of the return
+///    value. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B. \n
+///    Bit [6]: Determines whether the index of the lowest set bit or the
+///             highest set bit is returned. \n
+///      0: The index of the least significant set bit. \n
+///      1: The index of the most significant set bit. \n
+/// \returns Returns an integer representing the result index of the comparison.
+#define _mm_cmpistri(A, B, M)                                                  \
+  ((int)__builtin_ia32_pcmpistri128((__v16qi)(__m128i)(A),                     \
+                                    (__v16qi)(__m128i)(B), (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with explicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns a 128-bit integer vector representing the result
+///    mask of the comparison.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_cmpestrm(__m128i A, int LA, __m128i B, int LB, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPESTRM / PCMPESTRM </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LA
+///    An integer that specifies the length of the string in \a A.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LB
+///    An integer that specifies the length of the string in \a B.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words, the type of comparison to perform, and the format of the return
+///    value. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search \a B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B. \n
+///    Bit [6]: Determines whether the result is zero-extended or expanded to 16
+///             bytes. \n
+///      0: The result is zero-extended to 16 bytes. \n
+///      1: The result is expanded to 16 bytes (this expansion is performed by
+///         repeating each bit 8 or 16 times). \n
+/// \returns Returns a 128-bit integer vector representing the result mask of
+///    the comparison.
+#define _mm_cmpestrm(A, LA, B, LB, M)                                          \
+  ((__m128i)__builtin_ia32_pcmpestrm128((__v16qi)(__m128i)(A), (int)(LA),      \
+                                        (__v16qi)(__m128i)(B), (int)(LB),      \
+                                        (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with explicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns an integer representing the result index of the
+///    comparison.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpestri(__m128i A, int LA, __m128i B, int LB, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LA
+///    An integer that specifies the length of the string in \a A.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LB
+///    An integer that specifies the length of the string in \a B.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words, the type of comparison to perform, and the format of the return
+///    value. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B. \n
+///    Bit [6]: Determines whether the index of the lowest set bit or the
+///             highest set bit is returned. \n
+///      0: The index of the least significant set bit. \n
+///      1: The index of the most significant set bit. \n
+/// \returns Returns an integer representing the result index of the comparison.
+#define _mm_cmpestri(A, LA, B, LB, M)                                          \
+  ((int)__builtin_ia32_pcmpestri128((__v16qi)(__m128i)(A), (int)(LA),          \
+                                    (__v16qi)(__m128i)(B), (int)(LB),          \
+                                    (int)(M)))
+
+/* SSE4.2 Packed Comparison Intrinsics and EFlag Reading.  */
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with implicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns 1 if the bit mask is zero and the length of the
+///    string in \a B is the maximum, otherwise, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpistra(__m128i A, __m128i B, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words and the type of comparison to perform. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search \a B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B. \n
+/// \returns Returns 1 if the bit mask is zero and the length of the string in
+///    \a B is the maximum; otherwise, returns 0.
+#define _mm_cmpistra(A, B, M)                                                  \
+  ((int)__builtin_ia32_pcmpistria128((__v16qi)(__m128i)(A),                    \
+                                     (__v16qi)(__m128i)(B), (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with implicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns 1 if the bit mask is non-zero, otherwise, returns
+///    0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpistrc(__m128i A, __m128i B, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words and the type of comparison to perform. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B.
+/// \returns Returns 1 if the bit mask is non-zero, otherwise, returns 0.
+#define _mm_cmpistrc(A, B, M)                                                  \
+  ((int)__builtin_ia32_pcmpistric128((__v16qi)(__m128i)(A),                    \
+                                     (__v16qi)(__m128i)(B), (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with implicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns bit 0 of the resulting bit mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpistro(__m128i A, __m128i B, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words and the type of comparison to perform. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B. \n
+/// \returns Returns bit 0 of the resulting bit mask.
+#define _mm_cmpistro(A, B, M)                                                  \
+  ((int)__builtin_ia32_pcmpistrio128((__v16qi)(__m128i)(A),                    \
+                                     (__v16qi)(__m128i)(B), (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with implicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns 1 if the length of the string in \a A is less than
+///    the maximum, otherwise, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpistrs(__m128i A, __m128i B, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words and the type of comparison to perform. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search \a B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B. \n
+/// \returns Returns 1 if the length of the string in \a A is less than the
+///    maximum, otherwise, returns 0.
+#define _mm_cmpistrs(A, B, M)                                                  \
+  ((int)__builtin_ia32_pcmpistris128((__v16qi)(__m128i)(A),                    \
+                                     (__v16qi)(__m128i)(B), (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with implicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns 1 if the length of the string in \a B is less than
+///    the maximum, otherwise, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpistrz(__m128i A, __m128i B, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPISTRI / PCMPISTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words and the type of comparison to perform. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search \a B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B.
+/// \returns Returns 1 if the length of the string in \a B is less than the
+///    maximum, otherwise, returns 0.
+#define _mm_cmpistrz(A, B, M)                                                  \
+  ((int)__builtin_ia32_pcmpistriz128((__v16qi)(__m128i)(A),                    \
+                                     (__v16qi)(__m128i)(B), (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with explicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns 1 if the bit mask is zero and the length of the
+///    string in \a B is the maximum, otherwise, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpestra(__m128i A, int LA, __m128i B, int LB, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LA
+///    An integer that specifies the length of the string in \a A.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LB
+///    An integer that specifies the length of the string in \a B.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words and the type of comparison to perform. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search \a B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B.
+/// \returns Returns 1 if the bit mask is zero and the length of the string in
+///    \a B is the maximum, otherwise, returns 0.
+#define _mm_cmpestra(A, LA, B, LB, M)                                          \
+  ((int)__builtin_ia32_pcmpestria128((__v16qi)(__m128i)(A), (int)(LA),         \
+                                     (__v16qi)(__m128i)(B), (int)(LB),         \
+                                     (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with explicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns 1 if the resulting mask is non-zero, otherwise,
+///    returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpestrc(__m128i A, int LA, __m128i B, int LB, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LA
+///    An integer that specifies the length of the string in \a A.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LB
+///    An integer that specifies the length of the string in \a B.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words and the type of comparison to perform. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search \a B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B. \n
+/// \returns Returns 1 if the resulting mask is non-zero, otherwise, returns 0.
+#define _mm_cmpestrc(A, LA, B, LB, M)                                          \
+  ((int)__builtin_ia32_pcmpestric128((__v16qi)(__m128i)(A), (int)(LA),         \
+                                     (__v16qi)(__m128i)(B), (int)(LB),         \
+                                     (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with explicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns bit 0 of the resulting bit mask.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpestro(__m128i A, int LA, __m128i B, int LB, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LA
+///    An integer that specifies the length of the string in \a A.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LB
+///    An integer that specifies the length of the string in \a B.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words and the type of comparison to perform. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search \a B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B.
+/// \returns Returns bit 0 of the resulting bit mask.
+#define _mm_cmpestro(A, LA, B, LB, M)                                          \
+  ((int)__builtin_ia32_pcmpestrio128((__v16qi)(__m128i)(A), (int)(LA),         \
+                                     (__v16qi)(__m128i)(B), (int)(LB),         \
+                                     (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with explicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns 1 if the length of the string in \a A is less than
+///    the maximum, otherwise, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpestrs(__m128i A, int LA, __m128i B, int LB, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPESTRI / PCMPESTRI </c>
+/// instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LA
+///    An integer that specifies the length of the string in \a A.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LB
+///    An integer that specifies the length of the string in \a B.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words and the type of comparison to perform. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search \a B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement in the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B. \n
+/// \returns Returns 1 if the length of the string in \a A is less than the
+///    maximum, otherwise, returns 0.
+#define _mm_cmpestrs(A, LA, B, LB, M)                                          \
+  ((int)__builtin_ia32_pcmpestris128((__v16qi)(__m128i)(A), (int)(LA),         \
+                                     (__v16qi)(__m128i)(B), (int)(LB),         \
+                                     (int)(M)))
+
+/// Uses the immediate operand \a M to perform a comparison of string
+///    data with explicitly defined lengths that is contained in source operands
+///    \a A and \a B. Returns 1 if the length of the string in \a B is less than
+///    the maximum, otherwise, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_cmpestrz(__m128i A, int LA, __m128i B, int LB, const int M);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPCMPESTRI </c> instruction.
+///
+/// \param A
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LA
+///    An integer that specifies the length of the string in \a A.
+/// \param B
+///    A 128-bit integer vector containing one of the source operands to be
+///    compared.
+/// \param LB
+///    An integer that specifies the length of the string in \a B.
+/// \param M
+///    An 8-bit immediate operand specifying whether the characters are bytes or
+///    words and the type of comparison to perform. \n
+///    Bits [1:0]: Determine source data format. \n
+///      00: 16 unsigned bytes  \n
+///      01: 8 unsigned words \n
+///      10: 16 signed bytes \n
+///      11: 8 signed words \n
+///    Bits [3:2]: Determine comparison type and aggregation method. \n
+///      00: Subset: Each character in \a B is compared for equality with all
+///          the characters in \a A. \n
+///      01: Ranges: Each character in \a B is compared to \a A. The comparison
+///          basis is greater than or equal for even-indexed elements in \a A,
+///          and less than or equal for odd-indexed elements in \a A. \n
+///      10: Match: Compare each pair of corresponding characters in \a A and
+///          \a B for equality. \n
+///      11: Substring: Search \a B for substring matches of \a A. \n
+///    Bits [5:4]: Determine whether to perform a one's complement on the bit
+///                mask of the comparison results. \n
+///      00: No effect. \n
+///      01: Negate the bit mask. \n
+///      10: No effect. \n
+///      11: Negate the bit mask only for bits with an index less than or equal
+///          to the size of \a A or \a B.
+/// \returns Returns 1 if the length of the string in \a B is less than the
+///    maximum, otherwise, returns 0.
+#define _mm_cmpestrz(A, LA, B, LB, M)                                          \
+  ((int)__builtin_ia32_pcmpestriz128((__v16qi)(__m128i)(A), (int)(LA),         \
+                                     (__v16qi)(__m128i)(B), (int)(LB),         \
+                                     (int)(M)))
+
+/* SSE4.2 Compare Packed Data -- Greater Than.  */
+/// Compares each of the corresponding 64-bit values of the 128-bit
+///    integer vectors to determine if the values in the first operand are
+///    greater than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPCMPGTQ / PCMPGTQ </c> instruction.
+///
+/// \param __V1
+///    A 128-bit integer vector.
+/// \param __V2
+///    A 128-bit integer vector.
+/// \returns A 128-bit integer vector containing the comparison results.
+static __inline__ __m128i __DEFAULT_FN_ATTRS _mm_cmpgt_epi64(__m128i __V1,
+                                                             __m128i __V2) {
+  return (__m128i)((__v2di)__V1 > (__v2di)__V2);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#include "popcntintrin.h"
+
+#include "crc32intrin.h"
+
+#endif /* __SMMINTRIN_H */
diff --git a/third_party/intel/clang/tbmintrin.h b/third_party/intel/clang/tbmintrin.h
new file mode 100644
index 000000000..f4e848a1c
--- /dev/null
+++ b/third_party/intel/clang/tbmintrin.h
@@ -0,0 +1,140 @@
+/*===---- tbmintrin.h - TBM intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __X86INTRIN_H
+#error "Never use <tbmintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __TBMINTRIN_H
+#define __TBMINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("tbm")))
+
+#define __bextri_u32(a, b) \
+  ((unsigned int)__builtin_ia32_bextri_u32((unsigned int)(a), \
+                                           (unsigned int)(b)))
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__blcfill_u32(unsigned int __a)
+{
+  return __a & (__a + 1);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__blci_u32(unsigned int __a)
+{
+  return __a | ~(__a + 1);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__blcic_u32(unsigned int __a)
+{
+  return ~__a & (__a + 1);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__blcmsk_u32(unsigned int __a)
+{
+  return __a ^ (__a + 1);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__blcs_u32(unsigned int __a)
+{
+  return __a | (__a + 1);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__blsfill_u32(unsigned int __a)
+{
+  return __a | (__a - 1);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__blsic_u32(unsigned int __a)
+{
+  return ~__a | (__a - 1);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__t1mskc_u32(unsigned int __a)
+{
+  return ~__a | (__a + 1);
+}
+
+static __inline__ unsigned int __DEFAULT_FN_ATTRS
+__tzmsk_u32(unsigned int __a)
+{
+  return ~__a & (__a - 1);
+}
+
+#ifdef __x86_64__
+#define __bextri_u64(a, b) \
+  ((unsigned long long)__builtin_ia32_bextri_u64((unsigned long long)(a), \
+                                                 (unsigned long long)(b)))
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__blcfill_u64(unsigned long long __a)
+{
+  return __a & (__a + 1);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__blci_u64(unsigned long long __a)
+{
+  return __a | ~(__a + 1);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__blcic_u64(unsigned long long __a)
+{
+  return ~__a & (__a + 1);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__blcmsk_u64(unsigned long long __a)
+{
+  return __a ^ (__a + 1);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__blcs_u64(unsigned long long __a)
+{
+  return __a | (__a + 1);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__blsfill_u64(unsigned long long __a)
+{
+  return __a | (__a - 1);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__blsic_u64(unsigned long long __a)
+{
+  return ~__a | (__a - 1);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__t1mskc_u64(unsigned long long __a)
+{
+  return ~__a | (__a + 1);
+}
+
+static __inline__ unsigned long long __DEFAULT_FN_ATTRS
+__tzmsk_u64(unsigned long long __a)
+{
+  return ~__a & (__a - 1);
+}
+#endif
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __TBMINTRIN_H */
diff --git a/third_party/intel/clang/tmmintrin.h b/third_party/intel/clang/tmmintrin.h
new file mode 100644
index 000000000..1674545c0
--- /dev/null
+++ b/third_party/intel/clang/tmmintrin.h
@@ -0,0 +1,784 @@
+/*===---- tmmintrin.h - SSSE3 intrinsics -----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __TMMINTRIN_H
+#define __TMMINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+#include "pmmintrin.h"
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("ssse3,no-evex512"), __min_vector_width__(64)))
+#define __DEFAULT_FN_ATTRS_MMX                                                 \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("mmx,ssse3,no-evex512"),                           \
+                 __min_vector_width__(64)))
+
+/// Computes the absolute value of each of the packed 8-bit signed
+///    integers in the source operand and stores the 8-bit unsigned integer
+///    results in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PABSB instruction.
+///
+/// \param __a
+///    A 64-bit vector of [8 x i8].
+/// \returns A 64-bit integer vector containing the absolute values of the
+///    elements in the operand.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_abs_pi8(__m64 __a)
+{
+    return (__m64)__builtin_ia32_pabsb((__v8qi)__a);
+}
+
+/// Computes the absolute value of each of the packed 8-bit signed
+///    integers in the source operand and stores the 8-bit unsigned integer
+///    results in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPABSB instruction.
+///
+/// \param __a
+///    A 128-bit vector of [16 x i8].
+/// \returns A 128-bit integer vector containing the absolute values of the
+///    elements in the operand.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_abs_epi8(__m128i __a)
+{
+    return (__m128i)__builtin_elementwise_abs((__v16qs)__a);
+}
+
+/// Computes the absolute value of each of the packed 16-bit signed
+///    integers in the source operand and stores the 16-bit unsigned integer
+///    results in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PABSW instruction.
+///
+/// \param __a
+///    A 64-bit vector of [4 x i16].
+/// \returns A 64-bit integer vector containing the absolute values of the
+///    elements in the operand.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_abs_pi16(__m64 __a)
+{
+    return (__m64)__builtin_ia32_pabsw((__v4hi)__a);
+}
+
+/// Computes the absolute value of each of the packed 16-bit signed
+///    integers in the source operand and stores the 16-bit unsigned integer
+///    results in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPABSW instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x i16].
+/// \returns A 128-bit integer vector containing the absolute values of the
+///    elements in the operand.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_abs_epi16(__m128i __a)
+{
+    return (__m128i)__builtin_elementwise_abs((__v8hi)__a);
+}
+
+/// Computes the absolute value of each of the packed 32-bit signed
+///    integers in the source operand and stores the 32-bit unsigned integer
+///    results in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PABSD instruction.
+///
+/// \param __a
+///    A 64-bit vector of [2 x i32].
+/// \returns A 64-bit integer vector containing the absolute values of the
+///    elements in the operand.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_abs_pi32(__m64 __a)
+{
+    return (__m64)__builtin_ia32_pabsd((__v2si)__a);
+}
+
+/// Computes the absolute value of each of the packed 32-bit signed
+///    integers in the source operand and stores the 32-bit unsigned integer
+///    results in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPABSD instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x i32].
+/// \returns A 128-bit integer vector containing the absolute values of the
+///    elements in the operand.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_abs_epi32(__m128i __a)
+{
+    return (__m128i)__builtin_elementwise_abs((__v4si)__a);
+}
+
+/// Concatenates the two 128-bit integer vector operands, and
+///    right-shifts the result by the number of bytes specified in the immediate
+///    operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128i _mm_alignr_epi8(__m128i a, __m128i b, const int n);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c PALIGNR instruction.
+///
+/// \param a
+///    A 128-bit vector of [16 x i8] containing one of the source operands.
+/// \param b
+///    A 128-bit vector of [16 x i8] containing one of the source operands.
+/// \param n
+///    An immediate operand specifying how many bytes to right-shift the result.
+/// \returns A 128-bit integer vector containing the concatenated right-shifted
+///    value.
+#define _mm_alignr_epi8(a, b, n) \
+  ((__m128i)__builtin_ia32_palignr128((__v16qi)(__m128i)(a), \
+                                      (__v16qi)(__m128i)(b), (n)))
+
+/// Concatenates the two 64-bit integer vector operands, and right-shifts
+///    the result by the number of bytes specified in the immediate operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m64 _mm_alignr_pi8(__m64 a, __m64 b, const int n);
+/// \endcode
+///
+/// This intrinsic corresponds to the \c PALIGNR instruction.
+///
+/// \param a
+///    A 64-bit vector of [8 x i8] containing one of the source operands.
+/// \param b
+///    A 64-bit vector of [8 x i8] containing one of the source operands.
+/// \param n
+///    An immediate operand specifying how many bytes to right-shift the result.
+/// \returns A 64-bit integer vector containing the concatenated right-shifted
+///    value.
+#define _mm_alignr_pi8(a, b, n) \
+  ((__m64)__builtin_ia32_palignr((__v8qi)(__m64)(a), (__v8qi)(__m64)(b), (n)))
+
+/// Horizontally adds the adjacent pairs of values contained in 2 packed
+///    128-bit vectors of [8 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPHADDW instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x i16] containing one of the source operands. The
+///    horizontal sums of the values are stored in the lower bits of the
+///    destination.
+/// \param __b
+///    A 128-bit vector of [8 x i16] containing one of the source operands. The
+///    horizontal sums of the values are stored in the upper bits of the
+///    destination.
+/// \returns A 128-bit vector of [8 x i16] containing the horizontal sums of
+///    both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_hadd_epi16(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_phaddw128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Horizontally adds the adjacent pairs of values contained in 2 packed
+///    128-bit vectors of [4 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPHADDD instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x i32] containing one of the source operands. The
+///    horizontal sums of the values are stored in the lower bits of the
+///    destination.
+/// \param __b
+///    A 128-bit vector of [4 x i32] containing one of the source operands. The
+///    horizontal sums of the values are stored in the upper bits of the
+///    destination.
+/// \returns A 128-bit vector of [4 x i32] containing the horizontal sums of
+///    both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_hadd_epi32(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_phaddd128((__v4si)__a, (__v4si)__b);
+}
+
+/// Horizontally adds the adjacent pairs of values contained in 2 packed
+///    64-bit vectors of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PHADDW instruction.
+///
+/// \param __a
+///    A 64-bit vector of [4 x i16] containing one of the source operands. The
+///    horizontal sums of the values are stored in the lower bits of the
+///    destination.
+/// \param __b
+///    A 64-bit vector of [4 x i16] containing one of the source operands. The
+///    horizontal sums of the values are stored in the upper bits of the
+///    destination.
+/// \returns A 64-bit vector of [4 x i16] containing the horizontal sums of both
+///    operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_hadd_pi16(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_phaddw((__v4hi)__a, (__v4hi)__b);
+}
+
+/// Horizontally adds the adjacent pairs of values contained in 2 packed
+///    64-bit vectors of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PHADDD instruction.
+///
+/// \param __a
+///    A 64-bit vector of [2 x i32] containing one of the source operands. The
+///    horizontal sums of the values are stored in the lower bits of the
+///    destination.
+/// \param __b
+///    A 64-bit vector of [2 x i32] containing one of the source operands. The
+///    horizontal sums of the values are stored in the upper bits of the
+///    destination.
+/// \returns A 64-bit vector of [2 x i32] containing the horizontal sums of both
+///    operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_hadd_pi32(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_phaddd((__v2si)__a, (__v2si)__b);
+}
+
+/// Horizontally adds, with saturation, the adjacent pairs of values contained
+///    in two packed 128-bit vectors of [8 x i16].
+///
+///    Positive sums greater than 0x7FFF are saturated to 0x7FFF. Negative sums
+///    less than 0x8000 are saturated to 0x8000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPHADDSW instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x i16] containing one of the source operands. The
+///    horizontal sums of the values are stored in the lower bits of the
+///    destination.
+/// \param __b
+///    A 128-bit vector of [8 x i16] containing one of the source operands. The
+///    horizontal sums of the values are stored in the upper bits of the
+///    destination.
+/// \returns A 128-bit vector of [8 x i16] containing the horizontal saturated
+///    sums of both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_hadds_epi16(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_phaddsw128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Horizontally adds, with saturation, the adjacent pairs of values contained
+///    in two packed 64-bit vectors of [4 x i16].
+///
+///    Positive sums greater than 0x7FFF are saturated to 0x7FFF. Negative sums
+///    less than 0x8000 are saturated to 0x8000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PHADDSW instruction.
+///
+/// \param __a
+///    A 64-bit vector of [4 x i16] containing one of the source operands. The
+///    horizontal sums of the values are stored in the lower bits of the
+///    destination.
+/// \param __b
+///    A 64-bit vector of [4 x i16] containing one of the source operands. The
+///    horizontal sums of the values are stored in the upper bits of the
+///    destination.
+/// \returns A 64-bit vector of [4 x i16] containing the horizontal saturated
+///    sums of both operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_hadds_pi16(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_phaddsw((__v4hi)__a, (__v4hi)__b);
+}
+
+/// Horizontally subtracts the adjacent pairs of values contained in 2
+///    packed 128-bit vectors of [8 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPHSUBW instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x i16] containing one of the source operands. The
+///    horizontal differences between the values are stored in the lower bits of
+///    the destination.
+/// \param __b
+///    A 128-bit vector of [8 x i16] containing one of the source operands. The
+///    horizontal differences between the values are stored in the upper bits of
+///    the destination.
+/// \returns A 128-bit vector of [8 x i16] containing the horizontal differences
+///    of both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_hsub_epi16(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_phsubw128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Horizontally subtracts the adjacent pairs of values contained in 2
+///    packed 128-bit vectors of [4 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPHSUBD instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x i32] containing one of the source operands. The
+///    horizontal differences between the values are stored in the lower bits of
+///    the destination.
+/// \param __b
+///    A 128-bit vector of [4 x i32] containing one of the source operands. The
+///    horizontal differences between the values are stored in the upper bits of
+///    the destination.
+/// \returns A 128-bit vector of [4 x i32] containing the horizontal differences
+///    of both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_hsub_epi32(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_phsubd128((__v4si)__a, (__v4si)__b);
+}
+
+/// Horizontally subtracts the adjacent pairs of values contained in 2
+///    packed 64-bit vectors of [4 x i16].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PHSUBW instruction.
+///
+/// \param __a
+///    A 64-bit vector of [4 x i16] containing one of the source operands. The
+///    horizontal differences between the values are stored in the lower bits of
+///    the destination.
+/// \param __b
+///    A 64-bit vector of [4 x i16] containing one of the source operands. The
+///    horizontal differences between the values are stored in the upper bits of
+///    the destination.
+/// \returns A 64-bit vector of [4 x i16] containing the horizontal differences
+///    of both operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_hsub_pi16(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_phsubw((__v4hi)__a, (__v4hi)__b);
+}
+
+/// Horizontally subtracts the adjacent pairs of values contained in 2
+///    packed 64-bit vectors of [2 x i32].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PHSUBD instruction.
+///
+/// \param __a
+///    A 64-bit vector of [2 x i32] containing one of the source operands. The
+///    horizontal differences between the values are stored in the lower bits of
+///    the destination.
+/// \param __b
+///    A 64-bit vector of [2 x i32] containing one of the source operands. The
+///    horizontal differences between the values are stored in the upper bits of
+///    the destination.
+/// \returns A 64-bit vector of [2 x i32] containing the horizontal differences
+///    of both operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_hsub_pi32(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_phsubd((__v2si)__a, (__v2si)__b);
+}
+
+/// Horizontally subtracts, with saturation, the adjacent pairs of values
+///    contained in two packed 128-bit vectors of [8 x i16].
+///
+///    Positive differences greater than 0x7FFF are saturated to 0x7FFF.
+///    Negative differences less than 0x8000 are saturated to 0x8000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPHSUBSW instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x i16] containing one of the source operands. The
+///    horizontal differences between the values are stored in the lower bits of
+///    the destination.
+/// \param __b
+///    A 128-bit vector of [8 x i16] containing one of the source operands. The
+///    horizontal differences between the values are stored in the upper bits of
+///    the destination.
+/// \returns A 128-bit vector of [8 x i16] containing the horizontal saturated
+///    differences of both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_hsubs_epi16(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_phsubsw128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Horizontally subtracts, with saturation, the adjacent pairs of values
+///    contained in two packed 64-bit vectors of [4 x i16].
+///
+///    Positive differences greater than 0x7FFF are saturated to 0x7FFF.
+///    Negative differences less than 0x8000 are saturated to 0x8000.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PHSUBSW instruction.
+///
+/// \param __a
+///    A 64-bit vector of [4 x i16] containing one of the source operands. The
+///    horizontal differences between the values are stored in the lower bits of
+///    the destination.
+/// \param __b
+///    A 64-bit vector of [4 x i16] containing one of the source operands. The
+///    horizontal differences between the values are stored in the upper bits of
+///    the destination.
+/// \returns A 64-bit vector of [4 x i16] containing the horizontal saturated
+///    differences of both operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_hsubs_pi16(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_phsubsw((__v4hi)__a, (__v4hi)__b);
+}
+
+/// Multiplies corresponding pairs of packed 8-bit unsigned integer
+///    values contained in the first source operand and packed 8-bit signed
+///    integer values contained in the second source operand, adds pairs of
+///    contiguous products with signed saturation, and writes the 16-bit sums to
+///    the corresponding bits in the destination.
+///
+///    For example, bits [7:0] of both operands are multiplied, bits [15:8] of
+///    both operands are multiplied, and the sum of both results is written to
+///    bits [15:0] of the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPMADDUBSW instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the first source operand.
+/// \param __b
+///    A 128-bit integer vector containing the second source operand.
+/// \returns A 128-bit integer vector containing the sums of products of both
+///    operands: \n
+///    \a R0 := (\a __a0 * \a __b0) + (\a __a1 * \a __b1) \n
+///    \a R1 := (\a __a2 * \a __b2) + (\a __a3 * \a __b3) \n
+///    \a R2 := (\a __a4 * \a __b4) + (\a __a5 * \a __b5) \n
+///    \a R3 := (\a __a6 * \a __b6) + (\a __a7 * \a __b7) \n
+///    \a R4 := (\a __a8 * \a __b8) + (\a __a9 * \a __b9) \n
+///    \a R5 := (\a __a10 * \a __b10) + (\a __a11 * \a __b11) \n
+///    \a R6 := (\a __a12 * \a __b12) + (\a __a13 * \a __b13) \n
+///    \a R7 := (\a __a14 * \a __b14) + (\a __a15 * \a __b15)
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_maddubs_epi16(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_pmaddubsw128((__v16qi)__a, (__v16qi)__b);
+}
+
+/// Multiplies corresponding pairs of packed 8-bit unsigned integer
+///    values contained in the first source operand and packed 8-bit signed
+///    integer values contained in the second source operand, adds pairs of
+///    contiguous products with signed saturation, and writes the 16-bit sums to
+///    the corresponding bits in the destination.
+///
+///    For example, bits [7:0] of both operands are multiplied, bits [15:8] of
+///    both operands are multiplied, and the sum of both results is written to
+///    bits [15:0] of the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PMADDUBSW instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing the first source operand.
+/// \param __b
+///    A 64-bit integer vector containing the second source operand.
+/// \returns A 64-bit integer vector containing the sums of products of both
+///    operands: \n
+///    \a R0 := (\a __a0 * \a __b0) + (\a __a1 * \a __b1) \n
+///    \a R1 := (\a __a2 * \a __b2) + (\a __a3 * \a __b3) \n
+///    \a R2 := (\a __a4 * \a __b4) + (\a __a5 * \a __b5) \n
+///    \a R3 := (\a __a6 * \a __b6) + (\a __a7 * \a __b7)
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_maddubs_pi16(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_pmaddubsw((__v8qi)__a, (__v8qi)__b);
+}
+
+/// Multiplies packed 16-bit signed integer values, truncates the 32-bit
+///    products to the 18 most significant bits by right-shifting, rounds the
+///    truncated value by adding 1, and writes bits [16:1] to the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPMULHRSW instruction.
+///
+/// \param __a
+///    A 128-bit vector of [8 x i16] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [8 x i16] containing one of the source operands.
+/// \returns A 128-bit vector of [8 x i16] containing the rounded and scaled
+///    products of both operands.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_mulhrs_epi16(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_pmulhrsw128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// Multiplies packed 16-bit signed integer values, truncates the 32-bit
+///    products to the 18 most significant bits by right-shifting, rounds the
+///    truncated value by adding 1, and writes bits [16:1] to the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PMULHRSW instruction.
+///
+/// \param __a
+///    A 64-bit vector of [4 x i16] containing one of the source operands.
+/// \param __b
+///    A 64-bit vector of [4 x i16] containing one of the source operands.
+/// \returns A 64-bit vector of [4 x i16] containing the rounded and scaled
+///    products of both operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_mulhrs_pi16(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_pmulhrsw((__v4hi)__a, (__v4hi)__b);
+}
+
+/// Copies the 8-bit integers from a 128-bit integer vector to the
+///    destination or clears 8-bit values in the destination, as specified by
+///    the second source operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPSHUFB instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the values to be copied.
+/// \param __b
+///    A 128-bit integer vector containing control bytes corresponding to
+///    positions in the destination:
+///    Bit 7: \n
+///    1: Clear the corresponding byte in the destination. \n
+///    0: Copy the selected source byte to the corresponding byte in the
+///    destination. \n
+///    Bits [6:4] Reserved.  \n
+///    Bits [3:0] select the source byte to be copied.
+/// \returns A 128-bit integer vector containing the copied or cleared values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_shuffle_epi8(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_pshufb128((__v16qi)__a, (__v16qi)__b);
+}
+
+/// Copies the 8-bit integers from a 64-bit integer vector to the
+///    destination or clears 8-bit values in the destination, as specified by
+///    the second source operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PSHUFB instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing the values to be copied.
+/// \param __b
+///    A 64-bit integer vector containing control bytes corresponding to
+///    positions in the destination:
+///    Bit 7: \n
+///    1: Clear the corresponding byte in the destination. \n
+///    0: Copy the selected source byte to the corresponding byte in the
+///    destination. \n
+///    Bits [3:0] select the source byte to be copied.
+/// \returns A 64-bit integer vector containing the copied or cleared values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_shuffle_pi8(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_pshufb((__v8qi)__a, (__v8qi)__b);
+}
+
+/// For each 8-bit integer in the first source operand, perform one of
+///    the following actions as specified by the second source operand.
+///
+///    If the byte in the second source is negative, calculate the two's
+///    complement of the corresponding byte in the first source, and write that
+///    value to the destination. If the byte in the second source is positive,
+///    copy the corresponding byte from the first source to the destination. If
+///    the byte in the second source is zero, clear the corresponding byte in
+///    the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPSIGNB instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the values to be copied.
+/// \param __b
+///    A 128-bit integer vector containing control bytes corresponding to
+///    positions in the destination.
+/// \returns A 128-bit integer vector containing the resultant values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sign_epi8(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_psignb128((__v16qi)__a, (__v16qi)__b);
+}
+
+/// For each 16-bit integer in the first source operand, perform one of
+///    the following actions as specified by the second source operand.
+///
+///    If the word in the second source is negative, calculate the two's
+///    complement of the corresponding word in the first source, and write that
+///    value to the destination. If the word in the second source is positive,
+///    copy the corresponding word from the first source to the destination. If
+///    the word in the second source is zero, clear the corresponding word in
+///    the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPSIGNW instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the values to be copied.
+/// \param __b
+///    A 128-bit integer vector containing control words corresponding to
+///    positions in the destination.
+/// \returns A 128-bit integer vector containing the resultant values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sign_epi16(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_psignw128((__v8hi)__a, (__v8hi)__b);
+}
+
+/// For each 32-bit integer in the first source operand, perform one of
+///    the following actions as specified by the second source operand.
+///
+///    If the doubleword in the second source is negative, calculate the two's
+///    complement of the corresponding word in the first source, and write that
+///    value to the destination. If the doubleword in the second source is
+///    positive, copy the corresponding word from the first source to the
+///    destination. If the doubleword in the second source is zero, clear the
+///    corresponding word in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c VPSIGND instruction.
+///
+/// \param __a
+///    A 128-bit integer vector containing the values to be copied.
+/// \param __b
+///    A 128-bit integer vector containing control doublewords corresponding to
+///    positions in the destination.
+/// \returns A 128-bit integer vector containing the resultant values.
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sign_epi32(__m128i __a, __m128i __b)
+{
+    return (__m128i)__builtin_ia32_psignd128((__v4si)__a, (__v4si)__b);
+}
+
+/// For each 8-bit integer in the first source operand, perform one of
+///    the following actions as specified by the second source operand.
+///
+///    If the byte in the second source is negative, calculate the two's
+///    complement of the corresponding byte in the first source, and write that
+///    value to the destination. If the byte in the second source is positive,
+///    copy the corresponding byte from the first source to the destination. If
+///    the byte in the second source is zero, clear the corresponding byte in
+///    the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PSIGNB instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing the values to be copied.
+/// \param __b
+///    A 64-bit integer vector containing control bytes corresponding to
+///    positions in the destination.
+/// \returns A 64-bit integer vector containing the resultant values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_sign_pi8(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_psignb((__v8qi)__a, (__v8qi)__b);
+}
+
+/// For each 16-bit integer in the first source operand, perform one of
+///    the following actions as specified by the second source operand.
+///
+///    If the word in the second source is negative, calculate the two's
+///    complement of the corresponding word in the first source, and write that
+///    value to the destination. If the word in the second source is positive,
+///    copy the corresponding word from the first source to the destination. If
+///    the word in the second source is zero, clear the corresponding word in
+///    the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PSIGNW instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing the values to be copied.
+/// \param __b
+///    A 64-bit integer vector containing control words corresponding to
+///    positions in the destination.
+/// \returns A 64-bit integer vector containing the resultant values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_sign_pi16(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_psignw((__v4hi)__a, (__v4hi)__b);
+}
+
+/// For each 32-bit integer in the first source operand, perform one of
+///    the following actions as specified by the second source operand.
+///
+///    If the doubleword in the second source is negative, calculate the two's
+///    complement of the corresponding doubleword in the first source, and
+///    write that value to the destination. If the doubleword in the second
+///    source is positive, copy the corresponding doubleword from the first
+///    source to the destination. If the doubleword in the second source is
+///    zero, clear the corresponding doubleword in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c PSIGND instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing the values to be copied.
+/// \param __b
+///    A 64-bit integer vector containing two control doublewords corresponding
+///    to positions in the destination.
+/// \returns A 64-bit integer vector containing the resultant values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_sign_pi32(__m64 __a, __m64 __b)
+{
+    return (__m64)__builtin_ia32_psignd((__v2si)__a, (__v2si)__b);
+}
+
+#undef __DEFAULT_FN_ATTRS
+#undef __DEFAULT_FN_ATTRS_MMX
+
+#endif /* __TMMINTRIN_H */
diff --git a/third_party/intel/clang/tsxldtrkintrin.h b/third_party/intel/clang/tsxldtrkintrin.h
new file mode 100644
index 000000000..491823e93
--- /dev/null
+++ b/third_party/intel/clang/tsxldtrkintrin.h
@@ -0,0 +1,56 @@
+/*===------------- tsxldtrkintrin.h - tsxldtrk intrinsics ------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <tsxldtrkintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __TSXLDTRKINTRIN_H
+#define __TSXLDTRKINTRIN_H
+
+/* Define the default attributes for the functions in this file */
+#define _DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__, __target__("tsxldtrk")))
+
+/// Marks the start of an TSX (RTM) suspend load address tracking region. If
+///    this intrinsic is used inside a transactional region, subsequent loads
+///    are not added to the read set of the transaction. If it's used inside a
+///    suspend load address tracking region it will cause transaction abort.
+///    If it's used outside of a transactional region it behaves like a NOP.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c XSUSLDTRK instruction.
+///
+static __inline__ void _DEFAULT_FN_ATTRS
+_xsusldtrk (void)
+{
+    __builtin_ia32_xsusldtrk();
+}
+
+/// Marks the end of an TSX (RTM) suspend load address tracking region. If this
+///    intrinsic is used inside a suspend load address tracking region it will
+///    end the suspend region and all following load addresses will be added to
+///    the transaction read set. If it's used inside an active transaction but
+///    not in a suspend region it will cause transaction abort. If it's used
+///    outside of a transactional region it behaves like a NOP.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the \c XRESLDTRK instruction.
+///
+static __inline__ void _DEFAULT_FN_ATTRS
+_xresldtrk (void)
+{
+    __builtin_ia32_xresldtrk();
+}
+
+#undef _DEFAULT_FN_ATTRS
+
+#endif /* __TSXLDTRKINTRIN_H */
diff --git a/third_party/intel/clang/uintrintrin.h b/third_party/intel/clang/uintrintrin.h
new file mode 100644
index 000000000..135dc814c
--- /dev/null
+++ b/third_party/intel/clang/uintrintrin.h
@@ -0,0 +1,157 @@
+/*===------------------ uintrintrin.h - UINTR intrinsics -------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __X86GPRINTRIN_H
+#error "Never use <uintrintrin.h> directly; include <x86gprintrin.h> instead."
+#endif
+
+#ifndef __UINTRINTRIN_H
+#define __UINTRINTRIN_H
+
+/* Define the default attributes for the functions in this file */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__, __target__("uintr")))
+
+#ifdef __x86_64__
+
+struct __uintr_frame
+{
+  unsigned long long rip;
+  unsigned long long rflags;
+  unsigned long long rsp;
+};
+
+/// Clears the user interrupt flag (UIF). Its effect takes place immediately: a
+///    user interrupt cannot be delivered on the instruction boundary following
+///    CLUI. Can be executed only if CR4.UINT = 1, the logical processor is in
+///    64-bit mode, and software is not executing inside an enclave; otherwise,
+///    each causes an invalid-opcode exception. Causes a transactional abort if
+///    executed inside a transactional region; the abort loads EAX as it would
+///    had it been due to an execution of CLI.
+///
+/// \headerfile <x86gprintrin.h>
+///
+/// This intrinsic corresponds to the <c> CLUI </c> instruction.
+///
+/// \code{.operation}
+///   UIF := 0
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS
+_clui (void)
+{
+  __builtin_ia32_clui();
+}
+
+/// Sets the user interrupt flag (UIF). Its effect takes place immediately; a
+///    user interrupt may be delivered on the instruction boundary following
+///    STUI. Can be executed only if CR4.UINT = 1, the logical processor is in
+///    64-bit mode, and software is not executing inside an enclave; otherwise,
+///    each causes an invalid-opcode exception. Causes a transactional abort if
+///    executed inside a transactional region; the abort loads EAX as it would
+///    had it been due to an execution of STI.
+///
+/// \headerfile <x86gprintrin.h>
+///
+/// This intrinsic corresponds to the <c> STUI </c> instruction.
+///
+/// \code{.operation}
+///   UIF := 1
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS
+_stui (void)
+{
+  __builtin_ia32_stui();
+}
+
+/// Get the current value of the user interrupt flag (UIF). Can be executed
+///    regardless of CPL and inside a transactional region. Can be executed only
+///    if CR4.UINT = 1, the logical processor is in 64-bit mode, and software is
+///    not executing inside an enclave; otherwise, it causes an invalid-opcode
+///    exception.
+///
+/// \headerfile <x86gprintrin.h>
+///
+/// This intrinsic corresponds to the <c> TESTUI </c> instruction.
+///
+/// \returns The current value of the user interrupt flag (UIF).
+///
+/// \code{.operation}
+///   CF := UIF
+///   ZF := 0
+///   AF := 0
+///   OF := 0
+///   PF := 0
+///   SF := 0
+///   dst := CF
+/// \endcode
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_testui (void)
+{
+  return __builtin_ia32_testui();
+}
+
+/// Send interprocessor user interrupt. Can be executed only if
+///    CR4.UINT = IA32_UINT_TT[0] = 1, the logical processor is in 64-bit mode,
+///    and software is not executing inside an enclave; otherwise, it causes an
+///    invalid-opcode exception. May be executed at any privilege level, all of
+///    its memory accesses are performed with supervisor privilege.
+///
+/// \headerfile <x86gprintrin.h>
+///
+/// This intrinsic corresponds to the <c> SENDUIPI </c> instruction
+///
+/// \param __a
+///    Index of user-interrupt target table entry in user-interrupt target
+///    table.
+///
+/// \code{.operation}
+///   IF __a > UITTSZ
+///     GP (0)
+///   FI
+///   tempUITTE := MEM[UITTADDR + (a<<4)]
+///   // tempUITTE must be valid, and can't have any reserved bit set
+///   IF (tempUITTE.V == 0 OR tempUITTE[7:1] != 0)
+///     GP (0)
+///   FI
+///   tempUPID := MEM[tempUITTE.UPIDADDR] // under lock
+///   // tempUPID can't have any reserved bit set
+///   IF (tempUPID[15:2] != 0 OR tempUPID[31:24] != 0)
+///     GP (0) // release lock
+///   FI
+///   tempUPID.PIR[tempUITTE.UV] := 1;
+///   IF (tempUPID.SN == 0 AND tempUPID.ON == 0)
+///     tempUPID.ON := 1
+///     sendNotify := 1
+///   ELSE
+///     sendNotify := 0
+///   FI
+///   MEM[tempUITTE.UPIDADDR] := tempUPID // release lock
+///   IF sendNotify == 1
+///     IF IA32_APIC_BASE[10] == 1 // local APIC is in x2APIC mode
+///       // send ordinary IPI with vector tempUPID.NV to 32-bit physical APIC
+///       // ID tempUPID.NDST
+///       SendOrdinaryIPI(tempUPID.NV, tempUPID.NDST)
+///     ELSE
+///       // send ordinary IPI with vector tempUPID.NV to 8-bit physical APIC
+///       // ID tempUPID.NDST[15:8]
+///       SendOrdinaryIPI(tempUPID.NV, tempUPID.NDST[15:8])
+///     FI
+///   FI
+/// \endcode
+static __inline__ void __DEFAULT_FN_ATTRS
+_senduipi (unsigned long long __a)
+{
+  __builtin_ia32_senduipi(__a);
+}
+
+#endif /* __x86_64__ */
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __UINTRINTRIN_H */
diff --git a/third_party/intel/clang/usermsrintrin.h b/third_party/intel/clang/usermsrintrin.h
new file mode 100644
index 000000000..613883767
--- /dev/null
+++ b/third_party/intel/clang/usermsrintrin.h
@@ -0,0 +1,51 @@
+/*===--------------- usermsrintrin.h - USERMSR intrinsics -----------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __X86GPRINTRIN_H
+#error "Never use <usermsrintrin.h> directly; include <x86gprintrin.h> instead."
+#endif // __X86GPRINTRIN_H
+
+#ifndef __USERMSRINTRIN_H
+#define __USERMSRINTRIN_H
+#ifdef __x86_64__
+
+/// Reads the contents of a 64-bit MSR specified in \a __A into \a dst.
+///
+/// This intrinsic corresponds to the <c> URDMSR </c> instruction.
+/// \param __A
+///    An unsigned long long.
+///
+/// \code{.operation}
+///    DEST := MSR[__A]
+/// \endcode
+static __inline__ unsigned long long
+    __attribute__((__always_inline__, __nodebug__, __target__("usermsr")))
+    _urdmsr(unsigned long long __A) {
+  return __builtin_ia32_urdmsr(__A);
+}
+
+/// Writes the contents of \a __B into the 64-bit MSR specified in \a __A.
+///
+/// This intrinsic corresponds to the <c> UWRMSR </c> instruction.
+///
+/// \param __A
+///    An unsigned long long.
+/// \param __B
+///    An unsigned long long.
+///
+/// \code{.operation}
+///    MSR[__A] := __B
+/// \endcode
+static __inline__ void
+    __attribute__((__always_inline__, __nodebug__, __target__("usermsr")))
+    _uwrmsr(unsigned long long __A, unsigned long long __B) {
+  return __builtin_ia32_uwrmsr(__A, __B);
+}
+
+#endif // __x86_64__
+#endif // __USERMSRINTRIN_H
diff --git a/third_party/intel/clang/vaesintrin.h b/third_party/intel/clang/vaesintrin.h
new file mode 100644
index 000000000..d7c162f5c
--- /dev/null
+++ b/third_party/intel/clang/vaesintrin.h
@@ -0,0 +1,87 @@
+/*===------------------ vaesintrin.h - VAES intrinsics ---------------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <vaesintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __VAESINTRIN_H
+#define __VAESINTRIN_H
+
+/* Default attributes for YMM forms. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("vaes"), __min_vector_width__(256)))
+
+/* Default attributes for ZMM forms. */
+#define __DEFAULT_FN_ATTRS_F                                                   \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("avx512f,evex512,vaes"),                           \
+                 __min_vector_width__(512)))
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS
+ _mm256_aesenc_epi128(__m256i __A, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_aesenc256((__v4di) __A,
+              (__v4di) __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS
+ _mm256_aesdec_epi128(__m256i __A, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_aesdec256((__v4di) __A,
+              (__v4di) __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS
+ _mm256_aesenclast_epi128(__m256i __A, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_aesenclast256((__v4di) __A,
+              (__v4di) __B);
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS
+ _mm256_aesdeclast_epi128(__m256i __A, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_aesdeclast256((__v4di) __A,
+              (__v4di) __B);
+}
+
+#ifdef __AVX512FINTRIN_H
+static __inline__ __m512i __DEFAULT_FN_ATTRS_F
+ _mm512_aesenc_epi128(__m512i __A, __m512i __B)
+{
+  return (__m512i) __builtin_ia32_aesenc512((__v8di) __A,
+              (__v8di) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS_F
+ _mm512_aesdec_epi128(__m512i __A, __m512i __B)
+{
+  return (__m512i) __builtin_ia32_aesdec512((__v8di) __A,
+              (__v8di) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS_F
+ _mm512_aesenclast_epi128(__m512i __A, __m512i __B)
+{
+  return (__m512i) __builtin_ia32_aesenclast512((__v8di) __A,
+              (__v8di) __B);
+}
+
+static __inline__ __m512i __DEFAULT_FN_ATTRS_F
+ _mm512_aesdeclast_epi128(__m512i __A, __m512i __B)
+{
+  return (__m512i) __builtin_ia32_aesdeclast512((__v8di) __A,
+              (__v8di) __B);
+}
+#endif // __AVX512FINTRIN_H
+
+#undef __DEFAULT_FN_ATTRS
+#undef __DEFAULT_FN_ATTRS_F
+
+#endif // __VAESINTRIN_H
diff --git a/third_party/intel/clang/vpclmulqdqintrin.h b/third_party/intel/clang/vpclmulqdqintrin.h
new file mode 100644
index 000000000..485692ea2
--- /dev/null
+++ b/third_party/intel/clang/vpclmulqdqintrin.h
@@ -0,0 +1,30 @@
+/*===------------ vpclmulqdqintrin.h - VPCLMULQDQ intrinsics ---------------===
+ *
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#ifndef __IMMINTRIN_H
+#error "Never use <vpclmulqdqintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __VPCLMULQDQINTRIN_H
+#define __VPCLMULQDQINTRIN_H
+
+#define _mm256_clmulepi64_epi128(A, B, I) \
+  ((__m256i)__builtin_ia32_pclmulqdq256((__v4di)(__m256i)(A),  \
+                                        (__v4di)(__m256i)(B),  \
+                                        (char)(I)))
+
+#ifdef __AVX512FINTRIN_H
+#define _mm512_clmulepi64_epi128(A, B, I) \
+  ((__m512i)__builtin_ia32_pclmulqdq512((__v8di)(__m512i)(A),  \
+                                        (__v8di)(__m512i)(B),  \
+                                        (char)(I)))
+#endif // __AVX512FINTRIN_H
+
+#endif /* __VPCLMULQDQINTRIN_H */
+
diff --git a/third_party/intel/clang/waitpkgintrin.h b/third_party/intel/clang/waitpkgintrin.h
new file mode 100644
index 000000000..7ecada4cf
--- /dev/null
+++ b/third_party/intel/clang/waitpkgintrin.h
@@ -0,0 +1,42 @@
+/*===----------------------- waitpkgintrin.h - WAITPKG --------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
+#error "Never use <waitpkgintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __WAITPKGINTRIN_H
+#define __WAITPKGINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS \
+  __attribute__((__always_inline__, __nodebug__,  __target__("waitpkg")))
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_umonitor (void * __address)
+{
+  __builtin_ia32_umonitor (__address);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_umwait (unsigned int __control, unsigned long long __counter)
+{
+  return __builtin_ia32_umwait (__control,
+    (unsigned int)(__counter >> 32), (unsigned int)__counter);
+}
+
+static __inline__ unsigned char __DEFAULT_FN_ATTRS
+_tpause (unsigned int __control, unsigned long long __counter)
+{
+  return __builtin_ia32_tpause (__control,
+    (unsigned int)(__counter >> 32), (unsigned int)__counter);
+}
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif /* __WAITPKGINTRIN_H */
diff --git a/third_party/intel/clang/wbnoinvdintrin.h b/third_party/intel/clang/wbnoinvdintrin.h
new file mode 100644
index 000000000..cac0347ef
--- /dev/null
+++ b/third_party/intel/clang/wbnoinvdintrin.h
@@ -0,0 +1,24 @@
+/*===-------------- wbnoinvdintrin.h - wbnoinvd intrinsic-------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
+#error "Never use <wbnoinvdintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __WBNOINVDINTRIN_H
+#define __WBNOINVDINTRIN_H
+
+static __inline__ void
+  __attribute__((__always_inline__, __nodebug__,  __target__("wbnoinvd")))
+_wbnoinvd (void)
+{
+  __builtin_ia32_wbnoinvd ();
+}
+
+#endif /* __WBNOINVDINTRIN_H */
diff --git a/third_party/intel/clang/wmmintrin.h b/third_party/intel/clang/wmmintrin.h
new file mode 100644
index 000000000..f3121e1c3
--- /dev/null
+++ b/third_party/intel/clang/wmmintrin.h
@@ -0,0 +1,23 @@
+/*===---- wmmintrin.h - AES intrinsics ------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __WMMINTRIN_H
+#define __WMMINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+#include "emmintrin.h"
+
+#include "__wmmintrin_aes.h"
+
+#include "__wmmintrin_pclmul.h"
+
+#endif /* __WMMINTRIN_H */
diff --git a/third_party/intel/clang/x86gprintrin.h b/third_party/intel/clang/x86gprintrin.h
new file mode 100644
index 000000000..f8447ed4a
--- /dev/null
+++ b/third_party/intel/clang/x86gprintrin.h
@@ -0,0 +1,63 @@
+/*===--------------- x86gprintrin.h - X86 GPR intrinsics ------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __X86GPRINTRIN_H
+#define __X86GPRINTRIN_H
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__HRESET__)
+#include "hresetintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__UINTR__)
+#include "uintrintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__USERMSR__)
+#include "usermsrintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__CRC32__)
+#include "crc32intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__PRFCHI__)
+#include "prfchiintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__RAOINT__)
+#include "raointintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__CMPCCXADD__)
+#include "cmpccxaddintrin.h"
+#endif
+
+#if defined(__i386__)
+#define __SAVE_GPRBX "mov {%%ebx, %%eax |eax, ebx};"
+#define __RESTORE_GPRBX "mov {%%eax, %%ebx |ebx, eax};"
+#define __TMPGPR "eax"
+#else
+// When in 64-bit target, the 32-bit operands generate a 32-bit result,
+// zero-extended to a 64-bit result in the destination general-purpose,
+// It means "mov x %ebx" will clobber the higher 32 bits of rbx, so we
+// should preserve the 64-bit register rbx.
+#define __SAVE_GPRBX "mov {%%rbx, %%rax |rax, rbx};"
+#define __RESTORE_GPRBX "mov {%%rax, %%rbx |rbx, rax};"
+#define __TMPGPR "rax"
+#endif
+
+#define __SSC_MARK(__Tag)                                                      \
+  __asm__ __volatile__( __SAVE_GPRBX                                           \
+                       "mov {%0, %%ebx|ebx, %0}; "                             \
+                       ".byte 0x64, 0x67, 0x90; "                              \
+                        __RESTORE_GPRBX                                        \
+                       ::"i"(__Tag)                                            \
+                       :  __TMPGPR );
+
+#endif /* __X86GPRINTRIN_H */
diff --git a/third_party/intel/clang/x86intrin.h b/third_party/intel/clang/x86intrin.h
new file mode 100644
index 000000000..ceae912cf
--- /dev/null
+++ b/third_party/intel/clang/x86intrin.h
@@ -0,0 +1,53 @@
+/*===---- x86intrin.h - X86 intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __X86INTRIN_H
+#define __X86INTRIN_H
+
+#include "ia32intrin.h"
+
+#include "immintrin.h"
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__PRFCHW__)
+#include "prfchwintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__SSE4A__)
+#include "ammintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__FMA4__)
+#include "fma4intrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__XOP__)
+#include "xopintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__TBM__)
+#include "tbmintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__LWP__)
+#include "lwpintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__MWAITX__)
+#include "mwaitxintrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__CLZERO__)
+#include "clzerointrin.h"
+#endif
+
+#if !defined(__SCE__) || __has_feature(modules) || defined(__RDPRU__)
+#include "rdpruintrin.h"
+#endif
+
+#endif /* __X86INTRIN_H */
diff --git a/third_party/intel/clang/xmmintrin.h b/third_party/intel/clang/xmmintrin.h
new file mode 100644
index 000000000..6a371c48f
--- /dev/null
+++ b/third_party/intel/clang/xmmintrin.h
@@ -0,0 +1,3207 @@
+/*===---- xmmintrin.h - SSE intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __XMMINTRIN_H
+#define __XMMINTRIN_H
+
+#if !defined(__i386__) && !defined(__x86_64__)
+#error "This header is only meant to be used on x86 and x64 architecture"
+#endif
+
+#include "mmintrin.h"
+
+typedef int __v4si __attribute__((__vector_size__(16)));
+typedef float __v4sf __attribute__((__vector_size__(16)));
+typedef float __m128 __attribute__((__vector_size__(16), __aligned__(16)));
+
+typedef float __m128_u __attribute__((__vector_size__(16), __aligned__(1)));
+
+/* Unsigned types */
+typedef unsigned int __v4su __attribute__((__vector_size__(16)));
+
+/* This header should only be included in a hosted environment as it depends on
+ * a standard library to provide allocation routines. */
+#if __STDC_HOSTED__
+#include "mm_malloc.h"
+#endif
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS                                                     \
+  __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), \
+                 __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS_MMX                                                 \
+  __attribute__((__always_inline__, __nodebug__,                               \
+                 __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
+
+/// Adds the 32-bit float values in the low-order bits of the operands.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VADDSS / ADDSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+///    The lower 32 bits of this operand are used in the calculation.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+///    The lower 32 bits of this operand are used in the calculation.
+/// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the sum
+///    of the lower 32 bits of both operands. The upper 96 bits are copied from
+///    the upper 96 bits of the first source operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_add_ss(__m128 __a, __m128 __b)
+{
+  __a[0] += __b[0];
+  return __a;
+}
+
+/// Adds two 128-bit vectors of [4 x float], and returns the results of
+///    the addition.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VADDPS / ADDPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+/// \returns A 128-bit vector of [4 x float] containing the sums of both
+///    operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_add_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)((__v4sf)__a + (__v4sf)__b);
+}
+
+/// Subtracts the 32-bit float value in the low-order bits of the second
+///    operand from the corresponding value in the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSUBSS / SUBSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the minuend. The lower 32 bits
+///    of this operand are used in the calculation.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing the subtrahend. The lower 32
+///    bits of this operand are used in the calculation.
+/// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
+///    difference of the lower 32 bits of both operands. The upper 96 bits are
+///    copied from the upper 96 bits of the first source operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_sub_ss(__m128 __a, __m128 __b)
+{
+  __a[0] -= __b[0];
+  return __a;
+}
+
+/// Subtracts each of the values of the second operand from the first
+///    operand, both of which are 128-bit vectors of [4 x float] and returns
+///    the results of the subtraction.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSUBPS / SUBPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the minuend.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing the subtrahend.
+/// \returns A 128-bit vector of [4 x float] containing the differences between
+///    both operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_sub_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)((__v4sf)__a - (__v4sf)__b);
+}
+
+/// Multiplies two 32-bit float values in the low-order bits of the
+///    operands.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMULSS / MULSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+///    The lower 32 bits of this operand are used in the calculation.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+///    The lower 32 bits of this operand are used in the calculation.
+/// \returns A 128-bit vector of [4 x float] containing the product of the lower
+///    32 bits of both operands. The upper 96 bits are copied from the upper 96
+///    bits of the first source operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_mul_ss(__m128 __a, __m128 __b)
+{
+  __a[0] *= __b[0];
+  return __a;
+}
+
+/// Multiplies two 128-bit vectors of [4 x float] and returns the
+///    results of the multiplication.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMULPS / MULPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+/// \returns A 128-bit vector of [4 x float] containing the products of both
+///    operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_mul_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)((__v4sf)__a * (__v4sf)__b);
+}
+
+/// Divides the value in the low-order 32 bits of the first operand by
+///    the corresponding value in the second operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDIVSS / DIVSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the dividend. The lower 32
+///    bits of this operand are used in the calculation.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing the divisor. The lower 32 bits
+///    of this operand are used in the calculation.
+/// \returns A 128-bit vector of [4 x float] containing the quotients of the
+///    lower 32 bits of both operands. The upper 96 bits are copied from the
+///    upper 96 bits of the first source operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_div_ss(__m128 __a, __m128 __b)
+{
+  __a[0] /= __b[0];
+  return __a;
+}
+
+/// Divides two 128-bit vectors of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VDIVPS / DIVPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the dividend.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing the divisor.
+/// \returns A 128-bit vector of [4 x float] containing the quotients of both
+///    operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_div_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)((__v4sf)__a / (__v4sf)__b);
+}
+
+/// Calculates the square root of the value stored in the low-order bits
+///    of a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSQRTSS / SQRTSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the calculation.
+/// \returns A 128-bit vector of [4 x float] containing the square root of the
+///    value in the low-order bits of the operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_sqrt_ss(__m128 __a)
+{
+  return (__m128)__builtin_ia32_sqrtss((__v4sf)__a);
+}
+
+/// Calculates the square roots of the values stored in a 128-bit vector
+///    of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSQRTPS / SQRTPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the square roots of the
+///    values in the operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_sqrt_ps(__m128 __a)
+{
+  return __builtin_ia32_sqrtps((__v4sf)__a);
+}
+
+/// Calculates the approximate reciprocal of the value stored in the
+///    low-order bits of a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VRCPSS / RCPSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the calculation.
+/// \returns A 128-bit vector of [4 x float] containing the approximate
+///    reciprocal of the value in the low-order bits of the operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_rcp_ss(__m128 __a)
+{
+  return (__m128)__builtin_ia32_rcpss((__v4sf)__a);
+}
+
+/// Calculates the approximate reciprocals of the values stored in a
+///    128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VRCPPS / RCPPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the approximate
+///    reciprocals of the values in the operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_rcp_ps(__m128 __a)
+{
+  return (__m128)__builtin_ia32_rcpps((__v4sf)__a);
+}
+
+/// Calculates the approximate reciprocal of the square root of the value
+///    stored in the low-order bits of a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VRSQRTSS / RSQRTSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the calculation.
+/// \returns A 128-bit vector of [4 x float] containing the approximate
+///    reciprocal of the square root of the value in the low-order bits of the
+///    operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_rsqrt_ss(__m128 __a)
+{
+  return __builtin_ia32_rsqrtss((__v4sf)__a);
+}
+
+/// Calculates the approximate reciprocals of the square roots of the
+///    values stored in a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VRSQRTPS / RSQRTPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the approximate
+///    reciprocals of the square roots of the values in the operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_rsqrt_ps(__m128 __a)
+{
+  return __builtin_ia32_rsqrtps((__v4sf)__a);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands and returns the lesser value in the low-order bits of the
+///    vector of [4 x float].
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMINSS / MINSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
+///    minimum value between both operands. The upper 96 bits are copied from
+///    the upper 96 bits of the first source operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_min_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_minss((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 128-bit vectors of [4 x float] and returns the lesser
+///    of each pair of values.
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMINPS / MINPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands.
+/// \returns A 128-bit vector of [4 x float] containing the minimum values
+///    between both operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_min_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_minps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands and returns the greater value in the low-order bits of a 128-bit
+///    vector of [4 x float].
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMAXSS / MAXSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
+///    maximum value between both operands. The upper 96 bits are copied from
+///    the upper 96 bits of the first source operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_max_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_maxss((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 128-bit vectors of [4 x float] and returns the greater
+///    of each pair of values.
+///
+///    If either value in a comparison is NaN, returns the value from \a __b.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMAXPS / MAXPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands.
+/// \returns A 128-bit vector of [4 x float] containing the maximum values
+///    between both operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_max_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_maxps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Performs a bitwise AND of two 128-bit vectors of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VANDPS / ANDPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector containing one of the source operands.
+/// \param __b
+///    A 128-bit vector containing one of the source operands.
+/// \returns A 128-bit vector of [4 x float] containing the bitwise AND of the
+///    values between both operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_and_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)((__v4su)__a & (__v4su)__b);
+}
+
+/// Performs a bitwise AND of two 128-bit vectors of [4 x float], using
+///    the one's complement of the values contained in the first source
+///    operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VANDNPS / ANDNPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the first source operand. The
+///    one's complement of this value is used in the bitwise AND.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing the second source operand.
+/// \returns A 128-bit vector of [4 x float] containing the bitwise AND of the
+///    one's complement of the first operand and the values in the second
+///    operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_andnot_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)(~(__v4su)__a & (__v4su)__b);
+}
+
+/// Performs a bitwise OR of two 128-bit vectors of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VORPS / ORPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+/// \returns A 128-bit vector of [4 x float] containing the bitwise OR of the
+///    values between both operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_or_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)((__v4su)__a | (__v4su)__b);
+}
+
+/// Performs a bitwise exclusive OR of two 128-bit vectors of
+///    [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VXORPS / XORPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the source operands.
+/// \returns A 128-bit vector of [4 x float] containing the bitwise exclusive OR
+///    of the values between both operands.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_xor_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)((__v4su)__a ^ (__v4su)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands for equality.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFF for true, in the
+///    low-order bits of a vector [4 x float].
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPEQSS / CMPEQSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpeq_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpeqss((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] for equality.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPEQPS / CMPEQPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpeq_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpeqps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the value in the first operand is less than the
+///    corresponding value in the second operand.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFF for true, in the
+///    low-order bits of a vector of [4 x float].
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLTSS / CMPLTSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmplt_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpltss((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] to determine if the values in the first
+///    operand are less than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLTPS / CMPLTPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmplt_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpltps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the value in the first operand is less than or
+///    equal to the corresponding value in the second operand.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true, in
+///    the low-order bits of a vector of [4 x float].
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLESS / CMPLESS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmple_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpless((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] to determine if the values in the first
+///    operand are less than or equal to those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLEPS / CMPLEPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmple_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpleps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the value in the first operand is greater than
+///    the corresponding value in the second operand.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFF for true, in the
+///    low-order bits of a vector of [4 x float].
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLTSS / CMPLTSS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpgt_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_shufflevector((__v4sf)__a,
+                                         (__v4sf)__builtin_ia32_cmpltss((__v4sf)__b, (__v4sf)__a),
+                                         4, 1, 2, 3);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] to determine if the values in the first
+///    operand are greater than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLTPS / CMPLTPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpgt_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpltps((__v4sf)__b, (__v4sf)__a);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the value in the first operand is greater than
+///    or equal to the corresponding value in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true, in the
+///    low-order bits of a vector of [4 x float].
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLESS / CMPLESS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpge_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_shufflevector((__v4sf)__a,
+                                         (__v4sf)__builtin_ia32_cmpless((__v4sf)__b, (__v4sf)__a),
+                                         4, 1, 2, 3);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] to determine if the values in the first
+///    operand are greater than or equal to those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFFFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns false.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPLEPS / CMPLEPS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpge_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpleps((__v4sf)__b, (__v4sf)__a);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both operands
+///    for inequality.
+///
+///    The comparison returns 0x0 for false, 0xFFFFFFFF for true, in the
+///    low-order bits of a vector of [4 x float].
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNEQSS / CMPNEQSS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpneq_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpneqss((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] for inequality.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNEQPS / CMPNEQPS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpneq_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpneqps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the value in the first operand is not less than
+///    the corresponding value in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true, in the
+///    low-order bits of a vector of [4 x float].
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLTSS / CMPNLTSS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpnlt_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpnltss((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] to determine if the values in the first
+///    operand are not less than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLTPS / CMPNLTPS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpnlt_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpnltps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the value in the first operand is not less than
+///    or equal to the corresponding value in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true, in the
+///    low-order bits of a vector of [4 x float].
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLESS / CMPNLESS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpnle_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpnless((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] to determine if the values in the first
+///    operand are not less than or equal to those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLEPS / CMPNLEPS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpnle_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpnleps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the value in the first operand is not greater
+///    than the corresponding value in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true, in the
+///    low-order bits of a vector of [4 x float].
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLTSS / CMPNLTSS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpngt_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_shufflevector((__v4sf)__a,
+                                         (__v4sf)__builtin_ia32_cmpnltss((__v4sf)__b, (__v4sf)__a),
+                                         4, 1, 2, 3);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] to determine if the values in the first
+///    operand are not greater than those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLTPS / CMPNLTPS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpngt_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpnltps((__v4sf)__b, (__v4sf)__a);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the value in the first operand is not greater
+///    than or equal to the corresponding value in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true, in the
+///    low-order bits of a vector of [4 x float].
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLESS / CMPNLESS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpnge_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_shufflevector((__v4sf)__a,
+                                         (__v4sf)__builtin_ia32_cmpnless((__v4sf)__b, (__v4sf)__a),
+                                         4, 1, 2, 3);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] to determine if the values in the first
+///    operand are not greater than or equal to those in the second operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, returns true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPNLEPS / CMPNLEPS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpnge_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpnleps((__v4sf)__b, (__v4sf)__a);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the value in the first operand is ordered with
+///    respect to the corresponding value in the second operand.
+///
+///    A pair of floating-point values are ordered with respect to each
+///    other if neither value is a NaN. Each comparison returns 0x0 for false,
+///    0xFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPORDSS / CMPORDSS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpord_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpordss((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] to determine if the values in the first
+///    operand are ordered with respect to those in the second operand.
+///
+///    A pair of floating-point values are ordered with respect to each
+///    other if neither value is a NaN. Each comparison returns 0x0 for false,
+///    0xFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPORDPS / CMPORDPS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpord_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpordps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the value in the first operand is unordered
+///    with respect to the corresponding value in the second operand.
+///
+///    A pair of double-precision values are unordered with respect to each
+///    other if one or both values are NaN. Each comparison returns 0x0 for
+///    false, 0xFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPUNORDSS / CMPUNORDSS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float] containing one of the operands. The lower
+///    32 bits of this operand are used in the comparison.
+/// \returns A 128-bit vector of [4 x float] containing the comparison results
+///    in the low-order bits.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpunord_ss(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpunordss((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares each of the corresponding 32-bit float values of the
+///    128-bit vectors of [4 x float] to determine if the values in the first
+///    operand are unordered with respect to those in the second operand.
+///
+///    A pair of double-precision values are unordered with respect to each
+///    other if one or both values are NaN. Each comparison returns 0x0 for
+///    false, 0xFFFFFFFFFFFFFFFF for true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCMPUNORDPS / CMPUNORDPS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 128-bit vector of [4 x float].
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cmpunord_ps(__m128 __a, __m128 __b)
+{
+  return (__m128)__builtin_ia32_cmpunordps((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands for equality.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISS / COMISS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_comieq_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_comieq((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the first operand is less than the second
+///    operand.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISS / COMISS </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_comilt_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_comilt((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the first operand is less than or equal to the
+///    second operand.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISS / COMISS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_comile_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_comile((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the first operand is greater than the second
+///    operand.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISS / COMISS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_comigt_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_comigt((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the first operand is greater than or equal to
+///    the second operand.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISS / COMISS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_comige_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_comige((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Compares two 32-bit float values in the low-order bits of both
+///    operands to determine if the first operand is not equal to the second
+///    operand.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 1.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCOMISS / COMISS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_comineq_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_comineq((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Performs an unordered comparison of two 32-bit float values using
+///    the low-order bits of both operands to determine equality.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISS / UCOMISS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_ucomieq_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_ucomieq((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Performs an unordered comparison of two 32-bit float values using
+///    the low-order bits of both operands to determine if the first operand is
+///    less than the second operand.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISS / UCOMISS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_ucomilt_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_ucomilt((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Performs an unordered comparison of two 32-bit float values using
+///    the low-order bits of both operands to determine if the first operand is
+///    less than or equal to the second operand.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISS / UCOMISS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_ucomile_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_ucomile((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Performs an unordered comparison of two 32-bit float values using
+///    the low-order bits of both operands to determine if the first operand is
+///    greater than the second operand.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISS / UCOMISS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_ucomigt_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_ucomigt((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Performs an unordered comparison of two 32-bit float values using
+///    the low-order bits of both operands to determine if the first operand is
+///    greater than or equal to the second operand.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISS / UCOMISS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_ucomige_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_ucomige((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Performs an unordered comparison of two 32-bit float values using
+///    the low-order bits of both operands to determine inequality.
+///
+///    The comparison returns 0 for false, 1 for true. If either value in a
+///    comparison is NaN, returns 0.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUCOMISS / UCOMISS </c> instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \param __b
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the comparison.
+/// \returns An integer containing the comparison results.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_ucomineq_ss(__m128 __a, __m128 __b)
+{
+  return __builtin_ia32_ucomineq((__v4sf)__a, (__v4sf)__b);
+}
+
+/// Converts a float value contained in the lower 32 bits of a vector of
+///    [4 x float] into a 32-bit integer.
+///
+///    If the converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSS2SI / CVTSS2SI </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the conversion.
+/// \returns A 32-bit integer containing the converted value.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_cvtss_si32(__m128 __a)
+{
+  return __builtin_ia32_cvtss2si((__v4sf)__a);
+}
+
+/// Converts a float value contained in the lower 32 bits of a vector of
+///    [4 x float] into a 32-bit integer.
+///
+///    If the converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSS2SI / CVTSS2SI </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the conversion.
+/// \returns A 32-bit integer containing the converted value.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_cvt_ss2si(__m128 __a)
+{
+  return _mm_cvtss_si32(__a);
+}
+
+#ifdef __x86_64__
+
+/// Converts a float value contained in the lower 32 bits of a vector of
+///    [4 x float] into a 64-bit integer.
+///
+///    If the converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSS2SI / CVTSS2SI </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the conversion.
+/// \returns A 64-bit integer containing the converted value.
+static __inline__ long long __DEFAULT_FN_ATTRS
+_mm_cvtss_si64(__m128 __a)
+{
+  return __builtin_ia32_cvtss2si64((__v4sf)__a);
+}
+
+#endif
+
+/// Converts two low-order float values in a 128-bit vector of
+///    [4 x float] into a 64-bit vector of [2 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPS2PI </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 64-bit integer vector containing the converted values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_cvtps_pi32(__m128 __a)
+{
+  return (__m64)__builtin_ia32_cvtps2pi((__v4sf)__a);
+}
+
+/// Converts two low-order float values in a 128-bit vector of
+///    [4 x float] into a 64-bit vector of [2 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPS2PI </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 64-bit integer vector containing the converted values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_cvt_ps2pi(__m128 __a)
+{
+  return _mm_cvtps_pi32(__a);
+}
+
+/// Converts the lower (first) element of a vector of [4 x float] into a signed
+///    truncated (rounded toward zero) 32-bit integer.
+///
+///    If the converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTTSS2SI / CVTTSS2SI </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the conversion.
+/// \returns A 32-bit integer containing the converted value.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_cvttss_si32(__m128 __a)
+{
+  return __builtin_ia32_cvttss2si((__v4sf)__a);
+}
+
+/// Converts the lower (first) element of a vector of [4 x float] into a signed
+///    truncated (rounded toward zero) 32-bit integer.
+///
+///    If the converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTTSS2SI / CVTTSS2SI </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the conversion.
+/// \returns A 32-bit integer containing the converted value.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_cvtt_ss2si(__m128 __a)
+{
+  return _mm_cvttss_si32(__a);
+}
+
+#ifdef __x86_64__
+/// Converts the lower (first) element of a vector of [4 x float] into a signed
+///    truncated (rounded toward zero) 64-bit integer.
+///
+///    If the converted value does not fit in a 64-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTTSS2SI / CVTTSS2SI </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the conversion.
+/// \returns A 64-bit integer containing the converted value.
+static __inline__ long long __DEFAULT_FN_ATTRS
+_mm_cvttss_si64(__m128 __a)
+{
+  return __builtin_ia32_cvttss2si64((__v4sf)__a);
+}
+#endif
+
+/// Converts the lower (first) two elements of a 128-bit vector of [4 x float]
+///    into two signed truncated (rounded toward zero) 32-bit integers,
+///    returned in a 64-bit vector of [2 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTTPS2PI / VTTPS2PI </c>
+///   instructions.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 64-bit integer vector containing the converted values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_cvttps_pi32(__m128 __a)
+{
+  return (__m64)__builtin_ia32_cvttps2pi((__v4sf)__a);
+}
+
+/// Converts the lower (first) two elements of a 128-bit vector of [4 x float]
+///    into two signed truncated (rounded toward zero) 64-bit integers,
+///    returned in a 64-bit vector of [2 x i32].
+///
+///    If a converted value does not fit in a 32-bit integer, raises a
+///    floating-point invalid exception. If the exception is masked, returns
+///    the most negative integer.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTTPS2PI </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \returns A 64-bit integer vector containing the converted values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_cvtt_ps2pi(__m128 __a)
+{
+  return _mm_cvttps_pi32(__a);
+}
+
+/// Converts a 32-bit signed integer value into a floating point value
+///    and writes it to the lower 32 bits of the destination. The remaining
+///    higher order elements of the destination vector are copied from the
+///    corresponding elements in the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSI2SS / CVTSI2SS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 32-bit signed integer operand containing the value to be converted.
+/// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
+///    converted value of the second operand. The upper 96 bits are copied from
+///    the upper 96 bits of the first operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cvtsi32_ss(__m128 __a, int __b)
+{
+  __a[0] = __b;
+  return __a;
+}
+
+/// Converts a 32-bit signed integer value into a floating point value
+///    and writes it to the lower 32 bits of the destination. The remaining
+///    higher order elements of the destination are copied from the
+///    corresponding elements in the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSI2SS / CVTSI2SS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 32-bit signed integer operand containing the value to be converted.
+/// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
+///    converted value of the second operand. The upper 96 bits are copied from
+///    the upper 96 bits of the first operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cvt_si2ss(__m128 __a, int __b)
+{
+  return _mm_cvtsi32_ss(__a, __b);
+}
+
+#ifdef __x86_64__
+
+/// Converts a 64-bit signed integer value into a floating point value
+///    and writes it to the lower 32 bits of the destination. The remaining
+///    higher order elements of the destination are copied from the
+///    corresponding elements in the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VCVTSI2SS / CVTSI2SS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 64-bit signed integer operand containing the value to be converted.
+/// \returns A 128-bit vector of [4 x float] whose lower 32 bits contain the
+///    converted value of the second operand. The upper 96 bits are copied from
+///    the upper 96 bits of the first operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_cvtsi64_ss(__m128 __a, long long __b)
+{
+  __a[0] = __b;
+  return __a;
+}
+
+#endif
+
+/// Converts two elements of a 64-bit vector of [2 x i32] into two
+///    floating point values and writes them to the lower 64-bits of the
+///    destination. The remaining higher order elements of the destination are
+///    copied from the corresponding elements in the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPI2PS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 64-bit vector of [2 x i32]. The elements in this vector are converted
+///    and written to the corresponding low-order elements in the destination.
+/// \returns A 128-bit vector of [4 x float] whose lower 64 bits contain the
+///    converted value of the second operand. The upper 64 bits are copied from
+///    the upper 64 bits of the first operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS_MMX
+_mm_cvtpi32_ps(__m128 __a, __m64 __b)
+{
+  return __builtin_ia32_cvtpi2ps((__v4sf)__a, (__v2si)__b);
+}
+
+/// Converts two elements of a 64-bit vector of [2 x i32] into two
+///    floating point values and writes them to the lower 64-bits of the
+///    destination. The remaining higher order elements of the destination are
+///    copied from the corresponding elements in the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPI2PS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float].
+/// \param __b
+///    A 64-bit vector of [2 x i32]. The elements in this vector are converted
+///    and written to the corresponding low-order elements in the destination.
+/// \returns A 128-bit vector of [4 x float] whose lower 64 bits contain the
+///    converted value from the second operand. The upper 64 bits are copied
+///    from the upper 64 bits of the first operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS_MMX
+_mm_cvt_pi2ps(__m128 __a, __m64 __b)
+{
+  return _mm_cvtpi32_ps(__a, __b);
+}
+
+/// Extracts a float value contained in the lower 32 bits of a vector of
+///    [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. The lower 32 bits of this operand are
+///    used in the extraction.
+/// \returns A 32-bit float containing the extracted value.
+static __inline__ float __DEFAULT_FN_ATTRS
+_mm_cvtss_f32(__m128 __a)
+{
+  return __a[0];
+}
+
+/// Loads two packed float values from the address \a __p into the
+///     high-order bits of a 128-bit vector of [4 x float]. The low-order bits
+///     are copied from the low-order bits of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVHPD / MOVHPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. Bits [63:0] are written to bits [63:0]
+///    of the destination.
+/// \param __p
+///    A pointer to two packed float values. Bits [63:0] are written to bits
+///    [127:64] of the destination.
+/// \returns A 128-bit vector of [4 x float] containing the moved values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_loadh_pi(__m128 __a, const __m64 *__p)
+{
+  typedef float __mm_loadh_pi_v2f32 __attribute__((__vector_size__(8)));
+  struct __mm_loadh_pi_struct {
+    __mm_loadh_pi_v2f32 __u;
+  } __attribute__((__packed__, __may_alias__));
+  __mm_loadh_pi_v2f32 __b = ((const struct __mm_loadh_pi_struct*)__p)->__u;
+  __m128 __bb = __builtin_shufflevector(__b, __b, 0, 1, 0, 1);
+  return __builtin_shufflevector(__a, __bb, 0, 1, 4, 5);
+}
+
+/// Loads two packed float values from the address \a __p into the
+///    low-order bits of a 128-bit vector of [4 x float]. The high-order bits
+///    are copied from the high-order bits of the first operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVLPD / MOVLPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. Bits [127:64] are written to bits
+///    [127:64] of the destination.
+/// \param __p
+///    A pointer to two packed float values. Bits [63:0] are written to bits
+///    [63:0] of the destination.
+/// \returns A 128-bit vector of [4 x float] containing the moved values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_loadl_pi(__m128 __a, const __m64 *__p)
+{
+  typedef float __mm_loadl_pi_v2f32 __attribute__((__vector_size__(8)));
+  struct __mm_loadl_pi_struct {
+    __mm_loadl_pi_v2f32 __u;
+  } __attribute__((__packed__, __may_alias__));
+  __mm_loadl_pi_v2f32 __b = ((const struct __mm_loadl_pi_struct*)__p)->__u;
+  __m128 __bb = __builtin_shufflevector(__b, __b, 0, 1, 0, 1);
+  return __builtin_shufflevector(__a, __bb, 4, 5, 2, 3);
+}
+
+/// Constructs a 128-bit floating-point vector of [4 x float]. The lower
+///    32 bits of the vector are initialized with the single-precision
+///    floating-point value loaded from a specified memory location. The upper
+///    96 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVSS / MOVSS </c> instruction.
+///
+/// \param __p
+///    A pointer to a 32-bit memory location containing a single-precision
+///    floating-point value.
+/// \returns An initialized 128-bit floating-point vector of [4 x float]. The
+///    lower 32 bits contain the value loaded from the memory location. The
+///    upper 96 bits are set to zero.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_load_ss(const float *__p)
+{
+  struct __mm_load_ss_struct {
+    float __u;
+  } __attribute__((__packed__, __may_alias__));
+  float __u = ((const struct __mm_load_ss_struct*)__p)->__u;
+  return __extension__ (__m128){ __u, 0, 0, 0 };
+}
+
+/// Loads a 32-bit float value and duplicates it to all four vector
+///    elements of a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBROADCASTSS / MOVSS + shuffling </c>
+///    instruction.
+///
+/// \param __p
+///    A pointer to a float value to be loaded and duplicated.
+/// \returns A 128-bit vector of [4 x float] containing the loaded and
+///    duplicated values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_load1_ps(const float *__p)
+{
+  struct __mm_load1_ps_struct {
+    float __u;
+  } __attribute__((__packed__, __may_alias__));
+  float __u = ((const struct __mm_load1_ps_struct*)__p)->__u;
+  return __extension__ (__m128){ __u, __u, __u, __u };
+}
+
+#define        _mm_load_ps1(p) _mm_load1_ps(p)
+
+/// Loads a 128-bit floating-point vector of [4 x float] from an aligned
+///    memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPS / MOVAPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a 128-bit memory location. The address of the memory
+///    location has to be 128-bit aligned.
+/// \returns A 128-bit vector of [4 x float] containing the loaded values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_load_ps(const float *__p)
+{
+  return *(const __m128*)__p;
+}
+
+/// Loads a 128-bit floating-point vector of [4 x float] from an
+///    unaligned memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVUPS / MOVUPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a 128-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \returns A 128-bit vector of [4 x float] containing the loaded values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_loadu_ps(const float *__p)
+{
+  struct __loadu_ps {
+    __m128_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  return ((const struct __loadu_ps*)__p)->__v;
+}
+
+/// Loads four packed float values, in reverse order, from an aligned
+///    memory location to 32-bit elements in a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPS / MOVAPS + shuffling </c>
+///    instruction.
+///
+/// \param __p
+///    A pointer to a 128-bit memory location. The address of the memory
+///    location has to be 128-bit aligned.
+/// \returns A 128-bit vector of [4 x float] containing the moved values, loaded
+///    in reverse order.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_loadr_ps(const float *__p)
+{
+  __m128 __a = _mm_load_ps(__p);
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 3, 2, 1, 0);
+}
+
+/// Create a 128-bit vector of [4 x float] with undefined values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic has no corresponding instruction.
+///
+/// \returns A 128-bit vector of [4 x float] containing undefined values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_undefined_ps(void)
+{
+  return (__m128)__builtin_ia32_undef128();
+}
+
+/// Constructs a 128-bit floating-point vector of [4 x float]. The lower
+///    32 bits of the vector are initialized with the specified single-precision
+///    floating-point value. The upper 96 bits are set to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVSS / MOVSS </c> instruction.
+///
+/// \param __w
+///    A single-precision floating-point value used to initialize the lower 32
+///    bits of the result.
+/// \returns An initialized 128-bit floating-point vector of [4 x float]. The
+///    lower 32 bits contain the value provided in the source operand. The
+///    upper 96 bits are set to zero.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_set_ss(float __w)
+{
+  return __extension__ (__m128){ __w, 0, 0, 0 };
+}
+
+/// Constructs a 128-bit floating-point vector of [4 x float], with each
+///    of the four single-precision floating-point vector elements set to the
+///    specified single-precision floating-point value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPERMILPS / PERMILPS </c> instruction.
+///
+/// \param __w
+///    A single-precision floating-point value used to initialize each vector
+///    element of the result.
+/// \returns An initialized 128-bit floating-point vector of [4 x float].
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_set1_ps(float __w)
+{
+  return __extension__ (__m128){ __w, __w, __w, __w };
+}
+
+/* Microsoft specific. */
+/// Constructs a 128-bit floating-point vector of [4 x float], with each
+///    of the four single-precision floating-point vector elements set to the
+///    specified single-precision floating-point value.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPERMILPS / PERMILPS </c> instruction.
+///
+/// \param __w
+///    A single-precision floating-point value used to initialize each vector
+///    element of the result.
+/// \returns An initialized 128-bit floating-point vector of [4 x float].
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_set_ps1(float __w)
+{
+    return _mm_set1_ps(__w);
+}
+
+/// Constructs a 128-bit floating-point vector of [4 x float]
+///    initialized with the specified single-precision floating-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __z
+///    A single-precision floating-point value used to initialize bits [127:96]
+///    of the result.
+/// \param __y
+///    A single-precision floating-point value used to initialize bits [95:64]
+///    of the result.
+/// \param __x
+///    A single-precision floating-point value used to initialize bits [63:32]
+///    of the result.
+/// \param __w
+///    A single-precision floating-point value used to initialize bits [31:0]
+///    of the result.
+/// \returns An initialized 128-bit floating-point vector of [4 x float].
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_set_ps(float __z, float __y, float __x, float __w)
+{
+  return __extension__ (__m128){ __w, __x, __y, __z };
+}
+
+/// Constructs a 128-bit floating-point vector of [4 x float],
+///    initialized in reverse order with the specified 32-bit single-precision
+///    float-point values.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic is a utility function and does not correspond to a specific
+///    instruction.
+///
+/// \param __z
+///    A single-precision floating-point value used to initialize bits [31:0]
+///    of the result.
+/// \param __y
+///    A single-precision floating-point value used to initialize bits [63:32]
+///    of the result.
+/// \param __x
+///    A single-precision floating-point value used to initialize bits [95:64]
+///    of the result.
+/// \param __w
+///    A single-precision floating-point value used to initialize bits [127:96]
+///    of the result.
+/// \returns An initialized 128-bit floating-point vector of [4 x float].
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_setr_ps(float __z, float __y, float __x, float __w)
+{
+  return __extension__ (__m128){ __z, __y, __x, __w };
+}
+
+/// Constructs a 128-bit floating-point vector of [4 x float] initialized
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VXORPS / XORPS </c> instruction.
+///
+/// \returns An initialized 128-bit floating-point vector of [4 x float] with
+///    all elements set to zero.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_setzero_ps(void)
+{
+  return __extension__ (__m128){ 0.0f, 0.0f, 0.0f, 0.0f };
+}
+
+/// Stores the upper 64 bits of a 128-bit vector of [4 x float] to a
+///    memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VPEXTRQ / PEXTRQ </c> instruction.
+///
+/// \param __p
+///    A pointer to a 64-bit memory location.
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the values to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_storeh_pi(__m64 *__p, __m128 __a)
+{
+  typedef float __mm_storeh_pi_v2f32 __attribute__((__vector_size__(8)));
+  struct __mm_storeh_pi_struct {
+    __mm_storeh_pi_v2f32 __u;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __mm_storeh_pi_struct*)__p)->__u = __builtin_shufflevector(__a, __a, 2, 3);
+}
+
+/// Stores the lower 64 bits of a 128-bit vector of [4 x float] to a
+///     memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVLPS / MOVLPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a memory location that will receive the float values.
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the values to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_storel_pi(__m64 *__p, __m128 __a)
+{
+  typedef float __mm_storeh_pi_v2f32 __attribute__((__vector_size__(8)));
+  struct __mm_storeh_pi_struct {
+    __mm_storeh_pi_v2f32 __u;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __mm_storeh_pi_struct*)__p)->__u = __builtin_shufflevector(__a, __a, 0, 1);
+}
+
+/// Stores the lower 32 bits of a 128-bit vector of [4 x float] to a
+///     memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVSS / MOVSS </c> instruction.
+///
+/// \param __p
+///    A pointer to a 32-bit memory location.
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_store_ss(float *__p, __m128 __a)
+{
+  struct __mm_store_ss_struct {
+    float __u;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __mm_store_ss_struct*)__p)->__u = __a[0];
+}
+
+/// Stores a 128-bit vector of [4 x float] to an unaligned memory
+///    location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVUPS / MOVUPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a 128-bit memory location. The address of the memory
+///    location does not have to be aligned.
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the values to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_storeu_ps(float *__p, __m128 __a)
+{
+  struct __storeu_ps {
+    __m128_u __v;
+  } __attribute__((__packed__, __may_alias__));
+  ((struct __storeu_ps*)__p)->__v = __a;
+}
+
+/// Stores a 128-bit vector of [4 x float] into an aligned memory
+///    location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPS / MOVAPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a 128-bit memory location. The address of the memory
+///    location has to be 16-byte aligned.
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the values to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_store_ps(float *__p, __m128 __a)
+{
+  *(__m128*)__p = __a;
+}
+
+/// Stores the lower 32 bits of a 128-bit vector of [4 x float] into
+///    four contiguous elements in an aligned memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to <c> VMOVAPS / MOVAPS + shuffling </c>
+///    instruction.
+///
+/// \param __p
+///    A pointer to a 128-bit memory location.
+/// \param __a
+///    A 128-bit vector of [4 x float] whose lower 32 bits are stored to each
+///    of the four contiguous elements pointed by \a __p.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_store1_ps(float *__p, __m128 __a)
+{
+  __a = __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 0, 0, 0, 0);
+  _mm_store_ps(__p, __a);
+}
+
+/// Stores the lower 32 bits of a 128-bit vector of [4 x float] into
+///    four contiguous elements in an aligned memory location.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to <c> VMOVAPS / MOVAPS + shuffling </c>
+///    instruction.
+///
+/// \param __p
+///    A pointer to a 128-bit memory location.
+/// \param __a
+///    A 128-bit vector of [4 x float] whose lower 32 bits are stored to each
+///    of the four contiguous elements pointed by \a __p.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_store_ps1(float *__p, __m128 __a)
+{
+  _mm_store1_ps(__p, __a);
+}
+
+/// Stores float values from a 128-bit vector of [4 x float] to an
+///    aligned memory location in reverse order.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVAPS / MOVAPS + shuffling </c>
+///    instruction.
+///
+/// \param __p
+///    A pointer to a 128-bit memory location. The address of the memory
+///    location has to be 128-bit aligned.
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the values to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_storer_ps(float *__p, __m128 __a)
+{
+  __a = __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 3, 2, 1, 0);
+  _mm_store_ps(__p, __a);
+}
+
+#define _MM_HINT_ET0 7
+#define _MM_HINT_ET1 6
+#define _MM_HINT_T0  3
+#define _MM_HINT_T1  2
+#define _MM_HINT_T2  1
+#define _MM_HINT_NTA 0
+
+#ifndef _MSC_VER
+/* FIXME: We have to #define this because "sel" must be a constant integer, and
+   Sema doesn't do any form of constant propagation yet. */
+
+/// Loads one cache line of data from the specified address to a location
+///    closer to the processor.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// void _mm_prefetch(const void *a, const int sel);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> PREFETCHNTA </c> instruction.
+///
+/// \param a
+///    A pointer to a memory location containing a cache line of data.
+/// \param sel
+///    A predefined integer constant specifying the type of prefetch
+///    operation: \n
+///    _MM_HINT_NTA: Move data using the non-temporal access (NTA) hint. The
+///    PREFETCHNTA instruction will be generated. \n
+///    _MM_HINT_T0: Move data using the T0 hint. The PREFETCHT0 instruction will
+///    be generated. \n
+///    _MM_HINT_T1: Move data using the T1 hint. The PREFETCHT1 instruction will
+///    be generated. \n
+///    _MM_HINT_T2: Move data using the T2 hint. The PREFETCHT2 instruction will
+///    be generated.
+#define _mm_prefetch(a, sel) (__builtin_prefetch((const void *)(a), \
+                                                 ((sel) >> 2) & 1, (sel) & 0x3))
+#endif
+
+/// Stores a 64-bit integer in the specified aligned memory location. To
+///    minimize caching, the data is flagged as non-temporal (unlikely to be
+///    used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MOVNTQ </c> instruction.
+///
+/// \param __p
+///    A pointer to an aligned memory location used to store the register value.
+/// \param __a
+///    A 64-bit integer containing the value to be stored.
+static __inline__ void __DEFAULT_FN_ATTRS_MMX
+_mm_stream_pi(void *__p, __m64 __a)
+{
+  __builtin_ia32_movntq((__m64 *)__p, __a);
+}
+
+/// Moves packed float values from a 128-bit vector of [4 x float] to a
+///    128-bit aligned memory location. To minimize caching, the data is flagged
+///    as non-temporal (unlikely to be used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVNTPS / MOVNTPS </c> instruction.
+///
+/// \param __p
+///    A pointer to a 128-bit aligned memory location that will receive the
+///    single-precision floating-point values.
+/// \param __a
+///    A 128-bit vector of [4 x float] containing the values to be moved.
+static __inline__ void __DEFAULT_FN_ATTRS
+_mm_stream_ps(void *__p, __m128 __a)
+{
+  __builtin_nontemporal_store((__v4sf)__a, (__v4sf*)__p);
+}
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/// Forces strong memory ordering (serialization) between store
+///    instructions preceding this instruction and store instructions following
+///    this instruction, ensuring the system completes all previous stores
+///    before executing subsequent stores.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> SFENCE </c> instruction.
+///
+void _mm_sfence(void);
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+/// Extracts 16-bit element from a 64-bit vector of [4 x i16] and
+///    returns it, as specified by the immediate integer operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// int _mm_extract_pi16(__m64 a, int n);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VPEXTRW / PEXTRW </c> instruction.
+///
+/// \param a
+///    A 64-bit vector of [4 x i16].
+/// \param n
+///    An immediate integer operand that determines which bits are extracted: \n
+///    0: Bits [15:0] are copied to the destination. \n
+///    1: Bits [31:16] are copied to the destination. \n
+///    2: Bits [47:32] are copied to the destination. \n
+///    3: Bits [63:48] are copied to the destination.
+/// \returns A 16-bit integer containing the extracted 16 bits of packed data.
+#define _mm_extract_pi16(a, n) \
+  ((int)__builtin_ia32_vec_ext_v4hi((__v4hi)a, (int)n))
+
+/// Copies data from the 64-bit vector of [4 x i16] to the destination,
+///    and inserts the lower 16-bits of an integer operand at the 16-bit offset
+///    specified by the immediate operand \a n.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m64 _mm_insert_pi16(__m64 a, int d, int n);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> PINSRW </c> instruction.
+///
+/// \param a
+///    A 64-bit vector of [4 x i16].
+/// \param d
+///    An integer. The lower 16-bit value from this operand is written to the
+///    destination at the offset specified by operand \a n.
+/// \param n
+///    An immediate integer operant that determines which the bits to be used
+///    in the destination. \n
+///    0: Bits [15:0] are copied to the destination. \n
+///    1: Bits [31:16] are copied to the destination. \n
+///    2: Bits [47:32] are copied to the destination. \n
+///    3: Bits [63:48] are copied to the destination.  \n
+///    The remaining bits in the destination are copied from the corresponding
+///    bits in operand \a a.
+/// \returns A 64-bit integer vector containing the copied packed data from the
+///    operands.
+#define _mm_insert_pi16(a, d, n) \
+  ((__m64)__builtin_ia32_vec_set_v4hi((__v4hi)a, (int)d, (int)n))
+
+/// Compares each of the corresponding packed 16-bit integer values of
+///    the 64-bit integer vectors, and writes the greater value to the
+///    corresponding bits in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PMAXSW </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 64-bit integer vector containing one of the source operands.
+/// \returns A 64-bit integer vector containing the comparison results.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_max_pi16(__m64 __a, __m64 __b)
+{
+  return (__m64)__builtin_ia32_pmaxsw((__v4hi)__a, (__v4hi)__b);
+}
+
+/// Compares each of the corresponding packed 8-bit unsigned integer
+///    values of the 64-bit integer vectors, and writes the greater value to the
+///    corresponding bits in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PMAXUB </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 64-bit integer vector containing one of the source operands.
+/// \returns A 64-bit integer vector containing the comparison results.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_max_pu8(__m64 __a, __m64 __b)
+{
+  return (__m64)__builtin_ia32_pmaxub((__v8qi)__a, (__v8qi)__b);
+}
+
+/// Compares each of the corresponding packed 16-bit integer values of
+///    the 64-bit integer vectors, and writes the lesser value to the
+///    corresponding bits in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PMINSW </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 64-bit integer vector containing one of the source operands.
+/// \returns A 64-bit integer vector containing the comparison results.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_min_pi16(__m64 __a, __m64 __b)
+{
+  return (__m64)__builtin_ia32_pminsw((__v4hi)__a, (__v4hi)__b);
+}
+
+/// Compares each of the corresponding packed 8-bit unsigned integer
+///    values of the 64-bit integer vectors, and writes the lesser value to the
+///    corresponding bits in the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PMINUB </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 64-bit integer vector containing one of the source operands.
+/// \returns A 64-bit integer vector containing the comparison results.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_min_pu8(__m64 __a, __m64 __b)
+{
+  return (__m64)__builtin_ia32_pminub((__v8qi)__a, (__v8qi)__b);
+}
+
+/// Takes the most significant bit from each 8-bit element in a 64-bit
+///    integer vector to create an 8-bit mask value. Zero-extends the value to
+///    32-bit integer and writes it to the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PMOVMSKB </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing the values with bits to be extracted.
+/// \returns The most significant bit from each 8-bit element in \a __a,
+///    written to bits [7:0].
+static __inline__ int __DEFAULT_FN_ATTRS_MMX
+_mm_movemask_pi8(__m64 __a)
+{
+  return __builtin_ia32_pmovmskb((__v8qi)__a);
+}
+
+/// Multiplies packed 16-bit unsigned integer values and writes the
+///    high-order 16 bits of each 32-bit product to the corresponding bits in
+///    the destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PMULHUW </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 64-bit integer vector containing one of the source operands.
+/// \returns A 64-bit integer vector containing the products of both operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_mulhi_pu16(__m64 __a, __m64 __b)
+{
+  return (__m64)__builtin_ia32_pmulhuw((__v4hi)__a, (__v4hi)__b);
+}
+
+/// Shuffles the 4 16-bit integers from a 64-bit integer vector to the
+///    destination, as specified by the immediate value operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m64 _mm_shuffle_pi16(__m64 a, const int n);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> PSHUFW </c> instruction.
+///
+/// \param a
+///    A 64-bit integer vector containing the values to be shuffled.
+/// \param n
+///    An immediate value containing an 8-bit value specifying which elements to
+///    copy from \a a. The destinations within the 64-bit destination are
+///    assigned values as follows: \n
+///    Bits [1:0] are used to assign values to bits [15:0] in the
+///    destination. \n
+///    Bits [3:2] are used to assign values to bits [31:16] in the
+///    destination. \n
+///    Bits [5:4] are used to assign values to bits [47:32] in the
+///    destination. \n
+///    Bits [7:6] are used to assign values to bits [63:48] in the
+///    destination. \n
+///    Bit value assignments: \n
+///    00: assigned from bits [15:0] of \a a. \n
+///    01: assigned from bits [31:16] of \a a. \n
+///    10: assigned from bits [47:32] of \a a. \n
+///    11: assigned from bits [63:48] of \a a. \n
+///    Note: To generate a mask, you can use the \c _MM_SHUFFLE macro.
+///    <c>_MM_SHUFFLE(b6, b4, b2, b0)</c> can create an 8-bit mask of the form
+///    <c>[b6, b4, b2, b0]</c>.
+/// \returns A 64-bit integer vector containing the shuffled values.
+#define _mm_shuffle_pi16(a, n) \
+  ((__m64)__builtin_ia32_pshufw((__v4hi)(__m64)(a), (n)))
+
+/// Conditionally copies the values from each 8-bit element in the first
+///    64-bit integer vector operand to the specified memory location, as
+///    specified by the most significant bit in the corresponding element in the
+///    second 64-bit integer vector operand.
+///
+///    To minimize caching, the data is flagged as non-temporal
+///    (unlikely to be used again soon).
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> MASKMOVQ </c> instruction.
+///
+/// \param __d
+///    A 64-bit integer vector containing the values with elements to be copied.
+/// \param __n
+///    A 64-bit integer vector operand. The most significant bit from each 8-bit
+///    element determines whether the corresponding element in operand \a __d
+///    is copied. If the most significant bit of a given element is 1, the
+///    corresponding element in operand \a __d is copied.
+/// \param __p
+///    A pointer to a 64-bit memory location that will receive the conditionally
+///    copied integer values. The address of the memory location does not have
+///    to be aligned.
+static __inline__ void __DEFAULT_FN_ATTRS_MMX
+_mm_maskmove_si64(__m64 __d, __m64 __n, char *__p)
+{
+  __builtin_ia32_maskmovq((__v8qi)__d, (__v8qi)__n, __p);
+}
+
+/// Computes the rounded averages of the packed unsigned 8-bit integer
+///    values and writes the averages to the corresponding bits in the
+///    destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PAVGB </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 64-bit integer vector containing one of the source operands.
+/// \returns A 64-bit integer vector containing the averages of both operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_avg_pu8(__m64 __a, __m64 __b)
+{
+  return (__m64)__builtin_ia32_pavgb((__v8qi)__a, (__v8qi)__b);
+}
+
+/// Computes the rounded averages of the packed unsigned 16-bit integer
+///    values and writes the averages to the corresponding bits in the
+///    destination.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PAVGW </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 64-bit integer vector containing one of the source operands.
+/// \returns A 64-bit integer vector containing the averages of both operands.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_avg_pu16(__m64 __a, __m64 __b)
+{
+  return (__m64)__builtin_ia32_pavgw((__v4hi)__a, (__v4hi)__b);
+}
+
+/// Subtracts the corresponding 8-bit unsigned integer values of the two
+///    64-bit vector operands and computes the absolute value for each of the
+///    difference. Then sum of the 8 absolute differences is written to the
+///    bits [15:0] of the destination; the remaining bits [63:16] are cleared.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> PSADBW </c> instruction.
+///
+/// \param __a
+///    A 64-bit integer vector containing one of the source operands.
+/// \param __b
+///    A 64-bit integer vector containing one of the source operands.
+/// \returns A 64-bit integer vector whose lower 16 bits contain the sums of the
+///    sets of absolute differences between both operands. The upper bits are
+///    cleared.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_sad_pu8(__m64 __a, __m64 __b)
+{
+  return (__m64)__builtin_ia32_psadbw((__v8qi)__a, (__v8qi)__b);
+}
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/// Returns the contents of the MXCSR register as a 32-bit unsigned
+///    integer value.
+///
+///    There are several groups of macros associated with this
+///    intrinsic, including:
+///    <ul>
+///    <li>
+///      For checking exception states: _MM_EXCEPT_INVALID, _MM_EXCEPT_DIV_ZERO,
+///      _MM_EXCEPT_DENORM, _MM_EXCEPT_OVERFLOW, _MM_EXCEPT_UNDERFLOW,
+///      _MM_EXCEPT_INEXACT. There is a convenience wrapper
+///      _MM_GET_EXCEPTION_STATE().
+///    </li>
+///    <li>
+///      For checking exception masks: _MM_MASK_UNDERFLOW, _MM_MASK_OVERFLOW,
+///      _MM_MASK_INVALID, _MM_MASK_DENORM, _MM_MASK_DIV_ZERO, _MM_MASK_INEXACT.
+///      There is a convenience wrapper _MM_GET_EXCEPTION_MASK().
+///    </li>
+///    <li>
+///      For checking rounding modes: _MM_ROUND_NEAREST, _MM_ROUND_DOWN,
+///      _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO. There is a convenience wrapper
+///      _MM_GET_ROUNDING_MODE().
+///    </li>
+///    <li>
+///      For checking flush-to-zero mode: _MM_FLUSH_ZERO_ON, _MM_FLUSH_ZERO_OFF.
+///      There is a convenience wrapper _MM_GET_FLUSH_ZERO_MODE().
+///    </li>
+///    <li>
+///      For checking denormals-are-zero mode: _MM_DENORMALS_ZERO_ON,
+///      _MM_DENORMALS_ZERO_OFF. There is a convenience wrapper
+///      _MM_GET_DENORMALS_ZERO_MODE().
+///    </li>
+///    </ul>
+///
+///    For example, the following expression checks if an overflow exception has
+///    occurred:
+///    \code
+///      ( _mm_getcsr() & _MM_EXCEPT_OVERFLOW )
+///    \endcode
+///
+///    The following expression gets the current rounding mode:
+///    \code
+///      _MM_GET_ROUNDING_MODE()
+///    \endcode
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VSTMXCSR / STMXCSR </c> instruction.
+///
+/// \returns A 32-bit unsigned integer containing the contents of the MXCSR
+///    register.
+unsigned int _mm_getcsr(void);
+
+/// Sets the MXCSR register with the 32-bit unsigned integer value.
+///
+///    There are several groups of macros associated with this intrinsic,
+///    including:
+///    <ul>
+///    <li>
+///      For setting exception states: _MM_EXCEPT_INVALID, _MM_EXCEPT_DIV_ZERO,
+///      _MM_EXCEPT_DENORM, _MM_EXCEPT_OVERFLOW, _MM_EXCEPT_UNDERFLOW,
+///      _MM_EXCEPT_INEXACT. There is a convenience wrapper
+///      _MM_SET_EXCEPTION_STATE(x) where x is one of these macros.
+///    </li>
+///    <li>
+///      For setting exception masks: _MM_MASK_UNDERFLOW, _MM_MASK_OVERFLOW,
+///      _MM_MASK_INVALID, _MM_MASK_DENORM, _MM_MASK_DIV_ZERO, _MM_MASK_INEXACT.
+///      There is a convenience wrapper _MM_SET_EXCEPTION_MASK(x) where x is one
+///      of these macros.
+///    </li>
+///    <li>
+///      For setting rounding modes: _MM_ROUND_NEAREST, _MM_ROUND_DOWN,
+///      _MM_ROUND_UP, _MM_ROUND_TOWARD_ZERO. There is a convenience wrapper
+///      _MM_SET_ROUNDING_MODE(x) where x is one of these macros.
+///    </li>
+///    <li>
+///      For setting flush-to-zero mode: _MM_FLUSH_ZERO_ON, _MM_FLUSH_ZERO_OFF.
+///      There is a convenience wrapper _MM_SET_FLUSH_ZERO_MODE(x) where x is
+///      one of these macros.
+///    </li>
+///    <li>
+///      For setting denormals-are-zero mode: _MM_DENORMALS_ZERO_ON,
+///      _MM_DENORMALS_ZERO_OFF. There is a convenience wrapper
+///      _MM_SET_DENORMALS_ZERO_MODE(x) where x is one of these macros.
+///    </li>
+///    </ul>
+///
+///    For example, the following expression causes subsequent floating-point
+///    operations to round up:
+///      _mm_setcsr(_mm_getcsr() | _MM_ROUND_UP)
+///
+///    The following example sets the DAZ and FTZ flags:
+///    \code
+///    void setFlags() {
+///      _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
+///      _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
+///    }
+///    \endcode
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VLDMXCSR / LDMXCSR </c> instruction.
+///
+/// \param __i
+///    A 32-bit unsigned integer value to be written to the MXCSR register.
+void _mm_setcsr(unsigned int __i);
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+/// Selects 4 float values from the 128-bit operands of [4 x float], as
+///    specified by the immediate value operand.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_shuffle_ps(__m128 a, __m128 b, const int mask);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> VSHUFPS / SHUFPS </c> instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x float].
+/// \param b
+///    A 128-bit vector of [4 x float].
+/// \param mask
+///    An immediate value containing an 8-bit value specifying which elements to
+///    copy from \a a and \a b. \n
+///    Bits [3:0] specify the values copied from operand \a a. \n
+///    Bits [7:4] specify the values copied from operand \a b. \n
+///    The destinations within the 128-bit destination are assigned values as
+///    follows: \n
+///    Bits [1:0] are used to assign values to bits [31:0] in the
+///    destination. \n
+///    Bits [3:2] are used to assign values to bits [63:32] in the
+///    destination. \n
+///    Bits [5:4] are used to assign values to bits [95:64] in the
+///    destination. \n
+///    Bits [7:6] are used to assign values to bits [127:96] in the
+///    destination. \n
+///    Bit value assignments: \n
+///    00: Bits [31:0] copied from the specified operand. \n
+///    01: Bits [63:32] copied from the specified operand. \n
+///    10: Bits [95:64] copied from the specified operand. \n
+///    11: Bits [127:96] copied from the specified operand. \n
+///    Note: To generate a mask, you can use the \c _MM_SHUFFLE macro.
+///    <c>_MM_SHUFFLE(b6, b4, b2, b0)</c> can create an 8-bit mask of the form
+///    <c>[b6, b4, b2, b0]</c>.
+/// \returns A 128-bit vector of [4 x float] containing the shuffled values.
+#define _mm_shuffle_ps(a, b, mask) \
+  ((__m128)__builtin_ia32_shufps((__v4sf)(__m128)(a), (__v4sf)(__m128)(b), \
+                                 (int)(mask)))
+
+/// Unpacks the high-order (index 2,3) values from two 128-bit vectors of
+///    [4 x float] and interleaves them into a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKHPS / UNPCKHPS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. \n
+///    Bits [95:64] are written to bits [31:0] of the destination. \n
+///    Bits [127:96] are written to bits [95:64] of the destination.
+/// \param __b
+///    A 128-bit vector of [4 x float].
+///    Bits [95:64] are written to bits [63:32] of the destination. \n
+///    Bits [127:96] are written to bits [127:96] of the destination.
+/// \returns A 128-bit vector of [4 x float] containing the interleaved values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_unpackhi_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__b, 2, 6, 3, 7);
+}
+
+/// Unpacks the low-order (index 0,1) values from two 128-bit vectors of
+///    [4 x float] and interleaves them into a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKLPS / UNPCKLPS </c> instruction.
+///
+/// \param __a
+///    A 128-bit vector of [4 x float]. \n
+///    Bits [31:0] are written to bits [31:0] of the destination.  \n
+///    Bits [63:32] are written to bits [95:64] of the destination.
+/// \param __b
+///    A 128-bit vector of [4 x float]. \n
+///    Bits [31:0] are written to bits [63:32] of the destination. \n
+///    Bits [63:32] are written to bits [127:96] of the destination.
+/// \returns A 128-bit vector of [4 x float] containing the interleaved values.
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_unpacklo_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__b, 0, 4, 1, 5);
+}
+
+/// Constructs a 128-bit floating-point vector of [4 x float]. The lower
+///    32 bits are set to the lower 32 bits of the second parameter. The upper
+///    96 bits are set to the upper 96 bits of the first parameter.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VBLENDPS / BLENDPS / MOVSS </c>
+///    instruction.
+///
+/// \param __a
+///    A 128-bit floating-point vector of [4 x float]. The upper 96 bits are
+///    written to the upper 96 bits of the result.
+/// \param __b
+///    A 128-bit floating-point vector of [4 x float]. The lower 32 bits are
+///    written to the lower 32 bits of the result.
+/// \returns A 128-bit floating-point vector of [4 x float].
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_move_ss(__m128 __a, __m128 __b)
+{
+  __a[0] = __b[0];
+  return __a;
+}
+
+/// Constructs a 128-bit floating-point vector of [4 x float]. The lower
+///    64 bits are set to the upper 64 bits of the second parameter. The upper
+///    64 bits are set to the upper 64 bits of the first parameter.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKHPD / UNPCKHPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit floating-point vector of [4 x float]. The upper 64 bits are
+///    written to the upper 64 bits of the result.
+/// \param __b
+///    A 128-bit floating-point vector of [4 x float]. The upper 64 bits are
+///    written to the lower 64 bits of the result.
+/// \returns A 128-bit floating-point vector of [4 x float].
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_movehl_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__b, 6, 7, 2, 3);
+}
+
+/// Constructs a 128-bit floating-point vector of [4 x float]. The lower
+///    64 bits are set to the lower 64 bits of the first parameter. The upper
+///    64 bits are set to the lower 64 bits of the second parameter.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VUNPCKLPD / UNPCKLPD </c> instruction.
+///
+/// \param __a
+///    A 128-bit floating-point vector of [4 x float]. The lower 64 bits are
+///    written to the lower 64 bits of the result.
+/// \param __b
+///    A 128-bit floating-point vector of [4 x float]. The lower 64 bits are
+///    written to the upper 64 bits of the result.
+/// \returns A 128-bit floating-point vector of [4 x float].
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_movelh_ps(__m128 __a, __m128 __b)
+{
+  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__b, 0, 1, 4, 5);
+}
+
+/// Converts a 64-bit vector of [4 x i16] into a 128-bit vector of [4 x
+///    float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPI2PS + COMPOSITE </c> instruction.
+///
+/// \param __a
+///    A 64-bit vector of [4 x i16]. The elements of the destination are copied
+///    from the corresponding elements in this operand.
+/// \returns A 128-bit vector of [4 x float] containing the copied and converted
+///    values from the operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS_MMX
+_mm_cvtpi16_ps(__m64 __a)
+{
+  __m64 __b, __c;
+  __m128 __r;
+
+  __b = _mm_setzero_si64();
+  __b = _mm_cmpgt_pi16(__b, __a);
+  __c = _mm_unpackhi_pi16(__a, __b);
+  __r = _mm_setzero_ps();
+  __r = _mm_cvtpi32_ps(__r, __c);
+  __r = _mm_movelh_ps(__r, __r);
+  __c = _mm_unpacklo_pi16(__a, __b);
+  __r = _mm_cvtpi32_ps(__r, __c);
+
+  return __r;
+}
+
+/// Converts a 64-bit vector of 16-bit unsigned integer values into a
+///    128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPI2PS + COMPOSITE </c> instruction.
+///
+/// \param __a
+///    A 64-bit vector of 16-bit unsigned integer values. The elements of the
+///    destination are copied from the corresponding elements in this operand.
+/// \returns A 128-bit vector of [4 x float] containing the copied and converted
+///    values from the operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS_MMX
+_mm_cvtpu16_ps(__m64 __a)
+{
+  __m64 __b, __c;
+  __m128 __r;
+
+  __b = _mm_setzero_si64();
+  __c = _mm_unpackhi_pi16(__a, __b);
+  __r = _mm_setzero_ps();
+  __r = _mm_cvtpi32_ps(__r, __c);
+  __r = _mm_movelh_ps(__r, __r);
+  __c = _mm_unpacklo_pi16(__a, __b);
+  __r = _mm_cvtpi32_ps(__r, __c);
+
+  return __r;
+}
+
+/// Converts the lower four 8-bit values from a 64-bit vector of [8 x i8]
+///    into a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPI2PS + COMPOSITE </c> instruction.
+///
+/// \param __a
+///    A 64-bit vector of [8 x i8]. The elements of the destination are copied
+///    from the corresponding lower 4 elements in this operand.
+/// \returns A 128-bit vector of [4 x float] containing the copied and converted
+///    values from the operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS_MMX
+_mm_cvtpi8_ps(__m64 __a)
+{
+  __m64 __b;
+
+  __b = _mm_setzero_si64();
+  __b = _mm_cmpgt_pi8(__b, __a);
+  __b = _mm_unpacklo_pi8(__a, __b);
+
+  return _mm_cvtpi16_ps(__b);
+}
+
+/// Converts the lower four unsigned 8-bit integer values from a 64-bit
+///    vector of [8 x u8] into a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPI2PS + COMPOSITE </c> instruction.
+///
+/// \param __a
+///    A 64-bit vector of unsigned 8-bit integer values. The elements of the
+///    destination are copied from the corresponding lower 4 elements in this
+///    operand.
+/// \returns A 128-bit vector of [4 x float] containing the copied and converted
+///    values from the source operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS_MMX
+_mm_cvtpu8_ps(__m64 __a)
+{
+  __m64 __b;
+
+  __b = _mm_setzero_si64();
+  __b = _mm_unpacklo_pi8(__a, __b);
+
+  return _mm_cvtpi16_ps(__b);
+}
+
+/// Converts the two 32-bit signed integer values from each 64-bit vector
+///    operand of [2 x i32] into a 128-bit vector of [4 x float].
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPI2PS + COMPOSITE </c> instruction.
+///
+/// \param __a
+///    A 64-bit vector of [2 x i32]. The lower elements of the destination are
+///    copied from the elements in this operand.
+/// \param __b
+///    A 64-bit vector of [2 x i32]. The upper elements of the destination are
+///    copied from the elements in this operand.
+/// \returns A 128-bit vector of [4 x float] whose lower 64 bits contain the
+///    copied and converted values from the first operand. The upper 64 bits
+///    contain the copied and converted values from the second operand.
+static __inline__ __m128 __DEFAULT_FN_ATTRS_MMX
+_mm_cvtpi32x2_ps(__m64 __a, __m64 __b)
+{
+  __m128 __c;
+
+  __c = _mm_setzero_ps();
+  __c = _mm_cvtpi32_ps(__c, __b);
+  __c = _mm_movelh_ps(__c, __c);
+
+  return _mm_cvtpi32_ps(__c, __a);
+}
+
+/// Converts each single-precision floating-point element of a 128-bit
+///    floating-point vector of [4 x float] into a 16-bit signed integer, and
+///    packs the results into a 64-bit integer vector of [4 x i16].
+///
+///    If the floating-point element is NaN or infinity, or if the
+///    floating-point element is greater than 0x7FFFFFFF or less than -0x8000,
+///    it is converted to 0x8000. Otherwise if the floating-point element is
+///    greater than 0x7FFF, it is converted to 0x7FFF.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPS2PI + COMPOSITE </c> instruction.
+///
+/// \param __a
+///    A 128-bit floating-point vector of [4 x float].
+/// \returns A 64-bit integer vector of [4 x i16] containing the converted
+///    values.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_cvtps_pi16(__m128 __a)
+{
+  __m64 __b, __c;
+
+  __b = _mm_cvtps_pi32(__a);
+  __a = _mm_movehl_ps(__a, __a);
+  __c = _mm_cvtps_pi32(__a);
+
+  return _mm_packs_pi32(__b, __c);
+}
+
+/// Converts each single-precision floating-point element of a 128-bit
+///    floating-point vector of [4 x float] into an 8-bit signed integer, and
+///    packs the results into the lower 32 bits of a 64-bit integer vector of
+///    [8 x i8]. The upper 32 bits of the vector are set to 0.
+///
+///    If the floating-point element is NaN or infinity, or if the
+///    floating-point element is greater than 0x7FFFFFFF or less than -0x80, it
+///    is converted to 0x80. Otherwise if the floating-point element is greater
+///    than 0x7F, it is converted to 0x7F.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> CVTPS2PI + COMPOSITE </c> instruction.
+///
+/// \param __a
+///    128-bit floating-point vector of [4 x float].
+/// \returns A 64-bit integer vector of [8 x i8]. The lower 32 bits contain the
+///    converted values and the uppper 32 bits are set to zero.
+static __inline__ __m64 __DEFAULT_FN_ATTRS_MMX
+_mm_cvtps_pi8(__m128 __a)
+{
+  __m64 __b, __c;
+
+  __b = _mm_cvtps_pi16(__a);
+  __c = _mm_setzero_si64();
+
+  return _mm_packs_pi16(__b, __c);
+}
+
+/// Extracts the sign bits from each single-precision floating-point
+///    element of a 128-bit floating-point vector of [4 x float] and returns the
+///    sign bits in bits [0:3] of the result. Bits [31:4] of the result are set
+///    to zero.
+///
+/// \headerfile <x86intrin.h>
+///
+/// This intrinsic corresponds to the <c> VMOVMSKPS / MOVMSKPS </c> instruction.
+///
+/// \param __a
+///    A 128-bit floating-point vector of [4 x float].
+/// \returns A 32-bit integer value. Bits [3:0] contain the sign bits from each
+///    single-precision floating-point element of the parameter. Bits [31:4] are
+///    set to zero.
+static __inline__ int __DEFAULT_FN_ATTRS
+_mm_movemask_ps(__m128 __a)
+{
+  return __builtin_ia32_movmskps((__v4sf)__a);
+}
+
+/* Compare */
+#define _CMP_EQ_OQ    0x00 /* Equal (ordered, non-signaling)  */
+#define _CMP_LT_OS    0x01 /* Less-than (ordered, signaling)  */
+#define _CMP_LE_OS    0x02 /* Less-than-or-equal (ordered, signaling)  */
+#define _CMP_UNORD_Q  0x03 /* Unordered (non-signaling)  */
+#define _CMP_NEQ_UQ   0x04 /* Not-equal (unordered, non-signaling)  */
+#define _CMP_NLT_US   0x05 /* Not-less-than (unordered, signaling)  */
+#define _CMP_NLE_US   0x06 /* Not-less-than-or-equal (unordered, signaling)  */
+#define _CMP_ORD_Q    0x07 /* Ordered (non-signaling)   */
+
+/// Compares each of the corresponding values of two 128-bit vectors of
+///    [4 x float], using the operation specified by the immediate integer
+///    operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, comparisons that are ordered
+///    return false, and comparisons that are unordered return true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_cmp_ps(__m128 a, __m128 b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> (V)CMPPS </c> instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x float].
+/// \param b
+///    A 128-bit vector of [4 x float].
+/// \param c
+///    An immediate integer operand, with bits [4:0] specifying which comparison
+///    operation to use: \n
+///    0x00: Equal (ordered, non-signaling) \n
+///    0x01: Less-than (ordered, signaling) \n
+///    0x02: Less-than-or-equal (ordered, signaling) \n
+///    0x03: Unordered (non-signaling) \n
+///    0x04: Not-equal (unordered, non-signaling) \n
+///    0x05: Not-less-than (unordered, signaling) \n
+///    0x06: Not-less-than-or-equal (unordered, signaling) \n
+///    0x07: Ordered (non-signaling) \n
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+#define _mm_cmp_ps(a, b, c)                                                    \
+  ((__m128)__builtin_ia32_cmpps((__v4sf)(__m128)(a), (__v4sf)(__m128)(b), (c)))
+
+/// Compares each of the corresponding scalar values of two 128-bit
+///    vectors of [4 x float], using the operation specified by the immediate
+///    integer operand.
+///
+///    Each comparison returns 0x0 for false, 0xFFFFFFFF for true.
+///    If either value in a comparison is NaN, comparisons that are ordered
+///    return false, and comparisons that are unordered return true.
+///
+/// \headerfile <x86intrin.h>
+///
+/// \code
+/// __m128 _mm_cmp_ss(__m128 a, __m128 b, const int c);
+/// \endcode
+///
+/// This intrinsic corresponds to the <c> (V)CMPSS </c> instruction.
+///
+/// \param a
+///    A 128-bit vector of [4 x float].
+/// \param b
+///    A 128-bit vector of [4 x float].
+/// \param c
+///    An immediate integer operand, with bits [4:0] specifying which comparison
+///    operation to use: \n
+///    0x00: Equal (ordered, non-signaling) \n
+///    0x01: Less-than (ordered, signaling) \n
+///    0x02: Less-than-or-equal (ordered, signaling) \n
+///    0x03: Unordered (non-signaling) \n
+///    0x04: Not-equal (unordered, non-signaling) \n
+///    0x05: Not-less-than (unordered, signaling) \n
+///    0x06: Not-less-than-or-equal (unordered, signaling) \n
+///    0x07: Ordered (non-signaling) \n
+/// \returns A 128-bit vector of [4 x float] containing the comparison results.
+#define _mm_cmp_ss(a, b, c)                                                    \
+  ((__m128)__builtin_ia32_cmpss((__v4sf)(__m128)(a), (__v4sf)(__m128)(b), (c)))
+
+#define _MM_ALIGN16 __attribute__((aligned(16)))
+
+#define _MM_SHUFFLE(z, y, x, w) (((z) << 6) | ((y) << 4) | ((x) << 2) | (w))
+
+#define _MM_EXCEPT_INVALID    (0x0001U)
+#define _MM_EXCEPT_DENORM     (0x0002U)
+#define _MM_EXCEPT_DIV_ZERO   (0x0004U)
+#define _MM_EXCEPT_OVERFLOW   (0x0008U)
+#define _MM_EXCEPT_UNDERFLOW  (0x0010U)
+#define _MM_EXCEPT_INEXACT    (0x0020U)
+#define _MM_EXCEPT_MASK       (0x003fU)
+
+#define _MM_MASK_INVALID      (0x0080U)
+#define _MM_MASK_DENORM       (0x0100U)
+#define _MM_MASK_DIV_ZERO     (0x0200U)
+#define _MM_MASK_OVERFLOW     (0x0400U)
+#define _MM_MASK_UNDERFLOW    (0x0800U)
+#define _MM_MASK_INEXACT      (0x1000U)
+#define _MM_MASK_MASK         (0x1f80U)
+
+#define _MM_ROUND_NEAREST     (0x0000U)
+#define _MM_ROUND_DOWN        (0x2000U)
+#define _MM_ROUND_UP          (0x4000U)
+#define _MM_ROUND_TOWARD_ZERO (0x6000U)
+#define _MM_ROUND_MASK        (0x6000U)
+
+#define _MM_FLUSH_ZERO_MASK   (0x8000U)
+#define _MM_FLUSH_ZERO_ON     (0x8000U)
+#define _MM_FLUSH_ZERO_OFF    (0x0000U)
+
+#define _MM_GET_EXCEPTION_MASK() (_mm_getcsr() & _MM_MASK_MASK)
+#define _MM_GET_EXCEPTION_STATE() (_mm_getcsr() & _MM_EXCEPT_MASK)
+#define _MM_GET_FLUSH_ZERO_MODE() (_mm_getcsr() & _MM_FLUSH_ZERO_MASK)
+#define _MM_GET_ROUNDING_MODE() (_mm_getcsr() & _MM_ROUND_MASK)
+
+#define _MM_SET_EXCEPTION_MASK(x) (_mm_setcsr((_mm_getcsr() & ~_MM_MASK_MASK) | (x)))
+#define _MM_SET_EXCEPTION_STATE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_EXCEPT_MASK) | (x)))
+#define _MM_SET_FLUSH_ZERO_MODE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_FLUSH_ZERO_MASK) | (x)))
+#define _MM_SET_ROUNDING_MODE(x) (_mm_setcsr((_mm_getcsr() & ~_MM_ROUND_MASK) | (x)))
+
+#define _MM_TRANSPOSE4_PS(row0, row1, row2, row3) \
+do { \
+  __m128 tmp3, tmp2, tmp1, tmp0; \
+  tmp0 = _mm_unpacklo_ps((row0), (row1)); \
+  tmp2 = _mm_unpacklo_ps((row2), (row3)); \
+  tmp1 = _mm_unpackhi_ps((row0), (row1)); \
+  tmp3 = _mm_unpackhi_ps((row2), (row3)); \
+  (row0) = _mm_movelh_ps(tmp0, tmp2); \
+  (row1) = _mm_movehl_ps(tmp2, tmp0); \
+  (row2) = _mm_movelh_ps(tmp1, tmp3); \
+  (row3) = _mm_movehl_ps(tmp3, tmp1); \
+} while (0)
+
+/* Aliases for compatibility. */
+#define _m_pextrw _mm_extract_pi16
+#define _m_pinsrw _mm_insert_pi16
+#define _m_pmaxsw _mm_max_pi16
+#define _m_pmaxub _mm_max_pu8
+#define _m_pminsw _mm_min_pi16
+#define _m_pminub _mm_min_pu8
+#define _m_pmovmskb _mm_movemask_pi8
+#define _m_pmulhuw _mm_mulhi_pu16
+#define _m_pshufw _mm_shuffle_pi16
+#define _m_maskmovq _mm_maskmove_si64
+#define _m_pavgb _mm_avg_pu8
+#define _m_pavgw _mm_avg_pu16
+#define _m_psadbw _mm_sad_pu8
+#define _m_ _mm_
+
+#undef __DEFAULT_FN_ATTRS
+#undef __DEFAULT_FN_ATTRS_MMX
+
+/* Ugly hack for backwards-compatibility (compatible with gcc) */
+#if defined(__SSE2__) && !__building_module(_Builtin_intrinsics)
+#include "emmintrin.h"
+#endif
+
+#endif /* __XMMINTRIN_H */
diff --git a/third_party/intel/clang/xopintrin.h b/third_party/intel/clang/xopintrin.h
new file mode 100644
index 000000000..976cdf490
--- /dev/null
+++ b/third_party/intel/clang/xopintrin.h
@@ -0,0 +1,770 @@
+/*===---- xopintrin.h - XOP intrinsics -------------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __X86INTRIN_H
+#error "Never use <xopintrin.h> directly; include <x86intrin.h> instead."
+#endif
+
+#ifndef __XOPINTRIN_H
+#define __XOPINTRIN_H
+
+#include <fma4intrin.h>
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("xop"), __min_vector_width__(128)))
+#define __DEFAULT_FN_ATTRS256 __attribute__((__always_inline__, __nodebug__, __target__("xop"), __min_vector_width__(256)))
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_maccs_epi16(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmacssww((__v8hi)__A, (__v8hi)__B, (__v8hi)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_macc_epi16(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmacsww((__v8hi)__A, (__v8hi)__B, (__v8hi)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_maccsd_epi16(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmacsswd((__v8hi)__A, (__v8hi)__B, (__v4si)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_maccd_epi16(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmacswd((__v8hi)__A, (__v8hi)__B, (__v4si)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_maccs_epi32(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmacssdd((__v4si)__A, (__v4si)__B, (__v4si)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_macc_epi32(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmacsdd((__v4si)__A, (__v4si)__B, (__v4si)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_maccslo_epi32(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmacssdql((__v4si)__A, (__v4si)__B, (__v2di)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_macclo_epi32(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmacsdql((__v4si)__A, (__v4si)__B, (__v2di)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_maccshi_epi32(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmacssdqh((__v4si)__A, (__v4si)__B, (__v2di)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_macchi_epi32(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmacsdqh((__v4si)__A, (__v4si)__B, (__v2di)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_maddsd_epi16(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmadcsswd((__v8hi)__A, (__v8hi)__B, (__v4si)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_maddd_epi16(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpmadcswd((__v8hi)__A, (__v8hi)__B, (__v4si)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddw_epi8(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphaddbw((__v16qi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddd_epi8(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphaddbd((__v16qi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddq_epi8(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphaddbq((__v16qi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddd_epi16(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphaddwd((__v8hi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddq_epi16(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphaddwq((__v8hi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddq_epi32(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphadddq((__v4si)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddw_epu8(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphaddubw((__v16qi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddd_epu8(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphaddubd((__v16qi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddq_epu8(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphaddubq((__v16qi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddd_epu16(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphadduwd((__v8hi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddq_epu16(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphadduwq((__v8hi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_haddq_epu32(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphaddudq((__v4si)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_hsubw_epi8(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphsubbw((__v16qi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_hsubd_epi16(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphsubwd((__v8hi)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_hsubq_epi32(__m128i __A)
+{
+  return (__m128i)__builtin_ia32_vphsubdq((__v4si)__A);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_cmov_si128(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)(((__v2du)__A & (__v2du)__C) | ((__v2du)__B & ~(__v2du)__C));
+}
+
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cmov_si256(__m256i __A, __m256i __B, __m256i __C)
+{
+  return (__m256i)(((__v4du)__A & (__v4du)__C) | ((__v4du)__B & ~(__v4du)__C));
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_perm_epi8(__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i)__builtin_ia32_vpperm((__v16qi)__A, (__v16qi)__B, (__v16qi)__C);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_rot_epi8(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vprotb((__v16qi)__A, (__v16qi)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_rot_epi16(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vprotw((__v8hi)__A, (__v8hi)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_rot_epi32(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vprotd((__v4si)__A, (__v4si)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_rot_epi64(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vprotq((__v2di)__A, (__v2di)__B);
+}
+
+#define _mm_roti_epi8(A, N) \
+  ((__m128i)__builtin_ia32_vprotbi((__v16qi)(__m128i)(A), (N)))
+
+#define _mm_roti_epi16(A, N) \
+  ((__m128i)__builtin_ia32_vprotwi((__v8hi)(__m128i)(A), (N)))
+
+#define _mm_roti_epi32(A, N) \
+  ((__m128i)__builtin_ia32_vprotdi((__v4si)(__m128i)(A), (N)))
+
+#define _mm_roti_epi64(A, N) \
+  ((__m128i)__builtin_ia32_vprotqi((__v2di)(__m128i)(A), (N)))
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_shl_epi8(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpshlb((__v16qi)__A, (__v16qi)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_shl_epi16(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpshlw((__v8hi)__A, (__v8hi)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_shl_epi32(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpshld((__v4si)__A, (__v4si)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_shl_epi64(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpshlq((__v2di)__A, (__v2di)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sha_epi8(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpshab((__v16qi)__A, (__v16qi)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sha_epi16(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpshaw((__v8hi)__A, (__v8hi)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sha_epi32(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpshad((__v4si)__A, (__v4si)__B);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_sha_epi64(__m128i __A, __m128i __B)
+{
+  return (__m128i)__builtin_ia32_vpshaq((__v2di)__A, (__v2di)__B);
+}
+
+#define _mm_com_epu8(A, B, N) \
+  ((__m128i)__builtin_ia32_vpcomub((__v16qi)(__m128i)(A), \
+                                   (__v16qi)(__m128i)(B), (N)))
+
+#define _mm_com_epu16(A, B, N) \
+  ((__m128i)__builtin_ia32_vpcomuw((__v8hi)(__m128i)(A), \
+                                   (__v8hi)(__m128i)(B), (N)))
+
+#define _mm_com_epu32(A, B, N) \
+  ((__m128i)__builtin_ia32_vpcomud((__v4si)(__m128i)(A), \
+                                   (__v4si)(__m128i)(B), (N)))
+
+#define _mm_com_epu64(A, B, N) \
+  ((__m128i)__builtin_ia32_vpcomuq((__v2di)(__m128i)(A), \
+                                   (__v2di)(__m128i)(B), (N)))
+
+#define _mm_com_epi8(A, B, N) \
+  ((__m128i)__builtin_ia32_vpcomb((__v16qi)(__m128i)(A), \
+                                  (__v16qi)(__m128i)(B), (N)))
+
+#define _mm_com_epi16(A, B, N) \
+  ((__m128i)__builtin_ia32_vpcomw((__v8hi)(__m128i)(A), \
+                                  (__v8hi)(__m128i)(B), (N)))
+
+#define _mm_com_epi32(A, B, N) \
+  ((__m128i)__builtin_ia32_vpcomd((__v4si)(__m128i)(A), \
+                                  (__v4si)(__m128i)(B), (N)))
+
+#define _mm_com_epi64(A, B, N) \
+  ((__m128i)__builtin_ia32_vpcomq((__v2di)(__m128i)(A), \
+                                  (__v2di)(__m128i)(B), (N)))
+
+#define _MM_PCOMCTRL_LT    0
+#define _MM_PCOMCTRL_LE    1
+#define _MM_PCOMCTRL_GT    2
+#define _MM_PCOMCTRL_GE    3
+#define _MM_PCOMCTRL_EQ    4
+#define _MM_PCOMCTRL_NEQ   5
+#define _MM_PCOMCTRL_FALSE 6
+#define _MM_PCOMCTRL_TRUE  7
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comlt_epu8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_LT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comle_epu8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_LE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comgt_epu8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_GT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comge_epu8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_GE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comeq_epu8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_EQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comneq_epu8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_NEQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comfalse_epu8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_FALSE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comtrue_epu8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu8(__A, __B, _MM_PCOMCTRL_TRUE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comlt_epu16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_LT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comle_epu16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_LE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comgt_epu16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_GT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comge_epu16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_GE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comeq_epu16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_EQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comneq_epu16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_NEQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comfalse_epu16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_FALSE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comtrue_epu16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu16(__A, __B, _MM_PCOMCTRL_TRUE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comlt_epu32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_LT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comle_epu32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_LE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comgt_epu32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_GT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comge_epu32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_GE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comeq_epu32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_EQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comneq_epu32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_NEQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comfalse_epu32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_FALSE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comtrue_epu32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu32(__A, __B, _MM_PCOMCTRL_TRUE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comlt_epu64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_LT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comle_epu64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_LE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comgt_epu64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_GT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comge_epu64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_GE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comeq_epu64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_EQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comneq_epu64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_NEQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comfalse_epu64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_FALSE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comtrue_epu64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epu64(__A, __B, _MM_PCOMCTRL_TRUE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comlt_epi8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_LT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comle_epi8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_LE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comgt_epi8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_GT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comge_epi8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_GE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comeq_epi8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_EQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comneq_epi8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_NEQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comfalse_epi8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_FALSE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comtrue_epi8(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi8(__A, __B, _MM_PCOMCTRL_TRUE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comlt_epi16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_LT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comle_epi16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_LE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comgt_epi16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_GT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comge_epi16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_GE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comeq_epi16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_EQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comneq_epi16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_NEQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comfalse_epi16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_FALSE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comtrue_epi16(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi16(__A, __B, _MM_PCOMCTRL_TRUE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comlt_epi32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_LT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comle_epi32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_LE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comgt_epi32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_GT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comge_epi32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_GE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comeq_epi32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_EQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comneq_epi32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_NEQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comfalse_epi32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_FALSE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comtrue_epi32(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi32(__A, __B, _MM_PCOMCTRL_TRUE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comlt_epi64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_LT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comle_epi64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_LE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comgt_epi64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_GT);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comge_epi64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_GE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comeq_epi64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_EQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comneq_epi64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_NEQ);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comfalse_epi64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_FALSE);
+}
+
+static __inline__ __m128i __DEFAULT_FN_ATTRS
+_mm_comtrue_epi64(__m128i __A, __m128i __B)
+{
+  return _mm_com_epi64(__A, __B, _MM_PCOMCTRL_TRUE);
+}
+
+#define _mm_permute2_pd(X, Y, C, I) \
+  ((__m128d)__builtin_ia32_vpermil2pd((__v2df)(__m128d)(X), \
+                                      (__v2df)(__m128d)(Y), \
+                                      (__v2di)(__m128i)(C), (I)))
+
+#define _mm256_permute2_pd(X, Y, C, I) \
+  ((__m256d)__builtin_ia32_vpermil2pd256((__v4df)(__m256d)(X), \
+                                         (__v4df)(__m256d)(Y), \
+                                         (__v4di)(__m256i)(C), (I)))
+
+#define _mm_permute2_ps(X, Y, C, I) \
+  ((__m128)__builtin_ia32_vpermil2ps((__v4sf)(__m128)(X), (__v4sf)(__m128)(Y), \
+                                     (__v4si)(__m128i)(C), (I)))
+
+#define _mm256_permute2_ps(X, Y, C, I) \
+  ((__m256)__builtin_ia32_vpermil2ps256((__v8sf)(__m256)(X), \
+                                        (__v8sf)(__m256)(Y), \
+                                        (__v8si)(__m256i)(C), (I)))
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_frcz_ss(__m128 __A)
+{
+  return (__m128)__builtin_ia32_vfrczss((__v4sf)__A);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS
+_mm_frcz_sd(__m128d __A)
+{
+  return (__m128d)__builtin_ia32_vfrczsd((__v2df)__A);
+}
+
+static __inline__ __m128 __DEFAULT_FN_ATTRS
+_mm_frcz_ps(__m128 __A)
+{
+  return (__m128)__builtin_ia32_vfrczps((__v4sf)__A);
+}
+
+static __inline__ __m128d __DEFAULT_FN_ATTRS
+_mm_frcz_pd(__m128d __A)
+{
+  return (__m128d)__builtin_ia32_vfrczpd((__v2df)__A);
+}
+
+static __inline__ __m256 __DEFAULT_FN_ATTRS256
+_mm256_frcz_ps(__m256 __A)
+{
+  return (__m256)__builtin_ia32_vfrczps256((__v8sf)__A);
+}
+
+static __inline__ __m256d __DEFAULT_FN_ATTRS256
+_mm256_frcz_pd(__m256d __A)
+{
+  return (__m256d)__builtin_ia32_vfrczpd256((__v4df)__A);
+}
+
+#undef __DEFAULT_FN_ATTRS
+#undef __DEFAULT_FN_ATTRS256
+
+#endif /* __XOPINTRIN_H */
diff --git a/third_party/intel/clang/xsavecintrin.h b/third_party/intel/clang/xsavecintrin.h
new file mode 100644
index 000000000..1f2d00120
--- /dev/null
+++ b/third_party/intel/clang/xsavecintrin.h
@@ -0,0 +1,84 @@
+/*===---- xsavecintrin.h - XSAVEC intrinsic --------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <xsavecintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __XSAVECINTRIN_H
+#define __XSAVECINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__,  __target__("xsavec")))
+
+/// Performs a full or partial save of processor state to the memory at
+///    \a __p. The exact state saved depends on the 64-bit mask \a __m and
+///    processor control register \c XCR0.
+///
+/// \code{.operation}
+/// mask[62:0] := __m[62:0] AND XCR0[62:0]
+/// FOR i := 0 TO 62
+///   IF mask[i] == 1
+///     CASE (i) OF
+///     0: save X87 FPU state
+///     1: save SSE state
+///     DEFAULT: __p.Ext_Save_Area[i] := ProcessorState[i]
+///   FI
+/// ENDFOR
+/// __p.Header.XSTATE_BV[62:0] := INIT_FUNCTION(mask[62:0])
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c XSAVEC instruction.
+///
+/// \param __p
+///    Pointer to the save area; must be 64-byte aligned.
+/// \param __m
+///    A 64-bit mask indicating what state should be saved.
+static __inline__ void __DEFAULT_FN_ATTRS
+_xsavec(void *__p, unsigned long long __m) {
+  __builtin_ia32_xsavec(__p, __m);
+}
+
+#ifdef __x86_64__
+/// Performs a full or partial save of processor state to the memory at
+///    \a __p. The exact state saved depends on the 64-bit mask \a __m and
+///    processor control register \c XCR0.
+///
+/// \code{.operation}
+/// mask[62:0] := __m[62:0] AND XCR0[62:0]
+/// FOR i := 0 TO 62
+///   IF mask[i] == 1
+///     CASE (i) OF
+///     0: save X87 FPU state
+///     1: save SSE state
+///     DEFAULT: __p.Ext_Save_Area[i] := ProcessorState[i]
+///   FI
+/// ENDFOR
+/// __p.Header.XSTATE_BV[62:0] := INIT_FUNCTION(mask[62:0])
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c XSAVEC64 instruction.
+///
+/// \param __p
+///    Pointer to the save area; must be 64-byte aligned.
+/// \param __m
+///    A 64-bit mask indicating what state should be saved.
+static __inline__ void __DEFAULT_FN_ATTRS
+_xsavec64(void *__p, unsigned long long __m) {
+  __builtin_ia32_xsavec64(__p, __m);
+}
+#endif
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/xsaveintrin.h b/third_party/intel/clang/xsaveintrin.h
new file mode 100644
index 000000000..9429db6dd
--- /dev/null
+++ b/third_party/intel/clang/xsaveintrin.h
@@ -0,0 +1,63 @@
+/*===---- xsaveintrin.h - XSAVE intrinsic ----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <xsaveintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __XSAVEINTRIN_H
+#define __XSAVEINTRIN_H
+
+#ifdef _MSC_VER
+#define _XCR_XFEATURE_ENABLED_MASK 0
+#endif
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__,  __target__("xsave")))
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_xsave(void *__p, unsigned long long __m) {
+  __builtin_ia32_xsave(__p, __m);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_xrstor(void *__p, unsigned long long __m) {
+  __builtin_ia32_xrstor(__p, __m);
+}
+
+#ifndef _MSC_VER
+#define _xgetbv(A) __builtin_ia32_xgetbv((long long)(A))
+#define _xsetbv(A, B) __builtin_ia32_xsetbv((unsigned int)(A), (unsigned long long)(B))
+#else
+#ifdef __cplusplus
+extern "C" {
+#endif
+unsigned __int64 __cdecl _xgetbv(unsigned int);
+void __cdecl _xsetbv(unsigned int, unsigned __int64);
+#ifdef __cplusplus
+}
+#endif
+#endif /* _MSC_VER */
+
+#ifdef __x86_64__
+static __inline__ void __DEFAULT_FN_ATTRS
+_xsave64(void *__p, unsigned long long __m) {
+  __builtin_ia32_xsave64(__p, __m);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_xrstor64(void *__p, unsigned long long __m) {
+  __builtin_ia32_xrstor64(__p, __m);
+}
+
+#endif
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/xsaveoptintrin.h b/third_party/intel/clang/xsaveoptintrin.h
new file mode 100644
index 000000000..89a4c44db
--- /dev/null
+++ b/third_party/intel/clang/xsaveoptintrin.h
@@ -0,0 +1,34 @@
+/*===---- xsaveoptintrin.h - XSAVEOPT intrinsic ----------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <xsaveoptintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __XSAVEOPTINTRIN_H
+#define __XSAVEOPTINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__,  __target__("xsaveopt")))
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_xsaveopt(void *__p, unsigned long long __m) {
+  __builtin_ia32_xsaveopt(__p, __m);
+}
+
+#ifdef __x86_64__
+static __inline__ void __DEFAULT_FN_ATTRS
+_xsaveopt64(void *__p, unsigned long long __m) {
+  __builtin_ia32_xsaveopt64(__p, __m);
+}
+#endif
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/xsavesintrin.h b/third_party/intel/clang/xsavesintrin.h
new file mode 100644
index 000000000..3f99219a2
--- /dev/null
+++ b/third_party/intel/clang/xsavesintrin.h
@@ -0,0 +1,44 @@
+/*===---- xsavesintrin.h - XSAVES intrinsic --------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <xsavesintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __XSAVESINTRIN_H
+#define __XSAVESINTRIN_H
+
+/* Define the default attributes for the functions in this file. */
+#define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__,  __target__("xsaves")))
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_xsaves(void *__p, unsigned long long __m) {
+  __builtin_ia32_xsaves(__p, __m);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_xrstors(void *__p, unsigned long long __m) {
+  __builtin_ia32_xrstors(__p, __m);
+}
+
+#ifdef __x86_64__
+static __inline__ void __DEFAULT_FN_ATTRS
+_xrstors64(void *__p, unsigned long long __m) {
+  __builtin_ia32_xrstors64(__p, __m);
+}
+
+static __inline__ void __DEFAULT_FN_ATTRS
+_xsaves64(void *__p, unsigned long long __m) {
+  __builtin_ia32_xsaves64(__p, __m);
+}
+#endif
+
+#undef __DEFAULT_FN_ATTRS
+
+#endif
diff --git a/third_party/intel/clang/xtestintrin.h b/third_party/intel/clang/xtestintrin.h
new file mode 100644
index 000000000..7d19e3733
--- /dev/null
+++ b/third_party/intel/clang/xtestintrin.h
@@ -0,0 +1,27 @@
+/*===---- xtestintrin.h - XTEST intrinsic ----------------------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ *===-----------------------------------------------------------------------===
+ */
+
+#ifndef __IMMINTRIN_H
+#error "Never use <xtestintrin.h> directly; include <immintrin.h> instead."
+#endif
+
+#ifndef __XTESTINTRIN_H
+#define __XTESTINTRIN_H
+
+/* xtest returns non-zero if the instruction is executed within an RTM or active
+ * HLE region. */
+/* FIXME: This can be an either or for RTM/HLE. Deal with this when HLE is
+ * supported. */
+static __inline__ int
+    __attribute__((__always_inline__, __nodebug__, __target__("rtm")))
+    _xtest(void) {
+  return __builtin_ia32_xtest();
+}
+
+#endif
diff --git a/third_party/intel/cmpccxaddintrin.internal.h b/third_party/intel/cmpccxaddintrin.internal.h
new file mode 100644
index 000000000..6b3924a2c
--- /dev/null
+++ b/third_party/intel/cmpccxaddintrin.internal.h
@@ -0,0 +1,55 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#ifndef _X86GPRINTRIN_H_INCLUDED
+#error "Never use <cmpccxaddintrin.h> directly; include <x86gprintrin.h> instead."
+#endif
+#ifndef _CMPCCXADDINTRIN_H_INCLUDED
+#define _CMPCCXADDINTRIN_H_INCLUDED
+#ifdef __x86_64__
+#ifndef __CMPCCXADD__
+#pragma GCC push_options
+#pragma GCC target("cmpccxadd")
+#define __DISABLE_CMPCCXADD__
+#endif
+typedef enum {
+    _CMPCCX_O,
+    _CMPCCX_NO,
+    _CMPCCX_B,
+    _CMPCCX_NB,
+    _CMPCCX_Z,
+    _CMPCCX_NZ,
+    _CMPCCX_BE,
+    _CMPCCX_NBE,
+    _CMPCCX_S,
+    _CMPCCX_NS,
+    _CMPCCX_P,
+    _CMPCCX_NP,
+    _CMPCCX_L,
+    _CMPCCX_NL,
+    _CMPCCX_LE,
+    _CMPCCX_NLE,
+} _CMPCCX_ENUM;
+#ifdef __OPTIMIZE__
+extern __inline int
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_cmpccxadd_epi32 (int *__A, int __B, int __C, const _CMPCCX_ENUM __D)
+{
+  return __builtin_ia32_cmpccxadd (__A, __B, __C, __D);
+}
+extern __inline long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_cmpccxadd_epi64 (long long *__A, long long __B, long long __C,
+     const _CMPCCX_ENUM __D)
+{
+  return __builtin_ia32_cmpccxadd64 (__A, __B, __C, __D);
+}
+#else
+#define _cmpccxadd_epi32(A,B,C,D) __builtin_ia32_cmpccxadd ((int *) (A), (int) (B), (int) (C), (_CMPCCX_ENUM) (D))
+#define _cmpccxadd_epi64(A,B,C,D) __builtin_ia32_cmpccxadd64 ((long long *) (A), (long long) (B), (long long) (C), (_CMPCCX_ENUM) (D))
+#endif
+#ifdef __DISABLE_CMPCCXADD__
+#undef __DISABLE_CMPCCXADD__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
+#endif
diff --git a/third_party/intel/cpuid.internal.h b/third_party/intel/cpuid.internal.h
index 3f082193c..dd9b2cc3d 100644
--- a/third_party/intel/cpuid.internal.h
+++ b/third_party/intel/cpuid.internal.h
@@ -1,9 +1,6 @@
 #if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
 #ifndef _CPUID_H_INCLUDED
 #define _CPUID_H_INCLUDED
-#define bit_AVXVNNI (1 << 4)
-#define bit_AVX512BF16 (1 << 5)
-#define bit_HRESET (1 << 22)
 #define bit_SSE3 (1 << 0)
 #define bit_PCLMUL (1 << 1)
 #define bit_LZCNT (1 << 5)
@@ -70,34 +67,54 @@
 #define bit_SHSTK (1 << 7)
 #define bit_GFNI (1 << 8)
 #define bit_VAES (1 << 9)
-#define bit_AVX512VNNI (1 << 11)
 #define bit_VPCLMULQDQ (1 << 10)
+#define bit_AVX512VNNI (1 << 11)
 #define bit_AVX512BITALG (1 << 12)
 #define bit_AVX512VPOPCNTDQ (1 << 14)
 #define bit_RDPID (1 << 22)
+#define bit_KL (1 << 23)
+#define bit_CLDEMOTE (1 << 25)
 #define bit_MOVDIRI (1 << 27)
 #define bit_MOVDIR64B (1 << 28)
 #define bit_ENQCMD (1 << 29)
-#define bit_CLDEMOTE (1 << 25)
-#define bit_KL (1 << 23)
 #define bit_AVX5124VNNIW (1 << 2)
 #define bit_AVX5124FMAPS (1 << 3)
-#define bit_AVX512VP2INTERSECT (1 << 8)
-#define bit_AVX512FP16 (1 << 23)
-#define bit_IBT (1 << 20)
 #define bit_UINTR (1 << 5)
-#define bit_PCONFIG (1 << 18)
+#define bit_AVX512VP2INTERSECT (1 << 8)
 #define bit_SERIALIZE (1 << 14)
 #define bit_TSXLDTRK (1 << 16)
+#define bit_PCONFIG (1 << 18)
+#define bit_IBT (1 << 20)
 #define bit_AMX_BF16 (1 << 22)
+#define bit_AVX512FP16 (1 << 23)
 #define bit_AMX_TILE (1 << 24)
 #define bit_AMX_INT8 (1 << 25)
+#define bit_SHA512 (1 << 0)
+#define bit_SM3 (1 << 1)
+#define bit_SM4 (1 << 2)
+#define bit_RAOINT (1 << 3)
+#define bit_AVXVNNI (1 << 4)
+#define bit_AVX512BF16 (1 << 5)
+#define bit_CMPCCXADD (1 << 7)
+#define bit_AMX_COMPLEX (1 << 8)
+#define bit_AMX_FP16 (1 << 21)
+#define bit_HRESET (1 << 22)
+#define bit_AVXIFMA (1 << 23)
+#define bit_AVXVNNIINT8 (1 << 4)
+#define bit_AVXNECONVERT (1 << 5)
+#define bit_AVXVNNIINT16 (1 << 10)
+#define bit_PREFETCHI (1 << 14)
+#define bit_USER_MSR (1 << 15)
+#define bit_AVX10 (1 << 19)
+#define bit_APX_F (1 << 21)
 #define bit_XSAVEOPT (1 << 0)
 #define bit_XSAVEC (1 << 1)
 #define bit_XSAVES (1 << 3)
 #define bit_PTWRITE (1 << 4)
 #define bit_AESKLE ( 1<<0 )
 #define bit_WIDEKL ( 1<<2 )
+#define bit_AVX10_256 (1 << 17)
+#define bit_AVX10_512 (1 << 18)
 #define signature_AMD_ebx 0x68747541
 #define signature_AMD_ecx 0x444d4163
 #define signature_AMD_edx 0x69746e65
@@ -137,6 +154,9 @@
 #define signature_VORTEX_ebx 0x74726f56
 #define signature_VORTEX_ecx 0x436f5320
 #define signature_VORTEX_edx 0x36387865
+#define signature_SHANGHAI_ebx 0x68532020
+#define signature_SHANGHAI_ecx 0x20206961
+#define signature_SHANGHAI_edx 0x68676e61
 #ifndef __x86_64__
 #define __cpuid(level, a, b, c, d) do { if (__builtin_constant_p (level) && (level) != 1) __asm__ __volatile__ ("cpuid\n\t" : "=a" (a), "=b" (b), "=c" (c), "=d" (d) : "0" (level)); else __asm__ __volatile__ ("cpuid\n\t" : "=a" (a), "=b" (b), "=c" (c), "=d" (d) : "0" (level), "1" (0), "2" (0)); } while (0)
 #else
@@ -175,7 +195,7 @@ __get_cpuid_max (unsigned int __ext, unsigned int *__sig)
     : "=&r" (__eax), "=&r" (__ebx)
     : "i" (0x00200000));
 #endif
-  if (!((__eax ^ __ebx) & 0x00200000))
+  if (__builtin_expect (!((__eax ^ __ebx) & 0x00200000), 0))
     return 0;
 #endif
   __cpuid (__ext, __eax, __ebx, __ecx, __edx);
@@ -202,7 +222,7 @@ __get_cpuid_count (unsigned int __leaf, unsigned int __subleaf,
 {
   unsigned int __ext = __leaf & 0x80000000;
   unsigned int __maxlevel = __get_cpuid_max (__ext, 0);
-  if (__maxlevel == 0 || __maxlevel < __leaf)
+  if (__builtin_expect (__maxlevel == 0, 0) || __maxlevel < __leaf)
     return 0;
   __cpuid_count (__leaf, __subleaf, *__eax, *__ebx, *__ecx, *__edx);
   return 1;
diff --git a/third_party/intel/emmintrin.internal.h b/third_party/intel/emmintrin.internal.h
index c0c3bf59d..6f781d3be 100644
--- a/third_party/intel/emmintrin.internal.h
+++ b/third_party/intel/emmintrin.internal.h
@@ -50,7 +50,10 @@ _mm_setr_pd (double __W, double __X)
 extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_undefined_pd (void)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
   __m128d __Y = __Y;
+#pragma GCC diagnostic pop
   return __Y;
 }
 extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -605,7 +608,10 @@ _mm_move_epi64 (__m128i __A)
 extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_undefined_si128 (void)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
   __m128i __Y = __Y;
+#pragma GCC diagnostic pop
   return __Y;
 }
 extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
diff --git a/third_party/intel/gfniintrin.internal.h b/third_party/intel/gfniintrin.internal.h
index 6dfe26778..b56cfeda9 100644
--- a/third_party/intel/gfniintrin.internal.h
+++ b/third_party/intel/gfniintrin.internal.h
@@ -94,7 +94,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_maskz_gf2p8mul_epi8 (__mmask16 __A, __m128i __B, __m128i __C)
 {
   return (__m128i) __builtin_ia32_vgf2p8mulb_v16qi_mask ((__v16qi) __B,
-   (__v16qi) __C, (__v16qi) _mm_setzero_si128 (), __A);
+   (__v16qi) __C, (__v16qi) _mm_avx512_setzero_si128 (), __A);
 }
 #ifdef __OPTIMIZE__
 extern __inline __m128i
@@ -115,7 +115,7 @@ _mm_maskz_gf2p8affineinv_epi64_epi8 (__mmask16 __A, __m128i __B, __m128i __C,
 {
   return (__m128i) __builtin_ia32_vgf2p8affineinvqb_v16qi_mask ((__v16qi) __B,
       (__v16qi) __C, __D,
-      (__v16qi) _mm_setzero_si128 (),
+      (__v16qi) _mm_avx512_setzero_si128 (),
        __A);
 }
 extern __inline __m128i
@@ -132,13 +132,13 @@ _mm_maskz_gf2p8affine_epi64_epi8 (__mmask16 __A, __m128i __B, __m128i __C,
       const int __D)
 {
   return (__m128i) __builtin_ia32_vgf2p8affineqb_v16qi_mask ((__v16qi) __B,
-       (__v16qi) __C, __D, (__v16qi) _mm_setzero_si128 (), __A);
+       (__v16qi) __C, __D, (__v16qi) _mm_avx512_setzero_si128 (), __A);
 }
 #else
 #define _mm_mask_gf2p8affineinv_epi64_epi8(A, B, C, D, E) ((__m128i) __builtin_ia32_vgf2p8affineinvqb_v16qi_mask( (__v16qi)(__m128i)(C), (__v16qi)(__m128i)(D), (int)(E), (__v16qi)(__m128i)(A), (__mmask16)(B)))
-#define _mm_maskz_gf2p8affineinv_epi64_epi8(A, B, C, D) ((__m128i) __builtin_ia32_vgf2p8affineinvqb_v16qi_mask( (__v16qi)(__m128i)(B), (__v16qi)(__m128i)(C), (int)(D), (__v16qi)(__m128i) _mm_setzero_si128 (), (__mmask16)(A)))
+#define _mm_maskz_gf2p8affineinv_epi64_epi8(A, B, C, D) ((__m128i) __builtin_ia32_vgf2p8affineinvqb_v16qi_mask( (__v16qi)(__m128i)(B), (__v16qi)(__m128i)(C), (int)(D), (__v16qi)(__m128i) _mm_avx512_setzero_si128 (), (__mmask16)(A)))
 #define _mm_mask_gf2p8affine_epi64_epi8(A, B, C, D, E) ((__m128i) __builtin_ia32_vgf2p8affineqb_v16qi_mask((__v16qi)(__m128i)(C), (__v16qi)(__m128i)(D), (int)(E), (__v16qi)(__m128i)(A), (__mmask16)(B)))
-#define _mm_maskz_gf2p8affine_epi64_epi8(A, B, C, D) ((__m128i) __builtin_ia32_vgf2p8affineqb_v16qi_mask((__v16qi)(__m128i)(B), (__v16qi)(__m128i)(C), (int)(D), (__v16qi)(__m128i) _mm_setzero_si128 (), (__mmask16)(A)))
+#define _mm_maskz_gf2p8affine_epi64_epi8(A, B, C, D) ((__m128i) __builtin_ia32_vgf2p8affineqb_v16qi_mask((__v16qi)(__m128i)(B), (__v16qi)(__m128i)(C), (int)(D), (__v16qi)(__m128i) _mm_avx512_setzero_si128 (), (__mmask16)(A)))
 #endif
 #ifdef __DISABLE_GFNIAVX512VL__
 #undef __DISABLE_GFNIAVX512VL__
@@ -163,7 +163,7 @@ __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm256_maskz_gf2p8mul_epi8 (__mmask32 __A, __m256i __B, __m256i __C)
 {
   return (__m256i) __builtin_ia32_vgf2p8mulb_v32qi_mask ((__v32qi) __B,
-   (__v32qi) __C, (__v32qi) _mm256_setzero_si256 (), __A);
+   (__v32qi) __C, (__v32qi) _mm256_avx512_setzero_si256 (), __A);
 }
 #ifdef __OPTIMIZE__
 extern __inline __m256i
@@ -184,7 +184,7 @@ _mm256_maskz_gf2p8affineinv_epi64_epi8 (__mmask32 __A, __m256i __B,
 {
   return (__m256i) __builtin_ia32_vgf2p8affineinvqb_v32qi_mask ((__v32qi) __B,
           (__v32qi) __C, __D,
-          (__v32qi) _mm256_setzero_si256 (), __A);
+          (__v32qi) _mm256_avx512_setzero_si256 (), __A);
 }
 extern __inline __m256i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -203,21 +203,56 @@ _mm256_maskz_gf2p8affine_epi64_epi8 (__mmask32 __A, __m256i __B,
          __m256i __C, const int __D)
 {
   return (__m256i) __builtin_ia32_vgf2p8affineqb_v32qi_mask ((__v32qi) __B,
-  (__v32qi) __C, __D, (__v32qi)_mm256_setzero_si256 (), __A);
+  (__v32qi) __C, __D, (__v32qi)_mm256_avx512_setzero_si256 (), __A);
 }
 #else
 #define _mm256_mask_gf2p8affineinv_epi64_epi8(A, B, C, D, E) ((__m256i) __builtin_ia32_vgf2p8affineinvqb_v32qi_mask( (__v32qi)(__m256i)(C), (__v32qi)(__m256i)(D), (int)(E), (__v32qi)(__m256i)(A), (__mmask32)(B)))
-#define _mm256_maskz_gf2p8affineinv_epi64_epi8(A, B, C, D) ((__m256i) __builtin_ia32_vgf2p8affineinvqb_v32qi_mask( (__v32qi)(__m256i)(B), (__v32qi)(__m256i)(C), (int)(D), (__v32qi)(__m256i) _mm256_setzero_si256 (), (__mmask32)(A)))
+#define _mm256_maskz_gf2p8affineinv_epi64_epi8(A, B, C, D) ((__m256i) __builtin_ia32_vgf2p8affineinvqb_v32qi_mask( (__v32qi)(__m256i)(B), (__v32qi)(__m256i)(C), (int)(D), (__v32qi)(__m256i) _mm256_avx512_setzero_si256 (), (__mmask32)(A)))
 #define _mm256_mask_gf2p8affine_epi64_epi8(A, B, C, D, E) ((__m256i) __builtin_ia32_vgf2p8affineqb_v32qi_mask((__v32qi)(__m256i)(C), (__v32qi)(__m256i)(D), (int)(E), (__v32qi)(__m256i)(A), (__mmask32)(B)))
-#define _mm256_maskz_gf2p8affine_epi64_epi8(A, B, C, D) ((__m256i) __builtin_ia32_vgf2p8affineqb_v32qi_mask((__v32qi)(__m256i)(B), (__v32qi)(__m256i)(C), (int)(D), (__v32qi)(__m256i) _mm256_setzero_si256 (), (__mmask32)(A)))
+#define _mm256_maskz_gf2p8affine_epi64_epi8(A, B, C, D) ((__m256i) __builtin_ia32_vgf2p8affineqb_v32qi_mask((__v32qi)(__m256i)(B), (__v32qi)(__m256i)(C), (int)(D), (__v32qi)(__m256i) _mm256_avx512_setzero_si256 (), (__mmask32)(A)))
 #endif
 #ifdef __DISABLE_GFNIAVX512VLBW__
 #undef __DISABLE_GFNIAVX512VLBW__
 #pragma GCC pop_options
 #endif
-#if !defined(__GFNI__) || !defined(__AVX512F__) || !defined(__AVX512BW__)
+#if !defined(__GFNI__) || !defined(__EVEX512__) || !defined(__AVX512F__)
 #pragma GCC push_options
-#pragma GCC target("gfni,avx512f,avx512bw")
+#pragma GCC target("gfni,avx512f,evex512")
+#define __DISABLE_GFNIAVX512F__
+#endif
+extern __inline __m512i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm512_gf2p8mul_epi8 (__m512i __A, __m512i __B)
+{
+  return (__m512i) __builtin_ia32_vgf2p8mulb_v64qi ((__v64qi) __A,
+          (__v64qi) __B);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m512i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm512_gf2p8affineinv_epi64_epi8 (__m512i __A, __m512i __B, const int __C)
+{
+  return (__m512i) __builtin_ia32_vgf2p8affineinvqb_v64qi ((__v64qi) __A,
+          (__v64qi) __B, __C);
+}
+extern __inline __m512i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm512_gf2p8affine_epi64_epi8 (__m512i __A, __m512i __B, const int __C)
+{
+  return (__m512i) __builtin_ia32_vgf2p8affineqb_v64qi ((__v64qi) __A,
+       (__v64qi) __B, __C);
+}
+#else
+#define _mm512_gf2p8affineinv_epi64_epi8(A, B, C) ((__m512i) __builtin_ia32_vgf2p8affineinvqb_v64qi ( (__v64qi)(__m512i)(A), (__v64qi)(__m512i)(B), (int)(C)))
+#define _mm512_gf2p8affine_epi64_epi8(A, B, C) ((__m512i) __builtin_ia32_vgf2p8affineqb_v64qi ((__v64qi)(__m512i)(A), (__v64qi)(__m512i)(B), (int)(C)))
+#endif
+#ifdef __DISABLE_GFNIAVX512F__
+#undef __DISABLE_GFNIAVX512F__
+#pragma GCC pop_options
+#endif
+#if !defined(__GFNI__) || !defined(__EVEX512__) || !defined(__AVX512BW__)
+#pragma GCC push_options
+#pragma GCC target("gfni,avx512bw,evex512")
 #define __DISABLE_GFNIAVX512FBW__
 #endif
 extern __inline __m512i
@@ -235,13 +270,6 @@ _mm512_maskz_gf2p8mul_epi8 (__mmask64 __A, __m512i __B, __m512i __C)
   return (__m512i) __builtin_ia32_vgf2p8mulb_v64qi_mask ((__v64qi) __B,
    (__v64qi) __C, (__v64qi) _mm512_setzero_si512 (), __A);
 }
-extern __inline __m512i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm512_gf2p8mul_epi8 (__m512i __A, __m512i __B)
-{
-  return (__m512i) __builtin_ia32_vgf2p8mulb_v64qi ((__v64qi) __A,
-          (__v64qi) __B);
-}
 #ifdef __OPTIMIZE__
 extern __inline __m512i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
@@ -265,13 +293,6 @@ _mm512_maskz_gf2p8affineinv_epi64_epi8 (__mmask64 __A, __m512i __B,
 }
 extern __inline __m512i
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm512_gf2p8affineinv_epi64_epi8 (__m512i __A, __m512i __B, const int __C)
-{
-  return (__m512i) __builtin_ia32_vgf2p8affineinvqb_v64qi ((__v64qi) __A,
-          (__v64qi) __B, __C);
-}
-extern __inline __m512i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm512_mask_gf2p8affine_epi64_epi8 (__m512i __A, __mmask64 __B, __m512i __C,
         __m512i __D, const int __E)
 {
@@ -286,20 +307,11 @@ _mm512_maskz_gf2p8affine_epi64_epi8 (__mmask64 __A, __m512i __B, __m512i __C,
   return (__m512i) __builtin_ia32_vgf2p8affineqb_v64qi_mask ((__v64qi) __B,
     (__v64qi) __C, __D, (__v64qi) _mm512_setzero_si512 (), __A);
 }
-extern __inline __m512i
-__attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm512_gf2p8affine_epi64_epi8 (__m512i __A, __m512i __B, const int __C)
-{
-  return (__m512i) __builtin_ia32_vgf2p8affineqb_v64qi ((__v64qi) __A,
-       (__v64qi) __B, __C);
-}
 #else
 #define _mm512_mask_gf2p8affineinv_epi64_epi8(A, B, C, D, E) ((__m512i) __builtin_ia32_vgf2p8affineinvqb_v64qi_mask( (__v64qi)(__m512i)(C), (__v64qi)(__m512i)(D), (int)(E), (__v64qi)(__m512i)(A), (__mmask64)(B)))
 #define _mm512_maskz_gf2p8affineinv_epi64_epi8(A, B, C, D) ((__m512i) __builtin_ia32_vgf2p8affineinvqb_v64qi_mask( (__v64qi)(__m512i)(B), (__v64qi)(__m512i)(C), (int)(D), (__v64qi)(__m512i) _mm512_setzero_si512 (), (__mmask64)(A)))
-#define _mm512_gf2p8affineinv_epi64_epi8(A, B, C) ((__m512i) __builtin_ia32_vgf2p8affineinvqb_v64qi ( (__v64qi)(__m512i)(A), (__v64qi)(__m512i)(B), (int)(C)))
 #define _mm512_mask_gf2p8affine_epi64_epi8(A, B, C, D, E) ((__m512i) __builtin_ia32_vgf2p8affineqb_v64qi_mask((__v64qi)(__m512i)(C), (__v64qi)(__m512i)(D), (int)(E), (__v64qi)(__m512i)(A), (__mmask64)(B)))
 #define _mm512_maskz_gf2p8affine_epi64_epi8(A, B, C, D) ((__m512i) __builtin_ia32_vgf2p8affineqb_v64qi_mask((__v64qi)(__m512i)(B), (__v64qi)(__m512i)(C), (int)(D), (__v64qi)(__m512i) _mm512_setzero_si512 (), (__mmask64)(A)))
-#define _mm512_gf2p8affine_epi64_epi8(A, B, C) ((__m512i) __builtin_ia32_vgf2p8affineqb_v64qi ((__v64qi)(__m512i)(A), (__v64qi)(__m512i)(B), (int)(C)))
 #endif
 #ifdef __DISABLE_GFNIAVX512FBW__
 #undef __DISABLE_GFNIAVX512FBW__
diff --git a/third_party/intel/immintrin.internal.h b/third_party/intel/immintrin.internal.h
index a932d9755..1d02c5183 100644
--- a/third_party/intel/immintrin.internal.h
+++ b/third_party/intel/immintrin.internal.h
@@ -11,6 +11,9 @@
 #include "third_party/intel/wmmintrin.internal.h"
 #include "third_party/intel/avxintrin.internal.h"
 #include "third_party/intel/avxvnniintrin.internal.h"
+#include "third_party/intel/avxifmaintrin.internal.h"
+#include "third_party/intel/avxvnniint8intrin.internal.h"
+#include "third_party/intel/avxvnniint16intrin.internal.h"
 #include "third_party/intel/avx2intrin.internal.h"
 #include "third_party/intel/avx512fintrin.internal.h"
 #include "third_party/intel/avx512erintrin.internal.h"
@@ -34,13 +37,15 @@
 #include "third_party/intel/avx512vnnivlintrin.internal.h"
 #include "third_party/intel/avx512vpopcntdqvlintrin.internal.h"
 #include "third_party/intel/avx512bitalgintrin.internal.h"
+#include "third_party/intel/avx512bitalgvlintrin.internal.h"
 #include "third_party/intel/avx512vp2intersectintrin.internal.h"
 #include "third_party/intel/avx512vp2intersectvlintrin.internal.h"
-#ifdef __SSE2__
 #include "third_party/intel/avx512fp16intrin.internal.h"
 #include "third_party/intel/avx512fp16vlintrin.internal.h"
-#endif
 #include "third_party/intel/shaintrin.internal.h"
+#include "third_party/intel/sm3intrin.internal.h"
+#include "third_party/intel/sha512intrin.internal.h"
+#include "third_party/intel/sm4intrin.internal.h"
 #include "third_party/intel/fmaintrin.internal.h"
 #include "third_party/intel/f16cintrin.internal.h"
 #include "third_party/intel/rtmintrin.internal.h"
@@ -49,10 +54,13 @@
 #include "third_party/intel/vpclmulqdqintrin.internal.h"
 #include "third_party/intel/avx512bf16vlintrin.internal.h"
 #include "third_party/intel/avx512bf16intrin.internal.h"
+#include "third_party/intel/avxneconvertintrin.internal.h"
 #include "third_party/intel/amxtileintrin.internal.h"
 #include "third_party/intel/amxint8intrin.internal.h"
 #include "third_party/intel/amxbf16intrin.internal.h"
+#include "third_party/intel/amxcomplexintrin.internal.h"
 #include "third_party/intel/prfchwintrin.internal.h"
 #include "third_party/intel/keylockerintrin.internal.h"
+#include "third_party/intel/amxfp16intrin.internal.h"
 #endif
 #endif
diff --git a/third_party/intel/mm_malloc.internal.h b/third_party/intel/mm_malloc.internal.h
index e3b5a0423..2443d5f0b 100644
--- a/third_party/intel/mm_malloc.internal.h
+++ b/third_party/intel/mm_malloc.internal.h
@@ -3,23 +3,27 @@
 #define _MM_MALLOC_H_INCLUDED
 #include "libc/mem/mem.h"
 #ifndef __cplusplus
-extern int _mm_posix_memalign(void **, size_t, size_t)
+extern int posix_memalign (void **, size_t, size_t);
 #else
-extern "C" int _mm_posix_memalign(void **, size_t, size_t) throw()
+extern "C" int posix_memalign (void **, size_t, size_t);
 #endif
-    __asm__("posix_memalign");
-static __inline void *_mm_malloc(size_t __size, size_t __alignment) {
+static __inline void *
+_mm_malloc (size_t __size, size_t __alignment)
+{
   void *__ptr;
-  if (__alignment == 1) return malloc(__size);
-  if (__alignment == 2 || (sizeof(void *) == 8 && __alignment == 4))
-    __alignment = sizeof(void *);
-  if (_mm_posix_memalign(&__ptr, __alignment, __size) == 0)
+  if (__alignment == 1)
+    return malloc (__size);
+  if (__alignment == 2 || (sizeof (void *) == 8 && __alignment == 4))
+    __alignment = sizeof (void *);
+  if (posix_memalign (&__ptr, __alignment, __size) == 0)
     return __ptr;
   else
     return NULL;
 }
-static __inline void _mm_free(void *__ptr) {
-  free(__ptr);
+static __inline void
+_mm_free (void *__ptr)
+{
+  free (__ptr);
 }
 #endif
 #endif
diff --git a/third_party/intel/prfchiintrin.internal.h b/third_party/intel/prfchiintrin.internal.h
new file mode 100644
index 000000000..9ae2660fc
--- /dev/null
+++ b/third_party/intel/prfchiintrin.internal.h
@@ -0,0 +1,31 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#if !defined _X86GPRINTRIN_H_INCLUDED
+# error "Never use <prfchiintrin.h> directly; include <x86gprintrin.h> instead."
+#endif
+#ifndef _PRFCHIINTRIN_H_INCLUDED
+#define _PRFCHIINTRIN_H_INCLUDED
+#ifdef __x86_64__
+#ifndef __PREFETCHI__
+#pragma GCC push_options
+#pragma GCC target("prefetchi")
+#define __DISABLE_PREFETCHI__
+#endif
+extern __inline void
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_m_prefetchit0 (void* __P)
+{
+  __builtin_ia32_prefetchi (__P, 3);
+}
+extern __inline void
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_m_prefetchit1 (void* __P)
+{
+  __builtin_ia32_prefetchi (__P, 2);
+}
+#ifdef __DISABLE_PREFETCHI__
+#undef __DISABLE_PREFETCHI__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
+#endif
diff --git a/third_party/intel/raointintrin.internal.h b/third_party/intel/raointintrin.internal.h
new file mode 100644
index 000000000..9e841b16c
--- /dev/null
+++ b/third_party/intel/raointintrin.internal.h
@@ -0,0 +1,67 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#ifndef _X86GPRINTRIN_H_INCLUDED
+#error "Never use <raointintrin.h> directly; include <x86gprintrin.h> instead."
+#endif
+#ifndef __RAOINTINTRIN_H_INCLUDED
+#define __RAOINTINTRIN_H_INCLUDED
+#ifndef __RAOINT__
+#pragma GCC push_options
+#pragma GCC target("raoint")
+#define __DISABLE_RAOINT__
+#endif
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_aadd_i32 (int *__A, int __B)
+{
+  __builtin_ia32_aadd32 ((int *)__A, __B);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_aand_i32 (int *__A, int __B)
+{
+  __builtin_ia32_aand32 ((int *)__A, __B);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_aor_i32 (int *__A, int __B)
+{
+  __builtin_ia32_aor32 ((int *)__A, __B);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_axor_i32 (int *__A, int __B)
+{
+  __builtin_ia32_axor32 ((int *)__A, __B);
+}
+#ifdef __x86_64__
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_aadd_i64 (long long *__A, long long __B)
+{
+  __builtin_ia32_aadd64 ((long long *)__A, __B);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_aand_i64 (long long *__A, long long __B)
+{
+  __builtin_ia32_aand64 ((long long *)__A, __B);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_aor_i64 (long long *__A, long long __B)
+{
+  __builtin_ia32_aor64 ((long long *)__A, __B);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_axor_i64 (long long *__A, long long __B)
+{
+  __builtin_ia32_axor64 ((long long *)__A, __B);
+}
+#endif
+#ifdef __DISABLE_RAOINT__
+#undef __DISABLE_RAOINT__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/sha512intrin.internal.h b/third_party/intel/sha512intrin.internal.h
new file mode 100644
index 000000000..b233f24c4
--- /dev/null
+++ b/third_party/intel/sha512intrin.internal.h
@@ -0,0 +1,36 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#ifndef _IMMINTRIN_H_INCLUDED
+#error "Never use <sha512intrin.h> directly; include <immintrin.h> instead."
+#endif
+#ifndef _SHA512INTRIN_H_INCLUDED
+#define _SHA512INTRIN_H_INCLUDED
+#ifndef __SHA512__
+#pragma GCC push_options
+#pragma GCC target("sha512")
+#define __DISABLE_SHA512__
+#endif
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_sha512msg1_epi64 (__m256i __A, __m128i __B)
+{
+  return (__m256i) __builtin_ia32_vsha512msg1 ((__v4di) __A, (__v2di) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_sha512msg2_epi64 (__m256i __A, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_vsha512msg2 ((__v4di) __A, (__v4di) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_sha512rnds2_epi64 (__m256i __A, __m256i __B, __m128i __C)
+{
+  return (__m256i) __builtin_ia32_vsha512rnds2 ((__v4di) __A, (__v4di) __B,
+      (__v2di) __C);
+}
+#ifdef __DISABLE_SHA512__
+#undef __DISABLE_SHA512__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/sm3intrin.internal.h b/third_party/intel/sm3intrin.internal.h
new file mode 100644
index 000000000..98df61745
--- /dev/null
+++ b/third_party/intel/sm3intrin.internal.h
@@ -0,0 +1,42 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#ifndef _IMMINTRIN_H_INCLUDED
+#error "Never use <sm3intrin.h> directly; include <immintrin.h> instead."
+#endif
+#ifndef _SM3INTRIN_H_INCLUDED
+#define _SM3INTRIN_H_INCLUDED
+#ifndef __SM3__
+#pragma GCC push_options
+#pragma GCC target("sm3")
+#define __DISABLE_SM3__
+#endif
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sm3msg1_epi32 (__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i) __builtin_ia32_vsm3msg1 ((__v4si) __A, (__v4si) __B,
+         (__v4si) __C);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sm3msg2_epi32 (__m128i __A, __m128i __B, __m128i __C)
+{
+  return (__m128i) __builtin_ia32_vsm3msg2 ((__v4si) __A, (__v4si) __B,
+         (__v4si) __C);
+}
+#ifdef __OPTIMIZE__
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sm3rnds2_epi32 (__m128i __A, __m128i __B, __m128i __C, const int __D)
+{
+  return (__m128i) __builtin_ia32_vsm3rnds2 ((__v4si) __A, (__v4si) __B,
+          (__v4si) __C, __D);
+}
+#else
+#define _mm_sm3rnds2_epi32(A, B, C, D) ((__m128i) __builtin_ia32_vsm3rnds2 ((__v4si) (A), (__v4si) (B), (__v4si) (C), (int) (D)))
+#endif
+#ifdef __DISABLE_SM3__
+#undef __DISABLE_SM3__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/sm4intrin.internal.h b/third_party/intel/sm4intrin.internal.h
new file mode 100644
index 000000000..17658edd4
--- /dev/null
+++ b/third_party/intel/sm4intrin.internal.h
@@ -0,0 +1,41 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#ifndef _IMMINTRIN_H_INCLUDED
+#error "Never use <sm4intrin.h> directly; include <immintrin.h> instead."
+#endif
+#ifndef _SM4INTRIN_H_INCLUDED
+#define _SM4INTRIN_H_INCLUDED
+#ifndef __SM4__
+#pragma GCC push_options
+#pragma GCC target("sm4")
+#define __DISABLE_SM4__
+#endif
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sm4key4_epi32 (__m128i __A, __m128i __B)
+{
+  return (__m128i) __builtin_ia32_vsm4key4128 ((__v4si) __A, (__v4si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_sm4key4_epi32 (__m256i __A, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_vsm4key4256 ((__v8si) __A, (__v8si) __B);
+}
+extern __inline __m128i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm_sm4rnds4_epi32 (__m128i __A, __m128i __B)
+{
+  return (__m128i) __builtin_ia32_vsm4rnds4128 ((__v4si) __A, (__v4si) __B);
+}
+extern __inline __m256i
+__attribute__((__gnu_inline__, __always_inline__, __artificial__))
+_mm256_sm4rnds4_epi32 (__m256i __A, __m256i __B)
+{
+  return (__m256i) __builtin_ia32_vsm4rnds4256 ((__v8si) __A, (__v8si) __B);
+}
+#ifdef __DISABLE_SM4__
+#undef __DISABLE_SM4__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
diff --git a/third_party/intel/smmintrin.internal.h b/third_party/intel/smmintrin.internal.h
index 5179c6e2e..a2e28ecaf 100644
--- a/third_party/intel/smmintrin.internal.h
+++ b/third_party/intel/smmintrin.internal.h
@@ -224,12 +224,12 @@ _mm_insert_ps (__m128 __D, __m128 __S, const int __N)
 extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_extract_ps (__m128 __X, const int __N)
 {
-  union { int i; float f; } __tmp;
-  __tmp.f = __builtin_ia32_vec_ext_v4sf ((__v4sf)__X, __N);
-  return __tmp.i;
+  union { int __i; float __f; } __tmp;
+  __tmp.__f = __builtin_ia32_vec_ext_v4sf ((__v4sf)__X, __N);
+  return __tmp.__i;
 }
 #else
-#define _mm_extract_ps(X, N) (__extension__ ({ union { int i; float f; } __tmp; __tmp.f = __builtin_ia32_vec_ext_v4sf ((__v4sf)(__m128)(X), (int)(N)); __tmp.i; }))
+#define _mm_extract_ps(X, N) (__extension__ ({ union { int __i; float __f; } __tmp; __tmp.__f = __builtin_ia32_vec_ext_v4sf ((__v4sf)(__m128)(X), (int)(N)); __tmp.__i; }))
 #endif
 #define _MM_EXTRACT_FLOAT(D, S, N) { (D) = __builtin_ia32_vec_ext_v4sf ((__v4sf)(S), (N)); }
 #define _MM_PICK_OUT_PS(X, N) _mm_insert_ps (_mm_setzero_ps (), (X), _MM_MK_INSERTPS_NDX ((N), 0, 0x0e))
diff --git a/third_party/intel/upgrade.sh b/third_party/intel/upgrade.sh
index f5f32ddae..9fcd0a74f 100755
--- a/third_party/intel/upgrade.sh
+++ b/third_party/intel/upgrade.sh
@@ -7,6 +7,8 @@ FILES='
 adxintrin
 ammintrin
 amxbf16intrin
+amxcomplexintrin
+amxfp16intrin
 amxint8intrin
 amxtileintrin
 avx2intrin
@@ -15,6 +17,7 @@ avx5124vnniwintrin
 avx512bf16intrin
 avx512bf16vlintrin
 avx512bitalgintrin
+avx512bitalgvlintrin
 avx512bwintrin
 avx512cdintrin
 avx512dqintrin
@@ -38,15 +41,21 @@ avx512vp2intersectintrin
 avx512vp2intersectvlintrin
 avx512vpopcntdqintrin
 avx512vpopcntdqvlintrin
+avxifmaintrin
+avxvnniint8intrin
+avxvnniint16intrin
 avxintrin
+avxneconvertintrin
 avxvnniintrin
 bmi2intrin
+bmmintrin
 bmiintrin
 cetintrin
 cldemoteintrin
 clflushoptintrin
 clwbintrin
 clzerointrin
+cmpccxaddintrin
 cpuid
 emmintrin
 enqcmdintrin
@@ -72,17 +81,23 @@ pconfigintrin
 pkuintrin
 pmmintrin
 popcntintrin
+prfchiintrin
 prfchwintrin
+raointintrin
 rdseedintrin
 rtmintrin
 serializeintrin
 sgxintrin
+sha512intrin
 shaintrin
+sm3intrin
+sm4intrin
 smmintrin
 tbmintrin
 tmmintrin
 tsxldtrkintrin
 uintrintrin
+usermsrintrin
 vaesintrin
 vpclmulqdqintrin
 waitpkgintrin
diff --git a/third_party/intel/usermsrintrin.internal.h b/third_party/intel/usermsrintrin.internal.h
new file mode 100644
index 000000000..481e3ffe6
--- /dev/null
+++ b/third_party/intel/usermsrintrin.internal.h
@@ -0,0 +1,31 @@
+#if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
+#if !defined _X86GPRINTRIN_H_INCLUDED
+#error "Never use <usermsrintrin.h> directly; include <x86gprintrin.h> instead."
+#endif
+#ifndef _USER_MSRINTRIN_H_INCLUDED
+#define _USER_MSRINTRIN_H_INCLUDED
+#ifdef __x86_64__
+#ifndef __USER_MSR__
+#pragma GCC push_options
+#pragma GCC target("usermsr")
+#define __DISABLE_USER_MSR__
+#endif
+extern __inline unsigned long long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_urdmsr (unsigned long long __A)
+{
+  return (unsigned long long) __builtin_ia32_urdmsr (__A);
+}
+extern __inline void
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+_uwrmsr (unsigned long long __A, unsigned long long __B)
+{
+  __builtin_ia32_uwrmsr (__A, __B);
+}
+#ifdef __DISABLE_USER_MSR__
+#undef __DISABLE_USER_MSR__
+#pragma GCC pop_options
+#endif
+#endif
+#endif
+#endif
diff --git a/third_party/intel/vaesintrin.internal.h b/third_party/intel/vaesintrin.internal.h
index 6a55221af..574b40880 100644
--- a/third_party/intel/vaesintrin.internal.h
+++ b/third_party/intel/vaesintrin.internal.h
@@ -1,9 +1,9 @@
 #if defined(__x86_64__) && !(__ASSEMBLER__ + __LINKER__ + 0)
 #ifndef __VAESINTRIN_H_INCLUDED
 #define __VAESINTRIN_H_INCLUDED
-#if !defined(__VAES__) || !defined(__AVX__)
+#if !defined(__VAES__)
 #pragma GCC push_options
-#pragma GCC target("vaes,avx")
+#pragma GCC target("vaes")
 #define __DISABLE_VAES__
 #endif
 extern __inline __m256i
@@ -36,9 +36,9 @@ _mm256_aesenclast_epi128 (__m256i __A, __m256i __B)
 #undef __DISABLE_VAES__
 #pragma GCC pop_options
 #endif
-#if !defined(__VAES__) || !defined(__AVX512F__)
+#if !defined(__VAES__) || !defined(__AVX512F__) || !defined(__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("vaes,avx512f")
+#pragma GCC target("vaes,avx512f,evex512")
 #define __DISABLE_VAESF__
 #endif
 extern __inline __m512i
diff --git a/third_party/intel/vpclmulqdqintrin.internal.h b/third_party/intel/vpclmulqdqintrin.internal.h
index f2726d0e3..e1e8785d7 100644
--- a/third_party/intel/vpclmulqdqintrin.internal.h
+++ b/third_party/intel/vpclmulqdqintrin.internal.h
@@ -4,9 +4,9 @@
 #endif
 #ifndef _VPCLMULQDQINTRIN_H_INCLUDED
 #define _VPCLMULQDQINTRIN_H_INCLUDED
-#if !defined(__VPCLMULQDQ__) || !defined(__AVX512F__)
+#if !defined(__VPCLMULQDQ__) || !defined(__AVX512F__) || !defined(__EVEX512__)
 #pragma GCC push_options
-#pragma GCC target("vpclmulqdq,avx512f")
+#pragma GCC target("vpclmulqdq,avx512f,evex512")
 #define __DISABLE_VPCLMULQDQF__
 #endif
 #ifdef __OPTIMIZE__
@@ -24,9 +24,9 @@ _mm512_clmulepi64_epi128 (__m512i __A, __m512i __B, const int __C)
 #undef __DISABLE_VPCLMULQDQF__
 #pragma GCC pop_options
 #endif
-#if !defined(__VPCLMULQDQ__) || !defined(__AVX__)
+#if !defined(__VPCLMULQDQ__)
 #pragma GCC push_options
-#pragma GCC target("vpclmulqdq,avx")
+#pragma GCC target("vpclmulqdq")
 #define __DISABLE_VPCLMULQDQ__
 #endif
 #ifdef __OPTIMIZE__
diff --git a/third_party/intel/wmmintrin.internal.h b/third_party/intel/wmmintrin.internal.h
index ff5dee236..c1c3f274e 100644
--- a/third_party/intel/wmmintrin.internal.h
+++ b/third_party/intel/wmmintrin.internal.h
@@ -7,27 +7,10 @@
 #pragma GCC target("aes,sse2")
 #define __DISABLE_AES__
 #endif
-extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_aesdec_si128 (__m128i __X, __m128i __Y)
-{
-  return (__m128i) __builtin_ia32_aesdec128 ((__v2di)__X, (__v2di)__Y);
-}
-extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_aesdeclast_si128 (__m128i __X, __m128i __Y)
-{
-  return (__m128i) __builtin_ia32_aesdeclast128 ((__v2di)__X,
-       (__v2di)__Y);
-}
-extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_aesenc_si128 (__m128i __X, __m128i __Y)
-{
-  return (__m128i) __builtin_ia32_aesenc128 ((__v2di)__X, (__v2di)__Y);
-}
-extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
-_mm_aesenclast_si128 (__m128i __X, __m128i __Y)
-{
-  return (__m128i) __builtin_ia32_aesenclast128 ((__v2di)__X, (__v2di)__Y);
-}
+#define _mm_aesdec_si128(X, Y) (__m128i) __builtin_ia32_aesdec128 ((__v2di) (X), (__v2di) (Y))
+#define _mm_aesdeclast_si128(X, Y) (__m128i) __builtin_ia32_aesdeclast128 ((__v2di) (X), (__v2di) (Y))
+#define _mm_aesenc_si128(X, Y) (__m128i) __builtin_ia32_aesenc128 ((__v2di) (X), (__v2di) (Y))
+#define _mm_aesenclast_si128(X, Y) (__m128i) __builtin_ia32_aesenclast128 ((__v2di) (X), (__v2di) (Y))
 extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_aesimc_si128 (__m128i __X)
 {
diff --git a/third_party/intel/x86gprintrin.internal.h b/third_party/intel/x86gprintrin.internal.h
index 875718588..f9b3e8554 100644
--- a/third_party/intel/x86gprintrin.internal.h
+++ b/third_party/intel/x86gprintrin.internal.h
@@ -16,6 +16,7 @@
 #include "third_party/intel/clflushoptintrin.internal.h"
 #include "third_party/intel/clwbintrin.internal.h"
 #include "third_party/intel/clzerointrin.internal.h"
+#include "third_party/intel/cmpccxaddintrin.internal.h"
 #include "third_party/intel/enqcmdintrin.internal.h"
 #include "third_party/intel/fxsrintrin.internal.h"
 #include "third_party/intel/lzcntintrin.internal.h"
@@ -26,6 +27,8 @@
 #include "third_party/intel/pconfigintrin.internal.h"
 #include "third_party/intel/popcntintrin.internal.h"
 #include "third_party/intel/pkuintrin.internal.h"
+#include "third_party/intel/prfchiintrin.internal.h"
+#include "third_party/intel/raointintrin.internal.h"
 #include "third_party/intel/rdseedintrin.internal.h"
 #include "third_party/intel/rtmintrin.internal.h"
 #include "third_party/intel/serializeintrin.internal.h"
@@ -41,6 +44,7 @@
 #include "third_party/intel/xsavesintrin.internal.h"
 #include "third_party/intel/xtestintrin.internal.h"
 #include "third_party/intel/hresetintrin.internal.h"
+#include "third_party/intel/usermsrintrin.internal.h"
 extern __inline void
 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _wbinvd (void)
diff --git a/third_party/intel/xmmintrin.internal.h b/third_party/intel/xmmintrin.internal.h
index 3a97b9fa1..65e42bc5e 100644
--- a/third_party/intel/xmmintrin.internal.h
+++ b/third_party/intel/xmmintrin.internal.h
@@ -5,6 +5,8 @@
 #include "third_party/intel/mm_malloc.internal.h"
 enum _mm_hint
 {
+  _MM_HINT_IT0 = 19,
+  _MM_HINT_IT1 = 18,
   _MM_HINT_ET0 = 7,
   _MM_HINT_ET1 = 6,
   _MM_HINT_T0 = 3,
@@ -16,10 +18,11 @@ enum _mm_hint
 extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_prefetch (const void *__P, enum _mm_hint __I)
 {
-  __builtin_prefetch (__P, (__I & 0x4) >> 2, __I & 0x3);
+  __builtin_ia32_prefetch (__P, (__I & 0x4) >> 2,
+      __I & 0x3, (__I & 0x10) >> 4);
 }
 #else
-#define _mm_prefetch(P, I) __builtin_prefetch ((P), ((I & 0x4) >> 2), (I & 0x3))
+#define _mm_prefetch(P, I) __builtin_ia32_prefetch ((P), ((I) & 0x4) >> 2, ((I) & 0x3), ((I) & 0x10) >> 4)
 #endif
 #ifndef __SSE__
 #pragma GCC push_options
@@ -55,7 +58,10 @@ typedef float __v4sf __attribute__ ((__vector_size__ (16)));
 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
 _mm_undefined_ps (void)
 {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winit-self"
   __m128 __Y = __Y;
+#pragma GCC diagnostic pop
   return __Y;
 }
 extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
diff --git a/third_party/less/BUILD.mk b/third_party/less/BUILD.mk
index 2a0ddd0ff..45990d4ed 100644
--- a/third_party/less/BUILD.mk
+++ b/third_party/less/BUILD.mk
@@ -26,9 +26,11 @@ THIRD_PARTY_LESS_DIRECTDEPS =				\
 	LIBC_RUNTIME					\
 	LIBC_STDIO					\
 	LIBC_STR					\
+	LIBC_SYSTEM					\
 	LIBC_SYSV					\
+	THIRD_PARTY_MUSL				\
 	THIRD_PARTY_NCURSES				\
-	THIRD_PARTY_PCRE
+	THIRD_PARTY_PCRE				\
 
 THIRD_PARTY_LESS_DEPS :=				\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_LESS_DIRECTDEPS),$($(x))))
diff --git a/third_party/libcxx/BUILD.mk b/third_party/libcxx/BUILD.mk
index e45f701f1..e33b96ee2 100644
--- a/third_party/libcxx/BUILD.mk
+++ b/third_party/libcxx/BUILD.mk
@@ -8,6 +8,7 @@ THIRD_PARTY_LIBCXX = $(THIRD_PARTY_LIBCXX_A_DEPS) $(THIRD_PARTY_LIBCXX_A)
 THIRD_PARTY_LIBCXX_A = o/$(MODE)/third_party/libcxx/libcxx.a
 
 THIRD_PARTY_LIBCXX_A_HDRS = \
+third_party/libcxx/__assertion_handler \
 third_party/libcxx/__algorithm/adjacent_find.h \
 third_party/libcxx/__algorithm/all_of.h \
 third_party/libcxx/__algorithm/any_of.h \
@@ -31,6 +32,8 @@ third_party/libcxx/__algorithm/find_end.h \
 third_party/libcxx/__algorithm/find_first_of.h \
 third_party/libcxx/__algorithm/find_if.h \
 third_party/libcxx/__algorithm/find_if_not.h \
+third_party/libcxx/__algorithm/find_segment_if.h \
+third_party/libcxx/__algorithm/fold.h \
 third_party/libcxx/__algorithm/for_each.h \
 third_party/libcxx/__algorithm/for_each_n.h \
 third_party/libcxx/__algorithm/for_each_segment.h \
@@ -79,18 +82,22 @@ third_party/libcxx/__algorithm/partition_copy.h \
 third_party/libcxx/__algorithm/partition_point.h \
 third_party/libcxx/__algorithm/pop_heap.h \
 third_party/libcxx/__algorithm/prev_permutation.h \
+third_party/libcxx/__algorithm/pstl.h \
 third_party/libcxx/__algorithm/push_heap.h \
 third_party/libcxx/__algorithm/ranges_adjacent_find.h \
 third_party/libcxx/__algorithm/ranges_all_of.h \
 third_party/libcxx/__algorithm/ranges_any_of.h \
 third_party/libcxx/__algorithm/ranges_binary_search.h \
 third_party/libcxx/__algorithm/ranges_clamp.h \
+third_party/libcxx/__algorithm/ranges_contains.h \
+third_party/libcxx/__algorithm/ranges_contains_subrange.h \
 third_party/libcxx/__algorithm/ranges_copy.h \
 third_party/libcxx/__algorithm/ranges_copy_backward.h \
 third_party/libcxx/__algorithm/ranges_copy_if.h \
 third_party/libcxx/__algorithm/ranges_copy_n.h \
 third_party/libcxx/__algorithm/ranges_count.h \
 third_party/libcxx/__algorithm/ranges_count_if.h \
+third_party/libcxx/__algorithm/ranges_ends_with.h \
 third_party/libcxx/__algorithm/ranges_equal.h \
 third_party/libcxx/__algorithm/ranges_equal_range.h \
 third_party/libcxx/__algorithm/ranges_fill.h \
@@ -100,6 +107,7 @@ third_party/libcxx/__algorithm/ranges_find_end.h \
 third_party/libcxx/__algorithm/ranges_find_first_of.h \
 third_party/libcxx/__algorithm/ranges_find_if.h \
 third_party/libcxx/__algorithm/ranges_find_if_not.h \
+third_party/libcxx/__algorithm/ranges_find_last.h \
 third_party/libcxx/__algorithm/ranges_for_each.h \
 third_party/libcxx/__algorithm/ranges_for_each_n.h \
 third_party/libcxx/__algorithm/ranges_generate.h \
@@ -190,6 +198,7 @@ third_party/libcxx/__algorithm/shift_left.h \
 third_party/libcxx/__algorithm/shift_right.h \
 third_party/libcxx/__algorithm/shuffle.h \
 third_party/libcxx/__algorithm/sift_down.h \
+third_party/libcxx/__algorithm/simd_utils.h \
 third_party/libcxx/__algorithm/sort.h \
 third_party/libcxx/__algorithm/sort_heap.h \
 third_party/libcxx/__algorithm/stable_partition.h \
@@ -210,6 +219,7 @@ third_party/libcxx/__atomic/atomic_base.h \
 third_party/libcxx/__atomic/atomic_flag.h \
 third_party/libcxx/__atomic/atomic_init.h \
 third_party/libcxx/__atomic/atomic_lock_free.h \
+third_party/libcxx/__atomic/atomic_ref.h \
 third_party/libcxx/__atomic/atomic_sync.h \
 third_party/libcxx/__atomic/check_memory_order.h \
 third_party/libcxx/__atomic/contention_t.h \
@@ -218,7 +228,7 @@ third_party/libcxx/__atomic/fence.h \
 third_party/libcxx/__atomic/is_always_lock_free.h \
 third_party/libcxx/__atomic/kill_dependency.h \
 third_party/libcxx/__atomic/memory_order.h \
-third_party/libcxx/__availability \
+third_party/libcxx/__atomic/to_gcc_order.h \
 third_party/libcxx/__bit/bit_cast.h \
 third_party/libcxx/__bit/bit_ceil.h \
 third_party/libcxx/__bit/bit_floor.h \
@@ -230,6 +240,7 @@ third_party/libcxx/__bit/countl.h \
 third_party/libcxx/__bit/countr.h \
 third_party/libcxx/__bit/endian.h \
 third_party/libcxx/__bit/has_single_bit.h \
+third_party/libcxx/__bit/invert_if.h \
 third_party/libcxx/__bit/popcount.h \
 third_party/libcxx/__bit/rotate.h \
 third_party/libcxx/__bit_reference \
@@ -249,11 +260,14 @@ third_party/libcxx/__chrono/convert_to_timespec.h \
 third_party/libcxx/__chrono/convert_to_tm.h \
 third_party/libcxx/__chrono/day.h \
 third_party/libcxx/__chrono/duration.h \
+third_party/libcxx/__chrono/exception.h \
 third_party/libcxx/__chrono/file_clock.h \
 third_party/libcxx/__chrono/formatter.h \
 third_party/libcxx/__chrono/hh_mm_ss.h \
 third_party/libcxx/__chrono/high_resolution_clock.h \
+third_party/libcxx/__chrono/leap_second.h \
 third_party/libcxx/__chrono/literals.h \
+third_party/libcxx/__chrono/local_info.h \
 third_party/libcxx/__chrono/month.h \
 third_party/libcxx/__chrono/month_weekday.h \
 third_party/libcxx/__chrono/monthday.h \
@@ -261,13 +275,19 @@ third_party/libcxx/__chrono/ostream.h \
 third_party/libcxx/__chrono/parser_std_format_spec.h \
 third_party/libcxx/__chrono/statically_widen.h \
 third_party/libcxx/__chrono/steady_clock.h \
+third_party/libcxx/__chrono/sys_info.h \
 third_party/libcxx/__chrono/system_clock.h \
 third_party/libcxx/__chrono/time_point.h \
+third_party/libcxx/__chrono/time_zone.h \
+third_party/libcxx/__chrono/time_zone_link.h \
+third_party/libcxx/__chrono/tzdb.h \
+third_party/libcxx/__chrono/tzdb_list.h \
 third_party/libcxx/__chrono/weekday.h \
 third_party/libcxx/__chrono/year.h \
 third_party/libcxx/__chrono/year_month.h \
 third_party/libcxx/__chrono/year_month_day.h \
 third_party/libcxx/__chrono/year_month_weekday.h \
+third_party/libcxx/__chrono/zoned_time.h \
 third_party/libcxx/__compare/common_comparison_category.h \
 third_party/libcxx/__compare/compare_partial_order_fallback.h \
 third_party/libcxx/__compare/compare_strong_order_fallback.h \
@@ -306,12 +326,18 @@ third_party/libcxx/__concepts/totally_ordered.h \
 third_party/libcxx/__condition_variable/condition_variable.h \
 third_party/libcxx/__config \
 third_party/libcxx/__config_site \
+third_party/libcxx/__configuration/abi.h \
+third_party/libcxx/__configuration/availability.h \
+third_party/libcxx/__configuration/compiler.h \
+third_party/libcxx/__configuration/language.h \
+third_party/libcxx/__configuration/platform.h \
 third_party/libcxx/__coroutine/coroutine_handle.h \
 third_party/libcxx/__coroutine/coroutine_traits.h \
 third_party/libcxx/__coroutine/noop_coroutine_handle.h \
 third_party/libcxx/__coroutine/trivial_awaitables.h \
-third_party/libcxx/__debug \
 third_party/libcxx/__debug_utils/randomize_range.h \
+third_party/libcxx/__debug_utils/sanitizers.h \
+third_party/libcxx/__debug_utils/strict_weak_ordering_check.h \
 third_party/libcxx/__exception/exception.h \
 third_party/libcxx/__exception/exception_ptr.h \
 third_party/libcxx/__exception/nested_exception.h \
@@ -349,7 +375,6 @@ third_party/libcxx/__format/format_args.h \
 third_party/libcxx/__format/format_context.h \
 third_party/libcxx/__format/format_error.h \
 third_party/libcxx/__format/format_functions.h \
-third_party/libcxx/__format/format_fwd.h \
 third_party/libcxx/__format/format_parse_context.h \
 third_party/libcxx/__format/format_string.h \
 third_party/libcxx/__format/format_to_n_result.h \
@@ -363,11 +388,13 @@ third_party/libcxx/__format/formatter_output.h \
 third_party/libcxx/__format/formatter_pointer.h \
 third_party/libcxx/__format/formatter_string.h \
 third_party/libcxx/__format/formatter_tuple.h \
+third_party/libcxx/__format/indic_conjunct_break_table.h \
 third_party/libcxx/__format/parser_std_format_spec.h \
 third_party/libcxx/__format/range_default_formatter.h \
 third_party/libcxx/__format/range_formatter.h \
 third_party/libcxx/__format/unicode.h \
 third_party/libcxx/__format/width_estimation_table.h \
+third_party/libcxx/__format/write_escaped.h \
 third_party/libcxx/__functional/binary_function.h \
 third_party/libcxx/__functional/binary_negate.h \
 third_party/libcxx/__functional/bind.h \
@@ -396,30 +423,40 @@ third_party/libcxx/__functional/unary_function.h \
 third_party/libcxx/__functional/unary_negate.h \
 third_party/libcxx/__functional/weak_result_type.h \
 third_party/libcxx/__fwd/array.h \
+third_party/libcxx/__fwd/bit_reference.h \
+third_party/libcxx/__fwd/complex.h \
+third_party/libcxx/__fwd/deque.h \
+third_party/libcxx/__fwd/format.h \
 third_party/libcxx/__fwd/fstream.h \
-third_party/libcxx/__fwd/get.h \
-third_party/libcxx/__fwd/hash.h \
+third_party/libcxx/__fwd/functional.h \
 third_party/libcxx/__fwd/ios.h \
 third_party/libcxx/__fwd/istream.h \
+third_party/libcxx/__fwd/mdspan.h \
+third_party/libcxx/__fwd/memory.h \
 third_party/libcxx/__fwd/memory_resource.h \
 third_party/libcxx/__fwd/ostream.h \
 third_party/libcxx/__fwd/pair.h \
+third_party/libcxx/__fwd/queue.h \
 third_party/libcxx/__fwd/span.h \
 third_party/libcxx/__fwd/sstream.h \
+third_party/libcxx/__fwd/stack.h \
 third_party/libcxx/__fwd/streambuf.h \
 third_party/libcxx/__fwd/string.h \
 third_party/libcxx/__fwd/string_view.h \
 third_party/libcxx/__fwd/subrange.h \
 third_party/libcxx/__fwd/tuple.h \
+third_party/libcxx/__fwd/vector.h \
 third_party/libcxx/__hash_table \
 third_party/libcxx/__ios/fpos.h \
 third_party/libcxx/__iterator/access.h \
 third_party/libcxx/__iterator/advance.h \
+third_party/libcxx/__iterator/aliasing_iterator.h \
 third_party/libcxx/__iterator/back_insert_iterator.h \
 third_party/libcxx/__iterator/bounded_iter.h \
 third_party/libcxx/__iterator/common_iterator.h \
 third_party/libcxx/__iterator/concepts.h \
 third_party/libcxx/__iterator/counted_iterator.h \
+third_party/libcxx/__iterator/cpp17_iterator_concepts.h \
 third_party/libcxx/__iterator/data.h \
 third_party/libcxx/__iterator/default_sentinel.h \
 third_party/libcxx/__iterator/distance.h \
@@ -445,6 +482,7 @@ third_party/libcxx/__iterator/ostreambuf_iterator.h \
 third_party/libcxx/__iterator/permutable.h \
 third_party/libcxx/__iterator/prev.h \
 third_party/libcxx/__iterator/projected.h \
+third_party/libcxx/__iterator/ranges_iterator_traits.h \
 third_party/libcxx/__iterator/readable_traits.h \
 third_party/libcxx/__iterator/reverse_access.h \
 third_party/libcxx/__iterator/reverse_iterator.h \
@@ -454,7 +492,37 @@ third_party/libcxx/__iterator/sortable.h \
 third_party/libcxx/__iterator/unreachable_sentinel.h \
 third_party/libcxx/__iterator/wrap_iter.h \
 third_party/libcxx/__locale \
+third_party/libcxx/__locale_dir/locale_base_api.h \
+third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_defaults.h \
+third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_fallbacks.h \
+third_party/libcxx/__locale_dir/locale_base_api/locale_guard.h \
+third_party/libcxx/__math/abs.h \
+third_party/libcxx/__math/copysign.h \
+third_party/libcxx/__math/error_functions.h \
+third_party/libcxx/__math/exponential_functions.h \
+third_party/libcxx/__math/fdim.h \
+third_party/libcxx/__math/fma.h \
+third_party/libcxx/__math/gamma.h \
+third_party/libcxx/__math/hyperbolic_functions.h \
+third_party/libcxx/__math/hypot.h \
+third_party/libcxx/__math/inverse_hyperbolic_functions.h \
+third_party/libcxx/__math/inverse_trigonometric_functions.h \
+third_party/libcxx/__math/logarithms.h \
+third_party/libcxx/__math/min_max.h \
+third_party/libcxx/__math/modulo.h \
+third_party/libcxx/__math/remainder.h \
+third_party/libcxx/__math/roots.h \
+third_party/libcxx/__math/rounding_functions.h \
+third_party/libcxx/__math/special_functions.h \
+third_party/libcxx/__math/traits.h \
+third_party/libcxx/__math/trigonometric_functions.h \
+third_party/libcxx/__mbstate_t.h \
+third_party/libcxx/__mdspan/default_accessor.h \
 third_party/libcxx/__mdspan/extents.h \
+third_party/libcxx/__mdspan/layout_left.h \
+third_party/libcxx/__mdspan/layout_right.h \
+third_party/libcxx/__mdspan/layout_stride.h \
+third_party/libcxx/__mdspan/mdspan.h \
 third_party/libcxx/__memory/addressof.h \
 third_party/libcxx/__memory/align.h \
 third_party/libcxx/__memory/aligned_alloc.h \
@@ -471,6 +539,8 @@ third_party/libcxx/__memory/compressed_pair.h \
 third_party/libcxx/__memory/concepts.h \
 third_party/libcxx/__memory/construct_at.h \
 third_party/libcxx/__memory/destruct_n.h \
+third_party/libcxx/__memory/inout_ptr.h \
+third_party/libcxx/__memory/out_ptr.h \
 third_party/libcxx/__memory/pointer_traits.h \
 third_party/libcxx/__memory/ranges_construct_at.h \
 third_party/libcxx/__memory/ranges_uninitialized_algorithms.h \
@@ -492,6 +562,7 @@ third_party/libcxx/__memory_resource/synchronized_pool_resource.h \
 third_party/libcxx/__memory_resource/unsynchronized_pool_resource.h \
 third_party/libcxx/__mutex/lock_guard.h \
 third_party/libcxx/__mutex/mutex.h \
+third_party/libcxx/__mutex/once_flag.h \
 third_party/libcxx/__mutex/tag_types.h \
 third_party/libcxx/__mutex/unique_lock.h \
 third_party/libcxx/__node_handle \
@@ -504,10 +575,31 @@ third_party/libcxx/__numeric/inner_product.h \
 third_party/libcxx/__numeric/iota.h \
 third_party/libcxx/__numeric/midpoint.h \
 third_party/libcxx/__numeric/partial_sum.h \
+third_party/libcxx/__numeric/pstl.h \
 third_party/libcxx/__numeric/reduce.h \
+third_party/libcxx/__numeric/saturation_arithmetic.h \
 third_party/libcxx/__numeric/transform_exclusive_scan.h \
 third_party/libcxx/__numeric/transform_inclusive_scan.h \
 third_party/libcxx/__numeric/transform_reduce.h \
+third_party/libcxx/__ostream/basic_ostream.h \
+third_party/libcxx/__ostream/print.h \
+third_party/libcxx/__pstl/backend.h \
+third_party/libcxx/__pstl/backend_fwd.h \
+third_party/libcxx/__pstl/backends/default.h \
+third_party/libcxx/__pstl/backends/libdispatch.h \
+third_party/libcxx/__pstl/backends/serial.h \
+third_party/libcxx/__pstl/backends/std_thread.h \
+third_party/libcxx/__pstl/cpu_algos/any_of.h \
+third_party/libcxx/__pstl/cpu_algos/cpu_traits.h \
+third_party/libcxx/__pstl/cpu_algos/fill.h \
+third_party/libcxx/__pstl/cpu_algos/find_if.h \
+third_party/libcxx/__pstl/cpu_algos/for_each.h \
+third_party/libcxx/__pstl/cpu_algos/merge.h \
+third_party/libcxx/__pstl/cpu_algos/stable_sort.h \
+third_party/libcxx/__pstl/cpu_algos/transform.h \
+third_party/libcxx/__pstl/cpu_algos/transform_reduce.h \
+third_party/libcxx/__pstl/dispatch.h \
+third_party/libcxx/__pstl/handle_exception.h \
 third_party/libcxx/__random/bernoulli_distribution.h \
 third_party/libcxx/__random/binomial_distribution.h \
 third_party/libcxx/__random/cauchy_distribution.h \
@@ -548,10 +640,10 @@ third_party/libcxx/__random/weibull_distribution.h \
 third_party/libcxx/__ranges/access.h \
 third_party/libcxx/__ranges/all.h \
 third_party/libcxx/__ranges/as_rvalue_view.h \
+third_party/libcxx/__ranges/chunk_by_view.h \
 third_party/libcxx/__ranges/common_view.h \
 third_party/libcxx/__ranges/concepts.h \
 third_party/libcxx/__ranges/container_compatible_range.h \
-third_party/libcxx/__ranges/copyable_box.h \
 third_party/libcxx/__ranges/counted.h \
 third_party/libcxx/__ranges/dangling.h \
 third_party/libcxx/__ranges/data.h \
@@ -568,12 +660,14 @@ third_party/libcxx/__ranges/iota_view.h \
 third_party/libcxx/__ranges/istream_view.h \
 third_party/libcxx/__ranges/join_view.h \
 third_party/libcxx/__ranges/lazy_split_view.h \
+third_party/libcxx/__ranges/movable_box.h \
 third_party/libcxx/__ranges/non_propagating_cache.h \
 third_party/libcxx/__ranges/owning_view.h \
 third_party/libcxx/__ranges/range_adaptor.h \
 third_party/libcxx/__ranges/rbegin.h \
 third_party/libcxx/__ranges/ref_view.h \
 third_party/libcxx/__ranges/rend.h \
+third_party/libcxx/__ranges/repeat_view.h \
 third_party/libcxx/__ranges/reverse_view.h \
 third_party/libcxx/__ranges/single_view.h \
 third_party/libcxx/__ranges/size.h \
@@ -581,6 +675,7 @@ third_party/libcxx/__ranges/split_view.h \
 third_party/libcxx/__ranges/subrange.h \
 third_party/libcxx/__ranges/take_view.h \
 third_party/libcxx/__ranges/take_while_view.h \
+third_party/libcxx/__ranges/to.h \
 third_party/libcxx/__ranges/transform_view.h \
 third_party/libcxx/__ranges/view_interface.h \
 third_party/libcxx/__ranges/views.h \
@@ -590,25 +685,40 @@ third_party/libcxx/__std_mbstate_t.h \
 third_party/libcxx/__stop_token/atomic_unique_lock.h \
 third_party/libcxx/__stop_token/intrusive_list_view.h \
 third_party/libcxx/__stop_token/intrusive_shared_ptr.h \
+third_party/libcxx/__stop_token/stop_callback.h \
+third_party/libcxx/__stop_token/stop_source.h \
+third_party/libcxx/__stop_token/stop_state.h \
+third_party/libcxx/__stop_token/stop_token.h \
 third_party/libcxx/__string/char_traits.h \
 third_party/libcxx/__string/constexpr_c_functions.h \
 third_party/libcxx/__string/extern_template_lists.h \
+third_party/libcxx/__support/xlocale/__nop_locale_mgmt.h \
+third_party/libcxx/__support/xlocale/__posix_l_fallback.h \
+third_party/libcxx/__support/xlocale/__strtonum_fallback.h \
 third_party/libcxx/__system_error/errc.h \
 third_party/libcxx/__system_error/error_category.h \
 third_party/libcxx/__system_error/error_code.h \
 third_party/libcxx/__system_error/error_condition.h \
 third_party/libcxx/__system_error/system_error.h \
+third_party/libcxx/__thread/formatter.h \
+third_party/libcxx/__thread/id.h \
+third_party/libcxx/__thread/jthread.h \
 third_party/libcxx/__thread/poll_with_backoff.h \
+third_party/libcxx/__thread/support.h \
+third_party/libcxx/__thread/support/pthread.h \
+third_party/libcxx/__thread/this_thread.h \
+third_party/libcxx/__thread/thread.h \
 third_party/libcxx/__thread/timed_backoff_policy.h \
-third_party/libcxx/__threading_support \
 third_party/libcxx/__tree \
+third_party/libcxx/__tuple/find_index.h \
+third_party/libcxx/__tuple/ignore.h \
 third_party/libcxx/__tuple/make_tuple_types.h \
-third_party/libcxx/__tuple/pair_like.h \
 third_party/libcxx/__tuple/sfinae_helpers.h \
 third_party/libcxx/__tuple/tuple_element.h \
 third_party/libcxx/__tuple/tuple_indices.h \
 third_party/libcxx/__tuple/tuple_like.h \
 third_party/libcxx/__tuple/tuple_like_ext.h \
+third_party/libcxx/__tuple/tuple_like_no_subrange.h \
 third_party/libcxx/__tuple/tuple_size.h \
 third_party/libcxx/__tuple/tuple_types.h \
 third_party/libcxx/__type_traits/add_const.h \
@@ -620,7 +730,6 @@ third_party/libcxx/__type_traits/add_volatile.h \
 third_party/libcxx/__type_traits/aligned_storage.h \
 third_party/libcxx/__type_traits/aligned_union.h \
 third_party/libcxx/__type_traits/alignment_of.h \
-third_party/libcxx/__type_traits/apply_cv.h \
 third_party/libcxx/__type_traits/can_extract_key.h \
 third_party/libcxx/__type_traits/common_reference.h \
 third_party/libcxx/__type_traits/common_type.h \
@@ -628,8 +737,10 @@ third_party/libcxx/__type_traits/conditional.h \
 third_party/libcxx/__type_traits/conjunction.h \
 third_party/libcxx/__type_traits/copy_cv.h \
 third_party/libcxx/__type_traits/copy_cvref.h \
+third_party/libcxx/__type_traits/datasizeof.h \
 third_party/libcxx/__type_traits/decay.h \
 third_party/libcxx/__type_traits/dependent_type.h \
+third_party/libcxx/__type_traits/desugars_to.h \
 third_party/libcxx/__type_traits/disjunction.h \
 third_party/libcxx/__type_traits/enable_if.h \
 third_party/libcxx/__type_traits/extent.h \
@@ -654,10 +765,7 @@ third_party/libcxx/__type_traits/is_const.h \
 third_party/libcxx/__type_traits/is_constant_evaluated.h \
 third_party/libcxx/__type_traits/is_constructible.h \
 third_party/libcxx/__type_traits/is_convertible.h \
-third_party/libcxx/__type_traits/is_copy_assignable.h \
-third_party/libcxx/__type_traits/is_copy_constructible.h \
 third_party/libcxx/__type_traits/is_core_convertible.h \
-third_party/libcxx/__type_traits/is_default_constructible.h \
 third_party/libcxx/__type_traits/is_destructible.h \
 third_party/libcxx/__type_traits/is_empty.h \
 third_party/libcxx/__type_traits/is_enum.h \
@@ -670,20 +778,11 @@ third_party/libcxx/__type_traits/is_fundamental.h \
 third_party/libcxx/__type_traits/is_implicitly_default_constructible.h \
 third_party/libcxx/__type_traits/is_integral.h \
 third_party/libcxx/__type_traits/is_literal_type.h \
-third_party/libcxx/__type_traits/is_member_function_pointer.h \
-third_party/libcxx/__type_traits/is_member_object_pointer.h \
 third_party/libcxx/__type_traits/is_member_pointer.h \
-third_party/libcxx/__type_traits/is_move_assignable.h \
-third_party/libcxx/__type_traits/is_move_constructible.h \
 third_party/libcxx/__type_traits/is_nothrow_assignable.h \
 third_party/libcxx/__type_traits/is_nothrow_constructible.h \
 third_party/libcxx/__type_traits/is_nothrow_convertible.h \
-third_party/libcxx/__type_traits/is_nothrow_copy_assignable.h \
-third_party/libcxx/__type_traits/is_nothrow_copy_constructible.h \
-third_party/libcxx/__type_traits/is_nothrow_default_constructible.h \
 third_party/libcxx/__type_traits/is_nothrow_destructible.h \
-third_party/libcxx/__type_traits/is_nothrow_move_assignable.h \
-third_party/libcxx/__type_traits/is_nothrow_move_constructible.h \
 third_party/libcxx/__type_traits/is_null_pointer.h \
 third_party/libcxx/__type_traits/is_object.h \
 third_party/libcxx/__type_traits/is_pod.h \
@@ -695,7 +794,6 @@ third_party/libcxx/__type_traits/is_reference_wrapper.h \
 third_party/libcxx/__type_traits/is_referenceable.h \
 third_party/libcxx/__type_traits/is_same.h \
 third_party/libcxx/__type_traits/is_scalar.h \
-third_party/libcxx/__type_traits/is_scoped_enum.h \
 third_party/libcxx/__type_traits/is_signed.h \
 third_party/libcxx/__type_traits/is_signed_integer.h \
 third_party/libcxx/__type_traits/is_specialization.h \
@@ -704,14 +802,10 @@ third_party/libcxx/__type_traits/is_swappable.h \
 third_party/libcxx/__type_traits/is_trivial.h \
 third_party/libcxx/__type_traits/is_trivially_assignable.h \
 third_party/libcxx/__type_traits/is_trivially_constructible.h \
-third_party/libcxx/__type_traits/is_trivially_copy_assignable.h \
-third_party/libcxx/__type_traits/is_trivially_copy_constructible.h \
 third_party/libcxx/__type_traits/is_trivially_copyable.h \
-third_party/libcxx/__type_traits/is_trivially_default_constructible.h \
 third_party/libcxx/__type_traits/is_trivially_destructible.h \
 third_party/libcxx/__type_traits/is_trivially_lexicographically_comparable.h \
-third_party/libcxx/__type_traits/is_trivially_move_assignable.h \
-third_party/libcxx/__type_traits/is_trivially_move_constructible.h \
+third_party/libcxx/__type_traits/is_trivially_relocatable.h \
 third_party/libcxx/__type_traits/is_unbounded_array.h \
 third_party/libcxx/__type_traits/is_union.h \
 third_party/libcxx/__type_traits/is_unsigned.h \
@@ -728,7 +822,6 @@ third_party/libcxx/__type_traits/maybe_const.h \
 third_party/libcxx/__type_traits/nat.h \
 third_party/libcxx/__type_traits/negation.h \
 third_party/libcxx/__type_traits/noexcept_move_assign_container.h \
-third_party/libcxx/__type_traits/predicate_traits.h \
 third_party/libcxx/__type_traits/promote.h \
 third_party/libcxx/__type_traits/rank.h \
 third_party/libcxx/__type_traits/remove_all_extents.h \
@@ -749,23 +842,29 @@ third_party/libcxx/__type_traits/unwrap_ref.h \
 third_party/libcxx/__type_traits/void_t.h \
 third_party/libcxx/__undef_macros \
 third_party/libcxx/__utility/as_const.h \
+third_party/libcxx/__utility/as_lvalue.h \
 third_party/libcxx/__utility/auto_cast.h \
 third_party/libcxx/__utility/cmp.h \
 third_party/libcxx/__utility/convert_to_integral.h \
 third_party/libcxx/__utility/declval.h \
+third_party/libcxx/__utility/empty.h \
 third_party/libcxx/__utility/exception_guard.h \
 third_party/libcxx/__utility/exchange.h \
 third_party/libcxx/__utility/forward.h \
 third_party/libcxx/__utility/forward_like.h \
 third_party/libcxx/__utility/in_place.h \
 third_party/libcxx/__utility/integer_sequence.h \
+third_party/libcxx/__utility/is_pointer_in_range.h \
+third_party/libcxx/__utility/is_valid_range.h \
 third_party/libcxx/__utility/move.h \
+third_party/libcxx/__utility/no_destroy.h \
 third_party/libcxx/__utility/pair.h \
 third_party/libcxx/__utility/piecewise_construct.h \
 third_party/libcxx/__utility/priority_tag.h \
+third_party/libcxx/__utility/private_constructor_tag.h \
 third_party/libcxx/__utility/rel_ops.h \
+third_party/libcxx/__utility/small_buffer.h \
 third_party/libcxx/__utility/swap.h \
-third_party/libcxx/__utility/terminate_on_exception.h \
 third_party/libcxx/__utility/to_underlying.h \
 third_party/libcxx/__utility/unreachable.h \
 third_party/libcxx/__variant/monostate.h \
@@ -793,6 +892,1099 @@ third_party/libcxx/cmath \
 third_party/libcxx/codecvt \
 third_party/libcxx/compare \
 third_party/libcxx/complex \
+third_party/libcxx/complex.h \
+third_party/libcxx/concepts \
+third_party/libcxx/condition_variable \
+third_party/libcxx/coroutine \
+third_party/libcxx/csetjmp \
+third_party/libcxx/csignal \
+third_party/libcxx/cstdarg \
+third_party/libcxx/cstdbool \
+third_party/libcxx/cstddef \
+third_party/libcxx/cstdint \
+third_party/libcxx/cstdio \
+third_party/libcxx/cstdlib \
+third_party/libcxx/cstring \
+third_party/libcxx/ctgmath \
+third_party/libcxx/ctime \
+third_party/libcxx/ctype.h \
+third_party/libcxx/cuchar \
+third_party/libcxx/cwchar \
+third_party/libcxx/cwctype \
+third_party/libcxx/deque \
+third_party/libcxx/errno.h \
+third_party/libcxx/exception \
+third_party/libcxx/execution \
+third_party/libcxx/expected \
+third_party/libcxx/experimental/__config \
+third_party/libcxx/experimental/__simd/aligned_tag.h \
+third_party/libcxx/experimental/__simd/declaration.h \
+third_party/libcxx/experimental/__simd/reference.h \
+third_party/libcxx/experimental/__simd/scalar.h \
+third_party/libcxx/experimental/__simd/simd.h \
+third_party/libcxx/experimental/__simd/simd_mask.h \
+third_party/libcxx/experimental/__simd/traits.h \
+third_party/libcxx/experimental/__simd/utility.h \
+third_party/libcxx/experimental/__simd/vec_ext.h \
+third_party/libcxx/experimental/iterator \
+third_party/libcxx/experimental/memory \
+third_party/libcxx/experimental/propagate_const \
+third_party/libcxx/experimental/simd \
+third_party/libcxx/experimental/type_traits \
+third_party/libcxx/experimental/utility \
+third_party/libcxx/ext/__hash \
+third_party/libcxx/ext/hash_map \
+third_party/libcxx/ext/hash_set \
+third_party/libcxx/fenv.h \
+third_party/libcxx/filesystem \
+third_party/libcxx/float.h \
+third_party/libcxx/format \
+third_party/libcxx/forward_list \
+third_party/libcxx/fstream \
+third_party/libcxx/functional \
+third_party/libcxx/future \
+third_party/libcxx/initializer_list \
+third_party/libcxx/inttypes.h \
+third_party/libcxx/iomanip \
+third_party/libcxx/ios \
+third_party/libcxx/iosfwd \
+third_party/libcxx/iostream \
+third_party/libcxx/istream \
+third_party/libcxx/iterator \
+third_party/libcxx/latch \
+third_party/libcxx/limits \
+third_party/libcxx/list \
+third_party/libcxx/locale \
+third_party/libcxx/locale.h \
+third_party/libcxx/map \
+third_party/libcxx/math.h \
+third_party/libcxx/mdspan \
+third_party/libcxx/memory \
+third_party/libcxx/memory_resource \
+third_party/libcxx/mutex \
+third_party/libcxx/new \
+third_party/libcxx/numbers \
+third_party/libcxx/numeric \
+third_party/libcxx/optional \
+third_party/libcxx/ostream \
+third_party/libcxx/print \
+third_party/libcxx/queue \
+third_party/libcxx/random \
+third_party/libcxx/ranges \
+third_party/libcxx/ratio \
+third_party/libcxx/regex \
+third_party/libcxx/scoped_allocator \
+third_party/libcxx/semaphore \
+third_party/libcxx/set \
+third_party/libcxx/shared_mutex \
+third_party/libcxx/source_location \
+third_party/libcxx/span \
+third_party/libcxx/sstream \
+third_party/libcxx/stack \
+third_party/libcxx/stdatomic.h \
+third_party/libcxx/stdbool.h \
+third_party/libcxx/stddef.h \
+third_party/libcxx/stdexcept \
+third_party/libcxx/stdint.h \
+third_party/libcxx/stdio.h \
+third_party/libcxx/stdlib.h \
+third_party/libcxx/stop_token \
+third_party/libcxx/streambuf \
+third_party/libcxx/string \
+third_party/libcxx/string.h \
+third_party/libcxx/string_view \
+third_party/libcxx/strstream \
+third_party/libcxx/syncstream \
+third_party/libcxx/system_error \
+third_party/libcxx/tgmath.h \
+third_party/libcxx/thread \
+third_party/libcxx/tuple \
+third_party/libcxx/type_traits \
+third_party/libcxx/typeindex \
+third_party/libcxx/typeinfo \
+third_party/libcxx/uchar.h \
+third_party/libcxx/unordered_map \
+third_party/libcxx/unordered_set \
+third_party/libcxx/utility \
+third_party/libcxx/valarray \
+third_party/libcxx/variant \
+third_party/libcxx/vector \
+third_party/libcxx/version \
+third_party/libcxx/wchar.h \
+third_party/libcxx/wctype.h \
+third_party/libcxx/fs/error.h \
+third_party/libcxx/fs/file_descriptor.h \
+third_party/libcxx/fs/format_string.h \
+third_party/libcxx/fs/path_parser.h \
+third_party/libcxx/fs/posix_compat.h \
+third_party/libcxx/fs/time_utils.h \
+third_party/libcxx/chrono_system_time_init.h \
+third_party/libcxx/iostream_init.h \
+third_party/libcxx/memory_resource_init_helper.h \
+third_party/libcxx/std_stream.h \
+third_party/libcxx/overridable_function.h \
+third_party/libcxx/atomic_support.h \
+third_party/libcxx/exception_libcxxabi.h \
+third_party/libcxx/exception_pointer_cxxabi.h \
+third_party/libcxx/to_chars_floating_point.h \
+third_party/libcxx/refstring.h \
+third_party/libcxx/config_elast.h \
+third_party/libcxx/sso_allocator.h \
+third_party/libcxx/stdexcept_default.h \
+third_party/libcxx/ryu/common.h \
+third_party/libcxx/ryu/d2fixed_full_table.h \
+third_party/libcxx/ryu/d2fixed.h \
+third_party/libcxx/ryu/d2s_full_table.h \
+third_party/libcxx/ryu/d2s.h \
+third_party/libcxx/ryu/d2s_intrinsics.h \
+third_party/libcxx/ryu/digit_table.h \
+third_party/libcxx/ryu/f2s.h \
+third_party/libcxx/ryu/ryu.h \
+third_party/libcxx/stdfloat \
+
+THIRD_PARTY_LIBCXX_A_SRCS = \
+third_party/libcxx/algorithm.cpp \
+third_party/libcxx/any.cpp \
+third_party/libcxx/atomic.cpp \
+third_party/libcxx/barrier.cpp \
+third_party/libcxx/bind.cpp \
+third_party/libcxx/call_once.cpp \
+third_party/libcxx/charconv.cpp \
+third_party/libcxx/chrono.cpp \
+third_party/libcxx/condition_variable.cpp \
+third_party/libcxx/condition_variable_destructor.cpp \
+third_party/libcxx/error_category.cpp \
+third_party/libcxx/exception.cpp \
+third_party/libcxx/expected.cpp \
+third_party/libcxx/fstream.cpp \
+third_party/libcxx/functional.cpp \
+third_party/libcxx/future.cpp \
+third_party/libcxx/hash.cpp \
+third_party/libcxx/ios.cpp \
+third_party/libcxx/ios.instantiations.cpp \
+third_party/libcxx/iostream.cpp \
+third_party/libcxx/legacy_pointer_safety.cpp \
+third_party/libcxx/locale.cpp \
+third_party/libcxx/locale2.cpp \
+third_party/libcxx/locale3.cpp \
+third_party/libcxx/locale4.cpp \
+third_party/libcxx/memory.cpp \
+third_party/libcxx/memory_resource.cpp \
+third_party/libcxx/mutex.cpp \
+third_party/libcxx/mutex_destructor.cpp \
+third_party/libcxx/new.cpp \
+third_party/libcxx/new_handler.cpp \
+third_party/libcxx/new_helpers.cpp \
+third_party/libcxx/optional.cpp \
+third_party/libcxx/ostream.cpp \
+third_party/libcxx/print.cpp \
+third_party/libcxx/random.cpp \
+third_party/libcxx/random_shuffle.cpp \
+third_party/libcxx/regex.cpp \
+third_party/libcxx/shared_mutex.cpp \
+third_party/libcxx/stdexcept.cpp \
+third_party/libcxx/string.cpp \
+third_party/libcxx/strstream.cpp \
+third_party/libcxx/system_error.cpp \
+third_party/libcxx/thread.cpp \
+third_party/libcxx/typeinfo.cpp \
+third_party/libcxx/valarray.cpp \
+third_party/libcxx/variant.cpp \
+third_party/libcxx/vector.cpp \
+third_party/libcxx/verbose_abort.cpp \
+third_party/libcxx/fs/directory_entry.cpp \
+third_party/libcxx/fs/directory_iterator.cpp \
+third_party/libcxx/fs/filesystem_clock.cpp \
+third_party/libcxx/fs/filesystem_error.cpp \
+third_party/libcxx/fs/int128_builtins.cpp \
+third_party/libcxx/fs/operations.cpp \
+third_party/libcxx/fs/path.cpp \
+third_party/libcxx/ryu/d2fixed.cpp \
+third_party/libcxx/ryu/d2s.cpp \
+third_party/libcxx/ryu/f2s.cpp \
+third_party/libcxx/errc.cpp \
+
+THIRD_PARTY_LIBCXX_A_HDRS_CHECKEM = \
+third_party/libcxx/__assertion_handler \
+third_party/libcxx/__algorithm/adjacent_find.h \
+third_party/libcxx/__algorithm/all_of.h \
+third_party/libcxx/__algorithm/any_of.h \
+third_party/libcxx/__algorithm/binary_search.h \
+third_party/libcxx/__algorithm/clamp.h \
+third_party/libcxx/__algorithm/comp.h \
+third_party/libcxx/__algorithm/comp_ref_type.h \
+third_party/libcxx/__algorithm/copy.h \
+third_party/libcxx/__algorithm/copy_backward.h \
+third_party/libcxx/__algorithm/copy_if.h \
+third_party/libcxx/__algorithm/copy_move_common.h \
+third_party/libcxx/__algorithm/copy_n.h \
+third_party/libcxx/__algorithm/count.h \
+third_party/libcxx/__algorithm/count_if.h \
+third_party/libcxx/__algorithm/equal.h \
+third_party/libcxx/__algorithm/equal_range.h \
+third_party/libcxx/__algorithm/fill.h \
+third_party/libcxx/__algorithm/fill_n.h \
+third_party/libcxx/__algorithm/find.h \
+third_party/libcxx/__algorithm/find_end.h \
+third_party/libcxx/__algorithm/find_first_of.h \
+third_party/libcxx/__algorithm/find_if.h \
+third_party/libcxx/__algorithm/find_if_not.h \
+third_party/libcxx/__algorithm/find_segment_if.h \
+third_party/libcxx/__algorithm/fold.h \
+third_party/libcxx/__algorithm/for_each.h \
+third_party/libcxx/__algorithm/for_each_n.h \
+third_party/libcxx/__algorithm/for_each_segment.h \
+third_party/libcxx/__algorithm/generate.h \
+third_party/libcxx/__algorithm/generate_n.h \
+third_party/libcxx/__algorithm/half_positive.h \
+third_party/libcxx/__algorithm/in_found_result.h \
+third_party/libcxx/__algorithm/in_fun_result.h \
+third_party/libcxx/__algorithm/in_in_out_result.h \
+third_party/libcxx/__algorithm/in_in_result.h \
+third_party/libcxx/__algorithm/in_out_out_result.h \
+third_party/libcxx/__algorithm/in_out_result.h \
+third_party/libcxx/__algorithm/includes.h \
+third_party/libcxx/__algorithm/inplace_merge.h \
+third_party/libcxx/__algorithm/is_heap.h \
+third_party/libcxx/__algorithm/is_heap_until.h \
+third_party/libcxx/__algorithm/is_partitioned.h \
+third_party/libcxx/__algorithm/is_permutation.h \
+third_party/libcxx/__algorithm/is_sorted.h \
+third_party/libcxx/__algorithm/is_sorted_until.h \
+third_party/libcxx/__algorithm/iter_swap.h \
+third_party/libcxx/__algorithm/iterator_operations.h \
+third_party/libcxx/__algorithm/lexicographical_compare.h \
+third_party/libcxx/__algorithm/lexicographical_compare_three_way.h \
+third_party/libcxx/__algorithm/lower_bound.h \
+third_party/libcxx/__algorithm/make_heap.h \
+third_party/libcxx/__algorithm/make_projected.h \
+third_party/libcxx/__algorithm/max.h \
+third_party/libcxx/__algorithm/max_element.h \
+third_party/libcxx/__algorithm/merge.h \
+third_party/libcxx/__algorithm/min.h \
+third_party/libcxx/__algorithm/min_element.h \
+third_party/libcxx/__algorithm/min_max_result.h \
+third_party/libcxx/__algorithm/minmax.h \
+third_party/libcxx/__algorithm/minmax_element.h \
+third_party/libcxx/__algorithm/mismatch.h \
+third_party/libcxx/__algorithm/move.h \
+third_party/libcxx/__algorithm/move_backward.h \
+third_party/libcxx/__algorithm/next_permutation.h \
+third_party/libcxx/__algorithm/none_of.h \
+third_party/libcxx/__algorithm/nth_element.h \
+third_party/libcxx/__algorithm/partial_sort.h \
+third_party/libcxx/__algorithm/partial_sort_copy.h \
+third_party/libcxx/__algorithm/partition.h \
+third_party/libcxx/__algorithm/partition_copy.h \
+third_party/libcxx/__algorithm/partition_point.h \
+third_party/libcxx/__algorithm/pop_heap.h \
+third_party/libcxx/__algorithm/prev_permutation.h \
+third_party/libcxx/__algorithm/pstl.h \
+third_party/libcxx/__algorithm/push_heap.h \
+third_party/libcxx/__algorithm/ranges_adjacent_find.h \
+third_party/libcxx/__algorithm/ranges_all_of.h \
+third_party/libcxx/__algorithm/ranges_any_of.h \
+third_party/libcxx/__algorithm/ranges_binary_search.h \
+third_party/libcxx/__algorithm/ranges_clamp.h \
+third_party/libcxx/__algorithm/ranges_contains.h \
+third_party/libcxx/__algorithm/ranges_contains_subrange.h \
+third_party/libcxx/__algorithm/ranges_copy.h \
+third_party/libcxx/__algorithm/ranges_copy_backward.h \
+third_party/libcxx/__algorithm/ranges_copy_if.h \
+third_party/libcxx/__algorithm/ranges_copy_n.h \
+third_party/libcxx/__algorithm/ranges_count.h \
+third_party/libcxx/__algorithm/ranges_count_if.h \
+third_party/libcxx/__algorithm/ranges_ends_with.h \
+third_party/libcxx/__algorithm/ranges_equal.h \
+third_party/libcxx/__algorithm/ranges_equal_range.h \
+third_party/libcxx/__algorithm/ranges_fill.h \
+third_party/libcxx/__algorithm/ranges_fill_n.h \
+third_party/libcxx/__algorithm/ranges_find.h \
+third_party/libcxx/__algorithm/ranges_find_end.h \
+third_party/libcxx/__algorithm/ranges_find_first_of.h \
+third_party/libcxx/__algorithm/ranges_find_if.h \
+third_party/libcxx/__algorithm/ranges_find_if_not.h \
+third_party/libcxx/__algorithm/ranges_find_last.h \
+third_party/libcxx/__algorithm/ranges_for_each.h \
+third_party/libcxx/__algorithm/ranges_for_each_n.h \
+third_party/libcxx/__algorithm/ranges_generate.h \
+third_party/libcxx/__algorithm/ranges_generate_n.h \
+third_party/libcxx/__algorithm/ranges_includes.h \
+third_party/libcxx/__algorithm/ranges_inplace_merge.h \
+third_party/libcxx/__algorithm/ranges_is_heap.h \
+third_party/libcxx/__algorithm/ranges_is_heap_until.h \
+third_party/libcxx/__algorithm/ranges_is_partitioned.h \
+third_party/libcxx/__algorithm/ranges_is_permutation.h \
+third_party/libcxx/__algorithm/ranges_is_sorted.h \
+third_party/libcxx/__algorithm/ranges_is_sorted_until.h \
+third_party/libcxx/__algorithm/ranges_iterator_concept.h \
+third_party/libcxx/__algorithm/ranges_lexicographical_compare.h \
+third_party/libcxx/__algorithm/ranges_lower_bound.h \
+third_party/libcxx/__algorithm/ranges_make_heap.h \
+third_party/libcxx/__algorithm/ranges_max.h \
+third_party/libcxx/__algorithm/ranges_max_element.h \
+third_party/libcxx/__algorithm/ranges_merge.h \
+third_party/libcxx/__algorithm/ranges_min.h \
+third_party/libcxx/__algorithm/ranges_min_element.h \
+third_party/libcxx/__algorithm/ranges_minmax.h \
+third_party/libcxx/__algorithm/ranges_minmax_element.h \
+third_party/libcxx/__algorithm/ranges_mismatch.h \
+third_party/libcxx/__algorithm/ranges_move.h \
+third_party/libcxx/__algorithm/ranges_move_backward.h \
+third_party/libcxx/__algorithm/ranges_next_permutation.h \
+third_party/libcxx/__algorithm/ranges_none_of.h \
+third_party/libcxx/__algorithm/ranges_nth_element.h \
+third_party/libcxx/__algorithm/ranges_partial_sort.h \
+third_party/libcxx/__algorithm/ranges_partial_sort_copy.h \
+third_party/libcxx/__algorithm/ranges_partition.h \
+third_party/libcxx/__algorithm/ranges_partition_copy.h \
+third_party/libcxx/__algorithm/ranges_partition_point.h \
+third_party/libcxx/__algorithm/ranges_pop_heap.h \
+third_party/libcxx/__algorithm/ranges_prev_permutation.h \
+third_party/libcxx/__algorithm/ranges_push_heap.h \
+third_party/libcxx/__algorithm/ranges_remove.h \
+third_party/libcxx/__algorithm/ranges_remove_copy.h \
+third_party/libcxx/__algorithm/ranges_remove_copy_if.h \
+third_party/libcxx/__algorithm/ranges_remove_if.h \
+third_party/libcxx/__algorithm/ranges_replace.h \
+third_party/libcxx/__algorithm/ranges_replace_copy.h \
+third_party/libcxx/__algorithm/ranges_replace_copy_if.h \
+third_party/libcxx/__algorithm/ranges_replace_if.h \
+third_party/libcxx/__algorithm/ranges_reverse.h \
+third_party/libcxx/__algorithm/ranges_reverse_copy.h \
+third_party/libcxx/__algorithm/ranges_rotate.h \
+third_party/libcxx/__algorithm/ranges_rotate_copy.h \
+third_party/libcxx/__algorithm/ranges_sample.h \
+third_party/libcxx/__algorithm/ranges_search.h \
+third_party/libcxx/__algorithm/ranges_search_n.h \
+third_party/libcxx/__algorithm/ranges_set_difference.h \
+third_party/libcxx/__algorithm/ranges_set_intersection.h \
+third_party/libcxx/__algorithm/ranges_set_symmetric_difference.h \
+third_party/libcxx/__algorithm/ranges_set_union.h \
+third_party/libcxx/__algorithm/ranges_shuffle.h \
+third_party/libcxx/__algorithm/ranges_sort.h \
+third_party/libcxx/__algorithm/ranges_sort_heap.h \
+third_party/libcxx/__algorithm/ranges_stable_partition.h \
+third_party/libcxx/__algorithm/ranges_stable_sort.h \
+third_party/libcxx/__algorithm/ranges_starts_with.h \
+third_party/libcxx/__algorithm/ranges_swap_ranges.h \
+third_party/libcxx/__algorithm/ranges_transform.h \
+third_party/libcxx/__algorithm/ranges_unique.h \
+third_party/libcxx/__algorithm/ranges_unique_copy.h \
+third_party/libcxx/__algorithm/ranges_upper_bound.h \
+third_party/libcxx/__algorithm/remove.h \
+third_party/libcxx/__algorithm/remove_copy.h \
+third_party/libcxx/__algorithm/remove_copy_if.h \
+third_party/libcxx/__algorithm/remove_if.h \
+third_party/libcxx/__algorithm/replace.h \
+third_party/libcxx/__algorithm/replace_copy.h \
+third_party/libcxx/__algorithm/replace_copy_if.h \
+third_party/libcxx/__algorithm/replace_if.h \
+third_party/libcxx/__algorithm/reverse.h \
+third_party/libcxx/__algorithm/reverse_copy.h \
+third_party/libcxx/__algorithm/rotate.h \
+third_party/libcxx/__algorithm/rotate_copy.h \
+third_party/libcxx/__algorithm/sample.h \
+third_party/libcxx/__algorithm/search.h \
+third_party/libcxx/__algorithm/search_n.h \
+third_party/libcxx/__algorithm/set_difference.h \
+third_party/libcxx/__algorithm/set_intersection.h \
+third_party/libcxx/__algorithm/set_symmetric_difference.h \
+third_party/libcxx/__algorithm/set_union.h \
+third_party/libcxx/__algorithm/shift_left.h \
+third_party/libcxx/__algorithm/shift_right.h \
+third_party/libcxx/__algorithm/shuffle.h \
+third_party/libcxx/__algorithm/sift_down.h \
+third_party/libcxx/__algorithm/simd_utils.h \
+third_party/libcxx/__algorithm/sort.h \
+third_party/libcxx/__algorithm/sort_heap.h \
+third_party/libcxx/__algorithm/stable_partition.h \
+third_party/libcxx/__algorithm/stable_sort.h \
+third_party/libcxx/__algorithm/swap_ranges.h \
+third_party/libcxx/__algorithm/three_way_comp_ref_type.h \
+third_party/libcxx/__algorithm/transform.h \
+third_party/libcxx/__algorithm/uniform_random_bit_generator_adaptor.h \
+third_party/libcxx/__algorithm/unique.h \
+third_party/libcxx/__algorithm/unique_copy.h \
+third_party/libcxx/__algorithm/unwrap_iter.h \
+third_party/libcxx/__algorithm/unwrap_range.h \
+third_party/libcxx/__algorithm/upper_bound.h \
+third_party/libcxx/__assert \
+third_party/libcxx/__atomic/aliases.h \
+third_party/libcxx/__atomic/atomic.h \
+third_party/libcxx/__atomic/atomic_base.h \
+third_party/libcxx/__atomic/atomic_flag.h \
+third_party/libcxx/__atomic/atomic_init.h \
+third_party/libcxx/__atomic/atomic_lock_free.h \
+third_party/libcxx/__atomic/atomic_ref.h \
+third_party/libcxx/__atomic/atomic_sync.h \
+third_party/libcxx/__atomic/check_memory_order.h \
+third_party/libcxx/__atomic/contention_t.h \
+third_party/libcxx/__atomic/cxx_atomic_impl.h \
+third_party/libcxx/__atomic/fence.h \
+third_party/libcxx/__atomic/is_always_lock_free.h \
+third_party/libcxx/__atomic/kill_dependency.h \
+third_party/libcxx/__atomic/memory_order.h \
+third_party/libcxx/__atomic/to_gcc_order.h \
+third_party/libcxx/__bit/bit_cast.h \
+third_party/libcxx/__bit/bit_ceil.h \
+third_party/libcxx/__bit/bit_floor.h \
+third_party/libcxx/__bit/bit_log2.h \
+third_party/libcxx/__bit/bit_width.h \
+third_party/libcxx/__bit/blsr.h \
+third_party/libcxx/__bit/byteswap.h \
+third_party/libcxx/__bit/countl.h \
+third_party/libcxx/__bit/countr.h \
+third_party/libcxx/__bit/endian.h \
+third_party/libcxx/__bit/has_single_bit.h \
+third_party/libcxx/__bit/invert_if.h \
+third_party/libcxx/__bit/popcount.h \
+third_party/libcxx/__bit/rotate.h \
+third_party/libcxx/__bit_reference \
+third_party/libcxx/__charconv/chars_format.h \
+third_party/libcxx/__charconv/from_chars_integral.h \
+third_party/libcxx/__charconv/from_chars_result.h \
+third_party/libcxx/__charconv/tables.h \
+third_party/libcxx/__charconv/to_chars.h \
+third_party/libcxx/__charconv/to_chars_base_10.h \
+third_party/libcxx/__charconv/to_chars_floating_point.h \
+third_party/libcxx/__charconv/to_chars_integral.h \
+third_party/libcxx/__charconv/to_chars_result.h \
+third_party/libcxx/__charconv/traits.h \
+third_party/libcxx/__chrono/calendar.h \
+third_party/libcxx/__chrono/concepts.h \
+third_party/libcxx/__chrono/convert_to_timespec.h \
+third_party/libcxx/__chrono/convert_to_tm.h \
+third_party/libcxx/__chrono/day.h \
+third_party/libcxx/__chrono/duration.h \
+third_party/libcxx/__chrono/exception.h \
+third_party/libcxx/__chrono/file_clock.h \
+third_party/libcxx/__chrono/formatter.h \
+third_party/libcxx/__chrono/hh_mm_ss.h \
+third_party/libcxx/__chrono/high_resolution_clock.h \
+third_party/libcxx/__chrono/leap_second.h \
+third_party/libcxx/__chrono/literals.h \
+third_party/libcxx/__chrono/local_info.h \
+third_party/libcxx/__chrono/month.h \
+third_party/libcxx/__chrono/month_weekday.h \
+third_party/libcxx/__chrono/monthday.h \
+third_party/libcxx/__chrono/ostream.h \
+third_party/libcxx/__chrono/parser_std_format_spec.h \
+third_party/libcxx/__chrono/statically_widen.h \
+third_party/libcxx/__chrono/steady_clock.h \
+third_party/libcxx/__chrono/sys_info.h \
+third_party/libcxx/__chrono/system_clock.h \
+third_party/libcxx/__chrono/time_point.h \
+third_party/libcxx/__chrono/time_zone.h \
+third_party/libcxx/__chrono/time_zone_link.h \
+third_party/libcxx/__chrono/tzdb.h \
+third_party/libcxx/__chrono/tzdb_list.h \
+third_party/libcxx/__chrono/weekday.h \
+third_party/libcxx/__chrono/year.h \
+third_party/libcxx/__chrono/year_month.h \
+third_party/libcxx/__chrono/year_month_day.h \
+third_party/libcxx/__chrono/year_month_weekday.h \
+third_party/libcxx/__chrono/zoned_time.h \
+third_party/libcxx/__compare/common_comparison_category.h \
+third_party/libcxx/__compare/compare_partial_order_fallback.h \
+third_party/libcxx/__compare/compare_strong_order_fallback.h \
+third_party/libcxx/__compare/compare_three_way.h \
+third_party/libcxx/__compare/compare_three_way_result.h \
+third_party/libcxx/__compare/compare_weak_order_fallback.h \
+third_party/libcxx/__compare/is_eq.h \
+third_party/libcxx/__compare/ordering.h \
+third_party/libcxx/__compare/partial_order.h \
+third_party/libcxx/__compare/strong_order.h \
+third_party/libcxx/__compare/synth_three_way.h \
+third_party/libcxx/__compare/three_way_comparable.h \
+third_party/libcxx/__compare/weak_order.h \
+third_party/libcxx/__concepts/arithmetic.h \
+third_party/libcxx/__concepts/assignable.h \
+third_party/libcxx/__concepts/boolean_testable.h \
+third_party/libcxx/__concepts/class_or_enum.h \
+third_party/libcxx/__concepts/common_reference_with.h \
+third_party/libcxx/__concepts/common_with.h \
+third_party/libcxx/__concepts/constructible.h \
+third_party/libcxx/__concepts/convertible_to.h \
+third_party/libcxx/__concepts/copyable.h \
+third_party/libcxx/__concepts/derived_from.h \
+third_party/libcxx/__concepts/destructible.h \
+third_party/libcxx/__concepts/different_from.h \
+third_party/libcxx/__concepts/equality_comparable.h \
+third_party/libcxx/__concepts/invocable.h \
+third_party/libcxx/__concepts/movable.h \
+third_party/libcxx/__concepts/predicate.h \
+third_party/libcxx/__concepts/regular.h \
+third_party/libcxx/__concepts/relation.h \
+third_party/libcxx/__concepts/same_as.h \
+third_party/libcxx/__concepts/semiregular.h \
+third_party/libcxx/__concepts/swappable.h \
+third_party/libcxx/__concepts/totally_ordered.h \
+third_party/libcxx/__condition_variable/condition_variable.h \
+third_party/libcxx/__config \
+third_party/libcxx/__config_site \
+third_party/libcxx/__configuration/abi.h \
+third_party/libcxx/__configuration/availability.h \
+third_party/libcxx/__configuration/compiler.h \
+third_party/libcxx/__configuration/language.h \
+third_party/libcxx/__configuration/platform.h \
+third_party/libcxx/__coroutine/coroutine_handle.h \
+third_party/libcxx/__coroutine/coroutine_traits.h \
+third_party/libcxx/__coroutine/noop_coroutine_handle.h \
+third_party/libcxx/__coroutine/trivial_awaitables.h \
+third_party/libcxx/__debug_utils/randomize_range.h \
+third_party/libcxx/__debug_utils/sanitizers.h \
+third_party/libcxx/__debug_utils/strict_weak_ordering_check.h \
+third_party/libcxx/__exception/exception.h \
+third_party/libcxx/__exception/exception_ptr.h \
+third_party/libcxx/__exception/nested_exception.h \
+third_party/libcxx/__exception/operations.h \
+third_party/libcxx/__exception/terminate.h \
+third_party/libcxx/__expected/bad_expected_access.h \
+third_party/libcxx/__expected/expected.h \
+third_party/libcxx/__expected/unexpect.h \
+third_party/libcxx/__expected/unexpected.h \
+third_party/libcxx/__filesystem/copy_options.h \
+third_party/libcxx/__filesystem/directory_entry.h \
+third_party/libcxx/__filesystem/directory_iterator.h \
+third_party/libcxx/__filesystem/directory_options.h \
+third_party/libcxx/__filesystem/file_status.h \
+third_party/libcxx/__filesystem/file_time_type.h \
+third_party/libcxx/__filesystem/file_type.h \
+third_party/libcxx/__filesystem/filesystem_error.h \
+third_party/libcxx/__filesystem/operations.h \
+third_party/libcxx/__filesystem/path.h \
+third_party/libcxx/__filesystem/path_iterator.h \
+third_party/libcxx/__filesystem/perm_options.h \
+third_party/libcxx/__filesystem/perms.h \
+third_party/libcxx/__filesystem/recursive_directory_iterator.h \
+third_party/libcxx/__filesystem/space_info.h \
+third_party/libcxx/__filesystem/u8path.h \
+third_party/libcxx/__format/buffer.h \
+third_party/libcxx/__format/concepts.h \
+third_party/libcxx/__format/enable_insertable.h \
+third_party/libcxx/__format/escaped_output_table.h \
+third_party/libcxx/__format/extended_grapheme_cluster_table.h \
+third_party/libcxx/__format/format_arg.h \
+third_party/libcxx/__format/format_args.h \
+third_party/libcxx/__format/format_context.h \
+third_party/libcxx/__format/format_error.h \
+third_party/libcxx/__format/format_functions.h \
+third_party/libcxx/__format/format_parse_context.h \
+third_party/libcxx/__format/format_string.h \
+third_party/libcxx/__format/format_to_n_result.h \
+third_party/libcxx/__format/formatter.h \
+third_party/libcxx/__format/formatter_bool.h \
+third_party/libcxx/__format/formatter_char.h \
+third_party/libcxx/__format/formatter_floating_point.h \
+third_party/libcxx/__format/formatter_integer.h \
+third_party/libcxx/__format/formatter_integral.h \
+third_party/libcxx/__format/formatter_output.h \
+third_party/libcxx/__format/formatter_pointer.h \
+third_party/libcxx/__format/formatter_string.h \
+third_party/libcxx/__format/formatter_tuple.h \
+third_party/libcxx/__format/indic_conjunct_break_table.h \
+third_party/libcxx/__format/parser_std_format_spec.h \
+third_party/libcxx/__format/unicode.h \
+third_party/libcxx/__format/width_estimation_table.h \
+third_party/libcxx/__format/write_escaped.h \
+third_party/libcxx/__functional/binary_function.h \
+third_party/libcxx/__functional/binary_negate.h \
+third_party/libcxx/__functional/bind.h \
+third_party/libcxx/__functional/bind_back.h \
+third_party/libcxx/__functional/bind_front.h \
+third_party/libcxx/__functional/binder1st.h \
+third_party/libcxx/__functional/binder2nd.h \
+third_party/libcxx/__functional/compose.h \
+third_party/libcxx/__functional/default_searcher.h \
+third_party/libcxx/__functional/function.h \
+third_party/libcxx/__functional/hash.h \
+third_party/libcxx/__functional/identity.h \
+third_party/libcxx/__functional/invoke.h \
+third_party/libcxx/__functional/is_transparent.h \
+third_party/libcxx/__functional/mem_fn.h \
+third_party/libcxx/__functional/mem_fun_ref.h \
+third_party/libcxx/__functional/not_fn.h \
+third_party/libcxx/__functional/operations.h \
+third_party/libcxx/__functional/perfect_forward.h \
+third_party/libcxx/__functional/pointer_to_binary_function.h \
+third_party/libcxx/__functional/pointer_to_unary_function.h \
+third_party/libcxx/__functional/ranges_operations.h \
+third_party/libcxx/__functional/reference_wrapper.h \
+third_party/libcxx/__functional/unary_function.h \
+third_party/libcxx/__functional/unary_negate.h \
+third_party/libcxx/__functional/weak_result_type.h \
+third_party/libcxx/__fwd/array.h \
+third_party/libcxx/__fwd/bit_reference.h \
+third_party/libcxx/__fwd/complex.h \
+third_party/libcxx/__fwd/deque.h \
+third_party/libcxx/__fwd/format.h \
+third_party/libcxx/__fwd/fstream.h \
+third_party/libcxx/__fwd/functional.h \
+third_party/libcxx/__fwd/ios.h \
+third_party/libcxx/__fwd/istream.h \
+third_party/libcxx/__fwd/mdspan.h \
+third_party/libcxx/__fwd/memory.h \
+third_party/libcxx/__fwd/memory_resource.h \
+third_party/libcxx/__fwd/ostream.h \
+third_party/libcxx/__fwd/pair.h \
+third_party/libcxx/__fwd/queue.h \
+third_party/libcxx/__fwd/span.h \
+third_party/libcxx/__fwd/sstream.h \
+third_party/libcxx/__fwd/stack.h \
+third_party/libcxx/__fwd/streambuf.h \
+third_party/libcxx/__fwd/string.h \
+third_party/libcxx/__fwd/string_view.h \
+third_party/libcxx/__fwd/subrange.h \
+third_party/libcxx/__fwd/tuple.h \
+third_party/libcxx/__fwd/vector.h \
+third_party/libcxx/__hash_table \
+third_party/libcxx/__ios/fpos.h \
+third_party/libcxx/__iterator/access.h \
+third_party/libcxx/__iterator/advance.h \
+third_party/libcxx/__iterator/aliasing_iterator.h \
+third_party/libcxx/__iterator/back_insert_iterator.h \
+third_party/libcxx/__iterator/bounded_iter.h \
+third_party/libcxx/__iterator/common_iterator.h \
+third_party/libcxx/__iterator/concepts.h \
+third_party/libcxx/__iterator/counted_iterator.h \
+third_party/libcxx/__iterator/cpp17_iterator_concepts.h \
+third_party/libcxx/__iterator/data.h \
+third_party/libcxx/__iterator/default_sentinel.h \
+third_party/libcxx/__iterator/distance.h \
+third_party/libcxx/__iterator/empty.h \
+third_party/libcxx/__iterator/erase_if_container.h \
+third_party/libcxx/__iterator/front_insert_iterator.h \
+third_party/libcxx/__iterator/incrementable_traits.h \
+third_party/libcxx/__iterator/indirectly_comparable.h \
+third_party/libcxx/__iterator/insert_iterator.h \
+third_party/libcxx/__iterator/istream_iterator.h \
+third_party/libcxx/__iterator/istreambuf_iterator.h \
+third_party/libcxx/__iterator/iter_move.h \
+third_party/libcxx/__iterator/iter_swap.h \
+third_party/libcxx/__iterator/iterator.h \
+third_party/libcxx/__iterator/iterator_traits.h \
+third_party/libcxx/__iterator/iterator_with_data.h \
+third_party/libcxx/__iterator/mergeable.h \
+third_party/libcxx/__iterator/move_iterator.h \
+third_party/libcxx/__iterator/move_sentinel.h \
+third_party/libcxx/__iterator/next.h \
+third_party/libcxx/__iterator/ostream_iterator.h \
+third_party/libcxx/__iterator/ostreambuf_iterator.h \
+third_party/libcxx/__iterator/permutable.h \
+third_party/libcxx/__iterator/prev.h \
+third_party/libcxx/__iterator/projected.h \
+third_party/libcxx/__iterator/ranges_iterator_traits.h \
+third_party/libcxx/__iterator/readable_traits.h \
+third_party/libcxx/__iterator/reverse_access.h \
+third_party/libcxx/__iterator/reverse_iterator.h \
+third_party/libcxx/__iterator/segmented_iterator.h \
+third_party/libcxx/__iterator/size.h \
+third_party/libcxx/__iterator/sortable.h \
+third_party/libcxx/__iterator/unreachable_sentinel.h \
+third_party/libcxx/__iterator/wrap_iter.h \
+third_party/libcxx/__locale \
+third_party/libcxx/__locale_dir/locale_base_api.h \
+third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_defaults.h \
+third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_fallbacks.h \
+third_party/libcxx/__locale_dir/locale_base_api/locale_guard.h \
+third_party/libcxx/__math/abs.h \
+third_party/libcxx/__math/copysign.h \
+third_party/libcxx/__math/error_functions.h \
+third_party/libcxx/__math/exponential_functions.h \
+third_party/libcxx/__math/fdim.h \
+third_party/libcxx/__math/fma.h \
+third_party/libcxx/__math/gamma.h \
+third_party/libcxx/__math/hyperbolic_functions.h \
+third_party/libcxx/__math/hypot.h \
+third_party/libcxx/__math/inverse_hyperbolic_functions.h \
+third_party/libcxx/__math/inverse_trigonometric_functions.h \
+third_party/libcxx/__math/logarithms.h \
+third_party/libcxx/__math/min_max.h \
+third_party/libcxx/__math/modulo.h \
+third_party/libcxx/__math/remainder.h \
+third_party/libcxx/__math/roots.h \
+third_party/libcxx/__math/rounding_functions.h \
+third_party/libcxx/__math/special_functions.h \
+third_party/libcxx/__math/traits.h \
+third_party/libcxx/__math/trigonometric_functions.h \
+third_party/libcxx/__mbstate_t.h \
+third_party/libcxx/__mdspan/default_accessor.h \
+third_party/libcxx/__mdspan/extents.h \
+third_party/libcxx/__mdspan/layout_left.h \
+third_party/libcxx/__mdspan/layout_right.h \
+third_party/libcxx/__mdspan/layout_stride.h \
+third_party/libcxx/__mdspan/mdspan.h \
+third_party/libcxx/__memory/addressof.h \
+third_party/libcxx/__memory/align.h \
+third_party/libcxx/__memory/aligned_alloc.h \
+third_party/libcxx/__memory/allocate_at_least.h \
+third_party/libcxx/__memory/allocation_guard.h \
+third_party/libcxx/__memory/allocator.h \
+third_party/libcxx/__memory/allocator_arg_t.h \
+third_party/libcxx/__memory/allocator_destructor.h \
+third_party/libcxx/__memory/allocator_traits.h \
+third_party/libcxx/__memory/assume_aligned.h \
+third_party/libcxx/__memory/auto_ptr.h \
+third_party/libcxx/__memory/builtin_new_allocator.h \
+third_party/libcxx/__memory/compressed_pair.h \
+third_party/libcxx/__memory/concepts.h \
+third_party/libcxx/__memory/construct_at.h \
+third_party/libcxx/__memory/destruct_n.h \
+third_party/libcxx/__memory/inout_ptr.h \
+third_party/libcxx/__memory/out_ptr.h \
+third_party/libcxx/__memory/pointer_traits.h \
+third_party/libcxx/__memory/ranges_construct_at.h \
+third_party/libcxx/__memory/ranges_uninitialized_algorithms.h \
+third_party/libcxx/__memory/raw_storage_iterator.h \
+third_party/libcxx/__memory/shared_ptr.h \
+third_party/libcxx/__memory/swap_allocator.h \
+third_party/libcxx/__memory/temp_value.h \
+third_party/libcxx/__memory/temporary_buffer.h \
+third_party/libcxx/__memory/uninitialized_algorithms.h \
+third_party/libcxx/__memory/unique_ptr.h \
+third_party/libcxx/__memory/uses_allocator.h \
+third_party/libcxx/__memory/uses_allocator_construction.h \
+third_party/libcxx/__memory/voidify.h \
+third_party/libcxx/__memory_resource/memory_resource.h \
+third_party/libcxx/__memory_resource/monotonic_buffer_resource.h \
+third_party/libcxx/__memory_resource/polymorphic_allocator.h \
+third_party/libcxx/__memory_resource/pool_options.h \
+third_party/libcxx/__memory_resource/synchronized_pool_resource.h \
+third_party/libcxx/__memory_resource/unsynchronized_pool_resource.h \
+third_party/libcxx/__mutex/lock_guard.h \
+third_party/libcxx/__mutex/mutex.h \
+third_party/libcxx/__mutex/once_flag.h \
+third_party/libcxx/__mutex/tag_types.h \
+third_party/libcxx/__mutex/unique_lock.h \
+third_party/libcxx/__node_handle \
+third_party/libcxx/__numeric/accumulate.h \
+third_party/libcxx/__numeric/adjacent_difference.h \
+third_party/libcxx/__numeric/exclusive_scan.h \
+third_party/libcxx/__numeric/gcd_lcm.h \
+third_party/libcxx/__numeric/inclusive_scan.h \
+third_party/libcxx/__numeric/inner_product.h \
+third_party/libcxx/__numeric/iota.h \
+third_party/libcxx/__numeric/midpoint.h \
+third_party/libcxx/__numeric/partial_sum.h \
+third_party/libcxx/__numeric/pstl.h \
+third_party/libcxx/__numeric/reduce.h \
+third_party/libcxx/__numeric/saturation_arithmetic.h \
+third_party/libcxx/__numeric/transform_exclusive_scan.h \
+third_party/libcxx/__numeric/transform_inclusive_scan.h \
+third_party/libcxx/__numeric/transform_reduce.h \
+third_party/libcxx/__ostream/basic_ostream.h \
+third_party/libcxx/__ostream/print.h \
+third_party/libcxx/__pstl/backend.h \
+third_party/libcxx/__pstl/backend_fwd.h \
+third_party/libcxx/__pstl/backends/default.h \
+third_party/libcxx/__pstl/backends/libdispatch.h \
+third_party/libcxx/__pstl/backends/serial.h \
+third_party/libcxx/__pstl/backends/std_thread.h \
+third_party/libcxx/__pstl/cpu_algos/any_of.h \
+third_party/libcxx/__pstl/cpu_algos/cpu_traits.h \
+third_party/libcxx/__pstl/cpu_algos/fill.h \
+third_party/libcxx/__pstl/cpu_algos/find_if.h \
+third_party/libcxx/__pstl/cpu_algos/for_each.h \
+third_party/libcxx/__pstl/cpu_algos/merge.h \
+third_party/libcxx/__pstl/cpu_algos/stable_sort.h \
+third_party/libcxx/__pstl/cpu_algos/transform.h \
+third_party/libcxx/__pstl/cpu_algos/transform_reduce.h \
+third_party/libcxx/__pstl/dispatch.h \
+third_party/libcxx/__pstl/handle_exception.h \
+third_party/libcxx/__random/bernoulli_distribution.h \
+third_party/libcxx/__random/binomial_distribution.h \
+third_party/libcxx/__random/cauchy_distribution.h \
+third_party/libcxx/__random/chi_squared_distribution.h \
+third_party/libcxx/__random/clamp_to_integral.h \
+third_party/libcxx/__random/default_random_engine.h \
+third_party/libcxx/__random/discard_block_engine.h \
+third_party/libcxx/__random/discrete_distribution.h \
+third_party/libcxx/__random/exponential_distribution.h \
+third_party/libcxx/__random/extreme_value_distribution.h \
+third_party/libcxx/__random/fisher_f_distribution.h \
+third_party/libcxx/__random/gamma_distribution.h \
+third_party/libcxx/__random/generate_canonical.h \
+third_party/libcxx/__random/geometric_distribution.h \
+third_party/libcxx/__random/independent_bits_engine.h \
+third_party/libcxx/__random/is_seed_sequence.h \
+third_party/libcxx/__random/is_valid.h \
+third_party/libcxx/__random/knuth_b.h \
+third_party/libcxx/__random/linear_congruential_engine.h \
+third_party/libcxx/__random/log2.h \
+third_party/libcxx/__random/lognormal_distribution.h \
+third_party/libcxx/__random/mersenne_twister_engine.h \
+third_party/libcxx/__random/negative_binomial_distribution.h \
+third_party/libcxx/__random/normal_distribution.h \
+third_party/libcxx/__random/piecewise_constant_distribution.h \
+third_party/libcxx/__random/piecewise_linear_distribution.h \
+third_party/libcxx/__random/poisson_distribution.h \
+third_party/libcxx/__random/random_device.h \
+third_party/libcxx/__random/ranlux.h \
+third_party/libcxx/__random/seed_seq.h \
+third_party/libcxx/__random/shuffle_order_engine.h \
+third_party/libcxx/__random/student_t_distribution.h \
+third_party/libcxx/__random/subtract_with_carry_engine.h \
+third_party/libcxx/__random/uniform_int_distribution.h \
+third_party/libcxx/__random/uniform_random_bit_generator.h \
+third_party/libcxx/__random/uniform_real_distribution.h \
+third_party/libcxx/__random/weibull_distribution.h \
+third_party/libcxx/__ranges/access.h \
+third_party/libcxx/__ranges/all.h \
+third_party/libcxx/__ranges/as_rvalue_view.h \
+third_party/libcxx/__ranges/chunk_by_view.h \
+third_party/libcxx/__ranges/common_view.h \
+third_party/libcxx/__ranges/concepts.h \
+third_party/libcxx/__ranges/container_compatible_range.h \
+third_party/libcxx/__ranges/counted.h \
+third_party/libcxx/__ranges/dangling.h \
+third_party/libcxx/__ranges/data.h \
+third_party/libcxx/__ranges/drop_view.h \
+third_party/libcxx/__ranges/drop_while_view.h \
+third_party/libcxx/__ranges/elements_view.h \
+third_party/libcxx/__ranges/empty.h \
+third_party/libcxx/__ranges/empty_view.h \
+third_party/libcxx/__ranges/enable_borrowed_range.h \
+third_party/libcxx/__ranges/enable_view.h \
+third_party/libcxx/__ranges/filter_view.h \
+third_party/libcxx/__ranges/from_range.h \
+third_party/libcxx/__ranges/iota_view.h \
+third_party/libcxx/__ranges/istream_view.h \
+third_party/libcxx/__ranges/join_view.h \
+third_party/libcxx/__ranges/lazy_split_view.h \
+third_party/libcxx/__ranges/movable_box.h \
+third_party/libcxx/__ranges/non_propagating_cache.h \
+third_party/libcxx/__ranges/owning_view.h \
+third_party/libcxx/__ranges/range_adaptor.h \
+third_party/libcxx/__ranges/rbegin.h \
+third_party/libcxx/__ranges/ref_view.h \
+third_party/libcxx/__ranges/rend.h \
+third_party/libcxx/__ranges/repeat_view.h \
+third_party/libcxx/__ranges/reverse_view.h \
+third_party/libcxx/__ranges/single_view.h \
+third_party/libcxx/__ranges/size.h \
+third_party/libcxx/__ranges/split_view.h \
+third_party/libcxx/__ranges/subrange.h \
+third_party/libcxx/__ranges/take_view.h \
+third_party/libcxx/__ranges/take_while_view.h \
+third_party/libcxx/__ranges/to.h \
+third_party/libcxx/__ranges/transform_view.h \
+third_party/libcxx/__ranges/view_interface.h \
+third_party/libcxx/__ranges/views.h \
+third_party/libcxx/__ranges/zip_view.h \
+third_party/libcxx/__split_buffer \
+third_party/libcxx/__std_mbstate_t.h \
+third_party/libcxx/__stop_token/atomic_unique_lock.h \
+third_party/libcxx/__stop_token/intrusive_list_view.h \
+third_party/libcxx/__stop_token/intrusive_shared_ptr.h \
+third_party/libcxx/__stop_token/stop_callback.h \
+third_party/libcxx/__stop_token/stop_source.h \
+third_party/libcxx/__stop_token/stop_state.h \
+third_party/libcxx/__stop_token/stop_token.h \
+third_party/libcxx/__string/char_traits.h \
+third_party/libcxx/__string/constexpr_c_functions.h \
+third_party/libcxx/__string/extern_template_lists.h \
+third_party/libcxx/__support/xlocale/__nop_locale_mgmt.h \
+third_party/libcxx/__support/xlocale/__posix_l_fallback.h \
+third_party/libcxx/__support/xlocale/__strtonum_fallback.h \
+third_party/libcxx/__system_error/errc.h \
+third_party/libcxx/__system_error/error_category.h \
+third_party/libcxx/__system_error/error_code.h \
+third_party/libcxx/__system_error/error_condition.h \
+third_party/libcxx/__system_error/system_error.h \
+third_party/libcxx/__thread/formatter.h \
+third_party/libcxx/__thread/id.h \
+third_party/libcxx/__thread/jthread.h \
+third_party/libcxx/__thread/poll_with_backoff.h \
+third_party/libcxx/__thread/support.h \
+third_party/libcxx/__thread/support/pthread.h \
+third_party/libcxx/__thread/this_thread.h \
+third_party/libcxx/__thread/thread.h \
+third_party/libcxx/__thread/timed_backoff_policy.h \
+third_party/libcxx/__tree \
+third_party/libcxx/__tuple/find_index.h \
+third_party/libcxx/__tuple/ignore.h \
+third_party/libcxx/__tuple/make_tuple_types.h \
+third_party/libcxx/__tuple/sfinae_helpers.h \
+third_party/libcxx/__tuple/tuple_element.h \
+third_party/libcxx/__tuple/tuple_indices.h \
+third_party/libcxx/__tuple/tuple_like.h \
+third_party/libcxx/__tuple/tuple_like_ext.h \
+third_party/libcxx/__tuple/tuple_like_no_subrange.h \
+third_party/libcxx/__tuple/tuple_size.h \
+third_party/libcxx/__tuple/tuple_types.h \
+third_party/libcxx/__type_traits/add_const.h \
+third_party/libcxx/__type_traits/add_cv.h \
+third_party/libcxx/__type_traits/add_lvalue_reference.h \
+third_party/libcxx/__type_traits/add_pointer.h \
+third_party/libcxx/__type_traits/add_rvalue_reference.h \
+third_party/libcxx/__type_traits/add_volatile.h \
+third_party/libcxx/__type_traits/aligned_storage.h \
+third_party/libcxx/__type_traits/aligned_union.h \
+third_party/libcxx/__type_traits/alignment_of.h \
+third_party/libcxx/__type_traits/can_extract_key.h \
+third_party/libcxx/__type_traits/common_reference.h \
+third_party/libcxx/__type_traits/common_type.h \
+third_party/libcxx/__type_traits/conditional.h \
+third_party/libcxx/__type_traits/conjunction.h \
+third_party/libcxx/__type_traits/copy_cv.h \
+third_party/libcxx/__type_traits/copy_cvref.h \
+third_party/libcxx/__type_traits/datasizeof.h \
+third_party/libcxx/__type_traits/decay.h \
+third_party/libcxx/__type_traits/dependent_type.h \
+third_party/libcxx/__type_traits/desugars_to.h \
+third_party/libcxx/__type_traits/disjunction.h \
+third_party/libcxx/__type_traits/enable_if.h \
+third_party/libcxx/__type_traits/extent.h \
+third_party/libcxx/__type_traits/has_unique_object_representation.h \
+third_party/libcxx/__type_traits/has_virtual_destructor.h \
+third_party/libcxx/__type_traits/integral_constant.h \
+third_party/libcxx/__type_traits/invoke.h \
+third_party/libcxx/__type_traits/is_abstract.h \
+third_party/libcxx/__type_traits/is_aggregate.h \
+third_party/libcxx/__type_traits/is_allocator.h \
+third_party/libcxx/__type_traits/is_always_bitcastable.h \
+third_party/libcxx/__type_traits/is_arithmetic.h \
+third_party/libcxx/__type_traits/is_array.h \
+third_party/libcxx/__type_traits/is_assignable.h \
+third_party/libcxx/__type_traits/is_base_of.h \
+third_party/libcxx/__type_traits/is_bounded_array.h \
+third_party/libcxx/__type_traits/is_callable.h \
+third_party/libcxx/__type_traits/is_char_like_type.h \
+third_party/libcxx/__type_traits/is_class.h \
+third_party/libcxx/__type_traits/is_compound.h \
+third_party/libcxx/__type_traits/is_const.h \
+third_party/libcxx/__type_traits/is_constant_evaluated.h \
+third_party/libcxx/__type_traits/is_constructible.h \
+third_party/libcxx/__type_traits/is_convertible.h \
+third_party/libcxx/__type_traits/is_core_convertible.h \
+third_party/libcxx/__type_traits/is_destructible.h \
+third_party/libcxx/__type_traits/is_empty.h \
+third_party/libcxx/__type_traits/is_enum.h \
+third_party/libcxx/__type_traits/is_equality_comparable.h \
+third_party/libcxx/__type_traits/is_execution_policy.h \
+third_party/libcxx/__type_traits/is_final.h \
+third_party/libcxx/__type_traits/is_floating_point.h \
+third_party/libcxx/__type_traits/is_function.h \
+third_party/libcxx/__type_traits/is_fundamental.h \
+third_party/libcxx/__type_traits/is_implicitly_default_constructible.h \
+third_party/libcxx/__type_traits/is_integral.h \
+third_party/libcxx/__type_traits/is_literal_type.h \
+third_party/libcxx/__type_traits/is_member_pointer.h \
+third_party/libcxx/__type_traits/is_nothrow_assignable.h \
+third_party/libcxx/__type_traits/is_nothrow_constructible.h \
+third_party/libcxx/__type_traits/is_nothrow_convertible.h \
+third_party/libcxx/__type_traits/is_nothrow_destructible.h \
+third_party/libcxx/__type_traits/is_null_pointer.h \
+third_party/libcxx/__type_traits/is_object.h \
+third_party/libcxx/__type_traits/is_pod.h \
+third_party/libcxx/__type_traits/is_pointer.h \
+third_party/libcxx/__type_traits/is_polymorphic.h \
+third_party/libcxx/__type_traits/is_primary_template.h \
+third_party/libcxx/__type_traits/is_reference.h \
+third_party/libcxx/__type_traits/is_reference_wrapper.h \
+third_party/libcxx/__type_traits/is_referenceable.h \
+third_party/libcxx/__type_traits/is_same.h \
+third_party/libcxx/__type_traits/is_scalar.h \
+third_party/libcxx/__type_traits/is_signed.h \
+third_party/libcxx/__type_traits/is_signed_integer.h \
+third_party/libcxx/__type_traits/is_specialization.h \
+third_party/libcxx/__type_traits/is_standard_layout.h \
+third_party/libcxx/__type_traits/is_swappable.h \
+third_party/libcxx/__type_traits/is_trivial.h \
+third_party/libcxx/__type_traits/is_trivially_assignable.h \
+third_party/libcxx/__type_traits/is_trivially_constructible.h \
+third_party/libcxx/__type_traits/is_trivially_copyable.h \
+third_party/libcxx/__type_traits/is_trivially_destructible.h \
+third_party/libcxx/__type_traits/is_trivially_lexicographically_comparable.h \
+third_party/libcxx/__type_traits/is_trivially_relocatable.h \
+third_party/libcxx/__type_traits/is_unbounded_array.h \
+third_party/libcxx/__type_traits/is_union.h \
+third_party/libcxx/__type_traits/is_unsigned.h \
+third_party/libcxx/__type_traits/is_unsigned_integer.h \
+third_party/libcxx/__type_traits/is_valid_expansion.h \
+third_party/libcxx/__type_traits/is_void.h \
+third_party/libcxx/__type_traits/is_volatile.h \
+third_party/libcxx/__type_traits/lazy.h \
+third_party/libcxx/__type_traits/make_32_64_or_128_bit.h \
+third_party/libcxx/__type_traits/make_const_lvalue_ref.h \
+third_party/libcxx/__type_traits/make_signed.h \
+third_party/libcxx/__type_traits/make_unsigned.h \
+third_party/libcxx/__type_traits/maybe_const.h \
+third_party/libcxx/__type_traits/nat.h \
+third_party/libcxx/__type_traits/negation.h \
+third_party/libcxx/__type_traits/noexcept_move_assign_container.h \
+third_party/libcxx/__type_traits/promote.h \
+third_party/libcxx/__type_traits/rank.h \
+third_party/libcxx/__type_traits/remove_all_extents.h \
+third_party/libcxx/__type_traits/remove_const.h \
+third_party/libcxx/__type_traits/remove_const_ref.h \
+third_party/libcxx/__type_traits/remove_cv.h \
+third_party/libcxx/__type_traits/remove_cvref.h \
+third_party/libcxx/__type_traits/remove_extent.h \
+third_party/libcxx/__type_traits/remove_pointer.h \
+third_party/libcxx/__type_traits/remove_reference.h \
+third_party/libcxx/__type_traits/remove_volatile.h \
+third_party/libcxx/__type_traits/result_of.h \
+third_party/libcxx/__type_traits/strip_signature.h \
+third_party/libcxx/__type_traits/type_identity.h \
+third_party/libcxx/__type_traits/type_list.h \
+third_party/libcxx/__type_traits/underlying_type.h \
+third_party/libcxx/__type_traits/unwrap_ref.h \
+third_party/libcxx/__type_traits/void_t.h \
+third_party/libcxx/__undef_macros \
+third_party/libcxx/__utility/as_const.h \
+third_party/libcxx/__utility/as_lvalue.h \
+third_party/libcxx/__utility/auto_cast.h \
+third_party/libcxx/__utility/cmp.h \
+third_party/libcxx/__utility/convert_to_integral.h \
+third_party/libcxx/__utility/declval.h \
+third_party/libcxx/__utility/empty.h \
+third_party/libcxx/__utility/exception_guard.h \
+third_party/libcxx/__utility/exchange.h \
+third_party/libcxx/__utility/forward.h \
+third_party/libcxx/__utility/forward_like.h \
+third_party/libcxx/__utility/in_place.h \
+third_party/libcxx/__utility/integer_sequence.h \
+third_party/libcxx/__utility/is_pointer_in_range.h \
+third_party/libcxx/__utility/is_valid_range.h \
+third_party/libcxx/__utility/move.h \
+third_party/libcxx/__utility/no_destroy.h \
+third_party/libcxx/__utility/pair.h \
+third_party/libcxx/__utility/piecewise_construct.h \
+third_party/libcxx/__utility/priority_tag.h \
+third_party/libcxx/__utility/private_constructor_tag.h \
+third_party/libcxx/__utility/rel_ops.h \
+third_party/libcxx/__utility/small_buffer.h \
+third_party/libcxx/__utility/swap.h \
+third_party/libcxx/__utility/to_underlying.h \
+third_party/libcxx/__utility/unreachable.h \
+third_party/libcxx/__variant/monostate.h \
+third_party/libcxx/__verbose_abort \
+third_party/libcxx/algorithm \
+third_party/libcxx/any \
+third_party/libcxx/array \
+third_party/libcxx/atomic \
+third_party/libcxx/barrier \
+third_party/libcxx/bit \
+third_party/libcxx/bitset \
+third_party/libcxx/cassert \
+third_party/libcxx/ccomplex \
+third_party/libcxx/cctype \
+third_party/libcxx/cerrno \
+third_party/libcxx/cfenv \
+third_party/libcxx/cfloat \
+third_party/libcxx/charconv \
+third_party/libcxx/chrono \
+third_party/libcxx/cinttypes \
+third_party/libcxx/ciso646 \
+third_party/libcxx/climits \
+third_party/libcxx/clocale \
+third_party/libcxx/cmath \
+third_party/libcxx/codecvt \
+third_party/libcxx/compare \
+third_party/libcxx/complex \
+third_party/libcxx/complex.h \
 third_party/libcxx/concepts \
 third_party/libcxx/condition_variable \
 third_party/libcxx/coroutine \
@@ -815,24 +2007,20 @@ third_party/libcxx/exception \
 third_party/libcxx/execution \
 third_party/libcxx/expected \
 third_party/libcxx/experimental/__config \
-third_party/libcxx/experimental/__memory \
-third_party/libcxx/experimental/deque \
-third_party/libcxx/experimental/forward_list \
+third_party/libcxx/experimental/__simd/aligned_tag.h \
+third_party/libcxx/experimental/__simd/declaration.h \
+third_party/libcxx/experimental/__simd/reference.h \
+third_party/libcxx/experimental/__simd/scalar.h \
+third_party/libcxx/experimental/__simd/simd.h \
+third_party/libcxx/experimental/__simd/simd_mask.h \
+third_party/libcxx/experimental/__simd/traits.h \
+third_party/libcxx/experimental/__simd/utility.h \
+third_party/libcxx/experimental/__simd/vec_ext.h \
 third_party/libcxx/experimental/iterator \
-third_party/libcxx/experimental/list \
-third_party/libcxx/experimental/map \
-third_party/libcxx/experimental/memory_resource \
+third_party/libcxx/experimental/memory \
 third_party/libcxx/experimental/propagate_const \
-third_party/libcxx/experimental/regex \
-third_party/libcxx/experimental/set \
-third_party/libcxx/experimental/simd \
-third_party/libcxx/experimental/string \
 third_party/libcxx/experimental/type_traits \
-third_party/libcxx/experimental/unordered_map \
-third_party/libcxx/experimental/unordered_set \
 third_party/libcxx/experimental/utility \
-third_party/libcxx/experimental/vector \
-third_party/libcxx/ext/__hash \
 third_party/libcxx/filesystem \
 third_party/libcxx/format \
 third_party/libcxx/forward_list \
@@ -860,6 +2048,7 @@ third_party/libcxx/numbers \
 third_party/libcxx/numeric \
 third_party/libcxx/optional \
 third_party/libcxx/ostream \
+third_party/libcxx/print \
 third_party/libcxx/queue \
 third_party/libcxx/random \
 third_party/libcxx/ranges \
@@ -873,11 +2062,14 @@ third_party/libcxx/source_location \
 third_party/libcxx/span \
 third_party/libcxx/sstream \
 third_party/libcxx/stack \
+third_party/libcxx/stdatomic.h \
 third_party/libcxx/stdexcept \
+third_party/libcxx/stop_token \
 third_party/libcxx/streambuf \
 third_party/libcxx/string \
 third_party/libcxx/string_view \
 third_party/libcxx/strstream \
+third_party/libcxx/syncstream \
 third_party/libcxx/system_error \
 third_party/libcxx/thread \
 third_party/libcxx/tuple \
@@ -891,180 +2083,32 @@ third_party/libcxx/valarray \
 third_party/libcxx/variant \
 third_party/libcxx/vector \
 third_party/libcxx/version \
-
-THIRD_PARTY_LIBCXX_A_INCS = \
-third_party/libcxx/__algorithm/pstl_any_all_none_of.h \
-third_party/libcxx/__algorithm/pstl_backend.h \
-third_party/libcxx/__algorithm/pstl_backends/cpu_backend.h \
-third_party/libcxx/__algorithm/pstl_backends/cpu_backends/any_of.h \
-third_party/libcxx/__algorithm/pstl_backends/cpu_backends/backend.h \
-third_party/libcxx/__algorithm/pstl_backends/cpu_backends/fill.h \
-third_party/libcxx/__algorithm/pstl_backends/cpu_backends/find_if.h \
-third_party/libcxx/__algorithm/pstl_backends/cpu_backends/for_each.h \
-third_party/libcxx/__algorithm/pstl_backends/cpu_backends/merge.h \
-third_party/libcxx/__algorithm/pstl_backends/cpu_backends/serial.h \
-third_party/libcxx/__algorithm/pstl_backends/cpu_backends/thread.h \
-third_party/libcxx/__algorithm/pstl_backends/cpu_backends/transform.h \
-third_party/libcxx/__algorithm/pstl_copy.h \
-third_party/libcxx/__algorithm/pstl_fill.h \
-third_party/libcxx/__algorithm/pstl_find.h \
-third_party/libcxx/__algorithm/pstl_for_each.h \
-third_party/libcxx/__algorithm/pstl_frontend_dispatch.h \
-third_party/libcxx/__algorithm/pstl_merge.h \
-third_party/libcxx/__algorithm/pstl_transform.h \
-third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_defaults.h \
-third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_fallbacks.h \
-third_party/libcxx/__locale_dir/locale_base_api/locale_guard.h \
-third_party/libcxx/__mbstate_t.h \
-third_party/libcxx/__pstl/internal/algorithm_fwd.h \
-third_party/libcxx/__pstl/internal/algorithm_impl.h \
-third_party/libcxx/__pstl/internal/execution_defs.h \
-third_party/libcxx/__pstl/internal/execution_impl.h \
-third_party/libcxx/__pstl/internal/glue_algorithm_defs.h \
-third_party/libcxx/__pstl/internal/glue_algorithm_impl.h \
-third_party/libcxx/__pstl/internal/glue_memory_defs.h \
-third_party/libcxx/__pstl/internal/glue_memory_impl.h \
-third_party/libcxx/__pstl/internal/glue_numeric_defs.h \
-third_party/libcxx/__pstl/internal/glue_numeric_impl.h \
-third_party/libcxx/__pstl/internal/memory_impl.h \
-third_party/libcxx/__pstl/internal/numeric_fwd.h \
-third_party/libcxx/__pstl/internal/numeric_impl.h \
-third_party/libcxx/__pstl/internal/omp/parallel_for.h \
-third_party/libcxx/__pstl/internal/omp/parallel_for_each.h \
-third_party/libcxx/__pstl/internal/omp/parallel_invoke.h \
-third_party/libcxx/__pstl/internal/omp/parallel_merge.h \
-third_party/libcxx/__pstl/internal/omp/parallel_reduce.h \
-third_party/libcxx/__pstl/internal/omp/parallel_scan.h \
-third_party/libcxx/__pstl/internal/omp/parallel_stable_partial_sort.h \
-third_party/libcxx/__pstl/internal/omp/parallel_stable_sort.h \
-third_party/libcxx/__pstl/internal/omp/parallel_transform_reduce.h \
-third_party/libcxx/__pstl/internal/omp/parallel_transform_scan.h \
-third_party/libcxx/__pstl/internal/omp/util.h \
-third_party/libcxx/__pstl/internal/parallel_backend.h \
-third_party/libcxx/__pstl/internal/parallel_backend_omp.h \
-third_party/libcxx/__pstl/internal/parallel_backend_serial.h \
-third_party/libcxx/__pstl/internal/parallel_backend_tbb.h \
-third_party/libcxx/__pstl/internal/parallel_backend_utils.h \
-third_party/libcxx/__pstl/internal/unseq_backend_simd.h \
-third_party/libcxx/__pstl/internal/utils.h \
-third_party/libcxx/__pstl_algorithm \
-third_party/libcxx/__pstl_config_site \
-third_party/libcxx/__pstl_memory \
-third_party/libcxx/__pstl_numeric \
-third_party/libcxx/__support/android/locale_bionic.h \
-third_party/libcxx/__support/musl/xlocale.h \
-third_party/libcxx/complex.h \
-third_party/libcxx/ctype.h \
-third_party/libcxx/errno.h \
-third_party/libcxx/fenv.h \
-third_party/libcxx/float.h \
-third_party/libcxx/inttypes.h \
-third_party/libcxx/limits.h \
-third_party/libcxx/locale.h \
-third_party/libcxx/math.h \
-third_party/libcxx/setjmp.h \
-third_party/libcxx/src/chrono_system_time_init.h \
-third_party/libcxx/src/experimental/memory_resource_init_helper.h \
-third_party/libcxx/src/filesystem/filesystem_common.h \
-third_party/libcxx/src/filesystem/posix_compat.h \
-third_party/libcxx/src/include/apple_availability.h \
-third_party/libcxx/src/include/atomic_support.h \
-third_party/libcxx/src/include/config_elast.h \
-third_party/libcxx/src/include/refstring.h \
-third_party/libcxx/src/include/ryu/common.h \
-third_party/libcxx/src/include/ryu/d2fixed.h \
-third_party/libcxx/src/include/ryu/d2fixed_full_table.h \
-third_party/libcxx/src/include/ryu/d2s.h \
-third_party/libcxx/src/include/ryu/d2s_full_table.h \
-third_party/libcxx/src/include/ryu/d2s_intrinsics.h \
-third_party/libcxx/src/include/ryu/digit_table.h \
-third_party/libcxx/src/include/ryu/f2s.h \
-third_party/libcxx/src/include/ryu/ryu.h \
-third_party/libcxx/src/include/sso_allocator.h \
-third_party/libcxx/src/include/to_chars_floating_point.h \
-third_party/libcxx/src/iostream_init.h \
-third_party/libcxx/src/memory_resource_init_helper.h \
-third_party/libcxx/src/std_stream.h \
-third_party/libcxx/src/support/runtime/exception_fallback.ipp \
-third_party/libcxx/src/support/runtime/exception_glibcxx.ipp \
-third_party/libcxx/src/support/runtime/exception_libcxxabi.ipp \
-third_party/libcxx/src/support/runtime/exception_libcxxrt.ipp \
-third_party/libcxx/src/support/runtime/exception_msvc.ipp \
-third_party/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp \
-third_party/libcxx/src/support/runtime/exception_pointer_glibcxx.ipp \
-third_party/libcxx/src/support/runtime/exception_pointer_msvc.ipp \
-third_party/libcxx/src/support/runtime/exception_pointer_unimplemented.ipp \
-third_party/libcxx/src/support/runtime/new_handler_fallback.ipp \
-third_party/libcxx/src/support/runtime/stdexcept_default.ipp \
-third_party/libcxx/src/support/runtime/stdexcept_vcruntime.ipp \
-third_party/libcxx/stdatomic.h \
-third_party/libcxx/stdbool.h \
-third_party/libcxx/stddef.h \
-third_party/libcxx/stdint.h \
-third_party/libcxx/stdio.h \
-third_party/libcxx/stdlib.h \
-third_party/libcxx/string.h \
-third_party/libcxx/tgmath.h \
-third_party/libcxx/uchar.h \
-third_party/libcxx/wchar.h \
-third_party/libcxx/wctype.h \
-third_party/libcxx/libcxx.imp \
-third_party/libcxx/module.modulemap \
-
-THIRD_PARTY_LIBCXX_A_SRCS = \
-third_party/libcxx/src/algorithm.cpp \
-third_party/libcxx/src/any.cpp \
-third_party/libcxx/src/atomic.cpp \
-third_party/libcxx/src/barrier.cpp \
-third_party/libcxx/src/bind.cpp \
-third_party/libcxx/src/charconv.cpp \
-third_party/libcxx/src/chrono.cpp \
-third_party/libcxx/src/condition_variable.cpp \
-third_party/libcxx/src/condition_variable_destructor.cpp \
-third_party/libcxx/src/debug.cpp \
-third_party/libcxx/src/exception.cpp \
-third_party/libcxx/src/experimental/memory_resource.cpp \
-third_party/libcxx/src/filesystem/directory_iterator.cpp \
-third_party/libcxx/src/filesystem/int128_builtins.cpp \
-third_party/libcxx/src/filesystem/operations.cpp \
-third_party/libcxx/src/functional.cpp \
-third_party/libcxx/src/future.cpp \
-third_party/libcxx/src/hash.cpp \
-third_party/libcxx/src/ios.cpp \
-third_party/libcxx/src/ios.instantiations.cpp \
-third_party/libcxx/src/iostream.cpp \
-third_party/libcxx/src/legacy_debug_handler.cpp \
-third_party/libcxx/src/legacy_pointer_safety.cpp \
-third_party/libcxx/src/locale.cpp \
-third_party/libcxx/src/memory.cpp \
-third_party/libcxx/src/memory_resource.cpp \
-third_party/libcxx/src/mutex.cpp \
-third_party/libcxx/src/mutex_destructor.cpp \
-third_party/libcxx/src/new.cpp \
-third_party/libcxx/src/optional.cpp \
-third_party/libcxx/src/random.cpp \
-third_party/libcxx/src/regex.cpp \
-third_party/libcxx/src/ryu/d2fixed.cpp \
-third_party/libcxx/src/ryu/d2s.cpp \
-third_party/libcxx/src/ryu/f2s.cpp \
-third_party/libcxx/src/shared_mutex.cpp \
-third_party/libcxx/src/stdexcept.cpp \
-third_party/libcxx/src/string.cpp \
-third_party/libcxx/src/strstream.cpp \
-third_party/libcxx/src/system_error.cpp \
-third_party/libcxx/src/thread.cpp \
-third_party/libcxx/src/typeinfo.cpp \
-third_party/libcxx/src/valarray.cpp \
-third_party/libcxx/src/variant.cpp \
-third_party/libcxx/src/vector.cpp \
-third_party/libcxx/src/verbose_abort.cpp
+third_party/libcxx/fs/error.h \
+third_party/libcxx/fs/file_descriptor.h \
+third_party/libcxx/fs/format_string.h \
+third_party/libcxx/fs/path_parser.h \
+third_party/libcxx/fs/posix_compat.h \
+third_party/libcxx/fs/time_utils.h \
+third_party/libcxx/std_stream.h \
+third_party/libcxx/overridable_function.h \
+third_party/libcxx/atomic_support.h \
+third_party/libcxx/refstring.h \
+third_party/libcxx/config_elast.h \
+third_party/libcxx/sso_allocator.h \
+third_party/libcxx/stdexcept_default.h \
+third_party/libcxx/ryu/common.h \
+third_party/libcxx/ryu/d2fixed_full_table.h \
+third_party/libcxx/ryu/d2s_full_table.h \
+third_party/libcxx/ryu/d2s_intrinsics.h \
+third_party/libcxx/ryu/digit_table.h \
+third_party/libcxx/ryu/ryu.h \
 
 THIRD_PARTY_LIBCXX_A_OBJS =					\
 	$(THIRD_PARTY_LIBCXX_A_SRCS:%.cpp=o/$(MODE)/%.o)
 
 THIRD_PARTY_LIBCXX_A_CHECKS =					\
 	$(THIRD_PARTY_LIBCXX_A).pkg				\
-	$(THIRD_PARTY_LIBCXX_A_HDRS:%=o/$(MODE)/%.okk)
+	$(THIRD_PARTY_LIBCXX_A_HDRS_CHECKEM:%=o/$(MODE)/%.okk)
 
 THIRD_PARTY_LIBCXX_A_DIRECTDEPS =				\
 	LIBC_CALLS						\
@@ -1108,6 +2152,9 @@ $(THIRD_PARTY_LIBCXX_A_OBJS): private				\
 			-DLIBCXX_BUILDING_LIBCXXABI		\
 			-D_LIBCPP_BUILDING_LIBRARY
 
+o/$(MODE)/third_party/libcxx/locale.o: private			\
+		OVERRIDE_COPTS += -O -g0
+
 THIRD_PARTY_LIBCXX_LIBS = $(foreach x,$(THIRD_PARTY_LIBCXX_ARTIFACTS),$($(x)))
 THIRD_PARTY_LIBCXX_SRCS = $(foreach x,$(THIRD_PARTY_LIBCXX_ARTIFACTS),$($(x)_SRCS))
 THIRD_PARTY_LIBCXX_HDRS = $(foreach x,$(THIRD_PARTY_LIBCXX_ARTIFACTS),$($(x)_HDRS))
diff --git a/third_party/libcxx/CREDITS.TXT b/third_party/libcxx/CREDITS.TXT
deleted file mode 100644
index 46a06c6ea..000000000
--- a/third_party/libcxx/CREDITS.TXT
+++ /dev/null
@@ -1,150 +0,0 @@
-This file is a partial list of people who have contributed to the LLVM/libc++
-project.  If you have contributed a patch or made some other contribution to
-LLVM/libc++, please submit a patch to this file to add yourself, and it will be
-done!
-
-The list is sorted by surname and formatted to allow easy grepping and
-beautification by scripts.  The fields are: name (N), email (E), web-address
-(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
-(S).
-
-N: Saleem Abdulrasool
-E: compnerd@compnerd.org
-D: Minor patches and Linux fixes.
-
-N: Dan Albert
-E: danalbert@google.com
-D: Android support and test runner improvements.
-
-N: Dimitry Andric
-E: dimitry@andric.com
-D: Visibility fixes, minor FreeBSD portability patches.
-
-N: Holger Arnold
-E: holgerar@gmail.com
-D: Minor fix.
-
-N: Ruben Van Boxem
-E: vanboxem dot ruben at gmail dot com
-D: Initial Windows patches.
-
-N: David Chisnall
-E: theraven at theravensnest dot org
-D: FreeBSD and Solaris ports, libcxxrt support, some atomics work.
-
-N: Marshall Clow
-E: mclow.lists@gmail.com
-E: marshall@idio.com
-D: C++14 support, patches and bug fixes.
-
-N: Jonathan B Coe
-E: jbcoe@me.com
-D: Implementation of propagate_const.
-
-N: Glen Joseph Fernandes
-E: glenjofe@gmail.com
-D: Implementation of to_address.
-
-N: Eric Fiselier
-E: eric@efcs.ca
-D: LFTS support, patches and bug fixes.
-
-N: Bill Fisher
-E: william.w.fisher@gmail.com
-D: Regex bug fixes.
-
-N: Matthew Dempsky
-E: matthew@dempsky.org
-D: Minor patches and bug fixes.
-
-N: Google Inc.
-D: Copyright owner and contributor of the CityHash algorithm
-
-N: Howard Hinnant
-E: hhinnant@apple.com
-D: Architect and primary author of libc++
-
-N: Hyeon-bin Jeong
-E: tuhertz@gmail.com
-D: Minor patches and bug fixes.
-
-N: Argyrios Kyrtzidis
-E: kyrtzidis@apple.com
-D: Bug fixes.
-
-N: Bruce Mitchener, Jr.
-E: bruce.mitchener@gmail.com
-D: Emscripten-related changes.
-
-N: Michel Morin
-E: mimomorin@gmail.com
-D: Minor patches to is_convertible.
-
-N: Andrew Morrow
-E: andrew.c.morrow@gmail.com
-D: Minor patches and Linux fixes.
-
-N: Michael Park
-E: mcypark@gmail.com
-D: Implementation of <variant>.
-
-N: Arvid Picciani
-E: aep at exys dot org
-D: Minor patches and musl port.
-
-N: Bjorn Reese
-E: breese@users.sourceforge.net
-D: Initial regex prototype
-
-N: Nico Rieck
-E: nico.rieck@gmail.com
-D: Windows fixes
-
-N: Jon Roelofs
-E: jroelofS@jroelofs.com
-D: Remote testing, Newlib port, baremetal/single-threaded support.
-
-N: Jonathan Sauer
-D: Minor patches, mostly related to constexpr
-
-N: Craig Silverstein
-E: csilvers@google.com
-D: Implemented Cityhash as the string hash function on 64-bit machines
-
-N: Richard Smith
-D: Minor patches.
-
-N: Joerg Sonnenberger
-E: joerg@NetBSD.org
-D: NetBSD port.
-
-N: Stephan Tolksdorf
-E: st@quanttec.com
-D: Minor <atomic> fix
-
-N: Michael van der Westhuizen
-E: r1mikey at gmail dot com
-
-N: Larisse Voufo
-D: Minor patches.
-
-N: Klaas de Vries
-E: klaas at klaasgaaf dot nl
-D: Minor bug fix.
-
-N: Zhang Xiongpang
-E: zhangxiongpang@gmail.com
-D: Minor patches and bug fixes.
-
-N: Xing Xue
-E: xingxue@ca.ibm.com
-D: AIX port
-
-N: Zhihao Yuan
-E: lichray@gmail.com
-D: Standard compatibility fixes.
-
-N: Jeffrey Yasskin
-E: jyasskin@gmail.com
-E: jyasskin@google.com
-D: Linux fixes.
diff --git a/third_party/libcxx/LICENSE.TXT b/third_party/libcxx/LICENSE.TXT
deleted file mode 100644
index e159d2834..000000000
--- a/third_party/libcxx/LICENSE.TXT
+++ /dev/null
@@ -1,311 +0,0 @@
-==============================================================================
-The LLVM Project is under the Apache License v2.0 with LLVM Exceptions:
-==============================================================================
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-    1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-    2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-    3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-    4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-    5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-    6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-    7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-    8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-    9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-    END OF TERMS AND CONDITIONS
-
-    APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-    Copyright [yyyy] [name of copyright owner]
-
-    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.
-
-
----- LLVM Exceptions to the Apache 2.0 License ----
-
-As an exception, if, as a result of your compiling your source code, portions
-of this Software are embedded into an Object form of such source code, you
-may redistribute such embedded portions in such Object form without complying
-with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
-
-In addition, if you combine or link compiled forms of this Software with
-software that is licensed under the GPLv2 ("Combined Software") and if a
-court of competent jurisdiction determines that the patent provision (Section
-3), the indemnity provision (Section 9) or other Section of the License
-conflicts with the conditions of the GPLv2, you may retroactively and
-prospectively choose to deem waived or otherwise exclude such Section(s) of
-the License, but only in their entirety and only with respect to the Combined
-Software.
-
-==============================================================================
-Software from third parties included in the LLVM Project:
-==============================================================================
-The LLVM Project contains third party software which is under different license
-terms. All such code will be identified clearly using at least one of two
-mechanisms:
-1) It will be in a separate directory tree with its own `LICENSE.txt` or
-   `LICENSE` file at the top containing the specific license and restrictions
-   which apply to that software, or
-2) It will contain specific license and restriction terms at the top of every
-   file.
-
-==============================================================================
-Legacy LLVM License (https://llvm.org/docs/DeveloperPolicy.html#legacy):
-==============================================================================
-
-The libc++ library is dual licensed under both the University of Illinois
-"BSD-Like" license and the MIT license.  As a user of this code you may choose
-to use it under either license.  As a contributor, you agree to allow your code
-to be used under both.
-
-Full text of the relevant licenses is included below.
-
-==============================================================================
-
-University of Illinois/NCSA
-Open Source License
-
-Copyright (c) 2009-2019 by the contributors listed in CREDITS.TXT
-
-All rights reserved.
-
-Developed by:
-
-    LLVM Team
-
-    University of Illinois at Urbana-Champaign
-
-    http://llvm.org
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal with
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimers.
-
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimers in the
-      documentation and/or other materials provided with the distribution.
-
-    * Neither the names of the LLVM Team, University of Illinois at
-      Urbana-Champaign, nor the names of its contributors may be used to
-      endorse or promote products derived from this Software without specific
-      prior written permission.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
-SOFTWARE.
-
-==============================================================================
-
-Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
diff --git a/third_party/libcxx/README.cosmo b/third_party/libcxx/README.cosmo
index 506113754..1aebb72c9 100644
--- a/third_party/libcxx/README.cosmo
+++ b/third_party/libcxx/README.cosmo
@@ -5,14 +5,11 @@ DESCRIPTION
 ORIGIN
 
   git@github.com:llvm/llvm-project.git
-  commit ad0543f4ea82ec41c5e854af65758fa8d92d5553
-  Author: Haojian Wu <hokein.wu@gmail.com>
-  Date:   Thu Jun 1 15:31:43 2023 +0200
+  commit 83c2bfdacb0593b3a72e93098a55afdcd93d865f
+  Date:   Mon Jul 22 10:22:23 2024 -0400
 
 LOCAL CHANGES
 
   - Wrote __config_site
-  - Add __COSMOPOLITAN__ when appropriate
-  - Kludged (and probably broke) awful `cerr` feature
-  - Break apart locale.cpp due to its outrageous build times
-  - Suppress -Wattribute sometimes due to __always_inline__ hack
+  - Add special handling for cosmo errno
+  - Shaped and molded directory structure
diff --git a/third_party/libcxx/__algorithm/adjacent_find.h b/third_party/libcxx/__algorithm/adjacent_find.h
index 30df4a976..6f15456e3 100644
--- a/third_party/libcxx/__algorithm/adjacent_find.h
+++ b/third_party/libcxx/__algorithm/adjacent_find.h
@@ -20,10 +20,13 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Iter, class _Sent, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter
 __adjacent_find(_Iter __first, _Sent __last, _BinaryPredicate&& __pred) {
   if (__first == __last)
     return __first;
@@ -37,17 +40,19 @@ __adjacent_find(_Iter __first, _Sent __last, _BinaryPredicate&& __pred) {
 }
 
 template <class _ForwardIterator, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
 adjacent_find(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
   return std::__adjacent_find(std::move(__first), std::move(__last), __pred);
 }
 
 template <class _ForwardIterator>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
 adjacent_find(_ForwardIterator __first, _ForwardIterator __last) {
   return std::adjacent_find(std::move(__first), std::move(__last), __equal_to());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_ADJACENT_FIND_H
diff --git a/third_party/libcxx/__algorithm/all_of.h b/third_party/libcxx/__algorithm/all_of.h
index 237f8495c..ec84eea75 100644
--- a/third_party/libcxx/__algorithm/all_of.h
+++ b/third_party/libcxx/__algorithm/all_of.h
@@ -19,7 +19,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Predicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
   for (; __first != __last; ++__first)
     if (!__pred(*__first))
diff --git a/third_party/libcxx/__algorithm/any_of.h b/third_party/libcxx/__algorithm/any_of.h
index fe0882816..b5ff778c4 100644
--- a/third_party/libcxx/__algorithm/any_of.h
+++ b/third_party/libcxx/__algorithm/any_of.h
@@ -19,7 +19,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Predicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
   for (; __first != __last; ++__first)
     if (__pred(*__first))
diff --git a/third_party/libcxx/__algorithm/binary_search.h b/third_party/libcxx/__algorithm/binary_search.h
index 8f958c2c1..6065fc372 100644
--- a/third_party/libcxx/__algorithm/binary_search.h
+++ b/third_party/libcxx/__algorithm/binary_search.h
@@ -22,23 +22,16 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
-{
-    __first = std::lower_bound<_ForwardIterator, _Tp, __comp_ref_type<_Compare> >(__first, __last, __value, __comp);
-    return __first != __last && !__comp(__value, *__first);
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
+  __first = std::lower_bound<_ForwardIterator, _Tp, __comp_ref_type<_Compare> >(__first, __last, __value, __comp);
+  return __first != __last && !__comp(__value, *__first);
 }
 
 template <class _ForwardIterator, class _Tp>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
-{
-    return std::binary_search(__first, __last, __value,
-                              __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
+  return std::binary_search(__first, __last, __value, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/clamp.h b/third_party/libcxx/__algorithm/clamp.h
index 336b93fd8..1a5a3d074 100644
--- a/third_party/libcxx/__algorithm/clamp.h
+++ b/third_party/libcxx/__algorithm/clamp.h
@@ -20,24 +20,22 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
-template<class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY constexpr
-const _Tp&
-clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
-{
-    _LIBCPP_ASSERT(!__comp(__hi, __lo), "Bad bounds passed to std::clamp");
-    return __comp(__v, __lo) ? __lo : __comp(__hi, __v) ? __hi : __v;
-
+template <class _Tp, class _Compare>
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&
+clamp(_LIBCPP_LIFETIMEBOUND const _Tp& __v,
+      _LIBCPP_LIFETIMEBOUND const _Tp& __lo,
+      _LIBCPP_LIFETIMEBOUND const _Tp& __hi,
+      _Compare __comp) {
+  _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(!__comp(__hi, __lo), "Bad bounds passed to std::clamp");
+  return __comp(__v, __lo) ? __lo : __comp(__hi, __v) ? __hi : __v;
 }
 
-template<class _Tp>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY constexpr
-const _Tp&
-clamp(const _Tp& __v, const _Tp& __lo, const _Tp& __hi)
-{
-    return _VSTD::clamp(__v, __lo, __hi, __less<_Tp>());
+template <class _Tp>
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&
+clamp(_LIBCPP_LIFETIMEBOUND const _Tp& __v,
+      _LIBCPP_LIFETIMEBOUND const _Tp& __lo,
+      _LIBCPP_LIFETIMEBOUND const _Tp& __hi) {
+  return std::clamp(__v, __lo, __hi, __less<>());
 }
 #endif
 
diff --git a/third_party/libcxx/__algorithm/comp.h b/third_party/libcxx/__algorithm/comp.h
index 1001e42a3..a0fa88d6d 100644
--- a/third_party/libcxx/__algorithm/comp.h
+++ b/third_party/libcxx/__algorithm/comp.h
@@ -10,8 +10,7 @@
 #define _LIBCPP___ALGORITHM_COMP_H
 
 #include <__config>
-#include <__type_traits/integral_constant.h>
-#include <__type_traits/predicate_traits.h>
+#include <__type_traits/desugars_to.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -26,45 +25,24 @@ struct __equal_to {
   }
 };
 
-template <class _Lhs, class _Rhs>
-struct __is_trivial_equality_predicate<__equal_to, _Lhs, _Rhs> : true_type {};
+template <class _Tp, class _Up>
+inline const bool __desugars_to_v<__equal_tag, __equal_to, _Tp, _Up> = true;
 
-template <class _T1, class _T2 = _T1>
-struct __less
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
+// The definition is required because __less is part of the ABI, but it's empty
+// because all comparisons should be transparent.
+template <class _T1 = void, class _T2 = _T1>
+struct __less {};
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _T1& __x, const _T2& __y) const {return __x < __y;}
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _T2& __x, const _T1& __y) const {return __x < __y;}
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _T2& __x, const _T2& __y) const {return __x < __y;}
+template <>
+struct __less<void, void> {
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp& __lhs, const _Up& __rhs) const {
+    return __lhs < __rhs;
+  }
 };
 
-template <class _T1>
-struct __less<_T1, _T1>
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
-};
-
-template <class _T1>
-struct __less<const _T1, _T1>
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
-};
-
-template <class _T1>
-struct __less<_T1, const _T1>
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _T1& __x, const _T1& __y) const {return __x < __y;}
-};
+template <class _Tp>
+inline const bool __desugars_to_v<__less_tag, __less<>, _Tp, _Tp> = true;
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__algorithm/comp_ref_type.h b/third_party/libcxx/__algorithm/comp_ref_type.h
index 55c5ce84a..c367fbb91 100644
--- a/third_party/libcxx/__algorithm/comp_ref_type.h
+++ b/third_party/libcxx/__algorithm/comp_ref_type.h
@@ -9,8 +9,8 @@
 #ifndef _LIBCPP___ALGORITHM_COMP_REF_TYPE_H
 #define _LIBCPP___ALGORITHM_COMP_REF_TYPE_H
 
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__utility/declval.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -20,52 +20,41 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare>
-struct __debug_less
-{
-    _Compare &__comp_;
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI __debug_less(_Compare& __c) : __comp_(__c) {}
+struct __debug_less {
+  _Compare& __comp_;
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI __debug_less(_Compare& __c) : __comp_(__c) {}
 
-    template <class _Tp, class _Up>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
-    bool operator()(const _Tp& __x,  const _Up& __y)
-    {
-        bool __r = __comp_(__x, __y);
-        if (__r)
-            __do_compare_assert(0, __y, __x);
-        return __r;
-    }
+  template <class _Tp, class _Up>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Up& __y) {
+    bool __r = __comp_(__x, __y);
+    if (__r)
+      __do_compare_assert(0, __y, __x);
+    return __r;
+  }
 
-    template <class _Tp, class _Up>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
-    bool operator()(_Tp& __x,  _Up& __y)
-    {
-        bool __r = __comp_(__x, __y);
-        if (__r)
-            __do_compare_assert(0, __y, __x);
-        return __r;
-    }
+  template <class _Tp, class _Up>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(_Tp& __x, _Up& __y) {
+    bool __r = __comp_(__x, __y);
+    if (__r)
+      __do_compare_assert(0, __y, __x);
+    return __r;
+  }
 
-    template <class _LHS, class _RHS>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14
-    inline _LIBCPP_INLINE_VISIBILITY
-    decltype((void)std::declval<_Compare&>()(
-        std::declval<_LHS &>(), std::declval<_RHS &>()))
-    __do_compare_assert(int, _LHS & __l, _RHS & __r) {
-        _LIBCPP_DEBUG_ASSERT(!__comp_(__l, __r),
-            "Comparator does not induce a strict weak ordering");
-        (void)__l;
-        (void)__r;
-    }
+  template <class _LHS, class _RHS>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 inline
+      _LIBCPP_HIDE_FROM_ABI decltype((void)std::declval<_Compare&>()(std::declval<_LHS&>(), std::declval<_RHS&>()))
+      __do_compare_assert(int, _LHS& __l, _RHS& __r) {
+    _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(!__comp_(__l, __r), "Comparator does not induce a strict weak ordering");
+    (void)__l;
+    (void)__r;
+  }
 
-    template <class _LHS, class _RHS>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14
-    inline _LIBCPP_INLINE_VISIBILITY
-    void __do_compare_assert(long, _LHS &, _RHS &) {}
+  template <class _LHS, class _RHS>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 inline _LIBCPP_HIDE_FROM_ABI void __do_compare_assert(long, _LHS&, _RHS&) {}
 };
 
-// Pass the comparator by lvalue reference. Or in debug mode, using a
-// debugging wrapper that stores a reference.
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
+// Pass the comparator by lvalue reference. Or in the debug mode, using a debugging wrapper that stores a reference.
+#if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
 template <class _Comp>
 using __comp_ref_type = __debug_less<_Comp>;
 #else
diff --git a/third_party/libcxx/__algorithm/copy.h b/third_party/libcxx/__algorithm/copy.h
index c29ff8fa7..0890b895f 100644
--- a/third_party/libcxx/__algorithm/copy.h
+++ b/third_party/libcxx/__algorithm/copy.h
@@ -32,7 +32,7 @@ template <class, class _InIter, class _Sent, class _OutIter>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter> __copy(_InIter, _Sent, _OutIter);
 
 template <class _AlgPolicy>
-struct __copy_loop {
+struct __copy_impl {
   template <class _InIter, class _Sent, class _OutIter>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
   operator()(_InIter __first, _Sent __last, _OutIter __result) const {
@@ -51,9 +51,10 @@ struct __copy_loop {
 
     _OutIter& __result_;
 
-    _LIBCPP_HIDE_FROM_ABI _CopySegment(_OutIter& __result) : __result_(__result) {}
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit _CopySegment(_OutIter& __result)
+        : __result_(__result) {}
 
-    _LIBCPP_HIDE_FROM_ABI void
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
     operator()(typename _Traits::__local_iterator __lfirst, typename _Traits::__local_iterator __llast) {
       __result_ = std::__copy<_AlgPolicy>(__lfirst, __llast, std::move(__result_)).second;
     }
@@ -72,7 +73,7 @@ struct __copy_loop {
                               !__is_segmented_iterator<_InIter>::value && __is_segmented_iterator<_OutIter>::value,
                           int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
-  operator()(_InIter __first, _InIter __last, _OutIter __result) {
+  operator()(_InIter __first, _InIter __last, _OutIter __result) const {
     using _Traits = __segmented_iterator_traits<_OutIter>;
     using _DiffT  = typename common_type<__iter_diff_t<_InIter>, __iter_diff_t<_OutIter> >::type;
 
@@ -93,9 +94,7 @@ struct __copy_loop {
       __local_first = _Traits::__begin(++__segment_iterator);
     }
   }
-};
 
-struct __copy_trivial {
   // At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
   template <class _In, class _Out, __enable_if_t<__can_lower_copy_assignment_to_memmove<_In, _Out>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
@@ -107,12 +106,12 @@ struct __copy_trivial {
 template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
 pair<_InIter, _OutIter> inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
 __copy(_InIter __first, _Sent __last, _OutIter __result) {
-  return std::__dispatch_copy_or_move<_AlgPolicy, __copy_loop<_AlgPolicy>, __copy_trivial>(
+  return std::__copy_move_unwrap_iters<__copy_impl<_AlgPolicy> >(
       std::move(__first), std::move(__last), std::move(__result));
 }
 
 template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
 copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
   return std::__copy<_ClassicAlgPolicy>(__first, __last, __result).second;
 }
diff --git a/third_party/libcxx/__algorithm/copy_backward.h b/third_party/libcxx/__algorithm/copy_backward.h
index 5bc93c625..73dc846a9 100644
--- a/third_party/libcxx/__algorithm/copy_backward.h
+++ b/third_party/libcxx/__algorithm/copy_backward.h
@@ -15,7 +15,7 @@
 #include <__config>
 #include <__iterator/segmented_iterator.h>
 #include <__type_traits/common_type.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 
@@ -33,7 +33,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InIter, _OutIter>
 __copy_backward(_InIter __first, _Sent __last, _OutIter __result);
 
 template <class _AlgPolicy>
-struct __copy_backward_loop {
+struct __copy_backward_impl {
   template <class _InIter, class _Sent, class _OutIter>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
   operator()(_InIter __first, _Sent __last, _OutIter __result) const {
@@ -80,7 +80,7 @@ struct __copy_backward_loop {
                               !__is_segmented_iterator<_InIter>::value && __is_segmented_iterator<_OutIter>::value,
                           int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
-  operator()(_InIter __first, _InIter __last, _OutIter __result) {
+  operator()(_InIter __first, _InIter __last, _OutIter __result) const {
     using _Traits           = __segmented_iterator_traits<_OutIter>;
     auto __orig_last        = __last;
     auto __segment_iterator = _Traits::__segment(__result);
@@ -104,12 +104,9 @@ struct __copy_backward_loop {
       __local_last = _Traits::__end(__segment_iterator);
     }
   }
-};
 
-struct __copy_backward_trivial {
   // At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
-  template <class _In, class _Out,
-            __enable_if_t<__can_lower_copy_assignment_to_memmove<_In, _Out>::value, int> = 0>
+  template <class _In, class _Out, __enable_if_t<__can_lower_copy_assignment_to_memmove<_In, _Out>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
   operator()(_In* __first, _In* __last, _Out* __result) const {
     return std::__copy_backward_trivial_impl(__first, __last, __result);
@@ -119,21 +116,18 @@ struct __copy_backward_trivial {
 template <class _AlgPolicy, class _BidirectionalIterator1, class _Sentinel, class _BidirectionalIterator2>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_BidirectionalIterator1, _BidirectionalIterator2>
 __copy_backward(_BidirectionalIterator1 __first, _Sentinel __last, _BidirectionalIterator2 __result) {
-  return std::__dispatch_copy_or_move<_AlgPolicy, __copy_backward_loop<_AlgPolicy>, __copy_backward_trivial>(
+  return std::__copy_move_unwrap_iters<__copy_backward_impl<_AlgPolicy> >(
       std::move(__first), std::move(__last), std::move(__result));
 }
 
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_BidirectionalIterator2
-copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
-              _BidirectionalIterator2 __result)
-{
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _BidirectionalIterator2
+copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, _BidirectionalIterator2 __result) {
   static_assert(std::is_copy_constructible<_BidirectionalIterator1>::value &&
-                std::is_copy_constructible<_BidirectionalIterator1>::value, "Iterators must be copy constructible.");
+                    std::is_copy_constructible<_BidirectionalIterator1>::value,
+                "Iterators must be copy constructible.");
 
-  return std::__copy_backward<_ClassicAlgPolicy>(
-      std::move(__first), std::move(__last), std::move(__result)).second;
+  return std::__copy_backward<_ClassicAlgPolicy>(std::move(__first), std::move(__last), std::move(__result)).second;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/copy_if.h b/third_party/libcxx/__algorithm/copy_if.h
index a5938b871..228e4d223 100644
--- a/third_party/libcxx/__algorithm/copy_if.h
+++ b/third_party/libcxx/__algorithm/copy_if.h
@@ -17,21 +17,16 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _InputIterator, class _OutputIterator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-copy_if(_InputIterator __first, _InputIterator __last,
-        _OutputIterator __result, _Predicate __pred)
-{
-    for (; __first != __last; ++__first)
-    {
-        if (__pred(*__first))
-        {
-            *__result = *__first;
-            ++__result;
-        }
+template <class _InputIterator, class _OutputIterator, class _Predicate>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) {
+  for (; __first != __last; ++__first) {
+    if (__pred(*__first)) {
+      *__result = *__first;
+      ++__result;
     }
-    return __result;
+  }
+  return __result;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/copy_move_common.h b/third_party/libcxx/__algorithm/copy_move_common.h
index b88c14911..8a98451a8 100644
--- a/third_party/libcxx/__algorithm/copy_move_common.h
+++ b/third_party/libcxx/__algorithm/copy_move_common.h
@@ -15,12 +15,12 @@
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__memory/pointer_traits.h>
+#include <__string/constexpr_c_functions.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_always_bitcastable.h>
 #include <__type_traits/is_constant_evaluated.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/is_trivially_assignable.h>
-#include <__type_traits/is_trivially_copyable.h>
 #include <__type_traits/is_volatile.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
@@ -30,6 +30,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Type traits.
@@ -37,22 +40,19 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _From, class _To>
 struct __can_lower_copy_assignment_to_memmove {
   static const bool value =
-    // If the types are always bitcastable, it's valid to do a bitwise copy between them.
-    __is_always_bitcastable<_From, _To>::value &&
-    // Reject conversions that wouldn't be performed by the regular built-in assignment (e.g. between arrays).
-    is_trivially_assignable<_To&, const _From&>::value &&
-    // `memmove` doesn't accept `volatile` pointers, make sure the optimization SFINAEs away in that case.
-    !is_volatile<_From>::value &&
-    !is_volatile<_To>::value;
+      // If the types are always bitcastable, it's valid to do a bitwise copy between them.
+      __is_always_bitcastable<_From, _To>::value &&
+      // Reject conversions that wouldn't be performed by the regular built-in assignment (e.g. between arrays).
+      is_trivially_assignable<_To&, const _From&>::value &&
+      // `memmove` doesn't accept `volatile` pointers, make sure the optimization SFINAEs away in that case.
+      !is_volatile<_From>::value && !is_volatile<_To>::value;
 };
 
 template <class _From, class _To>
 struct __can_lower_move_assignment_to_memmove {
   static const bool value =
-    __is_always_bitcastable<_From, _To>::value &&
-    is_trivially_assignable<_To&, _From&&>::value &&
-    !is_volatile<_From>::value &&
-    !is_volatile<_To>::value;
+      __is_always_bitcastable<_From, _To>::value && is_trivially_assignable<_To&, _From&&>::value &&
+      !is_volatile<_From>::value && !is_volatile<_To>::value;
 };
 
 // `memmove` algorithms implementation.
@@ -61,7 +61,8 @@ template <class _In, class _Out>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
 __copy_trivial_impl(_In* __first, _In* __last, _Out* __result) {
   const size_t __n = static_cast<size_t>(__last - __first);
-  ::__builtin_memmove(__result, __first, __n * sizeof(_Out));
+
+  std::__constexpr_memmove(__result, __first, __element_count(__n));
 
   return std::make_pair(__last, __result + __n);
 }
@@ -72,92 +73,42 @@ __copy_backward_trivial_impl(_In* __first, _In* __last, _Out* __result) {
   const size_t __n = static_cast<size_t>(__last - __first);
   __result -= __n;
 
-  ::__builtin_memmove(__result, __first, __n * sizeof(_Out));
+  std::__constexpr_memmove(__result, __first, __element_count(__n));
 
   return std::make_pair(__last, __result);
 }
 
 // Iterator unwrapping and dispatching to the correct overload.
 
-template <class _F1, class _F2>
-struct __overload : _F1, _F2 {
-  using _F1::operator();
-  using _F2::operator();
-};
-
-template <class _InIter, class _Sent, class _OutIter, class = void>
-struct __can_rewrap : false_type {};
-
-template <class _InIter, class _Sent, class _OutIter>
-struct __can_rewrap<_InIter,
-                    _Sent,
-                    _OutIter,
-                    // Note that sentinels are always copy-constructible.
-                    __enable_if_t< is_copy_constructible<_InIter>::value &&
-                                   is_copy_constructible<_OutIter>::value > > : true_type {};
+template <class _InIter, class _OutIter>
+struct __can_rewrap
+    : integral_constant<bool, is_copy_constructible<_InIter>::value && is_copy_constructible<_OutIter>::value> {};
 
 template <class _Algorithm,
           class _InIter,
           class _Sent,
           class _OutIter,
-          __enable_if_t<__can_rewrap<_InIter, _Sent, _OutIter>::value, int> = 0>
+          __enable_if_t<__can_rewrap<_InIter, _OutIter>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pair<_InIter, _OutIter>
-__unwrap_and_dispatch(_InIter __first, _Sent __last, _OutIter __out_first) {
+__copy_move_unwrap_iters(_InIter __first, _Sent __last, _OutIter __out_first) {
   auto __range  = std::__unwrap_range(__first, std::move(__last));
   auto __result = _Algorithm()(std::move(__range.first), std::move(__range.second), std::__unwrap_iter(__out_first));
   return std::make_pair(std::__rewrap_range<_Sent>(std::move(__first), std::move(__result.first)),
-                                 std::__rewrap_iter(std::move(__out_first), std::move(__result.second)));
+                        std::__rewrap_iter(std::move(__out_first), std::move(__result.second)));
 }
 
 template <class _Algorithm,
           class _InIter,
           class _Sent,
           class _OutIter,
-          __enable_if_t<!__can_rewrap<_InIter, _Sent, _OutIter>::value, int> = 0>
+          __enable_if_t<!__can_rewrap<_InIter, _OutIter>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pair<_InIter, _OutIter>
-__unwrap_and_dispatch(_InIter __first, _Sent __last, _OutIter __out_first) {
+__copy_move_unwrap_iters(_InIter __first, _Sent __last, _OutIter __out_first) {
   return _Algorithm()(std::move(__first), std::move(__last), std::move(__out_first));
 }
 
-template <class _IterOps, class _InValue, class _OutIter, class = void>
-struct __can_copy_without_conversion : false_type {};
-
-template <class _IterOps, class _InValue, class _OutIter>
-struct __can_copy_without_conversion<
-    _IterOps,
-    _InValue,
-    _OutIter,
-    __enable_if_t<is_same<_InValue, typename _IterOps::template __value_type<_OutIter> >::value> > : true_type {};
-
-template <class _AlgPolicy,
-          class _NaiveAlgorithm,
-          class _OptimizedAlgorithm,
-          class _InIter,
-          class _Sent,
-          class _OutIter>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pair<_InIter, _OutIter>
-__dispatch_copy_or_move(_InIter __first, _Sent __last, _OutIter __out_first) {
-#ifdef _LIBCPP_COMPILER_GCC
-  // GCC doesn't support `__builtin_memmove` during constant evaluation.
-  if (__libcpp_is_constant_evaluated()) {
-    return std::__unwrap_and_dispatch<_NaiveAlgorithm>(std::move(__first), std::move(__last), std::move(__out_first));
-  }
-#else
-  // In Clang, `__builtin_memmove` only supports fully trivially copyable types (just having trivial copy assignment is
-  // insufficient). Also, conversions are not supported.
-  if (__libcpp_is_constant_evaluated()) {
-    using _InValue = typename _IterOps<_AlgPolicy>::template __value_type<_InIter>;
-    if (!is_trivially_copyable<_InValue>::value ||
-        !__can_copy_without_conversion<_IterOps<_AlgPolicy>, _InValue, _OutIter>::value) {
-      return std::__unwrap_and_dispatch<_NaiveAlgorithm>(std::move(__first), std::move(__last), std::move(__out_first));
-    }
-  }
-#endif // _LIBCPP_COMPILER_GCC
-
-  using _Algorithm = __overload<_NaiveAlgorithm, _OptimizedAlgorithm>;
-  return std::__unwrap_and_dispatch<_Algorithm>(std::move(__first), std::move(__last), std::move(__out_first));
-}
-
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_COPY_MOVE_COMMON_H
diff --git a/third_party/libcxx/__algorithm/copy_n.h b/third_party/libcxx/__algorithm/copy_n.h
index f3701662a..f93f39203 100644
--- a/third_party/libcxx/__algorithm/copy_n.h
+++ b/third_party/libcxx/__algorithm/copy_n.h
@@ -21,45 +21,38 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _InputIterator, class _Size, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __has_input_iterator_category<_InputIterator>::value &&
-   !__has_random_access_iterator_category<_InputIterator>::value,
-    _OutputIterator
->::type
-copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
-{
-    typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
-    _IntegralSize __n = __orig_n;
-    if (__n > 0)
-    {
-        *__result = *__first;
-        ++__result;
-        for (--__n; __n > 0; --__n)
-        {
-            ++__first;
-            *__result = *__first;
-            ++__result;
-        }
+template <class _InputIterator,
+          class _Size,
+          class _OutputIterator,
+          __enable_if_t<__has_input_iterator_category<_InputIterator>::value &&
+                            !__has_random_access_iterator_category<_InputIterator>::value,
+                        int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) {
+  typedef decltype(std::__convert_to_integral(__orig_n)) _IntegralSize;
+  _IntegralSize __n = __orig_n;
+  if (__n > 0) {
+    *__result = *__first;
+    ++__result;
+    for (--__n; __n > 0; --__n) {
+      ++__first;
+      *__result = *__first;
+      ++__result;
     }
-    return __result;
+  }
+  return __result;
 }
 
-template<class _InputIterator, class _Size, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __has_random_access_iterator_category<_InputIterator>::value,
-    _OutputIterator
->::type
-copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result)
-{
-    typedef typename iterator_traits<_InputIterator>::difference_type difference_type;
-    typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
-    _IntegralSize __n = __orig_n;
-    return _VSTD::copy(__first, __first + difference_type(__n), __result);
+template <class _InputIterator,
+          class _Size,
+          class _OutputIterator,
+          __enable_if_t<__has_random_access_iterator_category<_InputIterator>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) {
+  typedef typename iterator_traits<_InputIterator>::difference_type difference_type;
+  typedef decltype(std::__convert_to_integral(__orig_n)) _IntegralSize;
+  _IntegralSize __n = __orig_n;
+  return std::copy(__first, __first + difference_type(__n), __result);
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/count.h b/third_party/libcxx/__algorithm/count.h
index 6c8c7fda3..1cfe7f631 100644
--- a/third_party/libcxx/__algorithm/count.h
+++ b/third_party/libcxx/__algorithm/count.h
@@ -10,26 +10,83 @@
 #ifndef _LIBCPP___ALGORITHM_COUNT_H
 #define _LIBCPP___ALGORITHM_COUNT_H
 
+#include <__algorithm/iterator_operations.h>
+#include <__algorithm/min.h>
+#include <__bit/invert_if.h>
+#include <__bit/popcount.h>
 #include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__fwd/bit_reference.h>
 #include <__iterator/iterator_traits.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIterator, class _Tp>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    typename iterator_traits<_InputIterator>::difference_type
-    count(_InputIterator __first, _InputIterator __last, const _Tp& __value) {
-  typename iterator_traits<_InputIterator>::difference_type __r(0);
+// generic implementation
+template <class _AlgPolicy, class _Iter, class _Sent, class _Tp, class _Proj>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename _IterOps<_AlgPolicy>::template __difference_type<_Iter>
+__count(_Iter __first, _Sent __last, const _Tp& __value, _Proj& __proj) {
+  typename _IterOps<_AlgPolicy>::template __difference_type<_Iter> __r(0);
   for (; __first != __last; ++__first)
-    if (*__first == __value)
+    if (std::__invoke(__proj, *__first) == __value)
       ++__r;
   return __r;
 }
 
+// __bit_iterator implementation
+template <bool _ToCount, class _Cp, bool _IsConst>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __bit_iterator<_Cp, _IsConst>::difference_type
+__count_bool(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n) {
+  using _It             = __bit_iterator<_Cp, _IsConst>;
+  using __storage_type  = typename _It::__storage_type;
+  using difference_type = typename _It::difference_type;
+
+  const int __bits_per_word = _It::__bits_per_word;
+  difference_type __r       = 0;
+  // do first partial word
+  if (__first.__ctz_ != 0) {
+    __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+    __storage_type __dn    = std::min(__clz_f, __n);
+    __storage_type __m     = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+    __r                    = std::__libcpp_popcount(std::__invert_if<!_ToCount>(*__first.__seg_) & __m);
+    __n -= __dn;
+    ++__first.__seg_;
+  }
+  // do middle whole words
+  for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
+    __r += std::__libcpp_popcount(std::__invert_if<!_ToCount>(*__first.__seg_));
+  // do last partial word
+  if (__n > 0) {
+    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+    __r += std::__libcpp_popcount(std::__invert_if<!_ToCount>(*__first.__seg_) & __m);
+  }
+  return __r;
+}
+
+template <class, class _Cp, bool _IsConst, class _Tp, class _Proj, __enable_if_t<__is_identity<_Proj>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __iter_diff_t<__bit_iterator<_Cp, _IsConst> >
+__count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value, _Proj&) {
+  if (__value)
+    return std::__count_bool<true>(__first, static_cast<typename _Cp::size_type>(__last - __first));
+  return std::__count_bool<false>(__first, static_cast<typename _Cp::size_type>(__last - __first));
+}
+
+template <class _InputIterator, class _Tp>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __iter_diff_t<_InputIterator>
+count(_InputIterator __first, _InputIterator __last, const _Tp& __value) {
+  __identity __proj;
+  return std::__count<_ClassicAlgPolicy>(__first, __last, __value, __proj);
+}
+
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_COUNT_H
diff --git a/third_party/libcxx/__algorithm/count_if.h b/third_party/libcxx/__algorithm/count_if.h
index b96521fe0..25782069d 100644
--- a/third_party/libcxx/__algorithm/count_if.h
+++ b/third_party/libcxx/__algorithm/count_if.h
@@ -20,9 +20,9 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Predicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    typename iterator_traits<_InputIterator>::difference_type
-    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+typename iterator_traits<_InputIterator>::difference_type
+count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
   typename iterator_traits<_InputIterator>::difference_type __r(0);
   for (; __first != __last; ++__first)
     if (__pred(*__first))
diff --git a/third_party/libcxx/__algorithm/equal.h b/third_party/libcxx/__algorithm/equal.h
index c07d4e208..bfc8f72f6 100644
--- a/third_party/libcxx/__algorithm/equal.h
+++ b/third_party/libcxx/__algorithm/equal.h
@@ -18,18 +18,20 @@
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__string/constexpr_c_functions.h>
+#include <__type_traits/desugars_to.h>
 #include <__type_traits/enable_if.h>
-#include <__type_traits/integral_constant.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_equality_comparable.h>
 #include <__type_traits/is_volatile.h>
-#include <__type_traits/predicate_traits.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
@@ -41,41 +43,31 @@ _LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 boo
   return true;
 }
 
-template <
-    class _Tp,
-    class _Up,
-    class _BinaryPredicate,
-    __enable_if_t<__is_trivial_equality_predicate<_BinaryPredicate, _Tp, _Up>::value && !is_volatile<_Tp>::value &&
-                      !is_volatile<_Up>::value && __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
-                  int> = 0>
+template <class _Tp,
+          class _Up,
+          class _BinaryPredicate,
+          __enable_if_t<__desugars_to_v<__equal_tag, _BinaryPredicate, _Tp, _Up> && !is_volatile<_Tp>::value &&
+                            !is_volatile<_Up>::value && __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
+                        int> = 0>
 _LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 __equal_iter_impl(_Tp* __first1, _Tp* __last1, _Up* __first2, _BinaryPredicate&) {
-  return std::__constexpr_memcmp_equal(__first1, __first2, (__last1 - __first1) * sizeof(_Tp));
+  return std::__constexpr_memcmp_equal(__first1, __first2, __element_count(__last1 - __first1));
 }
 
 template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) {
   return std::__equal_iter_impl(
       std::__unwrap_iter(__first1), std::__unwrap_iter(__last1), std::__unwrap_iter(__first2), __pred);
 }
 
 template <class _InputIterator1, class _InputIterator2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) {
   return std::equal(__first1, __last1, __first2, __equal_to());
 }
 
 #if _LIBCPP_STD_VER >= 14
-template <class _BinaryPredicate, class _InputIterator1, class _InputIterator2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
-        _BinaryPredicate __pred, input_iterator_tag, input_iterator_tag) {
-  for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2)
-    if (!__pred(*__first1, *__first2))
-      return false;
-  return __first1 == __last1 && __first2 == __last2;
-}
 
 template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
 _LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_impl(
@@ -94,22 +86,27 @@ template <class _Tp,
           class _Pred,
           class _Proj1,
           class _Proj2,
-          __enable_if_t<__is_trivial_equality_predicate<_Pred, _Tp, _Up>::value && __is_identity<_Proj1>::value &&
+          __enable_if_t<__desugars_to_v<__equal_tag, _Pred, _Tp, _Up> && __is_identity<_Proj1>::value &&
                             __is_identity<_Proj2>::value && !is_volatile<_Tp>::value && !is_volatile<_Up>::value &&
                             __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
                         int> = 0>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_impl(
-    _Tp* __first1, _Tp* __last1, _Up* __first2, _Up*, _Pred&, _Proj1&, _Proj2&) {
-  return std::__constexpr_memcmp_equal(__first1, __first2, (__last1 - __first1) * sizeof(_Tp));
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+__equal_impl(_Tp* __first1, _Tp* __last1, _Up* __first2, _Up*, _Pred&, _Proj1&, _Proj2&) {
+  return std::__constexpr_memcmp_equal(__first1, __first2, __element_count(__last1 - __first1));
 }
 
-template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _RandomAccessIterator2 __first2,
-        _RandomAccessIterator2 __last2, _BinaryPredicate __pred, random_access_iterator_tag,
-        random_access_iterator_tag) {
-  if (_VSTD::distance(__first1, __last1) != _VSTD::distance(__first2, __last2))
-    return false;
+template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+equal(_InputIterator1 __first1,
+      _InputIterator1 __last1,
+      _InputIterator2 __first2,
+      _InputIterator2 __last2,
+      _BinaryPredicate __pred) {
+  if constexpr (__has_random_access_iterator_category<_InputIterator1>::value &&
+                __has_random_access_iterator_category<_InputIterator2>::value) {
+    if (std::distance(__first1, __last1) != std::distance(__first2, __last2))
+      return false;
+  }
   __identity __proj;
   return std::__equal_impl(
       std::__unwrap_iter(__first1),
@@ -121,29 +118,16 @@ __equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1, _Random
       __proj);
 }
 
-template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
-      _BinaryPredicate __pred) {
-  return _VSTD::__equal<_BinaryPredicate&>(
-      __first1, __last1, __first2, __last2, __pred, typename iterator_traits<_InputIterator1>::iterator_category(),
-      typename iterator_traits<_InputIterator2>::iterator_category());
+template <class _InputIterator1, class _InputIterator2>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
+  return std::equal(__first1, __last1, __first2, __last2, __equal_to());
 }
 
-template <class _InputIterator1, class _InputIterator2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
-  return std::__equal(
-      __first1,
-      __last1,
-      __first2,
-      __last2,
-      __equal_to(),
-      typename iterator_traits<_InputIterator1>::iterator_category(),
-      typename iterator_traits<_InputIterator2>::iterator_category());
-}
-#endif
+#endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_EQUAL_H
diff --git a/third_party/libcxx/__algorithm/equal_range.h b/third_party/libcxx/__algorithm/equal_range.h
index 2075b0341..09bbf8f00 100644
--- a/third_party/libcxx/__algorithm/equal_range.h
+++ b/third_party/libcxx/__algorithm/equal_range.h
@@ -23,7 +23,7 @@
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__type_traits/is_callable.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 
@@ -31,6 +31,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _Iter, class _Sent, class _Tp, class _Proj>
@@ -49,21 +52,18 @@ __equal_range(_Iter __first, _Sent __last, const _Tp& __value, _Compare&& __comp
       __len = __half_len;
     } else {
       _Iter __mp1 = __mid;
-      return pair<_Iter, _Iter>(
-          std::__lower_bound_impl<_AlgPolicy>(__first, __mid, __value, __comp, __proj),
-          std::__upper_bound<_AlgPolicy>(++__mp1, __end, __value, __comp, __proj));
+      return pair<_Iter, _Iter>(std::__lower_bound<_AlgPolicy>(__first, __mid, __value, __comp, __proj),
+                                std::__upper_bound<_AlgPolicy>(++__mp1, __end, __value, __comp, __proj));
     }
   }
   return pair<_Iter, _Iter>(__first, __first);
 }
 
 template <class _ForwardIterator, class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_ForwardIterator, _ForwardIterator>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_ForwardIterator, _ForwardIterator>
 equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
-  static_assert(__is_callable<_Compare, decltype(*__first), const _Tp&>::value,
-                "The comparator has to be callable");
-  static_assert(is_copy_constructible<_ForwardIterator>::value,
-                "Iterator has to be copy constructible");
+  static_assert(__is_callable<_Compare, decltype(*__first), const _Tp&>::value, "The comparator has to be callable");
+  static_assert(is_copy_constructible<_ForwardIterator>::value, "Iterator has to be copy constructible");
   return std::__equal_range<_ClassicAlgPolicy>(
       std::move(__first),
       std::move(__last),
@@ -73,15 +73,13 @@ equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __valu
 }
 
 template <class _ForwardIterator, class _Tp>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_ForwardIterator, _ForwardIterator>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_ForwardIterator, _ForwardIterator>
 equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
-  return std::equal_range(
-      std::move(__first),
-      std::move(__last),
-      __value,
-      __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
+  return std::equal_range(std::move(__first), std::move(__last), __value, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_EQUAL_RANGE_H
diff --git a/third_party/libcxx/__algorithm/fill.h b/third_party/libcxx/__algorithm/fill.h
index 0753c427a..1ce3eadb0 100644
--- a/third_party/libcxx/__algorithm/fill.h
+++ b/third_party/libcxx/__algorithm/fill.h
@@ -22,28 +22,22 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // fill isn't specialized for std::memset, because the compiler already optimizes the loop to a call to std::memset.
 
 template <class _ForwardIterator, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, forward_iterator_tag)
-{
-    for (; __first != __last; ++__first)
-        *__first = __value;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, forward_iterator_tag) {
+  for (; __first != __last; ++__first)
+    *__first = __value;
 }
 
 template <class _RandomAccessIterator, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value, random_access_iterator_tag)
-{
-    _VSTD::fill_n(__first, __last - __first, __value);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value, random_access_iterator_tag) {
+  std::fill_n(__first, __last - __first, __value);
 }
 
 template <class _ForwardIterator, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
-{
-    _VSTD::__fill(__first, __last, __value, typename iterator_traits<_ForwardIterator>::iterator_category());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
+  std::__fill(__first, __last, __value, typename iterator_traits<_ForwardIterator>::iterator_category());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/fill_n.h b/third_party/libcxx/__algorithm/fill_n.h
index e7863ac7e..f29633f88 100644
--- a/third_party/libcxx/__algorithm/fill_n.h
+++ b/third_party/libcxx/__algorithm/fill_n.h
@@ -9,36 +9,90 @@
 #ifndef _LIBCPP___ALGORITHM_FILL_N_H
 #define _LIBCPP___ALGORITHM_FILL_N_H
 
+#include <__algorithm/min.h>
 #include <__config>
+#include <__fwd/bit_reference.h>
 #include <__iterator/iterator_traits.h>
+#include <__memory/pointer_traits.h>
 #include <__utility/convert_to_integral.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // fill_n isn't specialized for std::memset, because the compiler already optimizes the loop to a call to std::memset.
 
 template <class _OutputIterator, class _Size, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
-{
-    for (; __n > 0; ++__first, (void) --__n)
-        *__first = __value;
-    return __first;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value);
+
+template <bool _FillVal, class _Cp>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+__fill_n_bool(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n) {
+  using _It            = __bit_iterator<_Cp, false>;
+  using __storage_type = typename _It::__storage_type;
+
+  const int __bits_per_word = _It::__bits_per_word;
+  // do first partial word
+  if (__first.__ctz_ != 0) {
+    __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+    __storage_type __dn    = std::min(__clz_f, __n);
+    __storage_type __m     = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+    if (_FillVal)
+      *__first.__seg_ |= __m;
+    else
+      *__first.__seg_ &= ~__m;
+    __n -= __dn;
+    ++__first.__seg_;
+  }
+  // do middle whole words
+  __storage_type __nw = __n / __bits_per_word;
+  std::__fill_n(std::__to_address(__first.__seg_), __nw, _FillVal ? static_cast<__storage_type>(-1) : 0);
+  __n -= __nw * __bits_per_word;
+  // do last partial word
+  if (__n > 0) {
+    __first.__seg_ += __nw;
+    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+    if (_FillVal)
+      *__first.__seg_ |= __m;
+    else
+      *__first.__seg_ &= ~__m;
+  }
+}
+
+template <class _Cp, class _Size>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, false>
+__fill_n(__bit_iterator<_Cp, false> __first, _Size __n, const bool& __value) {
+  if (__n > 0) {
+    if (__value)
+      std::__fill_n_bool<true>(__first, __n);
+    else
+      std::__fill_n_bool<false>(__first, __n);
+  }
+  return __first + __n;
 }
 
 template <class _OutputIterator, class _Size, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
-{
-   return _VSTD::__fill_n(__first, _VSTD::__convert_to_integral(__n), __value);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) {
+  for (; __n > 0; ++__first, (void)--__n)
+    *__first = __value;
+  return __first;
+}
+
+template <class _OutputIterator, class _Size, class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) {
+  return std::__fill_n(__first, std::__convert_to_integral(__n), __value);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_FILL_N_H
diff --git a/third_party/libcxx/__algorithm/find.h b/third_party/libcxx/__algorithm/find.h
index e0de50328..7f58dbb13 100644
--- a/third_party/libcxx/__algorithm/find.h
+++ b/third_party/libcxx/__algorithm/find.h
@@ -10,12 +10,22 @@
 #ifndef _LIBCPP___ALGORITHM_FIND_H
 #define _LIBCPP___ALGORITHM_FIND_H
 
+#include <__algorithm/find_segment_if.h>
+#include <__algorithm/min.h>
 #include <__algorithm/unwrap_iter.h>
+#include <__bit/countr.h>
+#include <__bit/invert_if.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
+#include <__fwd/bit_reference.h>
+#include <__iterator/segmented_iterator.h>
 #include <__string/constexpr_c_functions.h>
+#include <__type_traits/is_integral.h>
 #include <__type_traits/is_same.h>
+#include <__type_traits/is_signed.h>
+#include <__utility/move.h>
+#include <limits>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <cwchar>
@@ -25,25 +35,29 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+// generic implementation
 template <class _Iter, class _Sent, class _Tp, class _Proj>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Iter
-__find_impl(_Iter __first, _Sent __last, const _Tp& __value, _Proj& __proj) {
+__find(_Iter __first, _Sent __last, const _Tp& __value, _Proj& __proj) {
   for (; __first != __last; ++__first)
     if (std::__invoke(__proj, *__first) == __value)
       break;
   return __first;
 }
 
+// trivially equality comparable implementations
 template <class _Tp,
           class _Up,
           class _Proj,
           __enable_if_t<__is_identity<_Proj>::value && __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value &&
                             sizeof(_Tp) == 1,
                         int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp*
-__find_impl(_Tp* __first, _Tp* __last, const _Up& __value, _Proj&) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __find(_Tp* __first, _Tp* __last, const _Up& __value, _Proj&) {
   if (auto __ret = std::__constexpr_memchr(__first, __value, __last - __first))
     return __ret;
   return __last;
@@ -56,22 +70,112 @@ template <class _Tp,
           __enable_if_t<__is_identity<_Proj>::value && __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value &&
                             sizeof(_Tp) == sizeof(wchar_t) && _LIBCPP_ALIGNOF(_Tp) >= _LIBCPP_ALIGNOF(wchar_t),
                         int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp*
-__find_impl(_Tp* __first, _Tp* __last, const _Up& __value, _Proj&) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __find(_Tp* __first, _Tp* __last, const _Up& __value, _Proj&) {
   if (auto __ret = std::__constexpr_wmemchr(__first, __value, __last - __first))
     return __ret;
   return __last;
 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
+// TODO: This should also be possible to get right with different signedness
+// cast integral types to allow vectorization
+template <class _Tp,
+          class _Up,
+          class _Proj,
+          __enable_if_t<__is_identity<_Proj>::value && !__libcpp_is_trivially_equality_comparable<_Tp, _Up>::value &&
+                            is_integral<_Tp>::value && is_integral<_Up>::value &&
+                            is_signed<_Tp>::value == is_signed<_Up>::value,
+                        int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp*
+__find(_Tp* __first, _Tp* __last, const _Up& __value, _Proj& __proj) {
+  if (__value < numeric_limits<_Tp>::min() || __value > numeric_limits<_Tp>::max())
+    return __last;
+  return std::__find(__first, __last, _Tp(__value), __proj);
+}
+
+// __bit_iterator implementation
+template <bool _ToFind, class _Cp, bool _IsConst>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, _IsConst>
+__find_bool(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n) {
+  using _It            = __bit_iterator<_Cp, _IsConst>;
+  using __storage_type = typename _It::__storage_type;
+
+  const int __bits_per_word = _It::__bits_per_word;
+  // do first partial word
+  if (__first.__ctz_ != 0) {
+    __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
+    __storage_type __dn    = std::min(__clz_f, __n);
+    __storage_type __m     = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+    __storage_type __b     = std::__invert_if<!_ToFind>(*__first.__seg_) & __m;
+    if (__b)
+      return _It(__first.__seg_, static_cast<unsigned>(std::__libcpp_ctz(__b)));
+    if (__n == __dn)
+      return __first + __n;
+    __n -= __dn;
+    ++__first.__seg_;
+  }
+  // do middle whole words
+  for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word) {
+    __storage_type __b = std::__invert_if<!_ToFind>(*__first.__seg_);
+    if (__b)
+      return _It(__first.__seg_, static_cast<unsigned>(std::__libcpp_ctz(__b)));
+  }
+  // do last partial word
+  if (__n > 0) {
+    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+    __storage_type __b = std::__invert_if<!_ToFind>(*__first.__seg_) & __m;
+    if (__b)
+      return _It(__first.__seg_, static_cast<unsigned>(std::__libcpp_ctz(__b)));
+  }
+  return _It(__first.__seg_, static_cast<unsigned>(__n));
+}
+
+template <class _Cp, bool _IsConst, class _Tp, class _Proj, __enable_if_t<__is_identity<_Proj>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, _IsConst>
+__find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value, _Proj&) {
+  if (static_cast<bool>(__value))
+    return std::__find_bool<true>(__first, static_cast<typename _Cp::size_type>(__last - __first));
+  return std::__find_bool<false>(__first, static_cast<typename _Cp::size_type>(__last - __first));
+}
+
+// segmented iterator implementation
+
+template <class>
+struct __find_segment;
+
+template <class _SegmentedIterator,
+          class _Tp,
+          class _Proj,
+          __enable_if_t<__is_segmented_iterator<_SegmentedIterator>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _SegmentedIterator
+__find(_SegmentedIterator __first, _SegmentedIterator __last, const _Tp& __value, _Proj& __proj) {
+  return std::__find_segment_if(std::move(__first), std::move(__last), __find_segment<_Tp>(__value), __proj);
+}
+
+template <class _Tp>
+struct __find_segment {
+  const _Tp& __value_;
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __find_segment(const _Tp& __value) : __value_(__value) {}
+
+  template <class _InputIterator, class _Proj>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _InputIterator
+  operator()(_InputIterator __first, _InputIterator __last, _Proj& __proj) const {
+    return std::__find(__first, __last, __value_, __proj);
+  }
+};
+
+// public API
 template <class _InputIterator, class _Tp>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
 find(_InputIterator __first, _InputIterator __last, const _Tp& __value) {
   __identity __proj;
   return std::__rewrap_iter(
-      __first, std::__find_impl(std::__unwrap_iter(__first), std::__unwrap_iter(__last), __value, __proj));
+      __first, std::__find(std::__unwrap_iter(__first), std::__unwrap_iter(__last), __value, __proj));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_FIND_H
diff --git a/third_party/libcxx/__algorithm/find_end.h b/third_party/libcxx/__algorithm/find_end.h
index edb9891c6..7e08e7953 100644
--- a/third_party/libcxx/__algorithm/find_end.h
+++ b/third_party/libcxx/__algorithm/find_end.h
@@ -28,15 +28,14 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <
-    class _AlgPolicy,
-    class _Iter1,
-    class _Sent1,
-    class _Iter2,
-    class _Sent2,
-    class _Pred,
-    class _Proj1,
-    class _Proj2>
+template < class _AlgPolicy,
+           class _Iter1,
+           class _Sent1,
+           class _Iter2,
+           class _Sent2,
+           class _Pred,
+           class _Proj1,
+           class _Proj2>
 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1> __find_end_impl(
     _Iter1 __first1,
     _Sent1 __last1,
@@ -49,7 +48,7 @@ _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1>
     forward_iterator_tag) {
   // modeled after search algorithm
   _Iter1 __match_first = _IterOps<_AlgPolicy>::next(__first1, __last1); // __last1 is the "default" answer
-  _Iter1 __match_last = __match_first;
+  _Iter1 __match_last  = __match_first;
   if (__first2 == __last2)
     return pair<_Iter1, _Iter1>(__match_last, __match_last);
   while (true) {
@@ -66,15 +65,14 @@ _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1>
     while (true) {
       if (++__m2 == __last2) { // Pattern exhaused, record answer and search for another one
         __match_first = __first1;
-        __match_last = ++__m1;
+        __match_last  = ++__m1;
         ++__first1;
         break;
       }
       if (++__m1 == __last1) // Source exhausted, return last answer
         return pair<_Iter1, _Iter1>(__match_first, __match_last);
-       // mismatch, restart with a new __first
-      if (!std::__invoke(__pred, std::__invoke(__proj1, *__m1), std::__invoke(__proj2, *__m2)))
-      {
+      // mismatch, restart with a new __first
+      if (!std::__invoke(__pred, std::__invoke(__proj1, *__m1), std::__invoke(__proj2, *__m2))) {
         ++__first1;
         break;
       } // else there is a match, check next elements
@@ -82,15 +80,14 @@ _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1>
   }
 }
 
-template <
-    class _IterOps,
-    class _Pred,
-    class _Iter1,
-    class _Sent1,
-    class _Iter2,
-    class _Sent2,
-    class _Proj1,
-    class _Proj2>
+template < class _IterOps,
+           class _Pred,
+           class _Iter1,
+           class _Sent1,
+           class _Iter2,
+           class _Sent2,
+           class _Proj1,
+           class _Proj2>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter1 __find_end(
     _Iter1 __first1,
     _Sent1 __sent1,
@@ -127,23 +124,21 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter1 __find_end(
         return __last1;
 
       // if there is a mismatch, restart with a new __l1
-      if (!std::__invoke(__pred, std::__invoke(__proj1, *--__m1), std::__invoke(__proj2, *--__m2)))
-      {
+      if (!std::__invoke(__pred, std::__invoke(__proj1, *--__m1), std::__invoke(__proj2, *--__m2))) {
         break;
       } // else there is a match, check next elements
     }
   }
 }
 
-template <
-    class _AlgPolicy,
-    class _Pred,
-    class _Iter1,
-    class _Sent1,
-    class _Iter2,
-    class _Sent2,
-    class _Proj1,
-    class _Proj2>
+template < class _AlgPolicy,
+           class _Pred,
+           class _Iter1,
+           class _Sent1,
+           class _Iter2,
+           class _Sent2,
+           class _Proj1,
+           class _Proj2>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Iter1 __find_end(
     _Iter1 __first1,
     _Sent1 __sent1,
@@ -165,8 +160,8 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Iter1 __find_end(
   if (__len1 < __len2)
     return __last1;
   const _Iter1 __s = __first1 + _D1(__len2 - 1); // End of pattern match can't go before here
-  _Iter1 __l1 = __last1;
-  _Iter2 __l2 = __last2;
+  _Iter1 __l1      = __last1;
+  _Iter2 __l2      = __last2;
   --__l2;
   while (true) {
     while (true) {
@@ -189,10 +184,12 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Iter1 __find_end(
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-_ForwardIterator1 __find_end_classic(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-                                     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
-                                     _BinaryPredicate& __pred) {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator1 __find_end_classic(
+    _ForwardIterator1 __first1,
+    _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2,
+    _ForwardIterator2 __last2,
+    _BinaryPredicate& __pred) {
   auto __proj = __identity();
   return std::__find_end_impl<_ClassicAlgPolicy>(
              __first1,
@@ -208,17 +205,18 @@ _ForwardIterator1 __find_end_classic(_ForwardIterator1 __first1, _ForwardIterato
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-                           _ForwardIterator2 __first2, _ForwardIterator2 __last2,
-                           _BinaryPredicate __pred) {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator1 find_end(
+    _ForwardIterator1 __first1,
+    _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2,
+    _ForwardIterator2 __last2,
+    _BinaryPredicate __pred) {
   return std::__find_end_classic(__first1, __last1, __first2, __last2, __pred);
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator1 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-                           _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator1
+find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
   return std::find_end(__first1, __last1, __first2, __last2, __equal_to());
 }
 
diff --git a/third_party/libcxx/__algorithm/find_first_of.h b/third_party/libcxx/__algorithm/find_first_of.h
index 12f0109a6..6b99f562f 100644
--- a/third_party/libcxx/__algorithm/find_first_of.h
+++ b/third_party/libcxx/__algorithm/find_first_of.h
@@ -21,12 +21,12 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator1 __find_first_of_ce(_ForwardIterator1 __first1,
-                                                                   _ForwardIterator1 __last1,
-                                                                   _ForwardIterator2 __first2,
-                                                                   _ForwardIterator2 __last2,
-                                                                   _BinaryPredicate&& __pred) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator1 __find_first_of_ce(
+    _ForwardIterator1 __first1,
+    _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2,
+    _ForwardIterator2 __last2,
+    _BinaryPredicate&& __pred) {
   for (; __first1 != __last1; ++__first1)
     for (_ForwardIterator2 __j = __first2; __j != __last2; ++__j)
       if (__pred(*__first1, *__j))
@@ -35,14 +35,17 @@ _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator1 __find_first_of_ce(_ForwardItera
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator1
-find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
-              _ForwardIterator2 __last2, _BinaryPredicate __pred) {
-  return _VSTD::__find_first_of_ce(__first1, __last1, __first2, __last2, __pred);
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator1 find_first_of(
+    _ForwardIterator1 __first1,
+    _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2,
+    _ForwardIterator2 __last2,
+    _BinaryPredicate __pred) {
+  return std::__find_first_of_ce(__first1, __last1, __first2, __last2, __pred);
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator1 find_first_of(
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator1 find_first_of(
     _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
   return std::__find_first_of_ce(__first1, __last1, __first2, __last2, __equal_to());
 }
diff --git a/third_party/libcxx/__algorithm/find_if.h b/third_party/libcxx/__algorithm/find_if.h
index f4ef3ac31..22092d352 100644
--- a/third_party/libcxx/__algorithm/find_if.h
+++ b/third_party/libcxx/__algorithm/find_if.h
@@ -19,7 +19,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Predicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
 find_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
   for (; __first != __last; ++__first)
     if (__pred(*__first))
diff --git a/third_party/libcxx/__algorithm/find_if_not.h b/third_party/libcxx/__algorithm/find_if_not.h
index 96c159cf5..cc2001967 100644
--- a/third_party/libcxx/__algorithm/find_if_not.h
+++ b/third_party/libcxx/__algorithm/find_if_not.h
@@ -19,7 +19,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Predicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
 find_if_not(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
   for (; __first != __last; ++__first)
     if (!__pred(*__first))
diff --git a/third_party/libcxx/__algorithm/find_segment_if.h b/third_party/libcxx/__algorithm/find_segment_if.h
new file mode 100644
index 000000000..9d6064f3e
--- /dev/null
+++ b/third_party/libcxx/__algorithm/find_segment_if.h
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_FIND_SEGMENT_IF_H
+#define _LIBCPP___ALGORITHM_FIND_SEGMENT_IF_H
+
+#include <__config>
+#include <__iterator/segmented_iterator.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// __find_segment_if is a utility function for optimizing iteration over segmented iterators linearly.
+// [__first, __last) has to be a segmented range. __pred is expected to take a range of local iterators and the __proj.
+// It returns an iterator to the first element that satisfies the predicate, or a one-past-the-end iterator if there was
+// no match. __proj may be anything that should be passed to __pred, but is expected to be a projection to support
+// ranges algorithms, or __identity for classic algorithms.
+
+template <class _SegmentedIterator, class _Pred, class _Proj>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _SegmentedIterator
+__find_segment_if(_SegmentedIterator __first, _SegmentedIterator __last, _Pred __pred, _Proj& __proj) {
+  using _Traits = __segmented_iterator_traits<_SegmentedIterator>;
+
+  auto __sfirst = _Traits::__segment(__first);
+  auto __slast  = _Traits::__segment(__last);
+
+  // We are in a single segment, so we might not be at the beginning or end
+  if (__sfirst == __slast)
+    return _Traits::__compose(__sfirst, __pred(_Traits::__local(__first), _Traits::__local(__last), __proj));
+
+  { // We have more than one segment. Iterate over the first segment, since we might not start at the beginning
+    auto __llast = _Traits::__end(__sfirst);
+    auto __liter = __pred(_Traits::__local(__first), __llast, __proj);
+    if (__liter != __llast)
+      return _Traits::__compose(__sfirst, __liter);
+  }
+  ++__sfirst;
+
+  // Iterate over the segments which are guaranteed to be completely in the range
+  while (__sfirst != __slast) {
+    auto __llast = _Traits::__end(__sfirst);
+    auto __liter = __pred(_Traits::__begin(__sfirst), _Traits::__end(__sfirst), __proj);
+    if (__liter != __llast)
+      return _Traits::__compose(__sfirst, __liter);
+    ++__sfirst;
+  }
+
+  // Iterate over the last segment
+  return _Traits::__compose(__sfirst, __pred(_Traits::__begin(__sfirst), _Traits::__local(__last), __proj));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ALGORITHM_FIND_SEGMENT_IF_H
diff --git a/third_party/libcxx/__algorithm/fold.h b/third_party/libcxx/__algorithm/fold.h
new file mode 100644
index 000000000..255658f52
--- /dev/null
+++ b/third_party/libcxx/__algorithm/fold.h
@@ -0,0 +1,128 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_FOLD_H
+#define _LIBCPP___ALGORITHM_FOLD_H
+
+#include <__concepts/assignable.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/invocable.h>
+#include <__concepts/movable.h>
+#include <__config>
+#include <__functional/invoke.h>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/next.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/invoke.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+template <class _Ip, class _Tp>
+struct in_value_result {
+  _LIBCPP_NO_UNIQUE_ADDRESS _Ip in;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Tp value;
+
+  template <class _I2, class _T2>
+    requires convertible_to<const _Ip&, _I2> && convertible_to<const _Tp&, _T2>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_value_result<_I2, _T2>() const& {
+    return {in, value};
+  }
+
+  template <class _I2, class _T2>
+    requires convertible_to<_Ip, _I2> && convertible_to<_Tp, _T2>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_value_result<_I2, _T2>() && {
+    return {std::move(in), std::move(value)};
+  }
+};
+
+template <class _Ip, class _Tp>
+using fold_left_with_iter_result = in_value_result<_Ip, _Tp>;
+
+template <class _Fp, class _Tp, class _Ip, class _Rp, class _Up = decay_t<_Rp>>
+concept __indirectly_binary_left_foldable_impl =
+    convertible_to<_Rp, _Up> &&                    //
+    movable<_Tp> &&                                //
+    movable<_Up> &&                                //
+    convertible_to<_Tp, _Up> &&                    //
+    invocable<_Fp&, _Up, iter_reference_t<_Ip>> && //
+    assignable_from<_Up&, invoke_result_t<_Fp&, _Up, iter_reference_t<_Ip>>>;
+
+template <class _Fp, class _Tp, class _Ip>
+concept __indirectly_binary_left_foldable =
+    copy_constructible<_Fp> &&                     //
+    invocable<_Fp&, _Tp, iter_reference_t<_Ip>> && //
+    __indirectly_binary_left_foldable_impl<_Fp, _Tp, _Ip, invoke_result_t<_Fp&, _Tp, iter_reference_t<_Ip>>>;
+
+struct __fold_left_with_iter {
+  template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Tp, __indirectly_binary_left_foldable<_Tp, _Ip> _Fp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Ip __first, _Sp __last, _Tp __init, _Fp __f) {
+    using _Up = decay_t<invoke_result_t<_Fp&, _Tp, iter_reference_t<_Ip>>>;
+
+    if (__first == __last) {
+      return fold_left_with_iter_result<_Ip, _Up>{std::move(__first), _Up(std::move(__init))};
+    }
+
+    _Up __result = std::invoke(__f, std::move(__init), *__first);
+    for (++__first; __first != __last; ++__first) {
+      __result = std::invoke(__f, std::move(__result), *__first);
+    }
+
+    return fold_left_with_iter_result<_Ip, _Up>{std::move(__first), std::move(__result)};
+  }
+
+  template <input_range _Rp, class _Tp, __indirectly_binary_left_foldable<_Tp, iterator_t<_Rp>> _Fp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Rp&& __r, _Tp __init, _Fp __f) {
+    auto __result = operator()(ranges::begin(__r), ranges::end(__r), std::move(__init), std::ref(__f));
+
+    using _Up = decay_t<invoke_result_t<_Fp&, _Tp, range_reference_t<_Rp>>>;
+    return fold_left_with_iter_result<borrowed_iterator_t<_Rp>, _Up>{std::move(__result.in), std::move(__result.value)};
+  }
+};
+
+inline constexpr auto fold_left_with_iter = __fold_left_with_iter();
+
+struct __fold_left {
+  template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Tp, __indirectly_binary_left_foldable<_Tp, _Ip> _Fp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Ip __first, _Sp __last, _Tp __init, _Fp __f) {
+    return fold_left_with_iter(std::move(__first), std::move(__last), std::move(__init), std::ref(__f)).value;
+  }
+
+  template <input_range _Rp, class _Tp, __indirectly_binary_left_foldable<_Tp, iterator_t<_Rp>> _Fp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Rp&& __r, _Tp __init, _Fp __f) {
+    return fold_left_with_iter(ranges::begin(__r), ranges::end(__r), std::move(__init), std::ref(__f)).value;
+  }
+};
+
+inline constexpr auto fold_left = __fold_left();
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_FOLD_H
diff --git a/third_party/libcxx/__algorithm/for_each.h b/third_party/libcxx/__algorithm/for_each.h
index 5e273cf1b..259e527f8 100644
--- a/third_party/libcxx/__algorithm/for_each.h
+++ b/third_party/libcxx/__algorithm/for_each.h
@@ -13,13 +13,18 @@
 #include <__algorithm/for_each_segment.h>
 #include <__config>
 #include <__iterator/segmented_iterator.h>
+#include <__ranges/movable_box.h>
 #include <__type_traits/enable_if.h>
+#include <__utility/in_place.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Function>
@@ -30,18 +35,23 @@ for_each(_InputIterator __first, _InputIterator __last, _Function __f) {
   return __f;
 }
 
-#if _LIBCPP_STD_VER >= 20
+// __movable_box is available in C++20, but is actually a copyable-box, so optimization is only correct in C++23
+#if _LIBCPP_STD_VER >= 23
 template <class _SegmentedIterator, class _Function>
   requires __is_segmented_iterator<_SegmentedIterator>::value
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Function
+_LIBCPP_HIDE_FROM_ABI constexpr _Function
 for_each(_SegmentedIterator __first, _SegmentedIterator __last, _Function __func) {
+  ranges::__movable_box<_Function> __wrapped_func(in_place, std::move(__func));
   std::__for_each_segment(__first, __last, [&](auto __lfirst, auto __llast) {
-    __func = std::for_each(__lfirst, __llast, std::move(__func));
+    __wrapped_func =
+        ranges::__movable_box<_Function>(in_place, std::for_each(__lfirst, __llast, std::move(*__wrapped_func)));
   });
-  return __func;
+  return std::move(*__wrapped_func);
 }
-#endif // _LIBCPP_STD_VER >= 20
+#endif // _LIBCPP_STD_VER >= 23
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_FOR_EACH_H
diff --git a/third_party/libcxx/__algorithm/for_each_n.h b/third_party/libcxx/__algorithm/for_each_n.h
index 5bd731822..fce380b49 100644
--- a/third_party/libcxx/__algorithm/for_each_n.h
+++ b/third_party/libcxx/__algorithm/for_each_n.h
@@ -22,10 +22,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 17
 
 template <class _InputIterator, class _Size, class _Function>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator for_each_n(_InputIterator __first,
-                                                                                         _Size __orig_n,
-                                                                                         _Function __f) {
-  typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
+for_each_n(_InputIterator __first, _Size __orig_n, _Function __f) {
+  typedef decltype(std::__convert_to_integral(__orig_n)) _IntegralSize;
   _IntegralSize __n = __orig_n;
   while (__n > 0) {
     __f(*__first);
diff --git a/third_party/libcxx/__algorithm/generate.h b/third_party/libcxx/__algorithm/generate.h
index 48e21b51e..c95b52740 100644
--- a/third_party/libcxx/__algorithm/generate.h
+++ b/third_party/libcxx/__algorithm/generate.h
@@ -18,12 +18,10 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Generator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen)
-{
-    for (; __first != __last; ++__first)
-        *__first = __gen();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) {
+  for (; __first != __last; ++__first)
+    *__first = __gen();
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/generate_n.h b/third_party/libcxx/__algorithm/generate_n.h
index ff5c82d3e..f36403fd0 100644
--- a/third_party/libcxx/__algorithm/generate_n.h
+++ b/third_party/libcxx/__algorithm/generate_n.h
@@ -19,15 +19,13 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _OutputIterator, class _Size, class _Generator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-generate_n(_OutputIterator __first, _Size __orig_n, _Generator __gen)
-{
-    typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
-    _IntegralSize __n = __orig_n;
-    for (; __n > 0; ++__first, (void) --__n)
-        *__first = __gen();
-    return __first;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+generate_n(_OutputIterator __first, _Size __orig_n, _Generator __gen) {
+  typedef decltype(std::__convert_to_integral(__orig_n)) _IntegralSize;
+  _IntegralSize __n = __orig_n;
+  for (; __n > 0; ++__first, (void)--__n)
+    *__first = __gen();
+  return __first;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/half_positive.h b/third_party/libcxx/__algorithm/half_positive.h
index 5a0f4baf6..ebda0da37 100644
--- a/third_party/libcxx/__algorithm/half_positive.h
+++ b/third_party/libcxx/__algorithm/half_positive.h
@@ -22,28 +22,14 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Perform division by two quickly for positive integers (llvm.org/PR39129)
 
-template <typename _Integral>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    is_integral<_Integral>::value,
-    _Integral
->::type
-__half_positive(_Integral __value)
-{
-    return static_cast<_Integral>(static_cast<__make_unsigned_t<_Integral> >(__value) / 2);
+template <typename _Integral, __enable_if_t<is_integral<_Integral>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Integral __half_positive(_Integral __value) {
+  return static_cast<_Integral>(static_cast<__make_unsigned_t<_Integral> >(__value) / 2);
 }
 
-template <typename _Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    !is_integral<_Tp>::value,
-    _Tp
->::type
-__half_positive(_Tp __value)
-{
-    return __value / 2;
+template <typename _Tp, __enable_if_t<!is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp __half_positive(_Tp __value) {
+  return __value / 2;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/in_found_result.h b/third_party/libcxx/__algorithm/in_found_result.h
index d9ca287f0..a67ae3879 100644
--- a/third_party/libcxx/__algorithm/in_found_result.h
+++ b/third_party/libcxx/__algorithm/in_found_result.h
@@ -18,6 +18,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -30,7 +33,7 @@ struct in_found_result {
 
   template <class _InIter2>
     requires convertible_to<const _InIter1&, _InIter2>
-  _LIBCPP_HIDE_FROM_ABI constexpr operator in_found_result<_InIter2>() const & {
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_found_result<_InIter2>() const& {
     return {in, found};
   }
 
@@ -46,4 +49,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_IN_FOUND_RESULT_H
diff --git a/third_party/libcxx/__algorithm/in_fun_result.h b/third_party/libcxx/__algorithm/in_fun_result.h
index 33374eddc..a22069a9a 100644
--- a/third_party/libcxx/__algorithm/in_fun_result.h
+++ b/third_party/libcxx/__algorithm/in_fun_result.h
@@ -18,6 +18,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -30,7 +33,7 @@ struct in_fun_result {
 
   template <class _InIter2, class _Func2>
     requires convertible_to<const _InIter1&, _InIter2> && convertible_to<const _Func1&, _Func2>
-  _LIBCPP_HIDE_FROM_ABI constexpr operator in_fun_result<_InIter2, _Func2>() const & {
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_fun_result<_InIter2, _Func2>() const& {
     return {in, fun};
   }
 
@@ -46,4 +49,6 @@ struct in_fun_result {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_IN_FUN_RESULT_H
diff --git a/third_party/libcxx/__algorithm/in_in_out_result.h b/third_party/libcxx/__algorithm/in_in_out_result.h
index 6b50e0e24..ba0380b5c 100644
--- a/third_party/libcxx/__algorithm/in_in_out_result.h
+++ b/third_party/libcxx/__algorithm/in_in_out_result.h
@@ -18,6 +18,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -31,18 +34,16 @@ struct in_in_out_result {
   _LIBCPP_NO_UNIQUE_ADDRESS _OutIter1 out;
 
   template <class _InIter3, class _InIter4, class _OutIter2>
-    requires convertible_to<const _InIter1&, _InIter3>
-          && convertible_to<const _InIter2&, _InIter4> && convertible_to<const _OutIter1&, _OutIter2>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  operator in_in_out_result<_InIter3, _InIter4, _OutIter2>() const& {
+    requires convertible_to<const _InIter1&, _InIter3> && convertible_to<const _InIter2&, _InIter4> &&
+             convertible_to<const _OutIter1&, _OutIter2>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_in_out_result<_InIter3, _InIter4, _OutIter2>() const& {
     return {in1, in2, out};
   }
 
   template <class _InIter3, class _InIter4, class _OutIter2>
-    requires convertible_to<_InIter1, _InIter3>
-          && convertible_to<_InIter2, _InIter4> && convertible_to<_OutIter1, _OutIter2>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  operator in_in_out_result<_InIter3, _InIter4, _OutIter2>() && {
+    requires convertible_to<_InIter1, _InIter3> && convertible_to<_InIter2, _InIter4> &&
+             convertible_to<_OutIter1, _OutIter2>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_in_out_result<_InIter3, _InIter4, _OutIter2>() && {
     return {std::move(in1), std::move(in2), std::move(out)};
   }
 };
@@ -53,4 +54,6 @@ struct in_in_out_result {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_IN_IN_OUT_RESULT_H
diff --git a/third_party/libcxx/__algorithm/in_in_result.h b/third_party/libcxx/__algorithm/in_in_result.h
index 1eceb9de0..994573fc7 100644
--- a/third_party/libcxx/__algorithm/in_in_result.h
+++ b/third_party/libcxx/__algorithm/in_in_result.h
@@ -18,6 +18,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -31,15 +34,13 @@ struct in_in_result {
 
   template <class _InIter3, class _InIter4>
     requires convertible_to<const _InIter1&, _InIter3> && convertible_to<const _InIter2&, _InIter4>
-   _LIBCPP_HIDE_FROM_ABI constexpr
-   operator in_in_result<_InIter3, _InIter4>() const & {
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_in_result<_InIter3, _InIter4>() const& {
     return {in1, in2};
   }
 
   template <class _InIter3, class _InIter4>
     requires convertible_to<_InIter1, _InIter3> && convertible_to<_InIter2, _InIter4>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  operator in_in_result<_InIter3, _InIter4>() && {
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_in_result<_InIter3, _InIter4>() && {
     return {std::move(in1), std::move(in2)};
   }
 };
@@ -50,4 +51,6 @@ struct in_in_result {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_IN_IN_RESULT_H
diff --git a/third_party/libcxx/__algorithm/in_out_out_result.h b/third_party/libcxx/__algorithm/in_out_out_result.h
index 2f7a09b5c..8ceb45284 100644
--- a/third_party/libcxx/__algorithm/in_out_out_result.h
+++ b/third_party/libcxx/__algorithm/in_out_out_result.h
@@ -18,6 +18,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -30,18 +33,16 @@ struct in_out_out_result {
   _LIBCPP_NO_UNIQUE_ADDRESS _OutIter2 out2;
 
   template <class _InIter2, class _OutIter3, class _OutIter4>
-    requires convertible_to<const _InIter1&, _InIter2>
-          && convertible_to<const _OutIter1&, _OutIter3> && convertible_to<const _OutIter2&, _OutIter4>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  operator in_out_out_result<_InIter2, _OutIter3, _OutIter4>() const& {
+    requires convertible_to<const _InIter1&, _InIter2> && convertible_to<const _OutIter1&, _OutIter3> &&
+             convertible_to<const _OutIter2&, _OutIter4>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_out_out_result<_InIter2, _OutIter3, _OutIter4>() const& {
     return {in, out1, out2};
   }
 
   template <class _InIter2, class _OutIter3, class _OutIter4>
-    requires convertible_to<_InIter1, _InIter2>
-          && convertible_to<_OutIter1, _OutIter3> && convertible_to<_OutIter2, _OutIter4>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  operator in_out_out_result<_InIter2, _OutIter3, _OutIter4>() && {
+    requires convertible_to<_InIter1, _InIter2> && convertible_to<_OutIter1, _OutIter3> &&
+             convertible_to<_OutIter2, _OutIter4>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_out_out_result<_InIter2, _OutIter3, _OutIter4>() && {
     return {std::move(in), std::move(out1), std::move(out2)};
   }
 };
@@ -51,4 +52,6 @@ struct in_out_out_result {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_IN_OUT_OUT_RESULT_H
diff --git a/third_party/libcxx/__algorithm/in_out_result.h b/third_party/libcxx/__algorithm/in_out_result.h
index 158b35532..a7a986cf8 100644
--- a/third_party/libcxx/__algorithm/in_out_result.h
+++ b/third_party/libcxx/__algorithm/in_out_result.h
@@ -18,28 +18,29 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
 
-template<class _InIter1, class _OutIter1>
+template <class _InIter1, class _OutIter1>
 struct in_out_result {
   _LIBCPP_NO_UNIQUE_ADDRESS _InIter1 in;
   _LIBCPP_NO_UNIQUE_ADDRESS _OutIter1 out;
 
   template <class _InIter2, class _OutIter2>
     requires convertible_to<const _InIter1&, _InIter2> && convertible_to<const _OutIter1&, _OutIter2>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr operator in_out_result<_InIter2, _OutIter2>() const & {
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_out_result<_InIter2, _OutIter2>() const& {
     return {in, out};
   }
 
   template <class _InIter2, class _OutIter2>
     requires convertible_to<_InIter1, _InIter2> && convertible_to<_OutIter1, _OutIter2>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr operator in_out_result<_InIter2, _OutIter2>() && {
+  _LIBCPP_HIDE_FROM_ABI constexpr operator in_out_result<_InIter2, _OutIter2>() && {
     return {std::move(in), std::move(out)};
   }
 };
@@ -50,4 +51,6 @@ struct in_out_result {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_IN_OUT_RESULT_H
diff --git a/third_party/libcxx/__algorithm/includes.h b/third_party/libcxx/__algorithm/includes.h
index cc39f275b..62af03c37 100644
--- a/third_party/libcxx/__algorithm/includes.h
+++ b/third_party/libcxx/__algorithm/includes.h
@@ -22,15 +22,23 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Comp, class _Proj1, class _Proj2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__includes(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
-           _Comp&& __comp, _Proj1&& __proj1, _Proj2&& __proj2) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __includes(
+    _Iter1 __first1,
+    _Sent1 __last1,
+    _Iter2 __first2,
+    _Sent2 __last2,
+    _Comp&& __comp,
+    _Proj1&& __proj1,
+    _Proj2&& __proj2) {
   for (; __first2 != __last2; ++__first1) {
-    if (__first1 == __last1 || std::__invoke(
-          __comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1)))
+    if (__first1 == __last1 ||
+        std::__invoke(__comp, std::__invoke(__proj2, *__first2), std::__invoke(__proj1, *__first1)))
       return false;
     if (!std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
       ++__first2;
@@ -39,14 +47,14 @@ __includes(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
 }
 
 template <class _InputIterator1, class _InputIterator2, class _Compare>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool includes(
-    _InputIterator1 __first1,
-    _InputIterator1 __last1,
-    _InputIterator2 __first2,
-    _InputIterator2 __last2,
-    _Compare __comp) {
-  static_assert(__is_callable<_Compare, decltype(*__first1), decltype(*__first2)>::value,
-      "Comparator has to be callable");
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+includes(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _Compare __comp) {
+  static_assert(
+      __is_callable<_Compare, decltype(*__first1), decltype(*__first2)>::value, "Comparator has to be callable");
 
   return std::__includes(
       std::move(__first1),
@@ -59,17 +67,13 @@ _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
 }
 
 template <class _InputIterator1, class _InputIterator2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
-  return std::includes(
-      std::move(__first1),
-      std::move(__last1),
-      std::move(__first2),
-      std::move(__last2),
-      __less<typename iterator_traits<_InputIterator1>::value_type,
-             typename iterator_traits<_InputIterator2>::value_type>());
+  return std::includes(std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_INCLUDES_H
diff --git a/third_party/libcxx/__algorithm/inplace_merge.h b/third_party/libcxx/__algorithm/inplace_merge.h
index 5bbefc94b..a6bcc66a2 100644
--- a/third_party/libcxx/__algorithm/inplace_merge.h
+++ b/third_party/libcxx/__algorithm/inplace_merge.h
@@ -42,54 +42,57 @@ template <class _Predicate>
 class __invert // invert the sense of a comparison
 {
 private:
-    _Predicate __p_;
+  _Predicate __p_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY __invert() {}
+  _LIBCPP_HIDE_FROM_ABI __invert() {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __invert(_Predicate __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __invert(_Predicate __p) : __p_(__p) {}
 
-    template <class _T1>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _T1& __x) {return !__p_(__x);}
+  template <class _T1>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _T1& __x) {
+    return !__p_(__x);
+  }
 
-    template <class _T1, class _T2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _T1& __x, const _T2& __y) {return __p_(__y, __x);}
+  template <class _T1, class _T2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _T1& __x, const _T2& __y) {
+    return __p_(__y, __x);
+  }
 };
 
-template <class _AlgPolicy, class _Compare, class _InputIterator1, class _Sent1,
-          class _InputIterator2, class _Sent2, class _OutputIterator>
-_LIBCPP_HIDE_FROM_ABI
-void __half_inplace_merge(_InputIterator1 __first1, _Sent1 __last1,
-                          _InputIterator2 __first2, _Sent2 __last2,
-                          _OutputIterator __result, _Compare&& __comp)
-{
-    for (; __first1 != __last1; ++__result)
-    {
-        if (__first2 == __last2)
-        {
-            std::__move<_AlgPolicy>(__first1, __last1, __result);
-            return;
-        }
-
-        if (__comp(*__first2, *__first1))
-        {
-            *__result = _IterOps<_AlgPolicy>::__iter_move(__first2);
-            ++__first2;
-        }
-        else
-        {
-            *__result = _IterOps<_AlgPolicy>::__iter_move(__first1);
-            ++__first1;
-        }
+template <class _AlgPolicy,
+          class _Compare,
+          class _InputIterator1,
+          class _Sent1,
+          class _InputIterator2,
+          class _Sent2,
+          class _OutputIterator>
+_LIBCPP_HIDE_FROM_ABI void __half_inplace_merge(
+    _InputIterator1 __first1,
+    _Sent1 __last1,
+    _InputIterator2 __first2,
+    _Sent2 __last2,
+    _OutputIterator __result,
+    _Compare&& __comp) {
+  for (; __first1 != __last1; ++__result) {
+    if (__first2 == __last2) {
+      std::__move<_AlgPolicy>(__first1, __last1, __result);
+      return;
     }
-    // __first2 through __last2 are already in the right spot.
+
+    if (__comp(*__first2, *__first1)) {
+      *__result = _IterOps<_AlgPolicy>::__iter_move(__first2);
+      ++__first2;
+    } else {
+      *__result = _IterOps<_AlgPolicy>::__iter_move(__first1);
+      ++__first1;
+    }
+  }
+  // __first2 through __last2 are already in the right spot.
 }
 
 template <class _AlgPolicy, class _Compare, class _BidirectionalIterator>
-_LIBCPP_HIDE_FROM_ABI
-void __buffered_inplace_merge(
+_LIBCPP_HIDE_FROM_ABI void __buffered_inplace_merge(
     _BidirectionalIterator __first,
     _BidirectionalIterator __middle,
     _BidirectionalIterator __last,
@@ -98,27 +101,25 @@ void __buffered_inplace_merge(
     typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
     typename iterator_traits<_BidirectionalIterator>::value_type* __buff) {
   typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
-    __destruct_n __d(0);
-    unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
-    if (__len1 <= __len2)
-    {
-        value_type* __p = __buff;
-        for (_BidirectionalIterator __i = __first; __i != __middle; __d.template __incr<value_type>(), (void) ++__i, (void) ++__p)
-            ::new ((void*)__p) value_type(_IterOps<_AlgPolicy>::__iter_move(__i));
-        std::__half_inplace_merge<_AlgPolicy>(__buff, __p, __middle, __last, __first, __comp);
-    }
-    else
-    {
-        value_type* __p = __buff;
-        for (_BidirectionalIterator __i = __middle; __i != __last; __d.template __incr<value_type>(), (void) ++__i, (void) ++__p)
-            ::new ((void*)__p) value_type(_IterOps<_AlgPolicy>::__iter_move(__i));
-        typedef __unconstrained_reverse_iterator<_BidirectionalIterator> _RBi;
-        typedef __unconstrained_reverse_iterator<value_type*> _Rv;
-        typedef __invert<_Compare> _Inverted;
-        std::__half_inplace_merge<_AlgPolicy>(_Rv(__p), _Rv(__buff),
-                                    _RBi(__middle), _RBi(__first),
-                                    _RBi(__last), _Inverted(__comp));
-    }
+  __destruct_n __d(0);
+  unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
+  if (__len1 <= __len2) {
+    value_type* __p = __buff;
+    for (_BidirectionalIterator __i = __first; __i != __middle;
+         __d.template __incr<value_type>(), (void)++__i, (void)++__p)
+      ::new ((void*)__p) value_type(_IterOps<_AlgPolicy>::__iter_move(__i));
+    std::__half_inplace_merge<_AlgPolicy>(__buff, __p, __middle, __last, __first, __comp);
+  } else {
+    value_type* __p = __buff;
+    for (_BidirectionalIterator __i = __middle; __i != __last;
+         __d.template __incr<value_type>(), (void)++__i, (void)++__p)
+      ::new ((void*)__p) value_type(_IterOps<_AlgPolicy>::__iter_move(__i));
+    typedef reverse_iterator<_BidirectionalIterator> _RBi;
+    typedef reverse_iterator<value_type*> _Rv;
+    typedef __invert<_Compare> _Inverted;
+    std::__half_inplace_merge<_AlgPolicy>(
+        _Rv(__p), _Rv(__buff), _RBi(__middle), _RBi(__first), _RBi(__last), _Inverted(__comp));
+  }
 }
 
 template <class _AlgPolicy, class _Compare, class _BidirectionalIterator>
@@ -131,107 +132,92 @@ void __inplace_merge(
     typename iterator_traits<_BidirectionalIterator>::difference_type __len2,
     typename iterator_traits<_BidirectionalIterator>::value_type* __buff,
     ptrdiff_t __buff_size) {
-    using _Ops = _IterOps<_AlgPolicy>;
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
-    while (true)
-    {
-        // if __middle == __last, we're done
-        if (__len2 == 0)
-            return;
-        if (__len1 <= __buff_size || __len2 <= __buff_size)
-            return std::__buffered_inplace_merge<_AlgPolicy>
-                   (__first, __middle, __last, __comp, __len1, __len2, __buff);
-        // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0
-        for (; true; ++__first, (void) --__len1)
-        {
-            if (__len1 == 0)
-                return;
-            if (__comp(*__middle, *__first))
-                break;
-        }
-        // __first < __middle < __last
-        // *__first > *__middle
-        // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that
-        //     all elements in:
-        //         [__first, __m1)  <= [__middle, __m2)
-        //         [__middle, __m2) <  [__m1, __middle)
-        //         [__m1, __middle) <= [__m2, __last)
-        //     and __m1 or __m2 is in the middle of its range
-        _BidirectionalIterator __m1;  // "median" of [__first, __middle)
-        _BidirectionalIterator __m2;  // "median" of [__middle, __last)
-        difference_type __len11;      // distance(__first, __m1)
-        difference_type __len21;      // distance(__middle, __m2)
-        // binary search smaller range
-        if (__len1 < __len2)
-        {   // __len >= 1, __len2 >= 2
-            __len21 = __len2 / 2;
-            __m2 = __middle;
-            _Ops::advance(__m2, __len21);
-            __m1 = std::__upper_bound<_AlgPolicy>(__first, __middle, *__m2, __comp, std::__identity());
-            __len11 = _Ops::distance(__first, __m1);
-        }
-        else
-        {
-            if (__len1 == 1)
-            {   // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1
-                // It is known *__first > *__middle
-              _Ops::iter_swap(__first, __middle);
-                return;
-            }
-            // __len1 >= 2, __len2 >= 1
-            __len11 = __len1 / 2;
-            __m1 = __first;
-            _Ops::advance(__m1, __len11);
-            __m2 = std::lower_bound(__middle, __last, *__m1, __comp);
-            __len21 = _Ops::distance(__middle, __m2);
-        }
-        difference_type __len12 = __len1 - __len11;  // distance(__m1, __middle)
-        difference_type __len22 = __len2 - __len21;  // distance(__m2, __last)
-        // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last)
-        // swap middle two partitions
-        __middle = std::__rotate<_AlgPolicy>(__m1, __middle, __m2).first;
-        // __len12 and __len21 now have swapped meanings
-        // merge smaller range with recursive call and larger with tail recursion elimination
-        if (__len11 + __len21 < __len12 + __len22)
-        {
-            std::__inplace_merge<_AlgPolicy>(
-                __first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
-            __first = __middle;
-            __middle = __m2;
-            __len1 = __len12;
-            __len2 = __len22;
-        }
-        else
-        {
-            std::__inplace_merge<_AlgPolicy>(
-                __middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
-            __last = __middle;
-            __middle = __m1;
-            __len1 = __len11;
-            __len2 = __len21;
-        }
+  typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
+  while (true) {
+    // if __middle == __last, we're done
+    if (__len2 == 0)
+      return;
+    if (__len1 <= __buff_size || __len2 <= __buff_size)
+      return std::__buffered_inplace_merge<_AlgPolicy>(__first, __middle, __last, __comp, __len1, __len2, __buff);
+    // shrink [__first, __middle) as much as possible (with no moves), returning if it shrinks to 0
+    for (; true; ++__first, (void)--__len1) {
+      if (__len1 == 0)
+        return;
+      if (__comp(*__middle, *__first))
+        break;
     }
+    // __first < __middle < __last
+    // *__first > *__middle
+    // partition [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last) such that
+    //     all elements in:
+    //         [__first, __m1)  <= [__middle, __m2)
+    //         [__middle, __m2) <  [__m1, __middle)
+    //         [__m1, __middle) <= [__m2, __last)
+    //     and __m1 or __m2 is in the middle of its range
+    _BidirectionalIterator __m1; // "median" of [__first, __middle)
+    _BidirectionalIterator __m2; // "median" of [__middle, __last)
+    difference_type __len11;     // distance(__first, __m1)
+    difference_type __len21;     // distance(__middle, __m2)
+    // binary search smaller range
+    if (__len1 < __len2) { // __len >= 1, __len2 >= 2
+      __len21 = __len2 / 2;
+      __m2    = __middle;
+      _Ops::advance(__m2, __len21);
+      __m1    = std::__upper_bound<_AlgPolicy>(__first, __middle, *__m2, __comp, std::__identity());
+      __len11 = _Ops::distance(__first, __m1);
+    } else {
+      if (__len1 == 1) { // __len1 >= __len2 && __len2 > 0, therefore __len2 == 1
+                         // It is known *__first > *__middle
+        _Ops::iter_swap(__first, __middle);
+        return;
+      }
+      // __len1 >= 2, __len2 >= 1
+      __len11 = __len1 / 2;
+      __m1    = __first;
+      _Ops::advance(__m1, __len11);
+      __m2    = std::lower_bound(__middle, __last, *__m1, __comp);
+      __len21 = _Ops::distance(__middle, __m2);
+    }
+    difference_type __len12 = __len1 - __len11; // distance(__m1, __middle)
+    difference_type __len22 = __len2 - __len21; // distance(__m2, __last)
+    // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last)
+    // swap middle two partitions
+    __middle = std::__rotate<_AlgPolicy>(__m1, __middle, __m2).first;
+    // __len12 and __len21 now have swapped meanings
+    // merge smaller range with recursive call and larger with tail recursion elimination
+    if (__len11 + __len21 < __len12 + __len22) {
+      std::__inplace_merge<_AlgPolicy>(__first, __m1, __middle, __comp, __len11, __len21, __buff, __buff_size);
+      __first  = __middle;
+      __middle = __m2;
+      __len1   = __len12;
+      __len2   = __len22;
+    } else {
+      std::__inplace_merge<_AlgPolicy>(__middle, __m2, __last, __comp, __len12, __len22, __buff, __buff_size);
+      __last   = __middle;
+      __middle = __m1;
+      __len1   = __len11;
+      __len2   = __len21;
+    }
+  }
 }
 
 template <class _AlgPolicy, class _BidirectionalIterator, class _Compare>
-_LIBCPP_HIDE_FROM_ABI
-void
-__inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
-              _Compare&& __comp)
-{
-    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
-    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
-    difference_type __len1 = _IterOps<_AlgPolicy>::distance(__first, __middle);
-    difference_type __len2 = _IterOps<_AlgPolicy>::distance(__middle, __last);
-    difference_type __buf_size = _VSTD::min(__len1, __len2);
-// TODO: Remove the use of std::get_temporary_buffer
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    pair<value_type*, ptrdiff_t> __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size);
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-    unique_ptr<value_type, __return_temporary_buffer> __h(__buf.first);
-    return std::__inplace_merge<_AlgPolicy>(
-        std::move(__first), std::move(__middle), std::move(__last), __comp, __len1, __len2, __buf.first, __buf.second);
+_LIBCPP_HIDE_FROM_ABI void __inplace_merge(
+    _BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last, _Compare&& __comp) {
+  typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
+  typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
+  difference_type __len1     = _IterOps<_AlgPolicy>::distance(__first, __middle);
+  difference_type __len2     = _IterOps<_AlgPolicy>::distance(__middle, __last);
+  difference_type __buf_size = std::min(__len1, __len2);
+  // TODO: Remove the use of std::get_temporary_buffer
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  pair<value_type*, ptrdiff_t> __buf = std::get_temporary_buffer<value_type>(__buf_size);
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+  unique_ptr<value_type, __return_temporary_buffer> __h(__buf.first);
+  return std::__inplace_merge<_AlgPolicy>(
+      std::move(__first), std::move(__middle), std::move(__last), __comp, __len1, __len2, __buf.first, __buf.second);
 }
 
 template <class _BidirectionalIterator, class _Compare>
@@ -242,12 +228,9 @@ inline _LIBCPP_HIDE_FROM_ABI void inplace_merge(
 }
 
 template <class _BidirectionalIterator>
-inline _LIBCPP_HIDE_FROM_ABI
-void
-inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last)
-{
-    std::inplace_merge(std::move(__first), std::move(__middle), std::move(__last),
-                        __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI void
+inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last) {
+  std::inplace_merge(std::move(__first), std::move(__middle), std::move(__last), __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/is_heap.h b/third_party/libcxx/__algorithm/is_heap.h
index 2dcb4a28e..c589b804a 100644
--- a/third_party/libcxx/__algorithm/is_heap.h
+++ b/third_party/libcxx/__algorithm/is_heap.h
@@ -22,21 +22,15 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _RandomAccessIterator, class _Compare>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
-{
-    return std::__is_heap_until(__first, __last, static_cast<__comp_ref_type<_Compare> >(__comp)) == __last;
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+  return std::__is_heap_until(__first, __last, static_cast<__comp_ref_type<_Compare> >(__comp)) == __last;
 }
 
-template<class _RandomAccessIterator>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
-{
-    return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+template <class _RandomAccessIterator>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
+  return std::is_heap(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/is_heap_until.h b/third_party/libcxx/__algorithm/is_heap_until.h
index 6ed4cb29c..a174f2453 100644
--- a/third_party/libcxx/__algorithm/is_heap_until.h
+++ b/third_party/libcxx/__algorithm/is_heap_until.h
@@ -22,43 +22,39 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare, class _RandomAccessIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator
-__is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp)
-{
-    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-    difference_type __len = __last - __first;
-    difference_type __p = 0;
-    difference_type __c = 1;
-    _RandomAccessIterator __pp = __first;
-    while (__c < __len)
-    {
-        _RandomAccessIterator __cp = __first + __c;
-        if (__comp(*__pp, *__cp))
-            return __cp;
-        ++__c;
-        ++__cp;
-        if (__c == __len)
-            return __last;
-        if (__comp(*__pp, *__cp))
-            return __cp;
-        ++__p;
-        ++__pp;
-        __c = 2 * __p + 1;
-    }
-    return __last;
+__is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) {
+  typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
+  difference_type __len      = __last - __first;
+  difference_type __p        = 0;
+  difference_type __c        = 1;
+  _RandomAccessIterator __pp = __first;
+  while (__c < __len) {
+    _RandomAccessIterator __cp = __first + __c;
+    if (__comp(*__pp, *__cp))
+      return __cp;
+    ++__c;
+    ++__cp;
+    if (__c == __len)
+      return __last;
+    if (__comp(*__pp, *__cp))
+      return __cp;
+    ++__p;
+    ++__pp;
+    __c = 2 * __p + 1;
+  }
+  return __last;
 }
 
 template <class _RandomAccessIterator, class _Compare>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator
-is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
-{
-    return std::__is_heap_until(__first, __last, static_cast<__comp_ref_type<_Compare> >(__comp));
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator
+is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+  return std::__is_heap_until(__first, __last, static_cast<__comp_ref_type<_Compare> >(__comp));
 }
 
-template<class _RandomAccessIterator>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator
-is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
-{
-    return _VSTD::__is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+template <class _RandomAccessIterator>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator
+is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) {
+  return std::__is_heap_until(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/is_partitioned.h b/third_party/libcxx/__algorithm/is_partitioned.h
index ab59d3cce..1f7c8b0b2 100644
--- a/third_party/libcxx/__algorithm/is_partitioned.h
+++ b/third_party/libcxx/__algorithm/is_partitioned.h
@@ -18,19 +18,18 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Predicate>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-is_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred)
-{
-    for (; __first != __last; ++__first)
-        if (!__pred(*__first))
-            break;
-    if ( __first == __last )
-        return true;
-    ++__first;
-    for (; __first != __last; ++__first)
-        if (__pred(*__first))
-            return false;
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+is_partitioned(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
+  for (; __first != __last; ++__first)
+    if (!__pred(*__first))
+      break;
+  if (__first == __last)
     return true;
+  ++__first;
+  for (; __first != __last; ++__first)
+    if (__pred(*__first))
+      return false;
+  return true;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/is_permutation.h b/third_party/libcxx/__algorithm/is_permutation.h
index 2a7c606b8..2ddfb32a2 100644
--- a/third_party/libcxx/__algorithm/is_permutation.h
+++ b/third_party/libcxx/__algorithm/is_permutation.h
@@ -26,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class = void>
@@ -34,18 +37,24 @@ struct _ConstTimeDistance : false_type {};
 #if _LIBCPP_STD_VER >= 20
 
 template <class _Iter1, class _Sent1, class _Iter2, class _Sent2>
-struct _ConstTimeDistance<_Iter1, _Sent1, _Iter2, _Sent2, __enable_if_t<
-  sized_sentinel_for<_Sent1, _Iter1> &&
-  sized_sentinel_for<_Sent2, _Iter2>
->> : true_type {};
+struct _ConstTimeDistance<_Iter1,
+                          _Sent1,
+                          _Iter2,
+                          _Sent2,
+                          __enable_if_t< sized_sentinel_for<_Sent1, _Iter1> && sized_sentinel_for<_Sent2, _Iter2> >>
+    : true_type {};
 
 #else
 
 template <class _Iter1, class _Iter2>
-struct _ConstTimeDistance<_Iter1, _Iter1, _Iter2, _Iter2, __enable_if_t<
-    is_same<typename iterator_traits<_Iter1>::iterator_category, random_access_iterator_tag>::value &&
-    is_same<typename iterator_traits<_Iter2>::iterator_category, random_access_iterator_tag>::value
-> > : true_type {};
+struct _ConstTimeDistance<
+    _Iter1,
+    _Iter1,
+    _Iter2,
+    _Iter2,
+    __enable_if_t< is_same<typename iterator_traits<_Iter1>::iterator_category, random_access_iterator_tag>::value &&
+                   is_same<typename iterator_traits<_Iter2>::iterator_category, random_access_iterator_tag>::value > >
+    : true_type {};
 
 #endif // _LIBCPP_STD_VER >= 20
 
@@ -53,11 +62,21 @@ struct _ConstTimeDistance<_Iter1, _Iter1, _Iter2, _Iter2, __enable_if_t<
 
 // For each element in [f1, l1) see if there are the same number of equal elements in [f2, l2)
 template <class _AlgPolicy,
-          class _Iter1, class _Sent1, class _Iter2, class _Sent2,
-          class _Proj1, class _Proj2, class _Pred>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__is_permutation_impl(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
-                      _Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2) {
+          class _Iter1,
+          class _Sent1,
+          class _Iter2,
+          class _Sent2,
+          class _Proj1,
+          class _Proj2,
+          class _Pred>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __is_permutation_impl(
+    _Iter1 __first1,
+    _Sent1 __last1,
+    _Iter2 __first2,
+    _Sent2 __last2,
+    _Pred&& __pred,
+    _Proj1&& __proj1,
+    _Proj2&& __proj2) {
   using _D1 = __iter_diff_t<_Iter1>;
 
   for (auto __i = __first1; __i != __last1; ++__i) {
@@ -94,9 +113,8 @@ __is_permutation_impl(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 _
 
 // 2+1 iterators, predicate. Not used by range algorithms.
 template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _ForwardIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__is_permutation(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2 __first2,
-                 _BinaryPredicate&& __pred) {
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __is_permutation(
+    _ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2 __first2, _BinaryPredicate&& __pred) {
   // Shorten sequences as much as possible by lopping of any equal prefix.
   for (; __first1 != __last1; ++__first1, (void)++__first2) {
     if (!__pred(*__first1, *__first2))
@@ -108,24 +126,39 @@ __is_permutation(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterato
 
   //  __first1 != __last1 && *__first1 != *__first2
   using _D1 = __iter_diff_t<_ForwardIterator1>;
-  _D1 __l1 = _IterOps<_AlgPolicy>::distance(__first1, __last1);
+  _D1 __l1  = _IterOps<_AlgPolicy>::distance(__first1, __last1);
   if (__l1 == _D1(1))
     return false;
   auto __last2 = _IterOps<_AlgPolicy>::next(__first2, __l1);
 
   return std::__is_permutation_impl<_AlgPolicy>(
-      std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
-      __pred, __identity(), __identity());
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__last2),
+      __pred,
+      __identity(),
+      __identity());
 }
 
 // 2+2 iterators, predicate, non-constant time `distance`.
 template <class _AlgPolicy,
-          class _Iter1, class _Sent1, class _Iter2, class _Sent2,
-          class _Proj1, class _Proj2, class _Pred>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
-                 _Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2,
-                 /*_ConstTimeDistance=*/false_type) {
+          class _Iter1,
+          class _Sent1,
+          class _Iter2,
+          class _Sent2,
+          class _Proj1,
+          class _Proj2,
+          class _Pred>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __is_permutation(
+    _Iter1 __first1,
+    _Sent1 __last1,
+    _Iter2 __first2,
+    _Sent2 __last2,
+    _Pred&& __pred,
+    _Proj1&& __proj1,
+    _Proj2&& __proj2,
+    /*_ConstTimeDistance=*/false_type) {
   // Shorten sequences as much as possible by lopping of any equal prefix.
   while (__first1 != __last1 && __first2 != __last2) {
     if (!std::__invoke(__pred, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
@@ -140,44 +173,73 @@ __is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last
     return false;
 
   using _D1 = __iter_diff_t<_Iter1>;
-  _D1 __l1 = _IterOps<_AlgPolicy>::distance(__first1, __last1);
+  _D1 __l1  = _IterOps<_AlgPolicy>::distance(__first1, __last1);
 
   using _D2 = __iter_diff_t<_Iter2>;
-  _D2 __l2 = _IterOps<_AlgPolicy>::distance(__first2, __last2);
+  _D2 __l2  = _IterOps<_AlgPolicy>::distance(__first2, __last2);
   if (__l1 != __l2)
     return false;
 
   return std::__is_permutation_impl<_AlgPolicy>(
-      std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
-      __pred, __proj1, __proj2);
+      std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __pred, __proj1, __proj2);
 }
 
 // 2+2 iterators, predicate, specialization for constant-time `distance` call.
 template <class _AlgPolicy,
-          class _Iter1, class _Sent1, class _Iter2, class _Sent2,
-          class _Proj1, class _Proj2, class _Pred>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
-                 _Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2,
-                 /*_ConstTimeDistance=*/true_type) {
+          class _Iter1,
+          class _Sent1,
+          class _Iter2,
+          class _Sent2,
+          class _Proj1,
+          class _Proj2,
+          class _Pred>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __is_permutation(
+    _Iter1 __first1,
+    _Sent1 __last1,
+    _Iter2 __first2,
+    _Sent2 __last2,
+    _Pred&& __pred,
+    _Proj1&& __proj1,
+    _Proj2&& __proj2,
+    /*_ConstTimeDistance=*/true_type) {
   if (std::distance(__first1, __last1) != std::distance(__first2, __last2))
     return false;
   return std::__is_permutation<_AlgPolicy>(
-      std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
-      __pred, __proj1, __proj2,
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__last2),
+      __pred,
+      __proj1,
+      __proj2,
       /*_ConstTimeDistance=*/false_type());
 }
 
 // 2+2 iterators, predicate
 template <class _AlgPolicy,
-          class _Iter1, class _Sent1, class _Iter2, class _Sent2,
-          class _Proj1, class _Proj2, class _Pred>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
-                 _Pred&& __pred, _Proj1&& __proj1, _Proj2&& __proj2) {
+          class _Iter1,
+          class _Sent1,
+          class _Iter2,
+          class _Sent2,
+          class _Proj1,
+          class _Proj2,
+          class _Pred>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __is_permutation(
+    _Iter1 __first1,
+    _Sent1 __last1,
+    _Iter2 __first2,
+    _Sent2 __last2,
+    _Pred&& __pred,
+    _Proj1&& __proj1,
+    _Proj2&& __proj2) {
   return std::__is_permutation<_AlgPolicy>(
-      std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
-      __pred, __proj1, __proj2,
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__last2),
+      __pred,
+      __proj1,
+      __proj2,
       _ConstTimeDistance<_Iter1, _Sent1, _Iter2, _Sent2>());
 }
 
@@ -185,19 +247,17 @@ __is_permutation(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last
 
 // 2+1 iterators, predicate
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
-               _BinaryPredicate __pred) {
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool is_permutation(
+    _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _BinaryPredicate __pred) {
   static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value,
-      "The predicate has to be callable");
+                "The predicate has to be callable");
 
-  return std::__is_permutation<_ClassicAlgPolicy>(
-      std::move(__first1), std::move(__last1), std::move(__first2), __pred);
+  return std::__is_permutation<_ClassicAlgPolicy>(std::move(__first1), std::move(__last1), std::move(__first2), __pred);
 }
 
 // 2+1 iterators
 template <class _ForwardIterator1, class _ForwardIterator2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
   return std::is_permutation(__first1, __last1, __first2, __equal_to());
 }
@@ -206,7 +266,7 @@ is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIt
 
 // 2+2 iterators
 template <class _ForwardIterator1, class _ForwardIterator2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool is_permutation(
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool is_permutation(
     _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
   return std::__is_permutation<_ClassicAlgPolicy>(
       std::move(__first1),
@@ -220,19 +280,29 @@ _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
 
 // 2+2 iterators, predicate
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
-               _ForwardIterator2 __last2, _BinaryPredicate __pred) {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool is_permutation(
+    _ForwardIterator1 __first1,
+    _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2,
+    _ForwardIterator2 __last2,
+    _BinaryPredicate __pred) {
   static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value,
-      "The predicate has to be callable");
+                "The predicate has to be callable");
 
   return std::__is_permutation<_ClassicAlgPolicy>(
-      std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
-      __pred, __identity(), __identity());
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__last2),
+      __pred,
+      __identity(),
+      __identity());
 }
 
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_IS_PERMUTATION_H
diff --git a/third_party/libcxx/__algorithm/is_sorted.h b/third_party/libcxx/__algorithm/is_sorted.h
index bf44f4576..3befb1ac9 100644
--- a/third_party/libcxx/__algorithm/is_sorted.h
+++ b/third_party/libcxx/__algorithm/is_sorted.h
@@ -22,21 +22,15 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Compare>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
-{
-    return _VSTD::__is_sorted_until<__comp_ref_type<_Compare> >(__first, __last, __comp) == __last;
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
+  return std::__is_sorted_until<__comp_ref_type<_Compare> >(__first, __last, __comp) == __last;
 }
 
-template<class _ForwardIterator>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-is_sorted(_ForwardIterator __first, _ForwardIterator __last)
-{
-    return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
+template <class _ForwardIterator>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+is_sorted(_ForwardIterator __first, _ForwardIterator __last) {
+  return std::is_sorted(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/is_sorted_until.h b/third_party/libcxx/__algorithm/is_sorted_until.h
index b6683000a..53a49f00d 100644
--- a/third_party/libcxx/__algorithm/is_sorted_until.h
+++ b/third_party/libcxx/__algorithm/is_sorted_until.h
@@ -22,33 +22,28 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare, class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
-__is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
-{
-    if (__first != __last)
-    {
-        _ForwardIterator __i = __first;
-        while (++__i != __last)
-        {
-            if (__comp(*__i, *__first))
-                return __i;
-            __first = __i;
-        }
+__is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
+  if (__first != __last) {
+    _ForwardIterator __i = __first;
+    while (++__i != __last) {
+      if (__comp(*__i, *__first))
+        return __i;
+      __first = __i;
     }
-    return __last;
+  }
+  return __last;
 }
 
 template <class _ForwardIterator, class _Compare>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
-is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
-{
-    return _VSTD::__is_sorted_until<__comp_ref_type<_Compare> >(__first, __last, __comp);
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+is_sorted_until(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
+  return std::__is_sorted_until<__comp_ref_type<_Compare> >(__first, __last, __comp);
 }
 
-template<class _ForwardIterator>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
-is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
-{
-    return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
+template <class _ForwardIterator>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+is_sorted_until(_ForwardIterator __first, _ForwardIterator __last) {
+  return std::is_sorted_until(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/iter_swap.h b/third_party/libcxx/__algorithm/iter_swap.h
index 44422b5de..a1412e5d8 100644
--- a/third_party/libcxx/__algorithm/iter_swap.h
+++ b/third_party/libcxx/__algorithm/iter_swap.h
@@ -20,8 +20,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator1, class _ForwardIterator2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void iter_swap(_ForwardIterator1 __a,
-                                                                              _ForwardIterator2 __b)
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
     //                                  _NOEXCEPT_(_NOEXCEPT_(swap(*__a, *__b)))
     _NOEXCEPT_(_NOEXCEPT_(swap(*std::declval<_ForwardIterator1>(), *std::declval<_ForwardIterator2>()))) {
   swap(*__a, *__b);
diff --git a/third_party/libcxx/__algorithm/iterator_operations.h b/third_party/libcxx/__algorithm/iterator_operations.h
index 2bdc0ac2f..8ced98923 100644
--- a/third_party/libcxx/__algorithm/iterator_operations.h
+++ b/third_party/libcxx/__algorithm/iterator_operations.h
@@ -11,6 +11,7 @@
 
 #include <__algorithm/iter_swap.h>
 #include <__algorithm/ranges_iterator_concept.h>
+#include <__assert>
 #include <__config>
 #include <__iterator/advance.h>
 #include <__iterator/distance.h>
@@ -33,16 +34,19 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _AlgPolicy> struct _IterOps;
+template <class _AlgPolicy>
+struct _IterOps;
 
 #if _LIBCPP_STD_VER >= 20
 struct _RangeAlgPolicy {};
 
 template <>
 struct _IterOps<_RangeAlgPolicy> {
-
   template <class _Iter>
   using __value_type = iter_value_t<_Iter>;
 
@@ -52,12 +56,12 @@ struct _IterOps<_RangeAlgPolicy> {
   template <class _Iter>
   using __difference_type = iter_difference_t<_Iter>;
 
-  static constexpr auto advance = ranges::advance;
-  static constexpr auto distance = ranges::distance;
-  static constexpr auto __iter_move = ranges::iter_move;
-  static constexpr auto iter_swap = ranges::iter_swap;
-  static constexpr auto next = ranges::next;
-  static constexpr auto prev = ranges::prev;
+  static constexpr auto advance      = ranges::advance;
+  static constexpr auto distance     = ranges::distance;
+  static constexpr auto __iter_move  = ranges::iter_move;
+  static constexpr auto iter_swap    = ranges::iter_swap;
+  static constexpr auto next         = ranges::next;
+  static constexpr auto prev         = ranges::prev;
   static constexpr auto __advance_to = ranges::advance;
 };
 
@@ -67,7 +71,6 @@ struct _ClassicAlgPolicy {};
 
 template <>
 struct _IterOps<_ClassicAlgPolicy> {
-
   template <class _Iter>
   using __value_type = typename iterator_traits<_Iter>::value_type;
 
@@ -79,15 +82,14 @@ struct _IterOps<_ClassicAlgPolicy> {
 
   // advance
   template <class _Iter, class _Distance>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-  static void advance(_Iter& __iter, _Distance __count) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static void advance(_Iter& __iter, _Distance __count) {
     std::advance(__iter, __count);
   }
 
   // distance
   template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-  static typename iterator_traits<_Iter>::difference_type distance(_Iter __first, _Iter __last) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static typename iterator_traits<_Iter>::difference_type
+  distance(_Iter __first, _Iter __last) {
     return std::distance(__first, __last);
   }
 
@@ -98,37 +100,33 @@ struct _IterOps<_ClassicAlgPolicy> {
   using __move_t = decltype(std::move(*std::declval<_Iter&>()));
 
   template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-  static void __validate_iter_reference() {
-    static_assert(is_same<__deref_t<_Iter>, typename iterator_traits<__remove_cvref_t<_Iter> >::reference>::value,
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static void __validate_iter_reference() {
+    static_assert(
+        is_same<__deref_t<_Iter>, typename iterator_traits<__remove_cvref_t<_Iter> >::reference>::value,
         "It looks like your iterator's `iterator_traits<It>::reference` does not match the return type of "
         "dereferencing the iterator, i.e., calling `*it`. This is undefined behavior according to [input.iterators] "
         "and can lead to dangling reference issues at runtime, so we are flagging this.");
   }
 
   // iter_move
-  template <class _Iter>
+  template <class _Iter, __enable_if_t<is_reference<__deref_t<_Iter> >::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static
-  // If the result of dereferencing `_Iter` is a reference type, deduce the result of calling `std::move` on it. Note
-  // that the C++03 mode doesn't support `decltype(auto)` as the return type.
-  __enable_if_t<
-      is_reference<__deref_t<_Iter> >::value,
-      __move_t<_Iter> >
-  __iter_move(_Iter&& __i) {
+      // If the result of dereferencing `_Iter` is a reference type, deduce the result of calling `std::move` on it.
+      // Note that the C++03 mode doesn't support `decltype(auto)` as the return type.
+      __move_t<_Iter>
+      __iter_move(_Iter&& __i) {
     __validate_iter_reference<_Iter>();
 
     return std::move(*std::forward<_Iter>(__i));
   }
 
-  template <class _Iter>
+  template <class _Iter, __enable_if_t<!is_reference<__deref_t<_Iter> >::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static
-  // If the result of dereferencing `_Iter` is a value type, deduce the return value of this function to also be a
-  // value -- otherwise, after `operator*` returns a temporary, this function would return a dangling reference to that
-  // temporary. Note that the C++03 mode doesn't support `auto` as the return type.
-  __enable_if_t<
-      !is_reference<__deref_t<_Iter> >::value,
-      __deref_t<_Iter> >
-  __iter_move(_Iter&& __i) {
+      // If the result of dereferencing `_Iter` is a value type, deduce the return value of this function to also be a
+      // value -- otherwise, after `operator*` returns a temporary, this function would return a dangling reference to
+      // that temporary. Note that the C++03 mode doesn't support `auto` as the return type.
+      __deref_t<_Iter>
+      __iter_move(_Iter&& __i) {
     __validate_iter_reference<_Iter>();
 
     return *std::forward<_Iter>(__i);
@@ -136,40 +134,90 @@ struct _IterOps<_ClassicAlgPolicy> {
 
   // iter_swap
   template <class _Iter1, class _Iter2>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-  static void iter_swap(_Iter1&& __a, _Iter2&& __b) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static void iter_swap(_Iter1&& __a, _Iter2&& __b) {
     std::iter_swap(std::forward<_Iter1>(__a), std::forward<_Iter2>(__b));
   }
 
   // next
   template <class _Iterator>
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14
-  _Iterator next(_Iterator, _Iterator __last) {
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 _Iterator next(_Iterator, _Iterator __last) {
     return __last;
   }
 
   template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14
-  __remove_cvref_t<_Iter> next(_Iter&& __it,
-                          typename iterator_traits<__remove_cvref_t<_Iter> >::difference_type __n = 1) {
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 __remove_cvref_t<_Iter>
+  next(_Iter&& __it, typename iterator_traits<__remove_cvref_t<_Iter> >::difference_type __n = 1) {
     return std::next(std::forward<_Iter>(__it), __n);
   }
 
   // prev
   template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14
-  __remove_cvref_t<_Iter> prev(_Iter&& __iter,
-                 typename iterator_traits<__remove_cvref_t<_Iter> >::difference_type __n = 1) {
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 __remove_cvref_t<_Iter>
+  prev(_Iter&& __iter, typename iterator_traits<__remove_cvref_t<_Iter> >::difference_type __n = 1) {
     return std::prev(std::forward<_Iter>(__iter), __n);
   }
 
   template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14
-  void __advance_to(_Iter& __first, _Iter __last) {
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 void __advance_to(_Iter& __first, _Iter __last) {
     __first = __last;
   }
+
+  // advance with sentinel, a la std::ranges::advance
+  template <class _Iter>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static __difference_type<_Iter>
+  __advance_to(_Iter& __iter, __difference_type<_Iter> __count, const _Iter& __sentinel) {
+    return _IterOps::__advance_to(__iter, __count, __sentinel, typename iterator_traits<_Iter>::iterator_category());
+  }
+
+private:
+  // advance with sentinel, a la std::ranges::advance -- InputIterator specialization
+  template <class _InputIter>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static __difference_type<_InputIter> __advance_to(
+      _InputIter& __iter, __difference_type<_InputIter> __count, const _InputIter& __sentinel, input_iterator_tag) {
+    __difference_type<_InputIter> __dist = 0;
+    for (; __dist < __count && __iter != __sentinel; ++__dist)
+      ++__iter;
+    return __count - __dist;
+  }
+
+  // advance with sentinel, a la std::ranges::advance -- BidirectionalIterator specialization
+  template <class _BiDirIter>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static __difference_type<_BiDirIter>
+  __advance_to(_BiDirIter& __iter,
+               __difference_type<_BiDirIter> __count,
+               const _BiDirIter& __sentinel,
+               bidirectional_iterator_tag) {
+    __difference_type<_BiDirIter> __dist = 0;
+    if (__count >= 0)
+      for (; __dist < __count && __iter != __sentinel; ++__dist)
+        ++__iter;
+    else
+      for (__count = -__count; __dist < __count && __iter != __sentinel; ++__dist)
+        --__iter;
+    return __count - __dist;
+  }
+
+  // advance with sentinel, a la std::ranges::advance -- RandomIterator specialization
+  template <class _RandIter>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static __difference_type<_RandIter>
+  __advance_to(_RandIter& __iter,
+               __difference_type<_RandIter> __count,
+               const _RandIter& __sentinel,
+               random_access_iterator_tag) {
+    auto __dist = _IterOps::distance(__iter, __sentinel);
+    _LIBCPP_ASSERT_VALID_INPUT_RANGE(
+        __count == 0 || (__dist < 0) == (__count < 0), "__sentinel must precede __iter when __count < 0");
+    if (__count < 0)
+      __dist = __dist > __count ? __dist : __count;
+    else
+      __dist = __dist < __count ? __dist : __count;
+    __iter += __dist;
+    return __count - __dist;
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_ITERATOR_OPERATIONS_H
diff --git a/third_party/libcxx/__algorithm/lexicographical_compare.h b/third_party/libcxx/__algorithm/lexicographical_compare.h
index 0a13c5dd3..edc29e269 100644
--- a/third_party/libcxx/__algorithm/lexicographical_compare.h
+++ b/third_party/libcxx/__algorithm/lexicographical_compare.h
@@ -21,40 +21,35 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare, class _InputIterator1, class _InputIterator2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
-                          _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
-{
-    for (; __first2 != __last2; ++__first1, (void) ++__first2)
-    {
-        if (__first1 == __last1 || __comp(*__first1, *__first2))
-            return true;
-        if (__comp(*__first2, *__first1))
-            return false;
-    }
-    return false;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __lexicographical_compare(
+    _InputIterator1 __first1,
+    _InputIterator1 __last1,
+    _InputIterator2 __first2,
+    _InputIterator2 __last2,
+    _Compare __comp) {
+  for (; __first2 != __last2; ++__first1, (void)++__first2) {
+    if (__first1 == __last1 || __comp(*__first1, *__first2))
+      return true;
+    if (__comp(*__first2, *__first1))
+      return false;
+  }
+  return false;
 }
 
 template <class _InputIterator1, class _InputIterator2, class _Compare>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
-                        _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
-{
-    return _VSTD::__lexicographical_compare<__comp_ref_type<_Compare> >(__first1, __last1, __first2, __last2, __comp);
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool lexicographical_compare(
+    _InputIterator1 __first1,
+    _InputIterator1 __last1,
+    _InputIterator2 __first2,
+    _InputIterator2 __last2,
+    _Compare __comp) {
+  return std::__lexicographical_compare<__comp_ref_type<_Compare> >(__first1, __last1, __first2, __last2, __comp);
 }
 
 template <class _InputIterator1, class _InputIterator2>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
-                        _InputIterator2 __first2, _InputIterator2 __last2)
-{
-    return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2,
-                                         __less<typename iterator_traits<_InputIterator1>::value_type,
-                                                typename iterator_traits<_InputIterator2>::value_type>());
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool lexicographical_compare(
+    _InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
+  return std::lexicographical_compare(__first1, __last1, __first2, __last2, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/lexicographical_compare_three_way.h b/third_party/libcxx/__algorithm/lexicographical_compare_three_way.h
index 32de97d07..a5872e90c 100644
--- a/third_party/libcxx/__algorithm/lexicographical_compare_three_way.h
+++ b/third_party/libcxx/__algorithm/lexicographical_compare_three_way.h
@@ -17,7 +17,7 @@
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__type_traits/common_type.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -90,7 +90,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto __lexicographical_compare_three_way_slow_pa
 }
 
 template <class _InputIterator1, class _InputIterator2, class _Cmp>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto lexicographical_compare_three_way(
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto lexicographical_compare_three_way(
     _InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Cmp __comp)
     -> decltype(__comp(*__first1, *__first2)) {
   static_assert(__comparison_category<decltype(__comp(*__first1, *__first2))>,
@@ -110,7 +110,7 @@ _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto lexicographical_compa
 }
 
 template <class _InputIterator1, class _InputIterator2>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto lexicographical_compare_three_way(
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto lexicographical_compare_three_way(
     _InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
   return std::lexicographical_compare_three_way(
       std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), std::compare_three_way());
diff --git a/third_party/libcxx/__algorithm/lower_bound.h b/third_party/libcxx/__algorithm/lower_bound.h
index 810939375..c417d8483 100644
--- a/third_party/libcxx/__algorithm/lower_bound.h
+++ b/third_party/libcxx/__algorithm/lower_bound.h
@@ -27,11 +27,13 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _AlgPolicy, class _Iter, class _Sent, class _Type, class _Proj, class _Comp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_Iter __lower_bound_impl(_Iter __first, _Sent __last, const _Type& __value, _Comp& __comp, _Proj& __proj) {
-  auto __len = _IterOps<_AlgPolicy>::distance(__first, __last);
-
+template <class _AlgPolicy, class _Iter, class _Type, class _Proj, class _Comp>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter __lower_bound_bisecting(
+    _Iter __first,
+    const _Type& __value,
+    typename iterator_traits<_Iter>::difference_type __len,
+    _Comp& __comp,
+    _Proj& __proj) {
   while (__len != 0) {
     auto __l2 = std::__half_positive(__len);
     _Iter __m = __first;
@@ -46,20 +48,60 @@ _Iter __lower_bound_impl(_Iter __first, _Sent __last, const _Type& __value, _Com
   return __first;
 }
 
+// One-sided binary search, aka meta binary search, has been in the public domain for decades, and has the general
+// advantage of being \Omega(1) rather than the classic algorithm's \Omega(log(n)), with the downside of executing at
+// most 2*log(n) comparisons vs the classic algorithm's exact log(n). There are two scenarios in which it really shines:
+// the first one is when operating over non-random-access iterators, because the classic algorithm requires knowing the
+// container's size upfront, which adds \Omega(n) iterator increments to the complexity. The second one is when you're
+// traversing the container in order, trying to fast-forward to the next value: in that case, the classic algorithm
+// would yield \Omega(n*log(n)) comparisons and, for non-random-access iterators, \Omega(n^2) iterator increments,
+// whereas the one-sided version will yield O(n) operations on both counts, with a \Omega(log(n)) bound on the number of
+// comparisons.
+template <class _AlgPolicy, class _ForwardIterator, class _Sent, class _Type, class _Proj, class _Comp>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+__lower_bound_onesided(_ForwardIterator __first, _Sent __last, const _Type& __value, _Comp& __comp, _Proj& __proj) {
+  // step = 0, ensuring we can always short-circuit when distance is 1 later on
+  if (__first == __last || !std::__invoke(__comp, std::__invoke(__proj, *__first), __value))
+    return __first;
+
+  using _Distance = typename iterator_traits<_ForwardIterator>::difference_type;
+  for (_Distance __step = 1; __first != __last; __step <<= 1) {
+    auto __it   = __first;
+    auto __dist = __step - _IterOps<_AlgPolicy>::__advance_to(__it, __step, __last);
+    // once we reach the last range where needle can be we must start
+    // looking inwards, bisecting that range
+    if (__it == __last || !std::__invoke(__comp, std::__invoke(__proj, *__it), __value)) {
+      // we've already checked the previous value and it was less, we can save
+      // one comparison by skipping bisection
+      if (__dist == 1)
+        return __it;
+      return std::__lower_bound_bisecting<_AlgPolicy>(__first, __value, __dist, __comp, __proj);
+    }
+    // range not found, move forward!
+    __first = __it;
+  }
+  return __first;
+}
+
+template <class _AlgPolicy, class _ForwardIterator, class _Sent, class _Type, class _Proj, class _Comp>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+__lower_bound(_ForwardIterator __first, _Sent __last, const _Type& __value, _Comp& __comp, _Proj& __proj) {
+  const auto __dist = _IterOps<_AlgPolicy>::distance(__first, __last);
+  return std::__lower_bound_bisecting<_AlgPolicy>(__first, __value, __dist, __comp, __proj);
+}
+
 template <class _ForwardIterator, class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
-  static_assert(__is_callable<_Compare, decltype(*__first), const _Tp&>::value,
-                "The comparator has to be callable");
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
+  static_assert(__is_callable<_Compare, decltype(*__first), const _Tp&>::value, "The comparator has to be callable");
   auto __proj = std::__identity();
-  return std::__lower_bound_impl<_ClassicAlgPolicy>(__first, __last, __value, __comp, __proj);
+  return std::__lower_bound<_ClassicAlgPolicy>(__first, __last, __value, __comp, __proj);
 }
 
 template <class _ForwardIterator, class _Tp>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
-  return std::lower_bound(__first, __last, __value,
-                          __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
+  return std::lower_bound(__first, __last, __value, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/make_heap.h b/third_party/libcxx/__algorithm/make_heap.h
index d66cfe2e5..e8f0cdb27 100644
--- a/third_party/libcxx/__algorithm/make_heap.h
+++ b/third_party/libcxx/__algorithm/make_heap.h
@@ -21,36 +21,40 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-void __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) {
   __comp_ref_type<_Compare> __comp_ref = __comp;
 
   using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;
-  difference_type __n = __last - __first;
+  difference_type __n   = __last - __first;
   if (__n > 1) {
     // start from the first parent, there is no need to consider children
     for (difference_type __start = (__n - 2) / 2; __start >= 0; --__start) {
-        std::__sift_down<_AlgPolicy>(__first, __comp_ref, __n, __first + __start);
+      std::__sift_down<_AlgPolicy>(__first, __comp_ref, __n, __first + __start);
     }
   }
 }
 
 template <class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
   std::__make_heap<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp);
 }
 
 template <class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
-  std::make_heap(std::move(__first), std::move(__last),
-      __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
+  std::make_heap(std::move(__first), std::move(__last), __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_MAKE_HEAP_H
diff --git a/third_party/libcxx/__algorithm/make_projected.h b/third_party/libcxx/__algorithm/make_projected.h
index ec854763a..5245e523f 100644
--- a/third_party/libcxx/__algorithm/make_projected.h
+++ b/third_party/libcxx/__algorithm/make_projected.h
@@ -36,44 +36,38 @@ struct _ProjectedPred {
       : __pred(__pred_arg), __proj(__proj_arg) {}
 
   template <class _Tp>
-  typename __invoke_of<_Pred&,
-                       decltype(std::__invoke(std::declval<_Proj&>(), std::declval<_Tp>()))
-  >::type
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI operator()(_Tp&& __v) const {
+  typename __invoke_of<_Pred&, decltype(std::__invoke(std::declval<_Proj&>(), std::declval<_Tp>()))>::type
+      _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI
+      operator()(_Tp&& __v) const {
     return std::__invoke(__pred, std::__invoke(__proj, std::forward<_Tp>(__v)));
   }
 
   template <class _T1, class _T2>
   typename __invoke_of<_Pred&,
                        decltype(std::__invoke(std::declval<_Proj&>(), std::declval<_T1>())),
-                       decltype(std::__invoke(std::declval<_Proj&>(), std::declval<_T2>()))
-  >::type
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI operator()(_T1&& __lhs, _T2&& __rhs) const {
-    return std::__invoke(__pred,
-                      std::__invoke(__proj, std::forward<_T1>(__lhs)),
-                      std::__invoke(__proj, std::forward<_T2>(__rhs)));
+                       decltype(std::__invoke(std::declval<_Proj&>(), std::declval<_T2>()))>::type _LIBCPP_CONSTEXPR
+  _LIBCPP_HIDE_FROM_ABI
+  operator()(_T1&& __lhs, _T2&& __rhs) const {
+    return std::__invoke(
+        __pred, std::__invoke(__proj, std::forward<_T1>(__lhs)), std::__invoke(__proj, std::forward<_T2>(__rhs)));
   }
-
 };
 
-template <class _Pred,
-          class _Proj,
-          __enable_if_t<!(!is_member_pointer<__decay_t<_Pred> >::value &&
-                            __is_identity<__decay_t<_Proj> >::value),
-                        int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ProjectedPred<_Pred, _Proj>
-__make_projected(_Pred& __pred, _Proj& __proj) {
+template <
+    class _Pred,
+    class _Proj,
+    __enable_if_t<!(!is_member_pointer<__decay_t<_Pred> >::value && __is_identity<__decay_t<_Proj> >::value), int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ProjectedPred<_Pred, _Proj> __make_projected(_Pred& __pred, _Proj& __proj) {
   return _ProjectedPred<_Pred, _Proj>(__pred, __proj);
 }
 
 // Avoid creating the functor and just use the pristine comparator -- for certain algorithms, this would enable
 // optimizations that rely on the type of the comparator. Additionally, this results in less layers of indirection in
 // the call stack when the comparator is invoked, even in an unoptimized build.
-template <class _Pred,
-          class _Proj,
-          __enable_if_t<!is_member_pointer<__decay_t<_Pred> >::value &&
-                          __is_identity<__decay_t<_Proj> >::value,
-                        int> = 0>
+template <
+    class _Pred,
+    class _Proj,
+    __enable_if_t<!is_member_pointer<__decay_t<_Pred> >::value && __is_identity<__decay_t<_Proj> >::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Pred& __make_projected(_Pred& __pred, _Proj&) {
   return __pred;
 }
@@ -87,8 +81,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 
 template <class _Comp, class _Proj1, class _Proj2>
-_LIBCPP_HIDE_FROM_ABI constexpr
-decltype(auto) __make_projected_comp(_Comp& __comp, _Proj1& __proj1, _Proj2& __proj2) {
+_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) __make_projected_comp(_Comp& __comp, _Proj1& __proj1, _Proj2& __proj2) {
   if constexpr (__is_identity<decay_t<_Proj1>>::value && __is_identity<decay_t<_Proj2>>::value &&
                 !is_member_pointer_v<decay_t<_Comp>>) {
     // Avoid creating the lambda and just use the pristine comparator -- for certain algorithms, this would enable
@@ -96,10 +89,10 @@ decltype(auto) __make_projected_comp(_Comp& __comp, _Proj1& __proj1, _Proj2& __p
     return __comp;
 
   } else {
-    return [&](auto&& __lhs, auto&& __rhs) {
+    return [&](auto&& __lhs, auto&& __rhs) -> bool {
       return std::invoke(__comp,
-                        std::invoke(__proj1, std::forward<decltype(__lhs)>(__lhs)),
-                        std::invoke(__proj2, std::forward<decltype(__rhs)>(__rhs)));
+                         std::invoke(__proj1, std::forward<decltype(__lhs)>(__lhs)),
+                         std::invoke(__proj2, std::forward<decltype(__rhs)>(__rhs)));
     };
   }
 }
diff --git a/third_party/libcxx/__algorithm/max.h b/third_party/libcxx/__algorithm/max.h
index 97f61f2aa..d4c99f6f3 100644
--- a/third_party/libcxx/__algorithm/max.h
+++ b/third_party/libcxx/__algorithm/max.h
@@ -25,41 +25,28 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const _Tp&
-max(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b, _Compare __comp)
-{
-    return __comp(__a, __b) ? __b : __a;
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp&
+max(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b, _Compare __comp) {
+  return __comp(__a, __b) ? __b : __a;
 }
 
 template <class _Tp>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const _Tp&
-max(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b)
-{
-    return _VSTD::max(__a, __b, __less<_Tp>());
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp&
+max(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b) {
+  return std::max(__a, __b, __less<>());
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template<class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp
-max(initializer_list<_Tp> __t, _Compare __comp)
-{
-    return *_VSTD::__max_element<__comp_ref_type<_Compare> >(__t.begin(), __t.end(), __comp);
+template <class _Tp, class _Compare>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp
+max(initializer_list<_Tp> __t, _Compare __comp) {
+  return *std::__max_element<__comp_ref_type<_Compare> >(__t.begin(), __t.end(), __comp);
 }
 
-template<class _Tp>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp
-max(initializer_list<_Tp> __t)
-{
-    return *_VSTD::max_element(__t.begin(), __t.end(), __less<_Tp>());
+template <class _Tp>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp max(initializer_list<_Tp> __t) {
+  return *std::max_element(__t.begin(), __t.end(), __less<>());
 }
 
 #endif // _LIBCPP_CXX03_LANG
diff --git a/third_party/libcxx/__algorithm/max_element.h b/third_party/libcxx/__algorithm/max_element.h
index f816a17fa..c036726cb 100644
--- a/third_party/libcxx/__algorithm/max_element.h
+++ b/third_party/libcxx/__algorithm/max_element.h
@@ -22,34 +22,28 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare, class _ForwardIterator>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
-__max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
-{
-    static_assert(__has_forward_iterator_category<_ForwardIterator>::value,
-        "std::max_element requires a ForwardIterator");
-    if (__first != __last)
-    {
-        _ForwardIterator __i = __first;
-        while (++__i != __last)
-            if (__comp(*__first, *__i))
-                __first = __i;
-    }
-    return __first;
+__max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
+  static_assert(
+      __has_forward_iterator_category<_ForwardIterator>::value, "std::max_element requires a ForwardIterator");
+  if (__first != __last) {
+    _ForwardIterator __i = __first;
+    while (++__i != __last)
+      if (__comp(*__first, *__i))
+        __first = __i;
+  }
+  return __first;
 }
 
 template <class _ForwardIterator, class _Compare>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
-max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
-{
-    return _VSTD::__max_element<__comp_ref_type<_Compare> >(__first, __last, __comp);
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
+max_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
+  return std::__max_element<__comp_ref_type<_Compare> >(__first, __last, __comp);
 }
 
-
 template <class _ForwardIterator>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
-max_element(_ForwardIterator __first, _ForwardIterator __last)
-{
-    return _VSTD::max_element(__first, __last,
-              __less<typename iterator_traits<_ForwardIterator>::value_type>());
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
+max_element(_ForwardIterator __first, _ForwardIterator __last) {
+  return std::max_element(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/merge.h b/third_party/libcxx/__algorithm/merge.h
index e54e430bc..bad663c4b 100644
--- a/third_party/libcxx/__algorithm/merge.h
+++ b/third_party/libcxx/__algorithm/merge.h
@@ -22,47 +22,46 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-__merge(_InputIterator1 __first1, _InputIterator1 __last1,
-        _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
-{
-    for (; __first1 != __last1; ++__result)
-    {
-        if (__first2 == __last2)
-            return _VSTD::copy(__first1, __last1, __result);
-        if (__comp(*__first2, *__first1))
-        {
-            *__result = *__first2;
-            ++__first2;
-        }
-        else
-        {
-            *__result = *__first1;
-            ++__first1;
-        }
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator __merge(
+    _InputIterator1 __first1,
+    _InputIterator1 __last1,
+    _InputIterator2 __first2,
+    _InputIterator2 __last2,
+    _OutputIterator __result,
+    _Compare __comp) {
+  for (; __first1 != __last1; ++__result) {
+    if (__first2 == __last2)
+      return std::copy(__first1, __last1, __result);
+    if (__comp(*__first2, *__first1)) {
+      *__result = *__first2;
+      ++__first2;
+    } else {
+      *__result = *__first1;
+      ++__first1;
     }
-    return _VSTD::copy(__first2, __last2, __result);
+  }
+  return std::copy(__first2, __last2, __result);
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-merge(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result, _Compare __comp)
-{
-    return _VSTD::__merge<__comp_ref_type<_Compare> >(__first1, __last1, __first2, __last2, __result, __comp);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+merge(_InputIterator1 __first1,
+      _InputIterator1 __last1,
+      _InputIterator2 __first2,
+      _InputIterator2 __last2,
+      _OutputIterator __result,
+      _Compare __comp) {
+  return std::__merge<__comp_ref_type<_Compare> >(__first1, __last1, __first2, __last2, __result, __comp);
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-merge(_InputIterator1 __first1, _InputIterator1 __last1,
-      _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
-{
-    typedef typename iterator_traits<_InputIterator1>::value_type __v1;
-    typedef typename iterator_traits<_InputIterator2>::value_type __v2;
-    return _VSTD::merge(__first1, __last1, __first2, __last2, __result, __less<__v1, __v2>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+merge(_InputIterator1 __first1,
+      _InputIterator1 __last1,
+      _InputIterator2 __first2,
+      _InputIterator2 __last2,
+      _OutputIterator __result) {
+  return std::merge(__first1, __last1, __first2, __last2, __result, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/min.h b/third_party/libcxx/__algorithm/min.h
index d073a1653..1bafad8a4 100644
--- a/third_party/libcxx/__algorithm/min.h
+++ b/third_party/libcxx/__algorithm/min.h
@@ -25,41 +25,28 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const _Tp&
-min(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b, _Compare __comp)
-{
-    return __comp(__b, __a) ? __b : __a;
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp&
+min(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b, _Compare __comp) {
+  return __comp(__b, __a) ? __b : __a;
 }
 
 template <class _Tp>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const _Tp&
-min(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b)
-{
-    return _VSTD::min(__a, __b, __less<_Tp>());
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp&
+min(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b) {
+  return std::min(__a, __b, __less<>());
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template<class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp
-min(initializer_list<_Tp> __t, _Compare __comp)
-{
-    return *_VSTD::__min_element<__comp_ref_type<_Compare> >(__t.begin(), __t.end(), __comp);
+template <class _Tp, class _Compare>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp
+min(initializer_list<_Tp> __t, _Compare __comp) {
+  return *std::__min_element<__comp_ref_type<_Compare> >(__t.begin(), __t.end(), __comp);
 }
 
-template<class _Tp>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp
-min(initializer_list<_Tp> __t)
-{
-    return *_VSTD::min_element(__t.begin(), __t.end(), __less<_Tp>());
+template <class _Tp>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp min(initializer_list<_Tp> __t) {
+  return *std::min_element(__t.begin(), __t.end(), __less<>());
 }
 
 #endif // _LIBCPP_CXX03_LANG
diff --git a/third_party/libcxx/__algorithm/min_element.h b/third_party/libcxx/__algorithm/min_element.h
index aeabd30a7..65f3594d6 100644
--- a/third_party/libcxx/__algorithm/min_element.h
+++ b/third_party/libcxx/__algorithm/min_element.h
@@ -22,11 +22,14 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Comp, class _Iter, class _Sent, class _Proj>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Iter __min_element(_Iter __first, _Sent __last, _Comp __comp, _Proj& __proj) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Iter
+__min_element(_Iter __first, _Sent __last, _Comp __comp, _Proj& __proj) {
   if (__first == __last)
     return __first;
 
@@ -39,32 +42,30 @@ _Iter __min_element(_Iter __first, _Sent __last, _Comp __comp, _Proj& __proj) {
 }
 
 template <class _Comp, class _Iter, class _Sent>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Iter __min_element(_Iter __first, _Sent __last, _Comp __comp) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Iter __min_element(_Iter __first, _Sent __last, _Comp __comp) {
   auto __proj = __identity();
   return std::__min_element<_Comp>(std::move(__first), std::move(__last), __comp, __proj);
 }
 
 template <class _ForwardIterator, class _Compare>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
-min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
-{
-  static_assert(__has_forward_iterator_category<_ForwardIterator>::value,
-      "std::min_element requires a ForwardIterator");
-  static_assert(__is_callable<_Compare, decltype(*__first), decltype(*__first)>::value,
-              "The comparator has to be callable");
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
+min_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
+  static_assert(
+      __has_forward_iterator_category<_ForwardIterator>::value, "std::min_element requires a ForwardIterator");
+  static_assert(
+      __is_callable<_Compare, decltype(*__first), decltype(*__first)>::value, "The comparator has to be callable");
 
   return std::__min_element<__comp_ref_type<_Compare> >(std::move(__first), std::move(__last), __comp);
 }
 
 template <class _ForwardIterator>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
-min_element(_ForwardIterator __first, _ForwardIterator __last)
-{
-    return _VSTD::min_element(__first, __last,
-              __less<typename iterator_traits<_ForwardIterator>::value_type>());
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
+min_element(_ForwardIterator __first, _ForwardIterator __last) {
+  return std::min_element(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_MIN_ELEMENT_H
diff --git a/third_party/libcxx/__algorithm/min_max_result.h b/third_party/libcxx/__algorithm/min_max_result.h
index ef2d99038..e988df7c1 100644
--- a/third_party/libcxx/__algorithm/min_max_result.h
+++ b/third_party/libcxx/__algorithm/min_max_result.h
@@ -34,7 +34,7 @@ struct min_max_result {
 
   template <class _T2>
     requires convertible_to<const _T1&, _T2>
-  _LIBCPP_HIDE_FROM_ABI constexpr operator min_max_result<_T2>() const & {
+  _LIBCPP_HIDE_FROM_ABI constexpr operator min_max_result<_T2>() const& {
     return {min, max};
   }
 
diff --git a/third_party/libcxx/__algorithm/minmax.h b/third_party/libcxx/__algorithm/minmax.h
index f486de2ef..9feda2b4c 100644
--- a/third_party/libcxx/__algorithm/minmax.h
+++ b/third_party/libcxx/__algorithm/minmax.h
@@ -23,43 +23,33 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<const _Tp&, const _Tp&>
-minmax(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b, _Compare __comp)
-{
-    return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) :
-                              pair<const _Tp&, const _Tp&>(__a, __b);
+template <class _Tp, class _Compare>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<const _Tp&, const _Tp&>
+minmax(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b, _Compare __comp) {
+  return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a) : pair<const _Tp&, const _Tp&>(__a, __b);
 }
 
-template<class _Tp>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<const _Tp&, const _Tp&>
-minmax(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b)
-{
-    return std::minmax(__a, __b, __less<_Tp>());
+template <class _Tp>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<const _Tp&, const _Tp&>
+minmax(_LIBCPP_LIFETIMEBOUND const _Tp& __a, _LIBCPP_LIFETIMEBOUND const _Tp& __b) {
+  return std::minmax(__a, __b, __less<>());
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template<class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Tp, _Tp> minmax(initializer_list<_Tp> __t, _Compare __comp) {
-    static_assert(__is_callable<_Compare, _Tp, _Tp>::value, "The comparator has to be callable");
-    __identity __proj;
-    auto __ret = std::__minmax_element_impl(__t.begin(), __t.end(), __comp, __proj);
-    return pair<_Tp, _Tp>(*__ret.first, *__ret.second);
+template <class _Tp, class _Compare>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Tp, _Tp>
+minmax(initializer_list<_Tp> __t, _Compare __comp) {
+  static_assert(__is_callable<_Compare, _Tp, _Tp>::value, "The comparator has to be callable");
+  __identity __proj;
+  auto __ret = std::__minmax_element_impl(__t.begin(), __t.end(), __comp, __proj);
+  return pair<_Tp, _Tp>(*__ret.first, *__ret.second);
 }
 
-template<class _Tp>
-_LIBCPP_NODISCARD_EXT inline
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Tp, _Tp>
-minmax(initializer_list<_Tp> __t)
-{
-    return std::minmax(__t, __less<_Tp>());
+template <class _Tp>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Tp, _Tp>
+minmax(initializer_list<_Tp> __t) {
+  return std::minmax(__t, __less<>());
 }
 
 #endif // _LIBCPP_CXX03_LANG
diff --git a/third_party/libcxx/__algorithm/minmax_element.h b/third_party/libcxx/__algorithm/minmax_element.h
index eca460de3..43cb23347 100644
--- a/third_party/libcxx/__algorithm/minmax_element.h
+++ b/third_party/libcxx/__algorithm/minmax_element.h
@@ -29,19 +29,18 @@ class _MinmaxElementLessFunc {
   _Proj& __proj_;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-  _MinmaxElementLessFunc(_Comp& __comp, _Proj& __proj) : __comp_(__comp), __proj_(__proj) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _MinmaxElementLessFunc(_Comp& __comp, _Proj& __proj)
+      : __comp_(__comp), __proj_(__proj) {}
 
   template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-  bool operator()(_Iter& __it1, _Iter& __it2) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(_Iter& __it1, _Iter& __it2) {
     return std::__invoke(__comp_, std::__invoke(__proj_, *__it1), std::__invoke(__proj_, *__it2));
   }
 };
 
 template <class _Iter, class _Sent, class _Proj, class _Comp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Iter, _Iter> __minmax_element_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter, _Iter>
+__minmax_element_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
   auto __less = _MinmaxElementLessFunc<_Comp, _Proj>(__comp, __proj);
 
   pair<_Iter, _Iter> __result(__first, __first);
@@ -66,8 +65,8 @@ pair<_Iter, _Iter> __minmax_element_impl(_Iter __first, _Sent __last, _Comp& __c
     if (__less(__first, __i)) {
       if (__less(__first, __result.first))
         __result.first = __first;
-    if (!__less(__i, __result.second))
-      __result.second = __i;
+      if (!__less(__i, __result.second))
+        __result.second = __i;
     } else {
       if (__less(__i, __result.first))
         __result.first = __i;
@@ -80,21 +79,20 @@ pair<_Iter, _Iter> __minmax_element_impl(_Iter __first, _Sent __last, _Comp& __c
 }
 
 template <class _ForwardIterator, class _Compare>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_ForwardIterator, _ForwardIterator>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_ForwardIterator, _ForwardIterator>
 minmax_element(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
-  static_assert(__has_forward_iterator_category<_ForwardIterator>::value,
-                "std::minmax_element requires a ForwardIterator");
-  static_assert(__is_callable<_Compare, decltype(*__first), decltype(*__first)>::value,
-                "The comparator has to be callable");
+  static_assert(
+      __has_forward_iterator_category<_ForwardIterator>::value, "std::minmax_element requires a ForwardIterator");
+  static_assert(
+      __is_callable<_Compare, decltype(*__first), decltype(*__first)>::value, "The comparator has to be callable");
   auto __proj = __identity();
   return std::__minmax_element_impl(__first, __last, __comp, __proj);
 }
 
 template <class _ForwardIterator>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_ForwardIterator, _ForwardIterator> minmax_element(_ForwardIterator __first, _ForwardIterator __last) {
-    return std::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_ForwardIterator, _ForwardIterator>
+minmax_element(_ForwardIterator __first, _ForwardIterator __last) {
+  return std::minmax_element(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/mismatch.h b/third_party/libcxx/__algorithm/mismatch.h
index e5b014f45..632bec024 100644
--- a/third_party/libcxx/__algorithm/mismatch.h
+++ b/third_party/libcxx/__algorithm/mismatch.h
@@ -11,53 +11,207 @@
 #define _LIBCPP___ALGORITHM_MISMATCH_H
 
 #include <__algorithm/comp.h>
+#include <__algorithm/min.h>
+#include <__algorithm/simd_utils.h>
+#include <__algorithm/unwrap_iter.h>
 #include <__config>
-#include <__iterator/iterator_traits.h>
+#include <__functional/identity.h>
+#include <__iterator/aliasing_iterator.h>
+#include <__type_traits/desugars_to.h>
+#include <__type_traits/invoke.h>
+#include <__type_traits/is_constant_evaluated.h>
+#include <__type_traits/is_equality_comparable.h>
+#include <__type_traits/is_integral.h>
+#include <__utility/move.h>
 #include <__utility/pair.h>
+#include <__utility/unreachable.h>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) {
-  for (; __first1 != __last1; ++__first1, (void)++__first2)
-    if (!__pred(*__first1, *__first2))
+template <class _Iter1, class _Sent1, class _Iter2, class _Pred, class _Proj1, class _Proj2>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Iter1, _Iter2>
+__mismatch_loop(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
+  while (__first1 != __last1) {
+    if (!std::__invoke(__pred, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
       break;
-  return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    ++__first1;
+    ++__first2;
+  }
+  return std::make_pair(std::move(__first1), std::move(__first2));
+}
+
+template <class _Iter1, class _Sent1, class _Iter2, class _Pred, class _Proj1, class _Proj2>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Iter1, _Iter2>
+__mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
+  return std::__mismatch_loop(__first1, __last1, __first2, __pred, __proj1, __proj2);
+}
+
+#if _LIBCPP_VECTORIZE_ALGORITHMS
+
+template <class _Iter>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Iter, _Iter>
+__mismatch_vectorized(_Iter __first1, _Iter __last1, _Iter __first2) {
+  using __value_type              = __iter_value_type<_Iter>;
+  constexpr size_t __unroll_count = 4;
+  constexpr size_t __vec_size     = __native_vector_size<__value_type>;
+  using __vec                     = __simd_vector<__value_type, __vec_size>;
+
+  if (!__libcpp_is_constant_evaluated()) {
+    auto __orig_first1 = __first1;
+    auto __last2       = __first2 + (__last1 - __first1);
+    while (static_cast<size_t>(__last1 - __first1) >= __unroll_count * __vec_size) [[__unlikely__]] {
+      __vec __lhs[__unroll_count];
+      __vec __rhs[__unroll_count];
+
+      for (size_t __i = 0; __i != __unroll_count; ++__i) {
+        __lhs[__i] = std::__load_vector<__vec>(__first1 + __i * __vec_size);
+        __rhs[__i] = std::__load_vector<__vec>(__first2 + __i * __vec_size);
+      }
+
+      for (size_t __i = 0; __i != __unroll_count; ++__i) {
+        if (auto __cmp_res = __lhs[__i] == __rhs[__i]; !std::__all_of(__cmp_res)) {
+          auto __offset = __i * __vec_size + std::__find_first_not_set(__cmp_res);
+          return {__first1 + __offset, __first2 + __offset};
+        }
+      }
+
+      __first1 += __unroll_count * __vec_size;
+      __first2 += __unroll_count * __vec_size;
+    }
+
+    // check the remaining 0-3 vectors
+    while (static_cast<size_t>(__last1 - __first1) >= __vec_size) {
+      if (auto __cmp_res = std::__load_vector<__vec>(__first1) == std::__load_vector<__vec>(__first2);
+          !std::__all_of(__cmp_res)) {
+        auto __offset = std::__find_first_not_set(__cmp_res);
+        return {__first1 + __offset, __first2 + __offset};
+      }
+      __first1 += __vec_size;
+      __first2 += __vec_size;
+    }
+
+    if (__last1 - __first1 == 0)
+      return {__first1, __first2};
+
+    // Check if we can load elements in front of the current pointer. If that's the case load a vector at
+    // (last - vector_size) to check the remaining elements
+    if (static_cast<size_t>(__first1 - __orig_first1) >= __vec_size) {
+      __first1 = __last1 - __vec_size;
+      __first2 = __last2 - __vec_size;
+      auto __offset =
+          std::__find_first_not_set(std::__load_vector<__vec>(__first1) == std::__load_vector<__vec>(__first2));
+      return {__first1 + __offset, __first2 + __offset};
+    } // else loop over the elements individually
+  }
+
+  __equal_to __pred;
+  __identity __proj;
+  return std::__mismatch_loop(__first1, __last1, __first2, __pred, __proj, __proj);
+}
+
+template <class _Tp,
+          class _Pred,
+          class _Proj1,
+          class _Proj2,
+          __enable_if_t<is_integral<_Tp>::value && __desugars_to_v<__equal_tag, _Pred, _Tp, _Tp> &&
+                            __is_identity<_Proj1>::value && __is_identity<_Proj2>::value,
+                        int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Tp*, _Tp*>
+__mismatch(_Tp* __first1, _Tp* __last1, _Tp* __first2, _Pred&, _Proj1&, _Proj2&) {
+  return std::__mismatch_vectorized(__first1, __last1, __first2);
+}
+
+template <class _Tp,
+          class _Pred,
+          class _Proj1,
+          class _Proj2,
+          __enable_if_t<!is_integral<_Tp>::value && __desugars_to_v<__equal_tag, _Pred, _Tp, _Tp> &&
+                            __is_identity<_Proj1>::value && __is_identity<_Proj2>::value &&
+                            __can_map_to_integer_v<_Tp> && __libcpp_is_trivially_equality_comparable<_Tp, _Tp>::value,
+                        int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Tp*, _Tp*>
+__mismatch(_Tp* __first1, _Tp* __last1, _Tp* __first2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
+  if (__libcpp_is_constant_evaluated()) {
+    return std::__mismatch_loop(__first1, __last1, __first2, __pred, __proj1, __proj2);
+  } else {
+    using _Iter = __aliasing_iterator<_Tp*, __get_as_integer_type_t<_Tp>>;
+    auto __ret  = std::__mismatch_vectorized(_Iter(__first1), _Iter(__last1), _Iter(__first2));
+    return {__ret.first.__base(), __ret.second.__base()};
+  }
+}
+#endif // _LIBCPP_VECTORIZE_ALGORITHMS
+
+template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
+mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) {
+  __identity __proj;
+  auto __res = std::__mismatch(
+      std::__unwrap_iter(__first1), std::__unwrap_iter(__last1), std::__unwrap_iter(__first2), __pred, __proj, __proj);
+  return std::make_pair(std::__rewrap_iter(__first1, __res.first), std::__rewrap_iter(__first2, __res.second));
 }
 
 template <class _InputIterator1, class _InputIterator2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
+mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2) {
   return std::mismatch(__first1, __last1, __first2, __equal_to());
 }
 
 #if _LIBCPP_STD_VER >= 14
-template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2,
-             _BinaryPredicate __pred) {
-  for (; __first1 != __last1 && __first2 != __last2; ++__first1, (void)++__first2)
-    if (!__pred(*__first1, *__first2))
+template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Iter1, _Iter2> __mismatch(
+    _Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
+  while (__first1 != __last1 && __first2 != __last2) {
+    if (!std::__invoke(__pred, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
       break;
-  return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    ++__first1;
+    ++__first2;
+  }
+  return {std::move(__first1), std::move(__first2)};
+}
+
+template <class _Tp, class _Pred, class _Proj1, class _Proj2>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Tp*, _Tp*>
+__mismatch(_Tp* __first1, _Tp* __last1, _Tp* __first2, _Tp* __last2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
+  auto __len = std::min(__last1 - __first1, __last2 - __first2);
+  return std::__mismatch(__first1, __first1 + __len, __first2, __pred, __proj1, __proj2);
+}
+
+template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
+mismatch(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _BinaryPredicate __pred) {
+  __identity __proj;
+  auto __res = std::__mismatch(
+      std::__unwrap_iter(__first1),
+      std::__unwrap_iter(__last1),
+      std::__unwrap_iter(__first2),
+      std::__unwrap_iter(__last2),
+      __pred,
+      __proj,
+      __proj);
+  return {std::__rewrap_iter(__first1, __res.first), std::__rewrap_iter(__first2, __res.second)};
 }
 
 template <class _InputIterator1, class _InputIterator2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
-    mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator1, _InputIterator2>
+mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2) {
   return std::mismatch(__first1, __last1, __first2, __last2, __equal_to());
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_MISMATCH_H
diff --git a/third_party/libcxx/__algorithm/move.h b/third_party/libcxx/__algorithm/move.h
index b1b702a06..1716d43e2 100644
--- a/third_party/libcxx/__algorithm/move.h
+++ b/third_party/libcxx/__algorithm/move.h
@@ -16,7 +16,7 @@
 #include <__config>
 #include <__iterator/segmented_iterator.h>
 #include <__type_traits/common_type.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 
@@ -34,7 +34,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIte
 __move(_InIter __first, _Sent __last, _OutIter __result);
 
 template <class _AlgPolicy>
-struct __move_loop {
+struct __move_impl {
   template <class _InIter, class _Sent, class _OutIter>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
   operator()(_InIter __first, _Sent __last, _OutIter __result) const {
@@ -52,9 +52,10 @@ struct __move_loop {
 
     _OutIter& __result_;
 
-    _LIBCPP_HIDE_FROM_ABI _MoveSegment(_OutIter& __result) : __result_(__result) {}
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit _MoveSegment(_OutIter& __result)
+        : __result_(__result) {}
 
-    _LIBCPP_HIDE_FROM_ABI void
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
     operator()(typename _Traits::__local_iterator __lfirst, typename _Traits::__local_iterator __llast) {
       __result_ = std::__move<_AlgPolicy>(__lfirst, __llast, std::move(__result_)).second;
     }
@@ -73,7 +74,7 @@ struct __move_loop {
                               !__is_segmented_iterator<_InIter>::value && __is_segmented_iterator<_OutIter>::value,
                           int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
-  operator()(_InIter __first, _InIter __last, _OutIter __result) {
+  operator()(_InIter __first, _InIter __last, _OutIter __result) const {
     using _Traits = __segmented_iterator_traits<_OutIter>;
     using _DiffT  = typename common_type<__iter_diff_t<_InIter>, __iter_diff_t<_OutIter> >::type;
 
@@ -94,12 +95,9 @@ struct __move_loop {
       __local_first = _Traits::__begin(++__segment_iterator);
     }
   }
-};
 
-struct __move_trivial {
   // At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
-  template <class _In, class _Out,
-            __enable_if_t<__can_lower_move_assignment_to_memmove<_In, _Out>::value, int> = 0>
+  template <class _In, class _Out, __enable_if_t<__can_lower_move_assignment_to_memmove<_In, _Out>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
   operator()(_In* __first, _In* __last, _Out* __result) const {
     return std::__copy_trivial_impl(__first, __last, __result);
@@ -109,7 +107,7 @@ struct __move_trivial {
 template <class _AlgPolicy, class _InIter, class _Sent, class _OutIter>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
 __move(_InIter __first, _Sent __last, _OutIter __result) {
-  return std::__dispatch_copy_or_move<_AlgPolicy, __move_loop<_AlgPolicy>, __move_trivial>(
+  return std::__copy_move_unwrap_iters<__move_impl<_AlgPolicy> >(
       std::move(__first), std::move(__last), std::move(__result));
 }
 
diff --git a/third_party/libcxx/__algorithm/move_backward.h b/third_party/libcxx/__algorithm/move_backward.h
index db4c4db1c..4beb7bdba 100644
--- a/third_party/libcxx/__algorithm/move_backward.h
+++ b/third_party/libcxx/__algorithm/move_backward.h
@@ -15,7 +15,7 @@
 #include <__config>
 #include <__iterator/segmented_iterator.h>
 #include <__type_traits/common_type.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 
@@ -33,7 +33,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_BidirectionalIterator1
 __move_backward(_BidirectionalIterator1 __first, _Sentinel __last, _BidirectionalIterator2 __result);
 
 template <class _AlgPolicy>
-struct __move_backward_loop {
+struct __move_backward_impl {
   template <class _InIter, class _Sent, class _OutIter>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
   operator()(_InIter __first, _Sent __last, _OutIter __result) const {
@@ -80,7 +80,7 @@ struct __move_backward_loop {
                               !__is_segmented_iterator<_InIter>::value && __is_segmented_iterator<_OutIter>::value,
                           int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
-  operator()(_InIter __first, _InIter __last, _OutIter __result) {
+  operator()(_InIter __first, _InIter __last, _OutIter __result) const {
     using _Traits = __segmented_iterator_traits<_OutIter>;
     using _DiffT  = typename common_type<__iter_diff_t<_InIter>, __iter_diff_t<_OutIter> >::type;
 
@@ -104,12 +104,9 @@ struct __move_backward_loop {
       __local_last = _Traits::__end(--__segment_iterator);
     }
   }
-};
 
-struct __move_backward_trivial {
   // At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
-  template <class _In, class _Out,
-            __enable_if_t<__can_lower_move_assignment_to_memmove<_In, _Out>::value, int> = 0>
+  template <class _In, class _Out, __enable_if_t<__can_lower_move_assignment_to_memmove<_In, _Out>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In*, _Out*>
   operator()(_In* __first, _In* __last, _Out* __result) const {
     return std::__copy_backward_trivial_impl(__first, __last, __result);
@@ -120,14 +117,15 @@ template <class _AlgPolicy, class _BidirectionalIterator1, class _Sentinel, clas
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_BidirectionalIterator1, _BidirectionalIterator2>
 __move_backward(_BidirectionalIterator1 __first, _Sentinel __last, _BidirectionalIterator2 __result) {
   static_assert(std::is_copy_constructible<_BidirectionalIterator1>::value &&
-                std::is_copy_constructible<_BidirectionalIterator1>::value, "Iterators must be copy constructible.");
+                    std::is_copy_constructible<_BidirectionalIterator1>::value,
+                "Iterators must be copy constructible.");
 
-  return std::__dispatch_copy_or_move<_AlgPolicy, __move_backward_loop<_AlgPolicy>, __move_backward_trivial>(
+  return std::__copy_move_unwrap_iters<__move_backward_impl<_AlgPolicy> >(
       std::move(__first), std::move(__last), std::move(__result));
 }
 
 template <class _BidirectionalIterator1, class _BidirectionalIterator2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _BidirectionalIterator2
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _BidirectionalIterator2
 move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, _BidirectionalIterator2 __result) {
   return std::__move_backward<_ClassicAlgPolicy>(std::move(__first), std::move(__last), std::move(__result)).second;
 }
diff --git a/third_party/libcxx/__algorithm/next_permutation.h b/third_party/libcxx/__algorithm/next_permutation.h
index 73e8b99ab..011ee028c 100644
--- a/third_party/libcxx/__algorithm/next_permutation.h
+++ b/third_party/libcxx/__algorithm/next_permutation.h
@@ -22,57 +22,54 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _BidirectionalIterator, class _Sentinel>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_BidirectionalIterator, bool>
-__next_permutation(_BidirectionalIterator __first, _Sentinel __last, _Compare&& __comp)
-{
-    using _Result = pair<_BidirectionalIterator, bool>;
+__next_permutation(_BidirectionalIterator __first, _Sentinel __last, _Compare&& __comp) {
+  using _Result = pair<_BidirectionalIterator, bool>;
 
-    _BidirectionalIterator __last_iter = _IterOps<_AlgPolicy>::next(__first, __last);
-    _BidirectionalIterator __i = __last_iter;
-    if (__first == __last || __first == --__i)
-        return _Result(std::move(__last_iter), false);
+  _BidirectionalIterator __last_iter = _IterOps<_AlgPolicy>::next(__first, __last);
+  _BidirectionalIterator __i         = __last_iter;
+  if (__first == __last || __first == --__i)
+    return _Result(std::move(__last_iter), false);
 
-    while (true)
-    {
-        _BidirectionalIterator __ip1 = __i;
-        if (__comp(*--__i, *__ip1))
-        {
-            _BidirectionalIterator __j = __last_iter;
-            while (!__comp(*__i, *--__j))
-                ;
-            _IterOps<_AlgPolicy>::iter_swap(__i, __j);
-            std::__reverse<_AlgPolicy>(__ip1, __last_iter);
-            return _Result(std::move(__last_iter), true);
-        }
-        if (__i == __first)
-        {
-            std::__reverse<_AlgPolicy>(__first, __last_iter);
-            return _Result(std::move(__last_iter), false);
-        }
+  while (true) {
+    _BidirectionalIterator __ip1 = __i;
+    if (__comp(*--__i, *__ip1)) {
+      _BidirectionalIterator __j = __last_iter;
+      while (!__comp(*__i, *--__j))
+        ;
+      _IterOps<_AlgPolicy>::iter_swap(__i, __j);
+      std::__reverse<_AlgPolicy>(__ip1, __last_iter);
+      return _Result(std::move(__last_iter), true);
     }
+    if (__i == __first) {
+      std::__reverse<_AlgPolicy>(__first, __last_iter);
+      return _Result(std::move(__last_iter), false);
+    }
+  }
 }
 
 template <class _BidirectionalIterator, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
-{
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) {
   return std::__next_permutation<_ClassicAlgPolicy>(
-      std::move(__first), std::move(__last), static_cast<__comp_ref_type<_Compare> >(__comp)).second;
+             std::move(__first), std::move(__last), static_cast<__comp_ref_type<_Compare> >(__comp))
+      .second;
 }
 
 template <class _BidirectionalIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
-{
-    return _VSTD::next_permutation(__first, __last,
-                                  __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) {
+  return std::next_permutation(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_NEXT_PERMUTATION_H
diff --git a/third_party/libcxx/__algorithm/none_of.h b/third_party/libcxx/__algorithm/none_of.h
index 19357eb23..50841ba17 100644
--- a/third_party/libcxx/__algorithm/none_of.h
+++ b/third_party/libcxx/__algorithm/none_of.h
@@ -19,7 +19,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Predicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
   for (; __first != __last; ++__first)
     if (__pred(*__first))
diff --git a/third_party/libcxx/__algorithm/nth_element.h b/third_party/libcxx/__algorithm/nth_element.h
index 9fdfb2cae..da748d725 100644
--- a/third_party/libcxx/__algorithm/nth_element.h
+++ b/third_party/libcxx/__algorithm/nth_element.h
@@ -13,8 +13,8 @@
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/sort.h>
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__debug_utils/randomize_range.h>
 #include <__iterator/iterator_traits.h>
 #include <__utility/move.h>
@@ -23,209 +23,212 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Compare, class _RandomAccessIterator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
-__nth_element_find_guard(_RandomAccessIterator& __i, _RandomAccessIterator& __j,
-                         _RandomAccessIterator __m, _Compare __comp)
-{
-    // manually guard downward moving __j against __i
-    while (true) {
-        if (__i == --__j) {
-            return false;
-        }
-        if (__comp(*__j, *__m)) {
-            return true;  // found guard for downward moving __j, now use unguarded partition
-        }
+template <class _Compare, class _RandomAccessIterator>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool __nth_element_find_guard(
+    _RandomAccessIterator& __i, _RandomAccessIterator& __j, _RandomAccessIterator __m, _Compare __comp) {
+  // manually guard downward moving __j against __i
+  while (true) {
+    if (__i == --__j) {
+      return false;
     }
+    if (__comp(*__j, *__m)) {
+      return true; // found guard for downward moving __j, now use unguarded partition
+    }
+  }
 }
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
-__nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp)
-{
-    using _Ops = _IterOps<_AlgPolicy>;
+// NOLINTNEXTLINE(readability-function-cognitive-complexity)
+__nth_element(
+    _RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) {
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    // _Compare is known to be a reference type
-    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-    const difference_type __limit = 7;
-    while (true)
-    {
-        if (__nth == __last)
-            return;
-        difference_type __len = __last - __first;
-        switch (__len)
-        {
-        case 0:
-        case 1:
-            return;
-        case 2:
-            if (__comp(*--__last, *__first))
-                _Ops::iter_swap(__first, __last);
-            return;
-        case 3:
-            {
-            _RandomAccessIterator __m = __first;
-            std::__sort3<_AlgPolicy, _Compare>(__first, ++__m, --__last, __comp);
-            return;
-            }
-        }
-        if (__len <= __limit)
-        {
-            std::__selection_sort<_AlgPolicy, _Compare>(__first, __last, __comp);
-            return;
-        }
-        // __len > __limit >= 3
-        _RandomAccessIterator __m = __first + __len/2;
-        _RandomAccessIterator __lm1 = __last;
-        unsigned __n_swaps = std::__sort3<_AlgPolicy, _Compare>(__first, __m, --__lm1, __comp);
-        // *__m is median
-        // partition [__first, __m) < *__m and *__m <= [__m, __last)
-        // (this inhibits tossing elements equivalent to __m around unnecessarily)
-        _RandomAccessIterator __i = __first;
-        _RandomAccessIterator __j = __lm1;
-        // j points beyond range to be tested, *__lm1 is known to be <= *__m
-        // The search going up is known to be guarded but the search coming down isn't.
-        // Prime the downward search with a guard.
-        if (!__comp(*__i, *__m))  // if *__first == *__m
-        {
-            // *__first == *__m, *__first doesn't go in first part
-            if (_VSTD::__nth_element_find_guard<_Compare>(__i, __j, __m, __comp)) {
-                _Ops::iter_swap(__i, __j);
-                ++__n_swaps;
-            } else {
-                // *__first == *__m, *__m <= all other elements
-                // Partition instead into [__first, __i) == *__first and *__first < [__i, __last)
-                ++__i;  // __first + 1
-                __j = __last;
-                if (!__comp(*__first, *--__j)) {  // we need a guard if *__first == *(__last-1)
-                    while (true) {
-                        if (__i == __j) {
-                            return;  // [__first, __last) all equivalent elements
-                        } else if (__comp(*__first, *__i)) {
-                            _Ops::iter_swap(__i, __j);
-                            ++__n_swaps;
-                            ++__i;
-                            break;
-                        }
-                        ++__i;
-                    }
-                }
-                // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1
-                if (__i == __j) {
-                    return;
-                }
-                while (true) {
-                    while (!__comp(*__first, *__i))
-                        ++__i;
-                    while (__comp(*__first, *--__j))
-                        ;
-                    if (__i >= __j)
-                        break;
-                    _Ops::iter_swap(__i, __j);
-                    ++__n_swaps;
-                    ++__i;
-                }
-                // [__first, __i) == *__first and *__first < [__i, __last)
-                // The first part is sorted,
-                if (__nth < __i) {
-                    return;
-                }
-                // __nth_element the second part
-                // _VSTD::__nth_element<_Compare>(__i, __nth, __last, __comp);
-                __first = __i;
-                continue;
-            }
-        }
-        ++__i;
-        // j points beyond range to be tested, *__lm1 is known to be <= *__m
-        // if not yet partitioned...
-        if (__i < __j)
-        {
-            // known that *(__i - 1) < *__m
-            while (true)
-            {
-                // __m still guards upward moving __i
-                while (__comp(*__i, *__m))
-                    ++__i;
-                // It is now known that a guard exists for downward moving __j
-                while (!__comp(*--__j, *__m))
-                    ;
-                if (__i >= __j)
-                    break;
-                _Ops::iter_swap(__i, __j);
-                ++__n_swaps;
-                // It is known that __m != __j
-                // If __m just moved, follow it
-                if (__m == __i)
-                    __m = __j;
-                ++__i;
-            }
-        }
-        // [__first, __i) < *__m and *__m <= [__i, __last)
-        if (__i != __m && __comp(*__m, *__i))
-        {
-            _Ops::iter_swap(__i, __m);
-            ++__n_swaps;
-        }
-        // [__first, __i) < *__i and *__i <= [__i+1, __last)
-        if (__nth == __i)
-            return;
-        if (__n_swaps == 0)
-        {
-            // We were given a perfectly partitioned sequence.  Coincidence?
-            if (__nth < __i)
-            {
-                // Check for [__first, __i) already sorted
-                __j = __m = __first;
-                while (true) {
-                    if (++__j == __i) {
-                        // [__first, __i) sorted
-                        return;
-                    }
-                    if (__comp(*__j, *__m)) {
-                        // not yet sorted, so sort
-                        break;
-                    }
-                    __m = __j;
-                }
-            }
-            else
-            {
-                // Check for [__i, __last) already sorted
-                __j = __m = __i;
-                while (true) {
-                    if (++__j == __last) {
-                        // [__i, __last) sorted
-                        return;
-                    }
-                    if (__comp(*__j, *__m)) {
-                        // not yet sorted, so sort
-                        break;
-                    }
-                    __m = __j;
-                }
-            }
-        }
-        // __nth_element on range containing __nth
-        if (__nth < __i)
-        {
-            // _VSTD::__nth_element<_Compare>(__first, __nth, __i, __comp);
-            __last = __i;
-        }
-        else
-        {
-            // _VSTD::__nth_element<_Compare>(__i+1, __nth, __last, __comp);
-            __first = ++__i;
-        }
+  // _Compare is known to be a reference type
+  typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
+  const difference_type __limit = 7;
+  while (true) {
+    if (__nth == __last)
+      return;
+    difference_type __len = __last - __first;
+    switch (__len) {
+    case 0:
+    case 1:
+      return;
+    case 2:
+      if (__comp(*--__last, *__first))
+        _Ops::iter_swap(__first, __last);
+      return;
+    case 3: {
+      _RandomAccessIterator __m = __first;
+      std::__sort3<_AlgPolicy, _Compare>(__first, ++__m, --__last, __comp);
+      return;
     }
+    }
+    if (__len <= __limit) {
+      std::__selection_sort<_AlgPolicy, _Compare>(__first, __last, __comp);
+      return;
+    }
+    // __len > __limit >= 3
+    _RandomAccessIterator __m   = __first + __len / 2;
+    _RandomAccessIterator __lm1 = __last;
+    unsigned __n_swaps          = std::__sort3<_AlgPolicy, _Compare>(__first, __m, --__lm1, __comp);
+    // *__m is median
+    // partition [__first, __m) < *__m and *__m <= [__m, __last)
+    // (this inhibits tossing elements equivalent to __m around unnecessarily)
+    _RandomAccessIterator __i = __first;
+    _RandomAccessIterator __j = __lm1;
+    // j points beyond range to be tested, *__lm1 is known to be <= *__m
+    // The search going up is known to be guarded but the search coming down isn't.
+    // Prime the downward search with a guard.
+    if (!__comp(*__i, *__m)) // if *__first == *__m
+    {
+      // *__first == *__m, *__first doesn't go in first part
+      if (std::__nth_element_find_guard<_Compare>(__i, __j, __m, __comp)) {
+        _Ops::iter_swap(__i, __j);
+        ++__n_swaps;
+      } else {
+        // *__first == *__m, *__m <= all other elements
+        // Partition instead into [__first, __i) == *__first and *__first < [__i, __last)
+        ++__i; // __first + 1
+        __j = __last;
+        if (!__comp(*__first, *--__j)) { // we need a guard if *__first == *(__last-1)
+          while (true) {
+            if (__i == __j) {
+              return; // [__first, __last) all equivalent elements
+            } else if (__comp(*__first, *__i)) {
+              _Ops::iter_swap(__i, __j);
+              ++__n_swaps;
+              ++__i;
+              break;
+            }
+            ++__i;
+          }
+        }
+        // [__first, __i) == *__first and *__first < [__j, __last) and __j == __last - 1
+        if (__i == __j) {
+          return;
+        }
+        while (true) {
+          while (!__comp(*__first, *__i)) {
+            ++__i;
+            _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+                __i != __last,
+                "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+          }
+          do {
+            _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+                __j != __first,
+                "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+            --__j;
+          } while (__comp(*__first, *__j));
+          if (__i >= __j)
+            break;
+          _Ops::iter_swap(__i, __j);
+          ++__n_swaps;
+          ++__i;
+        }
+        // [__first, __i) == *__first and *__first < [__i, __last)
+        // The first part is sorted,
+        if (__nth < __i) {
+          return;
+        }
+        // __nth_element the second part
+        // std::__nth_element<_Compare>(__i, __nth, __last, __comp);
+        __first = __i;
+        continue;
+      }
+    }
+    ++__i;
+    // j points beyond range to be tested, *__lm1 is known to be <= *__m
+    // if not yet partitioned...
+    if (__i < __j) {
+      // known that *(__i - 1) < *__m
+      while (true) {
+        // __m still guards upward moving __i
+        while (__comp(*__i, *__m)) {
+          ++__i;
+          _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+              __i != __last,
+              "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+        }
+        // It is now known that a guard exists for downward moving __j
+        do {
+          _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+              __j != __first,
+              "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+          --__j;
+        } while (!__comp(*__j, *__m));
+        if (__i >= __j)
+          break;
+        _Ops::iter_swap(__i, __j);
+        ++__n_swaps;
+        // It is known that __m != __j
+        // If __m just moved, follow it
+        if (__m == __i)
+          __m = __j;
+        ++__i;
+      }
+    }
+    // [__first, __i) < *__m and *__m <= [__i, __last)
+    if (__i != __m && __comp(*__m, *__i)) {
+      _Ops::iter_swap(__i, __m);
+      ++__n_swaps;
+    }
+    // [__first, __i) < *__i and *__i <= [__i+1, __last)
+    if (__nth == __i)
+      return;
+    if (__n_swaps == 0) {
+      // We were given a perfectly partitioned sequence.  Coincidence?
+      if (__nth < __i) {
+        // Check for [__first, __i) already sorted
+        __j = __m = __first;
+        while (true) {
+          if (++__j == __i) {
+            // [__first, __i) sorted
+            return;
+          }
+          if (__comp(*__j, *__m)) {
+            // not yet sorted, so sort
+            break;
+          }
+          __m = __j;
+        }
+      } else {
+        // Check for [__i, __last) already sorted
+        __j = __m = __i;
+        while (true) {
+          if (++__j == __last) {
+            // [__i, __last) sorted
+            return;
+          }
+          if (__comp(*__j, *__m)) {
+            // not yet sorted, so sort
+            break;
+          }
+          __m = __j;
+        }
+      }
+    }
+    // __nth_element on range containing __nth
+    if (__nth < __i) {
+      // std::__nth_element<_Compare>(__first, __nth, __i, __comp);
+      __last = __i;
+    } else {
+      // std::__nth_element<_Compare>(__i+1, __nth, __last, __comp);
+      __first = ++__i;
+    }
+  }
 }
 
 template <class _AlgPolicy, class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void __nth_element_impl(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last,
-                        _Compare& __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __nth_element_impl(
+    _RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare& __comp) {
   if (__nth == __last)
     return;
 
@@ -240,19 +243,19 @@ void __nth_element_impl(_RandomAccessIterator __first, _RandomAccessIterator __n
 }
 
 template <class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last,
-                 _Compare __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last, _Compare __comp) {
   std::__nth_element_impl<_ClassicAlgPolicy>(std::move(__first), std::move(__nth), std::move(__last), __comp);
 }
 
 template <class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) {
-  std::nth_element(std::move(__first), std::move(__nth), std::move(__last), __less<typename
-      iterator_traits<_RandomAccessIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last) {
+  std::nth_element(std::move(__first), std::move(__nth), std::move(__last), __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_NTH_ELEMENT_H
diff --git a/third_party/libcxx/__algorithm/partial_sort.h b/third_party/libcxx/__algorithm/partial_sort.h
index 4b8e0e76b..7f8d0c491 100644
--- a/third_party/libcxx/__algorithm/partial_sort.h
+++ b/third_party/libcxx/__algorithm/partial_sort.h
@@ -16,22 +16,23 @@
 #include <__algorithm/sift_down.h>
 #include <__algorithm/sort_heap.h>
 #include <__config>
-#include <__debug>
 #include <__debug_utils/randomize_range.h>
 #include <__iterator/iterator_traits.h>
-#include <__type_traits/is_copy_assignable.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator, class _Sentinel>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_RandomAccessIterator __partial_sort_impl(
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl(
     _RandomAccessIterator __first, _RandomAccessIterator __middle, _Sentinel __last, _Compare&& __comp) {
   if (__first == __middle) {
     return _IterOps<_AlgPolicy>::next(__middle, __last);
@@ -40,14 +41,12 @@ _RandomAccessIterator __partial_sort_impl(
   std::__make_heap<_AlgPolicy>(__first, __middle, __comp);
 
   typename iterator_traits<_RandomAccessIterator>::difference_type __len = __middle - __first;
-  _RandomAccessIterator __i = __middle;
-  for (; __i != __last; ++__i)
-  {
-      if (__comp(*__i, *__first))
-      {
-          _IterOps<_AlgPolicy>::iter_swap(__i, __first);
-          std::__sift_down<_AlgPolicy>(__first, __comp, __len, __first);
-      }
+  _RandomAccessIterator __i                                              = __middle;
+  for (; __i != __last; ++__i) {
+    if (__comp(*__i, *__first)) {
+      _IterOps<_AlgPolicy>::iter_swap(__i, __first);
+      std::__sift_down<_AlgPolicy>(__first, __comp, __len, __first);
+    }
   }
   std::__sort_heap<_AlgPolicy>(std::move(__first), std::move(__middle), __comp);
 
@@ -55,11 +54,10 @@ _RandomAccessIterator __partial_sort_impl(
 }
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator, class _Sentinel>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_RandomAccessIterator __partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _Sentinel __last,
-                                     _Compare& __comp) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator
+__partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _Sentinel __last, _Compare& __comp) {
   if (__first == __middle)
-      return _IterOps<_AlgPolicy>::next(__middle, __last);
+    return _IterOps<_AlgPolicy>::next(__middle, __last);
 
   std::__debug_randomize_range<_AlgPolicy>(__first, __last);
 
@@ -72,11 +70,8 @@ _RandomAccessIterator __partial_sort(_RandomAccessIterator __first, _RandomAcces
 }
 
 template <class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
-             _Compare __comp)
-{
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void partial_sort(
+    _RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last, _Compare __comp) {
   static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible.");
   static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable.");
 
@@ -84,14 +79,13 @@ partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _Ran
 }
 
 template <class _RandomAccessIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
-{
-    _VSTD::partial_sort(__first, __middle, __last,
-                        __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) {
+  std::partial_sort(__first, __middle, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_PARTIAL_SORT_H
diff --git a/third_party/libcxx/__algorithm/partial_sort_copy.h b/third_party/libcxx/__algorithm/partial_sort_copy.h
index 1aba07105..ef7c9d34d 100644
--- a/third_party/libcxx/__algorithm/partial_sort_copy.h
+++ b/third_party/libcxx/__algorithm/partial_sort_copy.h
@@ -28,61 +28,79 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _AlgPolicy, class _Compare,
-          class _InputIterator, class _Sentinel1, class _RandomAccessIterator, class _Sentinel2,
-          class _Proj1, class _Proj2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator, _RandomAccessIterator>
-__partial_sort_copy(_InputIterator __first, _Sentinel1 __last,
-                    _RandomAccessIterator __result_first, _Sentinel2 __result_last,
-                    _Compare&& __comp, _Proj1&& __proj1, _Proj2&& __proj2)
-{
-    _RandomAccessIterator __r = __result_first;
-    auto&& __projected_comp = std::__make_projected(__comp, __proj2);
+template <class _AlgPolicy,
+          class _Compare,
+          class _InputIterator,
+          class _Sentinel1,
+          class _RandomAccessIterator,
+          class _Sentinel2,
+          class _Proj1,
+          class _Proj2>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator, _RandomAccessIterator> __partial_sort_copy(
+    _InputIterator __first,
+    _Sentinel1 __last,
+    _RandomAccessIterator __result_first,
+    _Sentinel2 __result_last,
+    _Compare&& __comp,
+    _Proj1&& __proj1,
+    _Proj2&& __proj2) {
+  _RandomAccessIterator __r = __result_first;
+  auto&& __projected_comp   = std::__make_projected(__comp, __proj2);
 
-    if (__r != __result_last)
-    {
-        for (; __first != __last && __r != __result_last; ++__first, (void) ++__r)
-            *__r = *__first;
-        std::__make_heap<_AlgPolicy>(__result_first, __r, __projected_comp);
-        typename iterator_traits<_RandomAccessIterator>::difference_type __len = __r - __result_first;
-        for (; __first != __last; ++__first)
-            if (std::__invoke(__comp, std::__invoke(__proj1, *__first), std::__invoke(__proj2, *__result_first))) {
-                *__result_first = *__first;
-                std::__sift_down<_AlgPolicy>(__result_first, __projected_comp, __len, __result_first);
-            }
-        std::__sort_heap<_AlgPolicy>(__result_first, __r, __projected_comp);
-    }
+  if (__r != __result_last) {
+    for (; __first != __last && __r != __result_last; ++__first, (void)++__r)
+      *__r = *__first;
+    std::__make_heap<_AlgPolicy>(__result_first, __r, __projected_comp);
+    typename iterator_traits<_RandomAccessIterator>::difference_type __len = __r - __result_first;
+    for (; __first != __last; ++__first)
+      if (std::__invoke(__comp, std::__invoke(__proj1, *__first), std::__invoke(__proj2, *__result_first))) {
+        *__result_first = *__first;
+        std::__sift_down<_AlgPolicy>(__result_first, __projected_comp, __len, __result_first);
+      }
+    std::__sort_heap<_AlgPolicy>(__result_first, __r, __projected_comp);
+  }
 
-    return pair<_InputIterator, _RandomAccessIterator>(
-        _IterOps<_AlgPolicy>::next(std::move(__first), std::move(__last)), std::move(__r));
+  return pair<_InputIterator, _RandomAccessIterator>(
+      _IterOps<_AlgPolicy>::next(std::move(__first), std::move(__last)), std::move(__r));
 }
 
 template <class _InputIterator, class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_RandomAccessIterator
-partial_sort_copy(_InputIterator __first, _InputIterator __last,
-                  _RandomAccessIterator __result_first, _RandomAccessIterator __result_last, _Compare __comp)
-{
-  static_assert(__is_callable<_Compare, decltype(*__first), decltype(*__result_first)>::value,
-                "Comparator has to be callable");
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator partial_sort_copy(
+    _InputIterator __first,
+    _InputIterator __last,
+    _RandomAccessIterator __result_first,
+    _RandomAccessIterator __result_last,
+    _Compare __comp) {
+  static_assert(
+      __is_callable<_Compare, decltype(*__first), decltype(*__result_first)>::value, "Comparator has to be callable");
 
-  auto __result = std::__partial_sort_copy<_ClassicAlgPolicy>(__first, __last, __result_first, __result_last,
-      static_cast<__comp_ref_type<_Compare> >(__comp), __identity(), __identity());
+  auto __result = std::__partial_sort_copy<_ClassicAlgPolicy>(
+      __first,
+      __last,
+      __result_first,
+      __result_last,
+      static_cast<__comp_ref_type<_Compare> >(__comp),
+      __identity(),
+      __identity());
   return __result.second;
 }
 
 template <class _InputIterator, class _RandomAccessIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_RandomAccessIterator
-partial_sort_copy(_InputIterator __first, _InputIterator __last,
-                  _RandomAccessIterator __result_first, _RandomAccessIterator __result_last)
-{
-    return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last,
-                                   __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator partial_sort_copy(
+    _InputIterator __first,
+    _InputIterator __last,
+    _RandomAccessIterator __result_first,
+    _RandomAccessIterator __result_last) {
+  return std::partial_sort_copy(__first, __last, __result_first, __result_last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_PARTIAL_SORT_COPY_H
diff --git a/third_party/libcxx/__algorithm/partition.h b/third_party/libcxx/__algorithm/partition.h
index a58dd6464..824e49b9e 100644
--- a/third_party/libcxx/__algorithm/partition.h
+++ b/third_party/libcxx/__algorithm/partition.h
@@ -19,74 +19,65 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Predicate, class _AlgPolicy, class _ForwardIterator, class _Sentinel>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_ForwardIterator, _ForwardIterator>
-__partition_impl(_ForwardIterator __first, _Sentinel __last, _Predicate __pred, forward_iterator_tag)
-{
-    while (true)
-    {
-        if (__first == __last)
-            return std::make_pair(std::move(__first), std::move(__first));
-        if (!__pred(*__first))
-            break;
-        ++__first;
-    }
+__partition_impl(_ForwardIterator __first, _Sentinel __last, _Predicate __pred, forward_iterator_tag) {
+  while (true) {
+    if (__first == __last)
+      return std::make_pair(std::move(__first), std::move(__first));
+    if (!__pred(*__first))
+      break;
+    ++__first;
+  }
 
-    _ForwardIterator __p = __first;
-    while (++__p != __last)
-    {
-        if (__pred(*__p))
-        {
-            _IterOps<_AlgPolicy>::iter_swap(__first, __p);
-            ++__first;
-        }
+  _ForwardIterator __p = __first;
+  while (++__p != __last) {
+    if (__pred(*__p)) {
+      _IterOps<_AlgPolicy>::iter_swap(__first, __p);
+      ++__first;
     }
-    return std::make_pair(std::move(__first), std::move(__p));
+  }
+  return std::make_pair(std::move(__first), std::move(__p));
 }
 
 template <class _Predicate, class _AlgPolicy, class _BidirectionalIterator, class _Sentinel>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_BidirectionalIterator, _BidirectionalIterator>
-__partition_impl(_BidirectionalIterator __first, _Sentinel __sentinel, _Predicate __pred,
-            bidirectional_iterator_tag)
-{
-    _BidirectionalIterator __original_last = _IterOps<_AlgPolicy>::next(__first, __sentinel);
-    _BidirectionalIterator __last = __original_last;
+__partition_impl(_BidirectionalIterator __first, _Sentinel __sentinel, _Predicate __pred, bidirectional_iterator_tag) {
+  _BidirectionalIterator __original_last = _IterOps<_AlgPolicy>::next(__first, __sentinel);
+  _BidirectionalIterator __last          = __original_last;
 
-    while (true)
-    {
-        while (true)
-        {
-            if (__first == __last)
-                return std::make_pair(std::move(__first), std::move(__original_last));
-            if (!__pred(*__first))
-                break;
-            ++__first;
-        }
-        do
-        {
-            if (__first == --__last)
-                return std::make_pair(std::move(__first), std::move(__original_last));
-        } while (!__pred(*__last));
-        _IterOps<_AlgPolicy>::iter_swap(__first, __last);
-        ++__first;
+  while (true) {
+    while (true) {
+      if (__first == __last)
+        return std::make_pair(std::move(__first), std::move(__original_last));
+      if (!__pred(*__first))
+        break;
+      ++__first;
     }
+    do {
+      if (__first == --__last)
+        return std::make_pair(std::move(__first), std::move(__original_last));
+    } while (!__pred(*__last));
+    _IterOps<_AlgPolicy>::iter_swap(__first, __last);
+    ++__first;
+  }
 }
 
 template <class _AlgPolicy, class _ForwardIterator, class _Sentinel, class _Predicate, class _IterCategory>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-pair<_ForwardIterator, _ForwardIterator> __partition(
-    _ForwardIterator __first, _Sentinel __last, _Predicate&& __pred, _IterCategory __iter_category) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_ForwardIterator, _ForwardIterator>
+__partition(_ForwardIterator __first, _Sentinel __last, _Predicate&& __pred, _IterCategory __iter_category) {
   return std::__partition_impl<__remove_cvref_t<_Predicate>&, _AlgPolicy>(
       std::move(__first), std::move(__last), __pred, __iter_category);
 }
 
 template <class _ForwardIterator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator
-partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
-{
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
   using _IterCategory = typename iterator_traits<_ForwardIterator>::iterator_category;
   auto __result = std::__partition<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __pred, _IterCategory());
   return __result.first;
@@ -94,4 +85,6 @@ partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_PARTITION_H
diff --git a/third_party/libcxx/__algorithm/partition_copy.h b/third_party/libcxx/__algorithm/partition_copy.h
index ff8826a93..147b45c78 100644
--- a/third_party/libcxx/__algorithm/partition_copy.h
+++ b/third_party/libcxx/__algorithm/partition_copy.h
@@ -19,27 +19,23 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIterator, class _OutputIterator1,
-          class _OutputIterator2, class _Predicate>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_OutputIterator1, _OutputIterator2>
-partition_copy(_InputIterator __first, _InputIterator __last,
-               _OutputIterator1 __out_true, _OutputIterator2 __out_false,
-               _Predicate __pred)
-{
-    for (; __first != __last; ++__first)
-    {
-        if (__pred(*__first))
-        {
-            *__out_true = *__first;
-            ++__out_true;
-        }
-        else
-        {
-            *__out_false = *__first;
-            ++__out_false;
-        }
+template <class _InputIterator, class _OutputIterator1, class _OutputIterator2, class _Predicate>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_OutputIterator1, _OutputIterator2> partition_copy(
+    _InputIterator __first,
+    _InputIterator __last,
+    _OutputIterator1 __out_true,
+    _OutputIterator2 __out_false,
+    _Predicate __pred) {
+  for (; __first != __last; ++__first) {
+    if (__pred(*__first)) {
+      *__out_true = *__first;
+      ++__out_true;
+    } else {
+      *__out_false = *__first;
+      ++__out_false;
     }
-    return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
+  }
+  return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/partition_point.h b/third_party/libcxx/__algorithm/partition_point.h
index 6ede71a26..504dbf1d1 100644
--- a/third_party/libcxx/__algorithm/partition_point.h
+++ b/third_party/libcxx/__algorithm/partition_point.h
@@ -21,26 +21,22 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _ForwardIterator, class _Predicate>
+template <class _ForwardIterator, class _Predicate>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
-partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
-{
-    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
-    difference_type __len = _VSTD::distance(__first, __last);
-    while (__len != 0)
-    {
-        difference_type __l2 = _VSTD::__half_positive(__len);
-        _ForwardIterator __m = __first;
-        _VSTD::advance(__m, __l2);
-        if (__pred(*__m))
-        {
-            __first = ++__m;
-            __len -= __l2 + 1;
-        }
-        else
-            __len = __l2;
-    }
-    return __first;
+partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
+  typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
+  difference_type __len = std::distance(__first, __last);
+  while (__len != 0) {
+    difference_type __l2 = std::__half_positive(__len);
+    _ForwardIterator __m = __first;
+    std::advance(__m, __l2);
+    if (__pred(*__m)) {
+      __first = ++__m;
+      __len -= __l2 + 1;
+    } else
+      __len = __l2;
+  }
+  return __first;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/pop_heap.h b/third_party/libcxx/__algorithm/pop_heap.h
index 4187523ef..6d2383009 100644
--- a/third_party/libcxx/__algorithm/pop_heap.h
+++ b/third_party/libcxx/__algorithm/pop_heap.h
@@ -17,27 +17,33 @@
 #include <__assert>
 #include <__config>
 #include <__iterator/iterator_traits.h>
-#include <__type_traits/is_copy_assignable.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp,
-    typename iterator_traits<_RandomAccessIterator>::difference_type __len) {
-  _LIBCPP_ASSERT(__len > 0, "The heap given to pop_heap must be non-empty");
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+__pop_heap(_RandomAccessIterator __first,
+           _RandomAccessIterator __last,
+           _Compare& __comp,
+           typename iterator_traits<_RandomAccessIterator>::difference_type __len) {
+  // Calling `pop_heap` on an empty range is undefined behavior, but in practice it will be a no-op.
+  _LIBCPP_ASSERT_PEDANTIC(__len > 0, "The heap given to pop_heap must be non-empty");
 
   __comp_ref_type<_Compare> __comp_ref = __comp;
 
   using value_type = typename iterator_traits<_RandomAccessIterator>::value_type;
   if (__len > 1) {
-    value_type __top = _IterOps<_AlgPolicy>::__iter_move(__first);  // create a hole at __first
+    value_type __top             = _IterOps<_AlgPolicy>::__iter_move(__first); // create a hole at __first
     _RandomAccessIterator __hole = std::__floyd_sift_down<_AlgPolicy>(__first, __comp_ref, __len);
     --__last;
 
@@ -53,8 +59,8 @@ void __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Co
 }
 
 template <class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
   static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible.");
   static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable.");
 
@@ -63,12 +69,13 @@ void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp
 }
 
 template <class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
-  std::pop_heap(std::move(__first), std::move(__last),
-      __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
+  std::pop_heap(std::move(__first), std::move(__last), __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_POP_HEAP_H
diff --git a/third_party/libcxx/__algorithm/prev_permutation.h b/third_party/libcxx/__algorithm/prev_permutation.h
index 0b86ab74e..8d15b6806 100644
--- a/third_party/libcxx/__algorithm/prev_permutation.h
+++ b/third_party/libcxx/__algorithm/prev_permutation.h
@@ -22,58 +22,54 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _BidirectionalIterator, class _Sentinel>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-pair<_BidirectionalIterator, bool>
-__prev_permutation(_BidirectionalIterator __first, _Sentinel __last, _Compare&& __comp)
-{
-    using _Result = pair<_BidirectionalIterator, bool>;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_BidirectionalIterator, bool>
+__prev_permutation(_BidirectionalIterator __first, _Sentinel __last, _Compare&& __comp) {
+  using _Result = pair<_BidirectionalIterator, bool>;
 
-    _BidirectionalIterator __last_iter = _IterOps<_AlgPolicy>::next(__first, __last);
-    _BidirectionalIterator __i = __last_iter;
-    if (__first == __last || __first == --__i)
-        return _Result(std::move(__last_iter), false);
+  _BidirectionalIterator __last_iter = _IterOps<_AlgPolicy>::next(__first, __last);
+  _BidirectionalIterator __i         = __last_iter;
+  if (__first == __last || __first == --__i)
+    return _Result(std::move(__last_iter), false);
 
-    while (true)
-    {
-        _BidirectionalIterator __ip1 = __i;
-        if (__comp(*__ip1, *--__i))
-        {
-            _BidirectionalIterator __j = __last_iter;
-            while (!__comp(*--__j, *__i))
-                ;
-            _IterOps<_AlgPolicy>::iter_swap(__i, __j);
-            std::__reverse<_AlgPolicy>(__ip1, __last_iter);
-            return _Result(std::move(__last_iter), true);
-        }
-        if (__i == __first)
-        {
-            std::__reverse<_AlgPolicy>(__first, __last_iter);
-            return _Result(std::move(__last_iter), false);
-        }
+  while (true) {
+    _BidirectionalIterator __ip1 = __i;
+    if (__comp(*__ip1, *--__i)) {
+      _BidirectionalIterator __j = __last_iter;
+      while (!__comp(*--__j, *__i))
+        ;
+      _IterOps<_AlgPolicy>::iter_swap(__i, __j);
+      std::__reverse<_AlgPolicy>(__ip1, __last_iter);
+      return _Result(std::move(__last_iter), true);
     }
+    if (__i == __first) {
+      std::__reverse<_AlgPolicy>(__first, __last_iter);
+      return _Result(std::move(__last_iter), false);
+    }
+  }
 }
 
 template <class _BidirectionalIterator, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp)
-{
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) {
   return std::__prev_permutation<_ClassicAlgPolicy>(
-      std::move(__first), std::move(__last), static_cast<__comp_ref_type<_Compare> >(__comp)).second;
+             std::move(__first), std::move(__last), static_cast<__comp_ref_type<_Compare> >(__comp))
+      .second;
 }
 
 template <class _BidirectionalIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
-{
-    return _VSTD::prev_permutation(__first, __last,
-                                  __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last) {
+  return std::prev_permutation(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_PREV_PERMUTATION_H
diff --git a/third_party/libcxx/__algorithm/pstl.h b/third_party/libcxx/__algorithm/pstl.h
new file mode 100644
index 000000000..0bb052b3f
--- /dev/null
+++ b/third_party/libcxx/__algorithm/pstl.h
@@ -0,0 +1,663 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_PSTL_H
+#define _LIBCPP___ALGORITHM_PSTL_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
+#  include <__functional/operations.h>
+#  include <__iterator/cpp17_iterator_concepts.h>
+#  include <__iterator/iterator_traits.h>
+#  include <__pstl/backend.h>
+#  include <__pstl/dispatch.h>
+#  include <__pstl/handle_exception.h>
+#  include <__type_traits/enable_if.h>
+#  include <__type_traits/is_execution_policy.h>
+#  include <__type_traits/remove_cvref.h>
+#  include <__utility/forward.h>
+#  include <__utility/move.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Predicate,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
+any_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "any_of requires a ForwardIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__any_of, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Pred,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
+all_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "all_of requires a ForwardIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__all_of, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Pred,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
+none_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "none_of requires a ForwardIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__none_of, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _ForwardOutIterator,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
+copy(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
+      _ForwardIterator, "copy(first, last, result) requires [first, last) to be ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
+      _ForwardOutIterator, "copy(first, last, result) requires result to be a ForwardIterator");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
+      _ForwardOutIterator, decltype(*__first), "copy(first, last, result) requires result to be an OutputIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__copy, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _ForwardOutIterator,
+          class _Size,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
+copy_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _ForwardOutIterator __result) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
+      _ForwardIterator, "copy_n(first, n, result) requires first to be a ForwardIterator");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
+      _ForwardOutIterator, "copy_n(first, n, result) requires result to be a ForwardIterator");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
+      _ForwardOutIterator, decltype(*__first), "copy_n(first, n, result) requires result to be an OutputIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__copy_n, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__result));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Predicate,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI __iter_diff_t<_ForwardIterator>
+count_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
+      _ForwardIterator, "count_if(first, last, pred) requires [first, last) to be ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__count_if, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Tp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI __iter_diff_t<_ForwardIterator>
+count(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
+      _ForwardIterator, "count(first, last, val) requires [first, last) to be ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__count, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _Pred,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool
+equal(_ExecutionPolicy&& __policy,
+      _ForwardIterator1 __first1,
+      _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2,
+      _Pred __pred) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__pred));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool
+equal(_ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__equal_3leg, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      equal_to{});
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _Pred,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool
+equal(_ExecutionPolicy&& __policy,
+      _ForwardIterator1 __first1,
+      _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2,
+      _ForwardIterator2 __last2,
+      _Pred __pred) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__last2),
+      std::move(__pred));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool
+equal(_ExecutionPolicy&& __policy,
+      _ForwardIterator1 __first1,
+      _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2,
+      _ForwardIterator2 __last2) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__equal, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__last2),
+      equal_to{});
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Tp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+fill(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__fill, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Size,
+          class _Tp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+fill_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, const _Tp& __value) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "fill_n requires a ForwardIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__fill_n, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), __value);
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Predicate,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator
+find_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__find_if, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Predicate,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator
+find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if_not requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__find_if_not, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Tp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator
+find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__find, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __value);
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Function,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+for_each(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Function __func) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__for_each, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__func));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Size,
+          class _Function,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+for_each_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __size, _Function __func) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "for_each_n requires a ForwardIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__for_each_n, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__size), std::move(__func));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Generator,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+generate(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__generate, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__gen));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Size,
+          class _Generator,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+generate_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _Generator __gen) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "generate_n requires a ForwardIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__generate_n, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__n), std::move(__gen));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Predicate,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool
+is_partitioned(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "is_partitioned requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__is_partitioned, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _ForwardOutIterator,
+          class _Comp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
+merge(_ExecutionPolicy&& __policy,
+      _ForwardIterator1 __first1,
+      _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2,
+      _ForwardIterator2 __last2,
+      _ForwardOutIterator __result,
+      _Comp __comp) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__last2),
+      std::move(__result),
+      std::move(__comp));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _ForwardOutIterator,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
+merge(_ExecutionPolicy&& __policy,
+      _ForwardIterator1 __first1,
+      _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2,
+      _ForwardIterator2 __last2,
+      _ForwardOutIterator __result) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "merge requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "merge requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first1), "merge requires an OutputIterator");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, decltype(*__first2), "merge requires an OutputIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__merge, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__last2),
+      std::move(__result),
+      less{});
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _ForwardOutIterator,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
+move(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "move requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "move requires an OutputIterator");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
+      _ForwardOutIterator, decltype(std::move(*__first)), "move requires an OutputIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__move, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__result));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Pred,
+          class _Tp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+replace_if(_ExecutionPolicy&& __policy,
+           _ForwardIterator __first,
+           _ForwardIterator __last,
+           _Pred __pred,
+           const _Tp& __new_value) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_if requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__replace_if, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__pred), __new_value);
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Tp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+replace(_ExecutionPolicy&& __policy,
+        _ForwardIterator __first,
+        _ForwardIterator __last,
+        const _Tp& __old_value,
+        const _Tp& __new_value) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__replace, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), __old_value, __new_value);
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _ForwardOutIterator,
+          class _Pred,
+          class _Tp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void replace_copy_if(
+    _ExecutionPolicy&& __policy,
+    _ForwardIterator __first,
+    _ForwardIterator __last,
+    _ForwardOutIterator __result,
+    _Pred __pred,
+    const _Tp& __new_value) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy_if requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy_if requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
+      _ForwardOutIterator, decltype(*__first), "replace_copy_if requires an OutputIterator");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__replace_copy_if, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first),
+      std::move(__last),
+      std::move(__result),
+      std::move(__pred),
+      __new_value);
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _ForwardOutIterator,
+          class _Tp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void replace_copy(
+    _ExecutionPolicy&& __policy,
+    _ForwardIterator __first,
+    _ForwardIterator __last,
+    _ForwardOutIterator __result,
+    const _Tp& __old_value,
+    const _Tp& __new_value) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "replace_copy requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "replace_copy requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
+      _ForwardOutIterator, decltype(*__first), "replace_copy requires an OutputIterator");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(_ForwardOutIterator, const _Tp&, "replace_copy requires an OutputIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__replace_copy, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first),
+      std::move(__last),
+      std::move(__result),
+      __old_value,
+      __new_value);
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _ForwardOutIterator,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator rotate_copy(
+    _ExecutionPolicy&& __policy,
+    _ForwardIterator __first,
+    _ForwardIterator __middle,
+    _ForwardIterator __last,
+    _ForwardOutIterator __result) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "rotate_copy requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "rotate_copy requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
+      _ForwardOutIterator, decltype(*__first), "rotate_copy requires an OutputIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__rotate_copy, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first),
+      std::move(__middle),
+      std::move(__last),
+      std::move(__result));
+}
+
+template <class _ExecutionPolicy,
+          class _RandomAccessIterator,
+          class _Comp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
+  _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
+}
+
+template <class _ExecutionPolicy,
+          class _RandomAccessIterator,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
+  _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "sort requires RandomAccessIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__sort, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
+}
+
+template <class _ExecutionPolicy,
+          class _RandomAccessIterator,
+          class _Comp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
+  _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__comp));
+}
+
+template <class _ExecutionPolicy,
+          class _RandomAccessIterator,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void
+stable_sort(_ExecutionPolicy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last) {
+  _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(_RandomAccessIterator, "stable_sort requires RandomAccessIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__stable_sort, __pstl::__current_configuration, _RawPolicy>;
+  __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), less{});
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _ForwardOutIterator,
+          class _UnaryOperation,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform(
+    _ExecutionPolicy&& __policy,
+    _ForwardIterator __first,
+    _ForwardIterator __last,
+    _ForwardOutIterator __result,
+    _UnaryOperation __op) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "transform requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
+      _ForwardOutIterator, decltype(__op(*__first)), "transform requires an OutputIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__transform, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first),
+      std::move(__last),
+      std::move(__result),
+      std::move(__op));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _ForwardOutIterator,
+          class _BinaryOperation,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform(
+    _ExecutionPolicy&& __policy,
+    _ForwardIterator1 __first1,
+    _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2,
+    _ForwardOutIterator __result,
+    _BinaryOperation __op) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardOutIterator, "transform requires an OutputIterator");
+  _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(
+      _ForwardOutIterator, decltype(__op(*__first1, *__first2)), "transform requires an OutputIterator");
+  using _Implementation = __pstl::__dispatch<__pstl::__transform_binary, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__result),
+      std::move(__op));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_PSTL_H
diff --git a/third_party/libcxx/__algorithm/pstl_any_all_none_of.h b/third_party/libcxx/__algorithm/pstl_any_all_none_of.h
deleted file mode 100644
index 374d9af17..000000000
--- a/third_party/libcxx/__algorithm/pstl_any_all_none_of.h
+++ /dev/null
@@ -1,95 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_ANY_ALL_NONE_OF_H
-#define _LIBCPP___ALGORITHM_PSTL_ANY_ALL_NONE_OF_H
-
-#include <__algorithm/pstl_find.h>
-#include <__algorithm/pstl_frontend_dispatch.h>
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/enable_if.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__type_traits/remove_cvref.h>
-#include <__utility/terminate_on_exception.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class>
-void __pstl_any_of(); // declaration needed for the frontend dispatch below
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Predicate,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI bool
-any_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
-  return std::__pstl_frontend_dispatch(
-      _LIBCPP_PSTL_CUSTOMIZATION_POINT(__pstl_any_of),
-      [&](_ForwardIterator __g_first, _ForwardIterator __g_last, _Predicate __g_pred) {
-        return std::find_if(__policy, __g_first, __g_last, __g_pred) != __g_last;
-      },
-      std::move(__first),
-      std::move(__last),
-      std::move(__pred));
-}
-
-template <class>
-void __pstl_all_of(); // declaration needed for the frontend dispatch below
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Pred,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI bool
-all_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
-  return std::__pstl_frontend_dispatch(
-      _LIBCPP_PSTL_CUSTOMIZATION_POINT(__pstl_all_of),
-      [&](_ForwardIterator __g_first, _ForwardIterator __g_last, _Pred __g_pred) {
-        return !std::any_of(__policy, __g_first, __g_last, [&](__iter_reference<_ForwardIterator> __value) {
-          return !__g_pred(__value);
-        });
-      },
-      std::move(__first),
-      std::move(__last),
-      std::move(__pred));
-}
-
-template <class>
-void __pstl_none_of(); // declaration needed for the frontend dispatch below
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Pred,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI bool
-none_of(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred __pred) {
-  return std::__pstl_frontend_dispatch(
-      _LIBCPP_PSTL_CUSTOMIZATION_POINT(__pstl_none_of),
-      [&](_ForwardIterator __g_first, _ForwardIterator __g_last, _Pred __g_pred) {
-        return !std::any_of(__policy, __g_first, __g_last, __g_pred);
-      },
-      std::move(__first),
-      std::move(__last),
-      std::move(__pred));
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_ANY_ALL_NONE_OF_H
diff --git a/third_party/libcxx/__algorithm/pstl_backend.h b/third_party/libcxx/__algorithm/pstl_backend.h
deleted file mode 100644
index ae37e56a7..000000000
--- a/third_party/libcxx/__algorithm/pstl_backend.h
+++ /dev/null
@@ -1,125 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKEND_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKEND_H
-
-#include <__algorithm/pstl_backends/cpu_backend.h>
-#include <__config>
-#include <execution>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-/*
-TODO: Documentation of how backends work
-
-A PSTL parallel backend is a tag type to which the following functions are associated, at minimum:
-
-  template <class _ExecutionPolicy, class _Iterator, class _Func>
-  void __pstl_for_each(_Backend, _ExecutionPolicy&&, _Iterator __first, _Iterator __last, _Func __f);
-
-  template <class _ExecutionPolicy, class _Iterator, class _Predicate>
-  _Iterator __pstl_find_if(_Backend, _Iterator __first, _Iterator __last, _Predicate __pred);
-
-  template <class _ExecutionPolicy, class _InIterator, class _OutIterator, class _UnaryOperation>
-  _OutIterator __pstl_transform(_InIterator __first, _InIterator __last, _OutIterator __result, _UnaryOperation __op);
-
-  template <class _ExecutionPolicy, class _InIterator1, class _InIterator2, class _OutIterator, class _BinaryOperation>
-  _OutIterator __pstl_transform(_InIterator1 __first1,
-                                _InIterator1 __last1,
-                                _InIterator2 __first2,
-                                _OutIterator __result,
-                                _BinaryOperation __op);
-
-// TODO: Complete this list
-
-The following functions are optional but can be provided. If provided, they are used by the corresponding
-algorithms, otherwise they are implemented in terms of other algorithms. If none of the optional algorithms are
-implemented, all the algorithms will eventually forward to the basis algorithms listed above:
-
-  template <class _ExecutionPolicy, class _Iterator, class _Size, class _Func>
-  void __pstl_for_each_n(_Backend, _Iterator __first, _Size __n, _Func __f);
-
-  template <class _ExecutionPolicy, class _Iterator, class _Predicate>
-  bool __pstl_any_of(_Backend, _Iterator __first, _iterator __last, _Predicate __pred);
-
-  template <class _ExecutionPolicy, class _Iterator, class _Predicate>
-  bool __pstl_all_of(_Backend, _Iterator __first, _iterator __last, _Predicate __pred);
-
-  template <class _ExecutionPolicy, class _Iterator, class _Predicate>
-  bool __pstl_none_of(_Backend, _Iterator __first, _iterator __last, _Predicate __pred);
-
-  template <class _ExecutionPolicy, class _Iterator, class _Tp>
-  _Iterator __pstl_find(_Backend, _Iterator __first, _Iterator __last, const _Tp& __value);
-
-  template <class _ExecutionPolicy, class _Iterator, class _Predicate>
-  _Iterator __pstl_find_if_not(_Backend, _Iterator __first, _Iterator __last, _Predicate __pred);
-
-  template <class _ExecutionPolicy, class _Iterator, class _Tp>
-  void __pstl_fill(_Backend, _Iterator __first, _Iterator __last, const _Tp& __value);
-
-  template <class _ExecutionPolicy, class _Iterator, class _SizeT, class _Tp>
-  void __pstl_fill_n(_Backend, _Iterator __first, _SizeT __n, const _Tp& __value);
-
-  template <class _ExecutionPolicy, class _terator1, class _Iterator2, class _OutIterator, class _Comp>
-  _OutIterator __pstl_merge(_Backend,
-                            _Iterator1 __first1,
-                            _Iterator1 __last1,
-                            _Iterator2 __first2,
-                            _Iterator2 __last2,
-                            _OutIterator __result,
-                            _Comp __comp);
-
-// TODO: Complete this list
-
-*/
-
-template <class _ExecutionPolicy>
-struct __select_backend;
-
-template <>
-struct __select_backend<std::execution::sequenced_policy> {
-  using type = __cpu_backend_tag;
-};
-
-#  if _LIBCPP_STD_VER >= 20
-template <>
-struct __select_backend<std::execution::unsequenced_policy> {
-  using type = __cpu_backend_tag;
-};
-#  endif
-
-#  if defined(_LIBCPP_PSTL_CPU_BACKEND_SERIAL) || defined(_LIBCPP_PSTL_CPU_BACKEND_THREAD)
-template <>
-struct __select_backend<std::execution::parallel_policy> {
-  using type = __cpu_backend_tag;
-};
-
-template <>
-struct __select_backend<std::execution::parallel_unsequenced_policy> {
-  using type = __cpu_backend_tag;
-};
-
-#  else
-
-// ...New vendors can add parallel backends here...
-
-#    error "Invalid choice of a PSTL parallel backend"
-#  endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKEND_H
diff --git a/third_party/libcxx/__algorithm/pstl_backends/cpu_backend.h b/third_party/libcxx/__algorithm/pstl_backends/cpu_backend.h
deleted file mode 100644
index 3939b8211..000000000
--- a/third_party/libcxx/__algorithm/pstl_backends/cpu_backend.h
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKEND_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKEND_H
-
-#include <__config>
-
-/*
-
-  // _Functor takes a subrange for [__first, __last) that should be executed in serial
-  template <class _RandomAccessIterator, class _Functor>
-  void __parallel_for(_RandomAccessIterator __first, _RandomAccessIterator __last, _Functor __func);
-
-  // Cancel the execution of other jobs - they aren't needed anymore
-  void __cancel_execution();
-
-  template <class _RandomAccessIterator1,
-            class _RandomAccessIterator2,
-            class _RandomAccessIterator3,
-            class _Compare,
-            class _LeafMerge>
-  void __parallel_merge(
-      _RandomAccessIterator1 __first1,
-      _RandomAccessIterator1 __last1,
-      _RandomAccessIterator2 __first2,
-      _RandomAccessIterator2 __last2,
-      _RandomAccessIterator3 __outit,
-      _Compare __comp,
-      _LeafMerge __leaf_merge);
-
-  TODO: Document the parallel backend
-*/
-
-#include <__algorithm/pstl_backends/cpu_backends/any_of.h>
-#include <__algorithm/pstl_backends/cpu_backends/fill.h>
-#include <__algorithm/pstl_backends/cpu_backends/find_if.h>
-#include <__algorithm/pstl_backends/cpu_backends/for_each.h>
-#include <__algorithm/pstl_backends/cpu_backends/merge.h>
-#include <__algorithm/pstl_backends/cpu_backends/transform.h>
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKEND_H
diff --git a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/any_of.h b/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/any_of.h
deleted file mode 100644
index 8fe26797b..000000000
--- a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/any_of.h
+++ /dev/null
@@ -1,90 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKEND_ANY_OF_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKEND_ANY_OF_H
-
-#include <__algorithm/any_of.h>
-#include <__algorithm/find_if.h>
-#include <__algorithm/pstl_backends/cpu_backends/backend.h>
-#include <__atomic/atomic.h>
-#include <__atomic/memory_order.h>
-#include <__config>
-#include <__functional/operations.h>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__utility/pair.h>
-#include <__utility/terminate_on_exception.h>
-#include <cstdint>
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Index, class _Brick>
-_LIBCPP_HIDE_FROM_ABI bool __parallel_or(_Index __first, _Index __last, _Brick __f) {
-  std::atomic<bool> __found(false);
-  __par_backend::__parallel_for(__first, __last, [__f, &__found](_Index __i, _Index __j) {
-    if (!__found.load(std::memory_order_relaxed) && __f(__i, __j)) {
-      __found.store(true, std::memory_order_relaxed);
-      __par_backend::__cancel_execution();
-    }
-  });
-  return __found;
-}
-
-// TODO: check whether __simd_first() can be used here
-template <class _Index, class _DifferenceType, class _Pred>
-_LIBCPP_HIDE_FROM_ABI bool __simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept {
-  _DifferenceType __block_size = 4 < __n ? 4 : __n;
-  const _Index __last          = __first + __n;
-  while (__last != __first) {
-    int32_t __flag = 1;
-    _PSTL_PRAGMA_SIMD_REDUCTION(& : __flag)
-    for (_DifferenceType __i = 0; __i < __block_size; ++__i)
-      if (__pred(*(__first + __i)))
-        __flag = 0;
-    if (!__flag)
-      return true;
-
-    __first += __block_size;
-    if (__last - __first >= __block_size << 1) {
-      // Double the block _Size.  Any unnecessary iterations can be amortized against work done so far.
-      __block_size <<= 1;
-    } else {
-      __block_size = __last - __first;
-    }
-  }
-  return false;
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-_LIBCPP_HIDE_FROM_ABI bool
-__pstl_any_of(__cpu_backend_tag, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
-  if constexpr (__is_parallel_execution_policy_v<_ExecutionPolicy> &&
-                __has_random_access_iterator_category<_ForwardIterator>::value) {
-    return std::__terminate_on_exception([&] {
-      return std::__parallel_or(
-          __first, __last, [&__pred](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
-            return std::__pstl_any_of<__remove_parallel_policy_t<_ExecutionPolicy>>(
-                __cpu_backend_tag{}, __brick_first, __brick_last, __pred);
-          });
-    });
-  } else if constexpr (__is_unsequenced_execution_policy_v<_ExecutionPolicy> &&
-                       __has_random_access_iterator_category<_ForwardIterator>::value) {
-    return std::__simd_or(__first, __last - __first, __pred);
-  } else {
-    return std::any_of(__first, __last, __pred);
-  }
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKEND_ANY_OF_H
diff --git a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/backend.h b/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/backend.h
deleted file mode 100644
index e40d16857..000000000
--- a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/backend.h
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKEND_BACKEND_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKEND_BACKEND_H
-
-#include <__config>
-
-#if defined(_LIBCPP_PSTL_CPU_BACKEND_SERIAL)
-#  include <__algorithm/pstl_backends/cpu_backends/serial.h>
-#elif defined(_LIBCPP_PSTL_CPU_BACKEND_THREAD)
-#  include <__algorithm/pstl_backends/cpu_backends/thread.h>
-#else
-#  error "Invalid CPU backend choice"
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-struct __cpu_backend_tag {};
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKEND_BACKEND_H
diff --git a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/fill.h b/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/fill.h
deleted file mode 100644
index 5e5e0a23b..000000000
--- a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/fill.h
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_FILL_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_FILL_H
-
-#include <__algorithm/fill.h>
-#include <__algorithm/pstl_backends/cpu_backends/backend.h>
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__utility/terminate_on_exception.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Index, class _DifferenceType, class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Index __simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept {
-  _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
-  _PSTL_PRAGMA_SIMD
-  for (_DifferenceType __i = 0; __i < __n; ++__i)
-    __first[__i] = __value;
-  return __first + __n;
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-_LIBCPP_HIDE_FROM_ABI void
-__pstl_fill(__cpu_backend_tag, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
-  if constexpr (__is_parallel_execution_policy_v<_ExecutionPolicy> &&
-                __has_random_access_iterator_category<_ForwardIterator>::value) {
-    std::__terminate_on_exception([&] {
-      __par_backend::__parallel_for(
-          __first, __last, [&__value](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
-            std::__pstl_fill<__remove_parallel_policy_t<_ExecutionPolicy>>(
-                __cpu_backend_tag{}, __brick_first, __brick_last, __value);
-          });
-    });
-  } else if constexpr (__is_unsequenced_execution_policy_v<_ExecutionPolicy> &&
-                       __has_random_access_iterator_category<_ForwardIterator>::value) {
-    std::__simd_fill_n(__first, __last - __first, __value);
-  } else {
-    std::fill(__first, __last, __value);
-  }
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_FILL_H
diff --git a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/find_if.h b/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/find_if.h
deleted file mode 100644
index 72059a48b..000000000
--- a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/find_if.h
+++ /dev/null
@@ -1,125 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_FIND_IF_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_FIND_IF_H
-
-#include <__algorithm/find_if.h>
-#include <__algorithm/pstl_backends/cpu_backends/backend.h>
-#include <__atomic/atomic.h>
-#include <__config>
-#include <__functional/operations.h>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__utility/pair.h>
-#include <__utility/terminate_on_exception.h>
-#include <cstddef>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Index, class _Brick, class _Compare>
-_LIBCPP_HIDE_FROM_ABI _Index
-__parallel_find(_Index __first, _Index __last, _Brick __f, _Compare __comp, bool __b_first) {
-  typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
-  const _DifferenceType __n      = __last - __first;
-  _DifferenceType __initial_dist = __b_first ? __n : -1;
-  std::atomic<_DifferenceType> __extremum(__initial_dist);
-  // TODO: find out what is better here: parallel_for or parallel_reduce
-  __par_backend::__parallel_for(__first, __last, [__comp, __f, __first, &__extremum](_Index __i, _Index __j) {
-    // See "Reducing Contention Through Priority Updates", PPoPP '13, for discussion of
-    // why using a shared variable scales fairly well in this situation.
-    if (__comp(__i - __first, __extremum)) {
-      _Index __res = __f(__i, __j);
-      // If not '__last' returned then we found what we want so put this to extremum
-      if (__res != __j) {
-        const _DifferenceType __k = __res - __first;
-        for (_DifferenceType __old = __extremum; __comp(__k, __old); __old = __extremum) {
-          __extremum.compare_exchange_weak(__old, __k);
-        }
-      }
-    }
-  });
-  return __extremum != __initial_dist ? __first + __extremum : __last;
-}
-
-const std::size_t __lane_size = 64;
-
-template <class _Index, class _DifferenceType, class _Compare>
-_LIBCPP_HIDE_FROM_ABI _Index
-__simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept {
-  // Experiments show good block sizes like this
-  const _DifferenceType __block_size                        = 8;
-  alignas(__lane_size) _DifferenceType __lane[__block_size] = {0};
-  while (__end - __begin >= __block_size) {
-    _DifferenceType __found = 0;
-    _PSTL_PRAGMA_SIMD_REDUCTION(| : __found) for (_DifferenceType __i = __begin; __i < __begin + __block_size; ++__i) {
-      const _DifferenceType __t = __comp(__first, __i);
-      __lane[__i - __begin]     = __t;
-      __found |= __t;
-    }
-    if (__found) {
-      _DifferenceType __i;
-      // This will vectorize
-      for (__i = 0; __i < __block_size; ++__i) {
-        if (__lane[__i]) {
-          break;
-        }
-      }
-      return __first + __begin + __i;
-    }
-    __begin += __block_size;
-  }
-
-  // Keep remainder scalar
-  while (__begin != __end) {
-    if (__comp(__first, __begin)) {
-      return __first + __begin;
-    }
-    ++__begin;
-  }
-  return __first + __end;
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-_LIBCPP_HIDE_FROM_ABI _ForwardIterator
-__pstl_find_if(__cpu_backend_tag, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
-  if constexpr (__is_parallel_execution_policy_v<_ExecutionPolicy> &&
-                __has_random_access_iterator_category<_ForwardIterator>::value) {
-    return std::__terminate_on_exception([&] {
-      return std::__parallel_find(
-          __first,
-          __last,
-          [&__pred](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
-            return std::__pstl_find_if<__remove_parallel_policy_t<_ExecutionPolicy>>(
-                __cpu_backend_tag{}, __brick_first, __brick_last, __pred);
-          },
-          less<>{},
-          true);
-    });
-  } else if constexpr (__is_unsequenced_execution_policy_v<_ExecutionPolicy> &&
-                       __has_random_access_iterator_category<_ForwardIterator>::value) {
-    using __diff_t = __iter_diff_t<_ForwardIterator>;
-    return std::__simd_first(__first, __diff_t(0), __last - __first, [&__pred](_ForwardIterator __iter, __diff_t __i) {
-      return __pred(__iter[__i]);
-    });
-  } else {
-    return std::find_if(__first, __last, __pred);
-  }
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_FIND_IF_H
diff --git a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/for_each.h b/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/for_each.h
deleted file mode 100644
index 36d0ac238..000000000
--- a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/for_each.h
+++ /dev/null
@@ -1,60 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKNEDS_FOR_EACH_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKNEDS_FOR_EACH_H
-
-#include <__algorithm/for_each.h>
-#include <__algorithm/pstl_backends/cpu_backends/backend.h>
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__utility/terminate_on_exception.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Iterator, class _DifferenceType, class _Function>
-_LIBCPP_HIDE_FROM_ABI _Iterator __simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept {
-  _PSTL_PRAGMA_SIMD
-  for (_DifferenceType __i = 0; __i < __n; ++__i)
-    __f(__first[__i]);
-
-  return __first + __n;
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Functor>
-_LIBCPP_HIDE_FROM_ABI void
-__pstl_for_each(__cpu_backend_tag, _ForwardIterator __first, _ForwardIterator __last, _Functor __func) {
-  if constexpr (__is_parallel_execution_policy_v<_ExecutionPolicy> &&
-                __has_random_access_iterator_category<_ForwardIterator>::value) {
-    std::__terminate_on_exception([&] {
-      std::__par_backend::__parallel_for(
-          __first, __last, [__func](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
-            std::__pstl_for_each<__remove_parallel_policy_t<_ExecutionPolicy>>(
-                __cpu_backend_tag{}, __brick_first, __brick_last, __func);
-          });
-    });
-  } else if constexpr (__is_unsequenced_execution_policy_v<_ExecutionPolicy> &&
-                       __has_random_access_iterator_category<_ForwardIterator>::value) {
-    std::__simd_walk_1(__first, __last - __first, __func);
-  } else {
-    std::for_each(__first, __last, __func);
-  }
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKNEDS_FOR_EACH_H
diff --git a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/merge.h b/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/merge.h
deleted file mode 100644
index d5be1e302..000000000
--- a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/merge.h
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_MERGE_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_MERGE_H
-
-#include <__algorithm/merge.h>
-#include <__algorithm/pstl_backends/cpu_backends/backend.h>
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__utility/move.h>
-#include <__utility/terminate_on_exception.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardOutIterator,
-          class _Comp>
-_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator __pstl_merge(
-    __cpu_backend_tag,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardOutIterator __result,
-    _Comp __comp) {
-  if constexpr (__is_parallel_execution_policy_v<_ExecutionPolicy> &&
-                __has_random_access_iterator_category<_ForwardIterator1>::value &&
-                __has_random_access_iterator_category<_ForwardIterator2>::value &&
-                __has_random_access_iterator_category<_ForwardOutIterator>::value) {
-    return std::__terminate_on_exception([&] {
-      __par_backend::__parallel_merge(
-          __first1,
-          __last1,
-          __first2,
-          __last2,
-          __result,
-          __comp,
-          [](_ForwardIterator1 __g_first1,
-             _ForwardIterator1 __g_last1,
-             _ForwardIterator2 __g_first2,
-             _ForwardIterator2 __g_last2,
-             _ForwardOutIterator __g_result,
-             _Comp __g_comp) {
-            return std::__pstl_merge<__remove_parallel_policy_t<_ExecutionPolicy>>(
-                __cpu_backend_tag{},
-                std::move(__g_first1),
-                std::move(__g_last1),
-                std::move(__g_first2),
-                std::move(__g_last2),
-                std::move(__g_result),
-                std::move(__g_comp));
-          });
-      return __result + (__last1 - __first1) + (__last2 - __first2);
-    });
-  } else {
-    return std::merge(__first1, __last1, __first2, __last2, __result, __comp);
-  }
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_MERGE_H
diff --git a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/serial.h b/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/serial.h
deleted file mode 100644
index 0c3aafae6..000000000
--- a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/serial.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_SERIAL_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_SERIAL_H
-
-#include <__config>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace __par_backend {
-inline namespace __serial_cpu_backend {
-
-template <class _RandomAccessIterator, class _Fp>
-_LIBCPP_HIDE_FROM_ABI void __parallel_for(_RandomAccessIterator __first, _RandomAccessIterator __last, _Fp __f) {
-  __f(__first, __last);
-}
-
-_LIBCPP_HIDE_FROM_ABI inline void __cancel_execution() {}
-
-template <class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _RandomAccessIterator3,
-          class _Compare,
-          class _LeafMerge>
-_LIBCPP_HIDE_FROM_ABI void __parallel_merge(
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _RandomAccessIterator3 __outit,
-    _Compare __comp,
-    _LeafMerge __leaf_merge) {
-  __leaf_merge(__first1, __last1, __first2, __last2, __outit, __comp);
-}
-
-// TODO: Complete this list
-
-} // namespace __serial_cpu_backend
-} // namespace __par_backend
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_SERIAL_H
diff --git a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/thread.h b/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/thread.h
deleted file mode 100644
index 93745d306..000000000
--- a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/thread.h
+++ /dev/null
@@ -1,59 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_THREAD_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_THREAD_H
-
-#include <__assert>
-#include <__config>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-// This backend implementation is for testing purposes only and not meant for production use. This will be replaced
-// by a proper implementation once the PSTL implementation is somewhat stable.
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace __par_backend {
-inline namespace __thread_cpu_backend {
-
-template <class _RandomAccessIterator, class _Fp>
-_LIBCPP_HIDE_FROM_ABI void __parallel_for(_RandomAccessIterator __first, _RandomAccessIterator __last, _Fp __f) {
-  __f(__first, __last);
-}
-
-_LIBCPP_HIDE_FROM_ABI inline void __cancel_execution() {}
-
-template <class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _RandomAccessIterator3,
-          class _Compare,
-          class _LeafMerge>
-_LIBCPP_HIDE_FROM_ABI void __parallel_merge(
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _RandomAccessIterator3 __outit,
-    _Compare __comp,
-    _LeafMerge __leaf_merge) {
-  __leaf_merge(__first1, __last1, __first2, __last2, __outit, __comp);
-}
-
-} // namespace __thread_cpu_backend
-} // namespace __par_backend
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_THREAD_H
diff --git a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/transform.h b/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/transform.h
deleted file mode 100644
index ef25ff023..000000000
--- a/third_party/libcxx/__algorithm/pstl_backends/cpu_backends/transform.h
+++ /dev/null
@@ -1,132 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_TRANSFORM_H
-#define _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_TRANSFORM_H
-
-#include <__algorithm/pstl_backends/cpu_backends/backend.h>
-#include <__algorithm/transform.h>
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/enable_if.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__type_traits/remove_cvref.h>
-#include <__utility/terminate_on_exception.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Function>
-_LIBCPP_HIDE_FROM_ABI _Iterator2
-__simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept {
-  _PSTL_PRAGMA_SIMD
-  for (_DifferenceType __i = 0; __i < __n; ++__i)
-    __f(__first1[__i], __first2[__i]);
-  return __first2 + __n;
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _ForwardOutIterator, class _UnaryOperation>
-_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator __pstl_transform(
-    __cpu_backend_tag,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _ForwardOutIterator __result,
-    _UnaryOperation __op) {
-  if constexpr (__is_parallel_execution_policy_v<_ExecutionPolicy> &&
-                __has_random_access_iterator_category<_ForwardIterator>::value &&
-                __has_random_access_iterator_category<_ForwardOutIterator>::value) {
-    std::__terminate_on_exception([&] {
-      std::__par_backend::__parallel_for(
-          __first, __last, [__op, __first, __result](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
-            return std::__pstl_transform<__remove_parallel_policy_t<_ExecutionPolicy>>(
-                __cpu_backend_tag{}, __brick_first, __brick_last, __result + (__brick_first - __first), __op);
-          });
-    });
-    return __result + (__last - __first);
-  } else if constexpr (__is_unsequenced_execution_policy_v<_ExecutionPolicy> &&
-                       __has_random_access_iterator_category<_ForwardIterator>::value &&
-                       __has_random_access_iterator_category<_ForwardOutIterator>::value) {
-    return std::__simd_walk_2(
-        __first,
-        __last - __first,
-        __result,
-        [&](__iter_reference<_ForwardIterator> __in_value, __iter_reference<_ForwardOutIterator> __out_value) {
-          __out_value = __op(__in_value);
-        });
-  } else {
-    return std::transform(__first, __last, __result, __op);
-  }
-}
-
-template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Iterator3, class _Function>
-_LIBCPP_HIDE_FROM_ABI _Iterator3 __simd_walk_3(
-    _Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3, _Function __f) noexcept {
-  _PSTL_PRAGMA_SIMD
-  for (_DifferenceType __i = 0; __i < __n; ++__i)
-    __f(__first1[__i], __first2[__i], __first3[__i]);
-  return __first3 + __n;
-}
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardOutIterator,
-          class _BinaryOperation,
-          enable_if_t<is_execution_policy_v<__remove_cvref_t<_ExecutionPolicy>>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator __pstl_transform(
-    __cpu_backend_tag,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardOutIterator __result,
-    _BinaryOperation __op) {
-  if constexpr (__is_parallel_execution_policy_v<_ExecutionPolicy> &&
-                __has_random_access_iterator_category<_ForwardIterator1>::value &&
-                __has_random_access_iterator_category<_ForwardIterator2>::value &&
-                __has_random_access_iterator_category<_ForwardOutIterator>::value) {
-    std::__terminate_on_exception([&] {
-      std::__par_backend::__parallel_for(
-          __first1,
-          __last1,
-          [__op, __first1, __first2, __result](_ForwardIterator1 __brick_first, _ForwardIterator1 __brick_last) {
-            return std::__pstl_transform<__remove_parallel_policy_t<_ExecutionPolicy>>(
-                __cpu_backend_tag{},
-                __brick_first,
-                __brick_last,
-                __first2 + (__brick_first - __first1),
-                __result + (__brick_first - __first1),
-                __op);
-          });
-    });
-    return __result + (__last1 - __first1);
-  } else if constexpr (__is_unsequenced_execution_policy_v<_ExecutionPolicy> &&
-                       __has_random_access_iterator_category<_ForwardIterator1>::value &&
-                       __has_random_access_iterator_category<_ForwardIterator2>::value &&
-                       __has_random_access_iterator_category<_ForwardOutIterator>::value) {
-    return std::__simd_walk_3(
-        __first1,
-        __last1 - __first1,
-        __first2,
-        __result,
-        [&](__iter_reference<_ForwardIterator1> __in1,
-            __iter_reference<_ForwardIterator2> __in2,
-            __iter_reference<_ForwardOutIterator> __out_value) { __out_value = __op(__in1, __in2); });
-  } else {
-    return std::transform(__first1, __last1, __first2, __result, __op);
-  }
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_BACKENDS_CPU_BACKENDS_TRANSFORM_H
diff --git a/third_party/libcxx/__algorithm/pstl_copy.h b/third_party/libcxx/__algorithm/pstl_copy.h
deleted file mode 100644
index 5b7d921d7..000000000
--- a/third_party/libcxx/__algorithm/pstl_copy.h
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_COPY_H
-#define _LIBCPP___ALGORITHM_PSTL_COPY_H
-
-#include <__algorithm/copy_n.h>
-#include <__algorithm/pstl_transform.h>
-#include <__config>
-#include <__functional/identity.h>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_constant_evaluated.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__type_traits/is_trivially_copyable.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// TODO: Use the std::copy/move shenanigans to forward to std::memmove
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _ForwardOutIterator,
-          enable_if_t<is_execution_policy_v<__remove_cvref_t<_ExecutionPolicy>>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
-copy(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __result) {
-  return std::transform(__policy, __first, __last, __result, __identity());
-}
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _ForwardOutIterator,
-          class _Size,
-          enable_if_t<is_execution_policy_v<__remove_cvref_t<_ExecutionPolicy>>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
-copy_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __n, _ForwardOutIterator __result) {
-  if constexpr (__has_random_access_iterator_category<_ForwardIterator>::value)
-    return std::copy(__policy, __first, __first + __n, __result);
-  else
-    return std::copy_n(__first, __n, __result);
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_COPY_H
diff --git a/third_party/libcxx/__algorithm/pstl_fill.h b/third_party/libcxx/__algorithm/pstl_fill.h
deleted file mode 100644
index 03217b36d..000000000
--- a/third_party/libcxx/__algorithm/pstl_fill.h
+++ /dev/null
@@ -1,79 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_FILL_H
-#define _LIBCPP___ALGORITHM_PSTL_FILL_H
-
-#include <__algorithm/fill_n.h>
-#include <__algorithm/pstl_for_each.h>
-#include <__algorithm/pstl_frontend_dispatch.h>
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__type_traits/remove_cvref.h>
-#include <__utility/terminate_on_exception.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class>
-void __pstl_fill(); // declaration needed for the frontend dispatch below
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Tp,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI void
-fill(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
-  std::__pstl_frontend_dispatch(
-      _LIBCPP_PSTL_CUSTOMIZATION_POINT(__pstl_fill),
-      [&](_ForwardIterator __g_first, _ForwardIterator __g_last, const _Tp& __g_value) {
-        std::for_each(__policy, __g_first, __g_last, [&](__iter_reference<_ForwardIterator> __element) {
-          __element = __g_value;
-        });
-      },
-      std::move(__first),
-      std::move(__last),
-      __value);
-}
-
-template <class>
-void __pstl_fill_n(); // declaration needed for the frontend dispatch below
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _SizeT,
-          class _Tp,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI void
-fill_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _SizeT __n, const _Tp& __value) {
-  std::__pstl_frontend_dispatch(
-      _LIBCPP_PSTL_CUSTOMIZATION_POINT(__pstl_fill_n),
-      [&](_ForwardIterator __g_first, _SizeT __g_n, const _Tp& __g_value) {
-        if constexpr (__has_random_access_iterator_category<_ForwardIterator>::value)
-          std::fill(__policy, __g_first, __g_first + __g_n, __g_value);
-        else
-          std::fill_n(__g_first, __g_n, __g_value);
-      },
-      std::move(__first),
-      __n,
-      __value);
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_FILL_H
diff --git a/third_party/libcxx/__algorithm/pstl_find.h b/third_party/libcxx/__algorithm/pstl_find.h
deleted file mode 100644
index 6d69560dc..000000000
--- a/third_party/libcxx/__algorithm/pstl_find.h
+++ /dev/null
@@ -1,89 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_FIND_H
-#define _LIBCPP___ALGORITHM_PSTL_FIND_H
-
-#include <__algorithm/comp.h>
-#include <__algorithm/find.h>
-#include <__algorithm/pstl_backend.h>
-#include <__algorithm/pstl_frontend_dispatch.h>
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__type_traits/remove_cvref.h>
-#include <__utility/terminate_on_exception.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Predicate,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _ForwardIterator
-find_if(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
-  using _Backend = typename __select_backend<_RawPolicy>::type;
-  return std::__pstl_find_if<_RawPolicy>(_Backend{}, std::move(__first), std::move(__last), std::move(__pred));
-}
-
-template <class>
-void __pstl_find_if_not();
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Predicate,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _ForwardIterator
-find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
-  return std::__pstl_frontend_dispatch(
-      _LIBCPP_PSTL_CUSTOMIZATION_POINT(__pstl_find_if_not),
-      [&](_ForwardIterator __g_first, _ForwardIterator __g_last, _Predicate __g_pred) {
-        return std::find_if(__policy, __g_first, __g_last, [&](__iter_reference<_ForwardIterator> __value) {
-          return !__g_pred(__value);
-        });
-      },
-      std::move(__first),
-      std::move(__last),
-      std::move(__pred));
-}
-
-template <class>
-void __pstl_find();
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Tp,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _ForwardIterator
-find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
-  return std::__pstl_frontend_dispatch(
-      _LIBCPP_PSTL_CUSTOMIZATION_POINT(__pstl_find),
-      [&](_ForwardIterator __g_first, _ForwardIterator __g_last, const _Tp& __g_value) {
-        return std::find_if(__policy, __g_first, __g_last, [&](__iter_reference<_ForwardIterator> __element) {
-          return __element == __g_value;
-        });
-      },
-      std::move(__first),
-      std::move(__last),
-      __value);
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_FIND_H
diff --git a/third_party/libcxx/__algorithm/pstl_for_each.h b/third_party/libcxx/__algorithm/pstl_for_each.h
deleted file mode 100644
index 1c435385d..000000000
--- a/third_party/libcxx/__algorithm/pstl_for_each.h
+++ /dev/null
@@ -1,71 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_FOR_EACH_H
-#define _LIBCPP___ALGORITHM_PSTL_FOR_EACH_H
-
-#include <__algorithm/for_each.h>
-#include <__algorithm/for_each_n.h>
-#include <__algorithm/pstl_backend.h>
-#include <__algorithm/pstl_frontend_dispatch.h>
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__type_traits/remove_cvref.h>
-#include <__type_traits/void_t.h>
-#include <__utility/terminate_on_exception.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Function,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI void
-for_each(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __func) {
-  using _Backend = typename __select_backend<_RawPolicy>::type;
-  std::__pstl_for_each<_RawPolicy>(_Backend{}, std::move(__first), std::move(__last), std::move(__func));
-}
-
-template <class>
-void __pstl_for_each_n(); // declaration needed for the frontend dispatch below
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Size,
-          class _Function,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI void
-for_each_n(_ExecutionPolicy&& __policy, _ForwardIterator __first, _Size __size, _Function __func) {
-  return std::__pstl_frontend_dispatch(
-      _LIBCPP_PSTL_CUSTOMIZATION_POINT(__pstl_for_each_n),
-      [&](_ForwardIterator __g_first, _Size __g_size, _Function __g_func) {
-        if constexpr (__has_random_access_iterator_category<_ForwardIterator>::value) {
-          std::for_each(__policy, std::move(__g_first), __g_first + __g_size, std::move(__g_func));
-        } else {
-          std::for_each_n(std::move(__g_first), __g_size, std::move(__g_func));
-        }
-      },
-      __first,
-      __size,
-      std::move(__func));
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_FOR_EACH_H
diff --git a/third_party/libcxx/__algorithm/pstl_frontend_dispatch.h b/third_party/libcxx/__algorithm/pstl_frontend_dispatch.h
deleted file mode 100644
index dc49f3e51..000000000
--- a/third_party/libcxx/__algorithm/pstl_frontend_dispatch.h
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_FRONTEND_DISPATCH
-#define _LIBCPP___ALGORITHM_PSTL_FRONTEND_DISPATCH
-
-#include <__config>
-#include <__type_traits/is_callable.h>
-#include <__utility/forward.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#  define _LIBCPP_PSTL_CUSTOMIZATION_POINT(name)                                                                       \
-    [](auto&&... __args) -> decltype(std::name<_RawPolicy>(typename __select_backend<_RawPolicy>::type{},              \
-                                                           std::forward<decltype(__args)>(__args)...)) {               \
-      return std::name<_RawPolicy>(                                                                                    \
-          typename __select_backend<_RawPolicy>::type{}, std::forward<decltype(__args)>(__args)...);                   \
-    }
-
-template <class _SpecializedImpl, class _GenericImpl, class... _Args>
-_LIBCPP_HIDE_FROM_ABI decltype(auto)
-__pstl_frontend_dispatch(_SpecializedImpl __specialized_impl, _GenericImpl __generic_impl, _Args&&... __args) {
-  if constexpr (__is_callable<_SpecializedImpl, _Args...>::value) {
-    return __specialized_impl(std::forward<_Args>(__args)...);
-  } else {
-    return __generic_impl(std::forward<_Args>(__args)...);
-  }
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_FRONTEND_DISPATCH
diff --git a/third_party/libcxx/__algorithm/pstl_merge.h b/third_party/libcxx/__algorithm/pstl_merge.h
deleted file mode 100644
index b5585eeec..000000000
--- a/third_party/libcxx/__algorithm/pstl_merge.h
+++ /dev/null
@@ -1,56 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_MERGE_H
-#define _LIBCPP___ALGORITHM_PSTL_MERGE_H
-
-#include <__algorithm/pstl_backend.h>
-#include <__config>
-#include <__functional/operations.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__type_traits/remove_cvref.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardOutIterator,
-          class _Comp                                         = std::less<>,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator
-merge(_ExecutionPolicy&&,
-      _ForwardIterator1 __first1,
-      _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2,
-      _ForwardIterator2 __last2,
-      _ForwardOutIterator __result,
-      _Comp __comp = {}) {
-  using _Backend = typename __select_backend<_RawPolicy>::type;
-  return std::__pstl_merge<_RawPolicy>(
-      _Backend{},
-      std::move(__first1),
-      std::move(__last1),
-      std::move(__first2),
-      std::move(__last2),
-      std::move(__result),
-      std::move(__comp));
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_MERGE_H
diff --git a/third_party/libcxx/__algorithm/pstl_transform.h b/third_party/libcxx/__algorithm/pstl_transform.h
deleted file mode 100644
index 9d2d731ee..000000000
--- a/third_party/libcxx/__algorithm/pstl_transform.h
+++ /dev/null
@@ -1,66 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___ALGORITHM_PSTL_TRANSFORM_H
-#define _LIBCPP___ALGORITHM_PSTL_TRANSFORM_H
-
-#include <__algorithm/pstl_backend.h>
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_execution_policy.h>
-#include <__utility/terminate_on_exception.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _ForwardOutIterator,
-          class _UnaryOperation,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform(
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _ForwardOutIterator __result,
-    _UnaryOperation __op) {
-  using _Backend = typename __select_backend<_RawPolicy>::type;
-  return std::__pstl_transform<_RawPolicy>(
-      _Backend{}, std::move(__first), std::move(__last), std::move(__result), std::move(__op));
-}
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardOutIterator,
-          class _BinaryOperation,
-          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
-          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _ForwardOutIterator transform(
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardOutIterator __result,
-    _BinaryOperation __op) {
-  using _Backend = typename __select_backend<_RawPolicy>::type;
-  return std::__pstl_transform<_RawPolicy>(
-      _Backend{}, std::move(__first1), std::move(__last1), std::move(__first2), std::move(__result), std::move(__op));
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___ALGORITHM_PSTL_TRANSFORM_H
diff --git a/third_party/libcxx/__algorithm/push_heap.h b/third_party/libcxx/__algorithm/push_heap.h
index e831162a8..ec0b445f2 100644
--- a/third_party/libcxx/__algorithm/push_heap.h
+++ b/third_party/libcxx/__algorithm/push_heap.h
@@ -14,31 +14,36 @@
 #include <__algorithm/iterator_operations.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
-#include <__type_traits/is_copy_assignable.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-void __sift_up(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp,
-        typename iterator_traits<_RandomAccessIterator>::difference_type __len) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+__sift_up(_RandomAccessIterator __first,
+          _RandomAccessIterator __last,
+          _Compare&& __comp,
+          typename iterator_traits<_RandomAccessIterator>::difference_type __len) {
   using value_type = typename iterator_traits<_RandomAccessIterator>::value_type;
 
   if (__len > 1) {
-    __len = (__len - 2) / 2;
+    __len                       = (__len - 2) / 2;
     _RandomAccessIterator __ptr = __first + __len;
 
     if (__comp(*__ptr, *--__last)) {
       value_type __t(_IterOps<_AlgPolicy>::__iter_move(__last));
       do {
         *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr);
-        __last = __ptr;
+        __last  = __ptr;
         if (__len == 0)
           break;
         __len = (__len - 1) / 2;
@@ -51,15 +56,15 @@ void __sift_up(_RandomAccessIterator __first, _RandomAccessIterator __last, _Com
 }
 
 template <class _AlgPolicy, class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-void __push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+__push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) {
   typename iterator_traits<_RandomAccessIterator>::difference_type __len = __last - __first;
   std::__sift_up<_AlgPolicy, __comp_ref_type<_Compare> >(std::move(__first), std::move(__last), __comp, __len);
 }
 
 template <class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
   static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible.");
   static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable.");
 
@@ -67,12 +72,13 @@ void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Com
 }
 
 template <class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
-  std::push_heap(std::move(__first), std::move(__last),
-      __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
+  std::push_heap(std::move(__first), std::move(__last), __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_PUSH_HEAP_H
diff --git a/third_party/libcxx/__algorithm/ranges_adjacent_find.h b/third_party/libcxx/__algorithm/ranges_adjacent_find.h
index e3de36bbc..3c54f7233 100644
--- a/third_party/libcxx/__algorithm/ranges_adjacent_find.h
+++ b/third_party/libcxx/__algorithm/ranges_adjacent_find.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -31,10 +34,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __adjacent_find {
 struct __fn {
-
   template <class _Iter, class _Sent, class _Proj, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  _Iter __adjacent_find_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter
+  __adjacent_find_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
     if (__first == __last)
       return __first;
 
@@ -47,27 +49,28 @@ struct __fn {
     return __i;
   }
 
-  template <forward_iterator _Iter, sentinel_for<_Iter> _Sent,
-            class _Proj = identity,
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj                                                                       = identity,
             indirect_binary_predicate<projected<_Iter, _Proj>, projected<_Iter, _Proj>> _Pred = ranges::equal_to>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, _Pred __pred = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, _Pred __pred = {}, _Proj __proj = {}) const {
     return __adjacent_find_impl(std::move(__first), std::move(__last), __pred, __proj);
   }
 
   template <forward_range _Range,
             class _Proj = identity,
-            indirect_binary_predicate<projected<iterator_t<_Range>, _Proj>,
-                                      projected<iterator_t<_Range>, _Proj>> _Pred = ranges::equal_to>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __range, _Pred __pred = {}, _Proj __proj = {}) const {
+            indirect_binary_predicate<projected<iterator_t<_Range>, _Proj>, projected<iterator_t<_Range>, _Proj>>
+                _Pred = ranges::equal_to>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __range, _Pred __pred = {}, _Proj __proj = {}) const {
     return __adjacent_find_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
   }
 };
 } // namespace __adjacent_find
 
 inline namespace __cpo {
-  inline constexpr auto adjacent_find = __adjacent_find::__fn{};
+inline constexpr auto adjacent_find = __adjacent_find::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -75,4 +78,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_ADJACENT_FIND_H
diff --git a/third_party/libcxx/__algorithm/ranges_all_of.h b/third_party/libcxx/__algorithm/ranges_all_of.h
index 494a77d74..2f603b32f 100644
--- a/third_party/libcxx/__algorithm/ranges_all_of.h
+++ b/third_party/libcxx/__algorithm/ranges_all_of.h
@@ -22,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -29,10 +32,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __all_of {
 struct __fn {
-
   template <class _Iter, class _Sent, class _Proj, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  bool __all_of_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static bool __all_of_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
     for (; __first != __last; ++__first) {
       if (!std::invoke(__pred, std::invoke(__proj, *__first)))
         return false;
@@ -40,24 +41,27 @@ struct __fn {
     return true;
   }
 
-  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+  template <input_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
     return __all_of_impl(std::move(__first), std::move(__last), __pred, __proj);
   }
 
-  template <input_range _Range, class _Proj = identity,
+  template <input_range _Range,
+            class _Proj = identity,
             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
     return __all_of_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
   }
 };
 } // namespace __all_of
 
 inline namespace __cpo {
-  inline constexpr auto all_of = __all_of::__fn{};
+inline constexpr auto all_of = __all_of::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -65,4 +69,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_ALL_OF_H
diff --git a/third_party/libcxx/__algorithm/ranges_any_of.h b/third_party/libcxx/__algorithm/ranges_any_of.h
index eb102bd85..205fcecc0 100644
--- a/third_party/libcxx/__algorithm/ranges_any_of.h
+++ b/third_party/libcxx/__algorithm/ranges_any_of.h
@@ -22,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -29,10 +32,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __any_of {
 struct __fn {
-
   template <class _Iter, class _Sent, class _Proj, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  bool __any_of_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static bool __any_of_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
     for (; __first != __last; ++__first) {
       if (std::invoke(__pred, std::invoke(__proj, *__first)))
         return true;
@@ -40,24 +41,27 @@ struct __fn {
     return false;
   }
 
-  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+  template <input_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Iter __first, _Sent __last, _Pred __pred = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Iter __first, _Sent __last, _Pred __pred = {}, _Proj __proj = {}) const {
     return __any_of_impl(std::move(__first), std::move(__last), __pred, __proj);
   }
 
-  template <input_range _Range, class _Proj = identity,
+  template <input_range _Range,
+            class _Proj = identity,
             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
     return __any_of_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
   }
 };
 } // namespace __any_of
 
 inline namespace __cpo {
-  inline constexpr auto any_of = __any_of::__fn{};
+inline constexpr auto any_of = __any_of::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -65,4 +69,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_ANY_OF_H
diff --git a/third_party/libcxx/__algorithm/ranges_binary_search.h b/third_party/libcxx/__algorithm/ranges_binary_search.h
index d89597e1b..1ef2bd62b 100644
--- a/third_party/libcxx/__algorithm/ranges_binary_search.h
+++ b/third_party/libcxx/__algorithm/ranges_binary_search.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -31,28 +34,33 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __binary_search {
 struct __fn {
-  template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity,
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Type,
+            class _Proj                                                             = identity,
             indirect_strict_weak_order<const _Type*, projected<_Iter, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Iter __first, _Sent __last, const _Type& __value, _Comp __comp = {}, _Proj __proj = {}) const {
-    auto __ret = std::__lower_bound_impl<_RangeAlgPolicy>(__first, __last, __value, __comp, __proj);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Iter __first, _Sent __last, const _Type& __value, _Comp __comp = {}, _Proj __proj = {}) const {
+    auto __ret = std::__lower_bound<_RangeAlgPolicy>(__first, __last, __value, __comp, __proj);
     return __ret != __last && !std::invoke(__comp, __value, std::invoke(__proj, *__ret));
   }
 
-  template <forward_range _Range, class _Type, class _Proj = identity,
+  template <forward_range _Range,
+            class _Type,
+            class _Proj                                                                          = identity,
             indirect_strict_weak_order<const _Type*, projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Range&& __r, const _Type& __value, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Range&& __r, const _Type& __value, _Comp __comp = {}, _Proj __proj = {}) const {
     auto __first = ranges::begin(__r);
-    auto __last = ranges::end(__r);
-    auto __ret = std::__lower_bound_impl<_RangeAlgPolicy>(__first, __last, __value, __comp, __proj);
+    auto __last  = ranges::end(__r);
+    auto __ret   = std::__lower_bound<_RangeAlgPolicy>(__first, __last, __value, __comp, __proj);
     return __ret != __last && !std::invoke(__comp, __value, std::invoke(__proj, *__ret));
   }
 };
 } // namespace __binary_search
 
 inline namespace __cpo {
-  inline constexpr auto binary_search = __binary_search::__fn{};
+inline constexpr auto binary_search = __binary_search::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -60,4 +68,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_BINARY_SEARCH_H
diff --git a/third_party/libcxx/__algorithm/ranges_clamp.h b/third_party/libcxx/__algorithm/ranges_clamp.h
index 45a8464c9..e6181ef94 100644
--- a/third_party/libcxx/__algorithm/ranges_clamp.h
+++ b/third_party/libcxx/__algorithm/ranges_clamp.h
@@ -22,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -29,32 +32,28 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __clamp {
 struct __fn {
-
   template <class _Type,
-            class _Proj = identity,
+            class _Proj                                                      = identity,
             indirect_strict_weak_order<projected<const _Type*, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  const _Type& operator()(const _Type& __value,
-                          const _Type& __low,
-                          const _Type& __high,
-                          _Comp __comp = {},
-                          _Proj __proj = {}) const {
-    _LIBCPP_ASSERT(!bool(std::invoke(__comp, std::invoke(__proj, __high), std::invoke(__proj, __low))),
-                   "Bad bounds passed to std::ranges::clamp");
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Type& operator()(
+      const _Type& __value, const _Type& __low, const _Type& __high, _Comp __comp = {}, _Proj __proj = {}) const {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        !bool(std::invoke(__comp, std::invoke(__proj, __high), std::invoke(__proj, __low))),
+        "Bad bounds passed to std::ranges::clamp");
 
-    if (std::invoke(__comp, std::invoke(__proj, __value), std::invoke(__proj, __low)))
+    auto&& __projected = std::invoke(__proj, __value);
+    if (std::invoke(__comp, std::forward<decltype(__projected)>(__projected), std::invoke(__proj, __low)))
       return __low;
-    else if (std::invoke(__comp, std::invoke(__proj, __high), std::invoke(__proj, __value)))
+    else if (std::invoke(__comp, std::invoke(__proj, __high), std::forward<decltype(__projected)>(__projected)))
       return __high;
     else
       return __value;
   }
-
 };
 } // namespace __clamp
 
 inline namespace __cpo {
-  inline constexpr auto clamp = __clamp::__fn{};
+inline constexpr auto clamp = __clamp::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -62,4 +61,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_CLAMP_H
diff --git a/third_party/libcxx/__algorithm/ranges_contains.h b/third_party/libcxx/__algorithm/ranges_contains.h
new file mode 100644
index 000000000..4836c3bae
--- /dev/null
+++ b/third_party/libcxx/__algorithm/ranges_contains.h
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_RANGES_CONTAINS_H
+#define _LIBCPP___ALGORITHM_RANGES_CONTAINS_H
+
+#include <__algorithm/ranges_find.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/ranges_operations.h>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/concepts.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __contains {
+struct __fn {
+  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type*>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool static
+  operator()(_Iter __first, _Sent __last, const _Type& __value, _Proj __proj = {}) {
+    return ranges::find(std::move(__first), __last, __value, std::ref(__proj)) != __last;
+  }
+
+  template <input_range _Range, class _Type, class _Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type*>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool static
+  operator()(_Range&& __range, const _Type& __value, _Proj __proj = {}) {
+    return ranges::find(ranges::begin(__range), ranges::end(__range), __value, std::ref(__proj)) !=
+           ranges::end(__range);
+  }
+};
+} // namespace __contains
+
+inline namespace __cpo {
+inline constexpr auto contains = __contains::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_RANGES_CONTAINS_H
diff --git a/third_party/libcxx/__algorithm/ranges_contains_subrange.h b/third_party/libcxx/__algorithm/ranges_contains_subrange.h
new file mode 100644
index 000000000..4398c457f
--- /dev/null
+++ b/third_party/libcxx/__algorithm/ranges_contains_subrange.h
@@ -0,0 +1,97 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_RANGES_CONTAINS_SUBRANGE_H
+#define _LIBCPP___ALGORITHM_RANGES_CONTAINS_SUBRANGE_H
+
+#include <__algorithm/ranges_search.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/ranges_operations.h>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/concepts.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/size.h>
+#include <__ranges/subrange.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __contains_subrange {
+struct __fn {
+  template <forward_iterator _Iter1,
+            sentinel_for<_Iter1> _Sent1,
+            forward_iterator _Iter2,
+            sentinel_for<_Iter2> _Sent2,
+            class _Pred  = ranges::equal_to,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool static operator()(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred __pred   = {},
+      _Proj1 __proj1 = {},
+      _Proj2 __proj2 = {}) {
+    if (__first2 == __last2)
+      return true;
+
+    auto __ret = ranges::search(
+        std::move(__first1), __last1, std::move(__first2), __last2, __pred, std::ref(__proj1), std::ref(__proj2));
+    return __ret.empty() == false;
+  }
+
+  template <forward_range _Range1,
+            forward_range _Range2,
+            class _Pred  = ranges::equal_to,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>, _Pred, _Proj1, _Proj2>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool static
+  operator()(_Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) {
+    if constexpr (sized_range<_Range2>) {
+      if (ranges::size(__range2) == 0)
+        return true;
+    } else {
+      if (ranges::begin(__range2) == ranges::end(__range2))
+        return true;
+    }
+
+    auto __ret = ranges::search(__range1, __range2, __pred, std::ref(__proj1), std::ref(__proj2));
+    return __ret.empty() == false;
+  }
+};
+} // namespace __contains_subrange
+
+inline namespace __cpo {
+inline constexpr auto contains_subrange = __contains_subrange::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_RANGES_CONTAINS_SUBRANGE_H
diff --git a/third_party/libcxx/__algorithm/ranges_copy.h b/third_party/libcxx/__algorithm/ranges_copy.h
index f5700c3d3..e1d6d32f0 100644
--- a/third_party/libcxx/__algorithm/ranges_copy.h
+++ b/third_party/libcxx/__algorithm/ranges_copy.h
@@ -25,6 +25,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -36,19 +39,18 @@ using copy_result = in_out_result<_InIter, _OutIter>;
 
 namespace __copy {
 struct __fn {
-
   template <input_iterator _InIter, sentinel_for<_InIter> _Sent, weakly_incrementable _OutIter>
     requires indirectly_copyable<_InIter, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  copy_result<_InIter, _OutIter> operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr copy_result<_InIter, _OutIter>
+  operator()(_InIter __first, _Sent __last, _OutIter __result) const {
     auto __ret = std::__copy<_RangeAlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
     return {std::move(__ret.first), std::move(__ret.second)};
   }
 
   template <input_range _Range, weakly_incrementable _OutIter>
     requires indirectly_copyable<iterator_t<_Range>, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  copy_result<borrowed_iterator_t<_Range>, _OutIter> operator()(_Range&& __r, _OutIter __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr copy_result<borrowed_iterator_t<_Range>, _OutIter>
+  operator()(_Range&& __r, _OutIter __result) const {
     auto __ret = std::__copy<_RangeAlgPolicy>(ranges::begin(__r), ranges::end(__r), std::move(__result));
     return {std::move(__ret.first), std::move(__ret.second)};
   }
@@ -56,7 +58,7 @@ struct __fn {
 } // namespace __copy
 
 inline namespace __cpo {
-  inline constexpr auto copy = __copy::__fn{};
+inline constexpr auto copy = __copy::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -64,4 +66,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_COPY_H
diff --git a/third_party/libcxx/__algorithm/ranges_copy_backward.h b/third_party/libcxx/__algorithm/ranges_copy_backward.h
index b7b5b8879..93e326042 100644
--- a/third_party/libcxx/__algorithm/ranges_copy_backward.h
+++ b/third_party/libcxx/__algorithm/ranges_copy_backward.h
@@ -23,30 +23,32 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-template<class _Ip, class _Op>
+template <class _Ip, class _Op>
 using copy_backward_result = in_out_result<_Ip, _Op>;
 
 namespace __copy_backward {
 struct __fn {
-
   template <bidirectional_iterator _InIter1, sentinel_for<_InIter1> _Sent1, bidirectional_iterator _InIter2>
     requires indirectly_copyable<_InIter1, _InIter2>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  copy_backward_result<_InIter1, _InIter2> operator()(_InIter1 __first, _Sent1 __last, _InIter2 __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr copy_backward_result<_InIter1, _InIter2>
+  operator()(_InIter1 __first, _Sent1 __last, _InIter2 __result) const {
     auto __ret = std::__copy_backward<_RangeAlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
     return {std::move(__ret.first), std::move(__ret.second)};
   }
 
   template <bidirectional_range _Range, bidirectional_iterator _Iter>
     requires indirectly_copyable<iterator_t<_Range>, _Iter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  copy_backward_result<borrowed_iterator_t<_Range>, _Iter> operator()(_Range&& __r, _Iter __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr copy_backward_result<borrowed_iterator_t<_Range>, _Iter>
+  operator()(_Range&& __r, _Iter __result) const {
     auto __ret = std::__copy_backward<_RangeAlgPolicy>(ranges::begin(__r), ranges::end(__r), std::move(__result));
     return {std::move(__ret.first), std::move(__ret.second)};
   }
@@ -54,7 +56,7 @@ struct __fn {
 } // namespace __copy_backward
 
 inline namespace __cpo {
-  inline constexpr auto copy_backward = __copy_backward::__fn{};
+inline constexpr auto copy_backward = __copy_backward::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -62,4 +64,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_COPY_BACKWARD_H
diff --git a/third_party/libcxx/__algorithm/ranges_copy_if.h b/third_party/libcxx/__algorithm/ranges_copy_if.h
index b714e4cd1..4b41d2154 100644
--- a/third_party/libcxx/__algorithm/ranges_copy_if.h
+++ b/third_party/libcxx/__algorithm/ranges_copy_if.h
@@ -24,21 +24,22 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-template<class _Ip, class _Op>
+template <class _Ip, class _Op>
 using copy_if_result = in_out_result<_Ip, _Op>;
 
 namespace __copy_if {
 struct __fn {
-
   template <class _InIter, class _Sent, class _OutIter, class _Proj, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI static constexpr
-  copy_if_result <_InIter, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI static constexpr copy_if_result<_InIter, _OutIter>
   __copy_if_impl(_InIter __first, _Sent __last, _OutIter __result, _Pred& __pred, _Proj& __proj) {
     for (; __first != __last; ++__first) {
       if (std::invoke(__pred, std::invoke(__proj, *__first))) {
@@ -49,20 +50,23 @@ struct __fn {
     return {std::move(__first), std::move(__result)};
   }
 
-  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, weakly_incrementable _OutIter, class _Proj = identity,
+  template <input_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            weakly_incrementable _OutIter,
+            class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
     requires indirectly_copyable<_Iter, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  copy_if_result<_Iter, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr copy_if_result<_Iter, _OutIter>
   operator()(_Iter __first, _Sent __last, _OutIter __result, _Pred __pred, _Proj __proj = {}) const {
     return __copy_if_impl(std::move(__first), std::move(__last), std::move(__result), __pred, __proj);
   }
 
-  template <input_range _Range, weakly_incrementable _OutIter, class _Proj = identity,
+  template <input_range _Range,
+            weakly_incrementable _OutIter,
+            class _Proj = identity,
             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
     requires indirectly_copyable<iterator_t<_Range>, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  copy_if_result<borrowed_iterator_t<_Range>, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr copy_if_result<borrowed_iterator_t<_Range>, _OutIter>
   operator()(_Range&& __r, _OutIter __result, _Pred __pred, _Proj __proj = {}) const {
     return __copy_if_impl(ranges::begin(__r), ranges::end(__r), std::move(__result), __pred, __proj);
   }
@@ -70,7 +74,7 @@ struct __fn {
 } // namespace __copy_if
 
 inline namespace __cpo {
-  inline constexpr auto copy_if = __copy_if::__fn{};
+inline constexpr auto copy_if = __copy_if::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -78,4 +82,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_COPY_IF_H
diff --git a/third_party/libcxx/__algorithm/ranges_copy_n.h b/third_party/libcxx/__algorithm/ranges_copy_n.h
index 30ee019ac..4353fa992 100644
--- a/third_party/libcxx/__algorithm/ranges_copy_n.h
+++ b/third_party/libcxx/__algorithm/ranges_copy_n.h
@@ -25,6 +25,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -36,10 +39,9 @@ using copy_n_result = in_out_result<_Ip, _Op>;
 
 namespace __copy_n {
 struct __fn {
-
   template <class _InIter, class _DiffType, class _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  copy_n_result<_InIter, _OutIter> __go(_InIter __first, _DiffType __n, _OutIter __result) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static copy_n_result<_InIter, _OutIter>
+  __go(_InIter __first, _DiffType __n, _OutIter __result) {
     while (__n != 0) {
       *__result = *__first;
       ++__first;
@@ -50,23 +52,23 @@ struct __fn {
   }
 
   template <random_access_iterator _InIter, class _DiffType, random_access_iterator _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  copy_n_result<_InIter, _OutIter> __go(_InIter __first, _DiffType __n, _OutIter __result) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static copy_n_result<_InIter, _OutIter>
+  __go(_InIter __first, _DiffType __n, _OutIter __result) {
     auto __ret = std::__copy<_RangeAlgPolicy>(__first, __first + __n, __result);
     return {__ret.first, __ret.second};
   }
 
   template <input_iterator _Ip, weakly_incrementable _Op>
     requires indirectly_copyable<_Ip, _Op>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  copy_n_result<_Ip, _Op> operator()(_Ip __first, iter_difference_t<_Ip> __n, _Op __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr copy_n_result<_Ip, _Op>
+  operator()(_Ip __first, iter_difference_t<_Ip> __n, _Op __result) const {
     return __go(std::move(__first), __n, std::move(__result));
   }
 };
 } // namespace __copy_n
 
 inline namespace __cpo {
-  inline constexpr auto copy_n = __copy_n::__fn{};
+inline constexpr auto copy_n = __copy_n::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -74,4 +76,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_COPY_N_H
diff --git a/third_party/libcxx/__algorithm/ranges_count.h b/third_party/libcxx/__algorithm/ranges_count.h
index 677ee3818..4f3511743 100644
--- a/third_party/libcxx/__algorithm/ranges_count.h
+++ b/third_party/libcxx/__algorithm/ranges_count.h
@@ -9,7 +9,8 @@
 #ifndef _LIBCPP___ALGORITHM_RANGES_COUNT_H
 #define _LIBCPP___ALGORITHM_RANGES_COUNT_H
 
-#include <__algorithm/ranges_count_if.h>
+#include <__algorithm/count.h>
+#include <__algorithm/iterator_operations.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/ranges_operations.h>
@@ -25,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -34,24 +38,22 @@ namespace __count {
 struct __fn {
   template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity>
     requires indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type*>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  iter_difference_t<_Iter> operator()(_Iter __first, _Sent __last, const _Type& __value, _Proj __proj = {}) const {
-    auto __pred = [&](auto&& __e) { return __e == __value; };
-    return ranges::__count_if_impl(std::move(__first), std::move(__last), __pred, __proj);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Iter>
+  operator()(_Iter __first, _Sent __last, const _Type& __value, _Proj __proj = {}) const {
+    return std::__count<_RangeAlgPolicy>(std::move(__first), std::move(__last), __value, __proj);
   }
 
   template <input_range _Range, class _Type, class _Proj = identity>
     requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type*>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  range_difference_t<_Range> operator()(_Range&& __r, const _Type& __value, _Proj __proj = {}) const {
-    auto __pred = [&](auto&& __e) { return __e == __value; };
-    return ranges::__count_if_impl(ranges::begin(__r), ranges::end(__r), __pred, __proj);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr range_difference_t<_Range>
+  operator()(_Range&& __r, const _Type& __value, _Proj __proj = {}) const {
+    return std::__count<_RangeAlgPolicy>(ranges::begin(__r), ranges::end(__r), __value, __proj);
   }
 };
 } // namespace __count
 
 inline namespace __cpo {
-  inline constexpr auto count = __count::__fn{};
+inline constexpr auto count = __count::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -59,4 +61,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_COUNT_H
diff --git a/third_party/libcxx/__algorithm/ranges_count_if.h b/third_party/libcxx/__algorithm/ranges_count_if.h
index 48c4370eb..5f2396ff7 100644
--- a/third_party/libcxx/__algorithm/ranges_count_if.h
+++ b/third_party/libcxx/__algorithm/ranges_count_if.h
@@ -25,15 +25,17 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 template <class _Iter, class _Sent, class _Proj, class _Pred>
-_LIBCPP_HIDE_FROM_ABI constexpr
-iter_difference_t<_Iter> __count_if_impl(_Iter __first, _Sent __last,
-                                             _Pred& __pred, _Proj& __proj) {
+_LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Iter>
+__count_if_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
   iter_difference_t<_Iter> __counter(0);
   for (; __first != __last; ++__first) {
     if (std::invoke(__pred, std::invoke(__proj, *__first)))
@@ -44,24 +46,27 @@ iter_difference_t<_Iter> __count_if_impl(_Iter __first, _Sent __last,
 
 namespace __count_if {
 struct __fn {
-  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+  template <input_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Predicate>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  iter_difference_t<_Iter> operator()(_Iter __first, _Sent __last, _Predicate __pred, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Iter>
+  operator()(_Iter __first, _Sent __last, _Predicate __pred, _Proj __proj = {}) const {
     return ranges::__count_if_impl(std::move(__first), std::move(__last), __pred, __proj);
   }
 
-  template <input_range _Range, class _Proj = identity,
+  template <input_range _Range,
+            class _Proj = identity,
             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Predicate>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  range_difference_t<_Range> operator()(_Range&& __r, _Predicate __pred, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr range_difference_t<_Range>
+  operator()(_Range&& __r, _Predicate __pred, _Proj __proj = {}) const {
     return ranges::__count_if_impl(ranges::begin(__r), ranges::end(__r), __pred, __proj);
   }
 };
 } // namespace __count_if
 
 inline namespace __cpo {
-  inline constexpr auto count_if = __count_if::__fn{};
+inline constexpr auto count_if = __count_if::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -69,4 +74,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_COUNT_IF_H
diff --git a/third_party/libcxx/__algorithm/ranges_ends_with.h b/third_party/libcxx/__algorithm/ranges_ends_with.h
new file mode 100644
index 000000000..06efdef36
--- /dev/null
+++ b/third_party/libcxx/__algorithm/ranges_ends_with.h
@@ -0,0 +1,201 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_RANGES_ENDS_WITH_H
+#define _LIBCPP___ALGORITHM_RANGES_ENDS_WITH_H
+
+#include <__algorithm/ranges_equal.h>
+#include <__algorithm/ranges_starts_with.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/ranges_operations.h>
+#include <__functional/reference_wrapper.h>
+#include <__iterator/advance.h>
+#include <__iterator/concepts.h>
+#include <__iterator/distance.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__iterator/reverse_iterator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+namespace __ends_with {
+struct __fn {
+  template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool __ends_with_fn_impl_bidirectional(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred& __pred,
+      _Proj1& __proj1,
+      _Proj2& __proj2) {
+    auto __rbegin1 = std::make_reverse_iterator(__last1);
+    auto __rend1   = std::make_reverse_iterator(__first1);
+    auto __rbegin2 = std::make_reverse_iterator(__last2);
+    auto __rend2   = std::make_reverse_iterator(__first2);
+    return ranges::starts_with(
+        __rbegin1, __rend1, __rbegin2, __rend2, std::ref(__pred), std::ref(__proj1), std::ref(__proj2));
+  }
+
+  template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool __ends_with_fn_impl(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred& __pred,
+      _Proj1& __proj1,
+      _Proj2& __proj2) {
+    if constexpr (std::bidirectional_iterator<_Sent1> && std::bidirectional_iterator<_Sent2> &&
+                  (!std::random_access_iterator<_Sent1>) && (!std::random_access_iterator<_Sent2>)) {
+      return __ends_with_fn_impl_bidirectional(__first1, __last1, __first2, __last2, __pred, __proj1, __proj2);
+
+    } else {
+      auto __n1 = ranges::distance(__first1, __last1);
+      auto __n2 = ranges::distance(__first2, __last2);
+      if (__n2 == 0)
+        return true;
+      if (__n2 > __n1)
+        return false;
+
+      return __ends_with_fn_impl_with_offset(
+          std::move(__first1),
+          std::move(__last1),
+          std::move(__first2),
+          std::move(__last2),
+          __pred,
+          __proj1,
+          __proj2,
+          __n1 - __n2);
+    }
+  }
+
+  template <class _Iter1,
+            class _Sent1,
+            class _Iter2,
+            class _Sent2,
+            class _Pred,
+            class _Proj1,
+            class _Proj2,
+            class _Offset>
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __ends_with_fn_impl_with_offset(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred& __pred,
+      _Proj1& __proj1,
+      _Proj2& __proj2,
+      _Offset __offset) {
+    if constexpr (std::bidirectional_iterator<_Sent1> && std::bidirectional_iterator<_Sent2> &&
+                  !std::random_access_iterator<_Sent1> && !std::random_access_iterator<_Sent2>) {
+      return __ends_with_fn_impl_bidirectional(
+          std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __pred, __proj1, __proj2);
+
+    } else {
+      ranges::advance(__first1, __offset);
+      return ranges::equal(
+          std::move(__first1),
+          std::move(__last1),
+          std::move(__first2),
+          std::move(__last2),
+          std::ref(__pred),
+          std::ref(__proj1),
+          std::ref(__proj2));
+    }
+  }
+
+  template <input_iterator _Iter1,
+            sentinel_for<_Iter1> _Sent1,
+            input_iterator _Iter2,
+            sentinel_for<_Iter2> _Sent2,
+            class _Pred  = ranges::equal_to,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires(forward_iterator<_Iter1> || sized_sentinel_for<_Sent1, _Iter1>) &&
+            (forward_iterator<_Iter2> || sized_sentinel_for<_Sent2, _Iter2>) &&
+            indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred __pred   = {},
+      _Proj1 __proj1 = {},
+      _Proj2 __proj2 = {}) const {
+    return __ends_with_fn_impl(
+        std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __pred, __proj1, __proj2);
+  }
+
+  template <input_range _Range1,
+            input_range _Range2,
+            class _Pred  = ranges::equal_to,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires(forward_range<_Range1> || sized_range<_Range1>) && (forward_range<_Range2> || sized_range<_Range2>) &&
+            indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>, _Pred, _Proj1, _Proj2>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+      _Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+    if constexpr (sized_range<_Range1> && sized_range<_Range2>) {
+      auto __n1 = ranges::size(__range1);
+      auto __n2 = ranges::size(__range2);
+      if (__n2 == 0)
+        return true;
+      if (__n2 > __n1)
+        return false;
+      auto __offset = __n1 - __n2;
+
+      return __ends_with_fn_impl_with_offset(
+          ranges::begin(__range1),
+          ranges::end(__range1),
+          ranges::begin(__range2),
+          ranges::end(__range2),
+          __pred,
+          __proj1,
+          __proj2,
+          __offset);
+
+    } else {
+      return __ends_with_fn_impl(
+          ranges::begin(__range1),
+          ranges::end(__range1),
+          ranges::begin(__range2),
+          ranges::end(__range2),
+          __pred,
+          __proj1,
+          __proj2);
+    }
+  }
+};
+} // namespace __ends_with
+
+inline namespace __cpo {
+inline constexpr auto ends_with = __ends_with::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_RANGES_ENDS_WITH_H
diff --git a/third_party/libcxx/__algorithm/ranges_equal.h b/third_party/libcxx/__algorithm/ranges_equal.h
index 87544531c..edbd0e364 100644
--- a/third_party/libcxx/__algorithm/ranges_equal.h
+++ b/third_party/libcxx/__algorithm/ranges_equal.h
@@ -26,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -33,61 +36,67 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __equal {
 struct __fn {
-  template <input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
-            input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
-            class _Pred = ranges::equal_to,
+  template <input_iterator _Iter1,
+            sentinel_for<_Iter1> _Sent1,
+            input_iterator _Iter2,
+            sentinel_for<_Iter2> _Sent2,
+            class _Pred  = ranges::equal_to,
             class _Proj1 = identity,
             class _Proj2 = identity>
     requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Iter1 __first1, _Sent1 __last1,
-                  _Iter2 __first2, _Sent2 __last2,
-                  _Pred __pred = {},
-                  _Proj1 __proj1 = {},
-                  _Proj2 __proj2 = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred __pred   = {},
+      _Proj1 __proj1 = {},
+      _Proj2 __proj2 = {}) const {
     if constexpr (sized_sentinel_for<_Sent1, _Iter1> && sized_sentinel_for<_Sent2, _Iter2>) {
       if (__last1 - __first1 != __last2 - __first2)
         return false;
     }
     auto __unwrapped1 = std::__unwrap_range(std::move(__first1), std::move(__last1));
     auto __unwrapped2 = std::__unwrap_range(std::move(__first2), std::move(__last2));
-    return std::__equal_impl(std::move(__unwrapped1.first), std::move(__unwrapped1.second),
-                             std::move(__unwrapped2.first), std::move(__unwrapped2.second),
-                             __pred,
-                             __proj1,
-                             __proj2);
+    return std::__equal_impl(
+        std::move(__unwrapped1.first),
+        std::move(__unwrapped1.second),
+        std::move(__unwrapped2.first),
+        std::move(__unwrapped2.second),
+        __pred,
+        __proj1,
+        __proj2);
   }
 
   template <input_range _Range1,
             input_range _Range2,
-            class _Pred = ranges::equal_to,
+            class _Pred  = ranges::equal_to,
             class _Proj1 = identity,
             class _Proj2 = identity>
     requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Range1&& __range1,
-                  _Range2&& __range2,
-                  _Pred __pred = {},
-                  _Proj1 __proj1 = {},
-                  _Proj2 __proj2 = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+      _Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
     if constexpr (sized_range<_Range1> && sized_range<_Range2>) {
       if (ranges::distance(__range1) != ranges::distance(__range2))
         return false;
     }
     auto __unwrapped1 = std::__unwrap_range(ranges::begin(__range1), ranges::end(__range1));
     auto __unwrapped2 = std::__unwrap_range(ranges::begin(__range2), ranges::end(__range2));
-    return std::__equal_impl(std::move(__unwrapped1.first), std::move(__unwrapped1.second),
-                             std::move(__unwrapped2.first), std::move(__unwrapped2.second),
-                             __pred,
-                             __proj1,
-                             __proj2);
+    return std::__equal_impl(
+        std::move(__unwrapped1.first),
+        std::move(__unwrapped1.second),
+        std::move(__unwrapped2.first),
+        std::move(__unwrapped2.second),
+        __pred,
+        __proj1,
+        __proj2);
     return false;
   }
 };
 } // namespace __equal
 
 inline namespace __cpo {
-  inline constexpr auto equal = __equal::__fn{};
+inline constexpr auto equal = __equal::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -95,4 +104,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_EQUAL_H
diff --git a/third_party/libcxx/__algorithm/ranges_equal_range.h b/third_party/libcxx/__algorithm/ranges_equal_range.h
index 075634ae9..4a308e016 100644
--- a/third_party/libcxx/__algorithm/ranges_equal_range.h
+++ b/third_party/libcxx/__algorithm/ranges_equal_range.h
@@ -1,6 +1,6 @@
 //===----------------------------------------------------------------------===//
 //
-// Part of the LLVM __project, under the Apache License v2.0 with LLVM Exceptions.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
@@ -30,6 +30,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -38,28 +41,25 @@ namespace ranges {
 namespace __equal_range {
 
 struct __fn {
-  template <
-      forward_iterator _Iter,
-      sentinel_for<_Iter> _Sent,
-      class _Tp,
-      class _Proj                                                           = identity,
-      indirect_strict_weak_order<const _Tp*, projected<_Iter, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Tp,
+            class _Proj                                                           = identity,
+            indirect_strict_weak_order<const _Tp*, projected<_Iter, _Proj>> _Comp = ranges::less>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
   operator()(_Iter __first, _Sent __last, const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const {
-    auto __ret = std::__equal_range<_RangeAlgPolicy>(
-        std::move(__first), std::move(__last), __value, __comp, __proj);
+    auto __ret = std::__equal_range<_RangeAlgPolicy>(std::move(__first), std::move(__last), __value, __comp, __proj);
     return {std::move(__ret.first), std::move(__ret.second)};
   }
 
-  template <
-      forward_range _Range,
-      class _Tp,
-      class _Proj                                                                        = identity,
-      indirect_strict_weak_order<const _Tp*, projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
+  template <forward_range _Range,
+            class _Tp,
+            class _Proj                                                                        = identity,
+            indirect_strict_weak_order<const _Tp*, projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
   operator()(_Range&& __range, const _Tp& __value, _Comp __comp = {}, _Proj __proj = {}) const {
-    auto __ret = std::__equal_range<_RangeAlgPolicy>(
-        ranges::begin(__range), ranges::end(__range), __value, __comp, __proj);
+    auto __ret =
+        std::__equal_range<_RangeAlgPolicy>(ranges::begin(__range), ranges::end(__range), __value, __comp, __proj);
     return {std::move(__ret.first), std::move(__ret.second)};
   }
 };
@@ -67,7 +67,7 @@ struct __fn {
 } // namespace __equal_range
 
 inline namespace __cpo {
-  inline constexpr auto equal_range = __equal_range::__fn{};
+inline constexpr auto equal_range = __equal_range::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -75,4 +75,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_EQUAL_RANGE_H
diff --git a/third_party/libcxx/__algorithm/ranges_fill.h b/third_party/libcxx/__algorithm/ranges_fill.h
index 4e0594c6d..7a177d85e 100644
--- a/third_party/libcxx/__algorithm/ranges_fill.h
+++ b/third_party/libcxx/__algorithm/ranges_fill.h
@@ -20,6 +20,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -28,9 +31,8 @@ namespace ranges {
 namespace __fill {
 struct __fn {
   template <class _Type, output_iterator<const _Type&> _Iter, sentinel_for<_Iter> _Sent>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, const _Type& __value) const {
-    if constexpr(random_access_iterator<_Iter> && sized_sentinel_for<_Sent, _Iter>) {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter operator()(_Iter __first, _Sent __last, const _Type& __value) const {
+    if constexpr (random_access_iterator<_Iter> && sized_sentinel_for<_Sent, _Iter>) {
       return ranges::fill_n(__first, __last - __first, __value);
     } else {
       for (; __first != __last; ++__first)
@@ -40,15 +42,14 @@ struct __fn {
   }
 
   template <class _Type, output_range<const _Type&> _Range>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __range, const _Type& __value) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range> operator()(_Range&& __range, const _Type& __value) const {
     return (*this)(ranges::begin(__range), ranges::end(__range), __value);
   }
 };
 } // namespace __fill
 
 inline namespace __cpo {
-  inline constexpr auto fill = __fill::__fn{};
+inline constexpr auto fill = __fill::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -56,4 +57,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_FILL_H
diff --git a/third_party/libcxx/__algorithm/ranges_fill_n.h b/third_party/libcxx/__algorithm/ranges_fill_n.h
index c5f7e6ead..a6e988c00 100644
--- a/third_party/libcxx/__algorithm/ranges_fill_n.h
+++ b/third_party/libcxx/__algorithm/ranges_fill_n.h
@@ -17,6 +17,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -25,8 +28,8 @@ namespace ranges {
 namespace __fill_n {
 struct __fn {
   template <class _Type, output_iterator<const _Type&> _Iter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, iter_difference_t<_Iter> __n, const _Type& __value) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, iter_difference_t<_Iter> __n, const _Type& __value) const {
     for (; __n != 0; --__n) {
       *__first = __value;
       ++__first;
@@ -37,7 +40,7 @@ struct __fn {
 } // namespace __fill_n
 
 inline namespace __cpo {
-  inline constexpr auto fill_n = __fill_n::__fn{};
+inline constexpr auto fill_n = __fill_n::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -45,4 +48,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_FILL_N_H
diff --git a/third_party/libcxx/__algorithm/ranges_find.h b/third_party/libcxx/__algorithm/ranges_find.h
index 084cdfff0..6b0d5efe3 100644
--- a/third_party/libcxx/__algorithm/ranges_find.h
+++ b/third_party/libcxx/__algorithm/ranges_find.h
@@ -28,6 +28,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -41,30 +44,30 @@ struct __fn {
     if constexpr (forward_iterator<_Iter>) {
       auto [__first_un, __last_un] = std::__unwrap_range(__first, std::move(__last));
       return std::__rewrap_range<_Sent>(
-          std::move(__first), std::__find_impl(std::move(__first_un), std::move(__last_un), __value, __proj));
+          std::move(__first), std::__find(std::move(__first_un), std::move(__last_un), __value, __proj));
     } else {
-      return std::__find_impl(std::move(__first), std::move(__last), __value, __proj);
+      return std::__find(std::move(__first), std::move(__last), __value, __proj);
     }
   }
 
   template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Tp, class _Proj = identity>
     requires indirect_binary_predicate<ranges::equal_to, projected<_Ip, _Proj>, const _Tp*>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Ip operator()(_Ip __first, _Sp __last, const _Tp& __value, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Ip
+  operator()(_Ip __first, _Sp __last, const _Tp& __value, _Proj __proj = {}) const {
     return __find_unwrap(std::move(__first), std::move(__last), __value, __proj);
   }
 
   template <input_range _Rp, class _Tp, class _Proj = identity>
     requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Rp>, _Proj>, const _Tp*>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Rp> operator()(_Rp&& __r, const _Tp& __value, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Rp>
+  operator()(_Rp&& __r, const _Tp& __value, _Proj __proj = {}) const {
     return __find_unwrap(ranges::begin(__r), ranges::end(__r), __value, __proj);
   }
 };
 } // namespace __find
 
 inline namespace __cpo {
-  inline constexpr auto find = __find::__fn{};
+inline constexpr auto find = __find::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -72,4 +75,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_FIND_H
diff --git a/third_party/libcxx/__algorithm/ranges_find_end.h b/third_party/libcxx/__algorithm/ranges_find_end.h
index 2d46e8c38..e49e66dd4 100644
--- a/third_party/libcxx/__algorithm/ranges_find_end.h
+++ b/third_party/libcxx/__algorithm/ranges_find_end.h
@@ -27,6 +27,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -34,18 +37,22 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __find_end {
 struct __fn {
-  template <forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
-            forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
-            class _Pred = ranges::equal_to,
+  template <forward_iterator _Iter1,
+            sentinel_for<_Iter1> _Sent1,
+            forward_iterator _Iter2,
+            sentinel_for<_Iter2> _Sent2,
+            class _Pred  = ranges::equal_to,
             class _Proj1 = identity,
             class _Proj2 = identity>
     requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  subrange<_Iter1> operator()(_Iter1 __first1, _Sent1 __last1,
-                              _Iter2 __first2, _Sent2 __last2,
-                              _Pred __pred = {},
-                              _Proj1 __proj1 = {},
-                              _Proj2 __proj2 = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter1> operator()(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred __pred   = {},
+      _Proj1 __proj1 = {},
+      _Proj2 __proj2 = {}) const {
     auto __ret = std::__find_end_impl<_RangeAlgPolicy>(
         __first1,
         __last1,
@@ -61,16 +68,12 @@ struct __fn {
 
   template <forward_range _Range1,
             forward_range _Range2,
-            class _Pred = ranges::equal_to,
+            class _Pred  = ranges::equal_to,
             class _Proj1 = identity,
             class _Proj2 = identity>
     requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_subrange_t<_Range1> operator()(_Range1&& __range1,
-                                          _Range2&& __range2,
-                                          _Pred __pred = {},
-                                          _Proj1 __proj1 = {},
-                                          _Proj2 __proj2 = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range1> operator()(
+      _Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
     auto __ret = std::__find_end_impl<_RangeAlgPolicy>(
         ranges::begin(__range1),
         ranges::end(__range1),
@@ -87,7 +90,7 @@ struct __fn {
 } // namespace __find_end
 
 inline namespace __cpo {
-  inline constexpr auto find_end = __find_end::__fn{};
+inline constexpr auto find_end = __find_end::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -95,4 +98,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_FIND_END_H
diff --git a/third_party/libcxx/__algorithm/ranges_find_first_of.h b/third_party/libcxx/__algorithm/ranges_find_first_of.h
index 5699583ba..d92d9686b 100644
--- a/third_party/libcxx/__algorithm/ranges_find_first_of.h
+++ b/third_party/libcxx/__algorithm/ranges_find_first_of.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -31,14 +34,15 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __find_first_of {
 struct __fn {
-
   template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  _Iter1 __find_first_of_impl(_Iter1 __first1, _Sent1 __last1,
-                              _Iter2 __first2, _Sent2 __last2,
-                              _Pred& __pred,
-                              _Proj1& __proj1,
-                              _Proj2& __proj2) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter1 __find_first_of_impl(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred& __pred,
+      _Proj1& __proj1,
+      _Proj2& __proj2) {
     for (; __first1 != __last1; ++__first1) {
       for (auto __j = __first2; __j != __last2; ++__j) {
         if (std::invoke(__pred, std::invoke(__proj1, *__first1), std::invoke(__proj2, *__j)))
@@ -48,49 +52,48 @@ struct __fn {
     return __first1;
   }
 
-  template <input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
-            forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
-            class _Pred = ranges::equal_to,
+  template <input_iterator _Iter1,
+            sentinel_for<_Iter1> _Sent1,
+            forward_iterator _Iter2,
+            sentinel_for<_Iter2> _Sent2,
+            class _Pred  = ranges::equal_to,
             class _Proj1 = identity,
             class _Proj2 = identity>
     requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter1 operator()(_Iter1 __first1, _Sent1 __last1,
-                    _Iter2 __first2, _Sent2 __last2,
-                    _Pred __pred = {},
-                    _Proj1 __proj1 = {},
-                    _Proj2 __proj2 = {}) const {
-    return __find_first_of_impl(std::move(__first1), std::move(__last1),
-                                std::move(__first2), std::move(__last2),
-                                __pred,
-                                __proj1,
-                                __proj2);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter1 operator()(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred __pred   = {},
+      _Proj1 __proj1 = {},
+      _Proj2 __proj2 = {}) const {
+    return __find_first_of_impl(
+        std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __pred, __proj1, __proj2);
   }
 
   template <input_range _Range1,
             forward_range _Range2,
-            class _Pred = ranges::equal_to,
+            class _Pred  = ranges::equal_to,
             class _Proj1 = identity,
             class _Proj2 = identity>
     requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range1> operator()(_Range1&& __range1,
-                                          _Range2&& __range2,
-                                          _Pred __pred = {},
-                                          _Proj1 __proj1 = {},
-                                          _Proj2 __proj2 = {}) const {
-    return __find_first_of_impl(ranges::begin(__range1), ranges::end(__range1),
-                                ranges::begin(__range2), ranges::end(__range2),
-                                __pred,
-                                __proj1,
-                                __proj2);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range1> operator()(
+      _Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+    return __find_first_of_impl(
+        ranges::begin(__range1),
+        ranges::end(__range1),
+        ranges::begin(__range2),
+        ranges::end(__range2),
+        __pred,
+        __proj1,
+        __proj2);
   }
-
 };
 } // namespace __find_first_of
 
 inline namespace __cpo {
-  inline constexpr auto find_first_of = __find_first_of::__fn{};
+inline constexpr auto find_first_of = __find_first_of::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -98,4 +101,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_FIND_FIRST_OF_H
diff --git a/third_party/libcxx/__algorithm/ranges_find_if.h b/third_party/libcxx/__algorithm/ranges_find_if.h
index 6e2bd4c3d..888f9ec3c 100644
--- a/third_party/libcxx/__algorithm/ranges_find_if.h
+++ b/third_party/libcxx/__algorithm/ranges_find_if.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -31,8 +34,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 
 template <class _Ip, class _Sp, class _Pred, class _Proj>
-_LIBCPP_HIDE_FROM_ABI constexpr
-_Ip __find_if_impl(_Ip __first, _Sp __last, _Pred& __pred, _Proj& __proj) {
+_LIBCPP_HIDE_FROM_ABI constexpr _Ip __find_if_impl(_Ip __first, _Sp __last, _Pred& __pred, _Proj& __proj) {
   for (; __first != __last; ++__first) {
     if (std::invoke(__pred, std::invoke(__proj, *__first)))
       break;
@@ -42,25 +44,25 @@ _Ip __find_if_impl(_Ip __first, _Sp __last, _Pred& __pred, _Proj& __proj) {
 
 namespace __find_if {
 struct __fn {
-
-  template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+  template <input_iterator _Ip,
+            sentinel_for<_Ip> _Sp,
+            class _Proj = identity,
             indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Ip operator()(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Ip
+  operator()(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj = {}) const {
     return ranges::__find_if_impl(std::move(__first), std::move(__last), __pred, __proj);
   }
 
-  template <input_range _Rp, class _Proj = identity,
-            indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Rp> operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
+  template <input_range _Rp, class _Proj = identity, indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Rp>
+  operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
     return ranges::__find_if_impl(ranges::begin(__r), ranges::end(__r), __pred, __proj);
   }
 };
 } // namespace __find_if
 
 inline namespace __cpo {
-  inline constexpr auto find_if = __find_if::__fn{};
+inline constexpr auto find_if = __find_if::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -68,4 +70,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_FIND_IF_H
diff --git a/third_party/libcxx/__algorithm/ranges_find_if_not.h b/third_party/libcxx/__algorithm/ranges_find_if_not.h
index e60ee2b49..ec19545b5 100644
--- a/third_party/libcxx/__algorithm/ranges_find_if_not.h
+++ b/third_party/libcxx/__algorithm/ranges_find_if_not.h
@@ -26,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -33,26 +36,27 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __find_if_not {
 struct __fn {
-  template <input_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+  template <input_iterator _Ip,
+            sentinel_for<_Ip> _Sp,
+            class _Proj = identity,
             indirect_unary_predicate<projected<_Ip, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Ip operator()(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj = {}) const {
-    auto __pred2 = [&](auto&& __e) { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Ip
+  operator()(_Ip __first, _Sp __last, _Pred __pred, _Proj __proj = {}) const {
+    auto __pred2 = [&](auto&& __e) -> bool { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
     return ranges::__find_if_impl(std::move(__first), std::move(__last), __pred2, __proj);
   }
 
-  template <input_range _Rp, class _Proj = identity,
-            indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Rp> operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
-    auto __pred2 = [&](auto&& __e) { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
+  template <input_range _Rp, class _Proj = identity, indirect_unary_predicate<projected<iterator_t<_Rp>, _Proj>> _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Rp>
+  operator()(_Rp&& __r, _Pred __pred, _Proj __proj = {}) const {
+    auto __pred2 = [&](auto&& __e) -> bool { return !std::invoke(__pred, std::forward<decltype(__e)>(__e)); };
     return ranges::__find_if_impl(ranges::begin(__r), ranges::end(__r), __pred2, __proj);
   }
 };
 } // namespace __find_if_not
 
 inline namespace __cpo {
-  inline constexpr auto find_if_not = __find_if_not::__fn{};
+inline constexpr auto find_if_not = __find_if_not::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -60,4 +64,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_FIND_IF_NOT_H
diff --git a/third_party/libcxx/__algorithm/ranges_find_last.h b/third_party/libcxx/__algorithm/ranges_find_last.h
new file mode 100644
index 000000000..95f7e77b8
--- /dev/null
+++ b/third_party/libcxx/__algorithm/ranges_find_last.h
@@ -0,0 +1,175 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_RANGES_FIND_LAST_H
+#define _LIBCPP___ALGORITHM_RANGES_FIND_LAST_H
+
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/invoke.h>
+#include <__functional/ranges_operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/indirectly_comparable.h>
+#include <__iterator/next.h>
+#include <__iterator/prev.h>
+#include <__iterator/projected.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/subrange.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _Iter, class _Sent, class _Pred, class _Proj>
+_LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+__find_last_impl(_Iter __first, _Sent __last, _Pred __pred, _Proj& __proj) {
+  if (__first == __last) {
+    return subrange<_Iter>(__first, __first);
+  }
+
+  if constexpr (bidirectional_iterator<_Iter>) {
+    auto __last_it = ranges::next(__first, __last);
+    for (auto __it = ranges::prev(__last_it); __it != __first; --__it) {
+      if (__pred(std::invoke(__proj, *__it))) {
+        return subrange<_Iter>(std::move(__it), std::move(__last_it));
+      }
+    }
+    if (__pred(std::invoke(__proj, *__first))) {
+      return subrange<_Iter>(std::move(__first), std::move(__last_it));
+    }
+    return subrange<_Iter>(__last_it, __last_it);
+  } else {
+    bool __found = false;
+    _Iter __found_it;
+    for (; __first != __last; ++__first) {
+      if (__pred(std::invoke(__proj, *__first))) {
+        __found    = true;
+        __found_it = __first;
+      }
+    }
+
+    if (__found) {
+      return subrange<_Iter>(std::move(__found_it), std::move(__first));
+    } else {
+      return subrange<_Iter>(__first, __first);
+    }
+  }
+}
+
+namespace __find_last {
+struct __fn {
+  template <class _Type>
+  struct __op {
+    const _Type& __value;
+    template <class _Elem>
+    _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Elem&& __elem) const {
+      return std::forward<_Elem>(__elem) == __value;
+    }
+  };
+
+  template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type*>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr static subrange<_Iter>
+  operator()(_Iter __first, _Sent __last, const _Type& __value, _Proj __proj = {}) {
+    return ranges::__find_last_impl(std::move(__first), std::move(__last), __op<_Type>{__value}, __proj);
+  }
+
+  template <forward_range _Range, class _Type, class _Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type*>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr static borrowed_subrange_t<_Range>
+  operator()(_Range&& __range, const _Type& __value, _Proj __proj = {}) {
+    return ranges::__find_last_impl(ranges::begin(__range), ranges::end(__range), __op<_Type>{__value}, __proj);
+  }
+};
+} // namespace __find_last
+
+namespace __find_last_if {
+struct __fn {
+  template <class _Pred>
+  struct __op {
+    _Pred& __pred;
+    template <class _Elem>
+    _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Elem&& __elem) const {
+      return std::invoke(__pred, std::forward<_Elem>(__elem));
+    }
+  };
+
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr static subrange<_Iter>
+  operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) {
+    return ranges::__find_last_impl(std::move(__first), std::move(__last), __op<_Pred>{__pred}, __proj);
+  }
+
+  template <forward_range _Range,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr static borrowed_subrange_t<_Range>
+  operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) {
+    return ranges::__find_last_impl(ranges::begin(__range), ranges::end(__range), __op<_Pred>{__pred}, __proj);
+  }
+};
+} // namespace __find_last_if
+
+namespace __find_last_if_not {
+struct __fn {
+  template <class _Pred>
+  struct __op {
+    _Pred& __pred;
+    template <class _Elem>
+    _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Elem&& __elem) const {
+      return !std::invoke(__pred, std::forward<_Elem>(__elem));
+    }
+  };
+
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr static subrange<_Iter>
+  operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) {
+    return ranges::__find_last_impl(std::move(__first), std::move(__last), __op<_Pred>{__pred}, __proj);
+  }
+
+  template <forward_range _Range,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr static borrowed_subrange_t<_Range>
+  operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) {
+    return ranges::__find_last_impl(ranges::begin(__range), ranges::end(__range), __op<_Pred>{__pred}, __proj);
+  }
+};
+} // namespace __find_last_if_not
+
+inline namespace __cpo {
+inline constexpr auto find_last        = __find_last::__fn{};
+inline constexpr auto find_last_if     = __find_last_if::__fn{};
+inline constexpr auto find_last_if_not = __find_last_if_not::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_RANGES_FIND_LAST_H
diff --git a/third_party/libcxx/__algorithm/ranges_for_each.h b/third_party/libcxx/__algorithm/ranges_for_each.h
index a72f77963..225dc774c 100644
--- a/third_party/libcxx/__algorithm/ranges_for_each.h
+++ b/third_party/libcxx/__algorithm/ranges_for_each.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -37,37 +40,35 @@ namespace __for_each {
 struct __fn {
 private:
   template <class _Iter, class _Sent, class _Proj, class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  for_each_result<_Iter, _Func> __for_each_impl(_Iter __first, _Sent __last, _Func& __func, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static for_each_result<_Iter, _Func>
+  __for_each_impl(_Iter __first, _Sent __last, _Func& __func, _Proj& __proj) {
     for (; __first != __last; ++__first)
       std::invoke(__func, std::invoke(__proj, *__first));
     return {std::move(__first), std::move(__func)};
   }
 
 public:
-  template <input_iterator _Iter, sentinel_for<_Iter> _Sent,
+  template <input_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
             class _Proj = identity,
             indirectly_unary_invocable<projected<_Iter, _Proj>> _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  for_each_result<_Iter, _Func> operator()(_Iter __first, _Sent __last, _Func __func, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr for_each_result<_Iter, _Func>
+  operator()(_Iter __first, _Sent __last, _Func __func, _Proj __proj = {}) const {
     return __for_each_impl(std::move(__first), std::move(__last), __func, __proj);
   }
 
   template <input_range _Range,
             class _Proj = identity,
             indirectly_unary_invocable<projected<iterator_t<_Range>, _Proj>> _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  for_each_result<borrowed_iterator_t<_Range>, _Func> operator()(_Range&& __range,
-                                                                 _Func __func,
-                                                                 _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr for_each_result<borrowed_iterator_t<_Range>, _Func>
+  operator()(_Range&& __range, _Func __func, _Proj __proj = {}) const {
     return __for_each_impl(ranges::begin(__range), ranges::end(__range), __func, __proj);
   }
-
 };
 } // namespace __for_each
 
 inline namespace __cpo {
-  inline constexpr auto for_each = __for_each::__fn{};
+inline constexpr auto for_each = __for_each::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -75,4 +76,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_FOR_EACH_H
diff --git a/third_party/libcxx/__algorithm/ranges_for_each_n.h b/third_party/libcxx/__algorithm/ranges_for_each_n.h
index daf0a5d82..d1fdca34c 100644
--- a/third_party/libcxx/__algorithm/ranges_for_each_n.h
+++ b/third_party/libcxx/__algorithm/ranges_for_each_n.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -35,27 +38,20 @@ using for_each_n_result = in_fun_result<_Iter, _Func>;
 
 namespace __for_each_n {
 struct __fn {
-
-  template <input_iterator _Iter,
-            class _Proj = identity,
-            indirectly_unary_invocable<projected<_Iter, _Proj>> _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  for_each_n_result<_Iter, _Func> operator()(_Iter __first,
-                                             iter_difference_t<_Iter> __count,
-                                             _Func __func,
-                                             _Proj __proj = {}) const {
+  template <input_iterator _Iter, class _Proj = identity, indirectly_unary_invocable<projected<_Iter, _Proj>> _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr for_each_n_result<_Iter, _Func>
+  operator()(_Iter __first, iter_difference_t<_Iter> __count, _Func __func, _Proj __proj = {}) const {
     while (__count-- > 0) {
       std::invoke(__func, std::invoke(__proj, *__first));
       ++__first;
     }
     return {std::move(__first), std::move(__func)};
   }
-
 };
 } // namespace __for_each_n
 
 inline namespace __cpo {
-  inline constexpr auto for_each_n = __for_each_n::__fn{};
+inline constexpr auto for_each_n = __for_each_n::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -63,4 +59,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_FOR_EACH_N_H
diff --git a/third_party/libcxx/__algorithm/ranges_generate.h b/third_party/libcxx/__algorithm/ranges_generate.h
index de0db1665..e6467198e 100644
--- a/third_party/libcxx/__algorithm/ranges_generate.h
+++ b/third_party/libcxx/__algorithm/ranges_generate.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -32,10 +35,8 @@ namespace ranges {
 namespace __generate {
 
 struct __fn {
-
   template <class _OutIter, class _Sent, class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  static _OutIter __generate_fn_impl(_OutIter __first, _Sent __last, _Func& __gen) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _OutIter __generate_fn_impl(_OutIter __first, _Sent __last, _Func& __gen) {
     for (; __first != __last; ++__first) {
       *__first = __gen();
     }
@@ -44,25 +45,22 @@ struct __fn {
   }
 
   template <input_or_output_iterator _OutIter, sentinel_for<_OutIter> _Sent, copy_constructible _Func>
-  requires invocable<_Func&> && indirectly_writable<_OutIter, invoke_result_t<_Func&>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _OutIter operator()(_OutIter __first, _Sent __last, _Func __gen) const {
+    requires invocable<_Func&> && indirectly_writable<_OutIter, invoke_result_t<_Func&>>
+  _LIBCPP_HIDE_FROM_ABI constexpr _OutIter operator()(_OutIter __first, _Sent __last, _Func __gen) const {
     return __generate_fn_impl(std::move(__first), std::move(__last), __gen);
   }
 
   template <class _Range, copy_constructible _Func>
-  requires invocable<_Func&> && output_range<_Range, invoke_result_t<_Func&>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __range, _Func __gen) const {
+    requires invocable<_Func&> && output_range<_Range, invoke_result_t<_Func&>>
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range> operator()(_Range&& __range, _Func __gen) const {
     return __generate_fn_impl(ranges::begin(__range), ranges::end(__range), __gen);
   }
-
 };
 
 } // namespace __generate
 
 inline namespace __cpo {
-  inline constexpr auto generate = __generate::__fn{};
+inline constexpr auto generate = __generate::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -70,4 +68,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_GENERATE_H
diff --git a/third_party/libcxx/__algorithm/ranges_generate_n.h b/third_party/libcxx/__algorithm/ranges_generate_n.h
index 122cd8db7..cd5fd7483 100644
--- a/third_party/libcxx/__algorithm/ranges_generate_n.h
+++ b/third_party/libcxx/__algorithm/ranges_generate_n.h
@@ -25,6 +25,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -33,11 +36,10 @@ namespace ranges {
 namespace __generate_n {
 
 struct __fn {
-
   template <input_or_output_iterator _OutIter, copy_constructible _Func>
-  requires invocable<_Func&> && indirectly_writable<_OutIter, invoke_result_t<_Func&>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _OutIter operator()(_OutIter __first, iter_difference_t<_OutIter> __n, _Func __gen) const {
+    requires invocable<_Func&> && indirectly_writable<_OutIter, invoke_result_t<_Func&>>
+  _LIBCPP_HIDE_FROM_ABI constexpr _OutIter
+  operator()(_OutIter __first, iter_difference_t<_OutIter> __n, _Func __gen) const {
     for (; __n > 0; --__n) {
       *__first = __gen();
       ++__first;
@@ -45,13 +47,12 @@ struct __fn {
 
     return __first;
   }
-
 };
 
 } // namespace __generate_n
 
 inline namespace __cpo {
-  inline constexpr auto generate_n = __generate_n::__fn{};
+inline constexpr auto generate_n = __generate_n::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -59,4 +60,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_GENERATE_N_H
diff --git a/third_party/libcxx/__algorithm/ranges_includes.h b/third_party/libcxx/__algorithm/ranges_includes.h
index 314a92377..c4c3b8ed0 100644
--- a/third_party/libcxx/__algorithm/ranges_includes.h
+++ b/third_party/libcxx/__algorithm/ranges_includes.h
@@ -27,6 +27,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -35,15 +38,14 @@ namespace ranges {
 namespace __includes {
 
 struct __fn {
-  template <
-      input_iterator _Iter1,
-      sentinel_for<_Iter1> _Sent1,
-      input_iterator _Iter2,
-      sentinel_for<_Iter2> _Sent2,
-      class _Proj1                                                                           = identity,
-      class _Proj2                                                                           = identity,
-      indirect_strict_weak_order<projected<_Iter1, _Proj1>, projected<_Iter2, _Proj2>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+  template <input_iterator _Iter1,
+            sentinel_for<_Iter1> _Sent1,
+            input_iterator _Iter2,
+            sentinel_for<_Iter2> _Sent2,
+            class _Proj1                                                                           = identity,
+            class _Proj2                                                                           = identity,
+            indirect_strict_weak_order<projected<_Iter1, _Proj1>, projected<_Iter2, _Proj2>> _Comp = ranges::less>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
       _Iter1 __first1,
       _Sent1 __last1,
       _Iter2 __first2,
@@ -61,14 +63,13 @@ struct __fn {
         std::move(__proj2));
   }
 
-  template <
-      input_range _Range1,
-      input_range _Range2,
-      class _Proj1 = identity,
-      class _Proj2 = identity,
-      indirect_strict_weak_order<projected<iterator_t<_Range1>, _Proj1>, projected<iterator_t<_Range2>, _Proj2>>
-          _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+  template <input_range _Range1,
+            input_range _Range2,
+            class _Proj1 = identity,
+            class _Proj2 = identity,
+            indirect_strict_weak_order<projected<iterator_t<_Range1>, _Proj1>, projected<iterator_t<_Range2>, _Proj2>>
+                _Comp = ranges::less>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
       _Range1&& __range1, _Range2&& __range2, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
     return std::__includes(
         ranges::begin(__range1),
@@ -84,7 +85,7 @@ struct __fn {
 } // namespace __includes
 
 inline namespace __cpo {
-  inline constexpr auto includes = __includes::__fn{};
+inline constexpr auto includes = __includes::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -92,4 +93,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_INCLUDES_H
diff --git a/third_party/libcxx/__algorithm/ranges_inplace_merge.h b/third_party/libcxx/__algorithm/ranges_inplace_merge.h
index 8f78975d7..d94c0ad46 100644
--- a/third_party/libcxx/__algorithm/ranges_inplace_merge.h
+++ b/third_party/libcxx/__algorithm/ranges_inplace_merge.h
@@ -31,6 +31,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -38,43 +41,37 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __inplace_merge {
 
-  struct __fn {
-    template <class _Iter, class _Sent, class _Comp, class _Proj>
-    _LIBCPP_HIDE_FROM_ABI static constexpr auto
-    __inplace_merge_impl(_Iter __first, _Iter __middle, _Sent __last, _Comp&& __comp, _Proj&& __proj) {
-      auto __last_iter = ranges::next(__middle, __last);
-      std::__inplace_merge<_RangeAlgPolicy>(
-          std::move(__first), std::move(__middle), __last_iter, std::__make_projected(__comp, __proj));
-      return __last_iter;
-    }
+struct __fn {
+  template <class _Iter, class _Sent, class _Comp, class _Proj>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  __inplace_merge_impl(_Iter __first, _Iter __middle, _Sent __last, _Comp&& __comp, _Proj&& __proj) {
+    auto __last_iter = ranges::next(__middle, __last);
+    std::__inplace_merge<_RangeAlgPolicy>(
+        std::move(__first), std::move(__middle), __last_iter, std::__make_projected(__comp, __proj));
+    return __last_iter;
+  }
 
-    template <
-        bidirectional_iterator _Iter,
-        sentinel_for<_Iter> _Sent,
-        class _Comp = ranges::less,
-        class _Proj = identity>
-      requires sortable<_Iter, _Comp, _Proj>
-    _LIBCPP_HIDE_FROM_ABI _Iter
-    operator()(_Iter __first, _Iter __middle, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
-      return __inplace_merge_impl(
-          std::move(__first), std::move(__middle), std::move(__last), std::move(__comp), std::move(__proj));
-    }
+  template <bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
+    requires sortable<_Iter, _Comp, _Proj>
+  _LIBCPP_HIDE_FROM_ABI _Iter
+  operator()(_Iter __first, _Iter __middle, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+    return __inplace_merge_impl(
+        std::move(__first), std::move(__middle), std::move(__last), std::move(__comp), std::move(__proj));
+  }
 
-    template <bidirectional_range _Range, class _Comp = ranges::less, class _Proj = identity>
-      requires sortable<
-          iterator_t<_Range>,
-          _Comp,
-          _Proj> _LIBCPP_HIDE_FROM_ABI borrowed_iterator_t<_Range>
-      operator()(_Range&& __range, iterator_t<_Range> __middle, _Comp __comp = {}, _Proj __proj = {}) const {
-      return __inplace_merge_impl(
-          ranges::begin(__range), std::move(__middle), ranges::end(__range), std::move(__comp), std::move(__proj));
-    }
-  };
+  template <bidirectional_range _Range, class _Comp = ranges::less, class _Proj = identity>
+    requires sortable<iterator_t<_Range>, _Comp, _Proj>
+  _LIBCPP_HIDE_FROM_ABI borrowed_iterator_t<_Range>
+  operator()(_Range&& __range, iterator_t<_Range> __middle, _Comp __comp = {}, _Proj __proj = {}) const {
+    return __inplace_merge_impl(
+        ranges::begin(__range), std::move(__middle), ranges::end(__range), std::move(__comp), std::move(__proj));
+  }
+};
 
 } // namespace __inplace_merge
 
 inline namespace __cpo {
-  inline constexpr auto inplace_merge = __inplace_merge::__fn{};
+inline constexpr auto inplace_merge = __inplace_merge::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -82,4 +79,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_INPLACE_MERGE_H
diff --git a/third_party/libcxx/__algorithm/ranges_is_heap.h b/third_party/libcxx/__algorithm/ranges_is_heap.h
index 9c77e0c3f..3d9e18ce1 100644
--- a/third_party/libcxx/__algorithm/ranges_is_heap.h
+++ b/third_party/libcxx/__algorithm/ranges_is_heap.h
@@ -26,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -34,28 +37,30 @@ namespace ranges {
 namespace __is_heap {
 
 struct __fn {
-
   template <class _Iter, class _Sent, class _Proj, class _Comp>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  static bool __is_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
-    auto __last_iter = ranges::next(__first, __last);
+  _LIBCPP_HIDE_FROM_ABI constexpr static bool
+  __is_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+    auto __last_iter        = ranges::next(__first, __last);
     auto&& __projected_comp = std::__make_projected(__comp, __proj);
 
     auto __result = std::__is_heap_until(std::move(__first), std::move(__last_iter), __projected_comp);
     return __result == __last;
   }
 
-  template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+  template <random_access_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj                                               = identity,
             indirect_strict_weak_order<projected<_Iter, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return __is_heap_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
-  template <random_access_range _Range, class _Proj = identity,
+  template <random_access_range _Range,
+            class _Proj                                                            = identity,
             indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
     return __is_heap_fn_impl(ranges::begin(__range), ranges::end(__range), __comp, __proj);
   }
 };
@@ -63,7 +68,7 @@ struct __fn {
 } // namespace __is_heap
 
 inline namespace __cpo {
-  inline constexpr auto is_heap = __is_heap::__fn{};
+inline constexpr auto is_heap = __is_heap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -71,4 +76,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_IS_HEAP_H
diff --git a/third_party/libcxx/__algorithm/ranges_is_heap_until.h b/third_party/libcxx/__algorithm/ranges_is_heap_until.h
index 3b1fec758..7a2e1fc77 100644
--- a/third_party/libcxx/__algorithm/ranges_is_heap_until.h
+++ b/third_party/libcxx/__algorithm/ranges_is_heap_until.h
@@ -27,6 +27,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -35,36 +38,37 @@ namespace ranges {
 namespace __is_heap_until {
 
 struct __fn {
-
   template <class _Iter, class _Sent, class _Proj, class _Comp>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  static _Iter __is_heap_until_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
-    auto __last_iter = ranges::next(__first, __last);
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter
+  __is_heap_until_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+    auto __last_iter        = ranges::next(__first, __last);
     auto&& __projected_comp = std::__make_projected(__comp, __proj);
 
     return std::__is_heap_until(std::move(__first), std::move(__last_iter), __projected_comp);
   }
 
-  template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+  template <random_access_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj                                               = identity,
             indirect_strict_weak_order<projected<_Iter, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return __is_heap_until_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
-  template <random_access_range _Range, class _Proj = identity,
+  template <random_access_range _Range,
+            class _Proj                                                            = identity,
             indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
     return __is_heap_until_fn_impl(ranges::begin(__range), ranges::end(__range), __comp, __proj);
   }
-
 };
 
 } // namespace __is_heap_until
 
 inline namespace __cpo {
-  inline constexpr auto is_heap_until = __is_heap_until::__fn{};
+inline constexpr auto is_heap_until = __is_heap_until::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -72,4 +76,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_IS_HEAP_UNTIL_H
diff --git a/third_party/libcxx/__algorithm/ranges_is_partitioned.h b/third_party/libcxx/__algorithm/ranges_is_partitioned.h
index 6782717cc..5be6fba46 100644
--- a/third_party/libcxx/__algorithm/ranges_is_partitioned.h
+++ b/third_party/libcxx/__algorithm/ranges_is_partitioned.h
@@ -23,6 +23,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -30,10 +33,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __is_partitioned {
 struct __fn {
-
   template <class _Iter, class _Sent, class _Proj, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  bool __is_parititioned_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static bool
+  __is_partitioned_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
     for (; __first != __last; ++__first) {
       if (!std::invoke(__pred, std::invoke(__proj, *__first)))
         break;
@@ -51,26 +53,27 @@ struct __fn {
     return true;
   }
 
-  template <input_iterator _Iter, sentinel_for<_Iter> _Sent,
+  template <input_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
             class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
-    return __is_parititioned_impl(std::move(__first), std::move(__last), __pred, __proj);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
+    return __is_partitioned_impl(std::move(__first), std::move(__last), __pred, __proj);
   }
 
   template <input_range _Range,
             class _Proj = identity,
             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
-    return __is_parititioned_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+    return __is_partitioned_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
   }
 };
 } // namespace __is_partitioned
 
 inline namespace __cpo {
-  inline constexpr auto is_partitioned = __is_partitioned::__fn{};
+inline constexpr auto is_partitioned = __is_partitioned::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -78,4 +81,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_IS_PARTITIONED_H
diff --git a/third_party/libcxx/__algorithm/ranges_is_permutation.h b/third_party/libcxx/__algorithm/ranges_is_permutation.h
index 95a0a8251..1f8d67007 100644
--- a/third_party/libcxx/__algorithm/ranges_is_permutation.h
+++ b/third_party/libcxx/__algorithm/ranges_is_permutation.h
@@ -25,6 +25,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -32,53 +35,66 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __is_permutation {
 struct __fn {
-
-  template <class _Iter1, class _Sent1, class _Iter2, class _Sent2,
-            class _Proj1, class _Proj2, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  bool __is_permutation_func_impl(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
-                                  _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
+  template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Proj1, class _Proj2, class _Pred>
+  _LIBCPP_HIDE_FROM_ABI constexpr static bool __is_permutation_func_impl(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred& __pred,
+      _Proj1& __proj1,
+      _Proj2& __proj2) {
     return std::__is_permutation<_RangeAlgPolicy>(
-        std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
-        __pred, __proj1, __proj2);
+        std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __pred, __proj1, __proj2);
   }
 
-  template <forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
-            forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
-            class _Proj1 = identity,
-            class _Proj2 = identity,
-            indirect_equivalence_relation<projected<_Iter1, _Proj1>,
-                                          projected<_Iter2, _Proj2>> _Pred = ranges::equal_to>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
-                  _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+  template <
+      forward_iterator _Iter1,
+      sentinel_for<_Iter1> _Sent1,
+      forward_iterator _Iter2,
+      sentinel_for<_Iter2> _Sent2,
+      class _Proj1                                                                              = identity,
+      class _Proj2                                                                              = identity,
+      indirect_equivalence_relation<projected<_Iter1, _Proj1>, projected<_Iter2, _Proj2>> _Pred = ranges::equal_to>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred __pred   = {},
+      _Proj1 __proj1 = {},
+      _Proj2 __proj2 = {}) const {
     return __is_permutation_func_impl(
-        std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2),
-        __pred, __proj1, __proj2);
+        std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __pred, __proj1, __proj2);
   }
 
   template <forward_range _Range1,
             forward_range _Range2,
-            class _Proj1 = identity,
-            class _Proj2 = identity,
-            indirect_equivalence_relation<projected<iterator_t<_Range1>, _Proj1>, projected<iterator_t<_Range2>, _Proj2>> _Pred = ranges::equal_to>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Range1&& __range1, _Range2&& __range2,
-                  _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+            class _Proj1                                                                = identity,
+            class _Proj2                                                                = identity,
+            indirect_equivalence_relation<projected<iterator_t<_Range1>, _Proj1>,
+                                          projected<iterator_t<_Range2>, _Proj2>> _Pred = ranges::equal_to>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+      _Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
     if constexpr (sized_range<_Range1> && sized_range<_Range2>) {
       if (ranges::distance(__range1) != ranges::distance(__range2))
         return false;
     }
 
     return __is_permutation_func_impl(
-        ranges::begin(__range1), ranges::end(__range1), ranges::begin(__range2), ranges::end(__range2),
-        __pred, __proj1, __proj2);
+        ranges::begin(__range1),
+        ranges::end(__range1),
+        ranges::begin(__range2),
+        ranges::end(__range2),
+        __pred,
+        __proj1,
+        __proj2);
   }
 };
 } // namespace __is_permutation
 
 inline namespace __cpo {
-  inline constexpr auto is_permutation = __is_permutation::__fn{};
+inline constexpr auto is_permutation = __is_permutation::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -86,4 +102,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_IS_PERMUTATION_H
diff --git a/third_party/libcxx/__algorithm/ranges_is_sorted.h b/third_party/libcxx/__algorithm/ranges_is_sorted.h
index 50c97baa8..5b88d422b 100644
--- a/third_party/libcxx/__algorithm/ranges_is_sorted.h
+++ b/third_party/libcxx/__algorithm/ranges_is_sorted.h
@@ -23,6 +23,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -30,19 +33,20 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __is_sorted {
 struct __fn {
-  template <forward_iterator _Iter, sentinel_for<_Iter> _Sent,
-            class _Proj = identity,
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj                                               = identity,
             indirect_strict_weak_order<projected<_Iter, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return ranges::__is_sorted_until_impl(std::move(__first), __last, __comp, __proj) == __last;
   }
 
   template <forward_range _Range,
-            class _Proj = identity,
+            class _Proj                                                            = identity,
             indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
     auto __last = ranges::end(__range);
     return ranges::__is_sorted_until_impl(ranges::begin(__range), __last, __comp, __proj) == __last;
   }
@@ -50,7 +54,7 @@ struct __fn {
 } // namespace __is_sorted
 
 inline namespace __cpo {
-  inline constexpr auto is_sorted = __is_sorted::__fn{};
+inline constexpr auto is_sorted = __is_sorted::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -58,4 +62,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP__ALGORITHM_RANGES_IS_SORTED_H
diff --git a/third_party/libcxx/__algorithm/ranges_is_sorted_until.h b/third_party/libcxx/__algorithm/ranges_is_sorted_until.h
index f139d0391..54de530c8 100644
--- a/third_party/libcxx/__algorithm/ranges_is_sorted_until.h
+++ b/third_party/libcxx/__algorithm/ranges_is_sorted_until.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -31,8 +34,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 
 template <class _Iter, class _Sent, class _Proj, class _Comp>
-_LIBCPP_HIDE_FROM_ABI constexpr
-_Iter __is_sorted_until_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+_LIBCPP_HIDE_FROM_ABI constexpr _Iter
+__is_sorted_until_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
   if (__first == __last)
     return __first;
   auto __i = __first;
@@ -46,26 +49,27 @@ _Iter __is_sorted_until_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj&
 
 namespace __is_sorted_until {
 struct __fn {
-  template <forward_iterator _Iter, sentinel_for<_Iter> _Sent,
-            class _Proj = identity,
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj                                               = identity,
             indirect_strict_weak_order<projected<_Iter, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return ranges::__is_sorted_until_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
   template <forward_range _Range,
-            class _Proj = identity,
+            class _Proj                                                            = identity,
             indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
     return ranges::__is_sorted_until_impl(ranges::begin(__range), ranges::end(__range), __comp, __proj);
   }
 };
 } // namespace __is_sorted_until
 
 inline namespace __cpo {
-  inline constexpr auto is_sorted_until = __is_sorted_until::__fn{};
+inline constexpr auto is_sorted_until = __is_sorted_until::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -73,4 +77,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP__ALGORITHM_RANGES_IS_SORTED_UNTIL_H
diff --git a/third_party/libcxx/__algorithm/ranges_iterator_concept.h b/third_party/libcxx/__algorithm/ranges_iterator_concept.h
index 9a9203040..2af891d3a 100644
--- a/third_party/libcxx/__algorithm/ranges_iterator_concept.h
+++ b/third_party/libcxx/__algorithm/ranges_iterator_concept.h
@@ -18,6 +18,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -48,4 +51,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_ITERATOR_CONCEPT_H
diff --git a/third_party/libcxx/__algorithm/ranges_lexicographical_compare.h b/third_party/libcxx/__algorithm/ranges_lexicographical_compare.h
index c51f4d7e5..6d82017e3 100644
--- a/third_party/libcxx/__algorithm/ranges_lexicographical_compare.h
+++ b/third_party/libcxx/__algorithm/ranges_lexicographical_compare.h
@@ -23,6 +23,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -30,17 +33,17 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __lexicographical_compare {
 struct __fn {
-
   template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Proj1, class _Proj2, class _Comp>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  bool __lexicographical_compare_impl(_Iter1 __first1, _Sent1 __last1,
-                                      _Iter2 __first2, _Sent2 __last2,
-                                      _Comp& __comp,
-                                      _Proj1& __proj1,
-                                      _Proj2& __proj2) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static bool __lexicographical_compare_impl(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Comp& __comp,
+      _Proj1& __proj1,
+      _Proj2& __proj2) {
     while (__first2 != __last2) {
-      if (__first1 == __last1
-       || std::invoke(__comp, std::invoke(__proj1, *__first1), std::invoke(__proj2, *__first2)))
+      if (__first1 == __last1 || std::invoke(__comp, std::invoke(__proj1, *__first1), std::invoke(__proj2, *__first2)))
         return true;
       if (std::invoke(__comp, std::invoke(__proj2, *__first2), std::invoke(__proj1, *__first1)))
         return false;
@@ -50,44 +53,47 @@ struct __fn {
     return false;
   }
 
-  template <input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
-            input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
-            class _Proj1 = identity,
-            class _Proj2 = identity,
+  template <input_iterator _Iter1,
+            sentinel_for<_Iter1> _Sent1,
+            input_iterator _Iter2,
+            sentinel_for<_Iter2> _Sent2,
+            class _Proj1                                                                           = identity,
+            class _Proj2                                                                           = identity,
             indirect_strict_weak_order<projected<_Iter1, _Proj1>, projected<_Iter2, _Proj2>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Iter1 __first1, _Sent1 __last1,
-                  _Iter2 __first2, _Sent2 __last2,
-                  _Comp __comp = {},
-                  _Proj1 __proj1 = {},
-                  _Proj2 __proj2 = {}) const {
-    return __lexicographical_compare_impl(std::move(__first1), std::move(__last1),
-                                          std::move(__first2), std::move(__last2),
-                                          __comp,
-                                          __proj1,
-                                          __proj2);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Comp __comp   = {},
+      _Proj1 __proj1 = {},
+      _Proj2 __proj2 = {}) const {
+    return __lexicographical_compare_impl(
+        std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __comp, __proj1, __proj2);
   }
 
   template <input_range _Range1,
             input_range _Range2,
             class _Proj1 = identity,
             class _Proj2 = identity,
-            indirect_strict_weak_order<projected<iterator_t<_Range1>, _Proj1>,
-                                       projected<iterator_t<_Range2>, _Proj2>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Range1&& __range1, _Range2&& __range2, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
-    return __lexicographical_compare_impl(ranges::begin(__range1), ranges::end(__range1),
-                                          ranges::begin(__range2), ranges::end(__range2),
-                                          __comp,
-                                          __proj1,
-                                          __proj2);
+            indirect_strict_weak_order<projected<iterator_t<_Range1>, _Proj1>, projected<iterator_t<_Range2>, _Proj2>>
+                _Comp = ranges::less>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+      _Range1&& __range1, _Range2&& __range2, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+    return __lexicographical_compare_impl(
+        ranges::begin(__range1),
+        ranges::end(__range1),
+        ranges::begin(__range2),
+        ranges::end(__range2),
+        __comp,
+        __proj1,
+        __proj2);
   }
-
 };
 } // namespace __lexicographical_compare
 
 inline namespace __cpo {
-  inline constexpr auto lexicographical_compare = __lexicographical_compare::__fn{};
+inline constexpr auto lexicographical_compare = __lexicographical_compare::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -95,4 +101,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_LEXICOGRAPHICAL_COMPARE_H
diff --git a/third_party/libcxx/__algorithm/ranges_lower_bound.h b/third_party/libcxx/__algorithm/ranges_lower_bound.h
index 743563940..0651147e0 100644
--- a/third_party/libcxx/__algorithm/ranges_lower_bound.h
+++ b/third_party/libcxx/__algorithm/ranges_lower_bound.h
@@ -27,6 +27,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -35,27 +38,29 @@ namespace ranges {
 
 namespace __lower_bound {
 struct __fn {
-  template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity,
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Type,
+            class _Proj                                                             = identity,
             indirect_strict_weak_order<const _Type*, projected<_Iter, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, const _Type& __value, _Comp __comp = {}, _Proj __proj = {}) const {
-    return std::__lower_bound_impl<_RangeAlgPolicy>(__first, __last, __value, __comp, __proj);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, const _Type& __value, _Comp __comp = {}, _Proj __proj = {}) const {
+    return std::__lower_bound<_RangeAlgPolicy>(__first, __last, __value, __comp, __proj);
   }
 
-  template <forward_range _Range, class _Type, class _Proj = identity,
+  template <forward_range _Range,
+            class _Type,
+            class _Proj                                                                          = identity,
             indirect_strict_weak_order<const _Type*, projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __r,
-                                         const _Type& __value,
-                                         _Comp __comp = {},
-                                         _Proj __proj = {}) const {
-    return std::__lower_bound_impl<_RangeAlgPolicy>(ranges::begin(__r), ranges::end(__r), __value, __comp, __proj);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __r, const _Type& __value, _Comp __comp = {}, _Proj __proj = {}) const {
+    return std::__lower_bound<_RangeAlgPolicy>(ranges::begin(__r), ranges::end(__r), __value, __comp, __proj);
   }
 };
 } // namespace __lower_bound
 
 inline namespace __cpo {
-  inline constexpr auto lower_bound = __lower_bound::__fn{};
+inline constexpr auto lower_bound = __lower_bound::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -63,4 +68,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_LOWER_BOUND_H
diff --git a/third_party/libcxx/__algorithm/ranges_make_heap.h b/third_party/libcxx/__algorithm/ranges_make_heap.h
index 7f92fa310..fe9c024fb 100644
--- a/third_party/libcxx/__algorithm/ranges_make_heap.h
+++ b/third_party/libcxx/__algorithm/ranges_make_heap.h
@@ -32,6 +32,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -41,8 +44,8 @@ namespace __make_heap {
 
 struct __fn {
   template <class _Iter, class _Sent, class _Comp, class _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  _Iter __make_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter
+  __make_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
     auto __last_iter = ranges::next(__first, __last);
 
     auto&& __projected_comp = std::__make_projected(__comp, __proj);
@@ -53,15 +56,15 @@ struct __fn {
 
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<_Iter, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return __make_heap_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
   template <random_access_range _Range, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<iterator_t<_Range>, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     return __make_heap_fn_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
   }
 };
@@ -69,7 +72,7 @@ struct __fn {
 } // namespace __make_heap
 
 inline namespace __cpo {
-  inline constexpr auto make_heap = __make_heap::__fn{};
+inline constexpr auto make_heap = __make_heap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -77,4 +80,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_MAKE_HEAP_H
diff --git a/third_party/libcxx/__algorithm/ranges_max.h b/third_party/libcxx/__algorithm/ranges_max.h
index 2fd2970bb..d0ee6f314 100644
--- a/third_party/libcxx/__algorithm/ranges_max.h
+++ b/third_party/libcxx/__algorithm/ranges_max.h
@@ -31,45 +31,51 @@
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_PUSH_MACROS
-#include <__undef_macros>
+#  include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __max {
 struct __fn {
-  template <class _Tp, class _Proj = identity,
+  template <class _Tp,
+            class _Proj                                                    = identity,
             indirect_strict_weak_order<projected<const _Tp*, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  const _Tp& operator()(_LIBCPP_LIFETIMEBOUND const _Tp& __a,
-                        _LIBCPP_LIFETIMEBOUND const _Tp& __b,
-                        _Comp __comp = {},
-                        _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&
+  operator()(_LIBCPP_LIFETIMEBOUND const _Tp& __a,
+             _LIBCPP_LIFETIMEBOUND const _Tp& __b,
+             _Comp __comp = {},
+             _Proj __proj = {}) const {
     return std::invoke(__comp, std::invoke(__proj, __a), std::invoke(__proj, __b)) ? __b : __a;
   }
 
-  template <copyable _Tp, class _Proj = identity,
+  template <copyable _Tp,
+            class _Proj                                                    = identity,
             indirect_strict_weak_order<projected<const _Tp*, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Tp operator()(initializer_list<_Tp> __il, _Comp __comp = {}, _Proj __proj = {}) const {
-    _LIBCPP_ASSERT(__il.begin() != __il.end(), "initializer_list must contain at least one element");
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp
+  operator()(initializer_list<_Tp> __il, _Comp __comp = {}, _Proj __proj = {}) const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __il.begin() != __il.end(), "initializer_list must contain at least one element");
 
-    auto __comp_lhs_rhs_swapped = [&](auto&& __lhs, auto&& __rhs) { return std::invoke(__comp, __rhs, __lhs); };
+    auto __comp_lhs_rhs_swapped = [&](auto&& __lhs, auto&& __rhs) -> bool { return std::invoke(__comp, __rhs, __lhs); };
     return *ranges::__min_element_impl(__il.begin(), __il.end(), __comp_lhs_rhs_swapped, __proj);
   }
 
-  template <input_range _Rp, class _Proj = identity,
+  template <input_range _Rp,
+            class _Proj                                                         = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rp>, _Proj>> _Comp = ranges::less>
     requires indirectly_copyable_storable<iterator_t<_Rp>, range_value_t<_Rp>*>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  range_value_t<_Rp> operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr range_value_t<_Rp>
+  operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     auto __first = ranges::begin(__r);
-    auto __last = ranges::end(__r);
+    auto __last  = ranges::end(__r);
 
-    _LIBCPP_ASSERT(__first != __last, "range must contain at least one element");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__first != __last, "range must contain at least one element");
 
     if constexpr (forward_range<_Rp> && !__is_cheap_to_copy<range_value_t<_Rp>>) {
-      auto __comp_lhs_rhs_swapped = [&](auto&& __lhs, auto&& __rhs) { return std::invoke(__comp, __rhs, __lhs); };
+      auto __comp_lhs_rhs_swapped = [&](auto&& __lhs, auto&& __rhs) -> bool {
+        return std::invoke(__comp, __rhs, __lhs);
+      };
       return *ranges::__min_element_impl(std::move(__first), std::move(__last), __comp_lhs_rhs_swapped, __proj);
     } else {
       range_value_t<_Rp> __result = *__first;
@@ -84,7 +90,7 @@ struct __fn {
 } // namespace __max
 
 inline namespace __cpo {
-  inline constexpr auto max = __max::__fn{};
+inline constexpr auto max = __max::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -92,6 +98,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#endif // _LIBCPP_STD_VER >= 20 &&
+#endif // _LIBCPP_STD_VER >= 20
 
 #endif // _LIBCPP___ALGORITHM_RANGES_MAX_H
diff --git a/third_party/libcxx/__algorithm/ranges_max_element.h b/third_party/libcxx/__algorithm/ranges_max_element.h
index 39e86d3b9..c57730927 100644
--- a/third_party/libcxx/__algorithm/ranges_max_element.h
+++ b/third_party/libcxx/__algorithm/ranges_max_element.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -31,26 +34,29 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __max_element {
 struct __fn {
-  template <forward_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+  template <forward_iterator _Ip,
+            sentinel_for<_Ip> _Sp,
+            class _Proj                                             = identity,
             indirect_strict_weak_order<projected<_Ip, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Ip operator()(_Ip __first, _Sp __last, _Comp __comp = {}, _Proj __proj = {}) const {
-    auto __comp_lhs_rhs_swapped = [&](auto&& __lhs, auto&& __rhs) { return std::invoke(__comp, __rhs, __lhs); };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Ip
+  operator()(_Ip __first, _Sp __last, _Comp __comp = {}, _Proj __proj = {}) const {
+    auto __comp_lhs_rhs_swapped = [&](auto&& __lhs, auto&& __rhs) -> bool { return std::invoke(__comp, __rhs, __lhs); };
     return ranges::__min_element_impl(__first, __last, __comp_lhs_rhs_swapped, __proj);
   }
 
-  template <forward_range _Rp, class _Proj = identity,
+  template <forward_range _Rp,
+            class _Proj                                                         = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rp>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Rp> operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
-    auto __comp_lhs_rhs_swapped = [&](auto&& __lhs, auto&& __rhs) { return std::invoke(__comp, __rhs, __lhs); };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Rp>
+  operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+    auto __comp_lhs_rhs_swapped = [&](auto&& __lhs, auto&& __rhs) -> bool { return std::invoke(__comp, __rhs, __lhs); };
     return ranges::__min_element_impl(ranges::begin(__r), ranges::end(__r), __comp_lhs_rhs_swapped, __proj);
   }
 };
 } // namespace __max_element
 
 inline namespace __cpo {
-  inline constexpr auto max_element = __max_element::__fn{};
+inline constexpr auto max_element = __max_element::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -58,4 +64,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_MAX_ELEMENT_H
diff --git a/third_party/libcxx/__algorithm/ranges_merge.h b/third_party/libcxx/__algorithm/ranges_merge.h
index c5797b0e7..bdf9a62d9 100644
--- a/third_party/libcxx/__algorithm/ranges_merge.h
+++ b/third_party/libcxx/__algorithm/ranges_merge.h
@@ -27,6 +27,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -38,25 +41,25 @@ using merge_result = in_in_out_result<_InIter1, _InIter2, _OutIter>;
 
 namespace __merge {
 
-template <
-    class _InIter1,
-    class _Sent1,
-    class _InIter2,
-    class _Sent2,
-    class _OutIter,
-    class _Comp,
-    class _Proj1,
-    class _Proj2>
-_LIBCPP_HIDE_FROM_ABI constexpr merge_result<__remove_cvref_t<_InIter1>, __remove_cvref_t<_InIter2>, __remove_cvref_t<_OutIter>>
-__merge_impl(
-    _InIter1&& __first1,
-    _Sent1&& __last1,
-    _InIter2&& __first2,
-    _Sent2&& __last2,
-    _OutIter&& __result,
-    _Comp&& __comp,
-    _Proj1&& __proj1,
-    _Proj2&& __proj2) {
+template < class _InIter1,
+           class _Sent1,
+           class _InIter2,
+           class _Sent2,
+           class _OutIter,
+           class _Comp,
+           class _Proj1,
+           class _Proj2>
+_LIBCPP_HIDE_FROM_ABI constexpr merge_result<__remove_cvref_t<_InIter1>,
+                                             __remove_cvref_t<_InIter2>,
+                                             __remove_cvref_t<_OutIter>>
+__merge_impl(_InIter1&& __first1,
+             _Sent1&& __last1,
+             _InIter2&& __first2,
+             _Sent2&& __last2,
+             _OutIter&& __result,
+             _Comp&& __comp,
+             _Proj1&& __proj1,
+             _Proj2&& __proj2) {
   for (; __first1 != __last1 && __first2 != __last2; ++__result) {
     if (std::invoke(__comp, std::invoke(__proj2, *__first2), std::invoke(__proj1, *__first1))) {
       *__result = *__first2;
@@ -72,15 +75,14 @@ __merge_impl(
 }
 
 struct __fn {
-  template <
-      input_iterator _InIter1,
-      sentinel_for<_InIter1> _Sent1,
-      input_iterator _InIter2,
-      sentinel_for<_InIter2> _Sent2,
-      weakly_incrementable _OutIter,
-      class _Comp  = less,
-      class _Proj1 = identity,
-      class _Proj2 = identity>
+  template <input_iterator _InIter1,
+            sentinel_for<_InIter1> _Sent1,
+            input_iterator _InIter2,
+            sentinel_for<_InIter2> _Sent2,
+            weakly_incrementable _OutIter,
+            class _Comp  = less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
     requires mergeable<_InIter1, _InIter2, _OutIter, _Comp, _Proj1, _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr merge_result<_InIter1, _InIter2, _OutIter> operator()(
       _InIter1 __first1,
@@ -94,28 +96,20 @@ struct __fn {
     return __merge::__merge_impl(__first1, __last1, __first2, __last2, __result, __comp, __proj1, __proj2);
   }
 
-  template <
-      input_range _Range1,
-      input_range _Range2,
-      weakly_incrementable _OutIter,
-      class _Comp  = less,
-      class _Proj1 = identity,
-      class _Proj2 = identity>
-    requires mergeable<
-        iterator_t<_Range1>,
-        iterator_t<_Range2>,
-        _OutIter,
-        _Comp,
-        _Proj1,
-        _Proj2>
+  template <input_range _Range1,
+            input_range _Range2,
+            weakly_incrementable _OutIter,
+            class _Comp  = less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _OutIter, _Comp, _Proj1, _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr merge_result<borrowed_iterator_t<_Range1>, borrowed_iterator_t<_Range2>, _OutIter>
-        operator()(
-            _Range1&& __range1,
-            _Range2&& __range2,
-            _OutIter __result,
-            _Comp __comp   = {},
-            _Proj1 __proj1 = {},
-            _Proj2 __proj2 = {}) const {
+  operator()(_Range1&& __range1,
+             _Range2&& __range2,
+             _OutIter __result,
+             _Comp __comp   = {},
+             _Proj1 __proj1 = {},
+             _Proj2 __proj2 = {}) const {
     return __merge::__merge_impl(
         ranges::begin(__range1),
         ranges::end(__range1),
@@ -131,7 +125,7 @@ struct __fn {
 } // namespace __merge
 
 inline namespace __cpo {
-  inline constexpr auto merge = __merge::__fn{};
+inline constexpr auto merge = __merge::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -139,4 +133,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_MERGE_H
diff --git a/third_party/libcxx/__algorithm/ranges_min.h b/third_party/libcxx/__algorithm/ranges_min.h
index 5e941a1db..cc569d2a0 100644
--- a/third_party/libcxx/__algorithm/ranges_min.h
+++ b/third_party/libcxx/__algorithm/ranges_min.h
@@ -30,39 +30,43 @@
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_PUSH_MACROS
-#include <__undef_macros>
+#  include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __min {
 struct __fn {
-  template <class _Tp, class _Proj = identity,
+  template <class _Tp,
+            class _Proj                                                    = identity,
             indirect_strict_weak_order<projected<const _Tp*, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  const _Tp& operator()(_LIBCPP_LIFETIMEBOUND const _Tp& __a,
-                        _LIBCPP_LIFETIMEBOUND const _Tp& __b,
-                        _Comp __comp = {},
-                        _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&
+  operator()(_LIBCPP_LIFETIMEBOUND const _Tp& __a,
+             _LIBCPP_LIFETIMEBOUND const _Tp& __b,
+             _Comp __comp = {},
+             _Proj __proj = {}) const {
     return std::invoke(__comp, std::invoke(__proj, __b), std::invoke(__proj, __a)) ? __b : __a;
   }
 
-  template <copyable _Tp, class _Proj = identity,
+  template <copyable _Tp,
+            class _Proj                                                    = identity,
             indirect_strict_weak_order<projected<const _Tp*, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Tp operator()(initializer_list<_Tp> __il, _Comp __comp = {}, _Proj __proj = {}) const {
-    _LIBCPP_ASSERT(__il.begin() != __il.end(), "initializer_list must contain at least one element");
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp
+  operator()(initializer_list<_Tp> __il, _Comp __comp = {}, _Proj __proj = {}) const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __il.begin() != __il.end(), "initializer_list must contain at least one element");
     return *ranges::__min_element_impl(__il.begin(), __il.end(), __comp, __proj);
   }
 
-  template <input_range _Rp, class _Proj = identity,
+  template <input_range _Rp,
+            class _Proj                                                         = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rp>, _Proj>> _Comp = ranges::less>
     requires indirectly_copyable_storable<iterator_t<_Rp>, range_value_t<_Rp>*>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  range_value_t<_Rp> operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr range_value_t<_Rp>
+  operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     auto __first = ranges::begin(__r);
-    auto __last = ranges::end(__r);
-    _LIBCPP_ASSERT(__first != __last, "range must contain at least one element");
+    auto __last  = ranges::end(__r);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__first != __last, "range must contain at least one element");
     if constexpr (forward_range<_Rp> && !__is_cheap_to_copy<range_value_t<_Rp>>) {
       return *ranges::__min_element_impl(__first, __last, __comp, __proj);
     } else {
@@ -78,7 +82,7 @@ struct __fn {
 } // namespace __min
 
 inline namespace __cpo {
-  inline constexpr auto min = __min::__fn{};
+inline constexpr auto min = __min::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -86,6 +90,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#endif // _LIBCPP_STD_VER >= 20 &&
+#endif // _LIBCPP_STD_VER >= 20
 
 #endif // _LIBCPP___ALGORITHM_RANGES_MIN_H
diff --git a/third_party/libcxx/__algorithm/ranges_min_element.h b/third_party/libcxx/__algorithm/ranges_min_element.h
index 4c58adb31..588ef258e 100644
--- a/third_party/libcxx/__algorithm/ranges_min_element.h
+++ b/third_party/libcxx/__algorithm/ranges_min_element.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -32,8 +35,7 @@ namespace ranges {
 
 // TODO(ranges): `ranges::min_element` can now simply delegate to `std::__min_element`.
 template <class _Ip, class _Sp, class _Proj, class _Comp>
-_LIBCPP_HIDE_FROM_ABI constexpr
-_Ip __min_element_impl(_Ip __first, _Sp __last, _Comp& __comp, _Proj& __proj) {
+_LIBCPP_HIDE_FROM_ABI constexpr _Ip __min_element_impl(_Ip __first, _Sp __last, _Comp& __comp, _Proj& __proj) {
   if (__first == __last)
     return __first;
 
@@ -46,24 +48,27 @@ _Ip __min_element_impl(_Ip __first, _Sp __last, _Comp& __comp, _Proj& __proj) {
 
 namespace __min_element {
 struct __fn {
-  template <forward_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+  template <forward_iterator _Ip,
+            sentinel_for<_Ip> _Sp,
+            class _Proj                                             = identity,
             indirect_strict_weak_order<projected<_Ip, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Ip operator()(_Ip __first, _Sp __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Ip
+  operator()(_Ip __first, _Sp __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return ranges::__min_element_impl(__first, __last, __comp, __proj);
   }
 
-  template <forward_range _Rp, class _Proj = identity,
+  template <forward_range _Rp,
+            class _Proj                                                         = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rp>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Rp> operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Rp>
+  operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     return ranges::__min_element_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
   }
 };
 } // namespace __min_element
 
 inline namespace __cpo {
-  inline constexpr auto min_element = __min_element::__fn{};
+inline constexpr auto min_element = __min_element::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -71,4 +76,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_MIN_ELEMENT_H
diff --git a/third_party/libcxx/__algorithm/ranges_minmax.h b/third_party/libcxx/__algorithm/ranges_minmax.h
index 2a966bbee..09cbefd91 100644
--- a/third_party/libcxx/__algorithm/ranges_minmax.h
+++ b/third_party/libcxx/__algorithm/ranges_minmax.h
@@ -23,7 +23,9 @@
 #include <__iterator/projected.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
+#include <__type_traits/desugars_to.h>
 #include <__type_traits/is_reference.h>
+#include <__type_traits/is_trivially_copyable.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
@@ -37,7 +39,7 @@
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_PUSH_MACROS
-#include <__undef_macros>
+#  include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -47,9 +49,10 @@ using minmax_result = min_max_result<_T1>;
 
 namespace __minmax {
 struct __fn {
-  template <class _Type, class _Proj = identity,
+  template <class _Type,
+            class _Proj                                                      = identity,
             indirect_strict_weak_order<projected<const _Type*, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr ranges::minmax_result<const _Type&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr ranges::minmax_result<const _Type&>
   operator()(_LIBCPP_LIFETIMEBOUND const _Type& __a,
              _LIBCPP_LIFETIMEBOUND const _Type& __b,
              _Comp __comp = {},
@@ -59,27 +62,43 @@ struct __fn {
     return {__a, __b};
   }
 
-  template <copyable _Type, class _Proj = identity,
+  template <copyable _Type,
+            class _Proj                                                      = identity,
             indirect_strict_weak_order<projected<const _Type*, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  ranges::minmax_result<_Type> operator()(initializer_list<_Type> __il, _Comp __comp = {}, _Proj __proj = {}) const {
-    _LIBCPP_ASSERT(__il.begin() != __il.end(), "initializer_list has to contain at least one element");
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr ranges::minmax_result<_Type>
+  operator()(initializer_list<_Type> __il, _Comp __comp = {}, _Proj __proj = {}) const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __il.begin() != __il.end(), "initializer_list has to contain at least one element");
     auto __iters = std::__minmax_element_impl(__il.begin(), __il.end(), __comp, __proj);
-    return ranges::minmax_result<_Type> { *__iters.first, *__iters.second };
+    return ranges::minmax_result<_Type>{*__iters.first, *__iters.second};
   }
 
-  template <input_range _Range, class _Proj = identity,
+  template <input_range _Range,
+            class _Proj                                                            = identity,
             indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
     requires indirectly_copyable_storable<iterator_t<_Range>, range_value_t<_Range>*>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  ranges::minmax_result<range_value_t<_Range>> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
-    auto __first = ranges::begin(__r);
-    auto __last = ranges::end(__r);
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr ranges::minmax_result<range_value_t<_Range>>
+  operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+    auto __first  = ranges::begin(__r);
+    auto __last   = ranges::end(__r);
     using _ValueT = range_value_t<_Range>;
 
-    _LIBCPP_ASSERT(__first != __last, "range has to contain at least one element");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__first != __last, "range has to contain at least one element");
 
-    if constexpr (forward_range<_Range>) {
+    // This optimiation is not in minmax_element because clang doesn't see through the pointers and as a result doesn't
+    // vectorize the code.
+    if constexpr (contiguous_range<_Range> && is_integral_v<_ValueT> &&
+                  __is_cheap_to_copy<_ValueT> & __is_identity<_Proj>::value &&
+                  __desugars_to_v<__less_tag, _Comp, _ValueT, _ValueT>) {
+      minmax_result<_ValueT> __result = {__r[0], __r[0]};
+      for (auto __e : __r) {
+        if (__e < __result.min)
+          __result.min = __e;
+        if (__result.max < __e)
+          __result.max = __e;
+      }
+      return __result;
+    } else if constexpr (forward_range<_Range>) {
       // Special-case the one element case. Avoid repeatedly initializing objects from the result of an iterator
       // dereference when doing so might not be idempotent. The `if constexpr` avoids the extra branch in cases where
       // it's not needed.
@@ -98,8 +117,9 @@ struct __fn {
       // input_iterators can't be copied, so the implementation for input_iterators has to store
       // the values instead of a pointer to the correct values
       auto __less = [&](auto&& __a, auto&& __b) -> bool {
-        return std::invoke(__comp, std::invoke(__proj, std::forward<decltype(__a)>(__a)),
-                                   std::invoke(__proj, std::forward<decltype(__b)>(__b)));
+        return std::invoke(__comp,
+                           std::invoke(__proj, std::forward<decltype(__a)>(__a)),
+                           std::invoke(__proj, std::forward<decltype(__b)>(__b)));
       };
 
       // During initialization, members are allowed to refer to already initialized members
@@ -142,7 +162,7 @@ struct __fn {
 } // namespace __minmax
 
 inline namespace __cpo {
-  inline constexpr auto minmax = __minmax::__fn{};
+inline constexpr auto minmax = __minmax::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__algorithm/ranges_minmax_element.h b/third_party/libcxx/__algorithm/ranges_minmax_element.h
index cbf350557..4bf6d2404 100644
--- a/third_party/libcxx/__algorithm/ranges_minmax_element.h
+++ b/third_party/libcxx/__algorithm/ranges_minmax_element.h
@@ -28,6 +28,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -39,18 +42,20 @@ using minmax_element_result = min_max_result<_T1>;
 
 namespace __minmax_element {
 struct __fn {
-  template <forward_iterator _Ip, sentinel_for<_Ip> _Sp, class _Proj = identity,
+  template <forward_iterator _Ip,
+            sentinel_for<_Ip> _Sp,
+            class _Proj                                             = identity,
             indirect_strict_weak_order<projected<_Ip, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  ranges::minmax_element_result<_Ip> operator()(_Ip __first, _Sp __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr ranges::minmax_element_result<_Ip>
+  operator()(_Ip __first, _Sp __last, _Comp __comp = {}, _Proj __proj = {}) const {
     auto __ret = std::__minmax_element_impl(std::move(__first), std::move(__last), __comp, __proj);
     return {__ret.first, __ret.second};
   }
 
-  template <forward_range _Rp, class _Proj = identity,
+  template <forward_range _Rp,
+            class _Proj                                                         = identity,
             indirect_strict_weak_order<projected<iterator_t<_Rp>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  ranges::minmax_element_result<borrowed_iterator_t<_Rp>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr ranges::minmax_element_result<borrowed_iterator_t<_Rp>>
   operator()(_Rp&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     auto __ret = std::__minmax_element_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
     return {__ret.first, __ret.second};
@@ -59,7 +64,7 @@ struct __fn {
 } // namespace __minmax_element
 
 inline namespace __cpo {
-  inline constexpr auto minmax_element = __minmax_element::__fn{};
+inline constexpr auto minmax_element = __minmax_element::__fn{};
 } // namespace __cpo
 
 } // namespace ranges
@@ -68,4 +73,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_MINMAX_H
diff --git a/third_party/libcxx/__algorithm/ranges_mismatch.h b/third_party/libcxx/__algorithm/ranges_mismatch.h
index 098c4151c..c4bf0022a 100644
--- a/third_party/libcxx/__algorithm/ranges_mismatch.h
+++ b/third_party/libcxx/__algorithm/ranges_mismatch.h
@@ -10,6 +10,8 @@
 #define _LIBCPP___ALGORITHM_RANGES_MISMATCH_H
 
 #include <__algorithm/in_in_result.h>
+#include <__algorithm/mismatch.h>
+#include <__algorithm/unwrap_range.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__functional/invoke.h>
@@ -25,6 +27,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -36,45 +41,53 @@ using mismatch_result = in_in_result<_I1, _I2>;
 
 namespace __mismatch {
 struct __fn {
-  template <class _I1, class _S1, class _I2, class _S2,
-            class _Pred, class _Proj1, class _Proj2>
-  static _LIBCPP_HIDE_FROM_ABI constexpr
-  mismatch_result<_I1, _I2>
-  __go(_I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2,
-       _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
-    while (__first1 != __last1 && __first2 != __last2) {
-      if (!std::invoke(__pred, std::invoke(__proj1, *__first1), std::invoke(__proj2, *__first2)))
-        break;
-      ++__first1;
-      ++__first2;
+  template <class _I1, class _S1, class _I2, class _S2, class _Pred, class _Proj1, class _Proj2>
+  static _LIBCPP_HIDE_FROM_ABI constexpr mismatch_result<_I1, _I2>
+  __go(_I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
+    if constexpr (forward_iterator<_I1> && forward_iterator<_I2>) {
+      auto __range1 = std::__unwrap_range(__first1, __last1);
+      auto __range2 = std::__unwrap_range(__first2, __last2);
+      auto __res =
+          std::__mismatch(__range1.first, __range1.second, __range2.first, __range2.second, __pred, __proj1, __proj2);
+      return {std::__rewrap_range<_S1>(__first1, __res.first), std::__rewrap_range<_S2>(__first2, __res.second)};
+    } else {
+      auto __res = std::__mismatch(
+          std::move(__first1), std::move(__last1), std::move(__first2), std::move(__last2), __pred, __proj1, __proj2);
+      return {std::move(__res.first), std::move(__res.second)};
     }
-    return {std::move(__first1), std::move(__first2)};
   }
 
-  template <input_iterator _I1, sentinel_for<_I1> _S1,
-            input_iterator _I2, sentinel_for<_I2> _S2,
-            class _Pred = ranges::equal_to, class _Proj1 = identity, class _Proj2 = identity>
+  template <input_iterator _I1,
+            sentinel_for<_I1> _S1,
+            input_iterator _I2,
+            sentinel_for<_I2> _S2,
+            class _Pred  = ranges::equal_to,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
     requires indirectly_comparable<_I1, _I2, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  mismatch_result<_I1, _I2> operator()(_I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2,
-                                       _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr mismatch_result<_I1, _I2> operator()(
+      _I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {})
+      const {
     return __go(std::move(__first1), __last1, std::move(__first2), __last2, __pred, __proj1, __proj2);
   }
 
-  template <input_range _R1, input_range _R2,
-            class _Pred = ranges::equal_to, class _Proj1 = identity, class _Proj2 = identity>
+  template <input_range _R1,
+            input_range _R2,
+            class _Pred  = ranges::equal_to,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
     requires indirectly_comparable<iterator_t<_R1>, iterator_t<_R2>, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  mismatch_result<borrowed_iterator_t<_R1>, borrowed_iterator_t<_R2>>
+  [[nodiscard]]
+  _LIBCPP_HIDE_FROM_ABI constexpr mismatch_result<borrowed_iterator_t<_R1>, borrowed_iterator_t<_R2>>
   operator()(_R1&& __r1, _R2&& __r2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
-    return __go(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2),
-                __pred, __proj1, __proj2);
+    return __go(
+        ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2), __pred, __proj1, __proj2);
   }
 };
 } // namespace __mismatch
 
 inline namespace __cpo {
-  constexpr inline auto mismatch = __mismatch::__fn{};
+constexpr inline auto mismatch = __mismatch::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -82,4 +95,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_MISMATCH_H
diff --git a/third_party/libcxx/__algorithm/ranges_move.h b/third_party/libcxx/__algorithm/ranges_move.h
index 5e06e903f..be869f36c 100644
--- a/third_party/libcxx/__algorithm/ranges_move.h
+++ b/third_party/libcxx/__algorithm/ranges_move.h
@@ -23,6 +23,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -34,33 +37,31 @@ using move_result = in_out_result<_InIter, _OutIter>;
 
 namespace __move {
 struct __fn {
-
   template <class _InIter, class _Sent, class _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  move_result<_InIter, _OutIter> __move_impl(_InIter __first, _Sent __last, _OutIter __result) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static move_result<_InIter, _OutIter>
+  __move_impl(_InIter __first, _Sent __last, _OutIter __result) {
     auto __ret = std::__move<_RangeAlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
     return {std::move(__ret.first), std::move(__ret.second)};
   }
 
   template <input_iterator _InIter, sentinel_for<_InIter> _Sent, weakly_incrementable _OutIter>
     requires indirectly_movable<_InIter, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  move_result<_InIter, _OutIter> operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr move_result<_InIter, _OutIter>
+  operator()(_InIter __first, _Sent __last, _OutIter __result) const {
     return __move_impl(std::move(__first), std::move(__last), std::move(__result));
   }
 
   template <input_range _Range, weakly_incrementable _OutIter>
     requires indirectly_movable<iterator_t<_Range>, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  move_result<borrowed_iterator_t<_Range>, _OutIter> operator()(_Range&& __range, _OutIter __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr move_result<borrowed_iterator_t<_Range>, _OutIter>
+  operator()(_Range&& __range, _OutIter __result) const {
     return __move_impl(ranges::begin(__range), ranges::end(__range), std::move(__result));
   }
-
 };
 } // namespace __move
 
 inline namespace __cpo {
-  inline constexpr auto move = __move::__fn{};
+inline constexpr auto move = __move::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -68,4 +69,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_MOVE_H
diff --git a/third_party/libcxx/__algorithm/ranges_move_backward.h b/third_party/libcxx/__algorithm/ranges_move_backward.h
index 95c2c6612..6d4071a33 100644
--- a/third_party/libcxx/__algorithm/ranges_move_backward.h
+++ b/third_party/libcxx/__algorithm/ranges_move_backward.h
@@ -25,6 +25,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -36,33 +39,31 @@ using move_backward_result = in_out_result<_InIter, _OutIter>;
 
 namespace __move_backward {
 struct __fn {
-
   template <class _InIter, class _Sent, class _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  move_backward_result<_InIter, _OutIter> __move_backward_impl(_InIter __first, _Sent __last, _OutIter __result) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static move_backward_result<_InIter, _OutIter>
+  __move_backward_impl(_InIter __first, _Sent __last, _OutIter __result) {
     auto __ret = std::__move_backward<_RangeAlgPolicy>(std::move(__first), std::move(__last), std::move(__result));
     return {std::move(__ret.first), std::move(__ret.second)};
   }
 
   template <bidirectional_iterator _InIter, sentinel_for<_InIter> _Sent, bidirectional_iterator _OutIter>
     requires indirectly_movable<_InIter, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  move_backward_result<_InIter, _OutIter> operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr move_backward_result<_InIter, _OutIter>
+  operator()(_InIter __first, _Sent __last, _OutIter __result) const {
     return __move_backward_impl(std::move(__first), std::move(__last), std::move(__result));
   }
 
   template <bidirectional_range _Range, bidirectional_iterator _Iter>
     requires indirectly_movable<iterator_t<_Range>, _Iter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  move_backward_result<borrowed_iterator_t<_Range>, _Iter> operator()(_Range&& __range, _Iter __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr move_backward_result<borrowed_iterator_t<_Range>, _Iter>
+  operator()(_Range&& __range, _Iter __result) const {
     return __move_backward_impl(ranges::begin(__range), ranges::end(__range), std::move(__result));
   }
-
 };
 } // namespace __move_backward
 
 inline namespace __cpo {
-  inline constexpr auto move_backward = __move_backward::__fn{};
+inline constexpr auto move_backward = __move_backward::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -70,4 +71,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_MOVE_BACKWARD_H
diff --git a/third_party/libcxx/__algorithm/ranges_next_permutation.h b/third_party/libcxx/__algorithm/ranges_next_permutation.h
index 9ebab3ea7..18535e0a6 100644
--- a/third_party/libcxx/__algorithm/ranges_next_permutation.h
+++ b/third_party/libcxx/__algorithm/ranges_next_permutation.h
@@ -28,6 +28,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -70,4 +73,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_NEXT_PERMUTATION_H
diff --git a/third_party/libcxx/__algorithm/ranges_none_of.h b/third_party/libcxx/__algorithm/ranges_none_of.h
index 39940adbb..7df3c1829 100644
--- a/third_party/libcxx/__algorithm/ranges_none_of.h
+++ b/third_party/libcxx/__algorithm/ranges_none_of.h
@@ -22,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -29,10 +32,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __none_of {
 struct __fn {
-
   template <class _Iter, class _Sent, class _Proj, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  bool __none_of_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static bool
+  __none_of_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
     for (; __first != __last; ++__first) {
       if (std::invoke(__pred, std::invoke(__proj, *__first)))
         return false;
@@ -40,24 +42,27 @@ struct __fn {
     return true;
   }
 
-  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+  template <input_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Iter __first, _Sent __last, _Pred __pred = {}, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Iter __first, _Sent __last, _Pred __pred = {}, _Proj __proj = {}) const {
     return __none_of_impl(std::move(__first), std::move(__last), __pred, __proj);
   }
 
-  template <input_range _Range, class _Proj = identity,
+  template <input_range _Range,
+            class _Proj = identity,
             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  bool operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
     return __none_of_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
   }
 };
 } // namespace __none_of
 
 inline namespace __cpo {
-  inline constexpr auto none_of = __none_of::__fn{};
+inline constexpr auto none_of = __none_of::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -65,4 +70,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_NONE_OF_H
diff --git a/third_party/libcxx/__algorithm/ranges_nth_element.h b/third_party/libcxx/__algorithm/ranges_nth_element.h
index 96bf33b07..90ade9efe 100644
--- a/third_party/libcxx/__algorithm/ranges_nth_element.h
+++ b/third_party/libcxx/__algorithm/ranges_nth_element.h
@@ -31,6 +31,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -40,8 +43,8 @@ namespace __nth_element {
 
 struct __fn {
   template <class _Iter, class _Sent, class _Comp, class _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  _Iter __nth_element_fn_impl(_Iter __first, _Iter __nth, _Sent __last, _Comp& __comp, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter
+  __nth_element_fn_impl(_Iter __first, _Iter __nth, _Sent __last, _Comp& __comp, _Proj& __proj) {
     auto __last_iter = ranges::next(__first, __last);
 
     auto&& __projected_comp = std::__make_projected(__comp, __proj);
@@ -52,16 +55,15 @@ struct __fn {
 
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<_Iter, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Iter __nth, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Iter __nth, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return __nth_element_fn_impl(std::move(__first), std::move(__nth), std::move(__last), __comp, __proj);
   }
 
   template <random_access_range _Range, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<iterator_t<_Range>, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __r, iterator_t<_Range> __nth, _Comp __comp = {},
-                                         _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __r, iterator_t<_Range> __nth, _Comp __comp = {}, _Proj __proj = {}) const {
     return __nth_element_fn_impl(ranges::begin(__r), std::move(__nth), ranges::end(__r), __comp, __proj);
   }
 };
@@ -69,7 +71,7 @@ struct __fn {
 } // namespace __nth_element
 
 inline namespace __cpo {
-  inline constexpr auto nth_element = __nth_element::__fn{};
+inline constexpr auto nth_element = __nth_element::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -77,4 +79,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_NTH_ELEMENT_H
diff --git a/third_party/libcxx/__algorithm/ranges_partial_sort.h b/third_party/libcxx/__algorithm/ranges_partial_sort.h
index 4562c3544..c67247d2e 100644
--- a/third_party/libcxx/__algorithm/ranges_partial_sort.h
+++ b/third_party/libcxx/__algorithm/ranges_partial_sort.h
@@ -33,6 +33,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -42,24 +45,23 @@ namespace __partial_sort {
 
 struct __fn {
   template <class _Iter, class _Sent, class _Comp, class _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  _Iter __partial_sort_fn_impl(_Iter __first, _Iter __middle, _Sent __last, _Comp& __comp, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter
+  __partial_sort_fn_impl(_Iter __first, _Iter __middle, _Sent __last, _Comp& __comp, _Proj& __proj) {
     auto&& __projected_comp = std::__make_projected(__comp, __proj);
     return std::__partial_sort<_RangeAlgPolicy>(std::move(__first), std::move(__middle), __last, __projected_comp);
   }
 
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<_Iter, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Iter __middle, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Iter __middle, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return __partial_sort_fn_impl(std::move(__first), std::move(__middle), std::move(__last), __comp, __proj);
   }
 
   template <random_access_range _Range, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<iterator_t<_Range>, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __r, iterator_t<_Range> __middle, _Comp __comp = {},
-                                         _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __r, iterator_t<_Range> __middle, _Comp __comp = {}, _Proj __proj = {}) const {
     return __partial_sort_fn_impl(ranges::begin(__r), std::move(__middle), ranges::end(__r), __comp, __proj);
   }
 };
@@ -67,7 +69,7 @@ struct __fn {
 } // namespace __partial_sort
 
 inline namespace __cpo {
-  inline constexpr auto partial_sort = __partial_sort::__fn{};
+inline constexpr auto partial_sort = __partial_sort::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -75,4 +77,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_PARTIAL_SORT_H
diff --git a/third_party/libcxx/__algorithm/ranges_partial_sort_copy.h b/third_party/libcxx/__algorithm/ranges_partial_sort_copy.h
index 5401a374e..b3bdeb78f 100644
--- a/third_party/libcxx/__algorithm/ranges_partial_sort_copy.h
+++ b/third_party/libcxx/__algorithm/ranges_partial_sort_copy.h
@@ -30,6 +30,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -42,46 +45,63 @@ using partial_sort_copy_result = in_out_result<_InIter, _OutIter>;
 namespace __partial_sort_copy {
 
 struct __fn {
-
-  template <input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
-            random_access_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
-            class _Comp = ranges::less, class _Proj1 = identity, class _Proj2 = identity>
-  requires indirectly_copyable<_Iter1, _Iter2> && sortable<_Iter2, _Comp, _Proj2> &&
-           indirect_strict_weak_order<_Comp, projected<_Iter1, _Proj1>, projected<_Iter2, _Proj2>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  partial_sort_copy_result<_Iter1, _Iter2>
-  operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result_first, _Sent2 __result_last,
-             _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+  template <input_iterator _Iter1,
+            sentinel_for<_Iter1> _Sent1,
+            random_access_iterator _Iter2,
+            sentinel_for<_Iter2> _Sent2,
+            class _Comp  = ranges::less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires indirectly_copyable<_Iter1, _Iter2> && sortable<_Iter2, _Comp, _Proj2> &&
+             indirect_strict_weak_order<_Comp, projected<_Iter1, _Proj1>, projected<_Iter2, _Proj2>>
+  _LIBCPP_HIDE_FROM_ABI constexpr partial_sort_copy_result<_Iter1, _Iter2> operator()(
+      _Iter1 __first,
+      _Sent1 __last,
+      _Iter2 __result_first,
+      _Sent2 __result_last,
+      _Comp __comp   = {},
+      _Proj1 __proj1 = {},
+      _Proj2 __proj2 = {}) const {
     auto __result = std::__partial_sort_copy<_RangeAlgPolicy>(
-        std::move(__first), std::move(__last), std::move(__result_first), std::move(__result_last),
-        __comp, __proj1, __proj2
-    );
+        std::move(__first),
+        std::move(__last),
+        std::move(__result_first),
+        std::move(__result_last),
+        __comp,
+        __proj1,
+        __proj2);
     return {std::move(__result.first), std::move(__result.second)};
   }
 
-  template <input_range _Range1, random_access_range _Range2, class _Comp = ranges::less,
-            class _Proj1 = identity, class _Proj2 = identity>
-  requires indirectly_copyable<iterator_t<_Range1>, iterator_t<_Range2>> &&
-           sortable<iterator_t<_Range2>, _Comp, _Proj2> &&
-           indirect_strict_weak_order<_Comp, projected<iterator_t<_Range1>, _Proj1>,
-                                      projected<iterator_t<_Range2>, _Proj2>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  partial_sort_copy_result<borrowed_iterator_t<_Range1>, borrowed_iterator_t<_Range2>>
-  operator()(_Range1&& __range, _Range2&& __result_range, _Comp __comp = {},
-             _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+  template <input_range _Range1,
+            random_access_range _Range2,
+            class _Comp  = ranges::less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires indirectly_copyable<iterator_t<_Range1>, iterator_t<_Range2>> &&
+             sortable<iterator_t<_Range2>, _Comp, _Proj2> &&
+             indirect_strict_weak_order<_Comp,
+                                        projected<iterator_t<_Range1>, _Proj1>,
+                                        projected<iterator_t<_Range2>, _Proj2>>
+  _LIBCPP_HIDE_FROM_ABI constexpr partial_sort_copy_result<borrowed_iterator_t<_Range1>, borrowed_iterator_t<_Range2>>
+  operator()(
+      _Range1&& __range, _Range2&& __result_range, _Comp __comp = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
     auto __result = std::__partial_sort_copy<_RangeAlgPolicy>(
-        ranges::begin(__range), ranges::end(__range), ranges::begin(__result_range), ranges::end(__result_range),
-        __comp, __proj1, __proj2
-    );
+        ranges::begin(__range),
+        ranges::end(__range),
+        ranges::begin(__result_range),
+        ranges::end(__result_range),
+        __comp,
+        __proj1,
+        __proj2);
     return {std::move(__result.first), std::move(__result.second)};
   }
-
 };
 
 } // namespace __partial_sort_copy
 
 inline namespace __cpo {
-  inline constexpr auto partial_sort_copy = __partial_sort_copy::__fn{};
+inline constexpr auto partial_sort_copy = __partial_sort_copy::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -89,4 +109,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_PARTIAL_SORT_COPY_H
diff --git a/third_party/libcxx/__algorithm/ranges_partition.h b/third_party/libcxx/__algorithm/ranges_partition.h
index de839de12..a67ac4c96 100644
--- a/third_party/libcxx/__algorithm/ranges_partition.h
+++ b/third_party/libcxx/__algorithm/ranges_partition.h
@@ -32,6 +32,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -40,38 +43,39 @@ namespace ranges {
 namespace __partition {
 
 struct __fn {
-
   template <class _Iter, class _Sent, class _Proj, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI static constexpr
-  subrange<__remove_cvref_t<_Iter>> __partition_fn_impl(_Iter&& __first, _Sent&& __last, _Pred&& __pred, _Proj&& __proj) {
+  _LIBCPP_HIDE_FROM_ABI static constexpr subrange<__remove_cvref_t<_Iter>>
+  __partition_fn_impl(_Iter&& __first, _Sent&& __last, _Pred&& __pred, _Proj&& __proj) {
     auto&& __projected_pred = std::__make_projected(__pred, __proj);
-    auto __result = std::__partition<_RangeAlgPolicy>(
+    auto __result           = std::__partition<_RangeAlgPolicy>(
         std::move(__first), std::move(__last), __projected_pred, __iterator_concept<_Iter>());
 
     return {std::move(__result.first), std::move(__result.second)};
   }
 
-  template <permutable _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+  template <permutable _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  subrange<_Iter> operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+  operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
     return __partition_fn_impl(__first, __last, __pred, __proj);
   }
 
-  template <forward_range _Range, class _Proj = identity,
+  template <forward_range _Range,
+            class _Proj = identity,
             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
-  requires permutable<iterator_t<_Range>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_subrange_t<_Range> operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+    requires permutable<iterator_t<_Range>>
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
+  operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
     return __partition_fn_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
   }
-
 };
 
 } // namespace __partition
 
 inline namespace __cpo {
-  inline constexpr auto partition = __partition::__fn{};
+inline constexpr auto partition = __partition::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -79,4 +83,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_PARTITION_H
diff --git a/third_party/libcxx/__algorithm/ranges_partition_copy.h b/third_party/libcxx/__algorithm/ranges_partition_copy.h
index e398387bf..d60c865dd 100644
--- a/third_party/libcxx/__algorithm/ranges_partition_copy.h
+++ b/third_party/libcxx/__algorithm/ranges_partition_copy.h
@@ -26,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -38,14 +41,18 @@ using partition_copy_result = in_out_out_result<_InIter, _OutIter1, _OutIter2>;
 namespace __partition_copy {
 
 struct __fn {
-
   // TODO(ranges): delegate to the classic algorithm.
   template <class _InIter, class _Sent, class _OutIter1, class _OutIter2, class _Proj, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  static partition_copy_result<
-      __remove_cvref_t<_InIter>, __remove_cvref_t<_OutIter1>, __remove_cvref_t<_OutIter2>
-  > __partition_copy_fn_impl( _InIter&& __first, _Sent&& __last, _OutIter1&& __out_true, _OutIter2&& __out_false,
-      _Pred& __pred, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static partition_copy_result<__remove_cvref_t<_InIter>,
+                                                               __remove_cvref_t<_OutIter1>,
+                                                               __remove_cvref_t<_OutIter2> >
+  __partition_copy_fn_impl(
+      _InIter&& __first,
+      _Sent&& __last,
+      _OutIter1&& __out_true,
+      _OutIter2&& __out_false,
+      _Pred& __pred,
+      _Proj& __proj) {
     for (; __first != __last; ++__first) {
       if (std::invoke(__pred, std::invoke(__proj, *__first))) {
         *__out_true = *__first;
@@ -60,34 +67,37 @@ struct __fn {
     return {std::move(__first), std::move(__out_true), std::move(__out_false)};
   }
 
-  template <input_iterator _InIter, sentinel_for<_InIter> _Sent,
-            weakly_incrementable _OutIter1, weakly_incrementable _OutIter2,
-            class _Proj = identity, indirect_unary_predicate<projected<_InIter, _Proj>> _Pred>
-  requires indirectly_copyable<_InIter, _OutIter1> && indirectly_copyable<_InIter, _OutIter2>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  partition_copy_result<_InIter, _OutIter1, _OutIter2>
-  operator()(_InIter __first, _Sent __last, _OutIter1 __out_true, _OutIter2 __out_false,
-             _Pred __pred, _Proj __proj = {}) const {
+  template <input_iterator _InIter,
+            sentinel_for<_InIter> _Sent,
+            weakly_incrementable _OutIter1,
+            weakly_incrementable _OutIter2,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<_InIter, _Proj>> _Pred>
+    requires indirectly_copyable<_InIter, _OutIter1> && indirectly_copyable<_InIter, _OutIter2>
+  _LIBCPP_HIDE_FROM_ABI constexpr partition_copy_result<_InIter, _OutIter1, _OutIter2> operator()(
+      _InIter __first, _Sent __last, _OutIter1 __out_true, _OutIter2 __out_false, _Pred __pred, _Proj __proj = {})
+      const {
     return __partition_copy_fn_impl(
         std::move(__first), std::move(__last), std::move(__out_true), std::move(__out_false), __pred, __proj);
   }
 
-  template <input_range _Range, weakly_incrementable _OutIter1, weakly_incrementable _OutIter2,
-            class _Proj = identity, indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
-  requires indirectly_copyable<iterator_t<_Range>, _OutIter1> && indirectly_copyable<iterator_t<_Range>, _OutIter2>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  partition_copy_result<borrowed_iterator_t<_Range>, _OutIter1, _OutIter2>
+  template <input_range _Range,
+            weakly_incrementable _OutIter1,
+            weakly_incrementable _OutIter2,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+    requires indirectly_copyable<iterator_t<_Range>, _OutIter1> && indirectly_copyable<iterator_t<_Range>, _OutIter2>
+  _LIBCPP_HIDE_FROM_ABI constexpr partition_copy_result<borrowed_iterator_t<_Range>, _OutIter1, _OutIter2>
   operator()(_Range&& __range, _OutIter1 __out_true, _OutIter2 __out_false, _Pred __pred, _Proj __proj = {}) const {
     return __partition_copy_fn_impl(
         ranges::begin(__range), ranges::end(__range), std::move(__out_true), std::move(__out_false), __pred, __proj);
   }
-
 };
 
 } // namespace __partition_copy
 
 inline namespace __cpo {
-  inline constexpr auto partition_copy = __partition_copy::__fn{};
+inline constexpr auto partition_copy = __partition_copy::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -95,4 +105,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_PARTITION_COPY_H
diff --git a/third_party/libcxx/__algorithm/ranges_partition_point.h b/third_party/libcxx/__algorithm/ranges_partition_point.h
index 129ebb6c6..c5b11b5fe 100644
--- a/third_party/libcxx/__algorithm/ranges_partition_point.h
+++ b/third_party/libcxx/__algorithm/ranges_partition_point.h
@@ -27,6 +27,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -35,16 +38,15 @@ namespace ranges {
 namespace __partition_point {
 
 struct __fn {
-
   // TODO(ranges): delegate to the classic algorithm.
   template <class _Iter, class _Sent, class _Proj, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  static _Iter __partition_point_fn_impl(_Iter&& __first, _Sent&& __last, _Pred& __pred, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter
+  __partition_point_fn_impl(_Iter&& __first, _Sent&& __last, _Pred& __pred, _Proj& __proj) {
     auto __len = ranges::distance(__first, __last);
 
     while (__len != 0) {
       auto __half_len = std::__half_positive(__len);
-      auto __mid = ranges::next(__first, __half_len);
+      auto __mid      = ranges::next(__first, __half_len);
 
       if (std::invoke(__pred, std::invoke(__proj, *__mid))) {
         __first = ++__mid;
@@ -58,26 +60,27 @@ struct __fn {
     return __first;
   }
 
-  template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
     return __partition_point_fn_impl(std::move(__first), std::move(__last), __pred, __proj);
   }
 
-  template <forward_range _Range, class _Proj = identity,
+  template <forward_range _Range,
+            class _Proj = identity,
             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
     return __partition_point_fn_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
   }
-
 };
 
 } // namespace __partition_point
 
 inline namespace __cpo {
-  inline constexpr auto partition_point = __partition_point::__fn{};
+inline constexpr auto partition_point = __partition_point::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -85,4 +88,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_PARTITION_POINT_H
diff --git a/third_party/libcxx/__algorithm/ranges_pop_heap.h b/third_party/libcxx/__algorithm/ranges_pop_heap.h
index 54ea97db7..01f92c0f2 100644
--- a/third_party/libcxx/__algorithm/ranges_pop_heap.h
+++ b/third_party/libcxx/__algorithm/ranges_pop_heap.h
@@ -32,6 +32,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -41,10 +44,10 @@ namespace __pop_heap {
 
 struct __fn {
   template <class _Iter, class _Sent, class _Comp, class _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  _Iter __pop_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter
+  __pop_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
     auto __last_iter = ranges::next(__first, __last);
-    auto __len = __last_iter - __first;
+    auto __len       = __last_iter - __first;
 
     auto&& __projected_comp = std::__make_projected(__comp, __proj);
     std::__pop_heap<_RangeAlgPolicy>(std::move(__first), __last_iter, __projected_comp, __len);
@@ -54,15 +57,15 @@ struct __fn {
 
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<_Iter, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return __pop_heap_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
   template <random_access_range _Range, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<iterator_t<_Range>, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     return __pop_heap_fn_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
   }
 };
@@ -70,7 +73,7 @@ struct __fn {
 } // namespace __pop_heap
 
 inline namespace __cpo {
-  inline constexpr auto pop_heap = __pop_heap::__fn{};
+inline constexpr auto pop_heap = __pop_heap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -78,4 +81,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_POP_HEAP_H
diff --git a/third_party/libcxx/__algorithm/ranges_prev_permutation.h b/third_party/libcxx/__algorithm/ranges_prev_permutation.h
index bf062874a..225cee9b7 100644
--- a/third_party/libcxx/__algorithm/ranges_prev_permutation.h
+++ b/third_party/libcxx/__algorithm/ranges_prev_permutation.h
@@ -28,6 +28,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -40,9 +43,7 @@ using prev_permutation_result = in_found_result<_InIter>;
 namespace __prev_permutation {
 
 struct __fn {
-
-  template <bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
-            class _Comp = ranges::less, class _Proj = identity>
+  template <bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<_Iter, _Comp, _Proj>
   _LIBCPP_HIDE_FROM_ABI constexpr prev_permutation_result<_Iter>
   operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
@@ -51,8 +52,7 @@ struct __fn {
     return {std::move(__result.first), std::move(__result.second)};
   }
 
-  template <bidirectional_range _Range,
-            class _Comp = ranges::less, class _Proj = identity>
+  template <bidirectional_range _Range, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<iterator_t<_Range>, _Comp, _Proj>
   _LIBCPP_HIDE_FROM_ABI constexpr prev_permutation_result<borrowed_iterator_t<_Range>>
   operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
@@ -60,7 +60,6 @@ struct __fn {
         ranges::begin(__range), ranges::end(__range), std::__make_projected(__comp, __proj));
     return {std::move(__result.first), std::move(__result.second)};
   }
-
 };
 
 } // namespace __prev_permutation
@@ -74,4 +73,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_PREV_PERMUTATION_H
diff --git a/third_party/libcxx/__algorithm/ranges_push_heap.h b/third_party/libcxx/__algorithm/ranges_push_heap.h
index 6e65d11d0..9d187af38 100644
--- a/third_party/libcxx/__algorithm/ranges_push_heap.h
+++ b/third_party/libcxx/__algorithm/ranges_push_heap.h
@@ -32,6 +32,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -41,8 +44,8 @@ namespace __push_heap {
 
 struct __fn {
   template <class _Iter, class _Sent, class _Comp, class _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  _Iter __push_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter
+  __push_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
     auto __last_iter = ranges::next(__first, __last);
 
     auto&& __projected_comp = std::__make_projected(__comp, __proj);
@@ -53,15 +56,15 @@ struct __fn {
 
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<_Iter, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return __push_heap_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
   template <random_access_range _Range, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<iterator_t<_Range>, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     return __push_heap_fn_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
   }
 };
@@ -69,7 +72,7 @@ struct __fn {
 } // namespace __push_heap
 
 inline namespace __cpo {
-  inline constexpr auto push_heap = __push_heap::__fn{};
+inline constexpr auto push_heap = __push_heap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -77,4 +80,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_PUSH_HEAP_H
diff --git a/third_party/libcxx/__algorithm/ranges_remove.h b/third_party/libcxx/__algorithm/ranges_remove.h
index 6dd48e087..17c3a2c5c 100644
--- a/third_party/libcxx/__algorithm/ranges_remove.h
+++ b/third_party/libcxx/__algorithm/ranges_remove.h
@@ -25,6 +25,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -32,28 +35,27 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __remove {
 struct __fn {
-
   template <permutable _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity>
     requires indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type*>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  subrange<_Iter> operator()(_Iter __first, _Sent __last, const _Type& __value, _Proj __proj = {}) const {
-    auto __pred = [&](auto&& __other) { return __value == __other; };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+  operator()(_Iter __first, _Sent __last, const _Type& __value, _Proj __proj = {}) const {
+    auto __pred = [&](auto&& __other) -> bool { return __value == __other; };
     return ranges::__remove_if_impl(std::move(__first), std::move(__last), __pred, __proj);
   }
 
   template <forward_range _Range, class _Type, class _Proj = identity>
-    requires permutable<iterator_t<_Range>>
-          && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type*>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_subrange_t<_Range> operator()(_Range&& __range, const _Type& __value, _Proj __proj = {}) const {
-    auto __pred = [&](auto&& __other) { return __value == __other; };
+    requires permutable<iterator_t<_Range>> &&
+             indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type*>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
+  operator()(_Range&& __range, const _Type& __value, _Proj __proj = {}) const {
+    auto __pred = [&](auto&& __other) -> bool { return __value == __other; };
     return ranges::__remove_if_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
   }
 };
 } // namespace __remove
 
 inline namespace __cpo {
-  inline constexpr auto remove = __remove::__fn{};
+inline constexpr auto remove = __remove::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -61,4 +63,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_H
diff --git a/third_party/libcxx/__algorithm/ranges_remove_copy.h b/third_party/libcxx/__algorithm/ranges_remove_copy.h
index a9a19c17f..84529ecea 100644
--- a/third_party/libcxx/__algorithm/ranges_remove_copy.h
+++ b/third_party/libcxx/__algorithm/ranges_remove_copy.h
@@ -26,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -37,35 +40,35 @@ using remove_copy_result = in_out_result<_InIter, _OutIter>;
 
 namespace __remove_copy {
 
-  struct __fn {
-    template <input_iterator _InIter,
-              sentinel_for<_InIter> _Sent,
-              weakly_incrementable _OutIter,
-              class _Type,
-              class _Proj = identity>
-      requires indirectly_copyable<_InIter, _OutIter> &&
-               indirect_binary_predicate<ranges::equal_to, projected<_InIter, _Proj>, const _Type*>
-    _LIBCPP_HIDE_FROM_ABI constexpr remove_copy_result<_InIter, _OutIter>
-    operator()(_InIter __first, _Sent __last, _OutIter __result, const _Type& __value, _Proj __proj = {}) const {
-      auto __pred = [&](auto&& __val) { return __value == __val; };
-      return ranges::__remove_copy_if_impl(std::move(__first), std::move(__last), std::move(__result), __pred, __proj);
-    }
+struct __fn {
+  template <input_iterator _InIter,
+            sentinel_for<_InIter> _Sent,
+            weakly_incrementable _OutIter,
+            class _Type,
+            class _Proj = identity>
+    requires indirectly_copyable<_InIter, _OutIter> &&
+             indirect_binary_predicate<ranges::equal_to, projected<_InIter, _Proj>, const _Type*>
+  _LIBCPP_HIDE_FROM_ABI constexpr remove_copy_result<_InIter, _OutIter>
+  operator()(_InIter __first, _Sent __last, _OutIter __result, const _Type& __value, _Proj __proj = {}) const {
+    auto __pred = [&](auto&& __val) -> bool { return __value == __val; };
+    return ranges::__remove_copy_if_impl(std::move(__first), std::move(__last), std::move(__result), __pred, __proj);
+  }
 
-    template <input_range _Range, weakly_incrementable _OutIter, class _Type, class _Proj = identity>
-      requires indirectly_copyable<iterator_t<_Range>, _OutIter> &&
-               indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type*>
-    _LIBCPP_HIDE_FROM_ABI constexpr remove_copy_result<borrowed_iterator_t<_Range>, _OutIter>
-    operator()(_Range&& __range, _OutIter __result, const _Type& __value, _Proj __proj = {}) const {
-      auto __pred = [&](auto&& __val) { return __value == __val; };
-      return ranges::__remove_copy_if_impl(
-          ranges::begin(__range), ranges::end(__range), std::move(__result), __pred, __proj);
-    }
-  };
+  template <input_range _Range, weakly_incrementable _OutIter, class _Type, class _Proj = identity>
+    requires indirectly_copyable<iterator_t<_Range>, _OutIter> &&
+             indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type*>
+  _LIBCPP_HIDE_FROM_ABI constexpr remove_copy_result<borrowed_iterator_t<_Range>, _OutIter>
+  operator()(_Range&& __range, _OutIter __result, const _Type& __value, _Proj __proj = {}) const {
+    auto __pred = [&](auto&& __val) -> bool { return __value == __val; };
+    return ranges::__remove_copy_if_impl(
+        ranges::begin(__range), ranges::end(__range), std::move(__result), __pred, __proj);
+  }
+};
 
 } // namespace __remove_copy
 
 inline namespace __cpo {
-  inline constexpr auto remove_copy = __remove_copy::__fn{};
+inline constexpr auto remove_copy = __remove_copy::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -73,4 +76,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_COPY_H
diff --git a/third_party/libcxx/__algorithm/ranges_remove_copy_if.h b/third_party/libcxx/__algorithm/ranges_remove_copy_if.h
index e6d043e36..56fe01753 100644
--- a/third_party/libcxx/__algorithm/ranges_remove_copy_if.h
+++ b/third_party/libcxx/__algorithm/ranges_remove_copy_if.h
@@ -29,6 +29,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -52,34 +55,34 @@ __remove_copy_if_impl(_InIter __first, _Sent __last, _OutIter __result, _Pred& _
 
 namespace __remove_copy_if {
 
-  struct __fn {
-    template <input_iterator _InIter,
-              sentinel_for<_InIter> _Sent,
-              weakly_incrementable _OutIter,
-              class _Proj = identity,
-              indirect_unary_predicate<projected<_InIter, _Proj>> _Pred>
-      requires indirectly_copyable<_InIter, _OutIter>
-    _LIBCPP_HIDE_FROM_ABI constexpr remove_copy_if_result<_InIter, _OutIter>
-    operator()(_InIter __first, _Sent __last, _OutIter __result, _Pred __pred, _Proj __proj = {}) const {
-      return ranges::__remove_copy_if_impl(std::move(__first), std::move(__last), std::move(__result), __pred, __proj);
-    }
+struct __fn {
+  template <input_iterator _InIter,
+            sentinel_for<_InIter> _Sent,
+            weakly_incrementable _OutIter,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<_InIter, _Proj>> _Pred>
+    requires indirectly_copyable<_InIter, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr remove_copy_if_result<_InIter, _OutIter>
+  operator()(_InIter __first, _Sent __last, _OutIter __result, _Pred __pred, _Proj __proj = {}) const {
+    return ranges::__remove_copy_if_impl(std::move(__first), std::move(__last), std::move(__result), __pred, __proj);
+  }
 
-    template <input_range _Range,
-              weakly_incrementable _OutIter,
-              class _Proj = identity,
-              indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
-      requires indirectly_copyable<iterator_t<_Range>, _OutIter>
-    _LIBCPP_HIDE_FROM_ABI constexpr remove_copy_if_result<borrowed_iterator_t<_Range>, _OutIter>
-    operator()(_Range&& __range, _OutIter __result, _Pred __pred, _Proj __proj = {}) const {
-      return ranges::__remove_copy_if_impl(
-          ranges::begin(__range), ranges::end(__range), std::move(__result), __pred, __proj);
-    }
-  };
+  template <input_range _Range,
+            weakly_incrementable _OutIter,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+    requires indirectly_copyable<iterator_t<_Range>, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr remove_copy_if_result<borrowed_iterator_t<_Range>, _OutIter>
+  operator()(_Range&& __range, _OutIter __result, _Pred __pred, _Proj __proj = {}) const {
+    return ranges::__remove_copy_if_impl(
+        ranges::begin(__range), ranges::end(__range), std::move(__result), __pred, __proj);
+  }
+};
 
 } // namespace __remove_copy_if
 
 inline namespace __cpo {
-  inline constexpr auto remove_copy_if = __remove_copy_if::__fn{};
+inline constexpr auto remove_copy_if = __remove_copy_if::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -87,4 +90,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_COPY_IF_H
diff --git a/third_party/libcxx/__algorithm/ranges_remove_if.h b/third_party/libcxx/__algorithm/ranges_remove_if.h
index 7507c21b8..0ea5d9a01 100644
--- a/third_party/libcxx/__algorithm/ranges_remove_if.h
+++ b/third_party/libcxx/__algorithm/ranges_remove_if.h
@@ -27,6 +27,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -34,8 +37,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 
 template <class _Iter, class _Sent, class _Proj, class _Pred>
-_LIBCPP_HIDE_FROM_ABI constexpr
-subrange<_Iter> __remove_if_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
+_LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+__remove_if_impl(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
   auto __new_end = ranges::__find_if_impl(__first, __last, __pred, __proj);
   if (__new_end == __last)
     return {__new_end, __new_end};
@@ -52,12 +55,12 @@ subrange<_Iter> __remove_if_impl(_Iter __first, _Sent __last, _Pred& __pred, _Pr
 
 namespace __remove_if {
 struct __fn {
-
-  template <permutable _Iter, sentinel_for<_Iter> _Sent,
+  template <permutable _Iter,
+            sentinel_for<_Iter> _Sent,
             class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  subrange<_Iter> operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+  operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
     return ranges::__remove_if_impl(std::move(__first), std::move(__last), __pred, __proj);
   }
 
@@ -65,16 +68,15 @@ struct __fn {
             class _Proj = identity,
             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
     requires permutable<iterator_t<_Range>>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_subrange_t<_Range> operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
+  operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
     return ranges::__remove_if_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
   }
-
 };
 } // namespace __remove_if
 
 inline namespace __cpo {
-  inline constexpr auto remove_if = __remove_if::__fn{};
+inline constexpr auto remove_if = __remove_if::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -82,4 +84,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_REMOVE_IF_H
diff --git a/third_party/libcxx/__algorithm/ranges_replace.h b/third_party/libcxx/__algorithm/ranges_replace.h
index 258e25d05..2b88dc032 100644
--- a/third_party/libcxx/__algorithm/ranges_replace.h
+++ b/third_party/libcxx/__algorithm/ranges_replace.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -31,39 +34,28 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __replace {
 struct __fn {
-
-  template <input_iterator _Iter, sentinel_for<_Iter> _Sent,
-            class _Type1,
-            class _Type2,
-            class _Proj = identity>
-    requires indirectly_writable<_Iter, const _Type2&>
-          && indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type1*>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last,
-                   const _Type1& __old_value,
-                   const _Type2& __new_value,
-                   _Proj __proj = {}) const {
-    auto __pred = [&](const auto& __val) { return __val == __old_value; };
+  template <input_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type1, class _Type2, class _Proj = identity>
+    requires indirectly_writable<_Iter, const _Type2&> &&
+             indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Type1*>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter operator()(
+      _Iter __first, _Sent __last, const _Type1& __old_value, const _Type2& __new_value, _Proj __proj = {}) const {
+    auto __pred = [&](const auto& __val) -> bool { return __val == __old_value; };
     return ranges::__replace_if_impl(std::move(__first), std::move(__last), __pred, __new_value, __proj);
   }
 
-  template <input_range _Range,
-            class _Type1,
-            class _Type2,
-            class _Proj = identity>
-    requires indirectly_writable<iterator_t<_Range>, const _Type2&>
-          && indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type1*>
+  template <input_range _Range, class _Type1, class _Type2, class _Proj = identity>
+    requires indirectly_writable<iterator_t<_Range>, const _Type2&> &&
+             indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _Type1*>
   _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
   operator()(_Range&& __range, const _Type1& __old_value, const _Type2& __new_value, _Proj __proj = {}) const {
-    auto __pred = [&](auto&& __val) { return __val == __old_value; };
+    auto __pred = [&](auto&& __val) -> bool { return __val == __old_value; };
     return ranges::__replace_if_impl(ranges::begin(__range), ranges::end(__range), __pred, __new_value, __proj);
   }
-
 };
 } // namespace __replace
 
 inline namespace __cpo {
-  inline constexpr auto replace = __replace::__fn{};
+inline constexpr auto replace = __replace::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -71,4 +63,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_H
diff --git a/third_party/libcxx/__algorithm/ranges_replace_copy.h b/third_party/libcxx/__algorithm/ranges_replace_copy.h
index 79eaebb41..633f993e5 100644
--- a/third_party/libcxx/__algorithm/ranges_replace_copy.h
+++ b/third_party/libcxx/__algorithm/ranges_replace_copy.h
@@ -26,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -37,50 +40,47 @@ using replace_copy_result = in_out_result<_InIter, _OutIter>;
 
 namespace __replace_copy {
 
-  struct __fn {
-    template <input_iterator _InIter,
-              sentinel_for<_InIter> _Sent,
-              class _OldType,
-              class _NewType,
-              output_iterator<const _NewType&> _OutIter,
-              class _Proj = identity>
-      requires indirectly_copyable<_InIter, _OutIter> &&
-               indirect_binary_predicate<ranges::equal_to, projected<_InIter, _Proj>, const _OldType*>
-    _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_result<_InIter, _OutIter>
-    operator()(_InIter __first,
-               _Sent __last,
-               _OutIter __result,
-               const _OldType& __old_value,
-               const _NewType& __new_value,
-               _Proj __proj = {}) const {
-      auto __pred = [&](const auto& __value) { return __value == __old_value; };
-      return ranges::__replace_copy_if_impl(
-          std::move(__first), std::move(__last), std::move(__result), __pred, __new_value, __proj);
-    }
+struct __fn {
+  template <input_iterator _InIter,
+            sentinel_for<_InIter> _Sent,
+            class _OldType,
+            class _NewType,
+            output_iterator<const _NewType&> _OutIter,
+            class _Proj = identity>
+    requires indirectly_copyable<_InIter, _OutIter> &&
+             indirect_binary_predicate<ranges::equal_to, projected<_InIter, _Proj>, const _OldType*>
+  _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_result<_InIter, _OutIter>
+  operator()(_InIter __first,
+             _Sent __last,
+             _OutIter __result,
+             const _OldType& __old_value,
+             const _NewType& __new_value,
+             _Proj __proj = {}) const {
+    auto __pred = [&](const auto& __value) -> bool { return __value == __old_value; };
+    return ranges::__replace_copy_if_impl(
+        std::move(__first), std::move(__last), std::move(__result), __pred, __new_value, __proj);
+  }
 
-    template <input_range _Range,
-              class _OldType,
-              class _NewType,
-              output_iterator<const _NewType&> _OutIter,
-              class _Proj = identity>
-      requires indirectly_copyable<iterator_t<_Range>, _OutIter> &&
-               indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _OldType*>
-    _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_result<borrowed_iterator_t<_Range>, _OutIter>
-    operator()(_Range&& __range,
-               _OutIter __result,
-               const _OldType& __old_value,
-               const _NewType& __new_value,
-               _Proj __proj = {}) const {
-      auto __pred = [&](const auto& __value) { return __value == __old_value; };
-      return ranges::__replace_copy_if_impl(
-          ranges::begin(__range), ranges::end(__range), std::move(__result), __pred, __new_value, __proj);
-    }
-  };
+  template <input_range _Range,
+            class _OldType,
+            class _NewType,
+            output_iterator<const _NewType&> _OutIter,
+            class _Proj = identity>
+    requires indirectly_copyable<iterator_t<_Range>, _OutIter> &&
+             indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _Proj>, const _OldType*>
+  _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_result<borrowed_iterator_t<_Range>, _OutIter> operator()(
+      _Range&& __range, _OutIter __result, const _OldType& __old_value, const _NewType& __new_value, _Proj __proj = {})
+      const {
+    auto __pred = [&](const auto& __value) -> bool { return __value == __old_value; };
+    return ranges::__replace_copy_if_impl(
+        ranges::begin(__range), ranges::end(__range), std::move(__result), __pred, __new_value, __proj);
+  }
+};
 
 } // namespace __replace_copy
 
 inline namespace __cpo {
-  inline constexpr auto replace_copy = __replace_copy::__fn{};
+inline constexpr auto replace_copy = __replace_copy::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -88,4 +88,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_COPY_H
diff --git a/third_party/libcxx/__algorithm/ranges_replace_copy_if.h b/third_party/libcxx/__algorithm/ranges_replace_copy_if.h
index 8ff2eba8f..e065c3ac0 100644
--- a/third_party/libcxx/__algorithm/ranges_replace_copy_if.h
+++ b/third_party/libcxx/__algorithm/ranges_replace_copy_if.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -51,38 +54,38 @@ _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_if_result<_InIter, _OutIter> __repl
 
 namespace __replace_copy_if {
 
-  struct __fn {
-    template <input_iterator _InIter,
-              sentinel_for<_InIter> _Sent,
-              class _Type,
-              output_iterator<const _Type&> _OutIter,
-              class _Proj = identity,
-              indirect_unary_predicate<projected<_InIter, _Proj>> _Pred>
-      requires indirectly_copyable<_InIter, _OutIter>
-    _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_if_result<_InIter, _OutIter> operator()(
-        _InIter __first, _Sent __last, _OutIter __result, _Pred __pred, const _Type& __new_value, _Proj __proj = {})
-        const {
-      return ranges::__replace_copy_if_impl(
-          std::move(__first), std::move(__last), std::move(__result), __pred, __new_value, __proj);
-    }
+struct __fn {
+  template <input_iterator _InIter,
+            sentinel_for<_InIter> _Sent,
+            class _Type,
+            output_iterator<const _Type&> _OutIter,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<_InIter, _Proj>> _Pred>
+    requires indirectly_copyable<_InIter, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_if_result<_InIter, _OutIter> operator()(
+      _InIter __first, _Sent __last, _OutIter __result, _Pred __pred, const _Type& __new_value, _Proj __proj = {})
+      const {
+    return ranges::__replace_copy_if_impl(
+        std::move(__first), std::move(__last), std::move(__result), __pred, __new_value, __proj);
+  }
 
-    template <input_range _Range,
-              class _Type,
-              output_iterator<const _Type&> _OutIter,
-              class _Proj = identity,
-              indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
-      requires indirectly_copyable<iterator_t<_Range>, _OutIter>
-    _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_if_result<borrowed_iterator_t<_Range>, _OutIter>
-    operator()(_Range&& __range, _OutIter __result, _Pred __pred, const _Type& __new_value, _Proj __proj = {}) const {
-      return ranges::__replace_copy_if_impl(
-          ranges::begin(__range), ranges::end(__range), std::move(__result), __pred, __new_value, __proj);
-    }
-  };
+  template <input_range _Range,
+            class _Type,
+            output_iterator<const _Type&> _OutIter,
+            class _Proj = identity,
+            indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
+    requires indirectly_copyable<iterator_t<_Range>, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr replace_copy_if_result<borrowed_iterator_t<_Range>, _OutIter>
+  operator()(_Range&& __range, _OutIter __result, _Pred __pred, const _Type& __new_value, _Proj __proj = {}) const {
+    return ranges::__replace_copy_if_impl(
+        ranges::begin(__range), ranges::end(__range), std::move(__result), __pred, __new_value, __proj);
+  }
+};
 
 } // namespace __replace_copy_if
 
 inline namespace __cpo {
-  inline constexpr auto replace_copy_if = __replace_copy_if::__fn{};
+inline constexpr auto replace_copy_if = __replace_copy_if::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -90,4 +93,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_COPY_IF_H
diff --git a/third_party/libcxx/__algorithm/ranges_replace_if.h b/third_party/libcxx/__algorithm/ranges_replace_if.h
index 2b7dda9e6..6445f42ae 100644
--- a/third_party/libcxx/__algorithm/ranges_replace_if.h
+++ b/third_party/libcxx/__algorithm/ranges_replace_if.h
@@ -23,6 +23,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -30,8 +33,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 
 template <class _Iter, class _Sent, class _Type, class _Proj, class _Pred>
-_LIBCPP_HIDE_FROM_ABI constexpr
-_Iter __replace_if_impl(_Iter __first, _Sent __last, _Pred& __pred, const _Type& __new_value, _Proj& __proj) {
+_LIBCPP_HIDE_FROM_ABI constexpr _Iter
+__replace_if_impl(_Iter __first, _Sent __last, _Pred& __pred, const _Type& __new_value, _Proj& __proj) {
   for (; __first != __last; ++__first) {
     if (std::invoke(__pred, std::invoke(__proj, *__first)))
       *__first = __new_value;
@@ -41,14 +44,14 @@ _Iter __replace_if_impl(_Iter __first, _Sent __last, _Pred& __pred, const _Type&
 
 namespace __replace_if {
 struct __fn {
-
-  template <input_iterator _Iter, sentinel_for<_Iter> _Sent,
+  template <input_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
             class _Type,
             class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
     requires indirectly_writable<_Iter, const _Type&>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, _Pred __pred, const _Type& __new_value, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, _Pred __pred, const _Type& __new_value, _Proj __proj = {}) const {
     return ranges::__replace_if_impl(std::move(__first), std::move(__last), __pred, __new_value, __proj);
   }
 
@@ -61,12 +64,11 @@ struct __fn {
   operator()(_Range&& __range, _Pred __pred, const _Type& __new_value, _Proj __proj = {}) const {
     return ranges::__replace_if_impl(ranges::begin(__range), ranges::end(__range), __pred, __new_value, __proj);
   }
-
 };
 } // namespace __replace_if
 
 inline namespace __cpo {
-  inline constexpr auto replace_if = __replace_if::__fn{};
+inline constexpr auto replace_if = __replace_if::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -74,4 +76,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_REPLACE_IF_H
diff --git a/third_party/libcxx/__algorithm/ranges_reverse.h b/third_party/libcxx/__algorithm/ranges_reverse.h
index 801fccb85..9ec865995 100644
--- a/third_party/libcxx/__algorithm/ranges_reverse.h
+++ b/third_party/libcxx/__algorithm/ranges_reverse.h
@@ -29,11 +29,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __reverse {
 struct __fn {
-
   template <bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent>
     requires permutable<_Iter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter operator()(_Iter __first, _Sent __last) const {
     if constexpr (random_access_iterator<_Iter>) {
       if (__first == __last)
         return __first;
@@ -63,16 +61,14 @@ struct __fn {
 
   template <bidirectional_range _Range>
     requires permutable<iterator_t<_Range>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __range) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range> operator()(_Range&& __range) const {
     return (*this)(ranges::begin(__range), ranges::end(__range));
   }
-
 };
 } // namespace __reverse
 
 inline namespace __cpo {
-  inline constexpr auto reverse = __reverse::__fn{};
+inline constexpr auto reverse = __reverse::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__algorithm/ranges_reverse_copy.h b/third_party/libcxx/__algorithm/ranges_reverse_copy.h
index c23039976..60043787a 100644
--- a/third_party/libcxx/__algorithm/ranges_reverse_copy.h
+++ b/third_party/libcxx/__algorithm/ranges_reverse_copy.h
@@ -25,6 +25,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -36,27 +39,25 @@ using reverse_copy_result = in_out_result<_InIter, _OutIter>;
 
 namespace __reverse_copy {
 struct __fn {
-
   template <bidirectional_iterator _InIter, sentinel_for<_InIter> _Sent, weakly_incrementable _OutIter>
     requires indirectly_copyable<_InIter, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  reverse_copy_result<_InIter, _OutIter> operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_copy_result<_InIter, _OutIter>
+  operator()(_InIter __first, _Sent __last, _OutIter __result) const {
     return (*this)(subrange(std::move(__first), std::move(__last)), std::move(__result));
   }
 
   template <bidirectional_range _Range, weakly_incrementable _OutIter>
     requires indirectly_copyable<iterator_t<_Range>, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  reverse_copy_result<borrowed_iterator_t<_Range>, _OutIter> operator()(_Range&& __range, _OutIter __result) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_copy_result<borrowed_iterator_t<_Range>, _OutIter>
+  operator()(_Range&& __range, _OutIter __result) const {
     auto __ret = ranges::copy(std::__reverse_range(__range), std::move(__result));
     return {ranges::next(ranges::begin(__range), ranges::end(__range)), std::move(__ret.out)};
   }
-
 };
 } // namespace __reverse_copy
 
 inline namespace __cpo {
-  inline constexpr auto reverse_copy = __reverse_copy::__fn{};
+inline constexpr auto reverse_copy = __reverse_copy::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -64,4 +65,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_REVERSE_COPY_H
diff --git a/third_party/libcxx/__algorithm/ranges_rotate.h b/third_party/libcxx/__algorithm/ranges_rotate.h
index 99e6ca67e..8d33a6f07 100644
--- a/third_party/libcxx/__algorithm/ranges_rotate.h
+++ b/third_party/libcxx/__algorithm/ranges_rotate.h
@@ -25,6 +25,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -33,34 +36,29 @@ namespace ranges {
 namespace __rotate {
 
 struct __fn {
-
   template <class _Iter, class _Sent>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  static subrange<_Iter> __rotate_fn_impl(_Iter __first, _Iter __middle, _Sent __last) {
-    auto __ret = std::__rotate<_RangeAlgPolicy>(
-      std::move(__first), std::move(__middle), std::move(__last));
+  _LIBCPP_HIDE_FROM_ABI constexpr static subrange<_Iter> __rotate_fn_impl(_Iter __first, _Iter __middle, _Sent __last) {
+    auto __ret = std::__rotate<_RangeAlgPolicy>(std::move(__first), std::move(__middle), std::move(__last));
     return {std::move(__ret.first), std::move(__ret.second)};
   }
 
   template <permutable _Iter, sentinel_for<_Iter> _Sent>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  subrange<_Iter> operator()(_Iter __first, _Iter __middle, _Sent __last) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter> operator()(_Iter __first, _Iter __middle, _Sent __last) const {
     return __rotate_fn_impl(std::move(__first), std::move(__middle), std::move(__last));
   }
 
   template <forward_range _Range>
-  requires permutable<iterator_t<_Range>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_subrange_t<_Range> operator()(_Range&& __range, iterator_t<_Range> __middle) const {
+    requires permutable<iterator_t<_Range>>
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
+  operator()(_Range&& __range, iterator_t<_Range> __middle) const {
     return __rotate_fn_impl(ranges::begin(__range), std::move(__middle), ranges::end(__range));
   }
-
 };
 
 } // namespace __rotate
 
 inline namespace __cpo {
-  inline constexpr auto rotate = __rotate::__fn{};
+inline constexpr auto rotate = __rotate::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -68,4 +66,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_ROTATE_H
diff --git a/third_party/libcxx/__algorithm/ranges_rotate_copy.h b/third_party/libcxx/__algorithm/ranges_rotate_copy.h
index 5b9321f90..26fe110b5 100644
--- a/third_party/libcxx/__algorithm/ranges_rotate_copy.h
+++ b/third_party/libcxx/__algorithm/ranges_rotate_copy.h
@@ -13,7 +13,6 @@
 #include <__algorithm/ranges_copy.h>
 #include <__config>
 #include <__iterator/concepts.h>
-#include <__iterator/reverse_iterator.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
@@ -23,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -34,30 +36,26 @@ using rotate_copy_result = in_out_result<_InIter, _OutIter>;
 
 namespace __rotate_copy {
 struct __fn {
-
-  template <bidirectional_iterator _InIter, sentinel_for<_InIter> _Sent, weakly_incrementable _OutIter>
+  template <forward_iterator _InIter, sentinel_for<_InIter> _Sent, weakly_incrementable _OutIter>
     requires indirectly_copyable<_InIter, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  rotate_copy_result<_InIter, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr rotate_copy_result<_InIter, _OutIter>
   operator()(_InIter __first, _InIter __middle, _Sent __last, _OutIter __result) const {
     auto __res1 = ranges::copy(__middle, __last, std::move(__result));
     auto __res2 = ranges::copy(__first, __middle, std::move(__res1.out));
     return {std::move(__res1.in), std::move(__res2.out)};
   }
 
-  template <bidirectional_range _Range, weakly_incrementable _OutIter>
+  template <forward_range _Range, weakly_incrementable _OutIter>
     requires indirectly_copyable<iterator_t<_Range>, _OutIter>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  rotate_copy_result<borrowed_iterator_t<_Range>, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr rotate_copy_result<borrowed_iterator_t<_Range>, _OutIter>
   operator()(_Range&& __range, iterator_t<_Range> __middle, _OutIter __result) const {
     return (*this)(ranges::begin(__range), std::move(__middle), ranges::end(__range), std::move(__result));
   }
-
 };
 } // namespace __rotate_copy
 
 inline namespace __cpo {
-  inline constexpr auto rotate_copy = __rotate_copy::__fn{};
+inline constexpr auto rotate_copy = __rotate_copy::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -65,4 +63,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_ROTATE_COPY_H
diff --git a/third_party/libcxx/__algorithm/ranges_sample.h b/third_party/libcxx/__algorithm/ranges_sample.h
index a5ff2d0c8..e4f60a7b6 100644
--- a/third_party/libcxx/__algorithm/ranges_sample.h
+++ b/third_party/libcxx/__algorithm/ranges_sample.h
@@ -27,6 +27,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -35,35 +38,30 @@ namespace ranges {
 namespace __sample {
 
 struct __fn {
-
   template <input_iterator _Iter, sentinel_for<_Iter> _Sent, weakly_incrementable _OutIter, class _Gen>
-  requires (forward_iterator<_Iter> || random_access_iterator<_OutIter>) &&
-           indirectly_copyable<_Iter, _OutIter> &&
-           uniform_random_bit_generator<remove_reference_t<_Gen>>
-  _LIBCPP_HIDE_FROM_ABI
-  _OutIter operator()(_Iter __first, _Sent __last,
-                      _OutIter __out_first, iter_difference_t<_Iter> __n, _Gen&& __gen) const {
+    requires(forward_iterator<_Iter> || random_access_iterator<_OutIter>) && indirectly_copyable<_Iter, _OutIter> &&
+            uniform_random_bit_generator<remove_reference_t<_Gen>>
+  _LIBCPP_HIDE_FROM_ABI _OutIter
+  operator()(_Iter __first, _Sent __last, _OutIter __out_first, iter_difference_t<_Iter> __n, _Gen&& __gen) const {
     _ClassicGenAdaptor<_Gen> __adapted_gen(__gen);
     return std::__sample<_RangeAlgPolicy>(
         std::move(__first), std::move(__last), std::move(__out_first), __n, __adapted_gen);
   }
 
   template <input_range _Range, weakly_incrementable _OutIter, class _Gen>
-  requires (forward_range<_Range> || random_access_iterator<_OutIter>) &&
-           indirectly_copyable<iterator_t<_Range>, _OutIter> &&
-           uniform_random_bit_generator<remove_reference_t<_Gen>>
-  _LIBCPP_HIDE_FROM_ABI
-  _OutIter operator()(_Range&& __range, _OutIter __out_first, range_difference_t<_Range> __n, _Gen&& __gen) const {
-    return (*this)(ranges::begin(__range), ranges::end(__range),
-                   std::move(__out_first), __n, std::forward<_Gen>(__gen));
+    requires(forward_range<_Range> || random_access_iterator<_OutIter>) &&
+            indirectly_copyable<iterator_t<_Range>, _OutIter> && uniform_random_bit_generator<remove_reference_t<_Gen>>
+  _LIBCPP_HIDE_FROM_ABI _OutIter
+  operator()(_Range&& __range, _OutIter __out_first, range_difference_t<_Range> __n, _Gen&& __gen) const {
+    return (*this)(
+        ranges::begin(__range), ranges::end(__range), std::move(__out_first), __n, std::forward<_Gen>(__gen));
   }
-
 };
 
 } // namespace __sample
 
 inline namespace __cpo {
-  inline constexpr auto sample = __sample::__fn{};
+inline constexpr auto sample = __sample::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -71,4 +69,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_SAMPLE_H
diff --git a/third_party/libcxx/__algorithm/ranges_search.h b/third_party/libcxx/__algorithm/ranges_search.h
index 6d3e31868..55294c606 100644
--- a/third_party/libcxx/__algorithm/ranges_search.h
+++ b/third_party/libcxx/__algorithm/ranges_search.h
@@ -69,33 +69,33 @@ struct __fn {
     return {__ret.first, __ret.second};
   }
 
-  template <forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
-            forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
-            class _Pred = ranges::equal_to,
+  template <forward_iterator _Iter1,
+            sentinel_for<_Iter1> _Sent1,
+            forward_iterator _Iter2,
+            sentinel_for<_Iter2> _Sent2,
+            class _Pred  = ranges::equal_to,
             class _Proj1 = identity,
             class _Proj2 = identity>
     requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  subrange<_Iter1> operator()(_Iter1 __first1, _Sent1 __last1,
-                              _Iter2 __first2, _Sent2 __last2,
-                              _Pred __pred = {},
-                              _Proj1 __proj1 = {},
-                              _Proj2 __proj2 = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter1> operator()(
+      _Iter1 __first1,
+      _Sent1 __last1,
+      _Iter2 __first2,
+      _Sent2 __last2,
+      _Pred __pred   = {},
+      _Proj1 __proj1 = {},
+      _Proj2 __proj2 = {}) const {
     return __ranges_search_impl(__first1, __last1, __first2, __last2, __pred, __proj1, __proj2);
   }
 
   template <forward_range _Range1,
             forward_range _Range2,
-            class _Pred = ranges::equal_to,
+            class _Pred  = ranges::equal_to,
             class _Proj1 = identity,
             class _Proj2 = identity>
     requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_subrange_t<_Range1> operator()(_Range1&& __range1,
-                                          _Range2&& __range2,
-                                          _Pred __pred = {},
-                                          _Proj1 __proj1 = {},
-                                          _Proj2 __proj2 = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range1> operator()(
+      _Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
     auto __first1 = ranges::begin(__range1);
     if constexpr (sized_range<_Range2>) {
       auto __size2 = ranges::size(__range2);
@@ -119,12 +119,11 @@ struct __fn {
         __proj1,
         __proj2);
   }
-
 };
 } // namespace __search
 
 inline namespace __cpo {
-  inline constexpr auto search = __search::__fn{};
+inline constexpr auto search = __search::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__algorithm/ranges_search_n.h b/third_party/libcxx/__algorithm/ranges_search_n.h
index ed5ec34f0..56e12755b 100644
--- a/third_party/libcxx/__algorithm/ranges_search_n.h
+++ b/third_party/libcxx/__algorithm/ranges_search_n.h
@@ -31,6 +31,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -38,7 +41,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __search_n {
 struct __fn {
-
   template <class _Iter1, class _Sent1, class _SizeT, class _Type, class _Pred, class _Proj>
   _LIBCPP_HIDE_FROM_ABI static constexpr subrange<_Iter1> __ranges_search_n_impl(
       _Iter1 __first, _Sent1 __last, _SizeT __count, const _Type& __value, _Pred& __pred, _Proj& __proj) {
@@ -59,36 +61,31 @@ struct __fn {
       }
     }
 
-    auto __ret = std::__search_n_forward_impl<_RangeAlgPolicy>(__first, __last,
-                                                               __count,
-                                                               __value,
-                                                               __pred,
-                                                               __proj);
+    auto __ret = std::__search_n_forward_impl<_RangeAlgPolicy>(__first, __last, __count, __value, __pred, __proj);
     return {std::move(__ret.first), std::move(__ret.second)};
   }
 
-  template <forward_iterator _Iter, sentinel_for<_Iter> _Sent,
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
             class _Type,
             class _Pred = ranges::equal_to,
             class _Proj = identity>
     requires indirectly_comparable<_Iter, const _Type*, _Pred, _Proj>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  subrange<_Iter> operator()(_Iter __first, _Sent __last,
-                             iter_difference_t<_Iter> __count,
-                             const _Type& __value,
-                             _Pred __pred = {},
-                             _Proj __proj = _Proj{}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+  operator()(_Iter __first,
+             _Sent __last,
+             iter_difference_t<_Iter> __count,
+             const _Type& __value,
+             _Pred __pred = {},
+             _Proj __proj = _Proj{}) const {
     return __ranges_search_n_impl(__first, __last, __count, __value, __pred, __proj);
   }
 
   template <forward_range _Range, class _Type, class _Pred = ranges::equal_to, class _Proj = identity>
     requires indirectly_comparable<iterator_t<_Range>, const _Type*, _Pred, _Proj>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_subrange_t<_Range> operator()(_Range&& __range,
-                                         range_difference_t<_Range> __count,
-                                         const _Type& __value,
-                                         _Pred __pred = {},
-                                         _Proj __proj = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range> operator()(
+      _Range&& __range, range_difference_t<_Range> __count, const _Type& __value, _Pred __pred = {}, _Proj __proj = {})
+      const {
     auto __first = ranges::begin(__range);
     if (__count <= 0)
       return {__first, __first};
@@ -106,7 +103,7 @@ struct __fn {
 } // namespace __search_n
 
 inline namespace __cpo {
-  inline constexpr auto search_n = __search_n::__fn{};
+inline constexpr auto search_n = __search_n::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -114,4 +111,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_SEARCH_N_H
diff --git a/third_party/libcxx/__algorithm/ranges_set_difference.h b/third_party/libcxx/__algorithm/ranges_set_difference.h
index 6b9af876b..0841fb4ff 100644
--- a/third_party/libcxx/__algorithm/ranges_set_difference.h
+++ b/third_party/libcxx/__algorithm/ranges_set_difference.h
@@ -30,6 +30,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -42,15 +45,14 @@ using set_difference_result = in_out_result<_InIter, _OutIter>;
 namespace __set_difference {
 
 struct __fn {
-  template <
-      input_iterator _InIter1,
-      sentinel_for<_InIter1> _Sent1,
-      input_iterator _InIter2,
-      sentinel_for<_InIter2> _Sent2,
-      weakly_incrementable _OutIter,
-      class _Comp  = less,
-      class _Proj1 = identity,
-      class _Proj2 = identity>
+  template <input_iterator _InIter1,
+            sentinel_for<_InIter1> _Sent1,
+            input_iterator _InIter2,
+            sentinel_for<_InIter2> _Sent2,
+            weakly_incrementable _OutIter,
+            class _Comp  = less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
     requires mergeable<_InIter1, _InIter2, _OutIter, _Comp, _Proj1, _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr set_difference_result<_InIter1, _OutIter> operator()(
       _InIter1 __first1,
@@ -66,22 +68,20 @@ struct __fn {
     return {std::move(__ret.first), std::move(__ret.second)};
   }
 
-  template <
-      input_range _Range1,
-      input_range _Range2,
-      weakly_incrementable _OutIter,
-      class _Comp  = less,
-      class _Proj1 = identity,
-      class _Proj2 = identity>
+  template <input_range _Range1,
+            input_range _Range2,
+            weakly_incrementable _OutIter,
+            class _Comp  = less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
     requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _OutIter, _Comp, _Proj1, _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr set_difference_result<borrowed_iterator_t<_Range1>, _OutIter>
-    operator()(
-        _Range1&& __range1,
-        _Range2&& __range2,
-        _OutIter __result,
-        _Comp __comp   = {},
-        _Proj1 __proj1 = {},
-        _Proj2 __proj2 = {}) const {
+  operator()(_Range1&& __range1,
+             _Range2&& __range2,
+             _OutIter __result,
+             _Comp __comp   = {},
+             _Proj1 __proj1 = {},
+             _Proj2 __proj2 = {}) const {
     auto __ret = std::__set_difference<_RangeAlgPolicy>(
         ranges::begin(__range1),
         ranges::end(__range1),
@@ -96,11 +96,14 @@ struct __fn {
 } // namespace __set_difference
 
 inline namespace __cpo {
-  inline constexpr auto set_difference = __set_difference::__fn{};
+inline constexpr auto set_difference = __set_difference::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_SET_DIFFERENCE_H
diff --git a/third_party/libcxx/__algorithm/ranges_set_intersection.h b/third_party/libcxx/__algorithm/ranges_set_intersection.h
index 5848656ce..942737974 100644
--- a/third_party/libcxx/__algorithm/ranges_set_intersection.h
+++ b/third_party/libcxx/__algorithm/ranges_set_intersection.h
@@ -28,6 +28,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -40,15 +43,14 @@ using set_intersection_result = in_in_out_result<_InIter1, _InIter2, _OutIter>;
 namespace __set_intersection {
 
 struct __fn {
-  template <
-      input_iterator _InIter1,
-      sentinel_for<_InIter1> _Sent1,
-      input_iterator _InIter2,
-      sentinel_for<_InIter2> _Sent2,
-      weakly_incrementable _OutIter,
-      class _Comp  = less,
-      class _Proj1 = identity,
-      class _Proj2 = identity>
+  template <input_iterator _InIter1,
+            sentinel_for<_InIter1> _Sent1,
+            input_iterator _InIter2,
+            sentinel_for<_InIter2> _Sent2,
+            weakly_incrementable _OutIter,
+            class _Comp  = less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
     requires mergeable<_InIter1, _InIter2, _OutIter, _Comp, _Proj1, _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr set_intersection_result<_InIter1, _InIter2, _OutIter> operator()(
       _InIter1 __first1,
@@ -69,30 +71,22 @@ struct __fn {
     return {std::move(__ret.__in1_), std::move(__ret.__in2_), std::move(__ret.__out_)};
   }
 
-  template <
-      input_range _Range1,
-      input_range _Range2,
-      weakly_incrementable _OutIter,
-      class _Comp  = less,
-      class _Proj1 = identity,
-      class _Proj2 = identity>
-    requires mergeable<
-        iterator_t<_Range1>,
-        iterator_t<_Range2>,
-        _OutIter,
-        _Comp,
-        _Proj1,
-        _Proj2>
-    _LIBCPP_HIDE_FROM_ABI constexpr set_intersection_result<borrowed_iterator_t<_Range1>,
-                                                            borrowed_iterator_t<_Range2>,
-                                                            _OutIter>
-    operator()(
-        _Range1&& __range1,
-        _Range2&& __range2,
-        _OutIter __result,
-        _Comp __comp   = {},
-        _Proj1 __proj1 = {},
-        _Proj2 __proj2 = {}) const {
+  template <input_range _Range1,
+            input_range _Range2,
+            weakly_incrementable _OutIter,
+            class _Comp  = less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _OutIter, _Comp, _Proj1, _Proj2>
+  _LIBCPP_HIDE_FROM_ABI constexpr set_intersection_result<borrowed_iterator_t<_Range1>,
+                                                          borrowed_iterator_t<_Range2>,
+                                                          _OutIter>
+  operator()(_Range1&& __range1,
+             _Range2&& __range2,
+             _OutIter __result,
+             _Comp __comp   = {},
+             _Proj1 __proj1 = {},
+             _Proj2 __proj2 = {}) const {
     auto __ret = std::__set_intersection<_RangeAlgPolicy>(
         ranges::begin(__range1),
         ranges::end(__range1),
@@ -107,11 +101,14 @@ struct __fn {
 } // namespace __set_intersection
 
 inline namespace __cpo {
-  inline constexpr auto set_intersection = __set_intersection::__fn{};
+inline constexpr auto set_intersection = __set_intersection::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_SET_INTERSECTION_H
diff --git a/third_party/libcxx/__algorithm/ranges_set_symmetric_difference.h b/third_party/libcxx/__algorithm/ranges_set_symmetric_difference.h
index f8bcf3795..995eb0999 100644
--- a/third_party/libcxx/__algorithm/ranges_set_symmetric_difference.h
+++ b/third_party/libcxx/__algorithm/ranges_set_symmetric_difference.h
@@ -28,6 +28,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -40,15 +43,14 @@ using set_symmetric_difference_result = in_in_out_result<_InIter1, _InIter2, _Ou
 namespace __set_symmetric_difference {
 
 struct __fn {
-  template <
-      input_iterator _InIter1,
-      sentinel_for<_InIter1> _Sent1,
-      input_iterator _InIter2,
-      sentinel_for<_InIter2> _Sent2,
-      weakly_incrementable _OutIter,
-      class _Comp  = ranges::less,
-      class _Proj1 = identity,
-      class _Proj2 = identity>
+  template <input_iterator _InIter1,
+            sentinel_for<_InIter1> _Sent1,
+            input_iterator _InIter2,
+            sentinel_for<_InIter2> _Sent2,
+            weakly_incrementable _OutIter,
+            class _Comp  = ranges::less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
     requires mergeable<_InIter1, _InIter2, _OutIter, _Comp, _Proj1, _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr set_symmetric_difference_result<_InIter1, _InIter2, _OutIter> operator()(
       _InIter1 __first1,
@@ -69,30 +71,22 @@ struct __fn {
     return {std::move(__ret.__in1_), std::move(__ret.__in2_), std::move(__ret.__out_)};
   }
 
-  template <
-      input_range _Range1,
-      input_range _Range2,
-      weakly_incrementable _OutIter,
-      class _Comp  = ranges::less,
-      class _Proj1 = identity,
-      class _Proj2 = identity>
-    requires mergeable<
-        iterator_t<_Range1>,
-        iterator_t<_Range2>,
-        _OutIter,
-        _Comp,
-        _Proj1,
-        _Proj2>
+  template <input_range _Range1,
+            input_range _Range2,
+            weakly_incrementable _OutIter,
+            class _Comp  = ranges::less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _OutIter, _Comp, _Proj1, _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr set_symmetric_difference_result<borrowed_iterator_t<_Range1>,
                                                                   borrowed_iterator_t<_Range2>,
                                                                   _OutIter>
-    operator()(
-        _Range1&& __range1,
-        _Range2&& __range2,
-        _OutIter __result,
-        _Comp __comp   = {},
-        _Proj1 __proj1 = {},
-        _Proj2 __proj2 = {}) const {
+  operator()(_Range1&& __range1,
+             _Range2&& __range2,
+             _OutIter __result,
+             _Comp __comp   = {},
+             _Proj1 __proj1 = {},
+             _Proj2 __proj2 = {}) const {
     auto __ret = std::__set_symmetric_difference<_RangeAlgPolicy>(
         ranges::begin(__range1),
         ranges::end(__range1),
@@ -107,11 +101,14 @@ struct __fn {
 } // namespace __set_symmetric_difference
 
 inline namespace __cpo {
-  inline constexpr auto set_symmetric_difference = __set_symmetric_difference::__fn{};
+inline constexpr auto set_symmetric_difference = __set_symmetric_difference::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_SET_SYMMETRIC_DIFFERENCE_H
diff --git a/third_party/libcxx/__algorithm/ranges_set_union.h b/third_party/libcxx/__algorithm/ranges_set_union.h
index bc669cc83..e870e390c 100644
--- a/third_party/libcxx/__algorithm/ranges_set_union.h
+++ b/third_party/libcxx/__algorithm/ranges_set_union.h
@@ -31,6 +31,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -43,15 +46,14 @@ using set_union_result = in_in_out_result<_InIter1, _InIter2, _OutIter>;
 namespace __set_union {
 
 struct __fn {
-  template <
-      input_iterator _InIter1,
-      sentinel_for<_InIter1> _Sent1,
-      input_iterator _InIter2,
-      sentinel_for<_InIter2> _Sent2,
-      weakly_incrementable _OutIter,
-      class _Comp  = ranges::less,
-      class _Proj1 = identity,
-      class _Proj2 = identity>
+  template <input_iterator _InIter1,
+            sentinel_for<_InIter1> _Sent1,
+            input_iterator _InIter2,
+            sentinel_for<_InIter2> _Sent2,
+            weakly_incrementable _OutIter,
+            class _Comp  = ranges::less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
     requires mergeable<_InIter1, _InIter2, _OutIter, _Comp, _Proj1, _Proj2>
   _LIBCPP_HIDE_FROM_ABI constexpr set_union_result<_InIter1, _InIter2, _OutIter> operator()(
       _InIter1 __first1,
@@ -72,30 +74,20 @@ struct __fn {
     return {std::move(__ret.__in1_), std::move(__ret.__in2_), std::move(__ret.__out_)};
   }
 
-  template <
-      input_range _Range1,
-      input_range _Range2,
-      weakly_incrementable _OutIter,
-      class _Comp  = ranges::less,
-      class _Proj1 = identity,
-      class _Proj2 = identity>
-    requires mergeable<
-        iterator_t<_Range1>,
-        iterator_t<_Range2>,
-        _OutIter,
-        _Comp,
-        _Proj1,
-        _Proj2>
-  _LIBCPP_HIDE_FROM_ABI constexpr set_union_result<borrowed_iterator_t<_Range1>,
-                                                   borrowed_iterator_t<_Range2>,
-                                                   _OutIter>
-    operator()(
-        _Range1&& __range1,
-        _Range2&& __range2,
-        _OutIter __result,
-        _Comp __comp   = {},
-        _Proj1 __proj1 = {},
-        _Proj2 __proj2 = {}) const {
+  template <input_range _Range1,
+            input_range _Range2,
+            weakly_incrementable _OutIter,
+            class _Comp  = ranges::less,
+            class _Proj1 = identity,
+            class _Proj2 = identity>
+    requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _OutIter, _Comp, _Proj1, _Proj2>
+  _LIBCPP_HIDE_FROM_ABI constexpr set_union_result<borrowed_iterator_t<_Range1>, borrowed_iterator_t<_Range2>, _OutIter>
+  operator()(_Range1&& __range1,
+             _Range2&& __range2,
+             _OutIter __result,
+             _Comp __comp   = {},
+             _Proj1 __proj1 = {},
+             _Proj2 __proj2 = {}) const {
     auto __ret = std::__set_union<_RangeAlgPolicy>(
         ranges::begin(__range1),
         ranges::end(__range1),
@@ -110,7 +102,7 @@ struct __fn {
 } // namespace __set_union
 
 inline namespace __cpo {
-  inline constexpr auto set_union = __set_union::__fn{};
+inline constexpr auto set_union = __set_union::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -118,4 +110,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_SET_UNION_H
diff --git a/third_party/libcxx/__algorithm/ranges_shuffle.h b/third_party/libcxx/__algorithm/ranges_shuffle.h
index 2f45fb00f..ab98ea22c 100644
--- a/third_party/libcxx/__algorithm/ranges_shuffle.h
+++ b/third_party/libcxx/__algorithm/ranges_shuffle.h
@@ -31,6 +31,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -39,28 +42,24 @@ namespace ranges {
 namespace __shuffle {
 
 struct __fn {
-
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Gen>
-  requires permutable<_Iter> && uniform_random_bit_generator<remove_reference_t<_Gen>>
-  _LIBCPP_HIDE_FROM_ABI
-  _Iter operator()(_Iter __first, _Sent __last, _Gen&& __gen) const {
+    requires permutable<_Iter> && uniform_random_bit_generator<remove_reference_t<_Gen>>
+  _LIBCPP_HIDE_FROM_ABI _Iter operator()(_Iter __first, _Sent __last, _Gen&& __gen) const {
     _ClassicGenAdaptor<_Gen> __adapted_gen(__gen);
     return std::__shuffle<_RangeAlgPolicy>(std::move(__first), std::move(__last), __adapted_gen);
   }
 
-  template<random_access_range _Range, class _Gen>
-  requires permutable<iterator_t<_Range>> && uniform_random_bit_generator<remove_reference_t<_Gen>>
-  _LIBCPP_HIDE_FROM_ABI
-  borrowed_iterator_t<_Range> operator()(_Range&& __range, _Gen&& __gen) const {
+  template <random_access_range _Range, class _Gen>
+    requires permutable<iterator_t<_Range>> && uniform_random_bit_generator<remove_reference_t<_Gen>>
+  _LIBCPP_HIDE_FROM_ABI borrowed_iterator_t<_Range> operator()(_Range&& __range, _Gen&& __gen) const {
     return (*this)(ranges::begin(__range), ranges::end(__range), std::forward<_Gen>(__gen));
   }
-
 };
 
 } // namespace __shuffle
 
 inline namespace __cpo {
-  inline constexpr auto shuffle = __shuffle::__fn{};
+inline constexpr auto shuffle = __shuffle::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -68,4 +67,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_SHUFFLE_H
diff --git a/third_party/libcxx/__algorithm/ranges_sort.h b/third_party/libcxx/__algorithm/ranges_sort.h
index 60305b10a..0296c146b 100644
--- a/third_party/libcxx/__algorithm/ranges_sort.h
+++ b/third_party/libcxx/__algorithm/ranges_sort.h
@@ -31,6 +31,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -40,8 +43,8 @@ namespace __sort {
 
 struct __fn {
   template <class _Iter, class _Sent, class _Comp, class _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  _Iter __sort_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter
+  __sort_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
     auto __last_iter = ranges::next(__first, __last);
 
     auto&& __projected_comp = std::__make_projected(__comp, __proj);
@@ -52,15 +55,15 @@ struct __fn {
 
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<_Iter, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return __sort_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
   template <random_access_range _Range, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<iterator_t<_Range>, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     return __sort_fn_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
   }
 };
@@ -68,7 +71,7 @@ struct __fn {
 } // namespace __sort
 
 inline namespace __cpo {
-  inline constexpr auto sort = __sort::__fn{};
+inline constexpr auto sort = __sort::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -76,4 +79,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_SORT_H
diff --git a/third_party/libcxx/__algorithm/ranges_sort_heap.h b/third_party/libcxx/__algorithm/ranges_sort_heap.h
index b40eef976..bab30df17 100644
--- a/third_party/libcxx/__algorithm/ranges_sort_heap.h
+++ b/third_party/libcxx/__algorithm/ranges_sort_heap.h
@@ -32,6 +32,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -41,8 +44,8 @@ namespace __sort_heap {
 
 struct __fn {
   template <class _Iter, class _Sent, class _Comp, class _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr static
-  _Iter __sort_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI constexpr static _Iter
+  __sort_heap_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
     auto __last_iter = ranges::next(__first, __last);
 
     auto&& __projected_comp = std::__make_projected(__comp, __proj);
@@ -53,15 +56,15 @@ struct __fn {
 
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<_Iter, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return __sort_heap_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
   template <random_access_range _Range, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<iterator_t<_Range>, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     return __sort_heap_fn_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
   }
 };
@@ -69,7 +72,7 @@ struct __fn {
 } // namespace __sort_heap
 
 inline namespace __cpo {
-  inline constexpr auto sort_heap = __sort_heap::__fn{};
+inline constexpr auto sort_heap = __sort_heap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -77,4 +80,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_SORT_HEAP_H
diff --git a/third_party/libcxx/__algorithm/ranges_stable_partition.h b/third_party/libcxx/__algorithm/ranges_stable_partition.h
index 77bef850a..f34027ff7 100644
--- a/third_party/libcxx/__algorithm/ranges_stable_partition.h
+++ b/third_party/libcxx/__algorithm/ranges_stable_partition.h
@@ -34,6 +34,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -42,42 +45,41 @@ namespace ranges {
 namespace __stable_partition {
 
 struct __fn {
-
   template <class _Iter, class _Sent, class _Proj, class _Pred>
-  _LIBCPP_HIDE_FROM_ABI static
-  subrange<__remove_cvref_t<_Iter>> __stable_partition_fn_impl(
-      _Iter&& __first, _Sent&& __last, _Pred&& __pred, _Proj&& __proj) {
+  _LIBCPP_HIDE_FROM_ABI static subrange<__remove_cvref_t<_Iter>>
+  __stable_partition_fn_impl(_Iter&& __first, _Sent&& __last, _Pred&& __pred, _Proj&& __proj) {
     auto __last_iter = ranges::next(__first, __last);
 
     auto&& __projected_pred = std::__make_projected(__pred, __proj);
-    auto __result = std::__stable_partition<_RangeAlgPolicy>(
+    auto __result           = std::__stable_partition<_RangeAlgPolicy>(
         std::move(__first), __last_iter, __projected_pred, __iterator_concept<_Iter>());
 
     return {std::move(__result), std::move(__last_iter)};
   }
 
-  template <bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent, class _Proj = identity,
+  template <bidirectional_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj = identity,
             indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
-  requires permutable<_Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  subrange<_Iter> operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
+    requires permutable<_Iter>
+  _LIBCPP_HIDE_FROM_ABI subrange<_Iter> operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const {
     return __stable_partition_fn_impl(__first, __last, __pred, __proj);
   }
 
-  template <bidirectional_range _Range, class _Proj = identity,
+  template <bidirectional_range _Range,
+            class _Proj = identity,
             indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
-  requires permutable<iterator_t<_Range>>
-  _LIBCPP_HIDE_FROM_ABI
-  borrowed_subrange_t<_Range> operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
+    requires permutable<iterator_t<_Range>>
+  _LIBCPP_HIDE_FROM_ABI borrowed_subrange_t<_Range>
+  operator()(_Range&& __range, _Pred __pred, _Proj __proj = {}) const {
     return __stable_partition_fn_impl(ranges::begin(__range), ranges::end(__range), __pred, __proj);
   }
-
 };
 
 } // namespace __stable_partition
 
 inline namespace __cpo {
-  inline constexpr auto stable_partition = __stable_partition::__fn{};
+inline constexpr auto stable_partition = __stable_partition::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -85,4 +87,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_STABLE_PARTITION_H
diff --git a/third_party/libcxx/__algorithm/ranges_stable_sort.h b/third_party/libcxx/__algorithm/ranges_stable_sort.h
index b823e3bcb..93909e253 100644
--- a/third_party/libcxx/__algorithm/ranges_stable_sort.h
+++ b/third_party/libcxx/__algorithm/ranges_stable_sort.h
@@ -31,6 +31,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -40,8 +43,7 @@ namespace __stable_sort {
 
 struct __fn {
   template <class _Iter, class _Sent, class _Comp, class _Proj>
-  _LIBCPP_HIDE_FROM_ABI
-  static _Iter __stable_sort_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
+  _LIBCPP_HIDE_FROM_ABI static _Iter __stable_sort_fn_impl(_Iter __first, _Sent __last, _Comp& __comp, _Proj& __proj) {
     auto __last_iter = ranges::next(__first, __last);
 
     auto&& __projected_comp = std::__make_projected(__comp, __proj);
@@ -52,15 +54,14 @@ struct __fn {
 
   template <random_access_iterator _Iter, sentinel_for<_Iter> _Sent, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<_Iter, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI
-  _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI _Iter operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
     return __stable_sort_fn_impl(std::move(__first), std::move(__last), __comp, __proj);
   }
 
   template <random_access_range _Range, class _Comp = ranges::less, class _Proj = identity>
     requires sortable<iterator_t<_Range>, _Comp, _Proj>
-  _LIBCPP_HIDE_FROM_ABI
-  borrowed_iterator_t<_Range> operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI borrowed_iterator_t<_Range>
+  operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const {
     return __stable_sort_fn_impl(ranges::begin(__r), ranges::end(__r), __comp, __proj);
   }
 };
@@ -68,7 +69,7 @@ struct __fn {
 } // namespace __stable_sort
 
 inline namespace __cpo {
-  inline constexpr auto stable_sort = __stable_sort::__fn{};
+inline constexpr auto stable_sort = __stable_sort::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -76,4 +77,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_STABLE_SORT_H
diff --git a/third_party/libcxx/__algorithm/ranges_starts_with.h b/third_party/libcxx/__algorithm/ranges_starts_with.h
index 7da78001d..17084e4f2 100644
--- a/third_party/libcxx/__algorithm/ranges_starts_with.h
+++ b/third_party/libcxx/__algorithm/ranges_starts_with.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 23
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -39,14 +42,14 @@ struct __fn {
             class _Proj1 = identity,
             class _Proj2 = identity>
     requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr bool operator()(
       _Iter1 __first1,
       _Sent1 __last1,
       _Iter2 __first2,
       _Sent2 __last2,
       _Pred __pred   = {},
       _Proj1 __proj1 = {},
-      _Proj2 __proj2 = {}) const {
+      _Proj2 __proj2 = {}) {
     return __mismatch::__fn::__go(
                std::move(__first1),
                std::move(__last1),
@@ -64,8 +67,8 @@ struct __fn {
             class _Proj1 = identity,
             class _Proj2 = identity>
     requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>, _Pred, _Proj1, _Proj2>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
-      _Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr bool
+  operator()(_Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) {
     return __mismatch::__fn::__go(
                ranges::begin(__range1),
                ranges::end(__range1),
@@ -87,4 +90,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 23
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_STARTS_WITH_H
diff --git a/third_party/libcxx/__algorithm/ranges_swap_ranges.h b/third_party/libcxx/__algorithm/ranges_swap_ranges.h
index 34124dbd8..b6d9f6183 100644
--- a/third_party/libcxx/__algorithm/ranges_swap_ranges.h
+++ b/third_party/libcxx/__algorithm/ranges_swap_ranges.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -35,8 +38,7 @@ using swap_ranges_result = in_in_result<_I1, _I2>;
 
 namespace __swap_ranges {
 struct __fn {
-  template <input_iterator _I1, sentinel_for<_I1> _S1,
-            input_iterator _I2, sentinel_for<_I2> _S2>
+  template <input_iterator _I1, sentinel_for<_I1> _S1, input_iterator _I2, sentinel_for<_I2> _S2>
     requires indirectly_swappable<_I1, _I2>
   _LIBCPP_HIDE_FROM_ABI constexpr swap_ranges_result<_I1, _I2>
   operator()(_I1 __first1, _S1 __last1, _I2 __first2, _S2 __last2) const {
@@ -47,17 +49,15 @@ struct __fn {
 
   template <input_range _R1, input_range _R2>
     requires indirectly_swappable<iterator_t<_R1>, iterator_t<_R2>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  swap_ranges_result<borrowed_iterator_t<_R1>, borrowed_iterator_t<_R2>>
+  _LIBCPP_HIDE_FROM_ABI constexpr swap_ranges_result<borrowed_iterator_t<_R1>, borrowed_iterator_t<_R2>>
   operator()(_R1&& __r1, _R2&& __r2) const {
-    return operator()(ranges::begin(__r1), ranges::end(__r1),
-                      ranges::begin(__r2), ranges::end(__r2));
+    return operator()(ranges::begin(__r1), ranges::end(__r1), ranges::begin(__r2), ranges::end(__r2));
   }
 };
 } // namespace __swap_ranges
 
 inline namespace __cpo {
-  inline constexpr auto swap_ranges = __swap_ranges::__fn{};
+inline constexpr auto swap_ranges = __swap_ranges::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -65,4 +65,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_SWAP_RANGES_H
diff --git a/third_party/libcxx/__algorithm/ranges_transform.h b/third_party/libcxx/__algorithm/ranges_transform.h
index 1bba756fe..7850ec4f8 100644
--- a/third_party/libcxx/__algorithm/ranges_transform.h
+++ b/third_party/libcxx/__algorithm/ranges_transform.h
@@ -26,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -41,15 +44,9 @@ using binary_transform_result = in_in_out_result<_I1, _I2, _O1>;
 namespace __transform {
 struct __fn {
 private:
-  template <class _InIter, class _Sent,
-            class _OutIter,
-            class _Func,
-            class _Proj>
-  _LIBCPP_HIDE_FROM_ABI static constexpr
-  unary_transform_result<_InIter, _OutIter> __unary(_InIter __first, _Sent __last,
-                                                    _OutIter __result,
-                                                    _Func& __operation,
-                                                    _Proj& __projection) {
+  template <class _InIter, class _Sent, class _OutIter, class _Func, class _Proj>
+  _LIBCPP_HIDE_FROM_ABI static constexpr unary_transform_result<_InIter, _OutIter>
+  __unary(_InIter __first, _Sent __last, _OutIter __result, _Func& __operation, _Proj& __projection) {
     while (__first != __last) {
       *__result = std::invoke(__operation, std::invoke(__projection, *__first));
       ++__first;
@@ -59,76 +56,80 @@ private:
     return {std::move(__first), std::move(__result)};
   }
 
-  template <class _InIter1, class _Sent1,
-            class _InIter2, class _Sent2,
+  template <class _InIter1,
+            class _Sent1,
+            class _InIter2,
+            class _Sent2,
             class _OutIter,
             class _Func,
             class _Proj1,
             class _Proj2>
   _LIBCPP_HIDE_FROM_ABI static constexpr binary_transform_result<_InIter1, _InIter2, _OutIter>
-  __binary(_InIter1 __first1, _Sent1 __last1,
-           _InIter2 __first2, _Sent2 __last2,
+  __binary(_InIter1 __first1,
+           _Sent1 __last1,
+           _InIter2 __first2,
+           _Sent2 __last2,
            _OutIter __result,
            _Func& __binary_operation,
            _Proj1& __projection1,
            _Proj2& __projection2) {
     while (__first1 != __last1 && __first2 != __last2) {
-      *__result = std::invoke(__binary_operation, std::invoke(__projection1, *__first1),
-                                                  std::invoke(__projection2, *__first2));
+      *__result =
+          std::invoke(__binary_operation, std::invoke(__projection1, *__first1), std::invoke(__projection2, *__first2));
       ++__first1;
       ++__first2;
       ++__result;
     }
     return {std::move(__first1), std::move(__first2), std::move(__result)};
   }
+
 public:
-  template <input_iterator _InIter, sentinel_for<_InIter> _Sent,
+  template <input_iterator _InIter,
+            sentinel_for<_InIter> _Sent,
             weakly_incrementable _OutIter,
             copy_constructible _Func,
             class _Proj = identity>
     requires indirectly_writable<_OutIter, indirect_result_t<_Func&, projected<_InIter, _Proj>>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  unary_transform_result<_InIter, _OutIter> operator()(_InIter __first, _Sent __last,
-                                                       _OutIter __result,
-                                                       _Func __operation,
-                                                       _Proj __proj = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr unary_transform_result<_InIter, _OutIter>
+  operator()(_InIter __first, _Sent __last, _OutIter __result, _Func __operation, _Proj __proj = {}) const {
     return __unary(std::move(__first), std::move(__last), std::move(__result), __operation, __proj);
   }
 
-  template <input_range _Range,
-            weakly_incrementable _OutIter,
-            copy_constructible _Func,
-            class _Proj = identity>
+  template <input_range _Range, weakly_incrementable _OutIter, copy_constructible _Func, class _Proj = identity>
     requires indirectly_writable<_OutIter, indirect_result_t<_Func, projected<iterator_t<_Range>, _Proj>>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  unary_transform_result<borrowed_iterator_t<_Range>, _OutIter> operator()(_Range&& __range,
-                                                                           _OutIter __result,
-                                                                           _Func __operation,
-                                                                           _Proj __projection = {}) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr unary_transform_result<borrowed_iterator_t<_Range>, _OutIter>
+  operator()(_Range&& __range, _OutIter __result, _Func __operation, _Proj __projection = {}) const {
     return __unary(ranges::begin(__range), ranges::end(__range), std::move(__result), __operation, __projection);
   }
 
-  template <input_iterator _InIter1, sentinel_for<_InIter1> _Sent1,
-            input_iterator _InIter2, sentinel_for<_InIter2> _Sent2,
+  template <input_iterator _InIter1,
+            sentinel_for<_InIter1> _Sent1,
+            input_iterator _InIter2,
+            sentinel_for<_InIter2> _Sent2,
             weakly_incrementable _OutIter,
             copy_constructible _Func,
             class _Proj1 = identity,
             class _Proj2 = identity>
-    requires indirectly_writable<_OutIter, indirect_result_t<_Func&, projected<_InIter1, _Proj1>,
-                                                                     projected<_InIter2, _Proj2>>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  binary_transform_result<_InIter1, _InIter2, _OutIter> operator()(_InIter1 __first1, _Sent1 __last1,
-                                                                   _InIter2 __first2, _Sent2 __last2,
-                                                                   _OutIter __result,
-                                                                   _Func __binary_operation,
-                                                                   _Proj1 __projection1 = {},
-                                                                   _Proj2 __projection2 = {}) const {
-    return __binary(std::move(__first1), std::move(__last1),
-                    std::move(__first2), std::move(__last2),
-                    std::move(__result),
-                    __binary_operation,
-                    __projection1,
-                    __projection2);
+    requires indirectly_writable<_OutIter,
+                                 indirect_result_t<_Func&, projected<_InIter1, _Proj1>, projected<_InIter2, _Proj2>>>
+  _LIBCPP_HIDE_FROM_ABI constexpr binary_transform_result<_InIter1, _InIter2, _OutIter> operator()(
+      _InIter1 __first1,
+      _Sent1 __last1,
+      _InIter2 __first2,
+      _Sent2 __last2,
+      _OutIter __result,
+      _Func __binary_operation,
+      _Proj1 __projection1 = {},
+      _Proj2 __projection2 = {}) const {
+    return __binary(
+        std::move(__first1),
+        std::move(__last1),
+        std::move(__first2),
+        std::move(__last2),
+        std::move(__result),
+        __binary_operation,
+        __projection1,
+        __projection2);
   }
 
   template <input_range _Range1,
@@ -137,29 +138,33 @@ public:
             copy_constructible _Func,
             class _Proj1 = identity,
             class _Proj2 = identity>
-    requires indirectly_writable<_OutIter, indirect_result_t<_Func&, projected<iterator_t<_Range1>, _Proj1>,
-                                                                     projected<iterator_t<_Range2>, _Proj2>>>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  binary_transform_result<borrowed_iterator_t<_Range1>, borrowed_iterator_t<_Range2>, _OutIter>
+    requires indirectly_writable<
+        _OutIter,
+        indirect_result_t<_Func&, projected<iterator_t<_Range1>, _Proj1>, projected<iterator_t<_Range2>, _Proj2>>>
+  _LIBCPP_HIDE_FROM_ABI constexpr binary_transform_result<borrowed_iterator_t<_Range1>,
+                                                          borrowed_iterator_t<_Range2>,
+                                                          _OutIter>
   operator()(_Range1&& __range1,
              _Range2&& __range2,
              _OutIter __result,
              _Func __binary_operation,
              _Proj1 __projection1 = {},
              _Proj2 __projection2 = {}) const {
-    return __binary(ranges::begin(__range1), ranges::end(__range1),
-                    ranges::begin(__range2), ranges::end(__range2),
-                    std::move(__result),
-                    __binary_operation,
-                    __projection1,
-                    __projection2);
+    return __binary(
+        ranges::begin(__range1),
+        ranges::end(__range1),
+        ranges::begin(__range2),
+        ranges::end(__range2),
+        std::move(__result),
+        __binary_operation,
+        __projection1,
+        __projection2);
   }
-
 };
 } // namespace __transform
 
 inline namespace __cpo {
-  inline constexpr auto transform = __transform::__fn{};
+inline constexpr auto transform = __transform::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -167,4 +172,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_TRANSFORM_H
diff --git a/third_party/libcxx/__algorithm/ranges_unique.h b/third_party/libcxx/__algorithm/ranges_unique.h
index 9e05c09fe..7a9b78432 100644
--- a/third_party/libcxx/__algorithm/ranges_unique.h
+++ b/third_party/libcxx/__algorithm/ranges_unique.h
@@ -32,6 +32,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -39,36 +42,34 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __unique {
 
-  struct __fn {
-    template <
-        permutable _Iter,
-        sentinel_for<_Iter> _Sent,
-        class _Proj                                                  = identity,
-        indirect_equivalence_relation<projected<_Iter, _Proj>> _Comp = ranges::equal_to>
-    _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
-    operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
-      auto __ret = std::__unique<_RangeAlgPolicy>(
-          std::move(__first), std::move(__last), std::__make_projected(__comp, __proj));
-      return {std::move(__ret.first), std::move(__ret.second)};
-    }
+struct __fn {
+  template <permutable _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Proj                                                  = identity,
+            indirect_equivalence_relation<projected<_Iter, _Proj>> _Comp = ranges::equal_to>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange<_Iter>
+  operator()(_Iter __first, _Sent __last, _Comp __comp = {}, _Proj __proj = {}) const {
+    auto __ret =
+        std::__unique<_RangeAlgPolicy>(std::move(__first), std::move(__last), std::__make_projected(__comp, __proj));
+    return {std::move(__ret.first), std::move(__ret.second)};
+  }
 
-    template <
-        forward_range _Range,
-        class _Proj                                                               = identity,
-        indirect_equivalence_relation<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::equal_to>
-      requires permutable<iterator_t<_Range>>
-    _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
-    operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
-      auto __ret = std::__unique<_RangeAlgPolicy>(
-          ranges::begin(__range), ranges::end(__range), std::__make_projected(__comp, __proj));
-      return {std::move(__ret.first), std::move(__ret.second)};
-    }
-  };
+  template <forward_range _Range,
+            class _Proj                                                               = identity,
+            indirect_equivalence_relation<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::equal_to>
+    requires permutable<iterator_t<_Range>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_subrange_t<_Range>
+  operator()(_Range&& __range, _Comp __comp = {}, _Proj __proj = {}) const {
+    auto __ret = std::__unique<_RangeAlgPolicy>(
+        ranges::begin(__range), ranges::end(__range), std::__make_projected(__comp, __proj));
+    return {std::move(__ret.first), std::move(__ret.second)};
+  }
+};
 
 } // namespace __unique
 
 inline namespace __cpo {
-  inline constexpr auto unique = __unique::__fn{};
+inline constexpr auto unique = __unique::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -76,4 +77,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_UNIQUE_H
diff --git a/third_party/libcxx/__algorithm/ranges_unique_copy.h b/third_party/libcxx/__algorithm/ranges_unique_copy.h
index 2aaa879ea..61133885a 100644
--- a/third_party/libcxx/__algorithm/ranges_unique_copy.h
+++ b/third_party/libcxx/__algorithm/ranges_unique_copy.h
@@ -21,7 +21,6 @@
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/projected.h>
-#include <__iterator/readable_traits.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
@@ -33,6 +32,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -87,9 +89,9 @@ struct __fn {
             class _Proj                                                               = identity,
             indirect_equivalence_relation<projected<iterator_t<_Range>, _Proj>> _Comp = ranges::equal_to>
     requires indirectly_copyable<iterator_t<_Range>, _OutIter> &&
-      (forward_iterator<iterator_t<_Range>> ||
-       (input_iterator<_OutIter> && same_as<range_value_t<_Range>, iter_value_t<_OutIter>>) ||
-       indirectly_copyable_storable<iterator_t<_Range>, _OutIter>)
+             (forward_iterator<iterator_t<_Range>> ||
+              (input_iterator<_OutIter> && same_as<range_value_t<_Range>, iter_value_t<_OutIter>>) ||
+              indirectly_copyable_storable<iterator_t<_Range>, _OutIter>)
   _LIBCPP_HIDE_FROM_ABI constexpr unique_copy_result<borrowed_iterator_t<_Range>, _OutIter>
   operator()(_Range&& __range, _OutIter __result, _Comp __comp = {}, _Proj __proj = {}) const {
     auto __ret = std::__unique_copy<_RangeAlgPolicy>(
@@ -113,4 +115,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_RANGES_UNIQUE_COPY_H
diff --git a/third_party/libcxx/__algorithm/ranges_upper_bound.h b/third_party/libcxx/__algorithm/ranges_upper_bound.h
index 43ce89b89..fa6fa7f70 100644
--- a/third_party/libcxx/__algorithm/ranges_upper_bound.h
+++ b/third_party/libcxx/__algorithm/ranges_upper_bound.h
@@ -32,39 +32,38 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __upper_bound {
 struct __fn {
-  template <forward_iterator _Iter, sentinel_for<_Iter> _Sent, class _Type, class _Proj = identity,
+  template <forward_iterator _Iter,
+            sentinel_for<_Iter> _Sent,
+            class _Type,
+            class _Proj                                                             = identity,
             indirect_strict_weak_order<const _Type*, projected<_Iter, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  _Iter operator()(_Iter __first, _Sent __last, const _Type& __value, _Comp __comp = {}, _Proj __proj = {}) const {
-    auto __comp_lhs_rhs_swapped = [&](const auto& __lhs, const auto& __rhs) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter
+  operator()(_Iter __first, _Sent __last, const _Type& __value, _Comp __comp = {}, _Proj __proj = {}) const {
+    auto __comp_lhs_rhs_swapped = [&](const auto& __lhs, const auto& __rhs) -> bool {
       return !std::invoke(__comp, __rhs, __lhs);
     };
 
-    return std::__lower_bound_impl<_RangeAlgPolicy>(__first, __last, __value, __comp_lhs_rhs_swapped, __proj);
+    return std::__lower_bound<_RangeAlgPolicy>(__first, __last, __value, __comp_lhs_rhs_swapped, __proj);
   }
 
-  template <forward_range _Range, class _Type, class _Proj = identity,
+  template <forward_range _Range,
+            class _Type,
+            class _Proj                                                                          = identity,
             indirect_strict_weak_order<const _Type*, projected<iterator_t<_Range>, _Proj>> _Comp = ranges::less>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr
-  borrowed_iterator_t<_Range> operator()(_Range&& __r,
-                                         const _Type& __value,
-                                         _Comp __comp = {},
-                                         _Proj __proj = {}) const {
-    auto __comp_lhs_rhs_swapped = [&](const auto& __lhs, const auto& __rhs) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_Range>
+  operator()(_Range&& __r, const _Type& __value, _Comp __comp = {}, _Proj __proj = {}) const {
+    auto __comp_lhs_rhs_swapped = [&](const auto& __lhs, const auto& __rhs) -> bool {
       return !std::invoke(__comp, __rhs, __lhs);
     };
 
-    return std::__lower_bound_impl<_RangeAlgPolicy>(ranges::begin(__r),
-                                                   ranges::end(__r),
-                                                   __value,
-                                                   __comp_lhs_rhs_swapped,
-                                                   __proj);
+    return std::__lower_bound<_RangeAlgPolicy>(
+        ranges::begin(__r), ranges::end(__r), __value, __comp_lhs_rhs_swapped, __proj);
   }
 };
 } // namespace __upper_bound
 
 inline namespace __cpo {
-  inline constexpr auto upper_bound = __upper_bound::__fn{};
+inline constexpr auto upper_bound = __upper_bound::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__algorithm/remove.h b/third_party/libcxx/__algorithm/remove.h
index 533e41b54..fd01c23cb 100644
--- a/third_party/libcxx/__algorithm/remove.h
+++ b/third_party/libcxx/__algorithm/remove.h
@@ -18,28 +18,29 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Tp>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
-remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
-{
-    __first = _VSTD::find(__first, __last, __value);
-    if (__first != __last)
-    {
-        _ForwardIterator __i = __first;
-        while (++__i != __last)
-        {
-            if (!(*__i == __value))
-            {
-                *__first = _VSTD::move(*__i);
-                ++__first;
-            }
-        }
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
+  __first = std::find(__first, __last, __value);
+  if (__first != __last) {
+    _ForwardIterator __i = __first;
+    while (++__i != __last) {
+      if (!(*__i == __value)) {
+        *__first = std::move(*__i);
+        ++__first;
+      }
     }
-    return __first;
+  }
+  return __first;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_REMOVE_H
diff --git a/third_party/libcxx/__algorithm/remove_copy.h b/third_party/libcxx/__algorithm/remove_copy.h
index ecba08a05..7be4c166c 100644
--- a/third_party/libcxx/__algorithm/remove_copy.h
+++ b/third_party/libcxx/__algorithm/remove_copy.h
@@ -18,19 +18,15 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _OutputIterator, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value)
-{
-    for (; __first != __last; ++__first)
-    {
-        if (!(*__first == __value))
-        {
-            *__result = *__first;
-            ++__result;
-        }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value) {
+  for (; __first != __last; ++__first) {
+    if (!(*__first == __value)) {
+      *__result = *__first;
+      ++__result;
     }
-    return __result;
+  }
+  return __result;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/remove_copy_if.h b/third_party/libcxx/__algorithm/remove_copy_if.h
index 2f235fd32..dcafed169 100644
--- a/third_party/libcxx/__algorithm/remove_copy_if.h
+++ b/third_party/libcxx/__algorithm/remove_copy_if.h
@@ -18,19 +18,15 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _OutputIterator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred)
-{
-    for (; __first != __last; ++__first)
-    {
-        if (!__pred(*__first))
-        {
-            *__result = *__first;
-            ++__result;
-        }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+remove_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Predicate __pred) {
+  for (; __first != __last; ++__first) {
+    if (!__pred(*__first)) {
+      *__result = *__first;
+      ++__result;
     }
-    return __result;
+  }
+  return __result;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/remove_if.h b/third_party/libcxx/__algorithm/remove_if.h
index 27350728d..b14f3c0ef 100644
--- a/third_party/libcxx/__algorithm/remove_if.h
+++ b/third_party/libcxx/__algorithm/remove_if.h
@@ -17,28 +17,29 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Predicate>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
-remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
-{
-    __first = _VSTD::find_if<_ForwardIterator, _Predicate&>(__first, __last, __pred);
-    if (__first != __last)
-    {
-        _ForwardIterator __i = __first;
-        while (++__i != __last)
-        {
-            if (!__pred(*__i))
-            {
-                *__first = _VSTD::move(*__i);
-                ++__first;
-            }
-        }
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
+  __first = std::find_if<_ForwardIterator, _Predicate&>(__first, __last, __pred);
+  if (__first != __last) {
+    _ForwardIterator __i = __first;
+    while (++__i != __last) {
+      if (!__pred(*__i)) {
+        *__first = std::move(*__i);
+        ++__first;
+      }
     }
-    return __first;
+  }
+  return __first;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_REMOVE_IF_H
diff --git a/third_party/libcxx/__algorithm/replace.h b/third_party/libcxx/__algorithm/replace.h
index ce6215066..8057c7868 100644
--- a/third_party/libcxx/__algorithm/replace.h
+++ b/third_party/libcxx/__algorithm/replace.h
@@ -18,13 +18,11 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-replace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value)
-{
-    for (; __first != __last; ++__first)
-        if (*__first == __old_value)
-            *__first = __new_value;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+replace(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value, const _Tp& __new_value) {
+  for (; __first != __last; ++__first)
+    if (*__first == __old_value)
+      *__first = __new_value;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/replace_copy.h b/third_party/libcxx/__algorithm/replace_copy.h
index bebb14cbe..9a2258d9f 100644
--- a/third_party/libcxx/__algorithm/replace_copy.h
+++ b/third_party/libcxx/__algorithm/replace_copy.h
@@ -18,17 +18,18 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _OutputIterator, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-replace_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
-             const _Tp& __old_value, const _Tp& __new_value)
-{
-    for (; __first != __last; ++__first, (void) ++__result)
-        if (*__first == __old_value)
-            *__result = __new_value;
-        else
-            *__result = *__first;
-    return __result;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator replace_copy(
+    _InputIterator __first,
+    _InputIterator __last,
+    _OutputIterator __result,
+    const _Tp& __old_value,
+    const _Tp& __new_value) {
+  for (; __first != __last; ++__first, (void)++__result)
+    if (*__first == __old_value)
+      *__result = __new_value;
+    else
+      *__result = *__first;
+  return __result;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/replace_copy_if.h b/third_party/libcxx/__algorithm/replace_copy_if.h
index e1ddb527b..c2ed30f08 100644
--- a/third_party/libcxx/__algorithm/replace_copy_if.h
+++ b/third_party/libcxx/__algorithm/replace_copy_if.h
@@ -18,17 +18,18 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _OutputIterator, class _Predicate, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-replace_copy_if(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
-                _Predicate __pred, const _Tp& __new_value)
-{
-    for (; __first != __last; ++__first, (void) ++__result)
-        if (__pred(*__first))
-            *__result = __new_value;
-        else
-            *__result = *__first;
-    return __result;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator replace_copy_if(
+    _InputIterator __first,
+    _InputIterator __last,
+    _OutputIterator __result,
+    _Predicate __pred,
+    const _Tp& __new_value) {
+  for (; __first != __last; ++__first, (void)++__result)
+    if (__pred(*__first))
+      *__result = __new_value;
+    else
+      *__result = *__first;
+  return __result;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/replace_if.h b/third_party/libcxx/__algorithm/replace_if.h
index b3a3367d2..78487e3de 100644
--- a/third_party/libcxx/__algorithm/replace_if.h
+++ b/third_party/libcxx/__algorithm/replace_if.h
@@ -18,13 +18,11 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Predicate, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value)
-{
-    for (; __first != __last; ++__first)
-        if (__pred(*__first))
-            *__first = __new_value;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+replace_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, const _Tp& __new_value) {
+  for (; __first != __last; ++__first)
+    if (__pred(*__first))
+      *__first = __new_value;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/reverse.h b/third_party/libcxx/__algorithm/reverse.h
index aa7695170..4167c9116 100644
--- a/third_party/libcxx/__algorithm/reverse.h
+++ b/third_party/libcxx/__algorithm/reverse.h
@@ -19,47 +19,44 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _BidirectionalIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__reverse_impl(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag)
-{
-    while (__first != __last)
-    {
-        if (__first == --__last)
-            break;
-        _IterOps<_AlgPolicy>::iter_swap(__first, __last);
-        ++__first;
-    }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+__reverse_impl(_BidirectionalIterator __first, _BidirectionalIterator __last, bidirectional_iterator_tag) {
+  while (__first != __last) {
+    if (__first == --__last)
+      break;
+    _IterOps<_AlgPolicy>::iter_swap(__first, __last);
+    ++__first;
+  }
 }
 
 template <class _AlgPolicy, class _RandomAccessIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__reverse_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag)
-{
-    if (__first != __last)
-        for (; __first < --__last; ++__first)
-            _IterOps<_AlgPolicy>::iter_swap(__first, __last);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+__reverse_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, random_access_iterator_tag) {
+  if (__first != __last)
+    for (; __first < --__last; ++__first)
+      _IterOps<_AlgPolicy>::iter_swap(__first, __last);
 }
 
 template <class _AlgPolicy, class _BidirectionalIterator, class _Sentinel>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void __reverse(_BidirectionalIterator __first, _Sentinel __last) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __reverse(_BidirectionalIterator __first, _Sentinel __last) {
   using _IterCategory = typename _IterOps<_AlgPolicy>::template __iterator_category<_BidirectionalIterator>;
   std::__reverse_impl<_AlgPolicy>(std::move(__first), std::move(__last), _IterCategory());
 }
 
 template <class _BidirectionalIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
-{
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+reverse(_BidirectionalIterator __first, _BidirectionalIterator __last) {
   std::__reverse<_ClassicAlgPolicy>(std::move(__first), std::move(__last));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_REVERSE_H
diff --git a/third_party/libcxx/__algorithm/reverse_copy.h b/third_party/libcxx/__algorithm/reverse_copy.h
index f4a0e9713..0fcecc392 100644
--- a/third_party/libcxx/__algorithm/reverse_copy.h
+++ b/third_party/libcxx/__algorithm/reverse_copy.h
@@ -18,13 +18,11 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _BidirectionalIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result)
-{
-    for (; __first != __last; ++__result)
-        *__result = *--__last;
-    return __result;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last, _OutputIterator __result) {
+  for (; __first != __last; ++__result)
+    *__result = *--__last;
+  return __result;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/rotate.h b/third_party/libcxx/__algorithm/rotate.h
index 7ed6f1862..df4ca95aa 100644
--- a/third_party/libcxx/__algorithm/rotate.h
+++ b/third_party/libcxx/__algorithm/rotate.h
@@ -15,7 +15,7 @@
 #include <__algorithm/swap_ranges.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
-#include <__type_traits/is_trivially_move_assignable.h>
+#include <__type_traits/is_trivially_assignable.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 
@@ -23,199 +23,176 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
-__rotate_left(_ForwardIterator __first, _ForwardIterator __last)
-{
-    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
-    using _Ops = _IterOps<_AlgPolicy>;
+__rotate_left(_ForwardIterator __first, _ForwardIterator __last) {
+  typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    value_type __tmp = _Ops::__iter_move(__first);
-    _ForwardIterator __lm1 = std::__move<_AlgPolicy>(
-        _Ops::next(__first), __last, __first).second;
-    *__lm1 = _VSTD::move(__tmp);
-    return __lm1;
+  value_type __tmp       = _Ops::__iter_move(__first);
+  _ForwardIterator __lm1 = std::__move<_AlgPolicy>(_Ops::next(__first), __last, __first).second;
+  *__lm1                 = std::move(__tmp);
+  return __lm1;
 }
 
 template <class _AlgPolicy, class _BidirectionalIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _BidirectionalIterator
-__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last)
-{
-    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
-    using _Ops = _IterOps<_AlgPolicy>;
+__rotate_right(_BidirectionalIterator __first, _BidirectionalIterator __last) {
+  typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    _BidirectionalIterator __lm1 = _Ops::prev(__last);
-    value_type __tmp = _Ops::__iter_move(__lm1);
-    _BidirectionalIterator __fp1 = std::__move_backward<_AlgPolicy>(__first, __lm1, std::move(__last)).second;
-    *__first = _VSTD::move(__tmp);
-    return __fp1;
+  _BidirectionalIterator __lm1 = _Ops::prev(__last);
+  value_type __tmp             = _Ops::__iter_move(__lm1);
+  _BidirectionalIterator __fp1 = std::__move_backward<_AlgPolicy>(__first, __lm1, std::move(__last)).second;
+  *__first                     = std::move(__tmp);
+  return __fp1;
 }
 
 template <class _AlgPolicy, class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _ForwardIterator
-__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
-{
-    _ForwardIterator __i = __middle;
-    while (true)
-    {
-        _IterOps<_AlgPolicy>::iter_swap(__first, __i);
-        ++__first;
-        if (++__i == __last)
-            break;
+__rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) {
+  _ForwardIterator __i = __middle;
+  while (true) {
+    _IterOps<_AlgPolicy>::iter_swap(__first, __i);
+    ++__first;
+    if (++__i == __last)
+      break;
+    if (__first == __middle)
+      __middle = __i;
+  }
+  _ForwardIterator __r = __first;
+  if (__first != __middle) {
+    __i = __middle;
+    while (true) {
+      _IterOps<_AlgPolicy>::iter_swap(__first, __i);
+      ++__first;
+      if (++__i == __last) {
         if (__first == __middle)
-            __middle = __i;
-    }
-    _ForwardIterator __r = __first;
-    if (__first != __middle)
-    {
+          break;
         __i = __middle;
-        while (true)
-        {
-            _IterOps<_AlgPolicy>::iter_swap(__first, __i);
-            ++__first;
-            if (++__i == __last)
-            {
-                if (__first == __middle)
-                    break;
-                __i = __middle;
-            }
-            else if (__first == __middle)
-                __middle = __i;
-        }
+      } else if (__first == __middle)
+        __middle = __i;
     }
-    return __r;
+  }
+  return __r;
 }
 
-template<typename _Integral>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX17 _Integral
-__algo_gcd(_Integral __x, _Integral __y)
-{
-    do
-    {
-        _Integral __t = __x % __y;
-        __x = __y;
-        __y = __t;
-    } while (__y);
-    return __x;
+template <typename _Integral>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _Integral __algo_gcd(_Integral __x, _Integral __y) {
+  do {
+    _Integral __t = __x % __y;
+    __x           = __y;
+    __y           = __t;
+  } while (__y);
+  return __x;
 }
 
 template <class _AlgPolicy, typename _RandomAccessIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _RandomAccessIterator
-__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
-{
-    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
-    using _Ops = _IterOps<_AlgPolicy>;
+__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) {
+  typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
+  typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    const difference_type __m1 = __middle - __first;
-    const difference_type __m2 = _Ops::distance(__middle, __last);
-    if (__m1 == __m2)
-    {
-        std::__swap_ranges<_AlgPolicy>(__first, __middle, __middle, __last);
-        return __middle;
-    }
-    const difference_type __g = _VSTD::__algo_gcd(__m1, __m2);
-    for (_RandomAccessIterator __p = __first + __g; __p != __first;)
-    {
-        value_type __t(_Ops::__iter_move(--__p));
-        _RandomAccessIterator __p1 = __p;
-        _RandomAccessIterator __p2 = __p1 + __m1;
-        do
-        {
-            *__p1 = _Ops::__iter_move(__p2);
-            __p1 = __p2;
-            const difference_type __d = _Ops::distance(__p2, __last);
-            if (__m1 < __d)
-                __p2 += __m1;
-            else
-                __p2 = __first + (__m1 - __d);
-        } while (__p2 != __p);
-        *__p1 = _VSTD::move(__t);
-    }
-    return __first + __m2;
+  const difference_type __m1 = __middle - __first;
+  const difference_type __m2 = _Ops::distance(__middle, __last);
+  if (__m1 == __m2) {
+    std::__swap_ranges<_AlgPolicy>(__first, __middle, __middle, __last);
+    return __middle;
+  }
+  const difference_type __g = std::__algo_gcd(__m1, __m2);
+  for (_RandomAccessIterator __p = __first + __g; __p != __first;) {
+    value_type __t(_Ops::__iter_move(--__p));
+    _RandomAccessIterator __p1 = __p;
+    _RandomAccessIterator __p2 = __p1 + __m1;
+    do {
+      *__p1                     = _Ops::__iter_move(__p2);
+      __p1                      = __p2;
+      const difference_type __d = _Ops::distance(__p2, __last);
+      if (__m1 < __d)
+        __p2 += __m1;
+      else
+        __p2 = __first + (__m1 - __d);
+    } while (__p2 != __p);
+    *__p1 = std::move(__t);
+  }
+  return __first + __m2;
 }
 
 template <class _AlgPolicy, class _ForwardIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
-__rotate_impl(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
-         _VSTD::forward_iterator_tag)
-{
-    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
-    if (is_trivially_move_assignable<value_type>::value)
-    {
-        if (_IterOps<_AlgPolicy>::next(__first) == __middle)
-            return std::__rotate_left<_AlgPolicy>(__first, __last);
-    }
-    return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator
+__rotate_impl(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, std::forward_iterator_tag) {
+  typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
+  if (is_trivially_move_assignable<value_type>::value) {
+    if (_IterOps<_AlgPolicy>::next(__first) == __middle)
+      return std::__rotate_left<_AlgPolicy>(__first, __last);
+  }
+  return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);
 }
 
 template <class _AlgPolicy, class _BidirectionalIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _BidirectionalIterator
-__rotate_impl(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last,
-         bidirectional_iterator_tag)
-{
-    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
-    if (is_trivially_move_assignable<value_type>::value)
-    {
-        if (_IterOps<_AlgPolicy>::next(__first) == __middle)
-            return std::__rotate_left<_AlgPolicy>(__first, __last);
-        if (_IterOps<_AlgPolicy>::next(__middle) == __last)
-            return std::__rotate_right<_AlgPolicy>(__first, __last);
-    }
-    return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _BidirectionalIterator __rotate_impl(
+    _BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last,
+    bidirectional_iterator_tag) {
+  typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
+  if (is_trivially_move_assignable<value_type>::value) {
+    if (_IterOps<_AlgPolicy>::next(__first) == __middle)
+      return std::__rotate_left<_AlgPolicy>(__first, __last);
+    if (_IterOps<_AlgPolicy>::next(__middle) == __last)
+      return std::__rotate_right<_AlgPolicy>(__first, __last);
+  }
+  return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);
 }
 
 template <class _AlgPolicy, class _RandomAccessIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _RandomAccessIterator
-__rotate_impl(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last,
-         random_access_iterator_tag)
-{
-    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
-    if (is_trivially_move_assignable<value_type>::value)
-    {
-        if (_IterOps<_AlgPolicy>::next(__first) == __middle)
-            return std::__rotate_left<_AlgPolicy>(__first, __last);
-        if (_IterOps<_AlgPolicy>::next(__middle) == __last)
-            return std::__rotate_right<_AlgPolicy>(__first, __last);
-        return std::__rotate_gcd<_AlgPolicy>(__first, __middle, __last);
-    }
-    return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _RandomAccessIterator __rotate_impl(
+    _RandomAccessIterator __first,
+    _RandomAccessIterator __middle,
+    _RandomAccessIterator __last,
+    random_access_iterator_tag) {
+  typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
+  if (is_trivially_move_assignable<value_type>::value) {
+    if (_IterOps<_AlgPolicy>::next(__first) == __middle)
+      return std::__rotate_left<_AlgPolicy>(__first, __last);
+    if (_IterOps<_AlgPolicy>::next(__middle) == __last)
+      return std::__rotate_right<_AlgPolicy>(__first, __last);
+    return std::__rotate_gcd<_AlgPolicy>(__first, __middle, __last);
+  }
+  return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);
 }
 
 template <class _AlgPolicy, class _Iterator, class _Sentinel>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Iterator, _Iterator>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iterator, _Iterator>
 __rotate(_Iterator __first, _Iterator __middle, _Sentinel __last) {
-  using _Ret = pair<_Iterator, _Iterator>;
+  using _Ret            = pair<_Iterator, _Iterator>;
   _Iterator __last_iter = _IterOps<_AlgPolicy>::next(__middle, __last);
 
   if (__first == __middle)
-      return _Ret(__last_iter, __last_iter);
+    return _Ret(__last_iter, __last_iter);
   if (__middle == __last)
-      return _Ret(std::move(__first), std::move(__last_iter));
+    return _Ret(std::move(__first), std::move(__last_iter));
 
   using _IterCategory = typename _IterOps<_AlgPolicy>::template __iterator_category<_Iterator>;
-  auto __result = std::__rotate_impl<_AlgPolicy>(
-      std::move(__first), std::move(__middle), __last_iter, _IterCategory());
+  auto __result = std::__rotate_impl<_AlgPolicy>(std::move(__first), std::move(__middle), __last_iter, _IterCategory());
 
   return _Ret(std::move(__result), std::move(__last_iter));
 }
 
 template <class _ForwardIterator>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
-rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
-{
-  return std::__rotate<_ClassicAlgPolicy>(
-      std::move(__first), std::move(__middle), std::move(__last)).first;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) {
+  return std::__rotate<_ClassicAlgPolicy>(std::move(__first), std::move(__middle), std::move(__last)).first;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_ROTATE_H
diff --git a/third_party/libcxx/__algorithm/rotate_copy.h b/third_party/libcxx/__algorithm/rotate_copy.h
index c154649ab..cddcadd23 100644
--- a/third_party/libcxx/__algorithm/rotate_copy.h
+++ b/third_party/libcxx/__algorithm/rotate_copy.h
@@ -19,11 +19,9 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result)
-{
-    return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result) {
+  return std::copy(__first, __middle, std::copy(__middle, __last, __result));
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/sample.h b/third_party/libcxx/__algorithm/sample.h
index 8769d494e..ebe5180b7 100644
--- a/third_party/libcxx/__algorithm/sample.h
+++ b/third_party/libcxx/__algorithm/sample.h
@@ -29,38 +29,45 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy,
-          class _PopulationIterator, class _PopulationSentinel, class _SampleIterator, class _Distance,
+          class _PopulationIterator,
+          class _PopulationSentinel,
+          class _SampleIterator,
+          class _Distance,
           class _UniformRandomNumberGenerator>
-_LIBCPP_INLINE_VISIBILITY
-_SampleIterator __sample(_PopulationIterator __first,
-                         _PopulationSentinel __last, _SampleIterator __output_iter,
-                         _Distance __n,
-                         _UniformRandomNumberGenerator& __g,
-                         input_iterator_tag) {
-
+_LIBCPP_HIDE_FROM_ABI _SampleIterator __sample(
+    _PopulationIterator __first,
+    _PopulationSentinel __last,
+    _SampleIterator __output_iter,
+    _Distance __n,
+    _UniformRandomNumberGenerator& __g,
+    input_iterator_tag) {
   _Distance __k = 0;
-  for (; __first != __last && __k < __n; ++__first, (void) ++__k)
+  for (; __first != __last && __k < __n; ++__first, (void)++__k)
     __output_iter[__k] = *__first;
   _Distance __sz = __k;
-  for (; __first != __last; ++__first, (void) ++__k) {
+  for (; __first != __last; ++__first, (void)++__k) {
     _Distance __r = uniform_int_distribution<_Distance>(0, __k)(__g);
     if (__r < __sz)
       __output_iter[__r] = *__first;
   }
-  return __output_iter + _VSTD::min(__n, __k);
+  return __output_iter + std::min(__n, __k);
 }
 
 template <class _AlgPolicy,
-          class _PopulationIterator, class _PopulationSentinel, class _SampleIterator, class _Distance,
+          class _PopulationIterator,
+          class _PopulationSentinel,
+          class _SampleIterator,
+          class _Distance,
           class _UniformRandomNumberGenerator>
-_LIBCPP_INLINE_VISIBILITY
-_SampleIterator __sample(_PopulationIterator __first,
-                         _PopulationSentinel __last, _SampleIterator __output_iter,
-                         _Distance __n,
-                         _UniformRandomNumberGenerator& __g,
-                         forward_iterator_tag) {
+_LIBCPP_HIDE_FROM_ABI _SampleIterator __sample(
+    _PopulationIterator __first,
+    _PopulationSentinel __last,
+    _SampleIterator __output_iter,
+    _Distance __n,
+    _UniformRandomNumberGenerator& __g,
+    forward_iterator_tag) {
   _Distance __unsampled_sz = _IterOps<_AlgPolicy>::distance(__first, __last);
-  for (__n = _VSTD::min(__n, __unsampled_sz); __n != 0; ++__first) {
+  for (__n = std::min(__n, __unsampled_sz); __n != 0; ++__first) {
     _Distance __r = uniform_int_distribution<_Distance>(0, --__unsampled_sz)(__g);
     if (__r < __n) {
       *__output_iter++ = *__first;
@@ -71,36 +78,40 @@ _SampleIterator __sample(_PopulationIterator __first,
 }
 
 template <class _AlgPolicy,
-          class _PopulationIterator, class _PopulationSentinel, class _SampleIterator, class _Distance,
+          class _PopulationIterator,
+          class _PopulationSentinel,
+          class _SampleIterator,
+          class _Distance,
           class _UniformRandomNumberGenerator>
-_LIBCPP_INLINE_VISIBILITY
-_SampleIterator __sample(_PopulationIterator __first,
-                         _PopulationSentinel __last, _SampleIterator __output_iter,
-                         _Distance __n, _UniformRandomNumberGenerator& __g) {
-  _LIBCPP_ASSERT(__n >= 0, "N must be a positive number.");
+_LIBCPP_HIDE_FROM_ABI _SampleIterator __sample(
+    _PopulationIterator __first,
+    _PopulationSentinel __last,
+    _SampleIterator __output_iter,
+    _Distance __n,
+    _UniformRandomNumberGenerator& __g) {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n >= 0, "N must be a positive number.");
 
   using _PopIterCategory = typename _IterOps<_AlgPolicy>::template __iterator_category<_PopulationIterator>;
-  using _Difference = typename _IterOps<_AlgPolicy>::template __difference_type<_PopulationIterator>;
-  using _CommonType = typename common_type<_Distance, _Difference>::type;
+  using _Difference      = typename _IterOps<_AlgPolicy>::template __difference_type<_PopulationIterator>;
+  using _CommonType      = typename common_type<_Distance, _Difference>::type;
 
   return std::__sample<_AlgPolicy>(
-      std::move(__first), std::move(__last), std::move(__output_iter), _CommonType(__n),
-      __g, _PopIterCategory());
+      std::move(__first), std::move(__last), std::move(__output_iter), _CommonType(__n), __g, _PopIterCategory());
 }
 
 #if _LIBCPP_STD_VER >= 17
-template <class _PopulationIterator, class _SampleIterator, class _Distance,
-          class _UniformRandomNumberGenerator>
-inline _LIBCPP_INLINE_VISIBILITY
-_SampleIterator sample(_PopulationIterator __first,
-                       _PopulationIterator __last, _SampleIterator __output_iter,
-                       _Distance __n, _UniformRandomNumberGenerator&& __g) {
+template <class _PopulationIterator, class _SampleIterator, class _Distance, class _UniformRandomNumberGenerator>
+inline _LIBCPP_HIDE_FROM_ABI _SampleIterator
+sample(_PopulationIterator __first,
+       _PopulationIterator __last,
+       _SampleIterator __output_iter,
+       _Distance __n,
+       _UniformRandomNumberGenerator&& __g) {
   static_assert(__has_forward_iterator_category<_PopulationIterator>::value ||
-                __has_random_access_iterator_category<_SampleIterator>::value,
+                    __has_random_access_iterator_category<_SampleIterator>::value,
                 "SampleIterator must meet the requirements of RandomAccessIterator");
 
-  return std::__sample<_ClassicAlgPolicy>(
-      std::move(__first), std::move(__last), std::move(__output_iter), __n, __g);
+  return std::__sample<_ClassicAlgPolicy>(std::move(__first), std::move(__last), std::move(__output_iter), __n, __g);
 }
 
 #endif // _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/__algorithm/search.h b/third_party/libcxx/__algorithm/search.h
index 5882a0480..b82ca7809 100644
--- a/third_party/libcxx/__algorithm/search.h
+++ b/third_party/libcxx/__algorithm/search.h
@@ -29,17 +29,15 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy,
-          class _Iter1, class _Sent1,
-          class _Iter2, class _Sent2,
+          class _Iter1,
+          class _Sent1,
+          class _Iter2,
+          class _Sent2,
           class _Pred,
           class _Proj1,
           class _Proj2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Iter1, _Iter1> __search_forward_impl(_Iter1 __first1, _Sent1 __last1,
-                                           _Iter2 __first2, _Sent2 __last2,
-                                           _Pred& __pred,
-                                           _Proj1& __proj1,
-                                           _Proj2& __proj2) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1> __search_forward_impl(
+    _Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
   if (__first2 == __last2)
     return std::make_pair(__first1, __first1); // Everything matches an empty sequence
   while (true) {
@@ -64,8 +62,7 @@ pair<_Iter1, _Iter1> __search_forward_impl(_Iter1 __first1, _Sent1 __last1,
       }
 
       // if there is a mismatch, restart with a new __first1
-      if (!std::__invoke(__pred, std::__invoke(__proj1, *__m1), std::__invoke(__proj2, *__m2)))
-      {
+      if (!std::__invoke(__pred, std::__invoke(__proj1, *__m1), std::__invoke(__proj2, *__m2))) {
         ++__first1;
         break;
       } // else there is a match, check next elements
@@ -74,21 +71,25 @@ pair<_Iter1, _Iter1> __search_forward_impl(_Iter1 __first1, _Sent1 __last1,
 }
 
 template <class _AlgPolicy,
-          class _Iter1, class _Sent1,
-          class _Iter2, class _Sent2,
+          class _Iter1,
+          class _Sent1,
+          class _Iter2,
+          class _Sent2,
           class _Pred,
           class _Proj1,
           class _Proj2,
           class _DiffT1,
           class _DiffT2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Iter1, _Iter1> __search_random_access_impl(_Iter1 __first1, _Sent1 __last1,
-                                                 _Iter2 __first2, _Sent2 __last2,
-                                                 _Pred& __pred,
-                                                 _Proj1& __proj1,
-                                                 _Proj2& __proj2,
-                                                 _DiffT1 __size1,
-                                                 _DiffT2 __size2) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1> __search_random_access_impl(
+    _Iter1 __first1,
+    _Sent1 __last1,
+    _Iter2 __first2,
+    _Sent2 __last2,
+    _Pred& __pred,
+    _Proj1& __proj1,
+    _Proj2& __proj2,
+    _DiffT1 __size1,
+    _DiffT2 __size2) {
   const _Iter1 __s = __first1 + __size1 - _DiffT1(__size2 - 1); // Start of pattern match can't go beyond here
 
   while (true) {
@@ -116,20 +117,18 @@ pair<_Iter1, _Iter1> __search_random_access_impl(_Iter1 __first1, _Sent1 __last1
   }
 }
 
-template <class _Iter1, class _Sent1,
-          class _Iter2, class _Sent2,
+template <class _Iter1,
+          class _Sent1,
+          class _Iter2,
+          class _Sent2,
           class _Pred,
           class _Proj1,
-          class _Proj2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Iter1, _Iter1> __search_impl(_Iter1 __first1, _Sent1 __last1,
-                                   _Iter2 __first2, _Sent2 __last2,
-                                   _Pred& __pred,
-                                   _Proj1& __proj1,
-                                   _Proj2& __proj2,
-                                   __enable_if_t<__has_random_access_iterator_category<_Iter1>::value
-                                              && __has_random_access_iterator_category<_Iter2>::value>* = nullptr) {
-
+          class _Proj2,
+          __enable_if_t<__has_random_access_iterator_category<_Iter1>::value &&
+                            __has_random_access_iterator_category<_Iter2>::value,
+                        int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1> __search_impl(
+    _Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
   auto __size2 = __last2 - __first2;
   if (__size2 == 0)
     return std::make_pair(__first1, __first1);
@@ -139,42 +138,34 @@ pair<_Iter1, _Iter1> __search_impl(_Iter1 __first1, _Sent1 __last1,
     return std::make_pair(__last1, __last1);
   }
 
-  return std::__search_random_access_impl<_ClassicAlgPolicy>(__first1, __last1,
-                                                             __first2, __last2,
-                                                             __pred,
-                                                             __proj1,
-                                                             __proj2,
-                                                             __size1,
-                                                             __size2);
+  return std::__search_random_access_impl<_ClassicAlgPolicy>(
+      __first1, __last1, __first2, __last2, __pred, __proj1, __proj2, __size1, __size2);
 }
 
-template <class _Iter1, class _Sent1,
-          class _Iter2, class _Sent2,
-          class _Pred,
-          class _Proj1,
-          class _Proj2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Iter1, _Iter1> __search_impl(_Iter1 __first1, _Sent1 __last1,
-                                   _Iter2 __first2, _Sent2 __last2,
-                                   _Pred& __pred,
-                                   _Proj1& __proj1,
-                                   _Proj2& __proj2,
-                                   __enable_if_t<__has_forward_iterator_category<_Iter1>::value
-                                              && __has_forward_iterator_category<_Iter2>::value
-                                              && !(__has_random_access_iterator_category<_Iter1>::value
-                                                && __has_random_access_iterator_category<_Iter2>::value)>* = nullptr) {
-  return std::__search_forward_impl<_ClassicAlgPolicy>(__first1, __last1,
-                                                       __first2, __last2,
-                                                       __pred,
-                                                       __proj1,
-                                                       __proj2);
+template <
+    class _Iter1,
+    class _Sent1,
+    class _Iter2,
+    class _Sent2,
+    class _Pred,
+    class _Proj1,
+    class _Proj2,
+    __enable_if_t<__has_forward_iterator_category<_Iter1>::value && __has_forward_iterator_category<_Iter2>::value &&
+                      !(__has_random_access_iterator_category<_Iter1>::value &&
+                        __has_random_access_iterator_category<_Iter2>::value),
+                  int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1> __search_impl(
+    _Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
+  return std::__search_forward_impl<_ClassicAlgPolicy>(__first1, __last1, __first2, __last2, __pred, __proj1, __proj2);
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-                         _ForwardIterator2 __first2, _ForwardIterator2 __last2,
-                         _BinaryPredicate __pred) {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator1
+search(_ForwardIterator1 __first1,
+       _ForwardIterator1 __last1,
+       _ForwardIterator2 __first2,
+       _ForwardIterator2 __last2,
+       _BinaryPredicate __pred) {
   static_assert(__is_callable<_BinaryPredicate, decltype(*__first1), decltype(*__first2)>::value,
                 "BinaryPredicate has to be callable");
   auto __proj = __identity();
@@ -182,15 +173,14 @@ _ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator1 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
-                         _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator1
+search(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2, _ForwardIterator2 __last2) {
   return std::search(__first1, __last1, __first2, __last2, __equal_to());
 }
 
 #if _LIBCPP_STD_VER >= 17
 template <class _ForwardIterator, class _Searcher>
-_LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
 search(_ForwardIterator __f, _ForwardIterator __l, const _Searcher& __s) {
   return __s(__f, __l).first;
 }
diff --git a/third_party/libcxx/__algorithm/search_n.h b/third_party/libcxx/__algorithm/search_n.h
index 7e3ddf48a..771647d31 100644
--- a/third_party/libcxx/__algorithm/search_n.h
+++ b/third_party/libcxx/__algorithm/search_n.h
@@ -31,12 +31,8 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Pred, class _Iter, class _Sent, class _SizeT, class _Type, class _Proj>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Iter, _Iter> __search_n_forward_impl(_Iter __first, _Sent __last,
-                                           _SizeT __count,
-                                           const _Type& __value,
-                                           _Pred& __pred,
-                                           _Proj& __proj) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter, _Iter> __search_n_forward_impl(
+    _Iter __first, _Sent __last, _SizeT __count, const _Type& __value, _Pred& __pred, _Proj& __proj) {
   if (__count <= 0)
     return std::make_pair(__first, __first);
   while (true) {
@@ -62,8 +58,7 @@ pair<_Iter, _Iter> __search_n_forward_impl(_Iter __first, _Sent __last,
       }
 
       // if there is a mismatch, restart with a new __first
-      if (!std::__invoke(__pred, std::__invoke(__proj, *__m), __value))
-      {
+      if (!std::__invoke(__pred, std::__invoke(__proj, *__m), __value)) {
         __first = __m;
         ++__first;
         break;
@@ -73,13 +68,8 @@ pair<_Iter, _Iter> __search_n_forward_impl(_Iter __first, _Sent __last,
 }
 
 template <class _AlgPolicy, class _Pred, class _Iter, class _Sent, class _SizeT, class _Type, class _Proj, class _DiffT>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-std::pair<_Iter, _Iter> __search_n_random_access_impl(_Iter __first, _Sent __last,
-                                                      _SizeT __count,
-                                                      const _Type& __value,
-                                                      _Pred& __pred,
-                                                      _Proj& __proj,
-                                                      _DiffT __size1) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 std::pair<_Iter, _Iter> __search_n_random_access_impl(
+    _Iter __first, _Sent __last, _SizeT __count, const _Type& __value, _Pred& __pred, _Proj& __proj, _DiffT __size1) {
   using difference_type = typename iterator_traits<_Iter>::difference_type;
   if (__count == 0)
     return std::make_pair(__first, __first);
@@ -109,8 +99,7 @@ std::pair<_Iter, _Iter> __search_n_random_access_impl(_Iter __first, _Sent __las
       ++__m; // no need to check range on __m because __s guarantees we have enough source
 
       // if there is a mismatch, restart with a new __first
-      if (!std::__invoke(__pred, std::__invoke(__proj, *__m), __value))
-      {
+      if (!std::__invoke(__pred, std::__invoke(__proj, *__m), __value)) {
         __first = __m;
         ++__first;
         break;
@@ -119,61 +108,45 @@ std::pair<_Iter, _Iter> __search_n_random_access_impl(_Iter __first, _Sent __las
   }
 }
 
-template <class _Iter, class _Sent,
+template <class _Iter,
+          class _Sent,
           class _DiffT,
           class _Type,
           class _Pred,
-          class _Proj>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Iter, _Iter> __search_n_impl(_Iter __first, _Sent __last,
-                                   _DiffT __count,
-                                   const _Type& __value,
-                                   _Pred& __pred,
-                                   _Proj& __proj,
-                                   __enable_if_t<__has_random_access_iterator_category<_Iter>::value>* = nullptr) {
-  return std::__search_n_random_access_impl<_ClassicAlgPolicy>(__first, __last,
-                                                               __count,
-                                                               __value,
-                                                               __pred,
-                                                               __proj,
-                                                               __last - __first);
+          class _Proj,
+          __enable_if_t<__has_random_access_iterator_category<_Iter>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter, _Iter>
+__search_n_impl(_Iter __first, _Sent __last, _DiffT __count, const _Type& __value, _Pred& __pred, _Proj& __proj) {
+  return std::__search_n_random_access_impl<_ClassicAlgPolicy>(
+      __first, __last, __count, __value, __pred, __proj, __last - __first);
 }
 
-template <class _Iter1, class _Sent1,
+template <class _Iter1,
+          class _Sent1,
           class _DiffT,
           class _Type,
           class _Pred,
-          class _Proj>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<_Iter1, _Iter1> __search_n_impl(_Iter1 __first, _Sent1 __last,
-                                     _DiffT __count,
-                                     const _Type& __value,
-                                     _Pred& __pred,
-                                     _Proj& __proj,
-                                     __enable_if_t<__has_forward_iterator_category<_Iter1>::value
-                                               && !__has_random_access_iterator_category<_Iter1>::value>* = nullptr) {
-  return std::__search_n_forward_impl<_ClassicAlgPolicy>(__first, __last,
-                                                         __count,
-                                                         __value,
-                                                         __pred,
-                                                         __proj);
+          class _Proj,
+          __enable_if_t<__has_forward_iterator_category<_Iter1>::value &&
+                            !__has_random_access_iterator_category<_Iter1>::value,
+                        int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1>
+__search_n_impl(_Iter1 __first, _Sent1 __last, _DiffT __count, const _Type& __value, _Pred& __pred, _Proj& __proj) {
+  return std::__search_n_forward_impl<_ClassicAlgPolicy>(__first, __last, __count, __value, __pred, __proj);
 }
 
 template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last,
-                          _Size __count,
-                          const _Tp& __value,
-                          _BinaryPredicate __pred) {
-  static_assert(__is_callable<_BinaryPredicate, decltype(*__first), const _Tp&>::value,
-                "BinaryPredicate has to be callable");
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator search_n(
+    _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, _BinaryPredicate __pred) {
+  static_assert(
+      __is_callable<_BinaryPredicate, decltype(*__first), const _Tp&>::value, "BinaryPredicate has to be callable");
   auto __proj = __identity();
   return std::__search_n_impl(__first, __last, std::__convert_to_integral(__count), __value, __pred, __proj).first;
 }
 
 template <class _ForwardIterator, class _Size, class _Tp>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
   return std::search_n(__first, __last, std::__convert_to_integral(__count), __value, __equal_to());
 }
 
diff --git a/third_party/libcxx/__algorithm/set_difference.h b/third_party/libcxx/__algorithm/set_difference.h
index 5a7d3bc18..f414bcecb 100644
--- a/third_party/libcxx/__algorithm/set_difference.h
+++ b/third_party/libcxx/__algorithm/set_difference.h
@@ -25,6 +25,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Comp, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
@@ -55,7 +58,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_d
     _OutputIterator __result,
     _Compare __comp) {
   return std::__set_difference<_ClassicAlgPolicy, __comp_ref_type<_Compare> >(
-      __first1, __last1, __first2, __last2, __result, __comp)
+             __first1, __last1, __first2, __last2, __result, __comp)
       .second;
 }
 
@@ -66,16 +69,11 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_d
     _InputIterator2 __first2,
     _InputIterator2 __last2,
     _OutputIterator __result) {
-  return std::__set_difference<_ClassicAlgPolicy>(
-      __first1,
-      __last1,
-      __first2,
-      __last2,
-      __result,
-      __less<typename iterator_traits<_InputIterator1>::value_type,
-             typename iterator_traits<_InputIterator2>::value_type>()).second;
+  return std::__set_difference<_ClassicAlgPolicy>(__first1, __last1, __first2, __last2, __result, __less<>()).second;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_SET_DIFFERENCE_H
diff --git a/third_party/libcxx/__algorithm/set_intersection.h b/third_party/libcxx/__algorithm/set_intersection.h
index 9fa7799ae..bb0d86cd0 100644
--- a/third_party/libcxx/__algorithm/set_intersection.h
+++ b/third_party/libcxx/__algorithm/set_intersection.h
@@ -12,15 +12,23 @@
 #include <__algorithm/comp.h>
 #include <__algorithm/comp_ref_type.h>
 #include <__algorithm/iterator_operations.h>
+#include <__algorithm/lower_bound.h>
 #include <__config>
+#include <__functional/identity.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
+#include <__type_traits/is_same.h>
+#include <__utility/exchange.h>
 #include <__utility/move.h>
+#include <__utility/swap.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InIter1, class _InIter2, class _OutIter>
@@ -35,10 +43,103 @@ struct __set_intersection_result {
       : __in1_(std::move(__in_iter1)), __in2_(std::move(__in_iter2)), __out_(std::move(__out_iter)) {}
 };
 
-template <class _AlgPolicy, class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __set_intersection_result<_InIter1, _InIter2, _OutIter>
+// Helper for __set_intersection() with one-sided binary search: populate result and advance input iterators if they
+// are found to potentially contain the same value in two consecutive calls. This function is very intimately related to
+// the way it is used and doesn't attempt to abstract that, it's not appropriate for general usage outside of its
+// context.
+template <class _InForwardIter1, class _InForwardIter2, class _OutIter>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __set_intersection_add_output_if_equal(
+    bool __may_be_equal,
+    _InForwardIter1& __first1,
+    _InForwardIter2& __first2,
+    _OutIter& __result,
+    bool& __prev_may_be_equal) {
+  if (__may_be_equal && __prev_may_be_equal) {
+    *__result = *__first1;
+    ++__result;
+    ++__first1;
+    ++__first2;
+    __prev_may_be_equal = false;
+  } else {
+    __prev_may_be_equal = __may_be_equal;
+  }
+}
+
+// With forward iterators we can make multiple passes over the data, allowing the use of one-sided binary search to
+// reduce best-case complexity to log(N). Understanding how we can use binary search and still respect complexity
+// guarantees is _not_ straightforward: the guarantee is "at most 2*(N+M)-1 comparisons", and one-sided binary search
+// will necessarily overshoot depending on the position of the needle in the haystack -- for instance, if we're
+// searching for 3 in (1, 2, 3, 4), we'll check if 3<1, then 3<2, then 3<4, and, finally, 3<3, for a total of 4
+// comparisons, when linear search would have yielded 3. However, because we won't need to perform the intervening
+// reciprocal comparisons (ie 1<3, 2<3, 4<3), that extra comparison doesn't run afoul of the guarantee. Additionally,
+// this type of scenario can only happen for match distances of up to 5 elements, because 2*log2(8) is 6, and we'll
+// still be worse-off at position 5 of an 8-element set. From then onwards these scenarios can't happen. TL;DR: we'll be
+// 1 comparison worse-off compared to the classic linear-searching algorithm if matching position 3 of a set with 4
+// elements, or position 5 if the set has 7 or 8 elements, but we'll never exceed the complexity guarantees from the
+// standard.
+template <class _AlgPolicy,
+          class _Compare,
+          class _InForwardIter1,
+          class _Sent1,
+          class _InForwardIter2,
+          class _Sent2,
+          class _OutIter>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 __set_intersection_result<_InForwardIter1, _InForwardIter2, _OutIter>
 __set_intersection(
-    _InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) {
+    _InForwardIter1 __first1,
+    _Sent1 __last1,
+    _InForwardIter2 __first2,
+    _Sent2 __last2,
+    _OutIter __result,
+    _Compare&& __comp,
+    std::forward_iterator_tag,
+    std::forward_iterator_tag) {
+  _LIBCPP_CONSTEXPR std::__identity __proj;
+  bool __prev_may_be_equal = false;
+
+  while (__first2 != __last2) {
+    _InForwardIter1 __first1_next =
+        std::__lower_bound_onesided<_AlgPolicy>(__first1, __last1, *__first2, __comp, __proj);
+    std::swap(__first1_next, __first1);
+    // keeping in mind that a==b iff !(a<b) && !(b<a):
+    // if we can't advance __first1, that means !(*__first1 < *_first2), therefore __may_be_equal==true
+    std::__set_intersection_add_output_if_equal(
+        __first1 == __first1_next, __first1, __first2, __result, __prev_may_be_equal);
+    if (__first1 == __last1)
+      break;
+
+    _InForwardIter2 __first2_next =
+        std::__lower_bound_onesided<_AlgPolicy>(__first2, __last2, *__first1, __comp, __proj);
+    std::swap(__first2_next, __first2);
+    std::__set_intersection_add_output_if_equal(
+        __first2 == __first2_next, __first1, __first2, __result, __prev_may_be_equal);
+  }
+  return __set_intersection_result<_InForwardIter1, _InForwardIter2, _OutIter>(
+      _IterOps<_AlgPolicy>::next(std::move(__first1), std::move(__last1)),
+      _IterOps<_AlgPolicy>::next(std::move(__first2), std::move(__last2)),
+      std::move(__result));
+}
+
+// input iterators are not suitable for multipass algorithms, so we stick to the classic single-pass version
+template <class _AlgPolicy,
+          class _Compare,
+          class _InInputIter1,
+          class _Sent1,
+          class _InInputIter2,
+          class _Sent2,
+          class _OutIter>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 __set_intersection_result<_InInputIter1, _InInputIter2, _OutIter>
+__set_intersection(
+    _InInputIter1 __first1,
+    _Sent1 __last1,
+    _InInputIter2 __first2,
+    _Sent2 __last2,
+    _OutIter __result,
+    _Compare&& __comp,
+    std::input_iterator_tag,
+    std::input_iterator_tag) {
   while (__first1 != __last1 && __first2 != __last2) {
     if (__comp(*__first1, *__first2))
       ++__first1;
@@ -52,12 +153,28 @@ __set_intersection(
     }
   }
 
-  return __set_intersection_result<_InIter1, _InIter2, _OutIter>(
+  return __set_intersection_result<_InInputIter1, _InInputIter2, _OutIter>(
       _IterOps<_AlgPolicy>::next(std::move(__first1), std::move(__last1)),
       _IterOps<_AlgPolicy>::next(std::move(__first2), std::move(__last2)),
       std::move(__result));
 }
 
+template <class _AlgPolicy, class _Compare, class _InIter1, class _Sent1, class _InIter2, class _Sent2, class _OutIter>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 __set_intersection_result<_InIter1, _InIter2, _OutIter>
+__set_intersection(
+    _InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Sent2 __last2, _OutIter __result, _Compare&& __comp) {
+  return std::__set_intersection<_AlgPolicy>(
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__last2),
+      std::move(__result),
+      std::forward<_Compare>(__comp),
+      typename std::_IterOps<_AlgPolicy>::template __iterator_category<_InIter1>(),
+      typename std::_IterOps<_AlgPolicy>::template __iterator_category<_InIter2>());
+}
+
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_intersection(
     _InputIterator1 __first1,
@@ -89,11 +206,12 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_i
              std::move(__first2),
              std::move(__last2),
              std::move(__result),
-             __less<typename iterator_traits<_InputIterator1>::value_type,
-                    typename iterator_traits<_InputIterator2>::value_type>())
+             __less<>())
       .__out_;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_SET_INTERSECTION_H
diff --git a/third_party/libcxx/__algorithm/set_symmetric_difference.h b/third_party/libcxx/__algorithm/set_symmetric_difference.h
index bcb095870..db36665a6 100644
--- a/third_party/libcxx/__algorithm/set_symmetric_difference.h
+++ b/third_party/libcxx/__algorithm/set_symmetric_difference.h
@@ -22,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InIter1, class _InIter2, class _OutIter>
@@ -96,10 +99,11 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_symmetri
       std::move(__first2),
       std::move(__last2),
       std::move(__result),
-      __less<typename iterator_traits<_InputIterator1>::value_type,
-             typename iterator_traits<_InputIterator2>::value_type>());
+      __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_SET_SYMMETRIC_DIFFERENCE_H
diff --git a/third_party/libcxx/__algorithm/set_union.h b/third_party/libcxx/__algorithm/set_union.h
index 4d154b81e..a79c50fd3 100644
--- a/third_party/libcxx/__algorithm/set_union.h
+++ b/third_party/libcxx/__algorithm/set_union.h
@@ -22,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InIter1, class _InIter2, class _OutIter>
@@ -92,10 +95,11 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator set_union(
       std::move(__first2),
       std::move(__last2),
       std::move(__result),
-      __less<typename iterator_traits<_InputIterator1>::value_type,
-             typename iterator_traits<_InputIterator2>::value_type>());
+      __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_SET_UNION_H
diff --git a/third_party/libcxx/__algorithm/shift_left.h b/third_party/libcxx/__algorithm/shift_left.h
index 023b56dcf..06cd7c5f8 100644
--- a/third_party/libcxx/__algorithm/shift_left.h
+++ b/third_party/libcxx/__algorithm/shift_left.h
@@ -17,39 +17,43 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 template <class _ForwardIterator>
-inline _LIBCPP_INLINE_VISIBILITY constexpr
-_ForwardIterator
-shift_left(_ForwardIterator __first, _ForwardIterator __last,
-           typename iterator_traits<_ForwardIterator>::difference_type __n)
-{
-    if (__n == 0) {
-        return __last;
-    }
+inline _LIBCPP_HIDE_FROM_ABI constexpr _ForwardIterator
+shift_left(_ForwardIterator __first,
+           _ForwardIterator __last,
+           typename iterator_traits<_ForwardIterator>::difference_type __n) {
+  if (__n == 0) {
+    return __last;
+  }
 
-    _ForwardIterator __m = __first;
-    if constexpr (__has_random_access_iterator_category<_ForwardIterator>::value) {
-        if (__n >= __last - __first) {
-            return __first;
-        }
-        __m += __n;
-    } else {
-        for (; __n > 0; --__n) {
-            if (__m == __last) {
-                return __first;
-            }
-            ++__m;
-        }
+  _ForwardIterator __m = __first;
+  if constexpr (__has_random_access_iterator_category<_ForwardIterator>::value) {
+    if (__n >= __last - __first) {
+      return __first;
     }
-    return _VSTD::move(__m, __last, __first);
+    __m += __n;
+  } else {
+    for (; __n > 0; --__n) {
+      if (__m == __last) {
+        return __first;
+      }
+      ++__m;
+    }
+  }
+  return std::move(__m, __last, __first);
 }
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_SHIFT_LEFT_H
diff --git a/third_party/libcxx/__algorithm/shift_right.h b/third_party/libcxx/__algorithm/shift_right.h
index 70aff45fe..01853057f 100644
--- a/third_party/libcxx/__algorithm/shift_right.h
+++ b/third_party/libcxx/__algorithm/shift_right.h
@@ -20,82 +20,86 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 template <class _ForwardIterator>
-inline _LIBCPP_INLINE_VISIBILITY constexpr
-_ForwardIterator
-shift_right(_ForwardIterator __first, _ForwardIterator __last,
-            typename iterator_traits<_ForwardIterator>::difference_type __n)
-{
-    if (__n == 0) {
-        return __first;
+inline _LIBCPP_HIDE_FROM_ABI constexpr _ForwardIterator
+shift_right(_ForwardIterator __first,
+            _ForwardIterator __last,
+            typename iterator_traits<_ForwardIterator>::difference_type __n) {
+  if (__n == 0) {
+    return __first;
+  }
+
+  if constexpr (__has_random_access_iterator_category<_ForwardIterator>::value) {
+    decltype(__n) __d = __last - __first;
+    if (__n >= __d) {
+      return __last;
+    }
+    _ForwardIterator __m = __first + (__d - __n);
+    return std::move_backward(__first, __m, __last);
+  } else if constexpr (__has_bidirectional_iterator_category<_ForwardIterator>::value) {
+    _ForwardIterator __m = __last;
+    for (; __n > 0; --__n) {
+      if (__m == __first) {
+        return __last;
+      }
+      --__m;
+    }
+    return std::move_backward(__first, __m, __last);
+  } else {
+    _ForwardIterator __ret = __first;
+    for (; __n > 0; --__n) {
+      if (__ret == __last) {
+        return __last;
+      }
+      ++__ret;
     }
 
-    if constexpr (__has_random_access_iterator_category<_ForwardIterator>::value) {
-        decltype(__n) __d = __last - __first;
-        if (__n >= __d) {
-            return __last;
-        }
-        _ForwardIterator __m = __first + (__d - __n);
-        return _VSTD::move_backward(__first, __m, __last);
-    } else if constexpr (__has_bidirectional_iterator_category<_ForwardIterator>::value) {
-        _ForwardIterator __m = __last;
-        for (; __n > 0; --__n) {
-            if (__m == __first) {
-                return __last;
-            }
-            --__m;
-        }
-        return _VSTD::move_backward(__first, __m, __last);
-    } else {
-        _ForwardIterator __ret = __first;
-        for (; __n > 0; --__n) {
-            if (__ret == __last) {
-                return __last;
-            }
-            ++__ret;
-        }
+    // We have an __n-element scratch space from __first to __ret.
+    // Slide an __n-element window [__trail, __lead) from left to right.
+    // We're essentially doing swap_ranges(__first, __ret, __trail, __lead)
+    // over and over; but once __lead reaches __last we needn't bother
+    // to save the values of elements [__trail, __last).
 
-        // We have an __n-element scratch space from __first to __ret.
-        // Slide an __n-element window [__trail, __lead) from left to right.
-        // We're essentially doing swap_ranges(__first, __ret, __trail, __lead)
-        // over and over; but once __lead reaches __last we needn't bother
-        // to save the values of elements [__trail, __last).
-
-        auto __trail = __first;
-        auto __lead = __ret;
-        while (__trail != __ret) {
-            if (__lead == __last) {
-                _VSTD::move(__first, __trail, __ret);
-                return __ret;
-            }
-            ++__trail;
-            ++__lead;
-        }
-
-        _ForwardIterator __mid = __first;
-        while (true) {
-            if (__lead == __last) {
-                __trail = _VSTD::move(__mid, __ret, __trail);
-                _VSTD::move(__first, __mid, __trail);
-                return __ret;
-            }
-            swap(*__mid, *__trail);
-            ++__mid;
-            ++__trail;
-            ++__lead;
-            if (__mid == __ret) {
-                __mid = __first;
-            }
-        }
+    auto __trail = __first;
+    auto __lead  = __ret;
+    while (__trail != __ret) {
+      if (__lead == __last) {
+        std::move(__first, __trail, __ret);
+        return __ret;
+      }
+      ++__trail;
+      ++__lead;
     }
+
+    _ForwardIterator __mid = __first;
+    while (true) {
+      if (__lead == __last) {
+        __trail = std::move(__mid, __ret, __trail);
+        std::move(__first, __mid, __trail);
+        return __ret;
+      }
+      swap(*__mid, *__trail);
+      ++__mid;
+      ++__trail;
+      ++__lead;
+      if (__mid == __ret) {
+        __mid = __first;
+      }
+    }
+  }
 }
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_SHIFT_RIGHT_H
diff --git a/third_party/libcxx/__algorithm/shuffle.h b/third_party/libcxx/__algorithm/shuffle.h
index d6cc3401a..c9c56ce8c 100644
--- a/third_party/libcxx/__algorithm/shuffle.h
+++ b/third_party/libcxx/__algorithm/shuffle.h
@@ -11,7 +11,6 @@
 
 #include <__algorithm/iterator_operations.h>
 #include <__config>
-#include <__debug>
 #include <__iterator/iterator_traits.h>
 #include <__random/uniform_int_distribution.h>
 #include <__utility/forward.h>
@@ -29,12 +28,12 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TYPE_VIS __libcpp_debug_randomizer {
+class _LIBCPP_EXPORTED_FROM_ABI __libcpp_debug_randomizer {
 public:
   _LIBCPP_HIDE_FROM_ABI __libcpp_debug_randomizer() {
     __state_ = __seed();
-    __inc_ = __state_ + 0xda3e39cb94b95bdbULL;
-    __inc_ = (__inc_ << 1) | 1;
+    __inc_   = __state_ + 0xda3e39cb94b95bdbULL;
+    __inc_   = (__inc_ << 1) | 1;
   }
   typedef uint_fast32_t result_type;
 
@@ -43,7 +42,7 @@ public:
 
   _LIBCPP_HIDE_FROM_ABI result_type operator()() {
     uint_fast64_t __oldstate = __state_;
-    __state_ = __oldstate * 6364136223846793005ULL + __inc_;
+    __state_                 = __oldstate * 6364136223846793005ULL + __inc_;
     return __oldstate >> 32;
   }
 
@@ -63,102 +62,95 @@ private:
   }
 };
 
-#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE) \
-  || defined(_LIBCPP_BUILDING_LIBRARY)
-class _LIBCPP_TYPE_VIS __rs_default;
+#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE) || defined(_LIBCPP_BUILDING_LIBRARY)
+class _LIBCPP_EXPORTED_FROM_ABI __rs_default;
 
-_LIBCPP_FUNC_VIS __rs_default __rs_get();
+_LIBCPP_EXPORTED_FROM_ABI __rs_default __rs_get();
 
-class _LIBCPP_TYPE_VIS __rs_default
-{
-    static unsigned __c_;
+class _LIBCPP_EXPORTED_FROM_ABI __rs_default {
+  static unsigned __c_;
+
+  __rs_default();
 
-    __rs_default();
 public:
-    typedef uint_fast32_t result_type;
+  typedef uint_fast32_t result_type;
 
-    static const result_type _Min = 0;
-    static const result_type _Max = 0xFFFFFFFF;
+  static const result_type _Min = 0;
+  static const result_type _Max = 0xFFFFFFFF;
 
-    __rs_default(const __rs_default&);
-    ~__rs_default();
+  __rs_default(const __rs_default&);
+  ~__rs_default();
 
-    result_type operator()();
+  result_type operator()();
 
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR result_type min() {return _Min;}
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR result_type max() {return _Max;}
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR result_type max() { return _Max; }
 
-    friend _LIBCPP_FUNC_VIS __rs_default __rs_get();
+  friend _LIBCPP_EXPORTED_FROM_ABI __rs_default __rs_get();
 };
 
-_LIBCPP_FUNC_VIS __rs_default __rs_get();
+_LIBCPP_EXPORTED_FROM_ABI __rs_default __rs_get();
 
 template <class _RandomAccessIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_IN_CXX14 void
-random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
-{
-    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-    typedef uniform_int_distribution<ptrdiff_t> _Dp;
-    typedef typename _Dp::param_type _Pp;
-    difference_type __d = __last - __first;
-    if (__d > 1)
-    {
-        _Dp __uid;
-        __rs_default __g = __rs_get();
-        for (--__last, (void) --__d; __first < __last; ++__first, (void) --__d)
-        {
-            difference_type __i = __uid(__g, _Pp(0, __d));
-            if (__i != difference_type(0))
-                swap(*__first, *(__first + __i));
-        }
+random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last) {
+  typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
+  typedef uniform_int_distribution<ptrdiff_t> _Dp;
+  typedef typename _Dp::param_type _Pp;
+  difference_type __d = __last - __first;
+  if (__d > 1) {
+    _Dp __uid;
+    __rs_default __g = __rs_get();
+    for (--__last, (void)--__d; __first < __last; ++__first, (void)--__d) {
+      difference_type __i = __uid(__g, _Pp(0, __d));
+      if (__i != difference_type(0))
+        swap(*__first, *(__first + __i));
     }
+  }
 }
 
 template <class _RandomAccessIterator, class _RandomNumberGenerator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_IN_CXX14 void
-random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
-#ifndef _LIBCPP_CXX03_LANG
+random_shuffle(_RandomAccessIterator __first,
+               _RandomAccessIterator __last,
+#  ifndef _LIBCPP_CXX03_LANG
                _RandomNumberGenerator&& __rand)
-#else
+#  else
                _RandomNumberGenerator& __rand)
-#endif
+#  endif
 {
-    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-    difference_type __d = __last - __first;
-    if (__d > 1)
-    {
-        for (--__last; __first < __last; ++__first, (void) --__d)
-        {
-            difference_type __i = __rand(__d);
-            if (__i != difference_type(0))
-              swap(*__first, *(__first + __i));
-        }
+  typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
+  difference_type __d = __last - __first;
+  if (__d > 1) {
+    for (--__last; __first < __last; ++__first, (void)--__d) {
+      difference_type __i = __rand(__d);
+      if (__i != difference_type(0))
+        swap(*__first, *(__first + __i));
     }
+  }
 }
 #endif
 
 template <class _AlgPolicy, class _RandomAccessIterator, class _Sentinel, class _UniformRandomNumberGenerator>
-_LIBCPP_HIDE_FROM_ABI _RandomAccessIterator __shuffle(
-    _RandomAccessIterator __first, _Sentinel __last_sentinel, _UniformRandomNumberGenerator&& __g) {
-    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-    typedef uniform_int_distribution<ptrdiff_t> _Dp;
-    typedef typename _Dp::param_type _Pp;
+_LIBCPP_HIDE_FROM_ABI _RandomAccessIterator
+__shuffle(_RandomAccessIterator __first, _Sentinel __last_sentinel, _UniformRandomNumberGenerator&& __g) {
+  typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
+  typedef uniform_int_distribution<ptrdiff_t> _Dp;
+  typedef typename _Dp::param_type _Pp;
 
-    auto __original_last = _IterOps<_AlgPolicy>::next(__first, __last_sentinel);
-    auto __last = __original_last;
-    difference_type __d = __last - __first;
-    if (__d > 1)
-    {
-        _Dp __uid;
-        for (--__last, (void) --__d; __first < __last; ++__first, (void) --__d)
-        {
-            difference_type __i = __uid(__g, _Pp(0, __d));
-            if (__i != difference_type(0))
-                _IterOps<_AlgPolicy>::iter_swap(__first, __first + __i);
-        }
+  auto __original_last = _IterOps<_AlgPolicy>::next(__first, __last_sentinel);
+  auto __last          = __original_last;
+  difference_type __d  = __last - __first;
+  if (__d > 1) {
+    _Dp __uid;
+    for (--__last, (void)--__d; __first < __last; ++__first, (void)--__d) {
+      difference_type __i = __uid(__g, _Pp(0, __d));
+      if (__i != difference_type(0))
+        _IterOps<_AlgPolicy>::iter_swap(__first, __first + __i);
     }
+  }
 
-    return __original_last;
+  return __original_last;
 }
 
 template <class _RandomAccessIterator, class _UniformRandomNumberGenerator>
diff --git a/third_party/libcxx/__algorithm/sift_down.h b/third_party/libcxx/__algorithm/sift_down.h
index e3972fb6f..42803e306 100644
--- a/third_party/libcxx/__algorithm/sift_down.h
+++ b/third_party/libcxx/__algorithm/sift_down.h
@@ -19,96 +19,100 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
-__sift_down(_RandomAccessIterator __first, _Compare&& __comp,
+__sift_down(_RandomAccessIterator __first,
+            _Compare&& __comp,
             typename iterator_traits<_RandomAccessIterator>::difference_type __len,
-            _RandomAccessIterator __start)
-{
-    using _Ops = _IterOps<_AlgPolicy>;
+            _RandomAccessIterator __start) {
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
-    // left-child of __start is at 2 * __start + 1
-    // right-child of __start is at 2 * __start + 2
-    difference_type __child = __start - __first;
+  typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
+  typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
+  // left-child of __start is at 2 * __start + 1
+  // right-child of __start is at 2 * __start + 2
+  difference_type __child = __start - __first;
 
-    if (__len < 2 || (__len - 2) / 2 < __child)
-        return;
+  if (__len < 2 || (__len - 2) / 2 < __child)
+    return;
 
-    __child = 2 * __child + 1;
-    _RandomAccessIterator __child_i = __first + __child;
+  __child                         = 2 * __child + 1;
+  _RandomAccessIterator __child_i = __first + __child;
+
+  if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + difference_type(1)))) {
+    // right-child exists and is greater than left-child
+    ++__child_i;
+    ++__child;
+  }
+
+  // check if we are in heap-order
+  if (__comp(*__child_i, *__start))
+    // we are, __start is larger than its largest child
+    return;
+
+  value_type __top(_Ops::__iter_move(__start));
+  do {
+    // we are not in heap-order, swap the parent with its largest child
+    *__start = _Ops::__iter_move(__child_i);
+    __start  = __child_i;
+
+    if ((__len - 2) / 2 < __child)
+      break;
+
+    // recompute the child based off of the updated parent
+    __child   = 2 * __child + 1;
+    __child_i = __first + __child;
 
     if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + difference_type(1)))) {
-        // right-child exists and is greater than left-child
-        ++__child_i;
-        ++__child;
+      // right-child exists and is greater than left-child
+      ++__child_i;
+      ++__child;
     }
 
     // check if we are in heap-order
-    if (__comp(*__child_i, *__start))
-        // we are, __start is larger than its largest child
-        return;
-
-    value_type __top(_Ops::__iter_move(__start));
-    do
-    {
-        // we are not in heap-order, swap the parent with its largest child
-        *__start = _Ops::__iter_move(__child_i);
-        __start = __child_i;
-
-        if ((__len - 2) / 2 < __child)
-            break;
-
-        // recompute the child based off of the updated parent
-        __child = 2 * __child + 1;
-        __child_i = __first + __child;
-
-        if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + difference_type(1)))) {
-            // right-child exists and is greater than left-child
-            ++__child_i;
-            ++__child;
-        }
-
-        // check if we are in heap-order
-    } while (!__comp(*__child_i, __top));
-    *__start = _VSTD::move(__top);
+  } while (!__comp(*__child_i, __top));
+  *__start = std::move(__top);
 }
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _RandomAccessIterator
-__floyd_sift_down(_RandomAccessIterator __first, _Compare&& __comp,
-                  typename iterator_traits<_RandomAccessIterator>::difference_type __len)
-{
-    using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;
-    _LIBCPP_ASSERT(__len >= 2, "shouldn't be called unless __len >= 2");
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _RandomAccessIterator __floyd_sift_down(
+    _RandomAccessIterator __first,
+    _Compare&& __comp,
+    typename iterator_traits<_RandomAccessIterator>::difference_type __len) {
+  using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;
+  _LIBCPP_ASSERT_INTERNAL(__len >= 2, "shouldn't be called unless __len >= 2");
 
-    _RandomAccessIterator __hole = __first;
-    _RandomAccessIterator __child_i = __first;
-    difference_type __child = 0;
+  _RandomAccessIterator __hole    = __first;
+  _RandomAccessIterator __child_i = __first;
+  difference_type __child         = 0;
 
-    while (true) {
-        __child_i += difference_type(__child + 1);
-        __child = 2 * __child + 1;
+  while (true) {
+    __child_i += difference_type(__child + 1);
+    __child = 2 * __child + 1;
 
-        if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + difference_type(1)))) {
-            // right-child exists and is greater than left-child
-            ++__child_i;
-            ++__child;
-        }
-
-        // swap __hole with its largest child
-        *__hole = _IterOps<_AlgPolicy>::__iter_move(__child_i);
-        __hole = __child_i;
-
-        // if __hole is now a leaf, we're done
-        if (__child > (__len - 2) / 2)
-            return __hole;
+    if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + difference_type(1)))) {
+      // right-child exists and is greater than left-child
+      ++__child_i;
+      ++__child;
     }
+
+    // swap __hole with its largest child
+    *__hole = _IterOps<_AlgPolicy>::__iter_move(__child_i);
+    __hole  = __child_i;
+
+    // if __hole is now a leaf, we're done
+    if (__child > (__len - 2) / 2)
+      return __hole;
+  }
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_SIFT_DOWN_H
diff --git a/third_party/libcxx/__algorithm/simd_utils.h b/third_party/libcxx/__algorithm/simd_utils.h
new file mode 100644
index 000000000..549197be8
--- /dev/null
+++ b/third_party/libcxx/__algorithm/simd_utils.h
@@ -0,0 +1,164 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ALGORITHM_SIMD_UTILS_H
+#define _LIBCPP___ALGORITHM_SIMD_UTILS_H
+
+#include <__algorithm/min.h>
+#include <__bit/bit_cast.h>
+#include <__bit/countl.h>
+#include <__bit/countr.h>
+#include <__config>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_same.h>
+#include <__utility/integer_sequence.h>
+#include <cstddef>
+#include <cstdint>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+// TODO: Find out how altivec changes things and allow vectorizations there too.
+#if _LIBCPP_STD_VER >= 14 && defined(_LIBCPP_CLANG_VER) && !defined(__ALTIVEC__)
+#  define _LIBCPP_HAS_ALGORITHM_VECTOR_UTILS 1
+#else
+#  define _LIBCPP_HAS_ALGORITHM_VECTOR_UTILS 0
+#endif
+
+#if _LIBCPP_HAS_ALGORITHM_VECTOR_UTILS && !defined(__OPTIMIZE_SIZE__)
+#  define _LIBCPP_VECTORIZE_ALGORITHMS 1
+#else
+#  define _LIBCPP_VECTORIZE_ALGORITHMS 0
+#endif
+
+#if _LIBCPP_HAS_ALGORITHM_VECTOR_UTILS
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+inline constexpr bool __can_map_to_integer_v =
+    sizeof(_Tp) == alignof(_Tp) && (sizeof(_Tp) == 1 || sizeof(_Tp) == 2 || sizeof(_Tp) == 4 || sizeof(_Tp) == 8);
+
+template <size_t _TypeSize>
+struct __get_as_integer_type_impl;
+
+template <>
+struct __get_as_integer_type_impl<1> {
+  using type = uint8_t;
+};
+
+template <>
+struct __get_as_integer_type_impl<2> {
+  using type = uint16_t;
+};
+template <>
+struct __get_as_integer_type_impl<4> {
+  using type = uint32_t;
+};
+template <>
+struct __get_as_integer_type_impl<8> {
+  using type = uint64_t;
+};
+
+template <class _Tp>
+using __get_as_integer_type_t = typename __get_as_integer_type_impl<sizeof(_Tp)>::type;
+
+// This isn't specialized for 64 byte vectors on purpose. They have the potential to significantly reduce performance
+// in mixed simd/non-simd workloads and don't provide any performance improvement for currently vectorized algorithms
+// as far as benchmarks are concerned.
+#  if defined(__AVX__) || defined(__MVS__)
+template <class _Tp>
+inline constexpr size_t __native_vector_size = 32 / sizeof(_Tp);
+#  elif defined(__SSE__) || defined(__ARM_NEON__)
+template <class _Tp>
+inline constexpr size_t __native_vector_size = 16 / sizeof(_Tp);
+#  elif defined(__MMX__)
+template <class _Tp>
+inline constexpr size_t __native_vector_size = 8 / sizeof(_Tp);
+#  else
+template <class _Tp>
+inline constexpr size_t __native_vector_size = 1;
+#  endif
+
+template <class _ArithmeticT, size_t _Np>
+using __simd_vector __attribute__((__ext_vector_type__(_Np))) = _ArithmeticT;
+
+template <class _VecT>
+inline constexpr size_t __simd_vector_size_v = []<bool _False = false>() -> size_t {
+  static_assert(_False, "Not a vector!");
+}();
+
+template <class _Tp, size_t _Np>
+inline constexpr size_t __simd_vector_size_v<__simd_vector<_Tp, _Np>> = _Np;
+
+template <class _Tp, size_t _Np>
+_LIBCPP_HIDE_FROM_ABI _Tp __simd_vector_underlying_type_impl(__simd_vector<_Tp, _Np>) {
+  return _Tp{};
+}
+
+template <class _VecT>
+using __simd_vector_underlying_type_t = decltype(std::__simd_vector_underlying_type_impl(_VecT{}));
+
+// This isn't inlined without always_inline when loading chars.
+template <class _VecT, class _Iter>
+_LIBCPP_NODISCARD _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _VecT __load_vector(_Iter __iter) noexcept {
+  return [=]<size_t... _Indices>(index_sequence<_Indices...>) _LIBCPP_ALWAYS_INLINE noexcept {
+    return _VecT{__iter[_Indices]...};
+  }(make_index_sequence<__simd_vector_size_v<_VecT>>{});
+}
+
+template <class _Tp, size_t _Np>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool __all_of(__simd_vector<_Tp, _Np> __vec) noexcept {
+  return __builtin_reduce_and(__builtin_convertvector(__vec, __simd_vector<bool, _Np>));
+}
+
+template <class _Tp, size_t _Np>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI size_t __find_first_set(__simd_vector<_Tp, _Np> __vec) noexcept {
+  using __mask_vec = __simd_vector<bool, _Np>;
+
+  // This has MSan disabled du to https://github.com/llvm/llvm-project/issues/85876
+  auto __impl = [&]<class _MaskT>(_MaskT) _LIBCPP_NO_SANITIZE("memory") noexcept {
+#  if defined(_LIBCPP_BIG_ENDIAN)
+    return std::min<size_t>(
+        _Np, std::__countl_zero(__builtin_bit_cast(_MaskT, __builtin_convertvector(__vec, __mask_vec))));
+#  else
+    return std::min<size_t>(
+        _Np, std::__countr_zero(__builtin_bit_cast(_MaskT, __builtin_convertvector(__vec, __mask_vec))));
+#  endif
+  };
+
+  if constexpr (sizeof(__mask_vec) == sizeof(uint8_t)) {
+    return __impl(uint8_t{});
+  } else if constexpr (sizeof(__mask_vec) == sizeof(uint16_t)) {
+    return __impl(uint16_t{});
+  } else if constexpr (sizeof(__mask_vec) == sizeof(uint32_t)) {
+    return __impl(uint32_t{});
+  } else if constexpr (sizeof(__mask_vec) == sizeof(uint64_t)) {
+    return __impl(uint64_t{});
+  } else {
+    static_assert(sizeof(__mask_vec) == 0, "unexpected required size for mask integer type");
+    return 0;
+  }
+}
+
+template <class _Tp, size_t _Np>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI size_t __find_first_not_set(__simd_vector<_Tp, _Np> __vec) noexcept {
+  return std::__find_first_set(~__vec);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_HAS_ALGORITHM_VECTOR_UTILS
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ALGORITHM_SIMD_UTILS_H
diff --git a/third_party/libcxx/__algorithm/sort.h b/third_party/libcxx/__algorithm/sort.h
index 77e0b2e92..07b581463 100644
--- a/third_party/libcxx/__algorithm/sort.h
+++ b/third_party/libcxx/__algorithm/sort.h
@@ -21,14 +21,15 @@
 #include <__bit/countl.h>
 #include <__bit/countr.h>
 #include <__config>
-#include <__debug>
 #include <__debug_utils/randomize_range.h>
+#include <__debug_utils/strict_weak_ordering_check.h>
 #include <__functional/operations.h>
 #include <__functional/ranges_operations.h>
 #include <__iterator/iterator_traits.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/disjunction.h>
 #include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_constant_evaluated.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <climits>
@@ -38,54 +39,55 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // stable, 2-3 compares, 0-2 swaps
 
 template <class _AlgPolicy, class _Compare, class _ForwardIterator>
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_CONSTEXPR_SINCE_CXX14 unsigned __sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z,
-                                               _Compare __c) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 unsigned
+__sort3(_ForwardIterator __x, _ForwardIterator __y, _ForwardIterator __z, _Compare __c) {
   using _Ops = _IterOps<_AlgPolicy>;
 
   unsigned __r = 0;
-  if (!__c(*__y, *__x))   // if x <= y
+  if (!__c(*__y, *__x)) // if x <= y
   {
-    if (!__c(*__z, *__y)) // if y <= z
-      return __r;         // x <= y && y <= z
-                          // x <= y && y > z
-    _Ops::iter_swap(__y, __z);     // x <= z && y < z
+    if (!__c(*__z, *__y))      // if y <= z
+      return __r;              // x <= y && y <= z
+                               // x <= y && y > z
+    _Ops::iter_swap(__y, __z); // x <= z && y < z
     __r = 1;
-    if (__c(*__y, *__x))  // if x > y
+    if (__c(*__y, *__x)) // if x > y
     {
-      _Ops::iter_swap(__x, __y);   // x < y && y <= z
+      _Ops::iter_swap(__x, __y); // x < y && y <= z
       __r = 2;
     }
-    return __r;           // x <= y && y < z
+    return __r; // x <= y && y < z
   }
-  if (__c(*__z, *__y))    // x > y, if y > z
+  if (__c(*__z, *__y)) // x > y, if y > z
   {
-    _Ops::iter_swap(__x, __z);     // x < y && y < z
+    _Ops::iter_swap(__x, __z); // x < y && y < z
     __r = 1;
     return __r;
   }
-  _Ops::iter_swap(__x, __y);       // x > y && y <= z
-  __r = 1;                // x < y && x <= z
-  if (__c(*__z, *__y))    // if y > z
+  _Ops::iter_swap(__x, __y); // x > y && y <= z
+  __r = 1;                   // x < y && x <= z
+  if (__c(*__z, *__y))       // if y > z
   {
-    _Ops::iter_swap(__y, __z);     // x <= y && y < z
+    _Ops::iter_swap(__y, __z); // x <= y && y < z
     __r = 2;
   }
   return __r;
-}                         // x <= y && y <= z
+} // x <= y && y <= z
 
 // stable, 3-6 compares, 0-5 swaps
 
 template <class _AlgPolicy, class _Compare, class _ForwardIterator>
-_LIBCPP_HIDE_FROM_ABI
-void __sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, _ForwardIterator __x4,
-                 _Compare __c) {
-  using _Ops   = _IterOps<_AlgPolicy>;
+_LIBCPP_HIDE_FROM_ABI void
+__sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3, _ForwardIterator __x4, _Compare __c) {
+  using _Ops = _IterOps<_AlgPolicy>;
   std::__sort3<_AlgPolicy, _Compare>(__x1, __x2, __x3, __c);
   if (__c(*__x4, *__x3)) {
     _Ops::iter_swap(__x3, __x4);
@@ -101,8 +103,13 @@ void __sort4(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3
 // stable, 4-10 compares, 0-9 swaps
 
 template <class _AlgPolicy, class _Comp, class _ForwardIterator>
-_LIBCPP_HIDE_FROM_ABI void __sort5(_ForwardIterator __x1, _ForwardIterator __x2, _ForwardIterator __x3,
-                                   _ForwardIterator __x4, _ForwardIterator __x5, _Comp __comp) {
+_LIBCPP_HIDE_FROM_ABI void
+__sort5(_ForwardIterator __x1,
+        _ForwardIterator __x2,
+        _ForwardIterator __x3,
+        _ForwardIterator __x4,
+        _ForwardIterator __x5,
+        _Comp __comp) {
   using _Ops = _IterOps<_AlgPolicy>;
 
   std::__sort4<_AlgPolicy, _Comp>(__x1, __x2, __x3, __x4, __comp);
@@ -123,8 +130,8 @@ _LIBCPP_HIDE_FROM_ABI void __sort5(_ForwardIterator __x1, _ForwardIterator __x2,
 // The comparator being simple is a prerequisite for using the branchless optimization.
 template <class _Tp>
 struct __is_simple_comparator : false_type {};
-template <class _Tp>
-struct __is_simple_comparator<__less<_Tp>&> : true_type {};
+template <>
+struct __is_simple_comparator<__less<>&> : true_type {};
 template <class _Tp>
 struct __is_simple_comparator<less<_Tp>&> : true_type {};
 template <class _Tp>
@@ -138,8 +145,9 @@ struct __is_simple_comparator<ranges::greater&> : true_type {};
 
 template <class _Compare, class _Iter, class _Tp = typename iterator_traits<_Iter>::value_type>
 using __use_branchless_sort =
-    integral_constant<bool, __libcpp_is_contiguous_iterator<_Iter>::value && sizeof(_Tp) <= sizeof(void*) &&
-                                is_arithmetic<_Tp>::value && __is_simple_comparator<_Compare>::value>;
+    integral_constant<bool,
+                      __libcpp_is_contiguous_iterator<_Iter>::value && sizeof(_Tp) <= sizeof(void*) &&
+                          is_arithmetic<_Tp>::value && __is_simple_comparator<_Compare>::value>;
 
 namespace __detail {
 
@@ -153,46 +161,56 @@ template <class _Compare, class _RandomAccessIterator>
 inline _LIBCPP_HIDE_FROM_ABI void __cond_swap(_RandomAccessIterator __x, _RandomAccessIterator __y, _Compare __c) {
   // Note: this function behaves correctly even with proxy iterators (because it relies on `value_type`).
   using value_type = typename iterator_traits<_RandomAccessIterator>::value_type;
-  bool __r = __c(*__x, *__y);
+  bool __r         = __c(*__x, *__y);
   value_type __tmp = __r ? *__x : *__y;
-  *__y = __r ? *__y : *__x;
-  *__x = __tmp;
+  *__y             = __r ? *__y : *__x;
+  *__x             = __tmp;
 }
 
 // Ensures that *__x, *__y and *__z are ordered according to the comparator __c,
 // under the assumption that *__y and *__z are already ordered.
 template <class _Compare, class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI void __partially_sorted_swap(_RandomAccessIterator __x, _RandomAccessIterator __y,
-                                                          _RandomAccessIterator __z, _Compare __c) {
+inline _LIBCPP_HIDE_FROM_ABI void
+__partially_sorted_swap(_RandomAccessIterator __x, _RandomAccessIterator __y, _RandomAccessIterator __z, _Compare __c) {
   // Note: this function behaves correctly even with proxy iterators (because it relies on `value_type`).
   using value_type = typename iterator_traits<_RandomAccessIterator>::value_type;
-  bool __r = __c(*__z, *__x);
+  bool __r         = __c(*__z, *__x);
   value_type __tmp = __r ? *__z : *__x;
-  *__z = __r ? *__x : *__z;
-  __r = __c(__tmp, *__y);
-  *__x = __r ? *__x : *__y;
-  *__y = __r ? *__y : __tmp;
+  *__z             = __r ? *__x : *__z;
+  __r              = __c(__tmp, *__y);
+  *__x             = __r ? *__x : *__y;
+  *__y             = __r ? *__y : __tmp;
 }
 
-template <class, class _Compare, class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<__use_branchless_sort<_Compare, _RandomAccessIterator>::value, void>
-__sort3_maybe_branchless(_RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3,
-                         _Compare __c) {
+template <class,
+          class _Compare,
+          class _RandomAccessIterator,
+          __enable_if_t<__use_branchless_sort<_Compare, _RandomAccessIterator>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void __sort3_maybe_branchless(
+    _RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3, _Compare __c) {
   std::__cond_swap<_Compare>(__x2, __x3, __c);
   std::__partially_sorted_swap<_Compare>(__x1, __x2, __x3, __c);
 }
 
-template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<!__use_branchless_sort<_Compare, _RandomAccessIterator>::value, void>
-__sort3_maybe_branchless(_RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3,
-                         _Compare __c) {
+template <class _AlgPolicy,
+          class _Compare,
+          class _RandomAccessIterator,
+          __enable_if_t<!__use_branchless_sort<_Compare, _RandomAccessIterator>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void __sort3_maybe_branchless(
+    _RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3, _Compare __c) {
   std::__sort3<_AlgPolicy, _Compare>(__x1, __x2, __x3, __c);
 }
 
-template <class, class _Compare, class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<__use_branchless_sort<_Compare, _RandomAccessIterator>::value, void>
-__sort4_maybe_branchless(_RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3,
-                         _RandomAccessIterator __x4, _Compare __c) {
+template <class,
+          class _Compare,
+          class _RandomAccessIterator,
+          __enable_if_t<__use_branchless_sort<_Compare, _RandomAccessIterator>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void __sort4_maybe_branchless(
+    _RandomAccessIterator __x1,
+    _RandomAccessIterator __x2,
+    _RandomAccessIterator __x3,
+    _RandomAccessIterator __x4,
+    _Compare __c) {
   std::__cond_swap<_Compare>(__x1, __x3, __c);
   std::__cond_swap<_Compare>(__x2, __x4, __c);
   std::__cond_swap<_Compare>(__x1, __x2, __c);
@@ -200,16 +218,24 @@ __sort4_maybe_branchless(_RandomAccessIterator __x1, _RandomAccessIterator __x2,
   std::__cond_swap<_Compare>(__x2, __x3, __c);
 }
 
-template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<!__use_branchless_sort<_Compare, _RandomAccessIterator>::value, void>
-__sort4_maybe_branchless(_RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3,
-                         _RandomAccessIterator __x4, _Compare __c) {
+template <class _AlgPolicy,
+          class _Compare,
+          class _RandomAccessIterator,
+          __enable_if_t<!__use_branchless_sort<_Compare, _RandomAccessIterator>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void __sort4_maybe_branchless(
+    _RandomAccessIterator __x1,
+    _RandomAccessIterator __x2,
+    _RandomAccessIterator __x3,
+    _RandomAccessIterator __x4,
+    _Compare __c) {
   std::__sort4<_AlgPolicy, _Compare>(__x1, __x2, __x3, __x4, __c);
 }
 
-template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<__use_branchless_sort<_Compare, _RandomAccessIterator>::value, void>
-__sort5_maybe_branchless(
+template <class _AlgPolicy,
+          class _Compare,
+          class _RandomAccessIterator,
+          __enable_if_t<__use_branchless_sort<_Compare, _RandomAccessIterator>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void __sort5_maybe_branchless(
     _RandomAccessIterator __x1,
     _RandomAccessIterator __x2,
     _RandomAccessIterator __x3,
@@ -224,19 +250,25 @@ __sort5_maybe_branchless(
   std::__partially_sorted_swap<_Compare>(__x2, __x3, __x4, __c);
 }
 
-template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<!__use_branchless_sort<_Compare, _RandomAccessIterator>::value, void>
-__sort5_maybe_branchless(_RandomAccessIterator __x1, _RandomAccessIterator __x2, _RandomAccessIterator __x3,
-                         _RandomAccessIterator __x4, _RandomAccessIterator __x5, _Compare __c) {
+template <class _AlgPolicy,
+          class _Compare,
+          class _RandomAccessIterator,
+          __enable_if_t<!__use_branchless_sort<_Compare, _RandomAccessIterator>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void __sort5_maybe_branchless(
+    _RandomAccessIterator __x1,
+    _RandomAccessIterator __x2,
+    _RandomAccessIterator __x3,
+    _RandomAccessIterator __x4,
+    _RandomAccessIterator __x5,
+    _Compare __c) {
   std::__sort5<_AlgPolicy, _Compare, _RandomAccessIterator>(
       std::move(__x1), std::move(__x2), std::move(__x3), std::move(__x4), std::move(__x5), __c);
 }
 
 // Assumes size > 0
 template <class _AlgPolicy, class _Compare, class _BidirectionalIterator>
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_CONSTEXPR_SINCE_CXX14 void __selection_sort(_BidirectionalIterator __first, _BidirectionalIterator __last,
-                                                    _Compare __comp) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+__selection_sort(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) {
   _BidirectionalIterator __lm1 = __last;
   for (--__lm1; __first != __lm1; ++__first) {
     _BidirectionalIterator __i = std::__min_element<_Compare>(__first, __last, __comp);
@@ -248,8 +280,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX14 void __selection_sort(_BidirectionalIterator __fir
 // Sort the iterator range [__first, __last) using the comparator __comp using
 // the insertion sort algorithm.
 template <class _AlgPolicy, class _Compare, class _BidirectionalIterator>
-_LIBCPP_HIDE_FROM_ABI
-void __insertion_sort(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) {
+_LIBCPP_HIDE_FROM_ABI void
+__insertion_sort(_BidirectionalIterator __first, _BidirectionalIterator __last, _Compare __comp) {
   using _Ops = _IterOps<_AlgPolicy>;
 
   typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
@@ -285,17 +317,20 @@ __insertion_sort_unguarded(_RandomAccessIterator const __first, _RandomAccessIte
   typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
   if (__first == __last)
     return;
-  const _RandomAccessIterator __leftmost = __first - difference_type(1); (void)__leftmost; // can be unused when assertions are disabled
+  const _RandomAccessIterator __leftmost = __first - difference_type(1);
+  (void)__leftmost; // can be unused when assertions are disabled
   for (_RandomAccessIterator __i = __first + difference_type(1); __i != __last; ++__i) {
     _RandomAccessIterator __j = __i - difference_type(1);
     if (__comp(*__i, *__j)) {
       value_type __t(_Ops::__iter_move(__i));
       _RandomAccessIterator __k = __j;
-      __j = __i;
+      __j                       = __i;
       do {
         *__j = _Ops::__iter_move(__k);
-        __j = __k;
-        _LIBCPP_ASSERT(__k != __leftmost, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+        __j  = __k;
+        _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+            __k != __leftmost,
+            "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
       } while (__comp(__t, *--__k)); // No need for bounds check due to the assumption stated above.
       *__j = std::move(__t);
     }
@@ -303,8 +338,8 @@ __insertion_sort_unguarded(_RandomAccessIterator const __first, _RandomAccessIte
 }
 
 template <class _AlgPolicy, class _Comp, class _RandomAccessIterator>
-_LIBCPP_HIDE_FROM_ABI bool __insertion_sort_incomplete(
-    _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
+_LIBCPP_HIDE_FROM_ABI bool
+__insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
   using _Ops = _IterOps<_AlgPolicy>;
 
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
@@ -325,23 +360,27 @@ _LIBCPP_HIDE_FROM_ABI bool __insertion_sort_incomplete(
     return true;
   case 5:
     std::__sort5_maybe_branchless<_AlgPolicy, _Comp>(
-        __first, __first + difference_type(1), __first + difference_type(2), __first + difference_type(3),
-        --__last, __comp);
+        __first,
+        __first + difference_type(1),
+        __first + difference_type(2),
+        __first + difference_type(3),
+        --__last,
+        __comp);
     return true;
   }
   typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
   _RandomAccessIterator __j = __first + difference_type(2);
   std::__sort3_maybe_branchless<_AlgPolicy, _Comp>(__first, __first + difference_type(1), __j, __comp);
   const unsigned __limit = 8;
-  unsigned __count = 0;
+  unsigned __count       = 0;
   for (_RandomAccessIterator __i = __j + difference_type(1); __i != __last; ++__i) {
     if (__comp(*__i, *__j)) {
       value_type __t(_Ops::__iter_move(__i));
       _RandomAccessIterator __k = __j;
-      __j = __i;
+      __j                       = __i;
       do {
         *__j = _Ops::__iter_move(__k);
-        __j = __k;
+        __j  = __k;
       } while (__j != __first && __comp(__t, *--__k));
       *__j = std::move(__t);
       if (++__count == __limit)
@@ -497,9 +536,10 @@ __bitset_partition(_RandomAccessIterator __first, _RandomAccessIterator __last,
   using _Ops = _IterOps<_AlgPolicy>;
   typedef typename std::iterator_traits<_RandomAccessIterator>::value_type value_type;
   typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-  _LIBCPP_ASSERT(__last - __first >= difference_type(3), "");
-  const _RandomAccessIterator __begin = __first;            // used for bounds checking, those are not moved around
-  const _RandomAccessIterator __end = __last; (void)__end;  //
+  _LIBCPP_ASSERT_INTERNAL(__last - __first >= difference_type(3), "");
+  const _RandomAccessIterator __begin = __first; // used for bounds checking, those are not moved around
+  const _RandomAccessIterator __end   = __last;
+  (void)__end; //
 
   value_type __pivot(_Ops::__iter_move(__first));
   // Find the first element greater than the pivot.
@@ -507,7 +547,9 @@ __bitset_partition(_RandomAccessIterator __first, _RandomAccessIterator __last,
     // Not guarded since we know the last element is greater than the pivot.
     do {
       ++__first;
-      _LIBCPP_ASSERT(__first != __end, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __first != __end,
+          "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
     } while (!__comp(__pivot, *__first));
   } else {
     while (++__first < __last && !__comp(__pivot, *__first)) {
@@ -518,7 +560,9 @@ __bitset_partition(_RandomAccessIterator __first, _RandomAccessIterator __last,
     // It will be always guarded because __introsort will do the median-of-three
     // before calling this.
     do {
-      _LIBCPP_ASSERT(__last != __begin, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __last != __begin,
+          "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
       --__last;
     } while (__comp(__pivot, *__last));
   }
@@ -584,16 +628,19 @@ __partition_with_equals_on_right(_RandomAccessIterator __first, _RandomAccessIte
   using _Ops = _IterOps<_AlgPolicy>;
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   typedef typename std::iterator_traits<_RandomAccessIterator>::value_type value_type;
-  _LIBCPP_ASSERT(__last - __first >= difference_type(3), "");
-  const _RandomAccessIterator __begin = __first;            // used for bounds checking, those are not moved around
-  const _RandomAccessIterator __end = __last; (void)__end;  //
+  _LIBCPP_ASSERT_INTERNAL(__last - __first >= difference_type(3), "");
+  const _RandomAccessIterator __begin = __first; // used for bounds checking, those are not moved around
+  const _RandomAccessIterator __end   = __last;
+  (void)__end; //
   value_type __pivot(_Ops::__iter_move(__first));
   // Find the first element greater or equal to the pivot.  It will be always
   // guarded because __introsort will do the median-of-three before calling
   // this.
   do {
     ++__first;
-    _LIBCPP_ASSERT(__first != __end, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __first != __end,
+        "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
   } while (__comp(*__first, __pivot));
 
   // Find the last element less than the pivot.
@@ -603,7 +650,9 @@ __partition_with_equals_on_right(_RandomAccessIterator __first, _RandomAccessIte
   } else {
     // Guarded.
     do {
-      _LIBCPP_ASSERT(__last != __begin, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __last != __begin,
+          "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
       --__last;
     } while (!__comp(*__last, __pivot));
   }
@@ -619,10 +668,14 @@ __partition_with_equals_on_right(_RandomAccessIterator __first, _RandomAccessIte
     _Ops::iter_swap(__first, __last);
     do {
       ++__first;
-      _LIBCPP_ASSERT(__first != __end, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __first != __end,
+          "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
     } while (__comp(*__first, __pivot));
     do {
-      _LIBCPP_ASSERT(__last != __begin, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __last != __begin,
+          "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
       --__last;
     } while (!__comp(*__last, __pivot));
   }
@@ -643,15 +696,17 @@ __partition_with_equals_on_left(_RandomAccessIterator __first, _RandomAccessIter
   using _Ops = _IterOps<_AlgPolicy>;
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   typedef typename std::iterator_traits<_RandomAccessIterator>::value_type value_type;
-  // TODO(LLVM18): Make __begin const, see https://reviews.llvm.org/D147089#4349748
-  _RandomAccessIterator __begin = __first;                  // used for bounds checking, those are not moved around
-  const _RandomAccessIterator __end = __last; (void)__end;  //
+  const _RandomAccessIterator __begin = __first; // used for bounds checking, those are not moved around
+  const _RandomAccessIterator __end   = __last;
+  (void)__end; //
   value_type __pivot(_Ops::__iter_move(__first));
   if (__comp(__pivot, *(__last - difference_type(1)))) {
     // Guarded.
     do {
       ++__first;
-      _LIBCPP_ASSERT(__first != __end, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __first != __end,
+          "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
     } while (!__comp(__pivot, *__first));
   } else {
     while (++__first < __last && !__comp(__pivot, *__first)) {
@@ -662,7 +717,9 @@ __partition_with_equals_on_left(_RandomAccessIterator __first, _RandomAccessIter
     // It will be always guarded because __introsort will do the
     // median-of-three before calling this.
     do {
-      _LIBCPP_ASSERT(__last != __begin, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __last != __begin,
+          "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
       --__last;
     } while (__comp(__pivot, *__last));
   }
@@ -670,10 +727,14 @@ __partition_with_equals_on_left(_RandomAccessIterator __first, _RandomAccessIter
     _Ops::iter_swap(__first, __last);
     do {
       ++__first;
-      _LIBCPP_ASSERT(__first != __end, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __first != __end,
+          "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
     } while (!__comp(__pivot, *__first));
     do {
-      _LIBCPP_ASSERT(__last != __begin, "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __last != __begin,
+          "Would read out of bounds, does your comparator satisfy the strict-weak ordering requirement?");
       --__last;
     } while (__comp(__pivot, *__last));
   }
@@ -724,8 +785,12 @@ void __introsort(_RandomAccessIterator __first,
       return;
     case 5:
       std::__sort5_maybe_branchless<_AlgPolicy, _Compare>(
-          __first, __first + difference_type(1), __first + difference_type(2), __first + difference_type(3),
-          --__last, __comp);
+          __first,
+          __first + difference_type(1),
+          __first + difference_type(2),
+          __first + difference_type(3),
+          --__last,
+          __comp);
       return;
     }
     // Use insertion sort if the length of the range is below the specified limit.
@@ -774,10 +839,10 @@ void __introsort(_RandomAccessIterator __first,
       continue;
     }
     // Use bitset partition only if asked for.
-    auto __ret =
-        _UseBitSetPartition
-            ? std::__bitset_partition<_AlgPolicy, _RandomAccessIterator, _Compare>(__first, __last, __comp)
-            : std::__partition_with_equals_on_right<_AlgPolicy, _RandomAccessIterator, _Compare>(__first, __last, __comp);
+    auto __ret                = _UseBitSetPartition
+                                  ? std::__bitset_partition<_AlgPolicy, _RandomAccessIterator, _Compare>(__first, __last, __comp)
+                                  : std::__partition_with_equals_on_right<_AlgPolicy, _RandomAccessIterator, _Compare>(
+                         __first, __last, __comp);
     _RandomAccessIterator __i = __ret.first;
     // [__first, __i) < *__i and *__i <= [__i+1, __last)
     // If we were given a perfect partition, see if insertion sort is quick...
@@ -825,23 +890,31 @@ inline _LIBCPP_HIDE_FROM_ABI _Number __log2i(_Number __n) {
 template <class _Comp, class _RandomAccessIterator>
 void __sort(_RandomAccessIterator, _RandomAccessIterator, _Comp);
 
-extern template _LIBCPP_FUNC_VIS void __sort<__less<char>&, char*>(char*, char*, __less<char>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void __sort<__less<char>&, char*>(char*, char*, __less<char>&);
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-extern template _LIBCPP_FUNC_VIS void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void __sort<__less<wchar_t>&, wchar_t*>(wchar_t*, wchar_t*, __less<wchar_t>&);
 #endif
-extern template _LIBCPP_FUNC_VIS void __sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<short>&, short*>(short*, short*, __less<short>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<int>&, int*>(int*, int*, __less<int>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<long>&, long*>(long*, long*, __less<long>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<unsigned long long>&, unsigned long long*>(unsigned long long*, unsigned long long*, __less<unsigned long long>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<float>&, float*>(float*, float*, __less<float>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<double>&, double*>(double*, double*, __less<double>&);
-extern template _LIBCPP_FUNC_VIS void __sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void
+__sort<__less<signed char>&, signed char*>(signed char*, signed char*, __less<signed char>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void
+__sort<__less<unsigned char>&, unsigned char*>(unsigned char*, unsigned char*, __less<unsigned char>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void __sort<__less<short>&, short*>(short*, short*, __less<short>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void
+__sort<__less<unsigned short>&, unsigned short*>(unsigned short*, unsigned short*, __less<unsigned short>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void __sort<__less<int>&, int*>(int*, int*, __less<int>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void
+__sort<__less<unsigned>&, unsigned*>(unsigned*, unsigned*, __less<unsigned>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void __sort<__less<long>&, long*>(long*, long*, __less<long>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void
+__sort<__less<unsigned long>&, unsigned long*>(unsigned long*, unsigned long*, __less<unsigned long>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void
+__sort<__less<long long>&, long long*>(long long*, long long*, __less<long long>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void __sort<__less<unsigned long long>&, unsigned long long*>(
+    unsigned long long*, unsigned long long*, __less<unsigned long long>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void __sort<__less<float>&, float*>(float*, float*, __less<float>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void __sort<__less<double>&, double*>(double*, double*, __less<double>&);
+extern template _LIBCPP_EXPORTED_FROM_ABI void
+__sort<__less<long double>&, long double*>(long double*, long double*, __less<long double>&);
 
 template <class _AlgPolicy, class _RandomAccessIterator, class _Comp>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
@@ -855,8 +928,7 @@ __sort_dispatch(_RandomAccessIterator __first, _RandomAccessIterator __last, _Co
   std::__introsort<_AlgPolicy,
                    _Comp&,
                    _RandomAccessIterator,
-                   __use_branchless_sort<_Comp, _RandomAccessIterator>::value>(
-      __first, __last, __comp, __depth_limit);
+                   __use_branchless_sort<_Comp, _RandomAccessIterator>::value>(__first, __last, __comp, __depth_limit);
 }
 
 template <class _Type, class... _Options>
@@ -884,7 +956,8 @@ using __sort_is_specialized_in_library = __is_any_of<
     long double>;
 
 template <class _AlgPolicy, class _Type, __enable_if_t<__sort_is_specialized_in_library<_Type>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI void __sort_dispatch(_Type* __first, _Type* __last, __less<_Type>& __comp) {
+_LIBCPP_HIDE_FROM_ABI void __sort_dispatch(_Type* __first, _Type* __last, __less<>&) {
+  __less<_Type> __comp;
   std::__sort<__less<_Type>&, _Type*>(__first, __last, __comp);
 }
 
@@ -911,8 +984,8 @@ _LIBCPP_HIDE_FROM_ABI void __sort_dispatch(_Type* __first, _Type* __last, ranges
 #endif
 
 template <class _AlgPolicy, class _RandomAccessIterator, class _Comp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void __sort_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp& __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+__sort_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp& __comp) {
   std::__debug_randomize_range<_AlgPolicy>(__first, __last);
 
   if (__libcpp_is_constant_evaluated()) {
@@ -921,20 +994,23 @@ void __sort_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, _C
   } else {
     std::__sort_dispatch<_AlgPolicy>(std::__unwrap_iter(__first), std::__unwrap_iter(__last), __comp);
   }
+  std::__check_strict_weak_ordering_sorted(std::__unwrap_iter(__first), std::__unwrap_iter(__last), __comp);
 }
 
 template <class _RandomAccessIterator, class _Comp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) {
   std::__sort_impl<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp);
 }
 
 template <class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void sort(_RandomAccessIterator __first, _RandomAccessIterator __last) {
-  std::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+sort(_RandomAccessIterator __first, _RandomAccessIterator __last) {
+  std::sort(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_SORT_H
diff --git a/third_party/libcxx/__algorithm/sort_heap.h b/third_party/libcxx/__algorithm/sort_heap.h
index 0dc9acced..f20b110c7 100644
--- a/third_party/libcxx/__algorithm/sort_heap.h
+++ b/third_party/libcxx/__algorithm/sort_heap.h
@@ -14,30 +14,36 @@
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/pop_heap.h>
 #include <__config>
+#include <__debug_utils/strict_weak_ordering_check.h>
 #include <__iterator/iterator_traits.h>
-#include <__type_traits/is_copy_assignable.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-void __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+__sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) {
+  _RandomAccessIterator __saved_last   = __last;
   __comp_ref_type<_Compare> __comp_ref = __comp;
 
   using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;
-  for (difference_type __n = __last - __first; __n > 1; --__last, (void) --__n)
+  for (difference_type __n = __last - __first; __n > 1; --__last, (void)--__n)
     std::__pop_heap<_AlgPolicy>(__first, __last, __comp_ref, __n);
+  std::__check_strict_weak_ordering_sorted(__first, __saved_last, __comp_ref);
 }
 
 template <class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
   static_assert(std::is_copy_constructible<_RandomAccessIterator>::value, "Iterators must be copy constructible.");
   static_assert(std::is_copy_assignable<_RandomAccessIterator>::value, "Iterators must be copy assignable.");
 
@@ -45,12 +51,13 @@ void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Com
 }
 
 template <class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
-  std::sort_heap(std::move(__first), std::move(__last),
-      __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) {
+  std::sort_heap(std::move(__first), std::move(__last), __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_SORT_HEAP_H
diff --git a/third_party/libcxx/__algorithm/stable_partition.h b/third_party/libcxx/__algorithm/stable_partition.h
index 3b68bd306..8bb1eaf2d 100644
--- a/third_party/libcxx/__algorithm/stable_partition.h
+++ b/third_party/libcxx/__algorithm/stable_partition.h
@@ -26,298 +26,275 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Predicate, class _ForwardIterator, class _Distance, class _Pair>
-_LIBCPP_HIDE_FROM_ABI _ForwardIterator
-__stable_partition_impl(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
-                   _Distance __len, _Pair __p, forward_iterator_tag __fit)
-{
-    using _Ops = _IterOps<_AlgPolicy>;
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator __stable_partition_impl(
+    _ForwardIterator __first,
+    _ForwardIterator __last,
+    _Predicate __pred,
+    _Distance __len,
+    _Pair __p,
+    forward_iterator_tag __fit) {
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    // *__first is known to be false
-    // __len >= 1
-    if (__len == 1)
-        return __first;
-    if (__len == 2)
-    {
-        _ForwardIterator __m = __first;
-        if (__pred(*++__m))
-        {
-            _Ops::iter_swap(__first, __m);
-            return __m;
-        }
-        return __first;
+  // *__first is known to be false
+  // __len >= 1
+  if (__len == 1)
+    return __first;
+  if (__len == 2) {
+    _ForwardIterator __m = __first;
+    if (__pred(*++__m)) {
+      _Ops::iter_swap(__first, __m);
+      return __m;
     }
-    if (__len <= __p.second)
-    {   // The buffer is big enough to use
-        typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
-        __destruct_n __d(0);
-        unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
-        // Move the falses into the temporary buffer, and the trues to the front of the line
-        // Update __first to always point to the end of the trues
-        value_type* __t = __p.first;
-        ::new ((void*)__t) value_type(_Ops::__iter_move(__first));
+    return __first;
+  }
+  if (__len <= __p.second) { // The buffer is big enough to use
+    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
+    __destruct_n __d(0);
+    unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
+    // Move the falses into the temporary buffer, and the trues to the front of the line
+    // Update __first to always point to the end of the trues
+    value_type* __t = __p.first;
+    ::new ((void*)__t) value_type(_Ops::__iter_move(__first));
+    __d.template __incr<value_type>();
+    ++__t;
+    _ForwardIterator __i = __first;
+    while (++__i != __last) {
+      if (__pred(*__i)) {
+        *__first = _Ops::__iter_move(__i);
+        ++__first;
+      } else {
+        ::new ((void*)__t) value_type(_Ops::__iter_move(__i));
         __d.template __incr<value_type>();
         ++__t;
-        _ForwardIterator __i = __first;
-        while (++__i != __last)
-        {
-            if (__pred(*__i))
-            {
-                *__first = _Ops::__iter_move(__i);
-                ++__first;
-            }
-            else
-            {
-                ::new ((void*)__t) value_type(_Ops::__iter_move(__i));
-                __d.template __incr<value_type>();
-                ++__t;
-            }
-        }
-        // All trues now at start of range, all falses in buffer
-        // Move falses back into range, but don't mess up __first which points to first false
-        __i = __first;
-        for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, (void) ++__i)
-            *__i = _Ops::__iter_move(__t2);
-        // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
-        return __first;
+      }
     }
-    // Else not enough buffer, do in place
-    // __len >= 3
-    _ForwardIterator __m = __first;
-    _Distance __len2 = __len / 2;  // __len2 >= 2
-    _Ops::advance(__m, __len2);
-    // recurse on [__first, __m), *__first know to be false
-    // F?????????????????
-    // f       m         l
-    _ForwardIterator __first_false = std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
-        __first, __m, __pred, __len2, __p, __fit);
-    // TTTFFFFF??????????
-    // f  ff   m         l
-    // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true
-    _ForwardIterator __m1 = __m;
-    _ForwardIterator __second_false = __last;
-    _Distance __len_half = __len - __len2;
-    while (__pred(*__m1))
-    {
-        if (++__m1 == __last)
-            goto __second_half_done;
-        --__len_half;
-    }
-    // TTTFFFFFTTTF??????
-    // f  ff   m  m1     l
-    __second_false = std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
-        __m1, __last, __pred, __len_half, __p, __fit);
+    // All trues now at start of range, all falses in buffer
+    // Move falses back into range, but don't mess up __first which points to first false
+    __i = __first;
+    for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, (void)++__i)
+      *__i = _Ops::__iter_move(__t2);
+    // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
+    return __first;
+  }
+  // Else not enough buffer, do in place
+  // __len >= 3
+  _ForwardIterator __m = __first;
+  _Distance __len2     = __len / 2; // __len2 >= 2
+  _Ops::advance(__m, __len2);
+  // recurse on [__first, __m), *__first know to be false
+  // F?????????????????
+  // f       m         l
+  _ForwardIterator __first_false =
+      std::__stable_partition_impl<_AlgPolicy, _Predicate&>(__first, __m, __pred, __len2, __p, __fit);
+  // TTTFFFFF??????????
+  // f  ff   m         l
+  // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true
+  _ForwardIterator __m1           = __m;
+  _ForwardIterator __second_false = __last;
+  _Distance __len_half            = __len - __len2;
+  while (__pred(*__m1)) {
+    if (++__m1 == __last)
+      goto __second_half_done;
+    --__len_half;
+  }
+  // TTTFFFFFTTTF??????
+  // f  ff   m  m1     l
+  __second_false = std::__stable_partition_impl<_AlgPolicy, _Predicate&>(__m1, __last, __pred, __len_half, __p, __fit);
 __second_half_done:
-    // TTTFFFFFTTTTTFFFFF
-    // f  ff   m    sf   l
-    return std::__rotate<_AlgPolicy>(__first_false, __m, __second_false).first;
-    // TTTTTTTTFFFFFFFFFF
-    //         |
+  // TTTFFFFFTTTTTFFFFF
+  // f  ff   m    sf   l
+  return std::__rotate<_AlgPolicy>(__first_false, __m, __second_false).first;
+  // TTTTTTTTFFFFFFFFFF
+  //         |
 }
 
 template <class _AlgPolicy, class _Predicate, class _ForwardIterator>
 _LIBCPP_HIDE_FROM_ABI _ForwardIterator
-__stable_partition_impl(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred,
-                   forward_iterator_tag)
-{
-    const unsigned __alloc_limit = 3;  // might want to make this a function of trivial assignment
-    // Either prove all true and return __first or point to first false
-    while (true)
-    {
-        if (__first == __last)
-            return __first;
-        if (!__pred(*__first))
-            break;
-        ++__first;
-    }
-    // We now have a reduced range [__first, __last)
-    // *__first is known to be false
-    typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
-    typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
-    difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last);
-    pair<value_type*, ptrdiff_t> __p(0, 0);
-    unique_ptr<value_type, __return_temporary_buffer> __h;
-    if (__len >= __alloc_limit)
-    {
-// TODO: Remove the use of std::get_temporary_buffer
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-        __p = _VSTD::get_temporary_buffer<value_type>(__len);
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-        __h.reset(__p.first);
-    }
-    return std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
-        std::move(__first), std::move(__last), __pred, __len, __p, forward_iterator_tag());
+__stable_partition_impl(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred, forward_iterator_tag) {
+  typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
+  typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
+
+  const difference_type __alloc_limit = 3; // might want to make this a function of trivial assignment
+  // Either prove all true and return __first or point to first false
+  while (true) {
+    if (__first == __last)
+      return __first;
+    if (!__pred(*__first))
+      break;
+    ++__first;
+  }
+  // We now have a reduced range [__first, __last)
+  // *__first is known to be false
+  difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last);
+  pair<value_type*, ptrdiff_t> __p(0, 0);
+  unique_ptr<value_type, __return_temporary_buffer> __h;
+  if (__len >= __alloc_limit) {
+    // TODO: Remove the use of std::get_temporary_buffer
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    __p = std::get_temporary_buffer<value_type>(__len);
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
+    __h.reset(__p.first);
+  }
+  return std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
+      std::move(__first), std::move(__last), __pred, __len, __p, forward_iterator_tag());
 }
 
 template <class _AlgPolicy, class _Predicate, class _BidirectionalIterator, class _Distance, class _Pair>
-_BidirectionalIterator
-__stable_partition_impl(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
-                   _Distance __len, _Pair __p, bidirectional_iterator_tag __bit)
-{
-    using _Ops = _IterOps<_AlgPolicy>;
+_BidirectionalIterator __stable_partition_impl(
+    _BidirectionalIterator __first,
+    _BidirectionalIterator __last,
+    _Predicate __pred,
+    _Distance __len,
+    _Pair __p,
+    bidirectional_iterator_tag __bit) {
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    // *__first is known to be false
-    // *__last is known to be true
-    // __len >= 2
-    if (__len == 2)
-    {
-        _Ops::iter_swap(__first, __last);
-        return __last;
+  // *__first is known to be false
+  // *__last is known to be true
+  // __len >= 2
+  if (__len == 2) {
+    _Ops::iter_swap(__first, __last);
+    return __last;
+  }
+  if (__len == 3) {
+    _BidirectionalIterator __m = __first;
+    if (__pred(*++__m)) {
+      _Ops::iter_swap(__first, __m);
+      _Ops::iter_swap(__m, __last);
+      return __last;
     }
-    if (__len == 3)
-    {
-        _BidirectionalIterator __m = __first;
-        if (__pred(*++__m))
-        {
-            _Ops::iter_swap(__first, __m);
-            _Ops::iter_swap(__m, __last);
-            return __last;
-        }
-        _Ops::iter_swap(__m, __last);
-        _Ops::iter_swap(__first, __m);
-        return __m;
-    }
-    if (__len <= __p.second)
-    {   // The buffer is big enough to use
-        typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
-        __destruct_n __d(0);
-        unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
-        // Move the falses into the temporary buffer, and the trues to the front of the line
-        // Update __first to always point to the end of the trues
-        value_type* __t = __p.first;
-        ::new ((void*)__t) value_type(_Ops::__iter_move(__first));
+    _Ops::iter_swap(__m, __last);
+    _Ops::iter_swap(__first, __m);
+    return __m;
+  }
+  if (__len <= __p.second) { // The buffer is big enough to use
+    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
+    __destruct_n __d(0);
+    unique_ptr<value_type, __destruct_n&> __h(__p.first, __d);
+    // Move the falses into the temporary buffer, and the trues to the front of the line
+    // Update __first to always point to the end of the trues
+    value_type* __t = __p.first;
+    ::new ((void*)__t) value_type(_Ops::__iter_move(__first));
+    __d.template __incr<value_type>();
+    ++__t;
+    _BidirectionalIterator __i = __first;
+    while (++__i != __last) {
+      if (__pred(*__i)) {
+        *__first = _Ops::__iter_move(__i);
+        ++__first;
+      } else {
+        ::new ((void*)__t) value_type(_Ops::__iter_move(__i));
         __d.template __incr<value_type>();
         ++__t;
-        _BidirectionalIterator __i = __first;
-        while (++__i != __last)
-        {
-            if (__pred(*__i))
-            {
-                *__first = _Ops::__iter_move(__i);
-                ++__first;
-            }
-            else
-            {
-                ::new ((void*)__t) value_type(_Ops::__iter_move(__i));
-                __d.template __incr<value_type>();
-                ++__t;
-            }
-        }
-        // move *__last, known to be true
-        *__first = _Ops::__iter_move(__i);
-        __i = ++__first;
-        // All trues now at start of range, all falses in buffer
-        // Move falses back into range, but don't mess up __first which points to first false
-        for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, (void) ++__i)
-            *__i = _Ops::__iter_move(__t2);
-        // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
-        return __first;
+      }
     }
-    // Else not enough buffer, do in place
-    // __len >= 4
-    _BidirectionalIterator __m = __first;
-    _Distance __len2 = __len / 2;  // __len2 >= 2
-    _Ops::advance(__m, __len2);
-    // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false
-    // F????????????????T
-    // f       m        l
-    _BidirectionalIterator __m1 = __m;
-    _BidirectionalIterator __first_false = __first;
-    _Distance __len_half = __len2;
-    while (!__pred(*--__m1))
-    {
-        if (__m1 == __first)
-            goto __first_half_done;
-        --__len_half;
-    }
-    // F???TFFF?????????T
-    // f   m1  m        l
-    __first_false = std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
-        __first, __m1, __pred, __len_half, __p, __bit);
+    // move *__last, known to be true
+    *__first = _Ops::__iter_move(__i);
+    __i      = ++__first;
+    // All trues now at start of range, all falses in buffer
+    // Move falses back into range, but don't mess up __first which points to first false
+    for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, (void)++__i)
+      *__i = _Ops::__iter_move(__t2);
+    // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
+    return __first;
+  }
+  // Else not enough buffer, do in place
+  // __len >= 4
+  _BidirectionalIterator __m = __first;
+  _Distance __len2           = __len / 2; // __len2 >= 2
+  _Ops::advance(__m, __len2);
+  // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false
+  // F????????????????T
+  // f       m        l
+  _BidirectionalIterator __m1          = __m;
+  _BidirectionalIterator __first_false = __first;
+  _Distance __len_half                 = __len2;
+  while (!__pred(*--__m1)) {
+    if (__m1 == __first)
+      goto __first_half_done;
+    --__len_half;
+  }
+  // F???TFFF?????????T
+  // f   m1  m        l
+  __first_false = std::__stable_partition_impl<_AlgPolicy, _Predicate&>(__first, __m1, __pred, __len_half, __p, __bit);
 __first_half_done:
-    // TTTFFFFF?????????T
-    // f  ff   m        l
-    // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true
-    __m1 = __m;
-    _BidirectionalIterator __second_false = __last;
-    ++__second_false;
-    __len_half = __len - __len2;
-    while (__pred(*__m1))
-    {
-        if (++__m1 == __last)
-            goto __second_half_done;
-        --__len_half;
-    }
-    // TTTFFFFFTTTF?????T
-    // f  ff   m  m1    l
-    __second_false = std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
-        __m1, __last, __pred, __len_half, __p, __bit);
+  // TTTFFFFF?????????T
+  // f  ff   m        l
+  // recurse on [__m, __last], except increase __m until *(__m) is false, *__last know to be true
+  __m1                                  = __m;
+  _BidirectionalIterator __second_false = __last;
+  ++__second_false;
+  __len_half = __len - __len2;
+  while (__pred(*__m1)) {
+    if (++__m1 == __last)
+      goto __second_half_done;
+    --__len_half;
+  }
+  // TTTFFFFFTTTF?????T
+  // f  ff   m  m1    l
+  __second_false = std::__stable_partition_impl<_AlgPolicy, _Predicate&>(__m1, __last, __pred, __len_half, __p, __bit);
 __second_half_done:
-    // TTTFFFFFTTTTTFFFFF
-    // f  ff   m    sf  l
-    return std::__rotate<_AlgPolicy>(__first_false, __m, __second_false).first;
-    // TTTTTTTTFFFFFFFFFF
-    //         |
+  // TTTFFFFFTTTTTFFFFF
+  // f  ff   m    sf  l
+  return std::__rotate<_AlgPolicy>(__first_false, __m, __second_false).first;
+  // TTTTTTTTFFFFFFFFFF
+  //         |
 }
 
 template <class _AlgPolicy, class _Predicate, class _BidirectionalIterator>
-_LIBCPP_HIDE_FROM_ABI _BidirectionalIterator
-__stable_partition_impl(_BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred,
-                   bidirectional_iterator_tag)
-{
-    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
-    typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
-    const difference_type __alloc_limit = 4;  // might want to make this a function of trivial assignment
-    // Either prove all true and return __first or point to first false
-    while (true)
-    {
-        if (__first == __last)
-            return __first;
-        if (!__pred(*__first))
-            break;
-        ++__first;
-    }
-    // __first points to first false, everything prior to __first is already set.
-    // Either prove [__first, __last) is all false and return __first, or point __last to last true
-    do
-    {
-        if (__first == --__last)
-            return __first;
-    } while (!__pred(*__last));
-    // We now have a reduced range [__first, __last]
-    // *__first is known to be false
-    // *__last is known to be true
-    // __len >= 2
-    difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last) + 1;
-    pair<value_type*, ptrdiff_t> __p(0, 0);
-    unique_ptr<value_type, __return_temporary_buffer> __h;
-    if (__len >= __alloc_limit)
-    {
-// TODO: Remove the use of std::get_temporary_buffer
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-        __p = _VSTD::get_temporary_buffer<value_type>(__len);
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-        __h.reset(__p.first);
-    }
-    return std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
-        std::move(__first), std::move(__last), __pred, __len, __p, bidirectional_iterator_tag());
+_LIBCPP_HIDE_FROM_ABI _BidirectionalIterator __stable_partition_impl(
+    _BidirectionalIterator __first, _BidirectionalIterator __last, _Predicate __pred, bidirectional_iterator_tag) {
+  typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
+  typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
+  const difference_type __alloc_limit = 4; // might want to make this a function of trivial assignment
+  // Either prove all true and return __first or point to first false
+  while (true) {
+    if (__first == __last)
+      return __first;
+    if (!__pred(*__first))
+      break;
+    ++__first;
+  }
+  // __first points to first false, everything prior to __first is already set.
+  // Either prove [__first, __last) is all false and return __first, or point __last to last true
+  do {
+    if (__first == --__last)
+      return __first;
+  } while (!__pred(*__last));
+  // We now have a reduced range [__first, __last]
+  // *__first is known to be false
+  // *__last is known to be true
+  // __len >= 2
+  difference_type __len = _IterOps<_AlgPolicy>::distance(__first, __last) + 1;
+  pair<value_type*, ptrdiff_t> __p(0, 0);
+  unique_ptr<value_type, __return_temporary_buffer> __h;
+  if (__len >= __alloc_limit) {
+    // TODO: Remove the use of std::get_temporary_buffer
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    __p = std::get_temporary_buffer<value_type>(__len);
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
+    __h.reset(__p.first);
+  }
+  return std::__stable_partition_impl<_AlgPolicy, _Predicate&>(
+      std::move(__first), std::move(__last), __pred, __len, __p, bidirectional_iterator_tag());
 }
 
 template <class _AlgPolicy, class _Predicate, class _ForwardIterator, class _IterCategory>
-_LIBCPP_HIDE_FROM_ABI
-_ForwardIterator __stable_partition(
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator __stable_partition(
     _ForwardIterator __first, _ForwardIterator __last, _Predicate&& __pred, _IterCategory __iter_category) {
   return std::__stable_partition_impl<_AlgPolicy, __remove_cvref_t<_Predicate>&>(
       std::move(__first), std::move(__last), __pred, __iter_category);
 }
 
 template <class _ForwardIterator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-_ForwardIterator
-stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
-{
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
   using _IterCategory = typename iterator_traits<_ForwardIterator>::iterator_category;
   return std::__stable_partition<_ClassicAlgPolicy, _Predicate&>(
       std::move(__first), std::move(__last), __pred, _IterCategory());
@@ -325,4 +302,6 @@ stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate _
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_STABLE_PARTITION_H
diff --git a/third_party/libcxx/__algorithm/stable_sort.h b/third_party/libcxx/__algorithm/stable_sort.h
index 0c9daa2ad..726e7e16b 100644
--- a/third_party/libcxx/__algorithm/stable_sort.h
+++ b/third_party/libcxx/__algorithm/stable_sort.h
@@ -15,11 +15,12 @@
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/sort.h>
 #include <__config>
+#include <__debug_utils/strict_weak_ordering_check.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/destruct_n.h>
 #include <__memory/temporary_buffer.h>
 #include <__memory/unique_ptr.h>
-#include <__type_traits/is_trivially_copy_assignable.h>
+#include <__type_traits/is_trivially_assignable.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <new>
@@ -28,12 +29,17 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _BidirectionalIterator>
-_LIBCPP_HIDE_FROM_ABI
-void __insertion_sort_move(_BidirectionalIterator __first1, _BidirectionalIterator __last1,
-                           typename iterator_traits<_BidirectionalIterator>::value_type* __first2, _Compare __comp) {
+_LIBCPP_HIDE_FROM_ABI void __insertion_sort_move(
+    _BidirectionalIterator __first1,
+    _BidirectionalIterator __last1,
+    typename iterator_traits<_BidirectionalIterator>::value_type* __first2,
+    _Compare __comp) {
   using _Ops = _IterOps<_AlgPolicy>;
 
   typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
@@ -62,217 +68,206 @@ void __insertion_sort_move(_BidirectionalIterator __first1, _BidirectionalIterat
 }
 
 template <class _AlgPolicy, class _Compare, class _InputIterator1, class _InputIterator2>
-_LIBCPP_HIDE_FROM_ABI void
-__merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1,
-        _InputIterator2 __first2, _InputIterator2 __last2,
-        typename iterator_traits<_InputIterator1>::value_type* __result, _Compare __comp)
-{
-    using _Ops = _IterOps<_AlgPolicy>;
+_LIBCPP_HIDE_FROM_ABI void __merge_move_construct(
+    _InputIterator1 __first1,
+    _InputIterator1 __last1,
+    _InputIterator2 __first2,
+    _InputIterator2 __last2,
+    typename iterator_traits<_InputIterator1>::value_type* __result,
+    _Compare __comp) {
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    typedef typename iterator_traits<_InputIterator1>::value_type value_type;
-    __destruct_n __d(0);
-    unique_ptr<value_type, __destruct_n&> __h(__result, __d);
-    for (; true; ++__result)
-    {
-        if (__first1 == __last1)
-        {
-            for (; __first2 != __last2; ++__first2, (void) ++__result, __d.template __incr<value_type>())
-                ::new ((void*)__result) value_type(_Ops::__iter_move(__first2));
-            __h.release();
-            return;
-        }
-        if (__first2 == __last2)
-        {
-            for (; __first1 != __last1; ++__first1, (void) ++__result, __d.template __incr<value_type>())
-                ::new ((void*)__result) value_type(_Ops::__iter_move(__first1));
-            __h.release();
-            return;
-        }
-        if (__comp(*__first2, *__first1))
-        {
-            ::new ((void*)__result) value_type(_Ops::__iter_move(__first2));
-            __d.template __incr<value_type>();
-            ++__first2;
-        }
-        else
-        {
-            ::new ((void*)__result) value_type(_Ops::__iter_move(__first1));
-            __d.template __incr<value_type>();
-            ++__first1;
-        }
+  typedef typename iterator_traits<_InputIterator1>::value_type value_type;
+  __destruct_n __d(0);
+  unique_ptr<value_type, __destruct_n&> __h(__result, __d);
+  for (; true; ++__result) {
+    if (__first1 == __last1) {
+      for (; __first2 != __last2; ++__first2, (void)++__result, __d.template __incr<value_type>())
+        ::new ((void*)__result) value_type(_Ops::__iter_move(__first2));
+      __h.release();
+      return;
     }
+    if (__first2 == __last2) {
+      for (; __first1 != __last1; ++__first1, (void)++__result, __d.template __incr<value_type>())
+        ::new ((void*)__result) value_type(_Ops::__iter_move(__first1));
+      __h.release();
+      return;
+    }
+    if (__comp(*__first2, *__first1)) {
+      ::new ((void*)__result) value_type(_Ops::__iter_move(__first2));
+      __d.template __incr<value_type>();
+      ++__first2;
+    } else {
+      ::new ((void*)__result) value_type(_Ops::__iter_move(__first1));
+      __d.template __incr<value_type>();
+      ++__first1;
+    }
+  }
 }
 
 template <class _AlgPolicy, class _Compare, class _InputIterator1, class _InputIterator2, class _OutputIterator>
-_LIBCPP_HIDE_FROM_ABI void
-__merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1,
-        _InputIterator2 __first2, _InputIterator2 __last2,
-        _OutputIterator __result, _Compare __comp)
-{
-    using _Ops = _IterOps<_AlgPolicy>;
+_LIBCPP_HIDE_FROM_ABI void __merge_move_assign(
+    _InputIterator1 __first1,
+    _InputIterator1 __last1,
+    _InputIterator2 __first2,
+    _InputIterator2 __last2,
+    _OutputIterator __result,
+    _Compare __comp) {
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    for (; __first1 != __last1; ++__result)
-    {
-        if (__first2 == __last2)
-        {
-            for (; __first1 != __last1; ++__first1, (void) ++__result)
-                *__result = _Ops::__iter_move(__first1);
-            return;
-        }
-        if (__comp(*__first2, *__first1))
-        {
-            *__result = _Ops::__iter_move(__first2);
-            ++__first2;
-        }
-        else
-        {
-            *__result = _Ops::__iter_move(__first1);
-            ++__first1;
-        }
+  for (; __first1 != __last1; ++__result) {
+    if (__first2 == __last2) {
+      for (; __first1 != __last1; ++__first1, (void)++__result)
+        *__result = _Ops::__iter_move(__first1);
+      return;
     }
-    for (; __first2 != __last2; ++__first2, (void) ++__result)
-        *__result = _Ops::__iter_move(__first2);
+    if (__comp(*__first2, *__first1)) {
+      *__result = _Ops::__iter_move(__first2);
+      ++__first2;
+    } else {
+      *__result = _Ops::__iter_move(__first1);
+      ++__first1;
+    }
+  }
+  for (; __first2 != __last2; ++__first2, (void)++__result)
+    *__result = _Ops::__iter_move(__first2);
 }
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-void
-__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
-              typename iterator_traits<_RandomAccessIterator>::difference_type __len,
-              typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size);
+void __stable_sort(_RandomAccessIterator __first,
+                   _RandomAccessIterator __last,
+                   _Compare __comp,
+                   typename iterator_traits<_RandomAccessIterator>::difference_type __len,
+                   typename iterator_traits<_RandomAccessIterator>::value_type* __buff,
+                   ptrdiff_t __buff_size);
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-void
-__stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Compare __comp,
-                   typename iterator_traits<_RandomAccessIterator>::difference_type __len,
-                   typename iterator_traits<_RandomAccessIterator>::value_type* __first2)
-{
-    using _Ops = _IterOps<_AlgPolicy>;
+void __stable_sort_move(_RandomAccessIterator __first1,
+                        _RandomAccessIterator __last1,
+                        _Compare __comp,
+                        typename iterator_traits<_RandomAccessIterator>::difference_type __len,
+                        typename iterator_traits<_RandomAccessIterator>::value_type* __first2) {
+  using _Ops = _IterOps<_AlgPolicy>;
 
-    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
-    switch (__len)
-    {
-    case 0:
-        return;
-    case 1:
-        ::new ((void*)__first2) value_type(_Ops::__iter_move(__first1));
-        return;
-    case 2:
-        __destruct_n __d(0);
-        unique_ptr<value_type, __destruct_n&> __h2(__first2, __d);
-        if (__comp(*--__last1, *__first1))
-        {
-            ::new ((void*)__first2) value_type(_Ops::__iter_move(__last1));
-            __d.template __incr<value_type>();
-            ++__first2;
-            ::new ((void*)__first2) value_type(_Ops::__iter_move(__first1));
-        }
-        else
-        {
-            ::new ((void*)__first2) value_type(_Ops::__iter_move(__first1));
-            __d.template __incr<value_type>();
-            ++__first2;
-            ::new ((void*)__first2) value_type(_Ops::__iter_move(__last1));
-        }
-        __h2.release();
-        return;
+  typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
+  switch (__len) {
+  case 0:
+    return;
+  case 1:
+    ::new ((void*)__first2) value_type(_Ops::__iter_move(__first1));
+    return;
+  case 2:
+    __destruct_n __d(0);
+    unique_ptr<value_type, __destruct_n&> __h2(__first2, __d);
+    if (__comp(*--__last1, *__first1)) {
+      ::new ((void*)__first2) value_type(_Ops::__iter_move(__last1));
+      __d.template __incr<value_type>();
+      ++__first2;
+      ::new ((void*)__first2) value_type(_Ops::__iter_move(__first1));
+    } else {
+      ::new ((void*)__first2) value_type(_Ops::__iter_move(__first1));
+      __d.template __incr<value_type>();
+      ++__first2;
+      ::new ((void*)__first2) value_type(_Ops::__iter_move(__last1));
     }
-    if (__len <= 8)
-    {
-        std::__insertion_sort_move<_AlgPolicy, _Compare>(__first1, __last1, __first2, __comp);
-        return;
-    }
-    typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
-    _RandomAccessIterator __m = __first1 + __l2;
-    std::__stable_sort<_AlgPolicy, _Compare>(__first1, __m, __comp, __l2, __first2, __l2);
-    std::__stable_sort<_AlgPolicy, _Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2);
-    std::__merge_move_construct<_AlgPolicy, _Compare>(__first1, __m, __m, __last1, __first2, __comp);
+    __h2.release();
+    return;
+  }
+  if (__len <= 8) {
+    std::__insertion_sort_move<_AlgPolicy, _Compare>(__first1, __last1, __first2, __comp);
+    return;
+  }
+  typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
+  _RandomAccessIterator __m                                             = __first1 + __l2;
+  std::__stable_sort<_AlgPolicy, _Compare>(__first1, __m, __comp, __l2, __first2, __l2);
+  std::__stable_sort<_AlgPolicy, _Compare>(__m, __last1, __comp, __len - __l2, __first2 + __l2, __len - __l2);
+  std::__merge_move_construct<_AlgPolicy, _Compare>(__first1, __m, __m, __last1, __first2, __comp);
 }
 
 template <class _Tp>
-struct __stable_sort_switch
-{
-    static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value;
+struct __stable_sort_switch {
+  static const unsigned value = 128 * is_trivially_copy_assignable<_Tp>::value;
 };
 
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
-void
-__stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp,
-              typename iterator_traits<_RandomAccessIterator>::difference_type __len,
-              typename iterator_traits<_RandomAccessIterator>::value_type* __buff, ptrdiff_t __buff_size)
-{
-    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
-    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
-    switch (__len)
-    {
-    case 0:
-    case 1:
-        return;
-    case 2:
-        if (__comp(*--__last, *__first))
-            _IterOps<_AlgPolicy>::iter_swap(__first, __last);
-        return;
-    }
-    if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value))
-    {
-        std::__insertion_sort<_AlgPolicy, _Compare>(__first, __last, __comp);
-        return;
-    }
-    typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
-    _RandomAccessIterator __m = __first + __l2;
-    if (__len <= __buff_size)
-    {
-        __destruct_n __d(0);
-        unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
-        std::__stable_sort_move<_AlgPolicy, _Compare>(__first, __m, __comp, __l2, __buff);
-        __d.__set(__l2, (value_type*)nullptr);
-        std::__stable_sort_move<_AlgPolicy, _Compare>(__m, __last, __comp, __len - __l2, __buff + __l2);
-        __d.__set(__len, (value_type*)nullptr);
-        std::__merge_move_assign<_AlgPolicy, _Compare>(
-            __buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp);
-//         _VSTD::__merge<_Compare>(move_iterator<value_type*>(__buff),
-//                                  move_iterator<value_type*>(__buff + __l2),
-//                                  move_iterator<_RandomAccessIterator>(__buff + __l2),
-//                                  move_iterator<_RandomAccessIterator>(__buff + __len),
-//                                  __first, __comp);
-        return;
-    }
-    std::__stable_sort<_AlgPolicy, _Compare>(__first, __m, __comp, __l2, __buff, __buff_size);
-    std::__stable_sort<_AlgPolicy, _Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size);
-    std::__inplace_merge<_AlgPolicy>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size);
+void __stable_sort(_RandomAccessIterator __first,
+                   _RandomAccessIterator __last,
+                   _Compare __comp,
+                   typename iterator_traits<_RandomAccessIterator>::difference_type __len,
+                   typename iterator_traits<_RandomAccessIterator>::value_type* __buff,
+                   ptrdiff_t __buff_size) {
+  typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
+  typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
+  switch (__len) {
+  case 0:
+  case 1:
+    return;
+  case 2:
+    if (__comp(*--__last, *__first))
+      _IterOps<_AlgPolicy>::iter_swap(__first, __last);
+    return;
+  }
+  if (__len <= static_cast<difference_type>(__stable_sort_switch<value_type>::value)) {
+    std::__insertion_sort<_AlgPolicy, _Compare>(__first, __last, __comp);
+    return;
+  }
+  typename iterator_traits<_RandomAccessIterator>::difference_type __l2 = __len / 2;
+  _RandomAccessIterator __m                                             = __first + __l2;
+  if (__len <= __buff_size) {
+    __destruct_n __d(0);
+    unique_ptr<value_type, __destruct_n&> __h2(__buff, __d);
+    std::__stable_sort_move<_AlgPolicy, _Compare>(__first, __m, __comp, __l2, __buff);
+    __d.__set(__l2, (value_type*)nullptr);
+    std::__stable_sort_move<_AlgPolicy, _Compare>(__m, __last, __comp, __len - __l2, __buff + __l2);
+    __d.__set(__len, (value_type*)nullptr);
+    std::__merge_move_assign<_AlgPolicy, _Compare>(
+        __buff, __buff + __l2, __buff + __l2, __buff + __len, __first, __comp);
+    //         std::__merge<_Compare>(move_iterator<value_type*>(__buff),
+    //                                  move_iterator<value_type*>(__buff + __l2),
+    //                                  move_iterator<_RandomAccessIterator>(__buff + __l2),
+    //                                  move_iterator<_RandomAccessIterator>(__buff + __len),
+    //                                  __first, __comp);
+    return;
+  }
+  std::__stable_sort<_AlgPolicy, _Compare>(__first, __m, __comp, __l2, __buff, __buff_size);
+  std::__stable_sort<_AlgPolicy, _Compare>(__m, __last, __comp, __len - __l2, __buff, __buff_size);
+  std::__inplace_merge<_AlgPolicy>(__first, __m, __last, __comp, __l2, __len - __l2, __buff, __buff_size);
 }
 
 template <class _AlgPolicy, class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_HIDE_FROM_ABI
-void __stable_sort_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) {
-  using value_type = typename iterator_traits<_RandomAccessIterator>::value_type;
+inline _LIBCPP_HIDE_FROM_ABI void
+__stable_sort_impl(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare& __comp) {
+  using value_type      = typename iterator_traits<_RandomAccessIterator>::value_type;
   using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;
 
   difference_type __len = __last - __first;
   pair<value_type*, ptrdiff_t> __buf(0, 0);
   unique_ptr<value_type, __return_temporary_buffer> __h;
   if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value)) {
-// TODO: Remove the use of std::get_temporary_buffer
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-      __buf = std::get_temporary_buffer<value_type>(__len);
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-      __h.reset(__buf.first);
+    // TODO: Remove the use of std::get_temporary_buffer
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    __buf = std::get_temporary_buffer<value_type>(__len);
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
+    __h.reset(__buf.first);
   }
 
   std::__stable_sort<_AlgPolicy, __comp_ref_type<_Compare> >(__first, __last, __comp, __len, __buf.first, __buf.second);
+  std::__check_strict_weak_ordering_sorted(__first, __last, __comp);
 }
 
 template <class _RandomAccessIterator, class _Compare>
-inline _LIBCPP_HIDE_FROM_ABI
-void stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
+inline _LIBCPP_HIDE_FROM_ABI void
+stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
   std::__stable_sort_impl<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __comp);
 }
 
 template <class _RandomAccessIterator>
-inline _LIBCPP_HIDE_FROM_ABI
-void stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) {
-  std::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+inline _LIBCPP_HIDE_FROM_ABI void stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last) {
+  std::stable_sort(__first, __last, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_STABLE_SORT_H
diff --git a/third_party/libcxx/__algorithm/swap_ranges.h b/third_party/libcxx/__algorithm/swap_ranges.h
index 5ce5ed8c8..54b453b72 100644
--- a/third_party/libcxx/__algorithm/swap_ranges.h
+++ b/third_party/libcxx/__algorithm/swap_ranges.h
@@ -18,12 +18,14 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // 2+2 iterators: the shorter size will be used.
 template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _ForwardIterator2, class _Sentinel2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-pair<_ForwardIterator1, _ForwardIterator2>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_ForwardIterator1, _ForwardIterator2>
 __swap_ranges(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2 __first2, _Sentinel2 __last2) {
   while (__first1 != __last1 && __first2 != __last2) {
     _IterOps<_AlgPolicy>::iter_swap(__first1, __first2);
@@ -36,8 +38,7 @@ __swap_ranges(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2
 
 // 2+1 iterators: size2 >= size1.
 template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _ForwardIterator2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-pair<_ForwardIterator1, _ForwardIterator2>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_ForwardIterator1, _ForwardIterator2>
 __swap_ranges(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2 __first2) {
   while (__first1 != __last1) {
     _IterOps<_AlgPolicy>::iter_swap(__first1, __first2);
@@ -49,12 +50,13 @@ __swap_ranges(_ForwardIterator1 __first1, _Sentinel1 __last1, _ForwardIterator2
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator2
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator2
 swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
-  return std::__swap_ranges<_ClassicAlgPolicy>(
-      std::move(__first1), std::move(__last1), std::move(__first2)).second;
+  return std::__swap_ranges<_ClassicAlgPolicy>(std::move(__first1), std::move(__last1), std::move(__first2)).second;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_SWAP_RANGES_H
diff --git a/third_party/libcxx/__algorithm/three_way_comp_ref_type.h b/third_party/libcxx/__algorithm/three_way_comp_ref_type.h
index 10396e068..70c581897 100644
--- a/third_party/libcxx/__algorithm/three_way_comp_ref_type.h
+++ b/third_party/libcxx/__algorithm/three_way_comp_ref_type.h
@@ -11,8 +11,8 @@
 
 #include <__compare/ordering.h>
 #include <__config>
-#include <__debug>
 #include <__utility/declval.h>
+#include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -27,35 +27,38 @@ struct __debug_three_way_comp {
   _Comp& __comp_;
   _LIBCPP_HIDE_FROM_ABI constexpr __debug_three_way_comp(_Comp& __c) : __comp_(__c) {}
 
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(const _Tp& __x, const _Up& __y) {
+    auto __r = __comp_(__x, __y);
+    if constexpr (__comparison_category<decltype(__comp_(__x, __y))>)
+      __do_compare_assert(__y, __x, __r);
+    return __r;
+  }
+
   template <class _Tp, class _Up>
   _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp& __x, _Up& __y) {
     auto __r = __comp_(__x, __y);
-    __do_compare_assert(0, __y, __x, __r);
+    if constexpr (__comparison_category<decltype(__comp_(__x, __y))>)
+      __do_compare_assert(__y, __x, __r);
     return __r;
   }
 
   template <class _LHS, class _RHS, class _Order>
-  _LIBCPP_HIDE_FROM_ABI constexpr inline void __do_compare_assert(int, _LHS& __l, _RHS& __r, _Order __o)
-    requires __comparison_category<decltype(std::declval<_Comp&>()(std::declval<_LHS&>(), std::declval<_RHS&>()))>
-  {
+  _LIBCPP_HIDE_FROM_ABI constexpr void __do_compare_assert(_LHS& __l, _RHS& __r, _Order __o) {
     _Order __expected = __o;
     if (__o == _Order::less)
       __expected = _Order::greater;
     if (__o == _Order::greater)
       __expected = _Order::less;
-    _LIBCPP_DEBUG_ASSERT(__comp_(__l, __r) == __expected, "Comparator does not induce a strict weak ordering");
+    _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+        __comp_(__l, __r) == __expected, "Comparator does not induce a strict weak ordering");
     (void)__l;
     (void)__r;
-    (void)__expected;
   }
-
-  template <class _LHS, class _RHS, class _Order>
-  _LIBCPP_HIDE_FROM_ABI constexpr inline void __do_compare_assert(long, _LHS&, _RHS&, _Order) {}
 };
 
-// Pass the comparator by lvalue reference. Or in debug mode, using a
-// debugging wrapper that stores a reference.
-#  ifndef _LIBCPP_ENABLE_DEBUG_MODE
+// Pass the comparator by lvalue reference. Or in the debug mode, using a debugging wrapper that stores a reference.
+#  if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
 template <class _Comp>
 using __three_way_comp_ref_type = __debug_three_way_comp<_Comp>;
 #  else
diff --git a/third_party/libcxx/__algorithm/transform.h b/third_party/libcxx/__algorithm/transform.h
index 4722c154c..1b4244095 100644
--- a/third_party/libcxx/__algorithm/transform.h
+++ b/third_party/libcxx/__algorithm/transform.h
@@ -18,24 +18,23 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _OutputIterator, class _UnaryOperation>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op)
-{
-    for (; __first != __last; ++__first, (void) ++__result)
-        *__result = __op(*__first);
-    return __result;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op) {
+  for (; __first != __last; ++__first, (void)++__result)
+    *__result = __op(*__first);
+  return __result;
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-transform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
-          _OutputIterator __result, _BinaryOperation __binary_op)
-{
-    for (; __first1 != __last1; ++__first1, (void) ++__first2, ++__result)
-        *__result = __binary_op(*__first1, *__first2);
-    return __result;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator transform(
+    _InputIterator1 __first1,
+    _InputIterator1 __last1,
+    _InputIterator2 __first2,
+    _OutputIterator __result,
+    _BinaryOperation __binary_op) {
+  for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
+    *__result = __binary_op(*__first1, *__first2);
+  return __result;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/uniform_random_bit_generator_adaptor.h b/third_party/libcxx/__algorithm/uniform_random_bit_generator_adaptor.h
index 1f2039949..aef0fbfb7 100644
--- a/third_party/libcxx/__algorithm/uniform_random_bit_generator_adaptor.h
+++ b/third_party/libcxx/__algorithm/uniform_random_bit_generator_adaptor.h
@@ -20,7 +20,7 @@
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_PUSH_MACROS
-#include <__undef_macros>
+#  include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -41,16 +41,12 @@ private:
 public:
   using result_type = invoke_result_t<_Gen&>;
 
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto min() { return __remove_cvref_t<_Gen>::min(); }
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto max() { return __remove_cvref_t<_Gen>::max(); }
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto min() { return __remove_cvref_t<_Gen>::min(); }
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto max() { return __remove_cvref_t<_Gen>::max(); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit _ClassicGenAdaptor(_Gen& __g) : __gen_(__g) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit _ClassicGenAdaptor(_Gen& __g) : __gen_(__g) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()() const { return __gen_(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()() const { return __gen_(); }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__algorithm/unique.h b/third_party/libcxx/__algorithm/unique.h
index 1717a00c8..d59701459 100644
--- a/third_party/libcxx/__algorithm/unique.h
+++ b/third_party/libcxx/__algorithm/unique.h
@@ -21,12 +21,15 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // unique
 
 template <class _AlgPolicy, class _Iter, class _Sent, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 std::pair<_Iter, _Iter>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 std::pair<_Iter, _Iter>
 __unique(_Iter __first, _Sent __last, _BinaryPredicate&& __pred) {
   __first = std::__adjacent_find(__first, __last, __pred);
   if (__first != __last) {
@@ -43,17 +46,19 @@ __unique(_Iter __first, _Sent __last, _BinaryPredicate&& __pred) {
 }
 
 template <class _ForwardIterator, class _BinaryPredicate>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
 unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
   return std::__unique<_ClassicAlgPolicy>(std::move(__first), std::move(__last), __pred).first;
 }
 
 template <class _ForwardIterator>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
 unique(_ForwardIterator __first, _ForwardIterator __last) {
   return std::unique(__first, __last, __equal_to());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_UNIQUE_H
diff --git a/third_party/libcxx/__algorithm/unique_copy.h b/third_party/libcxx/__algorithm/unique_copy.h
index 81fcd50f0..16ce80cab 100644
--- a/third_party/libcxx/__algorithm/unique_copy.h
+++ b/third_party/libcxx/__algorithm/unique_copy.h
@@ -23,6 +23,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace __unique_copy_tags {
@@ -119,4 +122,6 @@ unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __res
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_UNIQUE_COPY_H
diff --git a/third_party/libcxx/__algorithm/unwrap_iter.h b/third_party/libcxx/__algorithm/unwrap_iter.h
index c93b3443c..8cc0d22d4 100644
--- a/third_party/libcxx/__algorithm/unwrap_iter.h
+++ b/third_party/libcxx/__algorithm/unwrap_iter.h
@@ -13,7 +13,7 @@
 #include <__iterator/iterator_traits.h>
 #include <__memory/pointer_traits.h>
 #include <__type_traits/enable_if.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/declval.h>
 #include <__utility/move.h>
 
@@ -21,12 +21,14 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // TODO: Change the name of __unwrap_iter_impl to something more appropriate
 // The job of __unwrap_iter is to remove iterator wrappers (like reverse_iterator or __wrap_iter),
 // to reduce the number of template instantiations and to enable pointer-based optimizations e.g. in std::copy.
-// In debug mode, we don't do this.
 //
 // Some algorithms (e.g. std::copy, but not std::sort) need to convert an
 // "unwrapped" result back into the original iterator type. Doing that is the job of __rewrap_iter.
@@ -38,7 +40,8 @@ struct __unwrap_iter_impl {
   static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Iter __unwrap(_Iter __i) _NOEXCEPT { return __i; }
 };
 
-#ifndef _LIBCPP_ENABLE_DEBUG_MODE
+// TODO(hardening): make sure that the following unwrapping doesn't unexpectedly turn hardened iterators into raw
+// pointers.
 
 // It's a contiguous iterator, so we can use a raw pointer instead
 template <class _Iter>
@@ -54,13 +57,11 @@ struct __unwrap_iter_impl<_Iter, true> {
   }
 };
 
-#endif // !_LIBCPP_ENABLE_DEBUG_MODE
-
-template<class _Iter,
-         class _Impl = __unwrap_iter_impl<_Iter>,
-         __enable_if_t<is_copy_constructible<_Iter>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-decltype(_Impl::__unwrap(std::declval<_Iter>())) __unwrap_iter(_Iter __i) _NOEXCEPT {
+template <class _Iter,
+          class _Impl                                             = __unwrap_iter_impl<_Iter>,
+          __enable_if_t<is_copy_constructible<_Iter>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 decltype(_Impl::__unwrap(std::declval<_Iter>()))
+__unwrap_iter(_Iter __i) _NOEXCEPT {
   return _Impl::__unwrap(__i);
 }
 
@@ -79,4 +80,6 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _OrigIter __rewrap_iter(_OrigIter __orig
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_UNWRAP_ITER_H
diff --git a/third_party/libcxx/__algorithm/unwrap_range.h b/third_party/libcxx/__algorithm/unwrap_range.h
index 2c75c8f49..2d4b9bb55 100644
--- a/third_party/libcxx/__algorithm/unwrap_range.h
+++ b/third_party/libcxx/__algorithm/unwrap_range.h
@@ -22,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // __unwrap_range and __rewrap_range are used to unwrap ranges which may have different iterator and sentinel types.
@@ -50,7 +53,7 @@ struct __unwrap_range_impl {
   }
 
   _LIBCPP_HIDE_FROM_ABI static constexpr auto __rewrap(const _Iter&, _Iter __iter)
-    requires (!(random_access_iterator<_Iter> && sized_sentinel_for<_Sent, _Iter>))
+    requires(!(random_access_iterator<_Iter> && sized_sentinel_for<_Sent, _Iter>))
   {
     return __iter;
   }
@@ -73,10 +76,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto __unwrap_range(_Iter __first, _Sent __last)
   return __unwrap_range_impl<_Iter, _Sent>::__unwrap(std::move(__first), std::move(__last));
 }
 
-template <
-    class _Sent,
-    class _Iter,
-    class _Unwrapped = decltype(std::__unwrap_range(std::declval<_Iter>(), std::declval<_Sent>()))>
+template < class _Sent, class _Iter, class _Unwrapped>
 _LIBCPP_HIDE_FROM_ABI constexpr _Iter __rewrap_range(_Iter __orig_iter, _Unwrapped __iter) {
   return __unwrap_range_impl<_Iter, _Sent>::__rewrap(std::move(__orig_iter), std::move(__iter));
 }
@@ -86,7 +86,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR pair<_Unwrapped, _Unwrapped> __unwrap_ra
   return std::make_pair(std::__unwrap_iter(std::move(__first)), std::__unwrap_iter(std::move(__last)));
 }
 
-template <class _Iter, class _Unwrapped = decltype(std::__unwrap_iter(std::declval<_Iter>()))>
+template <class _Iter, class _Unwrapped>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Iter __rewrap_range(_Iter __orig_iter, _Unwrapped __iter) {
   return std::__rewrap_iter(std::move(__orig_iter), std::move(__iter));
 }
@@ -94,4 +94,6 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Iter __rewrap_range(_Iter __orig_iter,
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_UNWRAP_RANGE_H
diff --git a/third_party/libcxx/__algorithm/upper_bound.h b/third_party/libcxx/__algorithm/upper_bound.h
index 96552ce1f..c39dec2e8 100644
--- a/third_party/libcxx/__algorithm/upper_bound.h
+++ b/third_party/libcxx/__algorithm/upper_bound.h
@@ -18,13 +18,16 @@
 #include <__iterator/advance.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Compare, class _Iter, class _Sent, class _Tp, class _Proj>
@@ -45,24 +48,21 @@ __upper_bound(_Iter __first, _Sent __last, const _Tp& __value, _Compare&& __comp
 }
 
 template <class _ForwardIterator, class _Tp, class _Compare>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
 upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
-  static_assert(is_copy_constructible<_ForwardIterator>::value,
-                "Iterator has to be copy constructible");
+  static_assert(is_copy_constructible<_ForwardIterator>::value, "Iterator has to be copy constructible");
   return std::__upper_bound<_ClassicAlgPolicy>(
       std::move(__first), std::move(__last), __value, std::move(__comp), std::__identity());
 }
 
 template <class _ForwardIterator, class _Tp>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
 upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
-  return std::upper_bound(
-      std::move(__first),
-      std::move(__last),
-      __value,
-      __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>());
+  return std::upper_bound(std::move(__first), std::move(__last), __value, __less<>());
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ALGORITHM_UPPER_BOUND_H
diff --git a/third_party/libcxx/__assert b/third_party/libcxx/__assert
index e20ee50b1..49769fb4d 100644
--- a/third_party/libcxx/__assert
+++ b/third_party/libcxx/__assert
@@ -10,40 +10,109 @@
 #ifndef _LIBCPP___ASSERT
 #define _LIBCPP___ASSERT
 
+#include <__assertion_handler> // Note: this include is generated by CMake and is potentially vendor-provided.
 #include <__config>
-#include <__verbose_abort>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-// Automatically enable assertions when the debug mode is enabled.
-#if defined(_LIBCPP_ENABLE_DEBUG_MODE)
-#  ifndef _LIBCPP_ENABLE_ASSERTIONS
-#    define _LIBCPP_ENABLE_ASSERTIONS 1
-#  endif
-#endif
+#define _LIBCPP_ASSERT(expression, message)                                                                            \
+  (__builtin_expect(static_cast<bool>(expression), 1)                                                                  \
+       ? (void)0                                                                                                       \
+       : _LIBCPP_ASSERTION_HANDLER(__FILE__ ":" _LIBCPP_TOSTRING(__LINE__) ": assertion " _LIBCPP_TOSTRING(            \
+             expression) " failed: " message "\n"))
 
-#ifndef _LIBCPP_ENABLE_ASSERTIONS
-#  define _LIBCPP_ENABLE_ASSERTIONS _LIBCPP_ENABLE_ASSERTIONS_DEFAULT
-#endif
-
-#if _LIBCPP_ENABLE_ASSERTIONS != 0 && _LIBCPP_ENABLE_ASSERTIONS != 1
-#  error "_LIBCPP_ENABLE_ASSERTIONS must be set to 0 or 1"
-#endif
-
-#if _LIBCPP_ENABLE_ASSERTIONS
-#  define _LIBCPP_ASSERT(expression, message)                                                                          \
-    (__builtin_expect(static_cast<bool>(expression), 1)                                                                \
-         ? (void)0                                                                                                     \
-         : _LIBCPP_VERBOSE_ABORT(                                                                                      \
-               "%s:%d: assertion %s failed: %s", __builtin_FILE(), __builtin_LINE(), #expression, message))
-#elif !defined(_LIBCPP_ASSERTIONS_DISABLE_ASSUME) && __has_builtin(__builtin_assume)
-#  define _LIBCPP_ASSERT(expression, message)                                                                          \
+// TODO: __builtin_assume can currently inhibit optimizations. Until this has been fixed and we can add
+//       assumptions without a clear optimization intent, disable that to avoid worsening the code generation.
+//       See https://discourse.llvm.org/t/llvm-assume-blocks-optimization/71609 for a discussion.
+#if 0 && __has_builtin(__builtin_assume)
+#  define _LIBCPP_ASSUME(expression)                                                                                   \
     (_LIBCPP_DIAGNOSTIC_PUSH _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wassume")                                              \
          __builtin_assume(static_cast<bool>(expression)) _LIBCPP_DIAGNOSTIC_POP)
 #else
-#  define _LIBCPP_ASSERT(expression, message) ((void)0)
+#  define _LIBCPP_ASSUME(expression) ((void)0)
 #endif
 
+// clang-format off
+// Fast hardening mode checks.
+
+#if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_FAST
+
+// Enabled checks.
+#  define _LIBCPP_ASSERT_VALID_INPUT_RANGE(expression, message)       _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(expression, message)    _LIBCPP_ASSERT(expression, message)
+// Disabled checks.
+// On most modern platforms, dereferencing a null pointer does not lead to an actual memory access.
+#  define _LIBCPP_ASSERT_NON_NULL(expression, message)                _LIBCPP_ASSUME(expression)
+// Overlapping ranges will make algorithms produce incorrect results but don't directly lead to a security
+// vulnerability.
+#  define _LIBCPP_ASSERT_NON_OVERLAPPING_RANGES(expression, message)  _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_VALID_DEALLOCATION(expression, message)      _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(expression, message) _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(expression, message)    _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(expression, message)  _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_PEDANTIC(expression, message)                _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(expression, message)    _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_INTERNAL(expression, message)                _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_UNCATEGORIZED(expression, message)           _LIBCPP_ASSUME(expression)
+
+// Extensive hardening mode checks.
+
+#elif _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_EXTENSIVE
+
+// Enabled checks.
+#  define _LIBCPP_ASSERT_VALID_INPUT_RANGE(expression, message)       _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(expression, message)    _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_NON_NULL(expression, message)                _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_NON_OVERLAPPING_RANGES(expression, message)  _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_VALID_DEALLOCATION(expression, message)      _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(expression, message) _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(expression, message)    _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(expression, message)  _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_PEDANTIC(expression, message)                _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_UNCATEGORIZED(expression, message)           _LIBCPP_ASSERT(expression, message)
+// Disabled checks.
+#  define _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(expression, message)    _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_INTERNAL(expression, message)                _LIBCPP_ASSUME(expression)
+
+// Debug hardening mode checks.
+
+#elif _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
+
+// All checks enabled.
+#  define _LIBCPP_ASSERT_VALID_INPUT_RANGE(expression, message)       _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(expression, message)    _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_NON_NULL(expression, message)                _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_NON_OVERLAPPING_RANGES(expression, message)  _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_VALID_DEALLOCATION(expression, message)      _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(expression, message) _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(expression, message)    _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(expression, message)  _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_PEDANTIC(expression, message)                _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(expression, message)    _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_INTERNAL(expression, message)                _LIBCPP_ASSERT(expression, message)
+#  define _LIBCPP_ASSERT_UNCATEGORIZED(expression, message)           _LIBCPP_ASSERT(expression, message)
+
+// Disable all checks if hardening is not enabled.
+
+#else
+
+// All checks disabled.
+#  define _LIBCPP_ASSERT_VALID_INPUT_RANGE(expression, message)       _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(expression, message)    _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_NON_NULL(expression, message)                _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_NON_OVERLAPPING_RANGES(expression, message)  _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_VALID_DEALLOCATION(expression, message)      _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(expression, message) _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(expression, message)    _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(expression, message)  _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_PEDANTIC(expression, message)                _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(expression, message)    _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_INTERNAL(expression, message)                _LIBCPP_ASSUME(expression)
+#  define _LIBCPP_ASSERT_UNCATEGORIZED(expression, message)           _LIBCPP_ASSUME(expression)
+
+#endif // _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_FAST
+// clang-format on
+
 #endif // _LIBCPP___ASSERT
diff --git a/third_party/libcxx/__assertion_handler b/third_party/libcxx/__assertion_handler
new file mode 100644
index 000000000..8bc0553c0
--- /dev/null
+++ b/third_party/libcxx/__assertion_handler
@@ -0,0 +1,31 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ASSERTION_HANDLER
+#define _LIBCPP___ASSERTION_HANDLER
+
+#include <__config>
+#include <__verbose_abort>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
+
+#  define _LIBCPP_ASSERTION_HANDLER(message) _LIBCPP_VERBOSE_ABORT("%s", message)
+
+#else
+
+// TODO(hardening): use `__builtin_verbose_trap(message)` once that becomes available.
+#  define _LIBCPP_ASSERTION_HANDLER(message) ((void)message, __builtin_trap())
+
+#endif // _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
+
+#endif // _LIBCPP___ASSERTION_HANDLER
diff --git a/third_party/libcxx/__atomic/aliases.h b/third_party/libcxx/__atomic/aliases.h
index e2f9fae40..e27e09af6 100644
--- a/third_party/libcxx/__atomic/aliases.h
+++ b/third_party/libcxx/__atomic/aliases.h
@@ -15,9 +15,9 @@
 #include <__atomic/is_always_lock_free.h>
 #include <__config>
 #include <__type_traits/conditional.h>
+#include <__type_traits/make_unsigned.h>
 #include <cstddef>
 #include <cstdint>
-#include <cstdlib>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -80,36 +80,30 @@ using atomic_ptrdiff_t = atomic<ptrdiff_t>;
 using atomic_intmax_t  = atomic<intmax_t>;
 using atomic_uintmax_t = atomic<uintmax_t>;
 
-// atomic_*_lock_free : prefer the contention type most highly, then the largest lock-free type
+// C++20 atomic_{signed,unsigned}_lock_free: prefer the contention type most highly, then the largest lock-free type
+#if _LIBCPP_STD_VER >= 20
+#  if ATOMIC_LLONG_LOCK_FREE == 2
+using __largest_lock_free_type = long long;
+#  elif ATOMIC_INT_LOCK_FREE == 2
+using __largest_lock_free_type = int;
+#  elif ATOMIC_SHORT_LOCK_FREE == 2
+using __largest_lock_free_type = short;
+#  elif ATOMIC_CHAR_LOCK_FREE == 2
+using __largest_lock_free_type = char;
+#  else
+#    define _LIBCPP_NO_LOCK_FREE_TYPES // There are no lockfree types (this can happen on unusual platforms)
+#  endif
 
-#if _LIBCPP_STD_VER >= 17
-#  define _LIBCPP_CONTENTION_LOCK_FREE ::std::__libcpp_is_always_lock_free<__cxx_contention_t>::__value
-#else
-#  define _LIBCPP_CONTENTION_LOCK_FREE false
-#endif
+#  ifndef _LIBCPP_NO_LOCK_FREE_TYPES
+using __contention_t_or_largest =
+    __conditional_t<__libcpp_is_always_lock_free<__cxx_contention_t>::__value,
+                    __cxx_contention_t,
+                    __largest_lock_free_type>;
 
-#if ATOMIC_LLONG_LOCK_FREE == 2
-using __libcpp_signed_lock_free = __conditional_t<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, long long>;
-using __libcpp_unsigned_lock_free =
-    __conditional_t<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned long long>;
-#elif ATOMIC_INT_LOCK_FREE == 2
-using __libcpp_signed_lock_free   = __conditional_t<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, int>;
-using __libcpp_unsigned_lock_free = __conditional_t<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned int>;
-#elif ATOMIC_SHORT_LOCK_FREE == 2
-using __libcpp_signed_lock_free   = __conditional_t<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, short>;
-using __libcpp_unsigned_lock_free = __conditional_t<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned short>;
-#elif ATOMIC_CHAR_LOCK_FREE == 2
-using __libcpp_signed_lock_free   = __conditional_t<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, char>;
-using __libcpp_unsigned_lock_free = __conditional_t<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned char>;
-#else
-// No signed/unsigned lock-free types
-#  define _LIBCPP_NO_LOCK_FREE_TYPES
-#endif
-
-#if !defined(_LIBCPP_NO_LOCK_FREE_TYPES)
-using atomic_signed_lock_free   = atomic<__libcpp_signed_lock_free>;
-using atomic_unsigned_lock_free = atomic<__libcpp_unsigned_lock_free>;
-#endif
+using atomic_signed_lock_free   = atomic<__contention_t_or_largest>;
+using atomic_unsigned_lock_free = atomic<make_unsigned_t<__contention_t_or_largest>>;
+#  endif // !_LIBCPP_NO_LOCK_FREE_TYPES
+#endif   // C++20
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__atomic/atomic.h b/third_party/libcxx/__atomic/atomic.h
index 68df7f12c..bd3f659c2 100644
--- a/third_party/libcxx/__atomic/atomic.h
+++ b/third_party/libcxx/__atomic/atomic.h
@@ -14,11 +14,17 @@
 #include <__atomic/cxx_atomic_impl.h>
 #include <__atomic/memory_order.h>
 #include <__config>
+#include <__functional/operations.h>
 #include <__memory/addressof.h>
+#include <__type_traits/is_floating_point.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_same.h>
+#include <__type_traits/remove_const.h>
 #include <__type_traits/remove_pointer.h>
+#include <__type_traits/remove_volatile.h>
+#include <__utility/forward.h>
 #include <cstddef>
+#include <cstring>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -27,636 +33,588 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct atomic
-    : public __atomic_base<_Tp>
-{
+struct atomic : public __atomic_base<_Tp> {
   using __base          = __atomic_base<_Tp>;
   using value_type      = _Tp;
   using difference_type = value_type;
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    atomic() = default;
+  _LIBCPP_HIDE_FROM_ABI atomic() = default;
 #else
-    _LIBCPP_HIDE_FROM_ABI
-    atomic() _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI atomic() _NOEXCEPT = default;
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI
-    _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator=(_Tp __d) volatile _NOEXCEPT
-        {__base::store(__d); return __d;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator=(_Tp __d) _NOEXCEPT
-        {__base::store(__d); return __d;}
+  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __d) volatile _NOEXCEPT {
+    __base::store(__d);
+    return __d;
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __d) _NOEXCEPT {
+    __base::store(__d);
+    return __d;
+  }
 
-    atomic& operator=(const atomic&) = delete;
-    atomic& operator=(const atomic&) volatile = delete;
+  atomic& operator=(const atomic&)          = delete;
+  atomic& operator=(const atomic&) volatile = delete;
 };
 
 // atomic<T*>
 
 template <class _Tp>
-struct atomic<_Tp*>
-    : public __atomic_base<_Tp*>
-{
-    using __base          = __atomic_base<_Tp*>;
-    using value_type      = _Tp*;
-    using difference_type = ptrdiff_t;
+struct atomic<_Tp*> : public __atomic_base<_Tp*> {
+  using __base          = __atomic_base<_Tp*>;
+  using value_type      = _Tp*;
+  using difference_type = ptrdiff_t;
 
-    _LIBCPP_HIDE_FROM_ABI
-    atomic() _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI atomic() _NOEXCEPT = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    _LIBCPP_CONSTEXPR atomic(_Tp* __d) _NOEXCEPT : __base(__d) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR atomic(_Tp* __d) _NOEXCEPT : __base(__d) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator=(_Tp* __d) volatile _NOEXCEPT
-        {__base::store(__d); return __d;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator=(_Tp* __d) _NOEXCEPT
-        {__base::store(__d); return __d;}
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator=(_Tp* __d) volatile _NOEXCEPT {
+    __base::store(__d);
+    return __d;
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator=(_Tp* __d) _NOEXCEPT {
+    __base::store(__d);
+    return __d;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
-        // __atomic_fetch_add accepts function pointers, guard against them.
-        static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
-        return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
-    }
+  _LIBCPP_HIDE_FROM_ABI _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    // __atomic_fetch_add accepts function pointers, guard against them.
+    static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
+    return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
-        // __atomic_fetch_add accepts function pointers, guard against them.
-        static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
-        return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
-    }
+  _LIBCPP_HIDE_FROM_ABI _Tp* fetch_add(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    // __atomic_fetch_add accepts function pointers, guard against them.
+    static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
+    return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
-        // __atomic_fetch_add accepts function pointers, guard against them.
-        static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
-        return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
-    }
+  _LIBCPP_HIDE_FROM_ABI _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    // __atomic_fetch_add accepts function pointers, guard against them.
+    static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
+    return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
-        // __atomic_fetch_add accepts function pointers, guard against them.
-        static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
-        return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
-    }
+  _LIBCPP_HIDE_FROM_ABI _Tp* fetch_sub(ptrdiff_t __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    // __atomic_fetch_add accepts function pointers, guard against them.
+    static_assert(!is_function<__remove_pointer_t<_Tp> >::value, "Pointer to function isn't allowed");
+    return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator++(int) volatile _NOEXCEPT            {return fetch_add(1);}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator++(int) _NOEXCEPT                     {return fetch_add(1);}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator--(int) volatile _NOEXCEPT            {return fetch_sub(1);}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator--(int) _NOEXCEPT                     {return fetch_sub(1);}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator++() volatile _NOEXCEPT               {return fetch_add(1) + 1;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator++() _NOEXCEPT                        {return fetch_add(1) + 1;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator--() volatile _NOEXCEPT               {return fetch_sub(1) - 1;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator--() _NOEXCEPT                        {return fetch_sub(1) - 1;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator+=(ptrdiff_t __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator+=(ptrdiff_t __op) _NOEXCEPT          {return fetch_add(__op) + __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator-=(ptrdiff_t __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* operator-=(ptrdiff_t __op) _NOEXCEPT          {return fetch_sub(__op) - __op;}
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator++(int) volatile _NOEXCEPT { return fetch_add(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator++(int) _NOEXCEPT { return fetch_add(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator--(int) volatile _NOEXCEPT { return fetch_sub(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator--(int) _NOEXCEPT { return fetch_sub(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator++() volatile _NOEXCEPT { return fetch_add(1) + 1; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator++() _NOEXCEPT { return fetch_add(1) + 1; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator--() volatile _NOEXCEPT { return fetch_sub(1) - 1; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator--() _NOEXCEPT { return fetch_sub(1) - 1; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator+=(ptrdiff_t __op) volatile _NOEXCEPT { return fetch_add(__op) + __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator+=(ptrdiff_t __op) _NOEXCEPT { return fetch_add(__op) + __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator-=(ptrdiff_t __op) volatile _NOEXCEPT { return fetch_sub(__op) - __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator-=(ptrdiff_t __op) _NOEXCEPT { return fetch_sub(__op) - __op; }
 
-    atomic& operator=(const atomic&) = delete;
-    atomic& operator=(const atomic&) volatile = delete;
+  atomic& operator=(const atomic&)          = delete;
+  atomic& operator=(const atomic&) volatile = delete;
 };
 
+#if _LIBCPP_STD_VER >= 20
+template <class _Tp>
+  requires is_floating_point_v<_Tp>
+struct atomic<_Tp> : __atomic_base<_Tp> {
+private:
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool __is_fp80_long_double() {
+    // Only x87-fp80 long double has 64-bit mantissa
+    return __LDBL_MANT_DIG__ == 64 && std::is_same_v<_Tp, long double>;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool __has_rmw_builtin() {
+#  ifndef _LIBCPP_COMPILER_CLANG_BASED
+    return false;
+#  else
+    // The builtin __cxx_atomic_fetch_add errors during compilation for
+    // long double on platforms with fp80 format.
+    // For more details, see
+    // lib/Sema/SemaChecking.cpp function IsAllowedValueType
+    // LLVM Parser does not allow atomicrmw with x86_fp80 type.
+    // if (ValType->isSpecificBuiltinType(BuiltinType::LongDouble) &&
+    //    &Context.getTargetInfo().getLongDoubleFormat() ==
+    //        &llvm::APFloat::x87DoubleExtended())
+    // For more info
+    // https://github.com/llvm/llvm-project/issues/68602
+    // https://reviews.llvm.org/D53965
+    return !__is_fp80_long_double();
+#  endif
+  }
+
+  template <class _This, class _Operation, class _BuiltinOp>
+  _LIBCPP_HIDE_FROM_ABI static _Tp
+  __rmw_op(_This&& __self, _Tp __operand, memory_order __m, _Operation __operation, _BuiltinOp __builtin_op) {
+    if constexpr (__has_rmw_builtin()) {
+      return __builtin_op(std::addressof(std::forward<_This>(__self).__a_), __operand, __m);
+    } else {
+      _Tp __old = __self.load(memory_order_relaxed);
+      _Tp __new = __operation(__old, __operand);
+      while (!__self.compare_exchange_weak(__old, __new, __m, memory_order_relaxed)) {
+#  ifdef _LIBCPP_COMPILER_CLANG_BASED
+        if constexpr (__is_fp80_long_double()) {
+          // https://github.com/llvm/llvm-project/issues/47978
+          // clang bug: __old is not updated on failure for atomic<long double>::compare_exchange_weak
+          // Note __old = __self.load(memory_order_relaxed) will not work
+          std::__cxx_atomic_load_inplace(std::addressof(__self.__a_), &__old, memory_order_relaxed);
+        }
+#  endif
+        __new = __operation(__old, __operand);
+      }
+      return __old;
+    }
+  }
+
+  template <class _This>
+  _LIBCPP_HIDE_FROM_ABI static _Tp __fetch_add(_This&& __self, _Tp __operand, memory_order __m) {
+    auto __builtin_op = [](auto __a, auto __builtin_operand, auto __order) {
+      return std::__cxx_atomic_fetch_add(__a, __builtin_operand, __order);
+    };
+    return __rmw_op(std::forward<_This>(__self), __operand, __m, std::plus<>{}, __builtin_op);
+  }
+
+  template <class _This>
+  _LIBCPP_HIDE_FROM_ABI static _Tp __fetch_sub(_This&& __self, _Tp __operand, memory_order __m) {
+    auto __builtin_op = [](auto __a, auto __builtin_operand, auto __order) {
+      return std::__cxx_atomic_fetch_sub(__a, __builtin_operand, __order);
+    };
+    return __rmw_op(std::forward<_This>(__self), __operand, __m, std::minus<>{}, __builtin_op);
+  }
+
+public:
+  using __base          = __atomic_base<_Tp>;
+  using value_type      = _Tp;
+  using difference_type = value_type;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr atomic() noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr atomic(_Tp __d) noexcept : __base(__d) {}
+
+  atomic(const atomic&)                     = delete;
+  atomic& operator=(const atomic&)          = delete;
+  atomic& operator=(const atomic&) volatile = delete;
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __d) volatile noexcept
+    requires __base::is_always_lock_free
+  {
+    __base::store(__d);
+    return __d;
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __d) noexcept {
+    __base::store(__d);
+    return __d;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile noexcept
+    requires __base::is_always_lock_free
+  {
+    return __fetch_add(*this, __op, __m);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) noexcept {
+    return __fetch_add(*this, __op, __m);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile noexcept
+    requires __base::is_always_lock_free
+  {
+    return __fetch_sub(*this, __op, __m);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) noexcept {
+    return __fetch_sub(*this, __op, __m);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __op) volatile noexcept
+    requires __base::is_always_lock_free
+  {
+    return fetch_add(__op) + __op;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __op) noexcept { return fetch_add(__op) + __op; }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __op) volatile noexcept
+    requires __base::is_always_lock_free
+  {
+    return fetch_sub(__op) - __op;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __op) noexcept { return fetch_sub(__op) - __op; }
+};
+
+#endif // _LIBCPP_STD_VER >= 20
+
 // atomic_is_lock_free
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool
-atomic_is_lock_free(const volatile atomic<_Tp>* __o) _NOEXCEPT
-{
-    return __o->is_lock_free();
+_LIBCPP_HIDE_FROM_ABI bool atomic_is_lock_free(const volatile atomic<_Tp>* __o) _NOEXCEPT {
+  return __o->is_lock_free();
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool
-atomic_is_lock_free(const atomic<_Tp>* __o) _NOEXCEPT
-{
-    return __o->is_lock_free();
+_LIBCPP_HIDE_FROM_ABI bool atomic_is_lock_free(const atomic<_Tp>* __o) _NOEXCEPT {
+  return __o->is_lock_free();
 }
 
 // atomic_init
 
 template <class _Tp>
-_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI
-void
-atomic_init(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
-{
-    std::__cxx_atomic_init(std::addressof(__o->__a_), __d);
+_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI void
+atomic_init(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT {
+  std::__cxx_atomic_init(std::addressof(__o->__a_), __d);
 }
 
 template <class _Tp>
-_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI
-void
-atomic_init(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
-{
-    std::__cxx_atomic_init(std::addressof(__o->__a_), __d);
+_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI void
+atomic_init(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT {
+  std::__cxx_atomic_init(std::addressof(__o->__a_), __d);
 }
 
 // atomic_store
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void
-atomic_store(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
-{
-    __o->store(__d);
+_LIBCPP_HIDE_FROM_ABI void atomic_store(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT {
+  __o->store(__d);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void
-atomic_store(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
-{
-    __o->store(__d);
+_LIBCPP_HIDE_FROM_ABI void atomic_store(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT {
+  __o->store(__d);
 }
 
 // atomic_store_explicit
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void
+_LIBCPP_HIDE_FROM_ABI void
 atomic_store_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, memory_order __m) _NOEXCEPT
-  _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
-{
-    __o->store(__d, __m);
+    _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
+  __o->store(__d, __m);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void
+_LIBCPP_HIDE_FROM_ABI void
 atomic_store_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, memory_order __m) _NOEXCEPT
-  _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)
-{
-    __o->store(__d, __m);
+    _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
+  __o->store(__d, __m);
 }
 
 // atomic_load
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-atomic_load(const volatile atomic<_Tp>* __o) _NOEXCEPT
-{
-    return __o->load();
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_load(const volatile atomic<_Tp>* __o) _NOEXCEPT {
+  return __o->load();
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-atomic_load(const atomic<_Tp>* __o) _NOEXCEPT
-{
-    return __o->load();
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_load(const atomic<_Tp>* __o) _NOEXCEPT {
+  return __o->load();
 }
 
 // atomic_load_explicit
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-atomic_load_explicit(const volatile atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
-  _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
-{
-    return __o->load(__m);
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_load_explicit(const volatile atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
+    _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
+  return __o->load(__m);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-atomic_load_explicit(const atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
-  _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
-{
-    return __o->load(__m);
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_load_explicit(const atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
+    _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
+  return __o->load(__m);
 }
 
 // atomic_exchange
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-atomic_exchange(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
-{
-    return __o->exchange(__d);
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_exchange(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT {
+  return __o->exchange(__d);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-atomic_exchange(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT
-{
-    return __o->exchange(__d);
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_exchange(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d) _NOEXCEPT {
+  return __o->exchange(__d);
 }
 
 // atomic_exchange_explicit
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-atomic_exchange_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, memory_order __m) _NOEXCEPT
-{
-    return __o->exchange(__d, __m);
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_exchange_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, memory_order __m) _NOEXCEPT {
+  return __o->exchange(__d, __m);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-atomic_exchange_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, memory_order __m) _NOEXCEPT
-{
-    return __o->exchange(__d, __m);
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_exchange_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, memory_order __m) _NOEXCEPT {
+  return __o->exchange(__d, __m);
 }
 
 // atomic_compare_exchange_weak
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool
-atomic_compare_exchange_weak(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT
-{
-    return __o->compare_exchange_weak(*__e, __d);
+_LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_weak(
+    volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT {
+  return __o->compare_exchange_weak(*__e, __d);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool
-atomic_compare_exchange_weak(atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT
-{
-    return __o->compare_exchange_weak(*__e, __d);
+_LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_weak(
+    atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT {
+  return __o->compare_exchange_weak(*__e, __d);
 }
 
 // atomic_compare_exchange_strong
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool
-atomic_compare_exchange_strong(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT
-{
-    return __o->compare_exchange_strong(*__e, __d);
+_LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_strong(
+    volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT {
+  return __o->compare_exchange_strong(*__e, __d);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool
-atomic_compare_exchange_strong(atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT
-{
-    return __o->compare_exchange_strong(*__e, __d);
+_LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_strong(
+    atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d) _NOEXCEPT {
+  return __o->compare_exchange_strong(*__e, __d);
 }
 
 // atomic_compare_exchange_weak_explicit
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool
-atomic_compare_exchange_weak_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e,
-                                      typename atomic<_Tp>::value_type __d,
-                                      memory_order __s, memory_order __f) _NOEXCEPT
-  _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
-{
-    return __o->compare_exchange_weak(*__e, __d, __s, __f);
+_LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_weak_explicit(
+    volatile atomic<_Tp>* __o,
+    typename atomic<_Tp>::value_type* __e,
+    typename atomic<_Tp>::value_type __d,
+    memory_order __s,
+    memory_order __f) _NOEXCEPT _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
+  return __o->compare_exchange_weak(*__e, __d, __s, __f);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool
-atomic_compare_exchange_weak_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d,
-                                      memory_order __s, memory_order __f) _NOEXCEPT
-  _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
-{
-    return __o->compare_exchange_weak(*__e, __d, __s, __f);
+_LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_weak_explicit(
+    atomic<_Tp>* __o,
+    typename atomic<_Tp>::value_type* __e,
+    typename atomic<_Tp>::value_type __d,
+    memory_order __s,
+    memory_order __f) _NOEXCEPT _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
+  return __o->compare_exchange_weak(*__e, __d, __s, __f);
 }
 
 // atomic_compare_exchange_strong_explicit
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool
-atomic_compare_exchange_strong_explicit(volatile atomic<_Tp>* __o,
-                                        typename atomic<_Tp>::value_type* __e, typename atomic<_Tp>::value_type __d,
-                                        memory_order __s, memory_order __f) _NOEXCEPT
-  _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
-{
-    return __o->compare_exchange_strong(*__e, __d, __s, __f);
+_LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_strong_explicit(
+    volatile atomic<_Tp>* __o,
+    typename atomic<_Tp>::value_type* __e,
+    typename atomic<_Tp>::value_type __d,
+    memory_order __s,
+    memory_order __f) _NOEXCEPT _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
+  return __o->compare_exchange_strong(*__e, __d, __s, __f);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool
-atomic_compare_exchange_strong_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type* __e,
-                                        typename atomic<_Tp>::value_type __d,
-                                        memory_order __s, memory_order __f) _NOEXCEPT
-  _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f)
-{
-    return __o->compare_exchange_strong(*__e, __d, __s, __f);
+_LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_strong_explicit(
+    atomic<_Tp>* __o,
+    typename atomic<_Tp>::value_type* __e,
+    typename atomic<_Tp>::value_type __d,
+    memory_order __s,
+    memory_order __f) _NOEXCEPT _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
+  return __o->compare_exchange_strong(*__e, __d, __s, __f);
 }
 
 // atomic_wait
 
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-void atomic_wait(const volatile atomic<_Tp>* __o,
-                 typename atomic<_Tp>::value_type __v) _NOEXCEPT
-{
-    return __o->wait(__v);
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+atomic_wait(const volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __v) _NOEXCEPT {
+  return __o->wait(__v);
 }
 
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-void atomic_wait(const atomic<_Tp>* __o,
-                 typename atomic<_Tp>::value_type __v) _NOEXCEPT
-{
-    return __o->wait(__v);
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+atomic_wait(const atomic<_Tp>* __o, typename atomic<_Tp>::value_type __v) _NOEXCEPT {
+  return __o->wait(__v);
 }
 
 // atomic_wait_explicit
 
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-void atomic_wait_explicit(const volatile atomic<_Tp>* __o,
-                          typename atomic<_Tp>::value_type __v,
-                          memory_order __m) _NOEXCEPT
-  _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
-{
-    return __o->wait(__v, __m);
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+atomic_wait_explicit(const volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __v, memory_order __m) _NOEXCEPT
+    _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
+  return __o->wait(__v, __m);
 }
 
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-void atomic_wait_explicit(const atomic<_Tp>* __o,
-                          typename atomic<_Tp>::value_type __v,
-                          memory_order __m) _NOEXCEPT
-  _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)
-{
-    return __o->wait(__v, __m);
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+atomic_wait_explicit(const atomic<_Tp>* __o, typename atomic<_Tp>::value_type __v, memory_order __m) _NOEXCEPT
+    _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
+  return __o->wait(__v, __m);
 }
 
 // atomic_notify_one
 
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-void atomic_notify_one(volatile atomic<_Tp>* __o) _NOEXCEPT
-{
-    __o->notify_one();
+_LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+atomic_notify_one(volatile atomic<_Tp>* __o) _NOEXCEPT {
+  __o->notify_one();
 }
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-void atomic_notify_one(atomic<_Tp>* __o) _NOEXCEPT
-{
-    __o->notify_one();
+_LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+atomic_notify_one(atomic<_Tp>* __o) _NOEXCEPT {
+  __o->notify_one();
 }
 
 // atomic_notify_all
 
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-void atomic_notify_all(volatile atomic<_Tp>* __o) _NOEXCEPT
-{
-    __o->notify_all();
+_LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+atomic_notify_all(volatile atomic<_Tp>* __o) _NOEXCEPT {
+  __o->notify_all();
 }
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-void atomic_notify_all(atomic<_Tp>* __o) _NOEXCEPT
-{
-    __o->notify_all();
+_LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+atomic_notify_all(atomic<_Tp>* __o) _NOEXCEPT {
+  __o->notify_all();
 }
 
 // atomic_fetch_add
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-atomic_fetch_add(volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT
-{
-    return __o->fetch_add(__op);
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_fetch_add(volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT {
+  return __o->fetch_add(__op);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-atomic_fetch_add(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT
-{
-    return __o->fetch_add(__op);
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_add(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT {
+  return __o->fetch_add(__op);
 }
 
 // atomic_fetch_add_explicit
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp atomic_fetch_add_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_add(__op, __m);
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_add_explicit(
+    volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT {
+  return __o->fetch_add(__op, __m);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp atomic_fetch_add_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_add(__op, __m);
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_fetch_add_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT {
+  return __o->fetch_add(__op, __m);
 }
 
 // atomic_fetch_sub
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp atomic_fetch_sub(volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT
-{
-    return __o->fetch_sub(__op);
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_fetch_sub(volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT {
+  return __o->fetch_sub(__op);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp atomic_fetch_sub(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT
-{
-    return __o->fetch_sub(__op);
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_sub(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op) _NOEXCEPT {
+  return __o->fetch_sub(__op);
 }
 
 // atomic_fetch_sub_explicit
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp atomic_fetch_sub_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_sub(__op, __m);
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_sub_explicit(
+    volatile atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT {
+  return __o->fetch_sub(__op, __m);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp atomic_fetch_sub_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_sub(__op, __m);
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_fetch_sub_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::difference_type __op, memory_order __m) _NOEXCEPT {
+  return __o->fetch_sub(__op, __m);
 }
 
 // atomic_fetch_and
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_and(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
-{
-    return __o->fetch_and(__op);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_and(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
+  return __o->fetch_and(__op);
 }
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_and(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
-{
-    return __o->fetch_and(__op);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_and(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
+  return __o->fetch_and(__op);
 }
 
 // atomic_fetch_and_explicit
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_and_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_and(__op, __m);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_and_explicit(
+    volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
+  return __o->fetch_and(__op, __m);
 }
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_and_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_and(__op, __m);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_fetch_and_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
+  return __o->fetch_and(__op, __m);
 }
 
 // atomic_fetch_or
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_or(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
-{
-    return __o->fetch_or(__op);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_or(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
+  return __o->fetch_or(__op);
 }
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_or(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
-{
-    return __o->fetch_or(__op);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_or(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
+  return __o->fetch_or(__op);
 }
 
 // atomic_fetch_or_explicit
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_or_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_or(__op, __m);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_fetch_or_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
+  return __o->fetch_or(__op, __m);
 }
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_or_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_or(__op, __m);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_fetch_or_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
+  return __o->fetch_or(__op, __m);
 }
 
 // atomic_fetch_xor
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_xor(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
-{
-    return __o->fetch_xor(__op);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_xor(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
+  return __o->fetch_xor(__op);
 }
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_xor(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT
-{
-    return __o->fetch_xor(__op);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_xor(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op) _NOEXCEPT {
+  return __o->fetch_xor(__op);
 }
 
 // atomic_fetch_xor_explicit
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_xor_explicit(volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_xor(__op, __m);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp atomic_fetch_xor_explicit(
+    volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
+  return __o->fetch_xor(__op, __m);
 }
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if
-<
-    is_integral<_Tp>::value && !is_same<_Tp, bool>::value,
-    _Tp
->::type
-atomic_fetch_xor_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT
-{
-    return __o->fetch_xor(__op, __m);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value && !is_same<_Tp, bool>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp
+atomic_fetch_xor_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __op, memory_order __m) _NOEXCEPT {
+  return __o->fetch_xor(__op, __m);
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__atomic/atomic_base.h b/third_party/libcxx/__atomic/atomic_base.h
index 87100ba5d..7e26434c9 100644
--- a/third_party/libcxx/__atomic/atomic_base.h
+++ b/third_party/libcxx/__atomic/atomic_base.h
@@ -14,11 +14,10 @@
 #include <__atomic/cxx_atomic_impl.h>
 #include <__atomic/is_always_lock_free.h>
 #include <__atomic/memory_order.h>
-#include <__availability>
 #include <__config>
 #include <__memory/addressof.h>
 #include <__type_traits/is_integral.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_same.h>
 #include <version>
 
@@ -29,202 +28,192 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, bool = is_integral<_Tp>::value && !is_same<_Tp, bool>::value>
-struct __atomic_base  // false
+struct __atomic_base // false
 {
-    mutable __cxx_atomic_impl<_Tp> __a_;
+  mutable __cxx_atomic_impl<_Tp> __a_;
 
 #if _LIBCPP_STD_VER >= 17
-  static _LIBCPP_CONSTEXPR bool is_always_lock_free = __libcpp_is_always_lock_free<__cxx_atomic_impl<_Tp> >::__value;
+  static constexpr bool is_always_lock_free = __libcpp_is_always_lock_free<__cxx_atomic_impl<_Tp> >::__value;
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI
-    bool is_lock_free() const volatile _NOEXCEPT
-        {return __cxx_atomic_is_lock_free(sizeof(_Tp));}
-    _LIBCPP_HIDE_FROM_ABI
-    bool is_lock_free() const _NOEXCEPT
-        {return static_cast<__atomic_base const volatile*>(this)->is_lock_free();}
-    _LIBCPP_HIDE_FROM_ABI void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
-      std::__cxx_atomic_store(std::addressof(__a_), __d, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI void store(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
-      std::__cxx_atomic_store(std::addressof(__a_), __d, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
-        _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
-      return std::__cxx_atomic_load(std::addressof(__a_), __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
-        _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
-      return std::__cxx_atomic_load(std::addressof(__a_), __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI
-    operator _Tp() const volatile _NOEXCEPT {return load();}
-    _LIBCPP_HIDE_FROM_ABI
-    operator _Tp() const _NOEXCEPT          {return load();}
-    _LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
-      return std::__cxx_atomic_exchange(std::addressof(__a_), __d, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
-      return std::__cxx_atomic_exchange(std::addressof(__a_), __d, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI bool
-    compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) volatile _NOEXCEPT
-        _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
-      return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
-    }
-    _LIBCPP_HIDE_FROM_ABI bool compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) _NOEXCEPT
-        _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
-      return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
-    }
-    _LIBCPP_HIDE_FROM_ABI bool
-    compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) volatile _NOEXCEPT
-        _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
-      return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
-    }
-    _LIBCPP_HIDE_FROM_ABI bool compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) _NOEXCEPT
-        _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
-      return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
-    }
-    _LIBCPP_HIDE_FROM_ABI bool
-    compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
-      return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI bool
-    compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
-      return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI bool
-    compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
-      return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI bool
-    compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
-      return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
-    }
+  _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const volatile _NOEXCEPT {
+    return __cxx_atomic_is_lock_free(sizeof(__cxx_atomic_impl<_Tp>));
+  }
+  _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const _NOEXCEPT {
+    return static_cast<__atomic_base const volatile*>(this)->is_lock_free();
+  }
+  _LIBCPP_HIDE_FROM_ABI void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
+      _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
+    std::__cxx_atomic_store(std::addressof(__a_), __d, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI void store(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT
+      _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
+    std::__cxx_atomic_store(std::addressof(__a_), __d, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
+      _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
+    return std::__cxx_atomic_load(std::addressof(__a_), __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
+      _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
+    return std::__cxx_atomic_load(std::addressof(__a_), __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI operator _Tp() const volatile _NOEXCEPT { return load(); }
+  _LIBCPP_HIDE_FROM_ABI operator _Tp() const _NOEXCEPT { return load(); }
+  _LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    return std::__cxx_atomic_exchange(std::addressof(__a_), __d, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    return std::__cxx_atomic_exchange(std::addressof(__a_), __d, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool
+  compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) volatile _NOEXCEPT
+      _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
+    return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) _NOEXCEPT
+      _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
+    return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool
+  compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) volatile _NOEXCEPT
+      _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
+    return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __s, memory_order __f) _NOEXCEPT
+      _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__s, __f) {
+    return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __s, __f);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool
+  compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool
+  compare_exchange_weak(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    return std::__cxx_atomic_compare_exchange_weak(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool
+  compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool
+  compare_exchange_strong(_Tp& __e, _Tp __d, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    return std::__cxx_atomic_compare_exchange_strong(std::addressof(__a_), std::addressof(__e), __d, __m, __m);
+  }
 
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const
-        volatile _NOEXCEPT {
-      std::__cxx_atomic_wait(std::addressof(__a_), __v, __m);
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
-    wait(_Tp __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT {
-      std::__cxx_atomic_wait(std::addressof(__a_), __v, __m);
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() volatile _NOEXCEPT {
-      std::__cxx_atomic_notify_one(std::addressof(__a_));
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT {
-      std::__cxx_atomic_notify_one(std::addressof(__a_));
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() volatile _NOEXCEPT {
-      std::__cxx_atomic_notify_all(std::addressof(__a_));
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT {
-      std::__cxx_atomic_notify_all(std::addressof(__a_));
-    }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const
+      volatile _NOEXCEPT {
+    std::__atomic_wait(*this, __v, __m);
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+  wait(_Tp __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT {
+    std::__atomic_wait(*this, __v, __m);
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() volatile _NOEXCEPT {
+    std::__atomic_notify_one(*this);
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT { std::__atomic_notify_one(*this); }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() volatile _NOEXCEPT {
+    std::__atomic_notify_all(*this);
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT { std::__atomic_notify_all(*this); }
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    __atomic_base() noexcept(is_nothrow_default_constructible_v<_Tp>) : __a_(_Tp()) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr __atomic_base() noexcept(is_nothrow_default_constructible_v<_Tp>) : __a_(_Tp()) {}
 #else
-    _LIBCPP_HIDE_FROM_ABI
-    __atomic_base() _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI __atomic_base() _NOEXCEPT = default;
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-    __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __a_(__d) {}
 
-    __atomic_base(const __atomic_base&) = delete;
+  __atomic_base(const __atomic_base&) = delete;
 };
 
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp, bool __b>
-_LIBCPP_CONSTEXPR bool __atomic_base<_Tp, __b>::is_always_lock_free;
-#endif
-
 // atomic<Integral>
 
 template <class _Tp>
-struct __atomic_base<_Tp, true>
-    : public __atomic_base<_Tp, false>
-{
-    using __base = __atomic_base<_Tp, false>;
+struct __atomic_base<_Tp, true> : public __atomic_base<_Tp, false> {
+  using __base = __atomic_base<_Tp, false>;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    __atomic_base() _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __atomic_base() _NOEXCEPT = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __atomic_base(_Tp __d) _NOEXCEPT : __base(__d) {}
 
-    _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
-      return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
-      return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
-      return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
-      return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
-      return std::__cxx_atomic_fetch_and(std::addressof(this->__a_), __op, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
-      return std::__cxx_atomic_fetch_and(std::addressof(this->__a_), __op, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
-      return std::__cxx_atomic_fetch_or(std::addressof(this->__a_), __op, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
-      return std::__cxx_atomic_fetch_or(std::addressof(this->__a_), __op, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
-      return std::__cxx_atomic_fetch_xor(std::addressof(this->__a_), __op, __m);
-    }
-    _LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
-      return std::__cxx_atomic_fetch_xor(std::addressof(this->__a_), __op, __m);
-    }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    return std::__cxx_atomic_fetch_add(std::addressof(this->__a_), __op, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    return std::__cxx_atomic_fetch_sub(std::addressof(this->__a_), __op, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    return std::__cxx_atomic_fetch_and(std::addressof(this->__a_), __op, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    return std::__cxx_atomic_fetch_and(std::addressof(this->__a_), __op, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    return std::__cxx_atomic_fetch_or(std::addressof(this->__a_), __op, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    return std::__cxx_atomic_fetch_or(std::addressof(this->__a_), __op, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    return std::__cxx_atomic_fetch_xor(std::addressof(this->__a_), __op, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __op, memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    return std::__cxx_atomic_fetch_xor(std::addressof(this->__a_), __op, __m);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator++(int) volatile _NOEXCEPT      {return fetch_add(_Tp(1));}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator++(int) _NOEXCEPT               {return fetch_add(_Tp(1));}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator--(int) volatile _NOEXCEPT      {return fetch_sub(_Tp(1));}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator--(int) _NOEXCEPT               {return fetch_sub(_Tp(1));}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator++() volatile _NOEXCEPT         {return fetch_add(_Tp(1)) + _Tp(1);}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator++() _NOEXCEPT                  {return fetch_add(_Tp(1)) + _Tp(1);}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator--() volatile _NOEXCEPT         {return fetch_sub(_Tp(1)) - _Tp(1);}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator--() _NOEXCEPT                  {return fetch_sub(_Tp(1)) - _Tp(1);}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator+=(_Tp __op) volatile _NOEXCEPT {return fetch_add(__op) + __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator+=(_Tp __op) _NOEXCEPT          {return fetch_add(__op) + __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator-=(_Tp __op) volatile _NOEXCEPT {return fetch_sub(__op) - __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator-=(_Tp __op) _NOEXCEPT          {return fetch_sub(__op) - __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator&=(_Tp __op) volatile _NOEXCEPT {return fetch_and(__op) & __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator&=(_Tp __op) _NOEXCEPT          {return fetch_and(__op) & __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator|=(_Tp __op) volatile _NOEXCEPT {return fetch_or(__op) | __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator|=(_Tp __op) _NOEXCEPT          {return fetch_or(__op) | __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator^=(_Tp __op) volatile _NOEXCEPT {return fetch_xor(__op) ^ __op;}
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp operator^=(_Tp __op) _NOEXCEPT          {return fetch_xor(__op) ^ __op;}
+  _LIBCPP_HIDE_FROM_ABI _Tp operator++(int) volatile _NOEXCEPT { return fetch_add(_Tp(1)); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator++(int) _NOEXCEPT { return fetch_add(_Tp(1)); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator--(int) volatile _NOEXCEPT { return fetch_sub(_Tp(1)); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator--(int) _NOEXCEPT { return fetch_sub(_Tp(1)); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator++() volatile _NOEXCEPT { return fetch_add(_Tp(1)) + _Tp(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator++() _NOEXCEPT { return fetch_add(_Tp(1)) + _Tp(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator--() volatile _NOEXCEPT { return fetch_sub(_Tp(1)) - _Tp(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator--() _NOEXCEPT { return fetch_sub(_Tp(1)) - _Tp(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __op) volatile _NOEXCEPT { return fetch_add(__op) + __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __op) _NOEXCEPT { return fetch_add(__op) + __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __op) volatile _NOEXCEPT { return fetch_sub(__op) - __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __op) _NOEXCEPT { return fetch_sub(__op) - __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator&=(_Tp __op) volatile _NOEXCEPT { return fetch_and(__op) & __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator&=(_Tp __op) _NOEXCEPT { return fetch_and(__op) & __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator|=(_Tp __op) volatile _NOEXCEPT { return fetch_or(__op) | __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator|=(_Tp __op) _NOEXCEPT { return fetch_or(__op) | __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator^=(_Tp __op) volatile _NOEXCEPT { return fetch_xor(__op) ^ __op; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator^=(_Tp __op) _NOEXCEPT { return fetch_xor(__op) ^ __op; }
+};
+
+// Here we need _IsIntegral because the default template argument is not enough
+// e.g  __atomic_base<int> is __atomic_base<int, true>, which inherits from
+// __atomic_base<int, false> and the caller of the wait function is
+// __atomic_base<int, false>. So specializing __atomic_base<_Tp> does not work
+template <class _Tp, bool _IsIntegral>
+struct __atomic_waitable_traits<__atomic_base<_Tp, _IsIntegral> > {
+  static _LIBCPP_HIDE_FROM_ABI _Tp __atomic_load(const __atomic_base<_Tp, _IsIntegral>& __a, memory_order __order) {
+    return __a.load(__order);
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI _Tp
+  __atomic_load(const volatile __atomic_base<_Tp, _IsIntegral>& __this, memory_order __order) {
+    return __this.load(__order);
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI const __cxx_atomic_impl<_Tp>*
+  __atomic_contention_address(const __atomic_base<_Tp, _IsIntegral>& __a) {
+    return std::addressof(__a.__a_);
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI const volatile __cxx_atomic_impl<_Tp>*
+  __atomic_contention_address(const volatile __atomic_base<_Tp, _IsIntegral>& __this) {
+    return std::addressof(__this.__a_);
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__atomic/atomic_flag.h b/third_party/libcxx/__atomic/atomic_flag.h
index edfa978f9..00b157cdf 100644
--- a/third_party/libcxx/__atomic/atomic_flag.h
+++ b/third_party/libcxx/__atomic/atomic_flag.h
@@ -15,7 +15,8 @@
 #include <__atomic/memory_order.h>
 #include <__chrono/duration.h>
 #include <__config>
-#include <__threading_support>
+#include <__memory/addressof.h>
+#include <__thread/support.h>
 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -24,205 +25,163 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct atomic_flag
-{
-    __cxx_atomic_impl<_LIBCPP_ATOMIC_FLAG_TYPE> __a_;
+struct atomic_flag {
+  __cxx_atomic_impl<_LIBCPP_ATOMIC_FLAG_TYPE> __a_;
 
-    _LIBCPP_HIDE_FROM_ABI
-    bool test(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
-        {return _LIBCPP_ATOMIC_FLAG_TYPE(true) == __cxx_atomic_load(&__a_, __m);}
-    _LIBCPP_HIDE_FROM_ABI
-    bool test(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
-        {return _LIBCPP_ATOMIC_FLAG_TYPE(true) == __cxx_atomic_load(&__a_, __m);}
+  _LIBCPP_HIDE_FROM_ABI bool test(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT {
+    return _LIBCPP_ATOMIC_FLAG_TYPE(true) == __cxx_atomic_load(&__a_, __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool test(memory_order __m = memory_order_seq_cst) const _NOEXCEPT {
+    return _LIBCPP_ATOMIC_FLAG_TYPE(true) == __cxx_atomic_load(&__a_, __m);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    bool test_and_set(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        {return __cxx_atomic_exchange(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(true), __m);}
-    _LIBCPP_HIDE_FROM_ABI
-    bool test_and_set(memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        {return __cxx_atomic_exchange(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(true), __m);}
-    _LIBCPP_HIDE_FROM_ABI
-    void clear(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
-        {__cxx_atomic_store(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(false), __m);}
-    _LIBCPP_HIDE_FROM_ABI
-    void clear(memory_order __m = memory_order_seq_cst) _NOEXCEPT
-        {__cxx_atomic_store(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(false), __m);}
+  _LIBCPP_HIDE_FROM_ABI bool test_and_set(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    return __cxx_atomic_exchange(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(true), __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool test_and_set(memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    return __cxx_atomic_exchange(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(true), __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI void clear(memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT {
+    __cxx_atomic_store(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(false), __m);
+  }
+  _LIBCPP_HIDE_FROM_ABI void clear(memory_order __m = memory_order_seq_cst) _NOEXCEPT {
+    __cxx_atomic_store(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(false), __m);
+  }
 
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-    void wait(bool __v, memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
-        {__cxx_atomic_wait(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(__v), __m);}
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-    void wait(bool __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT
-        {__cxx_atomic_wait(&__a_, _LIBCPP_ATOMIC_FLAG_TYPE(__v), __m);}
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-    void notify_one() volatile _NOEXCEPT
-        {__cxx_atomic_notify_one(&__a_);}
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-    void notify_one() _NOEXCEPT
-        {__cxx_atomic_notify_one(&__a_);}
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-    void notify_all() volatile _NOEXCEPT
-        {__cxx_atomic_notify_all(&__a_);}
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-    void notify_all() _NOEXCEPT
-        {__cxx_atomic_notify_all(&__a_);}
+  _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+  wait(bool __v, memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT {
+    std::__atomic_wait(*this, _LIBCPP_ATOMIC_FLAG_TYPE(__v), __m);
+  }
+  _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+  wait(bool __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT {
+    std::__atomic_wait(*this, _LIBCPP_ATOMIC_FLAG_TYPE(__v), __m);
+  }
+  _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() volatile _NOEXCEPT {
+    std::__atomic_notify_one(*this);
+  }
+  _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT {
+    std::__atomic_notify_one(*this);
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() volatile _NOEXCEPT {
+    std::__atomic_notify_all(*this);
+  }
+  _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT {
+    std::__atomic_notify_all(*this);
+  }
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    atomic_flag() _NOEXCEPT : __a_(false) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr atomic_flag() _NOEXCEPT : __a_(false) {}
 #else
-    atomic_flag() _NOEXCEPT = default;
+  atomic_flag() _NOEXCEPT = default;
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-    atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} // EXTENSION
-
-    atomic_flag(const atomic_flag&) = delete;
-    atomic_flag& operator=(const atomic_flag&) = delete;
-    atomic_flag& operator=(const atomic_flag&) volatile = delete;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR atomic_flag(bool __b) _NOEXCEPT : __a_(__b) {} // EXTENSION
 
+  atomic_flag(const atomic_flag&)                     = delete;
+  atomic_flag& operator=(const atomic_flag&)          = delete;
+  atomic_flag& operator=(const atomic_flag&) volatile = delete;
 };
 
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-atomic_flag_test(const volatile atomic_flag* __o) _NOEXCEPT
-{
-    return __o->test();
+template <>
+struct __atomic_waitable_traits<atomic_flag> {
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_ATOMIC_FLAG_TYPE __atomic_load(const atomic_flag& __a, memory_order __order) {
+    return std::__cxx_atomic_load(&__a.__a_, __order);
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_ATOMIC_FLAG_TYPE
+  __atomic_load(const volatile atomic_flag& __a, memory_order __order) {
+    return std::__cxx_atomic_load(&__a.__a_, __order);
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI const __cxx_atomic_impl<_LIBCPP_ATOMIC_FLAG_TYPE>*
+  __atomic_contention_address(const atomic_flag& __a) {
+    return std::addressof(__a.__a_);
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI const volatile __cxx_atomic_impl<_LIBCPP_ATOMIC_FLAG_TYPE>*
+  __atomic_contention_address(const volatile atomic_flag& __a) {
+    return std::addressof(__a.__a_);
+  }
+};
+
+inline _LIBCPP_HIDE_FROM_ABI bool atomic_flag_test(const volatile atomic_flag* __o) _NOEXCEPT { return __o->test(); }
+
+inline _LIBCPP_HIDE_FROM_ABI bool atomic_flag_test(const atomic_flag* __o) _NOEXCEPT { return __o->test(); }
+
+inline _LIBCPP_HIDE_FROM_ABI bool
+atomic_flag_test_explicit(const volatile atomic_flag* __o, memory_order __m) _NOEXCEPT {
+  return __o->test(__m);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-atomic_flag_test(const atomic_flag* __o) _NOEXCEPT
-{
-    return __o->test();
+inline _LIBCPP_HIDE_FROM_ABI bool atomic_flag_test_explicit(const atomic_flag* __o, memory_order __m) _NOEXCEPT {
+  return __o->test(__m);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-atomic_flag_test_explicit(const volatile atomic_flag* __o, memory_order __m) _NOEXCEPT
-{
-    return __o->test(__m);
+inline _LIBCPP_HIDE_FROM_ABI bool atomic_flag_test_and_set(volatile atomic_flag* __o) _NOEXCEPT {
+  return __o->test_and_set();
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-atomic_flag_test_explicit(const atomic_flag* __o, memory_order __m) _NOEXCEPT
-{
-    return __o->test(__m);
+inline _LIBCPP_HIDE_FROM_ABI bool atomic_flag_test_and_set(atomic_flag* __o) _NOEXCEPT { return __o->test_and_set(); }
+
+inline _LIBCPP_HIDE_FROM_ABI bool
+atomic_flag_test_and_set_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEPT {
+  return __o->test_and_set(__m);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-atomic_flag_test_and_set(volatile atomic_flag* __o) _NOEXCEPT
-{
-    return __o->test_and_set();
+inline _LIBCPP_HIDE_FROM_ABI bool atomic_flag_test_and_set_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT {
+  return __o->test_and_set(__m);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-atomic_flag_test_and_set(atomic_flag* __o) _NOEXCEPT
-{
-    return __o->test_and_set();
+inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_clear(volatile atomic_flag* __o) _NOEXCEPT { __o->clear(); }
+
+inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_clear(atomic_flag* __o) _NOEXCEPT { __o->clear(); }
+
+inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_clear_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEPT {
+  __o->clear(__m);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-atomic_flag_test_and_set_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEPT
-{
-    return __o->test_and_set(__m);
+inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_clear_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT {
+  __o->clear(__m);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-atomic_flag_test_and_set_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT
-{
-    return __o->test_and_set(__m);
+inline _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+atomic_flag_wait(const volatile atomic_flag* __o, bool __v) _NOEXCEPT {
+  __o->wait(__v);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-void
-atomic_flag_clear(volatile atomic_flag* __o) _NOEXCEPT
-{
-    __o->clear();
+inline _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+atomic_flag_wait(const atomic_flag* __o, bool __v) _NOEXCEPT {
+  __o->wait(__v);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-void
-atomic_flag_clear(atomic_flag* __o) _NOEXCEPT
-{
-    __o->clear();
+inline _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+atomic_flag_wait_explicit(const volatile atomic_flag* __o, bool __v, memory_order __m) _NOEXCEPT {
+  __o->wait(__v, __m);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-void
-atomic_flag_clear_explicit(volatile atomic_flag* __o, memory_order __m) _NOEXCEPT
-{
-    __o->clear(__m);
+inline _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+atomic_flag_wait_explicit(const atomic_flag* __o, bool __v, memory_order __m) _NOEXCEPT {
+  __o->wait(__v, __m);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-void
-atomic_flag_clear_explicit(atomic_flag* __o, memory_order __m) _NOEXCEPT
-{
-    __o->clear(__m);
+inline _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+atomic_flag_notify_one(volatile atomic_flag* __o) _NOEXCEPT {
+  __o->notify_one();
 }
 
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC
-void
-atomic_flag_wait(const volatile atomic_flag* __o, bool __v) _NOEXCEPT
-{
-    __o->wait(__v);
+inline _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+atomic_flag_notify_one(atomic_flag* __o) _NOEXCEPT {
+  __o->notify_one();
 }
 
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC
-void
-atomic_flag_wait(const atomic_flag* __o, bool __v) _NOEXCEPT
-{
-    __o->wait(__v);
+inline _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+atomic_flag_notify_all(volatile atomic_flag* __o) _NOEXCEPT {
+  __o->notify_all();
 }
 
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC
-void
-atomic_flag_wait_explicit(const volatile atomic_flag* __o,
-                          bool __v, memory_order __m) _NOEXCEPT
-{
-    __o->wait(__v, __m);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC
-void
-atomic_flag_wait_explicit(const atomic_flag* __o,
-                          bool __v, memory_order __m) _NOEXCEPT
-{
-    __o->wait(__v, __m);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC
-void
-atomic_flag_notify_one(volatile atomic_flag* __o) _NOEXCEPT
-{
-    __o->notify_one();
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC
-void
-atomic_flag_notify_one(atomic_flag* __o) _NOEXCEPT
-{
-    __o->notify_one();
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC
-void
-atomic_flag_notify_all(volatile atomic_flag* __o) _NOEXCEPT
-{
-    __o->notify_all();
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC
-void
-atomic_flag_notify_all(atomic_flag* __o) _NOEXCEPT
-{
-    __o->notify_all();
+inline _LIBCPP_DEPRECATED_ATOMIC_SYNC _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+atomic_flag_notify_all(atomic_flag* __o) _NOEXCEPT {
+  __o->notify_all();
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__atomic/atomic_init.h b/third_party/libcxx/__atomic/atomic_init.h
index 14310aee1..8e86ba31b 100644
--- a/third_party/libcxx/__atomic/atomic_init.h
+++ b/third_party/libcxx/__atomic/atomic_init.h
@@ -18,10 +18,8 @@
 #define ATOMIC_FLAG_INIT {false}
 #define ATOMIC_VAR_INIT(__v) {__v}
 
-#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
-# if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 1400
+#if _LIBCPP_STD_VER >= 20 && defined(_LIBCPP_COMPILER_CLANG_BASED) && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
 #  pragma clang deprecated(ATOMIC_VAR_INIT)
-# endif
-#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
+#endif
 
 #endif // _LIBCPP___ATOMIC_ATOMIC_INIT_H
diff --git a/third_party/libcxx/__atomic/atomic_lock_free.h b/third_party/libcxx/__atomic/atomic_lock_free.h
index d607569ed..0715439db 100644
--- a/third_party/libcxx/__atomic/atomic_lock_free.h
+++ b/third_party/libcxx/__atomic/atomic_lock_free.h
@@ -16,33 +16,33 @@
 #endif
 
 #if defined(__CLANG_ATOMIC_BOOL_LOCK_FREE)
-# define ATOMIC_BOOL_LOCK_FREE      __CLANG_ATOMIC_BOOL_LOCK_FREE
-# define ATOMIC_CHAR_LOCK_FREE      __CLANG_ATOMIC_CHAR_LOCK_FREE
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-# define ATOMIC_CHAR8_T_LOCK_FREE   __CLANG_ATOMIC_CHAR8_T_LOCK_FREE
-#endif
-# define ATOMIC_CHAR16_T_LOCK_FREE  __CLANG_ATOMIC_CHAR16_T_LOCK_FREE
-# define ATOMIC_CHAR32_T_LOCK_FREE  __CLANG_ATOMIC_CHAR32_T_LOCK_FREE
-# define ATOMIC_WCHAR_T_LOCK_FREE   __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
-# define ATOMIC_SHORT_LOCK_FREE     __CLANG_ATOMIC_SHORT_LOCK_FREE
-# define ATOMIC_INT_LOCK_FREE       __CLANG_ATOMIC_INT_LOCK_FREE
-# define ATOMIC_LONG_LOCK_FREE      __CLANG_ATOMIC_LONG_LOCK_FREE
-# define ATOMIC_LLONG_LOCK_FREE     __CLANG_ATOMIC_LLONG_LOCK_FREE
-# define ATOMIC_POINTER_LOCK_FREE   __CLANG_ATOMIC_POINTER_LOCK_FREE
+#  define ATOMIC_BOOL_LOCK_FREE __CLANG_ATOMIC_BOOL_LOCK_FREE
+#  define ATOMIC_CHAR_LOCK_FREE __CLANG_ATOMIC_CHAR_LOCK_FREE
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
+#    define ATOMIC_CHAR8_T_LOCK_FREE __CLANG_ATOMIC_CHAR8_T_LOCK_FREE
+#  endif
+#  define ATOMIC_CHAR16_T_LOCK_FREE __CLANG_ATOMIC_CHAR16_T_LOCK_FREE
+#  define ATOMIC_CHAR32_T_LOCK_FREE __CLANG_ATOMIC_CHAR32_T_LOCK_FREE
+#  define ATOMIC_WCHAR_T_LOCK_FREE __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
+#  define ATOMIC_SHORT_LOCK_FREE __CLANG_ATOMIC_SHORT_LOCK_FREE
+#  define ATOMIC_INT_LOCK_FREE __CLANG_ATOMIC_INT_LOCK_FREE
+#  define ATOMIC_LONG_LOCK_FREE __CLANG_ATOMIC_LONG_LOCK_FREE
+#  define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE
+#  define ATOMIC_POINTER_LOCK_FREE __CLANG_ATOMIC_POINTER_LOCK_FREE
 #elif defined(__GCC_ATOMIC_BOOL_LOCK_FREE)
-# define ATOMIC_BOOL_LOCK_FREE      __GCC_ATOMIC_BOOL_LOCK_FREE
-# define ATOMIC_CHAR_LOCK_FREE      __GCC_ATOMIC_CHAR_LOCK_FREE
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-# define ATOMIC_CHAR8_T_LOCK_FREE   __GCC_ATOMIC_CHAR8_T_LOCK_FREE
-#endif
-# define ATOMIC_CHAR16_T_LOCK_FREE  __GCC_ATOMIC_CHAR16_T_LOCK_FREE
-# define ATOMIC_CHAR32_T_LOCK_FREE  __GCC_ATOMIC_CHAR32_T_LOCK_FREE
-# define ATOMIC_WCHAR_T_LOCK_FREE   __GCC_ATOMIC_WCHAR_T_LOCK_FREE
-# define ATOMIC_SHORT_LOCK_FREE     __GCC_ATOMIC_SHORT_LOCK_FREE
-# define ATOMIC_INT_LOCK_FREE       __GCC_ATOMIC_INT_LOCK_FREE
-# define ATOMIC_LONG_LOCK_FREE      __GCC_ATOMIC_LONG_LOCK_FREE
-# define ATOMIC_LLONG_LOCK_FREE     __GCC_ATOMIC_LLONG_LOCK_FREE
-# define ATOMIC_POINTER_LOCK_FREE   __GCC_ATOMIC_POINTER_LOCK_FREE
+#  define ATOMIC_BOOL_LOCK_FREE __GCC_ATOMIC_BOOL_LOCK_FREE
+#  define ATOMIC_CHAR_LOCK_FREE __GCC_ATOMIC_CHAR_LOCK_FREE
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
+#    define ATOMIC_CHAR8_T_LOCK_FREE __GCC_ATOMIC_CHAR8_T_LOCK_FREE
+#  endif
+#  define ATOMIC_CHAR16_T_LOCK_FREE __GCC_ATOMIC_CHAR16_T_LOCK_FREE
+#  define ATOMIC_CHAR32_T_LOCK_FREE __GCC_ATOMIC_CHAR32_T_LOCK_FREE
+#  define ATOMIC_WCHAR_T_LOCK_FREE __GCC_ATOMIC_WCHAR_T_LOCK_FREE
+#  define ATOMIC_SHORT_LOCK_FREE __GCC_ATOMIC_SHORT_LOCK_FREE
+#  define ATOMIC_INT_LOCK_FREE __GCC_ATOMIC_INT_LOCK_FREE
+#  define ATOMIC_LONG_LOCK_FREE __GCC_ATOMIC_LONG_LOCK_FREE
+#  define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
+#  define ATOMIC_POINTER_LOCK_FREE __GCC_ATOMIC_POINTER_LOCK_FREE
 #endif
 
 #endif // _LIBCPP___ATOMIC_ATOMIC_LOCK_FREE_H
diff --git a/third_party/libcxx/__atomic/atomic_ref.h b/third_party/libcxx/__atomic/atomic_ref.h
new file mode 100644
index 000000000..156f19611
--- /dev/null
+++ b/third_party/libcxx/__atomic/atomic_ref.h
@@ -0,0 +1,360 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ATOMIC_ATOMIC_REF_H
+#define _LIBCPP___ATOMIC_ATOMIC_REF_H
+
+#include <__assert>
+#include <__atomic/atomic_sync.h>
+#include <__atomic/check_memory_order.h>
+#include <__atomic/to_gcc_order.h>
+#include <__concepts/arithmetic.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__memory/addressof.h>
+#include <__type_traits/has_unique_object_representation.h>
+#include <__type_traits/is_trivially_copyable.h>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp>
+struct __atomic_ref_base {
+protected:
+  _Tp* __ptr_;
+
+  _LIBCPP_HIDE_FROM_ABI __atomic_ref_base(_Tp& __obj) : __ptr_(std::addressof(__obj)) {}
+
+private:
+  _LIBCPP_HIDE_FROM_ABI static _Tp* __clear_padding(_Tp& __val) noexcept {
+    _Tp* __ptr = std::addressof(__val);
+#  if __has_builtin(__builtin_clear_padding)
+    __builtin_clear_padding(__ptr);
+#  endif
+    return __ptr;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static bool __compare_exchange(
+      _Tp* __ptr, _Tp* __expected, _Tp* __desired, bool __is_weak, int __success, int __failure) noexcept {
+    if constexpr (
+#  if __has_builtin(__builtin_clear_padding)
+        has_unique_object_representations_v<_Tp> || floating_point<_Tp>
+#  else
+        true // NOLINT(readability-simplify-boolean-expr)
+#  endif
+    ) {
+      return __atomic_compare_exchange(__ptr, __expected, __desired, __is_weak, __success, __failure);
+    } else { // _Tp has padding bits and __builtin_clear_padding is available
+      __clear_padding(*__desired);
+      _Tp __copy = *__expected;
+      __clear_padding(__copy);
+      // The algorithm we use here is basically to perform `__atomic_compare_exchange` on the
+      // values until it has either succeeded, or failed because the value representation of the
+      // objects involved was different. This is why we loop around __atomic_compare_exchange:
+      // we basically loop until its failure is caused by the value representation of the objects
+      // being different, not only their object representation.
+      while (true) {
+        _Tp __prev = __copy;
+        if (__atomic_compare_exchange(__ptr, std::addressof(__copy), __desired, __is_weak, __success, __failure)) {
+          return true;
+        }
+        _Tp __curr = __copy;
+        if (std::memcmp(__clear_padding(__prev), __clear_padding(__curr), sizeof(_Tp)) != 0) {
+          // Value representation without padding bits do not compare equal ->
+          // write the current content of *ptr into *expected
+          std::memcpy(__expected, std::addressof(__copy), sizeof(_Tp));
+          return false;
+        }
+      }
+    }
+  }
+
+  friend struct __atomic_waitable_traits<__atomic_ref_base<_Tp>>;
+
+public:
+  using value_type = _Tp;
+
+  static constexpr size_t required_alignment = alignof(_Tp);
+
+  // The __atomic_always_lock_free builtin takes into account the alignment of the pointer if provided,
+  // so we create a fake pointer with a suitable alignment when querying it. Note that we are guaranteed
+  // that the pointer is going to be aligned properly at runtime because that is a (checked) precondition
+  // of atomic_ref's constructor.
+  static constexpr bool is_always_lock_free =
+      __atomic_always_lock_free(sizeof(_Tp), reinterpret_cast<void*>(-required_alignment));
+
+  _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const noexcept { return __atomic_is_lock_free(sizeof(_Tp), __ptr_); }
+
+  _LIBCPP_HIDE_FROM_ABI void store(_Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept
+      _LIBCPP_CHECK_STORE_MEMORY_ORDER(__order) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __order == memory_order::relaxed || __order == memory_order::release || __order == memory_order::seq_cst,
+        "atomic_ref: memory order argument to atomic store operation is invalid");
+    __atomic_store(__ptr_, __clear_padding(__desired), std::__to_gcc_order(__order));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept {
+    store(__desired);
+    return __desired;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __order = memory_order::seq_cst) const noexcept
+      _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__order) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __order == memory_order::relaxed || __order == memory_order::consume || __order == memory_order::acquire ||
+            __order == memory_order::seq_cst,
+        "atomic_ref: memory order argument to atomic load operation is invalid");
+    alignas(_Tp) byte __mem[sizeof(_Tp)];
+    auto* __ret = reinterpret_cast<_Tp*>(__mem);
+    __atomic_load(__ptr_, __ret, std::__to_gcc_order(__order));
+    return *__ret;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI operator _Tp() const noexcept { return load(); }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp exchange(_Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept {
+    alignas(_Tp) byte __mem[sizeof(_Tp)];
+    auto* __ret = reinterpret_cast<_Tp*>(__mem);
+    __atomic_exchange(__ptr_, __clear_padding(__desired), __ret, std::__to_gcc_order(__order));
+    return *__ret;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool
+  compare_exchange_weak(_Tp& __expected, _Tp __desired, memory_order __success, memory_order __failure) const noexcept
+      _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__success, __failure) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __failure == memory_order::relaxed || __failure == memory_order::consume ||
+            __failure == memory_order::acquire || __failure == memory_order::seq_cst,
+        "atomic_ref: failure memory order argument to weak atomic compare-and-exchange operation is invalid");
+    return __compare_exchange(
+        __ptr_,
+        std::addressof(__expected),
+        std::addressof(__desired),
+        true,
+        std::__to_gcc_order(__success),
+        std::__to_gcc_order(__failure));
+  }
+  _LIBCPP_HIDE_FROM_ABI bool
+  compare_exchange_strong(_Tp& __expected, _Tp __desired, memory_order __success, memory_order __failure) const noexcept
+      _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__success, __failure) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __failure == memory_order::relaxed || __failure == memory_order::consume ||
+            __failure == memory_order::acquire || __failure == memory_order::seq_cst,
+        "atomic_ref: failure memory order argument to strong atomic compare-and-exchange operation is invalid");
+    return __compare_exchange(
+        __ptr_,
+        std::addressof(__expected),
+        std::addressof(__desired),
+        false,
+        std::__to_gcc_order(__success),
+        std::__to_gcc_order(__failure));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool
+  compare_exchange_weak(_Tp& __expected, _Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept {
+    return __compare_exchange(
+        __ptr_,
+        std::addressof(__expected),
+        std::addressof(__desired),
+        true,
+        std::__to_gcc_order(__order),
+        std::__to_gcc_failure_order(__order));
+  }
+  _LIBCPP_HIDE_FROM_ABI bool
+  compare_exchange_strong(_Tp& __expected, _Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept {
+    return __compare_exchange(
+        __ptr_,
+        std::addressof(__expected),
+        std::addressof(__desired),
+        false,
+        std::__to_gcc_order(__order),
+        std::__to_gcc_failure_order(__order));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void wait(_Tp __old, memory_order __order = memory_order::seq_cst) const noexcept
+      _LIBCPP_CHECK_WAIT_MEMORY_ORDER(__order) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __order == memory_order::relaxed || __order == memory_order::consume || __order == memory_order::acquire ||
+            __order == memory_order::seq_cst,
+        "atomic_ref: memory order argument to atomic wait operation is invalid");
+    std::__atomic_wait(*this, __old, __order);
+  }
+  _LIBCPP_HIDE_FROM_ABI void notify_one() const noexcept { std::__atomic_notify_one(*this); }
+  _LIBCPP_HIDE_FROM_ABI void notify_all() const noexcept { std::__atomic_notify_all(*this); }
+};
+
+template <class _Tp>
+struct __atomic_waitable_traits<__atomic_ref_base<_Tp>> {
+  static _LIBCPP_HIDE_FROM_ABI _Tp __atomic_load(const __atomic_ref_base<_Tp>& __a, memory_order __order) {
+    return __a.load(__order);
+  }
+  static _LIBCPP_HIDE_FROM_ABI const _Tp* __atomic_contention_address(const __atomic_ref_base<_Tp>& __a) {
+    return __a.__ptr_;
+  }
+};
+
+template <class _Tp>
+struct atomic_ref : public __atomic_ref_base<_Tp> {
+  static_assert(is_trivially_copyable_v<_Tp>, "std::atomic_ref<T> requires that 'T' be a trivially copyable type");
+
+  using __base = __atomic_ref_base<_Tp>;
+
+  _LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp& __obj) : __base(__obj) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        reinterpret_cast<uintptr_t>(std::addressof(__obj)) % __base::required_alignment == 0,
+        "atomic_ref ctor: referenced object must be aligned to required_alignment");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI atomic_ref(const atomic_ref&) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept { return __base::operator=(__desired); }
+
+  atomic_ref& operator=(const atomic_ref&) = delete;
+};
+
+template <class _Tp>
+  requires(std::integral<_Tp> && !std::same_as<bool, _Tp>)
+struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
+  using __base = __atomic_ref_base<_Tp>;
+
+  using difference_type = __base::value_type;
+
+  _LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp& __obj) : __base(__obj) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        reinterpret_cast<uintptr_t>(std::addressof(__obj)) % __base::required_alignment == 0,
+        "atomic_ref ctor: referenced object must be aligned to required_alignment");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI atomic_ref(const atomic_ref&) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept { return __base::operator=(__desired); }
+
+  atomic_ref& operator=(const atomic_ref&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+    return __atomic_fetch_add(this->__ptr_, __arg, std::__to_gcc_order(__order));
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+    return __atomic_fetch_sub(this->__ptr_, __arg, std::__to_gcc_order(__order));
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_and(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+    return __atomic_fetch_and(this->__ptr_, __arg, std::__to_gcc_order(__order));
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_or(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+    return __atomic_fetch_or(this->__ptr_, __arg, std::__to_gcc_order(__order));
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_xor(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+    return __atomic_fetch_xor(this->__ptr_, __arg, std::__to_gcc_order(__order));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator++(int) const noexcept { return fetch_add(_Tp(1)); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator--(int) const noexcept { return fetch_sub(_Tp(1)); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator++() const noexcept { return fetch_add(_Tp(1)) + _Tp(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator--() const noexcept { return fetch_sub(_Tp(1)) - _Tp(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __arg) const noexcept { return fetch_add(__arg) + __arg; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __arg) const noexcept { return fetch_sub(__arg) - __arg; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator&=(_Tp __arg) const noexcept { return fetch_and(__arg) & __arg; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator|=(_Tp __arg) const noexcept { return fetch_or(__arg) | __arg; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator^=(_Tp __arg) const noexcept { return fetch_xor(__arg) ^ __arg; }
+};
+
+template <class _Tp>
+  requires std::floating_point<_Tp>
+struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
+  using __base = __atomic_ref_base<_Tp>;
+
+  using difference_type = __base::value_type;
+
+  _LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp& __obj) : __base(__obj) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        reinterpret_cast<uintptr_t>(std::addressof(__obj)) % __base::required_alignment == 0,
+        "atomic_ref ctor: referenced object must be aligned to required_alignment");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI atomic_ref(const atomic_ref&) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator=(_Tp __desired) const noexcept { return __base::operator=(__desired); }
+
+  atomic_ref& operator=(const atomic_ref&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+    _Tp __old = this->load(memory_order_relaxed);
+    _Tp __new = __old + __arg;
+    while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed)) {
+      __new = __old + __arg;
+    }
+    return __old;
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+    _Tp __old = this->load(memory_order_relaxed);
+    _Tp __new = __old - __arg;
+    while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed)) {
+      __new = __old - __arg;
+    }
+    return __old;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __arg) const noexcept { return fetch_add(__arg) + __arg; }
+  _LIBCPP_HIDE_FROM_ABI _Tp operator-=(_Tp __arg) const noexcept { return fetch_sub(__arg) - __arg; }
+};
+
+template <class _Tp>
+struct atomic_ref<_Tp*> : public __atomic_ref_base<_Tp*> {
+  using __base = __atomic_ref_base<_Tp*>;
+
+  using difference_type = ptrdiff_t;
+
+  _LIBCPP_HIDE_FROM_ABI explicit atomic_ref(_Tp*& __ptr) : __base(__ptr) {}
+
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator=(_Tp* __desired) const noexcept { return __base::operator=(__desired); }
+
+  atomic_ref& operator=(const atomic_ref&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI _Tp* fetch_add(ptrdiff_t __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+    return __atomic_fetch_add(this->__ptr_, __arg * sizeof(_Tp), std::__to_gcc_order(__order));
+  }
+  _LIBCPP_HIDE_FROM_ABI _Tp* fetch_sub(ptrdiff_t __arg, memory_order __order = memory_order_seq_cst) const noexcept {
+    return __atomic_fetch_sub(this->__ptr_, __arg * sizeof(_Tp), std::__to_gcc_order(__order));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator++(int) const noexcept { return fetch_add(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator--(int) const noexcept { return fetch_sub(1); }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator++() const noexcept { return fetch_add(1) + 1; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator--() const noexcept { return fetch_sub(1) - 1; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator+=(ptrdiff_t __arg) const noexcept { return fetch_add(__arg) + __arg; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator-=(ptrdiff_t __arg) const noexcept { return fetch_sub(__arg) - __arg; }
+};
+
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(atomic_ref);
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP__ATOMIC_ATOMIC_REF_H
diff --git a/third_party/libcxx/__atomic/atomic_sync.h b/third_party/libcxx/__atomic/atomic_sync.h
index d55450bb5..aaf81f587 100644
--- a/third_party/libcxx/__atomic/atomic_sync.h
+++ b/third_party/libcxx/__atomic/atomic_sync.h
@@ -12,13 +12,17 @@
 #include <__atomic/contention_t.h>
 #include <__atomic/cxx_atomic_impl.h>
 #include <__atomic/memory_order.h>
-#include <__availability>
+#include <__atomic/to_gcc_order.h>
 #include <__chrono/duration.h>
 #include <__config>
 #include <__memory/addressof.h>
 #include <__thread/poll_with_backoff.h>
-#include <__threading_support>
+#include <__thread/support.h>
+#include <__type_traits/conjunction.h>
 #include <__type_traits/decay.h>
+#include <__type_traits/invoke.h>
+#include <__type_traits/void_t.h>
+#include <__utility/declval.h>
 #include <cstring>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -27,84 +31,173 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#ifndef _LIBCPP_HAS_NO_THREADS
+// The customisation points to enable the following functions:
+// - __atomic_wait
+// - __atomic_wait_unless
+// - __atomic_notify_one
+// - __atomic_notify_all
+// Note that std::atomic<T>::wait was back-ported to C++03
+// The below implementations look ugly to support C++03
+template <class _Tp, class = void>
+struct __atomic_waitable_traits {
+  template <class _AtomicWaitable>
+  static void __atomic_load(_AtomicWaitable&&, memory_order) = delete;
 
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(void const volatile*);
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(void const volatile*);
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t __libcpp_atomic_monitor(void const volatile*);
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __libcpp_atomic_wait(void const volatile*, __cxx_contention_t);
-
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile*);
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(__cxx_atomic_contention_t const volatile*);
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t __libcpp_atomic_monitor(__cxx_atomic_contention_t const volatile*);
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __libcpp_atomic_wait(__cxx_atomic_contention_t const volatile*, __cxx_contention_t);
-
-template <class _Atp, class _Fn>
-struct __libcpp_atomic_wait_backoff_impl {
-    _Atp* __a;
-    _Fn __test_fn;
-    _LIBCPP_AVAILABILITY_SYNC
-    _LIBCPP_HIDE_FROM_ABI bool operator()(chrono::nanoseconds __elapsed) const
-    {
-        if(__elapsed > chrono::microseconds(64))
-        {
-            auto const __monitor = std::__libcpp_atomic_monitor(__a);
-            if(__test_fn())
-                return true;
-            std::__libcpp_atomic_wait(__a, __monitor);
-        }
-        else if(__elapsed > chrono::microseconds(4))
-            __libcpp_thread_yield();
-        else
-            {} // poll
-        return false;
-    }
+  template <class _AtomicWaitable>
+  static void __atomic_contention_address(_AtomicWaitable&&) = delete;
 };
 
-template <class _Atp, class _Fn>
-_LIBCPP_AVAILABILITY_SYNC
-_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_wait(_Atp* __a, _Fn && __test_fn)
-{
-    __libcpp_atomic_wait_backoff_impl<_Atp, __decay_t<_Fn> > __backoff_fn = {__a, __test_fn};
-    return std::__libcpp_thread_poll_with_backoff(__test_fn, __backoff_fn);
+template <class _Tp, class = void>
+struct __atomic_waitable : false_type {};
+
+template <class _Tp>
+struct __atomic_waitable< _Tp,
+                          __void_t<decltype(__atomic_waitable_traits<__decay_t<_Tp> >::__atomic_load(
+                                       std::declval<const _Tp&>(), std::declval<memory_order>())),
+                                   decltype(__atomic_waitable_traits<__decay_t<_Tp> >::__atomic_contention_address(
+                                       std::declval<const _Tp&>()))> > : true_type {};
+
+template <class _AtomicWaitable, class _Poll>
+struct __atomic_wait_poll_impl {
+  const _AtomicWaitable& __a_;
+  _Poll __poll_;
+  memory_order __order_;
+
+  _LIBCPP_HIDE_FROM_ABI bool operator()() const {
+    auto __current_val = __atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__atomic_load(__a_, __order_);
+    return __poll_(__current_val);
+  }
+};
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(void const volatile*) _NOEXCEPT;
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(void const volatile*) _NOEXCEPT;
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t
+__libcpp_atomic_monitor(void const volatile*) _NOEXCEPT;
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void
+__libcpp_atomic_wait(void const volatile*, __cxx_contention_t) _NOEXCEPT;
+
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void
+__cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile*) _NOEXCEPT;
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void
+__cxx_atomic_notify_all(__cxx_atomic_contention_t const volatile*) _NOEXCEPT;
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t
+__libcpp_atomic_monitor(__cxx_atomic_contention_t const volatile*) _NOEXCEPT;
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void
+__libcpp_atomic_wait(__cxx_atomic_contention_t const volatile*, __cxx_contention_t) _NOEXCEPT;
+
+template <class _AtomicWaitable, class _Poll>
+struct __atomic_wait_backoff_impl {
+  const _AtomicWaitable& __a_;
+  _Poll __poll_;
+  memory_order __order_;
+
+  using __waitable_traits = __atomic_waitable_traits<__decay_t<_AtomicWaitable> >;
+
+  _LIBCPP_AVAILABILITY_SYNC
+  _LIBCPP_HIDE_FROM_ABI bool
+  __update_monitor_val_and_poll(__cxx_atomic_contention_t const volatile*, __cxx_contention_t& __monitor_val) const {
+    // In case the contention type happens to be __cxx_atomic_contention_t, i.e. __cxx_atomic_impl<int64_t>,
+    // the platform wait is directly monitoring the atomic value itself.
+    // `__poll_` takes the current value of the atomic as an in-out argument
+    // to potentially modify it. After it returns, `__monitor` has a value
+    // which can be safely waited on by `std::__libcpp_atomic_wait` without any
+    // ABA style issues.
+    __monitor_val = __waitable_traits::__atomic_load(__a_, __order_);
+    return __poll_(__monitor_val);
+  }
+
+  _LIBCPP_AVAILABILITY_SYNC
+  _LIBCPP_HIDE_FROM_ABI bool
+  __update_monitor_val_and_poll(void const volatile* __contention_address, __cxx_contention_t& __monitor_val) const {
+    // In case the contention type is anything else, platform wait is monitoring a __cxx_atomic_contention_t
+    // from the global pool, the monitor comes from __libcpp_atomic_monitor
+    __monitor_val      = std::__libcpp_atomic_monitor(__contention_address);
+    auto __current_val = __waitable_traits::__atomic_load(__a_, __order_);
+    return __poll_(__current_val);
+  }
+
+  _LIBCPP_AVAILABILITY_SYNC
+  _LIBCPP_HIDE_FROM_ABI bool operator()(chrono::nanoseconds __elapsed) const {
+    if (__elapsed > chrono::microseconds(64)) {
+      auto __contention_address = __waitable_traits::__atomic_contention_address(__a_);
+      __cxx_contention_t __monitor_val;
+      if (__update_monitor_val_and_poll(__contention_address, __monitor_val))
+        return true;
+      std::__libcpp_atomic_wait(__contention_address, __monitor_val);
+    } else if (__elapsed > chrono::microseconds(4))
+      __libcpp_thread_yield();
+    else {
+    } // poll
+    return false;
+  }
+};
+
+// The semantics of this function are similar to `atomic`'s
+// `.wait(T old, std::memory_order order)`, but instead of having a hardcoded
+// predicate (is the loaded value unequal to `old`?), the predicate function is
+// specified as an argument. The loaded value is given as an in-out argument to
+// the predicate. If the predicate function returns `true`,
+// `__atomic_wait_unless` will return. If the predicate function returns
+// `false`, it must set the argument to its current understanding of the atomic
+// value. The predicate function must not return `false` spuriously.
+template <class _AtomicWaitable, class _Poll>
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+__atomic_wait_unless(const _AtomicWaitable& __a, _Poll&& __poll, memory_order __order) {
+  static_assert(__atomic_waitable<_AtomicWaitable>::value, "");
+  __atomic_wait_poll_impl<_AtomicWaitable, __decay_t<_Poll> > __poll_impl     = {__a, __poll, __order};
+  __atomic_wait_backoff_impl<_AtomicWaitable, __decay_t<_Poll> > __backoff_fn = {__a, __poll, __order};
+  std::__libcpp_thread_poll_with_backoff(__poll_impl, __backoff_fn);
+}
+
+template <class _AtomicWaitable>
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void __atomic_notify_one(const _AtomicWaitable& __a) {
+  static_assert(__atomic_waitable<_AtomicWaitable>::value, "");
+  std::__cxx_atomic_notify_one(__atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__atomic_contention_address(__a));
+}
+
+template <class _AtomicWaitable>
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void __atomic_notify_all(const _AtomicWaitable& __a) {
+  static_assert(__atomic_waitable<_AtomicWaitable>::value, "");
+  std::__cxx_atomic_notify_all(__atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__atomic_contention_address(__a));
 }
 
 #else // _LIBCPP_HAS_NO_THREADS
 
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI void __cxx_atomic_notify_all(__cxx_atomic_impl<_Tp> const volatile*) { }
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI void __cxx_atomic_notify_one(__cxx_atomic_impl<_Tp> const volatile*) { }
-template <class _Atp, class _Fn>
-_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_wait(_Atp*, _Fn && __test_fn)
-{
-    return std::__libcpp_thread_poll_with_backoff(__test_fn, __spinning_backoff_policy());
+template <class _AtomicWaitable, class _Poll>
+_LIBCPP_HIDE_FROM_ABI void __atomic_wait_unless(const _AtomicWaitable& __a, _Poll&& __poll, memory_order __order) {
+  __atomic_wait_poll_impl<_AtomicWaitable, __decay_t<_Poll> > __poll_fn = {__a, __poll, __order};
+  std::__libcpp_thread_poll_with_backoff(__poll_fn, __spinning_backoff_policy());
 }
 
+template <class _AtomicWaitable>
+_LIBCPP_HIDE_FROM_ABI void __atomic_notify_one(const _AtomicWaitable&) {}
+
+template <class _AtomicWaitable>
+_LIBCPP_HIDE_FROM_ABI void __atomic_notify_all(const _AtomicWaitable&) {}
+
 #endif // _LIBCPP_HAS_NO_THREADS
 
-template <typename _Tp> _LIBCPP_HIDE_FROM_ABI
-bool __cxx_nonatomic_compare_equal(_Tp const& __lhs, _Tp const& __rhs) {
-    return std::memcmp(std::addressof(__lhs), std::addressof(__rhs), sizeof(_Tp)) == 0;
+template <typename _Tp>
+_LIBCPP_HIDE_FROM_ABI bool __cxx_nonatomic_compare_equal(_Tp const& __lhs, _Tp const& __rhs) {
+  return std::memcmp(std::addressof(__lhs), std::addressof(__rhs), sizeof(_Tp)) == 0;
 }
 
-template <class _Atp, class _Tp>
-struct __cxx_atomic_wait_test_fn_impl {
-    _Atp* __a;
-    _Tp __val;
-    memory_order __order;
-    _LIBCPP_HIDE_FROM_ABI bool operator()() const
-    {
-        return !std::__cxx_nonatomic_compare_equal(std::__cxx_atomic_load(__a, __order), __val);
-    }
+template <class _Tp>
+struct __atomic_compare_unequal_to {
+  _Tp __val_;
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __arg) const {
+    return !std::__cxx_nonatomic_compare_equal(__arg, __val_);
+  }
 };
 
-template <class _Atp, class _Tp>
-_LIBCPP_AVAILABILITY_SYNC
-_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_wait(_Atp* __a, _Tp const __val, memory_order __order)
-{
-    __cxx_atomic_wait_test_fn_impl<_Atp, _Tp> __test_fn = {__a, __val, __order};
-    return std::__cxx_atomic_wait(__a, __test_fn);
+template <class _AtomicWaitable, class _Up>
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+__atomic_wait(_AtomicWaitable& __a, _Up __val, memory_order __order) {
+  static_assert(__atomic_waitable<_AtomicWaitable>::value, "");
+  __atomic_compare_unequal_to<_Up> __nonatomic_equal = {__val};
+  std::__atomic_wait_unless(__a, __nonatomic_equal, __order);
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__atomic/check_memory_order.h b/third_party/libcxx/__atomic/check_memory_order.h
index d74431212..536f764a6 100644
--- a/third_party/libcxx/__atomic/check_memory_order.h
+++ b/third_party/libcxx/__atomic/check_memory_order.h
@@ -15,20 +15,20 @@
 #  pragma GCC system_header
 #endif
 
-#define _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) \
-  _LIBCPP_DIAGNOSE_WARNING(__m == memory_order_consume || \
-                           __m == memory_order_acquire || \
-                           __m == memory_order_acq_rel,   \
-                        "memory order argument to atomic operation is invalid")
+#define _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m)                                                                          \
+  _LIBCPP_DIAGNOSE_WARNING(__m == memory_order_consume || __m == memory_order_acquire || __m == memory_order_acq_rel,  \
+                           "memory order argument to atomic operation is invalid")
 
-#define _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) \
-  _LIBCPP_DIAGNOSE_WARNING(__m == memory_order_release || \
-                           __m == memory_order_acq_rel,   \
-                        "memory order argument to atomic operation is invalid")
+#define _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m)                                                                           \
+  _LIBCPP_DIAGNOSE_WARNING(__m == memory_order_release || __m == memory_order_acq_rel,                                 \
+                           "memory order argument to atomic operation is invalid")
 
-#define _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__m, __f) \
-  _LIBCPP_DIAGNOSE_WARNING(__f == memory_order_release || \
-                           __f == memory_order_acq_rel,   \
-                        "memory order argument to atomic operation is invalid")
+#define _LIBCPP_CHECK_EXCHANGE_MEMORY_ORDER(__m, __f)                                                                  \
+  _LIBCPP_DIAGNOSE_WARNING(__f == memory_order_release || __f == memory_order_acq_rel,                                 \
+                           "memory order argument to atomic operation is invalid")
+
+#define _LIBCPP_CHECK_WAIT_MEMORY_ORDER(__m)                                                                           \
+  _LIBCPP_DIAGNOSE_WARNING(__m == memory_order_release || __m == memory_order_acq_rel,                                 \
+                           "memory order argument to atomic operation is invalid")
 
 #endif // _LIBCPP___ATOMIC_CHECK_MEMORY_ORDER_H
diff --git a/third_party/libcxx/__atomic/contention_t.h b/third_party/libcxx/__atomic/contention_t.h
index 1d8d02430..65890f338 100644
--- a/third_party/libcxx/__atomic/contention_t.h
+++ b/third_party/libcxx/__atomic/contention_t.h
@@ -20,9 +20,9 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if defined(__linux__) || (defined(_AIX) && !defined(__64BIT__))
-    using __cxx_contention_t = int32_t;
+using __cxx_contention_t = int32_t;
 #else
-    using __cxx_contention_t = int64_t;
+using __cxx_contention_t = int64_t;
 #endif // __linux__ || (_AIX && !__64BIT__)
 
 using __cxx_atomic_contention_t = __cxx_atomic_impl<__cxx_contention_t>;
diff --git a/third_party/libcxx/__atomic/cxx_atomic_impl.h b/third_party/libcxx/__atomic/cxx_atomic_impl.h
index 167cee7f0..18e88aa97 100644
--- a/third_party/libcxx/__atomic/cxx_atomic_impl.h
+++ b/third_party/libcxx/__atomic/cxx_atomic_impl.h
@@ -9,16 +9,14 @@
 #ifndef _LIBCPP___ATOMIC_CXX_ATOMIC_IMPL_H
 #define _LIBCPP___ATOMIC_CXX_ATOMIC_IMPL_H
 
-#include <__atomic/is_always_lock_free.h>
 #include <__atomic/memory_order.h>
+#include <__atomic/to_gcc_order.h>
 #include <__config>
 #include <__memory/addressof.h>
-#include <__type_traits/conditional.h>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_trivially_copyable.h>
 #include <__type_traits/remove_const.h>
 #include <cstddef>
-#include <cstring>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -26,122 +24,95 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP) || \
-    defined(_LIBCPP_ATOMIC_ONLY_USE_BUILTINS)
+#if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP)
 
 // [atomics.types.generic]p1 guarantees _Tp is trivially copyable. Because
 // the default operator= in an object is not volatile, a byte-by-byte copy
 // is required.
-template <typename _Tp, typename _Tv> _LIBCPP_HIDE_FROM_ABI
-typename enable_if<is_assignable<_Tp&, _Tv>::value>::type
-__cxx_atomic_assign_volatile(_Tp& __a_value, _Tv const& __val) {
+template <typename _Tp, typename _Tv, __enable_if_t<is_assignable<_Tp&, _Tv>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void __cxx_atomic_assign_volatile(_Tp& __a_value, _Tv const& __val) {
   __a_value = __val;
 }
-template <typename _Tp, typename _Tv> _LIBCPP_HIDE_FROM_ABI
-typename enable_if<is_assignable<_Tp&, _Tv>::value>::type
-__cxx_atomic_assign_volatile(_Tp volatile& __a_value, _Tv volatile const& __val) {
+template <typename _Tp, typename _Tv, __enable_if_t<is_assignable<_Tp&, _Tv>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI void __cxx_atomic_assign_volatile(_Tp volatile& __a_value, _Tv volatile const& __val) {
   volatile char* __to         = reinterpret_cast<volatile char*>(std::addressof(__a_value));
-  volatile char* __end = __to + sizeof(_Tp);
+  volatile char* __end        = __to + sizeof(_Tp);
   volatile const char* __from = reinterpret_cast<volatile const char*>(std::addressof(__val));
   while (__to != __end)
     *__to++ = *__from++;
 }
 
-#endif
-
-#if defined(_LIBCPP_HAS_GCC_ATOMIC_IMP)
-
 template <typename _Tp>
 struct __cxx_atomic_base_impl {
-
   _LIBCPP_HIDE_FROM_ABI
-#ifndef _LIBCPP_CXX03_LANG
-    __cxx_atomic_base_impl() _NOEXCEPT = default;
-#else
-    __cxx_atomic_base_impl() _NOEXCEPT : __a_value() {}
-#endif // _LIBCPP_CXX03_LANG
-  _LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT
-    : __a_value(value) {}
+#  ifndef _LIBCPP_CXX03_LANG
+  __cxx_atomic_base_impl() _NOEXCEPT = default;
+#  else
+  __cxx_atomic_base_impl() _NOEXCEPT : __a_value() {
+  }
+#  endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT : __a_value(value) {}
   _Tp __a_value;
 };
 
-_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR int __to_gcc_order(memory_order __order) {
-  // Avoid switch statement to make this a constexpr.
-  return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
-         (__order == memory_order_acquire ? __ATOMIC_ACQUIRE:
-          (__order == memory_order_release ? __ATOMIC_RELEASE:
-           (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST:
-            (__order == memory_order_acq_rel ? __ATOMIC_ACQ_REL:
-              __ATOMIC_CONSUME))));
-}
-
-_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR int __to_gcc_failure_order(memory_order __order) {
-  // Avoid switch statement to make this a constexpr.
-  return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
-         (__order == memory_order_acquire ? __ATOMIC_ACQUIRE:
-          (__order == memory_order_release ? __ATOMIC_RELAXED:
-           (__order == memory_order_seq_cst ? __ATOMIC_SEQ_CST:
-            (__order == memory_order_acq_rel ? __ATOMIC_ACQUIRE:
-              __ATOMIC_CONSUME))));
-}
-
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_init(volatile __cxx_atomic_base_impl<_Tp>* __a,  _Tp __val) {
+_LIBCPP_HIDE_FROM_ABI void __cxx_atomic_init(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __val) {
   __cxx_atomic_assign_volatile(__a->__a_value, __val);
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp>* __a,  _Tp __val) {
+_LIBCPP_HIDE_FROM_ABI void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp>* __a, _Tp __val) {
   __a->__a_value = __val;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-void __cxx_atomic_thread_fence(memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI inline void __cxx_atomic_thread_fence(memory_order __order) {
   __atomic_thread_fence(__to_gcc_order(__order));
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-void __cxx_atomic_signal_fence(memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI inline void __cxx_atomic_signal_fence(memory_order __order) {
   __atomic_signal_fence(__to_gcc_order(__order));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_store(volatile __cxx_atomic_base_impl<_Tp>* __a,  _Tp __val,
-                        memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI void
+__cxx_atomic_store(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __val, memory_order __order) {
   __atomic_store(std::addressof(__a->__a_value), std::addressof(__val), __to_gcc_order(__order));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp>* __a,  _Tp __val,
-                        memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp>* __a, _Tp __val, memory_order __order) {
   __atomic_store(std::addressof(__a->__a_value), std::addressof(__val), __to_gcc_order(__order));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_load(const volatile __cxx_atomic_base_impl<_Tp>* __a,
-                      memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp __cxx_atomic_load(const volatile __cxx_atomic_base_impl<_Tp>* __a, memory_order __order) {
   _Tp __ret;
   __atomic_load(std::addressof(__a->__a_value), std::addressof(__ret), __to_gcc_order(__order));
   return __ret;
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_load(const __cxx_atomic_base_impl<_Tp>* __a, memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI void
+__cxx_atomic_load_inplace(const volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp* __dst, memory_order __order) {
+  __atomic_load(std::addressof(__a->__a_value), __dst, __to_gcc_order(__order));
+}
+
+template <typename _Tp>
+_LIBCPP_HIDE_FROM_ABI void
+__cxx_atomic_load_inplace(const __cxx_atomic_base_impl<_Tp>* __a, _Tp* __dst, memory_order __order) {
+  __atomic_load(std::addressof(__a->__a_value), __dst, __to_gcc_order(__order));
+}
+
+template <typename _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __cxx_atomic_load(const __cxx_atomic_base_impl<_Tp>* __a, memory_order __order) {
   _Tp __ret;
   __atomic_load(std::addressof(__a->__a_value), std::addressof(__ret), __to_gcc_order(__order));
   return __ret;
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_exchange(volatile __cxx_atomic_base_impl<_Tp>* __a,
-                          _Tp __value, memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_exchange(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __value, memory_order __order) {
   _Tp __ret;
   __atomic_exchange(
       std::addressof(__a->__a_value), std::addressof(__value), std::addressof(__ret), __to_gcc_order(__order));
@@ -149,9 +120,7 @@ _Tp __cxx_atomic_exchange(volatile __cxx_atomic_base_impl<_Tp>* __a,
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp>* __a, _Tp __value,
-                          memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp>* __a, _Tp __value, memory_order __order) {
   _Tp __ret;
   __atomic_exchange(
       std::addressof(__a->__a_value), std::addressof(__value), std::addressof(__ret), __to_gcc_order(__order));
@@ -159,23 +128,11 @@ _Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp>* __a, _Tp __value,
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_strong(
-    volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value,
-    memory_order __success, memory_order __failure) {
-  return __atomic_compare_exchange(
-      std::addressof(__a->__a_value),
-      __expected,
-      std::addressof(__value),
-      false,
-      __to_gcc_order(__success),
-      __to_gcc_failure_order(__failure));
-}
-
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_strong(
-    __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value, memory_order __success,
+_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_compare_exchange_strong(
+    volatile __cxx_atomic_base_impl<_Tp>* __a,
+    _Tp* __expected,
+    _Tp __value,
+    memory_order __success,
     memory_order __failure) {
   return __atomic_compare_exchange(
       std::addressof(__a->__a_value),
@@ -187,23 +144,23 @@ bool __cxx_atomic_compare_exchange_strong(
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_weak(
-    volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value,
-    memory_order __success, memory_order __failure) {
+_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_compare_exchange_strong(
+    __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) {
   return __atomic_compare_exchange(
       std::addressof(__a->__a_value),
       __expected,
       std::addressof(__value),
-      true,
+      false,
       __to_gcc_order(__success),
       __to_gcc_failure_order(__failure));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_weak(
-    __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value, memory_order __success,
+_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_compare_exchange_weak(
+    volatile __cxx_atomic_base_impl<_Tp>* __a,
+    _Tp* __expected,
+    _Tp __value,
+    memory_order __success,
     memory_order __failure) {
   return __atomic_compare_exchange(
       std::addressof(__a->__a_value),
@@ -215,178 +172,194 @@ bool __cxx_atomic_compare_exchange_weak(
 }
 
 template <typename _Tp>
-struct __skip_amt { enum {value = 1}; };
+_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_compare_exchange_weak(
+    __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) {
+  return __atomic_compare_exchange(
+      std::addressof(__a->__a_value),
+      __expected,
+      std::addressof(__value),
+      true,
+      __to_gcc_order(__success),
+      __to_gcc_failure_order(__failure));
+}
 
 template <typename _Tp>
-struct __skip_amt<_Tp*> { enum {value = sizeof(_Tp)}; };
+struct __skip_amt {
+  enum { value = 1 };
+};
+
+template <typename _Tp>
+struct __skip_amt<_Tp*> {
+  enum { value = sizeof(_Tp) };
+};
 
 // FIXME: Haven't figured out what the spec says about using arrays with
 // atomic_fetch_add. Force a failure rather than creating bad behavior.
 template <typename _Tp>
-struct __skip_amt<_Tp[]> { };
+struct __skip_amt<_Tp[]> {};
 template <typename _Tp, int n>
-struct __skip_amt<_Tp[n]> { };
+struct __skip_amt<_Tp[n]> {};
 
 template <typename _Tp, typename _Td>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_add(volatile __cxx_atomic_base_impl<_Tp>* __a,
-                           _Td __delta, memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_add(volatile __cxx_atomic_base_impl<_Tp>* __a, _Td __delta, memory_order __order) {
   return __atomic_fetch_add(std::addressof(__a->__a_value), __delta * __skip_amt<_Tp>::value, __to_gcc_order(__order));
 }
 
 template <typename _Tp, typename _Td>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp>* __a, _Td __delta,
-                           memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp>* __a, _Td __delta, memory_order __order) {
   return __atomic_fetch_add(std::addressof(__a->__a_value), __delta * __skip_amt<_Tp>::value, __to_gcc_order(__order));
 }
 
 template <typename _Tp, typename _Td>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_sub(volatile __cxx_atomic_base_impl<_Tp>* __a,
-                           _Td __delta, memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_sub(volatile __cxx_atomic_base_impl<_Tp>* __a, _Td __delta, memory_order __order) {
   return __atomic_fetch_sub(std::addressof(__a->__a_value), __delta * __skip_amt<_Tp>::value, __to_gcc_order(__order));
 }
 
 template <typename _Tp, typename _Td>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp>* __a, _Td __delta,
-                           memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp>* __a, _Td __delta, memory_order __order) {
   return __atomic_fetch_sub(std::addressof(__a->__a_value), __delta * __skip_amt<_Tp>::value, __to_gcc_order(__order));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_and(volatile __cxx_atomic_base_impl<_Tp>* __a,
-                           _Tp __pattern, memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_and(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
   return __atomic_fetch_and(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp>* __a,
-                           _Tp __pattern, memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
   return __atomic_fetch_and(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_or(volatile __cxx_atomic_base_impl<_Tp>* __a,
-                          _Tp __pattern, memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_or(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
   return __atomic_fetch_or(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern,
-                          memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp __cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
   return __atomic_fetch_or(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_xor(volatile __cxx_atomic_base_impl<_Tp>* __a,
-                           _Tp __pattern, memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_xor(volatile __cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
   return __atomic_fetch_xor(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
 }
 
 template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern,
-                           memory_order __order) {
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) {
   return __atomic_fetch_xor(std::addressof(__a->__a_value), __pattern, __to_gcc_order(__order));
 }
 
-#define __cxx_atomic_is_lock_free(__s) __atomic_is_lock_free(__s, 0)
+#  define __cxx_atomic_is_lock_free(__s) __atomic_is_lock_free(__s, 0)
 
 #elif defined(_LIBCPP_HAS_C_ATOMIC_IMP)
 
 template <typename _Tp>
 struct __cxx_atomic_base_impl {
-
   _LIBCPP_HIDE_FROM_ABI
-#ifndef _LIBCPP_CXX03_LANG
-    __cxx_atomic_base_impl() _NOEXCEPT = default;
-#else
-    __cxx_atomic_base_impl() _NOEXCEPT : __a_value() {}
-#endif // _LIBCPP_CXX03_LANG
-  _LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp __value) _NOEXCEPT
-    : __a_value(__value) {}
+#  ifndef _LIBCPP_CXX03_LANG
+  __cxx_atomic_base_impl() _NOEXCEPT = default;
+#  else
+  __cxx_atomic_base_impl() _NOEXCEPT : __a_value() {
+  }
+#  endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp __value) _NOEXCEPT : __a_value(__value) {}
   _LIBCPP_DISABLE_EXTENSION_WARNING _Atomic(_Tp) __a_value;
 };
 
-#define __cxx_atomic_is_lock_free(__s) __c11_atomic_is_lock_free(__s)
+#  define __cxx_atomic_is_lock_free(__s) __c11_atomic_is_lock_free(__s)
 
-_LIBCPP_HIDE_FROM_ABI inline
-void __cxx_atomic_thread_fence(memory_order __order) _NOEXCEPT {
-    __c11_atomic_thread_fence(static_cast<__memory_order_underlying_t>(__order));
+_LIBCPP_HIDE_FROM_ABI inline void __cxx_atomic_thread_fence(memory_order __order) _NOEXCEPT {
+  __c11_atomic_thread_fence(static_cast<__memory_order_underlying_t>(__order));
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-void __cxx_atomic_signal_fence(memory_order __order) _NOEXCEPT {
-    __c11_atomic_signal_fence(static_cast<__memory_order_underlying_t>(__order));
+_LIBCPP_HIDE_FROM_ABI inline void __cxx_atomic_signal_fence(memory_order __order) _NOEXCEPT {
+  __c11_atomic_signal_fence(static_cast<__memory_order_underlying_t>(__order));
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __val) _NOEXCEPT {
-    __c11_atomic_init(std::addressof(__a->__a_value), __val);
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __val) _NOEXCEPT {
+  __c11_atomic_init(std::addressof(__a->__a_value), __val);
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp> * __a, _Tp __val) _NOEXCEPT {
-    __c11_atomic_init(std::addressof(__a->__a_value), __val);
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI void __cxx_atomic_init(__cxx_atomic_base_impl<_Tp>* __a, _Tp __val) _NOEXCEPT {
+  __c11_atomic_init(std::addressof(__a->__a_value), __val);
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __val, memory_order __order) _NOEXCEPT {
-    __c11_atomic_store(std::addressof(__a->__a_value), __val, static_cast<__memory_order_underlying_t>(__order));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI void
+__cxx_atomic_store(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __val, memory_order __order) _NOEXCEPT {
+  __c11_atomic_store(std::addressof(__a->__a_value), __val, static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_store(__cxx_atomic_base_impl<_Tp> * __a, _Tp __val, memory_order __order) _NOEXCEPT {
-    __c11_atomic_store(std::addressof(__a->__a_value), __val, static_cast<__memory_order_underlying_t>(__order));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI void
+__cxx_atomic_store(__cxx_atomic_base_impl<_Tp>* __a, _Tp __val, memory_order __order) _NOEXCEPT {
+  __c11_atomic_store(std::addressof(__a->__a_value), __val, static_cast<__memory_order_underlying_t>(__order));
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const volatile* __a, memory_order __order) _NOEXCEPT {
-    using __ptr_type = __remove_const_t<decltype(__a->__a_value)>*;
-    return __c11_atomic_load(
-        const_cast<__ptr_type>(std::addressof(__a->__a_value)), static_cast<__memory_order_underlying_t>(__order));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const volatile* __a, memory_order __order) _NOEXCEPT {
+  using __ptr_type = __remove_const_t<decltype(__a->__a_value)>*;
+  return __c11_atomic_load(
+      const_cast<__ptr_type>(std::addressof(__a->__a_value)), static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const* __a, memory_order __order) _NOEXCEPT {
-    using __ptr_type = __remove_const_t<decltype(__a->__a_value)>*;
-    return __c11_atomic_load(
-        const_cast<__ptr_type>(std::addressof(__a->__a_value)), static_cast<__memory_order_underlying_t>(__order));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp __cxx_atomic_load(__cxx_atomic_base_impl<_Tp> const* __a, memory_order __order) _NOEXCEPT {
+  using __ptr_type = __remove_const_t<decltype(__a->__a_value)>*;
+  return __c11_atomic_load(
+      const_cast<__ptr_type>(std::addressof(__a->__a_value)), static_cast<__memory_order_underlying_t>(__order));
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __value, memory_order __order) _NOEXCEPT {
-    return __c11_atomic_exchange(
-        std::addressof(__a->__a_value), __value, static_cast<__memory_order_underlying_t>(__order));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI void
+__cxx_atomic_load_inplace(__cxx_atomic_base_impl<_Tp> const volatile* __a, _Tp* __dst, memory_order __order) _NOEXCEPT {
+  using __ptr_type = __remove_const_t<decltype(__a->__a_value)>*;
+  *__dst           = __c11_atomic_load(
+      const_cast<__ptr_type>(std::addressof(__a->__a_value)), static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp> * __a, _Tp __value, memory_order __order) _NOEXCEPT {
-    return __c11_atomic_exchange(
-        std::addressof(__a->__a_value), __value, static_cast<__memory_order_underlying_t>(__order));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI void
+__cxx_atomic_load_inplace(__cxx_atomic_base_impl<_Tp> const* __a, _Tp* __dst, memory_order __order) _NOEXCEPT {
+  using __ptr_type = __remove_const_t<decltype(__a->__a_value)>*;
+  *__dst           = __c11_atomic_load(
+      const_cast<__ptr_type>(std::addressof(__a->__a_value)), static_cast<__memory_order_underlying_t>(__order));
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __value, memory_order __order) _NOEXCEPT {
+  return __c11_atomic_exchange(
+      std::addressof(__a->__a_value), __value, static_cast<__memory_order_underlying_t>(__order));
+}
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_exchange(__cxx_atomic_base_impl<_Tp>* __a, _Tp __value, memory_order __order) _NOEXCEPT {
+  return __c11_atomic_exchange(
+      std::addressof(__a->__a_value), __value, static_cast<__memory_order_underlying_t>(__order));
 }
 
 _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR memory_order __to_failure_order(memory_order __order) {
   // Avoid switch statement to make this a constexpr.
-  return __order == memory_order_release ? memory_order_relaxed:
-         (__order == memory_order_acq_rel ? memory_order_acquire:
-             __order);
+  return __order == memory_order_release
+           ? memory_order_relaxed
+           : (__order == memory_order_acq_rel ? memory_order_acquire : __order);
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_compare_exchange_strong(
+    __cxx_atomic_base_impl<_Tp> volatile* __a,
+    _Tp* __expected,
+    _Tp __value,
+    memory_order __success,
+    memory_order __failure) _NOEXCEPT {
   return __c11_atomic_compare_exchange_strong(
       std::addressof(__a->__a_value),
       __expected,
@@ -394,9 +367,10 @@ bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_base_impl<_Tp> volatile*
       static_cast<__memory_order_underlying_t>(__success),
       static_cast<__memory_order_underlying_t>(__to_failure_order(__failure)));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_base_impl<_Tp> * __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_compare_exchange_strong(
+    __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure)
+    _NOEXCEPT {
   return __c11_atomic_compare_exchange_strong(
       std::addressof(__a->__a_value),
       __expected,
@@ -405,9 +379,13 @@ bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_base_impl<_Tp> * __a, _Tp
       static_cast<__memory_order_underlying_t>(__to_failure_order(__failure)));
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_compare_exchange_weak(
+    __cxx_atomic_base_impl<_Tp> volatile* __a,
+    _Tp* __expected,
+    _Tp __value,
+    memory_order __success,
+    memory_order __failure) _NOEXCEPT {
   return __c11_atomic_compare_exchange_weak(
       std::addressof(__a->__a_value),
       __expected,
@@ -415,9 +393,10 @@ bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_base_impl<_Tp> volatile* __
       static_cast<__memory_order_underlying_t>(__success),
       static_cast<__memory_order_underlying_t>(__to_failure_order(__failure)));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_base_impl<_Tp> * __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI bool __cxx_atomic_compare_exchange_weak(
+    __cxx_atomic_base_impl<_Tp>* __a, _Tp* __expected, _Tp __value, memory_order __success, memory_order __failure)
+    _NOEXCEPT {
   return __c11_atomic_compare_exchange_weak(
       std::addressof(__a->__a_value),
       __expected,
@@ -426,404 +405,104 @@ bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_base_impl<_Tp> * __a, _Tp*
       static_cast<__memory_order_underlying_t>(__to_failure_order(__failure)));
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __delta, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __delta, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_add(
       std::addressof(__a->__a_value), __delta, static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp> * __a, _Tp __delta, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp>* __a, _Tp __delta, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_add(
       std::addressof(__a->__a_value), __delta, static_cast<__memory_order_underlying_t>(__order));
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp* __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp*> volatile* __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp*
+__cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp*> volatile* __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_add(
       std::addressof(__a->__a_value), __delta, static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp* __cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp*> * __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp*
+__cxx_atomic_fetch_add(__cxx_atomic_base_impl<_Tp*>* __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_add(
       std::addressof(__a->__a_value), __delta, static_cast<__memory_order_underlying_t>(__order));
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __delta, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __delta, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_sub(
       std::addressof(__a->__a_value), __delta, static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp> * __a, _Tp __delta, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp>* __a, _Tp __delta, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_sub(
       std::addressof(__a->__a_value), __delta, static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp* __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp*> volatile* __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp*
+__cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp*> volatile* __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_sub(
       std::addressof(__a->__a_value), __delta, static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp* __cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp*> * __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp*
+__cxx_atomic_fetch_sub(__cxx_atomic_base_impl<_Tp*>* __a, ptrdiff_t __delta, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_sub(
       std::addressof(__a->__a_value), __delta, static_cast<__memory_order_underlying_t>(__order));
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_and(
       std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp> * __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_and(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_and(
       std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_or(
       std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp> * __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_or(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_or(
       std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
 }
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp> volatile* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_xor(
       std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
 }
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp> * __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__cxx_atomic_fetch_xor(__cxx_atomic_base_impl<_Tp>* __a, _Tp __pattern, memory_order __order) _NOEXCEPT {
   return __c11_atomic_fetch_xor(
       std::addressof(__a->__a_value), __pattern, static_cast<__memory_order_underlying_t>(__order));
 }
 
 #endif // _LIBCPP_HAS_GCC_ATOMIC_IMP, _LIBCPP_HAS_C_ATOMIC_IMP
 
-#ifdef _LIBCPP_ATOMIC_ONLY_USE_BUILTINS
-
-template<typename _Tp>
-struct __cxx_atomic_lock_impl {
-
-  _LIBCPP_HIDE_FROM_ABI
-  __cxx_atomic_lock_impl() _NOEXCEPT
-    : __a_value(), __a_lock(0) {}
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit
-  __cxx_atomic_lock_impl(_Tp value) _NOEXCEPT
-    : __a_value(value), __a_lock(0) {}
-
-  _Tp __a_value;
-  mutable __cxx_atomic_base_impl<_LIBCPP_ATOMIC_FLAG_TYPE> __a_lock;
-
-  _LIBCPP_HIDE_FROM_ABI void __lock() const volatile {
-    while(1 == __cxx_atomic_exchange(&__a_lock, _LIBCPP_ATOMIC_FLAG_TYPE(true), memory_order_acquire))
-        /*spin*/;
-  }
-  _LIBCPP_HIDE_FROM_ABI void __lock() const {
-    while(1 == __cxx_atomic_exchange(&__a_lock, _LIBCPP_ATOMIC_FLAG_TYPE(true), memory_order_acquire))
-        /*spin*/;
-  }
-  _LIBCPP_HIDE_FROM_ABI void __unlock() const volatile {
-    __cxx_atomic_store(&__a_lock, _LIBCPP_ATOMIC_FLAG_TYPE(false), memory_order_release);
-  }
-  _LIBCPP_HIDE_FROM_ABI void __unlock() const {
-    __cxx_atomic_store(&__a_lock, _LIBCPP_ATOMIC_FLAG_TYPE(false), memory_order_release);
-  }
-  _LIBCPP_HIDE_FROM_ABI _Tp __read() const volatile {
-    __lock();
-    _Tp __old;
-    __cxx_atomic_assign_volatile(__old, __a_value);
-    __unlock();
-    return __old;
-  }
-  _LIBCPP_HIDE_FROM_ABI _Tp __read() const {
-    __lock();
-    _Tp __old = __a_value;
-    __unlock();
-    return __old;
-  }
-};
-
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_init(volatile __cxx_atomic_lock_impl<_Tp>* __a,  _Tp __val) {
-  __cxx_atomic_assign_volatile(__a->__a_value, __val);
-}
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_init(__cxx_atomic_lock_impl<_Tp>* __a,  _Tp __val) {
-  __a->__a_value = __val;
-}
-
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_store(volatile __cxx_atomic_lock_impl<_Tp>* __a,  _Tp __val, memory_order) {
-  __a->__lock();
-  __cxx_atomic_assign_volatile(__a->__a_value, __val);
-  __a->__unlock();
-}
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void __cxx_atomic_store(__cxx_atomic_lock_impl<_Tp>* __a,  _Tp __val, memory_order) {
-  __a->__lock();
-  __a->__a_value = __val;
-  __a->__unlock();
-}
-
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_load(const volatile __cxx_atomic_lock_impl<_Tp>* __a, memory_order) {
-  return __a->__read();
-}
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_load(const __cxx_atomic_lock_impl<_Tp>* __a, memory_order) {
-  return __a->__read();
-}
-
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_exchange(volatile __cxx_atomic_lock_impl<_Tp>* __a, _Tp __value, memory_order) {
-  __a->__lock();
-  _Tp __old;
-  __cxx_atomic_assign_volatile(__old, __a->__a_value);
-  __cxx_atomic_assign_volatile(__a->__a_value, __value);
-  __a->__unlock();
-  return __old;
-}
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_exchange(__cxx_atomic_lock_impl<_Tp>* __a, _Tp __value, memory_order) {
-  __a->__lock();
-  _Tp __old = __a->__a_value;
-  __a->__a_value = __value;
-  __a->__unlock();
-  return __old;
-}
-
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_strong(volatile __cxx_atomic_lock_impl<_Tp>* __a,
-                                          _Tp* __expected, _Tp __value, memory_order, memory_order) {
-  _Tp __temp;
-  __a->__lock();
-  __cxx_atomic_assign_volatile(__temp, __a->__a_value);
-  bool __ret = (std::memcmp(&__temp, __expected, sizeof(_Tp)) == 0);
-  if(__ret)
-    __cxx_atomic_assign_volatile(__a->__a_value, __value);
-  else
-    __cxx_atomic_assign_volatile(*__expected, __a->__a_value);
-  __a->__unlock();
-  return __ret;
-}
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_strong(__cxx_atomic_lock_impl<_Tp>* __a,
-                                          _Tp* __expected, _Tp __value, memory_order, memory_order) {
-  __a->__lock();
-  bool __ret = (std::memcmp(&__a->__a_value, __expected, sizeof(_Tp)) == 0);
-  if(__ret)
-    std::memcpy(&__a->__a_value, &__value, sizeof(_Tp));
-  else
-    std::memcpy(__expected, &__a->__a_value, sizeof(_Tp));
-  __a->__unlock();
-  return __ret;
-}
-
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_weak(volatile __cxx_atomic_lock_impl<_Tp>* __a,
-                                        _Tp* __expected, _Tp __value, memory_order, memory_order) {
-  _Tp __temp;
-  __a->__lock();
-  __cxx_atomic_assign_volatile(__temp, __a->__a_value);
-  bool __ret = (std::memcmp(&__temp, __expected, sizeof(_Tp)) == 0);
-  if(__ret)
-    __cxx_atomic_assign_volatile(__a->__a_value, __value);
-  else
-    __cxx_atomic_assign_volatile(*__expected, __a->__a_value);
-  __a->__unlock();
-  return __ret;
-}
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-bool __cxx_atomic_compare_exchange_weak(__cxx_atomic_lock_impl<_Tp>* __a,
-                                        _Tp* __expected, _Tp __value, memory_order, memory_order) {
-  __a->__lock();
-  bool __ret = (std::memcmp(&__a->__a_value, __expected, sizeof(_Tp)) == 0);
-  if(__ret)
-    std::memcpy(&__a->__a_value, &__value, sizeof(_Tp));
-  else
-    std::memcpy(__expected, &__a->__a_value, sizeof(_Tp));
-  __a->__unlock();
-  return __ret;
-}
-
-template <typename _Tp, typename _Td>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_add(volatile __cxx_atomic_lock_impl<_Tp>* __a,
-                           _Td __delta, memory_order) {
-  __a->__lock();
-  _Tp __old;
-  __cxx_atomic_assign_volatile(__old, __a->__a_value);
-  __cxx_atomic_assign_volatile(__a->__a_value, _Tp(__old + __delta));
-  __a->__unlock();
-  return __old;
-}
-template <typename _Tp, typename _Td>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_add(__cxx_atomic_lock_impl<_Tp>* __a,
-                           _Td __delta, memory_order) {
-  __a->__lock();
-  _Tp __old = __a->__a_value;
-  __a->__a_value += __delta;
-  __a->__unlock();
-  return __old;
-}
-
-template <typename _Tp, typename _Td>
-_LIBCPP_HIDE_FROM_ABI
-_Tp* __cxx_atomic_fetch_add(volatile __cxx_atomic_lock_impl<_Tp*>* __a,
-                           ptrdiff_t __delta, memory_order) {
-  __a->__lock();
-  _Tp* __old;
-  __cxx_atomic_assign_volatile(__old, __a->__a_value);
-  __cxx_atomic_assign_volatile(__a->__a_value, __old + __delta);
-  __a->__unlock();
-  return __old;
-}
-template <typename _Tp, typename _Td>
-_LIBCPP_HIDE_FROM_ABI
-_Tp* __cxx_atomic_fetch_add(__cxx_atomic_lock_impl<_Tp*>* __a,
-                           ptrdiff_t __delta, memory_order) {
-  __a->__lock();
-  _Tp* __old = __a->__a_value;
-  __a->__a_value += __delta;
-  __a->__unlock();
-  return __old;
-}
-
-template <typename _Tp, typename _Td>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_sub(volatile __cxx_atomic_lock_impl<_Tp>* __a,
-                           _Td __delta, memory_order) {
-  __a->__lock();
-  _Tp __old;
-  __cxx_atomic_assign_volatile(__old, __a->__a_value);
-  __cxx_atomic_assign_volatile(__a->__a_value, _Tp(__old - __delta));
-  __a->__unlock();
-  return __old;
-}
-template <typename _Tp, typename _Td>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_sub(__cxx_atomic_lock_impl<_Tp>* __a,
-                           _Td __delta, memory_order) {
-  __a->__lock();
-  _Tp __old = __a->__a_value;
-  __a->__a_value -= __delta;
-  __a->__unlock();
-  return __old;
-}
-
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_and(volatile __cxx_atomic_lock_impl<_Tp>* __a,
-                           _Tp __pattern, memory_order) {
-  __a->__lock();
-  _Tp __old;
-  __cxx_atomic_assign_volatile(__old, __a->__a_value);
-  __cxx_atomic_assign_volatile(__a->__a_value, _Tp(__old & __pattern));
-  __a->__unlock();
-  return __old;
-}
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_and(__cxx_atomic_lock_impl<_Tp>* __a,
-                           _Tp __pattern, memory_order) {
-  __a->__lock();
-  _Tp __old = __a->__a_value;
-  __a->__a_value &= __pattern;
-  __a->__unlock();
-  return __old;
-}
-
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_or(volatile __cxx_atomic_lock_impl<_Tp>* __a,
-                          _Tp __pattern, memory_order) {
-  __a->__lock();
-  _Tp __old;
-  __cxx_atomic_assign_volatile(__old, __a->__a_value);
-  __cxx_atomic_assign_volatile(__a->__a_value, _Tp(__old | __pattern));
-  __a->__unlock();
-  return __old;
-}
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_or(__cxx_atomic_lock_impl<_Tp>* __a,
-                          _Tp __pattern, memory_order) {
-  __a->__lock();
-  _Tp __old = __a->__a_value;
-  __a->__a_value |= __pattern;
-  __a->__unlock();
-  return __old;
-}
-
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_xor(volatile __cxx_atomic_lock_impl<_Tp>* __a,
-                           _Tp __pattern, memory_order) {
-  __a->__lock();
-  _Tp __old;
-  __cxx_atomic_assign_volatile(__old, __a->__a_value);
-  __cxx_atomic_assign_volatile(__a->__a_value, _Tp(__old ^ __pattern));
-  __a->__unlock();
-  return __old;
-}
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp __cxx_atomic_fetch_xor(__cxx_atomic_lock_impl<_Tp>* __a,
-                           _Tp __pattern, memory_order) {
-  __a->__lock();
-  _Tp __old = __a->__a_value;
-  __a->__a_value ^= __pattern;
-  __a->__unlock();
-  return __old;
-}
-
-template <typename _Tp,
-          typename _Base = typename conditional<__libcpp_is_always_lock_free<_Tp>::__value,
-                                                __cxx_atomic_base_impl<_Tp>,
-                                                __cxx_atomic_lock_impl<_Tp> >::type>
-#else
-template <typename _Tp,
-          typename _Base = __cxx_atomic_base_impl<_Tp> >
-#endif //_LIBCPP_ATOMIC_ONLY_USE_BUILTINS
+template <typename _Tp, typename _Base = __cxx_atomic_base_impl<_Tp> >
 struct __cxx_atomic_impl : public _Base {
-    static_assert(is_trivially_copyable<_Tp>::value,
-      "std::atomic<T> requires that 'T' be a trivially copyable type");
+  static_assert(is_trivially_copyable<_Tp>::value, "std::atomic<T> requires that 'T' be a trivially copyable type");
 
   _LIBCPP_HIDE_FROM_ABI __cxx_atomic_impl() _NOEXCEPT = default;
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __cxx_atomic_impl(_Tp __value) _NOEXCEPT
-    : _Base(__value) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __cxx_atomic_impl(_Tp __value) _NOEXCEPT : _Base(__value) {}
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__atomic/fence.h b/third_party/libcxx/__atomic/fence.h
index c62f38f21..8c27ea54d 100644
--- a/third_party/libcxx/__atomic/fence.h
+++ b/third_party/libcxx/__atomic/fence.h
@@ -19,19 +19,9 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-inline _LIBCPP_HIDE_FROM_ABI
-void
-atomic_thread_fence(memory_order __m) _NOEXCEPT
-{
-    __cxx_atomic_thread_fence(__m);
-}
+inline _LIBCPP_HIDE_FROM_ABI void atomic_thread_fence(memory_order __m) _NOEXCEPT { __cxx_atomic_thread_fence(__m); }
 
-inline _LIBCPP_HIDE_FROM_ABI
-void
-atomic_signal_fence(memory_order __m) _NOEXCEPT
-{
-    __cxx_atomic_signal_fence(__m);
-}
+inline _LIBCPP_HIDE_FROM_ABI void atomic_signal_fence(memory_order __m) _NOEXCEPT { __cxx_atomic_signal_fence(__m); }
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__atomic/is_always_lock_free.h b/third_party/libcxx/__atomic/is_always_lock_free.h
index fbbd43707..f928e79f7 100644
--- a/third_party/libcxx/__atomic/is_always_lock_free.h
+++ b/third_party/libcxx/__atomic/is_always_lock_free.h
@@ -20,7 +20,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _Tp>
 struct __libcpp_is_always_lock_free {
   // __atomic_always_lock_free is available in all Standard modes
-  static const bool __value = __atomic_always_lock_free(sizeof(_Tp), 0);
+  static const bool __value = __atomic_always_lock_free(sizeof(_Tp), nullptr);
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__atomic/kill_dependency.h b/third_party/libcxx/__atomic/kill_dependency.h
index 1bd5c8ca7..103d52d35 100644
--- a/third_party/libcxx/__atomic/kill_dependency.h
+++ b/third_party/libcxx/__atomic/kill_dependency.h
@@ -18,10 +18,8 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp kill_dependency(_Tp __y) _NOEXCEPT
-{
-    return __y;
+_LIBCPP_HIDE_FROM_ABI _Tp kill_dependency(_Tp __y) _NOEXCEPT {
+  return __y;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__atomic/memory_order.h b/third_party/libcxx/__atomic/memory_order.h
index 3671dc3cf..294121d1c 100644
--- a/third_party/libcxx/__atomic/memory_order.h
+++ b/third_party/libcxx/__atomic/memory_order.h
@@ -22,14 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // Figure out what the underlying type for `memory_order` would be if it were
 // declared as an unscoped enum (accounting for -fshort-enums). Use this result
 // to pin the underlying type in C++20.
-enum __legacy_memory_order {
-    __mo_relaxed,
-    __mo_consume,
-    __mo_acquire,
-    __mo_release,
-    __mo_acq_rel,
-    __mo_seq_cst
-};
+enum __legacy_memory_order { __mo_relaxed, __mo_consume, __mo_acquire, __mo_release, __mo_acq_rel, __mo_seq_cst };
 
 using __memory_order_underlying_t = underlying_type<__legacy_memory_order>::type;
 
@@ -44,8 +37,8 @@ enum class memory_order : __memory_order_underlying_t {
   seq_cst = __mo_seq_cst
 };
 
-static_assert((is_same<underlying_type<memory_order>::type, __memory_order_underlying_t>::value),
-  "unexpected underlying type for std::memory_order");
+static_assert(is_same<underlying_type<memory_order>::type, __memory_order_underlying_t>::value,
+              "unexpected underlying type for std::memory_order");
 
 inline constexpr auto memory_order_relaxed = memory_order::relaxed;
 inline constexpr auto memory_order_consume = memory_order::consume;
diff --git a/third_party/libcxx/__atomic/to_gcc_order.h b/third_party/libcxx/__atomic/to_gcc_order.h
new file mode 100644
index 000000000..d04c111ad
--- /dev/null
+++ b/third_party/libcxx/__atomic/to_gcc_order.h
@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ATOMIC_TO_GCC_ORDER_H
+#define _LIBCPP___ATOMIC_TO_GCC_ORDER_H
+
+#include <__atomic/memory_order.h>
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if defined(__ATOMIC_RELAXED) && defined(__ATOMIC_CONSUME) && defined(__ATOMIC_ACQUIRE) &&                             \
+    defined(__ATOMIC_RELEASE) && defined(__ATOMIC_ACQ_REL) && defined(__ATOMIC_SEQ_CST)
+
+_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR int __to_gcc_order(memory_order __order) {
+  // Avoid switch statement to make this a constexpr.
+  return __order == memory_order_relaxed
+           ? __ATOMIC_RELAXED
+           : (__order == memory_order_acquire
+                  ? __ATOMIC_ACQUIRE
+                  : (__order == memory_order_release
+                         ? __ATOMIC_RELEASE
+                         : (__order == memory_order_seq_cst
+                                ? __ATOMIC_SEQ_CST
+                                : (__order == memory_order_acq_rel ? __ATOMIC_ACQ_REL : __ATOMIC_CONSUME))));
+}
+
+_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR int __to_gcc_failure_order(memory_order __order) {
+  // Avoid switch statement to make this a constexpr.
+  return __order == memory_order_relaxed
+           ? __ATOMIC_RELAXED
+           : (__order == memory_order_acquire
+                  ? __ATOMIC_ACQUIRE
+                  : (__order == memory_order_release
+                         ? __ATOMIC_RELAXED
+                         : (__order == memory_order_seq_cst
+                                ? __ATOMIC_SEQ_CST
+                                : (__order == memory_order_acq_rel ? __ATOMIC_ACQUIRE : __ATOMIC_CONSUME))));
+}
+
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ATOMIC_TO_GCC_ORDER_H
diff --git a/third_party/libcxx/__availability b/third_party/libcxx/__availability
deleted file mode 100644
index 3c4c5cc7b..000000000
--- a/third_party/libcxx/__availability
+++ /dev/null
@@ -1,348 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___AVAILABILITY
-#define _LIBCPP___AVAILABILITY
-
-#include <__config>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-// Libc++ is shipped by various vendors. In particular, it is used as a system
-// library on macOS, iOS and other Apple platforms. In order for users to be
-// able to compile a binary that is intended to be deployed to an older version
-// of a platform, Clang provides availability attributes [1]. These attributes
-// can be placed on declarations and are used to describe the life cycle of a
-// symbol in the library.
-//
-// The main goal is to ensure a compile-time error if a symbol that hasn't been
-// introduced in a previously released library is used in a program that targets
-// that previously released library. Normally, this would be a load-time error
-// when one tries to launch the program against the older library.
-//
-// For example, the filesystem library was introduced in the dylib in macOS 10.15.
-// If a user compiles on a macOS 10.15 host but targets macOS 10.13 with their
-// program, the compiler would normally not complain (because the required
-// declarations are in the headers), but the dynamic loader would fail to find
-// the symbols when actually trying to launch the program on macOS 10.13. To
-// turn this into a compile-time issue instead, declarations are annotated with
-// when they were introduced, and the compiler can produce a diagnostic if the
-// program references something that isn't available on the deployment target.
-//
-// This mechanism is general in nature, and any vendor can add their markup to
-// the library (see below). Whenever a new feature is added that requires support
-// in the shared library, two macros are added below to allow marking the feature
-// as unavailable:
-// 1. A macro named `_LIBCPP_AVAILABILITY_HAS_NO_<feature>` which must be defined
-//    exactly when compiling for a target that doesn't support the feature.
-// 2. A macro named `_LIBCPP_AVAILABILITY_<feature>`, which must always be defined
-//    and must expand to the proper availability attribute for the platform.
-//
-// When vendors decide to ship the feature as part of their shared library, they
-// can update these macros appropriately for their platform, and the library will
-// use those to provide an optimal user experience.
-//
-// Furthermore, many features in the standard library have corresponding
-// feature-test macros. The `_LIBCPP_AVAILABILITY_HAS_NO_<feature>` macros
-// are checked by the corresponding feature-test macros generated by
-// generate_feature_test_macro_components.py to ensure that the library
-// doesn't announce a feature as being implemented if it is unavailable on
-// the deployment target.
-//
-// Note that this mechanism is disabled by default in the "upstream" libc++.
-// Availability annotations are only meaningful when shipping libc++ inside
-// a platform (i.e. as a system library), and so vendors that want them should
-// turn those annotations on at CMake configuration time.
-//
-// [1]: https://clang.llvm.org/docs/AttributeReference.html#availability
-
-
-// For backwards compatibility, allow users to define _LIBCPP_DISABLE_AVAILABILITY
-// for a while.
-#if defined(_LIBCPP_DISABLE_AVAILABILITY)
-#   if !defined(_LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
-#       define _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
-#   endif
-#endif
-
-// Availability markup is disabled when building the library, or when the compiler
-// doesn't support the proper attributes.
-#if defined(_LIBCPP_BUILDING_LIBRARY) ||                                        \
-    defined(_LIBCXXABI_BUILDING_LIBRARY) ||                                     \
-    !__has_feature(attribute_availability_with_strict) ||                       \
-    !__has_feature(attribute_availability_in_templates) ||                      \
-    !__has_extension(pragma_clang_attribute_external_declaration)
-#   if !defined(_LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
-#       define _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
-#   endif
-#endif
-
-#if defined(_LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
-
-    // This controls the availability of std::shared_mutex and std::shared_timed_mutex,
-    // which were added to the dylib later.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX
-#   define _LIBCPP_AVAILABILITY_SHARED_MUTEX
-
-    // These macros control the availability of std::bad_optional_access and
-    // other exception types. These were put in the shared library to prevent
-    // code bloat from every user program defining the vtable for these exception
-    // types.
-    //
-    // Note that when exceptions are disabled, the methods that normally throw
-    // these exceptions can be used even on older deployment targets, but those
-    // methods will abort instead of throwing.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_BAD_OPTIONAL_ACCESS
-#   define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
-
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_BAD_VARIANT_ACCESS
-#   define _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS
-
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_BAD_ANY_CAST
-#   define _LIBCPP_AVAILABILITY_BAD_ANY_CAST
-
-    // This controls the availability of std::uncaught_exceptions().
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_UNCAUGHT_EXCEPTIONS
-#   define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS
-
-    // This controls the availability of the sized version of ::operator delete,
-    // ::operator delete[], and their align_val_t variants, which were all added
-    // in C++17, and hence not present in early dylibs.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_SIZED_NEW_DELETE
-#   define _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE
-
-    // This controls the availability of the std::future_error exception.
-    //
-    // Note that when exceptions are disabled, the methods that normally throw
-    // std::future_error can be used even on older deployment targets, but those
-    // methods will abort instead of throwing.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_FUTURE_ERROR
-#   define _LIBCPP_AVAILABILITY_FUTURE_ERROR
-
-    // This controls the availability of std::type_info's vtable.
-    // I can't imagine how using std::type_info can work at all if
-    // this isn't supported.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_TYPEINFO_VTABLE
-#   define _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
-
-    // This controls the availability of std::locale::category members
-    // (e.g. std::locale::collate), which are defined in the dylib.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_LOCALE_CATEGORY
-#   define _LIBCPP_AVAILABILITY_LOCALE_CATEGORY
-
-    // This controls the availability of atomic operations on std::shared_ptr
-    // (e.g. `std::atomic_store(std::shared_ptr)`), which require a shared
-    // lock table located in the dylib.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_ATOMIC_SHARED_PTR
-#   define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-
-    // These macros control the availability of all parts of <filesystem> that
-    // depend on something in the dylib.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_FILESYSTEM
-#   define _LIBCPP_AVAILABILITY_FILESYSTEM
-#   define _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
-#   define _LIBCPP_AVAILABILITY_FILESYSTEM_POP
-
-    // This controls the availability of floating-point std::to_chars functions.
-    // These overloads were added later than the integer overloads.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_TO_CHARS_FLOATING_POINT
-#   define _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT
-
-    // This controls the availability of the C++20 synchronization library,
-    // which requires shared library support for various operations
-    // (see libcxx/src/atomic.cpp). This includes <barier>, <latch>,
-    // <semaphore>, and notification functions on std::atomic.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_SYNC
-#   define _LIBCPP_AVAILABILITY_SYNC
-
-    // This controls whether the library claims to provide a default verbose
-    // termination function, and consequently whether the headers will try
-    // to use it when the mechanism isn't overriden at compile-time.
-// #   define _LIBCPP_AVAILABILITY_HAS_NO_VERBOSE_ABORT
-#   define _LIBCPP_AVAILABILITY_VERBOSE_ABORT
-
-#elif defined(__APPLE__)
-
-    // shared_mutex and shared_timed_mutex
-#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \
-        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \
-        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) ||         \
-        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX
-#   endif
-#   define _LIBCPP_AVAILABILITY_SHARED_MUTEX                                    \
-        __attribute__((availability(macos,strict,introduced=10.12)))            \
-        __attribute__((availability(ios,strict,introduced=10.0)))               \
-        __attribute__((availability(tvos,strict,introduced=10.0)))              \
-        __attribute__((availability(watchos,strict,introduced=3.0)))
-
-        // bad_optional_access, bad_variant_access and bad_any_cast
-        // Note: bad_optional_access & friends were not introduced in the matching
-        // macOS and iOS versions, so the version mismatch between macOS and others
-        // is intended.
-#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101300) ||    \
-        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 120000) || \
-        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 120000) ||         \
-        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 50000)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_BAD_OPTIONAL_ACCESS
-#       define _LIBCPP_AVAILABILITY_HAS_NO_BAD_VARIANT_ACCESS
-#       define _LIBCPP_AVAILABILITY_HAS_NO_BAD_ANY_CAST
-#   endif
-#   define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS                             \
-        __attribute__((availability(macos,strict,introduced=10.13)))            \
-        __attribute__((availability(ios,strict,introduced=12.0)))               \
-        __attribute__((availability(tvos,strict,introduced=12.0)))              \
-        __attribute__((availability(watchos,strict,introduced=5.0)))
-#   define _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS                              \
-        _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
-#   define _LIBCPP_AVAILABILITY_BAD_ANY_CAST                                    \
-        _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
-
-    // uncaught_exceptions
-#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \
-        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \
-        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) ||         \
-        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_UNCAUGHT_EXCEPTIONS
-#   endif
-#   define _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS                             \
-        __attribute__((availability(macos,strict,introduced=10.12)))            \
-        __attribute__((availability(ios,strict,introduced=10.0)))               \
-        __attribute__((availability(tvos,strict,introduced=10.0)))              \
-        __attribute__((availability(watchos,strict,introduced=3.0)))
-
-    // sized operator new and sized operator delete
-#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) ||    \
-        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \
-        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) ||         \
-        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_SIZED_NEW_DELETE
-#   endif
-#   define _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE                                \
-        __attribute__((availability(macos,strict,introduced=10.12)))            \
-        __attribute__((availability(ios,strict,introduced=10.0)))               \
-        __attribute__((availability(tvos,strict,introduced=10.0)))              \
-        __attribute__((availability(watchos,strict,introduced=3.0)))
-
-    // future_error
-#   if (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 60000)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_FUTURE_ERROR
-#   endif
-#   define _LIBCPP_AVAILABILITY_FUTURE_ERROR                                    \
-        __attribute__((availability(ios,strict,introduced=6.0)))
-
-    // type_info's vtable
-#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 100900) ||    \
-        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 70000)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_TYPEINFO_VTABLE
-#   endif
-#   define _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE                                 \
-        __attribute__((availability(macos,strict,introduced=10.9)))             \
-        __attribute__((availability(ios,strict,introduced=7.0)))
-
-    // locale::category
-#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 100900) ||    \
-        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 70000)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_LOCALE_CATEGORY
-#   endif
-#   define _LIBCPP_AVAILABILITY_LOCALE_CATEGORY                                 \
-        __attribute__((availability(macos,strict,introduced=10.9)))             \
-        __attribute__((availability(ios,strict,introduced=7.0)))
-
-    // atomic operations on shared_ptr
-#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 100900) ||    \
-        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 70000)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_ATOMIC_SHARED_PTR
-#   endif
-#   define _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR                               \
-        __attribute__((availability(macos,strict,introduced=10.9)))             \
-        __attribute__((availability(ios,strict,introduced=7.0)))
-
-    // <filesystem>
-#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101500) ||    \
-        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 130000) || \
-        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 130000) ||         \
-        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 60000)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_FILESYSTEM
-#   endif
-#   define _LIBCPP_AVAILABILITY_FILESYSTEM                                      \
-        __attribute__((availability(macos,strict,introduced=10.15)))            \
-        __attribute__((availability(ios,strict,introduced=13.0)))               \
-        __attribute__((availability(tvos,strict,introduced=13.0)))              \
-        __attribute__((availability(watchos,strict,introduced=6.0)))
-#   define _LIBCPP_AVAILABILITY_FILESYSTEM_PUSH                                 \
-        _Pragma("clang attribute push(__attribute__((availability(macos,strict,introduced=10.15))), apply_to=any(function,record))") \
-        _Pragma("clang attribute push(__attribute__((availability(ios,strict,introduced=13.0))), apply_to=any(function,record))")    \
-        _Pragma("clang attribute push(__attribute__((availability(tvos,strict,introduced=13.0))), apply_to=any(function,record))")   \
-        _Pragma("clang attribute push(__attribute__((availability(watchos,strict,introduced=6.0))), apply_to=any(function,record))")
-#   define _LIBCPP_AVAILABILITY_FILESYSTEM_POP                                  \
-        _Pragma("clang attribute pop")                                          \
-        _Pragma("clang attribute pop")                                          \
-        _Pragma("clang attribute pop")                                          \
-        _Pragma("clang attribute pop")
-
-    // std::to_chars(floating-point)
-#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 130300) ||    \
-        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 160300) || \
-        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 160300) ||         \
-        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 90300)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_TO_CHARS_FLOATING_POINT
-#   endif
-#   define _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT                         \
-        __attribute__((availability(macos,strict,introduced=13.3)))             \
-        __attribute__((availability(ios,strict,introduced=16.3)))               \
-        __attribute__((availability(tvos,strict,introduced=16.3)))              \
-        __attribute__((availability(watchos,strict,introduced=9.3)))
-
-    // c++20 synchronization library
-#   if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 110000) ||    \
-        (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 140000) || \
-        (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 140000) ||         \
-        (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 70000)
-#       define _LIBCPP_AVAILABILITY_HAS_NO_SYNC
-#   endif
-#   define _LIBCPP_AVAILABILITY_SYNC                                            \
-        __attribute__((availability(macos,strict,introduced=11.0)))             \
-        __attribute__((availability(ios,strict,introduced=14.0)))               \
-        __attribute__((availability(tvos,strict,introduced=14.0)))              \
-        __attribute__((availability(watchos,strict,introduced=7.0)))
-
-    // __libcpp_verbose_abort
-#   if 1 // TODO: Update once this is released
-#       define _LIBCPP_AVAILABILITY_HAS_NO_VERBOSE_ABORT
-#   endif
-#   define _LIBCPP_AVAILABILITY_VERBOSE_ABORT                                   \
-        __attribute__((unavailable))
-
-#else
-
-// ...New vendors can add availability markup here...
-
-#   error "It looks like you're trying to enable vendor availability markup, but you haven't defined the corresponding macros yet!"
-
-#endif
-
-// Define availability attributes that depend on _LIBCPP_HAS_NO_EXCEPTIONS.
-// Those are defined in terms of the availability attributes above, and
-// should not be vendor-specific.
-#if defined(_LIBCPP_HAS_NO_EXCEPTIONS)
-#   define _LIBCPP_AVAILABILITY_FUTURE
-#   define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
-#   define _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-#   define _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-#else
-#   define _LIBCPP_AVAILABILITY_FUTURE                    _LIBCPP_AVAILABILITY_FUTURE_ERROR
-#   define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST        _LIBCPP_AVAILABILITY_BAD_ANY_CAST
-#   define _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
-#   define _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS  _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS
-#endif
-
-#endif // _LIBCPP___AVAILABILITY
diff --git a/third_party/libcxx/__bit/bit_cast.h b/third_party/libcxx/__bit/bit_cast.h
index 39842465e..cd0456738 100644
--- a/third_party/libcxx/__bit/bit_cast.h
+++ b/third_party/libcxx/__bit/bit_cast.h
@@ -19,13 +19,21 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _ToType, class _FromType>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI constexpr _ToType __bit_cast(const _FromType& __from) noexcept {
+  return __builtin_bit_cast(_ToType, __from);
+}
+
+#endif // _LIBCPP_CXX03_LANG
+
 #if _LIBCPP_STD_VER >= 20
 
 template <class _ToType, class _FromType>
-  requires(sizeof(_ToType) == sizeof(_FromType) &&
-           is_trivially_copyable_v<_ToType> &&
+  requires(sizeof(_ToType) == sizeof(_FromType) && is_trivially_copyable_v<_ToType> &&
            is_trivially_copyable_v<_FromType>)
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr _ToType bit_cast(const _FromType& __from) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _ToType bit_cast(const _FromType& __from) noexcept {
   return __builtin_bit_cast(_ToType, __from);
 }
 
diff --git a/third_party/libcxx/__bit/bit_ceil.h b/third_party/libcxx/__bit/bit_ceil.h
index 1332900ae..cfd792dc2 100644
--- a/third_party/libcxx/__bit/bit_ceil.h
+++ b/third_party/libcxx/__bit/bit_ceil.h
@@ -21,25 +21,33 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER >= 20
+#if _LIBCPP_STD_VER >= 17
 
-template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp bit_ceil(_Tp __t) noexcept {
+template <class _Tp>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp __bit_ceil(_Tp __t) noexcept {
   if (__t < 2)
     return 1;
-  const unsigned __n = numeric_limits<_Tp>::digits - std::countl_zero((_Tp)(__t - 1u));
-  _LIBCPP_ASSERT(__n != numeric_limits<_Tp>::digits, "Bad input to bit_ceil");
+  const unsigned __n = numeric_limits<_Tp>::digits - std::__countl_zero((_Tp)(__t - 1u));
+  _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__n != numeric_limits<_Tp>::digits, "Bad input to bit_ceil");
 
   if constexpr (sizeof(_Tp) >= sizeof(unsigned))
     return _Tp{1} << __n;
   else {
-    const unsigned __extra = numeric_limits<unsigned>::digits - numeric_limits<_Tp>::digits;
+    const unsigned __extra   = numeric_limits<unsigned>::digits - numeric_limits<_Tp>::digits;
     const unsigned __ret_val = 1u << (__n + __extra);
     return (_Tp)(__ret_val >> __extra);
   }
 }
 
-#endif // _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
+
+template <__libcpp_unsigned_integer _Tp>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp bit_ceil(_Tp __t) noexcept {
+  return std::__bit_ceil(__t);
+}
+
+#  endif // _LIBCPP_STD_VER >= 20
+#endif   // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__bit/bit_floor.h b/third_party/libcxx/__bit/bit_floor.h
index b2e38092f..133e36950 100644
--- a/third_party/libcxx/__bit/bit_floor.h
+++ b/third_party/libcxx/__bit/bit_floor.h
@@ -23,7 +23,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp bit_floor(_Tp __t) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp bit_floor(_Tp __t) noexcept {
   return __t == 0 ? 0 : _Tp{1} << std::__bit_log2(__t);
 }
 
diff --git a/third_party/libcxx/__bit/bit_width.h b/third_party/libcxx/__bit/bit_width.h
index 4381f227f..853e48177 100644
--- a/third_party/libcxx/__bit/bit_width.h
+++ b/third_party/libcxx/__bit/bit_width.h
@@ -22,7 +22,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr int bit_width(_Tp __t) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int bit_width(_Tp __t) noexcept {
   return __t == 0 ? 0 : std::__bit_log2(__t) + 1;
 }
 
diff --git a/third_party/libcxx/__bit/blsr.h b/third_party/libcxx/__bit/blsr.h
index de991e9ad..76bd521f5 100644
--- a/third_party/libcxx/__bit/blsr.h
+++ b/third_party/libcxx/__bit/blsr.h
@@ -17,15 +17,15 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unsigned __libcpp_blsr(unsigned __x) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unsigned __libcpp_blsr(unsigned __x) _NOEXCEPT {
   return __x ^ (__x & -__x);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unsigned long __libcpp_blsr(unsigned long __x) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unsigned long __libcpp_blsr(unsigned long __x) _NOEXCEPT {
   return __x ^ (__x & -__x);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR unsigned long long __libcpp_blsr(unsigned long long __x) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unsigned long long __libcpp_blsr(unsigned long long __x) _NOEXCEPT {
   return __x ^ (__x & -__x);
 }
 
diff --git a/third_party/libcxx/__bit/byteswap.h b/third_party/libcxx/__bit/byteswap.h
index b290e80a5..6225ecf2f 100644
--- a/third_party/libcxx/__bit/byteswap.h
+++ b/third_party/libcxx/__bit/byteswap.h
@@ -23,8 +23,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 23
 
 template <integral _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp byteswap(_Tp __val) noexcept {
-
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp byteswap(_Tp __val) noexcept {
   if constexpr (sizeof(_Tp) == 1) {
     return __val;
   } else if constexpr (sizeof(_Tp) == 2) {
@@ -33,15 +32,15 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Tp byteswap(_Tp __val) noexcept {
     return __builtin_bswap32(__val);
   } else if constexpr (sizeof(_Tp) == 8) {
     return __builtin_bswap64(__val);
-#ifndef _LIBCPP_HAS_NO_INT128
+#  ifndef _LIBCPP_HAS_NO_INT128
   } else if constexpr (sizeof(_Tp) == 16) {
-#if __has_builtin(__builtin_bswap128)
+#    if __has_builtin(__builtin_bswap128)
     return __builtin_bswap128(__val);
-#else
+#    else
     return static_cast<_Tp>(byteswap(static_cast<uint64_t>(__val))) << 64 |
            static_cast<_Tp>(byteswap(static_cast<uint64_t>(__val >> 64)));
-#endif // __has_builtin(__builtin_bswap128)
-#endif // _LIBCPP_HAS_NO_INT128
+#    endif // __has_builtin(__builtin_bswap128)
+#  endif   // _LIBCPP_HAS_NO_INT128
   } else {
     static_assert(sizeof(_Tp) == 0, "byteswap is unimplemented for integral types of this size");
   }
diff --git a/third_party/libcxx/__bit/countl.h b/third_party/libcxx/__bit/countl.h
index 86eaee0c1..998a0b44c 100644
--- a/third_party/libcxx/__bit/countl.h
+++ b/third_party/libcxx/__bit/countl.h
@@ -6,6 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
+// TODO: __builtin_clzg is available since Clang 19 and GCC 14. When support for older versions is dropped, we can
+//  refactor this code to exclusively use __builtin_clzg.
+
 #ifndef _LIBCPP___BIT_COUNTL_H
 #define _LIBCPP___BIT_COUNTL_H
 
@@ -24,18 +27,23 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __libcpp_clz(unsigned __x)           _NOEXCEPT { return __builtin_clz(__x); }
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __libcpp_clz(unsigned __x) _NOEXCEPT {
+  return __builtin_clz(__x);
+}
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __libcpp_clz(unsigned long __x)      _NOEXCEPT { return __builtin_clzl(__x); }
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __libcpp_clz(unsigned long __x) _NOEXCEPT {
+  return __builtin_clzl(__x);
+}
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __libcpp_clz(unsigned long long __x) _NOEXCEPT { return __builtin_clzll(__x); }
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __libcpp_clz(unsigned long long __x) _NOEXCEPT {
+  return __builtin_clzll(__x);
+}
 
-#  ifndef _LIBCPP_HAS_NO_INT128
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __libcpp_clz(__uint128_t __x) _NOEXCEPT {
+#ifndef _LIBCPP_HAS_NO_INT128
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __libcpp_clz(__uint128_t __x) _NOEXCEPT {
+#  if __has_builtin(__builtin_clzg)
+  return __builtin_clzg(__x);
+#  else
   // The function is written in this form due to C++ constexpr limitations.
   // The algorithm:
   // - Test whether any bit in the high 64-bits is set
@@ -45,53 +53,54 @@ int __libcpp_clz(__uint128_t __x) _NOEXCEPT {
   // - Any bits set:
   //   - The number of leading zeros of the input is the number of leading
   //     zeros in the high 64-bits.
-  return ((__x >> 64) == 0)
-           ? (64 + __builtin_clzll(static_cast<unsigned long long>(__x)))
-           : __builtin_clzll(static_cast<unsigned long long>(__x >> 64));
+  return ((__x >> 64) == 0) ? (64 + __builtin_clzll(static_cast<unsigned long long>(__x)))
+                            : __builtin_clzll(static_cast<unsigned long long>(__x >> 64));
+#  endif
 }
-#  endif // _LIBCPP_HAS_NO_INT128
+#endif // _LIBCPP_HAS_NO_INT128
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-int __countl_zero(_Tp __t) _NOEXCEPT
-{
-    static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__countl_zero requires an unsigned integer type");
-    if (__t == 0)
-        return numeric_limits<_Tp>::digits;
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int __countl_zero(_Tp __t) _NOEXCEPT {
+  static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__countl_zero requires an unsigned integer type");
+#if __has_builtin(__builtin_clzg)
+  return __builtin_clzg(__t, numeric_limits<_Tp>::digits);
+#else  // __has_builtin(__builtin_clzg)
+  if (__t == 0)
+    return numeric_limits<_Tp>::digits;
 
-    if      (sizeof(_Tp) <= sizeof(unsigned int))
-        return std::__libcpp_clz(static_cast<unsigned int>(__t))
-              - (numeric_limits<unsigned int>::digits - numeric_limits<_Tp>::digits);
-    else if (sizeof(_Tp) <= sizeof(unsigned long))
-        return std::__libcpp_clz(static_cast<unsigned long>(__t))
-              - (numeric_limits<unsigned long>::digits - numeric_limits<_Tp>::digits);
-    else if (sizeof(_Tp) <= sizeof(unsigned long long))
-        return std::__libcpp_clz(static_cast<unsigned long long>(__t))
-              - (numeric_limits<unsigned long long>::digits - numeric_limits<_Tp>::digits);
-    else
-    {
-        int __ret = 0;
-        int __iter = 0;
-        const unsigned int __ulldigits = numeric_limits<unsigned long long>::digits;
-        while (true) {
-            __t = std::__rotr(__t, __ulldigits);
-            if ((__iter = std::__countl_zero(static_cast<unsigned long long>(__t))) != __ulldigits)
-                break;
-            __ret += __iter;
-            }
-        return __ret + __iter;
+  if (sizeof(_Tp) <= sizeof(unsigned int))
+    return std::__libcpp_clz(static_cast<unsigned int>(__t)) -
+           (numeric_limits<unsigned int>::digits - numeric_limits<_Tp>::digits);
+  else if (sizeof(_Tp) <= sizeof(unsigned long))
+    return std::__libcpp_clz(static_cast<unsigned long>(__t)) -
+           (numeric_limits<unsigned long>::digits - numeric_limits<_Tp>::digits);
+  else if (sizeof(_Tp) <= sizeof(unsigned long long))
+    return std::__libcpp_clz(static_cast<unsigned long long>(__t)) -
+           (numeric_limits<unsigned long long>::digits - numeric_limits<_Tp>::digits);
+  else {
+    int __ret                      = 0;
+    int __iter                     = 0;
+    const unsigned int __ulldigits = numeric_limits<unsigned long long>::digits;
+    while (true) {
+      __t = std::__rotl(__t, __ulldigits);
+      if ((__iter = std::__countl_zero(static_cast<unsigned long long>(__t))) != __ulldigits)
+        break;
+      __ret += __iter;
     }
+    return __ret + __iter;
+  }
+#endif // __has_builtin(__builtin_clzg)
 }
 
 #if _LIBCPP_STD_VER >= 20
 
 template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr int countl_zero(_Tp __t) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countl_zero(_Tp __t) noexcept {
   return std::__countl_zero(__t);
 }
 
 template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr int countl_one(_Tp __t) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countl_one(_Tp __t) noexcept {
   return __t != numeric_limits<_Tp>::max() ? std::countl_zero(static_cast<_Tp>(~__t)) : numeric_limits<_Tp>::digits;
 }
 
diff --git a/third_party/libcxx/__bit/countr.h b/third_party/libcxx/__bit/countr.h
index d3ca5b6c9..9e92021fb 100644
--- a/third_party/libcxx/__bit/countr.h
+++ b/third_party/libcxx/__bit/countr.h
@@ -6,6 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
+// TODO: __builtin_ctzg is available since Clang 19 and GCC 14. When support for older versions is dropped, we can
+//  refactor this code to exclusively use __builtin_ctzg.
+
 #ifndef _LIBCPP___BIT_COUNTR_H
 #define _LIBCPP___BIT_COUNTR_H
 
@@ -23,22 +26,25 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __libcpp_ctz(unsigned __x)           _NOEXCEPT { return __builtin_ctz(__x); }
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __libcpp_ctz(unsigned __x) _NOEXCEPT {
+  return __builtin_ctz(__x);
+}
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __libcpp_ctz(unsigned long __x)      _NOEXCEPT { return __builtin_ctzl(__x); }
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __libcpp_ctz(unsigned long __x) _NOEXCEPT {
+  return __builtin_ctzl(__x);
+}
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __libcpp_ctz(unsigned long long __x) _NOEXCEPT { return __builtin_ctzll(__x); }
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __libcpp_ctz(unsigned long long __x) _NOEXCEPT {
+  return __builtin_ctzll(__x);
+}
 
-#if _LIBCPP_STD_VER >= 20
-
-template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr int countr_zero(_Tp __t) noexcept {
+template <class _Tp>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int __countr_zero(_Tp __t) _NOEXCEPT {
+#if __has_builtin(__builtin_ctzg)
+  return __builtin_ctzg(__t, numeric_limits<_Tp>::digits);
+#else  // __has_builtin(__builtin_ctzg)
   if (__t == 0)
     return numeric_limits<_Tp>::digits;
-
   if (sizeof(_Tp) <= sizeof(unsigned int))
     return std::__libcpp_ctz(static_cast<unsigned int>(__t));
   else if (sizeof(_Tp) <= sizeof(unsigned long))
@@ -46,7 +52,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr int countr_zero(_Tp __t) noexcept {
   else if (sizeof(_Tp) <= sizeof(unsigned long long))
     return std::__libcpp_ctz(static_cast<unsigned long long>(__t));
   else {
-    int __ret = 0;
+    int __ret                      = 0;
     const unsigned int __ulldigits = numeric_limits<unsigned long long>::digits;
     while (static_cast<unsigned long long>(__t) == 0uLL) {
       __ret += __ulldigits;
@@ -54,10 +60,18 @@ _LIBCPP_HIDE_FROM_ABI constexpr int countr_zero(_Tp __t) noexcept {
     }
     return __ret + std::__libcpp_ctz(static_cast<unsigned long long>(__t));
   }
+#endif // __has_builtin(__builtin_ctzg)
+}
+
+#if _LIBCPP_STD_VER >= 20
+
+template <__libcpp_unsigned_integer _Tp>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countr_zero(_Tp __t) noexcept {
+  return std::__countr_zero(__t);
 }
 
 template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr int countr_one(_Tp __t) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countr_one(_Tp __t) noexcept {
   return __t != numeric_limits<_Tp>::max() ? std::countr_zero(static_cast<_Tp>(~__t)) : numeric_limits<_Tp>::digits;
 }
 
diff --git a/third_party/libcxx/__bit/endian.h b/third_party/libcxx/__bit/endian.h
index 52635f2d2..2d31e5ddf 100644
--- a/third_party/libcxx/__bit/endian.h
+++ b/third_party/libcxx/__bit/endian.h
@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 enum class endian {
   little = 0xDEAD,
-  big = 0xFACE,
+  big    = 0xFACE,
 #  if defined(_LIBCPP_LITTLE_ENDIAN)
   native = little
 #  elif defined(_LIBCPP_BIG_ENDIAN)
diff --git a/third_party/libcxx/__bit/has_single_bit.h b/third_party/libcxx/__bit/has_single_bit.h
index b89f5995b..52f5853a1 100644
--- a/third_party/libcxx/__bit/has_single_bit.h
+++ b/third_party/libcxx/__bit/has_single_bit.h
@@ -24,7 +24,7 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool has_single_bit(_Tp __t) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_single_bit(_Tp __t) noexcept {
   return __t != 0 && (((__t & (__t - 1)) == 0));
 }
 
diff --git a/third_party/libcxx/__bit/invert_if.h b/third_party/libcxx/__bit/invert_if.h
new file mode 100644
index 000000000..f7606ede2
--- /dev/null
+++ b/third_party/libcxx/__bit/invert_if.h
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___BIT_INVERT_IF_H
+#define _LIBCPP___BIT_INVERT_IF_H
+
+#include <__concepts/arithmetic.h>
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <bool _Invert, class _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __invert_if(_Tp __v) {
+  if (_Invert)
+    return ~__v;
+  return __v;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___BIT_INVERT_IF_H
diff --git a/third_party/libcxx/__bit/popcount.h b/third_party/libcxx/__bit/popcount.h
index 33b94cff7..5cf0a01d0 100644
--- a/third_party/libcxx/__bit/popcount.h
+++ b/third_party/libcxx/__bit/popcount.h
@@ -6,6 +6,9 @@
 //
 //===----------------------------------------------------------------------===//
 
+// TODO: __builtin_popcountg is available since Clang 19 and GCC 14. When support for older versions is dropped, we can
+//  refactor this code to exclusively use __builtin_popcountg.
+
 #ifndef _LIBCPP___BIT_POPCOUNT_H
 #define _LIBCPP___BIT_POPCOUNT_H
 
@@ -23,19 +26,25 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __libcpp_popcount(unsigned __x)           _NOEXCEPT { return __builtin_popcount(__x); }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __libcpp_popcount(unsigned __x) _NOEXCEPT {
+  return __builtin_popcount(__x);
+}
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __libcpp_popcount(unsigned long __x)      _NOEXCEPT { return __builtin_popcountl(__x); }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __libcpp_popcount(unsigned long __x) _NOEXCEPT {
+  return __builtin_popcountl(__x);
+}
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __libcpp_popcount(unsigned long long __x) _NOEXCEPT { return __builtin_popcountll(__x); }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __libcpp_popcount(unsigned long long __x) _NOEXCEPT {
+  return __builtin_popcountll(__x);
+}
 
 #if _LIBCPP_STD_VER >= 20
 
 template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr int popcount(_Tp __t) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int popcount(_Tp __t) noexcept {
+#  if __has_builtin(__builtin_popcountg)
+  return __builtin_popcountg(__t);
+#  else  // __has_builtin(__builtin_popcountg)
   if (sizeof(_Tp) <= sizeof(unsigned int))
     return std::__libcpp_popcount(static_cast<unsigned int>(__t));
   else if (sizeof(_Tp) <= sizeof(unsigned long))
@@ -50,6 +59,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr int popcount(_Tp __t) noexcept {
     }
     return __ret;
   }
+#  endif // __has_builtin(__builtin_popcountg)
 }
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__bit/rotate.h b/third_party/libcxx/__bit/rotate.h
index 5aa7518b3..d848056c3 100644
--- a/third_party/libcxx/__bit/rotate.h
+++ b/third_party/libcxx/__bit/rotate.h
@@ -20,29 +20,35 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp __rotr(_Tp __t, unsigned int __cnt) _NOEXCEPT
-{
-    static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__rotr requires an unsigned integer type");
-    const unsigned int __dig = numeric_limits<_Tp>::digits;
-    if ((__cnt % __dig) == 0)
-        return __t;
-    return (__t >> (__cnt % __dig)) | (__t << (__dig - (__cnt % __dig)));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __rotr(_Tp __t, int __cnt) _NOEXCEPT {
+  static_assert(__libcpp_is_unsigned_integer<_Tp>::value, "__rotr requires an unsigned integer type");
+  const unsigned int __dig = numeric_limits<_Tp>::digits;
+  if ((__cnt % __dig) == 0)
+    return __t;
+
+  if (__cnt < 0) {
+    __cnt *= -1;
+    return (__t << (__cnt % __dig)) | (__t >> (__dig - (__cnt % __dig))); // rotr with negative __cnt is similar to rotl
+  }
+
+  return (__t >> (__cnt % __dig)) | (__t << (__dig - (__cnt % __dig)));
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __rotl(_Tp __t, int __cnt) _NOEXCEPT {
+  return std::__rotr(__t, -__cnt);
 }
 
 #if _LIBCPP_STD_VER >= 20
 
 template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp rotl(_Tp __t, unsigned int __cnt) noexcept {
-  const unsigned int __dig = numeric_limits<_Tp>::digits;
-  if ((__cnt % __dig) == 0)
-    return __t;
-  return (__t << (__cnt % __dig)) | (__t >> (__dig - (__cnt % __dig)));
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotl(_Tp __t, int __cnt) noexcept {
+  return std::__rotl(__t, __cnt);
 }
 
 template <__libcpp_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp rotr(_Tp __t, unsigned int __cnt) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotr(_Tp __t, int __cnt) noexcept {
   return std::__rotr(__t, __cnt);
 }
 
diff --git a/third_party/libcxx/__bit_reference b/third_party/libcxx/__bit_reference
index 95188ff68..606069d98 100644
--- a/third_party/libcxx/__bit_reference
+++ b/third_party/libcxx/__bit_reference
@@ -14,8 +14,10 @@
 #include <__algorithm/fill_n.h>
 #include <__algorithm/min.h>
 #include <__bit/countr.h>
+#include <__bit/invert_if.h>
 #include <__bit/popcount.h>
 #include <__config>
+#include <__fwd/bit_reference.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
@@ -30,1330 +32,975 @@
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Cp, bool _IsConst, typename _Cp::__storage_type = 0> class __bit_iterator;
-template <class _Cp> class __bit_const_reference;
+template <class _Cp>
+class __bit_const_reference;
 
 template <class _Tp>
-struct __has_storage_type
-{
-    static const bool value = false;
+struct __has_storage_type {
+  static const bool value = false;
 };
 
 template <class _Cp, bool = __has_storage_type<_Cp>::value>
-class __bit_reference
-{
-    typedef typename _Cp::__storage_type    __storage_type;
-    typedef typename _Cp::__storage_pointer __storage_pointer;
+class __bit_reference {
+  using __storage_type    = typename _Cp::__storage_type;
+  using __storage_pointer = typename _Cp::__storage_pointer;
 
-    __storage_pointer __seg_;
-    __storage_type    __mask_;
+  __storage_pointer __seg_;
+  __storage_type __mask_;
 
-    friend typename _Cp::__self;
+  friend typename _Cp::__self;
+
+  friend class __bit_const_reference<_Cp>;
+  friend class __bit_iterator<_Cp, false>;
 
-    friend class __bit_const_reference<_Cp>;
-    friend class __bit_iterator<_Cp, false>;
 public:
-    using __container = typename _Cp::__self;
+  using __container = typename _Cp::__self;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    __bit_reference(const __bit_reference&) = default;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_reference(const __bit_reference&) = default;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 operator bool() const _NOEXCEPT
-        {return static_cast<bool>(*__seg_ & __mask_);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 bool operator ~() const _NOEXCEPT
-        {return !static_cast<bool>(*this);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 operator bool() const _NOEXCEPT {
+    return static_cast<bool>(*__seg_ & __mask_);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool operator~() const _NOEXCEPT {
+    return !static_cast<bool>(*this);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    __bit_reference& operator=(bool __x) _NOEXCEPT
-    {
-        if (__x)
-            *__seg_ |= __mask_;
-        else
-            *__seg_ &= ~__mask_;
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_reference& operator=(bool __x) _NOEXCEPT {
+    if (__x)
+      *__seg_ |= __mask_;
+    else
+      *__seg_ &= ~__mask_;
+    return *this;
+  }
 
 #if _LIBCPP_STD_VER >= 23
-    _LIBCPP_HIDE_FROM_ABI constexpr const __bit_reference& operator=(bool __x) const noexcept {
-        if (__x)
-            *__seg_ |= __mask_;
-        else
-            *__seg_ &= ~__mask_;
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr const __bit_reference& operator=(bool __x) const noexcept {
+    if (__x)
+      *__seg_ |= __mask_;
+    else
+      *__seg_ &= ~__mask_;
+    return *this;
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT
-        {return operator=(static_cast<bool>(__x));}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT {
+    return operator=(static_cast<bool>(__x));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void flip() _NOEXCEPT { *__seg_ ^= __mask_; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, false> operator&() const _NOEXCEPT {
+    return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(std::__libcpp_ctz(__mask_)));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void flip() _NOEXCEPT {*__seg_ ^= __mask_;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, false> operator&() const _NOEXCEPT
-        {return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(std::__libcpp_ctz(__mask_)));}
 private:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    explicit __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
-        : __seg_(__s), __mask_(__m) {}
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
+      : __seg_(__s),
+        __mask_(__m) {}
 };
 
 template <class _Cp>
-class __bit_reference<_Cp, false>
-{
-};
+class __bit_reference<_Cp, false> {};
 
 template <class _Cp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) _NOEXCEPT
-{
-    bool __t = __x;
-    __x = __y;
-    __y = __t;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) _NOEXCEPT {
+  bool __t = __x;
+  __x      = __y;
+  __y      = __t;
 }
 
 template <class _Cp, class _Dp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) _NOEXCEPT
-{
-    bool __t = __x;
-    __x = __y;
-    __y = __t;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) _NOEXCEPT {
+  bool __t = __x;
+  __x      = __y;
+  __y      = __t;
 }
 
 template <class _Cp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-swap(__bit_reference<_Cp> __x, bool& __y) _NOEXCEPT
-{
-    bool __t = __x;
-    __x = __y;
-    __y = __t;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(__bit_reference<_Cp> __x, bool& __y) _NOEXCEPT {
+  bool __t = __x;
+  __x      = __y;
+  __y      = __t;
 }
 
 template <class _Cp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-swap(bool& __x, __bit_reference<_Cp> __y) _NOEXCEPT
-{
-    bool __t = __x;
-    __x = __y;
-    __y = __t;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(bool& __x, __bit_reference<_Cp> __y) _NOEXCEPT {
+  bool __t = __x;
+  __x      = __y;
+  __y      = __t;
 }
 
 template <class _Cp>
-class __bit_const_reference
-{
-    typedef typename _Cp::__storage_type          __storage_type;
-    typedef typename _Cp::__const_storage_pointer __storage_pointer;
+class __bit_const_reference {
+  using __storage_type    = typename _Cp::__storage_type;
+  using __storage_pointer = typename _Cp::__const_storage_pointer;
 
-    __storage_pointer        __seg_;
-    __storage_type __mask_;
+  __storage_pointer __seg_;
+  __storage_type __mask_;
+
+  friend typename _Cp::__self;
+  friend class __bit_iterator<_Cp, true>;
 
-    friend typename _Cp::__self;
-    friend class __bit_iterator<_Cp, true>;
 public:
-    using __container = typename _Cp::__self;
+  using __container = typename _Cp::__self;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __bit_const_reference(const __bit_const_reference&) = default;
+  _LIBCPP_HIDE_FROM_ABI __bit_const_reference(const __bit_const_reference&) = default;
+  __bit_const_reference& operator=(const __bit_const_reference&)            = delete;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    __bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT
-        : __seg_(__x.__seg_), __mask_(__x.__mask_) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT
+      : __seg_(__x.__seg_),
+        __mask_(__x.__mask_) {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT
-        {return static_cast<bool>(*__seg_ & __mask_);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT {
+    return static_cast<bool>(*__seg_ & __mask_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, true> operator&() const _NOEXCEPT {
+    return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(std::__libcpp_ctz(__mask_)));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, true> operator&() const _NOEXCEPT
-        {return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(std::__libcpp_ctz(__mask_)));}
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR
-    explicit __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
-        : __seg_(__s), __mask_(__m) {}
-
-    __bit_const_reference& operator=(const __bit_const_reference&) = delete;
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR explicit __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
+      : __seg_(__s),
+        __mask_(__m) {}
 };
 
-// find
-
-template <class _Cp, bool _IsConst>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, _IsConst>
-__find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
-{
-    typedef __bit_iterator<_Cp, _IsConst> _It;
-    typedef typename _It::__storage_type __storage_type;
-    const int __bits_per_word = _It::__bits_per_word;
-    // do first partial word
-    if (__first.__ctz_ != 0)
-    {
-        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _VSTD::min(__clz_f, __n);
-        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-        __storage_type __b = *__first.__seg_ & __m;
-        if (__b)
-            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b)));
-        if (__n == __dn)
-            return __first + __n;
-        __n -= __dn;
-        ++__first.__seg_;
-    }
-    // do middle whole words
-    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
-        if (*__first.__seg_)
-            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(*__first.__seg_)));
-    // do last partial word
-    if (__n > 0)
-    {
-        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __storage_type __b = *__first.__seg_ & __m;
-        if (__b)
-            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b)));
-    }
-    return _It(__first.__seg_, static_cast<unsigned>(__n));
-}
-
-template <class _Cp, bool _IsConst>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, _IsConst>
-__find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
-{
-    typedef __bit_iterator<_Cp, _IsConst> _It;
-    typedef typename _It::__storage_type __storage_type;
-    const int __bits_per_word = _It::__bits_per_word;
-    // do first partial word
-    if (__first.__ctz_ != 0)
-    {
-        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _VSTD::min(__clz_f, __n);
-        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-        __storage_type __b = ~*__first.__seg_ & __m;
-        if (__b)
-            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b)));
-        if (__n == __dn)
-            return __first + __n;
-        __n -= __dn;
-        ++__first.__seg_;
-    }
-    // do middle whole words
-    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
-    {
-        __storage_type __b = ~*__first.__seg_;
-        if (__b)
-            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b)));
-    }
-    // do last partial word
-    if (__n > 0)
-    {
-        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __storage_type __b = ~*__first.__seg_ & __m;
-        if (__b)
-            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__libcpp_ctz(__b)));
-    }
-    return _It(__first.__seg_, static_cast<unsigned>(__n));
-}
-
-template <class _Cp, bool _IsConst, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-__bit_iterator<_Cp, _IsConst>
-find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value)
-{
-    if (static_cast<bool>(__value))
-        return _VSTD::__find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
-    return _VSTD::__find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
-}
-
-// count
-
-template <class _Cp, bool _IsConst>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __bit_iterator<_Cp, _IsConst>::difference_type
-__count_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
-{
-    typedef __bit_iterator<_Cp, _IsConst> _It;
-    typedef typename _It::__storage_type __storage_type;
-    typedef typename _It::difference_type difference_type;
-    const int __bits_per_word = _It::__bits_per_word;
-    difference_type __r = 0;
-    // do first partial word
-    if (__first.__ctz_ != 0)
-    {
-        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _VSTD::min(__clz_f, __n);
-        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-        __r = _VSTD::__libcpp_popcount(*__first.__seg_ & __m);
-        __n -= __dn;
-        ++__first.__seg_;
-    }
-    // do middle whole words
-    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
-        __r += _VSTD::__libcpp_popcount(*__first.__seg_);
-    // do last partial word
-    if (__n > 0)
-    {
-        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __r += _VSTD::__libcpp_popcount(*__first.__seg_ & __m);
-    }
-    return __r;
-}
-
-template <class _Cp, bool _IsConst>
-_LIBCPP_HIDE_FROM_ABI typename __bit_iterator<_Cp, _IsConst>::difference_type
-__count_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n)
-{
-    typedef __bit_iterator<_Cp, _IsConst> _It;
-    typedef typename _It::__storage_type __storage_type;
-    typedef typename _It::difference_type difference_type;
-    const int __bits_per_word = _It::__bits_per_word;
-    difference_type __r = 0;
-    // do first partial word
-    if (__first.__ctz_ != 0)
-    {
-        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _VSTD::min(__clz_f, __n);
-        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-        __r = _VSTD::__libcpp_popcount(~*__first.__seg_ & __m);
-        __n -= __dn;
-        ++__first.__seg_;
-    }
-    // do middle whole words
-    for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
-        __r += _VSTD::__libcpp_popcount(~*__first.__seg_);
-    // do last partial word
-    if (__n > 0)
-    {
-        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __r += _VSTD::__libcpp_popcount(~*__first.__seg_ & __m);
-    }
-    return __r;
-}
-
-template <class _Cp, bool _IsConst, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __bit_iterator<_Cp, _IsConst>::difference_type
-count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value)
-{
-    if (static_cast<bool>(__value))
-        return _VSTD::__count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
-    return _VSTD::__count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
-}
-
-// fill_n
-
-template <class _Cp>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
-__fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
-{
-    typedef __bit_iterator<_Cp, false> _It;
-    typedef typename _It::__storage_type __storage_type;
-    const int __bits_per_word = _It::__bits_per_word;
-    // do first partial word
-    if (__first.__ctz_ != 0)
-    {
-        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _VSTD::min(__clz_f, __n);
-        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-        *__first.__seg_ &= ~__m;
-        __n -= __dn;
-        ++__first.__seg_;
-    }
-    // do middle whole words
-    __storage_type __nw = __n / __bits_per_word;
-    std::fill_n(std::__to_address(__first.__seg_), __nw, 0);
-    __n -= __nw * __bits_per_word;
-    // do last partial word
-    if (__n > 0)
-    {
-        __first.__seg_ += __nw;
-        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        *__first.__seg_ &= ~__m;
-    }
-}
-
-template <class _Cp>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
-__fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
-{
-    typedef __bit_iterator<_Cp, false> _It;
-    typedef typename _It::__storage_type __storage_type;
-    const int __bits_per_word = _It::__bits_per_word;
-    // do first partial word
-    if (__first.__ctz_ != 0)
-    {
-        __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _VSTD::min(__clz_f, __n);
-        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-        *__first.__seg_ |= __m;
-        __n -= __dn;
-        ++__first.__seg_;
-    }
-    // do middle whole words
-    __storage_type __nw = __n / __bits_per_word;
-    // __storage_type is always an unsigned type, so -1 sets all bits
-    std::fill_n(std::__to_address(__first.__seg_), __nw, static_cast<__storage_type>(-1));
-    __n -= __nw * __bits_per_word;
-    // do last partial word
-    if (__n > 0)
-    {
-        __first.__seg_ += __nw;
-        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        *__first.__seg_ |= __m;
-    }
-}
-
-template <class _Cp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value)
-{
-    if (__n > 0)
-    {
-        if (__value)
-            _VSTD::__fill_n_true(__first, __n);
-        else
-            _VSTD::__fill_n_false(__first, __n);
-    }
-}
-
-// fill
-
-template <class _Cp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value)
-{
-    _VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value);
-}
-
 // copy
 
 template <class _Cp, bool _IsConst>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false>
-__copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
-                                                     __bit_iterator<_Cp, false> __result)
-{
-    typedef __bit_iterator<_Cp, _IsConst> _In;
-    typedef  typename _In::difference_type difference_type;
-    typedef typename _In::__storage_type __storage_type;
-    const int __bits_per_word = _In::__bits_per_word;
-    difference_type __n = __last - __first;
-    if (__n > 0)
-    {
-        // do first word
-        if (__first.__ctz_ != 0)
-        {
-            unsigned __clz = __bits_per_word - __first.__ctz_;
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
-            __n -= __dn;
-            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
-            __storage_type __b = *__first.__seg_ & __m;
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b;
-            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
-            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
-            ++__first.__seg_;
-            // __first.__ctz_ = 0;
-        }
-        // __first.__ctz_ == 0;
-        // do middle words
-        __storage_type __nw = __n / __bits_per_word;
-        std::copy_n(std::__to_address(__first.__seg_), __nw, std::__to_address(__result.__seg_));
-        __n -= __nw * __bits_per_word;
-        __result.__seg_ += __nw;
-        // do last word
-        if (__n > 0)
-        {
-            __first.__seg_ += __nw;
-            __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-            __storage_type __b = *__first.__seg_ & __m;
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b;
-            __result.__ctz_ = static_cast<unsigned>(__n);
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false> __copy_aligned(
+    __bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
+  using _In             = __bit_iterator<_Cp, _IsConst>;
+  using difference_type = typename _In::difference_type;
+  using __storage_type  = typename _In::__storage_type;
+
+  const int __bits_per_word = _In::__bits_per_word;
+  difference_type __n       = __last - __first;
+  if (__n > 0) {
+    // do first word
+    if (__first.__ctz_ != 0) {
+      unsigned __clz       = __bits_per_word - __first.__ctz_;
+      difference_type __dn = std::min(static_cast<difference_type>(__clz), __n);
+      __n -= __dn;
+      __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
+      __storage_type __b = *__first.__seg_ & __m;
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b;
+      __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+      __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
+      ++__first.__seg_;
+      // __first.__ctz_ = 0;
     }
-    return __result;
+    // __first.__ctz_ == 0;
+    // do middle words
+    __storage_type __nw = __n / __bits_per_word;
+    std::copy_n(std::__to_address(__first.__seg_), __nw, std::__to_address(__result.__seg_));
+    __n -= __nw * __bits_per_word;
+    __result.__seg_ += __nw;
+    // do last word
+    if (__n > 0) {
+      __first.__seg_ += __nw;
+      __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+      __storage_type __b = *__first.__seg_ & __m;
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b;
+      __result.__ctz_ = static_cast<unsigned>(__n);
+    }
+  }
+  return __result;
 }
 
 template <class _Cp, bool _IsConst>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false>
-__copy_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
-                                                       __bit_iterator<_Cp, false> __result)
-{
-    typedef __bit_iterator<_Cp, _IsConst> _In;
-    typedef  typename _In::difference_type difference_type;
-    typedef typename _In::__storage_type __storage_type;
-    const int __bits_per_word = _In::__bits_per_word;
-    difference_type __n = __last - __first;
-    if (__n > 0)
-    {
-        // do first word
-        if (__first.__ctz_ != 0)
-        {
-            unsigned __clz_f = __bits_per_word - __first.__ctz_;
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
-            __n -= __dn;
-            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-            __storage_type __b = *__first.__seg_ & __m;
-            unsigned __clz_r = __bits_per_word - __result.__ctz_;
-            __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
-            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
-            *__result.__seg_ &= ~__m;
-            if (__result.__ctz_ > __first.__ctz_)
-                *__result.__seg_ |= __b << (__result.__ctz_ - __first.__ctz_);
-            else
-                *__result.__seg_ |= __b >> (__first.__ctz_ - __result.__ctz_);
-            __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
-            __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_)  % __bits_per_word);
-            __dn -= __ddn;
-            if (__dn > 0)
-            {
-                __m = ~__storage_type(0) >> (__bits_per_word - __dn);
-                *__result.__seg_ &= ~__m;
-                *__result.__seg_ |= __b >> (__first.__ctz_ + __ddn);
-                __result.__ctz_ = static_cast<unsigned>(__dn);
-            }
-            ++__first.__seg_;
-            // __first.__ctz_ = 0;
-        }
-        // __first.__ctz_ == 0;
-        // do middle words
-        unsigned __clz_r = __bits_per_word - __result.__ctz_;
-        __storage_type __m = ~__storage_type(0) << __result.__ctz_;
-        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_)
-        {
-            __storage_type __b = *__first.__seg_;
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b << __result.__ctz_;
-            ++__result.__seg_;
-            *__result.__seg_ &= __m;
-            *__result.__seg_ |= __b >> __clz_r;
-        }
-        // do last word
-        if (__n > 0)
-        {
-            __m = ~__storage_type(0) >> (__bits_per_word - __n);
-            __storage_type __b = *__first.__seg_ & __m;
-            __storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__clz_r));
-            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b << __result.__ctz_;
-            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
-            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
-            __n -= __dn;
-            if (__n > 0)
-            {
-                __m = ~__storage_type(0) >> (__bits_per_word - __n);
-                *__result.__seg_ &= ~__m;
-                *__result.__seg_ |= __b >> __dn;
-                __result.__ctz_ = static_cast<unsigned>(__n);
-            }
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false> __copy_unaligned(
+    __bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
+  using _In             = __bit_iterator<_Cp, _IsConst>;
+  using difference_type = typename _In::difference_type;
+  using __storage_type  = typename _In::__storage_type;
+
+  const int __bits_per_word = _In::__bits_per_word;
+  difference_type __n       = __last - __first;
+  if (__n > 0) {
+    // do first word
+    if (__first.__ctz_ != 0) {
+      unsigned __clz_f     = __bits_per_word - __first.__ctz_;
+      difference_type __dn = std::min(static_cast<difference_type>(__clz_f), __n);
+      __n -= __dn;
+      __storage_type __m   = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+      __storage_type __b   = *__first.__seg_ & __m;
+      unsigned __clz_r     = __bits_per_word - __result.__ctz_;
+      __storage_type __ddn = std::min<__storage_type>(__dn, __clz_r);
+      __m                  = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
+      *__result.__seg_ &= ~__m;
+      if (__result.__ctz_ > __first.__ctz_)
+        *__result.__seg_ |= __b << (__result.__ctz_ - __first.__ctz_);
+      else
+        *__result.__seg_ |= __b >> (__first.__ctz_ - __result.__ctz_);
+      __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
+      __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);
+      __dn -= __ddn;
+      if (__dn > 0) {
+        __m = ~__storage_type(0) >> (__bits_per_word - __dn);
+        *__result.__seg_ &= ~__m;
+        *__result.__seg_ |= __b >> (__first.__ctz_ + __ddn);
+        __result.__ctz_ = static_cast<unsigned>(__dn);
+      }
+      ++__first.__seg_;
+      // __first.__ctz_ = 0;
     }
-    return __result;
+    // __first.__ctz_ == 0;
+    // do middle words
+    unsigned __clz_r   = __bits_per_word - __result.__ctz_;
+    __storage_type __m = ~__storage_type(0) << __result.__ctz_;
+    for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_) {
+      __storage_type __b = *__first.__seg_;
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b << __result.__ctz_;
+      ++__result.__seg_;
+      *__result.__seg_ &= __m;
+      *__result.__seg_ |= __b >> __clz_r;
+    }
+    // do last word
+    if (__n > 0) {
+      __m                 = ~__storage_type(0) >> (__bits_per_word - __n);
+      __storage_type __b  = *__first.__seg_ & __m;
+      __storage_type __dn = std::min(__n, static_cast<difference_type>(__clz_r));
+      __m                 = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b << __result.__ctz_;
+      __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+      __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
+      __n -= __dn;
+      if (__n > 0) {
+        __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        *__result.__seg_ &= ~__m;
+        *__result.__seg_ |= __b >> __dn;
+        __result.__ctz_ = static_cast<unsigned>(__n);
+      }
+    }
+  }
+  return __result;
 }
 
 template <class _Cp, bool _IsConst>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-__bit_iterator<_Cp, false>
-copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
-{
-    if (__first.__ctz_ == __result.__ctz_)
-        return _VSTD::__copy_aligned(__first, __last, __result);
-    return _VSTD::__copy_unaligned(__first, __last, __result);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, false>
+copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
+  if (__first.__ctz_ == __result.__ctz_)
+    return std::__copy_aligned(__first, __last, __result);
+  return std::__copy_unaligned(__first, __last, __result);
 }
 
 // copy_backward
 
 template <class _Cp, bool _IsConst>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false>
-__copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
-                                                     __bit_iterator<_Cp, false> __result)
-{
-    typedef __bit_iterator<_Cp, _IsConst> _In;
-    typedef  typename _In::difference_type difference_type;
-    typedef typename _In::__storage_type __storage_type;
-    const int __bits_per_word = _In::__bits_per_word;
-    difference_type __n = __last - __first;
-    if (__n > 0)
-    {
-        // do first word
-        if (__last.__ctz_ != 0)
-        {
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
-            __n -= __dn;
-            unsigned __clz = __bits_per_word - __last.__ctz_;
-            __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz);
-            __storage_type __b = *__last.__seg_ & __m;
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b;
-            __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) +
-                                                       __result.__ctz_)  % __bits_per_word);
-            // __last.__ctz_ = 0
-         }
-        // __last.__ctz_ == 0 || __n == 0
-        // __result.__ctz_ == 0 || __n == 0
-        // do middle words
-        __storage_type __nw = __n / __bits_per_word;
-        __result.__seg_ -= __nw;
-        __last.__seg_ -= __nw;
-        std::copy_n(std::__to_address(__last.__seg_), __nw, std::__to_address(__result.__seg_));
-        __n -= __nw * __bits_per_word;
-        // do last word
-        if (__n > 0)
-        {
-            __storage_type __m = ~__storage_type(0) << (__bits_per_word - __n);
-            __storage_type __b = *--__last.__seg_ & __m;
-            *--__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b;
-            __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false> __copy_backward_aligned(
+    __bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
+  using _In             = __bit_iterator<_Cp, _IsConst>;
+  using difference_type = typename _In::difference_type;
+  using __storage_type  = typename _In::__storage_type;
+
+  const int __bits_per_word = _In::__bits_per_word;
+  difference_type __n       = __last - __first;
+  if (__n > 0) {
+    // do first word
+    if (__last.__ctz_ != 0) {
+      difference_type __dn = std::min(static_cast<difference_type>(__last.__ctz_), __n);
+      __n -= __dn;
+      unsigned __clz     = __bits_per_word - __last.__ctz_;
+      __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz);
+      __storage_type __b = *__last.__seg_ & __m;
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b;
+      __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) + __result.__ctz_) % __bits_per_word);
+      // __last.__ctz_ = 0
     }
-    return __result;
+    // __last.__ctz_ == 0 || __n == 0
+    // __result.__ctz_ == 0 || __n == 0
+    // do middle words
+    __storage_type __nw = __n / __bits_per_word;
+    __result.__seg_ -= __nw;
+    __last.__seg_ -= __nw;
+    std::copy_n(std::__to_address(__last.__seg_), __nw, std::__to_address(__result.__seg_));
+    __n -= __nw * __bits_per_word;
+    // do last word
+    if (__n > 0) {
+      __storage_type __m = ~__storage_type(0) << (__bits_per_word - __n);
+      __storage_type __b = *--__last.__seg_ & __m;
+      *--__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b;
+      __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
+    }
+  }
+  return __result;
 }
 
 template <class _Cp, bool _IsConst>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false>
-__copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last,
-                                                       __bit_iterator<_Cp, false> __result)
-{
-    typedef __bit_iterator<_Cp, _IsConst> _In;
-    typedef  typename _In::difference_type difference_type;
-    typedef typename _In::__storage_type __storage_type;
-    const int __bits_per_word = _In::__bits_per_word;
-    difference_type __n = __last - __first;
-    if (__n > 0)
-    {
-        // do first word
-        if (__last.__ctz_ != 0)
-        {
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
-            __n -= __dn;
-            unsigned __clz_l = __bits_per_word - __last.__ctz_;
-            __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_l);
-            __storage_type __b = *__last.__seg_ & __m;
-            unsigned __clz_r = __bits_per_word - __result.__ctz_;
-            __storage_type __ddn = _VSTD::min(__dn, static_cast<difference_type>(__result.__ctz_));
-            if (__ddn > 0)
-            {
-                __m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r);
-                *__result.__seg_ &= ~__m;
-                if (__result.__ctz_ > __last.__ctz_)
-                    *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);
-                else
-                    *__result.__seg_ |= __b >> (__last.__ctz_ - __result.__ctz_);
-                __result.__ctz_ = static_cast<unsigned>(((-__ddn & (__bits_per_word - 1)) +
-                                                         __result.__ctz_)  % __bits_per_word);
-                __dn -= __ddn;
-            }
-            if (__dn > 0)
-            {
-                // __result.__ctz_ == 0
-                --__result.__seg_;
-                __result.__ctz_ = static_cast<unsigned>(-__dn & (__bits_per_word - 1));
-                __m = ~__storage_type(0) << __result.__ctz_;
-                *__result.__seg_ &= ~__m;
-                __last.__ctz_ -= __dn + __ddn;
-                *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);
-            }
-            // __last.__ctz_ = 0
-         }
-        // __last.__ctz_ == 0 || __n == 0
-        // __result.__ctz_ != 0 || __n == 0
-        // do middle words
-        unsigned __clz_r = __bits_per_word - __result.__ctz_;
-        __storage_type __m = ~__storage_type(0) >> __clz_r;
-        for (; __n >= __bits_per_word; __n -= __bits_per_word)
-        {
-            __storage_type __b = *--__last.__seg_;
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b >> __clz_r;
-            *--__result.__seg_ &= __m;
-            *__result.__seg_ |= __b << __result.__ctz_;
-        }
-        // do last word
-        if (__n > 0)
-        {
-            __m = ~__storage_type(0) << (__bits_per_word - __n);
-            __storage_type __b = *--__last.__seg_ & __m;
-            __clz_r = __bits_per_word - __result.__ctz_;
-            __storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__result.__ctz_));
-            __m = (~__storage_type(0) << (__result.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_r);
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b >> (__bits_per_word - __result.__ctz_);
-            __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) +
-                                                     __result.__ctz_)  % __bits_per_word);
-            __n -= __dn;
-            if (__n > 0)
-            {
-                // __result.__ctz_ == 0
-                --__result.__seg_;
-                __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
-                __m = ~__storage_type(0) << __result.__ctz_;
-                *__result.__seg_ &= ~__m;
-                *__result.__seg_ |= __b << (__result.__ctz_ - (__bits_per_word - __n - __dn));
-            }
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false> __copy_backward_unaligned(
+    __bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
+  using _In             = __bit_iterator<_Cp, _IsConst>;
+  using difference_type = typename _In::difference_type;
+  using __storage_type  = typename _In::__storage_type;
+
+  const int __bits_per_word = _In::__bits_per_word;
+  difference_type __n       = __last - __first;
+  if (__n > 0) {
+    // do first word
+    if (__last.__ctz_ != 0) {
+      difference_type __dn = std::min(static_cast<difference_type>(__last.__ctz_), __n);
+      __n -= __dn;
+      unsigned __clz_l     = __bits_per_word - __last.__ctz_;
+      __storage_type __m   = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_l);
+      __storage_type __b   = *__last.__seg_ & __m;
+      unsigned __clz_r     = __bits_per_word - __result.__ctz_;
+      __storage_type __ddn = std::min(__dn, static_cast<difference_type>(__result.__ctz_));
+      if (__ddn > 0) {
+        __m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r);
+        *__result.__seg_ &= ~__m;
+        if (__result.__ctz_ > __last.__ctz_)
+          *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);
+        else
+          *__result.__seg_ |= __b >> (__last.__ctz_ - __result.__ctz_);
+        __result.__ctz_ = static_cast<unsigned>(((-__ddn & (__bits_per_word - 1)) + __result.__ctz_) % __bits_per_word);
+        __dn -= __ddn;
+      }
+      if (__dn > 0) {
+        // __result.__ctz_ == 0
+        --__result.__seg_;
+        __result.__ctz_ = static_cast<unsigned>(-__dn & (__bits_per_word - 1));
+        __m             = ~__storage_type(0) << __result.__ctz_;
+        *__result.__seg_ &= ~__m;
+        __last.__ctz_ -= __dn + __ddn;
+        *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);
+      }
+      // __last.__ctz_ = 0
     }
-    return __result;
+    // __last.__ctz_ == 0 || __n == 0
+    // __result.__ctz_ != 0 || __n == 0
+    // do middle words
+    unsigned __clz_r   = __bits_per_word - __result.__ctz_;
+    __storage_type __m = ~__storage_type(0) >> __clz_r;
+    for (; __n >= __bits_per_word; __n -= __bits_per_word) {
+      __storage_type __b = *--__last.__seg_;
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b >> __clz_r;
+      *--__result.__seg_ &= __m;
+      *__result.__seg_ |= __b << __result.__ctz_;
+    }
+    // do last word
+    if (__n > 0) {
+      __m                 = ~__storage_type(0) << (__bits_per_word - __n);
+      __storage_type __b  = *--__last.__seg_ & __m;
+      __clz_r             = __bits_per_word - __result.__ctz_;
+      __storage_type __dn = std::min(__n, static_cast<difference_type>(__result.__ctz_));
+      __m                 = (~__storage_type(0) << (__result.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_r);
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b >> (__bits_per_word - __result.__ctz_);
+      __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) + __result.__ctz_) % __bits_per_word);
+      __n -= __dn;
+      if (__n > 0) {
+        // __result.__ctz_ == 0
+        --__result.__seg_;
+        __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
+        __m             = ~__storage_type(0) << __result.__ctz_;
+        *__result.__seg_ &= ~__m;
+        *__result.__seg_ |= __b << (__result.__ctz_ - (__bits_per_word - __n - __dn));
+      }
+    }
+  }
+  return __result;
 }
 
 template <class _Cp, bool _IsConst>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-__bit_iterator<_Cp, false>
-copy_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
-{
-    if (__last.__ctz_ == __result.__ctz_)
-        return _VSTD::__copy_backward_aligned(__first, __last, __result);
-    return _VSTD::__copy_backward_unaligned(__first, __last, __result);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, false> copy_backward(
+    __bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
+  if (__last.__ctz_ == __result.__ctz_)
+    return std::__copy_backward_aligned(__first, __last, __result);
+  return std::__copy_backward_unaligned(__first, __last, __result);
 }
 
 // move
 
 template <class _Cp, bool _IsConst>
-inline _LIBCPP_INLINE_VISIBILITY
-__bit_iterator<_Cp, false>
-move(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
-{
-    return _VSTD::copy(__first, __last, __result);
+inline _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false>
+move(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
+  return std::copy(__first, __last, __result);
 }
 
 // move_backward
 
 template <class _Cp, bool _IsConst>
-inline _LIBCPP_INLINE_VISIBILITY
-__bit_iterator<_Cp, false>
-move_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result)
-{
-    return _VSTD::copy_backward(__first, __last, __result);
+inline _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false> move_backward(
+    __bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
+  return std::copy_backward(__first, __last, __result);
 }
 
 // swap_ranges
 
-template <class __C1, class __C2>
-_LIBCPP_HIDE_FROM_ABI __bit_iterator<__C2, false>
-__swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
-                      __bit_iterator<__C2, false> __result)
-{
-    typedef __bit_iterator<__C1, false> _I1;
-    typedef  typename _I1::difference_type difference_type;
-    typedef typename _I1::__storage_type __storage_type;
-    const int __bits_per_word = _I1::__bits_per_word;
-    difference_type __n = __last - __first;
-    if (__n > 0)
-    {
-        // do first word
-        if (__first.__ctz_ != 0)
-        {
-            unsigned __clz = __bits_per_word - __first.__ctz_;
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
-            __n -= __dn;
-            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
-            __storage_type __b1 = *__first.__seg_ & __m;
-            *__first.__seg_ &= ~__m;
-            __storage_type __b2 = *__result.__seg_ & __m;
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b1;
-            *__first.__seg_  |= __b2;
-            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
-            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
-            ++__first.__seg_;
-            // __first.__ctz_ = 0;
-        }
-        // __first.__ctz_ == 0;
-        // do middle words
-        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_, ++__result.__seg_)
-            swap(*__first.__seg_, *__result.__seg_);
-        // do last word
-        if (__n > 0)
-        {
-            __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-            __storage_type __b1 = *__first.__seg_ & __m;
-            *__first.__seg_ &= ~__m;
-            __storage_type __b2 = *__result.__seg_ & __m;
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b1;
-            *__first.__seg_  |= __b2;
-            __result.__ctz_ = static_cast<unsigned>(__n);
-        }
+template <class _Cl, class _Cr>
+_LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cr, false> __swap_ranges_aligned(
+    __bit_iterator<_Cl, false> __first, __bit_iterator<_Cl, false> __last, __bit_iterator<_Cr, false> __result) {
+  using _I1             = __bit_iterator<_Cl, false>;
+  using difference_type = typename _I1::difference_type;
+  using __storage_type  = typename _I1::__storage_type;
+
+  const int __bits_per_word = _I1::__bits_per_word;
+  difference_type __n       = __last - __first;
+  if (__n > 0) {
+    // do first word
+    if (__first.__ctz_ != 0) {
+      unsigned __clz       = __bits_per_word - __first.__ctz_;
+      difference_type __dn = std::min(static_cast<difference_type>(__clz), __n);
+      __n -= __dn;
+      __storage_type __m  = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
+      __storage_type __b1 = *__first.__seg_ & __m;
+      *__first.__seg_ &= ~__m;
+      __storage_type __b2 = *__result.__seg_ & __m;
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b1;
+      *__first.__seg_ |= __b2;
+      __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+      __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
+      ++__first.__seg_;
+      // __first.__ctz_ = 0;
     }
-    return __result;
+    // __first.__ctz_ == 0;
+    // do middle words
+    for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_, ++__result.__seg_)
+      swap(*__first.__seg_, *__result.__seg_);
+    // do last word
+    if (__n > 0) {
+      __storage_type __m  = ~__storage_type(0) >> (__bits_per_word - __n);
+      __storage_type __b1 = *__first.__seg_ & __m;
+      *__first.__seg_ &= ~__m;
+      __storage_type __b2 = *__result.__seg_ & __m;
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b1;
+      *__first.__seg_ |= __b2;
+      __result.__ctz_ = static_cast<unsigned>(__n);
+    }
+  }
+  return __result;
 }
 
-template <class __C1, class __C2>
-_LIBCPP_HIDE_FROM_ABI __bit_iterator<__C2, false>
-__swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
-                        __bit_iterator<__C2, false> __result)
-{
-    typedef __bit_iterator<__C1, false> _I1;
-    typedef  typename _I1::difference_type difference_type;
-    typedef typename _I1::__storage_type __storage_type;
-    const int __bits_per_word = _I1::__bits_per_word;
-    difference_type __n = __last - __first;
-    if (__n > 0)
-    {
-        // do first word
-        if (__first.__ctz_ != 0)
-        {
-            unsigned __clz_f = __bits_per_word - __first.__ctz_;
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
-            __n -= __dn;
-            __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-            __storage_type __b1 = *__first.__seg_ & __m;
-            *__first.__seg_ &= ~__m;
-            unsigned __clz_r = __bits_per_word - __result.__ctz_;
-            __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
-            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
-            __storage_type __b2 = *__result.__seg_ & __m;
-            *__result.__seg_ &= ~__m;
-            if (__result.__ctz_ > __first.__ctz_)
-            {
-                unsigned __s = __result.__ctz_ - __first.__ctz_;
-                *__result.__seg_ |= __b1 << __s;
-                *__first.__seg_  |= __b2 >> __s;
-            }
-            else
-            {
-                unsigned __s = __first.__ctz_ - __result.__ctz_;
-                *__result.__seg_ |= __b1 >> __s;
-                *__first.__seg_  |= __b2 << __s;
-            }
-            __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
-            __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_)  % __bits_per_word);
-            __dn -= __ddn;
-            if (__dn > 0)
-            {
-                __m = ~__storage_type(0) >> (__bits_per_word - __dn);
-                __b2 = *__result.__seg_ & __m;
-                *__result.__seg_ &= ~__m;
-                unsigned __s = __first.__ctz_ + __ddn;
-                *__result.__seg_ |= __b1 >> __s;
-                *__first.__seg_  |= __b2 << __s;
-                __result.__ctz_ = static_cast<unsigned>(__dn);
-            }
-            ++__first.__seg_;
-            // __first.__ctz_ = 0;
-        }
-        // __first.__ctz_ == 0;
-        // do middle words
-        __storage_type __m = ~__storage_type(0) << __result.__ctz_;
-        unsigned __clz_r = __bits_per_word - __result.__ctz_;
-        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_)
-        {
-            __storage_type __b1 = *__first.__seg_;
-            __storage_type __b2 = *__result.__seg_ & __m;
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b1 << __result.__ctz_;
-            *__first.__seg_  = __b2 >> __result.__ctz_;
-            ++__result.__seg_;
-            __b2 = *__result.__seg_ & ~__m;
-            *__result.__seg_ &= __m;
-            *__result.__seg_ |= __b1 >> __clz_r;
-            *__first.__seg_  |= __b2 << __clz_r;
-        }
-        // do last word
-        if (__n > 0)
-        {
-            __m = ~__storage_type(0) >> (__bits_per_word - __n);
-            __storage_type __b1 = *__first.__seg_ & __m;
-            *__first.__seg_ &= ~__m;
-            __storage_type __dn = _VSTD::min<__storage_type>(__n, __clz_r);
-            __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
-            __storage_type __b2 = *__result.__seg_ & __m;
-            *__result.__seg_ &= ~__m;
-            *__result.__seg_ |= __b1 << __result.__ctz_;
-            *__first.__seg_  |= __b2 >> __result.__ctz_;
-            __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
-            __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_)  % __bits_per_word);
-            __n -= __dn;
-            if (__n > 0)
-            {
-                __m = ~__storage_type(0) >> (__bits_per_word - __n);
-                __b2 = *__result.__seg_ & __m;
-                *__result.__seg_ &= ~__m;
-                *__result.__seg_ |= __b1 >> __dn;
-                *__first.__seg_  |= __b2 << __dn;
-                __result.__ctz_ = static_cast<unsigned>(__n);
-            }
-        }
+template <class _Cl, class _Cr>
+_LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cr, false> __swap_ranges_unaligned(
+    __bit_iterator<_Cl, false> __first, __bit_iterator<_Cl, false> __last, __bit_iterator<_Cr, false> __result) {
+  using _I1             = __bit_iterator<_Cl, false>;
+  using difference_type = typename _I1::difference_type;
+  using __storage_type  = typename _I1::__storage_type;
+
+  const int __bits_per_word = _I1::__bits_per_word;
+  difference_type __n       = __last - __first;
+  if (__n > 0) {
+    // do first word
+    if (__first.__ctz_ != 0) {
+      unsigned __clz_f     = __bits_per_word - __first.__ctz_;
+      difference_type __dn = std::min(static_cast<difference_type>(__clz_f), __n);
+      __n -= __dn;
+      __storage_type __m  = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+      __storage_type __b1 = *__first.__seg_ & __m;
+      *__first.__seg_ &= ~__m;
+      unsigned __clz_r     = __bits_per_word - __result.__ctz_;
+      __storage_type __ddn = std::min<__storage_type>(__dn, __clz_r);
+      __m                  = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
+      __storage_type __b2  = *__result.__seg_ & __m;
+      *__result.__seg_ &= ~__m;
+      if (__result.__ctz_ > __first.__ctz_) {
+        unsigned __s = __result.__ctz_ - __first.__ctz_;
+        *__result.__seg_ |= __b1 << __s;
+        *__first.__seg_ |= __b2 >> __s;
+      } else {
+        unsigned __s = __first.__ctz_ - __result.__ctz_;
+        *__result.__seg_ |= __b1 >> __s;
+        *__first.__seg_ |= __b2 << __s;
+      }
+      __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
+      __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);
+      __dn -= __ddn;
+      if (__dn > 0) {
+        __m  = ~__storage_type(0) >> (__bits_per_word - __dn);
+        __b2 = *__result.__seg_ & __m;
+        *__result.__seg_ &= ~__m;
+        unsigned __s = __first.__ctz_ + __ddn;
+        *__result.__seg_ |= __b1 >> __s;
+        *__first.__seg_ |= __b2 << __s;
+        __result.__ctz_ = static_cast<unsigned>(__dn);
+      }
+      ++__first.__seg_;
+      // __first.__ctz_ = 0;
     }
-    return __result;
+    // __first.__ctz_ == 0;
+    // do middle words
+    __storage_type __m = ~__storage_type(0) << __result.__ctz_;
+    unsigned __clz_r   = __bits_per_word - __result.__ctz_;
+    for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_) {
+      __storage_type __b1 = *__first.__seg_;
+      __storage_type __b2 = *__result.__seg_ & __m;
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b1 << __result.__ctz_;
+      *__first.__seg_ = __b2 >> __result.__ctz_;
+      ++__result.__seg_;
+      __b2 = *__result.__seg_ & ~__m;
+      *__result.__seg_ &= __m;
+      *__result.__seg_ |= __b1 >> __clz_r;
+      *__first.__seg_ |= __b2 << __clz_r;
+    }
+    // do last word
+    if (__n > 0) {
+      __m                 = ~__storage_type(0) >> (__bits_per_word - __n);
+      __storage_type __b1 = *__first.__seg_ & __m;
+      *__first.__seg_ &= ~__m;
+      __storage_type __dn = std::min<__storage_type>(__n, __clz_r);
+      __m                 = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
+      __storage_type __b2 = *__result.__seg_ & __m;
+      *__result.__seg_ &= ~__m;
+      *__result.__seg_ |= __b1 << __result.__ctz_;
+      *__first.__seg_ |= __b2 >> __result.__ctz_;
+      __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
+      __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
+      __n -= __dn;
+      if (__n > 0) {
+        __m  = ~__storage_type(0) >> (__bits_per_word - __n);
+        __b2 = *__result.__seg_ & __m;
+        *__result.__seg_ &= ~__m;
+        *__result.__seg_ |= __b1 >> __dn;
+        *__first.__seg_ |= __b2 << __dn;
+        __result.__ctz_ = static_cast<unsigned>(__n);
+      }
+    }
+  }
+  return __result;
 }
 
-template <class __C1, class __C2>
-inline _LIBCPP_INLINE_VISIBILITY
-__bit_iterator<__C2, false>
-swap_ranges(__bit_iterator<__C1, false> __first1, __bit_iterator<__C1, false> __last1,
-            __bit_iterator<__C2, false> __first2)
-{
-    if (__first1.__ctz_ == __first2.__ctz_)
-        return _VSTD::__swap_ranges_aligned(__first1, __last1, __first2);
-    return _VSTD::__swap_ranges_unaligned(__first1, __last1, __first2);
+template <class _Cl, class _Cr>
+inline _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cr, false> swap_ranges(
+    __bit_iterator<_Cl, false> __first1, __bit_iterator<_Cl, false> __last1, __bit_iterator<_Cr, false> __first2) {
+  if (__first1.__ctz_ == __first2.__ctz_)
+    return std::__swap_ranges_aligned(__first1, __last1, __first2);
+  return std::__swap_ranges_unaligned(__first1, __last1, __first2);
 }
 
 // rotate
 
 template <class _Cp>
-struct __bit_array
-{
-    typedef typename _Cp::difference_type difference_type;
-    typedef typename _Cp::__storage_type  __storage_type;
-    typedef typename _Cp::__storage_pointer __storage_pointer;
-    typedef typename _Cp::iterator        iterator;
-    static const unsigned __bits_per_word = _Cp::__bits_per_word;
-    static const unsigned _Np = 4;
+struct __bit_array {
+  using difference_type   = typename _Cp::difference_type;
+  using __storage_type    = typename _Cp::__storage_type;
+  using __storage_pointer = typename _Cp::__storage_pointer;
+  using iterator          = typename _Cp::iterator;
 
-    difference_type __size_;
-    __storage_type __word_[_Np];
+  static const unsigned __bits_per_word = _Cp::__bits_per_word;
+  static const unsigned _Np             = 4;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 static difference_type capacity()
-        {return static_cast<difference_type>(_Np * __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __bit_array(difference_type __s) : __size_(__s) {
-        if (__libcpp_is_constant_evaluated()) {
-            for (size_t __i = 0; __i != __bit_array<_Cp>::_Np; ++__i)
-                std::__construct_at(__word_ + __i, 0);
-        }
-    }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator begin()
-    {
-        return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]), 0);
-    }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator end()
-    {
-        return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]) + __size_ / __bits_per_word,
-                                                  static_cast<unsigned>(__size_ % __bits_per_word));
+  difference_type __size_;
+  __storage_type __word_[_Np];
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static difference_type capacity() {
+    return static_cast<difference_type>(_Np * __bits_per_word);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __bit_array(difference_type __s) : __size_(__s) {
+    if (__libcpp_is_constant_evaluated()) {
+      for (size_t __i = 0; __i != __bit_array<_Cp>::_Np; ++__i)
+        std::__construct_at(__word_ + __i, 0);
     }
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator begin() {
+    return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]), 0);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator end() {
+    return iterator(pointer_traits<__storage_pointer>::pointer_to(__word_[0]) + __size_ / __bits_per_word,
+                    static_cast<unsigned>(__size_ % __bits_per_word));
+  }
 };
 
 template <class _Cp>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false>
-rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle, __bit_iterator<_Cp, false> __last)
-{
-    typedef __bit_iterator<_Cp, false> _I1;
-    typedef  typename _I1::difference_type difference_type;
-    difference_type __d1 = __middle - __first;
-    difference_type __d2 = __last - __middle;
-    _I1 __r = __first + __d2;
-    while (__d1 != 0 && __d2 != 0)
-    {
-        if (__d1 <= __d2)
-        {
-            if (__d1 <= __bit_array<_Cp>::capacity())
-            {
-                __bit_array<_Cp> __b(__d1);
-                _VSTD::copy(__first, __middle, __b.begin());
-                _VSTD::copy(__b.begin(), __b.end(), _VSTD::copy(__middle, __last, __first));
-                break;
-            }
-            else
-            {
-                __bit_iterator<_Cp, false> __mp = _VSTD::swap_ranges(__first, __middle, __middle);
-                __first = __middle;
-                __middle = __mp;
-                __d2 -= __d1;
-            }
-        }
-        else
-        {
-            if (__d2 <= __bit_array<_Cp>::capacity())
-            {
-                __bit_array<_Cp> __b(__d2);
-                _VSTD::copy(__middle, __last, __b.begin());
-                _VSTD::copy_backward(__b.begin(), __b.end(), _VSTD::copy_backward(__first, __middle, __last));
-                break;
-            }
-            else
-            {
-                __bit_iterator<_Cp, false> __mp = __first + __d2;
-                _VSTD::swap_ranges(__first, __mp, __middle);
-                __first = __mp;
-                __d1 -= __d2;
-            }
-        }
+rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle, __bit_iterator<_Cp, false> __last) {
+  using _I1             = __bit_iterator<_Cp, false>;
+  using difference_type = typename _I1::difference_type;
+
+  difference_type __d1 = __middle - __first;
+  difference_type __d2 = __last - __middle;
+  _I1 __r              = __first + __d2;
+  while (__d1 != 0 && __d2 != 0) {
+    if (__d1 <= __d2) {
+      if (__d1 <= __bit_array<_Cp>::capacity()) {
+        __bit_array<_Cp> __b(__d1);
+        std::copy(__first, __middle, __b.begin());
+        std::copy(__b.begin(), __b.end(), std::copy(__middle, __last, __first));
+        break;
+      } else {
+        __bit_iterator<_Cp, false> __mp = std::swap_ranges(__first, __middle, __middle);
+        __first                         = __middle;
+        __middle                        = __mp;
+        __d2 -= __d1;
+      }
+    } else {
+      if (__d2 <= __bit_array<_Cp>::capacity()) {
+        __bit_array<_Cp> __b(__d2);
+        std::copy(__middle, __last, __b.begin());
+        std::copy_backward(__b.begin(), __b.end(), std::copy_backward(__first, __middle, __last));
+        break;
+      } else {
+        __bit_iterator<_Cp, false> __mp = __first + __d2;
+        std::swap_ranges(__first, __mp, __middle);
+        __first = __mp;
+        __d1 -= __d2;
+      }
     }
-    return __r;
+  }
+  return __r;
 }
 
 // equal
 
 template <class _Cp, bool _IC1, bool _IC2>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool
-__equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
-                  __bit_iterator<_Cp, _IC2> __first2)
-{
-    typedef __bit_iterator<_Cp, _IC1> _It;
-    typedef  typename _It::difference_type difference_type;
-    typedef typename _It::__storage_type __storage_type;
-    const int __bits_per_word = _It::__bits_per_word;
-    difference_type __n = __last1 - __first1;
-    if (__n > 0)
-    {
-        // do first word
-        if (__first1.__ctz_ != 0)
-        {
-            unsigned __clz_f = __bits_per_word - __first1.__ctz_;
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
-            __n -= __dn;
-            __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-            __storage_type __b = *__first1.__seg_ & __m;
-            unsigned __clz_r = __bits_per_word - __first2.__ctz_;
-            __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
-            __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
-            if (__first2.__ctz_ > __first1.__ctz_)
-            {
-                if ((*__first2.__seg_ & __m) != (__b << (__first2.__ctz_ - __first1.__ctz_)))
-                    return false;
-            }
-            else
-            {
-                if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ - __first2.__ctz_)))
-                    return false;
-            }
-            __first2.__seg_ += (__ddn + __first2.__ctz_) / __bits_per_word;
-            __first2.__ctz_ = static_cast<unsigned>((__ddn + __first2.__ctz_)  % __bits_per_word);
-            __dn -= __ddn;
-            if (__dn > 0)
-            {
-                __m = ~__storage_type(0) >> (__bits_per_word - __dn);
-                if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ + __ddn)))
-                    return false;
-                __first2.__ctz_ = static_cast<unsigned>(__dn);
-            }
-            ++__first1.__seg_;
-            // __first1.__ctz_ = 0;
-        }
-        // __first1.__ctz_ == 0;
-        // do middle words
-        unsigned __clz_r = __bits_per_word - __first2.__ctz_;
-        __storage_type __m = ~__storage_type(0) << __first2.__ctz_;
-        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_)
-        {
-            __storage_type __b = *__first1.__seg_;
-            if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
-                return false;
-            ++__first2.__seg_;
-            if ((*__first2.__seg_ & ~__m) != (__b >> __clz_r))
-                return false;
-        }
-        // do last word
-        if (__n > 0)
-        {
-            __m = ~__storage_type(0) >> (__bits_per_word - __n);
-            __storage_type __b = *__first1.__seg_ & __m;
-            __storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__clz_r));
-            __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
-            if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
-                return false;
-            __first2.__seg_ += (__dn + __first2.__ctz_) / __bits_per_word;
-            __first2.__ctz_ = static_cast<unsigned>((__dn + __first2.__ctz_)  % __bits_per_word);
-            __n -= __dn;
-            if (__n > 0)
-            {
-                __m = ~__storage_type(0) >> (__bits_per_word - __n);
-                if ((*__first2.__seg_ & __m) != (__b >> __dn))
-                    return false;
-            }
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool __equal_unaligned(
+    __bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2) {
+  using _It             = __bit_iterator<_Cp, _IC1>;
+  using difference_type = typename _It::difference_type;
+  using __storage_type  = typename _It::__storage_type;
+
+  const int __bits_per_word = _It::__bits_per_word;
+  difference_type __n       = __last1 - __first1;
+  if (__n > 0) {
+    // do first word
+    if (__first1.__ctz_ != 0) {
+      unsigned __clz_f     = __bits_per_word - __first1.__ctz_;
+      difference_type __dn = std::min(static_cast<difference_type>(__clz_f), __n);
+      __n -= __dn;
+      __storage_type __m   = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
+      __storage_type __b   = *__first1.__seg_ & __m;
+      unsigned __clz_r     = __bits_per_word - __first2.__ctz_;
+      __storage_type __ddn = std::min<__storage_type>(__dn, __clz_r);
+      __m                  = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
+      if (__first2.__ctz_ > __first1.__ctz_) {
+        if ((*__first2.__seg_ & __m) != (__b << (__first2.__ctz_ - __first1.__ctz_)))
+          return false;
+      } else {
+        if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ - __first2.__ctz_)))
+          return false;
+      }
+      __first2.__seg_ += (__ddn + __first2.__ctz_) / __bits_per_word;
+      __first2.__ctz_ = static_cast<unsigned>((__ddn + __first2.__ctz_) % __bits_per_word);
+      __dn -= __ddn;
+      if (__dn > 0) {
+        __m = ~__storage_type(0) >> (__bits_per_word - __dn);
+        if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ + __ddn)))
+          return false;
+        __first2.__ctz_ = static_cast<unsigned>(__dn);
+      }
+      ++__first1.__seg_;
+      // __first1.__ctz_ = 0;
     }
-    return true;
+    // __first1.__ctz_ == 0;
+    // do middle words
+    unsigned __clz_r   = __bits_per_word - __first2.__ctz_;
+    __storage_type __m = ~__storage_type(0) << __first2.__ctz_;
+    for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_) {
+      __storage_type __b = *__first1.__seg_;
+      if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
+        return false;
+      ++__first2.__seg_;
+      if ((*__first2.__seg_ & ~__m) != (__b >> __clz_r))
+        return false;
+    }
+    // do last word
+    if (__n > 0) {
+      __m                 = ~__storage_type(0) >> (__bits_per_word - __n);
+      __storage_type __b  = *__first1.__seg_ & __m;
+      __storage_type __dn = std::min(__n, static_cast<difference_type>(__clz_r));
+      __m                 = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
+      if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
+        return false;
+      __first2.__seg_ += (__dn + __first2.__ctz_) / __bits_per_word;
+      __first2.__ctz_ = static_cast<unsigned>((__dn + __first2.__ctz_) % __bits_per_word);
+      __n -= __dn;
+      if (__n > 0) {
+        __m = ~__storage_type(0) >> (__bits_per_word - __n);
+        if ((*__first2.__seg_ & __m) != (__b >> __dn))
+          return false;
+      }
+    }
+  }
+  return true;
 }
 
 template <class _Cp, bool _IC1, bool _IC2>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool
-__equal_aligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1,
-                __bit_iterator<_Cp, _IC2> __first2)
-{
-    typedef __bit_iterator<_Cp, _IC1> _It;
-    typedef  typename _It::difference_type difference_type;
-    typedef typename _It::__storage_type __storage_type;
-    const int __bits_per_word = _It::__bits_per_word;
-    difference_type __n = __last1 - __first1;
-    if (__n > 0)
-    {
-        // do first word
-        if (__first1.__ctz_ != 0)
-        {
-            unsigned __clz = __bits_per_word - __first1.__ctz_;
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
-            __n -= __dn;
-            __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
-            if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
-                return false;
-            ++__first2.__seg_;
-            ++__first1.__seg_;
-            // __first1.__ctz_ = 0;
-            // __first2.__ctz_ = 0;
-        }
-        // __first1.__ctz_ == 0;
-        // __first2.__ctz_ == 0;
-        // do middle words
-        for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_, ++__first2.__seg_)
-            if (*__first2.__seg_ != *__first1.__seg_)
-                return false;
-        // do last word
-        if (__n > 0)
-        {
-            __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-            if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
-                return false;
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool __equal_aligned(
+    __bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2) {
+  using _It             = __bit_iterator<_Cp, _IC1>;
+  using difference_type = typename _It::difference_type;
+  using __storage_type  = typename _It::__storage_type;
+
+  const int __bits_per_word = _It::__bits_per_word;
+  difference_type __n       = __last1 - __first1;
+  if (__n > 0) {
+    // do first word
+    if (__first1.__ctz_ != 0) {
+      unsigned __clz       = __bits_per_word - __first1.__ctz_;
+      difference_type __dn = std::min(static_cast<difference_type>(__clz), __n);
+      __n -= __dn;
+      __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
+      if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
+        return false;
+      ++__first2.__seg_;
+      ++__first1.__seg_;
+      // __first1.__ctz_ = 0;
+      // __first2.__ctz_ = 0;
     }
-    return true;
+    // __first1.__ctz_ == 0;
+    // __first2.__ctz_ == 0;
+    // do middle words
+    for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_, ++__first2.__seg_)
+      if (*__first2.__seg_ != *__first1.__seg_)
+        return false;
+    // do last word
+    if (__n > 0) {
+      __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+      if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
+        return false;
+    }
+  }
+  return true;
 }
 
 template <class _Cp, bool _IC1, bool _IC2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2)
-{
-    if (__first1.__ctz_ == __first2.__ctz_)
-        return _VSTD::__equal_aligned(__first1, __last1, __first2);
-    return _VSTD::__equal_unaligned(__first1, __last1, __first2);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2) {
+  if (__first1.__ctz_ == __first2.__ctz_)
+    return std::__equal_aligned(__first1, __last1, __first2);
+  return std::__equal_unaligned(__first1, __last1, __first2);
 }
 
-template <class _Cp, bool _IsConst,
-          typename _Cp::__storage_type>
-class __bit_iterator
-{
+template <class _Cp, bool _IsConst, typename _Cp::__storage_type>
+class __bit_iterator {
 public:
-    typedef typename _Cp::difference_type                                                          difference_type;
-    typedef bool                                                                                  value_type;
-    typedef __bit_iterator                                                                        pointer;
+  using difference_type = typename _Cp::difference_type;
+  using value_type      = bool;
+  using pointer         = __bit_iterator;
 #ifndef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
-    typedef __conditional_t<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> > reference;
+  using reference = __conditional_t<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >;
 #else
-    using reference = __conditional_t<_IsConst, bool, __bit_reference<_Cp> >;
+  using reference = __conditional_t<_IsConst, bool, __bit_reference<_Cp> >;
 #endif
-    typedef random_access_iterator_tag                                                            iterator_category;
+  using iterator_category = random_access_iterator_tag;
 
 private:
-    typedef typename _Cp::__storage_type                                           __storage_type;
-    typedef __conditional_t<_IsConst, typename _Cp::__const_storage_pointer, typename _Cp::__storage_pointer>
-        __storage_pointer;
-    static const unsigned __bits_per_word = _Cp::__bits_per_word;
+  using __storage_type = typename _Cp::__storage_type;
+  using __storage_pointer =
+      __conditional_t<_IsConst, typename _Cp::__const_storage_pointer, typename _Cp::__storage_pointer>;
 
-    __storage_pointer __seg_;
-    unsigned          __ctz_;
+  static const unsigned __bits_per_word = _Cp::__bits_per_word;
+
+  __storage_pointer __seg_;
+  unsigned __ctz_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator() _NOEXCEPT
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER >= 14
-    : __seg_(nullptr), __ctz_(0)
+      : __seg_(nullptr),
+        __ctz_(0)
 #endif
-    {}
+  {
+  }
 
-    // When _IsConst=false, this is the copy constructor.
-    // It is non-trivial. Making it trivial would break ABI.
-    // When _IsConst=true, this is a converting constructor;
-    // the copy and move constructors are implicitly generated
-    // and trivial.
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
-        : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
+  // When _IsConst=false, this is the copy constructor.
+  // It is non-trivial. Making it trivial would break ABI.
+  // When _IsConst=true, this is a converting constructor;
+  // the copy and move constructors are implicitly generated
+  // and trivial.
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
+      : __seg_(__it.__seg_),
+        __ctz_(__it.__ctz_) {}
 
-    // When _IsConst=false, we have a user-provided copy constructor,
-    // so we must also provide a copy assignment operator because
-    // the implicit generation of a defaulted one is deprecated.
-    // When _IsConst=true, the assignment operators are
-    // implicitly generated and trivial.
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    __bit_iterator& operator=(const _If<_IsConst, struct __private_nat, __bit_iterator>& __it) {
-        __seg_ = __it.__seg_;
-        __ctz_ = __it.__ctz_;
-        return *this;
+  // When _IsConst=false, we have a user-provided copy constructor,
+  // so we must also provide a copy assignment operator because
+  // the implicit generation of a defaulted one is deprecated.
+  // When _IsConst=true, the assignment operators are
+  // implicitly generated and trivial.
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator&
+  operator=(const _If<_IsConst, struct __private_nat, __bit_iterator>& __it) {
+    __seg_ = __it.__seg_;
+    __ctz_ = __it.__ctz_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator*() const _NOEXCEPT {
+    return __conditional_t<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >(
+        __seg_, __storage_type(1) << __ctz_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator++() {
+    if (__ctz_ != __bits_per_word - 1)
+      ++__ctz_;
+    else {
+      __ctz_ = 0;
+      ++__seg_;
     }
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator*() const _NOEXCEPT {
-        return __conditional_t<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >(
-            __seg_, __storage_type(1) << __ctz_);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator operator++(int) {
+    __bit_iterator __tmp = *this;
+    ++(*this);
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator--() {
+    if (__ctz_ != 0)
+      --__ctz_;
+    else {
+      __ctz_ = __bits_per_word - 1;
+      --__seg_;
     }
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator++()
-    {
-        if (__ctz_ != __bits_per_word-1)
-            ++__ctz_;
-        else
-        {
-            __ctz_ = 0;
-            ++__seg_;
-        }
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator operator--(int) {
+    __bit_iterator __tmp = *this;
+    --(*this);
+    return __tmp;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator operator++(int)
-    {
-        __bit_iterator __tmp = *this;
-        ++(*this);
-        return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator+=(difference_type __n) {
+    if (__n >= 0)
+      __seg_ += (__n + __ctz_) / __bits_per_word;
+    else
+      __seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1) /
+                static_cast<difference_type>(__bits_per_word);
+    __n &= (__bits_per_word - 1);
+    __ctz_ = static_cast<unsigned>((__n + __ctz_) % __bits_per_word);
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator--()
-    {
-        if (__ctz_ != 0)
-            --__ctz_;
-        else
-        {
-            __ctz_ = __bits_per_word - 1;
-            --__seg_;
-        }
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator-=(difference_type __n) {
+    return *this += -__n;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator operator--(int)
-    {
-        __bit_iterator __tmp = *this;
-        --(*this);
-        return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator operator+(difference_type __n) const {
+    __bit_iterator __t(*this);
+    __t += __n;
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator+=(difference_type __n)
-    {
-        if (__n >= 0)
-            __seg_ += (__n + __ctz_) / __bits_per_word;
-        else
-            __seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1)
-                    / static_cast<difference_type>(__bits_per_word);
-        __n &= (__bits_per_word - 1);
-        __ctz_ = static_cast<unsigned>((__n + __ctz_)  % __bits_per_word);
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator operator-(difference_type __n) const {
+    __bit_iterator __t(*this);
+    __t -= __n;
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator& operator-=(difference_type __n)
-    {
-        return *this += -__n;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator
+  operator+(difference_type __n, const __bit_iterator& __it) {
+    return __it + __n;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator operator+(difference_type __n) const
-    {
-        __bit_iterator __t(*this);
-        __t += __n;
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend difference_type
+  operator-(const __bit_iterator& __x, const __bit_iterator& __y) {
+    return (__x.__seg_ - __y.__seg_) * __bits_per_word + __x.__ctz_ - __y.__ctz_;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator operator-(difference_type __n) const
-    {
-        __bit_iterator __t(*this);
-        __t -= __n;
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator[](difference_type __n) const {
+    return *(*this + __n);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend __bit_iterator operator+(difference_type __n, const __bit_iterator& __it) {return __it + __n;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
+  operator==(const __bit_iterator& __x, const __bit_iterator& __y) {
+    return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend difference_type operator-(const __bit_iterator& __x, const __bit_iterator& __y)
-        {return (__x.__seg_ - __y.__seg_) * __bits_per_word + __x.__ctz_ - __y.__ctz_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
+  operator!=(const __bit_iterator& __x, const __bit_iterator& __y) {
+    return !(__x == __y);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator[](difference_type __n) const {return *(*this + __n);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
+  operator<(const __bit_iterator& __x, const __bit_iterator& __y) {
+    return __x.__seg_ < __y.__seg_ || (__x.__seg_ == __y.__seg_ && __x.__ctz_ < __y.__ctz_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool operator==(const __bit_iterator& __x, const __bit_iterator& __y)
-        {return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
+  operator>(const __bit_iterator& __x, const __bit_iterator& __y) {
+    return __y < __x;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool operator!=(const __bit_iterator& __x, const __bit_iterator& __y)
-        {return !(__x == __y);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
+  operator<=(const __bit_iterator& __x, const __bit_iterator& __y) {
+    return !(__y < __x);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool operator<(const __bit_iterator& __x, const __bit_iterator& __y)
-        {return __x.__seg_ < __y.__seg_ || (__x.__seg_ == __y.__seg_ && __x.__ctz_ < __y.__ctz_);}
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool operator>(const __bit_iterator& __x, const __bit_iterator& __y)
-        {return __y < __x;}
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool operator<=(const __bit_iterator& __x, const __bit_iterator& __y)
-        {return !(__y < __x);}
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool operator>=(const __bit_iterator& __x, const __bit_iterator& __y)
-        {return !(__x < __y);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
+  operator>=(const __bit_iterator& __x, const __bit_iterator& __y) {
+    return !(__x < __y);
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    explicit __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
-        : __seg_(__s), __ctz_(__ctz) {}
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
+      : __seg_(__s),
+        __ctz_(__ctz) {}
 
-    friend typename _Cp::__self;
+  friend typename _Cp::__self;
 
-    friend class __bit_reference<_Cp>;
-    friend class __bit_const_reference<_Cp>;
-    friend class __bit_iterator<_Cp, true>;
-    template <class _Dp> friend struct __bit_array;
-    template <class _Dp>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend void __fill_n_false(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
+  friend class __bit_reference<_Cp>;
+  friend class __bit_const_reference<_Cp>;
+  friend class __bit_iterator<_Cp, true>;
+  template <class _Dp>
+  friend struct __bit_array;
 
-    template <class _Dp>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend void __fill_n_true(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
+  template <bool _FillVal, class _Dp>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend void
+  __fill_n_bool(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n);
 
-    template <class _Dp, bool _IC>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend __bit_iterator<_Dp, false> __copy_aligned(__bit_iterator<_Dp, _IC> __first,
-                                                     __bit_iterator<_Dp, _IC> __last,
-                                                     __bit_iterator<_Dp, false> __result);
-    template <class _Dp, bool _IC>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend __bit_iterator<_Dp, false> __copy_unaligned(__bit_iterator<_Dp, _IC> __first,
-                                                       __bit_iterator<_Dp, _IC> __last,
-                                                       __bit_iterator<_Dp, false> __result);
-    template <class _Dp, bool _IC>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend __bit_iterator<_Dp, false> copy(__bit_iterator<_Dp, _IC> __first,
-                                           __bit_iterator<_Dp, _IC> __last,
-                                           __bit_iterator<_Dp, false> __result);
-    template <class _Dp, bool _IC>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend __bit_iterator<_Dp, false> __copy_backward_aligned(__bit_iterator<_Dp, _IC> __first,
-                                                              __bit_iterator<_Dp, _IC> __last,
-                                                              __bit_iterator<_Dp, false> __result);
-    template <class _Dp, bool _IC>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend __bit_iterator<_Dp, false> __copy_backward_unaligned(__bit_iterator<_Dp, _IC> __first,
-                                                                __bit_iterator<_Dp, _IC> __last,
-                                                                __bit_iterator<_Dp, false> __result);
-    template <class _Dp, bool _IC>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend __bit_iterator<_Dp, false> copy_backward(__bit_iterator<_Dp, _IC> __first,
-                                                    __bit_iterator<_Dp, _IC> __last,
-                                                    __bit_iterator<_Dp, false> __result);
-    template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>,
-                                                                                           __bit_iterator<__C1, false>,
-                                                                                           __bit_iterator<__C2, false>);
-    template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>,
-                                                                                             __bit_iterator<__C1, false>,
-                                                                                             __bit_iterator<__C2, false>);
-    template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>,
-                                                                                 __bit_iterator<__C1, false>,
-                                                                                 __bit_iterator<__C2, false>);
-    template <class _Dp>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend __bit_iterator<_Dp, false> rotate(__bit_iterator<_Dp, false>,
-                                             __bit_iterator<_Dp, false>,
-                                             __bit_iterator<_Dp, false>);
-    template <class _Dp, bool _IC1, bool _IC2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend bool __equal_aligned(__bit_iterator<_Dp, _IC1>,
-                                __bit_iterator<_Dp, _IC1>,
-                                __bit_iterator<_Dp, _IC2>);
-    template <class _Dp, bool _IC1, bool _IC2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend bool __equal_unaligned(__bit_iterator<_Dp, _IC1>,
-                                  __bit_iterator<_Dp, _IC1>,
-                                  __bit_iterator<_Dp, _IC2>);
-    template <class _Dp, bool _IC1, bool _IC2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend bool equal(__bit_iterator<_Dp, _IC1>,
-                      __bit_iterator<_Dp, _IC1>,
-                      __bit_iterator<_Dp, _IC2>);
-    template <class _Dp, bool _IC>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend __bit_iterator<_Dp, _IC> __find_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
-    template <class _Dp, bool _IC>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    friend __bit_iterator<_Dp, _IC> __find_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
-    template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-                   __count_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
-    template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type
-                   __count_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
+  template <class _Dp, bool _IC>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_aligned(
+      __bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
+  template <class _Dp, bool _IC>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_unaligned(
+      __bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
+  template <class _Dp, bool _IC>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false>
+  copy(__bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
+  template <class _Dp, bool _IC>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_backward_aligned(
+      __bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
+  template <class _Dp, bool _IC>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_backward_unaligned(
+      __bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
+  template <class _Dp, bool _IC>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false>
+  copy_backward(__bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
+  template <class _Cl, class _Cr>
+  friend __bit_iterator<_Cr, false>
+      __swap_ranges_aligned(__bit_iterator<_Cl, false>, __bit_iterator<_Cl, false>, __bit_iterator<_Cr, false>);
+  template <class _Cl, class _Cr>
+  friend __bit_iterator<_Cr, false>
+      __swap_ranges_unaligned(__bit_iterator<_Cl, false>, __bit_iterator<_Cl, false>, __bit_iterator<_Cr, false>);
+  template <class _Cl, class _Cr>
+  friend __bit_iterator<_Cr, false>
+      swap_ranges(__bit_iterator<_Cl, false>, __bit_iterator<_Cl, false>, __bit_iterator<_Cr, false>);
+  template <class _Dp>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false>
+      rotate(__bit_iterator<_Dp, false>, __bit_iterator<_Dp, false>, __bit_iterator<_Dp, false>);
+  template <class _Dp, bool _IC1, bool _IC2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
+      __equal_aligned(__bit_iterator<_Dp, _IC1>, __bit_iterator<_Dp, _IC1>, __bit_iterator<_Dp, _IC2>);
+  template <class _Dp, bool _IC1, bool _IC2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
+      __equal_unaligned(__bit_iterator<_Dp, _IC1>, __bit_iterator<_Dp, _IC1>, __bit_iterator<_Dp, _IC2>);
+  template <class _Dp, bool _IC1, bool _IC2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool
+      equal(__bit_iterator<_Dp, _IC1>, __bit_iterator<_Dp, _IC1>, __bit_iterator<_Dp, _IC2>);
+  template <bool _ToFind, class _Dp, bool _IC>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, _IC>
+      __find_bool(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
+  template <bool _ToCount, class _Dp, bool _IC>
+  friend typename __bit_iterator<_Dp, _IC>::difference_type _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 __count_bool(__bit_iterator<_Dp, _IC>, typename _Dp::size_type);
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__charconv/chars_format.h b/third_party/libcxx/__charconv/chars_format.h
index 0e781c047..c76cebd5d 100644
--- a/third_party/libcxx/__charconv/chars_format.h
+++ b/third_party/libcxx/__charconv/chars_format.h
@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-enum class _LIBCPP_ENUM_VIS chars_format { scientific = 0x1, fixed = 0x2, hex = 0x4, general = fixed | scientific };
+enum class chars_format { scientific = 0x1, fixed = 0x2, hex = 0x4, general = fixed | scientific };
 
 inline _LIBCPP_HIDE_FROM_ABI constexpr chars_format operator~(chars_format __x) {
   return chars_format(~std::__to_underlying(__x));
@@ -39,20 +39,17 @@ inline _LIBCPP_HIDE_FROM_ABI constexpr chars_format operator^(chars_format __x,
   return chars_format(std::__to_underlying(__x) ^ std::__to_underlying(__y));
 }
 
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 chars_format&
-operator&=(chars_format& __x, chars_format __y) {
+inline _LIBCPP_HIDE_FROM_ABI constexpr chars_format& operator&=(chars_format& __x, chars_format __y) {
   __x = __x & __y;
   return __x;
 }
 
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 chars_format&
-operator|=(chars_format& __x, chars_format __y) {
+inline _LIBCPP_HIDE_FROM_ABI constexpr chars_format& operator|=(chars_format& __x, chars_format __y) {
   __x = __x | __y;
   return __x;
 }
 
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 chars_format&
-operator^=(chars_format& __x, chars_format __y) {
+inline _LIBCPP_HIDE_FROM_ABI constexpr chars_format& operator^=(chars_format& __x, chars_format __y) {
   __x = __x ^ __y;
   return __x;
 }
diff --git a/third_party/libcxx/__charconv/from_chars_integral.h b/third_party/libcxx/__charconv/from_chars_integral.h
index 990aa2174..c1f033b37 100644
--- a/third_party/libcxx/__charconv/from_chars_integral.h
+++ b/third_party/libcxx/__charconv/from_chars_integral.h
@@ -11,6 +11,7 @@
 #define _LIBCPP___CHARCONV_FROM_CHARS_INTEGRAL_H
 
 #include <__algorithm/copy_n.h>
+#include <__assert>
 #include <__charconv/from_chars_result.h>
 #include <__charconv/traits.h>
 #include <__config>
@@ -124,7 +125,7 @@ __subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f, _Ts...
   return __r;
 }
 
-template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
+template <typename _Tp, __enable_if_t<is_unsigned<_Tp>::value, int> = 0>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value) {
   using __tx          = __itoa::__traits<_Tp>;
@@ -145,7 +146,7 @@ __from_chars_atoi(const char* __first, const char* __last, _Tp& __value) {
       });
 }
 
-template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
+template <typename _Tp, __enable_if_t<is_signed<_Tp>::value, int> = 0>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value) {
   using __t = decltype(std::__to_unsigned_like(__value));
@@ -170,7 +171,7 @@ inline constexpr float __from_chars_log2f_lut[35] = {
     4.321928,  4.3923173, 4.4594316, 4.523562, 4.5849624, 4.643856, 4.70044,  4.7548876, 4.807355,
     4.857981,  4.9068904, 4.9541965, 5,        5.044394,  5.087463, 5.129283, 5.169925};
 
-template <typename _Tp, typename enable_if<is_unsigned<_Tp>::value, int>::type = 0>
+template <typename _Tp, __enable_if_t<is_unsigned<_Tp>::value, int> = 0>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value, int __base) {
   if (__base == 10)
@@ -211,23 +212,23 @@ __from_chars_integral(const char* __first, const char* __last, _Tp& __value, int
       __base);
 }
 
-template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>
+template <typename _Tp, __enable_if_t<is_signed<_Tp>::value, int> = 0>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_integral(const char* __first, const char* __last, _Tp& __value, int __base) {
   using __t = decltype(std::__to_unsigned_like(__value));
   return std::__sign_combinator(__first, __last, __value, __from_chars_integral<__t>, __base);
 }
 
-template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
+template <typename _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 from_chars(const char* __first, const char* __last, _Tp& __value) {
   return std::__from_chars_atoi(__first, __last, __value);
 }
 
-template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
+template <typename _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI from_chars_result
 from_chars(const char* __first, const char* __last, _Tp& __value, int __base) {
-  _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
+  _LIBCPP_ASSERT_UNCATEGORIZED(2 <= __base && __base <= 36, "base not in [2, 36]");
   return std::__from_chars_integral(__first, __last, __value, __base);
 }
 #endif // _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/__charconv/from_chars_result.h b/third_party/libcxx/__charconv/from_chars_result.h
index 7eeb9ec81..a7bfd6530 100644
--- a/third_party/libcxx/__charconv/from_chars_result.h
+++ b/third_party/libcxx/__charconv/from_chars_result.h
@@ -21,12 +21,15 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-struct _LIBCPP_TYPE_VIS from_chars_result {
+struct _LIBCPP_EXPORTED_FROM_ABI from_chars_result {
   const char* ptr;
   errc ec;
 #  if _LIBCPP_STD_VER >= 20
   _LIBCPP_HIDE_FROM_ABI friend bool operator==(const from_chars_result&, const from_chars_result&) = default;
 #  endif
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return ec == errc{}; }
+#  endif
 };
 
 #endif // _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/__charconv/to_chars_base_10.h b/third_party/libcxx/__charconv/to_chars_base_10.h
index 028ff3352..c49f4f679 100644
--- a/third_party/libcxx/__charconv/to_chars_base_10.h
+++ b/third_party/libcxx/__charconv/to_chars_base_10.h
@@ -11,6 +11,7 @@
 #define _LIBCPP___CHARCONV_TO_CHARS_BASE_10_H
 
 #include <__algorithm/copy_n.h>
+#include <__assert>
 #include <__charconv/tables.h>
 #include <__config>
 #include <cstdint>
@@ -132,14 +133,14 @@ __base_10_u64(char* __buffer, uint64_t __value) noexcept {
 /// range that can be used. However the range is sufficient for
 /// \ref __base_10_u128.
 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline __uint128_t __pow_10(int __exp) noexcept {
-  _LIBCPP_ASSERT(__exp >= __pow10_128_offset, "Index out of bounds");
+  _LIBCPP_ASSERT_INTERNAL(__exp >= __pow10_128_offset, "Index out of bounds");
   return __pow10_128[__exp - __pow10_128_offset];
 }
 
 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI inline char*
 __base_10_u128(char* __buffer, __uint128_t __value) noexcept {
-  _LIBCPP_ASSERT(
-      __value > numeric_limits<uint64_t>::max(), "The optimizations for this algorithm fail when this isn't true.");
+  _LIBCPP_ASSERT_INTERNAL(
+      __value > numeric_limits<uint64_t>::max(), "The optimizations for this algorithm fails when this isn't true.");
 
   // Unlike the 64 to 32 bit case the 128 bit case the "upper half" can't be
   // stored in the "lower half". Instead we first need to handle the top most
diff --git a/third_party/libcxx/__charconv/to_chars_floating_point.h b/third_party/libcxx/__charconv/to_chars_floating_point.h
index 6ede36e88..118f316b2 100644
--- a/third_party/libcxx/__charconv/to_chars_floating_point.h
+++ b/third_party/libcxx/__charconv/to_chars_floating_point.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___CHARCONV_TO_CHARS_FLOATING_POINT_H
 #define _LIBCPP___CHARCONV_TO_CHARS_FLOATING_POINT_H
 
-#include <__availability>
 #include <__charconv/chars_format.h>
 #include <__charconv/to_chars_result.h>
 #include <__config>
@@ -23,31 +22,31 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS to_chars_result
+_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_EXPORTED_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, float __value);
 
-_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS to_chars_result
+_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_EXPORTED_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, double __value);
 
-_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS to_chars_result
+_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_EXPORTED_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, long double __value);
 
-_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS to_chars_result
+_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_EXPORTED_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, float __value, chars_format __fmt);
 
-_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS to_chars_result
+_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_EXPORTED_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, double __value, chars_format __fmt);
 
-_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS to_chars_result
+_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_EXPORTED_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, long double __value, chars_format __fmt);
 
-_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS to_chars_result
+_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_EXPORTED_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, float __value, chars_format __fmt, int __precision);
 
-_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS to_chars_result
+_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_EXPORTED_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, double __value, chars_format __fmt, int __precision);
 
-_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS to_chars_result
+_LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_EXPORTED_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, long double __value, chars_format __fmt, int __precision);
 #endif // _LIBCPP_STD_VER >= 17
 
diff --git a/third_party/libcxx/__charconv/to_chars_integral.h b/third_party/libcxx/__charconv/to_chars_integral.h
index 6c726c088..0369f4dfb 100644
--- a/third_party/libcxx/__charconv/to_chars_integral.h
+++ b/third_party/libcxx/__charconv/to_chars_integral.h
@@ -11,6 +11,7 @@
 #define _LIBCPP___CHARCONV_TO_CHARS_INTEGRAL_H
 
 #include <__algorithm/copy_n.h>
+#include <__assert>
 #include <__bit/countl.h>
 #include <__charconv/tables.h>
 #include <__charconv/to_chars_base_10.h>
@@ -222,23 +223,23 @@ struct _LIBCPP_HIDDEN __integral<16> {
 
 } // namespace __itoa
 
-template <unsigned _Base, typename _Tp, typename enable_if<(sizeof(_Tp) >= sizeof(unsigned)), int>::type = 0>
+template <unsigned _Base, typename _Tp, __enable_if_t<(sizeof(_Tp) >= sizeof(unsigned)), int> = 0>
 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int __to_chars_integral_width(_Tp __value) {
   return __itoa::__integral<_Base>::__width(__value);
 }
 
-template <unsigned _Base, typename _Tp, typename enable_if<(sizeof(_Tp) < sizeof(unsigned)), int>::type = 0>
+template <unsigned _Base, typename _Tp, __enable_if_t<(sizeof(_Tp) < sizeof(unsigned)), int> = 0>
 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int __to_chars_integral_width(_Tp __value) {
   return std::__to_chars_integral_width<_Base>(static_cast<unsigned>(__value));
 }
 
-template <unsigned _Base, typename _Tp, typename enable_if<(sizeof(_Tp) >= sizeof(unsigned)), int>::type = 0>
+template <unsigned _Base, typename _Tp, __enable_if_t<(sizeof(_Tp) >= sizeof(unsigned)), int> = 0>
 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value) {
   return __itoa::__integral<_Base>::__to_chars(__first, __last, __value);
 }
 
-template <unsigned _Base, typename _Tp, typename enable_if<(sizeof(_Tp) < sizeof(unsigned)), int>::type = 0>
+template <unsigned _Base, typename _Tp, __enable_if_t<(sizeof(_Tp) < sizeof(unsigned)), int> = 0>
 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 __to_chars_integral(char* __first, char* __last, _Tp __value) {
   return std::__to_chars_integral<_Base>(__first, __last, static_cast<unsigned>(__value));
@@ -246,7 +247,7 @@ __to_chars_integral(char* __first, char* __last, _Tp __value) {
 
 template <typename _Tp>
 _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int __to_chars_integral_width(_Tp __value, unsigned __base) {
-  _LIBCPP_ASSERT(__value >= 0, "The function requires a non-negative value.");
+  _LIBCPP_ASSERT_INTERNAL(__value >= 0, "The function requires a non-negative value.");
 
   unsigned __base_2 = __base * __base;
   unsigned __base_3 = __base_2 * __base;
@@ -300,7 +301,7 @@ __to_chars_integral(char* __first, char* __last, _Tp __value, int __base, false_
   return {__last, errc(0)};
 }
 
-template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
+template <typename _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, _Tp __value) {
   using _Type = __make_32_64_or_128_bit_t<_Tp>;
@@ -308,10 +309,10 @@ to_chars(char* __first, char* __last, _Tp __value) {
   return std::__to_chars_itoa(__first, __last, static_cast<_Type>(__value), is_signed<_Tp>());
 }
 
-template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
+template <typename _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
 inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI to_chars_result
 to_chars(char* __first, char* __last, _Tp __value, int __base) {
-  _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
+  _LIBCPP_ASSERT_UNCATEGORIZED(2 <= __base && __base <= 36, "base not in [2, 36]");
 
   using _Type = __make_32_64_or_128_bit_t<_Tp>;
   return std::__to_chars_integral(__first, __last, static_cast<_Type>(__value), __base, is_signed<_Tp>());
diff --git a/third_party/libcxx/__charconv/to_chars_result.h b/third_party/libcxx/__charconv/to_chars_result.h
index 67221b398..8df0897a4 100644
--- a/third_party/libcxx/__charconv/to_chars_result.h
+++ b/third_party/libcxx/__charconv/to_chars_result.h
@@ -21,12 +21,15 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-struct _LIBCPP_TYPE_VIS to_chars_result {
+struct _LIBCPP_EXPORTED_FROM_ABI to_chars_result {
   char* ptr;
   errc ec;
 #  if _LIBCPP_STD_VER >= 20
   _LIBCPP_HIDE_FROM_ABI friend bool operator==(const to_chars_result&, const to_chars_result&) = default;
 #  endif
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return ec == errc{}; }
+#  endif
 };
 
 #endif // _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/__charconv/traits.h b/third_party/libcxx/__charconv/traits.h
index 505a0b1ac..c91c6da32 100644
--- a/third_party/libcxx/__charconv/traits.h
+++ b/third_party/libcxx/__charconv/traits.h
@@ -10,6 +10,7 @@
 #ifndef _LIBCPP___CHARCONV_TRAITS
 #define _LIBCPP___CHARCONV_TRAITS
 
+#include <__assert>
 #include <__bit/countl.h>
 #include <__charconv/tables.h>
 #include <__charconv/to_chars_base_10.h>
@@ -101,11 +102,11 @@ struct _LIBCPP_HIDDEN __traits_base<_Tp, __enable_if_t<sizeof(_Tp) == sizeof(__u
   /// zero is set to one. This means the first element of the lookup table is
   /// zero.
   static _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI int __width(_Tp __v) {
-    _LIBCPP_ASSERT(
+    _LIBCPP_ASSERT_INTERNAL(
         __v > numeric_limits<uint64_t>::max(), "The optimizations for this algorithm fail when this isn't true.");
     // There's always a bit set in the upper 64-bits.
     auto __t = (128 - std::__libcpp_clz(static_cast<uint64_t>(__v >> 64))) * 1233 >> 12;
-    _LIBCPP_ASSERT(__t >= __itoa::__pow10_128_offset, "Index out of bounds");
+    _LIBCPP_ASSERT_INTERNAL(__t >= __itoa::__pow10_128_offset, "Index out of bounds");
     // __t is adjusted since the lookup table misses the lower entries.
     return __t - (__v < __itoa::__pow10_128[__t - __itoa::__pow10_128_offset]) + 1;
   }
diff --git a/third_party/libcxx/__chrono/calendar.h b/third_party/libcxx/__chrono/calendar.h
index 94b5e315c..bb1c5e7eb 100644
--- a/third_party/libcxx/__chrono/calendar.h
+++ b/third_party/libcxx/__chrono/calendar.h
@@ -22,19 +22,19 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 struct local_t {};
-template<class Duration>
-using local_time  = time_point<local_t, Duration>;
+template <class _Duration>
+using local_time    = time_point<local_t, _Duration>;
 using local_seconds = local_time<seconds>;
 using local_days    = local_time<days>;
 
-struct last_spec { explicit last_spec() = default; };
+struct last_spec {
+  explicit last_spec() = default;
+};
 inline constexpr last_spec last{};
 
-
 } // namespace chrono
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__chrono/convert_to_timespec.h b/third_party/libcxx/__chrono/convert_to_timespec.h
index fab07f256..11e0b826d 100644
--- a/third_party/libcxx/__chrono/convert_to_timespec.h
+++ b/third_party/libcxx/__chrono/convert_to_timespec.h
@@ -26,23 +26,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // Convert a nanoseconds duration to the given TimeSpec type, which must have
 // the same properties as std::timespec.
 template <class _TimeSpec>
-_LIBCPP_HIDE_FROM_ABI inline
-_TimeSpec __convert_to_timespec(const chrono::nanoseconds& __ns)
-{
+_LIBCPP_HIDE_FROM_ABI inline _TimeSpec __convert_to_timespec(const chrono::nanoseconds& __ns) {
   using namespace chrono;
   seconds __s = duration_cast<seconds>(__ns);
   _TimeSpec __ts;
   typedef decltype(__ts.tv_sec) __ts_sec;
   const __ts_sec __ts_sec_max = numeric_limits<__ts_sec>::max();
 
-  if (__s.count() < __ts_sec_max)
-  {
-    __ts.tv_sec = static_cast<__ts_sec>(__s.count());
+  if (__s.count() < __ts_sec_max) {
+    __ts.tv_sec  = static_cast<__ts_sec>(__s.count());
     __ts.tv_nsec = static_cast<decltype(__ts.tv_nsec)>((__ns - __s).count());
-  }
-  else
-  {
-    __ts.tv_sec = __ts_sec_max;
+  } else {
+    __ts.tv_sec  = __ts_sec_max;
     __ts.tv_nsec = 999999999; // (10^9 - 1)
   }
 
diff --git a/third_party/libcxx/__chrono/convert_to_tm.h b/third_party/libcxx/__chrono/convert_to_tm.h
index f4dcddece..3a51019b8 100644
--- a/third_party/libcxx/__chrono/convert_to_tm.h
+++ b/third_party/libcxx/__chrono/convert_to_tm.h
@@ -16,10 +16,12 @@
 #include <__chrono/duration.h>
 #include <__chrono/file_clock.h>
 #include <__chrono/hh_mm_ss.h>
+#include <__chrono/local_info.h>
 #include <__chrono/month.h>
 #include <__chrono/month_weekday.h>
 #include <__chrono/monthday.h>
 #include <__chrono/statically_widen.h>
+#include <__chrono/sys_info.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
 #include <__chrono/weekday.h>
@@ -27,10 +29,13 @@
 #include <__chrono/year_month.h>
 #include <__chrono/year_month_day.h>
 #include <__chrono/year_month_weekday.h>
+#include <__chrono/zoned_time.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/format_error.h>
 #include <__memory/addressof.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_specialization.h>
 #include <cstdint>
 #include <ctime>
 #include <limits>
@@ -77,7 +82,7 @@ _LIBCPP_HIDE_FROM_ABI _Tm __convert_to_tm(const _Date& __date, chrono::weekday _
 
 template <class _Tm, class _Duration>
 _LIBCPP_HIDE_FROM_ABI _Tm __convert_to_tm(const chrono::sys_time<_Duration> __tp) {
-  chrono::sys_days __days = chrono::time_point_cast<chrono::days>(__tp);
+  chrono::sys_days __days = chrono::floor<chrono::days>(__tp);
   chrono::year_month_day __ymd{__days};
 
   _Tm __result = std::__convert_to_tm<_Tm>(chrono::year_month_day{__ymd}, chrono::weekday{__days});
@@ -116,12 +121,23 @@ _LIBCPP_HIDE_FROM_ABI _Tm __convert_to_tm(const _ChronoT& __value) {
     //   ...  However, if a flag refers to a "time of day" (e.g. %H, %I, %p,
     //   etc.), then a specialization of duration is interpreted as the time of
     //   day elapsed since midnight.
-    uint64_t __sec = chrono::duration_cast<chrono::seconds>(__value).count();
-    __sec %= 24 * 3600;
-    __result.tm_hour = __sec / 3600;
-    __sec %= 3600;
-    __result.tm_min = __sec / 60;
-    __result.tm_sec = __sec % 60;
+
+    // Not all values can be converted to hours, it may run into ratio
+    // conversion errors. In that case the conversion to seconds works.
+    if constexpr (is_convertible_v<_ChronoT, chrono::hours>) {
+      auto __hour      = chrono::floor<chrono::hours>(__value);
+      auto __sec       = chrono::duration_cast<chrono::seconds>(__value - __hour);
+      __result.tm_hour = __hour.count() % 24;
+      __result.tm_min  = __sec.count() / 60;
+      __result.tm_sec  = __sec.count() % 60;
+    } else {
+      uint64_t __sec = chrono::duration_cast<chrono::seconds>(__value).count();
+      __sec %= 24 * 3600;
+      __result.tm_hour = __sec / 3600;
+      __sec %= 3600;
+      __result.tm_min = __sec / 60;
+      __result.tm_sec = __sec % 60;
+    }
   } else if constexpr (same_as<_ChronoT, chrono::day>)
     __result.tm_mday = static_cast<unsigned>(__value);
   else if constexpr (same_as<_ChronoT, chrono::month>)
@@ -159,6 +175,18 @@ _LIBCPP_HIDE_FROM_ABI _Tm __convert_to_tm(const _ChronoT& __value) {
       if (__value.hours().count() > std::numeric_limits<decltype(__result.tm_hour)>::max())
         std::__throw_format_error("Formatting hh_mm_ss, encountered an hour overflow");
     __result.tm_hour = __value.hours().count();
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+  } else if constexpr (same_as<_ChronoT, chrono::sys_info>) {
+    // Has no time information.
+  } else if constexpr (same_as<_ChronoT, chrono::local_info>) {
+    // Has no time information.
+#    if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                          \
+        !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  } else if constexpr (__is_specialization_v<_ChronoT, chrono::zoned_time>) {
+    return std::__convert_to_tm<_Tm>(
+        chrono::sys_time<typename _ChronoT::duration>{__value.get_local_time().time_since_epoch()});
+#    endif
+#  endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
   } else
     static_assert(sizeof(_ChronoT) == 0, "Add the missing type specialization");
 
diff --git a/third_party/libcxx/__chrono/day.h b/third_party/libcxx/__chrono/day.h
index c907c036c..7342084b0 100644
--- a/third_party/libcxx/__chrono/day.h
+++ b/third_party/libcxx/__chrono/day.h
@@ -22,58 +22,73 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 class day {
 private:
-    unsigned char __d_;
+  unsigned char __d_;
+
 public:
-    day() = default;
-    _LIBCPP_HIDE_FROM_ABI explicit inline constexpr day(unsigned __val) noexcept : __d_(static_cast<unsigned char>(__val)) {}
-    _LIBCPP_HIDE_FROM_ABI inline constexpr day& operator++()    noexcept { ++__d_; return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr day  operator++(int) noexcept { day __tmp = *this; ++(*this); return __tmp; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr day& operator--()    noexcept { --__d_; return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr day  operator--(int) noexcept { day __tmp = *this; --(*this); return __tmp; }
-    _LIBCPP_HIDE_FROM_ABI        constexpr day& operator+=(const days& __dd) noexcept;
-    _LIBCPP_HIDE_FROM_ABI        constexpr day& operator-=(const days& __dd) noexcept;
-    _LIBCPP_HIDE_FROM_ABI explicit inline constexpr operator unsigned() const noexcept { return __d_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __d_ >= 1 && __d_ <= 31; }
-  };
+  day() = default;
+  _LIBCPP_HIDE_FROM_ABI explicit inline constexpr day(unsigned __val) noexcept
+      : __d_(static_cast<unsigned char>(__val)) {}
+  _LIBCPP_HIDE_FROM_ABI inline constexpr day& operator++() noexcept {
+    ++__d_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr day operator++(int) noexcept {
+    day __tmp = *this;
+    ++(*this);
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr day& operator--() noexcept {
+    --__d_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr day operator--(int) noexcept {
+    day __tmp = *this;
+    --(*this);
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr day& operator+=(const days& __dd) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr day& operator-=(const days& __dd) noexcept;
+  _LIBCPP_HIDE_FROM_ABI explicit inline constexpr operator unsigned() const noexcept { return __d_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __d_ >= 1 && __d_ <= 31; }
+};
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator==(const day& __lhs, const day& __rhs) noexcept {
+  return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs);
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const day& __lhs, const day& __rhs) noexcept
-{ return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); }
-
-_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const day& __lhs, const day& __rhs) noexcept {
+_LIBCPP_HIDE_FROM_ABI inline constexpr strong_ordering operator<=>(const day& __lhs, const day& __rhs) noexcept {
   return static_cast<unsigned>(__lhs) <=> static_cast<unsigned>(__rhs);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-day operator+ (const day& __lhs, const days& __rhs) noexcept
-{ return day(static_cast<unsigned>(__lhs) + __rhs.count()); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr day operator+(const day& __lhs, const days& __rhs) noexcept {
+  return day(static_cast<unsigned>(__lhs) + __rhs.count());
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-day operator+ (const days& __lhs, const day& __rhs) noexcept
-{ return __rhs + __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr day operator+(const days& __lhs, const day& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-day operator- (const day& __lhs, const days& __rhs) noexcept
-{ return __lhs + -__rhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr day operator-(const day& __lhs, const days& __rhs) noexcept {
+  return __lhs + -__rhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-days operator-(const day& __lhs, const day& __rhs) noexcept
-{ return days(static_cast<int>(static_cast<unsigned>(__lhs)) -
-              static_cast<int>(static_cast<unsigned>(__rhs))); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr days operator-(const day& __lhs, const day& __rhs) noexcept {
+  return days(static_cast<int>(static_cast<unsigned>(__lhs)) - static_cast<int>(static_cast<unsigned>(__rhs)));
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-day& day::operator+=(const days& __dd) noexcept
-{ *this = *this + __dd; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr day& day::operator+=(const days& __dd) noexcept {
+  *this = *this + __dd;
+  return *this;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-day& day::operator-=(const days& __dd) noexcept
-{ *this = *this - __dd; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr day& day::operator-=(const days& __dd) noexcept {
+  *this = *this - __dd;
+  return *this;
+}
 
 } // namespace chrono
 
diff --git a/third_party/libcxx/__chrono/duration.h b/third_party/libcxx/__chrono/duration.h
index 96e9671eb..1e36d7342 100644
--- a/third_party/libcxx/__chrono/duration.h
+++ b/third_party/libcxx/__chrono/duration.h
@@ -29,104 +29,82 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
-template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration;
+template <class _Rep, class _Period = ratio<1> >
+class _LIBCPP_TEMPLATE_VIS duration;
 
 template <class _Tp>
 struct __is_duration : false_type {};
 
 template <class _Rep, class _Period>
-struct __is_duration<duration<_Rep, _Period> > : true_type  {};
+struct __is_duration<duration<_Rep, _Period> > : true_type {};
 
 template <class _Rep, class _Period>
-struct __is_duration<const duration<_Rep, _Period> > : true_type  {};
+struct __is_duration<const duration<_Rep, _Period> > : true_type {};
 
 template <class _Rep, class _Period>
-struct __is_duration<volatile duration<_Rep, _Period> > : true_type  {};
+struct __is_duration<volatile duration<_Rep, _Period> > : true_type {};
 
 template <class _Rep, class _Period>
-struct __is_duration<const volatile duration<_Rep, _Period> > : true_type  {};
+struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {};
 
 } // namespace chrono
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>,
-                                         chrono::duration<_Rep2, _Period2> >
-{
-    typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
-                             typename __ratio_gcd<_Period1, _Period2>::type> type;
+struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>, chrono::duration<_Rep2, _Period2> > {
+  typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type, typename __ratio_gcd<_Period1, _Period2>::type>
+      type;
 };
 
 namespace chrono {
 
 // duration_cast
 
-template <class _FromDuration, class _ToDuration,
+template <class _FromDuration,
+          class _ToDuration,
           class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type,
-          bool = _Period::num == 1,
-          bool = _Period::den == 1>
+          bool          = _Period::num == 1,
+          bool          = _Period::den == 1>
 struct __duration_cast;
 
 template <class _FromDuration, class _ToDuration, class _Period>
-struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    _ToDuration operator()(const _FromDuration& __fd) const
-    {
-        return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
-    }
+struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true> {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration operator()(const _FromDuration& __fd) const {
+    return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
+  }
 };
 
 template <class _FromDuration, class _ToDuration, class _Period>
-struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    _ToDuration operator()(const _FromDuration& __fd) const
-    {
-        typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
-        return _ToDuration(static_cast<typename _ToDuration::rep>(
-                           static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den)));
-    }
+struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false> {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration operator()(const _FromDuration& __fd) const {
+    typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
+    return _ToDuration(
+        static_cast<typename _ToDuration::rep>(static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den)));
+  }
 };
 
 template <class _FromDuration, class _ToDuration, class _Period>
-struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    _ToDuration operator()(const _FromDuration& __fd) const
-    {
-        typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
-        return _ToDuration(static_cast<typename _ToDuration::rep>(
-                           static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)));
-    }
+struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true> {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration operator()(const _FromDuration& __fd) const {
+    typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
+    return _ToDuration(
+        static_cast<typename _ToDuration::rep>(static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)));
+  }
 };
 
 template <class _FromDuration, class _ToDuration, class _Period>
-struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    _ToDuration operator()(const _FromDuration& __fd) const
-    {
-        typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
-        return _ToDuration(static_cast<typename _ToDuration::rep>(
-                           static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)
-                                                          / static_cast<_Ct>(_Period::den)));
-    }
+struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false> {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration operator()(const _FromDuration& __fd) const {
+    typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
+    return _ToDuration(static_cast<typename _ToDuration::rep>(
+        static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num) / static_cast<_Ct>(_Period::den)));
+  }
 };
 
-template <class _ToDuration, class _Rep, class _Period>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    _ToDuration
->::type
-duration_cast(const duration<_Rep, _Period>& __fd)
-{
-    return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
+template <class _ToDuration, class _Rep, class _Period, __enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration duration_cast(const duration<_Rep, _Period>& __fd) {
+  return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
 }
 
 template <class _Rep>
@@ -138,210 +116,204 @@ inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>:
 #endif
 
 template <class _Rep>
-struct _LIBCPP_TEMPLATE_VIS duration_values
-{
+struct _LIBCPP_TEMPLATE_VIS duration_values {
 public:
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT {return _Rep(0);}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max()  _NOEXCEPT {return numeric_limits<_Rep>::max();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min()  _NOEXCEPT {return numeric_limits<_Rep>::lowest();}
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT { return _Rep(0); }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR _Rep max() _NOEXCEPT { return numeric_limits<_Rep>::max(); }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR _Rep min() _NOEXCEPT { return numeric_limits<_Rep>::lowest(); }
 };
 
 #if _LIBCPP_STD_VER >= 17
-template <class _ToDuration, class _Rep, class _Period>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    _ToDuration
->::type
-floor(const duration<_Rep, _Period>& __d)
-{
-    _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
-    if (__t > __d)
-        __t = __t - _ToDuration{1};
-    return __t;
+template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration floor(const duration<_Rep, _Period>& __d) {
+  _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
+  if (__t > __d)
+    __t = __t - _ToDuration{1};
+  return __t;
 }
 
-template <class _ToDuration, class _Rep, class _Period>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    _ToDuration
->::type
-ceil(const duration<_Rep, _Period>& __d)
-{
-    _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
-    if (__t < __d)
-        __t = __t + _ToDuration{1};
-    return __t;
+template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration ceil(const duration<_Rep, _Period>& __d) {
+  _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
+  if (__t < __d)
+    __t = __t + _ToDuration{1};
+  return __t;
 }
 
-template <class _ToDuration, class _Rep, class _Period>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    _ToDuration
->::type
-round(const duration<_Rep, _Period>& __d)
-{
-    _ToDuration __lower = chrono::floor<_ToDuration>(__d);
-    _ToDuration __upper = __lower + _ToDuration{1};
-    auto __lower_diff   = __d - __lower;
-    auto __upper_diff   = __upper - __d;
-    if (__lower_diff < __upper_diff)
-        return __lower;
-    if (__lower_diff > __upper_diff)
-        return __upper;
-    return __lower.count() & 1 ? __upper : __lower;
+template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration round(const duration<_Rep, _Period>& __d) {
+  _ToDuration __lower = chrono::floor<_ToDuration>(__d);
+  _ToDuration __upper = __lower + _ToDuration{1};
+  auto __lower_diff   = __d - __lower;
+  auto __upper_diff   = __upper - __d;
+  if (__lower_diff < __upper_diff)
+    return __lower;
+  if (__lower_diff > __upper_diff)
+    return __upper;
+  return __lower.count() & 1 ? __upper : __lower;
 }
 #endif
 
 // duration
 
 template <class _Rep, class _Period>
-class _LIBCPP_TEMPLATE_VIS duration
-{
-    static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
-    static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
-    static_assert(_Period::num > 0, "duration period must be positive");
+class _LIBCPP_TEMPLATE_VIS duration {
+  static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
+  static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
+  static_assert(_Period::num > 0, "duration period must be positive");
 
-    template <class _R1, class _R2>
-    struct __no_overflow
+  template <class _R1, class _R2>
+  struct __no_overflow {
+  private:
+    static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
+    static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
+    static const intmax_t __n1        = _R1::num / __gcd_n1_n2;
+    static const intmax_t __d1        = _R1::den / __gcd_d1_d2;
+    static const intmax_t __n2        = _R2::num / __gcd_n1_n2;
+    static const intmax_t __d2        = _R2::den / __gcd_d1_d2;
+    static const intmax_t max         = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
+
+    template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
+    struct __mul // __overflow == false
     {
-    private:
-        static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
-        static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
-        static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
-        static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
-        static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
-        static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
-        static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
-
-        template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
-        struct __mul    // __overflow == false
-        {
-            static const intmax_t value = _Xp * _Yp;
-        };
-
-        template <intmax_t _Xp, intmax_t _Yp>
-        struct __mul<_Xp, _Yp, true>
-        {
-            static const intmax_t value = 1;
-        };
-
-    public:
-        static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
-        typedef ratio<__mul<__n1, __d2, !value>::value,
-                      __mul<__n2, __d1, !value>::value> type;
+      static const intmax_t value = _Xp * _Yp;
     };
 
-public:
-    typedef _Rep rep;
-    typedef typename _Period::type period;
-private:
-    rep __rep_;
-public:
+    template <intmax_t _Xp, intmax_t _Yp>
+    struct __mul<_Xp, _Yp, true> {
+      static const intmax_t value = 1;
+    };
 
+  public:
+    static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
+    typedef ratio<__mul<__n1, __d2, !value>::value, __mul<__n2, __d1, !value>::value> type;
+  };
+
+public:
+  typedef _Rep rep;
+  typedef typename _Period::type period;
+
+private:
+  rep __rep_;
+
+public:
 #ifndef _LIBCPP_CXX03_LANG
-        constexpr duration() = default;
+  constexpr duration() = default;
 #else
-        _LIBCPP_HIDE_FROM_ABI duration() {}
+  _LIBCPP_HIDE_FROM_ABI duration() {}
 #endif
 
-    template <class _Rep2>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-        explicit duration(const _Rep2& __r,
-            typename enable_if
-            <
-               is_convertible<const _Rep2&, rep>::value &&
-               (treat_as_floating_point<rep>::value ||
-               !treat_as_floating_point<_Rep2>::value)
-            >::type* = nullptr)
-                : __rep_(__r) {}
+  template <class _Rep2,
+            __enable_if_t<is_convertible<const _Rep2&, rep>::value &&
+                              (treat_as_floating_point<rep>::value || !treat_as_floating_point<_Rep2>::value),
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit duration(const _Rep2& __r) : __rep_(__r) {}
 
-    // conversions
-    template <class _Rep2, class _Period2>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-        duration(const duration<_Rep2, _Period2>& __d,
-            typename enable_if
-            <
-                __no_overflow<_Period2, period>::value && (
-                treat_as_floating_point<rep>::value ||
-                (__no_overflow<_Period2, period>::type::den == 1 &&
-                 !treat_as_floating_point<_Rep2>::value))
-            >::type* = nullptr)
-                : __rep_(chrono::duration_cast<duration>(__d).count()) {}
+  // conversions
+  template <class _Rep2,
+            class _Period2,
+            __enable_if_t<__no_overflow<_Period2, period>::value && (treat_as_floating_point<rep>::value ||
+                                                                     (__no_overflow<_Period2, period>::type::den == 1 &&
+                                                                      !treat_as_floating_point<_Rep2>::value)),
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR duration(const duration<_Rep2, _Period2>& __d)
+      : __rep_(chrono::duration_cast<duration>(__d).count()) {}
 
-    // observer
+  // observer
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR rep count() const { return __rep_; }
 
-    // arithmetic
+  // arithmetic
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator++()      {++__rep_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration  operator++(int)   {return duration(__rep_++);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator--()      {--__rep_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration  operator--(int)   {return duration(__rep_--);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {
+    return typename common_type<duration>::type(*this);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {
+    return typename common_type<duration>::type(-__rep_);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator++() {
+    ++__rep_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration operator++(int) { return duration(__rep_++); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator--() {
+    --__rep_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration operator--(int) { return duration(__rep_--); }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator+=(const duration& __d) {
+    __rep_ += __d.count();
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator-=(const duration& __d) {
+    __rep_ -= __d.count();
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator*=(const rep& __rhs) {__rep_ *= __rhs; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator/=(const rep& __rhs) {__rep_ /= __rhs; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator%=(const rep& __rhs) {__rep_ %= __rhs; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator%=(const duration& __rhs) {__rep_ %= __rhs.count(); return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator*=(const rep& __rhs) {
+    __rep_ *= __rhs;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator/=(const rep& __rhs) {
+    __rep_ /= __rhs;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator%=(const rep& __rhs) {
+    __rep_ %= __rhs;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator%=(const duration& __rhs) {
+    __rep_ %= __rhs.count();
+    return *this;
+  }
 
-    // special values
+  // special values
 
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {return duration(duration_values<rep>::zero());}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min()  _NOEXCEPT {return duration(duration_values<rep>::min());}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max()  _NOEXCEPT {return duration(duration_values<rep>::max());}
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {
+    return duration(duration_values<rep>::zero());
+  }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR duration min() _NOEXCEPT {
+    return duration(duration_values<rep>::min());
+  }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR duration max() _NOEXCEPT {
+    return duration(duration_values<rep>::max());
+  }
 };
 
-typedef duration<long long,         nano> nanoseconds;
-typedef duration<long long,        micro> microseconds;
-typedef duration<long long,        milli> milliseconds;
-typedef duration<long long              > seconds;
-typedef duration<     long, ratio<  60> > minutes;
-typedef duration<     long, ratio<3600> > hours;
+typedef duration<long long, nano> nanoseconds;
+typedef duration<long long, micro> microseconds;
+typedef duration<long long, milli> milliseconds;
+typedef duration<long long > seconds;
+typedef duration< long, ratio< 60> > minutes;
+typedef duration< long, ratio<3600> > hours;
 #if _LIBCPP_STD_VER >= 20
-typedef duration<     int, ratio_multiply<ratio<24>, hours::period>>         days;
-typedef duration<     int, ratio_multiply<ratio<7>,   days::period>>         weeks;
-typedef duration<     int, ratio_multiply<ratio<146097, 400>, days::period>> years;
-typedef duration<     int, ratio_divide<years::period, ratio<12>>>           months;
+typedef duration< int, ratio_multiply<ratio<24>, hours::period>> days;
+typedef duration< int, ratio_multiply<ratio<7>, days::period>> weeks;
+typedef duration< int, ratio_multiply<ratio<146097, 400>, days::period>> years;
+typedef duration< int, ratio_divide<years::period, ratio<12>>> months;
 #endif
 // Duration ==
 
 template <class _LhsDuration, class _RhsDuration>
-struct __duration_eq
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
-        {
-            typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
-            return _Ct(__lhs).count() == _Ct(__rhs).count();
-        }
+struct __duration_eq {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const {
+    typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
+    return _Ct(__lhs).count() == _Ct(__rhs).count();
+  }
 };
 
 template <class _LhsDuration>
-struct __duration_eq<_LhsDuration, _LhsDuration>
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
-        {return __lhs.count() == __rhs.count();}
+struct __duration_eq<_LhsDuration, _LhsDuration> {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const {
+    return __lhs.count() == __rhs.count();
+  }
 };
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-bool
-operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
 }
 
 #if _LIBCPP_STD_VER <= 17
@@ -349,12 +321,9 @@ operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period
 // Duration !=
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-bool
-operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    return !(__lhs == __rhs);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  return !(__lhs == __rhs);
 }
 
 #endif // _LIBCPP_STD_VER <= 17
@@ -362,76 +331,58 @@ operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period
 // Duration <
 
 template <class _LhsDuration, class _RhsDuration>
-struct __duration_lt
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
-        {
-            typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
-            return _Ct(__lhs).count() < _Ct(__rhs).count();
-        }
+struct __duration_lt {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const {
+    typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
+    return _Ct(__lhs).count() < _Ct(__rhs).count();
+  }
 };
 
 template <class _LhsDuration>
-struct __duration_lt<_LhsDuration, _LhsDuration>
-{
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
-        {return __lhs.count() < __rhs.count();}
+struct __duration_lt<_LhsDuration, _LhsDuration> {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const {
+    return __lhs.count() < __rhs.count();
+  }
 };
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-bool
-operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator<(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
 }
 
 // Duration >
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-bool
-operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    return __rhs < __lhs;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator>(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  return __rhs < __lhs;
 }
 
 // Duration <=
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-bool
-operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    return !(__rhs < __lhs);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  return !(__rhs < __lhs);
 }
 
 // Duration >=
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-bool
-operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    return !(__lhs < __rhs);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  return !(__lhs < __rhs);
 }
 
 #if _LIBCPP_STD_VER >= 20
 
-template<class _Rep1, class _Period1, class _Rep2, class _Period2>
+template <class _Rep1, class _Period1, class _Rep2, class _Period2>
   requires three_way_comparable<common_type_t<_Rep1, _Rep2>>
-_LIBCPP_HIDE_FROM_ABI
-constexpr auto operator<=>(const duration<_Rep1, _Period1>& __lhs,
-                           const duration<_Rep2, _Period2>& __rhs)
-{
-    using _Ct = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
-    return _Ct(__lhs).count() <=> _Ct(__rhs).count();
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+operator<=>(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  using _Ct = common_type_t<duration<_Rep1, _Period1>, duration<_Rep2, _Period2>>;
+  return _Ct(__lhs).count() <=> _Ct(__rhs).count();
 }
 
 #endif // _LIBCPP_STD_VER >= 20
@@ -439,193 +390,151 @@ constexpr auto operator<=>(const duration<_Rep1, _Period1>& __lhs,
 // Duration +
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
-operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
-    return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
+operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
+  return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
 }
 
 // Duration -
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
-operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
-    return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
+operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
+  return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
 }
 
 // Duration *
 
-template <class _Rep1, class _Period, class _Rep2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-typename enable_if
-<
-    is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
-    duration<typename common_type<_Rep1, _Rep2>::type, _Period>
->::type
-operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
-{
-    typedef typename common_type<_Rep1, _Rep2>::type _Cr;
-    typedef duration<_Cr, _Period> _Cd;
-    return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
+template <class _Rep1,
+          class _Period,
+          class _Rep2,
+          __enable_if_t<is_convertible<const _Rep2&, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) {
+  typedef typename common_type<_Rep1, _Rep2>::type _Cr;
+  typedef duration<_Cr, _Period> _Cd;
+  return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
 }
 
-template <class _Rep1, class _Period, class _Rep2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-typename enable_if
-<
-    is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
-    duration<typename common_type<_Rep1, _Rep2>::type, _Period>
->::type
-operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
-{
-    return __d * __s;
+template <class _Rep1,
+          class _Period,
+          class _Rep2,
+          __enable_if_t<is_convertible<const _Rep1&, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) {
+  return __d * __s;
 }
 
 // Duration /
 
-template <class _Rep1, class _Period, class _Rep2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-typename enable_if
-<
-    !__is_duration<_Rep2>::value &&
-      is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
-    duration<typename common_type<_Rep1, _Rep2>::type, _Period>
->::type
-operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
-{
-    typedef typename common_type<_Rep1, _Rep2>::type _Cr;
-    typedef duration<_Cr, _Period> _Cd;
-    return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
+template <class _Rep1,
+          class _Period,
+          class _Rep2,
+          __enable_if_t<!__is_duration<_Rep2>::value &&
+                            is_convertible<const _Rep2&, typename common_type<_Rep1, _Rep2>::type>::value,
+                        int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) {
+  typedef typename common_type<_Rep1, _Rep2>::type _Cr;
+  typedef duration<_Cr, _Period> _Cd;
+  return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
 }
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-typename common_type<_Rep1, _Rep2>::type
-operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
-    return _Ct(__lhs).count() / _Ct(__rhs).count();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename common_type<_Rep1, _Rep2>::type
+operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
+  return _Ct(__lhs).count() / _Ct(__rhs).count();
 }
 
 // Duration %
 
-template <class _Rep1, class _Period, class _Rep2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-typename enable_if
-<
-    !__is_duration<_Rep2>::value &&
-      is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
-    duration<typename common_type<_Rep1, _Rep2>::type, _Period>
->::type
-operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
-{
-    typedef typename common_type<_Rep1, _Rep2>::type _Cr;
-    typedef duration<_Cr, _Period> _Cd;
-    return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
+template <class _Rep1,
+          class _Period,
+          class _Rep2,
+          __enable_if_t<!__is_duration<_Rep2>::value &&
+                            is_convertible<const _Rep2&, typename common_type<_Rep1, _Rep2>::type>::value,
+                        int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) {
+  typedef typename common_type<_Rep1, _Rep2>::type _Cr;
+  typedef duration<_Cr, _Period> _Cd;
+  return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
 }
 
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
-operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    typedef typename common_type<_Rep1, _Rep2>::type _Cr;
-    typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
-    return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
+operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  typedef typename common_type<_Rep1, _Rep2>::type _Cr;
+  typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
+  return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
 }
 
 } // namespace chrono
 
 #if _LIBCPP_STD_VER >= 14
 // Suffixes for duration literals [time.duration.literals]
-inline namespace literals
-{
-  inline namespace chrono_literals
-  {
+inline namespace literals {
+inline namespace chrono_literals {
 
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::hours operator""h(unsigned long long __h)
-    {
-        return chrono::hours(static_cast<chrono::hours::rep>(__h));
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::hours operator""h(unsigned long long __h) {
+  return chrono::hours(static_cast<chrono::hours::rep>(__h));
+}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h)
-    {
-        return chrono::duration<long double, ratio<3600,1>>(__h);
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, ratio<3600, 1>> operator""h(long double __h) {
+  return chrono::duration<long double, ratio<3600, 1>>(__h);
+}
 
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::minutes operator""min(unsigned long long __m) {
+  return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
+}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::minutes operator""min(unsigned long long __m)
-    {
-        return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, ratio<60, 1>> operator""min(long double __m) {
+  return chrono::duration<long double, ratio<60, 1>>(__m);
+}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m)
-    {
-        return chrono::duration<long double, ratio<60,1>> (__m);
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::seconds operator""s(unsigned long long __s) {
+  return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
+}
 
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double> operator""s(long double __s) {
+  return chrono::duration<long double>(__s);
+}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::seconds operator""s(unsigned long long __s)
-    {
-        return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::milliseconds operator""ms(unsigned long long __ms) {
+  return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
+}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double> operator""s(long double __s)
-    {
-        return chrono::duration<long double> (__s);
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, milli> operator""ms(long double __ms) {
+  return chrono::duration<long double, milli>(__ms);
+}
 
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::microseconds operator""us(unsigned long long __us) {
+  return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
+}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::milliseconds operator""ms(unsigned long long __ms)
-    {
-        return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, micro> operator""us(long double __us) {
+  return chrono::duration<long double, micro>(__us);
+}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, milli> operator""ms(long double __ms)
-    {
-        return chrono::duration<long double, milli>(__ms);
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::nanoseconds operator""ns(unsigned long long __ns) {
+  return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
+}
 
-
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::microseconds operator""us(unsigned long long __us)
-    {
-        return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
-    }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, micro> operator""us(long double __us)
-    {
-        return chrono::duration<long double, micro> (__us);
-    }
-
-
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::nanoseconds operator""ns(unsigned long long __ns)
-    {
-        return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
-    }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, nano> operator""ns(long double __ns)
-    {
-        return chrono::duration<long double, nano> (__ns);
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, nano> operator""ns(long double __ns) {
+  return chrono::duration<long double, nano>(__ns);
+}
 
 } // namespace chrono_literals
 } // namespace literals
 
 namespace chrono { // hoist the literals into namespace std::chrono
-   using namespace literals::chrono_literals;
+using namespace literals::chrono_literals;
 } // namespace chrono
 
 #endif // _LIBCPP_STD_VER >= 14
diff --git a/third_party/libcxx/__chrono/exception.h b/third_party/libcxx/__chrono/exception.h
new file mode 100644
index 000000000..266f8fac4
--- /dev/null
+++ b/third_party/libcxx/__chrono/exception.h
@@ -0,0 +1,135 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_EXCEPTION_H
+#define _LIBCPP___CHRONO_EXCEPTION_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#  include <__chrono/calendar.h>
+#  include <__chrono/local_info.h>
+#  include <__chrono/time_point.h>
+#  include <__config>
+#  include <__configuration/availability.h>
+#  include <__verbose_abort>
+#  include <format>
+#  include <stdexcept>
+#  include <string>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20
+
+namespace chrono {
+
+class nonexistent_local_time : public runtime_error {
+public:
+  template <class _Duration>
+  _LIBCPP_HIDE_FROM_ABI nonexistent_local_time(const local_time<_Duration>& __time, const local_info& __info)
+      : runtime_error{__create_message(__time, __info)} {
+    // [time.zone.exception.nonexist]/2
+    //   Preconditions: i.result == local_info::nonexistent is true.
+    // The value of __info.result is not used.
+    _LIBCPP_ASSERT_PEDANTIC(__info.result == local_info::nonexistent,
+                            "creating an nonexistent_local_time from a local_info that is not non-existent");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI nonexistent_local_time(const nonexistent_local_time&)            = default;
+  _LIBCPP_HIDE_FROM_ABI nonexistent_local_time& operator=(const nonexistent_local_time&) = default;
+
+  _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI ~nonexistent_local_time() override; // exported as key function
+
+private:
+  template <class _Duration>
+  _LIBCPP_HIDE_FROM_ABI string __create_message(const local_time<_Duration>& __time, const local_info& __info) {
+    return std::format(
+        R"({} is in a gap between
+{} {} and
+{} {} which are both equivalent to
+{} UTC)",
+        __time,
+        local_seconds{__info.first.end.time_since_epoch()} + __info.first.offset,
+        __info.first.abbrev,
+        local_seconds{__info.second.begin.time_since_epoch()} + __info.second.offset,
+        __info.second.abbrev,
+        __info.first.end);
+  }
+};
+
+template <class _Duration>
+_LIBCPP_NORETURN _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI void __throw_nonexistent_local_time(
+    [[maybe_unused]] const local_time<_Duration>& __time, [[maybe_unused]] const local_info& __info) {
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw nonexistent_local_time(__time, __info);
+#    else
+  _LIBCPP_VERBOSE_ABORT("nonexistent_local_time was thrown in -fno-exceptions mode");
+#    endif
+}
+
+class ambiguous_local_time : public runtime_error {
+public:
+  template <class _Duration>
+  _LIBCPP_HIDE_FROM_ABI ambiguous_local_time(const local_time<_Duration>& __time, const local_info& __info)
+      : runtime_error{__create_message(__time, __info)} {
+    // [time.zone.exception.ambig]/2
+    //   Preconditions: i.result == local_info::ambiguous is true.
+    // The value of __info.result is not used.
+    _LIBCPP_ASSERT_PEDANTIC(__info.result == local_info::ambiguous,
+                            "creating an ambiguous_local_time from a local_info that is not ambiguous");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI ambiguous_local_time(const ambiguous_local_time&)            = default;
+  _LIBCPP_HIDE_FROM_ABI ambiguous_local_time& operator=(const ambiguous_local_time&) = default;
+
+  _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI ~ambiguous_local_time() override; // exported as key function
+
+private:
+  template <class _Duration>
+  _LIBCPP_HIDE_FROM_ABI string __create_message(const local_time<_Duration>& __time, const local_info& __info) {
+    return std::format(
+        // There are two spaces after the full-stop; this has been verified
+        // in the sources of the Standard.
+        R"({0} is ambiguous.  It could be
+{0} {1} == {2} UTC or
+{0} {3} == {4} UTC)",
+        __time,
+        __info.first.abbrev,
+        __time - __info.first.offset,
+        __info.second.abbrev,
+        __time - __info.second.offset);
+  }
+};
+
+template <class _Duration>
+_LIBCPP_NORETURN _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI void __throw_ambiguous_local_time(
+    [[maybe_unused]] const local_time<_Duration>& __time, [[maybe_unused]] const local_info& __info) {
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw ambiguous_local_time(__time, __info);
+#    else
+  _LIBCPP_VERBOSE_ABORT("ambiguous_local_time was thrown in -fno-exceptions mode");
+#    endif
+}
+
+} // namespace chrono
+
+#  endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#endif // _LIBCPP___CHRONO_EXCEPTION_H
diff --git a/third_party/libcxx/__chrono/file_clock.h b/third_party/libcxx/__chrono/file_clock.h
index 7a4dce9d5..4dd3f88ce 100644
--- a/third_party/libcxx/__chrono/file_clock.h
+++ b/third_party/libcxx/__chrono/file_clock.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___CHRONO_FILE_CLOCK_H
 #define _LIBCPP___CHRONO_FILE_CLOCK_H
 
-#include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
@@ -31,13 +30,12 @@ _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 // [time.clock.file], type file_clock
-using file_clock = _VSTD_FS::_FilesystemClock;
+using file_clock = filesystem::_FilesystemClock;
 
-template<class _Duration>
+template <class _Duration>
 using file_time = time_point<file_clock, _Duration>;
 
 } // namespace chrono
@@ -49,35 +47,32 @@ _LIBCPP_END_NAMESPACE_STD
 #ifndef _LIBCPP_CXX03_LANG
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 struct _FilesystemClock {
-#if !defined(_LIBCPP_HAS_NO_INT128)
+#  if !defined(_LIBCPP_HAS_NO_INT128)
   typedef __int128_t rep;
   typedef nano period;
-#else
+#  else
   typedef long long rep;
   typedef nano period;
-#endif
+#  endif
 
   typedef chrono::duration<rep, period> duration;
   typedef chrono::time_point<_FilesystemClock> time_point;
 
-  _LIBCPP_EXPORTED_FROM_ABI
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false;
+  _LIBCPP_EXPORTED_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false;
 
-  _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_FUNC_VIS static time_point now() noexcept;
+  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_EXPORTED_FROM_ABI static time_point now() noexcept;
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
   template <class _Duration>
-  _LIBCPP_HIDE_FROM_ABI
-  static chrono::sys_time<_Duration> to_sys(const chrono::file_time<_Duration>& __t) {
+  _LIBCPP_HIDE_FROM_ABI static chrono::sys_time<_Duration> to_sys(const chrono::file_time<_Duration>& __t) {
     return chrono::sys_time<_Duration>(__t.time_since_epoch());
   }
 
   template <class _Duration>
-  _LIBCPP_HIDE_FROM_ABI
-  static chrono::file_time<_Duration> from_sys(const chrono::sys_time<_Duration>& __t) {
+  _LIBCPP_HIDE_FROM_ABI static chrono::file_time<_Duration> from_sys(const chrono::sys_time<_Duration>& __t) {
     return chrono::file_time<_Duration>(__t.time_since_epoch());
   }
-#endif // _LIBCPP_STD_VER >= 20
+#  endif // _LIBCPP_STD_VER >= 20
 };
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 #endif // !_LIBCPP_CXX03_LANG
diff --git a/third_party/libcxx/__chrono/formatter.h b/third_party/libcxx/__chrono/formatter.h
index 679edf39c..449c415e9 100644
--- a/third_party/libcxx/__chrono/formatter.h
+++ b/third_party/libcxx/__chrono/formatter.h
@@ -10,6 +10,7 @@
 #ifndef _LIBCPP___CHRONO_FORMATTER_H
 #define _LIBCPP___CHRONO_FORMATTER_H
 
+#include <__algorithm/ranges_copy.h>
 #include <__chrono/calendar.h>
 #include <__chrono/concepts.h>
 #include <__chrono/convert_to_tm.h>
@@ -17,12 +18,14 @@
 #include <__chrono/duration.h>
 #include <__chrono/file_clock.h>
 #include <__chrono/hh_mm_ss.h>
+#include <__chrono/local_info.h>
 #include <__chrono/month.h>
 #include <__chrono/month_weekday.h>
 #include <__chrono/monthday.h>
 #include <__chrono/ostream.h>
 #include <__chrono/parser_std_format_spec.h>
 #include <__chrono/statically_widen.h>
+#include <__chrono/sys_info.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
 #include <__chrono/weekday.h>
@@ -30,6 +33,7 @@
 #include <__chrono/year_month.h>
 #include <__chrono/year_month_day.h>
 #include <__chrono/year_month_weekday.h>
+#include <__chrono/zoned_time.h>
 #include <__concepts/arithmetic.h>
 #include <__concepts/same_as.h>
 #include <__config>
@@ -38,13 +42,14 @@
 #include <__format/format_functions.h>
 #include <__format/format_parse_context.h>
 #include <__format/formatter.h>
-#include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
+#include <__format/write_escaped.h>
 #include <__memory/addressof.h>
+#include <__type_traits/is_specialization.h>
 #include <cmath>
 #include <ctime>
+#include <limits>
 #include <sstream>
-#include <string>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -80,12 +85,15 @@ namespace __formatter {
 // small). Therefore a duration uses its own conversion.
 template <class _CharT, class _Rep, class _Period>
 _LIBCPP_HIDE_FROM_ABI void
-__format_sub_seconds(const chrono::duration<_Rep, _Period>& __value, basic_stringstream<_CharT>& __sstr) {
+__format_sub_seconds(basic_stringstream<_CharT>& __sstr, const chrono::duration<_Rep, _Period>& __value) {
   __sstr << std::use_facet<numpunct<_CharT>>(__sstr.getloc()).decimal_point();
 
   using __duration = chrono::duration<_Rep, _Period>;
 
   auto __fraction = __value - chrono::duration_cast<chrono::seconds>(__value);
+  // Converts a negative fraction to its positive value.
+  if (__value < chrono::seconds{0} && __fraction != __duration{0})
+    __fraction += chrono::seconds{1};
   if constexpr (chrono::treat_as_floating_point_v<_Rep>)
     // When the floating-point value has digits itself they are ignored based
     // on the wording in [tab:time.format.spec]
@@ -101,23 +109,23 @@ __format_sub_seconds(const chrono::duration<_Rep, _Period>& __value, basic_strin
     // https://godbolt.org/z/6dsbnW8ba
     std::format_to(std::ostreambuf_iterator<_CharT>{__sstr},
                    _LIBCPP_STATICALLY_WIDEN(_CharT, "{:0{}.0f}"),
-                   __fraction.count(),
+                   chrono::duration_cast<typename chrono::hh_mm_ss<__duration>::precision>(__fraction).count(),
                    chrono::hh_mm_ss<__duration>::fractional_width);
   else
     std::format_to(std::ostreambuf_iterator<_CharT>{__sstr},
                    _LIBCPP_STATICALLY_WIDEN(_CharT, "{:0{}}"),
-                   __fraction.count(),
+                   chrono::duration_cast<typename chrono::hh_mm_ss<__duration>::precision>(__fraction).count(),
                    chrono::hh_mm_ss<__duration>::fractional_width);
 }
 
 template <class _CharT, __is_time_point _Tp>
-_LIBCPP_HIDE_FROM_ABI void __format_sub_seconds(const _Tp& __value, basic_stringstream<_CharT>& __sstr) {
-  __formatter::__format_sub_seconds(__value.time_since_epoch(), __sstr);
+_LIBCPP_HIDE_FROM_ABI void __format_sub_seconds(basic_stringstream<_CharT>& __sstr, const _Tp& __value) {
+  __formatter::__format_sub_seconds(__sstr, __value.time_since_epoch());
 }
 
 template <class _CharT, class _Duration>
 _LIBCPP_HIDE_FROM_ABI void
-__format_sub_seconds(const chrono::hh_mm_ss<_Duration>& __value, basic_stringstream<_CharT>& __sstr) {
+__format_sub_seconds(basic_stringstream<_CharT>& __sstr, const chrono::hh_mm_ss<_Duration>& __value) {
   __sstr << std::use_facet<numpunct<_CharT>>(__sstr.getloc()).decimal_point();
   if constexpr (chrono::treat_as_floating_point_v<typename _Duration::rep>)
     std::format_to(std::ostreambuf_iterator<_CharT>{__sstr},
@@ -131,10 +139,24 @@ __format_sub_seconds(const chrono::hh_mm_ss<_Duration>& __value, basic_stringstr
                    __value.fractional_width);
 }
 
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB) && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) &&                     \
+      !defined(_LIBCPP_HAS_NO_FILESYSTEM) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+template <class _CharT, class _Duration, class _TimeZonePtr>
+_LIBCPP_HIDE_FROM_ABI void
+__format_sub_seconds(basic_stringstream<_CharT>& __sstr, const chrono::zoned_time<_Duration, _TimeZonePtr>& __value) {
+  __formatter::__format_sub_seconds(__sstr, __value.get_local_time().time_since_epoch());
+}
+#  endif
+
 template <class _Tp>
 consteval bool __use_fraction() {
   if constexpr (__is_time_point<_Tp>)
     return chrono::hh_mm_ss<typename _Tp::duration>::fractional_width;
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB) && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) &&                     \
+      !defined(_LIBCPP_HAS_NO_FILESYSTEM) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  else if constexpr (__is_specialization_v<_Tp, chrono::zoned_time>)
+    return chrono::hh_mm_ss<typename _Tp::duration>::fractional_width;
+#  endif
   else if constexpr (chrono::__is_duration<_Tp>::value)
     return chrono::hh_mm_ss<_Tp>::fractional_width;
   else if constexpr (__is_hh_mm_ss<_Tp>)
@@ -144,7 +166,7 @@ consteval bool __use_fraction() {
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI void __format_year(int __year, basic_stringstream<_CharT>& __sstr) {
+_LIBCPP_HIDE_FROM_ABI void __format_year(basic_stringstream<_CharT>& __sstr, int __year) {
   if (__year < 0) {
     __sstr << _CharT('-');
     __year = -__year;
@@ -160,7 +182,7 @@ _LIBCPP_HIDE_FROM_ABI void __format_year(int __year, basic_stringstream<_CharT>&
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI void __format_century(int __year, basic_stringstream<_CharT>& __sstr) {
+_LIBCPP_HIDE_FROM_ABI void __format_century(basic_stringstream<_CharT>& __sstr, int __year) {
   // TODO FMT Write an issue
   // [tab:time.format.spec]
   //   %C The year divided by 100 using floored division. If the result is a
@@ -171,10 +193,56 @@ _LIBCPP_HIDE_FROM_ABI void __format_century(int __year, basic_stringstream<_Char
   __sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "{:02}"), __century);
 }
 
+// Implements the %z format specifier according to [tab:time.format.spec], where
+// '__modifier' signals %Oz or %Ez were used. (Both modifiers behave the same,
+// so there is no need to distinguish between them.)
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI void
+__format_zone_offset(basic_stringstream<_CharT>& __sstr, chrono::seconds __offset, bool __modifier) {
+  if (__offset < 0s) {
+    __sstr << _CharT('-');
+    __offset = -__offset;
+  } else {
+    __sstr << _CharT('+');
+  }
+
+  chrono::hh_mm_ss __hms{__offset};
+  std::ostreambuf_iterator<_CharT> __out_it{__sstr};
+  // Note HMS does not allow formatting hours > 23, but the offset is not limited to 24H.
+  std::format_to(__out_it, _LIBCPP_STATICALLY_WIDEN(_CharT, "{:02}"), __hms.hours().count());
+  if (__modifier)
+    __sstr << _CharT(':');
+  std::format_to(__out_it, _LIBCPP_STATICALLY_WIDEN(_CharT, "{:02}"), __hms.minutes().count());
+}
+
+// Helper to store the time zone information needed for formatting.
+struct _LIBCPP_HIDE_FROM_ABI __time_zone {
+  // Typically these abbreviations are short and fit in the string's internal
+  // buffer.
+  string __abbrev;
+  chrono::seconds __offset;
+};
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI __time_zone __convert_to_time_zone([[maybe_unused]] const _Tp& __value) {
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+  if constexpr (same_as<_Tp, chrono::sys_info>)
+    return {__value.abbrev, __value.offset};
+#    if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                          \
+        !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  else if constexpr (__is_specialization_v<_Tp, chrono::zoned_time>)
+    return __formatter::__convert_to_time_zone(__value.get_info());
+#    endif
+  else
+#  endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+    return {"UTC", chrono::seconds{0}};
+}
+
 template <class _CharT, class _Tp>
 _LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(
-    const _Tp& __value, basic_stringstream<_CharT>& __sstr, basic_string_view<_CharT> __chrono_specs) {
+    basic_stringstream<_CharT>& __sstr, const _Tp& __value, basic_string_view<_CharT> __chrono_specs) {
   tm __t              = std::__convert_to_tm<tm>(__value);
+  __time_zone __z     = __formatter::__convert_to_time_zone(__value);
   const auto& __facet = std::use_facet<time_put<_CharT>>(__sstr.getloc());
   for (auto __it = __chrono_specs.begin(); __it != __chrono_specs.end(); ++__it) {
     if (*__it == _CharT('%')) {
@@ -197,9 +265,10 @@ _LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(
         // strftime's output is only defined in the range [00, 99].
         int __year = __t.tm_year + 1900;
         if (__year < 1000 || __year > 9999)
-          __formatter::__format_century(__year, __sstr);
+          __formatter::__format_century(__sstr, __year);
         else
-          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
+          __facet.put(
+              {__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
       } break;
 
       case _CharT('j'):
@@ -210,7 +279,8 @@ _LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(
           // an intemediate step.
           __sstr << chrono::duration_cast<chrono::days>(chrono::duration_cast<chrono::seconds>(__value)).count();
         else
-          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
+          __facet.put(
+              {__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
         break;
 
       case _CharT('q'):
@@ -238,9 +308,10 @@ _LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(
 
       case _CharT('S'):
       case _CharT('T'):
-        __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
+        __facet.put(
+            {__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
         if constexpr (__use_fraction<_Tp>())
-          __formatter::__format_sub_seconds(__value, __sstr);
+          __formatter::__format_sub_seconds(__sstr, __value);
         break;
 
         // Unlike time_put and strftime the formatting library requires %Y
@@ -281,21 +352,24 @@ _LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(
         // Depending on the platform's libc the range of supported years is
         // limited. Intead of of testing all conditions use the internal
         // implementation unconditionally.
-        __formatter::__format_year(__t.tm_year + 1900, __sstr);
+        __formatter::__format_year(__sstr, __t.tm_year + 1900);
         break;
 
-      case _CharT('F'): {
-        int __year = __t.tm_year + 1900;
-        if (__year < 1000) {
-          __formatter::__format_year(__year, __sstr);
-          __sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "-{:02}-{:02}"), __t.tm_mon + 1, __t.tm_mday);
-        } else
-          __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
-      } break;
+      case _CharT('F'):
+        // Depending on the platform's libc the range of supported years is
+        // limited. Instead of testing all conditions use the internal
+        // implementation unconditionally.
+        __formatter::__format_year(__sstr, __t.tm_year + 1900);
+        __sstr << std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "-{:02}-{:02}"), __t.tm_mon + 1, __t.tm_mday);
+        break;
+
+      case _CharT('z'):
+        __formatter::__format_zone_offset(__sstr, __z.__offset, false);
+        break;
 
       case _CharT('Z'):
-        // TODO FMT Add proper timezone support.
-        __sstr << _LIBCPP_STATICALLY_WIDEN(_CharT, "UTC");
+        // __abbrev is always a char so the copy may convert.
+        ranges::copy(__z.__abbrev, std::ostreambuf_iterator<_CharT>{__sstr});
         break;
 
       case _CharT('O'):
@@ -305,17 +379,25 @@ _LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(
           // fractional part should be formatted.
           if (*(__it + 1) == 'S') {
             ++__it;
-            __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
-            __formatter::__format_sub_seconds(__value, __sstr);
+            __facet.put(
+                {__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
+            __formatter::__format_sub_seconds(__sstr, __value);
             break;
           }
         }
+
+        // Oz produces the same output as Ez below.
         [[fallthrough]];
       case _CharT('E'):
         ++__it;
+        if (*__it == 'z') {
+          __formatter::__format_zone_offset(__sstr, __z.__offset, true);
+          break;
+        }
         [[fallthrough]];
       default:
-        __facet.put({__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
+        __facet.put(
+            {__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
         break;
       }
     } else {
@@ -360,6 +442,17 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool __weekday_ok(const _Tp& __value) {
     return __value.weekday().ok();
   else if constexpr (__is_hh_mm_ss<_Tp>)
     return true;
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+  else if constexpr (same_as<_Tp, chrono::sys_info>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::local_info>)
+    return true;
+#    if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                          \
+        !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  else if constexpr (__is_specialization_v<_Tp, chrono::zoned_time>)
+    return true;
+#    endif
+#  endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
   else
     static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
 }
@@ -400,6 +493,17 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool __weekday_name_ok(const _Tp& __value) {
     return __value.weekday().ok();
   else if constexpr (__is_hh_mm_ss<_Tp>)
     return true;
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+  else if constexpr (same_as<_Tp, chrono::sys_info>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::local_info>)
+    return true;
+#    if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                          \
+        !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  else if constexpr (__is_specialization_v<_Tp, chrono::zoned_time>)
+    return true;
+#    endif
+#  endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
   else
     static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
 }
@@ -440,6 +544,17 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool __date_ok(const _Tp& __value) {
     return __value.ok();
   else if constexpr (__is_hh_mm_ss<_Tp>)
     return true;
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+  else if constexpr (same_as<_Tp, chrono::sys_info>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::local_info>)
+    return true;
+#    if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                          \
+        !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  else if constexpr (__is_specialization_v<_Tp, chrono::zoned_time>)
+    return true;
+#    endif
+#  endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
   else
     static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
 }
@@ -480,6 +595,17 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool __month_name_ok(const _Tp& __value) {
     return __value.month().ok();
   else if constexpr (__is_hh_mm_ss<_Tp>)
     return true;
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+  else if constexpr (same_as<_Tp, chrono::sys_info>)
+    return true;
+  else if constexpr (same_as<_Tp, chrono::local_info>)
+    return true;
+#    if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                          \
+        !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  else if constexpr (__is_specialization_v<_Tp, chrono::zoned_time>)
+    return true;
+#    endif
+#  endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
   else
     static_assert(sizeof(_Tp) == 0, "Add the missing type specialization");
 }
@@ -505,28 +631,35 @@ __format_chrono(const _Tp& __value,
     __sstr << __value;
   else {
     if constexpr (chrono::__is_duration<_Tp>::value) {
-      if (__value < __value.zero())
-        __sstr << _CharT('-');
-      __formatter::__format_chrono_using_chrono_specs(chrono::abs(__value), __sstr, __chrono_specs);
+      // A duration can be a user defined arithmetic type. Users may specialize
+      // numeric_limits, but they may not specialize is_signed.
+      if constexpr (numeric_limits<typename _Tp::rep>::is_signed) {
+        if (__value < __value.zero()) {
+          __sstr << _CharT('-');
+          __formatter::__format_chrono_using_chrono_specs(__sstr, -__value, __chrono_specs);
+        } else
+          __formatter::__format_chrono_using_chrono_specs(__sstr, __value, __chrono_specs);
+      } else
+        __formatter::__format_chrono_using_chrono_specs(__sstr, __value, __chrono_specs);
       // TODO FMT When keeping the precision it will truncate the string.
       // Note that the behaviour what the precision does isn't specified.
       __specs.__precision_ = -1;
     } else {
       // Test __weekday_name_ before __weekday_ to give a better error.
       if (__specs.__chrono_.__weekday_name_ && !__formatter::__weekday_name_ok(__value))
-        std::__throw_format_error("formatting a weekday name needs a valid weekday");
+        std::__throw_format_error("Formatting a weekday name needs a valid weekday");
 
       if (__specs.__chrono_.__weekday_ && !__formatter::__weekday_ok(__value))
-        std::__throw_format_error("formatting a weekday needs a valid weekday");
+        std::__throw_format_error("Formatting a weekday needs a valid weekday");
 
       if (__specs.__chrono_.__day_of_year_ && !__formatter::__date_ok(__value))
-        std::__throw_format_error("formatting a day of year needs a valid date");
+        std::__throw_format_error("Formatting a day of year needs a valid date");
 
       if (__specs.__chrono_.__week_of_year_ && !__formatter::__date_ok(__value))
-        std::__throw_format_error("formatting a week of year needs a valid date");
+        std::__throw_format_error("Formatting a week of year needs a valid date");
 
       if (__specs.__chrono_.__month_name_ && !__formatter::__month_name_ok(__value))
-        std::__throw_format_error("formatting a month name from an invalid month number");
+        std::__throw_format_error("Formatting a month name from an invalid month number");
 
       if constexpr (__is_hh_mm_ss<_Tp>) {
         // Note this is a pedantic intepretation of the Standard. A hh_mm_ss
@@ -545,13 +678,13 @@ __format_chrono(const _Tp& __value,
         //   - Write it as not valid,
         //   - or write the number of days.
         if (__specs.__chrono_.__hour_ && __value.hours().count() > 23)
-          std::__throw_format_error("formatting a hour needs a valid value");
+          std::__throw_format_error("Formatting a hour needs a valid value");
 
         if (__value.is_negative())
           __sstr << _CharT('-');
       }
 
-      __formatter::__format_chrono_using_chrono_specs(__value, __sstr, __chrono_specs);
+      __formatter::__format_chrono_using_chrono_specs(__sstr, __value, __chrono_specs);
     }
   }
 
@@ -635,8 +768,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::day, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::day, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -647,8 +779,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -659,8 +790,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -671,8 +801,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::weekday, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::weekday, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -683,8 +812,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::weekday_indexed, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::weekday_indexed, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -695,8 +823,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::weekday_last, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::weekday_last, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -707,8 +834,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_day, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_day, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -719,8 +845,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_day_last, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_day_last, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -731,8 +856,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_weekday, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_weekday, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -743,8 +867,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_weekday_last, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::month_weekday_last, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -755,8 +878,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -767,8 +889,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_day, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_day, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -779,8 +900,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_day_last, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_day_last, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -791,8 +911,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_weekday, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_weekday, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -803,8 +922,7 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_weekday_last, _CharT>
-    : public __formatter_chrono<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<chrono::year_month_weekday_last, _CharT> : public __formatter_chrono<_CharT> {
 public:
   using _Base = __formatter_chrono<_CharT>;
 
@@ -824,6 +942,47 @@ public:
     return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__time);
   }
 };
+
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+template <__fmt_char_type _CharT>
+struct formatter<chrono::sys_info, _CharT> : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  template <class _ParseContext>
+  _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
+    return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__time_zone);
+  }
+};
+
+template <__fmt_char_type _CharT>
+struct formatter<chrono::local_info, _CharT> : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  template <class _ParseContext>
+  _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
+    return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags{});
+  }
+};
+#    if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                          \
+        !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+// Note due to how libc++'s formatters are implemented there is no need to add
+// the exposition only local-time-format-t abstraction.
+template <class _Duration, class _TimeZonePtr, __fmt_char_type _CharT>
+struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT> : public __formatter_chrono<_CharT> {
+public:
+  using _Base = __formatter_chrono<_CharT>;
+
+  template <class _ParseContext>
+  _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
+    return _Base::__parse(__ctx, __format_spec::__fields_chrono, __format_spec::__flags::__clock);
+  }
+};
+#    endif // !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&
+           // !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  endif   // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
 #endif // if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__chrono/hh_mm_ss.h b/third_party/libcxx/__chrono/hh_mm_ss.h
index 5bd452e57..57d2247fe 100644
--- a/third_party/libcxx/__chrono/hh_mm_ss.h
+++ b/third_party/libcxx/__chrono/hh_mm_ss.h
@@ -24,85 +24,84 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 template <class _Duration>
-class hh_mm_ss
-{
+class hh_mm_ss {
 private:
-    static_assert(__is_duration<_Duration>::value, "template parameter of hh_mm_ss must be a std::chrono::duration");
-    using __CommonType = common_type_t<_Duration, chrono::seconds>;
+  static_assert(__is_duration<_Duration>::value, "template parameter of hh_mm_ss must be a std::chrono::duration");
+  using __CommonType = common_type_t<_Duration, chrono::seconds>;
 
-    _LIBCPP_HIDE_FROM_ABI static constexpr uint64_t __pow10(unsigned __exp)
-    {
-        uint64_t __ret = 1;
-        for (unsigned __i = 0; __i < __exp; ++__i)
-            __ret *= 10U;
-        return __ret;
-    }
+  _LIBCPP_HIDE_FROM_ABI static constexpr uint64_t __pow10(unsigned __exp) {
+    uint64_t __ret = 1;
+    for (unsigned __i = 0; __i < __exp; ++__i)
+      __ret *= 10U;
+    return __ret;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI static constexpr unsigned __width(uint64_t __n, uint64_t __d = 10, unsigned __w = 0)
-    {
-        if (__n >= 2 && __d != 0 && __w < 19)
-            return 1 + __width(__n, __d % __n * 10, __w+1);
-        return 0;
-    }
+  _LIBCPP_HIDE_FROM_ABI static constexpr unsigned __width(uint64_t __n, uint64_t __d = 10, unsigned __w = 0) {
+    if (__n >= 2 && __d != 0 && __w < 19)
+      return 1 + __width(__n, __d % __n * 10, __w + 1);
+    return 0;
+  }
 
 public:
-    _LIBCPP_HIDE_FROM_ABI static unsigned constexpr fractional_width = __width(__CommonType::period::den) < 19 ?
-                                                 __width(__CommonType::period::den) : 6u;
-    using precision = duration<typename __CommonType::rep, ratio<1, __pow10(fractional_width)>>;
+  _LIBCPP_HIDE_FROM_ABI static unsigned constexpr fractional_width =
+      __width(__CommonType::period::den) < 19 ? __width(__CommonType::period::den) : 6u;
+  using precision = duration<typename __CommonType::rep, ratio<1, __pow10(fractional_width)>>;
 
-    _LIBCPP_HIDE_FROM_ABI constexpr hh_mm_ss() noexcept : hh_mm_ss{_Duration::zero()} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr hh_mm_ss() noexcept : hh_mm_ss{_Duration::zero()} {}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit hh_mm_ss(_Duration __d) noexcept :
-        __is_neg_(__d < _Duration(0)),
-        __h_(chrono::duration_cast<chrono::hours>  (chrono::abs(__d))),
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit hh_mm_ss(_Duration __d) noexcept
+      : __is_neg_(__d < _Duration(0)),
+        __h_(chrono::duration_cast<chrono::hours>(chrono::abs(__d))),
         __m_(chrono::duration_cast<chrono::minutes>(chrono::abs(__d) - hours())),
         __s_(chrono::duration_cast<chrono::seconds>(chrono::abs(__d) - hours() - minutes())),
-        __f_(chrono::duration_cast<precision>      (chrono::abs(__d) - hours() - minutes() - seconds()))
-        {}
+        __f_(chrono::duration_cast<precision>(chrono::abs(__d) - hours() - minutes() - seconds())) {}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr bool is_negative()        const noexcept { return __is_neg_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::hours hours()     const noexcept { return __h_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::minutes minutes() const noexcept { return __m_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::seconds seconds() const noexcept { return __s_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr precision subseconds()    const noexcept { return __f_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool is_negative() const noexcept { return __is_neg_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr chrono::hours hours() const noexcept { return __h_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr chrono::minutes minutes() const noexcept { return __m_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr chrono::seconds seconds() const noexcept { return __s_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr precision subseconds() const noexcept { return __f_; }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr precision to_duration() const noexcept
-    {
-        auto __dur = __h_ + __m_ + __s_ + __f_;
-        return __is_neg_ ? -__dur : __dur;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr precision to_duration() const noexcept {
+    auto __dur = __h_ + __m_ + __s_ + __f_;
+    return __is_neg_ ? -__dur : __dur;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit operator precision() const noexcept { return to_duration(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator precision() const noexcept { return to_duration(); }
 
 private:
-    bool            __is_neg_;
-    chrono::hours   __h_;
-    chrono::minutes __m_;
-    chrono::seconds __s_;
-    precision       __f_;
+  bool __is_neg_;
+  chrono::hours __h_;
+  chrono::minutes __m_;
+  chrono::seconds __s_;
+  precision __f_;
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(hh_mm_ss);
 
-_LIBCPP_HIDE_FROM_ABI constexpr bool is_am(const hours& __h) noexcept { return __h >= hours( 0) && __h < hours(12); }
-_LIBCPP_HIDE_FROM_ABI constexpr bool is_pm(const hours& __h) noexcept { return __h >= hours(12) && __h < hours(24); }
-
-_LIBCPP_HIDE_FROM_ABI constexpr hours make12(const hours& __h) noexcept
-{
-    if      (__h == hours( 0)) return hours(12);
-    else if (__h <= hours(12)) return __h;
-    else                       return __h - hours(12);
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_am(const hours& __h) noexcept {
+  return __h >= hours(0) && __h < hours(12);
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_pm(const hours& __h) noexcept {
+  return __h >= hours(12) && __h < hours(24);
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr hours make24(const hours& __h, bool __is_pm) noexcept
-{
-    if (__is_pm)
-        return __h == hours(12) ? __h : __h + hours(12);
-    else
-        return __h == hours(12) ? hours(0) : __h;
+_LIBCPP_HIDE_FROM_ABI inline constexpr hours make12(const hours& __h) noexcept {
+  if (__h == hours(0))
+    return hours(12);
+  else if (__h <= hours(12))
+    return __h;
+  else
+    return __h - hours(12);
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr hours make24(const hours& __h, bool __is_pm) noexcept {
+  if (__is_pm)
+    return __h == hours(12) ? __h : __h + hours(12);
+  else
+    return __h == hours(12) ? hours(0) : __h;
 }
 } // namespace chrono
 
diff --git a/third_party/libcxx/__chrono/high_resolution_clock.h b/third_party/libcxx/__chrono/high_resolution_clock.h
index 778ff44f3..0697fd2de 100644
--- a/third_party/libcxx/__chrono/high_resolution_clock.h
+++ b/third_party/libcxx/__chrono/high_resolution_clock.h
@@ -20,8 +20,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
 typedef steady_clock high_resolution_clock;
diff --git a/third_party/libcxx/__chrono/leap_second.h b/third_party/libcxx/__chrono/leap_second.h
new file mode 100644
index 000000000..1a0e7f310
--- /dev/null
+++ b/third_party/libcxx/__chrono/leap_second.h
@@ -0,0 +1,126 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_LEAP_SECOND_H
+#define _LIBCPP___CHRONO_LEAP_SECOND_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#  include <__chrono/duration.h>
+#  include <__chrono/system_clock.h>
+#  include <__chrono/time_point.h>
+#  include <__compare/ordering.h>
+#  include <__compare/three_way_comparable.h>
+#  include <__config>
+#  include <__utility/private_constructor_tag.h>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20
+
+namespace chrono {
+
+class leap_second {
+public:
+  [[nodiscard]]
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr leap_second(__private_constructor_tag, sys_seconds __date, seconds __value)
+      : __date_(__date), __value_(__value) {}
+
+  _LIBCPP_HIDE_FROM_ABI leap_second(const leap_second&)            = default;
+  _LIBCPP_HIDE_FROM_ABI leap_second& operator=(const leap_second&) = default;
+
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI constexpr sys_seconds date() const noexcept { return __date_; }
+
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI constexpr seconds value() const noexcept { return __value_; }
+
+private:
+  sys_seconds __date_;
+  seconds __value_;
+};
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator==(const leap_second& __x, const leap_second& __y) {
+  return __x.date() == __y.date();
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr strong_ordering operator<=>(const leap_second& __x, const leap_second& __y) {
+  return __x.date() <=> __y.date();
+}
+
+template <class _Duration>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const leap_second& __x, const sys_time<_Duration>& __y) {
+  return __x.date() == __y;
+}
+
+template <class _Duration>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const leap_second& __x, const sys_time<_Duration>& __y) {
+  return __x.date() < __y;
+}
+
+template <class _Duration>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const sys_time<_Duration>& __x, const leap_second& __y) {
+  return __x < __y.date();
+}
+
+template <class _Duration>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const leap_second& __x, const sys_time<_Duration>& __y) {
+  return __y < __x;
+}
+
+template <class _Duration>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const sys_time<_Duration>& __x, const leap_second& __y) {
+  return __y < __x;
+}
+
+template <class _Duration>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const leap_second& __x, const sys_time<_Duration>& __y) {
+  return !(__y < __x);
+}
+
+template <class _Duration>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const sys_time<_Duration>& __x, const leap_second& __y) {
+  return !(__y < __x);
+}
+
+template <class _Duration>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const leap_second& __x, const sys_time<_Duration>& __y) {
+  return !(__x < __y);
+}
+
+template <class _Duration>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const sys_time<_Duration>& __x, const leap_second& __y) {
+  return !(__x < __y);
+}
+
+#    ifndef _LIBCPP_COMPILER_GCC
+// This requirement cause a compilation loop in GCC-13 and running out of memory.
+// TODO TZDB Test whether GCC-14 fixes this.
+template <class _Duration>
+  requires three_way_comparable_with<sys_seconds, sys_time<_Duration>>
+_LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(const leap_second& __x, const sys_time<_Duration>& __y) {
+  return __x.date() <=> __y;
+}
+#    endif
+
+} // namespace chrono
+
+#  endif //_LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#endif // _LIBCPP___CHRONO_LEAP_SECOND_H
diff --git a/third_party/libcxx/__chrono/literals.h b/third_party/libcxx/__chrono/literals.h
index 28ddc43a2..89800440e 100644
--- a/third_party/libcxx/__chrono/literals.h
+++ b/third_party/libcxx/__chrono/literals.h
@@ -22,24 +22,20 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-inline namespace literals
-{
-  inline namespace chrono_literals
-  {
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::day operator ""d(unsigned long long __d) noexcept
-    {
-        return chrono::day(static_cast<unsigned>(__d));
-    }
+inline namespace literals {
+inline namespace chrono_literals {
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::day operator""d(unsigned long long __d) noexcept {
+  return chrono::day(static_cast<unsigned>(__d));
+}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::year operator ""y(unsigned long long __y) noexcept
-    {
-        return chrono::year(static_cast<int>(__y));
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr chrono::year operator""y(unsigned long long __y) noexcept {
+  return chrono::year(static_cast<int>(__y));
+}
 } // namespace chrono_literals
 } // namespace literals
 
 namespace chrono { // hoist the literals into namespace std::chrono
-   using namespace literals::chrono_literals;
+using namespace literals::chrono_literals;
 } // namespace chrono
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__chrono/local_info.h b/third_party/libcxx/__chrono/local_info.h
new file mode 100644
index 000000000..cfe144890
--- /dev/null
+++ b/third_party/libcxx/__chrono/local_info.h
@@ -0,0 +1,50 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_LOCAL_INFO_H
+#define _LIBCPP___CHRONO_LOCAL_INFO_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#  include <__chrono/sys_info.h>
+#  include <__config>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20
+
+namespace chrono {
+
+struct local_info {
+  static constexpr int unique      = 0;
+  static constexpr int nonexistent = 1;
+  static constexpr int ambiguous   = 2;
+
+  int result;
+  sys_info first;
+  sys_info second;
+};
+
+} // namespace chrono
+
+#  endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#endif // _LIBCPP___CHRONO_LOCAL_INFO_H
diff --git a/third_party/libcxx/__chrono/month.h b/third_party/libcxx/__chrono/month.h
index 5dff7ce33..ce5cc21aa 100644
--- a/third_party/libcxx/__chrono/month.h
+++ b/third_party/libcxx/__chrono/month.h
@@ -22,64 +22,76 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 class month {
 private:
-    unsigned char __m_;
+  unsigned char __m_;
+
 public:
-    month() = default;
-    _LIBCPP_HIDE_FROM_ABI explicit inline constexpr month(unsigned __val) noexcept : __m_(static_cast<unsigned char>(__val)) {}
-    _LIBCPP_HIDE_FROM_ABI inline constexpr month& operator++()    noexcept { ++__m_; return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr month  operator++(int) noexcept { month __tmp = *this; ++(*this); return __tmp; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr month& operator--()    noexcept { --__m_; return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr month  operator--(int) noexcept { month __tmp = *this; --(*this); return __tmp; }
-    _LIBCPP_HIDE_FROM_ABI        constexpr month& operator+=(const months& __m1) noexcept;
-    _LIBCPP_HIDE_FROM_ABI        constexpr month& operator-=(const months& __m1) noexcept;
-    _LIBCPP_HIDE_FROM_ABI explicit inline constexpr operator unsigned() const noexcept { return __m_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __m_ >= 1 && __m_ <= 12; }
+  month() = default;
+  _LIBCPP_HIDE_FROM_ABI explicit inline constexpr month(unsigned __val) noexcept
+      : __m_(static_cast<unsigned char>(__val)) {}
+  _LIBCPP_HIDE_FROM_ABI inline constexpr month& operator++() noexcept {
+    *this += months{1};
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr month operator++(int) noexcept {
+    month __tmp = *this;
+    ++(*this);
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr month& operator--() noexcept {
+    *this -= months{1};
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr month operator--(int) noexcept {
+    month __tmp = *this;
+    --(*this);
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr month& operator+=(const months& __m1) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr month& operator-=(const months& __m1) noexcept;
+  _LIBCPP_HIDE_FROM_ABI explicit inline constexpr operator unsigned() const noexcept { return __m_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __m_ >= 1 && __m_ <= 12; }
 };
 
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const month& __lhs, const month& __rhs) noexcept
-{ return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); }
-
-_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const month& __lhs, const month& __rhs) noexcept {
-    return static_cast<unsigned>(__lhs) <=> static_cast<unsigned>(__rhs);
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator==(const month& __lhs, const month& __rhs) noexcept {
+  return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month operator+ (const month& __lhs, const months& __rhs) noexcept
-{
-    auto const __mu = static_cast<long long>(static_cast<unsigned>(__lhs)) + (__rhs.count() - 1);
-    auto const __yr = (__mu >= 0 ? __mu : __mu - 11) / 12;
-    return month{static_cast<unsigned>(__mu - __yr * 12 + 1)};
+_LIBCPP_HIDE_FROM_ABI inline constexpr strong_ordering operator<=>(const month& __lhs, const month& __rhs) noexcept {
+  return static_cast<unsigned>(__lhs) <=> static_cast<unsigned>(__rhs);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month operator+ (const months& __lhs, const month& __rhs) noexcept
-{ return __rhs + __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month operator- (const month& __lhs, const months& __rhs) noexcept
-{ return __lhs + -__rhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-months operator-(const month& __lhs, const month& __rhs) noexcept
-{
-    auto const __dm = static_cast<unsigned>(__lhs) - static_cast<unsigned>(__rhs);
-    return months(__dm <= 11 ? __dm : __dm + 12);
+_LIBCPP_HIDE_FROM_ABI inline constexpr month operator+(const month& __lhs, const months& __rhs) noexcept {
+  auto const __mu = static_cast<long long>(static_cast<unsigned>(__lhs)) + (__rhs.count() - 1);
+  auto const __yr = (__mu >= 0 ? __mu : __mu - 11) / 12;
+  return month{static_cast<unsigned>(__mu - __yr * 12 + 1)};
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month& month::operator+=(const months& __dm) noexcept
-{ *this = *this + __dm; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month operator+(const months& __lhs, const month& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month& month::operator-=(const months& __dm) noexcept
-{ *this = *this - __dm; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month operator-(const month& __lhs, const months& __rhs) noexcept {
+  return __lhs + -__rhs;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr months operator-(const month& __lhs, const month& __rhs) noexcept {
+  auto const __dm = static_cast<unsigned>(__lhs) - static_cast<unsigned>(__rhs);
+  return months(__dm <= 11 ? __dm : __dm + 12);
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr month& month::operator+=(const months& __dm) noexcept {
+  *this = *this + __dm;
+  return *this;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr month& month::operator-=(const months& __dm) noexcept {
+  *this = *this - __dm;
+  return *this;
+}
 
 inline constexpr month January{1};
 inline constexpr month February{2};
diff --git a/third_party/libcxx/__chrono/month_weekday.h b/third_party/libcxx/__chrono/month_weekday.h
index 802cbd74f..791987965 100644
--- a/third_party/libcxx/__chrono/month_weekday.h
+++ b/third_party/libcxx/__chrono/month_weekday.h
@@ -22,81 +22,80 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 class month_weekday {
 private:
-    chrono::month __m_;
-    chrono::weekday_indexed __wdi_;
+  chrono::month __m_;
+  chrono::weekday_indexed __wdi_;
+
 public:
-    _LIBCPP_HIDE_FROM_ABI constexpr month_weekday(const chrono::month& __mval, const chrono::weekday_indexed& __wdival) noexcept
-        : __m_{__mval}, __wdi_{__wdival} {}
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month                     month() const noexcept { return __m_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr bool                                 ok() const noexcept { return __m_.ok() && __wdi_.ok(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr month_weekday(const chrono::month& __mval,
+                                                const chrono::weekday_indexed& __wdival) noexcept
+      : __m_{__mval}, __wdi_{__wdival} {}
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __m_.ok() && __wdi_.ok(); }
 };
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const month_weekday& __lhs, const month_weekday& __rhs) noexcept
-{ return __lhs.month() == __rhs.month() && __lhs.weekday_indexed() == __rhs.weekday_indexed(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool
+operator==(const month_weekday& __lhs, const month_weekday& __rhs) noexcept {
+  return __lhs.month() == __rhs.month() && __lhs.weekday_indexed() == __rhs.weekday_indexed();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const month_weekday& __lhs, const month_weekday& __rhs) noexcept
-{ return !(__lhs == __rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_weekday
+operator/(const month& __lhs, const weekday_indexed& __rhs) noexcept {
+  return month_weekday{__lhs, __rhs};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_weekday operator/(const month& __lhs, const weekday_indexed& __rhs) noexcept
-{ return month_weekday{__lhs, __rhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_weekday operator/(int __lhs, const weekday_indexed& __rhs) noexcept {
+  return month_weekday{month(__lhs), __rhs};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_weekday operator/(int __lhs, const weekday_indexed& __rhs) noexcept
-{ return month_weekday{month(__lhs), __rhs}; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_weekday operator/(const weekday_indexed& __lhs, const month& __rhs) noexcept
-{ return month_weekday{__rhs, __lhs}; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_weekday operator/(const weekday_indexed& __lhs, int __rhs) noexcept
-{ return month_weekday{month(__rhs), __lhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_weekday
+operator/(const weekday_indexed& __lhs, const month& __rhs) noexcept {
+  return month_weekday{__rhs, __lhs};
+}
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_weekday operator/(const weekday_indexed& __lhs, int __rhs) noexcept {
+  return month_weekday{month(__rhs), __lhs};
+}
 
 class month_weekday_last {
-    chrono::month        __m_;
-    chrono::weekday_last __wdl_;
-  public:
-    _LIBCPP_HIDE_FROM_ABI constexpr month_weekday_last(const chrono::month& __mval, const chrono::weekday_last& __wdlval) noexcept
-        : __m_{__mval}, __wdl_{__wdlval} {}
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month               month() const noexcept { return __m_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday_last weekday_last() const noexcept { return __wdl_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr bool                           ok() const noexcept { return __m_.ok() && __wdl_.ok(); }
+  chrono::month __m_;
+  chrono::weekday_last __wdl_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr month_weekday_last(const chrono::month& __mval,
+                                                     const chrono::weekday_last& __wdlval) noexcept
+      : __m_{__mval}, __wdl_{__wdlval} {}
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday_last weekday_last() const noexcept { return __wdl_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __m_.ok() && __wdl_.ok(); }
 };
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const month_weekday_last& __lhs, const month_weekday_last& __rhs) noexcept
-{ return __lhs.month() == __rhs.month() && __lhs.weekday_last() == __rhs.weekday_last(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool
+operator==(const month_weekday_last& __lhs, const month_weekday_last& __rhs) noexcept {
+  return __lhs.month() == __rhs.month() && __lhs.weekday_last() == __rhs.weekday_last();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const month_weekday_last& __lhs, const month_weekday_last& __rhs) noexcept
-{ return !(__lhs == __rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_weekday_last
+operator/(const month& __lhs, const weekday_last& __rhs) noexcept {
+  return month_weekday_last{__lhs, __rhs};
+}
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_weekday_last operator/(int __lhs, const weekday_last& __rhs) noexcept {
+  return month_weekday_last{month(__lhs), __rhs};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_weekday_last operator/(const month& __lhs, const weekday_last& __rhs) noexcept
-{ return month_weekday_last{__lhs, __rhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_weekday_last
+operator/(const weekday_last& __lhs, const month& __rhs) noexcept {
+  return month_weekday_last{__rhs, __lhs};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_weekday_last operator/(int __lhs, const weekday_last& __rhs) noexcept
-{ return month_weekday_last{month(__lhs), __rhs}; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_weekday_last operator/(const weekday_last& __lhs, const month& __rhs) noexcept
-{ return month_weekday_last{__rhs, __lhs}; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_weekday_last operator/(const weekday_last& __lhs, int __rhs) noexcept
-{ return month_weekday_last{month(__rhs), __lhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_weekday_last operator/(const weekday_last& __lhs, int __rhs) noexcept {
+  return month_weekday_last{month(__rhs), __lhs};
+}
 } // namespace chrono
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__chrono/monthday.h b/third_party/libcxx/__chrono/monthday.h
index 03fd7503a..a89d16e51 100644
--- a/third_party/libcxx/__chrono/monthday.h
+++ b/third_party/libcxx/__chrono/monthday.h
@@ -24,101 +24,105 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 class month_day {
 private:
-   chrono::month __m_;
-   chrono::day   __d_;
+  chrono::month __m_;
+  chrono::day __d_;
+
 public:
-    month_day() = default;
-    _LIBCPP_HIDE_FROM_ABI constexpr month_day(const chrono::month& __mval, const chrono::day& __dval) noexcept
-        : __m_{__mval}, __d_{__dval} {}
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::day   day()   const noexcept { return __d_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr bool ok() const noexcept;
+  month_day() = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr month_day(const chrono::month& __mval, const chrono::day& __dval) noexcept
+      : __m_{__mval}, __d_{__dval} {}
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::day day() const noexcept { return __d_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool ok() const noexcept;
 };
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool month_day::ok() const noexcept
-{
-    if (!__m_.ok()) return false;
-    const unsigned __dval = static_cast<unsigned>(__d_);
-    if (__dval < 1 || __dval > 31) return false;
-    if (__dval <= 29) return true;
-//  Now we've got either 30 or 31
-    const unsigned __mval = static_cast<unsigned>(__m_);
-    if (__mval == 2) return false;
-    if (__mval == 4 || __mval == 6 || __mval == 9 || __mval == 11)
-        return __dval == 30;
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool month_day::ok() const noexcept {
+  if (!__m_.ok())
+    return false;
+  const unsigned __dval = static_cast<unsigned>(__d_);
+  if (__dval < 1 || __dval > 31)
+    return false;
+  if (__dval <= 29)
     return true;
+  //  Now we've got either 30 or 31
+  const unsigned __mval = static_cast<unsigned>(__m_);
+  if (__mval == 2)
+    return false;
+  if (__mval == 4 || __mval == 6 || __mval == 9 || __mval == 11)
+    return __dval == 30;
+  return true;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const month_day& __lhs, const month_day& __rhs) noexcept
-{ return __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day(); }
-
-_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const month_day& __lhs, const month_day& __rhs) noexcept {
-    if (auto __c = __lhs.month() <=> __rhs.month(); __c != 0)
-        return __c;
-    return __lhs.day() <=> __rhs.day();
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator==(const month_day& __lhs, const month_day& __rhs) noexcept {
+  return __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day();
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_day operator/(const month& __lhs, const day& __rhs) noexcept
-{ return month_day{__lhs, __rhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr strong_ordering
+operator<=>(const month_day& __lhs, const month_day& __rhs) noexcept {
+  if (auto __c = __lhs.month() <=> __rhs.month(); __c != 0)
+    return __c;
+  return __lhs.day() <=> __rhs.day();
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-month_day operator/(const day& __lhs, const month& __rhs) noexcept
-{ return __rhs / __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_day operator/(const month& __lhs, const day& __rhs) noexcept {
+  return month_day{__lhs, __rhs};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_day operator/(const month& __lhs, int __rhs) noexcept
-{ return __lhs / day(__rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_day operator/(const day& __lhs, const month& __rhs) noexcept {
+  return __rhs / __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-month_day operator/(int __lhs, const day& __rhs) noexcept
-{ return month(__lhs) / __rhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_day operator/(const month& __lhs, int __rhs) noexcept {
+  return __lhs / day(__rhs);
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-month_day operator/(const day& __lhs, int __rhs) noexcept
-{ return month(__rhs) / __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_day operator/(int __lhs, const day& __rhs) noexcept {
+  return month(__lhs) / __rhs;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_day operator/(const day& __lhs, int __rhs) noexcept {
+  return month(__rhs) / __lhs;
+}
 
 class month_day_last {
 private:
-    chrono::month __m_;
+  chrono::month __m_;
+
 public:
-    _LIBCPP_HIDE_FROM_ABI explicit constexpr month_day_last(const chrono::month& __val) noexcept
-        : __m_{__val} {}
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __m_.ok(); }
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr month_day_last(const chrono::month& __val) noexcept : __m_{__val} {}
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __m_.ok(); }
 };
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const month_day_last& __lhs, const month_day_last& __rhs) noexcept
-{ return __lhs.month() == __rhs.month(); }
-
-_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering
-operator<=>(const month_day_last& __lhs, const month_day_last& __rhs) noexcept {
-    return __lhs.month() <=> __rhs.month();
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool
+operator==(const month_day_last& __lhs, const month_day_last& __rhs) noexcept {
+  return __lhs.month() == __rhs.month();
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_day_last operator/(const month& __lhs, last_spec) noexcept
-{ return month_day_last{__lhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr strong_ordering
+operator<=>(const month_day_last& __lhs, const month_day_last& __rhs) noexcept {
+  return __lhs.month() <=> __rhs.month();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_day_last operator/(last_spec, const month& __rhs) noexcept
-{ return month_day_last{__rhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_day_last operator/(const month& __lhs, last_spec) noexcept {
+  return month_day_last{__lhs};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_day_last operator/(int __lhs, last_spec) noexcept
-{ return month_day_last{month(__lhs)}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_day_last operator/(last_spec, const month& __rhs) noexcept {
+  return month_day_last{__rhs};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-month_day_last operator/(last_spec, int __rhs) noexcept
-{ return month_day_last{month(__rhs)}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_day_last operator/(int __lhs, last_spec) noexcept {
+  return month_day_last{month(__lhs)};
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr month_day_last operator/(last_spec, int __rhs) noexcept {
+  return month_day_last{month(__rhs)};
+}
 
 } // namespace chrono
 
diff --git a/third_party/libcxx/__chrono/ostream.h b/third_party/libcxx/__chrono/ostream.h
index f171944b5..e6c43254e 100644
--- a/third_party/libcxx/__chrono/ostream.h
+++ b/third_party/libcxx/__chrono/ostream.h
@@ -15,20 +15,23 @@
 #include <__chrono/duration.h>
 #include <__chrono/file_clock.h>
 #include <__chrono/hh_mm_ss.h>
+#include <__chrono/local_info.h>
 #include <__chrono/month.h>
 #include <__chrono/month_weekday.h>
 #include <__chrono/monthday.h>
 #include <__chrono/statically_widen.h>
+#include <__chrono/sys_info.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/weekday.h>
 #include <__chrono/year.h>
 #include <__chrono/year_month.h>
 #include <__chrono/year_month_day.h>
 #include <__chrono/year_month_weekday.h>
+#include <__chrono/zoned_time.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/format_functions.h>
-#include <ostream>
+#include <__fwd/ostream.h>
 #include <ratio>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -42,11 +45,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace chrono {
 
 template <class _CharT, class _Traits, class _Duration>
+  requires(!treat_as_floating_point_v<typename _Duration::rep> && _Duration{1} < days{1})
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_time<_Duration> __tp) {
+operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_time<_Duration>& __tp) {
   return __os << std::format(__os.getloc(), _LIBCPP_STATICALLY_WIDEN(_CharT, "{:L%F %T}"), __tp);
 }
 
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_days& __dp) {
+  return __os << year_month_day{__dp};
+}
+
 template <class _CharT, class _Traits, class _Duration>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const file_time<_Duration> __tp) {
@@ -255,6 +265,54 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const hh_mm_ss<_Duration> __hms
   return __os << std::format(__os.getloc(), _LIBCPP_STATICALLY_WIDEN(_CharT, "{:L%T}"), __hms);
 }
 
+#  if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_info& __info) {
+  // __info.abbrev is always std::basic_string<char>.
+  // Since these strings typically are short the conversion should be cheap.
+  std::basic_string<_CharT> __abbrev{__info.abbrev.begin(), __info.abbrev.end()};
+  return __os << std::format(
+             _LIBCPP_STATICALLY_WIDEN(_CharT, "[{:%F %T}, {:%F %T}) {:%T} {:%Q%q} \"{}\""),
+             __info.begin,
+             __info.end,
+             hh_mm_ss{__info.offset},
+             __info.save,
+             __abbrev);
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const local_info& __info) {
+  auto __result = [&]() -> basic_string<_CharT> {
+    switch (__info.result) {
+    case local_info::unique:
+      return _LIBCPP_STATICALLY_WIDEN(_CharT, "unique");
+    case local_info::nonexistent:
+      return _LIBCPP_STATICALLY_WIDEN(_CharT, "non-existent");
+    case local_info::ambiguous:
+      return _LIBCPP_STATICALLY_WIDEN(_CharT, "ambiguous");
+
+    default:
+      return std::format(_LIBCPP_STATICALLY_WIDEN(_CharT, "unspecified result ({})"), __info.result);
+    };
+  };
+
+  return __os << std::format(
+             _LIBCPP_STATICALLY_WIDEN(_CharT, "{}: {{{}, {}}}"), __result(), __info.first, __info.second);
+}
+
+#    if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                          \
+        !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+template <class _CharT, class _Traits, class _Duration, class _TimeZonePtr>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const zoned_time<_Duration, _TimeZonePtr>& __tp) {
+  return __os << std::format(__os.getloc(), _LIBCPP_STATICALLY_WIDEN(_CharT, "{:L%F %T %Z}"), __tp);
+}
+#    endif
+#  endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
 } // namespace chrono
 
 #endif // if _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__chrono/parser_std_format_spec.h b/third_party/libcxx/__chrono/parser_std_format_spec.h
index fb6528a47..785bbae19 100644
--- a/third_party/libcxx/__chrono/parser_std_format_spec.h
+++ b/third_party/libcxx/__chrono/parser_std_format_spec.h
@@ -160,17 +160,17 @@ public:
 private:
   _LIBCPP_HIDE_FROM_ABI constexpr _ConstIterator
   __parse_chrono_specs(_ConstIterator __begin, _ConstIterator __end, __flags __flags) {
-    _LIBCPP_ASSERT(__begin != __end,
-                   "When called with an empty input the function will cause "
-                   "undefined behavior by evaluating data not in the input");
+    _LIBCPP_ASSERT_INTERNAL(__begin != __end,
+                            "When called with an empty input the function will cause "
+                            "undefined behavior by evaluating data not in the input");
 
     if (*__begin != _CharT('%') && *__begin != _CharT('}'))
-      std::__throw_format_error("Expected '%' or '}' in the chrono format-string");
+      std::__throw_format_error("The format specifier expects a '%' or a '}'");
 
     do {
       switch (*__begin) {
       case _CharT('{'):
-        std::__throw_format_error("The chrono-specs contains a '{'");
+        std::__throw_format_error("The chrono specifiers contain a '{'");
 
       case _CharT('}'):
         return __begin;
@@ -195,7 +195,7 @@ private:
   __parse_conversion_spec(_ConstIterator& __begin, _ConstIterator __end, __flags __flags) {
     ++__begin;
     if (__begin == __end)
-      std::__throw_format_error("End of input while parsing the modifier chrono conversion-spec");
+      std::__throw_format_error("End of input while parsing a conversion specifier");
 
     switch (*__begin) {
     case _CharT('n'):
diff --git a/third_party/libcxx/__chrono/steady_clock.h b/third_party/libcxx/__chrono/steady_clock.h
index ba8335173..612a7f156 100644
--- a/third_party/libcxx/__chrono/steady_clock.h
+++ b/third_party/libcxx/__chrono/steady_clock.h
@@ -20,20 +20,18 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
-class _LIBCPP_TYPE_VIS steady_clock
-{
+class _LIBCPP_EXPORTED_FROM_ABI steady_clock {
 public:
-    typedef nanoseconds                                   duration;
-    typedef duration::rep                                 rep;
-    typedef duration::period                              period;
-    typedef chrono::time_point<steady_clock, duration>    time_point;
-    static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = true;
+  typedef nanoseconds duration;
+  typedef duration::rep rep;
+  typedef duration::period period;
+  typedef chrono::time_point<steady_clock, duration> time_point;
+  static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = true;
 
-    static time_point now() _NOEXCEPT;
+  static time_point now() _NOEXCEPT;
 };
 #endif
 
diff --git a/third_party/libcxx/__chrono/sys_info.h b/third_party/libcxx/__chrono/sys_info.h
new file mode 100644
index 000000000..11536cbde
--- /dev/null
+++ b/third_party/libcxx/__chrono/sys_info.h
@@ -0,0 +1,51 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_SYS_INFO_H
+#define _LIBCPP___CHRONO_SYS_INFO_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#  include <__chrono/duration.h>
+#  include <__chrono/system_clock.h>
+#  include <__chrono/time_point.h>
+#  include <__config>
+#  include <string>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20
+
+namespace chrono {
+
+struct sys_info {
+  sys_seconds begin;
+  sys_seconds end;
+  seconds offset;
+  minutes save;
+  string abbrev;
+};
+
+} // namespace chrono
+
+#  endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#endif // _LIBCPP___CHRONO_SYS_INFO_H
diff --git a/third_party/libcxx/__chrono/system_clock.h b/third_party/libcxx/__chrono/system_clock.h
index e8a41ceab..5a9eb65bd 100644
--- a/third_party/libcxx/__chrono/system_clock.h
+++ b/third_party/libcxx/__chrono/system_clock.h
@@ -21,21 +21,19 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
-class _LIBCPP_TYPE_VIS system_clock
-{
+class _LIBCPP_EXPORTED_FROM_ABI system_clock {
 public:
-    typedef microseconds                     duration;
-    typedef duration::rep                    rep;
-    typedef duration::period                 period;
-    typedef chrono::time_point<system_clock> time_point;
-    static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false;
+  typedef microseconds duration;
+  typedef duration::rep rep;
+  typedef duration::period period;
+  typedef chrono::time_point<system_clock> time_point;
+  static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false;
 
-    static time_point now() _NOEXCEPT;
-    static time_t     to_time_t  (const time_point& __t) _NOEXCEPT;
-    static time_point from_time_t(time_t __t) _NOEXCEPT;
+  static time_point now() _NOEXCEPT;
+  static time_t to_time_t(const time_point& __t) _NOEXCEPT;
+  static time_point from_time_t(time_t __t) _NOEXCEPT;
 };
 
 #if _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__chrono/time_point.h b/third_party/libcxx/__chrono/time_point.h
index c14835401..aaf0b098f 100644
--- a/third_party/libcxx/__chrono/time_point.h
+++ b/third_party/libcxx/__chrono/time_point.h
@@ -28,128 +28,96 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 template <class _Clock, class _Duration = typename _Clock::duration>
-class _LIBCPP_TEMPLATE_VIS time_point
-{
-    static_assert(__is_duration<_Duration>::value,
-                  "Second template parameter of time_point must be a std::chrono::duration");
+class _LIBCPP_TEMPLATE_VIS time_point {
+  static_assert(__is_duration<_Duration>::value,
+                "Second template parameter of time_point must be a std::chrono::duration");
+
 public:
-    typedef _Clock                    clock;
-    typedef _Duration                 duration;
-    typedef typename duration::rep    rep;
-    typedef typename duration::period period;
+  typedef _Clock clock;
+  typedef _Duration duration;
+  typedef typename duration::rep rep;
+  typedef typename duration::period period;
+
 private:
-    duration __d_;
+  duration __d_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 time_point() : __d_(duration::zero()) {}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit time_point(const duration& __d) : __d_(__d) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 time_point() : __d_(duration::zero()) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit time_point(const duration& __d) : __d_(__d) {}
 
-    // conversions
-    template <class _Duration2>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    time_point(const time_point<clock, _Duration2>& __t,
-        typename enable_if
-        <
-            is_convertible<_Duration2, duration>::value
-        >::type* = nullptr)
-            : __d_(__t.time_since_epoch()) {}
+  // conversions
+  template <class _Duration2, __enable_if_t<is_convertible<_Duration2, duration>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 time_point(const time_point<clock, _Duration2>& __t)
+      : __d_(__t.time_since_epoch()) {}
 
-    // observer
+  // observer
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 duration time_since_epoch() const {return __d_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 duration time_since_epoch() const { return __d_; }
 
-    // arithmetic
+  // arithmetic
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 time_point& operator+=(const duration& __d) {
+    __d_ += __d;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 time_point& operator-=(const duration& __d) {
+    __d_ -= __d;
+    return *this;
+  }
 
-    // special values
+  // special values
 
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() _NOEXCEPT {return time_point(duration::min());}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() _NOEXCEPT {return time_point(duration::max());}
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR time_point min() _NOEXCEPT { return time_point(duration::min()); }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR time_point max() _NOEXCEPT { return time_point(duration::max()); }
 };
 
 } // namespace chrono
 
 template <class _Clock, class _Duration1, class _Duration2>
-struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>,
-                                         chrono::time_point<_Clock, _Duration2> >
-{
-    typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
+struct _LIBCPP_TEMPLATE_VIS
+common_type<chrono::time_point<_Clock, _Duration1>, chrono::time_point<_Clock, _Duration2> > {
+  typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
 };
 
 namespace chrono {
 
 template <class _ToDuration, class _Clock, class _Duration>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-time_point<_Clock, _ToDuration>
-time_point_cast(const time_point<_Clock, _Duration>& __t)
-{
-    return time_point<_Clock, _ToDuration>(chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 time_point<_Clock, _ToDuration>
+time_point_cast(const time_point<_Clock, _Duration>& __t) {
+  return time_point<_Clock, _ToDuration>(chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
 }
 
 #if _LIBCPP_STD_VER >= 17
-template <class _ToDuration, class _Clock, class _Duration>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    time_point<_Clock, _ToDuration>
->::type
-floor(const time_point<_Clock, _Duration>& __t)
-{
-    return time_point<_Clock, _ToDuration>{chrono::floor<_ToDuration>(__t.time_since_epoch())};
+template <class _ToDuration, class _Clock, class _Duration, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI constexpr time_point<_Clock, _ToDuration> floor(const time_point<_Clock, _Duration>& __t) {
+  return time_point<_Clock, _ToDuration>{chrono::floor<_ToDuration>(__t.time_since_epoch())};
 }
 
-template <class _ToDuration, class _Clock, class _Duration>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    time_point<_Clock, _ToDuration>
->::type
-ceil(const time_point<_Clock, _Duration>& __t)
-{
-    return time_point<_Clock, _ToDuration>{chrono::ceil<_ToDuration>(__t.time_since_epoch())};
+template <class _ToDuration, class _Clock, class _Duration, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI constexpr time_point<_Clock, _ToDuration> ceil(const time_point<_Clock, _Duration>& __t) {
+  return time_point<_Clock, _ToDuration>{chrono::ceil<_ToDuration>(__t.time_since_epoch())};
 }
 
-template <class _ToDuration, class _Clock, class _Duration>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    __is_duration<_ToDuration>::value,
-    time_point<_Clock, _ToDuration>
->::type
-round(const time_point<_Clock, _Duration>& __t)
-{
-    return time_point<_Clock, _ToDuration>{chrono::round<_ToDuration>(__t.time_since_epoch())};
+template <class _ToDuration, class _Clock, class _Duration, enable_if_t<__is_duration<_ToDuration>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI constexpr time_point<_Clock, _ToDuration> round(const time_point<_Clock, _Duration>& __t) {
+  return time_point<_Clock, _ToDuration>{chrono::round<_ToDuration>(__t.time_since_epoch())};
 }
 
-template <class _Rep, class _Period>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if
-<
-    numeric_limits<_Rep>::is_signed,
-    duration<_Rep, _Period>
->::type
-abs(duration<_Rep, _Period> __d)
-{
-    return __d >= __d.zero() ? +__d : -__d;
+template <class _Rep, class _Period, enable_if_t<numeric_limits<_Rep>::is_signed, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI constexpr duration<_Rep, _Period> abs(duration<_Rep, _Period> __d) {
+  return __d >= __d.zero() ? +__d : -__d;
 }
 #endif // _LIBCPP_STD_VER >= 17
 
 // time_point ==
 
 template <class _Clock, class _Duration1, class _Duration2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
-{
-    return __lhs.time_since_epoch() == __rhs.time_since_epoch();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
+  return __lhs.time_since_epoch() == __rhs.time_since_epoch();
 }
 
 #if _LIBCPP_STD_VER <= 17
@@ -157,11 +125,9 @@ operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock,
 // time_point !=
 
 template <class _Clock, class _Duration1, class _Duration2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
-{
-    return !(__lhs == __rhs);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
+  return !(__lhs == __rhs);
 }
 
 #endif // _LIBCPP_STD_VER <= 17
@@ -169,41 +135,33 @@ operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock,
 // time_point <
 
 template <class _Clock, class _Duration1, class _Duration2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
-{
-    return __lhs.time_since_epoch() < __rhs.time_since_epoch();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
+  return __lhs.time_since_epoch() < __rhs.time_since_epoch();
 }
 
 // time_point >
 
 template <class _Clock, class _Duration1, class _Duration2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
-{
-    return __rhs < __lhs;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
+  return __rhs < __lhs;
 }
 
 // time_point <=
 
 template <class _Clock, class _Duration1, class _Duration2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
-{
-    return !(__rhs < __lhs);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
+  return !(__rhs < __lhs);
 }
 
 // time_point >=
 
 template <class _Clock, class _Duration1, class _Duration2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
-{
-    return !(__lhs < __rhs);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
+  return !(__lhs < __rhs);
 }
 
 #if _LIBCPP_STD_VER >= 20
@@ -211,7 +169,7 @@ operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock,
 template <class _Clock, class _Duration1, three_way_comparable_with<_Duration1> _Duration2>
 _LIBCPP_HIDE_FROM_ABI constexpr auto
 operator<=>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
-    return __lhs.time_since_epoch() <=> __rhs.time_since_epoch();
+  return __lhs.time_since_epoch() <=> __rhs.time_since_epoch();
 }
 
 #endif // _LIBCPP_STD_VER >= 20
@@ -219,43 +177,38 @@ operator<=>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock
 // time_point operator+(time_point x, duration y);
 
 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
-operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
-    return _Tr (__lhs.time_since_epoch() + __rhs);
+inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX14 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
+operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
+  return _Tr(__lhs.time_since_epoch() + __rhs);
 }
 
 // time_point operator+(duration x, time_point y);
 
 template <class _Rep1, class _Period1, class _Clock, class _Duration2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
-operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
-{
-    return __rhs + __lhs;
+inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX14 time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
+operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
+  return __rhs + __lhs;
 }
 
 // time_point operator-(time_point x, duration y);
 
 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
-operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
-{
-    typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret;
-    return _Ret(__lhs.time_since_epoch() -__rhs);
+inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX14 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
+operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
+  typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret;
+  return _Ret(__lhs.time_since_epoch() - __rhs);
 }
 
 // duration operator-(time_point x, time_point y);
 
 template <class _Clock, class _Duration1, class _Duration2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename common_type<_Duration1, _Duration2>::type
-operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
-{
-    return __lhs.time_since_epoch() - __rhs.time_since_epoch();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename common_type<_Duration1, _Duration2>::type
+operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
+  return __lhs.time_since_epoch() - __rhs.time_since_epoch();
 }
 
 } // namespace chrono
diff --git a/third_party/libcxx/__chrono/time_zone.h b/third_party/libcxx/__chrono/time_zone.h
new file mode 100644
index 000000000..de11dac1e
--- /dev/null
+++ b/third_party/libcxx/__chrono/time_zone.h
@@ -0,0 +1,182 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_TIME_ZONE_H
+#define _LIBCPP___CHRONO_TIME_ZONE_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#  include <__chrono/calendar.h>
+#  include <__chrono/duration.h>
+#  include <__chrono/exception.h>
+#  include <__chrono/local_info.h>
+#  include <__chrono/sys_info.h>
+#  include <__chrono/system_clock.h>
+#  include <__compare/strong_order.h>
+#  include <__config>
+#  include <__memory/unique_ptr.h>
+#  include <__type_traits/common_type.h>
+#  include <string_view>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_PUSH_MACROS
+#  include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&   \
+      !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {
+
+enum class choose { earliest, latest };
+
+class _LIBCPP_AVAILABILITY_TZDB time_zone {
+  _LIBCPP_HIDE_FROM_ABI time_zone() = default;
+
+public:
+  class __impl; // public so it can be used by make_unique.
+
+  // The "constructor".
+  //
+  // The default constructor is private to avoid the constructor from being
+  // part of the ABI. Instead use an __ugly_named function as an ABI interface,
+  // since that gives us the ability to change it in the future.
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI static time_zone __create(unique_ptr<__impl>&& __p);
+
+  _LIBCPP_EXPORTED_FROM_ABI ~time_zone();
+
+  _LIBCPP_HIDE_FROM_ABI time_zone(time_zone&&)            = default;
+  _LIBCPP_HIDE_FROM_ABI time_zone& operator=(time_zone&&) = default;
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_view name() const noexcept { return __name(); }
+
+  template <class _Duration>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI sys_info get_info(const sys_time<_Duration>& __time) const {
+    return __get_info(chrono::time_point_cast<seconds>(__time));
+  }
+
+  template <class _Duration>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI local_info get_info(const local_time<_Duration>& __time) const {
+    return __get_info(chrono::time_point_cast<seconds>(__time));
+  }
+
+  // We don't apply nodiscard here since this function throws on many inputs,
+  // so it could be used as a validation.
+  template <class _Duration>
+  _LIBCPP_HIDE_FROM_ABI sys_time<common_type_t<_Duration, seconds>> to_sys(const local_time<_Duration>& __time) const {
+    local_info __info = get_info(__time);
+    switch (__info.result) {
+    case local_info::unique:
+      return sys_time<common_type_t<_Duration, seconds>>{__time.time_since_epoch() - __info.first.offset};
+
+    case local_info::nonexistent:
+      chrono::__throw_nonexistent_local_time(__time, __info);
+
+    case local_info::ambiguous:
+      chrono::__throw_ambiguous_local_time(__time, __info);
+    }
+
+    // TODO TZDB The Standard does not specify anything in these cases.
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __info.result != -1, "cannot convert the local time; it would be before the minimum system clock value");
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __info.result != -2, "cannot convert the local time; it would be after the maximum system clock value");
+
+    return {};
+  }
+
+  template <class _Duration>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI sys_time<common_type_t<_Duration, seconds>>
+  to_sys(const local_time<_Duration>& __time, choose __z) const {
+    local_info __info = get_info(__time);
+    switch (__info.result) {
+    case local_info::unique:
+    case local_info::nonexistent: // first and second are the same
+      return sys_time<common_type_t<_Duration, seconds>>{__time.time_since_epoch() - __info.first.offset};
+
+    case local_info::ambiguous:
+      switch (__z) {
+      case choose::earliest:
+        return sys_time<common_type_t<_Duration, seconds>>{__time.time_since_epoch() - __info.first.offset};
+
+      case choose::latest:
+        return sys_time<common_type_t<_Duration, seconds>>{__time.time_since_epoch() - __info.second.offset};
+
+        // Note a value out of bounds is not specified.
+      }
+    }
+
+    // TODO TZDB The standard does not specify anything in these cases.
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __info.result != -1, "cannot convert the local time; it would be before the minimum system clock value");
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __info.result != -2, "cannot convert the local time; it would be after the maximum system clock value");
+
+    return {};
+  }
+
+  template <class _Duration>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI local_time<common_type_t<_Duration, seconds>>
+  to_local(const sys_time<_Duration>& __time) const {
+    using _Dp = common_type_t<_Duration, seconds>;
+
+    sys_info __info = get_info(__time);
+
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __info.offset >= chrono::seconds{0} || __time.time_since_epoch() >= _Dp::min() - __info.offset,
+        "cannot convert the system time; it would be before the minimum local clock value");
+
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __info.offset <= chrono::seconds{0} || __time.time_since_epoch() <= _Dp::max() - __info.offset,
+        "cannot convert the system time; it would be after the maximum local clock value");
+
+    return local_time<_Dp>{__time.time_since_epoch() + __info.offset};
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const __impl& __implementation() const noexcept { return *__impl_; }
+
+private:
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI string_view __name() const noexcept;
+
+  [[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI sys_info __get_info(sys_seconds __time) const;
+  [[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI local_info __get_info(local_seconds __time) const;
+
+  unique_ptr<__impl> __impl_;
+};
+
+[[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI inline bool
+operator==(const time_zone& __x, const time_zone& __y) noexcept {
+  return __x.name() == __y.name();
+}
+
+[[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI inline strong_ordering
+operator<=>(const time_zone& __x, const time_zone& __y) noexcept {
+  return __x.name() <=> __y.name();
+}
+
+} // namespace chrono
+
+#  endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
+         // && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#endif // _LIBCPP___CHRONO_TIME_ZONE_H
diff --git a/third_party/libcxx/__chrono/time_zone_link.h b/third_party/libcxx/__chrono/time_zone_link.h
new file mode 100644
index 000000000..b2d365c5f
--- /dev/null
+++ b/third_party/libcxx/__chrono/time_zone_link.h
@@ -0,0 +1,79 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_TIME_ZONE_LINK_H
+#define _LIBCPP___CHRONO_TIME_ZONE_LINK_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#  include <__compare/strong_order.h>
+#  include <__config>
+#  include <__utility/private_constructor_tag.h>
+#  include <string>
+#  include <string_view>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_PUSH_MACROS
+#  include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&   \
+      !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {
+
+class time_zone_link {
+public:
+  [[nodiscard]]
+  _LIBCPP_HIDE_FROM_ABI explicit time_zone_link(__private_constructor_tag, string_view __name, string_view __target)
+      : __name_{__name}, __target_{__target} {}
+
+  _LIBCPP_HIDE_FROM_ABI time_zone_link(time_zone_link&&)            = default;
+  _LIBCPP_HIDE_FROM_ABI time_zone_link& operator=(time_zone_link&&) = default;
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_view name() const noexcept { return __name_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_view target() const noexcept { return __target_; }
+
+private:
+  string __name_;
+  // TODO TZDB instead of the name we can store the pointer to a zone. These
+  // pointers are immutable. This makes it possible to directly return a
+  // pointer in the time_zone in the 'locate_zone' function.
+  string __target_;
+};
+
+[[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI inline bool
+operator==(const time_zone_link& __x, const time_zone_link& __y) noexcept {
+  return __x.name() == __y.name();
+}
+
+[[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI inline strong_ordering
+operator<=>(const time_zone_link& __x, const time_zone_link& __y) noexcept {
+  return __x.name() <=> __y.name();
+}
+
+} // namespace chrono
+
+#  endif //_LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#endif // _LIBCPP___CHRONO_TIME_ZONE_LINK_H
diff --git a/third_party/libcxx/__chrono/tzdb.h b/third_party/libcxx/__chrono/tzdb.h
new file mode 100644
index 000000000..f731f8c31
--- /dev/null
+++ b/third_party/libcxx/__chrono/tzdb.h
@@ -0,0 +1,94 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_TZDB_H
+#define _LIBCPP___CHRONO_TZDB_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#  include <__algorithm/ranges_lower_bound.h>
+#  include <__chrono/leap_second.h>
+#  include <__chrono/time_zone.h>
+#  include <__chrono/time_zone_link.h>
+#  include <__config>
+#  include <string>
+#  include <vector>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_PUSH_MACROS
+#  include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&   \
+      !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {
+
+struct tzdb {
+  string version;
+  vector<time_zone> zones;
+  vector<time_zone_link> links;
+
+  vector<leap_second> leap_seconds;
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const time_zone* __locate_zone(string_view __name) const {
+    if (const time_zone* __result = __find_in_zone(__name))
+      return __result;
+
+    if (auto __it = ranges::lower_bound(links, __name, {}, &time_zone_link::name);
+        __it != links.end() && __it->name() == __name)
+      if (const time_zone* __result = __find_in_zone(__it->target()))
+        return __result;
+
+    return nullptr;
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const time_zone* locate_zone(string_view __name) const {
+    if (const time_zone* __result = __locate_zone(__name))
+      return __result;
+
+    std::__throw_runtime_error("tzdb: requested time zone not found");
+  }
+
+  [[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI const time_zone* current_zone() const {
+    return __current_zone();
+  }
+
+private:
+  _LIBCPP_HIDE_FROM_ABI const time_zone* __find_in_zone(string_view __name) const noexcept {
+    if (auto __it = ranges::lower_bound(zones, __name, {}, &time_zone::name);
+        __it != zones.end() && __it->name() == __name)
+      return std::addressof(*__it);
+
+    return nullptr;
+  }
+
+  [[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI const time_zone* __current_zone() const;
+};
+
+} // namespace chrono
+
+#  endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
+         // && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#endif // _LIBCPP___CHRONO_TZDB_H
diff --git a/third_party/libcxx/__chrono/tzdb_list.h b/third_party/libcxx/__chrono/tzdb_list.h
new file mode 100644
index 000000000..aeef4fe1a
--- /dev/null
+++ b/third_party/libcxx/__chrono/tzdb_list.h
@@ -0,0 +1,108 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_TZDB_LIST_H
+#define _LIBCPP___CHRONO_TZDB_LIST_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#  include <__chrono/time_zone.h>
+#  include <__chrono/tzdb.h>
+#  include <__config>
+#  include <__fwd/string.h>
+#  include <forward_list>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&   \
+      !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {
+
+// TODO TZDB
+// Libc++ recently switched to only export __ugly_names from the dylib.
+// Since the library is still experimental the functions in this header
+// should be adapted to this new style. The other tzdb headers should be
+// evaluated too.
+
+class _LIBCPP_AVAILABILITY_TZDB tzdb_list {
+public:
+  class __impl; // public to allow construction in dylib
+  _LIBCPP_HIDE_FROM_ABI explicit tzdb_list(__impl* __p) : __impl_(__p) {
+    _LIBCPP_ASSERT_NON_NULL(__impl_ != nullptr, "initialized time_zone without a valid pimpl object");
+  }
+  _LIBCPP_EXPORTED_FROM_ABI ~tzdb_list();
+
+  tzdb_list(const tzdb_list&)            = delete;
+  tzdb_list& operator=(const tzdb_list&) = delete;
+
+  using const_iterator = forward_list<tzdb>::const_iterator;
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const tzdb& front() const noexcept { return __front(); }
+
+  _LIBCPP_HIDE_FROM_ABI const_iterator erase_after(const_iterator __p) { return __erase_after(__p); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const noexcept { return __begin(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const noexcept { return __end(); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const noexcept { return __cbegin(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const noexcept { return __cend(); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI __impl& __implementation() { return *__impl_; }
+
+private:
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI const tzdb& __front() const noexcept;
+
+  _LIBCPP_EXPORTED_FROM_ABI const_iterator __erase_after(const_iterator __p);
+
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI const_iterator __begin() const noexcept;
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI const_iterator __end() const noexcept;
+
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI const_iterator __cbegin() const noexcept;
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI const_iterator __cend() const noexcept;
+
+  __impl* __impl_;
+};
+
+[[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI tzdb_list& get_tzdb_list();
+
+[[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI inline const tzdb& get_tzdb() {
+  return get_tzdb_list().front();
+}
+
+[[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI inline const time_zone* locate_zone(string_view __name) {
+  return get_tzdb().locate_zone(__name);
+}
+
+[[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_HIDE_FROM_ABI inline const time_zone* current_zone() {
+  return get_tzdb().current_zone();
+}
+
+_LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI const tzdb& reload_tzdb();
+
+[[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI string remote_version();
+
+} // namespace chrono
+
+#  endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
+         // && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#endif // _LIBCPP___CHRONO_TZDB_LIST_H
diff --git a/third_party/libcxx/__chrono/weekday.h b/third_party/libcxx/__chrono/weekday.h
index 84b4a3802..86c780cc7 100644
--- a/third_party/libcxx/__chrono/weekday.h
+++ b/third_party/libcxx/__chrono/weekday.h
@@ -24,157 +24,158 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 class weekday_indexed;
 class weekday_last;
 
 class weekday {
 private:
-    unsigned char __wd_;
-    _LIBCPP_HIDE_FROM_ABI static constexpr unsigned char __weekday_from_days(int __days) noexcept;
+  unsigned char __wd_;
+  _LIBCPP_HIDE_FROM_ABI static constexpr unsigned char __weekday_from_days(int __days) noexcept;
+
 public:
   weekday() = default;
-  _LIBCPP_HIDE_FROM_ABI inline explicit constexpr weekday(unsigned __val) noexcept : __wd_(static_cast<unsigned char>(__val == 7 ? 0 : __val)) {}
-  _LIBCPP_HIDE_FROM_ABI inline constexpr          weekday(const sys_days& __sysd) noexcept
-          : __wd_(__weekday_from_days(__sysd.time_since_epoch().count())) {}
+  _LIBCPP_HIDE_FROM_ABI inline explicit constexpr weekday(unsigned __val) noexcept
+      : __wd_(static_cast<unsigned char>(__val == 7 ? 0 : __val)) {}
+  _LIBCPP_HIDE_FROM_ABI inline constexpr weekday(const sys_days& __sysd) noexcept
+      : __wd_(__weekday_from_days(__sysd.time_since_epoch().count())) {}
   _LIBCPP_HIDE_FROM_ABI inline explicit constexpr weekday(const local_days& __locd) noexcept
-          : __wd_(__weekday_from_days(__locd.time_since_epoch().count())) {}
+      : __wd_(__weekday_from_days(__locd.time_since_epoch().count())) {}
 
-  _LIBCPP_HIDE_FROM_ABI inline constexpr weekday& operator++()    noexcept { __wd_ = (__wd_ == 6 ? 0 : __wd_ + 1); return *this; }
-  _LIBCPP_HIDE_FROM_ABI inline constexpr weekday  operator++(int) noexcept { weekday __tmp = *this; ++(*this); return __tmp; }
-  _LIBCPP_HIDE_FROM_ABI inline constexpr weekday& operator--()    noexcept { __wd_ = (__wd_ == 0 ? 6 : __wd_ - 1); return *this; }
-  _LIBCPP_HIDE_FROM_ABI inline constexpr weekday  operator--(int) noexcept { weekday __tmp = *this; --(*this); return __tmp; }
-  _LIBCPP_HIDE_FROM_ABI        constexpr weekday& operator+=(const days& __dd) noexcept;
-  _LIBCPP_HIDE_FROM_ABI        constexpr weekday& operator-=(const days& __dd) noexcept;
-  _LIBCPP_HIDE_FROM_ABI inline constexpr unsigned c_encoding()   const noexcept { return __wd_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr weekday& operator++() noexcept {
+    __wd_ = (__wd_ == 6 ? 0 : __wd_ + 1);
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr weekday operator++(int) noexcept {
+    weekday __tmp = *this;
+    ++(*this);
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr weekday& operator--() noexcept {
+    __wd_ = (__wd_ == 0 ? 6 : __wd_ - 1);
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr weekday operator--(int) noexcept {
+    weekday __tmp = *this;
+    --(*this);
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr weekday& operator+=(const days& __dd) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr weekday& operator-=(const days& __dd) noexcept;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr unsigned c_encoding() const noexcept { return __wd_; }
   _LIBCPP_HIDE_FROM_ABI inline constexpr unsigned iso_encoding() const noexcept { return __wd_ == 0u ? 7 : __wd_; }
   _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __wd_ <= 6; }
-  _LIBCPP_HIDE_FROM_ABI        constexpr weekday_indexed operator[](unsigned __index) const noexcept;
-  _LIBCPP_HIDE_FROM_ABI        constexpr weekday_last    operator[](last_spec) const noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr weekday_indexed operator[](unsigned __index) const noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr weekday_last operator[](last_spec) const noexcept;
 };
 
-
 // https://howardhinnant.github.io/date_algorithms.html#weekday_from_days
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-unsigned char weekday::__weekday_from_days(int __days) noexcept
-{
-    return static_cast<unsigned char>(
-              static_cast<unsigned>(__days >= -4 ? (__days+4) % 7 : (__days+5) % 7 + 6)
-           );
+_LIBCPP_HIDE_FROM_ABI inline constexpr unsigned char weekday::__weekday_from_days(int __days) noexcept {
+  return static_cast<unsigned char>(static_cast<unsigned>(__days >= -4 ? (__days + 4) % 7 : (__days + 5) % 7 + 6));
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const weekday& __lhs, const weekday& __rhs) noexcept
-{ return __lhs.c_encoding() == __rhs.c_encoding(); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const weekday& __lhs, const weekday& __rhs) noexcept
-{ return !(__lhs == __rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator< (const weekday& __lhs, const weekday& __rhs) noexcept
-{ return __lhs.c_encoding() < __rhs.c_encoding(); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator> (const weekday& __lhs, const weekday& __rhs) noexcept
-{ return __rhs < __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator<=(const weekday& __lhs, const weekday& __rhs) noexcept
-{ return !(__rhs < __lhs);}
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator>=(const weekday& __lhs, const weekday& __rhs) noexcept
-{ return !(__lhs < __rhs); }
-
-_LIBCPP_HIDE_FROM_ABI constexpr
-weekday operator+(const weekday& __lhs, const days& __rhs) noexcept
-{
-    auto const __mu = static_cast<long long>(__lhs.c_encoding()) + __rhs.count();
-    auto const __yr = (__mu >= 0 ? __mu : __mu - 6) / 7;
-    return weekday{static_cast<unsigned>(__mu - __yr * 7)};
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator==(const weekday& __lhs, const weekday& __rhs) noexcept {
+  return __lhs.c_encoding() == __rhs.c_encoding();
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-weekday operator+(const days& __lhs, const weekday& __rhs) noexcept
-{ return __rhs + __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI constexpr
-weekday operator-(const weekday& __lhs, const days& __rhs) noexcept
-{ return __lhs + -__rhs; }
-
-_LIBCPP_HIDE_FROM_ABI constexpr
-days operator-(const weekday& __lhs, const weekday& __rhs) noexcept
-{
-    const int __wdu = __lhs.c_encoding() - __rhs.c_encoding();
-    const int __wk = (__wdu >= 0 ? __wdu : __wdu-6) / 7;
-    return days{__wdu - __wk * 7};
+// TODO(LLVM 20): Remove the escape hatch
+#  ifdef _LIBCPP_ENABLE_REMOVED_WEEKDAY_RELATIONAL_OPERATORS
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator<(const weekday& __lhs, const weekday& __rhs) noexcept {
+  return __lhs.c_encoding() < __rhs.c_encoding();
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-weekday& weekday::operator+=(const days& __dd) noexcept
-{ *this = *this + __dd; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator>(const weekday& __lhs, const weekday& __rhs) noexcept {
+  return __rhs < __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-weekday& weekday::operator-=(const days& __dd) noexcept
-{ *this = *this - __dd; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator<=(const weekday& __lhs, const weekday& __rhs) noexcept {
+  return !(__rhs < __lhs);
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator>=(const weekday& __lhs, const weekday& __rhs) noexcept {
+  return !(__lhs < __rhs);
+}
+#  endif // _LIBCPP_ENABLE_REMOVED_WEEKDAY_RELATIONAL_OPERATORS
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr weekday operator+(const weekday& __lhs, const days& __rhs) noexcept {
+  auto const __mu = static_cast<long long>(__lhs.c_encoding()) + __rhs.count();
+  auto const __yr = (__mu >= 0 ? __mu : __mu - 6) / 7;
+  return weekday{static_cast<unsigned>(__mu - __yr * 7)};
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr weekday operator+(const days& __lhs, const weekday& __rhs) noexcept {
+  return __rhs + __lhs;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr weekday operator-(const weekday& __lhs, const days& __rhs) noexcept {
+  return __lhs + -__rhs;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr days operator-(const weekday& __lhs, const weekday& __rhs) noexcept {
+  const int __wdu = __lhs.c_encoding() - __rhs.c_encoding();
+  const int __wk  = (__wdu >= 0 ? __wdu : __wdu - 6) / 7;
+  return days{__wdu - __wk * 7};
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr weekday& weekday::operator+=(const days& __dd) noexcept {
+  *this = *this + __dd;
+  return *this;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr weekday& weekday::operator-=(const days& __dd) noexcept {
+  *this = *this - __dd;
+  return *this;
+}
 
 class weekday_indexed {
 private:
-    chrono::weekday __wd_;
-    unsigned char   __idx_;
+  chrono::weekday __wd_;
+  unsigned char __idx_;
+
 public:
-    weekday_indexed() = default;
-    _LIBCPP_HIDE_FROM_ABI inline constexpr weekday_indexed(const chrono::weekday& __wdval, unsigned __idxval) noexcept
-        : __wd_{__wdval}, __idx_(__idxval) {}
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday weekday() const noexcept { return __wd_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr unsigned                 index() const noexcept { return __idx_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __wd_.ok() && __idx_ >= 1 && __idx_ <= 5; }
+  weekday_indexed() = default;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr weekday_indexed(const chrono::weekday& __wdval, unsigned __idxval) noexcept
+      : __wd_{__wdval}, __idx_(__idxval) {}
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday weekday() const noexcept { return __wd_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr unsigned index() const noexcept { return __idx_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __wd_.ok() && __idx_ >= 1 && __idx_ <= 5; }
 };
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const weekday_indexed& __lhs, const weekday_indexed& __rhs) noexcept
-{ return __lhs.weekday() == __rhs.weekday() && __lhs.index() == __rhs.index(); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const weekday_indexed& __lhs, const weekday_indexed& __rhs) noexcept
-{ return !(__lhs == __rhs); }
-
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool
+operator==(const weekday_indexed& __lhs, const weekday_indexed& __rhs) noexcept {
+  return __lhs.weekday() == __rhs.weekday() && __lhs.index() == __rhs.index();
+}
 
 class weekday_last {
 private:
-    chrono::weekday __wd_;
+  chrono::weekday __wd_;
+
 public:
-    _LIBCPP_HIDE_FROM_ABI explicit constexpr weekday_last(const chrono::weekday& __val) noexcept
-        : __wd_{__val} {}
-    _LIBCPP_HIDE_FROM_ABI constexpr chrono::weekday weekday() const noexcept { return __wd_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr bool ok() const noexcept { return __wd_.ok(); }
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr weekday_last(const chrono::weekday& __val) noexcept : __wd_{__val} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr chrono::weekday weekday() const noexcept { return __wd_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool ok() const noexcept { return __wd_.ok(); }
 };
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const weekday_last& __lhs, const weekday_last& __rhs) noexcept
-{ return __lhs.weekday() == __rhs.weekday(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator==(const weekday_last& __lhs, const weekday_last& __rhs) noexcept {
+  return __lhs.weekday() == __rhs.weekday();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const weekday_last& __lhs, const weekday_last& __rhs) noexcept
-{ return !(__lhs == __rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr weekday_indexed weekday::operator[](unsigned __index) const noexcept {
+  return weekday_indexed{*this, __index};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-weekday_indexed weekday::operator[](unsigned __index) const noexcept { return weekday_indexed{*this, __index}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr weekday_last weekday::operator[](last_spec) const noexcept {
+  return weekday_last{*this};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-weekday_last weekday::operator[](last_spec) const noexcept { return weekday_last{*this}; }
-
-
-inline constexpr weekday   Sunday{0};
-inline constexpr weekday   Monday{1};
-inline constexpr weekday   Tuesday{2};
-inline constexpr weekday   Wednesday{3};
-inline constexpr weekday   Thursday{4};
-inline constexpr weekday   Friday{5};
-inline constexpr weekday   Saturday{6};
+inline constexpr weekday Sunday{0};
+inline constexpr weekday Monday{1};
+inline constexpr weekday Tuesday{2};
+inline constexpr weekday Wednesday{3};
+inline constexpr weekday Thursday{4};
+inline constexpr weekday Friday{5};
+inline constexpr weekday Saturday{6};
 
 } // namespace chrono
 
diff --git a/third_party/libcxx/__chrono/year.h b/third_party/libcxx/__chrono/year.h
index 14bcbdafd..1899d09f3 100644
--- a/third_party/libcxx/__chrono/year.h
+++ b/third_party/libcxx/__chrono/year.h
@@ -26,65 +26,81 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 class year {
 private:
-    short __y_;
+  short __y_;
+
 public:
-    year() = default;
-    _LIBCPP_HIDE_FROM_ABI explicit inline constexpr year(int __val) noexcept : __y_(static_cast<short>(__val)) {}
+  year() = default;
+  _LIBCPP_HIDE_FROM_ABI explicit inline constexpr year(int __val) noexcept : __y_(static_cast<short>(__val)) {}
 
-    _LIBCPP_HIDE_FROM_ABI inline constexpr year& operator++()    noexcept { ++__y_; return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr year  operator++(int) noexcept { year __tmp = *this; ++(*this); return __tmp; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr year& operator--()    noexcept { --__y_; return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr year  operator--(int) noexcept { year __tmp = *this; --(*this); return __tmp; }
-    _LIBCPP_HIDE_FROM_ABI        constexpr year& operator+=(const years& __dy) noexcept;
-    _LIBCPP_HIDE_FROM_ABI        constexpr year& operator-=(const years& __dy) noexcept;
-    _LIBCPP_HIDE_FROM_ABI inline constexpr year operator+() const noexcept { return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr year operator-() const noexcept { return year{-__y_}; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year& operator++() noexcept {
+    ++__y_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year operator++(int) noexcept {
+    year __tmp = *this;
+    ++(*this);
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year& operator--() noexcept {
+    --__y_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year operator--(int) noexcept {
+    year __tmp = *this;
+    --(*this);
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr year& operator+=(const years& __dy) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year& operator-=(const years& __dy) noexcept;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year operator+() const noexcept { return *this; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year operator-() const noexcept { return year{-__y_}; }
 
-    _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_leap() const noexcept { return __y_ % 4 == 0 && (__y_ % 100 != 0 || __y_ % 400 == 0); }
-    _LIBCPP_HIDE_FROM_ABI explicit inline constexpr operator int() const noexcept { return __y_; }
-    _LIBCPP_HIDE_FROM_ABI        constexpr bool ok() const noexcept;
-    _LIBCPP_HIDE_FROM_ABI static inline constexpr year min() noexcept { return year{-32767}; }
-    _LIBCPP_HIDE_FROM_ABI static inline constexpr year max() noexcept { return year{ 32767}; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_leap() const noexcept {
+    return __y_ % 4 == 0 && (__y_ % 100 != 0 || __y_ % 400 == 0);
+  }
+  _LIBCPP_HIDE_FROM_ABI explicit inline constexpr operator int() const noexcept { return __y_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool ok() const noexcept;
+  _LIBCPP_HIDE_FROM_ABI static inline constexpr year min() noexcept { return year{-32767}; }
+  _LIBCPP_HIDE_FROM_ABI static inline constexpr year max() noexcept { return year{32767}; }
 };
 
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const year& __lhs, const year& __rhs) noexcept
-{ return static_cast<int>(__lhs) == static_cast<int>(__rhs); }
-
-_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const year& __lhs, const year& __rhs) noexcept {
-    return static_cast<int>(__lhs) <=> static_cast<int>(__rhs);
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator==(const year& __lhs, const year& __rhs) noexcept {
+  return static_cast<int>(__lhs) == static_cast<int>(__rhs);
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year operator+ (const year& __lhs, const years& __rhs) noexcept
-{ return year(static_cast<int>(__lhs) + __rhs.count()); }
+_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const year& __lhs, const year& __rhs) noexcept {
+  return static_cast<int>(__lhs) <=> static_cast<int>(__rhs);
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year operator+ (const years& __lhs, const year& __rhs) noexcept
-{ return __rhs + __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year operator+(const year& __lhs, const years& __rhs) noexcept {
+  return year(static_cast<int>(__lhs) + __rhs.count());
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year operator- (const year& __lhs, const years& __rhs) noexcept
-{ return __lhs + -__rhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year operator+(const years& __lhs, const year& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-years operator-(const year& __lhs, const year& __rhs) noexcept
-{ return years{static_cast<int>(__lhs) - static_cast<int>(__rhs)}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year operator-(const year& __lhs, const years& __rhs) noexcept {
+  return __lhs + -__rhs;
+}
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr years operator-(const year& __lhs, const year& __rhs) noexcept {
+  return years{static_cast<int>(__lhs) - static_cast<int>(__rhs)};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year& year::operator+=(const years& __dy) noexcept
-{ *this = *this + __dy; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year& year::operator+=(const years& __dy) noexcept {
+  *this = *this + __dy;
+  return *this;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year& year::operator-=(const years& __dy) noexcept
-{ *this = *this - __dy; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year& year::operator-=(const years& __dy) noexcept {
+  *this = *this - __dy;
+  return *this;
+}
 
 _LIBCPP_HIDE_FROM_ABI constexpr bool year::ok() const noexcept {
   static_assert(static_cast<int>(std::numeric_limits<decltype(__y_)>::max()) == static_cast<int>(max()));
diff --git a/third_party/libcxx/__chrono/year_month.h b/third_party/libcxx/__chrono/year_month.h
index f4eea8427..369ea38f7 100644
--- a/third_party/libcxx/__chrono/year_month.h
+++ b/third_party/libcxx/__chrono/year_month.h
@@ -24,73 +24,95 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 class year_month {
-    chrono::year  __y_;
-    chrono::month __m_;
+  chrono::year __y_;
+  chrono::month __m_;
+
 public:
-    year_month() = default;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month(const chrono::year& __yval, const chrono::month& __mval) noexcept
-        : __y_{__yval}, __m_{__mval} {}
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year  year()  const noexcept { return __y_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr year_month& operator+=(const months& __dm) noexcept { this->__m_ += __dm; return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr year_month& operator-=(const months& __dm) noexcept { this->__m_ -= __dm; return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr year_month& operator+=(const years& __dy)  noexcept { this->__y_ += __dy; return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr year_month& operator-=(const years& __dy)  noexcept { this->__y_ -= __dy; return *this; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __y_.ok() && __m_.ok(); }
+  year_month() = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month(const chrono::year& __yval, const chrono::month& __mval) noexcept
+      : __y_{__yval}, __m_{__mval} {}
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year year() const noexcept { return __y_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year_month& operator+=(const months& __dm) noexcept;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year_month& operator-=(const months& __dm) noexcept;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year_month& operator+=(const years& __dy) noexcept;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year_month& operator-=(const years& __dy) noexcept;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __y_.ok() && __m_.ok(); }
 };
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month operator/(const year& __y, const month& __m) noexcept { return year_month{__y, __m}; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month operator/(const year& __y, int __m) noexcept { return year_month{__y, month(__m)}; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const year_month& __lhs, const year_month& __rhs) noexcept
-{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month(); }
-
-_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const year_month& __lhs, const year_month& __rhs) noexcept {
-    if (auto __c = __lhs.year() <=> __rhs.year(); __c != 0)
-      return __c;
-    return __lhs.month() <=> __rhs.month();
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month operator/(const year& __y, const month& __m) noexcept {
+  return year_month{__y, __m};
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-year_month operator+(const year_month& __lhs, const months& __rhs) noexcept
-{
-    int __dmi = static_cast<int>(static_cast<unsigned>(__lhs.month())) - 1 + __rhs.count();
-    const int __dy = (__dmi >= 0 ? __dmi : __dmi-11) / 12;
-    __dmi = __dmi - __dy * 12 + 1;
-    return (__lhs.year() + years(__dy)) / month(static_cast<unsigned>(__dmi));
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month operator/(const year& __y, int __m) noexcept {
+  return year_month{__y, month(__m)};
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-year_month operator+(const months& __lhs, const year_month& __rhs) noexcept
-{ return __rhs + __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator==(const year_month& __lhs, const year_month& __rhs) noexcept {
+  return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month();
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-year_month operator+(const year_month& __lhs, const years& __rhs) noexcept
-{ return (__lhs.year() + __rhs) / __lhs.month(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr strong_ordering
+operator<=>(const year_month& __lhs, const year_month& __rhs) noexcept {
+  if (auto __c = __lhs.year() <=> __rhs.year(); __c != 0)
+    return __c;
+  return __lhs.month() <=> __rhs.month();
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-year_month operator+(const years& __lhs, const year_month& __rhs) noexcept
-{ return __rhs + __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month operator+(const year_month& __lhs, const months& __rhs) noexcept {
+  int __dmi      = static_cast<int>(static_cast<unsigned>(__lhs.month())) - 1 + __rhs.count();
+  const int __dy = (__dmi >= 0 ? __dmi : __dmi - 11) / 12;
+  __dmi          = __dmi - __dy * 12 + 1;
+  return (__lhs.year() + years(__dy)) / month(static_cast<unsigned>(__dmi));
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-months operator-(const year_month& __lhs, const year_month& __rhs) noexcept
-{ return (__lhs.year() - __rhs.year()) + months(static_cast<unsigned>(__lhs.month()) - static_cast<unsigned>(__rhs.month())); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month operator+(const months& __lhs, const year_month& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-year_month operator-(const year_month& __lhs, const months& __rhs) noexcept
-{ return __lhs + -__rhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month operator+(const year_month& __lhs, const years& __rhs) noexcept {
+  return (__lhs.year() + __rhs) / __lhs.month();
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr
-year_month operator-(const year_month& __lhs, const years& __rhs) noexcept
-{ return __lhs + -__rhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month operator+(const years& __lhs, const year_month& __rhs) noexcept {
+  return __rhs + __lhs;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr months operator-(const year_month& __lhs, const year_month& __rhs) noexcept {
+  return (__lhs.year() - __rhs.year()) +
+         months(static_cast<unsigned>(__lhs.month()) - static_cast<unsigned>(__rhs.month()));
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month operator-(const year_month& __lhs, const months& __rhs) noexcept {
+  return __lhs + -__rhs;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month operator-(const year_month& __lhs, const years& __rhs) noexcept {
+  return __lhs + -__rhs;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month& year_month::operator+=(const months& __dm) noexcept {
+  *this = *this + __dm;
+  return *this;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month& year_month::operator-=(const months& __dm) noexcept {
+  *this = *this - __dm;
+  return *this;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month& year_month::operator+=(const years& __dy) noexcept {
+  *this = *this + __dy;
+  return *this;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month& year_month::operator-=(const years& __dy) noexcept {
+  *this = *this - __dy;
+  return *this;
+}
 
 } // namespace chrono
 
diff --git a/third_party/libcxx/__chrono/year_month_day.h b/third_party/libcxx/__chrono/year_month_day.h
index ed5903f7d..b06c0be03 100644
--- a/third_party/libcxx/__chrono/year_month_day.h
+++ b/third_party/libcxx/__chrono/year_month_day.h
@@ -31,271 +31,301 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 class year_month_day_last;
 
 class year_month_day {
 private:
-    chrono::year  __y_;
-    chrono::month __m_;
-    chrono::day   __d_;
+  chrono::year __y_;
+  chrono::month __m_;
+  chrono::day __d_;
+
 public:
-     year_month_day() = default;
-     _LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day(
-            const chrono::year& __yval, const chrono::month& __mval, const chrono::day& __dval) noexcept
-            : __y_{__yval}, __m_{__mval}, __d_{__dval} {}
-     _LIBCPP_HIDE_FROM_ABI        constexpr year_month_day(const year_month_day_last& __ymdl) noexcept;
-     _LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day(const sys_days& __sysd) noexcept
-            : year_month_day(__from_days(__sysd.time_since_epoch())) {}
-     _LIBCPP_HIDE_FROM_ABI inline explicit constexpr year_month_day(const local_days& __locd) noexcept
-            : year_month_day(__from_days(__locd.time_since_epoch())) {}
+  year_month_day() = default;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day(
+      const chrono::year& __yval, const chrono::month& __mval, const chrono::day& __dval) noexcept
+      : __y_{__yval}, __m_{__mval}, __d_{__dval} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_day(const year_month_day_last& __ymdl) noexcept;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day(const sys_days& __sysd) noexcept
+      : year_month_day(__from_days(__sysd.time_since_epoch())) {}
+  _LIBCPP_HIDE_FROM_ABI inline explicit constexpr year_month_day(const local_days& __locd) noexcept
+      : year_month_day(__from_days(__locd.time_since_epoch())) {}
 
-     _LIBCPP_HIDE_FROM_ABI        constexpr year_month_day& operator+=(const months& __dm) noexcept;
-     _LIBCPP_HIDE_FROM_ABI        constexpr year_month_day& operator-=(const months& __dm) noexcept;
-     _LIBCPP_HIDE_FROM_ABI        constexpr year_month_day& operator+=(const years& __dy)  noexcept;
-     _LIBCPP_HIDE_FROM_ABI        constexpr year_month_day& operator-=(const years& __dy)  noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_day& operator+=(const months& __dm) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_day& operator-=(const months& __dm) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_day& operator+=(const years& __dy) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_day& operator-=(const years& __dy) noexcept;
 
-     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year   year() const noexcept { return __y_; }
-     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
-     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::day     day() const noexcept { return __d_; }
-     _LIBCPP_HIDE_FROM_ABI inline constexpr operator   sys_days() const noexcept          { return   sys_days{__to_days()}; }
-     _LIBCPP_HIDE_FROM_ABI inline explicit constexpr operator local_days() const noexcept { return local_days{__to_days()}; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year year() const noexcept { return __y_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::day day() const noexcept { return __d_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr operator sys_days() const noexcept { return sys_days{__to_days()}; }
+  _LIBCPP_HIDE_FROM_ABI inline explicit constexpr operator local_days() const noexcept {
+    return local_days{__to_days()};
+  }
 
-     _LIBCPP_HIDE_FROM_ABI        constexpr bool             ok() const noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr bool ok() const noexcept;
 
-     _LIBCPP_HIDE_FROM_ABI static constexpr year_month_day __from_days(days __d) noexcept;
-     _LIBCPP_HIDE_FROM_ABI constexpr days __to_days() const noexcept;
+  _LIBCPP_HIDE_FROM_ABI static constexpr year_month_day __from_days(days __d) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr days __to_days() const noexcept;
 };
 
-
 // https://howardhinnant.github.io/date_algorithms.html#civil_from_days
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day year_month_day::__from_days(days __d) noexcept
-{
-    static_assert(numeric_limits<unsigned>::digits >= 18, "");
-    static_assert(numeric_limits<int>::digits >= 20     , "");
-    const int      __z = __d.count() + 719468;
-    const int      __era = (__z >= 0 ? __z : __z - 146096) / 146097;
-    const unsigned __doe = static_cast<unsigned>(__z - __era * 146097);              // [0, 146096]
-    const unsigned __yoe = (__doe - __doe/1460 + __doe/36524 - __doe/146096) / 365;  // [0, 399]
-    const int      __yr = static_cast<int>(__yoe) + __era * 400;
-    const unsigned __doy = __doe - (365 * __yoe + __yoe/4 - __yoe/100);              // [0, 365]
-    const unsigned __mp = (5 * __doy + 2)/153;                                       // [0, 11]
-    const unsigned __dy = __doy - (153 * __mp + 2)/5 + 1;                            // [1, 31]
-    const unsigned __mth = __mp + (__mp < 10 ? 3 : -9);                              // [1, 12]
-    return year_month_day{chrono::year{__yr + (__mth <= 2)}, chrono::month{__mth}, chrono::day{__dy}};
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day year_month_day::__from_days(days __d) noexcept {
+  static_assert(numeric_limits<unsigned>::digits >= 18, "");
+  static_assert(numeric_limits<int>::digits >= 20, "");
+  const int __z        = __d.count() + 719468;
+  const int __era      = (__z >= 0 ? __z : __z - 146096) / 146097;
+  const unsigned __doe = static_cast<unsigned>(__z - __era * 146097);                   // [0, 146096]
+  const unsigned __yoe = (__doe - __doe / 1460 + __doe / 36524 - __doe / 146096) / 365; // [0, 399]
+  const int __yr       = static_cast<int>(__yoe) + __era * 400;
+  const unsigned __doy = __doe - (365 * __yoe + __yoe / 4 - __yoe / 100); // [0, 365]
+  const unsigned __mp  = (5 * __doy + 2) / 153;                           // [0, 11]
+  const unsigned __dy  = __doy - (153 * __mp + 2) / 5 + 1;                // [1, 31]
+  const unsigned __mth = __mp + (__mp < 10 ? 3 : -9);                     // [1, 12]
+  return year_month_day{chrono::year{__yr + (__mth <= 2)}, chrono::month{__mth}, chrono::day{__dy}};
 }
 
 // https://howardhinnant.github.io/date_algorithms.html#days_from_civil
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-days year_month_day::__to_days() const noexcept
-{
-    static_assert(numeric_limits<unsigned>::digits >= 18, "");
-    static_assert(numeric_limits<int>::digits >= 20     , "");
+_LIBCPP_HIDE_FROM_ABI inline constexpr days year_month_day::__to_days() const noexcept {
+  static_assert(numeric_limits<unsigned>::digits >= 18, "");
+  static_assert(numeric_limits<int>::digits >= 20, "");
 
-    const int      __yr  = static_cast<int>(__y_) - (__m_ <= February);
-    const unsigned __mth = static_cast<unsigned>(__m_);
-    const unsigned __dy  = static_cast<unsigned>(__d_);
+  const int __yr       = static_cast<int>(__y_) - (__m_ <= February);
+  const unsigned __mth = static_cast<unsigned>(__m_);
+  const unsigned __dy  = static_cast<unsigned>(__d_);
 
-    const int      __era = (__yr >= 0 ? __yr : __yr - 399) / 400;
-    const unsigned __yoe = static_cast<unsigned>(__yr - __era * 400);                // [0, 399]
-    const unsigned __doy = (153 * (__mth + (__mth > 2 ? -3 : 9)) + 2) / 5 + __dy-1;  // [0, 365]
-    const unsigned __doe = __yoe * 365 + __yoe/4 - __yoe/100 + __doy;                // [0, 146096]
-    return days{__era * 146097 + static_cast<int>(__doe) - 719468};
+  const int __era      = (__yr >= 0 ? __yr : __yr - 399) / 400;
+  const unsigned __yoe = static_cast<unsigned>(__yr - __era * 400);                 // [0, 399]
+  const unsigned __doy = (153 * (__mth + (__mth > 2 ? -3 : 9)) + 2) / 5 + __dy - 1; // [0, 365]
+  const unsigned __doe = __yoe * 365 + __yoe / 4 - __yoe / 100 + __doy;             // [0, 146096]
+  return days{__era * 146097 + static_cast<int>(__doe) - 719468};
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const year_month_day& __lhs, const year_month_day& __rhs) noexcept
-{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool
+operator==(const year_month_day& __lhs, const year_month_day& __rhs) noexcept {
+  return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day();
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering
+_LIBCPP_HIDE_FROM_ABI inline constexpr strong_ordering
 operator<=>(const year_month_day& __lhs, const year_month_day& __rhs) noexcept {
-    if (auto __c = __lhs.year() <=> __rhs.year(); __c != 0)
-      return __c;
-    if (auto __c = __lhs.month() <=> __rhs.month(); __c != 0)
-      return __c;
-    return __lhs.day() <=> __rhs.day();
+  if (auto __c = __lhs.year() <=> __rhs.year(); __c != 0)
+    return __c;
+  if (auto __c = __lhs.month() <=> __rhs.month(); __c != 0)
+    return __c;
+  return __lhs.day() <=> __rhs.day();
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator/(const year_month& __lhs, const day& __rhs) noexcept
-{ return year_month_day{__lhs.year(), __lhs.month(), __rhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day operator/(const year_month& __lhs, const day& __rhs) noexcept {
+  return year_month_day{__lhs.year(), __lhs.month(), __rhs};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator/(const year_month& __lhs, int __rhs) noexcept
-{ return __lhs / day(__rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day operator/(const year_month& __lhs, int __rhs) noexcept {
+  return __lhs / day(__rhs);
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator/(const year& __lhs, const month_day& __rhs) noexcept
-{ return __lhs / __rhs.month() / __rhs.day(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day operator/(const year& __lhs, const month_day& __rhs) noexcept {
+  return __lhs / __rhs.month() / __rhs.day();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator/(int __lhs, const month_day& __rhs) noexcept
-{ return year(__lhs) / __rhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day operator/(int __lhs, const month_day& __rhs) noexcept {
+  return year(__lhs) / __rhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator/(const month_day& __lhs, const year& __rhs) noexcept
-{ return __rhs / __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day operator/(const month_day& __lhs, const year& __rhs) noexcept {
+  return __rhs / __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator/(const month_day& __lhs, int __rhs) noexcept
-{ return year(__rhs) / __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day operator/(const month_day& __lhs, int __rhs) noexcept {
+  return year(__rhs) / __lhs;
+}
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day
+operator+(const year_month_day& __lhs, const months& __rhs) noexcept {
+  return (__lhs.year() / __lhs.month() + __rhs) / __lhs.day();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator+(const year_month_day& __lhs, const months& __rhs) noexcept
-{ return (__lhs.year()/__lhs.month() + __rhs)/__lhs.day(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day
+operator+(const months& __lhs, const year_month_day& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator+(const months& __lhs, const year_month_day& __rhs) noexcept
-{ return __rhs + __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day
+operator-(const year_month_day& __lhs, const months& __rhs) noexcept {
+  return __lhs + -__rhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator-(const year_month_day& __lhs, const months& __rhs) noexcept
-{ return __lhs + -__rhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day
+operator+(const year_month_day& __lhs, const years& __rhs) noexcept {
+  return (__lhs.year() + __rhs) / __lhs.month() / __lhs.day();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator+(const year_month_day& __lhs, const years& __rhs) noexcept
-{ return (__lhs.year() + __rhs) / __lhs.month() / __lhs.day(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day
+operator+(const years& __lhs, const year_month_day& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator+(const years& __lhs, const year_month_day& __rhs) noexcept
-{ return __rhs + __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day
+operator-(const year_month_day& __lhs, const years& __rhs) noexcept {
+  return __lhs + -__rhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day operator-(const year_month_day& __lhs, const years& __rhs) noexcept
-{ return __lhs + -__rhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day& year_month_day::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day& year_month_day::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day& year_month_day::operator+=(const years& __dy)  noexcept { *this = *this + __dy; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day& year_month_day::operator-=(const years& __dy)  noexcept { *this = *this - __dy; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day& year_month_day::operator+=(const months& __dm) noexcept {
+  *this = *this + __dm;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day& year_month_day::operator-=(const months& __dm) noexcept {
+  *this = *this - __dm;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day& year_month_day::operator+=(const years& __dy) noexcept {
+  *this = *this + __dy;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day& year_month_day::operator-=(const years& __dy) noexcept {
+  *this = *this - __dy;
+  return *this;
+}
 
 class year_month_day_last {
 private:
-    chrono::year           __y_;
-    chrono::month_day_last __mdl_;
+  chrono::year __y_;
+  chrono::month_day_last __mdl_;
+
 public:
-     _LIBCPP_HIDE_FROM_ABI constexpr year_month_day_last(const year& __yval, const month_day_last& __mdlval) noexcept
-        : __y_{__yval}, __mdl_{__mdlval} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_day_last(const year& __yval, const month_day_last& __mdlval) noexcept
+      : __y_{__yval}, __mdl_{__mdlval} {}
 
-     _LIBCPP_HIDE_FROM_ABI constexpr year_month_day_last& operator+=(const months& __m) noexcept;
-     _LIBCPP_HIDE_FROM_ABI constexpr year_month_day_last& operator-=(const months& __m) noexcept;
-     _LIBCPP_HIDE_FROM_ABI constexpr year_month_day_last& operator+=(const years& __y)  noexcept;
-     _LIBCPP_HIDE_FROM_ABI constexpr year_month_day_last& operator-=(const years& __y)  noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_day_last& operator+=(const months& __m) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_day_last& operator-=(const months& __m) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_day_last& operator+=(const years& __y) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_day_last& operator-=(const years& __y) noexcept;
 
-     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year                     year() const noexcept { return __y_; }
-     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month                   month() const noexcept { return __mdl_.month(); }
-     _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month_day_last month_day_last() const noexcept { return __mdl_; }
-     _LIBCPP_HIDE_FROM_ABI        constexpr chrono::day                       day() const noexcept;
-     _LIBCPP_HIDE_FROM_ABI inline constexpr operator                     sys_days() const noexcept { return   sys_days{year()/month()/day()}; }
-     _LIBCPP_HIDE_FROM_ABI inline explicit constexpr operator          local_days() const noexcept { return local_days{year()/month()/day()}; }
-     _LIBCPP_HIDE_FROM_ABI inline constexpr bool                               ok() const noexcept { return __y_.ok() && __mdl_.ok(); }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year year() const noexcept { return __y_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __mdl_.month(); }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month_day_last month_day_last() const noexcept { return __mdl_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr chrono::day day() const noexcept;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr operator sys_days() const noexcept {
+    return sys_days{year() / month() / day()};
+  }
+  _LIBCPP_HIDE_FROM_ABI inline explicit constexpr operator local_days() const noexcept {
+    return local_days{year() / month() / day()};
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __y_.ok() && __mdl_.ok(); }
 };
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-chrono::day year_month_day_last::day() const noexcept
-{
-    constexpr chrono::day __d[] =
-    {
-        chrono::day(31), chrono::day(28), chrono::day(31),
-        chrono::day(30), chrono::day(31), chrono::day(30),
-        chrono::day(31), chrono::day(31), chrono::day(30),
-        chrono::day(31), chrono::day(30), chrono::day(31)
-    };
-    return (month() != February || !__y_.is_leap()) && month().ok() ?
-        __d[static_cast<unsigned>(month()) - 1] : chrono::day{29};
+_LIBCPP_HIDE_FROM_ABI inline constexpr chrono::day year_month_day_last::day() const noexcept {
+  constexpr chrono::day __d[] = {
+      chrono::day(31),
+      chrono::day(28),
+      chrono::day(31),
+      chrono::day(30),
+      chrono::day(31),
+      chrono::day(30),
+      chrono::day(31),
+      chrono::day(31),
+      chrono::day(30),
+      chrono::day(31),
+      chrono::day(30),
+      chrono::day(31)};
+  return (month() != February || !__y_.is_leap()) && month().ok()
+           ? __d[static_cast<unsigned>(month()) - 1]
+           : chrono::day{29};
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
-{ return __lhs.year() == __rhs.year() && __lhs.month_day_last() == __rhs.month_day_last(); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
-{ return !(__lhs == __rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator< (const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
-{
-    if (__lhs.year() < __rhs.year()) return true;
-    if (__lhs.year() > __rhs.year()) return false;
-    return __lhs.month_day_last() < __rhs.month_day_last();
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool
+operator==(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept {
+  return __lhs.year() == __rhs.year() && __lhs.month_day_last() == __rhs.month_day_last();
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator> (const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
-{ return __rhs < __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr strong_ordering
+operator<=>(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept {
+  if (auto __c = __lhs.year() <=> __rhs.year(); __c != 0)
+    return __c;
+  return __lhs.month_day_last() <=> __rhs.month_day_last();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator<=(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
-{ return !(__rhs < __lhs);}
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator>=(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
-{ return !(__lhs < __rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day_last operator/(const year_month& __lhs, last_spec) noexcept
-{ return year_month_day_last{__lhs.year(), month_day_last{__lhs.month()}}; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day_last operator/(const year& __lhs, const month_day_last& __rhs) noexcept
-{ return year_month_day_last{__lhs, __rhs}; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day_last operator/(int __lhs, const month_day_last& __rhs) noexcept
-{ return year_month_day_last{year{__lhs}, __rhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last operator/(const year_month& __lhs, last_spec) noexcept {
+  return year_month_day_last{__lhs.year(), month_day_last{__lhs.month()}};
+}
 
 _LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last
-operator/(const month_day_last& __lhs, const year& __rhs) noexcept
-{ return __rhs / __lhs; }
+operator/(const year& __lhs, const month_day_last& __rhs) noexcept {
+  return year_month_day_last{__lhs, __rhs};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day_last operator/(const month_day_last& __lhs, int __rhs) noexcept
-{ return year{__rhs} / __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last operator/(int __lhs, const month_day_last& __rhs) noexcept {
+  return year_month_day_last{year{__lhs}, __rhs};
+}
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last
+operator/(const month_day_last& __lhs, const year& __rhs) noexcept {
+  return __rhs / __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day_last operator+(const year_month_day_last& __lhs, const months& __rhs) noexcept
-{ return (__lhs.year() / __lhs.month() + __rhs) / last; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last operator/(const month_day_last& __lhs, int __rhs) noexcept {
+  return year{__rhs} / __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day_last operator+(const months& __lhs, const year_month_day_last& __rhs) noexcept
-{ return __rhs + __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last
+operator+(const year_month_day_last& __lhs, const months& __rhs) noexcept {
+  return (__lhs.year() / __lhs.month() + __rhs) / last;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day_last operator-(const year_month_day_last& __lhs, const months& __rhs) noexcept
-{ return __lhs + (-__rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last
+operator+(const months& __lhs, const year_month_day_last& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day_last operator+(const year_month_day_last& __lhs, const years& __rhs) noexcept
-{ return year_month_day_last{__lhs.year() + __rhs, __lhs.month_day_last()}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last
+operator-(const year_month_day_last& __lhs, const months& __rhs) noexcept {
+  return __lhs + (-__rhs);
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day_last operator+(const years& __lhs, const year_month_day_last& __rhs) noexcept
-{ return __rhs + __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last
+operator+(const year_month_day_last& __lhs, const years& __rhs) noexcept {
+  return year_month_day_last{__lhs.year() + __rhs, __lhs.month_day_last()};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day_last operator-(const year_month_day_last& __lhs, const years& __rhs) noexcept
-{ return __lhs + (-__rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last
+operator+(const years& __lhs, const year_month_day_last& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last& year_month_day_last::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last& year_month_day_last::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last& year_month_day_last::operator+=(const years& __dy)  noexcept { *this = *this + __dy; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last& year_month_day_last::operator-=(const years& __dy)  noexcept { *this = *this - __dy; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last
+operator-(const year_month_day_last& __lhs, const years& __rhs) noexcept {
+  return __lhs + (-__rhs);
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_day::year_month_day(const year_month_day_last& __ymdl) noexcept
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last&
+year_month_day_last::operator+=(const months& __dm) noexcept {
+  *this = *this + __dm;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last&
+year_month_day_last::operator-=(const months& __dm) noexcept {
+  *this = *this - __dm;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last&
+year_month_day_last::operator+=(const years& __dy) noexcept {
+  *this = *this + __dy;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day_last&
+year_month_day_last::operator-=(const years& __dy) noexcept {
+  *this = *this - __dy;
+  return *this;
+}
+
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_day::year_month_day(const year_month_day_last& __ymdl) noexcept
     : __y_{__ymdl.year()}, __m_{__ymdl.month()}, __d_{__ymdl.day()} {}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool year_month_day::ok() const noexcept
-{
-    if (!__y_.ok() || !__m_.ok()) return false;
-    return chrono::day{1} <= __d_ && __d_ <= (__y_ / __m_ / last).day();
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool year_month_day::ok() const noexcept {
+  if (!__y_.ok() || !__m_.ok())
+    return false;
+  return chrono::day{1} <= __d_ && __d_ <= (__y_ / __m_ / last).day();
 }
 
 } // namespace chrono
diff --git a/third_party/libcxx/__chrono/year_month_weekday.h b/third_party/libcxx/__chrono/year_month_weekday.h
index 28de10c94..0c3dd494c 100644
--- a/third_party/libcxx/__chrono/year_month_weekday.h
+++ b/third_party/libcxx/__chrono/year_month_weekday.h
@@ -31,220 +31,252 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace chrono
-{
+namespace chrono {
 
 class year_month_weekday {
-    chrono::year            __y_;
-    chrono::month           __m_;
-    chrono::weekday_indexed __wdi_;
+  chrono::year __y_;
+  chrono::month __m_;
+  chrono::weekday_indexed __wdi_;
+
 public:
-    year_month_weekday() = default;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday(const chrono::year& __yval, const chrono::month& __mval,
-                               const chrono::weekday_indexed& __wdival) noexcept
-        : __y_{__yval}, __m_{__mval}, __wdi_{__wdival} {}
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday(const sys_days& __sysd) noexcept
-            : year_month_weekday(__from_days(__sysd.time_since_epoch())) {}
-    _LIBCPP_HIDE_FROM_ABI inline explicit constexpr year_month_weekday(const local_days& __locd) noexcept
-            : year_month_weekday(__from_days(__locd.time_since_epoch())) {}
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const months&) noexcept;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const months&) noexcept;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const years&)  noexcept;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const years&)  noexcept;
+  year_month_weekday() = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday(
+      const chrono::year& __yval, const chrono::month& __mval, const chrono::weekday_indexed& __wdival) noexcept
+      : __y_{__yval}, __m_{__mval}, __wdi_{__wdival} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday(const sys_days& __sysd) noexcept
+      : year_month_weekday(__from_days(__sysd.time_since_epoch())) {}
+  _LIBCPP_HIDE_FROM_ABI inline explicit constexpr year_month_weekday(const local_days& __locd) noexcept
+      : year_month_weekday(__from_days(__locd.time_since_epoch())) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const months&) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const months&) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const years&) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const years&) noexcept;
 
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year                       year() const noexcept { return __y_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month                     month() const noexcept { return __m_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday                 weekday() const noexcept { return __wdi_.weekday(); }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr unsigned                          index() const noexcept { return __wdi_.index(); }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year year() const noexcept { return __y_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday weekday() const noexcept { return __wdi_.weekday(); }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr unsigned index() const noexcept { return __wdi_.index(); }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi_; }
 
-    _LIBCPP_HIDE_FROM_ABI inline constexpr                       operator sys_days() const noexcept { return   sys_days{__to_days()}; }
-    _LIBCPP_HIDE_FROM_ABI inline explicit constexpr operator            local_days() const noexcept { return local_days{__to_days()}; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept
-    {
-        if (!__y_.ok() || !__m_.ok() || !__wdi_.ok()) return false;
-        if (__wdi_.index() <= 4) return true;
-        auto __nth_weekday_day =
-            __wdi_.weekday() -
-            chrono::weekday{static_cast<sys_days>(__y_ / __m_ / 1)} +
-            days{(__wdi_.index() - 1) * 7 + 1};
-        return static_cast<unsigned>(__nth_weekday_day.count()) <=
-               static_cast<unsigned>((__y_ / __m_ / last).day());
-    }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr operator sys_days() const noexcept { return sys_days{__to_days()}; }
+  _LIBCPP_HIDE_FROM_ABI inline explicit constexpr operator local_days() const noexcept {
+    return local_days{__to_days()};
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept {
+    if (!__y_.ok() || !__m_.ok() || !__wdi_.ok())
+      return false;
+    if (__wdi_.index() <= 4)
+      return true;
+    auto __nth_weekday_day =
+        __wdi_.weekday() - chrono::weekday{static_cast<sys_days>(__y_ / __m_ / 1)} + days{(__wdi_.index() - 1) * 7 + 1};
+    return static_cast<unsigned>(__nth_weekday_day.count()) <= static_cast<unsigned>((__y_ / __m_ / last).day());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI static constexpr year_month_weekday __from_days(days __d) noexcept;
-    _LIBCPP_HIDE_FROM_ABI constexpr days __to_days() const noexcept;
+  _LIBCPP_HIDE_FROM_ABI static constexpr year_month_weekday __from_days(days __d) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr days __to_days() const noexcept;
 };
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday year_month_weekday::__from_days(days __d) noexcept
-{
-    const sys_days      __sysd{__d};
-    const chrono::weekday __wd = chrono::weekday(__sysd);
-    const year_month_day __ymd = year_month_day(__sysd);
-    return year_month_weekday{__ymd.year(), __ymd.month(),
-                              __wd[(static_cast<unsigned>(__ymd.day())-1)/7+1]};
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday year_month_weekday::__from_days(days __d) noexcept {
+  const sys_days __sysd{__d};
+  const chrono::weekday __wd = chrono::weekday(__sysd);
+  const year_month_day __ymd = year_month_day(__sysd);
+  return year_month_weekday{__ymd.year(), __ymd.month(), __wd[(static_cast<unsigned>(__ymd.day()) - 1) / 7 + 1]};
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-days year_month_weekday::__to_days() const noexcept
-{
-    const sys_days __sysd = sys_days(__y_/__m_/1);
-    return (__sysd + (__wdi_.weekday() - chrono::weekday(__sysd) + days{(__wdi_.index()-1)*7}))
-                .time_since_epoch();
+_LIBCPP_HIDE_FROM_ABI inline constexpr days year_month_weekday::__to_days() const noexcept {
+  const sys_days __sysd = sys_days(__y_ / __m_ / 1);
+  return (__sysd + (__wdi_.weekday() - chrono::weekday(__sysd) + days{(__wdi_.index() - 1) * 7})).time_since_epoch();
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const year_month_weekday& __lhs, const year_month_weekday& __rhs) noexcept
-{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.weekday_indexed() == __rhs.weekday_indexed(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool
+operator==(const year_month_weekday& __lhs, const year_month_weekday& __rhs) noexcept {
+  return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() &&
+         __lhs.weekday_indexed() == __rhs.weekday_indexed();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const year_month_weekday& __lhs, const year_month_weekday& __rhs) noexcept
-{ return !(__lhs == __rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday
+operator/(const year_month& __lhs, const weekday_indexed& __rhs) noexcept {
+  return year_month_weekday{__lhs.year(), __lhs.month(), __rhs};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator/(const year_month& __lhs, const weekday_indexed& __rhs) noexcept
-{ return year_month_weekday{__lhs.year(), __lhs.month(), __rhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday
+operator/(const year& __lhs, const month_weekday& __rhs) noexcept {
+  return year_month_weekday{__lhs, __rhs.month(), __rhs.weekday_indexed()};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator/(const year& __lhs, const month_weekday& __rhs) noexcept
-{ return year_month_weekday{__lhs, __rhs.month(), __rhs.weekday_indexed()}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday operator/(int __lhs, const month_weekday& __rhs) noexcept {
+  return year(__lhs) / __rhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator/(int __lhs, const month_weekday& __rhs) noexcept
-{ return year(__lhs) / __rhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday
+operator/(const month_weekday& __lhs, const year& __rhs) noexcept {
+  return __rhs / __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator/(const month_weekday& __lhs, const year& __rhs) noexcept
-{ return __rhs / __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday operator/(const month_weekday& __lhs, int __rhs) noexcept {
+  return year(__rhs) / __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator/(const month_weekday& __lhs, int __rhs) noexcept
-{ return year(__rhs) / __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday
+operator+(const year_month_weekday& __lhs, const months& __rhs) noexcept {
+  return (__lhs.year() / __lhs.month() + __rhs) / __lhs.weekday_indexed();
+}
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday
+operator+(const months& __lhs, const year_month_weekday& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator+(const year_month_weekday& __lhs, const months& __rhs) noexcept
-{ return (__lhs.year() / __lhs.month() + __rhs) / __lhs.weekday_indexed(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday
+operator-(const year_month_weekday& __lhs, const months& __rhs) noexcept {
+  return __lhs + (-__rhs);
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator+(const months& __lhs, const year_month_weekday& __rhs) noexcept
-{ return __rhs + __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday
+operator+(const year_month_weekday& __lhs, const years& __rhs) noexcept {
+  return year_month_weekday{__lhs.year() + __rhs, __lhs.month(), __lhs.weekday_indexed()};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator-(const year_month_weekday& __lhs, const months& __rhs) noexcept
-{ return __lhs + (-__rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday
+operator+(const years& __lhs, const year_month_weekday& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator+(const year_month_weekday& __lhs, const years& __rhs) noexcept
-{ return year_month_weekday{__lhs.year() + __rhs, __lhs.month(), __lhs.weekday_indexed()}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday
+operator-(const year_month_weekday& __lhs, const years& __rhs) noexcept {
+  return __lhs + (-__rhs);
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator+(const years& __lhs, const year_month_weekday& __rhs) noexcept
-{ return __rhs + __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday operator-(const year_month_weekday& __lhs, const years& __rhs) noexcept
-{ return __lhs + (-__rhs); }
-
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday& year_month_weekday::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday& year_month_weekday::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday& year_month_weekday::operator+=(const years& __dy)  noexcept { *this = *this + __dy; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday& year_month_weekday::operator-=(const years& __dy)  noexcept { *this = *this - __dy; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday& year_month_weekday::operator+=(const months& __dm) noexcept {
+  *this = *this + __dm;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday& year_month_weekday::operator-=(const months& __dm) noexcept {
+  *this = *this - __dm;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday& year_month_weekday::operator+=(const years& __dy) noexcept {
+  *this = *this + __dy;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday& year_month_weekday::operator-=(const years& __dy) noexcept {
+  *this = *this - __dy;
+  return *this;
+}
 
 class year_month_weekday_last {
 private:
-    chrono::year         __y_;
-    chrono::month        __m_;
-    chrono::weekday_last __wdl_;
+  chrono::year __y_;
+  chrono::month __m_;
+  chrono::weekday_last __wdl_;
+
 public:
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday_last(const chrono::year& __yval, const chrono::month& __mval,
-                                      const chrono::weekday_last& __wdlval) noexcept
-                : __y_{__yval}, __m_{__mval}, __wdl_{__wdlval} {}
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday_last& operator+=(const months& __dm) noexcept;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday_last& operator-=(const months& __dm) noexcept;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday_last& operator+=(const years& __dy)  noexcept;
-    _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday_last& operator-=(const years& __dy)  noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday_last(
+      const chrono::year& __yval, const chrono::month& __mval, const chrono::weekday_last& __wdlval) noexcept
+      : __y_{__yval}, __m_{__mval}, __wdl_{__wdlval} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday_last& operator+=(const months& __dm) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday_last& operator-=(const months& __dm) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday_last& operator+=(const years& __dy) noexcept;
+  _LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday_last& operator-=(const years& __dy) noexcept;
 
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year                 year() const noexcept { return __y_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month               month() const noexcept { return __m_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday           weekday() const noexcept { return __wdl_.weekday(); }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday_last weekday_last() const noexcept { return __wdl_; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr operator                 sys_days() const noexcept { return   sys_days{__to_days()}; }
-    _LIBCPP_HIDE_FROM_ABI inline explicit constexpr operator      local_days() const noexcept { return local_days{__to_days()}; }
-    _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __y_.ok() && __m_.ok() && __wdl_.ok(); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr days __to_days() const noexcept;
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year year() const noexcept { return __y_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday weekday() const noexcept { return __wdl_.weekday(); }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr chrono::weekday_last weekday_last() const noexcept { return __wdl_; }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr operator sys_days() const noexcept { return sys_days{__to_days()}; }
+  _LIBCPP_HIDE_FROM_ABI inline explicit constexpr operator local_days() const noexcept {
+    return local_days{__to_days()};
+  }
+  _LIBCPP_HIDE_FROM_ABI inline constexpr bool ok() const noexcept { return __y_.ok() && __m_.ok() && __wdl_.ok(); }
 
+  _LIBCPP_HIDE_FROM_ABI constexpr days __to_days() const noexcept;
 };
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-days year_month_weekday_last::__to_days() const noexcept
-{
-    const sys_days __last = sys_days{__y_/__m_/last};
-    return (__last - (chrono::weekday{__last} - __wdl_.weekday())).time_since_epoch();
-
+_LIBCPP_HIDE_FROM_ABI inline constexpr days year_month_weekday_last::__to_days() const noexcept {
+  const sys_days __last = sys_days{__y_ / __m_ / last};
+  return (__last - (chrono::weekday{__last} - __wdl_.weekday())).time_since_epoch();
 }
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator==(const year_month_weekday_last& __lhs, const year_month_weekday_last& __rhs) noexcept
-{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.weekday_last() == __rhs.weekday_last(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool
+operator==(const year_month_weekday_last& __lhs, const year_month_weekday_last& __rhs) noexcept {
+  return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.weekday_last() == __rhs.weekday_last();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-bool operator!=(const year_month_weekday_last& __lhs, const year_month_weekday_last& __rhs) noexcept
-{ return !(__lhs == __rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator/(const year_month& __lhs, const weekday_last& __rhs) noexcept {
+  return year_month_weekday_last{__lhs.year(), __lhs.month(), __rhs};
+}
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator/(const year& __lhs, const month_weekday_last& __rhs) noexcept {
+  return year_month_weekday_last{__lhs, __rhs.month(), __rhs.weekday_last()};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator/(const year_month& __lhs, const weekday_last& __rhs) noexcept
-{ return year_month_weekday_last{__lhs.year(), __lhs.month(), __rhs}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator/(int __lhs, const month_weekday_last& __rhs) noexcept {
+  return year(__lhs) / __rhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator/(const year& __lhs, const month_weekday_last& __rhs) noexcept
-{ return year_month_weekday_last{__lhs, __rhs.month(), __rhs.weekday_last()}; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator/(const month_weekday_last& __lhs, const year& __rhs) noexcept {
+  return __rhs / __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator/(int __lhs, const month_weekday_last& __rhs) noexcept
-{ return year(__lhs) / __rhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator/(const month_weekday_last& __lhs, int __rhs) noexcept {
+  return year(__rhs) / __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator/(const month_weekday_last& __lhs, const year& __rhs) noexcept
-{ return __rhs / __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator+(const year_month_weekday_last& __lhs, const months& __rhs) noexcept {
+  return (__lhs.year() / __lhs.month() + __rhs) / __lhs.weekday_last();
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator/(const month_weekday_last& __lhs, int __rhs) noexcept
-{ return year(__rhs) / __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator+(const months& __lhs, const year_month_weekday_last& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator-(const year_month_weekday_last& __lhs, const months& __rhs) noexcept {
+  return __lhs + (-__rhs);
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator+(const year_month_weekday_last& __lhs, const months& __rhs) noexcept
-{ return (__lhs.year() / __lhs.month() + __rhs) / __lhs.weekday_last(); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator+(const year_month_weekday_last& __lhs, const years& __rhs) noexcept {
+  return year_month_weekday_last{__lhs.year() + __rhs, __lhs.month(), __lhs.weekday_last()};
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator+(const months& __lhs, const year_month_weekday_last& __rhs) noexcept
-{ return __rhs + __lhs; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator+(const years& __lhs, const year_month_weekday_last& __rhs) noexcept {
+  return __rhs + __lhs;
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator-(const year_month_weekday_last& __lhs, const months& __rhs) noexcept
-{ return __lhs + (-__rhs); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last
+operator-(const year_month_weekday_last& __lhs, const years& __rhs) noexcept {
+  return __lhs + (-__rhs);
+}
 
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator+(const year_month_weekday_last& __lhs, const years& __rhs) noexcept
-{ return year_month_weekday_last{__lhs.year() + __rhs, __lhs.month(), __lhs.weekday_last()}; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator+(const years& __lhs, const year_month_weekday_last& __rhs) noexcept
-{ return __rhs + __lhs; }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr
-year_month_weekday_last operator-(const year_month_weekday_last& __lhs, const years& __rhs) noexcept
-{ return __lhs + (-__rhs); }
-
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const years& __dy)  noexcept { *this = *this + __dy; return *this; }
-_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const years& __dy)  noexcept { *this = *this - __dy; return *this; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last&
+year_month_weekday_last::operator+=(const months& __dm) noexcept {
+  *this = *this + __dm;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last&
+year_month_weekday_last::operator-=(const months& __dm) noexcept {
+  *this = *this - __dm;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last&
+year_month_weekday_last::operator+=(const years& __dy) noexcept {
+  *this = *this + __dy;
+  return *this;
+}
+_LIBCPP_HIDE_FROM_ABI inline constexpr year_month_weekday_last&
+year_month_weekday_last::operator-=(const years& __dy) noexcept {
+  *this = *this - __dy;
+  return *this;
+}
 
 } // namespace chrono
 
diff --git a/third_party/libcxx/__chrono/zoned_time.h b/third_party/libcxx/__chrono/zoned_time.h
new file mode 100644
index 000000000..8cfa21226
--- /dev/null
+++ b/third_party/libcxx/__chrono/zoned_time.h
@@ -0,0 +1,227 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// For information see https://libcxx.llvm.org/DesignDocs/TimeZone.html
+
+#ifndef _LIBCPP___CHRONO_ZONED_TIME_H
+#define _LIBCPP___CHRONO_ZONED_TIME_H
+
+#include <version>
+// Enable the contents of the header only when libc++ was built with experimental features enabled.
+#if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#  include <__chrono/calendar.h>
+#  include <__chrono/duration.h>
+#  include <__chrono/sys_info.h>
+#  include <__chrono/system_clock.h>
+#  include <__chrono/time_zone.h>
+#  include <__chrono/tzdb_list.h>
+#  include <__config>
+#  include <__fwd/string_view.h>
+#  include <__type_traits/common_type.h>
+#  include <__type_traits/conditional.h>
+#  include <__type_traits/remove_cvref.h>
+#  include <__utility/move.h>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_PUSH_MACROS
+#  include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&   \
+      !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+namespace chrono {
+
+template <class>
+struct zoned_traits {};
+
+template <>
+struct zoned_traits<const time_zone*> {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static const time_zone* default_zone() { return chrono::locate_zone("UTC"); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static const time_zone* locate_zone(string_view __name) {
+    return chrono::locate_zone(__name);
+  }
+};
+
+template <class _Duration, class _TimeZonePtr = const time_zone*>
+class zoned_time {
+  // [time.zone.zonedtime.ctor]/2
+  static_assert(__is_duration<_Duration>::value,
+                "the program is ill-formed since _Duration is not a specialization of std::chrono::duration");
+
+  // The wording uses the constraints like
+  //   constructible_from<zoned_time, decltype(__traits::locate_zone(string_view{}))>
+  // Using these constraints in the code causes the compiler to give an
+  // error that the constraint depends on itself. To avoid that issue use
+  // the fact it is possible to create this object from a _TimeZonePtr.
+  using __traits = zoned_traits<_TimeZonePtr>;
+
+public:
+  using duration = common_type_t<_Duration, seconds>;
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time()
+    requires requires { __traits::default_zone(); }
+      : __zone_{__traits::default_zone()}, __tp_{} {}
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time(const zoned_time&)            = default;
+  _LIBCPP_HIDE_FROM_ABI zoned_time& operator=(const zoned_time&) = default;
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time(const sys_time<_Duration>& __tp)
+    requires requires { __traits::default_zone(); }
+      : __zone_{__traits::default_zone()}, __tp_{__tp} {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit zoned_time(_TimeZonePtr __zone) : __zone_{std::move(__zone)}, __tp_{} {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit zoned_time(string_view __name)
+    requires(requires { __traits::locate_zone(string_view{}); } &&
+             constructible_from<_TimeZonePtr, decltype(__traits::locate_zone(string_view{}))>)
+      : __zone_{__traits::locate_zone(__name)}, __tp_{} {}
+
+  template <class _Duration2>
+  _LIBCPP_HIDE_FROM_ABI zoned_time(const zoned_time<_Duration2, _TimeZonePtr>& __zt)
+    requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+      : __zone_{__zt.get_time_zone()}, __tp_{__zt.get_sys_time()} {}
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time(_TimeZonePtr __zone, const sys_time<_Duration>& __tp)
+      : __zone_{std::move(__zone)}, __tp_{__tp} {}
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time(string_view __name, const sys_time<_Duration>& __tp)
+    requires requires { _TimeZonePtr{__traits::locate_zone(string_view{})}; }
+      : zoned_time{__traits::locate_zone(__name), __tp} {}
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time(_TimeZonePtr __zone, const local_time<_Duration>& __tp)
+    requires(is_convertible_v<decltype(std::declval<_TimeZonePtr&>() -> to_sys(local_time<_Duration>{})),
+                              sys_time<duration>>)
+      : __zone_{std::move(__zone)}, __tp_{__zone_->to_sys(__tp)} {}
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time(string_view __name, const local_time<_Duration>& __tp)
+    requires(requires {
+      _TimeZonePtr{__traits::locate_zone(string_view{})};
+    } && is_convertible_v<decltype(std::declval<_TimeZonePtr&>() -> to_sys(local_time<_Duration>{})),
+                          sys_time<duration>>)
+      : zoned_time{__traits::locate_zone(__name), __tp} {}
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time(_TimeZonePtr __zone, const local_time<_Duration>& __tp, choose __c)
+    requires(is_convertible_v<
+                decltype(std::declval<_TimeZonePtr&>() -> to_sys(local_time<_Duration>{}, choose::earliest)),
+                sys_time<duration>>)
+      : __zone_{std::move(__zone)}, __tp_{__zone_->to_sys(__tp, __c)} {}
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time(string_view __name, const local_time<_Duration>& __tp, choose __c)
+    requires(requires {
+      _TimeZonePtr{__traits::locate_zone(string_view{})};
+    } && is_convertible_v<decltype(std::declval<_TimeZonePtr&>() -> to_sys(local_time<_Duration>{}, choose::earliest)),
+                          sys_time<duration>>)
+      : zoned_time{__traits::locate_zone(__name), __tp, __c} {}
+
+  template <class _Duration2, class _TimeZonePtr2>
+  _LIBCPP_HIDE_FROM_ABI zoned_time(_TimeZonePtr __zone, const zoned_time<_Duration2, _TimeZonePtr2>& __zt)
+    requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+      : __zone_{std::move(__zone)}, __tp_{__zt.get_sys_time()} {}
+
+  // per wording choose has no effect
+  template <class _Duration2, class _TimeZonePtr2>
+  _LIBCPP_HIDE_FROM_ABI zoned_time(_TimeZonePtr __zone, const zoned_time<_Duration2, _TimeZonePtr2>& __zt, choose)
+    requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+      : __zone_{std::move(__zone)}, __tp_{__zt.get_sys_time()} {}
+
+  template <class _Duration2, class _TimeZonePtr2>
+  _LIBCPP_HIDE_FROM_ABI zoned_time(string_view __name, const zoned_time<_Duration2, _TimeZonePtr2>& __zt)
+    requires(requires {
+      _TimeZonePtr{__traits::locate_zone(string_view{})};
+    } && is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>)
+      : zoned_time{__traits::locate_zone(__name), __zt} {}
+
+  template <class _Duration2, class _TimeZonePtr2>
+  _LIBCPP_HIDE_FROM_ABI zoned_time(string_view __name, const zoned_time<_Duration2, _TimeZonePtr2>& __zt, choose __c)
+    requires(requires {
+      _TimeZonePtr{__traits::locate_zone(string_view{})};
+    } && is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>)
+      : zoned_time{__traits::locate_zone(__name), __zt, __c} {}
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time& operator=(const sys_time<_Duration>& __tp) {
+    __tp_ = __tp;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI zoned_time& operator=(const local_time<_Duration>& __tp) {
+    // TODO TZDB This seems wrong.
+    // Assigning a non-existent or ambiguous time will throw and not satisfy
+    // the post condition. This seems quite odd; I constructed an object with
+    // choose::earliest and that choice is not respected.
+    // what did LEWG do with this.
+    // MSVC STL and libstdc++ behave the same
+    __tp_ = __zone_->to_sys(__tp);
+    return *this;
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI operator sys_time<duration>() const { return get_sys_time(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit operator local_time<duration>() const { return get_local_time(); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _TimeZonePtr get_time_zone() const { return __zone_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI local_time<duration> get_local_time() const { return __zone_->to_local(__tp_); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI sys_time<duration> get_sys_time() const { return __tp_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI sys_info get_info() const { return __zone_->get_info(__tp_); }
+
+private:
+  _TimeZonePtr __zone_;
+  sys_time<duration> __tp_;
+};
+
+zoned_time() -> zoned_time<seconds>;
+
+template <class _Duration>
+zoned_time(sys_time<_Duration>) -> zoned_time<common_type_t<_Duration, seconds>>;
+
+template <class _TimeZonePtrOrName>
+using __time_zone_representation =
+    conditional_t<is_convertible_v<_TimeZonePtrOrName, string_view>,
+                  const time_zone*,
+                  remove_cvref_t<_TimeZonePtrOrName>>;
+
+template <class _TimeZonePtrOrName>
+zoned_time(_TimeZonePtrOrName&&) -> zoned_time<seconds, __time_zone_representation<_TimeZonePtrOrName>>;
+
+template <class _TimeZonePtrOrName, class _Duration>
+zoned_time(_TimeZonePtrOrName&&, sys_time<_Duration>)
+    -> zoned_time<common_type_t<_Duration, seconds>, __time_zone_representation<_TimeZonePtrOrName>>;
+
+template <class _TimeZonePtrOrName, class _Duration>
+zoned_time(_TimeZonePtrOrName&&, local_time<_Duration>, choose = choose::earliest)
+    -> zoned_time<common_type_t<_Duration, seconds>, __time_zone_representation<_TimeZonePtrOrName>>;
+
+template <class _Duration, class _TimeZonePtrOrName, class TimeZonePtr2>
+zoned_time(_TimeZonePtrOrName&&, zoned_time<_Duration, TimeZonePtr2>, choose = choose::earliest)
+    -> zoned_time<common_type_t<_Duration, seconds>, __time_zone_representation<_TimeZonePtrOrName>>;
+
+using zoned_seconds = zoned_time<seconds>;
+
+template <class _Duration1, class _Duration2, class _TimeZonePtr>
+_LIBCPP_HIDE_FROM_ABI bool
+operator==(const zoned_time<_Duration1, _TimeZonePtr>& __lhs, const zoned_time<_Duration2, _TimeZonePtr>& __rhs) {
+  return __lhs.get_time_zone() == __rhs.get_time_zone() && __lhs.get_sys_time() == __rhs.get_sys_time();
+}
+
+} // namespace chrono
+
+#  endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
+         // && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
+
+#endif // _LIBCPP___CHRONO_ZONED_TIME_H
diff --git a/third_party/libcxx/__compare/common_comparison_category.h b/third_party/libcxx/__compare/common_comparison_category.h
index 5fad99bf5..7aeb3da03 100644
--- a/third_party/libcxx/__compare/common_comparison_category.h
+++ b/third_party/libcxx/__compare/common_comparison_category.h
@@ -24,17 +24,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace __comp_detail {
 
-enum _ClassifyCompCategory : unsigned {
-  _None,
-  _PartialOrd,
-  _WeakOrd,
-  _StrongOrd,
-  _CCC_Size
-};
+enum _ClassifyCompCategory : unsigned { _None, _PartialOrd, _WeakOrd, _StrongOrd, _CCC_Size };
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-constexpr _ClassifyCompCategory __type_to_enum() noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr _ClassifyCompCategory __type_to_enum() noexcept {
   if (is_same_v<_Tp, partial_ordering>)
     return _PartialOrd;
   if (is_same_v<_Tp, weak_ordering>)
@@ -45,8 +38,7 @@ constexpr _ClassifyCompCategory __type_to_enum() noexcept {
 }
 
 template <size_t _Size>
-_LIBCPP_HIDE_FROM_ABI
-constexpr _ClassifyCompCategory
+_LIBCPP_HIDE_FROM_ABI constexpr _ClassifyCompCategory
 __compute_comp_type(const _ClassifyCompCategory (&__types)[_Size]) {
   int __seen[_CCC_Size] = {};
   for (auto __type : __types)
@@ -60,12 +52,11 @@ __compute_comp_type(const _ClassifyCompCategory (&__types)[_Size]) {
   return _StrongOrd;
 }
 
-template <class ..._Ts, bool _False = false>
-_LIBCPP_HIDE_FROM_ABI
-constexpr auto __get_comp_type() {
-  using _CCC = _ClassifyCompCategory;
+template <class... _Ts, bool _False = false>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __get_comp_type() {
+  using _CCC                    = _ClassifyCompCategory;
   constexpr _CCC __type_kinds[] = {_StrongOrd, __type_to_enum<_Ts>()...};
-  constexpr _CCC __cat = __comp_detail::__compute_comp_type(__type_kinds);
+  constexpr _CCC __cat          = __comp_detail::__compute_comp_type(__type_kinds);
   if constexpr (__cat == _None)
     return void();
   else if constexpr (__cat == _PartialOrd)
@@ -80,12 +71,12 @@ constexpr auto __get_comp_type() {
 } // namespace __comp_detail
 
 // [cmp.common], common comparison category type
-template<class... _Ts>
+template <class... _Ts>
 struct _LIBCPP_TEMPLATE_VIS common_comparison_category {
   using type = decltype(__comp_detail::__get_comp_type<_Ts...>());
 };
 
-template<class... _Ts>
+template <class... _Ts>
 using common_comparison_category_t = typename common_comparison_category<_Ts...>::type;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__compare/compare_partial_order_fallback.h b/third_party/libcxx/__compare/compare_partial_order_fallback.h
index fb2921ed5..e0efa3ccb 100644
--- a/third_party/libcxx/__compare/compare_partial_order_fallback.h
+++ b/third_party/libcxx/__compare/compare_partial_order_fallback.h
@@ -27,44 +27,46 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [cmp.alg]
 namespace __compare_partial_order_fallback {
-    struct __fn {
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
-            noexcept(noexcept(_VSTD::partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            -> decltype(      _VSTD::partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))
-            { return          _VSTD::partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)); }
+struct __fn {
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<1>) noexcept(
+      noexcept(std::partial_order(std::forward<_Tp>(__t), std::forward<_Up>(__u))))
+      -> decltype(std::partial_order(std::forward<_Tp>(__t), std::forward<_Up>(__u))) {
+    return std::partial_order(std::forward<_Tp>(__t), std::forward<_Up>(__u));
+  }
 
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
-            noexcept(noexcept(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? partial_ordering::equivalent :
-                              _VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? partial_ordering::less :
-                              _VSTD::forward<_Up>(__u) < _VSTD::forward<_Tp>(__t) ? partial_ordering::greater :
-                              partial_ordering::unordered))
-            -> decltype(      _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? partial_ordering::equivalent :
-                              _VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? partial_ordering::less :
-                              _VSTD::forward<_Up>(__u) < _VSTD::forward<_Tp>(__t) ? partial_ordering::greater :
-                              partial_ordering::unordered)
-        {
-            return            _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? partial_ordering::equivalent :
-                              _VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? partial_ordering::less :
-                              _VSTD::forward<_Up>(__u) < _VSTD::forward<_Tp>(__t) ? partial_ordering::greater :
-                              partial_ordering::unordered;
-        }
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<0>) noexcept(noexcept(
+      std::forward<_Tp>(__t) == std::forward<_Up>(__u)  ? partial_ordering::equivalent
+      : std::forward<_Tp>(__t) < std::forward<_Up>(__u) ? partial_ordering::less
+      : std::forward<_Up>(__u) < std::forward<_Tp>(__t)
+          ? partial_ordering::greater
+          : partial_ordering::unordered))
+      -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)  ? partial_ordering::equivalent
+                  : std::forward<_Tp>(__t) < std::forward<_Up>(__u) ? partial_ordering::less
+                  : std::forward<_Up>(__u) < std::forward<_Tp>(__t)
+                      ? partial_ordering::greater
+                      : partial_ordering::unordered) {
+    return std::forward<_Tp>(__t) == std::forward<_Up>(__u) ? partial_ordering::equivalent
+         : std::forward<_Tp>(__t) < std::forward<_Up>(__u)  ? partial_ordering::less
+         : std::forward<_Up>(__u) < std::forward<_Tp>(__t)
+             ? partial_ordering::greater
+             : partial_ordering::unordered;
+  }
 
-        template<class _Tp, class _Up>
-        _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
-            noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>())))
-            -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()))
-            { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
-    };
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<1>())))
+          -> decltype(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<1>())) {
+    return __go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<1>());
+  }
+};
 } // namespace __compare_partial_order_fallback
 
 inline namespace __cpo {
-    inline constexpr auto compare_partial_order_fallback = __compare_partial_order_fallback::__fn{};
+inline constexpr auto compare_partial_order_fallback = __compare_partial_order_fallback::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__compare/compare_strong_order_fallback.h b/third_party/libcxx/__compare/compare_strong_order_fallback.h
index d84d065e4..a94d517ed 100644
--- a/third_party/libcxx/__compare/compare_strong_order_fallback.h
+++ b/third_party/libcxx/__compare/compare_strong_order_fallback.h
@@ -27,41 +27,43 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [cmp.alg]
 namespace __compare_strong_order_fallback {
-    struct __fn {
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
-            noexcept(noexcept(_VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            -> decltype(      _VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))
-            { return          _VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)); }
+struct __fn {
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<1>) noexcept(
+      noexcept(std::strong_order(std::forward<_Tp>(__t), std::forward<_Up>(__u))))
+      -> decltype(std::strong_order(std::forward<_Tp>(__t), std::forward<_Up>(__u))) {
+    return std::strong_order(std::forward<_Tp>(__t), std::forward<_Up>(__u));
+  }
 
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
-            noexcept(noexcept(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? strong_ordering::equal :
-                              _VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? strong_ordering::less :
-                              strong_ordering::greater))
-            -> decltype(      _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? strong_ordering::equal :
-                              _VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? strong_ordering::less :
-                              strong_ordering::greater)
-        {
-            return            _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? strong_ordering::equal :
-                              _VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? strong_ordering::less :
-                              strong_ordering::greater;
-        }
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<0>) noexcept(noexcept(
+      std::forward<_Tp>(__t) == std::forward<_Up>(__u) ? strong_ordering::equal
+      : std::forward<_Tp>(__t) < std::forward<_Up>(__u)
+          ? strong_ordering::less
+          : strong_ordering::greater))
+      -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u) ? strong_ordering::equal
+                  : std::forward<_Tp>(__t) < std::forward<_Up>(__u)
+                      ? strong_ordering::less
+                      : strong_ordering::greater) {
+    return std::forward<_Tp>(__t) == std::forward<_Up>(__u) ? strong_ordering::equal
+         : std::forward<_Tp>(__t) < std::forward<_Up>(__u)
+             ? strong_ordering::less
+             : strong_ordering::greater;
+  }
 
-        template<class _Tp, class _Up>
-        _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
-            noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>())))
-            -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()))
-            { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
-    };
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<1>())))
+          -> decltype(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<1>())) {
+    return __go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<1>());
+  }
+};
 } // namespace __compare_strong_order_fallback
 
 inline namespace __cpo {
-    inline constexpr auto compare_strong_order_fallback = __compare_strong_order_fallback::__fn{};
+inline constexpr auto compare_strong_order_fallback = __compare_strong_order_fallback::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__compare/compare_three_way.h b/third_party/libcxx/__compare/compare_three_way.h
index 2bc63a00e..01c12076c 100644
--- a/third_party/libcxx/__compare/compare_three_way.h
+++ b/third_party/libcxx/__compare/compare_three_way.h
@@ -22,16 +22,15 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-struct _LIBCPP_TEMPLATE_VIS compare_three_way
-{
-    template<class _T1, class _T2>
-        requires three_way_comparable_with<_T1, _T2>
-    constexpr _LIBCPP_HIDE_FROM_ABI
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u)))
-        { return          _VSTD::forward<_T1>(__t) <=> _VSTD::forward<_T2>(__u); }
+struct _LIBCPP_TEMPLATE_VIS compare_three_way {
+  template <class _T1, class _T2>
+    requires three_way_comparable_with<_T1, _T2>
+  constexpr _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) <=> std::forward<_T2>(__u))) {
+    return std::forward<_T1>(__t) <=> std::forward<_T2>(__u);
+  }
 
-    using is_transparent = void;
+  using is_transparent = void;
 };
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__compare/compare_three_way_result.h b/third_party/libcxx/__compare/compare_three_way_result.h
index 632ebdce1..d75080734 100644
--- a/third_party/libcxx/__compare/compare_three_way_result.h
+++ b/third_party/libcxx/__compare/compare_three_way_result.h
@@ -21,20 +21,21 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-template<class, class, class>
-struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result { };
+template <class, class, class>
+struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result {};
 
-template<class _Tp, class _Up>
-struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result<_Tp, _Up, decltype(
-  std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>(), void()
-)> {
-    using type = decltype(std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>());
+template <class _Tp, class _Up>
+struct _LIBCPP_HIDE_FROM_ABI __compare_three_way_result<
+    _Tp,
+    _Up,
+    decltype(std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>(), void())> {
+  using type = decltype(std::declval<__make_const_lvalue_ref<_Tp>>() <=> std::declval<__make_const_lvalue_ref<_Up>>());
 };
 
-template<class _Tp, class _Up = _Tp>
-struct _LIBCPP_TEMPLATE_VIS compare_three_way_result : __compare_three_way_result<_Tp, _Up, void> { };
+template <class _Tp, class _Up = _Tp>
+struct _LIBCPP_TEMPLATE_VIS compare_three_way_result : __compare_three_way_result<_Tp, _Up, void> {};
 
-template<class _Tp, class _Up = _Tp>
+template <class _Tp, class _Up = _Tp>
 using compare_three_way_result_t = typename compare_three_way_result<_Tp, _Up>::type;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__compare/compare_weak_order_fallback.h b/third_party/libcxx/__compare/compare_weak_order_fallback.h
index d3ba04a86..062b7b582 100644
--- a/third_party/libcxx/__compare/compare_weak_order_fallback.h
+++ b/third_party/libcxx/__compare/compare_weak_order_fallback.h
@@ -27,41 +27,43 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [cmp.alg]
 namespace __compare_weak_order_fallback {
-    struct __fn {
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
-            noexcept(noexcept(_VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            -> decltype(      _VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))
-            { return          _VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)); }
+struct __fn {
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<1>) noexcept(
+      noexcept(std::weak_order(std::forward<_Tp>(__t), std::forward<_Up>(__u))))
+      -> decltype(std::weak_order(std::forward<_Tp>(__t), std::forward<_Up>(__u))) {
+    return std::weak_order(std::forward<_Tp>(__t), std::forward<_Up>(__u));
+  }
 
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
-            noexcept(noexcept(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? weak_ordering::equivalent :
-                              _VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? weak_ordering::less :
-                              weak_ordering::greater))
-            -> decltype(      _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? weak_ordering::equivalent :
-                              _VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? weak_ordering::less :
-                              weak_ordering::greater)
-        {
-            return            _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u) ? weak_ordering::equivalent :
-                              _VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u) ? weak_ordering::less :
-                              weak_ordering::greater;
-        }
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<0>) noexcept(noexcept(
+      std::forward<_Tp>(__t) == std::forward<_Up>(__u) ? weak_ordering::equivalent
+      : std::forward<_Tp>(__t) < std::forward<_Up>(__u)
+          ? weak_ordering::less
+          : weak_ordering::greater))
+      -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u) ? weak_ordering::equivalent
+                  : std::forward<_Tp>(__t) < std::forward<_Up>(__u)
+                      ? weak_ordering::less
+                      : weak_ordering::greater) {
+    return std::forward<_Tp>(__t) == std::forward<_Up>(__u) ? weak_ordering::equivalent
+         : std::forward<_Tp>(__t) < std::forward<_Up>(__u)
+             ? weak_ordering::less
+             : weak_ordering::greater;
+  }
 
-        template<class _Tp, class _Up>
-        _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
-            noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>())))
-            -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()))
-            { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<1>()); }
-    };
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<1>())))
+          -> decltype(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<1>())) {
+    return __go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<1>());
+  }
+};
 } // namespace __compare_weak_order_fallback
 
 inline namespace __cpo {
-    inline constexpr auto compare_weak_order_fallback = __compare_weak_order_fallback::__fn{};
+inline constexpr auto compare_weak_order_fallback = __compare_weak_order_fallback::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__compare/ordering.h b/third_party/libcxx/__compare/ordering.h
index c348f0433..2995d3813 100644
--- a/third_party/libcxx/__compare/ordering.h
+++ b/third_party/libcxx/__compare/ordering.h
@@ -22,46 +22,35 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 // exposition only
-enum class _LIBCPP_ENUM_VIS _OrdResult : signed char {
-  __less = -1,
-  __equiv = 0,
-  __greater = 1
-};
+enum class _OrdResult : signed char { __less = -1, __equiv = 0, __greater = 1 };
 
-enum class _LIBCPP_ENUM_VIS _NCmpResult : signed char {
-  __unordered = -127
-};
+enum class _NCmpResult : signed char { __unordered = -127 };
 
 class partial_ordering;
 class weak_ordering;
 class strong_ordering;
 
-template<class _Tp, class... _Args>
+template <class _Tp, class... _Args>
 inline constexpr bool __one_of_v = (is_same_v<_Tp, _Args> || ...);
 
 struct _CmpUnspecifiedParam {
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  _CmpUnspecifiedParam(int _CmpUnspecifiedParam::*) noexcept {}
+  _LIBCPP_HIDE_FROM_ABI constexpr _CmpUnspecifiedParam(int _CmpUnspecifiedParam::*) noexcept {}
 
-  template<class _Tp, class = enable_if_t<!__one_of_v<_Tp, int, partial_ordering, weak_ordering, strong_ordering>>>
+  template <class _Tp, class = enable_if_t<!__one_of_v<_Tp, int, partial_ordering, weak_ordering, strong_ordering>>>
   _CmpUnspecifiedParam(_Tp) = delete;
 };
 
 class partial_ordering {
   using _ValueT = signed char;
 
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr partial_ordering(_OrdResult __v) noexcept
-      : __value_(_ValueT(__v)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr partial_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr partial_ordering(_NCmpResult __v) noexcept
-      : __value_(_ValueT(__v)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr partial_ordering(_NCmpResult __v) noexcept : __value_(_ValueT(__v)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr bool __is_ordered() const noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __is_ordered() const noexcept {
     return __value_ != _ValueT(_NCmpResult::__unordered);
   }
+
 public:
   // valid values
   static const partial_ordering less;
@@ -70,63 +59,54 @@ public:
   static const partial_ordering unordered;
 
   // comparisons
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(partial_ordering, partial_ordering) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(partial_ordering, partial_ordering) noexcept = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__is_ordered() && __v.__value_ == 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator< (partial_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__is_ordered() && __v.__value_ < 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(partial_ordering __v, _CmpUnspecifiedParam) noexcept  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__is_ordered() && __v.__value_ <= 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator> (partial_ordering __v, _CmpUnspecifiedParam) noexcept  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__is_ordered() && __v.__value_ > 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(partial_ordering __v, _CmpUnspecifiedParam) noexcept  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__is_ordered() && __v.__value_ >= 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator< (_CmpUnspecifiedParam, partial_ordering __v) noexcept  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
     return __v.__is_ordered() && 0 < __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(_CmpUnspecifiedParam, partial_ordering __v) noexcept  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
     return __v.__is_ordered() && 0 <= __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator> (_CmpUnspecifiedParam, partial_ordering __v) noexcept  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
     return __v.__is_ordered() && 0 > __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
     return __v.__is_ordered() && 0 >= __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr partial_ordering operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr partial_ordering
+  operator<=>(partial_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr partial_ordering operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr partial_ordering
+  operator<=>(_CmpUnspecifiedParam, partial_ordering __v) noexcept {
     return __v < 0 ? partial_ordering::greater : (__v > 0 ? partial_ordering::less : __v);
   }
+
 private:
   _ValueT __value_;
 };
@@ -139,76 +119,62 @@ inline constexpr partial_ordering partial_ordering::unordered(_NCmpResult ::__un
 class weak_ordering {
   using _ValueT = signed char;
 
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr weak_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr weak_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
 
 public:
   static const weak_ordering less;
   static const weak_ordering equivalent;
   static const weak_ordering greater;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr operator partial_ordering() const noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr operator partial_ordering() const noexcept {
     return __value_ == 0 ? partial_ordering::equivalent
-        : (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
+                         : (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
   }
 
   // comparisons
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(weak_ordering, weak_ordering) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(weak_ordering, weak_ordering) noexcept = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__value_ == 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator< (weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__value_ < 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__value_ <= 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator> (weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__value_ > 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__value_ >= 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator< (_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
     return 0 < __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
     return 0 <= __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator> (_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
     return 0 > __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
     return 0 >= __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr weak_ordering operator<=>(weak_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr weak_ordering operator<=>(_CmpUnspecifiedParam, weak_ordering __v) noexcept {
     return __v < 0 ? weak_ordering::greater : (__v > 0 ? weak_ordering::less : __v);
   }
 
@@ -223,8 +189,7 @@ inline constexpr weak_ordering weak_ordering::greater(_OrdResult::__greater);
 class strong_ordering {
   using _ValueT = signed char;
 
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr strong_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr strong_ordering(_OrdResult __v) noexcept : __value_(_ValueT(__v)) {}
 
 public:
   static const strong_ordering less;
@@ -233,74 +198,61 @@ public:
   static const strong_ordering greater;
 
   // conversions
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr operator partial_ordering() const noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr operator partial_ordering() const noexcept {
     return __value_ == 0 ? partial_ordering::equivalent
-        : (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
+                         : (__value_ < 0 ? partial_ordering::less : partial_ordering::greater);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr operator weak_ordering() const noexcept {
-    return __value_ == 0 ? weak_ordering::equivalent
-        : (__value_ < 0 ? weak_ordering::less : weak_ordering::greater);
+  _LIBCPP_HIDE_FROM_ABI constexpr operator weak_ordering() const noexcept {
+    return __value_ == 0 ? weak_ordering::equivalent : (__value_ < 0 ? weak_ordering::less : weak_ordering::greater);
   }
 
   // comparisons
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(strong_ordering, strong_ordering) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(strong_ordering, strong_ordering) noexcept = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__value_ == 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator< (strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__value_ < 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__value_ <= 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator> (strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__value_ > 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v.__value_ >= 0;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator< (_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
     return 0 < __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
     return 0 <= __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator> (_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
     return 0 > __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
     return 0 >= __v.__value_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr strong_ordering operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr strong_ordering
+  operator<=>(strong_ordering __v, _CmpUnspecifiedParam) noexcept {
     return __v;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr strong_ordering operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr strong_ordering
+  operator<=>(_CmpUnspecifiedParam, strong_ordering __v) noexcept {
     return __v < 0 ? strong_ordering::greater : (__v > 0 ? strong_ordering::less : __v);
   }
 
diff --git a/third_party/libcxx/__compare/partial_order.h b/third_party/libcxx/__compare/partial_order.h
index 9cb76cc5b..1d2fae63e 100644
--- a/third_party/libcxx/__compare/partial_order.h
+++ b/third_party/libcxx/__compare/partial_order.h
@@ -28,43 +28,46 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [cmp.alg]
 namespace __partial_order {
-    struct __fn {
-    // NOLINTBEGIN(libcpp-robust-against-adl) partial_order should use ADL, but only here
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<2>)
-            noexcept(noexcept(partial_ordering(partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-            -> decltype(      partial_ordering(partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            { return          partial_ordering(partial_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
-    // NOLINTEND(libcpp-robust-against-adl)
+void partial_order() = delete;
 
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
-            noexcept(noexcept(partial_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-            -> decltype(      partial_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            { return          partial_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
+struct __fn {
+  // NOLINTBEGIN(libcpp-robust-against-adl) partial_order should use ADL, but only here
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<2>) noexcept(
+      noexcept(partial_ordering(partial_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)))))
+      -> decltype(partial_ordering(partial_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)))) {
+    return partial_ordering(partial_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)));
+  }
+  // NOLINTEND(libcpp-robust-against-adl)
 
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
-            noexcept(noexcept(partial_ordering(_VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-            -> decltype(      partial_ordering(_VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            { return          partial_ordering(_VSTD::weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<1>) noexcept(
+      noexcept(partial_ordering(compare_three_way()(std::forward<_Tp>(__t), std::forward<_Up>(__u)))))
+      -> decltype(partial_ordering(compare_three_way()(std::forward<_Tp>(__t), std::forward<_Up>(__u)))) {
+    return partial_ordering(compare_three_way()(std::forward<_Tp>(__t), std::forward<_Up>(__u)));
+  }
 
-        template<class _Tp, class _Up>
-        _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
-            noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>())))
-            -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()))
-            { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()); }
-    };
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<0>) noexcept(
+      noexcept(partial_ordering(std::weak_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)))))
+      -> decltype(partial_ordering(std::weak_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)))) {
+    return partial_ordering(std::weak_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)));
+  }
+
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<2>())))
+          -> decltype(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<2>())) {
+    return __go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<2>());
+  }
+};
 } // namespace __partial_order
 
 inline namespace __cpo {
-    inline constexpr auto partial_order = __partial_order::__fn{};
+inline constexpr auto partial_order = __partial_order::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__compare/strong_order.h b/third_party/libcxx/__compare/strong_order.h
index b6e0cfaaa..8c363b563 100644
--- a/third_party/libcxx/__compare/strong_order.h
+++ b/third_party/libcxx/__compare/strong_order.h
@@ -13,11 +13,14 @@
 #include <__compare/compare_three_way.h>
 #include <__compare/ordering.h>
 #include <__config>
+#include <__math/exponential_functions.h>
+#include <__math/traits.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/decay.h>
+#include <__type_traits/is_floating_point.h>
+#include <__type_traits/is_same.h>
 #include <__utility/forward.h>
 #include <__utility/priority_tag.h>
-#include <cmath>
 #include <cstdint>
 #include <limits>
 
@@ -34,100 +37,101 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [cmp.alg]
 namespace __strong_order {
-    struct __fn {
-    // NOLINTBEGIN(libcpp-robust-against-adl) strong_order should use ADL, but only here
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<2>)
-            noexcept(noexcept(strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-            -> decltype(      strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            { return          strong_ordering(strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
-    // NOLINTEND(libcpp-robust-against-adl)
+void strong_order() = delete;
 
-        template<class _Tp, class _Up, class _Dp = decay_t<_Tp>>
-            requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
-        _LIBCPP_HIDE_FROM_ABI static constexpr strong_ordering
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<1>) noexcept
-        {
-            if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int32_t)) {
-                int32_t __rx = _VSTD::bit_cast<int32_t>(__t);
-                int32_t __ry = _VSTD::bit_cast<int32_t>(__u);
-                __rx = (__rx < 0) ? (numeric_limits<int32_t>::min() - __rx - 1) : __rx;
-                __ry = (__ry < 0) ? (numeric_limits<int32_t>::min() - __ry - 1) : __ry;
-                return (__rx <=> __ry);
-            } else if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int64_t)) {
-                int64_t __rx = _VSTD::bit_cast<int64_t>(__t);
-                int64_t __ry = _VSTD::bit_cast<int64_t>(__u);
-                __rx = (__rx < 0) ? (numeric_limits<int64_t>::min() - __rx - 1) : __rx;
-                __ry = (__ry < 0) ? (numeric_limits<int64_t>::min() - __ry - 1) : __ry;
-                return (__rx <=> __ry);
-            } else if (__t < __u) {
-                return strong_ordering::less;
-            } else if (__t > __u) {
-                return strong_ordering::greater;
-            } else if (__t == __u) {
-                if constexpr (numeric_limits<_Dp>::radix == 2) {
-                    return _VSTD::signbit(__u) <=> _VSTD::signbit(__t);
-                } else {
-                    // This is bullet 3 of the IEEE754 algorithm, relevant
-                    // only for decimal floating-point;
-                    // see https://stackoverflow.com/questions/69068075/
-                    if (__t == 0 || _VSTD::isinf(__t)) {
-                        return _VSTD::signbit(__u) <=> _VSTD::signbit(__t);
-                    } else {
-                        int __texp, __uexp;
-                        (void)_VSTD::frexp(__t, &__texp);
-                        (void)_VSTD::frexp(__u, &__uexp);
-                        return (__t < 0) ? (__texp <=> __uexp) : (__uexp <=> __texp);
-                    }
-                }
-            } else {
-                // They're unordered, so one of them must be a NAN.
-                // The order is -QNAN, -SNAN, numbers, +SNAN, +QNAN.
-                bool __t_is_nan = _VSTD::isnan(__t);
-                bool __u_is_nan = _VSTD::isnan(__u);
-                bool __t_is_negative = _VSTD::signbit(__t);
-                bool __u_is_negative = _VSTD::signbit(__u);
-                using _IntType = conditional_t<
-                    sizeof(__t) == sizeof(int32_t), int32_t, conditional_t<
-                    sizeof(__t) == sizeof(int64_t), int64_t, void>
-                >;
-                if constexpr (is_same_v<_IntType, void>) {
-                    static_assert(sizeof(_Dp) == 0, "std::strong_order is unimplemented for this floating-point type");
-                } else if (__t_is_nan && __u_is_nan) {
-                    // Order by sign bit, then by "payload bits" (we'll just use bit_cast).
-                    if (__t_is_negative != __u_is_negative) {
-                        return (__u_is_negative <=> __t_is_negative);
-                    } else {
-                        return _VSTD::bit_cast<_IntType>(__t) <=> _VSTD::bit_cast<_IntType>(__u);
-                    }
-                } else if (__t_is_nan) {
-                    return __t_is_negative ? strong_ordering::less : strong_ordering::greater;
-                } else {
-                    return __u_is_negative ? strong_ordering::greater : strong_ordering::less;
-                }
-            }
+struct __fn {
+  // NOLINTBEGIN(libcpp-robust-against-adl) strong_order should use ADL, but only here
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<2>) noexcept(
+      noexcept(strong_ordering(strong_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)))))
+      -> decltype(strong_ordering(strong_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)))) {
+    return strong_ordering(strong_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)));
+  }
+  // NOLINTEND(libcpp-robust-against-adl)
+
+  template <class _Tp, class _Up, class _Dp = decay_t<_Tp>>
+    requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
+  _LIBCPP_HIDE_FROM_ABI static constexpr strong_ordering __go(_Tp&& __t, _Up&& __u, __priority_tag<1>) noexcept {
+    if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int32_t)) {
+      int32_t __rx = std::bit_cast<int32_t>(__t);
+      int32_t __ry = std::bit_cast<int32_t>(__u);
+      __rx         = (__rx < 0) ? (numeric_limits<int32_t>::min() - __rx - 1) : __rx;
+      __ry         = (__ry < 0) ? (numeric_limits<int32_t>::min() - __ry - 1) : __ry;
+      return (__rx <=> __ry);
+    } else if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int64_t)) {
+      int64_t __rx = std::bit_cast<int64_t>(__t);
+      int64_t __ry = std::bit_cast<int64_t>(__u);
+      __rx         = (__rx < 0) ? (numeric_limits<int64_t>::min() - __rx - 1) : __rx;
+      __ry         = (__ry < 0) ? (numeric_limits<int64_t>::min() - __ry - 1) : __ry;
+      return (__rx <=> __ry);
+    } else if (__t < __u) {
+      return strong_ordering::less;
+    } else if (__t > __u) {
+      return strong_ordering::greater;
+    } else if (__t == __u) {
+      if constexpr (numeric_limits<_Dp>::radix == 2) {
+        return __math::signbit(__u) <=> __math::signbit(__t);
+      } else {
+        // This is bullet 3 of the IEEE754 algorithm, relevant
+        // only for decimal floating-point;
+        // see https://stackoverflow.com/questions/69068075/
+        if (__t == 0 || __math::isinf(__t)) {
+          return __math::signbit(__u) <=> __math::signbit(__t);
+        } else {
+          int __texp, __uexp;
+          (void)__math::frexp(__t, &__texp);
+          (void)__math::frexp(__u, &__uexp);
+          return (__t < 0) ? (__texp <=> __uexp) : (__uexp <=> __texp);
         }
+      }
+    } else {
+      // They're unordered, so one of them must be a NAN.
+      // The order is -QNAN, -SNAN, numbers, +SNAN, +QNAN.
+      bool __t_is_nan      = __math::isnan(__t);
+      bool __u_is_nan      = __math::isnan(__u);
+      bool __t_is_negative = __math::signbit(__t);
+      bool __u_is_negative = __math::signbit(__u);
+      using _IntType =
+          conditional_t< sizeof(__t) == sizeof(int32_t),
+                         int32_t,
+                         conditional_t< sizeof(__t) == sizeof(int64_t), int64_t, void> >;
+      if constexpr (is_same_v<_IntType, void>) {
+        static_assert(sizeof(_Dp) == 0, "std::strong_order is unimplemented for this floating-point type");
+      } else if (__t_is_nan && __u_is_nan) {
+        // Order by sign bit, then by "payload bits" (we'll just use bit_cast).
+        if (__t_is_negative != __u_is_negative) {
+          return (__u_is_negative <=> __t_is_negative);
+        } else {
+          return std::bit_cast<_IntType>(__t) <=> std::bit_cast<_IntType>(__u);
+        }
+      } else if (__t_is_nan) {
+        return __t_is_negative ? strong_ordering::less : strong_ordering::greater;
+      } else {
+        return __u_is_negative ? strong_ordering::greater : strong_ordering::less;
+      }
+    }
+  }
 
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
-            noexcept(noexcept(strong_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-            -> decltype(      strong_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            { return          strong_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<0>) noexcept(
+      noexcept(strong_ordering(compare_three_way()(std::forward<_Tp>(__t), std::forward<_Up>(__u)))))
+      -> decltype(strong_ordering(compare_three_way()(std::forward<_Tp>(__t), std::forward<_Up>(__u)))) {
+    return strong_ordering(compare_three_way()(std::forward<_Tp>(__t), std::forward<_Up>(__u)));
+  }
 
-        template<class _Tp, class _Up>
-        _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
-            noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>())))
-            -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()))
-            { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<2>()); }
-    };
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<2>())))
+          -> decltype(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<2>())) {
+    return __go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<2>());
+  }
+};
 } // namespace __strong_order
 
 inline namespace __cpo {
-    inline constexpr auto strong_order = __strong_order::__fn{};
+inline constexpr auto strong_order = __strong_order::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__compare/synth_three_way.h b/third_party/libcxx/__compare/synth_three_way.h
index 6420d1362..e48ce4979 100644
--- a/third_party/libcxx/__compare/synth_three_way.h
+++ b/third_party/libcxx/__compare/synth_three_way.h
@@ -25,12 +25,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [expos.only.func]
 
-// TODO MODULES restore the lamba to match the Standard.
-// See https://github.com/llvm/llvm-project/issues/57222
-//_LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way =
-//  []<class _Tp, class _Up>(const _Tp& __t, const _Up& __u)
-template <class _Tp, class _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr auto __synth_three_way(const _Tp& __t, const _Up& __u)
+_LIBCPP_HIDE_FROM_ABI inline constexpr auto __synth_three_way = []<class _Tp, class _Up>(const _Tp& __t, const _Up& __u)
   requires requires {
     { __t < __u } -> __boolean_testable;
     { __u < __t } -> __boolean_testable;
@@ -45,7 +40,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto __synth_three_way(const _Tp& __t, const _Up
       return weak_ordering::greater;
     return weak_ordering::equivalent;
   }
-}
+};
 
 template <class _Tp, class _Up = _Tp>
 using __synth_three_way_result = decltype(std::__synth_three_way(std::declval<_Tp&>(), std::declval<_Up&>()));
diff --git a/third_party/libcxx/__compare/three_way_comparable.h b/third_party/libcxx/__compare/three_way_comparable.h
index 2b77bc3f5..7a44ea915 100644
--- a/third_party/libcxx/__compare/three_way_comparable.h
+++ b/third_party/libcxx/__compare/three_way_comparable.h
@@ -27,30 +27,26 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-template<class _Tp, class _Cat>
-concept __compares_as =
-  same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
+template <class _Tp, class _Cat>
+concept __compares_as = same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
 
-template<class _Tp, class _Cat = partial_ordering>
+template <class _Tp, class _Cat = partial_ordering>
 concept three_way_comparable =
-  __weakly_equality_comparable_with<_Tp, _Tp> &&
-  __partially_ordered_with<_Tp, _Tp> &&
-  requires(__make_const_lvalue_ref<_Tp> __a, __make_const_lvalue_ref<_Tp> __b) {
-    { __a <=> __b } -> __compares_as<_Cat>;
-  };
+    __weakly_equality_comparable_with<_Tp, _Tp> && __partially_ordered_with<_Tp, _Tp> &&
+    requires(__make_const_lvalue_ref<_Tp> __a, __make_const_lvalue_ref<_Tp> __b) {
+      { __a <=> __b } -> __compares_as<_Cat>;
+    };
 
-template<class _Tp, class _Up, class _Cat = partial_ordering>
+template <class _Tp, class _Up, class _Cat = partial_ordering>
 concept three_way_comparable_with =
-  three_way_comparable<_Tp, _Cat> &&
-  three_way_comparable<_Up, _Cat> &&
-  common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
-  three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _Cat> &&
-  __weakly_equality_comparable_with<_Tp, _Up> &&
-  __partially_ordered_with<_Tp, _Up> &&
-  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
-    { __t <=> __u } -> __compares_as<_Cat>;
-    { __u <=> __t } -> __compares_as<_Cat>;
-  };
+    three_way_comparable<_Tp, _Cat> && three_way_comparable<_Up, _Cat> &&
+    common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
+    three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _Cat> &&
+    __weakly_equality_comparable_with<_Tp, _Up> && __partially_ordered_with<_Tp, _Up> &&
+    requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+      { __t <=> __u } -> __compares_as<_Cat>;
+      { __u <=> __t } -> __compares_as<_Cat>;
+    };
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__compare/weak_order.h b/third_party/libcxx/__compare/weak_order.h
index 9cbc1d24a..1a3e85feb 100644
--- a/third_party/libcxx/__compare/weak_order.h
+++ b/third_party/libcxx/__compare/weak_order.h
@@ -13,10 +13,12 @@
 #include <__compare/ordering.h>
 #include <__compare/strong_order.h>
 #include <__config>
+#include <__math/traits.h>
 #include <__type_traits/decay.h>
+#include <__type_traits/is_floating_point.h>
+#include <__type_traits/is_same.h>
 #include <__utility/forward.h>
 #include <__utility/priority_tag.h>
-#include <cmath>
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #  pragma GCC system_header
@@ -28,71 +30,72 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [cmp.alg]
 namespace __weak_order {
-    struct __fn {
-    // NOLINTBEGIN(libcpp-robust-against-adl) weak_order should use ADL, but only here
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<3>)
-            noexcept(noexcept(weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-            -> decltype(      weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            { return          weak_ordering(weak_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
-    // NOLINTEND(libcpp-robust-against-adl)
+void weak_order() = delete;
 
-        template<class _Tp, class _Up, class _Dp = decay_t<_Tp>>
-            requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
-        _LIBCPP_HIDE_FROM_ABI static constexpr weak_ordering
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<2>) noexcept
-        {
-            partial_ordering __po = (__t <=> __u);
-            if (__po == partial_ordering::less) {
-                return weak_ordering::less;
-            } else if (__po == partial_ordering::equivalent) {
-                return weak_ordering::equivalent;
-            } else if (__po == partial_ordering::greater) {
-                return weak_ordering::greater;
-            } else {
-                // Otherwise, at least one of them is a NaN.
-                bool __t_is_nan = _VSTD::isnan(__t);
-                bool __u_is_nan = _VSTD::isnan(__u);
-                bool __t_is_negative = _VSTD::signbit(__t);
-                bool __u_is_negative = _VSTD::signbit(__u);
-                if (__t_is_nan && __u_is_nan) {
-                    return (__u_is_negative <=> __t_is_negative);
-                } else if (__t_is_nan) {
-                    return __t_is_negative ? weak_ordering::less : weak_ordering::greater;
-                } else {
-                    return __u_is_negative ? weak_ordering::greater : weak_ordering::less;
-                }
-            }
-        }
+struct __fn {
+  // NOLINTBEGIN(libcpp-robust-against-adl) weak_order should use ADL, but only here
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<3>) noexcept(
+      noexcept(weak_ordering(weak_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)))))
+      -> decltype(weak_ordering(weak_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)))) {
+    return weak_ordering(weak_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)));
+  }
+  // NOLINTEND(libcpp-robust-against-adl)
 
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<1>)
-            noexcept(noexcept(weak_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-            -> decltype(      weak_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            { return          weak_ordering(compare_three_way()(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
+  template <class _Tp, class _Up, class _Dp = decay_t<_Tp>>
+    requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
+  _LIBCPP_HIDE_FROM_ABI static constexpr weak_ordering __go(_Tp&& __t, _Up&& __u, __priority_tag<2>) noexcept {
+    partial_ordering __po = (__t <=> __u);
+    if (__po == partial_ordering::less) {
+      return weak_ordering::less;
+    } else if (__po == partial_ordering::equivalent) {
+      return weak_ordering::equivalent;
+    } else if (__po == partial_ordering::greater) {
+      return weak_ordering::greater;
+    } else {
+      // Otherwise, at least one of them is a NaN.
+      bool __t_is_nan      = __math::isnan(__t);
+      bool __u_is_nan      = __math::isnan(__u);
+      bool __t_is_negative = __math::signbit(__t);
+      bool __u_is_negative = __math::signbit(__u);
+      if (__t_is_nan && __u_is_nan) {
+        return (__u_is_negative <=> __t_is_negative);
+      } else if (__t_is_nan) {
+        return __t_is_negative ? weak_ordering::less : weak_ordering::greater;
+      } else {
+        return __u_is_negative ? weak_ordering::greater : weak_ordering::less;
+      }
+    }
+  }
 
-        template<class _Tp, class _Up>
-            requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
-        _LIBCPP_HIDE_FROM_ABI static constexpr auto
-        __go(_Tp&& __t, _Up&& __u, __priority_tag<0>)
-            noexcept(noexcept(weak_ordering(_VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u)))))
-            -> decltype(      weak_ordering(_VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-            { return          weak_ordering(_VSTD::strong_order(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))); }
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<1>) noexcept(
+      noexcept(weak_ordering(compare_three_way()(std::forward<_Tp>(__t), std::forward<_Up>(__u)))))
+      -> decltype(weak_ordering(compare_three_way()(std::forward<_Tp>(__t), std::forward<_Up>(__u)))) {
+    return weak_ordering(compare_three_way()(std::forward<_Tp>(__t), std::forward<_Up>(__u)));
+  }
 
-        template<class _Tp, class _Up>
-        _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
-            noexcept(noexcept(__go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>())))
-            -> decltype(      __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>()))
-            { return          __go(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u), __priority_tag<3>()); }
-    };
+  template <class _Tp, class _Up>
+    requires is_same_v<decay_t<_Tp>, decay_t<_Up>>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_Tp&& __t, _Up&& __u, __priority_tag<0>) noexcept(
+      noexcept(weak_ordering(std::strong_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)))))
+      -> decltype(weak_ordering(std::strong_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)))) {
+    return weak_ordering(std::strong_order(std::forward<_Tp>(__t), std::forward<_Up>(__u)));
+  }
+
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<3>())))
+          -> decltype(__go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<3>())) {
+    return __go(std::forward<_Tp>(__t), std::forward<_Up>(__u), __priority_tag<3>());
+  }
+};
 } // namespace __weak_order
 
 inline namespace __cpo {
-    inline constexpr auto weak_order = __weak_order::__fn{};
+inline constexpr auto weak_order = __weak_order::__fn{};
 } // namespace __cpo
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__concepts/arithmetic.h b/third_party/libcxx/__concepts/arithmetic.h
index 91a0b184b..0c44f1178 100644
--- a/third_party/libcxx/__concepts/arithmetic.h
+++ b/third_party/libcxx/__concepts/arithmetic.h
@@ -26,25 +26,29 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concepts.arithmetic], arithmetic concepts
 
-template<class _Tp>
+template <class _Tp>
 concept integral = is_integral_v<_Tp>;
 
-template<class _Tp>
+template <class _Tp>
 concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;
 
-template<class _Tp>
+template <class _Tp>
 concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
 
-template<class _Tp>
+template <class _Tp>
 concept floating_point = is_floating_point_v<_Tp>;
 
 // Concept helpers for the internal type traits for the fundamental types.
 
 template <class _Tp>
 concept __libcpp_unsigned_integer = __libcpp_is_unsigned_integer<_Tp>::value;
+
 template <class _Tp>
 concept __libcpp_signed_integer = __libcpp_is_signed_integer<_Tp>::value;
 
+template <class _Tp>
+concept __libcpp_integer = __libcpp_unsigned_integer<_Tp> || __libcpp_signed_integer<_Tp>;
+
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__concepts/assignable.h b/third_party/libcxx/__concepts/assignable.h
index 2dabae576..7423daabb 100644
--- a/third_party/libcxx/__concepts/assignable.h
+++ b/third_party/libcxx/__concepts/assignable.h
@@ -26,13 +26,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.assignable]
 
-template<class _Lhs, class _Rhs>
+template <class _Lhs, class _Rhs>
 concept assignable_from =
-  is_lvalue_reference_v<_Lhs> &&
-  common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
-  requires (_Lhs __lhs, _Rhs&& __rhs) {
-    { __lhs = _VSTD::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
-  };
+    is_lvalue_reference_v<_Lhs> &&
+    common_reference_with<__make_const_lvalue_ref<_Lhs>, __make_const_lvalue_ref<_Rhs>> &&
+    requires(_Lhs __lhs, _Rhs&& __rhs) {
+      { __lhs = std::forward<_Rhs>(__rhs) } -> same_as<_Lhs>;
+    };
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__concepts/boolean_testable.h b/third_party/libcxx/__concepts/boolean_testable.h
index 8efb6e5ff..b379fe9c5 100644
--- a/third_party/libcxx/__concepts/boolean_testable.h
+++ b/third_party/libcxx/__concepts/boolean_testable.h
@@ -23,12 +23,12 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concepts.booleantestable]
 
-template<class _Tp>
+template <class _Tp>
 concept __boolean_testable_impl = convertible_to<_Tp, bool>;
 
-template<class _Tp>
+template <class _Tp>
 concept __boolean_testable = __boolean_testable_impl<_Tp> && requires(_Tp&& __t) {
-  { !_VSTD::forward<_Tp>(__t) } -> __boolean_testable_impl;
+  { !std::forward<_Tp>(__t) } -> __boolean_testable_impl;
 };
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__concepts/class_or_enum.h b/third_party/libcxx/__concepts/class_or_enum.h
index 04c24bd98..2739e31e1 100644
--- a/third_party/libcxx/__concepts/class_or_enum.h
+++ b/third_party/libcxx/__concepts/class_or_enum.h
@@ -25,14 +25,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Whether a type is a class type or enumeration type according to the Core wording.
 
-template<class _Tp>
+template <class _Tp>
 concept __class_or_enum = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
 
-// Work around Clang bug https://llvm.org/PR52970
-// TODO: remove this workaround once libc++ no longer has to support Clang 13 (it was fixed in Clang 14).
-template<class _Tp>
-concept __workaround_52970 = is_class_v<__remove_cvref_t<_Tp>> || is_union_v<__remove_cvref_t<_Tp>>;
-
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__concepts/common_reference_with.h b/third_party/libcxx/__concepts/common_reference_with.h
index 6ad0db224..4eb687e07 100644
--- a/third_party/libcxx/__concepts/common_reference_with.h
+++ b/third_party/libcxx/__concepts/common_reference_with.h
@@ -24,11 +24,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.commonref]
 
-template<class _Tp, class _Up>
+template <class _Tp, class _Up>
 concept common_reference_with =
-  same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
-  convertible_to<_Tp, common_reference_t<_Tp, _Up>> &&
-  convertible_to<_Up, common_reference_t<_Tp, _Up>>;
+    same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>> &&
+    convertible_to<_Tp, common_reference_t<_Tp, _Up>> && convertible_to<_Up, common_reference_t<_Tp, _Up>>;
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__concepts/common_with.h b/third_party/libcxx/__concepts/common_with.h
index e159bcce9..85abb05ef 100644
--- a/third_party/libcxx/__concepts/common_with.h
+++ b/third_party/libcxx/__concepts/common_with.h
@@ -27,21 +27,23 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.common]
 
-template<class _Tp, class _Up>
+// clang-format off
+template <class _Tp, class _Up>
 concept common_with =
-  same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
-  requires {
-    static_cast<common_type_t<_Tp, _Up>>(std::declval<_Tp>());
-    static_cast<common_type_t<_Tp, _Up>>(std::declval<_Up>());
-  } &&
-  common_reference_with<
-    add_lvalue_reference_t<const _Tp>,
-    add_lvalue_reference_t<const _Up>> &&
-  common_reference_with<
-    add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
-    common_reference_t<
-      add_lvalue_reference_t<const _Tp>,
-      add_lvalue_reference_t<const _Up>>>;
+    same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>> &&
+    requires {
+        static_cast<common_type_t<_Tp, _Up>>(std::declval<_Tp>());
+        static_cast<common_type_t<_Tp, _Up>>(std::declval<_Up>());
+    } &&
+    common_reference_with<
+        add_lvalue_reference_t<const _Tp>,
+        add_lvalue_reference_t<const _Up>> &&
+    common_reference_with<
+        add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
+        common_reference_t<
+            add_lvalue_reference_t<const _Tp>,
+            add_lvalue_reference_t<const _Up>>>;
+// clang-format on
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__concepts/constructible.h b/third_party/libcxx/__concepts/constructible.h
index 6e3862c51..835a44429 100644
--- a/third_party/libcxx/__concepts/constructible.h
+++ b/third_party/libcxx/__concepts/constructible.h
@@ -23,31 +23,30 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 // [concept.constructible]
-template<class _Tp, class... _Args>
-concept constructible_from =
-    destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
+template <class _Tp, class... _Args>
+concept constructible_from = destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
 
 // [concept.default.init]
 
-template<class _Tp>
+template <class _Tp>
 concept __default_initializable = requires { ::new _Tp; };
 
-template<class _Tp>
-concept default_initializable = constructible_from<_Tp> &&
-    requires { _Tp{}; } && __default_initializable<_Tp>;
+template <class _Tp>
+concept default_initializable = constructible_from<_Tp> && requires { _Tp{}; } && __default_initializable<_Tp>;
 
 // [concept.moveconstructible]
-template<class _Tp>
-concept move_constructible =
-  constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
+template <class _Tp>
+concept move_constructible = constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
 
 // [concept.copyconstructible]
-template<class _Tp>
+// clang-format off
+template <class _Tp>
 concept copy_constructible =
-  move_constructible<_Tp> &&
-  constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
-  constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
-  constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
+    move_constructible<_Tp> &&
+    constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp> &&
+    constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp> &&
+    constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
+// clang-format on
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__concepts/convertible_to.h b/third_party/libcxx/__concepts/convertible_to.h
index 20ee31bc0..6d5b6c126 100644
--- a/third_party/libcxx/__concepts/convertible_to.h
+++ b/third_party/libcxx/__concepts/convertible_to.h
@@ -23,12 +23,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.convertible]
 
-template<class _From, class _To>
-concept convertible_to =
-  is_convertible_v<_From, _To> &&
-  requires {
-    static_cast<_To>(std::declval<_From>());
-  };
+template <class _From, class _To>
+concept convertible_to = is_convertible_v<_From, _To> && requires { static_cast<_To>(std::declval<_From>()); };
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__concepts/copyable.h b/third_party/libcxx/__concepts/copyable.h
index 0d6dd50cf..2bf0ad42f 100644
--- a/third_party/libcxx/__concepts/copyable.h
+++ b/third_party/libcxx/__concepts/copyable.h
@@ -24,13 +24,15 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concepts.object]
 
-template<class _Tp>
+// clang-format off
+template <class _Tp>
 concept copyable =
-  copy_constructible<_Tp> &&
-  movable<_Tp> &&
-  assignable_from<_Tp&, _Tp&> &&
-  assignable_from<_Tp&, const _Tp&> &&
-  assignable_from<_Tp&, const _Tp>;
+    copy_constructible<_Tp> &&
+    movable<_Tp> &&
+    assignable_from<_Tp&, _Tp&> &&
+    assignable_from<_Tp&, const _Tp&> &&
+    assignable_from<_Tp&, const _Tp>;
+// clang-format on
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__concepts/derived_from.h b/third_party/libcxx/__concepts/derived_from.h
index 1cbe458e2..9875faee8 100644
--- a/third_party/libcxx/__concepts/derived_from.h
+++ b/third_party/libcxx/__concepts/derived_from.h
@@ -23,10 +23,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.derived]
 
-template<class _Dp, class _Bp>
-concept derived_from =
-  is_base_of_v<_Bp, _Dp> &&
-  is_convertible_v<const volatile _Dp*, const volatile _Bp*>;
+template <class _Dp, class _Bp>
+concept derived_from = is_base_of_v<_Bp, _Dp> && is_convertible_v<const volatile _Dp*, const volatile _Bp*>;
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__concepts/destructible.h b/third_party/libcxx/__concepts/destructible.h
index 8da9c378b..28b4b1bc2 100644
--- a/third_party/libcxx/__concepts/destructible.h
+++ b/third_party/libcxx/__concepts/destructible.h
@@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.destructible]
 
-template<class _Tp>
+template <class _Tp>
 concept destructible = is_nothrow_destructible_v<_Tp>;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__concepts/different_from.h b/third_party/libcxx/__concepts/different_from.h
index 5ef1467ac..fd31f6e25 100644
--- a/third_party/libcxx/__concepts/different_from.h
+++ b/third_party/libcxx/__concepts/different_from.h
@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-template<class _Tp, class _Up>
+template <class _Tp, class _Up>
 concept __different_from = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__concepts/equality_comparable.h b/third_party/libcxx/__concepts/equality_comparable.h
index f1062884e..278fc7640 100644
--- a/third_party/libcxx/__concepts/equality_comparable.h
+++ b/third_party/libcxx/__concepts/equality_comparable.h
@@ -25,27 +25,29 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.equalitycomparable]
 
-template<class _Tp, class _Up>
+template <class _Tp, class _Up>
 concept __weakly_equality_comparable_with =
-  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
-    { __t == __u } -> __boolean_testable;
-    { __t != __u } -> __boolean_testable;
-    { __u == __t } -> __boolean_testable;
-    { __u != __t } -> __boolean_testable;
-  };
+    requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+      { __t == __u } -> __boolean_testable;
+      { __t != __u } -> __boolean_testable;
+      { __u == __t } -> __boolean_testable;
+      { __u != __t } -> __boolean_testable;
+    };
 
-template<class _Tp>
+template <class _Tp>
 concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
 
-template<class _Tp, class _Up>
+// clang-format off
+template <class _Tp, class _Up>
 concept equality_comparable_with =
-  equality_comparable<_Tp> && equality_comparable<_Up> &&
-  common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
-  equality_comparable<
-    common_reference_t<
-      __make_const_lvalue_ref<_Tp>,
-      __make_const_lvalue_ref<_Up>>> &&
-  __weakly_equality_comparable_with<_Tp, _Up>;
+    equality_comparable<_Tp> && equality_comparable<_Up> &&
+    common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
+    equality_comparable<
+        common_reference_t<
+            __make_const_lvalue_ref<_Tp>,
+            __make_const_lvalue_ref<_Up>>> &&
+    __weakly_equality_comparable_with<_Tp, _Up>;
+// clang-format on
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__concepts/invocable.h b/third_party/libcxx/__concepts/invocable.h
index 59eab01f8..8a29398b3 100644
--- a/third_party/libcxx/__concepts/invocable.h
+++ b/third_party/libcxx/__concepts/invocable.h
@@ -23,14 +23,14 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.invocable]
 
-template<class _Fn, class... _Args>
+template <class _Fn, class... _Args>
 concept invocable = requires(_Fn&& __fn, _Args&&... __args) {
-  _VSTD::invoke(_VSTD::forward<_Fn>(__fn), _VSTD::forward<_Args>(__args)...); // not required to be equality preserving
+  std::invoke(std::forward<_Fn>(__fn), std::forward<_Args>(__args)...); // not required to be equality preserving
 };
 
 // [concept.regular.invocable]
 
-template<class _Fn, class... _Args>
+template <class _Fn, class... _Args>
 concept regular_invocable = invocable<_Fn, _Args...>;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__concepts/movable.h b/third_party/libcxx/__concepts/movable.h
index f37d49f04..bc5b9d767 100644
--- a/third_party/libcxx/__concepts/movable.h
+++ b/third_party/libcxx/__concepts/movable.h
@@ -25,12 +25,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concepts.object]
 
-template<class _Tp>
-concept movable =
-  is_object_v<_Tp> &&
-  move_constructible<_Tp> &&
-  assignable_from<_Tp&, _Tp> &&
-  swappable<_Tp>;
+template <class _Tp>
+concept movable = is_object_v<_Tp> && move_constructible<_Tp> && assignable_from<_Tp&, _Tp> && swappable<_Tp>;
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__concepts/predicate.h b/third_party/libcxx/__concepts/predicate.h
index b09183c5c..00731efc8 100644
--- a/third_party/libcxx/__concepts/predicate.h
+++ b/third_party/libcxx/__concepts/predicate.h
@@ -24,9 +24,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.predicate]
 
-template<class _Fn, class... _Args>
-concept predicate =
-  regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
+template <class _Fn, class... _Args>
+concept predicate = regular_invocable<_Fn, _Args...> && __boolean_testable<invoke_result_t<_Fn, _Args...>>;
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__concepts/regular.h b/third_party/libcxx/__concepts/regular.h
index 93fb7016c..9f3d8bf30 100644
--- a/third_party/libcxx/__concepts/regular.h
+++ b/third_party/libcxx/__concepts/regular.h
@@ -23,7 +23,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.object]
 
-template<class _Tp>
+template <class _Tp>
 concept regular = semiregular<_Tp> && equality_comparable<_Tp>;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__concepts/relation.h b/third_party/libcxx/__concepts/relation.h
index 218afef21..7545a7db9 100644
--- a/third_party/libcxx/__concepts/relation.h
+++ b/third_party/libcxx/__concepts/relation.h
@@ -22,19 +22,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.relation]
 
-template<class _Rp, class _Tp, class _Up>
+template <class _Rp, class _Tp, class _Up>
 concept relation =
-  predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> &&
-  predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>;
+    predicate<_Rp, _Tp, _Tp> && predicate<_Rp, _Up, _Up> && predicate<_Rp, _Tp, _Up> && predicate<_Rp, _Up, _Tp>;
 
 // [concept.equiv]
 
-template<class _Rp, class _Tp, class _Up>
+template <class _Rp, class _Tp, class _Up>
 concept equivalence_relation = relation<_Rp, _Tp, _Up>;
 
 // [concept.strictweakorder]
 
-template<class _Rp, class _Tp, class _Up>
+template <class _Rp, class _Tp, class _Up>
 concept strict_weak_order = relation<_Rp, _Tp, _Up>;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__concepts/same_as.h b/third_party/libcxx/__concepts/same_as.h
index b86cadaa1..4241131c7 100644
--- a/third_party/libcxx/__concepts/same_as.h
+++ b/third_party/libcxx/__concepts/same_as.h
@@ -22,10 +22,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.same]
 
-template<class _Tp, class _Up>
+template <class _Tp, class _Up>
 concept __same_as_impl = _IsSame<_Tp, _Up>::value;
 
-template<class _Tp, class _Up>
+template <class _Tp, class _Up>
 concept same_as = __same_as_impl<_Tp, _Up> && __same_as_impl<_Up, _Tp>;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__concepts/semiregular.h b/third_party/libcxx/__concepts/semiregular.h
index ae2f3c669..7a159d17d 100644
--- a/third_party/libcxx/__concepts/semiregular.h
+++ b/third_party/libcxx/__concepts/semiregular.h
@@ -23,7 +23,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.object]
 
-template<class _Tp>
+template <class _Tp>
 concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__concepts/swappable.h b/third_party/libcxx/__concepts/swappable.h
index 859255dec..d339488a0 100644
--- a/third_party/libcxx/__concepts/swappable.h
+++ b/third_party/libcxx/__concepts/swappable.h
@@ -15,8 +15,8 @@
 #include <__concepts/constructible.h>
 #include <__config>
 #include <__type_traits/extent.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/exchange.h>
 #include <__utility/forward.h>
@@ -28,6 +28,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -37,85 +40,84 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __swap {
 
-  template<class _Tp>
-  void swap(_Tp&, _Tp&) = delete;
+template <class _Tp>
+void swap(_Tp&, _Tp&) = delete;
 
-  template<class _Tp, class _Up>
-  concept __unqualified_swappable_with =
+// clang-format off
+template <class _Tp, class _Up>
+concept __unqualified_swappable_with =
     (__class_or_enum<remove_cvref_t<_Tp>> || __class_or_enum<remove_cvref_t<_Up>>) &&
     requires(_Tp&& __t, _Up&& __u) {
-      swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
+        swap(std::forward<_Tp>(__t), std::forward<_Up>(__u));
     };
+// clang-format on
 
-  struct __fn;
+struct __fn;
 
-  template<class _Tp, class _Up, size_t _Size>
-  concept __swappable_arrays =
-    !__unqualified_swappable_with<_Tp(&)[_Size], _Up(&)[_Size]> &&
+// clang-format off
+template <class _Tp, class _Up, size_t _Size>
+concept __swappable_arrays =
+    !__unqualified_swappable_with<_Tp (&)[_Size], _Up (&)[_Size]> &&
     extent_v<_Tp> == extent_v<_Up> &&
-    requires(_Tp(& __t)[_Size], _Up(& __u)[_Size], const __fn& __swap) {
-      __swap(__t[0], __u[0]);
+    requires(_Tp (&__t)[_Size], _Up (&__u)[_Size], const __fn& __swap) {
+        __swap(__t[0], __u[0]);
     };
+// clang-format on
 
-  template<class _Tp>
-  concept __exchangeable =
-    !__unqualified_swappable_with<_Tp&, _Tp&> &&
-    move_constructible<_Tp> &&
-    assignable_from<_Tp&, _Tp>;
+template <class _Tp>
+concept __exchangeable =
+    !__unqualified_swappable_with<_Tp&, _Tp&> && move_constructible<_Tp> && assignable_from<_Tp&, _Tp>;
 
-  struct __fn {
-    // 2.1   `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
-    // *The name `swap` is used here unqualified.
-    template<class _Tp, class _Up>
-      requires __unqualified_swappable_with<_Tp, _Up>
-    _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp&& __t, _Up&& __u) const
-      noexcept(noexcept(swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u))))
-    {
-      swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
+struct __fn {
+  // 2.1   `S` is `(void)swap(E1, E2)`* if `E1` or `E2` has class or enumeration type and...
+  // *The name `swap` is used here unqualified.
+  template <class _Tp, class _Up>
+    requires __unqualified_swappable_with<_Tp, _Up>
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(swap(std::forward<_Tp>(__t), std::forward<_Up>(__u)))) {
+    swap(std::forward<_Tp>(__t), std::forward<_Up>(__u));
+  }
+
+  // 2.2   Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
+  template <class _Tp, class _Up, size_t _Size>
+    requires __swappable_arrays<_Tp, _Up, _Size>
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp (&__t)[_Size], _Up (&__u)[_Size]) const
+      noexcept(noexcept((*this)(*__t, *__u))) {
+    // TODO(cjdb): replace with `ranges::swap_ranges`.
+    for (size_t __i = 0; __i < _Size; ++__i) {
+      (*this)(__t[__i], __u[__i]);
     }
+  }
 
-    // 2.2   Otherwise, if `E1` and `E2` are lvalues of array types with equal extent and...
-    template<class _Tp, class _Up, size_t _Size>
-      requires __swappable_arrays<_Tp, _Up, _Size>
-    _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp(& __t)[_Size], _Up(& __u)[_Size]) const
-      noexcept(noexcept((*this)(*__t, *__u)))
-    {
-      // TODO(cjdb): replace with `ranges::swap_ranges`.
-      for (size_t __i = 0; __i < _Size; ++__i) {
-        (*this)(__t[__i], __u[__i]);
-      }
-    }
-
-    // 2.3   Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
-    template<__exchangeable _Tp>
-    _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp& __x, _Tp& __y) const
-      noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>)
-    {
-      __y = _VSTD::exchange(__x, _VSTD::move(__y));
-    }
-  };
+  // 2.3   Otherwise, if `E1` and `E2` are lvalues of the same type `T` that models...
+  template <__exchangeable _Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp& __x, _Tp& __y) const
+      noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_assignable_v<_Tp>) {
+    __y = std::exchange(__x, std::move(__y));
+  }
+};
 } // namespace __swap
 
 inline namespace __cpo {
-  inline constexpr auto swap = __swap::__fn{};
+inline constexpr auto swap = __swap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
-template<class _Tp>
+template <class _Tp>
 concept swappable = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };
 
-template<class _Tp, class _Up>
-concept swappable_with =
-  common_reference_with<_Tp, _Up> &&
-  requires(_Tp&& __t, _Up&& __u) {
-    ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Tp>(__t));
-    ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Up>(__u));
-    ranges::swap(_VSTD::forward<_Tp>(__t), _VSTD::forward<_Up>(__u));
-    ranges::swap(_VSTD::forward<_Up>(__u), _VSTD::forward<_Tp>(__t));
-  };
+template <class _Tp, class _Up>
+concept swappable_with = common_reference_with<_Tp, _Up> && requires(_Tp&& __t, _Up&& __u) {
+  ranges::swap(std::forward<_Tp>(__t), std::forward<_Tp>(__t));
+  ranges::swap(std::forward<_Up>(__u), std::forward<_Up>(__u));
+  ranges::swap(std::forward<_Tp>(__t), std::forward<_Up>(__u));
+  ranges::swap(std::forward<_Up>(__u), std::forward<_Tp>(__t));
+};
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___CONCEPTS_SWAPPABLE_H
diff --git a/third_party/libcxx/__concepts/totally_ordered.h b/third_party/libcxx/__concepts/totally_ordered.h
index 350eff338..186c3b430 100644
--- a/third_party/libcxx/__concepts/totally_ordered.h
+++ b/third_party/libcxx/__concepts/totally_ordered.h
@@ -25,31 +25,32 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [concept.totallyordered]
 
-template<class _Tp, class _Up>
-concept __partially_ordered_with =
-  requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
-    { __t <  __u } -> __boolean_testable;
-    { __t >  __u } -> __boolean_testable;
-    { __t <= __u } -> __boolean_testable;
-    { __t >= __u } -> __boolean_testable;
-    { __u <  __t } -> __boolean_testable;
-    { __u >  __t } -> __boolean_testable;
-    { __u <= __t } -> __boolean_testable;
-    { __u >= __t } -> __boolean_testable;
-  };
+template <class _Tp, class _Up>
+concept __partially_ordered_with = requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {
+  { __t < __u } -> __boolean_testable;
+  { __t > __u } -> __boolean_testable;
+  { __t <= __u } -> __boolean_testable;
+  { __t >= __u } -> __boolean_testable;
+  { __u < __t } -> __boolean_testable;
+  { __u > __t } -> __boolean_testable;
+  { __u <= __t } -> __boolean_testable;
+  { __u >= __t } -> __boolean_testable;
+};
 
-template<class _Tp>
+template <class _Tp>
 concept totally_ordered = equality_comparable<_Tp> && __partially_ordered_with<_Tp, _Tp>;
 
-template<class _Tp, class _Up>
+// clang-format off
+template <class _Tp, class _Up>
 concept totally_ordered_with =
-  totally_ordered<_Tp> && totally_ordered<_Up> &&
-  equality_comparable_with<_Tp, _Up> &&
-  totally_ordered<
-    common_reference_t<
-      __make_const_lvalue_ref<_Tp>,
-      __make_const_lvalue_ref<_Up>>> &&
-  __partially_ordered_with<_Tp, _Up>;
+    totally_ordered<_Tp> && totally_ordered<_Up> &&
+    equality_comparable_with<_Tp, _Up> &&
+    totally_ordered<
+        common_reference_t<
+            __make_const_lvalue_ref<_Tp>,
+            __make_const_lvalue_ref<_Up>>> &&
+    __partially_ordered_with<_Tp, _Up>;
+// clang-format on
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__condition_variable/condition_variable.h b/third_party/libcxx/__condition_variable/condition_variable.h
index 8fc80b633..de35aaca1 100644
--- a/third_party/libcxx/__condition_variable/condition_variable.h
+++ b/third_party/libcxx/__condition_variable/condition_variable.h
@@ -9,6 +9,7 @@
 #ifndef _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
 #define _LIBCPP___CONDITION_VARIABLE_CONDITION_VARIABLE_H
 
+#include <__chrono/duration.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
@@ -16,10 +17,11 @@
 #include <__mutex/mutex.h>
 #include <__mutex/unique_lock.h>
 #include <__system_error/system_error.h>
-#include <__threading_support>
+#include <__thread/support.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_floating_point.h>
 #include <__utility/move.h>
+#include <limits>
 #include <ratio>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -37,7 +39,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 _LIBCPP_DECLARE_STRONG_ENUM(cv_status){no_timeout, timeout};
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(cv_status)
 
-class _LIBCPP_TYPE_VIS condition_variable {
+class _LIBCPP_EXPORTED_FROM_ABI condition_variable {
   __libcpp_condvar_t __cv_ = _LIBCPP_CONDVAR_INITIALIZER;
 
 public:
@@ -91,9 +93,8 @@ private:
 };
 #endif // !_LIBCPP_HAS_NO_THREADS
 
-template <class _Rep, class _Period>
-inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<is_floating_point<_Rep>::value, chrono::nanoseconds>
-__safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d) {
+template <class _Rep, class _Period, __enable_if_t<is_floating_point<_Rep>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI chrono::nanoseconds __safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d) {
   using namespace chrono;
   using __ratio       = ratio_divide<_Period, nano>;
   using __ns_rep      = nanoseconds::rep;
@@ -112,9 +113,8 @@ __safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d) {
   return nanoseconds(static_cast<__ns_rep>(__result_float));
 }
 
-template <class _Rep, class _Period>
-inline _LIBCPP_HIDE_FROM_ABI __enable_if_t<!is_floating_point<_Rep>::value, chrono::nanoseconds>
-__safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d) {
+template <class _Rep, class _Period, __enable_if_t<!is_floating_point<_Rep>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI chrono::nanoseconds __safe_nanosecond_cast(chrono::duration<_Rep, _Period> __d) {
   using namespace chrono;
   if (__d.count() == 0) {
     return nanoseconds(0);
diff --git a/third_party/libcxx/__config b/third_party/libcxx/__config
index f474f9880..108f70082 100644
--- a/third_party/libcxx/__config
+++ b/third_party/libcxx/__config
@@ -11,184 +11,149 @@
 #define _LIBCPP___CONFIG
 
 #include <__config_site>
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#    define _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
-#  endif
-#endif
+#include <__configuration/abi.h>
+#include <__configuration/availability.h>
+#include <__configuration/compiler.h>
+#include <__configuration/platform.h>
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #  pragma GCC system_header
 #endif
 
-#if defined(__apple_build_version__)
-// Given AppleClang XX.Y.Z, _LIBCPP_APPLE_CLANG_VER is XXYZ (e.g. AppleClang 14.0.3 => 1403)
-#  define _LIBCPP_COMPILER_CLANG_BASED
-#  define _LIBCPP_APPLE_CLANG_VER (__apple_build_version__ / 10000)
-#elif defined(__clang__)
-#  define _LIBCPP_COMPILER_CLANG_BASED
-#  define _LIBCPP_CLANG_VER (__clang_major__ * 100 + __clang_minor__)
-#elif defined(__GNUC__)
-#  define _LIBCPP_COMPILER_GCC
-#endif
-
 #ifdef __cplusplus
 
+// The attributes supported by clang are documented at https://clang.llvm.org/docs/AttributeReference.html
+
 // _LIBCPP_VERSION represents the version of libc++, which matches the version of LLVM.
 // Given a LLVM release LLVM XX.YY.ZZ (e.g. LLVM 17.0.1 == 17.00.01), _LIBCPP_VERSION is
 // defined to XXYYZZ.
-#  define _LIBCPP_VERSION 170000
+#  define _LIBCPP_VERSION 190000
 
 #  define _LIBCPP_CONCAT_IMPL(_X, _Y) _X##_Y
 #  define _LIBCPP_CONCAT(_X, _Y) _LIBCPP_CONCAT_IMPL(_X, _Y)
 
-// Valid C++ identifier that revs with every libc++ version. This can be used to
-// generate identifiers that must be unique for every released libc++ version.
-#  define _LIBCPP_VERSIONED_IDENTIFIER _LIBCPP_CONCAT(v, _LIBCPP_VERSION)
-
 #  if __STDC_HOSTED__ == 0
 #    define _LIBCPP_FREESTANDING
 #  endif
 
-// NOLINTBEGIN(libcpp-cpp-version-check)
-#  ifndef _LIBCPP_STD_VER
-#    if __cplusplus <= 201103L
-#      define _LIBCPP_STD_VER 11
-#    elif __cplusplus <= 201402L
-#      define _LIBCPP_STD_VER 14
-#    elif __cplusplus <= 201703L
-#      define _LIBCPP_STD_VER 17
-#    elif __cplusplus <= 202002L
-#      define _LIBCPP_STD_VER 20
-#    elif __cplusplus <= 202302L
-#      define _LIBCPP_STD_VER 23
-#    else
-// Expected release year of the next C++ standard
-#      define _LIBCPP_STD_VER 26
-#    endif
-#  endif // _LIBCPP_STD_VER
-// NOLINTEND(libcpp-cpp-version-check)
+// HARDENING {
 
-#  if defined(__ELF__)
-#    define _LIBCPP_OBJECT_FORMAT_ELF 1
-#  elif defined(__MACH__)
-#    define _LIBCPP_OBJECT_FORMAT_MACHO 1
-#  elif defined(_WIN32)
-#    define _LIBCPP_OBJECT_FORMAT_COFF 1
-#  elif defined(__wasm__)
-#    define _LIBCPP_OBJECT_FORMAT_WASM 1
-#  elif defined(_AIX)
-#    define _LIBCPP_OBJECT_FORMAT_XCOFF 1
-#  else
-// ... add new file formats here ...
+// This is for backward compatibility -- make enabling `_LIBCPP_ENABLE_ASSERTIONS` (which predates hardening modes)
+// equivalent to setting the extensive mode. This is deprecated and will be removed in LLVM 20.
+#  ifdef _LIBCPP_ENABLE_ASSERTIONS
+#    warning "_LIBCPP_ENABLE_ASSERTIONS is deprecated, please use _LIBCPP_HARDENING_MODE instead"
+#    if _LIBCPP_ENABLE_ASSERTIONS != 0 && _LIBCPP_ENABLE_ASSERTIONS != 1
+#      error "_LIBCPP_ENABLE_ASSERTIONS must be set to 0 or 1"
+#    endif
+#    if _LIBCPP_ENABLE_ASSERTIONS
+#      define _LIBCPP_HARDENING_MODE _LIBCPP_HARDENING_MODE_EXTENSIVE
+#    endif
 #  endif
 
-#  if _LIBCPP_ABI_VERSION >= 2
-// Change short string representation so that string data starts at offset 0,
-// improving its alignment in some cases.
-#    define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
-// Fix deque iterator type in order to support incomplete types.
-#    define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
-// Fix undefined behavior in how std::list stores its linked nodes.
-#    define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB
-// Fix undefined behavior in  how __tree stores its end and parent nodes.
-#    define _LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB
-// Fix undefined behavior in how __hash_table stores its pointer types.
-#    define _LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB
-#    define _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB
-#    define _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
-// Define a key function for `bad_function_call` in the library, to centralize
-// its vtable and typeinfo to libc++ rather than having all other libraries
-// using that class define their own copies.
-#    define _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
-// Override the default return value of exception::what() for
-// bad_function_call::what() with a string that is specific to
-// bad_function_call (see http://wg21.link/LWG2233). This is an ABI break
-// because it changes the vtable layout of bad_function_call.
-#    define _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
-// Enable optimized version of __do_get_(un)signed which avoids redundant copies.
-#    define _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
-// Give reverse_iterator<T> one data member of type T, not two.
-// Also, in C++17 and later, don't derive iterator types from std::iterator.
-#    define _LIBCPP_ABI_NO_ITERATOR_BASES
-// Use the smallest possible integer type to represent the index of the variant.
-// Previously libc++ used "unsigned int" exclusively.
-#    define _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
-// Unstable attempt to provide a more optimized std::function
-#    define _LIBCPP_ABI_OPTIMIZED_FUNCTION
-// All the regex constants must be distinct and nonzero.
-#    define _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
-// Re-worked external template instantiations for std::string with a focus on
-// performance and fast-path inlining.
-#    define _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
-// Enable clang::trivial_abi on std::unique_ptr.
-#    define _LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI
-// Enable clang::trivial_abi on std::shared_ptr and std::weak_ptr
-#    define _LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI
-// std::random_device holds some state when it uses an implementation that gets
-// entropy from a file (see _LIBCPP_USING_DEV_RANDOM). When switching from this
-// implementation to another one on a platform that has already shipped
-// std::random_device, one needs to retain the same object layout to remain ABI
-// compatible. This switch removes these workarounds for platforms that don't care
-// about ABI compatibility.
-#    define _LIBCPP_ABI_NO_RANDOM_DEVICE_COMPATIBILITY_LAYOUT
-// Don't export the legacy __basic_string_common class and its methods from the built library.
-#    define _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
-// Don't export the legacy __vector_base_common class and its methods from the built library.
-#    define _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON
-// According to the Standard, `bitset::operator[] const` returns bool
-#    define _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
-// Fix the implementation of CityHash used for std::hash<fundamental-type>.
-// This is an ABI break because `std::hash` will return a different result,
-// which means that hashing the same object in translation units built against
-// different versions of libc++ can return inconsistent results. This is especially
-// tricky since std::hash is used in the implementation of unordered containers.
+// The library provides the macro `_LIBCPP_HARDENING_MODE` which can be set to one of the following values:
 //
-// The incorrect implementation of CityHash has the problem that it drops some
-// bits on the floor.
-#    define _LIBCPP_ABI_FIX_CITYHASH_IMPLEMENTATION
-// Remove the base 10 implementation of std::to_chars from the dylib.
-// The implementation moved to the header, but we still export the symbols from
-// the dylib for backwards compatibility.
-#    define _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
-#  elif _LIBCPP_ABI_VERSION == 1
-#    if !(defined(_LIBCPP_OBJECT_FORMAT_COFF) || defined(_LIBCPP_OBJECT_FORMAT_XCOFF))
-// Enable compiling copies of now inline methods into the dylib to support
-// applications compiled against older libraries. This is unnecessary with
-// COFF dllexport semantics, since dllexport forces a non-inline definition
-// of inline functions to be emitted anyway. Our own non-inline copy would
-// conflict with the dllexport-emitted copy, so we disable it. For XCOFF,
-// the linker will take issue with the symbols in the shared object if the
-// weak inline methods get visibility (such as from -fvisibility-inlines-hidden),
-// so disable it.
-#      define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
-#    endif
-// Feature macros for disabling pre ABI v1 features. All of these options
-// are deprecated.
-#    if defined(__FreeBSD__)
-#      define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
-#    endif
-// For XCOFF linkers, we have problems if we see a weak hidden version of a symbol
-// in user code (like you get with -fvisibility-inlines-hidden) and then a strong def
-// in the library, so we need to always rely on the library version.
-#    if defined(_AIX)
-#      define _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
+// - `_LIBCPP_HARDENING_MODE_NONE`;
+// - `_LIBCPP_HARDENING_MODE_FAST`;
+// - `_LIBCPP_HARDENING_MODE_EXTENSIVE`;
+// - `_LIBCPP_HARDENING_MODE_DEBUG`.
+//
+// These values have the following effects:
+//
+// - `_LIBCPP_HARDENING_MODE_NONE` -- sets the hardening mode to "none" which disables all runtime hardening checks;
+//
+// - `_LIBCPP_HARDENING_MODE_FAST` -- sets that hardening mode to "fast". The fast mode enables security-critical checks
+//   that can be done with relatively little runtime overhead in constant time;
+//
+// - `_LIBCPP_HARDENING_MODE_EXTENSIVE` -- sets the hardening mode to "extensive". The extensive mode is a superset of
+//   the fast mode that additionally enables checks that are relatively cheap and prevent common types of logic errors
+//   but are not necessarily security-critical;
+//
+// - `_LIBCPP_HARDENING_MODE_DEBUG` -- sets the hardening mode to "debug". The debug mode is a superset of the extensive
+//   mode and enables all checks available in the library, including internal assertions. Checks that are part of the
+//   debug mode can be very expensive and thus the debug mode is intended to be used for testing, not in production.
+
+// Inside the library, assertions are categorized so they can be cherry-picked based on the chosen hardening mode. These
+// macros are only for internal use -- users should only pick one of the high-level hardening modes described above.
+//
+// - `_LIBCPP_ASSERT_VALID_INPUT_RANGE` -- checks that ranges (whether expressed as an iterator pair, an iterator and
+//   a sentinel, an iterator and a count, or a `std::range`) given as input to library functions are valid:
+//   - the sentinel is reachable from the begin iterator;
+//   - TODO(hardening): both iterators refer to the same container.
+//
+// - `_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS` -- checks that any attempts to access a container element, whether through
+//   the container object or through an iterator, are valid and do not attempt to go out of bounds or otherwise access
+//   a non-existent element. For iterator checks to work, bounded iterators must be enabled in the ABI. Types like
+//   `optional` and `function` are considered one-element containers for the purposes of this check.
+//
+// - `_LIBCPP_ASSERT_NON_NULL` -- checks that the pointer being dereferenced is not null. On most modern platforms zero
+//   address does not refer to an actual location in memory, so a null pointer dereference would not compromize the
+//   memory security of a program (however, it is still undefined behavior that can result in strange errors due to
+//   compiler optimizations).
+//
+// - `_LIBCPP_ASSERT_NON_OVERLAPPING_RANGES` -- for functions that take several ranges as arguments, checks that the
+//   given ranges do not overlap.
+//
+// - `_LIBCPP_ASSERT_VALID_DEALLOCATION` -- checks that an attempt to deallocate memory is valid (e.g. the given object
+//   was allocated by the given allocator). Violating this category typically results in a memory leak.
+//
+// - `_LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL` -- checks that a call to an external API doesn't fail in
+//   an unexpected manner. This includes triggering documented cases of undefined behavior in an external library (like
+//   attempting to unlock an unlocked mutex in pthreads). Any API external to the library falls under this category
+//   (from system calls to compiler intrinsics). We generally don't expect these failures to compromize memory safety or
+//   otherwise create an immediate security issue.
+//
+// - `_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR` -- checks any operations that exchange nodes between containers to make sure
+//   the containers have compatible allocators.
+//
+// - `_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN` -- checks that the given argument is within the domain of valid arguments
+//   for the function. Violating this typically produces an incorrect result (e.g. the clamp algorithm returns the
+//   original value without clamping it due to incorrect functors) or puts an object into an invalid state (e.g.
+//   a string view where only a subset of elements is possible to access). This category is for assertions violating
+//   which doesn't cause any immediate issues in the library -- whatever the consequences are, they will happen in the
+//   user code.
+//
+// - `_LIBCPP_ASSERT_PEDANTIC` -- checks prerequisites which are imposed by the Standard, but violating which happens to
+//   be benign in our implementation.
+//
+// - `_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT` -- checks that the given argument satisfies the semantic requirements imposed
+//   by the Standard. Typically, there is no simple way to completely prove that a semantic requirement is satisfied;
+//   thus, this would often be a heuristic check and it might be quite expensive.
+//
+// - `_LIBCPP_ASSERT_INTERNAL` -- checks that internal invariants of the library hold. These assertions don't depend on
+//   user input.
+//
+// - `_LIBCPP_ASSERT_UNCATEGORIZED` -- for assertions that haven't been properly classified yet.
+
+// clang-format off
+#  define _LIBCPP_HARDENING_MODE_NONE      (1 << 1)
+#  define _LIBCPP_HARDENING_MODE_FAST      (1 << 2)
+#  define _LIBCPP_HARDENING_MODE_EXTENSIVE (1 << 4) // Deliberately not ordered.
+#  define _LIBCPP_HARDENING_MODE_DEBUG     (1 << 3)
+// clang-format on
+
+#  ifndef _LIBCPP_HARDENING_MODE
+
+#    ifndef _LIBCPP_HARDENING_MODE_DEFAULT
+#      error _LIBCPP_HARDENING_MODE_DEFAULT is not defined. This definition should be set at configuration time in the \
+`__config_site` header, please make sure your installation of libc++ is not broken.
 #    endif
+
+#    define _LIBCPP_HARDENING_MODE _LIBCPP_HARDENING_MODE_DEFAULT
 #  endif
 
-#  if defined(_LIBCPP_BUILDING_LIBRARY) || _LIBCPP_ABI_VERSION >= 2
-// Enable additional explicit instantiations of iostreams components. This
-// reduces the number of weak definitions generated in programs that use
-// iostreams by providing a single strong definition in the shared library.
-#    define _LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1
-
-// Define a key function for `bad_function_call` in the library, to centralize
-// its vtable and typeinfo to libc++ rather than having all other libraries
-// using that class define their own copies.
-#    define _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
+#  if _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_NONE &&                                                         \
+      _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_FAST &&                                                         \
+      _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_EXTENSIVE &&                                                    \
+      _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_DEBUG
+#    error _LIBCPP_HARDENING_MODE must be set to one of the following values: \
+_LIBCPP_HARDENING_MODE_NONE, \
+_LIBCPP_HARDENING_MODE_FAST, \
+_LIBCPP_HARDENING_MODE_EXTENSIVE, \
+_LIBCPP_HARDENING_MODE_DEBUG
 #  endif
 
+// } HARDENING
+
 #  define _LIBCPP_TOSTRING2(x) #x
 #  define _LIBCPP_TOSTRING(x) _LIBCPP_TOSTRING2(x)
 
@@ -197,30 +162,15 @@
 #    define _LIBCPP_CXX03_LANG
 #  endif
 
-#  ifndef __has_attribute
-#    define __has_attribute(__x) 0
-#  endif
-
-#  ifndef __has_builtin
-#    define __has_builtin(__x) 0
-#  endif
-
-#  ifndef __has_extension
-#    define __has_extension(__x) 0
-#  endif
-
-#  ifndef __has_feature
-#    define __has_feature(__x) 0
-#  endif
-
-#  ifndef __has_cpp_attribute
-#    define __has_cpp_attribute(__x) 0
-#  endif
-
 #  ifndef __has_constexpr_builtin
 #    define __has_constexpr_builtin(x) 0
 #  endif
 
+// This checks wheter a Clang module is built
+#  ifndef __building_module
+#    define __building_module(...) 0
+#  endif
+
 // '__is_identifier' returns '0' if '__x' is a reserved identifier provided by
 // the compiler and '1' otherwise.
 #  ifndef __is_identifier
@@ -233,8 +183,8 @@
 
 #  define __has_keyword(__x) !(__is_identifier(__x))
 
-#  ifndef __has_include
-#    define __has_include(...) 0
+#  ifndef __has_warning
+#    define __has_warning(...) 0
 #  endif
 
 #  if !defined(_LIBCPP_COMPILER_CLANG_BASED) && __cplusplus < 201103L
@@ -274,64 +224,17 @@
 // easier to grep for target specific flags once the feature is complete.
 #  if !defined(_LIBCPP_ENABLE_EXPERIMENTAL) && !defined(_LIBCPP_BUILDING_LIBRARY)
 #    define _LIBCPP_HAS_NO_INCOMPLETE_PSTL
+#    define _LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN
+#    define _LIBCPP_HAS_NO_EXPERIMENTAL_TZDB
+#    define _LIBCPP_HAS_NO_EXPERIMENTAL_SYNCSTREAM
 #  endif
 
-// Need to detect which libc we're using if we're on Linux.
-#  if defined(__linux__)
-#    include <features.h>
-#    if defined(__GLIBC_PREREQ)
-#      define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)
-#    else
-#      define _LIBCPP_GLIBC_PREREQ(a, b) 0
-#    endif // defined(__GLIBC_PREREQ)
-#  endif   // defined(__linux__)
-
 #  if defined(__MVS__)
 #    include <features.h> // for __NATIVE_ASCII_F
 #  endif
 
-#  ifdef __LITTLE_ENDIAN__
-#    if __LITTLE_ENDIAN__
-#      define _LIBCPP_LITTLE_ENDIAN
-#    endif // __LITTLE_ENDIAN__
-#  endif   // __LITTLE_ENDIAN__
-
-#  ifdef __BIG_ENDIAN__
-#    if __BIG_ENDIAN__
-#      define _LIBCPP_BIG_ENDIAN
-#    endif // __BIG_ENDIAN__
-#  endif   // __BIG_ENDIAN__
-
-#  ifdef __BYTE_ORDER__
-#    if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#      define _LIBCPP_LITTLE_ENDIAN
-#    elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#      define _LIBCPP_BIG_ENDIAN
-#    endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
-#  endif   // __BYTE_ORDER__
-
-#  ifdef __FreeBSD__
-#    include <sys/endian.h>
-#    include <osreldate.h>
-#    if _BYTE_ORDER == _LITTLE_ENDIAN
-#      define _LIBCPP_LITTLE_ENDIAN
-#    else // _BYTE_ORDER == _LITTLE_ENDIAN
-#      define _LIBCPP_BIG_ENDIAN
-#    endif // _BYTE_ORDER == _LITTLE_ENDIAN
-#  endif   // __FreeBSD__
-
-#  if defined(__NetBSD__) || defined(__OpenBSD__)
-#    include <sys/endian.h>
-#    if _BYTE_ORDER == _LITTLE_ENDIAN
-#      define _LIBCPP_LITTLE_ENDIAN
-#    else // _BYTE_ORDER == _LITTLE_ENDIAN
-#      define _LIBCPP_BIG_ENDIAN
-#    endif // _BYTE_ORDER == _LITTLE_ENDIAN
-#  endif   // defined(__NetBSD__) || defined(__OpenBSD__)
-
 #  if defined(_WIN32)
 #    define _LIBCPP_WIN32API
-#    define _LIBCPP_LITTLE_ENDIAN
 #    define _LIBCPP_SHORT_WCHAR 1
 // Both MinGW and native MSVC provide a "MSVC"-like environment
 #    define _LIBCPP_MSVCRT_LIKE
@@ -404,23 +307,6 @@
 #    define _LIBCPP_USING_DEV_RANDOM
 #  endif
 
-#  if !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
-#    include <endian.h>
-#    if __BYTE_ORDER == __LITTLE_ENDIAN
-#      define _LIBCPP_LITTLE_ENDIAN
-#    elif __BYTE_ORDER == __BIG_ENDIAN
-#      define _LIBCPP_BIG_ENDIAN
-#    else // __BYTE_ORDER == __BIG_ENDIAN
-#      error unable to determine endian
-#    endif
-#  endif // !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
-
-#  if __has_attribute(__no_sanitize__) && !defined(_LIBCPP_COMPILER_GCC)
-#    define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi")))
-#  else
-#    define _LIBCPP_NO_CFI
-#  endif
-
 #  ifndef _LIBCPP_CXX03_LANG
 
 #    define _LIBCPP_ALIGNOF(_Tp) alignof(_Tp)
@@ -428,7 +314,7 @@
 #    define _ALIGNAS(x) alignas(x)
 #    define _LIBCPP_NORETURN [[noreturn]]
 #    define _NOEXCEPT noexcept
-#    define _NOEXCEPT_(x) noexcept(x)
+#    define _NOEXCEPT_(...) noexcept(__VA_ARGS__)
 #    define _LIBCPP_CONSTEXPR constexpr
 
 #  else
@@ -440,7 +326,7 @@
 #    define _LIBCPP_HAS_NO_NOEXCEPT
 #    define nullptr __nullptr
 #    define _NOEXCEPT throw()
-#    define _NOEXCEPT_(x)
+#    define _NOEXCEPT_(...)
 #    define static_assert(...) _Static_assert(__VA_ARGS__)
 #    define decltype(...) __decltype(__VA_ARGS__)
 #    define _LIBCPP_CONSTEXPR
@@ -450,59 +336,32 @@ typedef __char32_t char32_t;
 
 #  endif
 
-#  if !defined(__cpp_exceptions) || __cpp_exceptions < 199711L
-#    define _LIBCPP_HAS_NO_EXCEPTIONS
-#  endif
-
 #  define _LIBCPP_PREFERRED_ALIGNOF(_Tp) __alignof(_Tp)
 
-#  if defined(_LIBCPP_COMPILER_CLANG_BASED)
-
-#    if defined(__APPLE__) && !defined(__i386__) && !defined(__x86_64__) && (!defined(__arm__) || __ARM_ARCH_7K__ >= 2)
-#      define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
-#    endif
-
 // Objective-C++ features (opt-in)
-#    if __has_feature(objc_arc)
-#      define _LIBCPP_HAS_OBJC_ARC
-#    endif
+#  if __has_feature(objc_arc)
+#    define _LIBCPP_HAS_OBJC_ARC
+#  endif
 
-#    if __has_feature(objc_arc_weak)
-#      define _LIBCPP_HAS_OBJC_ARC_WEAK
-#    endif
+#  if __has_feature(objc_arc_weak)
+#    define _LIBCPP_HAS_OBJC_ARC_WEAK
+#  endif
 
-#    if __has_extension(blocks)
-#      define _LIBCPP_HAS_EXTENSION_BLOCKS
-#    endif
+#  if __has_extension(blocks)
+#    define _LIBCPP_HAS_EXTENSION_BLOCKS
+#  endif
 
-#    if defined(_LIBCPP_HAS_EXTENSION_BLOCKS) && defined(__APPLE__)
-#      define _LIBCPP_HAS_BLOCKS_RUNTIME
-#    endif
+#  if defined(_LIBCPP_HAS_EXTENSION_BLOCKS) && defined(__APPLE__)
+#    define _LIBCPP_HAS_BLOCKS_RUNTIME
+#  endif
 
-#    if !__has_feature(address_sanitizer)
-#      define _LIBCPP_HAS_NO_ASAN
-#    endif
+#  if !__has_feature(address_sanitizer)
+#    define _LIBCPP_HAS_NO_ASAN
+#  endif
 
-// Allow for build-time disabling of unsigned integer sanitization
-#    if __has_attribute(no_sanitize)
-#      define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow")))
-#    endif
+#  define _LIBCPP_ALWAYS_INLINE __attribute__((__always_inline__))
 
-#    define _LIBCPP_ALWAYS_INLINE __attribute__((__always_inline__))
-
-#    define _LIBCPP_DISABLE_EXTENSION_WARNING __extension__
-
-#  elif defined(_LIBCPP_COMPILER_GCC)
-
-#    if !defined(__SANITIZE_ADDRESS__)
-#      define _LIBCPP_HAS_NO_ASAN
-#    endif
-
-#    define _LIBCPP_ALWAYS_INLINE __attribute__((__always_inline__))
-
-#    define _LIBCPP_DISABLE_EXTENSION_WARNING __extension__
-
-#  endif // _LIBCPP_COMPILER_[CLANG|GCC]
+#  define _LIBCPP_DISABLE_EXTENSION_WARNING __extension__
 
 #  if defined(_LIBCPP_OBJECT_FORMAT_COFF)
 
@@ -537,14 +396,11 @@ typedef __char32_t char32_t;
 #      define _LIBCPP_EXPORTED_FROM_ABI __declspec(dllimport)
 #    endif
 
-#    define _LIBCPP_TYPE_VIS _LIBCPP_DLL_VIS
-#    define _LIBCPP_FUNC_VIS _LIBCPP_DLL_VIS
-#    define _LIBCPP_EXCEPTION_ABI _LIBCPP_DLL_VIS
 #    define _LIBCPP_HIDDEN
 #    define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 #    define _LIBCPP_TEMPLATE_VIS
 #    define _LIBCPP_TEMPLATE_DATA_VIS
-#    define _LIBCPP_ENUM_VIS
+#    define _LIBCPP_TYPE_VISIBILITY_DEFAULT
 
 #  else
 
@@ -555,11 +411,8 @@ typedef __char32_t char32_t;
 #    endif
 
 #    define _LIBCPP_HIDDEN _LIBCPP_VISIBILITY("hidden")
-#    define _LIBCPP_FUNC_VIS _LIBCPP_VISIBILITY("default")
-#    define _LIBCPP_TYPE_VIS _LIBCPP_VISIBILITY("default")
 #    define _LIBCPP_TEMPLATE_DATA_VIS _LIBCPP_VISIBILITY("default")
 #    define _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_VISIBILITY("default")
-#    define _LIBCPP_EXCEPTION_ABI _LIBCPP_VISIBILITY("default")
 #    define _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_VISIBILITY("default")
 #    define _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
 
@@ -575,20 +428,17 @@ typedef __char32_t char32_t;
 #      define _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 #    endif
 
-#    if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS)
-#      if __has_attribute(__type_visibility__)
-#        define _LIBCPP_TEMPLATE_VIS __attribute__((__type_visibility__("default")))
-#      else
-#        define _LIBCPP_TEMPLATE_VIS __attribute__((__visibility__("default")))
-#      endif
+// GCC doesn't support the type_visibility attribute, so we have to keep the visibility attribute on templates
+#    if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) && !__has_attribute(__type_visibility__)
+#      define _LIBCPP_TEMPLATE_VIS __attribute__((__visibility__("default")))
 #    else
 #      define _LIBCPP_TEMPLATE_VIS
 #    endif
 
 #    if !defined(_LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS) && __has_attribute(__type_visibility__)
-#      define _LIBCPP_ENUM_VIS __attribute__((__type_visibility__("default")))
+#      define _LIBCPP_TYPE_VISIBILITY_DEFAULT __attribute__((__type_visibility__("default")))
 #    else
-#      define _LIBCPP_ENUM_VIS
+#      define _LIBCPP_TYPE_VISIBILITY_DEFAULT
 #    endif
 
 #  endif // defined(_LIBCPP_OBJECT_FORMAT_COFF)
@@ -602,22 +452,71 @@ typedef __char32_t char32_t;
 #    define _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION _LIBCPP_ALWAYS_INLINE
 #  endif
 
+#  ifdef _LIBCPP_COMPILER_CLANG_BASED
+#    define _LIBCPP_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+#    define _LIBCPP_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#    define _LIBCPP_CLANG_DIAGNOSTIC_IGNORED(str) _Pragma(_LIBCPP_TOSTRING(clang diagnostic ignored str))
+#    define _LIBCPP_GCC_DIAGNOSTIC_IGNORED(str)
+#  elif defined(_LIBCPP_COMPILER_GCC)
+#    define _LIBCPP_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+#    define _LIBCPP_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#    define _LIBCPP_CLANG_DIAGNOSTIC_IGNORED(str)
+#    define _LIBCPP_GCC_DIAGNOSTIC_IGNORED(str) _Pragma(_LIBCPP_TOSTRING(GCC diagnostic ignored str))
+#  else
+#    define _LIBCPP_DIAGNOSTIC_PUSH
+#    define _LIBCPP_DIAGNOSTIC_POP
+#    define _LIBCPP_CLANG_DIAGNOSTIC_IGNORED(str)
+#    define _LIBCPP_GCC_DIAGNOSTIC_IGNORED(str)
+#  endif
+
+#  if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_FAST
+#    define _LIBCPP_HARDENING_SIG f
+#  elif _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_EXTENSIVE
+#    define _LIBCPP_HARDENING_SIG s
+#  elif _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
+#    define _LIBCPP_HARDENING_SIG d
+#  else
+#    define _LIBCPP_HARDENING_SIG n // "none"
+#  endif
+
+#  ifdef _LIBCPP_HAS_NO_EXCEPTIONS
+#    define _LIBCPP_EXCEPTIONS_SIG n
+#  else
+#    define _LIBCPP_EXCEPTIONS_SIG e
+#  endif
+
+#  define _LIBCPP_ODR_SIGNATURE                                                                                        \
+    _LIBCPP_CONCAT(_LIBCPP_CONCAT(_LIBCPP_HARDENING_SIG, _LIBCPP_EXCEPTIONS_SIG), _LIBCPP_VERSION)
+
 // This macro marks a symbol as being hidden from libc++'s ABI. This is achieved
 // on two levels:
 // 1. The symbol is given hidden visibility, which ensures that users won't start exporting
 //    symbols from their dynamic library by means of using the libc++ headers. This ensures
 //    that those symbols stay private to the dynamic library in which it is defined.
 //
-// 2. The symbol is given an ABI tag that changes with each version of libc++. This ensures
-//    that no ODR violation can arise from mixing two TUs compiled with different versions
-//    of libc++ where we would have changed the definition of a symbol. If the symbols shared
-//    the same name, the ODR would require that their definitions be token-by-token equivalent,
-//    which basically prevents us from being able to make any change to any function in our
-//    headers. Using this ABI tag ensures that the symbol name is "bumped" artificially at
-//    each release, which lets us change the definition of these symbols at our leisure.
-//    Note that historically, this has been achieved in various ways, including force-inlining
-//    all functions or giving internal linkage to all functions. Both these (previous) solutions
-//    suffer from drawbacks that lead notably to code bloat.
+// 2. The symbol is given an ABI tag that encodes the ODR-relevant properties of the library.
+//    This ensures that no ODR violation can arise from mixing two TUs compiled with different
+//    versions or configurations of libc++ (such as exceptions vs no-exceptions). Indeed, if the
+//    program contains two definitions of a function, the ODR requires them to be token-by-token
+//    equivalent, and the linker is allowed to pick either definition and discard the other one.
+//
+//    For example, if a program contains a copy of `vector::at()` compiled with exceptions enabled
+//    *and* a copy of `vector::at()` compiled with exceptions disabled (by means of having two TUs
+//    compiled with different settings), the two definitions are both visible by the linker and they
+//    have the same name, but they have a meaningfully different implementation (one throws an exception
+//    and the other aborts the program). This violates the ODR and makes the program ill-formed, and in
+//    practice what will happen is that the linker will pick one of the definitions at random and will
+//    discard the other one. This can quite clearly lead to incorrect program behavior.
+//
+//    A similar reasoning holds for many other properties that are ODR-affecting. Essentially any
+//    property that causes the code of a function to differ from the code in another configuration
+//    can be considered ODR-affecting. In practice, we don't encode all such properties in the ABI
+//    tag, but we encode the ones that we think are most important: library version, exceptions, and
+//    hardening mode.
+//
+//    Note that historically, solving this problem has been achieved in various ways, including
+//    force-inlining all functions or giving internal linkage to all functions. Both these previous
+//    solutions suffer from drawbacks that lead notably to code bloat.
 //
 // Note that we use _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION to ensure that we don't depend
 // on _LIBCPP_HIDE_FROM_ABI methods of classes explicitly instantiated in the dynamic library.
@@ -631,22 +530,24 @@ typedef __char32_t char32_t;
 // the implementation of a virtual function in an ABI-incompatible way in the first place,
 // since that would be an ABI break anyway. Hence, the lack of ABI tag should not be noticeable.
 //
+// The macro can be applied to record and enum types. When the tagged type is nested in
+// a record this "parent" record needs to have the macro too. Another use case for applying
+// this macro to records and unions is to apply an ABI tag to inline constexpr variables.
+// This can be useful for inline variables that are implementation details which are expected
+// to change in the future.
+//
 // TODO: We provide a escape hatch with _LIBCPP_NO_ABI_TAG for folks who want to avoid increasing
 //       the length of symbols with an ABI tag. In practice, we should remove the escape hatch and
 //       use compression mangling instead, see https://github.com/itanium-cxx-abi/cxx-abi/issues/70.
 #  ifndef _LIBCPP_NO_ABI_TAG
 #    define _LIBCPP_HIDE_FROM_ABI                                                                                      \
       _LIBCPP_HIDDEN _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION                                                       \
-          __attribute__((__abi_tag__(_LIBCPP_TOSTRING(_LIBCPP_VERSIONED_IDENTIFIER))))
+      __attribute__((__abi_tag__(_LIBCPP_TOSTRING(_LIBCPP_ODR_SIGNATURE))))
 #  else
 #    define _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDDEN _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION
 #  endif
 #  define _LIBCPP_HIDE_FROM_ABI_VIRTUAL _LIBCPP_HIDDEN _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION
 
-// This macro provides a HIDE_FROM_ABI equivalent that can be applied to extern
-// "C" function, as those lack mangling.
-#  define _LIBCPP_HIDE_FROM_ABI_C _LIBCPP_HIDDEN _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION
-
 #  ifdef _LIBCPP_BUILDING_LIBRARY
 #    if _LIBCPP_ABI_VERSION > 1
 #      define _LIBCPP_HIDE_FROM_ABI_AFTER_V1 _LIBCPP_HIDE_FROM_ABI
@@ -657,65 +558,76 @@ typedef __char32_t char32_t;
 #    define _LIBCPP_HIDE_FROM_ABI_AFTER_V1 _LIBCPP_HIDE_FROM_ABI
 #  endif
 
-// Just so we can migrate to the new macros gradually.
-#  define _LIBCPP_INLINE_VISIBILITY _LIBCPP_HIDE_FROM_ABI
+// TODO: Remove this workaround once we drop support for Clang 16
+#  if __has_warning("-Wc++23-extensions")
+#    define _LIBCPP_CLANG_DIAGNOSTIC_IGNORED_CXX23_EXTENSION _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++23-extensions")
+#  else
+#    define _LIBCPP_CLANG_DIAGNOSTIC_IGNORED_CXX23_EXTENSION _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++2b-extensions")
+#  endif
+
+// Clang modules take a significant compile time hit when pushing and popping diagnostics.
+// Since all the headers are marked as system headers in the modulemap, we can simply disable this
+// pushing and popping when building with clang modules.
+#  if !__has_feature(modules)
+#    define _LIBCPP_PUSH_EXTENSION_DIAGNOSTICS                                                                         \
+      _LIBCPP_DIAGNOSTIC_PUSH                                                                                          \
+      _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++11-extensions")                                                           \
+      _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++14-extensions")                                                           \
+      _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++17-extensions")                                                           \
+      _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wc++20-extensions")                                                           \
+      _LIBCPP_CLANG_DIAGNOSTIC_IGNORED_CXX23_EXTENSION                                                                 \
+      _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wc++14-extensions")                                                             \
+      _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wc++17-extensions")                                                             \
+      _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wc++20-extensions")                                                             \
+      _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wc++23-extensions")
+#    define _LIBCPP_POP_EXTENSION_DIAGNOSTICS _LIBCPP_DIAGNOSTIC_POP
+#  else
+#    define _LIBCPP_PUSH_EXTENSION_DIAGNOSTICS
+#    define _LIBCPP_POP_EXTENSION_DIAGNOSTICS
+#  endif
 
 // Inline namespaces are available in Clang/GCC/MSVC regardless of C++ dialect.
 // clang-format off
-#  define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { inline namespace _LIBCPP_ABI_NAMESPACE {
-#  define _LIBCPP_END_NAMESPACE_STD }}
-#  define _VSTD std
+#  define _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_PUSH_EXTENSION_DIAGNOSTICS                                               \
+                                      namespace _LIBCPP_TYPE_VISIBILITY_DEFAULT std {                                  \
+                               inline namespace _LIBCPP_ABI_NAMESPACE {
+#  define _LIBCPP_END_NAMESPACE_STD }} _LIBCPP_POP_EXTENSION_DIAGNOSTICS
 
-_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
+#ifdef _LIBCPP_ABI_NO_FILESYSTEM_INLINE_NAMESPACE
+#  define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM _LIBCPP_BEGIN_NAMESPACE_STD namespace filesystem {
+#  define _LIBCPP_END_NAMESPACE_FILESYSTEM } _LIBCPP_END_NAMESPACE_STD
+#else
+#  define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM _LIBCPP_BEGIN_NAMESPACE_STD                                               \
+                                             inline namespace __fs { namespace filesystem {
 
-#  if _LIBCPP_STD_VER >= 17
-#    define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM                                                                         \
-       _LIBCPP_BEGIN_NAMESPACE_STD inline namespace __fs { namespace filesystem {
-#  else
-#    define _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM                                                                         \
-      _LIBCPP_BEGIN_NAMESPACE_STD namespace __fs { namespace filesystem {
-#  endif
+#  define _LIBCPP_END_NAMESPACE_FILESYSTEM }} _LIBCPP_END_NAMESPACE_STD
+#endif
 
-#  define _LIBCPP_END_NAMESPACE_FILESYSTEM _LIBCPP_END_NAMESPACE_STD }}
 // clang-format on
 
-#  define _VSTD_FS std::__fs::filesystem
-
 #  if __has_attribute(__enable_if__)
 #    define _LIBCPP_PREFERRED_OVERLOAD __attribute__((__enable_if__(true, "")))
 #  endif
 
-#  ifndef __SIZEOF_INT128__
+#  if !defined(__SIZEOF_INT128__) || defined(_MSC_VER)
 #    define _LIBCPP_HAS_NO_INT128
 #  endif
 
-#  if __has_attribute(__malloc__)
-#    define _LIBCPP_NOALIAS __attribute__((__malloc__))
-#  else
-#    define _LIBCPP_NOALIAS
-#  endif
-
-#  if __has_attribute(__using_if_exists__)
-#    define _LIBCPP_USING_IF_EXISTS __attribute__((__using_if_exists__))
-#  else
-#    define _LIBCPP_USING_IF_EXISTS
-#  endif
-
 #  ifdef _LIBCPP_CXX03_LANG
 #    define _LIBCPP_DECLARE_STRONG_ENUM(x)                                                                             \
-      struct _LIBCPP_TYPE_VIS x {                                                                                      \
+      struct _LIBCPP_EXPORTED_FROM_ABI x {                                                                             \
         enum __lx
 // clang-format off
 #    define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)                                                                      \
       __lx __v_;                                                                                                       \
-      _LIBCPP_INLINE_VISIBILITY x(__lx __v) : __v_(__v) {}                                                             \
-      _LIBCPP_INLINE_VISIBILITY explicit x(int __v) : __v_(static_cast<__lx>(__v)) {}                                  \
-      _LIBCPP_INLINE_VISIBILITY operator int() const { return __v_; }                                                  \
+      _LIBCPP_HIDE_FROM_ABI x(__lx __v) : __v_(__v) {}                                                                 \
+      _LIBCPP_HIDE_FROM_ABI explicit x(int __v) : __v_(static_cast<__lx>(__v)) {}                                      \
+      _LIBCPP_HIDE_FROM_ABI operator int() const { return __v_; }                                                      \
       };
 // clang-format on
 
 #  else // _LIBCPP_CXX03_LANG
-#    define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class _LIBCPP_ENUM_VIS x
+#    define _LIBCPP_DECLARE_STRONG_ENUM(x) enum class x
 #    define _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(x)
 #  endif // _LIBCPP_CXX03_LANG
 
@@ -787,6 +699,14 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 #    define _LIBCPP_DEPRECATED_(m)
 #  endif
 
+#  if _LIBCPP_STD_VER < 20
+#    define _LIBCPP_DEPRECATED_ATOMIC_SYNC                                                                             \
+      _LIBCPP_DEPRECATED_("The C++20 synchronization library has been deprecated prior to C++20. Please update to "    \
+                          "using -std=c++20 if you need to use these facilities.")
+#  else
+#    define _LIBCPP_DEPRECATED_ATOMIC_SYNC /* nothing */
+#  endif
+
 #  if !defined(_LIBCPP_CXX03_LANG)
 #    define _LIBCPP_DEPRECATED_IN_CXX11 _LIBCPP_DEPRECATED
 #  else
@@ -811,11 +731,17 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 #    define _LIBCPP_DEPRECATED_IN_CXX20
 #  endif
 
-#if _LIBCPP_STD_VER >= 23
-#  define _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_DEPRECATED
-#else
-#  define _LIBCPP_DEPRECATED_IN_CXX23
-#endif
+#  if _LIBCPP_STD_VER >= 23
+#    define _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_DEPRECATED
+#  else
+#    define _LIBCPP_DEPRECATED_IN_CXX23
+#  endif
+
+#  if _LIBCPP_STD_VER >= 26
+#    define _LIBCPP_DEPRECATED_IN_CXX26 _LIBCPP_DEPRECATED
+#  else
+#    define _LIBCPP_DEPRECATED_IN_CXX26
+#  endif
 
 #  if !defined(_LIBCPP_HAS_NO_CHAR8_T)
 #    define _LIBCPP_DEPRECATED_WITH_CHAR8_T _LIBCPP_DEPRECATED
@@ -870,45 +796,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 #    define _LIBCPP_CONSTEXPR_SINCE_CXX23
 #  endif
 
-#  if __has_cpp_attribute(nodiscard)
-#    define _LIBCPP_NODISCARD [[__nodiscard__]]
-#  else
-// We can't use GCC's [[gnu::warn_unused_result]] and
-// __attribute__((warn_unused_result)), because GCC does not silence them via
-// (void) cast.
-#    define _LIBCPP_NODISCARD
-#  endif
-
-// _LIBCPP_NODISCARD_EXT may be used to apply [[nodiscard]] to entities not
-// specified as such as an extension.
-#  if !defined(_LIBCPP_DISABLE_NODISCARD_EXT)
-#    define _LIBCPP_NODISCARD_EXT _LIBCPP_NODISCARD
-#  else
-#    define _LIBCPP_NODISCARD_EXT
-#  endif
-
-#  if _LIBCPP_STD_VER >= 20 || !defined(_LIBCPP_DISABLE_NODISCARD_EXT)
-#    define _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_NODISCARD
-#  else
-#    define _LIBCPP_NODISCARD_AFTER_CXX17
-#  endif
-
-#  if __has_attribute(__no_destroy__)
-#    define _LIBCPP_NO_DESTROY __attribute__((__no_destroy__))
-#  else
-#    define _LIBCPP_NO_DESTROY
-#  endif
-
-#  ifndef _LIBCPP_HAS_NO_ASAN
-    extern "C" _LIBCPP_FUNC_VIS void
-    __sanitizer_annotate_contiguous_container(const void*, const void*, const void*, const void*);
-#  endif
-
-// Try to find out if RTTI is disabled.
-#  if !defined(__cpp_rtti) || __cpp_rtti < 199711L
-#    define _LIBCPP_HAS_NO_RTTI
-#  endif
-
 #  ifndef _LIBCPP_WEAK
 #    define _LIBCPP_WEAK __attribute__((__weak__))
 #  endif
@@ -930,8 +817,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
         defined(__APPLE__) ||                                                                                          \
         defined(__MVS__) ||                                                                                            \
         defined(_AIX) ||                                                                                               \
-        defined(__EMSCRIPTEN__) ||                                                                                     \
-        defined(__COSMOPOLITAN__)
+        defined(__EMSCRIPTEN__)
 // clang-format on
 #      define _LIBCPP_HAS_THREAD_API_PTHREAD
 #    elif defined(__Fuchsia__)
@@ -986,7 +872,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 // clang-format off
 #  if (defined(_LIBCPP_HAS_THREAD_API_PTHREAD) && defined(__GLIBC__)) ||                                               \
       (defined(_LIBCPP_HAS_THREAD_API_C11) && defined(__Fuchsia__)) ||                                                 \
-       defined(_LIBCPP_HAS_THREAD_API_WIN32) || defined(__COSMOPOLITAN__)
+       defined(_LIBCPP_HAS_THREAD_API_WIN32)
 // clang-format on
 #    define _LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION
 #  endif
@@ -1003,13 +889,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 #    define _LIBCPP_HAS_TRIVIAL_CONDVAR_DESTRUCTION
 #  endif
 
-// Some systems do not provide gets() in their C library, for security reasons.
-#  if defined(_LIBCPP_MSVCRT) || (defined(__FreeBSD_version) && __FreeBSD_version >= 1300043) || defined(__OpenBSD__)
-#    define _LIBCPP_C_HAS_NO_GETS
-#  endif
-
 #  if defined(__BIONIC__) || defined(__NuttX__) || defined(__Fuchsia__) || defined(__wasi__) ||                        \
-      defined(_LIBCPP_HAS_MUSL_LIBC) || defined(__OpenBSD__) || defined(__COSMOPOLITAN__)
+      defined(_LIBCPP_HAS_MUSL_LIBC) || defined(__OpenBSD__)
 #    define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
 #  endif
 
@@ -1026,13 +907,12 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 #    ifndef _LIBCPP_ATOMIC_FLAG_TYPE
 #      define _LIBCPP_ATOMIC_FLAG_TYPE bool
 #    endif
-#    ifdef _LIBCPP_FREESTANDING
-#      define _LIBCPP_ATOMIC_ONLY_USE_BUILTINS
-#    endif
 #  endif
 
-#  ifndef _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-#    define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+#  if defined(__FreeBSD__) && defined(__clang__) && __has_attribute(__no_thread_safety_analysis__)
+#    define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS __attribute__((__no_thread_safety_analysis__))
+#  else
+#    define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
 #  endif
 
 #  if defined(_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS)
@@ -1053,10 +933,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 #    define _LIBCPP_THREAD_SAFETY_ANNOTATION(x)
 #  endif
 
-#ifdef _LIBCPP_CONSTINIT
-#undef _LIBCPP_CONSTINIT // TODO(jart): wut
-#endif
-
 #  if _LIBCPP_STD_VER >= 20
 #    define _LIBCPP_CONSTINIT constinit
 #  elif __has_attribute(__require_constant_initialization__)
@@ -1065,43 +941,21 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 #    define _LIBCPP_CONSTINIT
 #  endif
 
-#  if __has_attribute(__diagnose_if__) && !defined(_LIBCPP_DISABLE_ADDITIONAL_DIAGNOSTICS)
-#    define _LIBCPP_DIAGNOSE_WARNING(...) __attribute__((__diagnose_if__(__VA_ARGS__, "warning")))
+#  if defined(__CUDACC__) || defined(__CUDA_ARCH__) || defined(__CUDA_LIBDEVICE__)
+// The CUDA SDK contains an unfortunate definition for the __noinline__ macro,
+// which breaks the regular __attribute__((__noinline__)) syntax. Therefore,
+// when compiling for CUDA we use the non-underscored version of the noinline
+// attribute.
+//
+// This is a temporary workaround and we still expect the CUDA SDK team to solve
+// this issue properly in the SDK headers.
+//
+// See https://github.com/llvm/llvm-project/pull/73838 for more details.
+#    define _LIBCPP_NOINLINE __attribute__((noinline))
+#  elif __has_attribute(__noinline__)
+#    define _LIBCPP_NOINLINE __attribute__((__noinline__))
 #  else
-#    define _LIBCPP_DIAGNOSE_WARNING(...)
-#  endif
-
-// Use a function like macro to imply that it must be followed by a semicolon
-#  if __has_cpp_attribute(fallthrough)
-#    define _LIBCPP_FALLTHROUGH() [[fallthrough]]
-#  elif __has_attribute(__fallthrough__)
-#    define _LIBCPP_FALLTHROUGH() __attribute__((__fallthrough__))
-#  else
-#    define _LIBCPP_FALLTHROUGH() ((void)0)
-#  endif
-
-#  if __has_cpp_attribute(_Clang::__lifetimebound__)
-#    define _LIBCPP_LIFETIMEBOUND [[_Clang::__lifetimebound__]]
-#  else
-#    define _LIBCPP_LIFETIMEBOUND
-#  endif
-
-#  if __has_attribute(__nodebug__)
-#    define _LIBCPP_NODEBUG __attribute__((__nodebug__))
-#  else
-#    define _LIBCPP_NODEBUG
-#  endif
-
-#  if __has_attribute(__standalone_debug__)
-#    define _LIBCPP_STANDALONE_DEBUG __attribute__((__standalone_debug__))
-#  else
-#    define _LIBCPP_STANDALONE_DEBUG
-#  endif
-
-#  if __has_attribute(__preferred_name__)
-#    define _LIBCPP_PREFERRED_NAME(x) __attribute__((__preferred_name__(x)))
-#  else
-#    define _LIBCPP_PREFERRED_NAME(x)
+#    define _LIBCPP_NOINLINE
 #  endif
 
 // We often repeat things just for handling wide characters in the library.
@@ -1114,31 +968,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 #    define _LIBCPP_IF_WIDE_CHARACTERS(...) __VA_ARGS__
 #  endif
 
-#  if defined(_LIBCPP_ABI_MICROSOFT) && __has_declspec_attribute(empty_bases)
-#    define _LIBCPP_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
-#  else
-#    define _LIBCPP_DECLSPEC_EMPTY_BASES
-#  endif
-
-#  if defined(_LIBCPP_ENABLE_CXX17_REMOVED_FEATURES)
-#    define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
-#    define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
-#    define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
-#    define _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS
-#    define _LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION
-#  endif // _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
-
-#  if defined(_LIBCPP_ENABLE_CXX20_REMOVED_FEATURES)
-#    define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
-#    define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_VOID_SPECIALIZATION
-#    define _LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS
-#    define _LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
-#    define _LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR
-#    define _LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS
-#  endif // _LIBCPP_ENABLE_CXX20_REMOVED_FEATURES
-
-#  define _LIBCPP_PUSH_MACROS _Pragma("push_macro(\"min\")") _Pragma("push_macro(\"max\")")
-#  define _LIBCPP_POP_MACROS _Pragma("pop_macro(\"min\")") _Pragma("pop_macro(\"max\")")
+// clang-format off
+#  define _LIBCPP_PUSH_MACROS _Pragma("push_macro(\"min\")") _Pragma("push_macro(\"max\")") _Pragma("push_macro(\"refresh\")") _Pragma("push_macro(\"move\")") _Pragma("push_macro(\"erase\")")
+#  define _LIBCPP_POP_MACROS _Pragma("pop_macro(\"min\")") _Pragma("pop_macro(\"max\")") _Pragma("pop_macro(\"refresh\")") _Pragma("pop_macro(\"move\")") _Pragma("pop_macro(\"erase\")")
+// clang-format on
 
 #  ifndef _LIBCPP_NO_AUTO_LINK
 #    if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_BUILDING_LIBRARY)
@@ -1155,34 +988,12 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 //
 // Not all platforms support this, but it helps avoid fd-leaks on platforms that
 // do.
-#  if defined(__BIONIC__) || defined(__COSMOPOLITAN__)
+#  if defined(__BIONIC__)
 #    define _LIBCPP_FOPEN_CLOEXEC_MODE "e"
 #  else
 #    define _LIBCPP_FOPEN_CLOEXEC_MODE
 #  endif
 
-// Support for _FILE_OFFSET_BITS=64 landed gradually in Android, so the full set
-// of functions used in cstdio may not be available for low API levels when
-// using 64-bit file offsets on LP32.
-#  if defined(__BIONIC__) && defined(__USE_FILE_OFFSET64) && __ANDROID_API__ < 24
-#    define _LIBCPP_HAS_NO_FGETPOS_FSETPOS
-#  endif
-
-#  if __has_attribute(__init_priority__)
-#    define _LIBCPP_INIT_PRIORITY_MAX __attribute__((__init_priority__(100)))
-#  else
-#    define _LIBCPP_INIT_PRIORITY_MAX
-#  endif
-
-#  if __has_attribute(__format__)
-// The attribute uses 1-based indices for ordinary and static member functions.
-// The attribute uses 2-based indices for non-static member functions.
-#    define _LIBCPP_ATTRIBUTE_FORMAT(archetype, format_string_index, first_format_arg_index)                           \
-      __attribute__((__format__(archetype, format_string_index, first_format_arg_index)))
-#  else
-#    define _LIBCPP_ATTRIBUTE_FORMAT(archetype, format_string_index, first_format_arg_index) /* nothing */
-#  endif
-
 #  if __has_cpp_attribute(msvc::no_unique_address)
 // MSVC implements [[no_unique_address]] as a silent no-op currently.
 // (If/when MSVC breaks its C++ ABI, it will be changed to work as intended.)
@@ -1205,37 +1016,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 // the ABI inconsistent.
 #  endif
 
-#  ifdef _LIBCPP_COMPILER_CLANG_BASED
-#    define _LIBCPP_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
-#    define _LIBCPP_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
-#    define _LIBCPP_CLANG_DIAGNOSTIC_IGNORED(str) _Pragma(_LIBCPP_TOSTRING(clang diagnostic ignored str))
-#    define _LIBCPP_GCC_DIAGNOSTIC_IGNORED(str)
-#  elif defined(_LIBCPP_COMPILER_GCC)
-#    define _LIBCPP_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
-#    define _LIBCPP_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
-#    define _LIBCPP_CLANG_DIAGNOSTIC_IGNORED(str)
-#    define _LIBCPP_GCC_DIAGNOSTIC_IGNORED(str) _Pragma(_LIBCPP_TOSTRING(GCC diagnostic ignored str))
-#  else
-#    define _LIBCPP_DIAGNOSTIC_PUSH
-#    define _LIBCPP_DIAGNOSTIC_POP
-#    define _LIBCPP_CLANG_DIAGNOSTIC_IGNORED(str)
-#    define _LIBCPP_GCC_DIAGNOSTIC_IGNORED(str)
-#  endif
-
-#  if defined(_AIX) && !defined(_LIBCPP_COMPILER_GCC)
-#    define _LIBCPP_PACKED_BYTE_FOR_AIX _Pragma("pack(1)")
-#    define _LIBCPP_PACKED_BYTE_FOR_AIX_END _Pragma("pack(pop)")
-#  else
-#    define _LIBCPP_PACKED_BYTE_FOR_AIX     /* empty */
-#    define _LIBCPP_PACKED_BYTE_FOR_AIX_END /* empty */
-#  endif
-
-#  if __has_attribute(__packed__)
-#    define _LIBCPP_PACKED __attribute__((__packed__))
-#  else
-#    define _LIBCPP_PACKED
-#  endif
-
 // c8rtomb() and mbrtoc8() were added in C++20 and C23. Support for these
 // functions is gradually being added to existing C libraries. The conditions
 // below check for known C library versions and conditions under which these
@@ -1277,21 +1057,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 #    define _LIBCPP_WORKAROUND_OBJCXX_COMPILER_INTRINSICS
 #  endif
 
-// TODO: Make this a proper configuration option
-#define _PSTL_PAR_BACKEND_SERIAL
-
-#define _PSTL_PRAGMA(x) _Pragma(#    x)
+#  define _PSTL_PRAGMA(x) _Pragma(#x)
 
 // Enable SIMD for compilers that support OpenMP 4.0
-#if (defined(_OPENMP) && _OPENMP >= 201307)
+#  if (defined(_OPENMP) && _OPENMP >= 201307)
 
-#  define _PSTL_UDR_PRESENT
-#  define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(omp simd)
-#  define _PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA(omp declare simd)
-#  define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(omp simd reduction(PRM))
-#  define _PSTL_PRAGMA_SIMD_SCAN(PRM) _PSTL_PRAGMA(omp simd reduction(inscan, PRM))
-#  define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan inclusive(PRM))
-#  define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan exclusive(PRM))
+#    define _PSTL_UDR_PRESENT
+#    define _PSTL_PRAGMA_SIMD _PSTL_PRAGMA(omp simd)
+#    define _PSTL_PRAGMA_DECLARE_SIMD _PSTL_PRAGMA(omp declare simd)
+#    define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _PSTL_PRAGMA(omp simd reduction(PRM))
+#    define _PSTL_PRAGMA_SIMD_SCAN(PRM) _PSTL_PRAGMA(omp simd reduction(inscan, PRM))
+#    define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan inclusive(PRM))
+#    define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM) _PSTL_PRAGMA(omp scan exclusive(PRM))
 
 // Declaration of reduction functor, where
 // NAME - the name of the functor
@@ -1300,22 +1077,151 @@ _LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
 // omp_out - refers to the final value of the combiner operator
 // omp_priv - refers to the private copy of the initial value
 // omp_orig - refers to the original variable to be reduced
-#  define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)                                                                     \
-    _PSTL_PRAGMA(omp declare reduction(NAME:OP : omp_out(omp_in)) initializer(omp_priv = omp_orig))
+#    define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)                                                                   \
+      _PSTL_PRAGMA(omp declare reduction(NAME:OP : omp_out(omp_in)) initializer(omp_priv = omp_orig))
 
-#else // (defined(_OPENMP) && _OPENMP >= 201307)
+#  elif defined(_LIBCPP_COMPILER_CLANG_BASED)
 
-#  define _PSTL_PRAGMA_SIMD
-#  define _PSTL_PRAGMA_DECLARE_SIMD
-#  define _PSTL_PRAGMA_SIMD_REDUCTION(PRM)
-#  define _PSTL_PRAGMA_SIMD_SCAN(PRM)
-#  define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
-#  define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
-#  define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)
+#    define _PSTL_PRAGMA_SIMD _Pragma("clang loop vectorize(enable) interleave(enable)")
+#    define _PSTL_PRAGMA_DECLARE_SIMD
+#    define _PSTL_PRAGMA_SIMD_REDUCTION(PRM) _Pragma("clang loop vectorize(enable) interleave(enable)")
+#    define _PSTL_PRAGMA_SIMD_SCAN(PRM) _Pragma("clang loop vectorize(enable) interleave(enable)")
+#    define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
+#    define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
+#    define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)
 
-#endif // (defined(_OPENMP) && _OPENMP >= 201307)
+#  else // (defined(_OPENMP) && _OPENMP >= 201307)
 
-#define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
+#    define _PSTL_PRAGMA_SIMD
+#    define _PSTL_PRAGMA_DECLARE_SIMD
+#    define _PSTL_PRAGMA_SIMD_REDUCTION(PRM)
+#    define _PSTL_PRAGMA_SIMD_SCAN(PRM)
+#    define _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(PRM)
+#    define _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(PRM)
+#    define _PSTL_PRAGMA_DECLARE_REDUCTION(NAME, OP)
+
+#  endif // (defined(_OPENMP) && _OPENMP >= 201307)
+
+#  define _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
+
+// Optional attributes - these are useful for a better QoI, but not required to be available
+
+#  if __has_attribute(__no_sanitize__) && !defined(_LIBCPP_COMPILER_GCC)
+#    define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi")))
+#  else
+#    define _LIBCPP_NO_CFI
+#  endif
+
+#  if __has_attribute(__malloc__)
+#    define _LIBCPP_NOALIAS __attribute__((__malloc__))
+#  else
+#    define _LIBCPP_NOALIAS
+#  endif
+
+#  if __has_attribute(__using_if_exists__)
+#    define _LIBCPP_USING_IF_EXISTS __attribute__((__using_if_exists__))
+#  else
+#    define _LIBCPP_USING_IF_EXISTS
+#  endif
+
+#  if __has_cpp_attribute(__nodiscard__)
+#    define _LIBCPP_NODISCARD [[__nodiscard__]]
+#  else
+// We can't use GCC's [[gnu::warn_unused_result]] and
+// __attribute__((warn_unused_result)), because GCC does not silence them via
+// (void) cast.
+#    define _LIBCPP_NODISCARD
+#  endif
+
+#  if __has_attribute(__no_destroy__)
+#    define _LIBCPP_NO_DESTROY __attribute__((__no_destroy__))
+#  else
+#    define _LIBCPP_NO_DESTROY
+#  endif
+
+#  if __has_attribute(__diagnose_if__)
+#    define _LIBCPP_DIAGNOSE_WARNING(...) __attribute__((__diagnose_if__(__VA_ARGS__, "warning")))
+#  else
+#    define _LIBCPP_DIAGNOSE_WARNING(...)
+#  endif
+
+// Use a function like macro to imply that it must be followed by a semicolon
+#  if __has_cpp_attribute(fallthrough)
+#    define _LIBCPP_FALLTHROUGH() [[fallthrough]]
+#  elif __has_attribute(__fallthrough__)
+#    define _LIBCPP_FALLTHROUGH() __attribute__((__fallthrough__))
+#  else
+#    define _LIBCPP_FALLTHROUGH() ((void)0)
+#  endif
+
+#  if __has_cpp_attribute(_Clang::__lifetimebound__)
+#    define _LIBCPP_LIFETIMEBOUND [[_Clang::__lifetimebound__]]
+#  else
+#    define _LIBCPP_LIFETIMEBOUND
+#  endif
+
+#  if __has_attribute(__nodebug__)
+#    define _LIBCPP_NODEBUG __attribute__((__nodebug__))
+#  else
+#    define _LIBCPP_NODEBUG
+#  endif
+
+#  if __has_attribute(__standalone_debug__)
+#    define _LIBCPP_STANDALONE_DEBUG __attribute__((__standalone_debug__))
+#  else
+#    define _LIBCPP_STANDALONE_DEBUG
+#  endif
+
+#  if __has_attribute(__preferred_name__)
+#    define _LIBCPP_PREFERRED_NAME(x) __attribute__((__preferred_name__(x)))
+#  else
+#    define _LIBCPP_PREFERRED_NAME(x)
+#  endif
+
+#  if __has_attribute(__no_sanitize__)
+#    define _LIBCPP_NO_SANITIZE(...) __attribute__((__no_sanitize__(__VA_ARGS__)))
+#  else
+#    define _LIBCPP_NO_SANITIZE(...)
+#  endif
+
+#  if __has_attribute(__init_priority__)
+#    define _LIBCPP_INIT_PRIORITY_MAX __attribute__((__init_priority__(100)))
+#  else
+#    define _LIBCPP_INIT_PRIORITY_MAX
+#  endif
+
+#  if __has_attribute(__format__)
+// The attribute uses 1-based indices for ordinary and static member functions.
+// The attribute uses 2-based indices for non-static member functions.
+#    define _LIBCPP_ATTRIBUTE_FORMAT(archetype, format_string_index, first_format_arg_index)                           \
+      __attribute__((__format__(archetype, format_string_index, first_format_arg_index)))
+#  else
+#    define _LIBCPP_ATTRIBUTE_FORMAT(archetype, format_string_index, first_format_arg_index) /* nothing */
+#  endif
+
+#  if __has_attribute(__packed__)
+#    define _LIBCPP_PACKED __attribute__((__packed__))
+#  else
+#    define _LIBCPP_PACKED
+#  endif
+
+#  if defined(_LIBCPP_ABI_MICROSOFT) && __has_declspec_attribute(empty_bases)
+#    define _LIBCPP_DECLSPEC_EMPTY_BASES __declspec(empty_bases)
+#  else
+#    define _LIBCPP_DECLSPEC_EMPTY_BASES
+#  endif
+
+// Allow for build-time disabling of unsigned integer sanitization
+#  if __has_attribute(no_sanitize) && !defined(_LIBCPP_COMPILER_GCC)
+#    define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK __attribute__((__no_sanitize__("unsigned-integer-overflow")))
+#  else
+#    define _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+#  endif
+
+// Clang-18 has support for deducing this, but it does not set the FTM.
+#  if defined(__cpp_explicit_this_parameter) || (defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 1800)
+#    define _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER
+#  endif
 
 #endif // __cplusplus
 
diff --git a/third_party/libcxx/__config_site b/third_party/libcxx/__config_site
index d99f4580e..6f5fe9be3 100644
--- a/third_party/libcxx/__config_site
+++ b/third_party/libcxx/__config_site
@@ -26,25 +26,34 @@ __static_yoink("__demangle");
 #define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #define _LIBCPP_NO_ABI_TAG
-#define _LIBCPP_ABI_VERSION 2
-#define _LIBCPP_ABI_NAMESPACE __2
+#define _LIBCPP_ABI_VERSION 1
+#define _LIBCPP_ABI_NAMESPACE __1
+#define _LIBCPP_USING_GETENTROPY
 #define _LIBCPP_DISABLE_AVAILABILITY
 #define _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #define _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
 #define _LIBCPP_NO_VCRUNTIME
 #define _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION 1
 #define _LIBCPP_REMOVE_TRANSITIVE_INCLUDES
+#define _LIBCPP_HAS_THREAD_API_PTHREAD
+#define _LIBCPP_NO_VCRUNTIME
+#define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
+#define _LIBCPP_HAS_CLOCK_GETTIME
 
 #ifdef MODE_DBG
 #define _LIBCPP_ENABLE_DEBUG_MODE
 #define _LIBCPP_ENABLE_ASSERTIONS_DEFAULT 1
+#define _LIBCPP_HARDENING_MODE_DEFAULT (1 << 3) // debug
+#elif defined(TINY)
+#define _LIBCPP_ENABLE_ASSERTIONS_DEFAULT 0
+#define _LIBCPP_HARDENING_MODE_DEFAULT (1 << 1) // none
 #else
 #define _LIBCPP_ENABLE_ASSERTIONS_DEFAULT 0
+#define _LIBCPP_HARDENING_MODE_DEFAULT (1 << 2) // fast
 #endif
 
 // PSTL backends
-#define _LIBCPP_PSTL_CPU_BACKEND_SERIAL
-#define _LIBCPP_PSTL_CPU_BACKEND_THREAD
+#define _LIBCPP_PSTL_BACKEND_STD_THREAD
 
 // __USE_MINGW_ANSI_STDIO gets redefined on MinGW
 #ifdef __clang__
diff --git a/third_party/libcxx/__configuration/abi.h b/third_party/libcxx/__configuration/abi.h
new file mode 100644
index 000000000..710548d90
--- /dev/null
+++ b/third_party/libcxx/__configuration/abi.h
@@ -0,0 +1,159 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CONFIGURATION_ABI_H
+#define _LIBCPP___CONFIGURATION_ABI_H
+
+#include <__config_site>
+#include <__configuration/compiler.h>
+#include <__configuration/platform.h>
+
+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_ABI_VERSION >= 2
+// Change short string representation so that string data starts at offset 0,
+// improving its alignment in some cases.
+#  define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
+// Fix deque iterator type in order to support incomplete types.
+#  define _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
+// Fix undefined behavior in how std::list stores its linked nodes.
+#  define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB
+// Fix undefined behavior in  how __tree stores its end and parent nodes.
+#  define _LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB
+// Fix undefined behavior in how __hash_table stores its pointer types.
+#  define _LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB
+#  define _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB
+#  define _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
+// Override the default return value of exception::what() for bad_function_call::what()
+// with a string that is specific to bad_function_call (see http://wg21.link/LWG2233).
+// This is an ABI break on platforms that sign and authenticate vtable function pointers
+// because it changes the mangling of the virtual function located in the vtable, which
+// changes how it gets signed.
+#  define _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
+// Enable optimized version of __do_get_(un)signed which avoids redundant copies.
+#  define _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
+// Give reverse_iterator<T> one data member of type T, not two.
+// Also, in C++17 and later, don't derive iterator types from std::iterator.
+#  define _LIBCPP_ABI_NO_ITERATOR_BASES
+// Use the smallest possible integer type to represent the index of the variant.
+// Previously libc++ used "unsigned int" exclusively.
+#  define _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
+// Unstable attempt to provide a more optimized std::function
+#  define _LIBCPP_ABI_OPTIMIZED_FUNCTION
+// All the regex constants must be distinct and nonzero.
+#  define _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
+// Re-worked external template instantiations for std::string with a focus on
+// performance and fast-path inlining.
+#  define _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
+// Enable clang::trivial_abi on std::unique_ptr.
+#  define _LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI
+// Enable clang::trivial_abi on std::shared_ptr and std::weak_ptr
+#  define _LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI
+// std::random_device holds some state when it uses an implementation that gets
+// entropy from a file (see _LIBCPP_USING_DEV_RANDOM). When switching from this
+// implementation to another one on a platform that has already shipped
+// std::random_device, one needs to retain the same object layout to remain ABI
+// compatible. This switch removes these workarounds for platforms that don't care
+// about ABI compatibility.
+#  define _LIBCPP_ABI_NO_RANDOM_DEVICE_COMPATIBILITY_LAYOUT
+// Don't export the legacy __basic_string_common class and its methods from the built library.
+#  define _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
+// Don't export the legacy __vector_base_common class and its methods from the built library.
+#  define _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON
+// According to the Standard, `bitset::operator[] const` returns bool
+#  define _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
+// Fix the implementation of CityHash used for std::hash<fundamental-type>.
+// This is an ABI break because `std::hash` will return a different result,
+// which means that hashing the same object in translation units built against
+// different versions of libc++ can return inconsistent results. This is especially
+// tricky since std::hash is used in the implementation of unordered containers.
+//
+// The incorrect implementation of CityHash has the problem that it drops some
+// bits on the floor.
+#  define _LIBCPP_ABI_FIX_CITYHASH_IMPLEMENTATION
+// Remove the base 10 implementation of std::to_chars from the dylib.
+// The implementation moved to the header, but we still export the symbols from
+// the dylib for backwards compatibility.
+#  define _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
+// Define std::array/std::string_view iterators to be __wrap_iters instead of raw
+// pointers, which prevents people from relying on a non-portable implementation
+// detail. This is especially useful because enabling bounded iterators hardening
+// requires code not to make these assumptions.
+#  define _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_ARRAY
+#  define _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_STRING_VIEW
+// Dont' add an inline namespace for `std::filesystem`
+#  define _LIBCPP_ABI_NO_FILESYSTEM_INLINE_NAMESPACE
+// std::basic_ios uses WEOF to indicate that the fill value is
+// uninitialized. However, on platforms where the size of char_type is
+// equal to or greater than the size of int_type and char_type is unsigned,
+// std::char_traits<char_type>::eq_int_type() cannot distinguish between WEOF
+// and WCHAR_MAX. This ABI setting determines whether we should instead track whether the fill
+// value has been initialized using a separate boolean, which changes the ABI.
+#  define _LIBCPP_ABI_IOS_ALLOW_ARBITRARY_FILL_VALUE
+// Make a std::pair of trivially copyable types trivially copyable.
+// While this technically doesn't change the layout of pair itself, other types may decide to programatically change
+// their representation based on whether something is trivially copyable.
+#  define _LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR
+#elif _LIBCPP_ABI_VERSION == 1
+#  if !(defined(_LIBCPP_OBJECT_FORMAT_COFF) || defined(_LIBCPP_OBJECT_FORMAT_XCOFF))
+// Enable compiling copies of now inline methods into the dylib to support
+// applications compiled against older libraries. This is unnecessary with
+// COFF dllexport semantics, since dllexport forces a non-inline definition
+// of inline functions to be emitted anyway. Our own non-inline copy would
+// conflict with the dllexport-emitted copy, so we disable it. For XCOFF,
+// the linker will take issue with the symbols in the shared object if the
+// weak inline methods get visibility (such as from -fvisibility-inlines-hidden),
+// so disable it.
+#    define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
+#  endif
+// Feature macros for disabling pre ABI v1 features. All of these options
+// are deprecated.
+#  if defined(__FreeBSD__) && __FreeBSD__ < 14
+#    define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
+#  endif
+#endif
+
+// We had some bugs where we use [[no_unique_address]] together with construct_at,
+// which causes UB as the call on construct_at could write to overlapping subobjects
+//
+// https://github.com/llvm/llvm-project/issues/70506
+// https://github.com/llvm/llvm-project/issues/70494
+//
+// To fix the bug we had to change the ABI of some classes to remove [[no_unique_address]] under certain conditions.
+// The macro below is used for all classes whose ABI have changed as part of fixing these bugs.
+#define _LIBCPP_ABI_LLVM18_NO_UNIQUE_ADDRESS __attribute__((__abi_tag__("llvm18_nua")))
+
+// Changes the iterator type of select containers (see below) to a bounded iterator that keeps track of whether it's
+// within the bounds of the original container and asserts it on every dereference.
+//
+// ABI impact: changes the iterator type of the relevant containers.
+//
+// Supported containers:
+// - `span`;
+// - `string_view`.
+// #define _LIBCPP_ABI_BOUNDED_ITERATORS
+
+#if defined(_LIBCPP_COMPILER_CLANG_BASED)
+#  if defined(__APPLE__)
+#    if defined(__i386__) || defined(__x86_64__)
+// use old string layout on x86_64 and i386
+#    elif defined(__arm__)
+// use old string layout on arm (which does not include aarch64/arm64), except on watch ABIs
+#      if defined(__ARM_ARCH_7K__) && __ARM_ARCH_7K__ >= 2
+#        define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
+#      endif
+#    else
+#      define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
+#    endif
+#  endif
+#endif
+
+#endif // _LIBCPP___CONFIGURATION_ABI_H
diff --git a/third_party/libcxx/__configuration/availability.h b/third_party/libcxx/__configuration/availability.h
new file mode 100644
index 000000000..ab483a07c
--- /dev/null
+++ b/third_party/libcxx/__configuration/availability.h
@@ -0,0 +1,400 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CONFIGURATION_AVAILABILITY_H
+#define _LIBCPP___CONFIGURATION_AVAILABILITY_H
+
+#include <__configuration/compiler.h>
+#include <__configuration/language.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+// Libc++ is shipped by various vendors. In particular, it is used as a system
+// library on macOS, iOS and other Apple platforms. In order for users to be
+// able to compile a binary that is intended to be deployed to an older version
+// of a platform, Clang provides availability attributes [1]. These attributes
+// can be placed on declarations and are used to describe the life cycle of a
+// symbol in the library.
+//
+// The main goal is to ensure a compile-time error if a symbol that hasn't been
+// introduced in a previously released library is used in a program that targets
+// that previously released library. Normally, this would be a load-time error
+// when one tries to launch the program against the older library.
+//
+// For example, the filesystem library was introduced in the dylib in LLVM 9.
+// On Apple platforms, this corresponds to macOS 10.15. If a user compiles on
+// a macOS 10.15 host but targets macOS 10.13 with their program, the compiler
+// would normally not complain (because the required declarations are in the
+// headers), but the dynamic loader would fail to find the symbols when actually
+// trying to launch the program on macOS 10.13. To turn this into a compile-time
+// issue instead, declarations are annotated with when they were introduced, and
+// the compiler can produce a diagnostic if the program references something that
+// isn't available on the deployment target.
+//
+// This mechanism is general in nature, and any vendor can add their markup to
+// the library (see below). Whenever a new feature is added that requires support
+// in the shared library, two macros are added below to allow marking the feature
+// as unavailable:
+// 1. A macro named `_LIBCPP_AVAILABILITY_HAS_<feature>` which must be defined
+//    to `_LIBCPP_INTRODUCED_IN_<version>` for the appropriate LLVM version.
+// 2. A macro named `_LIBCPP_AVAILABILITY_<feature>`, which must be defined to
+//    `_LIBCPP_INTRODUCED_IN_<version>_MARKUP` for the appropriate LLVM version.
+//
+// When vendors decide to ship the feature as part of their shared library, they
+// can update the `_LIBCPP_INTRODUCED_IN_<version>` macro (and the markup counterpart)
+// based on the platform version they shipped that version of LLVM in. The library
+// will then use this markup to provide an optimal user experience on these platforms.
+//
+// Furthermore, many features in the standard library have corresponding
+// feature-test macros. The `_LIBCPP_AVAILABILITY_HAS_<feature>` macros
+// are checked by the corresponding feature-test macros generated by
+// generate_feature_test_macro_components.py to ensure that the library
+// doesn't announce a feature as being implemented if it is unavailable on
+// the deployment target.
+//
+// Note that this mechanism is disabled by default in the "upstream" libc++.
+// Availability annotations are only meaningful when shipping libc++ inside
+// a platform (i.e. as a system library), and so vendors that want them should
+// turn those annotations on at CMake configuration time.
+//
+// [1]: https://clang.llvm.org/docs/AttributeReference.html#availability
+
+// For backwards compatibility, allow users to define _LIBCPP_DISABLE_AVAILABILITY
+// for a while.
+#if defined(_LIBCPP_DISABLE_AVAILABILITY)
+#  if !defined(_LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
+#    define _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
+#  endif
+#endif
+
+// Availability markup is disabled when building the library, or when a non-Clang
+// compiler is used because only Clang supports the necessary attributes.
+#if defined(_LIBCPP_BUILDING_LIBRARY) || defined(_LIBCXXABI_BUILDING_LIBRARY) || !defined(_LIBCPP_COMPILER_CLANG_BASED)
+#  if !defined(_LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
+#    define _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
+#  endif
+#endif
+
+// When availability annotations are disabled, we take for granted that features introduced
+// in all versions of the library are available.
+#if defined(_LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_19 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_18 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_18_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_17 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_17_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_16 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_16_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_15 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_15_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_14 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_14_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_13 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_13_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_12 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_12_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_11 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_11_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_10 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_10_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_9 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE      /* nothing */
+#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_PUSH /* nothing */
+#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_POP  /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_8 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_8_ATTRIBUTE /* nothing */
+
+#  define _LIBCPP_INTRODUCED_IN_LLVM_4 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_4_ATTRIBUTE /* nothing */
+
+#elif defined(__APPLE__)
+
+// clang-format off
+
+// LLVM 19
+// TODO: Fill this in
+#  define _LIBCPP_INTRODUCED_IN_LLVM_19 0
+#  define _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE __attribute__((unavailable))
+
+// LLVM 18
+// TODO: Fill this in
+#  define _LIBCPP_INTRODUCED_IN_LLVM_18 0
+#  define _LIBCPP_INTRODUCED_IN_LLVM_18_ATTRIBUTE __attribute__((unavailable))
+
+// LLVM 17
+#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 140400) ||       \
+      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 170400) ||     \
+      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 170400) ||             \
+      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 100400)
+#    define _LIBCPP_INTRODUCED_IN_LLVM_17 0
+#  else
+#    define _LIBCPP_INTRODUCED_IN_LLVM_17 1
+#  endif
+#  define _LIBCPP_INTRODUCED_IN_LLVM_17_ATTRIBUTE                                                                 \
+    __attribute__((availability(macos, strict, introduced = 14.4)))                                               \
+    __attribute__((availability(ios, strict, introduced = 17.4)))                                                 \
+    __attribute__((availability(tvos, strict, introduced = 17.4)))                                                \
+    __attribute__((availability(watchos, strict, introduced = 10.4)))
+
+// LLVM 16
+#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 140000) ||       \
+      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 170000) ||     \
+      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 170000) ||             \
+      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 100000)
+#    define _LIBCPP_INTRODUCED_IN_LLVM_16 0
+#  else
+#    define _LIBCPP_INTRODUCED_IN_LLVM_16 1
+#  endif
+#  define _LIBCPP_INTRODUCED_IN_LLVM_16_ATTRIBUTE                                                                 \
+    __attribute__((availability(macos, strict, introduced = 14.0)))                                               \
+    __attribute__((availability(ios, strict, introduced = 17.0)))                                                 \
+    __attribute__((availability(tvos, strict, introduced = 17.0)))                                                \
+    __attribute__((availability(watchos, strict, introduced = 10.0)))
+
+// LLVM 15
+#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 130400) ||   \
+      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 160500) || \
+      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 160500) ||         \
+      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 90500)
+#    define _LIBCPP_INTRODUCED_IN_LLVM_15 0
+#  else
+#    define _LIBCPP_INTRODUCED_IN_LLVM_15 1
+#  endif
+#  define _LIBCPP_INTRODUCED_IN_LLVM_15_ATTRIBUTE                                                                 \
+    __attribute__((availability(macos, strict, introduced = 13.4)))                                               \
+    __attribute__((availability(ios, strict, introduced = 16.5)))                                                 \
+    __attribute__((availability(tvos, strict, introduced = 16.5)))                                                \
+    __attribute__((availability(watchos, strict, introduced = 9.5)))
+
+// LLVM 14
+#  define _LIBCPP_INTRODUCED_IN_LLVM_14 _LIBCPP_INTRODUCED_IN_LLVM_15
+#  define _LIBCPP_INTRODUCED_IN_LLVM_14_ATTRIBUTE _LIBCPP_INTRODUCED_IN_LLVM_15_ATTRIBUTE
+
+// LLVM 13
+#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 130000) ||   \
+      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 160000) || \
+      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 160000) ||         \
+      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 90000)
+#    define _LIBCPP_INTRODUCED_IN_LLVM_13 0
+#  else
+#    define _LIBCPP_INTRODUCED_IN_LLVM_13 1
+#  endif
+#  define _LIBCPP_INTRODUCED_IN_LLVM_13_ATTRIBUTE                                                                 \
+    __attribute__((availability(macos, strict, introduced = 13.0)))                                               \
+    __attribute__((availability(ios, strict, introduced = 16.0)))                                                 \
+    __attribute__((availability(tvos, strict, introduced = 16.0)))                                                \
+    __attribute__((availability(watchos, strict, introduced = 9.0)))
+
+// LLVM 12
+#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 120300)   ||     \
+      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 150300) ||     \
+      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 150300)         ||     \
+      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 80300)
+#    define _LIBCPP_INTRODUCED_IN_LLVM_12 0
+#  else
+#    define _LIBCPP_INTRODUCED_IN_LLVM_12 1
+#  endif
+#  define _LIBCPP_INTRODUCED_IN_LLVM_12_ATTRIBUTE                                                                 \
+    __attribute__((availability(macos, strict, introduced = 12.3)))                                               \
+    __attribute__((availability(ios, strict, introduced = 15.3)))                                                 \
+    __attribute__((availability(tvos, strict, introduced = 15.3)))                                                \
+    __attribute__((availability(watchos, strict, introduced = 8.3)))
+
+// LLVM 11
+#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 110000) ||   \
+      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 140000) || \
+      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 140000) ||         \
+      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 70000)
+#    define _LIBCPP_INTRODUCED_IN_LLVM_11 0
+#  else
+#    define _LIBCPP_INTRODUCED_IN_LLVM_11 1
+#  endif
+#  define _LIBCPP_INTRODUCED_IN_LLVM_11_ATTRIBUTE                                                                 \
+    __attribute__((availability(macos, strict, introduced = 11.0)))                                               \
+    __attribute__((availability(ios, strict, introduced = 14.0)))                                                 \
+    __attribute__((availability(tvos, strict, introduced = 14.0)))                                                \
+    __attribute__((availability(watchos, strict, introduced = 7.0)))
+
+// LLVM 10
+#  define _LIBCPP_INTRODUCED_IN_LLVM_10 _LIBCPP_INTRODUCED_IN_LLVM_11
+#  define _LIBCPP_INTRODUCED_IN_LLVM_10_ATTRIBUTE _LIBCPP_INTRODUCED_IN_LLVM_11_ATTRIBUTE
+
+// LLVM 9
+#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101500) ||   \
+      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 130000) || \
+      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 130000) ||         \
+      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 60000)
+#    define _LIBCPP_INTRODUCED_IN_LLVM_9 0
+#  else
+#    define _LIBCPP_INTRODUCED_IN_LLVM_9 1
+#  endif
+#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE                                                                  \
+    __attribute__((availability(macos, strict, introduced = 10.15)))                                              \
+    __attribute__((availability(ios, strict, introduced = 13.0)))                                                 \
+    __attribute__((availability(tvos, strict, introduced = 13.0)))                                                \
+    __attribute__((availability(watchos, strict, introduced = 6.0)))
+#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_PUSH                                                                            \
+    _Pragma("clang attribute push(__attribute__((availability(macos,strict,introduced=10.15))), apply_to=any(function,record))") \
+    _Pragma("clang attribute push(__attribute__((availability(ios,strict,introduced=13.0))), apply_to=any(function,record))")    \
+    _Pragma("clang attribute push(__attribute__((availability(tvos,strict,introduced=13.0))), apply_to=any(function,record))")   \
+    _Pragma("clang attribute push(__attribute__((availability(watchos,strict,introduced=6.0))), apply_to=any(function,record))")
+#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_POP                                                                    \
+    _Pragma("clang attribute pop") \
+    _Pragma("clang attribute pop") \
+    _Pragma("clang attribute pop") \
+    _Pragma("clang attribute pop")
+
+// LLVM 4
+#  if defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 50000
+#    define _LIBCPP_INTRODUCED_IN_LLVM_4 0
+#  else
+#    define _LIBCPP_INTRODUCED_IN_LLVM_4 1
+#  endif
+#  define _LIBCPP_INTRODUCED_IN_LLVM_4_ATTRIBUTE __attribute__((availability(watchos, strict, introduced = 5.0)))
+
+// clang-format on
+
+#else
+
+// ...New vendors can add availability markup here...
+
+#  error                                                                                                               \
+      "It looks like you're trying to enable vendor availability markup, but you haven't defined the corresponding macros yet!"
+
+#endif
+
+// These macros control the availability of std::bad_optional_access and
+// other exception types. These were put in the shared library to prevent
+// code bloat from every user program defining the vtable for these exception
+// types.
+//
+// Note that when exceptions are disabled, the methods that normally throw
+// these exceptions can be used even on older deployment targets, but those
+// methods will abort instead of throwing.
+#define _LIBCPP_AVAILABILITY_HAS_BAD_OPTIONAL_ACCESS _LIBCPP_INTRODUCED_IN_LLVM_4
+#define _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS _LIBCPP_INTRODUCED_IN_LLVM_4_ATTRIBUTE
+
+#define _LIBCPP_AVAILABILITY_HAS_BAD_VARIANT_ACCESS _LIBCPP_INTRODUCED_IN_LLVM_4
+#define _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS _LIBCPP_INTRODUCED_IN_LLVM_4_ATTRIBUTE
+
+#define _LIBCPP_AVAILABILITY_HAS_BAD_ANY_CAST _LIBCPP_INTRODUCED_IN_LLVM_4
+#define _LIBCPP_AVAILABILITY_BAD_ANY_CAST _LIBCPP_INTRODUCED_IN_LLVM_4_ATTRIBUTE
+
+// These macros control the availability of all parts of <filesystem> that
+// depend on something in the dylib.
+#define _LIBCPP_AVAILABILITY_HAS_FILESYSTEM_LIBRARY _LIBCPP_INTRODUCED_IN_LLVM_9
+#define _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE
+#define _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_PUSH
+#define _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_POP
+
+// This controls the availability of the C++20 synchronization library,
+// which requires shared library support for various operations
+// (see libcxx/src/atomic.cpp). This includes <barier>, <latch>,
+// <semaphore>, and notification functions on std::atomic.
+#define _LIBCPP_AVAILABILITY_HAS_SYNC _LIBCPP_INTRODUCED_IN_LLVM_11
+#define _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INTRODUCED_IN_LLVM_11_ATTRIBUTE
+
+// Enable additional explicit instantiations of iostreams components. This
+// reduces the number of weak definitions generated in programs that use
+// iostreams by providing a single strong definition in the shared library.
+//
+// TODO: Enable additional explicit instantiations on GCC once it supports exclude_from_explicit_instantiation,
+//       or once libc++ doesn't use the attribute anymore.
+// TODO: Enable them on Windows once https://llvm.org/PR41018 has been fixed.
+#if !defined(_LIBCPP_COMPILER_GCC) && !defined(_WIN32)
+#  define _LIBCPP_AVAILABILITY_HAS_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1 _LIBCPP_INTRODUCED_IN_LLVM_12
+#else
+#  define _LIBCPP_AVAILABILITY_HAS_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1 0
+#endif
+
+// This controls the availability of floating-point std::to_chars functions.
+// These overloads were added later than the integer overloads.
+#define _LIBCPP_AVAILABILITY_HAS_TO_CHARS_FLOATING_POINT _LIBCPP_INTRODUCED_IN_LLVM_14
+#define _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_INTRODUCED_IN_LLVM_14_ATTRIBUTE
+
+// This controls whether the library claims to provide a default verbose
+// termination function, and consequently whether the headers will try
+// to use it when the mechanism isn't overriden at compile-time.
+#define _LIBCPP_AVAILABILITY_HAS_VERBOSE_ABORT _LIBCPP_INTRODUCED_IN_LLVM_15
+#define _LIBCPP_AVAILABILITY_VERBOSE_ABORT _LIBCPP_INTRODUCED_IN_LLVM_15_ATTRIBUTE
+
+// This controls the availability of the C++17 std::pmr library,
+// which is implemented in large part in the built library.
+//
+// TODO: Enable std::pmr markup once https://github.com/llvm/llvm-project/issues/40340 has been fixed
+//       Until then, it is possible for folks to try to use `std::pmr` when back-deploying to targets that don't support
+//       it and it'll be a load-time error, but we don't have a good alternative because the library won't compile if we
+//       use availability annotations until that bug has been fixed.
+#define _LIBCPP_AVAILABILITY_HAS_PMR _LIBCPP_INTRODUCED_IN_LLVM_16
+#define _LIBCPP_AVAILABILITY_PMR
+
+// These macros controls the availability of __cxa_init_primary_exception
+// in the built library, which std::make_exception_ptr might use
+// (see libcxx/include/__exception/exception_ptr.h).
+#define _LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION _LIBCPP_INTRODUCED_IN_LLVM_18
+#define _LIBCPP_AVAILABILITY_INIT_PRIMARY_EXCEPTION _LIBCPP_INTRODUCED_IN_LLVM_18_ATTRIBUTE
+
+// This controls the availability of C++23 <print>, which
+// has a dependency on the built library (it needs access to
+// the underlying buffer types of std::cout, std::cerr, and std::clog.
+#define _LIBCPP_AVAILABILITY_HAS_PRINT _LIBCPP_INTRODUCED_IN_LLVM_18
+#define _LIBCPP_AVAILABILITY_PRINT _LIBCPP_INTRODUCED_IN_LLVM_18_ATTRIBUTE
+
+// This controls the availability of the C++20 time zone database.
+// The parser code is built in the library.
+#define _LIBCPP_AVAILABILITY_HAS_TZDB _LIBCPP_INTRODUCED_IN_LLVM_19
+#define _LIBCPP_AVAILABILITY_TZDB _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE
+
+// These macros determine whether we assume that std::bad_function_call and
+// std::bad_expected_access provide a key function in the dylib. This allows
+// centralizing their vtable and typeinfo instead of having all TUs provide
+// a weak definition that then gets deduplicated.
+#define _LIBCPP_AVAILABILITY_HAS_BAD_FUNCTION_CALL_KEY_FUNCTION _LIBCPP_INTRODUCED_IN_LLVM_19
+#define _LIBCPP_AVAILABILITY_BAD_FUNCTION_CALL_KEY_FUNCTION _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE
+#define _LIBCPP_AVAILABILITY_HAS_BAD_EXPECTED_ACCESS_KEY_FUNCTION _LIBCPP_INTRODUCED_IN_LLVM_19
+#define _LIBCPP_AVAILABILITY_BAD_EXPECTED_ACCESS_KEY_FUNCTION _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE
+
+// Define availability attributes that depend on _LIBCPP_HAS_NO_EXCEPTIONS.
+// Those are defined in terms of the availability attributes above, and
+// should not be vendor-specific.
+#if defined(_LIBCPP_HAS_NO_EXCEPTIONS)
+#  define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
+#  define _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
+#  define _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
+#else
+#  define _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _LIBCPP_AVAILABILITY_BAD_ANY_CAST
+#  define _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS
+#  define _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS
+#endif
+
+// Define availability attributes that depend on both
+// _LIBCPP_HAS_NO_EXCEPTIONS and _LIBCPP_HAS_NO_RTTI.
+#if defined(_LIBCPP_HAS_NO_EXCEPTIONS) || defined(_LIBCPP_HAS_NO_RTTI)
+#  undef _LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION
+#  undef _LIBCPP_AVAILABILITY_INIT_PRIMARY_EXCEPTION
+#  define _LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION 0
+#  define _LIBCPP_AVAILABILITY_INIT_PRIMARY_EXCEPTION
+#endif
+
+#endif // _LIBCPP___CONFIGURATION_AVAILABILITY_H
diff --git a/third_party/libcxx/__configuration/compiler.h b/third_party/libcxx/__configuration/compiler.h
new file mode 100644
index 000000000..80ece22bb
--- /dev/null
+++ b/third_party/libcxx/__configuration/compiler.h
@@ -0,0 +1,51 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CONFIGURATION_COMPILER_H
+#define _LIBCPP___CONFIGURATION_COMPILER_H
+
+#include <__config_site>
+
+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
+#  pragma GCC system_header
+#endif
+
+#if defined(__apple_build_version__)
+// Given AppleClang XX.Y.Z, _LIBCPP_APPLE_CLANG_VER is XXYZ (e.g. AppleClang 14.0.3 => 1403)
+#  define _LIBCPP_COMPILER_CLANG_BASED
+#  define _LIBCPP_APPLE_CLANG_VER (__apple_build_version__ / 10000)
+#elif defined(__clang__)
+#  define _LIBCPP_COMPILER_CLANG_BASED
+#  define _LIBCPP_CLANG_VER (__clang_major__ * 100 + __clang_minor__)
+#elif defined(__GNUC__)
+#  define _LIBCPP_COMPILER_GCC
+#  define _LIBCPP_GCC_VER (__GNUC__ * 100 + __GNUC_MINOR__)
+#endif
+
+#ifdef __cplusplus
+
+// Warn if a compiler version is used that is not supported anymore
+// LLVM RELEASE Update the minimum compiler versions
+#  if defined(_LIBCPP_CLANG_VER)
+#    if _LIBCPP_CLANG_VER < 1700
+#      warning "Libc++ only supports Clang 17 and later"
+#    endif
+#  elif defined(_LIBCPP_APPLE_CLANG_VER)
+#    if _LIBCPP_APPLE_CLANG_VER < 1500
+#      warning "Libc++ only supports AppleClang 15 and later"
+#    endif
+#  elif defined(_LIBCPP_GCC_VER)
+#    if _LIBCPP_GCC_VER < 1400
+#      warning "Libc++ only supports GCC 14 and later"
+#    endif
+#  endif
+
+#endif
+
+#endif // _LIBCPP___CONFIGURATION_COMPILER_H
diff --git a/third_party/libcxx/__configuration/language.h b/third_party/libcxx/__configuration/language.h
new file mode 100644
index 000000000..fa62a7b6f
--- /dev/null
+++ b/third_party/libcxx/__configuration/language.h
@@ -0,0 +1,46 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CONFIGURATION_LANGUAGE_H
+#define _LIBCPP___CONFIGURATION_LANGUAGE_H
+
+#include <__config_site>
+
+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
+#  pragma GCC system_header
+#endif
+
+// NOLINTBEGIN(libcpp-cpp-version-check)
+#ifdef __cplusplus
+#  if __cplusplus <= 201103L
+#    define _LIBCPP_STD_VER 11
+#  elif __cplusplus <= 201402L
+#    define _LIBCPP_STD_VER 14
+#  elif __cplusplus <= 201703L
+#    define _LIBCPP_STD_VER 17
+#  elif __cplusplus <= 202002L
+#    define _LIBCPP_STD_VER 20
+#  elif __cplusplus <= 202302L
+#    define _LIBCPP_STD_VER 23
+#  else
+// Expected release year of the next C++ standard
+#    define _LIBCPP_STD_VER 26
+#  endif
+#endif // __cplusplus
+// NOLINTEND(libcpp-cpp-version-check)
+
+#if !defined(__cpp_rtti) || __cpp_rtti < 199711L
+#  define _LIBCPP_HAS_NO_RTTI
+#endif
+
+#if !defined(__cpp_exceptions) || __cpp_exceptions < 199711L
+#  define _LIBCPP_HAS_NO_EXCEPTIONS
+#endif
+
+#endif // _LIBCPP___CONFIGURATION_LANGUAGE_H
diff --git a/third_party/libcxx/__configuration/platform.h b/third_party/libcxx/__configuration/platform.h
new file mode 100644
index 000000000..27f68d04e
--- /dev/null
+++ b/third_party/libcxx/__configuration/platform.h
@@ -0,0 +1,54 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CONFIGURATION_PLATFORM_H
+#define _LIBCPP___CONFIGURATION_PLATFORM_H
+
+#include <__config_site>
+
+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
+#  pragma GCC system_header
+#endif
+
+#if defined(__ELF__)
+#  define _LIBCPP_OBJECT_FORMAT_ELF 1
+#elif defined(__MACH__)
+#  define _LIBCPP_OBJECT_FORMAT_MACHO 1
+#elif defined(_WIN32)
+#  define _LIBCPP_OBJECT_FORMAT_COFF 1
+#elif defined(__wasm__)
+#  define _LIBCPP_OBJECT_FORMAT_WASM 1
+#elif defined(_AIX)
+#  define _LIBCPP_OBJECT_FORMAT_XCOFF 1
+#else
+// ... add new file formats here ...
+#endif
+
+// Need to detect which libc we're using if we're on Linux.
+#if defined(__linux__)
+#  include <features.h>
+#  if defined(__GLIBC_PREREQ)
+#    define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)
+#  else
+#    define _LIBCPP_GLIBC_PREREQ(a, b) 0
+#  endif // defined(__GLIBC_PREREQ)
+#endif   // defined(__linux__)
+
+#ifndef __BYTE_ORDER__
+#  error                                                                                                               \
+      "Your compiler doesn't seem to define __BYTE_ORDER__, which is required by libc++ to know the endianness of your target platform"
+#endif
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#  define _LIBCPP_LITTLE_ENDIAN
+#elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#  define _LIBCPP_BIG_ENDIAN
+#endif // __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+
+#endif // _LIBCPP___CONFIGURATION_PLATFORM_H
diff --git a/third_party/libcxx/__coroutine/coroutine_handle.h b/third_party/libcxx/__coroutine/coroutine_handle.h
index 2135111e4..4557a6643 100644
--- a/third_party/libcxx/__coroutine/coroutine_handle.h
+++ b/third_party/libcxx/__coroutine/coroutine_handle.h
@@ -32,166 +32,141 @@ struct _LIBCPP_TEMPLATE_VIS coroutine_handle;
 template <>
 struct _LIBCPP_TEMPLATE_VIS coroutine_handle<void> {
 public:
-    // [coroutine.handle.con], construct/reset
-    constexpr coroutine_handle() noexcept = default;
+  // [coroutine.handle.con], construct/reset
+  constexpr coroutine_handle() noexcept = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr coroutine_handle(nullptr_t) noexcept {}
+  _LIBCPP_HIDE_FROM_ABI constexpr coroutine_handle(nullptr_t) noexcept {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    coroutine_handle& operator=(nullptr_t) noexcept {
-        __handle_ = nullptr;
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI coroutine_handle& operator=(nullptr_t) noexcept {
+    __handle_ = nullptr;
+    return *this;
+  }
 
-    // [coroutine.handle.export.import], export/import
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void* address() const noexcept { return __handle_; }
+  // [coroutine.handle.export.import], export/import
+  _LIBCPP_HIDE_FROM_ABI constexpr void* address() const noexcept { return __handle_; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr coroutine_handle from_address(void* __addr) noexcept {
-        coroutine_handle __tmp;
-        __tmp.__handle_ = __addr;
-        return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI static constexpr coroutine_handle from_address(void* __addr) noexcept {
+    coroutine_handle __tmp;
+    __tmp.__handle_ = __addr;
+    return __tmp;
+  }
 
-    // [coroutine.handle.observers], observers
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit operator bool() const noexcept {
-        return __handle_ != nullptr;
-    }
+  // [coroutine.handle.observers], observers
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __handle_ != nullptr; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    bool done() const {
-        _LIBCPP_ASSERT(__is_suspended(), "done() can be called only on suspended coroutines");
-        return __builtin_coro_done(__handle_);
-    }
+  _LIBCPP_HIDE_FROM_ABI bool done() const {
+    _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(__is_suspended(), "done() can be called only on suspended coroutines");
+    return __builtin_coro_done(__handle_);
+  }
 
-    // [coroutine.handle.resumption], resumption
-    _LIBCPP_HIDE_FROM_ABI
-    void operator()() const { resume(); }
+  // [coroutine.handle.resumption], resumption
+  _LIBCPP_HIDE_FROM_ABI void operator()() const { resume(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    void resume() const {
-        _LIBCPP_ASSERT(__is_suspended(), "resume() can be called only on suspended coroutines");
-        _LIBCPP_ASSERT(!done(), "resume() has undefined behavior when the coroutine is done");
-        __builtin_coro_resume(__handle_);
-    }
+  _LIBCPP_HIDE_FROM_ABI void resume() const {
+    _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(__is_suspended(), "resume() can be called only on suspended coroutines");
+    _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(!done(), "resume() has undefined behavior when the coroutine is done");
+    __builtin_coro_resume(__handle_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    void destroy() const {
-        _LIBCPP_ASSERT(__is_suspended(), "destroy() can be called only on suspended coroutines");
-        __builtin_coro_destroy(__handle_);
-    }
+  _LIBCPP_HIDE_FROM_ABI void destroy() const {
+    _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(__is_suspended(), "destroy() can be called only on suspended coroutines");
+    __builtin_coro_destroy(__handle_);
+  }
 
 private:
-    _LIBCPP_HIDE_FROM_ABI bool __is_suspended() const {
-        // FIXME actually implement a check for if the coro is suspended.
-        return __handle_ != nullptr;
-    }
+  _LIBCPP_HIDE_FROM_ABI bool __is_suspended() const {
+    // FIXME actually implement a check for if the coro is suspended.
+    return __handle_ != nullptr;
+  }
 
-    void* __handle_ = nullptr;
+  void* __handle_ = nullptr;
 };
 
 // [coroutine.handle.compare]
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
-    return __x.address() == __y.address();
+inline _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
+  return __x.address() == __y.address();
 }
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr strong_ordering operator<=>(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
-    return compare_three_way()(__x.address(), __y.address());
+inline _LIBCPP_HIDE_FROM_ABI constexpr strong_ordering
+operator<=>(coroutine_handle<> __x, coroutine_handle<> __y) noexcept {
+  return compare_three_way()(__x.address(), __y.address());
 }
 
 template <class _Promise>
 struct _LIBCPP_TEMPLATE_VIS coroutine_handle {
 public:
-    // [coroutine.handle.con], construct/reset
-    constexpr coroutine_handle() noexcept = default;
+  // [coroutine.handle.con], construct/reset
+  constexpr coroutine_handle() noexcept = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr coroutine_handle(nullptr_t) noexcept {}
+  _LIBCPP_HIDE_FROM_ABI constexpr coroutine_handle(nullptr_t) noexcept {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    static coroutine_handle from_promise(_Promise& __promise) {
-        using _RawPromise = __remove_cv_t<_Promise>;
-        coroutine_handle __tmp;
-        __tmp.__handle_ =
-            __builtin_coro_promise(_VSTD::addressof(const_cast<_RawPromise&>(__promise)), alignof(_Promise), true);
-        return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI static coroutine_handle from_promise(_Promise& __promise) {
+    using _RawPromise = __remove_cv_t<_Promise>;
+    coroutine_handle __tmp;
+    __tmp.__handle_ =
+        __builtin_coro_promise(std::addressof(const_cast<_RawPromise&>(__promise)), alignof(_Promise), true);
+    return __tmp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    coroutine_handle& operator=(nullptr_t) noexcept {
-        __handle_ = nullptr;
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI coroutine_handle& operator=(nullptr_t) noexcept {
+    __handle_ = nullptr;
+    return *this;
+  }
 
-    // [coroutine.handle.export.import], export/import
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void* address() const noexcept { return __handle_; }
+  // [coroutine.handle.export.import], export/import
+  _LIBCPP_HIDE_FROM_ABI constexpr void* address() const noexcept { return __handle_; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr coroutine_handle from_address(void* __addr) noexcept {
-        coroutine_handle __tmp;
-        __tmp.__handle_ = __addr;
-        return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI static constexpr coroutine_handle from_address(void* __addr) noexcept {
+    coroutine_handle __tmp;
+    __tmp.__handle_ = __addr;
+    return __tmp;
+  }
 
-    // [coroutine.handle.conv], conversion
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr operator coroutine_handle<>() const noexcept {
-        return coroutine_handle<>::from_address(address());
-    }
+  // [coroutine.handle.conv], conversion
+  _LIBCPP_HIDE_FROM_ABI constexpr operator coroutine_handle<>() const noexcept {
+    return coroutine_handle<>::from_address(address());
+  }
 
-    // [coroutine.handle.observers], observers
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit operator bool() const noexcept {
-        return __handle_ != nullptr;
-    }
+  // [coroutine.handle.observers], observers
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __handle_ != nullptr; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    bool done() const {
-        _LIBCPP_ASSERT(__is_suspended(), "done() can be called only on suspended coroutines");
-        return __builtin_coro_done(__handle_);
-    }
+  _LIBCPP_HIDE_FROM_ABI bool done() const {
+    _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(__is_suspended(), "done() can be called only on suspended coroutines");
+    return __builtin_coro_done(__handle_);
+  }
 
-    // [coroutine.handle.resumption], resumption
-    _LIBCPP_HIDE_FROM_ABI
-    void operator()() const { resume(); }
+  // [coroutine.handle.resumption], resumption
+  _LIBCPP_HIDE_FROM_ABI void operator()() const { resume(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    void resume() const {
-        _LIBCPP_ASSERT(__is_suspended(), "resume() can be called only on suspended coroutines");
-        _LIBCPP_ASSERT(!done(), "resume() has undefined behavior when the coroutine is done");
-        __builtin_coro_resume(__handle_);
-    }
+  _LIBCPP_HIDE_FROM_ABI void resume() const {
+    _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(__is_suspended(), "resume() can be called only on suspended coroutines");
+    _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(!done(), "resume() has undefined behavior when the coroutine is done");
+    __builtin_coro_resume(__handle_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    void destroy() const {
-        _LIBCPP_ASSERT(__is_suspended(), "destroy() can be called only on suspended coroutines");
-        __builtin_coro_destroy(__handle_);
-    }
+  _LIBCPP_HIDE_FROM_ABI void destroy() const {
+    _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(__is_suspended(), "destroy() can be called only on suspended coroutines");
+    __builtin_coro_destroy(__handle_);
+  }
 
-    // [coroutine.handle.promise], promise access
-    _LIBCPP_HIDE_FROM_ABI
-    _Promise& promise() const {
-        return *static_cast<_Promise*>(__builtin_coro_promise(this->__handle_, alignof(_Promise), false));
-    }
+  // [coroutine.handle.promise], promise access
+  _LIBCPP_HIDE_FROM_ABI _Promise& promise() const {
+    return *static_cast<_Promise*>(__builtin_coro_promise(this->__handle_, alignof(_Promise), false));
+  }
 
 private:
-    _LIBCPP_HIDE_FROM_ABI bool __is_suspended() const {
-        // FIXME actually implement a check for if the coro is suspended.
-        return __handle_ != nullptr;
-    }
-    void* __handle_ = nullptr;
+  _LIBCPP_HIDE_FROM_ABI bool __is_suspended() const {
+    // FIXME actually implement a check for if the coro is suspended.
+    return __handle_ != nullptr;
+  }
+  void* __handle_ = nullptr;
 };
 
 // [coroutine.handle.hash]
 template <class _Tp>
 struct hash<coroutine_handle<_Tp>> {
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(const coroutine_handle<_Tp>& __v) const noexcept { return hash<void*>()(__v.address()); }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const coroutine_handle<_Tp>& __v) const noexcept {
+    return hash<void*>()(__v.address());
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__coroutine/coroutine_traits.h b/third_party/libcxx/__coroutine/coroutine_traits.h
index 7122cc8ea..78f05341f 100644
--- a/third_party/libcxx/__coroutine/coroutine_traits.h
+++ b/third_party/libcxx/__coroutine/coroutine_traits.h
@@ -34,17 +34,12 @@ template <class _Tp, class = void>
 struct __coroutine_traits_sfinae {};
 
 template <class _Tp>
-struct __coroutine_traits_sfinae<
-    _Tp, __void_t<typename _Tp::promise_type> >
-{
+struct __coroutine_traits_sfinae< _Tp, __void_t<typename _Tp::promise_type> > {
   using promise_type = typename _Tp::promise_type;
 };
 
 template <class _Ret, class... _Args>
-struct coroutine_traits
-    : public __coroutine_traits_sfinae<_Ret>
-{
-};
+struct coroutine_traits : public __coroutine_traits_sfinae<_Ret> {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__coroutine/noop_coroutine_handle.h b/third_party/libcxx/__coroutine/noop_coroutine_handle.h
index 9b7802d1e..da13d5796 100644
--- a/third_party/libcxx/__coroutine/noop_coroutine_handle.h
+++ b/third_party/libcxx/__coroutine/noop_coroutine_handle.h
@@ -20,7 +20,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__builtin_coro_noop) || defined(_LIBCPP_COMPILER_GCC)
+#  if __has_builtin(__builtin_coro_noop) || defined(_LIBCPP_COMPILER_GCC)
 
 // [coroutine.noop]
 // [coroutine.promise.noop]
@@ -30,80 +30,67 @@ struct noop_coroutine_promise {};
 template <>
 struct _LIBCPP_TEMPLATE_VIS coroutine_handle<noop_coroutine_promise> {
 public:
-    // [coroutine.handle.noop.conv], conversion
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr operator coroutine_handle<>() const noexcept {
-        return coroutine_handle<>::from_address(address());
-    }
+  // [coroutine.handle.noop.conv], conversion
+  _LIBCPP_HIDE_FROM_ABI constexpr operator coroutine_handle<>() const noexcept {
+    return coroutine_handle<>::from_address(address());
+  }
 
-    // [coroutine.handle.noop.observers], observers
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit operator bool() const noexcept { return true; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr bool done() const noexcept { return false; }
+  // [coroutine.handle.noop.observers], observers
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool done() const noexcept { return false; }
 
-    // [coroutine.handle.noop.resumption], resumption
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator()() const noexcept {}
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void resume() const noexcept {}
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void destroy() const noexcept {}
+  // [coroutine.handle.noop.resumption], resumption
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()() const noexcept {}
+  _LIBCPP_HIDE_FROM_ABI constexpr void resume() const noexcept {}
+  _LIBCPP_HIDE_FROM_ABI constexpr void destroy() const noexcept {}
 
-    // [coroutine.handle.noop.promise], promise access
-    _LIBCPP_HIDE_FROM_ABI
-    noop_coroutine_promise& promise() const noexcept {
-        return *static_cast<noop_coroutine_promise*>(
-            __builtin_coro_promise(this->__handle_, alignof(noop_coroutine_promise), false));
-    }
+  // [coroutine.handle.noop.promise], promise access
+  _LIBCPP_HIDE_FROM_ABI noop_coroutine_promise& promise() const noexcept {
+    return *static_cast<noop_coroutine_promise*>(
+        __builtin_coro_promise(this->__handle_, alignof(noop_coroutine_promise), false));
+  }
 
-    // [coroutine.handle.noop.address], address
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void* address() const noexcept { return __handle_; }
+  // [coroutine.handle.noop.address], address
+  _LIBCPP_HIDE_FROM_ABI constexpr void* address() const noexcept { return __handle_; }
 
 private:
-    _LIBCPP_HIDE_FROM_ABI
-    friend coroutine_handle<noop_coroutine_promise> noop_coroutine() noexcept;
+  _LIBCPP_HIDE_FROM_ABI friend coroutine_handle<noop_coroutine_promise> noop_coroutine() noexcept;
 
-#if __has_builtin(__builtin_coro_noop)
-    _LIBCPP_HIDE_FROM_ABI coroutine_handle() noexcept {
-        this->__handle_ = __builtin_coro_noop();
-    }
+#    if __has_builtin(__builtin_coro_noop)
+  _LIBCPP_HIDE_FROM_ABI coroutine_handle() noexcept { this->__handle_ = __builtin_coro_noop(); }
 
-    void* __handle_ = nullptr;
+  void* __handle_ = nullptr;
 
-#elif defined(_LIBCPP_COMPILER_GCC)
-    // GCC doesn't implement __builtin_coro_noop().
-    // Construct the coroutine frame manually instead.
-    struct __noop_coroutine_frame_ty_ {
-        static void __dummy_resume_destroy_func() { }
+#    elif defined(_LIBCPP_COMPILER_GCC)
+  // GCC doesn't implement __builtin_coro_noop().
+  // Construct the coroutine frame manually instead.
+  struct __noop_coroutine_frame_ty_ {
+    static void __dummy_resume_destroy_func() {}
 
-        void (*__resume_)() = __dummy_resume_destroy_func;
-        void (*__destroy_)() = __dummy_resume_destroy_func;
-        struct noop_coroutine_promise __promise_;
-    };
+    void (*__resume_)()  = __dummy_resume_destroy_func;
+    void (*__destroy_)() = __dummy_resume_destroy_func;
+    struct noop_coroutine_promise __promise_;
+  };
 
-    static __noop_coroutine_frame_ty_ __noop_coroutine_frame_;
+  static __noop_coroutine_frame_ty_ __noop_coroutine_frame_;
 
-    void* __handle_ = &__noop_coroutine_frame_;
+  void* __handle_ = &__noop_coroutine_frame_;
 
-    _LIBCPP_HIDE_FROM_ABI coroutine_handle() noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI coroutine_handle() noexcept = default;
 
-#endif // __has_builtin(__builtin_coro_noop)
+#    endif // __has_builtin(__builtin_coro_noop)
 };
 
 using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
 
-#if defined(_LIBCPP_COMPILER_GCC)
-inline noop_coroutine_handle::__noop_coroutine_frame_ty_
-    noop_coroutine_handle::__noop_coroutine_frame_{};
-#endif
+#    if defined(_LIBCPP_COMPILER_GCC)
+inline noop_coroutine_handle::__noop_coroutine_frame_ty_ noop_coroutine_handle::__noop_coroutine_frame_{};
+#    endif
 
 // [coroutine.noop.coroutine]
-inline _LIBCPP_HIDE_FROM_ABI
-noop_coroutine_handle noop_coroutine() noexcept { return noop_coroutine_handle(); }
+inline _LIBCPP_HIDE_FROM_ABI noop_coroutine_handle noop_coroutine() noexcept { return noop_coroutine_handle(); }
 
-#endif // __has_builtin(__builtin_coro_noop) || defined(_LIBCPP_COMPILER_GCC)
+#  endif // __has_builtin(__builtin_coro_noop) || defined(_LIBCPP_COMPILER_GCC)
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__coroutine/trivial_awaitables.h b/third_party/libcxx/__coroutine/trivial_awaitables.h
index 0e4b08e37..b604bd3c2 100644
--- a/third_party/libcxx/__coroutine/trivial_awaitables.h
+++ b/third_party/libcxx/__coroutine/trivial_awaitables.h
@@ -22,21 +22,15 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // [coroutine.trivial.awaitables]
 struct suspend_never {
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr bool await_ready() const noexcept { return true; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void await_resume() const noexcept {}
+  _LIBCPP_HIDE_FROM_ABI constexpr bool await_ready() const noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI constexpr void await_suspend(coroutine_handle<>) const noexcept {}
+  _LIBCPP_HIDE_FROM_ABI constexpr void await_resume() const noexcept {}
 };
 
 struct suspend_always {
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr bool await_ready() const noexcept { return false; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void await_suspend(coroutine_handle<>) const noexcept {}
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void await_resume() const noexcept {}
+  _LIBCPP_HIDE_FROM_ABI constexpr bool await_ready() const noexcept { return false; }
+  _LIBCPP_HIDE_FROM_ABI constexpr void await_suspend(coroutine_handle<>) const noexcept {}
+  _LIBCPP_HIDE_FROM_ABI constexpr void await_resume() const noexcept {}
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__debug b/third_party/libcxx/__debug
deleted file mode 100644
index ccbfae723..000000000
--- a/third_party/libcxx/__debug
+++ /dev/null
@@ -1,266 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___DEBUG
-#define _LIBCPP___DEBUG
-
-#include <__assert>
-#include <__config>
-#include <__type_traits/is_constant_evaluated.h>
-#include <cstddef>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if defined(_LIBCPP_ENABLE_DEBUG_MODE) && !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY)
-# define _LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY
-#endif
-
-#if defined(_LIBCPP_ENABLE_DEBUG_MODE) && !defined(_LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING)
-# define _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
-#endif
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-#   define _LIBCPP_DEBUG_ASSERT(x, m) _LIBCPP_ASSERT(::std::__libcpp_is_constant_evaluated() || (x), m)
-#else
-#   define _LIBCPP_DEBUG_ASSERT(x, m) ((void)0)
-#endif
-
-#if defined(_LIBCPP_ENABLE_DEBUG_MODE) || defined(_LIBCPP_BUILDING_LIBRARY)
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-struct _LIBCPP_TYPE_VIS __c_node;
-
-struct _LIBCPP_TYPE_VIS __i_node
-{
-    void* __i_;
-    __i_node* __next_;
-    __c_node* __c_;
-
-    __i_node(const __i_node&) = delete;
-    __i_node& operator=(const __i_node&) = delete;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __i_node(void* __i, __i_node* __next, __c_node* __c)
-        : __i_(__i), __next_(__next), __c_(__c) {}
-    ~__i_node();
-};
-
-struct _LIBCPP_TYPE_VIS __c_node
-{
-    void* __c_;
-    __c_node* __next_;
-    __i_node** beg_;
-    __i_node** end_;
-    __i_node** cap_;
-
-    __c_node(const __c_node&) = delete;
-    __c_node& operator=(const __c_node&) = delete;
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __c_node(void* __c, __c_node* __next)
-        : __c_(__c), __next_(__next), beg_(nullptr), end_(nullptr), cap_(nullptr) {}
-    virtual ~__c_node();
-
-    virtual bool __dereferenceable(const void*) const = 0;
-    virtual bool __decrementable(const void*) const = 0;
-    virtual bool __addable(const void*, ptrdiff_t) const = 0;
-    virtual bool __subscriptable(const void*, ptrdiff_t) const = 0;
-
-    void __add(__i_node* __i);
-    _LIBCPP_HIDDEN void __remove(__i_node* __i);
-};
-
-template <class _Cont>
-struct _C_node
-    : public __c_node
-{
-    explicit _C_node(void* __c, __c_node* __n)
-        : __c_node(__c, __n) {}
-
-    bool __dereferenceable(const void*) const override;
-    bool __decrementable(const void*) const override;
-    bool __addable(const void*, ptrdiff_t) const override;
-    bool __subscriptable(const void*, ptrdiff_t) const override;
-};
-
-template <class _Cont>
-inline bool
-_C_node<_Cont>::__dereferenceable(const void* __i) const
-{
-    typedef typename _Cont::const_iterator iterator;
-    const iterator* __j = static_cast<const iterator*>(__i);
-    _Cont* __cp = static_cast<_Cont*>(__c_);
-    return __cp->__dereferenceable(__j);
-}
-
-template <class _Cont>
-inline bool
-_C_node<_Cont>::__decrementable(const void* __i) const
-{
-    typedef typename _Cont::const_iterator iterator;
-    const iterator* __j = static_cast<const iterator*>(__i);
-    _Cont* __cp = static_cast<_Cont*>(__c_);
-    return __cp->__decrementable(__j);
-}
-
-template <class _Cont>
-inline bool
-_C_node<_Cont>::__addable(const void* __i, ptrdiff_t __n) const
-{
-    typedef typename _Cont::const_iterator iterator;
-    const iterator* __j = static_cast<const iterator*>(__i);
-    _Cont* __cp = static_cast<_Cont*>(__c_);
-    return __cp->__addable(__j, __n);
-}
-
-template <class _Cont>
-inline bool
-_C_node<_Cont>::__subscriptable(const void* __i, ptrdiff_t __n) const
-{
-    typedef typename _Cont::const_iterator iterator;
-    const iterator* __j = static_cast<const iterator*>(__i);
-    _Cont* __cp = static_cast<_Cont*>(__c_);
-    return __cp->__subscriptable(__j, __n);
-}
-
-class _LIBCPP_TYPE_VIS __libcpp_db
-{
-    __c_node** __cbeg_;
-    __c_node** __cend_;
-    size_t   __csz_;
-    __i_node** __ibeg_;
-    __i_node** __iend_;
-    size_t   __isz_;
-
-    explicit __libcpp_db();
-public:
-    __libcpp_db(const __libcpp_db&) = delete;
-    __libcpp_db& operator=(const __libcpp_db&) = delete;
-
-    ~__libcpp_db();
-
-    class __db_c_iterator;
-    class __db_c_const_iterator;
-    class __db_i_iterator;
-    class __db_i_const_iterator;
-
-    __db_c_const_iterator __c_end() const;
-    __db_i_const_iterator __i_end() const;
-
-    typedef __c_node*(_InsertConstruct)(void*, void*, __c_node*);
-
-    template <class _Cont>
-    _LIBCPP_INLINE_VISIBILITY static __c_node* __create_C_node(void *__mem, void *__c, __c_node *__next) {
-        return ::new (__mem) _C_node<_Cont>(__c, __next);
-    }
-
-    template <class _Cont>
-    _LIBCPP_INLINE_VISIBILITY
-    void __insert_c(_Cont* __c)
-    {
-        __insert_c(static_cast<void*>(__c), &__create_C_node<_Cont>);
-    }
-
-    void __insert_i(void* __i);
-    void __insert_c(void* __c, _InsertConstruct* __fn);
-    void __erase_c(void* __c);
-
-    void __insert_ic(void* __i, const void* __c);
-    void __iterator_copy(void* __i, const void* __i0);
-    void __erase_i(void* __i);
-
-    void* __find_c_from_i(void* __i) const;
-    void __invalidate_all(void* __c);
-    __c_node* __find_c_and_lock(void* __c) const;
-    __c_node* __find_c(void* __c) const;
-    void unlock() const;
-
-    void swap(void* __c1, void* __c2);
-
-
-    bool __dereferenceable(const void* __i) const;
-    bool __decrementable(const void* __i) const;
-    bool __addable(const void* __i, ptrdiff_t __n) const;
-    bool __subscriptable(const void* __i, ptrdiff_t __n) const;
-    bool __less_than_comparable(const void* __i, const void* __j) const;
-private:
-    _LIBCPP_HIDDEN
-    __i_node* __insert_iterator(void* __i);
-    _LIBCPP_HIDDEN
-    __i_node* __find_iterator(const void* __i) const;
-
-    friend _LIBCPP_FUNC_VIS __libcpp_db* __get_db();
-};
-
-_LIBCPP_FUNC_VIS __libcpp_db* __get_db();
-_LIBCPP_FUNC_VIS const __libcpp_db* __get_const_db();
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // defined(_LIBCPP_ENABLE_DEBUG_MODE) || defined(_LIBCPP_BUILDING_LIBRARY)
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 inline void __debug_db_insert_c(_Tp* __c) {
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    if (!__libcpp_is_constant_evaluated())
-        __get_db()->__insert_c(__c);
-#else
-    (void)(__c);
-#endif
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 inline void __debug_db_insert_i(_Tp* __i) {
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    if (!__libcpp_is_constant_evaluated())
-        __get_db()->__insert_i(__i);
-#else
-    (void)(__i);
-#endif
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 inline void __debug_db_erase_c(_Tp* __c) {
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    if (!__libcpp_is_constant_evaluated())
-        __get_db()->__erase_c(__c);
-#else
-    (void)(__c);
-#endif
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 inline void __debug_db_swap(_Tp* __lhs, _Tp* __rhs) {
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    if (!__libcpp_is_constant_evaluated())
-        __get_db()->swap(__lhs, __rhs);
-#else
-    (void)(__lhs);
-    (void)(__rhs);
-#endif
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 inline void __debug_db_invalidate_all(_Tp* __c) {
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    if (!__libcpp_is_constant_evaluated())
-        __get_db()->__invalidate_all(__c);
-#else
-    (void)(__c);
-#endif
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___DEBUG
diff --git a/third_party/libcxx/__debug_utils/randomize_range.h b/third_party/libcxx/__debug_utils/randomize_range.h
index dce61923b..7eb77d81a 100644
--- a/third_party/libcxx/__debug_utils/randomize_range.h
+++ b/third_party/libcxx/__debug_utils/randomize_range.h
@@ -23,8 +23,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _AlgPolicy, class _Iterator, class _Sentinel>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-void __debug_randomize_range(_Iterator __first, _Sentinel __last) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __debug_randomize_range(_Iterator __first, _Sentinel __last) {
 #ifdef _LIBCPP_DEBUG_RANDOMIZE_UNSPECIFIED_STABILITY
 #  ifdef _LIBCPP_CXX03_LANG
 #    error Support for unspecified stability is only for C++11 and higher
diff --git a/third_party/libcxx/__debug_utils/sanitizers.h b/third_party/libcxx/__debug_utils/sanitizers.h
new file mode 100644
index 000000000..d8547e324
--- /dev/null
+++ b/third_party/libcxx/__debug_utils/sanitizers.h
@@ -0,0 +1,104 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___LIBCXX_DEBUG_UTILS_SANITIZERS_H
+#define _LIBCPP___LIBCXX_DEBUG_UTILS_SANITIZERS_H
+
+#include <__config>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_constant_evaluated.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_HAS_NO_ASAN
+
+extern "C" {
+_LIBCPP_EXPORTED_FROM_ABI void
+__sanitizer_annotate_contiguous_container(const void*, const void*, const void*, const void*);
+_LIBCPP_EXPORTED_FROM_ABI void __sanitizer_annotate_double_ended_contiguous_container(
+    const void*, const void*, const void*, const void*, const void*, const void*);
+_LIBCPP_EXPORTED_FROM_ABI int
+__sanitizer_verify_double_ended_contiguous_container(const void*, const void*, const void*, const void*);
+}
+
+#endif // _LIBCPP_HAS_NO_ASAN
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// ASan choices
+#ifndef _LIBCPP_HAS_NO_ASAN
+#  define _LIBCPP_HAS_ASAN_CONTAINER_ANNOTATIONS_FOR_ALL_ALLOCATORS 1
+#endif
+
+#ifdef _LIBCPP_HAS_ASAN_CONTAINER_ANNOTATIONS_FOR_ALL_ALLOCATORS
+// __asan_annotate_container_with_allocator determines whether containers with custom allocators are annotated. This is
+// a public customization point to disable annotations if the custom allocator assumes that the memory isn't poisoned.
+// See the https://libcxx.llvm.org/UsingLibcxx.html#turning-off-asan-annotation-in-containers for more information.
+template <class _Alloc>
+struct __asan_annotate_container_with_allocator : true_type {};
+#endif
+
+// Annotate a double-ended contiguous range.
+// - [__first_storage, __last_storage) is the allocated memory region,
+// - [__first_old_contained, __last_old_contained) is the previously allowed (unpoisoned) range, and
+// - [__first_new_contained, __last_new_contained) is the new allowed (unpoisoned) range.
+template <class _Allocator>
+_LIBCPP_HIDE_FROM_ABI void __annotate_double_ended_contiguous_container(
+    const void* __first_storage,
+    const void* __last_storage,
+    const void* __first_old_contained,
+    const void* __last_old_contained,
+    const void* __first_new_contained,
+    const void* __last_new_contained) {
+#ifdef _LIBCPP_HAS_NO_ASAN
+  (void)__first_storage;
+  (void)__last_storage;
+  (void)__first_old_contained;
+  (void)__last_old_contained;
+  (void)__first_new_contained;
+  (void)__last_new_contained;
+#else
+  if (__asan_annotate_container_with_allocator<_Allocator>::value && __first_storage != nullptr)
+    __sanitizer_annotate_double_ended_contiguous_container(
+        __first_storage,
+        __last_storage,
+        __first_old_contained,
+        __last_old_contained,
+        __first_new_contained,
+        __last_new_contained);
+#endif
+}
+
+// Annotate a contiguous range.
+// [__first_storage, __last_storage) is the allocated memory region,
+// __old_last_contained is the previously last allowed (unpoisoned) element, and
+// __new_last_contained is the new last allowed (unpoisoned) element.
+template <class _Allocator>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __annotate_contiguous_container(
+    const void* __first_storage,
+    const void* __last_storage,
+    const void* __old_last_contained,
+    const void* __new_last_contained) {
+#ifdef _LIBCPP_HAS_NO_ASAN
+  (void)__first_storage;
+  (void)__last_storage;
+  (void)__old_last_contained;
+  (void)__new_last_contained;
+#else
+  if (!__libcpp_is_constant_evaluated() && __asan_annotate_container_with_allocator<_Allocator>::value &&
+      __first_storage != nullptr)
+    __sanitizer_annotate_contiguous_container(
+        __first_storage, __last_storage, __old_last_contained, __new_last_contained);
+#endif
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___LIBCXX_DEBUG_UTILS_SANITIZERS_H
diff --git a/third_party/libcxx/__debug_utils/strict_weak_ordering_check.h b/third_party/libcxx/__debug_utils/strict_weak_ordering_check.h
new file mode 100644
index 000000000..3a9d88728
--- /dev/null
+++ b/third_party/libcxx/__debug_utils/strict_weak_ordering_check.h
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___LIBCXX_DEBUG_STRICT_WEAK_ORDERING_CHECK
+#define _LIBCPP___LIBCXX_DEBUG_STRICT_WEAK_ORDERING_CHECK
+
+#include <__config>
+
+#include <__algorithm/comp_ref_type.h>
+#include <__algorithm/is_sorted.h>
+#include <__assert>
+#include <__iterator/iterator_traits.h>
+#include <__type_traits/is_constant_evaluated.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _RandomAccessIterator, class _Comp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+__check_strict_weak_ordering_sorted(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp& __comp) {
+#if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
+  using __diff_t  = __iter_diff_t<_RandomAccessIterator>;
+  using _Comp_ref = __comp_ref_type<_Comp>;
+  if (!__libcpp_is_constant_evaluated()) {
+    // Check if the range is actually sorted.
+    _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+        (std::is_sorted<_RandomAccessIterator, _Comp_ref>(__first, __last, _Comp_ref(__comp))),
+        "The range is not sorted after the sort, your comparator is not a valid strict-weak ordering");
+    // Limit the number of elements we need to check.
+    __diff_t __size = __last - __first > __diff_t(100) ? __diff_t(100) : __last - __first;
+    __diff_t __p    = 0;
+    while (__p < __size) {
+      __diff_t __q = __p + __diff_t(1);
+      // Find first element that is greater than *(__first+__p).
+      while (__q < __size && !__comp(*(__first + __p), *(__first + __q))) {
+        ++__q;
+      }
+      // Check that the elements from __p to __q are equal between each other.
+      for (__diff_t __b = __p; __b < __q; ++__b) {
+        for (__diff_t __a = __p; __a <= __b; ++__a) {
+          _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+              !__comp(*(__first + __a), *(__first + __b)), "Your comparator is not a valid strict-weak ordering");
+          _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+              !__comp(*(__first + __b), *(__first + __a)), "Your comparator is not a valid strict-weak ordering");
+        }
+      }
+      // Check that elements between __p and __q are less than between __q and __size.
+      for (__diff_t __a = __p; __a < __q; ++__a) {
+        for (__diff_t __b = __q; __b < __size; ++__b) {
+          _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+              __comp(*(__first + __a), *(__first + __b)), "Your comparator is not a valid strict-weak ordering");
+          _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
+              !__comp(*(__first + __b), *(__first + __a)), "Your comparator is not a valid strict-weak ordering");
+        }
+      }
+      // Skip these equal elements.
+      __p = __q;
+    }
+  }
+#else
+  (void)__first;
+  (void)__last;
+  (void)__comp;
+#endif // _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___LIBCXX_DEBUG_STRICT_WEAK_ORDERING_CHECK
diff --git a/third_party/libcxx/__exception/exception.h b/third_party/libcxx/__exception/exception.h
index 49a58dd16..e724e1b99 100644
--- a/third_party/libcxx/__exception/exception.h
+++ b/third_party/libcxx/__exception/exception.h
@@ -69,18 +69,21 @@ public:
 // On all other platforms, we define our own std::exception and std::bad_exception types
 // regardless of whether exceptions are turned on as a language feature.
 
-class _LIBCPP_EXCEPTION_ABI exception {
+class _LIBCPP_EXPORTED_FROM_ABI exception {
 public:
   _LIBCPP_HIDE_FROM_ABI exception() _NOEXCEPT {}
-  _LIBCPP_HIDE_FROM_ABI exception(const exception&) _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI exception(const exception&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI exception& operator=(const exception&) _NOEXCEPT = default;
 
   virtual ~exception() _NOEXCEPT;
   virtual const char* what() const _NOEXCEPT;
 };
 
-class _LIBCPP_EXCEPTION_ABI bad_exception : public exception {
+class _LIBCPP_EXPORTED_FROM_ABI bad_exception : public exception {
 public:
   _LIBCPP_HIDE_FROM_ABI bad_exception() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI bad_exception(const bad_exception&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_exception& operator=(const bad_exception&) _NOEXCEPT = default;
   ~bad_exception() _NOEXCEPT override;
   const char* what() const _NOEXCEPT override;
 };
diff --git a/third_party/libcxx/__exception/exception_ptr.h b/third_party/libcxx/__exception/exception_ptr.h
index 1307481f0..beadd9212 100644
--- a/third_party/libcxx/__exception/exception_ptr.h
+++ b/third_party/libcxx/__exception/exception_ptr.h
@@ -12,21 +12,63 @@
 #include <__config>
 #include <__exception/operations.h>
 #include <__memory/addressof.h>
+#include <__memory/construct_at.h>
+#include <__type_traits/decay.h>
 #include <cstddef>
 #include <cstdlib>
+#include <new>
+#include <typeinfo>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#ifndef _LIBCPP_ABI_MICROSOFT
+
+#  if _LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION
+
+namespace __cxxabiv1 {
+
+extern "C" {
+_LIBCPP_OVERRIDABLE_FUNC_VIS void* __cxa_allocate_exception(size_t) throw();
+_LIBCPP_OVERRIDABLE_FUNC_VIS void __cxa_free_exception(void*) throw();
+
+struct __cxa_exception;
+_LIBCPP_OVERRIDABLE_FUNC_VIS __cxa_exception* __cxa_init_primary_exception(
+    void*,
+    std::type_info*,
+#    if defined(_WIN32)
+    void(__thiscall*)(void*)) throw();
+#    elif defined(__wasm__)
+    // In Wasm, a destructor returns its argument
+    void* (*)(void*)) throw();
+#    else
+    void (*)(void*)) throw();
+#    endif
+}
+
+} // namespace __cxxabiv1
+
+#  endif
+
+#endif
+
 namespace std { // purposefully not using versioning namespace
 
 #ifndef _LIBCPP_ABI_MICROSOFT
 
-class _LIBCPP_TYPE_VIS exception_ptr {
+class _LIBCPP_EXPORTED_FROM_ABI exception_ptr {
   void* __ptr_;
 
+  static exception_ptr __from_native_exception_pointer(void*) _NOEXCEPT;
+
+  template <class _Ep>
+  friend _LIBCPP_HIDE_FROM_ABI exception_ptr make_exception_ptr(_Ep) _NOEXCEPT;
+
 public:
+  // exception_ptr is basically a COW string.
+  using __trivially_relocatable = exception_ptr;
+
   _LIBCPP_HIDE_FROM_ABI exception_ptr() _NOEXCEPT : __ptr_() {}
   _LIBCPP_HIDE_FROM_ABI exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
 
@@ -44,18 +86,44 @@ public:
     return !(__x == __y);
   }
 
-  friend _LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
-  friend _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
+  friend _LIBCPP_EXPORTED_FROM_ABI exception_ptr current_exception() _NOEXCEPT;
+  friend _LIBCPP_EXPORTED_FROM_ABI void rethrow_exception(exception_ptr);
 };
 
 template <class _Ep>
 _LIBCPP_HIDE_FROM_ABI exception_ptr make_exception_ptr(_Ep __e) _NOEXCEPT {
 #  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+#    if _LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION && __cplusplus >= 201103L
+  using _Ep2 = __decay_t<_Ep>;
+
+  void* __ex = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ep));
+#      ifdef __wasm__
+  // In Wasm, a destructor returns its argument
+  (void)__cxxabiv1::__cxa_init_primary_exception(
+      __ex, const_cast<std::type_info*>(&typeid(_Ep)), [](void* __p) -> void* {
+#      else
+  (void)__cxxabiv1::__cxa_init_primary_exception(__ex, const_cast<std::type_info*>(&typeid(_Ep)), [](void* __p) {
+#      endif
+        std::__destroy_at(static_cast<_Ep2*>(__p));
+#      ifdef __wasm__
+        return __p;
+#      endif
+      });
+
+  try {
+    ::new (__ex) _Ep2(__e);
+    return exception_ptr::__from_native_exception_pointer(__ex);
+  } catch (...) {
+    __cxxabiv1::__cxa_free_exception(__ex);
+    return current_exception();
+  }
+#    else
   try {
     throw __e;
   } catch (...) {
     return current_exception();
   }
+#    endif
 #  else
   ((void)__e);
   std::abort();
@@ -64,7 +132,7 @@ _LIBCPP_HIDE_FROM_ABI exception_ptr make_exception_ptr(_Ep __e) _NOEXCEPT {
 
 #else // _LIBCPP_ABI_MICROSOFT
 
-class _LIBCPP_TYPE_VIS exception_ptr {
+class _LIBCPP_EXPORTED_FROM_ABI exception_ptr {
   _LIBCPP_DIAGNOSTIC_PUSH
   _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wunused-private-field")
   void* __ptr1_;
@@ -81,17 +149,17 @@ public:
   explicit operator bool() const _NOEXCEPT;
 };
 
-_LIBCPP_FUNC_VIS bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT;
 
 inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT {
   return !(__x == __y);
 }
 
-_LIBCPP_FUNC_VIS void swap(exception_ptr&, exception_ptr&) _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI void swap(exception_ptr&, exception_ptr&) _NOEXCEPT;
 
-_LIBCPP_FUNC_VIS exception_ptr __copy_exception_ptr(void* __except, const void* __ptr);
-_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
+_LIBCPP_EXPORTED_FROM_ABI exception_ptr __copy_exception_ptr(void* __except, const void* __ptr);
+_LIBCPP_EXPORTED_FROM_ABI exception_ptr current_exception() _NOEXCEPT;
+_LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void rethrow_exception(exception_ptr);
 
 // This is a built-in template function which automagically extracts the required
 // information.
diff --git a/third_party/libcxx/__exception/nested_exception.h b/third_party/libcxx/__exception/nested_exception.h
index 182c7ddda..feb489f87 100644
--- a/third_party/libcxx/__exception/nested_exception.h
+++ b/third_party/libcxx/__exception/nested_exception.h
@@ -15,8 +15,8 @@
 #include <__type_traits/decay.h>
 #include <__type_traits/is_base_of.h>
 #include <__type_traits/is_class.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
-#include <__type_traits/is_copy_constructible.h>
 #include <__type_traits/is_final.h>
 #include <__type_traits/is_polymorphic.h>
 #include <__utility/forward.h>
@@ -28,13 +28,13 @@
 
 namespace std { // purposefully not using versioning namespace
 
-class _LIBCPP_EXCEPTION_ABI nested_exception {
+class _LIBCPP_EXPORTED_FROM_ABI nested_exception {
   exception_ptr __ptr_;
 
 public:
   nested_exception() _NOEXCEPT;
-  //     nested_exception(const nested_exception&) noexcept = default;
-  //     nested_exception& operator=(const nested_exception&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI nested_exception(const nested_exception&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI nested_exception& operator=(const nested_exception&) _NOEXCEPT = default;
   virtual ~nested_exception() _NOEXCEPT;
 
   // access functions
@@ -53,14 +53,14 @@ struct __throw_with_nested;
 
 template <class _Tp, class _Up>
 struct __throw_with_nested<_Tp, _Up, true> {
-  _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void __do_throw(_Tp&& __t) {
+  _LIBCPP_NORETURN static inline _LIBCPP_HIDE_FROM_ABI void __do_throw(_Tp&& __t) {
     throw __nested<_Up>(std::forward<_Tp>(__t));
   }
 };
 
 template <class _Tp, class _Up>
 struct __throw_with_nested<_Tp, _Up, false> {
-  _LIBCPP_NORETURN static inline _LIBCPP_INLINE_VISIBILITY void __do_throw(_Tp&& __t) { throw std::forward<_Tp>(__t); }
+  _LIBCPP_NORETURN static inline _LIBCPP_HIDE_FROM_ABI void __do_throw(_Tp&& __t) { throw std::forward<_Tp>(__t); }
 };
 #endif
 
@@ -84,17 +84,15 @@ struct __can_dynamic_cast
     : _BoolConstant< is_polymorphic<_From>::value &&
                      (!is_base_of<_To, _From>::value || is_convertible<const _From*, const _To*>::value)> {};
 
-template <class _Ep>
-inline _LIBCPP_HIDE_FROM_ABI void
-rethrow_if_nested(const _Ep& __e, __enable_if_t< __can_dynamic_cast<_Ep, nested_exception>::value>* = 0) {
+template <class _Ep, __enable_if_t< __can_dynamic_cast<_Ep, nested_exception>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void rethrow_if_nested(const _Ep& __e) {
   const nested_exception* __nep = dynamic_cast<const nested_exception*>(std::addressof(__e));
   if (__nep)
     __nep->rethrow_nested();
 }
 
-template <class _Ep>
-inline _LIBCPP_HIDE_FROM_ABI void
-rethrow_if_nested(const _Ep&, __enable_if_t<!__can_dynamic_cast<_Ep, nested_exception>::value>* = 0) {}
+template <class _Ep, __enable_if_t<!__can_dynamic_cast<_Ep, nested_exception>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void rethrow_if_nested(const _Ep&) {}
 
 } // namespace std
 
diff --git a/third_party/libcxx/__exception/operations.h b/third_party/libcxx/__exception/operations.h
index e8c5ba61e..0a9c7a7c7 100644
--- a/third_party/libcxx/__exception/operations.h
+++ b/third_party/libcxx/__exception/operations.h
@@ -9,7 +9,6 @@
 #ifndef _LIBCPP___EXCEPTION_OPERATIONS_H
 #define _LIBCPP___EXCEPTION_OPERATIONS_H
 
-#include <__availability>
 #include <__config>
 #include <cstddef>
 
@@ -21,22 +20,22 @@ namespace std { // purposefully not using versioning namespace
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS) ||                             \
     defined(_LIBCPP_BUILDING_LIBRARY)
 using unexpected_handler = void (*)();
-_LIBCPP_FUNC_VIS unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
-_LIBCPP_FUNC_VIS unexpected_handler get_unexpected() _NOEXCEPT;
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void unexpected();
+_LIBCPP_EXPORTED_FROM_ABI unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI unexpected_handler get_unexpected() _NOEXCEPT;
+_LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void unexpected();
 #endif
 
 using terminate_handler = void (*)();
-_LIBCPP_FUNC_VIS terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
-_LIBCPP_FUNC_VIS terminate_handler get_terminate() _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI terminate_handler get_terminate() _NOEXCEPT;
 
-_LIBCPP_FUNC_VIS bool uncaught_exception() _NOEXCEPT;
-_LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_UNCAUGHT_EXCEPTIONS int uncaught_exceptions() _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI bool uncaught_exception() _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI int uncaught_exceptions() _NOEXCEPT;
 
-class _LIBCPP_TYPE_VIS exception_ptr;
+class _LIBCPP_EXPORTED_FROM_ABI exception_ptr;
 
-_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
+_LIBCPP_EXPORTED_FROM_ABI exception_ptr current_exception() _NOEXCEPT;
+_LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void rethrow_exception(exception_ptr);
 } // namespace std
 
 #endif // _LIBCPP___EXCEPTION_OPERATIONS_H
diff --git a/third_party/libcxx/__exception/terminate.h b/third_party/libcxx/__exception/terminate.h
index d8dd9642b..e672471dc 100644
--- a/third_party/libcxx/__exception/terminate.h
+++ b/third_party/libcxx/__exception/terminate.h
@@ -16,7 +16,7 @@
 #endif
 
 namespace std { // purposefully not using versioning namespace
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void terminate() _NOEXCEPT;
+_LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void terminate() _NOEXCEPT;
 } // namespace std
 
 #endif // _LIBCPP___EXCEPTION_TERMINATE_H
diff --git a/third_party/libcxx/__expected/bad_expected_access.h b/third_party/libcxx/__expected/bad_expected_access.h
index 1b88ab2be..1b734389e 100644
--- a/third_party/libcxx/__expected/bad_expected_access.h
+++ b/third_party/libcxx/__expected/bad_expected_access.h
@@ -17,6 +17,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 23
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -24,23 +27,28 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _Err>
 class bad_expected_access;
 
+_LIBCPP_DIAGNOSTIC_PUSH
+#  if !_LIBCPP_AVAILABILITY_HAS_BAD_EXPECTED_ACCESS_KEY_FUNCTION
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wweak-vtables")
+#  endif
 template <>
-class bad_expected_access<void> : public exception {
+class _LIBCPP_EXPORTED_FROM_ABI bad_expected_access<void> : public exception {
 protected:
-  _LIBCPP_HIDE_FROM_ABI bad_expected_access() noexcept                             = default;
-  _LIBCPP_HIDE_FROM_ABI bad_expected_access(const bad_expected_access&)            = default;
-  _LIBCPP_HIDE_FROM_ABI bad_expected_access(bad_expected_access&&)                 = default;
-  _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(const bad_expected_access&) = default;
-  _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(bad_expected_access&&)      = default;
-  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~bad_expected_access() override                    = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access() noexcept                                      = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access(const bad_expected_access&) noexcept            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access(bad_expected_access&&) noexcept                 = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(const bad_expected_access&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI bad_expected_access& operator=(bad_expected_access&&) noexcept      = default;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~bad_expected_access() override                             = default;
 
 public:
-  // The way this has been designed (by using a class template below) means that we'll already
-  // have a profusion of these vtables in TUs, and the dynamic linker will already have a bunch
-  // of work to do. So it is not worth hiding the <void> specialization in the dylib, given that
-  // it adds deployment target restrictions.
+#  if _LIBCPP_AVAILABILITY_HAS_BAD_EXPECTED_ACCESS_KEY_FUNCTION
+  const char* what() const noexcept override;
+#  else
   _LIBCPP_HIDE_FROM_ABI_VIRTUAL const char* what() const noexcept override { return "bad access to std::expected"; }
+#  endif
 };
+_LIBCPP_DIAGNOSTIC_POP
 
 template <class _Err>
 class bad_expected_access : public bad_expected_access<void> {
@@ -60,4 +68,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 23
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___EXPECTED_BAD_EXPECTED_ACCESS_H
diff --git a/third_party/libcxx/__expected/expected.h b/third_party/libcxx/__expected/expected.h
index 668e23f21..f618b2060 100644
--- a/third_party/libcxx/__expected/expected.h
+++ b/third_party/libcxx/__expected/expected.h
@@ -23,29 +23,21 @@
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
-#include <__type_traits/is_copy_assignable.h>
-#include <__type_traits/is_copy_constructible.h>
-#include <__type_traits/is_default_constructible.h>
 #include <__type_traits/is_function.h>
-#include <__type_traits/is_move_assignable.h>
-#include <__type_traits/is_move_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
 #include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_nothrow_copy_assignable.h>
-#include <__type_traits/is_nothrow_copy_constructible.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
-#include <__type_traits/is_trivially_copy_constructible.h>
+#include <__type_traits/is_trivially_constructible.h>
 #include <__type_traits/is_trivially_destructible.h>
-#include <__type_traits/is_trivially_move_constructible.h>
+#include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/lazy.h>
 #include <__type_traits/negation.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_cvref.h>
+#include <__utility/as_const.h>
 #include <__utility/exception_guard.h>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
@@ -58,6 +50,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 23
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -84,93 +79,445 @@ _LIBCPP_HIDE_FROM_ABI void __throw_bad_expected_access(_Arg&& __arg) {
 #  endif
 }
 
+// If parameter type `_Tp` of `__conditional_no_unique_address` is neither
+// copyable nor movable, a constructor with this tag is provided. For that
+// constructor, the user has to provide a function and arguments. The function
+// must return an object of type `_Tp`. When the function is invoked by the
+// constructor, guaranteed copy elision kicks in and the `_Tp` is constructed
+// in place.
+struct __conditional_no_unique_address_invoke_tag {};
+
+// This class implements an object with `[[no_unique_address]]` conditionally applied to it,
+// based on the value of `_NoUnique`.
+//
+// A member of this class must always have `[[no_unique_address]]` applied to
+// it. Otherwise, the `[[no_unique_address]]` in the "`_NoUnique == true`" case
+// would not have any effect. In the `false` case, the `__v` is not
+// `[[no_unique_address]]`, so nullifies the effects of the "outer"
+// `[[no_unique_address]]` regarding data layout.
+//
+// If we had a language feature, this class would basically be replaced by `[[no_unique_address(condition)]]`.
+template <bool _NoUnique, class _Tp>
+struct __conditional_no_unique_address;
+
+template <class _Tp>
+struct __conditional_no_unique_address<true, _Tp> {
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __conditional_no_unique_address(in_place_t, _Args&&... __args)
+      : __v(std::forward<_Args>(__args)...) {}
+
+  template <class _Func, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __conditional_no_unique_address(
+      __conditional_no_unique_address_invoke_tag, _Func&& __f, _Args&&... __args)
+      : __v(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
+
+  _LIBCPP_NO_UNIQUE_ADDRESS _Tp __v;
+};
+
+template <class _Tp>
+struct __conditional_no_unique_address<false, _Tp> {
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __conditional_no_unique_address(in_place_t, _Args&&... __args)
+      : __v(std::forward<_Args>(__args)...) {}
+
+  template <class _Func, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __conditional_no_unique_address(
+      __conditional_no_unique_address_invoke_tag, _Func&& __f, _Args&&... __args)
+      : __v(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
+
+  _Tp __v;
+};
+
+// This function returns whether the type `_Second` can be stuffed into the tail padding
+// of the `_First` type if both of them are given `[[no_unique_address]]`.
+template <class _First, class _Second>
+inline constexpr bool __fits_in_tail_padding = []() {
+  struct __x {
+    _LIBCPP_NO_UNIQUE_ADDRESS _First __first;
+    _LIBCPP_NO_UNIQUE_ADDRESS _Second __second;
+  };
+  return sizeof(__x) == sizeof(_First);
+}();
+
+// This class implements the storage used by `std::expected`. We have a few
+// goals for this storage:
+// 1. Whenever the underlying {_Tp | _Unex} combination has free bytes in its
+//    tail padding, we should reuse it to store the bool discriminator of the
+//    expected, so as to save space.
+// 2. Whenever the `expected<_Tp, _Unex>` as a whole has free bytes in its tail
+//    padding, we should allow an object following the expected to be stored in
+//    its tail padding.
+// 3. However, we never want a user object (say `X`) that would follow an
+//    `expected<_Tp, _Unex>` to be stored in the padding bytes of the
+//    underlying {_Tp | _Unex} union, if any. That is because we use
+//    `construct_at` on that union, which would end up overwriting the `X`
+//    member if it is stored in the tail padding of the union.
+//
+// To achieve this, `__expected_base`'s logic is implemented in an inner
+// `__repr` class. `__expected_base` holds one `__repr` member which is
+// conditionally `[[no_unique_address]]`. The `__repr` class holds the
+// underlying {_Tp | _Unex} union and a boolean "has value" flag.
+//
+// Which one of the `__repr_`/`__union_` members is `[[no_unique_address]]`
+// depends on whether the "has value" boolean fits into the tail padding of
+// the underlying {_Tp | _Unex} union:
+//
+// - In case the "has value" bool fits into the tail padding of the union, the
+//   whole `__repr_` member is _not_ `[[no_unique_address]]` as it needs to be
+//   transparently replaced on `emplace()`/`swap()` etc.
+// - In case the "has value" bool does not fit into the tail padding of the
+//   union, only the union member must be transparently replaced (therefore is
+//   _not_ `[[no_unique_address]]`) and the "has value" flag must be adjusted
+//   manually.
+//
+// This way, the member that is transparently replaced on mutating operations
+// is never `[[no_unique_address]]`, satisfying the requirements from
+// "[basic.life]" in the standard.
+//
+// Stripped away of all superfluous elements, the layout of `__expected_base`
+// then looks like this:
+//
+//     template <class Tp, class Err>
+//     class expected_base {
+//       union union_t {
+//         [[no_unique_address]] Tp val;
+//         [[no_unique_address]] Err unex;
+//       };
+//
+//       static constexpr bool put_flag_in_tail                    = fits_in_tail_padding<union_t, bool>;
+//       static constexpr bool allow_reusing_expected_tail_padding = !put_flag_in_tail;
+//
+//       struct repr {
+//       private:
+//         // If "has value" fits into the tail, this should be
+//         // `[[no_unique_address]]`, otherwise not.
+//         [[no_unique_address]] conditional_no_unique_address<
+//             put_flag_in_tail,
+//             union_t>::type union_;
+//         [[no_unique_address]] bool has_val_;
+//       };
+//
+//     protected:
+//       // If "has value" fits into the tail, this must _not_ be
+//       // `[[no_unique_address]]` so that we fill out the
+//       // complete `expected` object.
+//       [[no_unique_address]] conditional_no_unique_address<
+//           allow_reusing_expected_tail_padding,
+//           repr>::type repr_;
+//     };
+//
 template <class _Tp, class _Err>
-class expected {
-  static_assert(
-      !is_reference_v<_Tp> &&
-          !is_function_v<_Tp> &&
-          !is_same_v<remove_cv_t<_Tp>, in_place_t> &&
-          !is_same_v<remove_cv_t<_Tp>, unexpect_t> &&
-          !__is_std_unexpected<remove_cv_t<_Tp>>::value &&
-          __valid_std_unexpected<_Err>::value
-      ,
-      "[expected.object.general] A program that instantiates the definition of template expected<T, E> for a "
-      "reference type, a function type, or for possibly cv-qualified types in_place_t, unexpect_t, or a "
-      "specialization of unexpected for the T parameter is ill-formed. A program that instantiates the "
-      "definition of the template expected<T, E> with a type for the E parameter that is not a valid "
-      "template argument for unexpected is ill-formed.");
+class __expected_base {
+  // use named union because [[no_unique_address]] cannot be applied to an unnamed union,
+  // also guaranteed elision into a potentially-overlapping subobject is unsettled (and
+  // it's not clear that it's implementable, given that the function is allowed to clobber
+  // the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107.
+  union __union_t {
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&)
+      requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> &&
+               is_trivially_copy_constructible_v<_Tp> && is_trivially_copy_constructible_v<_Err>)
+    = default;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t(__union_t&&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t(__union_t&&)
+      requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> &&
+               is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>)
+    = default;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(const __union_t&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(__union_t&&)      = delete;
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(in_place_t, _Args&&... __args)
+        : __val_(std::forward<_Args>(__args)...) {}
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(unexpect_t, _Args&&... __args)
+        : __unex_(std::forward<_Args>(__args)...) {}
+
+    template <class _Func, class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
+        std::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args)
+        : __val_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
+
+    template <class _Func, class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
+        std::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
+        : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
+
+    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
+      requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>)
+    = default;
+
+    // __repr's destructor handles this
+    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() {}
+
+    _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_;
+    _LIBCPP_NO_UNIQUE_ADDRESS _Err __unex_;
+  };
+
+  static constexpr bool __put_flag_in_tail                    = __fits_in_tail_padding<__union_t, bool>;
+  static constexpr bool __allow_reusing_expected_tail_padding = !__put_flag_in_tail;
+
+  struct __repr {
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr() = delete;
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(in_place_t __tag, _Args&&... __args)
+        : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(true) {}
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(unexpect_t __tag, _Args&&... __args)
+        : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(false) {}
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(std::__expected_construct_in_place_from_invoke_tag __tag,
+                                                    _Args&&... __args)
+        : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(true) {}
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(std::__expected_construct_unexpected_from_invoke_tag __tag,
+                                                    _Args&&... __args)
+        : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(false) {}
+
+    // The return value of `__make_union` must be constructed in place in the
+    // `__v` member of `__union_`, relying on guaranteed copy elision. To do
+    // this, the `__conditional_no_unique_address_invoke_tag` constructor is
+    // called with a lambda that is immediately called inside
+    // `__conditional_no_unique_address`'s constructor.
+    template <class _OtherUnion>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(bool __has_val, _OtherUnion&& __other)
+      requires(__allow_reusing_expected_tail_padding)
+        : __union_(__conditional_no_unique_address_invoke_tag{},
+                   [&] { return __make_union(__has_val, std::forward<_OtherUnion>(__other)); }),
+          __has_val_(__has_val) {}
+
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr(const __repr&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr(const __repr&)
+      requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> &&
+               is_trivially_copy_constructible_v<_Tp> && is_trivially_copy_constructible_v<_Err>)
+    = default;
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr(__repr&&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr(__repr&&)
+      requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> &&
+               is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>)
+    = default;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr& operator=(const __repr&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr& operator=(__repr&&)      = delete;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr ~__repr()
+      requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>)
+    = default;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr ~__repr()
+      requires(!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>)
+    {
+      __destroy_union_member();
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union()
+      requires(__allow_reusing_expected_tail_padding &&
+               (is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>))
+    {
+      // Note: Since the destructor of the union is trivial, this does nothing
+      // except to end the lifetime of the union.
+      std::destroy_at(&__union_.__v);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union()
+      requires(__allow_reusing_expected_tail_padding &&
+               (!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>))
+    {
+      __destroy_union_member();
+      std::destroy_at(&__union_.__v);
+    }
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr void __construct_union(in_place_t, _Args&&... __args)
+      requires(__allow_reusing_expected_tail_padding)
+    {
+      std::construct_at(&__union_.__v, in_place, std::forward<_Args>(__args)...);
+      __has_val_ = true;
+    }
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr void __construct_union(unexpect_t, _Args&&... __args)
+      requires(__allow_reusing_expected_tail_padding)
+    {
+      std::construct_at(&__union_.__v, unexpect, std::forward<_Args>(__args)...);
+      __has_val_ = false;
+    }
+
+  private:
+    template <class, class>
+    friend class __expected_base;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union_member()
+      requires(!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>)
+    {
+      if (__has_val_) {
+        std::destroy_at(std::addressof(__union_.__v.__val_));
+      } else {
+        std::destroy_at(std::addressof(__union_.__v.__unex_));
+      }
+    }
+
+    template <class _OtherUnion>
+    _LIBCPP_HIDE_FROM_ABI static constexpr __union_t __make_union(bool __has_val, _OtherUnion&& __other)
+      requires(__allow_reusing_expected_tail_padding)
+    {
+      if (__has_val)
+        return __union_t(in_place, std::forward<_OtherUnion>(__other).__val_);
+      else
+        return __union_t(unexpect, std::forward<_OtherUnion>(__other).__unex_);
+    }
+
+    _LIBCPP_NO_UNIQUE_ADDRESS __conditional_no_unique_address<__put_flag_in_tail, __union_t> __union_;
+    _LIBCPP_NO_UNIQUE_ADDRESS bool __has_val_;
+  };
+
+  template <class _OtherUnion>
+  _LIBCPP_HIDE_FROM_ABI static constexpr __repr __make_repr(bool __has_val, _OtherUnion&& __other)
+    requires(__put_flag_in_tail)
+  {
+    if (__has_val)
+      return __repr(in_place, std::forward<_OtherUnion>(__other).__val_);
+    else
+      return __repr(unexpect, std::forward<_OtherUnion>(__other).__unex_);
+  }
+
+protected:
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __expected_base(_Args&&... __args)
+      : __repr_(in_place, std::forward<_Args>(__args)...) {}
+
+  // In case we copy/move construct from another `expected` we need to create
+  // our `expected` so that it either has a value or not, depending on the "has
+  // value" flag of the other `expected`. To do this without falling back on
+  // `std::construct_at` we rely on guaranteed copy elision using two helper
+  // functions `__make_repr` and `__make_union`. There have to be two since
+  // there are two data layouts with different members being
+  // `[[no_unique_address]]`. GCC (as of version 13) does not do guaranteed
+  // copy elision when initializing `[[no_unique_address]]` members. The two
+  // cases are:
+  //
+  // - `__make_repr`: This is used when the "has value" flag lives in the tail
+  //   of the union. In this case, the `__repr` member is _not_
+  //   `[[no_unique_address]]`.
+  // - `__make_union`: When the "has value" flag does _not_ fit in the tail of
+  //   the union, the `__repr` member is `[[no_unique_address]]` and the union
+  //   is not.
+  //
+  // This constructor "catches" the first case and leaves the second case to
+  // `__union_t`, its constructors and `__make_union`.
+  template <class _OtherUnion>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __expected_base(bool __has_val, _OtherUnion&& __other)
+    requires(__put_flag_in_tail)
+      : __repr_(__conditional_no_unique_address_invoke_tag{},
+                [&] { return __make_repr(__has_val, std::forward<_OtherUnion>(__other)); }) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void __destroy() {
+    if constexpr (__put_flag_in_tail)
+      std::destroy_at(&__repr_.__v);
+    else
+      __repr_.__v.__destroy_union();
+  }
+
+  template <class _Tag, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr void __construct(_Tag __tag, _Args&&... __args) {
+    if constexpr (__put_flag_in_tail)
+      std::construct_at(&__repr_.__v, __tag, std::forward<_Args>(__args)...);
+    else
+      __repr_.__v.__construct_union(__tag, std::forward<_Args>(__args)...);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_val() const { return __repr_.__v.__has_val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr __union_t& __union() { return __repr_.__v.__union_.__v; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const __union_t& __union() const { return __repr_.__v.__union_.__v; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& __val() { return __repr_.__v.__union_.__v.__val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& __val() const { return __repr_.__v.__union_.__v.__val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err& __unex() { return __repr_.__v.__union_.__v.__unex_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Err& __unex() const { return __repr_.__v.__union_.__v.__unex_; }
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS __conditional_no_unique_address<__allow_reusing_expected_tail_padding, __repr> __repr_;
+};
+
+template <class _Tp, class _Err>
+class expected : private __expected_base<_Tp, _Err> {
+  static_assert(!is_reference_v<_Tp> && !is_function_v<_Tp> && !is_same_v<remove_cv_t<_Tp>, in_place_t> &&
+                    !is_same_v<remove_cv_t<_Tp>, unexpect_t> && !__is_std_unexpected<remove_cv_t<_Tp>>::value &&
+                    __valid_std_unexpected<_Err>::value,
+                "[expected.object.general] A program that instantiates the definition of template expected<T, E> for a "
+                "reference type, a function type, or for possibly cv-qualified types in_place_t, unexpect_t, or a "
+                "specialization of unexpected for the T parameter is ill-formed. A program that instantiates the "
+                "definition of the template expected<T, E> with a type for the E parameter that is not a valid "
+                "template argument for unexpected is ill-formed.");
 
   template <class _Up, class _OtherErr>
   friend class expected;
 
+  using __base = __expected_base<_Tp, _Err>;
+
 public:
   using value_type      = _Tp;
   using error_type      = _Err;
   using unexpected_type = unexpected<_Err>;
 
+  using __trivially_relocatable =
+      __conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value && __libcpp_is_trivially_relocatable<_Err>::value,
+                      expected,
+                      void>;
+
   template <class _Up>
   using rebind = expected<_Up, error_type>;
 
   // [expected.object.ctor], constructors
-  _LIBCPP_HIDE_FROM_ABI constexpr expected()
-    noexcept(is_nothrow_default_constructible_v<_Tp>) // strengthened
+  _LIBCPP_HIDE_FROM_ABI constexpr expected() noexcept(is_nothrow_default_constructible_v<_Tp>) // strengthened
     requires is_default_constructible_v<_Tp>
-      : __has_val_(true) {
-    std::construct_at(std::addressof(__union_.__val_));
-  }
+      : __base(in_place) {}
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) = delete;
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&)
-    requires(is_copy_constructible_v<_Tp> &&
-             is_copy_constructible_v<_Err> &&
-             is_trivially_copy_constructible_v<_Tp> &&
+    requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Tp> &&
              is_trivially_copy_constructible_v<_Err>)
   = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __other)
-    noexcept(is_nothrow_copy_constructible_v<_Tp> && is_nothrow_copy_constructible_v<_Err>) // strengthened
+  _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __other) noexcept(
+      is_nothrow_copy_constructible_v<_Tp> && is_nothrow_copy_constructible_v<_Err>) // strengthened
     requires(is_copy_constructible_v<_Tp> && is_copy_constructible_v<_Err> &&
              !(is_trivially_copy_constructible_v<_Tp> && is_trivially_copy_constructible_v<_Err>))
-      : __has_val_(__other.__has_val_) {
-    if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__val_), __other.__union_.__val_);
-    } else {
-      std::construct_at(std::addressof(__union_.__unex_), __other.__union_.__unex_);
-    }
-  }
-
+      : __base(__other.__has_val(), __other.__union()) {}
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&)
-    requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err>
-              && is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>)
+    requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Tp> &&
+             is_trivially_move_constructible_v<_Err>)
   = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __other)
-    noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_constructible_v<_Err>)
+  _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __other) noexcept(
+      is_nothrow_move_constructible_v<_Tp> && is_nothrow_move_constructible_v<_Err>)
     requires(is_move_constructible_v<_Tp> && is_move_constructible_v<_Err> &&
              !(is_trivially_move_constructible_v<_Tp> && is_trivially_move_constructible_v<_Err>))
-      : __has_val_(__other.__has_val_) {
-    if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__val_), std::move(__other.__union_.__val_));
-    } else {
-      std::construct_at(std::addressof(__union_.__unex_), std::move(__other.__union_.__unex_));
-    }
-  }
+      : __base(__other.__has_val(), std::move(__other.__union())) {}
 
 private:
   template <class _Up, class _OtherErr, class _UfQual, class _OtherErrQual>
   using __can_convert =
       _And< is_constructible<_Tp, _UfQual>,
             is_constructible<_Err, _OtherErrQual>,
-            _Not<is_constructible<_Tp, expected<_Up, _OtherErr>&>>,
-            _Not<is_constructible<_Tp, expected<_Up, _OtherErr>>>,
-            _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>&>>,
-            _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>>>,
-            _Not<is_convertible<expected<_Up, _OtherErr>&, _Tp>>,
-            _Not<is_convertible<expected<_Up, _OtherErr>&&, _Tp>>,
-            _Not<is_convertible<const expected<_Up, _OtherErr>&, _Tp>>,
-            _Not<is_convertible<const expected<_Up, _OtherErr>&&, _Tp>>,
+            _If<_Not<is_same<remove_cv_t<_Tp>, bool>>::value,
+                _And< 
+                      _Not<_And<is_same<_Tp, _Up>, is_same<_Err, _OtherErr>>>, // use the copy constructor instead, see #92676
+                      _Not<is_constructible<_Tp, expected<_Up, _OtherErr>&>>,
+                      _Not<is_constructible<_Tp, expected<_Up, _OtherErr>>>,
+                      _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>&>>,
+                      _Not<is_constructible<_Tp, const expected<_Up, _OtherErr>>>,
+                      _Not<is_convertible<expected<_Up, _OtherErr>&, _Tp>>,
+                      _Not<is_convertible<expected<_Up, _OtherErr>&&, _Tp>>,
+                      _Not<is_convertible<const expected<_Up, _OtherErr>&, _Tp>>,
+                      _Not<is_convertible<const expected<_Up, _OtherErr>&&, _Tp>>>,
+                true_type>,
             _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>&>>,
             _Not<is_constructible<unexpected<_Err>, expected<_Up, _OtherErr>>>,
             _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>,
@@ -179,141 +526,97 @@ private:
   template <class _Func, class... _Args>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(
       std::__expected_construct_in_place_from_invoke_tag __tag, _Func&& __f, _Args&&... __args)
-      : __union_(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...), __has_val_(true) {}
+      : __base(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...) {}
 
   template <class _Func, class... _Args>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(
       std::__expected_construct_unexpected_from_invoke_tag __tag, _Func&& __f, _Args&&... __args)
-      : __union_(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...), __has_val_(false) {}
+      : __base(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...) {}
 
 public:
   template <class _Up, class _OtherErr>
     requires __can_convert<_Up, _OtherErr, const _Up&, const _OtherErr&>::value
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _Up&, _Tp> ||
                                            !is_convertible_v<const _OtherErr&, _Err>)
-  expected(const expected<_Up, _OtherErr>& __other)
-    noexcept(is_nothrow_constructible_v<_Tp, const _Up&> &&
-             is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
-      : __has_val_(__other.__has_val_) {
-    if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__val_), __other.__union_.__val_);
-    } else {
-      std::construct_at(std::addressof(__union_.__unex_), __other.__union_.__unex_);
-    }
-  }
+      expected(const expected<_Up, _OtherErr>& __other) noexcept(
+          is_nothrow_constructible_v<_Tp, const _Up&> &&
+          is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
+      : __base(__other.__has_val(), __other.__union()) {}
 
   template <class _Up, class _OtherErr>
     requires __can_convert<_Up, _OtherErr, _Up, _OtherErr>::value
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp> || !is_convertible_v<_OtherErr, _Err>)
-  expected(expected<_Up, _OtherErr>&& __other)
-    noexcept(is_nothrow_constructible_v<_Tp, _Up> && is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
-      : __has_val_(__other.__has_val_) {
-    if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__val_), std::move(__other.__union_.__val_));
-    } else {
-      std::construct_at(std::addressof(__union_.__unex_), std::move(__other.__union_.__unex_));
-    }
-  }
+      expected(expected<_Up, _OtherErr>&& __other) noexcept(
+          is_nothrow_constructible_v<_Tp, _Up> && is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
+      : __base(__other.__has_val(), std::move(__other.__union())) {}
 
   template <class _Up = _Tp>
     requires(!is_same_v<remove_cvref_t<_Up>, in_place_t> && !is_same_v<expected, remove_cvref_t<_Up>> &&
-             !__is_std_unexpected<remove_cvref_t<_Up>>::value && is_constructible_v<_Tp, _Up>)
+             is_constructible_v<_Tp, _Up> && !__is_std_unexpected<remove_cvref_t<_Up>>::value &&
+             (!is_same_v<remove_cv_t<_Tp>, bool> || !__is_std_expected<remove_cvref_t<_Up>>::value))
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up, _Tp>)
-  expected(_Up&& __u)
-    noexcept(is_nothrow_constructible_v<_Tp, _Up>) // strengthened
-      : __has_val_(true) {
-    std::construct_at(std::addressof(__union_.__val_), std::forward<_Up>(__u));
-  }
-
+      expected(_Up&& __u) noexcept(is_nothrow_constructible_v<_Tp, _Up>) // strengthened
+      : __base(in_place, std::forward<_Up>(__u)) {}
 
   template <class _OtherErr>
     requires is_constructible_v<_Err, const _OtherErr&>
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>)
-  expected(const unexpected<_OtherErr>& __unex)
-    noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
-      : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), __unex.error());
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>) expected(
+      const unexpected<_OtherErr>& __unex) noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
+      : __base(unexpect, __unex.error()) {}
 
   template <class _OtherErr>
     requires is_constructible_v<_Err, _OtherErr>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>)
-  expected(unexpected<_OtherErr>&& __unex)
-    noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
-      : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), std::move(__unex.error()));
-  }
+      expected(unexpected<_OtherErr>&& __unex) noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
+      : __base(unexpect, std::move(__unex.error())) {}
 
   template <class... _Args>
     requires is_constructible_v<_Tp, _Args...>
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t, _Args&&... __args)
-    noexcept(is_nothrow_constructible_v<_Tp, _Args...>) // strengthened
-      : __has_val_(true) {
-    std::construct_at(std::addressof(__union_.__val_), std::forward<_Args>(__args)...);
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, _Args...>) // strengthened
+      : __base(in_place, std::forward<_Args>(__args)...) {}
 
   template <class _Up, class... _Args>
     requires is_constructible_v< _Tp, initializer_list<_Up>&, _Args... >
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit
-  expected(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
-    noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) // strengthened
-      : __has_val_(true) {
-    std::construct_at(std::addressof(__union_.__val_), __il, std::forward<_Args>(__args)...);
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t, initializer_list<_Up> __il, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>) // strengthened
+      : __base(in_place, __il, std::forward<_Args>(__args)...) {}
 
   template <class... _Args>
     requires is_constructible_v<_Err, _Args...>
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args)
-    noexcept(is_nothrow_constructible_v<_Err, _Args...>)  // strengthened
-      : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), std::forward<_Args>(__args)...);
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Err, _Args...>) // strengthened
+      : __base(unexpect, std::forward<_Args>(__args)...) {}
 
   template <class _Up, class... _Args>
     requires is_constructible_v< _Err, initializer_list<_Up>&, _Args... >
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit
-  expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args)
-    noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened
-      : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), __il, std::forward<_Args>(__args)...);
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened
+      : __base(unexpect, __il, std::forward<_Args>(__args)...) {}
 
   // [expected.object.dtor], destructor
 
-  _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
-    requires(is_trivially_destructible_v<_Tp> && is_trivially_destructible_v<_Err>)
-  = default;
-
-  _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
-    requires(!is_trivially_destructible_v<_Tp> || !is_trivially_destructible_v<_Err>)
-  {
-    if (__has_val_) {
-      std::destroy_at(std::addressof(__union_.__val_));
-    } else {
-      std::destroy_at(std::addressof(__union_.__unex_));
-    }
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr ~expected() = default;
 
 private:
-  template <class _T1, class _T2, class... _Args>
-  _LIBCPP_HIDE_FROM_ABI static constexpr void __reinit_expected(_T1& __newval, _T2& __oldval, _Args&&... __args) {
+  template <class _Tag, class _OtherTag, class _T1, class _T2, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr void __reinit_expected(_T2& __oldval, _Args&&... __args) {
     if constexpr (is_nothrow_constructible_v<_T1, _Args...>) {
-      std::destroy_at(std::addressof(__oldval));
-      std::construct_at(std::addressof(__newval), std::forward<_Args>(__args)...);
+      this->__destroy();
+      this->__construct(_Tag{}, std::forward<_Args>(__args)...);
     } else if constexpr (is_nothrow_move_constructible_v<_T1>) {
       _T1 __tmp(std::forward<_Args>(__args)...);
-      std::destroy_at(std::addressof(__oldval));
-      std::construct_at(std::addressof(__newval), std::move(__tmp));
+      this->__destroy();
+      this->__construct(_Tag{}, std::move(__tmp));
     } else {
       static_assert(
           is_nothrow_move_constructible_v<_T2>,
           "To provide strong exception guarantee, T2 has to satisfy `is_nothrow_move_constructible_v` so that it can "
           "be reverted to the previous state in case an exception is thrown during the assignment.");
       _T2 __tmp(std::move(__oldval));
-      std::destroy_at(std::addressof(__oldval));
-      auto __trans =
-          std::__make_exception_guard([&] { std::construct_at(std::addressof(__oldval), std::move(__tmp)); });
-      std::construct_at(std::addressof(__newval), std::forward<_Args>(__args)...);
+      this->__destroy();
+      auto __trans = std::__make_exception_guard([&] { this->__construct(_OtherTag{}, std::move(__tmp)); });
+      this->__construct(_Tag{}, std::forward<_Args>(__args)...);
       __trans.__complete();
     }
   }
@@ -322,73 +625,55 @@ public:
   // [expected.object.assign], assignment
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected&) = delete;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs)
-    noexcept(is_nothrow_copy_assignable_v<_Tp> &&
-             is_nothrow_copy_constructible_v<_Tp> &&
-             is_nothrow_copy_assignable_v<_Err> &&
-             is_nothrow_copy_constructible_v<_Err>) // strengthened
-    requires(is_copy_assignable_v<_Tp> &&
-             is_copy_constructible_v<_Tp> &&
-             is_copy_assignable_v<_Err> &&
+  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs) noexcept(
+      is_nothrow_copy_assignable_v<_Tp> && is_nothrow_copy_constructible_v<_Tp> && is_nothrow_copy_assignable_v<_Err> &&
+      is_nothrow_copy_constructible_v<_Err>) // strengthened
+    requires(is_copy_assignable_v<_Tp> && is_copy_constructible_v<_Tp> && is_copy_assignable_v<_Err> &&
              is_copy_constructible_v<_Err> &&
-             (is_nothrow_move_constructible_v<_Tp> ||
-              is_nothrow_move_constructible_v<_Err>))
+             (is_nothrow_move_constructible_v<_Tp> || is_nothrow_move_constructible_v<_Err>))
   {
-    if (__has_val_ && __rhs.__has_val_) {
-      __union_.__val_ = __rhs.__union_.__val_;
-    } else if (__has_val_) {
-      __reinit_expected(__union_.__unex_, __union_.__val_, __rhs.__union_.__unex_);
-    } else if (__rhs.__has_val_) {
-      __reinit_expected(__union_.__val_, __union_.__unex_, __rhs.__union_.__val_);
+    if (this->__has_val() && __rhs.__has_val()) {
+      this->__val() = __rhs.__val();
+    } else if (this->__has_val()) {
+      __reinit_expected<unexpect_t, in_place_t, _Err, _Tp>(this->__val(), __rhs.__unex());
+    } else if (__rhs.__has_val()) {
+      __reinit_expected<in_place_t, unexpect_t, _Tp, _Err>(this->__unex(), __rhs.__val());
     } else {
-      __union_.__unex_ = __rhs.__union_.__unex_;
+      this->__unex() = __rhs.__unex();
     }
-    // note: only reached if no exception+rollback was done inside __reinit_expected
-    __has_val_ = __rhs.__has_val_;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs)
-    noexcept(is_nothrow_move_assignable_v<_Tp> &&
-             is_nothrow_move_constructible_v<_Tp> &&
-             is_nothrow_move_assignable_v<_Err> &&
-             is_nothrow_move_constructible_v<_Err>)
-    requires(is_move_constructible_v<_Tp> &&
-             is_move_assignable_v<_Tp> &&
-             is_move_constructible_v<_Err> &&
+  _LIBCPP_HIDE_FROM_ABI constexpr expected&
+  operator=(expected&& __rhs) noexcept(is_nothrow_move_assignable_v<_Tp> && is_nothrow_move_constructible_v<_Tp> &&
+                                       is_nothrow_move_assignable_v<_Err> && is_nothrow_move_constructible_v<_Err>)
+    requires(is_move_constructible_v<_Tp> && is_move_assignable_v<_Tp> && is_move_constructible_v<_Err> &&
              is_move_assignable_v<_Err> &&
-             (is_nothrow_move_constructible_v<_Tp> ||
-              is_nothrow_move_constructible_v<_Err>))
+             (is_nothrow_move_constructible_v<_Tp> || is_nothrow_move_constructible_v<_Err>))
   {
-    if (__has_val_ && __rhs.__has_val_) {
-      __union_.__val_ = std::move(__rhs.__union_.__val_);
-    } else if (__has_val_) {
-      __reinit_expected(__union_.__unex_, __union_.__val_, std::move(__rhs.__union_.__unex_));
-    } else if (__rhs.__has_val_) {
-      __reinit_expected(__union_.__val_, __union_.__unex_, std::move(__rhs.__union_.__val_));
+    if (this->__has_val() && __rhs.__has_val()) {
+      this->__val() = std::move(__rhs.__val());
+    } else if (this->__has_val()) {
+      __reinit_expected<unexpect_t, in_place_t, _Err, _Tp>(this->__val(), std::move(__rhs.__unex()));
+    } else if (__rhs.__has_val()) {
+      __reinit_expected<in_place_t, unexpect_t, _Tp, _Err>(this->__unex(), std::move(__rhs.__val()));
     } else {
-      __union_.__unex_ = std::move(__rhs.__union_.__unex_);
+      this->__unex() = std::move(__rhs.__unex());
     }
-    // note: only reached if no exception+rollback was done inside __reinit_expected
-    __has_val_ = __rhs.__has_val_;
     return *this;
   }
 
   template <class _Up = _Tp>
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(_Up&& __v)
-    requires(!is_same_v<expected, remove_cvref_t<_Up>> &&
-             !__is_std_unexpected<remove_cvref_t<_Up>>::value &&
-             is_constructible_v<_Tp, _Up> &&
-             is_assignable_v<_Tp&, _Up> &&
-             (is_nothrow_constructible_v<_Tp, _Up> ||
-              is_nothrow_move_constructible_v<_Tp> ||
+    requires(!is_same_v<expected, remove_cvref_t<_Up>> && !__is_std_unexpected<remove_cvref_t<_Up>>::value &&
+             is_constructible_v<_Tp, _Up> && is_assignable_v<_Tp&, _Up> &&
+             (is_nothrow_constructible_v<_Tp, _Up> || is_nothrow_move_constructible_v<_Tp> ||
               is_nothrow_move_constructible_v<_Err>))
   {
-    if (__has_val_) {
-      __union_.__val_ = std::forward<_Up>(__v);
+    if (this->__has_val()) {
+      this->__val() = std::forward<_Up>(__v);
     } else {
-      __reinit_expected(__union_.__val_, __union_.__unex_, std::forward<_Up>(__v));
-      __has_val_ = true;
+      __reinit_expected<in_place_t, unexpect_t, _Tp, _Err>(this->__unex(), std::forward<_Up>(__v));
     }
     return *this;
   }
@@ -407,11 +692,10 @@ public:
   template <class _OtherErr>
     requires(__can_assign_from_unexpected<const _OtherErr&>)
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_OtherErr>& __un) {
-    if (__has_val_) {
-      __reinit_expected(__union_.__unex_, __union_.__val_, __un.error());
-      __has_val_ = false;
+    if (this->__has_val()) {
+      __reinit_expected<unexpect_t, in_place_t, _Err, _Tp>(this->__val(), __un.error());
     } else {
-      __union_.__unex_ = __un.error();
+      this->__unex() = __un.error();
     }
     return *this;
   }
@@ -419,11 +703,10 @@ public:
   template <class _OtherErr>
     requires(__can_assign_from_unexpected<_OtherErr>)
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_OtherErr>&& __un) {
-    if (__has_val_) {
-      __reinit_expected(__union_.__unex_, __union_.__val_, std::move(__un.error()));
-      __has_val_ = false;
+    if (this->__has_val()) {
+      __reinit_expected<unexpect_t, in_place_t, _Err, _Tp>(this->__val(), std::move(__un.error()));
     } else {
-      __union_.__unex_ = std::move(__un.error());
+      this->__unex() = std::move(__un.error());
     }
     return *this;
   }
@@ -431,90 +714,69 @@ public:
   template <class... _Args>
     requires is_nothrow_constructible_v<_Tp, _Args...>
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp& emplace(_Args&&... __args) noexcept {
-    if (__has_val_) {
-      std::destroy_at(std::addressof(__union_.__val_));
-    } else {
-      std::destroy_at(std::addressof(__union_.__unex_));
-      __has_val_ = true;
-    }
-    return *std::construct_at(std::addressof(__union_.__val_), std::forward<_Args>(__args)...);
+    this->__destroy();
+    this->__construct(in_place, std::forward<_Args>(__args)...);
+    return this->__val();
   }
 
   template <class _Up, class... _Args>
-    requires is_nothrow_constructible_v< _Tp, initializer_list<_Up>&, _Args... >
+    requires is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) noexcept {
-    if (__has_val_) {
-      std::destroy_at(std::addressof(__union_.__val_));
-    } else {
-      std::destroy_at(std::addressof(__union_.__unex_));
-      __has_val_ = true;
-    }
-    return *std::construct_at(std::addressof(__union_.__val_), __il, std::forward<_Args>(__args)...);
+    this->__destroy();
+    this->__construct(in_place, __il, std::forward<_Args>(__args)...);
+    return this->__val();
   }
 
-
 public:
   // [expected.object.swap], swap
-  _LIBCPP_HIDE_FROM_ABI constexpr void swap(expected& __rhs)
-    noexcept(is_nothrow_move_constructible_v<_Tp> &&
-             is_nothrow_swappable_v<_Tp> &&
-             is_nothrow_move_constructible_v<_Err> &&
-             is_nothrow_swappable_v<_Err>)
-    requires(is_swappable_v<_Tp> &&
-             is_swappable_v<_Err> &&
-             is_move_constructible_v<_Tp> &&
+  _LIBCPP_HIDE_FROM_ABI constexpr void
+  swap(expected& __rhs) noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp> &&
+                                 is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>)
+    requires(is_swappable_v<_Tp> && is_swappable_v<_Err> && is_move_constructible_v<_Tp> &&
              is_move_constructible_v<_Err> &&
-             (is_nothrow_move_constructible_v<_Tp> ||
-              is_nothrow_move_constructible_v<_Err>))
+             (is_nothrow_move_constructible_v<_Tp> || is_nothrow_move_constructible_v<_Err>))
   {
-    auto __swap_val_unex_impl = [&](expected& __with_val, expected& __with_err) {
+    auto __swap_val_unex_impl = [](expected& __with_val, expected& __with_err) {
       if constexpr (is_nothrow_move_constructible_v<_Err>) {
-        _Err __tmp(std::move(__with_err.__union_.__unex_));
-        std::destroy_at(std::addressof(__with_err.__union_.__unex_));
-        auto __trans = std::__make_exception_guard([&] {
-          std::construct_at(std::addressof(__with_err.__union_.__unex_), std::move(__tmp));
-        });
-        std::construct_at(std::addressof(__with_err.__union_.__val_), std::move(__with_val.__union_.__val_));
+        _Err __tmp(std::move(__with_err.__unex()));
+        __with_err.__destroy();
+        auto __trans = std::__make_exception_guard([&] { __with_err.__construct(unexpect, std::move(__tmp)); });
+        __with_err.__construct(in_place, std::move(__with_val.__val()));
         __trans.__complete();
-        std::destroy_at(std::addressof(__with_val.__union_.__val_));
-        std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__tmp));
+        __with_val.__destroy();
+        __with_val.__construct(unexpect, std::move(__tmp));
       } else {
         static_assert(is_nothrow_move_constructible_v<_Tp>,
                       "To provide strong exception guarantee, Tp has to satisfy `is_nothrow_move_constructible_v` so "
                       "that it can be reverted to the previous state in case an exception is thrown during swap.");
-        _Tp __tmp(std::move(__with_val.__union_.__val_));
-        std::destroy_at(std::addressof(__with_val.__union_.__val_));
-        auto __trans = std::__make_exception_guard([&] {
-          std::construct_at(std::addressof(__with_val.__union_.__val_), std::move(__tmp));
-        });
-        std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__with_err.__union_.__unex_));
+        _Tp __tmp(std::move(__with_val.__val()));
+        __with_val.__destroy();
+        auto __trans = std::__make_exception_guard([&] { __with_val.__construct(in_place, std::move(__tmp)); });
+        __with_val.__construct(unexpect, std::move(__with_err.__unex()));
         __trans.__complete();
-        std::destroy_at(std::addressof(__with_err.__union_.__unex_));
-        std::construct_at(std::addressof(__with_err.__union_.__val_), std::move(__tmp));
+        __with_err.__destroy();
+        __with_err.__construct(in_place, std::move(__tmp));
       }
-      __with_val.__has_val_ = false;
-      __with_err.__has_val_ = true;
     };
 
-    if (__has_val_) {
-      if (__rhs.__has_val_) {
+    if (this->__has_val()) {
+      if (__rhs.__has_val()) {
         using std::swap;
-        swap(__union_.__val_, __rhs.__union_.__val_);
+        swap(this->__val(), __rhs.__val());
       } else {
         __swap_val_unex_impl(*this, __rhs);
       }
     } else {
-      if (__rhs.__has_val_) {
+      if (__rhs.__has_val()) {
         __swap_val_unex_impl(__rhs, *this);
       } else {
         using std::swap;
-        swap(__union_.__unex_, __rhs.__union_.__unex_);
+        swap(this->__unex(), __rhs.__unex());
       }
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y)
-    noexcept(noexcept(__x.swap(__y)))
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y) noexcept(noexcept(__x.swap(__y)))
     requires requires { __x.swap(__y); }
   {
     __x.swap(__y);
@@ -522,99 +784,115 @@ public:
 
   // [expected.object.obs], observers
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* operator->() const noexcept {
-    _LIBCPP_ASSERT(__has_val_, "expected::operator-> requires the expected to contain a value");
-    return std::addressof(__union_.__val_);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        this->__has_val(), "expected::operator-> requires the expected to contain a value");
+    return std::addressof(this->__val());
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp* operator->() noexcept {
-    _LIBCPP_ASSERT(__has_val_, "expected::operator-> requires the expected to contain a value");
-    return std::addressof(__union_.__val_);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        this->__has_val(), "expected::operator-> requires the expected to contain a value");
+    return std::addressof(this->__val());
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const& noexcept {
-    _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
-    return __union_.__val_;
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        this->__has_val(), "expected::operator* requires the expected to contain a value");
+    return this->__val();
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() & noexcept {
-    _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
-    return __union_.__val_;
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        this->__has_val(), "expected::operator* requires the expected to contain a value");
+    return this->__val();
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& operator*() const&& noexcept {
-    _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
-    return std::move(__union_.__val_);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        this->__has_val(), "expected::operator* requires the expected to contain a value");
+    return std::move(this->__val());
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator*() && noexcept {
-    _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
-    return std::move(__union_.__val_);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        this->__has_val(), "expected::operator* requires the expected to contain a value");
+    return std::move(this->__val());
   }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __has_val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return this->__has_val(); }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __has_val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return this->__has_val(); }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& value() const& {
-    if (!__has_val_) {
-      std::__throw_bad_expected_access<_Err>(__union_.__unex_);
+    static_assert(is_copy_constructible_v<_Err>, "error_type has to be copy constructible");
+    if (!this->__has_val()) {
+      std::__throw_bad_expected_access<_Err>(std::as_const(error()));
     }
-    return __union_.__val_;
+    return this->__val();
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() & {
-    if (!__has_val_) {
-      std::__throw_bad_expected_access<_Err>(__union_.__unex_);
+    static_assert(is_copy_constructible_v<_Err>, "error_type has to be copy constructible");
+    if (!this->__has_val()) {
+      std::__throw_bad_expected_access<_Err>(std::as_const(error()));
     }
-    return __union_.__val_;
+    return this->__val();
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& value() const&& {
-    if (!__has_val_) {
-      std::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+    static_assert(is_copy_constructible_v<_Err> && is_constructible_v<_Err, decltype(std::move(error()))>,
+                  "error_type has to be both copy constructible and constructible from decltype(std::move(error()))");
+    if (!this->__has_val()) {
+      std::__throw_bad_expected_access<_Err>(std::move(error()));
     }
-    return std::move(__union_.__val_);
+    return std::move(this->__val());
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& value() && {
-    if (!__has_val_) {
-      std::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+    static_assert(is_copy_constructible_v<_Err> && is_constructible_v<_Err, decltype(std::move(error()))>,
+                  "error_type has to be both copy constructible and constructible from decltype(std::move(error()))");
+    if (!this->__has_val()) {
+      std::__throw_bad_expected_access<_Err>(std::move(error()));
     }
-    return std::move(__union_.__val_);
+    return std::move(this->__val());
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept {
-    _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return __union_.__unex_;
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !this->__has_val(), "expected::error requires the expected to contain an error");
+    return this->__unex();
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept {
-    _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return __union_.__unex_;
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !this->__has_val(), "expected::error requires the expected to contain an error");
+    return this->__unex();
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept {
-    _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return std::move(__union_.__unex_);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !this->__has_val(), "expected::error requires the expected to contain an error");
+    return std::move(this->__unex());
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept {
-    _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return std::move(__union_.__unex_);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !this->__has_val(), "expected::error requires the expected to contain an error");
+    return std::move(this->__unex());
   }
 
   template <class _Up>
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) const& {
     static_assert(is_copy_constructible_v<_Tp>, "value_type has to be copy constructible");
     static_assert(is_convertible_v<_Up, _Tp>, "argument has to be convertible to value_type");
-    return __has_val_ ? __union_.__val_ : static_cast<_Tp>(std::forward<_Up>(__v));
+    return this->__has_val() ? this->__val() : static_cast<_Tp>(std::forward<_Up>(__v));
   }
 
   template <class _Up>
   _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) && {
     static_assert(is_move_constructible_v<_Tp>, "value_type has to be move constructible");
     static_assert(is_convertible_v<_Up, _Tp>, "argument has to be convertible to value_type");
-    return __has_val_ ? std::move(__union_.__val_) : static_cast<_Tp>(std::forward<_Up>(__v));
+    return this->__has_val() ? std::move(this->__val()) : static_cast<_Tp>(std::forward<_Up>(__v));
   }
 
   template <class _Up = _Err>
@@ -640,11 +918,11 @@ public:
     requires is_constructible_v<_Err, _Err&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
     using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&>>;
-    static_assert(__is_std_expected<_Up>::value, "The result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_std_expected<_Up>::value, "The result of f(**this) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(value()) must have the same error_type as this expected");
+                  "The result of f(**this) must have the same error_type as this expected");
     if (has_value()) {
-      return std::invoke(std::forward<_Func>(__f), value());
+      return std::invoke(std::forward<_Func>(__f), this->__val());
     }
     return _Up(unexpect, error());
   }
@@ -653,11 +931,11 @@ public:
     requires is_constructible_v<_Err, const _Err&>
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
     using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&>>;
-    static_assert(__is_std_expected<_Up>::value, "The result of f(value()) must be a specialization of std::expected");
+    static_assert(__is_std_expected<_Up>::value, "The result of f(**this) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(value()) must have the same error_type as this expected");
+                  "The result of f(**this) must have the same error_type as this expected");
     if (has_value()) {
-      return std::invoke(std::forward<_Func>(__f), value());
+      return std::invoke(std::forward<_Func>(__f), this->__val());
     }
     return _Up(unexpect, error());
   }
@@ -667,11 +945,11 @@ public:
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
     using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&&>>;
     static_assert(
-        __is_std_expected<_Up>::value, "The result of f(std::move(value())) must be a specialization of std::expected");
+        __is_std_expected<_Up>::value, "The result of f(std::move(**this)) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(std::move(value())) must have the same error_type as this expected");
+                  "The result of f(std::move(**this)) must have the same error_type as this expected");
     if (has_value()) {
-      return std::invoke(std::forward<_Func>(__f), std::move(value()));
+      return std::invoke(std::forward<_Func>(__f), std::move(this->__val()));
     }
     return _Up(unexpect, std::move(error()));
   }
@@ -681,11 +959,11 @@ public:
   _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
     using _Up = remove_cvref_t<invoke_result_t<_Func, const _Tp&&>>;
     static_assert(
-        __is_std_expected<_Up>::value, "The result of f(std::move(value())) must be a specialization of std::expected");
+        __is_std_expected<_Up>::value, "The result of f(std::move(**this)) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Up::error_type, _Err>,
-                  "The result of f(std::move(value())) must have the same error_type as this expected");
+                  "The result of f(std::move(**this)) must have the same error_type as this expected");
     if (has_value()) {
-      return std::invoke(std::forward<_Func>(__f), std::move(value()));
+      return std::invoke(std::forward<_Func>(__f), std::move(this->__val()));
     }
     return _Up(unexpect, std::move(error()));
   }
@@ -698,7 +976,7 @@ public:
     static_assert(is_same_v<typename _Gp::value_type, _Tp>,
                   "The result of f(error()) must have the same value_type as this expected");
     if (has_value()) {
-      return _Gp(in_place, value());
+      return _Gp(in_place, this->__val());
     }
     return std::invoke(std::forward<_Func>(__f), error());
   }
@@ -711,7 +989,7 @@ public:
     static_assert(is_same_v<typename _Gp::value_type, _Tp>,
                   "The result of f(error()) must have the same value_type as this expected");
     if (has_value()) {
-      return _Gp(in_place, value());
+      return _Gp(in_place, this->__val());
     }
     return std::invoke(std::forward<_Func>(__f), error());
   }
@@ -725,7 +1003,7 @@ public:
     static_assert(is_same_v<typename _Gp::value_type, _Tp>,
                   "The result of f(std::move(error())) must have the same value_type as this expected");
     if (has_value()) {
-      return _Gp(in_place, std::move(value()));
+      return _Gp(in_place, std::move(this->__val()));
     }
     return std::invoke(std::forward<_Func>(__f), std::move(error()));
   }
@@ -739,7 +1017,7 @@ public:
     static_assert(is_same_v<typename _Gp::value_type, _Tp>,
                   "The result of f(std::move(error())) must have the same value_type as this expected");
     if (has_value()) {
-      return _Gp(in_place, std::move(value()));
+      return _Gp(in_place, std::move(this->__val()));
     }
     return std::invoke(std::forward<_Func>(__f), std::move(error()));
   }
@@ -752,9 +1030,10 @@ public:
       return expected<_Up, _Err>(unexpect, error());
     }
     if constexpr (!is_void_v<_Up>) {
-      return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), value());
+      return expected<_Up, _Err>(
+          __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), this->__val());
     } else {
-      std::invoke(std::forward<_Func>(__f), value());
+      std::invoke(std::forward<_Func>(__f), this->__val());
       return expected<_Up, _Err>();
     }
   }
@@ -767,9 +1046,10 @@ public:
       return expected<_Up, _Err>(unexpect, error());
     }
     if constexpr (!is_void_v<_Up>) {
-      return expected<_Up, _Err>(__expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), value());
+      return expected<_Up, _Err>(
+          __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), this->__val());
     } else {
-      std::invoke(std::forward<_Func>(__f), value());
+      std::invoke(std::forward<_Func>(__f), this->__val());
       return expected<_Up, _Err>();
     }
   }
@@ -783,9 +1063,9 @@ public:
     }
     if constexpr (!is_void_v<_Up>) {
       return expected<_Up, _Err>(
-          __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
+          __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(this->__val()));
     } else {
-      std::invoke(std::forward<_Func>(__f), std::move(value()));
+      std::invoke(std::forward<_Func>(__f), std::move(this->__val()));
       return expected<_Up, _Err>();
     }
   }
@@ -799,9 +1079,9 @@ public:
     }
     if constexpr (!is_void_v<_Up>) {
       return expected<_Up, _Err>(
-          __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
+          __expected_construct_in_place_from_invoke_tag{}, std::forward<_Func>(__f), std::move(this->__val()));
     } else {
-      std::invoke(std::forward<_Func>(__f), std::move(value()));
+      std::invoke(std::forward<_Func>(__f), std::move(this->__val()));
       return expected<_Up, _Err>();
     }
   }
@@ -813,7 +1093,7 @@ public:
     static_assert(__valid_std_unexpected<_Gp>::value,
                   "The result of f(error()) must be a valid template argument for unexpected");
     if (has_value()) {
-      return expected<_Tp, _Gp>(in_place, value());
+      return expected<_Tp, _Gp>(in_place, this->__val());
     }
     return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error());
   }
@@ -825,7 +1105,7 @@ public:
     static_assert(__valid_std_unexpected<_Gp>::value,
                   "The result of f(error()) must be a valid template argument for unexpected");
     if (has_value()) {
-      return expected<_Tp, _Gp>(in_place, value());
+      return expected<_Tp, _Gp>(in_place, this->__val());
     }
     return expected<_Tp, _Gp>(__expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), error());
   }
@@ -837,7 +1117,7 @@ public:
     static_assert(__valid_std_unexpected<_Gp>::value,
                   "The result of f(std::move(error())) must be a valid template argument for unexpected");
     if (has_value()) {
-      return expected<_Tp, _Gp>(in_place, std::move(value()));
+      return expected<_Tp, _Gp>(in_place, std::move(this->__val()));
     }
     return expected<_Tp, _Gp>(
         __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error()));
@@ -850,7 +1130,7 @@ public:
     static_assert(__valid_std_unexpected<_Gp>::value,
                   "The result of f(std::move(error())) must be a valid template argument for unexpected");
     if (has_value()) {
-      return expected<_Tp, _Gp>(in_place, std::move(value()));
+      return expected<_Tp, _Gp>(in_place, std::move(this->__val()));
     }
     return expected<_Tp, _Gp>(
         __expected_construct_unexpected_from_invoke_tag{}, std::forward<_Func>(__f), std::move(error()));
@@ -860,95 +1140,220 @@ public:
   template <class _T2, class _E2>
     requires(!is_void_v<_T2>)
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const expected<_T2, _E2>& __y) {
-    if (__x.__has_val_ != __y.__has_val_) {
+    if (__x.__has_val() != __y.__has_val()) {
       return false;
     } else {
-      if (__x.__has_val_) {
-        return __x.__union_.__val_ == __y.__union_.__val_;
+      if (__x.__has_val()) {
+        return __x.__val() == __y.__val();
       } else {
-        return __x.__union_.__unex_ == __y.__union_.__unex_;
+        return __x.__unex() == __y.__unex();
       }
     }
   }
 
   template <class _T2>
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const _T2& __v) {
-    return __x.__has_val_ && static_cast<bool>(__x.__union_.__val_ == __v);
+    return __x.__has_val() && static_cast<bool>(__x.__val() == __v);
   }
 
   template <class _E2>
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const unexpected<_E2>& __e) {
-    return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __e.error());
+    return !__x.__has_val() && static_cast<bool>(__x.__unex() == __e.error());
   }
+};
 
-private:
+template <class _Err>
+class __expected_void_base {
   struct __empty_t {};
-
-  template <class _ValueType, class _ErrorType>
-  union __union_t {
-    _LIBCPP_HIDE_FROM_ABI constexpr __union_t() {}
-
-    template <class _Func, class... _Args>
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
-        std::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args)
-        : __val_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
-
-    template <class _Func, class... _Args>
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
-        std::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
-        : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
-
-    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
-      requires(is_trivially_destructible_v<_ValueType> && is_trivially_destructible_v<_ErrorType>)
-    = default;
-
-    // the expected's destructor handles this
-    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() {}
-
-    _ValueType __val_;
-    _ErrorType __unex_;
-  };
-
   // use named union because [[no_unique_address]] cannot be applied to an unnamed union,
   // also guaranteed elision into a potentially-overlapping subobject is unsettled (and
   // it's not clear that it's implementable, given that the function is allowed to clobber
   // the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107.
-  template <class _ValueType, class _ErrorType>
-    requires(is_trivially_move_constructible_v<_ValueType> && is_trivially_move_constructible_v<_ErrorType>)
-  union __union_t<_ValueType, _ErrorType> {
-    _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
+  union __union_t {
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t(const __union_t&)
+      requires(is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Err>)
+    = default;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t(__union_t&&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t(__union_t&&)
+      requires(is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Err>)
+    = default;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(const __union_t&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __union_t& operator=(__union_t&&)      = delete;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(in_place_t) : __empty_() {}
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(unexpect_t, _Args&&... __args)
+        : __unex_(std::forward<_Args>(__args)...) {}
 
     template <class _Func, class... _Args>
     _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
-        std::__expected_construct_in_place_from_invoke_tag, _Func&& __f, _Args&&... __args)
-        : __val_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
-
-    template <class _Func, class... _Args>
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
-        std::__expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
+        __expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
         : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
 
     _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
-      requires(is_trivially_destructible_v<_ValueType> && is_trivially_destructible_v<_ErrorType>)
+      requires(is_trivially_destructible_v<_Err>)
     = default;
 
-    // the expected's destructor handles this
+    // __repr's destructor handles this
     _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
-      requires(!is_trivially_destructible_v<_ValueType> || !is_trivially_destructible_v<_ErrorType>)
+      requires(!is_trivially_destructible_v<_Err>)
     {}
 
     _LIBCPP_NO_UNIQUE_ADDRESS __empty_t __empty_;
-    _LIBCPP_NO_UNIQUE_ADDRESS _ValueType __val_;
-    _LIBCPP_NO_UNIQUE_ADDRESS _ErrorType __unex_;
+    _LIBCPP_NO_UNIQUE_ADDRESS _Err __unex_;
   };
 
-  _LIBCPP_NO_UNIQUE_ADDRESS __union_t<_Tp, _Err> __union_;
-  bool __has_val_;
+  static constexpr bool __put_flag_in_tail                    = __fits_in_tail_padding<__union_t, bool>;
+  static constexpr bool __allow_reusing_expected_tail_padding = !__put_flag_in_tail;
+
+  struct __repr {
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr() = delete;
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(in_place_t __tag) : __union_(in_place, __tag), __has_val_(true) {}
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(unexpect_t __tag, _Args&&... __args)
+        : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(false) {}
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(std::__expected_construct_unexpected_from_invoke_tag __tag,
+                                                    _Args&&... __args)
+        : __union_(in_place, __tag, std::forward<_Args>(__args)...), __has_val_(false) {}
+
+    template <class _OtherUnion>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __repr(bool __has_val, _OtherUnion&& __other)
+      requires(__allow_reusing_expected_tail_padding)
+        : __union_(__conditional_no_unique_address_invoke_tag{},
+                   [&] { return __make_union(__has_val, std::forward<_OtherUnion>(__other)); }),
+          __has_val_(__has_val) {}
+
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr(const __repr&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr(const __repr&)
+      requires(is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Err>)
+    = default;
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr(__repr&&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr(__repr&&)
+      requires(is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Err>)
+    = default;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr& operator=(const __repr&) = delete;
+    _LIBCPP_HIDE_FROM_ABI constexpr __repr& operator=(__repr&&)      = delete;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr ~__repr()
+      requires(is_trivially_destructible_v<_Err>)
+    = default;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr ~__repr()
+      requires(!is_trivially_destructible_v<_Err>)
+    {
+      __destroy_union_member();
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union()
+      requires(__allow_reusing_expected_tail_padding && is_trivially_destructible_v<_Err>)
+    {
+      std::destroy_at(&__union_.__v);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union()
+      requires(__allow_reusing_expected_tail_padding && !is_trivially_destructible_v<_Err>)
+    {
+      __destroy_union_member();
+      std::destroy_at(&__union_.__v);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr void __construct_union(in_place_t)
+      requires(__allow_reusing_expected_tail_padding)
+    {
+      std::construct_at(&__union_.__v, in_place);
+      __has_val_ = true;
+    }
+
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr void __construct_union(unexpect_t, _Args&&... __args)
+      requires(__allow_reusing_expected_tail_padding)
+    {
+      std::construct_at(&__union_.__v, unexpect, std::forward<_Args>(__args)...);
+      __has_val_ = false;
+    }
+
+  private:
+    template <class>
+    friend class __expected_void_base;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr void __destroy_union_member()
+      requires(!is_trivially_destructible_v<_Err>)
+    {
+      if (!__has_val_)
+        std::destroy_at(std::addressof(__union_.__v.__unex_));
+    }
+
+    template <class _OtherUnion>
+    _LIBCPP_HIDE_FROM_ABI static constexpr __union_t __make_union(bool __has_val, _OtherUnion&& __other)
+      requires(__allow_reusing_expected_tail_padding)
+    {
+      if (__has_val)
+        return __union_t(in_place);
+      else
+        return __union_t(unexpect, std::forward<_OtherUnion>(__other).__unex_);
+    }
+
+    _LIBCPP_NO_UNIQUE_ADDRESS __conditional_no_unique_address<__put_flag_in_tail, __union_t> __union_;
+    _LIBCPP_NO_UNIQUE_ADDRESS bool __has_val_;
+  };
+
+  template <class _OtherUnion>
+  _LIBCPP_HIDE_FROM_ABI static constexpr __repr __make_repr(bool __has_val, _OtherUnion&& __other)
+    requires(__put_flag_in_tail)
+  {
+    if (__has_val)
+      return __repr(in_place);
+    else
+      return __repr(unexpect, std::forward<_OtherUnion>(__other).__unex_);
+  }
+
+protected:
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __expected_void_base(_Args&&... __args)
+      : __repr_(in_place, std::forward<_Args>(__args)...) {}
+
+  template <class _OtherUnion>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __expected_void_base(bool __has_val, _OtherUnion&& __other)
+    requires(__put_flag_in_tail)
+      : __repr_(__conditional_no_unique_address_invoke_tag{},
+                [&] { return __make_repr(__has_val, std::forward<_OtherUnion>(__other)); }) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr void __destroy() {
+    if constexpr (__put_flag_in_tail)
+      std::destroy_at(&__repr_.__v);
+    else
+      __repr_.__v.__destroy_union();
+  }
+
+  template <class _Tag, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr void __construct(_Tag __tag, _Args&&... __args) {
+    if constexpr (__put_flag_in_tail)
+      std::construct_at(&__repr_.__v, __tag, std::forward<_Args>(__args)...);
+    else
+      __repr_.__v.__construct_union(__tag, std::forward<_Args>(__args)...);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_val() const { return __repr_.__v.__has_val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr __union_t& __union() { return __repr_.__v.__union_.__v; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const __union_t& __union() const { return __repr_.__v.__union_.__v; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Err& __unex() { return __repr_.__v.__union_.__v.__unex_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Err& __unex() const { return __repr_.__v.__union_.__v.__unex_; }
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS __conditional_no_unique_address<__allow_reusing_expected_tail_padding, __repr> __repr_;
 };
 
 template <class _Tp, class _Err>
   requires is_void_v<_Tp>
-class expected<_Tp, _Err> {
+class expected<_Tp, _Err> : private __expected_void_base<_Err> {
   static_assert(__valid_std_unexpected<_Err>::value,
                 "[expected.void.general] A program that instantiates expected<T, E> with a E that is not a "
                 "valid argument for unexpected<E> is ill-formed");
@@ -965,6 +1370,8 @@ class expected<_Tp, _Err> {
             _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>&>>,
             _Not<is_constructible<unexpected<_Err>, const expected<_Up, _OtherErr>>>>;
 
+  using __base = __expected_void_base<_Err>;
+
 public:
   using value_type      = _Tp;
   using error_type      = _Err;
@@ -974,7 +1381,7 @@ public:
   using rebind = expected<_Up, error_type>;
 
   // [expected.void.ctor], constructors
-  _LIBCPP_HIDE_FROM_ABI constexpr expected() noexcept : __has_val_(true) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr expected() noexcept : __base(in_place) {}
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected&) = delete;
 
@@ -982,132 +1389,104 @@ public:
     requires(is_copy_constructible_v<_Err> && is_trivially_copy_constructible_v<_Err>)
   = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __rhs)
-    noexcept(is_nothrow_copy_constructible_v<_Err>) // strengthened
+  _LIBCPP_HIDE_FROM_ABI constexpr expected(const expected& __rhs) noexcept(
+      is_nothrow_copy_constructible_v<_Err>) // strengthened
     requires(is_copy_constructible_v<_Err> && !is_trivially_copy_constructible_v<_Err>)
-      : __has_val_(__rhs.__has_val_) {
-    if (!__rhs.__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), __rhs.__union_.__unex_);
-    }
-  }
+      : __base(__rhs.__has_val(), __rhs.__union()) {}
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&&)
     requires(is_move_constructible_v<_Err> && is_trivially_move_constructible_v<_Err>)
   = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __rhs)
-    noexcept(is_nothrow_move_constructible_v<_Err>)
+  _LIBCPP_HIDE_FROM_ABI constexpr expected(expected&& __rhs) noexcept(is_nothrow_move_constructible_v<_Err>)
     requires(is_move_constructible_v<_Err> && !is_trivially_move_constructible_v<_Err>)
-      : __has_val_(__rhs.__has_val_) {
-    if (!__rhs.__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), std::move(__rhs.__union_.__unex_));
-    }
-  }
+      : __base(__rhs.__has_val(), std::move(__rhs.__union())) {}
 
   template <class _Up, class _OtherErr>
     requires __can_convert<_Up, _OtherErr, const _OtherErr&>::value
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>)
-  expected(const expected<_Up, _OtherErr>& __rhs)
-    noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
-      : __has_val_(__rhs.__has_val_) {
-    if (!__rhs.__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), __rhs.__union_.__unex_);
-    }
-  }
+      expected(const expected<_Up, _OtherErr>& __rhs) noexcept(
+          is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
+      : __base(__rhs.__has_val(), __rhs.__union()) {}
 
   template <class _Up, class _OtherErr>
     requires __can_convert<_Up, _OtherErr, _OtherErr>::value
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>)
-  expected(expected<_Up, _OtherErr>&& __rhs)
-    noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
-      : __has_val_(__rhs.__has_val_) {
-    if (!__rhs.__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), std::move(__rhs.__union_.__unex_));
-    }
-  }
+      expected(expected<_Up, _OtherErr>&& __rhs) noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
+      : __base(__rhs.__has_val(), std::move(__rhs.__union())) {}
 
   template <class _OtherErr>
     requires is_constructible_v<_Err, const _OtherErr&>
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>)
-  expected(const unexpected<_OtherErr>& __unex)
-    noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
-      : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), __unex.error());
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<const _OtherErr&, _Err>) expected(
+      const unexpected<_OtherErr>& __unex) noexcept(is_nothrow_constructible_v<_Err, const _OtherErr&>) // strengthened
+      : __base(unexpect, __unex.error()) {}
 
   template <class _OtherErr>
     requires is_constructible_v<_Err, _OtherErr>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherErr, _Err>)
-  expected(unexpected<_OtherErr>&& __unex)
-    noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
-      : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), std::move(__unex.error()));
-  }
+      expected(unexpected<_OtherErr>&& __unex) noexcept(is_nothrow_constructible_v<_Err, _OtherErr>) // strengthened
+      : __base(unexpect, std::move(__unex.error())) {}
 
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t) noexcept : __has_val_(true) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(in_place_t) noexcept : __base(in_place) {}
 
   template <class... _Args>
     requires is_constructible_v<_Err, _Args...>
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args)
-    noexcept(is_nothrow_constructible_v<_Err, _Args...>) // strengthened
-      : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), std::forward<_Args>(__args)...);
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Err, _Args...>) // strengthened
+      : __base(unexpect, std::forward<_Args>(__args)...) {}
 
   template <class _Up, class... _Args>
     requires is_constructible_v< _Err, initializer_list<_Up>&, _Args... >
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args)
-    noexcept(is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened
-      : __has_val_(false) {
-    std::construct_at(std::addressof(__union_.__unex_), __il, std::forward<_Args>(__args)...);
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(unexpect_t, initializer_list<_Up> __il, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Err, initializer_list<_Up>&, _Args...>) // strengthened
+      : __base(unexpect, __il, std::forward<_Args>(__args)...) {}
 
 private:
-  template <class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(__expected_construct_in_place_from_invoke_tag, _Func&& __f)
-      : __has_val_(true) {
-    std::invoke(std::forward<_Func>(__f));
-  }
-
   template <class _Func, class... _Args>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit expected(
       __expected_construct_unexpected_from_invoke_tag __tag, _Func&& __f, _Args&&... __args)
-      : __union_(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...), __has_val_(false) {}
+      : __base(__tag, std::forward<_Func>(__f), std::forward<_Args>(__args)...) {}
 
 public:
   // [expected.void.dtor], destructor
 
-  _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
-    requires is_trivially_destructible_v<_Err>
-  = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr ~expected() = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr ~expected()
-    requires(!is_trivially_destructible_v<_Err>)
-  {
-    if (!__has_val_) {
-      std::destroy_at(std::addressof(__union_.__unex_));
-    }
+private:
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr void __reinit_expected(unexpect_t, _Args&&... __args) {
+    _LIBCPP_ASSERT_INTERNAL(this->__has_val(), "__reinit_expected(unexpect_t, ...) needs value to be set");
+
+    this->__destroy();
+    auto __trans = std::__make_exception_guard([&] { this->__construct(in_place); });
+    this->__construct(unexpect, std::forward<_Args>(__args)...);
+    __trans.__complete();
   }
 
-  // [expected.void.assign], assignment
+  _LIBCPP_HIDE_FROM_ABI constexpr void __reinit_expected(in_place_t) {
+    _LIBCPP_ASSERT_INTERNAL(!this->__has_val(), "__reinit_expected(in_place_t, ...) needs value to be unset");
 
+    this->__destroy();
+    this->__construct(in_place);
+  }
+
+public:
+  // [expected.void.assign], assignment
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected&) = delete;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs)
-    noexcept(is_nothrow_copy_assignable_v<_Err> && is_nothrow_copy_constructible_v<_Err>) // strengthened
+  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const expected& __rhs) noexcept(
+      is_nothrow_copy_assignable_v<_Err> && is_nothrow_copy_constructible_v<_Err>) // strengthened
     requires(is_copy_assignable_v<_Err> && is_copy_constructible_v<_Err>)
   {
-    if (__has_val_) {
-      if (!__rhs.__has_val_) {
-        std::construct_at(std::addressof(__union_.__unex_), __rhs.__union_.__unex_);
-        __has_val_ = false;
+    if (this->__has_val()) {
+      if (!__rhs.__has_val()) {
+        __reinit_expected(unexpect, __rhs.__unex());
       }
     } else {
-      if (__rhs.__has_val_) {
-        std::destroy_at(std::addressof(__union_.__unex_));
-        __has_val_ = true;
+      if (__rhs.__has_val()) {
+        __reinit_expected(in_place);
       } else {
-        __union_.__unex_ = __rhs.__union_.__unex_;
+        this->__unex() = __rhs.__unex();
       }
     }
     return *this;
@@ -1115,23 +1494,19 @@ public:
 
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&&) = delete;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(expected&& __rhs)
-    noexcept(is_nothrow_move_assignable_v<_Err> &&
-             is_nothrow_move_constructible_v<_Err>)
-    requires(is_move_assignable_v<_Err> &&
-             is_move_constructible_v<_Err>)
+  _LIBCPP_HIDE_FROM_ABI constexpr expected&
+  operator=(expected&& __rhs) noexcept(is_nothrow_move_assignable_v<_Err> && is_nothrow_move_constructible_v<_Err>)
+    requires(is_move_assignable_v<_Err> && is_move_constructible_v<_Err>)
   {
-    if (__has_val_) {
-      if (!__rhs.__has_val_) {
-        std::construct_at(std::addressof(__union_.__unex_), std::move(__rhs.__union_.__unex_));
-        __has_val_ = false;
+    if (this->__has_val()) {
+      if (!__rhs.__has_val()) {
+        __reinit_expected(unexpect, std::move(__rhs.__unex()));
       }
     } else {
-      if (__rhs.__has_val_) {
-        std::destroy_at(std::addressof(__union_.__unex_));
-        __has_val_ = true;
+      if (__rhs.__has_val()) {
+        __reinit_expected(in_place);
       } else {
-        __union_.__unex_ = std::move(__rhs.__union_.__unex_);
+        this->__unex() = std::move(__rhs.__unex());
       }
     }
     return *this;
@@ -1140,11 +1515,10 @@ public:
   template <class _OtherErr>
     requires(is_constructible_v<_Err, const _OtherErr&> && is_assignable_v<_Err&, const _OtherErr&>)
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(const unexpected<_OtherErr>& __un) {
-    if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), __un.error());
-      __has_val_ = false;
+    if (this->__has_val()) {
+      __reinit_expected(unexpect, __un.error());
     } else {
-      __union_.__unex_ = __un.error();
+      this->__unex() = __un.error();
     }
     return *this;
   }
@@ -1152,94 +1526,98 @@ public:
   template <class _OtherErr>
     requires(is_constructible_v<_Err, _OtherErr> && is_assignable_v<_Err&, _OtherErr>)
   _LIBCPP_HIDE_FROM_ABI constexpr expected& operator=(unexpected<_OtherErr>&& __un) {
-    if (__has_val_) {
-      std::construct_at(std::addressof(__union_.__unex_), std::move(__un.error()));
-      __has_val_ = false;
+    if (this->__has_val()) {
+      __reinit_expected(unexpect, std::move(__un.error()));
     } else {
-      __union_.__unex_ = std::move(__un.error());
+      this->__unex() = std::move(__un.error());
     }
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr void emplace() noexcept {
-    if (!__has_val_) {
-      std::destroy_at(std::addressof(__union_.__unex_));
-      __has_val_ = true;
+    if (!this->__has_val()) {
+      __reinit_expected(in_place);
     }
   }
 
   // [expected.void.swap], swap
-  _LIBCPP_HIDE_FROM_ABI constexpr void swap(expected& __rhs)
-    noexcept(is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>)
+  _LIBCPP_HIDE_FROM_ABI constexpr void
+  swap(expected& __rhs) noexcept(is_nothrow_move_constructible_v<_Err> && is_nothrow_swappable_v<_Err>)
     requires(is_swappable_v<_Err> && is_move_constructible_v<_Err>)
   {
-    auto __swap_val_unex_impl = [&](expected& __with_val, expected& __with_err) {
-      std::construct_at(std::addressof(__with_val.__union_.__unex_), std::move(__with_err.__union_.__unex_));
-      std::destroy_at(std::addressof(__with_err.__union_.__unex_));
-      __with_val.__has_val_ = false;
-      __with_err.__has_val_ = true;
+    auto __swap_val_unex_impl = [](expected& __with_val, expected& __with_err) {
+      // May throw, but will re-engage `__with_val` in that case.
+      __with_val.__reinit_expected(unexpect, std::move(__with_err.__unex()));
+      // Will not throw.
+      __with_err.__reinit_expected(in_place);
     };
 
-    if (__has_val_) {
-      if (!__rhs.__has_val_) {
+    if (this->__has_val()) {
+      if (!__rhs.__has_val()) {
         __swap_val_unex_impl(*this, __rhs);
       }
     } else {
-      if (__rhs.__has_val_) {
+      if (__rhs.__has_val()) {
         __swap_val_unex_impl(__rhs, *this);
       } else {
         using std::swap;
-        swap(__union_.__unex_, __rhs.__union_.__unex_);
+        swap(this->__unex(), __rhs.__unex());
       }
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y)
-    noexcept(noexcept(__x.swap(__y)))
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(expected& __x, expected& __y) noexcept(noexcept(__x.swap(__y)))
     requires requires { __x.swap(__y); }
   {
     __x.swap(__y);
   }
 
   // [expected.void.obs], observers
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __has_val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return this->__has_val(); }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __has_val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return this->__has_val(); }
 
   _LIBCPP_HIDE_FROM_ABI constexpr void operator*() const noexcept {
-    _LIBCPP_ASSERT(__has_val_, "expected::operator* requires the expected to contain a value");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        this->__has_val(), "expected::operator* requires the expected to contain a value");
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr void value() const& {
-    if (!__has_val_) {
-      std::__throw_bad_expected_access<_Err>(__union_.__unex_);
+    static_assert(is_copy_constructible_v<_Err>);
+    if (!this->__has_val()) {
+      std::__throw_bad_expected_access<_Err>(this->__unex());
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr void value() && {
-    if (!__has_val_) {
-      std::__throw_bad_expected_access<_Err>(std::move(__union_.__unex_));
+    static_assert(is_copy_constructible_v<_Err> && is_move_constructible_v<_Err>);
+    if (!this->__has_val()) {
+      std::__throw_bad_expected_access<_Err>(std::move(this->__unex()));
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept {
-    _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return __union_.__unex_;
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !this->__has_val(), "expected::error requires the expected to contain an error");
+    return this->__unex();
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept {
-    _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return __union_.__unex_;
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !this->__has_val(), "expected::error requires the expected to contain an error");
+    return this->__unex();
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept {
-    _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return std::move(__union_.__unex_);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !this->__has_val(), "expected::error requires the expected to contain an error");
+    return std::move(this->__unex());
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept {
-    _LIBCPP_ASSERT(!__has_val_, "expected::error requires the expected to contain an error");
-    return std::move(__union_.__unex_);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !this->__has_val(), "expected::error requires the expected to contain an error");
+    return std::move(this->__unex());
   }
 
   template <class _Up = _Err>
@@ -1342,8 +1720,8 @@ public:
   template <class _Func>
   _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) && {
     using _Gp = remove_cvref_t<invoke_result_t<_Func, _Err&&>>;
-    static_assert(__is_std_expected<_Gp>::value,
-                  "The result of f(std::move(error())) must be a specialization of std::expected");
+    static_assert(
+        __is_std_expected<_Gp>::value, "The result of f(std::move(error())) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Gp::value_type, _Tp>,
                   "The result of f(std::move(error())) must have the same value_type as this expected");
     if (has_value()) {
@@ -1355,8 +1733,8 @@ public:
   template <class _Func>
   _LIBCPP_HIDE_FROM_ABI constexpr auto or_else(_Func&& __f) const&& {
     using _Gp = remove_cvref_t<invoke_result_t<_Func, const _Err&&>>;
-    static_assert(__is_std_expected<_Gp>::value,
-                  "The result of f(std::move(error())) must be a specialization of std::expected");
+    static_assert(
+        __is_std_expected<_Gp>::value, "The result of f(std::move(error())) must be a specialization of std::expected");
     static_assert(is_same_v<typename _Gp::value_type, _Tp>,
                   "The result of f(std::move(error())) must have the same value_type as this expected");
     if (has_value()) {
@@ -1475,74 +1853,23 @@ public:
   template <class _T2, class _E2>
     requires is_void_v<_T2>
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const expected<_T2, _E2>& __y) {
-    if (__x.__has_val_ != __y.__has_val_) {
+    if (__x.__has_val() != __y.__has_val()) {
       return false;
     } else {
-      return __x.__has_val_ || static_cast<bool>(__x.__union_.__unex_ == __y.__union_.__unex_);
+      return __x.__has_val() || static_cast<bool>(__x.__unex() == __y.__unex());
     }
   }
 
   template <class _E2>
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const expected& __x, const unexpected<_E2>& __y) {
-    return !__x.__has_val_ && static_cast<bool>(__x.__union_.__unex_ == __y.error());
+    return !__x.__has_val() && static_cast<bool>(__x.__unex() == __y.error());
   }
-
-private:
-  struct __empty_t {};
-
-  template <class _ErrorType>
-  union __union_t {
-    _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
-
-    template <class _Func, class... _Args>
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
-        __expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
-        : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
-
-    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
-      requires(is_trivially_destructible_v<_ErrorType>)
-    = default;
-
-    // the expected's destructor handles this
-    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t() {}
-
-    __empty_t __empty_;
-    _ErrorType __unex_;
-  };
-
-  // use named union because [[no_unique_address]] cannot be applied to an unnamed union,
-  // also guaranteed elision into a potentially-overlapping subobject is unsettled (and
-  // it's not clear that it's implementable, given that the function is allowed to clobber
-  // the tail padding) - see https://github.com/itanium-cxx-abi/cxx-abi/issues/107.
-  template <class _ErrorType>
-    requires is_trivially_move_constructible_v<_ErrorType>
-  union __union_t<_ErrorType> {
-    _LIBCPP_HIDE_FROM_ABI constexpr __union_t() : __empty_() {}
-
-    template <class _Func, class... _Args>
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit __union_t(
-        __expected_construct_unexpected_from_invoke_tag, _Func&& __f, _Args&&... __args)
-        : __unex_(std::invoke(std::forward<_Func>(__f), std::forward<_Args>(__args)...)) {}
-
-    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
-      requires(is_trivially_destructible_v<_ErrorType>)
-    = default;
-
-    // the expected's destructor handles this
-    _LIBCPP_HIDE_FROM_ABI constexpr ~__union_t()
-      requires(!is_trivially_destructible_v<_ErrorType>)
-    {}
-
-    _LIBCPP_NO_UNIQUE_ADDRESS __empty_t __empty_;
-    _LIBCPP_NO_UNIQUE_ADDRESS _ErrorType __unex_;
-  };
-
-  _LIBCPP_NO_UNIQUE_ADDRESS __union_t<_Err> __union_;
-  bool __has_val_;
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 23
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___EXPECTED_EXPECTED_H
diff --git a/third_party/libcxx/__expected/unexpected.h b/third_party/libcxx/__expected/unexpected.h
index 075963a84..c7fe3c52e 100644
--- a/third_party/libcxx/__expected/unexpected.h
+++ b/third_party/libcxx/__expected/unexpected.h
@@ -31,6 +31,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 23
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -119,4 +122,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 23
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___EXPECTED_UNEXPECTED_H
diff --git a/third_party/libcxx/__filesystem/copy_options.h b/third_party/libcxx/__filesystem/copy_options.h
index 96c753581..097eebe61 100644
--- a/third_party/libcxx/__filesystem/copy_options.h
+++ b/third_party/libcxx/__filesystem/copy_options.h
@@ -10,75 +10,60 @@
 #ifndef _LIBCPP___FILESYSTEM_COPY_OPTIONS_H
 #define _LIBCPP___FILESYSTEM_COPY_OPTIONS_H
 
-#include <__availability>
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
-
-enum class _LIBCPP_ENUM_VIS copy_options : unsigned short {
-  none = 0,
-  skip_existing = 1,
-  overwrite_existing = 2,
-  update_existing = 4,
-  recursive = 8,
-  copy_symlinks = 16,
-  skip_symlinks = 32,
-  directories_only = 64,
-  create_symlinks = 128,
-  create_hard_links = 256,
+enum class copy_options : unsigned short {
+  none                = 0,
+  skip_existing       = 1,
+  overwrite_existing  = 2,
+  update_existing     = 4,
+  recursive           = 8,
+  copy_symlinks       = 16,
+  skip_symlinks       = 32,
+  directories_only    = 64,
+  create_symlinks     = 128,
+  create_hard_links   = 256,
   __in_recursive_copy = 512,
 };
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr copy_options operator&(copy_options __lhs, copy_options __rhs) {
-  return static_cast<copy_options>(static_cast<unsigned short>(__lhs) &
-                                   static_cast<unsigned short>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator&(copy_options __lhs, copy_options __rhs) {
+  return static_cast<copy_options>(static_cast<unsigned short>(__lhs) & static_cast<unsigned short>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr copy_options operator|(copy_options __lhs, copy_options __rhs) {
-  return static_cast<copy_options>(static_cast<unsigned short>(__lhs) |
-                                   static_cast<unsigned short>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator|(copy_options __lhs, copy_options __rhs) {
+  return static_cast<copy_options>(static_cast<unsigned short>(__lhs) | static_cast<unsigned short>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr copy_options operator^(copy_options __lhs, copy_options __rhs) {
-  return static_cast<copy_options>(static_cast<unsigned short>(__lhs) ^
-                                   static_cast<unsigned short>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator^(copy_options __lhs, copy_options __rhs) {
+  return static_cast<copy_options>(static_cast<unsigned short>(__lhs) ^ static_cast<unsigned short>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr copy_options operator~(copy_options __lhs) {
+_LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator~(copy_options __lhs) {
   return static_cast<copy_options>(~static_cast<unsigned short>(__lhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline copy_options& operator&=(copy_options& __lhs, copy_options __rhs) {
+_LIBCPP_HIDE_FROM_ABI inline copy_options& operator&=(copy_options& __lhs, copy_options __rhs) {
   return __lhs = __lhs & __rhs;
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline copy_options& operator|=(copy_options& __lhs, copy_options __rhs) {
+_LIBCPP_HIDE_FROM_ABI inline copy_options& operator|=(copy_options& __lhs, copy_options __rhs) {
   return __lhs = __lhs | __rhs;
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline copy_options& operator^=(copy_options& __lhs, copy_options __rhs) {
+_LIBCPP_HIDE_FROM_ABI inline copy_options& operator^=(copy_options& __lhs, copy_options __rhs) {
   return __lhs = __lhs ^ __rhs;
 }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_COPY_OPTIONS_H
diff --git a/third_party/libcxx/__filesystem/directory_entry.h b/third_party/libcxx/__filesystem/directory_entry.h
index bd9dbdc76..96d88dcd9 100644
--- a/third_party/libcxx/__filesystem/directory_entry.h
+++ b/third_party/libcxx/__filesystem/directory_entry.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___FILESYSTEM_DIRECTORY_ENTRY_H
 #define _LIBCPP___FILESYSTEM_DIRECTORY_ENTRY_H
 
-#include <__availability>
 #include <__chrono/time_point.h>
 #include <__compare/ordering.h>
 #include <__config>
@@ -26,7 +25,6 @@
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <cstdint>
-#include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -35,231 +33,160 @@
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
-
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
 class directory_entry {
-  typedef _VSTD_FS::path _Path;
+  typedef filesystem::path _Path;
 
 public:
   // constructors and destructors
-  _LIBCPP_HIDE_FROM_ABI directory_entry() noexcept = default;
-  _LIBCPP_HIDE_FROM_ABI directory_entry(directory_entry const&) = default;
+  _LIBCPP_HIDE_FROM_ABI directory_entry() noexcept                  = default;
+  _LIBCPP_HIDE_FROM_ABI directory_entry(directory_entry const&)     = default;
   _LIBCPP_HIDE_FROM_ABI directory_entry(directory_entry&&) noexcept = default;
 
-  _LIBCPP_INLINE_VISIBILITY
-  explicit directory_entry(_Path const& __p) : __p_(__p) {
+  _LIBCPP_HIDE_FROM_ABI explicit directory_entry(_Path const& __p) : __p_(__p) {
     error_code __ec;
     __refresh(&__ec);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  directory_entry(_Path const& __p, error_code& __ec) : __p_(__p) {
-    __refresh(&__ec);
-  }
+  _LIBCPP_HIDE_FROM_ABI directory_entry(_Path const& __p, error_code& __ec) : __p_(__p) { __refresh(&__ec); }
 
   _LIBCPP_HIDE_FROM_ABI ~directory_entry() {}
 
-  _LIBCPP_HIDE_FROM_ABI directory_entry& operator=(directory_entry const&) = default;
+  _LIBCPP_HIDE_FROM_ABI directory_entry& operator=(directory_entry const&)     = default;
   _LIBCPP_HIDE_FROM_ABI directory_entry& operator=(directory_entry&&) noexcept = default;
 
-  _LIBCPP_INLINE_VISIBILITY
-  void assign(_Path const& __p) {
+  _LIBCPP_HIDE_FROM_ABI void assign(_Path const& __p) {
     __p_ = __p;
     error_code __ec;
     __refresh(&__ec);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void assign(_Path const& __p, error_code& __ec) {
+  _LIBCPP_HIDE_FROM_ABI void assign(_Path const& __p, error_code& __ec) {
     __p_ = __p;
     __refresh(&__ec);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void replace_filename(_Path const& __p) {
+  _LIBCPP_HIDE_FROM_ABI void replace_filename(_Path const& __p) {
     __p_.replace_filename(__p);
     error_code __ec;
     __refresh(&__ec);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void replace_filename(_Path const& __p, error_code& __ec) {
+  _LIBCPP_HIDE_FROM_ABI void replace_filename(_Path const& __p, error_code& __ec) {
     __p_ = __p_.parent_path() / __p;
     __refresh(&__ec);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void refresh() { __refresh(); }
+  _LIBCPP_HIDE_FROM_ABI void refresh() { __refresh(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void refresh(error_code& __ec) noexcept { __refresh(&__ec); }
+  _LIBCPP_HIDE_FROM_ABI void refresh(error_code& __ec) noexcept { __refresh(&__ec); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  _Path const& path() const noexcept { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI _Path const& path() const noexcept { return __p_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  operator const _Path&() const noexcept { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI operator const _Path&() const noexcept { return __p_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool exists() const { return _VSTD_FS::exists(file_status{__get_ft()}); }
+  _LIBCPP_HIDE_FROM_ABI bool exists() const { return filesystem::exists(file_status{__get_ft()}); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool exists(error_code& __ec) const noexcept {
-    return _VSTD_FS::exists(file_status{__get_ft(&__ec)});
+  _LIBCPP_HIDE_FROM_ABI bool exists(error_code& __ec) const noexcept {
+    return filesystem::exists(file_status{__get_ft(&__ec)});
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_block_file() const { return __get_ft() == file_type::block; }
+  _LIBCPP_HIDE_FROM_ABI bool is_block_file() const { return __get_ft() == file_type::block; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_block_file(error_code& __ec) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI bool is_block_file(error_code& __ec) const noexcept {
     return __get_ft(&__ec) == file_type::block;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_character_file() const { return __get_ft() == file_type::character; }
+  _LIBCPP_HIDE_FROM_ABI bool is_character_file() const { return __get_ft() == file_type::character; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_character_file(error_code& __ec) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI bool is_character_file(error_code& __ec) const noexcept {
     return __get_ft(&__ec) == file_type::character;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_directory() const { return __get_ft() == file_type::directory; }
+  _LIBCPP_HIDE_FROM_ABI bool is_directory() const { return __get_ft() == file_type::directory; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_directory(error_code& __ec) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI bool is_directory(error_code& __ec) const noexcept {
     return __get_ft(&__ec) == file_type::directory;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_fifo() const { return __get_ft() == file_type::fifo; }
+  _LIBCPP_HIDE_FROM_ABI bool is_fifo() const { return __get_ft() == file_type::fifo; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_fifo(error_code& __ec) const noexcept {
-    return __get_ft(&__ec) == file_type::fifo;
+  _LIBCPP_HIDE_FROM_ABI bool is_fifo(error_code& __ec) const noexcept { return __get_ft(&__ec) == file_type::fifo; }
+
+  _LIBCPP_HIDE_FROM_ABI bool is_other() const { return filesystem::is_other(file_status{__get_ft()}); }
+
+  _LIBCPP_HIDE_FROM_ABI bool is_other(error_code& __ec) const noexcept {
+    return filesystem::is_other(file_status{__get_ft(&__ec)});
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_other() const { return _VSTD_FS::is_other(file_status{__get_ft()}); }
+  _LIBCPP_HIDE_FROM_ABI bool is_regular_file() const { return __get_ft() == file_type::regular; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_other(error_code& __ec) const noexcept {
-    return _VSTD_FS::is_other(file_status{__get_ft(&__ec)});
-  }
-
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_regular_file() const { return __get_ft() == file_type::regular; }
-
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_regular_file(error_code& __ec) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI bool is_regular_file(error_code& __ec) const noexcept {
     return __get_ft(&__ec) == file_type::regular;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_socket() const { return __get_ft() == file_type::socket; }
+  _LIBCPP_HIDE_FROM_ABI bool is_socket() const { return __get_ft() == file_type::socket; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_socket(error_code& __ec) const noexcept {
-    return __get_ft(&__ec) == file_type::socket;
-  }
+  _LIBCPP_HIDE_FROM_ABI bool is_socket(error_code& __ec) const noexcept { return __get_ft(&__ec) == file_type::socket; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_symlink() const { return __get_sym_ft() == file_type::symlink; }
+  _LIBCPP_HIDE_FROM_ABI bool is_symlink() const { return __get_sym_ft() == file_type::symlink; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool is_symlink(error_code& __ec) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI bool is_symlink(error_code& __ec) const noexcept {
     return __get_sym_ft(&__ec) == file_type::symlink;
   }
-  _LIBCPP_INLINE_VISIBILITY
-  uintmax_t file_size() const { return __get_size(); }
+  _LIBCPP_HIDE_FROM_ABI uintmax_t file_size() const { return __get_size(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  uintmax_t file_size(error_code& __ec) const noexcept {
-    return __get_size(&__ec);
-  }
+  _LIBCPP_HIDE_FROM_ABI uintmax_t file_size(error_code& __ec) const noexcept { return __get_size(&__ec); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  uintmax_t hard_link_count() const { return __get_nlink(); }
+  _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count() const { return __get_nlink(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  uintmax_t hard_link_count(error_code& __ec) const noexcept {
-    return __get_nlink(&__ec);
-  }
+  _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count(error_code& __ec) const noexcept { return __get_nlink(&__ec); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_time_type last_write_time() const { return __get_write_time(); }
+  _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time() const { return __get_write_time(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_time_type last_write_time(error_code& __ec) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time(error_code& __ec) const noexcept {
     return __get_write_time(&__ec);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_status status() const { return __get_status(); }
+  _LIBCPP_HIDE_FROM_ABI file_status status() const { return __get_status(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_status status(error_code& __ec) const noexcept {
-    return __get_status(&__ec);
-  }
+  _LIBCPP_HIDE_FROM_ABI file_status status(error_code& __ec) const noexcept { return __get_status(&__ec); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_status symlink_status() const { return __get_symlink_status(); }
+  _LIBCPP_HIDE_FROM_ABI file_status symlink_status() const { return __get_symlink_status(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_status symlink_status(error_code& __ec) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI file_status symlink_status(error_code& __ec) const noexcept {
     return __get_symlink_status(&__ec);
   }
 
+  _LIBCPP_HIDE_FROM_ABI bool operator==(directory_entry const& __rhs) const noexcept { return __p_ == __rhs.__p_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool operator==(directory_entry const& __rhs) const noexcept {
-    return __p_ == __rhs.__p_;
-  }
+#  if _LIBCPP_STD_VER <= 17
+  _LIBCPP_HIDE_FROM_ABI bool operator!=(directory_entry const& __rhs) const noexcept { return __p_ != __rhs.__p_; }
 
-#if _LIBCPP_STD_VER <= 17
-  _LIBCPP_INLINE_VISIBILITY
-  bool operator!=(directory_entry const& __rhs) const noexcept {
-    return __p_ != __rhs.__p_;
-  }
+  _LIBCPP_HIDE_FROM_ABI bool operator<(directory_entry const& __rhs) const noexcept { return __p_ < __rhs.__p_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool operator<(directory_entry const& __rhs) const noexcept {
-    return __p_ < __rhs.__p_;
-  }
+  _LIBCPP_HIDE_FROM_ABI bool operator<=(directory_entry const& __rhs) const noexcept { return __p_ <= __rhs.__p_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool operator<=(directory_entry const& __rhs) const noexcept {
-    return __p_ <= __rhs.__p_;
-  }
+  _LIBCPP_HIDE_FROM_ABI bool operator>(directory_entry const& __rhs) const noexcept { return __p_ > __rhs.__p_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool operator>(directory_entry const& __rhs) const noexcept {
-    return __p_ > __rhs.__p_;
-  }
+  _LIBCPP_HIDE_FROM_ABI bool operator>=(directory_entry const& __rhs) const noexcept { return __p_ >= __rhs.__p_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  bool operator>=(directory_entry const& __rhs) const noexcept {
-    return __p_ >= __rhs.__p_;
-  }
+#  else // _LIBCPP_STD_VER <= 17
 
-#else // _LIBCPP_STD_VER <= 17
-
-  _LIBCPP_HIDE_FROM_ABI
-  strong_ordering operator<=>(const directory_entry& __rhs) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(const directory_entry& __rhs) const noexcept {
     return __p_ <=> __rhs.__p_;
   }
 
-#endif // _LIBCPP_STD_VER <= 17
+#  endif // _LIBCPP_STD_VER <= 17
 
   template <class _CharT, class _Traits>
-  _LIBCPP_INLINE_VISIBILITY
-  friend basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const directory_entry& __d) {
+  _LIBCPP_HIDE_FROM_ABI friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const directory_entry& __d) {
     return __os << __d.path();
   }
 
@@ -286,23 +213,20 @@ private:
     file_type __type_;
     _CacheType __cache_type_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __cached_data() noexcept { __reset(); }
+    _LIBCPP_HIDE_FROM_ABI __cached_data() noexcept { __reset(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __reset() {
+    _LIBCPP_HIDE_FROM_ABI void __reset() {
       __cache_type_ = _Empty;
-      __type_ = file_type::none;
+      __type_       = file_type::none;
       __sym_perms_ = __non_sym_perms_ = perms::unknown;
       __size_ = __nlink_ = uintmax_t(-1);
-      __write_time_ = file_time_type::min();
+      __write_time_      = file_time_type::min();
     }
   };
 
-  _LIBCPP_INLINE_VISIBILITY
-  static __cached_data __create_iter_result(file_type __ft) {
+  _LIBCPP_HIDE_FROM_ABI static __cached_data __create_iter_result(file_type __ft) {
     __cached_data __data;
-    __data.__type_ = __ft;
+    __data.__type_       = __ft;
     __data.__cache_type_ = [&]() {
       switch (__ft) {
       case file_type::none:
@@ -316,17 +240,14 @@ private:
     return __data;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void __assign_iter_entry(_Path&& __p, __cached_data __dt) {
-    __p_ = _VSTD::move(__p);
+  _LIBCPP_HIDE_FROM_ABI void __assign_iter_entry(_Path&& __p, __cached_data __dt) {
+    __p_    = std::move(__p);
     __data_ = __dt;
   }
 
-  _LIBCPP_FUNC_VIS
-  error_code __do_refresh() noexcept;
+  _LIBCPP_EXPORTED_FROM_ABI error_code __do_refresh() noexcept;
 
-  _LIBCPP_INLINE_VISIBILITY
-  static bool __is_dne_error(error_code const& __ec) {
+  _LIBCPP_HIDE_FROM_ABI static bool __is_dne_error(error_code const& __ec) {
     if (!__ec)
       return true;
     switch (static_cast<errc>(__ec.value())) {
@@ -338,9 +259,8 @@ private:
     }
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void __handle_error(const char* __msg, error_code* __dest_ec,
-                      error_code const& __ec, bool __allow_dne = false) const {
+  _LIBCPP_HIDE_FROM_ABI void
+  __handle_error(const char* __msg, error_code* __dest_ec, error_code const& __ec, bool __allow_dne = false) const {
     if (__dest_ec) {
       *__dest_ec = __ec;
       return;
@@ -349,14 +269,14 @@ private:
       __throw_filesystem_error(__msg, __p_, __ec);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void __refresh(error_code* __ec = nullptr) {
-    __handle_error("in directory_entry::refresh", __ec, __do_refresh(),
+  _LIBCPP_HIDE_FROM_ABI void __refresh(error_code* __ec = nullptr) {
+    __handle_error("in directory_entry::refresh",
+                   __ec,
+                   __do_refresh(),
                    /*allow_dne*/ true);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_type __get_sym_ft(error_code* __ec = nullptr) const {
+  _LIBCPP_HIDE_FROM_ABI file_type __get_sym_ft(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
       return __symlink_status(__p_, __ec).type();
@@ -369,7 +289,7 @@ private:
     case _IterNonSymlink:
     case _RefreshNonSymlink:
       file_status __st(__data_.__type_);
-      if (__ec && !_VSTD_FS::exists(__st))
+      if (__ec && !filesystem::exists(__st))
         *__ec = make_error_code(errc::no_such_file_or_directory);
       else if (__ec)
         __ec->clear();
@@ -378,8 +298,7 @@ private:
     __libcpp_unreachable();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_type __get_ft(error_code* __ec = nullptr) const {
+  _LIBCPP_HIDE_FROM_ABI file_type __get_ft(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterSymlink:
@@ -389,7 +308,7 @@ private:
     case _RefreshNonSymlink:
     case _RefreshSymlink: {
       file_status __st(__data_.__type_);
-      if (__ec && !_VSTD_FS::exists(__st))
+      if (__ec && !filesystem::exists(__st))
         *__ec = make_error_code(errc::no_such_file_or_directory);
       else if (__ec)
         __ec->clear();
@@ -399,8 +318,7 @@ private:
     __libcpp_unreachable();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_status __get_status(error_code* __ec = nullptr) const {
+  _LIBCPP_HIDE_FROM_ABI file_status __get_status(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
@@ -414,8 +332,7 @@ private:
     __libcpp_unreachable();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_status __get_symlink_status(error_code* __ec = nullptr) const {
+  _LIBCPP_HIDE_FROM_ABI file_status __get_symlink_status(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
@@ -430,24 +347,21 @@ private:
     __libcpp_unreachable();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  uintmax_t __get_size(error_code* __ec = nullptr) const {
+  _LIBCPP_HIDE_FROM_ABI uintmax_t __get_size(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
-      return _VSTD_FS::__file_size(__p_, __ec);
+      return filesystem::__file_size(__p_, __ec);
     case _RefreshSymlink:
     case _RefreshNonSymlink: {
       error_code __m_ec;
       file_status __st(__get_ft(&__m_ec));
       __handle_error("in directory_entry::file_size", __ec, __m_ec);
-      if (_VSTD_FS::exists(__st) && !_VSTD_FS::is_regular_file(__st)) {
-        errc __err_kind = _VSTD_FS::is_directory(__st) ? errc::is_a_directory
-                                                       : errc::not_supported;
-        __handle_error("in directory_entry::file_size", __ec,
-                       make_error_code(__err_kind));
+      if (filesystem::exists(__st) && !filesystem::is_regular_file(__st)) {
+        errc __err_kind = filesystem::is_directory(__st) ? errc::is_a_directory : errc::not_supported;
+        __handle_error("in directory_entry::file_size", __ec, make_error_code(__err_kind));
       }
       return __data_.__size_;
     }
@@ -455,14 +369,13 @@ private:
     __libcpp_unreachable();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  uintmax_t __get_nlink(error_code* __ec = nullptr) const {
+  _LIBCPP_HIDE_FROM_ABI uintmax_t __get_nlink(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
-      return _VSTD_FS::__hard_link_count(__p_, __ec);
+      return filesystem::__hard_link_count(__p_, __ec);
     case _RefreshSymlink:
     case _RefreshNonSymlink: {
       error_code __m_ec;
@@ -474,23 +387,20 @@ private:
     __libcpp_unreachable();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  file_time_type __get_write_time(error_code* __ec = nullptr) const {
+  _LIBCPP_HIDE_FROM_ABI file_time_type __get_write_time(error_code* __ec = nullptr) const {
     switch (__data_.__cache_type_) {
     case _Empty:
     case _IterNonSymlink:
     case _IterSymlink:
     case _RefreshSymlinkUnresolved:
-      return _VSTD_FS::__last_write_time(__p_, __ec);
+      return filesystem::__last_write_time(__p_, __ec);
     case _RefreshSymlink:
     case _RefreshNonSymlink: {
       error_code __m_ec;
       file_status __st(__get_ft(&__m_ec));
       __handle_error("in directory_entry::last_write_time", __ec, __m_ec);
-      if (_VSTD_FS::exists(__st) &&
-          __data_.__write_time_ == file_time_type::min())
-        __handle_error("in directory_entry::last_write_time", __ec,
-                       make_error_code(errc::value_too_large));
+      if (filesystem::exists(__st) && __data_.__write_time_ == file_time_type::min())
+        __handle_error("in directory_entry::last_write_time", __ec, make_error_code(errc::value_too_large));
       return __data_.__write_time_;
     }
     }
@@ -504,24 +414,21 @@ private:
 
 class __dir_element_proxy {
 public:
-  inline _LIBCPP_INLINE_VISIBILITY directory_entry operator*() {
-    return _VSTD::move(__elem_);
-  }
+  inline _LIBCPP_HIDE_FROM_ABI directory_entry operator*() { return std::move(__elem_); }
 
 private:
   friend class directory_iterator;
   friend class recursive_directory_iterator;
   _LIBCPP_HIDE_FROM_ABI explicit __dir_element_proxy(directory_entry const& __e) : __elem_(__e) {}
-  _LIBCPP_HIDE_FROM_ABI __dir_element_proxy(__dir_element_proxy&& __o)
-      : __elem_(_VSTD::move(__o.__elem_)) {}
+  _LIBCPP_HIDE_FROM_ABI __dir_element_proxy(__dir_element_proxy&& __o) : __elem_(std::move(__o.__elem_)) {}
   directory_entry __elem_;
 };
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_POP_MACROS
 
diff --git a/third_party/libcxx/__filesystem/directory_iterator.h b/third_party/libcxx/__filesystem/directory_iterator.h
index d74c8be10..e0246d800 100644
--- a/third_party/libcxx/__filesystem/directory_iterator.h
+++ b/third_party/libcxx/__filesystem/directory_iterator.h
@@ -11,11 +11,11 @@
 #define _LIBCPP___FILESYSTEM_DIRECTORY_ITERATOR_H
 
 #include <__assert>
-#include <__availability>
 #include <__config>
 #include <__filesystem/directory_entry.h>
 #include <__filesystem/directory_options.h>
 #include <__filesystem/path.h>
+#include <__iterator/default_sentinel.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/shared_ptr.h>
 #include <__ranges/enable_borrowed_range.h>
@@ -28,11 +28,14 @@
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
 class _LIBCPP_HIDDEN __dir_stream;
 class directory_iterator {
@@ -44,123 +47,105 @@ public:
   typedef input_iterator_tag iterator_category;
 
 public:
-  //ctor & dtor
-  _LIBCPP_HIDE_FROM_ABI
-  directory_iterator() noexcept {}
+  // ctor & dtor
+  _LIBCPP_HIDE_FROM_ABI directory_iterator() noexcept {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  explicit directory_iterator(const path& __p)
-      : directory_iterator(__p, nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI explicit directory_iterator(const path& __p) : directory_iterator(__p, nullptr) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  directory_iterator(const path& __p, directory_options __opts)
+  _LIBCPP_HIDE_FROM_ABI directory_iterator(const path& __p, directory_options __opts)
       : directory_iterator(__p, nullptr, __opts) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  directory_iterator(const path& __p, error_code& __ec)
-      : directory_iterator(__p, &__ec) {}
+  _LIBCPP_HIDE_FROM_ABI directory_iterator(const path& __p, error_code& __ec) : directory_iterator(__p, &__ec) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  directory_iterator(const path& __p, directory_options __opts,
-                     error_code& __ec)
+  _LIBCPP_HIDE_FROM_ABI directory_iterator(const path& __p, directory_options __opts, error_code& __ec)
       : directory_iterator(__p, &__ec, __opts) {}
 
-  _LIBCPP_HIDE_FROM_ABI directory_iterator(const directory_iterator&) = default;
-  _LIBCPP_HIDE_FROM_ABI directory_iterator(directory_iterator&&) = default;
+  _LIBCPP_HIDE_FROM_ABI directory_iterator(const directory_iterator&)            = default;
+  _LIBCPP_HIDE_FROM_ABI directory_iterator(directory_iterator&&)                 = default;
   _LIBCPP_HIDE_FROM_ABI directory_iterator& operator=(const directory_iterator&) = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  directory_iterator& operator=(directory_iterator&& __o) noexcept {
+  _LIBCPP_HIDE_FROM_ABI directory_iterator& operator=(directory_iterator&& __o) noexcept {
     // non-default implementation provided to support self-move assign.
     if (this != &__o) {
-      __imp_ = _VSTD::move(__o.__imp_);
+      __imp_ = std::move(__o.__imp_);
     }
     return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI ~directory_iterator() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  const directory_entry& operator*() const {
-    _LIBCPP_ASSERT(__imp_, "The end iterator cannot be dereferenced");
+  _LIBCPP_HIDE_FROM_ABI const directory_entry& operator*() const {
+    // Note: this check duplicates a check in `__dereference()`.
+    _LIBCPP_ASSERT_NON_NULL(__imp_, "The end iterator cannot be dereferenced");
     return __dereference();
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  const directory_entry* operator->() const { return &**this; }
+  _LIBCPP_HIDE_FROM_ABI const directory_entry* operator->() const { return &**this; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  directory_iterator& operator++() { return __increment(); }
+  _LIBCPP_HIDE_FROM_ABI directory_iterator& operator++() { return __increment(); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  __dir_element_proxy operator++(int) {
+  _LIBCPP_HIDE_FROM_ABI __dir_element_proxy operator++(int) {
     __dir_element_proxy __p(**this);
     __increment();
     return __p;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  directory_iterator& increment(error_code& __ec) { return __increment(&__ec); }
+  _LIBCPP_HIDE_FROM_ABI directory_iterator& increment(error_code& __ec) { return __increment(&__ec); }
+
+#  if _LIBCPP_STD_VER >= 20
+
+  _LIBCPP_HIDE_FROM_ABI bool operator==(default_sentinel_t) const noexcept { return *this == directory_iterator(); }
+
+#  endif
 
 private:
   inline _LIBCPP_HIDE_FROM_ABI friend bool
-  operator==(const directory_iterator& __lhs,
-             const directory_iterator& __rhs) noexcept;
+  operator==(const directory_iterator& __lhs, const directory_iterator& __rhs) noexcept;
 
   // construct the dir_stream
-  _LIBCPP_FUNC_VIS
-  directory_iterator(const path&, error_code*,
-                     directory_options = directory_options::none);
+  _LIBCPP_EXPORTED_FROM_ABI directory_iterator(const path&, error_code*, directory_options = directory_options::none);
 
-  _LIBCPP_FUNC_VIS
-  directory_iterator& __increment(error_code* __ec = nullptr);
+  _LIBCPP_EXPORTED_FROM_ABI directory_iterator& __increment(error_code* __ec = nullptr);
 
-  _LIBCPP_FUNC_VIS
-  const directory_entry& __dereference() const;
+  _LIBCPP_EXPORTED_FROM_ABI const directory_entry& __dereference() const;
 
 private:
   shared_ptr<__dir_stream> __imp_;
 };
 
 inline _LIBCPP_HIDE_FROM_ABI bool
-operator==(const directory_iterator& __lhs,
-           const directory_iterator& __rhs) noexcept {
+operator==(const directory_iterator& __lhs, const directory_iterator& __rhs) noexcept {
   return __lhs.__imp_ == __rhs.__imp_;
 }
 
 inline _LIBCPP_HIDE_FROM_ABI bool
-operator!=(const directory_iterator& __lhs,
-           const directory_iterator& __rhs) noexcept {
+operator!=(const directory_iterator& __lhs, const directory_iterator& __rhs) noexcept {
   return !(__lhs == __rhs);
 }
 
 // enable directory_iterator range-based for statements
-inline _LIBCPP_HIDE_FROM_ABI directory_iterator
-begin(directory_iterator __iter) noexcept {
-  return __iter;
-}
+inline _LIBCPP_HIDE_FROM_ABI directory_iterator begin(directory_iterator __iter) noexcept { return __iter; }
 
-inline _LIBCPP_HIDE_FROM_ABI directory_iterator
-end(directory_iterator) noexcept {
-  return directory_iterator();
-}
+inline _LIBCPP_HIDE_FROM_ABI directory_iterator end(directory_iterator) noexcept { return directory_iterator(); }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
 
 template <>
-_LIBCPP_AVAILABILITY_FILESYSTEM
-inline constexpr bool _VSTD::ranges::enable_borrowed_range<_VSTD_FS::directory_iterator> = true;
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY inline constexpr bool
+    std::ranges::enable_borrowed_range<std::filesystem::directory_iterator> = true;
 
 template <>
-_LIBCPP_AVAILABILITY_FILESYSTEM
-inline constexpr bool _VSTD::ranges::enable_view<_VSTD_FS::directory_iterator> = true;
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY inline constexpr bool
+    std::ranges::enable_view<std::filesystem::directory_iterator> = true;
 
-#endif // _LIBCPP_STD_VER >= 20
+#  endif // _LIBCPP_STD_VER >= 20
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
+
+_LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FILESYSTEM_DIRECTORY_ITERATOR_H
diff --git a/third_party/libcxx/__filesystem/directory_options.h b/third_party/libcxx/__filesystem/directory_options.h
index c5c031a56..d0cd3ebfd 100644
--- a/third_party/libcxx/__filesystem/directory_options.h
+++ b/third_party/libcxx/__filesystem/directory_options.h
@@ -10,73 +10,48 @@
 #ifndef _LIBCPP___FILESYSTEM_DIRECTORY_OPTIONS_H
 #define _LIBCPP___FILESYSTEM_DIRECTORY_OPTIONS_H
 
-#include <__availability>
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
+enum class directory_options : unsigned char { none = 0, follow_directory_symlink = 1, skip_permission_denied = 2 };
 
-enum class _LIBCPP_ENUM_VIS directory_options : unsigned char {
-  none = 0,
-  follow_directory_symlink = 1,
-  skip_permission_denied = 2
-};
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr directory_options operator&(directory_options __lhs,
-                                             directory_options __rhs) {
-  return static_cast<directory_options>(static_cast<unsigned char>(__lhs) &
-                                        static_cast<unsigned char>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr directory_options operator&(directory_options __lhs, directory_options __rhs) {
+  return static_cast<directory_options>(static_cast<unsigned char>(__lhs) & static_cast<unsigned char>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr directory_options operator|(directory_options __lhs,
-                                             directory_options __rhs) {
-  return static_cast<directory_options>(static_cast<unsigned char>(__lhs) |
-                                        static_cast<unsigned char>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr directory_options operator|(directory_options __lhs, directory_options __rhs) {
+  return static_cast<directory_options>(static_cast<unsigned char>(__lhs) | static_cast<unsigned char>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr directory_options operator^(directory_options __lhs,
-                                             directory_options __rhs) {
-  return static_cast<directory_options>(static_cast<unsigned char>(__lhs) ^
-                                        static_cast<unsigned char>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr directory_options operator^(directory_options __lhs, directory_options __rhs) {
+  return static_cast<directory_options>(static_cast<unsigned char>(__lhs) ^ static_cast<unsigned char>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr directory_options operator~(directory_options __lhs) {
+_LIBCPP_HIDE_FROM_ABI inline constexpr directory_options operator~(directory_options __lhs) {
   return static_cast<directory_options>(~static_cast<unsigned char>(__lhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline directory_options& operator&=(directory_options& __lhs,
-                                     directory_options __rhs) {
+_LIBCPP_HIDE_FROM_ABI inline directory_options& operator&=(directory_options& __lhs, directory_options __rhs) {
   return __lhs = __lhs & __rhs;
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline directory_options& operator|=(directory_options& __lhs,
-                                     directory_options __rhs) {
+_LIBCPP_HIDE_FROM_ABI inline directory_options& operator|=(directory_options& __lhs, directory_options __rhs) {
   return __lhs = __lhs | __rhs;
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline directory_options& operator^=(directory_options& __lhs,
-                                     directory_options __rhs) {
+_LIBCPP_HIDE_FROM_ABI inline directory_options& operator^=(directory_options& __lhs, directory_options __rhs) {
   return __lhs = __lhs ^ __rhs;
 }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_DIRECTORY_OPTIONS_H
diff --git a/third_party/libcxx/__filesystem/file_status.h b/third_party/libcxx/__filesystem/file_status.h
index 350b0fcc8..da316c8b0 100644
--- a/third_party/libcxx/__filesystem/file_status.h
+++ b/third_party/libcxx/__filesystem/file_status.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___FILESYSTEM_FILE_STATUS_H
 #define _LIBCPP___FILESYSTEM_FILE_STATUS_H
 
-#include <__availability>
 #include <__config>
 #include <__filesystem/file_type.h>
 #include <__filesystem/perms.h>
@@ -19,54 +18,50 @@
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
-
-class _LIBCPP_TYPE_VIS file_status {
+class _LIBCPP_EXPORTED_FROM_ABI file_status {
 public:
   // constructors
-  _LIBCPP_INLINE_VISIBILITY
-  file_status() noexcept : file_status(file_type::none) {}
-  _LIBCPP_INLINE_VISIBILITY
-  explicit file_status(file_type __ft, perms __prms = perms::unknown) noexcept
-      : __ft_(__ft),
-        __prms_(__prms) {}
+  _LIBCPP_HIDE_FROM_ABI file_status() noexcept : file_status(file_type::none) {}
+  _LIBCPP_HIDE_FROM_ABI explicit file_status(file_type __ft, perms __prms = perms::unknown) noexcept
+      : __ft_(__ft), __prms_(__prms) {}
 
   _LIBCPP_HIDE_FROM_ABI file_status(const file_status&) noexcept = default;
-  _LIBCPP_HIDE_FROM_ABI file_status(file_status&&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI file_status(file_status&&) noexcept      = default;
 
-  _LIBCPP_INLINE_VISIBILITY
-  ~file_status() {}
+  _LIBCPP_HIDE_FROM_ABI ~file_status() {}
 
   _LIBCPP_HIDE_FROM_ABI file_status& operator=(const file_status&) noexcept = default;
-  _LIBCPP_HIDE_FROM_ABI file_status& operator=(file_status&&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI file_status& operator=(file_status&&) noexcept      = default;
 
   // observers
-  _LIBCPP_INLINE_VISIBILITY
-  file_type type() const noexcept { return __ft_; }
+  _LIBCPP_HIDE_FROM_ABI file_type type() const noexcept { return __ft_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  perms permissions() const noexcept { return __prms_; }
+  _LIBCPP_HIDE_FROM_ABI perms permissions() const noexcept { return __prms_; }
 
   // modifiers
-  _LIBCPP_INLINE_VISIBILITY
-  void type(file_type __ft) noexcept { __ft_ = __ft; }
+  _LIBCPP_HIDE_FROM_ABI void type(file_type __ft) noexcept { __ft_ = __ft; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void permissions(perms __p) noexcept { __prms_ = __p; }
+  _LIBCPP_HIDE_FROM_ABI void permissions(perms __p) noexcept { __prms_ = __p; }
+
+#  if _LIBCPP_STD_VER >= 20
+
+  _LIBCPP_HIDE_FROM_ABI friend bool operator==(const file_status& __lhs, const file_status& __rhs) noexcept {
+    return __lhs.type() == __rhs.type() && __lhs.permissions() == __rhs.permissions();
+  }
+
+#  endif
 
 private:
   file_type __ft_;
   perms __prms_;
 };
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_FILE_STATUS_H
diff --git a/third_party/libcxx/__filesystem/file_time_type.h b/third_party/libcxx/__filesystem/file_time_type.h
index 7c4932e60..63e4ae157 100644
--- a/third_party/libcxx/__filesystem/file_time_type.h
+++ b/third_party/libcxx/__filesystem/file_time_type.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___FILESYSTEM_FILE_TIME_TYPE_H
 #define _LIBCPP___FILESYSTEM_FILE_TIME_TYPE_H
 
-#include <__availability>
 #include <__chrono/file_clock.h>
 #include <__chrono/time_point.h>
 #include <__config>
@@ -19,7 +18,7 @@
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
@@ -27,6 +26,6 @@ typedef chrono::time_point<_FilesystemClock> file_time_type;
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_FILE_TIME_TYPE_H
diff --git a/third_party/libcxx/__filesystem/file_type.h b/third_party/libcxx/__filesystem/file_type.h
index c756a05c8..e4ac1dfee 100644
--- a/third_party/libcxx/__filesystem/file_type.h
+++ b/third_party/libcxx/__filesystem/file_type.h
@@ -10,34 +10,33 @@
 #ifndef _LIBCPP___FILESYSTEM_FILE_TYPE_H
 #define _LIBCPP___FILESYSTEM_FILE_TYPE_H
 
-#include <__availability>
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
 // On Windows, the library never identifies files as block, character, fifo
 // or socket.
-enum class _LIBCPP_ENUM_VIS file_type : signed char {
-  none = 0,
+enum class file_type : signed char {
+  none      = 0,
   not_found = -1,
-  regular = 1,
+  regular   = 1,
   directory = 2,
-  symlink = 3,
-  block = 4,
+  symlink   = 3,
+  block     = 4,
   character = 5,
-  fifo = 6,
-  socket = 7,
-  unknown = 8
+  fifo      = 6,
+  socket    = 7,
+  unknown   = 8
 };
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_FILE_TYPE_H
diff --git a/third_party/libcxx/__filesystem/filesystem_error.h b/third_party/libcxx/__filesystem/filesystem_error.h
index d345dab76..80a11e3b1 100644
--- a/third_party/libcxx/__filesystem/filesystem_error.h
+++ b/third_party/libcxx/__filesystem/filesystem_error.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
 #define _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
 
-#include <__availability>
 #include <__config>
 #include <__filesystem/path.h>
 #include <__memory/shared_ptr.h>
@@ -18,62 +17,48 @@
 #include <__system_error/system_error.h>
 #include <__utility/forward.h>
 #include <__verbose_abort>
-#include <iosfwd>
-#include <new>
 #include <string>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-class _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_EXCEPTION_ABI filesystem_error : public system_error {
+class _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_EXPORTED_FROM_ABI filesystem_error : public system_error {
 public:
-  _LIBCPP_INLINE_VISIBILITY
-  filesystem_error(const string& __what, error_code __ec)
-      : system_error(__ec, __what),
-        __storage_(make_shared<_Storage>(path(), path())) {
+  _LIBCPP_HIDE_FROM_ABI filesystem_error(const string& __what, error_code __ec)
+      : system_error(__ec, __what), __storage_(make_shared<_Storage>(path(), path())) {
     __create_what(0);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  filesystem_error(const string& __what, const path& __p1, error_code __ec)
-      : system_error(__ec, __what),
-        __storage_(make_shared<_Storage>(__p1, path())) {
+  _LIBCPP_HIDE_FROM_ABI filesystem_error(const string& __what, const path& __p1, error_code __ec)
+      : system_error(__ec, __what), __storage_(make_shared<_Storage>(__p1, path())) {
     __create_what(1);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  filesystem_error(const string& __what, const path& __p1, const path& __p2,
-                   error_code __ec)
-      : system_error(__ec, __what),
-        __storage_(make_shared<_Storage>(__p1, __p2)) {
+  _LIBCPP_HIDE_FROM_ABI filesystem_error(const string& __what, const path& __p1, const path& __p2, error_code __ec)
+      : system_error(__ec, __what), __storage_(make_shared<_Storage>(__p1, __p2)) {
     __create_what(2);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  const path& path1() const noexcept { return __storage_->__p1_; }
+  _LIBCPP_HIDE_FROM_ABI const path& path1() const noexcept { return __storage_->__p1_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  const path& path2() const noexcept { return __storage_->__p2_; }
+  _LIBCPP_HIDE_FROM_ABI const path& path2() const noexcept { return __storage_->__p2_; }
 
   _LIBCPP_HIDE_FROM_ABI filesystem_error(const filesystem_error&) = default;
   ~filesystem_error() override; // key function
 
   _LIBCPP_HIDE_FROM_ABI_VIRTUAL
-  const char* what() const noexcept override {
-    return __storage_->__what_.c_str();
-  }
+  const char* what() const noexcept override { return __storage_->__what_.c_str(); }
 
   void __create_what(int __num_paths);
 
 private:
   struct _LIBCPP_HIDDEN _Storage {
-    _LIBCPP_INLINE_VISIBILITY
-    _Storage(const path& __p1, const path& __p2) : __p1_(__p1), __p2_(__p2) {}
+    _LIBCPP_HIDE_FROM_ABI _Storage(const path& __p1, const path& __p2) : __p1_(__p1), __p2_(__p2) {}
 
     path __p1_;
     path __p2_;
@@ -82,25 +67,22 @@ private:
   shared_ptr<_Storage> __storage_;
 };
 
-// TODO(ldionne): We need to pop the pragma and push it again after
-//                filesystem_error to work around PR41078.
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
-
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 template <class... _Args>
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-void __throw_filesystem_error(_Args&&... __args) {
-  throw filesystem_error(_VSTD::forward<_Args>(__args)...);
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY void
+__throw_filesystem_error(_Args&&... __args) {
+  throw filesystem_error(std::forward<_Args>(__args)...);
 }
-#else
-void __throw_filesystem_error(_Args&&...) {
-    _LIBCPP_VERBOSE_ABORT("filesystem_error was thrown in -fno-exceptions mode");
+#  else
+template <class... _Args>
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY void
+__throw_filesystem_error(_Args&&...) {
+  _LIBCPP_VERBOSE_ABORT("filesystem_error was thrown in -fno-exceptions mode");
 }
-#endif
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
+#  endif
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_FILESYSTEM_ERROR_H
diff --git a/third_party/libcxx/__filesystem/operations.h b/third_party/libcxx/__filesystem/operations.h
index 6bf58d8a7..f588189ed 100644
--- a/third_party/libcxx/__filesystem/operations.h
+++ b/third_party/libcxx/__filesystem/operations.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___FILESYSTEM_OPERATIONS_H
 #define _LIBCPP___FILESYSTEM_OPERATIONS_H
 
-#include <__availability>
 #include <__chrono/time_point.h>
 #include <__config>
 #include <__filesystem/copy_options.h>
@@ -28,77 +27,130 @@
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
-_LIBCPP_FUNC_VIS path __absolute(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS path __canonical(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS bool __copy_file(const path& __from, const path& __to, copy_options __opt, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS void __copy_symlink(const path& __existing_symlink, const path& __new_symlink, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS void __copy(const path& __from, const path& __to, copy_options __opt, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS bool __create_directories(const path&, error_code* = nullptr);
-_LIBCPP_FUNC_VIS void __create_directory_symlink(const path& __to, const path& __new_symlink, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS bool __create_directory(const path&, error_code* = nullptr);
-_LIBCPP_FUNC_VIS bool __create_directory(const path&, const path& __attributes, error_code* = nullptr);
-_LIBCPP_FUNC_VIS void __create_hard_link(const path& __to, const path& __new_hard_link, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS void __create_symlink(const path& __to, const path& __new_symlink, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS path __current_path(error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS void __current_path(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS bool __equivalent(const path&, const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS file_status __status(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS uintmax_t __file_size(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS file_status __symlink_status(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS file_time_type __last_write_time(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS void __last_write_time(const path&, file_time_type __new_time, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS path __read_symlink(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS uintmax_t __remove_all(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS bool __remove(const path&, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS void __rename(const path& __from, const path& __to, error_code* __ec = nullptr);
-_LIBCPP_FUNC_VIS void __resize_file(const path&, uintmax_t __size, error_code* = nullptr);
-_LIBCPP_FUNC_VIS path __temp_directory_path(error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI path __absolute(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI path __canonical(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI bool
+__copy_file(const path& __from, const path& __to, copy_options __opt, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI void
+__copy_symlink(const path& __existing_symlink, const path& __new_symlink, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI void
+__copy(const path& __from, const path& __to, copy_options __opt, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI bool __create_directories(const path&, error_code* = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI void
+__create_directory_symlink(const path& __to, const path& __new_symlink, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI bool __create_directory(const path&, error_code* = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI bool __create_directory(const path&, const path& __attributes, error_code* = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI void
+__create_hard_link(const path& __to, const path& __new_hard_link, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI void
+__create_symlink(const path& __to, const path& __new_symlink, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI path __current_path(error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI void __current_path(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI bool __equivalent(const path&, const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI file_status __status(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI uintmax_t __file_size(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI file_status __symlink_status(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI file_time_type __last_write_time(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI void __last_write_time(const path&, file_time_type __new_time, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI path __read_symlink(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI uintmax_t __remove_all(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI bool __remove(const path&, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI void __rename(const path& __from, const path& __to, error_code* __ec = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI void __resize_file(const path&, uintmax_t __size, error_code* = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI path __temp_directory_path(error_code* __ec = nullptr);
 
 inline _LIBCPP_HIDE_FROM_ABI path absolute(const path& __p) { return __absolute(__p); }
 inline _LIBCPP_HIDE_FROM_ABI path absolute(const path& __p, error_code& __ec) { return __absolute(__p, &__ec); }
-inline _LIBCPP_HIDE_FROM_ABI path canonical(const path& __p)                   { return __canonical(__p); }
+inline _LIBCPP_HIDE_FROM_ABI path canonical(const path& __p) { return __canonical(__p); }
 inline _LIBCPP_HIDE_FROM_ABI path canonical(const path& __p, error_code& __ec) { return __canonical(__p, &__ec); }
-inline _LIBCPP_HIDE_FROM_ABI bool copy_file(const path& __from, const path& __to) { return __copy_file(__from, __to, copy_options::none); }
-inline _LIBCPP_HIDE_FROM_ABI bool copy_file(const path& __from, const path& __to, error_code& __ec) { return __copy_file(__from, __to, copy_options::none, &__ec); }
-inline _LIBCPP_HIDE_FROM_ABI bool copy_file(const path& __from, const path& __to, copy_options __opt) { return __copy_file(__from, __to, __opt); }
-inline _LIBCPP_HIDE_FROM_ABI bool copy_file(const path& __from, const path& __to, copy_options __opt, error_code& __ec) { return __copy_file(__from, __to, __opt, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI bool copy_file(const path& __from, const path& __to) {
+  return __copy_file(__from, __to, copy_options::none);
+}
+inline _LIBCPP_HIDE_FROM_ABI bool copy_file(const path& __from, const path& __to, error_code& __ec) {
+  return __copy_file(__from, __to, copy_options::none, &__ec);
+}
+inline _LIBCPP_HIDE_FROM_ABI bool copy_file(const path& __from, const path& __to, copy_options __opt) {
+  return __copy_file(__from, __to, __opt);
+}
+inline _LIBCPP_HIDE_FROM_ABI bool
+copy_file(const path& __from, const path& __to, copy_options __opt, error_code& __ec) {
+  return __copy_file(__from, __to, __opt, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI void copy_symlink(const path& __from, const path& __to) { __copy_symlink(__from, __to); }
-inline _LIBCPP_HIDE_FROM_ABI void copy_symlink(const path& __from, const path& __to, error_code& __ec) noexcept { __copy_symlink(__from, __to, &__ec); }
-inline _LIBCPP_HIDE_FROM_ABI void copy(const path& __from, const path& __to) { __copy(__from, __to, copy_options::none); }
-inline _LIBCPP_HIDE_FROM_ABI void copy(const path& __from, const path& __to, error_code& __ec) { __copy(__from, __to, copy_options::none, &__ec); }
-inline _LIBCPP_HIDE_FROM_ABI void copy(const path& __from, const path& __to, copy_options __opt) { __copy(__from, __to, __opt); }
-inline _LIBCPP_HIDE_FROM_ABI void copy(const path& __from, const path& __to, copy_options __opt, error_code& __ec) { __copy(__from, __to, __opt, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI void copy_symlink(const path& __from, const path& __to, error_code& __ec) noexcept {
+  __copy_symlink(__from, __to, &__ec);
+}
+inline _LIBCPP_HIDE_FROM_ABI void copy(const path& __from, const path& __to) {
+  __copy(__from, __to, copy_options::none);
+}
+inline _LIBCPP_HIDE_FROM_ABI void copy(const path& __from, const path& __to, error_code& __ec) {
+  __copy(__from, __to, copy_options::none, &__ec);
+}
+inline _LIBCPP_HIDE_FROM_ABI void copy(const path& __from, const path& __to, copy_options __opt) {
+  __copy(__from, __to, __opt);
+}
+inline _LIBCPP_HIDE_FROM_ABI void copy(const path& __from, const path& __to, copy_options __opt, error_code& __ec) {
+  __copy(__from, __to, __opt, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI bool create_directories(const path& __p) { return __create_directories(__p); }
-inline _LIBCPP_HIDE_FROM_ABI bool create_directories(const path& __p, error_code& __ec) { return __create_directories(__p, &__ec); }
-inline _LIBCPP_HIDE_FROM_ABI void create_directory_symlink(const path& __target, const path& __link) { __create_directory_symlink(__target, __link); }
-inline _LIBCPP_HIDE_FROM_ABI void create_directory_symlink(const path& __target, const path& __link, error_code& __ec) noexcept { __create_directory_symlink(__target, __link, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI bool create_directories(const path& __p, error_code& __ec) {
+  return __create_directories(__p, &__ec);
+}
+inline _LIBCPP_HIDE_FROM_ABI void create_directory_symlink(const path& __target, const path& __link) {
+  __create_directory_symlink(__target, __link);
+}
+inline _LIBCPP_HIDE_FROM_ABI void
+create_directory_symlink(const path& __target, const path& __link, error_code& __ec) noexcept {
+  __create_directory_symlink(__target, __link, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI bool create_directory(const path& __p) { return __create_directory(__p); }
-inline _LIBCPP_HIDE_FROM_ABI bool create_directory(const path& __p, error_code& __ec) noexcept { return __create_directory(__p, &__ec); }
-inline _LIBCPP_HIDE_FROM_ABI bool create_directory(const path& __p, const path& __attrs) { return __create_directory(__p, __attrs); }
-inline _LIBCPP_HIDE_FROM_ABI bool create_directory(const path& __p, const path& __attrs, error_code& __ec) noexcept { return __create_directory(__p, __attrs, &__ec); }
-inline _LIBCPP_HIDE_FROM_ABI void create_hard_link(const path& __target, const path& __link) { __create_hard_link(__target, __link); }
-inline _LIBCPP_HIDE_FROM_ABI void create_hard_link(const path& __target, const path& __link, error_code& __ec) noexcept { __create_hard_link(__target, __link, &__ec); }
-inline _LIBCPP_HIDE_FROM_ABI void create_symlink(const path& __target, const path& __link) { __create_symlink(__target, __link); }
-inline _LIBCPP_HIDE_FROM_ABI void create_symlink(const path& __target, const path& __link, error_code& __ec) noexcept { return __create_symlink(__target, __link, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI bool create_directory(const path& __p, error_code& __ec) noexcept {
+  return __create_directory(__p, &__ec);
+}
+inline _LIBCPP_HIDE_FROM_ABI bool create_directory(const path& __p, const path& __attrs) {
+  return __create_directory(__p, __attrs);
+}
+inline _LIBCPP_HIDE_FROM_ABI bool create_directory(const path& __p, const path& __attrs, error_code& __ec) noexcept {
+  return __create_directory(__p, __attrs, &__ec);
+}
+inline _LIBCPP_HIDE_FROM_ABI void create_hard_link(const path& __target, const path& __link) {
+  __create_hard_link(__target, __link);
+}
+inline _LIBCPP_HIDE_FROM_ABI void
+create_hard_link(const path& __target, const path& __link, error_code& __ec) noexcept {
+  __create_hard_link(__target, __link, &__ec);
+}
+inline _LIBCPP_HIDE_FROM_ABI void create_symlink(const path& __target, const path& __link) {
+  __create_symlink(__target, __link);
+}
+inline _LIBCPP_HIDE_FROM_ABI void create_symlink(const path& __target, const path& __link, error_code& __ec) noexcept {
+  return __create_symlink(__target, __link, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI path current_path() { return __current_path(); }
 inline _LIBCPP_HIDE_FROM_ABI path current_path(error_code& __ec) { return __current_path(&__ec); }
 inline _LIBCPP_HIDE_FROM_ABI void current_path(const path& __p) { __current_path(__p); }
-inline _LIBCPP_HIDE_FROM_ABI void current_path(const path& __p, error_code& __ec) noexcept { __current_path(__p, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI void current_path(const path& __p, error_code& __ec) noexcept {
+  __current_path(__p, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI bool equivalent(const path& __p1, const path& __p2) { return __equivalent(__p1, __p2); }
-inline _LIBCPP_HIDE_FROM_ABI bool equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept { return __equivalent(__p1, __p2, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI bool equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept {
+  return __equivalent(__p1, __p2, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI bool status_known(file_status __s) noexcept { return __s.type() != file_type::none; }
-inline _LIBCPP_HIDE_FROM_ABI bool exists(file_status __s) noexcept { return status_known(__s) && __s.type() != file_type::not_found; }
+inline _LIBCPP_HIDE_FROM_ABI bool exists(file_status __s) noexcept {
+  return status_known(__s) && __s.type() != file_type::not_found;
+}
 inline _LIBCPP_HIDE_FROM_ABI bool exists(const path& __p) { return exists(__status(__p)); }
 
-inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p, error_code& __ec) noexcept {
+inline _LIBCPP_HIDE_FROM_ABI bool exists(const path& __p, error_code& __ec) noexcept {
   auto __s = __status(__p, &__ec);
   if (status_known(__s))
     __ec.clear();
@@ -106,46 +158,81 @@ inline _LIBCPP_INLINE_VISIBILITY bool exists(const path& __p, error_code& __ec)
 }
 
 inline _LIBCPP_HIDE_FROM_ABI uintmax_t file_size(const path& __p) { return __file_size(__p); }
-inline _LIBCPP_HIDE_FROM_ABI uintmax_t file_size(const path& __p, error_code& __ec) noexcept { return __file_size(__p, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI uintmax_t file_size(const path& __p, error_code& __ec) noexcept {
+  return __file_size(__p, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count(const path& __p) { return __hard_link_count(__p); }
-inline _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count(const path& __p, error_code& __ec) noexcept { return __hard_link_count(__p, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count(const path& __p, error_code& __ec) noexcept {
+  return __hard_link_count(__p, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(file_status __s) noexcept { return __s.type() == file_type::block; }
 inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(const path& __p) { return is_block_file(__status(__p)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(const path& __p, error_code& __ec) noexcept { return is_block_file(__status(__p, &__ec)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(file_status __s) noexcept { return __s.type() == file_type::character; }
+inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(const path& __p, error_code& __ec) noexcept {
+  return is_block_file(__status(__p, &__ec));
+}
+inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(file_status __s) noexcept {
+  return __s.type() == file_type::character;
+}
 inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(const path& __p) { return is_character_file(__status(__p)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(const path& __p, error_code& __ec) noexcept { return is_character_file(__status(__p, &__ec)); }
+inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(const path& __p, error_code& __ec) noexcept {
+  return is_character_file(__status(__p, &__ec));
+}
 inline _LIBCPP_HIDE_FROM_ABI bool is_directory(file_status __s) noexcept { return __s.type() == file_type::directory; }
 inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p) { return is_directory(__status(__p)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p, error_code& __ec) noexcept { return is_directory(__status(__p, &__ec)); }
-_LIBCPP_FUNC_VIS bool __fs_is_empty(const path& __p, error_code* __ec = nullptr);
+inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p, error_code& __ec) noexcept {
+  return is_directory(__status(__p, &__ec));
+}
+_LIBCPP_EXPORTED_FROM_ABI bool __fs_is_empty(const path& __p, error_code* __ec = nullptr);
 inline _LIBCPP_HIDE_FROM_ABI bool is_empty(const path& __p) { return __fs_is_empty(__p); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_empty(const path& __p, error_code& __ec) { return __fs_is_empty(__p, &__ec); }
 inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(file_status __s) noexcept { return __s.type() == file_type::fifo; }
 inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(const path& __p) { return is_fifo(__status(__p)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(const path& __p, error_code& __ec) noexcept { return is_fifo(__status(__p, &__ec)); }
+inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(const path& __p, error_code& __ec) noexcept {
+  return is_fifo(__status(__p, &__ec));
+}
 inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(file_status __s) noexcept { return __s.type() == file_type::regular; }
 inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(const path& __p) { return is_regular_file(__status(__p)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(const path& __p, error_code& __ec) noexcept { return is_regular_file(__status(__p, &__ec)); }
+inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(const path& __p, error_code& __ec) noexcept {
+  return is_regular_file(__status(__p, &__ec));
+}
 inline _LIBCPP_HIDE_FROM_ABI bool is_symlink(file_status __s) noexcept { return __s.type() == file_type::symlink; }
 inline _LIBCPP_HIDE_FROM_ABI bool is_symlink(const path& __p) { return is_symlink(__symlink_status(__p)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_symlink(const path& __p, error_code& __ec) noexcept { return is_symlink(__symlink_status(__p, &__ec)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_other(file_status __s) noexcept { return exists(__s) && !is_regular_file(__s) && !is_directory(__s) && !is_symlink(__s); }
+inline _LIBCPP_HIDE_FROM_ABI bool is_symlink(const path& __p, error_code& __ec) noexcept {
+  return is_symlink(__symlink_status(__p, &__ec));
+}
+inline _LIBCPP_HIDE_FROM_ABI bool is_other(file_status __s) noexcept {
+  return exists(__s) && !is_regular_file(__s) && !is_directory(__s) && !is_symlink(__s);
+}
 inline _LIBCPP_HIDE_FROM_ABI bool is_other(const path& __p) { return is_other(__status(__p)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_other(const path& __p, error_code& __ec) noexcept { return is_other(__status(__p, &__ec)); }
+inline _LIBCPP_HIDE_FROM_ABI bool is_other(const path& __p, error_code& __ec) noexcept {
+  return is_other(__status(__p, &__ec));
+}
 inline _LIBCPP_HIDE_FROM_ABI bool is_socket(file_status __s) noexcept { return __s.type() == file_type::socket; }
 inline _LIBCPP_HIDE_FROM_ABI bool is_socket(const path& __p) { return is_socket(__status(__p)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_socket(const path& __p, error_code& __ec) noexcept { return is_socket(__status(__p, &__ec)); }
+inline _LIBCPP_HIDE_FROM_ABI bool is_socket(const path& __p, error_code& __ec) noexcept {
+  return is_socket(__status(__p, &__ec));
+}
 inline _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time(const path& __p) { return __last_write_time(__p); }
-inline _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time(const path& __p, error_code& __ec) noexcept { return __last_write_time(__p, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time(const path& __p, error_code& __ec) noexcept {
+  return __last_write_time(__p, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI void last_write_time(const path& __p, file_time_type __t) { __last_write_time(__p, __t); }
-inline _LIBCPP_HIDE_FROM_ABI void last_write_time(const path& __p, file_time_type __t, error_code& __ec) noexcept { __last_write_time(__p, __t, &__ec); }
-_LIBCPP_FUNC_VIS void __permissions(const path&, perms, perm_options, error_code* = nullptr);
-inline _LIBCPP_HIDE_FROM_ABI void permissions(const path& __p, perms __prms, perm_options __opts = perm_options::replace) { __permissions(__p, __prms, __opts); }
-inline _LIBCPP_HIDE_FROM_ABI void permissions(const path& __p, perms __prms, error_code& __ec) noexcept { __permissions(__p, __prms, perm_options::replace, &__ec); }
-inline _LIBCPP_HIDE_FROM_ABI void permissions(const path& __p, perms __prms, perm_options __opts, error_code& __ec) { __permissions(__p, __prms, __opts, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI void last_write_time(const path& __p, file_time_type __t, error_code& __ec) noexcept {
+  __last_write_time(__p, __t, &__ec);
+}
+_LIBCPP_EXPORTED_FROM_ABI void __permissions(const path&, perms, perm_options, error_code* = nullptr);
+inline _LIBCPP_HIDE_FROM_ABI void
+permissions(const path& __p, perms __prms, perm_options __opts = perm_options::replace) {
+  __permissions(__p, __prms, __opts);
+}
+inline _LIBCPP_HIDE_FROM_ABI void permissions(const path& __p, perms __prms, error_code& __ec) noexcept {
+  __permissions(__p, __prms, perm_options::replace, &__ec);
+}
+inline _LIBCPP_HIDE_FROM_ABI void permissions(const path& __p, perms __prms, perm_options __opts, error_code& __ec) {
+  __permissions(__p, __prms, __opts, &__ec);
+}
 
-inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p, const path& __base, error_code& __ec) {
+inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, const path& __base, error_code& __ec) {
   path __tmp = __weakly_canonical(__p, &__ec);
   if (__ec)
     return {};
@@ -155,12 +242,16 @@ inline _LIBCPP_INLINE_VISIBILITY path proximate(const path& __p, const path& __b
   return __tmp.lexically_proximate(__tmp_base);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, error_code& __ec) { return proximate(__p, current_path(), __ec); }
-inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, const path& __base = current_path()) { return __weakly_canonical(__p).lexically_proximate(__weakly_canonical(__base)); }
+inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, error_code& __ec) {
+  return proximate(__p, current_path(), __ec);
+}
+inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, const path& __base = current_path()) {
+  return __weakly_canonical(__p).lexically_proximate(__weakly_canonical(__base));
+}
 inline _LIBCPP_HIDE_FROM_ABI path read_symlink(const path& __p) { return __read_symlink(__p); }
 inline _LIBCPP_HIDE_FROM_ABI path read_symlink(const path& __p, error_code& __ec) { return __read_symlink(__p, &__ec); }
 
-inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p, const path& __base, error_code& __ec) {
+inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, const path& __base, error_code& __ec) {
   path __tmp = __weakly_canonical(__p, &__ec);
   if (__ec)
     return path();
@@ -170,32 +261,50 @@ inline _LIBCPP_INLINE_VISIBILITY path relative(const path& __p, const path& __ba
   return __tmp.lexically_relative(__tmpbase);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, error_code& __ec) { return relative(__p, current_path(), __ec); }
-inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, const path& __base = current_path()) { return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base)); }
+inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, error_code& __ec) {
+  return relative(__p, current_path(), __ec);
+}
+inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, const path& __base = current_path()) {
+  return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base));
+}
 inline _LIBCPP_HIDE_FROM_ABI uintmax_t remove_all(const path& __p) { return __remove_all(__p); }
-inline _LIBCPP_HIDE_FROM_ABI uintmax_t remove_all(const path& __p, error_code& __ec) { return __remove_all(__p, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI uintmax_t remove_all(const path& __p, error_code& __ec) {
+  return __remove_all(__p, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI bool remove(const path& __p) { return __remove(__p); }
 inline _LIBCPP_HIDE_FROM_ABI bool remove(const path& __p, error_code& __ec) noexcept { return __remove(__p, &__ec); }
 inline _LIBCPP_HIDE_FROM_ABI void rename(const path& __from, const path& __to) { return __rename(__from, __to); }
-inline _LIBCPP_HIDE_FROM_ABI void rename(const path& __from, const path& __to, error_code& __ec) noexcept { return __rename(__from, __to, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI void rename(const path& __from, const path& __to, error_code& __ec) noexcept {
+  return __rename(__from, __to, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI void resize_file(const path& __p, uintmax_t __ns) { return __resize_file(__p, __ns); }
-inline _LIBCPP_HIDE_FROM_ABI void resize_file(const path& __p, uintmax_t __ns, error_code& __ec) noexcept { return __resize_file(__p, __ns, &__ec); }
-_LIBCPP_FUNC_VIS space_info __space(const path&, error_code* __ec = nullptr);
+inline _LIBCPP_HIDE_FROM_ABI void resize_file(const path& __p, uintmax_t __ns, error_code& __ec) noexcept {
+  return __resize_file(__p, __ns, &__ec);
+}
+_LIBCPP_EXPORTED_FROM_ABI space_info __space(const path&, error_code* __ec = nullptr);
 inline _LIBCPP_HIDE_FROM_ABI space_info space(const path& __p) { return __space(__p); }
-inline _LIBCPP_HIDE_FROM_ABI space_info space(const path& __p, error_code& __ec) noexcept { return __space(__p, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI space_info space(const path& __p, error_code& __ec) noexcept {
+  return __space(__p, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI file_status status(const path& __p) { return __status(__p); }
-inline _LIBCPP_HIDE_FROM_ABI file_status status(const path& __p, error_code& __ec) noexcept { return __status(__p, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI file_status status(const path& __p, error_code& __ec) noexcept {
+  return __status(__p, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI file_status symlink_status(const path& __p) { return __symlink_status(__p); }
-inline _LIBCPP_HIDE_FROM_ABI file_status symlink_status(const path& __p, error_code& __ec) noexcept { return __symlink_status(__p, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI file_status symlink_status(const path& __p, error_code& __ec) noexcept {
+  return __symlink_status(__p, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI path temp_directory_path() { return __temp_directory_path(); }
 inline _LIBCPP_HIDE_FROM_ABI path temp_directory_path(error_code& __ec) { return __temp_directory_path(&__ec); }
 inline _LIBCPP_HIDE_FROM_ABI path weakly_canonical(path const& __p) { return __weakly_canonical(__p); }
-inline _LIBCPP_HIDE_FROM_ABI path weakly_canonical(path const& __p, error_code& __ec) { return __weakly_canonical(__p, &__ec); }
+inline _LIBCPP_HIDE_FROM_ABI path weakly_canonical(path const& __p, error_code& __ec) {
+  return __weakly_canonical(__p, &__ec);
+}
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 #endif // _LIBCPP___FILESYSTEM_OPERATIONS_H
diff --git a/third_party/libcxx/__filesystem/path.h b/third_party/libcxx/__filesystem/path.h
index bf36ad9b5..ff468d517 100644
--- a/third_party/libcxx/__filesystem/path.h
+++ b/third_party/libcxx/__filesystem/path.h
@@ -12,10 +12,9 @@
 
 #include <__algorithm/replace.h>
 #include <__algorithm/replace_copy.h>
-#include <__availability>
 #include <__config>
 #include <__functional/unary_function.h>
-#include <__fwd/hash.h>
+#include <__fwd/functional.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__type_traits/decay.h>
@@ -27,19 +26,22 @@
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-# include <iomanip> // for quoted
-# include <locale>
+#  include <iomanip> // for quoted
+#  include <locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
 template <class _Tp>
 struct __can_convert_char {
@@ -50,47 +52,45 @@ struct __can_convert_char<const _Tp> : public __can_convert_char<_Tp> {};
 template <>
 struct __can_convert_char<char> {
   static const bool value = true;
-  using __char_type = char;
+  using __char_type       = char;
 };
 template <>
 struct __can_convert_char<wchar_t> {
   static const bool value = true;
-  using __char_type = wchar_t;
+  using __char_type       = wchar_t;
 };
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
 template <>
 struct __can_convert_char<char8_t> {
   static const bool value = true;
-  using __char_type = char8_t;
+  using __char_type       = char8_t;
 };
-#endif
+#  endif
 template <>
 struct __can_convert_char<char16_t> {
   static const bool value = true;
-  using __char_type = char16_t;
+  using __char_type       = char16_t;
 };
 template <>
 struct __can_convert_char<char32_t> {
   static const bool value = true;
-  using __char_type = char32_t;
+  using __char_type       = char32_t;
 };
 
-template <class _ECharT>
-_LIBCPP_HIDE_FROM_ABI
-typename enable_if<__can_convert_char<_ECharT>::value, bool>::type
-__is_separator(_ECharT __e) {
-#if defined(_LIBCPP_WIN32API)
+template <class _ECharT, __enable_if_t<__can_convert_char<_ECharT>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool __is_separator(_ECharT __e) {
+#  if defined(_LIBCPP_WIN32API)
   return __e == _ECharT('/') || __e == _ECharT('\\');
-#else
+#  else
   return __e == _ECharT('/');
-#endif
+#  endif
 }
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
 typedef u8string __u8_string;
-#else
+#  else
 typedef string __u8_string;
-#endif
+#  endif
 
 struct _NullSentinel {};
 
@@ -101,104 +101,75 @@ template <class _Tp, class = void>
 struct __is_pathable_string : public false_type {};
 
 template <class _ECharT, class _Traits, class _Alloc>
-struct __is_pathable_string<
-    basic_string<_ECharT, _Traits, _Alloc>,
-    _Void<typename __can_convert_char<_ECharT>::__char_type> >
+struct __is_pathable_string< basic_string<_ECharT, _Traits, _Alloc>,
+                             _Void<typename __can_convert_char<_ECharT>::__char_type> >
     : public __can_convert_char<_ECharT> {
   using _Str = basic_string<_ECharT, _Traits, _Alloc>;
-  using _Base = __can_convert_char<_ECharT>;
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
+  _LIBCPP_HIDE_FROM_ABI static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _ECharT const* __range_end(_Str const& __s) {
-    return __s.data() + __s.length();
-  }
+  _LIBCPP_HIDE_FROM_ABI static _ECharT const* __range_end(_Str const& __s) { return __s.data() + __s.length(); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _ECharT __first_or_null(_Str const& __s) {
-    return __s.empty() ? _ECharT{} : __s[0];
-  }
+  _LIBCPP_HIDE_FROM_ABI static _ECharT __first_or_null(_Str const& __s) { return __s.empty() ? _ECharT{} : __s[0]; }
 };
 
 template <class _ECharT, class _Traits>
-struct __is_pathable_string<
-    basic_string_view<_ECharT, _Traits>,
-    _Void<typename __can_convert_char<_ECharT>::__char_type> >
+struct __is_pathable_string< basic_string_view<_ECharT, _Traits>,
+                             _Void<typename __can_convert_char<_ECharT>::__char_type> >
     : public __can_convert_char<_ECharT> {
   using _Str = basic_string_view<_ECharT, _Traits>;
-  using _Base = __can_convert_char<_ECharT>;
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
+  _LIBCPP_HIDE_FROM_ABI static _ECharT const* __range_begin(_Str const& __s) { return __s.data(); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _ECharT const* __range_end(_Str const& __s) {
-    return __s.data() + __s.length();
-  }
+  _LIBCPP_HIDE_FROM_ABI static _ECharT const* __range_end(_Str const& __s) { return __s.data() + __s.length(); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _ECharT __first_or_null(_Str const& __s) {
-    return __s.empty() ? _ECharT{} : __s[0];
-  }
+  _LIBCPP_HIDE_FROM_ABI static _ECharT __first_or_null(_Str const& __s) { return __s.empty() ? _ECharT{} : __s[0]; }
 };
 
-template <class _Source, class _DS = __decay_t<_Source>,
-          class _UnqualPtrType =
-              __remove_const_t<__remove_pointer_t<_DS> >,
-          bool _IsCharPtr = is_pointer<_DS>::value&&
-              __can_convert_char<_UnqualPtrType>::value>
+template <class _Source,
+          class _DS            = __decay_t<_Source>,
+          class _UnqualPtrType = __remove_const_t<__remove_pointer_t<_DS> >,
+          bool _IsCharPtr      = is_pointer<_DS>::value && __can_convert_char<_UnqualPtrType>::value>
 struct __is_pathable_char_array : false_type {};
 
 template <class _Source, class _ECharT, class _UPtr>
-struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true>
-    : __can_convert_char<__remove_const_t<_ECharT> > {
-  using _Base = __can_convert_char<__remove_const_t<_ECharT> >;
+struct __is_pathable_char_array<_Source, _ECharT*, _UPtr, true> : __can_convert_char<__remove_const_t<_ECharT> > {
+  _LIBCPP_HIDE_FROM_ABI static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _ECharT const* __range_begin(const _ECharT* __b) { return __b; }
-
-  _LIBCPP_HIDE_FROM_ABI
-  static _ECharT const* __range_end(const _ECharT* __b) {
-    using _Iter = const _ECharT*;
+  _LIBCPP_HIDE_FROM_ABI static _ECharT const* __range_end(const _ECharT* __b) {
+    using _Iter              = const _ECharT*;
     const _ECharT __sentinel = _ECharT{};
-    _Iter __e = __b;
+    _Iter __e                = __b;
     for (; *__e != __sentinel; ++__e)
       ;
     return __e;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
+  _LIBCPP_HIDE_FROM_ABI static _ECharT __first_or_null(const _ECharT* __b) { return *__b; }
 };
 
-template <class _Iter, bool _IsIt = __has_input_iterator_category<_Iter>::value,
-          class = void>
+template <class _Iter, bool _IsIt = __has_input_iterator_category<_Iter>::value, class = void>
 struct __is_pathable_iter : false_type {};
 
 template <class _Iter>
 struct __is_pathable_iter<
-    _Iter, true,
-    _Void<typename __can_convert_char<
-        typename iterator_traits<_Iter>::value_type>::__char_type> >
+    _Iter,
+    true,
+    _Void<typename __can_convert_char< typename iterator_traits<_Iter>::value_type>::__char_type> >
     : __can_convert_char<typename iterator_traits<_Iter>::value_type> {
   using _ECharT = typename iterator_traits<_Iter>::value_type;
-  using _Base = __can_convert_char<_ECharT>;
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _Iter __range_begin(_Iter __b) { return __b; }
+  _LIBCPP_HIDE_FROM_ABI static _Iter __range_begin(_Iter __b) { return __b; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _NullSentinel __range_end(_Iter) { return _NullSentinel{}; }
+  _LIBCPP_HIDE_FROM_ABI static _NullSentinel __range_end(_Iter) { return _NullSentinel{}; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _ECharT __first_or_null(_Iter __b) { return *__b; }
+  _LIBCPP_HIDE_FROM_ABI static _ECharT __first_or_null(_Iter __b) { return *__b; }
 };
 
-template <class _Tp, bool _IsStringT = __is_pathable_string<_Tp>::value,
+template <class _Tp,
+          bool _IsStringT   = __is_pathable_string<_Tp>::value,
           bool _IsCharIterT = __is_pathable_char_array<_Tp>::value,
-          bool _IsIterT = !_IsCharIterT && __is_pathable_iter<_Tp>::value>
+          bool _IsIterT     = !_IsCharIterT && __is_pathable_iter<_Tp>::value>
 struct __is_pathable : false_type {
   static_assert(!_IsStringT && !_IsCharIterT && !_IsIterT, "Must all be false");
 };
@@ -207,74 +178,64 @@ template <class _Tp>
 struct __is_pathable<_Tp, true, false, false> : __is_pathable_string<_Tp> {};
 
 template <class _Tp>
-struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {
-};
+struct __is_pathable<_Tp, false, true, false> : __is_pathable_char_array<_Tp> {};
 
 template <class _Tp>
 struct __is_pathable<_Tp, false, false, true> : __is_pathable_iter<_Tp> {};
 
-#if defined(_LIBCPP_WIN32API)
+#  if defined(_LIBCPP_WIN32API)
 typedef wstring __path_string;
 typedef wchar_t __path_value;
-#else
+#  else
 typedef string __path_string;
 typedef char __path_value;
-#endif
+#  endif
 
-#if defined(_LIBCPP_WIN32API)
-_LIBCPP_FUNC_VIS
-size_t __wide_to_char(const wstring&, char*, size_t);
-_LIBCPP_FUNC_VIS
-size_t __char_to_wide(const string&, wchar_t*, size_t);
-#endif
+#  if defined(_LIBCPP_WIN32API)
+_LIBCPP_EXPORTED_FROM_ABI size_t __wide_to_char(const wstring&, char*, size_t);
+_LIBCPP_EXPORTED_FROM_ABI size_t __char_to_wide(const string&, wchar_t*, size_t);
+#  endif
 
 template <class _ECharT>
 struct _PathCVT;
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#  if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 template <class _ECharT>
 struct _PathCVT {
-  static_assert(__can_convert_char<_ECharT>::value,
-                "Char type not convertible");
+  static_assert(__can_convert_char<_ECharT>::value, "Char type not convertible");
 
   typedef __narrow_to_utf8<sizeof(_ECharT) * __CHAR_BIT__> _Narrower;
-#if defined(_LIBCPP_WIN32API)
+#    if defined(_LIBCPP_WIN32API)
   typedef __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__> _Widener;
-#endif
+#    endif
 
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append_range(__path_string& __dest, _ECharT const* __b,
-                             _ECharT const* __e) {
-#if defined(_LIBCPP_WIN32API)
+  _LIBCPP_HIDE_FROM_ABI static void __append_range(__path_string& __dest, _ECharT const* __b, _ECharT const* __e) {
+#    if defined(_LIBCPP_WIN32API)
     string __utf8;
     _Narrower()(back_inserter(__utf8), __b, __e);
     _Widener()(back_inserter(__dest), __utf8.data(), __utf8.data() + __utf8.size());
-#else
+#    else
     _Narrower()(back_inserter(__dest), __b, __e);
-#endif
+#    endif
   }
 
   template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
+  _LIBCPP_HIDE_FROM_ABI static void __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
     if (__b == __e)
       return;
     basic_string<_ECharT> __tmp(__b, __e);
-#if defined(_LIBCPP_WIN32API)
+#    if defined(_LIBCPP_WIN32API)
     string __utf8;
-    _Narrower()(back_inserter(__utf8), __tmp.data(),
-                __tmp.data() + __tmp.length());
+    _Narrower()(back_inserter(__utf8), __tmp.data(), __tmp.data() + __tmp.length());
     _Widener()(back_inserter(__dest), __utf8.data(), __utf8.data() + __utf8.size());
-#else
-    _Narrower()(back_inserter(__dest), __tmp.data(),
-                __tmp.data() + __tmp.length());
-#endif
+#    else
+    _Narrower()(back_inserter(__dest), __tmp.data(), __tmp.data() + __tmp.length());
+#    endif
   }
 
   template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append_range(__path_string& __dest, _Iter __b, _NullSentinel) {
+  _LIBCPP_HIDE_FROM_ABI static void __append_range(__path_string& __dest, _Iter __b, _NullSentinel) {
     static_assert(!is_same<_Iter, _ECharT*>::value, "Call const overload");
     const _ECharT __sentinel = _ECharT{};
     if (*__b == __sentinel)
@@ -282,94 +243,74 @@ struct _PathCVT {
     basic_string<_ECharT> __tmp;
     for (; *__b != __sentinel; ++__b)
       __tmp.push_back(*__b);
-#if defined(_LIBCPP_WIN32API)
+#    if defined(_LIBCPP_WIN32API)
     string __utf8;
-    _Narrower()(back_inserter(__utf8), __tmp.data(),
-                __tmp.data() + __tmp.length());
+    _Narrower()(back_inserter(__utf8), __tmp.data(), __tmp.data() + __tmp.length());
     _Widener()(back_inserter(__dest), __utf8.data(), __utf8.data() + __utf8.size());
-#else
-    _Narrower()(back_inserter(__dest), __tmp.data(),
-                __tmp.data() + __tmp.length());
-#endif
+#    else
+    _Narrower()(back_inserter(__dest), __tmp.data(), __tmp.data() + __tmp.length());
+#    endif
   }
 
   template <class _Source>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append_source(__path_string& __dest, _Source const& __s) {
+  _LIBCPP_HIDE_FROM_ABI static void __append_source(__path_string& __dest, _Source const& __s) {
     using _Traits = __is_pathable<_Source>;
-    __append_range(__dest, _Traits::__range_begin(__s),
-                   _Traits::__range_end(__s));
+    __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s));
   }
 };
-#endif // !_LIBCPP_HAS_NO_LOCALIZATION
+#  endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
 template <>
 struct _PathCVT<__path_value> {
-
-  template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  static typename enable_if<__has_exactly_input_iterator_category<_Iter>::value>::type
-  __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
+  template <class _Iter, __enable_if_t<__has_exactly_input_iterator_category<_Iter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static void __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     for (; __b != __e; ++__b)
       __dest.push_back(*__b);
   }
 
-  template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  static typename enable_if<__has_forward_iterator_category<_Iter>::value>::type
-  __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
+  template <class _Iter, __enable_if_t<__has_forward_iterator_category<_Iter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static void __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     __dest.append(__b, __e);
   }
 
   template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append_range(__path_string& __dest, _Iter __b, _NullSentinel) {
+  _LIBCPP_HIDE_FROM_ABI static void __append_range(__path_string& __dest, _Iter __b, _NullSentinel) {
     const char __sentinel = char{};
     for (; *__b != __sentinel; ++__b)
       __dest.push_back(*__b);
   }
 
   template <class _Source>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append_source(__path_string& __dest, _Source const& __s) {
+  _LIBCPP_HIDE_FROM_ABI static void __append_source(__path_string& __dest, _Source const& __s) {
     using _Traits = __is_pathable<_Source>;
-    __append_range(__dest, _Traits::__range_begin(__s),
-                   _Traits::__range_end(__s));
+    __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s));
   }
 };
 
-#if defined(_LIBCPP_WIN32API)
+#  if defined(_LIBCPP_WIN32API)
 template <>
 struct _PathCVT<char> {
-
-  _LIBCPP_HIDE_FROM_ABI
-  static void
-  __append_string(__path_string& __dest, const basic_string<char> &__str) {
-      size_t __size = __char_to_wide(__str, nullptr, 0);
-      size_t __pos = __dest.size();
-      __dest.resize(__pos + __size);
-      __char_to_wide(__str, const_cast<__path_value*>(__dest.data()) + __pos, __size);
+  _LIBCPP_HIDE_FROM_ABI static void __append_string(__path_string& __dest, const basic_string<char>& __str) {
+    size_t __size = __char_to_wide(__str, nullptr, 0);
+    size_t __pos  = __dest.size();
+    __dest.resize(__pos + __size);
+    __char_to_wide(__str, const_cast<__path_value*>(__dest.data()) + __pos, __size);
   }
 
-  template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  static typename enable_if<__has_exactly_input_iterator_category<_Iter>::value>::type
-  __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
+  template <class _Iter, __enable_if_t<__has_exactly_input_iterator_category<_Iter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static void __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
+    basic_string<char> __tmp(__b, __e);
+    __append_string(__dest, __tmp);
+  }
+
+  template <class _Iter, __enable_if_t<__has_forward_iterator_category<_Iter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static void __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
     basic_string<char> __tmp(__b, __e);
     __append_string(__dest, __tmp);
   }
 
   template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  static typename enable_if<__has_forward_iterator_category<_Iter>::value>::type
-  __append_range(__path_string& __dest, _Iter __b, _Iter __e) {
-    basic_string<char> __tmp(__b, __e);
-    __append_string(__dest, __tmp);
-  }
-
-  template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append_range(__path_string& __dest, _Iter __b, _NullSentinel) {
+  _LIBCPP_HIDE_FROM_ABI static void __append_range(__path_string& __dest, _Iter __b, _NullSentinel) {
     const char __sentinel = char{};
     basic_string<char> __tmp;
     for (; *__b != __sentinel; ++__b)
@@ -378,11 +319,9 @@ struct _PathCVT<char> {
   }
 
   template <class _Source>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append_source(__path_string& __dest, _Source const& __s) {
+  _LIBCPP_HIDE_FROM_ABI static void __append_source(__path_string& __dest, _Source const& __s) {
     using _Traits = __is_pathable<_Source>;
-    __append_range(__dest, _Traits::__range_begin(__s),
-                   _Traits::__range_end(__s));
+    __append_range(__dest, _Traits::__range_begin(__s), _Traits::__range_end(__s));
   }
 };
 
@@ -392,8 +331,7 @@ struct _PathExport {
   typedef __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__> _Widener;
 
   template <class _Str>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append(_Str& __dest, const __path_string& __src) {
+  _LIBCPP_HIDE_FROM_ABI static void __append(_Str& __dest, const __path_string& __src) {
     string __utf8;
     _Narrower()(back_inserter(__utf8), __src.data(), __src.data() + __src.size());
     _Widener()(back_inserter(__dest), __utf8.data(), __utf8.data() + __utf8.size());
@@ -403,10 +341,9 @@ struct _PathExport {
 template <>
 struct _PathExport<char> {
   template <class _Str>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append(_Str& __dest, const __path_string& __src) {
+  _LIBCPP_HIDE_FROM_ABI static void __append(_Str& __dest, const __path_string& __src) {
     size_t __size = __wide_to_char(__src, nullptr, 0);
-    size_t __pos = __dest.size();
+    size_t __pos  = __dest.size();
     __dest.resize(__size);
     __wide_to_char(__src, const_cast<char*>(__dest.data()) + __pos, __size);
   }
@@ -415,8 +352,7 @@ struct _PathExport<char> {
 template <>
 struct _PathExport<wchar_t> {
   template <class _Str>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append(_Str& __dest, const __path_string& __src) {
+  _LIBCPP_HIDE_FROM_ABI static void __append(_Str& __dest, const __path_string& __src) {
     __dest.append(__src.begin(), __src.end());
   }
 };
@@ -424,30 +360,27 @@ struct _PathExport<wchar_t> {
 template <>
 struct _PathExport<char16_t> {
   template <class _Str>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append(_Str& __dest, const __path_string& __src) {
+  _LIBCPP_HIDE_FROM_ABI static void __append(_Str& __dest, const __path_string& __src) {
     __dest.append(__src.begin(), __src.end());
   }
 };
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#    ifndef _LIBCPP_HAS_NO_CHAR8_T
 template <>
 struct _PathExport<char8_t> {
   typedef __narrow_to_utf8<sizeof(wchar_t) * __CHAR_BIT__> _Narrower;
 
   template <class _Str>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __append(_Str& __dest, const __path_string& __src) {
+  _LIBCPP_HIDE_FROM_ABI static void __append(_Str& __dest, const __path_string& __src) {
     _Narrower()(back_inserter(__dest), __src.data(), __src.data() + __src.size());
   }
 };
-#endif /* !_LIBCPP_HAS_NO_CHAR8_T */
-#endif /* _LIBCPP_WIN32API */
+#    endif /* !_LIBCPP_HAS_NO_CHAR8_T */
+#  endif   /* _LIBCPP_WIN32API */
 
-class _LIBCPP_TYPE_VIS path {
+class _LIBCPP_EXPORTED_FROM_ABI path {
   template <class _SourceOrIter, class _Tp = path&>
-  using _EnableIfPathable =
-      typename enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
+  using _EnableIfPathable = __enable_if_t<__is_pathable<_SourceOrIter>::value, _Tp>;
 
   template <class _Tp>
   using _SourceChar = typename __is_pathable<_Tp>::__char_type;
@@ -456,101 +389,84 @@ class _LIBCPP_TYPE_VIS path {
   using _SourceCVT = _PathCVT<_SourceChar<_Tp> >;
 
 public:
-#if defined(_LIBCPP_WIN32API)
+#  if defined(_LIBCPP_WIN32API)
   typedef wchar_t value_type;
   static constexpr value_type preferred_separator = L'\\';
-#else
+#  else
   typedef char value_type;
   static constexpr value_type preferred_separator = '/';
-#endif
+#  endif
   typedef basic_string<value_type> string_type;
   typedef basic_string_view<value_type> __string_view;
 
-  enum _LIBCPP_ENUM_VIS format : unsigned char {
-    auto_format,
-    native_format,
-    generic_format
-  };
+  enum format : unsigned char { auto_format, native_format, generic_format };
 
   // constructors and destructor
   _LIBCPP_HIDE_FROM_ABI path() noexcept {}
   _LIBCPP_HIDE_FROM_ABI path(const path& __p) : __pn_(__p.__pn_) {}
-  _LIBCPP_HIDE_FROM_ABI path(path&& __p) noexcept
-      : __pn_(_VSTD::move(__p.__pn_)) {}
+  _LIBCPP_HIDE_FROM_ABI path(path&& __p) noexcept : __pn_(std::move(__p.__pn_)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  path(string_type&& __s, format = format::auto_format) noexcept
-      : __pn_(_VSTD::move(__s)) {}
+  _LIBCPP_HIDE_FROM_ABI path(string_type&& __s, format = format::auto_format) noexcept : __pn_(std::move(__s)) {}
 
   template <class _Source, class = _EnableIfPathable<_Source, void> >
-  _LIBCPP_HIDE_FROM_ABI
-  path(const _Source& __src, format = format::auto_format) {
+  _LIBCPP_HIDE_FROM_ABI path(const _Source& __src, format = format::auto_format) {
     _SourceCVT<_Source>::__append_source(__pn_, __src);
   }
 
   template <class _InputIt>
-  _LIBCPP_HIDE_FROM_ABI
-  path(_InputIt __first, _InputIt __last, format = format::auto_format) {
+  _LIBCPP_HIDE_FROM_ABI path(_InputIt __first, _InputIt __last, format = format::auto_format) {
     typedef typename iterator_traits<_InputIt>::value_type _ItVal;
     _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
   }
 
-/*
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-  // TODO Implement locale conversions.
-  template <class _Source, class = _EnableIfPathable<_Source, void> >
-  path(const _Source& __src, const locale& __loc, format = format::auto_format);
-  template <class _InputIt>
-  path(_InputIt __first, _InputIt _last, const locale& __loc,
-       format = format::auto_format);
-#endif
-*/
+  /*
+  #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+    // TODO Implement locale conversions.
+    template <class _Source, class = _EnableIfPathable<_Source, void> >
+    path(const _Source& __src, const locale& __loc, format = format::auto_format);
+    template <class _InputIt>
+    path(_InputIt __first, _InputIt _last, const locale& __loc,
+         format = format::auto_format);
+  #endif
+  */
 
-  _LIBCPP_HIDE_FROM_ABI
-  ~path() = default;
+  _LIBCPP_HIDE_FROM_ABI ~path() = default;
 
   // assignments
-  _LIBCPP_HIDE_FROM_ABI
-  path& operator=(const path& __p) {
+  _LIBCPP_HIDE_FROM_ABI path& operator=(const path& __p) {
     __pn_ = __p.__pn_;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  path& operator=(path&& __p) noexcept {
-    __pn_ = _VSTD::move(__p.__pn_);
+  _LIBCPP_HIDE_FROM_ABI path& operator=(path&& __p) noexcept {
+    __pn_ = std::move(__p.__pn_);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  path& operator=(string_type&& __s) noexcept {
-    __pn_ = _VSTD::move(__s);
+  _LIBCPP_HIDE_FROM_ABI path& operator=(string_type&& __s) noexcept {
+    __pn_ = std::move(__s);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  path& assign(string_type&& __s) noexcept {
-    __pn_ = _VSTD::move(__s);
+  _LIBCPP_HIDE_FROM_ABI path& assign(string_type&& __s) noexcept {
+    __pn_ = std::move(__s);
     return *this;
   }
 
   template <class _Source>
-  _LIBCPP_HIDE_FROM_ABI _EnableIfPathable<_Source>
-  operator=(const _Source& __src) {
+  _LIBCPP_HIDE_FROM_ABI _EnableIfPathable<_Source> operator=(const _Source& __src) {
     return this->assign(__src);
   }
 
   template <class _Source>
-  _LIBCPP_HIDE_FROM_ABI
-  _EnableIfPathable<_Source> assign(const _Source& __src) {
+  _LIBCPP_HIDE_FROM_ABI _EnableIfPathable<_Source> assign(const _Source& __src) {
     __pn_.clear();
     _SourceCVT<_Source>::__append_source(__pn_, __src);
     return *this;
   }
 
   template <class _InputIt>
-  _LIBCPP_HIDE_FROM_ABI
-  path& assign(_InputIt __first, _InputIt __last) {
+  _LIBCPP_HIDE_FROM_ABI path& assign(_InputIt __first, _InputIt __last) {
     typedef typename iterator_traits<_InputIt>::value_type _ItVal;
     __pn_.clear();
     _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
@@ -559,19 +475,17 @@ public:
 
 public:
   // appends
-#if defined(_LIBCPP_WIN32API)
-  _LIBCPP_HIDE_FROM_ABI
-  path& operator/=(const path& __p) {
-    auto __p_root_name = __p.__root_name();
+#  if defined(_LIBCPP_WIN32API)
+  _LIBCPP_HIDE_FROM_ABI path& operator/=(const path& __p) {
+    auto __p_root_name      = __p.__root_name();
     auto __p_root_name_size = __p_root_name.size();
-    if (__p.is_absolute() ||
-        (!__p_root_name.empty() && __p_root_name != __string_view(root_name().__pn_))) {
+    if (__p.is_absolute() || (!__p_root_name.empty() && __p_root_name != __string_view(root_name().__pn_))) {
       __pn_ = __p.__pn_;
       return *this;
     }
     if (__p.has_root_directory()) {
       path __root_name_str = root_name();
-      __pn_ = __root_name_str.native();
+      __pn_                = __root_name_str.native();
       __pn_ += __string_view(__p.__pn_).substr(__p_root_name_size);
       return *this;
     }
@@ -581,25 +495,21 @@ public:
     return *this;
   }
   template <class _Source>
-  _LIBCPP_INLINE_VISIBILITY _EnableIfPathable<_Source>
-  operator/=(const _Source& __src) {
+  _LIBCPP_HIDE_FROM_ABI _EnableIfPathable<_Source> operator/=(const _Source& __src) {
     return operator/=(path(__src));
   }
 
   template <class _Source>
-  _LIBCPP_HIDE_FROM_ABI
-  _EnableIfPathable<_Source> append(const _Source& __src) {
+  _LIBCPP_HIDE_FROM_ABI _EnableIfPathable<_Source> append(const _Source& __src) {
     return operator/=(path(__src));
   }
 
   template <class _InputIt>
-  _LIBCPP_HIDE_FROM_ABI
-  path& append(_InputIt __first, _InputIt __last) {
+  _LIBCPP_HIDE_FROM_ABI path& append(_InputIt __first, _InputIt __last) {
     return operator/=(path(__first, __last));
   }
-#else
-  _LIBCPP_HIDE_FROM_ABI
-  path& operator/=(const path& __p) {
+#  else
+  _LIBCPP_HIDE_FROM_ABI path& operator/=(const path& __p) {
     if (__p.is_absolute()) {
       __pn_ = __p.__pn_;
       return *this;
@@ -614,17 +524,15 @@ public:
   // is known at compile time to be "/' since the user almost certainly intended
   // to append a separator instead of overwriting the path with "/"
   template <class _Source>
-  _LIBCPP_HIDE_FROM_ABI _EnableIfPathable<_Source>
-  operator/=(const _Source& __src) {
+  _LIBCPP_HIDE_FROM_ABI _EnableIfPathable<_Source> operator/=(const _Source& __src) {
     return this->append(__src);
   }
 
   template <class _Source>
-  _LIBCPP_HIDE_FROM_ABI
-  _EnableIfPathable<_Source> append(const _Source& __src) {
-    using _Traits = __is_pathable<_Source>;
-    using _CVT = _PathCVT<_SourceChar<_Source> >;
-    bool __source_is_absolute = _VSTD_FS::__is_separator(_Traits::__first_or_null(__src));
+  _LIBCPP_HIDE_FROM_ABI _EnableIfPathable<_Source> append(const _Source& __src) {
+    using _Traits             = __is_pathable<_Source>;
+    using _CVT                = _PathCVT<_SourceChar<_Source> >;
+    bool __source_is_absolute = filesystem::__is_separator(_Traits::__first_or_null(__src));
     if (__source_is_absolute)
       __pn_.clear();
     else if (has_filename())
@@ -634,103 +542,87 @@ public:
   }
 
   template <class _InputIt>
-  _LIBCPP_HIDE_FROM_ABI
-  path& append(_InputIt __first, _InputIt __last) {
+  _LIBCPP_HIDE_FROM_ABI path& append(_InputIt __first, _InputIt __last) {
     typedef typename iterator_traits<_InputIt>::value_type _ItVal;
     static_assert(__can_convert_char<_ItVal>::value, "Must convertible");
     using _CVT = _PathCVT<_ItVal>;
-    if (__first != __last && _VSTD_FS::__is_separator(*__first))
+    if (__first != __last && filesystem::__is_separator(*__first))
       __pn_.clear();
     else if (has_filename())
       __pn_ += preferred_separator;
     _CVT::__append_range(__pn_, __first, __last);
     return *this;
   }
-#endif
+#  endif
 
   // concatenation
-  _LIBCPP_HIDE_FROM_ABI
-  path& operator+=(const path& __x) {
+  _LIBCPP_HIDE_FROM_ABI path& operator+=(const path& __x) {
     __pn_ += __x.__pn_;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  path& operator+=(const string_type& __x) {
+  _LIBCPP_HIDE_FROM_ABI path& operator+=(const string_type& __x) {
     __pn_ += __x;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  path& operator+=(__string_view __x) {
+  _LIBCPP_HIDE_FROM_ABI path& operator+=(__string_view __x) {
     __pn_ += __x;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  path& operator+=(const value_type* __x) {
+  _LIBCPP_HIDE_FROM_ABI path& operator+=(const value_type* __x) {
     __pn_ += __x;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  path& operator+=(value_type __x) {
+  _LIBCPP_HIDE_FROM_ABI path& operator+=(value_type __x) {
     __pn_ += __x;
     return *this;
   }
 
-  template <class _ECharT>
-  _LIBCPP_HIDE_FROM_ABI
-  typename enable_if<__can_convert_char<_ECharT>::value, path&>::type
-  operator+=(_ECharT __x) {
-    _PathCVT<_ECharT>::__append_source(__pn_,
-                                       basic_string_view<_ECharT>(&__x, 1));
+  template <class _ECharT, __enable_if_t<__can_convert_char<_ECharT>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI path& operator+=(_ECharT __x) {
+    _PathCVT<_ECharT>::__append_source(__pn_, basic_string_view<_ECharT>(&__x, 1));
     return *this;
   }
 
   template <class _Source>
-  _LIBCPP_HIDE_FROM_ABI
-  _EnableIfPathable<_Source> operator+=(const _Source& __x) {
+  _LIBCPP_HIDE_FROM_ABI _EnableIfPathable<_Source> operator+=(const _Source& __x) {
     return this->concat(__x);
   }
 
   template <class _Source>
-  _LIBCPP_HIDE_FROM_ABI
-  _EnableIfPathable<_Source> concat(const _Source& __x) {
+  _LIBCPP_HIDE_FROM_ABI _EnableIfPathable<_Source> concat(const _Source& __x) {
     _SourceCVT<_Source>::__append_source(__pn_, __x);
     return *this;
   }
 
   template <class _InputIt>
-  _LIBCPP_HIDE_FROM_ABI
-  path& concat(_InputIt __first, _InputIt __last) {
+  _LIBCPP_HIDE_FROM_ABI path& concat(_InputIt __first, _InputIt __last) {
     typedef typename iterator_traits<_InputIt>::value_type _ItVal;
     _PathCVT<_ItVal>::__append_range(__pn_, __first, __last);
     return *this;
   }
 
   // modifiers
-  _LIBCPP_HIDE_FROM_ABI
-  void clear() noexcept { __pn_.clear(); }
+  _LIBCPP_HIDE_FROM_ABI void clear() noexcept { __pn_.clear(); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  path& make_preferred() {
-#if defined(_LIBCPP_WIN32API)
-    _VSTD::replace(__pn_.begin(), __pn_.end(), L'/', L'\\');
-#endif
+  _LIBCPP_HIDE_FROM_ABI path& make_preferred() {
+#  if defined(_LIBCPP_WIN32API)
+    std::replace(__pn_.begin(), __pn_.end(), L'/', L'\\');
+#  endif
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  path& remove_filename() {
+  _LIBCPP_HIDE_FROM_ABI path& remove_filename() {
     auto __fname = __filename();
     if (!__fname.empty())
       __pn_.erase(__fname.data() - __pn_.data());
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  path& replace_filename(const path& __replacement) {
+  _LIBCPP_HIDE_FROM_ABI path& replace_filename(const path& __replacement) {
     remove_filename();
     return (*this /= __replacement);
   }
@@ -756,7 +648,7 @@ public:
   friend _LIBCPP_HIDE_FROM_ABI bool operator>=(const path& __lhs, const path& __rhs) noexcept {
     return __lhs.__compare(__rhs.__pn_) >= 0;
   }
-#  else // _LIBCPP_STD_VER <= 17
+#  else  // _LIBCPP_STD_VER <= 17
   friend _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(const path& __lhs, const path& __rhs) noexcept {
     return __lhs.__compare(__rhs.__pn_) <=> 0;
   }
@@ -768,39 +660,31 @@ public:
     return __result;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  void swap(path& __rhs) noexcept { __pn_.swap(__rhs.__pn_); }
+  _LIBCPP_HIDE_FROM_ABI void swap(path& __rhs) noexcept { __pn_.swap(__rhs.__pn_); }
 
   // private helper to allow reserving memory in the path
-  _LIBCPP_HIDE_FROM_ABI
-  void __reserve(size_t __s) { __pn_.reserve(__s); }
+  _LIBCPP_HIDE_FROM_ABI void __reserve(size_t __s) { __pn_.reserve(__s); }
 
   // native format observers
-  _LIBCPP_HIDE_FROM_ABI
-  const string_type& native() const noexcept { return __pn_; }
+  _LIBCPP_HIDE_FROM_ABI const string_type& native() const noexcept { return __pn_; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  const value_type* c_str() const noexcept { return __pn_.c_str(); }
+  _LIBCPP_HIDE_FROM_ABI const value_type* c_str() const noexcept { return __pn_.c_str(); }
 
   _LIBCPP_HIDE_FROM_ABI operator string_type() const { return __pn_; }
 
-#if defined(_LIBCPP_WIN32API)
-  _LIBCPP_HIDE_FROM_ABI _VSTD::wstring wstring() const { return __pn_; }
+#  if defined(_LIBCPP_WIN32API)
+  _LIBCPP_HIDE_FROM_ABI std::wstring wstring() const { return __pn_; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  _VSTD::wstring generic_wstring() const {
-    _VSTD::wstring __s;
+  _LIBCPP_HIDE_FROM_ABI std::wstring generic_wstring() const {
+    std::wstring __s;
     __s.resize(__pn_.size());
-    _VSTD::replace_copy(__pn_.begin(), __pn_.end(), __s.begin(), '\\', '/');
+    std::replace_copy(__pn_.begin(), __pn_.end(), __s.begin(), '\\', '/');
     return __s;
   }
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-  template <class _ECharT, class _Traits = char_traits<_ECharT>,
-            class _Allocator = allocator<_ECharT> >
-  _LIBCPP_HIDE_FROM_ABI
-  basic_string<_ECharT, _Traits, _Allocator>
-  string(const _Allocator& __a = _Allocator()) const {
+#    if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  template <class _ECharT, class _Traits = char_traits<_ECharT>, class _Allocator = allocator<_ECharT> >
+  _LIBCPP_HIDE_FROM_ABI basic_string<_ECharT, _Traits, _Allocator> string(const _Allocator& __a = _Allocator()) const {
     using _Str = basic_string<_ECharT, _Traits, _Allocator>;
     _Str __s(__a);
     __s.reserve(__pn_.size());
@@ -808,9 +692,7 @@ public:
     return __s;
   }
 
-  _LIBCPP_HIDE_FROM_ABI _VSTD::string string() const {
-    return string<char>();
-  }
+  _LIBCPP_HIDE_FROM_ABI std::string string() const { return string<char>(); }
   _LIBCPP_HIDE_FROM_ABI __u8_string u8string() const {
     using _CVT = __narrow_to_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
     __u8_string __s;
@@ -819,54 +701,43 @@ public:
     return __s;
   }
 
-  _LIBCPP_HIDE_FROM_ABI _VSTD::u16string u16string() const {
-    return string<char16_t>();
-  }
-  _LIBCPP_HIDE_FROM_ABI _VSTD::u32string u32string() const {
-    return string<char32_t>();
-  }
+  _LIBCPP_HIDE_FROM_ABI std::u16string u16string() const { return string<char16_t>(); }
+  _LIBCPP_HIDE_FROM_ABI std::u32string u32string() const { return string<char32_t>(); }
 
   // generic format observers
-  template <class _ECharT, class _Traits = char_traits<_ECharT>,
-            class _Allocator = allocator<_ECharT> >
-  _LIBCPP_HIDE_FROM_ABI
-  basic_string<_ECharT, _Traits, _Allocator>
+  template <class _ECharT, class _Traits = char_traits<_ECharT>, class _Allocator = allocator<_ECharT> >
+  _LIBCPP_HIDE_FROM_ABI basic_string<_ECharT, _Traits, _Allocator>
   generic_string(const _Allocator& __a = _Allocator()) const {
     using _Str = basic_string<_ECharT, _Traits, _Allocator>;
-    _Str __s = string<_ECharT, _Traits, _Allocator>(__a);
+    _Str __s   = string<_ECharT, _Traits, _Allocator>(__a);
     // Note: This (and generic_u8string below) is slightly suboptimal as
     // it iterates twice over the string; once to convert it to the right
     // character type, and once to replace path delimiters.
-    _VSTD::replace(__s.begin(), __s.end(),
-                   static_cast<_ECharT>('\\'), static_cast<_ECharT>('/'));
+    std::replace(__s.begin(), __s.end(), static_cast<_ECharT>('\\'), static_cast<_ECharT>('/'));
     return __s;
   }
 
-  _LIBCPP_HIDE_FROM_ABI _VSTD::string generic_string() const { return generic_string<char>(); }
-  _LIBCPP_HIDE_FROM_ABI _VSTD::u16string generic_u16string() const { return generic_string<char16_t>(); }
-  _LIBCPP_HIDE_FROM_ABI _VSTD::u32string generic_u32string() const { return generic_string<char32_t>(); }
-  _LIBCPP_HIDE_FROM_ABI
-  __u8_string generic_u8string() const {
+  _LIBCPP_HIDE_FROM_ABI std::string generic_string() const { return generic_string<char>(); }
+  _LIBCPP_HIDE_FROM_ABI std::u16string generic_u16string() const { return generic_string<char16_t>(); }
+  _LIBCPP_HIDE_FROM_ABI std::u32string generic_u32string() const { return generic_string<char32_t>(); }
+  _LIBCPP_HIDE_FROM_ABI __u8_string generic_u8string() const {
     __u8_string __s = u8string();
-    _VSTD::replace(__s.begin(), __s.end(), '\\', '/');
+    std::replace(__s.begin(), __s.end(), '\\', '/');
     return __s;
   }
-#endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
-#else /* _LIBCPP_WIN32API */
+#    endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
+#  else    /* _LIBCPP_WIN32API */
 
-  _LIBCPP_HIDE_FROM_ABI _VSTD::string string() const { return __pn_; }
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-  _LIBCPP_HIDE_FROM_ABI _VSTD::u8string u8string() const { return _VSTD::u8string(__pn_.begin(), __pn_.end()); }
-#else
-  _LIBCPP_HIDE_FROM_ABI _VSTD::string u8string() const { return __pn_; }
-#endif
+  _LIBCPP_HIDE_FROM_ABI std::string string() const { return __pn_; }
+#    ifndef _LIBCPP_HAS_NO_CHAR8_T
+  _LIBCPP_HIDE_FROM_ABI std::u8string u8string() const { return std::u8string(__pn_.begin(), __pn_.end()); }
+#    else
+  _LIBCPP_HIDE_FROM_ABI std::string u8string() const { return __pn_; }
+#    endif
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-  template <class _ECharT, class _Traits = char_traits<_ECharT>,
-            class _Allocator = allocator<_ECharT> >
-  _LIBCPP_HIDE_FROM_ABI
-  basic_string<_ECharT, _Traits, _Allocator>
-  string(const _Allocator& __a = _Allocator()) const {
+#    if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  template <class _ECharT, class _Traits = char_traits<_ECharT>, class _Allocator = allocator<_ECharT> >
+  _LIBCPP_HIDE_FROM_ABI basic_string<_ECharT, _Traits, _Allocator> string(const _Allocator& __a = _Allocator()) const {
     using _CVT = __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__>;
     using _Str = basic_string<_ECharT, _Traits, _Allocator>;
     _Str __s(__a);
@@ -875,43 +746,35 @@ public:
     return __s;
   }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-  _LIBCPP_HIDE_FROM_ABI _VSTD::wstring wstring() const {
-    return string<wchar_t>();
-  }
-#endif
-  _LIBCPP_HIDE_FROM_ABI _VSTD::u16string u16string() const {
-    return string<char16_t>();
-  }
-  _LIBCPP_HIDE_FROM_ABI _VSTD::u32string u32string() const {
-    return string<char32_t>();
-  }
-#endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
+#      ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  _LIBCPP_HIDE_FROM_ABI std::wstring wstring() const { return string<wchar_t>(); }
+#      endif
+  _LIBCPP_HIDE_FROM_ABI std::u16string u16string() const { return string<char16_t>(); }
+  _LIBCPP_HIDE_FROM_ABI std::u32string u32string() const { return string<char32_t>(); }
+#    endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
 
   // generic format observers
-  _LIBCPP_HIDE_FROM_ABI _VSTD::string generic_string() const { return __pn_; }
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-  _LIBCPP_HIDE_FROM_ABI _VSTD::u8string generic_u8string() const { return _VSTD::u8string(__pn_.begin(), __pn_.end()); }
-#else
-  _LIBCPP_HIDE_FROM_ABI _VSTD::string generic_u8string() const { return __pn_; }
-#endif
+  _LIBCPP_HIDE_FROM_ABI std::string generic_string() const { return __pn_; }
+#    ifndef _LIBCPP_HAS_NO_CHAR8_T
+  _LIBCPP_HIDE_FROM_ABI std::u8string generic_u8string() const { return std::u8string(__pn_.begin(), __pn_.end()); }
+#    else
+  _LIBCPP_HIDE_FROM_ABI std::string generic_u8string() const { return __pn_; }
+#    endif
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-  template <class _ECharT, class _Traits = char_traits<_ECharT>,
-            class _Allocator = allocator<_ECharT> >
-  _LIBCPP_HIDE_FROM_ABI
-  basic_string<_ECharT, _Traits, _Allocator>
+#    if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  template <class _ECharT, class _Traits = char_traits<_ECharT>, class _Allocator = allocator<_ECharT> >
+  _LIBCPP_HIDE_FROM_ABI basic_string<_ECharT, _Traits, _Allocator>
   generic_string(const _Allocator& __a = _Allocator()) const {
     return string<_ECharT, _Traits, _Allocator>(__a);
   }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-  _LIBCPP_HIDE_FROM_ABI _VSTD::wstring generic_wstring() const { return string<wchar_t>(); }
-#endif
-  _LIBCPP_HIDE_FROM_ABI _VSTD::u16string generic_u16string() const { return string<char16_t>(); }
-  _LIBCPP_HIDE_FROM_ABI _VSTD::u32string generic_u32string() const { return string<char32_t>(); }
-#endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
-#endif /* !_LIBCPP_WIN32API */
+#      ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  _LIBCPP_HIDE_FROM_ABI std::wstring generic_wstring() const { return string<wchar_t>(); }
+#      endif
+  _LIBCPP_HIDE_FROM_ABI std::u16string generic_u16string() const { return string<char16_t>(); }
+  _LIBCPP_HIDE_FROM_ABI std::u32string generic_u32string() const { return string<char32_t>(); }
+#    endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
+#  endif   /* !_LIBCPP_WIN32API */
 
 private:
   int __compare(__string_view) const;
@@ -926,80 +789,43 @@ private:
 
 public:
   // compare
-  _LIBCPP_HIDE_FROM_ABI int compare(const path& __p) const noexcept {
-    return __compare(__p.__pn_);
-  }
-  _LIBCPP_HIDE_FROM_ABI int compare(const string_type& __s) const {
-    return __compare(__s);
-  }
-  _LIBCPP_HIDE_FROM_ABI int compare(__string_view __s) const {
-    return __compare(__s);
-  }
-  _LIBCPP_HIDE_FROM_ABI int compare(const value_type* __s) const {
-    return __compare(__s);
-  }
+  _LIBCPP_HIDE_FROM_ABI int compare(const path& __p) const noexcept { return __compare(__p.__pn_); }
+  _LIBCPP_HIDE_FROM_ABI int compare(const string_type& __s) const { return __compare(__s); }
+  _LIBCPP_HIDE_FROM_ABI int compare(__string_view __s) const { return __compare(__s); }
+  _LIBCPP_HIDE_FROM_ABI int compare(const value_type* __s) const { return __compare(__s); }
 
   // decomposition
-  _LIBCPP_HIDE_FROM_ABI path root_name() const {
-    return string_type(__root_name());
-  }
-  _LIBCPP_HIDE_FROM_ABI path root_directory() const {
-    return string_type(__root_directory());
-  }
+  _LIBCPP_HIDE_FROM_ABI path root_name() const { return string_type(__root_name()); }
+  _LIBCPP_HIDE_FROM_ABI path root_directory() const { return string_type(__root_directory()); }
   _LIBCPP_HIDE_FROM_ABI path root_path() const {
-#if defined(_LIBCPP_WIN32API)
+#  if defined(_LIBCPP_WIN32API)
     return string_type(__root_path_raw());
-#else
+#  else
     return root_name().append(string_type(__root_directory()));
-#endif
-  }
-  _LIBCPP_HIDE_FROM_ABI path relative_path() const {
-    return string_type(__relative_path());
-  }
-  _LIBCPP_HIDE_FROM_ABI path parent_path() const {
-    return string_type(__parent_path());
-  }
-  _LIBCPP_HIDE_FROM_ABI path filename() const {
-    return string_type(__filename());
+#  endif
   }
+  _LIBCPP_HIDE_FROM_ABI path relative_path() const { return string_type(__relative_path()); }
+  _LIBCPP_HIDE_FROM_ABI path parent_path() const { return string_type(__parent_path()); }
+  _LIBCPP_HIDE_FROM_ABI path filename() const { return string_type(__filename()); }
   _LIBCPP_HIDE_FROM_ABI path stem() const { return string_type(__stem()); }
-  _LIBCPP_HIDE_FROM_ABI path extension() const {
-    return string_type(__extension());
-  }
+  _LIBCPP_HIDE_FROM_ABI path extension() const { return string_type(__extension()); }
 
   // query
-  _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI bool
-  empty() const noexcept {
-    return __pn_.empty();
-  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const noexcept { return __pn_.empty(); }
 
-  _LIBCPP_HIDE_FROM_ABI bool has_root_name() const {
-    return !__root_name().empty();
-  }
-  _LIBCPP_HIDE_FROM_ABI bool has_root_directory() const {
-    return !__root_directory().empty();
-  }
-  _LIBCPP_HIDE_FROM_ABI bool has_root_path() const {
-    return !__root_path_raw().empty();
-  }
-  _LIBCPP_HIDE_FROM_ABI bool has_relative_path() const {
-    return !__relative_path().empty();
-  }
-  _LIBCPP_HIDE_FROM_ABI bool has_parent_path() const {
-    return !__parent_path().empty();
-  }
-  _LIBCPP_HIDE_FROM_ABI bool has_filename() const {
-    return !__filename().empty();
-  }
+  _LIBCPP_HIDE_FROM_ABI bool has_root_name() const { return !__root_name().empty(); }
+  _LIBCPP_HIDE_FROM_ABI bool has_root_directory() const { return !__root_directory().empty(); }
+  _LIBCPP_HIDE_FROM_ABI bool has_root_path() const { return !__root_path_raw().empty(); }
+  _LIBCPP_HIDE_FROM_ABI bool has_relative_path() const { return !__relative_path().empty(); }
+  _LIBCPP_HIDE_FROM_ABI bool has_parent_path() const { return !__parent_path().empty(); }
+  _LIBCPP_HIDE_FROM_ABI bool has_filename() const { return !__filename().empty(); }
   _LIBCPP_HIDE_FROM_ABI bool has_stem() const { return !__stem().empty(); }
-  _LIBCPP_HIDE_FROM_ABI bool has_extension() const {
-    return !__extension().empty();
-  }
+  _LIBCPP_HIDE_FROM_ABI bool has_extension() const { return !__extension().empty(); }
 
   _LIBCPP_HIDE_FROM_ABI bool is_absolute() const {
-#if defined(_LIBCPP_WIN32API)
+#  if defined(_LIBCPP_WIN32API)
     __string_view __root_name_str = __root_name();
-    __string_view __root_dir = __root_directory();
+    __string_view __root_dir      = __root_directory();
     if (__root_name_str.size() == 2 && __root_name_str[1] == ':') {
       // A drive letter with no root directory is relative, e.g. x:example.
       return !__root_dir.empty();
@@ -1016,9 +842,9 @@ public:
       return false;
     // Seems to be a server root name
     return true;
-#else
+#  else
     return has_root_directory();
-#endif
+#  endif
   }
   _LIBCPP_HIDE_FROM_ABI bool is_relative() const { return !is_absolute(); }
 
@@ -1034,30 +860,30 @@ public:
   }
 
   // iterators
-  class _LIBCPP_TYPE_VIS iterator;
+  class _LIBCPP_EXPORTED_FROM_ABI iterator;
   typedef iterator const_iterator;
 
   iterator begin() const;
   iterator end() const;
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-  template <class _CharT, class _Traits>
-  _LIBCPP_HIDE_FROM_ABI friend
-      typename enable_if<is_same<_CharT, value_type>::value &&
-                             is_same<_Traits, char_traits<value_type> >::value,
-                         basic_ostream<_CharT, _Traits>&>::type
-      operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
-    __os << _VSTD::__quoted(__p.native());
+#  if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+  template <
+      class _CharT,
+      class _Traits,
+      __enable_if_t<is_same<_CharT, value_type>::value && is_same<_Traits, char_traits<value_type> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
+    __os << std::__quoted(__p.native());
     return __os;
   }
 
-  template <class _CharT, class _Traits>
-  _LIBCPP_HIDE_FROM_ABI friend
-      typename enable_if<!is_same<_CharT, value_type>::value ||
-                             !is_same<_Traits, char_traits<value_type> >::value,
-                         basic_ostream<_CharT, _Traits>&>::type
-      operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
-    __os << _VSTD::__quoted(__p.string<_CharT, _Traits>());
+  template <
+      class _CharT,
+      class _Traits,
+      __enable_if_t<!is_same<_CharT, value_type>::value || !is_same<_Traits, char_traits<value_type> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const path& __p) {
+    __os << std::__quoted(__p.string<_CharT, _Traits>());
     return __os;
   }
 
@@ -1065,43 +891,41 @@ public:
   _LIBCPP_HIDE_FROM_ABI friend basic_istream<_CharT, _Traits>&
   operator>>(basic_istream<_CharT, _Traits>& __is, path& __p) {
     basic_string<_CharT, _Traits> __tmp;
-    __is >> _VSTD::__quoted(__tmp);
+    __is >> std::__quoted(__tmp);
     __p = __tmp;
     return __is;
   }
-#endif // !_LIBCPP_HAS_NO_LOCALIZATION
+#  endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
 private:
-  inline _LIBCPP_HIDE_FROM_ABI path&
-  __assign_view(__string_view const& __s) noexcept {
+  inline _LIBCPP_HIDE_FROM_ABI path& __assign_view(__string_view const& __s) {
     __pn_ = string_type(__s);
     return *this;
   }
   string_type __pn_;
 };
 
-inline _LIBCPP_HIDE_FROM_ABI void swap(path& __lhs, path& __rhs) noexcept {
-  __lhs.swap(__rhs);
-}
+inline _LIBCPP_HIDE_FROM_ABI void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); }
 
-_LIBCPP_FUNC_VIS
-size_t hash_value(const path& __p) noexcept;
+_LIBCPP_EXPORTED_FROM_ABI size_t hash_value(const path& __p) noexcept;
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <>
-struct _LIBCPP_AVAILABILITY_FILESYSTEM hash<_VSTD_FS::path> : __unary_function<_VSTD_FS::path, size_t> {
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(_VSTD_FS::path const& __p) const noexcept {
-    return _VSTD_FS::hash_value(__p);
+struct _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY hash<filesystem::path> : __unary_function<filesystem::path, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(filesystem::path const& __p) const noexcept {
+    return filesystem::hash_value(__p);
   }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FILESYSTEM_PATH_H
diff --git a/third_party/libcxx/__filesystem/path_iterator.h b/third_party/libcxx/__filesystem/path_iterator.h
index d754fdce2..f4d486d86 100644
--- a/third_party/libcxx/__filesystem/path_iterator.h
+++ b/third_party/libcxx/__filesystem/path_iterator.h
@@ -11,7 +11,6 @@
 #define _LIBCPP___FILESYSTEM_PATH_ITERATOR_H
 
 #include <__assert>
-#include <__availability>
 #include <__config>
 #include <__filesystem/path.h>
 #include <__iterator/iterator_traits.h>
@@ -23,13 +22,11 @@
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
-
-class _LIBCPP_TYPE_VIS path::iterator {
+class _LIBCPP_EXPORTED_FROM_ABI path::iterator {
 public:
   enum _ParserState : unsigned char {
     _Singular,
@@ -51,49 +48,37 @@ public:
   typedef path reference;
 
 public:
-  _LIBCPP_INLINE_VISIBILITY
-  iterator()
-      : __stashed_elem_(), __path_ptr_(nullptr), __entry_(),
-        __state_(_Singular) {}
+  _LIBCPP_HIDE_FROM_ABI iterator() : __stashed_elem_(), __path_ptr_(nullptr), __entry_(), __state_(_Singular) {}
 
   _LIBCPP_HIDE_FROM_ABI iterator(const iterator&) = default;
-  _LIBCPP_HIDE_FROM_ABI ~iterator() = default;
+  _LIBCPP_HIDE_FROM_ABI ~iterator()               = default;
 
   _LIBCPP_HIDE_FROM_ABI iterator& operator=(const iterator&) = default;
 
-  _LIBCPP_INLINE_VISIBILITY
-  reference operator*() const { return __stashed_elem_; }
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __stashed_elem_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  pointer operator->() const { return &__stashed_elem_; }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return &__stashed_elem_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  iterator& operator++() {
-    _LIBCPP_ASSERT(__state_ != _Singular,
-                   "attempting to increment a singular iterator");
-    _LIBCPP_ASSERT(__state_ != _AtEnd,
-                   "attempting to increment the end iterator");
+  _LIBCPP_HIDE_FROM_ABI iterator& operator++() {
+    _LIBCPP_ASSERT_NON_NULL(__state_ != _Singular, "attempting to increment a singular iterator");
+    _LIBCPP_ASSERT_UNCATEGORIZED(__state_ != _AtEnd, "attempting to increment the end iterator");
     return __increment();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  iterator operator++(int) {
+  _LIBCPP_HIDE_FROM_ABI iterator operator++(int) {
     iterator __it(*this);
     this->operator++();
     return __it;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  iterator& operator--() {
-    _LIBCPP_ASSERT(__state_ != _Singular,
-                   "attempting to decrement a singular iterator");
-    _LIBCPP_ASSERT(__entry_.data() != __path_ptr_->native().data(),
-                   "attempting to decrement the begin iterator");
+  _LIBCPP_HIDE_FROM_ABI iterator& operator--() {
+    _LIBCPP_ASSERT_NON_NULL(__state_ != _Singular, "attempting to decrement a singular iterator");
+    _LIBCPP_ASSERT_UNCATEGORIZED(
+        __entry_.data() != __path_ptr_->native().data(), "attempting to decrement the begin iterator");
     return __decrement();
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  iterator operator--(int) {
+  _LIBCPP_HIDE_FROM_ABI iterator operator--(int) {
     iterator __it(*this);
     this->operator--();
     return __it;
@@ -102,8 +87,7 @@ public:
 private:
   friend class path;
 
-  inline _LIBCPP_INLINE_VISIBILITY friend bool operator==(const iterator&,
-                                                          const iterator&);
+  inline _LIBCPP_HIDE_FROM_ABI friend bool operator==(const iterator&, const iterator&);
 
   iterator& __increment();
   iterator& __decrement();
@@ -114,21 +98,18 @@ private:
   _ParserState __state_;
 };
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator==(const path::iterator& __lhs,
-                                                 const path::iterator& __rhs) {
-  return __lhs.__path_ptr_ == __rhs.__path_ptr_ &&
-         __lhs.__entry_.data() == __rhs.__entry_.data();
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const path::iterator& __lhs, const path::iterator& __rhs) {
+  return __lhs.__path_ptr_ == __rhs.__path_ptr_ && __lhs.__entry_.data() == __rhs.__entry_.data();
 }
 
-inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const path::iterator& __lhs,
-                                                 const path::iterator& __rhs) {
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const path::iterator& __lhs, const path::iterator& __rhs) {
   return !(__lhs == __rhs);
 }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_PATH_ITERATOR_H
diff --git a/third_party/libcxx/__filesystem/perm_options.h b/third_party/libcxx/__filesystem/perm_options.h
index 4aba302ed..64c16ee60 100644
--- a/third_party/libcxx/__filesystem/perm_options.h
+++ b/third_party/libcxx/__filesystem/perm_options.h
@@ -10,68 +10,48 @@
 #ifndef _LIBCPP___FILESYSTEM_PERM_OPTIONS_H
 #define _LIBCPP___FILESYSTEM_PERM_OPTIONS_H
 
-#include <__availability>
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
+enum class perm_options : unsigned char { replace = 1, add = 2, remove = 4, nofollow = 8 };
 
-enum class _LIBCPP_ENUM_VIS perm_options : unsigned char {
-  replace = 1,
-  add = 2,
-  remove = 4,
-  nofollow = 8
-};
-
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr perm_options operator&(perm_options __lhs, perm_options __rhs) {
-  return static_cast<perm_options>(static_cast<unsigned>(__lhs) &
-                                   static_cast<unsigned>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator&(perm_options __lhs, perm_options __rhs) {
+  return static_cast<perm_options>(static_cast<unsigned>(__lhs) & static_cast<unsigned>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr perm_options operator|(perm_options __lhs, perm_options __rhs) {
-  return static_cast<perm_options>(static_cast<unsigned>(__lhs) |
-                                   static_cast<unsigned>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator|(perm_options __lhs, perm_options __rhs) {
+  return static_cast<perm_options>(static_cast<unsigned>(__lhs) | static_cast<unsigned>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr perm_options operator^(perm_options __lhs, perm_options __rhs) {
-  return static_cast<perm_options>(static_cast<unsigned>(__lhs) ^
-                                   static_cast<unsigned>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator^(perm_options __lhs, perm_options __rhs) {
+  return static_cast<perm_options>(static_cast<unsigned>(__lhs) ^ static_cast<unsigned>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr perm_options operator~(perm_options __lhs) {
+_LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator~(perm_options __lhs) {
   return static_cast<perm_options>(~static_cast<unsigned>(__lhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline perm_options& operator&=(perm_options& __lhs, perm_options __rhs) {
+_LIBCPP_HIDE_FROM_ABI inline perm_options& operator&=(perm_options& __lhs, perm_options __rhs) {
   return __lhs = __lhs & __rhs;
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline perm_options& operator|=(perm_options& __lhs, perm_options __rhs) {
+_LIBCPP_HIDE_FROM_ABI inline perm_options& operator|=(perm_options& __lhs, perm_options __rhs) {
   return __lhs = __lhs | __rhs;
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline perm_options& operator^=(perm_options& __lhs, perm_options __rhs) {
+_LIBCPP_HIDE_FROM_ABI inline perm_options& operator^=(perm_options& __lhs, perm_options __rhs) {
   return __lhs = __lhs ^ __rhs;
 }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_PERM_OPTIONS_H
diff --git a/third_party/libcxx/__filesystem/perms.h b/third_party/libcxx/__filesystem/perms.h
index df4590057..458f1e6e5 100644
--- a/third_party/libcxx/__filesystem/perms.h
+++ b/third_party/libcxx/__filesystem/perms.h
@@ -10,86 +10,71 @@
 #ifndef _LIBCPP___FILESYSTEM_PERMS_H
 #define _LIBCPP___FILESYSTEM_PERMS_H
 
-#include <__availability>
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
-
 // On Windows, these permission bits map to one single readonly flag per
 // file, and the executable bit is always returned as set. When setting
 // permissions, as long as the write bit is set for either owner, group or
 // others, the readonly flag is cleared.
-enum class _LIBCPP_ENUM_VIS perms : unsigned {
+enum class perms : unsigned {
   none = 0,
 
-  owner_read = 0400,
+  owner_read  = 0400,
   owner_write = 0200,
-  owner_exec = 0100,
-  owner_all = 0700,
+  owner_exec  = 0100,
+  owner_all   = 0700,
 
-  group_read = 040,
+  group_read  = 040,
   group_write = 020,
-  group_exec = 010,
-  group_all = 070,
+  group_exec  = 010,
+  group_all   = 070,
 
-  others_read = 04,
+  others_read  = 04,
   others_write = 02,
-  others_exec = 01,
-  others_all = 07,
+  others_exec  = 01,
+  others_all   = 07,
 
   all = 0777,
 
-  set_uid = 04000,
-  set_gid = 02000,
+  set_uid    = 04000,
+  set_gid    = 02000,
   sticky_bit = 01000,
-  mask = 07777,
-  unknown = 0xFFFF,
+  mask       = 07777,
+  unknown    = 0xFFFF,
 };
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr perms operator&(perms __lhs, perms __rhs) {
-  return static_cast<perms>(static_cast<unsigned>(__lhs) &
-                            static_cast<unsigned>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr perms operator&(perms __lhs, perms __rhs) {
+  return static_cast<perms>(static_cast<unsigned>(__lhs) & static_cast<unsigned>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr perms operator|(perms __lhs, perms __rhs) {
-  return static_cast<perms>(static_cast<unsigned>(__lhs) |
-                            static_cast<unsigned>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr perms operator|(perms __lhs, perms __rhs) {
+  return static_cast<perms>(static_cast<unsigned>(__lhs) | static_cast<unsigned>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr perms operator^(perms __lhs, perms __rhs) {
-  return static_cast<perms>(static_cast<unsigned>(__lhs) ^
-                            static_cast<unsigned>(__rhs));
+_LIBCPP_HIDE_FROM_ABI inline constexpr perms operator^(perms __lhs, perms __rhs) {
+  return static_cast<perms>(static_cast<unsigned>(__lhs) ^ static_cast<unsigned>(__rhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr perms operator~(perms __lhs) {
+_LIBCPP_HIDE_FROM_ABI inline constexpr perms operator~(perms __lhs) {
   return static_cast<perms>(~static_cast<unsigned>(__lhs));
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline perms& operator&=(perms& __lhs, perms __rhs) { return __lhs = __lhs & __rhs; }
+_LIBCPP_HIDE_FROM_ABI inline perms& operator&=(perms& __lhs, perms __rhs) { return __lhs = __lhs & __rhs; }
 
-_LIBCPP_INLINE_VISIBILITY
-inline perms& operator|=(perms& __lhs, perms __rhs) { return __lhs = __lhs | __rhs; }
+_LIBCPP_HIDE_FROM_ABI inline perms& operator|=(perms& __lhs, perms __rhs) { return __lhs = __lhs | __rhs; }
 
-_LIBCPP_INLINE_VISIBILITY
-inline perms& operator^=(perms& __lhs, perms __rhs) { return __lhs = __lhs ^ __rhs; }
-
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
+_LIBCPP_HIDE_FROM_ABI inline perms& operator^=(perms& __lhs, perms __rhs) { return __lhs = __lhs ^ __rhs; }
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_PERMS_H
diff --git a/third_party/libcxx/__filesystem/recursive_directory_iterator.h b/third_party/libcxx/__filesystem/recursive_directory_iterator.h
index 3d5c02540..caa1396eb 100644
--- a/third_party/libcxx/__filesystem/recursive_directory_iterator.h
+++ b/third_party/libcxx/__filesystem/recursive_directory_iterator.h
@@ -10,11 +10,11 @@
 #ifndef _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H
 #define _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H
 
-#include <__availability>
 #include <__config>
 #include <__filesystem/directory_entry.h>
 #include <__filesystem/directory_options.h>
 #include <__filesystem/path.h>
+#include <__iterator/default_sentinel.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/shared_ptr.h>
 #include <__ranges/enable_borrowed_range.h>
@@ -27,51 +27,46 @@
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
 class recursive_directory_iterator {
 public:
-  using value_type = directory_entry;
-  using difference_type = ptrdiff_t;
-  using pointer = directory_entry const*;
-  using reference = directory_entry const&;
+  using value_type        = directory_entry;
+  using difference_type   = ptrdiff_t;
+  using pointer           = directory_entry const*;
+  using reference         = directory_entry const&;
   using iterator_category = input_iterator_tag;
 
 public:
   // constructors and destructor
-  _LIBCPP_INLINE_VISIBILITY
-  recursive_directory_iterator() noexcept : __rec_(false) {}
+  _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator() noexcept : __rec_(false) {}
 
-  _LIBCPP_INLINE_VISIBILITY
-  explicit recursive_directory_iterator(
+  _LIBCPP_HIDE_FROM_ABI explicit recursive_directory_iterator(
       const path& __p, directory_options __xoptions = directory_options::none)
       : recursive_directory_iterator(__p, __xoptions, nullptr) {}
 
-  _LIBCPP_INLINE_VISIBILITY
-  recursive_directory_iterator(const path& __p, directory_options __xoptions,
-                               error_code& __ec)
+  _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator(const path& __p, directory_options __xoptions, error_code& __ec)
       : recursive_directory_iterator(__p, __xoptions, &__ec) {}
 
-  _LIBCPP_INLINE_VISIBILITY
-  recursive_directory_iterator(const path& __p, error_code& __ec)
+  _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator(const path& __p, error_code& __ec)
       : recursive_directory_iterator(__p, directory_options::none, &__ec) {}
 
   _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator(const recursive_directory_iterator&) = default;
-  _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator(recursive_directory_iterator&&) = default;
+  _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator(recursive_directory_iterator&&)      = default;
 
-  _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator&
-  operator=(const recursive_directory_iterator&) = default;
+  _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator& operator=(const recursive_directory_iterator&) = default;
 
-  _LIBCPP_INLINE_VISIBILITY
-  recursive_directory_iterator&
-  operator=(recursive_directory_iterator&& __o) noexcept {
+  _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator& operator=(recursive_directory_iterator&& __o) noexcept {
     // non-default implementation provided to support self-move assign.
     if (this != &__o) {
-      __imp_ = _VSTD::move(__o.__imp_);
+      __imp_ = std::move(__o.__imp_);
       __rec_ = __o.__rec_;
     }
     return *this;
@@ -79,108 +74,91 @@ public:
 
   _LIBCPP_HIDE_FROM_ABI ~recursive_directory_iterator() = default;
 
-  _LIBCPP_INLINE_VISIBILITY
-  const directory_entry& operator*() const { return __dereference(); }
+  _LIBCPP_HIDE_FROM_ABI const directory_entry& operator*() const { return __dereference(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  const directory_entry* operator->() const { return &__dereference(); }
+  _LIBCPP_HIDE_FROM_ABI const directory_entry* operator->() const { return &__dereference(); }
 
   _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator& operator++() { return __increment(); }
 
-  _LIBCPP_INLINE_VISIBILITY
-  __dir_element_proxy operator++(int) {
+  _LIBCPP_HIDE_FROM_ABI __dir_element_proxy operator++(int) {
     __dir_element_proxy __p(**this);
     __increment();
     return __p;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  recursive_directory_iterator& increment(error_code& __ec) {
-    return __increment(&__ec);
+  _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator& increment(error_code& __ec) { return __increment(&__ec); }
+
+  _LIBCPP_EXPORTED_FROM_ABI directory_options options() const;
+  _LIBCPP_EXPORTED_FROM_ABI int depth() const;
+
+  _LIBCPP_HIDE_FROM_ABI void pop() { __pop(); }
+
+  _LIBCPP_HIDE_FROM_ABI void pop(error_code& __ec) { __pop(&__ec); }
+
+  _LIBCPP_HIDE_FROM_ABI bool recursion_pending() const { return __rec_; }
+
+  _LIBCPP_HIDE_FROM_ABI void disable_recursion_pending() { __rec_ = false; }
+
+#  if _LIBCPP_STD_VER >= 20
+
+  _LIBCPP_HIDE_FROM_ABI bool operator==(default_sentinel_t) const noexcept {
+    return *this == recursive_directory_iterator();
   }
 
-  _LIBCPP_FUNC_VIS directory_options options() const;
-  _LIBCPP_FUNC_VIS int depth() const;
-
-  _LIBCPP_INLINE_VISIBILITY
-  void pop() { __pop(); }
-
-  _LIBCPP_INLINE_VISIBILITY
-  void pop(error_code& __ec) { __pop(&__ec); }
-
-  _LIBCPP_INLINE_VISIBILITY
-  bool recursion_pending() const { return __rec_; }
-
-  _LIBCPP_INLINE_VISIBILITY
-  void disable_recursion_pending() { __rec_ = false; }
+#  endif
 
 private:
-  _LIBCPP_FUNC_VIS
-  recursive_directory_iterator(const path& __p, directory_options __opt,
-                               error_code* __ec);
+  _LIBCPP_EXPORTED_FROM_ABI recursive_directory_iterator(const path& __p, directory_options __opt, error_code* __ec);
+  _LIBCPP_EXPORTED_FROM_ABI const directory_entry& __dereference() const;
+  _LIBCPP_EXPORTED_FROM_ABI bool __try_recursion(error_code* __ec);
+  _LIBCPP_EXPORTED_FROM_ABI void __advance(error_code* __ec = nullptr);
+  _LIBCPP_EXPORTED_FROM_ABI recursive_directory_iterator& __increment(error_code* __ec = nullptr);
+  _LIBCPP_EXPORTED_FROM_ABI void __pop(error_code* __ec = nullptr);
 
-  _LIBCPP_FUNC_VIS
-  const directory_entry& __dereference() const;
-
-  _LIBCPP_FUNC_VIS
-  bool __try_recursion(error_code* __ec);
-
-  _LIBCPP_FUNC_VIS
-  void __advance(error_code* __ec = nullptr);
-
-  _LIBCPP_FUNC_VIS
-  recursive_directory_iterator& __increment(error_code* __ec = nullptr);
-
-  _LIBCPP_FUNC_VIS
-  void __pop(error_code* __ec = nullptr);
-
-  inline _LIBCPP_INLINE_VISIBILITY friend bool
-  operator==(const recursive_directory_iterator&,
-             const recursive_directory_iterator&) noexcept;
+  inline _LIBCPP_HIDE_FROM_ABI friend bool
+  operator==(const recursive_directory_iterator&, const recursive_directory_iterator&) noexcept;
 
   struct _LIBCPP_HIDDEN __shared_imp;
   shared_ptr<__shared_imp> __imp_;
   bool __rec_;
 }; // class recursive_directory_iterator
 
-inline _LIBCPP_INLINE_VISIBILITY bool
-operator==(const recursive_directory_iterator& __lhs,
-           const recursive_directory_iterator& __rhs) noexcept {
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const recursive_directory_iterator& __lhs, const recursive_directory_iterator& __rhs) noexcept {
   return __lhs.__imp_ == __rhs.__imp_;
 }
 
-_LIBCPP_INLINE_VISIBILITY
-inline bool operator!=(const recursive_directory_iterator& __lhs,
-                       const recursive_directory_iterator& __rhs) noexcept {
+_LIBCPP_HIDE_FROM_ABI inline bool
+operator!=(const recursive_directory_iterator& __lhs, const recursive_directory_iterator& __rhs) noexcept {
   return !(__lhs == __rhs);
 }
 // enable recursive_directory_iterator range-based for statements
-inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
-begin(recursive_directory_iterator __iter) noexcept {
+inline _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator begin(recursive_directory_iterator __iter) noexcept {
   return __iter;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY recursive_directory_iterator
-end(recursive_directory_iterator) noexcept {
+inline _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator end(recursive_directory_iterator) noexcept {
   return recursive_directory_iterator();
 }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
 
 template <>
-_LIBCPP_AVAILABILITY_FILESYSTEM
-inline constexpr bool _VSTD::ranges::enable_borrowed_range<_VSTD_FS::recursive_directory_iterator> = true;
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY inline constexpr bool
+    std::ranges::enable_borrowed_range<std::filesystem::recursive_directory_iterator> = true;
 
 template <>
-_LIBCPP_AVAILABILITY_FILESYSTEM
-inline constexpr bool _VSTD::ranges::enable_view<_VSTD_FS::recursive_directory_iterator> = true;
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY inline constexpr bool
+    std::ranges::enable_view<std::filesystem::recursive_directory_iterator> = true;
 
-#endif // _LIBCPP_STD_VER >= 20
+#  endif // _LIBCPP_STD_VER >= 20
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM)
+
+_LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___FILESYSTEM_RECURSIVE_DIRECTORY_ITERATOR_H
diff --git a/third_party/libcxx/__filesystem/space_info.h b/third_party/libcxx/__filesystem/space_info.h
index 25fcb9a77..3fa57d330 100644
--- a/third_party/libcxx/__filesystem/space_info.h
+++ b/third_party/libcxx/__filesystem/space_info.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___FILESYSTEM_SPACE_INFO_H
 #define _LIBCPP___FILESYSTEM_SPACE_INFO_H
 
-#include <__availability>
 #include <__config>
 #include <cstdint>
 
@@ -18,13 +17,11 @@
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
-
-struct _LIBCPP_TYPE_VIS space_info {
+struct _LIBCPP_EXPORTED_FROM_ABI space_info {
   uintmax_t capacity;
   uintmax_t free;
   uintmax_t available;
@@ -34,10 +31,8 @@ struct _LIBCPP_TYPE_VIS space_info {
 #  endif
 };
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
-
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_SPACE_INFO_H
diff --git a/third_party/libcxx/__filesystem/u8path.h b/third_party/libcxx/__filesystem/u8path.h
index ebc1159ee..dae582312 100644
--- a/third_party/libcxx/__filesystem/u8path.h
+++ b/third_party/libcxx/__filesystem/u8path.h
@@ -11,7 +11,6 @@
 #define _LIBCPP___FILESYSTEM_U8PATH_H
 
 #include <__algorithm/unwrap_iter.h>
-#include <__availability>
 #include <__config>
 #include <__filesystem/path.h>
 #include <string>
@@ -19,52 +18,48 @@
 // Only required on Windows for __widen_from_utf8, and included conservatively
 // because it requires support for localization.
 #if defined(_LIBCPP_WIN32API)
-# include <locale>
+#  include <locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_PUSH
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 
-template <class _InputIt>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
-    typename enable_if<__is_pathable<_InputIt>::value, path>::type
-    u8path(_InputIt __f, _InputIt __l) {
+template <class _InputIt, __enable_if_t<__is_pathable<_InputIt>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(_InputIt __f, _InputIt __l) {
   static_assert(
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
       is_same<typename __is_pathable<_InputIt>::__char_type, char8_t>::value ||
-#endif
-      is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
+#  endif
+          is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
       "u8path(Iter, Iter) requires Iter have a value_type of type 'char'"
       " or 'char8_t'");
-#if defined(_LIBCPP_WIN32API)
+#  if defined(_LIBCPP_WIN32API)
   string __tmp(__f, __l);
   using _CVT = __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
-  _VSTD::wstring __w;
+  std::wstring __w;
   __w.reserve(__tmp.size());
   _CVT()(back_inserter(__w), __tmp.data(), __tmp.data() + __tmp.size());
   return path(__w);
-#else
+#  else
   return path(__f, __l);
-#endif /* !_LIBCPP_WIN32API */
+#  endif /* !_LIBCPP_WIN32API */
 }
 
-#if defined(_LIBCPP_WIN32API)
-template <class _InputIt>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
-    typename enable_if<__is_pathable<_InputIt>::value, path>::type
-    u8path(_InputIt __f, _NullSentinel) {
+#  if defined(_LIBCPP_WIN32API)
+template <class _InputIt, __enable_if_t<__is_pathable<_InputIt>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(_InputIt __f, _NullSentinel) {
   static_assert(
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#    ifndef _LIBCPP_HAS_NO_CHAR8_T
       is_same<typename __is_pathable<_InputIt>::__char_type, char8_t>::value ||
-#endif
-      is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
+#    endif
+          is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
       "u8path(Iter, Iter) requires Iter have a value_type of type 'char'"
       " or 'char8_t'");
   string __tmp;
@@ -72,36 +67,34 @@ _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
   for (; *__f != __sentinel; ++__f)
     __tmp.push_back(*__f);
   using _CVT = __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
-  _VSTD::wstring __w;
+  std::wstring __w;
   __w.reserve(__tmp.size());
   _CVT()(back_inserter(__w), __tmp.data(), __tmp.data() + __tmp.size());
   return path(__w);
 }
-#endif /* _LIBCPP_WIN32API */
+#  endif /* _LIBCPP_WIN32API */
 
-template <class _Source>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
-    typename enable_if<__is_pathable<_Source>::value, path>::type
-    u8path(const _Source& __s) {
+template <class _Source, __enable_if_t<__is_pathable<_Source>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(const _Source& __s) {
   static_assert(
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
       is_same<typename __is_pathable<_Source>::__char_type, char8_t>::value ||
-#endif
-      is_same<typename __is_pathable<_Source>::__char_type, char>::value,
+#  endif
+          is_same<typename __is_pathable<_Source>::__char_type, char>::value,
       "u8path(Source const&) requires Source have a character type of type "
       "'char' or 'char8_t'");
-#if defined(_LIBCPP_WIN32API)
+#  if defined(_LIBCPP_WIN32API)
   using _Traits = __is_pathable<_Source>;
-  return u8path(_VSTD::__unwrap_iter(_Traits::__range_begin(__s)), _VSTD::__unwrap_iter(_Traits::__range_end(__s)));
-#else
+  return u8path(std::__unwrap_iter(_Traits::__range_begin(__s)), std::__unwrap_iter(_Traits::__range_end(__s)));
+#  else
   return path(__s);
-#endif
+#  endif
 }
 
-_LIBCPP_AVAILABILITY_FILESYSTEM_POP
+_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 17
 
 #endif // _LIBCPP___FILESYSTEM_U8PATH_H
diff --git a/third_party/libcxx/__format/buffer.h b/third_party/libcxx/__format/buffer.h
index e74ca8f57..8598f0a1c 100644
--- a/third_party/libcxx/__format/buffer.h
+++ b/third_party/libcxx/__format/buffer.h
@@ -71,7 +71,7 @@ public:
         __obj_(__obj) {}
 
   _LIBCPP_HIDE_FROM_ABI void __reset(_CharT* __ptr, size_t __capacity) {
-    __ptr_ = __ptr;
+    __ptr_      = __ptr;
     __capacity_ = __capacity;
   }
 
@@ -95,7 +95,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI void __copy(basic_string_view<_InCharT> __str) {
     // When the underlying iterator is a simple iterator the __capacity_ is
     // infinite. For a string or container back_inserter it isn't. This means
-    // adding a large string the the buffer can cause some overhead. In that
+    // that adding a large string to the buffer can cause some overhead. In that
     // case a better approach could be:
     // - flush the buffer
     // - container.append(__str.begin(), __str.end());
@@ -107,19 +107,19 @@ public:
     size_t __n = __str.size();
 
     __flush_on_overflow(__n);
-    if (__n <= __capacity_) {
-      _VSTD::copy_n(__str.data(), __n, _VSTD::addressof(__ptr_[__size_]));
+    if (__n < __capacity_) { //  push_back requires the buffer to have room for at least one character (so use <).
+      std::copy_n(__str.data(), __n, std::addressof(__ptr_[__size_]));
       __size_ += __n;
       return;
     }
 
     // The output doesn't fit in the internal buffer.
     // Copy the data in "__capacity_" sized chunks.
-    _LIBCPP_ASSERT(__size_ == 0, "the buffer should be flushed by __flush_on_overflow");
+    _LIBCPP_ASSERT_INTERNAL(__size_ == 0, "the buffer should be flushed by __flush_on_overflow");
     const _InCharT* __first = __str.data();
     do {
-      size_t __chunk = _VSTD::min(__n, __capacity_);
-      _VSTD::copy_n(__first, __chunk, _VSTD::addressof(__ptr_[__size_]));
+      size_t __chunk = std::min(__n, __capacity_);
+      std::copy_n(__first, __chunk, std::addressof(__ptr_[__size_]));
       __size_ = __chunk;
       __first += __chunk;
       __n -= __chunk;
@@ -130,24 +130,26 @@ public:
   /// A std::transform wrapper.
   ///
   /// Like @ref __copy it may need to do type conversion.
-  template <__fmt_char_type _InCharT, class _UnaryOperation>
-  _LIBCPP_HIDE_FROM_ABI void __transform(const _InCharT* __first, const _InCharT* __last, _UnaryOperation __operation) {
-    _LIBCPP_ASSERT(__first <= __last, "not a valid range");
+  template <contiguous_iterator _Iterator,
+            class _UnaryOperation,
+            __fmt_char_type _InCharT = typename iterator_traits<_Iterator>::value_type>
+  _LIBCPP_HIDE_FROM_ABI void __transform(_Iterator __first, _Iterator __last, _UnaryOperation __operation) {
+    _LIBCPP_ASSERT_INTERNAL(__first <= __last, "not a valid range");
 
     size_t __n = static_cast<size_t>(__last - __first);
     __flush_on_overflow(__n);
-    if (__n <= __capacity_) {
-      _VSTD::transform(__first, __last, _VSTD::addressof(__ptr_[__size_]), _VSTD::move(__operation));
+    if (__n < __capacity_) { //  push_back requires the buffer to have room for at least one character (so use <).
+      std::transform(__first, __last, std::addressof(__ptr_[__size_]), std::move(__operation));
       __size_ += __n;
       return;
     }
 
     // The output doesn't fit in the internal buffer.
     // Transform the data in "__capacity_" sized chunks.
-    _LIBCPP_ASSERT(__size_ == 0, "the buffer should be flushed by __flush_on_overflow");
+    _LIBCPP_ASSERT_INTERNAL(__size_ == 0, "the buffer should be flushed by __flush_on_overflow");
     do {
-      size_t __chunk = _VSTD::min(__n, __capacity_);
-      _VSTD::transform(__first, __first + __chunk, _VSTD::addressof(__ptr_[__size_]), __operation);
+      size_t __chunk = std::min(__n, __capacity_);
+      std::transform(__first, __first + __chunk, std::addressof(__ptr_[__size_]), __operation);
       __size_ = __chunk;
       __first += __chunk;
       __n -= __chunk;
@@ -158,18 +160,18 @@ public:
   /// A \c fill_n wrapper.
   _LIBCPP_HIDE_FROM_ABI void __fill(size_t __n, _CharT __value) {
     __flush_on_overflow(__n);
-    if (__n <= __capacity_) {
-      _VSTD::fill_n(_VSTD::addressof(__ptr_[__size_]), __n, __value);
+    if (__n < __capacity_) { //  push_back requires the buffer to have room for at least one character (so use <).
+      std::fill_n(std::addressof(__ptr_[__size_]), __n, __value);
       __size_ += __n;
       return;
     }
 
     // The output doesn't fit in the internal buffer.
     // Fill the buffer in "__capacity_" sized chunks.
-    _LIBCPP_ASSERT(__size_ == 0, "the buffer should be flushed by __flush_on_overflow");
+    _LIBCPP_ASSERT_INTERNAL(__size_ == 0, "the buffer should be flushed by __flush_on_overflow");
     do {
-      size_t __chunk = _VSTD::min(__n, __capacity_);
-      _VSTD::fill_n(_VSTD::addressof(__ptr_[__size_]), __chunk, __value);
+      size_t __chunk = std::min(__n, __capacity_);
+      std::fill_n(std::addressof(__ptr_[__size_]), __chunk, __value);
       __size_ = __chunk;
       __n -= __chunk;
       __flush();
@@ -251,19 +253,18 @@ template <__fmt_char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __direct_storage {};
 
 template <class _OutIt, class _CharT>
-concept __enable_direct_output = __fmt_char_type<_CharT> &&
+concept __enable_direct_output =
+    __fmt_char_type<_CharT> &&
     (same_as<_OutIt, _CharT*>
-#ifndef _LIBCPP_ENABLE_DEBUG_MODE
-     || same_as<_OutIt, __wrap_iter<_CharT*>>
-#endif
-    );
+     // TODO(hardening): the following check might not apply to hardened iterators and might need to be wrapped in an
+     // `#ifdef`.
+     || same_as<_OutIt, __wrap_iter<_CharT*>>);
 
 /// Write policy for directly writing to the underlying output.
 template <class _OutIt, __fmt_char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __writer_direct {
 public:
-  _LIBCPP_HIDE_FROM_ABI explicit __writer_direct(_OutIt __out_it)
-      : __out_it_(__out_it) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __writer_direct(_OutIt __out_it) : __out_it_(__out_it) {}
 
   _LIBCPP_HIDE_FROM_ABI _OutIt __out_it() { return __out_it_; }
 
@@ -281,8 +282,7 @@ private:
 template <class _OutIt, __fmt_char_type _CharT>
 class _LIBCPP_TEMPLATE_VIS __writer_iterator {
 public:
-  _LIBCPP_HIDE_FROM_ABI explicit __writer_iterator(_OutIt __out_it)
-      : __out_it_{_VSTD::move(__out_it)} {}
+  _LIBCPP_HIDE_FROM_ABI explicit __writer_iterator(_OutIt __out_it) : __out_it_{std::move(__out_it)} {}
 
   _LIBCPP_HIDE_FROM_ABI _OutIt __out_it() && { return std::move(__out_it_); }
 
@@ -304,7 +304,8 @@ private:
 template <class _Container>
 concept __insertable =
     __enable_insertable<_Container> && __fmt_char_type<typename _Container::value_type> &&
-    requires(_Container& __t, add_pointer_t<typename _Container::value_type> __first,
+    requires(_Container& __t,
+             add_pointer_t<typename _Container::value_type> __first,
              add_pointer_t<typename _Container::value_type> __last) { __t.insert(__t.end(), __first, __last); };
 
 /// Extract the container type of a \ref back_insert_iterator.
@@ -343,28 +344,29 @@ class _LIBCPP_TEMPLATE_VIS __writer_selector {
   using _Container = typename __back_insert_iterator_container<_OutIt>::type;
 
 public:
-  using type = conditional_t<!same_as<_Container, void>, __writer_container<_Container>,
-                             conditional_t<__enable_direct_output<_OutIt, _CharT>, __writer_direct<_OutIt, _CharT>,
-                                           __writer_iterator<_OutIt, _CharT>>>;
+  using type =
+      conditional_t<!same_as<_Container, void>,
+                    __writer_container<_Container>,
+                    conditional_t<__enable_direct_output<_OutIt, _CharT>,
+                                  __writer_direct<_OutIt, _CharT>,
+                                  __writer_iterator<_OutIt, _CharT>>>;
 };
 
 /// The generic formatting buffer.
 template <class _OutIt, __fmt_char_type _CharT>
-requires(output_iterator<_OutIt, const _CharT&>) class _LIBCPP_TEMPLATE_VIS
-    __format_buffer {
+  requires(output_iterator<_OutIt, const _CharT&>)
+class _LIBCPP_TEMPLATE_VIS __format_buffer {
   using _Storage =
-      conditional_t<__enable_direct_output<_OutIt, _CharT>,
-                    __direct_storage<_CharT>, __internal_storage<_CharT>>;
+      conditional_t<__enable_direct_output<_OutIt, _CharT>, __direct_storage<_CharT>, __internal_storage<_CharT>>;
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it)
     requires(same_as<_Storage, __internal_storage<_CharT>>)
-      : __output_(__storage_.__begin(), __storage_.__buffer_size, this), __writer_(_VSTD::move(__out_it)) {}
+      : __output_(__storage_.__begin(), __storage_.__buffer_size, this), __writer_(std::move(__out_it)) {}
 
-  _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it) requires(
-      same_as<_Storage, __direct_storage<_CharT>>)
-      : __output_(_VSTD::__unwrap_iter(__out_it), size_t(-1), this),
-        __writer_(_VSTD::move(__out_it)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __format_buffer(_OutIt __out_it)
+    requires(same_as<_Storage, __direct_storage<_CharT>>)
+      : __output_(std::__unwrap_iter(__out_it), size_t(-1), this), __writer_(std::move(__out_it)) {}
 
   _LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return __output_.__make_output_iterator(); }
 
@@ -372,7 +374,7 @@ public:
 
   _LIBCPP_HIDE_FROM_ABI _OutIt __out_it() && {
     __output_.__flush();
-    return _VSTD::move(__writer_).__out_it();
+    return std::move(__writer_).__out_it();
   }
 
 private:
@@ -411,11 +413,11 @@ struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base {
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __max_size)
-      : __writer_(_VSTD::move(__out_it)), __max_size_(_VSTD::max(_Size(0), __max_size)) {}
+      : __writer_(std::move(__out_it)), __max_size_(std::max(_Size(0), __max_size)) {}
 
   _LIBCPP_HIDE_FROM_ABI void __flush(_CharT* __ptr, size_t __n) {
     if (_Size(__size_) <= __max_size_)
-      __writer_.__flush(__ptr, _VSTD::min(_Size(__n), __max_size_ - __size_));
+      __writer_.__flush(__ptr, std::min(_Size(__n), __max_size_ - __size_));
     __size_ += __n;
   }
 
@@ -441,8 +443,8 @@ class _LIBCPP_TEMPLATE_VIS __format_to_n_buffer_base<_OutIt, _CharT, true> {
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer_base(_OutIt __out_it, _Size __max_size)
-      : __output_(_VSTD::__unwrap_iter(__out_it), __max_size, this),
-        __writer_(_VSTD::move(__out_it)),
+      : __output_(std::__unwrap_iter(__out_it), __max_size, this),
+        __writer_(std::move(__out_it)),
         __max_size_(__max_size) {
     if (__max_size <= 0) [[unlikely]]
       __output_.__reset(__storage_.__begin(), __storage_.__buffer_size);
@@ -466,7 +468,7 @@ public:
     } else if (__size_ < __max_size_) {
       // Copies a part of the internal buffer to the output up to n characters.
       // See __output_buffer<_CharT>::__flush_on_overflow for more information.
-      _Size __s = _VSTD::min(_Size(__n), __max_size_ - __size_);
+      _Size __s = std::min(_Size(__n), __max_size_ - __size_);
       std::copy_n(__ptr, __s, __writer_.__out_it());
       __writer_.__flush(__ptr, __s);
     }
@@ -493,12 +495,12 @@ struct _LIBCPP_TEMPLATE_VIS __format_to_n_buffer final
 
 public:
   _LIBCPP_HIDE_FROM_ABI explicit __format_to_n_buffer(_OutIt __out_it, _Size __max_size)
-      : _Base(_VSTD::move(__out_it), __max_size) {}
+      : _Base(std::move(__out_it), __max_size) {}
   _LIBCPP_HIDE_FROM_ABI auto __make_output_iterator() { return this->__output_.__make_output_iterator(); }
 
   _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __result() && {
     this->__output_.__flush();
-    return {_VSTD::move(this->__writer_).__out_it(), this->__size_};
+    return {std::move(this->__writer_).__out_it(), this->__size_};
   }
 };
 
@@ -529,6 +531,7 @@ public:
 
   struct __iterator {
     using difference_type = ptrdiff_t;
+    using value_type      = _CharT;
 
     _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(__retarget_buffer& __buffer)
         : __buffer_(std::addressof(__buffer)) {}
@@ -551,7 +554,14 @@ public:
   __retarget_buffer& operator=(const __retarget_buffer&) = delete;
 
   _LIBCPP_HIDE_FROM_ABI explicit __retarget_buffer(size_t __size_hint) {
-    auto __result = std::__allocate_at_least(__alloc_, __size_hint ? __size_hint : 256 / sizeof(_CharT));
+    // When the initial size is very small a lot of resizes happen
+    // when elements added. So use a hard-coded minimum size.
+    //
+    // Note a size < 2 will not work
+    // - 0 there is no buffer, while push_back requires 1 empty element.
+    // - 1 multiplied by the grow factor is 1 and thus the buffer never
+    //   grows.
+    auto __result = std::__allocate_at_least(__alloc_, std::max(__size_hint, 256 / sizeof(_CharT)));
     __ptr_        = __result.ptr;
     __capacity_   = __result.count;
   }
@@ -582,9 +592,11 @@ public:
     __size_ += __n;
   }
 
-  template <__fmt_char_type _InCharT, class _UnaryOperation>
-  _LIBCPP_HIDE_FROM_ABI void __transform(const _InCharT* __first, const _InCharT* __last, _UnaryOperation __operation) {
-    _LIBCPP_ASSERT(__first <= __last, "not a valid range");
+  template <contiguous_iterator _Iterator,
+            class _UnaryOperation,
+            __fmt_char_type _InCharT = typename iterator_traits<_Iterator>::value_type>
+  _LIBCPP_HIDE_FROM_ABI void __transform(_Iterator __first, _Iterator __last, _UnaryOperation __operation) {
+    _LIBCPP_ASSERT_INTERNAL(__first <= __last, "not a valid range");
 
     size_t __n = static_cast<size_t>(__last - __first);
     if (__size_ + __n >= __capacity_)
@@ -611,12 +623,12 @@ private:
   _LIBCPP_HIDE_FROM_ABI void __grow_buffer() { __grow_buffer(__capacity_ * 1.6); }
 
   _LIBCPP_HIDE_FROM_ABI void __grow_buffer(size_t __capacity) {
-    _LIBCPP_ASSERT(__capacity > __capacity_, "the buffer must grow");
+    _LIBCPP_ASSERT_INTERNAL(__capacity > __capacity_, "the buffer must grow");
     auto __result = std::__allocate_at_least(__alloc_, __capacity);
     auto __guard  = std::__make_exception_guard([&] {
       allocator_traits<_Alloc>::deallocate(__alloc_, __result.ptr, __result.count);
     });
-    // This shouldn't throw, but just to be safe. Not that at -O1 this
+    // This shouldn't throw, but just to be safe. Note that at -O1 this
     // guard is optimized away so there is no runtime overhead.
     std::uninitialized_move_n(__ptr_, __size_, __result.ptr);
     __guard.__complete();
diff --git a/third_party/libcxx/__format/concepts.h b/third_party/libcxx/__format/concepts.h
index 62552f827..13380e9b9 100644
--- a/third_party/libcxx/__format/concepts.h
+++ b/third_party/libcxx/__format/concepts.h
@@ -13,11 +13,14 @@
 #include <__concepts/same_as.h>
 #include <__concepts/semiregular.h>
 #include <__config>
-#include <__format/format_fwd.h>
 #include <__format/format_parse_context.h>
+#include <__fwd/format.h>
+#include <__fwd/tuple.h>
+#include <__tuple/tuple_size.h>
 #include <__type_traits/is_specialization.h>
+#include <__type_traits/remove_const.h>
+#include <__type_traits/remove_reference.h>
 #include <__utility/pair.h>
-#include <tuple>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -43,17 +46,21 @@ concept __fmt_char_type =
 template <class _CharT>
 using __fmt_iter_for = _CharT*;
 
+template <class _Tp, class _Context, class _Formatter = typename _Context::template formatter_type<remove_const_t<_Tp>>>
+concept __formattable_with =
+    semiregular<_Formatter> &&
+    requires(_Formatter& __f,
+             const _Formatter& __cf,
+             _Tp&& __t,
+             _Context __fc,
+             basic_format_parse_context<typename _Context::char_type> __pc) {
+      { __f.parse(__pc) } -> same_as<typename decltype(__pc)::iterator>;
+      { __cf.format(__t, __fc) } -> same_as<typename _Context::iterator>;
+    };
+
 template <class _Tp, class _CharT>
 concept __formattable =
-    (semiregular<formatter<remove_cvref_t<_Tp>, _CharT>>) &&
-    requires(formatter<remove_cvref_t<_Tp>, _CharT> __f,
-             const formatter<remove_cvref_t<_Tp>, _CharT> __cf,
-             _Tp __t,
-             basic_format_context<__fmt_iter_for<_CharT>, _CharT> __fc,
-             basic_format_parse_context<_CharT> __pc) {
-      { __f.parse(__pc) } -> same_as<typename basic_format_parse_context<_CharT>::iterator>;
-      { __cf.format(__t, __fc) } -> same_as<__fmt_iter_for<_CharT>>;
-    };
+    __formattable_with<remove_reference_t<_Tp>, basic_format_context<__fmt_iter_for<_CharT>, _CharT>>;
 
 #  if _LIBCPP_STD_VER >= 23
 template <class _Tp, class _CharT>
@@ -69,7 +76,7 @@ concept __fmt_pair_like =
     __is_specialization_v<_Tp, pair> || (__is_specialization_v<_Tp, tuple> && tuple_size_v<_Tp> == 2);
 
 #  endif //_LIBCPP_STD_VER >= 23
-#endif //_LIBCPP_STD_VER >= 20
+#endif   //_LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__format/container_adaptor.h b/third_party/libcxx/__format/container_adaptor.h
index 9b66f4b83..9f49ca03b 100644
--- a/third_party/libcxx/__format/container_adaptor.h
+++ b/third_party/libcxx/__format/container_adaptor.h
@@ -10,17 +10,19 @@
 #ifndef _LIBCPP___FORMAT_CONTAINER_ADAPTOR_H
 #define _LIBCPP___FORMAT_CONTAINER_ADAPTOR_H
 
-#include <__availability>
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/formatter.h>
 #include <__format/range_default_formatter.h>
-#include <__ranges/all.h>
+#include <__fwd/queue.h>
+#include <__fwd/stack.h>
 #include <__ranges/ref_view.h>
 #include <__type_traits/is_const.h>
 #include <__type_traits/maybe_const.h>
-#include <queue>
-#include <stack>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__format/escaped_output_table.h b/third_party/libcxx/__format/escaped_output_table.h
index 222847e6a..f7be2dc61 100644
--- a/third_party/libcxx/__format/escaped_output_table.h
+++ b/third_party/libcxx/__format/escaped_output_table.h
@@ -75,14 +75,14 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 23
 
 namespace __escaped_output_table {
+// clang-format off
 
 /// The entries of the characters to escape in format's debug string.
 ///
 /// Contains the entries for [format.string.escaped]/2.2.1.2.1
-///   CE is a Unicode encoding and C corresponds to either a UCS scalar value
-///   whose Unicode property General_Category has a value in the groups
-///   Separator (Z) or Other (C) or to a UCS scalar value which has the Unicode
-///   property Grapheme_Extend=Yes, as described by table 12 of UAX #44
+///   CE is a Unicode encoding and C corresponds to a UCS scalar value whose
+///   Unicode property General_Category has a value in the groups Separator (Z)
+///   or Other (C), as described by table 12 of UAX #44
 ///
 /// Separator (Z) consists of General_Category
 /// - Space_Separator,
@@ -97,7 +97,6 @@ namespace __escaped_output_table {
 /// - Unassigned.
 ///
 /// The data is generated from
-/// - https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
 /// - https://www.unicode.org/Public/UCD/latest/ucd/extracted/DerivedGeneralCategory.txt
 ///
 /// The table is similar to the table
@@ -106,929 +105,755 @@ namespace __escaped_output_table {
 /// table lacks a property, thus having more bits available for the size.
 ///
 /// The data has 2 values:
-/// - bits [0, 10] The size of the range, allowing 2048 elements.
-/// - bits [11, 31] The lower bound code point of the range. The upper bound of
-///   the range is lower bound + size.
-inline constexpr uint32_t __entries[893] = {
-    0x00000020,
-    0x0003f821,
-    0x00056800,
-    0x0018006f,
-    0x001bc001,
-    0x001c0003,
-    0x001c5800,
-    0x001c6800,
-    0x001d1000,
-    0x00241806,
-    0x00298000,
-    0x002ab801,
-    0x002c5801,
-    0x002c802d,
-    0x002df800,
-    0x002e0801,
-    0x002e2001,
-    0x002e3808,
-    0x002f5803,
-    0x002fa810,
-    0x0030800a,
-    0x0030e000,
-    0x00325814,
-    0x00338000,
-    0x0036b007,
-    0x0036f805,
-    0x00373801,
-    0x00375003,
-    0x00387001,
-    0x00388800,
-    0x0039801c,
-    0x003d300a,
-    0x003d900d,
-    0x003f5808,
-    0x003fd802,
-    0x0040b003,
-    0x0040d808,
-    0x00412802,
-    0x00414806,
-    0x0041f800,
-    0x0042c804,
-    0x0042f800,
-    0x00435804,
-    0x00447810,
-    0x00465038,
-    0x0049d000,
-    0x0049e000,
-    0x004a0807,
-    0x004a6800,
-    0x004a8806,
-    0x004b1001,
-    0x004c0800,
-    0x004c2000,
-    0x004c6801,
-    0x004c8801,
-    0x004d4800,
-    0x004d8800,
-    0x004d9802,
-    0x004dd002,
-    0x004df000,
-    0x004e0805,
-    0x004e4801,
-    0x004e6800,
-    0x004e780c,
-    0x004ef000,
-    0x004f1003,
-    0x004ff004,
-    0x00502000,
-    0x00505803,
-    0x00508801,
-    0x00514800,
-    0x00518800,
-    0x0051a000,
-    0x0051b800,
-    0x0051d003,
-    0x00520817,
-    0x0052e800,
-    0x0052f806,
-    0x00538001,
-    0x0053a800,
-    0x0053b80b,
-    0x00542000,
-    0x00547000,
-    0x00549000,
-    0x00554800,
-    0x00558800,
-    0x0055a000,
-    0x0055d002,
-    0x00560807,
-    0x00565000,
-    0x00566802,
-    0x0056880e,
-    0x00571003,
-    0x00579006,
-    0x0057d007,
-    0x00582000,
-    0x00586801,
-    0x00588801,
-    0x00594800,
-    0x00598800,
-    0x0059a000,
-    0x0059d002,
-    0x0059f001,
-    0x005a0805,
-    0x005a4801,
-    0x005a680e,
-    0x005af000,
-    0x005b1003,
-    0x005bc00a,
-    0x005c2000,
-    0x005c5802,
-    0x005c8800,
-    0x005cb002,
-    0x005cd800,
-    0x005ce800,
-    0x005d0002,
-    0x005d2802,
-    0x005d5802,
-    0x005dd004,
-    0x005e0000,
-    0x005e1802,
-    0x005e4800,
-    0x005e6802,
-    0x005e8814,
-    0x005fd805,
-    0x00602000,
-    0x00606800,
-    0x00608800,
-    0x00614800,
-    0x0061d002,
-    0x0061f002,
-    0x00622812,
-    0x0062d801,
-    0x0062f001,
-    0x00631003,
-    0x00638006,
-    0x00640800,
-    0x00646800,
-    0x00648800,
-    0x00654800,
-    0x0065a000,
-    0x0065d002,
-    0x0065f800,
-    0x00661000,
-    0x00662801,
-    0x00664800,
-    0x00666010,
-    0x0066f800,
-    0x00671003,
-    0x00678000,
-    0x0067a00d,
-    0x00686800,
-    0x00688800,
-    0x0069d801,
-    0x0069f000,
-    0x006a0804,
-    0x006a4800,
-    0x006a6800,
-    0x006a8003,
-    0x006ab800,
-    0x006b1003,
-    0x006c0001,
-    0x006c2000,
-    0x006cb802,
-    0x006d9000,
-    0x006de000,
-    0x006df001,
-    0x006e3808,
-    0x006e9005,
-    0x006ef806,
-    0x006f8001,
-    0x006fa80b,
-    0x00718800,
-    0x0071a00a,
-    0x00723807,
-    0x0072e024,
-    0x00741800,
-    0x00742800,
-    0x00745800,
-    0x00752000,
-    0x00753000,
-    0x00758800,
-    0x0075a008,
-    0x0075f001,
-    0x00762800,
-    0x00763808,
-    0x0076d001,
-    0x0077001f,
-    0x0078c001,
-    0x0079a800,
-    0x0079b800,
-    0x0079c800,
-    0x007a4000,
-    0x007b6811,
-    0x007c0004,
-    0x007c3001,
-    0x007c6830,
-    0x007e3000,
-    0x007e6800,
-    0x007ed824,
-    0x00816803,
-    0x00819005,
-    0x0081c801,
-    0x0081e801,
-    0x0082c001,
-    0x0082f002,
-    0x00838803,
-    0x00841000,
-    0x00842801,
-    0x00846800,
-    0x0084e800,
-    0x00863000,
-    0x00864004,
-    0x00867001,
-    0x00924800,
-    0x00927001,
-    0x0092b800,
-    0x0092c800,
-    0x0092f001,
-    0x00944800,
-    0x00947001,
-    0x00958800,
-    0x0095b001,
-    0x0095f800,
-    0x00960800,
-    0x00963001,
-    0x0096b800,
-    0x00988800,
-    0x0098b001,
-    0x009ad804,
-    0x009be802,
-    0x009cd005,
-    0x009fb001,
-    0x009ff001,
-    0x00b40000,
-    0x00b4e802,
-    0x00b7c806,
-    0x00b89002,
-    0x00b8b008,
-    0x00b99001,
-    0x00b9b808,
-    0x00ba900d,
-    0x00bb6800,
-    0x00bb880e,
-    0x00bda001,
-    0x00bdb806,
-    0x00be3000,
-    0x00be480a,
-    0x00bee802,
-    0x00bf5005,
-    0x00bfd005,
-    0x00c05804,
-    0x00c0d005,
-    0x00c3c806,
-    0x00c42801,
-    0x00c54800,
-    0x00c55804,
-    0x00c7b009,
-    0x00c8f803,
-    0x00c93801,
-    0x00c96003,
-    0x00c99000,
-    0x00c9c806,
-    0x00ca0802,
-    0x00cb7001,
-    0x00cba80a,
-    0x00cd6003,
-    0x00ce5005,
-    0x00ced802,
-    0x00d0b801,
-    0x00d0d802,
-    0x00d2b000,
-    0x00d2c008,
-    0x00d31000,
-    0x00d32807,
-    0x00d3980c,
-    0x00d45005,
-    0x00d4d005,
-    0x00d57055,
-    0x00d9a006,
-    0x00d9e000,
-    0x00da1000,
-    0x00da6802,
-    0x00db5808,
-    0x00dbf802,
-    0x00dd1003,
-    0x00dd4001,
-    0x00dd5802,
-    0x00df3000,
-    0x00df4001,
-    0x00df6800,
-    0x00df7802,
-    0x00dfa007,
-    0x00e16007,
-    0x00e1b004,
-    0x00e25002,
-    0x00e44806,
-    0x00e5d801,
-    0x00e6400a,
-    0x00e6a00c,
-    0x00e71006,
-    0x00e76800,
-    0x00e7a000,
-    0x00e7c001,
-    0x00e7d804,
-    0x00ee003f,
-    0x00f8b001,
-    0x00f8f001,
-    0x00fa3001,
-    0x00fa7001,
-    0x00fac000,
-    0x00fad000,
-    0x00fae000,
-    0x00faf000,
-    0x00fbf001,
-    0x00fda800,
-    0x00fe2800,
-    0x00fea001,
-    0x00fee000,
-    0x00ff8001,
-    0x00ffa800,
-    0x00fff810,
-    0x01014007,
-    0x0102f810,
-    0x01039001,
-    0x01047800,
-    0x0104e802,
-    0x0106083e,
-    0x010c6003,
-    0x01213818,
-    0x01225814,
-    0x015ba001,
-    0x015cb000,
-    0x01677802,
-    0x0167a004,
-    0x01693000,
-    0x01694004,
-    0x01697001,
-    0x016b4006,
-    0x016b880e,
-    0x016cb808,
-    0x016d3800,
-    0x016d7800,
-    0x016db800,
-    0x016df800,
-    0x016e3800,
-    0x016e7800,
-    0x016eb800,
-    0x016ef820,
-    0x0172f021,
-    0x0174d000,
-    0x0177a00b,
-    0x017eb019,
-    0x017fe004,
-    0x01815005,
-    0x01820000,
-    0x0184b803,
-    0x01880004,
-    0x01898000,
-    0x018c7800,
-    0x018f200b,
-    0x0190f800,
-    0x05246802,
-    0x05263808,
-    0x05316013,
-    0x05337803,
-    0x0533a009,
-    0x0534f001,
-    0x05378001,
-    0x0537c007,
-    0x053e5804,
-    0x053e9000,
-    0x053ea000,
-    0x053ed017,
-    0x05401000,
-    0x05403000,
-    0x05405800,
-    0x05412801,
-    0x05416003,
-    0x0541d005,
-    0x0543c007,
-    0x05462009,
-    0x0546d017,
-    0x0547f800,
-    0x05493007,
-    0x054a380a,
-    0x054aa00a,
-    0x054be805,
-    0x054d9800,
-    0x054db003,
-    0x054de001,
-    0x054e7000,
-    0x054ed003,
-    0x054f2800,
-    0x054ff800,
-    0x05514805,
-    0x05518801,
-    0x0551a80a,
-    0x05521800,
-    0x05526000,
-    0x05527001,
-    0x0552d001,
-    0x0553e000,
-    0x05558000,
-    0x05559002,
-    0x0555b801,
-    0x0555f001,
-    0x05560800,
-    0x05561817,
-    0x05576001,
-    0x0557b00a,
-    0x05583801,
-    0x05587801,
-    0x0558b808,
-    0x05593800,
-    0x05597800,
-    0x055b6003,
-    0x055f2800,
-    0x055f4000,
-    0x055f6802,
-    0x055fd005,
-    0x06bd200b,
-    0x06be3803,
-    0x06bfe7ff,
-    0x06ffe7ff,
-    0x073fe7ff,
-    0x077fe7ff,
-    0x07bfe103,
-    0x07d37001,
-    0x07d6d025,
-    0x07d8380b,
-    0x07d8c004,
-    0x07d8f000,
-    0x07d9b800,
-    0x07d9e800,
-    0x07d9f800,
-    0x07da1000,
-    0x07da2800,
-    0x07de180f,
-    0x07ec8001,
-    0x07ee4006,
-    0x07ee801f,
-    0x07f0000f,
-    0x07f0d015,
-    0x07f29800,
-    0x07f33800,
-    0x07f36003,
-    0x07f3a800,
-    0x07f7e803,
-    0x07fcf001,
-    0x07fdf802,
-    0x07fe4001,
-    0x07fe8001,
-    0x07fec001,
-    0x07fee802,
-    0x07ff3800,
-    0x07ff780c,
-    0x07fff001,
-    0x08006000,
-    0x08013800,
-    0x0801d800,
-    0x0801f000,
-    0x08027001,
-    0x0802f021,
-    0x0807d804,
-    0x08081803,
-    0x0809a002,
-    0x080c7800,
-    0x080ce802,
-    0x080d082e,
-    0x080fe882,
-    0x0814e802,
-    0x0816880f,
-    0x0817e003,
-    0x08192008,
-    0x081a5804,
-    0x081bb009,
-    0x081cf000,
-    0x081e2003,
-    0x081eb029,
-    0x0824f001,
-    0x08255005,
-    0x0826a003,
-    0x0827e003,
-    0x08294007,
-    0x082b200a,
-    0x082bd800,
-    0x082c5800,
-    0x082c9800,
-    0x082cb000,
-    0x082d1000,
-    0x082d9000,
-    0x082dd000,
-    0x082de842,
-    0x0839b808,
-    0x083ab009,
-    0x083b4017,
-    0x083c3000,
-    0x083d8800,
-    0x083dd844,
-    0x08403001,
-    0x08404800,
-    0x0841b000,
-    0x0841c802,
-    0x0841e801,
-    0x0842b000,
-    0x0844f807,
-    0x0845802f,
-    0x08479800,
-    0x0847b004,
-    0x0848e002,
-    0x0849d004,
-    0x084a003f,
-    0x084dc003,
-    0x084e8001,
-    0x0850080e,
-    0x0850a000,
-    0x0850c000,
-    0x0851b009,
-    0x08524806,
-    0x0852c806,
-    0x0855001f,
-    0x08572805,
-    0x0857b808,
-    0x0859b002,
-    0x085ab001,
-    0x085b9804,
-    0x085c9006,
-    0x085ce80b,
-    0x085d804f,
-    0x08624836,
-    0x0865980c,
-    0x08679806,
-    0x0869200b,
-    0x0869d125,
-    0x0873f800,
-    0x08755002,
-    0x08757001,
-    0x0875904d,
-    0x08794007,
-    0x087a300a,
-    0x087ad015,
-    0x087c1003,
-    0x087c5025,
-    0x087e6013,
-    0x087fb808,
-    0x08800800,
-    0x0881c00e,
-    0x08827003,
-    0x08838000,
-    0x08839801,
-    0x0883b00b,
-    0x08859803,
-    0x0885c801,
-    0x0885e800,
-    0x0886100d,
-    0x08874806,
-    0x0887d008,
-    0x08893804,
-    0x08896808,
-    0x088a4007,
-    0x088b9800,
-    0x088bb80a,
-    0x088db008,
-    0x088e4803,
-    0x088e7800,
-    0x088f0000,
-    0x088fa80a,
-    0x08909000,
-    0x08917802,
-    0x0891a000,
-    0x0891b001,
-    0x0891f000,
-    0x0892083e,
-    0x08943800,
-    0x08944800,
-    0x08947000,
-    0x0894f000,
-    0x08955005,
-    0x0896f800,
-    0x0897180c,
-    0x0897d007,
-    0x08982000,
-    0x08986801,
-    0x08988801,
-    0x08994800,
-    0x08998800,
-    0x0899a000,
-    0x0899d002,
-    0x0899f000,
-    0x089a0000,
-    0x089a2801,
-    0x089a4801,
-    0x089a7001,
-    0x089a880b,
-    0x089b209b,
-    0x08a1c007,
-    0x08a21002,
-    0x08a23000,
-    0x08a2e000,
-    0x08a2f000,
-    0x08a3101d,
-    0x08a58000,
-    0x08a59805,
-    0x08a5d000,
-    0x08a5e800,
-    0x08a5f801,
-    0x08a61001,
-    0x08a64007,
-    0x08a6d0a5,
-    0x08ad7800,
-    0x08ad9005,
-    0x08ade001,
-    0x08adf801,
-    0x08aee023,
-    0x08b19807,
-    0x08b1e800,
-    0x08b1f801,
-    0x08b2280a,
-    0x08b2d005,
-    0x08b36812,
-    0x08b55800,
-    0x08b56800,
-    0x08b58005,
-    0x08b5b800,
-    0x08b5d005,
-    0x08b65035,
-    0x08b8d804,
-    0x08b91003,
-    0x08b93808,
-    0x08ba38b8,
-    0x08c17808,
-    0x08c1c801,
-    0x08c1e063,
-    0x08c7980b,
-    0x08c83801,
-    0x08c85001,
-    0x08c8a000,
-    0x08c8b800,
-    0x08c98000,
-    0x08c9b000,
-    0x08c9c803,
-    0x08c9f000,
-    0x08ca1800,
-    0x08ca3808,
-    0x08cad045,
-    0x08cd4001,
-    0x08cea007,
-    0x08cf0000,
-    0x08cf281a,
-    0x08d00809,
-    0x08d19805,
-    0x08d1d803,
-    0x08d23808,
-    0x08d28805,
-    0x08d2c802,
-    0x08d4500c,
-    0x08d4c001,
-    0x08d5180c,
-    0x08d7c806,
-    0x08d850f5,
-    0x08e04800,
-    0x08e1800d,
-    0x08e1f800,
-    0x08e23009,
-    0x08e36802,
-    0x08e48018,
-    0x08e55006,
-    0x08e59001,
-    0x08e5a84a,
-    0x08e83800,
-    0x08e85000,
-    0x08e98814,
-    0x08ea3808,
-    0x08ead005,
-    0x08eb3000,
-    0x08eb4800,
-    0x08ec7803,
-    0x08eca800,
-    0x08ecb800,
-    0x08ecc806,
-    0x08ed5135,
-    0x08f79801,
-    0x08f7c808,
-    0x08f88800,
-    0x08f9b007,
-    0x08fa0000,
-    0x08fa1000,
-    0x08fad055,
-    0x08fd880e,
-    0x08ff900c,
-    0x091cd065,
-    0x09237800,
-    0x0923a80a,
-    0x092a27ff,
-    0x096a224b,
-    0x097f980c,
-    0x09a18010,
-    0x09a23fff,
-    0x09e23fb8,
-    0x0a323fff,
-    0x0a723fff,
-    0x0ab23fff,
-    0x0af23fff,
-    0x0b3239b8,
-    0x0b51c806,
-    0x0b52f800,
-    0x0b535003,
-    0x0b55f800,
-    0x0b565005,
-    0x0b577006,
-    0x0b57b009,
-    0x0b598006,
-    0x0b5a3009,
-    0x0b5ad000,
-    0x0b5b1000,
-    0x0b5bc004,
-    0x0b5c82af,
-    0x0b74d864,
-    0x0b7a5804,
-    0x0b7c400a,
-    0x0b7d003f,
-    0x0b7f200b,
-    0x0b7f900d,
-    0x0c3fc007,
-    0x0c66b029,
-    0x0c684fff,
-    0x0ca84fff,
-    0x0ce84fff,
-    0x0d284fff,
-    0x0d684ae6,
-    0x0d7fa000,
-    0x0d7fe000,
-    0x0d7ff800,
-    0x0d89180e,
-    0x0d89981c,
-    0x0d8a9801,
-    0x0d8ab00d,
-    0x0d8b4007,
-    0x0d97e7ff,
-    0x0dd7e103,
-    0x0de35804,
-    0x0de3e802,
-    0x0de44806,
-    0x0de4d001,
-    0x0de4e801,
-    0x0de507ff,
-    0x0e2507ff,
-    0x0e6502af,
-    0x0e7e203b,
-    0x0e87b009,
-    0x0e893801,
-    0x0e8b2800,
-    0x0e8b3802,
-    0x0e8b7014,
-    0x0e8c2806,
-    0x0e8d5003,
-    0x0e8f5814,
-    0x0e921002,
-    0x0e923079,
-    0x0e96a00b,
-    0x0e97a00b,
-    0x0e9ab808,
-    0x0e9bc886,
-    0x0ea2a800,
-    0x0ea4e800,
-    0x0ea50001,
-    0x0ea51801,
-    0x0ea53801,
-    0x0ea56800,
-    0x0ea5d000,
-    0x0ea5e000,
-    0x0ea62000,
-    0x0ea83000,
-    0x0ea85801,
-    0x0ea8a800,
-    0x0ea8e800,
-    0x0ea9d000,
-    0x0ea9f800,
-    0x0eaa2800,
-    0x0eaa3802,
-    0x0eaa8800,
-    0x0eb53001,
-    0x0ebe6001,
-    0x0ed00036,
-    0x0ed1d831,
-    0x0ed3a800,
-    0x0ed42000,
-    0x0ed46473,
-    0x0ef8f805,
-    0x0ef95904,
-    0x0f037091,
-    0x0f096809,
-    0x0f09f001,
-    0x0f0a5003,
-    0x0f0a813f,
-    0x0f157011,
-    0x0f176003,
-    0x0f17d004,
-    0x0f1801cf,
-    0x0f276003,
-    0x0f27d2e5,
-    0x0f3f3800,
-    0x0f3f6000,
-    0x0f3f7800,
-    0x0f3ff800,
-    0x0f462801,
-    0x0f46802f,
-    0x0f4a2006,
-    0x0f4a6003,
-    0x0f4ad003,
-    0x0f4b0310,
-    0x0f65a84b,
-    0x0f69f0c1,
-    0x0f702000,
-    0x0f710000,
-    0x0f711800,
-    0x0f712801,
-    0x0f714000,
-    0x0f719800,
-    0x0f71c000,
-    0x0f71d000,
-    0x0f71e005,
-    0x0f721803,
-    0x0f724000,
-    0x0f725000,
-    0x0f726000,
-    0x0f728000,
-    0x0f729800,
-    0x0f72a801,
-    0x0f72c000,
-    0x0f72d000,
-    0x0f72e000,
-    0x0f72f000,
-    0x0f730000,
-    0x0f731800,
-    0x0f732801,
-    0x0f735800,
-    0x0f739800,
-    0x0f73c000,
-    0x0f73e800,
-    0x0f73f800,
-    0x0f745000,
-    0x0f74e004,
-    0x0f752000,
-    0x0f755000,
-    0x0f75e033,
-    0x0f77910d,
-    0x0f816003,
-    0x0f84a00b,
-    0x0f857801,
-    0x0f860000,
-    0x0f868000,
-    0x0f87b009,
-    0x0f8d7037,
-    0x0f90180c,
-    0x0f91e003,
-    0x0f924806,
-    0x0f92900d,
-    0x0f933099,
-    0x0fb6c003,
-    0x0fb76802,
-    0x0fb7e802,
-    0x0fbbb803,
-    0x0fbed005,
-    0x0fbf6003,
-    0x0fbf880e,
-    0x0fc06003,
-    0x0fc24007,
-    0x0fc2d005,
-    0x0fc44007,
-    0x0fc57001,
-    0x0fc5904d,
-    0x0fd2a00b,
-    0x0fd37001,
-    0x0fd3e802,
-    0x0fd44806,
-    0x0fd5f000,
-    0x0fd63007,
-    0x0fd6e003,
-    0x0fd74806,
-    0x0fd7c806,
-    0x0fdc9800,
-    0x0fde5824,
-    0x0fdfd405,
-    0x1537001f,
-    0x15b9d005,
-    0x15c0f001,
-    0x1675100d,
-    0x175f0fff,
-    0x179f0c1e,
-    0x17d0f5e1,
-    0x189a5804};
-
-/// At the end of the valid Unicode code points space a lot of code points are
-/// either reserved or a noncharacter. Adding all these entries to the
-/// lookup table would add 446 entries to the table (in Unicode 14).
-/// Instead the only the start of the region is stored, every code point in
-/// this region needs to be escaped.
-inline constexpr uint32_t __unallocated_region_lower_bound = 0x000323b0;
+/// - bits [0, 13] The size of the range, allowing 16384 elements.
+/// - bits [14, 31] The lower bound code point of the range. The upper bound of
+///   the range is lower bound + size. Note the code expects code units the fit
+///   into 18 bits, instead of the 21 bits needed for the full Unicode range.
+_LIBCPP_HIDE_FROM_ABI inline constexpr uint32_t __entries[711] = {
+    0x00000020 /* 00000000 - 00000020 [   33] */,
+    0x001fc021 /* 0000007f - 000000a0 [   34] */,
+    0x002b4000 /* 000000ad - 000000ad [    1] */,
+    0x00de0001 /* 00000378 - 00000379 [    2] */,
+    0x00e00003 /* 00000380 - 00000383 [    4] */,
+    0x00e2c000 /* 0000038b - 0000038b [    1] */,
+    0x00e34000 /* 0000038d - 0000038d [    1] */,
+    0x00e88000 /* 000003a2 - 000003a2 [    1] */,
+    0x014c0000 /* 00000530 - 00000530 [    1] */,
+    0x0155c001 /* 00000557 - 00000558 [    2] */,
+    0x0162c001 /* 0000058b - 0000058c [    2] */,
+    0x01640000 /* 00000590 - 00000590 [    1] */,
+    0x01720007 /* 000005c8 - 000005cf [    8] */,
+    0x017ac003 /* 000005eb - 000005ee [    4] */,
+    0x017d4010 /* 000005f5 - 00000605 [   17] */,
+    0x01870000 /* 0000061c - 0000061c [    1] */,
+    0x01b74000 /* 000006dd - 000006dd [    1] */,
+    0x01c38001 /* 0000070e - 0000070f [    2] */,
+    0x01d2c001 /* 0000074b - 0000074c [    2] */,
+    0x01ec800d /* 000007b2 - 000007bf [   14] */,
+    0x01fec001 /* 000007fb - 000007fc [    2] */,
+    0x020b8001 /* 0000082e - 0000082f [    2] */,
+    0x020fc000 /* 0000083f - 0000083f [    1] */,
+    0x02170001 /* 0000085c - 0000085d [    2] */,
+    0x0217c000 /* 0000085f - 0000085f [    1] */,
+    0x021ac004 /* 0000086b - 0000086f [    5] */,
+    0x0223c008 /* 0000088f - 00000897 [    9] */,
+    0x02388000 /* 000008e2 - 000008e2 [    1] */,
+    0x02610000 /* 00000984 - 00000984 [    1] */,
+    0x02634001 /* 0000098d - 0000098e [    2] */,
+    0x02644001 /* 00000991 - 00000992 [    2] */,
+    0x026a4000 /* 000009a9 - 000009a9 [    1] */,
+    0x026c4000 /* 000009b1 - 000009b1 [    1] */,
+    0x026cc002 /* 000009b3 - 000009b5 [    3] */,
+    0x026e8001 /* 000009ba - 000009bb [    2] */,
+    0x02714001 /* 000009c5 - 000009c6 [    2] */,
+    0x02724001 /* 000009c9 - 000009ca [    2] */,
+    0x0273c007 /* 000009cf - 000009d6 [    8] */,
+    0x02760003 /* 000009d8 - 000009db [    4] */,
+    0x02778000 /* 000009de - 000009de [    1] */,
+    0x02790001 /* 000009e4 - 000009e5 [    2] */,
+    0x027fc001 /* 000009ff - 00000a00 [    2] */,
+    0x02810000 /* 00000a04 - 00000a04 [    1] */,
+    0x0282c003 /* 00000a0b - 00000a0e [    4] */,
+    0x02844001 /* 00000a11 - 00000a12 [    2] */,
+    0x028a4000 /* 00000a29 - 00000a29 [    1] */,
+    0x028c4000 /* 00000a31 - 00000a31 [    1] */,
+    0x028d0000 /* 00000a34 - 00000a34 [    1] */,
+    0x028dc000 /* 00000a37 - 00000a37 [    1] */,
+    0x028e8001 /* 00000a3a - 00000a3b [    2] */,
+    0x028f4000 /* 00000a3d - 00000a3d [    1] */,
+    0x0290c003 /* 00000a43 - 00000a46 [    4] */,
+    0x02924001 /* 00000a49 - 00000a4a [    2] */,
+    0x02938002 /* 00000a4e - 00000a50 [    3] */,
+    0x02948006 /* 00000a52 - 00000a58 [    7] */,
+    0x02974000 /* 00000a5d - 00000a5d [    1] */,
+    0x0297c006 /* 00000a5f - 00000a65 [    7] */,
+    0x029dc009 /* 00000a77 - 00000a80 [   10] */,
+    0x02a10000 /* 00000a84 - 00000a84 [    1] */,
+    0x02a38000 /* 00000a8e - 00000a8e [    1] */,
+    0x02a48000 /* 00000a92 - 00000a92 [    1] */,
+    0x02aa4000 /* 00000aa9 - 00000aa9 [    1] */,
+    0x02ac4000 /* 00000ab1 - 00000ab1 [    1] */,
+    0x02ad0000 /* 00000ab4 - 00000ab4 [    1] */,
+    0x02ae8001 /* 00000aba - 00000abb [    2] */,
+    0x02b18000 /* 00000ac6 - 00000ac6 [    1] */,
+    0x02b28000 /* 00000aca - 00000aca [    1] */,
+    0x02b38001 /* 00000ace - 00000acf [    2] */,
+    0x02b4400e /* 00000ad1 - 00000adf [   15] */,
+    0x02b90001 /* 00000ae4 - 00000ae5 [    2] */,
+    0x02bc8006 /* 00000af2 - 00000af8 [    7] */,
+    0x02c00000 /* 00000b00 - 00000b00 [    1] */,
+    0x02c10000 /* 00000b04 - 00000b04 [    1] */,
+    0x02c34001 /* 00000b0d - 00000b0e [    2] */,
+    0x02c44001 /* 00000b11 - 00000b12 [    2] */,
+    0x02ca4000 /* 00000b29 - 00000b29 [    1] */,
+    0x02cc4000 /* 00000b31 - 00000b31 [    1] */,
+    0x02cd0000 /* 00000b34 - 00000b34 [    1] */,
+    0x02ce8001 /* 00000b3a - 00000b3b [    2] */,
+    0x02d14001 /* 00000b45 - 00000b46 [    2] */,
+    0x02d24001 /* 00000b49 - 00000b4a [    2] */,
+    0x02d38006 /* 00000b4e - 00000b54 [    7] */,
+    0x02d60003 /* 00000b58 - 00000b5b [    4] */,
+    0x02d78000 /* 00000b5e - 00000b5e [    1] */,
+    0x02d90001 /* 00000b64 - 00000b65 [    2] */,
+    0x02de0009 /* 00000b78 - 00000b81 [   10] */,
+    0x02e10000 /* 00000b84 - 00000b84 [    1] */,
+    0x02e2c002 /* 00000b8b - 00000b8d [    3] */,
+    0x02e44000 /* 00000b91 - 00000b91 [    1] */,
+    0x02e58002 /* 00000b96 - 00000b98 [    3] */,
+    0x02e6c000 /* 00000b9b - 00000b9b [    1] */,
+    0x02e74000 /* 00000b9d - 00000b9d [    1] */,
+    0x02e80002 /* 00000ba0 - 00000ba2 [    3] */,
+    0x02e94002 /* 00000ba5 - 00000ba7 [    3] */,
+    0x02eac002 /* 00000bab - 00000bad [    3] */,
+    0x02ee8003 /* 00000bba - 00000bbd [    4] */,
+    0x02f0c002 /* 00000bc3 - 00000bc5 [    3] */,
+    0x02f24000 /* 00000bc9 - 00000bc9 [    1] */,
+    0x02f38001 /* 00000bce - 00000bcf [    2] */,
+    0x02f44005 /* 00000bd1 - 00000bd6 [    6] */,
+    0x02f6000d /* 00000bd8 - 00000be5 [   14] */,
+    0x02fec004 /* 00000bfb - 00000bff [    5] */,
+    0x03034000 /* 00000c0d - 00000c0d [    1] */,
+    0x03044000 /* 00000c11 - 00000c11 [    1] */,
+    0x030a4000 /* 00000c29 - 00000c29 [    1] */,
+    0x030e8001 /* 00000c3a - 00000c3b [    2] */,
+    0x03114000 /* 00000c45 - 00000c45 [    1] */,
+    0x03124000 /* 00000c49 - 00000c49 [    1] */,
+    0x03138006 /* 00000c4e - 00000c54 [    7] */,
+    0x0315c000 /* 00000c57 - 00000c57 [    1] */,
+    0x0316c001 /* 00000c5b - 00000c5c [    2] */,
+    0x03178001 /* 00000c5e - 00000c5f [    2] */,
+    0x03190001 /* 00000c64 - 00000c65 [    2] */,
+    0x031c0006 /* 00000c70 - 00000c76 [    7] */,
+    0x03234000 /* 00000c8d - 00000c8d [    1] */,
+    0x03244000 /* 00000c91 - 00000c91 [    1] */,
+    0x032a4000 /* 00000ca9 - 00000ca9 [    1] */,
+    0x032d0000 /* 00000cb4 - 00000cb4 [    1] */,
+    0x032e8001 /* 00000cba - 00000cbb [    2] */,
+    0x03314000 /* 00000cc5 - 00000cc5 [    1] */,
+    0x03324000 /* 00000cc9 - 00000cc9 [    1] */,
+    0x03338006 /* 00000cce - 00000cd4 [    7] */,
+    0x0335c005 /* 00000cd7 - 00000cdc [    6] */,
+    0x0337c000 /* 00000cdf - 00000cdf [    1] */,
+    0x03390001 /* 00000ce4 - 00000ce5 [    2] */,
+    0x033c0000 /* 00000cf0 - 00000cf0 [    1] */,
+    0x033d000b /* 00000cf4 - 00000cff [   12] */,
+    0x03434000 /* 00000d0d - 00000d0d [    1] */,
+    0x03444000 /* 00000d11 - 00000d11 [    1] */,
+    0x03514000 /* 00000d45 - 00000d45 [    1] */,
+    0x03524000 /* 00000d49 - 00000d49 [    1] */,
+    0x03540003 /* 00000d50 - 00000d53 [    4] */,
+    0x03590001 /* 00000d64 - 00000d65 [    2] */,
+    0x03600000 /* 00000d80 - 00000d80 [    1] */,
+    0x03610000 /* 00000d84 - 00000d84 [    1] */,
+    0x0365c002 /* 00000d97 - 00000d99 [    3] */,
+    0x036c8000 /* 00000db2 - 00000db2 [    1] */,
+    0x036f0000 /* 00000dbc - 00000dbc [    1] */,
+    0x036f8001 /* 00000dbe - 00000dbf [    2] */,
+    0x0371c002 /* 00000dc7 - 00000dc9 [    3] */,
+    0x0372c003 /* 00000dcb - 00000dce [    4] */,
+    0x03754000 /* 00000dd5 - 00000dd5 [    1] */,
+    0x0375c000 /* 00000dd7 - 00000dd7 [    1] */,
+    0x03780005 /* 00000de0 - 00000de5 [    6] */,
+    0x037c0001 /* 00000df0 - 00000df1 [    2] */,
+    0x037d400b /* 00000df5 - 00000e00 [   12] */,
+    0x038ec003 /* 00000e3b - 00000e3e [    4] */,
+    0x03970024 /* 00000e5c - 00000e80 [   37] */,
+    0x03a0c000 /* 00000e83 - 00000e83 [    1] */,
+    0x03a14000 /* 00000e85 - 00000e85 [    1] */,
+    0x03a2c000 /* 00000e8b - 00000e8b [    1] */,
+    0x03a90000 /* 00000ea4 - 00000ea4 [    1] */,
+    0x03a98000 /* 00000ea6 - 00000ea6 [    1] */,
+    0x03af8001 /* 00000ebe - 00000ebf [    2] */,
+    0x03b14000 /* 00000ec5 - 00000ec5 [    1] */,
+    0x03b1c000 /* 00000ec7 - 00000ec7 [    1] */,
+    0x03b3c000 /* 00000ecf - 00000ecf [    1] */,
+    0x03b68001 /* 00000eda - 00000edb [    2] */,
+    0x03b8001f /* 00000ee0 - 00000eff [   32] */,
+    0x03d20000 /* 00000f48 - 00000f48 [    1] */,
+    0x03db4003 /* 00000f6d - 00000f70 [    4] */,
+    0x03e60000 /* 00000f98 - 00000f98 [    1] */,
+    0x03ef4000 /* 00000fbd - 00000fbd [    1] */,
+    0x03f34000 /* 00000fcd - 00000fcd [    1] */,
+    0x03f6c024 /* 00000fdb - 00000fff [   37] */,
+    0x04318000 /* 000010c6 - 000010c6 [    1] */,
+    0x04320004 /* 000010c8 - 000010cc [    5] */,
+    0x04338001 /* 000010ce - 000010cf [    2] */,
+    0x04924000 /* 00001249 - 00001249 [    1] */,
+    0x04938001 /* 0000124e - 0000124f [    2] */,
+    0x0495c000 /* 00001257 - 00001257 [    1] */,
+    0x04964000 /* 00001259 - 00001259 [    1] */,
+    0x04978001 /* 0000125e - 0000125f [    2] */,
+    0x04a24000 /* 00001289 - 00001289 [    1] */,
+    0x04a38001 /* 0000128e - 0000128f [    2] */,
+    0x04ac4000 /* 000012b1 - 000012b1 [    1] */,
+    0x04ad8001 /* 000012b6 - 000012b7 [    2] */,
+    0x04afc000 /* 000012bf - 000012bf [    1] */,
+    0x04b04000 /* 000012c1 - 000012c1 [    1] */,
+    0x04b18001 /* 000012c6 - 000012c7 [    2] */,
+    0x04b5c000 /* 000012d7 - 000012d7 [    1] */,
+    0x04c44000 /* 00001311 - 00001311 [    1] */,
+    0x04c58001 /* 00001316 - 00001317 [    2] */,
+    0x04d6c001 /* 0000135b - 0000135c [    2] */,
+    0x04df4002 /* 0000137d - 0000137f [    3] */,
+    0x04e68005 /* 0000139a - 0000139f [    6] */,
+    0x04fd8001 /* 000013f6 - 000013f7 [    2] */,
+    0x04ff8001 /* 000013fe - 000013ff [    2] */,
+    0x05a00000 /* 00001680 - 00001680 [    1] */,
+    0x05a74002 /* 0000169d - 0000169f [    3] */,
+    0x05be4006 /* 000016f9 - 000016ff [    7] */,
+    0x05c58008 /* 00001716 - 0000171e [    9] */,
+    0x05cdc008 /* 00001737 - 0000173f [    9] */,
+    0x05d5000b /* 00001754 - 0000175f [   12] */,
+    0x05db4000 /* 0000176d - 0000176d [    1] */,
+    0x05dc4000 /* 00001771 - 00001771 [    1] */,
+    0x05dd000b /* 00001774 - 0000177f [   12] */,
+    0x05f78001 /* 000017de - 000017df [    2] */,
+    0x05fa8005 /* 000017ea - 000017ef [    6] */,
+    0x05fe8005 /* 000017fa - 000017ff [    6] */,
+    0x06038000 /* 0000180e - 0000180e [    1] */,
+    0x06068005 /* 0000181a - 0000181f [    6] */,
+    0x061e4006 /* 00001879 - 0000187f [    7] */,
+    0x062ac004 /* 000018ab - 000018af [    5] */,
+    0x063d8009 /* 000018f6 - 000018ff [   10] */,
+    0x0647c000 /* 0000191f - 0000191f [    1] */,
+    0x064b0003 /* 0000192c - 0000192f [    4] */,
+    0x064f0003 /* 0000193c - 0000193f [    4] */,
+    0x06504002 /* 00001941 - 00001943 [    3] */,
+    0x065b8001 /* 0000196e - 0000196f [    2] */,
+    0x065d400a /* 00001975 - 0000197f [   11] */,
+    0x066b0003 /* 000019ac - 000019af [    4] */,
+    0x06728005 /* 000019ca - 000019cf [    6] */,
+    0x0676c002 /* 000019db - 000019dd [    3] */,
+    0x06870001 /* 00001a1c - 00001a1d [    2] */,
+    0x0697c000 /* 00001a5f - 00001a5f [    1] */,
+    0x069f4001 /* 00001a7d - 00001a7e [    2] */,
+    0x06a28005 /* 00001a8a - 00001a8f [    6] */,
+    0x06a68005 /* 00001a9a - 00001a9f [    6] */,
+    0x06ab8001 /* 00001aae - 00001aaf [    2] */,
+    0x06b3c030 /* 00001acf - 00001aff [   49] */,
+    0x06d34002 /* 00001b4d - 00001b4f [    3] */,
+    0x06dfc000 /* 00001b7f - 00001b7f [    1] */,
+    0x06fd0007 /* 00001bf4 - 00001bfb [    8] */,
+    0x070e0002 /* 00001c38 - 00001c3a [    3] */,
+    0x07128002 /* 00001c4a - 00001c4c [    3] */,
+    0x07224006 /* 00001c89 - 00001c8f [    7] */,
+    0x072ec001 /* 00001cbb - 00001cbc [    2] */,
+    0x07320007 /* 00001cc8 - 00001ccf [    8] */,
+    0x073ec004 /* 00001cfb - 00001cff [    5] */,
+    0x07c58001 /* 00001f16 - 00001f17 [    2] */,
+    0x07c78001 /* 00001f1e - 00001f1f [    2] */,
+    0x07d18001 /* 00001f46 - 00001f47 [    2] */,
+    0x07d38001 /* 00001f4e - 00001f4f [    2] */,
+    0x07d60000 /* 00001f58 - 00001f58 [    1] */,
+    0x07d68000 /* 00001f5a - 00001f5a [    1] */,
+    0x07d70000 /* 00001f5c - 00001f5c [    1] */,
+    0x07d78000 /* 00001f5e - 00001f5e [    1] */,
+    0x07df8001 /* 00001f7e - 00001f7f [    2] */,
+    0x07ed4000 /* 00001fb5 - 00001fb5 [    1] */,
+    0x07f14000 /* 00001fc5 - 00001fc5 [    1] */,
+    0x07f50001 /* 00001fd4 - 00001fd5 [    2] */,
+    0x07f70000 /* 00001fdc - 00001fdc [    1] */,
+    0x07fc0001 /* 00001ff0 - 00001ff1 [    2] */,
+    0x07fd4000 /* 00001ff5 - 00001ff5 [    1] */,
+    0x07ffc010 /* 00001fff - 0000200f [   17] */,
+    0x080a0007 /* 00002028 - 0000202f [    8] */,
+    0x0817c010 /* 0000205f - 0000206f [   17] */,
+    0x081c8001 /* 00002072 - 00002073 [    2] */,
+    0x0823c000 /* 0000208f - 0000208f [    1] */,
+    0x08274002 /* 0000209d - 0000209f [    3] */,
+    0x0830400e /* 000020c1 - 000020cf [   15] */,
+    0x083c400e /* 000020f1 - 000020ff [   15] */,
+    0x08630003 /* 0000218c - 0000218f [    4] */,
+    0x0909c018 /* 00002427 - 0000243f [   25] */,
+    0x0912c014 /* 0000244b - 0000245f [   21] */,
+    0x0add0001 /* 00002b74 - 00002b75 [    2] */,
+    0x0ae58000 /* 00002b96 - 00002b96 [    1] */,
+    0x0b3d0004 /* 00002cf4 - 00002cf8 [    5] */,
+    0x0b498000 /* 00002d26 - 00002d26 [    1] */,
+    0x0b4a0004 /* 00002d28 - 00002d2c [    5] */,
+    0x0b4b8001 /* 00002d2e - 00002d2f [    2] */,
+    0x0b5a0006 /* 00002d68 - 00002d6e [    7] */,
+    0x0b5c400d /* 00002d71 - 00002d7e [   14] */,
+    0x0b65c008 /* 00002d97 - 00002d9f [    9] */,
+    0x0b69c000 /* 00002da7 - 00002da7 [    1] */,
+    0x0b6bc000 /* 00002daf - 00002daf [    1] */,
+    0x0b6dc000 /* 00002db7 - 00002db7 [    1] */,
+    0x0b6fc000 /* 00002dbf - 00002dbf [    1] */,
+    0x0b71c000 /* 00002dc7 - 00002dc7 [    1] */,
+    0x0b73c000 /* 00002dcf - 00002dcf [    1] */,
+    0x0b75c000 /* 00002dd7 - 00002dd7 [    1] */,
+    0x0b77c000 /* 00002ddf - 00002ddf [    1] */,
+    0x0b978021 /* 00002e5e - 00002e7f [   34] */,
+    0x0ba68000 /* 00002e9a - 00002e9a [    1] */,
+    0x0bbd000b /* 00002ef4 - 00002eff [   12] */,
+    0x0bf58019 /* 00002fd6 - 00002fef [   26] */,
+    0x0c000000 /* 00003000 - 00003000 [    1] */,
+    0x0c100000 /* 00003040 - 00003040 [    1] */,
+    0x0c25c001 /* 00003097 - 00003098 [    2] */,
+    0x0c400004 /* 00003100 - 00003104 [    5] */,
+    0x0c4c0000 /* 00003130 - 00003130 [    1] */,
+    0x0c63c000 /* 0000318f - 0000318f [    1] */,
+    0x0c79000a /* 000031e4 - 000031ee [   11] */,
+    0x0c87c000 /* 0000321f - 0000321f [    1] */,
+    0x29234002 /* 0000a48d - 0000a48f [    3] */,
+    0x2931c008 /* 0000a4c7 - 0000a4cf [    9] */,
+    0x298b0013 /* 0000a62c - 0000a63f [   20] */,
+    0x29be0007 /* 0000a6f8 - 0000a6ff [    8] */,
+    0x29f2c004 /* 0000a7cb - 0000a7cf [    5] */,
+    0x29f48000 /* 0000a7d2 - 0000a7d2 [    1] */,
+    0x29f50000 /* 0000a7d4 - 0000a7d4 [    1] */,
+    0x29f68017 /* 0000a7da - 0000a7f1 [   24] */,
+    0x2a0b4002 /* 0000a82d - 0000a82f [    3] */,
+    0x2a0e8005 /* 0000a83a - 0000a83f [    6] */,
+    0x2a1e0007 /* 0000a878 - 0000a87f [    8] */,
+    0x2a318007 /* 0000a8c6 - 0000a8cd [    8] */,
+    0x2a368005 /* 0000a8da - 0000a8df [    6] */,
+    0x2a55000a /* 0000a954 - 0000a95e [   11] */,
+    0x2a5f4002 /* 0000a97d - 0000a97f [    3] */,
+    0x2a738000 /* 0000a9ce - 0000a9ce [    1] */,
+    0x2a768003 /* 0000a9da - 0000a9dd [    4] */,
+    0x2a7fc000 /* 0000a9ff - 0000a9ff [    1] */,
+    0x2a8dc008 /* 0000aa37 - 0000aa3f [    9] */,
+    0x2a938001 /* 0000aa4e - 0000aa4f [    2] */,
+    0x2a968001 /* 0000aa5a - 0000aa5b [    2] */,
+    0x2ab0c017 /* 0000aac3 - 0000aada [   24] */,
+    0x2abdc009 /* 0000aaf7 - 0000ab00 [   10] */,
+    0x2ac1c001 /* 0000ab07 - 0000ab08 [    2] */,
+    0x2ac3c001 /* 0000ab0f - 0000ab10 [    2] */,
+    0x2ac5c008 /* 0000ab17 - 0000ab1f [    9] */,
+    0x2ac9c000 /* 0000ab27 - 0000ab27 [    1] */,
+    0x2acbc000 /* 0000ab2f - 0000ab2f [    1] */,
+    0x2adb0003 /* 0000ab6c - 0000ab6f [    4] */,
+    0x2afb8001 /* 0000abee - 0000abef [    2] */,
+    0x2afe8005 /* 0000abfa - 0000abff [    6] */,
+    0x35e9000b /* 0000d7a4 - 0000d7af [   12] */,
+    0x35f1c003 /* 0000d7c7 - 0000d7ca [    4] */,
+    0x35ff2103 /* 0000d7fc - 0000f8ff [ 8452] */,
+    0x3e9b8001 /* 0000fa6e - 0000fa6f [    2] */,
+    0x3eb68025 /* 0000fada - 0000faff [   38] */,
+    0x3ec1c00b /* 0000fb07 - 0000fb12 [   12] */,
+    0x3ec60004 /* 0000fb18 - 0000fb1c [    5] */,
+    0x3ecdc000 /* 0000fb37 - 0000fb37 [    1] */,
+    0x3ecf4000 /* 0000fb3d - 0000fb3d [    1] */,
+    0x3ecfc000 /* 0000fb3f - 0000fb3f [    1] */,
+    0x3ed08000 /* 0000fb42 - 0000fb42 [    1] */,
+    0x3ed14000 /* 0000fb45 - 0000fb45 [    1] */,
+    0x3ef0c00f /* 0000fbc3 - 0000fbd2 [   16] */,
+    0x3f640001 /* 0000fd90 - 0000fd91 [    2] */,
+    0x3f720006 /* 0000fdc8 - 0000fdce [    7] */,
+    0x3f74001f /* 0000fdd0 - 0000fdef [   32] */,
+    0x3f868005 /* 0000fe1a - 0000fe1f [    6] */,
+    0x3f94c000 /* 0000fe53 - 0000fe53 [    1] */,
+    0x3f99c000 /* 0000fe67 - 0000fe67 [    1] */,
+    0x3f9b0003 /* 0000fe6c - 0000fe6f [    4] */,
+    0x3f9d4000 /* 0000fe75 - 0000fe75 [    1] */,
+    0x3fbf4003 /* 0000fefd - 0000ff00 [    4] */,
+    0x3fefc002 /* 0000ffbf - 0000ffc1 [    3] */,
+    0x3ff20001 /* 0000ffc8 - 0000ffc9 [    2] */,
+    0x3ff40001 /* 0000ffd0 - 0000ffd1 [    2] */,
+    0x3ff60001 /* 0000ffd8 - 0000ffd9 [    2] */,
+    0x3ff74002 /* 0000ffdd - 0000ffdf [    3] */,
+    0x3ff9c000 /* 0000ffe7 - 0000ffe7 [    1] */,
+    0x3ffbc00c /* 0000ffef - 0000fffb [   13] */,
+    0x3fff8001 /* 0000fffe - 0000ffff [    2] */,
+    0x40030000 /* 0001000c - 0001000c [    1] */,
+    0x4009c000 /* 00010027 - 00010027 [    1] */,
+    0x400ec000 /* 0001003b - 0001003b [    1] */,
+    0x400f8000 /* 0001003e - 0001003e [    1] */,
+    0x40138001 /* 0001004e - 0001004f [    2] */,
+    0x40178021 /* 0001005e - 0001007f [   34] */,
+    0x403ec004 /* 000100fb - 000100ff [    5] */,
+    0x4040c003 /* 00010103 - 00010106 [    4] */,
+    0x404d0002 /* 00010134 - 00010136 [    3] */,
+    0x4063c000 /* 0001018f - 0001018f [    1] */,
+    0x40674002 /* 0001019d - 0001019f [    3] */,
+    0x4068402e /* 000101a1 - 000101cf [   47] */,
+    0x407f8081 /* 000101fe - 0001027f [  130] */,
+    0x40a74002 /* 0001029d - 0001029f [    3] */,
+    0x40b4400e /* 000102d1 - 000102df [   15] */,
+    0x40bf0003 /* 000102fc - 000102ff [    4] */,
+    0x40c90008 /* 00010324 - 0001032c [    9] */,
+    0x40d2c004 /* 0001034b - 0001034f [    5] */,
+    0x40dec004 /* 0001037b - 0001037f [    5] */,
+    0x40e78000 /* 0001039e - 0001039e [    1] */,
+    0x40f10003 /* 000103c4 - 000103c7 [    4] */,
+    0x40f58029 /* 000103d6 - 000103ff [   42] */,
+    0x41278001 /* 0001049e - 0001049f [    2] */,
+    0x412a8005 /* 000104aa - 000104af [    6] */,
+    0x41350003 /* 000104d4 - 000104d7 [    4] */,
+    0x413f0003 /* 000104fc - 000104ff [    4] */,
+    0x414a0007 /* 00010528 - 0001052f [    8] */,
+    0x4159000a /* 00010564 - 0001056e [   11] */,
+    0x415ec000 /* 0001057b - 0001057b [    1] */,
+    0x4162c000 /* 0001058b - 0001058b [    1] */,
+    0x4164c000 /* 00010593 - 00010593 [    1] */,
+    0x41658000 /* 00010596 - 00010596 [    1] */,
+    0x41688000 /* 000105a2 - 000105a2 [    1] */,
+    0x416c8000 /* 000105b2 - 000105b2 [    1] */,
+    0x416e8000 /* 000105ba - 000105ba [    1] */,
+    0x416f4042 /* 000105bd - 000105ff [   67] */,
+    0x41cdc008 /* 00010737 - 0001073f [    9] */,
+    0x41d58009 /* 00010756 - 0001075f [   10] */,
+    0x41da0017 /* 00010768 - 0001077f [   24] */,
+    0x41e18000 /* 00010786 - 00010786 [    1] */,
+    0x41ec4000 /* 000107b1 - 000107b1 [    1] */,
+    0x41eec044 /* 000107bb - 000107ff [   69] */,
+    0x42018001 /* 00010806 - 00010807 [    2] */,
+    0x42024000 /* 00010809 - 00010809 [    1] */,
+    0x420d8000 /* 00010836 - 00010836 [    1] */,
+    0x420e4002 /* 00010839 - 0001083b [    3] */,
+    0x420f4001 /* 0001083d - 0001083e [    2] */,
+    0x42158000 /* 00010856 - 00010856 [    1] */,
+    0x4227c007 /* 0001089f - 000108a6 [    8] */,
+    0x422c002f /* 000108b0 - 000108df [   48] */,
+    0x423cc000 /* 000108f3 - 000108f3 [    1] */,
+    0x423d8004 /* 000108f6 - 000108fa [    5] */,
+    0x42470002 /* 0001091c - 0001091e [    3] */,
+    0x424e8004 /* 0001093a - 0001093e [    5] */,
+    0x4250003f /* 00010940 - 0001097f [   64] */,
+    0x426e0003 /* 000109b8 - 000109bb [    4] */,
+    0x42740001 /* 000109d0 - 000109d1 [    2] */,
+    0x42810000 /* 00010a04 - 00010a04 [    1] */,
+    0x4281c004 /* 00010a07 - 00010a0b [    5] */,
+    0x42850000 /* 00010a14 - 00010a14 [    1] */,
+    0x42860000 /* 00010a18 - 00010a18 [    1] */,
+    0x428d8001 /* 00010a36 - 00010a37 [    2] */,
+    0x428ec003 /* 00010a3b - 00010a3e [    4] */,
+    0x42924006 /* 00010a49 - 00010a4f [    7] */,
+    0x42964006 /* 00010a59 - 00010a5f [    7] */,
+    0x42a8001f /* 00010aa0 - 00010abf [   32] */,
+    0x42b9c003 /* 00010ae7 - 00010aea [    4] */,
+    0x42bdc008 /* 00010af7 - 00010aff [    9] */,
+    0x42cd8002 /* 00010b36 - 00010b38 [    3] */,
+    0x42d58001 /* 00010b56 - 00010b57 [    2] */,
+    0x42dcc004 /* 00010b73 - 00010b77 [    5] */,
+    0x42e48006 /* 00010b92 - 00010b98 [    7] */,
+    0x42e7400b /* 00010b9d - 00010ba8 [   12] */,
+    0x42ec004f /* 00010bb0 - 00010bff [   80] */,
+    0x43124036 /* 00010c49 - 00010c7f [   55] */,
+    0x432cc00c /* 00010cb3 - 00010cbf [   13] */,
+    0x433cc006 /* 00010cf3 - 00010cf9 [    7] */,
+    0x434a0007 /* 00010d28 - 00010d2f [    8] */,
+    0x434e8125 /* 00010d3a - 00010e5f [  294] */,
+    0x439fc000 /* 00010e7f - 00010e7f [    1] */,
+    0x43aa8000 /* 00010eaa - 00010eaa [    1] */,
+    0x43ab8001 /* 00010eae - 00010eaf [    2] */,
+    0x43ac804a /* 00010eb2 - 00010efc [   75] */,
+    0x43ca0007 /* 00010f28 - 00010f2f [    8] */,
+    0x43d68015 /* 00010f5a - 00010f6f [   22] */,
+    0x43e28025 /* 00010f8a - 00010faf [   38] */,
+    0x43f30013 /* 00010fcc - 00010fdf [   20] */,
+    0x43fdc008 /* 00010ff7 - 00010fff [    9] */,
+    0x44138003 /* 0001104e - 00011051 [    4] */,
+    0x441d8008 /* 00011076 - 0001107e [    9] */,
+    0x442f4000 /* 000110bd - 000110bd [    1] */,
+    0x4430c00c /* 000110c3 - 000110cf [   13] */,
+    0x443a4006 /* 000110e9 - 000110ef [    7] */,
+    0x443e8005 /* 000110fa - 000110ff [    6] */,
+    0x444d4000 /* 00011135 - 00011135 [    1] */,
+    0x44520007 /* 00011148 - 0001114f [    8] */,
+    0x445dc008 /* 00011177 - 0001117f [    9] */,
+    0x44780000 /* 000111e0 - 000111e0 [    1] */,
+    0x447d400a /* 000111f5 - 000111ff [   11] */,
+    0x44848000 /* 00011212 - 00011212 [    1] */,
+    0x4490803d /* 00011242 - 0001127f [   62] */,
+    0x44a1c000 /* 00011287 - 00011287 [    1] */,
+    0x44a24000 /* 00011289 - 00011289 [    1] */,
+    0x44a38000 /* 0001128e - 0001128e [    1] */,
+    0x44a78000 /* 0001129e - 0001129e [    1] */,
+    0x44aa8005 /* 000112aa - 000112af [    6] */,
+    0x44bac004 /* 000112eb - 000112ef [    5] */,
+    0x44be8005 /* 000112fa - 000112ff [    6] */,
+    0x44c10000 /* 00011304 - 00011304 [    1] */,
+    0x44c34001 /* 0001130d - 0001130e [    2] */,
+    0x44c44001 /* 00011311 - 00011312 [    2] */,
+    0x44ca4000 /* 00011329 - 00011329 [    1] */,
+    0x44cc4000 /* 00011331 - 00011331 [    1] */,
+    0x44cd0000 /* 00011334 - 00011334 [    1] */,
+    0x44ce8000 /* 0001133a - 0001133a [    1] */,
+    0x44d14001 /* 00011345 - 00011346 [    2] */,
+    0x44d24001 /* 00011349 - 0001134a [    2] */,
+    0x44d38001 /* 0001134e - 0001134f [    2] */,
+    0x44d44005 /* 00011351 - 00011356 [    6] */,
+    0x44d60004 /* 00011358 - 0001135c [    5] */,
+    0x44d90001 /* 00011364 - 00011365 [    2] */,
+    0x44db4002 /* 0001136d - 0001136f [    3] */,
+    0x44dd408a /* 00011375 - 000113ff [  139] */,
+    0x45170000 /* 0001145c - 0001145c [    1] */,
+    0x4518801d /* 00011462 - 0001147f [   30] */,
+    0x45320007 /* 000114c8 - 000114cf [    8] */,
+    0x453680a5 /* 000114da - 0001157f [  166] */,
+    0x456d8001 /* 000115b6 - 000115b7 [    2] */,
+    0x45778021 /* 000115de - 000115ff [   34] */,
+    0x4591400a /* 00011645 - 0001164f [   11] */,
+    0x45968005 /* 0001165a - 0001165f [    6] */,
+    0x459b4012 /* 0001166d - 0001167f [   19] */,
+    0x45ae8005 /* 000116ba - 000116bf [    6] */,
+    0x45b28035 /* 000116ca - 000116ff [   54] */,
+    0x45c6c001 /* 0001171b - 0001171c [    2] */,
+    0x45cb0003 /* 0001172c - 0001172f [    4] */,
+    0x45d1c0b8 /* 00011747 - 000117ff [  185] */,
+    0x460f0063 /* 0001183c - 0001189f [  100] */,
+    0x463cc00b /* 000118f3 - 000118fe [   12] */,
+    0x4641c001 /* 00011907 - 00011908 [    2] */,
+    0x46428001 /* 0001190a - 0001190b [    2] */,
+    0x46450000 /* 00011914 - 00011914 [    1] */,
+    0x4645c000 /* 00011917 - 00011917 [    1] */,
+    0x464d8000 /* 00011936 - 00011936 [    1] */,
+    0x464e4001 /* 00011939 - 0001193a [    2] */,
+    0x4651c008 /* 00011947 - 0001194f [    9] */,
+    0x46568045 /* 0001195a - 0001199f [   70] */,
+    0x466a0001 /* 000119a8 - 000119a9 [    2] */,
+    0x46760001 /* 000119d8 - 000119d9 [    2] */,
+    0x4679401a /* 000119e5 - 000119ff [   27] */,
+    0x46920007 /* 00011a48 - 00011a4f [    8] */,
+    0x46a8c00c /* 00011aa3 - 00011aaf [   13] */,
+    0x46be4006 /* 00011af9 - 00011aff [    7] */,
+    0x46c280f5 /* 00011b0a - 00011bff [  246] */,
+    0x47024000 /* 00011c09 - 00011c09 [    1] */,
+    0x470dc000 /* 00011c37 - 00011c37 [    1] */,
+    0x47118009 /* 00011c46 - 00011c4f [   10] */,
+    0x471b4002 /* 00011c6d - 00011c6f [    3] */,
+    0x47240001 /* 00011c90 - 00011c91 [    2] */,
+    0x472a0000 /* 00011ca8 - 00011ca8 [    1] */,
+    0x472dc048 /* 00011cb7 - 00011cff [   73] */,
+    0x4741c000 /* 00011d07 - 00011d07 [    1] */,
+    0x47428000 /* 00011d0a - 00011d0a [    1] */,
+    0x474dc002 /* 00011d37 - 00011d39 [    3] */,
+    0x474ec000 /* 00011d3b - 00011d3b [    1] */,
+    0x474f8000 /* 00011d3e - 00011d3e [    1] */,
+    0x47520007 /* 00011d48 - 00011d4f [    8] */,
+    0x47568005 /* 00011d5a - 00011d5f [    6] */,
+    0x47598000 /* 00011d66 - 00011d66 [    1] */,
+    0x475a4000 /* 00011d69 - 00011d69 [    1] */,
+    0x4763c000 /* 00011d8f - 00011d8f [    1] */,
+    0x47648000 /* 00011d92 - 00011d92 [    1] */,
+    0x47664006 /* 00011d99 - 00011d9f [    7] */,
+    0x476a8135 /* 00011daa - 00011edf [  310] */,
+    0x47be4006 /* 00011ef9 - 00011eff [    7] */,
+    0x47c44000 /* 00011f11 - 00011f11 [    1] */,
+    0x47cec002 /* 00011f3b - 00011f3d [    3] */,
+    0x47d68055 /* 00011f5a - 00011faf [   86] */,
+    0x47ec400e /* 00011fb1 - 00011fbf [   15] */,
+    0x47fc800c /* 00011ff2 - 00011ffe [   13] */,
+    0x48e68065 /* 0001239a - 000123ff [  102] */,
+    0x491bc000 /* 0001246f - 0001246f [    1] */,
+    0x491d400a /* 00012475 - 0001247f [   11] */,
+    0x49510a4b /* 00012544 - 00012f8f [ 2636] */,
+    0x4bfcc00c /* 00012ff3 - 00012fff [   13] */,
+    0x4d0c000f /* 00013430 - 0001343f [   16] */,
+    0x4d158fa9 /* 00013456 - 000143ff [ 4010] */,
+    0x5191e1b8 /* 00014647 - 000167ff [ 8633] */,
+    0x5a8e4006 /* 00016a39 - 00016a3f [    7] */,
+    0x5a97c000 /* 00016a5f - 00016a5f [    1] */,
+    0x5a9a8003 /* 00016a6a - 00016a6d [    4] */,
+    0x5aafc000 /* 00016abf - 00016abf [    1] */,
+    0x5ab28005 /* 00016aca - 00016acf [    6] */,
+    0x5abb8001 /* 00016aee - 00016aef [    2] */,
+    0x5abd8009 /* 00016af6 - 00016aff [   10] */,
+    0x5ad18009 /* 00016b46 - 00016b4f [   10] */,
+    0x5ad68000 /* 00016b5a - 00016b5a [    1] */,
+    0x5ad88000 /* 00016b62 - 00016b62 [    1] */,
+    0x5ade0004 /* 00016b78 - 00016b7c [    5] */,
+    0x5ae402af /* 00016b90 - 00016e3f [  688] */,
+    0x5ba6c064 /* 00016e9b - 00016eff [  101] */,
+    0x5bd2c003 /* 00016f4b - 00016f4e [    4] */,
+    0x5be20006 /* 00016f88 - 00016f8e [    7] */,
+    0x5be8003f /* 00016fa0 - 00016fdf [   64] */,
+    0x5bf9400a /* 00016fe5 - 00016fef [   11] */,
+    0x5bfc800d /* 00016ff2 - 00016fff [   14] */,
+    0x61fe0007 /* 000187f8 - 000187ff [    8] */,
+    0x63358029 /* 00018cd6 - 00018cff [   42] */,
+    0x634262e6 /* 00018d09 - 0001afef [ 8935] */,
+    0x6bfd0000 /* 0001aff4 - 0001aff4 [    1] */,
+    0x6bff0000 /* 0001affc - 0001affc [    1] */,
+    0x6bffc000 /* 0001afff - 0001afff [    1] */,
+    0x6c48c00e /* 0001b123 - 0001b131 [   15] */,
+    0x6c4cc01c /* 0001b133 - 0001b14f [   29] */,
+    0x6c54c001 /* 0001b153 - 0001b154 [    2] */,
+    0x6c55800d /* 0001b156 - 0001b163 [   14] */,
+    0x6c5a0007 /* 0001b168 - 0001b16f [    8] */,
+    0x6cbf0903 /* 0001b2fc - 0001bbff [ 2308] */,
+    0x6f1ac004 /* 0001bc6b - 0001bc6f [    5] */,
+    0x6f1f4002 /* 0001bc7d - 0001bc7f [    3] */,
+    0x6f224006 /* 0001bc89 - 0001bc8f [    7] */,
+    0x6f268001 /* 0001bc9a - 0001bc9b [    2] */,
+    0x6f28125f /* 0001bca0 - 0001ceff [ 4704] */,
+    0x73cb8001 /* 0001cf2e - 0001cf2f [    2] */,
+    0x73d1c008 /* 0001cf47 - 0001cf4f [    9] */,
+    0x73f1003b /* 0001cfc4 - 0001cfff [   60] */,
+    0x743d8009 /* 0001d0f6 - 0001d0ff [   10] */,
+    0x7449c001 /* 0001d127 - 0001d128 [    2] */,
+    0x745cc007 /* 0001d173 - 0001d17a [    8] */,
+    0x747ac014 /* 0001d1eb - 0001d1ff [   21] */,
+    0x74918079 /* 0001d246 - 0001d2bf [  122] */,
+    0x74b5000b /* 0001d2d4 - 0001d2df [   12] */,
+    0x74bd000b /* 0001d2f4 - 0001d2ff [   12] */,
+    0x74d5c008 /* 0001d357 - 0001d35f [    9] */,
+    0x74de4086 /* 0001d379 - 0001d3ff [  135] */,
+    0x75154000 /* 0001d455 - 0001d455 [    1] */,
+    0x75274000 /* 0001d49d - 0001d49d [    1] */,
+    0x75280001 /* 0001d4a0 - 0001d4a1 [    2] */,
+    0x7528c001 /* 0001d4a3 - 0001d4a4 [    2] */,
+    0x7529c001 /* 0001d4a7 - 0001d4a8 [    2] */,
+    0x752b4000 /* 0001d4ad - 0001d4ad [    1] */,
+    0x752e8000 /* 0001d4ba - 0001d4ba [    1] */,
+    0x752f0000 /* 0001d4bc - 0001d4bc [    1] */,
+    0x75310000 /* 0001d4c4 - 0001d4c4 [    1] */,
+    0x75418000 /* 0001d506 - 0001d506 [    1] */,
+    0x7542c001 /* 0001d50b - 0001d50c [    2] */,
+    0x75454000 /* 0001d515 - 0001d515 [    1] */,
+    0x75474000 /* 0001d51d - 0001d51d [    1] */,
+    0x754e8000 /* 0001d53a - 0001d53a [    1] */,
+    0x754fc000 /* 0001d53f - 0001d53f [    1] */,
+    0x75514000 /* 0001d545 - 0001d545 [    1] */,
+    0x7551c002 /* 0001d547 - 0001d549 [    3] */,
+    0x75544000 /* 0001d551 - 0001d551 [    1] */,
+    0x75a98001 /* 0001d6a6 - 0001d6a7 [    2] */,
+    0x75f30001 /* 0001d7cc - 0001d7cd [    2] */,
+    0x76a3000e /* 0001da8c - 0001da9a [   15] */,
+    0x76a80000 /* 0001daa0 - 0001daa0 [    1] */,
+    0x76ac044f /* 0001dab0 - 0001deff [ 1104] */,
+    0x77c7c005 /* 0001df1f - 0001df24 [    6] */,
+    0x77cac0d4 /* 0001df2b - 0001dfff [  213] */,
+    0x7801c000 /* 0001e007 - 0001e007 [    1] */,
+    0x78064001 /* 0001e019 - 0001e01a [    2] */,
+    0x78088000 /* 0001e022 - 0001e022 [    1] */,
+    0x78094000 /* 0001e025 - 0001e025 [    1] */,
+    0x780ac004 /* 0001e02b - 0001e02f [    5] */,
+    0x781b8020 /* 0001e06e - 0001e08e [   33] */,
+    0x7824006f /* 0001e090 - 0001e0ff [  112] */,
+    0x784b4002 /* 0001e12d - 0001e12f [    3] */,
+    0x784f8001 /* 0001e13e - 0001e13f [    2] */,
+    0x78528003 /* 0001e14a - 0001e14d [    4] */,
+    0x7854013f /* 0001e150 - 0001e28f [  320] */,
+    0x78abc010 /* 0001e2af - 0001e2bf [   17] */,
+    0x78be8004 /* 0001e2fa - 0001e2fe [    5] */,
+    0x78c001cf /* 0001e300 - 0001e4cf [  464] */,
+    0x793e82e5 /* 0001e4fa - 0001e7df [  742] */,
+    0x79f9c000 /* 0001e7e7 - 0001e7e7 [    1] */,
+    0x79fb0000 /* 0001e7ec - 0001e7ec [    1] */,
+    0x79fbc000 /* 0001e7ef - 0001e7ef [    1] */,
+    0x79ffc000 /* 0001e7ff - 0001e7ff [    1] */,
+    0x7a314001 /* 0001e8c5 - 0001e8c6 [    2] */,
+    0x7a35c028 /* 0001e8d7 - 0001e8ff [   41] */,
+    0x7a530003 /* 0001e94c - 0001e94f [    4] */,
+    0x7a568003 /* 0001e95a - 0001e95d [    4] */,
+    0x7a580310 /* 0001e960 - 0001ec70 [  785] */,
+    0x7b2d404b /* 0001ecb5 - 0001ed00 [   76] */,
+    0x7b4f80c1 /* 0001ed3e - 0001edff [  194] */,
+    0x7b810000 /* 0001ee04 - 0001ee04 [    1] */,
+    0x7b880000 /* 0001ee20 - 0001ee20 [    1] */,
+    0x7b88c000 /* 0001ee23 - 0001ee23 [    1] */,
+    0x7b894001 /* 0001ee25 - 0001ee26 [    2] */,
+    0x7b8a0000 /* 0001ee28 - 0001ee28 [    1] */,
+    0x7b8cc000 /* 0001ee33 - 0001ee33 [    1] */,
+    0x7b8e0000 /* 0001ee38 - 0001ee38 [    1] */,
+    0x7b8e8000 /* 0001ee3a - 0001ee3a [    1] */,
+    0x7b8f0005 /* 0001ee3c - 0001ee41 [    6] */,
+    0x7b90c003 /* 0001ee43 - 0001ee46 [    4] */,
+    0x7b920000 /* 0001ee48 - 0001ee48 [    1] */,
+    0x7b928000 /* 0001ee4a - 0001ee4a [    1] */,
+    0x7b930000 /* 0001ee4c - 0001ee4c [    1] */,
+    0x7b940000 /* 0001ee50 - 0001ee50 [    1] */,
+    0x7b94c000 /* 0001ee53 - 0001ee53 [    1] */,
+    0x7b954001 /* 0001ee55 - 0001ee56 [    2] */,
+    0x7b960000 /* 0001ee58 - 0001ee58 [    1] */,
+    0x7b968000 /* 0001ee5a - 0001ee5a [    1] */,
+    0x7b970000 /* 0001ee5c - 0001ee5c [    1] */,
+    0x7b978000 /* 0001ee5e - 0001ee5e [    1] */,
+    0x7b980000 /* 0001ee60 - 0001ee60 [    1] */,
+    0x7b98c000 /* 0001ee63 - 0001ee63 [    1] */,
+    0x7b994001 /* 0001ee65 - 0001ee66 [    2] */,
+    0x7b9ac000 /* 0001ee6b - 0001ee6b [    1] */,
+    0x7b9cc000 /* 0001ee73 - 0001ee73 [    1] */,
+    0x7b9e0000 /* 0001ee78 - 0001ee78 [    1] */,
+    0x7b9f4000 /* 0001ee7d - 0001ee7d [    1] */,
+    0x7b9fc000 /* 0001ee7f - 0001ee7f [    1] */,
+    0x7ba28000 /* 0001ee8a - 0001ee8a [    1] */,
+    0x7ba70004 /* 0001ee9c - 0001eea0 [    5] */,
+    0x7ba90000 /* 0001eea4 - 0001eea4 [    1] */,
+    0x7baa8000 /* 0001eeaa - 0001eeaa [    1] */,
+    0x7baf0033 /* 0001eebc - 0001eeef [   52] */,
+    0x7bbc810d /* 0001eef2 - 0001efff [  270] */,
+    0x7c0b0003 /* 0001f02c - 0001f02f [    4] */,
+    0x7c25000b /* 0001f094 - 0001f09f [   12] */,
+    0x7c2bc001 /* 0001f0af - 0001f0b0 [    2] */,
+    0x7c300000 /* 0001f0c0 - 0001f0c0 [    1] */,
+    0x7c340000 /* 0001f0d0 - 0001f0d0 [    1] */,
+    0x7c3d8009 /* 0001f0f6 - 0001f0ff [   10] */,
+    0x7c6b8037 /* 0001f1ae - 0001f1e5 [   56] */,
+    0x7c80c00c /* 0001f203 - 0001f20f [   13] */,
+    0x7c8f0003 /* 0001f23c - 0001f23f [    4] */,
+    0x7c924006 /* 0001f249 - 0001f24f [    7] */,
+    0x7c94800d /* 0001f252 - 0001f25f [   14] */,
+    0x7c998099 /* 0001f266 - 0001f2ff [  154] */,
+    0x7db60003 /* 0001f6d8 - 0001f6db [    4] */,
+    0x7dbb4002 /* 0001f6ed - 0001f6ef [    3] */,
+    0x7dbf4002 /* 0001f6fd - 0001f6ff [    3] */,
+    0x7dddc003 /* 0001f777 - 0001f77a [    4] */,
+    0x7df68005 /* 0001f7da - 0001f7df [    6] */,
+    0x7dfb0003 /* 0001f7ec - 0001f7ef [    4] */,
+    0x7dfc400e /* 0001f7f1 - 0001f7ff [   15] */,
+    0x7e030003 /* 0001f80c - 0001f80f [    4] */,
+    0x7e120007 /* 0001f848 - 0001f84f [    8] */,
+    0x7e168005 /* 0001f85a - 0001f85f [    6] */,
+    0x7e220007 /* 0001f888 - 0001f88f [    8] */,
+    0x7e2b8001 /* 0001f8ae - 0001f8af [    2] */,
+    0x7e2c804d /* 0001f8b2 - 0001f8ff [   78] */,
+    0x7e95000b /* 0001fa54 - 0001fa5f [   12] */,
+    0x7e9b8001 /* 0001fa6e - 0001fa6f [    2] */,
+    0x7e9f4002 /* 0001fa7d - 0001fa7f [    3] */,
+    0x7ea24006 /* 0001fa89 - 0001fa8f [    7] */,
+    0x7eaf8000 /* 0001fabe - 0001fabe [    1] */,
+    0x7eb18007 /* 0001fac6 - 0001facd [    8] */,
+    0x7eb70003 /* 0001fadc - 0001fadf [    4] */,
+    0x7eba4006 /* 0001fae9 - 0001faef [    7] */,
+    0x7ebe4006 /* 0001faf9 - 0001faff [    7] */,
+    0x7ee4c000 /* 0001fb93 - 0001fb93 [    1] */,
+    0x7ef2c024 /* 0001fbcb - 0001fbef [   37] */,
+    0x7efe8405 /* 0001fbfa - 0001ffff [ 1030] */,
+    0xa9b8001f /* 0002a6e0 - 0002a6ff [   32] */,
+    0xadce8005 /* 0002b73a - 0002b73f [    6] */,
+    0xae078001 /* 0002b81e - 0002b81f [    2] */,
+    0xb3a8800d /* 0002cea2 - 0002ceaf [   14] */,
+    0xbaf8400e /* 0002ebe1 - 0002ebef [   15] */,
+    0xbb9789a1 /* 0002ee5e - 0002f7ff [ 2466] */,
+    0xbe8785e1 /* 0002fa1e - 0002ffff [ 1506] */,
+    0xc4d2c004 /* 0003134b - 0003134f [    5] */};
 
 /// Returns whether the code unit needs to be escaped.
 ///
-/// \pre The code point is a valid Unicode code point.
+/// At the end of the valid Unicode code points space a lot of code points are
+/// either reserved or a noncharacter. Adding all these entries to the
+/// lookup table would greatly increase the size of the table. Instead these
+/// entries are manually processed. In this large area of reserved code points,
+/// there is a small area of extended graphemes that should not be escaped
+/// unconditionally. This is also manually coded. See the generation script for
+/// more details.
+
+///
+/// \\pre The code point is a valid Unicode code point.
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool __needs_escape(const char32_t __code_point) noexcept {
-  // Since __unallocated_region_lower_bound contains the unshifted range do the
-  // comparison without shifting.
-  if (__code_point >= __unallocated_region_lower_bound)
+
+  // The entries in the gap at the end.
+  if(__code_point >= 0x000e0100 && __code_point <= 0x000e01ef)
+     return false;
+
+  // The entries at the end.
+  if (__code_point >= 0x000323b0)
     return true;
 
-  ptrdiff_t __i = std::ranges::upper_bound(__entries, (__code_point << 11) | 0x7ffu) - __entries;
+  ptrdiff_t __i = std::ranges::upper_bound(__entries, (__code_point << 14) | 0x3fffu) - __entries;
   if (__i == 0)
     return false;
 
   --__i;
-  uint32_t __upper_bound = (__entries[__i] >> 11) + (__entries[__i] & 0x7ffu);
+  uint32_t __upper_bound = (__entries[__i] >> 14) + (__entries[__i] & 0x3fffu);
   return __code_point <= __upper_bound;
 }
 
+// clang-format on
 } // namespace __escaped_output_table
 
 #endif //_LIBCPP_STD_VER >= 23
diff --git a/third_party/libcxx/__format/extended_grapheme_cluster_table.h b/third_party/libcxx/__format/extended_grapheme_cluster_table.h
index bd6d39fdc..48581d8a5 100644
--- a/third_party/libcxx/__format/extended_grapheme_cluster_table.h
+++ b/third_party/libcxx/__format/extended_grapheme_cluster_table.h
@@ -124,7 +124,8 @@ enum class __property : uint8_t {
 /// this approach uses less space for the data and is about 4% faster in the
 /// following benchmark.
 /// libcxx/benchmarks/std_format_spec_string_unicode.bench.cpp
-inline constexpr uint32_t __entries[1496] = {
+// clang-format off
+_LIBCPP_HIDE_FROM_ABI inline constexpr uint32_t __entries[1496] = {
     0x00000091,
     0x00005005,
     0x00005811,
@@ -1621,6 +1622,7 @@ inline constexpr uint32_t __entries[1496] = {
     0x707787f1,
     0x707b87f1,
     0x707f80f1};
+// clang-format on
 
 /// Returns the extended grapheme cluster bondary property of a code point.
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __property __get_property(const char32_t __code_point) noexcept {
diff --git a/third_party/libcxx/__format/format_arg.h b/third_party/libcxx/__format/format_arg.h
index a27da8d74..aa02f81dc 100644
--- a/third_party/libcxx/__format/format_arg.h
+++ b/third_party/libcxx/__format/format_arg.h
@@ -13,24 +13,27 @@
 #include <__assert>
 #include <__concepts/arithmetic.h>
 #include <__config>
-#include <__format/format_error.h>
-#include <__format/format_fwd.h>
+#include <__format/concepts.h>
 #include <__format/format_parse_context.h>
 #include <__functional/invoke.h>
+#include <__fwd/format.h>
 #include <__memory/addressof.h>
 #include <__type_traits/conditional.h>
-#include <__type_traits/is_const.h>
-#include <__utility/declval.h>
+#include <__type_traits/remove_const.h>
 #include <__utility/forward.h>
+#include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <__variant/monostate.h>
-#include <string>
+#include <cstdint>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -54,7 +57,7 @@ namespace __format {
 /// handle to satisfy the user observable behaviour. The internal function
 /// __visit_format_arg doesn't do this wrapping. So in the format functions
 /// this function is used to avoid unneeded overhead.
-enum class _LIBCPP_ENUM_VIS __arg_t : uint8_t {
+enum class __arg_t : uint8_t {
   __none,
   __boolean,
   __char_type,
@@ -74,17 +77,17 @@ enum class _LIBCPP_ENUM_VIS __arg_t : uint8_t {
 };
 
 inline constexpr unsigned __packed_arg_t_bits = 5;
-inline constexpr uint8_t __packed_arg_t_mask = 0x1f;
+inline constexpr uint8_t __packed_arg_t_mask  = 0x1f;
 
 inline constexpr unsigned __packed_types_storage_bits = 64;
-inline constexpr unsigned __packed_types_max = __packed_types_storage_bits / __packed_arg_t_bits;
+inline constexpr unsigned __packed_types_max          = __packed_types_storage_bits / __packed_arg_t_bits;
 
-_LIBCPP_HIDE_FROM_ABI
-constexpr bool __use_packed_format_arg_store(size_t __size) { return __size <= __packed_types_max; }
+_LIBCPP_HIDE_FROM_ABI constexpr bool __use_packed_format_arg_store(size_t __size) {
+  return __size <= __packed_types_max;
+}
 
-_LIBCPP_HIDE_FROM_ABI
-constexpr __arg_t __get_packed_type(uint64_t __types, size_t __id) {
-  _LIBCPP_ASSERT(__id <= __packed_types_max, "");
+_LIBCPP_HIDE_FROM_ABI constexpr __arg_t __get_packed_type(uint64_t __types, size_t __id) {
+  _LIBCPP_ASSERT_INTERNAL(__id <= __packed_types_max, "");
 
   if (__id > 0)
     __types >>= __id * __packed_arg_t_bits;
@@ -94,58 +97,110 @@ constexpr __arg_t __get_packed_type(uint64_t __types, size_t __id) {
 
 } // namespace __format
 
-// This function is not user obervable, so it can directly use the non-standard
+// This function is not user observable, so it can directly use the non-standard
 // types of the "variant". See __arg_t for more details.
 template <class _Visitor, class _Context>
-_LIBCPP_HIDE_FROM_ABI decltype(auto)
-__visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
+_LIBCPP_HIDE_FROM_ABI decltype(auto) __visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
   switch (__arg.__type_) {
   case __format::__arg_t::__none:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__monostate_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__monostate_);
   case __format::__arg_t::__boolean:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__boolean_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__boolean_);
   case __format::__arg_t::__char_type:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__char_type_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__char_type_);
   case __format::__arg_t::__int:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__int_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__int_);
   case __format::__arg_t::__long_long:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__long_long_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__long_long_);
   case __format::__arg_t::__i128:
 #  ifndef _LIBCPP_HAS_NO_INT128
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__i128_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__i128_);
 #  else
     __libcpp_unreachable();
 #  endif
   case __format::__arg_t::__unsigned:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__unsigned_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__unsigned_);
   case __format::__arg_t::__unsigned_long_long:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__unsigned_long_long_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__unsigned_long_long_);
   case __format::__arg_t::__u128:
 #  ifndef _LIBCPP_HAS_NO_INT128
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__u128_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__u128_);
 #  else
     __libcpp_unreachable();
 #  endif
   case __format::__arg_t::__float:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__float_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__float_);
   case __format::__arg_t::__double:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__double_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__double_);
   case __format::__arg_t::__long_double:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__long_double_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__long_double_);
   case __format::__arg_t::__const_char_type_ptr:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__const_char_type_ptr_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__const_char_type_ptr_);
   case __format::__arg_t::__string_view:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__string_view_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__string_view_);
   case __format::__arg_t::__ptr:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), __arg.__value_.__ptr_);
+    return std::invoke(std::forward<_Visitor>(__vis), __arg.__value_.__ptr_);
   case __format::__arg_t::__handle:
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis),
-                         typename basic_format_arg<_Context>::handle{__arg.__value_.__handle_});
+    return std::invoke(
+        std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__arg.__value_.__handle_});
   }
 
   __libcpp_unreachable();
 }
 
+#  if _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_HAS_EXPLICIT_THIS_PARAMETER)
+
+template <class _Rp, class _Visitor, class _Context>
+_LIBCPP_HIDE_FROM_ABI _Rp __visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
+  switch (__arg.__type_) {
+  case __format::__arg_t::__none:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__monostate_);
+  case __format::__arg_t::__boolean:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__boolean_);
+  case __format::__arg_t::__char_type:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__char_type_);
+  case __format::__arg_t::__int:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__int_);
+  case __format::__arg_t::__long_long:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__long_long_);
+  case __format::__arg_t::__i128:
+#    ifndef _LIBCPP_HAS_NO_INT128
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__i128_);
+#    else
+    __libcpp_unreachable();
+#    endif
+  case __format::__arg_t::__unsigned:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__unsigned_);
+  case __format::__arg_t::__unsigned_long_long:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__unsigned_long_long_);
+  case __format::__arg_t::__u128:
+#    ifndef _LIBCPP_HAS_NO_INT128
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__u128_);
+#    else
+    __libcpp_unreachable();
+#    endif
+  case __format::__arg_t::__float:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__float_);
+  case __format::__arg_t::__double:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__double_);
+  case __format::__arg_t::__long_double:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__long_double_);
+  case __format::__arg_t::__const_char_type_ptr:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__const_char_type_ptr_);
+  case __format::__arg_t::__string_view:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__string_view_);
+  case __format::__arg_t::__ptr:
+    return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), __arg.__value_.__ptr_);
+  case __format::__arg_t::__handle:
+    return std::invoke_r<_Rp>(
+        std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__arg.__value_.__handle_});
+  }
+
+  __libcpp_unreachable();
+}
+
+#  endif // _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_HAS_EXPLICIT_THIS_PARAMETER)
+
 /// Contains the values used in basic_format_arg.
 ///
 /// This is a separate type so it's possible to store the values and types in
@@ -158,18 +213,14 @@ public:
   /// Contains the implementation for basic_format_arg::handle.
   struct __handle {
     template <class _Tp>
-    _LIBCPP_HIDE_FROM_ABI explicit __handle(_Tp&& __v) noexcept
-        : __ptr_(_VSTD::addressof(__v)),
+    _LIBCPP_HIDE_FROM_ABI explicit __handle(_Tp& __v) noexcept
+        : __ptr_(std::addressof(__v)),
           __format_([](basic_format_parse_context<_CharT>& __parse_ctx, _Context& __ctx, const void* __ptr) {
-            using _Dp = remove_cvref_t<_Tp>;
-            using _Formatter = typename _Context::template formatter_type<_Dp>;
-            constexpr bool __const_formattable =
-                requires { _Formatter().format(std::declval<const _Dp&>(), std::declval<_Context&>()); };
-            using _Qp = conditional_t<__const_formattable, const _Dp, _Dp>;
+            using _Dp = remove_const_t<_Tp>;
+            using _Qp = conditional_t<__formattable_with<const _Dp, _Context>, const _Dp, _Dp>;
+            static_assert(__formattable_with<_Qp, _Context>, "Mandated by [format.arg]/10");
 
-            static_assert(__const_formattable || !is_const_v<remove_reference_t<_Tp>>, "Mandated by [format.arg]/18");
-
-            _Formatter __f;
+            typename _Context::template formatter_type<_Dp> __f;
             __parse_ctx.advance_to(__f.parse(__parse_ctx));
             __ctx.advance_to(__f.format(*const_cast<_Qp*>(static_cast<const _Dp*>(__ptr)), __ctx));
           }) {}
@@ -221,9 +272,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(basic_string_view<_CharT> __value) noexcept
       : __string_view_(__value) {}
   _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(const void* __value) noexcept : __ptr_(__value) {}
-  _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__handle __value) noexcept
-      // TODO FMT Investigate why it doesn't work without the forward.
-      : __handle_(std::forward<__handle>(__value)) {}
+  _LIBCPP_HIDE_FROM_ABI __basic_format_arg_value(__handle&& __value) noexcept : __handle_(std::move(__value)) {}
 };
 
 template <class _Context>
@@ -231,13 +280,56 @@ class _LIBCPP_TEMPLATE_VIS basic_format_arg {
 public:
   class _LIBCPP_TEMPLATE_VIS handle;
 
-  _LIBCPP_HIDE_FROM_ABI basic_format_arg() noexcept
-      : __type_{__format::__arg_t::__none} {}
+  _LIBCPP_HIDE_FROM_ABI basic_format_arg() noexcept : __type_{__format::__arg_t::__none} {}
 
-  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept {
-    return __type_ != __format::__arg_t::__none;
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept { return __type_ != __format::__arg_t::__none; }
+
+#  if _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_HAS_EXPLICIT_THIS_PARAMETER)
+
+  // This function is user facing, so it must wrap the non-standard types of
+  // the "variant" in a handle to stay conforming. See __arg_t for more details.
+  template <class _Visitor>
+  _LIBCPP_HIDE_FROM_ABI decltype(auto) visit(this basic_format_arg __arg, _Visitor&& __vis) {
+    switch (__arg.__type_) {
+#    ifndef _LIBCPP_HAS_NO_INT128
+    case __format::__arg_t::__i128: {
+      typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__i128_};
+      return std::invoke(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
+    }
+
+    case __format::__arg_t::__u128: {
+      typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__u128_};
+      return std::invoke(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
+    }
+#    endif
+    default:
+      return std::__visit_format_arg(std::forward<_Visitor>(__vis), __arg);
+    }
   }
 
+  // This function is user facing, so it must wrap the non-standard types of
+  // the "variant" in a handle to stay conforming. See __arg_t for more details.
+  template <class _Rp, class _Visitor>
+  _LIBCPP_HIDE_FROM_ABI _Rp visit(this basic_format_arg __arg, _Visitor&& __vis) {
+    switch (__arg.__type_) {
+#    ifndef _LIBCPP_HAS_NO_INT128
+    case __format::__arg_t::__i128: {
+      typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__i128_};
+      return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
+    }
+
+    case __format::__arg_t::__u128: {
+      typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__u128_};
+      return std::invoke_r<_Rp>(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
+    }
+#    endif
+    default:
+      return std::__visit_format_arg<_Rp>(std::forward<_Visitor>(__vis), __arg);
+    }
+  }
+
+#  endif // _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_HAS_EXPLICIT_THIS_PARAMETER)
+
 private:
   using char_type = typename _Context::char_type;
 
@@ -264,8 +356,7 @@ public:
 template <class _Context>
 class _LIBCPP_TEMPLATE_VIS basic_format_arg<_Context>::handle {
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  void format(basic_format_parse_context<char_type>& __parse_ctx, _Context& __ctx) const {
+  _LIBCPP_HIDE_FROM_ABI void format(basic_format_parse_context<char_type>& __parse_ctx, _Context& __ctx) const {
     __handle_.__format_(__parse_ctx, __ctx, __handle_.__ptr_);
   }
 
@@ -279,22 +370,25 @@ private:
 // This function is user facing, so it must wrap the non-standard types of
 // the "variant" in a handle to stay conforming. See __arg_t for more details.
 template <class _Visitor, class _Context>
-_LIBCPP_HIDE_FROM_ABI decltype(auto)
-visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
+#  if _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_HAS_EXPLICIT_THIS_PARAMETER)
+_LIBCPP_DEPRECATED_IN_CXX26
+#  endif
+    _LIBCPP_HIDE_FROM_ABI decltype(auto)
+    visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
   switch (__arg.__type_) {
 #  ifndef _LIBCPP_HAS_NO_INT128
   case __format::__arg_t::__i128: {
     typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__i128_};
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
+    return std::invoke(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
   }
 
   case __format::__arg_t::__u128: {
     typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__u128_};
-    return _VSTD::invoke(_VSTD::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
+    return std::invoke(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
   }
-#  endif
+#  endif // _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_HAS_EXPLICIT_THIS_PARAMETER)
   default:
-    return _VSTD::__visit_format_arg(_VSTD::forward<_Visitor>(__vis), __arg);
+    return std::__visit_format_arg(std::forward<_Visitor>(__vis), __arg);
   }
 }
 
@@ -302,4 +396,6 @@ visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___FORMAT_FORMAT_ARG_H
diff --git a/third_party/libcxx/__format/format_arg_store.h b/third_party/libcxx/__format/format_arg_store.h
index 1dbbcf31b..23a599e99 100644
--- a/third_party/libcxx/__format/format_arg_store.h
+++ b/third_party/libcxx/__format/format_arg_store.h
@@ -10,6 +10,10 @@
 #ifndef _LIBCPP___FORMAT_FORMAT_ARG_STORE_H
 #define _LIBCPP___FORMAT_FORMAT_ARG_STORE_H
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
 #include <__concepts/arithmetic.h>
 #include <__concepts/same_as.h>
 #include <__config>
@@ -17,8 +21,7 @@
 #include <__format/format_arg.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/extent.h>
-#include <__type_traits/is_same.h>
-#include <__utility/forward.h>
+#include <__type_traits/remove_const.h>
 #include <string>
 #include <string_view>
 
@@ -148,23 +151,33 @@ consteval __arg_t __determine_arg_t() {
 // The overload for not formattable types allows triggering the static
 // assertion below.
 template <class _Context, class _Tp>
-  requires(!__formattable<_Tp, typename _Context::char_type>)
+  requires(!__formattable_with<_Tp, _Context>)
 consteval __arg_t __determine_arg_t() {
   return __arg_t::__none;
 }
 
+// Pseudo constuctor for basic_format_arg
+//
+// Modeled after template<class T> explicit basic_format_arg(T& v) noexcept;
+// [format.arg]/4-6
 template <class _Context, class _Tp>
-_LIBCPP_HIDE_FROM_ABI basic_format_arg<_Context> __create_format_arg(_Tp&& __value) noexcept {
-  constexpr __arg_t __arg = __determine_arg_t<_Context, remove_cvref_t<_Tp>>();
+_LIBCPP_HIDE_FROM_ABI basic_format_arg<_Context> __create_format_arg(_Tp& __value) noexcept {
+  using _Dp               = remove_const_t<_Tp>;
+  constexpr __arg_t __arg = __determine_arg_t<_Context, _Dp>();
   static_assert(__arg != __arg_t::__none, "the supplied type is not formattable");
+  static_assert(__formattable_with<_Tp, _Context>);
 
   // Not all types can be used to directly initialize the
   // __basic_format_arg_value.  First handle all types needing adjustment, the
   // final else requires no adjustment.
   if constexpr (__arg == __arg_t::__char_type)
-    // On some platforms initializing a wchar_t from a char is a narrowing
-    // conversion.
-    return basic_format_arg<_Context>{__arg, static_cast<typename _Context::char_type>(__value)};
+
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    if constexpr (same_as<typename _Context::char_type, wchar_t> && same_as<_Dp, char>)
+      return basic_format_arg<_Context>{__arg, static_cast<wchar_t>(static_cast<unsigned char>(__value))};
+    else
+#  endif
+      return basic_format_arg<_Context>{__arg, __value};
   else if constexpr (__arg == __arg_t::__int)
     return basic_format_arg<_Context>{__arg, static_cast<int>(__value)};
   else if constexpr (__arg == __arg_t::__long_long)
@@ -175,9 +188,9 @@ _LIBCPP_HIDE_FROM_ABI basic_format_arg<_Context> __create_format_arg(_Tp&& __val
     return basic_format_arg<_Context>{__arg, static_cast<unsigned long long>(__value)};
   else if constexpr (__arg == __arg_t::__string_view)
     // Using std::size on a character array will add the NUL-terminator to the size.
-    if constexpr (is_array_v<remove_cvref_t<_Tp>>)
+    if constexpr (is_array_v<_Dp>)
       return basic_format_arg<_Context>{
-          __arg, basic_string_view<typename _Context::char_type>{__value, extent_v<remove_cvref_t<_Tp>> - 1}};
+          __arg, basic_string_view<typename _Context::char_type>{__value, extent_v<_Dp> - 1}};
     else
       // When the _Traits or _Allocator are different an implicit conversion will
       // fail.
@@ -186,15 +199,14 @@ _LIBCPP_HIDE_FROM_ABI basic_format_arg<_Context> __create_format_arg(_Tp&& __val
   else if constexpr (__arg == __arg_t::__ptr)
     return basic_format_arg<_Context>{__arg, static_cast<const void*>(__value)};
   else if constexpr (__arg == __arg_t::__handle)
-    return basic_format_arg<_Context>{
-        __arg, typename __basic_format_arg_value<_Context>::__handle{_VSTD::forward<_Tp>(__value)}};
+    return basic_format_arg<_Context>{__arg, typename __basic_format_arg_value<_Context>::__handle{__value}};
   else
     return basic_format_arg<_Context>{__arg, __value};
 }
 
 template <class _Context, class... _Args>
-_LIBCPP_HIDE_FROM_ABI void __create_packed_storage(uint64_t& __types, __basic_format_arg_value<_Context>* __values,
-                                                   _Args&&... __args) noexcept {
+_LIBCPP_HIDE_FROM_ABI void
+__create_packed_storage(uint64_t& __types, __basic_format_arg_value<_Context>* __values, _Args&... __args) noexcept {
   int __shift = 0;
   (
       [&] {
@@ -211,27 +223,26 @@ _LIBCPP_HIDE_FROM_ABI void __create_packed_storage(uint64_t& __types, __basic_fo
 }
 
 template <class _Context, class... _Args>
-_LIBCPP_HIDE_FROM_ABI void __store_basic_format_arg(basic_format_arg<_Context>* __data, _Args&&... __args) noexcept {
+_LIBCPP_HIDE_FROM_ABI void __store_basic_format_arg(basic_format_arg<_Context>* __data, _Args&... __args) noexcept {
   ([&] { *__data++ = __format::__create_format_arg<_Context>(__args); }(), ...);
 }
 
-template <class _Context, size_t N>
+template <class _Context, size_t _Np>
 struct __packed_format_arg_store {
-  __basic_format_arg_value<_Context> __values_[N];
-  uint64_t __types_;
+  __basic_format_arg_value<_Context> __values_[_Np];
+  uint64_t __types_ = 0;
 };
 
-template <class _Context, size_t N>
+template <class _Context, size_t _Np>
 struct __unpacked_format_arg_store {
-  basic_format_arg<_Context> __args_[N];
+  basic_format_arg<_Context> __args_[_Np];
 };
 
 } // namespace __format
 
 template <class _Context, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS __format_arg_store {
-  _LIBCPP_HIDE_FROM_ABI
-  __format_arg_store(_Args&... __args) noexcept {
+  _LIBCPP_HIDE_FROM_ABI __format_arg_store(_Args&... __args) noexcept {
     if constexpr (sizeof...(_Args) != 0) {
       if constexpr (__format::__use_packed_format_arg_store(sizeof...(_Args)))
         __format::__create_packed_storage(__storage.__types_, __storage.__values_, __args...);
@@ -240,9 +251,10 @@ struct _LIBCPP_TEMPLATE_VIS __format_arg_store {
     }
   }
 
-  using _Storage = conditional_t<__format::__use_packed_format_arg_store(sizeof...(_Args)),
-                                 __format::__packed_format_arg_store<_Context, sizeof...(_Args)>,
-                                 __format::__unpacked_format_arg_store<_Context, sizeof...(_Args)>>;
+  using _Storage =
+      conditional_t<__format::__use_packed_format_arg_store(sizeof...(_Args)),
+                    __format::__packed_format_arg_store<_Context, sizeof...(_Args)>,
+                    __format::__unpacked_format_arg_store<_Context, sizeof...(_Args)>>;
 
   _Storage __storage;
 };
diff --git a/third_party/libcxx/__format/format_args.h b/third_party/libcxx/__format/format_args.h
index defb42a4a..07923570f 100644
--- a/third_party/libcxx/__format/format_args.h
+++ b/third_party/libcxx/__format/format_args.h
@@ -10,11 +10,10 @@
 #ifndef _LIBCPP___FORMAT_FORMAT_ARGS_H
 #define _LIBCPP___FORMAT_FORMAT_ARGS_H
 
-#include <__availability>
 #include <__config>
 #include <__format/format_arg.h>
 #include <__format/format_arg_store.h>
-#include <__format/format_fwd.h>
+#include <__fwd/format.h>
 #include <cstddef>
 #include <cstdint>
 
@@ -29,22 +28,19 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _Context>
 class _LIBCPP_TEMPLATE_VIS basic_format_args {
 public:
-  basic_format_args() noexcept = default;
-
   template <class... _Args>
   _LIBCPP_HIDE_FROM_ABI basic_format_args(const __format_arg_store<_Context, _Args...>& __store) noexcept
       : __size_(sizeof...(_Args)) {
     if constexpr (sizeof...(_Args) != 0) {
       if constexpr (__format::__use_packed_format_arg_store(sizeof...(_Args))) {
         __values_ = __store.__storage.__values_;
-        __types_ = __store.__storage.__types_;
+        __types_  = __store.__storage.__types_;
       } else
         __args_ = __store.__storage.__args_;
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  basic_format_arg<_Context> get(size_t __id) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI basic_format_arg<_Context> get(size_t __id) const noexcept {
     if (__id >= __size_)
       return basic_format_arg<_Context>{};
 
diff --git a/third_party/libcxx/__format/format_context.h b/third_party/libcxx/__format/format_context.h
index 521131db8..20c07559e 100644
--- a/third_party/libcxx/__format/format_context.h
+++ b/third_party/libcxx/__format/format_context.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___FORMAT_FORMAT_CONTEXT_H
 #define _LIBCPP___FORMAT_FORMAT_CONTEXT_H
 
-#include <__availability>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/buffer.h>
@@ -18,7 +17,7 @@
 #include <__format/format_arg_store.h>
 #include <__format/format_args.h>
 #include <__format/format_error.h>
-#include <__format/format_fwd.h>
+#include <__fwd/format.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__memory/addressof.h>
@@ -27,23 +26,26 @@
 #include <cstddef>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#include <locale>
-#include <optional>
+#  include <__locale>
+#  include <optional>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 template <class _OutIt, class _CharT>
-requires output_iterator<_OutIt, const _CharT&>
+  requires output_iterator<_OutIt, const _CharT&>
 class _LIBCPP_TEMPLATE_VIS basic_format_context;
 
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#  ifndef _LIBCPP_HAS_NO_LOCALIZATION
 /**
  * Helper to create a basic_format_context.
  *
@@ -51,32 +53,26 @@ class _LIBCPP_TEMPLATE_VIS basic_format_context;
  */
 template <class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI basic_format_context<_OutIt, _CharT>
-__format_context_create(
-    _OutIt __out_it,
-    basic_format_args<basic_format_context<_OutIt, _CharT>> __args,
-    optional<_VSTD::locale>&& __loc = nullopt) {
-  return _VSTD::basic_format_context(_VSTD::move(__out_it), __args, _VSTD::move(__loc));
+__format_context_create(_OutIt __out_it,
+                        basic_format_args<basic_format_context<_OutIt, _CharT>> __args,
+                        optional<std::locale>&& __loc = nullopt) {
+  return std::basic_format_context(std::move(__out_it), __args, std::move(__loc));
 }
-#else
+#  else
 template <class _OutIt, class _CharT>
 _LIBCPP_HIDE_FROM_ABI basic_format_context<_OutIt, _CharT>
-__format_context_create(
-    _OutIt __out_it,
-    basic_format_args<basic_format_context<_OutIt, _CharT>> __args) {
-  return _VSTD::basic_format_context(_VSTD::move(__out_it), __args);
+__format_context_create(_OutIt __out_it, basic_format_args<basic_format_context<_OutIt, _CharT>> __args) {
+  return std::basic_format_context(std::move(__out_it), __args);
 }
-#endif
+#  endif
 
-using format_context =
-    basic_format_context<back_insert_iterator<__format::__output_buffer<char>>,
-                         char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-using wformat_context = basic_format_context<
-    back_insert_iterator<__format::__output_buffer<wchar_t>>, wchar_t>;
-#endif
+using format_context = basic_format_context<back_insert_iterator<__format::__output_buffer<char>>, char>;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using wformat_context = basic_format_context< back_insert_iterator<__format::__output_buffer<wchar_t>>, wchar_t>;
+#  endif
 
 template <class _OutIt, class _CharT>
-requires output_iterator<_OutIt, const _CharT&>
+  requires output_iterator<_OutIt, const _CharT&>
 class
     // clang-format off
     _LIBCPP_TEMPLATE_VIS
@@ -85,29 +81,28 @@ class
     // clang-format on
     basic_format_context {
 public:
-  using iterator = _OutIt;
+  using iterator  = _OutIt;
   using char_type = _CharT;
   template <class _Tp>
   using formatter_type = formatter<_Tp, _CharT>;
 
-  _LIBCPP_HIDE_FROM_ABI basic_format_arg<basic_format_context>
-  arg(size_t __id) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI basic_format_arg<basic_format_context> arg(size_t __id) const noexcept {
     return __args_.get(__id);
   }
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
-  _LIBCPP_HIDE_FROM_ABI _VSTD::locale locale() {
+#  ifndef _LIBCPP_HAS_NO_LOCALIZATION
+  _LIBCPP_HIDE_FROM_ABI std::locale locale() {
     if (!__loc_)
-      __loc_ = _VSTD::locale{};
+      __loc_ = std::locale{};
     return *__loc_;
   }
-#endif
+#  endif
   _LIBCPP_HIDE_FROM_ABI iterator out() { return std::move(__out_it_); }
   _LIBCPP_HIDE_FROM_ABI void advance_to(iterator __it) { __out_it_ = std::move(__it); }
 
 private:
   iterator __out_it_;
   basic_format_args<basic_format_context> __args_;
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#  ifndef _LIBCPP_HAS_NO_LOCALIZATION
 
   // The Standard doesn't specify how the locale is stored.
   // [format.context]/6
@@ -118,30 +113,27 @@ private:
   // locale() is called and the optional has no value the value will be created.
   // This allows the implementation to lazily create the locale.
   // TODO FMT Validate whether lazy creation is the best solution.
-  optional<_VSTD::locale> __loc_;
+  optional<std::locale> __loc_;
 
-  template <class __OutIt, class __CharT>
-  friend _LIBCPP_HIDE_FROM_ABI basic_format_context<__OutIt, __CharT>
-  __format_context_create(__OutIt, basic_format_args<basic_format_context<__OutIt, __CharT>>,
-                          optional<_VSTD::locale>&&);
+  template <class _OtherOutIt, class _OtherCharT>
+  friend _LIBCPP_HIDE_FROM_ABI basic_format_context<_OtherOutIt, _OtherCharT> __format_context_create(
+      _OtherOutIt, basic_format_args<basic_format_context<_OtherOutIt, _OtherCharT>>, optional<std::locale>&&);
 
   // Note: the Standard doesn't specify the required constructors.
-  _LIBCPP_HIDE_FROM_ABI
-  explicit basic_format_context(_OutIt __out_it,
-                                basic_format_args<basic_format_context> __args,
-                                optional<_VSTD::locale>&& __loc)
-      : __out_it_(_VSTD::move(__out_it)), __args_(__args),
-        __loc_(_VSTD::move(__loc)) {}
-#else
-  template <class __OutIt, class __CharT>
-  friend _LIBCPP_HIDE_FROM_ABI basic_format_context<__OutIt, __CharT>
-      __format_context_create(__OutIt, basic_format_args<basic_format_context<__OutIt, __CharT>>);
+  _LIBCPP_HIDE_FROM_ABI explicit basic_format_context(
+      _OutIt __out_it, basic_format_args<basic_format_context> __args, optional<std::locale>&& __loc)
+      : __out_it_(std::move(__out_it)), __args_(__args), __loc_(std::move(__loc)) {}
+#  else
+  template <class _OtherOutIt, class _OtherCharT>
+  friend _LIBCPP_HIDE_FROM_ABI basic_format_context<_OtherOutIt, _OtherCharT>
+      __format_context_create(_OtherOutIt, basic_format_args<basic_format_context<_OtherOutIt, _OtherCharT>>);
 
-  _LIBCPP_HIDE_FROM_ABI
-  explicit basic_format_context(_OutIt __out_it,
-                                basic_format_args<basic_format_context> __args)
-      : __out_it_(_VSTD::move(__out_it)), __args_(__args) {}
-#endif
+  _LIBCPP_HIDE_FROM_ABI explicit basic_format_context(_OutIt __out_it, basic_format_args<basic_format_context> __args)
+      : __out_it_(std::move(__out_it)), __args_(__args) {}
+#  endif
+
+  basic_format_context(const basic_format_context&)            = delete;
+  basic_format_context& operator=(const basic_format_context&) = delete;
 };
 
 // A specialization for __retarget_buffer
@@ -161,8 +153,7 @@ private:
 // Here the width of an element in input is determined dynamically.
 // Note when the top-level element has no width the retargeting is not needed.
 template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS
-    basic_format_context<typename __format::__retarget_buffer<_CharT>::__iterator, _CharT> {
+class _LIBCPP_TEMPLATE_VIS basic_format_context<typename __format::__retarget_buffer<_CharT>::__iterator, _CharT> {
 public:
   using iterator  = typename __format::__retarget_buffer<_CharT>::__iterator;
   using char_type = _CharT;
@@ -177,20 +168,25 @@ public:
 #  endif
         __ctx_(std::addressof(__ctx)),
         __arg_([](void* __c, size_t __id) {
-          return std::visit_format_arg(
-              [&](auto __arg) -> basic_format_arg<basic_format_context> {
-                if constexpr (same_as<decltype(__arg), monostate>)
-                  return {};
-                else if constexpr (same_as<decltype(__arg), typename basic_format_arg<_Context>::handle>)
-                  // At the moment it's not possible for formatting to use a re-targeted handle.
-                  // TODO FMT add this when support is needed.
-                  std::__throw_format_error("Re-targeting handle not supported");
-                else
-                  return basic_format_arg<basic_format_context>{
-                      __format::__determine_arg_t<basic_format_context, decltype(__arg)>(),
-                      __basic_format_arg_value<basic_format_context>(__arg)};
-              },
-              static_cast<_Context*>(__c)->arg(__id));
+          auto __visitor = [&](auto __arg) -> basic_format_arg<basic_format_context> {
+            if constexpr (same_as<decltype(__arg), monostate>)
+              return {};
+            else if constexpr (same_as<decltype(__arg), typename basic_format_arg<_Context>::handle>)
+              // At the moment it's not possible for formatting to use a re-targeted handle.
+              // TODO FMT add this when support is needed.
+              std::__throw_format_error("Re-targeting handle not supported");
+            else
+              return basic_format_arg<basic_format_context>{
+                  __format::__determine_arg_t<basic_format_context, decltype(__arg)>(),
+                  __basic_format_arg_value<basic_format_context>(__arg)};
+          };
+#  if _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_HAS_EXPLICIT_THIS_PARAMETER)
+          return static_cast<_Context*>(__c)->arg(__id).visit(std::move(__visitor));
+#  else
+          _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+          return std::visit_format_arg(std::move(__visitor), static_cast<_Context*>(__c)->arg(__id));
+          _LIBCPP_SUPPRESS_DEPRECATED_POP
+#  endif // _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_HAS_EXPLICIT_THIS_PARAMETER)
         }) {
   }
 
@@ -198,7 +194,7 @@ public:
     return __arg_(__ctx_, __id);
   }
 #  ifndef _LIBCPP_HAS_NO_LOCALIZATION
-  _LIBCPP_HIDE_FROM_ABI _VSTD::locale locale() { return __loc_(__ctx_); }
+  _LIBCPP_HIDE_FROM_ABI std::locale locale() { return __loc_(__ctx_); }
 #  endif
   _LIBCPP_HIDE_FROM_ABI iterator out() { return std::move(__out_it_); }
   _LIBCPP_HIDE_FROM_ABI void advance_to(iterator __it) { __out_it_ = std::move(__it); }
@@ -219,4 +215,6 @@ _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_context);
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___FORMAT_FORMAT_CONTEXT_H
diff --git a/third_party/libcxx/__format/format_error.h b/third_party/libcxx/__format/format_error.h
index 7fb4dd0d7..ed40e395d 100644
--- a/third_party/libcxx/__format/format_error.h
+++ b/third_party/libcxx/__format/format_error.h
@@ -11,7 +11,7 @@
 #define _LIBCPP___FORMAT_FORMAT_ERROR_H
 
 #include <__config>
-#include <cstdlib>
+#include <__verbose_abort>
 #include <stdexcept>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -24,25 +24,23 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_DIAGNOSTIC_PUSH
 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wweak-vtables")
-class _LIBCPP_EXCEPTION_ABI format_error : public runtime_error {
+class _LIBCPP_EXPORTED_FROM_ABI format_error : public runtime_error {
 public:
-  _LIBCPP_HIDE_FROM_ABI explicit format_error(const string& __s)
-      : runtime_error(__s) {}
-  _LIBCPP_HIDE_FROM_ABI explicit format_error(const char* __s)
-      : runtime_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit format_error(const string& __s) : runtime_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit format_error(const char* __s) : runtime_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI format_error(const format_error&)            = default;
+  _LIBCPP_HIDE_FROM_ABI format_error& operator=(const format_error&) = default;
   _LIBCPP_HIDE_FROM_ABI_VIRTUAL
   ~format_error() noexcept override = default;
 };
 _LIBCPP_DIAGNOSTIC_POP
 
-_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void
-__throw_format_error(const char* __s) {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_format_error(const char* __s) {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   throw format_error(__s);
-#else
-  (void)__s;
-  _VSTD::abort();
-#endif
+#  else
+  _LIBCPP_VERBOSE_ABORT("format_error was thrown in -fno-exceptions mode with message \"%s\"", __s);
+#  endif
 }
 
 #endif //_LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__format/format_functions.h b/third_party/libcxx/__format/format_functions.h
index 72a9f377d..d14b49aff 100644
--- a/third_party/libcxx/__format/format_functions.h
+++ b/third_party/libcxx/__format/format_functions.h
@@ -11,11 +11,9 @@
 #define _LIBCPP___FORMAT_FORMAT_FUNCTIONS
 
 #include <__algorithm/clamp.h>
-#include <__availability>
 #include <__concepts/convertible_to.h>
 #include <__concepts/same_as.h>
 #include <__config>
-#include <__debug>
 #include <__format/buffer.h>
 #include <__format/format_arg.h>
 #include <__format/format_arg_store.h>
@@ -36,20 +34,23 @@
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
-#include <__iterator/readable_traits.h> // iter_value_t
+#include <__iterator/iterator_traits.h> // iter_value_t
 #include <__variant/monostate.h>
 #include <array>
 #include <string>
 #include <string_view>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#include <locale>
+#  include <__locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -60,21 +61,21 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // to do this optimization now.
 
 using format_args = basic_format_args<format_context>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using wformat_args = basic_format_args<wformat_context>;
-#endif
+#  endif
 
 template <class _Context = format_context, class... _Args>
-_LIBCPP_HIDE_FROM_ABI __format_arg_store<_Context, _Args...> make_format_args(_Args&&... __args) {
-  return _VSTD::__format_arg_store<_Context, _Args...>(__args...);
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI __format_arg_store<_Context, _Args...> make_format_args(_Args&... __args) {
+  return std::__format_arg_store<_Context, _Args...>(__args...);
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
-_LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...> make_wformat_args(_Args&&... __args) {
-  return _VSTD::__format_arg_store<wformat_context, _Args...>(__args...);
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI __format_arg_store<wformat_context, _Args...> make_wformat_args(_Args&... __args) {
+  return std::__format_arg_store<wformat_context, _Args...>(__args...);
 }
-#endif
+#  endif
 
 namespace __format {
 
@@ -128,13 +129,13 @@ public:
 
   _LIBCPP_HIDE_FROM_ABI constexpr __arg_t arg(size_t __id) const {
     if (__id >= __size_)
-      std::__throw_format_error("Argument index out of bounds");
+      std::__throw_format_error("The argument index value is too large for the number of arguments supplied");
     return __args_[__id];
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr const __compile_time_handle<_CharT>& __handle(size_t __id) const {
     if (__id >= __size_)
-      std::__throw_format_error("Argument index out of bounds");
+      std::__throw_format_error("The argument index value is too large for the number of arguments supplied");
     return __handles_[__id];
   }
 
@@ -189,9 +190,10 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __compile_time_validate_argument(
 
 // This function is not user facing, so it can directly use the non-standard types of the "variant".
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __compile_time_visit_format_arg(basic_format_parse_context<_CharT>& __parse_ctx,
-                                                                     __compile_time_basic_format_context<_CharT>& __ctx,
-                                                                     __arg_t __type) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __compile_time_visit_format_arg(
+    basic_format_parse_context<_CharT>& __parse_ctx,
+    __compile_time_basic_format_context<_CharT>& __ctx,
+    __arg_t __type) {
   switch (__type) {
   case __arg_t::__none:
     std::__throw_format_error("Invalid argument");
@@ -204,22 +206,22 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __compile_time_visit_format_arg(basic_forma
   case __arg_t::__long_long:
     return __format::__compile_time_validate_argument<_CharT, long long>(__parse_ctx, __ctx);
   case __arg_t::__i128:
-#      ifndef _LIBCPP_HAS_NO_INT128
+#  ifndef _LIBCPP_HAS_NO_INT128
     return __format::__compile_time_validate_argument<_CharT, __int128_t>(__parse_ctx, __ctx);
-#      else
+#  else
     std::__throw_format_error("Invalid argument");
-#      endif
+#  endif
     return;
   case __arg_t::__unsigned:
     return __format::__compile_time_validate_argument<_CharT, unsigned>(__parse_ctx, __ctx);
   case __arg_t::__unsigned_long_long:
     return __format::__compile_time_validate_argument<_CharT, unsigned long long>(__parse_ctx, __ctx);
   case __arg_t::__u128:
-#      ifndef _LIBCPP_HAS_NO_INT128
+#  ifndef _LIBCPP_HAS_NO_INT128
     return __format::__compile_time_validate_argument<_CharT, __uint128_t>(__parse_ctx, __ctx);
-#      else
+#  else
     std::__throw_format_error("Invalid argument");
-#      endif
+#  endif
     return;
   case __arg_t::__float:
     return __format::__compile_time_validate_argument<_CharT, float, true>(__parse_ctx, __ctx);
@@ -241,11 +243,13 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __compile_time_visit_format_arg(basic_forma
 
 template <contiguous_iterator _Iterator, class _ParseCtx, class _Ctx>
 _LIBCPP_HIDE_FROM_ABI constexpr _Iterator
-__handle_replacement_field(_Iterator __begin, _Iterator __end,
-                           _ParseCtx& __parse_ctx, _Ctx& __ctx) {
-  using _CharT = iter_value_t<_Iterator>;
+__handle_replacement_field(_Iterator __begin, _Iterator __end, _ParseCtx& __parse_ctx, _Ctx& __ctx) {
+  using _CharT                        = iter_value_t<_Iterator>;
   __format::__parse_number_result __r = __format::__parse_arg_id(__begin, __end, __parse_ctx);
 
+  if (__r.__last == __end)
+    std::__throw_format_error("The argument index should end with a ':' or a '}'");
+
   bool __parse = *__r.__last == _CharT(':');
   switch (*__r.__last) {
   case _CharT(':'):
@@ -257,22 +261,22 @@ __handle_replacement_field(_Iterator __begin, _Iterator __end,
     __parse_ctx.advance_to(__r.__last);
     break;
   default:
-    std::__throw_format_error("The replacement field arg-id should terminate at a ':' or '}'");
+    std::__throw_format_error("The argument index should end with a ':' or a '}'");
   }
 
   if constexpr (same_as<_Ctx, __compile_time_basic_format_context<_CharT>>) {
     __arg_t __type = __ctx.arg(__r.__value);
     if (__type == __arg_t::__none)
-      std::__throw_format_error("Argument index out of bounds");
+      std::__throw_format_error("The argument index value is too large for the number of arguments supplied");
     else if (__type == __arg_t::__handle)
       __ctx.__handle(__r.__value).__parse(__parse_ctx);
     else if (__parse)
       __format::__compile_time_visit_format_arg(__parse_ctx, __ctx, __type);
   } else
-    _VSTD::__visit_format_arg(
+    std::__visit_format_arg(
         [&](auto __arg) {
           if constexpr (same_as<decltype(__arg), monostate>)
-            std::__throw_format_error("Argument index out of bounds");
+            std::__throw_format_error("The argument index value is too large for the number of arguments supplied");
           else if constexpr (same_as<decltype(__arg), typename basic_format_arg<_Ctx>::handle>)
             __arg.format(__parse_ctx, __ctx);
           else {
@@ -292,13 +296,12 @@ __handle_replacement_field(_Iterator __begin, _Iterator __end,
 }
 
 template <class _ParseCtx, class _Ctx>
-_LIBCPP_HIDE_FROM_ABI constexpr typename _Ctx::iterator
-__vformat_to(_ParseCtx&& __parse_ctx, _Ctx&& __ctx) {
+_LIBCPP_HIDE_FROM_ABI constexpr typename _Ctx::iterator __vformat_to(_ParseCtx&& __parse_ctx, _Ctx&& __ctx) {
   using _CharT = typename _ParseCtx::char_type;
   static_assert(same_as<typename _Ctx::char_type, _CharT>);
 
-  auto __begin = __parse_ctx.begin();
-  auto __end = __parse_ctx.end();
+  auto __begin                     = __parse_ctx.begin();
+  auto __end                       = __parse_ctx.end();
   typename _Ctx::iterator __out_it = __ctx.out();
   while (__begin != __end) {
     switch (*__begin) {
@@ -308,9 +311,8 @@ __vformat_to(_ParseCtx&& __parse_ctx, _Ctx&& __ctx) {
         std::__throw_format_error("The format string terminates at a '{'");
 
       if (*__begin != _CharT('{')) [[likely]] {
-        __ctx.advance_to(_VSTD::move(__out_it));
-        __begin =
-            __format::__handle_replacement_field(__begin, __end, __parse_ctx, __ctx);
+        __ctx.advance_to(std::move(__out_it));
+        __begin  = __format::__handle_replacement_field(__begin, __end, __parse_ctx, __ctx);
         __out_it = __ctx.out();
 
         // The output is written and __begin points to the next character. So
@@ -336,6 +338,30 @@ __vformat_to(_ParseCtx&& __parse_ctx, _Ctx&& __ctx) {
 
 } // namespace __format
 
+#  if _LIBCPP_STD_VER >= 26
+template <class _CharT>
+struct _LIBCPP_TEMPLATE_VIS __runtime_format_string {
+private:
+  basic_string_view<_CharT> __str_;
+
+  template <class _Cp, class... _Args>
+  friend struct _LIBCPP_TEMPLATE_VIS basic_format_string;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __runtime_format_string(basic_string_view<_CharT> __s) noexcept : __str_(__s) {}
+
+  __runtime_format_string(const __runtime_format_string&)            = delete;
+  __runtime_format_string& operator=(const __runtime_format_string&) = delete;
+};
+
+_LIBCPP_HIDE_FROM_ABI inline __runtime_format_string<char> runtime_format(string_view __fmt) noexcept { return __fmt; }
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+_LIBCPP_HIDE_FROM_ABI inline __runtime_format_string<wchar_t> runtime_format(wstring_view __fmt) noexcept {
+  return __fmt;
+}
+#    endif
+#  endif //_LIBCPP_STD_VER >= 26
+
 template <class _CharT, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS basic_format_string {
   template <class _Tp>
@@ -345,9 +371,10 @@ struct _LIBCPP_TEMPLATE_VIS basic_format_string {
                            _Context{__types_.data(), __handles_.data(), sizeof...(_Args)});
   }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<_CharT> get() const noexcept {
-    return __str_;
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<_CharT> get() const noexcept { return __str_; }
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI basic_format_string(__runtime_format_string<_CharT> __s) noexcept : __str_(__s.__str_) {}
+#  endif
 
 private:
   basic_string_view<_CharT> __str_;
@@ -357,20 +384,6 @@ private:
   static constexpr array<__format::__arg_t, sizeof...(_Args)> __types_{
       __format::__determine_arg_t<_Context, remove_cvref_t<_Args>>()...};
 
-  // TODO FMT remove this work-around when the AIX ICE has been resolved.
-#    if defined(_AIX) && defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1400
-  template <class _Tp>
-  static constexpr __format::__compile_time_handle<_CharT> __get_handle() {
-    __format::__compile_time_handle<_CharT> __handle;
-    if (__format::__determine_arg_t<_Context, _Tp>() == __format::__arg_t::__handle)
-      __handle.template __enable<_Tp>();
-
-    return __handle;
-  }
-
-  static constexpr array<__format::__compile_time_handle<_CharT>, sizeof...(_Args)> __handles_{
-      __get_handle<_Args>()...};
-#    else
   static constexpr array<__format::__compile_time_handle<_CharT>, sizeof...(_Args)> __handles_{[] {
     using _Tp = remove_cvref_t<_Args>;
     __format::__compile_time_handle<_CharT> __handle;
@@ -379,30 +392,29 @@ private:
 
     return __handle;
   }()...};
-#    endif
 };
 
 template <class... _Args>
 using format_string = basic_format_string<char, type_identity_t<_Args>...>;
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
 using wformat_string = basic_format_string<wchar_t, type_identity_t<_Args>...>;
-#endif
+#  endif
 
 template <class _OutIt, class _CharT, class _FormatOutIt>
-requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
-    __vformat_to(
-        _OutIt __out_it, basic_string_view<_CharT> __fmt,
-        basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
+  requires(output_iterator<_OutIt, const _CharT&>)
+_LIBCPP_HIDE_FROM_ABI _OutIt __vformat_to(_OutIt __out_it,
+                                          basic_string_view<_CharT> __fmt,
+                                          basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
   if constexpr (same_as<_OutIt, _FormatOutIt>)
-    return _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
-                                         _VSTD::__format_context_create(_VSTD::move(__out_it), __args));
+    return std::__format::__vformat_to(
+        basic_format_parse_context{__fmt, __args.__size()}, std::__format_context_create(std::move(__out_it), __args));
   else {
-    __format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
-    _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
-                                  _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args));
-    return _VSTD::move(__buffer).__out_it();
+    __format::__format_buffer<_OutIt, _CharT> __buffer{std::move(__out_it)};
+    std::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
+                                std::__format_context_create(__buffer.__make_output_iterator(), __args));
+    return std::move(__buffer).__out_it();
   }
 }
 
@@ -410,268 +422,259 @@ requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
 // https://reviews.llvm.org/D110499#inline-1180704
 // TODO FMT Evaluate whether we want to file a Clang bug report regarding this.
 template <output_iterator<const char&> _OutIt>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt
-vformat_to(_OutIt __out_it, string_view __fmt, format_args __args) {
-  return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args);
+_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt vformat_to(_OutIt __out_it, string_view __fmt, format_args __args) {
+  return std::__vformat_to(std::move(__out_it), __fmt, __args);
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt
 vformat_to(_OutIt __out_it, wstring_view __fmt, wformat_args __args) {
-  return _VSTD::__vformat_to(_VSTD::move(__out_it), __fmt, __args);
+  return std::__vformat_to(std::move(__out_it), __fmt, __args);
 }
-#endif
+#  endif
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt
 format_to(_OutIt __out_it, format_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt.get(),
-                           _VSTD::make_format_args(__args...));
+  return std::vformat_to(std::move(__out_it), __fmt.get(), std::make_format_args(__args...));
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt
 format_to(_OutIt __out_it, wformat_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::vformat_to(_VSTD::move(__out_it), __fmt.get(),
-                           _VSTD::make_wformat_args(__args...));
+  return std::vformat_to(std::move(__out_it), __fmt.get(), std::make_wformat_args(__args...));
 }
-#endif
+#  endif
 
 // TODO FMT This needs to be a template or std::to_chars(floating-point) availability markup
 // fires too eagerly, see http://llvm.org/PR61563.
 template <class = void>
-_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI string
-vformat(string_view __fmt, format_args __args) {
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI string vformat(string_view __fmt, format_args __args) {
   string __res;
-  _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args);
+  std::vformat_to(std::back_inserter(__res), __fmt, __args);
   return __res;
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 // TODO FMT This needs to be a template or std::to_chars(floating-point) availability markup
 // fires too eagerly, see http://llvm.org/PR61563.
 template <class = void>
-_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI wstring
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI wstring
 vformat(wstring_view __fmt, wformat_args __args) {
   wstring __res;
-  _VSTD::vformat_to(_VSTD::back_inserter(__res), __fmt, __args);
+  std::vformat_to(std::back_inserter(__res), __fmt, __args);
   return __res;
 }
-#endif
+#  endif
 
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI string format(format_string<_Args...> __fmt,
-                                                                                      _Args&&... __args) {
-  return _VSTD::vformat(__fmt.get(), _VSTD::make_format_args(__args...));
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI string
+format(format_string<_Args...> __fmt, _Args&&... __args) {
+  return std::vformat(__fmt.get(), std::make_format_args(__args...));
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI wstring
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI wstring
 format(wformat_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::vformat(__fmt.get(), _VSTD::make_wformat_args(__args...));
+  return std::vformat(__fmt.get(), std::make_wformat_args(__args...));
 }
-#endif
+#  endif
 
 template <class _Context, class _OutIt, class _CharT>
-_LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
-                                                                basic_string_view<_CharT> __fmt,
-                                                                basic_format_args<_Context> __args) {
-  __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
-  _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
-                                _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args));
-  return _VSTD::move(__buffer).__result();
+_LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt>
+__vformat_to_n(_OutIt __out_it,
+               iter_difference_t<_OutIt> __n,
+               basic_string_view<_CharT> __fmt,
+               basic_format_args<_Context> __args) {
+  __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{std::move(__out_it), __n};
+  std::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
+                              std::__format_context_create(__buffer.__make_output_iterator(), __args));
+  return std::move(__buffer).__result();
 }
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt>
 format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, format_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::__vformat_to_n<format_context>(_VSTD::move(__out_it), __n, __fmt.get(), _VSTD::make_format_args(__args...));
+  return std::__vformat_to_n<format_context>(std::move(__out_it), __n, __fmt.get(), std::make_format_args(__args...));
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt>
-format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, wformat_string<_Args...> __fmt,
-            _Args&&... __args) {
-  return _VSTD::__vformat_to_n<wformat_context>(_VSTD::move(__out_it), __n, __fmt.get(), _VSTD::make_wformat_args(__args...));
+format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, wformat_string<_Args...> __fmt, _Args&&... __args) {
+  return std::__vformat_to_n<wformat_context>(std::move(__out_it), __n, __fmt.get(), std::make_wformat_args(__args...));
 }
-#endif
+#  endif
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
-  _VSTD::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
-                                _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args));
-  return _VSTD::move(__buffer).__result();
+  std::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
+                              std::__format_context_create(__buffer.__make_output_iterator(), __args));
+  return std::move(__buffer).__result();
 }
 
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
 formatted_size(format_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::__vformatted_size(__fmt.get(), basic_format_args{_VSTD::make_format_args(__args...)});
+  return std::__vformatted_size(__fmt.get(), basic_format_args{std::make_format_args(__args...)});
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
 formatted_size(wformat_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::__vformatted_size(__fmt.get(), basic_format_args{_VSTD::make_wformat_args(__args...)});
+  return std::__vformatted_size(__fmt.get(), basic_format_args{std::make_wformat_args(__args...)});
 }
-#endif
+#  endif
 
-#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#  ifndef _LIBCPP_HAS_NO_LOCALIZATION
 
 template <class _OutIt, class _CharT, class _FormatOutIt>
-requires(output_iterator<_OutIt, const _CharT&>) _LIBCPP_HIDE_FROM_ABI _OutIt
-    __vformat_to(
-        _OutIt __out_it, locale __loc, basic_string_view<_CharT> __fmt,
-        basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
+  requires(output_iterator<_OutIt, const _CharT&>)
+_LIBCPP_HIDE_FROM_ABI _OutIt __vformat_to(
+    _OutIt __out_it,
+    locale __loc,
+    basic_string_view<_CharT> __fmt,
+    basic_format_args<basic_format_context<_FormatOutIt, _CharT>> __args) {
   if constexpr (same_as<_OutIt, _FormatOutIt>)
-    return _VSTD::__format::__vformat_to(
-        basic_format_parse_context{__fmt, __args.__size()},
-        _VSTD::__format_context_create(_VSTD::move(__out_it), __args, _VSTD::move(__loc)));
+    return std::__format::__vformat_to(basic_format_parse_context{__fmt, __args.__size()},
+                                       std::__format_context_create(std::move(__out_it), __args, std::move(__loc)));
   else {
-    __format::__format_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it)};
-    _VSTD::__format::__vformat_to(
+    __format::__format_buffer<_OutIt, _CharT> __buffer{std::move(__out_it)};
+    std::__format::__vformat_to(
         basic_format_parse_context{__fmt, __args.__size()},
-        _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args, _VSTD::move(__loc)));
-    return _VSTD::move(__buffer).__out_it();
+        std::__format_context_create(__buffer.__make_output_iterator(), __args, std::move(__loc)));
+    return std::move(__buffer).__out_it();
   }
 }
 
 template <output_iterator<const char&> _OutIt>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt vformat_to(
-    _OutIt __out_it, locale __loc, string_view __fmt, format_args __args) {
-  return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
-                             __args);
+_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt
+vformat_to(_OutIt __out_it, locale __loc, string_view __fmt, format_args __args) {
+  return std::__vformat_to(std::move(__out_it), std::move(__loc), __fmt, __args);
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt vformat_to(
-    _OutIt __out_it, locale __loc, wstring_view __fmt, wformat_args __args) {
-  return _VSTD::__vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt,
-                             __args);
+_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt
+vformat_to(_OutIt __out_it, locale __loc, wstring_view __fmt, wformat_args __args) {
+  return std::__vformat_to(std::move(__out_it), std::move(__loc), __fmt, __args);
 }
-#endif
+#    endif
 
 template <output_iterator<const char&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt
 format_to(_OutIt __out_it, locale __loc, format_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt.get(),
-                           _VSTD::make_format_args(__args...));
+  return std::vformat_to(std::move(__out_it), std::move(__loc), __fmt.get(), std::make_format_args(__args...));
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _OutIt
 format_to(_OutIt __out_it, locale __loc, wformat_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::vformat_to(_VSTD::move(__out_it), _VSTD::move(__loc), __fmt.get(),
-                           _VSTD::make_wformat_args(__args...));
+  return std::vformat_to(std::move(__out_it), std::move(__loc), __fmt.get(), std::make_wformat_args(__args...));
 }
-#endif
+#    endif
 
 // TODO FMT This needs to be a template or std::to_chars(floating-point) availability markup
 // fires too eagerly, see http://llvm.org/PR61563.
 template <class = void>
-_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI string
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI string
 vformat(locale __loc, string_view __fmt, format_args __args) {
   string __res;
-  _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt,
-                    __args);
+  std::vformat_to(std::back_inserter(__res), std::move(__loc), __fmt, __args);
   return __res;
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 // TODO FMT This needs to be a template or std::to_chars(floating-point) availability markup
 // fires too eagerly, see http://llvm.org/PR61563.
 template <class = void>
-_LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI wstring
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE inline _LIBCPP_HIDE_FROM_ABI wstring
 vformat(locale __loc, wstring_view __fmt, wformat_args __args) {
   wstring __res;
-  _VSTD::vformat_to(_VSTD::back_inserter(__res), _VSTD::move(__loc), __fmt,
-                    __args);
+  std::vformat_to(std::back_inserter(__res), std::move(__loc), __fmt, __args);
   return __res;
 }
-#endif
+#    endif
 
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI string format(locale __loc,
-                                                                                      format_string<_Args...> __fmt,
-                                                                                      _Args&&... __args) {
-  return _VSTD::vformat(_VSTD::move(__loc), __fmt.get(),
-                        _VSTD::make_format_args(__args...));
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI string
+format(locale __loc, format_string<_Args...> __fmt, _Args&&... __args) {
+  return std::vformat(std::move(__loc), __fmt.get(), std::make_format_args(__args...));
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI wstring
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI wstring
 format(locale __loc, wformat_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::vformat(_VSTD::move(__loc), __fmt.get(),
-                        _VSTD::make_wformat_args(__args...));
+  return std::vformat(std::move(__loc), __fmt.get(), std::make_wformat_args(__args...));
 }
-#endif
+#    endif
 
 template <class _Context, class _OutIt, class _CharT>
-_LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n,
-                                                                locale __loc, basic_string_view<_CharT> __fmt,
-                                                                basic_format_args<_Context> __args) {
-  __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{_VSTD::move(__out_it), __n};
-  _VSTD::__format::__vformat_to(
+_LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> __vformat_to_n(
+    _OutIt __out_it,
+    iter_difference_t<_OutIt> __n,
+    locale __loc,
+    basic_string_view<_CharT> __fmt,
+    basic_format_args<_Context> __args) {
+  __format::__format_to_n_buffer<_OutIt, _CharT> __buffer{std::move(__out_it), __n};
+  std::__format::__vformat_to(
       basic_format_parse_context{__fmt, __args.__size()},
-      _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args, _VSTD::move(__loc)));
-  return _VSTD::move(__buffer).__result();
+      std::__format_context_create(__buffer.__make_output_iterator(), __args, std::move(__loc)));
+  return std::move(__buffer).__result();
 }
 
 template <output_iterator<const char&> _OutIt, class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt>
-format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, format_string<_Args...> __fmt,
-            _Args&&... __args) {
-  return _VSTD::__vformat_to_n<format_context>(_VSTD::move(__out_it), __n, _VSTD::move(__loc), __fmt.get(),
-                                               _VSTD::make_format_args(__args...));
+_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> format_to_n(
+    _OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, format_string<_Args...> __fmt, _Args&&... __args) {
+  return std::__vformat_to_n<format_context>(
+      std::move(__out_it), __n, std::move(__loc), __fmt.get(), std::make_format_args(__args...));
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <output_iterator<const wchar_t&> _OutIt, class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt>
-format_to_n(_OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, wformat_string<_Args...> __fmt,
-            _Args&&... __args) {
-  return _VSTD::__vformat_to_n<wformat_context>(_VSTD::move(__out_it), __n, _VSTD::move(__loc), __fmt.get(),
-                                                _VSTD::make_wformat_args(__args...));
+_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI format_to_n_result<_OutIt> format_to_n(
+    _OutIt __out_it, iter_difference_t<_OutIt> __n, locale __loc, wformat_string<_Args...> __fmt, _Args&&... __args) {
+  return std::__vformat_to_n<wformat_context>(
+      std::move(__out_it), __n, std::move(__loc), __fmt.get(), std::make_wformat_args(__args...));
 }
-#endif
+#    endif
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI size_t __vformatted_size(locale __loc, basic_string_view<_CharT> __fmt, auto __args) {
   __format::__formatted_size_buffer<_CharT> __buffer;
-  _VSTD::__format::__vformat_to(
+  std::__format::__vformat_to(
       basic_format_parse_context{__fmt, __args.__size()},
-      _VSTD::__format_context_create(__buffer.__make_output_iterator(), __args, _VSTD::move(__loc)));
-  return _VSTD::move(__buffer).__result();
+      std::__format_context_create(__buffer.__make_output_iterator(), __args, std::move(__loc)));
+  return std::move(__buffer).__result();
 }
 
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
 formatted_size(locale __loc, format_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.get(), basic_format_args{_VSTD::make_format_args(__args...)});
+  return std::__vformatted_size(std::move(__loc), __fmt.get(), basic_format_args{std::make_format_args(__args...)});
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class... _Args>
-_LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
+[[nodiscard]] _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI size_t
 formatted_size(locale __loc, wformat_string<_Args...> __fmt, _Args&&... __args) {
-  return _VSTD::__vformatted_size(_VSTD::move(__loc), __fmt.get(), basic_format_args{_VSTD::make_wformat_args(__args...)});
+  return std::__vformatted_size(std::move(__loc), __fmt.get(), basic_format_args{std::make_wformat_args(__args...)});
 }
-#endif
-
-#endif // _LIBCPP_HAS_NO_LOCALIZATION
+#    endif
 
+#  endif // _LIBCPP_HAS_NO_LOCALIZATION
 
 #endif //_LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___FORMAT_FORMAT_FUNCTIONS
diff --git a/third_party/libcxx/__format/format_fwd.h b/third_party/libcxx/__format/format_fwd.h
deleted file mode 100644
index 120b2fc8d..000000000
--- a/third_party/libcxx/__format/format_fwd.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___FORMAT_FORMAT_FWD_H
-#define _LIBCPP___FORMAT_FORMAT_FWD_H
-
-#include <__availability>
-#include <__config>
-#include <__iterator/concepts.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 20
-
-template <class _Context>
-class _LIBCPP_TEMPLATE_VIS basic_format_arg;
-
-template <class _OutIt, class _CharT>
-  requires output_iterator<_OutIt, const _CharT&>
-class _LIBCPP_TEMPLATE_VIS basic_format_context;
-
-template <class _Tp, class _CharT = char>
-struct _LIBCPP_TEMPLATE_VIS formatter;
-
-#endif //_LIBCPP_STD_VER >= 20
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___FORMAT_FORMAT_FWD_H
diff --git a/third_party/libcxx/__format/format_parse_context.h b/third_party/libcxx/__format/format_parse_context.h
index 79f53f77d..aefcd5497 100644
--- a/third_party/libcxx/__format/format_parse_context.h
+++ b/third_party/libcxx/__format/format_parse_context.h
@@ -26,32 +26,24 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _CharT>
 class _LIBCPP_TEMPLATE_VIS basic_format_parse_context {
 public:
-  using char_type = _CharT;
+  using char_type      = _CharT;
   using const_iterator = typename basic_string_view<_CharT>::const_iterator;
-  using iterator = const_iterator;
+  using iterator       = const_iterator;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit basic_format_parse_context(basic_string_view<_CharT> __fmt,
-                                                size_t __num_args = 0) noexcept
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit basic_format_parse_context(
+      basic_string_view<_CharT> __fmt, size_t __num_args = 0) noexcept
       : __begin_(__fmt.begin()),
         __end_(__fmt.end()),
         __indexing_(__unknown),
         __next_arg_id_(0),
         __num_args_(__num_args) {}
 
-  basic_format_parse_context(const basic_format_parse_context&) = delete;
-  basic_format_parse_context&
-  operator=(const basic_format_parse_context&) = delete;
+  basic_format_parse_context(const basic_format_parse_context&)            = delete;
+  basic_format_parse_context& operator=(const basic_format_parse_context&) = delete;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr const_iterator begin() const noexcept {
-    return __begin_;
-  }
-  _LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const noexcept {
-    return __end_;
-  }
-  _LIBCPP_HIDE_FROM_ABI constexpr void advance_to(const_iterator __it) {
-    __begin_ = __it;
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr const_iterator begin() const noexcept { return __begin_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const noexcept { return __end_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr void advance_to(const_iterator __it) { __begin_ = __it; }
 
   _LIBCPP_HIDE_FROM_ABI constexpr size_t next_arg_id() {
     if (__indexing_ == __manual)
@@ -102,9 +94,9 @@ private:
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_format_parse_context);
 
 using format_parse_context = basic_format_parse_context<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using wformat_parse_context = basic_format_parse_context<wchar_t>;
-#endif
+#  endif
 
 #endif //_LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__format/format_string.h b/third_party/libcxx/__format/format_string.h
index bec3fe167..bdf3cff7f 100644
--- a/third_party/libcxx/__format/format_string.h
+++ b/third_party/libcxx/__format/format_string.h
@@ -14,7 +14,7 @@
 #include <__config>
 #include <__format/format_error.h>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h> // iter_value_t
+#include <__iterator/iterator_traits.h> // iter_value_t
 #include <cstddef>
 #include <cstdint>
 
@@ -38,8 +38,7 @@ template <contiguous_iterator _Iterator>
 __parse_number_result(_Iterator, uint32_t) -> __parse_number_result<_Iterator>;
 
 template <contiguous_iterator _Iterator>
-_LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_Iterator>
-__parse_number(_Iterator __begin, _Iterator __end);
+_LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_Iterator> __parse_number(_Iterator __begin, _Iterator __end);
 
 /**
  * The maximum value of a numeric argument.
@@ -66,8 +65,7 @@ template <contiguous_iterator _Iterator>
 _LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_Iterator>
 __parse_automatic(_Iterator __begin, _Iterator, auto& __parse_ctx) {
   size_t __value = __parse_ctx.next_arg_id();
-  _LIBCPP_ASSERT(__value <= __number_max,
-                 "Compilers don't support this number of arguments");
+  _LIBCPP_ASSERT_UNCATEGORIZED(__value <= __number_max, "Compilers don't support this number of arguments");
 
   return {__begin, uint32_t(__value)};
 }
@@ -92,8 +90,7 @@ template <contiguous_iterator _Iterator>
 _LIBCPP_HIDE_FROM_ABI constexpr __parse_number_result<_Iterator>
 __parse_number(_Iterator __begin, _Iterator __end_input) {
   using _CharT = iter_value_t<_Iterator>;
-  static_assert(__format::__number_max == INT32_MAX,
-                "The algorithm is implemented based on this value.");
+  static_assert(__format::__number_max == INT32_MAX, "The algorithm is implemented based on this value.");
   /*
    * Limit the input to 9 digits, otherwise we need two checks during every
    * iteration:
@@ -101,7 +98,7 @@ __parse_number(_Iterator __begin, _Iterator __end_input) {
    * - Does the value exceed width of an uint32_t? (Switching to uint64_t would
    *   have the same issue, but with a higher maximum.)
    */
-  _Iterator __end = __end_input - __begin > 9 ? __begin + 9 : __end_input;
+  _Iterator __end  = __end_input - __begin > 9 ? __begin + 9 : __end_input;
   uint32_t __value = *__begin - _CharT('0');
   while (++__begin != __end) {
     if (*__begin < _CharT('0') || *__begin > _CharT('9'))
@@ -110,9 +107,7 @@ __parse_number(_Iterator __begin, _Iterator __end_input) {
     __value = __value * 10 + *__begin - _CharT('0');
   }
 
-  if (__begin != __end_input && *__begin >= _CharT('0') &&
-      *__begin <= _CharT('9')) {
-
+  if (__begin != __end_input && *__begin >= _CharT('0') && *__begin <= _CharT('9')) {
     /*
      * There are more than 9 digits, do additional validations:
      * - Does the 10th digit exceed the maximum allowed value?
@@ -120,10 +115,8 @@ __parse_number(_Iterator __begin, _Iterator __end_input) {
      * (More than 10 digits always overflows the maximum.)
      */
     uint64_t __v = uint64_t(__value) * 10 + *__begin++ - _CharT('0');
-    if (__v > __number_max ||
-        (__begin != __end_input && *__begin >= _CharT('0') &&
-         *__begin <= _CharT('9')))
-      std::__throw_format_error("The numeric value of the format-spec is too large");
+    if (__v > __number_max || (__begin != __end_input && *__begin >= _CharT('0') && *__begin <= _CharT('9')))
+      std::__throw_format_error("The numeric value of the format specifier is too large");
 
     __value = __v;
   }
@@ -153,7 +146,7 @@ __parse_arg_id(_Iterator __begin, _Iterator __end, auto& __parse_ctx) {
     return __detail::__parse_automatic(__begin, __end, __parse_ctx);
   }
   if (*__begin < _CharT('0') || *__begin > _CharT('9'))
-    std::__throw_format_error("The arg-id of the format-spec starts with an invalid character");
+    std::__throw_format_error("The argument index starts with an invalid character");
 
   return __detail::__parse_manual(__begin, __end, __parse_ctx);
 }
diff --git a/third_party/libcxx/__format/formatter.h b/third_party/libcxx/__format/formatter.h
index 172b2d5f7..e2f418f93 100644
--- a/third_party/libcxx/__format/formatter.h
+++ b/third_party/libcxx/__format/formatter.h
@@ -10,9 +10,8 @@
 #ifndef _LIBCPP___FORMAT_FORMATTER_H
 #define _LIBCPP___FORMAT_FORMATTER_H
 
-#include <__availability>
 #include <__config>
-#include <__format/format_fwd.h>
+#include <__fwd/format.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -33,8 +32,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 /// - is_move_assignable<F>.
 template <class _Tp, class _CharT>
 struct _LIBCPP_TEMPLATE_VIS formatter {
-  formatter() = delete;
-  formatter(const formatter&) = delete;
+  formatter()                            = delete;
+  formatter(const formatter&)            = delete;
   formatter& operator=(const formatter&) = delete;
 };
 
diff --git a/third_party/libcxx/__format/formatter_bool.h b/third_party/libcxx/__format/formatter_bool.h
index e95a216bb..17dc69541 100644
--- a/third_party/libcxx/__format/formatter_bool.h
+++ b/third_party/libcxx/__format/formatter_bool.h
@@ -11,20 +11,17 @@
 #define _LIBCPP___FORMAT_FORMATTER_BOOL_H
 
 #include <__algorithm/copy.h>
-#include <__availability>
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__format/concepts.h>
-#include <__format/format_error.h>
 #include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
 #include <__format/parser_std_format_spec.h>
 #include <__utility/unreachable.h>
-#include <string_view>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#  include <locale>
+#  include <__locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -41,7 +38,7 @@ public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
-    __format_spec::__process_parsed_bool(__parser_);
+    __format_spec::__process_parsed_bool(__parser_, "a bool");
     return __result;
   }
 
@@ -64,7 +61,7 @@ public:
           static_cast<unsigned>(__value), __ctx, __parser_.__get_parsed_std_specifications(__ctx));
 
     default:
-      _LIBCPP_ASSERT(false, "The parse function should have validated the type");
+      _LIBCPP_ASSERT_INTERNAL(false, "The parse function should have validated the type");
       __libcpp_unreachable();
     }
   }
diff --git a/third_party/libcxx/__format/formatter_char.h b/third_party/libcxx/__format/formatter_char.h
index 15a649807..d33e84368 100644
--- a/third_party/libcxx/__format/formatter_char.h
+++ b/third_party/libcxx/__format/formatter_char.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___FORMAT_FORMATTER_CHAR_H
 #define _LIBCPP___FORMAT_FORMATTER_CHAR_H
 
-#include <__availability>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/concepts.h>
@@ -19,8 +18,9 @@
 #include <__format/formatter_integral.h>
 #include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
+#include <__format/write_escaped.h>
 #include <__type_traits/conditional.h>
-#include <__type_traits/is_signed.h>
+#include <__type_traits/make_unsigned.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -36,7 +36,7 @@ public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
-    __format_spec::__process_parsed_char(__parser_);
+    __format_spec::__process_parsed_char(__parser_, "a character");
     return __result;
   }
 
@@ -50,22 +50,21 @@ public:
       return __formatter::__format_escaped_char(__value, __ctx.out(), __parser_.__get_parsed_std_specifications(__ctx));
 #  endif
 
-    if constexpr (sizeof(_CharT) <= sizeof(int))
-      // Promotes _CharT to an integral type. This reduces the number of
-      // instantiations of __format_integer reducing code size.
+    if constexpr (sizeof(_CharT) <= sizeof(unsigned))
       return __formatter::__format_integer(
-          static_cast<conditional_t<is_signed_v<_CharT>, int, unsigned>>(__value),
+          static_cast<unsigned>(static_cast<make_unsigned_t<_CharT>>(__value)),
           __ctx,
           __parser_.__get_parsed_std_specifications(__ctx));
     else
-      return __formatter::__format_integer(__value, __ctx, __parser_.__get_parsed_std_specifications(__ctx));
+      return __formatter::__format_integer(
+          static_cast<make_unsigned_t<_CharT>>(__value), __ctx, __parser_.__get_parsed_std_specifications(__ctx));
   }
 
   template <class _FormatContext>
   _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(char __value, _FormatContext& __ctx) const
     requires(same_as<_CharT, wchar_t>)
   {
-    return format(static_cast<wchar_t>(__value), __ctx);
+    return format(static_cast<wchar_t>(static_cast<unsigned char>(__value)), __ctx);
   }
 
 #  if _LIBCPP_STD_VER >= 23
@@ -83,8 +82,7 @@ template <>
 struct _LIBCPP_TEMPLATE_VIS formatter<char, wchar_t> : public __formatter_char<wchar_t> {};
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS formatter<wchar_t, wchar_t> : public __formatter_char<wchar_t> {
-};
+struct _LIBCPP_TEMPLATE_VIS formatter<wchar_t, wchar_t> : public __formatter_char<wchar_t> {};
 
 #  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
diff --git a/third_party/libcxx/__format/formatter_floating_point.h b/third_party/libcxx/__format/formatter_floating_point.h
index a699f403e..fa42ba203 100644
--- a/third_party/libcxx/__format/formatter_floating_point.h
+++ b/third_party/libcxx/__format/formatter_floating_point.h
@@ -16,6 +16,7 @@
 #include <__algorithm/min.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/transform.h>
+#include <__assert>
 #include <__charconv/chars_format.h>
 #include <__charconv/to_chars_floating_point.h>
 #include <__charconv/to_chars_result.h>
@@ -28,6 +29,7 @@
 #include <__format/formatter_integral.h>
 #include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
+#include <__iterator/concepts.h>
 #include <__memory/allocator.h>
 #include <__system_error/errc.h>
 #include <__type_traits/conditional.h>
@@ -37,7 +39,7 @@
 #include <cstddef>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#  include <locale>
+#  include <__locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -55,22 +57,22 @@ namespace __formatter {
 
 template <floating_point _Tp>
 _LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last, _Tp __value) {
-  to_chars_result __r = _VSTD::to_chars(__first, __last, __value);
-  _LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small");
+  to_chars_result __r = std::to_chars(__first, __last, __value);
+  _LIBCPP_ASSERT_INTERNAL(__r.ec == errc(0), "Internal buffer too small");
   return __r.ptr;
 }
 
 template <floating_point _Tp>
 _LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last, _Tp __value, chars_format __fmt) {
-  to_chars_result __r = _VSTD::to_chars(__first, __last, __value, __fmt);
-  _LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small");
+  to_chars_result __r = std::to_chars(__first, __last, __value, __fmt);
+  _LIBCPP_ASSERT_INTERNAL(__r.ec == errc(0), "Internal buffer too small");
   return __r.ptr;
 }
 
 template <floating_point _Tp>
 _LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last, _Tp __value, chars_format __fmt, int __precision) {
-  to_chars_result __r = _VSTD::to_chars(__first, __last, __value, __fmt, __precision);
-  _LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small");
+  to_chars_result __r = std::to_chars(__first, __last, __value, __fmt, __precision);
+  _LIBCPP_ASSERT_INTERNAL(__r.ec == errc(0), "Internal buffer too small");
   return __r.ptr;
 }
 
@@ -115,8 +117,8 @@ _LIBCPP_HIDE_FROM_ABI constexpr size_t __float_buffer_size(int __precision) {
 
 template <>
 struct __traits<float> {
-  static constexpr int __max_integral = 38;
-  static constexpr int __max_fractional = 149;
+  static constexpr int __max_integral         = 38;
+  static constexpr int __max_fractional       = 149;
   static constexpr int __max_fractional_value = 3;
   static constexpr size_t __stack_buffer_size = 256;
 
@@ -125,8 +127,8 @@ struct __traits<float> {
 
 template <>
 struct __traits<double> {
-  static constexpr int __max_integral = 308;
-  static constexpr int __max_fractional = 1074;
+  static constexpr int __max_integral         = 308;
+  static constexpr int __max_fractional       = 1074;
   static constexpr int __max_fractional_value = 4;
   static constexpr size_t __stack_buffer_size = 1024;
 
@@ -135,7 +137,7 @@ struct __traits<double> {
 
 /// Helper class to store the conversion buffer.
 ///
-/// Depending on the maxium size required for a value, the buffer is allocated
+/// Depending on the maximum size required for a value, the buffer is allocated
 /// on the stack or the heap.
 template <floating_point _Fp>
 class _LIBCPP_TEMPLATE_VIS __float_buffer {
@@ -152,7 +154,6 @@ public:
   // required.
   explicit _LIBCPP_HIDE_FROM_ABI __float_buffer(int __precision)
       : __precision_(__precision != -1 ? __precision : _Traits::__max_fractional) {
-
     // When the precision is larger than _Traits::__max_fractional the digits in
     // the range (_Traits::__max_fractional, precision] will contain the value
     // zero. There's no need to request to_chars to write these zeros:
@@ -164,7 +165,7 @@ public:
     //     to be converted from a char to a wchar_t.
     if (__precision_ > _Traits::__max_fractional) {
       __num_trailing_zeros_ = __precision_ - _Traits::__max_fractional;
-      __precision_ = _Traits::__max_fractional;
+      __precision_          = _Traits::__max_fractional;
     }
 
     __size_ = __formatter::__float_buffer_size<_Fp>(__precision_);
@@ -179,7 +180,7 @@ public:
     if (__size_ > _Traits::__stack_buffer_size)
       allocator<char>{}.deallocate(__begin_, __size_);
   }
-  _LIBCPP_HIDE_FROM_ABI __float_buffer(const __float_buffer&) = delete;
+  _LIBCPP_HIDE_FROM_ABI __float_buffer(const __float_buffer&)            = delete;
   _LIBCPP_HIDE_FROM_ABI __float_buffer& operator=(const __float_buffer&) = delete;
 
   _LIBCPP_HIDE_FROM_ABI char* begin() const { return __begin_; }
@@ -223,7 +224,7 @@ struct __float_result {
 constexpr inline _LIBCPP_HIDE_FROM_ABI char* __find_exponent(char* __first, char* __last) {
   ptrdiff_t __size = __last - __first;
   if (__size >= 4) {
-    __first = __last - _VSTD::min(__size, ptrdiff_t(6));
+    __first = __last - std::min(__size, ptrdiff_t(6));
     for (; __first != __last - 3; ++__first) {
       if (*__first == 'e')
         return __first;
@@ -233,8 +234,8 @@ constexpr inline _LIBCPP_HIDE_FROM_ABI char* __find_exponent(char* __first, char
 }
 
 template <class _Fp, class _Tp>
-_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_default(const __float_buffer<_Fp>& __buffer, _Tp __value,
-                                                             char* __integral) {
+_LIBCPP_HIDE_FROM_ABI __float_result
+__format_buffer_default(const __float_buffer<_Fp>& __buffer, _Tp __value, char* __integral) {
   __float_result __result;
   __result.__integral = __integral;
   __result.__last     = __formatter::__to_buffer(__integral, __buffer.end(), __value);
@@ -244,7 +245,7 @@ _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_default(const __float_buffe
   // Constrains:
   // - There's at least one decimal digit before the radix point.
   // - The radix point, when present, is placed before the exponent.
-  __result.__radix_point = _VSTD::find(__result.__integral + 1, __result.__exponent, '.');
+  __result.__radix_point = std::find(__result.__integral + 1, __result.__exponent, '.');
 
   // When the radix point isn't found its position is the exponent instead of
   // __result.__last.
@@ -252,19 +253,18 @@ _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_default(const __float_buffe
     __result.__radix_point = __result.__last;
 
   // clang-format off
-  _LIBCPP_ASSERT((__result.__integral != __result.__last) &&
-                 (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
-                 (__result.__exponent == __result.__last || *__result.__exponent == 'e'),
-                 "Post-condition failure.");
+  _LIBCPP_ASSERT_INTERNAL((__result.__integral != __result.__last) &&
+                          (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
+                          (__result.__exponent == __result.__last || *__result.__exponent == 'e'),
+                          "Post-condition failure.");
   // clang-format on
 
   return __result;
 }
 
 template <class _Fp, class _Tp>
-_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_hexadecimal_lower_case(const __float_buffer<_Fp>& __buffer,
-                                                                            _Tp __value, int __precision,
-                                                                            char* __integral) {
+_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_hexadecimal_lower_case(
+    const __float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) {
   __float_result __result;
   __result.__integral = __integral;
   if (__precision == -1)
@@ -296,67 +296,64 @@ _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_hexadecimal_lower_case(cons
     // 0123456789
     static_assert(__traits<_Fp>::__hex_precision_digits <= 4, "Guard against possible underflow.");
 
-    char* __last = __result.__last - 2;
-    __first = __last - __traits<_Fp>::__hex_precision_digits;
-    __result.__exponent = _VSTD::find(__first, __last, 'p');
+    char* __last        = __result.__last - 2;
+    __first             = __last - __traits<_Fp>::__hex_precision_digits;
+    __result.__exponent = std::find(__first, __last, 'p');
   } else {
     __result.__radix_point = __result.__last;
-    __result.__exponent = __first;
+    __result.__exponent    = __first;
   }
 
   // clang-format off
-  _LIBCPP_ASSERT((__result.__integral != __result.__last) &&
-                 (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
-                 (__result.__exponent != __result.__last && *__result.__exponent == 'p'),
-                 "Post-condition failure.");
+  _LIBCPP_ASSERT_INTERNAL((__result.__integral != __result.__last) &&
+                          (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
+                          (__result.__exponent != __result.__last && *__result.__exponent == 'p'),
+                          "Post-condition failure.");
   // clang-format on
 
   return __result;
 }
 
 template <class _Fp, class _Tp>
-_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_hexadecimal_upper_case(const __float_buffer<_Fp>& __buffer,
-                                                                            _Tp __value, int __precision,
-                                                                            char* __integral) {
+_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_hexadecimal_upper_case(
+    const __float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) {
   __float_result __result =
       __formatter::__format_buffer_hexadecimal_lower_case(__buffer, __value, __precision, __integral);
-  _VSTD::transform(__result.__integral, __result.__exponent, __result.__integral, __hex_to_upper);
+  std::transform(__result.__integral, __result.__exponent, __result.__integral, __hex_to_upper);
   *__result.__exponent = 'P';
   return __result;
 }
 
 template <class _Fp, class _Tp>
-_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_scientific_lower_case(const __float_buffer<_Fp>& __buffer,
-                                                                           _Tp __value, int __precision,
-                                                                           char* __integral) {
+_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_scientific_lower_case(
+    const __float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) {
   __float_result __result;
   __result.__integral = __integral;
   __result.__last =
       __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::scientific, __precision);
 
   char* __first = __integral + 1;
-  _LIBCPP_ASSERT(__first != __result.__last, "No exponent present");
+  _LIBCPP_ASSERT_INTERNAL(__first != __result.__last, "No exponent present");
   if (*__first == '.') {
     __result.__radix_point = __first;
     __result.__exponent    = __formatter::__find_exponent(__first + 1, __result.__last);
   } else {
     __result.__radix_point = __result.__last;
-    __result.__exponent = __first;
+    __result.__exponent    = __first;
   }
 
   // clang-format off
-  _LIBCPP_ASSERT((__result.__integral != __result.__last) &&
-                 (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
-                 (__result.__exponent != __result.__last && *__result.__exponent == 'e'),
-                 "Post-condition failure.");
+  _LIBCPP_ASSERT_INTERNAL((__result.__integral != __result.__last) &&
+                          (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
+                          (__result.__exponent != __result.__last && *__result.__exponent == 'e'),
+                          "Post-condition failure.");
   // clang-format on
   return __result;
 }
 
 template <class _Fp, class _Tp>
-_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_scientific_upper_case(const __float_buffer<_Fp>& __buffer,
-                                                                           _Tp __value, int __precision,
-                                                                           char* __integral) {
+_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_scientific_upper_case(
+    const __float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) {
   __float_result __result =
       __formatter::__format_buffer_scientific_lower_case(__buffer, __value, __precision, __integral);
   *__result.__exponent = 'E';
@@ -364,8 +361,8 @@ _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_scientific_upper_case(const
 }
 
 template <class _Fp, class _Tp>
-_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_fixed(const __float_buffer<_Fp>& __buffer, _Tp __value,
-                                                           int __precision, char* __integral) {
+_LIBCPP_HIDE_FROM_ABI __float_result
+__format_buffer_fixed(const __float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) {
   __float_result __result;
   __result.__integral = __integral;
   __result.__last     = __formatter::__to_buffer(__integral, __buffer.end(), __value, chars_format::fixed, __precision);
@@ -375,21 +372,20 @@ _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_fixed(const __float_buffer<
   // By converting __precision to a bool the subtraction can be done
   // unconditionally.
   __result.__radix_point = __result.__last - (__precision + bool(__precision));
-  __result.__exponent = __result.__last;
+  __result.__exponent    = __result.__last;
 
   // clang-format off
-  _LIBCPP_ASSERT((__result.__integral != __result.__last) &&
-                 (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
-                 (__result.__exponent == __result.__last),
-                 "Post-condition failure.");
+  _LIBCPP_ASSERT_INTERNAL((__result.__integral != __result.__last) &&
+                          (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
+                          (__result.__exponent == __result.__last),
+                          "Post-condition failure.");
   // clang-format on
   return __result;
 }
 
 template <class _Fp, class _Tp>
-_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_general_lower_case(__float_buffer<_Fp>& __buffer, _Tp __value,
-                                                                        int __precision, char* __integral) {
-
+_LIBCPP_HIDE_FROM_ABI __float_result
+__format_buffer_general_lower_case(__float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) {
   __buffer.__remove_trailing_zeros();
 
   __float_result __result;
@@ -399,7 +395,7 @@ _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_general_lower_case(__float_
   char* __first = __integral + 1;
   if (__first == __result.__last) {
     __result.__radix_point = __result.__last;
-    __result.__exponent = __result.__last;
+    __result.__exponent    = __result.__last;
   } else {
     __result.__exponent = __formatter::__find_exponent(__first, __result.__last);
     if (__result.__exponent != __result.__last)
@@ -410,23 +406,23 @@ _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_general_lower_case(__float_
       // In fixed mode the algorithm truncates trailing spaces and possibly the
       // radix point. There's no good guess for the position of the radix point
       // therefore scan the output after the first digit.
-      __result.__radix_point = _VSTD::find(__first, __result.__last, '.');
+      __result.__radix_point = std::find(__first, __result.__last, '.');
     }
   }
 
   // clang-format off
-  _LIBCPP_ASSERT((__result.__integral != __result.__last) &&
-                 (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
-                 (__result.__exponent == __result.__last || *__result.__exponent == 'e'),
-                 "Post-condition failure.");
+  _LIBCPP_ASSERT_INTERNAL((__result.__integral != __result.__last) &&
+                          (__result.__radix_point == __result.__last || *__result.__radix_point == '.') &&
+                          (__result.__exponent == __result.__last || *__result.__exponent == 'e'),
+                          "Post-condition failure.");
   // clang-format on
 
   return __result;
 }
 
 template <class _Fp, class _Tp>
-_LIBCPP_HIDE_FROM_ABI __float_result __format_buffer_general_upper_case(__float_buffer<_Fp>& __buffer, _Tp __value,
-                                                                        int __precision, char* __integral) {
+_LIBCPP_HIDE_FROM_ABI __float_result
+__format_buffer_general_upper_case(__float_buffer<_Fp>& __buffer, _Tp __value, int __precision, char* __integral) {
   __float_result __result = __formatter::__format_buffer_general_lower_case(__buffer, __value, __precision, __integral);
   if (__result.__exponent != __result.__last)
     *__result.__exponent = 'E';
@@ -490,7 +486,7 @@ _LIBCPP_HIDE_FROM_ABI __float_result __format_buffer(
     return __formatter::__format_buffer_general_upper_case(__buffer, __value, __buffer.__precision(), __first);
 
   default:
-    _LIBCPP_ASSERT(false, "The parser should have validated the type");
+    _LIBCPP_ASSERT_INTERNAL(false, "The parser should have validated the type");
     __libcpp_unreachable();
   }
 }
@@ -501,13 +497,13 @@ _LIBCPP_HIDE_FROM_ABI _OutIt __format_locale_specific_form(
     _OutIt __out_it,
     const __float_buffer<_Fp>& __buffer,
     const __float_result& __result,
-    _VSTD::locale __loc,
+    std::locale __loc,
     __format_spec::__parsed_specifications<_CharT> __specs) {
-  const auto& __np = std::use_facet<numpunct<_CharT>>(__loc);
+  const auto& __np  = std::use_facet<numpunct<_CharT>>(__loc);
   string __grouping = __np.grouping();
-  char* __first = __result.__integral;
+  char* __first     = __result.__integral;
   // When no radix point or exponent are present __last will be __result.__last.
-  char* __last = _VSTD::min(__result.__radix_point, __result.__exponent);
+  char* __last = std::min(__result.__radix_point, __result.__exponent);
 
   ptrdiff_t __digits = __last - __first;
   if (!__grouping.empty()) {
@@ -523,11 +519,11 @@ _LIBCPP_HIDE_FROM_ABI _OutIt __format_locale_specific_form(
       __grouping.size() -                  // Grouping contains one
       !__grouping.empty();                 // additional character
 
-  __formatter::__padding_size_result __padding    = {0, 0};
-  bool __zero_padding                             = __specs.__alignment_ == __format_spec::__alignment::__zero_padding;
+  __formatter::__padding_size_result __padding = {0, 0};
+  bool __zero_padding                          = __specs.__alignment_ == __format_spec::__alignment::__zero_padding;
   if (__size < __specs.__width_) {
     if (__zero_padding) {
-      __specs.__alignment_ = __format_spec::__alignment::__right;
+      __specs.__alignment_      = __format_spec::__alignment::__right;
       __specs.__fill_.__data[0] = _CharT('0');
     }
 
@@ -537,16 +533,16 @@ _LIBCPP_HIDE_FROM_ABI _OutIt __format_locale_specific_form(
   // sign and (zero padding or alignment)
   if (__zero_padding && __first != __buffer.begin())
     *__out_it++ = *__buffer.begin();
-  __out_it = __formatter::__fill(_VSTD::move(__out_it), __padding.__before_, __specs.__fill_);
+  __out_it = __formatter::__fill(std::move(__out_it), __padding.__before_, __specs.__fill_);
   if (!__zero_padding && __first != __buffer.begin())
     *__out_it++ = *__buffer.begin();
 
   // integral part
   if (__grouping.empty()) {
-    __out_it = __formatter::__copy(__first, __digits, _VSTD::move(__out_it));
+    __out_it = __formatter::__copy(__first, __digits, std::move(__out_it));
   } else {
-    auto __r = __grouping.rbegin();
-    auto __e = __grouping.rend() - 1;
+    auto __r     = __grouping.rbegin();
+    auto __e     = __grouping.rend() - 1;
     _CharT __sep = __np.thousands_sep();
     // The output is divided in small groups of numbers to write:
     // - A group before the first separator.
@@ -555,7 +551,7 @@ _LIBCPP_HIDE_FROM_ABI _OutIt __format_locale_specific_form(
     // This loop achieves that process by testing the termination condition
     // midway in the loop.
     while (true) {
-      __out_it = __formatter::__copy(__first, *__r, _VSTD::move(__out_it));
+      __out_it = __formatter::__copy(__first, *__r, std::move(__out_it));
       __first += *__r;
 
       if (__r == __e)
@@ -569,16 +565,16 @@ _LIBCPP_HIDE_FROM_ABI _OutIt __format_locale_specific_form(
   // fractional part
   if (__result.__radix_point != __result.__last) {
     *__out_it++ = __np.decimal_point();
-    __out_it    = __formatter::__copy(__result.__radix_point + 1, __result.__exponent, _VSTD::move(__out_it));
-    __out_it    = __formatter::__fill(_VSTD::move(__out_it), __buffer.__num_trailing_zeros(), _CharT('0'));
+    __out_it    = __formatter::__copy(__result.__radix_point + 1, __result.__exponent, std::move(__out_it));
+    __out_it    = __formatter::__fill(std::move(__out_it), __buffer.__num_trailing_zeros(), _CharT('0'));
   }
 
   // exponent
   if (__result.__exponent != __result.__last)
-    __out_it = __formatter::__copy(__result.__exponent, __result.__last, _VSTD::move(__out_it));
+    __out_it = __formatter::__copy(__result.__exponent, __result.__last, std::move(__out_it));
 
   // alignment
-  return __formatter::__fill(_VSTD::move(__out_it), __padding.__after_, __specs.__fill_);
+  return __formatter::__fill(std::move(__out_it), __padding.__after_, __specs.__fill_);
 }
 #  endif // _LIBCPP_HAS_NO_LOCALIZATION
 
@@ -596,7 +592,7 @@ _LIBCPP_HIDE_FROM_ABI _OutIt __format_floating_point_non_finite(
       __specs.__std_.__type_ == __format_spec::__type::__scientific_upper_case ||
       __specs.__std_.__type_ == __format_spec::__type::__fixed_upper_case ||
       __specs.__std_.__type_ == __format_spec::__type::__general_upper_case;
-  __last = _VSTD::copy_n(&("infnanINFNAN"[6 * __upper_case + 3 * __isnan]), 3, __last);
+  __last = std::copy_n(&("infnanINFNAN"[6 * __upper_case + 3 * __isnan]), 3, __last);
 
   // [format.string.std]/13
   // A zero (0) character preceding the width field pads the field with
@@ -605,16 +601,45 @@ _LIBCPP_HIDE_FROM_ABI _OutIt __format_floating_point_non_finite(
   if (__specs.__alignment_ == __format_spec::__alignment::__zero_padding)
     __specs.__alignment_ = __format_spec::__alignment::__right;
 
-  return __formatter::__write(__buffer, __last, _VSTD::move(__out_it), __specs);
+  return __formatter::__write(__buffer, __last, std::move(__out_it), __specs);
+}
+
+/// Writes additional zero's for the precision before the exponent.
+/// This is used when the precision requested in the format string is larger
+/// than the maximum precision of the floating-point type. These precision
+/// digits are always 0.
+///
+/// \param __exponent           The location of the exponent character.
+/// \param __num_trailing_zeros The number of 0's to write before the exponent
+///                             character.
+template <class _CharT, class _ParserCharT>
+_LIBCPP_HIDE_FROM_ABI auto __write_using_trailing_zeros(
+    const _CharT* __first,
+    const _CharT* __last,
+    output_iterator<const _CharT&> auto __out_it,
+    __format_spec::__parsed_specifications<_ParserCharT> __specs,
+    size_t __size,
+    const _CharT* __exponent,
+    size_t __num_trailing_zeros) -> decltype(__out_it) {
+  _LIBCPP_ASSERT_INTERNAL(__first <= __last, "Not a valid range");
+  _LIBCPP_ASSERT_INTERNAL(__num_trailing_zeros > 0, "The overload not writing trailing zeros should have been used");
+
+  __padding_size_result __padding =
+      __formatter::__padding_size(__size + __num_trailing_zeros, __specs.__width_, __specs.__alignment_);
+  __out_it = __formatter::__fill(std::move(__out_it), __padding.__before_, __specs.__fill_);
+  __out_it = __formatter::__copy(__first, __exponent, std::move(__out_it));
+  __out_it = __formatter::__fill(std::move(__out_it), __num_trailing_zeros, _CharT('0'));
+  __out_it = __formatter::__copy(__exponent, __last, std::move(__out_it));
+  return __formatter::__fill(std::move(__out_it), __padding.__after_, __specs.__fill_);
 }
 
 template <floating_point _Tp, class _CharT, class _FormatContext>
 _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
 __format_floating_point(_Tp __value, _FormatContext& __ctx, __format_spec::__parsed_specifications<_CharT> __specs) {
-  bool __negative = _VSTD::signbit(__value);
+  bool __negative = std::signbit(__value);
 
-  if (!_VSTD::isfinite(__value)) [[unlikely]]
-    return __formatter::__format_floating_point_non_finite(__ctx.out(), __specs, __negative, _VSTD::isnan(__value));
+  if (!std::isfinite(__value)) [[unlikely]]
+    return __formatter::__format_floating_point_non_finite(__ctx.out(), __specs, __negative, std::isnan(__value));
 
   // Depending on the std-format-spec string the sign and the value
   // might not be outputted together:
@@ -640,7 +665,7 @@ __format_floating_point(_Tp __value, _FormatContext& __ctx, __format_spec::__par
       // When there is an exponent the point needs to be moved before the
       // exponent. When there's no exponent the rotate does nothing. Since
       // rotate tests whether the operation is a nop, call it unconditionally.
-      _VSTD::rotate(__result.__exponent, __result.__last - 1, __result.__last);
+      std::rotate(__result.__exponent, __result.__last - 1, __result.__last);
       __result.__radix_point = __result.__exponent;
 
       // The radix point is always placed before the exponent.
@@ -665,7 +690,7 @@ __format_floating_point(_Tp __value, _FormatContext& __ctx, __format_spec::__par
       // Let P equal the precision if nonzero, 6 if the precision is not
       // specified, or 1 if the precision is 0. Then, if a conversion with
       // style E would have an exponent of X:
-      int __p = _VSTD::max(1, (__specs.__has_precision() ? __specs.__precision_ : 6));
+      int __p = std::max<int>(1, (__specs.__has_precision() ? __specs.__precision_ : 6));
       if (__result.__exponent == __result.__last)
         // if P > X >= -4, the conversion is with style f or F and precision P - 1 - X.
         // By including the radix point it calculates P - (1 + X)
@@ -711,15 +736,15 @@ __format_floating_point(_Tp __value, _FormatContext& __ctx, __format_spec::__par
       *__out_it++ = *__first++;
     // After the sign is written, zero padding is the same a right alignment
     // with '0'.
-    __specs.__alignment_ = __format_spec::__alignment::__right;
+    __specs.__alignment_      = __format_spec::__alignment::__right;
     __specs.__fill_.__data[0] = _CharT('0');
   }
 
   if (__num_trailing_zeros)
     return __formatter::__write_using_trailing_zeros(
-        __first, __result.__last, _VSTD::move(__out_it), __specs, __size, __result.__exponent, __num_trailing_zeros);
+        __first, __result.__last, std::move(__out_it), __specs, __size, __result.__exponent, __num_trailing_zeros);
 
-  return __formatter::__write(__first, __result.__last, _VSTD::move(__out_it), __specs, __size);
+  return __formatter::__write(__first, __result.__last, std::move(__out_it), __specs, __size);
 }
 
 } // namespace __formatter
@@ -730,7 +755,7 @@ public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_floating_point);
-    __format_spec::__process_parsed_floating_point(__parser_);
+    __format_spec::__process_parsed_floating_point(__parser_, "a floating-point");
     return __result;
   }
 
@@ -743,14 +768,11 @@ public:
 };
 
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<float, _CharT>
-    : public __formatter_floating_point<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<float, _CharT> : public __formatter_floating_point<_CharT> {};
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<double, _CharT>
-    : public __formatter_floating_point<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<double, _CharT> : public __formatter_floating_point<_CharT> {};
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<long double, _CharT>
-    : public __formatter_floating_point<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<long double, _CharT> : public __formatter_floating_point<_CharT> {};
 
 #endif //_LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__format/formatter_integer.h b/third_party/libcxx/__format/formatter_integer.h
index f7dac2885..41400f004 100644
--- a/third_party/libcxx/__format/formatter_integer.h
+++ b/third_party/libcxx/__format/formatter_integer.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___FORMAT_FORMATTER_INTEGER_H
 #define _LIBCPP___FORMAT_FORMATTER_INTEGER_H
 
-#include <__availability>
 #include <__concepts/arithmetic.h>
 #include <__config>
 #include <__format/concepts.h>
@@ -19,25 +18,24 @@
 #include <__format/formatter_integral.h>
 #include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
-#include <__type_traits/is_same.h>
+#include <__type_traits/is_void.h>
 #include <__type_traits/make_32_64_or_128_bit.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-    _LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-    template <__fmt_char_type _CharT>
-    struct _LIBCPP_TEMPLATE_VIS __formatter_integer {
-
+template <__fmt_char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS __formatter_integer {
 public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
-    __format_spec::__process_parsed_integer(__parser_);
+    __format_spec::__process_parsed_integer(__parser_, "an integer");
     return __result;
   }
 
@@ -49,7 +47,7 @@ public:
       return __formatter::__format_char(__value, __ctx.out(), __specs);
 
     using _Type = __make_32_64_or_128_bit_t<_Tp>;
-    static_assert(!is_same<_Type, void>::value, "unsupported integral type used in __formatter_integer::__format");
+    static_assert(!is_void<_Type>::value, "unsupported integral type used in __formatter_integer::__format");
 
     // Reduce the number of instantiation of the integer formatter
     return __formatter::__format_integer(static_cast<_Type>(__value), __ctx, __specs);
@@ -60,44 +58,34 @@ public:
 
 // Signed integral types.
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<signed char, _CharT>
-    : public __formatter_integer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<signed char, _CharT> : public __formatter_integer<_CharT> {};
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<short, _CharT> : public __formatter_integer<_CharT> {
-};
+struct _LIBCPP_TEMPLATE_VIS formatter<short, _CharT> : public __formatter_integer<_CharT> {};
 template <__fmt_char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS formatter<int, _CharT> : public __formatter_integer<_CharT> {};
 template <__fmt_char_type _CharT>
 struct _LIBCPP_TEMPLATE_VIS formatter<long, _CharT> : public __formatter_integer<_CharT> {};
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<long long, _CharT>
-    : public __formatter_integer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<long long, _CharT> : public __formatter_integer<_CharT> {};
 #  ifndef _LIBCPP_HAS_NO_INT128
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<__int128_t, _CharT>
-    : public __formatter_integer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<__int128_t, _CharT> : public __formatter_integer<_CharT> {};
 #  endif
 
 // Unsigned integral types.
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<unsigned char, _CharT>
-    : public __formatter_integer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<unsigned char, _CharT> : public __formatter_integer<_CharT> {};
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<unsigned short, _CharT>
-    : public __formatter_integer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<unsigned short, _CharT> : public __formatter_integer<_CharT> {};
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<unsigned, _CharT>
-    : public __formatter_integer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<unsigned, _CharT> : public __formatter_integer<_CharT> {};
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long, _CharT>
-    : public __formatter_integer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long, _CharT> : public __formatter_integer<_CharT> {};
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long long, _CharT>
-    : public __formatter_integer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<unsigned long long, _CharT> : public __formatter_integer<_CharT> {};
 #  ifndef _LIBCPP_HAS_NO_INT128
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<__uint128_t, _CharT>
-    : public __formatter_integer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<__uint128_t, _CharT> : public __formatter_integer<_CharT> {};
 #  endif
 
 #endif //_LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__format/formatter_integral.h b/third_party/libcxx/__format/formatter_integral.h
index 657c9bd15..eca966f88 100644
--- a/third_party/libcxx/__format/formatter_integral.h
+++ b/third_party/libcxx/__format/formatter_integral.h
@@ -20,6 +20,9 @@
 #include <__format/format_error.h>
 #include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/pointer_traits.h>
 #include <__system_error/errc.h>
 #include <__type_traits/make_unsigned.h>
 #include <__utility/unreachable.h>
@@ -29,7 +32,7 @@
 #include <string_view>
 
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
-#  include <locale>
+#  include <__locale>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -49,7 +52,9 @@ namespace __formatter {
 // Generic
 //
 
-_LIBCPP_HIDE_FROM_ABI inline char* __insert_sign(char* __buf, bool __negative, __format_spec::__sign __sign) {
+template <contiguous_iterator _Iterator>
+  requires same_as<char, iter_value_t<_Iterator>>
+_LIBCPP_HIDE_FROM_ABI inline _Iterator __insert_sign(_Iterator __buf, bool __negative, __format_spec::__sign __sign) {
   if (__negative)
     *__buf++ = '-';
   else
@@ -85,9 +90,8 @@ _LIBCPP_HIDE_FROM_ABI inline char* __insert_sign(char* __buf, bool __negative, _
  * regardless whether the @c std::numpunct's type is @c char or @c wchar_t.
  */
 _LIBCPP_HIDE_FROM_ABI inline string __determine_grouping(ptrdiff_t __size, const string& __grouping) {
-  _LIBCPP_ASSERT(!__grouping.empty() && __size > __grouping[0],
-                 "The slow grouping formatting is used while there will be no "
-                 "separators written");
+  _LIBCPP_ASSERT_INTERNAL(!__grouping.empty() && __size > __grouping[0],
+                          "The slow grouping formatting is used while there will be no separators written");
   string __r;
   auto __end = __grouping.end() - 1;
   auto __ptr = __grouping.begin();
@@ -119,10 +123,10 @@ _LIBCPP_HIDE_FROM_ABI inline string __determine_grouping(ptrdiff_t __size, const
 //
 
 template <__fmt_char_type _CharT>
-_LIBCPP_HIDE_FROM_ABI auto __format_char(
-    integral auto __value,
-    output_iterator<const _CharT&> auto __out_it,
-    __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
+_LIBCPP_HIDE_FROM_ABI auto
+__format_char(integral auto __value,
+              output_iterator<const _CharT&> auto __out_it,
+              __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
   using _Tp = decltype(__value);
   if constexpr (!same_as<_CharT, _Tp>) {
     // cmp_less and cmp_greater can't be used for character types.
@@ -141,21 +145,23 @@ _LIBCPP_HIDE_FROM_ABI auto __format_char(
   }
 
   const auto __c = static_cast<_CharT>(__value);
-  return __formatter::__write(_VSTD::addressof(__c), _VSTD::addressof(__c) + 1, _VSTD::move(__out_it), __specs);
+  return __formatter::__write(std::addressof(__c), std::addressof(__c) + 1, std::move(__out_it), __specs);
 }
 
 //
 // Integer
 //
 
-/** Wrapper around @ref to_chars, returning the output pointer. */
-template <integral _Tp>
-_LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last, _Tp __value, int __base) {
+/** Wrapper around @ref to_chars, returning the output iterator. */
+template <contiguous_iterator _Iterator, integral _Tp>
+  requires same_as<char, iter_value_t<_Iterator>>
+_LIBCPP_HIDE_FROM_ABI _Iterator __to_buffer(_Iterator __first, _Iterator __last, _Tp __value, int __base) {
   // TODO FMT Evaluate code overhead due to not calling the internal function
   // directly. (Should be zero overhead.)
-  to_chars_result __r = _VSTD::to_chars(__first, __last, __value, __base);
-  _LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small");
-  return __r.ptr;
+  to_chars_result __r = std::to_chars(std::to_address(__first), std::to_address(__last), __value, __base);
+  _LIBCPP_ASSERT_INTERNAL(__r.ec == errc(0), "Internal buffer too small");
+  auto __diff = __r.ptr - std::to_address(__first);
+  return __first + __diff;
 }
 
 /**
@@ -203,22 +209,93 @@ consteval size_t __buffer_size() noexcept
        + 1;                          // Reserve space for the sign.
 }
 
-template <unsigned_integral _Tp, class _CharT, class _FormatContext>
+template <class _OutIt, contiguous_iterator _Iterator, class _CharT>
+  requires same_as<char, iter_value_t<_Iterator>>
+_LIBCPP_HIDE_FROM_ABI _OutIt __write_using_decimal_separators(
+    _OutIt __out_it,
+    _Iterator __begin,
+    _Iterator __first,
+    _Iterator __last,
+    string&& __grouping,
+    _CharT __sep,
+    __format_spec::__parsed_specifications<_CharT> __specs) {
+  int __size = (__first - __begin) +    // [sign][prefix]
+               (__last - __first) +     // data
+               (__grouping.size() - 1); // number of separator characters
+
+  __padding_size_result __padding = {0, 0};
+  if (__specs.__alignment_ == __format_spec::__alignment::__zero_padding) {
+    // Write [sign][prefix].
+    __out_it = __formatter::__copy(__begin, __first, std::move(__out_it));
+
+    if (__specs.__width_ > __size) {
+      // Write zero padding.
+      __padding.__before_ = __specs.__width_ - __size;
+      __out_it            = __formatter::__fill(std::move(__out_it), __specs.__width_ - __size, _CharT('0'));
+    }
+  } else {
+    if (__specs.__width_ > __size) {
+      // Determine padding and write padding.
+      __padding = __formatter::__padding_size(__size, __specs.__width_, __specs.__alignment_);
+
+      __out_it = __formatter::__fill(std::move(__out_it), __padding.__before_, __specs.__fill_);
+    }
+    // Write [sign][prefix].
+    __out_it = __formatter::__copy(__begin, __first, std::move(__out_it));
+  }
+
+  auto __r = __grouping.rbegin();
+  auto __e = __grouping.rend() - 1;
+  _LIBCPP_ASSERT_INTERNAL(
+      __r != __e, "The slow grouping formatting is used while there will be no separators written.");
+  // The output is divided in small groups of numbers to write:
+  // - A group before the first separator.
+  // - A separator and a group, repeated for the number of separators.
+  // - A group after the last separator.
+  // This loop achieves that process by testing the termination condition
+  // midway in the loop.
+  //
+  // TODO FMT This loop evaluates the loop invariant `__parser.__type !=
+  // _Flags::_Type::__hexadecimal_upper_case` for every iteration. (This test
+  // happens in the __write call.) Benchmark whether making two loops and
+  // hoisting the invariant is worth the effort.
+  while (true) {
+    if (__specs.__std_.__type_ == __format_spec::__type::__hexadecimal_upper_case) {
+      __last   = __first + *__r;
+      __out_it = __formatter::__transform(__first, __last, std::move(__out_it), __hex_to_upper);
+      __first  = __last;
+    } else {
+      __out_it = __formatter::__copy(__first, *__r, std::move(__out_it));
+      __first += *__r;
+    }
+
+    if (__r == __e)
+      break;
+
+    ++__r;
+    *__out_it++ = __sep;
+  }
+
+  return __formatter::__fill(std::move(__out_it), __padding.__after_, __specs.__fill_);
+}
+
+template <unsigned_integral _Tp, contiguous_iterator _Iterator, class _CharT, class _FormatContext>
+  requires same_as<char, iter_value_t<_Iterator>>
 _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator __format_integer(
     _Tp __value,
     _FormatContext& __ctx,
     __format_spec::__parsed_specifications<_CharT> __specs,
     bool __negative,
-    char* __begin,
-    char* __end,
+    _Iterator __begin,
+    _Iterator __end,
     const char* __prefix,
     int __base) {
-  char* __first = __formatter::__insert_sign(__begin, __negative, __specs.__std_.__sign_);
+  _Iterator __first = __formatter::__insert_sign(__begin, __negative, __specs.__std_.__sign_);
   if (__specs.__std_.__alternate_form_ && __prefix)
     while (*__prefix)
       *__first++ = *__prefix++;
 
-  char* __last = __formatter::__to_buffer(__first, __end, __value, __base);
+  _Iterator __last = __formatter::__to_buffer(__first, __end, __value, __base);
 
 #  ifndef _LIBCPP_HAS_NO_LOCALIZATION
   if (__specs.__std_.__locale_specific_form_) {
@@ -249,12 +326,12 @@ _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator __format_integer(
     // The zero padding is done like:
     // - Write [sign][prefix]
     // - Write data right aligned with '0' as fill character.
-    __out_it             = __formatter::__copy(__begin, __first, _VSTD::move(__out_it));
-    __specs.__alignment_ = __format_spec::__alignment::__right;
+    __out_it                  = __formatter::__copy(__begin, __first, std::move(__out_it));
+    __specs.__alignment_      = __format_spec::__alignment::__right;
     __specs.__fill_.__data[0] = _CharT('0');
-    int32_t __size       = __first - __begin;
+    int32_t __size            = __first - __begin;
 
-    __specs.__width_ -= _VSTD::min(__size, __specs.__width_);
+    __specs.__width_ -= std::min(__size, __specs.__width_);
   }
 
   if (__specs.__std_.__type_ != __format_spec::__type::__hexadecimal_upper_case) [[likely]]
@@ -299,7 +376,7 @@ __format_integer(_Tp __value,
     return __formatter::__format_integer(__value, __ctx, __specs, __negative, __array.begin(), __array.end(), "0X", 16);
   }
   default:
-    _LIBCPP_ASSERT(false, "The parse function should have validated the type");
+    _LIBCPP_ASSERT_INTERNAL(false, "The parse function should have validated the type");
     __libcpp_unreachable();
   }
 }
diff --git a/third_party/libcxx/__format/formatter_output.h b/third_party/libcxx/__format/formatter_output.h
index 6263dba09..1498f64c4 100644
--- a/third_party/libcxx/__format/formatter_output.h
+++ b/third_party/libcxx/__format/formatter_output.h
@@ -12,35 +12,32 @@
 
 #include <__algorithm/ranges_copy.h>
 #include <__algorithm/ranges_fill_n.h>
-#include <__algorithm/ranges_for_each.h>
 #include <__algorithm/ranges_transform.h>
 #include <__bit/countl.h>
-#include <__charconv/to_chars_integral.h>
-#include <__charconv/to_chars_result.h>
-#include <__chrono/statically_widen.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/buffer.h>
 #include <__format/concepts.h>
-#include <__format/escaped_output_table.h>
 #include <__format/formatter.h>
 #include <__format/parser_std_format_spec.h>
 #include <__format/unicode.h>
 #include <__iterator/back_insert_iterator.h>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h> // iter_value_t
-#include <__system_error/errc.h>
-#include <__type_traits/make_unsigned.h>
+#include <__iterator/iterator_traits.h>
+#include <__memory/addressof.h>
+#include <__memory/pointer_traits.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
 #include <cstddef>
-#include <string>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -65,15 +62,15 @@ _LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char __c) {
   return __c;
 }
 
-struct _LIBCPP_TYPE_VIS __padding_size_result {
+struct _LIBCPP_EXPORTED_FROM_ABI __padding_size_result {
   size_t __before_;
   size_t __after_;
 };
 
 _LIBCPP_HIDE_FROM_ABI constexpr __padding_size_result
 __padding_size(size_t __size, size_t __width, __format_spec::__alignment __align) {
-  _LIBCPP_ASSERT(__width > __size, "don't call this function when no padding is required");
-  _LIBCPP_ASSERT(
+  _LIBCPP_ASSERT_INTERNAL(__width > __size, "don't call this function when no padding is required");
+  _LIBCPP_ASSERT_INTERNAL(
       __align != __format_spec::__alignment::__zero_padding, "the caller should have handled the zero-padding");
 
   size_t __fill = __width - __size;
@@ -103,51 +100,55 @@ __padding_size(size_t __size, size_t __width, __format_spec::__alignment __align
 ///
 /// This uses a "mass output function" of __format::__output_buffer when possible.
 template <__fmt_char_type _CharT, __fmt_char_type _OutCharT = _CharT>
-_LIBCPP_HIDE_FROM_ABI auto __copy(basic_string_view<_CharT> __str, output_iterator<const _OutCharT&> auto __out_it)
-    -> decltype(__out_it) {
-  if constexpr (_VSTD::same_as<decltype(__out_it), _VSTD::back_insert_iterator<__format::__output_buffer<_OutCharT>>>) {
+_LIBCPP_HIDE_FROM_ABI auto
+__copy(basic_string_view<_CharT> __str, output_iterator<const _OutCharT&> auto __out_it) -> decltype(__out_it) {
+  if constexpr (std::same_as<decltype(__out_it), std::back_insert_iterator<__format::__output_buffer<_OutCharT>>>) {
     __out_it.__get_container()->__copy(__str);
     return __out_it;
-  } else if constexpr (_VSTD::same_as<decltype(__out_it),
-                                      typename __format::__retarget_buffer<_OutCharT>::__iterator>) {
+  } else if constexpr (std::same_as<decltype(__out_it), typename __format::__retarget_buffer<_OutCharT>::__iterator>) {
     __out_it.__buffer_->__copy(__str);
     return __out_it;
   } else {
-    return std::ranges::copy(__str, _VSTD::move(__out_it)).out;
+    return std::ranges::copy(__str, std::move(__out_it)).out;
   }
 }
 
-template <__fmt_char_type _CharT, __fmt_char_type _OutCharT = _CharT>
+template <contiguous_iterator _Iterator,
+          __fmt_char_type _CharT    = typename iterator_traits<_Iterator>::value_type,
+          __fmt_char_type _OutCharT = _CharT>
 _LIBCPP_HIDE_FROM_ABI auto
-__copy(const _CharT* __first, const _CharT* __last, output_iterator<const _OutCharT&> auto __out_it)
-    -> decltype(__out_it) {
-  return __formatter::__copy(basic_string_view{__first, __last}, _VSTD::move(__out_it));
+__copy(_Iterator __first, _Iterator __last, output_iterator<const _OutCharT&> auto __out_it) -> decltype(__out_it) {
+  return __formatter::__copy(basic_string_view{__first, __last}, std::move(__out_it));
 }
 
-template <__fmt_char_type _CharT, __fmt_char_type _OutCharT = _CharT>
-_LIBCPP_HIDE_FROM_ABI auto __copy(const _CharT* __first, size_t __n, output_iterator<const _OutCharT&> auto __out_it)
-    -> decltype(__out_it) {
-  return __formatter::__copy(basic_string_view{__first, __n}, _VSTD::move(__out_it));
+template <contiguous_iterator _Iterator,
+          __fmt_char_type _CharT    = typename iterator_traits<_Iterator>::value_type,
+          __fmt_char_type _OutCharT = _CharT>
+_LIBCPP_HIDE_FROM_ABI auto
+__copy(_Iterator __first, size_t __n, output_iterator<const _OutCharT&> auto __out_it) -> decltype(__out_it) {
+  return __formatter::__copy(basic_string_view{std::to_address(__first), __n}, std::move(__out_it));
 }
 
 /// Transform wrapper.
 ///
 /// This uses a "mass output function" of __format::__output_buffer when possible.
-template <__fmt_char_type _CharT, __fmt_char_type _OutCharT = _CharT, class _UnaryOperation>
+template <contiguous_iterator _Iterator,
+          __fmt_char_type _CharT    = typename iterator_traits<_Iterator>::value_type,
+          __fmt_char_type _OutCharT = _CharT,
+          class _UnaryOperation>
 _LIBCPP_HIDE_FROM_ABI auto
-__transform(const _CharT* __first,
-            const _CharT* __last,
+__transform(_Iterator __first,
+            _Iterator __last,
             output_iterator<const _OutCharT&> auto __out_it,
             _UnaryOperation __operation) -> decltype(__out_it) {
-  if constexpr (_VSTD::same_as<decltype(__out_it), _VSTD::back_insert_iterator<__format::__output_buffer<_OutCharT>>>) {
-    __out_it.__get_container()->__transform(__first, __last, _VSTD::move(__operation));
+  if constexpr (std::same_as<decltype(__out_it), std::back_insert_iterator<__format::__output_buffer<_OutCharT>>>) {
+    __out_it.__get_container()->__transform(__first, __last, std::move(__operation));
     return __out_it;
-  } else if constexpr (_VSTD::same_as<decltype(__out_it),
-                                      typename __format::__retarget_buffer<_OutCharT>::__iterator>) {
-    __out_it.__buffer_->__transform(__first, __last, _VSTD::move(__operation));
+  } else if constexpr (std::same_as<decltype(__out_it), typename __format::__retarget_buffer<_OutCharT>::__iterator>) {
+    __out_it.__buffer_->__transform(__first, __last, std::move(__operation));
     return __out_it;
   } else {
-    return std::ranges::transform(__first, __last, _VSTD::move(__out_it), __operation).out;
+    return std::ranges::transform(__first, __last, std::move(__out_it), __operation).out;
   }
 }
 
@@ -156,14 +157,14 @@ __transform(const _CharT* __first,
 /// This uses a "mass output function" of __format::__output_buffer when possible.
 template <__fmt_char_type _CharT, output_iterator<const _CharT&> _OutIt>
 _LIBCPP_HIDE_FROM_ABI _OutIt __fill(_OutIt __out_it, size_t __n, _CharT __value) {
-  if constexpr (_VSTD::same_as<decltype(__out_it), _VSTD::back_insert_iterator<__format::__output_buffer<_CharT>>>) {
+  if constexpr (std::same_as<decltype(__out_it), std::back_insert_iterator<__format::__output_buffer<_CharT>>>) {
     __out_it.__get_container()->__fill(__n, __value);
     return __out_it;
-  } else if constexpr (_VSTD::same_as<decltype(__out_it), typename __format::__retarget_buffer<_CharT>::__iterator>) {
+  } else if constexpr (std::same_as<decltype(__out_it), typename __format::__retarget_buffer<_CharT>::__iterator>) {
     __out_it.__buffer_->__fill(__n, __value);
     return __out_it;
   } else {
-    return std::ranges::fill_n(_VSTD::move(__out_it), __n, __value);
+    return std::ranges::fill_n(std::move(__out_it), __n, __value);
   }
 }
 
@@ -207,70 +208,6 @@ _LIBCPP_HIDE_FROM_ABI _OutIt __fill(_OutIt __out_it, size_t __n, __format_spec::
 }
 #  endif   // _LIBCPP_HAS_NO_UNICODE
 
-template <class _OutIt, class _CharT>
-_LIBCPP_HIDE_FROM_ABI _OutIt __write_using_decimal_separators(_OutIt __out_it, const char* __begin, const char* __first,
-                                                              const char* __last, string&& __grouping, _CharT __sep,
-                                                              __format_spec::__parsed_specifications<_CharT> __specs) {
-  int __size = (__first - __begin) +    // [sign][prefix]
-               (__last - __first) +     // data
-               (__grouping.size() - 1); // number of separator characters
-
-  __padding_size_result __padding = {0, 0};
-  if (__specs.__alignment_ == __format_spec::__alignment::__zero_padding) {
-    // Write [sign][prefix].
-    __out_it = __formatter::__copy(__begin, __first, _VSTD::move(__out_it));
-
-    if (__specs.__width_ > __size) {
-      // Write zero padding.
-      __padding.__before_ = __specs.__width_ - __size;
-      __out_it            = __formatter::__fill(_VSTD::move(__out_it), __specs.__width_ - __size, _CharT('0'));
-    }
-  } else {
-    if (__specs.__width_ > __size) {
-      // Determine padding and write padding.
-      __padding = __formatter::__padding_size(__size, __specs.__width_, __specs.__alignment_);
-
-      __out_it = __formatter::__fill(_VSTD::move(__out_it), __padding.__before_, __specs.__fill_);
-    }
-    // Write [sign][prefix].
-    __out_it = __formatter::__copy(__begin, __first, _VSTD::move(__out_it));
-  }
-
-  auto __r = __grouping.rbegin();
-  auto __e = __grouping.rend() - 1;
-  _LIBCPP_ASSERT(__r != __e, "The slow grouping formatting is used while "
-                             "there will be no separators written.");
-  // The output is divided in small groups of numbers to write:
-  // - A group before the first separator.
-  // - A separator and a group, repeated for the number of separators.
-  // - A group after the last separator.
-  // This loop achieves that process by testing the termination condition
-  // midway in the loop.
-  //
-  // TODO FMT This loop evaluates the loop invariant `__parser.__type !=
-  // _Flags::_Type::__hexadecimal_upper_case` for every iteration. (This test
-  // happens in the __write call.) Benchmark whether making two loops and
-  // hoisting the invariant is worth the effort.
-  while (true) {
-    if (__specs.__std_.__type_ == __format_spec::__type::__hexadecimal_upper_case) {
-      __last = __first + *__r;
-      __out_it = __formatter::__transform(__first, __last, _VSTD::move(__out_it), __hex_to_upper);
-      __first = __last;
-    } else {
-      __out_it = __formatter::__copy(__first, *__r, _VSTD::move(__out_it));
-      __first += *__r;
-    }
-
-    if (__r == __e)
-      break;
-
-    ++__r;
-    *__out_it++ = __sep;
-  }
-
-  return __formatter::__fill(_VSTD::move(__out_it), __padding.__after_, __specs.__fill_);
-}
-
 /// Writes the input to the output with the required padding.
 ///
 /// Since the output column width is specified the function can be used for
@@ -299,12 +236,12 @@ __write(basic_string_view<_CharT> __str,
         __format_spec::__parsed_specifications<_ParserCharT> __specs,
         ptrdiff_t __size) -> decltype(__out_it) {
   if (__size >= __specs.__width_)
-    return __formatter::__copy(__str, _VSTD::move(__out_it));
+    return __formatter::__copy(__str, std::move(__out_it));
 
   __padding_size_result __padding = __formatter::__padding_size(__size, __specs.__width_, __specs.__std_.__alignment_);
-  __out_it                        = __formatter::__fill(_VSTD::move(__out_it), __padding.__before_, __specs.__fill_);
-  __out_it                        = __formatter::__copy(__str, _VSTD::move(__out_it));
-  return __formatter::__fill(_VSTD::move(__out_it), __padding.__after_, __specs.__fill_);
+  __out_it                        = __formatter::__fill(std::move(__out_it), __padding.__before_, __specs.__fill_);
+  __out_it                        = __formatter::__copy(__str, std::move(__out_it));
+  return __formatter::__fill(std::move(__out_it), __padding.__after_, __specs.__fill_);
 }
 
 template <contiguous_iterator _Iterator, class _ParserCharT>
@@ -314,8 +251,8 @@ __write(_Iterator __first,
         output_iterator<const iter_value_t<_Iterator>&> auto __out_it,
         __format_spec::__parsed_specifications<_ParserCharT> __specs,
         ptrdiff_t __size) -> decltype(__out_it) {
-  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
-  return __formatter::__write(basic_string_view{__first, __last}, _VSTD::move(__out_it), __specs, __size);
+  _LIBCPP_ASSERT_VALID_INPUT_RANGE(__first <= __last, "Not a valid range");
+  return __formatter::__write(basic_string_view{__first, __last}, std::move(__out_it), __specs, __size);
 }
 
 /// \overload
@@ -327,54 +264,30 @@ __write(_Iterator __first,
         _Iterator __last,
         output_iterator<const iter_value_t<_Iterator>&> auto __out_it,
         __format_spec::__parsed_specifications<_ParserCharT> __specs) -> decltype(__out_it) {
-  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
-  return __formatter::__write(__first, __last, _VSTD::move(__out_it), __specs, __last - __first);
+  _LIBCPP_ASSERT_VALID_INPUT_RANGE(__first <= __last, "Not a valid range");
+  return __formatter::__write(__first, __last, std::move(__out_it), __specs, __last - __first);
 }
 
-template <class _CharT, class _ParserCharT, class _UnaryOperation>
-_LIBCPP_HIDE_FROM_ABI auto __write_transformed(const _CharT* __first, const _CharT* __last,
-                                               output_iterator<const _CharT&> auto __out_it,
-                                               __format_spec::__parsed_specifications<_ParserCharT> __specs,
-                                               _UnaryOperation __op) -> decltype(__out_it) {
-  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
+template <contiguous_iterator _Iterator,
+          class _CharT = typename iterator_traits<_Iterator>::value_type,
+          class _ParserCharT,
+          class _UnaryOperation>
+_LIBCPP_HIDE_FROM_ABI auto __write_transformed(
+    _Iterator __first,
+    _Iterator __last,
+    output_iterator<const _CharT&> auto __out_it,
+    __format_spec::__parsed_specifications<_ParserCharT> __specs,
+    _UnaryOperation __op) -> decltype(__out_it) {
+  _LIBCPP_ASSERT_VALID_INPUT_RANGE(__first <= __last, "Not a valid range");
 
   ptrdiff_t __size = __last - __first;
   if (__size >= __specs.__width_)
-    return __formatter::__transform(__first, __last, _VSTD::move(__out_it), __op);
+    return __formatter::__transform(__first, __last, std::move(__out_it), __op);
 
   __padding_size_result __padding = __formatter::__padding_size(__size, __specs.__width_, __specs.__alignment_);
-  __out_it                        = __formatter::__fill(_VSTD::move(__out_it), __padding.__before_, __specs.__fill_);
-  __out_it                        = __formatter::__transform(__first, __last, _VSTD::move(__out_it), __op);
-  return __formatter::__fill(_VSTD::move(__out_it), __padding.__after_, __specs.__fill_);
-}
-
-/// Writes additional zero's for the precision before the exponent.
-/// This is used when the precision requested in the format string is larger
-/// than the maximum precision of the floating-point type. These precision
-/// digits are always 0.
-///
-/// \param __exponent           The location of the exponent character.
-/// \param __num_trailing_zeros The number of 0's to write before the exponent
-///                             character.
-template <class _CharT, class _ParserCharT>
-_LIBCPP_HIDE_FROM_ABI auto __write_using_trailing_zeros(
-    const _CharT* __first,
-    const _CharT* __last,
-    output_iterator<const _CharT&> auto __out_it,
-    __format_spec::__parsed_specifications<_ParserCharT> __specs,
-    size_t __size,
-    const _CharT* __exponent,
-    size_t __num_trailing_zeros) -> decltype(__out_it) {
-  _LIBCPP_ASSERT(__first <= __last, "Not a valid range");
-  _LIBCPP_ASSERT(__num_trailing_zeros > 0, "The overload not writing trailing zeros should have been used");
-
-  __padding_size_result __padding =
-      __formatter::__padding_size(__size + __num_trailing_zeros, __specs.__width_, __specs.__alignment_);
-  __out_it = __formatter::__fill(_VSTD::move(__out_it), __padding.__before_, __specs.__fill_);
-  __out_it = __formatter::__copy(__first, __exponent, _VSTD::move(__out_it));
-  __out_it = __formatter::__fill(_VSTD::move(__out_it), __num_trailing_zeros, _CharT('0'));
-  __out_it = __formatter::__copy(__exponent, __last, _VSTD::move(__out_it));
-  return __formatter::__fill(_VSTD::move(__out_it), __padding.__after_, __specs.__fill_);
+  __out_it                        = __formatter::__fill(std::move(__out_it), __padding.__before_, __specs.__fill_);
+  __out_it                        = __formatter::__transform(__first, __last, std::move(__out_it), __op);
+  return __formatter::__fill(std::move(__out_it), __padding.__after_, __specs.__fill_);
 }
 
 /// Writes a string using format's width estimation algorithm.
@@ -388,11 +301,11 @@ _LIBCPP_HIDE_FROM_ABI auto __write_string_no_precision(
     basic_string_view<_CharT> __str,
     output_iterator<const _CharT&> auto __out_it,
     __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
-  _LIBCPP_ASSERT(!__specs.__has_precision(), "use __write_string");
+  _LIBCPP_ASSERT_INTERNAL(!__specs.__has_precision(), "use __write_string");
 
   // No padding -> copy the string
   if (!__specs.__has_width())
-    return __formatter::__copy(__str, _VSTD::move(__out_it));
+    return __formatter::__copy(__str, std::move(__out_it));
 
   // Note when the estimated width is larger than size there's no padding. So
   // there's no reason to get the real size when the estimate is larger than or
@@ -400,7 +313,7 @@ _LIBCPP_HIDE_FROM_ABI auto __write_string_no_precision(
   size_t __size =
       __format_spec::__estimate_column_width(__str, __specs.__width_, __format_spec::__column_width_rounding::__up)
           .__width_;
-  return __formatter::__write(__str, _VSTD::move(__out_it), __specs, __size);
+  return __formatter::__write(__str, std::move(__out_it), __specs, __size);
 }
 
 template <class _CharT>
@@ -411,187 +324,12 @@ _LIBCPP_HIDE_FROM_ABI int __truncate(basic_string_view<_CharT>& __str, int __pre
   return __result.__width_;
 }
 
-/// Writes a string using format's width estimation algorithm.
-///
-/// \note When \c _LIBCPP_HAS_NO_UNICODE is defined the function assumes the
-/// input is ASCII.
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI auto __write_string(
-    basic_string_view<_CharT> __str,
-    output_iterator<const _CharT&> auto __out_it,
-    __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
-  if (!__specs.__has_precision())
-    return __formatter::__write_string_no_precision(__str, _VSTD::move(__out_it), __specs);
-
-  int __size = __formatter::__truncate(__str, __specs.__precision_);
-
-  return __formatter::__write(__str.begin(), __str.end(), _VSTD::move(__out_it), __specs, __size);
-}
-
-#  if _LIBCPP_STD_VER >= 23
-
-struct __nul_terminator {};
-
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI bool operator==(const _CharT* __cstr, __nul_terminator) {
-  return *__cstr == _CharT('\0');
-}
-
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI void
-__write_escaped_code_unit(basic_string<_CharT>& __str, char32_t __value, const _CharT* __prefix) {
-  back_insert_iterator __out_it{__str};
-  std::ranges::copy(__prefix, __nul_terminator{}, __out_it);
-
-  char __buffer[8];
-  to_chars_result __r = std::to_chars(std::begin(__buffer), std::end(__buffer), __value, 16);
-  _LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small");
-  std::ranges::copy(std::begin(__buffer), __r.ptr, __out_it);
-
-  __str += _CharT('}');
-}
-
-// [format.string.escaped]/2.2.1.2
-// ...
-// then the sequence \u{hex-digit-sequence} is appended to E, where
-// hex-digit-sequence is the shortest hexadecimal representation of C using
-// lower-case hexadecimal digits.
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI void __write_well_formed_escaped_code_unit(basic_string<_CharT>& __str, char32_t __value) {
-  __formatter::__write_escaped_code_unit(__str, __value, _LIBCPP_STATICALLY_WIDEN(_CharT, "\\u{"));
-}
-
-// [format.string.escaped]/2.2.3
-// Otherwise (X is a sequence of ill-formed code units), each code unit U is
-// appended to E in order as the sequence \x{hex-digit-sequence}, where
-// hex-digit-sequence is the shortest hexadecimal representation of U using
-// lower-case hexadecimal digits.
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI void __write_escape_ill_formed_code_unit(basic_string<_CharT>& __str, char32_t __value) {
-  __formatter::__write_escaped_code_unit(__str, __value, _LIBCPP_STATICALLY_WIDEN(_CharT, "\\x{"));
-}
-
-template <class _CharT>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool __is_escaped_sequence_written(basic_string<_CharT>& __str, char32_t __value) {
-#    ifdef _LIBCPP_HAS_NO_UNICODE
-  // For ASCII assume everything above 127 is printable.
-  if (__value > 127)
-    return false;
-#    endif
-
-  if (!__escaped_output_table::__needs_escape(__value))
-    return false;
-
-  __formatter::__write_well_formed_escaped_code_unit(__str, __value);
-  return true;
-}
-
-template <class _CharT>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr char32_t __to_char32(_CharT __value) {
-  return static_cast<make_unsigned_t<_CharT>>(__value);
-}
-
-enum class _LIBCPP_ENUM_VIS __escape_quotation_mark { __apostrophe, __double_quote };
-
-// [format.string.escaped]/2
-template <class _CharT>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
-__is_escaped_sequence_written(basic_string<_CharT>& __str, char32_t __value, __escape_quotation_mark __mark) {
-  // 2.2.1.1 - Mapped character in [tab:format.escape.sequences]
-  switch (__value) {
-  case _CharT('\t'):
-    __str += _LIBCPP_STATICALLY_WIDEN(_CharT, "\\t");
-    return true;
-  case _CharT('\n'):
-    __str += _LIBCPP_STATICALLY_WIDEN(_CharT, "\\n");
-    return true;
-  case _CharT('\r'):
-    __str += _LIBCPP_STATICALLY_WIDEN(_CharT, "\\r");
-    return true;
-  case _CharT('\''):
-    if (__mark == __escape_quotation_mark::__apostrophe)
-      __str += _LIBCPP_STATICALLY_WIDEN(_CharT, R"(\')");
-    else
-      __str += __value;
-    return true;
-  case _CharT('"'):
-    if (__mark == __escape_quotation_mark::__double_quote)
-      __str += _LIBCPP_STATICALLY_WIDEN(_CharT, R"(\")");
-    else
-      __str += __value;
-    return true;
-  case _CharT('\\'):
-    __str += _LIBCPP_STATICALLY_WIDEN(_CharT, R"(\\)");
-    return true;
-
-  // 2.2.1.2 - Space
-  case _CharT(' '):
-    __str += __value;
-    return true;
-  }
-
-  // 2.2.2
-  //   Otherwise, if X is a shift sequence, the effect on E and further
-  //   decoding of S is unspecified.
-  // For now shift sequences are ignored and treated as Unicode. Other parts
-  // of the format library do the same. It's unknown how ostream treats them.
-  // TODO FMT determine what to do with shift sequences.
-
-  // 2.2.1.2.1 and 2.2.1.2.2 - Escape
-  return __formatter::__is_escaped_sequence_written(__str, __formatter::__to_char32(__value));
-}
-
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI void
-__escape(basic_string<_CharT>& __str, basic_string_view<_CharT> __values, __escape_quotation_mark __mark) {
-  __unicode::__code_point_view<_CharT> __view{__values.begin(), __values.end()};
-
-  while (!__view.__at_end()) {
-    auto __first                                  = __view.__position();
-    typename __unicode::__consume_result __result = __view.__consume();
-    if (__result.__status == __unicode::__consume_result::__ok) {
-      if (!__formatter::__is_escaped_sequence_written(__str, __result.__code_point, __mark))
-        // 2.2.1.3 - Add the character
-        ranges::copy(__first, __view.__position(), std::back_insert_iterator(__str));
-    } else {
-      // 2.2.3 sequence of ill-formed code units
-      ranges::for_each(__first, __view.__position(), [&](_CharT __value) {
-        __formatter::__write_escape_ill_formed_code_unit(__str, __formatter::__to_char32(__value));
-      });
-    }
-  }
-}
-
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI auto
-__format_escaped_char(_CharT __value,
-                      output_iterator<const _CharT&> auto __out_it,
-                      __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
-  basic_string<_CharT> __str;
-  __str += _CharT('\'');
-  __formatter::__escape(__str, basic_string_view{std::addressof(__value), 1}, __escape_quotation_mark::__apostrophe);
-  __str += _CharT('\'');
-  return __formatter::__write(__str.data(), __str.data() + __str.size(), _VSTD::move(__out_it), __specs, __str.size());
-}
-
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI auto
-__format_escaped_string(basic_string_view<_CharT> __values,
-                        output_iterator<const _CharT&> auto __out_it,
-                        __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
-  basic_string<_CharT> __str;
-  __str += _CharT('"');
-  __formatter::__escape(__str, __values, __escape_quotation_mark::__double_quote);
-  __str += _CharT('"');
-  return __formatter::__write_string(basic_string_view{__str}, _VSTD::move(__out_it), __specs);
-}
-
-#  endif // _LIBCPP_STD_VER >= 23
-
 } // namespace __formatter
 
 #endif //_LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___FORMAT_FORMATTER_OUTPUT_H
diff --git a/third_party/libcxx/__format/formatter_pointer.h b/third_party/libcxx/__format/formatter_pointer.h
index ab699ba65..6941343ef 100644
--- a/third_party/libcxx/__format/formatter_pointer.h
+++ b/third_party/libcxx/__format/formatter_pointer.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___FORMAT_FORMATTER_POINTER_H
 #define _LIBCPP___FORMAT_FORMATTER_POINTER_H
 
-#include <__availability>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_parse_context.h>
@@ -35,7 +34,7 @@ public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
     typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_pointer);
-    __format_spec::__process_display_type_pointer(__parser_.__type_);
+    __format_spec::__process_display_type_pointer(__parser_.__type_, "a pointer");
     return __result;
   }
 
@@ -43,11 +42,15 @@ public:
   _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const void* __ptr, _FormatContext& __ctx) const {
     __format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
     __specs.__std_.__alternate_form_                       = true;
-    __specs.__std_.__type_                                 = __format_spec::__type::__hexadecimal_lower_case;
+    __specs.__std_.__type_ =
+        __specs.__std_.__type_ == __format_spec::__type::__pointer_upper_case
+            ? __format_spec::__type::__hexadecimal_upper_case
+            : __format_spec::__type::__hexadecimal_lower_case;
+
     return __formatter::__format_integer(reinterpret_cast<uintptr_t>(__ptr), __ctx, __specs);
   }
 
-  __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__right};
+  __format_spec::__parser<_CharT> __parser_;
 };
 
 // [format.formatter.spec]/2.4
@@ -56,14 +59,11 @@ public:
 // - template<> struct formatter<void*, charT>;
 // - template<> struct formatter<const void*, charT>;
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<nullptr_t, _CharT>
-    : public __formatter_pointer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<nullptr_t, _CharT> : public __formatter_pointer<_CharT> {};
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<void*, _CharT> : public __formatter_pointer<_CharT> {
-};
+struct _LIBCPP_TEMPLATE_VIS formatter<void*, _CharT> : public __formatter_pointer<_CharT> {};
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<const void*, _CharT>
-    : public __formatter_pointer<_CharT> {};
+struct _LIBCPP_TEMPLATE_VIS formatter<const void*, _CharT> : public __formatter_pointer<_CharT> {};
 
 #endif //_LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__format/formatter_string.h b/third_party/libcxx/__format/formatter_string.h
index 25a9e8ee4..347439fc8 100644
--- a/third_party/libcxx/__format/formatter_string.h
+++ b/third_party/libcxx/__format/formatter_string.h
@@ -10,14 +10,13 @@
 #ifndef _LIBCPP___FORMAT_FORMATTER_STRING_H
 #define _LIBCPP___FORMAT_FORMATTER_STRING_H
 
-#include <__availability>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
-#include <__utility/move.h>
+#include <__format/write_escaped.h>
 #include <string>
 #include <string_view>
 
@@ -59,14 +58,12 @@ public:
 
 // Formatter const char*.
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<const _CharT*, _CharT>
-    : public __formatter_string<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<const _CharT*, _CharT> : public __formatter_string<_CharT> {
   using _Base = __formatter_string<_CharT>;
 
   template <class _FormatContext>
   _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const _CharT* __str, _FormatContext& __ctx) const {
-    _LIBCPP_ASSERT(__str, "The basic_format_arg constructor should have "
-                          "prevented an invalid pointer.");
+    _LIBCPP_ASSERT_INTERNAL(__str, "The basic_format_arg constructor should have prevented an invalid pointer.");
 
     __format_spec::__parsed_specifications<_CharT> __specs = _Base::__parser_.__get_parsed_std_specifications(__ctx);
 #  if _LIBCPP_STD_VER >= 23
@@ -98,8 +95,7 @@ struct _LIBCPP_TEMPLATE_VIS formatter<const _CharT*, _CharT>
 
 // Formatter char*.
 template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<_CharT*, _CharT>
-    : public formatter<const _CharT*, _CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<_CharT*, _CharT> : public formatter<const _CharT*, _CharT> {
   using _Base = formatter<const _CharT*, _CharT>;
 
   template <class _FormatContext>
@@ -110,12 +106,12 @@ struct _LIBCPP_TEMPLATE_VIS formatter<_CharT*, _CharT>
 
 // Formatter char[].
 template <__fmt_char_type _CharT, size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS formatter<_CharT[_Size], _CharT>
-    : public __formatter_string<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<_CharT[_Size], _CharT> : public __formatter_string<_CharT> {
   using _Base = __formatter_string<_CharT>;
 
   template <class _FormatContext>
-  _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(_CharT __str[_Size], _FormatContext& __ctx) const {
+  _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
+  format(const _CharT (&__str)[_Size], _FormatContext& __ctx) const {
     return _Base::format(basic_string_view<_CharT>(__str, _Size), __ctx);
   }
 };
@@ -136,8 +132,7 @@ struct _LIBCPP_TEMPLATE_VIS formatter<basic_string<_CharT, _Traits, _Allocator>,
 
 // Formatter std::string_view.
 template <__fmt_char_type _CharT, class _Traits>
-struct _LIBCPP_TEMPLATE_VIS formatter<basic_string_view<_CharT, _Traits>, _CharT>
-    : public __formatter_string<_CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<basic_string_view<_CharT, _Traits>, _CharT> : public __formatter_string<_CharT> {
   using _Base = __formatter_string<_CharT>;
 
   template <class _FormatContext>
diff --git a/third_party/libcxx/__format/formatter_tuple.h b/third_party/libcxx/__format/formatter_tuple.h
index 92380f858..030097a87 100644
--- a/third_party/libcxx/__format/formatter_tuple.h
+++ b/third_party/libcxx/__format/formatter_tuple.h
@@ -11,19 +11,16 @@
 #define _LIBCPP___FORMAT_FORMATTER_TUPLE_H
 
 #include <__algorithm/ranges_copy.h>
-#include <__availability>
 #include <__chrono/statically_widen.h>
 #include <__config>
 #include <__format/buffer.h>
 #include <__format/concepts.h>
-#include <__format/format_args.h>
 #include <__format/format_context.h>
 #include <__format/format_error.h>
 #include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_output.h>
 #include <__format/parser_std_format_spec.h>
-#include <__iterator/back_insert_iterator.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/pair.h>
@@ -54,22 +51,20 @@ struct _LIBCPP_TEMPLATE_VIS __formatter_tuple {
     auto __begin = __parser_.__parse(__ctx, __format_spec::__fields_tuple);
 
     auto __end = __ctx.end();
-    if (__begin != __end) {
-      if (*__begin == _CharT('m')) {
-        if constexpr (sizeof...(_Args) == 2) {
-          set_separator(_LIBCPP_STATICALLY_WIDEN(_CharT, ": "));
-          set_brackets({}, {});
-          ++__begin;
-        } else
-          std::__throw_format_error("The format specifier m requires a pair or a two-element tuple");
-      } else if (*__begin == _CharT('n')) {
+    // Note 'n' is part of the type here
+    if (__parser_.__clear_brackets_)
+      set_brackets({}, {});
+    else if (__begin != __end && *__begin == _CharT('m')) {
+      if constexpr (sizeof...(_Args) == 2) {
+        set_separator(_LIBCPP_STATICALLY_WIDEN(_CharT, ": "));
         set_brackets({}, {});
         ++__begin;
-      }
+      } else
+        std::__throw_format_error("Type m requires a pair or a tuple with two elements");
     }
 
     if (__begin != __end && *__begin != _CharT('}'))
-      std::__throw_format_error("The format-spec should consume the input or end with a '}'");
+      std::__throw_format_error("The format specifier should consume the input or end with a '}'");
 
     __ctx.advance_to(__begin);
 
diff --git a/third_party/libcxx/__format/indic_conjunct_break_table.h b/third_party/libcxx/__format/indic_conjunct_break_table.h
new file mode 100644
index 000000000..44521d274
--- /dev/null
+++ b/third_party/libcxx/__format/indic_conjunct_break_table.h
@@ -0,0 +1,350 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// WARNING, this entire header is generated by
+// utils/generate_indic_conjunct_break_table.py
+// DO NOT MODIFY!
+
+// UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE
+//
+// See Terms of Use <https://www.unicode.org/copyright.html>
+// for definitions of Unicode Inc.'s Data Files and Software.
+//
+// NOTICE TO USER: Carefully read the following legal agreement.
+// BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
+// DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
+// YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+// TERMS AND CONDITIONS OF THIS AGREEMENT.
+// IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
+// THE DATA FILES OR SOFTWARE.
+//
+// COPYRIGHT AND PERMISSION NOTICE
+//
+// Copyright (c) 1991-2022 Unicode, Inc. All rights reserved.
+// Distributed under the Terms of Use in https://www.unicode.org/copyright.html.
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of the Unicode data files and any associated documentation
+// (the "Data Files") or Unicode software and any associated documentation
+// (the "Software") to deal in the Data Files or Software
+// without restriction, including without limitation the rights to use,
+// copy, modify, merge, publish, distribute, and/or sell copies of
+// the Data Files or Software, and to permit persons to whom the Data Files
+// or Software are furnished to do so, provided that either
+// (a) this copyright and permission notice appear with all copies
+// of the Data Files or Software, or
+// (b) this copyright and permission notice appear in associated
+// Documentation.
+//
+// THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
+// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT OF THIRD PARTY RIGHTS.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+// NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+// DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+// DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+//
+// Except as contained in this notice, the name of a copyright holder
+// shall not be used in advertising or otherwise to promote the sale,
+// use or other dealings in these Data Files or Software without prior
+// written authorization of the copyright holder.
+
+#ifndef _LIBCPP___FORMAT_INDIC_CONJUNCT_BREAK_TABLE_H
+#define _LIBCPP___FORMAT_INDIC_CONJUNCT_BREAK_TABLE_H
+
+#include <__algorithm/ranges_upper_bound.h>
+#include <__config>
+#include <__iterator/access.h>
+#include <cstddef>
+#include <cstdint>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+namespace __indic_conjunct_break {
+
+enum class __property : uint8_t {
+  // Values generated from the data files.
+  __Consonant,
+  __Extend,
+  __Linker,
+
+  // The code unit has none of above properties.
+  __none
+};
+
+/// The entries of the indic conjunct break property table.
+///
+/// The data is generated from
+/// -  https://www.unicode.org/Public/UCD/latest/ucd/DerivedCoreProperties.txt
+///
+/// The data has 3 values
+/// - bits [0, 1] The property. One of the values generated from the datafiles
+///   of \ref __property
+/// - bits [2, 10] The size of the range.
+/// - bits [11, 31] The lower bound code point of the range. The upper bound of
+///   the range is lower bound + size.
+///
+/// The 9 bits for the size allow a maximum range of 512 elements. Some ranges
+/// in the Unicode tables are larger. They are stored in multiple consecutive
+/// ranges in the data table. An alternative would be to store the sizes in a
+/// separate 16-bit value. The original MSVC STL code had such an approach, but
+/// this approach uses less space for the data and is about 4% faster in the
+/// following benchmark.
+/// libcxx/benchmarks/std_format_spec_string_unicode.bench.cpp
+// clang-format off
+_LIBCPP_HIDE_FROM_ABI inline constexpr uint32_t __entries[201] = {
+    0x00180139,
+    0x001a807d,
+    0x00241811,
+    0x002c88b1,
+    0x002df801,
+    0x002e0805,
+    0x002e2005,
+    0x002e3801,
+    0x00308029,
+    0x00325851,
+    0x00338001,
+    0x0036b019,
+    0x0036f815,
+    0x00373805,
+    0x0037500d,
+    0x00388801,
+    0x00398069,
+    0x003f5821,
+    0x003fe801,
+    0x0040b00d,
+    0x0040d821,
+    0x00412809,
+    0x00414811,
+    0x0042c809,
+    0x0044c01d,
+    0x0046505d,
+    0x00471871,
+    0x0048a890,
+    0x0049e001,
+    0x004a6802,
+    0x004a880d,
+    0x004ac01c,
+    0x004bc01c,
+    0x004ca84c,
+    0x004d5018,
+    0x004d9000,
+    0x004db00c,
+    0x004de001,
+    0x004e6802,
+    0x004ee004,
+    0x004ef800,
+    0x004f8004,
+    0x004ff001,
+    0x0051e001,
+    0x0054a84c,
+    0x00555018,
+    0x00559004,
+    0x0055a810,
+    0x0055e001,
+    0x00566802,
+    0x0057c800,
+    0x0058a84c,
+    0x00595018,
+    0x00599004,
+    0x0059a810,
+    0x0059e001,
+    0x005a6802,
+    0x005ae004,
+    0x005af800,
+    0x005b8800,
+    0x0060a84c,
+    0x0061503c,
+    0x0061e001,
+    0x00626802,
+    0x0062a805,
+    0x0062c008,
+    0x0065e001,
+    0x0068a894,
+    0x0069d805,
+    0x006a6802,
+    0x0071c009,
+    0x0072400d,
+    0x0075c009,
+    0x0076400d,
+    0x0078c005,
+    0x0079a801,
+    0x0079b801,
+    0x0079c801,
+    0x007b8805,
+    0x007ba001,
+    0x007bd00d,
+    0x007c0001,
+    0x007c1009,
+    0x007c3005,
+    0x007e3001,
+    0x0081b801,
+    0x0081c805,
+    0x00846801,
+    0x009ae809,
+    0x00b8a001,
+    0x00be9001,
+    0x00bee801,
+    0x00c54801,
+    0x00c9c809,
+    0x00d0b805,
+    0x00d30001,
+    0x00d3a81d,
+    0x00d3f801,
+    0x00d58035,
+    0x00d5f83d,
+    0x00d9a001,
+    0x00db5821,
+    0x00dd5801,
+    0x00df3001,
+    0x00e1b801,
+    0x00e68009,
+    0x00e6a031,
+    0x00e71019,
+    0x00e76801,
+    0x00e7a001,
+    0x00e7c005,
+    0x00ee00fd,
+    0x01006801,
+    0x01068031,
+    0x01070801,
+    0x0107282d,
+    0x01677809,
+    0x016bf801,
+    0x016f007d,
+    0x01815015,
+    0x0184c805,
+    0x05337801,
+    0x0533a025,
+    0x0534f005,
+    0x05378005,
+    0x05416001,
+    0x05470045,
+    0x05495809,
+    0x054d9801,
+    0x05558001,
+    0x05559009,
+    0x0555b805,
+    0x0555f005,
+    0x05560801,
+    0x0557b001,
+    0x055f6801,
+    0x07d8f001,
+    0x07f1003d,
+    0x080fe801,
+    0x08170001,
+    0x081bb011,
+    0x08506801,
+    0x08507801,
+    0x0851c009,
+    0x0851f801,
+    0x08572805,
+    0x0869200d,
+    0x08755805,
+    0x0877e809,
+    0x087a3029,
+    0x087c100d,
+    0x08838001,
+    0x0883f801,
+    0x0885d001,
+    0x08880009,
+    0x08899805,
+    0x088b9801,
+    0x088e5001,
+    0x0891b001,
+    0x08974805,
+    0x0899d805,
+    0x089b3019,
+    0x089b8011,
+    0x08a23001,
+    0x08a2f001,
+    0x08a61801,
+    0x08ae0001,
+    0x08b5b801,
+    0x08b95801,
+    0x08c1d001,
+    0x08c9f001,
+    0x08ca1801,
+    0x08d1a001,
+    0x08d23801,
+    0x08d4c801,
+    0x08ea1001,
+    0x08ea2005,
+    0x08ecb801,
+    0x08fa1001,
+    0x0b578011,
+    0x0b598019,
+    0x0de4f001,
+    0x0e8b2801,
+    0x0e8b3809,
+    0x0e8b7011,
+    0x0e8bd81d,
+    0x0e8c2819,
+    0x0e8d500d,
+    0x0e921009,
+    0x0f000019,
+    0x0f004041,
+    0x0f00d819,
+    0x0f011805,
+    0x0f013011,
+    0x0f047801,
+    0x0f098019,
+    0x0f157001,
+    0x0f17600d,
+    0x0f27600d,
+    0x0f468019,
+    0x0f4a2019};
+// clang-format on
+
+/// Returns the indic conjuct break property of a code point.
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __property __get_property(const char32_t __code_point) noexcept {
+  // The algorithm searches for the upper bound of the range and, when found,
+  // steps back one entry. This algorithm is used since the code point can be
+  // anywhere in the range. After a lower bound is found the next step is to
+  // compare whether the code unit is indeed in the range.
+  //
+  // Since the entry contains a code unit, size, and property the code point
+  // being sought needs to be adjusted. Just shifting the code point to the
+  // proper position doesn't work; suppose an entry has property 0, size 1,
+  // and lower bound 3. This results in the entry 0x1810.
+  // When searching for code point 3 it will search for 0x1800, find 0x1810
+  // and moves to the previous entry. Thus the lower bound value will never
+  // be found.
+  // The simple solution is to set the bits belonging to the property and
+  // size. Then the upper bound for code point 3 will return the entry after
+  // 0x1810. After moving to the previous entry the algorithm arrives at the
+  // correct entry.
+  ptrdiff_t __i = std::ranges::upper_bound(__entries, (__code_point << 11) | 0x7ffu) - __entries;
+  if (__i == 0)
+    return __property::__none;
+
+  --__i;
+  uint32_t __upper_bound = (__entries[__i] >> 11) + ((__entries[__i] >> 2) & 0b1'1111'1111);
+  if (__code_point <= __upper_bound)
+    return static_cast<__property>(__entries[__i] & 0b11);
+
+  return __property::__none;
+}
+
+} // namespace __indic_conjunct_break
+
+#endif //_LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FORMAT_INDIC_CONJUNCT_BREAK_TABLE_H
diff --git a/third_party/libcxx/__format/parser_std_format_spec.h b/third_party/libcxx/__format/parser_std_format_spec.h
index f3f7bce81..150bdde89 100644
--- a/third_party/libcxx/__format/parser_std_format_spec.h
+++ b/third_party/libcxx/__format/parser_std_format_spec.h
@@ -17,13 +17,11 @@
 /// affect the std-format-spec.
 
 #include <__algorithm/copy_n.h>
-#include <__algorithm/find_if.h>
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__concepts/arithmetic.h>
 #include <__concepts/same_as.h>
 #include <__config>
-#include <__debug>
 #include <__format/format_arg.h>
 #include <__format/format_error.h>
 #include <__format/format_parse_context.h>
@@ -31,12 +29,14 @@
 #include <__format/unicode.h>
 #include <__format/width_estimation_table.h>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h> // iter_value_t
+#include <__iterator/iterator_traits.h> // iter_value_t
 #include <__memory/addressof.h>
 #include <__type_traits/common_type.h>
+#include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_trivially_copyable.h>
 #include <__variant/monostate.h>
 #include <cstdint>
+#include <string>
 #include <string_view>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -52,6 +52,17 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace __format_spec {
 
+_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void
+__throw_invalid_option_format_error(const char* __id, const char* __option) {
+  std::__throw_format_error(
+      (string("The format specifier for ") + __id + " does not allow the " + __option + " option").c_str());
+}
+
+_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void __throw_invalid_type_format_error(const char* __id) {
+  std::__throw_format_error(
+      (string("The type option contains an invalid value for ") + __id + " formatting argument").c_str());
+}
+
 template <contiguous_iterator _Iterator, class _ParseContext>
 _LIBCPP_HIDE_FROM_ABI constexpr __format::__parse_number_result<_Iterator>
 __parse_arg_id(_Iterator __begin, _Iterator __end, _ParseContext& __ctx) {
@@ -59,20 +70,19 @@ __parse_arg_id(_Iterator __begin, _Iterator __end, _ParseContext& __ctx) {
   // This function is a wrapper to call the real parser. But it does the
   // validation for the pre-conditions and post-conditions.
   if (__begin == __end)
-    std::__throw_format_error("End of input while parsing format-spec arg-id");
+    std::__throw_format_error("End of input while parsing an argument index");
 
   __format::__parse_number_result __r = __format::__parse_arg_id(__begin, __end, __ctx);
 
   if (__r.__last == __end || *__r.__last != _CharT('}'))
-    std::__throw_format_error("Invalid arg-id");
+    std::__throw_format_error("The argument index is invalid");
 
   ++__r.__last;
   return __r;
 }
 
 template <class _Context>
-_LIBCPP_HIDE_FROM_ABI constexpr uint32_t
-__substitute_arg_id(basic_format_arg<_Context> __format_arg) {
+_LIBCPP_HIDE_FROM_ABI constexpr uint32_t __substitute_arg_id(basic_format_arg<_Context> __format_arg) {
   // [format.string.std]/8
   //   If the corresponding formatting argument is not of integral type...
   // This wording allows char and bool too. LWG-3720 changes the wording to
@@ -81,11 +91,11 @@ __substitute_arg_id(basic_format_arg<_Context> __format_arg) {
   // This means the 128-bit will not be valid anymore.
   // TODO FMT Verify this resolution is accepted and add a test to verify
   //          128-bit integrals fail and switch to visit_format_arg.
-  return _VSTD::__visit_format_arg(
+  return std::__visit_format_arg(
       [](auto __arg) -> uint32_t {
         using _Type = decltype(__arg);
         if constexpr (same_as<_Type, monostate>)
-          std::__throw_format_error("Argument index out of bounds");
+          std::__throw_format_error("The argument index value is too large for the number of arguments supplied");
 
         // [format.string.std]/8
         // If { arg-idopt } is used in a width or precision, the value of the
@@ -101,12 +111,12 @@ __substitute_arg_id(basic_format_arg<_Context> __format_arg) {
                       same_as<_Type, long long> || same_as<_Type, unsigned long long>) {
           if constexpr (signed_integral<_Type>) {
             if (__arg < 0)
-              std::__throw_format_error("A format-spec arg-id replacement shouldn't have a negative value");
+              std::__throw_format_error("An argument index may not have a negative value");
           }
 
           using _CT = common_type_t<_Type, decltype(__format::__number_max)>;
           if (static_cast<_CT>(__arg) > static_cast<_CT>(__format::__number_max))
-            std::__throw_format_error("A format-spec arg-id replacement exceeds the maximum supported value");
+            std::__throw_format_error("The value of the argument index exceeds its maximum value");
 
           return __arg;
         } else
@@ -119,48 +129,52 @@ __substitute_arg_id(basic_format_arg<_Context> __format_arg) {
 ///
 /// They default to false so when a new field is added it needs to be opted in
 /// explicitly.
-// TODO FMT Use an ABI tag for this struct.
-struct __fields {
-  uint8_t __sign_ : 1 {false};
-  uint8_t __alternate_form_ : 1 {false};
-  uint8_t __zero_padding_ : 1 {false};
-  uint8_t __precision_ : 1 {false};
-  uint8_t __locale_specific_form_ : 1 {false};
-  uint8_t __type_ : 1 {false};
+struct _LIBCPP_HIDE_FROM_ABI __fields {
+  uint16_t __sign_                 : 1 {false};
+  uint16_t __alternate_form_       : 1 {false};
+  uint16_t __zero_padding_         : 1 {false};
+  uint16_t __precision_            : 1 {false};
+  uint16_t __locale_specific_form_ : 1 {false};
+  uint16_t __type_                 : 1 {false};
   // Determines the valid values for fill.
   //
   // Originally the fill could be any character except { and }. Range-based
   // formatters use the colon to mark the beginning of the
   // underlying-format-spec. To avoid parsing ambiguities these formatter
   // specializations prohibit the use of the colon as a fill character.
-  uint8_t __use_range_fill_ : 1 {false};
+  uint16_t __use_range_fill_ : 1 {false};
+  uint16_t __clear_brackets_ : 1 {false};
+  uint16_t __consume_all_    : 1 {false};
 };
 
 // By not placing this constant in the formatter class it's not duplicated for
 // char and wchar_t.
+inline constexpr __fields __fields_bool{.__locale_specific_form_ = true, .__type_ = true, .__consume_all_ = true};
 inline constexpr __fields __fields_integral{
     .__sign_                 = true,
     .__alternate_form_       = true,
     .__zero_padding_         = true,
     .__locale_specific_form_ = true,
-    .__type_                 = true};
+    .__type_                 = true,
+    .__consume_all_          = true};
 inline constexpr __fields __fields_floating_point{
     .__sign_                 = true,
     .__alternate_form_       = true,
     .__zero_padding_         = true,
     .__precision_            = true,
     .__locale_specific_form_ = true,
-    .__type_                 = true};
-inline constexpr __fields __fields_string{.__precision_ = true, .__type_ = true};
-inline constexpr __fields __fields_pointer{.__type_ = true};
+    .__type_                 = true,
+    .__consume_all_          = true};
+inline constexpr __fields __fields_string{.__precision_ = true, .__type_ = true, .__consume_all_ = true};
+inline constexpr __fields __fields_pointer{.__zero_padding_ = true, .__type_ = true, .__consume_all_ = true};
 
 #  if _LIBCPP_STD_VER >= 23
-inline constexpr __fields __fields_tuple{.__use_range_fill_ = true};
-inline constexpr __fields __fields_range{.__use_range_fill_ = true};
+inline constexpr __fields __fields_tuple{.__use_range_fill_ = true, .__clear_brackets_ = true};
+inline constexpr __fields __fields_range{.__use_range_fill_ = true, .__clear_brackets_ = true};
 inline constexpr __fields __fields_fill_align_width{};
 #  endif
 
-enum class _LIBCPP_ENUM_VIS __alignment : uint8_t {
+enum class __alignment : uint8_t {
   /// No alignment is set in the format string.
   __default,
   __left,
@@ -169,7 +183,7 @@ enum class _LIBCPP_ENUM_VIS __alignment : uint8_t {
   __zero_padding
 };
 
-enum class _LIBCPP_ENUM_VIS __sign : uint8_t {
+enum class __sign : uint8_t {
   /// No sign is set in the format string.
   ///
   /// The sign isn't allowed for certain format-types. By using this value
@@ -181,8 +195,8 @@ enum class _LIBCPP_ENUM_VIS __sign : uint8_t {
   __space
 };
 
-enum class _LIBCPP_ENUM_VIS __type : uint8_t {
-  __default,
+enum class __type : uint8_t {
+  __default = 0,
   __string,
   __binary_lower_case,
   __binary_upper_case,
@@ -190,7 +204,8 @@ enum class _LIBCPP_ENUM_VIS __type : uint8_t {
   __decimal,
   __hexadecimal_lower_case,
   __hexadecimal_upper_case,
-  __pointer,
+  __pointer_lower_case,
+  __pointer_upper_case,
   __char,
   __hexfloat_lower_case,
   __hexfloat_upper_case,
@@ -203,23 +218,42 @@ enum class _LIBCPP_ENUM_VIS __type : uint8_t {
   __debug
 };
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr uint32_t __create_type_mask(__type __t) {
+  uint32_t __shift = static_cast<uint32_t>(__t);
+  if (__shift == 0)
+    return 1;
+
+  if (__shift > 31)
+    std::__throw_format_error("The type does not fit in the mask");
+
+  return 1 << __shift;
+}
+
+inline constexpr uint32_t __type_mask_integer =
+    __create_type_mask(__type::__binary_lower_case) |      //
+    __create_type_mask(__type::__binary_upper_case) |      //
+    __create_type_mask(__type::__decimal) |                //
+    __create_type_mask(__type::__octal) |                  //
+    __create_type_mask(__type::__hexadecimal_lower_case) | //
+    __create_type_mask(__type::__hexadecimal_upper_case);
+
 struct __std {
-  __alignment __alignment_ : 3;
-  __sign __sign_ : 2;
-  bool __alternate_form_ : 1;
+  __alignment __alignment_     : 3;
+  __sign __sign_               : 2;
+  bool __alternate_form_       : 1;
   bool __locale_specific_form_ : 1;
   __type __type_;
 };
 
 struct __chrono {
-  __alignment __alignment_ : 3;
+  __alignment __alignment_     : 3;
   bool __locale_specific_form_ : 1;
   bool __hour_                 : 1;
-  bool __weekday_name_ : 1;
+  bool __weekday_name_         : 1;
   bool __weekday_              : 1;
   bool __day_of_year_          : 1;
   bool __week_of_year_         : 1;
-  bool __month_name_ : 1;
+  bool __month_name_           : 1;
 };
 
 // The fill UCS scalar value.
@@ -303,50 +337,163 @@ static_assert(is_trivially_copyable_v<__parsed_specifications<wchar_t>>);
 template <class _CharT>
 class _LIBCPP_TEMPLATE_VIS __parser {
 public:
+  // Parses the format specification.
+  //
+  // Depending on whether the parsing is done compile-time or run-time
+  // the method slightly differs.
+  // - Only parses a field when it is in the __fields. Accepting all
+  //   fields and then validating the valid ones has a performance impact.
+  //   This is faster but gives slighly worse error messages.
+  // - At compile-time when a field is not accepted the parser will still
+  //   parse it and give an error when it's present. This gives a more
+  //   accurate error.
+  // The idea is that most times the format instead of the vformat
+  // functions are used. In that case the error will be detected during
+  // compilation and there is no need to pay for the run-time overhead.
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator __parse(_ParseContext& __ctx, __fields __fields) {
     auto __begin = __ctx.begin();
     auto __end   = __ctx.end();
-    if (__begin == __end)
+    if (__begin == __end || *__begin == _CharT('}') || (__fields.__use_range_fill_ && *__begin == _CharT(':')))
       return __begin;
 
-    if (__parse_fill_align(__begin, __end, __fields.__use_range_fill_) && __begin == __end)
+    if (__parse_fill_align(__begin, __end) && __begin == __end)
       return __begin;
 
-    if (__fields.__sign_ && __parse_sign(__begin) && __begin == __end)
-      return __begin;
+    if (__fields.__sign_) {
+      if (__parse_sign(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_sign(__begin)) {
+      std::__throw_format_error("The format specification does not allow the sign option");
+    }
 
-    if (__fields.__alternate_form_ && __parse_alternate_form(__begin) && __begin == __end)
-      return __begin;
+    if (__fields.__alternate_form_) {
+      if (__parse_alternate_form(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_alternate_form(__begin)) {
+      std::__throw_format_error("The format specifier does not allow the alternate form option");
+    }
 
-    if (__fields.__zero_padding_ && __parse_zero_padding(__begin) && __begin == __end)
-      return __begin;
+    if (__fields.__zero_padding_) {
+      if (__parse_zero_padding(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_zero_padding(__begin)) {
+      std::__throw_format_error("The format specifier does not allow the zero-padding option");
+    }
 
     if (__parse_width(__begin, __end, __ctx) && __begin == __end)
       return __begin;
 
-    if (__fields.__precision_ && __parse_precision(__begin, __end, __ctx) && __begin == __end)
-      return __begin;
+    if (__fields.__precision_) {
+      if (__parse_precision(__begin, __end, __ctx) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_precision(__begin, __end, __ctx)) {
+      std::__throw_format_error("The format specifier does not allow the precision option");
+    }
 
-    if (__fields.__locale_specific_form_ && __parse_locale_specific_form(__begin) && __begin == __end)
-      return __begin;
+    if (__fields.__locale_specific_form_) {
+      if (__parse_locale_specific_form(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_locale_specific_form(__begin)) {
+      std::__throw_format_error("The format specifier does not allow the locale-specific form option");
+    }
 
-    if (__fields.__type_) {
+    if (__fields.__clear_brackets_) {
+      if (__parse_clear_brackets(__begin) && __begin == __end)
+        return __begin;
+    } else if (std::is_constant_evaluated() && __parse_clear_brackets(__begin)) {
+      std::__throw_format_error("The format specifier does not allow the n option");
+    }
+
+    if (__fields.__type_)
       __parse_type(__begin);
 
-      // When __type_ is false the calling parser is expected to do additional
-      // parsing. In that case that parser should do the end of format string
-      // validation.
-      if (__begin != __end && *__begin != _CharT('}'))
-        std::__throw_format_error("The format-spec should consume the input or end with a '}'");
-    }
+    if (!__fields.__consume_all_)
+      return __begin;
+
+    if (__begin != __end && *__begin != _CharT('}'))
+      std::__throw_format_error("The format specifier should consume the input or end with a '}'");
 
     return __begin;
   }
 
+  // Validates the selected the parsed data.
+  //
+  // The valid fields in the parser may depend on the display type
+  // selected. But the type is the last optional field, so by the time
+  // it's known an option can't be used, it already has been parsed.
+  // This does the validation again.
+  //
+  // For example an integral may have a sign, zero-padding, or alternate
+  // form when the type option is not 'c'. So the generic approach is:
+  //
+  // typename _ParseContext::iterator __result = __parser_.__parse(__ctx, __format_spec::__fields_integral);
+  // if (__parser.__type_ == __format_spec::__type::__char) {
+  //   __parser.__validate((__format_spec::__fields_bool, "an integer");
+  //   ... // more char adjustments
+  // } else {
+  //   ... // validate an integral type.
+  // }
+  //
+  // For some types all valid options need a second validation run, like
+  // boolean types.
+  //
+  // Depending on whether the validation is done at compile-time or
+  // run-time the error differs
+  // - run-time the exception is thrown and contains the type of field
+  //   being validated.
+  // - at compile-time the line with `std::__throw_format_error` is shown
+  //   in the output. In that case it's important for the error to be on one
+  //   line.
+  // Note future versions of C++ may allow better compile-time error
+  // reporting.
+  _LIBCPP_HIDE_FROM_ABI constexpr void
+  __validate(__fields __fields, const char* __id, uint32_t __type_mask = -1) const {
+    if (!__fields.__sign_ && __sign_ != __sign::__default) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the sign option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "sign");
+    }
+
+    if (!__fields.__alternate_form_ && __alternate_form_) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the alternate form option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "alternate form");
+    }
+
+    if (!__fields.__zero_padding_ && __alignment_ == __alignment::__zero_padding) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the zero-padding option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "zero-padding");
+    }
+
+    if (!__fields.__precision_ && __precision_ != -1) { // Works both when the precision has a value or an arg-id.
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the precision option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "precision");
+    }
+
+    if (!__fields.__locale_specific_form_ && __locale_specific_form_) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier does not allow the locale-specific form option");
+      else
+        __format_spec::__throw_invalid_option_format_error(__id, "locale-specific form");
+    }
+
+    if ((__create_type_mask(__type_) & __type_mask) == 0) {
+      if (std::is_constant_evaluated())
+        std::__throw_format_error("The format specifier uses an invalid value for the type option");
+      else
+        __format_spec::__throw_invalid_type_format_error(__id);
+    }
+  }
+
   /// \returns the `__parsed_specifications` with the resolved dynamic sizes..
-  _LIBCPP_HIDE_FROM_ABI
-  __parsed_specifications<_CharT> __get_parsed_std_specifications(auto& __ctx) const {
+  _LIBCPP_HIDE_FROM_ABI __parsed_specifications<_CharT> __get_parsed_std_specifications(auto& __ctx) const {
     return __parsed_specifications<_CharT>{
         .__std_ = __std{.__alignment_            = __alignment_,
                         .__sign_                 = __sign_,
@@ -374,11 +521,11 @@ public:
         .__fill_{__fill_}};
   }
 
-  __alignment __alignment_ : 3 {__alignment::__default};
-  __sign __sign_ : 2 {__sign::__default};
-  bool __alternate_form_ : 1 {false};
+  __alignment __alignment_     : 3 {__alignment::__default};
+  __sign __sign_               : 2 {__sign::__default};
+  bool __alternate_form_       : 1 {false};
   bool __locale_specific_form_ : 1 {false};
-  bool __reserved_0_ : 1 {false};
+  bool __clear_brackets_       : 1 {false};
   __type __type_{__type::__default};
 
   // These flags are only used for formatting chrono. Since the struct has
@@ -393,11 +540,11 @@ public:
 
   bool __month_name_ : 1 {false};
 
-  uint8_t __reserved_1_ : 2 {0};
-  uint8_t __reserved_2_ : 6 {0};
+  uint8_t __reserved_0_ : 2 {0};
+  uint8_t __reserved_1_ : 6 {0};
   // These two flags are only used internally and not part of the
   // __parsed_specifications. Therefore put them at the end.
-  bool __width_as_arg_ : 1 {false};
+  bool __width_as_arg_     : 1 {false};
   bool __precision_as_arg_ : 1 {false};
 
   /// The requested width, either the value or the arg-id.
@@ -426,13 +573,11 @@ private:
     return false;
   }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr void __validate_fill_character(_CharT __fill, bool __use_range_fill) {
+  _LIBCPP_HIDE_FROM_ABI constexpr void __validate_fill_character(_CharT __fill) {
     // The forbidden fill characters all code points formed from a single code unit, thus the
     // check can be omitted when more code units are used.
-    if (__use_range_fill && (__fill == _CharT('{') || __fill == _CharT('}') || __fill == _CharT(':')))
-      std::__throw_format_error("The format-spec range-fill field contains an invalid character");
-    else if (__fill == _CharT('{') || __fill == _CharT('}'))
-      std::__throw_format_error("The format-spec fill field contains an invalid character");
+    if (__fill == _CharT('{'))
+      std::__throw_format_error("The fill option contains an invalid value");
   }
 
 #  ifndef _LIBCPP_HAS_NO_UNICODE
@@ -442,14 +587,15 @@ private:
 #    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
           || (same_as<_CharT, wchar_t> && sizeof(wchar_t) == 2)
 #    endif
-  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end, bool __use_range_fill) {
-    _LIBCPP_ASSERT(__begin != __end,
-                   "when called with an empty input the function will cause "
-                   "undefined behavior by evaluating data not in the input");
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __begin != __end,
+        "when called with an empty input the function will cause "
+        "undefined behavior by evaluating data not in the input");
     __unicode::__code_point_view<_CharT> __view{__begin, __end};
     __unicode::__consume_result __consumed = __view.__consume();
     if (__consumed.__status != __unicode::__consume_result::__ok)
-      std::__throw_format_error("The format-spec contains malformed Unicode characters");
+      std::__throw_format_error("The format specifier contains malformed Unicode characters");
 
     if (__view.__position() < __end && __parse_alignment(*__view.__position())) {
       ptrdiff_t __code_units = __view.__position() - __begin;
@@ -457,7 +603,7 @@ private:
         // The forbidden fill characters all are code points encoded
         // in one code unit, thus the check can be omitted when more
         // code units are used.
-        __validate_fill_character(*__begin, __use_range_fill);
+        __validate_fill_character(*__begin);
 
       std::copy_n(__begin, __code_units, std::addressof(__fill_.__data[0]));
       __begin += __code_units + 1;
@@ -474,15 +620,16 @@ private:
 #    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
   template <contiguous_iterator _Iterator>
     requires(same_as<_CharT, wchar_t> && sizeof(wchar_t) == 4)
-  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end, bool __use_range_fill) {
-    _LIBCPP_ASSERT(__begin != __end,
-                   "when called with an empty input the function will cause "
-                   "undefined behavior by evaluating data not in the input");
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __begin != __end,
+        "when called with an empty input the function will cause "
+        "undefined behavior by evaluating data not in the input");
     if (__begin + 1 != __end && __parse_alignment(*(__begin + 1))) {
       if (!__unicode::__is_scalar_value(*__begin))
-        std::__throw_format_error("The fill character contains an invalid value");
+        std::__throw_format_error("The fill option contains an invalid value");
 
-      __validate_fill_character(*__begin, __use_range_fill);
+      __validate_fill_character(*__begin);
 
       __fill_.__data[0] = *__begin;
       __begin += 2;
@@ -501,13 +648,14 @@ private:
 #  else // _LIBCPP_HAS_NO_UNICODE
   // range-fill and tuple-fill are identical
   template <contiguous_iterator _Iterator>
-  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end, bool __use_range_fill) {
-    _LIBCPP_ASSERT(__begin != __end,
-                   "when called with an empty input the function will cause "
-                   "undefined behavior by evaluating data not in the input");
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_fill_align(_Iterator& __begin, _Iterator __end) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __begin != __end,
+        "when called with an empty input the function will cause "
+        "undefined behavior by evaluating data not in the input");
     if (__begin + 1 != __end) {
       if (__parse_alignment(*(__begin + 1))) {
-        __validate_fill_character(*__begin, __use_range_fill);
+        __validate_fill_character(*__begin);
 
         __fill_.__data[0] = *__begin;
         __begin += 2;
@@ -567,13 +715,13 @@ private:
   template <contiguous_iterator _Iterator>
   _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_width(_Iterator& __begin, _Iterator __end, auto& __ctx) {
     if (*__begin == _CharT('0'))
-      std::__throw_format_error("A format-spec width field shouldn't have a leading zero");
+      std::__throw_format_error("The width option should not have a leading zero");
 
     if (*__begin == _CharT('{')) {
       __format::__parse_number_result __r = __format_spec::__parse_arg_id(++__begin, __end, __ctx);
-      __width_as_arg_ = true;
-      __width_ = __r.__value;
-      __begin = __r.__last;
+      __width_as_arg_                     = true;
+      __width_                            = __r.__value;
+      __begin                             = __r.__last;
       return true;
     }
 
@@ -581,9 +729,10 @@ private:
       return false;
 
     __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
-    __width_ = __r.__value;
-    _LIBCPP_ASSERT(__width_ != 0, "A zero value isn't allowed and should be impossible, "
-                                  "due to validations in this function");
+    __width_                            = __r.__value;
+    _LIBCPP_ASSERT_INTERNAL(__width_ != 0,
+                            "A zero value isn't allowed and should be impossible, "
+                            "due to validations in this function");
     __begin = __r.__last;
     return true;
   }
@@ -595,23 +744,23 @@ private:
 
     ++__begin;
     if (__begin == __end)
-      std::__throw_format_error("End of input while parsing format-spec precision");
+      std::__throw_format_error("End of input while parsing format specifier precision");
 
     if (*__begin == _CharT('{')) {
       __format::__parse_number_result __arg_id = __format_spec::__parse_arg_id(++__begin, __end, __ctx);
-      __precision_as_arg_ = true;
-      __precision_ = __arg_id.__value;
-      __begin = __arg_id.__last;
+      __precision_as_arg_                      = true;
+      __precision_                             = __arg_id.__value;
+      __begin                                  = __arg_id.__last;
       return true;
     }
 
     if (*__begin < _CharT('0') || *__begin > _CharT('9'))
-      std::__throw_format_error("The format-spec precision field doesn't contain a value or arg-id");
+      std::__throw_format_error("The precision option does not contain a value or an argument index");
 
     __format::__parse_number_result __r = __format::__parse_number(__begin, __end);
-    __precision_ = __r.__value;
-    __precision_as_arg_ = false;
-    __begin = __r.__last;
+    __precision_                        = __r.__value;
+    __precision_as_arg_                 = false;
+    __begin                             = __r.__last;
     return true;
   }
 
@@ -625,6 +774,16 @@ private:
     return true;
   }
 
+  template <contiguous_iterator _Iterator>
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __parse_clear_brackets(_Iterator& __begin) {
+    if (*__begin != _CharT('n'))
+      return false;
+
+    __clear_brackets_ = true;
+    ++__begin;
+    return true;
+  }
+
   template <contiguous_iterator _Iterator>
   _LIBCPP_HIDE_FROM_ABI constexpr void __parse_type(_Iterator& __begin) {
     // Determines the type. It does not validate whether the selected type is
@@ -676,7 +835,10 @@ private:
       __type_ = __type::__octal;
       break;
     case 'p':
-      __type_ = __type::__pointer;
+      __type_ = __type::__pointer_lower_case;
+      break;
+    case 'P':
+      __type_ = __type::__pointer_upper_case;
       break;
     case 's':
       __type_ = __type::__string;
@@ -695,16 +857,14 @@ private:
     ++__begin;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  int32_t __get_width(auto& __ctx) const {
+  _LIBCPP_HIDE_FROM_ABI int32_t __get_width(auto& __ctx) const {
     if (!__width_as_arg_)
       return __width_;
 
     return __format_spec::__substitute_arg_id(__ctx.arg(__width_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  int32_t __get_precision(auto& __ctx) const {
+  _LIBCPP_HIDE_FROM_ABI int32_t __get_precision(auto& __ctx) const {
     if (!__precision_as_arg_)
       return __precision_;
 
@@ -726,36 +886,28 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_string(__format_spec
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for a string argument");
+    std::__throw_format_error("The type option contains an invalid value for a string formatting argument");
   }
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_bool_string(__parser<_CharT>& __parser) {
-  if (__parser.__sign_ != __sign::__default)
-    std::__throw_format_error("A sign field isn't allowed in this format-spec");
-
-  if (__parser.__alternate_form_)
-    std::__throw_format_error("An alternate form field isn't allowed in this format-spec");
-
-  if (__parser.__alignment_ == __alignment::__zero_padding)
-    std::__throw_format_error("A zero-padding field isn't allowed in this format-spec");
-
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_bool_string(__parser<_CharT>& __parser, const char* __id) {
+  __parser.__validate(__format_spec::__fields_bool, __id);
   if (__parser.__alignment_ == __alignment::__default)
     __parser.__alignment_ = __alignment::__left;
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_char(__parser<_CharT>& __parser) {
-  __format_spec::__process_display_type_bool_string(__parser);
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_char(__parser<_CharT>& __parser, const char* __id) {
+  __format_spec::__process_display_type_bool_string(__parser, __id);
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_bool(__parser<_CharT>& __parser) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_bool(__parser<_CharT>& __parser, const char* __id) {
   switch (__parser.__type_) {
   case __format_spec::__type::__default:
   case __format_spec::__type::__string:
-    __format_spec::__process_display_type_bool_string(__parser);
+    __format_spec::__process_display_type_bool_string(__parser, __id);
     break;
 
   case __format_spec::__type::__binary_lower_case:
@@ -767,17 +919,17 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_bool(__parser<_CharT>& __p
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for a bool argument");
+    __format_spec::__throw_invalid_type_format_error(__id);
   }
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_char(__parser<_CharT>& __parser) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_char(__parser<_CharT>& __parser, const char* __id) {
   switch (__parser.__type_) {
   case __format_spec::__type::__default:
   case __format_spec::__type::__char:
   case __format_spec::__type::__debug:
-    __format_spec::__process_display_type_char(__parser);
+    __format_spec::__process_display_type_char(__parser, __id);
     break;
 
   case __format_spec::__type::__binary_lower_case:
@@ -789,12 +941,12 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_char(__parser<_CharT>& __p
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for a char argument");
+    __format_spec::__throw_invalid_type_format_error(__id);
   }
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_integer(__parser<_CharT>& __parser) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_integer(__parser<_CharT>& __parser, const char* __id) {
   switch (__parser.__type_) {
   case __format_spec::__type::__default:
   case __format_spec::__type::__binary_lower_case:
@@ -806,16 +958,16 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_integer(__parser<_CharT>&
     break;
 
   case __format_spec::__type::__char:
-    __format_spec::__process_display_type_char(__parser);
+    __format_spec::__process_display_type_char(__parser, __id);
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for an integer argument");
+    __format_spec::__throw_invalid_type_format_error(__id);
   }
 }
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_floating_point(__parser<_CharT>& __parser) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_floating_point(__parser<_CharT>& __parser, const char* __id) {
   switch (__parser.__type_) {
   case __format_spec::__type::__default:
   case __format_spec::__type::__hexfloat_lower_case:
@@ -834,18 +986,19 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __process_parsed_floating_point(__parser<_C
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for a floating-point argument");
+    __format_spec::__throw_invalid_type_format_error(__id);
   }
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_pointer(__format_spec::__type __type) {
+_LIBCPP_HIDE_FROM_ABI constexpr void __process_display_type_pointer(__format_spec::__type __type, const char* __id) {
   switch (__type) {
   case __format_spec::__type::__default:
-  case __format_spec::__type::__pointer:
+  case __format_spec::__type::__pointer_lower_case:
+  case __format_spec::__type::__pointer_upper_case:
     break;
 
   default:
-    std::__throw_format_error("The format-spec type has a type not supported for a pointer argument");
+    __format_spec::__throw_invalid_type_format_error(__id);
   }
 }
 
@@ -1002,8 +1155,8 @@ __estimate_column_width(basic_string_view<_CharT> __str, size_t __maximum, __col
   // When Unicode isn't supported assume ASCII and every code unit is one code
   // point. In ASCII the estimated column width is always one. Thus there's no
   // need for rounding.
-  size_t __width_ = _VSTD::min(__str.size(), __maximum);
-  return {__width_, __str.begin() + __width_};
+  size_t __width = std::min(__str.size(), __maximum);
+  return {__width, __str.begin() + __width};
 }
 
 #  endif // !defined(_LIBCPP_HAS_NO_UNICODE)
diff --git a/third_party/libcxx/__format/range_default_formatter.h b/third_party/libcxx/__format/range_default_formatter.h
index 7808d0b12..b35223ae9 100644
--- a/third_party/libcxx/__format/range_default_formatter.h
+++ b/third_party/libcxx/__format/range_default_formatter.h
@@ -10,8 +10,11 @@
 #ifndef _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H
 #define _LIBCPP___FORMAT_RANGE_DEFAULT_FORMATTER_H
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
 #include <__algorithm/ranges_copy.h>
-#include <__availability>
 #include <__chrono/statically_widen.h>
 #include <__concepts/same_as.h>
 #include <__config>
@@ -21,11 +24,12 @@
 #include <__iterator/back_insert_iterator.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
+#include <__ranges/from_range.h>
 #include <__ranges/size.h>
+#include <__type_traits/conditional.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/pair.h>
 #include <string_view>
-#include <tuple>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -108,8 +112,9 @@ public:
     return __underlying_.parse(__ctx);
   }
 
-  template <class FormatContext>
-  _LIBCPP_HIDE_FROM_ABI typename FormatContext::iterator format(__maybe_const_r& __range, FormatContext& __ctx) const {
+  template <class _FormatContext>
+  _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator
+  format(__maybe_const_r& __range, _FormatContext& __ctx) const {
     return __underlying_.format(__range, __ctx);
   }
 };
@@ -193,15 +198,8 @@ public:
     // specialization is the "basic" string formatter in libc++.
     if constexpr (ranges::contiguous_range<_Rp> && std::ranges::sized_range<_Rp>)
       return __underlying_.format(basic_string_view<_CharT>{ranges::data(__range), ranges::size(__range)}, __ctx);
-    else {
-      // P2106's from_range has not been implemented yet. Instead use a simple
-      // copy operation.
-      // TODO FMT use basic_string's "from_range" constructor.
-      // return __underlying_.format(basic_string<_CharT>{from_range, __range}, __ctx);
-      basic_string<_CharT> __str;
-      std::ranges::copy(__range, back_insert_iterator{__str});
-      return __underlying_.format(static_cast<basic_string_view<_CharT>>(__str), __ctx);
-    }
+    else
+      return __underlying_.format(basic_string<_CharT>{from_range, __range}, __ctx);
   }
 };
 
diff --git a/third_party/libcxx/__format/range_formatter.h b/third_party/libcxx/__format/range_formatter.h
index c0d238a55..691563074 100644
--- a/third_party/libcxx/__format/range_formatter.h
+++ b/third_party/libcxx/__format/range_formatter.h
@@ -10,14 +10,16 @@
 #ifndef _LIBCPP___FORMAT_RANGE_FORMATTER_H
 #define _LIBCPP___FORMAT_RANGE_FORMATTER_H
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
 #include <__algorithm/ranges_copy.h>
-#include <__availability>
 #include <__chrono/statically_widen.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/buffer.h>
 #include <__format/concepts.h>
-#include <__format/format_args.h>
 #include <__format/format_context.h>
 #include <__format/format_error.h>
 #include <__format/formatter.h>
@@ -26,6 +28,7 @@
 #include <__iterator/back_insert_iterator.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
+#include <__ranges/from_range.h>
 #include <__ranges/size.h>
 #include <__type_traits/remove_cvref.h>
 #include <string_view>
@@ -62,18 +65,8 @@ struct _LIBCPP_TEMPLATE_VIS range_formatter {
 
     // The n field overrides a possible m type, therefore delay applying the
     // effect of n until the type has been procesed.
-    bool __clear_brackets = (*__begin == _CharT('n'));
-    if (__clear_brackets) {
-      ++__begin;
-      if (__begin == __end) [[unlikely]] {
-        // Since there is no more data, clear the brackets before returning.
-        set_brackets({}, {});
-        return __parse_empty_range_underlying_spec(__ctx, __begin);
-      }
-    }
-
     __parse_type(__begin, __end);
-    if (__clear_brackets)
+    if (__parser_.__clear_brackets_)
       set_brackets({}, {});
     if (__begin == __end) [[unlikely]]
       return __parse_empty_range_underlying_spec(__ctx, __begin);
@@ -89,7 +82,7 @@ struct _LIBCPP_TEMPLATE_VIS range_formatter {
       // processed by the underlying. For example {:-} for a range in invalid,
       // the sign field is not present. Without this check the underlying_ will
       // get -} as input which my be valid.
-      std::__throw_format_error("The format-spec should consume the input or end with a '}'");
+      std::__throw_format_error("The format specifier should consume the input or end with a '}'");
 
     __ctx.advance_to(__begin);
     __begin = __underlying_.parse(__ctx);
@@ -102,13 +95,13 @@ struct _LIBCPP_TEMPLATE_VIS range_formatter {
     //   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^
     // could consume more than it should.
     if (__begin != __end && *__begin != _CharT('}'))
-      std::__throw_format_error("The format-spec should consume the input or end with a '}'");
+      std::__throw_format_error("The format specifier should consume the input or end with a '}'");
 
     if (__parser_.__type_ != __format_spec::__type::__default) {
       // [format.range.formatter]/6
       //   If the range-type is s or ?s, then there shall be no n option and no
       //   range-underlying-spec.
-      if (__clear_brackets) {
+      if (__parser_.__clear_brackets_) {
         if (__parser_.__type_ == __format_spec::__type::__string)
           std::__throw_format_error("The n option and type s can't be used together");
         std::__throw_format_error("The n option and type ?s can't be used together");
@@ -192,13 +185,7 @@ struct _LIBCPP_TEMPLATE_VIS range_formatter {
       std::formatter<basic_string<_CharT>, _CharT> __formatter;
       if (__debug_format)
         __formatter.set_debug_format();
-      // P2106's from_range has not been implemented yet. Instead use a simple
-      // copy operation.
-      // TODO FMT use basic_string's "from_range" constructor.
-      // return std::formatter<basic_string<_CharT>, _CharT>{}.format(basic_string<_CharT>{from_range, __range}, __ctx);
-      basic_string<_CharT> __str;
-      ranges::copy(__range, back_insert_iterator{__str});
-      return __formatter.format(__str, __ctx);
+      return __formatter.format(basic_string<_CharT>{from_range, __range}, __ctx);
     }
   }
 
@@ -231,7 +218,7 @@ private:
         set_separator(_LIBCPP_STATICALLY_WIDEN(_CharT, ", "));
         ++__begin;
       } else
-        std::__throw_format_error("The range-format-spec type m requires two elements for a pair or tuple");
+        std::__throw_format_error("Type m requires a pair or a tuple with two elements");
       break;
 
     case _CharT('s'):
@@ -239,18 +226,18 @@ private:
         __parser_.__type_ = __format_spec::__type::__string;
         ++__begin;
       } else
-        std::__throw_format_error("The range-format-spec type s requires formatting a character type");
+        std::__throw_format_error("Type s requires character type as formatting argument");
       break;
 
     case _CharT('?'):
       ++__begin;
       if (__begin == __end || *__begin != _CharT('s'))
-        std::__throw_format_error("The format-spec should consume the input or end with a '}'");
+        std::__throw_format_error("The format specifier should consume the input or end with a '}'");
       if constexpr (same_as<_Tp, _CharT>) {
         __parser_.__type_ = __format_spec::__type::__debug;
         ++__begin;
       } else
-        std::__throw_format_error("The range-format-spec type ?s requires formatting a character type");
+        std::__throw_format_error("Type ?s requires character type as formatting argument");
     }
   }
 
@@ -259,8 +246,8 @@ private:
   __parse_empty_range_underlying_spec(_ParseContext& __ctx, typename _ParseContext::iterator __begin) {
     __ctx.advance_to(__begin);
     [[maybe_unused]] typename _ParseContext::iterator __result = __underlying_.parse(__ctx);
-    _LIBCPP_ASSERT(__result == __begin,
-                   "the underlying's parse function should not advance the input beyond the end of the input");
+    _LIBCPP_ASSERT_INTERNAL(__result == __begin,
+                            "the underlying's parse function should not advance the input beyond the end of the input");
     return __begin;
   }
 
diff --git a/third_party/libcxx/__format/unicode.h b/third_party/libcxx/__format/unicode.h
index 12aed5079..de7d0fea1 100644
--- a/third_party/libcxx/__format/unicode.h
+++ b/third_party/libcxx/__format/unicode.h
@@ -15,9 +15,9 @@
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/extended_grapheme_cluster_table.h>
+#include <__format/indic_conjunct_break_table.h>
 #include <__iterator/concepts.h>
 #include <__iterator/readable_traits.h> // iter_value_t
-#include <__type_traits/make_unsigned.h>
 #include <__utility/unreachable.h>
 #include <string_view>
 
@@ -105,7 +105,7 @@ template <contiguous_iterator _Iterator>
   requires same_as<iter_value_t<_Iterator>, char>
 _LIBCPP_HIDE_FROM_ABI constexpr bool __is_continuation(_Iterator __char, int __count) {
   do {
-    if ((*__char & 0b1000'0000) != 0b1000'0000)
+    if ((*__char & 0b1100'0000) != 0b1000'0000)
       return false;
     --__count;
     ++__char;
@@ -155,7 +155,7 @@ public:
   // - The parser always needs to consume these code units
   // - The code is optimized for well-formed UTF-8
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __consume_result __consume() noexcept {
-    _LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input");
+    _LIBCPP_ASSERT_INTERNAL(__first_ != __last_, "can't move beyond the end of input");
 
     // Based on the number of leading 1 bits the number of code units in the
     // code point can be determined. See
@@ -261,7 +261,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI constexpr bool __at_end() const noexcept { return __first_ == __last_; }
 
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __consume_result __consume() noexcept {
-    _LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input");
+    _LIBCPP_ASSERT_INTERNAL(__first_ != __last_, "can't move beyond the end of input");
 
     char32_t __value = static_cast<char32_t>(*__first_++);
     if constexpr (sizeof(wchar_t) == 2) {
@@ -294,85 +294,231 @@ private:
 };
 #    endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
-_LIBCPP_HIDE_FROM_ABI constexpr bool __at_extended_grapheme_cluster_break(
-    bool& __ri_break_allowed,
-    bool __has_extened_pictographic,
-    __extended_grapheme_custer_property_boundary::__property __prev,
-    __extended_grapheme_custer_property_boundary::__property __next) {
-  using __extended_grapheme_custer_property_boundary::__property;
+// State machine to implement the Extended Grapheme Cluster Boundary
+//
+// The exact rules may change between Unicode versions.
+// This implements the extended rules see
+// https://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries
+class __extended_grapheme_cluster_break {
+  using __EGC_property  = __extended_grapheme_custer_property_boundary::__property;
+  using __inCB_property = __indic_conjunct_break::__property;
 
-  __has_extened_pictographic |= __prev == __property::__Extended_Pictographic;
-
-  // https://www.unicode.org/reports/tr29/tr29-39.html#Grapheme_Cluster_Boundary_Rules
-
-  // *** Break at the start and end of text, unless the text is empty. ***
-
-  _LIBCPP_ASSERT(__prev != __property::__sot, "should be handled in the constructor"); // GB1
-  _LIBCPP_ASSERT(__prev != __property::__eot, "should be handled by our caller");      // GB2
-
-  // *** Do not break between a CR and LF. Otherwise, break before and after controls. ***
-  if (__prev == __property::__CR && __next == __property::__LF) // GB3
-    return false;
-
-  if (__prev == __property::__Control || __prev == __property::__CR || __prev == __property::__LF) // GB4
-    return true;
-
-  if (__next == __property::__Control || __next == __property::__CR || __next == __property::__LF) // GB5
-    return true;
-
-  // *** Do not break Hangul syllable sequences. ***
-  if (__prev == __property::__L &&
-      (__next == __property::__L || __next == __property::__V || __next == __property::__LV ||
-       __next == __property::__LVT)) // GB6
-    return false;
-
-  if ((__prev == __property::__LV || __prev == __property::__V) &&
-      (__next == __property::__V || __next == __property::__T)) // GB7
-    return false;
-
-  if ((__prev == __property::__LVT || __prev == __property::__T) && __next == __property::__T) // GB8
-    return false;
-
-  // *** Do not break before extending characters or ZWJ. ***
-  if (__next == __property::__Extend || __next == __property::__ZWJ)
-    return false; // GB9
-
-  // *** Do not break before SpacingMarks, or after Prepend characters. ***
-  if (__next == __property::__SpacingMark) // GB9a
-    return false;
-
-  if (__prev == __property::__Prepend) // GB9b
-    return false;
-
-  // *** Do not break within emoji modifier sequences or emoji zwj sequences. ***
-
-  // GB11 \p{Extended_Pictographic} Extend* ZWJ x \p{Extended_Pictographic}
-  //
-  // Note that several parts of this rule are matched by GB9: Any x (Extend | ZWJ)
-  // - \p{Extended_Pictographic} x Extend
-  // - Extend x Extend
-  // - \p{Extended_Pictographic} x ZWJ
-  // - Extend x ZWJ
-  //
-  // So the only case left to test is
-  // - \p{Extended_Pictographic}' x ZWJ x \p{Extended_Pictographic}
-  //   where  \p{Extended_Pictographic}' is stored in __has_extened_pictographic
-  if (__has_extened_pictographic && __prev == __property::__ZWJ && __next == __property::__Extended_Pictographic)
-    return false;
-
-  // *** Do not break within emoji flag sequences ***
-
-  // That is, do not break between regional indicator (RI) symbols if there
-  // is an odd number of RI characters before the break point.
-
-  if (__prev == __property::__Regional_Indicator && __next == __property::__Regional_Indicator) { // GB12 + GB13
-    __ri_break_allowed = !__ri_break_allowed;
-    return __ri_break_allowed;
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __extended_grapheme_cluster_break(char32_t __first_code_point)
+      : __prev_code_point_(__first_code_point),
+        __prev_property_(__extended_grapheme_custer_property_boundary::__get_property(__first_code_point)) {
+    // Initializes the active rule.
+    if (__prev_property_ == __EGC_property::__Extended_Pictographic)
+      __active_rule_ = __rule::__GB11_emoji;
+    else if (__prev_property_ == __EGC_property::__Regional_Indicator)
+      __active_rule_ = __rule::__GB12_GB13_regional_indicator;
+    else if (__indic_conjunct_break::__get_property(__first_code_point) == __inCB_property::__Consonant)
+      __active_rule_ = __rule::__GB9c_indic_conjunct_break;
   }
 
-  // *** Otherwise, break everywhere. ***
-  return true; // GB999
-}
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(char32_t __next_code_point) {
+    __EGC_property __next_property = __extended_grapheme_custer_property_boundary::__get_property(__next_code_point);
+    bool __result                  = __evaluate(__next_code_point, __next_property);
+    __prev_code_point_             = __next_code_point;
+    __prev_property_               = __next_property;
+    return __result;
+  }
+
+  // The code point whose break propery are considered during the next
+  // evaluation cyle.
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr char32_t __current_code_point() const { return __prev_code_point_; }
+
+private:
+  // The naming of the identifiers matches the Unicode standard.
+  // NOLINTBEGIN(readability-identifier-naming)
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  __evaluate(char32_t __next_code_point, __EGC_property __next_property) {
+    switch (__active_rule_) {
+    case __rule::__none:
+      return __evaluate_none(__next_code_point, __next_property);
+    case __rule::__GB9c_indic_conjunct_break:
+      return __evaluate_GB9c_indic_conjunct_break(__next_code_point, __next_property);
+    case __rule::__GB11_emoji:
+      return __evaluate_GB11_emoji(__next_code_point, __next_property);
+    case __rule::__GB12_GB13_regional_indicator:
+      return __evaluate_GB12_GB13_regional_indicator(__next_code_point, __next_property);
+    }
+    __libcpp_unreachable();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __evaluate_none(char32_t __next_code_point, __EGC_property __next_property) {
+    // *** Break at the start and end of text, unless the text is empty. ***
+
+    _LIBCPP_ASSERT_INTERNAL(__prev_property_ != __EGC_property::__sot, "should be handled in the constructor"); // GB1
+    _LIBCPP_ASSERT_INTERNAL(__prev_property_ != __EGC_property::__eot, "should be handled by our caller");      // GB2
+
+    // *** Do not break between a CR and LF. Otherwise, break before and after controls. ***
+    if (__prev_property_ == __EGC_property::__CR && __next_property == __EGC_property::__LF) // GB3
+      return false;
+
+    if (__prev_property_ == __EGC_property::__Control || __prev_property_ == __EGC_property::__CR ||
+        __prev_property_ == __EGC_property::__LF) // GB4
+      return true;
+
+    if (__next_property == __EGC_property::__Control || __next_property == __EGC_property::__CR ||
+        __next_property == __EGC_property::__LF) // GB5
+      return true;
+
+    // *** Do not break Hangul syllable sequences. ***
+    if (__prev_property_ == __EGC_property::__L &&
+        (__next_property == __EGC_property::__L || __next_property == __EGC_property::__V ||
+         __next_property == __EGC_property::__LV || __next_property == __EGC_property::__LVT)) // GB6
+      return false;
+
+    if ((__prev_property_ == __EGC_property::__LV || __prev_property_ == __EGC_property::__V) &&
+        (__next_property == __EGC_property::__V || __next_property == __EGC_property::__T)) // GB7
+      return false;
+
+    if ((__prev_property_ == __EGC_property::__LVT || __prev_property_ == __EGC_property::__T) &&
+        __next_property == __EGC_property::__T) // GB8
+      return false;
+
+    // *** Do not break before extending characters or ZWJ. ***
+    if (__next_property == __EGC_property::__Extend || __next_property == __EGC_property::__ZWJ)
+      return false; // GB9
+
+    // *** Do not break before SpacingMarks, or after Prepend characters. ***
+    if (__next_property == __EGC_property::__SpacingMark) // GB9a
+      return false;
+
+    if (__prev_property_ == __EGC_property::__Prepend) // GB9b
+      return false;
+
+    // *** Do not break within certain combinations with Indic_Conjunct_Break (InCB)=Linker. ***
+    if (__indic_conjunct_break::__get_property(__next_code_point) == __inCB_property::__Consonant) {
+      __active_rule_                     = __rule::__GB9c_indic_conjunct_break;
+      __GB9c_indic_conjunct_break_state_ = __GB9c_indic_conjunct_break_state::__Consonant;
+      return true;
+    }
+
+    // *** Do not break within emoji modifier sequences or emoji zwj sequences. ***
+    if (__next_property == __EGC_property::__Extended_Pictographic) {
+      __active_rule_      = __rule::__GB11_emoji;
+      __GB11_emoji_state_ = __GB11_emoji_state::__Extended_Pictographic;
+      return true;
+    }
+
+    // *** Do not break within emoji flag sequences ***
+
+    // That is, do not break between regional indicator (RI) symbols if there
+    // is an odd number of RI characters before the break point.
+    if (__next_property == __EGC_property::__Regional_Indicator) { // GB12 + GB13
+      __active_rule_ = __rule::__GB12_GB13_regional_indicator;
+      return true;
+    }
+
+    // *** Otherwise, break everywhere. ***
+    return true; // GB999
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  __evaluate_GB9c_indic_conjunct_break(char32_t __next_code_point, __EGC_property __next_property) {
+    __inCB_property __break = __indic_conjunct_break::__get_property(__next_code_point);
+    if (__break == __inCB_property::__none) {
+      __active_rule_ = __rule::__none;
+      return __evaluate_none(__next_code_point, __next_property);
+    }
+
+    switch (__GB9c_indic_conjunct_break_state_) {
+    case __GB9c_indic_conjunct_break_state::__Consonant:
+      if (__break == __inCB_property::__Extend) {
+        return false;
+      }
+      if (__break == __inCB_property::__Linker) {
+        __GB9c_indic_conjunct_break_state_ = __GB9c_indic_conjunct_break_state::__Linker;
+        return false;
+      }
+      __active_rule_ = __rule::__none;
+      return __evaluate_none(__next_code_point, __next_property);
+
+    case __GB9c_indic_conjunct_break_state::__Linker:
+      if (__break == __inCB_property::__Extend) {
+        return false;
+      }
+      if (__break == __inCB_property::__Linker) {
+        return false;
+      }
+      if (__break == __inCB_property::__Consonant) {
+        __GB9c_indic_conjunct_break_state_ = __GB9c_indic_conjunct_break_state::__Consonant;
+        return false;
+      }
+      __active_rule_ = __rule::__none;
+      return __evaluate_none(__next_code_point, __next_property);
+    }
+    __libcpp_unreachable();
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  __evaluate_GB11_emoji(char32_t __next_code_point, __EGC_property __next_property) {
+    switch (__GB11_emoji_state_) {
+    case __GB11_emoji_state::__Extended_Pictographic:
+      if (__next_property == __EGC_property::__Extend) {
+        __GB11_emoji_state_ = __GB11_emoji_state::__Extend;
+        return false;
+      }
+      [[fallthrough]];
+    case __GB11_emoji_state::__Extend:
+      if (__next_property == __EGC_property::__ZWJ) {
+        __GB11_emoji_state_ = __GB11_emoji_state::__ZWJ;
+        return false;
+      }
+      if (__next_property == __EGC_property::__Extend)
+        return false;
+      __active_rule_ = __rule::__none;
+      return __evaluate_none(__next_code_point, __next_property);
+
+    case __GB11_emoji_state::__ZWJ:
+      if (__next_property == __EGC_property::__Extended_Pictographic) {
+        __GB11_emoji_state_ = __GB11_emoji_state::__Extended_Pictographic;
+        return false;
+      }
+      __active_rule_ = __rule::__none;
+      return __evaluate_none(__next_code_point, __next_property);
+    }
+    __libcpp_unreachable();
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool
+  __evaluate_GB12_GB13_regional_indicator(char32_t __next_code_point, __EGC_property __next_property) {
+    __active_rule_ = __rule::__none;
+    if (__next_property == __EGC_property::__Regional_Indicator)
+      return false;
+    return __evaluate_none(__next_code_point, __next_property);
+  }
+
+  char32_t __prev_code_point_;
+  __EGC_property __prev_property_;
+
+  enum class __rule {
+    __none,
+    __GB9c_indic_conjunct_break,
+    __GB11_emoji,
+    __GB12_GB13_regional_indicator,
+  };
+  __rule __active_rule_ = __rule::__none;
+
+  enum class __GB11_emoji_state {
+    __Extended_Pictographic,
+    __Extend,
+    __ZWJ,
+  };
+  __GB11_emoji_state __GB11_emoji_state_ = __GB11_emoji_state::__Extended_Pictographic;
+
+  enum class __GB9c_indic_conjunct_break_state {
+    __Consonant,
+    __Linker,
+  };
+
+  __GB9c_indic_conjunct_break_state __GB9c_indic_conjunct_break_state_ = __GB9c_indic_conjunct_break_state::__Consonant;
+
+  // NOLINTEND(readability-identifier-naming)
+};
 
 /// Helper class to extract an extended grapheme cluster from a Unicode character range.
 ///
@@ -385,9 +531,7 @@ class __extended_grapheme_cluster_view {
 
 public:
   _LIBCPP_HIDE_FROM_ABI constexpr explicit __extended_grapheme_cluster_view(_Iterator __first, _Iterator __last)
-      : __code_point_view_(__first, __last),
-        __next_code_point_(__code_point_view_.__consume().__code_point),
-        __next_prop_(__extended_grapheme_custer_property_boundary::__get_property(__next_code_point_)) {}
+      : __code_point_view_(__first, __last), __at_break_(__code_point_view_.__consume().__code_point) {}
 
   struct __cluster {
     /// The first code point of the extended grapheme cluster.
@@ -403,45 +547,20 @@ public:
     _Iterator __last_;
   };
 
-  _LIBCPP_HIDE_FROM_ABI constexpr __cluster __consume() {
-    _LIBCPP_ASSERT(
-        __next_prop_ != __extended_grapheme_custer_property_boundary::__property::__eot,
-        "can't move beyond the end of input");
-
-    char32_t __code_point = __next_code_point_;
-    if (!__code_point_view_.__at_end())
-      return {__code_point, __get_break()};
-
-    __next_prop_ = __extended_grapheme_custer_property_boundary::__property::__eot;
-    return {__code_point, __code_point_view_.__position()};
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __cluster __consume() {
+    char32_t __code_point = __at_break_.__current_code_point();
+    _Iterator __position  = __code_point_view_.__position();
+    while (!__code_point_view_.__at_end()) {
+      if (__at_break_(__code_point_view_.__consume().__code_point))
+        break;
+      __position = __code_point_view_.__position();
+    }
+    return {__code_point, __position};
   }
 
 private:
   __code_point_view<_CharT> __code_point_view_;
-
-  char32_t __next_code_point_;
-  __extended_grapheme_custer_property_boundary::__property __next_prop_;
-
-  _LIBCPP_HIDE_FROM_ABI constexpr _Iterator __get_break() {
-    bool __ri_break_allowed         = true;
-    bool __has_extened_pictographic = false;
-    while (true) {
-      _Iterator __result                                              = __code_point_view_.__position();
-      __extended_grapheme_custer_property_boundary::__property __prev = __next_prop_;
-      if (__code_point_view_.__at_end()) {
-        __next_prop_ = __extended_grapheme_custer_property_boundary::__property::__eot;
-        return __result;
-      }
-      __next_code_point_ = __code_point_view_.__consume().__code_point;
-      __next_prop_       = __extended_grapheme_custer_property_boundary::__get_property(__next_code_point_);
-
-      __has_extened_pictographic |=
-          __prev == __extended_grapheme_custer_property_boundary::__property::__Extended_Pictographic;
-
-      if (__at_extended_grapheme_cluster_break(__ri_break_allowed, __has_extened_pictographic, __prev, __next_prop_))
-        return __result;
-    }
-  }
+  __extended_grapheme_cluster_break __at_break_;
 };
 
 template <contiguous_iterator _Iterator>
@@ -463,7 +582,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI constexpr _Iterator __position() const noexcept { return __first_; }
 
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __consume_result __consume() noexcept {
-    _LIBCPP_ASSERT(__first_ != __last_, "can't move beyond the end of input");
+    _LIBCPP_ASSERT_INTERNAL(__first_ != __last_, "can't move beyond the end of input");
     return {static_cast<char32_t>(*__first_++)};
   }
 
diff --git a/third_party/libcxx/__format/width_estimation_table.h b/third_party/libcxx/__format/width_estimation_table.h
index cfb488975..11f61dea1 100644
--- a/third_party/libcxx/__format/width_estimation_table.h
+++ b/third_party/libcxx/__format/width_estimation_table.h
@@ -119,7 +119,7 @@ namespace __width_estimation_table {
 /// - bits [0, 13] The size of the range, allowing 16384 elements.
 /// - bits [14, 31] The lower bound code point of the range. The upper bound of
 ///   the range is lower bound + size.
-inline constexpr uint32_t __entries[108] = {
+_LIBCPP_HIDE_FROM_ABI inline constexpr uint32_t __entries[107] = {
     0x0440005f /* 00001100 - 0000115f [   96] */, //
     0x08c68001 /* 0000231a - 0000231b [    2] */, //
     0x08ca4001 /* 00002329 - 0000232a [    2] */, //
@@ -158,14 +158,13 @@ inline constexpr uint32_t __entries[108] = {
     0x0ba00019 /* 00002e80 - 00002e99 [   26] */, //
     0x0ba6c058 /* 00002e9b - 00002ef3 [   89] */, //
     0x0bc000d5 /* 00002f00 - 00002fd5 [  214] */, //
-    0x0bfc000b /* 00002ff0 - 00002ffb [   12] */, //
-    0x0c00003e /* 00003000 - 0000303e [   63] */, //
+    0x0bfc004e /* 00002ff0 - 0000303e [   79] */, //
     0x0c104055 /* 00003041 - 00003096 [   86] */, //
     0x0c264066 /* 00003099 - 000030ff [  103] */, //
     0x0c41402a /* 00003105 - 0000312f [   43] */, //
     0x0c4c405d /* 00003131 - 0000318e [   94] */, //
     0x0c640053 /* 00003190 - 000031e3 [   84] */, //
-    0x0c7c002e /* 000031f0 - 0000321e [   47] */, //
+    0x0c7bc02f /* 000031ef - 0000321e [   48] */, //
     0x0c880027 /* 00003220 - 00003247 [   40] */, //
     0x0c943fff /* 00003250 - 0000724f [16384] */, //
     0x1c94323c /* 00007250 - 0000a48c [12861] */, //
@@ -238,7 +237,7 @@ inline constexpr uint32_t __table_upper_bound = 0x0003fffd;
 
 /// Returns the estimated width of a Unicode code point.
 ///
-/// \pre The code point is a valid Unicode code point.
+/// \\pre The code point is a valid Unicode code point.
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int __estimated_width(const char32_t __code_point) noexcept {
   // Since __table_upper_bound contains the unshifted range do the
   // comparison without shifting.
diff --git a/third_party/libcxx/__format/write_escaped.h b/third_party/libcxx/__format/write_escaped.h
new file mode 100644
index 000000000..052ea98c3
--- /dev/null
+++ b/third_party/libcxx/__format/write_escaped.h
@@ -0,0 +1,242 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FORMAT_WRITE_ESCAPED_H
+#define _LIBCPP___FORMAT_WRITE_ESCAPED_H
+
+#include <__algorithm/ranges_copy.h>
+#include <__algorithm/ranges_for_each.h>
+#include <__charconv/to_chars_integral.h>
+#include <__charconv/to_chars_result.h>
+#include <__chrono/statically_widen.h>
+#include <__format/escaped_output_table.h>
+#include <__format/formatter_output.h>
+#include <__format/parser_std_format_spec.h>
+#include <__format/unicode.h>
+#include <__iterator/back_insert_iterator.h>
+#include <__memory/addressof.h>
+#include <__system_error/errc.h>
+#include <__type_traits/make_unsigned.h>
+#include <__utility/move.h>
+#include <string_view>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __formatter {
+
+#if _LIBCPP_STD_VER >= 20
+
+/// Writes a string using format's width estimation algorithm.
+///
+/// \note When \c _LIBCPP_HAS_NO_UNICODE is defined the function assumes the
+/// input is ASCII.
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto
+__write_string(basic_string_view<_CharT> __str,
+               output_iterator<const _CharT&> auto __out_it,
+               __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
+  if (!__specs.__has_precision())
+    return __formatter::__write_string_no_precision(__str, std::move(__out_it), __specs);
+
+  int __size = __formatter::__truncate(__str, __specs.__precision_);
+
+  return __formatter::__write(__str.begin(), __str.end(), std::move(__out_it), __specs, __size);
+}
+
+#endif // _LIBCPP_STD_VER >= 20
+#if _LIBCPP_STD_VER >= 23
+
+struct __nul_terminator {};
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI bool operator==(const _CharT* __cstr, __nul_terminator) {
+  return *__cstr == _CharT('\0');
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI void
+__write_escaped_code_unit(basic_string<_CharT>& __str, char32_t __value, const _CharT* __prefix) {
+  back_insert_iterator __out_it{__str};
+  std::ranges::copy(__prefix, __nul_terminator{}, __out_it);
+
+  char __buffer[8];
+  to_chars_result __r = std::to_chars(std::begin(__buffer), std::end(__buffer), __value, 16);
+  _LIBCPP_ASSERT_INTERNAL(__r.ec == errc(0), "Internal buffer too small");
+  std::ranges::copy(std::begin(__buffer), __r.ptr, __out_it);
+
+  __str += _CharT('}');
+}
+
+// [format.string.escaped]/2.2.1.2
+// ...
+// then the sequence \u{hex-digit-sequence} is appended to E, where
+// hex-digit-sequence is the shortest hexadecimal representation of C using
+// lower-case hexadecimal digits.
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI void __write_well_formed_escaped_code_unit(basic_string<_CharT>& __str, char32_t __value) {
+  __formatter::__write_escaped_code_unit(__str, __value, _LIBCPP_STATICALLY_WIDEN(_CharT, "\\u{"));
+}
+
+// [format.string.escaped]/2.2.3
+// Otherwise (X is a sequence of ill-formed code units), each code unit U is
+// appended to E in order as the sequence \x{hex-digit-sequence}, where
+// hex-digit-sequence is the shortest hexadecimal representation of U using
+// lower-case hexadecimal digits.
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI void __write_escape_ill_formed_code_unit(basic_string<_CharT>& __str, char32_t __value) {
+  __formatter::__write_escaped_code_unit(__str, __value, _LIBCPP_STATICALLY_WIDEN(_CharT, "\\x{"));
+}
+
+template <class _CharT>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
+__is_escaped_sequence_written(basic_string<_CharT>& __str, bool __last_escaped, char32_t __value) {
+#  ifdef _LIBCPP_HAS_NO_UNICODE
+  // For ASCII assume everything above 127 is printable.
+  if (__value > 127)
+    return false;
+#  endif
+
+  // [format.string.escaped]/2.2.1.2.1
+  //   CE is UTF-8, UTF-16, or UTF-32 and C corresponds to a Unicode scalar
+  //   value whose Unicode property General_Category has a value in the groups
+  //   Separator (Z) or Other (C), as described by UAX #44 of the Unicode Standard,
+  if (!__escaped_output_table::__needs_escape(__value))
+    // [format.string.escaped]/2.2.1.2.2
+    //   CE is UTF-8, UTF-16, or UTF-32 and C corresponds to a Unicode scalar
+    //   value with the Unicode property Grapheme_Extend=Yes as described by UAX
+    //   #44 of the Unicode Standard and C is not immediately preceded in S by a
+    //   character P appended to E without translation to an escape sequence,
+    if (!__last_escaped || __extended_grapheme_custer_property_boundary::__get_property(__value) !=
+                               __extended_grapheme_custer_property_boundary::__property::__Extend)
+      return false;
+
+  __formatter::__write_well_formed_escaped_code_unit(__str, __value);
+  return true;
+}
+
+template <class _CharT>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr char32_t __to_char32(_CharT __value) {
+  return static_cast<make_unsigned_t<_CharT>>(__value);
+}
+
+enum class __escape_quotation_mark { __apostrophe, __double_quote };
+
+// [format.string.escaped]/2
+template <class _CharT>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool __is_escaped_sequence_written(
+    basic_string<_CharT>& __str, char32_t __value, bool __last_escaped, __escape_quotation_mark __mark) {
+  // 2.2.1.1 - Mapped character in [tab:format.escape.sequences]
+  switch (__value) {
+  case _CharT('\t'):
+    __str += _LIBCPP_STATICALLY_WIDEN(_CharT, "\\t");
+    return true;
+  case _CharT('\n'):
+    __str += _LIBCPP_STATICALLY_WIDEN(_CharT, "\\n");
+    return true;
+  case _CharT('\r'):
+    __str += _LIBCPP_STATICALLY_WIDEN(_CharT, "\\r");
+    return true;
+  case _CharT('\''):
+    if (__mark == __escape_quotation_mark::__apostrophe)
+      __str += _LIBCPP_STATICALLY_WIDEN(_CharT, R"(\')");
+    else
+      __str += __value;
+    return true;
+  case _CharT('"'):
+    if (__mark == __escape_quotation_mark::__double_quote)
+      __str += _LIBCPP_STATICALLY_WIDEN(_CharT, R"(\")");
+    else
+      __str += __value;
+    return true;
+  case _CharT('\\'):
+    __str += _LIBCPP_STATICALLY_WIDEN(_CharT, R"(\\)");
+    return true;
+
+  // 2.2.1.2 - Space
+  case _CharT(' '):
+    __str += __value;
+    return true;
+  }
+
+  // 2.2.2
+  //   Otherwise, if X is a shift sequence, the effect on E and further
+  //   decoding of S is unspecified.
+  // For now shift sequences are ignored and treated as Unicode. Other parts
+  // of the format library do the same. It's unknown how ostream treats them.
+  // TODO FMT determine what to do with shift sequences.
+
+  // 2.2.1.2.1 and 2.2.1.2.2 - Escape
+  return __formatter::__is_escaped_sequence_written(__str, __last_escaped, __formatter::__to_char32(__value));
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI void
+__escape(basic_string<_CharT>& __str, basic_string_view<_CharT> __values, __escape_quotation_mark __mark) {
+  __unicode::__code_point_view<_CharT> __view{__values.begin(), __values.end()};
+
+  // When the first code unit has the property Grapheme_Extend=Yes it needs to
+  // be escaped. This happens when the previous code unit was also escaped.
+  bool __escape = true;
+  while (!__view.__at_end()) {
+    auto __first                                  = __view.__position();
+    typename __unicode::__consume_result __result = __view.__consume();
+    if (__result.__status == __unicode::__consume_result::__ok) {
+      __escape = __formatter::__is_escaped_sequence_written(__str, __result.__code_point, __escape, __mark);
+      if (!__escape)
+        // 2.2.1.3 - Add the character
+        ranges::copy(__first, __view.__position(), std::back_insert_iterator(__str));
+    } else {
+      // 2.2.3 sequence of ill-formed code units
+      ranges::for_each(__first, __view.__position(), [&](_CharT __value) {
+        __formatter::__write_escape_ill_formed_code_unit(__str, __formatter::__to_char32(__value));
+      });
+    }
+  }
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto
+__format_escaped_char(_CharT __value,
+                      output_iterator<const _CharT&> auto __out_it,
+                      __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
+  basic_string<_CharT> __str;
+  __str += _CharT('\'');
+  __formatter::__escape(__str, basic_string_view{std::addressof(__value), 1}, __escape_quotation_mark::__apostrophe);
+  __str += _CharT('\'');
+  return __formatter::__write(__str.data(), __str.data() + __str.size(), std::move(__out_it), __specs, __str.size());
+}
+
+template <class _CharT>
+_LIBCPP_HIDE_FROM_ABI auto
+__format_escaped_string(basic_string_view<_CharT> __values,
+                        output_iterator<const _CharT&> auto __out_it,
+                        __format_spec::__parsed_specifications<_CharT> __specs) -> decltype(__out_it) {
+  basic_string<_CharT> __str;
+  __str += _CharT('"');
+  __formatter::__escape(__str, __values, __escape_quotation_mark::__double_quote);
+  __str += _CharT('"');
+  return __formatter::__write_string(basic_string_view{__str}, std::move(__out_it), __specs);
+}
+
+#endif // _LIBCPP_STD_VER >= 23
+
+} // namespace __formatter
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___FORMAT_WRITE_ESCAPED_H
diff --git a/third_party/libcxx/__functional/binary_function.h b/third_party/libcxx/__functional/binary_function.h
index fdedb8b17..ddee3b170 100644
--- a/third_party/libcxx/__functional/binary_function.h
+++ b/third_party/libcxx/__functional/binary_function.h
@@ -21,20 +21,20 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
 
 template <class _Arg1, class _Arg2, class _Result>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binary_function
-{
-    typedef _Arg1   first_argument_type;
-    typedef _Arg2   second_argument_type;
-    typedef _Result result_type;
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binary_function {
+  typedef _Arg1 first_argument_type;
+  typedef _Arg2 second_argument_type;
+  typedef _Result result_type;
 };
 
 #endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
 
-template <class _Arg1, class _Arg2, class _Result> struct __binary_function_keep_layout_base {
+template <class _Arg1, class _Arg2, class _Result>
+struct __binary_function_keep_layout_base {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-  using first_argument_type _LIBCPP_DEPRECATED_IN_CXX17 = _Arg1;
+  using first_argument_type _LIBCPP_DEPRECATED_IN_CXX17  = _Arg1;
   using second_argument_type _LIBCPP_DEPRECATED_IN_CXX17 = _Arg2;
-  using result_type _LIBCPP_DEPRECATED_IN_CXX17 = _Result;
+  using result_type _LIBCPP_DEPRECATED_IN_CXX17          = _Result;
 #endif
 };
 
diff --git a/third_party/libcxx/__functional/binary_negate.h b/third_party/libcxx/__functional/binary_negate.h
index 73ecea997..ce52b5ae9 100644
--- a/third_party/libcxx/__functional/binary_negate.h
+++ b/third_party/libcxx/__functional/binary_negate.h
@@ -25,23 +25,24 @@ template <class _Predicate>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 binary_negate
     : public __binary_function<typename _Predicate::first_argument_type,
                                typename _Predicate::second_argument_type,
-                               bool>
-{
-    _Predicate __pred_;
-public:
-    _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_SINCE_CXX14
-    binary_negate(const _Predicate& __pred) : __pred_(__pred) {}
+                               bool> {
+  _Predicate __pred_;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const typename _Predicate::first_argument_type& __x,
-                    const typename _Predicate::second_argument_type& __y) const
-        {return !__pred_(__x, __y);}
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR_SINCE_CXX14 binary_negate(const _Predicate& __pred)
+      : __pred_(__pred) {}
+
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(
+      const typename _Predicate::first_argument_type& __x, const typename _Predicate::second_argument_type& __y) const {
+    return !__pred_(__x, __y);
+  }
 };
 
 template <class _Predicate>
-_LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-binary_negate<_Predicate>
-not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
+_LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI binary_negate<_Predicate>
+not2(const _Predicate& __pred) {
+  return binary_negate<_Predicate>(__pred);
+}
 
 #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS)
 
diff --git a/third_party/libcxx/__functional/bind.h b/third_party/libcxx/__functional/bind.h
index b0c9bfe78..b4f46441d 100644
--- a/third_party/libcxx/__functional/bind.h
+++ b/third_party/libcxx/__functional/bind.h
@@ -13,6 +13,7 @@
 #include <__config>
 #include <__functional/invoke.h>
 #include <__functional/weak_result_type.h>
+#include <__fwd/functional.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_reference_wrapper.h>
 #include <__type_traits/is_void.h>
@@ -25,34 +26,30 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp>
-struct is_bind_expression : _If<
-    _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
-    false_type,
-    is_bind_expression<__remove_cvref_t<_Tp> >
-> {};
+template <class _Tp>
+struct is_bind_expression
+    : _If< _IsSame<_Tp, __remove_cvref_t<_Tp> >::value, false_type, is_bind_expression<__remove_cvref_t<_Tp> > > {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_bind_expression_v = is_bind_expression<_Tp>::value;
 #endif
 
-template<class _Tp>
-struct is_placeholder : _If<
-    _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
-    integral_constant<int, 0>,
-    is_placeholder<__remove_cvref_t<_Tp> >
-> {};
+template <class _Tp>
+struct is_placeholder
+    : _If< _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
+           integral_constant<int, 0>,
+           is_placeholder<__remove_cvref_t<_Tp> > > {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr int is_placeholder_v = is_placeholder<_Tp>::value;
 #endif
 
-namespace placeholders
-{
+namespace placeholders {
 
-template <int _Np> struct __ph {};
+template <int _Np>
+struct __ph {};
 
 // C++17 recommends that we implement placeholders as `inline constexpr`, but allows
 // implementing them as `extern <implementation-defined>`. Libc++ implements them as
@@ -62,321 +59,234 @@ template <int _Np> struct __ph {};
 //
 // In practice, since placeholders are empty, `extern const` is almost impossible
 // to distinguish from `inline constexpr` from a usage stand point.
-_LIBCPP_FUNC_VIS extern const __ph<1>   _1;
-_LIBCPP_FUNC_VIS extern const __ph<2>   _2;
-_LIBCPP_FUNC_VIS extern const __ph<3>   _3;
-_LIBCPP_FUNC_VIS extern const __ph<4>   _4;
-_LIBCPP_FUNC_VIS extern const __ph<5>   _5;
-_LIBCPP_FUNC_VIS extern const __ph<6>   _6;
-_LIBCPP_FUNC_VIS extern const __ph<7>   _7;
-_LIBCPP_FUNC_VIS extern const __ph<8>   _8;
-_LIBCPP_FUNC_VIS extern const __ph<9>   _9;
-_LIBCPP_FUNC_VIS extern const __ph<10> _10;
+_LIBCPP_EXPORTED_FROM_ABI extern const __ph<1> _1;
+_LIBCPP_EXPORTED_FROM_ABI extern const __ph<2> _2;
+_LIBCPP_EXPORTED_FROM_ABI extern const __ph<3> _3;
+_LIBCPP_EXPORTED_FROM_ABI extern const __ph<4> _4;
+_LIBCPP_EXPORTED_FROM_ABI extern const __ph<5> _5;
+_LIBCPP_EXPORTED_FROM_ABI extern const __ph<6> _6;
+_LIBCPP_EXPORTED_FROM_ABI extern const __ph<7> _7;
+_LIBCPP_EXPORTED_FROM_ABI extern const __ph<8> _8;
+_LIBCPP_EXPORTED_FROM_ABI extern const __ph<9> _9;
+_LIBCPP_EXPORTED_FROM_ABI extern const __ph<10> _10;
 
 } // namespace placeholders
 
-template<int _Np>
-struct is_placeholder<placeholders::__ph<_Np> >
-    : public integral_constant<int, _Np> {};
-
+template <int _Np>
+struct is_placeholder<placeholders::__ph<_Np> > : public integral_constant<int, _Np> {};
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Uj>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_Tp&
-__mu(reference_wrapper<_Tp> __t, _Uj&)
-{
-    return __t.get();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& __mu(reference_wrapper<_Tp> __t, _Uj&) {
+  return __t.get();
 }
 
-template <class _Ti, class ..._Uj, size_t ..._Indx>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename __invoke_of<_Ti&, _Uj...>::type
-__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
-{
-    return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...);
+template <class _Ti, class... _Uj, size_t... _Indx>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __invoke_of<_Ti&, _Uj...>::type
+__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>) {
+  return __ti(std::forward<_Uj>(std::get<_Indx>(__uj))...);
 }
 
-template <class _Ti, class ..._Uj>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename __enable_if_t
-<
-    is_bind_expression<_Ti>::value,
-    __invoke_of<_Ti&, _Uj...>
->::type
-__mu(_Ti& __ti, tuple<_Uj...>& __uj)
-{
-    typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
-    return _VSTD::__mu_expand(__ti, __uj, __indices());
+template <class _Ti, class... _Uj, __enable_if_t<is_bind_expression<_Ti>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __invoke_of<_Ti&, _Uj...>::type
+__mu(_Ti& __ti, tuple<_Uj...>& __uj) {
+  typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
+  return std::__mu_expand(__ti, __uj, __indices());
 }
 
-template <bool IsPh, class _Ti, class _Uj>
+template <bool _IsPh, class _Ti, class _Uj>
 struct __mu_return2 {};
 
 template <class _Ti, class _Uj>
-struct __mu_return2<true, _Ti, _Uj>
-{
-    typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
+struct __mu_return2<true, _Ti, _Uj> {
+  typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
 };
 
-template <class _Ti, class _Uj>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    0 < is_placeholder<_Ti>::value,
-    typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
->::type
-__mu(_Ti&, _Uj& __uj)
-{
-    const size_t __indx = is_placeholder<_Ti>::value - 1;
-    return _VSTD::forward<typename tuple_element<__indx, _Uj>::type>(_VSTD::get<__indx>(__uj));
+template <class _Ti, class _Uj, __enable_if_t<0 < is_placeholder<_Ti>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
+__mu(_Ti&, _Uj& __uj) {
+  const size_t __indx = is_placeholder<_Ti>::value - 1;
+  return std::forward<typename tuple_element<__indx, _Uj>::type>(std::get<__indx>(__uj));
 }
 
-template <class _Ti, class _Uj>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    !is_bind_expression<_Ti>::value &&
-    is_placeholder<_Ti>::value == 0 &&
-    !__is_reference_wrapper<_Ti>::value,
-    _Ti&
->::type
-__mu(_Ti& __ti, _Uj&)
-{
-    return __ti;
+template <class _Ti,
+          class _Uj,
+          __enable_if_t<!is_bind_expression<_Ti>::value && is_placeholder<_Ti>::value == 0 &&
+                            !__is_reference_wrapper<_Ti>::value,
+                        int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Ti& __mu(_Ti& __ti, _Uj&) {
+  return __ti;
 }
 
-template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
-          class _TupleUj>
+template <class _Ti, bool _IsReferenceWrapper, bool _IsBindEx, bool _IsPh, class _TupleUj>
 struct __mu_return_impl;
 
-template <bool _Invokable, class _Ti, class ..._Uj>
-struct __mu_return_invokable  // false
+template <bool _Invokable, class _Ti, class... _Uj>
+struct __mu_return_invokable // false
 {
-    typedef __nat type;
+  typedef __nat type;
 };
 
-template <class _Ti, class ..._Uj>
-struct __mu_return_invokable<true, _Ti, _Uj...>
-{
-    typedef typename __invoke_of<_Ti&, _Uj...>::type type;
+template <class _Ti, class... _Uj>
+struct __mu_return_invokable<true, _Ti, _Uj...> {
+  typedef typename __invoke_of<_Ti&, _Uj...>::type type;
 };
 
-template <class _Ti, class ..._Uj>
+template <class _Ti, class... _Uj>
 struct __mu_return_impl<_Ti, false, true, false, tuple<_Uj...> >
-    : public __mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...>
-{
+    : public __mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...> {};
+
+template <class _Ti, class _TupleUj>
+struct __mu_return_impl<_Ti, false, false, true, _TupleUj> {
+  typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _TupleUj>::type&& type;
 };
 
 template <class _Ti, class _TupleUj>
-struct __mu_return_impl<_Ti, false, false, true, _TupleUj>
-{
-    typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
-                                   _TupleUj>::type&& type;
+struct __mu_return_impl<_Ti, true, false, false, _TupleUj> {
+  typedef typename _Ti::type& type;
 };
 
 template <class _Ti, class _TupleUj>
-struct __mu_return_impl<_Ti, true, false, false, _TupleUj>
-{
-    typedef typename _Ti::type& type;
-};
-
-template <class _Ti, class _TupleUj>
-struct __mu_return_impl<_Ti, false, false, false, _TupleUj>
-{
-    typedef _Ti& type;
+struct __mu_return_impl<_Ti, false, false, false, _TupleUj> {
+  typedef _Ti& type;
 };
 
 template <class _Ti, class _TupleUj>
 struct __mu_return
-    : public __mu_return_impl<_Ti,
-                              __is_reference_wrapper<_Ti>::value,
-                              is_bind_expression<_Ti>::value,
-                              0 < is_placeholder<_Ti>::value &&
-                              is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
-                              _TupleUj>
-{
-};
+    : public __mu_return_impl<
+          _Ti,
+          __is_reference_wrapper<_Ti>::value,
+          is_bind_expression<_Ti>::value,
+          0 < is_placeholder<_Ti>::value && is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
+          _TupleUj> {};
 
 template <class _Fp, class _BoundArgs, class _TupleUj>
-struct __is_valid_bind_return
-{
-    static const bool value = false;
+struct __is_valid_bind_return {
+  static const bool value = false;
 };
 
-template <class _Fp, class ..._BoundArgs, class _TupleUj>
-struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
-{
-    static const bool value = __invokable<_Fp,
-                    typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
+template <class _Fp, class... _BoundArgs, class _TupleUj>
+struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> {
+  static const bool value = __invokable<_Fp, typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
 };
 
-template <class _Fp, class ..._BoundArgs, class _TupleUj>
-struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
-{
-    static const bool value = __invokable<_Fp,
-                    typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
+template <class _Fp, class... _BoundArgs, class _TupleUj>
+struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> {
+  static const bool value = __invokable<_Fp, typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
 };
 
-template <class _Fp, class _BoundArgs, class _TupleUj,
-          bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
+template <class _Fp, class _BoundArgs, class _TupleUj, bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
 struct __bind_return;
 
-template <class _Fp, class ..._BoundArgs, class _TupleUj>
-struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>
-{
-    typedef typename __invoke_of
-    <
-        _Fp&,
-        typename __mu_return
-        <
-            _BoundArgs,
-            _TupleUj
-        >::type...
-    >::type type;
+template <class _Fp, class... _BoundArgs, class _TupleUj>
+struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true> {
+  typedef typename __invoke_of< _Fp&, typename __mu_return< _BoundArgs, _TupleUj >::type... >::type type;
 };
 
-template <class _Fp, class ..._BoundArgs, class _TupleUj>
-struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>
-{
-    typedef typename __invoke_of
-    <
-        _Fp&,
-        typename __mu_return
-        <
-            const _BoundArgs,
-            _TupleUj
-        >::type...
-    >::type type;
+template <class _Fp, class... _BoundArgs, class _TupleUj>
+struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true> {
+  typedef typename __invoke_of< _Fp&, typename __mu_return< const _BoundArgs, _TupleUj >::type... >::type type;
 };
 
-template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename __bind_return<_Fp, _BoundArgs, _Args>::type
-__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
-                _Args&& __args)
-{
-    return _VSTD::__invoke(__f, _VSTD::__mu(_VSTD::get<_Indx>(__bound_args), __args)...);
+template <class _Fp, class _BoundArgs, size_t... _Indx, class _Args>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __bind_return<_Fp, _BoundArgs, _Args>::type
+__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, _Args&& __args) {
+  return std::__invoke(__f, std::__mu(std::get<_Indx>(__bound_args), __args)...);
 }
 
-template<class _Fp, class ..._BoundArgs>
-class __bind : public __weak_result_type<__decay_t<_Fp> >
-{
+template <class _Fp, class... _BoundArgs>
+class __bind : public __weak_result_type<__decay_t<_Fp> > {
 protected:
-    using _Fd = __decay_t<_Fp>;
-    typedef tuple<__decay_t<_BoundArgs>...> _Td;
+  using _Fd = __decay_t<_Fp>;
+  typedef tuple<__decay_t<_BoundArgs>...> _Td;
+
 private:
-    _Fd __f_;
-    _Td __bound_args_;
+  _Fd __f_;
+  _Td __bound_args_;
+
+  typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
 
-    typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
 public:
-    template <class _Gp, class ..._BA,
-              class = typename enable_if
-                               <
-                                  is_constructible<_Fd, _Gp>::value &&
-                                  !is_same<__libcpp_remove_reference_t<_Gp>,
-                                           __bind>::value
-                               >::type>
-      _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-      explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
-        : __f_(_VSTD::forward<_Gp>(__f)),
-          __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
+  template <
+      class _Gp,
+      class... _BA,
+      __enable_if_t<is_constructible<_Fd, _Gp>::value && !is_same<__libcpp_remove_reference_t<_Gp>, __bind>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __bind(_Gp&& __f, _BA&&... __bound_args)
+      : __f_(std::forward<_Gp>(__f)), __bound_args_(std::forward<_BA>(__bound_args)...) {}
 
-    template <class ..._Args>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-        typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
-        operator()(_Args&& ...__args)
-        {
-            return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
-                                  tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
-        }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
+  operator()(_Args&&... __args) {
+    return std::__apply_functor(__f_, __bound_args_, __indices(), tuple<_Args&&...>(std::forward<_Args>(__args)...));
+  }
 
-    template <class ..._Args>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-        typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
-        operator()(_Args&& ...__args) const
-        {
-            return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
-                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
-        }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
+  operator()(_Args&&... __args) const {
+    return std::__apply_functor(__f_, __bound_args_, __indices(), tuple<_Args&&...>(std::forward<_Args>(__args)...));
+  }
 };
 
-template<class _Fp, class ..._BoundArgs>
+template <class _Fp, class... _BoundArgs>
 struct is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};
 
-template<class _Rp, class _Fp, class ..._BoundArgs>
-class __bind_r
-    : public __bind<_Fp, _BoundArgs...>
-{
-    typedef __bind<_Fp, _BoundArgs...> base;
-    typedef typename base::_Fd _Fd;
-    typedef typename base::_Td _Td;
+template <class _Rp, class _Fp, class... _BoundArgs>
+class __bind_r : public __bind<_Fp, _BoundArgs...> {
+  typedef __bind<_Fp, _BoundArgs...> base;
+  typedef typename base::_Fd _Fd;
+  typedef typename base::_Td _Td;
+
 public:
-    typedef _Rp result_type;
+  typedef _Rp result_type;
 
+  template <
+      class _Gp,
+      class... _BA,
+      __enable_if_t<is_constructible<_Fd, _Gp>::value && !is_same<__libcpp_remove_reference_t<_Gp>, __bind_r>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit __bind_r(_Gp&& __f, _BA&&... __bound_args)
+      : base(std::forward<_Gp>(__f), std::forward<_BA>(__bound_args)...) {}
 
-    template <class _Gp, class ..._BA,
-              class = typename enable_if
-                               <
-                                  is_constructible<_Fd, _Gp>::value &&
-                                  !is_same<__libcpp_remove_reference_t<_Gp>,
-                                           __bind_r>::value
-                               >::type>
-      _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-      explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
-        : base(_VSTD::forward<_Gp>(__f),
-               _VSTD::forward<_BA>(__bound_args)...) {}
+  template <
+      class... _Args,
+      __enable_if_t<is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type, result_type>::value ||
+                        is_void<_Rp>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 result_type operator()(_Args&&... __args) {
+    typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+    return _Invoker::__call(static_cast<base&>(*this), std::forward<_Args>(__args)...);
+  }
 
-    template <class ..._Args>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-        typename enable_if
-        <
-            is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
-                           result_type>::value || is_void<_Rp>::value,
-            result_type
-        >::type
-        operator()(_Args&& ...__args)
-        {
-            typedef __invoke_void_return_wrapper<_Rp> _Invoker;
-            return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
-        }
-
-    template <class ..._Args>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-        typename enable_if
-        <
-            is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
-                           result_type>::value || is_void<_Rp>::value,
-            result_type
-        >::type
-        operator()(_Args&& ...__args) const
-        {
-            typedef __invoke_void_return_wrapper<_Rp> _Invoker;
-            return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
-        }
+  template <class... _Args,
+            __enable_if_t<is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
+                                         result_type>::value ||
+                              is_void<_Rp>::value,
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 result_type operator()(_Args&&... __args) const {
+    typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+    return _Invoker::__call(static_cast<base const&>(*this), std::forward<_Args>(__args)...);
+  }
 };
 
-template<class _Rp, class _Fp, class ..._BoundArgs>
+template <class _Rp, class _Fp, class... _BoundArgs>
 struct is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
 
-template<class _Fp, class ..._BoundArgs>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-__bind<_Fp, _BoundArgs...>
-bind(_Fp&& __f, _BoundArgs&&... __bound_args)
-{
-    typedef __bind<_Fp, _BoundArgs...> type;
-    return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
+template <class _Fp, class... _BoundArgs>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bind<_Fp, _BoundArgs...>
+bind(_Fp&& __f, _BoundArgs&&... __bound_args) {
+  typedef __bind<_Fp, _BoundArgs...> type;
+  return type(std::forward<_Fp>(__f), std::forward<_BoundArgs>(__bound_args)...);
 }
 
-template<class _Rp, class _Fp, class ..._BoundArgs>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-__bind_r<_Rp, _Fp, _BoundArgs...>
-bind(_Fp&& __f, _BoundArgs&&... __bound_args)
-{
-    typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
-    return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
+template <class _Rp, class _Fp, class... _BoundArgs>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bind_r<_Rp, _Fp, _BoundArgs...>
+bind(_Fp&& __f, _BoundArgs&&... __bound_args) {
+  typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
+  return type(std::forward<_Fp>(__f), std::forward<_BoundArgs>(__bound_args)...);
 }
 
 #endif // _LIBCPP_CXX03_LANG
diff --git a/third_party/libcxx/__functional/bind_back.h b/third_party/libcxx/__functional/bind_back.h
index 71dc63c86..e44768d22 100644
--- a/third_party/libcxx/__functional/bind_back.h
+++ b/third_party/libcxx/__functional/bind_back.h
@@ -29,33 +29,52 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <size_t _NBound, class = make_index_sequence<_NBound>>
 struct __bind_back_op;
 
-template <size_t _NBound, size_t ..._Ip>
+template <size_t _NBound, size_t... _Ip>
 struct __bind_back_op<_NBound, index_sequence<_Ip...>> {
-    template <class _Fn, class _BoundArgs, class... _Args>
-    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&& __f, _BoundArgs&& __bound_args, _Args&&... __args) const
-        noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)..., _VSTD::get<_Ip>(_VSTD::forward<_BoundArgs>(__bound_args))...)))
-        -> decltype(      _VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)..., _VSTD::get<_Ip>(_VSTD::forward<_BoundArgs>(__bound_args))...))
-        { return          _VSTD::invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)..., _VSTD::get<_Ip>(_VSTD::forward<_BoundArgs>(__bound_args))...); }
+  template <class _Fn, class _BoundArgs, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&& __f, _BoundArgs&& __bound_args, _Args&&... __args) const
+      noexcept(noexcept(std::invoke(std::forward<_Fn>(__f),
+                                    std::forward<_Args>(__args)...,
+                                    std::get<_Ip>(std::forward<_BoundArgs>(__bound_args))...)))
+          -> decltype(std::invoke(std::forward<_Fn>(__f),
+                                  std::forward<_Args>(__args)...,
+                                  std::get<_Ip>(std::forward<_BoundArgs>(__bound_args))...)) {
+    return std::invoke(std::forward<_Fn>(__f),
+                       std::forward<_Args>(__args)...,
+                       std::get<_Ip>(std::forward<_BoundArgs>(__bound_args))...);
+  }
 };
 
 template <class _Fn, class _BoundArgs>
 struct __bind_back_t : __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs> {
-    using __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs>::__perfect_forward;
+  using __perfect_forward<__bind_back_op<tuple_size_v<_BoundArgs>>, _Fn, _BoundArgs>::__perfect_forward;
 };
 
-template <class _Fn, class ..._Args, class = enable_if_t<
-    _And<
-        is_constructible<decay_t<_Fn>, _Fn>,
-        is_move_constructible<decay_t<_Fn>>,
-        is_constructible<decay_t<_Args>, _Args>...,
-        is_move_constructible<decay_t<_Args>>...
-    >::value
->>
-_LIBCPP_HIDE_FROM_ABI
-constexpr auto __bind_back(_Fn&& __f, _Args&&... __args)
-    noexcept(noexcept(__bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...))))
-    -> decltype(      __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)))
-    { return          __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(_VSTD::forward<_Fn>(__f), _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)); }
+template <class _Fn, class... _Args>
+  requires is_constructible_v<decay_t<_Fn>, _Fn> && is_move_constructible_v<decay_t<_Fn>> &&
+               (is_constructible_v<decay_t<_Args>, _Args> && ...) && (is_move_constructible_v<decay_t<_Args>> && ...)
+_LIBCPP_HIDE_FROM_ABI constexpr auto __bind_back(_Fn&& __f, _Args&&... __args) noexcept(
+    noexcept(__bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(
+        std::forward<_Fn>(__f), std::forward_as_tuple(std::forward<_Args>(__args)...))))
+    -> decltype(__bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(
+        std::forward<_Fn>(__f), std::forward_as_tuple(std::forward<_Args>(__args)...))) {
+  return __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(
+      std::forward<_Fn>(__f), std::forward_as_tuple(std::forward<_Args>(__args)...));
+}
+
+#  if _LIBCPP_STD_VER >= 23
+template <class _Fn, class... _Args>
+_LIBCPP_HIDE_FROM_ABI constexpr auto bind_back(_Fn&& __f, _Args&&... __args) {
+  static_assert(is_constructible_v<decay_t<_Fn>, _Fn>, "bind_back requires decay_t<F> to be constructible from F");
+  static_assert(is_move_constructible_v<decay_t<_Fn>>, "bind_back requires decay_t<F> to be move constructible");
+  static_assert((is_constructible_v<decay_t<_Args>, _Args> && ...),
+                "bind_back requires all decay_t<Args> to be constructible from respective Args");
+  static_assert((is_move_constructible_v<decay_t<_Args>> && ...),
+                "bind_back requires all decay_t<Args> to be move constructible");
+  return __bind_back_t<decay_t<_Fn>, tuple<decay_t<_Args>...>>(
+      std::forward<_Fn>(__f), std::forward_as_tuple(std::forward<_Args>(__args)...));
+}
+#  endif // _LIBCPP_STD_VER >= 23
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__functional/bind_front.h b/third_party/libcxx/__functional/bind_front.h
index 72bb66480..87ef3affe 100644
--- a/third_party/libcxx/__functional/bind_front.h
+++ b/third_party/libcxx/__functional/bind_front.h
@@ -17,7 +17,6 @@
 #include <__type_traits/decay.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_constructible.h>
-#include <__type_traits/is_move_constructible.h>
 #include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -29,30 +28,23 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 struct __bind_front_op {
-    template <class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Args&& ...__args) const
-        noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Args>(__args)...)))
-        -> decltype(      _VSTD::invoke(_VSTD::forward<_Args>(__args)...))
-        { return          _VSTD::invoke(_VSTD::forward<_Args>(__args)...); }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const noexcept(
+      noexcept(std::invoke(std::forward<_Args>(__args)...))) -> decltype(std::invoke(std::forward<_Args>(__args)...)) {
+    return std::invoke(std::forward<_Args>(__args)...);
+  }
 };
 
-template <class _Fn, class ..._BoundArgs>
+template <class _Fn, class... _BoundArgs>
 struct __bind_front_t : __perfect_forward<__bind_front_op, _Fn, _BoundArgs...> {
-    using __perfect_forward<__bind_front_op, _Fn, _BoundArgs...>::__perfect_forward;
+  using __perfect_forward<__bind_front_op, _Fn, _BoundArgs...>::__perfect_forward;
 };
 
-template <class _Fn, class... _Args, class = enable_if_t<
-    _And<
-        is_constructible<decay_t<_Fn>, _Fn>,
-        is_move_constructible<decay_t<_Fn>>,
-        is_constructible<decay_t<_Args>, _Args>...,
-        is_move_constructible<decay_t<_Args>>...
-    >::value
->>
-_LIBCPP_HIDE_FROM_ABI
-constexpr auto bind_front(_Fn&& __f, _Args&&... __args) {
-    return __bind_front_t<decay_t<_Fn>, decay_t<_Args>...>(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
+template <class _Fn, class... _Args>
+  requires is_constructible_v<decay_t<_Fn>, _Fn> && is_move_constructible_v<decay_t<_Fn>> &&
+           (is_constructible_v<decay_t<_Args>, _Args> && ...) && (is_move_constructible_v<decay_t<_Args>> && ...)
+_LIBCPP_HIDE_FROM_ABI constexpr auto bind_front(_Fn&& __f, _Args&&... __args) {
+  return __bind_front_t<decay_t<_Fn>, decay_t<_Args>...>(std::forward<_Fn>(__f), std::forward<_Args>(__args)...);
 }
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__functional/binder1st.h b/third_party/libcxx/__functional/binder1st.h
index dea22c70e..04b51fefa 100644
--- a/third_party/libcxx/__functional/binder1st.h
+++ b/third_party/libcxx/__functional/binder1st.h
@@ -21,30 +21,31 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
-template <class __Operation>
+template <class _Operation>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder1st
-    : public __unary_function<typename __Operation::second_argument_type, typename __Operation::result_type>
-{
+    : public __unary_function<typename _Operation::second_argument_type, typename _Operation::result_type> {
 protected:
-    __Operation                               op;
-    typename __Operation::first_argument_type value;
+  _Operation op;
+  typename _Operation::first_argument_type value;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
-                               const typename __Operation::first_argument_type __y)
-        : op(__x), value(__y) {}
-    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
-        (typename __Operation::second_argument_type& __x) const
-            {return op(value, __x);}
-    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
-        (const typename __Operation::second_argument_type& __x) const
-            {return op(value, __x);}
+  _LIBCPP_HIDE_FROM_ABI binder1st(const _Operation& __x, const typename _Operation::first_argument_type __y)
+      : op(__x), value(__y) {}
+  _LIBCPP_HIDE_FROM_ABI typename _Operation::result_type
+  operator()(typename _Operation::second_argument_type& __x) const {
+    return op(value, __x);
+  }
+  _LIBCPP_HIDE_FROM_ABI typename _Operation::result_type
+  operator()(const typename _Operation::second_argument_type& __x) const {
+    return op(value, __x);
+  }
 };
 
-template <class __Operation, class _Tp>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-binder1st<__Operation>
-bind1st(const __Operation& __op, const _Tp& __x)
-    {return binder1st<__Operation>(__op, __x);}
+template <class _Operation, class _Tp>
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI binder1st<_Operation>
+bind1st(const _Operation& __op, const _Tp& __x) {
+  return binder1st<_Operation>(__op, __x);
+}
 
 #endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
diff --git a/third_party/libcxx/__functional/binder2nd.h b/third_party/libcxx/__functional/binder2nd.h
index c98a146b6..9d22e4430 100644
--- a/third_party/libcxx/__functional/binder2nd.h
+++ b/third_party/libcxx/__functional/binder2nd.h
@@ -21,30 +21,31 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
-template <class __Operation>
+template <class _Operation>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder2nd
-    : public __unary_function<typename __Operation::first_argument_type, typename __Operation::result_type>
-{
+    : public __unary_function<typename _Operation::first_argument_type, typename _Operation::result_type> {
 protected:
-    __Operation                                op;
-    typename __Operation::second_argument_type value;
+  _Operation op;
+  typename _Operation::second_argument_type value;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
-        : op(__x), value(__y) {}
-    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
-        (      typename __Operation::first_argument_type& __x) const
-            {return op(__x, value);}
-    _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
-        (const typename __Operation::first_argument_type& __x) const
-            {return op(__x, value);}
+  _LIBCPP_HIDE_FROM_ABI binder2nd(const _Operation& __x, const typename _Operation::second_argument_type __y)
+      : op(__x), value(__y) {}
+  _LIBCPP_HIDE_FROM_ABI typename _Operation::result_type
+  operator()(typename _Operation::first_argument_type& __x) const {
+    return op(__x, value);
+  }
+  _LIBCPP_HIDE_FROM_ABI typename _Operation::result_type
+  operator()(const typename _Operation::first_argument_type& __x) const {
+    return op(__x, value);
+  }
 };
 
-template <class __Operation, class _Tp>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-binder2nd<__Operation>
-bind2nd(const __Operation& __op, const _Tp& __x)
-    {return binder2nd<__Operation>(__op, __x);}
+template <class _Operation, class _Tp>
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI binder2nd<_Operation>
+bind2nd(const _Operation& __op, const _Tp& __x) {
+  return binder2nd<_Operation>(__op, __x);
+}
 
 #endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
diff --git a/third_party/libcxx/__functional/boyer_moore_searcher.h b/third_party/libcxx/__functional/boyer_moore_searcher.h
index d9d662714..648b60c50 100644
--- a/third_party/libcxx/__functional/boyer_moore_searcher.h
+++ b/third_party/libcxx/__functional/boyer_moore_searcher.h
@@ -9,6 +9,10 @@
 #ifndef _LIBCPP___FUNCTIONAL_BOYER_MOORE_SEARCHER_H
 #define _LIBCPP___FUNCTIONAL_BOYER_MOORE_SEARCHER_H
 
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
 #include <__algorithm/fill_n.h>
 #include <__config>
 #include <__functional/hash.h>
@@ -25,39 +29,29 @@
 #if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_PUSH_MACROS
-#include <__undef_macros>
+#  include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Key,
-          class _Value,
-          class _Hash,
-          class _BinaryPredicate,
-          bool /*useArray*/>
+template <class _Key, class _Value, class _Hash, class _BinaryPredicate, bool /*useArray*/>
 class _BMSkipTable;
 
 // General case for BM data searching; use a map
-template <class _Key,
-          class _Value,
-          class _Hash,
-          class _BinaryPredicate>
+template <class _Key, class _Value, class _Hash, class _BinaryPredicate>
 class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, false> {
 private:
   using value_type = _Value;
-  using key_type = _Key;
+  using key_type   = _Key;
 
   const value_type __default_value_;
   unordered_map<_Key, _Value, _Hash, _BinaryPredicate> __table_;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  explicit _BMSkipTable(size_t __sz, value_type __default_value, _Hash __hash, _BinaryPredicate __pred)
-      : __default_value_(__default_value),
-        __table_(__sz, __hash, __pred) {}
+  _LIBCPP_HIDE_FROM_ABI explicit _BMSkipTable(
+      size_t __sz, value_type __default_value, _Hash __hash, _BinaryPredicate __pred)
+      : __default_value_(__default_value), __table_(__sz, __hash, __pred) {}
 
-  _LIBCPP_HIDE_FROM_ABI void insert(const key_type& __key, value_type __val) {
-    __table_[__key] = __val;
-  }
+  _LIBCPP_HIDE_FROM_ABI void insert(const key_type& __key, value_type __val) { __table_[__key] = __val; }
 
   _LIBCPP_HIDE_FROM_ABI value_type operator[](const key_type& __key) const {
     auto __it = __table_.find(__key);
@@ -66,14 +60,11 @@ public:
 };
 
 // Special case small numeric values; use an array
-template <class _Key,
-          class _Value,
-          class _Hash,
-          class _BinaryPredicate>
+template <class _Key, class _Value, class _Hash, class _BinaryPredicate>
 class _BMSkipTable<_Key, _Value, _Hash, _BinaryPredicate, true> {
 private:
   using value_type = _Value;
-  using key_type = _Key;
+  using key_type   = _Key;
 
   using unsigned_key_type = make_unsigned_t<key_type>;
   std::array<value_type, 256> __table_;
@@ -94,34 +85,33 @@ public:
 };
 
 template <class _RandomAccessIterator1,
-          class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
+          class _Hash            = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
           class _BinaryPredicate = equal_to<>>
 class _LIBCPP_TEMPLATE_VIS boyer_moore_searcher {
 private:
   using difference_type = typename std::iterator_traits<_RandomAccessIterator1>::difference_type;
-  using value_type = typename std::iterator_traits<_RandomAccessIterator1>::value_type;
-  using __skip_table_type = _BMSkipTable<value_type,
-                                         difference_type,
-                                         _Hash,
-                                         _BinaryPredicate,
-                                         is_integral_v<value_type>
-                                      && sizeof(value_type) == 1
-                                      && is_same_v<_Hash, hash<value_type>>
-                                      && is_same_v<_BinaryPredicate, equal_to<>>>;
+  using value_type      = typename std::iterator_traits<_RandomAccessIterator1>::value_type;
+  using __skip_table_type =
+      _BMSkipTable<value_type,
+                   difference_type,
+                   _Hash,
+                   _BinaryPredicate,
+                   is_integral_v<value_type> && sizeof(value_type) == 1 && is_same_v<_Hash, hash<value_type>> &&
+                       is_same_v<_BinaryPredicate, equal_to<>>>;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  boyer_moore_searcher(_RandomAccessIterator1 __first,
-                       _RandomAccessIterator1 __last,
-                       _Hash __hash = _Hash(),
-                       _BinaryPredicate __pred = _BinaryPredicate())
-    : __first_(__first),
-      __last_(__last),
-      __pred_(__pred),
-      __pattern_length_(__last - __first),
-      __skip_table_(std::make_shared<__skip_table_type>(__pattern_length_, -1, __hash, __pred_)),
-      __suffix_(std::__allocate_shared_unbounded_array<difference_type[]>(
-          allocator<difference_type>(), __pattern_length_ + 1)) {
+  _LIBCPP_HIDE_FROM_ABI boyer_moore_searcher(
+      _RandomAccessIterator1 __first,
+      _RandomAccessIterator1 __last,
+      _Hash __hash            = _Hash(),
+      _BinaryPredicate __pred = _BinaryPredicate())
+      : __first_(__first),
+        __last_(__last),
+        __pred_(__pred),
+        __pattern_length_(__last - __first),
+        __skip_table_(std::make_shared<__skip_table_type>(__pattern_length_, -1, __hash, __pred_)),
+        __suffix_(std::__allocate_shared_unbounded_array<difference_type[]>(
+            allocator<difference_type>(), __pattern_length_ + 1)) {
     difference_type __i = 0;
     while (__first != __last) {
       __skip_table_->insert(*__first, __i);
@@ -158,8 +148,8 @@ private:
   template <class _RandomAccessIterator2>
   _LIBCPP_HIDE_FROM_ABI pair<_RandomAccessIterator2, _RandomAccessIterator2>
   __search(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const {
-    _RandomAccessIterator2 __current = __f;
-    const _RandomAccessIterator2 __last = __l - __pattern_length_;
+    _RandomAccessIterator2 __current      = __f;
+    const _RandomAccessIterator2 __last   = __l - __pattern_length_;
     const __skip_table_type& __skip_table = *__skip_table_;
 
     while (__current <= __last) {
@@ -186,7 +176,7 @@ private:
     const size_t __count = __last - __first;
 
     __prefix[0] = 0;
-    size_t __k = 0;
+    size_t __k  = 0;
 
     for (size_t __i = 1; __i != __count; ++__i) {
       while (__k > 0 && !__pred(__first[__k], __first[__i]))
@@ -215,7 +205,7 @@ private:
     __compute_bm_prefix(_ReverseIter(__last), _ReverseIter(__first), __pred, __scratch);
 
     for (size_t __i = 0; __i != __count; ++__i) {
-      const size_t __j = __count - __scratch[__i];
+      const size_t __j          = __count - __scratch[__i];
       const difference_type __k = __i - __scratch[__i] + 1;
 
       if (__suffix_[__j] > __k)
@@ -226,31 +216,31 @@ private:
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(boyer_moore_searcher);
 
 template <class _RandomAccessIterator1,
-          class _Hash = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
+          class _Hash            = hash<typename iterator_traits<_RandomAccessIterator1>::value_type>,
           class _BinaryPredicate = equal_to<>>
 class _LIBCPP_TEMPLATE_VIS boyer_moore_horspool_searcher {
 private:
   using difference_type = typename iterator_traits<_RandomAccessIterator1>::difference_type;
-  using value_type = typename iterator_traits<_RandomAccessIterator1>::value_type;
-  using __skip_table_type = _BMSkipTable<value_type,
-                                         difference_type,
-                                         _Hash,
-                                         _BinaryPredicate,
-                                         is_integral_v<value_type>
-                                      && sizeof(value_type) == 1
-                                      && is_same_v<_Hash, hash<value_type>>
-                                      && is_same_v<_BinaryPredicate, equal_to<>>>;
+  using value_type      = typename iterator_traits<_RandomAccessIterator1>::value_type;
+  using __skip_table_type =
+      _BMSkipTable<value_type,
+                   difference_type,
+                   _Hash,
+                   _BinaryPredicate,
+                   is_integral_v<value_type> && sizeof(value_type) == 1 && is_same_v<_Hash, hash<value_type>> &&
+                       is_same_v<_BinaryPredicate, equal_to<>>>;
+
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  boyer_moore_horspool_searcher(_RandomAccessIterator1 __first,
-                                _RandomAccessIterator1 __last,
-                                _Hash __hash = _Hash(),
-                                _BinaryPredicate __pred = _BinaryPredicate())
-    : __first_(__first),
-      __last_(__last),
-      __pred_(__pred),
-      __pattern_length_(__last - __first),
-      __skip_table_(std::make_shared<__skip_table_type>(__pattern_length_, __pattern_length_, __hash, __pred_)) {
+  _LIBCPP_HIDE_FROM_ABI boyer_moore_horspool_searcher(
+      _RandomAccessIterator1 __first,
+      _RandomAccessIterator1 __last,
+      _Hash __hash            = _Hash(),
+      _BinaryPredicate __pred = _BinaryPredicate())
+      : __first_(__first),
+        __last_(__last),
+        __pred_(__pred),
+        __pattern_length_(__last - __first),
+        __skip_table_(std::make_shared<__skip_table_type>(__pattern_length_, __pattern_length_, __hash, __pred_)) {
     if (__first == __last)
       return;
     --__last;
@@ -289,8 +279,8 @@ private:
   template <class _RandomAccessIterator2>
   _LIBCPP_HIDE_FROM_ABI pair<_RandomAccessIterator2, _RandomAccessIterator2>
   __search(_RandomAccessIterator2 __f, _RandomAccessIterator2 __l) const {
-    _RandomAccessIterator2 __current = __f;
-    const _RandomAccessIterator2 __last = __l - __pattern_length_;
+    _RandomAccessIterator2 __current      = __f;
+    const _RandomAccessIterator2 __last   = __l - __pattern_length_;
     const __skip_table_type& __skip_table = *__skip_table_;
 
     while (__current <= __last) {
diff --git a/third_party/libcxx/__functional/compose.h b/third_party/libcxx/__functional/compose.h
index 80fcd7076..4b86dd37c 100644
--- a/third_party/libcxx/__functional/compose.h
+++ b/third_party/libcxx/__functional/compose.h
@@ -25,25 +25,26 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 struct __compose_op {
-    template<class _Fn1, class _Fn2, class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Fn1&& __f1, _Fn2&& __f2, _Args&&... __args) const
-        noexcept(noexcept(_VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...))))
-        -> decltype(      _VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...)))
-        { return          _VSTD::invoke(_VSTD::forward<_Fn1>(__f1), _VSTD::invoke(_VSTD::forward<_Fn2>(__f2), _VSTD::forward<_Args>(__args)...)); }
+  template <class _Fn1, class _Fn2, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn1&& __f1, _Fn2&& __f2, _Args&&... __args) const noexcept(noexcept(
+      std::invoke(std::forward<_Fn1>(__f1), std::invoke(std::forward<_Fn2>(__f2), std::forward<_Args>(__args)...))))
+      -> decltype(std::invoke(std::forward<_Fn1>(__f1),
+                              std::invoke(std::forward<_Fn2>(__f2), std::forward<_Args>(__args)...))) {
+    return std::invoke(std::forward<_Fn1>(__f1), std::invoke(std::forward<_Fn2>(__f2), std::forward<_Args>(__args)...));
+  }
 };
 
 template <class _Fn1, class _Fn2>
 struct __compose_t : __perfect_forward<__compose_op, _Fn1, _Fn2> {
-    using __perfect_forward<__compose_op, _Fn1, _Fn2>::__perfect_forward;
+  using __perfect_forward<__compose_op, _Fn1, _Fn2>::__perfect_forward;
 };
 
 template <class _Fn1, class _Fn2>
-_LIBCPP_HIDE_FROM_ABI
-constexpr auto __compose(_Fn1&& __f1, _Fn2&& __f2)
-    noexcept(noexcept(__compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2))))
-    -> decltype(      __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2)))
-    { return          __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(_VSTD::forward<_Fn1>(__f1), _VSTD::forward<_Fn2>(__f2)); }
+_LIBCPP_HIDE_FROM_ABI constexpr auto __compose(_Fn1&& __f1, _Fn2&& __f2) noexcept(
+    noexcept(__compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(std::forward<_Fn1>(__f1), std::forward<_Fn2>(__f2))))
+    -> decltype(__compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(std::forward<_Fn1>(__f1), std::forward<_Fn2>(__f2))) {
+  return __compose_t<decay_t<_Fn1>, decay_t<_Fn2>>(std::forward<_Fn1>(__f1), std::forward<_Fn2>(__f2));
+}
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__functional/default_searcher.h b/third_party/libcxx/__functional/default_searcher.h
index 222b4c66e..db89d1075 100644
--- a/third_party/libcxx/__functional/default_searcher.h
+++ b/third_party/libcxx/__functional/default_searcher.h
@@ -26,27 +26,24 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 17
 
 // default searcher
-template<class _ForwardIterator, class _BinaryPredicate = equal_to<>>
+template <class _ForwardIterator, class _BinaryPredicate = equal_to<>>
 class _LIBCPP_TEMPLATE_VIS default_searcher {
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    default_searcher(_ForwardIterator __f, _ForwardIterator __l,
-                       _BinaryPredicate __p = _BinaryPredicate())
-        : __first_(__f), __last_(__l), __pred_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  default_searcher(_ForwardIterator __f, _ForwardIterator __l, _BinaryPredicate __p = _BinaryPredicate())
+      : __first_(__f), __last_(__l), __pred_(__p) {}
 
-    template <typename _ForwardIterator2>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    pair<_ForwardIterator2, _ForwardIterator2>
-    operator () (_ForwardIterator2 __f, _ForwardIterator2 __l) const
-    {
-        auto __proj = __identity();
-        return std::__search_impl(__f, __l, __first_, __last_, __pred_, __proj, __proj);
-    }
+  template <typename _ForwardIterator2>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_ForwardIterator2, _ForwardIterator2>
+  operator()(_ForwardIterator2 __f, _ForwardIterator2 __l) const {
+    auto __proj = __identity();
+    return std::__search_impl(__f, __l, __first_, __last_, __pred_, __proj, __proj);
+  }
 
 private:
-    _ForwardIterator __first_;
-    _ForwardIterator __last_;
-    _BinaryPredicate __pred_;
+  _ForwardIterator __first_;
+  _ForwardIterator __last_;
+  _BinaryPredicate __pred_;
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(default_searcher);
 
diff --git a/third_party/libcxx/__functional/function.h b/third_party/libcxx/__functional/function.h
index f3abba453..c7b98035e 100644
--- a/third_party/libcxx/__functional/function.h
+++ b/third_party/libcxx/__functional/function.h
@@ -28,7 +28,7 @@
 #include <__type_traits/decay.h>
 #include <__type_traits/is_core_convertible.h>
 #include <__type_traits/is_scalar.h>
-#include <__type_traits/is_trivially_copy_constructible.h>
+#include <__type_traits/is_trivially_constructible.h>
 #include <__type_traits/is_trivially_destructible.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/strip_signature.h>
@@ -45,6 +45,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #ifndef _LIBCPP_CXX03_LANG
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -52,84 +55,80 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // bad_function_call
 
 _LIBCPP_DIAGNOSTIC_PUSH
+#  if !_LIBCPP_AVAILABILITY_HAS_BAD_FUNCTION_CALL_KEY_FUNCTION
 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wweak-vtables")
-class _LIBCPP_EXCEPTION_ABI bad_function_call
-    : public exception
-{
+#  endif
+class _LIBCPP_EXPORTED_FROM_ABI bad_function_call : public exception {
 public:
+  _LIBCPP_HIDE_FROM_ABI bad_function_call() _NOEXCEPT                                    = default;
+  _LIBCPP_HIDE_FROM_ABI bad_function_call(const bad_function_call&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_function_call& operator=(const bad_function_call&) _NOEXCEPT = default;
 // Note that when a key function is not used, every translation unit that uses
 // bad_function_call will end up containing a weak definition of the vtable and
 // typeinfo.
-#ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
-    ~bad_function_call() _NOEXCEPT override;
-#else
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~bad_function_call() _NOEXCEPT override {}
-#endif
+#  if _LIBCPP_AVAILABILITY_HAS_BAD_FUNCTION_CALL_KEY_FUNCTION
+  ~bad_function_call() _NOEXCEPT override;
+#  else
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~bad_function_call() _NOEXCEPT override {}
+#  endif
 
-#ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
-    const char* what() const _NOEXCEPT override;
-#endif
+#  ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
+  const char* what() const _NOEXCEPT override;
+#  endif
 };
 _LIBCPP_DIAGNOSTIC_POP
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_bad_function_call()
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw bad_function_call();
-#else
-    _LIBCPP_VERBOSE_ABORT("bad_function_call was thrown in -fno-exceptions mode");
-#endif
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_bad_function_call() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw bad_function_call();
+#  else
+  _LIBCPP_VERBOSE_ABORT("bad_function_call was thrown in -fno-exceptions mode");
+#  endif
 }
 
-template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined
+template <class _Fp>
+class _LIBCPP_TEMPLATE_VIS function; // undefined
 
-namespace __function
-{
+namespace __function {
 
-template<class _Rp>
-struct __maybe_derive_from_unary_function
-{
-};
+template <class _Rp>
+struct __maybe_derive_from_unary_function {};
 
-template<class _Rp, class _A1>
-struct __maybe_derive_from_unary_function<_Rp(_A1)>
-    : public __unary_function<_A1, _Rp>
-{
-};
+template <class _Rp, class _A1>
+struct __maybe_derive_from_unary_function<_Rp(_A1)> : public __unary_function<_A1, _Rp> {};
 
-template<class _Rp>
-struct __maybe_derive_from_binary_function
-{
-};
+template <class _Rp>
+struct __maybe_derive_from_binary_function {};
 
-template<class _Rp, class _A1, class _A2>
-struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
-    : public __binary_function<_A1, _A2, _Rp>
-{
-};
+template <class _Rp, class _A1, class _A2>
+struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> : public __binary_function<_A1, _A2, _Rp> {};
 
 template <class _Fp>
-_LIBCPP_INLINE_VISIBILITY
-bool __not_null(_Fp const&) { return true; }
+_LIBCPP_HIDE_FROM_ABI bool __not_null(_Fp const&) {
+  return true;
+}
 
 template <class _Fp>
-_LIBCPP_INLINE_VISIBILITY
-bool __not_null(_Fp* __ptr) { return __ptr; }
+_LIBCPP_HIDE_FROM_ABI bool __not_null(_Fp* __ptr) {
+  return __ptr;
+}
 
 template <class _Ret, class _Class>
-_LIBCPP_INLINE_VISIBILITY
-bool __not_null(_Ret _Class::*__ptr) { return __ptr; }
+_LIBCPP_HIDE_FROM_ABI bool __not_null(_Ret _Class::*__ptr) {
+  return __ptr;
+}
 
 template <class _Fp>
-_LIBCPP_INLINE_VISIBILITY
-bool __not_null(function<_Fp> const& __f) { return !!__f; }
+_LIBCPP_HIDE_FROM_ABI bool __not_null(function<_Fp> const& __f) {
+  return !!__f;
+}
 
-#ifdef _LIBCPP_HAS_EXTENSION_BLOCKS
-template <class _Rp, class ..._Args>
-_LIBCPP_INLINE_VISIBILITY
-bool __not_null(_Rp (^__p)(_Args...)) { return __p; }
-#endif
+#  ifdef _LIBCPP_HAS_EXTENSION_BLOCKS
+template <class _Rp, class... _Args>
+_LIBCPP_HIDE_FROM_ABI bool __not_null(_Rp (^__p)(_Args...)) {
+  return __p;
+}
+#  endif
 
 } // namespace __function
 
@@ -137,84 +136,60 @@ namespace __function {
 
 // __alloc_func holds a functor and an allocator.
 
-template <class _Fp, class _Ap, class _FB> class __alloc_func;
+template <class _Fp, class _Ap, class _FB>
+class __alloc_func;
 template <class _Fp, class _FB>
 class __default_alloc_func;
 
 template <class _Fp, class _Ap, class _Rp, class... _ArgTypes>
-class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)>
-{
-    __compressed_pair<_Fp, _Ap> __f_;
+class __alloc_func<_Fp, _Ap, _Rp(_ArgTypes...)> {
+  __compressed_pair<_Fp, _Ap> __f_;
 
-  public:
-    typedef _LIBCPP_NODEBUG _Fp _Target;
-    typedef _LIBCPP_NODEBUG _Ap _Alloc;
+public:
+  typedef _LIBCPP_NODEBUG _Fp _Target;
+  typedef _LIBCPP_NODEBUG _Ap _Alloc;
 
-    _LIBCPP_INLINE_VISIBILITY
-    const _Target& __target() const { return __f_.first(); }
+  _LIBCPP_HIDE_FROM_ABI const _Target& __target() const { return __f_.first(); }
 
-    // WIN32 APIs may define __allocator, so use __get_allocator instead.
-    _LIBCPP_INLINE_VISIBILITY
-    const _Alloc& __get_allocator() const { return __f_.second(); }
+  // WIN32 APIs may define __allocator, so use __get_allocator instead.
+  _LIBCPP_HIDE_FROM_ABI const _Alloc& __get_allocator() const { return __f_.second(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __alloc_func(_Target&& __f)
-        : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
-               _VSTD::forward_as_tuple())
-    {
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit __alloc_func(_Target&& __f)
+      : __f_(piecewise_construct, std::forward_as_tuple(std::move(__f)), std::forward_as_tuple()) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __alloc_func(const _Target& __f, const _Alloc& __a)
-        : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
-               _VSTD::forward_as_tuple(__a))
-    {
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit __alloc_func(const _Target& __f, const _Alloc& __a)
+      : __f_(piecewise_construct, std::forward_as_tuple(__f), std::forward_as_tuple(__a)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __alloc_func(const _Target& __f, _Alloc&& __a)
-        : __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
-               _VSTD::forward_as_tuple(_VSTD::move(__a)))
-    {
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit __alloc_func(const _Target& __f, _Alloc&& __a)
+      : __f_(piecewise_construct, std::forward_as_tuple(__f), std::forward_as_tuple(std::move(__a))) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __alloc_func(_Target&& __f, _Alloc&& __a)
-        : __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
-               _VSTD::forward_as_tuple(_VSTD::move(__a)))
-    {
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit __alloc_func(_Target&& __f, _Alloc&& __a)
+      : __f_(piecewise_construct, std::forward_as_tuple(std::move(__f)), std::forward_as_tuple(std::move(__a))) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    _Rp operator()(_ArgTypes&&... __arg)
-    {
-        typedef __invoke_void_return_wrapper<_Rp> _Invoker;
-        return _Invoker::__call(__f_.first(),
-                                _VSTD::forward<_ArgTypes>(__arg)...);
-    }
+  _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes&&... __arg) {
+    typedef __invoke_void_return_wrapper<_Rp> _Invoker;
+    return _Invoker::__call(__f_.first(), std::forward<_ArgTypes>(__arg)...);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __alloc_func* __clone() const
-    {
-        typedef allocator_traits<_Alloc> __alloc_traits;
-        typedef __rebind_alloc<__alloc_traits, __alloc_func> _AA;
-        _AA __a(__f_.second());
-        typedef __allocator_destructor<_AA> _Dp;
-        unique_ptr<__alloc_func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
-        ::new ((void*)__hold.get()) __alloc_func(__f_.first(), _Alloc(__a));
-        return __hold.release();
-    }
+  _LIBCPP_HIDE_FROM_ABI __alloc_func* __clone() const {
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    typedef __rebind_alloc<__alloc_traits, __alloc_func> _AA;
+    _AA __a(__f_.second());
+    typedef __allocator_destructor<_AA> _Dp;
+    unique_ptr<__alloc_func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
+    ::new ((void*)__hold.get()) __alloc_func(__f_.first(), _Alloc(__a));
+    return __hold.release();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void destroy() _NOEXCEPT { __f_.~__compressed_pair<_Target, _Alloc>(); }
+  _LIBCPP_HIDE_FROM_ABI void destroy() _NOEXCEPT { __f_.~__compressed_pair<_Target, _Alloc>(); }
 
-    _LIBCPP_HIDE_FROM_ABI static void __destroy_and_delete(__alloc_func* __f) {
-      typedef allocator_traits<_Alloc> __alloc_traits;
-      typedef __rebind_alloc<__alloc_traits, __alloc_func> _FunAlloc;
-      _FunAlloc __a(__f->__get_allocator());
-      __f->destroy();
-      __a.deallocate(__f, 1);
-    }
+  _LIBCPP_HIDE_FROM_ABI static void __destroy_and_delete(__alloc_func* __f) {
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    typedef __rebind_alloc<__alloc_traits, __alloc_func> _FunAlloc;
+    _FunAlloc __a(__f->__get_allocator());
+    __f->destroy();
+    __a.deallocate(__f, 1);
+  }
 };
 
 template <class _Fp, class _Rp, class... _ArgTypes>
@@ -224,455 +199,377 @@ class __default_alloc_func<_Fp, _Rp(_ArgTypes...)> {
 public:
   typedef _LIBCPP_NODEBUG _Fp _Target;
 
-  _LIBCPP_INLINE_VISIBILITY
-  const _Target& __target() const { return __f_; }
+  _LIBCPP_HIDE_FROM_ABI const _Target& __target() const { return __f_; }
 
-  _LIBCPP_INLINE_VISIBILITY
-  explicit __default_alloc_func(_Target&& __f) : __f_(_VSTD::move(__f)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __default_alloc_func(_Target&& __f) : __f_(std::move(__f)) {}
 
-  _LIBCPP_INLINE_VISIBILITY
-  explicit __default_alloc_func(const _Target& __f) : __f_(__f) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __default_alloc_func(const _Target& __f) : __f_(__f) {}
 
-  _LIBCPP_INLINE_VISIBILITY
-  _Rp operator()(_ArgTypes&&... __arg) {
+  _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes&&... __arg) {
     typedef __invoke_void_return_wrapper<_Rp> _Invoker;
-    return _Invoker::__call(__f_, _VSTD::forward<_ArgTypes>(__arg)...);
+    return _Invoker::__call(__f_, std::forward<_ArgTypes>(__arg)...);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  __default_alloc_func* __clone() const {
-      __builtin_new_allocator::__holder_t __hold =
-        __builtin_new_allocator::__allocate_type<__default_alloc_func>(1);
-    __default_alloc_func* __res =
-        ::new ((void*)__hold.get()) __default_alloc_func(__f_);
+  _LIBCPP_HIDE_FROM_ABI __default_alloc_func* __clone() const {
+    __builtin_new_allocator::__holder_t __hold = __builtin_new_allocator::__allocate_type<__default_alloc_func>(1);
+    __default_alloc_func* __res                = ::new ((void*)__hold.get()) __default_alloc_func(__f_);
     (void)__hold.release();
     return __res;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void destroy() _NOEXCEPT { __f_.~_Target(); }
+  _LIBCPP_HIDE_FROM_ABI void destroy() _NOEXCEPT { __f_.~_Target(); }
 
   _LIBCPP_HIDE_FROM_ABI static void __destroy_and_delete(__default_alloc_func* __f) {
     __f->destroy();
-      __builtin_new_allocator::__deallocate_type<__default_alloc_func>(__f, 1);
+    __builtin_new_allocator::__deallocate_type<__default_alloc_func>(__f, 1);
   }
 };
 
 // __base provides an abstract interface for copyable functors.
 
-template<class _Fp> class _LIBCPP_TEMPLATE_VIS __base;
+template <class _Fp>
+class _LIBCPP_TEMPLATE_VIS __base;
 
-template<class _Rp, class ..._ArgTypes>
-class __base<_Rp(_ArgTypes...)>
-{
-    __base(const __base&);
-    __base& operator=(const __base&);
+template <class _Rp, class... _ArgTypes>
+class __base<_Rp(_ArgTypes...)> {
 public:
-    _LIBCPP_INLINE_VISIBILITY __base() {}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual ~__base() {}
-    virtual __base* __clone() const = 0;
-    virtual void __clone(__base*) const = 0;
-    virtual void destroy() _NOEXCEPT = 0;
-    virtual void destroy_deallocate() _NOEXCEPT = 0;
-    virtual _Rp operator()(_ArgTypes&& ...) = 0;
-#ifndef _LIBCPP_HAS_NO_RTTI
-    virtual const void* target(const type_info&) const _NOEXCEPT = 0;
-    virtual const std::type_info& target_type() const _NOEXCEPT = 0;
-#endif // _LIBCPP_HAS_NO_RTTI
+  __base(const __base&)            = delete;
+  __base& operator=(const __base&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI __base() {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual ~__base() {}
+  virtual __base* __clone() const             = 0;
+  virtual void __clone(__base*) const         = 0;
+  virtual void destroy() _NOEXCEPT            = 0;
+  virtual void destroy_deallocate() _NOEXCEPT = 0;
+  virtual _Rp operator()(_ArgTypes&&...)      = 0;
+#  ifndef _LIBCPP_HAS_NO_RTTI
+  virtual const void* target(const type_info&) const _NOEXCEPT = 0;
+  virtual const std::type_info& target_type() const _NOEXCEPT  = 0;
+#  endif // _LIBCPP_HAS_NO_RTTI
 };
 
 // __func implements __base for a given functor type.
 
-template<class _FD, class _Alloc, class _FB> class __func;
+template <class _FD, class _Alloc, class _FB>
+class __func;
+
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+class __func<_Fp, _Alloc, _Rp(_ArgTypes...)> : public __base<_Rp(_ArgTypes...)> {
+  __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> __f_;
 
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>
-    : public  __base<_Rp(_ArgTypes...)>
-{
-    __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> __f_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __func(_Fp&& __f)
-        : __f_(_VSTD::move(__f)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __func(_Fp&& __f) : __f_(std::move(__f)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __func(const _Fp& __f, const _Alloc& __a)
-        : __f_(__f, __a) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __func(const _Fp& __f, const _Alloc& __a) : __f_(__f, __a) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __func(const _Fp& __f, _Alloc&& __a)
-        : __f_(__f, _VSTD::move(__a)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __func(const _Fp& __f, _Alloc&& __a) : __f_(__f, std::move(__a)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __func(_Fp&& __f, _Alloc&& __a)
-        : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __func(_Fp&& __f, _Alloc&& __a) : __f_(std::move(__f), std::move(__a)) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual __base<_Rp(_ArgTypes...)>* __clone() const;
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy() _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy_deallocate() _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual _Rp operator()(_ArgTypes&&... __arg);
-#ifndef _LIBCPP_HAS_NO_RTTI
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual const void* target(const type_info&) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual const std::type_info& target_type() const _NOEXCEPT;
-#endif // _LIBCPP_HAS_NO_RTTI
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual __base<_Rp(_ArgTypes...)>* __clone() const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy_deallocate() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual _Rp operator()(_ArgTypes&&... __arg);
+#  ifndef _LIBCPP_HAS_NO_RTTI
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual const void* target(const type_info&) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual const std::type_info& target_type() const _NOEXCEPT;
+#  endif // _LIBCPP_HAS_NO_RTTI
 };
 
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-__base<_Rp(_ArgTypes...)>*
-__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
-{
-    typedef allocator_traits<_Alloc> __alloc_traits;
-    typedef __rebind_alloc<__alloc_traits, __func> _Ap;
-    _Ap __a(__f_.__get_allocator());
-    typedef __allocator_destructor<_Ap> _Dp;
-    unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
-    ::new ((void*)__hold.get()) __func(__f_.__target(), _Alloc(__a));
-    return __hold.release();
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+__base<_Rp(_ArgTypes...)>* __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const {
+  typedef allocator_traits<_Alloc> __alloc_traits;
+  typedef __rebind_alloc<__alloc_traits, __func> _Ap;
+  _Ap __a(__f_.__get_allocator());
+  typedef __allocator_destructor<_Ap> _Dp;
+  unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
+  ::new ((void*)__hold.get()) __func(__f_.__target(), _Alloc(__a));
+  return __hold.release();
 }
 
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-void
-__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
-{
-    ::new ((void*)__p) __func(__f_.__target(), __f_.__get_allocator());
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+void __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const {
+  ::new ((void*)__p) __func(__f_.__target(), __f_.__get_allocator());
 }
 
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-void
-__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
-{
-    __f_.destroy();
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+void __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT {
+  __f_.destroy();
 }
 
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-void
-__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
-{
-    typedef allocator_traits<_Alloc> __alloc_traits;
-    typedef __rebind_alloc<__alloc_traits, __func> _Ap;
-    _Ap __a(__f_.__get_allocator());
-    __f_.destroy();
-    __a.deallocate(this, 1);
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+void __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT {
+  typedef allocator_traits<_Alloc> __alloc_traits;
+  typedef __rebind_alloc<__alloc_traits, __func> _Ap;
+  _Ap __a(__f_.__get_allocator());
+  __f_.destroy();
+  __a.deallocate(this, 1);
 }
 
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-_Rp
-__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
-{
-    return __f_(_VSTD::forward<_ArgTypes>(__arg)...);
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+_Rp __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&&... __arg) {
+  return __f_(std::forward<_ArgTypes>(__arg)...);
 }
 
-#ifndef _LIBCPP_HAS_NO_RTTI
+#  ifndef _LIBCPP_HAS_NO_RTTI
 
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-const void*
-__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
-{
-    if (__ti == typeid(_Fp))
-        return _VSTD::addressof(__f_.__target());
-    return nullptr;
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+const void* __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT {
+  if (__ti == typeid(_Fp))
+    return std::addressof(__f_.__target());
+  return nullptr;
 }
 
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-const std::type_info&
-__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
-{
-    return typeid(_Fp);
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+const std::type_info& __func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT {
+  return typeid(_Fp);
 }
 
-#endif // _LIBCPP_HAS_NO_RTTI
+#  endif // _LIBCPP_HAS_NO_RTTI
 
 // __value_func creates a value-type from a __func.
 
-template <class _Fp> class __value_func;
+template <class _Fp>
+class __value_func;
 
-template <class _Rp, class... _ArgTypes> class __value_func<_Rp(_ArgTypes...)>
-{
-    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    typename aligned_storage<3 * sizeof(void*)>::type __buf_;
-    _LIBCPP_SUPPRESS_DEPRECATED_POP
+template <class _Rp, class... _ArgTypes>
+class __value_func<_Rp(_ArgTypes...)> {
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  typename aligned_storage<3 * sizeof(void*)>::type __buf_;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    typedef __base<_Rp(_ArgTypes...)> __func;
-    __func* __f_;
+  typedef __base<_Rp(_ArgTypes...)> __func;
+  __func* __f_;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI static __func* __as_base(void* __p)
-    {
-        return reinterpret_cast<__func*>(__p);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI static __func* __as_base(void* __p) { return reinterpret_cast<__func*>(__p); }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __value_func() _NOEXCEPT : __f_(nullptr) {}
+
+  template <class _Fp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI __value_func(_Fp&& __f, const _Alloc& __a) : __f_(nullptr) {
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun;
+    typedef __rebind_alloc<__alloc_traits, _Fun> _FunAlloc;
+
+    if (__function::__not_null(__f)) {
+      _FunAlloc __af(__a);
+      if (sizeof(_Fun) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value &&
+          is_nothrow_copy_constructible<_FunAlloc>::value) {
+        __f_ = ::new ((void*)&__buf_) _Fun(std::move(__f), _Alloc(__af));
+      } else {
+        typedef __allocator_destructor<_FunAlloc> _Dp;
+        unique_ptr<__func, _Dp> __hold(__af.allocate(1), _Dp(__af, 1));
+        ::new ((void*)__hold.get()) _Fun(std::move(__f), _Alloc(__a));
+        __f_ = __hold.release();
+      }
     }
+  }
 
-  public:
-    _LIBCPP_INLINE_VISIBILITY
-    __value_func() _NOEXCEPT : __f_(nullptr) {}
+  template <class _Fp, __enable_if_t<!is_same<__decay_t<_Fp>, __value_func>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit __value_func(_Fp&& __f) : __value_func(std::forward<_Fp>(__f), allocator<_Fp>()) {}
 
-    template <class _Fp, class _Alloc>
-    _LIBCPP_INLINE_VISIBILITY __value_func(_Fp&& __f, const _Alloc& __a)
-        : __f_(nullptr)
-    {
-        typedef allocator_traits<_Alloc> __alloc_traits;
-        typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun;
-        typedef __rebind_alloc<__alloc_traits, _Fun> _FunAlloc;
+  _LIBCPP_HIDE_FROM_ABI __value_func(const __value_func& __f) {
+    if (__f.__f_ == nullptr)
+      __f_ = nullptr;
+    else if ((void*)__f.__f_ == &__f.__buf_) {
+      __f_ = __as_base(&__buf_);
+      __f.__f_->__clone(__f_);
+    } else
+      __f_ = __f.__f_->__clone();
+  }
 
-        if (__function::__not_null(__f))
-        {
-            _FunAlloc __af(__a);
-            if (sizeof(_Fun) <= sizeof(__buf_) &&
-                is_nothrow_copy_constructible<_Fp>::value &&
-                is_nothrow_copy_constructible<_FunAlloc>::value)
-            {
-                __f_ =
-                    ::new ((void*)&__buf_) _Fun(_VSTD::move(__f), _Alloc(__af));
-            }
-            else
-            {
-                typedef __allocator_destructor<_FunAlloc> _Dp;
-                unique_ptr<__func, _Dp> __hold(__af.allocate(1), _Dp(__af, 1));
-                ::new ((void*)__hold.get()) _Fun(_VSTD::move(__f), _Alloc(__a));
-                __f_ = __hold.release();
-            }
-        }
+  _LIBCPP_HIDE_FROM_ABI __value_func(__value_func&& __f) _NOEXCEPT {
+    if (__f.__f_ == nullptr)
+      __f_ = nullptr;
+    else if ((void*)__f.__f_ == &__f.__buf_) {
+      __f_ = __as_base(&__buf_);
+      __f.__f_->__clone(__f_);
+    } else {
+      __f_     = __f.__f_;
+      __f.__f_ = nullptr;
     }
+  }
 
-    template <class _Fp,
-        class = typename enable_if<!is_same<__decay_t<_Fp>, __value_func>::value>::type>
-    _LIBCPP_INLINE_VISIBILITY explicit __value_func(_Fp&& __f)
-        : __value_func(_VSTD::forward<_Fp>(__f), allocator<_Fp>()) {}
+  _LIBCPP_HIDE_FROM_ABI ~__value_func() {
+    if ((void*)__f_ == &__buf_)
+      __f_->destroy();
+    else if (__f_)
+      __f_->destroy_deallocate();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __value_func(const __value_func& __f)
-    {
-        if (__f.__f_ == nullptr)
-            __f_ = nullptr;
-        else if ((void*)__f.__f_ == &__f.__buf_)
-        {
-            __f_ = __as_base(&__buf_);
-            __f.__f_->__clone(__f_);
-        }
-        else
-            __f_ = __f.__f_->__clone();
+  _LIBCPP_HIDE_FROM_ABI __value_func& operator=(__value_func&& __f) {
+    *this = nullptr;
+    if (__f.__f_ == nullptr)
+      __f_ = nullptr;
+    else if ((void*)__f.__f_ == &__f.__buf_) {
+      __f_ = __as_base(&__buf_);
+      __f.__f_->__clone(__f_);
+    } else {
+      __f_     = __f.__f_;
+      __f.__f_ = nullptr;
     }
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __value_func(__value_func&& __f) _NOEXCEPT
-    {
-        if (__f.__f_ == nullptr)
-            __f_ = nullptr;
-        else if ((void*)__f.__f_ == &__f.__buf_)
-        {
-            __f_ = __as_base(&__buf_);
-            __f.__f_->__clone(__f_);
-        }
-        else
-        {
-            __f_ = __f.__f_;
-            __f.__f_ = nullptr;
-        }
-    }
+  _LIBCPP_HIDE_FROM_ABI __value_func& operator=(nullptr_t) {
+    __func* __f = __f_;
+    __f_        = nullptr;
+    if ((void*)__f == &__buf_)
+      __f->destroy();
+    else if (__f)
+      __f->destroy_deallocate();
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~__value_func()
-    {
-        if ((void*)__f_ == &__buf_)
-            __f_->destroy();
-        else if (__f_)
-            __f_->destroy_deallocate();
-    }
+  _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes&&... __args) const {
+    if (__f_ == nullptr)
+      __throw_bad_function_call();
+    return (*__f_)(std::forward<_ArgTypes>(__args)...);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __value_func& operator=(__value_func&& __f)
-    {
-        *this = nullptr;
-        if (__f.__f_ == nullptr)
-            __f_ = nullptr;
-        else if ((void*)__f.__f_ == &__f.__buf_)
-        {
-            __f_ = __as_base(&__buf_);
-            __f.__f_->__clone(__f_);
-        }
-        else
-        {
-            __f_ = __f.__f_;
-            __f.__f_ = nullptr;
-        }
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(__value_func& __f) _NOEXCEPT {
+    if (&__f == this)
+      return;
+    if ((void*)__f_ == &__buf_ && (void*)__f.__f_ == &__f.__buf_) {
+      _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+      typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
+      _LIBCPP_SUPPRESS_DEPRECATED_POP
+      __func* __t = __as_base(&__tempbuf);
+      __f_->__clone(__t);
+      __f_->destroy();
+      __f_ = nullptr;
+      __f.__f_->__clone(__as_base(&__buf_));
+      __f.__f_->destroy();
+      __f.__f_ = nullptr;
+      __f_     = __as_base(&__buf_);
+      __t->__clone(__as_base(&__f.__buf_));
+      __t->destroy();
+      __f.__f_ = __as_base(&__f.__buf_);
+    } else if ((void*)__f_ == &__buf_) {
+      __f_->__clone(__as_base(&__f.__buf_));
+      __f_->destroy();
+      __f_     = __f.__f_;
+      __f.__f_ = __as_base(&__f.__buf_);
+    } else if ((void*)__f.__f_ == &__f.__buf_) {
+      __f.__f_->__clone(__as_base(&__buf_));
+      __f.__f_->destroy();
+      __f.__f_ = __f_;
+      __f_     = __as_base(&__buf_);
+    } else
+      std::swap(__f_, __f.__f_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __value_func& operator=(nullptr_t)
-    {
-        __func* __f = __f_;
-        __f_ = nullptr;
-        if ((void*)__f == &__buf_)
-            __f->destroy();
-        else if (__f)
-            __f->destroy_deallocate();
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __f_ != nullptr; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    _Rp operator()(_ArgTypes&&... __args) const
-    {
-        if (__f_ == nullptr)
-            __throw_bad_function_call();
-        return (*__f_)(_VSTD::forward<_ArgTypes>(__args)...);
-    }
+#  ifndef _LIBCPP_HAS_NO_RTTI
+  _LIBCPP_HIDE_FROM_ABI const std::type_info& target_type() const _NOEXCEPT {
+    if (__f_ == nullptr)
+      return typeid(void);
+    return __f_->target_type();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(__value_func& __f) _NOEXCEPT
-    {
-        if (&__f == this)
-            return;
-        if ((void*)__f_ == &__buf_ && (void*)__f.__f_ == &__f.__buf_)
-        {
-            _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-            typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
-            _LIBCPP_SUPPRESS_DEPRECATED_POP
-            __func* __t = __as_base(&__tempbuf);
-            __f_->__clone(__t);
-            __f_->destroy();
-            __f_ = nullptr;
-            __f.__f_->__clone(__as_base(&__buf_));
-            __f.__f_->destroy();
-            __f.__f_ = nullptr;
-            __f_ = __as_base(&__buf_);
-            __t->__clone(__as_base(&__f.__buf_));
-            __t->destroy();
-            __f.__f_ = __as_base(&__f.__buf_);
-        }
-        else if ((void*)__f_ == &__buf_)
-        {
-            __f_->__clone(__as_base(&__f.__buf_));
-            __f_->destroy();
-            __f_ = __f.__f_;
-            __f.__f_ = __as_base(&__f.__buf_);
-        }
-        else if ((void*)__f.__f_ == &__f.__buf_)
-        {
-            __f.__f_->__clone(__as_base(&__buf_));
-            __f.__f_->destroy();
-            __f.__f_ = __f_;
-            __f_ = __as_base(&__buf_);
-        }
-        else
-            _VSTD::swap(__f_, __f.__f_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const _NOEXCEPT { return __f_ != nullptr; }
-
-#ifndef _LIBCPP_HAS_NO_RTTI
-    _LIBCPP_INLINE_VISIBILITY
-    const std::type_info& target_type() const _NOEXCEPT
-    {
-        if (__f_ == nullptr)
-            return typeid(void);
-        return __f_->target_type();
-    }
-
-    template <typename _Tp>
-    _LIBCPP_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT
-    {
-        if (__f_ == nullptr)
-            return nullptr;
-        return (const _Tp*)__f_->target(typeid(_Tp));
-    }
-#endif // _LIBCPP_HAS_NO_RTTI
+  template <typename _Tp>
+  _LIBCPP_HIDE_FROM_ABI const _Tp* target() const _NOEXCEPT {
+    if (__f_ == nullptr)
+      return nullptr;
+    return (const _Tp*)__f_->target(typeid(_Tp));
+  }
+#  endif // _LIBCPP_HAS_NO_RTTI
 };
 
 // Storage for a functor object, to be used with __policy to manage copy and
 // destruction.
-union __policy_storage
-{
-    mutable char __small[sizeof(void*) * 2];
-    void* __large;
+union __policy_storage {
+  mutable char __small[sizeof(void*) * 2];
+  void* __large;
 };
 
 // True if _Fun can safely be held in __policy_storage.__small.
 template <typename _Fun>
 struct __use_small_storage
     : public integral_constant<
-          bool, sizeof(_Fun) <= sizeof(__policy_storage) &&
-                    _LIBCPP_ALIGNOF(_Fun) <= _LIBCPP_ALIGNOF(__policy_storage) &&
-                    is_trivially_copy_constructible<_Fun>::value &&
-                    is_trivially_destructible<_Fun>::value> {};
+          bool,
+          sizeof(_Fun) <= sizeof(__policy_storage)&& _LIBCPP_ALIGNOF(_Fun) <= _LIBCPP_ALIGNOF(__policy_storage) &&
+              is_trivially_copy_constructible<_Fun>::value && is_trivially_destructible<_Fun>::value> {};
 
 // Policy contains information about how to copy, destroy, and move the
 // underlying functor. You can think of it as a vtable of sorts.
-struct __policy
-{
-    // Used to copy or destroy __large values. null for trivial objects.
-    void* (*const __clone)(const void*);
-    void (*const __destroy)(void*);
+struct __policy {
+  // Used to copy or destroy __large values. null for trivial objects.
+  void* (*const __clone)(const void*);
+  void (*const __destroy)(void*);
 
-    // True if this is the null policy (no value).
-    const bool __is_null;
+  // True if this is the null policy (no value).
+  const bool __is_null;
 
-    // The target type. May be null if RTTI is disabled.
-    const std::type_info* const __type_info;
+  // The target type. May be null if RTTI is disabled.
+  const std::type_info* const __type_info;
 
-    // Returns a pointer to a static policy object suitable for the functor
-    // type.
-    template <typename _Fun>
-    _LIBCPP_INLINE_VISIBILITY static const __policy* __create()
-    {
-        return __choose_policy<_Fun>(__use_small_storage<_Fun>());
-    }
+  // Returns a pointer to a static policy object suitable for the functor
+  // type.
+  template <typename _Fun>
+  _LIBCPP_HIDE_FROM_ABI static const __policy* __create() {
+    return __choose_policy<_Fun>(__use_small_storage<_Fun>());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    static const __policy* __create_empty()
-    {
-        static const _LIBCPP_CONSTEXPR __policy __policy = {nullptr, nullptr,
-                                                            true,
-#ifndef _LIBCPP_HAS_NO_RTTI
-                                                            &typeid(void)
-#else
-                                                            nullptr
-#endif
-        };
-        return &__policy;
-    }
+  _LIBCPP_HIDE_FROM_ABI static const __policy* __create_empty() {
+    static constexpr __policy __policy = {
+        nullptr,
+        nullptr,
+        true,
+#  ifndef _LIBCPP_HAS_NO_RTTI
+        &typeid(void)
+#  else
+        nullptr
+#  endif
+    };
+    return &__policy;
+  }
 
-  private:
-    template <typename _Fun>
-    _LIBCPP_HIDE_FROM_ABI static void* __large_clone(const void* __s)
-    {
-        const _Fun* __f = static_cast<const _Fun*>(__s);
-        return __f->__clone();
-    }
+private:
+  template <typename _Fun>
+  _LIBCPP_HIDE_FROM_ABI static void* __large_clone(const void* __s) {
+    const _Fun* __f = static_cast<const _Fun*>(__s);
+    return __f->__clone();
+  }
 
-    template <typename _Fun>
-    _LIBCPP_HIDE_FROM_ABI static void __large_destroy(void* __s) {
-      _Fun::__destroy_and_delete(static_cast<_Fun*>(__s));
-    }
+  template <typename _Fun>
+  _LIBCPP_HIDE_FROM_ABI static void __large_destroy(void* __s) {
+    _Fun::__destroy_and_delete(static_cast<_Fun*>(__s));
+  }
 
-    template <typename _Fun>
-    _LIBCPP_INLINE_VISIBILITY static const __policy*
-    __choose_policy(/* is_small = */ false_type) {
-      static const _LIBCPP_CONSTEXPR __policy __policy = {
-          &__large_clone<_Fun>, &__large_destroy<_Fun>, false,
-#ifndef _LIBCPP_HAS_NO_RTTI
-          &typeid(typename _Fun::_Target)
-#else
-          nullptr
-#endif
-      };
-        return &__policy;
-    }
+  template <typename _Fun>
+  _LIBCPP_HIDE_FROM_ABI static const __policy* __choose_policy(/* is_small = */ false_type) {
+    static constexpr __policy __policy = {
+        &__large_clone<_Fun>,
+        &__large_destroy<_Fun>,
+        false,
+#  ifndef _LIBCPP_HAS_NO_RTTI
+        &typeid(typename _Fun::_Target)
+#  else
+        nullptr
+#  endif
+    };
+    return &__policy;
+  }
 
-    template <typename _Fun>
-    _LIBCPP_INLINE_VISIBILITY static const __policy*
-        __choose_policy(/* is_small = */ true_type)
-    {
-        static const _LIBCPP_CONSTEXPR __policy __policy = {
-            nullptr, nullptr, false,
-#ifndef _LIBCPP_HAS_NO_RTTI
-            &typeid(typename _Fun::_Target)
-#else
-            nullptr
-#endif
-        };
-        return &__policy;
-    }
+  template <typename _Fun>
+  _LIBCPP_HIDE_FROM_ABI static const __policy* __choose_policy(/* is_small = */ true_type) {
+    static constexpr __policy __policy = {
+        nullptr,
+        nullptr,
+        false,
+#  ifndef _LIBCPP_HAS_NO_RTTI
+        &typeid(typename _Fun::_Target)
+#  else
+        nullptr
+#  endif
+    };
+    return &__policy;
+  }
 };
 
 // Used to choose between perfect forwarding or pass-by-value. Pass-by-value is
@@ -682,545 +579,470 @@ using __fast_forward = __conditional_t<is_scalar<_Tp>::value, _Tp, _Tp&&>;
 
 // __policy_invoker calls an instance of __alloc_func held in __policy_storage.
 
-template <class _Fp> struct __policy_invoker;
+template <class _Fp>
+struct __policy_invoker;
 
 template <class _Rp, class... _ArgTypes>
-struct __policy_invoker<_Rp(_ArgTypes...)>
-{
-    typedef _Rp (*__Call)(const __policy_storage*,
-                          __fast_forward<_ArgTypes>...);
+struct __policy_invoker<_Rp(_ArgTypes...)> {
+  typedef _Rp (*__Call)(const __policy_storage*, __fast_forward<_ArgTypes>...);
 
-    __Call __call_;
+  __Call __call_;
 
-    // Creates an invoker that throws bad_function_call.
-    _LIBCPP_INLINE_VISIBILITY
-    __policy_invoker() : __call_(&__call_empty) {}
+  // Creates an invoker that throws bad_function_call.
+  _LIBCPP_HIDE_FROM_ABI __policy_invoker() : __call_(&__call_empty) {}
 
-    // Creates an invoker that calls the given instance of __func.
-    template <typename _Fun>
-    _LIBCPP_INLINE_VISIBILITY static __policy_invoker __create()
-    {
-        return __policy_invoker(&__call_impl<_Fun>);
-    }
+  // Creates an invoker that calls the given instance of __func.
+  template <typename _Fun>
+  _LIBCPP_HIDE_FROM_ABI static __policy_invoker __create() {
+    return __policy_invoker(&__call_impl<_Fun>);
+  }
 
-  private:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __policy_invoker(__Call __c) : __call_(__c) {}
+private:
+  _LIBCPP_HIDE_FROM_ABI explicit __policy_invoker(__Call __c) : __call_(__c) {}
 
-    _LIBCPP_HIDE_FROM_ABI static _Rp __call_empty(const __policy_storage*,
-                            __fast_forward<_ArgTypes>...)
-    {
-        __throw_bad_function_call();
-    }
+  _LIBCPP_HIDE_FROM_ABI static _Rp __call_empty(const __policy_storage*, __fast_forward<_ArgTypes>...) {
+    __throw_bad_function_call();
+  }
 
-    template <typename _Fun>
-    _LIBCPP_HIDE_FROM_ABI static _Rp __call_impl(const __policy_storage* __buf,
-                           __fast_forward<_ArgTypes>... __args)
-    {
-        _Fun* __f = reinterpret_cast<_Fun*>(__use_small_storage<_Fun>::value
-                                                ? &__buf->__small
-                                                : __buf->__large);
-        return (*__f)(_VSTD::forward<_ArgTypes>(__args)...);
-    }
+  template <typename _Fun>
+  _LIBCPP_HIDE_FROM_ABI static _Rp __call_impl(const __policy_storage* __buf, __fast_forward<_ArgTypes>... __args) {
+    _Fun* __f = reinterpret_cast<_Fun*>(__use_small_storage<_Fun>::value ? &__buf->__small : __buf->__large);
+    return (*__f)(std::forward<_ArgTypes>(__args)...);
+  }
 };
 
 // __policy_func uses a __policy and __policy_invoker to create a type-erased,
 // copyable functor.
 
-template <class _Fp> class __policy_func;
+template <class _Fp>
+class __policy_func;
 
-template <class _Rp, class... _ArgTypes> class __policy_func<_Rp(_ArgTypes...)>
-{
-    // Inline storage for small objects.
-    __policy_storage __buf_;
+template <class _Rp, class... _ArgTypes>
+class __policy_func<_Rp(_ArgTypes...)> {
+  // Inline storage for small objects.
+  __policy_storage __buf_;
 
-    // Calls the value stored in __buf_. This could technically be part of
-    // policy, but storing it here eliminates a level of indirection inside
-    // operator().
-    typedef __function::__policy_invoker<_Rp(_ArgTypes...)> __invoker;
-    __invoker __invoker_;
+  // Calls the value stored in __buf_. This could technically be part of
+  // policy, but storing it here eliminates a level of indirection inside
+  // operator().
+  typedef __function::__policy_invoker<_Rp(_ArgTypes...)> __invoker;
+  __invoker __invoker_;
 
-    // The policy that describes how to move / copy / destroy __buf_. Never
-    // null, even if the function is empty.
-    const __policy* __policy_;
-
-  public:
-    _LIBCPP_INLINE_VISIBILITY
-    __policy_func() : __policy_(__policy::__create_empty()) {}
-
-    template <class _Fp, class _Alloc>
-    _LIBCPP_INLINE_VISIBILITY __policy_func(_Fp&& __f, const _Alloc& __a)
-        : __policy_(__policy::__create_empty())
-    {
-        typedef __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun;
-        typedef allocator_traits<_Alloc> __alloc_traits;
-        typedef __rebind_alloc<__alloc_traits, _Fun> _FunAlloc;
-
-        if (__function::__not_null(__f))
-        {
-            __invoker_ = __invoker::template __create<_Fun>();
-            __policy_ = __policy::__create<_Fun>();
-
-            _FunAlloc __af(__a);
-            if (__use_small_storage<_Fun>())
-            {
-                ::new ((void*)&__buf_.__small)
-                    _Fun(_VSTD::move(__f), _Alloc(__af));
-            }
-            else
-            {
-                typedef __allocator_destructor<_FunAlloc> _Dp;
-                unique_ptr<_Fun, _Dp> __hold(__af.allocate(1), _Dp(__af, 1));
-                ::new ((void*)__hold.get())
-                    _Fun(_VSTD::move(__f), _Alloc(__af));
-                __buf_.__large = __hold.release();
-            }
-        }
-    }
-
-    template <class _Fp, class = typename enable_if<!is_same<__decay_t<_Fp>, __policy_func>::value>::type>
-    _LIBCPP_INLINE_VISIBILITY explicit __policy_func(_Fp&& __f)
-        : __policy_(__policy::__create_empty()) {
-      typedef __default_alloc_func<_Fp, _Rp(_ArgTypes...)> _Fun;
-
-      if (__function::__not_null(__f)) {
-        __invoker_ = __invoker::template __create<_Fun>();
-        __policy_ = __policy::__create<_Fun>();
-        if (__use_small_storage<_Fun>()) {
-          ::new ((void*)&__buf_.__small) _Fun(_VSTD::move(__f));
-        } else {
-          __builtin_new_allocator::__holder_t __hold =
-              __builtin_new_allocator::__allocate_type<_Fun>(1);
-          __buf_.__large = ::new ((void*)__hold.get()) _Fun(_VSTD::move(__f));
-          (void)__hold.release();
-        }
-      }
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __policy_func(const __policy_func& __f)
-        : __buf_(__f.__buf_), __invoker_(__f.__invoker_),
-          __policy_(__f.__policy_)
-    {
-        if (__policy_->__clone)
-            __buf_.__large = __policy_->__clone(__f.__buf_.__large);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __policy_func(__policy_func&& __f)
-        : __buf_(__f.__buf_), __invoker_(__f.__invoker_),
-          __policy_(__f.__policy_)
-    {
-        if (__policy_->__destroy)
-        {
-            __f.__policy_ = __policy::__create_empty();
-            __f.__invoker_ = __invoker();
-        }
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    ~__policy_func()
-    {
-        if (__policy_->__destroy)
-            __policy_->__destroy(__buf_.__large);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __policy_func& operator=(__policy_func&& __f)
-    {
-        *this = nullptr;
-        __buf_ = __f.__buf_;
-        __invoker_ = __f.__invoker_;
-        __policy_ = __f.__policy_;
-        __f.__policy_ = __policy::__create_empty();
-        __f.__invoker_ = __invoker();
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __policy_func& operator=(nullptr_t)
-    {
-        const __policy* __p = __policy_;
-        __policy_ = __policy::__create_empty();
-        __invoker_ = __invoker();
-        if (__p->__destroy)
-            __p->__destroy(__buf_.__large);
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _Rp operator()(_ArgTypes&&... __args) const
-    {
-        return __invoker_.__call_(_VSTD::addressof(__buf_),
-                                  _VSTD::forward<_ArgTypes>(__args)...);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(__policy_func& __f)
-    {
-        _VSTD::swap(__invoker_, __f.__invoker_);
-        _VSTD::swap(__policy_, __f.__policy_);
-        _VSTD::swap(__buf_, __f.__buf_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const _NOEXCEPT
-    {
-        return !__policy_->__is_null;
-    }
-
-#ifndef _LIBCPP_HAS_NO_RTTI
-    _LIBCPP_INLINE_VISIBILITY
-    const std::type_info& target_type() const _NOEXCEPT
-    {
-        return *__policy_->__type_info;
-    }
-
-    template <typename _Tp>
-    _LIBCPP_INLINE_VISIBILITY const _Tp* target() const _NOEXCEPT
-    {
-        if (__policy_->__is_null || typeid(_Tp) != *__policy_->__type_info)
-            return nullptr;
-        if (__policy_->__clone) // Out of line storage.
-            return reinterpret_cast<const _Tp*>(__buf_.__large);
-        else
-            return reinterpret_cast<const _Tp*>(&__buf_.__small);
-    }
-#endif // _LIBCPP_HAS_NO_RTTI
-};
-
-#if defined(_LIBCPP_HAS_BLOCKS_RUNTIME)
-
-extern "C" void *_Block_copy(const void *);
-extern "C" void _Block_release(const void *);
-
-template<class _Rp1, class ..._ArgTypes1, class _Alloc, class _Rp, class ..._ArgTypes>
-class __func<_Rp1(^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)>
-    : public  __base<_Rp(_ArgTypes...)>
-{
-    typedef _Rp1(^__block_type)(_ArgTypes1...);
-    __block_type __f_;
+  // The policy that describes how to move / copy / destroy __buf_. Never
+  // null, even if the function is empty.
+  const __policy* __policy_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __func(__block_type const& __f)
-#ifdef _LIBCPP_HAS_OBJC_ARC
-        : __f_(__f)
-#else
-        : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr))
-#endif
-    { }
+  _LIBCPP_HIDE_FROM_ABI __policy_func() : __policy_(__policy::__create_empty()) {}
 
-    // [TODO] add && to save on a retain
+  template <class _Fp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI __policy_func(_Fp&& __f, const _Alloc& __a) : __policy_(__policy::__create_empty()) {
+    typedef __alloc_func<_Fp, _Alloc, _Rp(_ArgTypes...)> _Fun;
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    typedef __rebind_alloc<__alloc_traits, _Fun> _FunAlloc;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __func(__block_type __f, const _Alloc& /* unused */)
-#ifdef _LIBCPP_HAS_OBJC_ARC
-        : __f_(__f)
-#else
-        : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr))
-#endif
-    { }
+    if (__function::__not_null(__f)) {
+      __invoker_ = __invoker::template __create<_Fun>();
+      __policy_  = __policy::__create<_Fun>();
 
-    virtual __base<_Rp(_ArgTypes...)>* __clone() const {
-        _LIBCPP_ASSERT(false,
-            "Block pointers are just pointers, so they should always fit into "
-            "std::function's small buffer optimization. This function should "
-            "never be invoked.");
-        return nullptr;
+      _FunAlloc __af(__a);
+      if (__use_small_storage<_Fun>()) {
+        ::new ((void*)&__buf_.__small) _Fun(std::move(__f), _Alloc(__af));
+      } else {
+        typedef __allocator_destructor<_FunAlloc> _Dp;
+        unique_ptr<_Fun, _Dp> __hold(__af.allocate(1), _Dp(__af, 1));
+        ::new ((void*)__hold.get()) _Fun(std::move(__f), _Alloc(__af));
+        __buf_.__large = __hold.release();
+      }
     }
+  }
 
-    virtual void __clone(__base<_Rp(_ArgTypes...)>* __p) const {
-        ::new ((void*)__p) __func(__f_);
-    }
+  template <class _Fp, __enable_if_t<!is_same<__decay_t<_Fp>, __policy_func>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit __policy_func(_Fp&& __f) : __policy_(__policy::__create_empty()) {
+    typedef __default_alloc_func<_Fp, _Rp(_ArgTypes...)> _Fun;
 
-    virtual void destroy() _NOEXCEPT {
-#ifndef _LIBCPP_HAS_OBJC_ARC
-        if (__f_)
-            _Block_release(__f_);
-#endif
-        __f_ = 0;
+    if (__function::__not_null(__f)) {
+      __invoker_ = __invoker::template __create<_Fun>();
+      __policy_  = __policy::__create<_Fun>();
+      if (__use_small_storage<_Fun>()) {
+        ::new ((void*)&__buf_.__small) _Fun(std::move(__f));
+      } else {
+        __builtin_new_allocator::__holder_t __hold = __builtin_new_allocator::__allocate_type<_Fun>(1);
+        __buf_.__large                             = ::new ((void*)__hold.get()) _Fun(std::move(__f));
+        (void)__hold.release();
+      }
     }
+  }
 
-    virtual void destroy_deallocate() _NOEXCEPT {
-        _LIBCPP_ASSERT(false,
-            "Block pointers are just pointers, so they should always fit into "
-            "std::function's small buffer optimization. This function should "
-            "never be invoked.");
-    }
+  _LIBCPP_HIDE_FROM_ABI __policy_func(const __policy_func& __f)
+      : __buf_(__f.__buf_), __invoker_(__f.__invoker_), __policy_(__f.__policy_) {
+    if (__policy_->__clone)
+      __buf_.__large = __policy_->__clone(__f.__buf_.__large);
+  }
 
-    virtual _Rp operator()(_ArgTypes&& ... __arg) {
-        return _VSTD::__invoke(__f_, _VSTD::forward<_ArgTypes>(__arg)...);
+  _LIBCPP_HIDE_FROM_ABI __policy_func(__policy_func&& __f)
+      : __buf_(__f.__buf_), __invoker_(__f.__invoker_), __policy_(__f.__policy_) {
+    if (__policy_->__destroy) {
+      __f.__policy_  = __policy::__create_empty();
+      __f.__invoker_ = __invoker();
     }
+  }
 
-#ifndef _LIBCPP_HAS_NO_RTTI
-    virtual const void* target(type_info const& __ti) const _NOEXCEPT {
-        if (__ti == typeid(__func::__block_type))
-            return &__f_;
-        return (const void*)nullptr;
-    }
+  _LIBCPP_HIDE_FROM_ABI ~__policy_func() {
+    if (__policy_->__destroy)
+      __policy_->__destroy(__buf_.__large);
+  }
 
-    virtual const std::type_info& target_type() const _NOEXCEPT {
-        return typeid(__func::__block_type);
-    }
-#endif // _LIBCPP_HAS_NO_RTTI
+  _LIBCPP_HIDE_FROM_ABI __policy_func& operator=(__policy_func&& __f) {
+    *this          = nullptr;
+    __buf_         = __f.__buf_;
+    __invoker_     = __f.__invoker_;
+    __policy_      = __f.__policy_;
+    __f.__policy_  = __policy::__create_empty();
+    __f.__invoker_ = __invoker();
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __policy_func& operator=(nullptr_t) {
+    const __policy* __p = __policy_;
+    __policy_           = __policy::__create_empty();
+    __invoker_          = __invoker();
+    if (__p->__destroy)
+      __p->__destroy(__buf_.__large);
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes&&... __args) const {
+    return __invoker_.__call_(std::addressof(__buf_), std::forward<_ArgTypes>(__args)...);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(__policy_func& __f) {
+    std::swap(__invoker_, __f.__invoker_);
+    std::swap(__policy_, __f.__policy_);
+    std::swap(__buf_, __f.__buf_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return !__policy_->__is_null; }
+
+#  ifndef _LIBCPP_HAS_NO_RTTI
+  _LIBCPP_HIDE_FROM_ABI const std::type_info& target_type() const _NOEXCEPT { return *__policy_->__type_info; }
+
+  template <typename _Tp>
+  _LIBCPP_HIDE_FROM_ABI const _Tp* target() const _NOEXCEPT {
+    if (__policy_->__is_null || typeid(_Tp) != *__policy_->__type_info)
+      return nullptr;
+    if (__policy_->__clone) // Out of line storage.
+      return reinterpret_cast<const _Tp*>(__buf_.__large);
+    else
+      return reinterpret_cast<const _Tp*>(&__buf_.__small);
+  }
+#  endif // _LIBCPP_HAS_NO_RTTI
 };
 
-#endif // _LIBCPP_HAS_EXTENSION_BLOCKS
+#  if defined(_LIBCPP_HAS_BLOCKS_RUNTIME)
+
+extern "C" void* _Block_copy(const void*);
+extern "C" void _Block_release(const void*);
+
+template <class _Rp1, class... _ArgTypes1, class _Alloc, class _Rp, class... _ArgTypes>
+class __func<_Rp1 (^)(_ArgTypes1...), _Alloc, _Rp(_ArgTypes...)> : public __base<_Rp(_ArgTypes...)> {
+  typedef _Rp1 (^__block_type)(_ArgTypes1...);
+  __block_type __f_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit __func(__block_type const& __f)
+#    ifdef _LIBCPP_HAS_OBJC_ARC
+      : __f_(__f)
+#    else
+      : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr))
+#    endif
+  {
+  }
+
+  // [TODO] add && to save on a retain
+
+  _LIBCPP_HIDE_FROM_ABI explicit __func(__block_type __f, const _Alloc& /* unused */)
+#    ifdef _LIBCPP_HAS_OBJC_ARC
+      : __f_(__f)
+#    else
+      : __f_(reinterpret_cast<__block_type>(__f ? _Block_copy(__f) : nullptr))
+#    endif
+  {
+  }
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual __base<_Rp(_ArgTypes...)>* __clone() const {
+    _LIBCPP_ASSERT_INTERNAL(
+        false,
+        "Block pointers are just pointers, so they should always fit into "
+        "std::function's small buffer optimization. This function should "
+        "never be invoked.");
+    return nullptr;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __clone(__base<_Rp(_ArgTypes...)>* __p) const {
+    ::new ((void*)__p) __func(__f_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy() _NOEXCEPT {
+#    ifndef _LIBCPP_HAS_OBJC_ARC
+    if (__f_)
+      _Block_release(__f_);
+#    endif
+    __f_ = 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy_deallocate() _NOEXCEPT {
+    _LIBCPP_ASSERT_INTERNAL(
+        false,
+        "Block pointers are just pointers, so they should always fit into "
+        "std::function's small buffer optimization. This function should "
+        "never be invoked.");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual _Rp operator()(_ArgTypes&&... __arg) {
+    return std::__invoke(__f_, std::forward<_ArgTypes>(__arg)...);
+  }
+
+#    ifndef _LIBCPP_HAS_NO_RTTI
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual const void* target(type_info const& __ti) const _NOEXCEPT {
+    if (__ti == typeid(__func::__block_type))
+      return &__f_;
+    return (const void*)nullptr;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual const std::type_info& target_type() const _NOEXCEPT {
+    return typeid(__func::__block_type);
+  }
+#    endif // _LIBCPP_HAS_NO_RTTI
+};
+
+#  endif // _LIBCPP_HAS_EXTENSION_BLOCKS
 
 } // namespace __function
 
-template<class _Rp, class ..._ArgTypes>
+template <class _Rp, class... _ArgTypes>
 class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>
     : public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
-      public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
-{
-#ifndef _LIBCPP_ABI_OPTIMIZED_FUNCTION
-    typedef __function::__value_func<_Rp(_ArgTypes...)> __func;
-#else
-    typedef __function::__policy_func<_Rp(_ArgTypes...)> __func;
-#endif
+      public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)> {
+#  ifndef _LIBCPP_ABI_OPTIMIZED_FUNCTION
+  typedef __function::__value_func<_Rp(_ArgTypes...)> __func;
+#  else
+  typedef __function::__policy_func<_Rp(_ArgTypes...)> __func;
+#  endif
 
-    __func __f_;
+  __func __f_;
 
-    template <class _Fp, bool = _And<
-        _IsNotSame<__remove_cvref_t<_Fp>, function>,
-        __invokable<_Fp, _ArgTypes...>
-    >::value>
-    struct __callable;
-    template <class _Fp>
-        struct __callable<_Fp, true>
-        {
-            static const bool value = is_void<_Rp>::value ||
-                __is_core_convertible<typename __invoke_of<_Fp, _ArgTypes...>::type,
-                                      _Rp>::value;
-        };
-    template <class _Fp>
-        struct __callable<_Fp, false>
-        {
-            static const bool value = false;
-        };
+  template <class _Fp,
+            bool = _And< _IsNotSame<__remove_cvref_t<_Fp>, function>, __invokable<_Fp, _ArgTypes...> >::value>
+  struct __callable;
+  template <class _Fp>
+  struct __callable<_Fp, true> {
+    static const bool value =
+        is_void<_Rp>::value || __is_core_convertible<typename __invoke_of<_Fp, _ArgTypes...>::type, _Rp>::value;
+  };
+  template <class _Fp>
+  struct __callable<_Fp, false> {
+    static const bool value = false;
+  };
 
   template <class _Fp>
-  using _EnableIfLValueCallable = typename enable_if<__callable<_Fp&>::value>::type;
+  using _EnableIfLValueCallable = __enable_if_t<__callable<_Fp&>::value>;
+
 public:
-    typedef _Rp result_type;
+  typedef _Rp result_type;
 
-    // construct/copy/destroy:
-    _LIBCPP_INLINE_VISIBILITY
-    function() _NOEXCEPT { }
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_HIDE_FROM_ABI function(nullptr_t) _NOEXCEPT {}
-    _LIBCPP_HIDE_FROM_ABI function(const function&);
-    _LIBCPP_HIDE_FROM_ABI function(function&&) _NOEXCEPT;
-    template<class _Fp, class = _EnableIfLValueCallable<_Fp>>
-    _LIBCPP_HIDE_FROM_ABI function(_Fp);
+  // construct/copy/destroy:
+  _LIBCPP_HIDE_FROM_ABI function() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI function(nullptr_t) _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI function(const function&);
+  _LIBCPP_HIDE_FROM_ABI function(function&&) _NOEXCEPT;
+  template <class _Fp, class = _EnableIfLValueCallable<_Fp>>
+  _LIBCPP_HIDE_FROM_ABI function(_Fp);
 
-#if _LIBCPP_STD_VER <= 14
-    template<class _Alloc>
-      _LIBCPP_INLINE_VISIBILITY
-      function(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
-    template<class _Alloc>
-      _LIBCPP_INLINE_VISIBILITY
-      function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT {}
-    template<class _Alloc>
-    _LIBCPP_HIDE_FROM_ABI function(allocator_arg_t, const _Alloc&, const function&);
-    template<class _Alloc>
-    _LIBCPP_HIDE_FROM_ABI function(allocator_arg_t, const _Alloc&, function&&);
-    template<class _Fp, class _Alloc, class = _EnableIfLValueCallable<_Fp>>
-    _LIBCPP_HIDE_FROM_ABI function(allocator_arg_t, const _Alloc& __a, _Fp __f);
-#endif
+#  if _LIBCPP_STD_VER <= 14
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI function(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI function(allocator_arg_t, const _Alloc&, const function&);
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI function(allocator_arg_t, const _Alloc&, function&&);
+  template <class _Fp, class _Alloc, class = _EnableIfLValueCallable<_Fp>>
+  _LIBCPP_HIDE_FROM_ABI function(allocator_arg_t, const _Alloc& __a, _Fp __f);
+#  endif
 
-    _LIBCPP_HIDE_FROM_ABI function& operator=(const function&);
-    _LIBCPP_HIDE_FROM_ABI function& operator=(function&&) _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI function& operator=(nullptr_t) _NOEXCEPT;
-    template<class _Fp, class = _EnableIfLValueCallable<__decay_t<_Fp>>>
-    _LIBCPP_HIDE_FROM_ABI function& operator=(_Fp&&);
+  _LIBCPP_HIDE_FROM_ABI function& operator=(const function&);
+  _LIBCPP_HIDE_FROM_ABI function& operator=(function&&) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI function& operator=(nullptr_t) _NOEXCEPT;
+  template <class _Fp, class = _EnableIfLValueCallable<__decay_t<_Fp>>>
+  _LIBCPP_HIDE_FROM_ABI function& operator=(_Fp&&);
 
-    _LIBCPP_HIDE_FROM_ABI ~function();
+  _LIBCPP_HIDE_FROM_ABI ~function();
 
-    // function modifiers:
-    _LIBCPP_HIDE_FROM_ABI void swap(function&) _NOEXCEPT;
+  // function modifiers:
+  _LIBCPP_HIDE_FROM_ABI void swap(function&) _NOEXCEPT;
 
-#if _LIBCPP_STD_VER <= 14
-    template<class _Fp, class _Alloc>
-      _LIBCPP_INLINE_VISIBILITY
-      void assign(_Fp&& __f, const _Alloc& __a)
-        {function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
-#endif
+#  if _LIBCPP_STD_VER <= 14
+  template <class _Fp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI void assign(_Fp&& __f, const _Alloc& __a) {
+    function(allocator_arg, __a, std::forward<_Fp>(__f)).swap(*this);
+  }
+#  endif
 
-    // function capacity:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const _NOEXCEPT {
-      return static_cast<bool>(__f_);
-    }
+  // function capacity:
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return static_cast<bool>(__f_); }
+
+  // deleted overloads close possible hole in the type system
+  template <class _R2, class... _ArgTypes2>
+  bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
+#  if _LIBCPP_STD_VER <= 17
+  template <class _R2, class... _ArgTypes2>
+  bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
+#  endif
 
-    // deleted overloads close possible hole in the type system
-    template<class _R2, class... _ArgTypes2>
-      bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
-    template<class _R2, class... _ArgTypes2>
-      bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
 public:
-    // function invocation:
-    _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes...) const;
+  // function invocation:
+  _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes...) const;
 
-#ifndef _LIBCPP_HAS_NO_RTTI
-    // function target access:
-    _LIBCPP_HIDE_FROM_ABI const std::type_info& target_type() const _NOEXCEPT;
-    template <typename _Tp>
-    _LIBCPP_HIDE_FROM_ABI _Tp* target() _NOEXCEPT;
-    template <typename _Tp>
-    _LIBCPP_HIDE_FROM_ABI const _Tp* target() const _NOEXCEPT;
-#endif // _LIBCPP_HAS_NO_RTTI
+#  ifndef _LIBCPP_HAS_NO_RTTI
+  // function target access:
+  _LIBCPP_HIDE_FROM_ABI const std::type_info& target_type() const _NOEXCEPT;
+  template <typename _Tp>
+  _LIBCPP_HIDE_FROM_ABI _Tp* target() _NOEXCEPT;
+  template <typename _Tp>
+  _LIBCPP_HIDE_FROM_ABI const _Tp* target() const _NOEXCEPT;
+#  endif // _LIBCPP_HAS_NO_RTTI
 };
 
-#if _LIBCPP_STD_VER >= 17
-template<class _Rp, class ..._Ap>
-function(_Rp(*)(_Ap...)) -> function<_Rp(_Ap...)>;
+#  if _LIBCPP_STD_VER >= 17
+template <class _Rp, class... _Ap>
+function(_Rp (*)(_Ap...)) -> function<_Rp(_Ap...)>;
 
-template<class _Fp, class _Stripped = typename __strip_signature<decltype(&_Fp::operator())>::type>
+template <class _Fp, class _Stripped = typename __strip_signature<decltype(&_Fp::operator())>::type>
 function(_Fp) -> function<_Stripped>;
-#endif // _LIBCPP_STD_VER >= 17
+#  endif // _LIBCPP_STD_VER >= 17
 
-template<class _Rp, class ..._ArgTypes>
+template <class _Rp, class... _ArgTypes>
 function<_Rp(_ArgTypes...)>::function(const function& __f) : __f_(__f.__f_) {}
 
-#if _LIBCPP_STD_VER <= 14
-template<class _Rp, class ..._ArgTypes>
+#  if _LIBCPP_STD_VER <= 14
+template <class _Rp, class... _ArgTypes>
 template <class _Alloc>
-function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
-                                     const function& __f) : __f_(__f.__f_) {}
-#endif
+function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, const function& __f) : __f_(__f.__f_) {}
+#  endif
 
 template <class _Rp, class... _ArgTypes>
-function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
-    : __f_(_VSTD::move(__f.__f_)) {}
+function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT : __f_(std::move(__f.__f_)) {}
 
-#if _LIBCPP_STD_VER <= 14
-template<class _Rp, class ..._ArgTypes>
+#  if _LIBCPP_STD_VER <= 14
+template <class _Rp, class... _ArgTypes>
 template <class _Alloc>
-function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
-                                      function&& __f)
-    : __f_(_VSTD::move(__f.__f_)) {}
-#endif
+function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&, function&& __f) : __f_(std::move(__f.__f_)) {}
+#  endif
 
 template <class _Rp, class... _ArgTypes>
 template <class _Fp, class>
-function<_Rp(_ArgTypes...)>::function(_Fp __f) : __f_(_VSTD::move(__f)) {}
+function<_Rp(_ArgTypes...)>::function(_Fp __f) : __f_(std::move(__f)) {}
 
-#if _LIBCPP_STD_VER <= 14
+#  if _LIBCPP_STD_VER <= 14
 template <class _Rp, class... _ArgTypes>
 template <class _Fp, class _Alloc, class>
-function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a,
-                                      _Fp __f)
-    : __f_(_VSTD::move(__f), __a) {}
-#endif
+function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a, _Fp __f) : __f_(std::move(__f), __a) {}
+#  endif
 
-template<class _Rp, class ..._ArgTypes>
-function<_Rp(_ArgTypes...)>&
-function<_Rp(_ArgTypes...)>::operator=(const function& __f)
-{
-    function(__f).swap(*this);
-    return *this;
+template <class _Rp, class... _ArgTypes>
+function<_Rp(_ArgTypes...)>& function<_Rp(_ArgTypes...)>::operator=(const function& __f) {
+  function(__f).swap(*this);
+  return *this;
 }
 
-template<class _Rp, class ..._ArgTypes>
-function<_Rp(_ArgTypes...)>&
-function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
-{
-    __f_ = _VSTD::move(__f.__f_);
-    return *this;
+template <class _Rp, class... _ArgTypes>
+function<_Rp(_ArgTypes...)>& function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT {
+  __f_ = std::move(__f.__f_);
+  return *this;
 }
 
-template<class _Rp, class ..._ArgTypes>
-function<_Rp(_ArgTypes...)>&
-function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
-{
-    __f_ = nullptr;
-    return *this;
+template <class _Rp, class... _ArgTypes>
+function<_Rp(_ArgTypes...)>& function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT {
+  __f_ = nullptr;
+  return *this;
 }
 
-template<class _Rp, class ..._ArgTypes>
+template <class _Rp, class... _ArgTypes>
 template <class _Fp, class>
-function<_Rp(_ArgTypes...)>&
-function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
-{
-    function(_VSTD::forward<_Fp>(__f)).swap(*this);
-    return *this;
+function<_Rp(_ArgTypes...)>& function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f) {
+  function(std::forward<_Fp>(__f)).swap(*this);
+  return *this;
 }
 
-template<class _Rp, class ..._ArgTypes>
+template <class _Rp, class... _ArgTypes>
 function<_Rp(_ArgTypes...)>::~function() {}
 
-template<class _Rp, class ..._ArgTypes>
-void
-function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
-{
-    __f_.swap(__f.__f_);
+template <class _Rp, class... _ArgTypes>
+void function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT {
+  __f_.swap(__f.__f_);
 }
 
-template<class _Rp, class ..._ArgTypes>
-_Rp
-function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
-{
-    return __f_(_VSTD::forward<_ArgTypes>(__arg)...);
+template <class _Rp, class... _ArgTypes>
+_Rp function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const {
+  return __f_(std::forward<_ArgTypes>(__arg)...);
 }
 
-#ifndef _LIBCPP_HAS_NO_RTTI
+#  ifndef _LIBCPP_HAS_NO_RTTI
 
-template<class _Rp, class ..._ArgTypes>
-const std::type_info&
-function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
-{
-    return __f_.target_type();
+template <class _Rp, class... _ArgTypes>
+const std::type_info& function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT {
+  return __f_.target_type();
 }
 
-template<class _Rp, class ..._ArgTypes>
+template <class _Rp, class... _ArgTypes>
 template <typename _Tp>
-_Tp*
-function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
-{
-    return (_Tp*)(__f_.template target<_Tp>());
+_Tp* function<_Rp(_ArgTypes...)>::target() _NOEXCEPT {
+  return (_Tp*)(__f_.template target<_Tp>());
 }
 
-template<class _Rp, class ..._ArgTypes>
+template <class _Rp, class... _ArgTypes>
 template <typename _Tp>
-const _Tp*
-function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
-{
-    return __f_.template target<_Tp>();
+const _Tp* function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT {
+  return __f_.template target<_Tp>();
 }
 
-#endif // _LIBCPP_HAS_NO_RTTI
+#  endif // _LIBCPP_HAS_NO_RTTI
 
 template <class _Rp, class... _ArgTypes>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {
+  return !__f;
+}
+
+#  if _LIBCPP_STD_VER <= 17
 
 template <class _Rp, class... _ArgTypes>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {
+  return !__f;
+}
 
 template <class _Rp, class... _ArgTypes>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {
+  return (bool)__f;
+}
 
 template <class _Rp, class... _ArgTypes>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {
+  return (bool)__f;
+}
+
+#  endif // _LIBCPP_STD_VER <= 17
 
 template <class _Rp, class... _ArgTypes>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
-{return __x.swap(__y);}
+inline _LIBCPP_HIDE_FROM_ABI void swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT {
+  return __x.swap(__y);
+}
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_CXX03_LANG
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___FUNCTIONAL_FUNCTION_H
diff --git a/third_party/libcxx/__functional/hash.h b/third_party/libcxx/__functional/hash.h
index fa09748b1..a9e450edd 100644
--- a/third_party/libcxx/__functional/hash.h
+++ b/third_party/libcxx/__functional/hash.h
@@ -10,23 +10,18 @@
 #define _LIBCPP___FUNCTIONAL_HASH_H
 
 #include <__config>
-#include <__functional/invoke.h>
 #include <__functional/unary_function.h>
-#include <__fwd/hash.h>
-#include <__tuple/sfinae_helpers.h>
-#include <__type_traits/is_copy_constructible.h>
-#include <__type_traits/is_default_constructible.h>
+#include <__fwd/functional.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/invoke.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/is_enum.h>
-#include <__type_traits/is_move_constructible.h>
 #include <__type_traits/underlying_type.h>
-#include <__utility/forward.h>
-#include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
-#include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -35,133 +30,117 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Size>
-inline _LIBCPP_HIDE_FROM_ABI
-_Size
-__loadword(const void* __p)
-{
-    _Size __r;
-    _VSTD::memcpy(&__r, __p, sizeof(__r));
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI _Size __loadword(const void* __p) {
+  _Size __r;
+  std::memcpy(&__r, __p, sizeof(__r));
+  return __r;
 }
 
 // We use murmur2 when size_t is 32 bits, and cityhash64 when size_t
 // is 64 bits.  This is because cityhash64 uses 64bit x 64bit
 // multiplication, which can be very slow on 32-bit systems.
-template <class _Size, size_t = sizeof(_Size)*__CHAR_BIT__>
+template <class _Size, size_t = sizeof(_Size) * __CHAR_BIT__>
 struct __murmur2_or_cityhash;
 
 template <class _Size>
-struct __murmur2_or_cityhash<_Size, 32>
-{
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-    _Size operator()(const void* __key, _Size __len) const {
-      // murmur2
-      const _Size __m = 0x5bd1e995;
-      const _Size __r = 24;
-      _Size __h = __len;
-      const unsigned char* __data = static_cast<const unsigned char*>(__key);
-      for (; __len >= 4; __data += 4, __len -= 4)
-      {
-          _Size __k = std::__loadword<_Size>(__data);
-          __k *= __m;
-          __k ^= __k >> __r;
-          __k *= __m;
-          __h *= __m;
-          __h ^= __k;
-      }
-      switch (__len)
-      {
-      case 3:
-          __h ^= static_cast<_Size>(__data[2] << 16);
-          _LIBCPP_FALLTHROUGH();
-      case 2:
-          __h ^= static_cast<_Size>(__data[1] << 8);
-          _LIBCPP_FALLTHROUGH();
-      case 1:
-          __h ^= __data[0];
-          __h *= __m;
-      }
-      __h ^= __h >> 13;
+struct __murmur2_or_cityhash<_Size, 32> {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK _Size
+  operator()(const void* __key, _Size __len) const {
+    // murmur2
+    const _Size __m             = 0x5bd1e995;
+    const _Size __r             = 24;
+    _Size __h                   = __len;
+    const unsigned char* __data = static_cast<const unsigned char*>(__key);
+    for (; __len >= 4; __data += 4, __len -= 4) {
+      _Size __k = std::__loadword<_Size>(__data);
+      __k *= __m;
+      __k ^= __k >> __r;
+      __k *= __m;
       __h *= __m;
-      __h ^= __h >> 15;
-      return __h;
+      __h ^= __k;
     }
+    switch (__len) {
+    case 3:
+      __h ^= static_cast<_Size>(__data[2] << 16);
+      _LIBCPP_FALLTHROUGH();
+    case 2:
+      __h ^= static_cast<_Size>(__data[1] << 8);
+      _LIBCPP_FALLTHROUGH();
+    case 1:
+      __h ^= __data[0];
+      __h *= __m;
+    }
+    __h ^= __h >> 13;
+    __h *= __m;
+    __h ^= __h >> 15;
+    return __h;
+  }
 };
 
 template <class _Size>
-struct __murmur2_or_cityhash<_Size, 64>
-{
+struct __murmur2_or_cityhash<_Size, 64> {
   // cityhash64
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-  _Size operator()(const void* __key, _Size __len) const {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK _Size
+  operator()(const void* __key, _Size __len) const {
     const char* __s = static_cast<const char*>(__key);
     if (__len <= 32) {
-        if (__len <= 16) {
+      if (__len <= 16) {
         return __hash_len_0_to_16(__s, __len);
-        } else {
+      } else {
         return __hash_len_17_to_32(__s, __len);
-        }
+      }
     } else if (__len <= 64) {
-        return __hash_len_33_to_64(__s, __len);
+      return __hash_len_33_to_64(__s, __len);
     }
 
     // For strings over 64 bytes we hash the end first, and then as we
     // loop we keep 56 bytes of state: v, w, x, y, and z.
     _Size __x = std::__loadword<_Size>(__s + __len - 40);
-    _Size __y = std::__loadword<_Size>(__s + __len - 16) +
-                std::__loadword<_Size>(__s + __len - 56);
-    _Size __z = __hash_len_16(std::__loadword<_Size>(__s + __len - 48) + __len,
-                            std::__loadword<_Size>(__s + __len - 24));
+    _Size __y = std::__loadword<_Size>(__s + __len - 16) + std::__loadword<_Size>(__s + __len - 56);
+    _Size __z =
+        __hash_len_16(std::__loadword<_Size>(__s + __len - 48) + __len, std::__loadword<_Size>(__s + __len - 24));
     pair<_Size, _Size> __v = __weak_hash_len_32_with_seeds(__s + __len - 64, __len, __z);
     pair<_Size, _Size> __w = __weak_hash_len_32_with_seeds(__s + __len - 32, __y + __k1, __x);
-    __x = __x * __k1 + std::__loadword<_Size>(__s);
+    __x                    = __x * __k1 + std::__loadword<_Size>(__s);
 
     // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
     __len = (__len - 1) & ~static_cast<_Size>(63);
     do {
-        __x = __rotate(__x + __y + __v.first + std::__loadword<_Size>(__s + 8), 37) * __k1;
-        __y = __rotate(__y + __v.second + std::__loadword<_Size>(__s + 48), 42) * __k1;
-        __x ^= __w.second;
-        __y += __v.first + std::__loadword<_Size>(__s + 40);
-        __z = __rotate(__z + __w.first, 33) * __k1;
-        __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first);
-        __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second,
-                                            __y + std::__loadword<_Size>(__s + 16));
-        _VSTD::swap(__z, __x);
-        __s += 64;
-        __len -= 64;
+      __x = __rotate(__x + __y + __v.first + std::__loadword<_Size>(__s + 8), 37) * __k1;
+      __y = __rotate(__y + __v.second + std::__loadword<_Size>(__s + 48), 42) * __k1;
+      __x ^= __w.second;
+      __y += __v.first + std::__loadword<_Size>(__s + 40);
+      __z = __rotate(__z + __w.first, 33) * __k1;
+      __v = __weak_hash_len_32_with_seeds(__s, __v.second * __k1, __x + __w.first);
+      __w = __weak_hash_len_32_with_seeds(__s + 32, __z + __w.second, __y + std::__loadword<_Size>(__s + 16));
+      std::swap(__z, __x);
+      __s += 64;
+      __len -= 64;
     } while (__len != 0);
-    return __hash_len_16(
-        __hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z,
-        __hash_len_16(__v.second, __w.second) + __x);
+    return __hash_len_16(__hash_len_16(__v.first, __w.first) + __shift_mix(__y) * __k1 + __z,
+                         __hash_len_16(__v.second, __w.second) + __x);
   }
 
-  private:
-    // Some primes between 2^63 and 2^64.
-    static const _Size __k0 = 0xc3a5c85c97cb3127ULL;
-    static const _Size __k1 = 0xb492b66fbe98f273ULL;
-    static const _Size __k2 = 0x9ae16a3b2f90404fULL;
-    static const _Size __k3 = 0xc949d7c7509e6557ULL;
+private:
+  // Some primes between 2^63 and 2^64.
+  static const _Size __k0 = 0xc3a5c85c97cb3127ULL;
+  static const _Size __k1 = 0xb492b66fbe98f273ULL;
+  static const _Size __k2 = 0x9ae16a3b2f90404fULL;
+  static const _Size __k3 = 0xc949d7c7509e6557ULL;
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _Size __rotate(_Size __val, int __shift) {
+  _LIBCPP_HIDE_FROM_ABI static _Size __rotate(_Size __val, int __shift) {
     return __shift == 0 ? __val : ((__val >> __shift) | (__val << (64 - __shift)));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _Size __rotate_by_at_least_1(_Size __val, int __shift) {
+  _LIBCPP_HIDE_FROM_ABI static _Size __rotate_by_at_least_1(_Size __val, int __shift) {
     return (__val >> __shift) | (__val << (64 - __shift));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static _Size __shift_mix(_Size __val) {
-    return __val ^ (__val >> 47);
-  }
+  _LIBCPP_HIDE_FROM_ABI static _Size __shift_mix(_Size __val) { return __val ^ (__val >> 47); }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-  static _Size __hash_len_16(_Size __u, _Size __v) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK static _Size __hash_len_16(_Size __u, _Size __v) {
     const _Size __mul = 0x9ddfea08eb382d69ULL;
-    _Size __a = (__u ^ __v) * __mul;
+    _Size __a         = (__u ^ __v) * __mul;
     __a ^= (__a >> 47);
     _Size __b = (__v ^ __a) * __mul;
     __b ^= (__b >> 47);
@@ -169,8 +148,8 @@ struct __murmur2_or_cityhash<_Size, 64>
     return __b;
   }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-  static _Size __hash_len_0_to_16(const char* __s, _Size __len) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK static _Size
+  __hash_len_0_to_16(const char* __s, _Size __len) {
     if (__len > 8) {
       const _Size __a = std::__loadword<_Size>(__s);
       const _Size __b = std::__loadword<_Size>(__s + __len - 8);
@@ -189,32 +168,29 @@ struct __murmur2_or_cityhash<_Size, 64>
       const unsigned char __a = static_cast<unsigned char>(__s[0]);
       const unsigned char __b = static_cast<unsigned char>(__s[__len >> 1]);
       const unsigned char __c = static_cast<unsigned char>(__s[__len - 1]);
-      const uint32_t __y = static_cast<uint32_t>(__a) +
-                           (static_cast<uint32_t>(__b) << 8);
-      const uint32_t __z = __len + (static_cast<uint32_t>(__c) << 2);
+      const uint32_t __y      = static_cast<uint32_t>(__a) + (static_cast<uint32_t>(__b) << 8);
+      const uint32_t __z      = __len + (static_cast<uint32_t>(__c) << 2);
       return __shift_mix(__y * __k2 ^ __z * __k3) * __k2;
     }
     return __k2;
   }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-  static _Size __hash_len_17_to_32(const char *__s, _Size __len) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK static _Size
+  __hash_len_17_to_32(const char* __s, _Size __len) {
     const _Size __a = std::__loadword<_Size>(__s) * __k1;
     const _Size __b = std::__loadword<_Size>(__s + 8);
     const _Size __c = std::__loadword<_Size>(__s + __len - 8) * __k2;
     const _Size __d = std::__loadword<_Size>(__s + __len - 16) * __k0;
-    return __hash_len_16(__rotate(__a - __b, 43) + __rotate(__c, 30) + __d,
-                         __a + __rotate(__b ^ __k3, 20) - __c + __len);
+    return __hash_len_16(
+        __rotate(__a - __b, 43) + __rotate(__c, 30) + __d, __a + __rotate(__b ^ __k3, 20) - __c + __len);
   }
 
   // Return a 16-byte hash for 48 bytes.  Quick and dirty.
   // Callers do best to use "random-looking" values for a and b.
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-  static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
-      _Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b)
-  {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK static pair<_Size, _Size>
+  __weak_hash_len_32_with_seeds(_Size __w, _Size __x, _Size __y, _Size __z, _Size __a, _Size __b) {
     __a += __w;
-    __b = __rotate(__b + __a + __z, 21);
+    __b             = __rotate(__b + __a + __z, 21);
     const _Size __c = __a;
     __a += __x;
     __a += __y;
@@ -223,24 +199,22 @@ struct __murmur2_or_cityhash<_Size, 64>
   }
 
   // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-  static pair<_Size, _Size> __weak_hash_len_32_with_seeds(
-      const char* __s, _Size __a, _Size __b)
-  {
-    return __weak_hash_len_32_with_seeds(std::__loadword<_Size>(__s),
-                                         std::__loadword<_Size>(__s + 8),
-                                         std::__loadword<_Size>(__s + 16),
-                                         std::__loadword<_Size>(__s + 24),
-                                         __a,
-                                         __b);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK static pair<_Size, _Size>
+  __weak_hash_len_32_with_seeds(const char* __s, _Size __a, _Size __b) {
+    return __weak_hash_len_32_with_seeds(
+        std::__loadword<_Size>(__s),
+        std::__loadword<_Size>(__s + 8),
+        std::__loadword<_Size>(__s + 16),
+        std::__loadword<_Size>(__s + 24),
+        __a,
+        __b);
   }
 
   // Return an 8-byte hash for 33 to 64 bytes.
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-  static _Size __hash_len_33_to_64(const char *__s, size_t __len) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK static _Size
+  __hash_len_33_to_64(const char* __s, size_t __len) {
     _Size __z = std::__loadword<_Size>(__s + 24);
-    _Size __a = std::__loadword<_Size>(__s) +
-                (__len + std::__loadword<_Size>(__s + __len - 16)) * __k0;
+    _Size __a = std::__loadword<_Size>(__s) + (__len + std::__loadword<_Size>(__s + __len - 16)) * __k0;
     _Size __b = __rotate(__a + __z, 52);
     _Size __c = __rotate(__a, 37);
     __a += std::__loadword<_Size>(__s + 8);
@@ -248,7 +222,7 @@ struct __murmur2_or_cityhash<_Size, 64>
     __a += std::__loadword<_Size>(__s + 16);
     _Size __vf = __a + __z;
     _Size __vs = __b + __rotate(__a, 31) + __c;
-    __a = std::__loadword<_Size>(__s + 16) + std::__loadword<_Size>(__s + __len - 32);
+    __a        = std::__loadword<_Size>(__s + 16) + std::__loadword<_Size>(__s + __len - 32);
     __z += std::__loadword<_Size>(__s + __len - 8);
     __b = __rotate(__a + __z, 52);
     __c = __rotate(__a, 37);
@@ -257,7 +231,7 @@ struct __murmur2_or_cityhash<_Size, 64>
     __a += std::__loadword<_Size>(__s + __len - 16);
     _Size __wf = __a + __z;
     _Size __ws = __b + __rotate(__a, 31) + __c;
-    _Size __r = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0);
+    _Size __r  = __shift_mix((__vf + __ws) * __k2 + (__wf + __vs) * __k0);
     return __shift_mix(__r * __k0 + __vs) * __k2;
   }
 };
@@ -266,104 +240,76 @@ template <class _Tp, size_t = sizeof(_Tp) / sizeof(size_t)>
 struct __scalar_hash;
 
 template <class _Tp>
-struct __scalar_hash<_Tp, 0>
-    : public __unary_function<_Tp, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(_Tp __v) const _NOEXCEPT
-    {
-        union
-        {
-            _Tp    __t;
-            size_t __a;
-        } __u;
-        __u.__a = 0;
-        __u.__t = __v;
-        return __u.__a;
-    }
+struct __scalar_hash<_Tp, 0> : public __unary_function<_Tp, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(_Tp __v) const _NOEXCEPT {
+    union {
+      _Tp __t;
+      size_t __a;
+    } __u;
+    __u.__a = 0;
+    __u.__t = __v;
+    return __u.__a;
+  }
 };
 
 template <class _Tp>
-struct __scalar_hash<_Tp, 1>
-    : public __unary_function<_Tp, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(_Tp __v) const _NOEXCEPT
-    {
-        union
-        {
-            _Tp    __t;
-            size_t __a;
-        } __u;
-        __u.__t = __v;
-        return __u.__a;
-    }
+struct __scalar_hash<_Tp, 1> : public __unary_function<_Tp, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(_Tp __v) const _NOEXCEPT {
+    union {
+      _Tp __t;
+      size_t __a;
+    } __u;
+    __u.__t = __v;
+    return __u.__a;
+  }
 };
 
 template <class _Tp>
-struct __scalar_hash<_Tp, 2>
-    : public __unary_function<_Tp, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(_Tp __v) const _NOEXCEPT
-    {
-        union
-        {
-            _Tp __t;
-            struct
-            {
-                size_t __a;
-                size_t __b;
-            } __s;
-        } __u;
-        __u.__t = __v;
-        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
-    }
+struct __scalar_hash<_Tp, 2> : public __unary_function<_Tp, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(_Tp __v) const _NOEXCEPT {
+    union {
+      _Tp __t;
+      struct {
+        size_t __a;
+        size_t __b;
+      } __s;
+    } __u;
+    __u.__t = __v;
+    return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
+  }
 };
 
 template <class _Tp>
-struct __scalar_hash<_Tp, 3>
-    : public __unary_function<_Tp, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(_Tp __v) const _NOEXCEPT
-    {
-        union
-        {
-            _Tp __t;
-            struct
-            {
-                size_t __a;
-                size_t __b;
-                size_t __c;
-            } __s;
-        } __u;
-        __u.__t = __v;
-        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
-    }
+struct __scalar_hash<_Tp, 3> : public __unary_function<_Tp, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(_Tp __v) const _NOEXCEPT {
+    union {
+      _Tp __t;
+      struct {
+        size_t __a;
+        size_t __b;
+        size_t __c;
+      } __s;
+    } __u;
+    __u.__t = __v;
+    return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
+  }
 };
 
 template <class _Tp>
-struct __scalar_hash<_Tp, 4>
-    : public __unary_function<_Tp, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(_Tp __v) const _NOEXCEPT
-    {
-        union
-        {
-            _Tp __t;
-            struct
-            {
-                size_t __a;
-                size_t __b;
-                size_t __c;
-                size_t __d;
-            } __s;
-        } __u;
-        __u.__t = __v;
-        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
-    }
+struct __scalar_hash<_Tp, 4> : public __unary_function<_Tp, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(_Tp __v) const _NOEXCEPT {
+    union {
+      _Tp __t;
+      struct {
+        size_t __a;
+        size_t __b;
+        size_t __c;
+        size_t __d;
+      } __s;
+    } __u;
+    __u.__t = __v;
+    return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
+  }
 };
 
 struct _PairT {
@@ -371,314 +317,223 @@ struct _PairT {
   size_t second;
 };
 
-_LIBCPP_HIDE_FROM_ABI
-inline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT {
-    typedef __scalar_hash<_PairT> _HashT;
-    const _PairT __p = {__lhs, __rhs};
-    return _HashT()(__p);
+_LIBCPP_HIDE_FROM_ABI inline size_t __hash_combine(size_t __lhs, size_t __rhs) _NOEXCEPT {
+  typedef __scalar_hash<_PairT> _HashT;
+  const _PairT __p = {__lhs, __rhs};
+  return _HashT()(__p);
 }
 
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS hash<_Tp*>
-    : public __unary_function<_Tp*, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(_Tp* __v) const _NOEXCEPT
-    {
-        union
-        {
-            _Tp* __t;
-            size_t __a;
-        } __u;
-        __u.__t = __v;
-        return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
-    }
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS hash<_Tp*> : public __unary_function<_Tp*, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(_Tp* __v) const _NOEXCEPT {
+    union {
+      _Tp* __t;
+      size_t __a;
+    } __u;
+    __u.__t = __v;
+    return __murmur2_or_cityhash<size_t>()(&__u, sizeof(__u));
+  }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<bool>
-    : public __unary_function<bool, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<bool> : public __unary_function<bool, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(bool __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<char>
-    : public __unary_function<char, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<char> : public __unary_function<char, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(char __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<signed char>
-    : public __unary_function<signed char, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<signed char> : public __unary_function<signed char, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(signed char __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<unsigned char>
-    : public __unary_function<unsigned char, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned char> : public __unary_function<unsigned char, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(unsigned char __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<char8_t>
-    : public __unary_function<char8_t, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(char8_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<char8_t> : public __unary_function<char8_t, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(char8_t __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 #endif // !_LIBCPP_HAS_NO_CHAR8_T
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<char16_t>
-    : public __unary_function<char16_t, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<char16_t> : public __unary_function<char16_t, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(char16_t __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<char32_t>
-    : public __unary_function<char32_t, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<char32_t> : public __unary_function<char32_t, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(char32_t __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<wchar_t>
-    : public __unary_function<wchar_t, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<wchar_t> : public __unary_function<wchar_t, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(wchar_t __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<short>
-    : public __unary_function<short, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<short> : public __unary_function<short, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(short __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<unsigned short>
-    : public __unary_function<unsigned short, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned short> : public __unary_function<unsigned short, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(unsigned short __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<int>
-    : public __unary_function<int, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<int> : public __unary_function<int, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(int __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<unsigned int>
-    : public __unary_function<unsigned int, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned int> : public __unary_function<unsigned int, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(unsigned int __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<long>
-    : public __unary_function<long, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<long> : public __unary_function<long, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(long __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<unsigned long>
-    : public __unary_function<unsigned long, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned long> : public __unary_function<unsigned long, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(unsigned long __v) const _NOEXCEPT { return static_cast<size_t>(__v); }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<long long>
-    : public __scalar_hash<long long>
-{
-};
+struct _LIBCPP_TEMPLATE_VIS hash<long long> : public __scalar_hash<long long> {};
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<unsigned long long>
-    : public __scalar_hash<unsigned long long>
-{
-};
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned long long> : public __scalar_hash<unsigned long long> {};
 
 #ifndef _LIBCPP_HAS_NO_INT128
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<__int128_t>
-    : public __scalar_hash<__int128_t>
-{
-};
+struct _LIBCPP_TEMPLATE_VIS hash<__int128_t> : public __scalar_hash<__int128_t> {};
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<__uint128_t>
-    : public __scalar_hash<__uint128_t>
-{
-};
+struct _LIBCPP_TEMPLATE_VIS hash<__uint128_t> : public __scalar_hash<__uint128_t> {};
 
 #endif
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<float>
-    : public __scalar_hash<float>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(float __v) const _NOEXCEPT
-    {
-        // -0.0 and 0.0 should return same hash
-       if (__v == 0.0f)
-           return 0;
-        return __scalar_hash<float>::operator()(__v);
-    }
+struct _LIBCPP_TEMPLATE_VIS hash<float> : public __scalar_hash<float> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(float __v) const _NOEXCEPT {
+    // -0.0 and 0.0 should return same hash
+    if (__v == 0.0f)
+      return 0;
+    return __scalar_hash<float>::operator()(__v);
+  }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<double>
-    : public __scalar_hash<double>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(double __v) const _NOEXCEPT
-    {
-        // -0.0 and 0.0 should return same hash
-       if (__v == 0.0)
-           return 0;
-        return __scalar_hash<double>::operator()(__v);
-    }
+struct _LIBCPP_TEMPLATE_VIS hash<double> : public __scalar_hash<double> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(double __v) const _NOEXCEPT {
+    // -0.0 and 0.0 should return same hash
+    if (__v == 0.0)
+      return 0;
+    return __scalar_hash<double>::operator()(__v);
+  }
 };
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<long double>
-    : public __scalar_hash<long double>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(long double __v) const _NOEXCEPT
-    {
-        // -0.0 and 0.0 should return same hash
-        if (__v == 0.0L)
-            return 0;
+struct _LIBCPP_TEMPLATE_VIS hash<long double> : public __scalar_hash<long double> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(long double __v) const _NOEXCEPT {
+    // -0.0 and 0.0 should return same hash
+    if (__v == 0.0L)
+      return 0;
 #if defined(__i386__) || (defined(__x86_64__) && defined(__ILP32__))
-        // Zero out padding bits
-        union
-        {
-            long double __t;
-            struct
-            {
-                size_t __a;
-                size_t __b;
-                size_t __c;
-                size_t __d;
-            } __s;
-        } __u;
-        __u.__s.__a = 0;
-        __u.__s.__b = 0;
-        __u.__s.__c = 0;
-        __u.__s.__d = 0;
-        __u.__t = __v;
-        return __u.__s.__a ^ __u.__s.__b ^ __u.__s.__c ^ __u.__s.__d;
+    // Zero out padding bits
+    union {
+      long double __t;
+      struct {
+        size_t __a;
+        size_t __b;
+        size_t __c;
+        size_t __d;
+      } __s;
+    } __u;
+    __u.__s.__a = 0;
+    __u.__s.__b = 0;
+    __u.__s.__c = 0;
+    __u.__s.__d = 0;
+    __u.__t     = __v;
+    return __u.__s.__a ^ __u.__s.__b ^ __u.__s.__c ^ __u.__s.__d;
 #elif defined(__x86_64__)
-        // Zero out padding bits
-        union
-        {
-            long double __t;
-            struct
-            {
-                size_t __a;
-                size_t __b;
-            } __s;
-        } __u;
-        __u.__s.__a = 0;
-        __u.__s.__b = 0;
-        __u.__t = __v;
-        return __u.__s.__a ^ __u.__s.__b;
+    // Zero out padding bits
+    union {
+      long double __t;
+      struct {
+        size_t __a;
+        size_t __b;
+      } __s;
+    } __u;
+    __u.__s.__a = 0;
+    __u.__s.__b = 0;
+    __u.__t     = __v;
+    return __u.__s.__a ^ __u.__s.__b;
 #else
-        return __scalar_hash<long double>::operator()(__v);
+    return __scalar_hash<long double>::operator()(__v);
 #endif
-    }
+  }
 };
 
 template <class _Tp, bool = is_enum<_Tp>::value>
-struct _LIBCPP_TEMPLATE_VIS __enum_hash
-    : public __unary_function<_Tp, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(_Tp __v) const _NOEXCEPT
-    {
-        typedef typename underlying_type<_Tp>::type type;
-        return hash<type>()(static_cast<type>(__v));
-    }
+struct _LIBCPP_TEMPLATE_VIS __enum_hash : public __unary_function<_Tp, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(_Tp __v) const _NOEXCEPT {
+    typedef typename underlying_type<_Tp>::type type;
+    return hash<type>()(static_cast<type>(__v));
+  }
 };
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS __enum_hash<_Tp, false> {
-    __enum_hash() = delete;
-    __enum_hash(__enum_hash const&) = delete;
-    __enum_hash& operator=(__enum_hash const&) = delete;
+  __enum_hash()                              = delete;
+  __enum_hash(__enum_hash const&)            = delete;
+  __enum_hash& operator=(__enum_hash const&) = delete;
 };
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS hash : public __enum_hash<_Tp>
-{
-};
+struct _LIBCPP_TEMPLATE_VIS hash : public __enum_hash<_Tp> {};
 
 #if _LIBCPP_STD_VER >= 17
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<nullptr_t>
-  : public __unary_function<nullptr_t, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI
-    size_t operator()(nullptr_t) const _NOEXCEPT {
-        return 662607004ull;
-    }
+struct _LIBCPP_TEMPLATE_VIS hash<nullptr_t> : public __unary_function<nullptr_t, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(nullptr_t) const _NOEXCEPT { return 662607004ull; }
 };
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Key, class _Hash>
-using __check_hash_requirements _LIBCPP_NODEBUG = integral_constant<bool,
-    is_copy_constructible<_Hash>::value &&
-    is_move_constructible<_Hash>::value &&
-    __invokable_r<size_t, _Hash, _Key const&>::value
->;
+using __check_hash_requirements _LIBCPP_NODEBUG =
+    integral_constant<bool,
+                      is_copy_constructible<_Hash>::value && is_move_constructible<_Hash>::value &&
+                          __invokable_r<size_t, _Hash, _Key const&>::value >;
 
 template <class _Key, class _Hash = hash<_Key> >
-using __has_enabled_hash _LIBCPP_NODEBUG = integral_constant<bool,
-    __check_hash_requirements<_Key, _Hash>::value &&
-    is_default_constructible<_Hash>::value
->;
+using __has_enabled_hash _LIBCPP_NODEBUG =
+    integral_constant<bool, __check_hash_requirements<_Key, _Hash>::value && is_default_constructible<_Hash>::value >;
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Type, class>
 using __enable_hash_helper_imp _LIBCPP_NODEBUG = _Type;
 
-template <class _Type, class ..._Keys>
-using __enable_hash_helper _LIBCPP_NODEBUG = __enable_hash_helper_imp<_Type,
-  typename enable_if<__all<__has_enabled_hash<_Keys>::value...>::value>::type
->;
-#else
-template <class _Type, class ...>
+template <class _Type, class... _Keys>
+using __enable_hash_helper _LIBCPP_NODEBUG =
+    __enable_hash_helper_imp<_Type, __enable_if_t<__all<__has_enabled_hash<_Keys>::value...>::value> >;
+#  else
+template <class _Type, class...>
 using __enable_hash_helper _LIBCPP_NODEBUG = _Type;
-#endif
+#  endif
 
 #endif // !_LIBCPP_CXX03_LANG
 
diff --git a/third_party/libcxx/__functional/identity.h b/third_party/libcxx/__functional/identity.h
index 5dffedf67..8468de3da 100644
--- a/third_party/libcxx/__functional/identity.h
+++ b/third_party/libcxx/__functional/identity.h
@@ -11,6 +11,7 @@
 #define _LIBCPP___FUNCTIONAL_IDENTITY_H
 
 #include <__config>
+#include <__fwd/functional.h>
 #include <__type_traits/integral_constant.h>
 #include <__utility/forward.h>
 
@@ -34,21 +35,28 @@ struct __identity {
 
 template <>
 struct __is_identity<__identity> : true_type {};
+template <>
+struct __is_identity<reference_wrapper<__identity> > : true_type {};
+template <>
+struct __is_identity<reference_wrapper<const __identity> > : true_type {};
 
 #if _LIBCPP_STD_VER >= 20
 
 struct identity {
-    template<class _Tp>
-    _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator()(_Tp&& __t) const noexcept
-    {
-        return _VSTD::forward<_Tp>(__t);
-    }
+  template <class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator()(_Tp&& __t) const noexcept {
+    return std::forward<_Tp>(__t);
+  }
 
-    using is_transparent = void;
+  using is_transparent = void;
 };
 
 template <>
 struct __is_identity<identity> : true_type {};
+template <>
+struct __is_identity<reference_wrapper<identity> > : true_type {};
+template <>
+struct __is_identity<reference_wrapper<const identity> > : true_type {};
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__functional/invoke.h b/third_party/libcxx/__functional/invoke.h
index a7dd31107..ef4bf25f0 100644
--- a/third_party/libcxx/__functional/invoke.h
+++ b/third_party/libcxx/__functional/invoke.h
@@ -22,12 +22,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-template <class _Fn, class ..._Args>
+template <class _Fn, class... _Args>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 invoke_result_t<_Fn, _Args...>
-invoke(_Fn&& __f, _Args&&... __args)
-    noexcept(is_nothrow_invocable_v<_Fn, _Args...>)
-{
-    return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
+invoke(_Fn&& __f, _Args&&... __args) noexcept(is_nothrow_invocable_v<_Fn, _Args...>) {
+  return std::__invoke(std::forward<_Fn>(__f), std::forward<_Args>(__args)...);
 }
 
 #endif // _LIBCPP_STD_VER >= 17
@@ -37,17 +35,17 @@ template <class _Result, class _Fn, class... _Args>
   requires is_invocable_r_v<_Result, _Fn, _Args...>
 _LIBCPP_HIDE_FROM_ABI constexpr _Result
 invoke_r(_Fn&& __f, _Args&&... __args) noexcept(is_nothrow_invocable_r_v<_Result, _Fn, _Args...>) {
-    if constexpr (is_void_v<_Result>) {
-        static_cast<void>(std::invoke(std::forward<_Fn>(__f), std::forward<_Args>(__args)...));
-    } else {
-        // TODO: Use reference_converts_from_temporary_v once implemented
-        // using _ImplicitInvokeResult = invoke_result_t<_Fn, _Args...>;
-        // static_assert(!reference_converts_from_temporary_v<_Result, _ImplicitInvokeResult>,
-        static_assert(true,
-            "Returning from invoke_r would bind a temporary object to the reference return type, "
-            "which would result in a dangling reference.");
-        return std::invoke(std::forward<_Fn>(__f), std::forward<_Args>(__args)...);
-    }
+  if constexpr (is_void_v<_Result>) {
+    static_cast<void>(std::invoke(std::forward<_Fn>(__f), std::forward<_Args>(__args)...));
+  } else {
+    // TODO: Use reference_converts_from_temporary_v once implemented
+    // using _ImplicitInvokeResult = invoke_result_t<_Fn, _Args...>;
+    // static_assert(!reference_converts_from_temporary_v<_Result, _ImplicitInvokeResult>,
+    static_assert(true,
+                  "Returning from invoke_r would bind a temporary object to the reference return type, "
+                  "which would result in a dangling reference.");
+    return std::invoke(std::forward<_Fn>(__f), std::forward<_Args>(__args)...);
+  }
 }
 #endif
 
diff --git a/third_party/libcxx/__functional/is_transparent.h b/third_party/libcxx/__functional/is_transparent.h
index c539a07d6..b2d62f2e3 100644
--- a/third_party/libcxx/__functional/is_transparent.h
+++ b/third_party/libcxx/__functional/is_transparent.h
@@ -11,7 +11,6 @@
 #define _LIBCPP___FUNCTIONAL_IS_TRANSPARENT
 
 #include <__config>
-#include <__type_traits/integral_constant.h>
 #include <__type_traits/void_t.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -23,11 +22,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 14
 
 template <class _Tp, class, class = void>
-struct __is_transparent : false_type {};
+inline const bool __is_transparent_v = false;
 
 template <class _Tp, class _Up>
-struct __is_transparent<_Tp, _Up, __void_t<typename _Tp::is_transparent> >
-   : true_type {};
+inline const bool __is_transparent_v<_Tp, _Up, __void_t<typename _Tp::is_transparent> > = true;
 
 #endif
 
diff --git a/third_party/libcxx/__functional/mem_fn.h b/third_party/libcxx/__functional/mem_fn.h
index fe221dd12..ee07a7177 100644
--- a/third_party/libcxx/__functional/mem_fn.h
+++ b/third_party/libcxx/__functional/mem_fn.h
@@ -23,34 +23,30 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-class __mem_fn : public __weak_result_type<_Tp>
-{
+class __mem_fn : public __weak_result_type<_Tp> {
 public:
-    // types
-    typedef _Tp type;
+  // types
+  typedef _Tp type;
+
 private:
-    type __f_;
+  type __f_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    __mem_fn(type __f) _NOEXCEPT : __f_(__f) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __mem_fn(type __f) _NOEXCEPT : __f_(__f) {}
 
-    // invoke
-    template <class... _ArgTypes>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
+  // invoke
+  template <class... _ArgTypes>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
 
-    typename __invoke_return<type, _ArgTypes...>::type
-    operator() (_ArgTypes&&... __args) const {
-        return std::__invoke(__f_, std::forward<_ArgTypes>(__args)...);
-    }
+  typename __invoke_return<type, _ArgTypes...>::type
+  operator()(_ArgTypes&&... __args) const {
+    return std::__invoke(__f_, std::forward<_ArgTypes>(__args)...);
+  }
 };
 
-template<class _Rp, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-__mem_fn<_Rp _Tp::*>
-mem_fn(_Rp _Tp::* __pm) _NOEXCEPT
-{
-    return __mem_fn<_Rp _Tp::*>(__pm);
+template <class _Rp, class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __mem_fn<_Rp _Tp::*> mem_fn(_Rp _Tp::*__pm) _NOEXCEPT {
+  return __mem_fn<_Rp _Tp::*>(__pm);
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__functional/mem_fun_ref.h b/third_party/libcxx/__functional/mem_fun_ref.h
index 65aab0696..c344420b0 100644
--- a/third_party/libcxx/__functional/mem_fun_ref.h
+++ b/third_party/libcxx/__functional/mem_fun_ref.h
@@ -22,149 +22,122 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
-template<class _Sp, class _Tp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_t
-    : public __unary_function<_Tp*, _Sp>
-{
-    _Sp (_Tp::*__p_)();
-public:
-    _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const
-        {return (__p->*__p_)();}
-};
-
-template<class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_t
-    : public __binary_function<_Tp*, _Ap, _Sp>
-{
-    _Sp (_Tp::*__p_)(_Ap);
-public:
-    _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const
-        {return (__p->*__p_)(__x);}
-};
-
-template<class _Sp, class _Tp>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-mem_fun_t<_Sp,_Tp>
-mem_fun(_Sp (_Tp::*__f)())
-    {return mem_fun_t<_Sp,_Tp>(__f);}
-
-template<class _Sp, class _Tp, class _Ap>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-mem_fun1_t<_Sp,_Tp,_Ap>
-mem_fun(_Sp (_Tp::*__f)(_Ap))
-    {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
-
-template<class _Sp, class _Tp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_ref_t
-    : public __unary_function<_Tp, _Sp>
-{
-    _Sp (_Tp::*__p_)();
-public:
-    _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const
-        {return (__p.*__p_)();}
-};
-
-template<class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_ref_t
-    : public __binary_function<_Tp, _Ap, _Sp>
-{
-    _Sp (_Tp::*__p_)(_Ap);
-public:
-    _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const
-        {return (__p.*__p_)(__x);}
-};
-
-template<class _Sp, class _Tp>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-mem_fun_ref_t<_Sp,_Tp>
-mem_fun_ref(_Sp (_Tp::*__f)())
-    {return mem_fun_ref_t<_Sp,_Tp>(__f);}
-
-template<class _Sp, class _Tp, class _Ap>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-mem_fun1_ref_t<_Sp,_Tp,_Ap>
-mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
-    {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
-
 template <class _Sp, class _Tp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_t
-    : public __unary_function<const _Tp*, _Sp>
-{
-    _Sp (_Tp::*__p_)() const;
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_t : public __unary_function<_Tp*, _Sp> {
+  _Sp (_Tp::*__p_)();
+
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const
-        {return (__p->*__p_)();}
+  _LIBCPP_HIDE_FROM_ABI explicit mem_fun_t(_Sp (_Tp::*__p)()) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI _Sp operator()(_Tp* __p) const { return (__p->*__p_)(); }
 };
 
 template <class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_t
-    : public __binary_function<const _Tp*, _Ap, _Sp>
-{
-    _Sp (_Tp::*__p_)(_Ap) const;
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_t : public __binary_function<_Tp*, _Ap, _Sp> {
+  _Sp (_Tp::*__p_)(_Ap);
+
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const
-        {return (__p->*__p_)(__x);}
+  _LIBCPP_HIDE_FROM_ABI explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap)) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI _Sp operator()(_Tp* __p, _Ap __x) const { return (__p->*__p_)(__x); }
 };
 
 template <class _Sp, class _Tp>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-const_mem_fun_t<_Sp,_Tp>
-mem_fun(_Sp (_Tp::*__f)() const)
-    {return const_mem_fun_t<_Sp,_Tp>(__f);}
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI mem_fun_t<_Sp, _Tp> mem_fun(_Sp (_Tp::*__f)()) {
+  return mem_fun_t<_Sp, _Tp>(__f);
+}
 
 template <class _Sp, class _Tp, class _Ap>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-const_mem_fun1_t<_Sp,_Tp,_Ap>
-mem_fun(_Sp (_Tp::*__f)(_Ap) const)
-    {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI mem_fun1_t<_Sp, _Tp, _Ap> mem_fun(_Sp (_Tp::*__f)(_Ap)) {
+  return mem_fun1_t<_Sp, _Tp, _Ap>(__f);
+}
 
 template <class _Sp, class _Tp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_ref_t
-    : public __unary_function<_Tp, _Sp>
-{
-    _Sp (_Tp::*__p_)() const;
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_ref_t : public __unary_function<_Tp, _Sp> {
+  _Sp (_Tp::*__p_)();
+
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const
-        {return (__p.*__p_)();}
+  _LIBCPP_HIDE_FROM_ABI explicit mem_fun_ref_t(_Sp (_Tp::*__p)()) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI _Sp operator()(_Tp& __p) const { return (__p.*__p_)(); }
 };
 
 template <class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_ref_t
-    : public __binary_function<_Tp, _Ap, _Sp>
-{
-    _Sp (_Tp::*__p_)(_Ap) const;
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_ref_t : public __binary_function<_Tp, _Ap, _Sp> {
+  _Sp (_Tp::*__p_)(_Ap);
+
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const
-        {return (__p.*__p_)(__x);}
+  _LIBCPP_HIDE_FROM_ABI explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap)) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI _Sp operator()(_Tp& __p, _Ap __x) const { return (__p.*__p_)(__x); }
 };
 
 template <class _Sp, class _Tp>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-const_mem_fun_ref_t<_Sp,_Tp>
-mem_fun_ref(_Sp (_Tp::*__f)() const)
-    {return const_mem_fun_ref_t<_Sp,_Tp>(__f);}
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI mem_fun_ref_t<_Sp, _Tp> mem_fun_ref(_Sp (_Tp::*__f)()) {
+  return mem_fun_ref_t<_Sp, _Tp>(__f);
+}
 
 template <class _Sp, class _Tp, class _Ap>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-const_mem_fun1_ref_t<_Sp,_Tp,_Ap>
-mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const)
-    {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI mem_fun1_ref_t<_Sp, _Tp, _Ap>
+mem_fun_ref(_Sp (_Tp::*__f)(_Ap)) {
+  return mem_fun1_ref_t<_Sp, _Tp, _Ap>(__f);
+}
+
+template <class _Sp, class _Tp>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_t : public __unary_function<const _Tp*, _Sp> {
+  _Sp (_Tp::*__p_)() const;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit const_mem_fun_t(_Sp (_Tp::*__p)() const) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI _Sp operator()(const _Tp* __p) const { return (__p->*__p_)(); }
+};
+
+template <class _Sp, class _Tp, class _Ap>
+class _LIBCPP_TEMPLATE_VIS
+_LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_t : public __binary_function<const _Tp*, _Ap, _Sp> {
+  _Sp (_Tp::*__p_)(_Ap) const;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI _Sp operator()(const _Tp* __p, _Ap __x) const { return (__p->*__p_)(__x); }
+};
+
+template <class _Sp, class _Tp>
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI const_mem_fun_t<_Sp, _Tp> mem_fun(_Sp (_Tp::*__f)() const) {
+  return const_mem_fun_t<_Sp, _Tp>(__f);
+}
+
+template <class _Sp, class _Tp, class _Ap>
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI const_mem_fun1_t<_Sp, _Tp, _Ap>
+mem_fun(_Sp (_Tp::*__f)(_Ap) const) {
+  return const_mem_fun1_t<_Sp, _Tp, _Ap>(__f);
+}
+
+template <class _Sp, class _Tp>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_ref_t : public __unary_function<_Tp, _Sp> {
+  _Sp (_Tp::*__p_)() const;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI _Sp operator()(const _Tp& __p) const { return (__p.*__p_)(); }
+};
+
+template <class _Sp, class _Tp, class _Ap>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_ref_t : public __binary_function<_Tp, _Ap, _Sp> {
+  _Sp (_Tp::*__p_)(_Ap) const;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI _Sp operator()(const _Tp& __p, _Ap __x) const { return (__p.*__p_)(__x); }
+};
+
+template <class _Sp, class _Tp>
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI const_mem_fun_ref_t<_Sp, _Tp>
+mem_fun_ref(_Sp (_Tp::*__f)() const) {
+  return const_mem_fun_ref_t<_Sp, _Tp>(__f);
+}
+
+template <class _Sp, class _Tp, class _Ap>
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI const_mem_fun1_ref_t<_Sp, _Tp, _Ap>
+mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const) {
+  return const_mem_fun1_ref_t<_Sp, _Tp, _Ap>(__f);
+}
 
 #endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
diff --git a/third_party/libcxx/__functional/not_fn.h b/third_party/libcxx/__functional/not_fn.h
index 0cdb1b7e2..4b3ce5524 100644
--- a/third_party/libcxx/__functional/not_fn.h
+++ b/third_party/libcxx/__functional/not_fn.h
@@ -16,7 +16,6 @@
 #include <__type_traits/decay.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_constructible.h>
-#include <__type_traits/is_move_constructible.h>
 #include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -28,26 +27,23 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 17
 
 struct __not_fn_op {
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 auto operator()(_Args&&... __args) const
-        noexcept(noexcept(!_VSTD::invoke(_VSTD::forward<_Args>(__args)...)))
-        -> decltype(      !_VSTD::invoke(_VSTD::forward<_Args>(__args)...))
-        { return          !_VSTD::invoke(_VSTD::forward<_Args>(__args)...); }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 auto operator()(_Args&&... __args) const
+      noexcept(noexcept(!std::invoke(std::forward<_Args>(__args)...)))
+          -> decltype(!std::invoke(std::forward<_Args>(__args)...)) {
+    return !std::invoke(std::forward<_Args>(__args)...);
+  }
 };
 
 template <class _Fn>
 struct __not_fn_t : __perfect_forward<__not_fn_op, _Fn> {
-    using __perfect_forward<__not_fn_op, _Fn>::__perfect_forward;
+  using __perfect_forward<__not_fn_op, _Fn>::__perfect_forward;
 };
 
-template <class _Fn, class = enable_if_t<
-    is_constructible_v<decay_t<_Fn>, _Fn> &&
-    is_move_constructible_v<decay_t<_Fn>>
->>
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_CONSTEXPR_SINCE_CXX20 auto not_fn(_Fn&& __f) {
-    return __not_fn_t<decay_t<_Fn>>(_VSTD::forward<_Fn>(__f));
+template <class _Fn,
+          class = enable_if_t< is_constructible_v<decay_t<_Fn>, _Fn> && is_move_constructible_v<decay_t<_Fn>> >>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 auto not_fn(_Fn&& __f) {
+  return __not_fn_t<decay_t<_Fn>>(std::forward<_Fn>(__f));
 }
 
 #endif // _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/__functional/operations.h b/third_party/libcxx/__functional/operations.h
index 3d0c3641b..0a6320f19 100644
--- a/third_party/libcxx/__functional/operations.h
+++ b/third_party/libcxx/__functional/operations.h
@@ -13,8 +13,7 @@
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/unary_function.h>
-#include <__type_traits/integral_constant.h>
-#include <__type_traits/predicate_traits.h>
+#include <__type_traits/desugars_to.h>
 #include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -30,27 +29,32 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS plus
-    : __binary_function<_Tp, _Tp, _Tp>
-{
-    typedef _Tp __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x + __y;}
+struct _LIBCPP_TEMPLATE_VIS plus : __binary_function<_Tp, _Tp, _Tp> {
+  typedef _Tp __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x + __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(plus);
 
+// The non-transparent std::plus specialization is only equivalent to a raw plus
+// operator when we don't perform an implicit conversion when calling it.
+template <class _Tp>
+inline const bool __desugars_to_v<__plus_tag, plus<_Tp>, _Tp, _Tp> = true;
+
+template <class _Tp, class _Up>
+inline const bool __desugars_to_v<__plus_tag, plus<void>, _Tp, _Up> = true;
+
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS plus<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS plus<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) + std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) + std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) + std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -59,27 +63,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS minus
-    : __binary_function<_Tp, _Tp, _Tp>
-{
-    typedef _Tp __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x - __y;}
+struct _LIBCPP_TEMPLATE_VIS minus : __binary_function<_Tp, _Tp, _Tp> {
+  typedef _Tp __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x - __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(minus);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS minus<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS minus<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) - std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) - std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) - std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -88,27 +89,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS multiplies
-    : __binary_function<_Tp, _Tp, _Tp>
-{
-    typedef _Tp __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x * __y;}
+struct _LIBCPP_TEMPLATE_VIS multiplies : __binary_function<_Tp, _Tp, _Tp> {
+  typedef _Tp __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x * __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(multiplies);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS multiplies<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS multiplies<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) * std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) * std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) * std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -117,27 +115,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS divides
-    : __binary_function<_Tp, _Tp, _Tp>
-{
-    typedef _Tp __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x / __y;}
+struct _LIBCPP_TEMPLATE_VIS divides : __binary_function<_Tp, _Tp, _Tp> {
+  typedef _Tp __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x / __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(divides);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS divides<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS divides<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) / std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) / std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) / std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -146,27 +141,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS modulus
-    : __binary_function<_Tp, _Tp, _Tp>
-{
-    typedef _Tp __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x % __y;}
+struct _LIBCPP_TEMPLATE_VIS modulus : __binary_function<_Tp, _Tp, _Tp> {
+  typedef _Tp __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x % __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(modulus);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS modulus<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS modulus<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) % std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) % std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) % std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -175,27 +167,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS negate
-    : __unary_function<_Tp, _Tp>
-{
-    typedef _Tp __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return -__x;}
+struct _LIBCPP_TEMPLATE_VIS negate : __unary_function<_Tp, _Tp> {
+  typedef _Tp __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return -__x; }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(negate);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS negate<void>
-{
-    template <class _Tp>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_Tp&& __x) const
-        noexcept(noexcept(- _VSTD::forward<_Tp>(__x)))
-        -> decltype(      - _VSTD::forward<_Tp>(__x))
-        { return          - _VSTD::forward<_Tp>(__x); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS negate<void> {
+  template <class _Tp>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_Tp&& __x) const
+      noexcept(noexcept(-std::forward<_Tp>(__x))) //
+      -> decltype(-std::forward<_Tp>(__x)) {
+    return -std::forward<_Tp>(__x);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -206,51 +193,43 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS bit_and
-    : __binary_function<_Tp, _Tp, _Tp>
-{
-    typedef _Tp __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x & __y;}
+struct _LIBCPP_TEMPLATE_VIS bit_and : __binary_function<_Tp, _Tp, _Tp> {
+  typedef _Tp __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x & __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_and);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS bit_and<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS bit_and<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) &
+                        std::forward<_T2>(__u))) -> decltype(std::forward<_T1>(__t) & std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) & std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
 #if _LIBCPP_STD_VER >= 14
 template <class _Tp = void>
-struct _LIBCPP_TEMPLATE_VIS bit_not
-    : __unary_function<_Tp, _Tp>
-{
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return ~__x;}
+struct _LIBCPP_TEMPLATE_VIS bit_not : __unary_function<_Tp, _Tp> {
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return ~__x; }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_not);
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS bit_not<void>
-{
-    template <class _Tp>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_Tp&& __x) const
-        noexcept(noexcept(~_VSTD::forward<_Tp>(__x)))
-        -> decltype(      ~_VSTD::forward<_Tp>(__x))
-        { return          ~_VSTD::forward<_Tp>(__x); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS bit_not<void> {
+  template <class _Tp>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_Tp&& __x) const
+      noexcept(noexcept(~std::forward<_Tp>(__x))) //
+      -> decltype(~std::forward<_Tp>(__x)) {
+    return ~std::forward<_Tp>(__x);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -259,27 +238,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS bit_or
-    : __binary_function<_Tp, _Tp, _Tp>
-{
-    typedef _Tp __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x | __y;}
+struct _LIBCPP_TEMPLATE_VIS bit_or : __binary_function<_Tp, _Tp, _Tp> {
+  typedef _Tp __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x | __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_or);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS bit_or<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS bit_or<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) | std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) | std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) | std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -288,27 +264,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS bit_xor
-    : __binary_function<_Tp, _Tp, _Tp>
-{
-    typedef _Tp __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x ^ __y;}
+struct _LIBCPP_TEMPLATE_VIS bit_xor : __binary_function<_Tp, _Tp, _Tp> {
+  typedef _Tp __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x ^ __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(bit_xor);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS bit_xor<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS bit_xor<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) ^ std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) ^ std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) ^ std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -319,64 +292,59 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS equal_to
-    : __binary_function<_Tp, _Tp, bool>
-{
-    typedef bool __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x == __y;}
+struct _LIBCPP_TEMPLATE_VIS equal_to : __binary_function<_Tp, _Tp, bool> {
+  typedef bool __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x == __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(equal_to);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS equal_to<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS equal_to<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) == std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) == std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) == std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
+// The non-transparent std::equal_to specialization is only equivalent to a raw equality
+// comparison when we don't perform an implicit conversion when calling it.
 template <class _Tp>
-struct __is_trivial_equality_predicate<equal_to<_Tp>, _Tp, _Tp> : true_type {};
+inline const bool __desugars_to_v<__equal_tag, equal_to<_Tp>, _Tp, _Tp> = true;
 
-#if _LIBCPP_STD_VER >= 14
-template <class _Tp>
-struct __is_trivial_equality_predicate<equal_to<>, _Tp, _Tp> : true_type {};
-#endif
+// In the transparent case, we do not enforce that
+template <class _Tp, class _Up>
+inline const bool __desugars_to_v<__equal_tag, equal_to<void>, _Tp, _Up> = true;
 
 #if _LIBCPP_STD_VER >= 14
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS not_equal_to
-    : __binary_function<_Tp, _Tp, bool>
-{
-    typedef bool __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x != __y;}
+struct _LIBCPP_TEMPLATE_VIS not_equal_to : __binary_function<_Tp, _Tp, bool> {
+  typedef bool __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x != __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(not_equal_to);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS not_equal_to<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS not_equal_to<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) != std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) != std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) != std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -385,28 +353,31 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS less
-    : __binary_function<_Tp, _Tp, bool>
-{
-    typedef bool __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x < __y;}
+struct _LIBCPP_TEMPLATE_VIS less : __binary_function<_Tp, _Tp, bool> {
+  typedef bool __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x < __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less);
 
+template <class _Tp>
+inline const bool __desugars_to_v<__less_tag, less<_Tp>, _Tp, _Tp> = true;
+
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS less<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS less<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) < std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) < std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) < std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
+
+template <class _Tp>
+inline const bool __desugars_to_v<__less_tag, less<>, _Tp, _Tp> = true;
 #endif
 
 #if _LIBCPP_STD_VER >= 14
@@ -414,27 +385,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS less_equal
-    : __binary_function<_Tp, _Tp, bool>
-{
-    typedef bool __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x <= __y;}
+struct _LIBCPP_TEMPLATE_VIS less_equal : __binary_function<_Tp, _Tp, bool> {
+  typedef bool __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x <= __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(less_equal);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS less_equal<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS less_equal<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) <= std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) <= std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) <= std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -443,27 +411,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS greater_equal
-    : __binary_function<_Tp, _Tp, bool>
-{
-    typedef bool __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x >= __y;}
+struct _LIBCPP_TEMPLATE_VIS greater_equal : __binary_function<_Tp, _Tp, bool> {
+  typedef bool __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x >= __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater_equal);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS greater_equal<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS greater_equal<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) >=
+                        std::forward<_T2>(__u))) -> decltype(std::forward<_T1>(__t) >= std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) >= std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -472,27 +437,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS greater
-    : __binary_function<_Tp, _Tp, bool>
-{
-    typedef bool __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x > __y;}
+struct _LIBCPP_TEMPLATE_VIS greater : __binary_function<_Tp, _Tp, bool> {
+  typedef bool __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x > __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(greater);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS greater<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS greater<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) > std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) > std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) > std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -503,27 +465,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS logical_and
-    : __binary_function<_Tp, _Tp, bool>
-{
-    typedef bool __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x && __y;}
+struct _LIBCPP_TEMPLATE_VIS logical_and : __binary_function<_Tp, _Tp, bool> {
+  typedef bool __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x && __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_and);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS logical_and<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS logical_and<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) && std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) && std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) && std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -532,27 +491,22 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS logical_not
-    : __unary_function<_Tp, bool>
-{
-    typedef bool __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Tp& __x) const
-        {return !__x;}
+struct _LIBCPP_TEMPLATE_VIS logical_not : __unary_function<_Tp, bool> {
+  typedef bool __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x) const { return !__x; }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_not);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS logical_not<void>
-{
-    template <class _Tp>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_Tp&& __x) const
-        noexcept(noexcept(!_VSTD::forward<_Tp>(__x)))
-        -> decltype(      !_VSTD::forward<_Tp>(__x))
-        { return          !_VSTD::forward<_Tp>(__x); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS logical_not<void> {
+  template <class _Tp>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_Tp&& __x) const
+      noexcept(noexcept(!std::forward<_Tp>(__x))) //
+      -> decltype(!std::forward<_Tp>(__x)) {
+    return !std::forward<_Tp>(__x);
+  }
+  typedef void is_transparent;
 };
 #endif
 
@@ -561,27 +515,24 @@ template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS logical_or
-    : __binary_function<_Tp, _Tp, bool>
-{
-    typedef bool __result_type;  // used by valarray
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x || __y;}
+struct _LIBCPP_TEMPLATE_VIS logical_or : __binary_function<_Tp, _Tp, bool> {
+  typedef bool __result_type; // used by valarray
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
+    return __x || __y;
+  }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(logical_or);
 
 #if _LIBCPP_STD_VER >= 14
 template <>
-struct _LIBCPP_TEMPLATE_VIS logical_or<void>
-{
-    template <class _T1, class _T2>
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    auto operator()(_T1&& __t, _T2&& __u) const
-        noexcept(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)))
-        -> decltype(      _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))
-        { return          _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); }
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS logical_or<void> {
+  template <class _T1, class _T2>
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI auto operator()(_T1&& __t, _T2&& __u) const
+      noexcept(noexcept(std::forward<_T1>(__t) || std::forward<_T2>(__u))) //
+      -> decltype(std::forward<_T1>(__t) || std::forward<_T2>(__u)) {
+    return std::forward<_T1>(__t) || std::forward<_T2>(__u);
+  }
+  typedef void is_transparent;
 };
 #endif
 
diff --git a/third_party/libcxx/__functional/perfect_forward.h b/third_party/libcxx/__functional/perfect_forward.h
index e12654c48..74177c789 100644
--- a/third_party/libcxx/__functional/perfect_forward.h
+++ b/third_party/libcxx/__functional/perfect_forward.h
@@ -11,8 +11,12 @@
 #define _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H
 
 #include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/invoke.h>
+#include <__type_traits/is_constructible.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <tuple>
 
@@ -20,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
@@ -33,61 +40,65 @@ private:
   tuple<_BoundArgs...> __bound_args_;
 
 public:
-  template <class... _Args, class = enable_if_t<
-    is_constructible_v<tuple<_BoundArgs...>, _Args&&...>
-  >>
+  template <class... _Args, class = enable_if_t< is_constructible_v<tuple<_BoundArgs...>, _Args&&...> >>
   _LIBCPP_HIDE_FROM_ABI explicit constexpr __perfect_forward_impl(_Args&&... __bound_args)
-    : __bound_args_(_VSTD::forward<_Args>(__bound_args)...) {}
+      : __bound_args_(std::forward<_Args>(__bound_args)...) {}
 
   _LIBCPP_HIDE_FROM_ABI __perfect_forward_impl(__perfect_forward_impl const&) = default;
-  _LIBCPP_HIDE_FROM_ABI __perfect_forward_impl(__perfect_forward_impl&&) = default;
+  _LIBCPP_HIDE_FROM_ABI __perfect_forward_impl(__perfect_forward_impl&&)      = default;
 
   _LIBCPP_HIDE_FROM_ABI __perfect_forward_impl& operator=(__perfect_forward_impl const&) = default;
-  _LIBCPP_HIDE_FROM_ABI __perfect_forward_impl& operator=(__perfect_forward_impl&&) = default;
+  _LIBCPP_HIDE_FROM_ABI __perfect_forward_impl& operator=(__perfect_forward_impl&&)      = default;
 
   template <class... _Args, class = enable_if_t<is_invocable_v<_Op, _BoundArgs&..., _Args...>>>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) &
-    noexcept(noexcept(_Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...)))
-    -> decltype(      _Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...))
-    { return          _Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) & noexcept(
+      noexcept(_Op()(std::get<_Idx>(__bound_args_)..., std::forward<_Args>(__args)...)))
+      -> decltype(_Op()(std::get<_Idx>(__bound_args_)..., std::forward<_Args>(__args)...)) {
+    return _Op()(std::get<_Idx>(__bound_args_)..., std::forward<_Args>(__args)...);
+  }
 
   template <class... _Args, class = enable_if_t<!is_invocable_v<_Op, _BoundArgs&..., _Args...>>>
   auto operator()(_Args&&...) & = delete;
 
   template <class... _Args, class = enable_if_t<is_invocable_v<_Op, _BoundArgs const&..., _Args...>>>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const&
-    noexcept(noexcept(_Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...)))
-    -> decltype(      _Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...))
-    { return          _Op()(_VSTD::get<_Idx>(__bound_args_)..., _VSTD::forward<_Args>(__args)...); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const& noexcept(
+      noexcept(_Op()(std::get<_Idx>(__bound_args_)..., std::forward<_Args>(__args)...)))
+      -> decltype(_Op()(std::get<_Idx>(__bound_args_)..., std::forward<_Args>(__args)...)) {
+    return _Op()(std::get<_Idx>(__bound_args_)..., std::forward<_Args>(__args)...);
+  }
 
   template <class... _Args, class = enable_if_t<!is_invocable_v<_Op, _BoundArgs const&..., _Args...>>>
   auto operator()(_Args&&...) const& = delete;
 
   template <class... _Args, class = enable_if_t<is_invocable_v<_Op, _BoundArgs..., _Args...>>>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) &&
-    noexcept(noexcept(_Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...)))
-    -> decltype(      _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...))
-    { return          _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) && noexcept(
+      noexcept(_Op()(std::get<_Idx>(std::move(__bound_args_))..., std::forward<_Args>(__args)...)))
+      -> decltype(_Op()(std::get<_Idx>(std::move(__bound_args_))..., std::forward<_Args>(__args)...)) {
+    return _Op()(std::get<_Idx>(std::move(__bound_args_))..., std::forward<_Args>(__args)...);
+  }
 
   template <class... _Args, class = enable_if_t<!is_invocable_v<_Op, _BoundArgs..., _Args...>>>
   auto operator()(_Args&&...) && = delete;
 
   template <class... _Args, class = enable_if_t<is_invocable_v<_Op, _BoundArgs const..., _Args...>>>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const&&
-    noexcept(noexcept(_Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...)))
-    -> decltype(      _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...))
-    { return          _Op()(_VSTD::get<_Idx>(_VSTD::move(__bound_args_))..., _VSTD::forward<_Args>(__args)...); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Args&&... __args) const&& noexcept(
+      noexcept(_Op()(std::get<_Idx>(std::move(__bound_args_))..., std::forward<_Args>(__args)...)))
+      -> decltype(_Op()(std::get<_Idx>(std::move(__bound_args_))..., std::forward<_Args>(__args)...)) {
+    return _Op()(std::get<_Idx>(std::move(__bound_args_))..., std::forward<_Args>(__args)...);
+  }
 
   template <class... _Args, class = enable_if_t<!is_invocable_v<_Op, _BoundArgs const..., _Args...>>>
   auto operator()(_Args&&...) const&& = delete;
 };
 
 // __perfect_forward implements a perfect-forwarding call wrapper as explained in [func.require].
-template <class _Op, class ..._Args>
+template <class _Op, class... _Args>
 using __perfect_forward = __perfect_forward_impl<_Op, index_sequence_for<_Args...>, _Args...>;
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___FUNCTIONAL_PERFECT_FORWARD_H
diff --git a/third_party/libcxx/__functional/pointer_to_binary_function.h b/third_party/libcxx/__functional/pointer_to_binary_function.h
index b2676c58f..e345250dc 100644
--- a/third_party/libcxx/__functional/pointer_to_binary_function.h
+++ b/third_party/libcxx/__functional/pointer_to_binary_function.h
@@ -22,22 +22,20 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
 template <class _Arg1, class _Arg2, class _Result>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_binary_function
-    : public __binary_function<_Arg1, _Arg2, _Result>
-{
-    _Result (*__f_)(_Arg1, _Arg2);
+class _LIBCPP_TEMPLATE_VIS
+_LIBCPP_DEPRECATED_IN_CXX11 pointer_to_binary_function : public __binary_function<_Arg1, _Arg2, _Result> {
+  _Result (*__f_)(_Arg1, _Arg2);
+
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))
-        : __f_(__f) {}
-    _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const
-        {return __f_(__x, __y);}
+  _LIBCPP_HIDE_FROM_ABI explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2)) : __f_(__f) {}
+  _LIBCPP_HIDE_FROM_ABI _Result operator()(_Arg1 __x, _Arg2 __y) const { return __f_(__x, __y); }
 };
 
 template <class _Arg1, class _Arg2, class _Result>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-pointer_to_binary_function<_Arg1,_Arg2,_Result>
-ptr_fun(_Result (*__f)(_Arg1,_Arg2))
-    {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI pointer_to_binary_function<_Arg1, _Arg2, _Result>
+ptr_fun(_Result (*__f)(_Arg1, _Arg2)) {
+  return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__f);
+}
 
 #endif
 
diff --git a/third_party/libcxx/__functional/pointer_to_unary_function.h b/third_party/libcxx/__functional/pointer_to_unary_function.h
index 77d07adf2..3a5d153d3 100644
--- a/third_party/libcxx/__functional/pointer_to_unary_function.h
+++ b/third_party/libcxx/__functional/pointer_to_unary_function.h
@@ -22,22 +22,20 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
 template <class _Arg, class _Result>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_unary_function
-    : public __unary_function<_Arg, _Result>
-{
-    _Result (*__f_)(_Arg);
+class _LIBCPP_TEMPLATE_VIS
+_LIBCPP_DEPRECATED_IN_CXX11 pointer_to_unary_function : public __unary_function<_Arg, _Result> {
+  _Result (*__f_)(_Arg);
+
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))
-        : __f_(__f) {}
-    _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const
-        {return __f_(__x);}
+  _LIBCPP_HIDE_FROM_ABI explicit pointer_to_unary_function(_Result (*__f)(_Arg)) : __f_(__f) {}
+  _LIBCPP_HIDE_FROM_ABI _Result operator()(_Arg __x) const { return __f_(__x); }
 };
 
 template <class _Arg, class _Result>
-_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
-pointer_to_unary_function<_Arg,_Result>
-ptr_fun(_Result (*__f)(_Arg))
-    {return pointer_to_unary_function<_Arg,_Result>(__f);}
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_HIDE_FROM_ABI pointer_to_unary_function<_Arg, _Result>
+ptr_fun(_Result (*__f)(_Arg)) {
+  return pointer_to_unary_function<_Arg, _Result>(__f);
+}
 
 #endif // _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 
diff --git a/third_party/libcxx/__functional/ranges_operations.h b/third_party/libcxx/__functional/ranges_operations.h
index c344fc38f..27f06eadd 100644
--- a/third_party/libcxx/__functional/ranges_operations.h
+++ b/third_party/libcxx/__functional/ranges_operations.h
@@ -13,8 +13,7 @@
 #include <__concepts/equality_comparable.h>
 #include <__concepts/totally_ordered.h>
 #include <__config>
-#include <__type_traits/integral_constant.h>
-#include <__type_traits/predicate_traits.h>
+#include <__type_traits/desugars_to.h>
 #include <__utility/forward.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -29,10 +28,10 @@ namespace ranges {
 
 struct equal_to {
   template <class _Tp, class _Up>
-  requires equality_comparable_with<_Tp, _Up>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp &&__t, _Up &&__u) const
-      noexcept(noexcept(bool(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u)))) {
-    return _VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u);
+    requires equality_comparable_with<_Tp, _Up>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(bool(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))) {
+    return std::forward<_Tp>(__t) == std::forward<_Up>(__u);
   }
 
   using is_transparent = void;
@@ -40,10 +39,10 @@ struct equal_to {
 
 struct not_equal_to {
   template <class _Tp, class _Up>
-  requires equality_comparable_with<_Tp, _Up>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp &&__t, _Up &&__u) const
-      noexcept(noexcept(bool(!(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u))))) {
-    return !(_VSTD::forward<_Tp>(__t) == _VSTD::forward<_Up>(__u));
+    requires equality_comparable_with<_Tp, _Up>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(bool(!(std::forward<_Tp>(__t) == std::forward<_Up>(__u))))) {
+    return !(std::forward<_Tp>(__t) == std::forward<_Up>(__u));
   }
 
   using is_transparent = void;
@@ -51,10 +50,10 @@ struct not_equal_to {
 
 struct less {
   template <class _Tp, class _Up>
-  requires totally_ordered_with<_Tp, _Up>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp &&__t, _Up &&__u) const
-      noexcept(noexcept(bool(_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u)))) {
-    return _VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u);
+    requires totally_ordered_with<_Tp, _Up>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(bool(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))) {
+    return std::forward<_Tp>(__t) < std::forward<_Up>(__u);
   }
 
   using is_transparent = void;
@@ -62,10 +61,10 @@ struct less {
 
 struct less_equal {
   template <class _Tp, class _Up>
-  requires totally_ordered_with<_Tp, _Up>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp &&__t, _Up &&__u) const
-      noexcept(noexcept(bool(!(_VSTD::forward<_Up>(__u) < _VSTD::forward<_Tp>(__t))))) {
-    return !(_VSTD::forward<_Up>(__u) < _VSTD::forward<_Tp>(__t));
+    requires totally_ordered_with<_Tp, _Up>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(bool(!(std::forward<_Up>(__u) < std::forward<_Tp>(__t))))) {
+    return !(std::forward<_Up>(__u) < std::forward<_Tp>(__t));
   }
 
   using is_transparent = void;
@@ -73,10 +72,10 @@ struct less_equal {
 
 struct greater {
   template <class _Tp, class _Up>
-  requires totally_ordered_with<_Tp, _Up>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp &&__t, _Up &&__u) const
-      noexcept(noexcept(bool(_VSTD::forward<_Up>(__u) < _VSTD::forward<_Tp>(__t)))) {
-    return _VSTD::forward<_Up>(__u) < _VSTD::forward<_Tp>(__t);
+    requires totally_ordered_with<_Tp, _Up>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(bool(std::forward<_Up>(__u) < std::forward<_Tp>(__t)))) {
+    return std::forward<_Up>(__u) < std::forward<_Tp>(__t);
   }
 
   using is_transparent = void;
@@ -84,10 +83,10 @@ struct greater {
 
 struct greater_equal {
   template <class _Tp, class _Up>
-  requires totally_ordered_with<_Tp, _Up>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp &&__t, _Up &&__u) const
-      noexcept(noexcept(bool(!(_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u))))) {
-    return !(_VSTD::forward<_Tp>(__t) < _VSTD::forward<_Up>(__u));
+    requires totally_ordered_with<_Tp, _Up>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t, _Up&& __u) const
+      noexcept(noexcept(bool(!(std::forward<_Tp>(__t) < std::forward<_Up>(__u))))) {
+    return !(std::forward<_Tp>(__t) < std::forward<_Up>(__u));
   }
 
   using is_transparent = void;
@@ -95,8 +94,13 @@ struct greater_equal {
 
 } // namespace ranges
 
-template <class _Lhs, class _Rhs>
-struct __is_trivial_equality_predicate<ranges::equal_to, _Lhs, _Rhs> : true_type {};
+// For ranges we do not require that the types on each side of the equality
+// operator are of the same type
+template <class _Tp, class _Up>
+inline const bool __desugars_to_v<__equal_tag, ranges::equal_to, _Tp, _Up> = true;
+
+template <class _Tp, class _Up>
+inline const bool __desugars_to_v<__less_tag, ranges::less, _Tp, _Up> = true;
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__functional/reference_wrapper.h b/third_party/libcxx/__functional/reference_wrapper.h
index 2d382a34f..3570e2673 100644
--- a/third_party/libcxx/__functional/reference_wrapper.h
+++ b/third_party/libcxx/__functional/reference_wrapper.h
@@ -10,12 +10,16 @@
 #ifndef _LIBCPP___FUNCTIONAL_REFERENCE_WRAPPER_H
 #define _LIBCPP___FUNCTIONAL_REFERENCE_WRAPPER_H
 
+#include <__compare/synth_three_way.h>
+#include <__concepts/boolean_testable.h>
 #include <__config>
 #include <__functional/invoke.h>
 #include <__functional/weak_result_type.h>
 #include <__memory/addressof.h>
 #include <__type_traits/enable_if.h>
+#include <__type_traits/is_const.h>
 #include <__type_traits/remove_cvref.h>
+#include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 
@@ -26,44 +30,91 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS reference_wrapper : public __weak_result_type<_Tp>
-{
+class _LIBCPP_TEMPLATE_VIS reference_wrapper : public __weak_result_type<_Tp> {
 public:
-    // types
-    typedef _Tp type;
+  // types
+  typedef _Tp type;
+
 private:
-    type* __f_;
+  type* __f_;
 
-    static void __fun(_Tp&) _NOEXCEPT;
-    static void __fun(_Tp&&) = delete;
+  static void __fun(_Tp&) _NOEXCEPT;
+  static void __fun(_Tp&&) = delete; // NOLINT(modernize-use-equals-delete) ; This is llvm.org/PR54276
 
 public:
-    template <class _Up, class = __enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, decltype(__fun(std::declval<_Up>())) > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    reference_wrapper(_Up&& __u) _NOEXCEPT_(noexcept(__fun(std::declval<_Up>()))) {
-        type& __f = static_cast<_Up&&>(__u);
-        __f_ = _VSTD::addressof(__f);
-    }
+  template <class _Up,
+            class = __void_t<decltype(__fun(std::declval<_Up>()))>,
+            __enable_if_t<!__is_same_uncvref<_Up, reference_wrapper>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper(_Up&& __u)
+      _NOEXCEPT_(noexcept(__fun(std::declval<_Up>()))) {
+    type& __f = static_cast<_Up&&>(__u);
+    __f_      = std::addressof(__f);
+  }
 
-    // access
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    operator type&() const _NOEXCEPT {return *__f_;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    type& get() const _NOEXCEPT {return *__f_;}
+  // access
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 operator type&() const _NOEXCEPT { return *__f_; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 type& get() const _NOEXCEPT { return *__f_; }
 
-    // invoke
-    template <class... _ArgTypes>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    typename __invoke_of<type&, _ArgTypes...>::type
-    operator() (_ArgTypes&&... __args) const
+  // invoke
+  template <class... _ArgTypes>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __invoke_of<type&, _ArgTypes...>::type
+  operator()(_ArgTypes&&... __args) const
 #if _LIBCPP_STD_VER >= 17
-        // Since is_nothrow_invocable requires C++17 LWG3764 is not backported
-        // to earlier versions.
-        noexcept(is_nothrow_invocable_v<_Tp&, _ArgTypes...>)
+      // Since is_nothrow_invocable requires C++17 LWG3764 is not backported
+      // to earlier versions.
+      noexcept(is_nothrow_invocable_v<_Tp&, _ArgTypes...>)
 #endif
-    {
-        return std::__invoke(get(), std::forward<_ArgTypes>(__args)...);
+  {
+    return std::__invoke(get(), std::forward<_ArgTypes>(__args)...);
+  }
+
+#if _LIBCPP_STD_VER >= 26
+
+  // [refwrap.comparisons], comparisons
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(reference_wrapper __x, reference_wrapper __y)
+    requires requires {
+      { __x.get() == __y.get() } -> __boolean_testable;
     }
+  {
+    return __x.get() == __y.get();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(reference_wrapper __x, const _Tp& __y)
+    requires requires {
+      { __x.get() == __y } -> __boolean_testable;
+    }
+  {
+    return __x.get() == __y;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(reference_wrapper __x, reference_wrapper<const _Tp> __y)
+    requires(!is_const_v<_Tp>) && requires {
+      { __x.get() == __y.get() } -> __boolean_testable;
+    }
+  {
+    return __x.get() == __y.get();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(reference_wrapper __x, reference_wrapper __y)
+    requires requires { std::__synth_three_way(__x.get(), __y.get()); }
+  {
+    return std::__synth_three_way(__x.get(), __y.get());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(reference_wrapper __x, const _Tp& __y)
+    requires requires { std::__synth_three_way(__x.get(), __y); }
+  {
+    return std::__synth_three_way(__x.get(), __y);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(reference_wrapper __x, reference_wrapper<const _Tp> __y)
+    requires(!is_const_v<_Tp>) && requires { std::__synth_three_way(__x.get(), __y.get()); }
+  {
+    return std::__synth_three_way(__x.get(), __y.get());
+  }
+
+#endif // _LIBCPP_STD_VER >= 26
 };
 
 #if _LIBCPP_STD_VER >= 17
@@ -72,39 +123,31 @@ reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
 #endif
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-reference_wrapper<_Tp>
-ref(_Tp& __t) _NOEXCEPT
-{
-    return reference_wrapper<_Tp>(__t);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<_Tp> ref(_Tp& __t) _NOEXCEPT {
+  return reference_wrapper<_Tp>(__t);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-reference_wrapper<_Tp>
-ref(reference_wrapper<_Tp> __t) _NOEXCEPT
-{
-    return __t;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<_Tp>
+ref(reference_wrapper<_Tp> __t) _NOEXCEPT {
+  return __t;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-reference_wrapper<const _Tp>
-cref(const _Tp& __t) _NOEXCEPT
-{
-    return reference_wrapper<const _Tp>(__t);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<const _Tp> cref(const _Tp& __t) _NOEXCEPT {
+  return reference_wrapper<const _Tp>(__t);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-reference_wrapper<const _Tp>
-cref(reference_wrapper<_Tp> __t) _NOEXCEPT
-{
-    return __t;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<const _Tp>
+cref(reference_wrapper<_Tp> __t) _NOEXCEPT {
+  return __t;
 }
 
-template <class _Tp> void ref(const _Tp&&) = delete;
-template <class _Tp> void cref(const _Tp&&) = delete;
+template <class _Tp>
+void ref(const _Tp&&) = delete;
+template <class _Tp>
+void cref(const _Tp&&) = delete;
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__functional/unary_function.h b/third_party/libcxx/__functional/unary_function.h
index f07cac175..69b1bc942 100644
--- a/third_party/libcxx/__functional/unary_function.h
+++ b/third_party/libcxx/__functional/unary_function.h
@@ -20,18 +20,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_UNARY_BINARY_FUNCTION)
 
 template <class _Arg, class _Result>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 unary_function
-{
-    typedef _Arg    argument_type;
-    typedef _Result result_type;
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 unary_function {
+  typedef _Arg argument_type;
+  typedef _Result result_type;
 };
 
 #endif // _LIBCPP_STD_VER <= 14
 
-template <class _Arg, class _Result> struct __unary_function_keep_layout_base {
+template <class _Arg, class _Result>
+struct __unary_function_keep_layout_base {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
   using argument_type _LIBCPP_DEPRECATED_IN_CXX17 = _Arg;
-  using result_type _LIBCPP_DEPRECATED_IN_CXX17 = _Result;
+  using result_type _LIBCPP_DEPRECATED_IN_CXX17   = _Result;
 #endif
 };
 
diff --git a/third_party/libcxx/__functional/unary_negate.h b/third_party/libcxx/__functional/unary_negate.h
index ab87e86d1..5bd487a97 100644
--- a/third_party/libcxx/__functional/unary_negate.h
+++ b/third_party/libcxx/__functional/unary_negate.h
@@ -22,23 +22,24 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS)
 
 template <class _Predicate>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 unary_negate
-    : public __unary_function<typename _Predicate::argument_type, bool>
-{
-    _Predicate __pred_;
+class _LIBCPP_TEMPLATE_VIS
+_LIBCPP_DEPRECATED_IN_CXX17 unary_negate : public __unary_function<typename _Predicate::argument_type, bool> {
+  _Predicate __pred_;
+
 public:
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    explicit unary_negate(const _Predicate& __pred)
-        : __pred_(__pred) {}
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const typename _Predicate::argument_type& __x) const
-        {return !__pred_(__x);}
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI explicit unary_negate(const _Predicate& __pred)
+      : __pred_(__pred) {}
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+  operator()(const typename _Predicate::argument_type& __x) const {
+    return !__pred_(__x);
+  }
 };
 
 template <class _Predicate>
-_LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-unary_negate<_Predicate>
-not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
+_LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI unary_negate<_Predicate>
+not1(const _Predicate& __pred) {
+  return unary_negate<_Predicate>(__pred);
+}
 
 #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS)
 
diff --git a/third_party/libcxx/__functional/weak_result_type.h b/third_party/libcxx/__functional/weak_result_type.h
index 18d1bf718..ad7a83951 100644
--- a/third_party/libcxx/__functional/weak_result_type.h
+++ b/third_party/libcxx/__functional/weak_result_type.h
@@ -25,268 +25,205 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct __has_result_type
-{
+struct __has_result_type {
 private:
-    template <class _Up> static false_type __test(...);
-    template <class _Up> static true_type __test(typename _Up::result_type* = 0);
+  template <class _Up>
+  static false_type __test(...);
+  template <class _Up>
+  static true_type __test(typename _Up::result_type* = 0);
+
 public:
-    static const bool value = decltype(__test<_Tp>(0))::value;
+  static const bool value = decltype(__test<_Tp>(0))::value;
 };
 
 // __weak_result_type
 
 template <class _Tp>
-struct __derives_from_unary_function
-{
+struct __derives_from_unary_function {
 private:
-    struct __two {char __lx; char __lxx;};
-    static __two __test(...);
-    template <class _Ap, class _Rp>
-        static __unary_function<_Ap, _Rp>
-        __test(const volatile __unary_function<_Ap, _Rp>*);
+  struct __two {
+    char __lx;
+    char __lxx;
+  };
+  static __two __test(...);
+  template <class _Ap, class _Rp>
+  static __unary_function<_Ap, _Rp> __test(const volatile __unary_function<_Ap, _Rp>*);
 
 public:
-    static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
-    typedef decltype(__test((_Tp*)0)) type;
+  static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
+  typedef decltype(__test((_Tp*)0)) type;
 };
 
 template <class _Tp>
-struct __derives_from_binary_function
-{
+struct __derives_from_binary_function {
 private:
-    struct __two {char __lx; char __lxx;};
-    static __two __test(...);
-    template <class _A1, class _A2, class _Rp>
-        static __binary_function<_A1, _A2, _Rp>
-        __test(const volatile __binary_function<_A1, _A2, _Rp>*);
+  struct __two {
+    char __lx;
+    char __lxx;
+  };
+  static __two __test(...);
+  template <class _A1, class _A2, class _Rp>
+  static __binary_function<_A1, _A2, _Rp> __test(const volatile __binary_function<_A1, _A2, _Rp>*);
 
 public:
-    static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
-    typedef decltype(__test((_Tp*)0)) type;
+  static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
+  typedef decltype(__test((_Tp*)0)) type;
 };
 
 template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
-struct __maybe_derive_from_unary_function  // bool is true
-    : public __derives_from_unary_function<_Tp>::type
-{
-};
+struct __maybe_derive_from_unary_function // bool is true
+    : public __derives_from_unary_function<_Tp>::type {};
 
 template <class _Tp>
-struct __maybe_derive_from_unary_function<_Tp, false>
-{
-};
+struct __maybe_derive_from_unary_function<_Tp, false> {};
 
 template <class _Tp, bool = __derives_from_binary_function<_Tp>::value>
-struct __maybe_derive_from_binary_function  // bool is true
-    : public __derives_from_binary_function<_Tp>::type
-{
-};
+struct __maybe_derive_from_binary_function // bool is true
+    : public __derives_from_binary_function<_Tp>::type {};
 
 template <class _Tp>
-struct __maybe_derive_from_binary_function<_Tp, false>
-{
-};
+struct __maybe_derive_from_binary_function<_Tp, false> {};
 
 template <class _Tp, bool = __has_result_type<_Tp>::value>
 struct __weak_result_type_imp // bool is true
     : public __maybe_derive_from_unary_function<_Tp>,
-      public __maybe_derive_from_binary_function<_Tp>
-{
+      public __maybe_derive_from_binary_function<_Tp> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = typename _Tp::result_type;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = typename _Tp::result_type;
 #endif
 };
 
 template <class _Tp>
 struct __weak_result_type_imp<_Tp, false>
-    : public __maybe_derive_from_unary_function<_Tp>,
-      public __maybe_derive_from_binary_function<_Tp>
-{
-};
+    : public __maybe_derive_from_unary_function<_Tp>, public __maybe_derive_from_binary_function<_Tp> {};
 
 template <class _Tp>
-struct __weak_result_type
-    : public __weak_result_type_imp<_Tp>
-{
-};
+struct __weak_result_type : public __weak_result_type_imp<_Tp> {};
 
 // 0 argument case
 
 template <class _Rp>
-struct __weak_result_type<_Rp ()>
-{
+struct __weak_result_type<_Rp()> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
 template <class _Rp>
-struct __weak_result_type<_Rp (&)()>
-{
+struct __weak_result_type<_Rp (&)()> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
 template <class _Rp>
-struct __weak_result_type<_Rp (*)()>
-{
+struct __weak_result_type<_Rp (*)()> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
 // 1 argument case
 
 template <class _Rp, class _A1>
-struct __weak_result_type<_Rp (_A1)>
-    : public __unary_function<_A1, _Rp>
-{
-};
+struct __weak_result_type<_Rp(_A1)> : public __unary_function<_A1, _Rp> {};
 
 template <class _Rp, class _A1>
-struct __weak_result_type<_Rp (&)(_A1)>
-    : public __unary_function<_A1, _Rp>
-{
-};
+struct __weak_result_type<_Rp (&)(_A1)> : public __unary_function<_A1, _Rp> {};
 
 template <class _Rp, class _A1>
-struct __weak_result_type<_Rp (*)(_A1)>
-    : public __unary_function<_A1, _Rp>
-{
-};
+struct __weak_result_type<_Rp (*)(_A1)> : public __unary_function<_A1, _Rp> {};
 
 template <class _Rp, class _Cp>
-struct __weak_result_type<_Rp (_Cp::*)()>
-    : public __unary_function<_Cp*, _Rp>
-{
-};
+struct __weak_result_type<_Rp (_Cp::*)()> : public __unary_function<_Cp*, _Rp> {};
 
 template <class _Rp, class _Cp>
-struct __weak_result_type<_Rp (_Cp::*)() const>
-    : public __unary_function<const _Cp*, _Rp>
-{
-};
+struct __weak_result_type<_Rp (_Cp::*)() const> : public __unary_function<const _Cp*, _Rp> {};
 
 template <class _Rp, class _Cp>
-struct __weak_result_type<_Rp (_Cp::*)() volatile>
-    : public __unary_function<volatile _Cp*, _Rp>
-{
-};
+struct __weak_result_type<_Rp (_Cp::*)() volatile> : public __unary_function<volatile _Cp*, _Rp> {};
 
 template <class _Rp, class _Cp>
-struct __weak_result_type<_Rp (_Cp::*)() const volatile>
-    : public __unary_function<const volatile _Cp*, _Rp>
-{
-};
+struct __weak_result_type<_Rp (_Cp::*)() const volatile> : public __unary_function<const volatile _Cp*, _Rp> {};
 
 // 2 argument case
 
 template <class _Rp, class _A1, class _A2>
-struct __weak_result_type<_Rp (_A1, _A2)>
-    : public __binary_function<_A1, _A2, _Rp>
-{
-};
+struct __weak_result_type<_Rp(_A1, _A2)> : public __binary_function<_A1, _A2, _Rp> {};
 
 template <class _Rp, class _A1, class _A2>
-struct __weak_result_type<_Rp (*)(_A1, _A2)>
-    : public __binary_function<_A1, _A2, _Rp>
-{
-};
+struct __weak_result_type<_Rp (*)(_A1, _A2)> : public __binary_function<_A1, _A2, _Rp> {};
 
 template <class _Rp, class _A1, class _A2>
-struct __weak_result_type<_Rp (&)(_A1, _A2)>
-    : public __binary_function<_A1, _A2, _Rp>
-{
-};
+struct __weak_result_type<_Rp (&)(_A1, _A2)> : public __binary_function<_A1, _A2, _Rp> {};
 
 template <class _Rp, class _Cp, class _A1>
-struct __weak_result_type<_Rp (_Cp::*)(_A1)>
-    : public __binary_function<_Cp*, _A1, _Rp>
-{
-};
+struct __weak_result_type<_Rp (_Cp::*)(_A1)> : public __binary_function<_Cp*, _A1, _Rp> {};
 
 template <class _Rp, class _Cp, class _A1>
-struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
-    : public __binary_function<const _Cp*, _A1, _Rp>
-{
-};
+struct __weak_result_type<_Rp (_Cp::*)(_A1) const> : public __binary_function<const _Cp*, _A1, _Rp> {};
 
 template <class _Rp, class _Cp, class _A1>
-struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
-    : public __binary_function<volatile _Cp*, _A1, _Rp>
-{
-};
+struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile> : public __binary_function<volatile _Cp*, _A1, _Rp> {};
 
 template <class _Rp, class _Cp, class _A1>
-struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile>
-    : public __binary_function<const volatile _Cp*, _A1, _Rp>
-{
+struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile> : public __binary_function<const volatile _Cp*, _A1, _Rp> {
 };
 
 // 3 or more arguments
 
-template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
-struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)>
-{
+template <class _Rp, class _A1, class _A2, class _A3, class... _A4>
+struct __weak_result_type<_Rp(_A1, _A2, _A3, _A4...)> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
-template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
-struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)>
-{
+template <class _Rp, class _A1, class _A2, class _A3, class... _A4>
+struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
-template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
-struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)>
-{
+template <class _Rp, class _A1, class _A2, class _A3, class... _A4>
+struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
-template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
-struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)>
-{
+template <class _Rp, class _Cp, class _A1, class _A2, class... _A3>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
-template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
-struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const>
-{
+template <class _Rp, class _Cp, class _A1, class _A2, class... _A3>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
-template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
-struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile>
-{
+template <class _Rp, class _Cp, class _A1, class _A2, class... _A3>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
-template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
-struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile>
-{
+template <class _Rp, class _Cp, class _A1, class _A2, class... _A3>
+struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile> {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
+  using result_type _LIBCPP_NODEBUG _LIBCPP_DEPRECATED_IN_CXX17 = _Rp;
 #endif
 };
 
-template <class _Tp, class ..._Args>
-struct __invoke_return
-{
-    typedef decltype(_VSTD::__invoke(std::declval<_Tp>(), std::declval<_Args>()...)) type;
+template <class _Tp, class... _Args>
+struct __invoke_return {
+  typedef decltype(std::__invoke(std::declval<_Tp>(), std::declval<_Args>()...)) type;
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__fwd/array.h b/third_party/libcxx/__fwd/array.h
index 9a79effb6..b429d0c5a 100644
--- a/third_party/libcxx/__fwd/array.h
+++ b/third_party/libcxx/__fwd/array.h
@@ -21,6 +21,26 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _Tp, size_t _Size>
 struct _LIBCPP_TEMPLATE_VIS array;
 
+template <size_t _Ip, class _Tp, size_t _Size>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp& get(array<_Tp, _Size>&) _NOEXCEPT;
+
+template <size_t _Ip, class _Tp, size_t _Size>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp& get(const array<_Tp, _Size>&) _NOEXCEPT;
+
+#ifndef _LIBCPP_CXX03_LANG
+template <size_t _Ip, class _Tp, size_t _Size>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp&& get(array<_Tp, _Size>&&) _NOEXCEPT;
+
+template <size_t _Ip, class _Tp, size_t _Size>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp&& get(const array<_Tp, _Size>&&) _NOEXCEPT;
+#endif
+
+template <class>
+struct __is_std_array : false_type {};
+
+template <class _Tp, size_t _Size>
+struct __is_std_array<array<_Tp, _Size> > : true_type {};
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FWD_ARRAY_H
diff --git a/third_party/libcxx/__fwd/bit_reference.h b/third_party/libcxx/__fwd/bit_reference.h
new file mode 100644
index 000000000..237efb6db
--- /dev/null
+++ b/third_party/libcxx/__fwd/bit_reference.h
@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_BIT_REFERENCE_H
+#define _LIBCPP___FWD_BIT_REFERENCE_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Cp, bool _IsConst, typename _Cp::__storage_type = 0>
+class __bit_iterator;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_BIT_REFERENCE_H
diff --git a/third_party/libcxx/__fwd/complex.h b/third_party/libcxx/__fwd/complex.h
new file mode 100644
index 000000000..22c78c5cc
--- /dev/null
+++ b/third_party/libcxx/__fwd/complex.h
@@ -0,0 +1,42 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_COMPLEX_H
+#define _LIBCPP___FWD_COMPLEX_H
+
+#include <__config>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS complex;
+
+#if _LIBCPP_STD_VER >= 26
+
+template <size_t _Ip, class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp& get(complex<_Tp>&) noexcept;
+
+template <size_t _Ip, class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp&& get(complex<_Tp>&&) noexcept;
+
+template <size_t _Ip, class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr const _Tp& get(const complex<_Tp>&) noexcept;
+
+template <size_t _Ip, class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& get(const complex<_Tp>&&) noexcept;
+
+#endif // _LIBCPP_STD_VER >= 26
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_COMPLEX_H
diff --git a/third_party/libcxx/__fwd/deque.h b/third_party/libcxx/__fwd/deque.h
new file mode 100644
index 000000000..fd2fb5bb4
--- /dev/null
+++ b/third_party/libcxx/__fwd/deque.h
@@ -0,0 +1,26 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_DEQUE_H
+#define _LIBCPP___FWD_DEQUE_H
+
+#include <__config>
+#include <__fwd/memory.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Allocator = allocator<_Tp> >
+class _LIBCPP_TEMPLATE_VIS deque;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_DEQUE_H
diff --git a/third_party/libcxx/__fwd/format.h b/third_party/libcxx/__fwd/format.h
new file mode 100644
index 000000000..b30c220f8
--- /dev/null
+++ b/third_party/libcxx/__fwd/format.h
@@ -0,0 +1,38 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_FORMAT_H
+#define _LIBCPP___FWD_FORMAT_H
+
+#include <__config>
+#include <__iterator/concepts.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Context>
+class _LIBCPP_TEMPLATE_VIS basic_format_arg;
+
+template <class _OutIt, class _CharT>
+  requires output_iterator<_OutIt, const _CharT&>
+class _LIBCPP_TEMPLATE_VIS basic_format_context;
+
+template <class _Tp, class _CharT = char>
+struct _LIBCPP_TEMPLATE_VIS formatter;
+
+#endif //_LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_FORMAT_H
diff --git a/third_party/libcxx/__fwd/functional.h b/third_party/libcxx/__fwd/functional.h
new file mode 100644
index 000000000..32c9ef33e
--- /dev/null
+++ b/third_party/libcxx/__fwd/functional.h
@@ -0,0 +1,28 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_FUNCTIONAL_H
+#define _LIBCPP___FWD_FUNCTIONAL_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class>
+struct _LIBCPP_TEMPLATE_VIS hash;
+
+template <class>
+class _LIBCPP_TEMPLATE_VIS reference_wrapper;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_FUNCTIONAL_H
diff --git a/third_party/libcxx/__fwd/get.h b/third_party/libcxx/__fwd/get.h
deleted file mode 100644
index d04341496..000000000
--- a/third_party/libcxx/__fwd/get.h
+++ /dev/null
@@ -1,115 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___FWD_GET_H
-#define _LIBCPP___FWD_GET_H
-
-#include <__concepts/copyable.h>
-#include <__config>
-#include <__fwd/array.h>
-#include <__fwd/pair.h>
-#include <__fwd/subrange.h>
-#include <__fwd/tuple.h>
-#include <__tuple/tuple_element.h>
-#include <cstddef>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <size_t _Ip, class ..._Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename tuple_element<_Ip, tuple<_Tp...> >::type&
-get(tuple<_Tp...>&) _NOEXCEPT;
-
-template <size_t _Ip, class ..._Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const typename tuple_element<_Ip, tuple<_Tp...> >::type&
-get(const tuple<_Tp...>&) _NOEXCEPT;
-
-template <size_t _Ip, class ..._Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename tuple_element<_Ip, tuple<_Tp...> >::type&&
-get(tuple<_Tp...>&&) _NOEXCEPT;
-
-template <size_t _Ip, class ..._Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
-get(const tuple<_Tp...>&&) _NOEXCEPT;
-
-#endif //_LIBCPP_CXX03_LANG
-
-template <size_t _Ip, class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(pair<_T1, _T2>&) _NOEXCEPT;
-
-template <size_t _Ip, class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(const pair<_T1, _T2>&) _NOEXCEPT;
-
-#ifndef _LIBCPP_CXX03_LANG
-template <size_t _Ip, class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
-get(pair<_T1, _T2>&&) _NOEXCEPT;
-
-template <size_t _Ip, class _T1, class _T2>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
-get(const pair<_T1, _T2>&&) _NOEXCEPT;
-#endif
-
-template <size_t _Ip, class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp&
-get(array<_Tp, _Size>&) _NOEXCEPT;
-
-template <size_t _Ip, class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const _Tp&
-get(const array<_Tp, _Size>&) _NOEXCEPT;
-
-#ifndef _LIBCPP_CXX03_LANG
-template <size_t _Ip, class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp&&
-get(array<_Tp, _Size>&&) _NOEXCEPT;
-
-template <size_t _Ip, class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const _Tp&&
-get(const array<_Tp, _Size>&&) _NOEXCEPT;
-#endif
-
-#if _LIBCPP_STD_VER >= 20
-
-namespace ranges {
-
-template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
-  requires((_Index == 0 && copyable<_Iter>) || _Index == 1)
-_LIBCPP_HIDE_FROM_ABI constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange);
-
-template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
-  requires(_Index < 2)
-_LIBCPP_HIDE_FROM_ABI constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange);
-
-} // namespace ranges
-
-using ranges::get;
-
-#endif // _LIBCPP_STD_VER >= 20
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___FWD_GET_H
diff --git a/third_party/libcxx/__fwd/hash.h b/third_party/libcxx/__fwd/hash.h
deleted file mode 100644
index af9eca876..000000000
--- a/third_party/libcxx/__fwd/hash.h
+++ /dev/null
@@ -1,25 +0,0 @@
-//===---------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===---------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___FWD_HASH_H
-#define _LIBCPP___FWD_HASH_H
-
-#include <__config>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class>
-struct _LIBCPP_TEMPLATE_VIS hash;
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___FWD_HASH_H
diff --git a/third_party/libcxx/__fwd/ios.h b/third_party/libcxx/__fwd/ios.h
index 82c865d58..48350709d 100644
--- a/third_party/libcxx/__fwd/ios.h
+++ b/third_party/libcxx/__fwd/ios.h
@@ -18,6 +18,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+class _LIBCPP_EXPORTED_FROM_ABI ios_base;
+
 template <class _CharT, class _Traits = char_traits<_CharT> >
 class _LIBCPP_TEMPLATE_VIS basic_ios;
 
diff --git a/third_party/libcxx/__fwd/mdspan.h b/third_party/libcxx/__fwd/mdspan.h
new file mode 100644
index 000000000..8889567a0
--- /dev/null
+++ b/third_party/libcxx/__fwd/mdspan.h
@@ -0,0 +1,57 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MDSPAN_LAYOUTS_H
+#define _LIBCPP___MDSPAN_LAYOUTS_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+// Layout policy with a mapping which corresponds to FORTRAN-style array layouts
+struct layout_left {
+  template <class _Extents>
+  class mapping;
+};
+
+// Layout policy with a mapping which corresponds to C-style array layouts
+struct layout_right {
+  template <class _Extents>
+  class mapping;
+};
+
+// Layout policy with a unique mapping where strides are arbitrary
+struct layout_stride {
+  template <class _Extents>
+  class mapping;
+};
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___MDSPAN_LAYOUTS_H
diff --git a/third_party/libcxx/__fwd/memory.h b/third_party/libcxx/__fwd/memory.h
new file mode 100644
index 000000000..b9e151855
--- /dev/null
+++ b/third_party/libcxx/__fwd/memory.h
@@ -0,0 +1,25 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_MEMORY_H
+#define _LIBCPP___FWD_MEMORY_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS allocator;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_MEMORY_H
diff --git a/third_party/libcxx/__fwd/memory_resource.h b/third_party/libcxx/__fwd/memory_resource.h
index 718a9078d..d68b2c2b6 100644
--- a/third_party/libcxx/__fwd/memory_resource.h
+++ b/third_party/libcxx/__fwd/memory_resource.h
@@ -19,7 +19,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace pmr {
 template <class _ValueType>
-class _LIBCPP_TEMPLATE_VIS polymorphic_allocator;
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_TEMPLATE_VIS polymorphic_allocator;
 } // namespace pmr
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__fwd/pair.h b/third_party/libcxx/__fwd/pair.h
index 3844014de..af32628fe 100644
--- a/third_party/libcxx/__fwd/pair.h
+++ b/third_party/libcxx/__fwd/pair.h
@@ -10,6 +10,8 @@
 #define _LIBCPP___FWD_PAIR_H
 
 #include <__config>
+#include <__fwd/tuple.h>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -20,6 +22,24 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class, class>
 struct _LIBCPP_TEMPLATE_VIS pair;
 
+template <size_t _Ip, class _T1, class _T2>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
+get(pair<_T1, _T2>&) _NOEXCEPT;
+
+template <size_t _Ip, class _T1, class _T2>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
+get(const pair<_T1, _T2>&) _NOEXCEPT;
+
+#ifndef _LIBCPP_CXX03_LANG
+template <size_t _Ip, class _T1, class _T2>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+get(pair<_T1, _T2>&&) _NOEXCEPT;
+
+template <size_t _Ip, class _T1, class _T2>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+get(const pair<_T1, _T2>&&) _NOEXCEPT;
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FWD_PAIR_H
diff --git a/third_party/libcxx/__fwd/queue.h b/third_party/libcxx/__fwd/queue.h
new file mode 100644
index 000000000..50d99ad9c
--- /dev/null
+++ b/third_party/libcxx/__fwd/queue.h
@@ -0,0 +1,31 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_QUEUE_H
+#define _LIBCPP___FWD_QUEUE_H
+
+#include <__config>
+#include <__functional/operations.h>
+#include <__fwd/deque.h>
+#include <__fwd/vector.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Container = deque<_Tp> >
+class _LIBCPP_TEMPLATE_VIS queue;
+
+template <class _Tp, class _Container = vector<_Tp>, class _Compare = less<typename _Container::value_type> >
+class _LIBCPP_TEMPLATE_VIS priority_queue;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_QUEUE_H
diff --git a/third_party/libcxx/__fwd/span.h b/third_party/libcxx/__fwd/span.h
index e9fa70382..8dafa742c 100644
--- a/third_party/libcxx/__fwd/span.h
+++ b/third_party/libcxx/__fwd/span.h
@@ -26,7 +26,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();
-template <typename _Tp, size_t _Extent = dynamic_extent> class span;
+template <typename _Tp, size_t _Extent = dynamic_extent>
+class span;
 
 #endif
 
diff --git a/third_party/libcxx/__fwd/sstream.h b/third_party/libcxx/__fwd/sstream.h
index e2d46fbe1..39a9c3faf 100644
--- a/third_party/libcxx/__fwd/sstream.h
+++ b/third_party/libcxx/__fwd/sstream.h
@@ -10,6 +10,7 @@
 #define _LIBCPP___FWD_SSTREAM_H
 
 #include <__config>
+#include <__fwd/memory.h>
 #include <__fwd/string.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
diff --git a/third_party/libcxx/__fwd/stack.h b/third_party/libcxx/__fwd/stack.h
new file mode 100644
index 000000000..7dab6c1a4
--- /dev/null
+++ b/third_party/libcxx/__fwd/stack.h
@@ -0,0 +1,26 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_STACK_H
+#define _LIBCPP___FWD_STACK_H
+
+#include <__config>
+#include <__fwd/deque.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Container = deque<_Tp> >
+class _LIBCPP_TEMPLATE_VIS stack;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_STACK_H
diff --git a/third_party/libcxx/__fwd/string.h b/third_party/libcxx/__fwd/string.h
index 7ab5561b7..2418e1f9b 100644
--- a/third_party/libcxx/__fwd/string.h
+++ b/third_party/libcxx/__fwd/string.h
@@ -10,6 +10,7 @@
 #define _LIBCPP___FWD_STRING_H
 
 #include <__config>
+#include <__fwd/memory.h>
 #include <__fwd/memory_resource.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -38,9 +39,6 @@ template <>
 struct char_traits<wchar_t>;
 #endif
 
-template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS allocator;
-
 template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT> >
 class _LIBCPP_TEMPLATE_VIS basic_string;
 
@@ -61,21 +59,20 @@ using u32string = basic_string<char32_t>;
 
 namespace pmr {
 template <class _CharT, class _Traits = char_traits<_CharT>>
-using basic_string = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
+using basic_string _LIBCPP_AVAILABILITY_PMR = std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
 
-using string = basic_string<char>;
+using string _LIBCPP_AVAILABILITY_PMR = basic_string<char>;
 
 #  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-using wstring = basic_string<wchar_t>;
+using wstring _LIBCPP_AVAILABILITY_PMR = basic_string<wchar_t>;
 #  endif
 
 #  ifndef _LIBCPP_HAS_NO_CHAR8_T
-using u8string = basic_string<char8_t>;
+using u8string _LIBCPP_AVAILABILITY_PMR = basic_string<char8_t>;
 #  endif
 
-using u16string = basic_string<char16_t>;
-using u32string = basic_string<char32_t>;
-
+using u16string _LIBCPP_AVAILABILITY_PMR = basic_string<char16_t>;
+using u32string _LIBCPP_AVAILABILITY_PMR = basic_string<char32_t>;
 } // namespace pmr
 
 #endif // _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/__fwd/string_view.h b/third_party/libcxx/__fwd/string_view.h
index 481899024..72a64be5b 100644
--- a/third_party/libcxx/__fwd/string_view.h
+++ b/third_party/libcxx/__fwd/string_view.h
@@ -11,7 +11,7 @@
 #define _LIBCPP___FWD_STRING_VIEW_H
 
 #include <__config>
-#include <iosfwd> // char_traits
+#include <__fwd/string.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -19,17 +19,17 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _CharT, class _Traits = char_traits<_CharT> >
+template <class _CharT, class _Traits = char_traits<_CharT> >
 class _LIBCPP_TEMPLATE_VIS basic_string_view;
 
-typedef basic_string_view<char>     string_view;
+typedef basic_string_view<char> string_view;
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
-typedef basic_string_view<char8_t>  u8string_view;
+typedef basic_string_view<char8_t> u8string_view;
 #endif
 typedef basic_string_view<char16_t> u16string_view;
 typedef basic_string_view<char32_t> u32string_view;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-typedef basic_string_view<wchar_t>  wstring_view;
+typedef basic_string_view<wchar_t> wstring_view;
 #endif
 
 // clang-format off
diff --git a/third_party/libcxx/__fwd/subrange.h b/third_party/libcxx/__fwd/subrange.h
index 8f7239247..60a41da23 100644
--- a/third_party/libcxx/__fwd/subrange.h
+++ b/third_party/libcxx/__fwd/subrange.h
@@ -9,7 +9,10 @@
 #ifndef _LIBCPP___FWD_SUBRANGE_H
 #define _LIBCPP___FWD_SUBRANGE_H
 
+#include <__concepts/copyable.h>
 #include <__config>
+#include <__iterator/concepts.h>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -17,20 +20,28 @@
 
 #if _LIBCPP_STD_VER >= 20
 
-#include <__iterator/concepts.h>
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-enum class _LIBCPP_ENUM_VIS subrange_kind : bool { unsized, sized };
+enum class subrange_kind : bool { unsized, sized };
 
 template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent, subrange_kind _Kind>
   requires(_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
 class _LIBCPP_TEMPLATE_VIS subrange;
 
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+  requires((_Index == 0 && copyable<_Iter>) || _Index == 1)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(const subrange<_Iter, _Sent, _Kind>&);
+
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+  requires(_Index < 2)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(subrange<_Iter, _Sent, _Kind>&&);
+
 } // namespace ranges
 
+using ranges::get;
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__fwd/tuple.h b/third_party/libcxx/__fwd/tuple.h
index 16b3fabbb..902770c29 100644
--- a/third_party/libcxx/__fwd/tuple.h
+++ b/third_party/libcxx/__fwd/tuple.h
@@ -10,6 +10,7 @@
 #define _LIBCPP___FWD_TUPLE_H
 
 #include <__config>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -17,11 +18,33 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+template <size_t, class>
+struct _LIBCPP_TEMPLATE_VIS tuple_element;
+
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class...>
 class _LIBCPP_TEMPLATE_VIS tuple;
 
+template <class>
+struct _LIBCPP_TEMPLATE_VIS tuple_size;
+
+template <size_t _Ip, class... _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, tuple<_Tp...> >::type&
+get(tuple<_Tp...>&) _NOEXCEPT;
+
+template <size_t _Ip, class... _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, tuple<_Tp...> >::type&
+get(const tuple<_Tp...>&) _NOEXCEPT;
+
+template <size_t _Ip, class... _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, tuple<_Tp...> >::type&&
+get(tuple<_Tp...>&&) _NOEXCEPT;
+
+template <size_t _Ip, class... _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
+get(const tuple<_Tp...>&&) _NOEXCEPT;
+
 #endif // _LIBCPP_CXX03_LANG
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__fwd/vector.h b/third_party/libcxx/__fwd/vector.h
new file mode 100644
index 000000000..c9cc96137
--- /dev/null
+++ b/third_party/libcxx/__fwd/vector.h
@@ -0,0 +1,26 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___FWD_VECTOR_H
+#define _LIBCPP___FWD_VECTOR_H
+
+#include <__config>
+#include <__fwd/memory.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Alloc = allocator<_Tp> >
+class _LIBCPP_TEMPLATE_VIS vector;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___FWD_VECTOR_H
diff --git a/third_party/libcxx/__hash_table b/third_party/libcxx/__hash_table
index 570e8209c..025758528 100644
--- a/third_party/libcxx/__hash_table
+++ b/third_party/libcxx/__hash_table
@@ -15,25 +15,22 @@
 #include <__assert>
 #include <__bit/countl.h>
 #include <__config>
-#include <__debug>
 #include <__functional/hash.h>
 #include <__functional/invoke.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
+#include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory/unique_ptr.h>
 #include <__type_traits/can_extract_key.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_const.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
 #include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_nothrow_copy_constructible.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_swappable.h>
@@ -46,6 +43,7 @@
 #include <cmath>
 #include <cstring>
 #include <initializer_list>
+#include <new> // __launder
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -54,7 +52,6 @@
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Key, class _Tp>
@@ -66,95 +63,100 @@ struct __is_hash_value_type_imp : false_type {};
 template <class _Key, class _Value>
 struct __is_hash_value_type_imp<__hash_value_type<_Key, _Value> > : true_type {};
 
-template <class ..._Args>
+template <class... _Args>
 struct __is_hash_value_type : false_type {};
 
 template <class _One>
 struct __is_hash_value_type<_One> : __is_hash_value_type_imp<__remove_cvref_t<_One> > {};
 
-_LIBCPP_FUNC_VIS
-size_t __next_prime(size_t __n);
+_LIBCPP_EXPORTED_FROM_ABI size_t __next_prime(size_t __n);
 
 template <class _NodePtr>
-struct __hash_node_base
-{
-    typedef typename pointer_traits<_NodePtr>::element_type __node_type;
-    typedef __hash_node_base __first_node;
-    typedef __rebind_pointer_t<_NodePtr, __first_node> __node_base_pointer;
-    typedef _NodePtr __node_pointer;
+struct __hash_node_base {
+  typedef typename pointer_traits<_NodePtr>::element_type __node_type;
+  typedef __hash_node_base __first_node;
+  typedef __rebind_pointer_t<_NodePtr, __first_node> __node_base_pointer;
+  typedef _NodePtr __node_pointer;
 
 #if defined(_LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB)
   typedef __node_base_pointer __next_pointer;
 #else
-    typedef __conditional_t<is_pointer<__node_pointer>::value, __node_base_pointer, __node_pointer> __next_pointer;
+  typedef __conditional_t<is_pointer<__node_pointer>::value, __node_base_pointer, __node_pointer> __next_pointer;
 #endif
 
-    __next_pointer    __next_;
+  __next_pointer __next_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __next_pointer __ptr() _NOEXCEPT {
-        return static_cast<__next_pointer>(
-            pointer_traits<__node_base_pointer>::pointer_to(*this));
-    }
+  _LIBCPP_HIDE_FROM_ABI __next_pointer __ptr() _NOEXCEPT {
+    return static_cast<__next_pointer>(pointer_traits<__node_base_pointer>::pointer_to(*this));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __upcast() _NOEXCEPT {
-        return static_cast<__node_pointer>(
-            pointer_traits<__node_base_pointer>::pointer_to(*this));
-    }
+  _LIBCPP_HIDE_FROM_ABI __node_pointer __upcast() _NOEXCEPT {
+    return static_cast<__node_pointer>(pointer_traits<__node_base_pointer>::pointer_to(*this));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t __hash() const _NOEXCEPT {
-        return static_cast<__node_type const&>(*this).__hash_;
-    }
+  _LIBCPP_HIDE_FROM_ABI size_t __hash() const _NOEXCEPT { return static_cast<__node_type const&>(*this).__hash_; }
 
-    _LIBCPP_INLINE_VISIBILITY __hash_node_base() _NOEXCEPT : __next_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI __hash_node_base() _NOEXCEPT : __next_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __hash_node_base(__next_pointer __next) _NOEXCEPT : __next_(__next) {}
 };
 
 template <class _Tp, class _VoidPtr>
-struct _LIBCPP_STANDALONE_DEBUG __hash_node
-    : public __hash_node_base
-             <
-                 __rebind_pointer_t<_VoidPtr, __hash_node<_Tp, _VoidPtr> >
-             >
-{
-    typedef _Tp __node_value_type;
+struct __hash_node : public __hash_node_base< __rebind_pointer_t<_VoidPtr, __hash_node<_Tp, _VoidPtr> > > {
+  typedef _Tp __node_value_type;
+  using _Base          = __hash_node_base<__rebind_pointer_t<_VoidPtr, __hash_node<_Tp, _VoidPtr> > >;
+  using __next_pointer = typename _Base::__next_pointer;
 
-    size_t            __hash_;
-    __node_value_type __value_;
+  size_t __hash_;
+
+  // We allow starting the lifetime of nodes without initializing the value held by the node,
+  // since that is handled by the hash table itself in order to be allocator-aware.
+#ifndef _LIBCPP_CXX03_LANG
+
+private:
+  union {
+    _Tp __value_;
+  };
+
+public:
+  _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return __value_; }
+#else
+
+private:
+  _ALIGNAS_TYPE(_Tp) char __buffer_[sizeof(_Tp)];
+
+public:
+  _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return *std::__launder(reinterpret_cast<_Tp*>(&__buffer_)); }
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI explicit __hash_node(__next_pointer __next, size_t __hash) : _Base(__next), __hash_(__hash) {}
+  _LIBCPP_HIDE_FROM_ABI ~__hash_node() {}
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-__is_hash_power2(size_t __bc)
-{
-    return __bc > 2 && !(__bc & (__bc - 1));
+inline _LIBCPP_HIDE_FROM_ABI bool __is_hash_power2(size_t __bc) { return __bc > 2 && !(__bc & (__bc - 1)); }
+
+inline _LIBCPP_HIDE_FROM_ABI size_t __constrain_hash(size_t __h, size_t __bc) {
+  return !(__bc & (__bc - 1)) ? __h & (__bc - 1) : (__h < __bc ? __h : __h % __bc);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-size_t
-__constrain_hash(size_t __h, size_t __bc)
-{
-    return !(__bc & (__bc - 1)) ? __h & (__bc - 1) :
-        (__h < __bc ? __h : __h % __bc);
+inline _LIBCPP_HIDE_FROM_ABI size_t __next_hash_pow2(size_t __n) {
+  return __n < 2 ? __n : (size_t(1) << (numeric_limits<size_t>::digits - __libcpp_clz(__n - 1)));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-size_t
-__next_hash_pow2(size_t __n)
-{
-    return __n < 2 ? __n : (size_t(1) << (numeric_limits<size_t>::digits - __libcpp_clz(__n-1)));
-}
+template <class _Tp, class _Hash, class _Equal, class _Alloc>
+class __hash_table;
 
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table;
-
-template <class _NodePtr>      class _LIBCPP_TEMPLATE_VIS __hash_iterator;
-template <class _ConstNodePtr> class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
-template <class _NodePtr>      class _LIBCPP_TEMPLATE_VIS __hash_local_iterator;
-template <class _ConstNodePtr> class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
-template <class _HashIterator> class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
-template <class _HashIterator> class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
+template <class _NodePtr>
+class _LIBCPP_TEMPLATE_VIS __hash_iterator;
+template <class _ConstNodePtr>
+class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+template <class _NodePtr>
+class _LIBCPP_TEMPLATE_VIS __hash_local_iterator;
+template <class _ConstNodePtr>
+class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+template <class _HashIterator>
+class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
+template <class _HashIterator>
+class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
 
 template <class _Tp>
 struct __hash_key_value_types {
@@ -164,73 +166,47 @@ struct __hash_key_value_types {
   typedef _Tp __container_value_type;
   static const bool __is_map = false;
 
-  _LIBCPP_INLINE_VISIBILITY
-  static key_type const& __get_key(_Tp const& __v) {
-    return __v;
-  }
-  _LIBCPP_INLINE_VISIBILITY
-  static __container_value_type const& __get_value(__node_value_type const& __v) {
-    return __v;
-  }
-  _LIBCPP_INLINE_VISIBILITY
-  static __container_value_type* __get_ptr(__node_value_type& __n) {
-    return _VSTD::addressof(__n);
-  }
-  _LIBCPP_INLINE_VISIBILITY
-  static __container_value_type&& __move(__node_value_type& __v) {
-    return _VSTD::move(__v);
-  }
+  _LIBCPP_HIDE_FROM_ABI static key_type const& __get_key(_Tp const& __v) { return __v; }
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type const& __get_value(__node_value_type const& __v) { return __v; }
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type* __get_ptr(__node_value_type& __n) { return std::addressof(__n); }
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type&& __move(__node_value_type& __v) { return std::move(__v); }
 };
 
 template <class _Key, class _Tp>
 struct __hash_key_value_types<__hash_value_type<_Key, _Tp> > {
-  typedef _Key                                         key_type;
-  typedef _Tp                                          mapped_type;
-  typedef __hash_value_type<_Key, _Tp>                 __node_value_type;
-  typedef pair<const _Key, _Tp>                        __container_value_type;
-  typedef __container_value_type                       __map_value_type;
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef __hash_value_type<_Key, _Tp> __node_value_type;
+  typedef pair<const _Key, _Tp> __container_value_type;
+  typedef __container_value_type __map_value_type;
   static const bool __is_map = true;
 
-  _LIBCPP_INLINE_VISIBILITY
-  static key_type const& __get_key(__container_value_type const& __v) {
-    return __v.first;
-  }
+  _LIBCPP_HIDE_FROM_ABI static key_type const& __get_key(__container_value_type const& __v) { return __v.first; }
 
-  template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY
-  static __enable_if_t<__is_same_uncvref<_Up, __node_value_type>::value, __container_value_type const&>
-  __get_value(_Up& __t) {
+  template <class _Up, __enable_if_t<__is_same_uncvref<_Up, __node_value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type const& __get_value(_Up& __t) {
     return __t.__get_value();
   }
 
-  template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY
-  static __enable_if_t<__is_same_uncvref<_Up, __container_value_type>::value, __container_value_type const&>
-  __get_value(_Up& __t) {
+  template <class _Up, __enable_if_t<__is_same_uncvref<_Up, __container_value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type const& __get_value(_Up& __t) {
     return __t;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  static __container_value_type* __get_ptr(__node_value_type& __n) {
-    return _VSTD::addressof(__n.__get_value());
-  }
-  _LIBCPP_INLINE_VISIBILITY
-  static pair<key_type&&, mapped_type&&> __move(__node_value_type& __v) {
-    return __v.__move();
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type* __get_ptr(__node_value_type& __n) {
+    return std::addressof(__n.__get_value());
   }
+  _LIBCPP_HIDE_FROM_ABI static pair<key_type&&, mapped_type&&> __move(__node_value_type& __v) { return __v.__move(); }
 };
 
-template <class _Tp, class _AllocPtr, class _KVTypes = __hash_key_value_types<_Tp>,
-          bool = _KVTypes::__is_map>
+template <class _Tp, class _AllocPtr, class _KVTypes = __hash_key_value_types<_Tp>, bool = _KVTypes::__is_map>
 struct __hash_map_pointer_types {};
 
 template <class _Tp, class _AllocPtr, class _KVTypes>
 struct __hash_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> {
-  typedef typename _KVTypes::__map_value_type   _Mv;
-  typedef __rebind_pointer_t<_AllocPtr, _Mv>
-                                                       __map_value_type_pointer;
-  typedef __rebind_pointer_t<_AllocPtr, const _Mv>
-                                                 __const_map_value_type_pointer;
+  typedef typename _KVTypes::__map_value_type _Mv;
+  typedef __rebind_pointer_t<_AllocPtr, _Mv> __map_value_type_pointer;
+  typedef __rebind_pointer_t<_AllocPtr, const _Mv> __const_map_value_type_pointer;
 };
 
 template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>
@@ -238,39 +214,36 @@ struct __hash_node_types;
 
 template <class _NodePtr, class _Tp, class _VoidPtr>
 struct __hash_node_types<_NodePtr, __hash_node<_Tp, _VoidPtr> >
-    : public __hash_key_value_types<_Tp>, __hash_map_pointer_types<_Tp, _VoidPtr>
+    : public __hash_key_value_types<_Tp>,
+      __hash_map_pointer_types<_Tp, _VoidPtr>
 
 {
-  typedef __hash_key_value_types<_Tp>           __base;
+  typedef __hash_key_value_types<_Tp> __base;
 
 public:
   typedef ptrdiff_t difference_type;
   typedef size_t size_type;
 
-  typedef __rebind_pointer_t<_NodePtr, void>       __void_pointer;
+  typedef __rebind_pointer_t<_NodePtr, void> __void_pointer;
 
-  typedef typename pointer_traits<_NodePtr>::element_type       __node_type;
-  typedef _NodePtr                                              __node_pointer;
+  typedef typename pointer_traits<_NodePtr>::element_type __node_type;
+  typedef _NodePtr __node_pointer;
 
-  typedef __hash_node_base<__node_pointer>                      __node_base_type;
-  typedef __rebind_pointer_t<_NodePtr, __node_base_type>
-                                                             __node_base_pointer;
+  typedef __hash_node_base<__node_pointer> __node_base_type;
+  typedef __rebind_pointer_t<_NodePtr, __node_base_type> __node_base_pointer;
 
-  typedef typename __node_base_type::__next_pointer          __next_pointer;
+  typedef typename __node_base_type::__next_pointer __next_pointer;
 
-  typedef _Tp                                                 __node_value_type;
-  typedef __rebind_pointer_t<_VoidPtr, __node_value_type>
-                                                      __node_value_type_pointer;
-  typedef __rebind_pointer_t<_VoidPtr, const __node_value_type>
-                                                __const_node_value_type_pointer;
+  typedef _Tp __node_value_type;
+  typedef __rebind_pointer_t<_VoidPtr, __node_value_type> __node_value_type_pointer;
+  typedef __rebind_pointer_t<_VoidPtr, const __node_value_type> __const_node_value_type_pointer;
 
 private:
-    static_assert(!is_const<__node_type>::value,
-                "_NodePtr should never be a pointer to const");
-    static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value),
-                  "_VoidPtr does not point to unqualified void type");
-    static_assert((is_same<__rebind_pointer_t<_VoidPtr, __node_type>,
-                          _NodePtr>::value), "_VoidPtr does not rebind to _NodePtr.");
+  static_assert(!is_const<__node_type>::value, "_NodePtr should never be a pointer to const");
+  static_assert(is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value,
+                "_VoidPtr does not point to unqualified void type");
+  static_assert(is_same<__rebind_pointer_t<_VoidPtr, __node_type>, _NodePtr>::value,
+                "_VoidPtr does not rebind to _NodePtr.");
 };
 
 template <class _HashIterator>
@@ -284,7 +257,6 @@ struct __hash_node_types_from_iterator<__hash_local_iterator<_NodePtr> > : __has
 template <class _NodePtr>
 struct __hash_node_types_from_iterator<__hash_const_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
 
-
 template <class _NodeValueTp, class _VoidPtr>
 struct __make_hash_node_types {
   typedef __hash_node<_NodeValueTp, _VoidPtr> _NodeTp;
@@ -293,550 +265,359 @@ struct __make_hash_node_types {
 };
 
 template <class _NodePtr>
-class _LIBCPP_TEMPLATE_VIS __hash_iterator
-{
-    typedef __hash_node_types<_NodePtr> _NodeTypes;
-    typedef _NodePtr                            __node_pointer;
-    typedef typename _NodeTypes::__next_pointer __next_pointer;
+class _LIBCPP_TEMPLATE_VIS __hash_iterator {
+  typedef __hash_node_types<_NodePtr> _NodeTypes;
+  typedef _NodePtr __node_pointer;
+  typedef typename _NodeTypes::__next_pointer __next_pointer;
 
-    __next_pointer            __node_;
+  __next_pointer __node_;
 
 public:
-    typedef forward_iterator_tag                           iterator_category;
-    typedef typename _NodeTypes::__node_value_type         value_type;
-    typedef typename _NodeTypes::difference_type           difference_type;
-    typedef value_type&                                    reference;
-    typedef typename _NodeTypes::__node_value_type_pointer pointer;
+  typedef forward_iterator_tag iterator_category;
+  typedef typename _NodeTypes::__node_value_type value_type;
+  typedef typename _NodeTypes::difference_type difference_type;
+  typedef value_type& reference;
+  typedef typename _NodeTypes::__node_value_type_pointer pointer;
 
-    _LIBCPP_INLINE_VISIBILITY __hash_iterator() _NOEXCEPT : __node_(nullptr) {
-        _VSTD::__debug_db_insert_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_iterator() _NOEXCEPT : __node_(nullptr) {}
 
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_iterator(const __hash_iterator& __i)
-        : __node_(__i.__node_)
-    {
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__i));
-    }
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to dereference a non-dereferenceable unordered container iterator");
+    return __node_->__upcast()->__get_value();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~__hash_iterator()
-    {
-        __get_db()->__erase_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to dereference a non-dereferenceable unordered container iterator");
+    return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__get_value());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_iterator& operator=(const __hash_iterator& __i)
-    {
-        if (this != _VSTD::addressof(__i))
-        {
-            __get_db()->__iterator_copy(this, _VSTD::addressof(__i));
-            __node_ = __i.__node_;
-        }
-        return *this;
-    }
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI __hash_iterator& operator++() {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to increment a non-incrementable unordered container iterator");
+    __node_ = __node_->__next_;
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to dereference a non-dereferenceable unordered container iterator");
-        return __node_->__upcast()->__value_;
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_iterator operator++(int) {
+    __hash_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                           "Attempted to dereference a non-dereferenceable unordered container iterator");
-        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_iterator& operator++() {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                       "Attempted to increment a non-incrementable unordered container iterator");
-        __node_ = __node_->__next_;
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_iterator operator++(int)
-    {
-        __hash_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
-
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __hash_iterator& __x, const __hash_iterator& __y)
-    {
-        return __x.__node_ == __y.__node_;
-    }
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __hash_iterator& __x, const __hash_iterator& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __hash_iterator& __x, const __hash_iterator& __y) {
+    return __x.__node_ == __y.__node_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __hash_iterator& __x, const __hash_iterator& __y) {
+    return !(__x == __y);
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __hash_iterator(__next_pointer __node, const void* __c) _NOEXCEPT
-        : __node_(__node)
-        {
-            (void)__c;
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-            __get_db()->__insert_ic(this, __c);
-#endif
-        }
-    template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+  _LIBCPP_HIDE_FROM_ABI explicit __hash_iterator(__next_pointer __node) _NOEXCEPT : __node_(__node) {}
+
+  template <class, class, class, class>
+  friend class __hash_table;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
 };
 
 template <class _NodePtr>
-class _LIBCPP_TEMPLATE_VIS __hash_const_iterator
-{
-    static_assert(!is_const<typename pointer_traits<_NodePtr>::element_type>::value, "");
-    typedef __hash_node_types<_NodePtr> _NodeTypes;
-    typedef _NodePtr                            __node_pointer;
-    typedef typename _NodeTypes::__next_pointer __next_pointer;
+class _LIBCPP_TEMPLATE_VIS __hash_const_iterator {
+  static_assert(!is_const<typename pointer_traits<_NodePtr>::element_type>::value, "");
+  typedef __hash_node_types<_NodePtr> _NodeTypes;
+  typedef _NodePtr __node_pointer;
+  typedef typename _NodeTypes::__next_pointer __next_pointer;
 
-    __next_pointer __node_;
+  __next_pointer __node_;
 
 public:
-    typedef __hash_iterator<_NodePtr> __non_const_iterator;
+  typedef __hash_iterator<_NodePtr> __non_const_iterator;
 
-    typedef forward_iterator_tag                                 iterator_category;
-    typedef typename _NodeTypes::__node_value_type               value_type;
-    typedef typename _NodeTypes::difference_type                 difference_type;
-    typedef const value_type&                                    reference;
-    typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
+  typedef forward_iterator_tag iterator_category;
+  typedef typename _NodeTypes::__node_value_type value_type;
+  typedef typename _NodeTypes::difference_type difference_type;
+  typedef const value_type& reference;
+  typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
 
+  _LIBCPP_HIDE_FROM_ABI __hash_const_iterator() _NOEXCEPT : __node_(nullptr) {}
 
-    _LIBCPP_INLINE_VISIBILITY __hash_const_iterator() _NOEXCEPT : __node_(nullptr) {
-        _VSTD::__debug_db_insert_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_const_iterator(const __non_const_iterator& __x) _NOEXCEPT : __node_(__x.__node_) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_iterator(const __non_const_iterator& __x) _NOEXCEPT
-        : __node_(__x.__node_)
-    {
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__x));
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
+    return __node_->__upcast()->__get_value();
+  }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
+    return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__get_value());
+  }
 
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_iterator(const __hash_const_iterator& __i)
-        : __node_(__i.__node_)
-    {
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__i));
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_const_iterator& operator++() {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to increment a non-incrementable unordered container const_iterator");
+    __node_ = __node_->__next_;
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~__hash_const_iterator()
-    {
-        __get_db()->__erase_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_const_iterator operator++(int) {
+    __hash_const_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_iterator& operator=(const __hash_const_iterator& __i)
-    {
-        if (this != _VSTD::addressof(__i))
-        {
-            __get_db()->__iterator_copy(this, _VSTD::addressof(__i));
-            __node_ = __i.__node_;
-        }
-        return *this;
-    }
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
-
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                           "Attempted to dereference a non-dereferenceable unordered container const_iterator");
-        return __node_->__upcast()->__value_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                           "Attempted to dereference a non-dereferenceable unordered container const_iterator");
-        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_iterator& operator++() {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to increment a non-incrementable unordered container const_iterator");
-        __node_ = __node_->__next_;
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_iterator operator++(int)
-    {
-        __hash_const_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
-
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __hash_const_iterator& __x, const __hash_const_iterator& __y)
-    {
-        return __x.__node_ == __y.__node_;
-    }
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __hash_const_iterator& __x, const __hash_const_iterator& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __hash_const_iterator& __x, const __hash_const_iterator& __y) {
+    return __x.__node_ == __y.__node_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __hash_const_iterator& __x, const __hash_const_iterator& __y) {
+    return !(__x == __y);
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __hash_const_iterator(__next_pointer __node, const void* __c) _NOEXCEPT
-        : __node_(__node)
-        {
-            (void)__c;
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-            __get_db()->__insert_ic(this, __c);
-#endif
-        }
-    template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+  _LIBCPP_HIDE_FROM_ABI explicit __hash_const_iterator(__next_pointer __node) _NOEXCEPT : __node_(__node) {}
+
+  template <class, class, class, class>
+  friend class __hash_table;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
 };
 
 template <class _NodePtr>
-class _LIBCPP_TEMPLATE_VIS __hash_local_iterator
-{
-    typedef __hash_node_types<_NodePtr> _NodeTypes;
-    typedef _NodePtr                            __node_pointer;
-    typedef typename _NodeTypes::__next_pointer __next_pointer;
+class _LIBCPP_TEMPLATE_VIS __hash_local_iterator {
+  typedef __hash_node_types<_NodePtr> _NodeTypes;
+  typedef _NodePtr __node_pointer;
+  typedef typename _NodeTypes::__next_pointer __next_pointer;
 
-    __next_pointer         __node_;
-    size_t                 __bucket_;
-    size_t                 __bucket_count_;
+  __next_pointer __node_;
+  size_t __bucket_;
+  size_t __bucket_count_;
 
 public:
-    typedef forward_iterator_tag                                iterator_category;
-    typedef typename _NodeTypes::__node_value_type              value_type;
-    typedef typename _NodeTypes::difference_type                difference_type;
-    typedef value_type&                                         reference;
-    typedef typename _NodeTypes::__node_value_type_pointer      pointer;
+  typedef forward_iterator_tag iterator_category;
+  typedef typename _NodeTypes::__node_value_type value_type;
+  typedef typename _NodeTypes::difference_type difference_type;
+  typedef value_type& reference;
+  typedef typename _NodeTypes::__node_value_type_pointer pointer;
 
-    _LIBCPP_INLINE_VISIBILITY __hash_local_iterator() _NOEXCEPT : __node_(nullptr) {
-        _VSTD::__debug_db_insert_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_local_iterator() _NOEXCEPT : __node_(nullptr) {}
 
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_local_iterator(const __hash_local_iterator& __i)
-        : __node_(__i.__node_),
-          __bucket_(__i.__bucket_),
-          __bucket_count_(__i.__bucket_count_)
-    {
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__i));
-    }
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
+    return __node_->__upcast()->__get_value();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~__hash_local_iterator()
-    {
-        __get_db()->__erase_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
+    return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__get_value());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_local_iterator& operator=(const __hash_local_iterator& __i)
-    {
-        if (this != _VSTD::addressof(__i))
-        {
-            __get_db()->__iterator_copy(this, _VSTD::addressof(__i));
-            __node_ = __i.__node_;
-            __bucket_ = __i.__bucket_;
-            __bucket_count_ = __i.__bucket_count_;
-        }
-        return *this;
-    }
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI __hash_local_iterator& operator++() {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to increment a non-incrementable unordered container local_iterator");
+    __node_ = __node_->__next_;
+    if (__node_ != nullptr && std::__constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
+      __node_ = nullptr;
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                           "Attempted to dereference a non-dereferenceable unordered container local_iterator");
-        return __node_->__upcast()->__value_;
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_local_iterator operator++(int) {
+    __hash_local_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to dereference a non-dereferenceable unordered container local_iterator");
-        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_local_iterator& operator++() {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                       "Attempted to increment a non-incrementable unordered container local_iterator");
-        __node_ = __node_->__next_;
-        if (__node_ != nullptr && std::__constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
-            __node_ = nullptr;
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_local_iterator operator++(int)
-    {
-        __hash_local_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
-
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __hash_local_iterator& __x, const __hash_local_iterator& __y)
-    {
-        return __x.__node_ == __y.__node_;
-    }
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __hash_local_iterator& __x, const __hash_local_iterator& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __hash_local_iterator& __x, const __hash_local_iterator& __y) {
+    return __x.__node_ == __y.__node_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __hash_local_iterator& __x, const __hash_local_iterator& __y) {
+    return !(__x == __y);
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __hash_local_iterator(__next_pointer __node, size_t __bucket,
-                                   size_t __bucket_count, const void* __c) _NOEXCEPT
-        : __node_(__node),
-          __bucket_(__bucket),
-          __bucket_count_(__bucket_count)
-        {
-            (void)__c;
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-            __get_db()->__insert_ic(this, __c);
-#endif
-            if (__node_ != nullptr)
-                __node_ = __node_->__next_;
-        }
-    template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
+  _LIBCPP_HIDE_FROM_ABI explicit __hash_local_iterator(
+      __next_pointer __node, size_t __bucket, size_t __bucket_count) _NOEXCEPT
+      : __node_(__node),
+        __bucket_(__bucket),
+        __bucket_count_(__bucket_count) {
+    if (__node_ != nullptr)
+      __node_ = __node_->__next_;
+  }
+
+  template <class, class, class, class>
+  friend class __hash_table;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_map_iterator;
 };
 
 template <class _ConstNodePtr>
-class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator
-{
-    typedef __hash_node_types<_ConstNodePtr> _NodeTypes;
-    typedef _ConstNodePtr                       __node_pointer;
-    typedef typename _NodeTypes::__next_pointer __next_pointer;
+class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator {
+  typedef __hash_node_types<_ConstNodePtr> _NodeTypes;
+  typedef _ConstNodePtr __node_pointer;
+  typedef typename _NodeTypes::__next_pointer __next_pointer;
 
-    __next_pointer         __node_;
-    size_t                 __bucket_;
-    size_t                 __bucket_count_;
+  __next_pointer __node_;
+  size_t __bucket_;
+  size_t __bucket_count_;
+
+  typedef pointer_traits<__node_pointer> __pointer_traits;
+  typedef typename __pointer_traits::element_type __node;
+  typedef __remove_const_t<__node> __non_const_node;
+  typedef __rebind_pointer_t<__node_pointer, __non_const_node> __non_const_node_pointer;
 
-    typedef pointer_traits<__node_pointer>          __pointer_traits;
-    typedef typename __pointer_traits::element_type __node;
-    typedef __remove_const_t<__node>                  __non_const_node;
-    typedef __rebind_pointer_t<__node_pointer, __non_const_node>
-        __non_const_node_pointer;
 public:
-    typedef __hash_local_iterator<__non_const_node_pointer>
-                                                    __non_const_iterator;
+  typedef __hash_local_iterator<__non_const_node_pointer> __non_const_iterator;
 
-    typedef forward_iterator_tag                                 iterator_category;
-    typedef typename _NodeTypes::__node_value_type               value_type;
-    typedef typename _NodeTypes::difference_type                 difference_type;
-    typedef const value_type&                                    reference;
-    typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
+  typedef forward_iterator_tag iterator_category;
+  typedef typename _NodeTypes::__node_value_type value_type;
+  typedef typename _NodeTypes::difference_type difference_type;
+  typedef const value_type& reference;
+  typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
 
+  _LIBCPP_HIDE_FROM_ABI __hash_const_local_iterator() _NOEXCEPT : __node_(nullptr) {}
 
-    _LIBCPP_INLINE_VISIBILITY __hash_const_local_iterator() _NOEXCEPT : __node_(nullptr) {
-        _VSTD::__debug_db_insert_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_const_local_iterator(const __non_const_iterator& __x) _NOEXCEPT
+      : __node_(__x.__node_),
+        __bucket_(__x.__bucket_),
+        __bucket_count_(__x.__bucket_count_) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_local_iterator(const __non_const_iterator& __x) _NOEXCEPT
-        : __node_(__x.__node_),
-          __bucket_(__x.__bucket_),
-          __bucket_count_(__x.__bucket_count_)
-    {
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__x));
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
+    return __node_->__upcast()->__get_value();
+  }
 
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_local_iterator(const __hash_const_local_iterator& __i)
-        : __node_(__i.__node_),
-          __bucket_(__i.__bucket_),
-          __bucket_count_(__i.__bucket_count_)
-    {
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__i));
-    }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
+    return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__get_value());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~__hash_const_local_iterator()
-    {
-        __get_db()->__erase_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_const_local_iterator& operator++() {
+    _LIBCPP_ASSERT_NON_NULL(
+        __node_ != nullptr, "Attempted to increment a non-incrementable unordered container const_local_iterator");
+    __node_ = __node_->__next_;
+    if (__node_ != nullptr && std::__constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
+      __node_ = nullptr;
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_local_iterator& operator=(const __hash_const_local_iterator& __i)
-    {
-        if (this != _VSTD::addressof(__i))
-        {
-            __get_db()->__iterator_copy(this, _VSTD::addressof(__i));
-            __node_ = __i.__node_;
-            __bucket_ = __i.__bucket_;
-            __bucket_count_ = __i.__bucket_count_;
-        }
-        return *this;
-    }
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI __hash_const_local_iterator operator++(int) {
+    __hash_const_local_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                           "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
-        return __node_->__upcast()->__value_;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                           "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
-        return pointer_traits<pointer>::pointer_to(__node_->__upcast()->__value_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_local_iterator& operator++() {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                       "Attempted to increment a non-incrementable unordered container const_local_iterator");
-        __node_ = __node_->__next_;
-        if (__node_ != nullptr && std::__constrain_hash(__node_->__hash(), __bucket_count_) != __bucket_)
-            __node_ = nullptr;
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_local_iterator operator++(int)
-    {
-        __hash_const_local_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
-
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y)
-    {
-        return __x.__node_ == __y.__node_;
-    }
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y) {
+    return __x.__node_ == __y.__node_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const __hash_const_local_iterator& __x, const __hash_const_local_iterator& __y) {
+    return !(__x == __y);
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __hash_const_local_iterator(__next_pointer __node_ptr, size_t __bucket,
-                                         size_t __bucket_count, const void* __c) _NOEXCEPT
-        : __node_(__node_ptr),
-          __bucket_(__bucket),
-          __bucket_count_(__bucket_count)
-        {
-            (void)__c;
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-            __get_db()->__insert_ic(this, __c);
-#endif
-            if (__node_ != nullptr)
-                __node_ = __node_->__next_;
-        }
-    template <class, class, class, class> friend class __hash_table;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
+  _LIBCPP_HIDE_FROM_ABI explicit __hash_const_local_iterator(
+      __next_pointer __node_ptr, size_t __bucket, size_t __bucket_count) _NOEXCEPT
+      : __node_(__node_ptr),
+        __bucket_(__bucket),
+        __bucket_count_(__bucket_count) {
+    if (__node_ != nullptr)
+      __node_ = __node_->__next_;
+  }
+
+  template <class, class, class, class>
+  friend class __hash_table;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
 };
 
 template <class _Alloc>
-class __bucket_list_deallocator
-{
-    typedef _Alloc                                          allocator_type;
-    typedef allocator_traits<allocator_type>                __alloc_traits;
-    typedef typename __alloc_traits::size_type              size_type;
+class __bucket_list_deallocator {
+  typedef _Alloc allocator_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
+  typedef typename __alloc_traits::size_type size_type;
+
+  __compressed_pair<size_type, allocator_type> __data_;
 
-    __compressed_pair<size_type, allocator_type> __data_;
 public:
-    typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::pointer pointer;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __bucket_list_deallocator()
-        _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
-        : __data_(0, __default_init_tag()) {}
+  _LIBCPP_HIDE_FROM_ABI __bucket_list_deallocator() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
+      : __data_(0, __default_init_tag()) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __bucket_list_deallocator(const allocator_type& __a, size_type __size)
-        _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
-        : __data_(__size, __a) {}
+  _LIBCPP_HIDE_FROM_ABI __bucket_list_deallocator(const allocator_type& __a, size_type __size)
+      _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
+      : __data_(__size, __a) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __bucket_list_deallocator(__bucket_list_deallocator&& __x)
-        _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
-        : __data_(_VSTD::move(__x.__data_))
-    {
-        __x.size() = 0;
-    }
+  _LIBCPP_HIDE_FROM_ABI __bucket_list_deallocator(__bucket_list_deallocator&& __x)
+      _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
+      : __data_(std::move(__x.__data_)) {
+    __x.size() = 0;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type& size() _NOEXCEPT {return __data_.first();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type  size() const _NOEXCEPT {return __data_.first();}
+  _LIBCPP_HIDE_FROM_ABI size_type& size() _NOEXCEPT { return __data_.first(); }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __data_.first(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type& __alloc() _NOEXCEPT {return __data_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const allocator_type& __alloc() const _NOEXCEPT {return __data_.second();}
+  _LIBCPP_HIDE_FROM_ABI allocator_type& __alloc() _NOEXCEPT { return __data_.second(); }
+  _LIBCPP_HIDE_FROM_ABI const allocator_type& __alloc() const _NOEXCEPT { return __data_.second(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
-    {
-        __alloc_traits::deallocate(__alloc(), __p, size());
-    }
+  _LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT { __alloc_traits::deallocate(__alloc(), __p, size()); }
 };
 
-template <class _Alloc> class __hash_map_node_destructor;
+template <class _Alloc>
+class __hash_map_node_destructor;
 
 template <class _Alloc>
-class __hash_node_destructor
-{
-    typedef _Alloc                                          allocator_type;
-    typedef allocator_traits<allocator_type>                __alloc_traits;
+class __hash_node_destructor {
+  typedef _Alloc allocator_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
 
 public:
-    typedef typename __alloc_traits::pointer                pointer;
+  typedef typename __alloc_traits::pointer pointer;
+
 private:
-    typedef __hash_node_types<pointer> _NodeTypes;
+  typedef __hash_node_types<pointer> _NodeTypes;
 
-    allocator_type& __na_;
+  allocator_type& __na_;
 
 public:
-    bool __value_constructed;
+  bool __value_constructed;
 
-    _LIBCPP_HIDE_FROM_ABI __hash_node_destructor(__hash_node_destructor const&) = default;
-    _LIBCPP_HIDE_FROM_ABI __hash_node_destructor& operator=(const __hash_node_destructor&) = delete;
+  _LIBCPP_HIDE_FROM_ABI __hash_node_destructor(__hash_node_destructor const&)            = default;
+  _LIBCPP_HIDE_FROM_ABI __hash_node_destructor& operator=(const __hash_node_destructor&) = delete;
 
+  _LIBCPP_HIDE_FROM_ABI explicit __hash_node_destructor(allocator_type& __na, bool __constructed = false) _NOEXCEPT
+      : __na_(__na),
+        __value_constructed(__constructed) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __hash_node_destructor(allocator_type& __na,
-                                    bool __constructed = false) _NOEXCEPT
-        : __na_(__na),
-          __value_constructed(__constructed)
-        {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
-    {
-        if (__value_constructed)
-            __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
-        if (__p)
-            __alloc_traits::deallocate(__na_, __p, 1);
+  _LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {
+    if (__value_constructed) {
+      __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__get_value()));
+      std::__destroy_at(std::addressof(*__p));
     }
+    if (__p)
+      __alloc_traits::deallocate(__na_, __p, 1);
+  }
 
-    template <class> friend class __hash_map_node_destructor;
+  template <class>
+  friend class __hash_map_node_destructor;
 };
 
 #if _LIBCPP_STD_VER >= 17
@@ -844,33 +625,30 @@ template <class _NodeType, class _Alloc>
 struct __generic_container_node_destructor;
 
 template <class _Tp, class _VoidPtr, class _Alloc>
-struct __generic_container_node_destructor<__hash_node<_Tp, _VoidPtr>, _Alloc>
-    : __hash_node_destructor<_Alloc>
-{
-    using __hash_node_destructor<_Alloc>::__hash_node_destructor;
+struct __generic_container_node_destructor<__hash_node<_Tp, _VoidPtr>, _Alloc> : __hash_node_destructor<_Alloc> {
+  using __hash_node_destructor<_Alloc>::__hash_node_destructor;
 };
 #endif
 
 template <class _Key, class _Hash, class _Equal>
 struct __enforce_unordered_container_requirements {
 #ifndef _LIBCPP_CXX03_LANG
-    static_assert(__check_hash_requirements<_Key, _Hash>::value,
-    "the specified hash does not meet the Hash requirements");
-    static_assert(is_copy_constructible<_Equal>::value,
-    "the specified comparator is required to be copy constructible");
+  static_assert(__check_hash_requirements<_Key, _Hash>::value,
+                "the specified hash does not meet the Hash requirements");
+  static_assert(is_copy_constructible<_Equal>::value, "the specified comparator is required to be copy constructible");
 #endif
-    typedef int type;
+  typedef int type;
 };
 
 template <class _Key, class _Hash, class _Equal>
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Equal const&, _Key const&, _Key const&>::value,
-    "the specified comparator type does not provide a viable const call operator")
-    _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Hash const&, _Key const&>::value,
-    "the specified hash functor does not provide a viable const call operator")
+_LIBCPP_DIAGNOSE_WARNING(!__invokable<_Equal const&, _Key const&, _Key const&>::value,
+                         "the specified comparator type does not provide a viable const call operator")
+_LIBCPP_DIAGNOSE_WARNING(!__invokable<_Hash const&, _Key const&>::value,
+                         "the specified hash functor does not provide a viable const call operator")
 #endif
-typename __enforce_unordered_container_requirements<_Key, _Hash, _Equal>::type
-__diagnose_unordered_container_requirements(int);
+    typename __enforce_unordered_container_requirements<_Key, _Hash, _Equal>::type
+    __diagnose_unordered_container_requirements(int);
 
 // This dummy overload is used so that the compiler won't emit a spurious
 // "no matching function for call to __diagnose_unordered_xxx" diagnostic
@@ -879,914 +657,670 @@ template <class _Key, class _Hash, class _Equal>
 int __diagnose_unordered_container_requirements(void*);
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-class __hash_table
-{
+class __hash_table {
 public:
-    typedef _Tp    value_type;
-    typedef _Hash  hasher;
-    typedef _Equal key_equal;
-    typedef _Alloc allocator_type;
+  typedef _Tp value_type;
+  typedef _Hash hasher;
+  typedef _Equal key_equal;
+  typedef _Alloc allocator_type;
 
 private:
-    typedef allocator_traits<allocator_type> __alloc_traits;
-    typedef typename
-      __make_hash_node_types<value_type, typename __alloc_traits::void_pointer>::type
-                                                                     _NodeTypes;
-public:
+  typedef allocator_traits<allocator_type> __alloc_traits;
+  typedef typename __make_hash_node_types<value_type, typename __alloc_traits::void_pointer>::type _NodeTypes;
 
-    typedef typename _NodeTypes::__node_value_type           __node_value_type;
-    typedef typename _NodeTypes::__container_value_type      __container_value_type;
-    typedef typename _NodeTypes::key_type                    key_type;
-    typedef value_type&                              reference;
-    typedef const value_type&                        const_reference;
-    typedef typename __alloc_traits::pointer         pointer;
-    typedef typename __alloc_traits::const_pointer   const_pointer;
+public:
+  typedef typename _NodeTypes::__node_value_type __node_value_type;
+  typedef typename _NodeTypes::__container_value_type __container_value_type;
+  typedef typename _NodeTypes::key_type key_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
 #ifndef _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
-    typedef typename __alloc_traits::size_type       size_type;
+  typedef typename __alloc_traits::size_type size_type;
 #else
-    typedef typename _NodeTypes::size_type           size_type;
+  typedef typename _NodeTypes::size_type size_type;
 #endif
-    typedef typename _NodeTypes::difference_type     difference_type;
-public:
-    // Create __node
+  typedef typename _NodeTypes::difference_type difference_type;
 
-    typedef typename _NodeTypes::__node_type __node;
-    typedef __rebind_alloc<__alloc_traits, __node>   __node_allocator;
-    typedef allocator_traits<__node_allocator>       __node_traits;
-    typedef typename _NodeTypes::__void_pointer      __void_pointer;
-    typedef typename _NodeTypes::__node_pointer      __node_pointer;
-    typedef typename _NodeTypes::__node_pointer      __node_const_pointer;
-    typedef typename _NodeTypes::__node_base_type    __first_node;
-    typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
-    typedef typename _NodeTypes::__next_pointer      __next_pointer;
+public:
+  // Create __node
+
+  typedef typename _NodeTypes::__node_type __node;
+  typedef __rebind_alloc<__alloc_traits, __node> __node_allocator;
+  typedef allocator_traits<__node_allocator> __node_traits;
+  typedef typename _NodeTypes::__void_pointer __void_pointer;
+  typedef typename _NodeTypes::__node_pointer __node_pointer;
+  typedef typename _NodeTypes::__node_pointer __node_const_pointer;
+  typedef typename _NodeTypes::__node_base_type __first_node;
+  typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
+  typedef typename _NodeTypes::__next_pointer __next_pointer;
 
 private:
-    // check for sane allocator pointer rebinding semantics. Rebinding the
-    // allocator for a new pointer type should be exactly the same as rebinding
-    // the pointer using 'pointer_traits'.
-    static_assert((is_same<__node_pointer, typename __node_traits::pointer>::value),
-                  "Allocator does not rebind pointers in a sane manner.");
-    typedef __rebind_alloc<__node_traits, __first_node> __node_base_allocator;
-    typedef allocator_traits<__node_base_allocator> __node_base_traits;
-    static_assert((is_same<__node_base_pointer, typename __node_base_traits::pointer>::value),
-                 "Allocator does not rebind pointers in a sane manner.");
+  // check for sane allocator pointer rebinding semantics. Rebinding the
+  // allocator for a new pointer type should be exactly the same as rebinding
+  // the pointer using 'pointer_traits'.
+  static_assert(is_same<__node_pointer, typename __node_traits::pointer>::value,
+                "Allocator does not rebind pointers in a sane manner.");
+  typedef __rebind_alloc<__node_traits, __first_node> __node_base_allocator;
+  typedef allocator_traits<__node_base_allocator> __node_base_traits;
+  static_assert(is_same<__node_base_pointer, typename __node_base_traits::pointer>::value,
+                "Allocator does not rebind pointers in a sane manner.");
 
 private:
+  typedef __rebind_alloc<__node_traits, __next_pointer> __pointer_allocator;
+  typedef __bucket_list_deallocator<__pointer_allocator> __bucket_list_deleter;
+  typedef unique_ptr<__next_pointer[], __bucket_list_deleter> __bucket_list;
+  typedef allocator_traits<__pointer_allocator> __pointer_alloc_traits;
+  typedef typename __bucket_list_deleter::pointer __node_pointer_pointer;
 
-    typedef __rebind_alloc<__node_traits, __next_pointer>  __pointer_allocator;
-    typedef __bucket_list_deallocator<__pointer_allocator> __bucket_list_deleter;
-    typedef unique_ptr<__next_pointer[], __bucket_list_deleter> __bucket_list;
-    typedef allocator_traits<__pointer_allocator>          __pointer_alloc_traits;
-    typedef typename __bucket_list_deleter::pointer       __node_pointer_pointer;
+  // --- Member data begin ---
+  __bucket_list __bucket_list_;
+  __compressed_pair<__first_node, __node_allocator> __p1_;
+  __compressed_pair<size_type, hasher> __p2_;
+  __compressed_pair<float, key_equal> __p3_;
+  // --- Member data end ---
 
-    // --- Member data begin ---
-    __bucket_list                                         __bucket_list_;
-    __compressed_pair<__first_node, __node_allocator>     __p1_;
-    __compressed_pair<size_type, hasher>                  __p2_;
-    __compressed_pair<float, key_equal>                   __p3_;
-    // --- Member data end ---
-
-    _LIBCPP_INLINE_VISIBILITY
-    size_type& size() _NOEXCEPT {return __p2_.first();}
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    size_type  size() const _NOEXCEPT {return __p2_.first();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    hasher& hash_function() _NOEXCEPT {return __p2_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const hasher& hash_function() const _NOEXCEPT {return __p2_.second();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    float& max_load_factor() _NOEXCEPT {return __p3_.first();}
-    _LIBCPP_INLINE_VISIBILITY
-    float  max_load_factor() const _NOEXCEPT {return __p3_.first();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    key_equal& key_eq() _NOEXCEPT {return __p3_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const key_equal& key_eq() const _NOEXCEPT {return __p3_.second();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __node_allocator& __node_alloc() _NOEXCEPT {return __p1_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const __node_allocator& __node_alloc() const _NOEXCEPT
-        {return __p1_.second();}
+  _LIBCPP_HIDE_FROM_ABI size_type& size() _NOEXCEPT { return __p2_.first(); }
 
 public:
-    typedef __hash_iterator<__node_pointer>                   iterator;
-    typedef __hash_const_iterator<__node_pointer>             const_iterator;
-    typedef __hash_local_iterator<__node_pointer>             local_iterator;
-    typedef __hash_const_local_iterator<__node_pointer>       const_local_iterator;
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __p2_.first(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_table()
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<__bucket_list>::value &&
-            is_nothrow_default_constructible<__first_node>::value &&
-            is_nothrow_default_constructible<__node_allocator>::value &&
-            is_nothrow_default_constructible<hasher>::value &&
-            is_nothrow_default_constructible<key_equal>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_table(const hasher& __hf, const key_equal& __eql);
-    _LIBCPP_HIDE_FROM_ABI __hash_table(const hasher& __hf, const key_equal& __eql,
-                 const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI explicit __hash_table(const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI __hash_table(const __hash_table& __u);
-    _LIBCPP_HIDE_FROM_ABI __hash_table(const __hash_table& __u, const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI __hash_table(__hash_table&& __u)
-        _NOEXCEPT_(
-            is_nothrow_move_constructible<__bucket_list>::value &&
-            is_nothrow_move_constructible<__first_node>::value &&
-            is_nothrow_move_constructible<__node_allocator>::value &&
-            is_nothrow_move_constructible<hasher>::value &&
-            is_nothrow_move_constructible<key_equal>::value);
-    _LIBCPP_HIDE_FROM_ABI __hash_table(__hash_table&& __u, const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI ~__hash_table();
+  _LIBCPP_HIDE_FROM_ABI hasher& hash_function() _NOEXCEPT { return __p2_.second(); }
+  _LIBCPP_HIDE_FROM_ABI const hasher& hash_function() const _NOEXCEPT { return __p2_.second(); }
 
-    _LIBCPP_HIDE_FROM_ABI __hash_table& operator=(const __hash_table& __u);
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_table& operator=(__hash_table&& __u)
-        _NOEXCEPT_(
-            __node_traits::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<__node_allocator>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI void __assign_unique(_InputIterator __first, _InputIterator __last);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI void __assign_multi(_InputIterator __first, _InputIterator __last);
+  _LIBCPP_HIDE_FROM_ABI float& max_load_factor() _NOEXCEPT { return __p3_.first(); }
+  _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __p3_.first(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT
-    {
-        return _VSTD::min<size_type>(
-            __node_traits::max_size(__node_alloc()),
-            numeric_limits<difference_type >::max()
-        );
-    }
+  _LIBCPP_HIDE_FROM_ABI key_equal& key_eq() _NOEXCEPT { return __p3_.second(); }
+  _LIBCPP_HIDE_FROM_ABI const key_equal& key_eq() const _NOEXCEPT { return __p3_.second(); }
+
+  _LIBCPP_HIDE_FROM_ABI __node_allocator& __node_alloc() _NOEXCEPT { return __p1_.second(); }
+  _LIBCPP_HIDE_FROM_ABI const __node_allocator& __node_alloc() const _NOEXCEPT { return __p1_.second(); }
+
+public:
+  typedef __hash_iterator<__node_pointer> iterator;
+  typedef __hash_const_iterator<__node_pointer> const_iterator;
+  typedef __hash_local_iterator<__node_pointer> local_iterator;
+  typedef __hash_const_local_iterator<__node_pointer> const_local_iterator;
+
+  _LIBCPP_HIDE_FROM_ABI __hash_table() _NOEXCEPT_(
+      is_nothrow_default_constructible<__bucket_list>::value&& is_nothrow_default_constructible<__first_node>::value&&
+          is_nothrow_default_constructible<__node_allocator>::value&& is_nothrow_default_constructible<hasher>::value&&
+              is_nothrow_default_constructible<key_equal>::value);
+  _LIBCPP_HIDE_FROM_ABI __hash_table(const hasher& __hf, const key_equal& __eql);
+  _LIBCPP_HIDE_FROM_ABI __hash_table(const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI explicit __hash_table(const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI __hash_table(const __hash_table& __u);
+  _LIBCPP_HIDE_FROM_ABI __hash_table(const __hash_table& __u, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI __hash_table(__hash_table&& __u) _NOEXCEPT_(
+      is_nothrow_move_constructible<__bucket_list>::value&& is_nothrow_move_constructible<__first_node>::value&&
+          is_nothrow_move_constructible<__node_allocator>::value&& is_nothrow_move_constructible<hasher>::value&&
+              is_nothrow_move_constructible<key_equal>::value);
+  _LIBCPP_HIDE_FROM_ABI __hash_table(__hash_table&& __u, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI ~__hash_table();
+
+  _LIBCPP_HIDE_FROM_ABI __hash_table& operator=(const __hash_table& __u);
+  _LIBCPP_HIDE_FROM_ABI __hash_table& operator=(__hash_table&& __u)
+      _NOEXCEPT_(__node_traits::propagate_on_container_move_assignment::value&&
+                     is_nothrow_move_assignable<__node_allocator>::value&& is_nothrow_move_assignable<hasher>::value&&
+                         is_nothrow_move_assignable<key_equal>::value);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void __assign_unique(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void __assign_multi(_InputIterator __first, _InputIterator __last);
+
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+    return std::min<size_type>(__node_traits::max_size(__node_alloc()), numeric_limits<difference_type >::max());
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    __next_pointer __node_insert_multi_prepare(size_t __cp_hash,
-                                               value_type& __cp_val);
-    _LIBCPP_INLINE_VISIBILITY
-    void __node_insert_multi_perform(__node_pointer __cp,
-                                     __next_pointer __pn) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI __next_pointer __node_insert_multi_prepare(size_t __cp_hash, value_type& __cp_val);
+  _LIBCPP_HIDE_FROM_ABI void __node_insert_multi_perform(__node_pointer __cp, __next_pointer __pn) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __next_pointer __node_insert_unique_prepare(size_t __nd_hash,
-                                                value_type& __nd_val);
-    _LIBCPP_INLINE_VISIBILITY
-    void __node_insert_unique_perform(__node_pointer __ptr) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI __next_pointer __node_insert_unique_prepare(size_t __nd_hash, value_type& __nd_val);
+  _LIBCPP_HIDE_FROM_ABI void __node_insert_unique_perform(__node_pointer __ptr) _NOEXCEPT;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __node_insert_unique(__node_pointer __nd);
-    _LIBCPP_INLINE_VISIBILITY
-    iterator             __node_insert_multi(__node_pointer __nd);
-    _LIBCPP_INLINE_VISIBILITY
-    iterator             __node_insert_multi(const_iterator __p,
-                                             __node_pointer __nd);
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __node_insert_unique(__node_pointer __nd);
+  _LIBCPP_HIDE_FROM_ABI iterator __node_insert_multi(__node_pointer __nd);
+  _LIBCPP_HIDE_FROM_ABI iterator __node_insert_multi(const_iterator __p, __node_pointer __nd);
 
-    template <class _Key, class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __emplace_unique_key_args(_Key const& __k, _Args&&... __args);
+  template <class _Key, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_key_args(_Key const& __k, _Args&&... __args);
 
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __emplace_unique(_Pp&& __x) {
-      return __emplace_unique_extract_key(_VSTD::forward<_Pp>(__x),
-                                          __can_extract_key<_Pp, key_type>());
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_Pp&& __x) {
+    return __emplace_unique_extract_key(std::forward<_Pp>(__x), __can_extract_key<_Pp, key_type>());
+  }
 
-    template <class _First, class _Second>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__can_extract_map_key<_First, key_type, __container_value_type>::value, pair<iterator, bool> >
-    __emplace_unique(_First&& __f, _Second&& __s) {
-        return __emplace_unique_key_args(__f, _VSTD::forward<_First>(__f),
-                                              _VSTD::forward<_Second>(__s));
-    }
+  template <class _First,
+            class _Second,
+            __enable_if_t<__can_extract_map_key<_First, key_type, __container_value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_First&& __f, _Second&& __s) {
+    return __emplace_unique_key_args(__f, std::forward<_First>(__f), std::forward<_Second>(__s));
+  }
 
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __emplace_unique(_Args&&... __args) {
-      return __emplace_unique_impl(_VSTD::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_Args&&... __args) {
+    return __emplace_unique_impl(std::forward<_Args>(__args)...);
+  }
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool>
-    __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {
-      return __emplace_unique_impl(_VSTD::forward<_Pp>(__x));
-    }
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool>
-    __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {
-      return __emplace_unique_key_args(__x, _VSTD::forward<_Pp>(__x));
-    }
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool>
-    __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {
-      return __emplace_unique_key_args(__x.first, _VSTD::forward<_Pp>(__x));
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {
+    return __emplace_unique_impl(std::forward<_Pp>(__x));
+  }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {
+    return __emplace_unique_key_args(__x, std::forward<_Pp>(__x));
+  }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {
+    return __emplace_unique_key_args(__x.first, std::forward<_Pp>(__x));
+  }
 
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __emplace_multi(_Args&&... __args);
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator __emplace_multi(_Args&&... __args);
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);
 
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __insert_unique(__container_value_type&& __x) {
+    return __emplace_unique_key_args(_NodeTypes::__get_key(__x), std::move(__x));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool>
-    __insert_unique(__container_value_type&& __x) {
-      return __emplace_unique_key_args(_NodeTypes::__get_key(__x), _VSTD::move(__x));
-    }
+  template <class _Pp, __enable_if_t<!__is_same_uncvref<_Pp, __container_value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __insert_unique(_Pp&& __x) {
+    return __emplace_unique(std::forward<_Pp>(__x));
+  }
 
-    template <class _Pp, class = __enable_if_t<!__is_same_uncvref<_Pp, __container_value_type>::value> >
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __insert_unique(_Pp&& __x) {
-      return __emplace_unique(_VSTD::forward<_Pp>(__x));
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_multi(_Pp&& __x) {
+    return __emplace_multi(std::forward<_Pp>(__x));
+  }
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __insert_multi(_Pp&& __x) {
-      return __emplace_multi(_VSTD::forward<_Pp>(__x));
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_multi(const_iterator __p, _Pp&& __x) {
+    return __emplace_hint_multi(__p, std::forward<_Pp>(__x));
+  }
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __insert_multi(const_iterator __p, _Pp&& __x) {
-        return __emplace_hint_multi(__p, _VSTD::forward<_Pp>(__x));
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __insert_unique(const __container_value_type& __x) {
-        return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x);
-    }
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __insert_unique(const __container_value_type& __x) {
+    return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x);
+  }
 
 #if _LIBCPP_STD_VER >= 17
-    template <class _NodeHandle, class _InsertReturnType>
-    _LIBCPP_INLINE_VISIBILITY
-    _InsertReturnType __node_handle_insert_unique(_NodeHandle&& __nh);
-    template <class _NodeHandle>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __node_handle_insert_unique(const_iterator __hint,
-                                         _NodeHandle&& __nh);
-    template <class _Table>
-    _LIBCPP_INLINE_VISIBILITY
-    void __node_handle_merge_unique(_Table& __source);
+  template <class _NodeHandle, class _InsertReturnType>
+  _LIBCPP_HIDE_FROM_ABI _InsertReturnType __node_handle_insert_unique(_NodeHandle&& __nh);
+  template <class _NodeHandle>
+  _LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_unique(const_iterator __hint, _NodeHandle&& __nh);
+  template <class _Table>
+  _LIBCPP_HIDE_FROM_ABI void __node_handle_merge_unique(_Table& __source);
 
-    template <class _NodeHandle>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __node_handle_insert_multi(_NodeHandle&& __nh);
-    template <class _NodeHandle>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __node_handle_insert_multi(const_iterator __hint, _NodeHandle&& __nh);
-    template <class _Table>
-    _LIBCPP_INLINE_VISIBILITY
-    void __node_handle_merge_multi(_Table& __source);
+  template <class _NodeHandle>
+  _LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_multi(_NodeHandle&& __nh);
+  template <class _NodeHandle>
+  _LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_multi(const_iterator __hint, _NodeHandle&& __nh);
+  template <class _Table>
+  _LIBCPP_HIDE_FROM_ABI void __node_handle_merge_multi(_Table& __source);
 
-    template <class _NodeHandle>
-    _LIBCPP_INLINE_VISIBILITY
-    _NodeHandle __node_handle_extract(key_type const& __key);
-    template <class _NodeHandle>
-    _LIBCPP_INLINE_VISIBILITY
-    _NodeHandle __node_handle_extract(const_iterator __it);
+  template <class _NodeHandle>
+  _LIBCPP_HIDE_FROM_ABI _NodeHandle __node_handle_extract(key_type const& __key);
+  template <class _NodeHandle>
+  _LIBCPP_HIDE_FROM_ABI _NodeHandle __node_handle_extract(const_iterator __it);
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY void __rehash_unique(size_type __n) { __rehash<true>(__n); }
-    _LIBCPP_INLINE_VISIBILITY void __rehash_multi(size_type __n) { __rehash<false>(__n); }
-    _LIBCPP_INLINE_VISIBILITY void __reserve_unique(size_type __n)
-    {
-        __rehash_unique(static_cast<size_type>(std::ceil(__n / max_load_factor())));
-    }
-    _LIBCPP_INLINE_VISIBILITY void __reserve_multi(size_type __n)
-    {
-        __rehash_multi(static_cast<size_type>(std::ceil(__n / max_load_factor())));
-    }
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void __rehash_unique(size_type __n) { __rehash<true>(__n); }
+  _LIBCPP_HIDE_FROM_ABI void __rehash_multi(size_type __n) { __rehash<false>(__n); }
+  _LIBCPP_HIDE_FROM_ABI void __reserve_unique(size_type __n) {
+    __rehash_unique(static_cast<size_type>(std::ceil(__n / max_load_factor())));
+  }
+  _LIBCPP_HIDE_FROM_ABI void __reserve_multi(size_type __n) {
+    __rehash_multi(static_cast<size_type>(std::ceil(__n / max_load_factor())));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const _NOEXCEPT
-    {
-        return __bucket_list_.get_deleter().size();
-    }
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __bucket_list_.get_deleter().size(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT;
 
-    template <class _Key>
-        _LIBCPP_INLINE_VISIBILITY
-        size_type bucket(const _Key& __k) const
-        {
-            _LIBCPP_ASSERT(bucket_count() > 0,
-                "unordered container::bucket(key) called when bucket_count() == 0");
-            return std::__constrain_hash(hash_function()(__k), bucket_count());
-        }
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI size_type bucket(const _Key& __k) const {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        bucket_count() > 0, "unordered container::bucket(key) called when bucket_count() == 0");
+    return std::__constrain_hash(hash_function()(__k), bucket_count());
+  }
 
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI iterator       find(const _Key& __x);
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI const_iterator find(const _Key& __x) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI iterator find(const _Key& __x);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _Key& __x) const;
 
-    typedef __hash_node_destructor<__node_allocator> _Dp;
-    typedef unique_ptr<__node, _Dp> __node_holder;
+  typedef __hash_node_destructor<__node_allocator> _Dp;
+  typedef unique_ptr<__node, _Dp> __node_holder;
 
-    _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
-    _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last);
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI size_type __erase_unique(const _Key& __k);
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI size_type __erase_multi(const _Key& __k);
-    _LIBCPP_HIDE_FROM_ABI __node_holder remove(const_iterator __p) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI size_type __erase_unique(const _Key& __k);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI size_type __erase_multi(const _Key& __k);
+  _LIBCPP_HIDE_FROM_ABI __node_holder remove(const_iterator __p) _NOEXCEPT;
 
-    template <class _Key>
-        _LIBCPP_INLINE_VISIBILITY
-        size_type __count_unique(const _Key& __k) const;
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI size_type __count_multi(const _Key& __k) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI size_type __count_unique(const _Key& __k) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI size_type __count_multi(const _Key& __k) const;
 
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator>
-        __equal_range_unique(const _Key& __k);
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator>
-        __equal_range_unique(const _Key& __k) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> __equal_range_unique(const _Key& __k);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> __equal_range_unique(const _Key& __k) const;
 
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator>
-        __equal_range_multi(const _Key& __k);
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator>
-        __equal_range_multi(const _Key& __k) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> __equal_range_multi(const _Key& __k);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> __equal_range_multi(const _Key& __k) const;
 
-    _LIBCPP_HIDE_FROM_ABI void swap(__hash_table& __u)
+  _LIBCPP_HIDE_FROM_ABI void swap(__hash_table& __u)
 #if _LIBCPP_STD_VER <= 11
-        _NOEXCEPT_(
-            __is_nothrow_swappable<hasher>::value && __is_nothrow_swappable<key_equal>::value
-            && (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value
-                  || __is_nothrow_swappable<__pointer_allocator>::value)
-            && (!__node_traits::propagate_on_container_swap::value
-                  || __is_nothrow_swappable<__node_allocator>::value)
-            );
+      _NOEXCEPT_(__is_nothrow_swappable_v<hasher>&& __is_nothrow_swappable_v<key_equal> &&
+                 (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value ||
+                  __is_nothrow_swappable_v<__pointer_allocator>) &&
+                 (!__node_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<__node_allocator>));
 #else
-     _NOEXCEPT_(__is_nothrow_swappable<hasher>::value && __is_nothrow_swappable<key_equal>::value);
+      _NOEXCEPT_(__is_nothrow_swappable_v<hasher>&& __is_nothrow_swappable_v<key_equal>);
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const _NOEXCEPT
-        {return max_size(); }
-    _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const;
-    _LIBCPP_INLINE_VISIBILITY float load_factor() const _NOEXCEPT
-    {
-        size_type __bc = bucket_count();
-        return __bc != 0 ? (float)size() / __bc : 0.f;
-    }
-    _LIBCPP_INLINE_VISIBILITY void max_load_factor(float __mlf) _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__mlf > 0,
-            "unordered container::max_load_factor(lf) called with lf <= 0");
-        max_load_factor() = _VSTD::max(__mlf, load_factor());
-    }
+  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return max_size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const;
+  _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT {
+    size_type __bc = bucket_count();
+    return __bc != 0 ? (float)size() / __bc : 0.f;
+  }
+  _LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) _NOEXCEPT {
+    // While passing a non-positive load factor is undefined behavior, in practice the result will be benign (the
+    // call will be equivalent to `max_load_factor(load_factor())`, which is also the case for passing a valid value
+    // less than the current `load_factor`).
+    _LIBCPP_ASSERT_PEDANTIC(__mlf > 0, "unordered container::max_load_factor(lf) called with lf <= 0");
+    max_load_factor() = std::max(__mlf, load_factor());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    local_iterator
-    begin(size_type __n)
-    {
-        _LIBCPP_ASSERT(__n < bucket_count(),
-            "unordered container::begin(n) called with n >= bucket_count()");
-        return local_iterator(__bucket_list_[__n], __n, bucket_count(), this);
-    }
+  _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __n < bucket_count(), "unordered container::begin(n) called with n >= bucket_count()");
+    return local_iterator(__bucket_list_[__n], __n, bucket_count());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    local_iterator
-    end(size_type __n)
-    {
-        _LIBCPP_ASSERT(__n < bucket_count(),
-            "unordered container::end(n) called with n >= bucket_count()");
-        return local_iterator(nullptr, __n, bucket_count(), this);
-    }
+  _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __n < bucket_count(), "unordered container::end(n) called with n >= bucket_count()");
+    return local_iterator(nullptr, __n, bucket_count());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator
-    cbegin(size_type __n) const
-    {
-        _LIBCPP_ASSERT(__n < bucket_count(),
-            "unordered container::cbegin(n) called with n >= bucket_count()");
-        return const_local_iterator(__bucket_list_[__n], __n, bucket_count(), this);
-    }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __n < bucket_count(), "unordered container::cbegin(n) called with n >= bucket_count()");
+    return const_local_iterator(__bucket_list_[__n], __n, bucket_count());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator
-    cend(size_type __n) const
-    {
-        _LIBCPP_ASSERT(__n < bucket_count(),
-            "unordered container::cend(n) called with n >= bucket_count()");
-        return const_local_iterator(nullptr, __n, bucket_count(), this);
-    }
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-    _LIBCPP_HIDE_FROM_ABI bool __dereferenceable(const const_iterator* __i) const;
-    _LIBCPP_HIDE_FROM_ABI bool __decrementable(const const_iterator* __i) const;
-    _LIBCPP_HIDE_FROM_ABI bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
-    _LIBCPP_HIDE_FROM_ABI bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __n < bucket_count(), "unordered container::cend(n) called with n >= bucket_count()");
+    return const_local_iterator(nullptr, __n, bucket_count());
+  }
 
 private:
-    template <bool _UniqueKeys>
-    _LIBCPP_HIDE_FROM_ABI void __rehash(size_type __n);
-    template <bool _UniqueKeys>
-    _LIBCPP_HIDE_FROM_ABI void __do_rehash(size_type __n);
+  template <bool _UniqueKeys>
+  _LIBCPP_HIDE_FROM_ABI void __rehash(size_type __n);
+  template <bool _UniqueKeys>
+  _LIBCPP_HIDE_FROM_ABI void __do_rehash(size_type __n);
 
-    template <class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node(_Args&& ...__args);
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node(_Args&&... __args);
 
-    template <class _First, class ..._Rest>
-    _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node_hash(size_t __hash, _First&& __f, _Rest&&... __rest);
+  template <class _First, class... _Rest>
+  _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node_hash(size_t __hash, _First&& __f, _Rest&&... __rest);
 
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __hash_table& __u) {
+    __copy_assign_alloc(__u, integral_constant<bool, __node_traits::propagate_on_container_copy_assignment::value>());
+  }
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __hash_table& __u, true_type);
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __hash_table&, false_type) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const __hash_table& __u)
-        {__copy_assign_alloc(__u, integral_constant<bool,
-             __node_traits::propagate_on_container_copy_assignment::value>());}
-    _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __hash_table& __u, true_type);
-    _LIBCPP_INLINE_VISIBILITY
-        void __copy_assign_alloc(const __hash_table&, false_type) {}
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(__hash_table& __u, false_type);
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(__hash_table& __u, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value&& is_nothrow_move_assignable<hasher>::value&&
+                     is_nothrow_move_assignable<key_equal>::value);
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__hash_table& __u) _NOEXCEPT_(
+      !__node_traits::propagate_on_container_move_assignment::value ||
+      (is_nothrow_move_assignable<__pointer_allocator>::value && is_nothrow_move_assignable<__node_allocator>::value)) {
+    __move_assign_alloc(__u, integral_constant<bool, __node_traits::propagate_on_container_move_assignment::value>());
+  }
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__hash_table& __u, true_type) _NOEXCEPT_(
+      is_nothrow_move_assignable<__pointer_allocator>::value&& is_nothrow_move_assignable<__node_allocator>::value) {
+    __bucket_list_.get_deleter().__alloc() = std::move(__u.__bucket_list_.get_deleter().__alloc());
+    __node_alloc()                         = std::move(__u.__node_alloc());
+  }
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
 
-    _LIBCPP_HIDE_FROM_ABI void __move_assign(__hash_table& __u, false_type);
-    _LIBCPP_HIDE_FROM_ABI void __move_assign(__hash_table& __u, true_type)
-        _NOEXCEPT_(
-            is_nothrow_move_assignable<__node_allocator>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__hash_table& __u)
-        _NOEXCEPT_(
-            !__node_traits::propagate_on_container_move_assignment::value ||
-            (is_nothrow_move_assignable<__pointer_allocator>::value &&
-             is_nothrow_move_assignable<__node_allocator>::value))
-        {__move_assign_alloc(__u, integral_constant<bool,
-             __node_traits::propagate_on_container_move_assignment::value>());}
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__hash_table& __u, true_type)
-        _NOEXCEPT_(
-            is_nothrow_move_assignable<__pointer_allocator>::value &&
-            is_nothrow_move_assignable<__node_allocator>::value)
-    {
-        __bucket_list_.get_deleter().__alloc() =
-                _VSTD::move(__u.__bucket_list_.get_deleter().__alloc());
-        __node_alloc() = _VSTD::move(__u.__node_alloc());
-    }
-    _LIBCPP_INLINE_VISIBILITY
-        void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI void __deallocate_node(__next_pointer __np) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI __next_pointer __detach() _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI void __deallocate_node(__next_pointer __np) _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI __next_pointer __detach() _NOEXCEPT;
-
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
 };
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
-    _NOEXCEPT_(
-        is_nothrow_default_constructible<__bucket_list>::value &&
-        is_nothrow_default_constructible<__first_node>::value &&
-        is_nothrow_default_constructible<__node_allocator>::value &&
-        is_nothrow_default_constructible<hasher>::value &&
-        is_nothrow_default_constructible<key_equal>::value)
-    : __p2_(0, __default_init_tag()),
-      __p3_(1.0f, __default_init_tag())
-{
-}
+inline __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table() _NOEXCEPT_(
+    is_nothrow_default_constructible<__bucket_list>::value&& is_nothrow_default_constructible<__first_node>::value&&
+        is_nothrow_default_constructible<__node_allocator>::value&& is_nothrow_default_constructible<hasher>::value&&
+            is_nothrow_default_constructible<key_equal>::value)
+    : __p2_(0, __default_init_tag()), __p3_(1.0f, __default_init_tag()) {}
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
-                                                       const key_equal& __eql)
-    : __bucket_list_(nullptr, __bucket_list_deleter()),
-      __p1_(),
-      __p2_(0, __hf),
-      __p3_(1.0f, __eql)
-{
-}
+inline __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf, const key_equal& __eql)
+    : __bucket_list_(nullptr, __bucket_list_deleter()), __p1_(), __p2_(0, __hf), __p3_(1.0f, __eql) {}
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const hasher& __hf,
-                                                       const key_equal& __eql,
-                                                       const allocator_type& __a)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(
+    const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
       __p1_(__default_init_tag(), __node_allocator(__a)),
       __p2_(0, __hf),
-      __p3_(1.0f, __eql)
-{
-}
+      __p3_(1.0f, __eql) {}
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
       __p1_(__default_init_tag(), __node_allocator(__a)),
       __p2_(0, __default_init_tag()),
-      __p3_(1.0f, __default_init_tag())
-{
-}
+      __p3_(1.0f, __default_init_tag()) {}
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u)
     : __bucket_list_(nullptr,
-          __bucket_list_deleter(allocator_traits<__pointer_allocator>::
-              select_on_container_copy_construction(
-                  __u.__bucket_list_.get_deleter().__alloc()), 0)),
-      __p1_(__default_init_tag(), allocator_traits<__node_allocator>::
-          select_on_container_copy_construction(__u.__node_alloc())),
+                     __bucket_list_deleter(allocator_traits<__pointer_allocator>::select_on_container_copy_construction(
+                                               __u.__bucket_list_.get_deleter().__alloc()),
+                                           0)),
+      __p1_(__default_init_tag(),
+            allocator_traits<__node_allocator>::select_on_container_copy_construction(__u.__node_alloc())),
       __p2_(0, __u.hash_function()),
-      __p3_(__u.__p3_)
-{
-}
+      __p3_(__u.__p3_) {}
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u,
-                                                       const allocator_type& __a)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u, const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
       __p1_(__default_init_tag(), __node_allocator(__a)),
       __p2_(0, __u.hash_function()),
-      __p3_(__u.__p3_)
-{
-}
+      __p3_(__u.__p3_) {}
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
-        _NOEXCEPT_(
-            is_nothrow_move_constructible<__bucket_list>::value &&
-            is_nothrow_move_constructible<__first_node>::value &&
-            is_nothrow_move_constructible<__node_allocator>::value &&
-            is_nothrow_move_constructible<hasher>::value &&
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u) _NOEXCEPT_(
+    is_nothrow_move_constructible<__bucket_list>::value&& is_nothrow_move_constructible<__first_node>::value&&
+        is_nothrow_move_constructible<__node_allocator>::value&& is_nothrow_move_constructible<hasher>::value&&
             is_nothrow_move_constructible<key_equal>::value)
-    : __bucket_list_(_VSTD::move(__u.__bucket_list_)),
-      __p1_(_VSTD::move(__u.__p1_)),
-      __p2_(_VSTD::move(__u.__p2_)),
-      __p3_(_VSTD::move(__u.__p3_))
-{
-    if (size() > 0)
-    {
-        __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
-            __p1_.first().__ptr();
-        __u.__p1_.first().__next_ = nullptr;
-        __u.size() = 0;
-    }
+    : __bucket_list_(std::move(__u.__bucket_list_)),
+      __p1_(std::move(__u.__p1_)),
+      __p2_(std::move(__u.__p2_)),
+      __p3_(std::move(__u.__p3_)) {
+  if (size() > 0) {
+    __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] = __p1_.first().__ptr();
+    __u.__p1_.first().__next_                                                              = nullptr;
+    __u.size()                                                                             = 0;
+  }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
-                                                       const allocator_type& __a)
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u, const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
       __p1_(__default_init_tag(), __node_allocator(__a)),
-      __p2_(0, _VSTD::move(__u.hash_function())),
-      __p3_(_VSTD::move(__u.__p3_))
-{
-    if (__a == allocator_type(__u.__node_alloc()))
-    {
-        __bucket_list_.reset(__u.__bucket_list_.release());
-        __bucket_list_.get_deleter().size() = __u.__bucket_list_.get_deleter().size();
-        __u.__bucket_list_.get_deleter().size() = 0;
-        if (__u.size() > 0)
-        {
-            __p1_.first().__next_ = __u.__p1_.first().__next_;
-            __u.__p1_.first().__next_ = nullptr;
-            __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
-                __p1_.first().__ptr();
-            size() = __u.size();
-            __u.size() = 0;
-        }
+      __p2_(0, std::move(__u.hash_function())),
+      __p3_(std::move(__u.__p3_)) {
+  if (__a == allocator_type(__u.__node_alloc())) {
+    __bucket_list_.reset(__u.__bucket_list_.release());
+    __bucket_list_.get_deleter().size()     = __u.__bucket_list_.get_deleter().size();
+    __u.__bucket_list_.get_deleter().size() = 0;
+    if (__u.size() > 0) {
+      __p1_.first().__next_     = __u.__p1_.first().__next_;
+      __u.__p1_.first().__next_ = nullptr;
+      __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] = __p1_.first().__ptr();
+      size()                                                                                 = __u.size();
+      __u.size()                                                                             = 0;
     }
+  }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table()
-{
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table() {
 #if defined(_LIBCPP_CXX03_LANG)
-    static_assert((is_copy_constructible<key_equal>::value),
-                 "Predicate must be copy-constructible.");
-    static_assert((is_copy_constructible<hasher>::value),
-                 "Hasher must be copy-constructible.");
+  static_assert(is_copy_constructible<key_equal>::value, "Predicate must be copy-constructible.");
+  static_assert(is_copy_constructible<hasher>::value, "Hasher must be copy-constructible.");
 #endif
 
-    __deallocate_node(__p1_.first().__next_);
-    std::__debug_db_erase_c(this);
+  __deallocate_node(__p1_.first().__next_);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__copy_assign_alloc(
-        const __hash_table& __u, true_type)
-{
-    if (__node_alloc() != __u.__node_alloc())
-    {
-        clear();
-        __bucket_list_.reset();
-        __bucket_list_.get_deleter().size() = 0;
-    }
-    __bucket_list_.get_deleter().__alloc() = __u.__bucket_list_.get_deleter().__alloc();
-    __node_alloc() = __u.__node_alloc();
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__copy_assign_alloc(const __hash_table& __u, true_type) {
+  if (__node_alloc() != __u.__node_alloc()) {
+    clear();
+    __bucket_list_.reset();
+    __bucket_list_.get_deleter().size() = 0;
+  }
+  __bucket_list_.get_deleter().__alloc() = __u.__bucket_list_.get_deleter().__alloc();
+  __node_alloc()                         = __u.__node_alloc();
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>&
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(const __hash_table& __u)
-{
-    if (this != _VSTD::addressof(__u))
-    {
-        __copy_assign_alloc(__u);
-        hash_function() = __u.hash_function();
-        key_eq() = __u.key_eq();
-        max_load_factor() = __u.max_load_factor();
-        __assign_multi(__u.begin(), __u.end());
-    }
-    return *this;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>& __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(const __hash_table& __u) {
+  if (this != std::addressof(__u)) {
+    __copy_assign_alloc(__u);
+    hash_function()   = __u.hash_function();
+    key_eq()          = __u.key_eq();
+    max_load_factor() = __u.max_load_factor();
+    __assign_multi(__u.begin(), __u.end());
+  }
+  return *this;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate_node(__next_pointer __np)
-    _NOEXCEPT
-{
-    __node_allocator& __na = __node_alloc();
-    while (__np != nullptr)
-    {
-        __next_pointer __next = __np->__next_;
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-        __c_node* __c = __get_db()->__find_c_and_lock(this);
-        for (__i_node** __p = __c->end_; __p != __c->beg_; )
-        {
-            --__p;
-            iterator* __i = static_cast<iterator*>((*__p)->__i_);
-            if (__i->__node_ == __np)
-            {
-                (*__p)->__c_ = nullptr;
-                if (--__c->end_ != __p)
-                    _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
-            }
-        }
-        __get_db()->unlock();
-#endif
-        __node_pointer __real_np = __np->__upcast();
-        __node_traits::destroy(__na, _NodeTypes::__get_ptr(__real_np->__value_));
-        __node_traits::deallocate(__na, __real_np, 1);
-        __np = __next;
-    }
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate_node(__next_pointer __np) _NOEXCEPT {
+  __node_allocator& __na = __node_alloc();
+  while (__np != nullptr) {
+    __next_pointer __next    = __np->__next_;
+    __node_pointer __real_np = __np->__upcast();
+    __node_traits::destroy(__na, _NodeTypes::__get_ptr(__real_np->__get_value()));
+    std::__destroy_at(std::addressof(*__real_np));
+    __node_traits::deallocate(__na, __real_np, 1);
+    __np = __next;
+  }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__next_pointer
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__detach() _NOEXCEPT
-{
-    size_type __bc = bucket_count();
-    for (size_type __i = 0; __i < __bc; ++__i)
-        __bucket_list_[__i] = nullptr;
-    size() = 0;
-    __next_pointer __cache = __p1_.first().__next_;
-    __p1_.first().__next_ = nullptr;
-    return __cache;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__detach() _NOEXCEPT {
+  size_type __bc = bucket_count();
+  for (size_type __i = 0; __i < __bc; ++__i)
+    __bucket_list_[__i] = nullptr;
+  size()                 = 0;
+  __next_pointer __cache = __p1_.first().__next_;
+  __p1_.first().__next_  = nullptr;
+  return __cache;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
-        __hash_table& __u, true_type)
-    _NOEXCEPT_(
-        is_nothrow_move_assignable<__node_allocator>::value &&
-        is_nothrow_move_assignable<hasher>::value &&
-        is_nothrow_move_assignable<key_equal>::value)
-{
-    clear();
-    __bucket_list_.reset(__u.__bucket_list_.release());
-    __bucket_list_.get_deleter().size() = __u.__bucket_list_.get_deleter().size();
-    __u.__bucket_list_.get_deleter().size() = 0;
-    __move_assign_alloc(__u);
-    size() = __u.size();
-    hash_function() = _VSTD::move(__u.hash_function());
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(__hash_table& __u, true_type)
+    _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value&& is_nothrow_move_assignable<hasher>::value&&
+                   is_nothrow_move_assignable<key_equal>::value) {
+  clear();
+  __bucket_list_.reset(__u.__bucket_list_.release());
+  __bucket_list_.get_deleter().size()     = __u.__bucket_list_.get_deleter().size();
+  __u.__bucket_list_.get_deleter().size() = 0;
+  __move_assign_alloc(__u);
+  size()                = __u.size();
+  hash_function()       = std::move(__u.hash_function());
+  max_load_factor()     = __u.max_load_factor();
+  key_eq()              = std::move(__u.key_eq());
+  __p1_.first().__next_ = __u.__p1_.first().__next_;
+  if (size() > 0) {
+    __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] = __p1_.first().__ptr();
+    __u.__p1_.first().__next_                                                              = nullptr;
+    __u.size()                                                                             = 0;
+  }
+}
+
+template <class _Tp, class _Hash, class _Equal, class _Alloc>
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(__hash_table& __u, false_type) {
+  if (__node_alloc() == __u.__node_alloc())
+    __move_assign(__u, true_type());
+  else {
+    hash_function()   = std::move(__u.hash_function());
+    key_eq()          = std::move(__u.key_eq());
     max_load_factor() = __u.max_load_factor();
-    key_eq() = _VSTD::move(__u.key_eq());
-    __p1_.first().__next_ = __u.__p1_.first().__next_;
-    if (size() > 0)
-    {
-        __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
-            __p1_.first().__ptr();
-        __u.__p1_.first().__next_ = nullptr;
-        __u.size() = 0;
-    }
-    std::__debug_db_swap(this, std::addressof(__u));
-}
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
-        __hash_table& __u, false_type)
-{
-    if (__node_alloc() == __u.__node_alloc())
-        __move_assign(__u, true_type());
-    else
-    {
-        hash_function() = _VSTD::move(__u.hash_function());
-        key_eq() = _VSTD::move(__u.key_eq());
-        max_load_factor() = __u.max_load_factor();
-        if (bucket_count() != 0)
-        {
-            __next_pointer __cache = __detach();
+    if (bucket_count() != 0) {
+      __next_pointer __cache = __detach();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            try
-            {
+      try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-                const_iterator __i = __u.begin();
-                while (__cache != nullptr && __u.size() != 0)
-                {
-                    __cache->__upcast()->__value_ =
-                        _VSTD::move(__u.remove(__i++)->__value_);
-                    __next_pointer __next = __cache->__next_;
-                    __node_insert_multi(__cache->__upcast());
-                    __cache = __next;
-                }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            }
-            catch (...)
-            {
-                __deallocate_node(__cache);
-                throw;
-            }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            __deallocate_node(__cache);
-        }
         const_iterator __i = __u.begin();
-        while (__u.size() != 0)
-        {
-            __node_holder __h = __construct_node(_NodeTypes::__move(__u.remove(__i++)->__value_));
-            __node_insert_multi(__h.get());
-            __h.release();
+        while (__cache != nullptr && __u.size() != 0) {
+          __cache->__upcast()->__get_value() = std::move(__u.remove(__i++)->__get_value());
+          __next_pointer __next              = __cache->__next_;
+          __node_insert_multi(__cache->__upcast());
+          __cache = __next;
         }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      } catch (...) {
+        __deallocate_node(__cache);
+        throw;
+      }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      __deallocate_node(__cache);
     }
+    const_iterator __i = __u.begin();
+    while (__u.size() != 0) {
+      __node_holder __h = __construct_node(_NodeTypes::__move(__u.remove(__i++)->__get_value()));
+      __node_insert_multi(__h.get());
+      __h.release();
+    }
+  }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline
-__hash_table<_Tp, _Hash, _Equal, _Alloc>&
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(__hash_table&& __u)
-    _NOEXCEPT_(
-        __node_traits::propagate_on_container_move_assignment::value &&
-        is_nothrow_move_assignable<__node_allocator>::value &&
-        is_nothrow_move_assignable<hasher>::value &&
-        is_nothrow_move_assignable<key_equal>::value)
-{
-    __move_assign(__u, integral_constant<bool,
-                  __node_traits::propagate_on_container_move_assignment::value>());
-    return *this;
+inline __hash_table<_Tp, _Hash, _Equal, _Alloc>&
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(__hash_table&& __u) _NOEXCEPT_(
+    __node_traits::propagate_on_container_move_assignment::value&& is_nothrow_move_assignable<__node_allocator>::value&&
+        is_nothrow_move_assignable<hasher>::value&& is_nothrow_move_assignable<key_equal>::value) {
+  __move_assign(__u, integral_constant<bool, __node_traits::propagate_on_container_move_assignment::value>());
+  return *this;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _InputIterator>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first,
-                                                          _InputIterator __last)
-{
-    typedef iterator_traits<_InputIterator> _ITraits;
-    typedef typename _ITraits::value_type _ItValueType;
-    static_assert((is_same<_ItValueType, __container_value_type>::value),
-                  "__assign_unique may only be called with the containers value type");
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first, _InputIterator __last) {
+  typedef iterator_traits<_InputIterator> _ITraits;
+  typedef typename _ITraits::value_type _ItValueType;
+  static_assert(is_same<_ItValueType, __container_value_type>::value,
+                "__assign_unique may only be called with the containers value type");
 
-    if (bucket_count() != 0)
-    {
-        __next_pointer __cache = __detach();
+  if (bucket_count() != 0) {
+    __next_pointer __cache = __detach();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (; __cache != nullptr && __first != __last; ++__first)
-            {
-                __cache->__upcast()->__value_ = *__first;
-                __next_pointer __next = __cache->__next_;
-                __node_insert_unique(__cache->__upcast());
-                __cache = __next;
-            }
+      for (; __cache != nullptr && __first != __last; ++__first) {
+        __cache->__upcast()->__get_value() = *__first;
+        __next_pointer __next              = __cache->__next_;
+        __node_insert_unique(__cache->__upcast());
+        __cache = __next;
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __deallocate_node(__cache);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __deallocate_node(__cache);
+    } catch (...) {
+      __deallocate_node(__cache);
+      throw;
     }
-    for (; __first != __last; ++__first)
-        __insert_unique(*__first);
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __deallocate_node(__cache);
+  }
+  for (; __first != __last; ++__first)
+    __insert_unique(*__first);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _InputIterator>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
-                                                         _InputIterator __last)
-{
-    typedef iterator_traits<_InputIterator> _ITraits;
-    typedef typename _ITraits::value_type _ItValueType;
-    static_assert((is_same<_ItValueType, __container_value_type>::value ||
-                  is_same<_ItValueType, __node_value_type>::value),
-                  "__assign_multi may only be called with the containers value type"
-                  " or the nodes value type");
-    if (bucket_count() != 0)
-    {
-        __next_pointer __cache = __detach();
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first, _InputIterator __last) {
+  typedef iterator_traits<_InputIterator> _ITraits;
+  typedef typename _ITraits::value_type _ItValueType;
+  static_assert(
+      (is_same<_ItValueType, __container_value_type>::value || is_same<_ItValueType, __node_value_type>::value),
+      "__assign_multi may only be called with the containers value type"
+      " or the nodes value type");
+  if (bucket_count() != 0) {
+    __next_pointer __cache = __detach();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (; __cache != nullptr && __first != __last; ++__first)
-            {
-                __cache->__upcast()->__value_ = *__first;
-                __next_pointer __next = __cache->__next_;
-                __node_insert_multi(__cache->__upcast());
-                __cache = __next;
-            }
+      for (; __cache != nullptr && __first != __last; ++__first) {
+        __cache->__upcast()->__get_value() = *__first;
+        __next_pointer __next              = __cache->__next_;
+        __node_insert_multi(__cache->__upcast());
+        __cache = __next;
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __deallocate_node(__cache);
-            throw;
-        }
+    } catch (...) {
+      __deallocate_node(__cache);
+      throw;
+    }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __deallocate_node(__cache);
-    }
-    for (; __first != __last; ++__first)
-        __insert_multi(_NodeTypes::__get_value(*__first));
+    __deallocate_node(__cache);
+  }
+  for (; __first != __last; ++__first)
+    __insert_multi(_NodeTypes::__get_value(*__first));
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() _NOEXCEPT
-{
-    return iterator(__p1_.first().__next_, this);
+inline typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() _NOEXCEPT {
+  return iterator(__p1_.first().__next_);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::end() _NOEXCEPT
-{
-    return iterator(nullptr, this);
+inline typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::end() _NOEXCEPT {
+  return iterator(nullptr);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() const _NOEXCEPT
-{
-    return const_iterator(__p1_.first().__next_, this);
+inline typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() const _NOEXCEPT {
+  return const_iterator(__p1_.first().__next_);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::end() const _NOEXCEPT
-{
-    return const_iterator(nullptr, this);
+inline typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::end() const _NOEXCEPT {
+  return const_iterator(nullptr);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT
-{
-    if (size() > 0)
-    {
-        __deallocate_node(__p1_.first().__next_);
-        __p1_.first().__next_ = nullptr;
-        size_type __bc = bucket_count();
-        for (size_type __i = 0; __i < __bc; ++__i)
-            __bucket_list_[__i] = nullptr;
-        size() = 0;
-    }
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT {
+  if (size() > 0) {
+    __deallocate_node(__p1_.first().__next_);
+    __p1_.first().__next_ = nullptr;
+    size_type __bc        = bucket_count();
+    for (size_type __i = 0; __i < __bc; ++__i)
+      __bucket_list_[__i] = nullptr;
+    size() = 0;
+  }
 }
 
-
 // Prepare the container for an insertion of the value __value with the hash
 // __hash. This does a lookup into the container to see if __value is already
 // present, and performs a rehash if necessary. Returns a pointer to the
@@ -1795,34 +1329,28 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT
 // Note that this function does forward exceptions if key_eq() throws, and never
 // mutates __value or actually inserts into the map.
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-_LIBCPP_INLINE_VISIBILITY
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__next_pointer
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique_prepare(
-    size_t __hash, value_type& __value)
-{
-    size_type __bc = bucket_count();
+_LIBCPP_HIDE_FROM_ABI typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__next_pointer
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique_prepare(size_t __hash, value_type& __value) {
+  size_type __bc = bucket_count();
 
-    if (__bc != 0)
-    {
-        size_t __chash = std::__constrain_hash(__hash, __bc);
-        __next_pointer __ndptr = __bucket_list_[__chash];
-        if (__ndptr != nullptr)
-        {
-            for (__ndptr = __ndptr->__next_; __ndptr != nullptr &&
-                                             std::__constrain_hash(__ndptr->__hash(), __bc) == __chash;
-                                                     __ndptr = __ndptr->__next_)
-            {
-                if (key_eq()(__ndptr->__upcast()->__value_, __value))
-                    return __ndptr;
-            }
-        }
+  if (__bc != 0) {
+    size_t __chash         = std::__constrain_hash(__hash, __bc);
+    __next_pointer __ndptr = __bucket_list_[__chash];
+    if (__ndptr != nullptr) {
+      for (__ndptr = __ndptr->__next_;
+           __ndptr != nullptr &&
+           (__ndptr->__hash() == __hash || std::__constrain_hash(__ndptr->__hash(), __bc) == __chash);
+           __ndptr = __ndptr->__next_) {
+        if ((__ndptr->__hash() == __hash) && key_eq()(__ndptr->__upcast()->__get_value(), __value))
+          return __ndptr;
+      }
     }
-    if (size()+1 > __bc * max_load_factor() || __bc == 0)
-    {
-        __rehash_unique(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
-                                     size_type(std::ceil(float(size() + 1) / max_load_factor()))));
-    }
-    return nullptr;
+  }
+  if (size() + 1 > __bc * max_load_factor() || __bc == 0) {
+    __rehash_unique(std::max<size_type>(
+        2 * __bc + !std::__is_hash_power2(__bc), size_type(std::ceil(float(size() + 1) / max_load_factor()))));
+  }
+  return nullptr;
 }
 
 // Insert the node __nd into the container by pushing it into the right bucket,
@@ -1830,50 +1358,41 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique_prepare(
 // rehashing has already occurred and that no element with the same key exists
 // in the map.
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-_LIBCPP_INLINE_VISIBILITY
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique_perform(
-    __node_pointer __nd) _NOEXCEPT
-{
-    size_type __bc = bucket_count();
-    size_t __chash = std::__constrain_hash(__nd->__hash(), __bc);
-    // insert_after __bucket_list_[__chash], or __first_node if bucket is null
-    __next_pointer __pn = __bucket_list_[__chash];
-    if (__pn == nullptr)
-    {
-        __pn =__p1_.first().__ptr();
-        __nd->__next_ = __pn->__next_;
-        __pn->__next_ = __nd->__ptr();
-        // fix up __bucket_list_
-        __bucket_list_[__chash] = __pn;
-        if (__nd->__next_ != nullptr)
-            __bucket_list_[std::__constrain_hash(__nd->__next_->__hash(), __bc)] = __nd->__ptr();
-    }
-    else
-    {
-        __nd->__next_ = __pn->__next_;
-        __pn->__next_ = __nd->__ptr();
-    }
-    ++size();
+_LIBCPP_HIDE_FROM_ABI void
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique_perform(__node_pointer __nd) _NOEXCEPT {
+  size_type __bc = bucket_count();
+  size_t __chash = std::__constrain_hash(__nd->__hash(), __bc);
+  // insert_after __bucket_list_[__chash], or __first_node if bucket is null
+  __next_pointer __pn = __bucket_list_[__chash];
+  if (__pn == nullptr) {
+    __pn          = __p1_.first().__ptr();
+    __nd->__next_ = __pn->__next_;
+    __pn->__next_ = __nd->__ptr();
+    // fix up __bucket_list_
+    __bucket_list_[__chash] = __pn;
+    if (__nd->__next_ != nullptr)
+      __bucket_list_[std::__constrain_hash(__nd->__next_->__hash(), __bc)] = __nd->__ptr();
+  } else {
+    __nd->__next_ = __pn->__next_;
+    __pn->__next_ = __nd->__ptr();
+  }
+  ++size();
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __nd)
-{
-    __nd->__hash_ = hash_function()(__nd->__value_);
-    __next_pointer __existing_node =
-        __node_insert_unique_prepare(__nd->__hash(), __nd->__value_);
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __nd) {
+  __nd->__hash_                  = hash_function()(__nd->__get_value());
+  __next_pointer __existing_node = __node_insert_unique_prepare(__nd->__hash(), __nd->__get_value());
 
-    // Insert the node, unless it already exists in the container.
-    bool __inserted = false;
-    if (__existing_node == nullptr)
-    {
-        __node_insert_unique_perform(__nd);
-        __existing_node = __nd->__ptr();
-        __inserted = true;
-    }
-    return pair<iterator, bool>(iterator(__existing_node, this), __inserted);
+  // Insert the node, unless it already exists in the container.
+  bool __inserted = false;
+  if (__existing_node == nullptr) {
+    __node_insert_unique_perform(__nd);
+    __existing_node = __nd->__ptr();
+    __inserted      = true;
+  }
+  return pair<iterator, bool>(iterator(__existing_node), __inserted);
 }
 
 // Prepare the container for an insertion of the value __cp_val with the hash
@@ -1885,40 +1404,34 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __
 // mutates __value or actually inserts into the map.
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__next_pointer
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_prepare(
-    size_t __cp_hash, value_type& __cp_val)
-{
-    size_type __bc = bucket_count();
-    if (size()+1 > __bc * max_load_factor() || __bc == 0)
-    {
-        __rehash_multi(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
-                       size_type(std::ceil(float(size() + 1) / max_load_factor()))));
-        __bc = bucket_count();
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_prepare(size_t __cp_hash, value_type& __cp_val) {
+  size_type __bc = bucket_count();
+  if (size() + 1 > __bc * max_load_factor() || __bc == 0) {
+    __rehash_multi(std::max<size_type>(
+        2 * __bc + !std::__is_hash_power2(__bc), size_type(std::ceil(float(size() + 1) / max_load_factor()))));
+    __bc = bucket_count();
+  }
+  size_t __chash      = std::__constrain_hash(__cp_hash, __bc);
+  __next_pointer __pn = __bucket_list_[__chash];
+  if (__pn != nullptr) {
+    for (bool __found = false;
+         __pn->__next_ != nullptr && std::__constrain_hash(__pn->__next_->__hash(), __bc) == __chash;
+         __pn = __pn->__next_) {
+      //      __found    key_eq()     action
+      //      false       false       loop
+      //      true        true        loop
+      //      false       true        set __found to true
+      //      true        false       break
+      if (__found !=
+          (__pn->__next_->__hash() == __cp_hash && key_eq()(__pn->__next_->__upcast()->__get_value(), __cp_val))) {
+        if (!__found)
+          __found = true;
+        else
+          break;
+      }
     }
-    size_t __chash = std::__constrain_hash(__cp_hash, __bc);
-    __next_pointer __pn = __bucket_list_[__chash];
-    if (__pn != nullptr)
-    {
-        for (bool __found = false; __pn->__next_ != nullptr &&
-                                   std::__constrain_hash(__pn->__next_->__hash(), __bc) == __chash;
-                                                           __pn = __pn->__next_)
-        {
-            //      __found    key_eq()     action
-            //      false       false       loop
-            //      true        true        loop
-            //      false       true        set __found to true
-            //      true        false       break
-            if (__found != (__pn->__next_->__hash() == __cp_hash &&
-                            key_eq()(__pn->__next_->__upcast()->__value_, __cp_val)))
-            {
-                if (!__found)
-                    __found = true;
-                else
-                    break;
-            }
-        }
-    }
-    return __pn;
+  }
+  return __pn;
 }
 
 // Insert the node __cp into the container after __pn (which is the last node in
@@ -1927,802 +1440,603 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_prepare(
 // all we need to do is update the bucket and size(). Assumes that __cp->__hash
 // is up-to-date.
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_perform(
-    __node_pointer __cp, __next_pointer __pn) _NOEXCEPT
-{
-    size_type __bc = bucket_count();
-    size_t __chash = std::__constrain_hash(__cp->__hash_, __bc);
-    if (__pn == nullptr)
-    {
-        __pn =__p1_.first().__ptr();
-        __cp->__next_ = __pn->__next_;
-        __pn->__next_ = __cp->__ptr();
-        // fix up __bucket_list_
-        __bucket_list_[__chash] = __pn;
-        if (__cp->__next_ != nullptr)
-            __bucket_list_[std::__constrain_hash(__cp->__next_->__hash(), __bc)]
-                = __cp->__ptr();
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi_perform(
+    __node_pointer __cp, __next_pointer __pn) _NOEXCEPT {
+  size_type __bc = bucket_count();
+  size_t __chash = std::__constrain_hash(__cp->__hash_, __bc);
+  if (__pn == nullptr) {
+    __pn          = __p1_.first().__ptr();
+    __cp->__next_ = __pn->__next_;
+    __pn->__next_ = __cp->__ptr();
+    // fix up __bucket_list_
+    __bucket_list_[__chash] = __pn;
+    if (__cp->__next_ != nullptr)
+      __bucket_list_[std::__constrain_hash(__cp->__next_->__hash(), __bc)] = __cp->__ptr();
+  } else {
+    __cp->__next_ = __pn->__next_;
+    __pn->__next_ = __cp->__ptr();
+    if (__cp->__next_ != nullptr) {
+      size_t __nhash = std::__constrain_hash(__cp->__next_->__hash(), __bc);
+      if (__nhash != __chash)
+        __bucket_list_[__nhash] = __cp->__ptr();
     }
-    else
-    {
-        __cp->__next_ = __pn->__next_;
-        __pn->__next_ = __cp->__ptr();
-        if (__cp->__next_ != nullptr)
-        {
-            size_t __nhash = std::__constrain_hash(__cp->__next_->__hash(), __bc);
-            if (__nhash != __chash)
-                __bucket_list_[__nhash] = __cp->__ptr();
-        }
+  }
+  ++size();
+}
+
+template <class _Tp, class _Hash, class _Equal, class _Alloc>
+typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __cp) {
+  __cp->__hash_       = hash_function()(__cp->__get_value());
+  __next_pointer __pn = __node_insert_multi_prepare(__cp->__hash(), __cp->__get_value());
+  __node_insert_multi_perform(__cp, __pn);
+
+  return iterator(__cp->__ptr());
+}
+
+template <class _Tp, class _Hash, class _Equal, class _Alloc>
+typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(const_iterator __p, __node_pointer __cp) {
+  if (__p != end() && key_eq()(*__p, __cp->__get_value())) {
+    __next_pointer __np = __p.__node_;
+    __cp->__hash_       = __np->__hash();
+    size_type __bc      = bucket_count();
+    if (size() + 1 > __bc * max_load_factor() || __bc == 0) {
+      __rehash_multi(std::max<size_type>(
+          2 * __bc + !std::__is_hash_power2(__bc), size_type(std::ceil(float(size() + 1) / max_load_factor()))));
+      __bc = bucket_count();
     }
+    size_t __chash      = std::__constrain_hash(__cp->__hash_, __bc);
+    __next_pointer __pp = __bucket_list_[__chash];
+    while (__pp->__next_ != __np)
+      __pp = __pp->__next_;
+    __cp->__next_ = __np;
+    __pp->__next_ = static_cast<__next_pointer>(__cp);
     ++size();
-}
-
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __cp)
-{
-    __cp->__hash_ = hash_function()(__cp->__value_);
-    __next_pointer __pn = __node_insert_multi_prepare(__cp->__hash(), __cp->__value_);
-    __node_insert_multi_perform(__cp, __pn);
-
-    return iterator(__cp->__ptr(), this);
+    return iterator(static_cast<__next_pointer>(__cp));
+  }
+  return __node_insert_multi(__cp);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(
-        const_iterator __p, __node_pointer __cp)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "unordered container::emplace_hint(const_iterator, args...) called with an iterator not"
-                         " referring to this unordered container");
-    if (__p != end() && key_eq()(*__p, __cp->__value_))
-    {
-        __next_pointer __np = __p.__node_;
-        __cp->__hash_ = __np->__hash();
-        size_type __bc = bucket_count();
-        if (size()+1 > __bc * max_load_factor() || __bc == 0)
-        {
-            __rehash_multi(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
-                           size_type(std::ceil(float(size() + 1) / max_load_factor()))));
-            __bc = bucket_count();
-        }
-        size_t __chash = std::__constrain_hash(__cp->__hash_, __bc);
-        __next_pointer __pp = __bucket_list_[__chash];
-        while (__pp->__next_ != __np)
-            __pp = __pp->__next_;
-        __cp->__next_ = __np;
-        __pp->__next_ = static_cast<__next_pointer>(__cp);
-        ++size();
-        return iterator(static_cast<__next_pointer>(__cp), this);
-    }
-    return __node_insert_multi(__cp);
-}
-
-
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-template <class _Key, class ..._Args>
+template <class _Key, class... _Args>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args)
-{
-
-    size_t __hash = hash_function()(__k);
-    size_type __bc = bucket_count();
-    bool __inserted = false;
-    __next_pointer __nd;
-    size_t __chash;
-    if (__bc != 0)
-    {
-        __chash = std::__constrain_hash(__hash, __bc);
-        __nd = __bucket_list_[__chash];
-        if (__nd != nullptr)
-        {
-            for (__nd = __nd->__next_; __nd != nullptr &&
-                (__nd->__hash() == __hash || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
-                                                           __nd = __nd->__next_)
-            {
-                if (key_eq()(__nd->__upcast()->__value_, __k))
-                    goto __done;
-            }
-        }
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args) {
+  size_t __hash   = hash_function()(__k);
+  size_type __bc  = bucket_count();
+  bool __inserted = false;
+  __next_pointer __nd;
+  size_t __chash;
+  if (__bc != 0) {
+    __chash = std::__constrain_hash(__hash, __bc);
+    __nd    = __bucket_list_[__chash];
+    if (__nd != nullptr) {
+      for (__nd = __nd->__next_;
+           __nd != nullptr && (__nd->__hash() == __hash || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
+           __nd = __nd->__next_) {
+        if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k))
+          goto __done;
+      }
     }
-    {
-        __node_holder __h = __construct_node_hash(__hash, _VSTD::forward<_Args>(__args)...);
-        if (size()+1 > __bc * max_load_factor() || __bc == 0)
-        {
-            __rehash_unique(_VSTD::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
-                           size_type(std::ceil(float(size() + 1) / max_load_factor()))));
-            __bc = bucket_count();
-            __chash = std::__constrain_hash(__hash, __bc);
-        }
-        // insert_after __bucket_list_[__chash], or __first_node if bucket is null
-        __next_pointer __pn = __bucket_list_[__chash];
-        if (__pn == nullptr)
-        {
-            __pn = __p1_.first().__ptr();
-            __h->__next_ = __pn->__next_;
-            __pn->__next_ = __h.get()->__ptr();
-            // fix up __bucket_list_
-            __bucket_list_[__chash] = __pn;
-            if (__h->__next_ != nullptr)
-                __bucket_list_[std::__constrain_hash(__h->__next_->__hash(), __bc)]
-                    = __h.get()->__ptr();
-        }
-        else
-        {
-            __h->__next_ = __pn->__next_;
-            __pn->__next_ = static_cast<__next_pointer>(__h.get());
-        }
-        __nd = static_cast<__next_pointer>(__h.release());
-        // increment size
-        ++size();
-        __inserted = true;
+  }
+  {
+    __node_holder __h = __construct_node_hash(__hash, std::forward<_Args>(__args)...);
+    if (size() + 1 > __bc * max_load_factor() || __bc == 0) {
+      __rehash_unique(std::max<size_type>(
+          2 * __bc + !std::__is_hash_power2(__bc), size_type(std::ceil(float(size() + 1) / max_load_factor()))));
+      __bc    = bucket_count();
+      __chash = std::__constrain_hash(__hash, __bc);
     }
+    // insert_after __bucket_list_[__chash], or __first_node if bucket is null
+    __next_pointer __pn = __bucket_list_[__chash];
+    if (__pn == nullptr) {
+      __pn          = __p1_.first().__ptr();
+      __h->__next_  = __pn->__next_;
+      __pn->__next_ = __h.get()->__ptr();
+      // fix up __bucket_list_
+      __bucket_list_[__chash] = __pn;
+      if (__h->__next_ != nullptr)
+        __bucket_list_[std::__constrain_hash(__h->__next_->__hash(), __bc)] = __h.get()->__ptr();
+    } else {
+      __h->__next_  = __pn->__next_;
+      __pn->__next_ = static_cast<__next_pointer>(__h.get());
+    }
+    __nd = static_cast<__next_pointer>(__h.release());
+    // increment size
+    ++size();
+    __inserted = true;
+  }
 __done:
-    return pair<iterator, bool>(iterator(__nd, this), __inserted);
+  return pair<iterator, bool>(iterator(__nd), __inserted);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class... _Args>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_impl(_Args&&... __args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    pair<iterator, bool> __r = __node_insert_unique(__h.get());
-    if (__r.second)
-        __h.release();
-    return __r;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_impl(_Args&&... __args) {
+  __node_holder __h        = __construct_node(std::forward<_Args>(__args)...);
+  pair<iterator, bool> __r = __node_insert_unique(__h.get());
+  if (__r.second)
+    __h.release();
+  return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class... _Args>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_multi(_Args&&... __args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    iterator __r = __node_insert_multi(__h.get());
-    __h.release();
-    return __r;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_multi(_Args&&... __args) {
+  __node_holder __h = __construct_node(std::forward<_Args>(__args)...);
+  iterator __r      = __node_insert_multi(__h.get());
+  __h.release();
+  return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class... _Args>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_hint_multi(
-        const_iterator __p, _Args&&... __args)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "unordered container::emplace_hint(const_iterator, args...) called with an iterator not"
-                         " referring to this unordered container");
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    iterator __r = __node_insert_multi(__p, __h.get());
-    __h.release();
-    return __r;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_hint_multi(const_iterator __p, _Args&&... __args) {
+  __node_holder __h = __construct_node(std::forward<_Args>(__args)...);
+  iterator __r      = __node_insert_multi(__p, __h.get());
+  __h.release();
+  return __r;
 }
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _NodeHandle, class _InsertReturnType>
-_LIBCPP_INLINE_VISIBILITY
-_InsertReturnType
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_insert_unique(
-    _NodeHandle&& __nh)
-{
-    if (__nh.empty())
-        return _InsertReturnType{end(), false, _NodeHandle()};
-    pair<iterator, bool> __result = __node_insert_unique(__nh.__ptr_);
-    if (__result.second)
-        __nh.__release_ptr();
-    return _InsertReturnType{__result.first, __result.second, _VSTD::move(__nh)};
+_LIBCPP_HIDE_FROM_ABI _InsertReturnType
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_insert_unique(_NodeHandle&& __nh) {
+  if (__nh.empty())
+    return _InsertReturnType{end(), false, _NodeHandle()};
+  pair<iterator, bool> __result = __node_insert_unique(__nh.__ptr_);
+  if (__result.second)
+    __nh.__release_ptr();
+  return _InsertReturnType{__result.first, __result.second, std::move(__nh)};
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _NodeHandle>
-_LIBCPP_INLINE_VISIBILITY
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_insert_unique(
-    const_iterator, _NodeHandle&& __nh)
-{
-    if (__nh.empty())
-        return end();
-    pair<iterator, bool> __result = __node_insert_unique(__nh.__ptr_);
-    if (__result.second)
-        __nh.__release_ptr();
-    return __result.first;
+_LIBCPP_HIDE_FROM_ABI typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_insert_unique(const_iterator, _NodeHandle&& __nh) {
+  if (__nh.empty())
+    return end();
+  pair<iterator, bool> __result = __node_insert_unique(__nh.__ptr_);
+  if (__result.second)
+    __nh.__release_ptr();
+  return __result.first;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _NodeHandle>
-_LIBCPP_INLINE_VISIBILITY
-_NodeHandle
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_extract(
-    key_type const& __key)
-{
-    iterator __i = find(__key);
-    if (__i == end())
-        return _NodeHandle();
-    return __node_handle_extract<_NodeHandle>(__i);
+_LIBCPP_HIDE_FROM_ABI _NodeHandle
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_extract(key_type const& __key) {
+  iterator __i = find(__key);
+  if (__i == end())
+    return _NodeHandle();
+  return __node_handle_extract<_NodeHandle>(__i);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _NodeHandle>
-_LIBCPP_INLINE_VISIBILITY
-_NodeHandle
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_extract(
-    const_iterator __p)
-{
-    allocator_type __alloc(__node_alloc());
-    return _NodeHandle(remove(__p).release(), __alloc);
+_LIBCPP_HIDE_FROM_ABI _NodeHandle __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_extract(const_iterator __p) {
+  allocator_type __alloc(__node_alloc());
+  return _NodeHandle(remove(__p).release(), __alloc);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Table>
-_LIBCPP_INLINE_VISIBILITY
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_merge_unique(
-    _Table& __source)
-{
-    static_assert(is_same<__node, typename _Table::__node>::value, "");
+_LIBCPP_HIDE_FROM_ABI void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_merge_unique(_Table& __source) {
+  static_assert(is_same<__node, typename _Table::__node>::value, "");
 
-    for (typename _Table::iterator __it = __source.begin();
-         __it != __source.end();)
-    {
-        __node_pointer __src_ptr = __it.__node_->__upcast();
-        size_t __hash = hash_function()(__src_ptr->__value_);
-        __next_pointer __existing_node =
-            __node_insert_unique_prepare(__hash, __src_ptr->__value_);
-        auto __prev_iter = __it++;
-        if (__existing_node == nullptr)
-        {
-            (void)__source.remove(__prev_iter).release();
-            __src_ptr->__hash_ = __hash;
-            __node_insert_unique_perform(__src_ptr);
-        }
+  for (typename _Table::iterator __it = __source.begin(); __it != __source.end();) {
+    __node_pointer __src_ptr       = __it.__node_->__upcast();
+    size_t __hash                  = hash_function()(__src_ptr->__get_value());
+    __next_pointer __existing_node = __node_insert_unique_prepare(__hash, __src_ptr->__get_value());
+    auto __prev_iter               = __it++;
+    if (__existing_node == nullptr) {
+      (void)__source.remove(__prev_iter).release();
+      __src_ptr->__hash_ = __hash;
+      __node_insert_unique_perform(__src_ptr);
     }
+  }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _NodeHandle>
-_LIBCPP_INLINE_VISIBILITY
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_insert_multi(
-    _NodeHandle&& __nh)
-{
-    if (__nh.empty())
-        return end();
-    iterator __result = __node_insert_multi(__nh.__ptr_);
-    __nh.__release_ptr();
-    return __result;
+_LIBCPP_HIDE_FROM_ABI typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_insert_multi(_NodeHandle&& __nh) {
+  if (__nh.empty())
+    return end();
+  iterator __result = __node_insert_multi(__nh.__ptr_);
+  __nh.__release_ptr();
+  return __result;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _NodeHandle>
-_LIBCPP_INLINE_VISIBILITY
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_insert_multi(
-    const_iterator __hint, _NodeHandle&& __nh)
-{
-    if (__nh.empty())
-        return end();
-    iterator __result = __node_insert_multi(__hint, __nh.__ptr_);
-    __nh.__release_ptr();
-    return __result;
+_LIBCPP_HIDE_FROM_ABI typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_insert_multi(const_iterator __hint, _NodeHandle&& __nh) {
+  if (__nh.empty())
+    return end();
+  iterator __result = __node_insert_multi(__hint, __nh.__ptr_);
+  __nh.__release_ptr();
+  return __result;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Table>
-_LIBCPP_INLINE_VISIBILITY
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_merge_multi(
-    _Table& __source)
-{
-    static_assert(is_same<typename _Table::__node, __node>::value, "");
+_LIBCPP_HIDE_FROM_ABI void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_handle_merge_multi(_Table& __source) {
+  static_assert(is_same<typename _Table::__node, __node>::value, "");
 
-    for (typename _Table::iterator __it = __source.begin();
-         __it != __source.end();)
-    {
-        __node_pointer __src_ptr = __it.__node_->__upcast();
-        size_t __src_hash = hash_function()(__src_ptr->__value_);
-        __next_pointer __pn =
-            __node_insert_multi_prepare(__src_hash, __src_ptr->__value_);
-        (void)__source.remove(__it++).release();
-        __src_ptr->__hash_ = __src_hash;
-        __node_insert_multi_perform(__src_ptr, __pn);
-    }
+  for (typename _Table::iterator __it = __source.begin(); __it != __source.end();) {
+    __node_pointer __src_ptr = __it.__node_->__upcast();
+    size_t __src_hash        = hash_function()(__src_ptr->__get_value());
+    __next_pointer __pn      = __node_insert_multi_prepare(__src_hash, __src_ptr->__get_value());
+    (void)__source.remove(__it++).release();
+    __src_ptr->__hash_ = __src_hash;
+    __node_insert_multi_perform(__src_ptr, __pn);
+  }
 }
 #endif // _LIBCPP_STD_VER >= 17
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <bool _UniqueKeys>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __n)
-_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-{
-    if (__n == 1)
-        __n = 2;
-    else if (__n & (__n - 1))
-        __n = std::__next_prime(__n);
-    size_type __bc = bucket_count();
-    if (__n > __bc)
-        __do_rehash<_UniqueKeys>(__n);
-    else if (__n < __bc)
-    {
-        __n = _VSTD::max<size_type>
-              (
-                  __n,
-                  std::__is_hash_power2(__bc) ? std::__next_hash_pow2(size_t(std::ceil(float(size()) / max_load_factor()))) :
-                                           std::__next_prime(size_t(std::ceil(float(size()) / max_load_factor())))
-              );
-        if (__n < __bc)
-            __do_rehash<_UniqueKeys>(__n);
-    }
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __n) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK {
+  if (__n == 1)
+    __n = 2;
+  else if (__n & (__n - 1))
+    __n = std::__next_prime(__n);
+  size_type __bc = bucket_count();
+  if (__n > __bc)
+    __do_rehash<_UniqueKeys>(__n);
+  else if (__n < __bc) {
+    __n = std::max<size_type>(
+        __n,
+        std::__is_hash_power2(__bc) ? std::__next_hash_pow2(size_t(std::ceil(float(size()) / max_load_factor())))
+                                    : std::__next_prime(size_t(std::ceil(float(size()) / max_load_factor()))));
+    if (__n < __bc)
+      __do_rehash<_UniqueKeys>(__n);
+  }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <bool _UniqueKeys>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__do_rehash(size_type __nbc)
-{
-    std::__debug_db_invalidate_all(this);
-    __pointer_allocator& __npa = __bucket_list_.get_deleter().__alloc();
-    __bucket_list_.reset(__nbc > 0 ?
-                      __pointer_alloc_traits::allocate(__npa, __nbc) : nullptr);
-    __bucket_list_.get_deleter().size() = __nbc;
-    if (__nbc > 0)
-    {
-        for (size_type __i = 0; __i < __nbc; ++__i)
-            __bucket_list_[__i] = nullptr;
-        __next_pointer __pp = __p1_.first().__ptr();
-        __next_pointer __cp = __pp->__next_;
-        if (__cp != nullptr)
-        {
-            size_type __chash = std::__constrain_hash(__cp->__hash(), __nbc);
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__do_rehash(size_type __nbc) {
+  __pointer_allocator& __npa = __bucket_list_.get_deleter().__alloc();
+  __bucket_list_.reset(__nbc > 0 ? __pointer_alloc_traits::allocate(__npa, __nbc) : nullptr);
+  __bucket_list_.get_deleter().size() = __nbc;
+  if (__nbc > 0) {
+    for (size_type __i = 0; __i < __nbc; ++__i)
+      __bucket_list_[__i] = nullptr;
+    __next_pointer __pp = __p1_.first().__ptr();
+    __next_pointer __cp = __pp->__next_;
+    if (__cp != nullptr) {
+      size_type __chash       = std::__constrain_hash(__cp->__hash(), __nbc);
+      __bucket_list_[__chash] = __pp;
+      size_type __phash       = __chash;
+      for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) {
+        __chash = std::__constrain_hash(__cp->__hash(), __nbc);
+        if (__chash == __phash)
+          __pp = __cp;
+        else {
+          if (__bucket_list_[__chash] == nullptr) {
             __bucket_list_[__chash] = __pp;
-            size_type __phash = __chash;
-            for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr;
-                                                           __cp = __pp->__next_)
-            {
-                __chash = std::__constrain_hash(__cp->__hash(), __nbc);
-                if (__chash == __phash)
-                    __pp = __cp;
-                else
-                {
-                    if (__bucket_list_[__chash] == nullptr)
-                    {
-                        __bucket_list_[__chash] = __pp;
-                        __pp = __cp;
-                        __phash = __chash;
-                    }
-                    else
-                    {
-                        __next_pointer __np = __cp;
-                        if _LIBCPP_CONSTEXPR_SINCE_CXX17 (!_UniqueKeys)
-                        {
-                            for (; __np->__next_ != nullptr &&
-                                   key_eq()(__cp->__upcast()->__value_,
-                                            __np->__next_->__upcast()->__value_);
-                                                               __np = __np->__next_)
-                                ;
-                        }
-                        __pp->__next_ = __np->__next_;
-                        __np->__next_ = __bucket_list_[__chash]->__next_;
-                        __bucket_list_[__chash]->__next_ = __cp;
-
-                    }
-                }
+            __pp                    = __cp;
+            __phash                 = __chash;
+          } else {
+            __next_pointer __np = __cp;
+            if _LIBCPP_CONSTEXPR_SINCE_CXX17 (!_UniqueKeys) {
+              for (; __np->__next_ != nullptr &&
+                     key_eq()(__cp->__upcast()->__get_value(), __np->__next_->__upcast()->__get_value());
+                   __np = __np->__next_)
+                ;
             }
+            __pp->__next_                    = __np->__next_;
+            __np->__next_                    = __bucket_list_[__chash]->__next_;
+            __bucket_list_[__chash]->__next_ = __cp;
+          }
         }
+      }
     }
+  }
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k)
-{
-    size_t __hash = hash_function()(__k);
-    size_type __bc = bucket_count();
-    if (__bc != 0)
-    {
-        size_t __chash = std::__constrain_hash(__hash, __bc);
-        __next_pointer __nd = __bucket_list_[__chash];
-        if (__nd != nullptr)
-        {
-            for (__nd = __nd->__next_; __nd != nullptr &&
-                (__nd->__hash() == __hash
-                  || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
-                                                           __nd = __nd->__next_)
-            {
-                if ((__nd->__hash() == __hash)
-                    && key_eq()(__nd->__upcast()->__value_, __k))
-                    return iterator(__nd, this);
-            }
-        }
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k) {
+  size_t __hash  = hash_function()(__k);
+  size_type __bc = bucket_count();
+  if (__bc != 0) {
+    size_t __chash      = std::__constrain_hash(__hash, __bc);
+    __next_pointer __nd = __bucket_list_[__chash];
+    if (__nd != nullptr) {
+      for (__nd = __nd->__next_;
+           __nd != nullptr && (__nd->__hash() == __hash || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
+           __nd = __nd->__next_) {
+        if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k))
+          return iterator(__nd);
+      }
     }
-    return end();
+  }
+  return end();
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k) const
-{
-    size_t __hash = hash_function()(__k);
-    size_type __bc = bucket_count();
-    if (__bc != 0)
-    {
-        size_t __chash = std::__constrain_hash(__hash, __bc);
-        __next_pointer __nd = __bucket_list_[__chash];
-        if (__nd != nullptr)
-        {
-            for (__nd = __nd->__next_; __nd != nullptr &&
-                (__hash == __nd->__hash()
-                    || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
-                                                           __nd = __nd->__next_)
-            {
-                if ((__nd->__hash() == __hash)
-                    && key_eq()(__nd->__upcast()->__value_, __k))
-                    return const_iterator(__nd, this);
-            }
-        }
-
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::find(const _Key& __k) const {
+  size_t __hash  = hash_function()(__k);
+  size_type __bc = bucket_count();
+  if (__bc != 0) {
+    size_t __chash      = std::__constrain_hash(__hash, __bc);
+    __next_pointer __nd = __bucket_list_[__chash];
+    if (__nd != nullptr) {
+      for (__nd = __nd->__next_;
+           __nd != nullptr && (__hash == __nd->__hash() || std::__constrain_hash(__nd->__hash(), __bc) == __chash);
+           __nd = __nd->__next_) {
+        if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k))
+          return const_iterator(__nd);
+      }
     }
-    return end();
+  }
+  return end();
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-template <class ..._Args>
+template <class... _Args>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&& ...__args)
-{
-    static_assert(!__is_hash_value_type<_Args...>::value,
-                  "Construct cannot be called with a hash value type");
-    __node_allocator& __na = __node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), _VSTD::forward<_Args>(__args)...);
-    __h.get_deleter().__value_constructed = true;
-    __h->__hash_ = hash_function()(__h->__value_);
-    __h->__next_ = nullptr;
-    return __h;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&&... __args) {
+  static_assert(!__is_hash_value_type<_Args...>::value, "Construct cannot be called with a hash value type");
+  __node_allocator& __na = __node_alloc();
+  __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
+
+  // Begin the lifetime of the node itself. Note that this doesn't begin the lifetime of the value
+  // held inside the node, since we need to use the allocator's construct() method for that.
+  //
+  // We don't use the allocator's construct() method to construct the node itself since the
+  // Cpp17FooInsertable named requirements don't require the allocator's construct() method
+  // to work on anything other than the value_type.
+  std::__construct_at(std::addressof(*__h), /* next = */ nullptr, /* hash = */ 0);
+
+  // Now construct the value_type using the allocator's construct() method.
+  __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__get_value()), std::forward<_Args>(__args)...);
+  __h.get_deleter().__value_constructed = true;
+
+  __h->__hash_ = hash_function()(__h->__get_value());
+  return __h;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-template <class _First, class ..._Rest>
+template <class _First, class... _Rest>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node_hash(
-    size_t __hash, _First&& __f, _Rest&& ...__rest)
-{
-    static_assert(!__is_hash_value_type<_First, _Rest...>::value,
-                  "Construct cannot be called with a hash value type");
-    __node_allocator& __na = __node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_),
-                             _VSTD::forward<_First>(__f),
-                             _VSTD::forward<_Rest>(__rest)...);
-    __h.get_deleter().__value_constructed = true;
-    __h->__hash_ = __hash;
-    __h->__next_ = nullptr;
-    return __h;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node_hash(size_t __hash, _First&& __f, _Rest&&... __rest) {
+  static_assert(!__is_hash_value_type<_First, _Rest...>::value, "Construct cannot be called with a hash value type");
+  __node_allocator& __na = __node_alloc();
+  __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
+  std::__construct_at(std::addressof(*__h), /* next = */ nullptr, /* hash = */ __hash);
+  __node_traits::construct(
+      __na, _NodeTypes::__get_ptr(__h->__get_value()), std::forward<_First>(__f), std::forward<_Rest>(__rest)...);
+  __h.get_deleter().__value_constructed = true;
+  return __h;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __p)
-{
-    __next_pointer __np = __p.__node_;
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "unordered container erase(iterator) called with an iterator not"
-                         " referring to this container");
-    _LIBCPP_ASSERT(__p != end(),
-                   "unordered container erase(iterator) called with a non-dereferenceable iterator");
-    iterator __r(__np, this);
-    ++__r;
-    remove(__p);
-    return __r;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __p) {
+  __next_pointer __np = __p.__node_;
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+      __p != end(), "unordered container::erase(iterator) called with a non-dereferenceable iterator");
+  iterator __r(__np);
+  ++__r;
+  remove(__p);
+  return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __first,
-                                                const_iterator __last)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__first)) == this,
-                         "unordered container::erase(iterator, iterator) called with an iterator not"
-                         " referring to this container");
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__last)) == this,
-                         "unordered container::erase(iterator, iterator) called with an iterator not"
-                         " referring to this container");
-    for (const_iterator __p = __first; __first != __last; __p = __first)
-    {
-        ++__first;
-        erase(__p);
-    }
-    __next_pointer __np = __last.__node_;
-    return iterator (__np, this);
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __first, const_iterator __last) {
+  for (const_iterator __p = __first; __first != __last; __p = __first) {
+    ++__first;
+    erase(__p);
+  }
+  __next_pointer __np = __last.__node_;
+  return iterator(__np);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__erase_unique(const _Key& __k)
-{
-    iterator __i = find(__k);
-    if (__i == end())
-        return 0;
-    erase(__i);
-    return 1;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__erase_unique(const _Key& __k) {
+  iterator __i = find(__k);
+  if (__i == end())
+    return 0;
+  erase(__i);
+  return 1;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__erase_multi(const _Key& __k)
-{
-    size_type __r = 0;
-    iterator __i = find(__k);
-    if (__i != end())
-    {
-        iterator __e = end();
-        do
-        {
-            erase(__i++);
-            ++__r;
-        } while (__i != __e && key_eq()(*__i, __k));
-    }
-    return __r;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__erase_multi(const _Key& __k) {
+  size_type __r = 0;
+  iterator __i  = find(__k);
+  if (__i != end()) {
+    iterator __e = end();
+    do {
+      erase(__i++);
+      ++__r;
+    } while (__i != __e && key_eq()(*__i, __k));
+  }
+  return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
-{
-    // current node
-    __next_pointer __cn = __p.__node_;
-    size_type __bc = bucket_count();
-    size_t __chash = std::__constrain_hash(__cn->__hash(), __bc);
-    // find previous node
-    __next_pointer __pn = __bucket_list_[__chash];
-    for (; __pn->__next_ != __cn; __pn = __pn->__next_)
-        ;
-    // Fix up __bucket_list_
-        // if __pn is not in same bucket (before begin is not in same bucket) &&
-        //    if __cn->__next_ is not in same bucket (nullptr is not in same bucket)
-    if (__pn == __p1_.first().__ptr()
-            || std::__constrain_hash(__pn->__hash(), __bc) != __chash)
-    {
-        if (__cn->__next_ == nullptr
-            || std::__constrain_hash(__cn->__next_->__hash(), __bc) != __chash)
-            __bucket_list_[__chash] = nullptr;
-    }
-        // if __cn->__next_ is not in same bucket (nullptr is in same bucket)
-    if (__cn->__next_ != nullptr)
-    {
-        size_t __nhash = std::__constrain_hash(__cn->__next_->__hash(), __bc);
-        if (__nhash != __chash)
-            __bucket_list_[__nhash] = __pn;
-    }
-    // remove __cn
-    __pn->__next_ = __cn->__next_;
-    __cn->__next_ = nullptr;
-    --size();
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    __c_node* __c = __get_db()->__find_c_and_lock(this);
-    for (__i_node** __dp = __c->end_; __dp != __c->beg_; )
-    {
-        --__dp;
-        iterator* __i = static_cast<iterator*>((*__dp)->__i_);
-        if (__i->__node_ == __cn)
-        {
-            (*__dp)->__c_ = nullptr;
-            if (--__c->end_ != __dp)
-                _VSTD::memmove(__dp, __dp+1, (__c->end_ - __dp)*sizeof(__i_node*));
-        }
-    }
-    __get_db()->unlock();
-#endif
-    return __node_holder(__cn->__upcast(), _Dp(__node_alloc(), true));
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT {
+  // current node
+  __next_pointer __cn = __p.__node_;
+  size_type __bc      = bucket_count();
+  size_t __chash      = std::__constrain_hash(__cn->__hash(), __bc);
+  // find previous node
+  __next_pointer __pn = __bucket_list_[__chash];
+  for (; __pn->__next_ != __cn; __pn = __pn->__next_)
+    ;
+  // Fix up __bucket_list_
+  // if __pn is not in same bucket (before begin is not in same bucket) &&
+  //    if __cn->__next_ is not in same bucket (nullptr is not in same bucket)
+  if (__pn == __p1_.first().__ptr() || std::__constrain_hash(__pn->__hash(), __bc) != __chash) {
+    if (__cn->__next_ == nullptr || std::__constrain_hash(__cn->__next_->__hash(), __bc) != __chash)
+      __bucket_list_[__chash] = nullptr;
+  }
+  // if __cn->__next_ is not in same bucket (nullptr is in same bucket)
+  if (__cn->__next_ != nullptr) {
+    size_t __nhash = std::__constrain_hash(__cn->__next_->__hash(), __bc);
+    if (__nhash != __chash)
+      __bucket_list_[__nhash] = __pn;
+  }
+  // remove __cn
+  __pn->__next_ = __cn->__next_;
+  __cn->__next_ = nullptr;
+  --size();
+  return __node_holder(__cn->__upcast(), _Dp(__node_alloc(), true));
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
-inline
-typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__count_unique(const _Key& __k) const
-{
-    return static_cast<size_type>(find(__k) != end());
+inline typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__count_unique(const _Key& __k) const {
+  return static_cast<size_type>(find(__k) != end());
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__count_multi(const _Key& __k) const
-{
-    size_type __r = 0;
-    const_iterator __i = find(__k);
-    if (__i != end())
-    {
-        const_iterator __e = end();
-        do
-        {
-            ++__i;
-            ++__r;
-        } while (__i != __e && key_eq()(*__i, __k));
-    }
-    return __r;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__count_multi(const _Key& __k) const {
+  size_type __r      = 0;
+  const_iterator __i = find(__k);
+  if (__i != end()) {
+    const_iterator __e = end();
+    do {
+      ++__i;
+      ++__r;
+    } while (__i != __e && key_eq()(*__i, __k));
+  }
+  return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator,
      typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_unique(
-        const _Key& __k)
-{
-    iterator __i = find(__k);
-    iterator __j = __i;
-    if (__i != end())
-        ++__j;
-    return pair<iterator, iterator>(__i, __j);
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_unique(const _Key& __k) {
+  iterator __i = find(__k);
+  iterator __j = __i;
+  if (__i != end())
+    ++__j;
+  return pair<iterator, iterator>(__i, __j);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator,
      typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_unique(
-        const _Key& __k) const
-{
-    const_iterator __i = find(__k);
-    const_iterator __j = __i;
-    if (__i != end())
-        ++__j;
-    return pair<const_iterator, const_iterator>(__i, __j);
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_unique(const _Key& __k) const {
+  const_iterator __i = find(__k);
+  const_iterator __j = __i;
+  if (__i != end())
+    ++__j;
+  return pair<const_iterator, const_iterator>(__i, __j);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator,
      typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_multi(
-        const _Key& __k)
-{
-    iterator __i = find(__k);
-    iterator __j = __i;
-    if (__i != end())
-    {
-        iterator __e = end();
-        do
-        {
-            ++__j;
-        } while (__j != __e && key_eq()(*__j, __k));
-    }
-    return pair<iterator, iterator>(__i, __j);
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_multi(const _Key& __k) {
+  iterator __i = find(__k);
+  iterator __j = __i;
+  if (__i != end()) {
+    iterator __e = end();
+    do {
+      ++__j;
+    } while (__j != __e && key_eq()(*__j, __k));
+  }
+  return pair<iterator, iterator>(__i, __j);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 template <class _Key>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator,
      typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator>
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_multi(
-        const _Key& __k) const
-{
-    const_iterator __i = find(__k);
-    const_iterator __j = __i;
-    if (__i != end())
-    {
-        const_iterator __e = end();
-        do
-        {
-            ++__j;
-        } while (__j != __e && key_eq()(*__j, __k));
-    }
-    return pair<const_iterator, const_iterator>(__i, __j);
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_multi(const _Key& __k) const {
+  const_iterator __i = find(__k);
+  const_iterator __j = __i;
+  if (__i != end()) {
+    const_iterator __e = end();
+    do {
+      ++__j;
+    } while (__j != __e && key_eq()(*__j, __k));
+  }
+  return pair<const_iterator, const_iterator>(__i, __j);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u)
+void __hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u)
 #if _LIBCPP_STD_VER <= 11
-    _NOEXCEPT_(
-        __is_nothrow_swappable<hasher>::value && __is_nothrow_swappable<key_equal>::value
-        && (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value
-              || __is_nothrow_swappable<__pointer_allocator>::value)
-        && (!__node_traits::propagate_on_container_swap::value
-              || __is_nothrow_swappable<__node_allocator>::value)
-            )
+    _NOEXCEPT_(__is_nothrow_swappable_v<hasher>&& __is_nothrow_swappable_v<key_equal> &&
+               (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value ||
+                __is_nothrow_swappable_v<__pointer_allocator>) &&
+               (!__node_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<__node_allocator>))
 #else
-  _NOEXCEPT_(__is_nothrow_swappable<hasher>::value && __is_nothrow_swappable<key_equal>::value)
+    _NOEXCEPT_(__is_nothrow_swappable_v<hasher>&& __is_nothrow_swappable_v<key_equal>)
 #endif
 {
-    _LIBCPP_ASSERT(__node_traits::propagate_on_container_swap::value ||
-                   this->__node_alloc() == __u.__node_alloc(),
-                   "list::swap: Either propagate_on_container_swap must be true"
-                   " or the allocators must compare equal");
-    {
+  _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+      __node_traits::propagate_on_container_swap::value || this->__node_alloc() == __u.__node_alloc(),
+      "unordered container::swap: Either propagate_on_container_swap "
+      "must be true or the allocators must compare equal");
+  {
     __node_pointer_pointer __npp = __bucket_list_.release();
     __bucket_list_.reset(__u.__bucket_list_.release());
     __u.__bucket_list_.reset(__npp);
-    }
-    _VSTD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
-    _VSTD::__swap_allocator(__bucket_list_.get_deleter().__alloc(),
-             __u.__bucket_list_.get_deleter().__alloc());
-    _VSTD::__swap_allocator(__node_alloc(), __u.__node_alloc());
-    _VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
-    __p2_.swap(__u.__p2_);
-    __p3_.swap(__u.__p3_);
-    if (size() > 0)
-        __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] =
-            __p1_.first().__ptr();
-    if (__u.size() > 0)
-        __u.__bucket_list_[std::__constrain_hash(__u.__p1_.first().__next_->__hash(), __u.bucket_count())] =
-            __u.__p1_.first().__ptr();
-    std::__debug_db_swap(this, std::addressof(__u));
+  }
+  std::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
+  std::__swap_allocator(__bucket_list_.get_deleter().__alloc(), __u.__bucket_list_.get_deleter().__alloc());
+  std::__swap_allocator(__node_alloc(), __u.__node_alloc());
+  std::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
+  __p2_.swap(__u.__p2_);
+  __p3_.swap(__u.__p3_);
+  if (size() > 0)
+    __bucket_list_[std::__constrain_hash(__p1_.first().__next_->__hash(), bucket_count())] = __p1_.first().__ptr();
+  if (__u.size() > 0)
+    __u.__bucket_list_[std::__constrain_hash(__u.__p1_.first().__next_->__hash(), __u.bucket_count())] =
+        __u.__p1_.first().__ptr();
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::size_type
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::bucket_size(size_type __n) const
-{
-    _LIBCPP_ASSERT(__n < bucket_count(),
-        "unordered container::bucket_size(n) called with n >= bucket_count()");
-    __next_pointer __np = __bucket_list_[__n];
-    size_type __bc = bucket_count();
-    size_type __r = 0;
-    if (__np != nullptr)
-    {
-        for (__np = __np->__next_; __np != nullptr &&
-                                   std::__constrain_hash(__np->__hash(), __bc) == __n;
-                                                         __np = __np->__next_, (void) ++__r)
-            ;
-    }
-    return __r;
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::bucket_size(size_type __n) const {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+      __n < bucket_count(), "unordered container::bucket_size(n) called with n >= bucket_count()");
+  __next_pointer __np = __bucket_list_[__n];
+  size_type __bc      = bucket_count();
+  size_type __r       = 0;
+  if (__np != nullptr) {
+    for (__np = __np->__next_; __np != nullptr && std::__constrain_hash(__np->__hash(), __bc) == __n;
+         __np = __np->__next_, (void)++__r)
+      ;
+  }
+  return __r;
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(__hash_table<_Tp, _Hash, _Equal, _Alloc>& __x,
-     __hash_table<_Tp, _Hash, _Equal, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(__hash_table<_Tp, _Hash, _Equal, _Alloc>& __x, __hash_table<_Tp, _Hash, _Equal, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-bool
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__dereferenceable(const const_iterator* __i) const
-{
-    return __i->__node_ != nullptr;
-}
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-bool
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__decrementable(const const_iterator*) const
-{
-    return false;
-}
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-bool
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__addable(const const_iterator*, ptrdiff_t) const
-{
-    return false;
-}
-
-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-bool
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__subscriptable(const const_iterator*, ptrdiff_t) const
-{
-    return false;
-}
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
-
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/__ios/fpos.h b/third_party/libcxx/__ios/fpos.h
index 87f0135fc..1af1e23ee 100644
--- a/third_party/libcxx/__ios/fpos.h
+++ b/third_party/libcxx/__ios/fpos.h
@@ -11,7 +11,7 @@
 #define _LIBCPP___IOS_FPOS_H
 
 #include <__config>
-#include <iosfwd>
+#include <__fwd/ios.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -57,20 +57,17 @@ public:
 };
 
 template <class _StateT>
-inline _LIBCPP_HIDE_FROM_ABI
-streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y) {
+inline _LIBCPP_HIDE_FROM_ABI streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y) {
   return streamoff(__x) - streamoff(__y);
 }
 
 template <class _StateT>
-inline _LIBCPP_HIDE_FROM_ABI
-bool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y) {
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const fpos<_StateT>& __x, const fpos<_StateT>& __y) {
   return streamoff(__x) == streamoff(__y);
 }
 
 template <class _StateT>
-inline _LIBCPP_HIDE_FROM_ABI
-bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y) {
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const fpos<_StateT>& __x, const fpos<_StateT>& __y) {
   return streamoff(__x) != streamoff(__y);
 }
 
diff --git a/third_party/libcxx/__iterator/access.h b/third_party/libcxx/__iterator/access.h
index d7bcb3378..acc4f60bf 100644
--- a/third_party/libcxx/__iterator/access.h
+++ b/third_party/libcxx/__iterator/access.h
@@ -20,106 +20,72 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, size_t _Np>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp*
-begin(_Tp (&__array)[_Np])
-{
-    return __array;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* begin(_Tp (&__array)[_Np]) _NOEXCEPT {
+  return __array;
 }
 
 template <class _Tp, size_t _Np>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp*
-end(_Tp (&__array)[_Np])
-{
-    return __array + _Np;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* end(_Tp (&__array)[_Np]) _NOEXCEPT {
+  return __array + _Np;
 }
 
 #if !defined(_LIBCPP_CXX03_LANG)
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto
-begin(_Cp& __c) -> decltype(__c.begin())
-{
-    return __c.begin();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto begin(_Cp& __c) -> decltype(__c.begin()) {
+  return __c.begin();
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto
-begin(const _Cp& __c) -> decltype(__c.begin())
-{
-    return __c.begin();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto begin(const _Cp& __c) -> decltype(__c.begin()) {
+  return __c.begin();
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto
-end(_Cp& __c) -> decltype(__c.end())
-{
-    return __c.end();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto end(_Cp& __c) -> decltype(__c.end()) {
+  return __c.end();
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto
-end(const _Cp& __c) -> decltype(__c.end())
-{
-    return __c.end();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto end(const _Cp& __c) -> decltype(__c.end()) {
+  return __c.end();
 }
 
-#if _LIBCPP_STD_VER >= 14
+#  if _LIBCPP_STD_VER >= 14
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-auto cbegin(const _Cp& __c) -> decltype(_VSTD::begin(__c))
-{
-    return _VSTD::begin(__c);
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+cbegin(const _Cp& __c) noexcept(noexcept(std::begin(__c))) -> decltype(std::begin(__c)) {
+  return std::begin(__c);
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-auto cend(const _Cp& __c) -> decltype(_VSTD::end(__c))
-{
-    return _VSTD::end(__c);
+_LIBCPP_HIDE_FROM_ABI constexpr auto cend(const _Cp& __c) noexcept(noexcept(std::end(__c))) -> decltype(std::end(__c)) {
+  return std::end(__c);
 }
 
-#endif
+#  endif
 
-
-#else  // defined(_LIBCPP_CXX03_LANG)
+#else // defined(_LIBCPP_CXX03_LANG)
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY
-typename _Cp::iterator
-begin(_Cp& __c)
-{
-    return __c.begin();
+_LIBCPP_HIDE_FROM_ABI typename _Cp::iterator begin(_Cp& __c) {
+  return __c.begin();
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY
-typename _Cp::const_iterator
-begin(const _Cp& __c)
-{
-    return __c.begin();
+_LIBCPP_HIDE_FROM_ABI typename _Cp::const_iterator begin(const _Cp& __c) {
+  return __c.begin();
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY
-typename _Cp::iterator
-end(_Cp& __c)
-{
-    return __c.end();
+_LIBCPP_HIDE_FROM_ABI typename _Cp::iterator end(_Cp& __c) {
+  return __c.end();
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY
-typename _Cp::const_iterator
-end(const _Cp& __c)
-{
-    return __c.end();
+_LIBCPP_HIDE_FROM_ABI typename _Cp::const_iterator end(const _Cp& __c) {
+  return __c.end();
 }
 
 #endif // !defined(_LIBCPP_CXX03_LANG)
diff --git a/third_party/libcxx/__iterator/advance.h b/third_party/libcxx/__iterator/advance.h
index c5f3c500d..296db1aaa 100644
--- a/third_party/libcxx/__iterator/advance.h
+++ b/third_party/libcxx/__iterator/advance.h
@@ -29,18 +29,21 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIter>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-void __advance(_InputIter& __i, typename iterator_traits<_InputIter>::difference_type __n, input_iterator_tag) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 void
+__advance(_InputIter& __i, typename iterator_traits<_InputIter>::difference_type __n, input_iterator_tag) {
   for (; __n > 0; --__n)
     ++__i;
 }
 
 template <class _BiDirIter>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-void __advance(_BiDirIter& __i, typename iterator_traits<_BiDirIter>::difference_type __n, bidirectional_iterator_tag) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 void
+__advance(_BiDirIter& __i, typename iterator_traits<_BiDirIter>::difference_type __n, bidirectional_iterator_tag) {
   if (__n >= 0)
     for (; __n > 0; --__n)
       ++__i;
@@ -50,22 +53,22 @@ void __advance(_BiDirIter& __i, typename iterator_traits<_BiDirIter>::difference
 }
 
 template <class _RandIter>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-void __advance(_RandIter& __i, typename iterator_traits<_RandIter>::difference_type __n, random_access_iterator_tag) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 void
+__advance(_RandIter& __i, typename iterator_traits<_RandIter>::difference_type __n, random_access_iterator_tag) {
   __i += __n;
 }
 
-template <
-    class _InputIter, class _Distance,
-    class _IntegralDistance = decltype(_VSTD::__convert_to_integral(std::declval<_Distance>())),
-    class = __enable_if_t<is_integral<_IntegralDistance>::value> >
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-void advance(_InputIter& __i, _Distance __orig_n) {
+template < class _InputIter,
+           class _Distance,
+           class _IntegralDistance = decltype(std::__convert_to_integral(std::declval<_Distance>())),
+           __enable_if_t<is_integral<_IntegralDistance>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 void advance(_InputIter& __i, _Distance __orig_n) {
   typedef typename iterator_traits<_InputIter>::difference_type _Difference;
-  _Difference __n = static_cast<_Difference>(_VSTD::__convert_to_integral(__orig_n));
-  _LIBCPP_ASSERT(__n >= 0 || __has_bidirectional_iterator_category<_InputIter>::value,
-                 "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
-  _VSTD::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
+  _Difference __n = static_cast<_Difference>(std::__convert_to_integral(__orig_n));
+  // Calling `advance` with a negative value on a non-bidirectional iterator is a no-op in the current implementation.
+  _LIBCPP_ASSERT_PEDANTIC(__n >= 0 || __has_bidirectional_iterator_category<_InputIter>::value,
+                          "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
+  std::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
 }
 
 #if _LIBCPP_STD_VER >= 20
@@ -78,8 +81,7 @@ namespace __advance {
 struct __fn {
 private:
   template <class _Ip>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr void __advance_forward(_Ip& __i, iter_difference_t<_Ip> __n) {
+  _LIBCPP_HIDE_FROM_ABI static constexpr void __advance_forward(_Ip& __i, iter_difference_t<_Ip> __n) {
     while (__n > 0) {
       --__n;
       ++__i;
@@ -87,8 +89,7 @@ private:
   }
 
   template <class _Ip>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr void __advance_backward(_Ip& __i, iter_difference_t<_Ip> __n) {
+  _LIBCPP_HIDE_FROM_ABI static constexpr void __advance_backward(_Ip& __i, iter_difference_t<_Ip> __n) {
     while (__n < 0) {
       ++__n;
       --__i;
@@ -98,10 +99,10 @@ private:
 public:
   // Preconditions: If `I` does not model `bidirectional_iterator`, `n` is not negative.
   template <input_or_output_iterator _Ip>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr void operator()(_Ip& __i, iter_difference_t<_Ip> __n) const {
-    _LIBCPP_ASSERT(__n >= 0 || bidirectional_iterator<_Ip>,
-                   "If `n < 0`, then `bidirectional_iterator<I>` must be true.");
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Ip& __i, iter_difference_t<_Ip> __n) const {
+    // Calling `advance` with a negative value on a non-bidirectional iterator is a no-op in the current implementation.
+    _LIBCPP_ASSERT_PEDANTIC(
+        __n >= 0 || bidirectional_iterator<_Ip>, "If `n < 0`, then `bidirectional_iterator<I>` must be true.");
 
     // If `I` models `random_access_iterator`, equivalent to `i += n`.
     if constexpr (random_access_iterator<_Ip>) {
@@ -120,14 +121,16 @@ public:
     }
   }
 
-  // Preconditions: Either `assignable_from<I&, S> || sized_sentinel_for<S, I>` is modeled, or [i, bound_sentinel) denotes a range.
+  // Preconditions: Either `assignable_from<I&, S> || sized_sentinel_for<S, I>` is modeled, or [i, bound_sentinel)
+  // denotes a range.
   template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
   _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Ip& __i, _Sp __bound_sentinel) const {
     // If `I` and `S` model `assignable_from<I&, S>`, equivalent to `i = std::move(bound_sentinel)`.
     if constexpr (assignable_from<_Ip&, _Sp>) {
-      __i = _VSTD::move(__bound_sentinel);
+      __i = std::move(__bound_sentinel);
     }
-    // Otherwise, if `S` and `I` model `sized_sentinel_for<S, I>`, equivalent to `ranges::advance(i, bound_sentinel - i)`.
+    // Otherwise, if `S` and `I` model `sized_sentinel_for<S, I>`, equivalent to `ranges::advance(i, bound_sentinel -
+    // i)`.
     else if constexpr (sized_sentinel_for<_Sp, _Ip>) {
       (*this)(__i, __bound_sentinel - __i);
     }
@@ -142,22 +145,20 @@ public:
   // Preconditions:
   //   * If `n > 0`, [i, bound_sentinel) denotes a range.
   //   * If `n == 0`, [i, bound_sentinel) or [bound_sentinel, i) denotes a range.
-  //   * If `n < 0`, [bound_sentinel, i) denotes a range, `I` models `bidirectional_iterator`, and `I` and `S` model `same_as<I, S>`.
+  //   * If `n < 0`, [bound_sentinel, i) denotes a range, `I` models `bidirectional_iterator`, and `I` and `S` model
+  //   `same_as<I, S>`.
   // Returns: `n - M`, where `M` is the difference between the ending and starting position.
   template <input_or_output_iterator _Ip, sentinel_for<_Ip> _Sp>
-  _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Ip> operator()(_Ip& __i, iter_difference_t<_Ip> __n,
-                                                                    _Sp __bound_sentinel) const {
-    _LIBCPP_ASSERT((__n >= 0) || (bidirectional_iterator<_Ip> && same_as<_Ip, _Sp>),
-                   "If `n < 0`, then `bidirectional_iterator<I> && same_as<I, S>` must be true.");
+  _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Ip>
+  operator()(_Ip& __i, iter_difference_t<_Ip> __n, _Sp __bound_sentinel) const {
+    // Calling `advance` with a negative value on a non-bidirectional iterator is a no-op in the current implementation.
+    _LIBCPP_ASSERT_PEDANTIC((__n >= 0) || (bidirectional_iterator<_Ip> && same_as<_Ip, _Sp>),
+                            "If `n < 0`, then `bidirectional_iterator<I> && same_as<I, S>` must be true.");
     // If `S` and `I` model `sized_sentinel_for<S, I>`:
     if constexpr (sized_sentinel_for<_Sp, _Ip>) {
       // If |n| >= |bound_sentinel - i|, equivalent to `ranges::advance(i, bound_sentinel)`.
       // __magnitude_geq(a, b) returns |a| >= |b|, assuming they have the same sign.
-      auto __magnitude_geq = [](auto __a, auto __b) {
-        return __a == 0 ? __b == 0 :
-               __a > 0  ? __a >= __b :
-                          __a <= __b;
-      };
+      auto __magnitude_geq = [](auto __a, auto __b) { return __a == 0 ? __b == 0 : __a > 0 ? __a >= __b : __a <= __b; };
       if (const auto __m = __bound_sentinel - __i; __magnitude_geq(__n, __m)) {
         (*this)(__i, __bound_sentinel);
         return __n - __m;
@@ -169,14 +170,14 @@ public:
     } else {
       // Otherwise, if `n` is non-negative, while `bool(i != bound_sentinel)` is true, increments `i` but at
       // most `n` times.
-      while (__i != __bound_sentinel && __n > 0) {
+      while (__n > 0 && __i != __bound_sentinel) {
         ++__i;
         --__n;
       }
 
       // Otherwise, while `bool(i != bound_sentinel)` is true, decrements `i` but at most `-n` times.
       if constexpr (bidirectional_iterator<_Ip> && same_as<_Ip, _Sp>) {
-        while (__i != __bound_sentinel && __n < 0) {
+        while (__n < 0 && __i != __bound_sentinel) {
           --__i;
           ++__n;
         }
@@ -191,7 +192,7 @@ public:
 } // namespace __advance
 
 inline namespace __cpo {
-  inline constexpr auto advance = __advance::__fn{};
+inline constexpr auto advance = __advance::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -199,4 +200,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_ADVANCE_H
diff --git a/third_party/libcxx/__iterator/aliasing_iterator.h b/third_party/libcxx/__iterator/aliasing_iterator.h
new file mode 100644
index 000000000..94ba57707
--- /dev/null
+++ b/third_party/libcxx/__iterator/aliasing_iterator.h
@@ -0,0 +1,127 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ITERATOR_ALIASING_ITERATOR_H
+#define _LIBCPP___ITERATOR_ALIASING_ITERATOR_H
+
+#include <__config>
+#include <__iterator/iterator_traits.h>
+#include <__memory/pointer_traits.h>
+#include <__type_traits/is_trivial.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+// This iterator wrapper is used to type-pun an iterator to return a different type. This is done without UB by not
+// actually punning the type, but instead inspecting the object representation of the base type and copying that into
+// an instance of the alias type. For that reason the alias type has to be trivial. The alias is returned as a prvalue
+// when derferencing the iterator, since it is temporary storage. This wrapper is used to vectorize some algorithms.
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _BaseIter, class _Alias>
+struct __aliasing_iterator_wrapper {
+  class __iterator {
+    _BaseIter __base_ = nullptr;
+
+    using __iter_traits     = iterator_traits<_BaseIter>;
+    using __base_value_type = typename __iter_traits::value_type;
+
+    static_assert(__has_random_access_iterator_category<_BaseIter>::value,
+                  "The base iterator has to be a random access iterator!");
+
+  public:
+    using iterator_category = random_access_iterator_tag;
+    using value_type        = _Alias;
+    using difference_type   = ptrdiff_t;
+    using reference         = value_type&;
+    using pointer           = value_type*;
+
+    static_assert(is_trivial<value_type>::value);
+    static_assert(sizeof(__base_value_type) == sizeof(value_type));
+
+    _LIBCPP_HIDE_FROM_ABI __iterator() = default;
+    _LIBCPP_HIDE_FROM_ABI __iterator(_BaseIter __base) _NOEXCEPT : __base_(__base) {}
+
+    _LIBCPP_HIDE_FROM_ABI __iterator& operator++() _NOEXCEPT {
+      ++__base_;
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI __iterator operator++(int) _NOEXCEPT {
+      __iterator __tmp(*this);
+      ++__base_;
+      return __tmp;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI __iterator& operator--() _NOEXCEPT {
+      --__base_;
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI __iterator operator--(int) _NOEXCEPT {
+      __iterator __tmp(*this);
+      --__base_;
+      return __tmp;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend __iterator operator+(__iterator __iter, difference_type __n) _NOEXCEPT {
+      return __iterator(__iter.__base_ + __n);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend __iterator operator+(difference_type __n, __iterator __iter) _NOEXCEPT {
+      return __iterator(__n + __iter.__base_);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI __iterator& operator+=(difference_type __n) _NOEXCEPT {
+      __base_ += __n;
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend __iterator operator-(__iterator __iter, difference_type __n) _NOEXCEPT {
+      return __iterator(__iter.__base_ - __n);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend difference_type operator-(__iterator __lhs, __iterator __rhs) _NOEXCEPT {
+      return __lhs.__base_ - __rhs.__base_;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI __iterator& operator-=(difference_type __n) _NOEXCEPT {
+      __base_ -= __n;
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI _BaseIter __base() const _NOEXCEPT { return __base_; }
+
+    _LIBCPP_HIDE_FROM_ABI _Alias operator*() const _NOEXCEPT {
+      _Alias __val;
+      __builtin_memcpy(&__val, std::__to_address(__base_), sizeof(value_type));
+      return __val;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI value_type operator[](difference_type __n) const _NOEXCEPT { return *(*this + __n); }
+
+    _LIBCPP_HIDE_FROM_ABI friend bool operator==(const __iterator& __lhs, const __iterator& __rhs) _NOEXCEPT {
+      return __lhs.__base_ == __rhs.__base_;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend bool operator!=(const __iterator& __lhs, const __iterator& __rhs) _NOEXCEPT {
+      return __lhs.__base_ != __rhs.__base_;
+    }
+  };
+};
+
+// This is required to avoid ADL instantiations on _BaseT
+template <class _BaseT, class _Alias>
+using __aliasing_iterator = typename __aliasing_iterator_wrapper<_BaseT, _Alias>::__iterator;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_ALIASING_ITERATOR_H
diff --git a/third_party/libcxx/__iterator/back_insert_iterator.h b/third_party/libcxx/__iterator/back_insert_iterator.h
index dc656e381..6d3dd4b12 100644
--- a/third_party/libcxx/__iterator/back_insert_iterator.h
+++ b/third_party/libcxx/__iterator/back_insert_iterator.h
@@ -21,6 +21,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
@@ -30,44 +33,53 @@ class _LIBCPP_TEMPLATE_VIS back_insert_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 #endif
 {
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
 protected:
-    _Container* container;
+  _Container* container;
+
 public:
-    typedef output_iterator_tag iterator_category;
-    typedef void value_type;
+  typedef output_iterator_tag iterator_category;
+  typedef void value_type;
 #if _LIBCPP_STD_VER >= 20
-    typedef ptrdiff_t difference_type;
+  typedef ptrdiff_t difference_type;
 #else
-    typedef void difference_type;
+  typedef void difference_type;
 #endif
-    typedef void pointer;
-    typedef void reference;
-    typedef _Container container_type;
+  typedef void pointer;
+  typedef void reference;
+  typedef _Container container_type;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator& operator=(const typename _Container::value_type& __value)
-        {container->push_back(__value); return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit back_insert_iterator(_Container& __x)
+      : container(std::addressof(__x)) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator&
+  operator=(const typename _Container::value_type& __value) {
+    container->push_back(__value);
+    return *this;
+  }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator& operator=(typename _Container::value_type&& __value)
-        {container->push_back(_VSTD::move(__value)); return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator&
+  operator=(typename _Container::value_type&& __value) {
+    container->push_back(std::move(__value));
+    return *this;
+  }
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator& operator*()     {return *this;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator& operator++()    {return *this;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator  operator++(int) {return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator& operator*() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator& operator++() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator operator++(int) { return *this; }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Container* __get_container() const { return container; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Container* __get_container() const { return container; }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(back_insert_iterator);
 
 template <class _Container>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-back_insert_iterator<_Container>
-back_inserter(_Container& __x)
-{
-    return back_insert_iterator<_Container>(__x);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 back_insert_iterator<_Container>
+back_inserter(_Container& __x) {
+  return back_insert_iterator<_Container>(__x);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_BACK_INSERT_ITERATOR_H
diff --git a/third_party/libcxx/__iterator/bounded_iter.h b/third_party/libcxx/__iterator/bounded_iter.h
index 329fd924d..a8f66f4a0 100644
--- a/third_party/libcxx/__iterator/bounded_iter.h
+++ b/third_party/libcxx/__iterator/bounded_iter.h
@@ -23,18 +23,28 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Iterator wrapper that carries the valid range it is allowed to access.
 //
 // This is a simple iterator wrapper for contiguous iterators that points
-// within a [begin, end) range and carries these bounds with it. The iterator
-// ensures that it is pointing within that [begin, end) range when it is
-// dereferenced.
+// within a [begin, end] range and carries these bounds with it. The iterator
+// ensures that it is pointing within [begin, end) range when it is
+// dereferenced. It also ensures that it is never iterated outside of
+// [begin, end]. This is important for two reasons:
 //
-// Arithmetic operations are allowed and the bounds of the resulting iterator
-// are not checked. Hence, it is possible to create an iterator pointing outside
-// its range, but it is not possible to dereference it.
+// 1. It allows `operator*` and `operator++` bounds checks to be `iter != end`.
+//    This is both less for the optimizer to prove, and aligns with how callers
+//    typically use iterators.
+//
+// 2. Advancing an iterator out of bounds is undefined behavior (see the table
+//    in [input.iterators]). In particular, when the underlying iterator is a
+//    pointer, it is undefined at the language level (see [expr.add]). If
+//    bounded iterators exhibited this undefined behavior, we risk compiler
+//    optimizations deleting non-redundant bounds checks.
 template <class _Iterator, class = __enable_if_t< __libcpp_is_contiguous_iterator<_Iterator>::value > >
 struct __bounded_iter {
   using value_type        = typename iterator_traits<_Iterator>::value_type;
@@ -48,14 +58,14 @@ struct __bounded_iter {
 
   // Create a singular iterator.
   //
-  // Such an iterator does not point to any object and is conceptually out of bounds, so it is
-  // not dereferenceable. Observing operations like comparison and assignment are valid.
+  // Such an iterator points past the end of an empty span, so it is not dereferenceable.
+  // Observing operations like comparison and assignment are valid.
   _LIBCPP_HIDE_FROM_ABI __bounded_iter() = default;
 
   _LIBCPP_HIDE_FROM_ABI __bounded_iter(__bounded_iter const&) = default;
   _LIBCPP_HIDE_FROM_ABI __bounded_iter(__bounded_iter&&)      = default;
 
-  template <class _OtherIterator, class = __enable_if_t< is_convertible<_OtherIterator, _Iterator>::value > >
+  template <class _OtherIterator, __enable_if_t< is_convertible<_OtherIterator, _Iterator>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __bounded_iter(__bounded_iter<_OtherIterator> const& __other) _NOEXCEPT
       : __current_(__other.__current_),
         __begin_(__other.__begin_),
@@ -67,18 +77,20 @@ struct __bounded_iter {
 
 private:
   // Create an iterator wrapping the given iterator, and whose bounds are described
-  // by the provided [begin, end) range.
+  // by the provided [begin, end] range.
   //
-  // This constructor does not check whether the resulting iterator is within its bounds.
-  // However, it does check that the provided [begin, end) range is a valid range (that
-  // is, begin <= end).
+  // The constructor does not check whether the resulting iterator is within its bounds. It is a
+  // responsibility of the container to ensure that the given bounds are valid.
   //
   // Since it is non-standard for iterators to have this constructor, __bounded_iter must
   // be created via `std::__make_bounded_iter`.
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __bounded_iter(
-      _Iterator __current, _Iterator __begin, _Iterator __end)
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __bounded_iter(_Iterator __current, _Iterator __begin, _Iterator __end)
       : __current_(__current), __begin_(__begin), __end_(__end) {
-    _LIBCPP_ASSERT(__begin <= __end, "__bounded_iter(current, begin, end): [begin, end) is not a valid range");
+    _LIBCPP_ASSERT_INTERNAL(
+        __begin <= __current, "__bounded_iter(current, begin, end): current and begin are inconsistent");
+    _LIBCPP_ASSERT_INTERNAL(
+        __current <= __end, "__bounded_iter(current, begin, end): current and end are inconsistent");
   }
 
   template <class _It>
@@ -87,30 +99,37 @@ private:
 public:
   // Dereference and indexing operations.
   //
-  // These operations check that the iterator is dereferenceable, that is within [begin, end).
+  // These operations check that the iterator is dereferenceable. Since the class invariant is
+  // that the iterator is always within `[begin, end]`, we only need to check it's not pointing to
+  // `end`. This is easier for the optimizer because it aligns with the `iter != container.end()`
+  // checks that typical callers already use (see
+  // https://github.com/llvm/llvm-project/issues/78829).
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference operator*() const _NOEXCEPT {
-    _LIBCPP_ASSERT(
-        __in_bounds(__current_), "__bounded_iter::operator*: Attempt to dereference an out-of-range iterator");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __current_ != __end_, "__bounded_iter::operator*: Attempt to dereference an iterator at the end");
     return *__current_;
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pointer operator->() const _NOEXCEPT {
-    _LIBCPP_ASSERT(
-        __in_bounds(__current_), "__bounded_iter::operator->: Attempt to dereference an out-of-range iterator");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __current_ != __end_, "__bounded_iter::operator->: Attempt to dereference an iterator at the end");
     return std::__to_address(__current_);
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference operator[](difference_type __n) const _NOEXCEPT {
-    _LIBCPP_ASSERT(
-        __in_bounds(__current_ + __n), "__bounded_iter::operator[]: Attempt to index an iterator out-of-range");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __n >= __begin_ - __current_, "__bounded_iter::operator[]: Attempt to index an iterator past the start");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __n < __end_ - __current_, "__bounded_iter::operator[]: Attempt to index an iterator at or past the end");
     return __current_[__n];
   }
 
   // Arithmetic operations.
   //
-  // These operations do not check that the resulting iterator is within the bounds, since that
-  // would make it impossible to create a past-the-end iterator.
+  // These operations check that the iterator remains within `[begin, end]`.
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __bounded_iter& operator++() _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __current_ != __end_, "__bounded_iter::operator++: Attempt to advance an iterator past the end");
     ++__current_;
     return *this;
   }
@@ -121,6 +140,8 @@ public:
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __bounded_iter& operator--() _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __current_ != __begin_, "__bounded_iter::operator--: Attempt to rewind an iterator past the start");
     --__current_;
     return *this;
   }
@@ -131,6 +152,10 @@ public:
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __bounded_iter& operator+=(difference_type __n) _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __n >= __begin_ - __current_, "__bounded_iter::operator+=: Attempt to rewind an iterator past the start");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __n <= __end_ - __current_, "__bounded_iter::operator+=: Attempt to advance an iterator past the end");
     __current_ += __n;
     return *this;
   }
@@ -148,6 +173,10 @@ public:
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __bounded_iter& operator-=(difference_type __n) _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __n <= __current_ - __begin_, "__bounded_iter::operator-=: Attempt to rewind an iterator past the start");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __n >= __current_ - __end_, "__bounded_iter::operator-=: Attempt to advance an iterator past the end");
     __current_ -= __n;
     return *this;
   }
@@ -194,15 +223,10 @@ public:
   }
 
 private:
-  // Return whether the given iterator is in the bounds of this __bounded_iter.
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __in_bounds(_Iterator const& __iter) const {
-    return __iter >= __begin_ && __iter < __end_;
-  }
-
   template <class>
   friend struct pointer_traits;
   _Iterator __current_;       // current iterator
-  _Iterator __begin_, __end_; // valid range represented as [begin, end)
+  _Iterator __begin_, __end_; // valid range represented as [begin, end]
 };
 
 template <class _It>
@@ -228,4 +252,6 @@ struct pointer_traits<__bounded_iter<_Iterator> > {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_BOUNDED_ITER_H
diff --git a/third_party/libcxx/__iterator/common_iterator.h b/third_party/libcxx/__iterator/common_iterator.h
index e1d114ab9..199de2cc7 100644
--- a/third_party/libcxx/__iterator/common_iterator.h
+++ b/third_party/libcxx/__iterator/common_iterator.h
@@ -34,119 +34,131 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-template<class _Iter>
+template <class _Iter>
 concept __can_use_postfix_proxy =
-  constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>> &&
-  move_constructible<iter_value_t<_Iter>>;
+    constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>> && move_constructible<iter_value_t<_Iter>>;
 
-template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
-  requires (!same_as<_Iter, _Sent> && copyable<_Iter>)
+template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+  requires(!same_as<_Iter, _Sent> && copyable<_Iter>)
 class common_iterator {
   struct __proxy {
     _LIBCPP_HIDE_FROM_ABI constexpr const iter_value_t<_Iter>* operator->() const noexcept {
-      return _VSTD::addressof(__value_);
+      return std::addressof(__value_);
     }
     iter_value_t<_Iter> __value_;
   };
 
   struct __postfix_proxy {
-    _LIBCPP_HIDE_FROM_ABI constexpr const iter_value_t<_Iter>& operator*() const noexcept {
-      return __value_;
-    }
+    _LIBCPP_HIDE_FROM_ABI constexpr const iter_value_t<_Iter>& operator*() const noexcept { return __value_; }
     iter_value_t<_Iter> __value_;
   };
 
-public:
   variant<_Iter, _Sent> __hold_;
+  template <input_or_output_iterator _OtherIter, sentinel_for<_OtherIter> _OtherSent>
+    requires(!same_as<_OtherIter, _OtherSent> && copyable<_OtherIter>)
+  friend class common_iterator;
 
-  _LIBCPP_HIDE_FROM_ABI common_iterator() requires default_initializable<_Iter> = default;
+public:
+  _LIBCPP_HIDE_FROM_ABI common_iterator()
+    requires default_initializable<_Iter>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr common_iterator(_Iter __i) : __hold_(in_place_type<_Iter>, _VSTD::move(__i)) {}
-  _LIBCPP_HIDE_FROM_ABI constexpr common_iterator(_Sent __s) : __hold_(in_place_type<_Sent>, _VSTD::move(__s)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr common_iterator(_Iter __i) : __hold_(in_place_type<_Iter>, std::move(__i)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr common_iterator(_Sent __s) : __hold_(in_place_type<_Sent>, std::move(__s)) {}
 
-  template<class _I2, class _S2>
+  template <class _I2, class _S2>
     requires convertible_to<const _I2&, _Iter> && convertible_to<const _S2&, _Sent>
   _LIBCPP_HIDE_FROM_ABI constexpr common_iterator(const common_iterator<_I2, _S2>& __other)
-    : __hold_([&]() -> variant<_Iter, _Sent> {
-      _LIBCPP_ASSERT(!__other.__hold_.valueless_by_exception(), "Attempted to construct from a valueless common_iterator");
-      if (__other.__hold_.index() == 0)
-        return variant<_Iter, _Sent>{in_place_index<0>, _VSTD::__unchecked_get<0>(__other.__hold_)};
-      return variant<_Iter, _Sent>{in_place_index<1>, _VSTD::__unchecked_get<1>(__other.__hold_)};
-    }()) {}
+      : __hold_([&]() -> variant<_Iter, _Sent> {
+          _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+              !__other.__hold_.valueless_by_exception(), "Attempted to construct from a valueless common_iterator");
+          if (__other.__hold_.index() == 0)
+            return variant<_Iter, _Sent>{in_place_index<0>, std::__unchecked_get<0>(__other.__hold_)};
+          return variant<_Iter, _Sent>{in_place_index<1>, std::__unchecked_get<1>(__other.__hold_)};
+        }()) {}
 
-  template<class _I2, class _S2>
+  template <class _I2, class _S2>
     requires convertible_to<const _I2&, _Iter> && convertible_to<const _S2&, _Sent> &&
              assignable_from<_Iter&, const _I2&> && assignable_from<_Sent&, const _S2&>
   _LIBCPP_HIDE_FROM_ABI common_iterator& operator=(const common_iterator<_I2, _S2>& __other) {
-    _LIBCPP_ASSERT(!__other.__hold_.valueless_by_exception(), "Attempted to assign from a valueless common_iterator");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !__other.__hold_.valueless_by_exception(), "Attempted to assign from a valueless common_iterator");
 
-    auto __idx = __hold_.index();
+    auto __idx       = __hold_.index();
     auto __other_idx = __other.__hold_.index();
 
     // If they're the same index, just assign.
     if (__idx == 0 && __other_idx == 0)
-      _VSTD::__unchecked_get<0>(__hold_) = _VSTD::__unchecked_get<0>(__other.__hold_);
+      std::__unchecked_get<0>(__hold_) = std::__unchecked_get<0>(__other.__hold_);
     else if (__idx == 1 && __other_idx == 1)
-      _VSTD::__unchecked_get<1>(__hold_) = _VSTD::__unchecked_get<1>(__other.__hold_);
+      std::__unchecked_get<1>(__hold_) = std::__unchecked_get<1>(__other.__hold_);
 
     // Otherwise replace with the oposite element.
     else if (__other_idx == 1)
-      __hold_.template emplace<1>(_VSTD::__unchecked_get<1>(__other.__hold_));
+      __hold_.template emplace<1>(std::__unchecked_get<1>(__other.__hold_));
     else if (__other_idx == 0)
-      __hold_.template emplace<0>(_VSTD::__unchecked_get<0>(__other.__hold_));
+      __hold_.template emplace<0>(std::__unchecked_get<0>(__other.__hold_));
 
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*()
-  {
-    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
-    return *_VSTD::__unchecked_get<_Iter>(__hold_);
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        std::holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
+    return *std::__unchecked_get<_Iter>(__hold_);
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const
     requires __dereferenceable<const _Iter>
   {
-    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
-    return *_VSTD::__unchecked_get<_Iter>(__hold_);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        std::holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
+    return *std::__unchecked_get<_Iter>(__hold_);
   }
 
-  template<class _I2 = _Iter>
-  _LIBCPP_HIDE_FROM_ABI decltype(auto) operator->() const
-    requires indirectly_readable<const _I2> &&
-    (requires(const _I2& __i) { __i.operator->(); } ||
-     is_reference_v<iter_reference_t<_I2>> ||
-     constructible_from<iter_value_t<_I2>, iter_reference_t<_I2>>)
+  template <class _I2 = _Iter>
+  _LIBCPP_HIDE_FROM_ABI auto operator->() const
+    requires indirectly_readable<const _I2> && (requires(const _I2& __i) {
+               __i.operator->();
+             } || is_reference_v<iter_reference_t<_I2>> || constructible_from<iter_value_t<_I2>, iter_reference_t<_I2>>)
   {
-    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
-    if constexpr (is_pointer_v<_Iter> || requires(const _Iter& __i) { __i.operator->(); })    {
-      return _VSTD::__unchecked_get<_Iter>(__hold_);
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        std::holds_alternative<_Iter>(__hold_), "Attempted to dereference a non-dereferenceable common_iterator");
+    if constexpr (is_pointer_v<_Iter> || requires(const _Iter& __i) { __i.operator->(); }) {
+      return std::__unchecked_get<_Iter>(__hold_);
     } else if constexpr (is_reference_v<iter_reference_t<_Iter>>) {
-      auto&& __tmp = *_VSTD::__unchecked_get<_Iter>(__hold_);
-      return _VSTD::addressof(__tmp);
+      auto&& __tmp = *std::__unchecked_get<_Iter>(__hold_);
+      return std::addressof(__tmp);
     } else {
-      return __proxy{*_VSTD::__unchecked_get<_Iter>(__hold_)};
+      return __proxy{*std::__unchecked_get<_Iter>(__hold_)};
     }
   }
 
   _LIBCPP_HIDE_FROM_ABI common_iterator& operator++() {
-    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__hold_), "Attempted to increment a non-dereferenceable common_iterator");
-    ++_VSTD::__unchecked_get<_Iter>(__hold_); return *this;
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        std::holds_alternative<_Iter>(__hold_), "Attempted to increment a non-dereferenceable common_iterator");
+    ++std::__unchecked_get<_Iter>(__hold_);
+    return *this;
   }
 
   _LIBCPP_HIDE_FROM_ABI decltype(auto) operator++(int) {
-    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__hold_), "Attempted to increment a non-dereferenceable common_iterator");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        std::holds_alternative<_Iter>(__hold_), "Attempted to increment a non-dereferenceable common_iterator");
     if constexpr (forward_iterator<_Iter>) {
       auto __tmp = *this;
       ++*this;
       return __tmp;
-    } else if constexpr (requires (_Iter& __i) { { *__i++ } -> __can_reference; } ||
-                         !__can_use_postfix_proxy<_Iter>) {
-      return _VSTD::__unchecked_get<_Iter>(__hold_)++;
+    } else if constexpr (requires(_Iter& __i) {
+                           { *__i++ } -> __can_reference;
+                         } || !__can_use_postfix_proxy<_Iter>) {
+      return std::__unchecked_get<_Iter>(__hold_)++;
     } else {
       auto __p = __postfix_proxy{**this};
       ++*this;
@@ -154,12 +166,14 @@ public:
     }
   }
 
-  template<class _I2, sentinel_for<_Iter> _S2>
+  template <class _I2, sentinel_for<_Iter> _S2>
     requires sentinel_for<_Sent, _I2>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
-    _LIBCPP_ASSERT(!__x.__hold_.valueless_by_exception(), "Attempted to compare a valueless common_iterator");
-    _LIBCPP_ASSERT(!__y.__hold_.valueless_by_exception(), "Attempted to compare a valueless common_iterator");
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !__x.__hold_.valueless_by_exception(), "Attempted to compare a valueless common_iterator");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !__y.__hold_.valueless_by_exception(), "Attempted to compare a valueless common_iterator");
 
     auto __x_index = __x.__hold_.index();
     auto __y_index = __y.__hold_.index();
@@ -168,17 +182,19 @@ public:
       return true;
 
     if (__x_index == 0)
-      return _VSTD::__unchecked_get<_Iter>(__x.__hold_) == _VSTD::__unchecked_get<_S2>(__y.__hold_);
+      return std::__unchecked_get<_Iter>(__x.__hold_) == std::__unchecked_get<_S2>(__y.__hold_);
 
-    return _VSTD::__unchecked_get<_Sent>(__x.__hold_) == _VSTD::__unchecked_get<_I2>(__y.__hold_);
+    return std::__unchecked_get<_Sent>(__x.__hold_) == std::__unchecked_get<_I2>(__y.__hold_);
   }
 
-  template<class _I2, sentinel_for<_Iter> _S2>
+  template <class _I2, sentinel_for<_Iter> _S2>
     requires sentinel_for<_Sent, _I2> && equality_comparable_with<_Iter, _I2>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
-    _LIBCPP_ASSERT(!__x.__hold_.valueless_by_exception(), "Attempted to compare a valueless common_iterator");
-    _LIBCPP_ASSERT(!__y.__hold_.valueless_by_exception(), "Attempted to compare a valueless common_iterator");
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator==(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !__x.__hold_.valueless_by_exception(), "Attempted to compare a valueless common_iterator");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !__y.__hold_.valueless_by_exception(), "Attempted to compare a valueless common_iterator");
 
     auto __x_index = __x.__hold_.index();
     auto __y_index = __y.__hold_.index();
@@ -187,20 +203,22 @@ public:
       return true;
 
     if (__x_index == 0 && __y_index == 0)
-      return  _VSTD::__unchecked_get<_Iter>(__x.__hold_) ==  _VSTD::__unchecked_get<_I2>(__y.__hold_);
+      return std::__unchecked_get<_Iter>(__x.__hold_) == std::__unchecked_get<_I2>(__y.__hold_);
 
     if (__x_index == 0)
-      return  _VSTD::__unchecked_get<_Iter>(__x.__hold_) == _VSTD::__unchecked_get<_S2>(__y.__hold_);
+      return std::__unchecked_get<_Iter>(__x.__hold_) == std::__unchecked_get<_S2>(__y.__hold_);
 
-    return _VSTD::__unchecked_get<_Sent>(__x.__hold_) ==  _VSTD::__unchecked_get<_I2>(__y.__hold_);
+    return std::__unchecked_get<_Sent>(__x.__hold_) == std::__unchecked_get<_I2>(__y.__hold_);
   }
 
-  template<sized_sentinel_for<_Iter> _I2, sized_sentinel_for<_Iter> _S2>
+  template <sized_sentinel_for<_Iter> _I2, sized_sentinel_for<_Iter> _S2>
     requires sized_sentinel_for<_Sent, _I2>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr iter_difference_t<_I2> operator-(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
-    _LIBCPP_ASSERT(!__x.__hold_.valueless_by_exception(), "Attempted to subtract from a valueless common_iterator");
-    _LIBCPP_ASSERT(!__y.__hold_.valueless_by_exception(), "Attempted to subtract a valueless common_iterator");
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_I2>
+  operator-(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !__x.__hold_.valueless_by_exception(), "Attempted to subtract from a valueless common_iterator");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !__y.__hold_.valueless_by_exception(), "Attempted to subtract a valueless common_iterator");
 
     auto __x_index = __x.__hold_.index();
     auto __y_index = __y.__hold_.index();
@@ -209,74 +227,73 @@ public:
       return 0;
 
     if (__x_index == 0 && __y_index == 0)
-      return  _VSTD::__unchecked_get<_Iter>(__x.__hold_) - _VSTD::__unchecked_get<_I2>(__y.__hold_);
+      return std::__unchecked_get<_Iter>(__x.__hold_) - std::__unchecked_get<_I2>(__y.__hold_);
 
     if (__x_index == 0)
-      return  _VSTD::__unchecked_get<_Iter>(__x.__hold_) - _VSTD::__unchecked_get<_S2>(__y.__hold_);
+      return std::__unchecked_get<_Iter>(__x.__hold_) - std::__unchecked_get<_S2>(__y.__hold_);
 
-    return _VSTD::__unchecked_get<_Sent>(__x.__hold_) - _VSTD::__unchecked_get<_I2>(__y.__hold_);
+    return std::__unchecked_get<_Sent>(__x.__hold_) - std::__unchecked_get<_I2>(__y.__hold_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const common_iterator& __i)
-    noexcept(noexcept(ranges::iter_move(std::declval<const _Iter&>())))
-      requires input_iterator<_Iter>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iter_rvalue_reference_t<_Iter>
+  iter_move(const common_iterator& __i) noexcept(noexcept(ranges::iter_move(std::declval<const _Iter&>())))
+    requires input_iterator<_Iter>
   {
-    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__i.__hold_), "Attempted to iter_move a non-dereferenceable common_iterator");
-    return ranges::iter_move( _VSTD::__unchecked_get<_Iter>(__i.__hold_));
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        std::holds_alternative<_Iter>(__i.__hold_), "Attempted to iter_move a non-dereferenceable common_iterator");
+    return ranges::iter_move(std::__unchecked_get<_Iter>(__i.__hold_));
   }
 
-  template<indirectly_swappable<_Iter> _I2, class _S2>
-  _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(const common_iterator& __x, const common_iterator<_I2, _S2>& __y)
-      noexcept(noexcept(ranges::iter_swap(std::declval<const _Iter&>(), std::declval<const _I2&>())))
-  {
-    _LIBCPP_ASSERT(std::holds_alternative<_Iter>(__x.__hold_), "Attempted to iter_swap a non-dereferenceable common_iterator");
-    _LIBCPP_ASSERT(std::holds_alternative<_I2>(__y.__hold_), "Attempted to iter_swap a non-dereferenceable common_iterator");
-    return ranges::iter_swap(_VSTD::__unchecked_get<_Iter>(__x.__hold_), _VSTD::__unchecked_get<_I2>(__y.__hold_));
+  template <indirectly_swappable<_Iter> _I2, class _S2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void
+  iter_swap(const common_iterator& __x, const common_iterator<_I2, _S2>& __y) noexcept(
+      noexcept(ranges::iter_swap(std::declval<const _Iter&>(), std::declval<const _I2&>()))) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        std::holds_alternative<_Iter>(__x.__hold_), "Attempted to iter_swap a non-dereferenceable common_iterator");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        std::holds_alternative<_I2>(__y.__hold_), "Attempted to iter_swap a non-dereferenceable common_iterator");
+    return ranges::iter_swap(std::__unchecked_get<_Iter>(__x.__hold_), std::__unchecked_get<_I2>(__y.__hold_));
   }
 };
 
-template<class _Iter, class _Sent>
+template <class _Iter, class _Sent>
 struct incrementable_traits<common_iterator<_Iter, _Sent>> {
   using difference_type = iter_difference_t<_Iter>;
 };
 
-template<class _Iter>
-concept __denotes_forward_iter =
-  requires { typename iterator_traits<_Iter>::iterator_category; } &&
-  derived_from<typename iterator_traits<_Iter>::iterator_category, forward_iterator_tag>;
+template <class _Iter>
+concept __denotes_forward_iter = requires {
+  typename iterator_traits<_Iter>::iterator_category;
+} && derived_from<typename iterator_traits<_Iter>::iterator_category, forward_iterator_tag>;
 
-template<class _Iter, class _Sent>
-concept __common_iter_has_ptr_op = requires(const common_iterator<_Iter, _Sent>& __a) {
-  __a.operator->();
-};
+template <class _Iter, class _Sent>
+concept __common_iter_has_ptr_op = requires(const common_iterator<_Iter, _Sent>& __a) { __a.operator->(); };
 
-template<class, class>
+template <class, class>
 struct __arrow_type_or_void {
-    using type = void;
+  using type = void;
 };
 
-template<class _Iter, class _Sent>
+template <class _Iter, class _Sent>
   requires __common_iter_has_ptr_op<_Iter, _Sent>
 struct __arrow_type_or_void<_Iter, _Sent> {
-    using type = decltype(std::declval<const common_iterator<_Iter, _Sent>&>().operator->());
+  using type = decltype(std::declval<const common_iterator<_Iter, _Sent>&>().operator->());
 };
 
-template<input_iterator _Iter, class _Sent>
+template <input_iterator _Iter, class _Sent>
 struct iterator_traits<common_iterator<_Iter, _Sent>> {
-  using iterator_concept = _If<forward_iterator<_Iter>,
-                               forward_iterator_tag,
-                               input_iterator_tag>;
-  using iterator_category = _If<__denotes_forward_iter<_Iter>,
-                                forward_iterator_tag,
-                                input_iterator_tag>;
-  using pointer = typename __arrow_type_or_void<_Iter, _Sent>::type;
-  using value_type = iter_value_t<_Iter>;
-  using difference_type = iter_difference_t<_Iter>;
-  using reference = iter_reference_t<_Iter>;
+  using iterator_concept  = _If<forward_iterator<_Iter>, forward_iterator_tag, input_iterator_tag>;
+  using iterator_category = _If<__denotes_forward_iter<_Iter>, forward_iterator_tag, input_iterator_tag>;
+  using pointer           = typename __arrow_type_or_void<_Iter, _Sent>::type;
+  using value_type        = iter_value_t<_Iter>;
+  using difference_type   = iter_difference_t<_Iter>;
+  using reference         = iter_reference_t<_Iter>;
 };
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_COMMON_ITERATOR_H
diff --git a/third_party/libcxx/__iterator/concepts.h b/third_party/libcxx/__iterator/concepts.h
index dd9e8d6ac..0a4878308 100644
--- a/third_party/libcxx/__iterator/concepts.h
+++ b/third_party/libcxx/__iterator/concepts.h
@@ -49,252 +49,209 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 // [iterator.concept.readable]
-template<class _In>
+template <class _In>
 concept __indirectly_readable_impl =
-  requires(const _In __i) {
-    typename iter_value_t<_In>;
-    typename iter_reference_t<_In>;
-    typename iter_rvalue_reference_t<_In>;
-    { *__i } -> same_as<iter_reference_t<_In>>;
-    { ranges::iter_move(__i) } -> same_as<iter_rvalue_reference_t<_In>>;
-  } &&
-  common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&> &&
-  common_reference_with<iter_reference_t<_In>&&, iter_rvalue_reference_t<_In>&&> &&
-  common_reference_with<iter_rvalue_reference_t<_In>&&, const iter_value_t<_In>&>;
+    requires(const _In __i) {
+      typename iter_value_t<_In>;
+      typename iter_reference_t<_In>;
+      typename iter_rvalue_reference_t<_In>;
+      { *__i } -> same_as<iter_reference_t<_In>>;
+      { ranges::iter_move(__i) } -> same_as<iter_rvalue_reference_t<_In>>;
+    } && common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&> &&
+    common_reference_with<iter_reference_t<_In>&&, iter_rvalue_reference_t<_In>&&> &&
+    common_reference_with<iter_rvalue_reference_t<_In>&&, const iter_value_t<_In>&>;
 
-template<class _In>
+template <class _In>
 concept indirectly_readable = __indirectly_readable_impl<remove_cvref_t<_In>>;
 
-template<indirectly_readable _Tp>
+template <indirectly_readable _Tp>
 using iter_common_reference_t = common_reference_t<iter_reference_t<_Tp>, iter_value_t<_Tp>&>;
 
 // [iterator.concept.writable]
-template<class _Out, class _Tp>
-concept indirectly_writable =
-  requires(_Out&& __o, _Tp&& __t) {
-    *__o = _VSTD::forward<_Tp>(__t);                        // not required to be equality-preserving
-    *_VSTD::forward<_Out>(__o) = _VSTD::forward<_Tp>(__t);  // not required to be equality-preserving
-    const_cast<const iter_reference_t<_Out>&&>(*__o) = _VSTD::forward<_Tp>(__t);                       // not required to be equality-preserving
-    const_cast<const iter_reference_t<_Out>&&>(*_VSTD::forward<_Out>(__o)) = _VSTD::forward<_Tp>(__t); // not required to be equality-preserving
-  };
+template <class _Out, class _Tp>
+concept indirectly_writable = requires(_Out&& __o, _Tp&& __t) {
+  *__o                                             = std::forward<_Tp>(__t); // not required to be equality-preserving
+  *std::forward<_Out>(__o)                         = std::forward<_Tp>(__t); // not required to be equality-preserving
+  const_cast<const iter_reference_t<_Out>&&>(*__o) = std::forward<_Tp>(__t); // not required to be equality-preserving
+  const_cast<const iter_reference_t<_Out>&&>(*std::forward<_Out>(__o)) =
+      std::forward<_Tp>(__t); // not required to be equality-preserving
+};
 
 // [iterator.concept.winc]
-template<class _Tp>
+template <class _Tp>
 concept __integer_like = integral<_Tp> && !same_as<_Tp, bool>;
 
-template<class _Tp>
+template <class _Tp>
 concept __signed_integer_like = signed_integral<_Tp>;
 
-template<class _Ip>
+template <class _Ip>
 concept weakly_incrementable =
-  // TODO: remove this once the clang bug is fixed (bugs.llvm.org/PR48173).
-  !same_as<_Ip, bool> && // Currently, clang does not handle bool correctly.
-  movable<_Ip> &&
-  requires(_Ip __i) {
-    typename iter_difference_t<_Ip>;
-    requires __signed_integer_like<iter_difference_t<_Ip>>;
-    { ++__i } -> same_as<_Ip&>;   // not required to be equality-preserving
-    __i++;                        // not required to be equality-preserving
-  };
+    // TODO: remove this once the clang bug is fixed (bugs.llvm.org/PR48173).
+    !same_as<_Ip, bool> && // Currently, clang does not handle bool correctly.
+    movable<_Ip> && requires(_Ip __i) {
+      typename iter_difference_t<_Ip>;
+      requires __signed_integer_like<iter_difference_t<_Ip>>;
+      { ++__i } -> same_as<_Ip&>; // not required to be equality-preserving
+      __i++;                      // not required to be equality-preserving
+    };
 
 // [iterator.concept.inc]
-template<class _Ip>
-concept incrementable =
-  regular<_Ip> &&
-  weakly_incrementable<_Ip> &&
-  requires(_Ip __i) {
-    { __i++ } -> same_as<_Ip>;
-  };
+template <class _Ip>
+concept incrementable = regular<_Ip> && weakly_incrementable<_Ip> && requires(_Ip __i) {
+  { __i++ } -> same_as<_Ip>;
+};
 
 // [iterator.concept.iterator]
-template<class _Ip>
-concept input_or_output_iterator =
-  requires(_Ip __i) {
-    { *__i } -> __can_reference;
-  } &&
-  weakly_incrementable<_Ip>;
+template <class _Ip>
+concept input_or_output_iterator = requires(_Ip __i) {
+  { *__i } -> __can_reference;
+} && weakly_incrementable<_Ip>;
 
 // [iterator.concept.sentinel]
-template<class _Sp, class _Ip>
-concept sentinel_for =
-  semiregular<_Sp> &&
-  input_or_output_iterator<_Ip> &&
-  __weakly_equality_comparable_with<_Sp, _Ip>;
+template <class _Sp, class _Ip>
+concept sentinel_for = semiregular<_Sp> && input_or_output_iterator<_Ip> && __weakly_equality_comparable_with<_Sp, _Ip>;
 
-template<class, class>
+template <class, class>
 inline constexpr bool disable_sized_sentinel_for = false;
 
-template<class _Sp, class _Ip>
+template <class _Sp, class _Ip>
 concept sized_sentinel_for =
-  sentinel_for<_Sp, _Ip> &&
-  !disable_sized_sentinel_for<remove_cv_t<_Sp>, remove_cv_t<_Ip>> &&
-  requires(const _Ip& __i, const _Sp& __s) {
-    { __s - __i } -> same_as<iter_difference_t<_Ip>>;
-    { __i - __s } -> same_as<iter_difference_t<_Ip>>;
-  };
+    sentinel_for<_Sp, _Ip> && !disable_sized_sentinel_for<remove_cv_t<_Sp>, remove_cv_t<_Ip>> &&
+    requires(const _Ip& __i, const _Sp& __s) {
+      { __s - __i } -> same_as<iter_difference_t<_Ip>>;
+      { __i - __s } -> same_as<iter_difference_t<_Ip>>;
+    };
 
 // [iterator.concept.input]
-template<class _Ip>
-concept input_iterator =
-  input_or_output_iterator<_Ip> &&
-  indirectly_readable<_Ip> &&
-  requires { typename _ITER_CONCEPT<_Ip>; } &&
-  derived_from<_ITER_CONCEPT<_Ip>, input_iterator_tag>;
+template <class _Ip>
+concept input_iterator = input_or_output_iterator<_Ip> && indirectly_readable<_Ip> && requires {
+  typename _ITER_CONCEPT<_Ip>;
+} && derived_from<_ITER_CONCEPT<_Ip>, input_iterator_tag>;
 
 // [iterator.concept.output]
-template<class _Ip, class _Tp>
+template <class _Ip, class _Tp>
 concept output_iterator =
-  input_or_output_iterator<_Ip> &&
-  indirectly_writable<_Ip, _Tp> &&
-  requires (_Ip __it, _Tp&& __t) {
-    *__it++ = _VSTD::forward<_Tp>(__t); // not required to be equality-preserving
-  };
+    input_or_output_iterator<_Ip> && indirectly_writable<_Ip, _Tp> && requires(_Ip __it, _Tp&& __t) {
+      *__it++ = std::forward<_Tp>(__t); // not required to be equality-preserving
+    };
 
 // [iterator.concept.forward]
-template<class _Ip>
+template <class _Ip>
 concept forward_iterator =
-  input_iterator<_Ip> &&
-  derived_from<_ITER_CONCEPT<_Ip>, forward_iterator_tag> &&
-  incrementable<_Ip> &&
-  sentinel_for<_Ip, _Ip>;
+    input_iterator<_Ip> && derived_from<_ITER_CONCEPT<_Ip>, forward_iterator_tag> && incrementable<_Ip> &&
+    sentinel_for<_Ip, _Ip>;
 
 // [iterator.concept.bidir]
-template<class _Ip>
+template <class _Ip>
 concept bidirectional_iterator =
-  forward_iterator<_Ip> &&
-  derived_from<_ITER_CONCEPT<_Ip>, bidirectional_iterator_tag> &&
-  requires(_Ip __i) {
-    { --__i } -> same_as<_Ip&>;
-    { __i-- } -> same_as<_Ip>;
-  };
+    forward_iterator<_Ip> && derived_from<_ITER_CONCEPT<_Ip>, bidirectional_iterator_tag> && requires(_Ip __i) {
+      { --__i } -> same_as<_Ip&>;
+      { __i-- } -> same_as<_Ip>;
+    };
 
-template<class _Ip>
+template <class _Ip>
 concept random_access_iterator =
-  bidirectional_iterator<_Ip> &&
-  derived_from<_ITER_CONCEPT<_Ip>, random_access_iterator_tag> &&
-  totally_ordered<_Ip> &&
-  sized_sentinel_for<_Ip, _Ip> &&
-  requires(_Ip __i, const _Ip __j, const iter_difference_t<_Ip> __n) {
-    { __i += __n } -> same_as<_Ip&>;
-    { __j +  __n } -> same_as<_Ip>;
-    { __n +  __j } -> same_as<_Ip>;
-    { __i -= __n } -> same_as<_Ip&>;
-    { __j -  __n } -> same_as<_Ip>;
-    {  __j[__n]  } -> same_as<iter_reference_t<_Ip>>;
-  };
+    bidirectional_iterator<_Ip> && derived_from<_ITER_CONCEPT<_Ip>, random_access_iterator_tag> &&
+    totally_ordered<_Ip> && sized_sentinel_for<_Ip, _Ip> &&
+    requires(_Ip __i, const _Ip __j, const iter_difference_t<_Ip> __n) {
+      { __i += __n } -> same_as<_Ip&>;
+      { __j + __n } -> same_as<_Ip>;
+      { __n + __j } -> same_as<_Ip>;
+      { __i -= __n } -> same_as<_Ip&>;
+      { __j - __n } -> same_as<_Ip>;
+      { __j[__n] } -> same_as<iter_reference_t<_Ip>>;
+    };
 
-template<class _Ip>
+template <class _Ip>
 concept contiguous_iterator =
-  random_access_iterator<_Ip> &&
-  derived_from<_ITER_CONCEPT<_Ip>, contiguous_iterator_tag> &&
-  is_lvalue_reference_v<iter_reference_t<_Ip>> &&
-  same_as<iter_value_t<_Ip>, remove_cvref_t<iter_reference_t<_Ip>>> &&
-  requires(const _Ip& __i) {
-    { _VSTD::to_address(__i) } -> same_as<add_pointer_t<iter_reference_t<_Ip>>>;
-  };
+    random_access_iterator<_Ip> && derived_from<_ITER_CONCEPT<_Ip>, contiguous_iterator_tag> &&
+    is_lvalue_reference_v<iter_reference_t<_Ip>> && same_as<iter_value_t<_Ip>, remove_cvref_t<iter_reference_t<_Ip>>> &&
+    requires(const _Ip& __i) {
+      { std::to_address(__i) } -> same_as<add_pointer_t<iter_reference_t<_Ip>>>;
+    };
 
-template<class _Ip>
+template <class _Ip>
 concept __has_arrow = input_iterator<_Ip> && (is_pointer_v<_Ip> || requires(_Ip __i) { __i.operator->(); });
 
 // [indirectcallable.indirectinvocable]
-template<class _Fp, class _It>
+template <class _Fp, class _It>
 concept indirectly_unary_invocable =
-  indirectly_readable<_It> &&
-  copy_constructible<_Fp> &&
-  invocable<_Fp&, iter_value_t<_It>&> &&
-  invocable<_Fp&, iter_reference_t<_It>> &&
-  invocable<_Fp&, iter_common_reference_t<_It>> &&
-  common_reference_with<
-    invoke_result_t<_Fp&, iter_value_t<_It>&>,
-    invoke_result_t<_Fp&, iter_reference_t<_It>>>;
+    indirectly_readable<_It> && copy_constructible<_Fp> && invocable<_Fp&, iter_value_t<_It>&> &&
+    invocable<_Fp&, iter_reference_t<_It>> &&
+    common_reference_with< invoke_result_t<_Fp&, iter_value_t<_It>&>, invoke_result_t<_Fp&, iter_reference_t<_It>>>;
 
-template<class _Fp, class _It>
+template <class _Fp, class _It>
 concept indirectly_regular_unary_invocable =
-  indirectly_readable<_It> &&
-  copy_constructible<_Fp> &&
-  regular_invocable<_Fp&, iter_value_t<_It>&> &&
-  regular_invocable<_Fp&, iter_reference_t<_It>> &&
-  regular_invocable<_Fp&, iter_common_reference_t<_It>> &&
-  common_reference_with<
-    invoke_result_t<_Fp&, iter_value_t<_It>&>,
-    invoke_result_t<_Fp&, iter_reference_t<_It>>>;
+    indirectly_readable<_It> && copy_constructible<_Fp> && regular_invocable<_Fp&, iter_value_t<_It>&> &&
+    regular_invocable<_Fp&, iter_reference_t<_It>> &&
+    common_reference_with< invoke_result_t<_Fp&, iter_value_t<_It>&>, invoke_result_t<_Fp&, iter_reference_t<_It>>>;
 
-template<class _Fp, class _It>
+template <class _Fp, class _It>
 concept indirect_unary_predicate =
-  indirectly_readable<_It> &&
-  copy_constructible<_Fp> &&
-  predicate<_Fp&, iter_value_t<_It>&> &&
-  predicate<_Fp&, iter_reference_t<_It>> &&
-  predicate<_Fp&, iter_common_reference_t<_It>>;
+    indirectly_readable<_It> && copy_constructible<_Fp> && predicate<_Fp&, iter_value_t<_It>&> &&
+    predicate<_Fp&, iter_reference_t<_It>>;
 
-template<class _Fp, class _It1, class _It2>
+template <class _Fp, class _It1, class _It2>
 concept indirect_binary_predicate =
-  indirectly_readable<_It1> && indirectly_readable<_It2> &&
-  copy_constructible<_Fp> &&
-  predicate<_Fp&, iter_value_t<_It1>&, iter_value_t<_It2>&> &&
-  predicate<_Fp&, iter_value_t<_It1>&, iter_reference_t<_It2>> &&
-  predicate<_Fp&, iter_reference_t<_It1>, iter_value_t<_It2>&> &&
-  predicate<_Fp&, iter_reference_t<_It1>, iter_reference_t<_It2>> &&
-  predicate<_Fp&, iter_common_reference_t<_It1>, iter_common_reference_t<_It2>>;
+    indirectly_readable<_It1> && indirectly_readable<_It2> && copy_constructible<_Fp> &&
+    predicate<_Fp&, iter_value_t<_It1>&, iter_value_t<_It2>&> &&
+    predicate<_Fp&, iter_value_t<_It1>&, iter_reference_t<_It2>> &&
+    predicate<_Fp&, iter_reference_t<_It1>, iter_value_t<_It2>&> &&
+    predicate<_Fp&, iter_reference_t<_It1>, iter_reference_t<_It2>>;
 
-template<class _Fp, class _It1, class _It2 = _It1>
+template <class _Fp, class _It1, class _It2 = _It1>
 concept indirect_equivalence_relation =
-  indirectly_readable<_It1> && indirectly_readable<_It2> &&
-  copy_constructible<_Fp> &&
-  equivalence_relation<_Fp&, iter_value_t<_It1>&, iter_value_t<_It2>&> &&
-  equivalence_relation<_Fp&, iter_value_t<_It1>&, iter_reference_t<_It2>> &&
-  equivalence_relation<_Fp&, iter_reference_t<_It1>, iter_value_t<_It2>&> &&
-  equivalence_relation<_Fp&, iter_reference_t<_It1>, iter_reference_t<_It2>> &&
-  equivalence_relation<_Fp&, iter_common_reference_t<_It1>, iter_common_reference_t<_It2>>;
+    indirectly_readable<_It1> && indirectly_readable<_It2> && copy_constructible<_Fp> &&
+    equivalence_relation<_Fp&, iter_value_t<_It1>&, iter_value_t<_It2>&> &&
+    equivalence_relation<_Fp&, iter_value_t<_It1>&, iter_reference_t<_It2>> &&
+    equivalence_relation<_Fp&, iter_reference_t<_It1>, iter_value_t<_It2>&> &&
+    equivalence_relation<_Fp&, iter_reference_t<_It1>, iter_reference_t<_It2>>;
 
-template<class _Fp, class _It1, class _It2 = _It1>
+template <class _Fp, class _It1, class _It2 = _It1>
 concept indirect_strict_weak_order =
-  indirectly_readable<_It1> && indirectly_readable<_It2> &&
-  copy_constructible<_Fp> &&
-  strict_weak_order<_Fp&, iter_value_t<_It1>&, iter_value_t<_It2>&> &&
-  strict_weak_order<_Fp&, iter_value_t<_It1>&, iter_reference_t<_It2>> &&
-  strict_weak_order<_Fp&, iter_reference_t<_It1>, iter_value_t<_It2>&> &&
-  strict_weak_order<_Fp&, iter_reference_t<_It1>, iter_reference_t<_It2>> &&
-  strict_weak_order<_Fp&, iter_common_reference_t<_It1>, iter_common_reference_t<_It2>>;
+    indirectly_readable<_It1> && indirectly_readable<_It2> && copy_constructible<_Fp> &&
+    strict_weak_order<_Fp&, iter_value_t<_It1>&, iter_value_t<_It2>&> &&
+    strict_weak_order<_Fp&, iter_value_t<_It1>&, iter_reference_t<_It2>> &&
+    strict_weak_order<_Fp&, iter_reference_t<_It1>, iter_value_t<_It2>&> &&
+    strict_weak_order<_Fp&, iter_reference_t<_It1>, iter_reference_t<_It2>>;
 
-template<class _Fp, class... _Its>
-  requires (indirectly_readable<_Its> && ...) && invocable<_Fp, iter_reference_t<_Its>...>
+template <class _Fp, class... _Its>
+  requires(indirectly_readable<_Its> && ...) && invocable<_Fp, iter_reference_t<_Its>...>
 using indirect_result_t = invoke_result_t<_Fp, iter_reference_t<_Its>...>;
 
-template<class _In, class _Out>
-concept indirectly_movable =
-  indirectly_readable<_In> &&
-  indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;
+template <class _In, class _Out>
+concept indirectly_movable = indirectly_readable<_In> && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;
 
-template<class _In, class _Out>
+template <class _In, class _Out>
 concept indirectly_movable_storable =
-  indirectly_movable<_In, _Out> &&
-  indirectly_writable<_Out, iter_value_t<_In>> &&
-  movable<iter_value_t<_In>> &&
-  constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>> &&
-  assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;
+    indirectly_movable<_In, _Out> && indirectly_writable<_Out, iter_value_t<_In>> && movable<iter_value_t<_In>> &&
+    constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>> &&
+    assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;
 
-template<class _In, class _Out>
-concept indirectly_copyable =
-  indirectly_readable<_In> &&
-  indirectly_writable<_Out, iter_reference_t<_In>>;
+template <class _In, class _Out>
+concept indirectly_copyable = indirectly_readable<_In> && indirectly_writable<_Out, iter_reference_t<_In>>;
 
-template<class _In, class _Out>
+template <class _In, class _Out>
 concept indirectly_copyable_storable =
-  indirectly_copyable<_In, _Out> &&
-  indirectly_writable<_Out, iter_value_t<_In>&> &&
-  indirectly_writable<_Out, const iter_value_t<_In>&> &&
-  indirectly_writable<_Out, iter_value_t<_In>&&> &&
-  indirectly_writable<_Out, const iter_value_t<_In>&&> &&
-  copyable<iter_value_t<_In>> &&
-  constructible_from<iter_value_t<_In>, iter_reference_t<_In>> &&
-  assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;
+    indirectly_copyable<_In, _Out> && indirectly_writable<_Out, iter_value_t<_In>&> &&
+    indirectly_writable<_Out, const iter_value_t<_In>&> && indirectly_writable<_Out, iter_value_t<_In>&&> &&
+    indirectly_writable<_Out, const iter_value_t<_In>&&> && copyable<iter_value_t<_In>> &&
+    constructible_from<iter_value_t<_In>, iter_reference_t<_In>> &&
+    assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;
 
 // Note: indirectly_swappable is located in iter_swap.h to prevent a dependency cycle
 // (both iter_swap and indirectly_swappable require indirectly_readable).
 
 #endif // _LIBCPP_STD_VER >= 20
 
+template <class _Tp>
+using __has_random_access_iterator_category_or_concept
+#if _LIBCPP_STD_VER >= 20
+    = integral_constant<bool, random_access_iterator<_Tp>>;
+#else  // _LIBCPP_STD_VER < 20
+    = __has_random_access_iterator_category<_Tp>;
+#endif // _LIBCPP_STD_VER
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_CONCEPTS_H
diff --git a/third_party/libcxx/__iterator/counted_iterator.h b/third_party/libcxx/__iterator/counted_iterator.h
index ad69a5c90..ea2832e3b 100644
--- a/third_party/libcxx/__iterator/counted_iterator.h
+++ b/third_party/libcxx/__iterator/counted_iterator.h
@@ -34,135 +34,126 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-template<class>
+template <class>
 struct __counted_iterator_concept {};
 
-template<class _Iter>
+template <class _Iter>
   requires requires { typename _Iter::iterator_concept; }
 struct __counted_iterator_concept<_Iter> {
   using iterator_concept = typename _Iter::iterator_concept;
 };
 
-template<class>
+template <class>
 struct __counted_iterator_category {};
 
-template<class _Iter>
+template <class _Iter>
   requires requires { typename _Iter::iterator_category; }
 struct __counted_iterator_category<_Iter> {
   using iterator_category = typename _Iter::iterator_category;
 };
 
-template<class>
+template <class>
 struct __counted_iterator_value_type {};
 
-template<indirectly_readable _Iter>
+template <indirectly_readable _Iter>
 struct __counted_iterator_value_type<_Iter> {
   using value_type = iter_value_t<_Iter>;
 };
 
-template<input_or_output_iterator _Iter>
+template <input_or_output_iterator _Iter>
 class counted_iterator
-  : public __counted_iterator_concept<_Iter>
-  , public __counted_iterator_category<_Iter>
-  , public __counted_iterator_value_type<_Iter>
-{
+    : public __counted_iterator_concept<_Iter>,
+      public __counted_iterator_category<_Iter>,
+      public __counted_iterator_value_type<_Iter> {
 public:
-  _LIBCPP_NO_UNIQUE_ADDRESS _Iter __current_ = _Iter();
-  iter_difference_t<_Iter> __count_ = 0;
-
-  using iterator_type = _Iter;
+  using iterator_type   = _Iter;
   using difference_type = iter_difference_t<_Iter>;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator() requires default_initializable<_Iter> = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator()
+    requires default_initializable<_Iter>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator(_Iter __iter, iter_difference_t<_Iter> __n)
-   : __current_(_VSTD::move(__iter)), __count_(__n) {
-    _LIBCPP_ASSERT(__n >= 0, "__n must not be negative.");
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator(_Iter __iter, iter_difference_t<_Iter> __n)
+      : __current_(std::move(__iter)), __count_(__n) {
+    _LIBCPP_ASSERT_UNCATEGORIZED(__n >= 0, "__n must not be negative.");
   }
 
-  template<class _I2>
+  template <class _I2>
     requires convertible_to<const _I2&, _Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator(const counted_iterator<_I2>& __other)
-   : __current_(__other.__current_), __count_(__other.__count_) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator(const counted_iterator<_I2>& __other)
+      : __current_(__other.__current_), __count_(__other.__count_) {}
 
-  template<class _I2>
+  template <class _I2>
     requires assignable_from<_Iter&, const _I2&>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator& operator=(const counted_iterator<_I2>& __other) {
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator& operator=(const counted_iterator<_I2>& __other) {
     __current_ = __other.__current_;
-    __count_ = __other.__count_;
+    __count_   = __other.__count_;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr const _Iter& base() const& noexcept { return __current_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Iter& base() const& noexcept { return __current_; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Iter base() && { return _VSTD::move(__current_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() && { return std::move(__current_); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr iter_difference_t<_Iter> count() const noexcept { return __count_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Iter> count() const noexcept { return __count_; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator*() {
-    _LIBCPP_ASSERT(__count_ > 0, "Iterator is equal to or past end.");
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count_ > 0, "Iterator is equal to or past end.");
     return *__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator*() const
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const
     requires __dereferenceable<const _Iter>
   {
-    _LIBCPP_ASSERT(__count_ > 0, "Iterator is equal to or past end.");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count_ > 0, "Iterator is equal to or past end.");
     return *__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator->() const noexcept
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator->() const noexcept
     requires contiguous_iterator<_Iter>
   {
-    return _VSTD::to_address(__current_);
+    return std::to_address(__current_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator& operator++() {
-    _LIBCPP_ASSERT(__count_ > 0, "Iterator already at or past end.");
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator& operator++() {
+    _LIBCPP_ASSERT_UNCATEGORIZED(__count_ > 0, "Iterator already at or past end.");
     ++__current_;
     --__count_;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  decltype(auto) operator++(int) {
-    _LIBCPP_ASSERT(__count_ > 0, "Iterator already at or past end.");
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator++(int) {
+    _LIBCPP_ASSERT_UNCATEGORIZED(__count_ > 0, "Iterator already at or past end.");
     --__count_;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try { return __current_++; }
-    catch(...) { ++__count_; throw; }
-#else
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+      return __current_++;
+    } catch (...) {
+      ++__count_;
+      throw;
+    }
+#  else
     return __current_++;
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator operator++(int)
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator operator++(int)
     requires forward_iterator<_Iter>
   {
-    _LIBCPP_ASSERT(__count_ > 0, "Iterator already at or past end.");
+    _LIBCPP_ASSERT_UNCATEGORIZED(__count_ > 0, "Iterator already at or past end.");
     counted_iterator __tmp = *this;
     ++*this;
     return __tmp;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator& operator--()
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator& operator--()
     requires bidirectional_iterator<_Iter>
   {
     --__current_;
@@ -170,8 +161,7 @@ public:
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator operator--(int)
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator operator--(int)
     requires bidirectional_iterator<_Iter>
   {
     counted_iterator __tmp = *this;
@@ -179,132 +169,121 @@ public:
     return __tmp;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator operator+(iter_difference_t<_Iter> __n) const
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator operator+(iter_difference_t<_Iter> __n) const
     requires random_access_iterator<_Iter>
   {
     return counted_iterator(__current_ + __n, __count_ - __n);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr counted_iterator operator+(
-    iter_difference_t<_Iter> __n, const counted_iterator& __x)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr counted_iterator
+  operator+(iter_difference_t<_Iter> __n, const counted_iterator& __x)
     requires random_access_iterator<_Iter>
   {
     return __x + __n;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator& operator+=(iter_difference_t<_Iter> __n)
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator& operator+=(iter_difference_t<_Iter> __n)
     requires random_access_iterator<_Iter>
   {
-    _LIBCPP_ASSERT(__n <= __count_, "Cannot advance iterator past end.");
+    _LIBCPP_ASSERT_UNCATEGORIZED(__n <= __count_, "Cannot advance iterator past end.");
     __current_ += __n;
     __count_ -= __n;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator operator-(iter_difference_t<_Iter> __n) const
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator operator-(iter_difference_t<_Iter> __n) const
     requires random_access_iterator<_Iter>
   {
     return counted_iterator(__current_ - __n, __count_ + __n);
   }
 
-  template<common_with<_Iter> _I2>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr iter_difference_t<_I2> operator-(
-    const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs)
-  {
+  template <common_with<_Iter> _I2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_I2>
+  operator-(const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs) {
     return __rhs.__count_ - __lhs.__count_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr iter_difference_t<_Iter> operator-(
-    const counted_iterator& __lhs, default_sentinel_t)
-  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_Iter>
+  operator-(const counted_iterator& __lhs, default_sentinel_t) {
     return -__lhs.__count_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr iter_difference_t<_Iter> operator-(
-    default_sentinel_t, const counted_iterator& __rhs)
-  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_Iter>
+  operator-(default_sentinel_t, const counted_iterator& __rhs) {
     return __rhs.__count_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr counted_iterator& operator-=(iter_difference_t<_Iter> __n)
+  _LIBCPP_HIDE_FROM_ABI constexpr counted_iterator& operator-=(iter_difference_t<_Iter> __n)
     requires random_access_iterator<_Iter>
   {
-    _LIBCPP_ASSERT(-__n <= __count_, "Attempt to subtract too large of a size: "
-                                     "counted_iterator would be decremented before the "
-                                     "first element of its range.");
+    _LIBCPP_ASSERT_UNCATEGORIZED(
+        -__n <= __count_,
+        "Attempt to subtract too large of a size: "
+        "counted_iterator would be decremented before the "
+        "first element of its range.");
     __current_ -= __n;
     __count_ += __n;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator[](iter_difference_t<_Iter> __n) const
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](iter_difference_t<_Iter> __n) const
     requires random_access_iterator<_Iter>
   {
-    _LIBCPP_ASSERT(__n < __count_, "Subscript argument must be less than size.");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < __count_, "Subscript argument must be less than size.");
     return __current_[__n];
   }
 
-  template<common_with<_Iter> _I2>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(
-    const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs)
-  {
+  template <common_with<_Iter> _I2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator==(const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs) {
     return __lhs.__count_ == __rhs.__count_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(
-    const counted_iterator& __lhs, default_sentinel_t)
-  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const counted_iterator& __lhs, default_sentinel_t) {
     return __lhs.__count_ == 0;
   }
 
-  template<common_with<_Iter> _I2>
-  _LIBCPP_HIDE_FROM_ABI friend constexpr strong_ordering operator<=>(
-    const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs)
-  {
+  template <common_with<_Iter> _I2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr strong_ordering
+  operator<=>(const counted_iterator& __lhs, const counted_iterator<_I2>& __rhs) {
     return __rhs.__count_ <=> __lhs.__count_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const counted_iterator& __i)
-    noexcept(noexcept(ranges::iter_move(__i.__current_)))
-      requires input_iterator<_Iter>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iter_rvalue_reference_t<_Iter>
+  iter_move(const counted_iterator& __i) noexcept(noexcept(ranges::iter_move(__i.__current_)))
+    requires input_iterator<_Iter>
   {
-    _LIBCPP_ASSERT(__i.__count_ > 0, "Iterator must not be past end of range.");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i.__count_ > 0, "Iterator must not be past end of range.");
     return ranges::iter_move(__i.__current_);
   }
 
-  template<indirectly_swappable<_Iter> _I2>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr void iter_swap(const counted_iterator& __x, const counted_iterator<_I2>& __y)
-    noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
-  {
-    _LIBCPP_ASSERT(__x.__count_ > 0 && __y.__count_ > 0,
-                   "Iterators must not be past end of range.");
+  template <indirectly_swappable<_Iter> _I2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void
+  iter_swap(const counted_iterator& __x,
+            const counted_iterator<_I2>& __y) noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_))) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __x.__count_ > 0 && __y.__count_ > 0, "Iterators must not be past end of range.");
     return ranges::iter_swap(__x.__current_, __y.__current_);
   }
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS _Iter __current_ = _Iter();
+  iter_difference_t<_Iter> __count_          = 0;
+  template <input_or_output_iterator _OtherIter>
+  friend class counted_iterator;
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(counted_iterator);
 
-template<input_iterator _Iter>
+template <input_iterator _Iter>
   requires same_as<_ITER_TRAITS<_Iter>, iterator_traits<_Iter>>
 struct iterator_traits<counted_iterator<_Iter>> : iterator_traits<_Iter> {
-  using pointer = conditional_t<contiguous_iterator<_Iter>,
-                                add_pointer_t<iter_reference_t<_Iter>>, void>;
+  using pointer = conditional_t<contiguous_iterator<_Iter>, add_pointer_t<iter_reference_t<_Iter>>, void>;
 };
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_COUNTED_ITERATOR_H
diff --git a/third_party/libcxx/__iterator/cpp17_iterator_concepts.h b/third_party/libcxx/__iterator/cpp17_iterator_concepts.h
new file mode 100644
index 000000000..ba3536b68
--- /dev/null
+++ b/third_party/libcxx/__iterator/cpp17_iterator_concepts.h
@@ -0,0 +1,190 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ITERATOR_CPP17_ITERATOR_CONCEPTS_H
+#define _LIBCPP___ITERATOR_CPP17_ITERATOR_CONCEPTS_H
+
+#include <__concepts/boolean_testable.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__iterator/iterator_traits.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_signed.h>
+#include <__type_traits/is_void.h>
+#include <__utility/as_const.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/swap.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 20
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+concept __cpp17_move_constructible = is_move_constructible_v<_Tp>;
+
+template <class _Tp>
+concept __cpp17_copy_constructible = __cpp17_move_constructible<_Tp> && is_copy_constructible_v<_Tp>;
+
+template <class _Tp>
+concept __cpp17_move_assignable = requires(_Tp __lhs, _Tp __rhs) {
+  { __lhs = std::move(__rhs) } -> same_as<_Tp&>;
+};
+
+template <class _Tp>
+concept __cpp17_copy_assignable = __cpp17_move_assignable<_Tp> && requires(_Tp __lhs, _Tp __rhs) {
+  { __lhs = __rhs } -> same_as<_Tp&>;
+  { __lhs = std::as_const(__rhs) } -> same_as<_Tp&>;
+};
+
+template <class _Tp>
+concept __cpp17_destructible = requires(_Tp __v) { __v.~_Tp(); };
+
+template <class _Tp>
+concept __cpp17_equality_comparable = requires(_Tp __lhs, _Tp __rhs) {
+  { __lhs == __rhs } -> __boolean_testable;
+  { std::as_const(__lhs) == __rhs } -> __boolean_testable;
+  { __lhs == std::as_const(__rhs) } -> __boolean_testable;
+  { std::as_const(__lhs) == std::as_const(__rhs) } -> __boolean_testable;
+};
+
+template <class _Tp>
+concept __cpp17_default_constructible = is_default_constructible_v<_Tp>;
+
+template <class _Iter>
+concept __cpp17_iterator =
+    __cpp17_copy_constructible<_Iter> && __cpp17_copy_assignable<_Iter> && __cpp17_destructible<_Iter> &&
+    (is_signed_v<__iter_diff_t<_Iter>> || is_void_v<__iter_diff_t<_Iter>>) && requires(_Iter __iter) {
+      { *__iter };
+      { ++__iter } -> same_as<_Iter&>;
+    };
+
+template <class _Iter>
+concept __cpp17_input_iterator =
+    __cpp17_iterator<_Iter> && __cpp17_equality_comparable<_Iter> && requires(_Iter __lhs, _Iter __rhs) {
+      { __lhs != __rhs } -> __boolean_testable;
+      { std::as_const(__lhs) != __rhs } -> __boolean_testable;
+      { __lhs != std::as_const(__rhs) } -> __boolean_testable;
+      { std::as_const(__lhs) != std::as_const(__rhs) } -> __boolean_testable;
+
+      { *__lhs } -> same_as<__iter_reference<_Iter>>;
+      { *std::as_const(__lhs) } -> same_as<__iter_reference<_Iter>>;
+
+      { ++__lhs } -> same_as<_Iter&>;
+      { (void)__lhs++ };
+      { *__lhs++ };
+    };
+
+template <class _Iter, class _WriteTo>
+concept __cpp17_output_iterator = __cpp17_iterator<_Iter> && requires(_Iter __iter, _WriteTo __write) {
+  { *__iter = std::forward<_WriteTo>(__write) };
+  { ++__iter } -> same_as<_Iter&>;
+  { __iter++ } -> convertible_to<const _Iter&>;
+  { *__iter++ = std::forward<_WriteTo>(__write) };
+};
+
+template <class _Iter>
+concept __cpp17_forward_iterator =
+    __cpp17_input_iterator<_Iter> && __cpp17_default_constructible<_Iter> && requires(_Iter __iter) {
+      { __iter++ } -> convertible_to<const _Iter&>;
+      { *__iter++ } -> same_as<__iter_reference<_Iter>>;
+    };
+
+template <class _Iter>
+concept __cpp17_bidirectional_iterator = __cpp17_forward_iterator<_Iter> && requires(_Iter __iter) {
+  { --__iter } -> same_as<_Iter&>;
+  { __iter-- } -> convertible_to<const _Iter&>;
+  { *__iter-- } -> same_as<__iter_reference<_Iter>>;
+};
+
+template <class _Iter>
+concept __cpp17_random_access_iterator =
+    __cpp17_bidirectional_iterator<_Iter> && requires(_Iter __iter, __iter_diff_t<_Iter> __n) {
+      { __iter += __n } -> same_as<_Iter&>;
+
+      { __iter + __n } -> same_as<_Iter>;
+      { __n + __iter } -> same_as<_Iter>;
+      { std::as_const(__iter) + __n } -> same_as<_Iter>;
+      { __n + std::as_const(__iter) } -> same_as<_Iter>;
+
+      { __iter -= __n } -> same_as<_Iter&>;
+      { __iter - __n } -> same_as<_Iter>;
+      { std::as_const(__iter) - __n } -> same_as<_Iter>;
+
+      { __iter - __iter } -> same_as<__iter_diff_t<_Iter>>;
+      { std::as_const(__iter) - __iter } -> same_as<__iter_diff_t<_Iter>>;
+      { __iter - std::as_const(__iter) } -> same_as<__iter_diff_t<_Iter>>;
+      { std::as_const(__iter) - std::as_const(__iter) } -> same_as<__iter_diff_t<_Iter>>;
+
+      { __iter[__n] } -> convertible_to<__iter_reference<_Iter>>;
+      { std::as_const(__iter)[__n] } -> convertible_to<__iter_reference<_Iter>>;
+
+      { __iter < __iter } -> __boolean_testable;
+      { std::as_const(__iter) < __iter } -> __boolean_testable;
+      { __iter < std::as_const(__iter) } -> __boolean_testable;
+      { std::as_const(__iter) < std::as_const(__iter) } -> __boolean_testable;
+
+      { __iter > __iter } -> __boolean_testable;
+      { std::as_const(__iter) > __iter } -> __boolean_testable;
+      { __iter > std::as_const(__iter) } -> __boolean_testable;
+      { std::as_const(__iter) > std::as_const(__iter) } -> __boolean_testable;
+
+      { __iter >= __iter } -> __boolean_testable;
+      { std::as_const(__iter) >= __iter } -> __boolean_testable;
+      { __iter >= std::as_const(__iter) } -> __boolean_testable;
+      { std::as_const(__iter) >= std::as_const(__iter) } -> __boolean_testable;
+
+      { __iter <= __iter } -> __boolean_testable;
+      { std::as_const(__iter) <= __iter } -> __boolean_testable;
+      { __iter <= std::as_const(__iter) } -> __boolean_testable;
+      { std::as_const(__iter) <= std::as_const(__iter) } -> __boolean_testable;
+    };
+
+_LIBCPP_END_NAMESPACE_STD
+
+#  ifndef _LIBCPP_DISABLE_ITERATOR_CHECKS
+#    define _LIBCPP_REQUIRE_CPP17_INPUT_ITERATOR(iter_t, message)                                                      \
+      static_assert(::std::__cpp17_input_iterator<iter_t>, message)
+#    define _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(iter_t, write_t, message)                                            \
+      static_assert(::std::__cpp17_output_iterator<iter_t, write_t>, message)
+#    define _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(iter_t, message)                                                    \
+      static_assert(::std::__cpp17_forward_iterator<iter_t>, message)
+#    define _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(iter_t, message)                                              \
+      static_assert(::std::__cpp17_bidirectional_iterator<iter_t>, message)
+#    define _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(iter_t, message)                                              \
+      static_assert(::std::__cpp17_random_access_iterator<iter_t>, message)
+#  else
+#    define _LIBCPP_REQUIRE_CPP17_INPUT_ITERATOR(iter_t, message) static_assert(true)
+#    define _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(iter_t, write_t, message) static_assert(true)
+#    define _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(iter_t, message) static_assert(true)
+#    define _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(iter_t, message) static_assert(true)
+#    define _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(iter_t, message) static_assert(true)
+#  endif
+
+#else // _LIBCPP_STD_VER >= 20
+
+#  define _LIBCPP_REQUIRE_CPP17_INPUT_ITERATOR(iter_t, message) static_assert(true)
+#  define _LIBCPP_REQUIRE_CPP17_OUTPUT_ITERATOR(iter_t, write_t, message) static_assert(true)
+#  define _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(iter_t, message) static_assert(true)
+#  define _LIBCPP_REQUIRE_CPP17_BIDIRECTIONAL_ITERATOR(iter_t, message) static_assert(true)
+#  define _LIBCPP_REQUIRE_CPP17_RANDOM_ACCESS_ITERATOR(iter_t, message) static_assert(true)
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ITERATOR_CPP17_ITERATOR_CONCEPTS_H
diff --git a/third_party/libcxx/__iterator/data.h b/third_party/libcxx/__iterator/data.h
index f10680744..b7c160365 100644
--- a/third_party/libcxx/__iterator/data.h
+++ b/third_party/libcxx/__iterator/data.h
@@ -22,27 +22,25 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-template <class _Cont> constexpr
-_LIBCPP_INLINE_VISIBILITY
-auto data(_Cont& __c)
-_NOEXCEPT_(noexcept(__c.data()))
--> decltype        (__c.data())
-{ return            __c.data(); }
+template <class _Cont>
+constexpr _LIBCPP_HIDE_FROM_ABI auto data(_Cont& __c) noexcept(noexcept(__c.data())) -> decltype(__c.data()) {
+  return __c.data();
+}
 
-template <class _Cont> constexpr
-_LIBCPP_INLINE_VISIBILITY
-auto data(const _Cont& __c)
-_NOEXCEPT_(noexcept(__c.data()))
--> decltype        (__c.data())
-{ return            __c.data(); }
+template <class _Cont>
+constexpr _LIBCPP_HIDE_FROM_ABI auto data(const _Cont& __c) noexcept(noexcept(__c.data())) -> decltype(__c.data()) {
+  return __c.data();
+}
 
 template <class _Tp, size_t _Sz>
-_LIBCPP_INLINE_VISIBILITY
-constexpr _Tp* data(_Tp (&__array)[_Sz]) noexcept { return __array; }
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp* data(_Tp (&__array)[_Sz]) noexcept {
+  return __array;
+}
 
 template <class _Ep>
-_LIBCPP_INLINE_VISIBILITY
-constexpr const _Ep* data(initializer_list<_Ep> __il) noexcept { return __il.begin(); }
+_LIBCPP_HIDE_FROM_ABI constexpr const _Ep* data(initializer_list<_Ep> __il) noexcept {
+  return __il.begin();
+}
 
 #endif
 
diff --git a/third_party/libcxx/__iterator/default_sentinel.h b/third_party/libcxx/__iterator/default_sentinel.h
index d5fb2b699..3b65f442f 100644
--- a/third_party/libcxx/__iterator/default_sentinel.h
+++ b/third_party/libcxx/__iterator/default_sentinel.h
@@ -20,7 +20,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-struct default_sentinel_t { };
+struct default_sentinel_t {};
 inline constexpr default_sentinel_t default_sentinel{};
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__iterator/distance.h b/third_party/libcxx/__iterator/distance.h
index ebe547337..75bd49c9a 100644
--- a/third_party/libcxx/__iterator/distance.h
+++ b/third_party/libcxx/__iterator/distance.h
@@ -27,30 +27,24 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-typename iterator_traits<_InputIter>::difference_type
-__distance(_InputIter __first, _InputIter __last, input_iterator_tag)
-{
-    typename iterator_traits<_InputIter>::difference_type __r(0);
-    for (; __first != __last; ++__first)
-        ++__r;
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 typename iterator_traits<_InputIter>::difference_type
+__distance(_InputIter __first, _InputIter __last, input_iterator_tag) {
+  typename iterator_traits<_InputIter>::difference_type __r(0);
+  for (; __first != __last; ++__first)
+    ++__r;
+  return __r;
 }
 
 template <class _RandIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-typename iterator_traits<_RandIter>::difference_type
-__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag)
-{
-    return __last - __first;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 typename iterator_traits<_RandIter>::difference_type
+__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag) {
+  return __last - __first;
 }
 
 template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-typename iterator_traits<_InputIter>::difference_type
-distance(_InputIter __first, _InputIter __last)
-{
-    return _VSTD::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 typename iterator_traits<_InputIter>::difference_type
+distance(_InputIter __first, _InputIter __last) {
+  return std::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
 }
 
 #if _LIBCPP_STD_VER >= 20
@@ -61,10 +55,9 @@ namespace ranges {
 namespace __distance {
 
 struct __fn {
-  template<class _Ip, sentinel_for<_Ip> _Sp>
-    requires (!sized_sentinel_for<_Sp, _Ip>)
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr iter_difference_t<_Ip> operator()(_Ip __first, _Sp __last) const {
+  template <class _Ip, sentinel_for<_Ip> _Sp>
+    requires(!sized_sentinel_for<_Sp, _Ip>)
+  _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Ip> operator()(_Ip __first, _Sp __last) const {
     iter_difference_t<_Ip> __n = 0;
     while (__first != __last) {
       ++__first;
@@ -73,9 +66,8 @@ struct __fn {
     return __n;
   }
 
-  template<class _Ip, sized_sentinel_for<decay_t<_Ip>> _Sp>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr iter_difference_t<_Ip> operator()(_Ip&& __first, _Sp __last) const {
+  template <class _Ip, sized_sentinel_for<decay_t<_Ip>> _Sp>
+  _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Ip> operator()(_Ip&& __first, _Sp __last) const {
     if constexpr (sized_sentinel_for<_Sp, __remove_cvref_t<_Ip>>) {
       return __last - __first;
     } else {
@@ -83,9 +75,8 @@ struct __fn {
     }
   }
 
-  template<range _Rp>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr range_difference_t<_Rp> operator()(_Rp&& __r) const {
+  template <range _Rp>
+  _LIBCPP_HIDE_FROM_ABI constexpr range_difference_t<_Rp> operator()(_Rp&& __r) const {
     if constexpr (sized_range<_Rp>) {
       return static_cast<range_difference_t<_Rp>>(ranges::size(__r));
     } else {
@@ -97,7 +88,7 @@ struct __fn {
 } // namespace __distance
 
 inline namespace __cpo {
-  inline constexpr auto distance = __distance::__fn{};
+inline constexpr auto distance = __distance::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__iterator/empty.h b/third_party/libcxx/__iterator/empty.h
index 2cd4c7abf..773f27769 100644
--- a/third_party/libcxx/__iterator/empty.h
+++ b/third_party/libcxx/__iterator/empty.h
@@ -23,19 +23,20 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 17
 
 template <class _Cont>
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-constexpr auto empty(const _Cont& __c)
-_NOEXCEPT_(noexcept(__c.empty()))
--> decltype        (__c.empty())
-{ return            __c.empty(); }
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto
+empty(const _Cont& __c) noexcept(noexcept(__c.empty())) -> decltype(__c.empty()) {
+  return __c.empty();
+}
 
 template <class _Tp, size_t _Sz>
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-constexpr bool empty(const _Tp (&)[_Sz]) noexcept { return false; }
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty(const _Tp (&)[_Sz]) noexcept {
+  return false;
+}
 
 template <class _Ep>
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-constexpr bool empty(initializer_list<_Ep> __il) noexcept { return __il.size() == 0; }
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty(initializer_list<_Ep> __il) noexcept {
+  return __il.size() == 0;
+}
 
 #endif // _LIBCPP_STD_VER >= 17
 
diff --git a/third_party/libcxx/__iterator/erase_if_container.h b/third_party/libcxx/__iterator/erase_if_container.h
index d7c71a947..0f87f50cd 100644
--- a/third_party/libcxx/__iterator/erase_if_container.h
+++ b/third_party/libcxx/__iterator/erase_if_container.h
@@ -16,12 +16,13 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Container, class _Predicate>
-_LIBCPP_HIDE_FROM_ABI
-typename _Container::size_type
-__libcpp_erase_if_container(_Container& __c, _Predicate& __pred) {
+_LIBCPP_HIDE_FROM_ABI typename _Container::size_type __libcpp_erase_if_container(_Container& __c, _Predicate& __pred) {
   typename _Container::size_type __old_size = __c.size();
 
   const typename _Container::iterator __last = __c.end();
@@ -37,4 +38,6 @@ __libcpp_erase_if_container(_Container& __c, _Predicate& __pred) {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_ERASE_IF_CONTAINER_H
diff --git a/third_party/libcxx/__iterator/front_insert_iterator.h b/third_party/libcxx/__iterator/front_insert_iterator.h
index 1ad5348b2..7f2c54ec8 100644
--- a/third_party/libcxx/__iterator/front_insert_iterator.h
+++ b/third_party/libcxx/__iterator/front_insert_iterator.h
@@ -21,6 +21,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
@@ -30,42 +33,51 @@ class _LIBCPP_TEMPLATE_VIS front_insert_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 #endif
 {
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-protected:
-    _Container* container;
-public:
-    typedef output_iterator_tag iterator_category;
-    typedef void value_type;
-#if _LIBCPP_STD_VER >= 20
-    typedef ptrdiff_t difference_type;
-#else
-    typedef void difference_type;
-#endif
-    typedef void pointer;
-    typedef void reference;
-    typedef _Container container_type;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator& operator=(const typename _Container::value_type& __value)
-        {container->push_front(__value); return *this;}
+protected:
+  _Container* container;
+
+public:
+  typedef output_iterator_tag iterator_category;
+  typedef void value_type;
+#if _LIBCPP_STD_VER >= 20
+  typedef ptrdiff_t difference_type;
+#else
+  typedef void difference_type;
+#endif
+  typedef void pointer;
+  typedef void reference;
+  typedef _Container container_type;
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit front_insert_iterator(_Container& __x)
+      : container(std::addressof(__x)) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator&
+  operator=(const typename _Container::value_type& __value) {
+    container->push_front(__value);
+    return *this;
+  }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator& operator=(typename _Container::value_type&& __value)
-        {container->push_front(_VSTD::move(__value)); return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator&
+  operator=(typename _Container::value_type&& __value) {
+    container->push_front(std::move(__value));
+    return *this;
+  }
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator& operator*()     {return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator& operator++()    {return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator  operator++(int) {return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator& operator*() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator& operator++() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator operator++(int) { return *this; }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(front_insert_iterator);
 
 template <class _Container>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-front_insert_iterator<_Container>
-front_inserter(_Container& __x)
-{
-    return front_insert_iterator<_Container>(__x);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 front_insert_iterator<_Container>
+front_inserter(_Container& __x) {
+  return front_insert_iterator<_Container>(__x);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_FRONT_INSERT_ITERATOR_H
diff --git a/third_party/libcxx/__iterator/incrementable_traits.h b/third_party/libcxx/__iterator/incrementable_traits.h
index 604e9580e..a228b228f 100644
--- a/third_party/libcxx/__iterator/incrementable_traits.h
+++ b/third_party/libcxx/__iterator/incrementable_traits.h
@@ -29,33 +29,33 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 // [incrementable.traits]
-template<class> struct incrementable_traits {};
+template <class>
+struct incrementable_traits {};
 
-template<class _Tp>
-requires is_object_v<_Tp>
+template <class _Tp>
+  requires is_object_v<_Tp>
 struct incrementable_traits<_Tp*> {
   using difference_type = ptrdiff_t;
 };
 
-template<class _Ip>
+template <class _Ip>
 struct incrementable_traits<const _Ip> : incrementable_traits<_Ip> {};
 
-template<class _Tp>
+template <class _Tp>
 concept __has_member_difference_type = requires { typename _Tp::difference_type; };
 
-template<__has_member_difference_type _Tp>
+template <__has_member_difference_type _Tp>
 struct incrementable_traits<_Tp> {
   using difference_type = typename _Tp::difference_type;
 };
 
-template<class _Tp>
-concept __has_integral_minus =
-  requires(const _Tp& __x, const _Tp& __y) {
-    { __x - __y } -> integral;
-  };
+template <class _Tp>
+concept __has_integral_minus = requires(const _Tp& __x, const _Tp& __y) {
+  { __x - __y } -> integral;
+};
 
-template<__has_integral_minus _Tp>
-requires (!__has_member_difference_type<_Tp>)
+template <__has_integral_minus _Tp>
+  requires(!__has_member_difference_type<_Tp>)
 struct incrementable_traits<_Tp> {
   using difference_type = make_signed_t<decltype(std::declval<_Tp>() - std::declval<_Tp>())>;
 };
@@ -67,9 +67,10 @@ struct iterator_traits;
 // `incrementable_traits<RI>::difference_type` if `iterator_traits<RI>` names a specialization
 // generated from the primary template, and `iterator_traits<RI>::difference_type` otherwise.
 template <class _Ip>
-using iter_difference_t = typename conditional_t<__is_primary_template<iterator_traits<remove_cvref_t<_Ip> > >::value,
-                                                 incrementable_traits<remove_cvref_t<_Ip> >,
-                                                 iterator_traits<remove_cvref_t<_Ip> > >::difference_type;
+using iter_difference_t =
+    typename conditional_t<__is_primary_template<iterator_traits<remove_cvref_t<_Ip> > >::value,
+                           incrementable_traits<remove_cvref_t<_Ip> >,
+                           iterator_traits<remove_cvref_t<_Ip> > >::difference_type;
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__iterator/indirectly_comparable.h b/third_party/libcxx/__iterator/indirectly_comparable.h
index e60ba25ca..e8a7398ba 100644
--- a/third_party/libcxx/__iterator/indirectly_comparable.h
+++ b/third_party/libcxx/__iterator/indirectly_comparable.h
@@ -24,8 +24,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 template <class _I1, class _I2, class _Rp, class _P1 = identity, class _P2 = identity>
-concept indirectly_comparable =
-  indirect_binary_predicate<_Rp, projected<_I1, _P1>, projected<_I2, _P2>>;
+concept indirectly_comparable = indirect_binary_predicate<_Rp, projected<_I1, _P1>, projected<_I2, _P2>>;
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__iterator/insert_iterator.h b/third_party/libcxx/__iterator/insert_iterator.h
index 55348545e..8b7574dc9 100644
--- a/third_party/libcxx/__iterator/insert_iterator.h
+++ b/third_party/libcxx/__iterator/insert_iterator.h
@@ -22,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -39,43 +42,54 @@ class _LIBCPP_TEMPLATE_VIS insert_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 #endif
 {
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-protected:
-    _Container* container;
-    __insert_iterator_iter_t<_Container> iter;
-public:
-    typedef output_iterator_tag iterator_category;
-    typedef void value_type;
-#if _LIBCPP_STD_VER >= 20
-    typedef ptrdiff_t difference_type;
-#else
-    typedef void difference_type;
-#endif
-    typedef void pointer;
-    typedef void reference;
-    typedef _Container container_type;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator(_Container& __x, __insert_iterator_iter_t<_Container> __i)
-        : container(_VSTD::addressof(__x)), iter(__i) {}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator=(const typename _Container::value_type& __value)
-        {iter = container->insert(iter, __value); ++iter; return *this;}
+protected:
+  _Container* container;
+  __insert_iterator_iter_t<_Container> iter;
+
+public:
+  typedef output_iterator_tag iterator_category;
+  typedef void value_type;
+#if _LIBCPP_STD_VER >= 20
+  typedef ptrdiff_t difference_type;
+#else
+  typedef void difference_type;
+#endif
+  typedef void pointer;
+  typedef void reference;
+  typedef _Container container_type;
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  insert_iterator(_Container& __x, __insert_iterator_iter_t<_Container> __i)
+      : container(std::addressof(__x)), iter(__i) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator&
+  operator=(const typename _Container::value_type& __value) {
+    iter = container->insert(iter, __value);
+    ++iter;
+    return *this;
+  }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator=(typename _Container::value_type&& __value)
-        {iter = container->insert(iter, _VSTD::move(__value)); ++iter; return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator&
+  operator=(typename _Container::value_type&& __value) {
+    iter = container->insert(iter, std::move(__value));
+    ++iter;
+    return *this;
+  }
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator*()        {return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator++()       {return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator++(int)    {return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator*() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator++() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator& operator++(int) { return *this; }
 };
 
 template <class _Container>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-insert_iterator<_Container>
-inserter(_Container& __x, __insert_iterator_iter_t<_Container> __i)
-{
-    return insert_iterator<_Container>(__x, __i);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert_iterator<_Container>
+inserter(_Container& __x, __insert_iterator_iter_t<_Container> __i) {
+  return insert_iterator<_Container>(__x, __i);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_INSERT_ITERATOR_H
diff --git a/third_party/libcxx/__iterator/istream_iterator.h b/third_party/libcxx/__iterator/istream_iterator.h
index 989902f21..58c9ac6d4 100644
--- a/third_party/libcxx/__iterator/istream_iterator.h
+++ b/third_party/libcxx/__iterator/istream_iterator.h
@@ -11,12 +11,13 @@
 #define _LIBCPP___ITERATOR_ISTREAM_ITERATOR_H
 
 #include <__config>
+#include <__fwd/istream.h>
+#include <__fwd/string.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <cstddef>
-#include <iosfwd> // for forward declarations of char_traits and basic_istream
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -25,78 +26,73 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-template <class _Tp, class _CharT = char,
-          class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
+template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
 class _LIBCPP_TEMPLATE_VIS istream_iterator
 #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
     : public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>
 #endif
 {
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
 public:
-    typedef input_iterator_tag iterator_category;
-    typedef _Tp value_type;
-    typedef _Distance difference_type;
-    typedef const _Tp* pointer;
-    typedef const _Tp& reference;
-    typedef _CharT char_type;
-    typedef _Traits traits_type;
-    typedef basic_istream<_CharT,_Traits> istream_type;
+  typedef input_iterator_tag iterator_category;
+  typedef _Tp value_type;
+  typedef _Distance difference_type;
+  typedef const _Tp* pointer;
+  typedef const _Tp& reference;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef basic_istream<_CharT, _Traits> istream_type;
+
 private:
-    istream_type* __in_stream_;
-    _Tp __value_;
+  istream_type* __in_stream_;
+  _Tp __value_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(nullptr), __value_() {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR istream_iterator() : __in_stream_(nullptr), __value_() {}
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI constexpr istream_iterator(default_sentinel_t) : istream_iterator() {}
+  _LIBCPP_HIDE_FROM_ABI constexpr istream_iterator(default_sentinel_t) : istream_iterator() {}
 #endif // _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY istream_iterator(istream_type& __s) : __in_stream_(_VSTD::addressof(__s))
-        {
-            if (!(*__in_stream_ >> __value_))
-                __in_stream_ = nullptr;
-        }
+  _LIBCPP_HIDE_FROM_ABI istream_iterator(istream_type& __s) : __in_stream_(std::addressof(__s)) {
+    if (!(*__in_stream_ >> __value_))
+      __in_stream_ = nullptr;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY const _Tp& operator*() const {return __value_;}
-    _LIBCPP_INLINE_VISIBILITY const _Tp* operator->() const {return _VSTD::addressof((operator*()));}
-    _LIBCPP_INLINE_VISIBILITY istream_iterator& operator++()
-        {
-            if (!(*__in_stream_ >> __value_))
-                __in_stream_ = nullptr;
-            return *this;
-        }
-    _LIBCPP_INLINE_VISIBILITY istream_iterator  operator++(int)
-        {istream_iterator __t(*this); ++(*this); return __t;}
+  _LIBCPP_HIDE_FROM_ABI const _Tp& operator*() const { return __value_; }
+  _LIBCPP_HIDE_FROM_ABI const _Tp* operator->() const { return std::addressof((operator*())); }
+  _LIBCPP_HIDE_FROM_ABI istream_iterator& operator++() {
+    if (!(*__in_stream_ >> __value_))
+      __in_stream_ = nullptr;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI istream_iterator operator++(int) {
+    istream_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool
-    operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
-               const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
+  template <class _Up, class _CharU, class _TraitsU, class _DistanceU>
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __x,
+                                               const istream_iterator<_Up, _CharU, _TraitsU, _DistanceU>& __y);
 
 #if _LIBCPP_STD_VER >= 20
-    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator& __i, default_sentinel_t) {
-      return __i.__in_stream_ == nullptr;
-    }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator& __i, default_sentinel_t) {
+    return __i.__in_stream_ == nullptr;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 };
 
 template <class _Tp, class _CharT, class _Traits, class _Distance>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
-           const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
-{
-    return __x.__in_stream_ == __y.__in_stream_;
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
+                                             const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y) {
+  return __x.__in_stream_ == __y.__in_stream_;
 }
 
 #if _LIBCPP_STD_VER <= 17
 template <class _Tp, class _CharT, class _Traits, class _Distance>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
-           const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __x,
+                                             const istream_iterator<_Tp, _CharT, _Traits, _Distance>& __y) {
+  return !(__x == __y);
 }
 #endif // _LIBCPP_STD_VER <= 17
 
diff --git a/third_party/libcxx/__iterator/istreambuf_iterator.h b/third_party/libcxx/__iterator/istreambuf_iterator.h
index e39fec6d7..51c4ecff3 100644
--- a/third_party/libcxx/__iterator/istreambuf_iterator.h
+++ b/third_party/libcxx/__iterator/istreambuf_iterator.h
@@ -11,10 +11,11 @@
 #define _LIBCPP___ITERATOR_ISTREAMBUF_ITERATOR_H
 
 #include <__config>
+#include <__fwd/istream.h>
+#include <__fwd/streambuf.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
-#include <iosfwd> // for forward declaration of basic_streambuf
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -23,95 +24,84 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-template<class _CharT, class _Traits>
+template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS istreambuf_iterator
 #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
-    : public iterator<input_iterator_tag, _CharT,
-                      typename _Traits::off_type, _CharT*,
-                      _CharT>
+    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type, _CharT*, _CharT>
 #endif
 {
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
 public:
-    typedef input_iterator_tag              iterator_category;
-    typedef _CharT                          value_type;
-    typedef typename _Traits::off_type      difference_type;
-    typedef _CharT*                         pointer;
-    typedef _CharT                          reference;
-    typedef _CharT                          char_type;
-    typedef _Traits                         traits_type;
-    typedef typename _Traits::int_type      int_type;
-    typedef basic_streambuf<_CharT,_Traits> streambuf_type;
-    typedef basic_istream<_CharT,_Traits>   istream_type;
+  typedef input_iterator_tag iterator_category;
+  typedef _CharT value_type;
+  typedef typename _Traits::off_type difference_type;
+  typedef _CharT* pointer;
+  typedef _CharT reference;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename _Traits::int_type int_type;
+  typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+  typedef basic_istream<_CharT, _Traits> istream_type;
+
 private:
-    mutable streambuf_type* __sbuf_;
+  mutable streambuf_type* __sbuf_;
 
-    class __proxy
-    {
-        char_type __keep_;
-        streambuf_type* __sbuf_;
-        _LIBCPP_INLINE_VISIBILITY
-        explicit __proxy(char_type __c, streambuf_type* __s)
-            : __keep_(__c), __sbuf_(__s) {}
-        friend class istreambuf_iterator;
-    public:
-        _LIBCPP_INLINE_VISIBILITY char_type operator*() const {return __keep_;}
-    };
+  class __proxy {
+    char_type __keep_;
+    streambuf_type* __sbuf_;
+    _LIBCPP_HIDE_FROM_ABI explicit __proxy(char_type __c, streambuf_type* __s) : __keep_(__c), __sbuf_(__s) {}
+    friend class istreambuf_iterator;
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI char_type operator*() const { return __keep_; }
+  };
+
+  _LIBCPP_HIDE_FROM_ABI bool __test_for_eof() const {
+    if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
+      __sbuf_ = nullptr;
+    return __sbuf_ == nullptr;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool __test_for_eof() const
-    {
-        if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sgetc(), traits_type::eof()))
-            __sbuf_ = nullptr;
-        return __sbuf_ == nullptr;
-    }
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR istreambuf_iterator() _NOEXCEPT : __sbuf_(nullptr) {}
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY constexpr istreambuf_iterator(default_sentinel_t) noexcept
-        : istreambuf_iterator() {}
+  _LIBCPP_HIDE_FROM_ABI constexpr istreambuf_iterator(default_sentinel_t) noexcept : istreambuf_iterator() {}
 #endif // _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(istream_type& __s) _NOEXCEPT
-        : __sbuf_(__s.rdbuf()) {}
-    _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(streambuf_type* __s) _NOEXCEPT
-        : __sbuf_(__s) {}
-    _LIBCPP_INLINE_VISIBILITY istreambuf_iterator(const __proxy& __p) _NOEXCEPT
-        : __sbuf_(__p.__sbuf_) {}
+  _LIBCPP_HIDE_FROM_ABI istreambuf_iterator(istream_type& __s) _NOEXCEPT : __sbuf_(__s.rdbuf()) {}
+  _LIBCPP_HIDE_FROM_ABI istreambuf_iterator(streambuf_type* __s) _NOEXCEPT : __sbuf_(__s) {}
+  _LIBCPP_HIDE_FROM_ABI istreambuf_iterator(const __proxy& __p) _NOEXCEPT : __sbuf_(__p.__sbuf_) {}
 
-    _LIBCPP_INLINE_VISIBILITY char_type  operator*() const
-        {return static_cast<char_type>(__sbuf_->sgetc());}
-    _LIBCPP_INLINE_VISIBILITY istreambuf_iterator& operator++()
-        {
-            __sbuf_->sbumpc();
-            return *this;
-        }
-    _LIBCPP_INLINE_VISIBILITY __proxy              operator++(int)
-        {
-            return __proxy(__sbuf_->sbumpc(), __sbuf_);
-        }
+  _LIBCPP_HIDE_FROM_ABI char_type operator*() const { return static_cast<char_type>(__sbuf_->sgetc()); }
+  _LIBCPP_HIDE_FROM_ABI istreambuf_iterator& operator++() {
+    __sbuf_->sbumpc();
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __proxy operator++(int) { return __proxy(__sbuf_->sbumpc(), __sbuf_); }
 
-    _LIBCPP_INLINE_VISIBILITY bool equal(const istreambuf_iterator& __b) const
-        {return __test_for_eof() == __b.__test_for_eof();}
+  _LIBCPP_HIDE_FROM_ABI bool equal(const istreambuf_iterator& __b) const {
+    return __test_for_eof() == __b.__test_for_eof();
+  }
 
 #if _LIBCPP_STD_VER >= 20
-    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istreambuf_iterator& __i, default_sentinel_t) {
-      return __i.__test_for_eof();
-    }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const istreambuf_iterator& __i, default_sentinel_t) {
+    return __i.__test_for_eof();
+  }
 #endif // _LIBCPP_STD_VER >= 20
 };
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator==(const istreambuf_iterator<_CharT,_Traits>& __a,
-                const istreambuf_iterator<_CharT,_Traits>& __b)
-                {return __a.equal(__b);}
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b) {
+  return __a.equal(__b);
+}
 
 #if _LIBCPP_STD_VER <= 17
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator!=(const istreambuf_iterator<_CharT,_Traits>& __a,
-                const istreambuf_iterator<_CharT,_Traits>& __b)
-                {return !__a.equal(__b);}
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, const istreambuf_iterator<_CharT, _Traits>& __b) {
+  return !__a.equal(__b);
+}
 #endif // _LIBCPP_STD_VER <= 17
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__iterator/iter_move.h b/third_party/libcxx/__iterator/iter_move.h
index 78b1448d0..ba8aed3c0 100644
--- a/third_party/libcxx/__iterator/iter_move.h
+++ b/third_party/libcxx/__iterator/iter_move.h
@@ -23,6 +23,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -32,73 +35,69 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __iter_move {
 
-void iter_move();
+void iter_move() = delete;
 
 template <class _Tp>
-concept __unqualified_iter_move =
-  __class_or_enum<remove_cvref_t<_Tp>> &&
-  requires (_Tp&& __t) {
-    // NOLINTNEXTLINE(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap
-    iter_move(std::forward<_Tp>(__t));
-  };
+concept __unqualified_iter_move = __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+  // NOLINTNEXTLINE(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap
+  iter_move(std::forward<_Tp>(__t));
+};
 
-template<class _Tp>
-concept __move_deref =
-  !__unqualified_iter_move<_Tp> &&
-  requires (_Tp&& __t) {
-    *__t;
-    requires is_lvalue_reference_v<decltype(*__t)>;
-  };
+template <class _Tp>
+concept __move_deref = !__unqualified_iter_move<_Tp> && requires(_Tp&& __t) {
+  *__t;
+  requires is_lvalue_reference_v<decltype(*__t)>;
+};
 
-template<class _Tp>
-concept __just_deref =
-  !__unqualified_iter_move<_Tp> &&
-  !__move_deref<_Tp> &&
-  requires (_Tp&& __t) {
-    *__t;
-    requires (!is_lvalue_reference_v<decltype(*__t)>);
-  };
+template <class _Tp>
+concept __just_deref = !__unqualified_iter_move<_Tp> && !__move_deref<_Tp> && requires(_Tp&& __t) {
+  *__t;
+  requires(!is_lvalue_reference_v<decltype(*__t)>);
+};
 
 // [iterator.cust.move]
 
 struct __fn {
   // NOLINTBEGIN(libcpp-robust-against-adl) iter_move ADL calls should only be made through ranges::iter_move
-  template<class _Ip>
+  template <class _Ip>
     requires __unqualified_iter_move<_Ip>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Ip&& __i) const
-    noexcept(noexcept(iter_move(std::forward<_Ip>(__i))))
-  {
+      noexcept(noexcept(iter_move(std::forward<_Ip>(__i)))) {
     return iter_move(std::forward<_Ip>(__i));
   }
   // NOLINTEND(libcpp-robust-against-adl)
 
-  template<class _Ip>
+  template <class _Ip>
     requires __move_deref<_Ip>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ip&& __i) const
-    noexcept(noexcept(std::move(*std::forward<_Ip>(__i))))
-    -> decltype(      std::move(*std::forward<_Ip>(__i)))
-    { return          std::move(*std::forward<_Ip>(__i)); }
+      noexcept(noexcept(std::move(*std::forward<_Ip>(__i)))) -> decltype(std::move(*std::forward<_Ip>(__i))) {
+    return std::move(*std::forward<_Ip>(__i));
+  }
 
-  template<class _Ip>
+  template <class _Ip>
     requires __just_deref<_Ip>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ip&& __i) const
-    noexcept(noexcept(*std::forward<_Ip>(__i)))
-    -> decltype(      *std::forward<_Ip>(__i))
-    { return          *std::forward<_Ip>(__i); }
+      noexcept(noexcept(*std::forward<_Ip>(__i))) -> decltype(*std::forward<_Ip>(__i)) {
+    return *std::forward<_Ip>(__i);
+  }
 };
 } // namespace __iter_move
 
 inline namespace __cpo {
-  inline constexpr auto iter_move = __iter_move::__fn{};
+inline constexpr auto iter_move = __iter_move::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
-template<__dereferenceable _Tp>
-  requires requires(_Tp& __t) { { ranges::iter_move(__t) } -> __can_reference; }
+template <__dereferenceable _Tp>
+  requires requires(_Tp& __t) {
+    { ranges::iter_move(__t) } -> __can_reference;
+  }
 using iter_rvalue_reference_t = decltype(ranges::iter_move(std::declval<_Tp&>()));
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_ITER_MOVE_H
diff --git a/third_party/libcxx/__iterator/iter_swap.h b/third_party/libcxx/__iterator/iter_swap.h
index c78efafb9..01ab1b97d 100644
--- a/third_party/libcxx/__iterator/iter_swap.h
+++ b/third_party/libcxx/__iterator/iter_swap.h
@@ -26,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -34,80 +37,72 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __iter_swap {
-  template<class _I1, class _I2>
-  void iter_swap(_I1, _I2) = delete;
+template <class _I1, class _I2>
+void iter_swap(_I1, _I2) = delete;
 
-  template<class _T1, class _T2>
-  concept __unqualified_iter_swap =
-    (__class_or_enum<remove_cvref_t<_T1>> || __class_or_enum<remove_cvref_t<_T2>>) &&
-    requires (_T1&& __x, _T2&& __y) {
+template <class _T1, class _T2>
+concept __unqualified_iter_swap =
+    (__class_or_enum<remove_cvref_t<_T1>> || __class_or_enum<remove_cvref_t<_T2>>) && requires(_T1&& __x, _T2&& __y) {
       // NOLINTNEXTLINE(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap
-      iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y));
+      iter_swap(std::forward<_T1>(__x), std::forward<_T2>(__y));
     };
 
-  template<class _T1, class _T2>
-  concept __readable_swappable =
+template <class _T1, class _T2>
+concept __readable_swappable =
     indirectly_readable<_T1> && indirectly_readable<_T2> &&
     swappable_with<iter_reference_t<_T1>, iter_reference_t<_T2>>;
 
+struct __fn {
+  // NOLINTBEGIN(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap
+  template <class _T1, class _T2>
+    requires __unqualified_iter_swap<_T1, _T2>
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_T1&& __x, _T2&& __y) const
+      noexcept(noexcept(iter_swap(std::forward<_T1>(__x), std::forward<_T2>(__y)))) {
+    (void)iter_swap(std::forward<_T1>(__x), std::forward<_T2>(__y));
+  }
+  // NOLINTEND(libcpp-robust-against-adl)
 
-  struct __fn {
-    // NOLINTBEGIN(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap
-    template <class _T1, class _T2>
-      requires __unqualified_iter_swap<_T1, _T2>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator()(_T1&& __x, _T2&& __y) const
-      noexcept(noexcept(iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y))))
-    {
-      (void)iter_swap(_VSTD::forward<_T1>(__x), _VSTD::forward<_T2>(__y));
-    }
-    // NOLINTEND(libcpp-robust-against-adl)
+  template <class _T1, class _T2>
+    requires(!__unqualified_iter_swap<_T1, _T2>) && __readable_swappable<_T1, _T2>
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_T1&& __x, _T2&& __y) const
+      noexcept(noexcept(ranges::swap(*std::forward<_T1>(__x), *std::forward<_T2>(__y)))) {
+    ranges::swap(*std::forward<_T1>(__x), *std::forward<_T2>(__y));
+  }
 
-    template <class _T1, class _T2>
-      requires (!__unqualified_iter_swap<_T1, _T2>) &&
-               __readable_swappable<_T1, _T2>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator()(_T1&& __x, _T2&& __y) const
-      noexcept(noexcept(ranges::swap(*_VSTD::forward<_T1>(__x), *_VSTD::forward<_T2>(__y))))
-    {
-      ranges::swap(*_VSTD::forward<_T1>(__x), *_VSTD::forward<_T2>(__y));
-    }
-
-    template <class _T1, class _T2>
-      requires (!__unqualified_iter_swap<_T1, _T2> &&
-                !__readable_swappable<_T1, _T2>) &&
-               indirectly_movable_storable<_T1, _T2> &&
-               indirectly_movable_storable<_T2, _T1>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator()(_T1&& __x, _T2&& __y) const
-      noexcept(noexcept(iter_value_t<_T2>(ranges::iter_move(__y))) &&
-               noexcept(*__y = ranges::iter_move(__x)) &&
-               noexcept(*_VSTD::forward<_T1>(__x) = std::declval<iter_value_t<_T2>>()))
-    {
-      iter_value_t<_T2> __old(ranges::iter_move(__y));
-      *__y = ranges::iter_move(__x);
-      *_VSTD::forward<_T1>(__x) = _VSTD::move(__old);
-    }
-  };
+  template <class _T1, class _T2>
+    requires(!__unqualified_iter_swap<_T1, _T2> &&   //
+             !__readable_swappable<_T1, _T2>) &&     //
+            indirectly_movable_storable<_T1, _T2> && //
+            indirectly_movable_storable<_T2, _T1>
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_T1&& __x, _T2&& __y) const
+      noexcept(noexcept(iter_value_t<_T2>(ranges::iter_move(__y))) && //
+               noexcept(*__y = ranges::iter_move(__x)) &&             //
+               noexcept(*std::forward<_T1>(__x) = std::declval<iter_value_t<_T2>>())) {
+    iter_value_t<_T2> __old(ranges::iter_move(__y));
+    *__y                    = ranges::iter_move(__x);
+    *std::forward<_T1>(__x) = std::move(__old);
+  }
+};
 } // namespace __iter_swap
 
 inline namespace __cpo {
-  inline constexpr auto iter_swap = __iter_swap::__fn{};
+inline constexpr auto iter_swap = __iter_swap::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
-template<class _I1, class _I2 = _I1>
+template <class _I1, class _I2 = _I1>
 concept indirectly_swappable =
-  indirectly_readable<_I1> && indirectly_readable<_I2> &&
-  requires(const _I1 __i1, const _I2 __i2) {
-    ranges::iter_swap(__i1, __i1);
-    ranges::iter_swap(__i2, __i2);
-    ranges::iter_swap(__i1, __i2);
-    ranges::iter_swap(__i2, __i1);
-  };
+    indirectly_readable<_I1> && indirectly_readable<_I2> && requires(const _I1 __i1, const _I2 __i2) {
+      ranges::iter_swap(__i1, __i1);
+      ranges::iter_swap(__i2, __i2);
+      ranges::iter_swap(__i1, __i2);
+      ranges::iter_swap(__i2, __i1);
+    };
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_ITER_SWAP_H
diff --git a/third_party/libcxx/__iterator/iterator.h b/third_party/libcxx/__iterator/iterator.h
index b417eeab7..ba9308f3c 100644
--- a/third_party/libcxx/__iterator/iterator.h
+++ b/third_party/libcxx/__iterator/iterator.h
@@ -19,15 +19,13 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Category, class _Tp, class _Distance = ptrdiff_t,
-         class _Pointer = _Tp*, class _Reference = _Tp&>
-struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 iterator
-{
-    typedef _Tp        value_type;
-    typedef _Distance  difference_type;
-    typedef _Pointer   pointer;
-    typedef _Reference reference;
-    typedef _Category  iterator_category;
+template <class _Category, class _Tp, class _Distance = ptrdiff_t, class _Pointer = _Tp*, class _Reference = _Tp&>
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 iterator {
+  typedef _Tp value_type;
+  typedef _Distance difference_type;
+  typedef _Pointer pointer;
+  typedef _Reference reference;
+  typedef _Category iterator_category;
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__iterator/iterator_traits.h b/third_party/libcxx/__iterator/iterator_traits.h
index a81f0b577..11af9e301 100644
--- a/third_party/libcxx/__iterator/iterator_traits.h
+++ b/third_party/libcxx/__iterator/iterator_traits.h
@@ -21,7 +21,6 @@
 #include <__fwd/pair.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/readable_traits.h>
-#include <__type_traits/add_const.h>
 #include <__type_traits/common_reference.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/disjunction.h>
@@ -49,9 +48,7 @@ template <class _Tp>
 using __with_reference = _Tp&;
 
 template <class _Tp>
-concept __can_reference = requires {
-  typename __with_reference<_Tp>;
-};
+concept __can_reference = requires { typename __with_reference<_Tp>; };
 
 template <class _Tp>
 concept __dereferenceable = requires(_Tp& __t) {
@@ -59,7 +56,7 @@ concept __dereferenceable = requires(_Tp& __t) {
 };
 
 // [iterator.traits]
-template<__dereferenceable _Tp>
+template <__dereferenceable _Tp>
 using iter_reference_t = decltype(*std::declval<_Tp&>());
 
 #endif // _LIBCPP_STD_VER >= 20
@@ -69,20 +66,16 @@ struct _LIBCPP_TEMPLATE_VIS iterator_traits;
 
 struct _LIBCPP_TEMPLATE_VIS input_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS output_iterator_tag {};
-struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag       : public input_iterator_tag {};
+struct _LIBCPP_TEMPLATE_VIS forward_iterator_tag : public input_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS bidirectional_iterator_tag : public forward_iterator_tag {};
 struct _LIBCPP_TEMPLATE_VIS random_access_iterator_tag : public bidirectional_iterator_tag {};
 #if _LIBCPP_STD_VER >= 20
-struct _LIBCPP_TEMPLATE_VIS contiguous_iterator_tag    : public random_access_iterator_tag {};
+struct _LIBCPP_TEMPLATE_VIS contiguous_iterator_tag : public random_access_iterator_tag {};
 #endif
 
 template <class _Iter>
 struct __iter_traits_cache {
-  using type = _If<
-    __is_primary_template<iterator_traits<_Iter> >::value,
-    _Iter,
-    iterator_traits<_Iter>
-  >;
+  using type = _If< __is_primary_template<iterator_traits<_Iter> >::value, _Iter, iterator_traits<_Iter> >;
 };
 template <class _Iter>
 using _ITER_TRAITS = typename __iter_traits_cache<_Iter>::type;
@@ -97,64 +90,61 @@ struct __iter_concept_category_test {
 };
 struct __iter_concept_random_fallback {
   template <class _Iter>
-  using _Apply = __enable_if_t<
-                          __is_primary_template<iterator_traits<_Iter> >::value,
-                          random_access_iterator_tag
-                        >;
+  using _Apply = __enable_if_t< __is_primary_template<iterator_traits<_Iter> >::value, random_access_iterator_tag >;
 };
 
-template <class _Iter, class _Tester> struct __test_iter_concept
-    : _IsValidExpansion<_Tester::template _Apply, _Iter>,
-      _Tester
-{
-};
+template <class _Iter, class _Tester>
+struct __test_iter_concept : _IsValidExpansion<_Tester::template _Apply, _Iter>, _Tester {};
 
 template <class _Iter>
 struct __iter_concept_cache {
-  using type = _Or<
-    __test_iter_concept<_Iter, __iter_concept_concept_test>,
-    __test_iter_concept<_Iter, __iter_concept_category_test>,
-    __test_iter_concept<_Iter, __iter_concept_random_fallback>
-  >;
+  using type = _Or< __test_iter_concept<_Iter, __iter_concept_concept_test>,
+                    __test_iter_concept<_Iter, __iter_concept_category_test>,
+                    __test_iter_concept<_Iter, __iter_concept_random_fallback> >;
 };
 
 template <class _Iter>
 using _ITER_CONCEPT = typename __iter_concept_cache<_Iter>::type::template _Apply<_Iter>;
 
-
 template <class _Tp>
-struct __has_iterator_typedefs
-{
+struct __has_iterator_typedefs {
 private:
-    template <class _Up> static false_type __test(...);
-    template <class _Up> static true_type __test(__void_t<typename _Up::iterator_category>* = nullptr,
-                                                 __void_t<typename _Up::difference_type>* = nullptr,
-                                                 __void_t<typename _Up::value_type>* = nullptr,
-                                                 __void_t<typename _Up::reference>* = nullptr,
-                                                 __void_t<typename _Up::pointer>* = nullptr);
-public:
-    static const bool value = decltype(__test<_Tp>(0,0,0,0,0))::value;
-};
+  template <class _Up>
+  static false_type __test(...);
+  template <class _Up>
+  static true_type
+  __test(__void_t<typename _Up::iterator_category>* = nullptr,
+         __void_t<typename _Up::difference_type>*   = nullptr,
+         __void_t<typename _Up::value_type>*        = nullptr,
+         __void_t<typename _Up::reference>*         = nullptr,
+         __void_t<typename _Up::pointer>*           = nullptr);
 
-
-template <class _Tp>
-struct __has_iterator_category
-{
-private:
-    template <class _Up> static false_type __test(...);
-    template <class _Up> static true_type __test(typename _Up::iterator_category* = nullptr);
 public:
-    static const bool value = decltype(__test<_Tp>(nullptr))::value;
+  static const bool value = decltype(__test<_Tp>(nullptr, nullptr, nullptr, nullptr, nullptr))::value;
 };
 
 template <class _Tp>
-struct __has_iterator_concept
-{
+struct __has_iterator_category {
 private:
-    template <class _Up> static false_type __test(...);
-    template <class _Up> static true_type __test(typename _Up::iterator_concept* = nullptr);
+  template <class _Up>
+  static false_type __test(...);
+  template <class _Up>
+  static true_type __test(typename _Up::iterator_category* = nullptr);
+
 public:
-    static const bool value = decltype(__test<_Tp>(nullptr))::value;
+  static const bool value = decltype(__test<_Tp>(nullptr))::value;
+};
+
+template <class _Tp>
+struct __has_iterator_concept {
+private:
+  template <class _Up>
+  static false_type __test(...);
+  template <class _Up>
+  static true_type __test(typename _Up::iterator_concept* = nullptr);
+
+public:
+  static const bool value = decltype(__test<_Tp>(nullptr))::value;
 };
 
 #if _LIBCPP_STD_VER >= 20
@@ -163,200 +153,194 @@ public:
 // from `[iterator.cpp17]`. To avoid confusion between the two, the exposition-only concepts have been banished to
 // a "detail" namespace indicating they have a niche use-case.
 namespace __iterator_traits_detail {
-template<class _Ip>
-concept __cpp17_iterator =
-  requires(_Ip __i) {
-    {   *__i } -> __can_reference;
-    {  ++__i } -> same_as<_Ip&>;
-    { *__i++ } -> __can_reference;
-  } &&
-  copyable<_Ip>;
+template <class _Ip>
+concept __cpp17_iterator = requires(_Ip __i) {
+  { *__i } -> __can_reference;
+  { ++__i } -> same_as<_Ip&>;
+  { *__i++ } -> __can_reference;
+} && copyable<_Ip>;
 
-template<class _Ip>
-concept __cpp17_input_iterator =
-  __cpp17_iterator<_Ip> &&
-  equality_comparable<_Ip> &&
-  requires(_Ip __i) {
-    typename incrementable_traits<_Ip>::difference_type;
-    typename indirectly_readable_traits<_Ip>::value_type;
-    typename common_reference_t<iter_reference_t<_Ip>&&,
-                                typename indirectly_readable_traits<_Ip>::value_type&>;
-    typename common_reference_t<decltype(*__i++)&&,
-                                typename indirectly_readable_traits<_Ip>::value_type&>;
-    requires signed_integral<typename incrementable_traits<_Ip>::difference_type>;
-  };
+template <class _Ip>
+concept __cpp17_input_iterator = __cpp17_iterator<_Ip> && equality_comparable<_Ip> && requires(_Ip __i) {
+  typename incrementable_traits<_Ip>::difference_type;
+  typename indirectly_readable_traits<_Ip>::value_type;
+  typename common_reference_t<iter_reference_t<_Ip>&&, typename indirectly_readable_traits<_Ip>::value_type&>;
+  typename common_reference_t<decltype(*__i++)&&, typename indirectly_readable_traits<_Ip>::value_type&>;
+  requires signed_integral<typename incrementable_traits<_Ip>::difference_type>;
+};
 
-template<class _Ip>
+template <class _Ip>
 concept __cpp17_forward_iterator =
-  __cpp17_input_iterator<_Ip> &&
-  constructible_from<_Ip> &&
-  is_reference_v<iter_reference_t<_Ip>> &&
-  same_as<remove_cvref_t<iter_reference_t<_Ip>>,
-          typename indirectly_readable_traits<_Ip>::value_type> &&
-  requires(_Ip __i) {
-    {  __i++ } -> convertible_to<_Ip const&>;
-    { *__i++ } -> same_as<iter_reference_t<_Ip>>;
-  };
+    __cpp17_input_iterator<_Ip> && constructible_from<_Ip> && is_reference_v<iter_reference_t<_Ip>> &&
+    same_as<remove_cvref_t<iter_reference_t<_Ip>>, typename indirectly_readable_traits<_Ip>::value_type> &&
+    requires(_Ip __i) {
+      { __i++ } -> convertible_to<_Ip const&>;
+      { *__i++ } -> same_as<iter_reference_t<_Ip>>;
+    };
 
-template<class _Ip>
-concept __cpp17_bidirectional_iterator =
-  __cpp17_forward_iterator<_Ip> &&
-  requires(_Ip __i) {
-    {  --__i } -> same_as<_Ip&>;
-    {  __i-- } -> convertible_to<_Ip const&>;
-    { *__i-- } -> same_as<iter_reference_t<_Ip>>;
-  };
+template <class _Ip>
+concept __cpp17_bidirectional_iterator = __cpp17_forward_iterator<_Ip> && requires(_Ip __i) {
+  { --__i } -> same_as<_Ip&>;
+  { __i-- } -> convertible_to<_Ip const&>;
+  { *__i-- } -> same_as<iter_reference_t<_Ip>>;
+};
 
-template<class _Ip>
+template <class _Ip>
 concept __cpp17_random_access_iterator =
-  __cpp17_bidirectional_iterator<_Ip> &&
-  totally_ordered<_Ip> &&
-  requires(_Ip __i, typename incrementable_traits<_Ip>::difference_type __n) {
-    { __i += __n } -> same_as<_Ip&>;
-    { __i -= __n } -> same_as<_Ip&>;
-    { __i +  __n } -> same_as<_Ip>;
-    { __n +  __i } -> same_as<_Ip>;
-    { __i -  __n } -> same_as<_Ip>;
-    { __i -  __i } -> same_as<decltype(__n)>; // NOLINT(misc-redundant-expression) ; This is llvm.org/PR54114
-    {  __i[__n]  } -> convertible_to<iter_reference_t<_Ip>>;
-  };
+    __cpp17_bidirectional_iterator<_Ip> && totally_ordered<_Ip> &&
+    requires(_Ip __i, typename incrementable_traits<_Ip>::difference_type __n) {
+      { __i += __n } -> same_as<_Ip&>;
+      { __i -= __n } -> same_as<_Ip&>;
+      { __i + __n } -> same_as<_Ip>;
+      { __n + __i } -> same_as<_Ip>;
+      { __i - __n } -> same_as<_Ip>;
+      { __i - __i } -> same_as<decltype(__n)>; // NOLINT(misc-redundant-expression) ; This is llvm.org/PR54114
+      { __i[__n] } -> convertible_to<iter_reference_t<_Ip>>;
+    };
 } // namespace __iterator_traits_detail
 
-template<class _Ip>
+template <class _Ip>
 concept __has_member_reference = requires { typename _Ip::reference; };
 
-template<class _Ip>
+template <class _Ip>
 concept __has_member_pointer = requires { typename _Ip::pointer; };
 
-template<class _Ip>
+template <class _Ip>
 concept __has_member_iterator_category = requires { typename _Ip::iterator_category; };
 
-template<class _Ip>
+template <class _Ip>
 concept __specifies_members = requires {
-    typename _Ip::value_type;
-    typename _Ip::difference_type;
-    requires __has_member_reference<_Ip>;
-    requires __has_member_iterator_category<_Ip>;
-  };
+  typename _Ip::value_type;
+  typename _Ip::difference_type;
+  requires __has_member_reference<_Ip>;
+  requires __has_member_iterator_category<_Ip>;
+};
 
-template<class>
+template <class>
 struct __iterator_traits_member_pointer_or_void {
   using type = void;
 };
 
-template<__has_member_pointer _Tp>
+template <__has_member_pointer _Tp>
 struct __iterator_traits_member_pointer_or_void<_Tp> {
   using type = typename _Tp::pointer;
 };
 
-template<class _Tp>
-concept __cpp17_iterator_missing_members =
-  !__specifies_members<_Tp> &&
-  __iterator_traits_detail::__cpp17_iterator<_Tp>;
+template <class _Tp>
+concept __cpp17_iterator_missing_members = !__specifies_members<_Tp> && __iterator_traits_detail::__cpp17_iterator<_Tp>;
 
-template<class _Tp>
+template <class _Tp>
 concept __cpp17_input_iterator_missing_members =
-  __cpp17_iterator_missing_members<_Tp> &&
-  __iterator_traits_detail::__cpp17_input_iterator<_Tp>;
+    __cpp17_iterator_missing_members<_Tp> && __iterator_traits_detail::__cpp17_input_iterator<_Tp>;
 
 // Otherwise, `pointer` names `void`.
-template<class>
-struct __iterator_traits_member_pointer_or_arrow_or_void { using type = void; };
+template <class>
+struct __iterator_traits_member_pointer_or_arrow_or_void {
+  using type = void;
+};
 
 // [iterator.traits]/3.2.1
 // If the qualified-id `I::pointer` is valid and denotes a type, `pointer` names that type.
-template<__has_member_pointer _Ip>
-struct __iterator_traits_member_pointer_or_arrow_or_void<_Ip> { using type = typename _Ip::pointer; };
+template <__has_member_pointer _Ip>
+struct __iterator_traits_member_pointer_or_arrow_or_void<_Ip> {
+  using type = typename _Ip::pointer;
+};
 
 // Otherwise, if `decltype(declval<I&>().operator->())` is well-formed, then `pointer` names that
 // type.
-template<class _Ip>
+template <class _Ip>
   requires requires(_Ip& __i) { __i.operator->(); } && (!__has_member_pointer<_Ip>)
 struct __iterator_traits_member_pointer_or_arrow_or_void<_Ip> {
   using type = decltype(std::declval<_Ip&>().operator->());
 };
 
 // Otherwise, `reference` names `iter-reference-t<I>`.
-template<class _Ip>
-struct __iterator_traits_member_reference { using type = iter_reference_t<_Ip>; };
+template <class _Ip>
+struct __iterator_traits_member_reference {
+  using type = iter_reference_t<_Ip>;
+};
 
 // [iterator.traits]/3.2.2
 // If the qualified-id `I::reference` is valid and denotes a type, `reference` names that type.
-template<__has_member_reference _Ip>
-struct __iterator_traits_member_reference<_Ip> { using type = typename _Ip::reference; };
+template <__has_member_reference _Ip>
+struct __iterator_traits_member_reference<_Ip> {
+  using type = typename _Ip::reference;
+};
 
 // [iterator.traits]/3.2.3.4
 // input_iterator_tag
-template<class _Ip>
+template <class _Ip>
 struct __deduce_iterator_category {
   using type = input_iterator_tag;
 };
 
 // [iterator.traits]/3.2.3.1
 // `random_access_iterator_tag` if `I` satisfies `cpp17-random-access-iterator`, or otherwise
-template<__iterator_traits_detail::__cpp17_random_access_iterator _Ip>
+template <__iterator_traits_detail::__cpp17_random_access_iterator _Ip>
 struct __deduce_iterator_category<_Ip> {
   using type = random_access_iterator_tag;
 };
 
 // [iterator.traits]/3.2.3.2
 // `bidirectional_iterator_tag` if `I` satisfies `cpp17-bidirectional-iterator`, or otherwise
-template<__iterator_traits_detail::__cpp17_bidirectional_iterator _Ip>
+template <__iterator_traits_detail::__cpp17_bidirectional_iterator _Ip>
 struct __deduce_iterator_category<_Ip> {
   using type = bidirectional_iterator_tag;
 };
 
 // [iterator.traits]/3.2.3.3
 // `forward_iterator_tag` if `I` satisfies `cpp17-forward-iterator`, or otherwise
-template<__iterator_traits_detail::__cpp17_forward_iterator _Ip>
+template <__iterator_traits_detail::__cpp17_forward_iterator _Ip>
 struct __deduce_iterator_category<_Ip> {
   using type = forward_iterator_tag;
 };
 
-template<class _Ip>
+template <class _Ip>
 struct __iterator_traits_iterator_category : __deduce_iterator_category<_Ip> {};
 
 // [iterator.traits]/3.2.3
 // If the qualified-id `I::iterator-category` is valid and denotes a type, `iterator-category` names
 // that type.
-template<__has_member_iterator_category _Ip>
+template <__has_member_iterator_category _Ip>
 struct __iterator_traits_iterator_category<_Ip> {
   using type = typename _Ip::iterator_category;
 };
 
 // otherwise, it names void.
-template<class>
-struct __iterator_traits_difference_type { using type = void; };
+template <class>
+struct __iterator_traits_difference_type {
+  using type = void;
+};
 
 // If the qualified-id `incrementable_traits<I>::difference_type` is valid and denotes a type, then
 // `difference_type` names that type;
-template<class _Ip>
-requires requires { typename incrementable_traits<_Ip>::difference_type; }
+template <class _Ip>
+  requires requires { typename incrementable_traits<_Ip>::difference_type; }
 struct __iterator_traits_difference_type<_Ip> {
   using type = typename incrementable_traits<_Ip>::difference_type;
 };
 
 // [iterator.traits]/3.4
 // Otherwise, `iterator_traits<I>` has no members by any of the above names.
-template<class>
+template <class>
 struct __iterator_traits {};
 
 // [iterator.traits]/3.1
 // If `I` has valid ([temp.deduct]) member types `difference-type`, `value-type`, `reference`, and
 // `iterator-category`, then `iterator-traits<I>` has the following publicly accessible members:
-template<__specifies_members _Ip>
+template <__specifies_members _Ip>
 struct __iterator_traits<_Ip> {
-  using iterator_category  = typename _Ip::iterator_category;
-  using value_type         = typename _Ip::value_type;
-  using difference_type    = typename _Ip::difference_type;
-  using pointer            = typename __iterator_traits_member_pointer_or_void<_Ip>::type;
-  using reference          = typename _Ip::reference;
+  using iterator_category = typename _Ip::iterator_category;
+  using value_type        = typename _Ip::value_type;
+  using difference_type   = typename _Ip::difference_type;
+  using pointer           = typename __iterator_traits_member_pointer_or_void<_Ip>::type;
+  using reference         = typename _Ip::reference;
 };
 
 // [iterator.traits]/3.2
 // Otherwise, if `I` satisfies the exposition-only concept `cpp17-input-iterator`,
 // `iterator-traits<I>` has the following publicly accessible members:
-template<__cpp17_input_iterator_missing_members _Ip>
+template <__cpp17_input_iterator_missing_members _Ip>
 struct __iterator_traits<_Ip> {
   using iterator_category = typename __iterator_traits_iterator_category<_Ip>::type;
   using value_type        = typename indirectly_readable_traits<_Ip>::value_type;
@@ -367,7 +351,7 @@ struct __iterator_traits<_Ip> {
 
 // Otherwise, if `I` satisfies the exposition-only concept `cpp17-iterator`, then
 // `iterator_traits<I>` has the following publicly accessible members:
-template<__cpp17_iterator_missing_members _Ip>
+template <__cpp17_iterator_missing_members _Ip>
 struct __iterator_traits<_Ip> {
   using iterator_category = output_iterator_tag;
   using value_type        = void;
@@ -376,36 +360,33 @@ struct __iterator_traits<_Ip> {
   using reference         = void;
 };
 
-template<class _Ip>
+template <class _Ip>
 struct iterator_traits : __iterator_traits<_Ip> {
   using __primary_template = iterator_traits;
 };
 
-#else // _LIBCPP_STD_VER >= 20
+#else  // _LIBCPP_STD_VER >= 20
 
-template <class _Iter, bool> struct __iterator_traits {};
+template <class _Iter, bool>
+struct __iterator_traits {};
 
-template <class _Iter, bool> struct __iterator_traits_impl {};
+template <class _Iter, bool>
+struct __iterator_traits_impl {};
 
 template <class _Iter>
-struct __iterator_traits_impl<_Iter, true>
-{
-    typedef typename _Iter::difference_type   difference_type;
-    typedef typename _Iter::value_type        value_type;
-    typedef typename _Iter::pointer           pointer;
-    typedef typename _Iter::reference         reference;
-    typedef typename _Iter::iterator_category iterator_category;
+struct __iterator_traits_impl<_Iter, true> {
+  typedef typename _Iter::difference_type difference_type;
+  typedef typename _Iter::value_type value_type;
+  typedef typename _Iter::pointer pointer;
+  typedef typename _Iter::reference reference;
+  typedef typename _Iter::iterator_category iterator_category;
 };
 
 template <class _Iter>
 struct __iterator_traits<_Iter, true>
-    :  __iterator_traits_impl
-      <
-        _Iter,
-        is_convertible<typename _Iter::iterator_category, input_iterator_tag>::value ||
-        is_convertible<typename _Iter::iterator_category, output_iterator_tag>::value
-      >
-{};
+    : __iterator_traits_impl< _Iter,
+                              is_convertible<typename _Iter::iterator_category, input_iterator_tag>::value ||
+                                  is_convertible<typename _Iter::iterator_category, output_iterator_tag>::value > {};
 
 // iterator_traits<Iterator> will only have the nested types if Iterator::iterator_category
 //    exists.  Else iterator_traits<Iterator> will be an empty class.  This is a
@@ -413,41 +394,35 @@ struct __iterator_traits<_Iter, true>
 //    the client expects instead of failing at compile time.
 
 template <class _Iter>
-struct _LIBCPP_TEMPLATE_VIS iterator_traits
-    : __iterator_traits<_Iter, __has_iterator_typedefs<_Iter>::value> {
-
+struct _LIBCPP_TEMPLATE_VIS iterator_traits : __iterator_traits<_Iter, __has_iterator_typedefs<_Iter>::value> {
   using __primary_template = iterator_traits;
 };
 #endif // _LIBCPP_STD_VER >= 20
 
-template<class _Tp>
+template <class _Tp>
 #if _LIBCPP_STD_VER >= 20
-requires is_object_v<_Tp>
+  requires is_object_v<_Tp>
 #endif
-struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*>
-{
-    typedef ptrdiff_t difference_type;
-    typedef __remove_cv_t<_Tp> value_type;
-    typedef _Tp* pointer;
-    typedef _Tp& reference;
-    typedef random_access_iterator_tag iterator_category;
+struct _LIBCPP_TEMPLATE_VIS iterator_traits<_Tp*> {
+  typedef ptrdiff_t difference_type;
+  typedef __remove_cv_t<_Tp> value_type;
+  typedef _Tp* pointer;
+  typedef _Tp& reference;
+  typedef random_access_iterator_tag iterator_category;
 #if _LIBCPP_STD_VER >= 20
-    typedef contiguous_iterator_tag    iterator_concept;
+  typedef contiguous_iterator_tag iterator_concept;
 #endif
 };
 
 template <class _Tp, class _Up, bool = __has_iterator_category<iterator_traits<_Tp> >::value>
-struct __has_iterator_category_convertible_to
-    : is_convertible<typename iterator_traits<_Tp>::iterator_category, _Up>
-{};
+struct __has_iterator_category_convertible_to : is_convertible<typename iterator_traits<_Tp>::iterator_category, _Up> {
+};
 
 template <class _Tp, class _Up>
 struct __has_iterator_category_convertible_to<_Tp, _Up, false> : false_type {};
 
 template <class _Tp, class _Up, bool = __has_iterator_concept<_Tp>::value>
-struct __has_iterator_concept_convertible_to
-    : is_convertible<typename _Tp::iterator_concept, _Up>
-{};
+struct __has_iterator_concept_convertible_to : is_convertible<typename _Tp::iterator_concept, _Up> {};
 
 template <class _Tp, class _Up>
 struct __has_iterator_concept_convertible_to<_Tp, _Up, false> : false_type {};
@@ -473,10 +448,9 @@ using __has_random_access_iterator_category = __has_iterator_category_convertibl
 //
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp>
-struct __libcpp_is_contiguous_iterator : _Or<
-    __has_iterator_category_convertible_to<_Tp, contiguous_iterator_tag>,
-    __has_iterator_concept_convertible_to<_Tp, contiguous_iterator_tag>
-> {};
+struct __libcpp_is_contiguous_iterator
+    : _Or< __has_iterator_category_convertible_to<_Tp, contiguous_iterator_tag>,
+           __has_iterator_concept_convertible_to<_Tp, contiguous_iterator_tag> > {};
 #else
 template <class _Tp>
 struct __libcpp_is_contiguous_iterator : false_type {};
@@ -486,41 +460,40 @@ struct __libcpp_is_contiguous_iterator : false_type {};
 template <class _Up>
 struct __libcpp_is_contiguous_iterator<_Up*> : true_type {};
 
-
 template <class _Iter>
 class __wrap_iter;
 
 template <class _Tp>
-using __has_exactly_input_iterator_category
-    = integral_constant<bool,
-         __has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value &&
-        !__has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value>;
+using __has_exactly_input_iterator_category =
+    integral_constant<bool,
+                      __has_iterator_category_convertible_to<_Tp, input_iterator_tag>::value &&
+                          !__has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value>;
 
 template <class _Tp>
-using __has_exactly_forward_iterator_category
-    = integral_constant<bool,
-         __has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value &&
-        !__has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag>::value>;
+using __has_exactly_forward_iterator_category =
+    integral_constant<bool,
+                      __has_iterator_category_convertible_to<_Tp, forward_iterator_tag>::value &&
+                          !__has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag>::value>;
 
 template <class _Tp>
-using __has_exactly_bidirectional_iterator_category
-    = integral_constant<bool,
-         __has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag>::value &&
-        !__has_iterator_category_convertible_to<_Tp, random_access_iterator_tag>::value>;
+using __has_exactly_bidirectional_iterator_category =
+    integral_constant<bool,
+                      __has_iterator_category_convertible_to<_Tp, bidirectional_iterator_tag>::value &&
+                          !__has_iterator_category_convertible_to<_Tp, random_access_iterator_tag>::value>;
 
-template<class _InputIterator>
+template <class _InputIterator>
 using __iter_value_type = typename iterator_traits<_InputIterator>::value_type;
 
-template<class _InputIterator>
+template <class _InputIterator>
 using __iter_key_type = __remove_const_t<typename iterator_traits<_InputIterator>::value_type::first_type>;
 
-template<class _InputIterator>
+template <class _InputIterator>
 using __iter_mapped_type = typename iterator_traits<_InputIterator>::value_type::second_type;
 
-template<class _InputIterator>
-using __iter_to_alloc_type = pair<
-    typename add_const<typename iterator_traits<_InputIterator>::value_type::first_type>::type,
-    typename iterator_traits<_InputIterator>::value_type::second_type>;
+template <class _InputIterator>
+using __iter_to_alloc_type =
+    pair<const typename iterator_traits<_InputIterator>::value_type::first_type,
+         typename iterator_traits<_InputIterator>::value_type::second_type>;
 
 template <class _Iter>
 using __iterator_category_type = typename iterator_traits<_Iter>::iterator_category;
@@ -534,6 +507,22 @@ using __iter_diff_t = typename iterator_traits<_Iter>::difference_type;
 template <class _Iter>
 using __iter_reference = typename iterator_traits<_Iter>::reference;
 
+#if _LIBCPP_STD_VER >= 20
+
+// [readable.traits]
+
+// Let `RI` be `remove_cvref_t<I>`. The type `iter_value_t<I>` denotes
+// `indirectly_readable_traits<RI>::value_type` if `iterator_traits<RI>` names a specialization
+// generated from the primary template, and `iterator_traits<RI>::value_type` otherwise.
+// This has to be in this file and not readable_traits.h to break the include cycle between the two.
+template <class _Ip>
+using iter_value_t =
+    typename conditional_t<__is_primary_template<iterator_traits<remove_cvref_t<_Ip> > >::value,
+                           indirectly_readable_traits<remove_cvref_t<_Ip> >,
+                           iterator_traits<remove_cvref_t<_Ip> > >::value_type;
+
+#endif // _LIBCPP_STD_VER >= 20
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_ITERATOR_TRAITS_H
diff --git a/third_party/libcxx/__iterator/iterator_with_data.h b/third_party/libcxx/__iterator/iterator_with_data.h
index 06c2fa699..afdc0a4e1 100644
--- a/third_party/libcxx/__iterator/iterator_with_data.h
+++ b/third_party/libcxx/__iterator/iterator_with_data.h
@@ -24,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -97,4 +100,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 20
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_ITERATOR_WITH_DATA_H
diff --git a/third_party/libcxx/__iterator/mergeable.h b/third_party/libcxx/__iterator/mergeable.h
index 494fda956..7976d7510 100644
--- a/third_party/libcxx/__iterator/mergeable.h
+++ b/third_party/libcxx/__iterator/mergeable.h
@@ -24,14 +24,15 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-template <class _Input1, class _Input2, class _Output,
-          class _Comp = ranges::less, class _Proj1 = identity, class _Proj2 = identity>
+template <class _Input1,
+          class _Input2,
+          class _Output,
+          class _Comp  = ranges::less,
+          class _Proj1 = identity,
+          class _Proj2 = identity>
 concept mergeable =
-    input_iterator<_Input1> &&
-    input_iterator<_Input2> &&
-    weakly_incrementable<_Output> &&
-    indirectly_copyable<_Input1, _Output> &&
-    indirectly_copyable<_Input2, _Output> &&
+    input_iterator<_Input1> && input_iterator<_Input2> && weakly_incrementable<_Output> &&
+    indirectly_copyable<_Input1, _Output> && indirectly_copyable<_Input2, _Output> &&
     indirect_strict_weak_order<_Comp, projected<_Input1, _Proj1>, projected<_Input2, _Proj2>>;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__iterator/move_iterator.h b/third_party/libcxx/__iterator/move_iterator.h
index 6028a0e84..a1c53e9bd 100644
--- a/third_party/libcxx/__iterator/move_iterator.h
+++ b/third_party/libcxx/__iterator/move_iterator.h
@@ -39,25 +39,27 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
-template<class _Iter, class = void>
+template <class _Iter, class = void>
 struct __move_iter_category_base {};
 
-template<class _Iter>
+template <class _Iter>
   requires requires { typename iterator_traits<_Iter>::iterator_category; }
 struct __move_iter_category_base<_Iter> {
-    using iterator_category = _If<
-        derived_from<typename iterator_traits<_Iter>::iterator_category, random_access_iterator_tag>,
-        random_access_iterator_tag,
-        typename iterator_traits<_Iter>::iterator_category
-    >;
+  using iterator_category =
+      _If< derived_from<typename iterator_traits<_Iter>::iterator_category, random_access_iterator_tag>,
+           random_access_iterator_tag,
+           typename iterator_traits<_Iter>::iterator_category >;
 };
 
-template<class _Iter, class _Sent>
+template <class _Iter, class _Sent>
 concept __move_iter_comparable = requires {
-    { std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>;
+  { std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>;
 };
 #endif // _LIBCPP_STD_VER >= 20
 
@@ -67,284 +69,279 @@ class _LIBCPP_TEMPLATE_VIS move_iterator
     : public __move_iter_category_base<_Iter>
 #endif
 {
-    #if _LIBCPP_STD_VER >= 20
+#if _LIBCPP_STD_VER >= 20
+
 private:
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr auto __get_iter_concept() {
-        if constexpr (random_access_iterator<_Iter>) {
-            return random_access_iterator_tag{};
-        } else if constexpr (bidirectional_iterator<_Iter>) {
-            return bidirectional_iterator_tag{};
-        } else if constexpr (forward_iterator<_Iter>) {
-            return forward_iterator_tag{};
-        } else {
-            return input_iterator_tag{};
-        }
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __get_iter_concept() {
+    if constexpr (random_access_iterator<_Iter>) {
+      return random_access_iterator_tag{};
+    } else if constexpr (bidirectional_iterator<_Iter>) {
+      return bidirectional_iterator_tag{};
+    } else if constexpr (forward_iterator<_Iter>) {
+      return forward_iterator_tag{};
+    } else {
+      return input_iterator_tag{};
     }
+  }
 #endif // _LIBCPP_STD_VER >= 20
+
 public:
 #if _LIBCPP_STD_VER >= 20
-    using iterator_type = _Iter;
-    using iterator_concept = decltype(__get_iter_concept());
-    // iterator_category is inherited and not always present
-    using value_type = iter_value_t<_Iter>;
-    using difference_type = iter_difference_t<_Iter>;
-    using pointer = _Iter;
-    using reference = iter_rvalue_reference_t<_Iter>;
+  using iterator_type    = _Iter;
+  using iterator_concept = decltype(__get_iter_concept());
+  // iterator_category is inherited and not always present
+  using value_type      = iter_value_t<_Iter>;
+  using difference_type = iter_difference_t<_Iter>;
+  using pointer         = _Iter;
+  using reference       = iter_rvalue_reference_t<_Iter>;
 #else
-    typedef _Iter iterator_type;
-    typedef _If<
-        __has_random_access_iterator_category<_Iter>::value,
-        random_access_iterator_tag,
-        typename iterator_traits<_Iter>::iterator_category
-    > iterator_category;
-    typedef typename iterator_traits<iterator_type>::value_type value_type;
-    typedef typename iterator_traits<iterator_type>::difference_type difference_type;
-    typedef iterator_type pointer;
+  typedef _Iter iterator_type;
+  typedef _If< __has_random_access_iterator_category<_Iter>::value,
+               random_access_iterator_tag,
+               typename iterator_traits<_Iter>::iterator_category >
+      iterator_category;
+  typedef typename iterator_traits<iterator_type>::value_type value_type;
+  typedef typename iterator_traits<iterator_type>::difference_type difference_type;
+  typedef iterator_type pointer;
 
-    typedef typename iterator_traits<iterator_type>::reference __reference;
-    typedef typename conditional<
-            is_reference<__reference>::value,
-            __libcpp_remove_reference_t<__reference>&&,
-            __reference
-        >::type reference;
+  typedef typename iterator_traits<iterator_type>::reference __reference;
+  typedef __conditional_t<is_reference<__reference>::value, __libcpp_remove_reference_t<__reference>&&, __reference>
+      reference;
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator& operator++() { ++__current_; return *this; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator++() {
+    ++__current_;
+    return *this;
+  }
 
-    _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    pointer operator->() const { return __current_; }
+  _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pointer operator->() const {
+    return __current_;
+  }
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    move_iterator() requires is_constructible_v<_Iter> : __current_() {}
+  _LIBCPP_HIDE_FROM_ABI constexpr move_iterator()
+    requires is_constructible_v<_Iter>
+      : __current_() {}
 
-    template <class _Up>
-        requires (!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
+  template <class _Up>
+    requires(!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter>
+  _LIBCPP_HIDE_FROM_ABI constexpr move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
 
-    template <class _Up>
-        requires (!_IsSame<_Up, _Iter>::value) &&
-                 convertible_to<const _Up&, _Iter> &&
-                 assignable_from<_Iter&, const _Up&>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    move_iterator& operator=(const move_iterator<_Up>& __u) {
-        __current_ = __u.base();
-        return *this;
-    }
+  template <class _Up>
+    requires(!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter> && assignable_from<_Iter&, const _Up&>
+  _LIBCPP_HIDE_FROM_ABI constexpr move_iterator& operator=(const move_iterator<_Up>& __u) {
+    __current_ = __u.base();
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Iter& base() const & noexcept { return __current_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() && { return std::move(__current_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Iter& base() const& noexcept { return __current_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() && { return std::move(__current_); }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    reference operator*() const { return ranges::iter_move(__current_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    reference operator[](difference_type __n) const { return ranges::iter_move(__current_ + __n); }
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator*() const { return ranges::iter_move(__current_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](difference_type __n) const {
+    return ranges::iter_move(__current_ + __n);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    auto operator++(int)
-        requires forward_iterator<_Iter>
-    {
-        move_iterator __tmp(*this); ++__current_; return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator++(int)
+    requires forward_iterator<_Iter>
+  {
+    move_iterator __tmp(*this);
+    ++__current_;
+    return __tmp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    void operator++(int) { ++__current_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++__current_; }
 #else
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator() : __current_() {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator() : __current_() {}
 
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value && is_convertible<const _Up&, _Iter>::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
+  template <class _Up, __enable_if_t< !is_same<_Up, _Iter>::value && is_convertible<const _Up&, _Iter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator(const move_iterator<_Up>& __u)
+      : __current_(__u.base()) {}
 
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value &&
-        is_convertible<const _Up&, _Iter>::value &&
-        is_assignable<_Iter&, const _Up&>::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator& operator=(const move_iterator<_Up>& __u) {
-        __current_ = __u.base();
-        return *this;
-    }
+  template <class _Up,
+            __enable_if_t< !is_same<_Up, _Iter>::value && is_convertible<const _Up&, _Iter>::value &&
+                               is_assignable<_Iter&, const _Up&>::value,
+                           int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator=(const move_iterator<_Up>& __u) {
+    __current_ = __u.base();
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    _Iter base() const { return __current_; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _Iter base() const { return __current_; }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference operator*() const { return static_cast<reference>(*__current_); }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference operator[](difference_type __n) const { return static_cast<reference>(__current_[__n]); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator*() const {
+    return static_cast<reference>(*__current_);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](difference_type __n) const {
+    return static_cast<reference>(__current_[__n]);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator operator++(int) { move_iterator __tmp(*this); ++__current_; return __tmp; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator++(int) {
+    move_iterator __tmp(*this);
+    ++__current_;
+    return __tmp;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator& operator--() { --__current_; return *this; }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator operator--(int) { move_iterator __tmp(*this); --__current_; return __tmp; }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator operator+(difference_type __n) const { return move_iterator(__current_ + __n); }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator& operator+=(difference_type __n) { __current_ += __n; return *this; }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator operator-(difference_type __n) const { return move_iterator(__current_ - __n); }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    move_iterator& operator-=(difference_type __n) { __current_ -= __n; return *this; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator--() {
+    --__current_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator--(int) {
+    move_iterator __tmp(*this);
+    --__current_;
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator+(difference_type __n) const {
+    return move_iterator(__current_ + __n);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator+=(difference_type __n) {
+    __current_ += __n;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator-(difference_type __n) const {
+    return move_iterator(__current_ - __n);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator-=(difference_type __n) {
+    __current_ -= __n;
+    return *this;
+  }
 
 #if _LIBCPP_STD_VER >= 20
-    template<sentinel_for<_Iter> _Sent>
-    friend _LIBCPP_HIDE_FROM_ABI constexpr
-    bool operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
-        requires __move_iter_comparable<_Iter, _Sent>
-    {
-        return __x.base() == __y.base();
-    }
+  template <sentinel_for<_Iter> _Sent>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
+    requires __move_iter_comparable<_Iter, _Sent>
+  {
+    return __x.base() == __y.base();
+  }
 
-    template<sized_sentinel_for<_Iter> _Sent>
-    friend _LIBCPP_HIDE_FROM_ABI constexpr
-    iter_difference_t<_Iter> operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y)
-    {
-        return __x.base() - __y.base();
-    }
+  template <sized_sentinel_for<_Iter> _Sent>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Iter>
+  operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y) {
+    return __x.base() - __y.base();
+  }
 
-    template<sized_sentinel_for<_Iter> _Sent>
-    friend _LIBCPP_HIDE_FROM_ABI constexpr
-    iter_difference_t<_Iter> operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y)
-    {
-        return __x.base() - __y.base();
-    }
+  template <sized_sentinel_for<_Iter> _Sent>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Iter>
+  operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y) {
+    return __x.base() - __y.base();
+  }
 
-    friend _LIBCPP_HIDE_FROM_ABI constexpr
-    iter_rvalue_reference_t<_Iter> iter_move(const move_iterator& __i)
-        noexcept(noexcept(ranges::iter_move(__i.__current_)))
-    {
-        return ranges::iter_move(__i.__current_);
-    }
+  friend _LIBCPP_HIDE_FROM_ABI constexpr iter_rvalue_reference_t<_Iter>
+  iter_move(const move_iterator& __i) noexcept(noexcept(ranges::iter_move(__i.__current_))) {
+    return ranges::iter_move(__i.__current_);
+  }
 
-    template<indirectly_swappable<_Iter> _It2>
-    friend _LIBCPP_HIDE_FROM_ABI constexpr
-    void iter_swap(const move_iterator& __x, const move_iterator<_It2>& __y)
-        noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
-    {
-        return ranges::iter_swap(__x.__current_, __y.__current_);
-    }
+  template <indirectly_swappable<_Iter> _It2>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr void
+  iter_swap(const move_iterator& __x,
+            const move_iterator<_It2>& __y) noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_))) {
+    return ranges::iter_swap(__x.__current_, __y.__current_);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
 private:
-    template<class _It2> friend class move_iterator;
+  template <class _It2>
+  friend class move_iterator;
 
-    _Iter __current_;
+  _Iter __current_;
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_iterator);
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() == __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
+operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() == __y.base();
 }
 
 #if _LIBCPP_STD_VER <= 17
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() != __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
+operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() != __y.base();
 }
 #endif // _LIBCPP_STD_VER <= 17
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() < __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
+operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() < __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() > __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
+operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() > __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() <= __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
+operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() <= __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() >= __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
+operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() >= __y.base();
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI constexpr
-auto operator<=>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-    -> compare_three_way_result_t<_Iter1, _Iter2>
-{
-    return __x.base() <=> __y.base();
+inline _LIBCPP_HIDE_FROM_ABI constexpr auto
+operator<=>(const move_iterator<_Iter1>& __x,
+            const move_iterator<_Iter2>& __y) -> compare_three_way_result_t<_Iter1, _Iter2> {
+  return __x.base() <=> __y.base();
 }
 #endif // _LIBCPP_STD_VER >= 20
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-    -> decltype(__x.base() - __y.base())
-{
-    return __x.base() - __y.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto
+operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) -> decltype(__x.base() - __y.base()) {
+  return __x.base() - __y.base();
 }
 #else
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_HIDE_FROM_ABI
-typename move_iterator<_Iter1>::difference_type
-operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
-{
-    return __x.base() - __y.base();
+inline _LIBCPP_HIDE_FROM_ABI typename move_iterator<_Iter1>::difference_type
+operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
+  return __x.base() - __y.base();
 }
 #endif // !_LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Iter>
-inline _LIBCPP_HIDE_FROM_ABI constexpr
-move_iterator<_Iter> operator+(iter_difference_t<_Iter> __n, const move_iterator<_Iter>& __x)
-    requires requires { { __x.base() + __n } -> same_as<_Iter>; }
+inline _LIBCPP_HIDE_FROM_ABI constexpr move_iterator<_Iter>
+operator+(iter_difference_t<_Iter> __n, const move_iterator<_Iter>& __x)
+  requires requires {
+    { __x.base() + __n } -> same_as<_Iter>;
+  }
 {
-    return __x + __n;
+  return __x + __n;
 }
 #else
 template <class _Iter>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-move_iterator<_Iter>
-operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x)
-{
-    return move_iterator<_Iter>(__x.base() + __n);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator<_Iter>
+operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x) {
+  return move_iterator<_Iter>(__x.base() + __n);
 }
 #endif // _LIBCPP_STD_VER >= 20
 
+#if _LIBCPP_STD_VER >= 20
+template <class _Iter1, class _Iter2>
+  requires(!sized_sentinel_for<_Iter1, _Iter2>)
+inline constexpr bool disable_sized_sentinel_for<move_iterator<_Iter1>, move_iterator<_Iter2>> = true;
+#endif // _LIBCPP_STD_VER >= 20
+
 template <class _Iter>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-move_iterator<_Iter>
-make_move_iterator(_Iter __i)
-{
-    return move_iterator<_Iter>(std::move(__i));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator<_Iter> make_move_iterator(_Iter __i) {
+  return move_iterator<_Iter>(std::move(__i));
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_MOVE_ITERATOR_H
diff --git a/third_party/libcxx/__iterator/move_sentinel.h b/third_party/libcxx/__iterator/move_sentinel.h
index 2fd0af889..4a2a09ef0 100644
--- a/third_party/libcxx/__iterator/move_sentinel.h
+++ b/third_party/libcxx/__iterator/move_sentinel.h
@@ -19,35 +19,35 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 template <semiregular _Sent>
-class _LIBCPP_TEMPLATE_VIS move_sentinel
-{
+class _LIBCPP_TEMPLATE_VIS move_sentinel {
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  move_sentinel() = default;
+  _LIBCPP_HIDE_FROM_ABI move_sentinel() = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  explicit move_sentinel(_Sent __s) : __last_(std::move(__s)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit move_sentinel(_Sent __s) : __last_(std::move(__s)) {}
 
   template <class _S2>
     requires convertible_to<const _S2&, _Sent>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  move_sentinel(const move_sentinel<_S2>& __s) : __last_(__s.base()) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr move_sentinel(const move_sentinel<_S2>& __s) : __last_(__s.base()) {}
 
   template <class _S2>
     requires assignable_from<_Sent&, const _S2&>
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  move_sentinel& operator=(const move_sentinel<_S2>& __s)
-    { __last_ = __s.base(); return *this; }
+  _LIBCPP_HIDE_FROM_ABI constexpr move_sentinel& operator=(const move_sentinel<_S2>& __s) {
+    __last_ = __s.base();
+    return *this;
+  }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _Sent base() const { return __last_; }
 
 private:
-    _Sent __last_ = _Sent();
+  _Sent __last_ = _Sent();
 };
 
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_sentinel);
@@ -56,4 +56,6 @@ _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_sentinel);
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___ITERATOR_MOVE_SENTINEL_H
diff --git a/third_party/libcxx/__iterator/next.h b/third_party/libcxx/__iterator/next.h
index 6cb63ecc8..21d3688ad 100644
--- a/third_party/libcxx/__iterator/next.h
+++ b/third_party/libcxx/__iterator/next.h
@@ -24,14 +24,15 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    typename enable_if<__has_input_iterator_category<_InputIter>::value, _InputIter>::type
-    next(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
-  _LIBCPP_ASSERT(__n >= 0 || __has_bidirectional_iterator_category<_InputIter>::value,
-                 "Attempt to next(it, n) with negative n on a non-bidirectional iterator");
+template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _InputIter
+next(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
+  // Calling `advance` with a negative value on a non-bidirectional iterator is a no-op in the current implementation.
+  // Note that this check duplicates the similar check in `std::advance`.
+  _LIBCPP_ASSERT_PEDANTIC(__n >= 0 || __has_bidirectional_iterator_category<_InputIter>::value,
+                          "Attempt to next(it, n) with negative n on a non-bidirectional iterator");
 
-  _VSTD::advance(__x, __n);
+  std::advance(__x, __n);
   return __x;
 }
 
@@ -44,15 +45,13 @@ namespace __next {
 
 struct __fn {
   template <input_or_output_iterator _Ip>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Ip operator()(_Ip __x) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Ip operator()(_Ip __x) const {
     ++__x;
     return __x;
   }
 
   template <input_or_output_iterator _Ip>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n) const {
     ranges::advance(__x, __n);
     return __x;
   }
@@ -73,7 +72,7 @@ struct __fn {
 } // namespace __next
 
 inline namespace __cpo {
-  inline constexpr auto next = __next::__fn{};
+inline constexpr auto next = __next::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__iterator/ostream_iterator.h b/third_party/libcxx/__iterator/ostream_iterator.h
index 025712bb1..05697e62d 100644
--- a/third_party/libcxx/__iterator/ostream_iterator.h
+++ b/third_party/libcxx/__iterator/ostream_iterator.h
@@ -11,11 +11,12 @@
 #define _LIBCPP___ITERATOR_OSTREAM_ITERATOR_H
 
 #include <__config>
+#include <__fwd/ostream.h>
+#include <__fwd/string.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <cstddef>
-#include <iosfwd> // for forward declarations of char_traits and basic_ostream
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -30,40 +31,43 @@ class _LIBCPP_TEMPLATE_VIS ostream_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 #endif
 {
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
 public:
-    typedef output_iterator_tag             iterator_category;
-    typedef void                            value_type;
+  typedef output_iterator_tag iterator_category;
+  typedef void value_type;
 #if _LIBCPP_STD_VER >= 20
-    typedef ptrdiff_t                       difference_type;
+  typedef ptrdiff_t difference_type;
 #else
-    typedef void                            difference_type;
+  typedef void difference_type;
 #endif
-    typedef void                            pointer;
-    typedef void                            reference;
-    typedef _CharT                          char_type;
-    typedef _Traits                         traits_type;
-    typedef basic_ostream<_CharT, _Traits>  ostream_type;
+  typedef void pointer;
+  typedef void reference;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef basic_ostream<_CharT, _Traits> ostream_type;
 
 private:
-    ostream_type* __out_stream_;
-    const char_type* __delim_;
-public:
-    _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s) _NOEXCEPT
-        : __out_stream_(_VSTD::addressof(__s)), __delim_(nullptr) {}
-    _LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT
-        : __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {}
-    _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value)
-        {
-            *__out_stream_ << __value;
-            if (__delim_)
-                *__out_stream_ << __delim_;
-            return *this;
-        }
+  ostream_type* __out_stream_;
+  const char_type* __delim_;
 
-    _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator*()     {return *this;}
-    _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++()    {return *this;}
-    _LIBCPP_INLINE_VISIBILITY ostream_iterator& operator++(int) {return *this;}
+public:
+  _LIBCPP_HIDE_FROM_ABI ostream_iterator(ostream_type& __s) _NOEXCEPT
+      : __out_stream_(std::addressof(__s)),
+        __delim_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT
+      : __out_stream_(std::addressof(__s)),
+        __delim_(__delimiter) {}
+  _LIBCPP_HIDE_FROM_ABI ostream_iterator& operator=(const _Tp& __value) {
+    *__out_stream_ << __value;
+    if (__delim_)
+      *__out_stream_ << __delim_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI ostream_iterator& operator*() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI ostream_iterator& operator++() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI ostream_iterator& operator++(int) { return *this; }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__iterator/ostreambuf_iterator.h b/third_party/libcxx/__iterator/ostreambuf_iterator.h
index 898ef90e7..dda0094dc 100644
--- a/third_party/libcxx/__iterator/ostreambuf_iterator.h
+++ b/third_party/libcxx/__iterator/ostreambuf_iterator.h
@@ -29,47 +29,42 @@ class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator
     : public iterator<output_iterator_tag, void, void, void, void>
 #endif
 {
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
 public:
-    typedef output_iterator_tag                 iterator_category;
-    typedef void                                value_type;
+  typedef output_iterator_tag iterator_category;
+  typedef void value_type;
 #if _LIBCPP_STD_VER >= 20
-    typedef ptrdiff_t                           difference_type;
+  typedef ptrdiff_t difference_type;
 #else
-    typedef void                                difference_type;
+  typedef void difference_type;
 #endif
-    typedef void                                pointer;
-    typedef void                                reference;
-    typedef _CharT                              char_type;
-    typedef _Traits                             traits_type;
-    typedef basic_streambuf<_CharT, _Traits>    streambuf_type;
-    typedef basic_ostream<_CharT, _Traits>      ostream_type;
+  typedef void pointer;
+  typedef void reference;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+  typedef basic_ostream<_CharT, _Traits> ostream_type;
 
 private:
-    streambuf_type* __sbuf_;
-public:
-    _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(ostream_type& __s) _NOEXCEPT
-        : __sbuf_(__s.rdbuf()) {}
-    _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT
-        : __sbuf_(__s) {}
-    _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator=(_CharT __c)
-        {
-            if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof()))
-                __sbuf_ = nullptr;
-            return *this;
-        }
-    _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator*()     {return *this;}
-    _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++()    {return *this;}
-    _LIBCPP_INLINE_VISIBILITY ostreambuf_iterator& operator++(int) {return *this;}
-    _LIBCPP_INLINE_VISIBILITY bool failed() const _NOEXCEPT {return __sbuf_ == nullptr;}
+  streambuf_type* __sbuf_;
 
-    template <class _Ch, class _Tr>
-    friend
-    _LIBCPP_HIDE_FROM_ABI
-    ostreambuf_iterator<_Ch, _Tr>
-    __pad_and_output(ostreambuf_iterator<_Ch, _Tr> __s,
-                     const _Ch* __ob, const _Ch* __op, const _Ch* __oe,
-                     ios_base& __iob, _Ch __fl);
+public:
+  _LIBCPP_HIDE_FROM_ABI ostreambuf_iterator(ostream_type& __s) _NOEXCEPT : __sbuf_(__s.rdbuf()) {}
+  _LIBCPP_HIDE_FROM_ABI ostreambuf_iterator(streambuf_type* __s) _NOEXCEPT : __sbuf_(__s) {}
+  _LIBCPP_HIDE_FROM_ABI ostreambuf_iterator& operator=(_CharT __c) {
+    if (__sbuf_ && traits_type::eq_int_type(__sbuf_->sputc(__c), traits_type::eof()))
+      __sbuf_ = nullptr;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI ostreambuf_iterator& operator*() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI ostreambuf_iterator& operator++() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI ostreambuf_iterator& operator++(int) { return *this; }
+  _LIBCPP_HIDE_FROM_ABI bool failed() const _NOEXCEPT { return __sbuf_ == nullptr; }
+
+  template <class _Ch, class _Tr>
+  friend _LIBCPP_HIDE_FROM_ABI ostreambuf_iterator<_Ch, _Tr> __pad_and_output(
+      ostreambuf_iterator<_Ch, _Tr> __s, const _Ch* __ob, const _Ch* __op, const _Ch* __oe, ios_base& __iob, _Ch __fl);
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__iterator/permutable.h b/third_party/libcxx/__iterator/permutable.h
index adf88f506..f65ba3bfb 100644
--- a/third_party/libcxx/__iterator/permutable.h
+++ b/third_party/libcxx/__iterator/permutable.h
@@ -24,8 +24,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Iterator>
 concept permutable =
-    forward_iterator<_Iterator> &&
-    indirectly_movable_storable<_Iterator, _Iterator> &&
+    forward_iterator<_Iterator> && indirectly_movable_storable<_Iterator, _Iterator> &&
     indirectly_swappable<_Iterator, _Iterator>;
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__iterator/prev.h b/third_party/libcxx/__iterator/prev.h
index d3f1071d5..2f0e6a088 100644
--- a/third_party/libcxx/__iterator/prev.h
+++ b/third_party/libcxx/__iterator/prev.h
@@ -24,13 +24,14 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    typename enable_if<__has_input_iterator_category<_InputIter>::value, _InputIter>::type
-    prev(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
-  _LIBCPP_ASSERT(__n <= 0 || __has_bidirectional_iterator_category<_InputIter>::value,
-                 "Attempt to prev(it, n) with a positive n on a non-bidirectional iterator");
-  _VSTD::advance(__x, -__n);
+template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _InputIter
+prev(_InputIter __x, typename iterator_traits<_InputIter>::difference_type __n = 1) {
+  // Calling `advance` with a negative value on a non-bidirectional iterator is a no-op in the current implementation.
+  // Note that this check duplicates the similar check in `std::advance`.
+  _LIBCPP_ASSERT_PEDANTIC(__n <= 0 || __has_bidirectional_iterator_category<_InputIter>::value,
+                          "Attempt to prev(it, n) with a positive n on a non-bidirectional iterator");
+  std::advance(__x, -__n);
   return __x;
 }
 
@@ -43,15 +44,13 @@ namespace __prev {
 
 struct __fn {
   template <bidirectional_iterator _Ip>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Ip operator()(_Ip __x) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Ip operator()(_Ip __x) const {
     --__x;
     return __x;
   }
 
   template <bidirectional_iterator _Ip>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n) const {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Ip operator()(_Ip __x, iter_difference_t<_Ip> __n) const {
     ranges::advance(__x, -__n);
     return __x;
   }
@@ -66,7 +65,7 @@ struct __fn {
 } // namespace __prev
 
 inline namespace __cpo {
-  inline constexpr auto prev = __prev::__fn{};
+inline constexpr auto prev = __prev::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__iterator/projected.h b/third_party/libcxx/__iterator/projected.h
index e74e56d6f..463d07b0d 100644
--- a/third_party/libcxx/__iterator/projected.h
+++ b/third_party/libcxx/__iterator/projected.h
@@ -12,7 +12,7 @@
 
 #include <__config>
 #include <__iterator/concepts.h>
-#include <__iterator/incrementable_traits.h>
+#include <__iterator/incrementable_traits.h> // iter_difference_t
 #include <__type_traits/remove_cvref.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -23,17 +23,29 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-template<indirectly_readable _It, indirectly_regular_unary_invocable<_It> _Proj>
-struct projected {
-  using value_type = remove_cvref_t<indirect_result_t<_Proj&, _It>>;
-  indirect_result_t<_Proj&, _It> operator*() const; // not defined
+template <class _It, class _Proj>
+struct __projected_impl {
+  struct __type {
+    using value_type = remove_cvref_t<indirect_result_t<_Proj&, _It>>;
+    indirect_result_t<_Proj&, _It> operator*() const; // not defined
+  };
 };
 
-template<weakly_incrementable _It, class _Proj>
-struct incrementable_traits<projected<_It, _Proj>> {
-  using difference_type = iter_difference_t<_It>;
+template <weakly_incrementable _It, class _Proj>
+struct __projected_impl<_It, _Proj> {
+  struct __type {
+    using value_type      = remove_cvref_t<indirect_result_t<_Proj&, _It>>;
+    using difference_type = iter_difference_t<_It>;
+    indirect_result_t<_Proj&, _It> operator*() const; // not defined
+  };
 };
 
+// Note that we implement std::projected in a way that satisfies P2538R1 even in standard
+// modes before C++26 to avoid breaking the ABI between standard modes (even though ABI
+// breaks with std::projected are expected to have essentially no impact).
+template <indirectly_readable _It, indirectly_regular_unary_invocable<_It> _Proj>
+using projected = typename __projected_impl<_It, _Proj>::__type;
+
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__iterator/ranges_iterator_traits.h b/third_party/libcxx/__iterator/ranges_iterator_traits.h
new file mode 100644
index 000000000..859e70820
--- /dev/null
+++ b/third_party/libcxx/__iterator/ranges_iterator_traits.h
@@ -0,0 +1,40 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___ITERATOR_RANGES_ITERATOR_TRAITS_H
+#define _LIBCPP___ITERATOR_RANGES_ITERATOR_TRAITS_H
+
+#include <__config>
+#include <__fwd/pair.h>
+#include <__ranges/concepts.h>
+#include <__type_traits/remove_const.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range>
+using __range_key_type = __remove_const_t<typename ranges::range_value_t<_Range>::first_type>;
+
+template <ranges::input_range _Range>
+using __range_mapped_type = typename ranges::range_value_t<_Range>::second_type;
+
+template <ranges::input_range _Range>
+using __range_to_alloc_type =
+    pair<const typename ranges::range_value_t<_Range>::first_type, typename ranges::range_value_t<_Range>::second_type>;
+
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___ITERATOR_RANGES_ITERATOR_TRAITS_H
diff --git a/third_party/libcxx/__iterator/readable_traits.h b/third_party/libcxx/__iterator/readable_traits.h
index fe4f0cd13..25e74567f 100644
--- a/third_party/libcxx/__iterator/readable_traits.h
+++ b/third_party/libcxx/__iterator/readable_traits.h
@@ -29,61 +29,50 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 // [readable.traits]
-template<class> struct __cond_value_type {};
+template <class>
+struct __cond_value_type {};
 
-template<class _Tp>
-requires is_object_v<_Tp>
-struct __cond_value_type<_Tp> { using value_type = remove_cv_t<_Tp>; };
+template <class _Tp>
+  requires is_object_v<_Tp>
+struct __cond_value_type<_Tp> {
+  using value_type = remove_cv_t<_Tp>;
+};
 
-template<class _Tp>
+template <class _Tp>
 concept __has_member_value_type = requires { typename _Tp::value_type; };
 
-template<class _Tp>
+template <class _Tp>
 concept __has_member_element_type = requires { typename _Tp::element_type; };
 
-template<class> struct indirectly_readable_traits {};
+template <class>
+struct indirectly_readable_traits {};
 
-template<class _Ip>
-requires is_array_v<_Ip>
+template <class _Ip>
+  requires is_array_v<_Ip>
 struct indirectly_readable_traits<_Ip> {
   using value_type = remove_cv_t<remove_extent_t<_Ip>>;
 };
 
-template<class _Ip>
+template <class _Ip>
 struct indirectly_readable_traits<const _Ip> : indirectly_readable_traits<_Ip> {};
 
-template<class _Tp>
+template <class _Tp>
 struct indirectly_readable_traits<_Tp*> : __cond_value_type<_Tp> {};
 
-template<__has_member_value_type _Tp>
-struct indirectly_readable_traits<_Tp>
-  : __cond_value_type<typename _Tp::value_type> {};
+template <__has_member_value_type _Tp>
+struct indirectly_readable_traits<_Tp> : __cond_value_type<typename _Tp::value_type> {};
 
-template<__has_member_element_type _Tp>
-struct indirectly_readable_traits<_Tp>
-  : __cond_value_type<typename _Tp::element_type> {};
+template <__has_member_element_type _Tp>
+struct indirectly_readable_traits<_Tp> : __cond_value_type<typename _Tp::element_type> {};
 
-template<__has_member_value_type _Tp>
+template <__has_member_value_type _Tp>
   requires __has_member_element_type<_Tp>
 struct indirectly_readable_traits<_Tp> {};
 
-template<__has_member_value_type _Tp>
+template <__has_member_value_type _Tp>
   requires __has_member_element_type<_Tp> &&
-           same_as<remove_cv_t<typename _Tp::element_type>,
-                   remove_cv_t<typename _Tp::value_type>>
-struct indirectly_readable_traits<_Tp>
-  : __cond_value_type<typename _Tp::value_type> {};
-
-template <class>
-struct iterator_traits;
-
-// Let `RI` be `remove_cvref_t<I>`. The type `iter_value_t<I>` denotes
-// `indirectly_readable_traits<RI>::value_type` if `iterator_traits<RI>` names a specialization
-// generated from the primary template, and `iterator_traits<RI>::value_type` otherwise.
-template <class _Ip>
-using iter_value_t = typename conditional_t<__is_primary_template<iterator_traits<remove_cvref_t<_Ip> > >::value,
-                                            indirectly_readable_traits<remove_cvref_t<_Ip> >,
-                                            iterator_traits<remove_cvref_t<_Ip> > >::value_type;
+           same_as<remove_cv_t<typename _Tp::element_type>, remove_cv_t<typename _Tp::value_type>>
+struct indirectly_readable_traits<_Tp> : __cond_value_type<typename _Tp::value_type> {};
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__iterator/reverse_access.h b/third_party/libcxx/__iterator/reverse_access.h
index b8c5a071c..54d7270b0 100644
--- a/third_party/libcxx/__iterator/reverse_access.h
+++ b/third_party/libcxx/__iterator/reverse_access.h
@@ -24,73 +24,53 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 14
 
 template <class _Tp, size_t _Np>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np])
-{
-    return reverse_iterator<_Tp*>(__array + _Np);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator<_Tp*> rbegin(_Tp (&__array)[_Np]) {
+  return reverse_iterator<_Tp*>(__array + _Np);
 }
 
 template <class _Tp, size_t _Np>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-reverse_iterator<_Tp*> rend(_Tp (&__array)[_Np])
-{
-    return reverse_iterator<_Tp*>(__array);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator<_Tp*> rend(_Tp (&__array)[_Np]) {
+  return reverse_iterator<_Tp*>(__array);
 }
 
 template <class _Ep>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-reverse_iterator<const _Ep*> rbegin(initializer_list<_Ep> __il)
-{
-    return reverse_iterator<const _Ep*>(__il.end());
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator<const _Ep*> rbegin(initializer_list<_Ep> __il) {
+  return reverse_iterator<const _Ep*>(__il.end());
 }
 
 template <class _Ep>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-reverse_iterator<const _Ep*> rend(initializer_list<_Ep> __il)
-{
-    return reverse_iterator<const _Ep*>(__il.begin());
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator<const _Ep*> rend(initializer_list<_Ep> __il) {
+  return reverse_iterator<const _Ep*>(__il.begin());
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto rbegin(_Cp& __c) -> decltype(__c.rbegin())
-{
-    return __c.rbegin();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto rbegin(_Cp& __c) -> decltype(__c.rbegin()) {
+  return __c.rbegin();
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto rbegin(const _Cp& __c) -> decltype(__c.rbegin())
-{
-    return __c.rbegin();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto rbegin(const _Cp& __c) -> decltype(__c.rbegin()) {
+  return __c.rbegin();
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto rend(_Cp& __c) -> decltype(__c.rend())
-{
-    return __c.rend();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto rend(_Cp& __c) -> decltype(__c.rend()) {
+  return __c.rend();
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto rend(const _Cp& __c) -> decltype(__c.rend())
-{
-    return __c.rend();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto rend(const _Cp& __c) -> decltype(__c.rend()) {
+  return __c.rend();
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto crbegin(const _Cp& __c) -> decltype(_VSTD::rbegin(__c))
-{
-    return _VSTD::rbegin(__c);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto crbegin(const _Cp& __c) -> decltype(std::rbegin(__c)) {
+  return std::rbegin(__c);
 }
 
 template <class _Cp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto crend(const _Cp& __c) -> decltype(_VSTD::rend(__c))
-{
-    return _VSTD::rend(__c);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto crend(const _Cp& __c) -> decltype(std::rend(__c)) {
+  return std::rend(__c);
 }
 
 #endif // _LIBCPP_STD_VER >= 14
diff --git a/third_party/libcxx/__iterator/reverse_iterator.h b/third_party/libcxx/__iterator/reverse_iterator.h
index beb10f7f4..50c0f21ea 100644
--- a/third_party/libcxx/__iterator/reverse_iterator.h
+++ b/third_party/libcxx/__iterator/reverse_iterator.h
@@ -34,7 +34,7 @@
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_convertible.h>
-#include <__type_traits/is_nothrow_copy_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_same.h>
 #include <__utility/declval.h>
@@ -57,440 +57,283 @@ class _LIBCPP_TEMPLATE_VIS reverse_iterator
                       typename iterator_traits<_Iter>::reference>
 #endif
 {
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
 private:
 #ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
-    _Iter __t_; // no longer used as of LWG #2360, not removed due to ABI break
+  _Iter __t_; // no longer used as of LWG #2360, not removed due to ABI break
 #endif
 
 #if _LIBCPP_STD_VER >= 20
-    static_assert(__has_bidirectional_iterator_category<_Iter>::value || bidirectional_iterator<_Iter>,
-        "reverse_iterator<It> requires It to be a bidirectional iterator.");
+  static_assert(__has_bidirectional_iterator_category<_Iter>::value || bidirectional_iterator<_Iter>,
+                "reverse_iterator<It> requires It to be a bidirectional iterator.");
 #endif // _LIBCPP_STD_VER >= 20
 
 protected:
-    _Iter current;
-public:
-    using iterator_type = _Iter;
+  _Iter current;
 
-    using iterator_category = _If<__has_random_access_iterator_category<_Iter>::value,
-                                  random_access_iterator_tag,
-                                  typename iterator_traits<_Iter>::iterator_category>;
-    using pointer = typename iterator_traits<_Iter>::pointer;
+public:
+  using iterator_type = _Iter;
+
+  using iterator_category =
+      _If<__has_random_access_iterator_category<_Iter>::value,
+          random_access_iterator_tag,
+          typename iterator_traits<_Iter>::iterator_category>;
+  using pointer = typename iterator_traits<_Iter>::pointer;
 #if _LIBCPP_STD_VER >= 20
-    using iterator_concept = _If<random_access_iterator<_Iter>, random_access_iterator_tag, bidirectional_iterator_tag>;
-    using value_type = iter_value_t<_Iter>;
-    using difference_type = iter_difference_t<_Iter>;
-    using reference = iter_reference_t<_Iter>;
+  using iterator_concept = _If<random_access_iterator<_Iter>, random_access_iterator_tag, bidirectional_iterator_tag>;
+  using value_type       = iter_value_t<_Iter>;
+  using difference_type  = iter_difference_t<_Iter>;
+  using reference        = iter_reference_t<_Iter>;
 #else
-    using value_type = typename iterator_traits<_Iter>::value_type;
-    using difference_type = typename iterator_traits<_Iter>::difference_type;
-    using reference = typename iterator_traits<_Iter>::reference;
+  using value_type      = typename iterator_traits<_Iter>::value_type;
+  using difference_type = typename iterator_traits<_Iter>::difference_type;
+  using reference       = typename iterator_traits<_Iter>::reference;
 #endif
 
 #ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator() : __t_(), current() {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator() : __t_(), current() {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    explicit reverse_iterator(_Iter __x) : __t_(__x), current(__x) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit reverse_iterator(_Iter __x) : __t_(__x), current(__x) {}
 
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
-    > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator(const reverse_iterator<_Up>& __u)
-        : __t_(__u.base()), current(__u.base())
-    { }
+  template <class _Up, __enable_if_t<!is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator(const reverse_iterator<_Up>& __u)
+      : __t_(__u.base()), current(__u.base()) {}
 
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value &&
-        is_convertible<_Up const&, _Iter>::value &&
-        is_assignable<_Iter&, _Up const&>::value
-    > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
-        __t_ = current = __u.base();
-        return *this;
-    }
+  template <class _Up,
+            __enable_if_t<!is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value &&
+                              is_assignable<_Iter&, _Up const&>::value,
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
+    __t_ = current = __u.base();
+    return *this;
+  }
 #else
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator() : current() {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator() : current() {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    explicit reverse_iterator(_Iter __x) : current(__x) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit reverse_iterator(_Iter __x) : current(__x) {}
 
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
-    > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator(const reverse_iterator<_Up>& __u)
-        : current(__u.base())
-    { }
+  template <class _Up, __enable_if_t<!is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator(const reverse_iterator<_Up>& __u)
+      : current(__u.base()) {}
 
-    template <class _Up, class = __enable_if_t<
-        !is_same<_Up, _Iter>::value &&
-        is_convertible<_Up const&, _Iter>::value &&
-        is_assignable<_Iter&, _Up const&>::value
-    > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
-        current = __u.base();
-        return *this;
-    }
+  template <class _Up,
+            __enable_if_t<!is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value &&
+                              is_assignable<_Iter&, _Up const&>::value,
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
+    current = __u.base();
+    return *this;
+  }
 #endif
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    _Iter base() const {return current;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference operator*() const {_Iter __tmp = current; return *--__tmp;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _Iter base() const { return current; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator*() const {
+    _Iter __tmp = current;
+    return *--__tmp;
+  }
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr pointer operator->() const
-      requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); }
-    {
-      if constexpr (is_pointer_v<_Iter>) {
-        return std::prev(current);
-      } else {
-        return std::prev(current).operator->();
-      }
+  _LIBCPP_HIDE_FROM_ABI constexpr pointer operator->() const
+    requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); }
+  {
+    if constexpr (is_pointer_v<_Iter>) {
+      return std::prev(current);
+    } else {
+      return std::prev(current).operator->();
     }
+  }
 #else
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    pointer operator->() const {
-      return std::addressof(operator*());
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 pointer operator->() const { return std::addressof(operator*()); }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator++() {--current; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator--() {++current; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator operator+(difference_type __n) const {return reverse_iterator(current - __n);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator operator-(difference_type __n) const {return reverse_iterator(current + __n);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference operator[](difference_type __n) const {return *(*this + __n);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator++() {
+    --current;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator operator++(int) {
+    reverse_iterator __tmp(*this);
+    --current;
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator--() {
+    ++current;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator operator--(int) {
+    reverse_iterator __tmp(*this);
+    ++current;
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator operator+(difference_type __n) const {
+    return reverse_iterator(current - __n);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator+=(difference_type __n) {
+    current -= __n;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator operator-(difference_type __n) const {
+    return reverse_iterator(current + __n);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator& operator-=(difference_type __n) {
+    current += __n;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](difference_type __n) const {
+    return *(*this + __n);
+  }
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI friend constexpr
-    iter_rvalue_reference_t<_Iter> iter_move(const reverse_iterator& __i)
-      noexcept(is_nothrow_copy_constructible_v<_Iter> &&
-          noexcept(ranges::iter_move(--std::declval<_Iter&>()))) {
-      auto __tmp = __i.base();
-      return ranges::iter_move(--__tmp);
-    }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr iter_rvalue_reference_t<_Iter> iter_move(const reverse_iterator& __i) noexcept(
+      is_nothrow_copy_constructible_v<_Iter> && noexcept(ranges::iter_move(--std::declval<_Iter&>()))) {
+    auto __tmp = __i.base();
+    return ranges::iter_move(--__tmp);
+  }
 
-    template <indirectly_swappable<_Iter> _Iter2>
-    _LIBCPP_HIDE_FROM_ABI friend constexpr
-    void iter_swap(const reverse_iterator& __x, const reverse_iterator<_Iter2>& __y)
-      noexcept(is_nothrow_copy_constructible_v<_Iter> &&
-          is_nothrow_copy_constructible_v<_Iter2> &&
-          noexcept(ranges::iter_swap(--std::declval<_Iter&>(), --std::declval<_Iter2&>()))) {
-      auto __xtmp = __x.base();
-      auto __ytmp = __y.base();
-      ranges::iter_swap(--__xtmp, --__ytmp);
-    }
+  template <indirectly_swappable<_Iter> _Iter2>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void
+  iter_swap(const reverse_iterator& __x, const reverse_iterator<_Iter2>& __y) noexcept(
+      is_nothrow_copy_constructible_v<_Iter> && is_nothrow_copy_constructible_v<_Iter2> &&
+      noexcept(ranges::iter_swap(--std::declval<_Iter&>(), --std::declval<_Iter2&>()))) {
+    auto __xtmp = __x.base();
+    auto __ytmp = __y.base();
+    ranges::iter_swap(--__xtmp, --__ytmp);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 };
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-      { __x.base() == __y.base() } -> convertible_to<bool>;
-    }
+  requires requires {
+    { __x.base() == __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() == __y.base();
+  return __x.base() == __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-        { __x.base() > __y.base() } -> convertible_to<bool>;
-      }
+  requires requires {
+    { __x.base() > __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() > __y.base();
+  return __x.base() > __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-      { __x.base() != __y.base() } -> convertible_to<bool>;
-    }
+  requires requires {
+    { __x.base() != __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() != __y.base();
+  return __x.base() != __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-        { __x.base() < __y.base() } -> convertible_to<bool>;
-      }
+  requires requires {
+    { __x.base() < __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() < __y.base();
+  return __x.base() < __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-        { __x.base() <= __y.base() } -> convertible_to<bool>;
-      }
+  requires requires {
+    { __x.base() <= __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() <= __y.base();
+  return __x.base() <= __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
 operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 #if _LIBCPP_STD_VER >= 20
-    requires requires {
-        { __x.base() >= __y.base() } -> convertible_to<bool>;
-      }
+  requires requires {
+    { __x.base() >= __y.base() } -> convertible_to<bool>;
+  }
 #endif // _LIBCPP_STD_VER >= 20
 {
-    return __x.base() >= __y.base();
+  return __x.base() >= __y.base();
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
-_LIBCPP_HIDE_FROM_ABI constexpr
-compare_three_way_result_t<_Iter1, _Iter2>
-operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
-{
-    return __y.base() <=> __x.base();
+_LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Iter1, _Iter2>
+operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) {
+  return __y.base() <=> __x.base();
 }
 #endif // _LIBCPP_STD_VER >= 20
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-auto
-operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
--> decltype(__y.base() - __x.base())
-{
-    return __y.base() - __x.base();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 auto
+operator-(const reverse_iterator<_Iter1>& __x,
+          const reverse_iterator<_Iter2>& __y) -> decltype(__y.base() - __x.base()) {
+  return __y.base() - __x.base();
 }
 #else
 template <class _Iter1, class _Iter2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename reverse_iterator<_Iter1>::difference_type
-operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
-{
-    return __y.base() - __x.base();
+inline _LIBCPP_HIDE_FROM_ABI typename reverse_iterator<_Iter1>::difference_type
+operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y) {
+  return __y.base() - __x.base();
 }
 #endif
 
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-reverse_iterator<_Iter>
-operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
-{
-    return reverse_iterator<_Iter>(__x.base() - __n);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator<_Iter>
+operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x) {
+  return reverse_iterator<_Iter>(__x.base() - __n);
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Iter1, class _Iter2>
-  requires (!sized_sentinel_for<_Iter1, _Iter2>)
+  requires(!sized_sentinel_for<_Iter1, _Iter2>)
 inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_Iter1>, reverse_iterator<_Iter2>> = true;
 #endif // _LIBCPP_STD_VER >= 20
 
 #if _LIBCPP_STD_VER >= 14
 template <class _Iter>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
-{
-    return reverse_iterator<_Iter>(__i);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator<_Iter> make_reverse_iterator(_Iter __i) {
+  return reverse_iterator<_Iter>(__i);
 }
 #endif
 
-#if _LIBCPP_STD_VER <= 17
-template <class _Iter>
-using __unconstrained_reverse_iterator = reverse_iterator<_Iter>;
-#else
+#if _LIBCPP_STD_VER >= 20
+template <ranges::bidirectional_range _Range>
+_LIBCPP_HIDE_FROM_ABI constexpr ranges::subrange<reverse_iterator<ranges::iterator_t<_Range>>,
+                                                 reverse_iterator<ranges::iterator_t<_Range>>>
+__reverse_range(_Range&& __range) {
+  auto __first = ranges::begin(__range);
+  return {std::make_reverse_iterator(ranges::next(__first, ranges::end(__range))), std::make_reverse_iterator(__first)};
+}
+#endif
 
-// __unconstrained_reverse_iterator allows us to use reverse iterators in the implementation of algorithms by working
-// around a language issue in C++20.
-// In C++20, when a reverse iterator wraps certain C++20-hostile iterators, calling comparison operators on it will
-// result in a compilation error. However, calling comparison operators on the pristine hostile iterator is not
-// an error. Thus, we cannot use reverse_iterators in the implementation of an algorithm that accepts a
-// C++20-hostile iterator. This class is an internal workaround -- it is a copy of reverse_iterator with
-// tweaks to make it support hostile iterators.
-//
-// A C++20-hostile iterator is one that defines a comparison operator where one of the arguments is an exact match
-// and the other requires an implicit conversion, for example:
-//   friend bool operator==(const BaseIter&, const DerivedIter&);
-//
-// C++20 rules for rewriting equality operators create another overload of this function with parameters reversed:
-//   friend bool operator==(const DerivedIter&, const BaseIter&);
-//
-// This creates an ambiguity in overload resolution.
-//
-// Clang treats this ambiguity differently in different contexts. When operator== is actually called in the function
-// body, the code is accepted with a warning. When a concept requires operator== to be a valid expression, however,
-// it evaluates to false. Thus, the implementation of reverse_iterator::operator== can actually call operator== on its
-// base iterators, but the constraints on reverse_iterator::operator== prevent it from being considered during overload
-// resolution. This class simply removes the problematic constraints from comparison functions.
-template <class _Iter>
-class __unconstrained_reverse_iterator {
-  _Iter __iter_;
-
-public:
-  static_assert(__has_bidirectional_iterator_category<_Iter>::value || bidirectional_iterator<_Iter>);
-
-  using iterator_type = _Iter;
-  using iterator_category =
-      _If<__has_random_access_iterator_category<_Iter>::value, random_access_iterator_tag, __iterator_category_type<_Iter>>;
-  using pointer = __iterator_pointer_type<_Iter>;
-  using value_type = iter_value_t<_Iter>;
-  using difference_type = iter_difference_t<_Iter>;
-  using reference = iter_reference_t<_Iter>;
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator() = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator(const __unconstrained_reverse_iterator&) = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit __unconstrained_reverse_iterator(_Iter __iter) : __iter_(__iter) {}
-
-  _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() const { return __iter_; }
-  _LIBCPP_HIDE_FROM_ABI constexpr reference operator*() const {
-    auto __tmp = __iter_;
-    return *--__tmp;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr pointer operator->() const {
-    if constexpr (is_pointer_v<_Iter>) {
-      return std::prev(__iter_);
-    } else {
-      return std::prev(__iter_).operator->();
-    }
-  }
-
-  _LIBCPP_HIDE_FROM_ABI friend constexpr
-  iter_rvalue_reference_t<_Iter> iter_move(const __unconstrained_reverse_iterator& __i)
-    noexcept(is_nothrow_copy_constructible_v<_Iter> &&
-        noexcept(ranges::iter_move(--std::declval<_Iter&>()))) {
-    auto __tmp = __i.base();
-    return ranges::iter_move(--__tmp);
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator& operator++() {
-    --__iter_;
-    return *this;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator operator++(int) {
-    auto __tmp = *this;
-    --__iter_;
-    return __tmp;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator& operator--() {
-    ++__iter_;
-    return *this;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator operator--(int) {
-    auto __tmp = *this;
-    ++__iter_;
-    return __tmp;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator& operator+=(difference_type __n) {
-    __iter_ -= __n;
-    return *this;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator& operator-=(difference_type __n) {
-    __iter_ += __n;
-    return *this;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator operator+(difference_type __n) const {
-    return __unconstrained_reverse_iterator(__iter_ - __n);
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator operator-(difference_type __n) const {
-    return __unconstrained_reverse_iterator(__iter_ + __n);
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr difference_type operator-(const __unconstrained_reverse_iterator& __other) const {
-    return __other.__iter_ - __iter_;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI constexpr auto operator[](difference_type __n) const { return *(*this + __n); }
-
-  // Deliberately unconstrained unlike the comparison functions in `reverse_iterator` -- see the class comment for the
-  // rationale.
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-  operator==(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
-    return __lhs.base() == __rhs.base();
-  }
-
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-  operator!=(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
-    return __lhs.base() != __rhs.base();
-  }
-
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-  operator<(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
-    return __lhs.base() > __rhs.base();
-  }
-
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-  operator>(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
-    return __lhs.base() < __rhs.base();
-  }
-
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-  operator<=(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
-    return __lhs.base() >= __rhs.base();
-  }
-
-  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-  operator>=(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
-    return __lhs.base() <= __rhs.base();
-  }
-};
-
-#endif // _LIBCPP_STD_VER <= 17
-
-template <template <class> class _RevIter1, template <class> class _RevIter2, class _Iter>
-struct __unwrap_reverse_iter_impl {
-  using _UnwrappedIter = decltype(__unwrap_iter_impl<_Iter>::__unwrap(std::declval<_Iter>()));
-  using _ReverseWrapper = _RevIter1<_RevIter2<_Iter> >;
+template <class _Iter, bool __b>
+struct __unwrap_iter_impl<reverse_iterator<reverse_iterator<_Iter> >, __b> {
+  using _UnwrappedIter  = decltype(__unwrap_iter_impl<_Iter>::__unwrap(std::declval<_Iter>()));
+  using _ReverseWrapper = reverse_iterator<reverse_iterator<_Iter> >;
 
   static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ReverseWrapper
   __rewrap(_ReverseWrapper __orig_iter, _UnwrappedIter __unwrapped_iter) {
     return _ReverseWrapper(
-        _RevIter2<_Iter>(__unwrap_iter_impl<_Iter>::__rewrap(__orig_iter.base().base(), __unwrapped_iter)));
+        reverse_iterator<_Iter>(__unwrap_iter_impl<_Iter>::__rewrap(__orig_iter.base().base(), __unwrapped_iter)));
   }
 
   static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _UnwrappedIter __unwrap(_ReverseWrapper __i) _NOEXCEPT {
@@ -498,36 +341,6 @@ struct __unwrap_reverse_iter_impl {
   }
 };
 
-#if _LIBCPP_STD_VER >= 20
-template <ranges::bidirectional_range _Range>
-_LIBCPP_HIDE_FROM_ABI constexpr ranges::
-    subrange<reverse_iterator<ranges::iterator_t<_Range>>, reverse_iterator<ranges::iterator_t<_Range>>>
-    __reverse_range(_Range&& __range) {
-  auto __first = ranges::begin(__range);
-  return {std::make_reverse_iterator(ranges::next(__first, ranges::end(__range))), std::make_reverse_iterator(__first)};
-}
-#endif
-
-template <class _Iter, bool __b>
-struct __unwrap_iter_impl<reverse_iterator<reverse_iterator<_Iter> >, __b>
-    : __unwrap_reverse_iter_impl<reverse_iterator, reverse_iterator, _Iter> {};
-
-#if _LIBCPP_STD_VER >= 20
-
-template <class _Iter, bool __b>
-struct __unwrap_iter_impl<reverse_iterator<__unconstrained_reverse_iterator<_Iter>>, __b>
-    : __unwrap_reverse_iter_impl<reverse_iterator, __unconstrained_reverse_iterator, _Iter> {};
-
-template <class _Iter, bool __b>
-struct __unwrap_iter_impl<__unconstrained_reverse_iterator<reverse_iterator<_Iter>>, __b>
-    : __unwrap_reverse_iter_impl<__unconstrained_reverse_iterator, reverse_iterator, _Iter> {};
-
-template <class _Iter, bool __b>
-struct __unwrap_iter_impl<__unconstrained_reverse_iterator<__unconstrained_reverse_iterator<_Iter>>, __b>
-    : __unwrap_reverse_iter_impl<__unconstrained_reverse_iterator, __unconstrained_reverse_iterator, _Iter> {};
-
-#endif // _LIBCPP_STD_VER >= 20
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_REVERSE_ITERATOR_H
diff --git a/third_party/libcxx/__iterator/size.h b/third_party/libcxx/__iterator/size.h
index 625eeb165..876e6963f 100644
--- a/third_party/libcxx/__iterator/size.h
+++ b/third_party/libcxx/__iterator/size.h
@@ -24,33 +24,33 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 17
 
 template <class _Cont>
-_LIBCPP_INLINE_VISIBILITY
-constexpr auto size(const _Cont& __c)
-_NOEXCEPT_(noexcept(__c.size()))
--> decltype        (__c.size())
-{ return            __c.size(); }
+_LIBCPP_HIDE_FROM_ABI constexpr auto size(const _Cont& __c) noexcept(noexcept(__c.size())) -> decltype(__c.size()) {
+  return __c.size();
+}
 
 template <class _Tp, size_t _Sz>
-_LIBCPP_INLINE_VISIBILITY
-constexpr size_t size(const _Tp (&)[_Sz]) noexcept { return _Sz; }
+_LIBCPP_HIDE_FROM_ABI constexpr size_t size(const _Tp (&)[_Sz]) noexcept {
+  return _Sz;
+}
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
 template <class _Cont>
-_LIBCPP_INLINE_VISIBILITY
-constexpr auto ssize(const _Cont& __c)
-_NOEXCEPT_(noexcept(static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size())))
-->                              common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>
-{ return            static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size()); }
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+ssize(const _Cont& __c) noexcept(noexcept(static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(
+    __c.size()))) -> common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>> {
+  return static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size());
+}
 
 // GCC complains about the implicit conversion from ptrdiff_t to size_t in
 // the array bound.
 _LIBCPP_DIAGNOSTIC_PUSH
 _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wsign-conversion")
 template <class _Tp, ptrdiff_t _Sz>
-_LIBCPP_INLINE_VISIBILITY
-constexpr ptrdiff_t ssize(const _Tp (&)[_Sz]) noexcept { return _Sz; }
+_LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t ssize(const _Tp (&)[_Sz]) noexcept {
+  return _Sz;
+}
 _LIBCPP_DIAGNOSTIC_POP
-#endif
+#  endif
 
 #endif // _LIBCPP_STD_VER >= 17
 
diff --git a/third_party/libcxx/__iterator/sortable.h b/third_party/libcxx/__iterator/sortable.h
index d4d77d6cf..1444860f2 100644
--- a/third_party/libcxx/__iterator/sortable.h
+++ b/third_party/libcxx/__iterator/sortable.h
@@ -26,9 +26,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 template <class _Iter, class _Comp = ranges::less, class _Proj = identity>
-concept sortable =
-  permutable<_Iter> &&
-  indirect_strict_weak_order<_Comp, projected<_Iter, _Proj>>;
+concept sortable = permutable<_Iter> && indirect_strict_weak_order<_Comp, projected<_Iter, _Proj>>;
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__iterator/unreachable_sentinel.h b/third_party/libcxx/__iterator/unreachable_sentinel.h
index 91fd0a57a..77e663da4 100644
--- a/third_party/libcxx/__iterator/unreachable_sentinel.h
+++ b/third_party/libcxx/__iterator/unreachable_sentinel.h
@@ -22,9 +22,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 struct unreachable_sentinel_t {
-  template<weakly_incrementable _Iter>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(unreachable_sentinel_t, const _Iter&) noexcept {
+  template <weakly_incrementable _Iter>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(unreachable_sentinel_t, const _Iter&) noexcept {
     return false;
   }
 };
diff --git a/third_party/libcxx/__iterator/wrap_iter.h b/third_party/libcxx/__iterator/wrap_iter.h
index a14059608..252d13b26 100644
--- a/third_party/libcxx/__iterator/wrap_iter.h
+++ b/third_party/libcxx/__iterator/wrap_iter.h
@@ -11,12 +11,12 @@
 #define _LIBCPP___ITERATOR_WRAP_ITER_H
 
 #include <__config>
-#include <__debug>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_convertible.h>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -25,242 +25,179 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Iter>
-class __wrap_iter
-{
+class __wrap_iter {
 public:
-    typedef _Iter                                                      iterator_type;
-    typedef typename iterator_traits<iterator_type>::value_type        value_type;
-    typedef typename iterator_traits<iterator_type>::difference_type   difference_type;
-    typedef typename iterator_traits<iterator_type>::pointer           pointer;
-    typedef typename iterator_traits<iterator_type>::reference         reference;
-    typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
+  typedef _Iter iterator_type;
+  typedef typename iterator_traits<iterator_type>::value_type value_type;
+  typedef typename iterator_traits<iterator_type>::difference_type difference_type;
+  typedef typename iterator_traits<iterator_type>::pointer pointer;
+  typedef typename iterator_traits<iterator_type>::reference reference;
+  typedef typename iterator_traits<iterator_type>::iterator_category iterator_category;
 #if _LIBCPP_STD_VER >= 20
-    typedef contiguous_iterator_tag                                    iterator_concept;
+  typedef contiguous_iterator_tag iterator_concept;
 #endif
 
 private:
-    iterator_type __i_;
+  iterator_type __i_;
+
 public:
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter() _NOEXCEPT
-                : __i_()
-    {
-        _VSTD::__debug_db_insert_i(this);
-    }
-    template <class _Up> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-        __wrap_iter(const __wrap_iter<_Up>& __u,
-            typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = nullptr) _NOEXCEPT
-            : __i_(__u.base())
-    {
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-      if (!__libcpp_is_constant_evaluated())
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__u));
-#endif
-    }
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    __wrap_iter(const __wrap_iter& __x)
-        : __i_(__x.base())
-    {
-      if (!__libcpp_is_constant_evaluated())
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__x));
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    __wrap_iter& operator=(const __wrap_iter& __x)
-    {
-        if (this != _VSTD::addressof(__x))
-        {
-            if (!__libcpp_is_constant_evaluated())
-                __get_db()->__iterator_copy(this, _VSTD::addressof(__x));
-            __i_ = __x.__i_;
-        }
-        return *this;
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    ~__wrap_iter()
-    {
-      if (!__libcpp_is_constant_evaluated())
-        __get_db()->__erase_i(this);
-    }
-#endif
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference operator*() const _NOEXCEPT
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to dereference a non-dereferenceable iterator");
-        return *__i_;
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pointer operator->() const _NOEXCEPT
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to dereference a non-dereferenceable iterator");
-        return _VSTD::__to_address(__i_);
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator++() _NOEXCEPT
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to increment a non-incrementable iterator");
-        ++__i_;
-        return *this;
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter  operator++(int) _NOEXCEPT
-        {__wrap_iter __tmp(*this); ++(*this); return __tmp;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter() _NOEXCEPT : __i_() {}
+  template <class _Up, __enable_if_t<is_convertible<_Up, iterator_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter(const __wrap_iter<_Up>& __u) _NOEXCEPT
+      : __i_(__u.base()) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference operator*() const _NOEXCEPT { return *__i_; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pointer operator->() const _NOEXCEPT {
+    return std::__to_address(__i_);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator++() _NOEXCEPT {
+    ++__i_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter operator++(int) _NOEXCEPT {
+    __wrap_iter __tmp(*this);
+    ++(*this);
+    return __tmp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator--() _NOEXCEPT
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__decrementable(this),
-                             "Attempted to decrement a non-decrementable iterator");
-        --__i_;
-        return *this;
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter  operator--(int) _NOEXCEPT
-        {__wrap_iter __tmp(*this); --(*this); return __tmp;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter  operator+ (difference_type __n) const _NOEXCEPT
-        {__wrap_iter __w(*this); __w += __n; return __w;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator+=(difference_type __n) _NOEXCEPT
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__addable(this, __n),
-                             "Attempted to add/subtract an iterator outside its valid range");
-        __i_ += __n;
-        return *this;
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter  operator- (difference_type __n) const _NOEXCEPT
-        {return *this + (-__n);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator-=(difference_type __n) _NOEXCEPT
-        {*this += -__n; return *this;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference    operator[](difference_type __n) const _NOEXCEPT
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__subscriptable(this, __n),
-                             "Attempted to subscript an iterator outside its valid range");
-        return __i_[__n];
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator--() _NOEXCEPT {
+    --__i_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter operator--(int) _NOEXCEPT {
+    __wrap_iter __tmp(*this);
+    --(*this);
+    return __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter operator+(difference_type __n) const _NOEXCEPT {
+    __wrap_iter __w(*this);
+    __w += __n;
+    return __w;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator+=(difference_type __n) _NOEXCEPT {
+    __i_ += __n;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter operator-(difference_type __n) const _NOEXCEPT {
+    return *this + (-__n);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter& operator-=(difference_type __n) _NOEXCEPT {
+    *this += -__n;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference operator[](difference_type __n) const _NOEXCEPT {
+    return __i_[__n];
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 iterator_type base() const _NOEXCEPT {return __i_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 iterator_type base() const _NOEXCEPT { return __i_; }
 
 private:
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit __wrap_iter(const void* __p, iterator_type __x) _NOEXCEPT : __i_(__x)
-    {
-        (void)__p;
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-      if (!__libcpp_is_constant_evaluated())
-        __get_db()->__insert_ic(this, __p);
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __wrap_iter(iterator_type __x) _NOEXCEPT : __i_(__x) {}
 
-    template <class _Up> friend class __wrap_iter;
-    template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
-    template <class _Tp, class _Alloc> friend class _LIBCPP_TEMPLATE_VIS vector;
-    template <class _Tp, size_t> friend class _LIBCPP_TEMPLATE_VIS span;
+  template <class _Up>
+  friend class __wrap_iter;
+  template <class _CharT, class _Traits, class _Alloc>
+  friend class basic_string;
+  template <class _CharT, class _Traits>
+  friend class basic_string_view;
+  template <class _Tp, class _Alloc>
+  friend class _LIBCPP_TEMPLATE_VIS vector;
+  template <class _Tp, size_t>
+  friend class _LIBCPP_TEMPLATE_VIS span;
+  template <class _Tp, size_t _Size>
+  friend struct array;
 };
 
 template <class _Iter1>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-bool operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
-{
-    return __x.base() == __y.base();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
+  return __x.base() == __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-bool operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
-{
-    return __x.base() == __y.base();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
+  return __x.base() == __y.base();
 }
 
 template <class _Iter1>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__less_than_comparable(_VSTD::addressof(__x), _VSTD::addressof(__y)),
-                         "Attempted to compare incomparable iterators");
-    return __x.base() < __y.base();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
+  return __x.base() < __y.base();
 }
 
 template <class _Iter1, class _Iter2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__less_than_comparable(&__x, &__y),
-                         "Attempted to compare incomparable iterators");
-    return __x.base() < __y.base();
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
+  return __x.base() < __y.base();
 }
 
 template <class _Iter1>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-bool operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
-{
-    return !(__x == __y);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
+  return !(__x == __y);
 }
 
 template <class _Iter1, class _Iter2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-bool operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
-{
-    return !(__x == __y);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
+  return !(__x == __y);
 }
 
 template <class _Iter1>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-bool operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
-{
-    return __y < __x;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
+  return __y < __x;
 }
 
 template <class _Iter1, class _Iter2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-bool operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
-{
-    return __y < __x;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
+  return __y < __x;
 }
 
 template <class _Iter1>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-bool operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
-{
-    return !(__x < __y);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
+  return !(__x < __y);
 }
 
 template <class _Iter1, class _Iter2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-bool operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
-{
-    return !(__x < __y);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
+  return !(__x < __y);
 }
 
 template <class _Iter1>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-bool operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT
-{
-    return !(__y < __x);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter1>& __y) _NOEXCEPT {
+  return !(__y < __x);
 }
 
 template <class _Iter1, class _Iter2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-bool operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
-{
-    return !(__y < __x);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT {
+  return !(__y < __x);
 }
 
 template <class _Iter1, class _Iter2>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
 #ifndef _LIBCPP_CXX03_LANG
-auto operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
-    -> decltype(__x.base() - __y.base())
+    auto
+    operator-(const __wrap_iter<_Iter1>& __x,
+              const __wrap_iter<_Iter2>& __y) _NOEXCEPT->decltype(__x.base() - __y.base())
 #else
 typename __wrap_iter<_Iter1>::difference_type
 operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
 #endif // C++03
 {
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__less_than_comparable(_VSTD::addressof(__x), _VSTD::addressof(__y)),
-                         "Attempted to subtract incompatible iterators");
-    return __x.base() - __y.base();
+  return __x.base() - __y.base();
 }
 
 template <class _Iter1>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-__wrap_iter<_Iter1> operator+(typename __wrap_iter<_Iter1>::difference_type __n, __wrap_iter<_Iter1> __x) _NOEXCEPT
-{
-    __x += __n;
-    return __x;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter<_Iter1>
+operator+(typename __wrap_iter<_Iter1>::difference_type __n, __wrap_iter<_Iter1> __x) _NOEXCEPT {
+  __x += __n;
+  return __x;
 }
 
 #if _LIBCPP_STD_VER <= 17
@@ -269,16 +206,14 @@ struct __libcpp_is_contiguous_iterator<__wrap_iter<_It> > : true_type {};
 #endif
 
 template <class _It>
-struct _LIBCPP_TEMPLATE_VIS pointer_traits<__wrap_iter<_It> >
-{
-    typedef __wrap_iter<_It> pointer;
-    typedef typename pointer_traits<_It>::element_type element_type;
-    typedef typename pointer_traits<_It>::difference_type difference_type;
+struct _LIBCPP_TEMPLATE_VIS pointer_traits<__wrap_iter<_It> > {
+  typedef __wrap_iter<_It> pointer;
+  typedef typename pointer_traits<_It>::element_type element_type;
+  typedef typename pointer_traits<_It>::difference_type difference_type;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-    static element_type *to_address(pointer __w) _NOEXCEPT {
-        return _VSTD::__to_address(__w.base());
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static element_type* to_address(pointer __w) _NOEXCEPT {
+    return std::__to_address(__w.base());
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__locale b/third_party/libcxx/__locale
index 774dc8c45..4b382764b 100644
--- a/third_party/libcxx/__locale
+++ b/third_party/libcxx/__locale
@@ -10,14 +10,17 @@
 #ifndef _LIBCPP___LOCALE
 #define _LIBCPP___LOCALE
 
-#include <__availability>
 #include <__config>
+#include <__locale_dir/locale_base_api.h>
+#include <__memory/shared_ptr.h> // __shared_count
+#include <__mutex/once_flag.h>
 #include <__type_traits/make_unsigned.h>
+#include <__utility/no_destroy.h>
+#include <__utility/private_constructor_tag.h>
 #include <cctype>
 #include <clocale>
 #include <cstdint>
 #include <cstdlib>
-#include <mutex>
 #include <string>
 
 // Some platforms require more includes than others. Keep the includes on all plaforms for now.
@@ -30,261 +33,206 @@
 #  include <__std_mbstate_t.h>
 #endif
 
-#if defined(_LIBCPP_MSVCRT_LIKE)
-# include <__support/win32/locale_win32.h>
-#elif defined(_AIX) || defined(__MVS__)
-# include <__support/ibm/xlocale.h>
-#elif defined(__ANDROID__)
-# include <__support/android/locale_bionic.h>
-#elif defined(_NEWLIB_VERSION)
-# include <__support/newlib/xlocale.h>
-#elif defined(__OpenBSD__)
-# include <__support/openbsd/xlocale.h>
-#elif (defined(__APPLE__) || defined(__FreeBSD__))
-# include <xlocale.h>
-#elif defined(__Fuchsia__)
-# include <__support/fuchsia/xlocale.h>
-#elif defined(__wasi__)
-// WASI libc uses musl's locales support.
-# include <__support/musl/xlocale.h>
-#elif defined(_LIBCPP_HAS_MUSL_LIBC) || defined(__COSMOPOLITAN__)
-# include <__support/musl/xlocale.h>
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TYPE_VIS locale;
+class _LIBCPP_EXPORTED_FROM_ABI locale;
 
 template <class _Facet>
-_LIBCPP_INLINE_VISIBILITY
-bool
-has_facet(const locale&) _NOEXCEPT;
+_LIBCPP_HIDE_FROM_ABI bool has_facet(const locale&) _NOEXCEPT;
 
 template <class _Facet>
-_LIBCPP_INLINE_VISIBILITY
-const _Facet&
-use_facet(const locale&);
+_LIBCPP_HIDE_FROM_ABI const _Facet& use_facet(const locale&);
 
-class _LIBCPP_TYPE_VIS locale
-{
+class _LIBCPP_EXPORTED_FROM_ABI locale {
 public:
-    // types:
-    class _LIBCPP_TYPE_VIS facet;
-    class _LIBCPP_TYPE_VIS id;
+  // locale is essentially a shared_ptr that doesn't support weak_ptrs and never got a move constructor.
+  using __trivially_relocatable = locale;
 
-    typedef int category;
-    _LIBCPP_AVAILABILITY_LOCALE_CATEGORY
-    static const category // values assigned here are for exposition only
-        none     = 0,
-        collate  = LC_COLLATE_MASK,
-        ctype    = LC_CTYPE_MASK,
-        monetary = LC_MONETARY_MASK,
-        numeric  = LC_NUMERIC_MASK,
-        time     = LC_TIME_MASK,
-        messages = LC_MESSAGES_MASK,
-        all = collate | ctype | monetary | numeric | time | messages;
+  // types:
+  class _LIBCPP_EXPORTED_FROM_ABI facet;
+  class _LIBCPP_EXPORTED_FROM_ABI id;
 
-    // construct/copy/destroy:
-    locale()  _NOEXCEPT;
-    locale(const locale&)  _NOEXCEPT;
-    explicit locale(const char*);
-    explicit locale(const string&);
-    locale(const locale&, const char*, category);
-    locale(const locale&, const string&, category);
-    template <class _Facet>
-        _LIBCPP_INLINE_VISIBILITY locale(const locale&, _Facet*);
-    locale(const locale&, const locale&, category);
+  typedef int category;
 
-    ~locale();
+  static const category // values assigned here are for exposition only
+      none    = 0,
+      collate = LC_COLLATE_MASK, ctype = LC_CTYPE_MASK, monetary = LC_MONETARY_MASK, numeric = LC_NUMERIC_MASK,
+      time = LC_TIME_MASK, messages = LC_MESSAGES_MASK, all = collate | ctype | monetary | numeric | time | messages;
 
-    const locale& operator=(const locale&)  _NOEXCEPT;
+  // construct/copy/destroy:
+  locale() _NOEXCEPT;
+  locale(const locale&) _NOEXCEPT;
+  explicit locale(const char*);
+  explicit locale(const string&);
+  locale(const locale&, const char*, category);
+  locale(const locale&, const string&, category);
+  template <class _Facet>
+  _LIBCPP_HIDE_FROM_ABI locale(const locale&, _Facet*);
+  locale(const locale&, const locale&, category);
 
-    template <class _Facet>
-      _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-      locale combine(const locale&) const;
+  ~locale();
 
-    // locale operations:
-    string name() const;
-    bool operator==(const locale&) const;
-    _LIBCPP_HIDE_FROM_ABI bool operator!=(const locale& __y) const {return !(*this == __y);}
-    template <class _CharT, class _Traits, class _Allocator>
-      _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-      bool operator()(const basic_string<_CharT, _Traits, _Allocator>&,
-                      const basic_string<_CharT, _Traits, _Allocator>&) const;
+  const locale& operator=(const locale&) _NOEXCEPT;
 
-    // global locale objects:
-    static locale global(const locale&);
-    static const locale& classic();
+  template <class _Facet>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS locale combine(const locale&) const;
+
+  // locale operations:
+  string name() const;
+  bool operator==(const locale&) const;
+#if _LIBCPP_STD_VER <= 17
+  _LIBCPP_HIDE_FROM_ABI bool operator!=(const locale& __y) const { return !(*this == __y); }
+#endif
+  template <class _CharT, class _Traits, class _Allocator>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool
+  operator()(const basic_string<_CharT, _Traits, _Allocator>&, const basic_string<_CharT, _Traits, _Allocator>&) const;
+
+  // global locale objects:
+  static locale global(const locale&);
+  static const locale& classic();
 
 private:
-    class __imp;
-    __imp* __locale_;
+  class __imp;
+  __imp* __locale_;
 
-    void __install_ctor(const locale&, facet*, long);
-    static locale& __global();
-    bool has_facet(id&) const;
-    const facet* use_facet(id&) const;
+  template <class>
+  friend struct __no_destroy;
+  _LIBCPP_HIDE_FROM_ABI explicit locale(__private_constructor_tag, __imp* __loc) : __locale_(__loc) {}
 
-    template <class _Facet> friend bool has_facet(const locale&)  _NOEXCEPT;
-    template <class _Facet> friend const _Facet& use_facet(const locale&);
+  void __install_ctor(const locale&, facet*, long);
+  static locale& __global();
+  bool has_facet(id&) const;
+  const facet* use_facet(id&) const;
+
+  template <class _Facet>
+  friend bool has_facet(const locale&) _NOEXCEPT;
+  template <class _Facet>
+  friend const _Facet& use_facet(const locale&);
 };
 
-class _LIBCPP_TYPE_VIS locale::facet
-    : public __shared_count
-{
+class _LIBCPP_EXPORTED_FROM_ABI locale::facet : public __shared_count {
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit facet(size_t __refs = 0)
-        : __shared_count(static_cast<long>(__refs)-1) {}
+  _LIBCPP_HIDE_FROM_ABI explicit facet(size_t __refs = 0) : __shared_count(static_cast<long>(__refs) - 1) {}
 
-    ~facet() override;
+  ~facet() override;
+
+  //    facet(const facet&) = delete;     // effectively done in __shared_count
+  //    void operator=(const facet&) = delete;
 
-//    facet(const facet&) = delete;     // effectively done in __shared_count
-//    void operator=(const facet&) = delete;
 private:
-    void __on_zero_shared() _NOEXCEPT override;
+  void __on_zero_shared() _NOEXCEPT override;
 };
 
-class _LIBCPP_TYPE_VIS locale::id
-{
-    once_flag      __flag_;
-    int32_t        __id_;
+class _LIBCPP_EXPORTED_FROM_ABI locale::id {
+  once_flag __flag_;
+  int32_t __id_;
+
+  static int32_t __next_id;
 
-    static int32_t __next_id;
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR id() :__id_(0) {}
-    void operator=(const id&) = delete;
-    id(const id&) = delete;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR id() : __id_(0) {}
+  void operator=(const id&) = delete;
+  id(const id&)             = delete;
 
-private:
-    void __init();
-public:  // only needed for tests
-    long __get();
+public: // only needed for tests
+  long __get();
 
-    friend class locale;
-    friend class locale::__imp;
+  friend class locale;
+  friend class locale::__imp;
 };
 
 template <class _Facet>
-inline _LIBCPP_INLINE_VISIBILITY
-locale::locale(const locale& __other, _Facet* __f)
-{
-    __install_ctor(__other, __f, __f ? __f->id.__get() : 0);
+inline _LIBCPP_HIDE_FROM_ABI locale::locale(const locale& __other, _Facet* __f) {
+  __install_ctor(__other, __f, __f ? __f->id.__get() : 0);
 }
 
 template <class _Facet>
-locale
-locale::combine(const locale& __other) const
-{
-    if (!_VSTD::has_facet<_Facet>(__other))
-        __throw_runtime_error("locale::combine: locale missing facet");
+locale locale::combine(const locale& __other) const {
+  if (!std::has_facet<_Facet>(__other))
+    __throw_runtime_error("locale::combine: locale missing facet");
 
-    return locale(*this, &const_cast<_Facet&>(_VSTD::use_facet<_Facet>(__other)));
+  return locale(*this, &const_cast<_Facet&>(std::use_facet<_Facet>(__other)));
 }
 
 template <class _Facet>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-has_facet(const locale& __l)  _NOEXCEPT
-{
-    return __l.has_facet(_Facet::id);
+inline _LIBCPP_HIDE_FROM_ABI bool has_facet(const locale& __l) _NOEXCEPT {
+  return __l.has_facet(_Facet::id);
 }
 
 template <class _Facet>
-inline _LIBCPP_INLINE_VISIBILITY
-const _Facet&
-use_facet(const locale& __l)
-{
-    return static_cast<const _Facet&>(*__l.use_facet(_Facet::id));
+inline _LIBCPP_HIDE_FROM_ABI const _Facet& use_facet(const locale& __l) {
+  return static_cast<const _Facet&>(*__l.use_facet(_Facet::id));
 }
 
 // template <class _CharT> class collate;
 
 template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS collate
-    : public locale::facet
-{
+class _LIBCPP_TEMPLATE_VIS collate : public locale::facet {
 public:
-    typedef _CharT char_type;
-    typedef basic_string<char_type> string_type;
+  typedef _CharT char_type;
+  typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit collate(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit collate(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    int compare(const char_type* __lo1, const char_type* __hi1,
-                const char_type* __lo2, const char_type* __hi2) const
-    {
-        return do_compare(__lo1, __hi1, __lo2, __hi2);
-    }
+  _LIBCPP_HIDE_FROM_ABI int
+  compare(const char_type* __lo1, const char_type* __hi1, const char_type* __lo2, const char_type* __hi2) const {
+    return do_compare(__lo1, __hi1, __lo2, __hi2);
+  }
 
-    // FIXME(EricWF): The _LIBCPP_ALWAYS_INLINE is needed on Windows to work
-    // around a dllimport bug that expects an external instantiation.
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_ALWAYS_INLINE
-    string_type transform(const char_type* __lo, const char_type* __hi) const
-    {
-        return do_transform(__lo, __hi);
-    }
+  // FIXME(EricWF): The _LIBCPP_ALWAYS_INLINE is needed on Windows to work
+  // around a dllimport bug that expects an external instantiation.
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE string_type
+  transform(const char_type* __lo, const char_type* __hi) const {
+    return do_transform(__lo, __hi);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    long hash(const char_type* __lo, const char_type* __hi) const
-    {
-        return do_hash(__lo, __hi);
-    }
+  _LIBCPP_HIDE_FROM_ABI long hash(const char_type* __lo, const char_type* __hi) const { return do_hash(__lo, __hi); }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    ~collate() override;
-    virtual int do_compare(const char_type* __lo1, const char_type* __hi1,
-                           const char_type* __lo2, const char_type* __hi2) const;
-    virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const
-        {return string_type(__lo, __hi);}
-    virtual long do_hash(const char_type* __lo, const char_type* __hi) const;
+  ~collate() override;
+  virtual int
+  do_compare(const char_type* __lo1, const char_type* __hi1, const char_type* __lo2, const char_type* __hi2) const;
+  virtual string_type do_transform(const char_type* __lo, const char_type* __hi) const {
+    return string_type(__lo, __hi);
+  }
+  virtual long do_hash(const char_type* __lo, const char_type* __hi) const;
 };
 
-template <class _CharT> locale::id collate<_CharT>::id;
+template <class _CharT>
+locale::id collate<_CharT>::id;
 
 template <class _CharT>
-collate<_CharT>::~collate()
-{
+collate<_CharT>::~collate() {}
+
+template <class _CharT>
+int collate<_CharT>::do_compare(
+    const char_type* __lo1, const char_type* __hi1, const char_type* __lo2, const char_type* __hi2) const {
+  for (; __lo2 != __hi2; ++__lo1, ++__lo2) {
+    if (__lo1 == __hi1 || *__lo1 < *__lo2)
+      return -1;
+    if (*__lo2 < *__lo1)
+      return 1;
+  }
+  return __lo1 != __hi1;
 }
 
 template <class _CharT>
-int
-collate<_CharT>::do_compare(const char_type* __lo1, const char_type* __hi1,
-                            const char_type* __lo2, const char_type* __hi2) const
-{
-    for (; __lo2 != __hi2; ++__lo1, ++__lo2)
-    {
-        if (__lo1 == __hi1 || *__lo1 < *__lo2)
-            return -1;
-        if (*__lo2 < *__lo1)
-            return 1;
-    }
-    return __lo1 != __hi1;
-}
-
-template <class _CharT>
-long
-collate<_CharT>::do_hash(const char_type* __lo, const char_type* __hi) const
-{
-    size_t __h = 0;
-    const size_t __sr = __CHAR_BIT__ * sizeof(size_t) - 8;
-    const size_t __mask = size_t(0xF) << (__sr + 4);
-    for(const char_type* __p = __lo; __p != __hi; ++__p)
-    {
-        __h = (__h << 4) + static_cast<size_t>(*__p);
-        size_t __g = __h & __mask;
-        __h ^= __g | (__g >> __sr);
-    }
-    return static_cast<long>(__h);
+long collate<_CharT>::do_hash(const char_type* __lo, const char_type* __hi) const {
+  size_t __h          = 0;
+  const size_t __sr   = __CHAR_BIT__ * sizeof(size_t) - 8;
+  const size_t __mask = size_t(0xF) << (__sr + 4);
+  for (const char_type* __p = __lo; __p != __hi; ++__p) {
+    __h        = (__h << 4) + static_cast<size_t>(*__p);
+    size_t __g = __h & __mask;
+    __h ^= __g | (__g >> __sr);
+  }
+  return static_cast<long>(__h);
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<char>;
@@ -294,871 +242,744 @@ extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS collate<wchar_t>;
 
 // template <class CharT> class collate_byname;
 
-template <class _CharT> class _LIBCPP_TEMPLATE_VIS collate_byname;
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS collate_byname;
 
 template <>
-class _LIBCPP_TYPE_VIS collate_byname<char>
-    : public collate<char>
-{
-    locale_t __l_;
-public:
-    typedef char char_type;
-    typedef basic_string<char_type> string_type;
+class _LIBCPP_EXPORTED_FROM_ABI collate_byname<char> : public collate<char> {
+  locale_t __l_;
 
-    explicit collate_byname(const char* __n, size_t __refs = 0);
-    explicit collate_byname(const string& __n, size_t __refs = 0);
+public:
+  typedef char char_type;
+  typedef basic_string<char_type> string_type;
+
+  explicit collate_byname(const char* __n, size_t __refs = 0);
+  explicit collate_byname(const string& __n, size_t __refs = 0);
 
 protected:
-    ~collate_byname() override;
-    int do_compare(const char_type* __lo1, const char_type* __hi1,
-                   const char_type* __lo2, const char_type* __hi2) const override;
-    string_type do_transform(const char_type* __lo, const char_type* __hi) const override;
+  ~collate_byname() override;
+  int do_compare(
+      const char_type* __lo1, const char_type* __hi1, const char_type* __lo2, const char_type* __hi2) const override;
+  string_type do_transform(const char_type* __lo, const char_type* __hi) const override;
 };
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-class _LIBCPP_TYPE_VIS collate_byname<wchar_t>
-    : public collate<wchar_t>
-{
-    locale_t __l_;
-public:
-    typedef wchar_t char_type;
-    typedef basic_string<char_type> string_type;
+class _LIBCPP_EXPORTED_FROM_ABI collate_byname<wchar_t> : public collate<wchar_t> {
+  locale_t __l_;
 
-    explicit collate_byname(const char* __n, size_t __refs = 0);
-    explicit collate_byname(const string& __n, size_t __refs = 0);
+public:
+  typedef wchar_t char_type;
+  typedef basic_string<char_type> string_type;
+
+  explicit collate_byname(const char* __n, size_t __refs = 0);
+  explicit collate_byname(const string& __n, size_t __refs = 0);
 
 protected:
-    ~collate_byname() override;
+  ~collate_byname() override;
 
-    int do_compare(const char_type* __lo1, const char_type* __hi1,
-                   const char_type* __lo2, const char_type* __hi2) const override;
-    string_type do_transform(const char_type* __lo, const char_type* __hi) const override;
+  int do_compare(
+      const char_type* __lo1, const char_type* __hi1, const char_type* __lo2, const char_type* __hi2) const override;
+  string_type do_transform(const char_type* __lo, const char_type* __hi) const override;
 };
 #endif
 
 template <class _CharT, class _Traits, class _Allocator>
-bool
-locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
-                   const basic_string<_CharT, _Traits, _Allocator>& __y) const
-{
-    return _VSTD::use_facet<_VSTD::collate<_CharT> >(*this).compare(
-                                       __x.data(), __x.data() + __x.size(),
-                                       __y.data(), __y.data() + __y.size()) < 0;
+bool locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
+                        const basic_string<_CharT, _Traits, _Allocator>& __y) const {
+  return std::use_facet<std::collate<_CharT> >(*this).compare(
+             __x.data(), __x.data() + __x.size(), __y.data(), __y.data() + __y.size()) < 0;
 }
 
 // template <class charT> class ctype
 
-class _LIBCPP_TYPE_VIS ctype_base
-{
+class _LIBCPP_EXPORTED_FROM_ABI ctype_base {
 public:
 #if defined(_LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE)
-    typedef unsigned long mask;
-    static const mask space  = 1<<0;
-    static const mask print  = 1<<1;
-    static const mask cntrl  = 1<<2;
-    static const mask upper  = 1<<3;
-    static const mask lower  = 1<<4;
-    static const mask alpha  = 1<<5;
-    static const mask digit  = 1<<6;
-    static const mask punct  = 1<<7;
-    static const mask xdigit = 1<<8;
-    static const mask blank  = 1<<9;
-#if defined(__BIONIC__)
-    // Historically this was a part of regex_traits rather than ctype_base. The
-    // historical value of the constant is preserved for ABI compatibility.
-    static const mask __regex_word = 0x8000;
-#else
-    static const mask __regex_word = 1<<10;
-#endif // defined(__BIONIC__)
+  typedef unsigned long mask;
+  static const mask space  = 1 << 0;
+  static const mask print  = 1 << 1;
+  static const mask cntrl  = 1 << 2;
+  static const mask upper  = 1 << 3;
+  static const mask lower  = 1 << 4;
+  static const mask alpha  = 1 << 5;
+  static const mask digit  = 1 << 6;
+  static const mask punct  = 1 << 7;
+  static const mask xdigit = 1 << 8;
+  static const mask blank  = 1 << 9;
+#  if defined(__BIONIC__)
+  // Historically this was a part of regex_traits rather than ctype_base. The
+  // historical value of the constant is preserved for ABI compatibility.
+  static const mask __regex_word = 0x8000;
+#  else
+  static const mask __regex_word = 1 << 10;
+#  endif // defined(__BIONIC__)
 #elif defined(__GLIBC__)
-    typedef unsigned short mask;
-    static const mask space  = _ISspace;
-    static const mask print  = _ISprint;
-    static const mask cntrl  = _IScntrl;
-    static const mask upper  = _ISupper;
-    static const mask lower  = _ISlower;
-    static const mask alpha  = _ISalpha;
-    static const mask digit  = _ISdigit;
-    static const mask punct  = _ISpunct;
-    static const mask xdigit = _ISxdigit;
-    static const mask blank  = _ISblank;
-#if defined(__mips__)
-    static const mask __regex_word = static_cast<mask>(_ISbit(15));
-#else
-    static const mask __regex_word = 0x80;
-#endif
+  typedef unsigned short mask;
+  static const mask space  = _ISspace;
+  static const mask print  = _ISprint;
+  static const mask cntrl  = _IScntrl;
+  static const mask upper  = _ISupper;
+  static const mask lower  = _ISlower;
+  static const mask alpha  = _ISalpha;
+  static const mask digit  = _ISdigit;
+  static const mask punct  = _ISpunct;
+  static const mask xdigit = _ISxdigit;
+  static const mask blank  = _ISblank;
+#  if defined(__mips__) || (BYTE_ORDER == BIG_ENDIAN)
+  static const mask __regex_word = static_cast<mask>(_ISbit(15));
+#  else
+  static const mask __regex_word = 0x80;
+#  endif
 #elif defined(_LIBCPP_MSVCRT_LIKE)
-    typedef unsigned short mask;
-    static const mask space  = _SPACE;
-    static const mask print  = _BLANK|_PUNCT|_ALPHA|_DIGIT;
-    static const mask cntrl  = _CONTROL;
-    static const mask upper  = _UPPER;
-    static const mask lower  = _LOWER;
-    static const mask alpha  = _ALPHA;
-    static const mask digit  = _DIGIT;
-    static const mask punct  = _PUNCT;
-    static const mask xdigit = _HEX;
-    static const mask blank  = _BLANK;
-    static const mask __regex_word = 0x4000; // 0x8000 and 0x0100 and 0x00ff are used
-# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
-# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
-#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__)
-# ifdef __APPLE__
-    typedef __uint32_t mask;
-# elif defined(__FreeBSD__)
-    typedef unsigned long mask;
-# elif defined(__EMSCRIPTEN__) || defined(__NetBSD__)
-    typedef unsigned short mask;
-# endif
-    static const mask space  = _CTYPE_S;
-    static const mask print  = _CTYPE_R;
-    static const mask cntrl  = _CTYPE_C;
-    static const mask upper  = _CTYPE_U;
-    static const mask lower  = _CTYPE_L;
-    static const mask alpha  = _CTYPE_A;
-    static const mask digit  = _CTYPE_D;
-    static const mask punct  = _CTYPE_P;
-    static const mask xdigit = _CTYPE_X;
+  typedef unsigned short mask;
+  static const mask space        = _SPACE;
+  static const mask print        = _BLANK | _PUNCT | _ALPHA | _DIGIT;
+  static const mask cntrl        = _CONTROL;
+  static const mask upper        = _UPPER;
+  static const mask lower        = _LOWER;
+  static const mask alpha        = _ALPHA;
+  static const mask digit        = _DIGIT;
+  static const mask punct        = _PUNCT;
+  static const mask xdigit       = _HEX;
+  static const mask blank        = _BLANK;
+  static const mask __regex_word = 0x4000; // 0x8000 and 0x0100 and 0x00ff are used
+#  define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
+#  define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
+#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
+#  ifdef __APPLE__
+  typedef __uint32_t mask;
+#  elif defined(__FreeBSD__)
+  typedef unsigned long mask;
+#  elif defined(__NetBSD__)
+  typedef unsigned short mask;
+#  endif
+  static const mask space  = _CTYPE_S;
+  static const mask print  = _CTYPE_R;
+  static const mask cntrl  = _CTYPE_C;
+  static const mask upper  = _CTYPE_U;
+  static const mask lower  = _CTYPE_L;
+  static const mask alpha  = _CTYPE_A;
+  static const mask digit  = _CTYPE_D;
+  static const mask punct  = _CTYPE_P;
+  static const mask xdigit = _CTYPE_X;
 
-# if defined(__NetBSD__)
-    static const mask blank  = _CTYPE_BL;
-    // NetBSD defines classes up to 0x2000
-    // see sys/ctype_bits.h, _CTYPE_Q
-    static const mask __regex_word = 0x8000;
-# else
-    static const mask blank  = _CTYPE_B;
-    static const mask __regex_word = 0x80;
-# endif
+#  if defined(__NetBSD__)
+  static const mask blank = _CTYPE_BL;
+  // NetBSD defines classes up to 0x2000
+  // see sys/ctype_bits.h, _CTYPE_Q
+  static const mask __regex_word = 0x8000;
+#  else
+  static const mask blank        = _CTYPE_B;
+  static const mask __regex_word = 0x80;
+#  endif
 #elif defined(_AIX)
-    typedef unsigned int mask;
-    static const mask space  = _ISSPACE;
-    static const mask print  = _ISPRINT;
-    static const mask cntrl  = _ISCNTRL;
-    static const mask upper  = _ISUPPER;
-    static const mask lower  = _ISLOWER;
-    static const mask alpha  = _ISALPHA;
-    static const mask digit  = _ISDIGIT;
-    static const mask punct  = _ISPUNCT;
-    static const mask xdigit = _ISXDIGIT;
-    static const mask blank  = _ISBLANK;
-    static const mask __regex_word = 0x8000;
+  typedef unsigned int mask;
+  static const mask space        = _ISSPACE;
+  static const mask print        = _ISPRINT;
+  static const mask cntrl        = _ISCNTRL;
+  static const mask upper        = _ISUPPER;
+  static const mask lower        = _ISLOWER;
+  static const mask alpha        = _ISALPHA;
+  static const mask digit        = _ISDIGIT;
+  static const mask punct        = _ISPUNCT;
+  static const mask xdigit       = _ISXDIGIT;
+  static const mask blank        = _ISBLANK;
+  static const mask __regex_word = 0x8000;
 #elif defined(_NEWLIB_VERSION)
-    // Same type as Newlib's _ctype_ array in newlib/libc/include/ctype.h.
-    typedef char mask;
-    static const mask space  = _S;
-    static const mask print  = _P | _U | _L | _N | _B;
-    static const mask cntrl  = _C;
-    static const mask upper  = _U;
-    static const mask lower  = _L;
-    static const mask alpha  = _U | _L;
-    static const mask digit  = _N;
-    static const mask punct  = _P;
-    static const mask xdigit = _X | _N;
-    static const mask blank  = _B;
-    // mask is already fully saturated, use a different type in regex_type_traits.
-    static const unsigned short __regex_word = 0x100;
-# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
-# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
-# define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
+  // Same type as Newlib's _ctype_ array in newlib/libc/include/ctype.h.
+  typedef char mask;
+  // In case char is signed, static_cast is needed to avoid warning on
+  // positive value becomming negative.
+  static const mask space  = static_cast<mask>(_S);
+  static const mask print  = static_cast<mask>(_P | _U | _L | _N | _B);
+  static const mask cntrl  = static_cast<mask>(_C);
+  static const mask upper  = static_cast<mask>(_U);
+  static const mask lower  = static_cast<mask>(_L);
+  static const mask alpha  = static_cast<mask>(_U | _L);
+  static const mask digit  = static_cast<mask>(_N);
+  static const mask punct  = static_cast<mask>(_P);
+  static const mask xdigit = static_cast<mask>(_X | _N);
+  static const mask blank  = static_cast<mask>(_B);
+  // mask is already fully saturated, use a different type in regex_type_traits.
+  static const unsigned short __regex_word = 0x100;
+#  define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
+#  define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
+#  define _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
 #elif defined(__MVS__)
-# if defined(__NATIVE_ASCII_F)
-    typedef unsigned int mask;
-    static const mask space  = _ISSPACE_A;
-    static const mask print  = _ISPRINT_A;
-    static const mask cntrl  = _ISCNTRL_A;
-    static const mask upper  = _ISUPPER_A;
-    static const mask lower  = _ISLOWER_A;
-    static const mask alpha  = _ISALPHA_A;
-    static const mask digit  = _ISDIGIT_A;
-    static const mask punct  = _ISPUNCT_A;
-    static const mask xdigit = _ISXDIGIT_A;
-    static const mask blank  = _ISBLANK_A;
-# else
-    typedef unsigned short mask;
-    static const mask space  = __ISSPACE;
-    static const mask print  = __ISPRINT;
-    static const mask cntrl  = __ISCNTRL;
-    static const mask upper  = __ISUPPER;
-    static const mask lower  = __ISLOWER;
-    static const mask alpha  = __ISALPHA;
-    static const mask digit  = __ISDIGIT;
-    static const mask punct  = __ISPUNCT;
-    static const mask xdigit = __ISXDIGIT;
-    static const mask blank  = __ISBLANK;
-# endif
-    static const mask __regex_word = 0x8000;
+#  if defined(__NATIVE_ASCII_F)
+  typedef unsigned int mask;
+  static const mask space  = _ISSPACE_A;
+  static const mask print  = _ISPRINT_A;
+  static const mask cntrl  = _ISCNTRL_A;
+  static const mask upper  = _ISUPPER_A;
+  static const mask lower  = _ISLOWER_A;
+  static const mask alpha  = _ISALPHA_A;
+  static const mask digit  = _ISDIGIT_A;
+  static const mask punct  = _ISPUNCT_A;
+  static const mask xdigit = _ISXDIGIT_A;
+  static const mask blank  = _ISBLANK_A;
+#  else
+  typedef unsigned short mask;
+  static const mask space  = __ISSPACE;
+  static const mask print  = __ISPRINT;
+  static const mask cntrl  = __ISCNTRL;
+  static const mask upper  = __ISUPPER;
+  static const mask lower  = __ISLOWER;
+  static const mask alpha  = __ISALPHA;
+  static const mask digit  = __ISDIGIT;
+  static const mask punct  = __ISPUNCT;
+  static const mask xdigit = __ISXDIGIT;
+  static const mask blank  = __ISBLANK;
+#  endif
+  static const mask __regex_word = 0x8000;
 #else
-# error unknown rune table for this platform -- do you mean to define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE?
+#  error unknown rune table for this platform -- do you mean to define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE?
 #endif
-    static const mask alnum  = alpha | digit;
-    static const mask graph  = alnum | punct;
+  static const mask alnum = alpha | digit;
+  static const mask graph = alnum | punct;
 
-    _LIBCPP_INLINE_VISIBILITY ctype_base() {}
+  _LIBCPP_HIDE_FROM_ABI ctype_base() {}
 
-    static_assert((__regex_word & ~(std::make_unsigned<mask>::type)(space | print | cntrl | upper | lower | alpha |
-                                                                    digit | punct | xdigit | blank)) == __regex_word,
-                  "__regex_word can't overlap other bits");
+  static_assert((__regex_word & ~(std::make_unsigned<mask>::type)(space | print | cntrl | upper | lower | alpha |
+                                                                  digit | punct | xdigit | blank)) == __regex_word,
+                "__regex_word can't overlap other bits");
 };
 
-template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype;
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS ctype;
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-class _LIBCPP_TYPE_VIS ctype<wchar_t>
-    : public locale::facet,
-      public ctype_base
-{
+class _LIBCPP_EXPORTED_FROM_ABI ctype<wchar_t> : public locale::facet, public ctype_base {
 public:
-    typedef wchar_t char_type;
+  typedef wchar_t char_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit ctype(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit ctype(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool is(mask __m, char_type __c) const
-    {
-        return do_is(__m, __c);
-    }
+  _LIBCPP_HIDE_FROM_ABI bool is(mask __m, char_type __c) const { return do_is(__m, __c); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const
-    {
-        return do_is(__low, __high, __vec);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const {
+    return do_is(__low, __high, __vec);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* scan_is(mask __m, const char_type* __low, const char_type* __high) const
-    {
-        return do_scan_is(__m, __low, __high);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type* scan_is(mask __m, const char_type* __low, const char_type* __high) const {
+    return do_scan_is(__m, __low, __high);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const
-    {
-        return do_scan_not(__m, __low, __high);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const {
+    return do_scan_not(__m, __low, __high);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    char_type toupper(char_type __c) const
-    {
-        return do_toupper(__c);
-    }
+  _LIBCPP_HIDE_FROM_ABI char_type toupper(char_type __c) const { return do_toupper(__c); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* toupper(char_type* __low, const char_type* __high) const
-    {
-        return do_toupper(__low, __high);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type* toupper(char_type* __low, const char_type* __high) const {
+    return do_toupper(__low, __high);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    char_type tolower(char_type __c) const
-    {
-        return do_tolower(__c);
-    }
+  _LIBCPP_HIDE_FROM_ABI char_type tolower(char_type __c) const { return do_tolower(__c); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* tolower(char_type* __low, const char_type* __high) const
-    {
-        return do_tolower(__low, __high);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type* tolower(char_type* __low, const char_type* __high) const {
+    return do_tolower(__low, __high);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    char_type widen(char __c) const
-    {
-        return do_widen(__c);
-    }
+  _LIBCPP_HIDE_FROM_ABI char_type widen(char __c) const { return do_widen(__c); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char* widen(const char* __low, const char* __high, char_type* __to) const
-    {
-        return do_widen(__low, __high, __to);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char* widen(const char* __low, const char* __high, char_type* __to) const {
+    return do_widen(__low, __high, __to);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    char narrow(char_type __c, char __dfault) const
-    {
-        return do_narrow(__c, __dfault);
-    }
+  _LIBCPP_HIDE_FROM_ABI char narrow(char_type __c, char __dfault) const { return do_narrow(__c, __dfault); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const
-    {
-        return do_narrow(__low, __high, __dfault, __to);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type*
+  narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const {
+    return do_narrow(__low, __high, __dfault, __to);
+  }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    ~ctype() override;
-    virtual bool do_is(mask __m, char_type __c) const;
-    virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const;
-    virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const;
-    virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const;
-    virtual char_type do_toupper(char_type) const;
-    virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
-    virtual char_type do_tolower(char_type) const;
-    virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
-    virtual char_type do_widen(char) const;
-    virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const;
-    virtual char do_narrow(char_type, char __dfault) const;
-    virtual const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const;
+  ~ctype() override;
+  virtual bool do_is(mask __m, char_type __c) const;
+  virtual const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const;
+  virtual const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const;
+  virtual const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const;
+  virtual char_type do_toupper(char_type) const;
+  virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
+  virtual char_type do_tolower(char_type) const;
+  virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
+  virtual char_type do_widen(char) const;
+  virtual const char* do_widen(const char* __low, const char* __high, char_type* __dest) const;
+  virtual char do_narrow(char_type, char __dfault) const;
+  virtual const char_type*
+  do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const;
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 template <>
-class _LIBCPP_TYPE_VIS ctype<char>
-    : public locale::facet, public ctype_base
-{
-    const mask* __tab_;
-    bool        __del_;
+class _LIBCPP_EXPORTED_FROM_ABI ctype<char> : public locale::facet, public ctype_base {
+  const mask* __tab_;
+  bool __del_;
+
 public:
-    typedef char char_type;
+  typedef char char_type;
 
-    explicit ctype(const mask* __tab = nullptr, bool __del = false, size_t __refs = 0);
+  explicit ctype(const mask* __tab = nullptr, bool __del = false, size_t __refs = 0);
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool is(mask __m, char_type __c) const
-    {
-        return isascii(__c) ? (__tab_[static_cast<int>(__c)] & __m) !=0 : false;
-    }
+  _LIBCPP_HIDE_FROM_ABI bool is(mask __m, char_type __c) const {
+    return isascii(__c) ? (__tab_[static_cast<int>(__c)] & __m) != 0 : false;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const
-    {
-        for (; __low != __high; ++__low, ++__vec)
-            *__vec = isascii(*__low) ? __tab_[static_cast<int>(*__low)] : 0;
-        return __low;
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type* is(const char_type* __low, const char_type* __high, mask* __vec) const {
+    for (; __low != __high; ++__low, ++__vec)
+      *__vec = isascii(*__low) ? __tab_[static_cast<int>(*__low)] : 0;
+    return __low;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* scan_is (mask __m, const char_type* __low, const char_type* __high) const
-    {
-        for (; __low != __high; ++__low)
-            if (isascii(*__low) && (__tab_[static_cast<int>(*__low)] & __m))
-                break;
-        return __low;
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type* scan_is(mask __m, const char_type* __low, const char_type* __high) const {
+    for (; __low != __high; ++__low)
+      if (isascii(*__low) && (__tab_[static_cast<int>(*__low)] & __m))
+        break;
+    return __low;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const
-    {
-        for (; __low != __high; ++__low)
-            if (!isascii(*__low) || !(__tab_[static_cast<int>(*__low)] & __m))
-                break;
-        return __low;
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type* scan_not(mask __m, const char_type* __low, const char_type* __high) const {
+    for (; __low != __high; ++__low)
+      if (!isascii(*__low) || !(__tab_[static_cast<int>(*__low)] & __m))
+        break;
+    return __low;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    char_type toupper(char_type __c) const
-    {
-        return do_toupper(__c);
-    }
+  _LIBCPP_HIDE_FROM_ABI char_type toupper(char_type __c) const { return do_toupper(__c); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* toupper(char_type* __low, const char_type* __high) const
-    {
-        return do_toupper(__low, __high);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type* toupper(char_type* __low, const char_type* __high) const {
+    return do_toupper(__low, __high);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    char_type tolower(char_type __c) const
-    {
-        return do_tolower(__c);
-    }
+  _LIBCPP_HIDE_FROM_ABI char_type tolower(char_type __c) const { return do_tolower(__c); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char_type* tolower(char_type* __low, const char_type* __high) const
-    {
-        return do_tolower(__low, __high);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char_type* tolower(char_type* __low, const char_type* __high) const {
+    return do_tolower(__low, __high);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    char_type widen(char __c) const
-    {
-        return do_widen(__c);
-    }
+  _LIBCPP_HIDE_FROM_ABI char_type widen(char __c) const { return do_widen(__c); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char* widen(const char* __low, const char* __high, char_type* __to) const
-    {
-        return do_widen(__low, __high, __to);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char* widen(const char* __low, const char* __high, char_type* __to) const {
+    return do_widen(__low, __high, __to);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    char narrow(char_type __c, char __dfault) const
-    {
-        return do_narrow(__c, __dfault);
-    }
+  _LIBCPP_HIDE_FROM_ABI char narrow(char_type __c, char __dfault) const { return do_narrow(__c, __dfault); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char* narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const
-    {
-        return do_narrow(__low, __high, __dfault, __to);
-    }
+  _LIBCPP_HIDE_FROM_ABI const char*
+  narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const {
+    return do_narrow(__low, __high, __dfault, __to);
+  }
 
-    static locale::id id;
+  static locale::id id;
 
 #ifdef _CACHED_RUNES
-    static const size_t table_size = _CACHED_RUNES;
+  static const size_t table_size = _CACHED_RUNES;
 #else
-    static const size_t table_size = 256;  // FIXME: Don't hardcode this.
+  static const size_t table_size = 256; // FIXME: Don't hardcode this.
 #endif
-    _LIBCPP_INLINE_VISIBILITY const mask* table() const  _NOEXCEPT {return __tab_;}
-    static const mask* classic_table()  _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI const mask* table() const _NOEXCEPT { return __tab_; }
+  static const mask* classic_table() _NOEXCEPT;
 #if defined(__GLIBC__) || defined(__EMSCRIPTEN__)
-    static const int* __classic_upper_table() _NOEXCEPT;
-    static const int* __classic_lower_table() _NOEXCEPT;
+  static const int* __classic_upper_table() _NOEXCEPT;
+  static const int* __classic_lower_table() _NOEXCEPT;
 #endif
 #if defined(__NetBSD__)
-    static const short* __classic_upper_table() _NOEXCEPT;
-    static const short* __classic_lower_table() _NOEXCEPT;
+  static const short* __classic_upper_table() _NOEXCEPT;
+  static const short* __classic_lower_table() _NOEXCEPT;
 #endif
 #if defined(__MVS__)
-    static const unsigned short* __classic_upper_table() _NOEXCEPT;
-    static const unsigned short* __classic_lower_table() _NOEXCEPT;
+  static const unsigned short* __classic_upper_table() _NOEXCEPT;
+  static const unsigned short* __classic_lower_table() _NOEXCEPT;
 #endif
 
 protected:
-    ~ctype() override;
-    virtual char_type do_toupper(char_type __c) const;
-    virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
-    virtual char_type do_tolower(char_type __c) const;
-    virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
-    virtual char_type do_widen(char __c) const;
-    virtual const char* do_widen(const char* __low, const char* __high, char_type* __to) const;
-    virtual char do_narrow(char_type __c, char __dfault) const;
-    virtual const char* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const;
+  ~ctype() override;
+  virtual char_type do_toupper(char_type __c) const;
+  virtual const char_type* do_toupper(char_type* __low, const char_type* __high) const;
+  virtual char_type do_tolower(char_type __c) const;
+  virtual const char_type* do_tolower(char_type* __low, const char_type* __high) const;
+  virtual char_type do_widen(char __c) const;
+  virtual const char* do_widen(const char* __low, const char* __high, char_type* __to) const;
+  virtual char do_narrow(char_type __c, char __dfault) const;
+  virtual const char* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __to) const;
 };
 
 // template <class CharT> class ctype_byname;
 
-template <class _CharT> class _LIBCPP_TEMPLATE_VIS ctype_byname;
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS ctype_byname;
 
 template <>
-class _LIBCPP_TYPE_VIS ctype_byname<char>
-    : public ctype<char>
-{
-    locale_t __l_;
+class _LIBCPP_EXPORTED_FROM_ABI ctype_byname<char> : public ctype<char> {
+  locale_t __l_;
 
 public:
-    explicit ctype_byname(const char*, size_t = 0);
-    explicit ctype_byname(const string&, size_t = 0);
+  explicit ctype_byname(const char*, size_t = 0);
+  explicit ctype_byname(const string&, size_t = 0);
 
 protected:
-    ~ctype_byname() override;
-    char_type do_toupper(char_type) const override;
-    const char_type* do_toupper(char_type* __low, const char_type* __high) const override;
-    char_type do_tolower(char_type) const override;
-    const char_type* do_tolower(char_type* __low, const char_type* __high) const override;
+  ~ctype_byname() override;
+  char_type do_toupper(char_type) const override;
+  const char_type* do_toupper(char_type* __low, const char_type* __high) const override;
+  char_type do_tolower(char_type) const override;
+  const char_type* do_tolower(char_type* __low, const char_type* __high) const override;
 };
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-class _LIBCPP_TYPE_VIS ctype_byname<wchar_t>
-    : public ctype<wchar_t>
-{
-    locale_t __l_;
+class _LIBCPP_EXPORTED_FROM_ABI ctype_byname<wchar_t> : public ctype<wchar_t> {
+  locale_t __l_;
 
 public:
-    explicit ctype_byname(const char*, size_t = 0);
-    explicit ctype_byname(const string&, size_t = 0);
+  explicit ctype_byname(const char*, size_t = 0);
+  explicit ctype_byname(const string&, size_t = 0);
 
 protected:
-    ~ctype_byname() override;
-    bool do_is(mask __m, char_type __c) const override;
-    const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const override;
-    const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const override;
-    const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const override;
-    char_type do_toupper(char_type) const override;
-    const char_type* do_toupper(char_type* __low, const char_type* __high) const override;
-    char_type do_tolower(char_type) const override;
-    const char_type* do_tolower(char_type* __low, const char_type* __high) const override;
-    char_type do_widen(char) const override;
-    const char* do_widen(const char* __low, const char* __high, char_type* __dest) const override;
-    char do_narrow(char_type, char __dfault) const override;
-    const char_type* do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const override;
+  ~ctype_byname() override;
+  bool do_is(mask __m, char_type __c) const override;
+  const char_type* do_is(const char_type* __low, const char_type* __high, mask* __vec) const override;
+  const char_type* do_scan_is(mask __m, const char_type* __low, const char_type* __high) const override;
+  const char_type* do_scan_not(mask __m, const char_type* __low, const char_type* __high) const override;
+  char_type do_toupper(char_type) const override;
+  const char_type* do_toupper(char_type* __low, const char_type* __high) const override;
+  char_type do_tolower(char_type) const override;
+  const char_type* do_tolower(char_type* __low, const char_type* __high) const override;
+  char_type do_widen(char) const override;
+  const char* do_widen(const char* __low, const char* __high, char_type* __dest) const override;
+  char do_narrow(char_type, char __dfault) const override;
+  const char_type*
+  do_narrow(const char_type* __low, const char_type* __high, char __dfault, char* __dest) const override;
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isspace(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool isspace(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isprint(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool isprint(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-iscntrl(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool iscntrl(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isupper(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool isupper(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-islower(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool islower(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isalpha(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool isalpha(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isdigit(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool isdigit(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-ispunct(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool ispunct(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isxdigit(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool isxdigit(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isalnum(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool isalnum(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isgraph(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c);
+inline _LIBCPP_HIDE_FROM_ABI bool isgraph(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c);
 }
 
 template <class _CharT>
 _LIBCPP_HIDE_FROM_ABI bool isblank(_CharT __c, const locale& __loc) {
-    return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c);
+  return std::use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-_CharT
-toupper(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).toupper(__c);
+inline _LIBCPP_HIDE_FROM_ABI _CharT toupper(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).toupper(__c);
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-_CharT
-tolower(_CharT __c, const locale& __loc)
-{
-    return std::use_facet<ctype<_CharT> >(__loc).tolower(__c);
+inline _LIBCPP_HIDE_FROM_ABI _CharT tolower(_CharT __c, const locale& __loc) {
+  return std::use_facet<ctype<_CharT> >(__loc).tolower(__c);
 }
 
 // codecvt_base
 
-class _LIBCPP_TYPE_VIS codecvt_base
-{
+class _LIBCPP_EXPORTED_FROM_ABI codecvt_base {
 public:
-    _LIBCPP_INLINE_VISIBILITY codecvt_base() {}
-    enum result {ok, partial, error, noconv};
+  _LIBCPP_HIDE_FROM_ABI codecvt_base() {}
+  enum result { ok, partial, error, noconv };
 };
 
 // template <class internT, class externT, class stateT> class codecvt;
 
-template <class _InternT, class _ExternT, class _StateT> class _LIBCPP_TEMPLATE_VIS codecvt;
+template <class _InternT, class _ExternT, class _StateT>
+class _LIBCPP_TEMPLATE_VIS codecvt;
 
 // template <> class codecvt<char, char, mbstate_t>
 
 template <>
-class _LIBCPP_TYPE_VIS codecvt<char, char, mbstate_t>
-    : public locale::facet,
-      public codecvt_base
-{
+class _LIBCPP_EXPORTED_FROM_ABI codecvt<char, char, mbstate_t> : public locale::facet, public codecvt_base {
 public:
-    typedef char      intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+  typedef char intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    result out(state_type& __st,
-               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  out(state_type& __st,
+      const intern_type* __frm,
+      const intern_type* __frm_end,
+      const intern_type*& __frm_nxt,
+      extern_type* __to,
+      extern_type* __to_end,
+      extern_type*& __to_nxt) const {
+    return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_unshift(__st, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const {
+    return do_unshift(__st, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
-    {
-        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  in(state_type& __st,
+     const extern_type* __frm,
+     const extern_type* __frm_end,
+     const extern_type*& __frm_nxt,
+     intern_type* __to,
+     intern_type* __to_end,
+     intern_type*& __to_nxt) const {
+    return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int encoding() const  _NOEXCEPT
-    {
-        return do_encoding();
-    }
+  _LIBCPP_HIDE_FROM_ABI int encoding() const _NOEXCEPT { return do_encoding(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool always_noconv() const  _NOEXCEPT
-    {
-        return do_always_noconv();
-    }
+  _LIBCPP_HIDE_FROM_ABI bool always_noconv() const _NOEXCEPT { return do_always_noconv(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
-    {
-        return do_length(__st, __frm, __end, __mx);
-    }
+  _LIBCPP_HIDE_FROM_ABI int
+  length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const {
+    return do_length(__st, __frm, __end, __mx);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int max_length() const  _NOEXCEPT
-    {
-        return do_max_length();
-    }
+  _LIBCPP_HIDE_FROM_ABI int max_length() const _NOEXCEPT { return do_max_length(); }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt(const char*, size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt(const char*, size_t __refs = 0) : locale::facet(__refs) {}
 
-    ~codecvt() override;
+  ~codecvt() override;
 
-    virtual result do_out(state_type& __st,
-                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result do_in(state_type& __st,
-                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result do_unshift(state_type& __st,
-                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
-    virtual int do_length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+  virtual result
+  do_out(state_type& __st,
+         const intern_type* __frm,
+         const intern_type* __frm_end,
+         const intern_type*& __frm_nxt,
+         extern_type* __to,
+         extern_type* __to_end,
+         extern_type*& __to_nxt) const;
+  virtual result
+  do_in(state_type& __st,
+        const extern_type* __frm,
+        const extern_type* __frm_end,
+        const extern_type*& __frm_nxt,
+        intern_type* __to,
+        intern_type* __to_end,
+        intern_type*& __to_nxt) const;
+  virtual result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+  virtual int do_encoding() const _NOEXCEPT;
+  virtual bool do_always_noconv() const _NOEXCEPT;
+  virtual int do_length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
+  virtual int do_max_length() const _NOEXCEPT;
 };
 
 // template <> class codecvt<wchar_t, char, mbstate_t>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-class _LIBCPP_TYPE_VIS codecvt<wchar_t, char, mbstate_t>
-    : public locale::facet,
-      public codecvt_base
-{
-    locale_t __l_;
+class _LIBCPP_EXPORTED_FROM_ABI codecvt<wchar_t, char, mbstate_t> : public locale::facet, public codecvt_base {
+  locale_t __l_;
+
 public:
-    typedef wchar_t   intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+  typedef wchar_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
 
-    explicit codecvt(size_t __refs = 0);
+  explicit codecvt(size_t __refs = 0);
 
-    _LIBCPP_INLINE_VISIBILITY
-    result out(state_type& __st,
-               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  out(state_type& __st,
+      const intern_type* __frm,
+      const intern_type* __frm_end,
+      const intern_type*& __frm_nxt,
+      extern_type* __to,
+      extern_type* __to_end,
+      extern_type*& __to_nxt) const {
+    return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_unshift(__st, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const {
+    return do_unshift(__st, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
-    {
-        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  in(state_type& __st,
+     const extern_type* __frm,
+     const extern_type* __frm_end,
+     const extern_type*& __frm_nxt,
+     intern_type* __to,
+     intern_type* __to_end,
+     intern_type*& __to_nxt) const {
+    return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int encoding() const  _NOEXCEPT
-    {
-        return do_encoding();
-    }
+  _LIBCPP_HIDE_FROM_ABI int encoding() const _NOEXCEPT { return do_encoding(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool always_noconv() const  _NOEXCEPT
-    {
-        return do_always_noconv();
-    }
+  _LIBCPP_HIDE_FROM_ABI bool always_noconv() const _NOEXCEPT { return do_always_noconv(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
-    {
-        return do_length(__st, __frm, __end, __mx);
-    }
+  _LIBCPP_HIDE_FROM_ABI int
+  length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const {
+    return do_length(__st, __frm, __end, __mx);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int max_length() const  _NOEXCEPT
-    {
-        return do_max_length();
-    }
+  _LIBCPP_HIDE_FROM_ABI int max_length() const _NOEXCEPT { return do_max_length(); }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    explicit codecvt(const char*, size_t __refs = 0);
+  explicit codecvt(const char*, size_t __refs = 0);
 
-    ~codecvt() override;
+  ~codecvt() override;
 
-    virtual result do_out(state_type& __st,
-                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result do_in(state_type& __st,
-                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result do_unshift(state_type& __st,
-                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+  virtual result
+  do_out(state_type& __st,
+         const intern_type* __frm,
+         const intern_type* __frm_end,
+         const intern_type*& __frm_nxt,
+         extern_type* __to,
+         extern_type* __to_end,
+         extern_type*& __to_nxt) const;
+  virtual result
+  do_in(state_type& __st,
+        const extern_type* __frm,
+        const extern_type* __frm_end,
+        const extern_type*& __frm_nxt,
+        intern_type* __to,
+        intern_type* __to_end,
+        intern_type*& __to_nxt) const;
+  virtual result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+  virtual int do_encoding() const _NOEXCEPT;
+  virtual bool do_always_noconv() const _NOEXCEPT;
+  virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
+  virtual int do_max_length() const _NOEXCEPT;
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 // template <> class codecvt<char16_t, char, mbstate_t> // deprecated in C++20
 
 template <>
-class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_TYPE_VIS codecvt<char16_t, char, mbstate_t>
-    : public locale::facet,
-      public codecvt_base
-{
+class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_EXPORTED_FROM_ABI codecvt<char16_t, char, mbstate_t>
+    : public locale::facet, public codecvt_base {
 public:
-    typedef char16_t  intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+  typedef char16_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    result out(state_type& __st,
-               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  out(state_type& __st,
+      const intern_type* __frm,
+      const intern_type* __frm_end,
+      const intern_type*& __frm_nxt,
+      extern_type* __to,
+      extern_type* __to_end,
+      extern_type*& __to_nxt) const {
+    return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_unshift(__st, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const {
+    return do_unshift(__st, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
-    {
-        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  in(state_type& __st,
+     const extern_type* __frm,
+     const extern_type* __frm_end,
+     const extern_type*& __frm_nxt,
+     intern_type* __to,
+     intern_type* __to_end,
+     intern_type*& __to_nxt) const {
+    return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int encoding() const  _NOEXCEPT
-    {
-        return do_encoding();
-    }
+  _LIBCPP_HIDE_FROM_ABI int encoding() const _NOEXCEPT { return do_encoding(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool always_noconv() const  _NOEXCEPT
-    {
-        return do_always_noconv();
-    }
+  _LIBCPP_HIDE_FROM_ABI bool always_noconv() const _NOEXCEPT { return do_always_noconv(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
-    {
-        return do_length(__st, __frm, __end, __mx);
-    }
+  _LIBCPP_HIDE_FROM_ABI int
+  length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const {
+    return do_length(__st, __frm, __end, __mx);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int max_length() const  _NOEXCEPT
-    {
-        return do_max_length();
-    }
+  _LIBCPP_HIDE_FROM_ABI int max_length() const _NOEXCEPT { return do_max_length(); }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt(const char*, size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt(const char*, size_t __refs = 0) : locale::facet(__refs) {}
 
-    ~codecvt() override;
+  ~codecvt() override;
 
-    virtual result do_out(state_type& __st,
-                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result do_in(state_type& __st,
-                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result do_unshift(state_type& __st,
-                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+  virtual result
+  do_out(state_type& __st,
+         const intern_type* __frm,
+         const intern_type* __frm_end,
+         const intern_type*& __frm_nxt,
+         extern_type* __to,
+         extern_type* __to_end,
+         extern_type*& __to_nxt) const;
+  virtual result
+  do_in(state_type& __st,
+        const extern_type* __frm,
+        const extern_type* __frm_end,
+        const extern_type*& __frm_nxt,
+        intern_type* __to,
+        intern_type* __to_end,
+        intern_type*& __to_nxt) const;
+  virtual result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+  virtual int do_encoding() const _NOEXCEPT;
+  virtual bool do_always_noconv() const _NOEXCEPT;
+  virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
+  virtual int do_max_length() const _NOEXCEPT;
 };
 
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
@@ -1166,87 +987,80 @@ protected:
 // template <> class codecvt<char16_t, char8_t, mbstate_t> // C++20
 
 template <>
-class _LIBCPP_TYPE_VIS codecvt<char16_t, char8_t, mbstate_t>
-    : public locale::facet,
-      public codecvt_base
-{
+class _LIBCPP_EXPORTED_FROM_ABI codecvt<char16_t, char8_t, mbstate_t> : public locale::facet, public codecvt_base {
 public:
-    typedef char16_t  intern_type;
-    typedef char8_t   extern_type;
-    typedef mbstate_t state_type;
+  typedef char16_t intern_type;
+  typedef char8_t extern_type;
+  typedef mbstate_t state_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    result out(state_type& __st,
-               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  out(state_type& __st,
+      const intern_type* __frm,
+      const intern_type* __frm_end,
+      const intern_type*& __frm_nxt,
+      extern_type* __to,
+      extern_type* __to_end,
+      extern_type*& __to_nxt) const {
+    return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_unshift(__st, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const {
+    return do_unshift(__st, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
-    {
-        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  in(state_type& __st,
+     const extern_type* __frm,
+     const extern_type* __frm_end,
+     const extern_type*& __frm_nxt,
+     intern_type* __to,
+     intern_type* __to_end,
+     intern_type*& __to_nxt) const {
+    return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int encoding() const  _NOEXCEPT
-    {
-        return do_encoding();
-    }
+  _LIBCPP_HIDE_FROM_ABI int encoding() const _NOEXCEPT { return do_encoding(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool always_noconv() const  _NOEXCEPT
-    {
-        return do_always_noconv();
-    }
+  _LIBCPP_HIDE_FROM_ABI bool always_noconv() const _NOEXCEPT { return do_always_noconv(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
-    {
-        return do_length(__st, __frm, __end, __mx);
-    }
+  _LIBCPP_HIDE_FROM_ABI int
+  length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const {
+    return do_length(__st, __frm, __end, __mx);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int max_length() const  _NOEXCEPT
-    {
-        return do_max_length();
-    }
+  _LIBCPP_HIDE_FROM_ABI int max_length() const _NOEXCEPT { return do_max_length(); }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt(const char*, size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt(const char*, size_t __refs = 0) : locale::facet(__refs) {}
 
-    ~codecvt() override;
+  ~codecvt() override;
 
-    virtual result do_out(state_type& __st,
-                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result do_in(state_type& __st,
-                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result do_unshift(state_type& __st,
-                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+  virtual result
+  do_out(state_type& __st,
+         const intern_type* __frm,
+         const intern_type* __frm_end,
+         const intern_type*& __frm_nxt,
+         extern_type* __to,
+         extern_type* __to_end,
+         extern_type*& __to_nxt) const;
+  virtual result
+  do_in(state_type& __st,
+        const extern_type* __frm,
+        const extern_type* __frm_end,
+        const extern_type*& __frm_nxt,
+        intern_type* __to,
+        intern_type* __to_end,
+        intern_type*& __to_nxt) const;
+  virtual result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+  virtual int do_encoding() const _NOEXCEPT;
+  virtual bool do_always_noconv() const _NOEXCEPT;
+  virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
+  virtual int do_max_length() const _NOEXCEPT;
 };
 
 #endif
@@ -1254,87 +1068,81 @@ protected:
 // template <> class codecvt<char32_t, char, mbstate_t> // deprecated in C++20
 
 template <>
-class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_TYPE_VIS codecvt<char32_t, char, mbstate_t>
-    : public locale::facet,
-      public codecvt_base
-{
+class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_EXPORTED_FROM_ABI codecvt<char32_t, char, mbstate_t>
+    : public locale::facet, public codecvt_base {
 public:
-    typedef char32_t  intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+  typedef char32_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    result out(state_type& __st,
-               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  out(state_type& __st,
+      const intern_type* __frm,
+      const intern_type* __frm_end,
+      const intern_type*& __frm_nxt,
+      extern_type* __to,
+      extern_type* __to_end,
+      extern_type*& __to_nxt) const {
+    return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_unshift(__st, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const {
+    return do_unshift(__st, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
-    {
-        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  in(state_type& __st,
+     const extern_type* __frm,
+     const extern_type* __frm_end,
+     const extern_type*& __frm_nxt,
+     intern_type* __to,
+     intern_type* __to_end,
+     intern_type*& __to_nxt) const {
+    return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int encoding() const  _NOEXCEPT
-    {
-        return do_encoding();
-    }
+  _LIBCPP_HIDE_FROM_ABI int encoding() const _NOEXCEPT { return do_encoding(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool always_noconv() const  _NOEXCEPT
-    {
-        return do_always_noconv();
-    }
+  _LIBCPP_HIDE_FROM_ABI bool always_noconv() const _NOEXCEPT { return do_always_noconv(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
-    {
-        return do_length(__st, __frm, __end, __mx);
-    }
+  _LIBCPP_HIDE_FROM_ABI int
+  length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const {
+    return do_length(__st, __frm, __end, __mx);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int max_length() const  _NOEXCEPT
-    {
-        return do_max_length();
-    }
+  _LIBCPP_HIDE_FROM_ABI int max_length() const _NOEXCEPT { return do_max_length(); }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt(const char*, size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt(const char*, size_t __refs = 0) : locale::facet(__refs) {}
 
-    ~codecvt() override;
+  ~codecvt() override;
 
-    virtual result do_out(state_type& __st,
-                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result do_in(state_type& __st,
-                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result do_unshift(state_type& __st,
-                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+  virtual result
+  do_out(state_type& __st,
+         const intern_type* __frm,
+         const intern_type* __frm_end,
+         const intern_type*& __frm_nxt,
+         extern_type* __to,
+         extern_type* __to_end,
+         extern_type*& __to_nxt) const;
+  virtual result
+  do_in(state_type& __st,
+        const extern_type* __frm,
+        const extern_type* __frm_end,
+        const extern_type*& __frm_nxt,
+        intern_type* __to,
+        intern_type* __to_end,
+        intern_type*& __to_nxt) const;
+  virtual result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+  virtual int do_encoding() const _NOEXCEPT;
+  virtual bool do_always_noconv() const _NOEXCEPT;
+  virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
+  virtual int do_max_length() const _NOEXCEPT;
 };
 
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
@@ -1342,87 +1150,80 @@ protected:
 // template <> class codecvt<char32_t, char8_t, mbstate_t> // C++20
 
 template <>
-class _LIBCPP_TYPE_VIS codecvt<char32_t, char8_t, mbstate_t>
-    : public locale::facet,
-      public codecvt_base
-{
+class _LIBCPP_EXPORTED_FROM_ABI codecvt<char32_t, char8_t, mbstate_t> : public locale::facet, public codecvt_base {
 public:
-    typedef char32_t  intern_type;
-    typedef char8_t   extern_type;
-    typedef mbstate_t state_type;
+  typedef char32_t intern_type;
+  typedef char8_t extern_type;
+  typedef mbstate_t state_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    result out(state_type& __st,
-               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  out(state_type& __st,
+      const intern_type* __frm,
+      const intern_type* __frm_end,
+      const intern_type*& __frm_nxt,
+      extern_type* __to,
+      extern_type* __to_end,
+      extern_type*& __to_nxt) const {
+    return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result unshift(state_type& __st,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
-    {
-        return do_unshift(__st, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const {
+    return do_unshift(__st, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result in(state_type& __st,
-              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
-    {
-        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
-    }
+  _LIBCPP_HIDE_FROM_ABI result
+  in(state_type& __st,
+     const extern_type* __frm,
+     const extern_type* __frm_end,
+     const extern_type*& __frm_nxt,
+     intern_type* __to,
+     intern_type* __to_end,
+     intern_type*& __to_nxt) const {
+    return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int encoding() const  _NOEXCEPT
-    {
-        return do_encoding();
-    }
+  _LIBCPP_HIDE_FROM_ABI int encoding() const _NOEXCEPT { return do_encoding(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool always_noconv() const  _NOEXCEPT
-    {
-        return do_always_noconv();
-    }
+  _LIBCPP_HIDE_FROM_ABI bool always_noconv() const _NOEXCEPT { return do_always_noconv(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
-    {
-        return do_length(__st, __frm, __end, __mx);
-    }
+  _LIBCPP_HIDE_FROM_ABI int
+  length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const {
+    return do_length(__st, __frm, __end, __mx);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int max_length() const  _NOEXCEPT
-    {
-        return do_max_length();
-    }
+  _LIBCPP_HIDE_FROM_ABI int max_length() const _NOEXCEPT { return do_max_length(); }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt(const char*, size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt(const char*, size_t __refs = 0) : locale::facet(__refs) {}
 
-    ~codecvt() override;
+  ~codecvt() override;
 
-    virtual result do_out(state_type& __st,
-                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual result do_in(state_type& __st,
-                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
-    virtual result do_unshift(state_type& __st,
-                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
-    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+  virtual result
+  do_out(state_type& __st,
+         const intern_type* __frm,
+         const intern_type* __frm_end,
+         const intern_type*& __frm_nxt,
+         extern_type* __to,
+         extern_type* __to_end,
+         extern_type*& __to_nxt) const;
+  virtual result
+  do_in(state_type& __st,
+        const extern_type* __frm,
+        const extern_type* __frm_end,
+        const extern_type*& __frm_nxt,
+        intern_type* __to,
+        intern_type* __to_end,
+        intern_type*& __to_nxt) const;
+  virtual result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+  virtual int do_encoding() const _NOEXCEPT;
+  virtual bool do_always_noconv() const _NOEXCEPT;
+  virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
+  virtual int do_max_length() const _NOEXCEPT;
 };
 
 #endif
@@ -1430,333 +1231,280 @@ protected:
 // template <class _InternT, class _ExternT, class _StateT> class codecvt_byname
 
 template <class _InternT, class _ExternT, class _StateT>
-class _LIBCPP_TEMPLATE_VIS codecvt_byname
-    : public codecvt<_InternT, _ExternT, _StateT>
-{
+class _LIBCPP_TEMPLATE_VIS codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> {
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt_byname(const char* __nm, size_t __refs = 0)
-        : codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt_byname(const string& __nm, size_t __refs = 0)
-        : codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt_byname(const char* __nm, size_t __refs = 0)
+      : codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt_byname(const string& __nm, size_t __refs = 0)
+      : codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {}
+
 protected:
-    ~codecvt_byname() override;
+  ~codecvt_byname() override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _InternT, class _ExternT, class _StateT>
-codecvt_byname<_InternT, _ExternT, _StateT>::~codecvt_byname()
-{
-}
+codecvt_byname<_InternT, _ExternT, _StateT>::~codecvt_byname() {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char, char, mbstate_t>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<wchar_t, char, mbstate_t>;
 #endif
-extern template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char, mbstate_t>; // deprecated in C++20
-extern template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char, mbstate_t>; // deprecated in C++20
+extern template class _LIBCPP_DEPRECATED_IN_CXX20
+_LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char, mbstate_t>; // deprecated in C++20
+extern template class _LIBCPP_DEPRECATED_IN_CXX20
+_LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char, mbstate_t>; // deprecated in C++20
 #ifndef _LIBCPP_HAS_NO_CHAR8_T
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char8_t, mbstate_t>; // C++20
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char8_t, mbstate_t>; // C++20
 #endif
 
 template <size_t _Np>
-struct __narrow_to_utf8
-{
-    template <class _OutputIterator, class _CharT>
-    _OutputIterator
-    operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const;
+struct __narrow_to_utf8 {
+  template <class _OutputIterator, class _CharT>
+  _OutputIterator operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const;
 };
 
 template <>
-struct __narrow_to_utf8<8>
-{
-    template <class _OutputIterator, class _CharT>
-    _LIBCPP_INLINE_VISIBILITY
-    _OutputIterator
-    operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
-    {
-        for (; __wb < __we; ++__wb, ++__s)
-            *__s = *__wb;
-        return __s;
-    }
+struct __narrow_to_utf8<8> {
+  template <class _OutputIterator, class _CharT>
+  _LIBCPP_HIDE_FROM_ABI _OutputIterator operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const {
+    for (; __wb < __we; ++__wb, ++__s)
+      *__s = *__wb;
+    return __s;
+  }
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-struct _LIBCPP_TYPE_VIS __narrow_to_utf8<16>
-    : public codecvt<char16_t, char, mbstate_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    __narrow_to_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+struct _LIBCPP_EXPORTED_FROM_ABI __narrow_to_utf8<16> : public codecvt<char16_t, char, mbstate_t> {
+  _LIBCPP_HIDE_FROM_ABI __narrow_to_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    ~__narrow_to_utf8() override;
+  ~__narrow_to_utf8() override;
 
-    template <class _OutputIterator, class _CharT>
-    _LIBCPP_INLINE_VISIBILITY
-    _OutputIterator
-    operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
-    {
-        result __r = ok;
-        mbstate_t __mb;
-        while (__wb < __we && __r != error)
-        {
-            const int __sz = 32;
-            char __buf[__sz];
-            char* __bn;
-            const char16_t* __wn = (const char16_t*)__wb;
-            __r = do_out(__mb, (const char16_t*)__wb, (const char16_t*)__we, __wn,
-                         __buf, __buf+__sz, __bn);
-            if (__r == codecvt_base::error || __wn == (const char16_t*)__wb)
-                __throw_runtime_error("locale not supported");
-            for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
-                *__s = *__p;
-            __wb = (const _CharT*)__wn;
-        }
-        return __s;
+  template <class _OutputIterator, class _CharT>
+  _LIBCPP_HIDE_FROM_ABI _OutputIterator operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const {
+    result __r = ok;
+    mbstate_t __mb;
+    while (__wb < __we && __r != error) {
+      const int __sz = 32;
+      char __buf[__sz];
+      char* __bn;
+      const char16_t* __wn = (const char16_t*)__wb;
+      __r = do_out(__mb, (const char16_t*)__wb, (const char16_t*)__we, __wn, __buf, __buf + __sz, __bn);
+      if (__r == codecvt_base::error || __wn == (const char16_t*)__wb)
+        __throw_runtime_error("locale not supported");
+      for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
+        *__s = *__p;
+      __wb = (const _CharT*)__wn;
     }
+    return __s;
+  }
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-struct _LIBCPP_TYPE_VIS __narrow_to_utf8<32>
-    : public codecvt<char32_t, char, mbstate_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    __narrow_to_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+struct _LIBCPP_EXPORTED_FROM_ABI __narrow_to_utf8<32> : public codecvt<char32_t, char, mbstate_t> {
+  _LIBCPP_HIDE_FROM_ABI __narrow_to_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    ~__narrow_to_utf8() override;
+  ~__narrow_to_utf8() override;
 
-    template <class _OutputIterator, class _CharT>
-    _LIBCPP_INLINE_VISIBILITY
-    _OutputIterator
-    operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
-    {
-        result __r = ok;
-        mbstate_t __mb;
-        while (__wb < __we && __r != error)
-        {
-            const int __sz = 32;
-            char __buf[__sz];
-            char* __bn;
-            const char32_t* __wn = (const char32_t*)__wb;
-            __r = do_out(__mb, (const char32_t*)__wb, (const char32_t*)__we, __wn,
-                         __buf, __buf+__sz, __bn);
-            if (__r == codecvt_base::error || __wn == (const char32_t*)__wb)
-                __throw_runtime_error("locale not supported");
-            for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
-                *__s = *__p;
-            __wb = (const _CharT*)__wn;
-        }
-        return __s;
+  template <class _OutputIterator, class _CharT>
+  _LIBCPP_HIDE_FROM_ABI _OutputIterator operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const {
+    result __r = ok;
+    mbstate_t __mb;
+    while (__wb < __we && __r != error) {
+      const int __sz = 32;
+      char __buf[__sz];
+      char* __bn;
+      const char32_t* __wn = (const char32_t*)__wb;
+      __r = do_out(__mb, (const char32_t*)__wb, (const char32_t*)__we, __wn, __buf, __buf + __sz, __bn);
+      if (__r == codecvt_base::error || __wn == (const char32_t*)__wb)
+        __throw_runtime_error("locale not supported");
+      for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
+        *__s = *__p;
+      __wb = (const _CharT*)__wn;
     }
+    return __s;
+  }
 };
 
 template <size_t _Np>
-struct __widen_from_utf8
-{
-    template <class _OutputIterator>
-    _OutputIterator
-    operator()(_OutputIterator __s, const char* __nb, const char* __ne) const;
+struct __widen_from_utf8 {
+  template <class _OutputIterator>
+  _OutputIterator operator()(_OutputIterator __s, const char* __nb, const char* __ne) const;
 };
 
 template <>
-struct __widen_from_utf8<8>
-{
-    template <class _OutputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-    _OutputIterator
-    operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
-    {
-        for (; __nb < __ne; ++__nb, ++__s)
-            *__s = *__nb;
-        return __s;
-    }
+struct __widen_from_utf8<8> {
+  template <class _OutputIterator>
+  _LIBCPP_HIDE_FROM_ABI _OutputIterator operator()(_OutputIterator __s, const char* __nb, const char* __ne) const {
+    for (; __nb < __ne; ++__nb, ++__s)
+      *__s = *__nb;
+    return __s;
+  }
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-struct _LIBCPP_TYPE_VIS __widen_from_utf8<16>
-    : public codecvt<char16_t, char, mbstate_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    __widen_from_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+struct _LIBCPP_EXPORTED_FROM_ABI __widen_from_utf8<16> : public codecvt<char16_t, char, mbstate_t> {
+  _LIBCPP_HIDE_FROM_ABI __widen_from_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    ~__widen_from_utf8() override;
+  ~__widen_from_utf8() override;
 
-    template <class _OutputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-    _OutputIterator
-    operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
-    {
-        result __r = ok;
-        mbstate_t __mb;
-        while (__nb < __ne && __r != error)
-        {
-            const int __sz = 32;
-            char16_t __buf[__sz];
-            char16_t* __bn;
-            const char* __nn = __nb;
-            __r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb+__sz : __ne, __nn,
-                        __buf, __buf+__sz, __bn);
-            if (__r == codecvt_base::error || __nn == __nb)
-                __throw_runtime_error("locale not supported");
-            for (const char16_t* __p = __buf; __p < __bn; ++__p, ++__s)
-                *__s = *__p;
-            __nb = __nn;
-        }
-        return __s;
+  template <class _OutputIterator>
+  _LIBCPP_HIDE_FROM_ABI _OutputIterator operator()(_OutputIterator __s, const char* __nb, const char* __ne) const {
+    result __r = ok;
+    mbstate_t __mb;
+    while (__nb < __ne && __r != error) {
+      const int __sz = 32;
+      char16_t __buf[__sz];
+      char16_t* __bn;
+      const char* __nn = __nb;
+      __r              = do_in(__mb, __nb, __ne - __nb > __sz ? __nb + __sz : __ne, __nn, __buf, __buf + __sz, __bn);
+      if (__r == codecvt_base::error || __nn == __nb)
+        __throw_runtime_error("locale not supported");
+      for (const char16_t* __p = __buf; __p < __bn; ++__p, ++__s)
+        *__s = *__p;
+      __nb = __nn;
     }
+    return __s;
+  }
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-struct _LIBCPP_TYPE_VIS __widen_from_utf8<32>
-    : public codecvt<char32_t, char, mbstate_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    __widen_from_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+struct _LIBCPP_EXPORTED_FROM_ABI __widen_from_utf8<32> : public codecvt<char32_t, char, mbstate_t> {
+  _LIBCPP_HIDE_FROM_ABI __widen_from_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    ~__widen_from_utf8() override;
+  ~__widen_from_utf8() override;
 
-    template <class _OutputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-    _OutputIterator
-    operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
-    {
-        result __r = ok;
-        mbstate_t __mb;
-        while (__nb < __ne && __r != error)
-        {
-            const int __sz = 32;
-            char32_t __buf[__sz];
-            char32_t* __bn;
-            const char* __nn = __nb;
-            __r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb+__sz : __ne, __nn,
-                        __buf, __buf+__sz, __bn);
-            if (__r == codecvt_base::error || __nn == __nb)
-                __throw_runtime_error("locale not supported");
-            for (const char32_t* __p = __buf; __p < __bn; ++__p, ++__s)
-                *__s = *__p;
-            __nb = __nn;
-        }
-        return __s;
+  template <class _OutputIterator>
+  _LIBCPP_HIDE_FROM_ABI _OutputIterator operator()(_OutputIterator __s, const char* __nb, const char* __ne) const {
+    result __r = ok;
+    mbstate_t __mb;
+    while (__nb < __ne && __r != error) {
+      const int __sz = 32;
+      char32_t __buf[__sz];
+      char32_t* __bn;
+      const char* __nn = __nb;
+      __r              = do_in(__mb, __nb, __ne - __nb > __sz ? __nb + __sz : __ne, __nn, __buf, __buf + __sz, __bn);
+      if (__r == codecvt_base::error || __nn == __nb)
+        __throw_runtime_error("locale not supported");
+      for (const char32_t* __p = __buf; __p < __bn; ++__p, ++__s)
+        *__s = *__p;
+      __nb = __nn;
     }
+    return __s;
+  }
 };
 
 // template <class charT> class numpunct
 
-template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct;
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS numpunct;
 
 template <>
-class _LIBCPP_TYPE_VIS numpunct<char>
-    : public locale::facet
-{
+class _LIBCPP_EXPORTED_FROM_ABI numpunct<char> : public locale::facet {
 public:
-    typedef char char_type;
-    typedef basic_string<char_type> string_type;
+  typedef char char_type;
+  typedef basic_string<char_type> string_type;
 
-    explicit numpunct(size_t __refs = 0);
+  explicit numpunct(size_t __refs = 0);
 
-    _LIBCPP_INLINE_VISIBILITY char_type decimal_point() const {return do_decimal_point();}
-    _LIBCPP_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
-    _LIBCPP_INLINE_VISIBILITY string grouping() const         {return do_grouping();}
-    _LIBCPP_INLINE_VISIBILITY string_type truename() const    {return do_truename();}
-    _LIBCPP_INLINE_VISIBILITY string_type falsename() const   {return do_falsename();}
+  _LIBCPP_HIDE_FROM_ABI char_type decimal_point() const { return do_decimal_point(); }
+  _LIBCPP_HIDE_FROM_ABI char_type thousands_sep() const { return do_thousands_sep(); }
+  _LIBCPP_HIDE_FROM_ABI string grouping() const { return do_grouping(); }
+  _LIBCPP_HIDE_FROM_ABI string_type truename() const { return do_truename(); }
+  _LIBCPP_HIDE_FROM_ABI string_type falsename() const { return do_falsename(); }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    ~numpunct() override;
-    virtual char_type do_decimal_point() const;
-    virtual char_type do_thousands_sep() const;
-    virtual string do_grouping() const;
-    virtual string_type do_truename() const;
-    virtual string_type do_falsename() const;
+  ~numpunct() override;
+  virtual char_type do_decimal_point() const;
+  virtual char_type do_thousands_sep() const;
+  virtual string do_grouping() const;
+  virtual string_type do_truename() const;
+  virtual string_type do_falsename() const;
 
-    char_type __decimal_point_;
-    char_type __thousands_sep_;
-    string __grouping_;
+  char_type __decimal_point_;
+  char_type __thousands_sep_;
+  string __grouping_;
 };
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-class _LIBCPP_TYPE_VIS numpunct<wchar_t>
-    : public locale::facet
-{
+class _LIBCPP_EXPORTED_FROM_ABI numpunct<wchar_t> : public locale::facet {
 public:
-    typedef wchar_t char_type;
-    typedef basic_string<char_type> string_type;
+  typedef wchar_t char_type;
+  typedef basic_string<char_type> string_type;
 
-    explicit numpunct(size_t __refs = 0);
+  explicit numpunct(size_t __refs = 0);
 
-    _LIBCPP_INLINE_VISIBILITY char_type decimal_point() const {return do_decimal_point();}
-    _LIBCPP_INLINE_VISIBILITY char_type thousands_sep() const {return do_thousands_sep();}
-    _LIBCPP_INLINE_VISIBILITY string grouping() const         {return do_grouping();}
-    _LIBCPP_INLINE_VISIBILITY string_type truename() const    {return do_truename();}
-    _LIBCPP_INLINE_VISIBILITY string_type falsename() const   {return do_falsename();}
+  _LIBCPP_HIDE_FROM_ABI char_type decimal_point() const { return do_decimal_point(); }
+  _LIBCPP_HIDE_FROM_ABI char_type thousands_sep() const { return do_thousands_sep(); }
+  _LIBCPP_HIDE_FROM_ABI string grouping() const { return do_grouping(); }
+  _LIBCPP_HIDE_FROM_ABI string_type truename() const { return do_truename(); }
+  _LIBCPP_HIDE_FROM_ABI string_type falsename() const { return do_falsename(); }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    ~numpunct() override;
-    virtual char_type do_decimal_point() const;
-    virtual char_type do_thousands_sep() const;
-    virtual string do_grouping() const;
-    virtual string_type do_truename() const;
-    virtual string_type do_falsename() const;
+  ~numpunct() override;
+  virtual char_type do_decimal_point() const;
+  virtual char_type do_thousands_sep() const;
+  virtual string do_grouping() const;
+  virtual string_type do_truename() const;
+  virtual string_type do_falsename() const;
 
-    char_type __decimal_point_;
-    char_type __thousands_sep_;
-    string __grouping_;
+  char_type __decimal_point_;
+  char_type __thousands_sep_;
+  string __grouping_;
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 // template <class charT> class numpunct_byname
 
-template <class _CharT> class _LIBCPP_TEMPLATE_VIS numpunct_byname;
+template <class _CharT>
+class _LIBCPP_TEMPLATE_VIS numpunct_byname;
 
 template <>
-class _LIBCPP_TYPE_VIS numpunct_byname<char>
-: public numpunct<char>
-{
+class _LIBCPP_EXPORTED_FROM_ABI numpunct_byname<char> : public numpunct<char> {
 public:
-    typedef char char_type;
-    typedef basic_string<char_type> string_type;
+  typedef char char_type;
+  typedef basic_string<char_type> string_type;
 
-    explicit numpunct_byname(const char* __nm, size_t __refs = 0);
-    explicit numpunct_byname(const string& __nm, size_t __refs = 0);
+  explicit numpunct_byname(const char* __nm, size_t __refs = 0);
+  explicit numpunct_byname(const string& __nm, size_t __refs = 0);
 
 protected:
-    ~numpunct_byname() override;
+  ~numpunct_byname() override;
 
 private:
-    void __init(const char*);
+  void __init(const char*);
 };
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-class _LIBCPP_TYPE_VIS numpunct_byname<wchar_t>
-: public numpunct<wchar_t>
-{
+class _LIBCPP_EXPORTED_FROM_ABI numpunct_byname<wchar_t> : public numpunct<wchar_t> {
 public:
-    typedef wchar_t char_type;
-    typedef basic_string<char_type> string_type;
+  typedef wchar_t char_type;
+  typedef basic_string<char_type> string_type;
 
-    explicit numpunct_byname(const char* __nm, size_t __refs = 0);
-    explicit numpunct_byname(const string& __nm, size_t __refs = 0);
+  explicit numpunct_byname(const char* __nm, size_t __refs = 0);
+  explicit numpunct_byname(const string& __nm, size_t __refs = 0);
 
 protected:
-    ~numpunct_byname() override;
+  ~numpunct_byname() override;
 
 private:
-    void __init(const char*);
+  void __init(const char*);
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
diff --git a/third_party/libcxx/__locale_dir/locale_base_api.h b/third_party/libcxx/__locale_dir/locale_base_api.h
new file mode 100644
index 000000000..546acdd55
--- /dev/null
+++ b/third_party/libcxx/__locale_dir/locale_base_api.h
@@ -0,0 +1,100 @@
+//===-----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___LOCALE_DIR_LOCALE_BASE_API_H
+#define _LIBCPP___LOCALE_DIR_LOCALE_BASE_API_H
+
+#include <__config>
+
+#if defined(_LIBCPP_MSVCRT_LIKE)
+// #  include <__locale_dir/locale_base_api/win32.h>
+#elif defined(_AIX) || defined(__MVS__)
+// #  include <__locale_dir/locale_base_api/ibm.h>
+#elif defined(__ANDROID__)
+// #  include <__locale_dir/locale_base_api/android.h>
+#elif defined(__sun__)
+// #  include <__locale_dir/locale_base_api/solaris.h>
+#elif defined(_NEWLIB_VERSION)
+// #  include <__locale_dir/locale_base_api/newlib.h>
+#elif defined(__OpenBSD__)
+// #  include <__locale_dir/locale_base_api/openbsd.h>
+#elif defined(__Fuchsia__)
+// #  include <__locale_dir/locale_base_api/fuchsia.h>
+#elif defined(__wasi__) || defined(_LIBCPP_HAS_MUSL_LIBC)
+// #  include <__locale_dir/locale_base_api/musl.h>
+#elif defined(__APPLE__) || defined(__FreeBSD__)
+#  include <xlocale.h>
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+/*
+The platform-specific headers have to provide the following interface:
+
+// TODO: rename this to __libcpp_locale_t
+using locale_t = implementation-defined;
+
+implementation-defined __libcpp_mb_cur_max_l(locale_t);
+wint_t __libcpp_btowc_l(int, locale_t);
+int __libcpp_wctob_l(wint_t, locale_t);
+size_t __libcpp_wcsnrtombs_l(char* dest, const wchar_t** src, size_t wide_char_count, size_t len, mbstate_t, locale_t);
+size_t __libcpp_wcrtomb_l(char* str, wchar_t wide_char, mbstate_t*, locale_t);
+size_t __libcpp_mbsnrtowcs_l(wchar_t* dest, const char** src, size_t max_out, size_t len, mbstate_t*, locale_t);
+size_t __libcpp_mbrtowc_l(wchar_t* dest, cosnt char* src, size_t count, mbstate_t*, locale_t);
+int __libcpp_mbtowc_l(wchar_t* dest, const char* src, size_t count, locale_t);
+size_t __libcpp_mbrlen_l(const char* str, size_t count, mbstate_t*, locale_t);
+lconv* __libcpp_localeconv_l(locale_t);
+size_t __libcpp_mbsrtowcs_l(wchar_t* dest, const char** src, size_t len, mbstate_t*, locale_t);
+int __libcpp_snprintf_l(char* dest, size_t buff_size, locale_t, const char* format, ...);
+int __libcpp_asprintf_l(char** dest, locale_t, const char* format, ...);
+int __libcpp_sscanf_l(const char* dest, locale_t, const char* format, ...);
+
+// TODO: change these to reserved names
+float strtof_l(const char* str, char** str_end, locale_t);
+double strtod_l(const char* str, char** str_end, locale_t);
+long double strtold_l(const char* str, char** str_end, locale_t);
+long long strtoll_l(const char* str, char** str_end, locale_t);
+unsigned long long strtoull_l(const char* str, char** str_end, locale_t);
+
+locale_t newlocale(int category_mask, const char* locale, locale_t base);
+void freelocale(locale_t);
+
+int islower_l(int ch, locale_t);
+int isupper_l(int ch, locale_t);
+int isdigit_l(int ch, locale_t);
+int isxdigit_l(int ch, locale_t);
+int strcoll_l(const char* lhs, const char* rhs, locale_t);
+size_t strxfrm_l(char* dst, const char* src, size_t n, locale_t);
+int wcscoll_l(const char* lhs, const char* rhs, locale_t);
+size_t wcsxfrm_l(wchar_t* dst, const wchar_t* src, size_t n, locale_t);
+int toupper_l(int ch, locale_t);
+int tolower_l(int ch, locale_t);
+int iswspace_l(wint_t ch, locale_t);
+int iswprint_l(wint_t ch, locale_t);
+int iswcntrl_l(wint_t ch, locale_t);
+int iswupper_l(wint_t ch, locale_t);
+int iswlower_l(wint_t ch, locale_t);
+int iswalpha_l(wint_t ch, locale_t);
+int iswblank_l(wint_t ch, locale_t);
+int iswdigit_l(wint_t ch, locale_t);
+int iswpunct_l(wint_t ch, locale_t);
+int iswxdigit_l(wint_t ch, locale_t);
+wint_t towupper_l(wint_t ch, locale_t);
+wint_t towlower_l(wint_t ch, locale_t);
+size_t strftime_l(char* str, size_t len, const char* format, const tm*, locale_t);
+
+
+These functions are equivalent to their C counterparts,
+except that locale_t is used instead of the current global locale.
+
+The variadic functions may be implemented as templates with a parameter pack instead of variadic functions.
+*/
+
+#endif // _LIBCPP___LOCALE_DIR_LOCALE_BASE_API_H
diff --git a/third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_defaults.h b/third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_defaults.h
index 38d36f0aa..01a830076 100644
--- a/third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_defaults.h
+++ b/third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_defaults.h
@@ -14,23 +14,25 @@
 #ifndef _LIBCPP___LOCALE_LOCALE_BASE_API_BSD_LOCALE_DEFAULTS_H
 #define _LIBCPP___LOCALE_LOCALE_BASE_API_BSD_LOCALE_DEFAULTS_H
 
+#include <__config>
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#define __libcpp_mb_cur_max_l(loc)                          MB_CUR_MAX_L(loc)
-#define __libcpp_btowc_l(ch, loc)                           btowc_l(ch, loc)
-#define __libcpp_wctob_l(wch, loc)                          wctob_l(wch, loc)
-#define __libcpp_wcsnrtombs_l(dst, src, nwc, len, ps, loc)  wcsnrtombs_l(dst, src, nwc, len, ps, loc)
-#define __libcpp_wcrtomb_l(src, wc, ps, loc)                wcrtomb_l(src, wc, ps, loc)
-#define __libcpp_mbsnrtowcs_l(dst, src, nms, len, ps, loc)  mbsnrtowcs_l(dst, src, nms, len, ps, loc)
-#define __libcpp_mbrtowc_l(pwc, s, n, ps, l)                mbrtowc_l(pwc, s, n, ps, l)
-#define __libcpp_mbtowc_l(pwc, pmb, max, l)                 mbtowc_l(pwc, pmb, max, l)
-#define __libcpp_mbrlen_l(s, n, ps, l)                      mbrlen_l(s, n, ps, l)
-#define __libcpp_localeconv_l(l)                            localeconv_l(l)
-#define __libcpp_mbsrtowcs_l(dest, src, len, ps, l)         mbsrtowcs_l(dest, src, len, ps, l)
-#define __libcpp_snprintf_l(...)                            snprintf_l(__VA_ARGS__)
-#define __libcpp_asprintf_l(...)                            asprintf_l(__VA_ARGS__)
-#define __libcpp_sscanf_l(...)                              sscanf_l(__VA_ARGS__)
+#define __libcpp_mb_cur_max_l(loc) MB_CUR_MAX_L(loc)
+#define __libcpp_btowc_l(ch, loc) btowc_l(ch, loc)
+#define __libcpp_wctob_l(wch, loc) wctob_l(wch, loc)
+#define __libcpp_wcsnrtombs_l(dst, src, nwc, len, ps, loc) wcsnrtombs_l(dst, src, nwc, len, ps, loc)
+#define __libcpp_wcrtomb_l(src, wc, ps, loc) wcrtomb_l(src, wc, ps, loc)
+#define __libcpp_mbsnrtowcs_l(dst, src, nms, len, ps, loc) mbsnrtowcs_l(dst, src, nms, len, ps, loc)
+#define __libcpp_mbrtowc_l(pwc, s, n, ps, l) mbrtowc_l(pwc, s, n, ps, l)
+#define __libcpp_mbtowc_l(pwc, pmb, max, l) mbtowc_l(pwc, pmb, max, l)
+#define __libcpp_mbrlen_l(s, n, ps, l) mbrlen_l(s, n, ps, l)
+#define __libcpp_localeconv_l(l) localeconv_l(l)
+#define __libcpp_mbsrtowcs_l(dest, src, len, ps, l) mbsrtowcs_l(dest, src, len, ps, l)
+#define __libcpp_snprintf_l(...) snprintf_l(__VA_ARGS__)
+#define __libcpp_asprintf_l(...) asprintf_l(__VA_ARGS__)
+#define __libcpp_sscanf_l(...) sscanf_l(__VA_ARGS__)
 
 #endif // _LIBCPP___LOCALE_LOCALE_BASE_API_BSD_LOCALE_DEFAULTS_H
diff --git a/third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_fallbacks.h b/third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_fallbacks.h
index 7776a744d..76b94287c 100644
--- a/third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_fallbacks.h
+++ b/third_party/libcxx/__locale_dir/locale_base_api/bsd_locale_fallbacks.h
@@ -28,119 +28,97 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-inline _LIBCPP_INLINE_VISIBILITY
-decltype(MB_CUR_MAX) __libcpp_mb_cur_max_l(locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return MB_CUR_MAX;
+inline _LIBCPP_HIDE_FROM_ABI decltype(MB_CUR_MAX) __libcpp_mb_cur_max_l(locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return MB_CUR_MAX;
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-inline _LIBCPP_INLINE_VISIBILITY
-wint_t __libcpp_btowc_l(int __c, locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return btowc(__c);
+inline _LIBCPP_HIDE_FROM_ABI wint_t __libcpp_btowc_l(int __c, locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return btowc(__c);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-int __libcpp_wctob_l(wint_t __c, locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return wctob(__c);
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_wctob_l(wint_t __c, locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return wctob(__c);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-size_t __libcpp_wcsnrtombs_l(char *__dest, const wchar_t **__src, size_t __nwc,
-                         size_t __len, mbstate_t *__ps, locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return wcsnrtombs(__dest, __src, __nwc, __len, __ps);
+inline _LIBCPP_HIDE_FROM_ABI size_t
+__libcpp_wcsnrtombs_l(char* __dest, const wchar_t** __src, size_t __nwc, size_t __len, mbstate_t* __ps, locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return wcsnrtombs(__dest, __src, __nwc, __len, __ps);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-size_t __libcpp_wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return wcrtomb(__s, __wc, __ps);
+inline _LIBCPP_HIDE_FROM_ABI size_t __libcpp_wcrtomb_l(char* __s, wchar_t __wc, mbstate_t* __ps, locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return wcrtomb(__s, __wc, __ps);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-size_t __libcpp_mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms,
-                      size_t __len, mbstate_t *__ps, locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return mbsnrtowcs(__dest, __src, __nms, __len, __ps);
+inline _LIBCPP_HIDE_FROM_ABI size_t
+__libcpp_mbsnrtowcs_l(wchar_t* __dest, const char** __src, size_t __nms, size_t __len, mbstate_t* __ps, locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return mbsnrtowcs(__dest, __src, __nms, __len, __ps);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-size_t __libcpp_mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
-                   mbstate_t *__ps, locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return mbrtowc(__pwc, __s, __n, __ps);
+inline _LIBCPP_HIDE_FROM_ABI size_t
+__libcpp_mbrtowc_l(wchar_t* __pwc, const char* __s, size_t __n, mbstate_t* __ps, locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return mbrtowc(__pwc, __s, __n, __ps);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-int __libcpp_mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return mbtowc(__pwc, __pmb, __max);
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_mbtowc_l(wchar_t* __pwc, const char* __pmb, size_t __max, locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return mbtowc(__pwc, __pmb, __max);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-size_t __libcpp_mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return mbrlen(__s, __n, __ps);
+inline _LIBCPP_HIDE_FROM_ABI size_t __libcpp_mbrlen_l(const char* __s, size_t __n, mbstate_t* __ps, locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return mbrlen(__s, __n, __ps);
 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
-inline _LIBCPP_INLINE_VISIBILITY
-lconv *__libcpp_localeconv_l(locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return localeconv();
+inline _LIBCPP_HIDE_FROM_ABI lconv* __libcpp_localeconv_l(locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return localeconv();
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-inline _LIBCPP_INLINE_VISIBILITY
-size_t __libcpp_mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len,
-                     mbstate_t *__ps, locale_t __l)
-{
-    __libcpp_locale_guard __current(__l);
-    return mbsrtowcs(__dest, __src, __len, __ps);
+inline _LIBCPP_HIDE_FROM_ABI size_t
+__libcpp_mbsrtowcs_l(wchar_t* __dest, const char** __src, size_t __len, mbstate_t* __ps, locale_t __l) {
+  __libcpp_locale_guard __current(__l);
+  return mbsrtowcs(__dest, __src, __len, __ps);
 }
 #endif
 
-inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 4, 5)
-int __libcpp_snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...) {
-    va_list __va;
-    va_start(__va, __format);
-    __libcpp_locale_guard __current(__l);
-    int __res = vsnprintf(__s, __n, __format, __va);
-    va_end(__va);
-    return __res;
+inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 4, 5) int __libcpp_snprintf_l(
+    char* __s, size_t __n, locale_t __l, const char* __format, ...) {
+  va_list __va;
+  va_start(__va, __format);
+  __libcpp_locale_guard __current(__l);
+  int __res = vsnprintf(__s, __n, __format, __va);
+  va_end(__va);
+  return __res;
 }
 
-inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4)
-int __libcpp_asprintf_l(char **__s, locale_t __l, const char *__format, ...) {
-    va_list __va;
-    va_start(__va, __format);
-    __libcpp_locale_guard __current(__l);
-    int __res = vasprintf(__s, __format, __va);
-    va_end(__va);
-    return __res;
+inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __libcpp_asprintf_l(
+    char** __s, locale_t __l, const char* __format, ...) {
+  va_list __va;
+  va_start(__va, __format);
+  __libcpp_locale_guard __current(__l);
+  int __res = vasprintf(__s, __format, __va);
+  va_end(__va);
+  return __res;
 }
 
-inline _LIBCPP_ATTRIBUTE_FORMAT(__scanf__, 3, 4)
-int __libcpp_sscanf_l(const char *__s, locale_t __l, const char *__format, ...) {
-    va_list __va;
-    va_start(__va, __format);
-    __libcpp_locale_guard __current(__l);
-    int __res = vsscanf(__s, __format, __va);
-    va_end(__va);
-    return __res;
+inline _LIBCPP_ATTRIBUTE_FORMAT(__scanf__, 3, 4) int __libcpp_sscanf_l(
+    const char* __s, locale_t __l, const char* __format, ...) {
+  va_list __va;
+  va_start(__va, __format);
+  __libcpp_locale_guard __current(__l);
+  int __res = vsscanf(__s, __format, __va);
+  va_end(__va);
+  return __res;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__locale_dir/locale_base_api/locale_guard.h b/third_party/libcxx/__locale_dir/locale_base_api/locale_guard.h
index 0e2e91af7..2baacb51c 100644
--- a/third_party/libcxx/__locale_dir/locale_base_api/locale_guard.h
+++ b/third_party/libcxx/__locale_dir/locale_base_api/locale_guard.h
@@ -10,6 +10,7 @@
 #define _LIBCPP___LOCALE_LOCALE_BASE_API_LOCALE_GUARD_H
 
 #include <__config>
+#include <__locale> // for locale_t
 #include <clocale>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -20,57 +21,55 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_LOCALE__L_EXTENSIONS)
 struct __libcpp_locale_guard {
-  _LIBCPP_INLINE_VISIBILITY __libcpp_locale_guard(locale_t& __loc) : __old_loc_(uselocale(__loc)) {}
+  _LIBCPP_HIDE_FROM_ABI __libcpp_locale_guard(locale_t& __loc) : __old_loc_(uselocale(__loc)) {}
 
-  _LIBCPP_INLINE_VISIBILITY ~__libcpp_locale_guard() {
+  _LIBCPP_HIDE_FROM_ABI ~__libcpp_locale_guard() {
     if (__old_loc_)
       uselocale(__old_loc_);
   }
 
   locale_t __old_loc_;
 
-private:
-  __libcpp_locale_guard(__libcpp_locale_guard const&);
-  __libcpp_locale_guard& operator=(__libcpp_locale_guard const&);
+  __libcpp_locale_guard(__libcpp_locale_guard const&)            = delete;
+  __libcpp_locale_guard& operator=(__libcpp_locale_guard const&) = delete;
 };
 #elif defined(_LIBCPP_MSVCRT_LIKE)
 struct __libcpp_locale_guard {
-    __libcpp_locale_guard(locale_t __l) :
-        __status(_configthreadlocale(_ENABLE_PER_THREAD_LOCALE)) {
-      // Setting the locale can be expensive even when the locale given is
-      // already the current locale, so do an explicit check to see if the
-      // current locale is already the one we want.
-      const char* __lc = __setlocale(nullptr);
-      // If every category is the same, the locale string will simply be the
-      // locale name, otherwise it will be a semicolon-separated string listing
-      // each category.  In the second case, we know at least one category won't
-      // be what we want, so we only have to check the first case.
-      if (_VSTD::strcmp(__l.__get_locale(), __lc) != 0) {
-        __locale_all = _strdup(__lc);
-        if (__locale_all == nullptr)
-          __throw_bad_alloc();
-        __setlocale(__l.__get_locale());
-      }
-    }
-    ~__libcpp_locale_guard() {
-      // The CRT documentation doesn't explicitly say, but setlocale() does the
-      // right thing when given a semicolon-separated list of locale settings
-      // for the different categories in the same format as returned by
-      // setlocale(LC_ALL, nullptr).
-      if (__locale_all != nullptr) {
-        __setlocale(__locale_all);
-        free(__locale_all);
-      }
-      _configthreadlocale(__status);
-    }
-    static const char* __setlocale(const char* __locale) {
-      const char* __new_locale = setlocale(LC_ALL, __locale);
-      if (__new_locale == nullptr)
+  __libcpp_locale_guard(locale_t __l) : __status(_configthreadlocale(_ENABLE_PER_THREAD_LOCALE)) {
+    // Setting the locale can be expensive even when the locale given is
+    // already the current locale, so do an explicit check to see if the
+    // current locale is already the one we want.
+    const char* __lc = __setlocale(nullptr);
+    // If every category is the same, the locale string will simply be the
+    // locale name, otherwise it will be a semicolon-separated string listing
+    // each category.  In the second case, we know at least one category won't
+    // be what we want, so we only have to check the first case.
+    if (std::strcmp(__l.__get_locale(), __lc) != 0) {
+      __locale_all = _strdup(__lc);
+      if (__locale_all == nullptr)
         __throw_bad_alloc();
-      return __new_locale;
+      __setlocale(__l.__get_locale());
     }
-    int __status;
-    char* __locale_all = nullptr;
+  }
+  ~__libcpp_locale_guard() {
+    // The CRT documentation doesn't explicitly say, but setlocale() does the
+    // right thing when given a semicolon-separated list of locale settings
+    // for the different categories in the same format as returned by
+    // setlocale(LC_ALL, nullptr).
+    if (__locale_all != nullptr) {
+      __setlocale(__locale_all);
+      free(__locale_all);
+    }
+    _configthreadlocale(__status);
+  }
+  static const char* __setlocale(const char* __locale) {
+    const char* __new_locale = setlocale(LC_ALL, __locale);
+    if (__new_locale == nullptr)
+      __throw_bad_alloc();
+    return __new_locale;
+  }
+  int __status;
+  char* __locale_all = nullptr;
 };
 #endif
 
diff --git a/third_party/libcxx/__math/abs.h b/third_party/libcxx/__math/abs.h
new file mode 100644
index 000000000..ab82a2800
--- /dev/null
+++ b/third_party/libcxx/__math/abs.h
@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_ABS_H
+#define _LIBCPP___MATH_ABS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// fabs
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float fabs(float __x) _NOEXCEPT { return __builtin_fabsf(__x); }
+
+template <class = int>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI double fabs(double __x) _NOEXCEPT {
+  return __builtin_fabs(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double fabs(long double __x) _NOEXCEPT {
+  return __builtin_fabsl(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI double fabs(_A1 __x) _NOEXCEPT {
+  return __builtin_fabs((double)__x);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_ABS_H
diff --git a/third_party/libcxx/__math/copysign.h b/third_party/libcxx/__math/copysign.h
new file mode 100644
index 000000000..b38690bb5
--- /dev/null
+++ b/third_party/libcxx/__math/copysign.h
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_COPYSIGN_H
+#define _LIBCPP___MATH_COPYSIGN_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/promote.h>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// copysign
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float copysign(float __x, float __y) _NOEXCEPT {
+  return ::__builtin_copysignf(__x, __y);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double copysign(long double __x, long double __y) _NOEXCEPT {
+  return ::__builtin_copysignl(__x, __y);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type copysign(_A1 __x, _A2 __y) _NOEXCEPT {
+  return ::__builtin_copysign(__x, __y);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_COPYSIGN_H
diff --git a/third_party/libcxx/__math/error_functions.h b/third_party/libcxx/__math/error_functions.h
new file mode 100644
index 000000000..6b528bb29
--- /dev/null
+++ b/third_party/libcxx/__math/error_functions.h
@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_ERROR_FUNCTIONS_H
+#define _LIBCPP___MATH_ERROR_FUNCTIONS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// erf
+
+inline _LIBCPP_HIDE_FROM_ABI float erf(float __x) _NOEXCEPT { return __builtin_erff(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double erf(double __x) _NOEXCEPT {
+  return __builtin_erf(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double erf(long double __x) _NOEXCEPT { return __builtin_erfl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double erf(_A1 __x) _NOEXCEPT {
+  return __builtin_erf((double)__x);
+}
+
+// erfc
+
+inline _LIBCPP_HIDE_FROM_ABI float erfc(float __x) _NOEXCEPT { return __builtin_erfcf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double erfc(double __x) _NOEXCEPT {
+  return __builtin_erfc(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double erfc(long double __x) _NOEXCEPT { return __builtin_erfcl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double erfc(_A1 __x) _NOEXCEPT {
+  return __builtin_erfc((double)__x);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_ERROR_FUNCTIONS_H
diff --git a/third_party/libcxx/__math/exponential_functions.h b/third_party/libcxx/__math/exponential_functions.h
new file mode 100644
index 000000000..109c33499
--- /dev/null
+++ b/third_party/libcxx/__math/exponential_functions.h
@@ -0,0 +1,171 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_EXPONENTIAL_FUNCTIONS_H
+#define _LIBCPP___MATH_EXPONENTIAL_FUNCTIONS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// exp
+
+inline _LIBCPP_HIDE_FROM_ABI float exp(float __x) _NOEXCEPT { return __builtin_expf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double exp(double __x) _NOEXCEPT {
+  return __builtin_exp(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double exp(long double __x) _NOEXCEPT { return __builtin_expl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double exp(_A1 __x) _NOEXCEPT {
+  return __builtin_exp((double)__x);
+}
+
+// frexp
+
+inline _LIBCPP_HIDE_FROM_ABI float frexp(float __x, int* __e) _NOEXCEPT { return __builtin_frexpf(__x, __e); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double frexp(double __x, int* __e) _NOEXCEPT {
+  return __builtin_frexp(__x, __e);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double frexp(long double __x, int* __e) _NOEXCEPT {
+  return __builtin_frexpl(__x, __e);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double frexp(_A1 __x, int* __e) _NOEXCEPT {
+  return __builtin_frexp((double)__x, __e);
+}
+
+// ldexp
+
+inline _LIBCPP_HIDE_FROM_ABI float ldexp(float __x, int __e) _NOEXCEPT { return __builtin_ldexpf(__x, __e); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double ldexp(double __x, int __e) _NOEXCEPT {
+  return __builtin_ldexp(__x, __e);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double ldexp(long double __x, int __e) _NOEXCEPT {
+  return __builtin_ldexpl(__x, __e);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double ldexp(_A1 __x, int __e) _NOEXCEPT {
+  return __builtin_ldexp((double)__x, __e);
+}
+
+// exp2
+
+inline _LIBCPP_HIDE_FROM_ABI float exp2(float __x) _NOEXCEPT { return __builtin_exp2f(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double exp2(double __x) _NOEXCEPT {
+  return __builtin_exp2(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double exp2(long double __x) _NOEXCEPT { return __builtin_exp2l(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double exp2(_A1 __x) _NOEXCEPT {
+  return __builtin_exp2((double)__x);
+}
+
+// expm1
+
+inline _LIBCPP_HIDE_FROM_ABI float expm1(float __x) _NOEXCEPT { return __builtin_expm1f(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double expm1(double __x) _NOEXCEPT {
+  return __builtin_expm1(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double expm1(long double __x) _NOEXCEPT { return __builtin_expm1l(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double expm1(_A1 __x) _NOEXCEPT {
+  return __builtin_expm1((double)__x);
+}
+
+// scalbln
+
+inline _LIBCPP_HIDE_FROM_ABI float scalbln(float __x, long __y) _NOEXCEPT { return __builtin_scalblnf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double scalbln(double __x, long __y) _NOEXCEPT {
+  return __builtin_scalbln(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double scalbln(long double __x, long __y) _NOEXCEPT {
+  return __builtin_scalblnl(__x, __y);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double scalbln(_A1 __x, long __y) _NOEXCEPT {
+  return __builtin_scalbln((double)__x, __y);
+}
+
+// scalbn
+
+inline _LIBCPP_HIDE_FROM_ABI float scalbn(float __x, int __y) _NOEXCEPT { return __builtin_scalbnf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double scalbn(double __x, int __y) _NOEXCEPT {
+  return __builtin_scalbn(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double scalbn(long double __x, int __y) _NOEXCEPT {
+  return __builtin_scalbnl(__x, __y);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double scalbn(_A1 __x, int __y) _NOEXCEPT {
+  return __builtin_scalbn((double)__x, __y);
+}
+
+// pow
+
+inline _LIBCPP_HIDE_FROM_ABI float pow(float __x, float __y) _NOEXCEPT { return __builtin_powf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double pow(double __x, double __y) _NOEXCEPT {
+  return __builtin_pow(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double pow(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_powl(__x, __y);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type pow(_A1 __x, _A2 __y) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2>::type;
+  static_assert(!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value), "");
+  return __math::pow((__result_type)__x, (__result_type)__y);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_EXPONENTIAL_FUNCTIONS_H
diff --git a/third_party/libcxx/__math/fdim.h b/third_party/libcxx/__math/fdim.h
new file mode 100644
index 000000000..dc1b4ecc0
--- /dev/null
+++ b/third_party/libcxx/__math/fdim.h
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_FDIM_H
+#define _LIBCPP___MATH_FDIM_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+inline _LIBCPP_HIDE_FROM_ABI float fdim(float __x, float __y) _NOEXCEPT { return __builtin_fdimf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double fdim(double __x, double __y) _NOEXCEPT {
+  return __builtin_fdim(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double fdim(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_fdiml(__x, __y);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type fdim(_A1 __x, _A2 __y) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2>::type;
+  static_assert(!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value), "");
+  return __math::fdim((__result_type)__x, (__result_type)__y);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_FDIM_H
diff --git a/third_party/libcxx/__math/fma.h b/third_party/libcxx/__math/fma.h
new file mode 100644
index 000000000..6ba7a5a2d
--- /dev/null
+++ b/third_party/libcxx/__math/fma.h
@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_FMA_H
+#define _LIBCPP___MATH_FMA_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+inline _LIBCPP_HIDE_FROM_ABI float fma(float __x, float __y, float __z) _NOEXCEPT {
+  return __builtin_fmaf(__x, __y, __z);
+}
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double fma(double __x, double __y, double __z) _NOEXCEPT {
+  return __builtin_fma(__x, __y, __z);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double fma(long double __x, long double __y, long double __z) _NOEXCEPT {
+  return __builtin_fmal(__x, __y, __z);
+}
+
+template <class _A1,
+          class _A2,
+          class _A3,
+          __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value && is_arithmetic<_A3>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2, _A3>::type fma(_A1 __x, _A2 __y, _A3 __z) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2, _A3>::type;
+  static_assert(
+      !(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value && _IsSame<_A3, __result_type>::value),
+      "");
+  return __builtin_fma((__result_type)__x, (__result_type)__y, (__result_type)__z);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_FMA_H
diff --git a/third_party/libcxx/__math/gamma.h b/third_party/libcxx/__math/gamma.h
new file mode 100644
index 000000000..693e111a8
--- /dev/null
+++ b/third_party/libcxx/__math/gamma.h
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_GAMMA_H
+#define _LIBCPP___MATH_GAMMA_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// lgamma
+
+inline _LIBCPP_HIDE_FROM_ABI float lgamma(float __x) _NOEXCEPT { return __builtin_lgammaf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double lgamma(double __x) _NOEXCEPT {
+  return __builtin_lgamma(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double lgamma(long double __x) _NOEXCEPT { return __builtin_lgammal(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double lgamma(_A1 __x) _NOEXCEPT {
+  return __builtin_lgamma((double)__x);
+}
+
+// nan
+
+// tgamma
+
+inline _LIBCPP_HIDE_FROM_ABI float tgamma(float __x) _NOEXCEPT { return __builtin_tgammaf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double tgamma(double __x) _NOEXCEPT {
+  return __builtin_tgamma(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double tgamma(long double __x) _NOEXCEPT { return __builtin_tgammal(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double tgamma(_A1 __x) _NOEXCEPT {
+  return __builtin_tgamma((double)__x);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_GAMMA_H
diff --git a/third_party/libcxx/__math/hyperbolic_functions.h b/third_party/libcxx/__math/hyperbolic_functions.h
new file mode 100644
index 000000000..78832bae7
--- /dev/null
+++ b/third_party/libcxx/__math/hyperbolic_functions.h
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_HYPERBOLIC_FUNCTIONS_H
+#define _LIBCPP___MATH_HYPERBOLIC_FUNCTIONS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// cosh
+
+inline _LIBCPP_HIDE_FROM_ABI float cosh(float __x) _NOEXCEPT { return __builtin_coshf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double cosh(double __x) _NOEXCEPT {
+  return __builtin_cosh(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double cosh(long double __x) _NOEXCEPT { return __builtin_coshl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double cosh(_A1 __x) _NOEXCEPT {
+  return __builtin_cosh((double)__x);
+}
+
+// sinh
+
+inline _LIBCPP_HIDE_FROM_ABI float sinh(float __x) _NOEXCEPT { return __builtin_sinhf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double sinh(double __x) _NOEXCEPT {
+  return __builtin_sinh(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double sinh(long double __x) _NOEXCEPT { return __builtin_sinhl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double sinh(_A1 __x) _NOEXCEPT {
+  return __builtin_sinh((double)__x);
+}
+
+// tanh
+
+inline _LIBCPP_HIDE_FROM_ABI float tanh(float __x) _NOEXCEPT { return __builtin_tanhf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double tanh(double __x) _NOEXCEPT {
+  return __builtin_tanh(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double tanh(long double __x) _NOEXCEPT { return __builtin_tanhl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double tanh(_A1 __x) _NOEXCEPT {
+  return __builtin_tanh((double)__x);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_HYPERBOLIC_FUNCTIONS_H
diff --git a/third_party/libcxx/__math/hypot.h b/third_party/libcxx/__math/hypot.h
new file mode 100644
index 000000000..1bf193a9a
--- /dev/null
+++ b/third_party/libcxx/__math/hypot.h
@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_HYPOT_H
+#define _LIBCPP___MATH_HYPOT_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+inline _LIBCPP_HIDE_FROM_ABI float hypot(float __x, float __y) _NOEXCEPT { return __builtin_hypotf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double hypot(double __x, double __y) _NOEXCEPT {
+  return __builtin_hypot(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double hypot(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_hypotl(__x, __y);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type hypot(_A1 __x, _A2 __y) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2>::type;
+  static_assert(!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value), "");
+  return __math::hypot((__result_type)__x, (__result_type)__y);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_HYPOT_H
diff --git a/third_party/libcxx/__math/inverse_hyperbolic_functions.h b/third_party/libcxx/__math/inverse_hyperbolic_functions.h
new file mode 100644
index 000000000..4660a58e4
--- /dev/null
+++ b/third_party/libcxx/__math/inverse_hyperbolic_functions.h
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_INVERSE_HYPERBOLIC_FUNCTIONS_H
+#define _LIBCPP___MATH_INVERSE_HYPERBOLIC_FUNCTIONS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// acosh
+
+inline _LIBCPP_HIDE_FROM_ABI float acosh(float __x) _NOEXCEPT { return __builtin_acoshf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double acosh(double __x) _NOEXCEPT {
+  return __builtin_acosh(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double acosh(long double __x) _NOEXCEPT { return __builtin_acoshl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double acosh(_A1 __x) _NOEXCEPT {
+  return __builtin_acosh((double)__x);
+}
+
+// asinh
+
+inline _LIBCPP_HIDE_FROM_ABI float asinh(float __x) _NOEXCEPT { return __builtin_asinhf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double asinh(double __x) _NOEXCEPT {
+  return __builtin_asinh(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double asinh(long double __x) _NOEXCEPT { return __builtin_asinhl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double asinh(_A1 __x) _NOEXCEPT {
+  return __builtin_asinh((double)__x);
+}
+
+// atanh
+
+inline _LIBCPP_HIDE_FROM_ABI float atanh(float __x) _NOEXCEPT { return __builtin_atanhf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double atanh(double __x) _NOEXCEPT {
+  return __builtin_atanh(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double atanh(long double __x) _NOEXCEPT { return __builtin_atanhl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double atanh(_A1 __x) _NOEXCEPT {
+  return __builtin_atanh((double)__x);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_INVERSE_HYPERBOLIC_FUNCTIONS_H
diff --git a/third_party/libcxx/__math/inverse_trigonometric_functions.h b/third_party/libcxx/__math/inverse_trigonometric_functions.h
new file mode 100644
index 000000000..cd98b46a6
--- /dev/null
+++ b/third_party/libcxx/__math/inverse_trigonometric_functions.h
@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_INVERSE_TRIGONOMETRIC_FUNCTIONS_H
+#define _LIBCPP___MATH_INVERSE_TRIGONOMETRIC_FUNCTIONS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// acos
+
+inline _LIBCPP_HIDE_FROM_ABI float acos(float __x) _NOEXCEPT { return __builtin_acosf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double acos(double __x) _NOEXCEPT {
+  return __builtin_acos(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double acos(long double __x) _NOEXCEPT { return __builtin_acosl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double acos(_A1 __x) _NOEXCEPT {
+  return __builtin_acos((double)__x);
+}
+
+// asin
+
+inline _LIBCPP_HIDE_FROM_ABI float asin(float __x) _NOEXCEPT { return __builtin_asinf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double asin(double __x) _NOEXCEPT {
+  return __builtin_asin(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double asin(long double __x) _NOEXCEPT { return __builtin_asinl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double asin(_A1 __x) _NOEXCEPT {
+  return __builtin_asin((double)__x);
+}
+
+// atan
+
+inline _LIBCPP_HIDE_FROM_ABI float atan(float __x) _NOEXCEPT { return __builtin_atanf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double atan(double __x) _NOEXCEPT {
+  return __builtin_atan(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double atan(long double __x) _NOEXCEPT { return __builtin_atanl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double atan(_A1 __x) _NOEXCEPT {
+  return __builtin_atan((double)__x);
+}
+
+// atan2
+
+inline _LIBCPP_HIDE_FROM_ABI float atan2(float __y, float __x) _NOEXCEPT { return __builtin_atan2f(__y, __x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double atan2(double __x, double __y) _NOEXCEPT {
+  return __builtin_atan2(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double atan2(long double __y, long double __x) _NOEXCEPT {
+  return __builtin_atan2l(__y, __x);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type atan2(_A1 __y, _A2 __x) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2>::type;
+  static_assert(!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value), "");
+  return __math::atan2((__result_type)__y, (__result_type)__x);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_INVERSE_TRIGONOMETRIC_FUNCTIONS_H
diff --git a/third_party/libcxx/__math/logarithms.h b/third_party/libcxx/__math/logarithms.h
new file mode 100644
index 000000000..5f5f94397
--- /dev/null
+++ b/third_party/libcxx/__math/logarithms.h
@@ -0,0 +1,124 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_LOGARITHMS_H
+#define _LIBCPP___MATH_LOGARITHMS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// log
+
+inline _LIBCPP_HIDE_FROM_ABI float log(float __x) _NOEXCEPT { return __builtin_logf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double log(double __x) _NOEXCEPT {
+  return __builtin_log(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double log(long double __x) _NOEXCEPT { return __builtin_logl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double log(_A1 __x) _NOEXCEPT {
+  return __builtin_log((double)__x);
+}
+
+// log10
+
+inline _LIBCPP_HIDE_FROM_ABI float log10(float __x) _NOEXCEPT { return __builtin_log10f(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double log10(double __x) _NOEXCEPT {
+  return __builtin_log10(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double log10(long double __x) _NOEXCEPT { return __builtin_log10l(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double log10(_A1 __x) _NOEXCEPT {
+  return __builtin_log10((double)__x);
+}
+
+// ilogb
+
+inline _LIBCPP_HIDE_FROM_ABI int ilogb(float __x) _NOEXCEPT { return __builtin_ilogbf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double ilogb(double __x) _NOEXCEPT {
+  return __builtin_ilogb(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI int ilogb(long double __x) _NOEXCEPT { return __builtin_ilogbl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI int ilogb(_A1 __x) _NOEXCEPT {
+  return __builtin_ilogb((double)__x);
+}
+
+// log1p
+
+inline _LIBCPP_HIDE_FROM_ABI float log1p(float __x) _NOEXCEPT { return __builtin_log1pf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double log1p(double __x) _NOEXCEPT {
+  return __builtin_log1p(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double log1p(long double __x) _NOEXCEPT { return __builtin_log1pl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double log1p(_A1 __x) _NOEXCEPT {
+  return __builtin_log1p((double)__x);
+}
+
+// log2
+
+inline _LIBCPP_HIDE_FROM_ABI float log2(float __x) _NOEXCEPT { return __builtin_log2f(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double log2(double __x) _NOEXCEPT {
+  return __builtin_log2(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double log2(long double __x) _NOEXCEPT { return __builtin_log2l(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double log2(_A1 __x) _NOEXCEPT {
+  return __builtin_log2((double)__x);
+}
+
+// logb
+
+inline _LIBCPP_HIDE_FROM_ABI float logb(float __x) _NOEXCEPT { return __builtin_logbf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double logb(double __x) _NOEXCEPT {
+  return __builtin_logb(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double logb(long double __x) _NOEXCEPT { return __builtin_logbl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double logb(_A1 __x) _NOEXCEPT {
+  return __builtin_logb((double)__x);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_LOGARITHMS_H
diff --git a/third_party/libcxx/__math/min_max.h b/third_party/libcxx/__math/min_max.h
new file mode 100644
index 000000000..27997b449
--- /dev/null
+++ b/third_party/libcxx/__math/min_max.h
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_MIN_MAX_H
+#define _LIBCPP___MATH_MIN_MAX_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// fmax
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float fmax(float __x, float __y) _NOEXCEPT {
+  return __builtin_fmaxf(__x, __y);
+}
+
+template <class = int>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI double fmax(double __x, double __y) _NOEXCEPT {
+  return __builtin_fmax(__x, __y);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double fmax(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_fmaxl(__x, __y);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type fmax(_A1 __x, _A2 __y) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2>::type;
+  static_assert(!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value), "");
+  return __math::fmax((__result_type)__x, (__result_type)__y);
+}
+
+// fmin
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float fmin(float __x, float __y) _NOEXCEPT {
+  return __builtin_fminf(__x, __y);
+}
+
+template <class = int>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI double fmin(double __x, double __y) _NOEXCEPT {
+  return __builtin_fmin(__x, __y);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double fmin(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_fminl(__x, __y);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type fmin(_A1 __x, _A2 __y) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2>::type;
+  static_assert(!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value), "");
+  return __math::fmin((__result_type)__x, (__result_type)__y);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_MIN_MAX_H
diff --git a/third_party/libcxx/__math/modulo.h b/third_party/libcxx/__math/modulo.h
new file mode 100644
index 000000000..c8ea506f3
--- /dev/null
+++ b/third_party/libcxx/__math/modulo.h
@@ -0,0 +1,63 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_MODULO_H
+#define _LIBCPP___MATH_MODULO_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// fmod
+
+inline _LIBCPP_HIDE_FROM_ABI float fmod(float __x, float __y) _NOEXCEPT { return __builtin_fmodf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double fmod(double __x, double __y) _NOEXCEPT {
+  return __builtin_fmod(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double fmod(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_fmodl(__x, __y);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type fmod(_A1 __x, _A2 __y) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2>::type;
+  static_assert(!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value), "");
+  return __math::fmod((__result_type)__x, (__result_type)__y);
+}
+
+// modf
+
+inline _LIBCPP_HIDE_FROM_ABI float modf(float __x, float* __y) _NOEXCEPT { return __builtin_modff(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double modf(double __x, double* __y) _NOEXCEPT {
+  return __builtin_modf(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double modf(long double __x, long double* __y) _NOEXCEPT {
+  return __builtin_modfl(__x, __y);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_MODULO_H
diff --git a/third_party/libcxx/__math/remainder.h b/third_party/libcxx/__math/remainder.h
new file mode 100644
index 000000000..0fbf0b8ef
--- /dev/null
+++ b/third_party/libcxx/__math/remainder.h
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_REMAINDER_H
+#define _LIBCPP___MATH_REMAINDER_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/promote.h>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// remainder
+
+inline _LIBCPP_HIDE_FROM_ABI float remainder(float __x, float __y) _NOEXCEPT { return __builtin_remainderf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double remainder(double __x, double __y) _NOEXCEPT {
+  return __builtin_remainder(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double remainder(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_remainderl(__x, __y);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type remainder(_A1 __x, _A2 __y) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2>::type;
+  static_assert(!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value), "");
+  return __math::remainder((__result_type)__x, (__result_type)__y);
+}
+
+// remquo
+
+inline _LIBCPP_HIDE_FROM_ABI float remquo(float __x, float __y, int* __z) _NOEXCEPT {
+  return __builtin_remquof(__x, __y, __z);
+}
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double remquo(double __x, double __y, int* __z) _NOEXCEPT {
+  return __builtin_remquo(__x, __y, __z);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double remquo(long double __x, long double __y, int* __z) _NOEXCEPT {
+  return __builtin_remquol(__x, __y, __z);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type remquo(_A1 __x, _A2 __y, int* __z) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2>::type;
+  static_assert(!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value), "");
+  return __math::remquo((__result_type)__x, (__result_type)__y, __z);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_REMAINDER_H
diff --git a/third_party/libcxx/__math/roots.h b/third_party/libcxx/__math/roots.h
new file mode 100644
index 000000000..359fd747c
--- /dev/null
+++ b/third_party/libcxx/__math/roots.h
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_ROOTS_H
+#define _LIBCPP___MATH_ROOTS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// sqrt
+
+inline _LIBCPP_HIDE_FROM_ABI float sqrt(float __x) _NOEXCEPT { return __builtin_sqrtf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double sqrt(double __x) _NOEXCEPT {
+  return __builtin_sqrt(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double sqrt(long double __x) _NOEXCEPT { return __builtin_sqrtl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double sqrt(_A1 __x) _NOEXCEPT {
+  return __builtin_sqrt((double)__x);
+}
+
+// cbrt
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float cbrt(float __x) _NOEXCEPT { return __builtin_cbrtf(__x); }
+
+template <class = int>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI double cbrt(double __x) _NOEXCEPT {
+  return __builtin_cbrt(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double cbrt(long double __x) _NOEXCEPT {
+  return __builtin_cbrtl(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI double cbrt(_A1 __x) _NOEXCEPT {
+  return __builtin_cbrt((double)__x);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_ROOTS_H
diff --git a/third_party/libcxx/__math/rounding_functions.h b/third_party/libcxx/__math/rounding_functions.h
new file mode 100644
index 000000000..f7246ba7f
--- /dev/null
+++ b/third_party/libcxx/__math/rounding_functions.h
@@ -0,0 +1,245 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_ROUNDING_FUNCTIONS_H
+#define _LIBCPP___MATH_ROUNDING_FUNCTIONS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// ceil
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float ceil(float __x) _NOEXCEPT { return __builtin_ceilf(__x); }
+
+template <class = int>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI double ceil(double __x) _NOEXCEPT {
+  return __builtin_ceil(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double ceil(long double __x) _NOEXCEPT {
+  return __builtin_ceill(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI double ceil(_A1 __x) _NOEXCEPT {
+  return __builtin_ceil((double)__x);
+}
+
+// floor
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float floor(float __x) _NOEXCEPT { return __builtin_floorf(__x); }
+
+template <class = int>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI double floor(double __x) _NOEXCEPT {
+  return __builtin_floor(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double floor(long double __x) _NOEXCEPT {
+  return __builtin_floorl(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI double floor(_A1 __x) _NOEXCEPT {
+  return __builtin_floor((double)__x);
+}
+
+// llrint
+
+inline _LIBCPP_HIDE_FROM_ABI long long llrint(float __x) _NOEXCEPT { return __builtin_llrintf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI long long llrint(double __x) _NOEXCEPT {
+  return __builtin_llrint(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long long llrint(long double __x) _NOEXCEPT { return __builtin_llrintl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI long long llrint(_A1 __x) _NOEXCEPT {
+  return __builtin_llrint((double)__x);
+}
+
+// llround
+
+inline _LIBCPP_HIDE_FROM_ABI long long llround(float __x) _NOEXCEPT { return __builtin_llroundf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI long long llround(double __x) _NOEXCEPT {
+  return __builtin_llround(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long long llround(long double __x) _NOEXCEPT { return __builtin_llroundl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI long long llround(_A1 __x) _NOEXCEPT {
+  return __builtin_llround((double)__x);
+}
+
+// lrint
+
+inline _LIBCPP_HIDE_FROM_ABI long lrint(float __x) _NOEXCEPT { return __builtin_lrintf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI long lrint(double __x) _NOEXCEPT {
+  return __builtin_lrint(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long lrint(long double __x) _NOEXCEPT { return __builtin_lrintl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI long lrint(_A1 __x) _NOEXCEPT {
+  return __builtin_lrint((double)__x);
+}
+
+// lround
+
+inline _LIBCPP_HIDE_FROM_ABI long lround(float __x) _NOEXCEPT { return __builtin_lroundf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI long lround(double __x) _NOEXCEPT {
+  return __builtin_lround(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long lround(long double __x) _NOEXCEPT { return __builtin_lroundl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI long lround(_A1 __x) _NOEXCEPT {
+  return __builtin_lround((double)__x);
+}
+
+// nearbyint
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float nearbyint(float __x) _NOEXCEPT {
+  return __builtin_nearbyintf(__x);
+}
+
+template <class = int>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI double nearbyint(double __x) _NOEXCEPT {
+  return __builtin_nearbyint(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double nearbyint(long double __x) _NOEXCEPT {
+  return __builtin_nearbyintl(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI double nearbyint(_A1 __x) _NOEXCEPT {
+  return __builtin_nearbyint((double)__x);
+}
+
+// nextafter
+
+inline _LIBCPP_HIDE_FROM_ABI float nextafter(float __x, float __y) _NOEXCEPT { return __builtin_nextafterf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double nextafter(double __x, double __y) _NOEXCEPT {
+  return __builtin_nextafter(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double nextafter(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_nextafterl(__x, __y);
+}
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __promote<_A1, _A2>::type nextafter(_A1 __x, _A2 __y) _NOEXCEPT {
+  using __result_type = typename __promote<_A1, _A2>::type;
+  static_assert(!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value), "");
+  return __math::nextafter((__result_type)__x, (__result_type)__y);
+}
+
+// nexttoward
+
+inline _LIBCPP_HIDE_FROM_ABI float nexttoward(float __x, long double __y) _NOEXCEPT {
+  return __builtin_nexttowardf(__x, __y);
+}
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double nexttoward(double __x, long double __y) _NOEXCEPT {
+  return __builtin_nexttoward(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double nexttoward(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_nexttowardl(__x, __y);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double nexttoward(_A1 __x, long double __y) _NOEXCEPT {
+  return __builtin_nexttoward((double)__x, __y);
+}
+
+// rint
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float rint(float __x) _NOEXCEPT { return __builtin_rintf(__x); }
+
+template <class = int>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI double rint(double __x) _NOEXCEPT {
+  return __builtin_rint(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double rint(long double __x) _NOEXCEPT {
+  return __builtin_rintl(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI double rint(_A1 __x) _NOEXCEPT {
+  return __builtin_rint((double)__x);
+}
+
+// round
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float round(float __x) _NOEXCEPT { return __builtin_round(__x); }
+
+template <class = int>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI double round(double __x) _NOEXCEPT {
+  return __builtin_round(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double round(long double __x) _NOEXCEPT {
+  return __builtin_roundl(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI double round(_A1 __x) _NOEXCEPT {
+  return __builtin_round((double)__x);
+}
+
+// trunc
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float trunc(float __x) _NOEXCEPT { return __builtin_trunc(__x); }
+
+template <class = int>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI double trunc(double __x) _NOEXCEPT {
+  return __builtin_trunc(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double trunc(long double __x) _NOEXCEPT {
+  return __builtin_truncl(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI double trunc(_A1 __x) _NOEXCEPT {
+  return __builtin_trunc((double)__x);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_ROUNDING_FUNCTIONS_H
diff --git a/third_party/libcxx/__math/special_functions.h b/third_party/libcxx/__math/special_functions.h
new file mode 100644
index 000000000..0b1c753a6
--- /dev/null
+++ b/third_party/libcxx/__math/special_functions.h
@@ -0,0 +1,84 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_SPECIAL_FUNCTIONS_H
+#define _LIBCPP___MATH_SPECIAL_FUNCTIONS_H
+
+#include <__config>
+#include <__math/copysign.h>
+#include <__math/traits.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 17
+
+template <class _Real>
+_LIBCPP_HIDE_FROM_ABI _Real __hermite(unsigned __n, _Real __x) {
+  // The Hermite polynomial H_n(x).
+  // The implementation is based on the recurrence formula: H_{n+1}(x) = 2x H_n(x) - 2n H_{n-1}.
+  // Press, William H., et al. Numerical recipes 3rd edition: The art of scientific computing.
+  // Cambridge university press, 2007, p. 183.
+
+  // NOLINTBEGIN(readability-identifier-naming)
+  if (__math::isnan(__x))
+    return __x;
+
+  _Real __H_0{1};
+  if (__n == 0)
+    return __H_0;
+
+  _Real __H_n_prev = __H_0;
+  _Real __H_n      = 2 * __x;
+  for (unsigned __i = 1; __i < __n; ++__i) {
+    _Real __H_n_next = 2 * (__x * __H_n - __i * __H_n_prev);
+    __H_n_prev       = __H_n;
+    __H_n            = __H_n_next;
+  }
+
+  if (!__math::isfinite(__H_n)) {
+    // Overflow occured. Two possible cases:
+    //    n is odd:  return infinity of the same sign as x.
+    //    n is even: return +Inf
+    _Real __inf = std::numeric_limits<_Real>::infinity();
+    return (__n & 1) ? __math::copysign(__inf, __x) : __inf;
+  }
+  return __H_n;
+  // NOLINTEND(readability-identifier-naming)
+}
+
+inline _LIBCPP_HIDE_FROM_ABI double hermite(unsigned __n, double __x) { return std::__hermite(__n, __x); }
+
+inline _LIBCPP_HIDE_FROM_ABI float hermite(unsigned __n, float __x) {
+  // use double internally -- float is too prone to overflow!
+  return static_cast<float>(std::hermite(__n, static_cast<double>(__x)));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double hermite(unsigned __n, long double __x) { return std::__hermite(__n, __x); }
+
+inline _LIBCPP_HIDE_FROM_ABI float hermitef(unsigned __n, float __x) { return std::hermite(__n, __x); }
+
+inline _LIBCPP_HIDE_FROM_ABI long double hermitel(unsigned __n, long double __x) { return std::hermite(__n, __x); }
+
+template <class _Integer, std::enable_if_t<std::is_integral_v<_Integer>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double hermite(unsigned __n, _Integer __x) {
+  return std::hermite(__n, static_cast<double>(__x));
+}
+
+#endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_SPECIAL_FUNCTIONS_H
diff --git a/third_party/libcxx/__math/traits.h b/third_party/libcxx/__math/traits.h
new file mode 100644
index 000000000..27ec52ece
--- /dev/null
+++ b/third_party/libcxx/__math/traits.h
@@ -0,0 +1,188 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_TRAITS_H
+#define _LIBCPP___MATH_TRAITS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_floating_point.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_signed.h>
+#include <__type_traits/promote.h>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// signbit
+
+template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI bool signbit(_A1 __x) _NOEXCEPT {
+  return __builtin_signbit(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value && is_signed<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI bool signbit(_A1 __x) _NOEXCEPT {
+  return __x < 0;
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value && !is_signed<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI bool signbit(_A1) _NOEXCEPT {
+  return false;
+}
+
+// isfinite
+
+template <class _A1, __enable_if_t<is_arithmetic<_A1>::value && numeric_limits<_A1>::has_infinity, int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(_A1 __x) _NOEXCEPT {
+  return __builtin_isfinite((typename __promote<_A1>::type)__x);
+}
+
+template <class _A1, __enable_if_t<is_arithmetic<_A1>::value && !numeric_limits<_A1>::has_infinity, int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(_A1) _NOEXCEPT {
+  return true;
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(float __x) _NOEXCEPT {
+  return __builtin_isfinite(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(double __x) _NOEXCEPT {
+  return __builtin_isfinite(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(long double __x) _NOEXCEPT {
+  return __builtin_isfinite(__x);
+}
+
+// isinf
+
+template <class _A1, __enable_if_t<is_arithmetic<_A1>::value && numeric_limits<_A1>::has_infinity, int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(_A1 __x) _NOEXCEPT {
+  return __builtin_isinf((typename __promote<_A1>::type)__x);
+}
+
+template <class _A1, __enable_if_t<is_arithmetic<_A1>::value && !numeric_limits<_A1>::has_infinity, int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(_A1) _NOEXCEPT {
+  return false;
+}
+
+#ifdef _LIBCPP_PREFERRED_OVERLOAD
+_LIBCPP_NODISCARD inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(float __x) _NOEXCEPT {
+  return __builtin_isinf(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool
+isinf(double __x) _NOEXCEPT {
+  return __builtin_isinf(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(long double __x) _NOEXCEPT {
+  return __builtin_isinf(__x);
+}
+#endif
+
+// isnan
+
+template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(_A1 __x) _NOEXCEPT {
+  return __builtin_isnan(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(_A1) _NOEXCEPT {
+  return false;
+}
+
+#ifdef _LIBCPP_PREFERRED_OVERLOAD
+_LIBCPP_NODISCARD inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(float __x) _NOEXCEPT {
+  return __builtin_isnan(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool
+isnan(double __x) _NOEXCEPT {
+  return __builtin_isnan(__x);
+}
+
+_LIBCPP_NODISCARD inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(long double __x) _NOEXCEPT {
+  return __builtin_isnan(__x);
+}
+#endif
+
+// isnormal
+
+template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnormal(_A1 __x) _NOEXCEPT {
+  return __builtin_isnormal(__x);
+}
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+_LIBCPP_NODISCARD _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnormal(_A1 __x) _NOEXCEPT {
+  return __x != 0;
+}
+
+// isgreater
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI bool isgreater(_A1 __x, _A2 __y) _NOEXCEPT {
+  using type = typename __promote<_A1, _A2>::type;
+  return __builtin_isgreater((type)__x, (type)__y);
+}
+
+// isgreaterequal
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI bool isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT {
+  using type = typename __promote<_A1, _A2>::type;
+  return __builtin_isgreaterequal((type)__x, (type)__y);
+}
+
+// isless
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI bool isless(_A1 __x, _A2 __y) _NOEXCEPT {
+  using type = typename __promote<_A1, _A2>::type;
+  return __builtin_isless((type)__x, (type)__y);
+}
+
+// islessequal
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI bool islessequal(_A1 __x, _A2 __y) _NOEXCEPT {
+  using type = typename __promote<_A1, _A2>::type;
+  return __builtin_islessequal((type)__x, (type)__y);
+}
+
+// islessgreater
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI bool islessgreater(_A1 __x, _A2 __y) _NOEXCEPT {
+  using type = typename __promote<_A1, _A2>::type;
+  return __builtin_islessgreater((type)__x, (type)__y);
+}
+
+// isunordered
+
+template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI bool isunordered(_A1 __x, _A2 __y) _NOEXCEPT {
+  using type = typename __promote<_A1, _A2>::type;
+  return __builtin_isunordered((type)__x, (type)__y);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_TRAITS_H
diff --git a/third_party/libcxx/__math/trigonometric_functions.h b/third_party/libcxx/__math/trigonometric_functions.h
new file mode 100644
index 000000000..0ad91c763
--- /dev/null
+++ b/third_party/libcxx/__math/trigonometric_functions.h
@@ -0,0 +1,76 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MATH_TRIGONOMETRIC_FUNCTIONS_H
+#define _LIBCPP___MATH_TRIGONOMETRIC_FUNCTIONS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __math {
+
+// cos
+
+inline _LIBCPP_HIDE_FROM_ABI float cos(float __x) _NOEXCEPT { return __builtin_cosf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double cos(double __x) _NOEXCEPT {
+  return __builtin_cos(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double cos(long double __x) _NOEXCEPT { return __builtin_cosl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double cos(_A1 __x) _NOEXCEPT {
+  return __builtin_cos((double)__x);
+}
+
+// sin
+
+inline _LIBCPP_HIDE_FROM_ABI float sin(float __x) _NOEXCEPT { return __builtin_sinf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double sin(double __x) _NOEXCEPT {
+  return __builtin_sin(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double sin(long double __x) _NOEXCEPT { return __builtin_sinl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double sin(_A1 __x) _NOEXCEPT {
+  return __builtin_sin((double)__x);
+}
+
+// tan
+
+inline _LIBCPP_HIDE_FROM_ABI float tan(float __x) _NOEXCEPT { return __builtin_tanf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double tan(double __x) _NOEXCEPT {
+  return __builtin_tan(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double tan(long double __x) _NOEXCEPT { return __builtin_tanl(__x); }
+
+template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double tan(_A1 __x) _NOEXCEPT {
+  return __builtin_tan((double)__x);
+}
+
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___MATH_TRIGONOMETRIC_FUNCTIONS_H
diff --git a/third_party/libcxx/__mbstate_t.h b/third_party/libcxx/__mbstate_t.h
index 2b9e719b1..3c77e956c 100644
--- a/third_party/libcxx/__mbstate_t.h
+++ b/third_party/libcxx/__mbstate_t.h
@@ -10,6 +10,7 @@
 #ifndef _LIBCPP___MBSTATE_T_H
 #define _LIBCPP___MBSTATE_T_H
 
+#include "libc/str/str.h"
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -35,20 +36,4 @@
 #  define __CORRECT_ISO_CPP_WCHAR_H_PROTO
 #endif
 
-#if defined(_LIBCPP_HAS_MUSL_LIBC)
-#   define __NEED_mbstate_t
-#   include <bits/alltypes.h>
-#   undef __NEED_mbstate_t
-#elif __has_include(<bits/types/mbstate_t.h>)
-#   include <bits/types/mbstate_t.h> // works on most Unixes
-#elif __has_include(<sys/_types/_mbstate_t.h>)
-#   include <sys/_types/_mbstate_t.h> // works on Darwin
-#elif !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS) && __has_include_next(<wchar.h>)
-#   include_next <wchar.h> // fall back to the C standard provider of mbstate_t
-#elif __has_include_next(<uchar.h>)
-#   include_next <uchar.h> // <uchar.h> is also required to make mbstate_t visible
-#else
-#   error "We don't know how to get the definition of mbstate_t without <wchar.h> on your platform."
-#endif
-
 #endif // _LIBCPP___MBSTATE_T_H
diff --git a/third_party/libcxx/__mdspan/default_accessor.h b/third_party/libcxx/__mdspan/default_accessor.h
new file mode 100644
index 000000000..1cc5f1554
--- /dev/null
+++ b/third_party/libcxx/__mdspan/default_accessor.h
@@ -0,0 +1,66 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MDSPAN_DEFAULT_ACCESSOR_H
+#define _LIBCPP___MDSPAN_DEFAULT_ACCESSOR_H
+
+#include <__config>
+#include <__type_traits/is_abstract.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/remove_const.h>
+#include <cinttypes>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _ElementType>
+struct default_accessor {
+  static_assert(!is_array_v<_ElementType>, "default_accessor: template argument may not be an array type");
+  static_assert(!is_abstract_v<_ElementType>, "default_accessor: template argument may not be an abstract class");
+
+  using offset_policy    = default_accessor;
+  using element_type     = _ElementType;
+  using reference        = _ElementType&;
+  using data_handle_type = _ElementType*;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr default_accessor() noexcept = default;
+  template <class _OtherElementType>
+    requires(is_convertible_v<_OtherElementType (*)[], element_type (*)[]>)
+  _LIBCPP_HIDE_FROM_ABI constexpr default_accessor(default_accessor<_OtherElementType>) noexcept {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr reference access(data_handle_type __p, size_t __i) const noexcept { return __p[__i]; }
+  _LIBCPP_HIDE_FROM_ABI constexpr data_handle_type offset(data_handle_type __p, size_t __i) const noexcept {
+    return __p + __i;
+  }
+};
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___MDSPAN_DEFAULT_ACCESSOR_H
diff --git a/third_party/libcxx/__mdspan/extents.h b/third_party/libcxx/__mdspan/extents.h
index e31e43493..95082ef3d 100644
--- a/third_party/libcxx/__mdspan/extents.h
+++ b/third_party/libcxx/__mdspan/extents.h
@@ -137,9 +137,9 @@ private:
   // static mapping of indices to the position in the dynamic values array
   using _DynamicIdxMap = __static_partial_sums<static_cast<size_t>(_Values == _DynTag)...>;
 
-  template <size_t... Indices>
-  _LIBCPP_HIDE_FROM_ABI static constexpr _DynamicValues __zeros(index_sequence<Indices...>) noexcept {
-    return _DynamicValues{((void)Indices, 0)...};
+  template <size_t... _Indices>
+  _LIBCPP_HIDE_FROM_ABI static constexpr _DynamicValues __zeros(index_sequence<_Indices...>) noexcept {
+    return _DynamicValues{((void)_Indices, 0)...};
   }
 
 public:
@@ -165,49 +165,55 @@ public:
   template <class... _DynVals>
     requires(sizeof...(_DynVals) != __size_dynamic_)
   _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(_DynVals... __vals) {
-    static_assert((sizeof...(_DynVals) == __size_), "Invalid number of values.");
+    static_assert(sizeof...(_DynVals) == __size_, "Invalid number of values.");
     _TDynamic __values[__size_] = {static_cast<_TDynamic>(__vals)...};
     for (size_t __i = 0; __i < __size_; __i++) {
       _TStatic __static_val = _StaticValues::__get(__i);
       if (__static_val == _DynTag) {
         __dyn_vals_[_DynamicIdxMap::__get(__i)] = __values[__i];
-      }
-      // Precondition check
-      else
-        _LIBCPP_ASSERT(__values[__i] == static_cast<_TDynamic>(__static_val),
-                       "extents construction: mismatch of provided arguments with static extents.");
+      } else
+        // Not catching this could lead to out of bounds errors later
+        // e.g. using my_mdspan_t = mdspan<int, extents<int, 10>>; my_mdspan_t = m(new int[5], 5);
+        // Right-hand-side construction looks ok with allocation and size matching,
+        // but since (potentially elsewhere defined) my_mdspan_t has static size m now thinks its range is 10 not 5
+        _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+            __values[__i] == static_cast<_TDynamic>(__static_val),
+            "extents construction: mismatch of provided arguments with static extents.");
     }
   }
 
   template <class _Tp, size_t _Size>
     requires(_Size != __size_dynamic_)
   _LIBCPP_HIDE_FROM_ABI constexpr __maybe_static_array(const span<_Tp, _Size>& __vals) {
-    static_assert((_Size == __size_) || (__size_ == dynamic_extent));
+    static_assert(_Size == __size_ || __size_ == dynamic_extent);
     for (size_t __i = 0; __i < __size_; __i++) {
       _TStatic __static_val = _StaticValues::__get(__i);
       if (__static_val == _DynTag) {
         __dyn_vals_[_DynamicIdxMap::__get(__i)] = static_cast<_TDynamic>(__vals[__i]);
-      }
-      // Precondition check
-      else
-        _LIBCPP_ASSERT(static_cast<_TDynamic>(__vals[__i]) == static_cast<_TDynamic>(__static_val),
-                       "extents construction: mismatch of provided arguments with static extents.");
+      } else
+        // Not catching this could lead to out of bounds errors later
+        // e.g. using my_mdspan_t = mdspan<int, extents<int, 10>>; my_mdspan_t = m(new int[N], span<int,1>(&N));
+        // Right-hand-side construction looks ok with allocation and size matching,
+        // but since (potentially elsewhere defined) my_mdspan_t has static size m now thinks its range is 10 not N
+        _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+            static_cast<_TDynamic>(__vals[__i]) == static_cast<_TDynamic>(__static_val),
+            "extents construction: mismatch of provided arguments with static extents.");
     }
   }
 
   // access functions
   _LIBCPP_HIDE_FROM_ABI static constexpr _TStatic __static_value(size_t __i) noexcept {
-    _LIBCPP_ASSERT(__i < __size_, "extents access: index must be less than rank");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __size_, "extents access: index must be less than rank");
     return _StaticValues::__get(__i);
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr _TDynamic __value(size_t __i) const {
-    _LIBCPP_ASSERT(__i < __size_, "extents access: index must be less than rank");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __size_, "extents access: index must be less than rank");
     _TStatic __static_val = _StaticValues::__get(__i);
     return __static_val == _DynTag ? __dyn_vals_[_DynamicIdxMap::__get(__i)] : static_cast<_TDynamic>(__static_val);
   }
   _LIBCPP_HIDE_FROM_ABI constexpr _TDynamic operator[](size_t __i) const {
-    _LIBCPP_ASSERT(__i < __size_, "extents access: index must be less than rank");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __size_, "extents access: index must be less than rank");
     return __value(__i);
   }
 
@@ -220,7 +226,7 @@ public:
 // value must be a positive integer otherwise returns false
 // if _From is not an integral, we just check positivity
 template <integral _To, class _From>
-  requires(is_integral_v<_From>)
+  requires(integral<_From>)
 _LIBCPP_HIDE_FROM_ABI constexpr bool __is_representable_as(_From __value) {
   using _To_u   = make_unsigned_t<_To>;
   using _From_u = make_unsigned_t<_From>;
@@ -236,7 +242,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool __is_representable_as(_From __value) {
 }
 
 template <integral _To, class _From>
-  requires(!is_integral_v<_From>)
+  requires(!integral<_From>)
 _LIBCPP_HIDE_FROM_ABI constexpr bool __is_representable_as(_From __value) {
   if constexpr (is_signed_v<_To>) {
     if (static_cast<_To>(__value) < 0)
@@ -310,28 +316,37 @@ public:
              (sizeof...(_OtherIndexTypes) == __rank_ || sizeof...(_OtherIndexTypes) == __rank_dynamic_))
   _LIBCPP_HIDE_FROM_ABI constexpr explicit extents(_OtherIndexTypes... __dynvals) noexcept
       : __vals_(static_cast<index_type>(__dynvals)...) {
-    _LIBCPP_ASSERT(__mdspan_detail::__are_representable_as<index_type>(__dynvals...),
-                   "extents ctor: arguments must be representable as index_type and nonnegative");
+    // Not catching this could lead to out of bounds errors later
+    // e.g. mdspan m(ptr, dextents<char, 1>(200u)); leads to an extent of -56 on m
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__mdspan_detail::__are_representable_as<index_type>(__dynvals...),
+                                        "extents ctor: arguments must be representable as index_type and nonnegative");
   }
 
   template <class _OtherIndexType, size_t _Size>
-    requires(is_convertible_v<_OtherIndexType, index_type> && is_nothrow_constructible_v<index_type, _OtherIndexType> &&
+    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
+             is_nothrow_constructible_v<index_type, const _OtherIndexType&> &&
              (_Size == __rank_ || _Size == __rank_dynamic_))
   explicit(_Size != __rank_dynamic_)
       _LIBCPP_HIDE_FROM_ABI constexpr extents(const array<_OtherIndexType, _Size>& __exts) noexcept
       : __vals_(span(__exts)) {
-    _LIBCPP_ASSERT(__mdspan_detail::__are_representable_as<index_type>(span(__exts)),
-                   "extents ctor: arguments must be representable as index_type and nonnegative");
+    // Not catching this could lead to out of bounds errors later
+    // e.g. mdspan m(ptr, dextents<char, 1>(array<unsigned,1>(200))); leads to an extent of -56 on m
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__mdspan_detail::__are_representable_as<index_type>(span(__exts)),
+                                        "extents ctor: arguments must be representable as index_type and nonnegative");
   }
 
   template <class _OtherIndexType, size_t _Size>
-    requires(is_convertible_v<_OtherIndexType, index_type> && is_nothrow_constructible_v<index_type, _OtherIndexType> &&
+    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
+             is_nothrow_constructible_v<index_type, const _OtherIndexType&> &&
              (_Size == __rank_ || _Size == __rank_dynamic_))
   explicit(_Size != __rank_dynamic_)
       _LIBCPP_HIDE_FROM_ABI constexpr extents(const span<_OtherIndexType, _Size>& __exts) noexcept
       : __vals_(__exts) {
-    _LIBCPP_ASSERT(__mdspan_detail::__are_representable_as<index_type>(__exts),
-                   "extents ctor: arguments must be representable as index_type and nonnegative");
+    // Not catching this could lead to out of bounds errors later
+    // e.g. array a{200u}; mdspan<int, dextents<char,1>> m(ptr, extents(span<unsigned,1>(a))); leads to an extent of -56
+    // on m
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__mdspan_detail::__are_representable_as<index_type>(__exts),
+                                        "extents ctor: arguments must be representable as index_type and nonnegative");
   }
 
 private:
@@ -380,10 +395,16 @@ public:
       for (size_t __r = 0; __r < rank(); __r++) {
         if constexpr (static_cast<make_unsigned_t<index_type>>(numeric_limits<index_type>::max()) <
                       static_cast<make_unsigned_t<_OtherIndexType>>(numeric_limits<_OtherIndexType>::max())) {
-          _LIBCPP_ASSERT(__mdspan_detail::__is_representable_as<index_type>(__other.extent(__r)),
-                         "extents ctor: arguments must be representable as index_type and nonnegative");
+          // Not catching this could lead to out of bounds errors later
+          // e.g. dextents<char,1>> e(dextents<unsigned,1>(200)) leads to an extent of -56 on e
+          _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+              __mdspan_detail::__is_representable_as<index_type>(__other.extent(__r)),
+              "extents ctor: arguments must be representable as index_type and nonnegative");
         }
-        _LIBCPP_ASSERT(
+        // Not catching this could lead to out of bounds errors later
+        // e.g. mdspan<int, extents<int, 10>> m = mdspan<int, dextents<int, 1>>(new int[5], 5);
+        // Right-hand-side construction was ok, but m now thinks its range is 10 not 5
+        _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
             (_Values::__static_value(__r) == dynamic_extent) ||
                 (static_cast<index_type>(__other.extent(__r)) == static_cast<index_type>(_Values::__static_value(__r))),
             "extents construction: mismatch of provided arguments with static extents.");
@@ -433,13 +454,26 @@ struct __make_dextents< _IndexType, 0, extents<_IndexType, _ExtentsPack...>> {
 template <class _IndexType, size_t _Rank>
 using dextents = typename __mdspan_detail::__make_dextents<_IndexType, _Rank>::type;
 
-// Deduction guide for extents
-template <class... _IndexTypes>
-extents(_IndexTypes...) -> extents<size_t, size_t((_IndexTypes(), dynamic_extent))...>;
+#  if _LIBCPP_STD_VER >= 26
+// [mdspan.extents.dims], alias template `dims`
+template <size_t _Rank, class _IndexType = size_t>
+using dims = dextents<_IndexType, _Rank>;
+#  endif
+
+// Deduction guide for extents
+#  if _LIBCPP_STD_VER >= 26
+template <class... _IndexTypes>
+  requires(is_convertible_v<_IndexTypes, size_t> && ...)
+explicit extents(_IndexTypes...) -> extents<size_t, __maybe_static_ext<_IndexTypes>...>;
+#  else
+template <class... _IndexTypes>
+  requires(is_convertible_v<_IndexTypes, size_t> && ...)
+explicit extents(_IndexTypes...) -> extents<size_t, size_t(((void)sizeof(_IndexTypes), dynamic_extent))...>;
+#  endif
 
-// Helper type traits for identifying a class as extents.
 namespace __mdspan_detail {
 
+// Helper type traits for identifying a class as extents.
 template <class _Tp>
 struct __is_extents : false_type {};
 
@@ -449,6 +483,44 @@ struct __is_extents<extents<_IndexType, _ExtentsPack...>> : true_type {};
 template <class _Tp>
 inline constexpr bool __is_extents_v = __is_extents<_Tp>::value;
 
+// Function to check whether a set of indices are a multidimensional
+// index into extents. This is a word of power in the C++ standard
+// requiring that the indices are larger than 0 and smaller than
+// the respective extents.
+
+template <integral _IndexType, class _From>
+  requires(integral<_From>)
+_LIBCPP_HIDE_FROM_ABI constexpr bool __is_index_in_extent(_IndexType __extent, _From __value) {
+  if constexpr (is_signed_v<_From>) {
+    if (__value < 0)
+      return false;
+  }
+  using _Tp = common_type_t<_IndexType, _From>;
+  return static_cast<_Tp>(__value) < static_cast<_Tp>(__extent);
+}
+
+template <integral _IndexType, class _From>
+  requires(!integral<_From>)
+_LIBCPP_HIDE_FROM_ABI constexpr bool __is_index_in_extent(_IndexType __extent, _From __value) {
+  if constexpr (is_signed_v<_IndexType>) {
+    if (static_cast<_IndexType>(__value) < 0)
+      return false;
+  }
+  return static_cast<_IndexType>(__value) < __extent;
+}
+
+template <size_t... _Idxs, class _Extents, class... _From>
+_LIBCPP_HIDE_FROM_ABI constexpr bool
+__is_multidimensional_index_in_impl(index_sequence<_Idxs...>, const _Extents& __ext, _From... __values) {
+  return (__mdspan_detail::__is_index_in_extent(__ext.extent(_Idxs), __values) && ...);
+}
+
+template <class _Extents, class... _From>
+_LIBCPP_HIDE_FROM_ABI constexpr bool __is_multidimensional_index_in(const _Extents& __ext, _From... __values) {
+  return __mdspan_detail::__is_multidimensional_index_in_impl(
+      make_index_sequence<_Extents::rank()>(), __ext, __values...);
+}
+
 } // namespace __mdspan_detail
 
 #endif // _LIBCPP_STD_VER >= 23
diff --git a/third_party/libcxx/__mdspan/layout_left.h b/third_party/libcxx/__mdspan/layout_left.h
new file mode 100644
index 000000000..d058cbccf
--- /dev/null
+++ b/third_party/libcxx/__mdspan/layout_left.h
@@ -0,0 +1,204 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MDSPAN_LAYOUT_LEFT_H
+#define _LIBCPP___MDSPAN_LAYOUT_LEFT_H
+
+#include <__assert>
+#include <__config>
+#include <__fwd/mdspan.h>
+#include <__mdspan/extents.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__utility/integer_sequence.h>
+#include <array>
+#include <cinttypes>
+#include <cstddef>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Extents>
+class layout_left::mapping {
+public:
+  static_assert(__mdspan_detail::__is_extents<_Extents>::value,
+                "layout_left::mapping template argument must be a specialization of extents.");
+
+  using extents_type = _Extents;
+  using index_type   = typename extents_type::index_type;
+  using size_type    = typename extents_type::size_type;
+  using rank_type    = typename extents_type::rank_type;
+  using layout_type  = layout_left;
+
+private:
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool __required_span_size_is_representable(const extents_type& __ext) {
+    if constexpr (extents_type::rank() == 0)
+      return true;
+
+    index_type __prod = __ext.extent(0);
+    for (rank_type __r = 1; __r < extents_type::rank(); __r++) {
+      bool __overflowed = __builtin_mul_overflow(__prod, __ext.extent(__r), &__prod);
+      if (__overflowed)
+        return false;
+    }
+    return true;
+  }
+
+  static_assert(extents_type::rank_dynamic() > 0 || __required_span_size_is_representable(extents_type()),
+                "layout_left::mapping product of static extents must be representable as index_type.");
+
+public:
+  // [mdspan.layout.left.cons], constructors
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping() noexcept               = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const mapping&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const extents_type& __ext) noexcept : __extents_(__ext) {
+    // not catching this could lead to out-of-bounds access later when used inside mdspan
+    // mapping<dextents<char, 2>> map(dextents<char, 2>(40,40)); map(10, 3) == -126
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __required_span_size_is_representable(__ext),
+        "layout_left::mapping extents ctor: product of extents must be representable as index_type.");
+  }
+
+  template <class _OtherExtents>
+    requires(is_constructible_v<extents_type, _OtherExtents>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
+      mapping(const mapping<_OtherExtents>& __other) noexcept
+      : __extents_(__other.extents()) {
+    // not catching this could lead to out-of-bounds access later when used inside mdspan
+    // mapping<dextents<char, 2>> map(mapping<dextents<int, 2>>(dextents<int, 2>(40,40))); map(10, 3) == -126
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
+        "layout_left::mapping converting ctor: other.required_span_size() must be representable as index_type.");
+  }
+
+  template <class _OtherExtents>
+    requires(is_constructible_v<extents_type, _OtherExtents> && _OtherExtents::rank() <= 1)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
+      mapping(const layout_right::mapping<_OtherExtents>& __other) noexcept
+      : __extents_(__other.extents()) {
+    // not catching this could lead to out-of-bounds access later when used inside mdspan
+    // Note: since this is constraint to rank 1, extents itself would catch the invalid conversion first
+    //       and thus this assertion should never be triggered, but keeping it here for consistency
+    // layout_left::mapping<dextents<char, 1>> map(
+    //           layout_right::mapping<dextents<unsigned, 1>>(dextents<unsigned, 1>(200))); map.extents().extent(0) ==
+    //           -56
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
+        "layout_left::mapping converting ctor: other.required_span_size() must be representable as index_type.");
+  }
+
+  template <class _OtherExtents>
+    requires(is_constructible_v<extents_type, _OtherExtents>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(extents_type::rank() > 0)
+      mapping(const layout_stride::mapping<_OtherExtents>& __other) noexcept
+      : __extents_(__other.extents()) {
+    if constexpr (extents_type::rank() > 0) {
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          ([&]() {
+            using _CommonType = common_type_t<typename extents_type::index_type, typename _OtherExtents::index_type>;
+            for (rank_type __r = 0; __r < extents_type::rank(); __r++)
+              if (static_cast<_CommonType>(stride(__r)) != static_cast<_CommonType>(__other.stride(__r)))
+                return false;
+            return true;
+          }()),
+          "layout_left::mapping from layout_stride ctor: strides are not compatible with layout_left.");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
+          "layout_left::mapping from layout_stride ctor: other.required_span_size() must be representable as "
+          "index_type.");
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping& operator=(const mapping&) noexcept = default;
+
+  // [mdspan.layout.left.obs], observers
+  _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept { return __extents_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type required_span_size() const noexcept {
+    index_type __size = 1;
+    for (size_t __r = 0; __r < extents_type::rank(); __r++)
+      __size *= __extents_.extent(__r);
+    return __size;
+  }
+
+  template <class... _Indices>
+    requires((sizeof...(_Indices) == extents_type::rank()) && (is_convertible_v<_Indices, index_type> && ...) &&
+             (is_nothrow_constructible_v<index_type, _Indices> && ...))
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type operator()(_Indices... __idx) const noexcept {
+    // Mappings are generally meant to be used for accessing allocations and are meant to guarantee to never
+    // return a value exceeding required_span_size(), which is used to know how large an allocation one needs
+    // Thus, this is a canonical point in multi-dimensional data structures to make invalid element access checks
+    // However, mdspan does check this on its own, so for now we avoid double checking in hardened mode
+    _LIBCPP_ASSERT_UNCATEGORIZED(__mdspan_detail::__is_multidimensional_index_in(__extents_, __idx...),
+                                 "layout_left::mapping: out of bounds indexing");
+    array<index_type, extents_type::rank()> __idx_a{static_cast<index_type>(__idx)...};
+    return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
+      index_type __res = 0;
+      ((__res = __idx_a[extents_type::rank() - 1 - _Pos] + __extents_.extent(extents_type::rank() - 1 - _Pos) * __res),
+       ...);
+      return __res;
+    }(make_index_sequence<sizeof...(_Indices)>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept { return true; }
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_unique() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_exhaustive() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_strided() noexcept { return true; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const noexcept
+    requires(extents_type::rank() > 0)
+  {
+    // While it would be caught by extents itself too, using a too large __r
+    // is functionally an out of bounds access on the stored information needed to compute strides
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __r < extents_type::rank(), "layout_left::mapping::stride(): invalid rank index");
+    index_type __s = 1;
+    for (rank_type __i = 0; __i < __r; __i++)
+      __s *= __extents_.extent(__i);
+    return __s;
+  }
+
+  template <class _OtherExtents>
+    requires(_OtherExtents::rank() == extents_type::rank())
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator==(const mapping& __lhs, const mapping<_OtherExtents>& __rhs) noexcept {
+    return __lhs.extents() == __rhs.extents();
+  }
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS extents_type __extents_{};
+};
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___MDSPAN_LAYOUT_LEFT_H
diff --git a/third_party/libcxx/__mdspan/layout_right.h b/third_party/libcxx/__mdspan/layout_right.h
new file mode 100644
index 000000000..6842e9dc3
--- /dev/null
+++ b/third_party/libcxx/__mdspan/layout_right.h
@@ -0,0 +1,201 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MDSPAN_LAYOUT_RIGHT_H
+#define _LIBCPP___MDSPAN_LAYOUT_RIGHT_H
+
+#include <__assert>
+#include <__config>
+#include <__fwd/mdspan.h>
+#include <__mdspan/extents.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__utility/integer_sequence.h>
+#include <cinttypes>
+#include <cstddef>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Extents>
+class layout_right::mapping {
+public:
+  static_assert(__mdspan_detail::__is_extents<_Extents>::value,
+                "layout_right::mapping template argument must be a specialization of extents.");
+
+  using extents_type = _Extents;
+  using index_type   = typename extents_type::index_type;
+  using size_type    = typename extents_type::size_type;
+  using rank_type    = typename extents_type::rank_type;
+  using layout_type  = layout_right;
+
+private:
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool __required_span_size_is_representable(const extents_type& __ext) {
+    if constexpr (extents_type::rank() == 0)
+      return true;
+
+    index_type __prod = __ext.extent(0);
+    for (rank_type __r = 1; __r < extents_type::rank(); __r++) {
+      bool __overflowed = __builtin_mul_overflow(__prod, __ext.extent(__r), &__prod);
+      if (__overflowed)
+        return false;
+    }
+    return true;
+  }
+
+  static_assert(extents_type::rank_dynamic() > 0 || __required_span_size_is_representable(extents_type()),
+                "layout_right::mapping product of static extents must be representable as index_type.");
+
+public:
+  // [mdspan.layout.right.cons], constructors
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping() noexcept               = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const mapping&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const extents_type& __ext) noexcept : __extents_(__ext) {
+    // not catching this could lead to out-of-bounds access later when used inside mdspan
+    // mapping<dextents<char, 2>> map(dextents<char, 2>(40,40)); map(3, 10) == -126
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __required_span_size_is_representable(__ext),
+        "layout_right::mapping extents ctor: product of extents must be representable as index_type.");
+  }
+
+  template <class _OtherExtents>
+    requires(is_constructible_v<extents_type, _OtherExtents>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
+      mapping(const mapping<_OtherExtents>& __other) noexcept
+      : __extents_(__other.extents()) {
+    // not catching this could lead to out-of-bounds access later when used inside mdspan
+    // mapping<dextents<char, 2>> map(mapping<dextents<int, 2>>(dextents<int, 2>(40,40))); map(3, 10) == -126
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
+        "layout_right::mapping converting ctor: other.required_span_size() must be representable as index_type.");
+  }
+
+  template <class _OtherExtents>
+    requires(is_constructible_v<extents_type, _OtherExtents> && _OtherExtents::rank() <= 1)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_OtherExtents, extents_type>)
+      mapping(const layout_left::mapping<_OtherExtents>& __other) noexcept
+      : __extents_(__other.extents()) {
+    // not catching this could lead to out-of-bounds access later when used inside mdspan
+    // Note: since this is constraint to rank 1, extents itself would catch the invalid conversion first
+    //       and thus this assertion should never be triggered, but keeping it here for consistency
+    // layout_right::mapping<dextents<char, 1>> map(
+    //           layout_left::mapping<dextents<unsigned, 1>>(dextents<unsigned, 1>(200))); map.extents().extent(0) ==
+    //           -56
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
+        "layout_right::mapping converting ctor: other.required_span_size() must be representable as index_type.");
+  }
+
+  template <class _OtherExtents>
+    requires(is_constructible_v<extents_type, _OtherExtents>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(extents_type::rank() > 0)
+      mapping(const layout_stride::mapping<_OtherExtents>& __other) noexcept
+      : __extents_(__other.extents()) {
+    if constexpr (extents_type::rank() > 0) {
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          ([&]() {
+            using _CommonType = common_type_t<typename extents_type::index_type, typename _OtherExtents::index_type>;
+            for (rank_type __r = 0; __r < extents_type::rank(); __r++)
+              if (static_cast<_CommonType>(stride(__r)) != static_cast<_CommonType>(__other.stride(__r)))
+                return false;
+            return true;
+          }()),
+          "layout_right::mapping from layout_stride ctor: strides are not compatible with layout_right.");
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
+          "layout_right::mapping from layout_stride ctor: other.required_span_size() must be representable as "
+          "index_type.");
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping& operator=(const mapping&) noexcept = default;
+
+  // [mdspan.layout.right.obs], observers
+  _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept { return __extents_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type required_span_size() const noexcept {
+    index_type __size = 1;
+    for (size_t __r = 0; __r < extents_type::rank(); __r++)
+      __size *= __extents_.extent(__r);
+    return __size;
+  }
+
+  template <class... _Indices>
+    requires((sizeof...(_Indices) == extents_type::rank()) && (is_convertible_v<_Indices, index_type> && ...) &&
+             (is_nothrow_constructible_v<index_type, _Indices> && ...))
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type operator()(_Indices... __idx) const noexcept {
+    // Mappings are generally meant to be used for accessing allocations and are meant to guarantee to never
+    // return a value exceeding required_span_size(), which is used to know how large an allocation one needs
+    // Thus, this is a canonical point in multi-dimensional data structures to make invalid element access checks
+    // However, mdspan does check this on its own, so for now we avoid double checking in hardened mode
+    _LIBCPP_ASSERT_UNCATEGORIZED(__mdspan_detail::__is_multidimensional_index_in(__extents_, __idx...),
+                                 "layout_right::mapping: out of bounds indexing");
+    return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
+      index_type __res = 0;
+      ((__res = static_cast<index_type>(__idx) + __extents_.extent(_Pos) * __res), ...);
+      return __res;
+    }(make_index_sequence<sizeof...(_Indices)>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept { return true; }
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_unique() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_exhaustive() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_strided() noexcept { return true; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const noexcept
+    requires(extents_type::rank() > 0)
+  {
+    // While it would be caught by extents itself too, using a too large __r
+    // is functionally an out of bounds access on the stored information needed to compute strides
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __r < extents_type::rank(), "layout_right::mapping::stride(): invalid rank index");
+    index_type __s = 1;
+    for (rank_type __i = extents_type::rank() - 1; __i > __r; __i--)
+      __s *= __extents_.extent(__i);
+    return __s;
+  }
+
+  template <class _OtherExtents>
+    requires(_OtherExtents::rank() == extents_type::rank())
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator==(const mapping& __lhs, const mapping<_OtherExtents>& __rhs) noexcept {
+    return __lhs.extents() == __rhs.extents();
+  }
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS extents_type __extents_{};
+};
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___MDSPAN_LAYOUT_RIGHT_H
diff --git a/third_party/libcxx/__mdspan/layout_stride.h b/third_party/libcxx/__mdspan/layout_stride.h
new file mode 100644
index 000000000..86148ac84
--- /dev/null
+++ b/third_party/libcxx/__mdspan/layout_stride.h
@@ -0,0 +1,366 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MDSPAN_LAYOUT_STRIDE_H
+#define _LIBCPP___MDSPAN_LAYOUT_STRIDE_H
+
+#include <__assert>
+#include <__config>
+#include <__fwd/mdspan.h>
+#include <__mdspan/extents.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__utility/as_const.h>
+#include <__utility/integer_sequence.h>
+#include <__utility/swap.h>
+#include <array>
+#include <cinttypes>
+#include <cstddef>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace __mdspan_detail {
+template <class _Layout, class _Mapping>
+constexpr bool __is_mapping_of =
+    is_same_v<typename _Layout::template mapping<typename _Mapping::extents_type>, _Mapping>;
+
+template <class _Mapping>
+concept __layout_mapping_alike = requires {
+  requires __is_mapping_of<typename _Mapping::layout_type, _Mapping>;
+  requires __is_extents_v<typename _Mapping::extents_type>;
+  { _Mapping::is_always_strided() } -> same_as<bool>;
+  { _Mapping::is_always_exhaustive() } -> same_as<bool>;
+  { _Mapping::is_always_unique() } -> same_as<bool>;
+  bool_constant<_Mapping::is_always_strided()>::value;
+  bool_constant<_Mapping::is_always_exhaustive()>::value;
+  bool_constant<_Mapping::is_always_unique()>::value;
+};
+} // namespace __mdspan_detail
+
+template <class _Extents>
+class layout_stride::mapping {
+public:
+  static_assert(__mdspan_detail::__is_extents<_Extents>::value,
+                "layout_stride::mapping template argument must be a specialization of extents.");
+
+  using extents_type = _Extents;
+  using index_type   = typename extents_type::index_type;
+  using size_type    = typename extents_type::size_type;
+  using rank_type    = typename extents_type::rank_type;
+  using layout_type  = layout_stride;
+
+private:
+  static constexpr rank_type __rank_ = extents_type::rank();
+
+  // Used for default construction check and mandates
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool __required_span_size_is_representable(const extents_type& __ext) {
+    if constexpr (__rank_ == 0)
+      return true;
+
+    index_type __prod = __ext.extent(0);
+    for (rank_type __r = 1; __r < __rank_; __r++) {
+      bool __overflowed = __builtin_mul_overflow(__prod, __ext.extent(__r), &__prod);
+      if (__overflowed)
+        return false;
+    }
+    return true;
+  }
+
+  template <class _OtherIndexType>
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool
+  __required_span_size_is_representable(const extents_type& __ext, span<_OtherIndexType, __rank_> __strides) {
+    if constexpr (__rank_ == 0)
+      return true;
+
+    index_type __size = 1;
+    for (rank_type __r = 0; __r < __rank_; __r++) {
+      // We can only check correct conversion of _OtherIndexType if it is an integral
+      if constexpr (is_integral_v<_OtherIndexType>) {
+        using _CommonType = common_type_t<index_type, _OtherIndexType>;
+        if (static_cast<_CommonType>(__strides[__r]) > static_cast<_CommonType>(numeric_limits<index_type>::max()))
+          return false;
+      }
+      if (__ext.extent(__r) == static_cast<index_type>(0))
+        return true;
+      index_type __prod     = (__ext.extent(__r) - 1);
+      bool __overflowed_mul = __builtin_mul_overflow(__prod, static_cast<index_type>(__strides[__r]), &__prod);
+      if (__overflowed_mul)
+        return false;
+      bool __overflowed_add = __builtin_add_overflow(__size, __prod, &__size);
+      if (__overflowed_add)
+        return false;
+    }
+    return true;
+  }
+
+  // compute offset of a strided layout mapping
+  template <class _StridedMapping>
+  _LIBCPP_HIDE_FROM_ABI static constexpr index_type __offset(const _StridedMapping& __mapping) {
+    if constexpr (_StridedMapping::extents_type::rank() == 0) {
+      return static_cast<index_type>(__mapping());
+    } else if (__mapping.required_span_size() == static_cast<typename _StridedMapping::index_type>(0)) {
+      return static_cast<index_type>(0);
+    } else {
+      return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
+        return static_cast<index_type>(__mapping((_Pos ? 0 : 0)...));
+      }(make_index_sequence<__rank_>());
+    }
+  }
+
+  // compute the permutation for sorting the stride array
+  // we never actually sort the stride array
+  _LIBCPP_HIDE_FROM_ABI constexpr void __bubble_sort_by_strides(array<rank_type, __rank_>& __permute) const {
+    for (rank_type __i = __rank_ - 1; __i > 0; __i--) {
+      for (rank_type __r = 0; __r < __i; __r++) {
+        if (__strides_[__permute[__r]] > __strides_[__permute[__r + 1]]) {
+          swap(__permute[__r], __permute[__r + 1]);
+        } else {
+          // if two strides are the same then one of the associated extents must be 1 or 0
+          // both could be, but you can't have one larger than 1 come first
+          if ((__strides_[__permute[__r]] == __strides_[__permute[__r + 1]]) &&
+              (__extents_.extent(__permute[__r]) > static_cast<index_type>(1)))
+            swap(__permute[__r], __permute[__r + 1]);
+        }
+      }
+    }
+  }
+
+  static_assert(extents_type::rank_dynamic() > 0 || __required_span_size_is_representable(extents_type()),
+                "layout_stride::mapping product of static extents must be representable as index_type.");
+
+public:
+  // [mdspan.layout.stride.cons], constructors
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping() noexcept : __extents_(extents_type()) {
+    // Note the nominal precondition is covered by above static assert since
+    // if rank_dynamic is != 0 required_span_size is zero for default construction
+    if constexpr (__rank_ > 0) {
+      index_type __stride = 1;
+      for (rank_type __r = __rank_ - 1; __r > static_cast<rank_type>(0); __r--) {
+        __strides_[__r] = __stride;
+        __stride *= __extents_.extent(__r);
+      }
+      __strides_[0] = __stride;
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const mapping&) noexcept = default;
+
+  template <class _OtherIndexType>
+    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
+             is_nothrow_constructible_v<index_type, const _OtherIndexType&>)
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const extents_type& __ext, span<_OtherIndexType, __rank_> __strides) noexcept
+      : __extents_(__ext), __strides_([&]<size_t... _Pos>(index_sequence<_Pos...>) {
+          return __mdspan_detail::__possibly_empty_array<index_type, __rank_>{
+              static_cast<index_type>(std::as_const(__strides[_Pos]))...};
+        }(make_index_sequence<__rank_>())) {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        ([&]<size_t... _Pos>(index_sequence<_Pos...>) {
+          // For integrals we can do a pre-conversion check, for other types not
+          if constexpr (is_integral_v<_OtherIndexType>) {
+            return ((__strides[_Pos] > static_cast<_OtherIndexType>(0)) && ... && true);
+          } else {
+            return ((static_cast<index_type>(__strides[_Pos]) > static_cast<index_type>(0)) && ... && true);
+          }
+        }(make_index_sequence<__rank_>())),
+        "layout_stride::mapping ctor: all strides must be greater than 0");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __required_span_size_is_representable(__ext, __strides),
+        "layout_stride::mapping ctor: required span size is not representable as index_type.");
+    if constexpr (__rank_ > 1) {
+      _LIBCPP_ASSERT_UNCATEGORIZED(
+          ([&]<size_t... _Pos>(index_sequence<_Pos...>) {
+            // basically sort the dimensions based on strides and extents, sorting is represented in permute array
+            array<rank_type, __rank_> __permute{_Pos...};
+            __bubble_sort_by_strides(__permute);
+
+            // check that this permutations represents a growing set
+            for (rank_type __i = 1; __i < __rank_; __i++)
+              if (static_cast<index_type>(__strides[__permute[__i]]) <
+                  static_cast<index_type>(__strides[__permute[__i - 1]]) * __extents_.extent(__permute[__i - 1]))
+                return false;
+            return true;
+          }(make_index_sequence<__rank_>())),
+          "layout_stride::mapping ctor: the provided extents and strides lead to a non-unique mapping");
+    }
+  }
+
+  template <class _OtherIndexType>
+    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
+             is_nothrow_constructible_v<index_type, const _OtherIndexType&>)
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping(const extents_type& __ext,
+                                          const array<_OtherIndexType, __rank_>& __strides) noexcept
+      : mapping(__ext, span(__strides)) {}
+
+  template <class _StridedLayoutMapping>
+    requires(__mdspan_detail::__layout_mapping_alike<_StridedLayoutMapping> &&
+             is_constructible_v<extents_type, typename _StridedLayoutMapping::extents_type> &&
+             _StridedLayoutMapping::is_always_unique() && _StridedLayoutMapping::is_always_strided())
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(
+      !(is_convertible_v<typename _StridedLayoutMapping::extents_type, extents_type> &&
+        (__mdspan_detail::__is_mapping_of<layout_left, _StridedLayoutMapping> ||
+         __mdspan_detail::__is_mapping_of<layout_right, _StridedLayoutMapping> ||
+         __mdspan_detail::__is_mapping_of<layout_stride, _StridedLayoutMapping>)))
+      mapping(const _StridedLayoutMapping& __other) noexcept
+      : __extents_(__other.extents()), __strides_([&]<size_t... _Pos>(index_sequence<_Pos...>) {
+          // stride() only compiles for rank > 0
+          if constexpr (__rank_ > 0) {
+            return __mdspan_detail::__possibly_empty_array<index_type, __rank_>{
+                static_cast<index_type>(__other.stride(_Pos))...};
+          } else {
+            return __mdspan_detail::__possibly_empty_array<index_type, 0>{};
+          }
+        }(make_index_sequence<__rank_>())) {
+    // stride() only compiles for rank > 0
+    if constexpr (__rank_ > 0) {
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+          ([&]<size_t... _Pos>(index_sequence<_Pos...>) {
+            return ((static_cast<index_type>(__other.stride(_Pos)) > static_cast<index_type>(0)) && ... && true);
+          }(make_index_sequence<__rank_>())),
+          "layout_stride::mapping converting ctor: all strides must be greater than 0");
+    }
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __mdspan_detail::__is_representable_as<index_type>(__other.required_span_size()),
+        "layout_stride::mapping converting ctor: other.required_span_size() must be representable as index_type.");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(static_cast<index_type>(0) == __offset(__other),
+                                        "layout_stride::mapping converting ctor: base offset of mapping must be zero.");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr mapping& operator=(const mapping&) noexcept = default;
+
+  // [mdspan.layout.stride.obs], observers
+  _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept { return __extents_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr array<index_type, __rank_> strides() const noexcept {
+    return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
+      return array<index_type, __rank_>{__strides_[_Pos]...};
+    }(make_index_sequence<__rank_>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type required_span_size() const noexcept {
+    if constexpr (__rank_ == 0) {
+      return static_cast<index_type>(1);
+    } else {
+      return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
+        if ((__extents_.extent(_Pos) * ... * 1) == 0)
+          return static_cast<index_type>(0);
+        else
+          return static_cast<index_type>(
+              static_cast<index_type>(1) +
+              (((__extents_.extent(_Pos) - static_cast<index_type>(1)) * __strides_[_Pos]) + ... +
+               static_cast<index_type>(0)));
+      }(make_index_sequence<__rank_>());
+    }
+  }
+
+  template <class... _Indices>
+    requires((sizeof...(_Indices) == __rank_) && (is_convertible_v<_Indices, index_type> && ...) &&
+             (is_nothrow_constructible_v<index_type, _Indices> && ...))
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type operator()(_Indices... __idx) const noexcept {
+    // Mappings are generally meant to be used for accessing allocations and are meant to guarantee to never
+    // return a value exceeding required_span_size(), which is used to know how large an allocation one needs
+    // Thus, this is a canonical point in multi-dimensional data structures to make invalid element access checks
+    // However, mdspan does check this on its own, so for now we avoid double checking in hardened mode
+    _LIBCPP_ASSERT_UNCATEGORIZED(__mdspan_detail::__is_multidimensional_index_in(__extents_, __idx...),
+                                 "layout_stride::mapping: out of bounds indexing");
+    return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
+      return ((static_cast<index_type>(__idx) * __strides_[_Pos]) + ... + index_type(0));
+    }(make_index_sequence<sizeof...(_Indices)>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept { return true; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept { return false; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept { return true; }
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_unique() noexcept { return true; }
+  // The answer of this function is fairly complex in the case where one or more
+  // extents are zero.
+  // Technically it is meaningless to query is_exhaustive() in that case, but unfortunately
+  // the way the standard defines this function, we can't give a simple true or false then.
+  _LIBCPP_HIDE_FROM_ABI constexpr bool is_exhaustive() const noexcept {
+    if constexpr (__rank_ == 0)
+      return true;
+    else {
+      index_type __span_size = required_span_size();
+      if (__span_size == static_cast<index_type>(0)) {
+        if constexpr (__rank_ == 1)
+          return __strides_[0] == 1;
+        else {
+          rank_type __r_largest = 0;
+          for (rank_type __r = 1; __r < __rank_; __r++)
+            if (__strides_[__r] > __strides_[__r_largest])
+              __r_largest = __r;
+          for (rank_type __r = 0; __r < __rank_; __r++)
+            if (__extents_.extent(__r) == 0 && __r != __r_largest)
+              return false;
+          return true;
+        }
+      } else {
+        return required_span_size() == [&]<size_t... _Pos>(index_sequence<_Pos...>) {
+          return (__extents_.extent(_Pos) * ... * static_cast<index_type>(1));
+        }(make_index_sequence<__rank_>());
+      }
+    }
+  }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_strided() noexcept { return true; }
+
+  // according to the standard layout_stride does not have a constraint on stride(r) for rank>0
+  // it still has the precondition though
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__r < __rank_, "layout_stride::mapping::stride(): invalid rank index");
+    return __strides_[__r];
+  }
+
+  template <class _OtherMapping>
+    requires(__mdspan_detail::__layout_mapping_alike<_OtherMapping> &&
+             (_OtherMapping::extents_type::rank() == __rank_) && _OtherMapping::is_always_strided())
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const mapping& __lhs, const _OtherMapping& __rhs) noexcept {
+    if (__offset(__rhs))
+      return false;
+    if constexpr (__rank_ == 0)
+      return true;
+    else {
+      return __lhs.extents() == __rhs.extents() && [&]<size_t... _Pos>(index_sequence<_Pos...>) {
+        // avoid warning when comparing signed and unsigner integers and pick the wider of two types
+        using _CommonType = common_type_t<index_type, typename _OtherMapping::index_type>;
+        return ((static_cast<_CommonType>(__lhs.stride(_Pos)) == static_cast<_CommonType>(__rhs.stride(_Pos))) && ... &&
+                true);
+      }(make_index_sequence<__rank_>());
+    }
+  }
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS extents_type __extents_{};
+  _LIBCPP_NO_UNIQUE_ADDRESS __mdspan_detail::__possibly_empty_array<index_type, __rank_> __strides_{};
+};
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___MDSPAN_LAYOUT_STRIDE_H
diff --git a/third_party/libcxx/__mdspan/mdspan.h b/third_party/libcxx/__mdspan/mdspan.h
new file mode 100644
index 000000000..1ff4fd4ba
--- /dev/null
+++ b/third_party/libcxx/__mdspan/mdspan.h
@@ -0,0 +1,319 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MDSPAN_MDSPAN_H
+#define _LIBCPP___MDSPAN_MDSPAN_H
+
+#include <__assert>
+#include <__config>
+#include <__fwd/mdspan.h>
+#include <__mdspan/default_accessor.h>
+#include <__mdspan/extents.h>
+#include <__type_traits/extent.h>
+#include <__type_traits/is_abstract.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/rank.h>
+#include <__type_traits/remove_all_extents.h>
+#include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_pointer.h>
+#include <__type_traits/remove_reference.h>
+#include <__utility/integer_sequence.h>
+#include <array>
+#include <cinttypes>
+#include <cstddef>
+#include <limits>
+#include <span>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+// Helper for lightweight test checking that one did pass a layout policy as LayoutPolicy template argument
+namespace __mdspan_detail {
+template <class _Layout, class _Extents>
+concept __has_invalid_mapping = !requires { typename _Layout::template mapping<_Extents>; };
+} // namespace __mdspan_detail
+
+template <class _ElementType,
+          class _Extents,
+          class _LayoutPolicy   = layout_right,
+          class _AccessorPolicy = default_accessor<_ElementType> >
+class mdspan {
+private:
+  static_assert(__mdspan_detail::__is_extents_v<_Extents>,
+                "mdspan: Extents template parameter must be a specialization of extents.");
+  static_assert(!is_array_v<_ElementType>, "mdspan: ElementType template parameter may not be an array type");
+  static_assert(!is_abstract_v<_ElementType>, "mdspan: ElementType template parameter may not be an abstract class");
+  static_assert(is_same_v<_ElementType, typename _AccessorPolicy::element_type>,
+                "mdspan: ElementType template parameter must match AccessorPolicy::element_type");
+  static_assert(!__mdspan_detail::__has_invalid_mapping<_LayoutPolicy, _Extents>,
+                "mdspan: LayoutPolicy template parameter is invalid. A common mistake is to pass a layout mapping "
+                "instead of a layout policy");
+
+public:
+  using extents_type     = _Extents;
+  using layout_type      = _LayoutPolicy;
+  using accessor_type    = _AccessorPolicy;
+  using mapping_type     = typename layout_type::template mapping<extents_type>;
+  using element_type     = _ElementType;
+  using value_type       = remove_cv_t<element_type>;
+  using index_type       = typename extents_type::index_type;
+  using size_type        = typename extents_type::size_type;
+  using rank_type        = typename extents_type::rank_type;
+  using data_handle_type = typename accessor_type::data_handle_type;
+  using reference        = typename accessor_type::reference;
+
+  _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank() noexcept { return extents_type::rank(); }
+  _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
+  _LIBCPP_HIDE_FROM_ABI static constexpr size_t static_extent(rank_type __r) noexcept {
+    return extents_type::static_extent(__r);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type extent(rank_type __r) const noexcept {
+    return __map_.extents().extent(__r);
+  };
+
+public:
+  //--------------------------------------------------------------------------------
+  // [mdspan.mdspan.cons], mdspan constructors, assignment, and destructor
+
+  _LIBCPP_HIDE_FROM_ABI constexpr mdspan()
+    requires((extents_type::rank_dynamic() > 0) && is_default_constructible_v<data_handle_type> &&
+             is_default_constructible_v<mapping_type> && is_default_constructible_v<accessor_type>)
+  = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr mdspan(const mdspan&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr mdspan(mdspan&&)      = default;
+
+  template <class... _OtherIndexTypes>
+    requires((is_convertible_v<_OtherIndexTypes, index_type> && ...) &&
+             (is_nothrow_constructible_v<index_type, _OtherIndexTypes> && ...) &&
+             ((sizeof...(_OtherIndexTypes) == rank()) || (sizeof...(_OtherIndexTypes) == rank_dynamic())) &&
+             is_constructible_v<mapping_type, extents_type> && is_default_constructible_v<accessor_type>)
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr mdspan(data_handle_type __p, _OtherIndexTypes... __exts)
+      : __ptr_(std::move(__p)), __map_(extents_type(static_cast<index_type>(std::move(__exts))...)), __acc_{} {}
+
+  template <class _OtherIndexType, size_t _Size>
+    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
+             is_nothrow_constructible_v<index_type, const _OtherIndexType&> &&
+             ((_Size == rank()) || (_Size == rank_dynamic())) && is_constructible_v<mapping_type, extents_type> &&
+             is_default_constructible_v<accessor_type>)
+  explicit(_Size != rank_dynamic())
+      _LIBCPP_HIDE_FROM_ABI constexpr mdspan(data_handle_type __p, const array<_OtherIndexType, _Size>& __exts)
+      : __ptr_(std::move(__p)), __map_(extents_type(__exts)), __acc_{} {}
+
+  template <class _OtherIndexType, size_t _Size>
+    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
+             is_nothrow_constructible_v<index_type, const _OtherIndexType&> &&
+             ((_Size == rank()) || (_Size == rank_dynamic())) && is_constructible_v<mapping_type, extents_type> &&
+             is_default_constructible_v<accessor_type>)
+  explicit(_Size != rank_dynamic())
+      _LIBCPP_HIDE_FROM_ABI constexpr mdspan(data_handle_type __p, span<_OtherIndexType, _Size> __exts)
+      : __ptr_(std::move(__p)), __map_(extents_type(__exts)), __acc_{} {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr mdspan(data_handle_type __p, const extents_type& __exts)
+    requires(is_default_constructible_v<accessor_type> && is_constructible_v<mapping_type, const extents_type&>)
+      : __ptr_(std::move(__p)), __map_(__exts), __acc_{} {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr mdspan(data_handle_type __p, const mapping_type& __m)
+    requires(is_default_constructible_v<accessor_type>)
+      : __ptr_(std::move(__p)), __map_(__m), __acc_{} {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr mdspan(data_handle_type __p, const mapping_type& __m, const accessor_type& __a)
+      : __ptr_(std::move(__p)), __map_(__m), __acc_(__a) {}
+
+  template <class _OtherElementType, class _OtherExtents, class _OtherLayoutPolicy, class _OtherAccessor>
+    requires(is_constructible_v<mapping_type, const typename _OtherLayoutPolicy::template mapping<_OtherExtents>&> &&
+             is_constructible_v<accessor_type, const _OtherAccessor&>)
+  explicit(!is_convertible_v<const typename _OtherLayoutPolicy::template mapping<_OtherExtents>&, mapping_type> ||
+           !is_convertible_v<const _OtherAccessor&, accessor_type>)
+      _LIBCPP_HIDE_FROM_ABI constexpr mdspan(
+          const mdspan<_OtherElementType, _OtherExtents, _OtherLayoutPolicy, _OtherAccessor>& __other)
+      : __ptr_(__other.__ptr_), __map_(__other.__map_), __acc_(__other.__acc_) {
+    static_assert(is_constructible_v<data_handle_type, const typename _OtherAccessor::data_handle_type&>,
+                  "mdspan: incompatible data_handle_type for mdspan construction");
+    static_assert(
+        is_constructible_v<extents_type, _OtherExtents>, "mdspan: incompatible extents for mdspan construction");
+
+    // The following precondition is part of the standard, but is unlikely to be triggered.
+    // The extents constructor checks this and the mapping must be storing the extents, since
+    // its extents() function returns a const reference to extents_type.
+    // The only way this can be triggered is if the mapping conversion constructor would for example
+    // always construct its extents() only from the dynamic extents, instead of from the other extents.
+    if constexpr (rank() > 0) {
+      for (size_t __r = 0; __r < rank(); __r++) {
+        // Not catching this could lead to out of bounds errors later
+        // e.g. mdspan<int, dextents<char,1>, non_checking_layout> m =
+        //        mdspan<int, dextents<unsigned, 1>, non_checking_layout>(ptr, 200); leads to an extent of -56 on m
+        _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+            (static_extent(__r) == dynamic_extent) ||
+                (static_cast<index_type>(__other.extent(__r)) == static_cast<index_type>(static_extent(__r))),
+            "mdspan: conversion mismatch of source dynamic extents with static extents");
+      }
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr mdspan& operator=(const mdspan&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr mdspan& operator=(mdspan&&)      = default;
+
+  //--------------------------------------------------------------------------------
+  // [mdspan.mdspan.members], members
+
+  template <class... _OtherIndexTypes>
+    requires((is_convertible_v<_OtherIndexTypes, index_type> && ...) &&
+             (is_nothrow_constructible_v<index_type, _OtherIndexTypes> && ...) &&
+             (sizeof...(_OtherIndexTypes) == rank()))
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](_OtherIndexTypes... __indices) const {
+    // Note the standard layouts would also check this, but user provided ones may not, so we
+    // check the precondition here
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__mdspan_detail::__is_multidimensional_index_in(extents(), __indices...),
+                                        "mdspan: operator[] out of bounds access");
+    return __acc_.access(__ptr_, __map_(static_cast<index_type>(std::move(__indices))...));
+  }
+
+  template <class _OtherIndexType>
+    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
+             is_nothrow_constructible_v<index_type, const _OtherIndexType&>)
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](const array< _OtherIndexType, rank()>& __indices) const {
+    return __acc_.access(__ptr_, [&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
+      return __map_(__indices[_Idxs]...);
+    }(make_index_sequence<rank()>()));
+  }
+
+  template <class _OtherIndexType>
+    requires(is_convertible_v<const _OtherIndexType&, index_type> &&
+             is_nothrow_constructible_v<index_type, const _OtherIndexType&>)
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](span<_OtherIndexType, rank()> __indices) const {
+    return __acc_.access(__ptr_, [&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
+      return __map_(__indices[_Idxs]...);
+    }(make_index_sequence<rank()>()));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept {
+    // Could leave this as only checked in debug mode: semantically size() is never
+    // guaranteed to be related to any accessible range
+    _LIBCPP_ASSERT_UNCATEGORIZED(
+        false == ([&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
+          size_type __prod = 1;
+          return (__builtin_mul_overflow(__prod, extent(_Idxs), &__prod) || ... || false);
+        }(make_index_sequence<rank()>())),
+        "mdspan: size() is not representable as size_type");
+    return [&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
+      return ((static_cast<size_type>(__map_.extents().extent(_Idxs))) * ... * size_type(1));
+    }(make_index_sequence<rank()>());
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const noexcept {
+    return [&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
+      return (rank() > 0) && ((__map_.extents().extent(_Idxs) == index_type(0)) || ... || false);
+    }(make_index_sequence<rank()>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void swap(mdspan& __x, mdspan& __y) noexcept {
+    swap(__x.__ptr_, __y.__ptr_);
+    swap(__x.__map_, __y.__map_);
+    swap(__x.__acc_, __y.__acc_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept { return __map_.extents(); };
+  _LIBCPP_HIDE_FROM_ABI constexpr const data_handle_type& data_handle() const noexcept { return __ptr_; };
+  _LIBCPP_HIDE_FROM_ABI constexpr const mapping_type& mapping() const noexcept { return __map_; };
+  _LIBCPP_HIDE_FROM_ABI constexpr const accessor_type& accessor() const noexcept { return __acc_; };
+
+  // per LWG-4021 "mdspan::is_always_meow() should be noexcept"
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept { return mapping_type::is_always_unique(); };
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept {
+    return mapping_type::is_always_exhaustive();
+  };
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept {
+    return mapping_type::is_always_strided();
+  };
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool is_unique() const { return __map_.is_unique(); };
+  _LIBCPP_HIDE_FROM_ABI constexpr bool is_exhaustive() const { return __map_.is_exhaustive(); };
+  _LIBCPP_HIDE_FROM_ABI constexpr bool is_strided() const { return __map_.is_strided(); };
+  _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const { return __map_.stride(__r); };
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS data_handle_type __ptr_{};
+  _LIBCPP_NO_UNIQUE_ADDRESS mapping_type __map_{};
+  _LIBCPP_NO_UNIQUE_ADDRESS accessor_type __acc_{};
+
+  template <class, class, class, class>
+  friend class mdspan;
+};
+
+#  if _LIBCPP_STD_VER >= 26
+template <class _ElementType, class... _OtherIndexTypes>
+  requires((is_convertible_v<_OtherIndexTypes, size_t> && ...) && (sizeof...(_OtherIndexTypes) > 0))
+explicit mdspan(_ElementType*,
+                _OtherIndexTypes...) -> mdspan<_ElementType, extents<size_t, __maybe_static_ext<_OtherIndexTypes>...>>;
+#  else
+template <class _ElementType, class... _OtherIndexTypes>
+  requires((is_convertible_v<_OtherIndexTypes, size_t> && ...) && (sizeof...(_OtherIndexTypes) > 0))
+explicit mdspan(_ElementType*,
+                _OtherIndexTypes...) -> mdspan<_ElementType, dextents<size_t, sizeof...(_OtherIndexTypes)>>;
+#  endif
+
+template <class _Pointer>
+  requires(is_pointer_v<remove_reference_t<_Pointer>>)
+mdspan(_Pointer&&) -> mdspan<remove_pointer_t<remove_reference_t<_Pointer>>, extents<size_t>>;
+
+template <class _CArray>
+  requires(is_array_v<_CArray> && (rank_v<_CArray> == 1))
+mdspan(_CArray&) -> mdspan<remove_all_extents_t<_CArray>, extents<size_t, extent_v<_CArray, 0>>>;
+
+template <class _ElementType, class _OtherIndexType, size_t _Size>
+mdspan(_ElementType*, const array<_OtherIndexType, _Size>&) -> mdspan<_ElementType, dextents<size_t, _Size>>;
+
+template <class _ElementType, class _OtherIndexType, size_t _Size>
+mdspan(_ElementType*, span<_OtherIndexType, _Size>) -> mdspan<_ElementType, dextents<size_t, _Size>>;
+
+// This one is necessary because all the constructors take `data_handle_type`s, not
+// `_ElementType*`s, and `data_handle_type` is taken from `accessor_type::data_handle_type`, which
+// seems to throw off automatic deduction guides.
+template <class _ElementType, class _OtherIndexType, size_t... _ExtentsPack>
+mdspan(_ElementType*, const extents<_OtherIndexType, _ExtentsPack...>&)
+    -> mdspan<_ElementType, extents<_OtherIndexType, _ExtentsPack...>>;
+
+template <class _ElementType, class _MappingType>
+mdspan(_ElementType*, const _MappingType&)
+    -> mdspan<_ElementType, typename _MappingType::extents_type, typename _MappingType::layout_type>;
+
+template <class _MappingType, class _AccessorType>
+mdspan(const typename _AccessorType::data_handle_type, const _MappingType&, const _AccessorType&)
+    -> mdspan<typename _AccessorType::element_type,
+              typename _MappingType::extents_type,
+              typename _MappingType::layout_type,
+              _AccessorType>;
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___MDSPAN_MDSPAN_H
diff --git a/third_party/libcxx/__memory/addressof.h b/third_party/libcxx/__memory/addressof.h
index d4c69b83a..fa590212c 100644
--- a/third_party/libcxx/__memory/addressof.h
+++ b/third_party/libcxx/__memory/addressof.h
@@ -19,12 +19,8 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17
-_LIBCPP_NO_CFI _LIBCPP_INLINE_VISIBILITY
-_Tp*
-addressof(_Tp& __x) _NOEXCEPT
-{
-    return __builtin_addressof(__x);
+inline _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_NO_CFI _LIBCPP_HIDE_FROM_ABI _Tp* addressof(_Tp& __x) _NOEXCEPT {
+  return __builtin_addressof(__x);
 }
 
 #if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF)
@@ -33,42 +29,31 @@ addressof(_Tp& __x) _NOEXCEPT
 // _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler
 // itself is providing these definitions. Otherwise, we provide them.
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-__strong _Tp*
-addressof(__strong _Tp& __x) _NOEXCEPT
-{
+inline _LIBCPP_HIDE_FROM_ABI __strong _Tp* addressof(__strong _Tp& __x) _NOEXCEPT {
   return &__x;
 }
 
-#ifdef _LIBCPP_HAS_OBJC_ARC_WEAK
+#  ifdef _LIBCPP_HAS_OBJC_ARC_WEAK
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-__weak _Tp*
-addressof(__weak _Tp& __x) _NOEXCEPT
-{
+inline _LIBCPP_HIDE_FROM_ABI __weak _Tp* addressof(__weak _Tp& __x) _NOEXCEPT {
   return &__x;
 }
-#endif
+#  endif
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-__autoreleasing _Tp*
-addressof(__autoreleasing _Tp& __x) _NOEXCEPT
-{
+inline _LIBCPP_HIDE_FROM_ABI __autoreleasing _Tp* addressof(__autoreleasing _Tp& __x) _NOEXCEPT {
   return &__x;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-__unsafe_unretained _Tp*
-addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT
-{
+inline _LIBCPP_HIDE_FROM_ABI __unsafe_unretained _Tp* addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT {
   return &__x;
 }
 #endif
 
 #if !defined(_LIBCPP_CXX03_LANG)
-template <class _Tp> _Tp* addressof(const _Tp&&) noexcept = delete;
+template <class _Tp>
+_Tp* addressof(const _Tp&&) noexcept = delete;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__memory/align.h b/third_party/libcxx/__memory/align.h
index c6792206b..bbb995f4a 100644
--- a/third_party/libcxx/__memory/align.h
+++ b/third_party/libcxx/__memory/align.h
@@ -18,7 +18,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-_LIBCPP_FUNC_VIS void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
+_LIBCPP_EXPORTED_FROM_ABI void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__memory/aligned_alloc.h b/third_party/libcxx/__memory/aligned_alloc.h
index 786963c72..cb424328b 100644
--- a/third_party/libcxx/__memory/aligned_alloc.h
+++ b/third_party/libcxx/__memory/aligned_alloc.h
@@ -27,36 +27,34 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // chances are that you want to use `__libcpp_allocate` instead.
 //
 // Returns the allocated memory, or `nullptr` on failure.
-inline _LIBCPP_HIDE_FROM_ABI
-void* __libcpp_aligned_alloc(std::size_t __alignment, std::size_t __size) {
+inline _LIBCPP_HIDE_FROM_ABI void* __libcpp_aligned_alloc(std::size_t __alignment, std::size_t __size) {
 #  if defined(_LIBCPP_MSVCRT_LIKE)
-    return ::_aligned_malloc(__size, __alignment);
+  return ::_aligned_malloc(__size, __alignment);
 #  elif _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_C11_ALIGNED_ALLOC)
-    // aligned_alloc() requires that __size is a multiple of __alignment,
-    // but for C++ [new.delete.general], only states "if the value of an
-    // alignment argument passed to any of these functions is not a valid
-    // alignment value, the behavior is undefined".
-    // To handle calls such as ::operator new(1, std::align_val_t(128)), we
-    // round __size up to the next multiple of __alignment.
-    size_t __rounded_size = (__size + __alignment - 1) & ~(__alignment - 1);
-    // Rounding up could have wrapped around to zero, so we have to add another
-    // max() ternary to the actual call site to avoid succeeded in that case.
-    return ::aligned_alloc(__alignment, __size > __rounded_size ? __size : __rounded_size);
+  // aligned_alloc() requires that __size is a multiple of __alignment,
+  // but for C++ [new.delete.general], only states "if the value of an
+  // alignment argument passed to any of these functions is not a valid
+  // alignment value, the behavior is undefined".
+  // To handle calls such as ::operator new(1, std::align_val_t(128)), we
+  // round __size up to the next multiple of __alignment.
+  size_t __rounded_size = (__size + __alignment - 1) & ~(__alignment - 1);
+  // Rounding up could have wrapped around to zero, so we have to add another
+  // max() ternary to the actual call site to avoid succeeded in that case.
+  return ::aligned_alloc(__alignment, __size > __rounded_size ? __size : __rounded_size);
 #  else
-    void* __result = nullptr;
-    (void)::posix_memalign(&__result, __alignment, __size);
-    // If posix_memalign fails, __result is unmodified so we still return `nullptr`.
-    return __result;
+  void* __result = nullptr;
+  (void)::posix_memalign(&__result, __alignment, __size);
+  // If posix_memalign fails, __result is unmodified so we still return `nullptr`.
+  return __result;
 #  endif
 }
 
-inline _LIBCPP_HIDE_FROM_ABI
-void __libcpp_aligned_free(void* __ptr) {
-#if defined(_LIBCPP_MSVCRT_LIKE)
+inline _LIBCPP_HIDE_FROM_ABI void __libcpp_aligned_free(void* __ptr) {
+#  if defined(_LIBCPP_MSVCRT_LIKE)
   ::_aligned_free(__ptr);
-#else
+#  else
   ::free(__ptr);
-#endif
+#  endif
 }
 
 #endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
diff --git a/third_party/libcxx/__memory/allocate_at_least.h b/third_party/libcxx/__memory/allocate_at_least.h
index 8d8ad071e..df73d9a2e 100644
--- a/third_party/libcxx/__memory/allocate_at_least.h
+++ b/third_party/libcxx/__memory/allocate_at_least.h
@@ -20,29 +20,14 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 23
-template <class _Pointer>
-struct allocation_result {
-  _Pointer ptr;
-  size_t count;
-};
-_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(allocation_result);
 
 template <class _Alloc>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
-allocation_result<typename allocator_traits<_Alloc>::pointer> allocate_at_least(_Alloc& __alloc, size_t __n) {
-  if constexpr (requires { __alloc.allocate_at_least(__n); }) {
-    return __alloc.allocate_at_least(__n);
-  } else {
-    return {__alloc.allocate(__n), __n};
-  }
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto __allocate_at_least(_Alloc& __alloc, size_t __n) {
+  return std::allocator_traits<_Alloc>::allocate_at_least(__alloc, __n);
 }
 
-template <class _Alloc>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
-auto __allocate_at_least(_Alloc& __alloc, size_t __n) {
-  return std::allocate_at_least(__alloc, __n);
-}
 #else
+
 template <class _Pointer>
 struct __allocation_result {
   _Pointer ptr;
@@ -50,8 +35,9 @@ struct __allocation_result {
 };
 
 template <class _Alloc>
-_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-__allocation_result<typename allocator_traits<_Alloc>::pointer> __allocate_at_least(_Alloc& __alloc, size_t __n) {
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR __allocation_result<typename allocator_traits<_Alloc>::pointer>
+__allocate_at_least(_Alloc& __alloc, size_t __n) {
   return {__alloc.allocate(__n), __n};
 }
 
diff --git a/third_party/libcxx/__memory/allocation_guard.h b/third_party/libcxx/__memory/allocation_guard.h
index 424598cc8..cb870af7b 100644
--- a/third_party/libcxx/__memory/allocation_guard.h
+++ b/third_party/libcxx/__memory/allocation_guard.h
@@ -11,6 +11,7 @@
 #define _LIBCPP___MEMORY_ALLOCATION_GUARD_H
 
 #include <__config>
+#include <__memory/addressof.h>
 #include <__memory/allocator_traits.h>
 #include <__utility/move.h>
 #include <cstddef>
@@ -19,6 +20,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Helper class to allocate memory using an Allocator in an exception safe
@@ -40,44 +44,65 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 //
 // This is similar to a unique_ptr, except it's easier to use with a
 // custom allocator.
-template<class _Alloc>
+template <class _Alloc>
 struct __allocation_guard {
-    using _Pointer = typename allocator_traits<_Alloc>::pointer;
-    using _Size = typename allocator_traits<_Alloc>::size_type;
+  using _Pointer = typename allocator_traits<_Alloc>::pointer;
+  using _Size    = typename allocator_traits<_Alloc>::size_type;
 
-    template<class _AllocT> // we perform the allocator conversion inside the constructor
-    _LIBCPP_HIDE_FROM_ABI
-    explicit __allocation_guard(_AllocT __alloc, _Size __n)
-        : __alloc_(_VSTD::move(__alloc))
-        , __n_(__n)
-        , __ptr_(allocator_traits<_Alloc>::allocate(__alloc_, __n_)) // initialization order is important
-    { }
+  template <class _AllocT> // we perform the allocator conversion inside the constructor
+  _LIBCPP_HIDE_FROM_ABI explicit __allocation_guard(_AllocT __alloc, _Size __n)
+      : __alloc_(std::move(__alloc)),
+        __n_(__n),
+        __ptr_(allocator_traits<_Alloc>::allocate(__alloc_, __n_)) // initialization order is important
+  {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    ~__allocation_guard() _NOEXCEPT {
-        if (__ptr_ != nullptr) {
-            allocator_traits<_Alloc>::deallocate(__alloc_, __ptr_, __n_);
-        }
+  _LIBCPP_HIDE_FROM_ABI ~__allocation_guard() _NOEXCEPT { __destroy(); }
+
+  _LIBCPP_HIDE_FROM_ABI __allocation_guard(const __allocation_guard&) = delete;
+  _LIBCPP_HIDE_FROM_ABI __allocation_guard(__allocation_guard&& __other) _NOEXCEPT
+      : __alloc_(std::move(__other.__alloc_)),
+        __n_(__other.__n_),
+        __ptr_(__other.__ptr_) {
+    __other.__ptr_ = nullptr;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __allocation_guard& operator=(const __allocation_guard& __other) = delete;
+  _LIBCPP_HIDE_FROM_ABI __allocation_guard& operator=(__allocation_guard&& __other) _NOEXCEPT {
+    if (std::addressof(__other) != this) {
+      __destroy();
+
+      __alloc_       = std::move(__other.__alloc_);
+      __n_           = __other.__n_;
+      __ptr_         = __other.__ptr_;
+      __other.__ptr_ = nullptr;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Pointer __release_ptr() _NOEXCEPT { // not called __release() because it's a keyword in objective-c++
-        _Pointer __tmp = __ptr_;
-        __ptr_ = nullptr;
-        return __tmp;
-    }
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Pointer __get() const _NOEXCEPT {
-        return __ptr_;
-    }
+  _LIBCPP_HIDE_FROM_ABI _Pointer
+  __release_ptr() _NOEXCEPT { // not called __release() because it's a keyword in objective-c++
+    _Pointer __tmp = __ptr_;
+    __ptr_         = nullptr;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Pointer __get() const _NOEXCEPT { return __ptr_; }
 
 private:
-    _Alloc __alloc_;
-    _Size __n_;
-    _Pointer __ptr_;
+  _LIBCPP_HIDE_FROM_ABI void __destroy() _NOEXCEPT {
+    if (__ptr_ != nullptr) {
+      allocator_traits<_Alloc>::deallocate(__alloc_, __ptr_, __n_);
+    }
+  }
+
+  _Alloc __alloc_;
+  _Size __n_;
+  _Pointer __ptr_;
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_ALLOCATION_GUARD_H
diff --git a/third_party/libcxx/__memory/allocator.h b/third_party/libcxx/__memory/allocator.h
index badfea05e..2d8624e77 100644
--- a/third_party/libcxx/__memory/allocator.h
+++ b/third_party/libcxx/__memory/allocator.h
@@ -14,6 +14,7 @@
 #include <__memory/addressof.h>
 #include <__memory/allocate_at_least.h>
 #include <__memory/allocator_traits.h>
+#include <__type_traits/is_const.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_void.h>
@@ -28,37 +29,41 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> class allocator;
+template <class _Tp>
+class allocator;
 
-#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_VOID_SPECIALIZATION)
+#if _LIBCPP_STD_VER <= 17
 // These specializations shouldn't be marked _LIBCPP_DEPRECATED_IN_CXX17.
 // Specializing allocator<void> is deprecated, but not using it.
 template <>
-class _LIBCPP_TEMPLATE_VIS allocator<void>
-{
-#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
+class _LIBCPP_TEMPLATE_VIS allocator<void> {
 public:
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef void*             pointer;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const void*       const_pointer;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef void              value_type;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef void* pointer;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef const void* const_pointer;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef void value_type;
 
-    template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
-#endif
+  template <class _Up>
+  struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {
+    typedef allocator<_Up> other;
+  };
 };
 
+// TODO(LLVM 20): Remove the escape hatch
+#  ifdef _LIBCPP_ENABLE_REMOVED_ALLOCATOR_CONST
 template <>
-class _LIBCPP_TEMPLATE_VIS allocator<const void>
-{
-#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
+class _LIBCPP_TEMPLATE_VIS allocator<const void> {
 public:
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const void*       pointer;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const void*       const_pointer;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const void        value_type;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef const void* pointer;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef const void* const_pointer;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef const void value_type;
 
-    template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
-#endif
+  template <class _Up>
+  struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {
+    typedef allocator<_Up> other;
+  };
 };
-#endif
+#  endif // _LIBCPP_ENABLE_REMOVED_ALLOCATOR_CONST
+#endif   // _LIBCPP_STD_VER <= 17
 
 // This class provides a non-trivial default constructor to the class that derives from it
 // if the condition is satisfied.
@@ -73,12 +78,11 @@ public:
 // By making those __non_trivial_if base classes unique, we work around this problem and
 // it is safe to start deriving from __non_trivial_if in existing classes.
 template <bool _Cond, class _Unique>
-struct __non_trivial_if { };
+struct __non_trivial_if {};
 
 template <class _Unique>
 struct __non_trivial_if<true, _Unique> {
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR __non_trivial_if() _NOEXCEPT { }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __non_trivial_if() _NOEXCEPT {}
 };
 
 // allocator
@@ -87,184 +91,177 @@ struct __non_trivial_if<true, _Unique> {
 //       allocator<void> trivial in C++20.
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS allocator
-    : private __non_trivial_if<!is_void<_Tp>::value, allocator<_Tp> >
-{
-    static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types");
+class _LIBCPP_TEMPLATE_VIS allocator : private __non_trivial_if<!is_void<_Tp>::value, allocator<_Tp> > {
+  static_assert(!is_const<_Tp>::value, "std::allocator does not support const types");
+  static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types");
+
 public:
-    typedef size_t      size_type;
-    typedef ptrdiff_t   difference_type;
-    typedef _Tp         value_type;
-    typedef true_type   propagate_on_container_move_assignment;
-    typedef true_type   is_always_equal;
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator() _NOEXCEPT = default;
-
-    template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    allocator(const allocator<_Up>&) _NOEXCEPT { }
-
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    _Tp* allocate(size_t __n) {
-        if (__n > allocator_traits<allocator>::max_size(*this))
-            __throw_bad_array_new_length();
-        if (__libcpp_is_constant_evaluated()) {
-            return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
-        } else {
-            return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
-        }
-    }
-
-#if _LIBCPP_STD_VER >= 23
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
-    allocation_result<_Tp*> allocate_at_least(size_t __n) {
-        return {allocate(__n), __n};
-    }
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef _Tp value_type;
+  typedef true_type propagate_on_container_move_assignment;
+#if _LIBCPP_STD_VER <= 23 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_ALLOCATOR_MEMBERS)
+  _LIBCPP_DEPRECATED_IN_CXX23 typedef true_type is_always_equal;
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void deallocate(_Tp* __p, size_t __n) _NOEXCEPT {
-        if (__libcpp_is_constant_evaluated()) {
-            ::operator delete(__p);
-        } else {
-            _VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
-        }
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator() _NOEXCEPT = default;
 
-    // C++20 Removed members
-#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp*       pointer;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp&       reference;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator(const allocator<_Up>&) _NOEXCEPT {}
 
-    template <class _Up>
-    struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {
-        typedef allocator<_Up> other;
-    };
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp* allocate(size_t __n) {
+    if (__n > allocator_traits<allocator>::max_size(*this))
+      __throw_bad_array_new_length();
+    if (__libcpp_is_constant_evaluated()) {
+      return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
+    } else {
+      return static_cast<_Tp*>(std::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
+    }
+  }
 
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
-    pointer address(reference __x) const _NOEXCEPT {
-        return _VSTD::addressof(__x);
-    }
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
-    const_pointer address(const_reference __x) const _NOEXCEPT {
-        return _VSTD::addressof(__x);
-    }
+#if _LIBCPP_STD_VER >= 23
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr allocation_result<_Tp*> allocate_at_least(size_t __n) {
+    return {allocate(__n), __n};
+  }
+#endif
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
-    _Tp* allocate(size_t __n, const void*) {
-        return allocate(__n);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void deallocate(_Tp* __p, size_t __n) _NOEXCEPT {
+    if (__libcpp_is_constant_evaluated()) {
+      ::operator delete(__p);
+    } else {
+      std::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
     }
+  }
 
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT {
-        return size_type(~0) / sizeof(_Tp);
-    }
+  // C++20 Removed members
+#if _LIBCPP_STD_VER <= 17
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp* pointer;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp& reference;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
 
-    template <class _Up, class... _Args>
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
-    void construct(_Up* __p, _Args&&... __args) {
-        ::new ((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
-    }
+  template <class _Up>
+  struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {
+    typedef allocator<_Up> other;
+  };
 
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
-    void destroy(pointer __p) {
-        __p->~_Tp();
-    }
+  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI pointer address(reference __x) const _NOEXCEPT {
+    return std::addressof(__x);
+  }
+  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI const_pointer address(const_reference __x) const _NOEXCEPT {
+    return std::addressof(__x);
+  }
+
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_IN_CXX17 _Tp* allocate(size_t __n, const void*) {
+    return allocate(__n);
+  }
+
+  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+    return size_type(~0) / sizeof(_Tp);
+  }
+
+  template <class _Up, class... _Args>
+  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI void construct(_Up* __p, _Args&&... __args) {
+    ::new ((void*)__p) _Up(std::forward<_Args>(__args)...);
+  }
+
+  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI void destroy(pointer __p) { __p->~_Tp(); }
 #endif
 };
 
+// TODO(LLVM 20): Remove the escape hatch
+#ifdef _LIBCPP_ENABLE_REMOVED_ALLOCATOR_CONST
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS allocator<const _Tp>
-    : private __non_trivial_if<!is_void<_Tp>::value, allocator<const _Tp> >
-{
-    static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types");
+    : private __non_trivial_if<!is_void<_Tp>::value, allocator<const _Tp> > {
+  static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types");
+
 public:
-    typedef size_t      size_type;
-    typedef ptrdiff_t   difference_type;
-    typedef const _Tp   value_type;
-    typedef true_type   propagate_on_container_move_assignment;
-    typedef true_type   is_always_equal;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef const _Tp value_type;
+  typedef true_type propagate_on_container_move_assignment;
+#  if _LIBCPP_STD_VER <= 23 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_ALLOCATOR_MEMBERS)
+  _LIBCPP_DEPRECATED_IN_CXX23 typedef true_type is_always_equal;
+#  endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator() _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator() _NOEXCEPT = default;
 
-    template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    allocator(const allocator<_Up>&) _NOEXCEPT { }
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator(const allocator<_Up>&) _NOEXCEPT {}
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const _Tp* allocate(size_t __n) {
-        if (__n > allocator_traits<allocator>::max_size(*this))
-            __throw_bad_array_new_length();
-        if (__libcpp_is_constant_evaluated()) {
-            return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp)));
-        } else {
-            return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
-        }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const _Tp* allocate(size_t __n) {
+    if (__n > allocator_traits<allocator>::max_size(*this))
+      __throw_bad_array_new_length();
+    if (__libcpp_is_constant_evaluated()) {
+      return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp)));
+    } else {
+      return static_cast<const _Tp*>(std::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
     }
+  }
 
-#if _LIBCPP_STD_VER >= 23
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr
-    allocation_result<const _Tp*> allocate_at_least(size_t __n) {
-        return {allocate(__n), __n};
+#  if _LIBCPP_STD_VER >= 23
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr allocation_result<const _Tp*> allocate_at_least(size_t __n) {
+    return {allocate(__n), __n};
+  }
+#  endif
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void deallocate(const _Tp* __p, size_t __n) {
+    if (__libcpp_is_constant_evaluated()) {
+      ::operator delete(const_cast<_Tp*>(__p));
+    } else {
+      std::__libcpp_deallocate((void*)const_cast<_Tp*>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
     }
-#endif
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void deallocate(const _Tp* __p, size_t __n) {
-        if (__libcpp_is_constant_evaluated()) {
-            ::operator delete(const_cast<_Tp*>(__p));
-        } else {
-            _VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
-        }
-    }
+  // C++20 Removed members
+#  if _LIBCPP_STD_VER <= 17
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* pointer;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& reference;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
 
-    // C++20 Removed members
-#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* pointer;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& reference;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
+  template <class _Up>
+  struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {
+    typedef allocator<_Up> other;
+  };
 
-    template <class _Up>
-    struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {
-        typedef allocator<_Up> other;
-    };
+  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI const_pointer address(const_reference __x) const _NOEXCEPT {
+    return std::addressof(__x);
+  }
 
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
-    const_pointer address(const_reference __x) const _NOEXCEPT {
-        return _VSTD::addressof(__x);
-    }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_IN_CXX17 const _Tp* allocate(size_t __n, const void*) {
+    return allocate(__n);
+  }
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
-    const _Tp* allocate(size_t __n, const void*) {
-        return allocate(__n);
-    }
+  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+    return size_type(~0) / sizeof(_Tp);
+  }
 
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT {
-        return size_type(~0) / sizeof(_Tp);
-    }
+  template <class _Up, class... _Args>
+  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI void construct(_Up* __p, _Args&&... __args) {
+    ::new ((void*)__p) _Up(std::forward<_Args>(__args)...);
+  }
 
-    template <class _Up, class... _Args>
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
-    void construct(_Up* __p, _Args&&... __args) {
-        ::new ((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
-    }
-
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
-    void destroy(pointer __p) {
-        __p->~_Tp();
-    }
-#endif
+  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI void destroy(pointer __p) { __p->~_Tp(); }
+#  endif
 };
+#endif // _LIBCPP_ENABLE_REMOVED_ALLOCATOR_CONST
 
 template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {
+  return true;
+}
+
+#if _LIBCPP_STD_VER <= 17
 
 template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;}
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {
+  return false;
+}
+
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__memory/allocator_arg_t.h b/third_party/libcxx/__memory/allocator_arg_t.h
index 4d9c115f7..7e66da740 100644
--- a/third_party/libcxx/__memory/allocator_arg_t.h
+++ b/third_party/libcxx/__memory/allocator_arg_t.h
@@ -23,7 +23,9 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct _LIBCPP_TEMPLATE_VIS allocator_arg_t { explicit allocator_arg_t() = default; };
+struct _LIBCPP_TEMPLATE_VIS allocator_arg_t {
+  explicit allocator_arg_t() = default;
+};
 
 #if _LIBCPP_STD_VER >= 17
 inline constexpr allocator_arg_t allocator_arg = allocator_arg_t();
@@ -35,42 +37,35 @@ constexpr allocator_arg_t allocator_arg = allocator_arg_t();
 
 // allocator construction
 
-template <class _Tp, class _Alloc, class ..._Args>
-struct __uses_alloc_ctor_imp
-{
-    typedef _LIBCPP_NODEBUG __remove_cvref_t<_Alloc> _RawAlloc;
-    static const bool __ua = uses_allocator<_Tp, _RawAlloc>::value;
-    static const bool __ic =
-        is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
-    static const int value = __ua ? 2 - __ic : 0;
+template <class _Tp, class _Alloc, class... _Args>
+struct __uses_alloc_ctor_imp {
+  typedef _LIBCPP_NODEBUG __remove_cvref_t<_Alloc> _RawAlloc;
+  static const bool __ua = uses_allocator<_Tp, _RawAlloc>::value;
+  static const bool __ic = is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
+  static const int value = __ua ? 2 - __ic : 0;
 };
 
-template <class _Tp, class _Alloc, class ..._Args>
-struct __uses_alloc_ctor
-    : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
-    {};
+template <class _Tp, class _Alloc, class... _Args>
+struct __uses_alloc_ctor : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value> {};
 
 template <class _Tp, class _Allocator, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args )
-{
-    new (__storage) _Tp (_VSTD::forward<_Args>(__args)...);
+inline _LIBCPP_HIDE_FROM_ABI void
+__user_alloc_construct_impl(integral_constant<int, 0>, _Tp* __storage, const _Allocator&, _Args&&... __args) {
+  new (__storage) _Tp(std::forward<_Args>(__args)...);
 }
 
 // FIXME: This should have a version which takes a non-const alloc.
 template <class _Tp, class _Allocator, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
-{
-    new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...);
+inline _LIBCPP_HIDE_FROM_ABI void
+__user_alloc_construct_impl(integral_constant<int, 1>, _Tp* __storage, const _Allocator& __a, _Args&&... __args) {
+  new (__storage) _Tp(allocator_arg, __a, std::forward<_Args>(__args)...);
 }
 
 // FIXME: This should have a version which takes a non-const alloc.
 template <class _Tp, class _Allocator, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
-{
-    new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a);
+inline _LIBCPP_HIDE_FROM_ABI void
+__user_alloc_construct_impl(integral_constant<int, 2>, _Tp* __storage, const _Allocator& __a, _Args&&... __args) {
+  new (__storage) _Tp(std::forward<_Args>(__args)..., __a);
 }
 
 #endif // _LIBCPP_CXX03_LANG
diff --git a/third_party/libcxx/__memory/allocator_destructor.h b/third_party/libcxx/__memory/allocator_destructor.h
index 623ad8ad8..ed3d8918f 100644
--- a/third_party/libcxx/__memory/allocator_destructor.h
+++ b/third_party/libcxx/__memory/allocator_destructor.h
@@ -19,22 +19,20 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Alloc>
-class __allocator_destructor
-{
-    typedef _LIBCPP_NODEBUG allocator_traits<_Alloc> __alloc_traits;
+class __allocator_destructor {
+  typedef _LIBCPP_NODEBUG allocator_traits<_Alloc> __alloc_traits;
+
 public:
-    typedef _LIBCPP_NODEBUG typename __alloc_traits::pointer pointer;
-    typedef _LIBCPP_NODEBUG typename __alloc_traits::size_type size_type;
+  typedef _LIBCPP_NODEBUG typename __alloc_traits::pointer pointer;
+  typedef _LIBCPP_NODEBUG typename __alloc_traits::size_type size_type;
+
 private:
-    _Alloc& __alloc_;
-    size_type __s_;
+  _Alloc& __alloc_;
+  size_type __s_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY __allocator_destructor(_Alloc& __a, size_type __s)
-             _NOEXCEPT
-        : __alloc_(__a), __s_(__s) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
-        {__alloc_traits::deallocate(__alloc_, __p, __s_);}
+  _LIBCPP_HIDE_FROM_ABI __allocator_destructor(_Alloc& __a, size_type __s) _NOEXCEPT : __alloc_(__a), __s_(__s) {}
+  _LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT { __alloc_traits::deallocate(__alloc_, __p, __s_); }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__memory/allocator_traits.h b/third_party/libcxx/__memory/allocator_traits.h
index 4658098d6..c5fcc8932 100644
--- a/third_party/libcxx/__memory/allocator_traits.h
+++ b/third_party/libcxx/__memory/allocator_traits.h
@@ -14,14 +14,15 @@
 #include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__type_traits/enable_if.h>
-#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/is_empty.h>
-#include <__type_traits/is_move_constructible.h>
+#include <__type_traits/is_same.h>
 #include <__type_traits/make_unsigned.h>
 #include <__type_traits/remove_reference.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <cstddef>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -33,326 +34,334 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#define _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(NAME, PROPERTY)                \
-    template <class _Tp, class = void> struct NAME : false_type { };    \
-    template <class _Tp>               struct NAME<_Tp, __void_t<typename _Tp:: PROPERTY > > : true_type { }
+#define _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(NAME, PROPERTY)                                                               \
+  template <class _Tp, class = void>                                                                                   \
+  struct NAME : false_type {};                                                                                         \
+  template <class _Tp>                                                                                                 \
+  struct NAME<_Tp, __void_t<typename _Tp::PROPERTY > > : true_type {}
 
 // __pointer
-_LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_pointer, pointer);
-template <class _Tp, class _Alloc,
+template <class _Tp,
+          class _Alloc,
           class _RawAlloc = __libcpp_remove_reference_t<_Alloc>,
-          bool = __has_pointer<_RawAlloc>::value>
+          bool            = __has_pointer<_RawAlloc>::value>
 struct __pointer {
-    using type _LIBCPP_NODEBUG = typename _RawAlloc::pointer;
+  using type _LIBCPP_NODEBUG = typename _RawAlloc::pointer;
 };
 template <class _Tp, class _Alloc, class _RawAlloc>
 struct __pointer<_Tp, _Alloc, _RawAlloc, false> {
-    using type _LIBCPP_NODEBUG = _Tp*;
+  using type _LIBCPP_NODEBUG = _Tp*;
 };
 
 // __const_pointer
 _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_const_pointer, const_pointer);
-template <class _Tp, class _Ptr, class _Alloc,
-          bool = __has_const_pointer<_Alloc>::value>
+template <class _Tp, class _Ptr, class _Alloc, bool = __has_const_pointer<_Alloc>::value>
 struct __const_pointer {
-    using type _LIBCPP_NODEBUG = typename _Alloc::const_pointer;
+  using type _LIBCPP_NODEBUG = typename _Alloc::const_pointer;
 };
 template <class _Tp, class _Ptr, class _Alloc>
 struct __const_pointer<_Tp, _Ptr, _Alloc, false> {
 #ifdef _LIBCPP_CXX03_LANG
-    using type = typename pointer_traits<_Ptr>::template rebind<const _Tp>::other;
+  using type = typename pointer_traits<_Ptr>::template rebind<const _Tp>::other;
 #else
-    using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const _Tp>;
+  using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const _Tp>;
 #endif
 };
 
 // __void_pointer
 _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_void_pointer, void_pointer);
-template <class _Ptr, class _Alloc,
-          bool = __has_void_pointer<_Alloc>::value>
+template <class _Ptr, class _Alloc, bool = __has_void_pointer<_Alloc>::value>
 struct __void_pointer {
-    using type _LIBCPP_NODEBUG = typename _Alloc::void_pointer;
+  using type _LIBCPP_NODEBUG = typename _Alloc::void_pointer;
 };
 template <class _Ptr, class _Alloc>
 struct __void_pointer<_Ptr, _Alloc, false> {
 #ifdef _LIBCPP_CXX03_LANG
-    using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<void>::other;
+  using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<void>::other;
 #else
-    using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<void>;
+  using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<void>;
 #endif
 };
 
 // __const_void_pointer
 _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_const_void_pointer, const_void_pointer);
-template <class _Ptr, class _Alloc,
-          bool = __has_const_void_pointer<_Alloc>::value>
+template <class _Ptr, class _Alloc, bool = __has_const_void_pointer<_Alloc>::value>
 struct __const_void_pointer {
-    using type _LIBCPP_NODEBUG = typename _Alloc::const_void_pointer;
+  using type _LIBCPP_NODEBUG = typename _Alloc::const_void_pointer;
 };
 template <class _Ptr, class _Alloc>
 struct __const_void_pointer<_Ptr, _Alloc, false> {
 #ifdef _LIBCPP_CXX03_LANG
-    using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const void>::other;
+  using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const void>::other;
 #else
-    using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const void>;
+  using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::template rebind<const void>;
 #endif
 };
 
 // __size_type
 _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_size_type, size_type);
 template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value>
-struct __size_type : make_unsigned<_DiffType> { };
+struct __size_type : make_unsigned<_DiffType> {};
 template <class _Alloc, class _DiffType>
 struct __size_type<_Alloc, _DiffType, true> {
-    using type _LIBCPP_NODEBUG = typename _Alloc::size_type;
+  using type _LIBCPP_NODEBUG = typename _Alloc::size_type;
 };
 
 // __alloc_traits_difference_type
 _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_alloc_traits_difference_type, difference_type);
 template <class _Alloc, class _Ptr, bool = __has_alloc_traits_difference_type<_Alloc>::value>
 struct __alloc_traits_difference_type {
-    using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::difference_type;
+  using type _LIBCPP_NODEBUG = typename pointer_traits<_Ptr>::difference_type;
 };
 template <class _Alloc, class _Ptr>
 struct __alloc_traits_difference_type<_Alloc, _Ptr, true> {
-    using type _LIBCPP_NODEBUG = typename _Alloc::difference_type;
+  using type _LIBCPP_NODEBUG = typename _Alloc::difference_type;
 };
 
 // __propagate_on_container_copy_assignment
 _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_copy_assignment, propagate_on_container_copy_assignment);
 template <class _Alloc, bool = __has_propagate_on_container_copy_assignment<_Alloc>::value>
-struct __propagate_on_container_copy_assignment : false_type { };
+struct __propagate_on_container_copy_assignment : false_type {};
 template <class _Alloc>
 struct __propagate_on_container_copy_assignment<_Alloc, true> {
-    using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_copy_assignment;
+  using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_copy_assignment;
 };
 
 // __propagate_on_container_move_assignment
 _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_move_assignment, propagate_on_container_move_assignment);
 template <class _Alloc, bool = __has_propagate_on_container_move_assignment<_Alloc>::value>
-struct __propagate_on_container_move_assignment : false_type { };
+struct __propagate_on_container_move_assignment : false_type {};
 template <class _Alloc>
 struct __propagate_on_container_move_assignment<_Alloc, true> {
-    using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_move_assignment;
+  using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_move_assignment;
 };
 
 // __propagate_on_container_swap
 _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_propagate_on_container_swap, propagate_on_container_swap);
 template <class _Alloc, bool = __has_propagate_on_container_swap<_Alloc>::value>
-struct __propagate_on_container_swap : false_type { };
+struct __propagate_on_container_swap : false_type {};
 template <class _Alloc>
 struct __propagate_on_container_swap<_Alloc, true> {
-    using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_swap;
+  using type _LIBCPP_NODEBUG = typename _Alloc::propagate_on_container_swap;
 };
 
 // __is_always_equal
 _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX(__has_is_always_equal, is_always_equal);
 template <class _Alloc, bool = __has_is_always_equal<_Alloc>::value>
-struct __is_always_equal : is_empty<_Alloc> { };
+struct __is_always_equal : is_empty<_Alloc> {};
 template <class _Alloc>
 struct __is_always_equal<_Alloc, true> {
-    using type _LIBCPP_NODEBUG = typename _Alloc::is_always_equal;
+  using type _LIBCPP_NODEBUG = typename _Alloc::is_always_equal;
 };
 
 // __allocator_traits_rebind
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Tp, class _Up, class = void>
-struct __has_rebind_other : false_type { };
+struct __has_rebind_other : false_type {};
 template <class _Tp, class _Up>
-struct __has_rebind_other<_Tp, _Up, __void_t<typename _Tp::template rebind<_Up>::other> > : true_type { };
+struct __has_rebind_other<_Tp, _Up, __void_t<typename _Tp::template rebind<_Up>::other> > : true_type {};
 
 template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
 struct __allocator_traits_rebind {
   static_assert(__has_rebind_other<_Tp, _Up>::value, "This allocator has to implement rebind");
   using type _LIBCPP_NODEBUG = typename _Tp::template rebind<_Up>::other;
 };
-template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
+template <template <class, class...> class _Alloc, class _Tp, class... _Args, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true> {
-    using type _LIBCPP_NODEBUG = typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other;
+  using type _LIBCPP_NODEBUG = typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other;
 };
-template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
+template <template <class, class...> class _Alloc, class _Tp, class... _Args, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false> {
-    using type _LIBCPP_NODEBUG = _Alloc<_Up, _Args...>;
+  using type _LIBCPP_NODEBUG = _Alloc<_Up, _Args...>;
 };
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-template<class _Alloc, class _Tp>
+template <class _Alloc, class _Tp>
 using __allocator_traits_rebind_t = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 
 // __has_allocate_hint
 template <class _Alloc, class _SizeType, class _ConstVoidPtr, class = void>
-struct __has_allocate_hint : false_type { };
+struct __has_allocate_hint : false_type {};
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
-struct __has_allocate_hint<_Alloc, _SizeType, _ConstVoidPtr, decltype(
-    (void)std::declval<_Alloc>().allocate(std::declval<_SizeType>(), std::declval<_ConstVoidPtr>())
-)> : true_type { };
+struct __has_allocate_hint<
+    _Alloc,
+    _SizeType,
+    _ConstVoidPtr,
+    decltype((void)std::declval<_Alloc>().allocate(std::declval<_SizeType>(), std::declval<_ConstVoidPtr>()))>
+    : true_type {};
 
 // __has_construct
-template <class, class _Alloc, class ..._Args>
-struct __has_construct_impl : false_type { };
+template <class, class _Alloc, class... _Args>
+struct __has_construct_impl : false_type {};
 
-template <class _Alloc, class ..._Args>
-struct __has_construct_impl<decltype(
-    (void)std::declval<_Alloc>().construct(std::declval<_Args>()...)
-), _Alloc, _Args...> : true_type { };
+template <class _Alloc, class... _Args>
+struct __has_construct_impl<decltype((void)std::declval<_Alloc>().construct(std::declval<_Args>()...)),
+                            _Alloc,
+                            _Args...> : true_type {};
 
-template <class _Alloc, class ..._Args>
-struct __has_construct : __has_construct_impl<void, _Alloc, _Args...> { };
+template <class _Alloc, class... _Args>
+struct __has_construct : __has_construct_impl<void, _Alloc, _Args...> {};
 
 // __has_destroy
 template <class _Alloc, class _Pointer, class = void>
-struct __has_destroy : false_type { };
+struct __has_destroy : false_type {};
 
 template <class _Alloc, class _Pointer>
-struct __has_destroy<_Alloc, _Pointer, decltype(
-    (void)std::declval<_Alloc>().destroy(std::declval<_Pointer>())
-)> : true_type { };
+struct __has_destroy<_Alloc, _Pointer, decltype((void)std::declval<_Alloc>().destroy(std::declval<_Pointer>()))>
+    : true_type {};
 
 // __has_max_size
 template <class _Alloc, class = void>
-struct __has_max_size : false_type { };
+struct __has_max_size : false_type {};
 
 template <class _Alloc>
-struct __has_max_size<_Alloc, decltype(
-    (void)std::declval<_Alloc&>().max_size()
-)> : true_type { };
+struct __has_max_size<_Alloc, decltype((void)std::declval<_Alloc&>().max_size())> : true_type {};
 
 // __has_select_on_container_copy_construction
 template <class _Alloc, class = void>
-struct __has_select_on_container_copy_construction : false_type { };
+struct __has_select_on_container_copy_construction : false_type {};
 
 template <class _Alloc>
-struct __has_select_on_container_copy_construction<_Alloc, decltype(
-    (void)std::declval<_Alloc>().select_on_container_copy_construction()
-)> : true_type { };
+struct __has_select_on_container_copy_construction<
+    _Alloc,
+    decltype((void)std::declval<_Alloc>().select_on_container_copy_construction())> : true_type {};
 
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Pointer, class _SizeType = size_t>
+struct allocation_result {
+  _Pointer ptr;
+  _SizeType count;
+};
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(allocation_result);
+
+#endif // _LIBCPP_STD_VER
+
 template <class _Alloc>
-struct _LIBCPP_TEMPLATE_VIS allocator_traits
-{
-    using allocator_type = _Alloc;
-    using value_type = typename allocator_type::value_type;
-    using pointer = typename __pointer<value_type, allocator_type>::type;
-    using const_pointer = typename __const_pointer<value_type, pointer, allocator_type>::type;
-    using void_pointer = typename __void_pointer<pointer, allocator_type>::type;
-    using const_void_pointer = typename __const_void_pointer<pointer, allocator_type>::type;
-    using difference_type = typename __alloc_traits_difference_type<allocator_type, pointer>::type;
-    using size_type = typename __size_type<allocator_type, difference_type>::type;
-    using propagate_on_container_copy_assignment = typename __propagate_on_container_copy_assignment<allocator_type>::type;
-    using propagate_on_container_move_assignment = typename __propagate_on_container_move_assignment<allocator_type>::type;
-    using propagate_on_container_swap = typename __propagate_on_container_swap<allocator_type>::type;
-    using is_always_equal = typename __is_always_equal<allocator_type>::type;
+struct _LIBCPP_TEMPLATE_VIS allocator_traits {
+  using allocator_type     = _Alloc;
+  using value_type         = typename allocator_type::value_type;
+  using pointer            = typename __pointer<value_type, allocator_type>::type;
+  using const_pointer      = typename __const_pointer<value_type, pointer, allocator_type>::type;
+  using void_pointer       = typename __void_pointer<pointer, allocator_type>::type;
+  using const_void_pointer = typename __const_void_pointer<pointer, allocator_type>::type;
+  using difference_type    = typename __alloc_traits_difference_type<allocator_type, pointer>::type;
+  using size_type          = typename __size_type<allocator_type, difference_type>::type;
+  using propagate_on_container_copy_assignment =
+      typename __propagate_on_container_copy_assignment<allocator_type>::type;
+  using propagate_on_container_move_assignment =
+      typename __propagate_on_container_move_assignment<allocator_type>::type;
+  using propagate_on_container_swap = typename __propagate_on_container_swap<allocator_type>::type;
+  using is_always_equal             = typename __is_always_equal<allocator_type>::type;
 
 #ifndef _LIBCPP_CXX03_LANG
-    template <class _Tp>
-    using rebind_alloc = __allocator_traits_rebind_t<allocator_type, _Tp>;
-    template <class _Tp>
-    using rebind_traits = allocator_traits<rebind_alloc<_Tp> >;
+  template <class _Tp>
+  using rebind_alloc = __allocator_traits_rebind_t<allocator_type, _Tp>;
+  template <class _Tp>
+  using rebind_traits = allocator_traits<rebind_alloc<_Tp> >;
 #else  // _LIBCPP_CXX03_LANG
-    template <class _Tp>
-    struct rebind_alloc {
-        using other = __allocator_traits_rebind_t<allocator_type, _Tp>;
-    };
-    template <class _Tp>
-    struct rebind_traits {
-        using other = allocator_traits<typename rebind_alloc<_Tp>::other>;
-    };
+  template <class _Tp>
+  struct rebind_alloc {
+    using other = __allocator_traits_rebind_t<allocator_type, _Tp>;
+  };
+  template <class _Tp>
+  struct rebind_traits {
+    using other = allocator_traits<typename rebind_alloc<_Tp>::other>;
+  };
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static pointer allocate(allocator_type& __a, size_type __n) {
-        return __a.allocate(__n);
-    }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static pointer
+  allocate(allocator_type& __a, size_type __n) {
+    return __a.allocate(__n);
+  }
 
-    template <class _Ap = _Alloc, class =
-        __enable_if_t<__has_allocate_hint<_Ap, size_type, const_void_pointer>::value> >
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) {
-        _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-        return __a.allocate(__n, __hint);
-        _LIBCPP_SUPPRESS_DEPRECATED_POP
-    }
-    template <class _Ap = _Alloc, class = void, class =
-        __enable_if_t<!__has_allocate_hint<_Ap, size_type, const_void_pointer>::value> >
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer) {
-        return __a.allocate(__n);
-    }
+  template <class _Ap = _Alloc, __enable_if_t<__has_allocate_hint<_Ap, size_type, const_void_pointer>::value, int> = 0>
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static pointer
+  allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) {
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    return __a.allocate(__n, __hint);
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
+  }
+  template <class _Ap                                                                           = _Alloc,
+            class                                                                               = void,
+            __enable_if_t<!__has_allocate_hint<_Ap, size_type, const_void_pointer>::value, int> = 0>
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static pointer
+  allocate(allocator_type& __a, size_type __n, const_void_pointer) {
+    return __a.allocate(__n);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT {
-        __a.deallocate(__p, __n);
+#if _LIBCPP_STD_VER >= 23
+  template <class _Ap = _Alloc>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr allocation_result<pointer, size_type>
+  allocate_at_least(_Ap& __alloc, size_type __n) {
+    if constexpr (requires { __alloc.allocate_at_least(__n); }) {
+      return __alloc.allocate_at_least(__n);
+    } else {
+      return {__alloc.allocate(__n), __n};
     }
-
-    template <class _Tp, class... _Args, class =
-        __enable_if_t<__has_construct<allocator_type, _Tp*, _Args...>::value> >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args) {
-        _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-        __a.construct(__p, _VSTD::forward<_Args>(__args)...);
-        _LIBCPP_SUPPRESS_DEPRECATED_POP
-    }
-    template <class _Tp, class... _Args, class = void, class =
-        __enable_if_t<!__has_construct<allocator_type, _Tp*, _Args...>::value> >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static void construct(allocator_type&, _Tp* __p, _Args&&... __args) {
-#if _LIBCPP_STD_VER >= 20
-        _VSTD::construct_at(__p, _VSTD::forward<_Args>(__args)...);
-#else
-        ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
+  }
 #endif
-    }
 
-    template <class _Tp, class =
-        __enable_if_t<__has_destroy<allocator_type, _Tp*>::value> >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static void destroy(allocator_type& __a, _Tp* __p) {
-        _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-        __a.destroy(__p);
-        _LIBCPP_SUPPRESS_DEPRECATED_POP
-    }
-    template <class _Tp, class = void, class =
-        __enable_if_t<!__has_destroy<allocator_type, _Tp*>::value> >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static void destroy(allocator_type&, _Tp* __p) {
-#if _LIBCPP_STD_VER >= 20
-        _VSTD::destroy_at(__p);
-#else
-        __p->~_Tp();
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void
+  deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT {
+    __a.deallocate(__p, __n);
+  }
 
-    template <class _Ap = _Alloc, class =
-        __enable_if_t<__has_max_size<const _Ap>::value> >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static size_type max_size(const allocator_type& __a) _NOEXCEPT {
-        _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-        return __a.max_size();
-        _LIBCPP_SUPPRESS_DEPRECATED_POP
-    }
-    template <class _Ap = _Alloc, class = void, class =
-        __enable_if_t<!__has_max_size<const _Ap>::value> >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static size_type max_size(const allocator_type&) _NOEXCEPT {
-        return numeric_limits<size_type>::max() / sizeof(value_type);
-    }
+  template <class _Tp, class... _Args, __enable_if_t<__has_construct<allocator_type, _Tp*, _Args...>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void
+  construct(allocator_type& __a, _Tp* __p, _Args&&... __args) {
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    __a.construct(__p, std::forward<_Args>(__args)...);
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
+  }
+  template <class _Tp,
+            class... _Args,
+            class                                                                       = void,
+            __enable_if_t<!__has_construct<allocator_type, _Tp*, _Args...>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void
+  construct(allocator_type&, _Tp* __p, _Args&&... __args) {
+    std::__construct_at(__p, std::forward<_Args>(__args)...);
+  }
 
-    template <class _Ap = _Alloc, class =
-        __enable_if_t<__has_select_on_container_copy_construction<const _Ap>::value> >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static allocator_type select_on_container_copy_construction(const allocator_type& __a) {
-        return __a.select_on_container_copy_construction();
-    }
-    template <class _Ap = _Alloc, class = void, class =
-        __enable_if_t<!__has_select_on_container_copy_construction<const _Ap>::value> >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static allocator_type select_on_container_copy_construction(const allocator_type& __a) {
-        return __a;
-    }
+  template <class _Tp, __enable_if_t<__has_destroy<allocator_type, _Tp*>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void destroy(allocator_type& __a, _Tp* __p) {
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    __a.destroy(__p);
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
+  }
+  template <class _Tp, class = void, __enable_if_t<!__has_destroy<allocator_type, _Tp*>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void destroy(allocator_type&, _Tp* __p) {
+    std::__destroy_at(__p);
+  }
+
+  template <class _Ap = _Alloc, __enable_if_t<__has_max_size<const _Ap>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static size_type max_size(const allocator_type& __a) _NOEXCEPT {
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    return __a.max_size();
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
+  }
+  template <class _Ap = _Alloc, class = void, __enable_if_t<!__has_max_size<const _Ap>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static size_type max_size(const allocator_type&) _NOEXCEPT {
+    return numeric_limits<size_type>::max() / sizeof(value_type);
+  }
+
+  template <class _Ap = _Alloc, __enable_if_t<__has_select_on_container_copy_construction<const _Ap>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static allocator_type
+  select_on_container_copy_construction(const allocator_type& __a) {
+    return __a.select_on_container_copy_construction();
+  }
+  template <class _Ap                                                                          = _Alloc,
+            class                                                                              = void,
+            __enable_if_t<!__has_select_on_container_copy_construction<const _Ap>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static allocator_type
+  select_on_container_copy_construction(const allocator_type& __a) {
+    return __a;
+  }
 };
 
 #ifndef _LIBCPP_CXX03_LANG
@@ -363,62 +372,48 @@ template <class _Traits, class _Tp>
 using __rebind_alloc = typename _Traits::template rebind_alloc<_Tp>::other;
 #endif
 
+template <class _Alloc>
+struct __check_valid_allocator : true_type {
+  using _Traits = std::allocator_traits<_Alloc>;
+  static_assert(is_same<_Alloc, __rebind_alloc<_Traits, typename _Traits::value_type> >::value,
+                "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
+                "original allocator");
+};
+
 // __is_default_allocator
 template <class _Tp>
-struct __is_default_allocator : false_type { };
+struct __is_default_allocator : false_type {};
 
-template <class> class allocator;
+template <class>
+class allocator;
 
 template <class _Tp>
-struct __is_default_allocator<allocator<_Tp> > : true_type { };
+struct __is_default_allocator<allocator<_Tp> > : true_type {};
 
 // __is_cpp17_move_insertable
 template <class _Alloc, class = void>
-struct __is_cpp17_move_insertable
-    : is_move_constructible<typename _Alloc::value_type>
-{ };
+struct __is_cpp17_move_insertable : is_move_constructible<typename _Alloc::value_type> {};
 
 template <class _Alloc>
-struct __is_cpp17_move_insertable<_Alloc, __enable_if_t<
-    !__is_default_allocator<_Alloc>::value &&
-    __has_construct<_Alloc, typename _Alloc::value_type*, typename _Alloc::value_type&&>::value
-> > : true_type { };
+struct __is_cpp17_move_insertable<
+    _Alloc,
+    __enable_if_t< !__is_default_allocator<_Alloc>::value &&
+                   __has_construct<_Alloc, typename _Alloc::value_type*, typename _Alloc::value_type&&>::value > >
+    : true_type {};
 
 // __is_cpp17_copy_insertable
 template <class _Alloc, class = void>
 struct __is_cpp17_copy_insertable
     : integral_constant<bool,
-        is_copy_constructible<typename _Alloc::value_type>::value &&
-        __is_cpp17_move_insertable<_Alloc>::value
-    >
-{ };
+                        is_copy_constructible<typename _Alloc::value_type>::value &&
+                            __is_cpp17_move_insertable<_Alloc>::value > {};
 
 template <class _Alloc>
-struct __is_cpp17_copy_insertable<_Alloc, __enable_if_t<
-    !__is_default_allocator<_Alloc>::value &&
-    __has_construct<_Alloc, typename _Alloc::value_type*, const typename _Alloc::value_type&>::value
-> >
-    : __is_cpp17_move_insertable<_Alloc>
-{ };
-
-// ASan choices
-#ifndef _LIBCPP_HAS_NO_ASAN
-#   define _LIBCPP_HAS_ASAN_CONTAINER_ANNOTATIONS_FOR_ALL_ALLOCATORS 1
-#endif
-
-#ifdef _LIBCPP_HAS_ASAN_CONTAINER_ANNOTATIONS_FOR_ALL_ALLOCATORS
-template <class _Alloc>
-struct __asan_annotate_container_with_allocator
-#   if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 1600
-      : true_type {};
-#   else
-      // TODO(LLVM-18): Remove the special-casing
-      : false_type {};
-#   endif
-
-template <class _Tp>
-struct __asan_annotate_container_with_allocator<allocator<_Tp> > : true_type {};
-#endif
+struct __is_cpp17_copy_insertable<
+    _Alloc,
+    __enable_if_t< !__is_default_allocator<_Alloc>::value &&
+                   __has_construct<_Alloc, typename _Alloc::value_type*, const typename _Alloc::value_type&>::value > >
+    : __is_cpp17_move_insertable<_Alloc> {};
 
 #undef _LIBCPP_ALLOCATOR_TRAITS_HAS_XXX
 
diff --git a/third_party/libcxx/__memory/assume_aligned.h b/third_party/libcxx/__memory/assume_aligned.h
index 1f505f592..526eb3334 100644
--- a/third_party/libcxx/__memory/assume_aligned.h
+++ b/third_party/libcxx/__memory/assume_aligned.h
@@ -22,21 +22,25 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+template <size_t _Np, class _Tp>
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __assume_aligned(_Tp* __ptr) {
+  static_assert(_Np != 0 && (_Np & (_Np - 1)) == 0, "std::assume_aligned<N>(p) requires N to be a power of two");
+
+  if (__libcpp_is_constant_evaluated()) {
+    (void)__builtin_assume_aligned(__ptr, _Np);
+    return __ptr;
+  } else {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        reinterpret_cast<uintptr_t>(__ptr) % _Np == 0, "Alignment assumption is violated");
+    return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Np));
+  }
+}
+
 #if _LIBCPP_STD_VER >= 20
 
 template <size_t _Np, class _Tp>
-[[nodiscard]]
-_LIBCPP_HIDE_FROM_ABI
-constexpr _Tp* assume_aligned(_Tp* __ptr) {
-  static_assert(_Np != 0 && (_Np & (_Np - 1)) == 0,
-    "std::assume_aligned<N>(p) requires N to be a power of two");
-
-  if (is_constant_evaluated()) {
-    return __ptr;
-  } else {
-    _LIBCPP_ASSERT(reinterpret_cast<uintptr_t>(__ptr) % _Np == 0, "Alignment assumption is violated");
-    return static_cast<_Tp*>(__builtin_assume_aligned(__ptr, _Np));
-  }
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp* assume_aligned(_Tp* __ptr) {
+  return std::__assume_aligned<_Np>(__ptr);
 }
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__memory/auto_ptr.h b/third_party/libcxx/__memory/auto_ptr.h
index c007b4d21..752143616 100644
--- a/third_party/libcxx/__memory/auto_ptr.h
+++ b/third_party/libcxx/__memory/auto_ptr.h
@@ -21,60 +21,68 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr_ref
-{
-    _Tp* __ptr_;
+struct _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr_ref {
+  _Tp* __ptr_;
 };
 
-template<class _Tp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr
-{
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr {
 private:
-    _Tp* __ptr_;
+  _Tp* __ptr_;
+
 public:
-    typedef _Tp element_type;
+  typedef _Tp element_type;
 
-    _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) _NOEXCEPT : __ptr_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) _NOEXCEPT : __ptr_(__p.release()) {}
-    template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr<_Up>& __p) _NOEXCEPT
-        : __ptr_(__p.release()) {}
-    _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr& __p) _NOEXCEPT
-        {reset(__p.release()); return *this;}
-    template<class _Up> _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr<_Up>& __p) _NOEXCEPT
-        {reset(__p.release()); return *this;}
-    _LIBCPP_INLINE_VISIBILITY auto_ptr& operator=(auto_ptr_ref<_Tp> __p) _NOEXCEPT
-        {reset(__p.__ptr_); return *this;}
-    _LIBCPP_INLINE_VISIBILITY ~auto_ptr() _NOEXCEPT {delete __ptr_;}
+  _LIBCPP_HIDE_FROM_ABI explicit auto_ptr(_Tp* __p = 0) _NOEXCEPT : __ptr_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI auto_ptr(auto_ptr& __p) _NOEXCEPT : __ptr_(__p.release()) {}
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI auto_ptr(auto_ptr<_Up>& __p) _NOEXCEPT : __ptr_(__p.release()) {}
+  _LIBCPP_HIDE_FROM_ABI auto_ptr& operator=(auto_ptr& __p) _NOEXCEPT {
+    reset(__p.release());
+    return *this;
+  }
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI auto_ptr& operator=(auto_ptr<_Up>& __p) _NOEXCEPT {
+    reset(__p.release());
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI auto_ptr& operator=(auto_ptr_ref<_Tp> __p) _NOEXCEPT {
+    reset(__p.__ptr_);
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI ~auto_ptr() _NOEXCEPT { delete __ptr_; }
 
-    _LIBCPP_INLINE_VISIBILITY _Tp& operator*() const _NOEXCEPT
-        {return *__ptr_;}
-    _LIBCPP_INLINE_VISIBILITY _Tp* operator->() const _NOEXCEPT {return __ptr_;}
-    _LIBCPP_INLINE_VISIBILITY _Tp* get() const _NOEXCEPT {return __ptr_;}
-    _LIBCPP_INLINE_VISIBILITY _Tp* release() _NOEXCEPT
-    {
-        _Tp* __t = __ptr_;
-        __ptr_ = nullptr;
-        return __t;
-    }
-    _LIBCPP_INLINE_VISIBILITY void reset(_Tp* __p = 0) _NOEXCEPT
-    {
-        if (__ptr_ != __p)
-            delete __ptr_;
-        __ptr_ = __p;
-    }
+  _LIBCPP_HIDE_FROM_ABI _Tp& operator*() const _NOEXCEPT { return *__ptr_; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* operator->() const _NOEXCEPT { return __ptr_; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* get() const _NOEXCEPT { return __ptr_; }
+  _LIBCPP_HIDE_FROM_ABI _Tp* release() _NOEXCEPT {
+    _Tp* __t = __ptr_;
+    __ptr_   = nullptr;
+    return __t;
+  }
+  _LIBCPP_HIDE_FROM_ABI void reset(_Tp* __p = 0) _NOEXCEPT {
+    if (__ptr_ != __p)
+      delete __ptr_;
+    __ptr_ = __p;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}
-    template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() _NOEXCEPT
-        {auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;}
-    template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() _NOEXCEPT
-        {return auto_ptr<_Up>(release());}
+  _LIBCPP_HIDE_FROM_ABI auto_ptr(auto_ptr_ref<_Tp> __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI operator auto_ptr_ref<_Up>() _NOEXCEPT {
+    auto_ptr_ref<_Up> __t;
+    __t.__ptr_ = release();
+    return __t;
+  }
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI operator auto_ptr<_Up>() _NOEXCEPT {
+    return auto_ptr<_Up>(release());
+  }
 };
 
 template <>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr<void>
-{
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr<void> {
 public:
-    typedef void element_type;
+  typedef void element_type;
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__memory/builtin_new_allocator.h b/third_party/libcxx/__memory/builtin_new_allocator.h
index ab449ad29..c6f7f3c5f 100644
--- a/third_party/libcxx/__memory/builtin_new_allocator.h
+++ b/third_party/libcxx/__memory/builtin_new_allocator.h
@@ -32,10 +32,10 @@ struct __builtin_new_allocator {
         : __size_(__size), __align_(__align) {}
 
     _LIBCPP_HIDE_FROM_ABI void operator()(void* __p) const _NOEXCEPT {
-        _VSTD::__libcpp_deallocate(__p, __size_, __align_);
+      std::__libcpp_deallocate(__p, __size_, __align_);
     }
 
-   private:
+  private:
     size_t __size_;
     size_t __align_;
   };
@@ -43,25 +43,22 @@ struct __builtin_new_allocator {
   typedef unique_ptr<void, __builtin_new_deleter> __holder_t;
 
   _LIBCPP_HIDE_FROM_ABI static __holder_t __allocate_bytes(size_t __s, size_t __align) {
-      return __holder_t(_VSTD::__libcpp_allocate(__s, __align),
-                     __builtin_new_deleter(__s, __align));
+    return __holder_t(std::__libcpp_allocate(__s, __align), __builtin_new_deleter(__s, __align));
   }
 
-  _LIBCPP_HIDE_FROM_ABI static void __deallocate_bytes(void* __p, size_t __s,
-                                 size_t __align) _NOEXCEPT {
-      _VSTD::__libcpp_deallocate(__p, __s, __align);
+  _LIBCPP_HIDE_FROM_ABI static void __deallocate_bytes(void* __p, size_t __s, size_t __align) _NOEXCEPT {
+    std::__libcpp_deallocate(__p, __s, __align);
   }
 
   template <class _Tp>
-  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
-  _LIBCPP_HIDE_FROM_ABI static __holder_t __allocate_type(size_t __n) {
-      return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI static __holder_t __allocate_type(size_t __n) {
+    return __allocate_bytes(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
   }
 
   template <class _Tp>
-  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE
-  _LIBCPP_HIDE_FROM_ABI static void __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
-      __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
+  _LIBCPP_NODEBUG _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI static void
+  __deallocate_type(void* __p, size_t __n) _NOEXCEPT {
+    __deallocate_bytes(__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
   }
 };
 
diff --git a/third_party/libcxx/__memory/compressed_pair.h b/third_party/libcxx/__memory/compressed_pair.h
index d5986dab7..40e5cfc35 100644
--- a/third_party/libcxx/__memory/compressed_pair.h
+++ b/third_party/libcxx/__memory/compressed_pair.h
@@ -11,13 +11,12 @@
 #define _LIBCPP___MEMORY_COMPRESSED_PAIR_H
 
 #include <__config>
-#include <__fwd/get.h>
 #include <__fwd/tuple.h>
 #include <__tuple/tuple_indices.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/dependent_type.h>
 #include <__type_traits/enable_if.h>
-#include <__type_traits/is_default_constructible.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/is_empty.h>
 #include <__type_traits/is_final.h>
 #include <__type_traits/is_same.h>
@@ -31,6 +30,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Tag used to default initialize one or both of the pair's elements.
@@ -39,21 +41,21 @@ struct __value_init_tag {};
 
 template <class _Tp, int _Idx, bool _CanBeEmptyBase = is_empty<_Tp>::value && !__libcpp_is_final<_Tp>::value>
 struct __compressed_pair_elem {
-  using _ParamT = _Tp;
-  using reference = _Tp&;
+  using _ParamT         = _Tp;
+  using reference       = _Tp&;
   using const_reference = const _Tp&;
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(__default_init_tag) {}
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(__value_init_tag) : __value_() {}
 
-  template <class _Up, class = __enable_if_t<!is_same<__compressed_pair_elem, __decay_t<_Up> >::value> >
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-  explicit __compressed_pair_elem(_Up&& __u) : __value_(std::forward<_Up>(__u)) {}
+  template <class _Up, __enable_if_t<!is_same<__compressed_pair_elem, __decay_t<_Up> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(_Up&& __u)
+      : __value_(std::forward<_Up>(__u)) {}
 
 #ifndef _LIBCPP_CXX03_LANG
   template <class... _Args, size_t... _Indices>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-  explicit __compressed_pair_elem(piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indices...>)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit __compressed_pair_elem(
+      piecewise_construct_t, tuple<_Args...> __args, __tuple_indices<_Indices...>)
       : __value_(std::forward<_Args>(std::get<_Indices>(__args))...) {}
 #endif
 
@@ -66,18 +68,18 @@ private:
 
 template <class _Tp, int _Idx>
 struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {
-  using _ParamT = _Tp;
-  using reference = _Tp&;
+  using _ParamT         = _Tp;
+  using reference       = _Tp&;
   using const_reference = const _Tp&;
-  using __value_type = _Tp;
+  using __value_type    = _Tp;
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem() = default;
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(__default_init_tag) {}
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(__value_init_tag) : __value_type() {}
 
-  template <class _Up, class = __enable_if_t<!is_same<__compressed_pair_elem, __decay_t<_Up> >::value> >
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-  explicit __compressed_pair_elem(_Up&& __u) : __value_type(std::forward<_Up>(__u)) {}
+  template <class _Up, __enable_if_t<!is_same<__compressed_pair_elem, __decay_t<_Up> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair_elem(_Up&& __u)
+      : __value_type(std::forward<_Up>(__u)) {}
 
 #ifndef _LIBCPP_CXX03_LANG
   template <class... _Args, size_t... _Indices>
@@ -91,74 +93,64 @@ struct __compressed_pair_elem<_Tp, _Idx, true> : private _Tp {
 };
 
 template <class _T1, class _T2>
-class __compressed_pair : private __compressed_pair_elem<_T1, 0>,
-                          private __compressed_pair_elem<_T2, 1> {
+class __compressed_pair : private __compressed_pair_elem<_T1, 0>, private __compressed_pair_elem<_T2, 1> {
 public:
   // NOTE: This static assert should never fire because __compressed_pair
   // is *almost never* used in a scenario where it's possible for T1 == T2.
   // (The exception is std::function where it is possible that the function
   //  object and the allocator have the same type).
-  static_assert((!is_same<_T1, _T2>::value),
-    "__compressed_pair cannot be instantiated when T1 and T2 are the same type; "
-    "The current implementation is NOT ABI-compatible with the previous implementation for this configuration");
+  static_assert(
+      (!is_same<_T1, _T2>::value),
+      "__compressed_pair cannot be instantiated when T1 and T2 are the same type; "
+      "The current implementation is NOT ABI-compatible with the previous implementation for this configuration");
 
   using _Base1 _LIBCPP_NODEBUG = __compressed_pair_elem<_T1, 0>;
   using _Base2 _LIBCPP_NODEBUG = __compressed_pair_elem<_T2, 1>;
 
-  template <bool _Dummy = true,
-    class = __enable_if_t<
-        __dependent_type<is_default_constructible<_T1>, _Dummy>::value &&
-        __dependent_type<is_default_constructible<_T2>, _Dummy>::value
-    >
-  >
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-  explicit __compressed_pair() : _Base1(__value_init_tag()), _Base2(__value_init_tag()) {}
+  template <bool _Dummy         = true,
+            __enable_if_t< __dependent_type<is_default_constructible<_T1>, _Dummy>::value &&
+                               __dependent_type<is_default_constructible<_T2>, _Dummy>::value,
+                           int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair()
+      : _Base1(__value_init_tag()), _Base2(__value_init_tag()) {}
 
   template <class _U1, class _U2>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-  explicit __compressed_pair(_U1&& __t1, _U2&& __t2) : _Base1(std::forward<_U1>(__t1)), _Base2(std::forward<_U2>(__t2)) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __compressed_pair(_U1&& __t1, _U2&& __t2)
+      : _Base1(std::forward<_U1>(__t1)), _Base2(std::forward<_U2>(__t2)) {}
 
 #ifndef _LIBCPP_CXX03_LANG
   template <class... _Args1, class... _Args2>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-  explicit __compressed_pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
-                             tuple<_Args2...> __second_args)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit __compressed_pair(
+      piecewise_construct_t __pc, tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
       : _Base1(__pc, std::move(__first_args), typename __make_tuple_indices<sizeof...(_Args1)>::type()),
         _Base2(__pc, std::move(__second_args), typename __make_tuple_indices<sizeof...(_Args2)>::type()) {}
 #endif
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-  typename _Base1::reference first() _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename _Base1::reference first() _NOEXCEPT {
     return static_cast<_Base1&>(*this).__get();
   }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-  typename _Base1::const_reference first() const _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename _Base1::const_reference first() const _NOEXCEPT {
     return static_cast<_Base1 const&>(*this).__get();
   }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-  typename _Base2::reference second() _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename _Base2::reference second() _NOEXCEPT {
     return static_cast<_Base2&>(*this).__get();
   }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-  typename _Base2::const_reference second() const _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename _Base2::const_reference second() const _NOEXCEPT {
     return static_cast<_Base2 const&>(*this).__get();
   }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static
-  _Base1* __get_first_base(__compressed_pair* __pair) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static _Base1* __get_first_base(__compressed_pair* __pair) _NOEXCEPT {
     return static_cast<_Base1*>(__pair);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static
-  _Base2* __get_second_base(__compressed_pair* __pair) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR static _Base2* __get_second_base(__compressed_pair* __pair) _NOEXCEPT {
     return static_cast<_Base2*>(__pair);
   }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-  void swap(__compressed_pair& __x)
-      _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void swap(__compressed_pair& __x)
+      _NOEXCEPT_(__is_nothrow_swappable_v<_T1>&& __is_nothrow_swappable_v<_T2>) {
     using std::swap;
     swap(first(), __x.first());
     swap(second(), __x.second());
@@ -166,12 +158,14 @@ public:
 };
 
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-void swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y)
-    _NOEXCEPT_(__is_nothrow_swappable<_T1>::value && __is_nothrow_swappable<_T2>::value) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+swap(__compressed_pair<_T1, _T2>& __x, __compressed_pair<_T1, _T2>& __y)
+    _NOEXCEPT_(__is_nothrow_swappable_v<_T1>&& __is_nothrow_swappable_v<_T2>) {
   __x.swap(__y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_COMPRESSED_PAIR_H
diff --git a/third_party/libcxx/__memory/concepts.h b/third_party/libcxx/__memory/concepts.h
index 9517a8fd5..216144aad 100644
--- a/third_party/libcxx/__memory/concepts.h
+++ b/third_party/libcxx/__memory/concepts.h
@@ -19,6 +19,7 @@
 #include <__ranges/concepts.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/remove_cvref.h>
+#include <__type_traits/remove_reference.h> // TODO(modules): This should not be required
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -36,8 +37,7 @@ namespace ranges {
 // at the address pointed-to by the iterator, which requires an lvalue.
 template <class _Ip>
 concept __nothrow_input_iterator =
-    input_iterator<_Ip> &&
-    is_lvalue_reference_v<iter_reference_t<_Ip>> &&
+    input_iterator<_Ip> && is_lvalue_reference_v<iter_reference_t<_Ip>> &&
     same_as<remove_cvref_t<iter_reference_t<_Ip>>, iter_value_t<_Ip>>;
 
 template <class _Sp, class _Ip>
@@ -45,20 +45,14 @@ concept __nothrow_sentinel_for = sentinel_for<_Sp, _Ip>;
 
 template <class _Rp>
 concept __nothrow_input_range =
-    range<_Rp> &&
-    __nothrow_input_iterator<iterator_t<_Rp>> &&
-    __nothrow_sentinel_for<sentinel_t<_Rp>, iterator_t<_Rp>>;
+    range<_Rp> && __nothrow_input_iterator<iterator_t<_Rp>> && __nothrow_sentinel_for<sentinel_t<_Rp>, iterator_t<_Rp>>;
 
 template <class _Ip>
 concept __nothrow_forward_iterator =
-    __nothrow_input_iterator<_Ip> &&
-    forward_iterator<_Ip> &&
-    __nothrow_sentinel_for<_Ip, _Ip>;
+    __nothrow_input_iterator<_Ip> && forward_iterator<_Ip> && __nothrow_sentinel_for<_Ip, _Ip>;
 
 template <class _Rp>
-concept __nothrow_forward_range =
-    __nothrow_input_range<_Rp> &&
-    __nothrow_forward_iterator<iterator_t<_Rp>>;
+concept __nothrow_forward_range = __nothrow_input_range<_Rp> && __nothrow_forward_iterator<iterator_t<_Rp>>;
 
 } // namespace ranges
 
diff --git a/third_party/libcxx/__memory/construct_at.h b/third_party/libcxx/__memory/construct_at.h
index fb146b7c7..eb0213248 100644
--- a/third_party/libcxx/__memory/construct_at.h
+++ b/third_party/libcxx/__memory/construct_at.h
@@ -26,6 +26,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // construct_at
@@ -34,18 +37,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))>
 _LIBCPP_HIDE_FROM_ABI constexpr _Tp* construct_at(_Tp* __location, _Args&&... __args) {
-  _LIBCPP_ASSERT(__location != nullptr, "null pointer given to construct_at");
+  _LIBCPP_ASSERT_NON_NULL(__location != nullptr, "null pointer given to construct_at");
   return ::new (std::__voidify(*__location)) _Tp(std::forward<_Args>(__args)...);
 }
 
 #endif
 
 template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* __construct_at(_Tp* __location, _Args&&... __args) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp* __construct_at(_Tp* __location, _Args&&... __args) {
 #if _LIBCPP_STD_VER >= 20
   return std::construct_at(__location, std::forward<_Args>(__args)...);
 #else
-  return _LIBCPP_ASSERT(__location != nullptr, "null pointer given to construct_at"),
+  return _LIBCPP_ASSERT_NON_NULL(__location != nullptr, "null pointer given to construct_at"),
          ::new (std::__voidify(*__location)) _Tp(std::forward<_Args>(__args)...);
 #endif
 }
@@ -56,75 +59,70 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* __construct_at(_Tp* __location, _Ar
 // taking an array).
 
 template <class _ForwardIterator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator __destroy(_ForwardIterator, _ForwardIterator);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator __destroy(_ForwardIterator, _ForwardIterator);
 
-template <class _Tp, typename enable_if<!is_array<_Tp>::value, int>::type = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void __destroy_at(_Tp* __loc) {
-    _LIBCPP_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
-    __loc->~_Tp();
+template <class _Tp, __enable_if_t<!is_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy_at(_Tp* __loc) {
+  _LIBCPP_ASSERT_NON_NULL(__loc != nullptr, "null pointer given to destroy_at");
+  __loc->~_Tp();
 }
 
 #if _LIBCPP_STD_VER >= 20
-template <class _Tp, typename enable_if<is_array<_Tp>::value, int>::type = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void __destroy_at(_Tp* __loc) {
-    _LIBCPP_ASSERT(__loc != nullptr, "null pointer given to destroy_at");
-    std::__destroy(std::begin(*__loc), std::end(*__loc));
+template <class _Tp, __enable_if_t<is_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy_at(_Tp* __loc) {
+  _LIBCPP_ASSERT_NON_NULL(__loc != nullptr, "null pointer given to destroy_at");
+  std::__destroy(std::begin(*__loc), std::end(*__loc));
 }
 #endif
 
 template <class _ForwardIterator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator __destroy(_ForwardIterator __first, _ForwardIterator __last) {
-    for (; __first != __last; ++__first)
-        std::__destroy_at(std::addressof(*__first));
-    return __first;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
+__destroy(_ForwardIterator __first, _ForwardIterator __last) {
+  for (; __first != __last; ++__first)
+    std::__destroy_at(std::addressof(*__first));
+  return __first;
 }
 
 template <class _BidirectionalIterator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_BidirectionalIterator __reverse_destroy(_BidirectionalIterator __first, _BidirectionalIterator __last) {
-    while (__last != __first) {
-        --__last;
-        std::__destroy_at(std::addressof(*__last));
-    }
-    return __last;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _BidirectionalIterator
+__reverse_destroy(_BidirectionalIterator __first, _BidirectionalIterator __last) {
+  while (__last != __first) {
+    --__last;
+    std::__destroy_at(std::addressof(*__last));
+  }
+  return __last;
 }
 
 #if _LIBCPP_STD_VER >= 17
 
 template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void destroy_at(_Tp* __loc) {
-    std::__destroy_at(__loc);
-}
-
-#if _LIBCPP_STD_VER >= 20
-template <class _Tp, enable_if_t<is_array_v<_Tp>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void destroy_at(_Tp* __loc) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void destroy_at(_Tp* __loc) {
   std::__destroy_at(__loc);
 }
-#endif
+
+#  if _LIBCPP_STD_VER >= 20
+template <class _Tp, enable_if_t<is_array_v<_Tp>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void destroy_at(_Tp* __loc) {
+  std::__destroy_at(__loc);
+}
+#  endif
 
 template <class _ForwardIterator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void destroy(_ForwardIterator __first, _ForwardIterator __last) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void destroy(_ForwardIterator __first, _ForwardIterator __last) {
   (void)std::__destroy(std::move(__first), std::move(__last));
 }
 
 template <class _ForwardIterator, class _Size>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-_ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) {
-    for (; __n > 0; (void)++__first, --__n)
-        std::__destroy_at(std::addressof(*__first));
-    return __first;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator destroy_n(_ForwardIterator __first, _Size __n) {
+  for (; __n > 0; (void)++__first, --__n)
+    std::__destroy_at(std::addressof(*__first));
+  return __first;
 }
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_CONSTRUCT_AT_H
diff --git a/third_party/libcxx/__memory/destruct_n.h b/third_party/libcxx/__memory/destruct_n.h
index 2cfb2e4c8..78635ad0a 100644
--- a/third_party/libcxx/__memory/destruct_n.h
+++ b/third_party/libcxx/__memory/destruct_n.h
@@ -20,43 +20,42 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct __destruct_n
-{
+struct __destruct_n {
 private:
-    size_t __size_;
+  size_t __size_;
 
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __process(_Tp* __p, false_type) _NOEXCEPT
-        {for (size_t __i = 0; __i < __size_; ++__i, ++__p) __p->~_Tp();}
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI void __process(_Tp* __p, false_type) _NOEXCEPT {
+    for (size_t __i = 0; __i < __size_; ++__i, ++__p)
+      __p->~_Tp();
+  }
 
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __process(_Tp*, true_type) _NOEXCEPT
-        {}
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI void __process(_Tp*, true_type) _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY void __incr(false_type) _NOEXCEPT
-        {++__size_;}
-    _LIBCPP_INLINE_VISIBILITY void __incr(true_type) _NOEXCEPT
-        {}
+  _LIBCPP_HIDE_FROM_ABI void __incr(false_type) _NOEXCEPT { ++__size_; }
+  _LIBCPP_HIDE_FROM_ABI void __incr(true_type) _NOEXCEPT {}
+
+  _LIBCPP_HIDE_FROM_ABI void __set(size_t __s, false_type) _NOEXCEPT { __size_ = __s; }
+  _LIBCPP_HIDE_FROM_ABI void __set(size_t, true_type) _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, false_type) _NOEXCEPT
-        {__size_ = __s;}
-    _LIBCPP_INLINE_VISIBILITY void __set(size_t, true_type) _NOEXCEPT
-        {}
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit __destruct_n(size_t __s) _NOEXCEPT
-        : __size_(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __destruct_n(size_t __s) _NOEXCEPT : __size_(__s) {}
 
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __incr() _NOEXCEPT
-        {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI void __incr() _NOEXCEPT {
+    __incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());
+  }
 
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) _NOEXCEPT
-        {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI void __set(size_t __s, _Tp*) _NOEXCEPT {
+    __set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());
+  }
 
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) _NOEXCEPT
-        {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI void operator()(_Tp* __p) _NOEXCEPT {
+    __process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__memory/inout_ptr.h b/third_party/libcxx/__memory/inout_ptr.h
new file mode 100644
index 000000000..72e1a21ad
--- /dev/null
+++ b/third_party/libcxx/__memory/inout_ptr.h
@@ -0,0 +1,109 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___INOUT_PTR_H
+#define _LIBCPP___INOUT_PTR_H
+
+#include <__config>
+#include <__memory/addressof.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_specialization.h>
+#include <__type_traits/is_void.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <tuple>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Smart, class _Pointer, class... _Args>
+class _LIBCPP_TEMPLATE_VIS inout_ptr_t {
+  static_assert(!__is_specialization_v<_Smart, shared_ptr>, "std::shared_ptr<> is not supported with std::inout_ptr.");
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit inout_ptr_t(_Smart& __smart, _Args... __args)
+      : __s_(__smart), __a_(std::forward<_Args>(__args)...), __p_([&__smart] {
+          if constexpr (is_pointer_v<_Smart>) {
+            return __smart;
+          } else {
+            return __smart.get();
+          }
+        }()) {
+    if constexpr (requires { __s_.release(); }) {
+      __s_.release();
+    } else {
+      __s_ = _Smart();
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI inout_ptr_t(const inout_ptr_t&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI ~inout_ptr_t() {
+    // LWG-3897 inout_ptr will not update raw pointer to null
+    if constexpr (!is_pointer_v<_Smart>) {
+      if (!__p_) {
+        return;
+      }
+    }
+
+    using _SP = __pointer_of_or_t<_Smart, _Pointer>;
+    if constexpr (is_pointer_v<_Smart>) {
+      std::apply([&](auto&&... __args) { __s_ = _Smart(static_cast<_SP>(__p_), std::forward<_Args>(__args)...); },
+                 std::move(__a_));
+    } else if constexpr (__resettable_smart_pointer_with_args<_Smart, _Pointer, _Args...>) {
+      std::apply([&](auto&&... __args) { __s_.reset(static_cast<_SP>(__p_), std::forward<_Args>(__args)...); },
+                 std::move(__a_));
+    } else {
+      static_assert(is_constructible_v<_Smart, _SP, _Args...>,
+                    "The smart pointer must be constructible from arguments of types _Smart, _Pointer, _Args...");
+      std::apply([&](auto&&... __args) { __s_ = _Smart(static_cast<_SP>(__p_), std::forward<_Args>(__args)...); },
+                 std::move(__a_));
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI operator _Pointer*() const noexcept { return std::addressof(const_cast<_Pointer&>(__p_)); }
+
+  _LIBCPP_HIDE_FROM_ABI operator void**() const noexcept
+    requires(!is_same_v<_Pointer, void*>)
+  {
+    static_assert(is_pointer_v<_Pointer>, "The conversion to void** requires _Pointer to be a raw pointer.");
+
+    return reinterpret_cast<void**>(static_cast<_Pointer*>(*this));
+  }
+
+private:
+  _Smart& __s_;
+  tuple<_Args...> __a_;
+  _Pointer __p_;
+};
+
+template <class _Pointer = void, class _Smart, class... _Args>
+_LIBCPP_HIDE_FROM_ABI auto inout_ptr(_Smart& __s, _Args&&... __args) {
+  using _Ptr = conditional_t<is_void_v<_Pointer>, __pointer_of_t<_Smart>, _Pointer>;
+  return std::inout_ptr_t<_Smart, _Ptr, _Args&&...>(__s, std::forward<_Args>(__args)...);
+}
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___INOUT_PTR_H
diff --git a/third_party/libcxx/__memory/out_ptr.h b/third_party/libcxx/__memory/out_ptr.h
new file mode 100644
index 000000000..95aa2029c
--- /dev/null
+++ b/third_party/libcxx/__memory/out_ptr.h
@@ -0,0 +1,101 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___OUT_PTR_H
+#define _LIBCPP___OUT_PTR_H
+
+#include <__config>
+#include <__memory/addressof.h>
+#include <__memory/pointer_traits.h>
+#include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
+#include <__type_traits/is_specialization.h>
+#include <__type_traits/is_void.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <tuple>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Smart, class _Pointer, class... _Args>
+class _LIBCPP_TEMPLATE_VIS out_ptr_t {
+  static_assert(!__is_specialization_v<_Smart, shared_ptr> || sizeof...(_Args) > 0,
+                "Using std::shared_ptr<> without a deleter in std::out_ptr is not supported.");
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit out_ptr_t(_Smart& __smart, _Args... __args)
+      : __s_(__smart), __a_(std::forward<_Args>(__args)...), __p_() {
+    using _Ptr = decltype(__smart);
+    if constexpr (__resettable_smart_pointer<_Ptr>) {
+      __s_.reset();
+    } else if constexpr (is_constructible_v<_Smart>) {
+      __s_ = _Smart();
+    } else {
+      static_assert(__resettable_smart_pointer<_Ptr> || is_constructible_v<_Smart>,
+                    "The adapted pointer type must have a reset() member function or be default constructible.");
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI out_ptr_t(const out_ptr_t&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI ~out_ptr_t() {
+    if (!__p_) {
+      return;
+    }
+
+    using _SP = __pointer_of_or_t<_Smart, _Pointer>;
+    if constexpr (__resettable_smart_pointer_with_args<_Smart, _Pointer, _Args...>) {
+      std::apply([&](auto&&... __args) { __s_.reset(static_cast<_SP>(__p_), std::forward<_Args>(__args)...); },
+                 std::move(__a_));
+    } else {
+      static_assert(is_constructible_v<_Smart, _SP, _Args...>,
+                    "The smart pointer must be constructible from arguments of types _Smart, _Pointer, _Args...");
+      std::apply([&](auto&&... __args) { __s_ = _Smart(static_cast<_SP>(__p_), std::forward<_Args>(__args)...); },
+                 std::move(__a_));
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI operator _Pointer*() const noexcept { return std::addressof(const_cast<_Pointer&>(__p_)); }
+
+  _LIBCPP_HIDE_FROM_ABI operator void**() const noexcept
+    requires(!is_same_v<_Pointer, void*>)
+  {
+    static_assert(is_pointer_v<_Pointer>, "The conversion to void** requires _Pointer to be a raw pointer.");
+
+    return reinterpret_cast<void**>(static_cast<_Pointer*>(*this));
+  }
+
+private:
+  _Smart& __s_;
+  tuple<_Args...> __a_;
+  _Pointer __p_ = _Pointer();
+};
+
+template <class _Pointer = void, class _Smart, class... _Args>
+_LIBCPP_HIDE_FROM_ABI auto out_ptr(_Smart& __s, _Args&&... __args) {
+  using _Ptr = conditional_t<is_void_v<_Pointer>, __pointer_of_t<_Smart>, _Pointer>;
+  return std::out_ptr_t<_Smart, _Ptr, _Args&&...>(__s, std::forward<_Args>(__args)...);
+}
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___OUT_PTR_H
diff --git a/third_party/libcxx/__memory/pointer_traits.h b/third_party/libcxx/__memory/pointer_traits.h
index c33e7bd43..0914aceb3 100644
--- a/third_party/libcxx/__memory/pointer_traits.h
+++ b/third_party/libcxx/__memory/pointer_traits.h
@@ -20,39 +20,45 @@
 #include <__type_traits/is_void.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
+#include <__utility/forward.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class = void>
-struct __has_element_type : false_type {};
+// clang-format off
+#define _LIBCPP_CLASS_TRAITS_HAS_XXX(NAME, PROPERTY)                                                                   \
+  template <class _Tp, class = void>                                                                                   \
+  struct NAME : false_type {};                                                                                         \
+  template <class _Tp>                                                                                                 \
+  struct NAME<_Tp, __void_t<typename _Tp::PROPERTY> > : true_type {}
+// clang-format on
 
-template <class _Tp>
-struct __has_element_type<_Tp, __void_t<typename _Tp::element_type> > : true_type {};
+_LIBCPP_CLASS_TRAITS_HAS_XXX(__has_pointer, pointer);
+_LIBCPP_CLASS_TRAITS_HAS_XXX(__has_element_type, element_type);
 
 template <class _Ptr, bool = __has_element_type<_Ptr>::value>
-struct __pointer_traits_element_type;
+struct __pointer_traits_element_type {};
 
 template <class _Ptr>
-struct __pointer_traits_element_type<_Ptr, true>
-{
-    typedef _LIBCPP_NODEBUG typename _Ptr::element_type type;
+struct __pointer_traits_element_type<_Ptr, true> {
+  typedef _LIBCPP_NODEBUG typename _Ptr::element_type type;
 };
 
-template <template <class, class...> class _Sp, class _Tp, class ..._Args>
-struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true>
-{
-    typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::element_type type;
+template <template <class, class...> class _Sp, class _Tp, class... _Args>
+struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true> {
+  typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::element_type type;
 };
 
-template <template <class, class...> class _Sp, class _Tp, class ..._Args>
-struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false>
-{
-    typedef _LIBCPP_NODEBUG _Tp type;
+template <template <class, class...> class _Sp, class _Tp, class... _Args>
+struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, false> {
+  typedef _LIBCPP_NODEBUG _Tp type;
 };
 
 template <class _Tp, class = void>
@@ -62,96 +68,108 @@ template <class _Tp>
 struct __has_difference_type<_Tp, __void_t<typename _Tp::difference_type> > : true_type {};
 
 template <class _Ptr, bool = __has_difference_type<_Ptr>::value>
-struct __pointer_traits_difference_type
-{
-    typedef _LIBCPP_NODEBUG ptrdiff_t type;
+struct __pointer_traits_difference_type {
+  typedef _LIBCPP_NODEBUG ptrdiff_t type;
 };
 
 template <class _Ptr>
-struct __pointer_traits_difference_type<_Ptr, true>
-{
-    typedef _LIBCPP_NODEBUG typename _Ptr::difference_type type;
+struct __pointer_traits_difference_type<_Ptr, true> {
+  typedef _LIBCPP_NODEBUG typename _Ptr::difference_type type;
 };
 
 template <class _Tp, class _Up>
-struct __has_rebind
-{
+struct __has_rebind {
 private:
-    template <class _Xp> static false_type __test(...);
-    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    template <class _Xp> static true_type __test(typename _Xp::template rebind<_Up>* = 0);
-    _LIBCPP_SUPPRESS_DEPRECATED_POP
+  template <class _Xp>
+  static false_type __test(...);
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  template <class _Xp>
+  static true_type __test(typename _Xp::template rebind<_Up>* = 0);
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
 public:
-    static const bool value = decltype(__test<_Tp>(0))::value;
+  static const bool value = decltype(__test<_Tp>(0))::value;
 };
 
 template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
-struct __pointer_traits_rebind
-{
+struct __pointer_traits_rebind {
 #ifndef _LIBCPP_CXX03_LANG
-    typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up> type;
+  typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up> type;
 #else
-    typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up>::other type;
+  typedef _LIBCPP_NODEBUG typename _Tp::template rebind<_Up>::other type;
 #endif
 };
 
-template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true>
-{
+template <template <class, class...> class _Sp, class _Tp, class... _Args, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, true> {
 #ifndef _LIBCPP_CXX03_LANG
-    typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
+  typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::template rebind<_Up> type;
 #else
-    typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type;
+  typedef _LIBCPP_NODEBUG typename _Sp<_Tp, _Args...>::template rebind<_Up>::other type;
 #endif
 };
 
-template <template <class, class...> class _Sp, class _Tp, class ..._Args, class _Up>
-struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false>
-{
-    typedef _Sp<_Up, _Args...> type;
+template <template <class, class...> class _Sp, class _Tp, class... _Args, class _Up>
+struct __pointer_traits_rebind<_Sp<_Tp, _Args...>, _Up, false> {
+  typedef _Sp<_Up, _Args...> type;
 };
 
+template <class _Ptr, class = void>
+struct __pointer_traits_impl {};
+
 template <class _Ptr>
-struct _LIBCPP_TEMPLATE_VIS pointer_traits
-{
-    typedef _Ptr                                                     pointer;
-    typedef typename __pointer_traits_element_type<pointer>::type    element_type;
-    typedef typename __pointer_traits_difference_type<pointer>::type difference_type;
+struct __pointer_traits_impl<_Ptr, __void_t<typename __pointer_traits_element_type<_Ptr>::type> > {
+  typedef _Ptr pointer;
+  typedef typename __pointer_traits_element_type<pointer>::type element_type;
+  typedef typename __pointer_traits_difference_type<pointer>::type difference_type;
 
 #ifndef _LIBCPP_CXX03_LANG
-    template <class _Up> using rebind = typename __pointer_traits_rebind<pointer, _Up>::type;
+  template <class _Up>
+  using rebind = typename __pointer_traits_rebind<pointer, _Up>::type;
 #else
-    template <class _Up> struct rebind
-        {typedef typename __pointer_traits_rebind<pointer, _Up>::type other;};
+  template <class _Up>
+  struct rebind {
+    typedef typename __pointer_traits_rebind<pointer, _Up>::type other;
+  };
 #endif // _LIBCPP_CXX03_LANG
 
 private:
-    struct __nat {};
+  struct __nat {};
+
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static pointer pointer_to(__conditional_t<is_void<element_type>::value, __nat, element_type>& __r)
-        {return pointer::pointer_to(__r);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static pointer
+  pointer_to(__conditional_t<is_void<element_type>::value, __nat, element_type>& __r) {
+    return pointer::pointer_to(__r);
+  }
 };
 
+template <class _Ptr>
+struct _LIBCPP_TEMPLATE_VIS pointer_traits : __pointer_traits_impl<_Ptr> {};
+
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*>
-{
-    typedef _Tp*      pointer;
-    typedef _Tp       element_type;
-    typedef ptrdiff_t difference_type;
+struct _LIBCPP_TEMPLATE_VIS pointer_traits<_Tp*> {
+  typedef _Tp* pointer;
+  typedef _Tp element_type;
+  typedef ptrdiff_t difference_type;
 
 #ifndef _LIBCPP_CXX03_LANG
-    template <class _Up> using rebind = _Up*;
+  template <class _Up>
+  using rebind = _Up*;
 #else
-    template <class _Up> struct rebind {typedef _Up* other;};
+  template <class _Up>
+  struct rebind {
+    typedef _Up* other;
+  };
 #endif
 
 private:
-    struct __nat {};
+  struct __nat {};
+
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static pointer pointer_to(__conditional_t<is_void<element_type>::value, __nat, element_type>& __r) _NOEXCEPT
-        {return _VSTD::addressof(__r);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static pointer
+  pointer_to(__conditional_t<is_void<element_type>::value, __nat, element_type>& __r) _NOEXCEPT {
+    return std::addressof(__r);
+  }
 };
 
 #ifndef _LIBCPP_CXX03_LANG
@@ -168,27 +186,23 @@ template <class _Pointer, class = void>
 struct __to_address_helper;
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-_Tp* __to_address(_Tp* __p) _NOEXCEPT {
-    static_assert(!is_function<_Tp>::value, "_Tp is a function type");
-    return __p;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* __to_address(_Tp* __p) _NOEXCEPT {
+  static_assert(!is_function<_Tp>::value, "_Tp is a function type");
+  return __p;
 }
 
 template <class _Pointer, class = void>
 struct _HasToAddress : false_type {};
 
 template <class _Pointer>
-struct _HasToAddress<_Pointer,
-    decltype((void)pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()))
-> : true_type {};
+struct _HasToAddress<_Pointer, decltype((void)pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>())) >
+    : true_type {};
 
 template <class _Pointer, class = void>
 struct _HasArrow : false_type {};
 
 template <class _Pointer>
-struct _HasArrow<_Pointer,
-    decltype((void)std::declval<const _Pointer&>().operator->())
-> : true_type {};
+struct _HasArrow<_Pointer, decltype((void)std::declval<const _Pointer&>().operator->()) > : true_type {};
 
 template <class _Pointer>
 struct _IsFancyPointer {
@@ -196,47 +210,98 @@ struct _IsFancyPointer {
 };
 
 // enable_if is needed here to avoid instantiating checks for fancy pointers on raw pointers
-template <class _Pointer, class = __enable_if_t<
-    _And<is_class<_Pointer>, _IsFancyPointer<_Pointer> >::value
-> >
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-__decay_t<decltype(__to_address_helper<_Pointer>::__call(std::declval<const _Pointer&>()))>
+template <class _Pointer, __enable_if_t< _And<is_class<_Pointer>, _IsFancyPointer<_Pointer> >::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR __decay_t<decltype(__to_address_helper<_Pointer>::__call(std::declval<const _Pointer&>()))>
 __to_address(const _Pointer& __p) _NOEXCEPT {
-    return __to_address_helper<_Pointer>::__call(__p);
+  return __to_address_helper<_Pointer>::__call(__p);
 }
 
 template <class _Pointer, class>
 struct __to_address_helper {
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    static decltype(_VSTD::__to_address(std::declval<const _Pointer&>().operator->()))
-    __call(const _Pointer& __p) _NOEXCEPT {
-        return _VSTD::__to_address(__p.operator->());
-    }
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR static decltype(std::__to_address(std::declval<const _Pointer&>().operator->()))
+  __call(const _Pointer& __p) _NOEXCEPT {
+    return std::__to_address(__p.operator->());
+  }
 };
 
 template <class _Pointer>
-struct __to_address_helper<_Pointer, decltype((void)pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()))> {
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    static decltype(pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()))
-    __call(const _Pointer& __p) _NOEXCEPT {
-        return pointer_traits<_Pointer>::to_address(__p);
-    }
+struct __to_address_helper<_Pointer,
+                           decltype((void)pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()))> {
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR static decltype(pointer_traits<_Pointer>::to_address(std::declval<const _Pointer&>()))
+  __call(const _Pointer& __p) _NOEXCEPT {
+    return pointer_traits<_Pointer>::to_address(__p);
+  }
 };
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY constexpr
-auto to_address(_Tp *__p) noexcept {
-    return _VSTD::__to_address(__p);
+inline _LIBCPP_HIDE_FROM_ABI constexpr auto to_address(_Tp* __p) noexcept {
+  return std::__to_address(__p);
 }
 
 template <class _Pointer>
-inline _LIBCPP_INLINE_VISIBILITY constexpr
-auto to_address(const _Pointer& __p) noexcept -> decltype(std::__to_address(__p)) {
-    return _VSTD::__to_address(__p);
+inline _LIBCPP_HIDE_FROM_ABI constexpr auto
+to_address(const _Pointer& __p) noexcept -> decltype(std::__to_address(__p)) {
+  return std::__to_address(__p);
 }
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Tp>
+struct __pointer_of {};
+
+template <class _Tp>
+  requires(__has_pointer<_Tp>::value)
+struct __pointer_of<_Tp> {
+  using type = typename _Tp::pointer;
+};
+
+template <class _Tp>
+  requires(!__has_pointer<_Tp>::value && __has_element_type<_Tp>::value)
+struct __pointer_of<_Tp> {
+  using type = typename _Tp::element_type*;
+};
+
+template <class _Tp>
+  requires(!__has_pointer<_Tp>::value && !__has_element_type<_Tp>::value &&
+           __has_element_type<pointer_traits<_Tp>>::value)
+struct __pointer_of<_Tp> {
+  using type = typename pointer_traits<_Tp>::element_type*;
+};
+
+template <typename _Tp>
+using __pointer_of_t = typename __pointer_of<_Tp>::type;
+
+template <class _Tp, class _Up>
+struct __pointer_of_or {
+  using type _LIBCPP_NODEBUG = _Up;
+};
+
+template <class _Tp, class _Up>
+  requires requires { typename __pointer_of_t<_Tp>; }
+struct __pointer_of_or<_Tp, _Up> {
+  using type _LIBCPP_NODEBUG = __pointer_of_t<_Tp>;
+};
+
+template <typename _Tp, typename _Up>
+using __pointer_of_or_t = typename __pointer_of_or<_Tp, _Up>::type;
+
+template <class _Smart>
+concept __resettable_smart_pointer = requires(_Smart __s) { __s.reset(); };
+
+template <class _Smart, class _Pointer, class... _Args>
+concept __resettable_smart_pointer_with_args = requires(_Smart __s, _Pointer __p, _Args... __args) {
+  __s.reset(static_cast<__pointer_of_or_t<_Smart, _Pointer>>(__p), std::forward<_Args>(__args)...);
+};
+
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_POINTER_TRAITS_H
diff --git a/third_party/libcxx/__memory/ranges_construct_at.h b/third_party/libcxx/__memory/ranges_construct_at.h
index 9ded2fc2e..f731e75e7 100644
--- a/third_party/libcxx/__memory/ranges_construct_at.h
+++ b/third_party/libcxx/__memory/ranges_construct_at.h
@@ -13,7 +13,7 @@
 #include <__concepts/destructible.h>
 #include <__config>
 #include <__iterator/incrementable_traits.h>
-#include <__iterator/readable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <__memory/concepts.h>
 #include <__memory/construct_at.h>
 #include <__ranges/access.h>
@@ -28,6 +28,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -38,19 +41,16 @@ namespace ranges {
 namespace __construct_at {
 
 struct __fn {
-  template<class _Tp, class... _Args, class = decltype(
-    ::new (std::declval<void*>()) _Tp(std::declval<_Args>()...)
-  )>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Tp* operator()(_Tp* __location, _Args&& ...__args) const {
-    return _VSTD::construct_at(__location, _VSTD::forward<_Args>(__args)...);
+  template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* operator()(_Tp* __location, _Args&&... __args) const {
+    return std::construct_at(__location, std::forward<_Args>(__args)...);
   }
 };
 
 } // namespace __construct_at
 
 inline namespace __cpo {
-  inline constexpr auto construct_at = __construct_at::__fn{};
+inline constexpr auto construct_at = __construct_at::__fn{};
 } // namespace __cpo
 
 // destroy_at
@@ -59,16 +59,15 @@ namespace __destroy_at {
 
 struct __fn {
   template <destructible _Tp>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr void operator()(_Tp* __location) const noexcept {
-    _VSTD::destroy_at(__location);
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator()(_Tp* __location) const noexcept {
+    std::destroy_at(__location);
   }
 };
 
 } // namespace __destroy_at
 
 inline namespace __cpo {
-  inline constexpr auto destroy_at = __destroy_at::__fn{};
+inline constexpr auto destroy_at = __destroy_at::__fn{};
 } // namespace __cpo
 
 // destroy
@@ -78,15 +77,13 @@ namespace __destroy {
 struct __fn {
   template <__nothrow_input_iterator _InputIterator, __nothrow_sentinel_for<_InputIterator> _Sentinel>
     requires destructible<iter_value_t<_InputIterator>>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _InputIterator operator()(_InputIterator __first, _Sentinel __last) const noexcept {
-    return _VSTD::__destroy(_VSTD::move(__first), _VSTD::move(__last));
+  _LIBCPP_HIDE_FROM_ABI constexpr _InputIterator operator()(_InputIterator __first, _Sentinel __last) const noexcept {
+    return std::__destroy(std::move(__first), std::move(__last));
   }
 
   template <__nothrow_input_range _InputRange>
     requires destructible<range_value_t<_InputRange>>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr borrowed_iterator_t<_InputRange> operator()(_InputRange&& __range) const noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr borrowed_iterator_t<_InputRange> operator()(_InputRange&& __range) const noexcept {
     return (*this)(ranges::begin(__range), ranges::end(__range));
   }
 };
@@ -94,7 +91,7 @@ struct __fn {
 } // namespace __destroy
 
 inline namespace __cpo {
-  inline constexpr auto destroy = __destroy::__fn{};
+inline constexpr auto destroy = __destroy::__fn{};
 } // namespace __cpo
 
 // destroy_n
@@ -104,16 +101,16 @@ namespace __destroy_n {
 struct __fn {
   template <__nothrow_input_iterator _InputIterator>
     requires destructible<iter_value_t<_InputIterator>>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _InputIterator operator()(_InputIterator __first, iter_difference_t<_InputIterator> __n) const noexcept {
-    return _VSTD::destroy_n(_VSTD::move(__first), __n);
+  _LIBCPP_HIDE_FROM_ABI constexpr _InputIterator
+  operator()(_InputIterator __first, iter_difference_t<_InputIterator> __n) const noexcept {
+    return std::destroy_n(std::move(__first), __n);
   }
 };
 
 } // namespace __destroy_n
 
 inline namespace __cpo {
-  inline constexpr auto destroy_n = __destroy_n::__fn{};
+inline constexpr auto destroy_n = __destroy_n::__fn{};
 } // namespace __cpo
 
 } // namespace ranges
@@ -122,4 +119,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_RANGES_CONSTRUCT_AT_H
diff --git a/third_party/libcxx/__memory/ranges_uninitialized_algorithms.h b/third_party/libcxx/__memory/ranges_uninitialized_algorithms.h
index 01c3e0100..90090055b 100644
--- a/third_party/libcxx/__memory/ranges_uninitialized_algorithms.h
+++ b/third_party/libcxx/__memory/ranges_uninitialized_algorithms.h
@@ -31,6 +31,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -42,13 +45,11 @@ namespace ranges {
 namespace __uninitialized_default_construct {
 
 struct __fn {
-  template <__nothrow_forward_iterator _ForwardIterator,
-            __nothrow_sentinel_for<_ForwardIterator> _Sentinel>
+  template <__nothrow_forward_iterator _ForwardIterator, __nothrow_sentinel_for<_ForwardIterator> _Sentinel>
     requires default_initializable<iter_value_t<_ForwardIterator>>
   _LIBCPP_HIDE_FROM_ABI _ForwardIterator operator()(_ForwardIterator __first, _Sentinel __last) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
-    return _VSTD::__uninitialized_default_construct<_ValueType>(
-        _VSTD::move(__first), _VSTD::move(__last));
+    return std::__uninitialized_default_construct<_ValueType>(std::move(__first), std::move(__last));
   }
 
   template <__nothrow_forward_range _ForwardRange>
@@ -61,7 +62,7 @@ struct __fn {
 } // namespace __uninitialized_default_construct
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_default_construct = __uninitialized_default_construct::__fn{};
+inline constexpr auto uninitialized_default_construct = __uninitialized_default_construct::__fn{};
 } // namespace __cpo
 
 // uninitialized_default_construct_n
@@ -71,17 +72,17 @@ namespace __uninitialized_default_construct_n {
 struct __fn {
   template <__nothrow_forward_iterator _ForwardIterator>
     requires default_initializable<iter_value_t<_ForwardIterator>>
-  _LIBCPP_HIDE_FROM_ABI _ForwardIterator operator()(_ForwardIterator __first,
-                              iter_difference_t<_ForwardIterator> __n) const {
+  _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+  operator()(_ForwardIterator __first, iter_difference_t<_ForwardIterator> __n) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
-    return _VSTD::__uninitialized_default_construct_n<_ValueType>(_VSTD::move(__first), __n);
+    return std::__uninitialized_default_construct_n<_ValueType>(std::move(__first), __n);
   }
 };
 
 } // namespace __uninitialized_default_construct_n
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_default_construct_n = __uninitialized_default_construct_n::__fn{};
+inline constexpr auto uninitialized_default_construct_n = __uninitialized_default_construct_n::__fn{};
 } // namespace __cpo
 
 // uninitialized_value_construct
@@ -89,13 +90,11 @@ inline namespace __cpo {
 namespace __uninitialized_value_construct {
 
 struct __fn {
-  template <__nothrow_forward_iterator _ForwardIterator,
-            __nothrow_sentinel_for<_ForwardIterator> _Sentinel>
+  template <__nothrow_forward_iterator _ForwardIterator, __nothrow_sentinel_for<_ForwardIterator> _Sentinel>
     requires default_initializable<iter_value_t<_ForwardIterator>>
   _LIBCPP_HIDE_FROM_ABI _ForwardIterator operator()(_ForwardIterator __first, _Sentinel __last) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
-    return _VSTD::__uninitialized_value_construct<_ValueType>(
-        _VSTD::move(__first), _VSTD::move(__last));
+    return std::__uninitialized_value_construct<_ValueType>(std::move(__first), std::move(__last));
   }
 
   template <__nothrow_forward_range _ForwardRange>
@@ -108,7 +107,7 @@ struct __fn {
 } // namespace __uninitialized_value_construct
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_value_construct = __uninitialized_value_construct::__fn{};
+inline constexpr auto uninitialized_value_construct = __uninitialized_value_construct::__fn{};
 } // namespace __cpo
 
 // uninitialized_value_construct_n
@@ -118,17 +117,17 @@ namespace __uninitialized_value_construct_n {
 struct __fn {
   template <__nothrow_forward_iterator _ForwardIterator>
     requires default_initializable<iter_value_t<_ForwardIterator>>
-  _LIBCPP_HIDE_FROM_ABI _ForwardIterator operator()(_ForwardIterator __first,
-                              iter_difference_t<_ForwardIterator> __n) const {
+  _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+  operator()(_ForwardIterator __first, iter_difference_t<_ForwardIterator> __n) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
-    return _VSTD::__uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n);
+    return std::__uninitialized_value_construct_n<_ValueType>(std::move(__first), __n);
   }
 };
 
 } // namespace __uninitialized_value_construct_n
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_value_construct_n = __uninitialized_value_construct_n::__fn{};
+inline constexpr auto uninitialized_value_construct_n = __uninitialized_value_construct_n::__fn{};
 } // namespace __cpo
 
 // uninitialized_fill
@@ -136,13 +135,11 @@ inline namespace __cpo {
 namespace __uninitialized_fill {
 
 struct __fn {
-  template <__nothrow_forward_iterator _ForwardIterator,
-            __nothrow_sentinel_for<_ForwardIterator> _Sentinel,
-            class _Tp>
+  template <__nothrow_forward_iterator _ForwardIterator, __nothrow_sentinel_for<_ForwardIterator> _Sentinel, class _Tp>
     requires constructible_from<iter_value_t<_ForwardIterator>, const _Tp&>
   _LIBCPP_HIDE_FROM_ABI _ForwardIterator operator()(_ForwardIterator __first, _Sentinel __last, const _Tp& __x) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
-    return _VSTD::__uninitialized_fill<_ValueType>(_VSTD::move(__first), _VSTD::move(__last), __x);
+    return std::__uninitialized_fill<_ValueType>(std::move(__first), std::move(__last), __x);
   }
 
   template <__nothrow_forward_range _ForwardRange, class _Tp>
@@ -155,7 +152,7 @@ struct __fn {
 } // namespace __uninitialized_fill
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_fill = __uninitialized_fill::__fn{};
+inline constexpr auto uninitialized_fill = __uninitialized_fill::__fn{};
 } // namespace __cpo
 
 // uninitialized_fill_n
@@ -165,18 +162,17 @@ namespace __uninitialized_fill_n {
 struct __fn {
   template <__nothrow_forward_iterator _ForwardIterator, class _Tp>
     requires constructible_from<iter_value_t<_ForwardIterator>, const _Tp&>
-  _LIBCPP_HIDE_FROM_ABI _ForwardIterator operator()(_ForwardIterator __first,
-                              iter_difference_t<_ForwardIterator> __n,
-                              const _Tp& __x) const {
+  _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+  operator()(_ForwardIterator __first, iter_difference_t<_ForwardIterator> __n, const _Tp& __x) const {
     using _ValueType = remove_reference_t<iter_reference_t<_ForwardIterator>>;
-    return _VSTD::__uninitialized_fill_n<_ValueType>(_VSTD::move(__first), __n, __x);
+    return std::__uninitialized_fill_n<_ValueType>(std::move(__first), __n, __x);
   }
 };
 
 } // namespace __uninitialized_fill_n
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_fill_n = __uninitialized_fill_n::__fn{};
+inline constexpr auto uninitialized_fill_n = __uninitialized_fill_n::__fn{};
 } // namespace __cpo
 
 // uninitialized_copy
@@ -196,24 +192,25 @@ struct __fn {
   operator()(_InputIterator __ifirst, _Sentinel1 __ilast, _OutputIterator __ofirst, _Sentinel2 __olast) const {
     using _ValueType = remove_reference_t<iter_reference_t<_OutputIterator>>;
 
-    auto __result = _VSTD::__uninitialized_copy<_ValueType>(_VSTD::move(__ifirst), _VSTD::move(__ilast),
-                                                            _VSTD::move(__ofirst), _VSTD::move(__olast));
-    return {_VSTD::move(__result.first), _VSTD::move(__result.second)};
+    auto __stop_copying = [&__olast](auto&& __out_iter) -> bool { return __out_iter == __olast; };
+    auto __result       = std::__uninitialized_copy<_ValueType>(
+        std::move(__ifirst), std::move(__ilast), std::move(__ofirst), __stop_copying);
+    return {std::move(__result.first), std::move(__result.second)};
   }
 
   template <input_range _InputRange, __nothrow_forward_range _OutputRange>
     requires constructible_from<range_value_t<_OutputRange>, range_reference_t<_InputRange>>
   _LIBCPP_HIDE_FROM_ABI uninitialized_copy_result<borrowed_iterator_t<_InputRange>, borrowed_iterator_t<_OutputRange>>
-  operator()( _InputRange&& __in_range, _OutputRange&& __out_range) const {
-    return (*this)(ranges::begin(__in_range), ranges::end(__in_range),
-                   ranges::begin(__out_range), ranges::end(__out_range));
+  operator()(_InputRange&& __in_range, _OutputRange&& __out_range) const {
+    return (*this)(
+        ranges::begin(__in_range), ranges::end(__in_range), ranges::begin(__out_range), ranges::end(__out_range));
   }
 };
 
 } // namespace __uninitialized_copy
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_copy = __uninitialized_copy::__fn{};
+inline constexpr auto uninitialized_copy = __uninitialized_copy::__fn{};
 } // namespace __cpo
 
 // uninitialized_copy_n
@@ -225,23 +222,26 @@ namespace __uninitialized_copy_n {
 
 struct __fn {
   template <input_iterator _InputIterator,
-           __nothrow_forward_iterator _OutputIterator,
-           __nothrow_sentinel_for<_OutputIterator> _Sentinel>
+            __nothrow_forward_iterator _OutputIterator,
+            __nothrow_sentinel_for<_OutputIterator> _Sentinel>
     requires constructible_from<iter_value_t<_OutputIterator>, iter_reference_t<_InputIterator>>
   _LIBCPP_HIDE_FROM_ABI uninitialized_copy_n_result<_InputIterator, _OutputIterator>
-  operator()(_InputIterator __ifirst, iter_difference_t<_InputIterator> __n,
-             _OutputIterator __ofirst, _Sentinel __olast) const {
-    using _ValueType = remove_reference_t<iter_reference_t<_OutputIterator>>;
-    auto __result = _VSTD::__uninitialized_copy_n<_ValueType>(_VSTD::move(__ifirst), __n,
-                                                              _VSTD::move(__ofirst), _VSTD::move(__olast));
-    return {_VSTD::move(__result.first), _VSTD::move(__result.second)};
+  operator()(_InputIterator __ifirst,
+             iter_difference_t<_InputIterator> __n,
+             _OutputIterator __ofirst,
+             _Sentinel __olast) const {
+    using _ValueType    = remove_reference_t<iter_reference_t<_OutputIterator>>;
+    auto __stop_copying = [&__olast](auto&& __out_iter) -> bool { return __out_iter == __olast; };
+    auto __result =
+        std::__uninitialized_copy_n<_ValueType>(std::move(__ifirst), __n, std::move(__ofirst), __stop_copying);
+    return {std::move(__result.first), std::move(__result.second)};
   }
 };
 
 } // namespace __uninitialized_copy_n
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_copy_n = __uninitialized_copy_n::__fn{};
+inline constexpr auto uninitialized_copy_n = __uninitialized_copy_n::__fn{};
 } // namespace __cpo
 
 // uninitialized_move
@@ -259,26 +259,27 @@ struct __fn {
     requires constructible_from<iter_value_t<_OutputIterator>, iter_rvalue_reference_t<_InputIterator>>
   _LIBCPP_HIDE_FROM_ABI uninitialized_move_result<_InputIterator, _OutputIterator>
   operator()(_InputIterator __ifirst, _Sentinel1 __ilast, _OutputIterator __ofirst, _Sentinel2 __olast) const {
-    using _ValueType = remove_reference_t<iter_reference_t<_OutputIterator>>;
-    auto __iter_move = [](auto&& __iter) -> decltype(auto) { return ranges::iter_move(__iter); };
-    auto __result = _VSTD::__uninitialized_move<_ValueType>(_VSTD::move(__ifirst), _VSTD::move(__ilast),
-                                                            _VSTD::move(__ofirst), _VSTD::move(__olast), __iter_move);
-    return {_VSTD::move(__result.first), _VSTD::move(__result.second)};
+    using _ValueType   = remove_reference_t<iter_reference_t<_OutputIterator>>;
+    auto __iter_move   = [](auto&& __iter) -> decltype(auto) { return ranges::iter_move(__iter); };
+    auto __stop_moving = [&__olast](auto&& __out_iter) -> bool { return __out_iter == __olast; };
+    auto __result      = std::__uninitialized_move<_ValueType>(
+        std::move(__ifirst), std::move(__ilast), std::move(__ofirst), __stop_moving, __iter_move);
+    return {std::move(__result.first), std::move(__result.second)};
   }
 
   template <input_range _InputRange, __nothrow_forward_range _OutputRange>
     requires constructible_from<range_value_t<_OutputRange>, range_rvalue_reference_t<_InputRange>>
   _LIBCPP_HIDE_FROM_ABI uninitialized_move_result<borrowed_iterator_t<_InputRange>, borrowed_iterator_t<_OutputRange>>
   operator()(_InputRange&& __in_range, _OutputRange&& __out_range) const {
-    return (*this)(ranges::begin(__in_range), ranges::end(__in_range),
-                   ranges::begin(__out_range), ranges::end(__out_range));
+    return (*this)(
+        ranges::begin(__in_range), ranges::end(__in_range), ranges::begin(__out_range), ranges::end(__out_range));
   }
 };
 
 } // namespace __uninitialized_move
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_move = __uninitialized_move::__fn{};
+inline constexpr auto uninitialized_move = __uninitialized_move::__fn{};
 } // namespace __cpo
 
 // uninitialized_move_n
@@ -290,24 +291,27 @@ namespace __uninitialized_move_n {
 
 struct __fn {
   template <input_iterator _InputIterator,
-           __nothrow_forward_iterator _OutputIterator,
-           __nothrow_sentinel_for<_OutputIterator> _Sentinel>
+            __nothrow_forward_iterator _OutputIterator,
+            __nothrow_sentinel_for<_OutputIterator> _Sentinel>
     requires constructible_from<iter_value_t<_OutputIterator>, iter_rvalue_reference_t<_InputIterator>>
   _LIBCPP_HIDE_FROM_ABI uninitialized_move_n_result<_InputIterator, _OutputIterator>
-  operator()(_InputIterator __ifirst, iter_difference_t<_InputIterator> __n,
-             _OutputIterator __ofirst, _Sentinel __olast) const {
-    using _ValueType = remove_reference_t<iter_reference_t<_OutputIterator>>;
-    auto __iter_move = [](auto&& __iter) -> decltype(auto) { return ranges::iter_move(__iter); };
-    auto __result = _VSTD::__uninitialized_move_n<_ValueType>(_VSTD::move(__ifirst), __n,
-                                                              _VSTD::move(__ofirst), _VSTD::move(__olast), __iter_move);
-    return {_VSTD::move(__result.first), _VSTD::move(__result.second)};
+  operator()(_InputIterator __ifirst,
+             iter_difference_t<_InputIterator> __n,
+             _OutputIterator __ofirst,
+             _Sentinel __olast) const {
+    using _ValueType   = remove_reference_t<iter_reference_t<_OutputIterator>>;
+    auto __iter_move   = [](auto&& __iter) -> decltype(auto) { return ranges::iter_move(__iter); };
+    auto __stop_moving = [&__olast](auto&& __out_iter) -> bool { return __out_iter == __olast; };
+    auto __result      = std::__uninitialized_move_n<_ValueType>(
+        std::move(__ifirst), __n, std::move(__ofirst), __stop_moving, __iter_move);
+    return {std::move(__result.first), std::move(__result.second)};
   }
 };
 
 } // namespace __uninitialized_move_n
 
 inline namespace __cpo {
-  inline constexpr auto uninitialized_move_n = __uninitialized_move_n::__fn{};
+inline constexpr auto uninitialized_move_n = __uninitialized_move_n::__fn{};
 } // namespace __cpo
 
 } // namespace ranges
@@ -316,4 +320,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_RANGES_UNINITIALIZED_ALGORITHMS_H
diff --git a/third_party/libcxx/__memory/raw_storage_iterator.h b/third_party/libcxx/__memory/raw_storage_iterator.h
index df7ef5afe..774878aa1 100644
--- a/third_party/libcxx/__memory/raw_storage_iterator.h
+++ b/third_party/libcxx/__memory/raw_storage_iterator.h
@@ -22,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR)
@@ -29,42 +32,56 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _OutputIterator, class _Tp>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 raw_storage_iterator
-#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+#  if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
     : public iterator<output_iterator_tag, void, void, void, void>
-#endif
+#  endif
 {
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-private:
-    _OutputIterator __x_;
-public:
-    typedef output_iterator_tag iterator_category;
-    typedef void                value_type;
-#if _LIBCPP_STD_VER >= 20
-    typedef ptrdiff_t           difference_type;
-#else
-    typedef void                difference_type;
-#endif
-    typedef void                pointer;
-    typedef void                reference;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    _LIBCPP_INLINE_VISIBILITY explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {}
-    _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator*() {return *this;}
-    _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(const _Tp& __element)
-        {::new ((void*)_VSTD::addressof(*__x_)) _Tp(__element); return *this;}
-#if _LIBCPP_STD_VER >= 14
-    _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator=(_Tp&& __element)
-        {::new ((void*)_VSTD::addressof(*__x_)) _Tp(_VSTD::move(__element)); return *this;}
-#endif
-    _LIBCPP_INLINE_VISIBILITY raw_storage_iterator& operator++() {++__x_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY raw_storage_iterator  operator++(int)
-        {raw_storage_iterator __t(*this); ++__x_; return __t;}
-#if _LIBCPP_STD_VER >= 14
-    _LIBCPP_INLINE_VISIBILITY _OutputIterator base() const { return __x_; }
-#endif
+private:
+  _OutputIterator __x_;
+
+public:
+  typedef output_iterator_tag iterator_category;
+  typedef void value_type;
+#  if _LIBCPP_STD_VER >= 20
+  typedef ptrdiff_t difference_type;
+#  else
+  typedef void difference_type;
+#  endif
+  typedef void pointer;
+  typedef void reference;
+
+  _LIBCPP_HIDE_FROM_ABI explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {}
+  _LIBCPP_HIDE_FROM_ABI raw_storage_iterator& operator*() { return *this; }
+  _LIBCPP_HIDE_FROM_ABI raw_storage_iterator& operator=(const _Tp& __element) {
+    ::new ((void*)std::addressof(*__x_)) _Tp(__element);
+    return *this;
+  }
+#  if _LIBCPP_STD_VER >= 14
+  _LIBCPP_HIDE_FROM_ABI raw_storage_iterator& operator=(_Tp&& __element) {
+    ::new ((void*)std::addressof(*__x_)) _Tp(std::move(__element));
+    return *this;
+  }
+#  endif
+  _LIBCPP_HIDE_FROM_ABI raw_storage_iterator& operator++() {
+    ++__x_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI raw_storage_iterator operator++(int) {
+    raw_storage_iterator __t(*this);
+    ++__x_;
+    return __t;
+  }
+#  if _LIBCPP_STD_VER >= 14
+  _LIBCPP_HIDE_FROM_ABI _OutputIterator base() const { return __x_; }
+#  endif
 };
 
 #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR)
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_RAW_STORAGE_ITERATOR_H
diff --git a/third_party/libcxx/__memory/shared_ptr.h b/third_party/libcxx/__memory/shared_ptr.h
index db8b67143..d487e4fbe 100644
--- a/third_party/libcxx/__memory/shared_ptr.h
+++ b/third_party/libcxx/__memory/shared_ptr.h
@@ -10,13 +10,14 @@
 #ifndef _LIBCPP___MEMORY_SHARED_PTR_H
 #define _LIBCPP___MEMORY_SHARED_PTR_H
 
-#include <__availability>
 #include <__compare/compare_three_way.h>
 #include <__compare/ordering.h>
 #include <__config>
+#include <__exception/exception.h>
 #include <__functional/binary_function.h>
 #include <__functional/operations.h>
 #include <__functional/reference_wrapper.h>
+#include <__fwd/ostream.h>
 #include <__iterator/access.h>
 #include <__memory/addressof.h>
 #include <__memory/allocation_guard.h>
@@ -35,8 +36,8 @@
 #include <__type_traits/disjunction.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_bounded_array.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
-#include <__type_traits/is_move_constructible.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_unbounded_array.h>
 #include <__type_traits/nat.h>
@@ -49,9 +50,7 @@
 #include <__utility/swap.h>
 #include <__verbose_abort>
 #include <cstddef>
-#include <iosfwd>
 #include <new>
-#include <stdexcept>
 #include <typeinfo>
 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
 #  include <__atomic/memory_order.h>
@@ -61,218 +60,183 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively)
 // should be sufficient for thread safety.
 // See https://llvm.org/PR22803
-#if defined(__clang__) && __has_builtin(__atomic_add_fetch)          \
-                       && defined(__ATOMIC_RELAXED)                  \
-                       && defined(__ATOMIC_ACQ_REL)
-#   define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
+#if defined(__clang__) && __has_builtin(__atomic_add_fetch) && defined(__ATOMIC_RELAXED) && defined(__ATOMIC_ACQ_REL)
+#  define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
 #elif defined(_LIBCPP_COMPILER_GCC)
-#   define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
+#  define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
 #endif
 
 template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-_ValueType __libcpp_relaxed_load(_ValueType const* __value) {
-#if !defined(_LIBCPP_HAS_NO_THREADS) && \
-    defined(__ATOMIC_RELAXED) &&        \
+inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_relaxed_load(_ValueType const* __value) {
+#if !defined(_LIBCPP_HAS_NO_THREADS) && defined(__ATOMIC_RELAXED) &&                                                   \
     (__has_builtin(__atomic_load_n) || defined(_LIBCPP_COMPILER_GCC))
-    return __atomic_load_n(__value, __ATOMIC_RELAXED);
+  return __atomic_load_n(__value, __ATOMIC_RELAXED);
 #else
-    return *__value;
+  return *__value;
 #endif
 }
 
 template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-_ValueType __libcpp_acquire_load(_ValueType const* __value) {
-#if !defined(_LIBCPP_HAS_NO_THREADS) && \
-    defined(__ATOMIC_ACQUIRE) &&        \
+inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_acquire_load(_ValueType const* __value) {
+#if !defined(_LIBCPP_HAS_NO_THREADS) && defined(__ATOMIC_ACQUIRE) &&                                                   \
     (__has_builtin(__atomic_load_n) || defined(_LIBCPP_COMPILER_GCC))
-    return __atomic_load_n(__value, __ATOMIC_ACQUIRE);
+  return __atomic_load_n(__value, __ATOMIC_ACQUIRE);
 #else
-    return *__value;
+  return *__value;
 #endif
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _Tp
-__libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPT
-{
+inline _LIBCPP_HIDE_FROM_ABI _Tp __libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPT {
 #if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
-    return __atomic_add_fetch(&__t, 1, __ATOMIC_RELAXED);
+  return __atomic_add_fetch(&__t, 1, __ATOMIC_RELAXED);
 #else
-    return __t += 1;
+  return __t += 1;
 #endif
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _Tp
-__libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPT
-{
+inline _LIBCPP_HIDE_FROM_ABI _Tp __libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPT {
 #if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
-    return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL);
+  return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL);
 #else
-    return __t -= 1;
+  return __t -= 1;
 #endif
 }
 
-class _LIBCPP_EXCEPTION_ABI bad_weak_ptr
-    : public std::exception
-{
+class _LIBCPP_EXPORTED_FROM_ABI bad_weak_ptr : public std::exception {
 public:
-    _LIBCPP_HIDE_FROM_ABI bad_weak_ptr() _NOEXCEPT = default;
-    _LIBCPP_HIDE_FROM_ABI bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default;
-    ~bad_weak_ptr() _NOEXCEPT override;
-    const char* what() const  _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI bad_weak_ptr() _NOEXCEPT                               = default;
+  _LIBCPP_HIDE_FROM_ABI bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_weak_ptr& operator=(const bad_weak_ptr&) _NOEXCEPT = default;
+  ~bad_weak_ptr() _NOEXCEPT override;
+  const char* what() const _NOEXCEPT override;
 };
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_bad_weak_ptr()
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_bad_weak_ptr() {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw bad_weak_ptr();
+  throw bad_weak_ptr();
 #else
-    _LIBCPP_VERBOSE_ABORT("bad_weak_ptr was thrown in -fno-exceptions mode");
+  _LIBCPP_VERBOSE_ABORT("bad_weak_ptr was thrown in -fno-exceptions mode");
 #endif
 }
 
-template<class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS weak_ptr;
 
-class _LIBCPP_TYPE_VIS __shared_count
-{
-    __shared_count(const __shared_count&);
-    __shared_count& operator=(const __shared_count&);
+class _LIBCPP_EXPORTED_FROM_ABI __shared_count {
+  __shared_count(const __shared_count&);
+  __shared_count& operator=(const __shared_count&);
 
 protected:
-    long __shared_owners_;
-    virtual ~__shared_count();
+  long __shared_owners_;
+  virtual ~__shared_count();
+
 private:
-    virtual void __on_zero_shared() _NOEXCEPT = 0;
+  virtual void __on_zero_shared() _NOEXCEPT = 0;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __shared_count(long __refs = 0) _NOEXCEPT
-        : __shared_owners_(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __shared_count(long __refs = 0) _NOEXCEPT : __shared_owners_(__refs) {}
 
 #if defined(_LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS)
-    void __add_shared() noexcept;
-    bool __release_shared() noexcept;
+  void __add_shared() noexcept;
+  bool __release_shared() noexcept;
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    void __add_shared() _NOEXCEPT {
-      __libcpp_atomic_refcount_increment(__shared_owners_);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    bool __release_shared() _NOEXCEPT {
-      if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) {
-        __on_zero_shared();
-        return true;
-      }
-      return false;
+  _LIBCPP_HIDE_FROM_ABI void __add_shared() _NOEXCEPT { __libcpp_atomic_refcount_increment(__shared_owners_); }
+  _LIBCPP_HIDE_FROM_ABI bool __release_shared() _NOEXCEPT {
+    if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) {
+      __on_zero_shared();
+      return true;
     }
+    return false;
+  }
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    long use_count() const _NOEXCEPT {
-        return __libcpp_relaxed_load(&__shared_owners_) + 1;
-    }
+  _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __libcpp_relaxed_load(&__shared_owners_) + 1; }
 };
 
-class _LIBCPP_TYPE_VIS __shared_weak_count
-    : private __shared_count
-{
-    long __shared_weak_owners_;
+class _LIBCPP_EXPORTED_FROM_ABI __shared_weak_count : private __shared_count {
+  long __shared_weak_owners_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __shared_weak_count(long __refs = 0) _NOEXCEPT
-        : __shared_count(__refs),
-          __shared_weak_owners_(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __shared_weak_count(long __refs = 0) _NOEXCEPT
+      : __shared_count(__refs),
+        __shared_weak_owners_(__refs) {}
+
 protected:
-    ~__shared_weak_count() override;
+  ~__shared_weak_count() override;
 
 public:
 #if defined(_LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS)
-    void __add_shared() noexcept;
-    void __add_weak() noexcept;
-    void __release_shared() noexcept;
+  void __add_shared() noexcept;
+  void __add_weak() noexcept;
+  void __release_shared() noexcept;
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    void __add_shared() _NOEXCEPT {
-      __shared_count::__add_shared();
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    void __add_weak() _NOEXCEPT {
-      __libcpp_atomic_refcount_increment(__shared_weak_owners_);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    void __release_shared() _NOEXCEPT {
-      if (__shared_count::__release_shared())
-        __release_weak();
-    }
+  _LIBCPP_HIDE_FROM_ABI void __add_shared() _NOEXCEPT { __shared_count::__add_shared(); }
+  _LIBCPP_HIDE_FROM_ABI void __add_weak() _NOEXCEPT { __libcpp_atomic_refcount_increment(__shared_weak_owners_); }
+  _LIBCPP_HIDE_FROM_ABI void __release_shared() _NOEXCEPT {
+    if (__shared_count::__release_shared())
+      __release_weak();
+  }
 #endif
-    void __release_weak() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    long use_count() const _NOEXCEPT {return __shared_count::use_count();}
-    __shared_weak_count* lock() _NOEXCEPT;
+  void __release_weak() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __shared_count::use_count(); }
+  __shared_weak_count* lock() _NOEXCEPT;
+
+  virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
 
-    virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
 private:
-    virtual void __on_zero_shared_weak() _NOEXCEPT = 0;
+  virtual void __on_zero_shared_weak() _NOEXCEPT = 0;
 };
 
 template <class _Tp, class _Dp, class _Alloc>
-class __shared_ptr_pointer
-    : public __shared_weak_count
-{
-    __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
+class __shared_ptr_pointer : public __shared_weak_count {
+  __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
-        :  __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {}
+  _LIBCPP_HIDE_FROM_ABI __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
+      : __data_(__compressed_pair<_Tp, _Dp>(__p, std::move(__d)), std::move(__a)) {}
 
 #ifndef _LIBCPP_HAS_NO_RTTI
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL const void* __get_deleter(const type_info&) const _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL const void* __get_deleter(const type_info&) const _NOEXCEPT override;
 #endif
 
 private:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override;
 };
 
 #ifndef _LIBCPP_HAS_NO_RTTI
 
 template <class _Tp, class _Dp, class _Alloc>
-const void*
-__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT
-{
-    return __t == typeid(_Dp) ? _VSTD::addressof(__data_.first().second()) : nullptr;
+const void* __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT {
+  return __t == typeid(_Dp) ? std::addressof(__data_.first().second()) : nullptr;
 }
 
 #endif // _LIBCPP_HAS_NO_RTTI
 
 template <class _Tp, class _Dp, class _Alloc>
-void
-__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT
-{
-    __data_.first().second()(__data_.first().first());
-    __data_.first().second().~_Dp();
+void __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT {
+  __data_.first().second()(__data_.first().first());
+  __data_.first().second().~_Dp();
 }
 
 template <class _Tp, class _Dp, class _Alloc>
-void
-__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT
-{
-    typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al;
-    typedef allocator_traits<_Al> _ATraits;
-    typedef pointer_traits<typename _ATraits::pointer> _PTraits;
+void __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT {
+  typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al;
+  typedef allocator_traits<_Al> _ATraits;
+  typedef pointer_traits<typename _ATraits::pointer> _PTraits;
 
-    _Al __a(__data_.second());
-    __data_.second().~_Alloc();
-    __a.deallocate(_PTraits::pointer_to(*this), 1);
+  _Al __a(__data_.second());
+  __data_.second().~_Alloc();
+  __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 // This tag is used to instantiate an allocator type. The various shared_ptr control blocks
@@ -281,108 +245,99 @@ __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT
 struct __for_overwrite_tag {};
 
 template <class _Tp, class _Alloc>
-struct __shared_ptr_emplace
-    : __shared_weak_count
-{
-    template<class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI
-    explicit __shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
-        : __storage_(_VSTD::move(__a))
-    {
-#if _LIBCPP_STD_VER >= 20
-        if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
-            static_assert(sizeof...(_Args) == 0, "No argument should be provided to the control block when using _for_overwrite");
-            ::new ((void*)__get_elem()) _Tp;
-        } else {
-            using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
-            _TpAlloc __tmp(*__get_alloc());
-            allocator_traits<_TpAlloc>::construct(__tmp, __get_elem(), _VSTD::forward<_Args>(__args)...);
-        }
-#else
-        ::new ((void*)__get_elem()) _Tp(_VSTD::forward<_Args>(__args)...);
-#endif
-    }
+struct __shared_ptr_emplace : __shared_weak_count {
+  template <class... _Args,
+            class _Allocator                                                                         = _Alloc,
+            __enable_if_t<is_same<typename _Allocator::value_type, __for_overwrite_tag>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit __shared_ptr_emplace(_Alloc __a, _Args&&...) : __storage_(std::move(__a)) {
+    static_assert(
+        sizeof...(_Args) == 0, "No argument should be provided to the control block when using _for_overwrite");
+    ::new ((void*)__get_elem()) _Tp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Alloc* __get_alloc() _NOEXCEPT { return __storage_.__get_alloc(); }
+  template <class... _Args,
+            class _Allocator                                                                          = _Alloc,
+            __enable_if_t<!is_same<typename _Allocator::value_type, __for_overwrite_tag>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit __shared_ptr_emplace(_Alloc __a, _Args&&... __args) : __storage_(std::move(__a)) {
+    using _TpAlloc = typename __allocator_traits_rebind<_Alloc, __remove_cv_t<_Tp> >::type;
+    _TpAlloc __tmp(*__get_alloc());
+    allocator_traits<_TpAlloc>::construct(__tmp, __get_elem(), std::forward<_Args>(__args)...);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    _Tp* __get_elem() _NOEXCEPT { return __storage_.__get_elem(); }
+  _LIBCPP_HIDE_FROM_ABI _Alloc* __get_alloc() _NOEXCEPT { return __storage_.__get_alloc(); }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp* __get_elem() _NOEXCEPT { return __storage_.__get_elem(); }
 
 private:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override {
-#if _LIBCPP_STD_VER >= 20
-        if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
-            __get_elem()->~_Tp();
-        } else {
-            using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
-            _TpAlloc __tmp(*__get_alloc());
-            allocator_traits<_TpAlloc>::destroy(__tmp, __get_elem());
-        }
-#else
-        __get_elem()->~_Tp();
-#endif
+  template <class _Allocator                                                                         = _Alloc,
+            __enable_if_t<is_same<typename _Allocator::value_type, __for_overwrite_tag>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void __on_zero_shared_impl() _NOEXCEPT {
+    __get_elem()->~_Tp();
+  }
+
+  template <class _Allocator                                                                          = _Alloc,
+            __enable_if_t<!is_same<typename _Allocator::value_type, __for_overwrite_tag>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void __on_zero_shared_impl() _NOEXCEPT {
+    using _TpAlloc = typename __allocator_traits_rebind<_Allocator, __remove_cv_t<_Tp> >::type;
+    _TpAlloc __tmp(*__get_alloc());
+    allocator_traits<_TpAlloc>::destroy(__tmp, __get_elem());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override { __on_zero_shared_impl(); }
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override {
+    using _ControlBlockAlloc   = typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type;
+    using _ControlBlockPointer = typename allocator_traits<_ControlBlockAlloc>::pointer;
+    _ControlBlockAlloc __tmp(*__get_alloc());
+    __storage_.~_Storage();
+    allocator_traits<_ControlBlockAlloc>::deallocate(__tmp, pointer_traits<_ControlBlockPointer>::pointer_to(*this), 1);
+  }
+
+  // This class implements the control block for non-array shared pointers created
+  // through `std::allocate_shared` and `std::make_shared`.
+  //
+  // In previous versions of the library, we used a compressed pair to store
+  // both the _Alloc and the _Tp. This implies using EBO, which is incompatible
+  // with Allocator construction for _Tp. To allow implementing P0674 in C++20,
+  // we now use a properly aligned char buffer while making sure that we maintain
+  // the same layout that we had when we used a compressed pair.
+  using _CompressedPair = __compressed_pair<_Alloc, _Tp>;
+  struct _ALIGNAS_TYPE(_CompressedPair) _Storage {
+    char __blob_[sizeof(_CompressedPair)];
+
+    _LIBCPP_HIDE_FROM_ABI explicit _Storage(_Alloc&& __a) { ::new ((void*)__get_alloc()) _Alloc(std::move(__a)); }
+    _LIBCPP_HIDE_FROM_ABI ~_Storage() { __get_alloc()->~_Alloc(); }
+    _LIBCPP_HIDE_FROM_ABI _Alloc* __get_alloc() _NOEXCEPT {
+      _CompressedPair* __as_pair                = reinterpret_cast<_CompressedPair*>(__blob_);
+      typename _CompressedPair::_Base1* __first = _CompressedPair::__get_first_base(__as_pair);
+      _Alloc* __alloc                           = reinterpret_cast<_Alloc*>(__first);
+      return __alloc;
     }
-
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override {
-        using _ControlBlockAlloc = typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type;
-        using _ControlBlockPointer = typename allocator_traits<_ControlBlockAlloc>::pointer;
-        _ControlBlockAlloc __tmp(*__get_alloc());
-        __storage_.~_Storage();
-        allocator_traits<_ControlBlockAlloc>::deallocate(__tmp,
-            pointer_traits<_ControlBlockPointer>::pointer_to(*this), 1);
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI _Tp* __get_elem() _NOEXCEPT {
+      _CompressedPair* __as_pair                 = reinterpret_cast<_CompressedPair*>(__blob_);
+      typename _CompressedPair::_Base2* __second = _CompressedPair::__get_second_base(__as_pair);
+      _Tp* __elem                                = reinterpret_cast<_Tp*>(__second);
+      return __elem;
     }
+  };
 
-    // This class implements the control block for non-array shared pointers created
-    // through `std::allocate_shared` and `std::make_shared`.
-    //
-    // In previous versions of the library, we used a compressed pair to store
-    // both the _Alloc and the _Tp. This implies using EBO, which is incompatible
-    // with Allocator construction for _Tp. To allow implementing P0674 in C++20,
-    // we now use a properly aligned char buffer while making sure that we maintain
-    // the same layout that we had when we used a compressed pair.
-    using _CompressedPair = __compressed_pair<_Alloc, _Tp>;
-    struct _ALIGNAS_TYPE(_CompressedPair) _Storage {
-        char __blob_[sizeof(_CompressedPair)];
-
-        _LIBCPP_HIDE_FROM_ABI explicit _Storage(_Alloc&& __a) {
-            ::new ((void*)__get_alloc()) _Alloc(_VSTD::move(__a));
-        }
-        _LIBCPP_HIDE_FROM_ABI ~_Storage() {
-            __get_alloc()->~_Alloc();
-        }
-        _LIBCPP_HIDE_FROM_ABI _Alloc* __get_alloc() _NOEXCEPT {
-            _CompressedPair *__as_pair = reinterpret_cast<_CompressedPair*>(__blob_);
-            typename _CompressedPair::_Base1* __first = _CompressedPair::__get_first_base(__as_pair);
-            _Alloc *__alloc = reinterpret_cast<_Alloc*>(__first);
-            return __alloc;
-        }
-        _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI _Tp* __get_elem() _NOEXCEPT {
-            _CompressedPair *__as_pair = reinterpret_cast<_CompressedPair*>(__blob_);
-            typename _CompressedPair::_Base2* __second = _CompressedPair::__get_second_base(__as_pair);
-            _Tp *__elem = reinterpret_cast<_Tp*>(__second);
-            return __elem;
-        }
-    };
-
-    static_assert(_LIBCPP_ALIGNOF(_Storage) == _LIBCPP_ALIGNOF(_CompressedPair), "");
-    static_assert(sizeof(_Storage) == sizeof(_CompressedPair), "");
-    _Storage __storage_;
+  static_assert(_LIBCPP_ALIGNOF(_Storage) == _LIBCPP_ALIGNOF(_CompressedPair), "");
+  static_assert(sizeof(_Storage) == sizeof(_CompressedPair), "");
+  _Storage __storage_;
 };
 
 struct __shared_ptr_dummy_rebind_allocator_type;
 template <>
-class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type>
-{
+class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type> {
 public:
-    template <class _Other>
-    struct rebind
-    {
-        typedef allocator<_Other> other;
-    };
+  template <class _Other>
+  struct rebind {
+    typedef allocator<_Other> other;
+  };
 };
 
-template<class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS enable_shared_from_this;
 
 // http://eel.is/c++draft/util.sharedptr#util.smartptr.shared.general-6
 // A pointer type Y* is said to be compatible with a pointer type T*
@@ -392,19 +347,13 @@ template <class _Yp, class _Tp>
 struct __bounded_convertible_to_unbounded : false_type {};
 
 template <class _Up, std::size_t _Np, class _Tp>
-struct __bounded_convertible_to_unbounded<_Up[_Np], _Tp>
-        : is_same<__remove_cv_t<_Tp>, _Up[]> {};
+struct __bounded_convertible_to_unbounded<_Up[_Np], _Tp> : is_same<__remove_cv_t<_Tp>, _Up[]> {};
 
 template <class _Yp, class _Tp>
-struct __compatible_with
-    : _Or<
-        is_convertible<_Yp*, _Tp*>,
-        __bounded_convertible_to_unbounded<_Yp, _Tp>
-    > {};
+struct __compatible_with : _Or< is_convertible<_Yp*, _Tp*>, __bounded_convertible_to_unbounded<_Yp, _Tp> > {};
 #else
 template <class _Yp, class _Tp>
-struct __compatible_with
-    : is_convertible<_Yp*, _Tp*> {};
+struct __compatible_with : is_convertible<_Yp*, _Tp*> {};
 #endif // _LIBCPP_STD_VER >= 17
 
 // Constructors that take raw pointers have a different set of "compatible" constraints
@@ -414,40 +363,32 @@ struct __compatible_with
 // - If T is not an array type, then Y* is convertible to T*.
 #if _LIBCPP_STD_VER >= 17
 template <class _Yp, class _Tp, class = void>
-struct __raw_pointer_compatible_with : _And<
-        _Not<is_array<_Tp>>,
-        is_convertible<_Yp*, _Tp*>
-        > {};
+struct __raw_pointer_compatible_with : _And< _Not<is_array<_Tp>>, is_convertible<_Yp*, _Tp*> > {};
 
 template <class _Yp, class _Up, std::size_t _Np>
-struct __raw_pointer_compatible_with<_Yp, _Up[_Np], __enable_if_t<
-            is_convertible<_Yp(*)[_Np], _Up(*)[_Np]>::value> >
-        : true_type {};
+struct __raw_pointer_compatible_with<_Yp, _Up[_Np], __enable_if_t< is_convertible<_Yp (*)[_Np], _Up (*)[_Np]>::value> >
+    : true_type {};
 
 template <class _Yp, class _Up>
-struct __raw_pointer_compatible_with<_Yp, _Up[], __enable_if_t<
-            is_convertible<_Yp(*)[], _Up(*)[]>::value> >
-        : true_type {};
+struct __raw_pointer_compatible_with<_Yp, _Up[], __enable_if_t< is_convertible<_Yp (*)[], _Up (*)[]>::value> >
+    : true_type {};
 
 #else
 template <class _Yp, class _Tp>
-struct __raw_pointer_compatible_with
-    : is_convertible<_Yp*, _Tp*> {};
+struct __raw_pointer_compatible_with : is_convertible<_Yp*, _Tp*> {};
 #endif // _LIBCPP_STD_VER >= 17
 
+template <class _Ptr, class = void>
+struct __is_deletable : false_type {};
+template <class _Ptr>
+struct __is_deletable<_Ptr, decltype(delete std::declval<_Ptr>())> : true_type {};
 
 template <class _Ptr, class = void>
-struct __is_deletable : false_type { };
+struct __is_array_deletable : false_type {};
 template <class _Ptr>
-struct __is_deletable<_Ptr, decltype(delete std::declval<_Ptr>())> : true_type { };
+struct __is_array_deletable<_Ptr, decltype(delete[] std::declval<_Ptr>())> : true_type {};
 
-template <class _Ptr, class = void>
-struct __is_array_deletable : false_type { };
-template <class _Ptr>
-struct __is_array_deletable<_Ptr, decltype(delete[] std::declval<_Ptr>())> : true_type { };
-
-template <class _Dp, class _Pt,
-    class = decltype(std::declval<_Dp>()(std::declval<_Pt>()))>
+template <class _Dp, class _Pt, class = decltype(std::declval<_Dp>()(std::declval<_Pt>()))>
 true_type __well_formed_deleter_test(int);
 
 template <class, class>
@@ -456,585 +397,472 @@ false_type __well_formed_deleter_test(...);
 template <class _Dp, class _Pt>
 struct __well_formed_deleter : decltype(std::__well_formed_deleter_test<_Dp, _Pt>(0)) {};
 
-template<class _Dp, class _Yp, class _Tp>
-struct __shared_ptr_deleter_ctor_reqs
-{
-    static const bool value = __raw_pointer_compatible_with<_Yp, _Tp>::value &&
-                              is_move_constructible<_Dp>::value &&
-                              __well_formed_deleter<_Dp, _Yp*>::value;
+template <class _Dp, class _Yp, class _Tp>
+struct __shared_ptr_deleter_ctor_reqs {
+  static const bool value = __raw_pointer_compatible_with<_Yp, _Tp>::value && is_move_constructible<_Dp>::value &&
+                            __well_formed_deleter<_Dp, _Yp*>::value;
 };
 
+template <class _Dp>
+using __shared_ptr_nullptr_deleter_ctor_reqs = _And<is_move_constructible<_Dp>, __well_formed_deleter<_Dp, nullptr_t> >;
+
 #if defined(_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI)
 #  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI __attribute__((__trivial_abi__))
 #else
 #  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI
 #endif
 
-template<class _Tp>
-class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr
-{
+template <class _Tp>
+class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr {
+  struct __nullptr_sfinae_tag {};
+
 public:
 #if _LIBCPP_STD_VER >= 17
-    typedef weak_ptr<_Tp> weak_type;
-    typedef remove_extent_t<_Tp> element_type;
+  typedef weak_ptr<_Tp> weak_type;
+  typedef remove_extent_t<_Tp> element_type;
 #else
-    typedef _Tp element_type;
+  typedef _Tp element_type;
 #endif
 
+  // A shared_ptr contains only two raw pointers which point to the heap and move constructing already doesn't require
+  // any bookkeeping, so it's always trivially relocatable.
+  using __trivially_relocatable = shared_ptr;
+
 private:
-    element_type*      __ptr_;
-    __shared_weak_count* __cntrl_;
+  element_type* __ptr_;
+  __shared_weak_count* __cntrl_;
 
 public:
-    _LIBCPP_HIDE_FROM_ABI
-    _LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT
-        : __ptr_(nullptr),
-          __cntrl_(nullptr)
-    { }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    _LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT
-        : __ptr_(nullptr),
-          __cntrl_(nullptr)
-    { }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) {}
 
-    template<class _Yp, class = __enable_if_t<
-        _And<
-            __raw_pointer_compatible_with<_Yp, _Tp>
-            // In C++03 we get errors when trying to do SFINAE with the
-            // delete operator, so we always pretend that it's deletable.
-            // The same happens on GCC.
+  template <class _Yp,
+            __enable_if_t< _And< __raw_pointer_compatible_with<_Yp, _Tp>
+  // In C++03 we get errors when trying to do SFINAE with the
+  // delete operator, so we always pretend that it's deletable.
+  // The same happens on GCC.
 #if !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_COMPILER_GCC)
-            , _If<is_array<_Tp>::value, __is_array_deletable<_Yp*>, __is_deletable<_Yp*> >
+                                 ,
+                                 _If<is_array<_Tp>::value, __is_array_deletable<_Yp*>, __is_deletable<_Yp*> >
 #endif
-        >::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI explicit shared_ptr(_Yp* __p) : __ptr_(__p) {
-        unique_ptr<_Yp> __hold(__p);
-        typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
-        typedef __shared_ptr_pointer<_Yp*, __shared_ptr_default_delete<_Tp, _Yp>, _AllocT> _CntrlBlk;
-        __cntrl_ = new _CntrlBlk(__p, __shared_ptr_default_delete<_Tp, _Yp>(), _AllocT());
-        __hold.release();
-        __enable_weak_this(__p, __p);
-    }
+                                 >::value,
+                           int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit shared_ptr(_Yp* __p) : __ptr_(__p) {
+    unique_ptr<_Yp> __hold(__p);
+    typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
+    typedef __shared_ptr_pointer<_Yp*, __shared_ptr_default_delete<_Tp, _Yp>, _AllocT> _CntrlBlk;
+    __cntrl_ = new _CntrlBlk(__p, __shared_ptr_default_delete<_Tp, _Yp>(), _AllocT());
+    __hold.release();
+    __enable_weak_this(__p, __p);
+  }
 
-    template<class _Yp, class _Dp, class = __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(_Yp* __p, _Dp __d)
-        : __ptr_(__p)
-    {
+  template <class _Yp, class _Dp, __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(_Yp* __p, _Dp __d) : __ptr_(__p) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
-            typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT> _CntrlBlk;
+      typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
+      typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT> _CntrlBlk;
 #ifndef _LIBCPP_CXX03_LANG
-            __cntrl_ = new _CntrlBlk(__p, _VSTD::move(__d), _AllocT());
+      __cntrl_ = new _CntrlBlk(__p, std::move(__d), _AllocT());
 #else
-            __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
+    __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
 #endif // not _LIBCPP_CXX03_LANG
-            __enable_weak_this(__p, __p);
+      __enable_weak_this(__p, __p);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __d(__p);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __d(__p);
+      throw;
     }
-
-    template<class _Yp, class _Dp, class _Alloc, class = __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(_Yp* __p, _Dp __d, _Alloc __a)
-        : __ptr_(__p)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
-            typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
-            typedef __allocator_destructor<_A2> _D2;
-            _A2 __a2(__a);
-            unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
-            ::new ((void*)_VSTD::addressof(*__hold2.get()))
+  }
+
+  template <class _Yp,
+            class _Dp,
+            class _Alloc,
+            __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(_Yp* __p, _Dp __d, _Alloc __a) : __ptr_(__p) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
+      typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
+      typedef __allocator_destructor<_A2> _D2;
+      _A2 __a2(__a);
+      unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
+      ::new ((void*)std::addressof(*__hold2.get()))
 #ifndef _LIBCPP_CXX03_LANG
-                _CntrlBlk(__p, _VSTD::move(__d), __a);
+          _CntrlBlk(__p, std::move(__d), __a);
 #else
-                _CntrlBlk(__p, __d, __a);
+        _CntrlBlk(__p, __d, __a);
 #endif // not _LIBCPP_CXX03_LANG
-            __cntrl_ = _VSTD::addressof(*__hold2.release());
-            __enable_weak_this(__p, __p);
+      __cntrl_ = std::addressof(*__hold2.release());
+      __enable_weak_this(__p, __p);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __d(__p);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __d(__p);
+      throw;
     }
-
-    template<class _Dp>
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(nullptr_t __p, _Dp __d)
-        : __ptr_(nullptr)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
-            typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT> _CntrlBlk;
+  }
+
+  template <class _Dp>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(
+      nullptr_t __p,
+      _Dp __d,
+      __enable_if_t<__shared_ptr_nullptr_deleter_ctor_reqs<_Dp>::value, __nullptr_sfinae_tag> = __nullptr_sfinae_tag())
+      : __ptr_(nullptr) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
+      typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT> _CntrlBlk;
 #ifndef _LIBCPP_CXX03_LANG
-            __cntrl_ = new _CntrlBlk(__p, _VSTD::move(__d), _AllocT());
+      __cntrl_ = new _CntrlBlk(__p, std::move(__d), _AllocT());
 #else
-            __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
+    __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
 #endif // not _LIBCPP_CXX03_LANG
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __d(__p);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __d(__p);
+      throw;
     }
-
-    template<class _Dp, class _Alloc>
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a)
-        : __ptr_(nullptr)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
-            typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
-            typedef __allocator_destructor<_A2> _D2;
-            _A2 __a2(__a);
-            unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
-            ::new ((void*)_VSTD::addressof(*__hold2.get()))
+  }
+
+  template <class _Dp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(
+      nullptr_t __p,
+      _Dp __d,
+      _Alloc __a,
+      __enable_if_t<__shared_ptr_nullptr_deleter_ctor_reqs<_Dp>::value, __nullptr_sfinae_tag> = __nullptr_sfinae_tag())
+      : __ptr_(nullptr) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
+      typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
+      typedef __allocator_destructor<_A2> _D2;
+      _A2 __a2(__a);
+      unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
+      ::new ((void*)std::addressof(*__hold2.get()))
 #ifndef _LIBCPP_CXX03_LANG
-                _CntrlBlk(__p, _VSTD::move(__d), __a);
+          _CntrlBlk(__p, std::move(__d), __a);
 #else
-                _CntrlBlk(__p, __d, __a);
+        _CntrlBlk(__p, __d, __a);
 #endif // not _LIBCPP_CXX03_LANG
-            __cntrl_ = _VSTD::addressof(*__hold2.release());
+      __cntrl_ = std::addressof(*__hold2.release());
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __d(__p);
-            throw;
-        }
+    } catch (...) {
+      __d(__p);
+      throw;
+    }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
+  }
 
-    template<class _Yp>
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(const shared_ptr<_Yp>& __r, element_type *__p) _NOEXCEPT
-        : __ptr_(__p),
-          __cntrl_(__r.__cntrl_)
-    {
-        if (__cntrl_)
-            __cntrl_->__add_shared();
-    }
+  template <class _Yp>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT
+      : __ptr_(__p),
+        __cntrl_(__r.__cntrl_) {
+    if (__cntrl_)
+      __cntrl_->__add_shared();
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(const shared_ptr& __r) _NOEXCEPT
-        : __ptr_(__r.__ptr_),
-          __cntrl_(__r.__cntrl_)
-    {
-        if (__cntrl_)
-            __cntrl_->__add_shared();
-    }
+// LWG-2996
+// We don't backport because it is an evolutionary change.
+#if _LIBCPP_STD_VER >= 20
+  template <class _Yp>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(shared_ptr<_Yp>&& __r, element_type* __p) noexcept
+      : __ptr_(__p), __cntrl_(__r.__cntrl_) {
+    __r.__ptr_   = nullptr;
+    __r.__cntrl_ = nullptr;
+  }
+#endif
 
-    template<class _Yp, class = __enable_if_t<__compatible_with<_Yp, _Tp>::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(const shared_ptr<_Yp>& __r) _NOEXCEPT
-        : __ptr_(__r.__ptr_),
-          __cntrl_(__r.__cntrl_)
-    {
-        if (__cntrl_)
-            __cntrl_->__add_shared();
-    }
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(const shared_ptr& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
+    if (__cntrl_)
+      __cntrl_->__add_shared();
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(shared_ptr&& __r) _NOEXCEPT
-        : __ptr_(__r.__ptr_),
-          __cntrl_(__r.__cntrl_)
-    {
-        __r.__ptr_ = nullptr;
-        __r.__cntrl_ = nullptr;
-    }
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(const shared_ptr<_Yp>& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
+    if (__cntrl_)
+      __cntrl_->__add_shared();
+  }
 
-    template<class _Yp, class = __enable_if_t<__compatible_with<_Yp, _Tp>::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(shared_ptr<_Yp>&& __r) _NOEXCEPT
-        : __ptr_(__r.__ptr_),
-          __cntrl_(__r.__cntrl_)
-    {
-        __r.__ptr_ = nullptr;
-        __r.__cntrl_ = nullptr;
-    }
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(shared_ptr&& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
+    __r.__ptr_   = nullptr;
+    __r.__cntrl_ = nullptr;
+  }
 
-    template<class _Yp, class = __enable_if_t<__compatible_with<_Yp, _Tp>::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    explicit shared_ptr(const weak_ptr<_Yp>& __r)
-        : __ptr_(__r.__ptr_),
-          __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_)
-    {
-        if (__cntrl_ == nullptr)
-            __throw_bad_weak_ptr();
-    }
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(shared_ptr<_Yp>&& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
+    __r.__ptr_   = nullptr;
+    __r.__cntrl_ = nullptr;
+  }
+
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit shared_ptr(const weak_ptr<_Yp>& __r)
+      : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_) {
+    if (__cntrl_ == nullptr)
+      __throw_bad_weak_ptr();
+  }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
-    template<class _Yp, class = __enable_if_t<is_convertible<_Yp*, element_type*>::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(auto_ptr<_Yp>&& __r)
-        : __ptr_(__r.get())
-    {
-        typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
-        __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>());
-        __enable_weak_this(__r.get(), __r.get());
-        __r.release();
-    }
+  template <class _Yp, __enable_if_t<is_convertible<_Yp*, element_type*>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(auto_ptr<_Yp>&& __r) : __ptr_(__r.get()) {
+    typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<__remove_cv_t<_Yp> > > _CntrlBlk;
+    __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<__remove_cv_t<_Yp> >());
+    __enable_weak_this(__r.get(), __r.get());
+    __r.release();
+  }
 #endif
 
-    template <class _Yp, class _Dp, class = __enable_if_t<
-        !is_lvalue_reference<_Dp>::value &&
-         __compatible_with<_Yp, _Tp>::value &&
-         is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(unique_ptr<_Yp, _Dp>&& __r)
-        : __ptr_(__r.get())
-    {
+  template <class _Yp,
+            class _Dp,
+            __enable_if_t<!is_lvalue_reference<_Dp>::value && __compatible_with<_Yp, _Tp>::value &&
+                              is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(unique_ptr<_Yp, _Dp>&& __r) : __ptr_(__r.get()) {
 #if _LIBCPP_STD_VER >= 14
-        if (__ptr_ == nullptr)
-            __cntrl_ = nullptr;
-        else
+    if (__ptr_ == nullptr)
+      __cntrl_ = nullptr;
+    else
 #endif
-        {
-            typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
-            typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, _Dp, _AllocT> _CntrlBlk;
-            __cntrl_ = new _CntrlBlk(__r.get(), std::move(__r.get_deleter()), _AllocT());
-            __enable_weak_this(__r.get(), __r.get());
-        }
-        __r.release();
-    }
-
-    template <class _Yp, class _Dp, class = void, class = __enable_if_t<
-        is_lvalue_reference<_Dp>::value &&
-         __compatible_with<_Yp, _Tp>::value &&
-        is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr(unique_ptr<_Yp, _Dp>&& __r)
-        : __ptr_(__r.get())
     {
+      typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
+      typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, _Dp, _AllocT> _CntrlBlk;
+      __cntrl_ = new _CntrlBlk(__r.get(), std::move(__r.get_deleter()), _AllocT());
+      __enable_weak_this(__r.get(), __r.get());
+    }
+    __r.release();
+  }
+
+  template <class _Yp,
+            class _Dp,
+            class              = void,
+            __enable_if_t<is_lvalue_reference<_Dp>::value && __compatible_with<_Yp, _Tp>::value &&
+                              is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr(unique_ptr<_Yp, _Dp>&& __r) : __ptr_(__r.get()) {
 #if _LIBCPP_STD_VER >= 14
-        if (__ptr_ == nullptr)
-            __cntrl_ = nullptr;
-        else
+    if (__ptr_ == nullptr)
+      __cntrl_ = nullptr;
+    else
 #endif
-        {
-            typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
-            typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer,
-                                        reference_wrapper<__libcpp_remove_reference_t<_Dp> >,
-                                        _AllocT> _CntrlBlk;
-            __cntrl_ = new _CntrlBlk(__r.get(), _VSTD::ref(__r.get_deleter()), _AllocT());
-            __enable_weak_this(__r.get(), __r.get());
-        }
-        __r.release();
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    ~shared_ptr()
     {
-        if (__cntrl_)
-            __cntrl_->__release_shared();
+      typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
+      typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer,
+                                   reference_wrapper<__libcpp_remove_reference_t<_Dp> >,
+                                   _AllocT>
+          _CntrlBlk;
+      __cntrl_ = new _CntrlBlk(__r.get(), std::ref(__r.get_deleter()), _AllocT());
+      __enable_weak_this(__r.get(), __r.get());
     }
+    __r.release();
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr<_Tp>& operator=(const shared_ptr& __r) _NOEXCEPT
-    {
-        shared_ptr(__r).swap(*this);
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI ~shared_ptr() {
+    if (__cntrl_)
+      __cntrl_->__release_shared();
+  }
 
-    template<class _Yp, class = __enable_if_t<__compatible_with<_Yp, _Tp>::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr<_Tp>& operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT
-    {
-        shared_ptr(__r).swap(*this);
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(const shared_ptr& __r) _NOEXCEPT {
+    shared_ptr(__r).swap(*this);
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr<_Tp>& operator=(shared_ptr&& __r) _NOEXCEPT
-    {
-        shared_ptr(_VSTD::move(__r)).swap(*this);
-        return *this;
-    }
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT {
+    shared_ptr(__r).swap(*this);
+    return *this;
+  }
 
-    template<class _Yp, class = __enable_if_t<__compatible_with<_Yp, _Tp>::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr<_Tp>& operator=(shared_ptr<_Yp>&& __r)
-    {
-        shared_ptr(_VSTD::move(__r)).swap(*this);
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(shared_ptr&& __r) _NOEXCEPT {
+    shared_ptr(std::move(__r)).swap(*this);
+    return *this;
+  }
+
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(shared_ptr<_Yp>&& __r) {
+    shared_ptr(std::move(__r)).swap(*this);
+    return *this;
+  }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
-    template<class _Yp, class = __enable_if_t<
-        !is_array<_Yp>::value &&
-        is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr<_Tp>& operator=(auto_ptr<_Yp>&& __r)
-    {
-        shared_ptr(_VSTD::move(__r)).swap(*this);
-        return *this;
-    }
+  template <class _Yp,
+            __enable_if_t<!is_array<_Yp>::value && is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value,
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(auto_ptr<_Yp>&& __r) {
+    shared_ptr(std::move(__r)).swap(*this);
+    return *this;
+  }
 #endif
 
-    template <class _Yp, class _Dp, class = __enable_if_t<_And<
-        __compatible_with<_Yp, _Tp>,
-        is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>
-    >::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    shared_ptr<_Tp>& operator=(unique_ptr<_Yp, _Dp>&& __r)
-    {
-        shared_ptr(_VSTD::move(__r)).swap(*this);
-        return *this;
-    }
+  template <class _Yp,
+            class _Dp,
+            __enable_if_t<_And< __compatible_with<_Yp, _Tp>,
+                                is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*> >::value,
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(unique_ptr<_Yp, _Dp>&& __r) {
+    shared_ptr(std::move(__r)).swap(*this);
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    void swap(shared_ptr& __r) _NOEXCEPT
-    {
-        _VSTD::swap(__ptr_, __r.__ptr_);
-        _VSTD::swap(__cntrl_, __r.__cntrl_);
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(shared_ptr& __r) _NOEXCEPT {
+    std::swap(__ptr_, __r.__ptr_);
+    std::swap(__cntrl_, __r.__cntrl_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    void reset() _NOEXCEPT
-    {
-        shared_ptr().swap(*this);
-    }
+  _LIBCPP_HIDE_FROM_ABI void reset() _NOEXCEPT { shared_ptr().swap(*this); }
 
-    template<class _Yp, class = __enable_if_t<
-        __raw_pointer_compatible_with<_Yp, _Tp>::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI
-    void reset(_Yp* __p)
-    {
-        shared_ptr(__p).swap(*this);
-    }
+  template <class _Yp, __enable_if_t<__raw_pointer_compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void reset(_Yp* __p) {
+    shared_ptr(__p).swap(*this);
+  }
 
-    template<class _Yp, class _Dp, class = __enable_if_t<
-        __shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    void reset(_Yp* __p, _Dp __d)
-    {
-        shared_ptr(__p, __d).swap(*this);
-    }
+  template <class _Yp, class _Dp, __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void reset(_Yp* __p, _Dp __d) {
+    shared_ptr(__p, __d).swap(*this);
+  }
 
-    template<class _Yp, class _Dp, class _Alloc, class = __enable_if_t<
-        __shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> >
-    _LIBCPP_HIDE_FROM_ABI
-    void reset(_Yp* __p, _Dp __d, _Alloc __a)
-    {
-        shared_ptr(__p, __d, __a).swap(*this);
-    }
+  template <class _Yp,
+            class _Dp,
+            class _Alloc,
+            __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void reset(_Yp* __p, _Dp __d, _Alloc __a) {
+    shared_ptr(__p, __d, __a).swap(*this);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    element_type* get() const _NOEXCEPT
-    {
-        return __ptr_;
-    }
+  _LIBCPP_HIDE_FROM_ABI element_type* get() const _NOEXCEPT { return __ptr_; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    __add_lvalue_reference_t<element_type> operator*() const _NOEXCEPT
-    {
-        return *__ptr_;
-    }
+  _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<element_type> operator*() const _NOEXCEPT { return *__ptr_; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    element_type* operator->() const _NOEXCEPT
-    {
-        static_assert(!is_array<_Tp>::value,
-                      "std::shared_ptr<T>::operator-> is only valid when T is not an array type.");
-        return __ptr_;
-    }
+  _LIBCPP_HIDE_FROM_ABI element_type* operator->() const _NOEXCEPT {
+    static_assert(!is_array<_Tp>::value, "std::shared_ptr<T>::operator-> is only valid when T is not an array type.");
+    return __ptr_;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    long use_count() const _NOEXCEPT
-    {
-        return __cntrl_ ? __cntrl_->use_count() : 0;
-    }
+  _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __cntrl_ ? __cntrl_->use_count() : 0; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    bool unique() const _NOEXCEPT
-    {
-        return use_count() == 1;
-    }
+#if _LIBCPP_STD_VER < 20 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_SHARED_PTR_UNIQUE)
+  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI bool unique() const _NOEXCEPT { return use_count() == 1; }
+#endif
 
-    _LIBCPP_HIDE_FROM_ABI
-    explicit operator bool() const _NOEXCEPT
-    {
-        return get() != nullptr;
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return get() != nullptr; }
 
-    template <class _Up>
-    _LIBCPP_HIDE_FROM_ABI
-    bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT
-    {
-        return __cntrl_ < __p.__cntrl_;
-    }
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT {
+    return __cntrl_ < __p.__cntrl_;
+  }
 
-    template <class _Up>
-    _LIBCPP_HIDE_FROM_ABI
-    bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT
-    {
-        return __cntrl_ < __p.__cntrl_;
-    }
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT {
+    return __cntrl_ < __p.__cntrl_;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    bool __owner_equivalent(const shared_ptr& __p) const
-    {
-        return __cntrl_ == __p.__cntrl_;
-    }
+  _LIBCPP_HIDE_FROM_ABI bool __owner_equivalent(const shared_ptr& __p) const { return __cntrl_ == __p.__cntrl_; }
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_HIDE_FROM_ABI
-    __add_lvalue_reference_t<element_type> operator[](ptrdiff_t __i) const
-    {
-            static_assert(is_array<_Tp>::value,
-                          "std::shared_ptr<T>::operator[] is only valid when T is an array type.");
-            return __ptr_[__i];
-    }
+  _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<element_type> operator[](ptrdiff_t __i) const {
+    static_assert(is_array<_Tp>::value, "std::shared_ptr<T>::operator[] is only valid when T is an array type.");
+    return __ptr_[__i];
+  }
 #endif
 
 #ifndef _LIBCPP_HAS_NO_RTTI
-    template <class _Dp>
-    _LIBCPP_HIDE_FROM_ABI
-    _Dp* __get_deleter() const _NOEXCEPT
-    {
-        return static_cast<_Dp*>(__cntrl_
-                    ? const_cast<void *>(__cntrl_->__get_deleter(typeid(_Dp)))
-                      : nullptr);
-    }
+  template <class _Dp>
+  _LIBCPP_HIDE_FROM_ABI _Dp* __get_deleter() const _NOEXCEPT {
+    return static_cast<_Dp*>(__cntrl_ ? const_cast<void*>(__cntrl_->__get_deleter(typeid(_Dp))) : nullptr);
+  }
 #endif // _LIBCPP_HAS_NO_RTTI
 
-    template<class _Yp, class _CntrlBlk>
-    _LIBCPP_HIDE_FROM_ABI
-    static shared_ptr<_Tp> __create_with_control_block(_Yp* __p, _CntrlBlk* __cntrl) _NOEXCEPT
-    {
-        shared_ptr<_Tp> __r;
-        __r.__ptr_ = __p;
-        __r.__cntrl_ = __cntrl;
-        __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
-        return __r;
-    }
+  template <class _Yp, class _CntrlBlk>
+  _LIBCPP_HIDE_FROM_ABI static shared_ptr<_Tp> __create_with_control_block(_Yp* __p, _CntrlBlk* __cntrl) _NOEXCEPT {
+    shared_ptr<_Tp> __r;
+    __r.__ptr_   = __p;
+    __r.__cntrl_ = __cntrl;
+    __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
+    return __r;
+  }
 
 private:
-    template <class _Yp, bool = is_function<_Yp>::value>
-    struct __shared_ptr_default_allocator
-    {
-        typedef allocator<_Yp> type;
-    };
+  template <class _Yp, bool = is_function<_Yp>::value>
+  struct __shared_ptr_default_allocator {
+    typedef allocator<__remove_cv_t<_Yp> > type;
+  };
 
-    template <class _Yp>
-    struct __shared_ptr_default_allocator<_Yp, true>
-    {
-        typedef allocator<__shared_ptr_dummy_rebind_allocator_type> type;
-    };
+  template <class _Yp>
+  struct __shared_ptr_default_allocator<_Yp, true> {
+    typedef allocator<__shared_ptr_dummy_rebind_allocator_type> type;
+  };
 
-    template <class _Yp, class _OrigPtr, class = __enable_if_t<
-        is_convertible<_OrigPtr*, const enable_shared_from_this<_Yp>*>::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI
-    void __enable_weak_this(const enable_shared_from_this<_Yp>* __e, _OrigPtr* __ptr) _NOEXCEPT
-    {
-        typedef __remove_cv_t<_Yp> _RawYp;
-        if (__e && __e->__weak_this_.expired())
-        {
-            __e->__weak_this_ = shared_ptr<_RawYp>(*this,
-                const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr)));
-        }
+  template <class _Yp,
+            class _OrigPtr,
+            __enable_if_t<is_convertible<_OrigPtr*, const enable_shared_from_this<_Yp>*>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void __enable_weak_this(const enable_shared_from_this<_Yp>* __e, _OrigPtr* __ptr) _NOEXCEPT {
+    typedef __remove_cv_t<_Yp> _RawYp;
+    if (__e && __e->__weak_this_.expired()) {
+      __e->__weak_this_ = shared_ptr<_RawYp>(*this, const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr)));
     }
+  }
 
-    _LIBCPP_HIDE_FROM_ABI void __enable_weak_this(...) _NOEXCEPT { }
+  _LIBCPP_HIDE_FROM_ABI void __enable_weak_this(...) _NOEXCEPT {}
 
-    template <class, class _Yp>
-    struct __shared_ptr_default_delete
-        : default_delete<_Yp>
-    { };
+  template <class, class _Yp>
+  struct __shared_ptr_default_delete : default_delete<_Yp> {};
 
-    template <class _Yp, class _Un, size_t _Sz>
-    struct __shared_ptr_default_delete<_Yp[_Sz], _Un>
-        : default_delete<_Yp[]>
-    { };
+  template <class _Yp, class _Un, size_t _Sz>
+  struct __shared_ptr_default_delete<_Yp[_Sz], _Un> : default_delete<_Yp[]> {};
 
-    template <class _Yp, class _Un>
-    struct __shared_ptr_default_delete<_Yp[], _Un>
-        : default_delete<_Yp[]>
-    { };
+  template <class _Yp, class _Un>
+  struct __shared_ptr_default_delete<_Yp[], _Un> : default_delete<_Yp[]> {};
 
-    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
-    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
+  template <class _Up>
+  friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
+  template <class _Up>
+  friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _Tp>
+template <class _Tp>
 shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
-template<class _Tp, class _Dp>
+template <class _Tp, class _Dp>
 shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>;
 #endif
 
 //
 // std::allocate_shared and std::make_shared
 //
-template<class _Tp, class _Alloc, class ..._Args, class = __enable_if_t<!is_array<_Tp>::value> >
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&& ...__args)
-{
-    using _ControlBlock = __shared_ptr_emplace<_Tp, _Alloc>;
-    using _ControlBlockAllocator = typename __allocator_traits_rebind<_Alloc, _ControlBlock>::type;
-    __allocation_guard<_ControlBlockAllocator> __guard(__a, 1);
-    ::new ((void*)_VSTD::addressof(*__guard.__get())) _ControlBlock(__a, _VSTD::forward<_Args>(__args)...);
-    auto __control_block = __guard.__release_ptr();
-    return shared_ptr<_Tp>::__create_with_control_block((*__control_block).__get_elem(), _VSTD::addressof(*__control_block));
+template <class _Tp, class _Alloc, class... _Args, __enable_if_t<!is_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&&... __args) {
+  using _ControlBlock          = __shared_ptr_emplace<_Tp, _Alloc>;
+  using _ControlBlockAllocator = typename __allocator_traits_rebind<_Alloc, _ControlBlock>::type;
+  __allocation_guard<_ControlBlockAllocator> __guard(__a, 1);
+  ::new ((void*)std::addressof(*__guard.__get())) _ControlBlock(__a, std::forward<_Args>(__args)...);
+  auto __control_block = __guard.__release_ptr();
+  return shared_ptr<_Tp>::__create_with_control_block(
+      (*__control_block).__get_elem(), std::addressof(*__control_block));
 }
 
-template<class _Tp, class ..._Args, class = __enable_if_t<!is_array<_Tp>::value> >
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> make_shared(_Args&& ...__args)
-{
-    return _VSTD::allocate_shared<_Tp>(allocator<_Tp>(), _VSTD::forward<_Args>(__args)...);
+template <class _Tp, class... _Args, __enable_if_t<!is_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(_Args&&... __args) {
+  return std::allocate_shared<_Tp>(allocator<__remove_cv_t<_Tp> >(), std::forward<_Args>(__args)...);
 }
 
 #if _LIBCPP_STD_VER >= 20
 
-template<class _Tp, class _Alloc, __enable_if_t<!is_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a)
-{
-    using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
-    _ForOverwriteAllocator __alloc(__a);
-    return std::allocate_shared<_Tp>(__alloc);
+template <class _Tp, class _Alloc, __enable_if_t<!is_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a) {
+  using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
+  _ForOverwriteAllocator __alloc(__a);
+  return std::allocate_shared<_Tp>(__alloc);
 }
 
-template<class _Tp, __enable_if_t<!is_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> make_shared_for_overwrite()
-{
-    return std::allocate_shared_for_overwrite<_Tp>(allocator<_Tp>());
+template <class _Tp, __enable_if_t<!is_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite() {
+  return std::allocate_shared_for_overwrite<_Tp>(allocator<__remove_cv_t<_Tp>>());
 }
 
 #endif // _LIBCPP_STD_VER >= 20
@@ -1043,190 +871,180 @@ shared_ptr<_Tp> make_shared_for_overwrite()
 
 template <size_t _Alignment>
 struct __sp_aligned_storage {
-    alignas(_Alignment) char __storage[_Alignment];
+  alignas(_Alignment) char __storage[_Alignment];
 };
 
 template <class _Tp, class _Alloc>
 struct __unbounded_array_control_block;
 
 template <class _Tp, class _Alloc>
-struct __unbounded_array_control_block<_Tp[], _Alloc> : __shared_weak_count
-{
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    _Tp* __get_data() noexcept { return __data_; }
+struct __unbounded_array_control_block<_Tp[], _Alloc> : __shared_weak_count {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* __get_data() noexcept { return __data_; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    explicit __unbounded_array_control_block(_Alloc const& __alloc, size_t __count, _Tp const& __arg)
-        : __alloc_(__alloc), __count_(__count)
-    {
-        std::__uninitialized_allocator_fill_n_multidimensional(__alloc_, std::begin(__data_), __count_, __arg);
+  _LIBCPP_HIDE_FROM_ABI explicit __unbounded_array_control_block(
+      _Alloc const& __alloc, size_t __count, _Tp const& __arg)
+      : __alloc_(__alloc), __count_(__count) {
+    std::__uninitialized_allocator_fill_n_multidimensional(__alloc_, std::begin(__data_), __count_, __arg);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI explicit __unbounded_array_control_block(_Alloc const& __alloc, size_t __count)
+      : __alloc_(__alloc), __count_(__count) {
+#  if _LIBCPP_STD_VER >= 20
+    if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
+      // We are purposefully not using an allocator-aware default construction because the spec says so.
+      // There's currently no way of expressing default initialization in an allocator-aware manner anyway.
+      std::uninitialized_default_construct_n(std::begin(__data_), __count_);
+    } else {
+      std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::begin(__data_), __count_);
     }
+#  else
+    std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::begin(__data_), __count_);
+#  endif
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    explicit __unbounded_array_control_block(_Alloc const& __alloc, size_t __count)
-        : __alloc_(__alloc), __count_(__count)
-    {
-#if _LIBCPP_STD_VER >= 20
-        if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
-            // We are purposefully not using an allocator-aware default construction because the spec says so.
-            // There's currently no way of expressing default initialization in an allocator-aware manner anyway.
-            std::uninitialized_default_construct_n(std::begin(__data_), __count_);
-        } else {
-            std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::begin(__data_), __count_);
-        }
-#else
-        std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::begin(__data_), __count_);
-#endif
-    }
+  // Returns the number of bytes required to store a control block followed by the given number
+  // of elements of _Tp, with the whole storage being aligned to a multiple of _Tp's alignment.
+  _LIBCPP_HIDE_FROM_ABI static constexpr size_t __bytes_for(size_t __elements) {
+    // When there's 0 elements, the control block alone is enough since it holds one element.
+    // Otherwise, we allocate one fewer element than requested because the control block already
+    // holds one. Also, we use the bitwise formula below to ensure that we allocate enough bytes
+    // for the whole allocation to be a multiple of _Tp's alignment. That formula is taken from [1].
+    //
+    // [1]: https://en.wikipedia.org/wiki/Data_structure_alignment#Computing_padding
+    size_t __bytes           = __elements == 0 ? sizeof(__unbounded_array_control_block)
+                                               : (__elements - 1) * sizeof(_Tp) + sizeof(__unbounded_array_control_block);
+    constexpr size_t __align = alignof(_Tp);
+    return (__bytes + __align - 1) & ~(__align - 1);
+  }
 
-    // Returns the number of bytes required to store a control block followed by the given number
-    // of elements of _Tp, with the whole storage being aligned to a multiple of _Tp's alignment.
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr size_t __bytes_for(size_t __elements) {
-        // When there's 0 elements, the control block alone is enough since it holds one element.
-        // Otherwise, we allocate one fewer element than requested because the control block already
-        // holds one. Also, we use the bitwise formula below to ensure that we allocate enough bytes
-        // for the whole allocation to be a multiple of _Tp's alignment. That formula is taken from [1].
-        //
-        // [1]: https://en.wikipedia.org/wiki/Data_structure_alignment#Computing_padding
-        size_t __bytes = __elements == 0 ? sizeof(__unbounded_array_control_block)
-                                         : (__elements - 1) * sizeof(_Tp) + sizeof(__unbounded_array_control_block);
-        constexpr size_t __align = alignof(_Tp);
-        return (__bytes + __align - 1) & ~(__align - 1);
-    }
-
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL
-    ~__unbounded_array_control_block() override { } // can't be `= default` because of the sometimes-non-trivial union member __data_
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  ~__unbounded_array_control_block() override {
+  } // can't be `= default` because of the sometimes-non-trivial union member __data_
 
 private:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override {
-#if _LIBCPP_STD_VER >= 20
-        if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
-            std::__reverse_destroy(__data_, __data_ + __count_);
-        } else {
-            __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
-            std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + __count_);
-        }
-#else
-        __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
-        std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + __count_);
-#endif
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override {
+#  if _LIBCPP_STD_VER >= 20
+    if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
+      std::__reverse_destroy(__data_, __data_ + __count_);
+    } else {
+      __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
+      std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + __count_);
     }
+#  else
+    __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
+    std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + __count_);
+#  endif
+  }
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override {
-        using _AlignedStorage = __sp_aligned_storage<alignof(__unbounded_array_control_block)>;
-        using _StorageAlloc = __allocator_traits_rebind_t<_Alloc, _AlignedStorage>;
-        using _PointerTraits = pointer_traits<typename allocator_traits<_StorageAlloc>::pointer>;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override {
+    using _AlignedStorage = __sp_aligned_storage<alignof(__unbounded_array_control_block)>;
+    using _StorageAlloc   = __allocator_traits_rebind_t<_Alloc, _AlignedStorage>;
+    using _PointerTraits  = pointer_traits<typename allocator_traits<_StorageAlloc>::pointer>;
 
-        _StorageAlloc __tmp(__alloc_);
-        __alloc_.~_Alloc();
-        size_t __size = __unbounded_array_control_block::__bytes_for(__count_);
-        _AlignedStorage* __storage = reinterpret_cast<_AlignedStorage*>(this);
-        allocator_traits<_StorageAlloc>::deallocate(__tmp, _PointerTraits::pointer_to(*__storage), __size);
-    }
+    _StorageAlloc __tmp(__alloc_);
+    __alloc_.~_Alloc();
+    size_t __size              = __unbounded_array_control_block::__bytes_for(__count_);
+    _AlignedStorage* __storage = reinterpret_cast<_AlignedStorage*>(this);
+    allocator_traits<_StorageAlloc>::deallocate(
+        __tmp, _PointerTraits::pointer_to(*__storage), __size / sizeof(_AlignedStorage));
+  }
 
-    _LIBCPP_NO_UNIQUE_ADDRESS _Alloc __alloc_;
-    size_t __count_;
-    union {
-        _Tp __data_[1];
-    };
+  _LIBCPP_NO_UNIQUE_ADDRESS _Alloc __alloc_;
+  size_t __count_;
+  union {
+    _Tp __data_[1];
+  };
 };
 
-template<class _Array, class _Alloc, class... _Arg>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Array> __allocate_shared_unbounded_array(const _Alloc& __a, size_t __n, _Arg&& ...__arg)
-{
-    static_assert(__libcpp_is_unbounded_array<_Array>::value);
-    // We compute the number of bytes necessary to hold the control block and the
-    // array elements. Then, we allocate an array of properly-aligned dummy structs
-    // large enough to hold the control block and array. This allows shifting the
-    // burden of aligning memory properly from us to the allocator.
-    using _ControlBlock = __unbounded_array_control_block<_Array, _Alloc>;
-    using _AlignedStorage = __sp_aligned_storage<alignof(_ControlBlock)>;
-    using _StorageAlloc = __allocator_traits_rebind_t<_Alloc, _AlignedStorage>;
-    __allocation_guard<_StorageAlloc> __guard(__a, _ControlBlock::__bytes_for(__n) / sizeof(_AlignedStorage));
-    _ControlBlock* __control_block = reinterpret_cast<_ControlBlock*>(std::addressof(*__guard.__get()));
-    std::__construct_at(__control_block, __a, __n, std::forward<_Arg>(__arg)...);
-    __guard.__release_ptr();
-    return shared_ptr<_Array>::__create_with_control_block(__control_block->__get_data(), __control_block);
+template <class _Array, class _Alloc, class... _Arg>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Array>
+__allocate_shared_unbounded_array(const _Alloc& __a, size_t __n, _Arg&&... __arg) {
+  static_assert(__libcpp_is_unbounded_array<_Array>::value);
+  // We compute the number of bytes necessary to hold the control block and the
+  // array elements. Then, we allocate an array of properly-aligned dummy structs
+  // large enough to hold the control block and array. This allows shifting the
+  // burden of aligning memory properly from us to the allocator.
+  using _ControlBlock   = __unbounded_array_control_block<_Array, _Alloc>;
+  using _AlignedStorage = __sp_aligned_storage<alignof(_ControlBlock)>;
+  using _StorageAlloc   = __allocator_traits_rebind_t<_Alloc, _AlignedStorage>;
+  __allocation_guard<_StorageAlloc> __guard(__a, _ControlBlock::__bytes_for(__n) / sizeof(_AlignedStorage));
+  _ControlBlock* __control_block = reinterpret_cast<_ControlBlock*>(std::addressof(*__guard.__get()));
+  std::__construct_at(__control_block, __a, __n, std::forward<_Arg>(__arg)...);
+  __guard.__release_ptr();
+  return shared_ptr<_Array>::__create_with_control_block(__control_block->__get_data(), __control_block);
 }
 
 template <class _Tp, class _Alloc>
 struct __bounded_array_control_block;
 
 template <class _Tp, size_t _Count, class _Alloc>
-struct __bounded_array_control_block<_Tp[_Count], _Alloc>
-    : __shared_weak_count
-{
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    _Tp* __get_data() noexcept { return __data_; }
+struct __bounded_array_control_block<_Tp[_Count], _Alloc> : __shared_weak_count {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* __get_data() noexcept { return __data_; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    explicit __bounded_array_control_block(_Alloc const& __alloc, _Tp const& __arg) : __alloc_(__alloc) {
-        std::__uninitialized_allocator_fill_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count, __arg);
+  _LIBCPP_HIDE_FROM_ABI explicit __bounded_array_control_block(_Alloc const& __alloc, _Tp const& __arg)
+      : __alloc_(__alloc) {
+    std::__uninitialized_allocator_fill_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count, __arg);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI explicit __bounded_array_control_block(_Alloc const& __alloc) : __alloc_(__alloc) {
+#  if _LIBCPP_STD_VER >= 20
+    if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
+      // We are purposefully not using an allocator-aware default construction because the spec says so.
+      // There's currently no way of expressing default initialization in an allocator-aware manner anyway.
+      std::uninitialized_default_construct_n(std::addressof(__data_[0]), _Count);
+    } else {
+      std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count);
     }
+#  else
+    std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count);
+#  endif
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    explicit __bounded_array_control_block(_Alloc const& __alloc) : __alloc_(__alloc) {
-#if _LIBCPP_STD_VER >= 20
-        if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
-            // We are purposefully not using an allocator-aware default construction because the spec says so.
-            // There's currently no way of expressing default initialization in an allocator-aware manner anyway.
-            std::uninitialized_default_construct_n(std::addressof(__data_[0]), _Count);
-        } else {
-            std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count);
-        }
-#else
-        std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count);
-#endif
-    }
-
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL
-    ~__bounded_array_control_block() override { } // can't be `= default` because of the sometimes-non-trivial union member __data_
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  ~__bounded_array_control_block() override {
+  } // can't be `= default` because of the sometimes-non-trivial union member __data_
 
 private:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override {
-#if _LIBCPP_STD_VER >= 20
-        if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
-            std::__reverse_destroy(__data_, __data_ + _Count);
-        } else {
-            __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
-            std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + _Count);
-        }
-#else
-        __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
-        std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + _Count);
-#endif
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override {
+#  if _LIBCPP_STD_VER >= 20
+    if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
+      std::__reverse_destroy(__data_, __data_ + _Count);
+    } else {
+      __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
+      std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + _Count);
     }
+#  else
+    __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
+    std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + _Count);
+#  endif
+  }
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override {
-        using _ControlBlockAlloc = __allocator_traits_rebind_t<_Alloc, __bounded_array_control_block>;
-        using _PointerTraits = pointer_traits<typename allocator_traits<_ControlBlockAlloc>::pointer>;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override {
+    using _ControlBlockAlloc = __allocator_traits_rebind_t<_Alloc, __bounded_array_control_block>;
+    using _PointerTraits     = pointer_traits<typename allocator_traits<_ControlBlockAlloc>::pointer>;
 
-        _ControlBlockAlloc __tmp(__alloc_);
-        __alloc_.~_Alloc();
-        allocator_traits<_ControlBlockAlloc>::deallocate(__tmp, _PointerTraits::pointer_to(*this), sizeof(*this));
-    }
+    _ControlBlockAlloc __tmp(__alloc_);
+    __alloc_.~_Alloc();
+    allocator_traits<_ControlBlockAlloc>::deallocate(__tmp, _PointerTraits::pointer_to(*this), 1);
+  }
 
-    _LIBCPP_NO_UNIQUE_ADDRESS _Alloc __alloc_;
-    union {
-        _Tp __data_[_Count];
-    };
+  _LIBCPP_NO_UNIQUE_ADDRESS _Alloc __alloc_;
+  union {
+    _Tp __data_[_Count];
+  };
 };
 
-template<class _Array, class _Alloc, class... _Arg>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Array> __allocate_shared_bounded_array(const _Alloc& __a, _Arg&& ...__arg)
-{
-    static_assert(__libcpp_is_bounded_array<_Array>::value);
-    using _ControlBlock = __bounded_array_control_block<_Array, _Alloc>;
-    using _ControlBlockAlloc = __allocator_traits_rebind_t<_Alloc, _ControlBlock>;
+template <class _Array, class _Alloc, class... _Arg>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Array> __allocate_shared_bounded_array(const _Alloc& __a, _Arg&&... __arg) {
+  static_assert(__libcpp_is_bounded_array<_Array>::value);
+  using _ControlBlock      = __bounded_array_control_block<_Array, _Alloc>;
+  using _ControlBlockAlloc = __allocator_traits_rebind_t<_Alloc, _ControlBlock>;
 
-    __allocation_guard<_ControlBlockAlloc> __guard(__a, 1);
-    _ControlBlock* __control_block = reinterpret_cast<_ControlBlock*>(std::addressof(*__guard.__get()));
-    std::__construct_at(__control_block, __a, std::forward<_Arg>(__arg)...);
-    __guard.__release_ptr();
-    return shared_ptr<_Array>::__create_with_control_block(__control_block->__get_data(), __control_block);
+  __allocation_guard<_ControlBlockAlloc> __guard(__a, 1);
+  _ControlBlock* __control_block = reinterpret_cast<_ControlBlock*>(std::addressof(*__guard.__get()));
+  std::__construct_at(__control_block, __a, std::forward<_Arg>(__arg)...);
+  __guard.__release_ptr();
+  return shared_ptr<_Array>::__create_with_control_block(__control_block->__get_data(), __control_block);
 }
 
 #endif // _LIBCPP_STD_VER >= 17
@@ -1234,856 +1052,643 @@ shared_ptr<_Array> __allocate_shared_bounded_array(const _Alloc& __a, _Arg&& ...
 #if _LIBCPP_STD_VER >= 20
 
 // bounded array variants
-template<class _Tp, class _Alloc, class = __enable_if_t<is_bounded_array<_Tp>::value>>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> allocate_shared(const _Alloc& __a)
-{
-    return std::__allocate_shared_bounded_array<_Tp>(__a);
+template <class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a) {
+  return std::__allocate_shared_bounded_array<_Tp>(__a);
 }
 
-template<class _Tp, class _Alloc, class = __enable_if_t<is_bounded_array<_Tp>::value>>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> allocate_shared(const _Alloc& __a, const remove_extent_t<_Tp>& __u)
-{
-    return std::__allocate_shared_bounded_array<_Tp>(__a, __u);
+template <class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, const remove_extent_t<_Tp>& __u) {
+  return std::__allocate_shared_bounded_array<_Tp>(__a, __u);
 }
 
-template<class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a)
-{
-    using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
-    _ForOverwriteAllocator __alloc(__a);
-    return std::__allocate_shared_bounded_array<_Tp>(__alloc);
+template <class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a) {
+  using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
+  _ForOverwriteAllocator __alloc(__a);
+  return std::__allocate_shared_bounded_array<_Tp>(__alloc);
 }
 
-template<class _Tp, class = __enable_if_t<is_bounded_array<_Tp>::value>>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> make_shared()
-{
-    return std::__allocate_shared_bounded_array<_Tp>(allocator<_Tp>());
+template <class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared() {
+  return std::__allocate_shared_bounded_array<_Tp>(allocator<_Tp>());
 }
 
-template<class _Tp, class = __enable_if_t<is_bounded_array<_Tp>::value>>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> make_shared(const remove_extent_t<_Tp>& __u)
-{
-    return std::__allocate_shared_bounded_array<_Tp>(allocator<_Tp>(), __u);
+template <class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(const remove_extent_t<_Tp>& __u) {
+  return std::__allocate_shared_bounded_array<_Tp>(allocator<_Tp>(), __u);
 }
 
-template<class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> make_shared_for_overwrite()
-{
-    return std::__allocate_shared_bounded_array<_Tp>(allocator<__for_overwrite_tag>());
+template <class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite() {
+  return std::__allocate_shared_bounded_array<_Tp>(allocator<__for_overwrite_tag>());
 }
 
 // unbounded array variants
-template<class _Tp, class _Alloc, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n)
-{
-    return std::__allocate_shared_unbounded_array<_Tp>(__a, __n);
+template <class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n) {
+  return std::__allocate_shared_unbounded_array<_Tp>(__a, __n);
 }
 
-template<class _Tp, class _Alloc, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n, const remove_extent_t<_Tp>& __u)
-{
-    return std::__allocate_shared_unbounded_array<_Tp>(__a, __n, __u);
+template <class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n, const remove_extent_t<_Tp>& __u) {
+  return std::__allocate_shared_unbounded_array<_Tp>(__a, __n, __u);
 }
 
-template<class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a, size_t __n)
-{
-    using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
-    _ForOverwriteAllocator __alloc(__a);
-    return std::__allocate_shared_unbounded_array<_Tp>(__alloc, __n);
+template <class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a, size_t __n) {
+  using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
+  _ForOverwriteAllocator __alloc(__a);
+  return std::__allocate_shared_unbounded_array<_Tp>(__alloc, __n);
 }
 
-template<class _Tp, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> make_shared(size_t __n)
-{
-    return std::__allocate_shared_unbounded_array<_Tp>(allocator<_Tp>(), __n);
+template <class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(size_t __n) {
+  return std::__allocate_shared_unbounded_array<_Tp>(allocator<_Tp>(), __n);
 }
 
-template<class _Tp, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> make_shared(size_t __n, const remove_extent_t<_Tp>& __u)
-{
-    return std::__allocate_shared_unbounded_array<_Tp>(allocator<_Tp>(), __n, __u);
+template <class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(size_t __n, const remove_extent_t<_Tp>& __u) {
+  return std::__allocate_shared_unbounded_array<_Tp>(allocator<_Tp>(), __n, __u);
 }
 
-template<class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI
-shared_ptr<_Tp> make_shared_for_overwrite(size_t __n)
-{
-    return std::__allocate_shared_unbounded_array<_Tp>(allocator<__for_overwrite_tag>(), __n);
+template <class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite(size_t __n) {
+  return std::__allocate_shared_unbounded_array<_Tp>(allocator<__for_overwrite_tag>(), __n);
 }
 
 #endif // _LIBCPP_STD_VER >= 20
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
-{
-    return __x.get() == __y.get();
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
+  return __x.get() == __y.get();
 }
 
 #if _LIBCPP_STD_VER <= 17
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
-{
-    return !(__x == __y);
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
+  return !(__x == __y);
 }
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
-{
-#if _LIBCPP_STD_VER <= 11
-    typedef typename common_type<_Tp*, _Up*>::type _Vp;
-    return less<_Vp>()(__x.get(), __y.get());
-#else
-    return less<>()(__x.get(), __y.get());
-#endif
-
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
+#  if _LIBCPP_STD_VER <= 11
+  typedef typename common_type<_Tp*, _Up*>::type _Vp;
+  return less<_Vp>()(__x.get(), __y.get());
+#  else
+  return less<>()(__x.get(), __y.get());
+#  endif
 }
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
-{
-    return __y < __x;
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
+  return __y < __x;
 }
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
-{
-    return !(__y < __x);
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
+  return !(__y < __x);
 }
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
-{
-    return !(__x < __y);
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
+  return !(__x < __y);
 }
 
 #endif // _LIBCPP_STD_VER <= 17
 
 #if _LIBCPP_STD_VER >= 20
-template<class _Tp, class _Up>
-_LIBCPP_HIDE_FROM_ABI strong_ordering
-operator<=>(shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) noexcept
-{
-    return compare_three_way()(__x.get(), __y.get());
+template <class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) noexcept {
+  return compare_three_way()(__x.get(), __y.get());
 }
 #endif
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
-{
-    return !__x;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
+  return !__x;
 }
 
 #if _LIBCPP_STD_VER <= 17
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
-{
-    return !__x;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
+  return !__x;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
-{
-    return static_cast<bool>(__x);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
+  return static_cast<bool>(__x);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
-{
-    return static_cast<bool>(__x);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
+  return static_cast<bool>(__x);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
-{
-    return less<_Tp*>()(__x.get(), nullptr);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
+  return less<typename shared_ptr<_Tp>::element_type*>()(__x.get(), nullptr);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
-{
-    return less<_Tp*>()(nullptr, __x.get());
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
+  return less<typename shared_ptr<_Tp>::element_type*>()(nullptr, __x.get());
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
-{
-    return nullptr < __x;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
+  return nullptr < __x;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
-{
-    return __x < nullptr;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
+  return __x < nullptr;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
-{
-    return !(nullptr < __x);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
+  return !(nullptr < __x);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
-{
-    return !(__x < nullptr);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
+  return !(__x < nullptr);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT
-{
-    return !(__x < nullptr);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
+  return !(__x < nullptr);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT
-{
-    return !(nullptr < __x);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
+  return !(nullptr < __x);
 }
 
 #endif // _LIBCPP_STD_VER <= 17
 
 #if _LIBCPP_STD_VER >= 20
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI strong_ordering
-operator<=>(shared_ptr<_Tp> const& __x, nullptr_t) noexcept
-{
-    return compare_three_way()(__x.get(), static_cast<typename shared_ptr<_Tp>::element_type*>(nullptr));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(shared_ptr<_Tp> const& __x, nullptr_t) noexcept {
+  return compare_three_way()(__x.get(), static_cast<typename shared_ptr<_Tp>::element_type*>(nullptr));
 }
 #endif
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT
-{
-    __x.swap(__y);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI void swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT {
+  __x.swap(__y);
 }
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-shared_ptr<_Tp>
-static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
-{
-    return shared_ptr<_Tp>(__r,
-                           static_cast<
-                               typename shared_ptr<_Tp>::element_type*>(__r.get()));
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
+  return shared_ptr<_Tp>(__r, static_cast< typename shared_ptr<_Tp>::element_type*>(__r.get()));
 }
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-shared_ptr<_Tp>
-dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
-{
-    typedef typename shared_ptr<_Tp>::element_type _ET;
-    _ET* __p = dynamic_cast<_ET*>(__r.get());
-    return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();
+// LWG-2996
+// We don't backport because it is an evolutionary change.
+#if _LIBCPP_STD_VER >= 20
+template <class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> static_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
+  return shared_ptr<_Tp>(std::move(__r), static_cast<typename shared_ptr<_Tp>::element_type*>(__r.get()));
+}
+#endif
+
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
+  typedef typename shared_ptr<_Tp>::element_type _ET;
+  _ET* __p = dynamic_cast<_ET*>(__r.get());
+  return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();
 }
 
-template<class _Tp, class _Up>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
-const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
-{
-    typedef typename shared_ptr<_Tp>::element_type _RTp;
-    return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
+// LWG-2996
+// We don't backport because it is an evolutionary change.
+#if _LIBCPP_STD_VER >= 20
+template <class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
+  auto* __p = dynamic_cast<typename shared_ptr<_Tp>::element_type*>(__r.get());
+  return __p ? shared_ptr<_Tp>(std::move(__r), __p) : shared_ptr<_Tp>();
+}
+#endif
+
+template <class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
+  typedef typename shared_ptr<_Tp>::element_type _RTp;
+  return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
 }
 
-template<class _Tp, class _Up>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
-reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT
-{
-    return shared_ptr<_Tp>(__r,
-                           reinterpret_cast<
-                               typename shared_ptr<_Tp>::element_type*>(__r.get()));
+// LWG-2996
+// We don't backport because it is an evolutionary change.
+#if _LIBCPP_STD_VER >= 20
+template <class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
+  return shared_ptr<_Tp>(std::move(__r), const_cast<typename shared_ptr<_Tp>::element_type*>(__r.get()));
 }
+#endif
+
+template <class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
+  return shared_ptr<_Tp>(__r, reinterpret_cast< typename shared_ptr<_Tp>::element_type*>(__r.get()));
+}
+
+// LWG-2996
+// We don't backport because it is an evolutionary change.
+#if _LIBCPP_STD_VER >= 20
+template <class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
+  return shared_ptr<_Tp>(std::move(__r), reinterpret_cast<typename shared_ptr<_Tp>::element_type*>(__r.get()));
+}
+#endif
 
 #ifndef _LIBCPP_HAS_NO_RTTI
 
-template<class _Dp, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Dp*
-get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT
-{
-    return __p.template __get_deleter<_Dp>();
+template <class _Dp, class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _Dp* get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT {
+  return __p.template __get_deleter<_Dp>();
 }
 
 #endif // _LIBCPP_HAS_NO_RTTI
 
-template<class _Tp>
-class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS weak_ptr
-{
+template <class _Tp>
+class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS weak_ptr {
 public:
 #if _LIBCPP_STD_VER >= 17
-    typedef remove_extent_t<_Tp> element_type;
+  typedef remove_extent_t<_Tp> element_type;
 #else
-    typedef _Tp element_type;
+  typedef _Tp element_type;
 #endif
 
+  // A weak_ptr contains only two raw pointers which point to the heap and move constructing already doesn't require
+  // any bookkeeping, so it's always trivially relocatable.
+  using __trivially_relocatable = weak_ptr;
+
 private:
-    element_type*        __ptr_;
-    __shared_weak_count* __cntrl_;
+  element_type* __ptr_;
+  __shared_weak_count* __cntrl_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT;
-    template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(shared_ptr<_Yp> const& __r,
-                   typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0)
-                        _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    weak_ptr(weak_ptr const& __r) _NOEXCEPT;
-    template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp> const& __r,
-                   typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0)
-                         _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    weak_ptr(weak_ptr&& __r) _NOEXCEPT;
-    template<class _Yp> _LIBCPP_INLINE_VISIBILITY weak_ptr(weak_ptr<_Yp>&& __r,
-                   typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type = 0)
-                         _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI ~weak_ptr();
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI weak_ptr(shared_ptr<_Yp> const& __r) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
-    template<class _Yp>
-        typename enable_if
-        <
-            __compatible_with<_Yp, _Tp>::value,
-            weak_ptr&
-        >::type
-        _LIBCPP_INLINE_VISIBILITY
-        operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI weak_ptr(weak_ptr const& __r) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT;
-    template<class _Yp>
-        typename enable_if
-        <
-            __compatible_with<_Yp, _Tp>::value,
-            weak_ptr&
-        >::type
-        _LIBCPP_INLINE_VISIBILITY
-        operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI weak_ptr(weak_ptr<_Yp> const& __r) _NOEXCEPT;
 
-    template<class _Yp>
-        typename enable_if
-        <
-            __compatible_with<_Yp, _Tp>::value,
-            weak_ptr&
-        >::type
-        _LIBCPP_INLINE_VISIBILITY
-        operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI weak_ptr(weak_ptr&& __r) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(weak_ptr& __r) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() _NOEXCEPT;
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI weak_ptr(weak_ptr<_Yp>&& __r) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    long use_count() const _NOEXCEPT
-        {return __cntrl_ ? __cntrl_->use_count() : 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    bool expired() const _NOEXCEPT
-        {return __cntrl_ == nullptr || __cntrl_->use_count() == 0;}
-    _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> lock() const _NOEXCEPT;
-    template<class _Up>
-        _LIBCPP_INLINE_VISIBILITY
-        bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT
-        {return __cntrl_ < __r.__cntrl_;}
-    template<class _Up>
-        _LIBCPP_INLINE_VISIBILITY
-        bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT
-        {return __cntrl_ < __r.__cntrl_;}
+  _LIBCPP_HIDE_FROM_ABI ~weak_ptr();
 
-    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
-    template <class _Up> friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
+  _LIBCPP_HIDE_FROM_ABI weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI weak_ptr& operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT;
+
+  _LIBCPP_HIDE_FROM_ABI weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT;
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI weak_ptr& operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;
+
+  template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI weak_ptr& operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;
+
+  _LIBCPP_HIDE_FROM_ABI void swap(weak_ptr& __r) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void reset() _NOEXCEPT;
+
+  _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __cntrl_ ? __cntrl_->use_count() : 0; }
+  _LIBCPP_HIDE_FROM_ABI bool expired() const _NOEXCEPT { return __cntrl_ == nullptr || __cntrl_->use_count() == 0; }
+  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> lock() const _NOEXCEPT;
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT {
+    return __cntrl_ < __r.__cntrl_;
+  }
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT {
+    return __cntrl_ < __r.__cntrl_;
+  }
+
+  template <class _Up>
+  friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
+  template <class _Up>
+  friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _Tp>
+template <class _Tp>
 weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;
 #endif
 
-template<class _Tp>
-inline
-_LIBCPP_CONSTEXPR
-weak_ptr<_Tp>::weak_ptr() _NOEXCEPT
-    : __ptr_(nullptr),
-      __cntrl_(nullptr)
-{
+template <class _Tp>
+inline _LIBCPP_CONSTEXPR weak_ptr<_Tp>::weak_ptr() _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) {}
+
+template <class _Tp>
+inline weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
+  if (__cntrl_)
+    __cntrl_->__add_weak();
 }
 
-template<class _Tp>
-inline
-weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT
-    : __ptr_(__r.__ptr_),
-      __cntrl_(__r.__cntrl_)
-{
-    if (__cntrl_)
-        __cntrl_->__add_weak();
+template <class _Tp>
+template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
+inline weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
+  if (__cntrl_)
+    __cntrl_->__add_weak();
 }
 
-template<class _Tp>
-template<class _Yp>
-inline
-weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r,
-                        typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type)
-                         _NOEXCEPT
-    : __ptr_(__r.__ptr_),
-      __cntrl_(__r.__cntrl_)
-{
-    if (__cntrl_)
-        __cntrl_->__add_weak();
+template <class _Tp>
+template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
+inline weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r) _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) {
+  shared_ptr<_Yp> __s = __r.lock();
+  *this               = weak_ptr<_Tp>(__s);
 }
 
-template<class _Tp>
-template<class _Yp>
-inline
-weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r,
-                        typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type)
-         _NOEXCEPT
-    : __ptr_(__r.__ptr_),
-      __cntrl_(__r.__cntrl_)
-{
-    if (__cntrl_)
-        __cntrl_->__add_weak();
+template <class _Tp>
+inline weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
+  __r.__ptr_   = nullptr;
+  __r.__cntrl_ = nullptr;
 }
 
-template<class _Tp>
-inline
-weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT
-    : __ptr_(__r.__ptr_),
-      __cntrl_(__r.__cntrl_)
-{
-    __r.__ptr_ = nullptr;
-    __r.__cntrl_ = nullptr;
+template <class _Tp>
+template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
+inline weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r) _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) {
+  shared_ptr<_Yp> __s = __r.lock();
+  *this               = weak_ptr<_Tp>(__s);
+  __r.reset();
 }
 
-template<class _Tp>
-template<class _Yp>
-inline
-weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r,
-                        typename enable_if<__compatible_with<_Yp, _Tp>::value, __nat*>::type)
-         _NOEXCEPT
-    : __ptr_(__r.__ptr_),
-      __cntrl_(__r.__cntrl_)
-{
-    __r.__ptr_ = nullptr;
-    __r.__cntrl_ = nullptr;
+template <class _Tp>
+weak_ptr<_Tp>::~weak_ptr() {
+  if (__cntrl_)
+    __cntrl_->__release_weak();
 }
 
-template<class _Tp>
-weak_ptr<_Tp>::~weak_ptr()
-{
-    if (__cntrl_)
-        __cntrl_->__release_weak();
+template <class _Tp>
+inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT {
+  weak_ptr(__r).swap(*this);
+  return *this;
 }
 
-template<class _Tp>
-inline
-weak_ptr<_Tp>&
-weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT
-{
-    weak_ptr(__r).swap(*this);
-    return *this;
+template <class _Tp>
+template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
+inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT {
+  weak_ptr(__r).swap(*this);
+  return *this;
 }
 
-template<class _Tp>
-template<class _Yp>
-inline
-typename enable_if
-<
-    __compatible_with<_Yp, _Tp>::value,
-    weak_ptr<_Tp>&
->::type
-weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT
-{
-    weak_ptr(__r).swap(*this);
-    return *this;
+template <class _Tp>
+inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT {
+  weak_ptr(std::move(__r)).swap(*this);
+  return *this;
 }
 
-template<class _Tp>
-inline
-weak_ptr<_Tp>&
-weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT
-{
-    weak_ptr(_VSTD::move(__r)).swap(*this);
-    return *this;
+template <class _Tp>
+template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
+inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT {
+  weak_ptr(std::move(__r)).swap(*this);
+  return *this;
 }
 
-template<class _Tp>
-template<class _Yp>
-inline
-typename enable_if
-<
-    __compatible_with<_Yp, _Tp>::value,
-    weak_ptr<_Tp>&
->::type
-weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT
-{
-    weak_ptr(_VSTD::move(__r)).swap(*this);
-    return *this;
+template <class _Tp>
+template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
+inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT {
+  weak_ptr(__r).swap(*this);
+  return *this;
 }
 
-template<class _Tp>
-template<class _Yp>
-inline
-typename enable_if
-<
-    __compatible_with<_Yp, _Tp>::value,
-    weak_ptr<_Tp>&
->::type
-weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT
-{
-    weak_ptr(__r).swap(*this);
-    return *this;
+template <class _Tp>
+inline void weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT {
+  std::swap(__ptr_, __r.__ptr_);
+  std::swap(__cntrl_, __r.__cntrl_);
 }
 
-template<class _Tp>
-inline
-void
-weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT
-{
-    _VSTD::swap(__ptr_, __r.__ptr_);
-    _VSTD::swap(__cntrl_, __r.__cntrl_);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI void swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT {
+  __x.swap(__y);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT
-{
-    __x.swap(__y);
+template <class _Tp>
+inline void weak_ptr<_Tp>::reset() _NOEXCEPT {
+  weak_ptr().swap(*this);
 }
 
-template<class _Tp>
-inline
-void
-weak_ptr<_Tp>::reset() _NOEXCEPT
-{
-    weak_ptr().swap(*this);
-}
-
-template<class _Tp>
-shared_ptr<_Tp>
-weak_ptr<_Tp>::lock() const _NOEXCEPT
-{
-    shared_ptr<_Tp> __r;
-    __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;
-    if (__r.__cntrl_)
-        __r.__ptr_ = __ptr_;
-    return __r;
+template <class _Tp>
+shared_ptr<_Tp> weak_ptr<_Tp>::lock() const _NOEXCEPT {
+  shared_ptr<_Tp> __r;
+  __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;
+  if (__r.__cntrl_)
+    __r.__ptr_ = __ptr_;
+  return __r;
 }
 
 #if _LIBCPP_STD_VER >= 17
-template <class _Tp = void> struct owner_less;
+template <class _Tp = void>
+struct owner_less;
 #else
-template <class _Tp> struct owner_less;
+template <class _Tp>
+struct owner_less;
 #endif
 
-
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> >
-    : __binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
-        {return __x.owner_before(__y);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(shared_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPT
-        {return __x.owner_before(__y);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(  weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
-        {return __x.owner_before(__y);}
+struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> > : __binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool> {
+  _LIBCPP_HIDE_FROM_ABI bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT {
+    return __x.owner_before(__y);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT {
+    return __x.owner_before(__y);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT {
+    return __x.owner_before(__y);
+  }
 };
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> >
-    : __binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(  weak_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPT
-        {return __x.owner_before(__y);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(shared_ptr<_Tp> const& __x,   weak_ptr<_Tp> const& __y) const _NOEXCEPT
-        {return __x.owner_before(__y);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(  weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT
-        {return __x.owner_before(__y);}
+struct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> > : __binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool> {
+  _LIBCPP_HIDE_FROM_ABI bool operator()(weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT {
+    return __x.owner_before(__y);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT {
+    return __x.owner_before(__y);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT {
+    return __x.owner_before(__y);
+  }
 };
 
 #if _LIBCPP_STD_VER >= 17
 template <>
-struct _LIBCPP_TEMPLATE_VIS owner_less<void>
-{
-    template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()( shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT
-        {return __x.owner_before(__y);}
-    template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()( shared_ptr<_Tp> const& __x,   weak_ptr<_Up> const& __y) const _NOEXCEPT
-        {return __x.owner_before(__y);}
-    template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(   weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT
-        {return __x.owner_before(__y);}
-    template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(   weak_ptr<_Tp> const& __x,   weak_ptr<_Up> const& __y) const _NOEXCEPT
-        {return __x.owner_before(__y);}
-    typedef void is_transparent;
+struct _LIBCPP_TEMPLATE_VIS owner_less<void> {
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT {
+    return __x.owner_before(__y);
+  }
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT {
+    return __x.owner_before(__y);
+  }
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT {
+    return __x.owner_before(__y);
+  }
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(weak_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT {
+    return __x.owner_before(__y);
+  }
+  typedef void is_transparent;
 };
 #endif
 
-template<class _Tp>
-class _LIBCPP_TEMPLATE_VIS enable_shared_from_this
-{
-    mutable weak_ptr<_Tp> __weak_this_;
-protected:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    enable_shared_from_this() _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY
-    enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY
-    enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPT
-        {return *this;}
-    _LIBCPP_INLINE_VISIBILITY
-    ~enable_shared_from_this() {}
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    shared_ptr<_Tp> shared_from_this()
-        {return shared_ptr<_Tp>(__weak_this_);}
-    _LIBCPP_INLINE_VISIBILITY
-    shared_ptr<_Tp const> shared_from_this() const
-        {return shared_ptr<const _Tp>(__weak_this_);}
-
-#if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
-    weak_ptr<_Tp> weak_from_this() _NOEXCEPT
-       { return __weak_this_; }
-
-    _LIBCPP_INLINE_VISIBILITY
-    weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT
-        { return __weak_this_; }
-#endif // _LIBCPP_STD_VER >= 17
-
-    template <class _Up> friend class shared_ptr;
-};
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;
-
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> >
-{
-#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> argument_type;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t          result_type;
-#endif
+class _LIBCPP_TEMPLATE_VIS enable_shared_from_this {
+  mutable weak_ptr<_Tp> __weak_this_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const shared_ptr<_Tp>& __ptr) const _NOEXCEPT
-    {
-        return hash<typename shared_ptr<_Tp>::element_type*>()(__ptr.get());
-    }
+protected:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR enable_shared_from_this() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPT { return *this; }
+  _LIBCPP_HIDE_FROM_ABI ~enable_shared_from_this() {}
+
+public:
+  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> shared_from_this() { return shared_ptr<_Tp>(__weak_this_); }
+  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp const> shared_from_this() const { return shared_ptr<const _Tp>(__weak_this_); }
+
+#if _LIBCPP_STD_VER >= 17
+  _LIBCPP_HIDE_FROM_ABI weak_ptr<_Tp> weak_from_this() _NOEXCEPT { return __weak_this_; }
+
+  _LIBCPP_HIDE_FROM_ABI weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT { return __weak_this_; }
+#endif // _LIBCPP_STD_VER >= 17
+
+  template <class _Up>
+  friend class shared_ptr;
 };
 
-template<class _CharT, class _Traits, class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS hash;
 
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> > {
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> argument_type;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const shared_ptr<_Tp>& __ptr) const _NOEXCEPT {
+    return hash<typename shared_ptr<_Tp>::element_type*>()(__ptr.get());
+  }
+};
+
+template <class _CharT, class _Traits, class _Yp>
+inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
 
 #if !defined(_LIBCPP_HAS_NO_THREADS)
 
-class _LIBCPP_TYPE_VIS __sp_mut
-{
-    void* __lx_;
+class _LIBCPP_EXPORTED_FROM_ABI __sp_mut {
+  void* __lx_;
+
 public:
-    void lock() _NOEXCEPT;
-    void unlock() _NOEXCEPT;
+  void lock() _NOEXCEPT;
+  void unlock() _NOEXCEPT;
 
 private:
-    _LIBCPP_CONSTEXPR __sp_mut(void*) _NOEXCEPT;
-    __sp_mut(const __sp_mut&);
-    __sp_mut& operator=(const __sp_mut&);
+  _LIBCPP_CONSTEXPR __sp_mut(void*) _NOEXCEPT;
+  __sp_mut(const __sp_mut&);
+  __sp_mut& operator=(const __sp_mut&);
 
-    friend _LIBCPP_FUNC_VIS __sp_mut& __get_sp_mut(const void*);
+  friend _LIBCPP_EXPORTED_FROM_ABI __sp_mut& __get_sp_mut(const void*);
 };
 
-_LIBCPP_FUNC_VIS _LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-__sp_mut& __get_sp_mut(const void*);
+_LIBCPP_EXPORTED_FROM_ABI __sp_mut& __get_sp_mut(const void*);
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-atomic_is_lock_free(const shared_ptr<_Tp>*)
-{
-    return false;
+inline _LIBCPP_HIDE_FROM_ABI bool atomic_is_lock_free(const shared_ptr<_Tp>*) {
+  return false;
 }
 
 template <class _Tp>
-_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
-atomic_load(const shared_ptr<_Tp>* __p)
-{
-    __sp_mut& __m = std::__get_sp_mut(__p);
-    __m.lock();
-    shared_ptr<_Tp> __q = *__p;
-    __m.unlock();
-    return __q;
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> atomic_load(const shared_ptr<_Tp>* __p) {
+  __sp_mut& __m = std::__get_sp_mut(__p);
+  __m.lock();
+  shared_ptr<_Tp> __q = *__p;
+  __m.unlock();
+  return __q;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-shared_ptr<_Tp>
-atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
-{
-    return std::atomic_load(__p);
+inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) {
+  return std::atomic_load(__p);
 }
 
 template <class _Tp>
-_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-_LIBCPP_HIDE_FROM_ABI void
-atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
-{
-    __sp_mut& __m = std::__get_sp_mut(__p);
-    __m.lock();
-    __p->swap(__r);
-    __m.unlock();
+_LIBCPP_HIDE_FROM_ABI void atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) {
+  __sp_mut& __m = std::__get_sp_mut(__p);
+  __m.lock();
+  __p->swap(__r);
+  __m.unlock();
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-void
-atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
-{
-    std::atomic_store(__p, __r);
+inline _LIBCPP_HIDE_FROM_ABI void atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) {
+  std::atomic_store(__p, __r);
 }
 
 template <class _Tp>
-_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
-atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
-{
-    __sp_mut& __m = std::__get_sp_mut(__p);
-    __m.lock();
-    __p->swap(__r);
-    __m.unlock();
-    return __r;
+_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) {
+  __sp_mut& __m = std::__get_sp_mut(__p);
+  __m.lock();
+  __p->swap(__r);
+  __m.unlock();
+  return __r;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-shared_ptr<_Tp>
-atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order)
-{
-    return std::atomic_exchange(__p, __r);
+inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
+atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) {
+  return std::atomic_exchange(__p, __r);
 }
 
 template <class _Tp>
-_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
 _LIBCPP_HIDE_FROM_ABI bool
-atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
-{
-    shared_ptr<_Tp> __temp;
-    __sp_mut& __m = std::__get_sp_mut(__p);
-    __m.lock();
-    if (__p->__owner_equivalent(*__v))
-    {
-        _VSTD::swap(__temp, *__p);
-        *__p = __w;
-        __m.unlock();
-        return true;
-    }
-    _VSTD::swap(__temp, *__v);
-    *__v = *__p;
+atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) {
+  shared_ptr<_Tp> __temp;
+  __sp_mut& __m = std::__get_sp_mut(__p);
+  __m.lock();
+  if (__p->__owner_equivalent(*__v)) {
+    std::swap(__temp, *__p);
+    *__p = __w;
     __m.unlock();
-    return false;
+    return true;
+  }
+  std::swap(__temp, *__v);
+  *__v = *__p;
+  __m.unlock();
+  return false;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-bool
-atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w)
-{
-    return std::atomic_compare_exchange_strong(__p, __v, __w);
+inline _LIBCPP_HIDE_FROM_ABI bool
+atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) {
+  return std::atomic_compare_exchange_strong(__p, __v, __w);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-bool
-atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
-                                        shared_ptr<_Tp> __w, memory_order, memory_order)
-{
-    return std::atomic_compare_exchange_strong(__p, __v, __w);
+inline _LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_strong_explicit(
+    shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w, memory_order, memory_order) {
+  return std::atomic_compare_exchange_strong(__p, __v, __w);
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_ATOMIC_SHARED_PTR
-bool
-atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
-                                      shared_ptr<_Tp> __w, memory_order, memory_order)
-{
-    return std::atomic_compare_exchange_weak(__p, __v, __w);
+inline _LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_weak_explicit(
+    shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w, memory_order, memory_order) {
+  return std::atomic_compare_exchange_weak(__p, __v, __w);
 }
 
 #endif // !defined(_LIBCPP_HAS_NO_THREADS)
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_SHARED_PTR_H
diff --git a/third_party/libcxx/__memory/swap_allocator.h b/third_party/libcxx/__memory/swap_allocator.h
index 90851cb79..b17e082a4 100644
--- a/third_party/libcxx/__memory/swap_allocator.h
+++ b/third_party/libcxx/__memory/swap_allocator.h
@@ -26,10 +26,10 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __swap_allocator(_Alloc
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
-    _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
+    _NOEXCEPT_(__is_nothrow_swappable_v<_Alloc>)
 #endif
 {
-  using _VSTD::swap;
+  using std::swap;
   swap(__a1, __a2);
 }
 
@@ -42,10 +42,10 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __swap_allocator
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
-    _NOEXCEPT_(__is_nothrow_swappable<_Alloc>::value)
+    _NOEXCEPT_(__is_nothrow_swappable_v<_Alloc>)
 #endif
 {
-  _VSTD::__swap_allocator(
+  std::__swap_allocator(
       __a1, __a2, integral_constant<bool, allocator_traits<_Alloc>::propagate_on_container_swap::value>());
 }
 
diff --git a/third_party/libcxx/__memory/temp_value.h b/third_party/libcxx/__memory/temp_value.h
index 3ce8b4bcb..4a133b3fb 100644
--- a/third_party/libcxx/__memory/temp_value.h
+++ b/third_party/libcxx/__memory/temp_value.h
@@ -23,32 +23,34 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Alloc>
 struct __temp_value {
-    typedef allocator_traits<_Alloc> _Traits;
+  typedef allocator_traits<_Alloc> _Traits;
 
 #ifdef _LIBCPP_CXX03_LANG
-    typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
+  typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;
 #else
-    union { _Tp __v; };
+  union {
+    _Tp __v;
+  };
 #endif
-    _Alloc &__a;
+  _Alloc& __a;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp *__addr() {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp* __addr() {
 #ifdef _LIBCPP_CXX03_LANG
-        return reinterpret_cast<_Tp*>(std::addressof(__v));
+    return reinterpret_cast<_Tp*>(std::addressof(__v));
 #else
-        return std::addressof(__v);
+    return std::addressof(__v);
 #endif
-    }
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp & get() { return *__addr(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& get() { return *__addr(); }
 
-    template<class... _Args>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 __temp_value(_Alloc &__alloc, _Args&& ... __args) : __a(__alloc) {
-      _Traits::construct(__a, __addr(), std::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI _LIBCPP_CONSTEXPR_SINCE_CXX20 __temp_value(_Alloc& __alloc, _Args&&... __args)
+      : __a(__alloc) {
+    _Traits::construct(__a, __addr(), std::forward<_Args>(__args)...);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__temp_value() { _Traits::destroy(__a, __addr()); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__temp_value() { _Traits::destroy(__a, __addr()); }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__memory/temporary_buffer.h b/third_party/libcxx/__memory/temporary_buffer.h
index c917f041a..88799ca95 100644
--- a/third_party/libcxx/__memory/temporary_buffer.h
+++ b/third_party/libcxx/__memory/temporary_buffer.h
@@ -11,7 +11,6 @@
 #define _LIBCPP___MEMORY_TEMPORARY_BUFFER_H
 
 #include <__config>
-#include <__type_traits/alignment_of.h>
 #include <__utility/pair.h>
 #include <cstddef>
 #include <new>
@@ -23,63 +22,52 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI _LIBCPP_DEPRECATED_IN_CXX17
-pair<_Tp*, ptrdiff_t>
-get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT
-{
-    pair<_Tp*, ptrdiff_t> __r(0, 0);
-    const ptrdiff_t __m = (~ptrdiff_t(0) ^
-                           ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1)))
-                           / sizeof(_Tp);
-    if (__n > __m)
-        __n = __m;
-    while (__n > 0)
-    {
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI _LIBCPP_DEPRECATED_IN_CXX17 pair<_Tp*, ptrdiff_t>
+get_temporary_buffer(ptrdiff_t __n) _NOEXCEPT {
+  pair<_Tp*, ptrdiff_t> __r(0, 0);
+  const ptrdiff_t __m =
+      (~ptrdiff_t(0) ^ ptrdiff_t(ptrdiff_t(1) << (sizeof(ptrdiff_t) * __CHAR_BIT__ - 1))) / sizeof(_Tp);
+  if (__n > __m)
+    __n = __m;
+  while (__n > 0) {
 #if !defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
-    if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp)))
-        {
-            align_val_t __al =
-                align_val_t(alignment_of<_Tp>::value);
-            __r.first = static_cast<_Tp*>(::operator new(
-                __n * sizeof(_Tp), __al, nothrow));
-        } else {
-            __r.first = static_cast<_Tp*>(::operator new(
-                __n * sizeof(_Tp), nothrow));
-        }
+    if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp))) {
+      align_val_t __al = align_val_t(_LIBCPP_ALIGNOF(_Tp));
+      __r.first        = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), __al, nothrow));
+    } else {
+      __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), nothrow));
+    }
 #else
-    if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp)))
-        {
-            // Since aligned operator new is unavailable, return an empty
-            // buffer rather than one with invalid alignment.
-            return __r;
-        }
+    if (__is_overaligned_for_new(_LIBCPP_ALIGNOF(_Tp))) {
+      // Since aligned operator new is unavailable, return an empty
+      // buffer rather than one with invalid alignment.
+      return __r;
+    }
 
-        __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), nothrow));
+    __r.first = static_cast<_Tp*>(::operator new(__n * sizeof(_Tp), nothrow));
 #endif
 
-        if (__r.first)
-        {
-            __r.second = __n;
-            break;
-        }
-        __n /= 2;
+    if (__r.first) {
+      __r.second = __n;
+      break;
     }
-    return __r;
+    __n /= 2;
+  }
+  return __r;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
-void return_temporary_buffer(_Tp* __p) _NOEXCEPT
-{
-  _VSTD::__libcpp_deallocate_unsized((void*)__p, _LIBCPP_ALIGNOF(_Tp));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_IN_CXX17 void return_temporary_buffer(_Tp* __p) _NOEXCEPT {
+  std::__libcpp_deallocate_unsized((void*)__p, _LIBCPP_ALIGNOF(_Tp));
 }
 
-struct __return_temporary_buffer
-{
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+struct __return_temporary_buffer {
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI void operator()(_Tp* __p) const {
+    std::return_temporary_buffer(__p);
+  }
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__memory/uninitialized_algorithms.h b/third_party/libcxx/__memory/uninitialized_algorithms.h
index c02803330..7475ef5cf 100644
--- a/third_party/libcxx/__memory/uninitialized_algorithms.h
+++ b/third_party/libcxx/__memory/uninitialized_algorithms.h
@@ -25,10 +25,9 @@
 #include <__type_traits/extent.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_constant_evaluated.h>
-#include <__type_traits/is_trivially_copy_assignable.h>
-#include <__type_traits/is_trivially_copy_constructible.h>
-#include <__type_traits/is_trivially_move_assignable.h>
-#include <__type_traits/is_trivially_move_constructible.h>
+#include <__type_traits/is_trivially_assignable.h>
+#include <__type_traits/is_trivially_constructible.h>
+#include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/is_unbounded_array.h>
 #include <__type_traits/negation.h>
 #include <__type_traits/remove_const.h>
@@ -42,144 +41,132 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-// This is a simplified version of C++20 `unreachable_sentinel` that doesn't use concepts and thus can be used in any
-// language mode.
-struct __unreachable_sentinel {
-  template <class _Iter>
-  _LIBCPP_HIDE_FROM_ABI friend _LIBCPP_CONSTEXPR bool operator!=(const _Iter&, __unreachable_sentinel) _NOEXCEPT {
-    return true;
+struct __always_false {
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator()(_Args&&...) const _NOEXCEPT {
+    return false;
   }
 };
 
 // uninitialized_copy
 
-template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2>
-inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
-__uninitialized_copy(_InputIterator __ifirst, _Sentinel1 __ilast,
-                     _ForwardIterator __ofirst, _Sentinel2 __olast) {
+template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _EndPredicate>
+inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> __uninitialized_copy(
+    _InputIterator __ifirst, _Sentinel1 __ilast, _ForwardIterator __ofirst, _EndPredicate __stop_copying) {
   _ForwardIterator __idx = __ofirst;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
 #endif
-    for (; __ifirst != __ilast && __idx != __olast; ++__ifirst, (void)++__idx)
-      ::new (_VSTD::__voidify(*__idx)) _ValueType(*__ifirst);
+    for (; __ifirst != __ilast && !__stop_copying(__idx); ++__ifirst, (void)++__idx)
+      ::new (std::__voidify(*__idx)) _ValueType(*__ifirst);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   } catch (...) {
-    _VSTD::__destroy(__ofirst, __idx);
+    std::__destroy(__ofirst, __idx);
     throw;
   }
 #endif
 
-  return pair<_InputIterator, _ForwardIterator>(_VSTD::move(__ifirst), _VSTD::move(__idx));
+  return pair<_InputIterator, _ForwardIterator>(std::move(__ifirst), std::move(__idx));
 }
 
 template <class _InputIterator, class _ForwardIterator>
-_LIBCPP_HIDE_FROM_ABI
-_ForwardIterator uninitialized_copy(_InputIterator __ifirst, _InputIterator __ilast,
-                                    _ForwardIterator __ofirst) {
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator
+uninitialized_copy(_InputIterator __ifirst, _InputIterator __ilast, _ForwardIterator __ofirst) {
   typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  auto __result = _VSTD::__uninitialized_copy<_ValueType>(_VSTD::move(__ifirst), _VSTD::move(__ilast),
-                                                          _VSTD::move(__ofirst), __unreachable_sentinel());
-  return _VSTD::move(__result.second);
+  auto __result = std::__uninitialized_copy<_ValueType>(
+      std::move(__ifirst), std::move(__ilast), std::move(__ofirst), __always_false());
+  return std::move(__result.second);
 }
 
 // uninitialized_copy_n
 
-template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel>
+template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _EndPredicate>
 inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
-__uninitialized_copy_n(_InputIterator __ifirst, _Size __n,
-                       _ForwardIterator __ofirst, _Sentinel __olast) {
+__uninitialized_copy_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst, _EndPredicate __stop_copying) {
   _ForwardIterator __idx = __ofirst;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
 #endif
-    for (; __n > 0 && __idx != __olast; ++__ifirst, (void)++__idx, (void)--__n)
-      ::new (_VSTD::__voidify(*__idx)) _ValueType(*__ifirst);
+    for (; __n > 0 && !__stop_copying(__idx); ++__ifirst, (void)++__idx, (void)--__n)
+      ::new (std::__voidify(*__idx)) _ValueType(*__ifirst);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   } catch (...) {
-    _VSTD::__destroy(__ofirst, __idx);
+    std::__destroy(__ofirst, __idx);
     throw;
   }
 #endif
 
-  return pair<_InputIterator, _ForwardIterator>(_VSTD::move(__ifirst), _VSTD::move(__idx));
+  return pair<_InputIterator, _ForwardIterator>(std::move(__ifirst), std::move(__idx));
 }
 
 template <class _InputIterator, class _Size, class _ForwardIterator>
-inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_copy_n(_InputIterator __ifirst, _Size __n,
-                                                                   _ForwardIterator __ofirst) {
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+uninitialized_copy_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst) {
   typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  auto __result = _VSTD::__uninitialized_copy_n<_ValueType>(_VSTD::move(__ifirst), __n, _VSTD::move(__ofirst),
-                                                            __unreachable_sentinel());
-  return _VSTD::move(__result.second);
+  auto __result =
+      std::__uninitialized_copy_n<_ValueType>(std::move(__ifirst), __n, std::move(__ofirst), __always_false());
+  return std::move(__result.second);
 }
 
 // uninitialized_fill
 
 template <class _ValueType, class _ForwardIterator, class _Sentinel, class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI
-_ForwardIterator __uninitialized_fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __x)
-{
-    _ForwardIterator __idx = __first;
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+__uninitialized_fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __x) {
+  _ForwardIterator __idx = __first;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
+  try {
 #endif
-        for (; __idx != __last; ++__idx)
-            ::new (_VSTD::__voidify(*__idx)) _ValueType(__x);
+    for (; __idx != __last; ++__idx)
+      ::new (std::__voidify(*__idx)) _ValueType(__x);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        _VSTD::__destroy(__first, __idx);
-        throw;
-    }
+  } catch (...) {
+    std::__destroy(__first, __idx);
+    throw;
+  }
 #endif
 
-    return __idx;
+  return __idx;
 }
 
 template <class _ForwardIterator, class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI
-void uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x)
-{
-    typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-    (void)_VSTD::__uninitialized_fill<_ValueType>(__first, __last, __x);
+inline _LIBCPP_HIDE_FROM_ABI void
+uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __x) {
+  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+  (void)std::__uninitialized_fill<_ValueType>(__first, __last, __x);
 }
 
 // uninitialized_fill_n
 
 template <class _ValueType, class _ForwardIterator, class _Size, class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI
-_ForwardIterator __uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
-{
-    _ForwardIterator __idx = __first;
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+__uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) {
+  _ForwardIterator __idx = __first;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
+  try {
 #endif
-        for (; __n > 0; ++__idx, (void) --__n)
-            ::new (_VSTD::__voidify(*__idx)) _ValueType(__x);
+    for (; __n > 0; ++__idx, (void)--__n)
+      ::new (std::__voidify(*__idx)) _ValueType(__x);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        _VSTD::__destroy(__first, __idx);
-        throw;
-    }
+  } catch (...) {
+    std::__destroy(__first, __idx);
+    throw;
+  }
 #endif
 
-    return __idx;
+  return __idx;
 }
 
 template <class _ForwardIterator, class _Size, class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI
-_ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
-{
-    typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-    return _VSTD::__uninitialized_fill_n<_ValueType>(__first, __n, __x);
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) {
+  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
+  return std::__uninitialized_fill_n<_ValueType>(__first, __n, __x);
 }
 
 #if _LIBCPP_STD_VER >= 17
@@ -187,182 +174,185 @@ _ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const
 // uninitialized_default_construct
 
 template <class _ValueType, class _ForwardIterator, class _Sentinel>
-inline _LIBCPP_HIDE_FROM_ABI
-_ForwardIterator __uninitialized_default_construct(_ForwardIterator __first, _Sentinel __last) {
-    auto __idx = __first;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try {
-#endif
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+__uninitialized_default_construct(_ForwardIterator __first, _Sentinel __last) {
+  auto __idx = __first;
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif
     for (; __idx != __last; ++__idx)
-        ::new (_VSTD::__voidify(*__idx)) _ValueType;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    } catch (...) {
-        _VSTD::__destroy(__first, __idx);
-        throw;
-    }
-#endif
+      ::new (std::__voidify(*__idx)) _ValueType;
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    std::__destroy(__first, __idx);
+    throw;
+  }
+#  endif
 
-    return __idx;
+  return __idx;
 }
 
 template <class _ForwardIterator>
-inline _LIBCPP_HIDE_FROM_ABI
-void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) {
-    using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
-    (void)_VSTD::__uninitialized_default_construct<_ValueType>(
-        _VSTD::move(__first), _VSTD::move(__last));
+inline _LIBCPP_HIDE_FROM_ABI void uninitialized_default_construct(_ForwardIterator __first, _ForwardIterator __last) {
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  (void)std::__uninitialized_default_construct<_ValueType>(std::move(__first), std::move(__last));
 }
 
 // uninitialized_default_construct_n
 
 template <class _ValueType, class _ForwardIterator, class _Size>
-inline _LIBCPP_HIDE_FROM_ABI
-_ForwardIterator __uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
-    auto __idx = __first;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try {
-#endif
-    for (; __n > 0; ++__idx, (void) --__n)
-        ::new (_VSTD::__voidify(*__idx)) _ValueType;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    } catch (...) {
-        _VSTD::__destroy(__first, __idx);
-        throw;
-    }
-#endif
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator __uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
+  auto __idx = __first;
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif
+    for (; __n > 0; ++__idx, (void)--__n)
+      ::new (std::__voidify(*__idx)) _ValueType;
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    std::__destroy(__first, __idx);
+    throw;
+  }
+#  endif
 
-    return __idx;
+  return __idx;
 }
 
 template <class _ForwardIterator, class _Size>
-inline _LIBCPP_HIDE_FROM_ABI
-_ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
-    using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
-    return _VSTD::__uninitialized_default_construct_n<_ValueType>(_VSTD::move(__first), __n);
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  return std::__uninitialized_default_construct_n<_ValueType>(std::move(__first), __n);
 }
 
 // uninitialized_value_construct
 
 template <class _ValueType, class _ForwardIterator, class _Sentinel>
-inline _LIBCPP_HIDE_FROM_ABI
-_ForwardIterator __uninitialized_value_construct(_ForwardIterator __first, _Sentinel __last) {
-    auto __idx = __first;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try {
-#endif
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+__uninitialized_value_construct(_ForwardIterator __first, _Sentinel __last) {
+  auto __idx = __first;
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif
     for (; __idx != __last; ++__idx)
-        ::new (_VSTD::__voidify(*__idx)) _ValueType();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    } catch (...) {
-        _VSTD::__destroy(__first, __idx);
-        throw;
-    }
-#endif
+      ::new (std::__voidify(*__idx)) _ValueType();
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    std::__destroy(__first, __idx);
+    throw;
+  }
+#  endif
 
-    return __idx;
+  return __idx;
 }
 
 template <class _ForwardIterator>
-inline _LIBCPP_HIDE_FROM_ABI
-void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) {
-    using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
-    (void)_VSTD::__uninitialized_value_construct<_ValueType>(
-        _VSTD::move(__first), _VSTD::move(__last));
+inline _LIBCPP_HIDE_FROM_ABI void uninitialized_value_construct(_ForwardIterator __first, _ForwardIterator __last) {
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  (void)std::__uninitialized_value_construct<_ValueType>(std::move(__first), std::move(__last));
 }
 
 // uninitialized_value_construct_n
 
 template <class _ValueType, class _ForwardIterator, class _Size>
-inline _LIBCPP_HIDE_FROM_ABI
-_ForwardIterator __uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
-    auto __idx = __first;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try {
-#endif
-    for (; __n > 0; ++__idx, (void) --__n)
-        ::new (_VSTD::__voidify(*__idx)) _ValueType();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    } catch (...) {
-        _VSTD::__destroy(__first, __idx);
-        throw;
-    }
-#endif
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator __uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
+  auto __idx = __first;
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif
+    for (; __n > 0; ++__idx, (void)--__n)
+      ::new (std::__voidify(*__idx)) _ValueType();
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    std::__destroy(__first, __idx);
+    throw;
+  }
+#  endif
 
-    return __idx;
+  return __idx;
 }
 
 template <class _ForwardIterator, class _Size>
-inline _LIBCPP_HIDE_FROM_ABI
-_ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
-    using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
-    return std::__uninitialized_value_construct_n<_ValueType>(_VSTD::move(__first), __n);
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
+  using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
+  return std::__uninitialized_value_construct_n<_ValueType>(std::move(__first), __n);
 }
 
 // uninitialized_move
 
-template <class _ValueType, class _InputIterator, class _Sentinel1, class _ForwardIterator, class _Sentinel2,
+template <class _ValueType,
+          class _InputIterator,
+          class _Sentinel1,
+          class _ForwardIterator,
+          class _EndPredicate,
           class _IterMove>
-inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
-__uninitialized_move(_InputIterator __ifirst, _Sentinel1 __ilast,
-                     _ForwardIterator __ofirst, _Sentinel2 __olast, _IterMove __iter_move) {
+inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> __uninitialized_move(
+    _InputIterator __ifirst,
+    _Sentinel1 __ilast,
+    _ForwardIterator __ofirst,
+    _EndPredicate __stop_moving,
+    _IterMove __iter_move) {
   auto __idx = __ofirst;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
-#endif
-    for (; __ifirst != __ilast && __idx != __olast; ++__idx, (void)++__ifirst) {
-      ::new (_VSTD::__voidify(*__idx)) _ValueType(__iter_move(__ifirst));
+#  endif
+    for (; __ifirst != __ilast && !__stop_moving(__idx); ++__idx, (void)++__ifirst) {
+      ::new (std::__voidify(*__idx)) _ValueType(__iter_move(__ifirst));
     }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   } catch (...) {
-    _VSTD::__destroy(__ofirst, __idx);
+    std::__destroy(__ofirst, __idx);
     throw;
   }
-#endif
+#  endif
 
-  return {_VSTD::move(__ifirst), _VSTD::move(__idx)};
+  return {std::move(__ifirst), std::move(__idx)};
 }
 
 template <class _InputIterator, class _ForwardIterator>
-inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_move(_InputIterator __ifirst, _InputIterator __ilast,
-                                                                 _ForwardIterator __ofirst) {
+inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
+uninitialized_move(_InputIterator __ifirst, _InputIterator __ilast, _ForwardIterator __ofirst) {
   using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
-  auto __iter_move = [](auto&& __iter) -> decltype(auto) { return _VSTD::move(*__iter); };
+  auto __iter_move = [](auto&& __iter) -> decltype(auto) { return std::move(*__iter); };
 
-  auto __result = _VSTD::__uninitialized_move<_ValueType>(_VSTD::move(__ifirst), _VSTD::move(__ilast),
-                                                          _VSTD::move(__ofirst), __unreachable_sentinel(), __iter_move);
-  return _VSTD::move(__result.second);
+  auto __result = std::__uninitialized_move<_ValueType>(
+      std::move(__ifirst), std::move(__ilast), std::move(__ofirst), __always_false(), __iter_move);
+  return std::move(__result.second);
 }
 
 // uninitialized_move_n
 
-template <class _ValueType, class _InputIterator, class _Size, class _ForwardIterator, class _Sentinel, class _IterMove>
-inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
-__uninitialized_move_n(_InputIterator __ifirst, _Size __n,
-                       _ForwardIterator __ofirst, _Sentinel __olast, _IterMove __iter_move) {
+template <class _ValueType,
+          class _InputIterator,
+          class _Size,
+          class _ForwardIterator,
+          class _EndPredicate,
+          class _IterMove>
+inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> __uninitialized_move_n(
+    _InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst, _EndPredicate __stop_moving, _IterMove __iter_move) {
   auto __idx = __ofirst;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   try {
-#endif
-    for (; __n > 0 && __idx != __olast; ++__idx, (void)++__ifirst, --__n)
-      ::new (_VSTD::__voidify(*__idx)) _ValueType(__iter_move(__ifirst));
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+#  endif
+    for (; __n > 0 && !__stop_moving(__idx); ++__idx, (void)++__ifirst, --__n)
+      ::new (std::__voidify(*__idx)) _ValueType(__iter_move(__ifirst));
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
   } catch (...) {
-    _VSTD::__destroy(__ofirst, __idx);
+    std::__destroy(__ofirst, __idx);
     throw;
   }
-#endif
+#  endif
 
-  return {_VSTD::move(__ifirst), _VSTD::move(__idx)};
+  return {std::move(__ifirst), std::move(__idx)};
 }
 
 template <class _InputIterator, class _Size, class _ForwardIterator>
 inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
 uninitialized_move_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst) {
   using _ValueType = typename iterator_traits<_ForwardIterator>::value_type;
-  auto __iter_move = [](auto&& __iter) -> decltype(auto) { return _VSTD::move(*__iter); };
+  auto __iter_move = [](auto&& __iter) -> decltype(auto) { return std::move(*__iter); };
 
-  return _VSTD::__uninitialized_move_n<_ValueType>(_VSTD::move(__ifirst), __n, _VSTD::move(__ofirst),
-                                                   __unreachable_sentinel(), __iter_move);
+  return std::__uninitialized_move_n<_ValueType>(
+      std::move(__ifirst), __n, std::move(__ofirst), __always_false(), __iter_move);
 }
 
 // TODO: Rewrite this to iterate left to right and use reverse_iterators when calling
@@ -372,35 +362,35 @@ uninitialized_move_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofir
 //
 // This function assumes that destructors do not throw, and that the allocator is bound to
 // the correct type.
-template<class _Alloc, class _BidirIter, class = __enable_if_t<
-    __has_bidirectional_iterator_category<_BidirIter>::value
->>
-_LIBCPP_HIDE_FROM_ABI
-constexpr void __allocator_destroy_multidimensional(_Alloc& __alloc, _BidirIter __first, _BidirIter __last) noexcept {
-    using _ValueType = typename iterator_traits<_BidirIter>::value_type;
-    static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _ValueType>,
-        "The allocator should already be rebound to the correct type");
+template <class _Alloc,
+          class _BidirIter,
+          __enable_if_t<__has_bidirectional_iterator_category<_BidirIter>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr void
+__allocator_destroy_multidimensional(_Alloc& __alloc, _BidirIter __first, _BidirIter __last) noexcept {
+  using _ValueType = typename iterator_traits<_BidirIter>::value_type;
+  static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _ValueType>,
+                "The allocator should already be rebound to the correct type");
 
-    if (__first == __last)
-        return;
+  if (__first == __last)
+    return;
 
-    if constexpr (is_array_v<_ValueType>) {
-        static_assert(!__libcpp_is_unbounded_array<_ValueType>::value,
-            "arrays of unbounded arrays don't exist, but if they did we would mess up here");
+  if constexpr (is_array_v<_ValueType>) {
+    static_assert(!__libcpp_is_unbounded_array<_ValueType>::value,
+                  "arrays of unbounded arrays don't exist, but if they did we would mess up here");
 
-        using _Element = remove_extent_t<_ValueType>;
-        __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
-        do {
-            --__last;
-            decltype(auto) __array = *__last;
-            std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + extent_v<_ValueType>);
-        } while (__last != __first);
-    } else {
-        do {
-            --__last;
-            allocator_traits<_Alloc>::destroy(__alloc, std::addressof(*__last));
-        } while (__last != __first);
-    }
+    using _Element = remove_extent_t<_ValueType>;
+    __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
+    do {
+      --__last;
+      decltype(auto) __array = *__last;
+      std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + extent_v<_ValueType>);
+    } while (__last != __first);
+  } else {
+    do {
+      --__last;
+      allocator_traits<_Alloc>::destroy(__alloc, std::addressof(*__last));
+    } while (__last != __first);
+  }
 }
 
 // Constructs the object at the given location using the allocator's construct method.
@@ -410,30 +400,29 @@ constexpr void __allocator_destroy_multidimensional(_Alloc& __alloc, _BidirIter
 // elements are destroyed in reverse order of initialization using allocator destruction.
 //
 // This function assumes that the allocator is bound to the correct type.
-template<class _Alloc, class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-constexpr void __allocator_construct_at_multidimensional(_Alloc& __alloc, _Tp* __loc) {
-    static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _Tp>,
-        "The allocator should already be rebound to the correct type");
+template <class _Alloc, class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr void __allocator_construct_at_multidimensional(_Alloc& __alloc, _Tp* __loc) {
+  static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _Tp>,
+                "The allocator should already be rebound to the correct type");
 
-    if constexpr (is_array_v<_Tp>) {
-        using _Element = remove_extent_t<_Tp>;
-        __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
-        size_t __i = 0;
-        _Tp& __array = *__loc;
+  if constexpr (is_array_v<_Tp>) {
+    using _Element = remove_extent_t<_Tp>;
+    __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
+    size_t __i   = 0;
+    _Tp& __array = *__loc;
 
-        // If an exception is thrown, destroy what we have constructed so far in reverse order.
-        auto __guard = std::__make_exception_guard([&]() {
-          std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + __i);
-        });
+    // If an exception is thrown, destroy what we have constructed so far in reverse order.
+    auto __guard = std::__make_exception_guard([&]() {
+      std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + __i);
+    });
 
-        for (; __i != extent_v<_Tp>; ++__i) {
-            std::__allocator_construct_at_multidimensional(__elem_alloc, std::addressof(__array[__i]));
-        }
-        __guard.__complete();
-    } else {
-        allocator_traits<_Alloc>::construct(__alloc, __loc);
+    for (; __i != extent_v<_Tp>; ++__i) {
+      std::__allocator_construct_at_multidimensional(__elem_alloc, std::addressof(__array[__i]));
     }
+    __guard.__complete();
+  } else {
+    allocator_traits<_Alloc>::construct(__alloc, __loc);
+  }
 }
 
 // Constructs the object at the given location using the allocator's construct method, passing along
@@ -446,33 +435,33 @@ constexpr void __allocator_construct_at_multidimensional(_Alloc& __alloc, _Tp* _
 // destruction.
 //
 // This function assumes that the allocator is bound to the correct type.
-template<class _Alloc, class _Tp, class _Arg>
-_LIBCPP_HIDE_FROM_ABI
-constexpr void __allocator_construct_at_multidimensional(_Alloc& __alloc, _Tp* __loc, _Arg const& __arg) {
-    static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _Tp>,
-        "The allocator should already be rebound to the correct type");
+template <class _Alloc, class _Tp, class _Arg>
+_LIBCPP_HIDE_FROM_ABI constexpr void
+__allocator_construct_at_multidimensional(_Alloc& __alloc, _Tp* __loc, _Arg const& __arg) {
+  static_assert(is_same_v<typename allocator_traits<_Alloc>::value_type, _Tp>,
+                "The allocator should already be rebound to the correct type");
 
-    if constexpr (is_array_v<_Tp>) {
-        static_assert(is_array_v<_Arg>,
-            "Provided non-array initialization argument to __allocator_construct_at_multidimensional when "
-            "trying to construct an array.");
+  if constexpr (is_array_v<_Tp>) {
+    static_assert(is_array_v<_Arg>,
+                  "Provided non-array initialization argument to __allocator_construct_at_multidimensional when "
+                  "trying to construct an array.");
 
-        using _Element = remove_extent_t<_Tp>;
-        __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
-        size_t __i = 0;
-        _Tp& __array = *__loc;
+    using _Element = remove_extent_t<_Tp>;
+    __allocator_traits_rebind_t<_Alloc, _Element> __elem_alloc(__alloc);
+    size_t __i   = 0;
+    _Tp& __array = *__loc;
 
-        // If an exception is thrown, destroy what we have constructed so far in reverse order.
-        auto __guard = std::__make_exception_guard([&]() {
-          std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + __i);
-        });
-        for (; __i != extent_v<_Tp>; ++__i) {
-            std::__allocator_construct_at_multidimensional(__elem_alloc, std::addressof(__array[__i]), __arg[__i]);
-        }
-        __guard.__complete();
-    } else {
-        allocator_traits<_Alloc>::construct(__alloc, __loc, __arg);
+    // If an exception is thrown, destroy what we have constructed so far in reverse order.
+    auto __guard = std::__make_exception_guard([&]() {
+      std::__allocator_destroy_multidimensional(__elem_alloc, __array, __array + __i);
+    });
+    for (; __i != extent_v<_Tp>; ++__i) {
+      std::__allocator_construct_at_multidimensional(__elem_alloc, std::addressof(__array[__i]), __arg[__i]);
     }
+    __guard.__complete();
+  } else {
+    allocator_traits<_Alloc>::construct(__alloc, __loc, __arg);
+  }
 }
 
 // Given a range starting at it and containing n elements, initializes each element in the
@@ -482,19 +471,23 @@ constexpr void __allocator_construct_at_multidimensional(_Alloc& __alloc, _Tp* _
 // If an exception is thrown, the initialized elements are destroyed in reverse order of
 // initialization using allocator_traits destruction. If the elements in the range are C-style
 // arrays, they are initialized element-wise using allocator construction, and recursively so.
-template<class _Alloc, class _BidirIter, class _Tp, class _Size = typename iterator_traits<_BidirIter>::difference_type>
+template <class _Alloc,
+          class _BidirIter,
+          class _Tp,
+          class _Size = typename iterator_traits<_BidirIter>::difference_type>
 _LIBCPP_HIDE_FROM_ABI constexpr void
 __uninitialized_allocator_fill_n_multidimensional(_Alloc& __alloc, _BidirIter __it, _Size __n, _Tp const& __value) {
-    using _ValueType = typename iterator_traits<_BidirIter>::value_type;
-    __allocator_traits_rebind_t<_Alloc, _ValueType> __value_alloc(__alloc);
-    _BidirIter __begin = __it;
+  using _ValueType = typename iterator_traits<_BidirIter>::value_type;
+  __allocator_traits_rebind_t<_Alloc, _ValueType> __value_alloc(__alloc);
+  _BidirIter __begin = __it;
 
-    // If an exception is thrown, destroy what we have constructed so far in reverse order.
-    auto __guard = std::__make_exception_guard([&]() { std::__allocator_destroy_multidimensional(__value_alloc, __begin, __it); });
-    for (; __n != 0; --__n, ++__it) {
-        std::__allocator_construct_at_multidimensional(__value_alloc, std::addressof(*__it), __value);
-    }
-    __guard.__complete();
+  // If an exception is thrown, destroy what we have constructed so far in reverse order.
+  auto __guard =
+      std::__make_exception_guard([&]() { std::__allocator_destroy_multidimensional(__value_alloc, __begin, __it); });
+  for (; __n != 0; --__n, ++__it) {
+    std::__allocator_construct_at_multidimensional(__value_alloc, std::addressof(*__it), __value);
+  }
+  __guard.__complete();
 }
 
 // Same as __uninitialized_allocator_fill_n_multidimensional, but doesn't pass any initialization argument
@@ -502,16 +495,17 @@ __uninitialized_allocator_fill_n_multidimensional(_Alloc& __alloc, _BidirIter __
 template <class _Alloc, class _BidirIter, class _Size = typename iterator_traits<_BidirIter>::difference_type>
 _LIBCPP_HIDE_FROM_ABI constexpr void
 __uninitialized_allocator_value_construct_n_multidimensional(_Alloc& __alloc, _BidirIter __it, _Size __n) {
-    using _ValueType = typename iterator_traits<_BidirIter>::value_type;
-    __allocator_traits_rebind_t<_Alloc, _ValueType> __value_alloc(__alloc);
-    _BidirIter __begin = __it;
+  using _ValueType = typename iterator_traits<_BidirIter>::value_type;
+  __allocator_traits_rebind_t<_Alloc, _ValueType> __value_alloc(__alloc);
+  _BidirIter __begin = __it;
 
-    // If an exception is thrown, destroy what we have constructed so far in reverse order.
-    auto __guard = std::__make_exception_guard([&]() { std::__allocator_destroy_multidimensional(__value_alloc, __begin, __it); });
-    for (; __n != 0; --__n, ++__it) {
-        std::__allocator_construct_at_multidimensional(__value_alloc, std::addressof(*__it));
-    }
-    __guard.__complete();
+  // If an exception is thrown, destroy what we have constructed so far in reverse order.
+  auto __guard =
+      std::__make_exception_guard([&]() { std::__allocator_destroy_multidimensional(__value_alloc, __begin, __it); });
+  for (; __n != 0; --__n, ++__it) {
+    std::__allocator_construct_at_multidimensional(__value_alloc, std::addressof(*__it));
+  }
+  __guard.__complete();
 }
 
 #endif // _LIBCPP_STD_VER >= 17
@@ -521,7 +515,7 @@ template <class _Alloc, class _Iter, class _Sent>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
 __allocator_destroy(_Alloc& __alloc, _Iter __first, _Sent __last) {
   for (; __first != __last; ++__first)
-     allocator_traits<_Alloc>::destroy(__alloc, std::__to_address(__first));
+    allocator_traits<_Alloc>::destroy(__alloc, std::__to_address(__first));
 }
 
 template <class _Alloc, class _Iter>
@@ -573,8 +567,9 @@ template <class _Alloc,
           __enable_if_t<
               // using _RawTypeIn because of the allocator<T const> extension
               is_trivially_copy_constructible<_RawTypeIn>::value && is_trivially_copy_assignable<_RawTypeIn>::value &&
-              is_same<__remove_cv_t<_In>, __remove_cv_t<_Out> >::value &&
-              __allocator_has_trivial_copy_construct<_Alloc, _RawTypeIn>::value>* = nullptr>
+                  is_same<__remove_const_t<_In>, __remove_const_t<_Out> >::value &&
+                  __allocator_has_trivial_copy_construct<_Alloc, _RawTypeIn>::value,
+              int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Out*
 __uninitialized_allocator_copy_impl(_Alloc&, _In* __first1, _In* __last1, _Out* __first2) {
   // TODO: Remove the const_cast once we drop support for std::allocator<T const>
@@ -591,36 +586,12 @@ __uninitialized_allocator_copy_impl(_Alloc&, _In* __first1, _In* __last1, _Out*
 }
 
 template <class _Alloc, class _Iter1, class _Sent1, class _Iter2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter2 __uninitialized_allocator_copy(_Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2) {
-    auto __unwrapped_range = std::__unwrap_range(__first1, __last1);
-    auto __result = std::__uninitialized_allocator_copy_impl(__alloc, __unwrapped_range.first, __unwrapped_range.second, std::__unwrap_iter(__first2));
-    return std::__rewrap_iter(__first2, __result);
-}
-
-// Move-construct the elements [__first1, __last1) into [__first2, __first2 + N)
-// if the move constructor is noexcept, where N is distance(__first1, __last1).
-//
-// Otherwise try to copy all elements. If an exception is thrown the already copied
-// elements are destroyed in reverse order of their construction.
-template <class _Alloc, class _Iter1, class _Sent1, class _Iter2>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter2 __uninitialized_allocator_move_if_noexcept(
-    _Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2) {
-  static_assert(__is_cpp17_move_insertable<_Alloc>::value,
-                "The specified type does not meet the requirements of Cpp17MoveInsertable");
-  auto __destruct_first = __first2;
-  auto __guard =
-      std::__make_exception_guard(_AllocatorDestroyRangeReverse<_Alloc, _Iter2>(__alloc, __destruct_first, __first2));
-  while (__first1 != __last1) {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), std::move_if_noexcept(*__first1));
-#else
-    allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), std::move(*__first1));
-#endif
-    ++__first1;
-    ++__first2;
-  }
-  __guard.__complete();
-  return __first2;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter2
+__uninitialized_allocator_copy(_Alloc& __alloc, _Iter1 __first1, _Sent1 __last1, _Iter2 __first2) {
+  auto __unwrapped_range = std::__unwrap_range(__first1, __last1);
+  auto __result          = std::__uninitialized_allocator_copy_impl(
+      __alloc, __unwrapped_range.first, __unwrapped_range.second, std::__unwrap_iter(__first2));
+  return std::__rewrap_iter(__first2, __result);
 }
 
 template <class _Alloc, class _Type>
@@ -629,29 +600,54 @@ struct __allocator_has_trivial_move_construct : _Not<__has_construct<_Alloc, _Ty
 template <class _Type>
 struct __allocator_has_trivial_move_construct<allocator<_Type>, _Type> : true_type {};
 
-#ifndef _LIBCPP_COMPILER_GCC
-template <
-    class _Alloc,
-    class _Iter1,
-    class _Iter2,
-    class _Type = typename iterator_traits<_Iter1>::value_type,
-    class = __enable_if_t<is_trivially_move_constructible<_Type>::value && is_trivially_move_assignable<_Type>::value &&
-                          __allocator_has_trivial_move_construct<_Alloc, _Type>::value> >
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Iter2
-__uninitialized_allocator_move_if_noexcept(_Alloc&, _Iter1 __first1, _Iter1 __last1, _Iter2 __first2) {
-  if (__libcpp_is_constant_evaluated()) {
-    while (__first1 != __last1) {
-      std::__construct_at(std::__to_address(__first2), std::move(*__first1));
-      ++__first1;
-      ++__first2;
+template <class _Alloc, class _Tp>
+struct __allocator_has_trivial_destroy : _Not<__has_destroy<_Alloc, _Tp*> > {};
+
+template <class _Tp, class _Up>
+struct __allocator_has_trivial_destroy<allocator<_Tp>, _Up> : true_type {};
+
+// __uninitialized_allocator_relocate relocates the objects in [__first, __last) into __result.
+// Relocation means that the objects in [__first, __last) are placed into __result as-if by move-construct and destroy,
+// except that the move constructor and destructor may never be called if they are known to be equivalent to a memcpy.
+//
+// Preconditions:  __result doesn't contain any objects and [__first, __last) contains objects
+// Postconditions: __result contains the objects from [__first, __last) and
+//                 [__first, __last) doesn't contain any objects
+//
+// The strong exception guarantee is provided if any of the following are true:
+// - is_nothrow_move_constructible<_Tp>
+// - is_copy_constructible<_Tp>
+// - __libcpp_is_trivially_relocatable<_Tp>
+template <class _Alloc, class _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+__uninitialized_allocator_relocate(_Alloc& __alloc, _Tp* __first, _Tp* __last, _Tp* __result) {
+  static_assert(__is_cpp17_move_insertable<_Alloc>::value,
+                "The specified type does not meet the requirements of Cpp17MoveInsertable");
+  if (__libcpp_is_constant_evaluated() || !__libcpp_is_trivially_relocatable<_Tp>::value ||
+      !__allocator_has_trivial_move_construct<_Alloc, _Tp>::value ||
+      !__allocator_has_trivial_destroy<_Alloc, _Tp>::value) {
+    auto __destruct_first = __result;
+    auto __guard =
+        std::__make_exception_guard(_AllocatorDestroyRangeReverse<_Alloc, _Tp*>(__alloc, __destruct_first, __result));
+    auto __iter = __first;
+    while (__iter != __last) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      allocator_traits<_Alloc>::construct(__alloc, __result, std::move_if_noexcept(*__iter));
+#else
+      allocator_traits<_Alloc>::construct(__alloc, __result, std::move(*__iter));
+#endif
+      ++__iter;
+      ++__result;
     }
-    return __first2;
+    __guard.__complete();
+    std::__allocator_destroy(__alloc, __first, __last);
   } else {
-    return std::move(__first1, __last1, __first2);
+    __builtin_memcpy(const_cast<__remove_const_t<_Tp>*>(__result), __first, sizeof(_Tp) * (__last - __first));
   }
 }
-#endif // _LIBCPP_COMPILER_GCC
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_UNINITIALIZED_ALGORITHMS_H
diff --git a/third_party/libcxx/__memory/unique_ptr.h b/third_party/libcxx/__memory/unique_ptr.h
index b30f8b220..f75259473 100644
--- a/third_party/libcxx/__memory/unique_ptr.h
+++ b/third_party/libcxx/__memory/unique_ptr.h
@@ -21,21 +21,24 @@
 #include <__memory/compressed_pair.h>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/common_type.h>
+#include <__type_traits/conditional.h>
 #include <__type_traits/dependent_type.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
-#include <__type_traits/is_default_constructible.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
+#include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/remove_extent.h>
+#include <__type_traits/remove_pointer.h>
 #include <__type_traits/type_identity.h>
+#include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <cstddef>
@@ -44,22 +47,34 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Ptr>
+struct __is_noexcept_deref_or_void {
+  static constexpr bool value = noexcept(*std::declval<_Ptr>());
+};
+
+template <>
+struct __is_noexcept_deref_or_void<void*> : true_type {};
+#endif
+
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS default_delete {
-    static_assert(!is_function<_Tp>::value,
-                  "default_delete cannot be instantiated for function types");
+  static_assert(!is_function<_Tp>::value, "default_delete cannot be instantiated for function types");
 #ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr default_delete() _NOEXCEPT = default;
 #else
-  _LIBCPP_INLINE_VISIBILITY default_delete() {}
+  _LIBCPP_HIDE_FROM_ABI default_delete() {}
 #endif
-  template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 default_delete(
-      const default_delete<_Up>&, typename enable_if<is_convertible<_Up*, _Tp*>::value>::type* = 0) _NOEXCEPT {}
+  template <class _Up, __enable_if_t<is_convertible<_Up*, _Tp*>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 default_delete(const default_delete<_Up>&) _NOEXCEPT {}
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator()(_Tp* __ptr) const _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator()(_Tp* __ptr) const _NOEXCEPT {
     static_assert(sizeof(_Tp) >= 0, "cannot delete an incomplete type");
     static_assert(!is_void<_Tp>::value, "cannot delete an incomplete type");
     delete __ptr;
@@ -70,22 +85,21 @@ template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS default_delete<_Tp[]> {
 private:
   template <class _Up>
-  struct _EnableIfConvertible
-      : enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value> {};
+  struct _EnableIfConvertible : enable_if<is_convertible<_Up (*)[], _Tp (*)[]>::value> {};
 
 public:
 #ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_INLINE_VISIBILITY constexpr default_delete() _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr default_delete() _NOEXCEPT = default;
 #else
-  _LIBCPP_INLINE_VISIBILITY default_delete() {}
+  _LIBCPP_HIDE_FROM_ABI default_delete() {}
 #endif
 
   template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
   default_delete(const default_delete<_Up[]>&, typename _EnableIfConvertible<_Up>::type* = 0) _NOEXCEPT {}
 
   template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 typename _EnableIfConvertible<_Up>::type
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 typename _EnableIfConvertible<_Up>::type
   operator()(_Up* __ptr) const _NOEXCEPT {
     static_assert(sizeof(_Up) >= 0, "cannot delete an incomplete type");
     delete[] __ptr;
@@ -127,109 +141,96 @@ public:
   typedef _Dp deleter_type;
   typedef _LIBCPP_NODEBUG typename __pointer<_Tp, deleter_type>::type pointer;
 
-  static_assert(!is_rvalue_reference<deleter_type>::value,
-                "the specified deleter type cannot be an rvalue reference");
+  static_assert(!is_rvalue_reference<deleter_type>::value, "the specified deleter type cannot be an rvalue reference");
+
+  // A unique_ptr contains the following members which may be trivially relocatable:
+  // - pointer : this may be trivially relocatable, so it's checked
+  // - deleter_type: this may be trivially relocatable, so it's checked
+  //
+  // This unique_ptr implementation only contains a pointer to the unique object and a deleter, so there are no
+  // references to itself. This means that the entire structure is trivially relocatable if its members are.
+  using __trivially_relocatable = __conditional_t<
+      __libcpp_is_trivially_relocatable<pointer>::value && __libcpp_is_trivially_relocatable<deleter_type>::value,
+      unique_ptr,
+      void>;
 
 private:
   __compressed_pair<pointer, deleter_type> __ptr_;
 
-  struct __nat { int __for_bool_; };
-
   typedef _LIBCPP_NODEBUG __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
 
   template <bool _Dummy>
-  using _LValRefType _LIBCPP_NODEBUG =
-      typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
+  using _LValRefType _LIBCPP_NODEBUG = typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
 
   template <bool _Dummy>
-  using _GoodRValRefType _LIBCPP_NODEBUG =
-      typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
+  using _GoodRValRefType _LIBCPP_NODEBUG = typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
 
   template <bool _Dummy>
-  using _BadRValRefType _LIBCPP_NODEBUG =
-      typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
+  using _BadRValRefType _LIBCPP_NODEBUG = typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
 
-  template <bool _Dummy, class _Deleter = typename __dependent_type<
-                             __type_identity<deleter_type>, _Dummy>::type>
+  template <bool _Dummy, class _Deleter = typename __dependent_type< __type_identity<deleter_type>, _Dummy>::type>
   using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG =
-      typename enable_if<is_default_constructible<_Deleter>::value &&
-                         !is_pointer<_Deleter>::value>::type;
+      __enable_if_t<is_default_constructible<_Deleter>::value && !is_pointer<_Deleter>::value>;
 
   template <class _ArgType>
-  using _EnableIfDeleterConstructible _LIBCPP_NODEBUG =
-      typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;
+  using _EnableIfDeleterConstructible _LIBCPP_NODEBUG = __enable_if_t<is_constructible<deleter_type, _ArgType>::value>;
 
   template <class _UPtr, class _Up>
-  using _EnableIfMoveConvertible _LIBCPP_NODEBUG = typename enable_if<
-      is_convertible<typename _UPtr::pointer, pointer>::value &&
-      !is_array<_Up>::value
-  >::type;
+  using _EnableIfMoveConvertible _LIBCPP_NODEBUG =
+      __enable_if_t< is_convertible<typename _UPtr::pointer, pointer>::value && !is_array<_Up>::value >;
 
   template <class _UDel>
-  using _EnableIfDeleterConvertible _LIBCPP_NODEBUG = typename enable_if<
-      (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) ||
-      (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)
-    >::type;
+  using _EnableIfDeleterConvertible _LIBCPP_NODEBUG =
+      __enable_if_t< (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) ||
+                     (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value) >;
 
   template <class _UDel>
-  using _EnableIfDeleterAssignable = typename enable_if<
-      is_assignable<_Dp&, _UDel&&>::value
-    >::type;
+  using _EnableIfDeleterAssignable = __enable_if_t< is_assignable<_Dp&, _UDel&&>::value >;
 
 public:
-  template <bool _Dummy = true,
-            class = _EnableIfDeleterDefaultConstructible<_Dummy> >
-  _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(__value_init_tag(), __value_init_tag()) {}
-
-  template <bool _Dummy = true,
-            class = _EnableIfDeleterDefaultConstructible<_Dummy> >
-  _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(__value_init_tag(), __value_init_tag()) {}
+  template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy> >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(__value_init_tag(), __value_init_tag()) {}
 
   template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy> >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit unique_ptr(pointer __p) _NOEXCEPT
-      : __ptr_(__p, __value_init_tag()) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT
+      : __ptr_(__value_init_tag(), __value_init_tag()) {}
+
+  template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy> >
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit unique_ptr(pointer __p) _NOEXCEPT : __ptr_(__p, __value_init_tag()) {}
 
   template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(pointer __p, _LValRefType<_Dummy> __d) _NOEXCEPT
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(pointer __p, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, __d) {}
 
   template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-  unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT : __ptr_(__p, _VSTD::move(__d)) {
-    static_assert(!is_reference<deleter_type>::value,
-                  "rvalue deleter bound to reference");
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(pointer __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
+      : __ptr_(__p, std::move(__d)) {
+    static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
   }
 
-  template <bool _Dummy = true,
-            class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete;
+  template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> > >
+  _LIBCPP_HIDE_FROM_ABI unique_ptr(pointer __p, _BadRValRefType<_Dummy> __d) = delete;
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr&& __u) _NOEXCEPT
+      : __ptr_(__u.release(), std::forward<deleter_type>(__u.get_deleter())) {}
 
   template <class _Up,
             class _Ep,
             class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
             class = _EnableIfDeleterConvertible<_Ep> >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
+      : __ptr_(__u.release(), std::forward<_Ep>(__u.get_deleter())) {}
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
-  template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr(auto_ptr<_Up>&& __p,
-             typename enable_if<is_convertible<_Up*, _Tp*>::value &&
-                                    is_same<_Dp, default_delete<_Tp> >::value,
-                                __nat>::type = __nat()) _NOEXCEPT
-      : __ptr_(__p.release(), __value_init_tag()) {}
+  template <class _Up,
+            __enable_if_t<is_convertible<_Up*, _Tp*>::value && is_same<_Dp, default_delete<_Tp> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI unique_ptr(auto_ptr<_Up>&& __p) _NOEXCEPT : __ptr_(__p.release(), __value_init_tag()) {}
 #endif
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
-    __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
+    __ptr_.second() = std::forward<deleter_type>(__u.get_deleter());
     return *this;
   }
 
@@ -237,72 +238,63 @@ public:
             class _Ep,
             class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
             class = _EnableIfDeleterAssignable<_Ep> >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
-    __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
+    __ptr_.second() = std::forward<_Ep>(__u.get_deleter());
     return *this;
   }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
-  template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY
-      typename enable_if<is_convertible<_Up*, _Tp*>::value &&
-                             is_same<_Dp, default_delete<_Tp> >::value,
-                         unique_ptr&>::type
-      operator=(auto_ptr<_Up> __p) {
+  template <class _Up,
+            __enable_if_t<is_convertible<_Up*, _Tp*>::value && is_same<_Dp, default_delete<_Tp> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI unique_ptr& operator=(auto_ptr<_Up> __p) {
     reset(__p.release());
     return *this;
   }
 #endif
 
 #ifdef _LIBCPP_CXX03_LANG
-  unique_ptr(unique_ptr const&) = delete;
+  unique_ptr(unique_ptr const&)            = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
 #endif
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 ~unique_ptr() { reset(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 ~unique_ptr() { reset(); }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(nullptr_t) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
   }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 __add_lvalue_reference_t<_Tp> operator*() const {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __add_lvalue_reference_t<_Tp> operator*() const
+      _NOEXCEPT_(__is_noexcept_deref_or_void<pointer>::value) {
     return *__ptr_.first();
   }
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer operator->() const _NOEXCEPT {
-    return __ptr_.first();
-  }
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer get() const _NOEXCEPT { return __ptr_.first(); }
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 deleter_type& get_deleter() _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer operator->() const _NOEXCEPT { return __ptr_.first(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer get() const _NOEXCEPT { return __ptr_.first(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 deleter_type& get_deleter() _NOEXCEPT { return __ptr_.second(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 const deleter_type& get_deleter() const _NOEXCEPT {
     return __ptr_.second();
   }
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 const deleter_type& get_deleter() const _NOEXCEPT {
-    return __ptr_.second();
-  }
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit operator bool() const _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit operator bool() const _NOEXCEPT {
     return __ptr_.first() != nullptr;
   }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer release() _NOEXCEPT {
-    pointer __t = __ptr_.first();
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer release() _NOEXCEPT {
+    pointer __t    = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;
   }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(pointer __p = pointer()) _NOEXCEPT {
-    pointer __tmp = __ptr_.first();
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(pointer __p = pointer()) _NOEXCEPT {
+    pointer __tmp  = __ptr_.first();
     __ptr_.first() = __p;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void swap(unique_ptr& __u) _NOEXCEPT {
-    __ptr_.swap(__u.__ptr_);
-  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void swap(unique_ptr& __u) _NOEXCEPT { __ptr_.swap(__u.__ptr_); }
 };
 
-
 template <class _Tp, class _Dp>
 class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr<_Tp[], _Dp> {
 public:
@@ -310,6 +302,17 @@ public:
   typedef _Dp deleter_type;
   typedef typename __pointer<_Tp, deleter_type>::type pointer;
 
+  // A unique_ptr contains the following members which may be trivially relocatable:
+  // - pointer : this may be trivially relocatable, so it's checked
+  // - deleter_type: this may be trivially relocatable, so it's checked
+  //
+  // This unique_ptr implementation only contains a pointer to the unique object and a deleter, so there are no
+  // references to itself. This means that the entire structure is trivially relocatable if its members are.
+  using __trivially_relocatable = __conditional_t<
+      __libcpp_is_trivially_relocatable<pointer>::value && __libcpp_is_trivially_relocatable<deleter_type>::value,
+      unique_ptr,
+      void>;
+
 private:
   __compressed_pair<pointer, deleter_type> __ptr_;
 
@@ -319,119 +322,98 @@ private:
   template <class _FromElem>
   struct _CheckArrayPointerConversion<_FromElem*>
       : integral_constant<bool,
-          is_same<_FromElem*, pointer>::value ||
-            (is_same<pointer, element_type*>::value &&
-             is_convertible<_FromElem(*)[], element_type(*)[]>::value)
-      >
-  {};
+                          is_same<_FromElem*, pointer>::value ||
+                              (is_same<pointer, element_type*>::value &&
+                               is_convertible<_FromElem (*)[], element_type (*)[]>::value) > {};
 
   typedef __unique_ptr_deleter_sfinae<_Dp> _DeleterSFINAE;
 
   template <bool _Dummy>
-  using _LValRefType _LIBCPP_NODEBUG =
-      typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
+  using _LValRefType _LIBCPP_NODEBUG = typename __dependent_type<_DeleterSFINAE, _Dummy>::__lval_ref_type;
 
   template <bool _Dummy>
-  using _GoodRValRefType _LIBCPP_NODEBUG =
-      typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
+  using _GoodRValRefType _LIBCPP_NODEBUG = typename __dependent_type<_DeleterSFINAE, _Dummy>::__good_rval_ref_type;
 
   template <bool _Dummy>
-  using _BadRValRefType _LIBCPP_NODEBUG =
-      typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
+  using _BadRValRefType _LIBCPP_NODEBUG = typename __dependent_type<_DeleterSFINAE, _Dummy>::__bad_rval_ref_type;
 
-  template <bool _Dummy, class _Deleter = typename __dependent_type<
-                             __type_identity<deleter_type>, _Dummy>::type>
+  template <bool _Dummy, class _Deleter = typename __dependent_type< __type_identity<deleter_type>, _Dummy>::type>
   using _EnableIfDeleterDefaultConstructible _LIBCPP_NODEBUG =
-      typename enable_if<is_default_constructible<_Deleter>::value &&
-                         !is_pointer<_Deleter>::value>::type;
+      __enable_if_t<is_default_constructible<_Deleter>::value && !is_pointer<_Deleter>::value>;
 
   template <class _ArgType>
-  using _EnableIfDeleterConstructible _LIBCPP_NODEBUG =
-      typename enable_if<is_constructible<deleter_type, _ArgType>::value>::type;
+  using _EnableIfDeleterConstructible _LIBCPP_NODEBUG = __enable_if_t<is_constructible<deleter_type, _ArgType>::value>;
 
   template <class _Pp>
-  using _EnableIfPointerConvertible _LIBCPP_NODEBUG = typename enable_if<
-      _CheckArrayPointerConversion<_Pp>::value
-  >::type;
+  using _EnableIfPointerConvertible _LIBCPP_NODEBUG = __enable_if_t< _CheckArrayPointerConversion<_Pp>::value >;
 
-  template <class _UPtr, class _Up,
-        class _ElemT = typename _UPtr::element_type>
-  using _EnableIfMoveConvertible _LIBCPP_NODEBUG = typename enable_if<
-      is_array<_Up>::value &&
-      is_same<pointer, element_type*>::value &&
-      is_same<typename _UPtr::pointer, _ElemT*>::value &&
-      is_convertible<_ElemT(*)[], element_type(*)[]>::value
-    >::type;
+  template <class _UPtr, class _Up, class _ElemT = typename _UPtr::element_type>
+  using _EnableIfMoveConvertible _LIBCPP_NODEBUG =
+      __enable_if_t< is_array<_Up>::value && is_same<pointer, element_type*>::value &&
+                     is_same<typename _UPtr::pointer, _ElemT*>::value &&
+                     is_convertible<_ElemT (*)[], element_type (*)[]>::value >;
 
   template <class _UDel>
-  using _EnableIfDeleterConvertible _LIBCPP_NODEBUG = typename enable_if<
-      (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) ||
-      (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value)
-    >::type;
+  using _EnableIfDeleterConvertible _LIBCPP_NODEBUG =
+      __enable_if_t< (is_reference<_Dp>::value && is_same<_Dp, _UDel>::value) ||
+                     (!is_reference<_Dp>::value && is_convertible<_UDel, _Dp>::value) >;
 
   template <class _UDel>
-  using _EnableIfDeleterAssignable _LIBCPP_NODEBUG = typename enable_if<
-      is_assignable<_Dp&, _UDel&&>::value
-    >::type;
+  using _EnableIfDeleterAssignable _LIBCPP_NODEBUG = __enable_if_t< is_assignable<_Dp&, _UDel&&>::value >;
 
 public:
-  template <bool _Dummy = true,
-            class = _EnableIfDeleterDefaultConstructible<_Dummy> >
-  _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(__value_init_tag(), __value_init_tag()) {}
+  template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy> >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unique_ptr() _NOEXCEPT : __ptr_(__value_init_tag(), __value_init_tag()) {}
 
-  template <bool _Dummy = true,
-            class = _EnableIfDeleterDefaultConstructible<_Dummy> >
-  _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT : __ptr_(__value_init_tag(), __value_init_tag()) {}
+  template <bool _Dummy = true, class = _EnableIfDeleterDefaultConstructible<_Dummy> >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unique_ptr(nullptr_t) _NOEXCEPT
+      : __ptr_(__value_init_tag(), __value_init_tag()) {}
 
   template <class _Pp,
             bool _Dummy = true,
             class       = _EnableIfDeleterDefaultConstructible<_Dummy>,
             class       = _EnableIfPointerConvertible<_Pp> >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit unique_ptr(_Pp __p) _NOEXCEPT
-      : __ptr_(__p, __value_init_tag()) {}
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit unique_ptr(_Pp __p) _NOEXCEPT : __ptr_(__p, __value_init_tag()) {}
 
   template <class _Pp,
             bool _Dummy = true,
             class       = _EnableIfDeleterConstructible<_LValRefType<_Dummy> >,
             class       = _EnableIfPointerConvertible<_Pp> >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) _NOEXCEPT
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(_Pp __p, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(__p, __d) {}
 
   template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_LValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) _NOEXCEPT
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(nullptr_t, _LValRefType<_Dummy> __d) _NOEXCEPT
       : __ptr_(nullptr, __d) {}
 
   template <class _Pp,
             bool _Dummy = true,
             class       = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> >,
             class       = _EnableIfPointerConvertible<_Pp> >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
-      : __ptr_(__p, _VSTD::move(__d)) {
-    static_assert(!is_reference<deleter_type>::value,
-                  "rvalue deleter bound to reference");
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(_Pp __p, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
+      : __ptr_(__p, std::move(__d)) {
+    static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
   }
 
   template <bool _Dummy = true, class = _EnableIfDeleterConstructible<_GoodRValRefType<_Dummy> > >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
-      : __ptr_(nullptr, _VSTD::move(__d)) {
-    static_assert(!is_reference<deleter_type>::value,
-                  "rvalue deleter bound to reference");
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(nullptr_t, _GoodRValRefType<_Dummy> __d) _NOEXCEPT
+      : __ptr_(nullptr, std::move(__d)) {
+    static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
   }
 
-  template <class _Pp, bool _Dummy = true,
-            class = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> >,
-            class = _EnableIfPointerConvertible<_Pp> >
-  _LIBCPP_INLINE_VISIBILITY
-  unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete;
+  template <class _Pp,
+            bool _Dummy = true,
+            class       = _EnableIfDeleterConstructible<_BadRValRefType<_Dummy> >,
+            class       = _EnableIfPointerConvertible<_Pp> >
+  _LIBCPP_HIDE_FROM_ABI unique_ptr(_Pp __p, _BadRValRefType<_Dummy> __d) = delete;
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr&& __u) _NOEXCEPT
+      : __ptr_(__u.release(), std::forward<deleter_type>(__u.get_deleter())) {}
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT {
     reset(__u.release());
-    __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
+    __ptr_.second() = std::forward<deleter_type>(__u.get_deleter());
     return *this;
   }
 
@@ -439,263 +421,228 @@ public:
             class _Ep,
             class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
             class = _EnableIfDeleterConvertible<_Ep> >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
-      : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
+      : __ptr_(__u.release(), std::forward<_Ep>(__u.get_deleter())) {}
 
   template <class _Up,
             class _Ep,
             class = _EnableIfMoveConvertible<unique_ptr<_Up, _Ep>, _Up>,
             class = _EnableIfDeleterAssignable<_Ep> >
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT {
     reset(__u.release());
-    __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
+    __ptr_.second() = std::forward<_Ep>(__u.get_deleter());
     return *this;
   }
 
 #ifdef _LIBCPP_CXX03_LANG
-  unique_ptr(unique_ptr const&) = delete;
+  unique_ptr(unique_ptr const&)            = delete;
   unique_ptr& operator=(unique_ptr const&) = delete;
 #endif
-public:
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 ~unique_ptr() { reset(); }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(nullptr_t) _NOEXCEPT {
+public:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 ~unique_ptr() { reset(); }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr& operator=(nullptr_t) _NOEXCEPT {
     reset();
     return *this;
   }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 __add_lvalue_reference_t<_Tp>
-  operator[](size_t __i) const {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __add_lvalue_reference_t<_Tp> operator[](size_t __i) const {
     return __ptr_.first()[__i];
   }
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer get() const _NOEXCEPT { return __ptr_.first(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer get() const _NOEXCEPT { return __ptr_.first(); }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 deleter_type& get_deleter() _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 deleter_type& get_deleter() _NOEXCEPT { return __ptr_.second(); }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 const deleter_type& get_deleter() const _NOEXCEPT {
     return __ptr_.second();
   }
-
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 const deleter_type& get_deleter() const _NOEXCEPT {
-    return __ptr_.second();
-  }
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit operator bool() const _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit operator bool() const _NOEXCEPT {
     return __ptr_.first() != nullptr;
   }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer release() _NOEXCEPT {
-    pointer __t = __ptr_.first();
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer release() _NOEXCEPT {
+    pointer __t    = __ptr_.first();
     __ptr_.first() = pointer();
     return __t;
   }
 
-  template <class _Pp>
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-      typename enable_if< _CheckArrayPointerConversion<_Pp>::value >::type
-      reset(_Pp __p) _NOEXCEPT {
-    pointer __tmp = __ptr_.first();
+  template <class _Pp, __enable_if_t<_CheckArrayPointerConversion<_Pp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(_Pp __p) _NOEXCEPT {
+    pointer __tmp  = __ptr_.first();
     __ptr_.first() = __p;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(nullptr_t = nullptr) _NOEXCEPT {
-    pointer __tmp = __ptr_.first();
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void reset(nullptr_t = nullptr) _NOEXCEPT {
+    pointer __tmp  = __ptr_.first();
     __ptr_.first() = nullptr;
     if (__tmp)
       __ptr_.second()(__tmp);
   }
 
-  _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void swap(unique_ptr& __u) _NOEXCEPT {
-    __ptr_.swap(__u.__ptr_);
-  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void swap(unique_ptr& __u) _NOEXCEPT { __ptr_.swap(__u.__ptr_); }
 };
 
-template <class _Tp, class _Dp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    typename enable_if< __is_swappable<_Dp>::value, void >::type
-    swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {
+template <class _Tp, class _Dp, __enable_if_t<__is_swappable_v<_Dp>, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
+swap(unique_ptr<_Tp, _Dp>& __x, unique_ptr<_Tp, _Dp>& __y) _NOEXCEPT {
   __x.swap(__y);
 }
 
 template <class _T1, class _D1, class _T2, class _D2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
 operator==(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {
   return __x.get() == __y.get();
 }
 
 #if _LIBCPP_STD_VER <= 17
 template <class _T1, class _D1, class _T2, class _D2>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x == __y);}
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {
+  return !(__x == __y);
+}
 #endif
 
 template <class _T1, class _D1, class _T2, class _D2>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y)
-{
-    typedef typename unique_ptr<_T1, _D1>::pointer _P1;
-    typedef typename unique_ptr<_T2, _D2>::pointer _P2;
-    typedef typename common_type<_P1, _P2>::type _Vp;
-    return less<_Vp>()(__x.get(), __y.get());
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {
+  typedef typename unique_ptr<_T1, _D1>::pointer _P1;
+  typedef typename unique_ptr<_T2, _D2>::pointer _P2;
+  typedef typename common_type<_P1, _P2>::type _Vp;
+  return less<_Vp>()(__x.get(), __y.get());
 }
 
 template <class _T1, class _D1, class _T2, class _D2>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator> (const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return __y < __x;}
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {
+  return __y < __x;
+}
 
 template <class _T1, class _D1, class _T2, class _D2>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__y < __x);}
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {
+  return !(__y < __x);
+}
 
 template <class _T1, class _D1, class _T2, class _D2>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);}
-
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {
+  return !(__x < __y);
+}
 
 #if _LIBCPP_STD_VER >= 20
 template <class _T1, class _D1, class _T2, class _D2>
-requires three_way_comparable_with<typename unique_ptr<_T1, _D1>::pointer,
-                                   typename unique_ptr<_T2, _D2>::pointer>
+  requires three_way_comparable_with<typename unique_ptr<_T1, _D1>::pointer, typename unique_ptr<_T2, _D2>::pointer>
 _LIBCPP_HIDE_FROM_ABI
-compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer,
-                           typename unique_ptr<_T2, _D2>::pointer>
+compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer, typename unique_ptr<_T2, _D2>::pointer>
 operator<=>(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {
-   return compare_three_way()(__x.get(), __y.get());
+  return compare_three_way()(__x.get(), __y.get());
 }
 #endif
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
 operator==(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT {
   return !__x;
 }
 
 #if _LIBCPP_STD_VER <= 17
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT
-{
-    return !__x;
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT {
+  return !__x;
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT
-{
-    return static_cast<bool>(__x);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const unique_ptr<_T1, _D1>& __x, nullptr_t) _NOEXCEPT {
+  return static_cast<bool>(__x);
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT
-{
-    return static_cast<bool>(__x);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(nullptr_t, const unique_ptr<_T1, _D1>& __x) _NOEXCEPT {
+  return static_cast<bool>(__x);
 }
 #endif // _LIBCPP_STD_VER <= 17
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator<(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
   typedef typename unique_ptr<_T1, _D1>::pointer _P1;
   return less<_P1>()(__x.get(), nullptr);
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator<(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
   typedef typename unique_ptr<_T1, _D1>::pointer _P1;
   return less<_P1>()(nullptr, __x.get());
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator>(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
   return nullptr < __x;
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator>(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
   return __x < nullptr;
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator<=(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
   return !(nullptr < __x);
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator<=(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
   return !(__x < nullptr);
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator>=(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
   return !(__x < nullptr);
 }
 
 template <class _T1, class _D1>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator>=(nullptr_t, const unique_ptr<_T1, _D1>& __x) {
   return !(nullptr < __x);
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _T1, class _D1>
-  requires three_way_comparable<
-      typename unique_ptr<_T1, _D1>::pointer> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-      compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer>
+  requires three_way_comparable< typename unique_ptr<_T1, _D1>::pointer>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 compare_three_way_result_t<typename unique_ptr<_T1, _D1>::pointer>
 operator<=>(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
-   return compare_three_way()(__x.get(), static_cast<typename unique_ptr<_T1, _D1>::pointer>(nullptr));
+  return compare_three_way()(__x.get(), static_cast<typename unique_ptr<_T1, _D1>::pointer>(nullptr));
 }
 #endif
 
 #if _LIBCPP_STD_VER >= 14
 
-template<class _Tp>
-struct __unique_if
-{
-    typedef unique_ptr<_Tp> __unique_single;
+template <class _Tp>
+struct __unique_if {
+  typedef unique_ptr<_Tp> __unique_single;
 };
 
-template<class _Tp>
-struct __unique_if<_Tp[]>
-{
-    typedef unique_ptr<_Tp[]> __unique_array_unknown_bound;
+template <class _Tp>
+struct __unique_if<_Tp[]> {
+  typedef unique_ptr<_Tp[]> __unique_array_unknown_bound;
 };
 
-template<class _Tp, size_t _Np>
-struct __unique_if<_Tp[_Np]>
-{
-    typedef void __unique_array_known_bound;
+template <class _Tp, size_t _Np>
+struct __unique_if<_Tp[_Np]> {
+  typedef void __unique_array_known_bound;
 };
 
 template <class _Tp, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __unique_if<_Tp>::__unique_single
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __unique_if<_Tp>::__unique_single
 make_unique(_Args&&... __args) {
-  return unique_ptr<_Tp>(new _Tp(_VSTD::forward<_Args>(__args)...));
+  return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...));
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __unique_if<_Tp>::__unique_array_unknown_bound
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 typename __unique_if<_Tp>::__unique_array_unknown_bound
 make_unique(size_t __n) {
   typedef __remove_extent_t<_Tp> _Up;
   return unique_ptr<_Tp>(new _Up[__n]());
 }
 
-template<class _Tp, class... _Args>
-    typename __unique_if<_Tp>::__unique_array_known_bound
-    make_unique(_Args&&...) = delete;
+template <class _Tp, class... _Args>
+typename __unique_if<_Tp>::__unique_array_known_bound make_unique(_Args&&...) = delete;
 
 #endif // _LIBCPP_STD_VER >= 14
 
@@ -713,34 +660,34 @@ make_unique_for_overwrite(size_t __n) {
   return unique_ptr<_Tp>(new __remove_extent_t<_Tp>[__n]);
 }
 
-template<class _Tp, class... _Args>
+template <class _Tp, class... _Args>
 typename __unique_if<_Tp>::__unique_array_known_bound make_unique_for_overwrite(_Args&&...) = delete;
 
 #endif // _LIBCPP_STD_VER >= 20
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS hash;
 
 template <class _Tp, class _Dp>
 #ifdef _LIBCPP_CXX03_LANG
 struct _LIBCPP_TEMPLATE_VIS hash<unique_ptr<_Tp, _Dp> >
 #else
-struct _LIBCPP_TEMPLATE_VIS hash<__enable_hash_helper<
-    unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp, _Dp>::pointer> >
+struct _LIBCPP_TEMPLATE_VIS hash<__enable_hash_helper< unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp, _Dp>::pointer> >
 #endif
 {
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef unique_ptr<_Tp, _Dp> argument_type;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t               result_type;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef unique_ptr<_Tp, _Dp> argument_type;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const unique_ptr<_Tp, _Dp>& __ptr) const
-    {
-        typedef typename unique_ptr<_Tp, _Dp>::pointer pointer;
-        return hash<pointer>()(__ptr.get());
-    }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const unique_ptr<_Tp, _Dp>& __ptr) const {
+    typedef typename unique_ptr<_Tp, _Dp>::pointer pointer;
+    return hash<pointer>()(__ptr.get());
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_UNIQUE_PTR_H
diff --git a/third_party/libcxx/__memory/uses_allocator.h b/third_party/libcxx/__memory/uses_allocator.h
index f82ac1796..84310c3fa 100644
--- a/third_party/libcxx/__memory/uses_allocator.h
+++ b/third_party/libcxx/__memory/uses_allocator.h
@@ -21,33 +21,26 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct __has_allocator_type
-{
+struct __has_allocator_type {
 private:
-    template <class _Up> static false_type __test(...);
-    template <class _Up> static true_type __test(typename _Up::allocator_type* = 0);
+  template <class _Up>
+  static false_type __test(...);
+  template <class _Up>
+  static true_type __test(typename _Up::allocator_type* = 0);
+
 public:
-    static const bool value = decltype(__test<_Tp>(0))::value;
+  static const bool value = decltype(__test<_Tp>(0))::value;
 };
 
 template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
-struct __uses_allocator
-    : public integral_constant<bool,
-        is_convertible<_Alloc, typename _Tp::allocator_type>::value>
-{
+struct __uses_allocator : public integral_constant<bool, is_convertible<_Alloc, typename _Tp::allocator_type>::value> {
 };
 
 template <class _Tp, class _Alloc>
-struct __uses_allocator<_Tp, _Alloc, false>
-    : public false_type
-{
-};
+struct __uses_allocator<_Tp, _Alloc, false> : public false_type {};
 
 template <class _Tp, class _Alloc>
-struct _LIBCPP_TEMPLATE_VIS uses_allocator
-    : public __uses_allocator<_Tp, _Alloc>
-{
-};
+struct _LIBCPP_TEMPLATE_VIS uses_allocator : public __uses_allocator<_Tp, _Alloc> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp, class _Alloc>
diff --git a/third_party/libcxx/__memory/uses_allocator_construction.h b/third_party/libcxx/__memory/uses_allocator_construction.h
index c6eccd2e1..5e5819d4c 100644
--- a/third_party/libcxx/__memory/uses_allocator_construction.h
+++ b/third_party/libcxx/__memory/uses_allocator_construction.h
@@ -12,6 +12,7 @@
 #include <__config>
 #include <__memory/construct_at.h>
 #include <__memory/uses_allocator.h>
+#include <__tuple/tuple_like_no_subrange.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cv.h>
@@ -23,6 +24,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
@@ -33,15 +37,19 @@ inline constexpr bool __is_std_pair = false;
 template <class _Type1, class _Type2>
 inline constexpr bool __is_std_pair<pair<_Type1, _Type2>> = true;
 
-template <class _Type, class _Alloc, class... _Args, __enable_if_t<!__is_std_pair<_Type>, int> = 0>
+template <class _Tp>
+inline constexpr bool __is_cv_std_pair = __is_std_pair<remove_cv_t<_Tp>>;
+
+template <class _Type, class _Alloc, class... _Args, __enable_if_t<!__is_cv_std_pair<_Type>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr auto
 __uses_allocator_construction_args(const _Alloc& __alloc, _Args&&... __args) noexcept {
-  if constexpr (!uses_allocator_v<_Type, _Alloc> && is_constructible_v<_Type, _Args...>) {
+  if constexpr (!uses_allocator_v<remove_cv_t<_Type>, _Alloc> && is_constructible_v<_Type, _Args...>) {
     return std::forward_as_tuple(std::forward<_Args>(__args)...);
-  } else if constexpr (uses_allocator_v<_Type, _Alloc> &&
+  } else if constexpr (uses_allocator_v<remove_cv_t<_Type>, _Alloc> &&
                        is_constructible_v<_Type, allocator_arg_t, const _Alloc&, _Args...>) {
     return tuple<allocator_arg_t, const _Alloc&, _Args&&...>(allocator_arg, __alloc, std::forward<_Args>(__args)...);
-  } else if constexpr (uses_allocator_v<_Type, _Alloc> && is_constructible_v<_Type, _Args..., const _Alloc&>) {
+  } else if constexpr (uses_allocator_v<remove_cv_t<_Type>, _Alloc> &&
+                       is_constructible_v<_Type, _Args..., const _Alloc&>) {
     return std::forward_as_tuple(std::forward<_Args>(__args)..., __alloc);
   } else {
     static_assert(
@@ -49,7 +57,7 @@ __uses_allocator_construction_args(const _Alloc& __alloc, _Args&&... __args) noe
   }
 }
 
-template <class _Pair, class _Alloc, class _Tuple1, class _Tuple2, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Tuple1, class _Tuple2, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr auto __uses_allocator_construction_args(
     const _Alloc& __alloc, piecewise_construct_t, _Tuple1&& __x, _Tuple2&& __y) noexcept {
   return std::make_tuple(
@@ -68,12 +76,12 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto __uses_allocator_construction_args(
           std::forward<_Tuple2>(__y)));
 }
 
-template <class _Pair, class _Alloc, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr auto __uses_allocator_construction_args(const _Alloc& __alloc) noexcept {
   return std::__uses_allocator_construction_args<_Pair>(__alloc, piecewise_construct, tuple<>{}, tuple<>{});
 }
 
-template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr auto
 __uses_allocator_construction_args(const _Alloc& __alloc, _Up&& __u, _Vp&& __v) noexcept {
   return std::__uses_allocator_construction_args<_Pair>(
@@ -84,7 +92,7 @@ __uses_allocator_construction_args(const _Alloc& __alloc, _Up&& __u, _Vp&& __v)
 }
 
 #  if _LIBCPP_STD_VER >= 23
-template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr auto
 __uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>& __pair) noexcept {
   return std::__uses_allocator_construction_args<_Pair>(
@@ -92,14 +100,14 @@ __uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>& __pair
 }
 #  endif
 
-template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr auto
 __uses_allocator_construction_args(const _Alloc& __alloc, const pair<_Up, _Vp>& __pair) noexcept {
   return std::__uses_allocator_construction_args<_Pair>(
       __alloc, piecewise_construct, std::forward_as_tuple(__pair.first), std::forward_as_tuple(__pair.second));
 }
 
-template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr auto
 __uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>&& __pair) noexcept {
   return std::__uses_allocator_construction_args<_Pair>(
@@ -110,7 +118,7 @@ __uses_allocator_construction_args(const _Alloc& __alloc, pair<_Up, _Vp>&& __pai
 }
 
 #  if _LIBCPP_STD_VER >= 23
-template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_std_pair<_Pair>, int> = 0>
+template <class _Pair, class _Alloc, class _Up, class _Vp, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr auto
 __uses_allocator_construction_args(const _Alloc& __alloc, const pair<_Up, _Vp>&& __pair) noexcept {
   return std::__uses_allocator_construction_args<_Pair>(
@@ -119,6 +127,16 @@ __uses_allocator_construction_args(const _Alloc& __alloc, const pair<_Up, _Vp>&&
       std::forward_as_tuple(std::get<0>(std::move(__pair))),
       std::forward_as_tuple(std::get<1>(std::move(__pair))));
 }
+
+template <class _Pair, class _Alloc, __pair_like_no_subrange _PairLike, __enable_if_t<__is_cv_std_pair<_Pair>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr auto
+__uses_allocator_construction_args(const _Alloc& __alloc, _PairLike&& __p) noexcept {
+  return std::__uses_allocator_construction_args<_Pair>(
+      __alloc,
+      piecewise_construct,
+      std::forward_as_tuple(std::get<0>(std::forward<_PairLike>(__p))),
+      std::forward_as_tuple(std::get<1>(std::forward<_PairLike>(__p))));
+}
 #  endif
 
 namespace __uses_allocator_detail {
@@ -136,42 +154,48 @@ template <class _Tp>
 inline constexpr bool __convertible_to_const_pair_ref =
     decltype(__uses_allocator_detail::__convertible_to_const_pair_ref_impl<_Tp>(0))::value;
 
+#  if _LIBCPP_STD_VER >= 23
+template <class _Tp, class _Up>
+inline constexpr bool __uses_allocator_constraints =
+    __is_cv_std_pair<_Tp> && !__pair_like_no_subrange<_Up> && !__convertible_to_const_pair_ref<_Up>;
+#  else
+template <class _Tp, class _Up>
+inline constexpr bool __uses_allocator_constraints = __is_cv_std_pair<_Tp> && !__convertible_to_const_pair_ref<_Up>;
+#  endif
+
 } // namespace __uses_allocator_detail
 
-template <
-    class _Pair,
-    class _Alloc,
-    class _Type,
-    __enable_if_t<__is_std_pair<_Pair> && !__uses_allocator_detail::__convertible_to_const_pair_ref<_Type>, int> = 0>
+template < class _Pair,
+           class _Alloc,
+           class _Type,
+           __enable_if_t<__uses_allocator_detail::__uses_allocator_constraints<_Pair, _Type>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr auto
 __uses_allocator_construction_args(const _Alloc& __alloc, _Type&& __value) noexcept;
 
 template <class _Type, class _Alloc, class... _Args>
 _LIBCPP_HIDE_FROM_ABI constexpr _Type __make_obj_using_allocator(const _Alloc& __alloc, _Args&&... __args);
 
-template <class _Pair,
-          class _Alloc,
-          class _Type,
-          __enable_if_t<__is_std_pair<_Pair> && !__uses_allocator_detail::__convertible_to_const_pair_ref<_Type>, int>>
+template < class _Pair,
+           class _Alloc,
+           class _Type,
+           __enable_if_t< __uses_allocator_detail::__uses_allocator_constraints<_Pair, _Type>, int>>
 _LIBCPP_HIDE_FROM_ABI constexpr auto
 __uses_allocator_construction_args(const _Alloc& __alloc, _Type&& __value) noexcept {
   struct __pair_constructor {
     using _PairMutable = remove_cv_t<_Pair>;
 
-    _LIBCPP_HIDE_FROM_ABI constexpr auto __do_construct(const _PairMutable& __pair) const {
+    _LIBCPP_HIDDEN constexpr auto __do_construct(const _PairMutable& __pair) const {
       return std::__make_obj_using_allocator<_PairMutable>(__alloc_, __pair);
     }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr auto __do_construct(_PairMutable&& __pair) const {
+    _LIBCPP_HIDDEN constexpr auto __do_construct(_PairMutable&& __pair) const {
       return std::__make_obj_using_allocator<_PairMutable>(__alloc_, std::move(__pair));
     }
 
     const _Alloc& __alloc_;
     _Type& __value_;
 
-    _LIBCPP_HIDE_FROM_ABI constexpr operator _PairMutable() const {
-      return __do_construct(std::forward<_Type>(this->__value_));
-    }
+    _LIBCPP_HIDDEN constexpr operator _PairMutable() const { return __do_construct(std::forward<_Type>(__value_)); }
   };
 
   return std::make_tuple(__pair_constructor{__alloc, __value});
@@ -218,4 +242,6 @@ uninitialized_construct_using_allocator(_Type* __ptr, const _Alloc& __alloc, _Ar
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___MEMORY_USES_ALLOCATOR_CONSTRUCTION_H
diff --git a/third_party/libcxx/__memory/voidify.h b/third_party/libcxx/__memory/voidify.h
index 39e10343f..dbd083bd8 100644
--- a/third_party/libcxx/__memory/voidify.h
+++ b/third_party/libcxx/__memory/voidify.h
@@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <typename _Tp>
 _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void* __voidify(_Tp& __from) {
   // Cast away cv-qualifiers to allow modifying elements of a range through const iterators.
-  return const_cast<void*>(static_cast<const volatile void*>(_VSTD::addressof(__from)));
+  return const_cast<void*>(static_cast<const volatile void*>(std::addressof(__from)));
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__memory_resource/memory_resource.h b/third_party/libcxx/__memory_resource/memory_resource.h
index 4f0e4e48e..ea85e50cd 100644
--- a/third_party/libcxx/__memory_resource/memory_resource.h
+++ b/third_party/libcxx/__memory_resource/memory_resource.h
@@ -10,6 +10,7 @@
 #define _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H
 
 #include <__config>
+#include <__fwd/memory_resource.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -24,15 +25,14 @@ namespace pmr {
 
 // [mem.res.class]
 
-class _LIBCPP_TYPE_VIS memory_resource {
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI memory_resource {
   static const size_t __max_align = alignof(max_align_t);
 
 public:
   virtual ~memory_resource();
 
-  _LIBCPP_NODISCARD_AFTER_CXX17
-  [[using __gnu__: __returns_nonnull__, __alloc_size__(2), __alloc_align__(3)]] _LIBCPP_HIDE_FROM_ABI void*
-  allocate(size_t __bytes, size_t __align = __max_align) {
+  [[nodiscard]] [[using __gnu__: __returns_nonnull__, __alloc_size__(2), __alloc_align__(3)]]
+  _LIBCPP_HIDE_FROM_ABI void* allocate(size_t __bytes, size_t __align = __max_align) {
     return do_allocate(__bytes, __align);
   }
 
@@ -51,20 +51,33 @@ private:
 
 // [mem.res.eq]
 
-inline _LIBCPP_HIDE_FROM_ABI bool operator==(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
+inline _LIBCPP_AVAILABILITY_PMR _LIBCPP_HIDE_FROM_ABI bool
+operator==(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
   return &__lhs == &__rhs || __lhs.is_equal(__rhs);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
+#  if _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_AVAILABILITY_PMR _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const memory_resource& __lhs, const memory_resource& __rhs) noexcept {
   return !(__lhs == __rhs);
 }
 
+#  endif
+
 // [mem.res.global]
 
-[[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS memory_resource* get_default_resource() noexcept;
-[[__gnu__::__returns_nonnull__]] _LIBCPP_FUNC_VIS memory_resource* set_default_resource(memory_resource*) noexcept;
-[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* new_delete_resource() noexcept;
-[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_FUNC_VIS memory_resource* null_memory_resource() noexcept;
+[[__gnu__::__returns_nonnull__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI memory_resource*
+get_default_resource() noexcept;
+
+[[__gnu__::__returns_nonnull__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI memory_resource*
+set_default_resource(memory_resource*) noexcept;
+
+[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI memory_resource*
+new_delete_resource() noexcept;
+
+[[using __gnu__: __returns_nonnull__, __const__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI memory_resource*
+null_memory_resource() noexcept;
 
 } // namespace pmr
 
diff --git a/third_party/libcxx/__memory_resource/monotonic_buffer_resource.h b/third_party/libcxx/__memory_resource/monotonic_buffer_resource.h
index f60d23e25..f45b30fdb 100644
--- a/third_party/libcxx/__memory_resource/monotonic_buffer_resource.h
+++ b/third_party/libcxx/__memory_resource/monotonic_buffer_resource.h
@@ -26,7 +26,7 @@ namespace pmr {
 
 // [mem.res.monotonic.buffer]
 
-class _LIBCPP_TYPE_VIS monotonic_buffer_resource : public memory_resource {
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI monotonic_buffer_resource : public memory_resource {
   static const size_t __default_buffer_capacity  = 1024;
   static const size_t __default_buffer_alignment = 16;
 
diff --git a/third_party/libcxx/__memory_resource/polymorphic_allocator.h b/third_party/libcxx/__memory_resource/polymorphic_allocator.h
index f36e2c5af..a71096d3e 100644
--- a/third_party/libcxx/__memory_resource/polymorphic_allocator.h
+++ b/third_party/libcxx/__memory_resource/polymorphic_allocator.h
@@ -11,12 +11,12 @@
 
 #include <__assert>
 #include <__config>
+#include <__fwd/pair.h>
 #include <__memory_resource/memory_resource.h>
 #include <__utility/exception_guard.h>
 #include <cstddef>
 #include <limits>
 #include <new>
-#include <stdexcept>
 #include <tuple>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -39,7 +39,7 @@ template <class _ValueType
           = byte
 #  endif
           >
-class _LIBCPP_TEMPLATE_VIS polymorphic_allocator {
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_TEMPLATE_VIS polymorphic_allocator {
 
 public:
   using value_type = _ValueType;
@@ -60,7 +60,7 @@ public:
 
   // [mem.poly.allocator.mem]
 
-  _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _ValueType* allocate(size_t __n) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ValueType* allocate(size_t __n) {
     if (__n > __max_size()) {
       __throw_bad_array_new_length();
     }
@@ -68,7 +68,10 @@ public:
   }
 
   _LIBCPP_HIDE_FROM_ABI void deallocate(_ValueType* __p, size_t __n) {
-    _LIBCPP_ASSERT(__n <= __max_size(), "deallocate called for size which exceeds max_size()");
+    _LIBCPP_ASSERT_VALID_DEALLOCATION(
+        __n <= __max_size(),
+        "deallocate() called for a size which exceeds max_size(), leading to a memory leak "
+        "(the argument will overflow and result in too few objects being deleted)");
     __res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
   }
 
@@ -207,12 +210,16 @@ operator==(const polymorphic_allocator<_Tp>& __lhs, const polymorphic_allocator<
   return *__lhs.resource() == *__rhs.resource();
 }
 
+#  if _LIBCPP_STD_VER <= 17
+
 template <class _Tp, class _Up>
 inline _LIBCPP_HIDE_FROM_ABI bool
 operator!=(const polymorphic_allocator<_Tp>& __lhs, const polymorphic_allocator<_Up>& __rhs) noexcept {
   return !(__lhs == __rhs);
 }
 
+#  endif
+
 } // namespace pmr
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__memory_resource/pool_options.h b/third_party/libcxx/__memory_resource/pool_options.h
index 6ddd89987..442959836 100644
--- a/third_party/libcxx/__memory_resource/pool_options.h
+++ b/third_party/libcxx/__memory_resource/pool_options.h
@@ -24,7 +24,7 @@ namespace pmr {
 
 // [mem.res.pool.options]
 
-struct _LIBCPP_TYPE_VIS pool_options {
+struct _LIBCPP_EXPORTED_FROM_ABI pool_options {
   size_t max_blocks_per_chunk        = 0;
   size_t largest_required_pool_block = 0;
 };
diff --git a/third_party/libcxx/__memory_resource/synchronized_pool_resource.h b/third_party/libcxx/__memory_resource/synchronized_pool_resource.h
index 576a29a4d..50a673c28 100644
--- a/third_party/libcxx/__memory_resource/synchronized_pool_resource.h
+++ b/third_party/libcxx/__memory_resource/synchronized_pool_resource.h
@@ -14,9 +14,7 @@
 #include <__memory_resource/pool_options.h>
 #include <__memory_resource/unsynchronized_pool_resource.h>
 #include <cstddef>
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-#  include <mutex>
-#endif
+#include <mutex>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -30,7 +28,7 @@ namespace pmr {
 
 // [mem.res.pool.overview]
 
-class _LIBCPP_TYPE_VIS synchronized_pool_resource : public memory_resource {
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI synchronized_pool_resource : public memory_resource {
 public:
   _LIBCPP_HIDE_FROM_ABI synchronized_pool_resource(const pool_options& __opts, memory_resource* __upstream)
       : __unsync_(__opts, __upstream) {}
diff --git a/third_party/libcxx/__memory_resource/unsynchronized_pool_resource.h b/third_party/libcxx/__memory_resource/unsynchronized_pool_resource.h
index 26e4bdf69..783db8426 100644
--- a/third_party/libcxx/__memory_resource/unsynchronized_pool_resource.h
+++ b/third_party/libcxx/__memory_resource/unsynchronized_pool_resource.h
@@ -27,7 +27,7 @@ namespace pmr {
 
 // [mem.res.pool.overview]
 
-class _LIBCPP_TYPE_VIS unsynchronized_pool_resource : public memory_resource {
+class _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI unsynchronized_pool_resource : public memory_resource {
   class __fixed_pool;
 
   class __adhoc_pool {
diff --git a/third_party/libcxx/__mutex/lock_guard.h b/third_party/libcxx/__mutex/lock_guard.h
index c075512fb..ef56896be 100644
--- a/third_party/libcxx/__mutex/lock_guard.h
+++ b/third_party/libcxx/__mutex/lock_guard.h
@@ -16,8 +16,6 @@
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_HAS_NO_THREADS
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Mutex>
@@ -29,18 +27,17 @@ private:
   mutex_type& __m_;
 
 public:
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI explicit lock_guard(mutex_type& __m)
-      _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
+  _LIBCPP_NODISCARD
+  _LIBCPP_HIDE_FROM_ABI explicit lock_guard(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
       : __m_(__m) {
     __m_.lock();
   }
 
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI lock_guard(mutex_type& __m, adopt_lock_t)
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI lock_guard(mutex_type& __m, adopt_lock_t)
       _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
       : __m_(__m) {}
   _LIBCPP_HIDE_FROM_ABI ~lock_guard() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) { __m_.unlock(); }
 
-private:
   lock_guard(lock_guard const&)            = delete;
   lock_guard& operator=(lock_guard const&) = delete;
 };
@@ -48,6 +45,4 @@ _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(lock_guard);
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_HAS_NO_THREADS
-
 #endif // _LIBCPP___MUTEX_LOCK_GUARD_H
diff --git a/third_party/libcxx/__mutex/mutex.h b/third_party/libcxx/__mutex/mutex.h
index 819d4f37d..1ed015471 100644
--- a/third_party/libcxx/__mutex/mutex.h
+++ b/third_party/libcxx/__mutex/mutex.h
@@ -10,8 +10,8 @@
 #define _LIBCPP___MUTEX_MUTEX_H
 
 #include <__config>
-#include <__threading_support>
-#include <__type_traits/is_nothrow_default_constructible.h>
+#include <__thread/support.h>
+#include <__type_traits/is_nothrow_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -21,7 +21,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TYPE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex {
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("mutex")) mutex {
   __libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
 
 public:
diff --git a/third_party/libcxx/__mutex/once_flag.h b/third_party/libcxx/__mutex/once_flag.h
new file mode 100644
index 000000000..9d7baecbc
--- /dev/null
+++ b/third_party/libcxx/__mutex/once_flag.h
@@ -0,0 +1,159 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MUTEX_ONCE_FLAG_H
+#define _LIBCPP___MUTEX_ONCE_FLAG_H
+
+#include <__config>
+#include <__functional/invoke.h>
+#include <__memory/shared_ptr.h> // __libcpp_acquire_load
+#include <__tuple/tuple_indices.h>
+#include <__tuple/tuple_size.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <cstdint>
+#ifndef _LIBCPP_CXX03_LANG
+#  include <tuple>
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct _LIBCPP_TEMPLATE_VIS once_flag;
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Callable, class... _Args>
+_LIBCPP_HIDE_FROM_ABI void call_once(once_flag&, _Callable&&, _Args&&...);
+
+#else // _LIBCPP_CXX03_LANG
+
+template <class _Callable>
+_LIBCPP_HIDE_FROM_ABI void call_once(once_flag&, _Callable&);
+
+template <class _Callable>
+_LIBCPP_HIDE_FROM_ABI void call_once(once_flag&, const _Callable&);
+
+#endif // _LIBCPP_CXX03_LANG
+
+struct _LIBCPP_TEMPLATE_VIS once_flag {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR once_flag() _NOEXCEPT : __state_(_Unset) {}
+  once_flag(const once_flag&)            = delete;
+  once_flag& operator=(const once_flag&) = delete;
+
+#if defined(_LIBCPP_ABI_MICROSOFT)
+  typedef uintptr_t _State_type;
+#else
+  typedef unsigned long _State_type;
+#endif
+
+  static const _State_type _Unset    = 0;
+  static const _State_type _Pending  = 1;
+  static const _State_type _Complete = ~_State_type(0);
+
+private:
+  _State_type __state_;
+
+#ifndef _LIBCPP_CXX03_LANG
+  template <class _Callable, class... _Args>
+  friend void call_once(once_flag&, _Callable&&, _Args&&...);
+#else  // _LIBCPP_CXX03_LANG
+  template <class _Callable>
+  friend void call_once(once_flag&, _Callable&);
+
+  template <class _Callable>
+  friend void call_once(once_flag&, const _Callable&);
+#endif // _LIBCPP_CXX03_LANG
+};
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Fp>
+class __call_once_param {
+  _Fp& __f_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit __call_once_param(_Fp& __f) : __f_(__f) {}
+
+  _LIBCPP_HIDE_FROM_ABI void operator()() {
+    typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
+    __execute(_Index());
+  }
+
+private:
+  template <size_t... _Indices>
+  _LIBCPP_HIDE_FROM_ABI void __execute(__tuple_indices<_Indices...>) {
+    std::__invoke(std::get<0>(std::move(__f_)), std::get<_Indices>(std::move(__f_))...);
+  }
+};
+
+#else
+
+template <class _Fp>
+class __call_once_param {
+  _Fp& __f_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit __call_once_param(_Fp& __f) : __f_(__f) {}
+
+  _LIBCPP_HIDE_FROM_ABI void operator()() { __f_(); }
+};
+
+#endif
+
+template <class _Fp>
+void _LIBCPP_HIDE_FROM_ABI __call_once_proxy(void* __vp) {
+  __call_once_param<_Fp>* __p = static_cast<__call_once_param<_Fp>*>(__vp);
+  (*__p)();
+}
+
+_LIBCPP_EXPORTED_FROM_ABI void __call_once(volatile once_flag::_State_type&, void*, void (*)(void*));
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Callable, class... _Args>
+inline _LIBCPP_HIDE_FROM_ABI void call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args) {
+  if (__libcpp_acquire_load(&__flag.__state_) != once_flag::_Complete) {
+    typedef tuple<_Callable&&, _Args&&...> _Gp;
+    _Gp __f(std::forward<_Callable>(__func), std::forward<_Args>(__args)...);
+    __call_once_param<_Gp> __p(__f);
+    std::__call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>);
+  }
+}
+
+#else // _LIBCPP_CXX03_LANG
+
+template <class _Callable>
+inline _LIBCPP_HIDE_FROM_ABI void call_once(once_flag& __flag, _Callable& __func) {
+  if (__libcpp_acquire_load(&__flag.__state_) != once_flag::_Complete) {
+    __call_once_param<_Callable> __p(__func);
+    std::__call_once(__flag.__state_, &__p, &__call_once_proxy<_Callable>);
+  }
+}
+
+template <class _Callable>
+inline _LIBCPP_HIDE_FROM_ABI void call_once(once_flag& __flag, const _Callable& __func) {
+  if (__libcpp_acquire_load(&__flag.__state_) != once_flag::_Complete) {
+    __call_once_param<const _Callable> __p(__func);
+    std::__call_once(__flag.__state_, &__p, &__call_once_proxy<const _Callable>);
+  }
+}
+
+#endif // _LIBCPP_CXX03_LANG
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___MUTEX_ONCE_FLAG_H
diff --git a/third_party/libcxx/__mutex/tag_types.h b/third_party/libcxx/__mutex/tag_types.h
index 5242fd666..2b2dd58ee 100644
--- a/third_party/libcxx/__mutex/tag_types.h
+++ b/third_party/libcxx/__mutex/tag_types.h
@@ -15,34 +15,30 @@
 #  pragma GCC system_header
 #endif
 
-#ifndef _LIBCPP_HAS_NO_THREADS
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct _LIBCPP_TYPE_VIS defer_lock_t {
+struct _LIBCPP_EXPORTED_FROM_ABI defer_lock_t {
   explicit defer_lock_t() = default;
 };
 
-struct _LIBCPP_TYPE_VIS try_to_lock_t {
+struct _LIBCPP_EXPORTED_FROM_ABI try_to_lock_t {
   explicit try_to_lock_t() = default;
 };
 
-struct _LIBCPP_TYPE_VIS adopt_lock_t {
+struct _LIBCPP_EXPORTED_FROM_ABI adopt_lock_t {
   explicit adopt_lock_t() = default;
 };
 
-#  if _LIBCPP_STD_VER >= 17
+#if _LIBCPP_STD_VER >= 17
 inline constexpr defer_lock_t defer_lock   = defer_lock_t();
 inline constexpr try_to_lock_t try_to_lock = try_to_lock_t();
 inline constexpr adopt_lock_t adopt_lock   = adopt_lock_t();
-#  elif !defined(_LIBCPP_CXX03_LANG)
+#elif !defined(_LIBCPP_CXX03_LANG)
 constexpr defer_lock_t defer_lock   = defer_lock_t();
 constexpr try_to_lock_t try_to_lock = try_to_lock_t();
 constexpr adopt_lock_t adopt_lock   = adopt_lock_t();
-#  endif
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_HAS_NO_THREADS
-
 #endif // _LIBCPP___MUTEX_TAG_TYPES_H
diff --git a/third_party/libcxx/__mutex/unique_lock.h b/third_party/libcxx/__mutex/unique_lock.h
index c27ce4b24..4a616ba51 100644
--- a/third_party/libcxx/__mutex/unique_lock.h
+++ b/third_party/libcxx/__mutex/unique_lock.h
@@ -36,26 +36,28 @@ private:
   bool __owns_;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
-  _LIBCPP_HIDE_FROM_ABI explicit unique_lock(mutex_type& __m) : __m_(std::addressof(__m)), __owns_(true) {
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI explicit unique_lock(mutex_type& __m)
+      : __m_(std::addressof(__m)), __owns_(true) {
     __m_->lock();
   }
 
-  _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
       : __m_(std::addressof(__m)),
         __owns_(false) {}
 
-  _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, try_to_lock_t)
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, try_to_lock_t)
       : __m_(std::addressof(__m)), __owns_(__m.try_lock()) {}
 
-  _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, adopt_lock_t) : __m_(std::addressof(__m)), __owns_(true) {}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, adopt_lock_t)
+      : __m_(std::addressof(__m)), __owns_(true) {}
 
   template <class _Clock, class _Duration>
-  _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __t)
       : __m_(std::addressof(__m)), __owns_(__m.try_lock_until(__t)) {}
 
   template <class _Rep, class _Period>
-  _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __d)
       : __m_(std::addressof(__m)), __owns_(__m.try_lock_for(__d)) {}
 
   _LIBCPP_HIDE_FROM_ABI ~unique_lock() {
@@ -66,7 +68,9 @@ public:
   unique_lock(unique_lock const&)            = delete;
   unique_lock& operator=(unique_lock const&) = delete;
 
-  _LIBCPP_HIDE_FROM_ABI unique_lock(unique_lock&& __u) _NOEXCEPT : __m_(__u.__m_), __owns_(__u.__owns_) {
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI unique_lock(unique_lock&& __u) _NOEXCEPT
+      : __m_(__u.__m_),
+        __owns_(__u.__owns_) {
     __u.__m_    = nullptr;
     __u.__owns_ = false;
   }
diff --git a/third_party/libcxx/__node_handle b/third_party/libcxx/__node_handle
index d9c2374d3..d0b35bfd1 100644
--- a/third_party/libcxx/__node_handle
+++ b/third_party/libcxx/__node_handle
@@ -68,6 +68,9 @@ public:
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
@@ -76,179 +79,131 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _NodeType, class _Alloc>
 struct __generic_container_node_destructor;
 
-template <class _NodeType, class _Alloc,
-          template <class, class> class _MapOrSetSpecifics>
+template <class _NodeType, class _Alloc, template <class, class> class _MapOrSetSpecifics>
 class _LIBCPP_TEMPLATE_VIS __basic_node_handle
-    : public _MapOrSetSpecifics<
-          _NodeType,
-          __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>
-{
-    template <class _Tp, class _Compare, class _Allocator>
-        friend class __tree;
-    template <class _Tp, class _Hash, class _Equal, class _Allocator>
-        friend class __hash_table;
-    friend struct _MapOrSetSpecifics<
-        _NodeType, __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>;
+    : public _MapOrSetSpecifics< _NodeType, __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>> {
+  template <class _Tp, class _Compare, class _Allocator>
+  friend class __tree;
+  template <class _Tp, class _Hash, class _Equal, class _Allocator>
+  friend class __hash_table;
+  friend struct _MapOrSetSpecifics< _NodeType, __basic_node_handle<_NodeType, _Alloc, _MapOrSetSpecifics>>;
 
-    typedef allocator_traits<_Alloc> __alloc_traits;
-    typedef __rebind_pointer_t<typename __alloc_traits::void_pointer,
-                                      _NodeType>
-        __node_pointer_type;
+  typedef allocator_traits<_Alloc> __alloc_traits;
+  typedef __rebind_pointer_t<typename __alloc_traits::void_pointer, _NodeType> __node_pointer_type;
 
 public:
-    typedef _Alloc allocator_type;
+  typedef _Alloc allocator_type;
 
 private:
-    __node_pointer_type __ptr_ = nullptr;
-    optional<allocator_type> __alloc_;
+  __node_pointer_type __ptr_ = nullptr;
+  optional<allocator_type> __alloc_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __release_ptr()
-    {
-        __ptr_ = nullptr;
-        __alloc_ = _VSTD::nullopt;
-    }
+  _LIBCPP_HIDE_FROM_ABI void __release_ptr() {
+    __ptr_   = nullptr;
+    __alloc_ = std::nullopt;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __destroy_node_pointer()
-    {
-        if (__ptr_ != nullptr)
-        {
-            typedef typename __allocator_traits_rebind<
-                allocator_type, _NodeType>::type __node_alloc_type;
-            __node_alloc_type __alloc(*__alloc_);
-            __generic_container_node_destructor<_NodeType, __node_alloc_type>(
-                __alloc, true)(__ptr_);
-            __ptr_ = nullptr;
-        }
+  _LIBCPP_HIDE_FROM_ABI void __destroy_node_pointer() {
+    if (__ptr_ != nullptr) {
+      typedef typename __allocator_traits_rebind< allocator_type, _NodeType>::type __node_alloc_type;
+      __node_alloc_type __alloc(*__alloc_);
+      __generic_container_node_destructor<_NodeType, __node_alloc_type>(__alloc, true)(__ptr_);
+      __ptr_ = nullptr;
     }
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __basic_node_handle(__node_pointer_type __ptr,
-                        allocator_type const& __alloc)
-            : __ptr_(__ptr), __alloc_(__alloc)
-    {
-    }
+  _LIBCPP_HIDE_FROM_ABI __basic_node_handle(__node_pointer_type __ptr, allocator_type const& __alloc)
+      : __ptr_(__ptr), __alloc_(__alloc) {}
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __basic_node_handle() = default;
+  _LIBCPP_HIDE_FROM_ABI __basic_node_handle() = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __basic_node_handle(__basic_node_handle&& __other) noexcept
-            : __ptr_(__other.__ptr_),
-              __alloc_(_VSTD::move(__other.__alloc_))
-    {
-        __other.__ptr_ = nullptr;
-        __other.__alloc_ = _VSTD::nullopt;
-    }
+  _LIBCPP_HIDE_FROM_ABI __basic_node_handle(__basic_node_handle&& __other) noexcept
+      : __ptr_(__other.__ptr_), __alloc_(std::move(__other.__alloc_)) {
+    __other.__ptr_   = nullptr;
+    __other.__alloc_ = std::nullopt;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __basic_node_handle& operator=(__basic_node_handle&& __other)
-    {
-        _LIBCPP_ASSERT(
-            __alloc_ == _VSTD::nullopt ||
-            __alloc_traits::propagate_on_container_move_assignment::value ||
+  _LIBCPP_HIDE_FROM_ABI __basic_node_handle& operator=(__basic_node_handle&& __other) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __alloc_ == std::nullopt || __alloc_traits::propagate_on_container_move_assignment::value ||
             __alloc_ == __other.__alloc_,
-            "node_type with incompatible allocator passed to "
-            "node_type::operator=(node_type&&)");
+        "node_type with incompatible allocator passed to "
+        "node_type::operator=(node_type&&)");
 
-        __destroy_node_pointer();
-        __ptr_ = __other.__ptr_;
+    __destroy_node_pointer();
+    __ptr_ = __other.__ptr_;
 
-        if (__alloc_traits::propagate_on_container_move_assignment::value ||
-            __alloc_ == _VSTD::nullopt)
-            __alloc_ = _VSTD::move(__other.__alloc_);
+    if (__alloc_traits::propagate_on_container_move_assignment::value || __alloc_ == std::nullopt)
+      __alloc_ = std::move(__other.__alloc_);
 
-        __other.__ptr_ = nullptr;
-        __other.__alloc_ = _VSTD::nullopt;
+    __other.__ptr_   = nullptr;
+    __other.__alloc_ = std::nullopt;
 
-        return *this;
-    }
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const { return *__alloc_; }
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const { return *__alloc_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const { return __ptr_ != nullptr; }
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return __ptr_ != nullptr; }
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool empty() const { return __ptr_ == nullptr; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool empty() const { return __ptr_ == nullptr; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(__basic_node_handle& __other) noexcept(
-        __alloc_traits::propagate_on_container_swap::value ||
-        __alloc_traits::is_always_equal::value)
-    {
-        using _VSTD::swap;
-        swap(__ptr_, __other.__ptr_);
-        if (__alloc_traits::propagate_on_container_swap::value ||
-            __alloc_ == _VSTD::nullopt || __other.__alloc_ == _VSTD::nullopt)
-            swap(__alloc_, __other.__alloc_);
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(__basic_node_handle& __other) noexcept(
+      __alloc_traits::propagate_on_container_swap::value || __alloc_traits::is_always_equal::value) {
+    using std::swap;
+    swap(__ptr_, __other.__ptr_);
+    if (__alloc_traits::propagate_on_container_swap::value || __alloc_ == std::nullopt ||
+        __other.__alloc_ == std::nullopt)
+      swap(__alloc_, __other.__alloc_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    friend void swap(__basic_node_handle& __a, __basic_node_handle& __b)
-        noexcept(noexcept(__a.swap(__b))) { __a.swap(__b); }
+  _LIBCPP_HIDE_FROM_ABI friend void
+  swap(__basic_node_handle& __a, __basic_node_handle& __b) noexcept(noexcept(__a.swap(__b))) {
+    __a.swap(__b);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~__basic_node_handle()
-    {
-        __destroy_node_pointer();
-    }
+  _LIBCPP_HIDE_FROM_ABI ~__basic_node_handle() { __destroy_node_pointer(); }
 };
 
 template <class _NodeType, class _Derived>
-struct __set_node_handle_specifics
-{
-    typedef typename _NodeType::__node_value_type value_type;
+struct __set_node_handle_specifics {
+  typedef typename _NodeType::__node_value_type value_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    value_type& value() const
-    {
-        return static_cast<_Derived const*>(this)->__ptr_->__value_;
-    }
+  _LIBCPP_HIDE_FROM_ABI value_type& value() const { return static_cast<_Derived const*>(this)->__ptr_->__get_value(); }
 };
 
 template <class _NodeType, class _Derived>
-struct __map_node_handle_specifics
-{
-    typedef typename _NodeType::__node_value_type::key_type key_type;
-    typedef typename _NodeType::__node_value_type::mapped_type mapped_type;
+struct __map_node_handle_specifics {
+  typedef typename _NodeType::__node_value_type::key_type key_type;
+  typedef typename _NodeType::__node_value_type::mapped_type mapped_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    key_type& key() const
-    {
-        return static_cast<_Derived const*>(this)->
-            __ptr_->__value_.__ref().first;
-    }
+  _LIBCPP_HIDE_FROM_ABI key_type& key() const {
+    return static_cast<_Derived const*>(this)->__ptr_->__get_value().__ref().first;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    mapped_type& mapped() const
-    {
-        return static_cast<_Derived const*>(this)->
-            __ptr_->__value_.__ref().second;
-    }
+  _LIBCPP_HIDE_FROM_ABI mapped_type& mapped() const {
+    return static_cast<_Derived const*>(this)->__ptr_->__get_value().__ref().second;
+  }
 };
 
 template <class _NodeType, class _Alloc>
-using __set_node_handle =
-    __basic_node_handle< _NodeType, _Alloc, __set_node_handle_specifics>;
+using __set_node_handle = __basic_node_handle< _NodeType, _Alloc, __set_node_handle_specifics>;
 
 template <class _NodeType, class _Alloc>
-using __map_node_handle =
-    __basic_node_handle< _NodeType, _Alloc, __map_node_handle_specifics>;
+using __map_node_handle = __basic_node_handle< _NodeType, _Alloc, __map_node_handle_specifics>;
 
 template <class _Iterator, class _NodeType>
-struct _LIBCPP_TEMPLATE_VIS __insert_return_type
-{
-    _Iterator position;
-    bool inserted;
-    _NodeType node;
+struct _LIBCPP_TEMPLATE_VIS __insert_return_type {
+  _Iterator position;
+  bool inserted;
+  _NodeType node;
 };
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif  // _LIBCPP___NODE_HANDLE
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___NODE_HANDLE
diff --git a/third_party/libcxx/__numeric/accumulate.h b/third_party/libcxx/__numeric/accumulate.h
index 823d50186..fedc1c46d 100644
--- a/third_party/libcxx/__numeric/accumulate.h
+++ b/third_party/libcxx/__numeric/accumulate.h
@@ -17,36 +17,37 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_Tp
-accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
-{
-    for (; __first != __last; ++__first)
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp
+accumulate(_InputIterator __first, _InputIterator __last, _Tp __init) {
+  for (; __first != __last; ++__first)
 #if _LIBCPP_STD_VER >= 20
-        __init = _VSTD::move(__init) + *__first;
+    __init = std::move(__init) + *__first;
 #else
-        __init = __init + *__first;
+    __init = __init + *__first;
 #endif
-    return __init;
+  return __init;
 }
 
 template <class _InputIterator, class _Tp, class _BinaryOperation>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_Tp
-accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op)
-{
-    for (; __first != __last; ++__first)
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp
+accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op) {
+  for (; __first != __last; ++__first)
 #if _LIBCPP_STD_VER >= 20
-        __init = __binary_op(_VSTD::move(__init), *__first);
+    __init = __binary_op(std::move(__init), *__first);
 #else
-        __init = __binary_op(__init, *__first);
+    __init = __binary_op(__init, *__first);
 #endif
-    return __init;
+  return __init;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___NUMERIC_ACCUMULATE_H
diff --git a/third_party/libcxx/__numeric/adjacent_difference.h b/third_party/libcxx/__numeric/adjacent_difference.h
index b3519fdeb..62b53342d 100644
--- a/third_party/libcxx/__numeric/adjacent_difference.h
+++ b/third_party/libcxx/__numeric/adjacent_difference.h
@@ -18,55 +18,51 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _OutputIterator>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    if (__first != __last)
-    {
-        typename iterator_traits<_InputIterator>::value_type __acc(*__first);
-        *__result = __acc;
-        for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
-        {
-            typename iterator_traits<_InputIterator>::value_type __val(*__first);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
+  if (__first != __last) {
+    typename iterator_traits<_InputIterator>::value_type __acc(*__first);
+    *__result = __acc;
+    for (++__first, (void)++__result; __first != __last; ++__first, (void)++__result) {
+      typename iterator_traits<_InputIterator>::value_type __val(*__first);
 #if _LIBCPP_STD_VER >= 20
-            *__result = __val - _VSTD::move(__acc);
+      *__result = __val - std::move(__acc);
 #else
-            *__result = __val - __acc;
+      *__result = __val - __acc;
 #endif
-            __acc = _VSTD::move(__val);
-        }
+      __acc = std::move(__val);
     }
-    return __result;
+  }
+  return __result;
 }
 
 template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-adjacent_difference(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
-                      _BinaryOperation __binary_op)
-{
-    if (__first != __last)
-    {
-        typename iterator_traits<_InputIterator>::value_type __acc(*__first);
-        *__result = __acc;
-        for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
-        {
-            typename iterator_traits<_InputIterator>::value_type __val(*__first);
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator adjacent_difference(
+    _InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op) {
+  if (__first != __last) {
+    typename iterator_traits<_InputIterator>::value_type __acc(*__first);
+    *__result = __acc;
+    for (++__first, (void)++__result; __first != __last; ++__first, (void)++__result) {
+      typename iterator_traits<_InputIterator>::value_type __val(*__first);
 #if _LIBCPP_STD_VER >= 20
-            *__result = __binary_op(__val, _VSTD::move(__acc));
+      *__result = __binary_op(__val, std::move(__acc));
 #else
-            *__result = __binary_op(__val, __acc);
+      *__result = __binary_op(__val, __acc);
 #endif
-            __acc = _VSTD::move(__val);
-        }
+      __acc = std::move(__val);
     }
-    return __result;
+  }
+  return __result;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___NUMERIC_ADJACENT_DIFFERENCE_H
diff --git a/third_party/libcxx/__numeric/exclusive_scan.h b/third_party/libcxx/__numeric/exclusive_scan.h
index 676ff7035..af85b477d 100644
--- a/third_party/libcxx/__numeric/exclusive_scan.h
+++ b/third_party/libcxx/__numeric/exclusive_scan.h
@@ -18,36 +18,41 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
 template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
 exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init, _BinaryOp __b) {
   if (__first != __last) {
     _Tp __tmp(__b(__init, *__first));
     while (true) {
-      *__result = _VSTD::move(__init);
+      *__result = std::move(__init);
       ++__result;
       ++__first;
       if (__first == __last)
         break;
-      __init = _VSTD::move(__tmp);
-      __tmp = __b(__init, *__first);
+      __init = std::move(__tmp);
+      __tmp  = __b(__init, *__first);
     }
   }
   return __result;
 }
 
 template <class _InputIterator, class _OutputIterator, class _Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
 exclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init) {
-  return _VSTD::exclusive_scan(__first, __last, __result, __init, _VSTD::plus<>());
+  return std::exclusive_scan(__first, __last, __result, __init, std::plus<>());
 }
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___NUMERIC_EXCLUSIVE_SCAN_H
diff --git a/third_party/libcxx/__numeric/gcd_lcm.h b/third_party/libcxx/__numeric/gcd_lcm.h
index 7139a7ec5..9be6cf851 100644
--- a/third_party/libcxx/__numeric/gcd_lcm.h
+++ b/third_party/libcxx/__numeric/gcd_lcm.h
@@ -10,7 +10,9 @@
 #ifndef _LIBCPP___NUMERIC_GCD_LCM_H
 #define _LIBCPP___NUMERIC_GCD_LCM_H
 
+#include <__algorithm/min.h>
 #include <__assert>
+#include <__bit/countr.h>
 #include <__config>
 #include <__type_traits/common_type.h>
 #include <__type_traits/is_integral.h>
@@ -30,68 +32,98 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-template <typename _Result, typename _Source, bool _IsSigned = is_signed<_Source>::value> struct __ct_abs;
+template <typename _Result, typename _Source, bool _IsSigned = is_signed<_Source>::value>
+struct __ct_abs;
 
 template <typename _Result, typename _Source>
 struct __ct_abs<_Result, _Source, true> {
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    _Result operator()(_Source __t) const noexcept
-    {
-        if (__t >= 0) return __t;
-        if (__t == numeric_limits<_Source>::min()) return -static_cast<_Result>(__t);
-        return -__t;
-    }
+  constexpr _LIBCPP_HIDE_FROM_ABI _Result operator()(_Source __t) const noexcept {
+    if (__t >= 0)
+      return __t;
+    if (__t == numeric_limits<_Source>::min())
+      return -static_cast<_Result>(__t);
+    return -__t;
+  }
 };
 
 template <typename _Result, typename _Source>
 struct __ct_abs<_Result, _Source, false> {
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    _Result operator()(_Source __t) const noexcept { return __t; }
+  constexpr _LIBCPP_HIDE_FROM_ABI _Result operator()(_Source __t) const noexcept { return __t; }
 };
 
+template <class _Tp>
+constexpr _LIBCPP_HIDDEN _Tp __gcd(_Tp __a, _Tp __b) {
+  static_assert(!is_signed<_Tp>::value, "");
 
-template<class _Tp>
-_LIBCPP_CONSTEXPR _LIBCPP_HIDDEN
-_Tp __gcd(_Tp __m, _Tp __n)
-{
-    static_assert((!is_signed<_Tp>::value), "");
-    return __n == 0 ? __m : _VSTD::__gcd<_Tp>(__n, __m % __n);
+  // From: https://lemire.me/blog/2013/12/26/fastest-way-to-compute-the-greatest-common-divisor
+  //
+  // If power of two divides both numbers, we can push it out.
+  // - gcd( 2^x * a, 2^x * b) = 2^x * gcd(a, b)
+  //
+  // If and only if exactly one number is even, we can divide that number by that power.
+  // - if a, b are odd, then gcd(2^x * a, b) = gcd(a, b)
+  //
+  // And standard gcd algorithm where instead of modulo, minus is used.
+
+  if (__a < __b) {
+    _Tp __tmp = __b;
+    __b       = __a;
+    __a       = __tmp;
+  }
+  if (__b == 0)
+    return __a;
+  __a %= __b; // Make both argument of the same size, and early result in the easy case.
+  if (__a == 0)
+    return __b;
+
+  int __az    = std::__countr_zero(__a);
+  int __bz    = std::__countr_zero(__b);
+  int __shift = std::min(__az, __bz);
+  __a >>= __az;
+  __b >>= __bz;
+  do {
+    _Tp __diff = __a - __b;
+    if (__a > __b) {
+      __a = __b;
+      __b = __diff;
+    } else {
+      __b = __b - __a;
+    }
+    if (__diff != 0)
+      __b >>= std::__countr_zero(__diff);
+  } while (__b != 0);
+  return __a << __shift;
 }
 
-template<class _Tp, class _Up>
-_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-common_type_t<_Tp,_Up>
-gcd(_Tp __m, _Up __n)
-{
-    static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to gcd must be integer types");
-    static_assert((!is_same<__remove_cv_t<_Tp>, bool>::value), "First argument to gcd cannot be bool" );
-    static_assert((!is_same<__remove_cv_t<_Up>, bool>::value), "Second argument to gcd cannot be bool" );
-    using _Rp = common_type_t<_Tp,_Up>;
-    using _Wp = make_unsigned_t<_Rp>;
-    return static_cast<_Rp>(_VSTD::__gcd(
-        static_cast<_Wp>(__ct_abs<_Rp, _Tp>()(__m)),
-        static_cast<_Wp>(__ct_abs<_Rp, _Up>()(__n))));
+template <class _Tp, class _Up>
+constexpr _LIBCPP_HIDE_FROM_ABI common_type_t<_Tp, _Up> gcd(_Tp __m, _Up __n) {
+  static_assert(is_integral<_Tp>::value && is_integral<_Up>::value, "Arguments to gcd must be integer types");
+  static_assert(!is_same<__remove_cv_t<_Tp>, bool>::value, "First argument to gcd cannot be bool");
+  static_assert(!is_same<__remove_cv_t<_Up>, bool>::value, "Second argument to gcd cannot be bool");
+  using _Rp = common_type_t<_Tp, _Up>;
+  using _Wp = make_unsigned_t<_Rp>;
+  return static_cast<_Rp>(
+      std::__gcd(static_cast<_Wp>(__ct_abs<_Rp, _Tp>()(__m)), static_cast<_Wp>(__ct_abs<_Rp, _Up>()(__n))));
 }
 
-template<class _Tp, class _Up>
-_LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-common_type_t<_Tp,_Up>
-lcm(_Tp __m, _Up __n)
-{
-    static_assert((is_integral<_Tp>::value && is_integral<_Up>::value), "Arguments to lcm must be integer types");
-    static_assert((!is_same<__remove_cv_t<_Tp>, bool>::value), "First argument to lcm cannot be bool" );
-    static_assert((!is_same<__remove_cv_t<_Up>, bool>::value), "Second argument to lcm cannot be bool" );
-    if (__m == 0 || __n == 0)
-        return 0;
+template <class _Tp, class _Up>
+constexpr _LIBCPP_HIDE_FROM_ABI common_type_t<_Tp, _Up> lcm(_Tp __m, _Up __n) {
+  static_assert(is_integral<_Tp>::value && is_integral<_Up>::value, "Arguments to lcm must be integer types");
+  static_assert(!is_same<__remove_cv_t<_Tp>, bool>::value, "First argument to lcm cannot be bool");
+  static_assert(!is_same<__remove_cv_t<_Up>, bool>::value, "Second argument to lcm cannot be bool");
+  if (__m == 0 || __n == 0)
+    return 0;
 
-    using _Rp = common_type_t<_Tp,_Up>;
-    _Rp __val1 = __ct_abs<_Rp, _Tp>()(__m) / _VSTD::gcd(__m, __n);
-    _Rp __val2 = __ct_abs<_Rp, _Up>()(__n);
-    _LIBCPP_ASSERT((numeric_limits<_Rp>::max() / __val1 > __val2), "Overflow in lcm");
-    return __val1 * __val2;
+  using _Rp  = common_type_t<_Tp, _Up>;
+  _Rp __val1 = __ct_abs<_Rp, _Tp>()(__m) / std::gcd(__m, __n);
+  _Rp __val2 = __ct_abs<_Rp, _Up>()(__n);
+  _Rp __res;
+  [[maybe_unused]] bool __overflow = __builtin_mul_overflow(__val1, __val2, &__res);
+  _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(!__overflow, "Overflow in lcm");
+  return __res;
 }
 
-#endif // _LIBCPP_STD_VER
+#endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__numeric/inclusive_scan.h b/third_party/libcxx/__numeric/inclusive_scan.h
index bd9634460..d714f102d 100644
--- a/third_party/libcxx/__numeric/inclusive_scan.h
+++ b/third_party/libcxx/__numeric/inclusive_scan.h
@@ -24,33 +24,32 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 17
 
 template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
 inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOp __b, _Tp __init) {
   for (; __first != __last; ++__first, (void)++__result) {
-    __init = __b(__init, *__first);
+    __init    = __b(__init, *__first);
     *__result = __init;
   }
   return __result;
 }
 
 template <class _InputIterator, class _OutputIterator, class _BinaryOp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
 inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOp __b) {
   if (__first != __last) {
     typename iterator_traits<_InputIterator>::value_type __init = *__first;
-    *__result++ = __init;
+    *__result++                                                 = __init;
     if (++__first != __last)
-      return _VSTD::inclusive_scan(__first, __last, __result, __b, __init);
+      return std::inclusive_scan(__first, __last, __result, __b, __init);
   }
 
   return __result;
 }
 
 template <class _InputIterator, class _OutputIterator>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator inclusive_scan(_InputIterator __first,
-                                                                                       _InputIterator __last,
-                                                                                       _OutputIterator __result) {
-  return _VSTD::inclusive_scan(__first, __last, __result, _VSTD::plus<>());
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+inclusive_scan(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
+  return std::inclusive_scan(__first, __last, __result, std::plus<>());
 }
 
 #endif // _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/__numeric/inner_product.h b/third_party/libcxx/__numeric/inner_product.h
index b36020098..0deab3d42 100644
--- a/third_party/libcxx/__numeric/inner_product.h
+++ b/third_party/libcxx/__numeric/inner_product.h
@@ -17,37 +17,42 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator1, class _InputIterator2, class _Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_Tp
-inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init)
-{
-    for (; __first1 != __last1; ++__first1, (void) ++__first2)
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp
+inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init) {
+  for (; __first1 != __last1; ++__first1, (void)++__first2)
 #if _LIBCPP_STD_VER >= 20
-        __init = _VSTD::move(__init) + *__first1 * *__first2;
+    __init = std::move(__init) + *__first1 * *__first2;
 #else
-        __init = __init + *__first1 * *__first2;
+    __init = __init + *__first1 * *__first2;
 #endif
-    return __init;
+  return __init;
 }
 
 template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_Tp
-inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
-              _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2)
-{
-    for (; __first1 != __last1; ++__first1, (void) ++__first2)
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp inner_product(
+    _InputIterator1 __first1,
+    _InputIterator1 __last1,
+    _InputIterator2 __first2,
+    _Tp __init,
+    _BinaryOperation1 __binary_op1,
+    _BinaryOperation2 __binary_op2) {
+  for (; __first1 != __last1; ++__first1, (void)++__first2)
 #if _LIBCPP_STD_VER >= 20
-        __init = __binary_op1(_VSTD::move(__init), __binary_op2(*__first1, *__first2));
+    __init = __binary_op1(std::move(__init), __binary_op2(*__first1, *__first2));
 #else
-        __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
+    __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
 #endif
-    return __init;
+  return __init;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___NUMERIC_INNER_PRODUCT_H
diff --git a/third_party/libcxx/__numeric/iota.h b/third_party/libcxx/__numeric/iota.h
index eacdc5b6e..27bd84e39 100644
--- a/third_party/libcxx/__numeric/iota.h
+++ b/third_party/libcxx/__numeric/iota.h
@@ -19,12 +19,10 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _ForwardIterator, class _Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
-{
-    for (; __first != __last; ++__first, (void) ++__value)
-        *__first = __value;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value) {
+  for (; __first != __last; ++__first, (void)++__value)
+    *__first = __value;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__numeric/midpoint.h b/third_party/libcxx/__numeric/midpoint.h
index 5325f5e6b..5ef30d4ec 100644
--- a/third_party/libcxx/__numeric/midpoint.h
+++ b/third_party/libcxx/__numeric/midpoint.h
@@ -35,55 +35,48 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<is_integral_v<_Tp> && !is_same_v<bool, _Tp> && !is_null_pointer_v<_Tp>, _Tp>
-midpoint(_Tp __a, _Tp __b) noexcept
-_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-{
-    using _Up = make_unsigned_t<_Tp>;
-    constexpr _Up __bitshift = numeric_limits<_Up>::digits - 1;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<is_integral_v<_Tp> && !is_same_v<bool, _Tp> && !is_null_pointer_v<_Tp>, _Tp>
+midpoint(_Tp __a, _Tp __b) noexcept _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK {
+  using _Up                = make_unsigned_t<_Tp>;
+  constexpr _Up __bitshift = numeric_limits<_Up>::digits - 1;
 
-    _Up __diff = _Up(__b) - _Up(__a);
-    _Up __sign_bit = __b < __a;
+  _Up __diff     = _Up(__b) - _Up(__a);
+  _Up __sign_bit = __b < __a;
 
-    _Up __half_diff = (__diff / 2) + (__sign_bit << __bitshift) + (__sign_bit & __diff);
+  _Up __half_diff = (__diff / 2) + (__sign_bit << __bitshift) + (__sign_bit & __diff);
 
-    return __a + __half_diff;
+  return __a + __half_diff;
 }
 
-
-template <class _TPtr>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<is_pointer_v<_TPtr>
-             && is_object_v<remove_pointer_t<_TPtr>>
-             && ! is_void_v<remove_pointer_t<_TPtr>>
-             && (sizeof(remove_pointer_t<_TPtr>) > 0), _TPtr>
-midpoint(_TPtr __a, _TPtr __b) noexcept
-{
-    return __a + _VSTD::midpoint(ptrdiff_t(0), __b - __a);
+template <class _Tp, enable_if_t<is_object_v<_Tp> && !is_void_v<_Tp> && (sizeof(_Tp) > 0), int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp* midpoint(_Tp* __a, _Tp* __b) noexcept {
+  return __a + std::midpoint(ptrdiff_t(0), __b - __a);
 }
 
-
 template <typename _Tp>
 _LIBCPP_HIDE_FROM_ABI constexpr int __sign(_Tp __val) {
-    return (_Tp(0) < __val) - (__val < _Tp(0));
+  return (_Tp(0) < __val) - (__val < _Tp(0));
 }
 
 template <typename _Fp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Fp __fp_abs(_Fp __f) { return __f >= 0 ? __f : -__f; }
+_LIBCPP_HIDE_FROM_ABI constexpr _Fp __fp_abs(_Fp __f) {
+  return __f >= 0 ? __f : -__f;
+}
 
 template <class _Fp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<is_floating_point_v<_Fp>, _Fp>
-midpoint(_Fp __a, _Fp __b) noexcept
-{
-    constexpr _Fp __lo = numeric_limits<_Fp>::min()*2;
-    constexpr _Fp __hi = numeric_limits<_Fp>::max()/2;
-    return std::__fp_abs(__a) <= __hi && std::__fp_abs(__b) <= __hi ?  // typical case: overflow is impossible
-      (__a + __b)/2 :                                        // always correctly rounded
-      std::__fp_abs(__a) < __lo ? __a + __b/2 :                   // not safe to halve a
-      std::__fp_abs(__b) < __lo ? __a/2 + __b :                   // not safe to halve b
-      __a/2 + __b/2;                                         // otherwise correctly rounded
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<is_floating_point_v<_Fp>, _Fp> midpoint(_Fp __a, _Fp __b) noexcept {
+  constexpr _Fp __lo = numeric_limits<_Fp>::min() * 2;
+  constexpr _Fp __hi = numeric_limits<_Fp>::max() / 2;
+
+  // typical case: overflow is impossible
+  if (std::__fp_abs(__a) <= __hi && std::__fp_abs(__b) <= __hi)
+    return (__a + __b) / 2; // always correctly rounded
+  if (std::__fp_abs(__a) < __lo)
+    return __a + __b / 2; // not safe to halve a
+  if (std::__fp_abs(__b) < __lo)
+    return __a / 2 + __b; // not safe to halve b
+
+  return __a / 2 + __b / 2; // otherwise correctly rounded
 }
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__numeric/partial_sum.h b/third_party/libcxx/__numeric/partial_sum.h
index 94f65d7e9..7c3cf7fb2 100644
--- a/third_party/libcxx/__numeric/partial_sum.h
+++ b/third_party/libcxx/__numeric/partial_sum.h
@@ -18,53 +18,49 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _OutputIterator>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    if (__first != __last)
-    {
-        typename iterator_traits<_InputIterator>::value_type __t(*__first);
-        *__result = __t;
-        for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
-        {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
+  if (__first != __last) {
+    typename iterator_traits<_InputIterator>::value_type __t(*__first);
+    *__result = __t;
+    for (++__first, (void)++__result; __first != __last; ++__first, (void)++__result) {
 #if _LIBCPP_STD_VER >= 20
-            __t = _VSTD::move(__t) + *__first;
+      __t = std::move(__t) + *__first;
 #else
-            __t = __t + *__first;
+      __t = __t + *__first;
 #endif
-            *__result = __t;
-        }
+      *__result = __t;
     }
-    return __result;
+  }
+  return __result;
 }
 
 template <class _InputIterator, class _OutputIterator, class _BinaryOperation>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
-              _BinaryOperation __binary_op)
-{
-    if (__first != __last)
-    {
-        typename iterator_traits<_InputIterator>::value_type __t(*__first);
-        *__result = __t;
-        for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
-        {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOperation __binary_op) {
+  if (__first != __last) {
+    typename iterator_traits<_InputIterator>::value_type __t(*__first);
+    *__result = __t;
+    for (++__first, (void)++__result; __first != __last; ++__first, (void)++__result) {
 #if _LIBCPP_STD_VER >= 20
-            __t = __binary_op(_VSTD::move(__t), *__first);
+      __t = __binary_op(std::move(__t), *__first);
 #else
-            __t = __binary_op(__t, *__first);
+      __t = __binary_op(__t, *__first);
 #endif
-            *__result = __t;
-        }
+      *__result = __t;
     }
-    return __result;
+  }
+  return __result;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___NUMERIC_PARTIAL_SUM_H
diff --git a/third_party/libcxx/__numeric/pstl.h b/third_party/libcxx/__numeric/pstl.h
new file mode 100644
index 000000000..7557686a3
--- /dev/null
+++ b/third_party/libcxx/__numeric/pstl.h
@@ -0,0 +1,174 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___NUMERIC_PSTL_H
+#define _LIBCPP___NUMERIC_PSTL_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
+#  include <__functional/identity.h>
+#  include <__functional/operations.h>
+#  include <__iterator/cpp17_iterator_concepts.h>
+#  include <__iterator/iterator_traits.h>
+#  include <__pstl/backend.h>
+#  include <__pstl/dispatch.h>
+#  include <__pstl/handle_exception.h>
+#  include <__type_traits/enable_if.h>
+#  include <__type_traits/is_execution_policy.h>
+#  include <__type_traits/remove_cvref.h>
+#  include <__utility/forward.h>
+#  include <__utility/move.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Tp,
+          class _BinaryOperation,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp reduce(
+    _ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation __op) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reduce requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__reduce, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first),
+      std::move(__last),
+      std::move(__init),
+      std::move(__op));
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Tp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp
+reduce(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp __init) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reduce requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__reduce, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy), std::move(__first), std::move(__last), std::move(__init), plus{});
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI __iter_value_type<_ForwardIterator>
+reduce(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reduce requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__reduce, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first),
+      std::move(__last),
+      __iter_value_type<_ForwardIterator>(),
+      plus{});
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _Tp,
+          class _BinaryOperation1,
+          class _BinaryOperation2,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp transform_reduce(
+    _ExecutionPolicy&& __policy,
+    _ForwardIterator1 __first1,
+    _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2,
+    _Tp __init,
+    _BinaryOperation1 __reduce,
+    _BinaryOperation2 __transform) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform_reduce requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform_reduce requires ForwardIterators");
+  using _Implementation =
+      __pstl::__dispatch<__pstl::__transform_reduce_binary, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__init),
+      std::move(__reduce),
+      std::move(__transform));
+}
+
+// This overload doesn't get a customization point because it's trivial to detect (through e.g.
+// __desugars_to_v) when specializing the more general variant, which should always be preferred
+template <class _ExecutionPolicy,
+          class _ForwardIterator1,
+          class _ForwardIterator2,
+          class _Tp,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp transform_reduce(
+    _ExecutionPolicy&& __policy,
+    _ForwardIterator1 __first1,
+    _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2,
+    _Tp __init) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "transform_reduce requires ForwardIterators");
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "transform_reduce requires ForwardIterators");
+  using _Implementation =
+      __pstl::__dispatch<__pstl::__transform_reduce_binary, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first1),
+      std::move(__last1),
+      std::move(__first2),
+      std::move(__init),
+      plus{},
+      multiplies{});
+}
+
+template <class _ExecutionPolicy,
+          class _ForwardIterator,
+          class _Tp,
+          class _BinaryOperation,
+          class _UnaryOperation,
+          class _RawPolicy                                    = __remove_cvref_t<_ExecutionPolicy>,
+          enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp transform_reduce(
+    _ExecutionPolicy&& __policy,
+    _ForwardIterator __first,
+    _ForwardIterator __last,
+    _Tp __init,
+    _BinaryOperation __reduce,
+    _UnaryOperation __transform) {
+  _LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "transform_reduce requires ForwardIterators");
+  using _Implementation = __pstl::__dispatch<__pstl::__transform_reduce, __pstl::__current_configuration, _RawPolicy>;
+  return __pstl::__handle_exception<_Implementation>(
+      std::forward<_ExecutionPolicy>(__policy),
+      std::move(__first),
+      std::move(__last),
+      std::move(__init),
+      std::move(__reduce),
+      std::move(__transform));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___NUMERIC_PSTL_H
diff --git a/third_party/libcxx/__numeric/reduce.h b/third_party/libcxx/__numeric/reduce.h
index 9e710fc99..6c205bf58 100644
--- a/third_party/libcxx/__numeric/reduce.h
+++ b/third_party/libcxx/__numeric/reduce.h
@@ -13,35 +13,41 @@
 #include <__config>
 #include <__functional/operations.h>
 #include <__iterator/iterator_traits.h>
+#include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 template <class _InputIterator, class _Tp, class _BinaryOp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp reduce(_InputIterator __first, _InputIterator __last,
-                                                                   _Tp __init, _BinaryOp __b) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp
+reduce(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOp __b) {
   for (; __first != __last; ++__first)
-    __init = __b(__init, *__first);
+    __init = __b(std::move(__init), *__first);
   return __init;
 }
 
 template <class _InputIterator, class _Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp reduce(_InputIterator __first, _InputIterator __last,
-                                                                   _Tp __init) {
-  return _VSTD::reduce(__first, __last, __init, _VSTD::plus<>());
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp
+reduce(_InputIterator __first, _InputIterator __last, _Tp __init) {
+  return std::reduce(__first, __last, __init, std::plus<>());
 }
 
 template <class _InputIterator>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 typename iterator_traits<_InputIterator>::value_type
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename iterator_traits<_InputIterator>::value_type
 reduce(_InputIterator __first, _InputIterator __last) {
-  return _VSTD::reduce(__first, __last, typename iterator_traits<_InputIterator>::value_type{});
+  return std::reduce(__first, __last, typename iterator_traits<_InputIterator>::value_type{});
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___NUMERIC_REDUCE_H
diff --git a/third_party/libcxx/__numeric/saturation_arithmetic.h b/third_party/libcxx/__numeric/saturation_arithmetic.h
new file mode 100644
index 000000000..2390b42aa
--- /dev/null
+++ b/third_party/libcxx/__numeric/saturation_arithmetic.h
@@ -0,0 +1,145 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___NUMERIC_SATURATION_ARITHMETIC_H
+#define _LIBCPP___NUMERIC_SATURATION_ARITHMETIC_H
+
+#include <__assert>
+#include <__concepts/arithmetic.h>
+#include <__config>
+#include <__utility/cmp.h>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template <__libcpp_integer _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp __add_sat(_Tp __x, _Tp __y) noexcept {
+  if (_Tp __sum; !__builtin_add_overflow(__x, __y, &__sum))
+    return __sum;
+  // Handle overflow
+  if constexpr (__libcpp_unsigned_integer<_Tp>) {
+    return std::numeric_limits<_Tp>::max();
+  } else {
+    // Signed addition overflow
+    if (__x > 0)
+      // Overflows if (x > 0 && y > 0)
+      return std::numeric_limits<_Tp>::max();
+    else
+      // Overflows if  (x < 0 && y < 0)
+      return std::numeric_limits<_Tp>::min();
+  }
+}
+
+template <__libcpp_integer _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp __sub_sat(_Tp __x, _Tp __y) noexcept {
+  if (_Tp __sub; !__builtin_sub_overflow(__x, __y, &__sub))
+    return __sub;
+  // Handle overflow
+  if constexpr (__libcpp_unsigned_integer<_Tp>) {
+    // Overflows if (x < y)
+    return std::numeric_limits<_Tp>::min();
+  } else {
+    // Signed subtration overflow
+    if (__x >= 0)
+      // Overflows if (x >= 0 && y < 0)
+      return std::numeric_limits<_Tp>::max();
+    else
+      // Overflows if (x < 0 && y > 0)
+      return std::numeric_limits<_Tp>::min();
+  }
+}
+
+template <__libcpp_integer _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp __mul_sat(_Tp __x, _Tp __y) noexcept {
+  if (_Tp __mul; !__builtin_mul_overflow(__x, __y, &__mul))
+    return __mul;
+  // Handle overflow
+  if constexpr (__libcpp_unsigned_integer<_Tp>) {
+    return std::numeric_limits<_Tp>::max();
+  } else {
+    // Signed multiplication overflow
+    if ((__x > 0 && __y > 0) || (__x < 0 && __y < 0))
+      return std::numeric_limits<_Tp>::max();
+    // Overflows if (x < 0 && y > 0) || (x > 0 && y < 0)
+    return std::numeric_limits<_Tp>::min();
+  }
+}
+
+template <__libcpp_integer _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp __div_sat(_Tp __x, _Tp __y) noexcept {
+  _LIBCPP_ASSERT_UNCATEGORIZED(__y != 0, "Division by 0 is undefined");
+  if constexpr (__libcpp_unsigned_integer<_Tp>) {
+    return __x / __y;
+  } else {
+    // Handle signed division overflow
+    if (__x == std::numeric_limits<_Tp>::min() && __y == _Tp{-1})
+      return std::numeric_limits<_Tp>::max();
+    return __x / __y;
+  }
+}
+
+template <__libcpp_integer _Rp, __libcpp_integer _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Rp __saturate_cast(_Tp __x) noexcept {
+  // Saturation is impossible edge case when ((min _Rp) < (min _Tp) && (max _Rp) > (max _Tp)) and it is expected to be
+  // optimized out by the compiler.
+
+  // Handle overflow
+  if (std::cmp_less(__x, std::numeric_limits<_Rp>::min()))
+    return std::numeric_limits<_Rp>::min();
+  if (std::cmp_greater(__x, std::numeric_limits<_Rp>::max()))
+    return std::numeric_limits<_Rp>::max();
+  // No overflow
+  return static_cast<_Rp>(__x);
+}
+
+#endif // _LIBCPP_STD_VER >= 20
+
+#if _LIBCPP_STD_VER >= 26
+
+template <__libcpp_integer _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp add_sat(_Tp __x, _Tp __y) noexcept {
+  return std::__add_sat(__x, __y);
+}
+
+template <__libcpp_integer _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp sub_sat(_Tp __x, _Tp __y) noexcept {
+  return std::__sub_sat(__x, __y);
+}
+
+template <__libcpp_integer _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp mul_sat(_Tp __x, _Tp __y) noexcept {
+  return std::__mul_sat(__x, __y);
+}
+
+template <__libcpp_integer _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp div_sat(_Tp __x, _Tp __y) noexcept {
+  return std::__div_sat(__x, __y);
+}
+
+template <__libcpp_integer _Rp, __libcpp_integer _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Rp saturate_cast(_Tp __x) noexcept {
+  return std::__saturate_cast<_Rp>(__x);
+}
+
+#endif // _LIBCPP_STD_VER >= 26
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___NUMERIC_SATURATION_ARITHMETIC_H
diff --git a/third_party/libcxx/__numeric/transform_exclusive_scan.h b/third_party/libcxx/__numeric/transform_exclusive_scan.h
index 3d5574c7d..fb88aa52c 100644
--- a/third_party/libcxx/__numeric/transform_exclusive_scan.h
+++ b/third_party/libcxx/__numeric/transform_exclusive_scan.h
@@ -20,26 +20,19 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-template <class _InputIterator, class _OutputIterator, class _Tp,
-          class _BinaryOp, class _UnaryOp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-transform_exclusive_scan(_InputIterator __first, _InputIterator __last,
-                           _OutputIterator __result, _Tp __init,
-                           _BinaryOp __b, _UnaryOp __u)
-{
-    if (__first != __last)
-    {
-        _Tp __saved = __init;
-        do
-        {
-            __init = __b(__init, __u(*__first));
-            *__result = __saved;
-            __saved = __init;
-            ++__result;
-        } while (++__first != __last);
-    }
-    return __result;
+template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator transform_exclusive_scan(
+    _InputIterator __first, _InputIterator __last, _OutputIterator __result, _Tp __init, _BinaryOp __b, _UnaryOp __u) {
+  if (__first != __last) {
+    _Tp __saved = __init;
+    do {
+      __init    = __b(__init, __u(*__first));
+      *__result = __saved;
+      __saved   = __init;
+      ++__result;
+    } while (++__first != __last);
+  }
+  return __result;
 }
 
 #endif // _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/__numeric/transform_inclusive_scan.h b/third_party/libcxx/__numeric/transform_inclusive_scan.h
index ee9168928..2eab1a142 100644
--- a/third_party/libcxx/__numeric/transform_inclusive_scan.h
+++ b/third_party/libcxx/__numeric/transform_inclusive_scan.h
@@ -22,33 +22,27 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 17
 
 template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
-                           _OutputIterator __result, _BinaryOp __b, _UnaryOp __u, _Tp __init)
-{
-    for (; __first != __last; ++__first, (void) ++__result) {
-        __init = __b(__init, __u(*__first));
-        *__result = __init;
-        }
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator transform_inclusive_scan(
+    _InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOp __b, _UnaryOp __u, _Tp __init) {
+  for (; __first != __last; ++__first, (void)++__result) {
+    __init    = __b(__init, __u(*__first));
+    *__result = __init;
+  }
 
-    return __result;
+  return __result;
 }
 
 template <class _InputIterator, class _OutputIterator, class _BinaryOp, class _UnaryOp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_OutputIterator
-transform_inclusive_scan(_InputIterator __first, _InputIterator __last,
-                               _OutputIterator __result, _BinaryOp __b, _UnaryOp __u)
-{
-    if (__first != __last) {
-        typename iterator_traits<_InputIterator>::value_type __init = __u(*__first);
-        *__result++ = __init;
-        if (++__first != __last)
-            return _VSTD::transform_inclusive_scan(__first, __last, __result, __b, __u, __init);
-    }
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator transform_inclusive_scan(
+    _InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryOp __b, _UnaryOp __u) {
+  if (__first != __last) {
+    typename iterator_traits<_InputIterator>::value_type __init = __u(*__first);
+    *__result++                                                 = __init;
+    if (++__first != __last)
+      return std::transform_inclusive_scan(__first, __last, __result, __b, __u, __init);
+  }
 
-    return __result;
+  return __result;
 }
 
 #endif // _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/__numeric/transform_reduce.h b/third_party/libcxx/__numeric/transform_reduce.h
index 39ec2664f..f1150510f 100644
--- a/third_party/libcxx/__numeric/transform_reduce.h
+++ b/third_party/libcxx/__numeric/transform_reduce.h
@@ -18,37 +18,42 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp transform_reduce(_InputIterator __first,
-                                                                             _InputIterator __last, _Tp __init,
-                                                                             _BinaryOp __b, _UnaryOp __u) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp
+transform_reduce(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOp __b, _UnaryOp __u) {
   for (; __first != __last; ++__first)
-    __init = __b(__init, __u(*__first));
+    __init = __b(std::move(__init), __u(*__first));
   return __init;
 }
 
 template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOp1, class _BinaryOp2>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp transform_reduce(_InputIterator1 __first1,
-                                                                             _InputIterator1 __last1,
-                                                                             _InputIterator2 __first2, _Tp __init,
-                                                                             _BinaryOp1 __b1, _BinaryOp2 __b2) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp transform_reduce(
+    _InputIterator1 __first1,
+    _InputIterator1 __last1,
+    _InputIterator2 __first2,
+    _Tp __init,
+    _BinaryOp1 __b1,
+    _BinaryOp2 __b2) {
   for (; __first1 != __last1; ++__first1, (void)++__first2)
-    __init = __b1(__init, __b2(*__first1, *__first2));
+    __init = __b1(std::move(__init), __b2(*__first1, *__first2));
   return __init;
 }
 
 template <class _InputIterator1, class _InputIterator2, class _Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp transform_reduce(_InputIterator1 __first1,
-                                                                             _InputIterator1 __last1,
-                                                                             _InputIterator2 __first2, _Tp __init) {
-  return _VSTD::transform_reduce(__first1, __last1, __first2, _VSTD::move(__init), _VSTD::plus<>(),
-                                 _VSTD::multiplies<>());
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp
+transform_reduce(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _Tp __init) {
+  return std::transform_reduce(__first1, __last1, __first2, std::move(__init), std::plus<>(), std::multiplies<>());
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___NUMERIC_TRANSFORM_REDUCE_H
diff --git a/third_party/libcxx/__ostream/basic_ostream.h b/third_party/libcxx/__ostream/basic_ostream.h
new file mode 100644
index 000000000..178359d68
--- /dev/null
+++ b/third_party/libcxx/__ostream/basic_ostream.h
@@ -0,0 +1,860 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___OSTREAM_BASIC_OSTREAM_H
+#define _LIBCPP___OSTREAM_BASIC_OSTREAM_H
+
+#include <__config>
+#include <__exception/operations.h>
+#include <__memory/shared_ptr.h>
+#include <__memory/unique_ptr.h>
+#include <__system_error/error_code.h>
+#include <__type_traits/conjunction.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_base_of.h>
+#include <__type_traits/void_t.h>
+#include <__utility/declval.h>
+#include <bitset>
+#include <cstddef>
+#include <ios>
+#include <locale>
+#include <new> // for __throw_bad_alloc
+#include <streambuf>
+#include <string_view>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _CharT, class _Traits>
+class _LIBCPP_TEMPLATE_VIS basic_ostream : virtual public basic_ios<_CharT, _Traits> {
+public:
+  // types (inherited from basic_ios (27.5.4)):
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+
+  // 27.7.2.2 Constructor/destructor:
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb) {
+    this->init(__sb);
+  }
+  ~basic_ostream() override;
+
+  basic_ostream(const basic_ostream& __rhs)            = delete;
+  basic_ostream& operator=(const basic_ostream& __rhs) = delete;
+
+protected:
+  inline _LIBCPP_HIDE_FROM_ABI basic_ostream(basic_ostream&& __rhs);
+
+  // 27.7.2.3 Assign/swap
+  inline _LIBCPP_HIDE_FROM_ABI basic_ostream& operator=(basic_ostream&& __rhs);
+
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_ostream& __rhs) {
+    basic_ios<char_type, traits_type>::swap(__rhs);
+  }
+
+public:
+  // 27.7.2.4 Prefix/suffix:
+  class _LIBCPP_TEMPLATE_VIS sentry;
+
+  // 27.7.2.6 Formatted output:
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)) {
+    return __pf(*this);
+  }
+
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream&
+  operator<<(basic_ios<char_type, traits_type>& (*__pf)(basic_ios<char_type, traits_type>&)) {
+    __pf(*this);
+    return *this;
+  }
+
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(ios_base& (*__pf)(ios_base&)) {
+    __pf(*this);
+    return *this;
+  }
+
+  basic_ostream& operator<<(bool __n);
+  basic_ostream& operator<<(short __n);
+  basic_ostream& operator<<(unsigned short __n);
+  basic_ostream& operator<<(int __n);
+  basic_ostream& operator<<(unsigned int __n);
+  basic_ostream& operator<<(long __n);
+  basic_ostream& operator<<(unsigned long __n);
+  basic_ostream& operator<<(long long __n);
+  basic_ostream& operator<<(unsigned long long __n);
+  basic_ostream& operator<<(float __f);
+  basic_ostream& operator<<(double __f);
+  basic_ostream& operator<<(long double __f);
+  basic_ostream& operator<<(const void* __p);
+
+#if _LIBCPP_STD_VER >= 23
+  _LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(const volatile void* __p) {
+    return operator<<(const_cast<const void*>(__p));
+  }
+#endif
+
+  basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
+
+#if _LIBCPP_STD_VER >= 17
+  // LWG 2221 - nullptr. This is not backported to older standards modes.
+  // See https://reviews.llvm.org/D127033 for more info on the rationale.
+  _LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(nullptr_t) { return *this << "nullptr"; }
+#endif
+
+  // 27.7.2.7 Unformatted output:
+  basic_ostream& put(char_type __c);
+  basic_ostream& write(const char_type* __s, streamsize __n);
+  basic_ostream& flush();
+
+  // 27.7.2.5 seeks:
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type tellp();
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(pos_type __pos);
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
+
+protected:
+  _LIBCPP_HIDE_FROM_ABI basic_ostream() {} // extension, intentially does not initialize
+};
+
+template <class _CharT, class _Traits>
+class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry {
+  bool __ok_;
+  basic_ostream<_CharT, _Traits>& __os_;
+
+public:
+  explicit sentry(basic_ostream<_CharT, _Traits>& __os);
+  ~sentry();
+  sentry(const sentry&)            = delete;
+  sentry& operator=(const sentry&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return __ok_; }
+};
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os) : __ok_(false), __os_(__os) {
+  if (__os.good()) {
+    if (__os.tie())
+      __os.tie()->flush();
+    __ok_ = true;
+  }
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>::sentry::~sentry() {
+  if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf) && !uncaught_exception()) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      if (__os_.rdbuf()->pubsync() == -1)
+        __os_.setstate(ios_base::badbit);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs) {
+  this->move(__rhs);
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs) {
+  swap(__rhs);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>::~basic_ostream() {}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>&
+basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      if (__sb) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+        try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+          typedef istreambuf_iterator<_CharT, _Traits> _Ip;
+          typedef ostreambuf_iterator<_CharT, _Traits> _Op;
+          _Ip __i(__sb);
+          _Ip __eof;
+          _Op __o(*this);
+          size_t __c = 0;
+          for (; __i != __eof; ++__i, ++__o, ++__c) {
+            *__o = *__i;
+            if (__o.failed())
+              break;
+          }
+          if (__c == 0)
+            this->setstate(ios_base::failbit);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+        } catch (...) {
+          this->__set_failbit_and_consider_rethrow();
+        }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      } else
+        this->setstate(ios_base::badbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(bool __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), __n).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(short __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this,
+                  *this,
+                  this->fill(),
+                  __flags == ios_base::oct || __flags == ios_base::hex
+                      ? static_cast<long>(static_cast<unsigned short>(__n))
+                      : static_cast<long>(__n))
+              .failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(int __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this,
+                  *this,
+                  this->fill(),
+                  __flags == ios_base::oct || __flags == ios_base::hex
+                      ? static_cast<long>(static_cast<unsigned int>(__n))
+                      : static_cast<long>(__n))
+              .failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), __n).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), __n).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long long __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), __n).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), __n).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(float __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(double __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), __n).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(long double __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), __n).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::operator<<(const void* __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
+      const _Fp& __f = std::use_facet<_Fp>(this->getloc());
+      if (__f.put(*this, *this, this->fill(), __n).failed())
+        this->setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+__put_character_sequence(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str, size_t __len) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
+    if (__s) {
+      typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
+      if (std::__pad_and_output(
+              _Ip(__os),
+              __str,
+              (__os.flags() & ios_base::adjustfield) == ios_base::left ? __str + __len : __str,
+              __str + __len,
+              __os,
+              __os.fill())
+              .failed())
+        __os.setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    __os.__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return __os;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c) {
+  return std::__put_character_sequence(__os, &__c, 1);
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
+    if (__s) {
+      _CharT __c = __os.widen(__cn);
+      typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
+      if (std::__pad_and_output(
+              _Ip(__os),
+              &__c,
+              (__os.flags() & ios_base::adjustfield) == ios_base::left ? &__c + 1 : &__c,
+              &__c + 1,
+              __os,
+              __os.fill())
+              .failed())
+        __os.setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    __os.__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return __os;
+}
+
+template <class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, char __c) {
+  return std::__put_character_sequence(__os, &__c, 1);
+}
+
+template <class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, signed char __c) {
+  return std::__put_character_sequence(__os, (char*)&__c, 1);
+}
+
+template <class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c) {
+  return std::__put_character_sequence(__os, (char*)&__c, 1);
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str) {
+  return std::__put_character_sequence(__os, __str, _Traits::length(__str));
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
+    if (__s) {
+      typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
+      size_t __len   = char_traits<char>::length(__strn);
+      const int __bs = 100;
+      _CharT __wbb[__bs];
+      _CharT* __wb = __wbb;
+      unique_ptr<_CharT, void (*)(void*)> __h(0, free);
+      if (__len > __bs) {
+        __wb = (_CharT*)malloc(__len * sizeof(_CharT));
+        if (__wb == 0)
+          __throw_bad_alloc();
+        __h.reset(__wb);
+      }
+      for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
+        *__p = __os.widen(*__strn);
+      if (std::__pad_and_output(
+              _Ip(__os),
+              __wb,
+              (__os.flags() & ios_base::adjustfield) == ios_base::left ? __wb + __len : __wb,
+              __wb + __len,
+              __os,
+              __os.fill())
+              .failed())
+        __os.setstate(ios_base::badbit | ios_base::failbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    __os.__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return __os;
+}
+
+template <class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>& __os, const char* __str) {
+  return std::__put_character_sequence(__os, __str, _Traits::length(__str));
+}
+
+template <class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
+operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str) {
+  const char* __s = (const char*)__str;
+  return std::__put_character_sequence(__os, __s, _Traits::length(__s));
+}
+
+template <class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
+operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str) {
+  const char* __s = (const char*)__str;
+  return std::__put_character_sequence(__os, __s, _Traits::length(__s));
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::put(char_type __c) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __s(*this);
+    if (__s) {
+      typedef ostreambuf_iterator<_CharT, _Traits> _Op;
+      _Op __o(*this);
+      *__o = __c;
+      if (__o.failed())
+        this->setstate(ios_base::badbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    sentry __sen(*this);
+    if (__sen && __n) {
+      if (this->rdbuf()->sputn(__s, __n) != __n)
+        this->setstate(ios_base::badbit);
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::flush() {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    if (this->rdbuf()) {
+      sentry __s(*this);
+      if (__s) {
+        if (this->rdbuf()->pubsync() == -1)
+          this->setstate(ios_base::badbit);
+      }
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->__set_badbit_and_consider_rethrow();
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+typename basic_ostream<_CharT, _Traits>::pos_type basic_ostream<_CharT, _Traits>::tellp() {
+  if (this->fail())
+    return pos_type(-1);
+  return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(pos_type __pos) {
+  sentry __s(*this);
+  if (!this->fail()) {
+    if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
+      this->setstate(ios_base::failbit);
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir) {
+  sentry __s(*this);
+  if (!this->fail()) {
+    if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
+      this->setstate(ios_base::failbit);
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& endl(basic_ostream<_CharT, _Traits>& __os) {
+  __os.put(__os.widen('\n'));
+  __os.flush();
+  return __os;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& ends(basic_ostream<_CharT, _Traits>& __os) {
+  __os.put(_CharT());
+  return __os;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI inline basic_ostream<_CharT, _Traits>& flush(basic_ostream<_CharT, _Traits>& __os) {
+  __os.flush();
+  return __os;
+}
+
+template <class _Stream, class _Tp, class = void>
+struct __is_ostreamable : false_type {};
+
+template <class _Stream, class _Tp>
+struct __is_ostreamable<_Stream, _Tp, decltype(std::declval<_Stream>() << std::declval<_Tp>(), void())> : true_type {};
+
+template <class _Stream,
+          class _Tp,
+          __enable_if_t<_And<is_base_of<ios_base, _Stream>, __is_ostreamable<_Stream&, const _Tp&> >::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Stream&& operator<<(_Stream&& __os, const _Tp& __x) {
+  __os << __x;
+  return std::move(__os);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<_CharT, _Traits, _Allocator>& __str) {
+  return std::__put_character_sequence(__os, __str.data(), __str.size());
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __sv) {
+  return std::__put_character_sequence(__os, __sv.data(), __sv.size());
+}
+
+template <class _CharT, class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec) {
+  return __os << __ec.category().name() << ':' << __ec.value();
+}
+
+template <class _CharT, class _Traits, class _Yp>
+inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p) {
+  return __os << __p.get();
+}
+
+template <
+    class _CharT,
+    class _Traits,
+    class _Yp,
+    class _Dp,
+    __enable_if_t<is_same<void,
+                          __void_t<decltype((std::declval<basic_ostream<_CharT, _Traits>&>()
+                                             << std::declval<typename unique_ptr<_Yp, _Dp>::pointer>()))> >::value,
+                  int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p) {
+  return __os << __p.get();
+}
+
+template <class _CharT, class _Traits, size_t _Size>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x) {
+  return __os << __x.template to_string<_CharT, _Traits>(std::use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
+                                                         std::use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
+}
+
+#if _LIBCPP_STD_VER >= 20
+
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
+
+#  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;
+#  endif
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;
+
+#endif // _LIBCPP_STD_VER >= 20
+
+extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___OSTREAM_BASIC_OSTREAM_H
diff --git a/third_party/libcxx/__ostream/print.h b/third_party/libcxx/__ostream/print.h
new file mode 100644
index 000000000..8265ac007
--- /dev/null
+++ b/third_party/libcxx/__ostream/print.h
@@ -0,0 +1,179 @@
+//===---------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___OSTREAM_PRINT_H
+#define _LIBCPP___OSTREAM_PRINT_H
+
+#include <__config>
+#include <__fwd/ostream.h>
+#include <__iterator/ostreambuf_iterator.h>
+#include <__ostream/basic_ostream.h>
+#include <format>
+#include <ios>
+#include <locale>
+#include <print>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void
+__vprint_nonunicode(ostream& __os, string_view __fmt, format_args __args, bool __write_nl) {
+  // [ostream.formatted.print]/3
+  // Effects: Behaves as a formatted output function
+  // ([ostream.formatted.reqmts]) of os, except that:
+  // - failure to generate output is reported as specified below, and
+  // - any exception thrown by the call to vformat is propagated without regard
+  //   to the value of os.exceptions() and without turning on ios_base::badbit
+  //   in the error state of os.
+  // After constructing a sentry object, the function initializes an automatic
+  // variable via
+  //   string out = vformat(os.getloc(), fmt, args);
+
+  ostream::sentry __s(__os);
+  if (__s) {
+    string __o = std::vformat(__os.getloc(), __fmt, __args);
+    if (__write_nl)
+      __o += '\n';
+
+    const char* __str = __o.data();
+    size_t __len      = __o.size();
+
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      typedef ostreambuf_iterator<char> _Ip;
+      if (std::__pad_and_output(
+              _Ip(__os),
+              __str,
+              (__os.flags() & ios_base::adjustfield) == ios_base::left ? __str + __len : __str,
+              __str + __len,
+              __os,
+              __os.fill())
+              .failed())
+        __os.setstate(ios_base::badbit | ios_base::failbit);
+
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __os.__set_badbit_and_consider_rethrow();
+    }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(ostream& __os, string_view __fmt, format_args __args) {
+  std::__vprint_nonunicode(__os, __fmt, __args, false);
+}
+
+// Returns the FILE* associated with the __os.
+// Returns a nullptr when no FILE* is associated with __os.
+// This function is in the dylib since the type of the buffer associated
+// with std::cout, std::cerr, and std::clog is only known in the dylib.
+//
+// This function implements part of the implementation-defined behavior
+// of [ostream.formatted.print]/3
+//   If the function is vprint_unicode and os is a stream that refers to
+//   a terminal capable of displaying Unicode which is determined in an
+//   implementation-defined manner, writes out to the terminal using the
+//   native Unicode API;
+// Whether the returned FILE* is "a terminal capable of displaying Unicode"
+// is determined in the same way as the print(FILE*, ...) overloads.
+_LIBCPP_EXPORTED_FROM_ABI FILE* __get_ostream_file(ostream& __os);
+
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI void __vprint_unicode(ostream& __os, string_view __fmt, format_args __args, bool __write_nl) {
+#    if _LIBCPP_AVAILABILITY_HAS_PRINT == 0
+  return std::__vprint_nonunicode(__os, __fmt, __args, __write_nl);
+#    else
+  FILE* __file = std::__get_ostream_file(__os);
+  if (!__file || !__print::__is_terminal(__file))
+    return std::__vprint_nonunicode(__os, __fmt, __args, __write_nl);
+
+  // [ostream.formatted.print]/3
+  //    If the function is vprint_unicode and os is a stream that refers to a
+  //    terminal capable of displaying Unicode which is determined in an
+  //    implementation-defined manner, writes out to the terminal using the
+  //    native Unicode API; if out contains invalid code units, the behavior is
+  //    undefined and implementations are encouraged to diagnose it. If the
+  //    native Unicode API is used, the function flushes os before writing out.
+  //
+  // This is the path for the native API, start with flushing.
+  __os.flush();
+
+#      ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#      endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    ostream::sentry __s(__os);
+    if (__s) {
+#      ifndef _LIBCPP_WIN32API
+      __print::__vprint_unicode_posix(__file, __fmt, __args, __write_nl, true);
+#      elif !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+    __print::__vprint_unicode_windows(__file, __fmt, __args, __write_nl, true);
+#      else
+#        error "Windows builds with wchar_t disabled are not supported."
+#      endif
+    }
+
+#      ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    __os.__set_badbit_and_consider_rethrow();
+  }
+#      endif // _LIBCPP_HAS_NO_EXCEPTIONS
+#    endif   // _LIBCPP_AVAILABILITY_HAS_PRINT
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(ostream& __os, string_view __fmt, format_args __args) {
+  std::__vprint_unicode(__os, __fmt, __args, false);
+}
+#  endif // _LIBCPP_HAS_NO_UNICODE
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void print(ostream& __os, format_string<_Args...> __fmt, _Args&&... __args) {
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+  if constexpr (__print::__use_unicode_execution_charset)
+    std::__vprint_unicode(__os, __fmt.get(), std::make_format_args(__args...), false);
+  else
+    std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), false);
+#  else  // _LIBCPP_HAS_NO_UNICODE
+  std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), false);
+#  endif // _LIBCPP_HAS_NO_UNICODE
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void println(ostream& __os, format_string<_Args...> __fmt, _Args&&... __args) {
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+  // Note the wording in the Standard is inefficient. The output of
+  // std::format is a std::string which is then copied. This solution
+  // just appends a newline at the end of the output.
+  if constexpr (__print::__use_unicode_execution_charset)
+    std::__vprint_unicode(__os, __fmt.get(), std::make_format_args(__args...), true);
+  else
+    std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), true);
+#  else  // _LIBCPP_HAS_NO_UNICODE
+  std::__vprint_nonunicode(__os, __fmt.get(), std::make_format_args(__args...), true);
+#  endif // _LIBCPP_HAS_NO_UNICODE
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void println(ostream& __os) {
+  std::print(__os, "\n");
+}
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___OSTREAM_PRINT_H
diff --git a/third_party/libcxx/__pstl/backend.h b/third_party/libcxx/__pstl/backend.h
new file mode 100644
index 000000000..86d9f28c7
--- /dev/null
+++ b/third_party/libcxx/__pstl/backend.h
@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_BACKEND_H
+#define _LIBCPP___PSTL_BACKEND_H
+
+#include <__config>
+#include <__pstl/backend_fwd.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if defined(_LIBCPP_PSTL_BACKEND_SERIAL)
+#  include <__pstl/backends/default.h>
+#  include <__pstl/backends/serial.h>
+#elif defined(_LIBCPP_PSTL_BACKEND_STD_THREAD)
+#  include <__pstl/backends/default.h>
+#  include <__pstl/backends/std_thread.h>
+#elif defined(_LIBCPP_PSTL_BACKEND_LIBDISPATCH)
+#  include <__pstl/backends/default.h>
+#  include <__pstl/backends/libdispatch.h>
+#endif
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_BACKEND_H
diff --git a/third_party/libcxx/__pstl/backend_fwd.h b/third_party/libcxx/__pstl/backend_fwd.h
new file mode 100644
index 000000000..32c5da576
--- /dev/null
+++ b/third_party/libcxx/__pstl/backend_fwd.h
@@ -0,0 +1,301 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_BACKEND_FWD_H
+#define _LIBCPP___PSTL_BACKEND_FWD_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+//
+// This header declares available PSTL backends and the functions that must be implemented in order for the
+// PSTL algorithms to be provided.
+//
+// Backends often do not implement the full set of functions themselves -- a configuration of the PSTL is
+// usually a set of backends "stacked" together which each implement some algorithms under some execution
+// policies. It is only necessary for the "stack" of backends to implement all algorithms under all execution
+// policies, but a single backend is not required to implement everything on its own.
+//
+// The signatures used by each backend function are documented below.
+//
+// Exception handling
+// ==================
+//
+// PSTL backends are expected to report errors (i.e. failure to allocate) by returning a disengaged `optional` from
+// their implementation. Exceptions shouldn't be used to report an internal failure-to-allocate, since all exceptions
+// are turned into a program termination at the front-end level. When a backend returns a disengaged `optional` to the
+// frontend, the frontend will turn that into a call to `std::__throw_bad_alloc();` to report the internal failure to
+// the user.
+//
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <class... _Backends>
+struct __backend_configuration;
+
+struct __default_backend_tag;
+struct __libdispatch_backend_tag;
+struct __serial_backend_tag;
+struct __std_thread_backend_tag;
+
+#if defined(_LIBCPP_PSTL_BACKEND_SERIAL)
+using __current_configuration = __backend_configuration<__serial_backend_tag, __default_backend_tag>;
+#elif defined(_LIBCPP_PSTL_BACKEND_STD_THREAD)
+using __current_configuration = __backend_configuration<__std_thread_backend_tag, __default_backend_tag>;
+#elif defined(_LIBCPP_PSTL_BACKEND_LIBDISPATCH)
+using __current_configuration = __backend_configuration<__libdispatch_backend_tag, __default_backend_tag>;
+#else
+
+// ...New vendors can add parallel backends here...
+
+#  error "Invalid PSTL backend configuration"
+#endif
+
+template <class _Backend, class _ExecutionPolicy>
+struct __find_if;
+// template <class _Policy, class _ForwardIterator, class _Predicate>
+// optional<_ForwardIterator>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __find_if_not;
+// template <class _Policy, class _ForwardIterator, class _Predicate>
+// optional<_ForwardIterator>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __find;
+// template <class _Policy, class _ForwardIterator, class _Tp>
+// optional<_ForwardIterator>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __any_of;
+// template <class _Policy, class _ForwardIterator, class _Predicate>
+// optional<bool>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __all_of;
+// template <class _Policy, class _ForwardIterator, class _Predicate>
+// optional<bool>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __none_of;
+// template <class _Policy, class _ForwardIterator, class _Predicate>
+// optional<bool>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __is_partitioned;
+// template <class _Policy, class _ForwardIterator, class _Predicate>
+// optional<bool>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __for_each;
+// template <class _Policy, class _ForwardIterator, class _Function>
+// optional<__empty>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __func) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __for_each_n;
+// template <class _Policy, class _ForwardIterator, class _Size, class _Function>
+// optional<__empty>
+// operator()(_Policy&&, _ForwardIterator __first, _Size __size, _Function __func) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __fill;
+// template <class _Policy, class _ForwardIterator, class _Tp>
+// optional<__empty>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __fill_n;
+// template <class _Policy, class _ForwardIterator, class _Size, class _Tp>
+// optional<__empty>
+// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _Tp const& __value) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __replace;
+// template <class _Policy, class _ForwardIterator, class _Tp>
+// optional<__empty>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
+//                       _Tp const& __old, _Tp const& __new) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __replace_if;
+// template <class _Policy, class _ForwardIterator, class _Predicate, class _Tp>
+// optional<__empty>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
+//                       _Predicate __pred, _Tp const& __new_value) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __generate;
+// template <class _Policy, class _ForwardIterator, class _Generator>
+// optional<__empty>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __gen) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __generate_n;
+// template <class _Policy, class _ForwardIterator, class _Size, class _Generator>
+// optional<__empty>
+// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _Generator __gen) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __merge;
+// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardOutIterator, class _Comp>
+// optional<_ForwardOutIterator>
+// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+//                       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+//                       _ForwardOutIterator __result, _Comp __comp) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __stable_sort;
+// template <class _Policy, class _RandomAccessIterator, class _Comp>
+// optional<__empty>
+// operator()(_Policy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __sort;
+// template <class _Policy, class _RandomAccessIterator, class _Comp>
+// optional<__empty>
+// operator()(_Policy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __transform;
+// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _UnaryOperation>
+// optional<_ForwardOutIterator>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
+//                       _ForwardOutIterator __result,
+//                       _UnaryOperation __op) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __transform_binary;
+// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
+//                          class _ForwardOutIterator,
+//                          class _BinaryOperation>
+// optional<_ForwardOutIterator>
+// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+//                       _ForwardIterator2 __first2,
+//                       _ForwardOutIterator __result,
+//                       _BinaryOperation __op) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __replace_copy_if;
+// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Predicate, class _Tp>
+// optional<__empty>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
+//                       _ForwardOutIterator __out_it,
+//                       _Predicate __pred,
+//                       _Tp const& __new_value) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __replace_copy;
+// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Tp>
+// optional<__empty>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
+//                       _ForwardOutIterator __out_it,
+//                       _Tp const& __old_value,
+//                       _Tp const& __new_value) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __move;
+// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
+// optional<_ForwardOutIterator>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
+//                       _ForwardOutIterator __out_it) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __copy;
+// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
+// optional<_ForwardOutIterator>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
+//                       _ForwardOutIterator __out_it) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __copy_n;
+// template <class _Policy, class _ForwardIterator, class _Size, class _ForwardOutIterator>
+// optional<_ForwardOutIterator>
+// operator()(_Policy&&, _ForwardIterator __first, _Size __n, _ForwardOutIterator __out_it) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __rotate_copy;
+// template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
+// optional<_ForwardOutIterator>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last,
+//                       _ForwardOutIterator __out_it) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __transform_reduce;
+// template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
+// optional<_Tp>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
+//                       _Tp __init,
+//                       _BinaryOperation __reduce,
+//                       _UnaryOperation __transform) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __transform_reduce_binary;
+// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2,
+//           class _Tp, class _BinaryOperation1, class _BinaryOperation2>
+// optional<_Tp> operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+//                                     _ForwardIterator2 __first2,
+//                                     _Tp __init,
+//                                     _BinaryOperation1 __reduce,
+//                                     _BinaryOperation2 __transform) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __count_if;
+// template <class _Policy, class _ForwardIterator, class _Predicate>
+// optional<__iter_diff_t<_ForwardIterator>>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __count;
+// template <class _Policy, class _ForwardIterator, class _Tp>
+// optional<__iter_diff_t<_ForwardIterator>>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __equal_3leg;
+// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
+// optional<bool>
+// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+//                       _ForwardIterator2 __first2,
+//                       _Predicate __pred) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __equal;
+// template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
+// optional<bool>
+// operator()(_Policy&&, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
+//                       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+//                       _Predicate __pred) const noexcept;
+
+template <class _Backend, class _ExecutionPolicy>
+struct __reduce;
+// template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation>
+// optional<_Tp>
+// operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last,
+//                       _Tp __init, _BinaryOperation __op) const noexcept;
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_BACKEND_FWD_H
diff --git a/third_party/libcxx/__pstl/backends/default.h b/third_party/libcxx/__pstl/backends/default.h
new file mode 100644
index 000000000..61a128805
--- /dev/null
+++ b/third_party/libcxx/__pstl/backends/default.h
@@ -0,0 +1,503 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_BACKENDS_DEFAULT_H
+#define _LIBCPP___PSTL_BACKENDS_DEFAULT_H
+
+#include <__algorithm/copy_n.h>
+#include <__algorithm/equal.h>
+#include <__algorithm/fill_n.h>
+#include <__algorithm/for_each_n.h>
+#include <__config>
+#include <__functional/identity.h>
+#include <__functional/not_fn.h>
+#include <__functional/operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/dispatch.h>
+#include <__utility/empty.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+//
+// This file provides an incomplete PSTL backend that implements all of the PSTL algorithms
+// based on a smaller set of basis operations.
+//
+// It is intended as a building block for other PSTL backends that implement some operations more
+// efficiently but may not want to define the full set of PSTL algorithms.
+//
+// This backend implements all the PSTL algorithms based on the following basis operations:
+//
+// find_if family
+// --------------
+// - find
+// - find_if_not
+// - any_of
+// - all_of
+// - none_of
+// - is_partitioned
+//
+// for_each family
+// ---------------
+// - for_each_n
+// - fill
+// - fill_n
+// - replace
+// - replace_if
+// - generate
+// - generate_n
+//
+// merge family
+// ------------
+// No other algorithms based on merge
+//
+// stable_sort family
+// ------------------
+// - sort
+//
+// transform_reduce and transform_reduce_binary family
+// ---------------------------------------------------
+// - count_if
+// - count
+// - equal(3 legs)
+// - equal
+// - reduce
+//
+// transform and transform_binary family
+// -------------------------------------
+// - replace_copy_if
+// - replace_copy
+// - move
+// - copy
+// - copy_n
+// - rotate_copy
+//
+
+//////////////////////////////////////////////////////////////
+// find_if family
+//////////////////////////////////////////////////////////////
+template <class _ExecutionPolicy>
+struct __find<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<_ForwardIterator>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) const noexcept {
+    using _FindIf = __dispatch<__find_if, __current_configuration, _ExecutionPolicy>;
+    return _FindIf()(
+        __policy, std::move(__first), std::move(__last), [&](__iter_reference<_ForwardIterator> __element) {
+          return __element == __value;
+        });
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __find_if_not<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<_ForwardIterator>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred) const noexcept {
+    using _FindIf = __dispatch<__find_if, __current_configuration, _ExecutionPolicy>;
+    return _FindIf()(__policy, __first, __last, std::not_fn(std::forward<_Pred>(__pred)));
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __any_of<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<bool>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred) const noexcept {
+    using _FindIf = __dispatch<__find_if, __current_configuration, _ExecutionPolicy>;
+    auto __res    = _FindIf()(__policy, __first, __last, std::forward<_Pred>(__pred));
+    if (!__res)
+      return nullopt;
+    return *__res != __last;
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __all_of<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<bool>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred) const noexcept {
+    using _AnyOf = __dispatch<__any_of, __current_configuration, _ExecutionPolicy>;
+    auto __res   = _AnyOf()(__policy, __first, __last, [&](__iter_reference<_ForwardIterator> __value) {
+      return !__pred(__value);
+    });
+    if (!__res)
+      return nullopt;
+    return !*__res;
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __none_of<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<bool>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred) const noexcept {
+    using _AnyOf = __dispatch<__any_of, __current_configuration, _ExecutionPolicy>;
+    auto __res   = _AnyOf()(__policy, __first, __last, std::forward<_Pred>(__pred));
+    if (!__res)
+      return nullopt;
+    return !*__res;
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __is_partitioned<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<bool>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred) const noexcept {
+    using _FindIfNot   = __dispatch<__find_if_not, __current_configuration, _ExecutionPolicy>;
+    auto __maybe_first = _FindIfNot()(__policy, std::move(__first), std::move(__last), __pred);
+    if (__maybe_first == nullopt)
+      return nullopt;
+
+    __first = *__maybe_first;
+    if (__first == __last)
+      return true;
+    ++__first;
+    using _NoneOf = __dispatch<__none_of, __current_configuration, _ExecutionPolicy>;
+    return _NoneOf()(__policy, std::move(__first), std::move(__last), __pred);
+  }
+};
+
+//////////////////////////////////////////////////////////////
+// for_each family
+//////////////////////////////////////////////////////////////
+template <class _ExecutionPolicy>
+struct __for_each_n<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Size, class _Function>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _Size __size, _Function __func) const noexcept {
+    if constexpr (__has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      using _ForEach          = __dispatch<__for_each, __current_configuration, _ExecutionPolicy>;
+      _ForwardIterator __last = __first + __size;
+      return _ForEach()(__policy, std::move(__first), std::move(__last), std::move(__func));
+    } else {
+      // Otherwise, use the serial algorithm to avoid doing two passes over the input
+      std::for_each_n(std::move(__first), __size, std::move(__func));
+      return __empty{};
+    }
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __fill<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept {
+    using _ForEach = __dispatch<__for_each, __current_configuration, _ExecutionPolicy>;
+    using _Ref     = __iter_reference<_ForwardIterator>;
+    return _ForEach()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) { __element = __value; });
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __fill_n<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Size, class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n, _Tp const& __value) const noexcept {
+    if constexpr (__has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      using _Fill             = __dispatch<__fill, __current_configuration, _ExecutionPolicy>;
+      _ForwardIterator __last = __first + __n;
+      return _Fill()(__policy, std::move(__first), std::move(__last), __value);
+    } else {
+      // Otherwise, use the serial algorithm to avoid doing two passes over the input
+      std::fill_n(std::move(__first), __n, __value);
+      return optional<__empty>{__empty{}};
+    }
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __replace<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __old, _Tp const& __new)
+      const noexcept {
+    using _ReplaceIf = __dispatch<__replace_if, __current_configuration, _ExecutionPolicy>;
+    using _Ref       = __iter_reference<_ForwardIterator>;
+    return _ReplaceIf()(
+        __policy, std::move(__first), std::move(__last), [&](_Ref __element) { return __element == __old; }, __new);
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __replace_if<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Pred, class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty> operator()(
+      _Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred, _Tp const& __new_value)
+      const noexcept {
+    using _ForEach = __dispatch<__for_each, __current_configuration, _ExecutionPolicy>;
+    using _Ref     = __iter_reference<_ForwardIterator>;
+    return _ForEach()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) {
+      if (__pred(__element))
+        __element = __new_value;
+    });
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __generate<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Generator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Generator&& __gen) const noexcept {
+    using _ForEach = __dispatch<__for_each, __current_configuration, _ExecutionPolicy>;
+    using _Ref     = __iter_reference<_ForwardIterator>;
+    return _ForEach()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) { __element = __gen(); });
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __generate_n<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Size, class _Generator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n, _Generator&& __gen) const noexcept {
+    using _ForEachN = __dispatch<__for_each_n, __current_configuration, _ExecutionPolicy>;
+    using _Ref      = __iter_reference<_ForwardIterator>;
+    return _ForEachN()(__policy, std::move(__first), __n, [&](_Ref __element) { __element = __gen(); });
+  }
+};
+
+//////////////////////////////////////////////////////////////
+// stable_sort family
+//////////////////////////////////////////////////////////////
+template <class _ExecutionPolicy>
+struct __sort<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _RandomAccessIterator, class _Comp>
+  _LIBCPP_HIDE_FROM_ABI optional<__empty> operator()(
+      _Policy&& __policy, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp&& __comp) const noexcept {
+    using _StableSort = __dispatch<__stable_sort, __current_configuration, _ExecutionPolicy>;
+    return _StableSort()(__policy, std::move(__first), std::move(__last), std::forward<_Comp>(__comp));
+  }
+};
+
+//////////////////////////////////////////////////////////////
+// transform_reduce family
+//////////////////////////////////////////////////////////////
+template <class _ExecutionPolicy>
+struct __count_if<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Predicate>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__iter_diff_t<_ForwardIterator>> operator()(
+      _Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate&& __pred) const noexcept {
+    using _TransformReduce = __dispatch<__transform_reduce, __current_configuration, _ExecutionPolicy>;
+    using _DiffT           = __iter_diff_t<_ForwardIterator>;
+    using _Ref             = __iter_reference<_ForwardIterator>;
+    return _TransformReduce()(
+        __policy, std::move(__first), std::move(__last), _DiffT{}, std::plus{}, [&](_Ref __element) -> _DiffT {
+          return __pred(__element) ? _DiffT(1) : _DiffT(0);
+        });
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __count<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__iter_diff_t<_ForwardIterator>>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept {
+    using _CountIf = __dispatch<__count_if, __current_configuration, _ExecutionPolicy>;
+    using _Ref     = __iter_reference<_ForwardIterator>;
+    return _CountIf()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) -> bool {
+      return __element == __value;
+    });
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __equal_3leg<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<bool>
+  operator()(_Policy&& __policy,
+             _ForwardIterator1 __first1,
+             _ForwardIterator1 __last1,
+             _ForwardIterator2 __first2,
+             _Predicate&& __pred) const noexcept {
+    using _TransformReduce = __dispatch<__transform_reduce_binary, __current_configuration, _ExecutionPolicy>;
+    return _TransformReduce()(
+        __policy,
+        std::move(__first1),
+        std::move(__last1),
+        std::move(__first2),
+        true,
+        std::logical_and{},
+        std::forward<_Predicate>(__pred));
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __equal<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<bool>
+  operator()(_Policy&& __policy,
+             _ForwardIterator1 __first1,
+             _ForwardIterator1 __last1,
+             _ForwardIterator2 __first2,
+             _ForwardIterator2 __last2,
+             _Predicate&& __pred) const noexcept {
+    if constexpr (__has_random_access_iterator_category<_ForwardIterator1>::value &&
+                  __has_random_access_iterator_category<_ForwardIterator2>::value) {
+      if (__last1 - __first1 != __last2 - __first2)
+        return false;
+      // Fall back to the 3 legged algorithm
+      using _Equal3Leg = __dispatch<__equal_3leg, __current_configuration, _ExecutionPolicy>;
+      return _Equal3Leg()(
+          __policy, std::move(__first1), std::move(__last1), std::move(__first2), std::forward<_Predicate>(__pred));
+    } else {
+      // If we don't have random access, fall back to the serial algorithm cause we can't do much
+      return std::equal(
+          std::move(__first1),
+          std::move(__last1),
+          std::move(__first2),
+          std::move(__last2),
+          std::forward<_Predicate>(__pred));
+    }
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __reduce<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<_Tp>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp __init, _BinaryOperation&& __op)
+      const noexcept {
+    using _TransformReduce = __dispatch<__transform_reduce, __current_configuration, _ExecutionPolicy>;
+    return _TransformReduce()(
+        __policy,
+        std::move(__first),
+        std::move(__last),
+        std::move(__init),
+        std::forward<_BinaryOperation>(__op),
+        __identity{});
+  }
+};
+
+//////////////////////////////////////////////////////////////
+// transform family
+//////////////////////////////////////////////////////////////
+template <class _ExecutionPolicy>
+struct __replace_copy_if<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Pred, class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&& __policy,
+             _ForwardIterator __first,
+             _ForwardIterator __last,
+             _ForwardOutIterator __out_it,
+             _Pred&& __pred,
+             _Tp const& __new_value) const noexcept {
+    using _Transform = __dispatch<__transform, __current_configuration, _ExecutionPolicy>;
+    using _Ref       = __iter_reference<_ForwardIterator>;
+    auto __res =
+        _Transform()(__policy, std::move(__first), std::move(__last), std::move(__out_it), [&](_Ref __element) {
+          return __pred(__element) ? __new_value : __element;
+        });
+    if (__res == nullopt)
+      return nullopt;
+    return __empty{};
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __replace_copy<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&& __policy,
+             _ForwardIterator __first,
+             _ForwardIterator __last,
+             _ForwardOutIterator __out_it,
+             _Tp const& __old_value,
+             _Tp const& __new_value) const noexcept {
+    using _ReplaceCopyIf = __dispatch<__replace_copy_if, __current_configuration, _ExecutionPolicy>;
+    using _Ref           = __iter_reference<_ForwardIterator>;
+    return _ReplaceCopyIf()(
+        __policy,
+        std::move(__first),
+        std::move(__last),
+        std::move(__out_it),
+        [&](_Ref __element) { return __element == __old_value; },
+        __new_value);
+  }
+};
+
+// TODO: Use the std::copy/move shenanigans to forward to std::memmove
+//       Investigate whether we want to still forward to std::transform(policy)
+//       in that case for the execution::par part, or whether we actually want
+//       to run everything serially in that case.
+template <class _ExecutionPolicy>
+struct __move<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<_ForwardOutIterator>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __out_it)
+      const noexcept {
+    using _Transform = __dispatch<__transform, __current_configuration, _ExecutionPolicy>;
+    return _Transform()(__policy, std::move(__first), std::move(__last), std::move(__out_it), [&](auto&& __element) {
+      return std::move(__element);
+    });
+  }
+};
+
+// TODO: Use the std::copy/move shenanigans to forward to std::memmove
+template <class _ExecutionPolicy>
+struct __copy<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<_ForwardOutIterator>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __out_it)
+      const noexcept {
+    using _Transform = __dispatch<__transform, __current_configuration, _ExecutionPolicy>;
+    return _Transform()(__policy, std::move(__first), std::move(__last), std::move(__out_it), __identity());
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __copy_n<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Size, class _ForwardOutIterator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<_ForwardOutIterator>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n, _ForwardOutIterator __out_it) const noexcept {
+    if constexpr (__has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      using _Copy             = __dispatch<__copy, __current_configuration, _ExecutionPolicy>;
+      _ForwardIterator __last = __first + __n;
+      return _Copy()(__policy, std::move(__first), std::move(__last), std::move(__out_it));
+    } else {
+      // Otherwise, use the serial algorithm to avoid doing two passes over the input
+      return std::copy_n(std::move(__first), __n, std::move(__out_it));
+    }
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __rotate_copy<__default_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _ForwardOutIterator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<_ForwardOutIterator>
+  operator()(_Policy&& __policy,
+             _ForwardIterator __first,
+             _ForwardIterator __middle,
+             _ForwardIterator __last,
+             _ForwardOutIterator __out_it) const noexcept {
+    using _Copy       = __dispatch<__copy, __current_configuration, _ExecutionPolicy>;
+    auto __result_mid = _Copy()(__policy, __middle, std::move(__last), std::move(__out_it));
+    if (__result_mid == nullopt)
+      return nullopt;
+    return _Copy()(__policy, std::move(__first), std::move(__middle), *std::move(__result_mid));
+  }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_BACKENDS_DEFAULT_H
diff --git a/third_party/libcxx/__pstl/backends/libdispatch.h b/third_party/libcxx/__pstl/backends/libdispatch.h
new file mode 100644
index 000000000..a0c3ad980
--- /dev/null
+++ b/third_party/libcxx/__pstl/backends/libdispatch.h
@@ -0,0 +1,397 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_BACKENDS_LIBDISPATCH_H
+#define _LIBCPP___PSTL_BACKENDS_LIBDISPATCH_H
+
+#include <__algorithm/inplace_merge.h>
+#include <__algorithm/lower_bound.h>
+#include <__algorithm/max.h>
+#include <__algorithm/merge.h>
+#include <__algorithm/upper_bound.h>
+#include <__atomic/atomic.h>
+#include <__config>
+#include <__exception/terminate.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/move_iterator.h>
+#include <__memory/allocator.h>
+#include <__memory/construct_at.h>
+#include <__memory/unique_ptr.h>
+#include <__numeric/reduce.h>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/any_of.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__pstl/cpu_algos/fill.h>
+#include <__pstl/cpu_algos/find_if.h>
+#include <__pstl/cpu_algos/for_each.h>
+#include <__pstl/cpu_algos/merge.h>
+#include <__pstl/cpu_algos/stable_sort.h>
+#include <__pstl/cpu_algos/transform.h>
+#include <__pstl/cpu_algos/transform_reduce.h>
+#include <__utility/empty.h>
+#include <__utility/exception_guard.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <cstddef>
+#include <new>
+#include <optional>
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+namespace __libdispatch {
+// ::dispatch_apply is marked as __attribute__((nothrow)) because it doesn't let exceptions propagate, and neither do
+// we.
+// TODO: Do we want to add [[_Clang::__callback__(__func, __context, __)]]?
+_LIBCPP_EXPORTED_FROM_ABI void
+__dispatch_apply(size_t __chunk_count, void* __context, void (*__func)(void* __context, size_t __chunk)) noexcept;
+
+template <class _Func>
+_LIBCPP_HIDE_FROM_ABI void __dispatch_apply(size_t __chunk_count, _Func __func) noexcept {
+  __libdispatch::__dispatch_apply(__chunk_count, &__func, [](void* __context, size_t __chunk) {
+    (*static_cast<_Func*>(__context))(__chunk);
+  });
+}
+
+struct __chunk_partitions {
+  ptrdiff_t __chunk_count_; // includes the first chunk
+  ptrdiff_t __chunk_size_;
+  ptrdiff_t __first_chunk_size_;
+};
+
+[[__gnu__::__const__]] _LIBCPP_EXPORTED_FROM_ABI __chunk_partitions __partition_chunks(ptrdiff_t __size) noexcept;
+
+template <class _RandomAccessIterator, class _Functor>
+_LIBCPP_HIDE_FROM_ABI optional<__empty>
+__dispatch_parallel_for(__chunk_partitions __partitions, _RandomAccessIterator __first, _Functor __func) {
+  // Perform the chunked execution.
+  __libdispatch::__dispatch_apply(__partitions.__chunk_count_, [&](size_t __chunk) {
+    auto __this_chunk_size = __chunk == 0 ? __partitions.__first_chunk_size_ : __partitions.__chunk_size_;
+    auto __index =
+        __chunk == 0
+            ? 0
+            : (__chunk * __partitions.__chunk_size_) + (__partitions.__first_chunk_size_ - __partitions.__chunk_size_);
+    __func(__first + __index, __first + __index + __this_chunk_size);
+  });
+
+  return __empty{};
+}
+} // namespace __libdispatch
+
+template <>
+struct __cpu_traits<__libdispatch_backend_tag> {
+  template <class _RandomAccessIterator, class _Functor>
+  _LIBCPP_HIDE_FROM_ABI static optional<__empty>
+  __for_each(_RandomAccessIterator __first, _RandomAccessIterator __last, _Functor __func) {
+    return __libdispatch::__dispatch_parallel_for(
+        __libdispatch::__partition_chunks(__last - __first), std::move(__first), std::move(__func));
+  }
+
+  template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIteratorOut>
+  struct __merge_range {
+    __merge_range(_RandomAccessIterator1 __mid1, _RandomAccessIterator2 __mid2, _RandomAccessIteratorOut __result)
+        : __mid1_(__mid1), __mid2_(__mid2), __result_(__result) {}
+
+    _RandomAccessIterator1 __mid1_;
+    _RandomAccessIterator2 __mid2_;
+    _RandomAccessIteratorOut __result_;
+  };
+
+  template <typename _RandomAccessIterator1,
+            typename _RandomAccessIterator2,
+            typename _RandomAccessIterator3,
+            typename _Compare,
+            typename _LeafMerge>
+  _LIBCPP_HIDE_FROM_ABI static optional<__empty>
+  __merge(_RandomAccessIterator1 __first1,
+          _RandomAccessIterator1 __last1,
+          _RandomAccessIterator2 __first2,
+          _RandomAccessIterator2 __last2,
+          _RandomAccessIterator3 __result,
+          _Compare __comp,
+          _LeafMerge __leaf_merge) noexcept {
+    __libdispatch::__chunk_partitions __partitions =
+        __libdispatch::__partition_chunks(std::max<ptrdiff_t>(__last1 - __first1, __last2 - __first2));
+
+    if (__partitions.__chunk_count_ == 0)
+      return __empty{};
+
+    if (__partitions.__chunk_count_ == 1) {
+      __leaf_merge(__first1, __last1, __first2, __last2, __result, __comp);
+      return __empty{};
+    }
+
+    using __merge_range_t = __merge_range<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3>;
+    auto const __n_ranges = __partitions.__chunk_count_ + 1;
+
+    // TODO: use __uninitialized_buffer
+    auto __destroy = [=](__merge_range_t* __ptr) {
+      std::destroy_n(__ptr, __n_ranges);
+      std::allocator<__merge_range_t>().deallocate(__ptr, __n_ranges);
+    };
+
+    unique_ptr<__merge_range_t[], decltype(__destroy)> __ranges(
+        [&]() -> __merge_range_t* {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+          try {
+#endif
+            return std::allocator<__merge_range_t>().allocate(__n_ranges);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+          } catch (const std::bad_alloc&) {
+            return nullptr;
+          }
+#endif
+        }(),
+        __destroy);
+
+    if (!__ranges)
+      return nullopt;
+
+    // TODO: Improve the case where the smaller range is merged into just a few (or even one) chunks of the larger case
+    __merge_range_t* __r = __ranges.get();
+    std::__construct_at(__r++, __first1, __first2, __result);
+
+    bool __iterate_first_range = __last1 - __first1 > __last2 - __first2;
+
+    auto __compute_chunk = [&](size_t __chunk_size) -> __merge_range_t {
+      auto [__mid1, __mid2] = [&] {
+        if (__iterate_first_range) {
+          auto __m1 = __first1 + __chunk_size;
+          auto __m2 = std::lower_bound(__first2, __last2, __m1[-1], __comp);
+          return std::make_pair(__m1, __m2);
+        } else {
+          auto __m2 = __first2 + __chunk_size;
+          auto __m1 = std::lower_bound(__first1, __last1, __m2[-1], __comp);
+          return std::make_pair(__m1, __m2);
+        }
+      }();
+
+      __result += (__mid1 - __first1) + (__mid2 - __first2);
+      __first1 = __mid1;
+      __first2 = __mid2;
+      return {std::move(__mid1), std::move(__mid2), __result};
+    };
+
+    // handle first chunk
+    std::__construct_at(__r++, __compute_chunk(__partitions.__first_chunk_size_));
+
+    // handle 2 -> N - 1 chunks
+    for (ptrdiff_t __i = 0; __i != __partitions.__chunk_count_ - 2; ++__i)
+      std::__construct_at(__r++, __compute_chunk(__partitions.__chunk_size_));
+
+    // handle last chunk
+    std::__construct_at(__r, __last1, __last2, __result);
+
+    __libdispatch::__dispatch_apply(__partitions.__chunk_count_, [&](size_t __index) {
+      auto __first_iters = __ranges[__index];
+      auto __last_iters  = __ranges[__index + 1];
+      __leaf_merge(
+          __first_iters.__mid1_,
+          __last_iters.__mid1_,
+          __first_iters.__mid2_,
+          __last_iters.__mid2_,
+          __first_iters.__result_,
+          __comp);
+    });
+
+    return __empty{};
+  }
+
+  template <class _RandomAccessIterator, class _Transform, class _Value, class _Combiner, class _Reduction>
+  _LIBCPP_HIDE_FROM_ABI static optional<_Value> __transform_reduce(
+      _RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Transform __transform,
+      _Value __init,
+      _Combiner __combiner,
+      _Reduction __reduction) {
+    if (__first == __last)
+      return __init;
+
+    auto __partitions = __libdispatch::__partition_chunks(__last - __first);
+
+    auto __destroy = [__count = __partitions.__chunk_count_](_Value* __ptr) {
+      std::destroy_n(__ptr, __count);
+      std::allocator<_Value>().deallocate(__ptr, __count);
+    };
+
+    // TODO: use __uninitialized_buffer
+    // TODO: allocate one element per worker instead of one element per chunk
+    unique_ptr<_Value[], decltype(__destroy)> __values(
+        std::allocator<_Value>().allocate(__partitions.__chunk_count_), __destroy);
+
+    // __dispatch_apply is noexcept
+    __libdispatch::__dispatch_apply(__partitions.__chunk_count_, [&](size_t __chunk) {
+      auto __this_chunk_size = __chunk == 0 ? __partitions.__first_chunk_size_ : __partitions.__chunk_size_;
+      auto __index           = __chunk == 0 ? 0
+                                            : (__chunk * __partitions.__chunk_size_) +
+                                        (__partitions.__first_chunk_size_ - __partitions.__chunk_size_);
+      if (__this_chunk_size != 1) {
+        std::__construct_at(
+            __values.get() + __chunk,
+            __reduction(__first + __index + 2,
+                        __first + __index + __this_chunk_size,
+                        __combiner(__transform(__first + __index), __transform(__first + __index + 1))));
+      } else {
+        std::__construct_at(__values.get() + __chunk, __transform(__first + __index));
+      }
+    });
+
+    return std::reduce(
+        std::make_move_iterator(__values.get()),
+        std::make_move_iterator(__values.get() + __partitions.__chunk_count_),
+        std::move(__init),
+        __combiner);
+  }
+
+  template <class _RandomAccessIterator, class _Comp, class _LeafSort>
+  _LIBCPP_HIDE_FROM_ABI static optional<__empty>
+  __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp, _LeafSort __leaf_sort) {
+    const auto __size = __last - __first;
+    auto __partitions = __libdispatch::__partition_chunks(__size);
+
+    if (__partitions.__chunk_count_ == 0)
+      return __empty{};
+
+    if (__partitions.__chunk_count_ == 1) {
+      __leaf_sort(__first, __last, __comp);
+      return __empty{};
+    }
+
+    using _Value = __iter_value_type<_RandomAccessIterator>;
+
+    auto __destroy = [__size](_Value* __ptr) {
+      std::destroy_n(__ptr, __size);
+      std::allocator<_Value>().deallocate(__ptr, __size);
+    };
+
+    // TODO: use __uninitialized_buffer
+    unique_ptr<_Value[], decltype(__destroy)> __values(std::allocator<_Value>().allocate(__size), __destroy);
+
+    // Initialize all elements to a moved-from state
+    // TODO: Don't do this - this can be done in the first merge - see https://llvm.org/PR63928
+    std::__construct_at(__values.get(), std::move(*__first));
+    for (__iter_diff_t<_RandomAccessIterator> __i = 1; __i != __size; ++__i) {
+      std::__construct_at(__values.get() + __i, std::move(__values.get()[__i - 1]));
+    }
+    *__first = std::move(__values.get()[__size - 1]);
+
+    __libdispatch::__dispatch_parallel_for(
+        __partitions,
+        __first,
+        [&__leaf_sort, &__comp](_RandomAccessIterator __chunk_first, _RandomAccessIterator __chunk_last) {
+          __leaf_sort(std::move(__chunk_first), std::move(__chunk_last), __comp);
+        });
+
+    bool __objects_are_in_buffer = false;
+    do {
+      const auto __old_chunk_size = __partitions.__chunk_size_;
+      if (__partitions.__chunk_count_ % 2 == 1) {
+        auto __inplace_merge_chunks = [&__comp, &__partitions](auto __first_chunk_begin) {
+          std::inplace_merge(
+              __first_chunk_begin,
+              __first_chunk_begin + __partitions.__first_chunk_size_,
+              __first_chunk_begin + __partitions.__first_chunk_size_ + __partitions.__chunk_size_,
+              __comp);
+        };
+        if (__objects_are_in_buffer)
+          __inplace_merge_chunks(__values.get());
+        else
+          __inplace_merge_chunks(__first);
+        __partitions.__first_chunk_size_ += 2 * __partitions.__chunk_size_;
+      } else {
+        __partitions.__first_chunk_size_ += __partitions.__chunk_size_;
+      }
+
+      __partitions.__chunk_size_ *= 2;
+      __partitions.__chunk_count_ /= 2;
+
+      auto __merge_chunks = [__partitions, __old_chunk_size, &__comp](auto __from_first, auto __to_first) {
+        __libdispatch::__dispatch_parallel_for(
+            __partitions,
+            __from_first,
+            [__old_chunk_size, &__from_first, &__to_first, &__comp](auto __chunk_first, auto __chunk_last) {
+              std::merge(std::make_move_iterator(__chunk_first),
+                         std::make_move_iterator(__chunk_last - __old_chunk_size),
+                         std::make_move_iterator(__chunk_last - __old_chunk_size),
+                         std::make_move_iterator(__chunk_last),
+                         __to_first + (__chunk_first - __from_first),
+                         __comp);
+            });
+      };
+
+      if (__objects_are_in_buffer)
+        __merge_chunks(__values.get(), __first);
+      else
+        __merge_chunks(__first, __values.get());
+      __objects_are_in_buffer = !__objects_are_in_buffer;
+    } while (__partitions.__chunk_count_ > 1);
+
+    if (__objects_are_in_buffer) {
+      std::move(__values.get(), __values.get() + __size, __first);
+    }
+
+    return __empty{};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static void __cancel_execution() {}
+
+  static constexpr size_t __lane_size = 64;
+};
+
+// Mandatory implementations of the computational basis
+template <class _ExecutionPolicy>
+struct __find_if<__libdispatch_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_find_if<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __for_each<__libdispatch_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_for_each<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __merge<__libdispatch_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_merge<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __stable_sort<__libdispatch_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_stable_sort<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __transform<__libdispatch_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_transform<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __transform_binary<__libdispatch_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_transform_binary<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __transform_reduce<__libdispatch_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_transform_reduce<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __transform_reduce_binary<__libdispatch_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_transform_reduce_binary<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+// Not mandatory, but better optimized
+template <class _ExecutionPolicy>
+struct __any_of<__libdispatch_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_any_of<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __fill<__libdispatch_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_fill<__libdispatch_backend_tag, _ExecutionPolicy> {};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_BACKENDS_LIBDISPATCH_H
diff --git a/third_party/libcxx/__pstl/backends/serial.h b/third_party/libcxx/__pstl/backends/serial.h
new file mode 100644
index 000000000..5f2449989
--- /dev/null
+++ b/third_party/libcxx/__pstl/backends/serial.h
@@ -0,0 +1,181 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_BACKENDS_SERIAL_H
+#define _LIBCPP___PSTL_BACKENDS_SERIAL_H
+
+#include <__algorithm/find_if.h>
+#include <__algorithm/for_each.h>
+#include <__algorithm/merge.h>
+#include <__algorithm/stable_sort.h>
+#include <__algorithm/transform.h>
+#include <__config>
+#include <__numeric/transform_reduce.h>
+#include <__pstl/backend_fwd.h>
+#include <__utility/empty.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+//
+// This partial PSTL backend runs everything serially.
+//
+// TODO: Right now, the serial backend must be used with another backend
+//       like the "default backend" because it doesn't implement all the
+//       necessary PSTL operations. It would be better to dispatch all
+//       algorithms to their serial counterpart directly, since this can
+//       often be more efficient than the "default backend"'s implementation
+//       if we end up running serially anyways.
+//
+
+template <class _ExecutionPolicy>
+struct __find_if<__serial_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Pred>
+  _LIBCPP_HIDE_FROM_ABI optional<_ForwardIterator>
+  operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred) const noexcept {
+    return std::find_if(std::move(__first), std::move(__last), std::forward<_Pred>(__pred));
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __for_each<__serial_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Function>
+  _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&&, _ForwardIterator __first, _ForwardIterator __last, _Function&& __func) const noexcept {
+    std::for_each(std::move(__first), std::move(__last), std::forward<_Function>(__func));
+    return __empty{};
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __merge<__serial_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardOutIterator, class _Comp>
+  _LIBCPP_HIDE_FROM_ABI optional<_ForwardOutIterator> operator()(
+      _Policy&&,
+      _ForwardIterator1 __first1,
+      _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2,
+      _ForwardIterator2 __last2,
+      _ForwardOutIterator __outit,
+      _Comp&& __comp) const noexcept {
+    return std::merge(
+        std::move(__first1),
+        std::move(__last1),
+        std::move(__first2),
+        std::move(__last2),
+        std::move(__outit),
+        std::forward<_Comp>(__comp));
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __stable_sort<__serial_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _RandomAccessIterator, class _Comp>
+  _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp&& __comp) const noexcept {
+    std::stable_sort(std::move(__first), std::move(__last), std::forward<_Comp>(__comp));
+    return __empty{};
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __transform<__serial_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _UnaryOperation>
+  _LIBCPP_HIDE_FROM_ABI optional<_ForwardOutIterator> operator()(
+      _Policy&&, _ForwardIterator __first, _ForwardIterator __last, _ForwardOutIterator __outit, _UnaryOperation&& __op)
+      const noexcept {
+    return std::transform(
+        std::move(__first), std::move(__last), std::move(__outit), std::forward<_UnaryOperation>(__op));
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __transform_binary<__serial_backend_tag, _ExecutionPolicy> {
+  template <class _Policy,
+            class _ForwardIterator1,
+            class _ForwardIterator2,
+            class _ForwardOutIterator,
+            class _BinaryOperation>
+  _LIBCPP_HIDE_FROM_ABI optional<_ForwardOutIterator>
+  operator()(_Policy&&,
+             _ForwardIterator1 __first1,
+             _ForwardIterator1 __last1,
+             _ForwardIterator2 __first2,
+             _ForwardOutIterator __outit,
+             _BinaryOperation&& __op) const noexcept {
+    return std::transform(
+        std::move(__first1),
+        std::move(__last1),
+        std::move(__first2),
+        std::move(__outit),
+        std::forward<_BinaryOperation>(__op));
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __transform_reduce<__serial_backend_tag, _ExecutionPolicy> {
+  template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
+  _LIBCPP_HIDE_FROM_ABI optional<_Tp>
+  operator()(_Policy&&,
+             _ForwardIterator __first,
+             _ForwardIterator __last,
+             _Tp __init,
+             _BinaryOperation&& __reduce,
+             _UnaryOperation&& __transform) const noexcept {
+    return std::transform_reduce(
+        std::move(__first),
+        std::move(__last),
+        std::move(__init),
+        std::forward<_BinaryOperation>(__reduce),
+        std::forward<_UnaryOperation>(__transform));
+  }
+};
+
+template <class _ExecutionPolicy>
+struct __transform_reduce_binary<__serial_backend_tag, _ExecutionPolicy> {
+  template <class _Policy,
+            class _ForwardIterator1,
+            class _ForwardIterator2,
+            class _Tp,
+            class _BinaryOperation1,
+            class _BinaryOperation2>
+  _LIBCPP_HIDE_FROM_ABI optional<_Tp> operator()(
+      _Policy&&,
+      _ForwardIterator1 __first1,
+      _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2,
+      _Tp __init,
+      _BinaryOperation1&& __reduce,
+      _BinaryOperation2&& __transform) const noexcept {
+    return std::transform_reduce(
+        std::move(__first1),
+        std::move(__last1),
+        std::move(__first2),
+        std::move(__init),
+        std::forward<_BinaryOperation1>(__reduce),
+        std::forward<_BinaryOperation2>(__transform));
+  }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_BACKENDS_SERIAL_H
diff --git a/third_party/libcxx/__pstl/backends/std_thread.h b/third_party/libcxx/__pstl/backends/std_thread.h
new file mode 100644
index 000000000..49570bd30
--- /dev/null
+++ b/third_party/libcxx/__pstl/backends/std_thread.h
@@ -0,0 +1,136 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_BACKENDS_STD_THREAD_H
+#define _LIBCPP___PSTL_BACKENDS_STD_THREAD_H
+
+#include <__config>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/any_of.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__pstl/cpu_algos/fill.h>
+#include <__pstl/cpu_algos/find_if.h>
+#include <__pstl/cpu_algos/for_each.h>
+#include <__pstl/cpu_algos/merge.h>
+#include <__pstl/cpu_algos/stable_sort.h>
+#include <__pstl/cpu_algos/transform.h>
+#include <__pstl/cpu_algos/transform_reduce.h>
+#include <__utility/empty.h>
+#include <__utility/move.h>
+#include <cstddef>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+//
+// This partial backend implementation is for testing purposes only and not meant for production use. This will be
+// replaced by a proper implementation once the PSTL implementation is somewhat stable.
+//
+// This is intended to be used on top of the "default backend".
+//
+
+template <>
+struct __cpu_traits<__std_thread_backend_tag> {
+  template <class _RandomAccessIterator, class _Fp>
+  _LIBCPP_HIDE_FROM_ABI static optional<__empty>
+  __for_each(_RandomAccessIterator __first, _RandomAccessIterator __last, _Fp __f) {
+    __f(__first, __last);
+    return __empty{};
+  }
+
+  template <class _Index, class _UnaryOp, class _Tp, class _BinaryOp, class _Reduce>
+  _LIBCPP_HIDE_FROM_ABI static optional<_Tp>
+  __transform_reduce(_Index __first, _Index __last, _UnaryOp, _Tp __init, _BinaryOp, _Reduce __reduce) {
+    return __reduce(std::move(__first), std::move(__last), std::move(__init));
+  }
+
+  template <class _RandomAccessIterator, class _Compare, class _LeafSort>
+  _LIBCPP_HIDE_FROM_ABI static optional<__empty>
+  __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp, _LeafSort __leaf_sort) {
+    __leaf_sort(__first, __last, __comp);
+    return __empty{};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static void __cancel_execution() {}
+
+  template <class _RandomAccessIterator1,
+            class _RandomAccessIterator2,
+            class _RandomAccessIterator3,
+            class _Compare,
+            class _LeafMerge>
+  _LIBCPP_HIDE_FROM_ABI static optional<__empty>
+  __merge(_RandomAccessIterator1 __first1,
+          _RandomAccessIterator1 __last1,
+          _RandomAccessIterator2 __first2,
+          _RandomAccessIterator2 __last2,
+          _RandomAccessIterator3 __outit,
+          _Compare __comp,
+          _LeafMerge __leaf_merge) {
+    __leaf_merge(__first1, __last1, __first2, __last2, __outit, __comp);
+    return __empty{};
+  }
+
+  static constexpr size_t __lane_size = 64;
+};
+
+// Mandatory implementations of the computational basis
+template <class _ExecutionPolicy>
+struct __find_if<__std_thread_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_find_if<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __for_each<__std_thread_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_for_each<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __merge<__std_thread_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_merge<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __stable_sort<__std_thread_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_stable_sort<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __transform<__std_thread_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_transform<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __transform_binary<__std_thread_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_transform_binary<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __transform_reduce<__std_thread_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_transform_reduce<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __transform_reduce_binary<__std_thread_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_transform_reduce_binary<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+// Not mandatory, but better optimized
+template <class _ExecutionPolicy>
+struct __any_of<__std_thread_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_any_of<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+template <class _ExecutionPolicy>
+struct __fill<__std_thread_backend_tag, _ExecutionPolicy>
+    : __cpu_parallel_fill<__std_thread_backend_tag, _ExecutionPolicy> {};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_BACKENDS_STD_THREAD_H
diff --git a/third_party/libcxx/__pstl/cpu_algos/any_of.h b/third_party/libcxx/__pstl/cpu_algos/any_of.h
new file mode 100644
index 000000000..b33c787a2
--- /dev/null
+++ b/third_party/libcxx/__pstl/cpu_algos/any_of.h
@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_CPU_ALGOS_ANY_OF_H
+#define _LIBCPP___PSTL_CPU_ALGOS_ANY_OF_H
+
+#include <__algorithm/any_of.h>
+#include <__assert>
+#include <__atomic/atomic.h>
+#include <__atomic/memory_order.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__type_traits/is_execution_policy.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <cstdint>
+#include <optional>
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <class _Backend, class _Index, class _Brick>
+_LIBCPP_HIDE_FROM_ABI optional<bool> __parallel_or(_Index __first, _Index __last, _Brick __f) {
+  std::atomic<bool> __found(false);
+  auto __ret = __cpu_traits<_Backend>::__for_each(__first, __last, [__f, &__found](_Index __i, _Index __j) {
+    if (!__found.load(std::memory_order_relaxed) && __f(__i, __j)) {
+      __found.store(true, std::memory_order_relaxed);
+      __cpu_traits<_Backend>::__cancel_execution();
+    }
+  });
+  if (!__ret)
+    return nullopt;
+  return static_cast<bool>(__found);
+}
+
+// TODO: check whether __simd_first() can be used here
+template <class _Index, class _DifferenceType, class _Pred>
+_LIBCPP_HIDE_FROM_ABI bool __simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept {
+  _DifferenceType __block_size = 4 < __n ? 4 : __n;
+  const _Index __last          = __first + __n;
+  while (__last != __first) {
+    int32_t __flag = 1;
+    _PSTL_PRAGMA_SIMD_REDUCTION(& : __flag)
+    for (_DifferenceType __i = 0; __i < __block_size; ++__i)
+      if (__pred(*(__first + __i)))
+        __flag = 0;
+    if (!__flag)
+      return true;
+
+    __first += __block_size;
+    if (__last - __first >= __block_size << 1) {
+      // Double the block _Size.  Any unnecessary iterations can be amortized against work done so far.
+      __block_size <<= 1;
+    } else {
+      __block_size = __last - __first;
+    }
+  }
+  return false;
+}
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_any_of {
+  template <class _Policy, class _ForwardIterator, class _Predicate>
+  _LIBCPP_HIDE_FROM_ABI optional<bool>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept {
+    if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      return __pstl::__parallel_or<_Backend>(
+          __first, __last, [&__policy, &__pred](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
+            using _AnyOfUnseq = __pstl::__any_of<_Backend, __remove_parallel_policy_t<_RawExecutionPolicy>>;
+            auto __res = _AnyOfUnseq()(std::__remove_parallel_policy(__policy), __brick_first, __brick_last, __pred);
+            _LIBCPP_ASSERT_INTERNAL(__res, "unseq/seq should never try to allocate!");
+            return *std::move(__res);
+          });
+    } else if constexpr (__is_unsequenced_execution_policy_v<_RawExecutionPolicy> &&
+                         __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      return __pstl::__simd_or(__first, __last - __first, __pred);
+    } else {
+      return std::any_of(__first, __last, __pred);
+    }
+  }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_ANY_OF_H
diff --git a/third_party/libcxx/__pstl/cpu_algos/cpu_traits.h b/third_party/libcxx/__pstl/cpu_algos/cpu_traits.h
new file mode 100644
index 000000000..0483d6918
--- /dev/null
+++ b/third_party/libcxx/__pstl/cpu_algos/cpu_traits.h
@@ -0,0 +1,86 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_CPU_ALGOS_CPU_TRAITS_H
+#define _LIBCPP___PSTL_CPU_ALGOS_CPU_TRAITS_H
+
+#include <__config>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+// __cpu_traits
+//
+// This traits class encapsulates the basis operations for a CPU-based implementation of the PSTL.
+// All the operations in the PSTL can be implemented from these basis operations, so a pure CPU backend
+// only needs to customize these traits in order to get an implementation of the whole PSTL.
+//
+// Basis operations
+// ================
+//
+//  template <class _RandomAccessIterator, class _Functor>
+//  optional<__empty> __for_each(_RandomAccessIterator __first, _RandomAccessIterator __last, _Functor __func);
+//    - __func must take a subrange of [__first, __last) that should be executed in serial
+//
+//  template <class _Iterator, class _UnaryOp, class _Tp, class _BinaryOp, class _Reduction>
+//  optional<_Tp> __transform_reduce(_Iterator __first, _Iterator __last, _UnaryOp, _Tp __init, _BinaryOp, _Reduction);
+//
+//  template <class _RandomAccessIterator1,
+//            class _RandomAccessIterator2,
+//            class _RandomAccessIterator3,
+//            class _Compare,
+//            class _LeafMerge>
+//  optional<_RandomAccessIterator3> __merge(_RandomAccessIterator1 __first1,
+//                                           _RandomAccessIterator1 __last1,
+//                                           _RandomAccessIterator2 __first2,
+//                                           _RandomAccessIterator2 __last2,
+//                                           _RandomAccessIterator3 __outit,
+//                                           _Compare __comp,
+//                                           _LeafMerge __leaf_merge);
+//
+//  template <class _RandomAccessIterator, class _Comp, class _LeafSort>
+//  optional<__empty> __stable_sort(_RandomAccessIterator __first,
+//                                  _RandomAccessIterator __last,
+//                                  _Comp __comp,
+//                                  _LeafSort __leaf_sort);
+//
+//   void __cancel_execution();
+//      Cancel the execution of other jobs - they aren't needed anymore. This is not a binding request,
+//      some backends may not actually be able to cancel jobs.
+//
+//   constexpr size_t __lane_size;
+//      Size of SIMD lanes.
+//      TODO: Merge this with __native_vector_size from __algorithm/simd_utils.h
+//
+//
+// Exception handling
+// ==================
+//
+// CPU backends are expected to report errors (i.e. failure to allocate) by returning a disengaged `optional` from their
+// implementation. Exceptions shouldn't be used to report an internal failure-to-allocate, since all exceptions are
+// turned into a program termination at the front-end level. When a backend returns a disengaged `optional` to the
+// frontend, the frontend will turn that into a call to `std::__throw_bad_alloc();` to report the internal failure to
+// the user.
+
+template <class _Backend>
+struct __cpu_traits;
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_CPU_TRAITS_H
diff --git a/third_party/libcxx/__pstl/cpu_algos/fill.h b/third_party/libcxx/__pstl/cpu_algos/fill.h
new file mode 100644
index 000000000..4e6d29b30
--- /dev/null
+++ b/third_party/libcxx/__pstl/cpu_algos/fill.h
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_CPU_ALGOS_FILL_H
+#define _LIBCPP___PSTL_CPU_ALGOS_FILL_H
+
+#include <__algorithm/fill.h>
+#include <__assert>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__type_traits/is_execution_policy.h>
+#include <__utility/empty.h>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <class _Index, class _DifferenceType, class _Tp>
+_LIBCPP_HIDE_FROM_ABI _Index __simd_fill_n(_Index __first, _DifferenceType __n, const _Tp& __value) noexcept {
+  _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
+  _PSTL_PRAGMA_SIMD
+  for (_DifferenceType __i = 0; __i < __n; ++__i)
+    __first[__i] = __value;
+  return __first + __n;
+}
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_fill {
+  template <class _Policy, class _ForwardIterator, class _Tp>
+  _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) const noexcept {
+    if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      return __cpu_traits<_Backend>::__for_each(
+          __first, __last, [&__policy, &__value](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
+            using _FillUnseq = __pstl::__fill<_Backend, __remove_parallel_policy_t<_RawExecutionPolicy>>;
+            [[maybe_unused]] auto __res =
+                _FillUnseq()(std::__remove_parallel_policy(__policy), __brick_first, __brick_last, __value);
+            _LIBCPP_ASSERT_INTERNAL(__res, "unseq/seq should never try to allocate!");
+          });
+    } else if constexpr (__is_unsequenced_execution_policy_v<_RawExecutionPolicy> &&
+                         __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      __pstl::__simd_fill_n(__first, __last - __first, __value);
+      return __empty{};
+    } else {
+      std::fill(__first, __last, __value);
+      return __empty{};
+    }
+  }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_FILL_H
diff --git a/third_party/libcxx/__pstl/cpu_algos/find_if.h b/third_party/libcxx/__pstl/cpu_algos/find_if.h
new file mode 100644
index 000000000..12b2e8897
--- /dev/null
+++ b/third_party/libcxx/__pstl/cpu_algos/find_if.h
@@ -0,0 +1,137 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_CPU_ALGOS_FIND_IF_H
+#define _LIBCPP___PSTL_CPU_ALGOS_FIND_IF_H
+
+#include <__algorithm/find_if.h>
+#include <__assert>
+#include <__atomic/atomic.h>
+#include <__config>
+#include <__functional/operations.h>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__type_traits/is_execution_policy.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
+#include <cstddef>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <class _Backend, class _Index, class _Brick, class _Compare>
+_LIBCPP_HIDE_FROM_ABI optional<_Index>
+__parallel_find(_Index __first, _Index __last, _Brick __f, _Compare __comp, bool __b_first) {
+  typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
+  const _DifferenceType __n      = __last - __first;
+  _DifferenceType __initial_dist = __b_first ? __n : -1;
+  std::atomic<_DifferenceType> __extremum(__initial_dist);
+  // TODO: find out what is better here: parallel_for or parallel_reduce
+  auto __res =
+      __cpu_traits<_Backend>::__for_each(__first, __last, [__comp, __f, __first, &__extremum](_Index __i, _Index __j) {
+        // See "Reducing Contention Through Priority Updates", PPoPP '13, for discussion of
+        // why using a shared variable scales fairly well in this situation.
+        if (__comp(__i - __first, __extremum)) {
+          _Index __result = __f(__i, __j);
+          // If not '__last' returned then we found what we want so put this to extremum
+          if (__result != __j) {
+            const _DifferenceType __k = __result - __first;
+            for (_DifferenceType __old = __extremum; __comp(__k, __old); __old = __extremum) {
+              __extremum.compare_exchange_weak(__old, __k);
+            }
+          }
+        }
+      });
+  if (!__res)
+    return nullopt;
+  return __extremum.load() != __initial_dist ? __first + __extremum.load() : __last;
+}
+
+template <class _Backend, class _Index, class _DifferenceType, class _Compare>
+_LIBCPP_HIDE_FROM_ABI _Index
+__simd_first(_Index __first, _DifferenceType __begin, _DifferenceType __end, _Compare __comp) noexcept {
+  // Experiments show good block sizes like this
+  const _DifferenceType __block_size                                                = 8;
+  alignas(__cpu_traits<_Backend>::__lane_size) _DifferenceType __lane[__block_size] = {0};
+  while (__end - __begin >= __block_size) {
+    _DifferenceType __found = 0;
+    _PSTL_PRAGMA_SIMD_REDUCTION(| : __found) for (_DifferenceType __i = __begin; __i < __begin + __block_size; ++__i) {
+      const _DifferenceType __t = __comp(__first, __i);
+      __lane[__i - __begin]     = __t;
+      __found |= __t;
+    }
+    if (__found) {
+      _DifferenceType __i;
+      // This will vectorize
+      for (__i = 0; __i < __block_size; ++__i) {
+        if (__lane[__i]) {
+          break;
+        }
+      }
+      return __first + __begin + __i;
+    }
+    __begin += __block_size;
+  }
+
+  // Keep remainder scalar
+  while (__begin != __end) {
+    if (__comp(__first, __begin)) {
+      return __first + __begin;
+    }
+    ++__begin;
+  }
+  return __first + __end;
+}
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_find_if {
+  template <class _Policy, class _ForwardIterator, class _Predicate>
+  _LIBCPP_HIDE_FROM_ABI optional<_ForwardIterator>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) const noexcept {
+    if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      return __pstl::__parallel_find<_Backend>(
+          __first,
+          __last,
+          [&__policy, &__pred](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
+            using _FindIfUnseq = __pstl::__find_if<_Backend, __remove_parallel_policy_t<_RawExecutionPolicy>>;
+            auto __res = _FindIfUnseq()(std::__remove_parallel_policy(__policy), __brick_first, __brick_last, __pred);
+            _LIBCPP_ASSERT_INTERNAL(__res, "unseq/seq should never try to allocate!");
+            return *std::move(__res);
+          },
+          less<>{},
+          true);
+    } else if constexpr (__is_unsequenced_execution_policy_v<_RawExecutionPolicy> &&
+                         __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      using __diff_t = __iter_diff_t<_ForwardIterator>;
+      return __pstl::__simd_first<_Backend>(
+          __first, __diff_t(0), __last - __first, [&__pred](_ForwardIterator __iter, __diff_t __i) {
+            return __pred(__iter[__i]);
+          });
+    } else {
+      return std::find_if(__first, __last, __pred);
+    }
+  }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_FIND_IF_H
diff --git a/third_party/libcxx/__pstl/cpu_algos/for_each.h b/third_party/libcxx/__pstl/cpu_algos/for_each.h
new file mode 100644
index 000000000..d4d786213
--- /dev/null
+++ b/third_party/libcxx/__pstl/cpu_algos/for_each.h
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_CPU_ALGOS_FOR_EACH_H
+#define _LIBCPP___PSTL_CPU_ALGOS_FOR_EACH_H
+
+#include <__algorithm/for_each.h>
+#include <__assert>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__type_traits/is_execution_policy.h>
+#include <__utility/empty.h>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <class _Iterator, class _DifferenceType, class _Function>
+_LIBCPP_HIDE_FROM_ABI _Iterator __simd_for_each(_Iterator __first, _DifferenceType __n, _Function __f) noexcept {
+  _PSTL_PRAGMA_SIMD
+  for (_DifferenceType __i = 0; __i < __n; ++__i)
+    __f(__first[__i]);
+
+  return __first + __n;
+}
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_for_each {
+  template <class _Policy, class _ForwardIterator, class _Function>
+  _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Function __func) const noexcept {
+    if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      return __cpu_traits<_Backend>::__for_each(
+          __first, __last, [&__policy, __func](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
+            using _ForEachUnseq = __pstl::__for_each<_Backend, __remove_parallel_policy_t<_RawExecutionPolicy>>;
+            [[maybe_unused]] auto __res =
+                _ForEachUnseq()(std::__remove_parallel_policy(__policy), __brick_first, __brick_last, __func);
+            _LIBCPP_ASSERT_INTERNAL(__res, "unseq/seq should never try to allocate!");
+          });
+    } else if constexpr (__is_unsequenced_execution_policy_v<_RawExecutionPolicy> &&
+                         __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      __pstl::__simd_for_each(__first, __last - __first, __func);
+      return __empty{};
+    } else {
+      std::for_each(__first, __last, __func);
+      return __empty{};
+    }
+  }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_FOR_EACH_H
diff --git a/third_party/libcxx/__pstl/cpu_algos/merge.h b/third_party/libcxx/__pstl/cpu_algos/merge.h
new file mode 100644
index 000000000..dfa4cbf69
--- /dev/null
+++ b/third_party/libcxx/__pstl/cpu_algos/merge.h
@@ -0,0 +1,85 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_CPU_ALGOS_MERGE_H
+#define _LIBCPP___PSTL_CPU_ALGOS_MERGE_H
+
+#include <__algorithm/merge.h>
+#include <__assert>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__type_traits/is_execution_policy.h>
+#include <__utility/move.h>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_merge {
+  template <class _Policy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardOutIterator, class _Comp>
+  _LIBCPP_HIDE_FROM_ABI optional<_ForwardOutIterator> operator()(
+      _Policy&& __policy,
+      _ForwardIterator1 __first1,
+      _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2,
+      _ForwardIterator2 __last2,
+      _ForwardOutIterator __result,
+      _Comp __comp) const noexcept {
+    if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator1>::value &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator2>::value &&
+                  __has_random_access_iterator_category_or_concept<_ForwardOutIterator>::value) {
+      auto __res = __cpu_traits<_Backend>::__merge(
+          __first1,
+          __last1,
+          __first2,
+          __last2,
+          __result,
+          __comp,
+          [&__policy](_ForwardIterator1 __g_first1,
+                      _ForwardIterator1 __g_last1,
+                      _ForwardIterator2 __g_first2,
+                      _ForwardIterator2 __g_last2,
+                      _ForwardOutIterator __g_result,
+                      _Comp __g_comp) {
+            using _MergeUnseq             = __pstl::__merge<_Backend, __remove_parallel_policy_t<_RawExecutionPolicy>>;
+            [[maybe_unused]] auto __g_res = _MergeUnseq()(
+                std::__remove_parallel_policy(__policy),
+                std::move(__g_first1),
+                std::move(__g_last1),
+                std::move(__g_first2),
+                std::move(__g_last2),
+                std::move(__g_result),
+                std::move(__g_comp));
+            _LIBCPP_ASSERT_INTERNAL(__g_res, "unsed/sed should never try to allocate!");
+          });
+      if (!__res)
+        return nullopt;
+      return __result + (__last1 - __first1) + (__last2 - __first2);
+    } else {
+      return std::merge(__first1, __last1, __first2, __last2, __result, __comp);
+    }
+  }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_MERGE_H
diff --git a/third_party/libcxx/__pstl/cpu_algos/stable_sort.h b/third_party/libcxx/__pstl/cpu_algos/stable_sort.h
new file mode 100644
index 000000000..8e64f3e53
--- /dev/null
+++ b/third_party/libcxx/__pstl/cpu_algos/stable_sort.h
@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_CPU_ALGOS_STABLE_SORT_H
+#define _LIBCPP___PSTL_CPU_ALGOS_STABLE_SORT_H
+
+#include <__algorithm/stable_sort.h>
+#include <__config>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__type_traits/is_execution_policy.h>
+#include <__utility/empty.h>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_stable_sort {
+  template <class _Policy, class _RandomAccessIterator, class _Comp>
+  _LIBCPP_HIDE_FROM_ABI optional<__empty>
+  operator()(_Policy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Comp __comp) const noexcept {
+    if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy>) {
+      return __cpu_traits<_Backend>::__stable_sort(
+          __first, __last, __comp, [](_RandomAccessIterator __g_first, _RandomAccessIterator __g_last, _Comp __g_comp) {
+            std::stable_sort(__g_first, __g_last, __g_comp);
+          });
+    } else {
+      std::stable_sort(__first, __last, __comp);
+      return __empty{};
+    }
+  }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_STABLE_SORT_H
diff --git a/third_party/libcxx/__pstl/cpu_algos/transform.h b/third_party/libcxx/__pstl/cpu_algos/transform.h
new file mode 100644
index 000000000..27ce8e27b
--- /dev/null
+++ b/third_party/libcxx/__pstl/cpu_algos/transform.h
@@ -0,0 +1,153 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_CPU_ALGOS_TRANSFORM_H
+#define _LIBCPP___PSTL_CPU_ALGOS_TRANSFORM_H
+
+#include <__algorithm/transform.h>
+#include <__assert>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__type_traits/is_execution_policy.h>
+#include <__utility/move.h>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Function>
+_LIBCPP_HIDE_FROM_ABI _Iterator2
+__simd_transform(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept {
+  _PSTL_PRAGMA_SIMD
+  for (_DifferenceType __i = 0; __i < __n; ++__i)
+    __f(__first1[__i], __first2[__i]);
+  return __first2 + __n;
+}
+
+template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Iterator3, class _Function>
+_LIBCPP_HIDE_FROM_ABI _Iterator3 __simd_transform(
+    _Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3, _Function __f) noexcept {
+  _PSTL_PRAGMA_SIMD
+  for (_DifferenceType __i = 0; __i < __n; ++__i)
+    __f(__first1[__i], __first2[__i], __first3[__i]);
+  return __first3 + __n;
+}
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_transform {
+  template <class _Policy, class _ForwardIterator, class _ForwardOutIterator, class _UnaryOperation>
+  _LIBCPP_HIDE_FROM_ABI optional<_ForwardOutIterator>
+  operator()(_Policy&& __policy,
+             _ForwardIterator __first,
+             _ForwardIterator __last,
+             _ForwardOutIterator __result,
+             _UnaryOperation __op) const noexcept {
+    if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator>::value &&
+                  __has_random_access_iterator_category_or_concept<_ForwardOutIterator>::value) {
+      __cpu_traits<_Backend>::__for_each(
+          __first,
+          __last,
+          [&__policy, __op, __first, __result](_ForwardIterator __brick_first, _ForwardIterator __brick_last) {
+            using _TransformUnseq = __pstl::__transform<_Backend, __remove_parallel_policy_t<_RawExecutionPolicy>>;
+            auto __res            = _TransformUnseq()(
+                std::__remove_parallel_policy(__policy),
+                __brick_first,
+                __brick_last,
+                __result + (__brick_first - __first),
+                __op);
+            _LIBCPP_ASSERT_INTERNAL(__res, "unseq/seq should never try to allocate!");
+            return *std::move(__res);
+          });
+      return __result + (__last - __first);
+    } else if constexpr (__is_unsequenced_execution_policy_v<_RawExecutionPolicy> &&
+                         __has_random_access_iterator_category_or_concept<_ForwardIterator>::value &&
+                         __has_random_access_iterator_category_or_concept<_ForwardOutIterator>::value) {
+      return __pstl::__simd_transform(
+          __first,
+          __last - __first,
+          __result,
+          [&](__iter_reference<_ForwardIterator> __in_value, __iter_reference<_ForwardOutIterator> __out_value) {
+            __out_value = __op(__in_value);
+          });
+    } else {
+      return std::transform(__first, __last, __result, __op);
+    }
+  }
+};
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_transform_binary {
+  template <class _Policy,
+            class _ForwardIterator1,
+            class _ForwardIterator2,
+            class _ForwardOutIterator,
+            class _BinaryOperation>
+  _LIBCPP_HIDE_FROM_ABI optional<_ForwardOutIterator>
+  operator()(_Policy&& __policy,
+             _ForwardIterator1 __first1,
+             _ForwardIterator1 __last1,
+             _ForwardIterator2 __first2,
+             _ForwardOutIterator __result,
+             _BinaryOperation __op) const noexcept {
+    if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator1>::value &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator2>::value &&
+                  __has_random_access_iterator_category_or_concept<_ForwardOutIterator>::value) {
+      auto __res = __cpu_traits<_Backend>::__for_each(
+          __first1,
+          __last1,
+          [&__policy, __op, __first1, __first2, __result](
+              _ForwardIterator1 __brick_first, _ForwardIterator1 __brick_last) {
+            using _TransformBinaryUnseq =
+                __pstl::__transform_binary<_Backend, __remove_parallel_policy_t<_RawExecutionPolicy>>;
+            return _TransformBinaryUnseq()(
+                std::__remove_parallel_policy(__policy),
+                __brick_first,
+                __brick_last,
+                __first2 + (__brick_first - __first1),
+                __result + (__brick_first - __first1),
+                __op);
+          });
+      if (!__res)
+        return nullopt;
+      return __result + (__last1 - __first1);
+    } else if constexpr (__is_unsequenced_execution_policy_v<_RawExecutionPolicy> &&
+                         __has_random_access_iterator_category_or_concept<_ForwardIterator1>::value &&
+                         __has_random_access_iterator_category_or_concept<_ForwardIterator2>::value &&
+                         __has_random_access_iterator_category_or_concept<_ForwardOutIterator>::value) {
+      return __pstl::__simd_transform(
+          __first1,
+          __last1 - __first1,
+          __first2,
+          __result,
+          [&](__iter_reference<_ForwardIterator1> __in1,
+              __iter_reference<_ForwardIterator2> __in2,
+              __iter_reference<_ForwardOutIterator> __out_value) { __out_value = __op(__in1, __in2); });
+    } else {
+      return std::transform(__first1, __last1, __first2, __result, __op);
+    }
+  }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_TRANSFORM_H
diff --git a/third_party/libcxx/__pstl/cpu_algos/transform_reduce.h b/third_party/libcxx/__pstl/cpu_algos/transform_reduce.h
new file mode 100644
index 000000000..36ac1a907
--- /dev/null
+++ b/third_party/libcxx/__pstl/cpu_algos/transform_reduce.h
@@ -0,0 +1,216 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_CPU_ALGOS_TRANSFORM_REDUCE_H
+#define _LIBCPP___PSTL_CPU_ALGOS_TRANSFORM_REDUCE_H
+
+#include <__assert>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__numeric/transform_reduce.h>
+#include <__pstl/backend_fwd.h>
+#include <__pstl/cpu_algos/cpu_traits.h>
+#include <__type_traits/desugars_to.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_execution_policy.h>
+#include <__utility/move.h>
+#include <cstddef>
+#include <new>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <typename _Backend,
+          typename _DifferenceType,
+          typename _Tp,
+          typename _BinaryOperation,
+          typename _UnaryOperation,
+          typename _UnaryResult = invoke_result_t<_UnaryOperation, _DifferenceType>,
+          __enable_if_t<__desugars_to_v<__plus_tag, _BinaryOperation, _Tp, _UnaryResult> && is_arithmetic_v<_Tp> &&
+                            is_arithmetic_v<_UnaryResult>,
+                        int>    = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept {
+  _PSTL_PRAGMA_SIMD_REDUCTION(+ : __init)
+  for (_DifferenceType __i = 0; __i < __n; ++__i)
+    __init += __f(__i);
+  return __init;
+}
+
+template <typename _Backend,
+          typename _Size,
+          typename _Tp,
+          typename _BinaryOperation,
+          typename _UnaryOperation,
+          typename _UnaryResult = invoke_result_t<_UnaryOperation, _Size>,
+          __enable_if_t<!(__desugars_to_v<__plus_tag, _BinaryOperation, _Tp, _UnaryResult> && is_arithmetic_v<_Tp> &&
+                          is_arithmetic_v<_UnaryResult>),
+                        int>    = 0>
+_LIBCPP_HIDE_FROM_ABI _Tp
+__simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept {
+  constexpr size_t __lane_size = __cpu_traits<_Backend>::__lane_size;
+  const _Size __block_size     = __lane_size / sizeof(_Tp);
+  if (__n > 2 * __block_size && __block_size > 1) {
+    alignas(__lane_size) char __lane_buffer[__lane_size];
+    _Tp* __lane = reinterpret_cast<_Tp*>(__lane_buffer);
+
+    // initializer
+    _PSTL_PRAGMA_SIMD
+    for (_Size __i = 0; __i < __block_size; ++__i) {
+      ::new (__lane + __i) _Tp(__binary_op(__f(__i), __f(__block_size + __i)));
+    }
+    // main loop
+    _Size __i                    = 2 * __block_size;
+    const _Size __last_iteration = __block_size * (__n / __block_size);
+    for (; __i < __last_iteration; __i += __block_size) {
+      _PSTL_PRAGMA_SIMD
+      for (_Size __j = 0; __j < __block_size; ++__j) {
+        __lane[__j] = __binary_op(std::move(__lane[__j]), __f(__i + __j));
+      }
+    }
+    // remainder
+    _PSTL_PRAGMA_SIMD
+    for (_Size __j = 0; __j < __n - __last_iteration; ++__j) {
+      __lane[__j] = __binary_op(std::move(__lane[__j]), __f(__last_iteration + __j));
+    }
+    // combiner
+    for (_Size __j = 0; __j < __block_size; ++__j) {
+      __init = __binary_op(std::move(__init), std::move(__lane[__j]));
+    }
+    // destroyer
+    _PSTL_PRAGMA_SIMD
+    for (_Size __j = 0; __j < __block_size; ++__j) {
+      __lane[__j].~_Tp();
+    }
+  } else {
+    for (_Size __i = 0; __i < __n; ++__i) {
+      __init = __binary_op(std::move(__init), __f(__i));
+    }
+  }
+  return __init;
+}
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_transform_reduce_binary {
+  template <class _Policy,
+            class _ForwardIterator1,
+            class _ForwardIterator2,
+            class _Tp,
+            class _BinaryOperation1,
+            class _BinaryOperation2>
+  _LIBCPP_HIDE_FROM_ABI optional<_Tp> operator()(
+      _Policy&& __policy,
+      _ForwardIterator1 __first1,
+      _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2,
+      _Tp __init,
+      _BinaryOperation1 __reduce,
+      _BinaryOperation2 __transform) const noexcept {
+    if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator1>::value &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator2>::value) {
+      return __cpu_traits<_Backend>::__transform_reduce(
+          __first1,
+          std::move(__last1),
+          [__first1, __first2, __transform](_ForwardIterator1 __iter) {
+            return __transform(*__iter, *(__first2 + (__iter - __first1)));
+          },
+          std::move(__init),
+          std::move(__reduce),
+          [&__policy, __first1, __first2, __reduce, __transform](
+              _ForwardIterator1 __brick_first, _ForwardIterator1 __brick_last, _Tp __brick_init) {
+            using _TransformReduceBinaryUnseq =
+                __pstl::__transform_reduce_binary<_Backend, __remove_parallel_policy_t<_RawExecutionPolicy>>;
+            return *_TransformReduceBinaryUnseq()(
+                std::__remove_parallel_policy(__policy),
+                __brick_first,
+                std::move(__brick_last),
+                __first2 + (__brick_first - __first1),
+                std::move(__brick_init),
+                std::move(__reduce),
+                std::move(__transform));
+          });
+    } else if constexpr (__is_unsequenced_execution_policy_v<_RawExecutionPolicy> &&
+                         __has_random_access_iterator_category_or_concept<_ForwardIterator1>::value &&
+                         __has_random_access_iterator_category_or_concept<_ForwardIterator2>::value) {
+      return __pstl::__simd_transform_reduce<_Backend>(
+          __last1 - __first1, std::move(__init), std::move(__reduce), [&](__iter_diff_t<_ForwardIterator1> __i) {
+            return __transform(__first1[__i], __first2[__i]);
+          });
+    } else {
+      return std::transform_reduce(
+          std::move(__first1),
+          std::move(__last1),
+          std::move(__first2),
+          std::move(__init),
+          std::move(__reduce),
+          std::move(__transform));
+    }
+  }
+};
+
+template <class _Backend, class _RawExecutionPolicy>
+struct __cpu_parallel_transform_reduce {
+  template <class _Policy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
+  _LIBCPP_HIDE_FROM_ABI optional<_Tp>
+  operator()(_Policy&& __policy,
+             _ForwardIterator __first,
+             _ForwardIterator __last,
+             _Tp __init,
+             _BinaryOperation __reduce,
+             _UnaryOperation __transform) const noexcept {
+    if constexpr (__is_parallel_execution_policy_v<_RawExecutionPolicy> &&
+                  __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      return __cpu_traits<_Backend>::__transform_reduce(
+          std::move(__first),
+          std::move(__last),
+          [__transform](_ForwardIterator __iter) { return __transform(*__iter); },
+          std::move(__init),
+          __reduce,
+          [&__policy, __transform, __reduce](auto __brick_first, auto __brick_last, _Tp __brick_init) {
+            using _TransformReduceUnseq =
+                __pstl::__transform_reduce<_Backend, __remove_parallel_policy_t<_RawExecutionPolicy>>;
+            auto __res = _TransformReduceUnseq()(
+                std::__remove_parallel_policy(__policy),
+                std::move(__brick_first),
+                std::move(__brick_last),
+                std::move(__brick_init),
+                std::move(__reduce),
+                std::move(__transform));
+            _LIBCPP_ASSERT_INTERNAL(__res, "unseq/seq should never try to allocate!");
+            return *std::move(__res);
+          });
+    } else if constexpr (__is_unsequenced_execution_policy_v<_RawExecutionPolicy> &&
+                         __has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
+      return __pstl::__simd_transform_reduce<_Backend>(
+          __last - __first,
+          std::move(__init),
+          std::move(__reduce),
+          [=, &__transform](__iter_diff_t<_ForwardIterator> __i) { return __transform(__first[__i]); });
+    } else {
+      return std::transform_reduce(
+          std::move(__first), std::move(__last), std::move(__init), std::move(__reduce), std::move(__transform));
+    }
+  }
+};
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_CPU_ALGOS_TRANSFORM_REDUCE_H
diff --git a/third_party/libcxx/__pstl/dispatch.h b/third_party/libcxx/__pstl/dispatch.h
new file mode 100644
index 000000000..5e903f752
--- /dev/null
+++ b/third_party/libcxx/__pstl/dispatch.h
@@ -0,0 +1,66 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_DISPATCH_H
+#define _LIBCPP___PSTL_DISPATCH_H
+
+#include <__config>
+#include <__pstl/backend_fwd.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/type_identity.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <template <class, class> class _Algorithm, class _Backend, class _ExecutionPolicy, class = void>
+constexpr bool __is_implemented_v = false;
+
+template <template <class, class> class _Algorithm, class _Backend, class _ExecutionPolicy>
+constexpr bool __is_implemented_v<_Algorithm,
+                                  _Backend,
+                                  _ExecutionPolicy,
+                                  __enable_if_t<sizeof(_Algorithm<_Backend, _ExecutionPolicy>)>> = true;
+
+// Helpful to provide better error messages. This will show the algorithm and the execution policy
+// in the compiler diagnostic.
+template <template <class, class> class _Algorithm, class _ExecutionPolicy>
+constexpr bool __cant_find_backend_for = false;
+
+template <template <class, class> class _Algorithm, class _BackendConfiguration, class _ExecutionPolicy>
+struct __find_first_implemented;
+
+template <template <class, class> class _Algorithm, class _ExecutionPolicy>
+struct __find_first_implemented<_Algorithm, __backend_configuration<>, _ExecutionPolicy> {
+  static_assert(__cant_find_backend_for<_Algorithm, _ExecutionPolicy>,
+                "Could not find a PSTL backend for the given algorithm and execution policy");
+};
+
+template <template <class, class> class _Algorithm, class _B1, class... _Bn, class _ExecutionPolicy>
+struct __find_first_implemented<_Algorithm, __backend_configuration<_B1, _Bn...>, _ExecutionPolicy>
+    : _If<__is_implemented_v<_Algorithm, _B1, _ExecutionPolicy>,
+          __type_identity<_Algorithm<_B1, _ExecutionPolicy>>,
+          __find_first_implemented<_Algorithm, __backend_configuration<_Bn...>, _ExecutionPolicy> > {};
+
+template <template <class, class> class _Algorithm, class _BackendConfiguration, class _ExecutionPolicy>
+using __dispatch = typename __find_first_implemented<_Algorithm, _BackendConfiguration, _ExecutionPolicy>::type;
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_DISPATCH_H
diff --git a/third_party/libcxx/__pstl/handle_exception.h b/third_party/libcxx/__pstl/handle_exception.h
new file mode 100644
index 000000000..d6270958c
--- /dev/null
+++ b/third_party/libcxx/__pstl/handle_exception.h
@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___PSTL_HANDLE_EXCEPTION_H
+#define _LIBCPP___PSTL_HANDLE_EXCEPTION_H
+
+#include <__config>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <new> // __throw_bad_alloc
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+namespace __pstl {
+
+template <class _BackendFunction, class... _Args>
+_LIBCPP_HIDE_FROM_ABI auto __handle_exception_impl(_Args&&... __args) noexcept {
+  return _BackendFunction{}(std::forward<_Args>(__args)...);
+}
+
+// This function is used to call a backend PSTL algorithm from a frontend algorithm.
+//
+// All PSTL backend algorithms return an optional denoting whether there was an
+// "infrastructure"-level failure (aka failure to allocate). This function takes
+// care of unwrapping that and throwing `bad_alloc()` in case there was a problem
+// in the underlying implementation.
+//
+// We must also be careful not to call any user code that could throw an exception
+// (such as moving or copying iterators) in here since that should terminate the
+// program, which is why we delegate to a noexcept helper below.
+template <class _BackendFunction, class... _Args>
+_LIBCPP_HIDE_FROM_ABI auto __handle_exception(_Args&&... __args) {
+  auto __result = __pstl::__handle_exception_impl<_BackendFunction>(std::forward<_Args>(__args)...);
+  if (__result == nullopt)
+    std::__throw_bad_alloc();
+  else
+    return std::move(*__result);
+}
+
+} // namespace __pstl
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___PSTL_HANDLE_EXCEPTION_H
diff --git a/third_party/libcxx/__pstl/internal/algorithm_fwd.h b/third_party/libcxx/__pstl/internal/algorithm_fwd.h
deleted file mode 100644
index ba350392c..000000000
--- a/third_party/libcxx/__pstl/internal/algorithm_fwd.h
+++ /dev/null
@@ -1,1768 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_ALGORITHM_FWD_H
-#define _PSTL_ALGORITHM_FWD_H
-
-#include <__config>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-
-namespace __pstl {
-namespace __internal {
-
-//------------------------------------------------------------------------
-// walk1 (pseudo)
-//
-// walk1 evaluates f(x) for each dereferenced value x drawn from [first,last)
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _Function>
-void __brick_walk1(_ForwardIterator,
-                   _ForwardIterator,
-                   _Function,
-                   /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _Function>
-void __brick_walk1(_RandomAccessIterator,
-                   _RandomAccessIterator,
-                   _Function,
-                   /*vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Function>
-void __pattern_walk1(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Function) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Function>
-void __pattern_walk1(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Function);
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Brick>
-void __pattern_walk_brick(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Brick) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Brick>
-void __pattern_walk_brick(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Brick);
-
-//------------------------------------------------------------------------
-// walk1_n
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _Size, class _Function>
-_ForwardIterator __brick_walk1_n(
-    _ForwardIterator,
-    _Size,
-    _Function,
-    /*_IsVectorTag=*/std::false_type);
-
-template <class _RandomAccessIterator, class _DifferenceType, class _Function>
-_RandomAccessIterator __brick_walk1_n(
-    _RandomAccessIterator,
-    _DifferenceType,
-    _Function,
-    /*vectorTag=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function>
-_ForwardIterator __pattern_walk1_n(_Tag, _ExecutionPolicy&&, _ForwardIterator, _Size, _Function) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function>
-_RandomAccessIterator
-__pattern_walk1_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _Size, _Function);
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick>
-_ForwardIterator __pattern_walk_brick_n(_Tag, _ExecutionPolicy&&, _ForwardIterator, _Size, _Brick) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
-_RandomAccessIterator
-__pattern_walk_brick_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _Size, _Brick);
-
-//------------------------------------------------------------------------
-// walk2 (pseudo)
-//
-// walk2 evaluates f(x,y) for deferenced values (x,y) drawn from [first1,last1) and [first2,...)
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
-_ForwardIterator2 __brick_walk2(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _Function,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Function>
-_RandomAccessIterator2 __brick_walk2(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _Function,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
-_ForwardIterator2 __brick_walk2_n(
-    _ForwardIterator1,
-    _Size,
-    _ForwardIterator2,
-    _Function,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Function>
-_RandomAccessIterator2 __brick_walk2_n(
-    _RandomAccessIterator1,
-    _Size,
-    _RandomAccessIterator2,
-    _Function,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function>
-_ForwardIterator2
-__pattern_walk2(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Function) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Function>
-_RandomAccessIterator2 __pattern_walk2(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _Function);
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _Size,
-          class _ForwardIterator2,
-          class _Function>
-_ForwardIterator2
-__pattern_walk2_n(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Function) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _Size,
-          class _RandomAccessIterator2,
-          class _Function>
-_RandomAccessIterator2 __pattern_walk2_n(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Function);
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick>
-_ForwardIterator2 __pattern_walk2_brick(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _Brick) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Brick>
-_RandomAccessIterator2 __pattern_walk2_brick(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _Brick);
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _Size,
-          class _ForwardIterator2,
-          class _Brick>
-_ForwardIterator2
-__pattern_walk2_brick_n(_Tag, _ExecutionPolicy&&, _ForwardIterator1, _Size, _ForwardIterator2, _Brick) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _Size,
-          class _RandomAccessIterator2,
-          class _Brick>
-_RandomAccessIterator2 __pattern_walk2_brick_n(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator1, _Size, _RandomAccessIterator2, _Brick);
-
-//------------------------------------------------------------------------
-// walk3 (pseudo)
-//
-// walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...)
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function>
-_ForwardIterator3 __brick_walk3(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator3,
-    _Function,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function>
-_RandomAccessIterator3 __brick_walk3(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator3,
-    _Function,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator3,
-          class _Function>
-_ForwardIterator3 __pattern_walk3(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator3,
-    _Function) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _RandomAccessIterator3,
-          class _Function>
-_RandomAccessIterator3 __pattern_walk3(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator3,
-    _Function);
-
-//------------------------------------------------------------------------
-// equal
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool __brick_equal(_ForwardIterator1,
-                   _ForwardIterator1,
-                   _ForwardIterator2,
-                   _BinaryPredicate,
-                   /* is_vector = */ std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-bool __brick_equal(_RandomAccessIterator1,
-                   _RandomAccessIterator1,
-                   _RandomAccessIterator2,
-                   _BinaryPredicate,
-                   /* is_vector = */ std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool __pattern_equal(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator1, _ForwardIterator1, _ForwardIterator2, _BinaryPredicate) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-bool __pattern_equal(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _BinaryPredicate);
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool __brick_equal(_ForwardIterator1,
-                   _ForwardIterator1,
-                   _ForwardIterator2,
-                   _ForwardIterator2,
-                   _BinaryPredicate,
-                   /* is_vector = */ std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-bool __brick_equal(_RandomAccessIterator1,
-                   _RandomAccessIterator1,
-                   _RandomAccessIterator2,
-                   _RandomAccessIterator2,
-                   _BinaryPredicate,
-                   /* is_vector = */ std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool __pattern_equal(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _BinaryPredicate) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-bool __pattern_equal(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _BinaryPredicate);
-
-//------------------------------------------------------------------------
-// find_end
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __brick_find_end(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _BinaryPredicate,
-    /*__is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator1 __brick_find_end(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _BinaryPredicate,
-    /*__is_vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __pattern_find_end(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _BinaryPredicate) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-_RandomAccessIterator1 __pattern_find_end(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _BinaryPredicate) noexcept;
-
-//------------------------------------------------------------------------
-// find_first_of
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __brick_find_first_of(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _BinaryPredicate,
-    /*__is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator1 __brick_find_first_of(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _BinaryPredicate,
-    /*__is_vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __pattern_find_first_of(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _BinaryPredicate) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-_RandomAccessIterator1 __pattern_find_first_of(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _BinaryPredicate) noexcept;
-
-//------------------------------------------------------------------------
-// search
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __brick_search(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _BinaryPredicate,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator1 __brick_search(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _BinaryPredicate,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __pattern_search(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _BinaryPredicate) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-_RandomAccessIterator1 __pattern_search(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _BinaryPredicate) noexcept;
-
-//------------------------------------------------------------------------
-// search_n
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-_ForwardIterator __brick_search_n(
-    _ForwardIterator,
-    _ForwardIterator,
-    _Size,
-    const _Tp&,
-    _BinaryPredicate,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate>
-_RandomAccessIterator __brick_search_n(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Size,
-    const _Tp&,
-    _BinaryPredicate,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-_ForwardIterator __pattern_search_n(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Size, const _Tp&, _BinaryPredicate) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _Size,
-          class _Tp,
-          class _BinaryPredicate>
-_RandomAccessIterator __pattern_search_n(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Size,
-    const _Tp&,
-    _BinaryPredicate) noexcept;
-
-//------------------------------------------------------------------------
-// copy_n
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _Size, class _OutputIterator>
-_OutputIterator __brick_copy_n(_ForwardIterator,
-                               _Size,
-                               _OutputIterator,
-                               /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _Size, class _OutputIterator>
-_OutputIterator __brick_copy_n(_RandomAccessIterator,
-                               _Size,
-                               _OutputIterator,
-                               /*vector=*/std::true_type) noexcept;
-
-//------------------------------------------------------------------------
-// copy
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator __brick_copy(_ForwardIterator,
-                             _ForwardIterator,
-                             _OutputIterator,
-                             /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __brick_copy(_RandomAccessIterator,
-                             _RandomAccessIterator,
-                             _OutputIterator,
-                             /*vector=*/std::true_type) noexcept;
-
-//------------------------------------------------------------------------
-// move
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator __brick_move(_ForwardIterator,
-                             _ForwardIterator,
-                             _OutputIterator,
-                             /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __brick_move(_RandomAccessIterator,
-                             _RandomAccessIterator,
-                             _OutputIterator,
-                             /*vector=*/std::true_type) noexcept;
-
-//------------------------------------------------------------------------
-// swap_ranges
-//------------------------------------------------------------------------
-template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator __brick_swap_ranges(
-    _ForwardIterator,
-    _ForwardIterator,
-    _OutputIterator,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __brick_swap_ranges(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    /*vector=*/std::true_type) noexcept;
-
-//------------------------------------------------------------------------
-// copy_if
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
-_OutputIterator __brick_copy_if(
-    _ForwardIterator,
-    _ForwardIterator,
-    _OutputIterator,
-    _UnaryPredicate,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator, class _UnaryPredicate>
-_OutputIterator __brick_copy_if(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    _UnaryPredicate,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate>
-std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1(
-    _ForwardIterator,
-    _ForwardIterator,
-    bool* __restrict,
-    _UnaryPredicate,
-    /*vector=*/std::false_type) noexcept;
-template <class _DifferenceType, class _RandomAccessIterator, class _UnaryPredicate>
-std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    bool* __restrict,
-    _UnaryPredicate,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _ForwardIterator, class _OutputIterator>
-void __brick_copy_by_mask(
-    _ForwardIterator,
-    _ForwardIterator,
-    _OutputIterator,
-    bool*,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator>
-void __brick_copy_by_mask(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    bool* __restrict,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2>
-void __brick_partition_by_mask(
-    _ForwardIterator,
-    _ForwardIterator,
-    _OutputIterator1,
-    _OutputIterator2,
-    bool*,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2>
-void __brick_partition_by_mask(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator1,
-    _OutputIterator2,
-    bool*,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
-_OutputIterator __pattern_copy_if(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _UnaryPredicate) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _OutputIterator,
-          class _UnaryPredicate>
-_OutputIterator __pattern_copy_if(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    _UnaryPredicate);
-
-//------------------------------------------------------------------------
-// count
-//------------------------------------------------------------------------
-
-template <class _RandomAccessIterator, class _Predicate>
-typename std::iterator_traits<_RandomAccessIterator>::difference_type __brick_count(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Predicate,
-    /* is_vector = */ std::true_type) noexcept;
-
-template <class _ForwardIterator, class _Predicate>
-typename std::iterator_traits<_ForwardIterator>::difference_type __brick_count(
-    _ForwardIterator,
-    _ForwardIterator,
-    _Predicate,
-    /* is_vector = */ std::false_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-typename std::iterator_traits<_ForwardIterator>::difference_type
-__pattern_count(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Predicate) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Predicate>
-typename std::iterator_traits<_RandomAccessIterator>::difference_type __pattern_count(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Predicate);
-
-//------------------------------------------------------------------------
-// unique
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator __brick_unique(
-    _ForwardIterator,
-    _ForwardIterator,
-    _BinaryPredicate,
-    /*is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator __brick_unique(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _BinaryPredicate,
-    /*is_vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator
-__pattern_unique(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator __pattern_unique(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _BinaryPredicate) noexcept;
-
-//------------------------------------------------------------------------
-// unique_copy
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate>
-OutputIterator __brick_unique_copy(
-    _ForwardIterator,
-    _ForwardIterator,
-    OutputIterator,
-    _BinaryPredicate,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator, class _BinaryPredicate>
-_OutputIterator __brick_unique_copy(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    _BinaryPredicate,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryPredicate>
-_OutputIterator __pattern_unique_copy(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryPredicate) noexcept;
-
-template <class _ExecutionPolicy, class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
-_DifferenceType __brick_calc_mask_2(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    bool* __restrict,
-    _BinaryPredicate,
-    /*vector=*/std::false_type) noexcept;
-
-template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
-_DifferenceType __brick_calc_mask_2(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    bool* __restrict,
-    _BinaryPredicate,
-    /*vector=*/std::true_type) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _OutputIterator,
-          class _BinaryPredicate>
-_OutputIterator __pattern_unique_copy(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    _BinaryPredicate);
-
-//------------------------------------------------------------------------
-// reverse
-//------------------------------------------------------------------------
-
-template <class _BidirectionalIterator>
-void __brick_reverse(_BidirectionalIterator,
-                     _BidirectionalIterator,
-                     /*__is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator>
-void __brick_reverse(_RandomAccessIterator,
-                     _RandomAccessIterator,
-                     /*__is_vector=*/std::true_type) noexcept;
-
-template <class _BidirectionalIterator>
-void __brick_reverse(_BidirectionalIterator,
-                     _BidirectionalIterator,
-                     _BidirectionalIterator,
-                     /*is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator>
-void __brick_reverse(_RandomAccessIterator,
-                     _RandomAccessIterator,
-                     _RandomAccessIterator,
-                     /*is_vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator>
-void __pattern_reverse(_Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator>
-void __pattern_reverse(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator);
-
-//------------------------------------------------------------------------
-// reverse_copy
-//------------------------------------------------------------------------
-
-template <class _BidirectionalIterator, class _OutputIterator>
-_OutputIterator __brick_reverse_copy(
-    _BidirectionalIterator,
-    _BidirectionalIterator,
-    _OutputIterator,
-    /*is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __brick_reverse_copy(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    /*is_vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator>
-_OutputIterator __pattern_reverse_copy(
-    _Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _OutputIterator) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __pattern_reverse_copy(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _OutputIterator);
-
-//------------------------------------------------------------------------
-// rotate
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator>
-_ForwardIterator __brick_rotate(
-    _ForwardIterator,
-    _ForwardIterator,
-    _ForwardIterator,
-    /*is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator>
-_RandomAccessIterator __brick_rotate(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    /*is_vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator>
-_ForwardIterator
-__pattern_rotate(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator>
-_RandomAccessIterator __pattern_rotate(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator);
-
-//------------------------------------------------------------------------
-// rotate_copy
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator __brick_rotate_copy(
-    _ForwardIterator,
-    _ForwardIterator,
-    _ForwardIterator,
-    _OutputIterator,
-    /*__is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __brick_rotate_copy(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    /*__is_vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator>
-_OutputIterator __pattern_rotate_copy(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _ForwardIterator, _OutputIterator) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _OutputIterator>
-_OutputIterator __pattern_rotate_copy(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator);
-
-//------------------------------------------------------------------------
-// is_partitioned
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _UnaryPredicate>
-bool __brick_is_partitioned(_ForwardIterator,
-                            _ForwardIterator,
-                            _UnaryPredicate,
-                            /*is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _UnaryPredicate>
-bool __brick_is_partitioned(_RandomAccessIterator,
-                            _RandomAccessIterator,
-                            _UnaryPredicate,
-                            /*is_vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-bool __pattern_is_partitioned(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-bool __pattern_is_partitioned(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate);
-
-//------------------------------------------------------------------------
-// partition
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator __brick_partition(
-    _ForwardIterator,
-    _ForwardIterator,
-    _UnaryPredicate,
-    /*is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __brick_partition(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _UnaryPredicate,
-    /*is_vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator
-__pattern_partition(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __pattern_partition(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _UnaryPredicate);
-
-//------------------------------------------------------------------------
-// stable_partition
-//------------------------------------------------------------------------
-
-template <class _BidirectionalIterator, class _UnaryPredicate>
-_BidirectionalIterator __brick_stable_partition(
-    _BidirectionalIterator,
-    _BidirectionalIterator,
-    _UnaryPredicate,
-    /*__is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __brick_stable_partition(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _UnaryPredicate,
-    /*__is_vector=*/std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
-_BidirectionalIterator __pattern_stable_partition(
-    _Tag, _ExecutionPolicy&&, _BidirectionalIterator, _BidirectionalIterator, _UnaryPredicate) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __pattern_stable_partition(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _UnaryPredicate) noexcept;
-
-//------------------------------------------------------------------------
-// partition_copy
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy(
-    _ForwardIterator,
-    _ForwardIterator,
-    _OutputIterator1,
-    _OutputIterator2,
-    _UnaryPredicate,
-    /*is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator1,
-    _OutputIterator2,
-    _UnaryPredicate,
-    /*is_vector=*/std::true_type) noexcept;
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _OutputIterator1,
-          class _OutputIterator2,
-          class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator,
-    _ForwardIterator,
-    _OutputIterator1,
-    _OutputIterator2,
-    _UnaryPredicate) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _OutputIterator1,
-          class _OutputIterator2,
-          class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator1,
-    _OutputIterator2,
-    _UnaryPredicate);
-
-//------------------------------------------------------------------------
-// sort
-//------------------------------------------------------------------------
-
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsMoveConstructible>
-void __pattern_sort(
-    _Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare, _IsMoveConstructible) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_sort(__parallel_tag<_IsVector>,
-                    _ExecutionPolicy&&,
-                    _RandomAccessIterator,
-                    _RandomAccessIterator,
-                    _Compare,
-                    /*is_move_constructible=*/std::true_type);
-
-//------------------------------------------------------------------------
-// stable_sort
-//------------------------------------------------------------------------
-
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_stable_sort(_Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_stable_sort(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare);
-
-//------------------------------------------------------------------------
-// partial_sort
-//------------------------------------------------------------------------
-
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_partial_sort(
-    _Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_partial_sort(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Compare);
-
-//------------------------------------------------------------------------
-// partial_sort_copy
-//------------------------------------------------------------------------
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Compare>
-_RandomAccessIterator2 __pattern_partial_sort_copy(
-    _Tag,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _Compare) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Compare>
-_RandomAccessIterator2 __pattern_partial_sort_copy(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _Compare);
-
-//------------------------------------------------------------------------
-// adjacent_find
-//------------------------------------------------------------------------
-
-template <class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator __brick_adjacent_find(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _BinaryPredicate,
-    /* IsVector = */ std::true_type,
-    bool) noexcept;
-
-template <class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator __brick_adjacent_find(
-    _ForwardIterator,
-    _ForwardIterator,
-    _BinaryPredicate,
-    /* IsVector = */ std::false_type,
-    bool) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator
-__pattern_adjacent_find(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _BinaryPredicate, bool) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator __pattern_adjacent_find(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _BinaryPredicate,
-    bool);
-
-//------------------------------------------------------------------------
-// nth_element
-//------------------------------------------------------------------------
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_nth_element(
-    _Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_nth_element(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Compare) noexcept;
-
-//------------------------------------------------------------------------
-// fill, fill_n
-//------------------------------------------------------------------------
-template <class _RandomAccessIterator, class _Tp>
-void __brick_fill(_RandomAccessIterator,
-                  _RandomAccessIterator,
-                  const _Tp&,
-                  /* __is_vector = */ std::true_type) noexcept;
-
-template <class _ForwardIterator, class _Tp>
-void __brick_fill(_ForwardIterator,
-                  _ForwardIterator,
-                  const _Tp&,
-                  /* __is_vector = */ std::false_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-void __pattern_fill(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, const _Tp&) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Tp>
-_RandomAccessIterator
-__pattern_fill(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, const _Tp&);
-
-template <class _RandomAccessIterator, class _Size, class _Tp>
-_RandomAccessIterator
-__brick_fill_n(_RandomAccessIterator,
-               _Size,
-               const _Tp&,
-               /* __is_vector = */ std::true_type) noexcept;
-
-template <class _OutputIterator, class _Size, class _Tp>
-_OutputIterator
-__brick_fill_n(_OutputIterator,
-               _Size,
-               const _Tp&,
-               /* __is_vector = */ std::false_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _OutputIterator, class _Size, class _Tp>
-_OutputIterator __pattern_fill_n(_Tag, _ExecutionPolicy&&, _OutputIterator, _Size, const _Tp&) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Tp>
-_RandomAccessIterator
-__pattern_fill_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _Size, const _Tp&);
-
-//------------------------------------------------------------------------
-// generate, generate_n
-//------------------------------------------------------------------------
-
-template <class _RandomAccessIterator, class _Generator>
-void __brick_generate(_RandomAccessIterator,
-                      _RandomAccessIterator,
-                      _Generator,
-                      /* is_vector = */ std::true_type) noexcept;
-
-template <class _ForwardIterator, class _Generator>
-void __brick_generate(_ForwardIterator,
-                      _ForwardIterator,
-                      _Generator,
-                      /* is_vector = */ std::false_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Generator>
-void __pattern_generate(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Generator) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Generator>
-_RandomAccessIterator __pattern_generate(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Generator);
-
-template <class _RandomAccessIterator, class Size, class _Generator>
-_RandomAccessIterator __brick_generate_n(
-    _RandomAccessIterator,
-    Size,
-    _Generator,
-    /* is_vector = */ std::true_type) noexcept;
-
-template <class OutputIterator, class Size, class _Generator>
-OutputIterator __brick_generate_n(
-    OutputIterator,
-    Size,
-    _Generator,
-    /* is_vector = */ std::false_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class OutputIterator, class Size, class _Generator>
-OutputIterator __pattern_generate_n(_Tag, _ExecutionPolicy&&, OutputIterator, Size, _Generator) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class Size, class _Generator>
-_RandomAccessIterator
-__pattern_generate_n(__parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, Size, _Generator);
-
-//------------------------------------------------------------------------
-// remove
-//------------------------------------------------------------------------
-template <class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator __brick_remove_if(
-    _ForwardIterator,
-    _ForwardIterator,
-    _UnaryPredicate,
-    /* __is_vector = */ std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __brick_remove_if(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _UnaryPredicate,
-    /* __is_vector = */ std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator
-__pattern_remove_if(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _UnaryPredicate) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __pattern_remove_if(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _UnaryPredicate) noexcept;
-
-//------------------------------------------------------------------------
-// merge
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_merge(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _OutputIterator,
-    _Compare,
-    /* __is_vector = */ std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_merge(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _OutputIterator,
-    _Compare,
-    /* __is_vector = */ std::true_type) noexcept;
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_merge(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _OutputIterator,
-    _Compare) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_merge(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _OutputIterator,
-    _Compare);
-
-//------------------------------------------------------------------------
-// inplace_merge
-//------------------------------------------------------------------------
-
-template <class _BidirectionalIterator, class _Compare>
-void __brick_inplace_merge(
-    _BidirectionalIterator,
-    _BidirectionalIterator,
-    _BidirectionalIterator,
-    _Compare,
-    /* __is_vector = */ std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _Compare>
-void __brick_inplace_merge(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Compare,
-    /* __is_vector = */ std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
-void __pattern_inplace_merge(
-    _Tag,
-    _ExecutionPolicy&&,
-    _BidirectionalIterator,
-    _BidirectionalIterator,
-    _BidirectionalIterator,
-    _Compare) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_inplace_merge(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Compare);
-
-//------------------------------------------------------------------------
-// includes
-//------------------------------------------------------------------------
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-bool __pattern_includes(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _Compare) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Compare>
-bool __pattern_includes(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _Compare);
-
-//------------------------------------------------------------------------
-// set_union
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_union(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _OutputIterator,
-    _Compare,
-    /*__is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_union(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _OutputIterator,
-    _Compare,
-    /*__is_vector=*/std::true_type) noexcept;
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_union(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _OutputIterator,
-    _Compare) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_union(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _OutputIterator,
-    _Compare);
-
-//------------------------------------------------------------------------
-// set_intersection
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_intersection(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _OutputIterator,
-    _Compare,
-    /*__is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_intersection(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _OutputIterator,
-    _Compare,
-    /*__is_vector=*/std::true_type) noexcept;
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_intersection(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _OutputIterator,
-    _Compare) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_intersection(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _OutputIterator,
-    _Compare);
-
-//------------------------------------------------------------------------
-// set_difference
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_difference(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _OutputIterator,
-    _Compare,
-    /*__is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_difference(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _OutputIterator,
-    _Compare,
-    /*__is_vector=*/std::true_type) noexcept;
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_difference(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _OutputIterator,
-    _Compare) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_difference(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _OutputIterator,
-    _Compare);
-
-//------------------------------------------------------------------------
-// set_symmetric_difference
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_symmetric_difference(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _OutputIterator,
-    _Compare,
-    /*__is_vector=*/std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_symmetric_difference(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _OutputIterator,
-    _Compare,
-    /*__is_vector=*/std::true_type) noexcept;
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_symmetric_difference(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _OutputIterator,
-    _Compare) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_symmetric_difference(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _OutputIterator,
-    _Compare);
-
-//------------------------------------------------------------------------
-// is_heap_until
-//------------------------------------------------------------------------
-
-template <class _RandomAccessIterator, class _Compare>
-_RandomAccessIterator __brick_is_heap_until(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Compare,
-    /* __is_vector = */ std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _Compare>
-_RandomAccessIterator __brick_is_heap_until(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Compare,
-    /* __is_vector = */ std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-_RandomAccessIterator
-__pattern_is_heap_until(_Tag, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept;
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-_RandomAccessIterator __pattern_is_heap_until(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare) noexcept;
-
-//------------------------------------------------------------------------
-// min_element
-//------------------------------------------------------------------------
-
-template <typename _ForwardIterator, typename _Compare>
-_ForwardIterator __brick_min_element(
-    _ForwardIterator,
-    _ForwardIterator,
-    _Compare,
-    /* __is_vector = */ std::false_type) noexcept;
-
-template <typename _RandomAccessIterator, typename _Compare>
-_RandomAccessIterator __brick_min_element(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Compare,
-    /* __is_vector = */ std::true_type) noexcept;
-
-template <typename _Tag, typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare>
-_ForwardIterator __pattern_min_element(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare) noexcept;
-
-template <typename _IsVector, typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare>
-_RandomAccessIterator __pattern_min_element(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare);
-
-//------------------------------------------------------------------------
-// minmax_element
-//------------------------------------------------------------------------
-
-template <typename _ForwardIterator, typename _Compare>
-std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(
-    _ForwardIterator,
-    _ForwardIterator,
-    _Compare,
-    /* __is_vector = */ std::false_type) noexcept;
-
-template <typename _RandomAccessIterator, typename _Compare>
-std::pair<_RandomAccessIterator, _RandomAccessIterator> __brick_minmax_element(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Compare,
-    /* __is_vector = */ std::true_type) noexcept;
-
-template <typename _Tag, typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare>
-std::pair<_ForwardIterator, _ForwardIterator>
-__pattern_minmax_element(_Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Compare) noexcept;
-
-template <typename _IsVector, typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare>
-std::pair<_RandomAccessIterator, _RandomAccessIterator> __pattern_minmax_element(
-    __parallel_tag<_IsVector>, _ExecutionPolicy&&, _RandomAccessIterator, _RandomAccessIterator, _Compare);
-
-//------------------------------------------------------------------------
-// mismatch
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _Predicate,
-    /* __is_vector = */ std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate>
-std::pair<_RandomAccessIterator1, _RandomAccessIterator2> __brick_mismatch(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _Predicate,
-    /* __is_vector = */ std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-std::pair<_ForwardIterator1, _ForwardIterator2> __pattern_mismatch(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _Predicate) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Predicate>
-std::pair<_RandomAccessIterator1, _RandomAccessIterator2> __pattern_mismatch(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _Predicate) noexcept;
-
-//------------------------------------------------------------------------
-// lexicographical_compare
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-bool __brick_lexicographical_compare(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _Compare,
-    /* __is_vector = */ std::false_type) noexcept;
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Compare>
-bool __brick_lexicographical_compare(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _Compare,
-    /* __is_vector = */ std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-bool __pattern_lexicographical_compare(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _ForwardIterator2,
-    _Compare) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Compare>
-bool __pattern_lexicographical_compare(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _RandomAccessIterator2,
-    _Compare) noexcept;
-
-} // namespace __internal
-} // namespace __pstl
-
-#endif /* _PSTL_ALGORITHM_FWD_H */
diff --git a/third_party/libcxx/__pstl/internal/algorithm_impl.h b/third_party/libcxx/__pstl/internal/algorithm_impl.h
deleted file mode 100644
index 46da3b5dd..000000000
--- a/third_party/libcxx/__pstl/internal/algorithm_impl.h
+++ /dev/null
@@ -1,4174 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_ALGORITHM_IMPL_H
-#define _PSTL_ALGORITHM_IMPL_H
-
-#include <__assert>
-#include <__config>
-#include <algorithm>
-#include <functional>
-#include <iterator>
-#include <type_traits>
-#include <utility>
-
-#include "execution_impl.h"
-#include "memory_impl.h"
-#include "parallel_backend.h"
-#include "parallel_backend_utils.h"
-// #include "parallel_impl.h"
-#include "unseq_backend_simd.h"
-
-namespace __pstl {
-namespace __internal {
-
-// [alg.foreach]
-// for_each_n with no policy
-
-template <class _ForwardIterator, class _Size, class _Function>
-_ForwardIterator __for_each_n_it_serial(_ForwardIterator __first, _Size __n, _Function __f) {
-  for (; __n > 0; ++__first, --__n)
-    __f(__first);
-  return __first;
-}
-
-//------------------------------------------------------------------------
-// walk1 (pseudo)
-//
-// walk1 evaluates f(x) for each dereferenced value x drawn from [first,last)
-//------------------------------------------------------------------------
-template <class _ForwardIterator, class _Function>
-void __brick_walk1(
-    _ForwardIterator __first, _ForwardIterator __last, _Function __f, /*vector=*/std::false_type) noexcept {
-  std::for_each(__first, __last, __f);
-}
-
-template <class _RandomAccessIterator, class _Function>
-void __brick_walk1(_RandomAccessIterator __first,
-                   _RandomAccessIterator __last,
-                   _Function __f,
-                   /*vector=*/std::true_type) noexcept {
-  __unseq_backend::__simd_walk_1(__first, __last - __first, __f);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Function>
-void __pattern_walk1(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Function __f) noexcept {
-  __internal::__brick_walk1(__first, __last, __f, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Function>
-void __pattern_walk1(__parallel_tag<_IsVector> __tag,
-                     _ExecutionPolicy&& __exec,
-                     _RandomAccessIterator __first,
-                     _RandomAccessIterator __last,
-                     _Function __f) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  __internal::__except_handler([&]() {
-    __par_backend::__parallel_for(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        [__f](_RandomAccessIterator __i, _RandomAccessIterator __j) {
-          __internal::__brick_walk1(__i, __j, __f, _IsVector{});
-        });
-  });
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Brick>
-void __pattern_walk_brick(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Brick __brick) noexcept {
-  __brick(__first, __last);
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Brick>
-void __pattern_walk_brick(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Brick __brick) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  __internal::__except_handler([&]() {
-    __par_backend::__parallel_for(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        [__brick](_RandomAccessIterator __i, _RandomAccessIterator __j) { __brick(__i, __j); });
-  });
-}
-
-//------------------------------------------------------------------------
-// walk1_n
-//------------------------------------------------------------------------
-template <class _ForwardIterator, class _Size, class _Function>
-_ForwardIterator __brick_walk1_n(_ForwardIterator __first, _Size __n, _Function __f, /*_IsVectorTag=*/std::false_type) {
-  return __internal::__for_each_n_it_serial(__first, __n, [&__f](_ForwardIterator __it) {
-    __f(*__it);
-  }); // calling serial version
-}
-
-template <class _RandomAccessIterator, class _DifferenceType, class _Function>
-_RandomAccessIterator
-__brick_walk1_n(_RandomAccessIterator __first,
-                _DifferenceType __n,
-                _Function __f,
-                /*vectorTag=*/std::true_type) noexcept {
-  return __unseq_backend::__simd_walk_1(__first, __n, __f);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function>
-_ForwardIterator
-__pattern_walk1_n(_Tag, _ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Function __f) noexcept {
-  return __internal::__brick_walk1_n(__first, __n, __f, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Function>
-_RandomAccessIterator __pattern_walk1_n(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _Size __n,
-    _Function __f) {
-  __internal::__pattern_walk1(__tag, std::forward<_ExecutionPolicy>(__exec), __first, __first + __n, __f);
-
-  return __first + __n;
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Brick>
-_ForwardIterator
-__pattern_walk_brick_n(_Tag, _ExecutionPolicy&&, _ForwardIterator __first, _Size __n, _Brick __brick) noexcept {
-  return __brick(__first, __n);
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Brick>
-_RandomAccessIterator __pattern_walk_brick_n(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _Size __n,
-    _Brick __brick) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    __par_backend::__parallel_for(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __first + __n,
-        [__brick](_RandomAccessIterator __i, _RandomAccessIterator __j) { __brick(__i, __j - __i); });
-    return __first + __n;
-  });
-}
-
-//------------------------------------------------------------------------
-// walk2 (pseudo)
-//
-// walk2 evaluates f(x,y) for deferenced values (x,y) drawn from [first1,last1) and [first2,...)
-//------------------------------------------------------------------------
-template <class _ForwardIterator1, class _ForwardIterator2, class _Function>
-_ForwardIterator2
-__brick_walk2(_ForwardIterator1 __first1,
-              _ForwardIterator1 __last1,
-              _ForwardIterator2 __first2,
-              _Function __f,
-              /*vector=*/std::false_type) noexcept {
-  for (; __first1 != __last1; ++__first1, ++__first2)
-    __f(*__first1, *__first2);
-  return __first2;
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Function>
-_RandomAccessIterator2
-__brick_walk2(_RandomAccessIterator1 __first1,
-              _RandomAccessIterator1 __last1,
-              _RandomAccessIterator2 __first2,
-              _Function __f,
-              /*vector=*/std::true_type) noexcept {
-  return __unseq_backend::__simd_walk_2(__first1, __last1 - __first1, __first2, __f);
-}
-
-template <class _ForwardIterator1, class _Size, class _ForwardIterator2, class _Function>
-_ForwardIterator2 __brick_walk2_n(
-    _ForwardIterator1 __first1,
-    _Size __n,
-    _ForwardIterator2 __first2,
-    _Function __f,
-    /*vector=*/std::false_type) noexcept {
-  for (; __n > 0; --__n, ++__first1, ++__first2)
-    __f(*__first1, *__first2);
-  return __first2;
-}
-
-template <class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2, class _Function>
-_RandomAccessIterator2 __brick_walk2_n(
-    _RandomAccessIterator1 __first1,
-    _Size __n,
-    _RandomAccessIterator2 __first2,
-    _Function __f,
-    /*vector=*/std::true_type) noexcept {
-  return __unseq_backend::__simd_walk_2(__first1, __n, __first2, __f);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Function>
-_ForwardIterator2 __pattern_walk2(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _Function __f) noexcept {
-  return __internal::__brick_walk2(__first1, __last1, __first2, __f, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Function>
-_RandomAccessIterator2 __pattern_walk2(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _Function __f) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    __par_backend::__parallel_for(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        [__f, __first1, __first2](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-          __internal::__brick_walk2(__i, __j, __first2 + (__i - __first1), __f, _IsVector{});
-        });
-    return __first2 + (__last1 - __first1);
-  });
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _Size,
-          class _ForwardIterator2,
-          class _Function>
-_ForwardIterator2 __pattern_walk2_n(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _Size __n,
-    _ForwardIterator2 __first2,
-    _Function __f) noexcept {
-  return __internal::__brick_walk2_n(__first1, __n, __first2, __f, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _Size,
-          class _RandomAccessIterator2,
-          class _Function>
-_RandomAccessIterator2 __pattern_walk2_n(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _Size __n,
-    _RandomAccessIterator2 __first2,
-    _Function __f) {
-  return __internal::__pattern_walk2(
-      __tag, std::forward<_ExecutionPolicy>(__exec), __first1, __first1 + __n, __first2, __f);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Brick>
-_ForwardIterator2 __pattern_walk2_brick(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _Brick __brick) noexcept {
-  return __brick(__first1, __last1, __first2);
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Brick>
-_RandomAccessIterator2 __pattern_walk2_brick(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _Brick __brick) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    __par_backend::__parallel_for(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-          __brick(__i, __j, __first2 + (__i - __first1));
-        });
-    return __first2 + (__last1 - __first1);
-  });
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _Size,
-          class _ForwardIterator2,
-          class _Brick>
-_ForwardIterator2 __pattern_walk2_brick_n(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _Size __n,
-    _ForwardIterator2 __first2,
-    _Brick __brick) noexcept {
-  return __brick(__first1, __n, __first2);
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _Size,
-          class _RandomAccessIterator2,
-          class _Brick>
-_RandomAccessIterator2 __pattern_walk2_brick_n(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _Size __n,
-    _RandomAccessIterator2 __first2,
-    _Brick __brick) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    __par_backend::__parallel_for(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __first1 + __n,
-        [__first1, __first2, __brick](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-          __brick(__i, __j - __i, __first2 + (__i - __first1));
-        });
-    return __first2 + __n;
-  });
-}
-
-//------------------------------------------------------------------------
-// walk3 (pseudo)
-//
-// walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...)
-//------------------------------------------------------------------------
-template <class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator3, class _Function>
-_ForwardIterator3 __brick_walk3(
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator3 __first3,
-    _Function __f,
-    /*vector=*/std::false_type) noexcept {
-  for (; __first1 != __last1; ++__first1, ++__first2, ++__first3)
-    __f(*__first1, *__first2, *__first3);
-  return __first3;
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Function>
-_RandomAccessIterator3 __brick_walk3(
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator3 __first3,
-    _Function __f,
-    /*vector=*/std::true_type) noexcept {
-  return __unseq_backend::__simd_walk_3(__first1, __last1 - __first1, __first2, __first3, __f);
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator3,
-          class _Function>
-_ForwardIterator3 __pattern_walk3(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator3 __first3,
-    _Function __f) noexcept {
-  return __internal::__brick_walk3(__first1, __last1, __first2, __first3, __f, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _RandomAccessIterator3,
-          class _Function>
-_RandomAccessIterator3 __pattern_walk3(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator3 __first3,
-    _Function __f) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    __par_backend::__parallel_for(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        [__f, __first1, __first2, __first3](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-          __internal::__brick_walk3(
-              __i, __j, __first2 + (__i - __first1), __first3 + (__i - __first1), __f, _IsVector{});
-        });
-    return __first3 + (__last1 - __first1);
-  });
-}
-
-//------------------------------------------------------------------------
-// equal
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool __brick_equal(_ForwardIterator1 __first1,
-                   _ForwardIterator1 __last1,
-                   _ForwardIterator2 __first2,
-                   _ForwardIterator2 __last2,
-                   _BinaryPredicate __p,
-                   /* IsVector = */ std::false_type) noexcept {
-  return std::equal(__first1, __last1, __first2, __last2, __p);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-bool __brick_equal(_RandomAccessIterator1 __first1,
-                   _RandomAccessIterator1 __last1,
-                   _RandomAccessIterator2 __first2,
-                   _RandomAccessIterator2 __last2,
-                   _BinaryPredicate __p,
-                   /* is_vector = */ std::true_type) noexcept {
-  if (__last1 - __first1 != __last2 - __first2)
-    return false;
-
-  return __unseq_backend::__simd_first(__first1, __last1 - __first1, __first2, std::not_fn(__p)).first == __last1;
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool __pattern_equal(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _BinaryPredicate __p) noexcept {
-  return __internal::__brick_equal(__first1, __last1, __first2, __last2, __p, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-bool __pattern_equal(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _BinaryPredicate __p) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  if (__last1 - __first1 != __last2 - __first2)
-    return false;
-
-  return __internal::__except_handler([&]() {
-    return !__internal::__parallel_or(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        [__first1, __first2, __p](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-          return !__internal::__brick_equal(
-              __i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), __p, _IsVector{});
-        });
-  });
-}
-
-//------------------------------------------------------------------------
-// equal version for sequences with equal length
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool __brick_equal(_ForwardIterator1 __first1,
-                   _ForwardIterator1 __last1,
-                   _ForwardIterator2 __first2,
-                   _BinaryPredicate __p,
-                   /* IsVector = */ std::false_type) noexcept {
-  return std::equal(__first1, __last1, __first2, __p);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-bool __brick_equal(_RandomAccessIterator1 __first1,
-                   _RandomAccessIterator1 __last1,
-                   _RandomAccessIterator2 __first2,
-                   _BinaryPredicate __p,
-                   /* is_vector = */ std::true_type) noexcept {
-  return __unseq_backend::__simd_first(__first1, __last1 - __first1, __first2, std::not_fn(__p)).first == __last1;
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-bool __pattern_equal(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _BinaryPredicate __p) noexcept {
-  return __internal::__brick_equal(__first1, __last1, __first2, __p, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-bool __pattern_equal(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _BinaryPredicate __p) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    return !__internal::__parallel_or(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        [__first1, __first2, __p](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-          return !__internal::__brick_equal(__i, __j, __first2 + (__i - __first1), __p, _IsVector{});
-        });
-  });
-}
-
-//------------------------------------------------------------------------
-// find_end
-//------------------------------------------------------------------------
-
-// find the first occurrence of the subsequence [s_first, s_last)
-//   or the  last occurrence of the subsequence in the range [first, last)
-// b_first determines what occurrence we want to find (first or last)
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate, class _IsVector>
-_RandomAccessIterator1 __find_subrange(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator1 __global_last,
-    _RandomAccessIterator2 __s_first,
-    _RandomAccessIterator2 __s_last,
-    _BinaryPredicate __pred,
-    bool __b_first,
-    _IsVector __is_vector) noexcept {
-  typedef typename std::iterator_traits<_RandomAccessIterator2>::value_type _ValueType;
-  auto __n2 = __s_last - __s_first;
-  if (__n2 < 1) {
-    return __b_first ? __first : __last;
-  }
-
-  auto __n1 = __global_last - __first;
-  if (__n1 < __n2) {
-    return __last;
-  }
-
-  auto __cur = __last;
-  while (__first != __last && (__global_last - __first >= __n2)) {
-    // find position of *s_first in [first, last) (it can be start of subsequence)
-    __first = __internal::__brick_find_if(
-        __first, __last, __equal_value_by_pred<_ValueType, _BinaryPredicate>(*__s_first, __pred), __is_vector);
-
-    // if position that was found previously is the start of subsequence
-    // then we can exit the loop (b_first == true) or keep the position
-    // (b_first == false)
-    if (__first != __last && (__global_last - __first >= __n2) &&
-        __internal::__brick_equal(__s_first + 1, __s_last, __first + 1, __pred, __is_vector)) {
-      if (__b_first) {
-        return __first;
-      } else {
-        __cur = __first;
-      }
-    } else if (__first == __last) {
-      break;
-    } else {
-    }
-
-    // in case of b_first == false we try to find new start position
-    // for the next subsequence
-    ++__first;
-  }
-  return __cur;
-}
-
-template <class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate, class _IsVector>
-_RandomAccessIterator __find_subrange(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _RandomAccessIterator __global_last,
-    _Size __count,
-    const _Tp& __value,
-    _BinaryPredicate __pred,
-    _IsVector __is_vector) noexcept {
-  if (static_cast<_Size>(__global_last - __first) < __count || __count < 1) {
-    return __last; // According to the standard last shall be returned when count < 1
-  }
-
-  auto __unary_pred = __equal_value_by_pred<_Tp, _BinaryPredicate>(__value, __pred);
-  while (__first != __last && (static_cast<_Size>(__global_last - __first) >= __count)) {
-    __first = __internal::__brick_find_if(__first, __last, __unary_pred, __is_vector);
-
-    // check that all of elements in [first+1, first+count) equal to value
-    if (__first != __last && (static_cast<_Size>(__global_last - __first) >= __count) &&
-        !__internal::__brick_any_of(__first + 1, __first + __count, std::not_fn(__unary_pred), __is_vector)) {
-      return __first;
-    } else if (__first == __last) {
-      break;
-    } else {
-      ++__first;
-    }
-  }
-  return __last;
-}
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __brick_find_end(
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __s_first,
-    _ForwardIterator2 __s_last,
-    _BinaryPredicate __pred,
-    /*__is_vector=*/std::false_type) noexcept {
-  return std::find_end(__first, __last, __s_first, __s_last, __pred);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator1 __brick_find_end(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __s_first,
-    _RandomAccessIterator2 __s_last,
-    _BinaryPredicate __pred,
-    /*__is_vector=*/std::true_type) noexcept {
-  return __find_subrange(__first, __last, __last, __s_first, __s_last, __pred, false, std::true_type());
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __pattern_find_end(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __s_first,
-    _ForwardIterator2 __s_last,
-    _BinaryPredicate __pred) noexcept {
-  return __internal::__brick_find_end(__first, __last, __s_first, __s_last, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-_RandomAccessIterator1 __pattern_find_end(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __s_first,
-    _RandomAccessIterator2 __s_last,
-    _BinaryPredicate __pred) noexcept {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  if (__last - __first == __s_last - __s_first) {
-    const bool __res =
-        __internal::__pattern_equal(__tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __pred);
-    return __res ? __first : __last;
-  } else {
-    return __internal::__except_handler([&]() {
-      return __internal::__parallel_find(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __first,
-          __last,
-          [__last, __s_first, __s_last, __pred](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-            return __internal::__find_subrange(__i, __j, __last, __s_first, __s_last, __pred, false, _IsVector{});
-          },
-          std::greater<typename std::iterator_traits<_RandomAccessIterator1>::difference_type>(),
-          /*is_first=*/false);
-    });
-  }
-}
-
-//------------------------------------------------------------------------
-// find_first_of
-//------------------------------------------------------------------------
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __brick_find_first_of(
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __s_first,
-    _ForwardIterator2 __s_last,
-    _BinaryPredicate __pred,
-    /*__is_vector=*/std::false_type) noexcept {
-  return std::find_first_of(__first, __last, __s_first, __s_last, __pred);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator1 __brick_find_first_of(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __s_first,
-    _RandomAccessIterator2 __s_last,
-    _BinaryPredicate __pred,
-    /*__is_vector=*/std::true_type) noexcept {
-  return __unseq_backend::__simd_find_first_of(__first, __last, __s_first, __s_last, __pred);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __pattern_find_first_of(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __s_first,
-    _ForwardIterator2 __s_last,
-    _BinaryPredicate __pred) noexcept {
-  return __internal::__brick_find_first_of(__first, __last, __s_first, __s_last, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-_RandomAccessIterator1 __pattern_find_first_of(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __s_first,
-    _RandomAccessIterator2 __s_last,
-    _BinaryPredicate __pred) noexcept {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    return __internal::__parallel_find(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        [__s_first, __s_last, __pred](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-          return __internal::__brick_find_first_of(__i, __j, __s_first, __s_last, __pred, _IsVector{});
-        },
-        std::less<typename std::iterator_traits<_RandomAccessIterator1>::difference_type>(),
-        /*is_first=*/true);
-  });
-}
-
-//------------------------------------------------------------------------
-// search
-//------------------------------------------------------------------------
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator1 __brick_search(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __s_first,
-    _RandomAccessIterator2 __s_last,
-    _BinaryPredicate __pred,
-    /*vector=*/std::false_type) noexcept {
-  return std::search(__first, __last, __s_first, __s_last, __pred);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator1 __brick_search(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __s_first,
-    _RandomAccessIterator2 __s_last,
-    _BinaryPredicate __pred,
-    /*vector=*/std::true_type) noexcept {
-  return __internal::__find_subrange(__first, __last, __last, __s_first, __s_last, __pred, true, std::true_type());
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_ForwardIterator1 __pattern_search(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __s_first,
-    _ForwardIterator2 __s_last,
-    _BinaryPredicate __pred) noexcept {
-  return __internal::__brick_search(__first, __last, __s_first, __s_last, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-_RandomAccessIterator1 __pattern_search(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __s_first,
-    _RandomAccessIterator2 __s_last,
-    _BinaryPredicate __pred) noexcept {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  if (__last - __first == __s_last - __s_first) {
-    const bool __res =
-        __internal::__pattern_equal(__tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __pred);
-    return __res ? __first : __last;
-  } else {
-    return __internal::__except_handler([&]() {
-      return __internal::__parallel_find(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __first,
-          __last,
-          [__last, __s_first, __s_last, __pred](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-            return __internal::__find_subrange(__i, __j, __last, __s_first, __s_last, __pred, true, _IsVector{});
-          },
-          std::less<typename std::iterator_traits<_RandomAccessIterator1>::difference_type>(),
-          /*is_first=*/true);
-    });
-  }
-}
-
-//------------------------------------------------------------------------
-// search_n
-//------------------------------------------------------------------------
-template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-_ForwardIterator __brick_search_n(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _Size __count,
-    const _Tp& __value,
-    _BinaryPredicate __pred,
-    /*vector=*/std::false_type) noexcept {
-  return std::search_n(__first, __last, __count, __value, __pred);
-}
-
-template <class _RandomAccessIterator, class _Size, class _Tp, class _BinaryPredicate>
-_RandomAccessIterator __brick_search_n(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Size __count,
-    const _Tp& __value,
-    _BinaryPredicate __pred,
-    /*vector=*/std::true_type) noexcept {
-  return __internal::__find_subrange(__first, __last, __last, __count, __value, __pred, std::true_type());
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-_ForwardIterator __pattern_search_n(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _Size __count,
-    const _Tp& __value,
-    _BinaryPredicate __pred) noexcept {
-  return __internal::__brick_search_n(__first, __last, __count, __value, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _Size,
-          class _Tp,
-          class _BinaryPredicate>
-_RandomAccessIterator __pattern_search_n(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Size __count,
-    const _Tp& __value,
-    _BinaryPredicate __pred) noexcept {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  if (static_cast<_Size>(__last - __first) == __count) {
-    const bool __result = !__internal::__pattern_any_of(
-        __tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value, &__pred](const _Tp& __val) {
-          return !__pred(__val, __value);
-        });
-    return __result ? __first : __last;
-  } else {
-    return __internal::__except_handler([&__exec, __first, __last, __count, &__value, __pred]() {
-      return __internal::__parallel_find(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __first,
-          __last,
-          [__last, __count, &__value, __pred](_RandomAccessIterator __i, _RandomAccessIterator __j) {
-            return __internal::__find_subrange(__i, __j, __last, __count, __value, __pred, _IsVector{});
-          },
-          std::less<typename std::iterator_traits<_RandomAccessIterator>::difference_type>(),
-          /*is_first=*/true);
-    });
-  }
-}
-
-//------------------------------------------------------------------------
-// copy_n
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _Size, class _OutputIterator>
-_OutputIterator
-__brick_copy_n(_ForwardIterator __first, _Size __n, _OutputIterator __result, /*vector=*/std::false_type) noexcept {
-  return std::copy_n(__first, __n, __result);
-}
-
-template <class _RandomAccessIterator1, class _Size, class _RandomAccessIterator2>
-_RandomAccessIterator2
-__brick_copy_n(_RandomAccessIterator1 __first,
-               _Size __n,
-               _RandomAccessIterator2 __result,
-               /*vector=*/std::true_type) noexcept {
-  return __unseq_backend::__simd_assign(
-      __first, __n, __result, [](_RandomAccessIterator1 __first, _RandomAccessIterator2 __result) {
-        *__result = *__first;
-      });
-}
-
-//------------------------------------------------------------------------
-// copy
-//------------------------------------------------------------------------
-template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator
-__brick_copy(_ForwardIterator __first,
-             _ForwardIterator __last,
-             _OutputIterator __result,
-             /*vector=*/std::false_type) noexcept {
-  return std::copy(__first, __last, __result);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2>
-_RandomAccessIterator2
-__brick_copy(_RandomAccessIterator1 __first,
-             _RandomAccessIterator1 __last,
-             _RandomAccessIterator2 __result,
-             /*vector=*/std::true_type) noexcept {
-  return __unseq_backend::__simd_assign(
-      __first, __last - __first, __result, [](_RandomAccessIterator1 __first, _RandomAccessIterator2 __result) {
-        *__result = *__first;
-      });
-}
-
-//------------------------------------------------------------------------
-// move
-//------------------------------------------------------------------------
-template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator
-__brick_move(_ForwardIterator __first,
-             _ForwardIterator __last,
-             _OutputIterator __result,
-             /*vector=*/std::false_type) noexcept {
-  return std::move(__first, __last, __result);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2>
-_RandomAccessIterator2
-__brick_move(_RandomAccessIterator1 __first,
-             _RandomAccessIterator1 __last,
-             _RandomAccessIterator2 __result,
-             /*vector=*/std::true_type) noexcept {
-  return __unseq_backend::__simd_assign(
-      __first, __last - __first, __result, [](_RandomAccessIterator1 __first, _RandomAccessIterator2 __result) {
-        *__result = std::move(*__first);
-      });
-}
-
-struct __brick_move_destroy {
-  template <typename _RandomAccessIterator1, typename _RandomAccessIterator2>
-  _RandomAccessIterator2
-  operator()(_RandomAccessIterator1 __first,
-             _RandomAccessIterator1 __last,
-             _RandomAccessIterator2 __result,
-             /*vec*/ std::true_type) const {
-    using _IteratorValueType = typename std::iterator_traits<_RandomAccessIterator1>::value_type;
-
-    return __unseq_backend::__simd_assign(
-        __first, __last - __first, __result, [](_RandomAccessIterator1 __first, _RandomAccessIterator2 __result) {
-          *__result = std::move(*__first);
-          (*__first).~_IteratorValueType();
-        });
-  }
-
-  template <typename _RandomAccessIterator1, typename _RandomAccessIterator2>
-  _RandomAccessIterator2
-  operator()(_RandomAccessIterator1 __first,
-             _RandomAccessIterator1 __last,
-             _RandomAccessIterator2 __result,
-             /*vec*/ std::false_type) const {
-    using _IteratorValueType = typename std::iterator_traits<_RandomAccessIterator1>::value_type;
-
-    for (; __first != __last; ++__first, ++__result) {
-      *__result = std::move(*__first);
-      (*__first).~_IteratorValueType();
-    }
-    return __result;
-  }
-};
-
-//------------------------------------------------------------------------
-// swap_ranges
-//------------------------------------------------------------------------
-template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator __brick_swap_ranges(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __result,
-    /*vector=*/std::false_type) noexcept {
-  return std::swap_ranges(__first, __last, __result);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2>
-_RandomAccessIterator2 __brick_swap_ranges(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __result,
-    /*vector=*/std::true_type) noexcept {
-  using std::iter_swap;
-  return __unseq_backend::__simd_assign(
-      __first, __last - __first, __result, iter_swap<_RandomAccessIterator1, _RandomAccessIterator2>);
-}
-
-//------------------------------------------------------------------------
-// copy_if
-//------------------------------------------------------------------------
-template <class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
-_OutputIterator __brick_copy_if(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __result,
-    _UnaryPredicate __pred,
-    /*vector=*/std::false_type) noexcept {
-  return std::copy_if(__first, __last, __result, __pred);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _UnaryPredicate>
-_RandomAccessIterator2 __brick_copy_if(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __result,
-    _UnaryPredicate __pred,
-    /*vector=*/std::true_type) noexcept {
-#if defined(_PSTL_MONOTONIC_PRESENT)
-  return __unseq_backend::__simd_copy_if(__first, __last - __first, __result, __pred);
-#else
-  return std::copy_if(__first, __last, __result, __pred);
-#endif
-}
-
-// TODO: Try to use transform_reduce for combining __brick_copy_if_phase1 on IsVector.
-template <class _DifferenceType, class _ForwardIterator, class _UnaryPredicate>
-std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    bool* __restrict __mask,
-    _UnaryPredicate __pred,
-    /*vector=*/std::false_type) noexcept {
-  auto __count_true = _DifferenceType(0);
-  auto __size       = __last - __first;
-
-  static_assert(__are_random_access_iterators<_ForwardIterator>::value,
-                "Pattern-brick error. Should be a random access iterator.");
-
-  for (; __first != __last; ++__first, ++__mask) {
-    *__mask = __pred(*__first);
-    if (*__mask) {
-      ++__count_true;
-    }
-  }
-  return std::make_pair(__count_true, __size - __count_true);
-}
-
-template <class _DifferenceType, class _RandomAccessIterator, class _UnaryPredicate>
-std::pair<_DifferenceType, _DifferenceType> __brick_calc_mask_1(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    bool* __mask,
-    _UnaryPredicate __pred,
-    /*vector=*/std::true_type) noexcept {
-  auto __result = __unseq_backend::__simd_calc_mask_1(__first, __last - __first, __mask, __pred);
-  return std::make_pair(__result, (__last - __first) - __result);
-}
-
-template <class _ForwardIterator, class _OutputIterator, class _Assigner>
-void __brick_copy_by_mask(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __result,
-    bool* __mask,
-    _Assigner __assigner,
-    /*vector=*/std::false_type) noexcept {
-  for (; __first != __last; ++__first, ++__mask) {
-    if (*__mask) {
-      __assigner(__first, __result);
-      ++__result;
-    }
-  }
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Assigner>
-void __brick_copy_by_mask(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __result,
-    bool* __restrict __mask,
-    _Assigner __assigner,
-    /*vector=*/std::true_type) noexcept {
-#if defined(_PSTL_MONOTONIC_PRESENT)
-  __unseq_backend::__simd_copy_by_mask(__first, __last - __first, __result, __mask, __assigner);
-#else
-  __internal::__brick_copy_by_mask(__first, __last, __result, __mask, __assigner, std::false_type());
-#endif
-}
-
-template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2>
-void __brick_partition_by_mask(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator1 __out_true,
-    _OutputIterator2 __out_false,
-    bool* __mask,
-    /*vector=*/std::false_type) noexcept {
-  for (; __first != __last; ++__first, ++__mask) {
-    if (*__mask) {
-      *__out_true = *__first;
-      ++__out_true;
-    } else {
-      *__out_false = *__first;
-      ++__out_false;
-    }
-  }
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3>
-void __brick_partition_by_mask(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __out_true,
-    _RandomAccessIterator3 __out_false,
-    bool* __mask,
-    /*vector=*/std::true_type) noexcept {
-#if defined(_PSTL_MONOTONIC_PRESENT)
-  __unseq_backend::__simd_partition_by_mask(__first, __last - __first, __out_true, __out_false, __mask);
-#else
-  __internal::__brick_partition_by_mask(__first, __last, __out_true, __out_false, __mask, std::false_type());
-#endif
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _UnaryPredicate>
-_OutputIterator __pattern_copy_if(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __result,
-    _UnaryPredicate __pred) noexcept {
-  return __internal::__brick_copy_if(__first, __last, __result, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _UnaryPredicate>
-_RandomAccessIterator2 __pattern_copy_if(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __result,
-    _UnaryPredicate __pred) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType;
-  const _DifferenceType __n = __last - __first;
-  if (_DifferenceType(1) < __n) {
-    __par_backend::__buffer<bool> __mask_buf(__n);
-    return __internal::__except_handler([&__exec, __n, __first, __result, __pred, &__mask_buf]() {
-      bool* __mask = __mask_buf.get();
-      _DifferenceType __m{};
-      __par_backend::__parallel_strict_scan(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __n,
-          _DifferenceType(0),
-          [=](_DifferenceType __i, _DifferenceType __len) { // Reduce
-            return __internal::__brick_calc_mask_1<_DifferenceType>(
-                       __first + __i, __first + (__i + __len), __mask + __i, __pred, _IsVector{})
-                .first;
-          },
-          std::plus<_DifferenceType>(),                                                // Combine
-          [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { // Scan
-            __internal::__brick_copy_by_mask(
-                __first + __i,
-                __first + (__i + __len),
-                __result + __initial,
-                __mask + __i,
-                [](_RandomAccessIterator1 __x, _RandomAccessIterator2 __z) { *__z = *__x; },
-                _IsVector{});
-          },
-          [&__m](_DifferenceType __total) { __m = __total; });
-      return __result + __m;
-    });
-  }
-  // trivial sequence - use serial algorithm
-  return __internal::__brick_copy_if(__first, __last, __result, __pred, _IsVector{});
-}
-
-//------------------------------------------------------------------------
-// count
-//------------------------------------------------------------------------
-template <class _RandomAccessIterator, class _Predicate>
-typename std::iterator_traits<_RandomAccessIterator>::difference_type
-__brick_count(_RandomAccessIterator __first,
-              _RandomAccessIterator __last,
-              _Predicate __pred,
-              /* is_vector = */ std::true_type) noexcept {
-  return __unseq_backend::__simd_count(__first, __last - __first, __pred);
-}
-
-template <class _ForwardIterator, class _Predicate>
-typename std::iterator_traits<_ForwardIterator>::difference_type
-__brick_count(_ForwardIterator __first,
-              _ForwardIterator __last,
-              _Predicate __pred,
-              /* is_vector = */ std::false_type) noexcept {
-  return std::count_if(__first, __last, __pred);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-typename std::iterator_traits<_ForwardIterator>::difference_type __pattern_count(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) noexcept {
-  return __internal::__brick_count(__first, __last, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Predicate>
-typename std::iterator_traits<_RandomAccessIterator>::difference_type __pattern_count(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Predicate __pred) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType;
-  return __internal::__except_handler([&]() {
-    return __par_backend::__parallel_reduce(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        _SizeType(0),
-        [__pred](_RandomAccessIterator __begin, _RandomAccessIterator __end, _SizeType __value) -> _SizeType {
-          return __value + __internal::__brick_count(__begin, __end, __pred, _IsVector{});
-        },
-        std::plus<_SizeType>());
-  });
-}
-
-//------------------------------------------------------------------------
-// unique
-//------------------------------------------------------------------------
-
-template <class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator
-__brick_unique(_RandomAccessIterator __first,
-               _RandomAccessIterator __last,
-               _BinaryPredicate __pred,
-               /*is_vector=*/std::false_type) noexcept {
-  return std::unique(__first, __last, __pred);
-}
-
-template <class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator
-__brick_unique(_RandomAccessIterator __first,
-               _RandomAccessIterator __last,
-               _BinaryPredicate __pred,
-               /*is_vector=*/std::true_type) noexcept {
-  // TODO: vectorize
-  return std::unique(__first, __last, __pred);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator __pattern_unique(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) noexcept {
-  return __internal::__brick_unique(__first, __last, __pred, typename _Tag::__is_vector{});
-}
-
-// That function is shared between two algorithms - remove_if (__pattern_remove_if) and unique (pattern unique). But a
-// mask calculation is different. So, a caller passes _CalcMask brick into remove_elements.
-template <class _IsVector, class _ExecutionPolicy, class _ForwardIterator, class _CalcMask>
-_ForwardIterator __remove_elements(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _CalcMask __calc_mask) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  typedef typename std::iterator_traits<_ForwardIterator>::difference_type _DifferenceType;
-  typedef typename std::iterator_traits<_ForwardIterator>::value_type _Tp;
-  _DifferenceType __n = __last - __first;
-  __par_backend::__buffer<bool> __mask_buf(__n);
-  // 1. find a first iterator that should be removed
-  return __internal::__except_handler([&]() {
-    bool* __mask          = __mask_buf.get();
-    _DifferenceType __min = __par_backend::__parallel_reduce(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        _DifferenceType(0),
-        __n,
-        __n,
-        [__first, __mask, &__calc_mask](
-            _DifferenceType __i, _DifferenceType __j, _DifferenceType __local_min) -> _DifferenceType {
-          // Create mask
-          __calc_mask(__mask + __i, __mask + __j, __first + __i);
-
-          // if minimum was found in a previous range we shouldn't do anymore
-          if (__local_min < __i) {
-            return __local_min;
-          }
-          // find first iterator that should be removed
-          bool* __result = __internal::__brick_find_if(
-              __mask + __i, __mask + __j, [](bool __val) { return !__val; }, _IsVector{});
-          if (__result - __mask == __j) {
-            return __local_min;
-          }
-          return std::min(__local_min, _DifferenceType(__result - __mask));
-        },
-        [](_DifferenceType __local_min1, _DifferenceType __local_min2) -> _DifferenceType {
-          return std::min(__local_min1, __local_min2);
-        });
-
-    // No elements to remove - exit
-    if (__min == __n) {
-      return __last;
-    }
-    __n -= __min;
-    __first += __min;
-
-    __par_backend::__buffer<_Tp> __buf(__n);
-    _Tp* __result = __buf.get();
-    __mask += __min;
-    _DifferenceType __m{};
-    // 2. Elements that doesn't satisfy pred are moved to result
-    __par_backend::__parallel_strict_scan(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __n,
-        _DifferenceType(0),
-        [__mask](_DifferenceType __i, _DifferenceType __len) {
-          return __internal::__brick_count(
-              __mask + __i, __mask + __i + __len, [](bool __val) { return __val; }, _IsVector{});
-        },
-        std::plus<_DifferenceType>(),
-        [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) {
-          __internal::__brick_copy_by_mask(
-              __first + __i,
-              __first + __i + __len,
-              __result + __initial,
-              __mask + __i,
-              [](_ForwardIterator __x, _Tp* __z) {
-                __internal::__invoke_if_else(
-                    std::is_trivial<_Tp>(),
-                    [&]() { *__z = std::move(*__x); },
-                    [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); });
-              },
-              _IsVector{});
-        },
-        [&__m](_DifferenceType __total) { __m = __total; });
-
-    // 3. Elements from result are moved to [first, last)
-    __par_backend::__parallel_for(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __result,
-        __result + __m,
-        [__result, __first](_Tp* __i, _Tp* __j) {
-          __invoke_if_else(
-              std::is_trivial<_Tp>(),
-              [&]() { __brick_move(__i, __j, __first + (__i - __result), _IsVector{}); },
-              [&]() { __brick_move_destroy()(__i, __j, __first + (__i - __result), _IsVector{}); });
-        });
-    return __first + __m;
-  });
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator __pattern_unique(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _BinaryPredicate __pred) noexcept {
-  typedef typename std::iterator_traits<_RandomAccessIterator>::reference _ReferenceType;
-
-  if (__first == __last) {
-    return __last;
-  }
-  if (__first + 1 == __last || __first + 2 == __last) {
-    // Trivial sequence - use serial algorithm
-    return __internal::__brick_unique(__first, __last, __pred, _IsVector{});
-  }
-  return __internal::__remove_elements(
-      __tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      ++__first,
-      __last,
-      [&__pred](bool* __b, bool* __e, _RandomAccessIterator __it) {
-        __internal::__brick_walk3(
-            __b,
-            __e,
-            __it - 1,
-            __it,
-            [&__pred](bool& __x, _ReferenceType __y, _ReferenceType __z) { __x = !__pred(__y, __z); },
-            _IsVector{});
-      });
-}
-
-//------------------------------------------------------------------------
-// unique_copy
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class OutputIterator, class _BinaryPredicate>
-OutputIterator __brick_unique_copy(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    OutputIterator __result,
-    _BinaryPredicate __pred,
-    /*vector=*/std::false_type) noexcept {
-  return std::unique_copy(__first, __last, __result, __pred);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _BinaryPredicate>
-_RandomAccessIterator2 __brick_unique_copy(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __result,
-    _BinaryPredicate __pred,
-    /*vector=*/std::true_type) noexcept {
-#if defined(_PSTL_MONOTONIC_PRESENT)
-  return __unseq_backend::__simd_unique_copy(__first, __last - __first, __result, __pred);
-#else
-  return std::unique_copy(__first, __last, __result, __pred);
-#endif
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryPredicate>
-_OutputIterator __pattern_unique_copy(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __result,
-    _BinaryPredicate __pred) noexcept {
-  return __internal::__brick_unique_copy(__first, __last, __result, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
-_DifferenceType __brick_calc_mask_2(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    bool* __restrict __mask,
-    _BinaryPredicate __pred,
-    /*vector=*/std::false_type) noexcept {
-  _DifferenceType __count = 0;
-  for (; __first != __last; ++__first, ++__mask) {
-    *__mask = !__pred(*__first, *(__first - 1));
-    __count += *__mask;
-  }
-  return __count;
-}
-
-template <class _DifferenceType, class _RandomAccessIterator, class _BinaryPredicate>
-_DifferenceType __brick_calc_mask_2(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    bool* __restrict __mask,
-    _BinaryPredicate __pred,
-    /*vector=*/std::true_type) noexcept {
-  return __unseq_backend::__simd_calc_mask_2(__first, __last - __first, __mask, __pred);
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryPredicate>
-_RandomAccessIterator2 __pattern_unique_copy(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __result,
-    _BinaryPredicate __pred) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType;
-  const _DifferenceType __n = __last - __first;
-  if (_DifferenceType(2) < __n) {
-    __par_backend::__buffer<bool> __mask_buf(__n);
-    if (_DifferenceType(2) < __n) {
-      return __internal::__except_handler([&__exec, __n, __first, __result, __pred, &__mask_buf]() {
-        bool* __mask = __mask_buf.get();
-        _DifferenceType __m{};
-        __par_backend::__parallel_strict_scan(
-            __backend_tag{},
-            std::forward<_ExecutionPolicy>(__exec),
-            __n,
-            _DifferenceType(0),
-            [=](_DifferenceType __i, _DifferenceType __len) -> _DifferenceType { // Reduce
-              _DifferenceType __extra = 0;
-              if (__i == 0) {
-                // Special boundary case
-                __mask[__i] = true;
-                if (--__len == 0)
-                  return 1;
-                ++__i;
-                ++__extra;
-              }
-              return __internal::__brick_calc_mask_2<_DifferenceType>(
-                         __first + __i, __first + (__i + __len), __mask + __i, __pred, _IsVector{}) +
-                     __extra;
-            },
-            std::plus<_DifferenceType>(),                                                // Combine
-            [=](_DifferenceType __i, _DifferenceType __len, _DifferenceType __initial) { // Scan
-              // Phase 2 is same as for __pattern_copy_if
-              __internal::__brick_copy_by_mask(
-                  __first + __i,
-                  __first + (__i + __len),
-                  __result + __initial,
-                  __mask + __i,
-                  [](_RandomAccessIterator1 __x, _RandomAccessIterator2 __z) { *__z = *__x; },
-                  _IsVector{});
-            },
-            [&__m](_DifferenceType __total) { __m = __total; });
-        return __result + __m;
-      });
-    }
-  }
-  // trivial sequence - use serial algorithm
-  return __internal::__brick_unique_copy(__first, __last, __result, __pred, _IsVector{});
-}
-
-//------------------------------------------------------------------------
-// reverse
-//------------------------------------------------------------------------
-template <class _BidirectionalIterator>
-void __brick_reverse(
-    _BidirectionalIterator __first, _BidirectionalIterator __last, /*__is_vector=*/std::false_type) noexcept {
-  std::reverse(__first, __last);
-}
-
-template <class _RandomAccessIterator>
-void __brick_reverse(
-    _RandomAccessIterator __first, _RandomAccessIterator __last, /*__is_vector=*/std::true_type) noexcept {
-  typedef typename std::iterator_traits<_RandomAccessIterator>::reference _ReferenceType;
-
-  const auto __n = (__last - __first) / 2;
-  __unseq_backend::__simd_walk_2(
-      __first, __n, std::reverse_iterator<_RandomAccessIterator>(__last), [](_ReferenceType __x, _ReferenceType __y) {
-        using std::swap;
-        swap(__x, __y);
-      });
-}
-
-// this brick is called in parallel version, so we can use iterator arithmetic
-template <class _BidirectionalIterator>
-void __brick_reverse(_BidirectionalIterator __first,
-                     _BidirectionalIterator __last,
-                     _BidirectionalIterator __d_last,
-                     /*is_vector=*/std::false_type) noexcept {
-  for (--__d_last; __first != __last; ++__first, --__d_last) {
-    using std::iter_swap;
-    iter_swap(__first, __d_last);
-  }
-}
-
-// this brick is called in parallel version, so we can use iterator arithmetic
-template <class _RandomAccessIterator>
-void __brick_reverse(_RandomAccessIterator __first,
-                     _RandomAccessIterator __last,
-                     _RandomAccessIterator __d_last,
-                     /*is_vector=*/std::true_type) noexcept {
-  typedef typename std::iterator_traits<_RandomAccessIterator>::reference _ReferenceType;
-
-  __unseq_backend::__simd_walk_2(
-      __first,
-      __last - __first,
-      std::reverse_iterator<_RandomAccessIterator>(__d_last),
-      [](_ReferenceType __x, _ReferenceType __y) {
-        using std::swap;
-        swap(__x, __y);
-      });
-}
-
-template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator>
-void __pattern_reverse(
-    _Tag, _ExecutionPolicy&&, _BidirectionalIterator __first, _BidirectionalIterator __last) noexcept {
-  __internal::__brick_reverse(__first, __last, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator>
-void __pattern_reverse(__parallel_tag<_IsVector> __tag,
-                       _ExecutionPolicy&& __exec,
-                       _RandomAccessIterator __first,
-                       _RandomAccessIterator __last) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  __par_backend::__parallel_for(
-      __backend_tag{},
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __first + (__last - __first) / 2,
-      [__first, __last](_RandomAccessIterator __inner_first, _RandomAccessIterator __inner_last) {
-        __internal::__brick_reverse(__inner_first, __inner_last, __last - (__inner_first - __first), _IsVector{});
-      });
-}
-
-//------------------------------------------------------------------------
-// reverse_copy
-//------------------------------------------------------------------------
-
-template <class _BidirectionalIterator, class _OutputIterator>
-_OutputIterator __brick_reverse_copy(
-    _BidirectionalIterator __first,
-    _BidirectionalIterator __last,
-    _OutputIterator __d_first,
-    /*is_vector=*/std::false_type) noexcept {
-  return std::reverse_copy(__first, __last, __d_first);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2>
-_RandomAccessIterator2 __brick_reverse_copy(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __d_first,
-    /*is_vector=*/std::true_type) noexcept {
-  typedef typename std::iterator_traits<_RandomAccessIterator1>::reference _ReferenceType1;
-  typedef typename std::iterator_traits<_RandomAccessIterator2>::reference _ReferenceType2;
-
-  return __unseq_backend::__simd_walk_2(
-      std::reverse_iterator<_RandomAccessIterator1>(__last),
-      __last - __first,
-      __d_first,
-      [](_ReferenceType1 __x, _ReferenceType2 __y) { __y = __x; });
-}
-
-template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _OutputIterator>
-_OutputIterator __pattern_reverse_copy(
-    _Tag,
-    _ExecutionPolicy&&,
-    _BidirectionalIterator __first,
-    _BidirectionalIterator __last,
-    _OutputIterator __d_first) noexcept {
-  return __internal::__brick_reverse_copy(__first, __last, __d_first, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2>
-_RandomAccessIterator2 __pattern_reverse_copy(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __d_first) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  auto __len = __last - __first;
-  __par_backend::__parallel_for(
-      __backend_tag{},
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      [__first, __len, __d_first](_RandomAccessIterator1 __inner_first, _RandomAccessIterator1 __inner_last) {
-        __internal::__brick_reverse_copy(
-            __inner_first, __inner_last, __d_first + (__len - (__inner_last - __first)), _IsVector{});
-      });
-  return __d_first + __len;
-}
-
-//------------------------------------------------------------------------
-// rotate
-//------------------------------------------------------------------------
-template <class _ForwardIterator>
-_ForwardIterator
-__brick_rotate(_ForwardIterator __first,
-               _ForwardIterator __middle,
-               _ForwardIterator __last,
-               /*is_vector=*/std::false_type) noexcept {
-#if defined(_PSTL_CPP11_STD_ROTATE_BROKEN)
-  std::rotate(__first, __middle, __last);
-  return std::next(__first, std::distance(__middle, __last));
-#else
-  return std::rotate(__first, __middle, __last);
-#endif
-}
-
-template <class _RandomAccessIterator>
-_RandomAccessIterator
-__brick_rotate(_RandomAccessIterator __first,
-               _RandomAccessIterator __middle,
-               _RandomAccessIterator __last,
-               /*is_vector=*/std::true_type) noexcept {
-  auto __n                          = __last - __first;
-  auto __m                          = __middle - __first;
-  const _RandomAccessIterator __ret = __first + (__last - __middle);
-
-  bool __is_left = (__m <= __n / 2);
-  if (!__is_left)
-    __m = __n - __m;
-
-  while (__n > 1 && __m > 0) {
-    using std::iter_swap;
-    const auto __m_2 = __m * 2;
-    if (__is_left) {
-      for (; __last - __first >= __m_2; __first += __m) {
-        __unseq_backend::__simd_assign(
-            __first, __m, __first + __m, iter_swap<_RandomAccessIterator, _RandomAccessIterator>);
-      }
-    } else {
-      for (; __last - __first >= __m_2; __last -= __m) {
-        __unseq_backend::__simd_assign(
-            __last - __m, __m, __last - __m_2, iter_swap<_RandomAccessIterator, _RandomAccessIterator>);
-      }
-    }
-    __is_left = !__is_left;
-    __m       = __n % __m;
-    __n       = __last - __first;
-  }
-
-  return __ret;
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator>
-_ForwardIterator __pattern_rotate(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) noexcept {
-  return __internal::__brick_rotate(__first, __middle, __last, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator>
-_RandomAccessIterator __pattern_rotate(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __middle,
-    _RandomAccessIterator __last) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _Tp;
-  auto __n = __last - __first;
-  auto __m = __middle - __first;
-  if (__m <= __n / 2) {
-    __par_backend::__buffer<_Tp> __buf(__n - __m);
-    return __internal::__except_handler([&__exec, __n, __m, __first, __middle, __last, &__buf]() {
-      _Tp* __result = __buf.get();
-      __par_backend::__parallel_for(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __middle,
-          __last,
-          [__middle, __result](_RandomAccessIterator __b, _RandomAccessIterator __e) {
-            __internal::__brick_uninitialized_move(__b, __e, __result + (__b - __middle), _IsVector{});
-          });
-
-      __par_backend::__parallel_for(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __first,
-          __middle,
-          [__last, __middle](_RandomAccessIterator __b, _RandomAccessIterator __e) {
-            __internal::__brick_move(__b, __e, __b + (__last - __middle), _IsVector{});
-          });
-
-      __par_backend::__parallel_for(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __result,
-          __result + (__n - __m),
-          [__first, __result](_Tp* __b, _Tp* __e) {
-            __brick_move_destroy()(__b, __e, __first + (__b - __result), _IsVector{});
-          });
-
-      return __first + (__last - __middle);
-    });
-  } else {
-    __par_backend::__buffer<_Tp> __buf(__m);
-    return __internal::__except_handler([&__exec, __n, __m, __first, __middle, __last, &__buf]() {
-      _Tp* __result = __buf.get();
-      __par_backend::__parallel_for(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __first,
-          __middle,
-          [__first, __result](_RandomAccessIterator __b, _RandomAccessIterator __e) {
-            __internal::__brick_uninitialized_move(__b, __e, __result + (__b - __first), _IsVector{});
-          });
-
-      __par_backend::__parallel_for(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __middle,
-          __last,
-          [__first, __middle](_RandomAccessIterator __b, _RandomAccessIterator __e) {
-            __internal::__brick_move(__b, __e, __first + (__b - __middle), _IsVector{});
-          });
-
-      __par_backend::__parallel_for(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __result,
-          __result + __m,
-          [__n, __m, __first, __result](_Tp* __b, _Tp* __e) {
-            __brick_move_destroy()(__b, __e, __first + ((__n - __m) + (__b - __result)), _IsVector{});
-          });
-
-      return __first + (__last - __middle);
-    });
-  }
-}
-
-//------------------------------------------------------------------------
-// rotate_copy
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _OutputIterator>
-_OutputIterator __brick_rotate_copy(
-    _ForwardIterator __first,
-    _ForwardIterator __middle,
-    _ForwardIterator __last,
-    _OutputIterator __result,
-    /*__is_vector=*/std::false_type) noexcept {
-  return std::rotate_copy(__first, __middle, __last, __result);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2>
-_RandomAccessIterator2 __brick_rotate_copy(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __middle,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __result,
-    /*__is_vector=*/std::true_type) noexcept {
-  _RandomAccessIterator2 __res = __internal::__brick_copy(__middle, __last, __result, std::true_type());
-  return __internal::__brick_copy(__first, __middle, __res, std::true_type());
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator>
-_OutputIterator __pattern_rotate_copy(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __middle,
-    _ForwardIterator __last,
-    _OutputIterator __result) noexcept {
-  return __internal::__brick_rotate_copy(__first, __middle, __last, __result, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator1, class _RandomAccessIterator2>
-_RandomAccessIterator2 __pattern_rotate_copy(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __middle,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __result) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  __par_backend::__parallel_for(
-      __backend_tag{},
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      [__first, __last, __middle, __result](_RandomAccessIterator1 __b, _RandomAccessIterator1 __e) {
-        if (__b > __middle) {
-          __internal::__brick_copy(__b, __e, __result + (__b - __middle), _IsVector{});
-        } else {
-          _RandomAccessIterator2 __new_result = __result + ((__last - __middle) + (__b - __first));
-          if (__e < __middle) {
-            __internal::__brick_copy(__b, __e, __new_result, _IsVector{});
-          } else {
-            __internal::__brick_copy(__b, __middle, __new_result, _IsVector{});
-            __internal::__brick_copy(__middle, __e, __result, _IsVector{});
-          }
-        }
-      });
-  return __result + (__last - __first);
-}
-
-//------------------------------------------------------------------------
-// is_partitioned
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _UnaryPredicate>
-bool __brick_is_partitioned(_ForwardIterator __first,
-                            _ForwardIterator __last,
-                            _UnaryPredicate __pred,
-                            /*is_vector=*/std::false_type) noexcept {
-  return std::is_partitioned(__first, __last, __pred);
-}
-
-template <class _RandomAccessIterator, class _UnaryPredicate>
-bool __brick_is_partitioned(_RandomAccessIterator __first,
-                            _RandomAccessIterator __last,
-                            _UnaryPredicate __pred,
-                            /*is_vector=*/std::true_type) noexcept {
-  typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType;
-  if (__first == __last) {
-    return true;
-  } else {
-    _RandomAccessIterator __result = __unseq_backend::__simd_first(
-        __first, _SizeType(0), __last - __first, [&__pred](_RandomAccessIterator __it, _SizeType __i) {
-          return !__pred(__it[__i]);
-        });
-    if (__result == __last) {
-      return true;
-    } else {
-      ++__result;
-      return !__unseq_backend::__simd_or(__result, __last - __result, __pred);
-    }
-  }
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-bool __pattern_is_partitioned(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) noexcept {
-  return __internal::__brick_is_partitioned(__first, __last, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-bool __pattern_is_partitioned(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _UnaryPredicate __pred) {
-  if (__first == __last) {
-    return true;
-  } else {
-    using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-    return __internal::__except_handler([&]() {
-      // State of current range:
-      // broken     - current range is not partitioned by pred
-      // all_true   - all elements in current range satisfy pred
-      // all_false  - all elements in current range don't satisfy pred
-      // true_false - elements satisfy pred are placed before elements that don't satisfy pred
-      enum _ReduceType { __not_init = -1, __broken, __all_true, __all_false, __true_false };
-      _ReduceType __init = __not_init;
-
-      // Array with states that we'll have when state from the left branch is merged with state from the right branch.
-      // State is calculated by formula: new_state = table[left_state * 4 + right_state]
-      _ReduceType __table[] = {
-          __broken,
-          __broken,
-          __broken,
-          __broken,
-          __broken,
-          __all_true,
-          __true_false,
-          __true_false,
-          __broken,
-          __broken,
-          __all_false,
-          __broken,
-          __broken,
-          __broken,
-          __true_false,
-          __broken};
-
-      __init = __par_backend::__parallel_reduce(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __first,
-          __last,
-          __init,
-          [&__pred,
-           &__table](_RandomAccessIterator __i, _RandomAccessIterator __j, _ReduceType __value) -> _ReduceType {
-            if (__value == __broken) {
-              return __broken;
-            }
-            _ReduceType __res = __not_init;
-            // if first element satisfy pred
-            if (__pred(*__i)) {
-              // find first element that don't satisfy pred
-              _RandomAccessIterator __x = __internal::__brick_find_if(__i + 1, __j, std::not_fn(__pred), _IsVector{});
-              if (__x != __j) {
-                // find first element after "x" that satisfy pred
-                _RandomAccessIterator __y = __internal::__brick_find_if(__x + 1, __j, __pred, _IsVector{});
-                // if it was found then range isn't partitioned by pred
-                if (__y != __j) {
-                  return __broken;
-                } else {
-                  __res = __true_false;
-                }
-              } else {
-                __res = __all_true;
-              }
-            } else { // if first element doesn't satisfy pred
-              // then we should find the first element that satisfy pred.
-              // If we found it then range isn't partitioned by pred
-              if (__internal::__brick_find_if(__i + 1, __j, __pred, _IsVector{}) != __j) {
-                return __broken;
-              } else {
-                __res = __all_false;
-              }
-            }
-            // if we have value from left range then we should calculate the result
-            return (__value == -1) ? __res : __table[__value * 4 + __res];
-          },
-
-          [&__table](_ReduceType __val1, _ReduceType __val2) -> _ReduceType {
-            if (__val1 == __broken || __val2 == __broken) {
-              return __broken;
-            }
-            // calculate the result for new big range
-            return __table[__val1 * 4 + __val2];
-          });
-      return __init != __broken;
-    });
-  }
-}
-
-//------------------------------------------------------------------------
-// partition
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator __brick_partition(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _UnaryPredicate __pred,
-    /*is_vector=*/std::false_type) noexcept {
-  return std::partition(__first, __last, __pred);
-}
-
-template <class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __brick_partition(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _UnaryPredicate __pred,
-    /*is_vector=*/std::true_type) noexcept {
-  // TODO: vectorize
-  return std::partition(__first, __last, __pred);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator __pattern_partition(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) noexcept {
-  return __internal::__brick_partition(__first, __last, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __pattern_partition(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _UnaryPredicate __pred) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  // partitioned range: elements before pivot satisfy pred (true part),
-  //                    elements after pivot don't satisfy pred (false part)
-  struct _PartitionRange {
-    _RandomAccessIterator __begin;
-    _RandomAccessIterator __pivot;
-    _RandomAccessIterator __end;
-  };
-
-  return __internal::__except_handler([&]() {
-    _PartitionRange __init{__last, __last, __last};
-
-    // lambda for merging two partitioned ranges to one partitioned range
-    auto __reductor = [&__exec](_PartitionRange __val1, _PartitionRange __val2) -> _PartitionRange {
-      auto __size1     = __val1.__end - __val1.__pivot;
-      auto __size2     = __val2.__pivot - __val2.__begin;
-      auto __new_begin = __val2.__begin - (__val1.__end - __val1.__begin);
-
-      // if all elements in left range satisfy pred then we can move new pivot to pivot of right range
-      if (__val1.__end == __val1.__pivot) {
-        return {__new_begin, __val2.__pivot, __val2.__end};
-      }
-      // if true part of right range greater than false part of left range
-      // then we should swap the false part of left range and last part of true part of right range
-      else if (__size2 > __size1) {
-        __par_backend::__parallel_for(
-            __backend_tag{},
-            std::forward<_ExecutionPolicy>(__exec),
-            __val1.__pivot,
-            __val1.__pivot + __size1,
-            [__val1, __val2, __size1](_RandomAccessIterator __i, _RandomAccessIterator __j) {
-              __internal::__brick_swap_ranges(
-                  __i, __j, (__val2.__pivot - __size1) + (__i - __val1.__pivot), _IsVector{});
-            });
-        return {__new_begin, __val2.__pivot - __size1, __val2.__end};
-      }
-      // else we should swap the first part of false part of left range and true part of right range
-      else {
-        __par_backend::__parallel_for(
-            __backend_tag{},
-            std::forward<_ExecutionPolicy>(__exec),
-            __val1.__pivot,
-            __val1.__pivot + __size2,
-            [__val1, __val2](_RandomAccessIterator __i, _RandomAccessIterator __j) {
-              __internal::__brick_swap_ranges(__i, __j, __val2.__begin + (__i - __val1.__pivot), _IsVector{});
-            });
-        return {__new_begin, __val1.__pivot + __size2, __val2.__end};
-      }
-    };
-
-    _PartitionRange __result = __par_backend::__parallel_reduce(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        __init,
-        [__pred,
-         __reductor](_RandomAccessIterator __i, _RandomAccessIterator __j, _PartitionRange __value) -> _PartitionRange {
-          // 1. serial partition
-          _RandomAccessIterator __pivot = __internal::__brick_partition(__i, __j, __pred, _IsVector{});
-
-          // 2. merging of two ranges (left and right respectively)
-          return __reductor(__value, {__i, __pivot, __j});
-        },
-        __reductor);
-    return __result.__pivot;
-  });
-}
-
-//------------------------------------------------------------------------
-// stable_partition
-//------------------------------------------------------------------------
-
-template <class _BidirectionalIterator, class _UnaryPredicate>
-_BidirectionalIterator __brick_stable_partition(
-    _BidirectionalIterator __first,
-    _BidirectionalIterator __last,
-    _UnaryPredicate __pred,
-    /*__is_vector=*/std::false_type) noexcept {
-  return std::stable_partition(__first, __last, __pred);
-}
-
-template <class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __brick_stable_partition(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _UnaryPredicate __pred,
-    /*__is_vector=*/std::true_type) noexcept {
-  // TODO: vectorize
-  return std::stable_partition(__first, __last, __pred);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
-_BidirectionalIterator __pattern_stable_partition(
-    _Tag,
-    _ExecutionPolicy&&,
-    _BidirectionalIterator __first,
-    _BidirectionalIterator __last,
-    _UnaryPredicate __pred) noexcept {
-  return __internal::__brick_stable_partition(__first, __last, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __pattern_stable_partition(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _UnaryPredicate __pred) noexcept {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  // partitioned range: elements before pivot satisfy pred (true part),
-  //                    elements after pivot don't satisfy pred (false part)
-  struct _PartitionRange {
-    _RandomAccessIterator __begin;
-    _RandomAccessIterator __pivot;
-    _RandomAccessIterator __end;
-  };
-
-  return __internal::__except_handler([&]() {
-    _PartitionRange __init{__last, __last, __last};
-
-    // lambda for merging two partitioned ranges to one partitioned range
-    auto __reductor = [](_PartitionRange __val1, _PartitionRange __val2) -> _PartitionRange {
-      auto __size1     = __val1.__end - __val1.__pivot;
-      auto __new_begin = __val2.__begin - (__val1.__end - __val1.__begin);
-
-      // if all elements in left range satisfy pred then we can move new pivot to pivot of right range
-      if (__val1.__end == __val1.__pivot) {
-        return {__new_begin, __val2.__pivot, __val2.__end};
-      }
-      // if true part of right range greater than false part of left range
-      // then we should swap the false part of left range and last part of true part of right range
-      else {
-        __internal::__brick_rotate(__val1.__pivot, __val2.__begin, __val2.__pivot, _IsVector{});
-        return {__new_begin, __val2.__pivot - __size1, __val2.__end};
-      }
-    };
-
-    _PartitionRange __result = __par_backend::__parallel_reduce(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        __init,
-        [&__pred,
-         __reductor](_RandomAccessIterator __i, _RandomAccessIterator __j, _PartitionRange __value) -> _PartitionRange {
-          // 1. serial stable_partition
-          _RandomAccessIterator __pivot = __internal::__brick_stable_partition(__i, __j, __pred, _IsVector{});
-
-          // 2. merging of two ranges (left and right respectively)
-          return __reductor(__value, {__i, __pivot, __j});
-        },
-        __reductor);
-    return __result.__pivot;
-  });
-}
-
-//------------------------------------------------------------------------
-// partition_copy
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _OutputIterator1, class _OutputIterator2, class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2> __brick_partition_copy(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator1 __out_true,
-    _OutputIterator2 __out_false,
-    _UnaryPredicate __pred,
-    /*is_vector=*/std::false_type) noexcept {
-  return std::partition_copy(__first, __last, __out_true, __out_false, __pred);
-}
-
-template <class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _RandomAccessIterator3,
-          class _UnaryPredicate>
-std::pair<_RandomAccessIterator2, _RandomAccessIterator3> __brick_partition_copy(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __out_true,
-    _RandomAccessIterator3 __out_false,
-    _UnaryPredicate __pred,
-    /*is_vector=*/std::true_type) noexcept {
-#if defined(_PSTL_MONOTONIC_PRESENT)
-  return __unseq_backend::__simd_partition_copy(__first, __last - __first, __out_true, __out_false, __pred);
-#else
-  return std::partition_copy(__first, __last, __out_true, __out_false, __pred);
-#endif
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _OutputIterator1,
-          class _OutputIterator2,
-          class _UnaryPredicate>
-std::pair<_OutputIterator1, _OutputIterator2> __pattern_partition_copy(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator1 __out_true,
-    _OutputIterator2 __out_false,
-    _UnaryPredicate __pred) noexcept {
-  return __internal::__brick_partition_copy(
-      __first, __last, __out_true, __out_false, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _RandomAccessIterator3,
-          class _UnaryPredicate>
-std::pair<_RandomAccessIterator2, _RandomAccessIterator3> __pattern_partition_copy(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __out_true,
-    _RandomAccessIterator3 __out_false,
-    _UnaryPredicate __pred) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType;
-  typedef std::pair<_DifferenceType, _DifferenceType> _ReturnType;
-  const _DifferenceType __n = __last - __first;
-  if (_DifferenceType(1) < __n) {
-    __par_backend::__buffer<bool> __mask_buf(__n);
-    return __internal::__except_handler([&__exec, __n, __first, __out_true, __out_false, __pred, &__mask_buf]() {
-      bool* __mask = __mask_buf.get();
-      _ReturnType __m{};
-      __par_backend::__parallel_strict_scan(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __n,
-          std::make_pair(_DifferenceType(0), _DifferenceType(0)),
-          [=](_DifferenceType __i, _DifferenceType __len) { // Reduce
-            return __internal::__brick_calc_mask_1<_DifferenceType>(
-                __first + __i, __first + (__i + __len), __mask + __i, __pred, _IsVector{});
-          },
-          [](const _ReturnType& __x, const _ReturnType& __y) -> _ReturnType {
-            return std::make_pair(__x.first + __y.first, __x.second + __y.second);
-          },                                                                       // Combine
-          [=](_DifferenceType __i, _DifferenceType __len, _ReturnType __initial) { // Scan
-            __internal::__brick_partition_by_mask(
-                __first + __i,
-                __first + (__i + __len),
-                __out_true + __initial.first,
-                __out_false + __initial.second,
-                __mask + __i,
-                _IsVector{});
-          },
-          [&__m](_ReturnType __total) { __m = __total; });
-      return std::make_pair(__out_true + __m.first, __out_false + __m.second);
-    });
-  }
-  // trivial sequence - use serial algorithm
-  return __internal::__brick_partition_copy(__first, __last, __out_true, __out_false, __pred, _IsVector{});
-}
-
-//------------------------------------------------------------------------
-// sort
-//------------------------------------------------------------------------
-
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare, class _IsMoveConstructible>
-void __pattern_sort(_Tag,
-                    _ExecutionPolicy&&,
-                    _RandomAccessIterator __first,
-                    _RandomAccessIterator __last,
-                    _Compare __comp,
-                    _IsMoveConstructible) noexcept {
-  std::sort(__first, __last, __comp);
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_sort(__parallel_tag<_IsVector> __tag,
-                    _ExecutionPolicy&& __exec,
-                    _RandomAccessIterator __first,
-                    _RandomAccessIterator __last,
-                    _Compare __comp,
-                    /*is_move_constructible=*/std::true_type) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  __internal::__except_handler([&]() {
-    __par_backend::__parallel_stable_sort(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        __comp,
-        [](_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
-          std::sort(__first, __last, __comp);
-        });
-  });
-}
-
-//------------------------------------------------------------------------
-// stable_sort
-//------------------------------------------------------------------------
-
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_stable_sort(
-    _Tag, _ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) noexcept {
-  std::stable_sort(__first, __last, __comp);
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_stable_sort(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Compare __comp) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  __internal::__except_handler([&]() {
-    __par_backend::__parallel_stable_sort(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        __comp,
-        [](_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
-          std::stable_sort(__first, __last, __comp);
-        });
-  });
-}
-
-//------------------------------------------------------------------------
-// partial_sort
-//------------------------------------------------------------------------
-
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_partial_sort(
-    _Tag,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __middle,
-    _RandomAccessIterator __last,
-    _Compare __comp) noexcept {
-  std::partial_sort(__first, __middle, __last, __comp);
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_partial_sort(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __middle,
-    _RandomAccessIterator __last,
-    _Compare __comp) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  const auto __n = __middle - __first;
-  if (__n == 0)
-    return;
-
-  __internal::__except_handler([&]() {
-    __par_backend::__parallel_stable_sort(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        __comp,
-        [__n](_RandomAccessIterator __begin, _RandomAccessIterator __end, _Compare __comp) {
-          if (__n < __end - __begin)
-            std::partial_sort(__begin, __begin + __n, __end, __comp);
-          else
-            std::sort(__begin, __end, __comp);
-        },
-        __n);
-  });
-}
-
-//------------------------------------------------------------------------
-// partial_sort_copy
-//------------------------------------------------------------------------
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare>
-_RandomAccessIterator __pattern_partial_sort_copy(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _RandomAccessIterator __d_first,
-    _RandomAccessIterator __d_last,
-    _Compare __comp) noexcept {
-  return std::partial_sort_copy(__first, __last, __d_first, __d_last, __comp);
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Compare>
-_RandomAccessIterator2 __pattern_partial_sort_copy(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __d_first,
-    _RandomAccessIterator2 __d_last,
-    _Compare __comp) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  if (__last == __first || __d_last == __d_first) {
-    return __d_first;
-  }
-  auto __n1 = __last - __first;
-  auto __n2 = __d_last - __d_first;
-  return __internal::__except_handler([&]() {
-    if (__n2 >= __n1) {
-      __par_backend::__parallel_stable_sort(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __d_first,
-          __d_first + __n1,
-          __comp,
-          [__first, __d_first](_RandomAccessIterator2 __i, _RandomAccessIterator2 __j, _Compare __comp) {
-            _RandomAccessIterator1 __i1 = __first + (__i - __d_first);
-            _RandomAccessIterator1 __j1 = __first + (__j - __d_first);
-
-        // 1. Copy elements from input to output
-#if !defined(_PSTL_ICC_18_OMP_SIMD_BROKEN)
-            __internal::__brick_copy(__i1, __j1, __i, _IsVector{});
-#else
-            std::copy(__i1, __j1, __i);
-#endif
-            // 2. Sort elements in output sequence
-            std::sort(__i, __j, __comp);
-          },
-          __n1);
-      return __d_first + __n1;
-    } else {
-      typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type _T1;
-      typedef typename std::iterator_traits<_RandomAccessIterator2>::value_type _T2;
-      __par_backend::__buffer<_T1> __buf(__n1);
-      _T1* __r = __buf.get();
-
-      __par_backend::__parallel_stable_sort(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __r,
-          __r + __n1,
-          __comp,
-          [__n2, __first, __r](_T1* __i, _T1* __j, _Compare __comp) {
-            _RandomAccessIterator1 __it = __first + (__i - __r);
-
-            // 1. Copy elements from input to raw memory
-            for (_T1* __k = __i; __k != __j; ++__k, ++__it) {
-              ::new (__k) _T2(*__it);
-            }
-
-            // 2. Sort elements in temporary __buffer
-            if (__n2 < __j - __i)
-              std::partial_sort(__i, __i + __n2, __j, __comp);
-            else
-              std::sort(__i, __j, __comp);
-          },
-          __n2);
-
-      // 3. Move elements from temporary __buffer to output
-      __par_backend::__parallel_for(
-          __backend_tag{},
-          std::forward<_ExecutionPolicy>(__exec),
-          __r,
-          __r + __n2,
-          [__r, __d_first](_T1* __i, _T1* __j) {
-            __brick_move_destroy()(__i, __j, __d_first + (__i - __r), _IsVector{});
-          });
-      __par_backend::__parallel_for(
-          __backend_tag{}, std::forward<_ExecutionPolicy>(__exec), __r + __n2, __r + __n1, [](_T1* __i, _T1* __j) {
-            __brick_destroy(__i, __j, _IsVector{});
-          });
-
-      return __d_first + __n2;
-    }
-  });
-}
-
-//------------------------------------------------------------------------
-// adjacent_find
-//------------------------------------------------------------------------
-template <class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator __brick_adjacent_find(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _BinaryPredicate __pred,
-    /* IsVector = */ std::true_type,
-    bool __or_semantic) noexcept {
-  return __unseq_backend::__simd_adjacent_find(__first, __last, __pred, __or_semantic);
-}
-
-template <class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator __brick_adjacent_find(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _BinaryPredicate __pred,
-    /* IsVector = */ std::false_type,
-    bool) noexcept {
-  return std::adjacent_find(__first, __last, __pred);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-_ForwardIterator __pattern_adjacent_find(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _BinaryPredicate __pred,
-    bool __or_semantic) noexcept {
-  return __internal::__brick_adjacent_find(__first, __last, __pred, typename _Tag::__is_vector{}, __or_semantic);
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _BinaryPredicate>
-_RandomAccessIterator __pattern_adjacent_find(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _BinaryPredicate __pred,
-    bool __or_semantic) {
-  if (__last - __first < 2)
-    return __last;
-
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    return __par_backend::__parallel_reduce(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        __last,
-        [__last, __pred, __or_semantic](
-            _RandomAccessIterator __begin, _RandomAccessIterator __end, _RandomAccessIterator __value)
-            -> _RandomAccessIterator {
-          // TODO: investigate performance benefits from the use of shared variable for the result,
-          // checking (compare_and_swap idiom) its __value at __first.
-          if (__or_semantic && __value < __last) { // found
-            __par_backend::__cancel_execution();
-            return __value;
-          }
-
-          if (__value > __begin) {
-            // modify __end to check the predicate on the boundary __values;
-            // TODO: to use a custom range with boundaries overlapping
-            // TODO: investigate what if we remove "if" below and run algorithm on range [__first, __last-1)
-            // then check the pair [__last-1, __last)
-            if (__end != __last)
-              ++__end;
-
-            // correct the global result iterator if the "brick" returns a local "__last"
-            const _RandomAccessIterator __res =
-                __internal::__brick_adjacent_find(__begin, __end, __pred, _IsVector{}, __or_semantic);
-            if (__res < __end)
-              __value = __res;
-          }
-          return __value;
-        },
-        [](_RandomAccessIterator __x, _RandomAccessIterator __y) -> _RandomAccessIterator {
-          return __x < __y ? __x : __y;
-        } // reduce a __value
-    );
-  });
-}
-
-//------------------------------------------------------------------------
-// nth_element
-//------------------------------------------------------------------------
-
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_nth_element(
-    _Tag,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __nth,
-    _RandomAccessIterator __last,
-    _Compare __comp) noexcept {
-  std::nth_element(__first, __nth, __last, __comp);
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_nth_element(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __nth,
-    _RandomAccessIterator __last,
-    _Compare __comp) noexcept {
-  if (__first == __last || __nth == __last) {
-    return;
-  }
-
-  using std::iter_swap;
-  typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _Tp;
-  _RandomAccessIterator __x;
-  do {
-    __x = __internal::__pattern_partition(
-        __tag, std::forward<_ExecutionPolicy>(__exec), __first + 1, __last, [&__comp, __first](const _Tp& __x) {
-          return __comp(__x, *__first);
-        });
-    --__x;
-    if (__x != __first) {
-      iter_swap(__first, __x);
-    }
-    // if x > nth then our new range for partition is [first, x)
-    if (__x - __nth > 0) {
-      __last = __x;
-    }
-    // if x < nth then our new range for partition is [x, last)
-    else if (__x - __nth < 0) {
-      // if *x == *nth then we can start new partition with x+1
-      if (!__comp(*__nth, *__x) && !__comp(*__x, *__nth)) {
-        ++__x;
-      } else {
-        iter_swap(__nth, __x);
-      }
-      __first = __x;
-    }
-  } while (__x != __nth);
-}
-
-//------------------------------------------------------------------------
-// generate, generate_n
-//------------------------------------------------------------------------
-template <class _RandomAccessIterator, class _Generator>
-void __brick_generate(_RandomAccessIterator __first,
-                      _RandomAccessIterator __last,
-                      _Generator __g,
-                      /* is_vector = */ std::true_type) noexcept {
-  __unseq_backend::__simd_generate_n(__first, __last - __first, __g);
-}
-
-template <class _ForwardIterator, class _Generator>
-void __brick_generate(_ForwardIterator __first,
-                      _ForwardIterator __last,
-                      _Generator __g,
-                      /* is_vector = */ std::false_type) noexcept {
-  std::generate(__first, __last, __g);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _Generator>
-void __pattern_generate(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Generator __g) noexcept {
-  __internal::__brick_generate(__first, __last, __g, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Generator>
-_RandomAccessIterator __pattern_generate(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Generator __g) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    __par_backend::__parallel_for(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        [__g](_RandomAccessIterator __begin, _RandomAccessIterator __end) {
-          __internal::__brick_generate(__begin, __end, __g, _IsVector{});
-        });
-    return __last;
-  });
-}
-
-template <class _RandomAccessIterator, class Size, class _Generator>
-_RandomAccessIterator __brick_generate_n(
-    _RandomAccessIterator __first,
-    Size __count,
-    _Generator __g,
-    /* is_vector = */ std::true_type) noexcept {
-  return __unseq_backend::__simd_generate_n(__first, __count, __g);
-}
-
-template <class OutputIterator, class Size, class _Generator>
-OutputIterator
-__brick_generate_n(OutputIterator __first, Size __count, _Generator __g, /* is_vector = */ std::false_type) noexcept {
-  return std::generate_n(__first, __count, __g);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _OutputIterator, class _Size, class _Generator>
-_OutputIterator
-__pattern_generate_n(_Tag, _ExecutionPolicy&&, _OutputIterator __first, _Size __count, _Generator __g) noexcept {
-  return __internal::__brick_generate_n(__first, __count, __g, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Size, class _Generator>
-_RandomAccessIterator __pattern_generate_n(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _Size __count,
-    _Generator __g) {
-  static_assert(__are_random_access_iterators<_RandomAccessIterator>::value,
-                "Pattern-brick error. Should be a random access iterator.");
-  return __internal::__pattern_generate(__tag, std::forward<_ExecutionPolicy>(__exec), __first, __first + __count, __g);
-}
-
-//------------------------------------------------------------------------
-// remove
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator __brick_remove_if(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _UnaryPredicate __pred,
-    /* __is_vector = */ std::false_type) noexcept {
-  return std::remove_if(__first, __last, __pred);
-}
-
-template <class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __brick_remove_if(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _UnaryPredicate __pred,
-    /* __is_vector = */ std::true_type) noexcept {
-#if defined(_PSTL_MONOTONIC_PRESENT)
-  return __unseq_backend::__simd_remove_if(__first, __last - __first, __pred);
-#else
-  return std::remove_if(__first, __last, __pred);
-#endif
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-_ForwardIterator __pattern_remove_if(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) noexcept {
-  return __internal::__brick_remove_if(__first, __last, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryPredicate>
-_RandomAccessIterator __pattern_remove_if(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _UnaryPredicate __pred) noexcept {
-  typedef typename std::iterator_traits<_RandomAccessIterator>::reference _ReferenceType;
-
-  if (__first == __last || __first + 1 == __last) {
-    // Trivial sequence - use serial algorithm
-    return __internal::__brick_remove_if(__first, __last, __pred, _IsVector{});
-  }
-
-  return __internal::__remove_elements(
-      __tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      [&__pred](bool* __b, bool* __e, _RandomAccessIterator __it) {
-        __internal::__brick_walk2(
-            __b, __e, __it, [&__pred](bool& __x, _ReferenceType __y) { __x = !__pred(__y); }, _IsVector{});
-      });
-}
-
-//------------------------------------------------------------------------
-// inplace_merge
-//------------------------------------------------------------------------
-template <class _BidirectionalIterator, class _Compare>
-void __brick_inplace_merge(
-    _BidirectionalIterator __first,
-    _BidirectionalIterator __middle,
-    _BidirectionalIterator __last,
-    _Compare __comp,
-    /* __is_vector = */ std::false_type) noexcept {
-  std::inplace_merge(__first, __middle, __last, __comp);
-}
-
-template <class _RandomAccessIterator, class _Compare>
-void __brick_inplace_merge(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __middle,
-    _RandomAccessIterator __last,
-    _Compare __comp,
-    /* __is_vector = */ std::true_type) noexcept {
-  // TODO: vectorize
-  std::inplace_merge(__first, __middle, __last, __comp);
-}
-
-template <class _Tag, class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
-void __pattern_inplace_merge(
-    _Tag,
-    _ExecutionPolicy&&,
-    _BidirectionalIterator __first,
-    _BidirectionalIterator __middle,
-    _BidirectionalIterator __last,
-    _Compare __comp) noexcept {
-  __internal::__brick_inplace_merge(__first, __middle, __last, __comp, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-void __pattern_inplace_merge(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __middle,
-    _RandomAccessIterator __last,
-    _Compare __comp) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  if (__first == __last || __first == __middle || __middle == __last) {
-    return;
-  }
-  typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _Tp;
-  auto __n = __last - __first;
-  __par_backend::__buffer<_Tp> __buf(__n);
-  _Tp* __r = __buf.get();
-  __internal::__except_handler([&]() {
-    auto __move_values = [](_RandomAccessIterator __x, _Tp* __z) {
-      __internal::__invoke_if_else(
-          std::is_trivial<_Tp>(),
-          [&]() { *__z = std::move(*__x); },
-          [&]() { ::new (std::addressof(*__z)) _Tp(std::move(*__x)); });
-    };
-
-    auto __move_sequences = [](_RandomAccessIterator __first1, _RandomAccessIterator __last1, _Tp* __first2) {
-      return __internal::__brick_uninitialized_move(__first1, __last1, __first2, _IsVector());
-    };
-
-    __par_backend::__parallel_merge(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __middle,
-        __middle,
-        __last,
-        __r,
-        __comp,
-        [__n, __move_values, __move_sequences](
-            _RandomAccessIterator __f1,
-            _RandomAccessIterator __l1,
-            _RandomAccessIterator __f2,
-            _RandomAccessIterator __l2,
-            _Tp* __f3,
-            _Compare __comp) {
-          (__utils::__serial_move_merge(__n))(
-              __f1, __l1, __f2, __l2, __f3, __comp, __move_values, __move_values, __move_sequences, __move_sequences);
-          return __f3 + (__l1 - __f1) + (__l2 - __f2);
-        });
-    __par_backend::__parallel_for(
-        __backend_tag{}, std::forward<_ExecutionPolicy>(__exec), __r, __r + __n, [__r, __first](_Tp* __i, _Tp* __j) {
-          __brick_move_destroy()(__i, __j, __first + (__i - __r), _IsVector{});
-        });
-  });
-}
-
-//------------------------------------------------------------------------
-// includes
-//------------------------------------------------------------------------
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-bool __pattern_includes(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _Compare __comp) noexcept {
-  return std::includes(__first1, __last1, __first2, __last2, __comp);
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Compare>
-bool __pattern_includes(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _Compare __comp) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  if (__first2 >= __last2)
-    return true;
-
-  if (__first1 >= __last1 || __comp(*__first2, *__first1) || __comp(*(__last1 - 1), *(__last2 - 1)))
-    return false;
-
-  __first1 = std::lower_bound(__first1, __last1, *__first2, __comp);
-  if (__first1 == __last1)
-    return false;
-
-  if (__last2 - __first2 == 1)
-    return !__comp(*__first1, *__first2) && !__comp(*__first2, *__first1);
-
-  return __internal::__except_handler([&]() {
-    return !__internal::__parallel_or(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first2,
-        __last2,
-        [__first1, __last1, __first2, __last2, &__comp](_RandomAccessIterator2 __i, _RandomAccessIterator2 __j) {
-          _LIBCPP_ASSERT(__j > __i, "");
-          //_LIBCPP_ASSERT(__j - __i > 1, "");
-
-          // 1. moving boundaries to "consume" subsequence of equal elements
-          auto __is_equal = [&__comp](_RandomAccessIterator2 __a, _RandomAccessIterator2 __b) -> bool {
-            return !__comp(*__a, *__b) && !__comp(*__b, *__a);
-          };
-
-          // 1.1 left bound, case "aaa[aaaxyz...]" - searching "x"
-          if (__i > __first2 && __is_equal(__i, __i - 1)) {
-            // whole subrange continues to content equal elements - return "no op"
-            if (__is_equal(__i, __j - 1))
-              return false;
-
-            __i = std::upper_bound(__i, __last2, *__i, __comp);
-          }
-
-          // 1.2 right bound, case "[...aaa]aaaxyz" - searching "x"
-          if (__j < __last2 && __is_equal(__j - 1, __j))
-            __j = std::upper_bound(__j, __last2, *__j, __comp);
-
-          // 2. testing is __a subsequence of the second range included into the first range
-          auto __b = std::lower_bound(__first1, __last1, *__i, __comp);
-
-          _LIBCPP_ASSERT(!__comp(*(__last1 - 1), *__b), "");
-          _LIBCPP_ASSERT(!__comp(*(__j - 1), *__i), "");
-          return !std::includes(__b, __last1, __i, __j, __comp);
-        });
-  });
-}
-
-constexpr auto __set_algo_cut_off = 1000;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare,
-          class _SizeFunction,
-          class _SetOP>
-_OutputIterator __parallel_set_op(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp,
-    _SizeFunction __size_func,
-    _SetOP __set_op) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
-  typedef typename std::iterator_traits<_OutputIterator>::value_type _Tp;
-
-  struct _SetRange {
-    _DifferenceType __pos, __len, __buf_pos;
-    bool empty() const { return __len == 0; }
-  };
-
-  const _DifferenceType __n1 = __last1 - __first1;
-  const _DifferenceType __n2 = __last2 - __first2;
-
-  __par_backend::__buffer<_Tp> __buf(__size_func(__n1, __n2));
-
-  return __internal::__except_handler(
-      [&__exec, __n1, __first1, __last1, __first2, __last2, __result, __comp, __size_func, __set_op, &__buf]() {
-        auto __buffer = __buf.get();
-        _DifferenceType __m{};
-        auto __scan = [=](_DifferenceType, _DifferenceType, const _SetRange& __s) { // Scan
-          if (!__s.empty())
-            __brick_move_destroy()(
-                __buffer + __s.__buf_pos, __buffer + (__s.__buf_pos + __s.__len), __result + __s.__pos, _IsVector{});
-        };
-        __par_backend::__parallel_strict_scan(
-            __backend_tag{},
-            std::forward<_ExecutionPolicy>(__exec),
-            __n1,
-            _SetRange{0, 0, 0},                               //-1, 0},
-            [=](_DifferenceType __i, _DifferenceType __len) { // Reduce
-              //[__b; __e) - a subrange of the first sequence, to reduce
-              _ForwardIterator1 __b = __first1 + __i, __e = __first1 + (__i + __len);
-
-              // try searching for the first element which not equal to *__b
-              if (__b != __first1)
-                __b = std::upper_bound(__b, __last1, *__b, __comp);
-
-              // try searching for the first element which not equal to *__e
-              if (__e != __last1)
-                __e = std::upper_bound(__e, __last1, *__e, __comp);
-
-              // check is [__b; __e) empty
-              if (__e - __b < 1) {
-                _ForwardIterator2 __bb = __last2;
-                if (__b != __last1)
-                  __bb = std::lower_bound(__first2, __last2, *__b, __comp);
-
-                const _DifferenceType __buf_pos = __size_func((__b - __first1), (__bb - __first2));
-                return _SetRange{0, 0, __buf_pos};
-              }
-
-              // try searching for "corresponding" subrange [__bb; __ee) in the second sequence
-              _ForwardIterator2 __bb = __first2;
-              if (__b != __first1)
-                __bb = std::lower_bound(__first2, __last2, *__b, __comp);
-
-              _ForwardIterator2 __ee = __last2;
-              if (__e != __last1)
-                __ee = std::lower_bound(__bb, __last2, *__e, __comp);
-
-              const _DifferenceType __buf_pos = __size_func((__b - __first1), (__bb - __first2));
-              auto __buffer_b                 = __buffer + __buf_pos;
-              auto __res                      = __set_op(__b, __e, __bb, __ee, __buffer_b, __comp);
-
-              return _SetRange{0, __res - __buffer_b, __buf_pos};
-            },
-            [](const _SetRange& __a, const _SetRange& __b) { // Combine
-              if (__b.__buf_pos > __a.__buf_pos || ((__b.__buf_pos == __a.__buf_pos) && !__b.empty()))
-                return _SetRange{__a.__pos + __a.__len + __b.__pos, __b.__len, __b.__buf_pos};
-              return _SetRange{__b.__pos + __b.__len + __a.__pos, __a.__len, __a.__buf_pos};
-            },
-            __scan,                                     // Scan
-            [&__m, &__scan](const _SetRange& __total) { // Apex
-              // final scan
-              __scan(0, 0, __total);
-              __m = __total.__pos + __total.__len;
-            });
-        return __result + __m;
-      });
-}
-
-// a shared parallel pattern for '__pattern_set_union' and '__pattern_set_symmetric_difference'
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare,
-          class _SetUnionOp>
-_OutputIterator __parallel_set_union_op(
-    _Tag __tag,
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp,
-    _SetUnionOp __set_union_op) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferenceType;
-
-  const auto __n1 = __last1 - __first1;
-  const auto __n2 = __last2 - __first2;
-
-  auto copy_range1 = [](_ForwardIterator1 __begin, _ForwardIterator1 __end, _OutputIterator __res) {
-    return __internal::__brick_copy(__begin, __end, __res, typename _Tag::__is_vector{});
-  };
-  auto copy_range2 = [](_ForwardIterator2 __begin, _ForwardIterator2 __end, _OutputIterator __res) {
-    return __internal::__brick_copy(__begin, __end, __res, typename _Tag::__is_vector{});
-  };
-
-  // {1} {}: parallel copying just first sequence
-  if (__n2 == 0)
-    return __internal::__pattern_walk2_brick(
-        __tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, copy_range1);
-
-  // {} {2}: parallel copying justmake  second sequence
-  if (__n1 == 0)
-    return __internal::__pattern_walk2_brick(
-        __tag, std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result, copy_range2);
-
-  // testing  whether the sequences are intersected
-  _ForwardIterator1 __left_bound_seq_1 = std::lower_bound(__first1, __last1, *__first2, __comp);
-
-  if (__left_bound_seq_1 == __last1) {
-    //{1} < {2}: seq2 is wholly greater than seq1, so, do parallel copying seq1 and seq2
-    __par_backend::__parallel_invoke(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        [=] {
-          __internal::__pattern_walk2_brick(
-              __tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result, copy_range1);
-        },
-        [=] {
-          __internal::__pattern_walk2_brick(
-              __tag, std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result + __n1, copy_range2);
-        });
-    return __result + __n1 + __n2;
-  }
-
-  // testing  whether the sequences are intersected
-  _ForwardIterator2 __left_bound_seq_2 = std::lower_bound(__first2, __last2, *__first1, __comp);
-
-  if (__left_bound_seq_2 == __last2) {
-    //{2} < {1}: seq2 is wholly greater than seq1, so, do parallel copying seq1 and seq2
-    __par_backend::__parallel_invoke(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        [=] {
-          __internal::__pattern_walk2_brick(
-              __tag, std::forward<_ExecutionPolicy>(__exec), __first2, __last2, __result, copy_range2);
-        },
-        [=] {
-          __internal::__pattern_walk2_brick(
-              __tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __result + __n2, copy_range1);
-        });
-    return __result + __n1 + __n2;
-  }
-
-  const auto __m1 = __left_bound_seq_1 - __first1;
-  if (__m1 > __set_algo_cut_off) {
-    auto __res_or = __result;
-    __result += __m1; // we know proper offset due to [first1; left_bound_seq_1) < [first2; last2)
-    __par_backend::__parallel_invoke(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        // do parallel copying of [first1; left_bound_seq_1)
-        [=] {
-          __internal::__pattern_walk2_brick(
-              __tag, std::forward<_ExecutionPolicy>(__exec), __first1, __left_bound_seq_1, __res_or, copy_range1);
-        },
-        [=, &__result] {
-          __result = __internal::__parallel_set_op(
-              __tag,
-              std::forward<_ExecutionPolicy>(__exec),
-              __left_bound_seq_1,
-              __last1,
-              __first2,
-              __last2,
-              __result,
-              __comp,
-              [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; },
-              __set_union_op);
-        });
-    return __result;
-  }
-
-  const auto __m2 = __left_bound_seq_2 - __first2;
-  _LIBCPP_ASSERT(__m1 == 0 || __m2 == 0, "");
-  if (__m2 > __set_algo_cut_off) {
-    auto __res_or = __result;
-    __result += __m2; // we know proper offset due to [first2; left_bound_seq_2) < [first1; last1)
-    __par_backend::__parallel_invoke(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        // do parallel copying of [first2; left_bound_seq_2)
-        [=] {
-          __internal::__pattern_walk2_brick(
-              __tag, std::forward<_ExecutionPolicy>(__exec), __first2, __left_bound_seq_2, __res_or, copy_range2);
-        },
-        [=, &__result] {
-          __result = __internal::__parallel_set_op(
-              __tag,
-              std::forward<_ExecutionPolicy>(__exec),
-              __first1,
-              __last1,
-              __left_bound_seq_2,
-              __last2,
-              __result,
-              __comp,
-              [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; },
-              __set_union_op);
-        });
-    return __result;
-  }
-
-  return __internal::__parallel_set_op(
-      __tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first1,
-      __last1,
-      __first2,
-      __last2,
-      __result,
-      __comp,
-      [](_DifferenceType __n, _DifferenceType __m) { return __n + __m; },
-      __set_union_op);
-}
-
-//------------------------------------------------------------------------
-// set_union
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_union(
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp,
-    /*__is_vector=*/std::false_type) noexcept {
-  return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <typename _IsVector>
-struct __BrickCopyConstruct {
-  template <typename _ForwardIterator, typename _OutputIterator>
-  _OutputIterator operator()(_ForwardIterator __first, _ForwardIterator __last, _OutputIterator __result) {
-    return __brick_uninitialized_copy(__first, __last, __result, _IsVector());
-  }
-};
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_union(
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp,
-    /*__is_vector=*/std::true_type) noexcept {
-  // TODO: vectorize
-  return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_union(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp) noexcept {
-  return __internal::__brick_set_union(
-      __first1, __last1, __first2, __last2, __result, __comp, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_union(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp) {
-  const auto __n1 = __last1 - __first1;
-  const auto __n2 = __last2 - __first2;
-
-  // use serial algorithm
-  if (__n1 + __n2 <= __set_algo_cut_off)
-    return std::set_union(__first1, __last1, __first2, __last2, __result, __comp);
-
-  typedef typename std::iterator_traits<_OutputIterator>::value_type _Tp;
-  return __parallel_set_union_op(
-      __tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first1,
-      __last1,
-      __first2,
-      __last2,
-      __result,
-      __comp,
-      [](_RandomAccessIterator1 __first1,
-         _RandomAccessIterator1 __last1,
-         _RandomAccessIterator2 __first2,
-         _RandomAccessIterator2 __last2,
-         _Tp* __result,
-         _Compare __comp) {
-        return __pstl::__utils::__set_union_construct(
-            __first1, __last1, __first2, __last2, __result, __comp, __BrickCopyConstruct<_IsVector>());
-      });
-}
-
-//------------------------------------------------------------------------
-// set_intersection
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_intersection(
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp,
-    /*__is_vector=*/std::false_type) noexcept {
-  return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Compare>
-_RandomAccessIterator3 __brick_set_intersection(
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _RandomAccessIterator3 __result,
-    _Compare __comp,
-    /*__is_vector=*/std::true_type) noexcept {
-  // TODO: vectorize
-  return std::set_intersection(__first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_intersection(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp) noexcept {
-  return __internal::__brick_set_intersection(
-      __first1, __last1, __first2, __last2, __result, __comp, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _RandomAccessIterator3,
-          class _Compare>
-_RandomAccessIterator3 __pattern_set_intersection(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _RandomAccessIterator3 __result,
-    _Compare __comp) {
-  typedef typename std::iterator_traits<_RandomAccessIterator3>::value_type _Tp;
-  typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType;
-
-  const auto __n1 = __last1 - __first1;
-  const auto __n2 = __last2 - __first2;
-
-  // intersection is empty
-  if (__n1 == 0 || __n2 == 0)
-    return __result;
-
-  // testing  whether the sequences are intersected
-  _RandomAccessIterator1 __left_bound_seq_1 = std::lower_bound(__first1, __last1, *__first2, __comp);
-  //{1} < {2}: seq 2 is wholly greater than seq 1, so, the intersection is empty
-  if (__left_bound_seq_1 == __last1)
-    return __result;
-
-  // testing  whether the sequences are intersected
-  _RandomAccessIterator2 __left_bound_seq_2 = std::lower_bound(__first2, __last2, *__first1, __comp);
-  //{2} < {1}: seq 1 is wholly greater than seq 2, so, the intersection is empty
-  if (__left_bound_seq_2 == __last2)
-    return __result;
-
-  const auto __m1 = __last1 - __left_bound_seq_1 + __n2;
-  if (__m1 > __set_algo_cut_off) {
-    // we know proper offset due to [first1; left_bound_seq_1) < [first2; last2)
-    return __internal::__parallel_set_op(
-        __tag,
-        std::forward<_ExecutionPolicy>(__exec),
-        __left_bound_seq_1,
-        __last1,
-        __first2,
-        __last2,
-        __result,
-        __comp,
-        [](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); },
-        [](_RandomAccessIterator1 __first1,
-           _RandomAccessIterator1 __last1,
-           _RandomAccessIterator2 __first2,
-           _RandomAccessIterator2 __last2,
-           _Tp* __result,
-           _Compare __comp) {
-          return __pstl::__utils::__set_intersection_construct(__first1, __last1, __first2, __last2, __result, __comp);
-        });
-  }
-
-  const auto __m2 = __last2 - __left_bound_seq_2 + __n1;
-  if (__m2 > __set_algo_cut_off) {
-    // we know proper offset due to [first2; left_bound_seq_2) < [first1; last1)
-    __result = __internal::__parallel_set_op(
-        __tag,
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        __left_bound_seq_2,
-        __last2,
-        __result,
-        __comp,
-        [](_DifferenceType __n, _DifferenceType __m) { return std::min(__n, __m); },
-        [](_RandomAccessIterator1 __first1,
-           _RandomAccessIterator1 __last1,
-           _RandomAccessIterator2 __first2,
-           _RandomAccessIterator2 __last2,
-           _Tp* __result,
-           _Compare __comp) {
-          return __pstl::__utils::__set_intersection_construct(__first2, __last2, __first1, __last1, __result, __comp);
-        });
-    return __result;
-  }
-
-  // [left_bound_seq_1; last1) and [left_bound_seq_2; last2) - use serial algorithm
-  return std::set_intersection(__left_bound_seq_1, __last1, __left_bound_seq_2, __last2, __result, __comp);
-}
-
-//------------------------------------------------------------------------
-// set_difference
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_difference(
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp,
-    /*__is_vector=*/std::false_type) noexcept {
-  return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Compare>
-_RandomAccessIterator3 __brick_set_difference(
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _RandomAccessIterator3 __result,
-    _Compare __comp,
-    /*__is_vector=*/std::true_type) noexcept {
-  // TODO: vectorize
-  return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_difference(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp) noexcept {
-  return __internal::__brick_set_difference(
-      __first1, __last1, __first2, __last2, __result, __comp, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _RandomAccessIterator3,
-          class _Compare>
-_RandomAccessIterator3 __pattern_set_difference(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _RandomAccessIterator3 __result,
-    _Compare __comp) {
-  typedef typename std::iterator_traits<_RandomAccessIterator3>::value_type _Tp;
-  typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType;
-
-  const auto __n1 = __last1 - __first1;
-  const auto __n2 = __last2 - __first2;
-
-  // {} \ {2}: the difference is empty
-  if (__n1 == 0)
-    return __result;
-
-  // {1} \ {}: parallel copying just first sequence
-  if (__n2 == 0)
-    return __internal::__pattern_walk2_brick(
-        __tag,
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        __result,
-        [](_RandomAccessIterator1 __begin, _RandomAccessIterator1 __end, _RandomAccessIterator3 __res) {
-          return __internal::__brick_copy(__begin, __end, __res, _IsVector{});
-        });
-
-  // testing  whether the sequences are intersected
-  _RandomAccessIterator1 __left_bound_seq_1 = std::lower_bound(__first1, __last1, *__first2, __comp);
-  //{1} < {2}: seq 2 is wholly greater than seq 1, so, parallel copying just first sequence
-  if (__left_bound_seq_1 == __last1)
-    return __internal::__pattern_walk2_brick(
-        __tag,
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        __result,
-        [](_RandomAccessIterator1 __begin, _RandomAccessIterator1 __end, _RandomAccessIterator3 __res) {
-          return __internal::__brick_copy(__begin, __end, __res, _IsVector{});
-        });
-
-  // testing  whether the sequences are intersected
-  _RandomAccessIterator2 __left_bound_seq_2 = std::lower_bound(__first2, __last2, *__first1, __comp);
-  //{2} < {1}: seq 1 is wholly greater than seq 2, so, parallel copying just first sequence
-  if (__left_bound_seq_2 == __last2)
-    return __internal::__pattern_walk2_brick(
-        __tag,
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        __result,
-        [](_RandomAccessIterator1 __begin, _RandomAccessIterator1 __end, _RandomAccessIterator3 __res) {
-          return __internal::__brick_copy(__begin, __end, __res, _IsVector{});
-        });
-
-  if (__n1 + __n2 > __set_algo_cut_off)
-    return __parallel_set_op(
-        __tag,
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        __first2,
-        __last2,
-        __result,
-        __comp,
-        [](_DifferenceType __n, _DifferenceType) { return __n; },
-        [](_RandomAccessIterator1 __first1,
-           _RandomAccessIterator1 __last1,
-           _RandomAccessIterator2 __first2,
-           _RandomAccessIterator2 __last2,
-           _Tp* __result,
-           _Compare __comp) {
-          return __pstl::__utils::__set_difference_construct(
-              __first1, __last1, __first2, __last2, __result, __comp, __BrickCopyConstruct<_IsVector>());
-        });
-
-  // use serial algorithm
-  return std::set_difference(__first1, __last1, __first2, __last2, __result, __comp);
-}
-
-//------------------------------------------------------------------------
-// set_symmetric_difference
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _OutputIterator, class _Compare>
-_OutputIterator __brick_set_symmetric_difference(
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp,
-    /*__is_vector=*/std::false_type) noexcept {
-  return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Compare>
-_RandomAccessIterator3 __brick_set_symmetric_difference(
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _RandomAccessIterator3 __result,
-    _Compare __comp,
-    /*__is_vector=*/std::true_type) noexcept {
-  // TODO: vectorize
-  return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _OutputIterator,
-          class _Compare>
-_OutputIterator __pattern_set_symmetric_difference(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _OutputIterator __result,
-    _Compare __comp) noexcept {
-  return __internal::__brick_set_symmetric_difference(
-      __first1, __last1, __first2, __last2, __result, __comp, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _RandomAccessIterator3,
-          class _Compare>
-_RandomAccessIterator3 __pattern_set_symmetric_difference(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _RandomAccessIterator3 __result,
-    _Compare __comp) {
-  const auto __n1 = __last1 - __first1;
-  const auto __n2 = __last2 - __first2;
-
-  // use serial algorithm
-  if (__n1 + __n2 <= __set_algo_cut_off)
-    return std::set_symmetric_difference(__first1, __last1, __first2, __last2, __result, __comp);
-
-  typedef typename std::iterator_traits<_RandomAccessIterator3>::value_type _Tp;
-  return __internal::__parallel_set_union_op(
-      __tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first1,
-      __last1,
-      __first2,
-      __last2,
-      __result,
-      __comp,
-      [](_RandomAccessIterator1 __first1,
-         _RandomAccessIterator1 __last1,
-         _RandomAccessIterator2 __first2,
-         _RandomAccessIterator2 __last2,
-         _Tp* __result,
-         _Compare __comp) {
-        return __pstl::__utils::__set_symmetric_difference_construct(
-            __first1, __last1, __first2, __last2, __result, __comp, __BrickCopyConstruct<_IsVector>());
-      });
-}
-
-//------------------------------------------------------------------------
-// is_heap_until
-//------------------------------------------------------------------------
-
-template <class _RandomAccessIterator, class _Compare>
-_RandomAccessIterator __brick_is_heap_until(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Compare __comp,
-    /* __is_vector = */ std::false_type) noexcept {
-  return std::is_heap_until(__first, __last, __comp);
-}
-
-template <class _RandomAccessIterator, class _Compare>
-_RandomAccessIterator __brick_is_heap_until(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Compare __comp,
-    /* __is_vector = */ std::true_type) noexcept {
-  if (__last - __first < 2)
-    return __last;
-  typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _SizeType;
-  return __unseq_backend::__simd_first(
-      __first, _SizeType(0), __last - __first, [&__comp](_RandomAccessIterator __it, _SizeType __i) {
-        return __comp(__it[(__i - 1) / 2], __it[__i]);
-      });
-}
-
-template <class _Tag, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-_RandomAccessIterator __pattern_is_heap_until(
-    _Tag, _ExecutionPolicy&&, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) noexcept {
-  return __internal::__brick_is_heap_until(__first, __last, __comp, typename _Tag::__is_vector{});
-}
-
-template <class _RandomAccessIterator, class _DifferenceType, class _Compare>
-_RandomAccessIterator __is_heap_until_local(
-    _RandomAccessIterator __first,
-    _DifferenceType __begin,
-    _DifferenceType __end,
-    _Compare __comp,
-    /* __is_vector = */ std::false_type) noexcept {
-  _DifferenceType __i = __begin;
-  for (; __i < __end; ++__i) {
-    if (__comp(__first[(__i - 1) / 2], __first[__i])) {
-      break;
-    }
-  }
-  return __first + __i;
-}
-
-template <class _RandomAccessIterator, class _DifferenceType, class _Compare>
-_RandomAccessIterator __is_heap_until_local(
-    _RandomAccessIterator __first,
-    _DifferenceType __begin,
-    _DifferenceType __end,
-    _Compare __comp,
-    /* __is_vector = */ std::true_type) noexcept {
-  return __unseq_backend::__simd_first(
-      __first, __begin, __end, [&__comp](_RandomAccessIterator __it, _DifferenceType __i) {
-        return __comp(__it[(__i - 1) / 2], __it[__i]);
-      });
-}
-
-template <class _IsVector, class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-_RandomAccessIterator __pattern_is_heap_until(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Compare __comp) noexcept {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  if (__last - __first < 2)
-    return __last;
-
-  return __internal::__except_handler([&]() {
-    return __parallel_find(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        [__first, __comp](_RandomAccessIterator __i, _RandomAccessIterator __j) {
-          return __internal::__is_heap_until_local(__first, __i - __first, __j - __first, __comp, _IsVector{});
-        },
-        std::less<typename std::iterator_traits<_RandomAccessIterator>::difference_type>(),
-        /*is_first=*/true);
-  });
-}
-
-//------------------------------------------------------------------------
-// min_element
-//------------------------------------------------------------------------
-
-template <typename _ForwardIterator, typename _Compare>
-_ForwardIterator __brick_min_element(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _Compare __comp,
-    /* __is_vector = */ std::false_type) noexcept {
-  return std::min_element(__first, __last, __comp);
-}
-
-template <typename _RandomAccessIterator, typename _Compare>
-_RandomAccessIterator __brick_min_element(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Compare __comp,
-    /* __is_vector = */ std::true_type) noexcept {
-#if defined(_PSTL_UDR_PRESENT)
-  return __unseq_backend::__simd_min_element(__first, __last - __first, __comp);
-#else
-  return std::min_element(__first, __last, __comp);
-#endif
-}
-
-template <typename _Tag, typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare>
-_ForwardIterator __pattern_min_element(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) noexcept {
-  return __internal::__brick_min_element(__first, __last, __comp, typename _Tag::__is_vector{});
-}
-
-template <typename _IsVector, typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare>
-_RandomAccessIterator __pattern_min_element(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Compare __comp) {
-  if (__first == __last)
-    return __last;
-
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    return __par_backend::__parallel_reduce(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first + 1,
-        __last,
-        __first,
-        [=](_RandomAccessIterator __begin, _RandomAccessIterator __end, _RandomAccessIterator __init)
-            -> _RandomAccessIterator {
-          const _RandomAccessIterator subresult = __internal::__brick_min_element(__begin, __end, __comp, _IsVector{});
-          return __internal::__cmp_iterators_by_values(__init, subresult, __comp);
-        },
-        [=](_RandomAccessIterator __it1, _RandomAccessIterator __it2) -> _RandomAccessIterator {
-          return __internal::__cmp_iterators_by_values(__it1, __it2, __comp);
-        });
-  });
-}
-
-//------------------------------------------------------------------------
-// minmax_element
-//------------------------------------------------------------------------
-
-template <typename _ForwardIterator, typename _Compare>
-std::pair<_ForwardIterator, _ForwardIterator> __brick_minmax_element(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _Compare __comp,
-    /* __is_vector = */ std::false_type) noexcept {
-  return std::minmax_element(__first, __last, __comp);
-}
-
-template <typename _RandomAccessIterator, typename _Compare>
-std::pair<_RandomAccessIterator, _RandomAccessIterator> __brick_minmax_element(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Compare __comp,
-    /* __is_vector = */ std::true_type) noexcept {
-#if defined(_PSTL_UDR_PRESENT)
-  return __unseq_backend::__simd_minmax_element(__first, __last - __first, __comp);
-#else
-  return std::minmax_element(__first, __last, __comp);
-#endif
-}
-
-template <typename _Tag, typename _ExecutionPolicy, typename _ForwardIterator, typename _Compare>
-std::pair<_ForwardIterator, _ForwardIterator> __pattern_minmax_element(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) noexcept {
-  return __internal::__brick_minmax_element(__first, __last, __comp, typename _Tag::__is_vector{});
-}
-
-template <typename _IsVector, typename _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare>
-std::pair<_RandomAccessIterator, _RandomAccessIterator> __pattern_minmax_element(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Compare __comp) {
-  if (__first == __last)
-    return std::make_pair(__first, __first);
-
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    typedef std::pair<_RandomAccessIterator, _RandomAccessIterator> _Result;
-
-    return __par_backend::__parallel_reduce(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first + 1,
-        __last,
-        std::make_pair(__first, __first),
-        [=](_RandomAccessIterator __begin, _RandomAccessIterator __end, _Result __init) -> _Result {
-          const _Result __subresult = __internal::__brick_minmax_element(__begin, __end, __comp, _IsVector{});
-          return std::make_pair(
-              __internal::__cmp_iterators_by_values(__subresult.first, __init.first, __comp),
-              __internal::__cmp_iterators_by_values(__init.second, __subresult.second, std::not_fn(__comp)));
-        },
-        [=](_Result __p1, _Result __p2) -> _Result {
-          return std::make_pair(__internal::__cmp_iterators_by_values(__p1.first, __p2.first, __comp),
-                                __internal::__cmp_iterators_by_values(__p2.second, __p1.second, std::not_fn(__comp)));
-        });
-  });
-}
-
-//------------------------------------------------------------------------
-// mismatch
-//------------------------------------------------------------------------
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-std::pair<_ForwardIterator1, _ForwardIterator2> __mismatch_serial(
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _BinaryPredicate __pred) {
-  return std::mismatch(__first1, __last1, __first2, __last2, __pred);
-}
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-std::pair<_ForwardIterator1, _ForwardIterator2> __brick_mismatch(
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _Predicate __pred,
-    /* __is_vector = */ std::false_type) noexcept {
-  return __mismatch_serial(__first1, __last1, __first2, __last2, __pred);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Predicate>
-std::pair<_RandomAccessIterator1, _RandomAccessIterator2> __brick_mismatch(
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _Predicate __pred,
-    /* __is_vector = */ std::true_type) noexcept {
-  auto __n = std::min(__last1 - __first1, __last2 - __first2);
-  return __unseq_backend::__simd_first(__first1, __n, __first2, std::not_fn(__pred));
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-std::pair<_ForwardIterator1, _ForwardIterator2> __pattern_mismatch(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _Predicate __pred) noexcept {
-  return __internal::__brick_mismatch(__first1, __last1, __first2, __last2, __pred, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Predicate>
-std::pair<_RandomAccessIterator1, _RandomAccessIterator2> __pattern_mismatch(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _Predicate __pred) noexcept {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    auto __n      = std::min(__last1 - __first1, __last2 - __first2);
-    auto __result = __internal::__parallel_find(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __first1 + __n,
-        [__first1, __first2, __pred](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-          return __internal::__brick_mismatch(
-                     __i, __j, __first2 + (__i - __first1), __first2 + (__j - __first1), __pred, _IsVector{})
-              .first;
-        },
-        std::less<typename std::iterator_traits<_RandomAccessIterator1>::difference_type>(),
-        /*is_first=*/true);
-    return std::make_pair(__result, __first2 + (__result - __first1));
-  });
-}
-
-//------------------------------------------------------------------------
-// lexicographical_compare
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-bool __brick_lexicographical_compare(
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _Compare __comp,
-    /* __is_vector = */ std::false_type) noexcept {
-  return std::lexicographical_compare(__first1, __last1, __first2, __last2, __comp);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _Compare>
-bool __brick_lexicographical_compare(
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _Compare __comp,
-    /* __is_vector = */ std::true_type) noexcept {
-  if (__first2 == __last2) { // if second sequence is empty
-    return false;
-  } else if (__first1 == __last1) { // if first sequence is empty
-    return true;
-  } else {
-    typedef typename std::iterator_traits<_RandomAccessIterator1>::reference ref_type1;
-    typedef typename std::iterator_traits<_RandomAccessIterator2>::reference ref_type2;
-    --__last1;
-    --__last2;
-    auto __n = std::min(__last1 - __first1, __last2 - __first2);
-    std::pair<_RandomAccessIterator1, _RandomAccessIterator2> __result = __unseq_backend::__simd_first(
-        __first1, __n, __first2, [__comp](const ref_type1 __x, const ref_type2 __y) mutable {
-          return __comp(__x, __y) || __comp(__y, __x);
-        });
-
-    if (__result.first == __last1 && __result.second != __last2) { // if first sequence shorter than second
-      return !__comp(*__result.second, *__result.first);
-    } else { // if second sequence shorter than first or both have the same number of elements
-      return __comp(*__result.first, *__result.second);
-    }
-  }
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-bool __pattern_lexicographical_compare(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _Compare __comp) noexcept {
-  return __internal::__brick_lexicographical_compare(
-      __first1, __last1, __first2, __last2, __comp, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Compare>
-bool __pattern_lexicographical_compare(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _RandomAccessIterator2 __last2,
-    _Compare __comp) noexcept {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  if (__first2 == __last2) { // if second sequence is empty
-    return false;
-  } else if (__first1 == __last1) { // if first sequence is empty
-    return true;
-  } else {
-    typedef typename std::iterator_traits<_RandomAccessIterator1>::reference _RefType1;
-    typedef typename std::iterator_traits<_RandomAccessIterator2>::reference _RefType2;
-    --__last1;
-    --__last2;
-    auto __n      = std::min(__last1 - __first1, __last2 - __first2);
-    auto __result = __internal::__parallel_find(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __first1 + __n,
-        [__first1, __first2, &__comp](_RandomAccessIterator1 __i, _RandomAccessIterator1 __j) {
-          return __internal::__brick_mismatch(
-                     __i,
-                     __j,
-                     __first2 + (__i - __first1),
-                     __first2 + (__j - __first1),
-                     [&__comp](const _RefType1 __x, const _RefType2 __y) {
-                       return !__comp(__x, __y) && !__comp(__y, __x);
-                     },
-                     _IsVector{})
-              .first;
-        },
-        std::less<typename std::iterator_traits<_RandomAccessIterator1>::difference_type>(),
-        /*is_first=*/true);
-
-    if (__result == __last1 && __first2 + (__result - __first1) != __last2) { // if first sequence shorter than second
-      return !__comp(*(__first2 + (__result - __first1)), *__result);
-    } else { // if second sequence shorter than first or both have the same number of elements
-      return __comp(*__result, *(__first2 + (__result - __first1)));
-    }
-  }
-}
-
-} // namespace __internal
-} // namespace __pstl
-
-#endif /* _PSTL_ALGORITHM_IMPL_H */
diff --git a/third_party/libcxx/__pstl/internal/execution_defs.h b/third_party/libcxx/__pstl/internal/execution_defs.h
deleted file mode 100644
index 5992f0e4a..000000000
--- a/third_party/libcxx/__pstl/internal/execution_defs.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_EXECUTION_POLICY_DEFS_H
-#define _PSTL_EXECUTION_POLICY_DEFS_H
-
-#include <__config>
-#include <__type_traits/decay.h>
-#include <__type_traits/enable_if.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-namespace __pstl {
-namespace execution {
-inline namespace v1 {
-
-// 2.4, Sequential execution policy
-class sequenced_policy {};
-
-// 2.5, Parallel execution policy
-class parallel_policy {};
-
-// 2.6, Parallel+Vector execution policy
-class parallel_unsequenced_policy {};
-
-class unsequenced_policy {};
-
-// 2.8, Execution policy objects
-constexpr sequenced_policy seq{};
-constexpr parallel_policy par{};
-constexpr parallel_unsequenced_policy par_unseq{};
-constexpr unsequenced_policy unseq{};
-
-// 2.3, Execution policy type trait
-template <class>
-struct is_execution_policy : std::false_type {};
-
-template <>
-struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type {};
-template <>
-struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type {};
-template <>
-struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type {};
-template <>
-struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type {};
-
-template <class _Tp>
-constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value;
-} // namespace v1
-} // namespace execution
-
-namespace __internal {
-template <class _ExecPolicy, class _Tp>
-using __enable_if_execution_policy =
-    typename std::enable_if<__pstl::execution::is_execution_policy<typename std::decay<_ExecPolicy>::type>::value,
-                            _Tp>::type;
-
-template <class _IsVector>
-struct __serial_tag;
-template <class _IsVector>
-struct __parallel_tag;
-
-} // namespace __internal
-
-} // namespace __pstl
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif /* _PSTL_EXECUTION_POLICY_DEFS_H */
diff --git a/third_party/libcxx/__pstl/internal/execution_impl.h b/third_party/libcxx/__pstl/internal/execution_impl.h
deleted file mode 100644
index c3a7405d3..000000000
--- a/third_party/libcxx/__pstl/internal/execution_impl.h
+++ /dev/null
@@ -1,97 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_EXECUTION_IMPL_H
-#define _PSTL_EXECUTION_IMPL_H
-
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/conditional.h>
-#include <__type_traits/conjunction.h>
-#include <__type_traits/decay.h>
-#include <__type_traits/integral_constant.h>
-#include <__type_traits/is_base_of.h>
-
-#include <__pstl/internal/execution_defs.h>
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-namespace __pstl {
-namespace __internal {
-
-template <typename _IteratorTag, typename... _IteratorTypes>
-using __are_iterators_of = std::conjunction<
-    std::is_base_of<_IteratorTag, typename std::iterator_traits<std::decay_t<_IteratorTypes>>::iterator_category>...>;
-
-template <typename... _IteratorTypes>
-using __are_random_access_iterators = __are_iterators_of<std::random_access_iterator_tag, _IteratorTypes...>;
-
-struct __serial_backend_tag {};
-struct __tbb_backend_tag {};
-struct __openmp_backend_tag {};
-
-#  if defined(_PSTL_PAR_BACKEND_TBB)
-using __par_backend_tag = __tbb_backend_tag;
-#  elif defined(_PSTL_PAR_BACKEND_OPENMP)
-using __par_backend_tag = __openmp_backend_tag;
-#  elif defined(_PSTL_PAR_BACKEND_SERIAL)
-using __par_backend_tag = __serial_backend_tag;
-#  else
-#    error "A parallel backend must be specified";
-#  endif
-
-template <class _IsVector>
-struct __serial_tag {
-  using __is_vector = _IsVector;
-};
-
-template <class _IsVector>
-struct __parallel_tag {
-  using __is_vector = _IsVector;
-  // backend tag can be change depending on
-  // TBB availability in the environment
-  using __backend_tag = __par_backend_tag;
-};
-
-template <class _IsVector, class... _IteratorTypes>
-using __tag_type =
-    typename std::conditional<__internal::__are_random_access_iterators<_IteratorTypes...>::value,
-                              __parallel_tag<_IsVector>,
-                              __serial_tag<_IsVector>>::type;
-
-template <class... _IteratorTypes>
-_LIBCPP_HIDE_FROM_ABI __serial_tag</*_IsVector = */ std::false_type>
-__select_backend(__pstl::execution::sequenced_policy, _IteratorTypes&&...) {
-  return {};
-}
-
-template <class... _IteratorTypes>
-_LIBCPP_HIDE_FROM_ABI __serial_tag<__internal::__are_random_access_iterators<_IteratorTypes...>>
-__select_backend(__pstl::execution::unsequenced_policy, _IteratorTypes&&...) {
-  return {};
-}
-
-template <class... _IteratorTypes>
-_LIBCPP_HIDE_FROM_ABI __tag_type</*_IsVector = */ std::false_type, _IteratorTypes...>
-__select_backend(__pstl::execution::parallel_policy, _IteratorTypes&&...) {
-  return {};
-}
-
-template <class... _IteratorTypes>
-_LIBCPP_HIDE_FROM_ABI __tag_type<__internal::__are_random_access_iterators<_IteratorTypes...>, _IteratorTypes...>
-__select_backend(__pstl::execution::parallel_unsequenced_policy, _IteratorTypes&&...) {
-  return {};
-}
-
-} // namespace __internal
-} // namespace __pstl
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif /* _PSTL_EXECUTION_IMPL_H */
diff --git a/third_party/libcxx/__pstl/internal/glue_algorithm_defs.h b/third_party/libcxx/__pstl/internal/glue_algorithm_defs.h
deleted file mode 100644
index 00458d5ff..000000000
--- a/third_party/libcxx/__pstl/internal/glue_algorithm_defs.h
+++ /dev/null
@@ -1,655 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_GLUE_ALGORITHM_DEFS_H
-#define _PSTL_GLUE_ALGORITHM_DEFS_H
-
-#include <__config>
-#include <functional>
-#include <iterator>
-
-#include "execution_defs.h"
-
-namespace std {
-
-// [alg.find.end]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
-find_end(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first,
-         _ForwardIterator1 __last,
-         _ForwardIterator2 __s_first,
-         _ForwardIterator2 __s_last,
-         _BinaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
-find_end(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first,
-         _ForwardIterator1 __last,
-         _ForwardIterator2 __s_first,
-         _ForwardIterator2 __s_last);
-
-// [alg.find_first_of]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_first_of(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __s_first,
-    _ForwardIterator2 __s_last,
-    _BinaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
-find_first_of(_ExecutionPolicy&& __exec,
-              _ForwardIterator1 __first,
-              _ForwardIterator1 __last,
-              _ForwardIterator2 __s_first,
-              _ForwardIterator2 __s_last);
-
-// [alg.adjacent_find]
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred);
-
-// [alg.count]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
-                                                 typename iterator_traits<_ForwardIterator>::difference_type>
-count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
-                                                 typename iterator_traits<_ForwardIterator>::difference_type>
-count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);
-
-// [alg.search]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
-search(_ExecutionPolicy&& __exec,
-       _ForwardIterator1 __first,
-       _ForwardIterator1 __last,
-       _ForwardIterator2 __s_first,
-       _ForwardIterator2 __s_last,
-       _BinaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
-search(_ExecutionPolicy&& __exec,
-       _ForwardIterator1 __first,
-       _ForwardIterator1 __last,
-       _ForwardIterator2 __s_first,
-       _ForwardIterator2 __s_last);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-search_n(_ExecutionPolicy&& __exec,
-         _ForwardIterator __first,
-         _ForwardIterator __last,
-         _Size __count,
-         const _Tp& __value,
-         _BinaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> search_n(
-    _ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value);
-
-// [alg.copy]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-copy_if(_ExecutionPolicy&& __exec,
-        _ForwardIterator1 __first,
-        _ForwardIterator1 __last,
-        _ForwardIterator2 result,
-        _Predicate __pred);
-
-// [alg.swap]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> swap_ranges(
-    _ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
-
-// [alg.replace]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-replace_if(_ExecutionPolicy&& __exec,
-           _ForwardIterator __first,
-           _ForwardIterator __last,
-           _UnaryPredicate __pred,
-           const _Tp& __new_value);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-replace(_ExecutionPolicy&& __exec,
-        _ForwardIterator __first,
-        _ForwardIterator __last,
-        const _Tp& __old_value,
-        const _Tp& __new_value);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryPredicate, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> replace_copy_if(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _UnaryPredicate __pred,
-    const _Tp& __new_value);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> replace_copy(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    const _Tp& __old_value,
-    const _Tp& __new_value);
-
-// [alg.generate]
-template <class _ExecutionPolicy, class _ForwardIterator, class _Generator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size count, _Generator __g);
-
-// [alg.remove]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> remove_copy_if(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _Predicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-remove_copy(_ExecutionPolicy&& __exec,
-            _ForwardIterator1 __first,
-            _ForwardIterator1 __last,
-            _ForwardIterator2 __result,
-            const _Tp& __value);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
-
-// [alg.unique]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-unique_copy(_ExecutionPolicy&& __exec,
-            _ForwardIterator1 __first,
-            _ForwardIterator1 __last,
-            _ForwardIterator2 __result,
-            _BinaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result);
-
-// [alg.reverse]
-
-template <class _ExecutionPolicy, class _BidirectionalIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last);
-
-template <class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-reverse_copy(_ExecutionPolicy&& __exec,
-             _BidirectionalIterator __first,
-             _BidirectionalIterator __last,
-             _ForwardIterator __d_first);
-
-// [alg.rotate]
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-rotate_copy(_ExecutionPolicy&& __exec,
-            _ForwardIterator1 __first,
-            _ForwardIterator1 __middle,
-            _ForwardIterator1 __last,
-            _ForwardIterator2 __result);
-
-// [alg.partitions]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator> stable_partition(
-    _ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred);
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _UnaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
-partition_copy(_ExecutionPolicy&& __exec,
-               _ForwardIterator __first,
-               _ForwardIterator __last,
-               _ForwardIterator1 __out_true,
-               _ForwardIterator2 __out_false,
-               _UnaryPredicate __pred);
-
-// [alg.sort]
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
-
-// [stable.sort]
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
-
-// [mismatch]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
-mismatch(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first1,
-         _ForwardIterator1 __last1,
-         _ForwardIterator2 __first2,
-         _ForwardIterator2 __last2,
-         _BinaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
-mismatch(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first1,
-         _ForwardIterator1 __last1,
-         _ForwardIterator2 __first2,
-         _BinaryPredicate __pred);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
-mismatch(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first1,
-         _ForwardIterator1 __last1,
-         _ForwardIterator2 __first2,
-         _ForwardIterator2 __last2);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
-mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
-
-// [alg.equal]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-equal(_ExecutionPolicy&& __exec,
-      _ForwardIterator1 __first1,
-      _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2,
-      _BinaryPredicate __p);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-equal(_ExecutionPolicy&& __exec,
-      _ForwardIterator1 __first1,
-      _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2,
-      _ForwardIterator2 __last2,
-      _BinaryPredicate __p);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-equal(_ExecutionPolicy&& __exec,
-      _ForwardIterator1 __first1,
-      _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2,
-      _ForwardIterator2 __last2);
-
-// [alg.move]
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first);
-
-// [partial.sort]
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-partial_sort(_ExecutionPolicy&& __exec,
-             _RandomAccessIterator __first,
-             _RandomAccessIterator __middle,
-             _RandomAccessIterator __last,
-             _Compare __comp);
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-partial_sort(_ExecutionPolicy&& __exec,
-             _RandomAccessIterator __first,
-             _RandomAccessIterator __middle,
-             _RandomAccessIterator __last);
-
-// [partial.sort.copy]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _RandomAccessIterator __d_first,
-    _RandomAccessIterator __d_last,
-    _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _RandomAccessIterator __d_first,
-    _RandomAccessIterator __d_last);
-
-// [is.sorted]
-template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-// [alg.nth.element]
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-nth_element(_ExecutionPolicy&& __exec,
-            _RandomAccessIterator __first,
-            _RandomAccessIterator __nth,
-            _RandomAccessIterator __last,
-            _Compare __comp);
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-nth_element(_ExecutionPolicy&& __exec,
-            _RandomAccessIterator __first,
-            _RandomAccessIterator __nth,
-            _RandomAccessIterator __last);
-
-// [alg.merge]
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator,
-          class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-merge(_ExecutionPolicy&& __exec,
-      _ForwardIterator1 __first1,
-      _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2,
-      _ForwardIterator2 __last2,
-      _ForwardIterator __d_first,
-      _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-merge(_ExecutionPolicy&& __exec,
-      _ForwardIterator1 __first1,
-      _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2,
-      _ForwardIterator2 __last2,
-      _ForwardIterator __d_first);
-
-template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-inplace_merge(_ExecutionPolicy&& __exec,
-              _BidirectionalIterator __first,
-              _BidirectionalIterator __middle,
-              _BidirectionalIterator __last,
-              _Compare __comp);
-
-template <class _ExecutionPolicy, class _BidirectionalIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-inplace_merge(_ExecutionPolicy&& __exec,
-              _BidirectionalIterator __first,
-              _BidirectionalIterator __middle,
-              _BidirectionalIterator __last);
-
-// [includes]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-includes(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first1,
-         _ForwardIterator1 __last1,
-         _ForwardIterator2 __first2,
-         _ForwardIterator2 __last2,
-         _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-includes(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first1,
-         _ForwardIterator1 __last1,
-         _ForwardIterator2 __first2,
-         _ForwardIterator2 __last2);
-
-// [set.union]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator,
-          class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-set_union(_ExecutionPolicy&& __exec,
-          _ForwardIterator1 __first1,
-          _ForwardIterator1 __last1,
-          _ForwardIterator2 __first2,
-          _ForwardIterator2 __last2,
-          _ForwardIterator __result,
-          _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-set_union(_ExecutionPolicy&& __exec,
-          _ForwardIterator1 __first1,
-          _ForwardIterator1 __last1,
-          _ForwardIterator2 __first2,
-          _ForwardIterator2 __last2,
-          _ForwardIterator __result);
-
-// [set.intersection]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator,
-          class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result,
-    _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result);
-
-// [set.difference]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator,
-          class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result,
-    _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result);
-
-// [set.symmetric.difference]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator,
-          class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator result,
-    _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result);
-
-// [is.heap]
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
-is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
-is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);
-
-// [alg.min.max]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
-minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
-minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-// [alg.lex.comparison]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _Compare __comp);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2);
-
-} // namespace std
-
-#endif /* _PSTL_GLUE_ALGORITHM_DEFS_H */
diff --git a/third_party/libcxx/__pstl/internal/glue_algorithm_impl.h b/third_party/libcxx/__pstl/internal/glue_algorithm_impl.h
deleted file mode 100644
index 4b1713307..000000000
--- a/third_party/libcxx/__pstl/internal/glue_algorithm_impl.h
+++ /dev/null
@@ -1,1081 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_GLUE_ALGORITHM_IMPL_H
-#define _PSTL_GLUE_ALGORITHM_IMPL_H
-
-#include <__config>
-#include <functional>
-
-#include "algorithm_fwd.h"
-#include "execution_defs.h"
-#include "numeric_fwd.h" /* count and count_if use __pattern_transform_reduce */
-#include "utils.h"
-
-#include "execution_impl.h"
-
-namespace std {
-
-// [alg.find.end]
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
-find_end(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first,
-         _ForwardIterator1 __last,
-         _ForwardIterator2 __s_first,
-         _ForwardIterator2 __s_last,
-         _BinaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __s_first);
-
-  return __pstl::__internal::__pattern_find_end(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
-find_end(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first,
-         _ForwardIterator1 __last,
-         _ForwardIterator2 __s_first,
-         _ForwardIterator2 __s_last) {
-  return std::find_end(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, std::equal_to<>());
-}
-
-// [alg.find_first_of]
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1> find_first_of(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __s_first,
-    _ForwardIterator2 __s_last,
-    _BinaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __s_first);
-
-  return __pstl::__internal::__pattern_find_first_of(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
-find_first_of(_ExecutionPolicy&& __exec,
-              _ForwardIterator1 __first,
-              _ForwardIterator1 __last,
-              _ForwardIterator2 __s_first,
-              _ForwardIterator2 __s_last) {
-  return std::find_first_of(
-      std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, std::equal_to<>());
-}
-
-// [alg.adjacent_find]
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  return __pstl::__internal::__pattern_adjacent_find(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      std::equal_to<_ValueType>(),
-      /*first_semantic*/ false);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-  return __pstl::__internal::__pattern_adjacent_find(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred, /*first_semantic*/ false);
-}
-
-// [alg.count]
-
-// Implementation note: count and count_if call the pattern directly instead of calling std::transform_reduce
-// so that we do not have to include <numeric>.
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
-                                                 typename iterator_traits<_ForwardIterator>::difference_type>
-count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  return __pstl::__internal::__pattern_count(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value](const _ValueType& __x) {
-        return __value == __x;
-      });
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
-                                                 typename iterator_traits<_ForwardIterator>::difference_type>
-count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-  return __pstl::__internal::__pattern_count(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
-}
-
-// [alg.search]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
-search(_ExecutionPolicy&& __exec,
-       _ForwardIterator1 __first,
-       _ForwardIterator1 __last,
-       _ForwardIterator2 __s_first,
-       _ForwardIterator2 __s_last,
-       _BinaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __s_first);
-
-  return __pstl::__internal::__pattern_search(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, __pred);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
-search(_ExecutionPolicy&& __exec,
-       _ForwardIterator1 __first,
-       _ForwardIterator1 __last,
-       _ForwardIterator2 __s_first,
-       _ForwardIterator2 __s_last) {
-  return std::search(std::forward<_ExecutionPolicy>(__exec), __first, __last, __s_first, __s_last, std::equal_to<>());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-search_n(_ExecutionPolicy&& __exec,
-         _ForwardIterator __first,
-         _ForwardIterator __last,
-         _Size __count,
-         const _Tp& __value,
-         _BinaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  return __pstl::__internal::__pattern_search_n(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __count, __value, __pred);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> search_n(
-    _ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
-  return std::search_n(
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __count,
-      __value,
-      std::equal_to<typename iterator_traits<_ForwardIterator>::value_type>());
-}
-
-// [alg.copy]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-copy_if(_ExecutionPolicy&& __exec,
-        _ForwardIterator1 __first,
-        _ForwardIterator1 __last,
-        _ForwardIterator2 __result,
-        _Predicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  return __pstl::__internal::__pattern_copy_if(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred);
-}
-
-// [alg.swap]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> swap_ranges(
-    _ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
-  typedef typename iterator_traits<_ForwardIterator1>::reference _ReferenceType1;
-  typedef typename iterator_traits<_ForwardIterator2>::reference _ReferenceType2;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
-
-  return __pstl::__internal::__pattern_walk2(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first1,
-      __last1,
-      __first2,
-      [](_ReferenceType1 __x, _ReferenceType2 __y) {
-        using std::swap;
-        swap(__x, __y);
-      });
-}
-
-// [alg.transform]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator,
-          class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-transform(_ExecutionPolicy&& __exec,
-          _ForwardIterator1 __first1,
-          _ForwardIterator1 __last1,
-          _ForwardIterator2 __first2,
-          _ForwardIterator __result,
-          _BinaryOperation __op) {
-  typedef typename iterator_traits<_ForwardIterator1>::reference _Input1Type;
-  typedef typename iterator_traits<_ForwardIterator2>::reference _Input2Type;
-  typedef typename iterator_traits<_ForwardIterator>::reference _OutputType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
-
-  return __pstl::__internal::__pattern_walk3(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first1,
-      __last1,
-      __first2,
-      __result,
-      [__op](_Input1Type x, _Input2Type y, _OutputType z) mutable { z = __op(x, y); });
-}
-
-// [alg.replace]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-replace_if(_ExecutionPolicy&& __exec,
-           _ForwardIterator __first,
-           _ForwardIterator __last,
-           _UnaryPredicate __pred,
-           const _Tp& __new_value) {
-  typedef typename iterator_traits<_ForwardIterator>::reference _ElementType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  __pstl::__internal::__pattern_walk1(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      [&__pred, &__new_value](_ElementType __elem) {
-        if (__pred(__elem)) {
-          __elem = __new_value;
-        }
-      });
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-replace(_ExecutionPolicy&& __exec,
-        _ForwardIterator __first,
-        _ForwardIterator __last,
-        const _Tp& __old_value,
-        const _Tp& __new_value) {
-  std::replace_if(
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __pstl::__internal::__equal_value<_Tp>(__old_value),
-      __new_value);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryPredicate, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> replace_copy_if(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _UnaryPredicate __pred,
-    const _Tp& __new_value) {
-  typedef typename iterator_traits<_ForwardIterator1>::reference _InputType;
-  typedef typename iterator_traits<_ForwardIterator2>::reference _OutputType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  return __pstl::__internal::__pattern_walk2(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __result,
-      [__pred, &__new_value](_InputType __x, _OutputType __y) mutable { __y = __pred(__x) ? __new_value : __x; });
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> replace_copy(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    const _Tp& __old_value,
-    const _Tp& __new_value) {
-  return std::replace_copy_if(
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __result,
-      __pstl::__internal::__equal_value<_Tp>(__old_value),
-      __new_value);
-}
-
-// [alg.generate]
-template <class _ExecutionPolicy, class _ForwardIterator, class _Generator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  __pstl::__internal::__pattern_generate(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __g);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, _Generator __g) {
-  if (__count <= 0)
-    return __first;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  return __pstl::__internal::__pattern_generate_n(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __count, __g);
-}
-
-// [alg.remove]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> remove_copy_if(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _Predicate __pred) {
-  return std::copy_if(std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, std::not_fn(__pred));
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-remove_copy(_ExecutionPolicy&& __exec,
-            _ForwardIterator1 __first,
-            _ForwardIterator1 __last,
-            _ForwardIterator2 __result,
-            const _Tp& __value) {
-  return std::copy_if(
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __result,
-      __pstl::__internal::__not_equal_value<_Tp>(__value));
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  return __pstl::__internal::__pattern_remove_if(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
-  return std::remove_if(
-      std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__equal_value<_Tp>(__value));
-}
-
-// [alg.unique]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  return __pstl::__internal::__pattern_unique(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  return std::unique(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::equal_to<>());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-unique_copy(_ExecutionPolicy&& __exec,
-            _ForwardIterator1 __first,
-            _ForwardIterator1 __last,
-            _ForwardIterator2 __result,
-            _BinaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  return __pstl::__internal::__pattern_unique_copy(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __pred);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> unique_copy(
-    _ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) {
-  return std::unique_copy(__exec, __first, __last, __result, std::equal_to<>());
-}
-
-// [alg.reverse]
-
-template <class _ExecutionPolicy, class _BidirectionalIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  __pstl::__internal::__pattern_reverse(__dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last);
-}
-
-template <class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-reverse_copy(_ExecutionPolicy&& __exec,
-             _BidirectionalIterator __first,
-             _BidirectionalIterator __last,
-             _ForwardIterator __d_first) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __d_first);
-
-  return __pstl::__internal::__pattern_reverse_copy(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first);
-}
-
-// [alg.rotate]
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  return __pstl::__internal::__pattern_rotate(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-rotate_copy(_ExecutionPolicy&& __exec,
-            _ForwardIterator1 __first,
-            _ForwardIterator1 __middle,
-            _ForwardIterator1 __last,
-            _ForwardIterator2 __result) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  return __pstl::__internal::__pattern_rotate_copy(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __result);
-}
-
-// [alg.partitions]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-  return __pstl::__internal::__pattern_is_partitioned(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  return __pstl::__internal::__pattern_partition(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
-}
-
-template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator> stable_partition(
-    _ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last, _UnaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-  return __pstl::__internal::__pattern_stable_partition(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __pred);
-}
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _UnaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
-partition_copy(_ExecutionPolicy&& __exec,
-               _ForwardIterator __first,
-               _ForwardIterator __last,
-               _ForwardIterator1 __out_true,
-               _ForwardIterator2 __out_false,
-               _UnaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __out_true, __out_false);
-
-  return __pstl::__internal::__pattern_partition_copy(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __out_true, __out_false, __pred);
-}
-
-// [alg.sort]
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType;
-  return __pstl::__internal::__pattern_sort(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __comp,
-      typename std::is_move_constructible<_InputType>::type());
-}
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) {
-  typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
-  std::sort(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
-}
-
-// [stable.sort]
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  return __pstl::__internal::__pattern_stable_sort(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp);
-}
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) {
-  typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
-  std::stable_sort(__exec, __first, __last, std::less<_InputType>());
-}
-
-// [mismatch]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
-mismatch(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first1,
-         _ForwardIterator1 __last1,
-         _ForwardIterator2 __first2,
-         _ForwardIterator2 __last2,
-         _BinaryPredicate __pred) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
-
-  return __pstl::__internal::__pattern_mismatch(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __pred);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
-mismatch(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first1,
-         _ForwardIterator1 __last1,
-         _ForwardIterator2 __first2,
-         _BinaryPredicate __pred) {
-  return std::mismatch(
-      __exec, __first1, __last1, __first2, std::next(__first2, std::distance(__first1, __last1)), __pred);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
-mismatch(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first1,
-         _ForwardIterator1 __last1,
-         _ForwardIterator2 __first2,
-         _ForwardIterator2 __last2) {
-  return std::mismatch(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::equal_to<>());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
-mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
-  // TODO: to get rid of "distance"
-  return std::mismatch(
-      std::forward<_ExecutionPolicy>(__exec),
-      __first1,
-      __last1,
-      __first2,
-      std::next(__first2, std::distance(__first1, __last1)));
-}
-
-// [alg.equal]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-equal(_ExecutionPolicy&& __exec,
-      _ForwardIterator1 __first1,
-      _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2,
-      _BinaryPredicate __p) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
-
-  return __pstl::__internal::__pattern_equal(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __p);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
-  return std::equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, std::equal_to<>());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-equal(_ExecutionPolicy&& __exec,
-      _ForwardIterator1 __first1,
-      _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2,
-      _ForwardIterator2 __last2,
-      _BinaryPredicate __p) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
-
-  return __pstl::__internal::__pattern_equal(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __p);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-equal(_ExecutionPolicy&& __exec,
-      _ForwardIterator1 __first1,
-      _ForwardIterator1 __last1,
-      _ForwardIterator2 __first2,
-      _ForwardIterator2 __last2) {
-  return equal(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::equal_to<>());
-}
-
-// [alg.move]
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
-move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __d_first);
-
-  using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
-
-  return __pstl::__internal::__pattern_walk2_brick(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __d_first,
-      [](_ForwardIterator1 __begin, _ForwardIterator1 __end, _ForwardIterator2 __res) {
-        return __pstl::__internal::__brick_move(__begin, __end, __res, __is_vector{});
-      });
-}
-
-// [partial.sort]
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-partial_sort(_ExecutionPolicy&& __exec,
-             _RandomAccessIterator __first,
-             _RandomAccessIterator __middle,
-             _RandomAccessIterator __last,
-             _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  __pstl::__internal::__pattern_partial_sort(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp);
-}
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-partial_sort(_ExecutionPolicy&& __exec,
-             _RandomAccessIterator __first,
-             _RandomAccessIterator __middle,
-             _RandomAccessIterator __last) {
-  typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType;
-  std::partial_sort(__exec, __first, __middle, __last, std::less<_InputType>());
-}
-
-// [partial.sort.copy]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _RandomAccessIterator __d_first,
-    _RandomAccessIterator __d_last,
-    _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __d_first);
-
-  return __pstl::__internal::__pattern_partial_sort_copy(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, __comp);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator> partial_sort_copy(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _RandomAccessIterator __d_first,
-    _RandomAccessIterator __d_last) {
-  return std::partial_sort_copy(
-      std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __d_last, std::less<>());
-}
-
-// [is.sorted]
-template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
-  auto __dispatch_tag          = __pstl::__internal::__select_backend(__exec, __first);
-  const _ForwardIterator __res = __pstl::__internal::__pattern_adjacent_find(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __pstl::__internal::__reorder_pred<_Compare>(__comp),
-      /*first_semantic*/ false);
-  return __res == __last ? __last : std::next(__res);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
-  return is_sorted_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-  return __pstl::__internal::__pattern_adjacent_find(
-             __dispatch_tag,
-             std::forward<_ExecutionPolicy>(__exec),
-             __first,
-             __last,
-             __pstl::__internal::__reorder_pred<_Compare>(__comp),
-             /*or_semantic*/ true) == __last;
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
-  return std::is_sorted(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
-}
-
-// [alg.merge]
-template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-inplace_merge(_ExecutionPolicy&& __exec,
-              _BidirectionalIterator __first,
-              _BidirectionalIterator __middle,
-              _BidirectionalIterator __last,
-              _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  __pstl::__internal::__pattern_inplace_merge(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __middle, __last, __comp);
-}
-
-template <class _ExecutionPolicy, class _BidirectionalIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-inplace_merge(_ExecutionPolicy&& __exec,
-              _BidirectionalIterator __first,
-              _BidirectionalIterator __middle,
-              _BidirectionalIterator __last) {
-  typedef typename std::iterator_traits<_BidirectionalIterator>::value_type _InputType;
-  std::inplace_merge(__exec, __first, __middle, __last, std::less<_InputType>());
-}
-
-// [includes]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-includes(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first1,
-         _ForwardIterator1 __last1,
-         _ForwardIterator2 __first2,
-         _ForwardIterator2 __last2,
-         _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
-
-  return __pstl::__internal::__pattern_includes(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-includes(_ExecutionPolicy&& __exec,
-         _ForwardIterator1 __first1,
-         _ForwardIterator1 __last1,
-         _ForwardIterator2 __first2,
-         _ForwardIterator2 __last2) {
-  return std::includes(std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::less<>());
-}
-
-// [set.union]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator,
-          class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-set_union(_ExecutionPolicy&& __exec,
-          _ForwardIterator1 __first1,
-          _ForwardIterator1 __last1,
-          _ForwardIterator2 __first2,
-          _ForwardIterator2 __last2,
-          _ForwardIterator __result,
-          _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
-
-  return __pstl::__internal::__pattern_set_union(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-set_union(_ExecutionPolicy&& __exec,
-          _ForwardIterator1 __first1,
-          _ForwardIterator1 __last1,
-          _ForwardIterator2 __first2,
-          _ForwardIterator2 __last2,
-          _ForwardIterator __result) {
-  return std::set_union(
-      std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, std::less<>());
-}
-
-// [set.intersection]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator,
-          class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result,
-    _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
-
-  return __pstl::__internal::__pattern_set_intersection(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_intersection(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result) {
-  return std::set_intersection(
-      std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, std::less<>());
-}
-
-// [set.difference]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator,
-          class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result,
-    _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
-
-  return __pstl::__internal::__pattern_set_difference(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_difference(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result) {
-  return std::set_difference(
-      std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, std::less<>());
-}
-
-// [set.symmetric.difference]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _ForwardIterator,
-          class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result,
-    _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2, __result);
-
-  return __pstl::__internal::__pattern_set_symmetric_difference(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, __comp);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> set_symmetric_difference(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _ForwardIterator __result) {
-  return std::set_symmetric_difference(
-      std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __result, std::less<>());
-}
-
-// [is.heap]
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
-is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  return __pstl::__internal::__pattern_is_heap_until(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp);
-}
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
-is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) {
-  typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
-  return std::is_heap_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
-}
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp) {
-  return std::is_heap_until(std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp) == __last;
-}
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
-is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last) {
-  typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _InputType;
-  return std::is_heap(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
-}
-
-// [alg.min.max]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-  return __pstl::__internal::__pattern_min_element(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
-  return std::min_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_InputType>());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
-  return min_element(
-      std::forward<_ExecutionPolicy>(__exec), __first, __last, __pstl::__internal::__reorder_pred<_Compare>(__comp));
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  typedef typename std::iterator_traits<_ForwardIterator>::value_type _InputType;
-  return std::min_element(
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __pstl::__internal::__reorder_pred<std::less<_InputType>>(std::less<_InputType>()));
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
-minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-  return __pstl::__internal::__pattern_minmax_element(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __comp);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
-minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  return std::minmax_element(std::forward<_ExecutionPolicy>(__exec), __first, __last, std::less<_ValueType>());
-}
-
-// [alg.nth.element]
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-nth_element(_ExecutionPolicy&& __exec,
-            _RandomAccessIterator __first,
-            _RandomAccessIterator __nth,
-            _RandomAccessIterator __last,
-            _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  __pstl::__internal::__pattern_nth_element(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, __comp);
-}
-
-template <class _ExecutionPolicy, class _RandomAccessIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-nth_element(_ExecutionPolicy&& __exec,
-            _RandomAccessIterator __first,
-            _RandomAccessIterator __nth,
-            _RandomAccessIterator __last) {
-  typedef typename iterator_traits<_RandomAccessIterator>::value_type _InputType;
-  std::nth_element(std::forward<_ExecutionPolicy>(__exec), __first, __nth, __last, std::less<_InputType>());
-}
-
-// [alg.lex.comparison]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2,
-    _Compare __comp) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
-
-  return __pstl::__internal::__pattern_lexicographical_compare(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, __comp);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool> lexicographical_compare(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _ForwardIterator2 __last2) {
-  return std::lexicographical_compare(
-      std::forward<_ExecutionPolicy>(__exec), __first1, __last1, __first2, __last2, std::less<>());
-}
-
-} // namespace std
-
-#endif /* _PSTL_GLUE_ALGORITHM_IMPL_H */
diff --git a/third_party/libcxx/__pstl/internal/glue_memory_defs.h b/third_party/libcxx/__pstl/internal/glue_memory_defs.h
deleted file mode 100644
index 4e8581cfd..000000000
--- a/third_party/libcxx/__pstl/internal/glue_memory_defs.h
+++ /dev/null
@@ -1,81 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_GLUE_MEMORY_DEFS_H
-#define _PSTL_GLUE_MEMORY_DEFS_H
-
-#include <__config>
-
-#include "execution_defs.h"
-
-namespace std {
-
-// [uninitialized.copy]
-
-template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);
-
-template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result);
-
-// [uninitialized.move]
-
-template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);
-
-template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result);
-
-// [uninitialized.fill]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value);
-
-// [specialized.destroy]
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
-
-// [uninitialized.construct.default]
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
-
-// [uninitialized.construct.value]
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);
-
-} //  namespace std
-
-#endif /* _PSTL_GLUE_MEMORY_DEFS_H */
diff --git a/third_party/libcxx/__pstl/internal/glue_memory_impl.h b/third_party/libcxx/__pstl/internal/glue_memory_impl.h
deleted file mode 100644
index b645ba3fc..000000000
--- a/third_party/libcxx/__pstl/internal/glue_memory_impl.h
+++ /dev/null
@@ -1,379 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_GLUE_MEMORY_IMPL_H
-#define _PSTL_GLUE_MEMORY_IMPL_H
-
-#include <__config>
-
-#include "algorithm_fwd.h"
-#include "execution_defs.h"
-#include "utils.h"
-
-#include "execution_impl.h"
-
-namespace std {
-
-// [uninitialized.copy]
-
-template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_copy(
-    _ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) {
-  typedef typename iterator_traits<_InputIterator>::value_type _ValueType1;
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2;
-  typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
-
-  return __pstl::__internal::__invoke_if_else(
-      std::integral_constant < bool,
-      std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
-      [&]() {
-        return __pstl::__internal::__pattern_walk2_brick(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __last,
-            __result,
-            [](_InputIterator __begin, _InputIterator __end, _ForwardIterator __res) {
-              return __pstl::__internal::__brick_copy(__begin, __end, __res, __is_vector{});
-            });
-      },
-      [&]() {
-        return __pstl::__internal::__pattern_walk2(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __last,
-            __result,
-            [](_ReferenceType1 __val1, _ReferenceType2 __val2) { ::new (std::addressof(__val2)) _ValueType2(__val1); });
-      });
-}
-
-template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result) {
-  typedef typename iterator_traits<_InputIterator>::value_type _ValueType1;
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2;
-  typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
-
-  return __pstl::__internal::__invoke_if_else(
-      std::integral_constant < bool,
-      std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
-      [&]() {
-        return __pstl::__internal::__pattern_walk2_brick_n(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __n,
-            __result,
-            [](_InputIterator __begin, _Size __sz, _ForwardIterator __res) {
-              return __pstl::__internal::__brick_copy_n(__begin, __sz, __res, __is_vector{});
-            });
-      },
-      [&]() {
-        return __pstl::__internal::__pattern_walk2_n(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __n,
-            __result,
-            [](_ReferenceType1 __val1, _ReferenceType2 __val2) { ::new (std::addressof(__val2)) _ValueType2(__val1); });
-      });
-}
-
-// [uninitialized.move]
-
-template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> uninitialized_move(
-    _ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result) {
-  typedef typename iterator_traits<_InputIterator>::value_type _ValueType1;
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2;
-  typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
-
-  return __pstl::__internal::__invoke_if_else(
-      std::integral_constant < bool,
-      std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
-      [&]() {
-        return __pstl::__internal::__pattern_walk2_brick(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __last,
-            __result,
-            [](_InputIterator __begin, _InputIterator __end, _ForwardIterator __res) {
-              return __pstl::__internal::__brick_copy(__begin, __end, __res, __is_vector{});
-            });
-      },
-      [&]() {
-        return __pstl::__internal::__pattern_walk2(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __last,
-            __result,
-            [](_ReferenceType1 __val1, _ReferenceType2 __val2) {
-              ::new (std::addressof(__val2)) _ValueType2(std::move(__val1));
-            });
-      });
-}
-
-template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result) {
-  typedef typename iterator_traits<_InputIterator>::value_type _ValueType1;
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType2;
-  typedef typename iterator_traits<_InputIterator>::reference _ReferenceType1;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType2;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
-
-  return __pstl::__internal::__invoke_if_else(
-      std::integral_constant < bool,
-      std::is_trivial<_ValueType1>::value&& std::is_trivial<_ValueType2>::value > (),
-      [&]() {
-        return __pstl::__internal::__pattern_walk2_brick_n(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __n,
-            __result,
-            [](_InputIterator __begin, _Size __sz, _ForwardIterator __res) {
-              return __pstl::__internal::__brick_copy_n(__begin, __sz, __res, __is_vector{});
-            });
-      },
-      [&]() {
-        return __pstl::__internal::__pattern_walk2_n(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __n,
-            __result,
-            [](_ReferenceType1 __val1, _ReferenceType2 __val2) {
-              ::new (std::addressof(__val2)) _ValueType2(std::move(__val1));
-            });
-      });
-}
-
-// [uninitialized.fill]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
-
-  __pstl::__internal::__invoke_if_else(
-      std::is_arithmetic<_ValueType>(),
-      [&]() {
-        __pstl::__internal::__pattern_walk_brick(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __last,
-            [&__value](_ForwardIterator __begin, _ForwardIterator __end) {
-              __pstl::__internal::__brick_fill(__begin, __end, _ValueType(__value), __is_vector{});
-            });
-      },
-      [&]() {
-        __pstl::__internal::__pattern_walk1(
-            __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, [&__value](_ReferenceType __val) {
-              ::new (std::addressof(__val)) _ValueType(__value);
-            });
-      });
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value) {
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
-
-  return __pstl::__internal::__invoke_if_else(
-      std::is_arithmetic<_ValueType>(),
-      [&]() {
-        return __pstl::__internal::__pattern_walk_brick_n(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __n,
-            [&__value](_ForwardIterator __begin, _Size __count) {
-              return __pstl::__internal::__brick_fill_n(__begin, __count, _ValueType(__value), __is_vector{});
-            });
-      },
-      [&]() {
-        return __pstl::__internal::__pattern_walk1_n(
-            __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __n, [&__value](_ReferenceType __val) {
-              ::new (std::addressof(__val)) _ValueType(__value);
-            });
-      });
-}
-
-// [specialized.destroy]
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  __pstl::__internal::__invoke_if_not(std::is_trivially_destructible<_ValueType>(), [&]() {
-    __pstl::__internal::__pattern_walk1(
-        __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, [](_ReferenceType __val) {
-          __val.~_ValueType();
-        });
-  });
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n) {
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  return __pstl::__internal::__invoke_if_else(
-      std::is_trivially_destructible<_ValueType>(),
-      [&]() { return std::next(__first, __n); },
-      [&]() {
-        return __pstl::__internal::__pattern_walk1_n(
-            __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __n, [](_ReferenceType __val) {
-              __val.~_ValueType();
-            });
-      });
-}
-
-// [uninitialized.construct.default]
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  __pstl::__internal::__invoke_if_not(std::is_trivial<_ValueType>(), [&]() {
-    __pstl::__internal::__pattern_walk1(
-        __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, [](_ReferenceType __val) {
-          ::new (std::addressof(__val)) _ValueType;
-        });
-  });
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n) {
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  return __pstl::__internal::__invoke_if_else(
-      std::is_trivial<_ValueType>(),
-      [&]() { return std::next(__first, __n); },
-      [&]() {
-        return __pstl::__internal::__pattern_walk1_n(
-            __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __n, [](_ReferenceType __val) {
-              ::new (std::addressof(__val)) _ValueType;
-            });
-      });
-}
-
-// [uninitialized.construct.value]
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
-uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
-
-  __pstl::__internal::__invoke_if_else(
-      std::is_trivial<_ValueType>(),
-      [&]() {
-        __pstl::__internal::__pattern_walk_brick(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __last,
-            [](_ForwardIterator __begin, _ForwardIterator __end) {
-              __pstl::__internal::__brick_fill(__begin, __end, _ValueType(), __is_vector{});
-            });
-      },
-      [&]() {
-        __pstl::__internal::__pattern_walk1(
-            __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, [](_ReferenceType __val) {
-              ::new (std::addressof(__val)) _ValueType();
-            });
-      });
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
-uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n) {
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  typedef typename iterator_traits<_ForwardIterator>::reference _ReferenceType;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-
-  using __is_vector = typename decltype(__dispatch_tag)::__is_vector;
-
-  return __pstl::__internal::__invoke_if_else(
-      std::is_trivial<_ValueType>(),
-      [&]() {
-        return __pstl::__internal::__pattern_walk_brick_n(
-            __dispatch_tag,
-            std::forward<_ExecutionPolicy>(__exec),
-            __first,
-            __n,
-            [](_ForwardIterator __begin, _Size __count) {
-              return __pstl::__internal::__brick_fill_n(__begin, __count, _ValueType(), __is_vector{});
-            });
-      },
-      [&]() {
-        return __pstl::__internal::__pattern_walk1_n(
-            __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __n, [](_ReferenceType __val) {
-              ::new (std::addressof(__val)) _ValueType();
-            });
-      });
-}
-
-} // namespace std
-
-#endif /* _PSTL_GLUE_MEMORY_IMPL_H */
diff --git a/third_party/libcxx/__pstl/internal/glue_numeric_defs.h b/third_party/libcxx/__pstl/internal/glue_numeric_defs.h
deleted file mode 100644
index 9ce35e362..000000000
--- a/third_party/libcxx/__pstl/internal/glue_numeric_defs.h
+++ /dev/null
@@ -1,175 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_GLUE_NUMERIC_DEFS_H
-#define _PSTL_GLUE_NUMERIC_DEFS_H
-
-#include <__config>
-#include <iterator>
-
-#include "execution_defs.h"
-
-namespace std {
-// [reduce]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
-reduce(_ExecutionPolicy&& __exec,
-       _ForwardIterator __first,
-       _ForwardIterator __last,
-       _Tp __init,
-       _BinaryOperation __binary_op);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
-reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init);
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
-                                                 typename iterator_traits<_ForwardIterator>::value_type>
-reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _Tp __init);
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _Tp,
-          class _BinaryOperation1,
-          class _BinaryOperation2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _Tp __init,
-    _BinaryOperation1 __binary_op1,
-    _BinaryOperation2 __binary_op2);
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op);
-
-// [exclusive.scan]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> exclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _Tp __init);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> exclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _Tp __init,
-    _BinaryOperation __binary_op);
-
-// [inclusive.scan]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(
-    _ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _BinaryOperation __binary_op);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _BinaryOperation __binary_op,
-    _Tp __init);
-
-// [transform.exclusive.scan]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _Tp,
-          class _BinaryOperation,
-          class _UnaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_exclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op);
-
-// [transform.inclusive.scan]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _BinaryOperation,
-          class _UnaryOperation,
-          class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_inclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op,
-    _Tp __init);
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _UnaryOperation,
-          class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_inclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op);
-
-// [adjacent.difference]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __d_first,
-    _BinaryOperation op);
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(
-    _ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first);
-
-} // namespace std
-
-#endif /* _PSTL_GLUE_NUMERIC_DEFS_H */
diff --git a/third_party/libcxx/__pstl/internal/glue_numeric_impl.h b/third_party/libcxx/__pstl/internal/glue_numeric_impl.h
deleted file mode 100644
index d8666716e..000000000
--- a/third_party/libcxx/__pstl/internal/glue_numeric_impl.h
+++ /dev/null
@@ -1,319 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_GLUE_NUMERIC_IMPL_H
-#define _PSTL_GLUE_NUMERIC_IMPL_H
-
-#include <__config>
-#include <functional>
-
-#include "execution_impl.h"
-#include "numeric_fwd.h"
-#include "utils.h"
-
-namespace std {
-
-// [reduce]
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
-reduce(_ExecutionPolicy&& __exec,
-       _ForwardIterator __first,
-       _ForwardIterator __last,
-       _Tp __init,
-       _BinaryOperation __binary_op) {
-  return transform_reduce(
-      std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, __binary_op, __pstl::__internal::__no_op());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
-reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init) {
-  return transform_reduce(
-      std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, std::plus<_Tp>(), __pstl::__internal::__no_op());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
-                                                 typename iterator_traits<_ForwardIterator>::value_type>
-reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last) {
-  typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
-  return transform_reduce(
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      _ValueType{},
-      std::plus<_ValueType>(),
-      __pstl::__internal::__no_op());
-}
-
-// [transform.reduce]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _Tp __init) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
-
-  typedef typename iterator_traits<_ForwardIterator1>::value_type _InputType;
-  return __pstl::__internal::__pattern_transform_reduce(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first1,
-      __last1,
-      __first2,
-      __init,
-      std::plus<_InputType>(),
-      std::multiplies<_InputType>());
-}
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _Tp,
-          class _BinaryOperation1,
-          class _BinaryOperation2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _Tp __init,
-    _BinaryOperation1 __binary_op1,
-    _BinaryOperation2 __binary_op2) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first1, __first2);
-  return __pstl::__internal::__pattern_transform_reduce(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first1,
-      __last1,
-      __first2,
-      __init,
-      __binary_op1,
-      __binary_op2);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp> transform_reduce(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first);
-  return __pstl::__internal::__pattern_transform_reduce(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __init, __binary_op, __unary_op);
-}
-
-// [exclusive.scan]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> exclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _Tp __init) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  using namespace __pstl;
-  return __internal::__pattern_transform_scan(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __result,
-      __pstl::__internal::__no_op(),
-      __init,
-      std::plus<_Tp>(),
-      /*inclusive=*/std::false_type());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> exclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _Tp __init,
-    _BinaryOperation __binary_op) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  using namespace __pstl;
-  return __internal::__pattern_transform_scan(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __result,
-      __pstl::__internal::__no_op(),
-      __init,
-      __binary_op,
-      /*inclusive=*/std::false_type());
-}
-
-// [inclusive.scan]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(
-    _ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result) {
-  typedef typename iterator_traits<_ForwardIterator1>::value_type _InputType;
-  return transform_inclusive_scan(
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __result,
-      std::plus<_InputType>(),
-      __pstl::__internal::__no_op());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _BinaryOperation __binary_op) {
-  return transform_inclusive_scan(
-      std::forward<_ExecutionPolicy>(__exec), __first, __last, __result, __binary_op, __pstl::__internal::__no_op());
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> inclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _BinaryOperation __binary_op,
-    _Tp __init) {
-  return transform_inclusive_scan(
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __result,
-      __binary_op,
-      __pstl::__internal::__no_op(),
-      __init);
-}
-
-// [transform.exclusive.scan]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _Tp,
-          class _BinaryOperation,
-          class _UnaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_exclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  return __pstl::__internal::__pattern_transform_scan(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __result,
-      __unary_op,
-      __init,
-      __binary_op,
-      /*inclusive=*/std::false_type());
-}
-
-// [transform.inclusive.scan]
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _BinaryOperation,
-          class _UnaryOperation,
-          class _Tp>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_inclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op,
-    _Tp __init) {
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __result);
-
-  return __pstl::__internal::__pattern_transform_scan(
-      __dispatch_tag,
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last,
-      __result,
-      __unary_op,
-      __init,
-      __binary_op,
-      /*inclusive=*/std::true_type());
-}
-
-template <class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _UnaryOperation,
-          class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> transform_inclusive_scan(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __result,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op) {
-  if (__first != __last) {
-    auto __tmp = __unary_op(*__first);
-    *__result  = __tmp;
-    return transform_inclusive_scan(
-        std::forward<_ExecutionPolicy>(__exec), ++__first, __last, ++__result, __binary_op, __unary_op, __tmp);
-  } else {
-    return __result;
-  }
-}
-
-// [adjacent.difference]
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(
-    _ExecutionPolicy&& __exec,
-    _ForwardIterator1 __first,
-    _ForwardIterator1 __last,
-    _ForwardIterator2 __d_first,
-    _BinaryOperation __op) {
-  if (__first == __last)
-    return __d_first;
-
-  auto __dispatch_tag = __pstl::__internal::__select_backend(__exec, __first, __d_first);
-
-  return __pstl::__internal::__pattern_adjacent_difference(
-      __dispatch_tag, std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, __op);
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
-__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2> adjacent_difference(
-    _ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first) {
-  typedef typename iterator_traits<_ForwardIterator1>::value_type _ValueType;
-  return adjacent_difference(
-      std::forward<_ExecutionPolicy>(__exec), __first, __last, __d_first, std::minus<_ValueType>());
-}
-
-} // namespace std
-
-#endif /* _PSTL_GLUE_NUMERIC_IMPL_H_ */
diff --git a/third_party/libcxx/__pstl/internal/memory_impl.h b/third_party/libcxx/__pstl/internal/memory_impl.h
deleted file mode 100644
index 5315ccd9a..000000000
--- a/third_party/libcxx/__pstl/internal/memory_impl.h
+++ /dev/null
@@ -1,106 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_MEMORY_IMPL_H
-#define _PSTL_MEMORY_IMPL_H
-
-#include <__config>
-#include <iterator>
-
-#include "unseq_backend_simd.h"
-
-namespace __pstl {
-namespace __internal {
-
-//------------------------------------------------------------------------
-// uninitialized_move
-//------------------------------------------------------------------------
-
-template <typename _ForwardIterator, typename _OutputIterator>
-_OutputIterator __brick_uninitialized_move(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __result,
-    /*vector=*/std::false_type) noexcept {
-  using _ValueType = typename std::iterator_traits<_OutputIterator>::value_type;
-  for (; __first != __last; ++__first, ++__result) {
-    ::new (std::addressof(*__result)) _ValueType(std::move(*__first));
-  }
-  return __result;
-}
-
-template <typename _RandomAccessIterator, typename _OutputIterator>
-_OutputIterator __brick_uninitialized_move(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _OutputIterator __result,
-    /*vector=*/std::true_type) noexcept {
-  using __ValueType     = typename std::iterator_traits<_OutputIterator>::value_type;
-  using _ReferenceType1 = typename std::iterator_traits<_RandomAccessIterator>::reference;
-  using _ReferenceType2 = typename std::iterator_traits<_OutputIterator>::reference;
-
-  return __unseq_backend::__simd_walk_2(
-      __first, __last - __first, __result, [](_ReferenceType1 __x, _ReferenceType2 __y) {
-        ::new (std::addressof(__y)) __ValueType(std::move(__x));
-      });
-}
-
-template <typename _Iterator>
-void __brick_destroy(_Iterator __first, _Iterator __last, /*vector*/ std::false_type) noexcept {
-  using _ValueType = typename std::iterator_traits<_Iterator>::value_type;
-
-  for (; __first != __last; ++__first)
-    __first->~_ValueType();
-}
-
-template <typename _RandomAccessIterator>
-void __brick_destroy(_RandomAccessIterator __first, _RandomAccessIterator __last, /*vector*/ std::true_type) noexcept {
-  using _ValueType     = typename std::iterator_traits<_RandomAccessIterator>::value_type;
-  using _ReferenceType = typename std::iterator_traits<_RandomAccessIterator>::reference;
-
-  __unseq_backend::__simd_walk_1(__first, __last - __first, [](_ReferenceType __x) { __x.~_ValueType(); });
-}
-
-//------------------------------------------------------------------------
-// uninitialized copy
-//------------------------------------------------------------------------
-
-template <typename _ForwardIterator, typename _OutputIterator>
-_OutputIterator __brick_uninitialized_copy(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __result,
-    /*vector=*/std::false_type) noexcept {
-  using _ValueType = typename std::iterator_traits<_OutputIterator>::value_type;
-  for (; __first != __last; ++__first, ++__result) {
-    ::new (std::addressof(*__result)) _ValueType(*__first);
-  }
-  return __result;
-}
-
-template <typename _RandomAccessIterator, typename _OutputIterator>
-_OutputIterator __brick_uninitialized_copy(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _OutputIterator __result,
-    /*vector=*/std::true_type) noexcept {
-  using __ValueType     = typename std::iterator_traits<_OutputIterator>::value_type;
-  using _ReferenceType1 = typename std::iterator_traits<_RandomAccessIterator>::reference;
-  using _ReferenceType2 = typename std::iterator_traits<_OutputIterator>::reference;
-
-  return __unseq_backend::__simd_walk_2(
-      __first, __last - __first, __result, [](_ReferenceType1 __x, _ReferenceType2 __y) {
-        ::new (std::addressof(__y)) __ValueType(__x);
-      });
-}
-
-} // namespace __internal
-} // namespace __pstl
-
-#endif /* _PSTL_MEMORY_IMPL_H */
diff --git a/third_party/libcxx/__pstl/internal/numeric_fwd.h b/third_party/libcxx/__pstl/internal/numeric_fwd.h
deleted file mode 100644
index 258a925f6..000000000
--- a/third_party/libcxx/__pstl/internal/numeric_fwd.h
+++ /dev/null
@@ -1,251 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_NUMERIC_FWD_H
-#define _PSTL_NUMERIC_FWD_H
-
-#include <__config>
-#include <type_traits>
-#include <utility>
-
-namespace __pstl {
-namespace __internal {
-
-//------------------------------------------------------------------------
-// transform_reduce (version with two binary functions, according to draft N4659)
-//------------------------------------------------------------------------
-
-template <class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Tp,
-          class _BinaryOperation1,
-          class _BinaryOperation2>
-_Tp __brick_transform_reduce(
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _Tp,
-    _BinaryOperation1,
-    _BinaryOperation2,
-    /*__is_vector=*/std::true_type) noexcept;
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
-_Tp __brick_transform_reduce(
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _Tp,
-    _BinaryOperation1,
-    _BinaryOperation2,
-    /*__is_vector=*/std::false_type) noexcept;
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _Tp,
-          class _BinaryOperation1,
-          class _BinaryOperation2>
-_Tp __pattern_transform_reduce(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1,
-    _ForwardIterator1,
-    _ForwardIterator2,
-    _Tp,
-    _BinaryOperation1,
-    _BinaryOperation2) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Tp,
-          class _BinaryOperation1,
-          class _BinaryOperation2>
-_Tp __pattern_transform_reduce(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator1,
-    _RandomAccessIterator1,
-    _RandomAccessIterator2,
-    _Tp,
-    _BinaryOperation1,
-    _BinaryOperation2);
-
-//------------------------------------------------------------------------
-// transform_reduce (version with unary and binary functions)
-//------------------------------------------------------------------------
-
-template <class _RandomAccessIterator, class _Tp, class _UnaryOperation, class _BinaryOperation>
-_Tp __brick_transform_reduce(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Tp,
-    _BinaryOperation,
-    _UnaryOperation,
-    /*is_vector=*/std::true_type) noexcept;
-
-template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
-_Tp __brick_transform_reduce(
-    _ForwardIterator,
-    _ForwardIterator,
-    _Tp,
-    _BinaryOperation,
-    _UnaryOperation,
-    /*is_vector=*/std::false_type) noexcept;
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Tp,
-          class _BinaryOperation,
-          class _UnaryOperation>
-_Tp __pattern_transform_reduce(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _Tp, _BinaryOperation, _UnaryOperation) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _Tp,
-          class _BinaryOperation,
-          class _UnaryOperation>
-_Tp __pattern_transform_reduce(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _Tp,
-    _BinaryOperation,
-    _UnaryOperation);
-
-//------------------------------------------------------------------------
-// transform_exclusive_scan
-//
-// walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...)
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
-std::pair<_OutputIterator, _Tp> __brick_transform_scan(
-    _ForwardIterator,
-    _ForwardIterator,
-    _OutputIterator,
-    _UnaryOperation,
-    _Tp,
-    _BinaryOperation,
-    /*Inclusive*/ std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
-std::pair<_OutputIterator, _Tp> __brick_transform_scan(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    _UnaryOperation,
-    _Tp,
-    _BinaryOperation,
-    /*Inclusive*/ std::true_type) noexcept;
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _OutputIterator,
-          class _UnaryOperation,
-          class _Tp,
-          class _BinaryOperation,
-          class _Inclusive>
-_OutputIterator __pattern_transform_scan(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator,
-    _ForwardIterator,
-    _OutputIterator,
-    _UnaryOperation,
-    _Tp,
-    _BinaryOperation,
-    _Inclusive) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _OutputIterator,
-          class _UnaryOperation,
-          class _Tp,
-          class _BinaryOperation,
-          class _Inclusive>
-typename std::enable_if<!std::is_floating_point<_Tp>::value, _OutputIterator>::type __pattern_transform_scan(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    _UnaryOperation,
-    _Tp,
-    _BinaryOperation,
-    _Inclusive);
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _OutputIterator,
-          class _UnaryOperation,
-          class _Tp,
-          class _BinaryOperation,
-          class _Inclusive>
-typename std::enable_if<std::is_floating_point<_Tp>::value, _OutputIterator>::type __pattern_transform_scan(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    _UnaryOperation,
-    _Tp,
-    _BinaryOperation,
-    _Inclusive);
-
-//------------------------------------------------------------------------
-// adjacent_difference
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
-_OutputIterator __brick_adjacent_difference(
-    _ForwardIterator,
-    _ForwardIterator,
-    _OutputIterator,
-    _BinaryOperation,
-    /*is_vector*/ std::false_type) noexcept;
-
-template <class _RandomAccessIterator, class _OutputIterator, class _BinaryOperation>
-_OutputIterator __brick_adjacent_difference(
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    _BinaryOperation,
-    /*is_vector*/ std::true_type) noexcept;
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
-_OutputIterator __pattern_adjacent_difference(
-    _Tag, _ExecutionPolicy&&, _ForwardIterator, _ForwardIterator, _OutputIterator, _BinaryOperation) noexcept;
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _OutputIterator,
-          class _BinaryOperation>
-_OutputIterator __pattern_adjacent_difference(
-    __parallel_tag<_IsVector>,
-    _ExecutionPolicy&&,
-    _RandomAccessIterator,
-    _RandomAccessIterator,
-    _OutputIterator,
-    _BinaryOperation);
-
-} // namespace __internal
-} // namespace __pstl
-
-#endif /* _PSTL_NUMERIC_FWD_H */
diff --git a/third_party/libcxx/__pstl/internal/numeric_impl.h b/third_party/libcxx/__pstl/internal/numeric_impl.h
deleted file mode 100644
index f26be1d98..000000000
--- a/third_party/libcxx/__pstl/internal/numeric_impl.h
+++ /dev/null
@@ -1,536 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_NUMERIC_IMPL_H
-#define _PSTL_NUMERIC_IMPL_H
-
-#include <__assert>
-#include <__config>
-#include <iterator>
-#include <type_traits>
-#include <numeric>
-
-#include "parallel_backend.h"
-#include "execution_impl.h"
-#include "unseq_backend_simd.h"
-#include "algorithm_fwd.h"
-
-namespace __pstl {
-namespace __internal {
-
-//------------------------------------------------------------------------
-// transform_reduce (version with two binary functions, according to draft N4659)
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
-_Tp __brick_transform_reduce(
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _Tp __init,
-    _BinaryOperation1 __binary_op1,
-    _BinaryOperation2 __binary_op2,
-    /*is_vector=*/std::false_type) noexcept {
-  return std::inner_product(__first1, __last1, __first2, __init, __binary_op1, __binary_op2);
-}
-
-template <class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Tp,
-          class _BinaryOperation1,
-          class _BinaryOperation2>
-_Tp __brick_transform_reduce(
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _Tp __init,
-    _BinaryOperation1 __binary_op1,
-    _BinaryOperation2 __binary_op2,
-    /*is_vector=*/std::true_type) noexcept {
-  typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType;
-  return __unseq_backend::__simd_transform_reduce(
-      __last1 - __first1, __init, __binary_op1, [=, &__binary_op2](_DifferenceType __i) {
-        return __binary_op2(__first1[__i], __first2[__i]);
-      });
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator1,
-          class _ForwardIterator2,
-          class _Tp,
-          class _BinaryOperation1,
-          class _BinaryOperation2>
-_Tp __pattern_transform_reduce(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator1 __first1,
-    _ForwardIterator1 __last1,
-    _ForwardIterator2 __first2,
-    _Tp __init,
-    _BinaryOperation1 __binary_op1,
-    _BinaryOperation2 __binary_op2) noexcept {
-  return __brick_transform_reduce(
-      __first1, __last1, __first2, __init, __binary_op1, __binary_op2, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _Tp,
-          class _BinaryOperation1,
-          class _BinaryOperation2>
-_Tp __pattern_transform_reduce(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first1,
-    _RandomAccessIterator1 __last1,
-    _RandomAccessIterator2 __first2,
-    _Tp __init,
-    _BinaryOperation1 __binary_op1,
-    _BinaryOperation2 __binary_op2) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    return __par_backend::__parallel_transform_reduce(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first1,
-        __last1,
-        [__first1, __first2, __binary_op2](_RandomAccessIterator1 __i) mutable {
-          return __binary_op2(*__i, *(__first2 + (__i - __first1)));
-        },
-        __init,
-        __binary_op1, // Combine
-        [__first1, __first2, __binary_op1, __binary_op2](
-            _RandomAccessIterator1 __i, _RandomAccessIterator1 __j, _Tp __init) -> _Tp {
-          return __internal::__brick_transform_reduce(
-              __i, __j, __first2 + (__i - __first1), __init, __binary_op1, __binary_op2, _IsVector{});
-        });
-  });
-}
-
-//------------------------------------------------------------------------
-// transform_reduce (version with unary and binary functions)
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
-_Tp __brick_transform_reduce(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op,
-    /*is_vector=*/std::false_type) noexcept {
-  return std::transform_reduce(__first, __last, __init, __binary_op, __unary_op);
-}
-
-template <class _RandomAccessIterator, class _Tp, class _UnaryOperation, class _BinaryOperation>
-_Tp __brick_transform_reduce(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op,
-    /*is_vector=*/std::true_type) noexcept {
-  typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
-  return __unseq_backend::__simd_transform_reduce(
-      __last - __first, __init, __binary_op, [=, &__unary_op](_DifferenceType __i) {
-        return __unary_op(__first[__i]);
-      });
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _Tp,
-          class _BinaryOperation,
-          class _UnaryOperation>
-_Tp __pattern_transform_reduce(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op) noexcept {
-  return __internal::__brick_transform_reduce(
-      __first, __last, __init, __binary_op, __unary_op, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _Tp,
-          class _BinaryOperation,
-          class _UnaryOperation>
-_Tp __pattern_transform_reduce(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _UnaryOperation __unary_op) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  return __internal::__except_handler([&]() {
-    return __par_backend::__parallel_transform_reduce(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __first,
-        __last,
-        [__unary_op](_RandomAccessIterator __i) mutable { return __unary_op(*__i); },
-        __init,
-        __binary_op,
-        [__unary_op, __binary_op](_RandomAccessIterator __i, _RandomAccessIterator __j, _Tp __init) {
-          return __internal::__brick_transform_reduce(__i, __j, __init, __binary_op, __unary_op, _IsVector{});
-        });
-  });
-}
-
-//------------------------------------------------------------------------
-// transform_exclusive_scan
-//
-// walk3 evaluates f(x,y,z) for (x,y,z) drawn from [first1,last1), [first2,...), [first3,...)
-//------------------------------------------------------------------------
-
-// Exclusive form
-template <class _ForwardIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
-std::pair<_OutputIterator, _Tp> __brick_transform_scan(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __result,
-    _UnaryOperation __unary_op,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    /*Inclusive*/ std::false_type,
-    /*is_vector=*/std::false_type) noexcept {
-  for (; __first != __last; ++__first, ++__result) {
-    *__result = __init;
-    __init = __binary_op(__init, __unary_op(*__first));
-  }
-  return std::make_pair(__result, __init);
-}
-
-// Inclusive form
-template <class _RandomAccessIterator, class _OutputIterator, class _UnaryOperation, class _Tp, class _BinaryOperation>
-std::pair<_OutputIterator, _Tp> __brick_transform_scan(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _OutputIterator __result,
-    _UnaryOperation __unary_op,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    /*Inclusive*/ std::true_type,
-    /*is_vector=*/std::false_type) noexcept {
-  for (; __first != __last; ++__first, ++__result) {
-    __init    = __binary_op(__init, __unary_op(*__first));
-    *__result = __init;
-  }
-  return std::make_pair(__result, __init);
-}
-
-// type is arithmetic and binary operation is a user defined operation.
-template <typename _Tp, typename _BinaryOperation>
-using is_arithmetic_udop =
-    std::integral_constant<bool,
-                           std::is_arithmetic<_Tp>::value && !std::is_same<_BinaryOperation, std::plus<_Tp>>::value>;
-
-// [restriction] - T shall be DefaultConstructible.
-// [violation] - default ctor of T shall set the identity value for binary_op.
-template <class _RandomAccessIterator,
-          class _OutputIterator,
-          class _UnaryOperation,
-          class _Tp,
-          class _BinaryOperation,
-          class _Inclusive>
-typename std::enable_if<!is_arithmetic_udop<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-__brick_transform_scan(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _OutputIterator __result,
-    _UnaryOperation __unary_op,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _Inclusive,
-    /*is_vector=*/std::true_type) noexcept {
-#if defined(_PSTL_UDS_PRESENT)
-  return __unseq_backend::__simd_scan(
-      __first, __last - __first, __result, __unary_op, __init, __binary_op, _Inclusive());
-#else
-  // We need to call serial brick here to call function for inclusive and exclusive scan that depends on _Inclusive()
-  // value
-  return __internal::__brick_transform_scan(
-      __first,
-      __last,
-      __result,
-      __unary_op,
-      __init,
-      __binary_op,
-      _Inclusive(),
-      /*is_vector=*/std::false_type());
-#endif
-}
-
-template <class _RandomAccessIterator,
-          class _OutputIterator,
-          class _UnaryOperation,
-          class _Tp,
-          class _BinaryOperation,
-          class _Inclusive>
-typename std::enable_if<is_arithmetic_udop<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-__brick_transform_scan(
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _OutputIterator __result,
-    _UnaryOperation __unary_op,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _Inclusive,
-    /*is_vector=*/std::true_type) noexcept {
-  return __internal::__brick_transform_scan(
-      __first,
-      __last,
-      __result,
-      __unary_op,
-      __init,
-      __binary_op,
-      _Inclusive(),
-      /*is_vector=*/std::false_type());
-}
-
-template <class _Tag,
-          class _ExecutionPolicy,
-          class _ForwardIterator,
-          class _OutputIterator,
-          class _UnaryOperation,
-          class _Tp,
-          class _BinaryOperation,
-          class _Inclusive>
-_OutputIterator __pattern_transform_scan(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __result,
-    _UnaryOperation __unary_op,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _Inclusive) noexcept {
-  return __internal::__brick_transform_scan(
-             __first, __last, __result, __unary_op, __init, __binary_op, _Inclusive(), typename _Tag::__is_vector{})
-      .first;
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _OutputIterator,
-          class _UnaryOperation,
-          class _Tp,
-          class _BinaryOperation,
-          class _Inclusive>
-typename std::enable_if<!std::is_floating_point<_Tp>::value, _OutputIterator>::type __pattern_transform_scan(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _OutputIterator __result,
-    _UnaryOperation __unary_op,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _Inclusive) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
-
-  return __internal::__except_handler([&]() {
-    __par_backend::__parallel_transform_scan(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __last - __first,
-        [__first, __unary_op](_DifferenceType __i) mutable { return __unary_op(__first[__i]); },
-        __init,
-        __binary_op,
-        [__first, __unary_op, __binary_op](_DifferenceType __i, _DifferenceType __j, _Tp __init) {
-          // Execute serial __brick_transform_reduce, due to the explicit SIMD vectorization (reduction) requires a
-          // commutative operation for the guarantee of correct scan.
-          return __internal::__brick_transform_reduce(
-              __first + __i,
-              __first + __j,
-              __init,
-              __binary_op,
-              __unary_op,
-              /*__is_vector*/ std::false_type());
-        },
-        [__first, __unary_op, __binary_op, __result](_DifferenceType __i, _DifferenceType __j, _Tp __init) {
-          return __internal::__brick_transform_scan(
-                     __first + __i,
-                     __first + __j,
-                     __result + __i,
-                     __unary_op,
-                     __init,
-                     __binary_op,
-                     _Inclusive(),
-                     _IsVector{})
-              .second;
-        });
-    return __result + (__last - __first);
-  });
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator,
-          class _OutputIterator,
-          class _UnaryOperation,
-          class _Tp,
-          class _BinaryOperation,
-          class _Inclusive>
-typename std::enable_if<std::is_floating_point<_Tp>::value, _OutputIterator>::type __pattern_transform_scan(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator __first,
-    _RandomAccessIterator __last,
-    _OutputIterator __result,
-    _UnaryOperation __unary_op,
-    _Tp __init,
-    _BinaryOperation __binary_op,
-    _Inclusive) {
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
-  _DifferenceType __n = __last - __first;
-
-  if (__n <= 0) {
-    return __result;
-  }
-  return __internal::__except_handler([&]() {
-    __par_backend::__parallel_strict_scan(
-        __backend_tag{},
-        std::forward<_ExecutionPolicy>(__exec),
-        __n,
-        __init,
-        [__first, __unary_op, __binary_op, __result](_DifferenceType __i, _DifferenceType __len) {
-          return __internal::__brick_transform_scan(
-                     __first + __i,
-                     __first + (__i + __len),
-                     __result + __i,
-                     __unary_op,
-                     _Tp{},
-                     __binary_op,
-                     _Inclusive(),
-                     _IsVector{})
-              .second;
-        },
-        __binary_op,
-        [__result, &__binary_op](_DifferenceType __i, _DifferenceType __len, _Tp __initial) {
-          return *(std::transform(__result + __i,
-                                  __result + __i + __len,
-                                  __result + __i,
-                                  [&__initial, &__binary_op](const _Tp& __x) {
-                                    return __binary_op(__initial, __x);
-                                  }) -
-                   1);
-        },
-        [](_Tp) {});
-    return __result + (__last - __first);
-  });
-}
-
-//------------------------------------------------------------------------
-// adjacent_difference
-//------------------------------------------------------------------------
-
-template <class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
-_OutputIterator __brick_adjacent_difference(
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __d_first,
-    _BinaryOperation __op,
-    /*is_vector*/ std::false_type) noexcept {
-  return std::adjacent_difference(__first, __last, __d_first, __op);
-}
-
-template <class _RandomAccessIterator1, class _RandomAccessIterator2, class BinaryOperation>
-_RandomAccessIterator2 __brick_adjacent_difference(
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __d_first,
-    BinaryOperation __op,
-    /*is_vector=*/std::true_type) noexcept {
-  _LIBCPP_ASSERT(__first != __last, "Range cannot be empty");
-
-  typedef typename std::iterator_traits<_RandomAccessIterator1>::reference _ReferenceType1;
-  typedef typename std::iterator_traits<_RandomAccessIterator2>::reference _ReferenceType2;
-
-  auto __n   = __last - __first;
-  *__d_first = *__first;
-  return __unseq_backend::__simd_walk_3(
-      __first + 1,
-      __n - 1,
-      __first,
-      __d_first + 1,
-      [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { __z = __op(__x, __y); });
-}
-
-template <class _Tag, class _ExecutionPolicy, class _ForwardIterator, class _OutputIterator, class _BinaryOperation>
-_OutputIterator __pattern_adjacent_difference(
-    _Tag,
-    _ExecutionPolicy&&,
-    _ForwardIterator __first,
-    _ForwardIterator __last,
-    _OutputIterator __d_first,
-    _BinaryOperation __op) noexcept {
-  return __internal::__brick_adjacent_difference(__first, __last, __d_first, __op, typename _Tag::__is_vector{});
-}
-
-template <class _IsVector,
-          class _ExecutionPolicy,
-          class _RandomAccessIterator1,
-          class _RandomAccessIterator2,
-          class _BinaryOperation>
-_RandomAccessIterator2 __pattern_adjacent_difference(
-    __parallel_tag<_IsVector> __tag,
-    _ExecutionPolicy&& __exec,
-    _RandomAccessIterator1 __first,
-    _RandomAccessIterator1 __last,
-    _RandomAccessIterator2 __d_first,
-    _BinaryOperation __op) {
-  _LIBCPP_ASSERT(__first != __last, "range cannot be empty");
-  typedef typename std::iterator_traits<_RandomAccessIterator1>::reference _ReferenceType1;
-  typedef typename std::iterator_traits<_RandomAccessIterator2>::reference _ReferenceType2;
-
-  using __backend_tag = typename decltype(__tag)::__backend_tag;
-
-  *__d_first = *__first;
-  __par_backend::__parallel_for(
-      __backend_tag{},
-      std::forward<_ExecutionPolicy>(__exec),
-      __first,
-      __last - 1,
-      [&__op, __d_first, __first](_RandomAccessIterator1 __b, _RandomAccessIterator1 __e) {
-        _RandomAccessIterator2 __d_b = __d_first + (__b - __first);
-        __internal::__brick_walk3(
-            __b,
-            __e,
-            __b + 1,
-            __d_b + 1,
-            [&__op](_ReferenceType1 __x, _ReferenceType1 __y, _ReferenceType2 __z) { __z = __op(__y, __x); },
-            _IsVector{});
-      });
-  return __d_first + (__last - __first);
-}
-
-} // namespace __internal
-} // namespace __pstl
-
-#endif /* _PSTL_NUMERIC_IMPL_H */
diff --git a/third_party/libcxx/__pstl/internal/omp/parallel_for.h b/third_party/libcxx/__pstl/internal/omp/parallel_for.h
deleted file mode 100644
index 0f841e531..000000000
--- a/third_party/libcxx/__pstl/internal/omp/parallel_for.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_PARALLEL_FOR_H
-#define _PSTL_INTERNAL_OMP_PARALLEL_FOR_H
-
-#include <cstddef>
-
-#include "util.h"
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-template <class _Index, class _Fp>
-void
-__parallel_for_body(_Index __first, _Index __last, _Fp __f)
-{
-    // initial partition of the iteration space into chunks
-    auto __policy = __omp_backend::__chunk_partitioner(__first, __last);
-
-    // To avoid over-subscription we use taskloop for the nested parallelism
-    _PSTL_PRAGMA(omp taskloop untied mergeable)
-    for (std::size_t __chunk = 0; __chunk < __policy.__n_chunks; ++__chunk)
-    {
-        __pstl::__omp_backend::__process_chunk(__policy, __first, __chunk, __f);
-    }
-}
-
-//------------------------------------------------------------------------
-// Notation:
-// Evaluation of brick f[i,j) for each subrange [i,j) of [first, last)
-//------------------------------------------------------------------------
-
-template <class _ExecutionPolicy, class _Index, class _Fp>
-void
-__parallel_for(__pstl::__internal::__openmp_backend_tag, _ExecutionPolicy&&, _Index __first, _Index __last, _Fp __f)
-{
-    if (omp_in_parallel())
-    {
-        // we don't create a nested parallel region in an existing parallel
-        // region: just create tasks
-        __pstl::__omp_backend::__parallel_for_body(__first, __last, __f);
-    }
-    else
-    {
-        // in any case (nested or non-nested) one parallel region is created and
-        // only one thread creates a set of tasks
-        _PSTL_PRAGMA(omp parallel)
-        _PSTL_PRAGMA(omp single nowait) { __pstl::__omp_backend::__parallel_for_body(__first, __last, __f); }
-    }
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-#endif // _PSTL_INTERNAL_OMP_PARALLEL_FOR_H
diff --git a/third_party/libcxx/__pstl/internal/omp/parallel_for_each.h b/third_party/libcxx/__pstl/internal/omp/parallel_for_each.h
deleted file mode 100644
index b9bfb0593..000000000
--- a/third_party/libcxx/__pstl/internal/omp/parallel_for_each.h
+++ /dev/null
@@ -1,59 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_PARALLEL_FOR_EACH_H
-#define _PSTL_INTERNAL_OMP_PARALLEL_FOR_EACH_H
-
-#include "util.h"
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-template <class _ForwardIterator, class _Fp>
-void
-__parallel_for_each_body(_ForwardIterator __first, _ForwardIterator __last, _Fp __f)
-{
-    using DifferenceType = typename std::iterator_traits<_ForwardIterator>::difference_type;
-    // TODO: Think of an approach to remove the std::distance call
-    auto __size = std::distance(__first, __last);
-
-    _PSTL_PRAGMA(omp taskloop untied mergeable)
-    for (DifferenceType __index = 0; __index < __size; ++__index)
-    {
-        // TODO: Think of an approach to remove the increment here each time.
-        auto __iter = std::next(__first, __index);
-        __f(*__iter);
-    }
-}
-
-template <class _ExecutionPolicy, class _ForwardIterator, class _Fp>
-void
-__parallel_for_each(_ExecutionPolicy&&, _ForwardIterator __first, _ForwardIterator __last, _Fp __f)
-{
-    if (omp_in_parallel())
-    {
-        // we don't create a nested parallel region in an existing parallel
-        // region: just create tasks
-        __pstl::__omp_backend::__parallel_for_each_body(__first, __last, __f);
-    }
-    else
-    {
-        // in any case (nested or non-nested) one parallel region is created and
-        // only one thread creates a set of tasks
-        _PSTL_PRAGMA(omp parallel)
-        _PSTL_PRAGMA(omp single nowait) { __pstl::__omp_backend::__parallel_for_each_body(__first, __last, __f); }
-    }
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-#endif // _PSTL_INTERNAL_OMP_PARALLEL_FOR_EACH_H
diff --git a/third_party/libcxx/__pstl/internal/omp/parallel_invoke.h b/third_party/libcxx/__pstl/internal/omp/parallel_invoke.h
deleted file mode 100644
index 045ccbe9a..000000000
--- a/third_party/libcxx/__pstl/internal/omp/parallel_invoke.h
+++ /dev/null
@@ -1,50 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_PARALLEL_INVOKE_H
-#define _PSTL_INTERNAL_OMP_PARALLEL_INVOKE_H
-
-#include "util.h"
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-template <typename _F1, typename _F2>
-void
-__parallel_invoke_body(_F1&& __f1, _F2&& __f2)
-{
-    _PSTL_PRAGMA(omp taskgroup)
-    {
-        _PSTL_PRAGMA(omp task untied mergeable) { std::forward<_F1>(__f1)(); }
-        _PSTL_PRAGMA(omp task untied mergeable) { std::forward<_F2>(__f2)(); }
-    }
-}
-
-template <class _ExecutionPolicy, typename _F1, typename _F2>
-void
-__parallel_invoke(__pstl::__internal::__openmp_backend_tag, _ExecutionPolicy&&, _F1&& __f1, _F2&& __f2)
-{
-    if (omp_in_parallel())
-    {
-        __pstl::__omp_backend::__parallel_invoke_body(std::forward<_F1>(__f1), std::forward<_F2>(__f2));
-    }
-    else
-    {
-        _PSTL_PRAGMA(omp parallel)
-        _PSTL_PRAGMA(omp single nowait)
-        __pstl::__omp_backend::__parallel_invoke_body(std::forward<_F1>(__f1), std::forward<_F2>(__f2));
-    }
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-#endif // _PSTL_INTERNAL_OMP_PARALLEL_INVOKE_H
diff --git a/third_party/libcxx/__pstl/internal/omp/parallel_merge.h b/third_party/libcxx/__pstl/internal/omp/parallel_merge.h
deleted file mode 100644
index e6f82c5e1..000000000
--- a/third_party/libcxx/__pstl/internal/omp/parallel_merge.h
+++ /dev/null
@@ -1,98 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_PARALLEL_MERGE_H
-#define _PSTL_INTERNAL_OMP_PARALLEL_MERGE_H
-
-#include "util.h"
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3,
-          typename _Compare, typename _LeafMerge>
-void
-__parallel_merge_body(std::size_t __size_x, std::size_t __size_y, _RandomAccessIterator1 __xs,
-                      _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye,
-                      _RandomAccessIterator3 __zs, _Compare __comp, _LeafMerge __leaf_merge)
-{
-
-    if (__size_x + __size_y <= __omp_backend::__default_chunk_size)
-    {
-        __leaf_merge(__xs, __xe, __ys, __ye, __zs, __comp);
-        return;
-    }
-
-    _RandomAccessIterator1 __xm;
-    _RandomAccessIterator2 __ym;
-
-    if (__size_x < __size_y)
-    {
-        __ym = __ys + (__size_y / 2);
-        __xm = std::upper_bound(__xs, __xe, *__ym, __comp);
-    }
-    else
-    {
-        __xm = __xs + (__size_x / 2);
-        __ym = std::lower_bound(__ys, __ye, *__xm, __comp);
-    }
-
-    auto __zm = __zs + (__xm - __xs) + (__ym - __ys);
-
-    _PSTL_PRAGMA(omp task untied mergeable default(none)
-                     firstprivate(__xs, __xm, __ys, __ym, __zs, __comp, __leaf_merge))
-    __pstl::__omp_backend::__parallel_merge_body(__xm - __xs, __ym - __ys, __xs, __xm, __ys, __ym, __zs, __comp,
-                                                      __leaf_merge);
-
-    _PSTL_PRAGMA(omp task untied mergeable default(none)
-                     firstprivate(__xm, __xe, __ym, __ye, __zm, __comp, __leaf_merge))
-    __pstl::__omp_backend::__parallel_merge_body(__xe - __xm, __ye - __ym, __xm, __xe, __ym, __ye, __zm, __comp,
-                                                      __leaf_merge);
-
-    _PSTL_PRAGMA(omp taskwait)
-}
-
-template <class _ExecutionPolicy, typename _RandomAccessIterator1, typename _RandomAccessIterator2,
-          typename _RandomAccessIterator3, typename _Compare, typename _LeafMerge>
-void
-__parallel_merge(__pstl::__internal::__openmp_backend_tag, _ExecutionPolicy&& /*__exec*/, _RandomAccessIterator1 __xs,
-                 _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye,
-                 _RandomAccessIterator3 __zs, _Compare __comp, _LeafMerge __leaf_merge)
-
-{
-    std::size_t __size_x = __xe - __xs;
-    std::size_t __size_y = __ye - __ys;
-
-    /*
-     * Run the merge in parallel by chunking it up. Use the smaller range (if any) as the iteration range, and the
-     * larger range as the search range.
-     */
-
-    if (omp_in_parallel())
-    {
-        __pstl::__omp_backend::__parallel_merge_body(__size_x, __size_y, __xs, __xe, __ys, __ye, __zs, __comp,
-                                                          __leaf_merge);
-    }
-    else
-    {
-        _PSTL_PRAGMA(omp parallel)
-        {
-            _PSTL_PRAGMA(omp single nowait)
-            __pstl::__omp_backend::__parallel_merge_body(__size_x, __size_y, __xs, __xe, __ys, __ye, __zs, __comp,
-                                                              __leaf_merge);
-        }
-    }
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-#endif // _PSTL_INTERNAL_OMP_PARALLEL_MERGE_H
diff --git a/third_party/libcxx/__pstl/internal/omp/parallel_reduce.h b/third_party/libcxx/__pstl/internal/omp/parallel_reduce.h
deleted file mode 100644
index 841d48fc3..000000000
--- a/third_party/libcxx/__pstl/internal/omp/parallel_reduce.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_PARALLEL_REDUCE_H
-#define _PSTL_INTERNAL_OMP_PARALLEL_REDUCE_H
-
-#include "util.h"
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-template <class _RandomAccessIterator, class _Value, typename _RealBody, typename _Reduction>
-_Value
-__parallel_reduce_body(_RandomAccessIterator __first, _RandomAccessIterator __last, _Value __identity,
-                       _RealBody __real_body, _Reduction __reduce)
-{
-    if (__should_run_serial(__first, __last))
-    {
-        return __real_body(__first, __last, __identity);
-    }
-
-    auto __middle = __first + ((__last - __first) / 2);
-    _Value __v1(__identity), __v2(__identity);
-    __parallel_invoke_body(
-        [&]() { __v1 = __parallel_reduce_body(__first, __middle, __identity, __real_body, __reduce); },
-        [&]() { __v2 = __parallel_reduce_body(__middle, __last, __identity, __real_body, __reduce); });
-
-    return __reduce(__v1, __v2);
-}
-
-//------------------------------------------------------------------------
-// Notation:
-//      r(i,j,init) returns reduction of init with reduction over [i,j)
-//      c(x,y) combines values x and y that were the result of r
-//------------------------------------------------------------------------
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _Value, typename _RealBody, typename _Reduction>
-_Value
-__parallel_reduce(__pstl::__internal::__openmp_backend_tag, _ExecutionPolicy&&, _RandomAccessIterator __first,
-                  _RandomAccessIterator __last, _Value __identity, _RealBody __real_body, _Reduction __reduction)
-{
-    // We don't create a nested parallel region in an existing parallel region:
-    // just create tasks.
-    if (omp_in_parallel())
-    {
-        return __pstl::__omp_backend::__parallel_reduce_body(__first, __last, __identity, __real_body, __reduction);
-    }
-
-    // In any case (nested or non-nested) one parallel region is created and only
-    // one thread creates a set of tasks.
-    _Value __res = __identity;
-
-    _PSTL_PRAGMA(omp parallel)
-    _PSTL_PRAGMA(omp single nowait)
-    {
-        __res = __pstl::__omp_backend::__parallel_reduce_body(__first, __last, __identity, __real_body, __reduction);
-    }
-
-    return __res;
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-#endif // _PSTL_INTERNAL_OMP_PARALLEL_REDUCE_H
diff --git a/third_party/libcxx/__pstl/internal/omp/parallel_scan.h b/third_party/libcxx/__pstl/internal/omp/parallel_scan.h
deleted file mode 100644
index f3eb967ca..000000000
--- a/third_party/libcxx/__pstl/internal/omp/parallel_scan.h
+++ /dev/null
@@ -1,136 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_PARALLEL_SCAN_H
-#define _PSTL_INTERNAL_OMP_PARALLEL_SCAN_H
-
-#include "parallel_invoke.h"
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-template <typename _Index>
-_Index
-__split(_Index __m)
-{
-    _Index __k = 1;
-    while (2 * __k < __m)
-        __k *= 2;
-    return __k;
-}
-
-template <typename _Index, typename _Tp, typename _Rp, typename _Cp>
-void
-__upsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Rp __reduce, _Cp __combine)
-{
-    if (__m == 1)
-        __r[0] = __reduce(__i * __tilesize, __lastsize);
-    else
-    {
-        _Index __k = __split(__m);
-        __omp_backend::__parallel_invoke_body(
-            [=] { __omp_backend::__upsweep(__i, __k, __tilesize, __r, __tilesize, __reduce, __combine); },
-            [=] {
-                __omp_backend::__upsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize, __reduce, __combine);
-            });
-        if (__m == 2 * __k)
-            __r[__m - 1] = __combine(__r[__k - 1], __r[__m - 1]);
-    }
-}
-
-template <typename _Index, typename _Tp, typename _Cp, typename _Sp>
-void
-__downsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Tp __initial, _Cp __combine,
-            _Sp __scan)
-{
-    if (__m == 1)
-        __scan(__i * __tilesize, __lastsize, __initial);
-    else
-    {
-        const _Index __k = __split(__m);
-        __omp_backend::__parallel_invoke_body(
-            [=] { __omp_backend::__downsweep(__i, __k, __tilesize, __r, __tilesize, __initial, __combine, __scan); },
-            // Assumes that __combine never throws.
-            // TODO: Consider adding a requirement for user functors to be constant.
-            [=, &__combine]
-            {
-                __omp_backend::__downsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize,
-                                           __combine(__initial, __r[__k - 1]), __combine, __scan);
-            });
-    }
-}
-
-template <typename _ExecutionPolicy, typename _Index, typename _Tp, typename _Rp, typename _Cp, typename _Sp,
-          typename _Ap>
-void
-__parallel_strict_scan_body(_Index __n, _Tp __initial, _Rp __reduce, _Cp __combine, _Sp __scan, _Ap __apex)
-{
-    _Index __p = omp_get_num_threads();
-    const _Index __slack = 4;
-    _Index __tilesize = (__n - 1) / (__slack * __p) + 1;
-    _Index __m = (__n - 1) / __tilesize;
-    __buffer<_Tp> __buf(__m + 1);
-    _Tp* __r = __buf.get();
-
-    __omp_backend::__upsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __reduce, __combine);
-
-    std::size_t __k = __m + 1;
-    _Tp __t = __r[__k - 1];
-    while ((__k &= __k - 1))
-    {
-        __t = __combine(__r[__k - 1], __t);
-    }
-
-    __apex(__combine(__initial, __t));
-    __omp_backend::__downsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __initial,
-                               __combine, __scan);
-}
-
-template <class _ExecutionPolicy, typename _Index, typename _Tp, typename _Rp, typename _Cp, typename _Sp, typename _Ap>
-void
-__parallel_strict_scan(__pstl::__internal::__openmp_backend_tag, _ExecutionPolicy&&, _Index __n, _Tp __initial,
-                       _Rp __reduce, _Cp __combine, _Sp __scan, _Ap __apex)
-{
-    if (__n <= __default_chunk_size)
-    {
-        _Tp __sum = __initial;
-        if (__n)
-        {
-            __sum = __combine(__sum, __reduce(_Index(0), __n));
-        }
-        __apex(__sum);
-        if (__n)
-        {
-            __scan(_Index(0), __n, __initial);
-        }
-        return;
-    }
-
-    if (omp_in_parallel())
-    {
-        __pstl::__omp_backend::__parallel_strict_scan_body<_ExecutionPolicy>(__n, __initial, __reduce, __combine,
-                                                                             __scan, __apex);
-    }
-    else
-    {
-        _PSTL_PRAGMA(omp parallel)
-        _PSTL_PRAGMA(omp single nowait)
-        {
-            __pstl::__omp_backend::__parallel_strict_scan_body<_ExecutionPolicy>(__n, __initial, __reduce, __combine,
-                                                                                 __scan, __apex);
-        }
-    }
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-#endif // _PSTL_INTERNAL_OMP_PARALLEL_SCAN_H
diff --git a/third_party/libcxx/__pstl/internal/omp/parallel_stable_partial_sort.h b/third_party/libcxx/__pstl/internal/omp/parallel_stable_partial_sort.h
deleted file mode 100644
index 06cd55bb4..000000000
--- a/third_party/libcxx/__pstl/internal/omp/parallel_stable_partial_sort.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_PARALLEL_STABLE_PARTIAL_SORT_H
-#define _PSTL_INTERNAL_OMP_PARALLEL_STABLE_PARTIAL_SORT_H
-
-#include "util.h"
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-template <typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
-void
-__parallel_stable_partial_sort(__pstl::__internal::__openmp_backend_tag, _RandomAccessIterator __xs,
-                               _RandomAccessIterator __xe, _Compare __comp, _LeafSort __leaf_sort,
-                               std::size_t /* __nsort */)
-{
-    // TODO: "Parallel partial sort needs to be implemented.");
-    __leaf_sort(__xs, __xe, __comp);
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-#endif // _PSTL_INTERNAL_OMP_PARALLEL_STABLE_PARTIAL_SORT_H
diff --git a/third_party/libcxx/__pstl/internal/omp/parallel_stable_sort.h b/third_party/libcxx/__pstl/internal/omp/parallel_stable_sort.h
deleted file mode 100644
index e4d067662..000000000
--- a/third_party/libcxx/__pstl/internal/omp/parallel_stable_sort.h
+++ /dev/null
@@ -1,160 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_PARALLEL_STABLE_SORT_H
-#define _PSTL_INTERNAL_OMP_PARALLEL_STABLE_SORT_H
-
-#include "util.h"
-#include "parallel_merge.h"
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-namespace __sort_details
-{
-struct __move_value
-{
-    template <typename _Iterator, typename _OutputIterator>
-    void
-    operator()(_Iterator __x, _OutputIterator __z) const
-    {
-        *__z = std::move(*__x);
-    }
-};
-
-template <typename _RandomAccessIterator, typename _OutputIterator>
-_OutputIterator
-__parallel_move_range(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _OutputIterator __d_first)
-{
-    std::size_t __size = __last1 - __first1;
-
-    // Perform serial moving of small chunks
-
-    if (__size <= __default_chunk_size)
-    {
-        return std::move(__first1, __last1, __d_first);
-    }
-
-    // Perform parallel moving of larger chunks
-    auto __policy = __pstl::__omp_backend::__chunk_partitioner(__first1, __last1);
-
-    _PSTL_PRAGMA(omp taskloop)
-    for (std::size_t __chunk = 0; __chunk < __policy.__n_chunks; ++__chunk)
-    {
-        __pstl::__omp_backend::__process_chunk(__policy, __first1, __chunk,
-                                       [&](auto __chunk_first, auto __chunk_last)
-                                       {
-                                           auto __chunk_offset = __chunk_first - __first1;
-                                           auto __output_it = __d_first + __chunk_offset;
-                                           std::move(__chunk_first, __chunk_last, __output_it);
-                                       });
-    }
-
-    return __d_first + __size;
-}
-
-struct __move_range
-{
-    template <typename _RandomAccessIterator, typename _OutputIterator>
-    _OutputIterator
-    operator()(_RandomAccessIterator __first1, _RandomAccessIterator __last1, _OutputIterator __d_first) const
-    {
-        return __pstl::__omp_backend::__sort_details::__parallel_move_range(__first1, __last1, __d_first);
-    }
-};
-} // namespace __sort_details
-
-template <typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
-void
-__parallel_stable_sort_body(_RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp,
-                            _LeafSort __leaf_sort)
-{
-    using _ValueType = typename std::iterator_traits<_RandomAccessIterator>::value_type;
-    using _VecType = typename std::vector<_ValueType>;
-    using _OutputIterator = typename _VecType::iterator;
-    using _MoveValue = typename __omp_backend::__sort_details::__move_value;
-    using _MoveRange = __omp_backend::__sort_details::__move_range;
-
-    if (__should_run_serial(__xs, __xe))
-    {
-        __leaf_sort(__xs, __xe, __comp);
-    }
-    else
-    {
-        std::size_t __size = __xe - __xs;
-        auto __mid = __xs + (__size / 2);
-        __pstl::__omp_backend::__parallel_invoke_body(
-            [&]() { __parallel_stable_sort_body(__xs, __mid, __comp, __leaf_sort); },
-            [&]() { __parallel_stable_sort_body(__mid, __xe, __comp, __leaf_sort); });
-
-        // Perform a parallel merge of the sorted ranges into __output_data.
-        _VecType __output_data(__size);
-        _MoveValue __move_value;
-        _MoveRange __move_range;
-        __utils::__serial_move_merge __merge(__size);
-        __pstl::__omp_backend::__parallel_merge_body(
-            __mid - __xs, __xe - __mid, __xs, __mid, __mid, __xe, __output_data.begin(), __comp,
-            [&__merge, &__move_value, &__move_range](_RandomAccessIterator __as, _RandomAccessIterator __ae,
-                                                     _RandomAccessIterator __bs, _RandomAccessIterator __be,
-                                                     _OutputIterator __cs, _Compare __comp)
-            { __merge(__as, __ae, __bs, __be, __cs, __comp, __move_value, __move_value, __move_range, __move_range); });
-
-        // Move the values from __output_data back in the original source range.
-        __pstl::__omp_backend::__sort_details::__parallel_move_range(__output_data.begin(), __output_data.end(), __xs);
-    }
-}
-
-template <class _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
-void
-__parallel_stable_sort(__pstl::__internal::__openmp_backend_tag __tag, _ExecutionPolicy&& /*__exec*/,
-                       _RandomAccessIterator __xs, _RandomAccessIterator __xe, _Compare __comp, _LeafSort __leaf_sort,
-                       std::size_t __nsort = 0)
-{
-    auto __count = static_cast<std::size_t>(__xe - __xs);
-    if (__count <= __default_chunk_size || __nsort < __count)
-    {
-        __leaf_sort(__xs, __xe, __comp);
-        return;
-    }
-
-    // TODO: the partial sort implementation should
-    // be shared with the other backends.
-
-    if (omp_in_parallel())
-    {
-        if (__count <= __nsort)
-        {
-            __pstl::__omp_backend::__parallel_stable_sort_body(__xs, __xe, __comp, __leaf_sort);
-        }
-        else
-        {
-            __pstl::__omp_backend::__parallel_stable_partial_sort(__tag, __xs, __xe, __comp, __leaf_sort, __nsort);
-        }
-    }
-    else
-    {
-        _PSTL_PRAGMA(omp parallel)
-        _PSTL_PRAGMA(omp single nowait)
-        if (__count <= __nsort)
-        {
-            __pstl::__omp_backend::__parallel_stable_sort_body(__xs, __xe, __comp, __leaf_sort);
-        }
-        else
-        {
-            __pstl::__omp_backend::__parallel_stable_partial_sort(__tag, __xs, __xe, __comp, __leaf_sort, __nsort);
-        }
-    }
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-#endif // _PSTL_INTERNAL_OMP_PARALLEL_STABLE_SORT_H
diff --git a/third_party/libcxx/__pstl/internal/omp/parallel_transform_reduce.h b/third_party/libcxx/__pstl/internal/omp/parallel_transform_reduce.h
deleted file mode 100644
index 1d4cc0a59..000000000
--- a/third_party/libcxx/__pstl/internal/omp/parallel_transform_reduce.h
+++ /dev/null
@@ -1,113 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_PARALLEL_TRANSFORM_REDUCE_H
-#define _PSTL_INTERNAL_OMP_PARALLEL_TRANSFORM_REDUCE_H
-
-#include "util.h"
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-//------------------------------------------------------------------------
-// parallel_transform_reduce
-//
-// Notation:
-//      r(i,j,init) returns reduction of init with reduction over [i,j)
-//      u(i) returns f(i,i+1,identity) for a hypothetical left identity element
-//      of r c(x,y) combines values x and y that were the result of r or u
-//------------------------------------------------------------------------
-
-template <class _RandomAccessIterator, class _UnaryOp, class _Value, class _Combiner, class _Reduction>
-auto
-__transform_reduce_body(_RandomAccessIterator __first, _RandomAccessIterator __last, _UnaryOp __unary_op, _Value __init,
-                        _Combiner __combiner, _Reduction __reduction)
-{
-    const std::size_t __num_threads = omp_get_num_threads();
-    const std::size_t __size = __last - __first;
-
-    // Initial partition of the iteration space into chunks. If the range is too small,
-    // this will result in a nonsense policy, so we check on the size as well below.
-    auto __policy = __omp_backend::__chunk_partitioner(__first + __num_threads, __last);
-
-    if (__size <= __num_threads || __policy.__n_chunks < 2)
-    {
-        return __reduction(__first, __last, __init);
-    }
-
-    // Here, we cannot use OpenMP UDR because we must store the init value in
-    // the combiner and it will be used several times. Although there should be
-    // the only one; we manually generate the identity elements for each thread.
-    std::vector<_Value> __accums;
-    __accums.reserve(__num_threads);
-
-    // initialize accumulators for all threads
-    for (std::size_t __i = 0; __i < __num_threads; ++__i)
-    {
-        __accums.emplace_back(__unary_op(__first + __i));
-    }
-
-    // main loop
-    _PSTL_PRAGMA(omp taskloop shared(__accums))
-    for (std::size_t __chunk = 0; __chunk < __policy.__n_chunks; ++__chunk)
-    {
-        __pstl::__omp_backend::__process_chunk(__policy, __first + __num_threads, __chunk,
-                                       [&](auto __chunk_first, auto __chunk_last)
-                                       {
-                                           auto __thread_num = omp_get_thread_num();
-                                           __accums[__thread_num] =
-                                               __reduction(__chunk_first, __chunk_last, __accums[__thread_num]);
-                                       });
-    }
-
-    // combine by accumulators
-    for (std::size_t __i = 0; __i < __num_threads; ++__i)
-    {
-        __init = __combiner(__init, __accums[__i]);
-    }
-
-    return __init;
-}
-
-template <class _ExecutionPolicy, class _RandomAccessIterator, class _UnaryOp, class _Value, class _Combiner,
-          class _Reduction>
-_Value
-__parallel_transform_reduce(__pstl::__internal::__openmp_backend_tag, _ExecutionPolicy&&, _RandomAccessIterator __first,
-                            _RandomAccessIterator __last, _UnaryOp __unary_op, _Value __init, _Combiner __combiner,
-                            _Reduction __reduction)
-{
-    _Value __result = __init;
-    if (omp_in_parallel())
-    {
-        // We don't create a nested parallel region in an existing parallel
-        // region: just create tasks
-        __result = __pstl::__omp_backend::__transform_reduce_body(__first, __last, __unary_op, __init, __combiner,
-                                                                  __reduction);
-    }
-    else
-    {
-        // Create a parallel region, and a single thread will create tasks
-        // for the region.
-        _PSTL_PRAGMA(omp parallel)
-        _PSTL_PRAGMA(omp single nowait)
-        {
-            __result = __pstl::__omp_backend::__transform_reduce_body(__first, __last, __unary_op, __init, __combiner,
-                                                                      __reduction);
-        }
-    }
-
-    return __result;
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-#endif // _PSTL_INTERNAL_OMP_PARALLEL_TRANSFORM_REDUCE_H
diff --git a/third_party/libcxx/__pstl/internal/omp/parallel_transform_scan.h b/third_party/libcxx/__pstl/internal/omp/parallel_transform_scan.h
deleted file mode 100644
index f83628994..000000000
--- a/third_party/libcxx/__pstl/internal/omp/parallel_transform_scan.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_PARALLEL_TRANSFORM_SCAN_H
-#define _PSTL_INTERNAL_OMP_PARALLEL_TRANSFORM_SCAN_H
-
-#include "util.h"
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-template <class _ExecutionPolicy, class _Index, class _Up, class _Tp, class _Cp, class _Rp, class _Sp>
-_Tp
-__parallel_transform_scan(__pstl::__internal::__openmp_backend_tag, _ExecutionPolicy&&, _Index __n, _Up /* __u */,
-                          _Tp __init, _Cp /* __combine */, _Rp /* __brick_reduce */, _Sp __scan)
-{
-    // TODO: parallelize this function.
-    return __scan(_Index(0), __n, __init);
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-#endif // _PSTL_INTERNAL_OMP_PARALLEL_TRANSFORM_SCAN_H
diff --git a/third_party/libcxx/__pstl/internal/omp/util.h b/third_party/libcxx/__pstl/internal/omp/util.h
deleted file mode 100644
index 23604c488..000000000
--- a/third_party/libcxx/__pstl/internal/omp/util.h
+++ /dev/null
@@ -1,171 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_INTERNAL_OMP_UTIL_H
-#define _PSTL_INTERNAL_OMP_UTIL_H
-
-#include <algorithm>
-#include <atomic>
-#include <iterator>
-#include <cstddef>
-#include <cstdio>
-#include <memory>
-#include <vector>
-#include <omp.h>
-
-#include "third_party/libcxx/__pstl/internal/parallel_backend_utils.h"
-#include "third_party/libcxx/__pstl/internal/unseq_backend_simd.h"
-#include "third_party/libcxx/__pstl/internal/utils.h"
-
-// Portability "#pragma" definition
-#ifdef _MSC_VER
-#    define _PSTL_PRAGMA(x) __pragma(x)
-#else
-#    define _PSTL_PRAGMA(x) _Pragma(#    x)
-#endif
-
-namespace __pstl
-{
-namespace __omp_backend
-{
-
-//------------------------------------------------------------------------
-// use to cancel execution
-//------------------------------------------------------------------------
-inline void
-__cancel_execution()
-{
-    // TODO: Figure out how to make cancelation work.
-}
-
-//------------------------------------------------------------------------
-// raw buffer
-//------------------------------------------------------------------------
-
-template <typename _Tp>
-class __buffer
-{
-    std::allocator<_Tp> __allocator_;
-    _Tp* __ptr_;
-    const std::size_t __buf_size_;
-    __buffer(const __buffer&) = delete;
-    void
-    operator=(const __buffer&) = delete;
-
-  public:
-    __buffer(std::size_t __n) : __allocator_(), __ptr_(__allocator_.allocate(__n)), __buf_size_(__n) {}
-
-    operator bool() const { return __ptr_ != nullptr; }
-
-    _Tp*
-    get() const
-    {
-        return __ptr_;
-    }
-    ~__buffer() { __allocator_.deallocate(__ptr_, __buf_size_); }
-};
-
-// Preliminary size of each chunk: requires further discussion
-inline constexpr std::size_t __default_chunk_size = 2048;
-
-// Convenience function to determine when we should run serial.
-template <typename _Iterator, std::enable_if_t<!std::is_integral<_Iterator>::value, bool> = true>
-constexpr auto
-__should_run_serial(_Iterator __first, _Iterator __last) -> bool
-{
-    using _difference_type = typename std::iterator_traits<_Iterator>::difference_type;
-    auto __size = std::distance(__first, __last);
-    return __size <= static_cast<_difference_type>(__default_chunk_size);
-}
-
-template <typename _Index, std::enable_if_t<std::is_integral<_Index>::value, bool> = true>
-constexpr auto
-__should_run_serial(_Index __first, _Index __last) -> bool
-{
-    using _difference_type = _Index;
-    auto __size = __last - __first;
-    return __size <= static_cast<_difference_type>(__default_chunk_size);
-}
-
-struct __chunk_metrics
-{
-    std::size_t __n_chunks;
-    std::size_t __chunk_size;
-    std::size_t __first_chunk_size;
-};
-
-// The iteration space partitioner according to __requested_chunk_size
-template <class _RandomAccessIterator, class _Size = std::size_t>
-auto
-__chunk_partitioner(_RandomAccessIterator __first, _RandomAccessIterator __last,
-                    _Size __requested_chunk_size = __default_chunk_size) -> __chunk_metrics
-{
-    /*
-     * This algorithm improves distribution of elements in chunks by avoiding
-     * small tail chunks. The leftover elements that do not fit neatly into
-     * the chunk size are redistributed to early chunks. This improves
-     * utilization of the processor's prefetch and reduces the number of
-     * tasks needed by 1.
-     */
-
-    const _Size __n = __last - __first;
-    _Size __n_chunks = 0;
-    _Size __chunk_size = 0;
-    _Size __first_chunk_size = 0;
-    if (__n < __requested_chunk_size)
-    {
-        __chunk_size = __n;
-        __first_chunk_size = __n;
-        __n_chunks = 1;
-        return __chunk_metrics{__n_chunks, __chunk_size, __first_chunk_size};
-    }
-
-    __n_chunks = (__n / __requested_chunk_size) + 1;
-    __chunk_size = __n / __n_chunks;
-    __first_chunk_size = __chunk_size;
-    const _Size __n_leftover_items = __n - (__n_chunks * __chunk_size);
-
-    if (__n_leftover_items == __chunk_size)
-    {
-        __n_chunks += 1;
-        return __chunk_metrics{__n_chunks, __chunk_size, __first_chunk_size};
-    }
-    else if (__n_leftover_items == 0)
-    {
-        __first_chunk_size = __chunk_size;
-        return __chunk_metrics{__n_chunks, __chunk_size, __first_chunk_size};
-    }
-
-    const _Size __n_extra_items_per_chunk = __n_leftover_items / __n_chunks;
-    const _Size __n_final_leftover_items = __n_leftover_items - (__n_extra_items_per_chunk * __n_chunks);
-
-    __chunk_size += __n_extra_items_per_chunk;
-    __first_chunk_size = __chunk_size + __n_final_leftover_items;
-
-    return __chunk_metrics{__n_chunks, __chunk_size, __first_chunk_size};
-}
-
-template <typename _Iterator, typename _Index, typename _Func>
-void
-__process_chunk(const __chunk_metrics& __metrics, _Iterator __base, _Index __chunk_index, _Func __f)
-{
-    auto __this_chunk_size = __chunk_index == 0 ? __metrics.__first_chunk_size : __metrics.__chunk_size;
-    auto __index = __chunk_index == 0 ? 0
-                                      : (__chunk_index * __metrics.__chunk_size) +
-                                            (__metrics.__first_chunk_size - __metrics.__chunk_size);
-    auto __first = __base + __index;
-    auto __last = __first + __this_chunk_size;
-    __f(__first, __last);
-}
-
-} // namespace __omp_backend
-} // namespace __pstl
-
-#endif // _PSTL_INTERNAL_OMP_UTIL_H
diff --git a/third_party/libcxx/__pstl/internal/parallel_backend.h b/third_party/libcxx/__pstl/internal/parallel_backend.h
deleted file mode 100644
index 9c30ee142..000000000
--- a/third_party/libcxx/__pstl/internal/parallel_backend.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_PARALLEL_BACKEND_H
-#define _PSTL_PARALLEL_BACKEND_H
-
-#include <__config>
-
-#if defined(_PSTL_PAR_BACKEND_SERIAL)
-#    include "parallel_backend_serial.h"
-#    if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-namespace __pstl
-{
-namespace __par_backend = __serial_backend;
-} // namespace __pstl
-#    endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-#elif defined(_PSTL_PAR_BACKEND_TBB)
-#    include "parallel_backend_tbb.h"
-namespace __pstl
-{
-namespace __par_backend = __tbb_backend;
-}
-#elif defined(_PSTL_PAR_BACKEND_OPENMP)
-#    include "parallel_backend_omp.h"
-namespace __pstl
-{
-namespace __par_backend = __omp_backend;
-}
-#else
-#  error "No backend set"
-#endif
-
-#endif /* _PSTL_PARALLEL_BACKEND_H */
diff --git a/third_party/libcxx/__pstl/internal/parallel_backend_omp.h b/third_party/libcxx/__pstl/internal/parallel_backend_omp.h
deleted file mode 100644
index 3ce63a1b1..000000000
--- a/third_party/libcxx/__pstl/internal/parallel_backend_omp.h
+++ /dev/null
@@ -1,58 +0,0 @@
-// -*- C++ -*-
-// -*-===----------------------------------------------------------------------===//
-//
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_PARALLEL_BACKEND_OMP_H
-#define _PSTL_PARALLEL_BACKEND_OMP_H
-
-//------------------------------------------------------------------------
-// parallel_invoke
-//------------------------------------------------------------------------
-
-#include "third_party/libcxx/__pstl/internal/omp/parallel_invoke.h"
-
-//------------------------------------------------------------------------
-// parallel_for
-//------------------------------------------------------------------------
-
-#include "third_party/libcxx/__pstl/internal/omp/parallel_for.h"
-
-//------------------------------------------------------------------------
-// parallel_for_each
-//------------------------------------------------------------------------
-
-#include "third_party/libcxx/__pstl/internal/omp/parallel_for_each.h"
-
-//------------------------------------------------------------------------
-// parallel_reduce
-//------------------------------------------------------------------------
-
-#include "third_party/libcxx/__pstl/internal/omp/parallel_reduce.h"
-#include "third_party/libcxx/__pstl/internal/omp/parallel_transform_reduce.h"
-
-//------------------------------------------------------------------------
-// parallel_scan
-//------------------------------------------------------------------------
-
-#include "third_party/libcxx/__pstl/internal/omp/parallel_scan.h"
-#include "third_party/libcxx/__pstl/internal/omp/parallel_transform_scan.h"
-
-//------------------------------------------------------------------------
-// parallel_stable_sort
-//------------------------------------------------------------------------
-
-#include "third_party/libcxx/__pstl/internal/omp/parallel_stable_partial_sort.h"
-#include "third_party/libcxx/__pstl/internal/omp/parallel_stable_sort.h"
-
-//------------------------------------------------------------------------
-// parallel_merge
-//------------------------------------------------------------------------
-#include "third_party/libcxx/__pstl/internal/omp/parallel_merge.h"
-
-#endif //_PSTL_PARALLEL_BACKEND_OMP_H
diff --git a/third_party/libcxx/__pstl/internal/parallel_backend_serial.h b/third_party/libcxx/__pstl/internal/parallel_backend_serial.h
deleted file mode 100644
index 4714ed419..000000000
--- a/third_party/libcxx/__pstl/internal/parallel_backend_serial.h
+++ /dev/null
@@ -1,114 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_PARALLEL_BACKEND_SERIAL_H
-#define _PSTL_PARALLEL_BACKEND_SERIAL_H
-
-#include <__config>
-#include <__memory/allocator.h>
-#include <__pstl/internal/execution_impl.h>
-#include <__utility/forward.h>
-#include <cstddef>
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-namespace __pstl
-{
-namespace __serial_backend
-{
-
-template <typename _Tp>
-class __buffer
-{
-    std::allocator<_Tp> __allocator_;
-    _Tp* __ptr_;
-    const std::size_t __buf_size_;
-    __buffer(const __buffer&) = delete;
-    void
-    operator=(const __buffer&) = delete;
-
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    __buffer(std::size_t __n) : __allocator_(), __ptr_(__allocator_.allocate(__n)), __buf_size_(__n) {}
-
-    _LIBCPP_HIDE_FROM_ABI operator bool() const { return __ptr_ != nullptr; }
-    _LIBCPP_HIDE_FROM_ABI _Tp*
-    get() const
-    {
-        return __ptr_;
-    }
-    _LIBCPP_HIDE_FROM_ABI ~__buffer() { __allocator_.deallocate(__ptr_, __buf_size_); }
-};
-
-template <class _ExecutionPolicy, class _Value, class _Index, typename _RealBody, typename _Reduction>
-_LIBCPP_HIDE_FROM_ABI _Value
-__parallel_reduce(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _Index __first, _Index __last,
-                  const _Value& __identity, const _RealBody& __real_body, const _Reduction&)
-{
-    if (__first == __last)
-    {
-        return __identity;
-    }
-    else
-    {
-        return __real_body(__first, __last, __identity);
-    }
-}
-
-template <class _ExecutionPolicy, class _Index, class _UnaryOp, class _Tp, class _BinaryOp, class _Reduce>
-_LIBCPP_HIDE_FROM_ABI _Tp
-__parallel_transform_reduce(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _Index __first, _Index __last,
-                            _UnaryOp, _Tp __init, _BinaryOp, _Reduce __reduce)
-{
-    return __reduce(__first, __last, __init);
-}
-
-template <class _ExecutionPolicy, typename _Index, typename _Tp, typename _Rp, typename _Cp, typename _Sp, typename _Ap>
-_LIBCPP_HIDE_FROM_ABI void
-__parallel_strict_scan(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _Index __n, _Tp __initial,
-                       _Rp __reduce, _Cp __combine, _Sp __scan, _Ap __apex)
-{
-    _Tp __sum = __initial;
-    if (__n)
-        __sum = __combine(__sum, __reduce(_Index(0), __n));
-    __apex(__sum);
-    if (__n)
-        __scan(_Index(0), __n, __initial);
-}
-
-template <class _ExecutionPolicy, class _Index, class _UnaryOp, class _Tp, class _BinaryOp, class _Reduce, class _Scan>
-_LIBCPP_HIDE_FROM_ABI _Tp
-__parallel_transform_scan(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _Index __n, _UnaryOp,
-                          _Tp __init, _BinaryOp, _Reduce, _Scan __scan)
-{
-    return __scan(_Index(0), __n, __init);
-}
-
-template <class _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
-_LIBCPP_HIDE_FROM_ABI void
-__parallel_stable_sort(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _RandomAccessIterator __first,
-                       _RandomAccessIterator __last, _Compare __comp, _LeafSort __leaf_sort, std::size_t = 0)
-{
-    __leaf_sort(__first, __last, __comp);
-}
-
-template <class _ExecutionPolicy, typename _F1, typename _F2>
-_LIBCPP_HIDE_FROM_ABI void
-__parallel_invoke(__pstl::__internal::__serial_backend_tag, _ExecutionPolicy&&, _F1&& __f1, _F2&& __f2)
-{
-    std::forward<_F1>(__f1)();
-    std::forward<_F2>(__f2)();
-}
-
-} // namespace __serial_backend
-} // namespace __pstl
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif /* _PSTL_PARALLEL_BACKEND_SERIAL_H */
diff --git a/third_party/libcxx/__pstl/internal/parallel_backend_tbb.h b/third_party/libcxx/__pstl/internal/parallel_backend_tbb.h
deleted file mode 100644
index 41fe9d846..000000000
--- a/third_party/libcxx/__pstl/internal/parallel_backend_tbb.h
+++ /dev/null
@@ -1,1293 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_PARALLEL_BACKEND_TBB_H
-#define _PSTL_PARALLEL_BACKEND_TBB_H
-
-#include <__assert>
-#include <__config>
-#include <algorithm>
-#include <type_traits>
-
-#include "parallel_backend_utils.h"
-
-// Bring in minimal required subset of Intel TBB
-#include <tbb/blocked_range.h>
-#include <tbb/parallel_for.h>
-#include <tbb/parallel_reduce.h>
-#include <tbb/parallel_scan.h>
-#include <tbb/parallel_invoke.h>
-#include <tbb/task_arena.h>
-#include <tbb/tbb_allocator.h>
-#include <tbb/task.h>
-
-#if TBB_INTERFACE_VERSION < 10000
-#    error Intel(R) Threading Building Blocks 2018 is required; older versions are not supported.
-#endif
-
-namespace __pstl
-{
-namespace __tbb_backend
-{
-
-//! Raw memory buffer with automatic freeing and no exceptions.
-/** Some of our algorithms need to start with raw memory buffer,
-not an initialize array, because initialization/destruction
-would make the span be at least O(N). */
-// tbb::allocator can improve performance in some cases.
-template <typename _Tp>
-class __buffer
-{
-    tbb::tbb_allocator<_Tp> _M_allocator;
-    _Tp* _M_ptr;
-    const std::size_t _M_buf_size;
-    __buffer(const __buffer&) = delete;
-    void
-    operator=(const __buffer&) = delete;
-
-  public:
-    //! Try to obtain buffer of given size to store objects of _Tp type
-    __buffer(std::size_t n) : _M_allocator(), _M_ptr(_M_allocator.allocate(n)), _M_buf_size(n) {}
-    //! True if buffer was successfully obtained, zero otherwise.
-    operator bool() const { return _M_ptr != NULL; }
-    //! Return pointer to buffer, or  NULL if buffer could not be obtained.
-    _Tp*
-    get() const
-    {
-        return _M_ptr;
-    }
-    //! Destroy buffer
-    ~__buffer() { _M_allocator.deallocate(_M_ptr, _M_buf_size); }
-};
-
-// Wrapper for tbb::task
-inline void
-__cancel_execution()
-{
-#if TBB_INTERFACE_VERSION <= 12000
-    tbb::task::self().group()->cancel_group_execution();
-#else
-    tbb::task::current_context()->cancel_group_execution();
-#endif
-}
-
-//------------------------------------------------------------------------
-// parallel_for
-//------------------------------------------------------------------------
-
-template <class _Index, class _RealBody>
-class __parallel_for_body
-{
-  public:
-    __parallel_for_body(const _RealBody& __body) : _M_body(__body) {}
-    __parallel_for_body(const __parallel_for_body& __body) : _M_body(__body._M_body) {}
-    void
-    operator()(const tbb::blocked_range<_Index>& __range) const
-    {
-        _M_body(__range.begin(), __range.end());
-    }
-
-  private:
-    _RealBody _M_body;
-};
-
-//! Evaluation of brick f[i,j) for each subrange [i,j) of [first,last)
-// wrapper over tbb::parallel_for
-template <class _ExecutionPolicy, class _Index, class _Fp>
-void
-__parallel_for(__pstl::__internal::__tbb_backend_tag, _ExecutionPolicy&&, _Index __first, _Index __last, _Fp __f)
-{
-    tbb::this_task_arena::isolate([=]() {
-        tbb::parallel_for(tbb::blocked_range<_Index>(__first, __last), __parallel_for_body<_Index, _Fp>(__f));
-    });
-}
-
-//! Evaluation of brick f[i,j) for each subrange [i,j) of [first,last)
-// wrapper over tbb::parallel_reduce
-template <class _ExecutionPolicy, class _Value, class _Index, typename _RealBody, typename _Reduction>
-_Value
-__parallel_reduce(__pstl::__internal::__tbb_backend_tag, _ExecutionPolicy&&, _Index __first, _Index __last,
-                  const _Value& __identity, const _RealBody& __real_body, const _Reduction& __reduction)
-{
-    return tbb::this_task_arena::isolate([__first, __last, &__identity, &__real_body, &__reduction]() -> _Value {
-        return tbb::parallel_reduce(
-            tbb::blocked_range<_Index>(__first, __last), __identity,
-            [__real_body](const tbb::blocked_range<_Index>& __r, const _Value& __value) -> _Value {
-                return __real_body(__r.begin(), __r.end(), __value);
-            },
-            __reduction);
-    });
-}
-
-//------------------------------------------------------------------------
-// parallel_transform_reduce
-//
-// Notation:
-//      r(i,j,init) returns reduction of init with reduction over [i,j)
-//      u(i) returns f(i,i+1,identity) for a hypothetical left identity element of r
-//      c(x,y) combines values x and y that were the result of r or u
-//------------------------------------------------------------------------
-
-template <class _Index, class _Up, class _Tp, class _Cp, class _Rp>
-struct __par_trans_red_body
-{
-    alignas(_Tp) char _M_sum_storage[sizeof(_Tp)]; // Holds generalized non-commutative sum when has_sum==true
-    _Rp _M_brick_reduce;                           // Most likely to have non-empty layout
-    _Up _M_u;
-    _Cp _M_combine;
-    bool _M_has_sum; // Put last to minimize size of class
-    _Tp&
-    sum()
-    {
-        __TBB_ASSERT(_M_has_sum, "sum expected");
-        return *(_Tp*)_M_sum_storage;
-    }
-    __par_trans_red_body(_Up __u, _Tp __init, _Cp __c, _Rp __r)
-        : _M_brick_reduce(__r), _M_u(__u), _M_combine(__c), _M_has_sum(true)
-    {
-        new (_M_sum_storage) _Tp(__init);
-    }
-
-    __par_trans_red_body(__par_trans_red_body& __left, tbb::split)
-        : _M_brick_reduce(__left._M_brick_reduce), _M_u(__left._M_u), _M_combine(__left._M_combine), _M_has_sum(false)
-    {
-    }
-
-    ~__par_trans_red_body()
-    {
-        // 17.6.5.12 tells us to not worry about catching exceptions from destructors.
-        if (_M_has_sum)
-            sum().~_Tp();
-    }
-
-    void
-    join(__par_trans_red_body& __rhs)
-    {
-        sum() = _M_combine(sum(), __rhs.sum());
-    }
-
-    void
-    operator()(const tbb::blocked_range<_Index>& __range)
-    {
-        _Index __i = __range.begin();
-        _Index __j = __range.end();
-        if (!_M_has_sum)
-        {
-            __TBB_ASSERT(__range.size() > 1, "there should be at least 2 elements");
-            new (&_M_sum_storage)
-                _Tp(_M_combine(_M_u(__i), _M_u(__i + 1))); // The condition i+1 < j is provided by the grain size of 3
-            _M_has_sum = true;
-            std::advance(__i, 2);
-            if (__i == __j)
-                return;
-        }
-        sum() = _M_brick_reduce(__i, __j, sum());
-    }
-};
-
-template <class _ExecutionPolicy, class _Index, class _Up, class _Tp, class _Cp, class _Rp>
-_Tp
-__parallel_transform_reduce(__pstl::__internal::__tbb_backend_tag, _ExecutionPolicy&&, _Index __first, _Index __last,
-                            _Up __u, _Tp __init, _Cp __combine, _Rp __brick_reduce)
-{
-    __tbb_backend::__par_trans_red_body<_Index, _Up, _Tp, _Cp, _Rp> __body(__u, __init, __combine, __brick_reduce);
-    // The grain size of 3 is used in order to provide mininum 2 elements for each body
-    tbb::this_task_arena::isolate(
-        [__first, __last, &__body]() { tbb::parallel_reduce(tbb::blocked_range<_Index>(__first, __last, 3), __body); });
-    return __body.sum();
-}
-
-//------------------------------------------------------------------------
-// parallel_scan
-//------------------------------------------------------------------------
-
-template <class _Index, class _Up, class _Tp, class _Cp, class _Rp, class _Sp>
-class __trans_scan_body
-{
-    alignas(_Tp) char _M_sum_storage[sizeof(_Tp)]; // Holds generalized non-commutative sum when has_sum==true
-    _Rp _M_brick_reduce;                           // Most likely to have non-empty layout
-    _Up _M_u;
-    _Cp _M_combine;
-    _Sp _M_scan;
-    bool _M_has_sum; // Put last to minimize size of class
-  public:
-    __trans_scan_body(_Up __u, _Tp __init, _Cp __combine, _Rp __reduce, _Sp __scan)
-        : _M_brick_reduce(__reduce), _M_u(__u), _M_combine(__combine), _M_scan(__scan), _M_has_sum(true)
-    {
-        new (_M_sum_storage) _Tp(__init);
-    }
-
-    __trans_scan_body(__trans_scan_body& __b, tbb::split)
-        : _M_brick_reduce(__b._M_brick_reduce), _M_u(__b._M_u), _M_combine(__b._M_combine), _M_scan(__b._M_scan),
-          _M_has_sum(false)
-    {
-    }
-
-    ~__trans_scan_body()
-    {
-        // 17.6.5.12 tells us to not worry about catching exceptions from destructors.
-        if (_M_has_sum)
-            sum().~_Tp();
-    }
-
-    _Tp&
-    sum() const
-    {
-        __TBB_ASSERT(_M_has_sum, "sum expected");
-        return *const_cast<_Tp*>(reinterpret_cast<_Tp const*>(_M_sum_storage));
-    }
-
-    void
-    operator()(const tbb::blocked_range<_Index>& __range, tbb::pre_scan_tag)
-    {
-        _Index __i = __range.begin();
-        _Index __j = __range.end();
-        if (!_M_has_sum)
-        {
-            new (&_M_sum_storage) _Tp(_M_u(__i));
-            _M_has_sum = true;
-            ++__i;
-            if (__i == __j)
-                return;
-        }
-        sum() = _M_brick_reduce(__i, __j, sum());
-    }
-
-    void
-    operator()(const tbb::blocked_range<_Index>& __range, tbb::final_scan_tag)
-    {
-        sum() = _M_scan(__range.begin(), __range.end(), sum());
-    }
-
-    void
-    reverse_join(__trans_scan_body& __a)
-    {
-        if (_M_has_sum)
-        {
-            sum() = _M_combine(__a.sum(), sum());
-        }
-        else
-        {
-            new (&_M_sum_storage) _Tp(__a.sum());
-            _M_has_sum = true;
-        }
-    }
-
-    void
-    assign(__trans_scan_body& __b)
-    {
-        sum() = __b.sum();
-    }
-};
-
-template <typename _Index>
-_Index
-__split(_Index __m)
-{
-    _Index __k = 1;
-    while (2 * __k < __m)
-        __k *= 2;
-    return __k;
-}
-
-//------------------------------------------------------------------------
-// __parallel_strict_scan
-//------------------------------------------------------------------------
-
-template <typename _Index, typename _Tp, typename _Rp, typename _Cp>
-void
-__upsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Rp __reduce, _Cp __combine)
-{
-    if (__m == 1)
-        __r[0] = __reduce(__i * __tilesize, __lastsize);
-    else
-    {
-        _Index __k = __split(__m);
-        tbb::parallel_invoke(
-            [=] { __tbb_backend::__upsweep(__i, __k, __tilesize, __r, __tilesize, __reduce, __combine); },
-            [=] {
-                __tbb_backend::__upsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize, __reduce, __combine);
-            });
-        if (__m == 2 * __k)
-            __r[__m - 1] = __combine(__r[__k - 1], __r[__m - 1]);
-    }
-}
-
-template <typename _Index, typename _Tp, typename _Cp, typename _Sp>
-void
-__downsweep(_Index __i, _Index __m, _Index __tilesize, _Tp* __r, _Index __lastsize, _Tp __initial, _Cp __combine,
-            _Sp __scan)
-{
-    if (__m == 1)
-        __scan(__i * __tilesize, __lastsize, __initial);
-    else
-    {
-        const _Index __k = __split(__m);
-        tbb::parallel_invoke(
-            [=] { __tbb_backend::__downsweep(__i, __k, __tilesize, __r, __tilesize, __initial, __combine, __scan); },
-            // Assumes that __combine never throws.
-            //TODO: Consider adding a requirement for user functors to be constant.
-            [=, &__combine] {
-                __tbb_backend::__downsweep(__i + __k, __m - __k, __tilesize, __r + __k, __lastsize,
-                                           __combine(__initial, __r[__k - 1]), __combine, __scan);
-            });
-    }
-}
-
-// Adapted from Intel(R) Cilk(TM) version from cilkpub.
-// Let i:len denote a counted interval of length n starting at i.  s denotes a generalized-sum value.
-// Expected actions of the functors are:
-//     reduce(i,len) -> s  -- return reduction value of i:len.
-//     combine(s1,s2) -> s -- return merged sum
-//     apex(s) -- do any processing necessary between reduce and scan.
-//     scan(i,len,initial) -- perform scan over i:len starting with initial.
-// The initial range 0:n is partitioned into consecutive subranges.
-// reduce and scan are each called exactly once per subrange.
-// Thus callers can rely upon side effects in reduce.
-// combine must not throw an exception.
-// apex is called exactly once, after all calls to reduce and before all calls to scan.
-// For example, it's useful for allocating a __buffer used by scan but whose size is the sum of all reduction values.
-// T must have a trivial constructor and destructor.
-template <class _ExecutionPolicy, typename _Index, typename _Tp, typename _Rp, typename _Cp, typename _Sp, typename _Ap>
-void
-__parallel_strict_scan(__pstl::__internal::__tbb_backend_tag, _ExecutionPolicy&&, _Index __n, _Tp __initial,
-                       _Rp __reduce, _Cp __combine, _Sp __scan, _Ap __apex)
-{
-    tbb::this_task_arena::isolate([=, &__combine]() {
-        if (__n > 1)
-        {
-            _Index __p = tbb::this_task_arena::max_concurrency();
-            const _Index __slack = 4;
-            _Index __tilesize = (__n - 1) / (__slack * __p) + 1;
-            _Index __m = (__n - 1) / __tilesize;
-            __buffer<_Tp> __buf(__m + 1);
-            _Tp* __r = __buf.get();
-            __tbb_backend::__upsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __reduce,
-                                     __combine);
-
-            // When __apex is a no-op and __combine has no side effects, a good optimizer
-            // should be able to eliminate all code between here and __apex.
-            // Alternatively, provide a default value for __apex that can be
-            // recognized by metaprogramming that conditionlly executes the following.
-            size_t __k = __m + 1;
-            _Tp __t = __r[__k - 1];
-            while ((__k &= __k - 1))
-                __t = __combine(__r[__k - 1], __t);
-            __apex(__combine(__initial, __t));
-            __tbb_backend::__downsweep(_Index(0), _Index(__m + 1), __tilesize, __r, __n - __m * __tilesize, __initial,
-                                       __combine, __scan);
-            return;
-        }
-        // Fewer than 2 elements in sequence, or out of memory.  Handle has single block.
-        _Tp __sum = __initial;
-        if (__n)
-            __sum = __combine(__sum, __reduce(_Index(0), __n));
-        __apex(__sum);
-        if (__n)
-            __scan(_Index(0), __n, __initial);
-    });
-}
-
-template <class _ExecutionPolicy, class _Index, class _Up, class _Tp, class _Cp, class _Rp, class _Sp>
-_Tp
-__parallel_transform_scan(__pstl::__internal::__tbb_backend_tag, _ExecutionPolicy&&, _Index __n, _Up __u, _Tp __init,
-                          _Cp __combine, _Rp __brick_reduce, _Sp __scan)
-{
-    __trans_scan_body<_Index, _Up, _Tp, _Cp, _Rp, _Sp> __body(__u, __init, __combine, __brick_reduce, __scan);
-    auto __range = tbb::blocked_range<_Index>(0, __n);
-    tbb::this_task_arena::isolate([__range, &__body]() { tbb::parallel_scan(__range, __body); });
-    return __body.sum();
-}
-
-//------------------------------------------------------------------------
-// parallel_stable_sort
-//------------------------------------------------------------------------
-
-//------------------------------------------------------------------------
-// stable_sort utilities
-//
-// These are used by parallel implementations but do not depend on them.
-//------------------------------------------------------------------------
-#define _PSTL_MERGE_CUT_OFF 2000
-
-template <typename _Func>
-class __func_task;
-template <typename _Func>
-class __root_task;
-
-#if TBB_INTERFACE_VERSION <= 12000
-class __task : public tbb::task
-{
-  public:
-    template <typename _Fn>
-    __task*
-    make_continuation(_Fn&& __f)
-    {
-        return new (allocate_continuation()) __func_task<typename std::decay<_Fn>::type>(std::forward<_Fn>(__f));
-    }
-
-    template <typename _Fn>
-    __task*
-    make_child_of(__task* parent, _Fn&& __f)
-    {
-        return new (parent->allocate_child()) __func_task<typename std::decay<_Fn>::type>(std::forward<_Fn>(__f));
-    }
-
-    template <typename _Fn>
-    __task*
-    make_additional_child_of(tbb::task* parent, _Fn&& __f)
-    {
-        return new (tbb::task::allocate_additional_child_of(*parent))
-            __func_task<typename std::decay<_Fn>::type>(std::forward<_Fn>(__f));
-    }
-
-    inline void
-    recycle_as_continuation()
-    {
-        tbb::task::recycle_as_continuation();
-    }
-
-    inline void
-    recycle_as_child_of(__task* parent)
-    {
-        tbb::task::recycle_as_child_of(*parent);
-    }
-
-    inline void
-    spawn(__task* __t)
-    {
-        tbb::task::spawn(*__t);
-    }
-
-    template <typename _Fn>
-    static inline void
-    spawn_root_and_wait(__root_task<_Fn>& __root)
-    {
-        tbb::task::spawn_root_and_wait(*__root._M_task);
-    }
-};
-
-template <typename _Func>
-class __func_task : public __task
-{
-    _Func _M_func;
-
-    tbb::task*
-    execute()
-    {
-        return _M_func(this);
-    };
-
-  public:
-    template <typename _Fn>
-    __func_task(_Fn&& __f) : _M_func{std::forward<_Fn>(__f)}
-    {
-    }
-
-    _Func&
-    body()
-    {
-        return _M_func;
-    }
-};
-
-template <typename _Func>
-class __root_task
-{
-    tbb::task* _M_task;
-
-  public:
-    template <typename... Args>
-    __root_task(Args&&... args)
-        : _M_task{new (tbb::task::allocate_root()) __func_task<_Func>{_Func(std::forward<Args>(args)...)}}
-    {
-    }
-
-    friend class __task;
-    friend class __func_task<_Func>;
-};
-
-#else  // TBB_INTERFACE_VERSION <= 12000
-class __task : public tbb::detail::d1::task
-{
-  protected:
-    tbb::detail::d1::small_object_allocator _M_allocator{};
-    tbb::detail::d1::execution_data* _M_execute_data{};
-    __task* _M_parent{};
-    std::atomic<int> _M_refcount{};
-    bool _M_recycle{};
-
-    template <typename _Fn>
-    __task*
-    allocate_func_task(_Fn&& __f)
-    {
-        _LIBCPP_ASSERT(_M_execute_data != nullptr, "");
-        tbb::detail::d1::small_object_allocator __alloc{};
-        auto __t =
-            __alloc.new_object<__func_task<typename std::decay<_Fn>::type>>(*_M_execute_data, std::forward<_Fn>(__f));
-        __t->_M_allocator = __alloc;
-        return __t;
-    }
-
-  public:
-    __task*
-    parent()
-    {
-        return _M_parent;
-    }
-
-    void
-    set_ref_count(int __n)
-    {
-        _M_refcount.store(__n, std::memory_order_release);
-    }
-
-    template <typename _Fn>
-    __task*
-    make_continuation(_Fn&& __f)
-    {
-        auto __t = allocate_func_task(std::forward<_Fn&&>(__f));
-        __t->_M_parent = _M_parent;
-        _M_parent = nullptr;
-        return __t;
-    }
-
-    template <typename _Fn>
-    __task*
-    make_child_of(__task* __parent, _Fn&& __f)
-    {
-        auto __t = allocate_func_task(std::forward<_Fn&&>(__f));
-        __t->_M_parent = __parent;
-        return __t;
-    }
-
-    template <typename _Fn>
-    __task*
-    make_additional_child_of(__task* __parent, _Fn&& __f)
-    {
-        auto __t = make_child_of(__parent, std::forward<_Fn>(__f));
-        _LIBCPP_ASSERT(__parent->_M_refcount.load(std::memory_order_relaxed) > 0, "");
-        ++__parent->_M_refcount;
-        return __t;
-    }
-
-    inline void
-    recycle_as_continuation()
-    {
-        _M_recycle = true;
-    }
-
-    inline void
-    recycle_as_child_of(__task* parent)
-    {
-        _M_recycle = true;
-        _M_parent = parent;
-    }
-
-    inline void
-    spawn(__task* __t)
-    {
-        _LIBCPP_ASSERT(_M_execute_data != nullptr, "");
-        tbb::detail::d1::spawn(*__t, *_M_execute_data->context);
-    }
-
-    template <typename _Fn>
-    static inline void
-    spawn_root_and_wait(__root_task<_Fn>& __root)
-    {
-        tbb::detail::d1::execute_and_wait(*__root._M_func_task, __root._M_context, __root._M_wait_object,
-                                          __root._M_context);
-    }
-
-    template <typename _Func>
-    friend class __func_task;
-};
-
-template <typename _Func>
-class __func_task : public __task
-{
-    _Func _M_func;
-
-    __task*
-    execute(tbb::detail::d1::execution_data& __ed) override
-    {
-        _M_execute_data = &__ed;
-        _M_recycle = false;
-        __task* __next = _M_func(this);
-        return finalize(__next);
-    };
-
-    __task*
-    cancel(tbb::detail::d1::execution_data& __ed) override
-    {
-        return finalize(nullptr);
-    }
-
-    __task*
-    finalize(__task* __next)
-    {
-        bool __recycle = _M_recycle;
-        _M_recycle = false;
-
-        if (__recycle)
-        {
-            return __next;
-        }
-
-        auto __parent = _M_parent;
-        auto __alloc = _M_allocator;
-        auto __ed = _M_execute_data;
-
-        this->~__func_task();
-
-        _LIBCPP_ASSERT(__parent != nullptr, "");
-        _LIBCPP_ASSERT(__parent->_M_refcount.load(std::memory_order_relaxed) > 0, "");
-        if (--__parent->_M_refcount == 0)
-        {
-            _LIBCPP_ASSERT(__next == nullptr, "");
-            __alloc.deallocate(this, *__ed);
-            return __parent;
-        }
-
-        return __next;
-    }
-
-    friend class __root_task<_Func>;
-
-  public:
-    template <typename _Fn>
-    __func_task(_Fn&& __f) : _M_func(std::forward<_Fn>(__f))
-    {
-    }
-
-    _Func&
-    body()
-    {
-        return _M_func;
-    }
-};
-
-template <typename _Func>
-class __root_task : public __task
-{
-    __task*
-    execute(tbb::detail::d1::execution_data& __ed) override
-    {
-        _M_wait_object.release();
-        return nullptr;
-    };
-
-    __task*
-    cancel(tbb::detail::d1::execution_data& __ed) override
-    {
-        _M_wait_object.release();
-        return nullptr;
-    }
-
-    __func_task<_Func>* _M_func_task{};
-    tbb::detail::d1::wait_context _M_wait_object{0};
-    tbb::task_group_context _M_context{};
-
-  public:
-    template <typename... Args>
-    __root_task(Args&&... args) : _M_wait_object{1}
-    {
-        tbb::detail::d1::small_object_allocator __alloc{};
-        _M_func_task = __alloc.new_object<__func_task<_Func>>(_Func(std::forward<Args>(args)...));
-        _M_func_task->_M_allocator = __alloc;
-        _M_func_task->_M_parent = this;
-        _M_refcount.store(1, std::memory_order_relaxed);
-    }
-
-    friend class __task;
-};
-#endif // TBB_INTERFACE_VERSION <= 12000
-
-template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _Compare, typename _Cleanup,
-          typename _LeafMerge>
-class __merge_func
-{
-    typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
-    typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
-    typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType;
-    typedef typename std::iterator_traits<_RandomAccessIterator1>::value_type _ValueType;
-
-    _RandomAccessIterator1 _M_x_beg;
-    _RandomAccessIterator2 _M_z_beg;
-
-    _SizeType _M_xs, _M_xe;
-    _SizeType _M_ys, _M_ye;
-    _SizeType _M_zs;
-    _Compare _M_comp;
-    _LeafMerge _M_leaf_merge;
-    _SizeType _M_nsort; //number of elements to be sorted for partial_sort alforithm
-
-    static const _SizeType __merge_cut_off = _PSTL_MERGE_CUT_OFF;
-
-    bool _root;   //means a task is merging root task
-    bool _x_orig; //"true" means X(or left ) subrange is in the original container; false - in the buffer
-    bool _y_orig; //"true" means Y(or right) subrange is in the original container; false - in the buffer
-    bool _split; //"true" means a merge task is a split task for parallel merging, the execution logic differs
-
-    bool
-    is_partial() const
-    {
-        return _M_nsort > 0;
-    }
-
-    struct __move_value
-    {
-        template <typename Iterator1, typename Iterator2>
-        void
-        operator()(Iterator1 __x, Iterator2 __z)
-        {
-            *__z = std::move(*__x);
-        }
-    };
-
-    struct __move_value_construct
-    {
-        template <typename Iterator1, typename Iterator2>
-        void
-        operator()(Iterator1 __x, Iterator2 __z)
-        {
-            ::new (std::addressof(*__z)) _ValueType(std::move(*__x));
-        }
-    };
-
-    struct __move_range
-    {
-        template <typename Iterator1, typename Iterator2>
-        Iterator2
-        operator()(Iterator1 __first1, Iterator1 __last1, Iterator2 __first2)
-        {
-            if (__last1 - __first1 < __merge_cut_off)
-                return std::move(__first1, __last1, __first2);
-
-            auto __n = __last1 - __first1;
-            tbb::parallel_for(tbb::blocked_range<_SizeType>(0, __n, __merge_cut_off),
-                              [__first1, __first2](const tbb::blocked_range<_SizeType>& __range) {
-                                  std::move(__first1 + __range.begin(), __first1 + __range.end(),
-                                            __first2 + __range.begin());
-                              });
-            return __first2 + __n;
-        }
-    };
-
-    struct __move_range_construct
-    {
-        template <typename Iterator1, typename Iterator2>
-        Iterator2
-        operator()(Iterator1 __first1, Iterator1 __last1, Iterator2 __first2)
-        {
-            if (__last1 - __first1 < __merge_cut_off)
-            {
-                for (; __first1 != __last1; ++__first1, ++__first2)
-                    __move_value_construct()(__first1, __first2);
-                return __first2;
-            }
-
-            auto __n = __last1 - __first1;
-            tbb::parallel_for(tbb::blocked_range<_SizeType>(0, __n, __merge_cut_off),
-                              [__first1, __first2](const tbb::blocked_range<_SizeType>& __range) {
-                                  for (auto i = __range.begin(); i != __range.end(); ++i)
-                                      __move_value_construct()(__first1 + i, __first2 + i);
-                              });
-            return __first2 + __n;
-        }
-    };
-
-    struct __cleanup_range
-    {
-        template <typename Iterator>
-        void
-        operator()(Iterator __first, Iterator __last)
-        {
-            if (__last - __first < __merge_cut_off)
-                _Cleanup()(__first, __last);
-            else
-            {
-                auto __n = __last - __first;
-                tbb::parallel_for(tbb::blocked_range<_SizeType>(0, __n, __merge_cut_off),
-                                  [__first](const tbb::blocked_range<_SizeType>& __range) {
-                                      _Cleanup()(__first + __range.begin(), __first + __range.end());
-                                  });
-            }
-        }
-    };
-
-  public:
-    __merge_func(_SizeType __xs, _SizeType __xe, _SizeType __ys, _SizeType __ye, _SizeType __zs, _Compare __comp,
-                 _Cleanup, _LeafMerge __leaf_merge, _SizeType __nsort, _RandomAccessIterator1 __x_beg,
-                 _RandomAccessIterator2 __z_beg, bool __x_orig, bool __y_orig, bool __root)
-        : _M_xs(__xs), _M_xe(__xe), _M_ys(__ys), _M_ye(__ye), _M_zs(__zs), _M_x_beg(__x_beg), _M_z_beg(__z_beg),
-          _M_comp(__comp), _M_leaf_merge(__leaf_merge), _M_nsort(__nsort), _root(__root),
-          _x_orig(__x_orig), _y_orig(__y_orig), _split(false)
-    {
-    }
-
-    bool
-    is_left(_SizeType __idx) const
-    {
-        return _M_xs == __idx;
-    }
-
-    template <typename IndexType>
-    void
-    set_odd(IndexType __idx, bool __on_off)
-    {
-        if (is_left(__idx))
-            _x_orig = __on_off;
-        else
-            _y_orig = __on_off;
-    }
-
-    __task*
-    operator()(__task* __self);
-
-  private:
-    __merge_func*
-    parent_merge(__task* __self) const
-    {
-        return _root ? nullptr : &static_cast<__func_task<__merge_func>*>(__self->parent())->body();
-    }
-    bool
-    x_less_y()
-    {
-        const auto __nx = (_M_xe - _M_xs);
-        const auto __ny = (_M_ye - _M_ys);
-        _LIBCPP_ASSERT(__nx > 0 && __ny > 0, "");
-
-        _LIBCPP_ASSERT(_x_orig == _y_orig, "");
-        _LIBCPP_ASSERT(!is_partial(), "");
-
-        if (_x_orig)
-        {
-            _LIBCPP_ASSERT(std::is_sorted(_M_x_beg + _M_xs, _M_x_beg + _M_xe, _M_comp), "");
-            _LIBCPP_ASSERT(std::is_sorted(_M_x_beg + _M_ys, _M_x_beg + _M_ye, _M_comp), "");
-            return !_M_comp(*(_M_x_beg + _M_ys), *(_M_x_beg + _M_xe - 1));
-        }
-
-        _LIBCPP_ASSERT(std::is_sorted(_M_z_beg + _M_xs, _M_z_beg + _M_xe, _M_comp), "");
-        _LIBCPP_ASSERT(std::is_sorted(_M_z_beg + _M_ys, _M_z_beg + _M_ye, _M_comp), "");
-        return !_M_comp(*(_M_z_beg + _M_zs + __nx), *(_M_z_beg + _M_zs + __nx - 1));
-    }
-    void
-    move_x_range()
-    {
-        const auto __nx = (_M_xe - _M_xs);
-        const auto __ny = (_M_ye - _M_ys);
-        _LIBCPP_ASSERT(__nx > 0 && __ny > 0, "");
-
-        if (_x_orig)
-            __move_range_construct()(_M_x_beg + _M_xs, _M_x_beg + _M_xe, _M_z_beg + _M_zs);
-        else
-        {
-            __move_range()(_M_z_beg + _M_zs, _M_z_beg + _M_zs + __nx, _M_x_beg + _M_xs);
-            __cleanup_range()(_M_z_beg + _M_zs, _M_z_beg + _M_zs + __nx);
-        }
-
-        _x_orig = !_x_orig;
-    }
-    void
-    move_y_range()
-    {
-        const auto __nx = (_M_xe - _M_xs);
-        const auto __ny = (_M_ye - _M_ys);
-
-        if (_y_orig)
-            __move_range_construct()(_M_x_beg + _M_ys, _M_x_beg + _M_ye, _M_z_beg + _M_zs + __nx);
-        else
-        {
-            __move_range()(_M_z_beg + _M_zs + __nx, _M_z_beg + _M_zs + __nx + __ny, _M_x_beg + _M_ys);
-            __cleanup_range()(_M_z_beg + _M_zs + __nx, _M_z_beg + _M_zs + __nx + __ny);
-        }
-
-        _y_orig = !_y_orig;
-    }
-    __task*
-    merge_ranges(__task* __self)
-    {
-        _LIBCPP_ASSERT(_x_orig == _y_orig, ""); //two merged subrange must be lie into the same buffer
-
-        const auto __nx = (_M_xe - _M_xs);
-        const auto __ny = (_M_ye - _M_ys);
-        const auto __n = __nx + __ny;
-
-        // need to merge {x} and {y}
-        if (__n > __merge_cut_off)
-            return split_merging(__self);
-
-        //merge to buffer
-        if (_x_orig)
-        {
-            _M_leaf_merge(_M_x_beg + _M_xs, _M_x_beg + _M_xe, _M_x_beg + _M_ys, _M_x_beg + _M_ye, _M_z_beg + _M_zs,
-                          _M_comp, __move_value_construct(), __move_value_construct(), __move_range_construct(),
-                          __move_range_construct());
-            _LIBCPP_ASSERT(parent_merge(__self), ""); //not root merging task
-        }
-        //merge to "origin"
-        else
-        {
-            _LIBCPP_ASSERT(_x_orig == _y_orig, "");
-
-            _LIBCPP_ASSERT(is_partial() || std::is_sorted(_M_z_beg + _M_xs, _M_z_beg + _M_xe, _M_comp), "");
-            _LIBCPP_ASSERT(is_partial() || std::is_sorted(_M_z_beg + _M_ys, _M_z_beg + _M_ye, _M_comp), "");
-
-            const auto __nx = (_M_xe - _M_xs);
-            const auto __ny = (_M_ye - _M_ys);
-
-            _M_leaf_merge(_M_z_beg + _M_xs, _M_z_beg + _M_xe, _M_z_beg + _M_ys, _M_z_beg + _M_ye, _M_x_beg + _M_zs,
-                          _M_comp, __move_value(), __move_value(), __move_range(), __move_range());
-
-            __cleanup_range()(_M_z_beg + _M_xs, _M_z_beg + _M_xe);
-            __cleanup_range()(_M_z_beg + _M_ys, _M_z_beg + _M_ye);
-        }
-        return nullptr;
-    }
-
-    __task*
-    process_ranges(__task* __self)
-    {
-        _LIBCPP_ASSERT(_x_orig == _y_orig, "");
-        _LIBCPP_ASSERT(!_split, "");
-
-        auto p = parent_merge(__self);
-
-        if (!p)
-        { //root merging task
-
-            //optimization, just for sort algorithm, //{x} <= {y}
-            if (!is_partial() && x_less_y()) //we have a solution
-            {
-                if (!_x_orig)
-                {                   //we have to move the solution to the origin
-                    move_x_range(); //parallel moving
-                    move_y_range(); //parallel moving
-                }
-                return nullptr;
-            }
-            //else: if we have data in the origin,
-            //we have to move data to the buffer for final merging into the origin.
-            if (_x_orig)
-            {
-                move_x_range(); //parallel moving
-                move_y_range(); //parallel moving
-            }
-            // need to merge {x} and {y}.
-            return merge_ranges(__self);
-        }
-        //else: not root merging task (parent_merge() == NULL)
-        //optimization, just for sort algorithm, //{x} <= {y}
-        if (!is_partial() && x_less_y())
-        {
-            const auto id_range = _M_zs;
-            p->set_odd(id_range, _x_orig);
-            return nullptr;
-        }
-        //else: we have to revert "_x(y)_orig" flag of the parent merging task
-        const auto id_range = _M_zs;
-        p->set_odd(id_range, !_x_orig);
-
-        return merge_ranges(__self);
-    }
-
-    //splitting as merge task into 2 of the same level
-    __task*
-    split_merging(__task* __self)
-    {
-        _LIBCPP_ASSERT(_x_orig == _y_orig, "");
-        const auto __nx = (_M_xe - _M_xs);
-        const auto __ny = (_M_ye - _M_ys);
-
-        _SizeType __xm{};
-        _SizeType __ym{};
-        if (__nx < __ny)
-        {
-            __ym = _M_ys + __ny / 2;
-
-            if (_x_orig)
-                __xm = std::upper_bound(_M_x_beg + _M_xs, _M_x_beg + _M_xe, *(_M_x_beg + __ym), _M_comp) - _M_x_beg;
-            else
-                __xm = std::upper_bound(_M_z_beg + _M_xs, _M_z_beg + _M_xe, *(_M_z_beg + __ym), _M_comp) - _M_z_beg;
-        }
-        else
-        {
-            __xm = _M_xs + __nx / 2;
-
-            if (_y_orig)
-                __ym = std::lower_bound(_M_x_beg + _M_ys, _M_x_beg + _M_ye, *(_M_x_beg + __xm), _M_comp) - _M_x_beg;
-            else
-                __ym = std::lower_bound(_M_z_beg + _M_ys, _M_z_beg + _M_ye, *(_M_z_beg + __xm), _M_comp) - _M_z_beg;
-        }
-
-        auto __zm = _M_zs + ((__xm - _M_xs) + (__ym - _M_ys));
-        __merge_func __right_func(__xm, _M_xe, __ym, _M_ye, __zm, _M_comp, _Cleanup(), _M_leaf_merge, _M_nsort,
-                                  _M_x_beg, _M_z_beg, _x_orig, _y_orig, _root);
-        __right_func._split = true;
-        auto __merge_task = __self->make_additional_child_of(__self->parent(), std::move(__right_func));
-        __self->spawn(__merge_task);
-        __self->recycle_as_continuation();
-
-        _M_xe = __xm;
-        _M_ye = __ym;
-        _split = true;
-
-        return __self;
-    }
-};
-
-template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename __M_Compare, typename _Cleanup,
-          typename _LeafMerge>
-__task*
-__merge_func<_RandomAccessIterator1, _RandomAccessIterator2, __M_Compare, _Cleanup, _LeafMerge>::
-operator()(__task* __self)
-{
-    //a. split merge task into 2 of the same level; the special logic,
-    //without processing(process_ranges) adjacent sub-ranges x and y
-    if (_split)
-        return merge_ranges(__self);
-
-    //b. General merging of adjacent sub-ranges x and y (with optimization in case of {x} <= {y} )
-
-    //1. x and y are in the even buffer
-    //2. x and y are in the odd buffer
-    if (_x_orig == _y_orig)
-        return process_ranges(__self);
-
-    //3. x is in even buffer, y is in the odd buffer
-    //4. x is in odd buffer, y is in the even buffer
-    if (!parent_merge(__self))
-    { //root merge task
-        if (_x_orig)
-            move_x_range();
-        else
-            move_y_range();
-    }
-    else
-    {
-        const _SizeType __nx = (_M_xe - _M_xs);
-        const _SizeType __ny = (_M_ye - _M_ys);
-        _LIBCPP_ASSERT(__nx > 0, "");
-        _LIBCPP_ASSERT(__nx > 0, "");
-
-        if (__nx < __ny)
-            move_x_range();
-        else
-            move_y_range();
-    }
-
-    return process_ranges(__self);
-}
-
-template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _Compare, typename _LeafSort>
-class __stable_sort_func
-{
-  public:
-    typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
-    typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
-    typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType;
-
-  private:
-    _RandomAccessIterator1 _M_xs, _M_xe, _M_x_beg;
-    _RandomAccessIterator2 _M_zs, _M_z_beg;
-    _Compare _M_comp;
-    _LeafSort _M_leaf_sort;
-    bool _M_root;
-    _SizeType _M_nsort; //zero or number of elements to be sorted for partial_sort alforithm
-
-  public:
-    __stable_sort_func(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __zs,
-                       bool __root, _Compare __comp, _LeafSort __leaf_sort, _SizeType __nsort,
-                       _RandomAccessIterator1 __x_beg, _RandomAccessIterator2 __z_beg)
-        : _M_xs(__xs), _M_xe(__xe), _M_x_beg(__x_beg), _M_zs(__zs), _M_z_beg(__z_beg), _M_comp(__comp),
-          _M_leaf_sort(__leaf_sort), _M_root(__root), _M_nsort(__nsort)
-    {
-    }
-
-    __task*
-    operator()(__task* __self);
-};
-
-#define _PSTL_STABLE_SORT_CUT_OFF 500
-
-template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _Compare, typename _LeafSort>
-__task*
-__stable_sort_func<_RandomAccessIterator1, _RandomAccessIterator2, _Compare, _LeafSort>::operator()(__task* __self)
-{
-    typedef __merge_func<_RandomAccessIterator1, _RandomAccessIterator2, _Compare, __utils::__serial_destroy,
-                         __utils::__serial_move_merge>
-        _MergeTaskType;
-
-    const _SizeType __n = _M_xe - _M_xs;
-    const _SizeType __nmerge = _M_nsort > 0 ? _M_nsort : __n;
-    const _SizeType __sort_cut_off = _PSTL_STABLE_SORT_CUT_OFF;
-    if (__n <= __sort_cut_off)
-    {
-        _M_leaf_sort(_M_xs, _M_xe, _M_comp);
-        _LIBCPP_ASSERT(!_M_root, "");
-        return nullptr;
-    }
-
-    const _RandomAccessIterator1 __xm = _M_xs + __n / 2;
-    const _RandomAccessIterator2 __zm = _M_zs + (__xm - _M_xs);
-    const _RandomAccessIterator2 __ze = _M_zs + __n;
-    _MergeTaskType __m(_MergeTaskType(_M_xs - _M_x_beg, __xm - _M_x_beg, __xm - _M_x_beg, _M_xe - _M_x_beg,
-                                      _M_zs - _M_z_beg, _M_comp, __utils::__serial_destroy(),
-                                      __utils::__serial_move_merge(__nmerge), _M_nsort, _M_x_beg, _M_z_beg,
-                                      /*x_orig*/ true, /*y_orig*/ true, /*root*/ _M_root));
-    auto __parent = __self->make_continuation(std::move(__m));
-    __parent->set_ref_count(2);
-    auto __right = __self->make_child_of(
-        __parent, __stable_sort_func(__xm, _M_xe, __zm, false, _M_comp, _M_leaf_sort, _M_nsort, _M_x_beg, _M_z_beg));
-    __self->spawn(__right);
-    __self->recycle_as_child_of(__parent);
-    _M_root = false;
-    _M_xe = __xm;
-
-    return __self;
-}
-
-template <class _ExecutionPolicy, typename _RandomAccessIterator, typename _Compare, typename _LeafSort>
-void
-__parallel_stable_sort(__pstl::__internal::__tbb_backend_tag, _ExecutionPolicy&&, _RandomAccessIterator __xs,
-                       _RandomAccessIterator __xe, _Compare __comp, _LeafSort __leaf_sort, std::size_t __nsort = 0)
-{
-    tbb::this_task_arena::isolate([=, &__nsort]() {
-        //sorting based on task tree and parallel merge
-        typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _ValueType;
-        typedef typename std::iterator_traits<_RandomAccessIterator>::difference_type _DifferenceType;
-        const _DifferenceType __n = __xe - __xs;
-        if (__nsort == __n)
-            __nsort = 0; // 'partial_sort' becames 'sort'
-
-        const _DifferenceType __sort_cut_off = _PSTL_STABLE_SORT_CUT_OFF;
-        if (__n > __sort_cut_off)
-        {
-            __buffer<_ValueType> __buf(__n);
-            __root_task<__stable_sort_func<_RandomAccessIterator, _ValueType*, _Compare, _LeafSort>> __root{
-                __xs, __xe, __buf.get(), true, __comp, __leaf_sort, __nsort, __xs, __buf.get()};
-            __task::spawn_root_and_wait(__root);
-            return;
-        }
-        //serial sort
-        __leaf_sort(__xs, __xe, __comp);
-    });
-}
-
-//------------------------------------------------------------------------
-// parallel_merge
-//------------------------------------------------------------------------
-template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3,
-          typename _Compare, typename _LeafMerge>
-class __merge_func_static
-{
-    _RandomAccessIterator1 _M_xs, _M_xe;
-    _RandomAccessIterator2 _M_ys, _M_ye;
-    _RandomAccessIterator3 _M_zs;
-    _Compare _M_comp;
-    _LeafMerge _M_leaf_merge;
-
-  public:
-    __merge_func_static(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys,
-                        _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp,
-                        _LeafMerge __leaf_merge)
-        : _M_xs(__xs), _M_xe(__xe), _M_ys(__ys), _M_ye(__ye), _M_zs(__zs), _M_comp(__comp), _M_leaf_merge(__leaf_merge)
-    {
-    }
-
-    __task*
-    operator()(__task* __self);
-};
-
-//TODO: consider usage of parallel_for with a custom blocked_range
-template <typename _RandomAccessIterator1, typename _RandomAccessIterator2, typename _RandomAccessIterator3,
-          typename __M_Compare, typename _LeafMerge>
-__task*
-__merge_func_static<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3, __M_Compare, _LeafMerge>::
-operator()(__task* __self)
-{
-    typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
-    typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
-    typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType;
-    const _SizeType __n = (_M_xe - _M_xs) + (_M_ye - _M_ys);
-    const _SizeType __merge_cut_off = _PSTL_MERGE_CUT_OFF;
-    if (__n <= __merge_cut_off)
-    {
-        _M_leaf_merge(_M_xs, _M_xe, _M_ys, _M_ye, _M_zs, _M_comp);
-        return nullptr;
-    }
-
-    _RandomAccessIterator1 __xm;
-    _RandomAccessIterator2 __ym;
-    if (_M_xe - _M_xs < _M_ye - _M_ys)
-    {
-        __ym = _M_ys + (_M_ye - _M_ys) / 2;
-        __xm = std::upper_bound(_M_xs, _M_xe, *__ym, _M_comp);
-    }
-    else
-    {
-        __xm = _M_xs + (_M_xe - _M_xs) / 2;
-        __ym = std::lower_bound(_M_ys, _M_ye, *__xm, _M_comp);
-    }
-    const _RandomAccessIterator3 __zm = _M_zs + ((__xm - _M_xs) + (__ym - _M_ys));
-    auto __right = __self->make_additional_child_of(
-        __self->parent(), __merge_func_static(__xm, _M_xe, __ym, _M_ye, __zm, _M_comp, _M_leaf_merge));
-    __self->spawn(__right);
-    __self->recycle_as_continuation();
-    _M_xe = __xm;
-    _M_ye = __ym;
-
-    return __self;
-}
-
-template <class _ExecutionPolicy, typename _RandomAccessIterator1, typename _RandomAccessIterator2,
-          typename _RandomAccessIterator3, typename _Compare, typename _LeafMerge>
-void
-__parallel_merge(__pstl::__internal::__tbb_backend_tag, _ExecutionPolicy&&, _RandomAccessIterator1 __xs,
-                 _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys, _RandomAccessIterator2 __ye,
-                 _RandomAccessIterator3 __zs, _Compare __comp, _LeafMerge __leaf_merge)
-{
-    typedef typename std::iterator_traits<_RandomAccessIterator1>::difference_type _DifferenceType1;
-    typedef typename std::iterator_traits<_RandomAccessIterator2>::difference_type _DifferenceType2;
-    typedef typename std::common_type<_DifferenceType1, _DifferenceType2>::type _SizeType;
-    const _SizeType __n = (__xe - __xs) + (__ye - __ys);
-    const _SizeType __merge_cut_off = _PSTL_MERGE_CUT_OFF;
-    if (__n <= __merge_cut_off)
-    {
-        // Fall back on serial merge
-        __leaf_merge(__xs, __xe, __ys, __ye, __zs, __comp);
-    }
-    else
-    {
-        tbb::this_task_arena::isolate([=]() {
-            typedef __merge_func_static<_RandomAccessIterator1, _RandomAccessIterator2, _RandomAccessIterator3,
-                                        _Compare, _LeafMerge>
-                _TaskType;
-            __root_task<_TaskType> __root{__xs, __xe, __ys, __ye, __zs, __comp, __leaf_merge};
-            __task::spawn_root_and_wait(__root);
-        });
-    }
-}
-
-//------------------------------------------------------------------------
-// parallel_invoke
-//------------------------------------------------------------------------
-template <class _ExecutionPolicy, typename _F1, typename _F2>
-void
-__parallel_invoke(__pstl::__internal::__tbb_backend_tag, _ExecutionPolicy&&, _F1&& __f1, _F2&& __f2)
-{
-    //TODO: a version of tbb::this_task_arena::isolate with variadic arguments pack should be added in the future
-    tbb::this_task_arena::isolate([&]() { tbb::parallel_invoke(std::forward<_F1>(__f1), std::forward<_F2>(__f2)); });
-}
-
-} // namespace __tbb_backend
-} // namespace __pstl
-
-#endif /* _PSTL_PARALLEL_BACKEND_TBB_H */
diff --git a/third_party/libcxx/__pstl/internal/parallel_backend_utils.h b/third_party/libcxx/__pstl/internal/parallel_backend_utils.h
deleted file mode 100644
index 032a0479e..000000000
--- a/third_party/libcxx/__pstl/internal/parallel_backend_utils.h
+++ /dev/null
@@ -1,260 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_PARALLEL_BACKEND_UTILS_H
-#define _PSTL_PARALLEL_BACKEND_UTILS_H
-
-#include <__assert>
-#include <__config>
-#include <__iterator/iterator_traits.h>
-#include <__memory/addressof.h>
-
-#include "utils.h"
-
-namespace __pstl
-{
-
-namespace __utils
-{
-
-//! Destroy sequence [xs,xe)
-struct __serial_destroy
-{
-    template <typename _RandomAccessIterator>
-    void
-    operator()(_RandomAccessIterator __zs, _RandomAccessIterator __ze)
-    {
-        typedef typename std::iterator_traits<_RandomAccessIterator>::value_type _ValueType;
-        while (__zs != __ze)
-        {
-            --__ze;
-            (*__ze).~_ValueType();
-        }
-    }
-};
-
-//! Merge sequences [__xs,__xe) and [__ys,__ye) to output sequence [__zs,(__xe-__xs)+(__ye-__ys)), using std::move
-struct __serial_move_merge
-{
-    const std::size_t _M_nmerge;
-
-    explicit __serial_move_merge(std::size_t __nmerge) : _M_nmerge(__nmerge) {}
-    template <class _RandomAccessIterator1, class _RandomAccessIterator2, class _RandomAccessIterator3, class _Compare,
-              class _MoveValueX, class _MoveValueY, class _MoveSequenceX, class _MoveSequenceY>
-    void
-    operator()(_RandomAccessIterator1 __xs, _RandomAccessIterator1 __xe, _RandomAccessIterator2 __ys,
-               _RandomAccessIterator2 __ye, _RandomAccessIterator3 __zs, _Compare __comp, _MoveValueX __move_value_x,
-               _MoveValueY __move_value_y, _MoveSequenceX __move_sequence_x, _MoveSequenceY __move_sequence_y)
-    {
-        constexpr bool __same_move_val = std::is_same<_MoveValueX, _MoveValueY>::value;
-        constexpr bool __same_move_seq = std::is_same<_MoveSequenceX, _MoveSequenceY>::value;
-
-        auto __n = _M_nmerge;
-        _LIBCPP_ASSERT(__n > 0, "");
-
-        auto __nx = __xe - __xs;
-        //auto __ny = __ye - __ys;
-        _RandomAccessIterator3 __zs_beg = __zs;
-
-        if (__xs != __xe)
-        {
-            if (__ys != __ye)
-            {
-                for (;;)
-                {
-                    if (__comp(*__ys, *__xs))
-                    {
-                        const auto __i = __zs - __zs_beg;
-                        if (__i < __nx)
-                            __move_value_x(__ys, __zs);
-                        else
-                            __move_value_y(__ys, __zs);
-                        ++__zs, --__n;
-                        if (++__ys == __ye)
-                        {
-                            break;
-                        }
-                        else if (__n == 0)
-                        {
-                            const auto __j = __zs - __zs_beg;
-                            if (__same_move_seq || __j < __nx)
-                                __zs = __move_sequence_x(__ys, __ye, __zs);
-                            else
-                                __zs = __move_sequence_y(__ys, __ye, __zs);
-                            break;
-                        }
-                    }
-                    else
-                    {
-                        const auto __i = __zs - __zs_beg;
-                        if (__same_move_val || __i < __nx)
-                            __move_value_x(__xs, __zs);
-                        else
-                            __move_value_y(__xs, __zs);
-                        ++__zs, --__n;
-                        if (++__xs == __xe)
-                        {
-                            const auto __j = __zs - __zs_beg;
-                            if (__same_move_seq || __j < __nx)
-                                __move_sequence_x(__ys, __ye, __zs);
-                            else
-                                __move_sequence_y(__ys, __ye, __zs);
-                            return;
-                        }
-                        else if (__n == 0)
-                        {
-                            const auto __j = __zs - __zs_beg;
-                            if (__same_move_seq || __j < __nx)
-                            {
-                                __zs = __move_sequence_x(__xs, __xe, __zs);
-                                __move_sequence_x(__ys, __ye, __zs);
-                            }
-                            else
-                            {
-                                __zs = __move_sequence_y(__xs, __xe, __zs);
-                                __move_sequence_y(__ys, __ye, __zs);
-                            }
-                            return;
-                        }
-                    }
-                }
-            }
-            __ys = __xs;
-            __ye = __xe;
-        }
-        const auto __i = __zs - __zs_beg;
-        if (__same_move_seq || __i < __nx)
-            __move_sequence_x(__ys, __ye, __zs);
-        else
-            __move_sequence_y(__ys, __ye, __zs);
-    }
-};
-
-template <typename _ForwardIterator1, typename _ForwardIterator2, typename _OutputIterator, typename _Compare,
-          typename _CopyConstructRange>
-_OutputIterator
-__set_union_construct(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
-                      _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
-                      _CopyConstructRange __cc_range)
-{
-    using _Tp = typename std::iterator_traits<_OutputIterator>::value_type;
-
-    for (; __first1 != __last1; ++__result)
-    {
-        if (__first2 == __last2)
-            return __cc_range(__first1, __last1, __result);
-        if (__comp(*__first2, *__first1))
-        {
-            ::new (std::addressof(*__result)) _Tp(*__first2);
-            ++__first2;
-        }
-        else
-        {
-            ::new (std::addressof(*__result)) _Tp(*__first1);
-            if (!__comp(*__first1, *__first2))
-                ++__first2;
-            ++__first1;
-        }
-    }
-    return __cc_range(__first2, __last2, __result);
-}
-
-template <typename _ForwardIterator1, typename _ForwardIterator2, typename _OutputIterator, typename _Compare>
-_OutputIterator
-__set_intersection_construct(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
-                             _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp)
-{
-    using _Tp = typename std::iterator_traits<_OutputIterator>::value_type;
-
-    for (; __first1 != __last1 && __first2 != __last2;)
-    {
-        if (__comp(*__first1, *__first2))
-            ++__first1;
-        else
-        {
-            if (!__comp(*__first2, *__first1))
-            {
-                ::new (std::addressof(*__result)) _Tp(*__first1);
-                ++__result;
-                ++__first1;
-            }
-            ++__first2;
-        }
-    }
-    return __result;
-}
-
-template <typename _ForwardIterator1, typename _ForwardIterator2, typename _OutputIterator, typename _Compare,
-          typename _CopyConstructRange>
-_OutputIterator
-__set_difference_construct(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
-                           _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
-                           _CopyConstructRange __cc_range)
-{
-    using _Tp = typename std::iterator_traits<_OutputIterator>::value_type;
-
-    for (; __first1 != __last1;)
-    {
-        if (__first2 == __last2)
-            return __cc_range(__first1, __last1, __result);
-
-        if (__comp(*__first1, *__first2))
-        {
-            ::new (std::addressof(*__result)) _Tp(*__first1);
-            ++__result;
-            ++__first1;
-        }
-        else
-        {
-            if (!__comp(*__first2, *__first1))
-                ++__first1;
-            ++__first2;
-        }
-    }
-    return __result;
-}
-template <typename _ForwardIterator1, typename _ForwardIterator2, typename _OutputIterator, typename _Compare,
-          typename _CopyConstructRange>
-_OutputIterator
-__set_symmetric_difference_construct(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
-                                     _ForwardIterator2 __last2, _OutputIterator __result, _Compare __comp,
-                                     _CopyConstructRange __cc_range)
-{
-    using _Tp = typename std::iterator_traits<_OutputIterator>::value_type;
-
-    for (; __first1 != __last1;)
-    {
-        if (__first2 == __last2)
-            return __cc_range(__first1, __last1, __result);
-
-        if (__comp(*__first1, *__first2))
-        {
-            ::new (std::addressof(*__result)) _Tp(*__first1);
-            ++__result;
-            ++__first1;
-        }
-        else
-        {
-            if (__comp(*__first2, *__first1))
-            {
-                ::new (std::addressof(*__result)) _Tp(*__first2);
-                ++__result;
-            }
-            else
-                ++__first1;
-            ++__first2;
-        }
-    }
-    return __cc_range(__first2, __last2, __result);
-}
-
-} // namespace __utils
-} // namespace __pstl
-
-#endif /* _PSTL_PARALLEL_BACKEND_UTILS_H */
diff --git a/third_party/libcxx/__pstl/internal/unseq_backend_simd.h b/third_party/libcxx/__pstl/internal/unseq_backend_simd.h
deleted file mode 100644
index 268ea1d3e..000000000
--- a/third_party/libcxx/__pstl/internal/unseq_backend_simd.h
+++ /dev/null
@@ -1,762 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_UNSEQ_BACKEND_SIMD_H
-#define _PSTL_UNSEQ_BACKEND_SIMD_H
-
-#include <__config>
-#include <__functional/operations.h>
-#include <__iterator/iterator_traits.h>
-#include <__type_traits/is_arithmetic.h>
-#include <__type_traits/is_same.h>
-#include <__utility/move.h>
-#include <__utility/pair.h>
-#include <cstddef>
-#include <cstdint>
-
-#include <__pstl/internal/utils.h>
-
-// This header defines the minimum set of vector routines required
-// to support parallel STL.
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-namespace __pstl
-{
-namespace __unseq_backend
-{
-
-// Expect vector width up to 64 (or 512 bit)
-const std::size_t __lane_size = 64;
-
-template <class _Iterator, class _DifferenceType, class _Function>
-_LIBCPP_HIDE_FROM_ABI _Iterator
-__simd_walk_1(_Iterator __first, _DifferenceType __n, _Function __f) noexcept
-{
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-        __f(__first[__i]);
-
-    return __first + __n;
-}
-
-template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Function>
-_LIBCPP_HIDE_FROM_ABI _Iterator2
-__simd_walk_2(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Function __f) noexcept
-{
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-        __f(__first1[__i], __first2[__i]);
-    return __first2 + __n;
-}
-
-template <class _Iterator1, class _DifferenceType, class _Iterator2, class _Iterator3, class _Function>
-_LIBCPP_HIDE_FROM_ABI _Iterator3
-__simd_walk_3(_Iterator1 __first1, _DifferenceType __n, _Iterator2 __first2, _Iterator3 __first3,
-              _Function __f) noexcept
-{
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-        __f(__first1[__i], __first2[__i], __first3[__i]);
-    return __first3 + __n;
-}
-
-// TODO: check whether __simd_first() can be used here
-template <class _Index, class _DifferenceType, class _Pred>
-_LIBCPP_HIDE_FROM_ABI bool
-__simd_or(_Index __first, _DifferenceType __n, _Pred __pred) noexcept
-{
-    _DifferenceType __block_size = 4 < __n ? 4 : __n;
-    const _Index __last = __first + __n;
-    while (__last != __first)
-    {
-        int32_t __flag = 1;
-        _PSTL_PRAGMA_SIMD_REDUCTION(& : __flag)
-        for (_DifferenceType __i = 0; __i < __block_size; ++__i)
-            if (__pred(*(__first + __i)))
-                __flag = 0;
-        if (!__flag)
-            return true;
-
-        __first += __block_size;
-        if (__last - __first >= __block_size << 1)
-        {
-            // Double the block _Size.  Any unnecessary iterations can be amortized against work done so far.
-            __block_size <<= 1;
-        }
-        else
-        {
-            __block_size = __last - __first;
-        }
-    }
-    return false;
-}
-
-template <class _Index1, class _DifferenceType, class _Index2, class _Pred>
-_LIBCPP_HIDE_FROM_ABI std::pair<_Index1, _Index2>
-__simd_first(_Index1 __first1, _DifferenceType __n, _Index2 __first2, _Pred __pred) noexcept
-{
-    const _Index1 __last1 = __first1 + __n;
-    const _Index2 __last2 = __first2 + __n;
-    // Experiments show good block sizes like this
-    const _DifferenceType __block_size = 8;
-    alignas(__lane_size) _DifferenceType __lane[__block_size] = {0};
-    while (__last1 - __first1 >= __block_size)
-    {
-        _DifferenceType __found = 0;
-        _DifferenceType __i;
-            _PSTL_PRAGMA_SIMD_REDUCTION(|
-                                        : __found) for (__i = 0; __i < __block_size; ++__i)
-        {
-            const _DifferenceType __t = __pred(__first1[__i], __first2[__i]);
-            __lane[__i] = __t;
-            __found |= __t;
-        }
-        if (__found)
-        {
-            _DifferenceType __i2;
-            // This will vectorize
-            for (__i2 = 0; __i2 < __block_size; ++__i2)
-            {
-                if (__lane[__i2])
-                    break;
-            }
-            return std::make_pair(__first1 + __i2, __first2 + __i2);
-        }
-        __first1 += __block_size;
-        __first2 += __block_size;
-    }
-
-    //Keep remainder scalar
-    for (; __last1 != __first1; ++__first1, ++__first2)
-        if (__pred(*(__first1), *(__first2)))
-            return std::make_pair(__first1, __first2);
-
-    return std::make_pair(__last1, __last2);
-}
-
-template <class _Index, class _DifferenceType, class _Pred>
-_LIBCPP_HIDE_FROM_ABI _DifferenceType
-__simd_count(_Index __index, _DifferenceType __n, _Pred __pred) noexcept
-{
-    _DifferenceType __count = 0;
-    _PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-        if (__pred(*(__index + __i)))
-            ++__count;
-
-    return __count;
-}
-
-template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _BinaryPredicate>
-_LIBCPP_HIDE_FROM_ABI _OutputIterator
-__simd_unique_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator __result,
-                   _BinaryPredicate __pred) noexcept
-{
-    if (__n == 0)
-        return __result;
-
-    _DifferenceType __cnt = 1;
-    __result[0] = __first[0];
-
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 1; __i < __n; ++__i)
-    {
-        if (!__pred(__first[__i], __first[__i - 1]))
-        {
-            __result[__cnt] = __first[__i];
-            ++__cnt;
-        }
-    }
-    return __result + __cnt;
-}
-
-template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner>
-_LIBCPP_HIDE_FROM_ABI _OutputIterator
-__simd_assign(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _Assigner __assigner) noexcept
-{
-    _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-        __assigner(__first + __i, __result + __i);
-    return __result + __n;
-}
-
-template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _UnaryPredicate>
-_LIBCPP_HIDE_FROM_ABI _OutputIterator
-__simd_copy_if(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, _UnaryPredicate __pred) noexcept
-{
-    _DifferenceType __cnt = 0;
-
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-    {
-        if (__pred(__first[__i]))
-        {
-            __result[__cnt] = __first[__i];
-            ++__cnt;
-        }
-    }
-    return __result + __cnt;
-}
-
-template <class _InputIterator, class _DifferenceType, class _BinaryPredicate>
-_LIBCPP_HIDE_FROM_ABI _DifferenceType
-__simd_calc_mask_2(_InputIterator __first, _DifferenceType __n, bool* __mask, _BinaryPredicate __pred) noexcept
-{
-    _DifferenceType __count = 0;
-
-    _PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-    {
-        __mask[__i] = !__pred(__first[__i], __first[__i - 1]);
-        __count += __mask[__i];
-    }
-    return __count;
-}
-
-template <class _InputIterator, class _DifferenceType, class _UnaryPredicate>
-_LIBCPP_HIDE_FROM_ABI _DifferenceType
-__simd_calc_mask_1(_InputIterator __first, _DifferenceType __n, bool* __mask, _UnaryPredicate __pred) noexcept
-{
-    _DifferenceType __count = 0;
-
-    _PSTL_PRAGMA_SIMD_REDUCTION(+ : __count)
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-    {
-        __mask[__i] = __pred(__first[__i]);
-        __count += __mask[__i];
-    }
-    return __count;
-}
-
-template <class _InputIterator, class _DifferenceType, class _OutputIterator, class _Assigner>
-_LIBCPP_HIDE_FROM_ABI void
-__simd_copy_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator __result, bool* __mask,
-                    _Assigner __assigner) noexcept
-{
-    _DifferenceType __cnt = 0;
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-    {
-        if (__mask[__i])
-        {
-            {
-                __assigner(__first + __i, __result + __cnt);
-                ++__cnt;
-            }
-        }
-    }
-}
-
-template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2>
-_LIBCPP_HIDE_FROM_ABI void
-__simd_partition_by_mask(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
-                         _OutputIterator2 __out_false, bool* __mask) noexcept
-{
-    _DifferenceType __cnt_true = 0, __cnt_false = 0;
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-    {
-        if (__mask[__i])
-        {
-            __out_true[__cnt_true] = __first[__i];
-            ++__cnt_true;
-        }
-        else
-        {
-            __out_false[__cnt_false] = __first[__i];
-            ++__cnt_false;
-        }
-    }
-}
-
-template <class _Index, class _DifferenceType, class _Generator>
-_LIBCPP_HIDE_FROM_ABI _Index
-__simd_generate_n(_Index __first, _DifferenceType __size, _Generator __g) noexcept
-{
-    _PSTL_USE_NONTEMPORAL_STORES_IF_ALLOWED
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 0; __i < __size; ++__i)
-        __first[__i] = __g();
-    return __first + __size;
-}
-
-template <class _Index, class _BinaryPredicate>
-_LIBCPP_HIDE_FROM_ABI _Index
-__simd_adjacent_find(_Index __first, _Index __last, _BinaryPredicate __pred, bool __or_semantic) noexcept
-{
-    if (__last - __first < 2)
-        return __last;
-
-    typedef typename std::iterator_traits<_Index>::difference_type _DifferenceType;
-    _DifferenceType __i = 0;
-
-    // Experiments show good block sizes like this
-    //TODO: to consider tuning block_size for various data types
-    const _DifferenceType __block_size = 8;
-    alignas(__lane_size) _DifferenceType __lane[__block_size] = {0};
-    while (__last - __first >= __block_size)
-    {
-        _DifferenceType __found = 0;
-            _PSTL_PRAGMA_SIMD_REDUCTION(|
-                                        : __found) for (__i = 0; __i < __block_size - 1; ++__i)
-        {
-            //TODO: to improve SIMD vectorization
-            const _DifferenceType __t = __pred(*(__first + __i), *(__first + __i + 1));
-            __lane[__i] = __t;
-            __found |= __t;
-        }
-
-        //Process a pair of elements on a boundary of a data block
-        if (__first + __block_size < __last && __pred(*(__first + __i), *(__first + __i + 1)))
-            __lane[__i] = __found = 1;
-
-        if (__found)
-        {
-            if (__or_semantic)
-                return __first;
-
-            // This will vectorize
-            for (__i = 0; __i < __block_size; ++__i)
-                if (__lane[__i])
-                    break;
-            return __first + __i; //As far as found is true a __result (__lane[__i] is true) is guaranteed
-        }
-        __first += __block_size;
-    }
-    //Process the rest elements
-    for (; __last - __first > 1; ++__first)
-        if (__pred(*__first, *(__first + 1)))
-            return __first;
-
-    return __last;
-}
-
-// It was created to reduce the code inside std::enable_if
-template <typename _Tp, typename _BinaryOperation>
-using is_arithmetic_plus = std::integral_constant<bool, std::is_arithmetic<_Tp>::value &&
-                                                            std::is_same<_BinaryOperation, std::plus<_Tp>>::value>;
-
-template <typename _DifferenceType, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>
-_LIBCPP_HIDE_FROM_ABI typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
-__simd_transform_reduce(_DifferenceType __n, _Tp __init, _BinaryOperation, _UnaryOperation __f) noexcept
-{
-    _PSTL_PRAGMA_SIMD_REDUCTION(+ : __init)
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-        __init += __f(__i);
-    return __init;
-}
-
-template <typename _Size, typename _Tp, typename _BinaryOperation, typename _UnaryOperation>
-_LIBCPP_HIDE_FROM_ABI typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, _Tp>::type
-__simd_transform_reduce(_Size __n, _Tp __init, _BinaryOperation __binary_op, _UnaryOperation __f) noexcept
-{
-    const _Size __block_size = __lane_size / sizeof(_Tp);
-    if (__n > 2 * __block_size && __block_size > 1)
-    {
-        alignas(__lane_size) char __lane_buffer[__lane_size];
-        _Tp* __lane = reinterpret_cast<_Tp*>(__lane_buffer);
-
-        // initializer
-        _PSTL_PRAGMA_SIMD
-        for (_Size __i = 0; __i < __block_size; ++__i)
-        {
-            ::new (__lane + __i) _Tp(__binary_op(__f(__i), __f(__block_size + __i)));
-        }
-        // main loop
-        _Size __i = 2 * __block_size;
-        const _Size __last_iteration = __block_size * (__n / __block_size);
-        for (; __i < __last_iteration; __i += __block_size)
-        {
-            _PSTL_PRAGMA_SIMD
-            for (_Size __j = 0; __j < __block_size; ++__j)
-            {
-                __lane[__j] = __binary_op(__lane[__j], __f(__i + __j));
-            }
-        }
-        // remainder
-        _PSTL_PRAGMA_SIMD
-        for (_Size __j = 0; __j < __n - __last_iteration; ++__j)
-        {
-            __lane[__j] = __binary_op(__lane[__j], __f(__last_iteration + __j));
-        }
-        // combiner
-        for (_Size __j = 0; __j < __block_size; ++__j)
-        {
-            __init = __binary_op(__init, __lane[__j]);
-        }
-        // destroyer
-        _PSTL_PRAGMA_SIMD
-        for (_Size __j = 0; __j < __block_size; ++__j)
-        {
-            __lane[__j].~_Tp();
-        }
-    }
-    else
-    {
-        for (_Size __i = 0; __i < __n; ++__i)
-        {
-            __init = __binary_op(__init, __f(__i));
-        }
-    }
-    return __init;
-}
-
-// Exclusive scan for "+" and arithmetic types
-template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
-          class _BinaryOperation>
-_LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
-            _BinaryOperation, /*Inclusive*/ std::false_type)
-{
-    _PSTL_PRAGMA_SIMD_SCAN(+ : __init)
-    for (_Size __i = 0; __i < __n; ++__i)
-    {
-        __result[__i] = __init;
-        _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__init)
-        __init += __unary_op(__first[__i]);
-    }
-    return std::make_pair(__result + __n, __init);
-}
-
-// As soon as we cannot call __binary_op in "combiner" we create a wrapper over _Tp to encapsulate __binary_op
-template <typename _Tp, typename _BinaryOp>
-struct _Combiner
-{
-    _Tp __value_;
-    _BinaryOp* __bin_op_; // Here is a pointer to function because of default ctor
-
-    _LIBCPP_HIDE_FROM_ABI _Combiner() : __value_{}, __bin_op_(nullptr) {}
-    _LIBCPP_HIDE_FROM_ABI
-    _Combiner(const _Tp& __value, const _BinaryOp* __bin_op)
-        : __value_(__value), __bin_op_(const_cast<_BinaryOp*>(__bin_op)) {}
-    _LIBCPP_HIDE_FROM_ABI _Combiner(const _Combiner& __obj) : __value_{}, __bin_op_(__obj.__bin_op) {}
-
-    _LIBCPP_HIDE_FROM_ABI void
-    operator()(const _Combiner& __obj)
-    {
-        __value_ = (*__bin_op_)(__value_, __obj.__value_);
-    }
-};
-
-// Exclusive scan for other binary operations and types
-template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
-          class _BinaryOperation>
-_LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
-            _BinaryOperation __binary_op, /*Inclusive*/ std::false_type)
-{
-    typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
-    _CombinerType __combined_init{__init, &__binary_op};
-
-    _PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType)
-    _PSTL_PRAGMA_SIMD_SCAN(__bin_op : __combined_init)
-    for (_Size __i = 0; __i < __n; ++__i)
-    {
-        __result[__i] = __combined_init.__value_;
-        _PSTL_PRAGMA_SIMD_EXCLUSIVE_SCAN(__combined_init)
-        __combined_init.__value_ = __binary_op(__combined_init.__value_, __unary_op(__first[__i]));
-    }
-    return std::make_pair(__result + __n, __combined_init.__value_);
-}
-
-// Inclusive scan for "+" and arithmetic types
-template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
-          class _BinaryOperation>
-_LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
-            _BinaryOperation, /*Inclusive*/ std::true_type)
-{
-    _PSTL_PRAGMA_SIMD_SCAN(+ : __init)
-    for (_Size __i = 0; __i < __n; ++__i)
-    {
-        __init += __unary_op(__first[__i]);
-        _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__init)
-        __result[__i] = __init;
-    }
-    return std::make_pair(__result + __n, __init);
-}
-
-// Inclusive scan for other binary operations and types
-template <class _InputIterator, class _Size, class _OutputIterator, class _UnaryOperation, class _Tp,
-          class _BinaryOperation>
-_LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<!is_arithmetic_plus<_Tp, _BinaryOperation>::value, std::pair<_OutputIterator, _Tp>>::type
-__simd_scan(_InputIterator __first, _Size __n, _OutputIterator __result, _UnaryOperation __unary_op, _Tp __init,
-            _BinaryOperation __binary_op, std::true_type)
-{
-    typedef _Combiner<_Tp, _BinaryOperation> _CombinerType;
-    _CombinerType __combined_init{__init, &__binary_op};
-
-    _PSTL_PRAGMA_DECLARE_REDUCTION(__bin_op, _CombinerType)
-    _PSTL_PRAGMA_SIMD_SCAN(__bin_op : __combined_init)
-    for (_Size __i = 0; __i < __n; ++__i)
-    {
-        __combined_init.__value_ = __binary_op(__combined_init.__value_, __unary_op(__first[__i]));
-        _PSTL_PRAGMA_SIMD_INCLUSIVE_SCAN(__combined_init)
-        __result[__i] = __combined_init.__value_;
-    }
-    return std::make_pair(__result + __n, __combined_init.__value_);
-}
-
-// [restriction] - std::iterator_traits<_ForwardIterator>::value_type should be DefaultConstructible.
-// complexity [violation] - We will have at most (__n-1 + number_of_lanes) comparisons instead of at most __n-1.
-template <typename _ForwardIterator, typename _Size, typename _Compare>
-_LIBCPP_HIDE_FROM_ABI _ForwardIterator
-__simd_min_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
-{
-    if (__n == 0)
-    {
-        return __first;
-    }
-
-    typedef typename std::iterator_traits<_ForwardIterator>::value_type _ValueType;
-    struct _ComplexType
-    {
-        _ValueType __min_val_;
-        _Size __min_ind_;
-        _Compare* __min_comp_;
-
-        _LIBCPP_HIDE_FROM_ABI _ComplexType() : __min_val_{}, __min_ind_{}, __min_comp_(nullptr) {}
-        _LIBCPP_HIDE_FROM_ABI _ComplexType(const _ValueType& __val, const _Compare* __comp)
-            : __min_val_(__val), __min_ind_(0), __min_comp_(const_cast<_Compare*>(__comp))
-        {
-        }
-        _LIBCPP_HIDE_FROM_ABI _ComplexType(const _ComplexType& __obj)
-            : __min_val_(__obj.__min_val_), __min_ind_(__obj.__min_ind_), __min_comp_(__obj.__min_comp_)
-        {
-        }
-
-        _PSTL_PRAGMA_DECLARE_SIMD
-        _LIBCPP_HIDE_FROM_ABI void
-        operator()(const _ComplexType& __obj)
-        {
-            if (!(*__min_comp_)(__min_val_, __obj.__min_val_) &&
-                ((*__min_comp_)(__obj.__min_val_, __min_val_) || __obj.__min_ind_ - __min_ind_ < 0))
-            {
-                __min_val_ = __obj.__min_val_;
-                __min_ind_ = __obj.__min_ind_;
-            }
-        }
-    };
-
-    _ComplexType __init{*__first, &__comp};
-
-    _PSTL_PRAGMA_DECLARE_REDUCTION(__min_func, _ComplexType)
-
-    _PSTL_PRAGMA_SIMD_REDUCTION(__min_func : __init)
-    for (_Size __i = 1; __i < __n; ++__i)
-    {
-        const _ValueType __min_val = __init.__min_val_;
-        const _ValueType __current = __first[__i];
-        if (__comp(__current, __min_val))
-        {
-            __init.__min_val_ = __current;
-            __init.__min_ind_ = __i;
-        }
-    }
-    return __first + __init.__min_ind_;
-}
-
-// [restriction] - std::iterator_traits<_ForwardIterator>::value_type should be DefaultConstructible.
-// complexity [violation] - We will have at most (2*(__n-1) + 4*number_of_lanes) comparisons instead of at most [1.5*(__n-1)].
-template <typename _ForwardIterator, typename _Size, typename _Compare>
-_LIBCPP_HIDE_FROM_ABI std::pair<_ForwardIterator, _ForwardIterator>
-__simd_minmax_element(_ForwardIterator __first, _Size __n, _Compare __comp) noexcept
-{
-    if (__n == 0)
-    {
-        return std::make_pair(__first, __first);
-    }
-    typedef typename std::iterator_traits<_ForwardIterator>::value_type _ValueType;
-
-    struct _ComplexType
-    {
-        _ValueType __min_val_;
-        _ValueType __max_val_;
-        _Size __min_ind_;
-        _Size __max_ind_;
-        _Compare* __minmax_comp;
-
-        _LIBCPP_HIDE_FROM_ABI _ComplexType()
-            : __min_val_{}, __max_val_{}, __min_ind_{}, __max_ind_{}, __minmax_comp(nullptr) {}
-        _LIBCPP_HIDE_FROM_ABI _ComplexType(
-                const _ValueType& __min_val, const _ValueType& __max_val, const _Compare* __comp)
-            : __min_val_(__min_val), __max_val_(__max_val), __min_ind_(0), __max_ind_(0),
-              __minmax_comp(const_cast<_Compare*>(__comp))
-        {
-        }
-        _LIBCPP_HIDE_FROM_ABI _ComplexType(const _ComplexType& __obj)
-            : __min_val_(__obj.__min_val_), __max_val_(__obj.__max_val_), __min_ind_(__obj.__min_ind_),
-              __max_ind_(__obj.__max_ind_), __minmax_comp(__obj.__minmax_comp)
-        {
-        }
-
-        _LIBCPP_HIDE_FROM_ABI void
-        operator()(const _ComplexType& __obj)
-        {
-            // min
-            if ((*__minmax_comp)(__obj.__min_val_, __min_val_))
-            {
-                __min_val_ = __obj.__min_val_;
-                __min_ind_ = __obj.__min_ind_;
-            }
-            else if (!(*__minmax_comp)(__min_val_, __obj.__min_val_))
-            {
-                __min_val_ = __obj.__min_val_;
-                __min_ind_ = (__min_ind_ - __obj.__min_ind_ < 0) ? __min_ind_ : __obj.__min_ind_;
-            }
-
-            // max
-            if ((*__minmax_comp)(__max_val_, __obj.__max_val_))
-            {
-                __max_val_ = __obj.__max_val_;
-                __max_ind_ = __obj.__max_ind_;
-            }
-            else if (!(*__minmax_comp)(__obj.__max_val_, __max_val_))
-            {
-                __max_val_ = __obj.__max_val_;
-                __max_ind_ = (__max_ind_ - __obj.__max_ind_ < 0) ? __obj.__max_ind_ : __max_ind_;
-            }
-        }
-    };
-
-    _ComplexType __init{*__first, *__first, &__comp};
-
-    _PSTL_PRAGMA_DECLARE_REDUCTION(__min_func, _ComplexType);
-
-    _PSTL_PRAGMA_SIMD_REDUCTION(__min_func : __init)
-    for (_Size __i = 1; __i < __n; ++__i)
-    {
-        auto __min_val = __init.__min_val_;
-        auto __max_val = __init.__max_val_;
-        auto __current = __first + __i;
-        if (__comp(*__current, __min_val))
-        {
-            __init.__min_val_ = *__current;
-            __init.__min_ind_ = __i;
-        }
-        else if (!__comp(*__current, __max_val))
-        {
-            __init.__max_val_ = *__current;
-            __init.__max_ind_ = __i;
-        }
-    }
-    return std::make_pair(__first + __init.__min_ind_, __first + __init.__max_ind_);
-}
-
-template <class _InputIterator, class _DifferenceType, class _OutputIterator1, class _OutputIterator2,
-          class _UnaryPredicate>
-_LIBCPP_HIDE_FROM_ABI std::pair<_OutputIterator1, _OutputIterator2>
-__simd_partition_copy(_InputIterator __first, _DifferenceType __n, _OutputIterator1 __out_true,
-                      _OutputIterator2 __out_false, _UnaryPredicate __pred) noexcept
-{
-    _DifferenceType __cnt_true = 0, __cnt_false = 0;
-
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 0; __i < __n; ++__i)
-    {
-        if (__pred(__first[__i]))
-        {
-            __out_true[__cnt_true] = __first[__i];
-            ++__cnt_true;
-        }
-        else
-        {
-            __out_false[__cnt_false] = __first[__i];
-            ++__cnt_false;
-        }
-    }
-    return std::make_pair(__out_true + __cnt_true, __out_false + __cnt_false);
-}
-
-template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
-_LIBCPP_HIDE_FROM_ABI _ForwardIterator1
-__simd_find_first_of(_ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
-                     _ForwardIterator2 __s_last, _BinaryPredicate __pred) noexcept
-{
-    typedef typename std::iterator_traits<_ForwardIterator1>::difference_type _DifferencType;
-
-    const _DifferencType __n1 = __last - __first;
-    const _DifferencType __n2 = __s_last - __s_first;
-    if (__n1 == 0 || __n2 == 0)
-    {
-        return __last; // according to the standard
-    }
-
-    // Common case
-    // If first sequence larger than second then we'll run simd_first with parameters of first sequence.
-    // Otherwise, vice versa.
-    if (__n1 < __n2)
-    {
-        for (; __first != __last; ++__first)
-        {
-            if (__unseq_backend::__simd_or(
-                    __s_first, __n2,
-                    __internal::__equal_value_by_pred<decltype(*__first), _BinaryPredicate>(*__first, __pred)))
-            {
-                return __first;
-            }
-        }
-    }
-    else
-    {
-        for (; __s_first != __s_last; ++__s_first)
-        {
-            const auto __result = __unseq_backend::__simd_first(
-                __first, _DifferencType(0), __n1, [__s_first, &__pred](_ForwardIterator1 __it, _DifferencType __i) {
-                    return __pred(__it[__i], *__s_first);
-                });
-            if (__result != __last)
-            {
-                return __result;
-            }
-        }
-    }
-    return __last;
-}
-
-template <class _RandomAccessIterator, class _DifferenceType, class _UnaryPredicate>
-_LIBCPP_HIDE_FROM_ABI _RandomAccessIterator
-__simd_remove_if(_RandomAccessIterator __first, _DifferenceType __n, _UnaryPredicate __pred) noexcept
-{
-    // find first element we need to remove
-    auto __current = __unseq_backend::__simd_first(
-        __first, _DifferenceType(0), __n,
-        [&__pred](_RandomAccessIterator __it, _DifferenceType __i) { return __pred(__it[__i]); });
-    __n -= __current - __first;
-
-    // if we have in sequence only one element that pred(__current[1]) != false we can exit the function
-    if (__n < 2)
-    {
-        return __current;
-    }
-
-    _DifferenceType __cnt = 0;
-    _PSTL_PRAGMA_SIMD
-    for (_DifferenceType __i = 1; __i < __n; ++__i)
-    {
-        if (!__pred(__current[__i]))
-        {
-            __current[__cnt] = std::move(__current[__i]);
-            ++__cnt;
-        }
-    }
-    return __current + __cnt;
-}
-} // namespace __unseq_backend
-} // namespace __pstl
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif /* _PSTL_UNSEQ_BACKEND_SIMD_H */
diff --git a/third_party/libcxx/__pstl/internal/utils.h b/third_party/libcxx/__pstl/internal/utils.h
deleted file mode 100644
index 92c8d48db..000000000
--- a/third_party/libcxx/__pstl/internal/utils.h
+++ /dev/null
@@ -1,144 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_UTILS_H
-#define _PSTL_UTILS_H
-
-#include <__config>
-#include <__exception/terminate.h>
-#include <__utility/forward.h>
-#include <new>
-
-#if !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-namespace __pstl {
-namespace __internal {
-
-template <typename _Fp>
-_LIBCPP_HIDE_FROM_ABI auto __except_handler(_Fp __f) -> decltype(__f()) {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-  try {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return __f();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-  } catch (const std::bad_alloc&) {
-    throw;            // re-throw bad_alloc according to the standard [algorithms.parallel.exceptions]
-  } catch (...) {
-    std::terminate(); // Good bye according to the standard [algorithms.parallel.exceptions]
-  }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-}
-
-template <typename _Fp>
-_LIBCPP_HIDE_FROM_ABI void __invoke_if(std::true_type, _Fp __f) {
-  __f();
-}
-
-template <typename _Fp>
-_LIBCPP_HIDE_FROM_ABI void __invoke_if(std::false_type, _Fp) {}
-
-template <typename _Fp>
-_LIBCPP_HIDE_FROM_ABI void __invoke_if_not(std::false_type, _Fp __f) {
-  __f();
-}
-
-template <typename _Fp>
-_LIBCPP_HIDE_FROM_ABI void __invoke_if_not(std::true_type, _Fp) {}
-
-template <typename _F1, typename _F2>
-_LIBCPP_HIDE_FROM_ABI auto __invoke_if_else(std::true_type, _F1 __f1, _F2) -> decltype(__f1()) {
-  return __f1();
-}
-
-template <typename _F1, typename _F2>
-_LIBCPP_HIDE_FROM_ABI auto __invoke_if_else(std::false_type, _F1, _F2 __f2) -> decltype(__f2()) {
-  return __f2();
-}
-
-//! Unary operator that returns reference to its argument.
-struct __no_op {
-  template <typename _Tp>
-  _LIBCPP_HIDE_FROM_ABI _Tp&& operator()(_Tp&& __a) const {
-    return std::forward<_Tp>(__a);
-  }
-};
-
-template <typename _Pred>
-class __reorder_pred {
-  _Pred __pred_;
-
-public:
-  _LIBCPP_HIDE_FROM_ABI explicit __reorder_pred(_Pred __pred) : __pred_(__pred) {}
-
-  template <typename _FTp, typename _STp>
-  _LIBCPP_HIDE_FROM_ABI bool operator()(_FTp&& __a, _STp&& __b) {
-    return __pred_(std::forward<_STp>(__b), std::forward<_FTp>(__a));
-  }
-};
-
-//! Like a polymorphic lambda for pred(...,value)
-template <typename _Tp, typename _Predicate>
-class __equal_value_by_pred {
-  const _Tp& __value_;
-  _Predicate __pred_;
-
-public:
-  _LIBCPP_HIDE_FROM_ABI __equal_value_by_pred(const _Tp& __value, _Predicate __pred)
-      : __value_(__value), __pred_(__pred) {}
-
-  template <typename _Arg>
-  _LIBCPP_HIDE_FROM_ABI bool operator()(_Arg&& __arg) {
-    return __pred_(std::forward<_Arg>(__arg), __value_);
-  }
-};
-
-//! Like a polymorphic lambda for ==value
-template <typename _Tp>
-class __equal_value {
-  const _Tp& __value_;
-
-public:
-  _LIBCPP_HIDE_FROM_ABI explicit __equal_value(const _Tp& __value) : __value_(__value) {}
-
-  template <typename _Arg>
-  _LIBCPP_HIDE_FROM_ABI bool operator()(_Arg&& __arg) const {
-    return std::forward<_Arg>(__arg) == __value_;
-  }
-};
-
-//! Logical negation of ==value
-template <typename _Tp>
-class __not_equal_value {
-  const _Tp& __value_;
-
-public:
-  _LIBCPP_HIDE_FROM_ABI explicit __not_equal_value(const _Tp& __value) : __value_(__value) {}
-
-  template <typename _Arg>
-  _LIBCPP_HIDE_FROM_ABI bool operator()(_Arg&& __arg) const {
-    return !(std::forward<_Arg>(__arg) == __value_);
-  }
-};
-
-template <typename _ForwardIterator, typename _Compare>
-_LIBCPP_HIDE_FROM_ABI _ForwardIterator
-__cmp_iterators_by_values(_ForwardIterator __a, _ForwardIterator __b, _Compare __comp) {
-  if (__a < __b) { // we should return closer iterator
-    return __comp(*__b, *__a) ? __b : __a;
-  } else {
-    return __comp(*__a, *__b) ? __a : __b;
-  }
-}
-
-} // namespace __internal
-} // namespace __pstl
-
-#endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
-
-#endif /* _PSTL_UTILS_H */
diff --git a/third_party/libcxx/__pstl_algorithm b/third_party/libcxx/__pstl_algorithm
deleted file mode 100644
index 79c18385c..000000000
--- a/third_party/libcxx/__pstl_algorithm
+++ /dev/null
@@ -1,15 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef __PSTL_ALGORITHM
-#define __PSTL_ALGORITHM
-
-#include <pstl/internal/glue_algorithm_impl.h>
-
-#endif /* __PSTL_ALGORITHM */
diff --git a/third_party/libcxx/__pstl_config_site b/third_party/libcxx/__pstl_config_site
deleted file mode 100644
index a41a1c383..000000000
--- a/third_party/libcxx/__pstl_config_site
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef __PSTL_CONFIG_SITE
-#define __PSTL_CONFIG_SITE
-
-#cmakedefine _PSTL_PAR_BACKEND_SERIAL
-#cmakedefine _PSTL_PAR_BACKEND_TBB
-#cmakedefine _PSTL_PAR_BACKEND_OPENMP
-#cmakedefine _PSTL_HIDE_FROM_ABI_PER_TU
-
-#endif // __PSTL_CONFIG_SITE
diff --git a/third_party/libcxx/__pstl_memory b/third_party/libcxx/__pstl_memory
deleted file mode 100644
index 12b7f5aa3..000000000
--- a/third_party/libcxx/__pstl_memory
+++ /dev/null
@@ -1,15 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef __PSTL_MEMORY
-#define __PSTL_MEMORY
-
-#include <pstl/internal/glue_memory_impl.h>
-
-#endif /* __PSTL_MEMORY */
diff --git a/third_party/libcxx/__pstl_numeric b/third_party/libcxx/__pstl_numeric
deleted file mode 100644
index cf168ef70..000000000
--- a/third_party/libcxx/__pstl_numeric
+++ /dev/null
@@ -1,15 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef __PSTL_NUMERIC
-#define __PSTL_NUMERIC
-
-#include <pstl/internal/glue_numeric_impl.h>
-
-#endif /* __PSTL_NUMERIC */
diff --git a/third_party/libcxx/__random/bernoulli_distribution.h b/third_party/libcxx/__random/bernoulli_distribution.h
index e38d3dfb8..4f33dca13 100644
--- a/third_party/libcxx/__random/bernoulli_distribution.h
+++ b/third_party/libcxx/__random/bernoulli_distribution.h
@@ -23,119 +23,97 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TEMPLATE_VIS bernoulli_distribution
-{
+class _LIBCPP_TEMPLATE_VIS bernoulli_distribution {
 public:
-    // types
-    typedef bool result_type;
+  // types
+  typedef bool result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        double __p_;
-    public:
-        typedef bernoulli_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    double __p_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(double __p = 0.5) : __p_(__p) {}
+  public:
+    typedef bernoulli_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        double p() const {return __p_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(double __p = 0.5) : __p_(__p) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__p_ == __y.__p_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI double p() const { return __p_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__p_ == __y.__p_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructors and reset functions
+  // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    bernoulli_distribution() : bernoulli_distribution(0.5) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit bernoulli_distribution(double __p) : __p_(param_type(__p)) {}
+  _LIBCPP_HIDE_FROM_ABI bernoulli_distribution() : bernoulli_distribution(0.5) {}
+  _LIBCPP_HIDE_FROM_ABI explicit bernoulli_distribution(double __p) : __p_(param_type(__p)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit bernoulli_distribution(double __p = 0.5) : __p_(param_type(__p)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    double p() const {return __p_.p();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI double p() const { return __p_.p(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return false;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return true;}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return false; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return true; }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const bernoulli_distribution& __x,
-                        const bernoulli_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const bernoulli_distribution& __x,
-                        const bernoulli_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const bernoulli_distribution& __x, const bernoulli_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const bernoulli_distribution& __x, const bernoulli_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
-template<class _URNG>
-inline
-bernoulli_distribution::result_type
-bernoulli_distribution::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    uniform_real_distribution<double> __gen;
-    return __gen(__g) < __p.p();
+template <class _URNG>
+inline bernoulli_distribution::result_type bernoulli_distribution::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  uniform_real_distribution<double> __gen;
+  return __gen(__g) < __p.p();
 }
 
 template <class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.p();
+operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  return __os << __x.p();
 }
 
 template <class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x)
-{
-    typedef bernoulli_distribution _Eng;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    double __p;
-    __is >> __p;
-    if (!__is.fail())
-        __x.param(param_type(__p));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x) {
+  typedef bernoulli_distribution _Eng;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  double __p;
+  __is >> __p;
+  if (!__is.fail())
+    __x.param(param_type(__p));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/binomial_distribution.h b/third_party/libcxx/__random/binomial_distribution.h
index 18053c7d1..e8774bb8d 100644
--- a/third_party/libcxx/__random/binomial_distribution.h
+++ b/third_party/libcxx/__random/binomial_distribution.h
@@ -24,101 +24,84 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS binomial_distribution
-{
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
+template <class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS binomial_distribution {
+  static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
+
 public:
-    // types
-    typedef _IntType result_type;
+  // types
+  typedef _IntType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __t_;
-        double __p_;
-        double __pr_;
-        double __odds_ratio_;
-        result_type __r0_;
-    public:
-        typedef binomial_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __t_;
+    double __p_;
+    double __pr_;
+    double __odds_ratio_;
+    result_type __r0_;
 
-        _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __t = 1, double __p = 0.5);
+  public:
+    typedef binomial_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type t() const {return __t_;}
-        _LIBCPP_INLINE_VISIBILITY
-        double p() const {return __p_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __t = 1, double __p = 0.5);
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
+    _LIBCPP_HIDE_FROM_ABI result_type t() const { return __t_; }
+    _LIBCPP_HIDE_FROM_ABI double p() const { return __p_; }
 
-        friend class binomial_distribution;
-    };
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+
+    friend class binomial_distribution;
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructors and reset functions
+  // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    binomial_distribution() : binomial_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit binomial_distribution(result_type __t, double __p = 0.5)
-        : __p_(param_type(__t, __p)) {}
+  _LIBCPP_HIDE_FROM_ABI binomial_distribution() : binomial_distribution(1) {}
+  _LIBCPP_HIDE_FROM_ABI explicit binomial_distribution(result_type __t, double __p = 0.5)
+      : __p_(param_type(__t, __p)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
-        : __p_(param_type(__t, __p)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
+      : __p_(param_type(__t, __p)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type t() const {return __p_.t();}
-    _LIBCPP_INLINE_VISIBILITY
-    double p() const {return __p_.p();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type t() const { return __p_.t(); }
+  _LIBCPP_HIDE_FROM_ABI double p() const { return __p_.p(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return t();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return t(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const binomial_distribution& __x,
-                        const binomial_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const binomial_distribution& __x,
-                        const binomial_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const binomial_distribution& __x, const binomial_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const binomial_distribution& __x, const binomial_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 #ifndef _LIBCPP_MSVCRT_LIKE
-extern "C" double lgamma_r(double, int *);
+extern "C" double lgamma_r(double, int*);
 #endif
 
-inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) {
+inline _LIBCPP_HIDE_FROM_ABI double __libcpp_lgamma(double __d) {
 #if defined(_LIBCPP_MSVCRT_LIKE)
   return lgamma(__d);
 #else
@@ -127,99 +110,85 @@ inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) {
 #endif
 }
 
-template<class _IntType>
-binomial_distribution<_IntType>::param_type::param_type(result_type __t, double __p)
-    : __t_(__t), __p_(__p)
-{
-    if (0 < __p_ && __p_ < 1)
-    {
-        __r0_ = static_cast<result_type>((__t_ + 1) * __p_);
-        __pr_ = _VSTD::exp(std::__libcpp_lgamma(__t_ + 1.) -
-                           std::__libcpp_lgamma(__r0_ + 1.) -
-                           std::__libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
-                           (__t_ - __r0_) * _VSTD::log(1 - __p_));
-        __odds_ratio_ = __p_ / (1 - __p_);
-    }
+template <class _IntType>
+binomial_distribution<_IntType>::param_type::param_type(result_type __t, double __p) : __t_(__t), __p_(__p) {
+  if (0 < __p_ && __p_ < 1) {
+    __r0_ = static_cast<result_type>((__t_ + 1) * __p_);
+    __pr_ = std::exp(
+        std::__libcpp_lgamma(__t_ + 1.) - std::__libcpp_lgamma(__r0_ + 1.) - std::__libcpp_lgamma(__t_ - __r0_ + 1.) +
+        __r0_ * std::log(__p_) + (__t_ - __r0_) * std::log(1 - __p_));
+    __odds_ratio_ = __p_ / (1 - __p_);
+  }
 }
 
 // Reference: Kemp, C.D. (1986). `A modal method for generating binomial
 //           variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
-template<class _IntType>
-template<class _URNG>
-_IntType
-binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    if (__pr.__t_ == 0 || __pr.__p_ == 0)
-        return 0;
-    if (__pr.__p_ == 1)
-        return __pr.__t_;
-    uniform_real_distribution<double> __gen;
-    double __u = __gen(__g) - __pr.__pr_;
-    if (__u < 0)
-        return __pr.__r0_;
-    double __pu = __pr.__pr_;
-    double __pd = __pu;
-    result_type __ru = __pr.__r0_;
-    result_type __rd = __ru;
-    while (true)
-    {
-        bool __break = true;
-        if (__rd >= 1)
-        {
-            __pd *= __rd / (__pr.__odds_ratio_ * (__pr.__t_ - __rd + 1));
-            __u -= __pd;
-            __break = false;
-            if (__u < 0)
-                return __rd - 1;
-        }
-        if ( __rd != 0 )
-            --__rd;
-        ++__ru;
-        if (__ru <= __pr.__t_)
-        {
-            __pu *= (__pr.__t_ - __ru + 1) * __pr.__odds_ratio_ / __ru;
-            __u -= __pu;
-            __break = false;
-            if (__u < 0)
-                return __ru;
-        }
-        if (__break)
-            return 0;
+template <class _IntType>
+template <class _URNG>
+_IntType binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  if (__pr.__t_ == 0 || __pr.__p_ == 0)
+    return 0;
+  if (__pr.__p_ == 1)
+    return __pr.__t_;
+  uniform_real_distribution<double> __gen;
+  double __u = __gen(__g) - __pr.__pr_;
+  if (__u < 0)
+    return __pr.__r0_;
+  double __pu      = __pr.__pr_;
+  double __pd      = __pu;
+  result_type __ru = __pr.__r0_;
+  result_type __rd = __ru;
+  while (true) {
+    bool __break = true;
+    if (__rd >= 1) {
+      __pd *= __rd / (__pr.__odds_ratio_ * (__pr.__t_ - __rd + 1));
+      __u -= __pd;
+      __break = false;
+      if (__u < 0)
+        return __rd - 1;
     }
+    if (__rd != 0)
+      --__rd;
+    ++__ru;
+    if (__ru <= __pr.__t_) {
+      __pu *= (__pr.__t_ - __ru + 1) * __pr.__odds_ratio_ / __ru;
+      __u -= __pu;
+      __break = false;
+      if (__u < 0)
+        return __ru;
+    }
+    if (__break)
+      return 0;
+  }
 }
 
 template <class _CharT, class _Traits, class _IntType>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const binomial_distribution<_IntType>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.t() << __sp << __x.p();
+operator<<(basic_ostream<_CharT, _Traits>& __os, const binomial_distribution<_IntType>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  return __os << __x.t() << __sp << __x.p();
 }
 
 template <class _CharT, class _Traits, class _IntType>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           binomial_distribution<_IntType>& __x)
-{
-    typedef binomial_distribution<_IntType> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __t;
-    double __p;
-    __is >> __t >> __p;
-    if (!__is.fail())
-        __x.param(param_type(__t, __p));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, binomial_distribution<_IntType>& __x) {
+  typedef binomial_distribution<_IntType> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __t;
+  double __p;
+  __is >> __t >> __p;
+  if (!__is.fail())
+    __x.param(param_type(__t, __p));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/cauchy_distribution.h b/third_party/libcxx/__random/cauchy_distribution.h
index 2fda6b538..bd341427a 100644
--- a/third_party/libcxx/__random/cauchy_distribution.h
+++ b/third_party/libcxx/__random/cauchy_distribution.h
@@ -25,136 +25,111 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS cauchy_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS cauchy_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __a_;
-        result_type __b_;
-    public:
-        typedef cauchy_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __a_;
+    result_type __b_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __a = 0, result_type __b = 1)
-            : __a_(__a), __b_(__b) {}
+  public:
+    typedef cauchy_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type a() const {return __a_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type b() const {return __b_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = 1) : __a_(__a), __b_(__b) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type a() const { return __a_; }
+    _LIBCPP_HIDE_FROM_ABI result_type b() const { return __b_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructor and reset functions
+  // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    cauchy_distribution() : cauchy_distribution(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit cauchy_distribution(result_type __a, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
+  _LIBCPP_HIDE_FROM_ABI cauchy_distribution() : cauchy_distribution(0) {}
+  _LIBCPP_HIDE_FROM_ABI explicit cauchy_distribution(result_type __a, result_type __b = 1)
+      : __p_(param_type(__a, __b)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
+      : __p_(param_type(__a, __b)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit cauchy_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit cauchy_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type a() const {return __p_.a();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type b() const {return __p_.b();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type a() const { return __p_.a(); }
+  _LIBCPP_HIDE_FROM_ABI result_type b() const { return __p_.b(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return -numeric_limits<result_type>::infinity();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return -numeric_limits<result_type>::infinity(); }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const cauchy_distribution& __x,
-                        const cauchy_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const cauchy_distribution& __x,
-                        const cauchy_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const cauchy_distribution& __x, const cauchy_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const cauchy_distribution& __x, const cauchy_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _RealType>
-template<class _URNG>
-inline
-_RealType
-cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    uniform_real_distribution<result_type> __gen;
-    // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
-    return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
+template <class _URNG>
+inline _RealType cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  uniform_real_distribution<result_type> __gen;
+  // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
+  return __p.a() + __p.b() * std::tan(3.1415926535897932384626433832795 * __gen(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const cauchy_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.a() << __sp << __x.b();
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const cauchy_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  __os << __x.a() << __sp << __x.b();
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           cauchy_distribution<_RT>& __x)
-{
-    typedef cauchy_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __a;
-    result_type __b;
-    __is >> __a >> __b;
-    if (!__is.fail())
-        __x.param(param_type(__a, __b));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, cauchy_distribution<_RT>& __x) {
+  typedef cauchy_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __a;
+  result_type __b;
+  __is >> __a >> __b;
+  if (!__is.fail())
+    __x.param(param_type(__a, __b));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/chi_squared_distribution.h b/third_party/libcxx/__random/chi_squared_distribution.h
index f2922b64d..efa96dcda 100644
--- a/third_party/libcxx/__random/chi_squared_distribution.h
+++ b/third_party/libcxx/__random/chi_squared_distribution.h
@@ -11,6 +11,7 @@
 
 #include <__config>
 #include <__random/gamma_distribution.h>
+#include <__random/is_valid.h>
 #include <iosfwd>
 #include <limits>
 
@@ -23,118 +24,98 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS chi_squared_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS chi_squared_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __n_;
-    public:
-        typedef chi_squared_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __n_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __n = 1) : __n_(__n) {}
+  public:
+    typedef chi_squared_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type n() const {return __n_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __n = 1) : __n_(__n) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__n_ == __y.__n_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type n() const { return __n_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__n_ == __y.__n_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructor and reset functions
+  // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    chi_squared_distribution() : chi_squared_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit chi_squared_distribution(result_type __n)
-        : __p_(param_type(__n)) {}
+  _LIBCPP_HIDE_FROM_ABI chi_squared_distribution() : chi_squared_distribution(1) {}
+  _LIBCPP_HIDE_FROM_ABI explicit chi_squared_distribution(result_type __n) : __p_(param_type(__n)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit chi_squared_distribution(result_type __n = 1)
-        : __p_(param_type(__n)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit chi_squared_distribution(result_type __n = 1) : __p_(param_type(__n)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit chi_squared_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit chi_squared_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g, const param_type& __p)
-        {return gamma_distribution<result_type>(__p.n() / 2, 2)(__g);}
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p) {
+    return gamma_distribution<result_type>(__p.n() / 2, 2)(__g);
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type n() const {return __p_.n();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type n() const { return __p_.n(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const chi_squared_distribution& __x,
-                        const chi_squared_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const chi_squared_distribution& __x,
-                        const chi_squared_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const chi_squared_distribution& __x, const chi_squared_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const chi_squared_distribution& __x, const chi_squared_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const chi_squared_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    __os << __x.n();
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const chi_squared_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  __os << __x.n();
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           chi_squared_distribution<_RT>& __x)
-{
-    typedef chi_squared_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __n;
-    __is >> __n;
-    if (!__is.fail())
-        __x.param(param_type(__n));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, chi_squared_distribution<_RT>& __x) {
+  typedef chi_squared_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __n;
+  __is >> __n;
+  if (!__is.fail())
+    __x.param(param_type(__n));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/clamp_to_integral.h b/third_party/libcxx/__random/clamp_to_integral.h
index c67d76d6e..d9bfd31b7 100644
--- a/third_party/libcxx/__random/clamp_to_integral.h
+++ b/third_party/libcxx/__random/clamp_to_integral.h
@@ -22,17 +22,18 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _IntT, class _FloatT,
-    bool _FloatBigger = (numeric_limits<_FloatT>::digits > numeric_limits<_IntT>::digits),
-    int _Bits = (numeric_limits<_IntT>::digits - numeric_limits<_FloatT>::digits)>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR _IntT __max_representable_int_for_float() _NOEXCEPT {
+template <class _IntT,
+          class _FloatT,
+          bool _FloatBigger = (numeric_limits<_FloatT>::digits > numeric_limits<_IntT>::digits),
+          int _Bits         = (numeric_limits<_IntT>::digits - numeric_limits<_FloatT>::digits)>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _IntT __max_representable_int_for_float() _NOEXCEPT {
   static_assert(is_floating_point<_FloatT>::value, "must be a floating point type");
   static_assert(is_integral<_IntT>::value, "must be an integral type");
   static_assert(numeric_limits<_FloatT>::radix == 2, "FloatT has incorrect radix");
-  static_assert((_IsSame<_FloatT, float>::value || _IsSame<_FloatT, double>::value
-                 || _IsSame<_FloatT,long double>::value), "unsupported floating point type");
-  return _FloatBigger ? numeric_limits<_IntT>::max() :  (numeric_limits<_IntT>::max() >> _Bits << _Bits);
+  static_assert(
+      (_IsSame<_FloatT, float>::value || _IsSame<_FloatT, double>::value || _IsSame<_FloatT, long double>::value),
+      "unsupported floating point type");
+  return _FloatBigger ? numeric_limits<_IntT>::max() : (numeric_limits<_IntT>::max() >> _Bits << _Bits);
 }
 
 // Convert a floating point number to the specified integral type after
@@ -40,9 +41,8 @@ _LIBCPP_CONSTEXPR _IntT __max_representable_int_for_float() _NOEXCEPT {
 //
 // The behavior is undefined if `__r` is NaN.
 template <class _IntT, class _RealT>
-_LIBCPP_INLINE_VISIBILITY
-_IntT __clamp_to_integral(_RealT __r) _NOEXCEPT {
-  using _Lim = numeric_limits<_IntT>;
+_LIBCPP_HIDE_FROM_ABI _IntT __clamp_to_integral(_RealT __r) _NOEXCEPT {
+  using _Lim            = numeric_limits<_IntT>;
   const _IntT __max_val = __max_representable_int_for_float<_IntT, _RealT>();
   if (__r >= ::nextafter(static_cast<_RealT>(__max_val), INFINITY)) {
     return _Lim::max();
diff --git a/third_party/libcxx/__random/discard_block_engine.h b/third_party/libcxx/__random/discard_block_engine.h
index 7bdcb6555..07f599067 100644
--- a/third_party/libcxx/__random/discard_block_engine.h
+++ b/third_party/libcxx/__random/discard_block_engine.h
@@ -27,177 +27,142 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Engine, size_t __p, size_t __r>
-class _LIBCPP_TEMPLATE_VIS discard_block_engine
-{
-    _Engine __e_;
-    int     __n_;
+template <class _Engine, size_t __p, size_t __r>
+class _LIBCPP_TEMPLATE_VIS discard_block_engine {
+  _Engine __e_;
+  int __n_;
 
-    static_assert(  0 <  __r, "discard_block_engine invalid parameters");
-    static_assert(__r <= __p, "discard_block_engine invalid parameters");
+  static_assert(0 < __r, "discard_block_engine invalid parameters");
+  static_assert(__r <= __p, "discard_block_engine invalid parameters");
 #ifndef _LIBCPP_CXX03_LANG // numeric_limits::max() is not constexpr in C++03
-    static_assert(__r <= numeric_limits<int>::max(), "discard_block_engine invalid parameters");
+  static_assert(__r <= numeric_limits<int>::max(), "discard_block_engine invalid parameters");
 #endif
-public:
-    // types
-    typedef typename _Engine::result_type result_type;
 
-    // engine characteristics
-    static _LIBCPP_CONSTEXPR const size_t block_size = __p;
-    static _LIBCPP_CONSTEXPR const size_t used_block = __r;
+public:
+  // types
+  typedef typename _Engine::result_type result_type;
+
+  // engine characteristics
+  static _LIBCPP_CONSTEXPR const size_t block_size = __p;
+  static _LIBCPP_CONSTEXPR const size_t used_block = __r;
 
 #ifdef _LIBCPP_CXX03_LANG
-    static const result_type _Min = _Engine::_Min;
-    static const result_type _Max = _Engine::_Max;
+  static const result_type _Min = _Engine::_Min;
+  static const result_type _Max = _Engine::_Max;
 #else
-    static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
-    static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
+  static constexpr result_type _Min = _Engine::min();
+  static constexpr result_type _Max = _Engine::max();
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); }
 
-    // constructors and seeding functions
-    _LIBCPP_INLINE_VISIBILITY
-    discard_block_engine() : __n_(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit discard_block_engine(const _Engine& __e)
-        : __e_(__e), __n_(0) {}
+  // constructors and seeding functions
+  _LIBCPP_HIDE_FROM_ABI discard_block_engine() : __n_(0) {}
+  _LIBCPP_HIDE_FROM_ABI explicit discard_block_engine(const _Engine& __e) : __e_(__e), __n_(0) {}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit discard_block_engine(_Engine&& __e)
-        : __e_(_VSTD::move(__e)), __n_(0) {}
+  _LIBCPP_HIDE_FROM_ABI explicit discard_block_engine(_Engine&& __e) : __e_(std::move(__e)), __n_(0) {}
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit discard_block_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value &&
-                           !is_convertible<_Sseq, _Engine>::value>::type* = 0)
-        : __e_(__q), __n_(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed() {__e_.seed(); __n_ = 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, discard_block_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;}
+  _LIBCPP_HIDE_FROM_ABI explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
+  template <
+      class _Sseq,
+      __enable_if_t<__is_seed_sequence<_Sseq, discard_block_engine>::value && !is_convertible<_Sseq, _Engine>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit discard_block_engine(_Sseq& __q) : __e_(__q), __n_(0) {}
+  _LIBCPP_HIDE_FROM_ABI void seed() {
+    __e_.seed();
+    __n_ = 0;
+  }
+  _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd) {
+    __e_.seed(__sd);
+    __n_ = 0;
+  }
+  template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, discard_block_engine>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) {
+    __e_.seed(__q);
+    __n_ = 0;
+  }
 
-    // generating functions
-    _LIBCPP_HIDE_FROM_ABI result_type operator()();
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  // generating functions
+  _LIBCPP_HIDE_FROM_ABI result_type operator()();
+  _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    const _Engine& base() const _NOEXCEPT {return __e_;}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI const _Engine& base() const _NOEXCEPT { return __e_; }
 
-    template<class _Eng, size_t _Pp, size_t _Rp>
-    friend
-    bool
-    operator==(
-        const discard_block_engine<_Eng, _Pp, _Rp>& __x,
-        const discard_block_engine<_Eng, _Pp, _Rp>& __y);
+  template <class _Eng, size_t _Pp, size_t _Rp>
+  friend bool
+  operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x, const discard_block_engine<_Eng, _Pp, _Rp>& __y);
 
-    template<class _Eng, size_t _Pp, size_t _Rp>
-    friend
-    bool
-    operator!=(
-        const discard_block_engine<_Eng, _Pp, _Rp>& __x,
-        const discard_block_engine<_Eng, _Pp, _Rp>& __y);
+  template <class _Eng, size_t _Pp, size_t _Rp>
+  friend bool
+  operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x, const discard_block_engine<_Eng, _Pp, _Rp>& __y);
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Pp, size_t _Rp>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const discard_block_engine<_Eng, _Pp, _Rp>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp>
+  friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const discard_block_engine<_Eng, _Pp, _Rp>& __x);
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Pp, size_t _Rp>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               discard_block_engine<_Eng, _Pp, _Rp>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, discard_block_engine<_Eng, _Pp, _Rp>& __x);
 };
 
-template<class _Engine, size_t __p, size_t __r>
-    _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size;
+template <class _Engine, size_t __p, size_t __r>
+_LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size;
 
-template<class _Engine, size_t __p, size_t __r>
-    _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block;
+template <class _Engine, size_t __p, size_t __r>
+_LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block;
 
-template<class _Engine, size_t __p, size_t __r>
-typename discard_block_engine<_Engine, __p, __r>::result_type
-discard_block_engine<_Engine, __p, __r>::operator()()
-{
-    if (__n_ >= static_cast<int>(__r))
-    {
-        __e_.discard(__p - __r);
-        __n_ = 0;
-    }
-    ++__n_;
-    return __e_();
+template <class _Engine, size_t __p, size_t __r>
+typename discard_block_engine<_Engine, __p, __r>::result_type discard_block_engine<_Engine, __p, __r>::operator()() {
+  if (__n_ >= static_cast<int>(__r)) {
+    __e_.discard(__p - __r);
+    __n_ = 0;
+  }
+  ++__n_;
+  return __e_();
 }
 
-template<class _Eng, size_t _Pp, size_t _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
-           const discard_block_engine<_Eng, _Pp, _Rp>& __y)
-{
-    return __x.__n_ == __y.__n_ && __x.__e_ == __y.__e_;
+template <class _Eng, size_t _Pp, size_t _Rp>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x, const discard_block_engine<_Eng, _Pp, _Rp>& __y) {
+  return __x.__n_ == __y.__n_ && __x.__e_ == __y.__e_;
 }
 
-template<class _Eng, size_t _Pp, size_t _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
-           const discard_block_engine<_Eng, _Pp, _Rp>& __y)
-{
-    return !(__x == __y);
+template <class _Eng, size_t _Pp, size_t _Rp>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x, const discard_block_engine<_Eng, _Pp, _Rp>& __y) {
+  return !(__x == __y);
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Pp, size_t _Rp>
+template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const discard_block_engine<_Eng, _Pp, _Rp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.__e_ << __sp << __x.__n_;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const discard_block_engine<_Eng, _Pp, _Rp>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _Ostream;
+  __os.flags(_Ostream::dec | _Ostream::left);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  return __os << __x.__e_ << __sp << __x.__n_;
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Pp, size_t _Rp>
+template <class _CharT, class _Traits, class _Eng, size_t _Pp, size_t _Rp>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           discard_block_engine<_Eng, _Pp, _Rp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    _Eng __e;
-    int __n;
-    __is >> __e >> __n;
-    if (!__is.fail())
-    {
-        __x.__e_ = __e;
-        __x.__n_ = __n;
-    }
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, discard_block_engine<_Eng, _Pp, _Rp>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  _Eng __e;
+  int __n;
+  __is >> __e >> __n;
+  if (!__is.fail()) {
+    __x.__e_ = __e;
+    __x.__n_ = __n;
+  }
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/discrete_distribution.h b/third_party/libcxx/__random/discrete_distribution.h
index a6546faae..bb72dd6cb 100644
--- a/third_party/libcxx/__random/discrete_distribution.h
+++ b/third_party/libcxx/__random/discrete_distribution.h
@@ -27,234 +27,182 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS discrete_distribution
-{
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
+template <class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS discrete_distribution {
+  static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
+
 public:
-    // types
-    typedef _IntType result_type;
+  // types
+  typedef _IntType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        vector<double> __p_;
-    public:
-        typedef discrete_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    vector<double> __p_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        param_type() {}
-        template<class _InputIterator>
-            _LIBCPP_INLINE_VISIBILITY
-            param_type(_InputIterator __f, _InputIterator __l)
-            : __p_(__f, __l) {__init();}
+  public:
+    typedef discrete_distribution distribution_type;
+
+    _LIBCPP_HIDE_FROM_ABI param_type() {}
+    template <class _InputIterator>
+    _LIBCPP_HIDE_FROM_ABI param_type(_InputIterator __f, _InputIterator __l) : __p_(__f, __l) {
+      __init();
+    }
 #ifndef _LIBCPP_CXX03_LANG
-        _LIBCPP_INLINE_VISIBILITY
-        param_type(initializer_list<double> __wl)
-            : __p_(__wl.begin(), __wl.end()) {__init();}
+    _LIBCPP_HIDE_FROM_ABI param_type(initializer_list<double> __wl) : __p_(__wl.begin(), __wl.end()) { __init(); }
 #endif // _LIBCPP_CXX03_LANG
-        template<class _UnaryOperation>
-        _LIBCPP_HIDE_FROM_ABI param_type(size_t __nw, double __xmin, double __xmax,
-                       _UnaryOperation __fw);
+    template <class _UnaryOperation>
+    _LIBCPP_HIDE_FROM_ABI param_type(size_t __nw, double __xmin, double __xmax, _UnaryOperation __fw);
 
-        _LIBCPP_HIDE_FROM_ABI vector<double> probabilities() const;
+    _LIBCPP_HIDE_FROM_ABI vector<double> probabilities() const;
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__p_ == __y.__p_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__p_ == __y.__p_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
 
-    private:
-        _LIBCPP_HIDE_FROM_ABI void __init();
+  private:
+    _LIBCPP_HIDE_FROM_ABI void __init();
 
-        friend class discrete_distribution;
+    friend class discrete_distribution;
 
-        template <class _CharT, class _Traits, class _IT>
-        friend
-        basic_ostream<_CharT, _Traits>&
-        operator<<(basic_ostream<_CharT, _Traits>& __os,
-                   const discrete_distribution<_IT>& __x);
+    template <class _CharT, class _Traits, class _IT>
+    friend basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const discrete_distribution<_IT>& __x);
 
-        template <class _CharT, class _Traits, class _IT>
-        friend
-        basic_istream<_CharT, _Traits>&
-        operator>>(basic_istream<_CharT, _Traits>& __is,
-                   discrete_distribution<_IT>& __x);
-    };
+    template <class _CharT, class _Traits, class _IT>
+    friend basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, discrete_distribution<_IT>& __x);
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructor and reset functions
-    _LIBCPP_INLINE_VISIBILITY
-    discrete_distribution() {}
-    template<class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        discrete_distribution(_InputIterator __f, _InputIterator __l)
-            : __p_(__f, __l) {}
+  // constructor and reset functions
+  _LIBCPP_HIDE_FROM_ABI discrete_distribution() {}
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI discrete_distribution(_InputIterator __f, _InputIterator __l) : __p_(__f, __l) {}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    discrete_distribution(initializer_list<double> __wl)
-        : __p_(__wl) {}
+  _LIBCPP_HIDE_FROM_ABI discrete_distribution(initializer_list<double> __wl) : __p_(__wl) {}
 #endif // _LIBCPP_CXX03_LANG
-    template<class _UnaryOperation>
-        _LIBCPP_INLINE_VISIBILITY
-        discrete_distribution(size_t __nw, double __xmin, double __xmax,
-                              _UnaryOperation __fw)
-        : __p_(__nw, __xmin, __xmax, __fw) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit discrete_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  template <class _UnaryOperation>
+  _LIBCPP_HIDE_FROM_ABI discrete_distribution(size_t __nw, double __xmin, double __xmax, _UnaryOperation __fw)
+      : __p_(__nw, __xmin, __xmax, __fw) {}
+  _LIBCPP_HIDE_FROM_ABI explicit discrete_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    vector<double> probabilities() const {return __p_.probabilities();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI vector<double> probabilities() const { return __p_.probabilities(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return __p_.__p_.size();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return __p_.__p_.size(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const discrete_distribution& __x,
-                        const discrete_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const discrete_distribution& __x,
-                        const discrete_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const discrete_distribution& __x, const discrete_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const discrete_distribution& __x, const discrete_distribution& __y) {
+    return !(__x == __y);
+  }
 
-    template <class _CharT, class _Traits, class _IT>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const discrete_distribution<_IT>& __x);
+  template <class _CharT, class _Traits, class _IT>
+  friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const discrete_distribution<_IT>& __x);
 
-    template <class _CharT, class _Traits, class _IT>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               discrete_distribution<_IT>& __x);
+  template <class _CharT, class _Traits, class _IT>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, discrete_distribution<_IT>& __x);
 };
 
-template<class _IntType>
-template<class _UnaryOperation>
-discrete_distribution<_IntType>::param_type::param_type(size_t __nw,
-                                                        double __xmin,
-                                                        double __xmax,
-                                                        _UnaryOperation __fw)
-{
-    if (__nw > 1)
-    {
-        __p_.reserve(__nw - 1);
-        double __d = (__xmax - __xmin) / __nw;
-        double __d2 = __d / 2;
-        for (size_t __k = 0; __k < __nw; ++__k)
-            __p_.push_back(__fw(__xmin + __k * __d + __d2));
-        __init();
+template <class _IntType>
+template <class _UnaryOperation>
+discrete_distribution<_IntType>::param_type::param_type(
+    size_t __nw, double __xmin, double __xmax, _UnaryOperation __fw) {
+  if (__nw > 1) {
+    __p_.reserve(__nw - 1);
+    double __d  = (__xmax - __xmin) / __nw;
+    double __d2 = __d / 2;
+    for (size_t __k = 0; __k < __nw; ++__k)
+      __p_.push_back(__fw(__xmin + __k * __d + __d2));
+    __init();
+  }
+}
+
+template <class _IntType>
+void discrete_distribution<_IntType>::param_type::__init() {
+  if (!__p_.empty()) {
+    if (__p_.size() > 1) {
+      double __s = std::accumulate(__p_.begin(), __p_.end(), 0.0);
+      for (vector<double>::iterator __i = __p_.begin(), __e = __p_.end(); __i < __e; ++__i)
+        *__i /= __s;
+      vector<double> __t(__p_.size() - 1);
+      std::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
+      swap(__p_, __t);
+    } else {
+      __p_.clear();
+      __p_.shrink_to_fit();
     }
+  }
 }
 
-template<class _IntType>
-void
-discrete_distribution<_IntType>::param_type::__init()
-{
-    if (!__p_.empty())
-    {
-        if (__p_.size() > 1)
-        {
-            double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0);
-            for (vector<double>::iterator __i = __p_.begin(), __e = __p_.end(); __i < __e; ++__i)
-                *__i /= __s;
-            vector<double> __t(__p_.size() - 1);
-            _VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
-            swap(__p_, __t);
-        }
-        else
-        {
-            __p_.clear();
-            __p_.shrink_to_fit();
-        }
-    }
+template <class _IntType>
+vector<double> discrete_distribution<_IntType>::param_type::probabilities() const {
+  size_t __n = __p_.size();
+  vector<double> __p(__n + 1);
+  std::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
+  if (__n > 0)
+    __p[__n] = 1 - __p_[__n - 1];
+  else
+    __p[0] = 1;
+  return __p;
 }
 
-template<class _IntType>
-vector<double>
-discrete_distribution<_IntType>::param_type::probabilities() const
-{
-    size_t __n = __p_.size();
-    vector<double> __p(__n+1);
-    _VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
-    if (__n > 0)
-        __p[__n] = 1 - __p_[__n-1];
-    else
-        __p[0] = 1;
-    return __p;
-}
-
-template<class _IntType>
-template<class _URNG>
-_IntType
-discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    uniform_real_distribution<double> __gen;
-    return static_cast<_IntType>(
-           _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
-                                                              __p.__p_.begin());
+template <class _IntType>
+template <class _URNG>
+_IntType discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  uniform_real_distribution<double> __gen;
+  return static_cast<_IntType>(std::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) - __p.__p_.begin());
 }
 
 template <class _CharT, class _Traits, class _IT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const discrete_distribution<_IT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    size_t __n = __x.__p_.__p_.size();
-    __os << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__p_[__i];
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const discrete_distribution<_IT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  size_t __n = __x.__p_.__p_.size();
+  __os << __n;
+  for (size_t __i = 0; __i < __n; ++__i)
+    __os << __sp << __x.__p_.__p_[__i];
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _IT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           discrete_distribution<_IT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    size_t __n;
-    __is >> __n;
-    vector<double> __p(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __p[__i];
-    if (!__is.fail())
-        swap(__x.__p_.__p_, __p);
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, discrete_distribution<_IT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  size_t __n;
+  __is >> __n;
+  vector<double> __p(__n);
+  for (size_t __i = 0; __i < __n; ++__i)
+    __is >> __p[__i];
+  if (!__is.fail())
+    swap(__x.__p_.__p_, __p);
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/exponential_distribution.h b/third_party/libcxx/__random/exponential_distribution.h
index b33b072ec..e0e388411 100644
--- a/third_party/libcxx/__random/exponential_distribution.h
+++ b/third_party/libcxx/__random/exponential_distribution.h
@@ -26,129 +26,103 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS exponential_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS exponential_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __lambda_;
-    public:
-        typedef exponential_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __lambda_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}
+  public:
+    typedef exponential_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type lambda() const {return __lambda_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__lambda_ == __y.__lambda_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type lambda() const { return __lambda_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__lambda_ == __y.__lambda_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructors and reset functions
+  // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    exponential_distribution() : exponential_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit exponential_distribution(result_type __lambda)
-        : __p_(param_type(__lambda)) {}
+  _LIBCPP_HIDE_FROM_ABI exponential_distribution() : exponential_distribution(1) {}
+  _LIBCPP_HIDE_FROM_ABI explicit exponential_distribution(result_type __lambda) : __p_(param_type(__lambda)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit exponential_distribution(result_type __lambda = 1)
-        : __p_(param_type(__lambda)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit exponential_distribution(result_type __lambda = 1) : __p_(param_type(__lambda)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type lambda() const {return __p_.lambda();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type lambda() const { return __p_.lambda(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const exponential_distribution& __x,
-                        const exponential_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const exponential_distribution& __x,
-                        const exponential_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const exponential_distribution& __x, const exponential_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const exponential_distribution& __x, const exponential_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _RealType>
-template<class _URNG>
-_RealType
-exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    return -_VSTD::log
-                  (
-                      result_type(1) -
-                      _VSTD::generate_canonical<result_type,
-                                       numeric_limits<result_type>::digits>(__g)
-                  )
-                  / __p.lambda();
+template <class _URNG>
+_RealType exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  return -std::log(result_type(1) - std::generate_canonical<result_type, numeric_limits<result_type>::digits>(__g)) /
+         __p.lambda();
 }
 
 template <class _CharT, class _Traits, class _RealType>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const exponential_distribution<_RealType>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    return __os << __x.lambda();
+operator<<(basic_ostream<_CharT, _Traits>& __os, const exponential_distribution<_RealType>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  return __os << __x.lambda();
 }
 
 template <class _CharT, class _Traits, class _RealType>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           exponential_distribution<_RealType>& __x)
-{
-    typedef exponential_distribution<_RealType> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __lambda;
-    __is >> __lambda;
-    if (!__is.fail())
-        __x.param(param_type(__lambda));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, exponential_distribution<_RealType>& __x) {
+  typedef exponential_distribution<_RealType> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __lambda;
+  __is >> __lambda;
+  if (!__is.fail())
+    __x.param(param_type(__lambda));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/extreme_value_distribution.h b/third_party/libcxx/__random/extreme_value_distribution.h
index c583ec06a..5505f9327 100644
--- a/third_party/libcxx/__random/extreme_value_distribution.h
+++ b/third_party/libcxx/__random/extreme_value_distribution.h
@@ -25,136 +25,111 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS extreme_value_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS extreme_value_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __a_;
-        result_type __b_;
-    public:
-        typedef extreme_value_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __a_;
+    result_type __b_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __a = 0, result_type __b = 1)
-            : __a_(__a), __b_(__b) {}
+  public:
+    typedef extreme_value_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type a() const {return __a_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type b() const {return __b_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = 1) : __a_(__a), __b_(__b) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type a() const { return __a_; }
+    _LIBCPP_HIDE_FROM_ABI result_type b() const { return __b_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructor and reset functions
+  // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    extreme_value_distribution() : extreme_value_distribution(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit extreme_value_distribution(result_type __a, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
+  _LIBCPP_HIDE_FROM_ABI extreme_value_distribution() : extreme_value_distribution(0) {}
+  _LIBCPP_HIDE_FROM_ABI explicit extreme_value_distribution(result_type __a, result_type __b = 1)
+      : __p_(param_type(__a, __b)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit extreme_value_distribution(result_type __a = 0,
-                                        result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit extreme_value_distribution(result_type __a = 0, result_type __b = 1)
+      : __p_(param_type(__a, __b)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit extreme_value_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit extreme_value_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type a() const {return __p_.a();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type b() const {return __p_.b();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type a() const { return __p_.a(); }
+  _LIBCPP_HIDE_FROM_ABI result_type b() const { return __p_.b(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return -numeric_limits<result_type>::infinity();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return -numeric_limits<result_type>::infinity(); }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const extreme_value_distribution& __x,
-                        const extreme_value_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const extreme_value_distribution& __x,
-                        const extreme_value_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const extreme_value_distribution& __x, const extreme_value_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const extreme_value_distribution& __x, const extreme_value_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
-template<class _RealType>
-template<class _URNG>
-_RealType
-extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    return __p.a() - __p.b() *
-         _VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
+template <class _RealType>
+template <class _URNG>
+_RealType extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  return __p.a() - __p.b() * std::log(-std::log(1 - uniform_real_distribution<result_type>()(__g)));
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const extreme_value_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.a() << __sp << __x.b();
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const extreme_value_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  __os << __x.a() << __sp << __x.b();
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           extreme_value_distribution<_RT>& __x)
-{
-    typedef extreme_value_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __a;
-    result_type __b;
-    __is >> __a >> __b;
-    if (!__is.fail())
-        __x.param(param_type(__a, __b));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, extreme_value_distribution<_RT>& __x) {
+  typedef extreme_value_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __a;
+  result_type __b;
+  __is >> __a >> __b;
+  if (!__is.fail())
+    __x.param(param_type(__a, __b));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/fisher_f_distribution.h b/third_party/libcxx/__random/fisher_f_distribution.h
index b757607bc..cd170b3af 100644
--- a/third_party/libcxx/__random/fisher_f_distribution.h
+++ b/third_party/libcxx/__random/fisher_f_distribution.h
@@ -24,136 +24,111 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS fisher_f_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS fisher_f_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __m_;
-        result_type __n_;
-    public:
-        typedef fisher_f_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __m_;
+    result_type __n_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __m = 1, result_type __n = 1)
-            : __m_(__m), __n_(__n) {}
+  public:
+    typedef fisher_f_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type m() const {return __m_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type n() const {return __n_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __m = 1, result_type __n = 1) : __m_(__m), __n_(__n) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type m() const { return __m_; }
+    _LIBCPP_HIDE_FROM_ABI result_type n() const { return __n_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructor and reset functions
+  // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    fisher_f_distribution() : fisher_f_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit fisher_f_distribution(result_type __m, result_type __n = 1)
-        : __p_(param_type(__m, __n)) {}
+  _LIBCPP_HIDE_FROM_ABI fisher_f_distribution() : fisher_f_distribution(1) {}
+  _LIBCPP_HIDE_FROM_ABI explicit fisher_f_distribution(result_type __m, result_type __n = 1)
+      : __p_(param_type(__m, __n)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
-        : __p_(param_type(__m, __n)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
+      : __p_(param_type(__m, __n)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit fisher_f_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit fisher_f_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type m() const {return __p_.m();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type n() const {return __p_.n();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type m() const { return __p_.m(); }
+  _LIBCPP_HIDE_FROM_ABI result_type n() const { return __p_.n(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const fisher_f_distribution& __x,
-                        const fisher_f_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const fisher_f_distribution& __x,
-                        const fisher_f_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const fisher_f_distribution& __x, const fisher_f_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const fisher_f_distribution& __x, const fisher_f_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _RealType>
-template<class _URNG>
-_RealType
-fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    gamma_distribution<result_type> __gdm(__p.m() * result_type(.5));
-    gamma_distribution<result_type> __gdn(__p.n() * result_type(.5));
-    return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g));
+template <class _URNG>
+_RealType fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  gamma_distribution<result_type> __gdm(__p.m() * result_type(.5));
+  gamma_distribution<result_type> __gdn(__p.n() * result_type(.5));
+  return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const fisher_f_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.m() << __sp << __x.n();
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const fisher_f_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  __os << __x.m() << __sp << __x.n();
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           fisher_f_distribution<_RT>& __x)
-{
-    typedef fisher_f_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __m;
-    result_type __n;
-    __is >> __m >> __n;
-    if (!__is.fail())
-        __x.param(param_type(__m, __n));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, fisher_f_distribution<_RT>& __x) {
+  typedef fisher_f_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __m;
+  result_type __n;
+  __is >> __m >> __n;
+  if (!__is.fail())
+    __x.param(param_type(__m, __n));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/gamma_distribution.h b/third_party/libcxx/__random/gamma_distribution.h
index 777f6b5c7..986e42c1c 100644
--- a/third_party/libcxx/__random/gamma_distribution.h
+++ b/third_party/libcxx/__random/gamma_distribution.h
@@ -26,187 +26,152 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS gamma_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS gamma_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __alpha_;
-        result_type __beta_;
-    public:
-        typedef gamma_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __alpha_;
+    result_type __beta_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __alpha = 1, result_type __beta = 1)
-            : __alpha_(__alpha), __beta_(__beta) {}
+  public:
+    typedef gamma_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type alpha() const {return __alpha_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type beta() const {return __beta_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __alpha = 1, result_type __beta = 1)
+        : __alpha_(__alpha), __beta_(__beta) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type alpha() const { return __alpha_; }
+    _LIBCPP_HIDE_FROM_ABI result_type beta() const { return __beta_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructors and reset functions
+  // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    gamma_distribution() : gamma_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit gamma_distribution(result_type __alpha, result_type __beta = 1)
-        : __p_(param_type(__alpha, __beta)) {}
+  _LIBCPP_HIDE_FROM_ABI gamma_distribution() : gamma_distribution(1) {}
+  _LIBCPP_HIDE_FROM_ABI explicit gamma_distribution(result_type __alpha, result_type __beta = 1)
+      : __p_(param_type(__alpha, __beta)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit gamma_distribution(result_type __alpha = 1,
-                                result_type __beta = 1)
-        : __p_(param_type(__alpha, __beta)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit gamma_distribution(result_type __alpha = 1, result_type __beta = 1)
+      : __p_(param_type(__alpha, __beta)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit gamma_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit gamma_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type alpha() const {return __p_.alpha();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type beta() const {return __p_.beta();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type alpha() const { return __p_.alpha(); }
+  _LIBCPP_HIDE_FROM_ABI result_type beta() const { return __p_.beta(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const gamma_distribution& __x,
-                        const gamma_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const gamma_distribution& __x,
-                        const gamma_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const gamma_distribution& __x, const gamma_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const gamma_distribution& __x, const gamma_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _RealType>
-template<class _URNG>
-_RealType
-gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    result_type __a = __p.alpha();
-    uniform_real_distribution<result_type> __gen(0, 1);
-    exponential_distribution<result_type> __egen;
-    result_type __x;
-    if (__a == 1)
-        __x = __egen(__g);
-    else if (__a > 1)
-    {
-        const result_type __b = __a - 1;
-        const result_type __c = 3 * __a - result_type(0.75);
-        while (true)
-        {
-            const result_type __u = __gen(__g);
-            const result_type __v = __gen(__g);
-            const result_type __w = __u * (1 - __u);
-            if (__w != 0)
-            {
-                const result_type __y = _VSTD::sqrt(__c / __w) *
-                                        (__u - result_type(0.5));
-                __x = __b + __y;
-                if (__x >= 0)
-                {
-                    const result_type __z = 64 * __w * __w * __w * __v * __v;
-                    if (__z <= 1 - 2 * __y * __y / __x)
-                        break;
-                    if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y))
-                        break;
-                }
-            }
+template <class _URNG>
+_RealType gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  result_type __a = __p.alpha();
+  uniform_real_distribution<result_type> __gen(0, 1);
+  exponential_distribution<result_type> __egen;
+  result_type __x;
+  if (__a == 1)
+    __x = __egen(__g);
+  else if (__a > 1) {
+    const result_type __b = __a - 1;
+    const result_type __c = 3 * __a - result_type(0.75);
+    while (true) {
+      const result_type __u = __gen(__g);
+      const result_type __v = __gen(__g);
+      const result_type __w = __u * (1 - __u);
+      if (__w != 0) {
+        const result_type __y = std::sqrt(__c / __w) * (__u - result_type(0.5));
+        __x                   = __b + __y;
+        if (__x >= 0) {
+          const result_type __z = 64 * __w * __w * __w * __v * __v;
+          if (__z <= 1 - 2 * __y * __y / __x)
+            break;
+          if (std::log(__z) <= 2 * (__b * std::log(__x / __b) - __y))
+            break;
         }
+      }
     }
-    else  // __a < 1
-    {
-        while (true)
-        {
-            const result_type __u = __gen(__g);
-            const result_type __es = __egen(__g);
-            if (__u <= 1 - __a)
-            {
-                __x = _VSTD::pow(__u, 1 / __a);
-                if (__x <= __es)
-                    break;
-            }
-            else
-            {
-                const result_type __e = -_VSTD::log((1-__u)/__a);
-                __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
-                if (__x <= __e + __es)
-                    break;
-            }
-        }
+  } else // __a < 1
+  {
+    while (true) {
+      const result_type __u  = __gen(__g);
+      const result_type __es = __egen(__g);
+      if (__u <= 1 - __a) {
+        __x = std::pow(__u, 1 / __a);
+        if (__x <= __es)
+          break;
+      } else {
+        const result_type __e = -std::log((1 - __u) / __a);
+        __x                   = std::pow(1 - __a + __a * __e, 1 / __a);
+        if (__x <= __e + __es)
+          break;
+      }
     }
-    return __x * __p.beta();
+  }
+  return __x * __p.beta();
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const gamma_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.alpha() << __sp << __x.beta();
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const gamma_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  __os << __x.alpha() << __sp << __x.beta();
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           gamma_distribution<_RT>& __x)
-{
-    typedef gamma_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __alpha;
-    result_type __beta;
-    __is >> __alpha >> __beta;
-    if (!__is.fail())
-        __x.param(param_type(__alpha, __beta));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, gamma_distribution<_RT>& __x) {
+  typedef gamma_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __alpha;
+  result_type __beta;
+  __is >> __alpha >> __beta;
+  if (!__is.fail())
+    __x.param(param_type(__alpha, __beta));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/generate_canonical.h b/third_party/libcxx/__random/generate_canonical.h
index 5f0aa6fd8..738de1517 100644
--- a/third_party/libcxx/__random/generate_canonical.h
+++ b/third_party/libcxx/__random/generate_canonical.h
@@ -26,24 +26,22 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // generate_canonical
 
-template<class _RealType, size_t __bits, class _URNG>
-_LIBCPP_HIDE_FROM_ABI _RealType
-generate_canonical(_URNG& __g)
-{
-    const size_t __dt = numeric_limits<_RealType>::digits;
-    const size_t __b = __dt < __bits ? __dt : __bits;
+template <class _RealType, size_t __bits, class _URNG>
+_LIBCPP_HIDE_FROM_ABI _RealType generate_canonical(_URNG& __g) {
+  const size_t __dt = numeric_limits<_RealType>::digits;
+  const size_t __b  = __dt < __bits ? __dt : __bits;
 #ifdef _LIBCPP_CXX03_LANG
-    const size_t __log_r = __log2<uint64_t, _URNG::_Max - _URNG::_Min + uint64_t(1)>::value;
+  const size_t __log_r = __log2<uint64_t, _URNG::_Max - _URNG::_Min + uint64_t(1)>::value;
 #else
-    const size_t __log_r = __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value;
+  const size_t __log_r = __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value;
 #endif
-    const size_t __k = __b / __log_r + (__b % __log_r != 0) + (__b == 0);
-    const _RealType __rp = static_cast<_RealType>(_URNG::max() - _URNG::min()) + _RealType(1);
-    _RealType __base = __rp;
-    _RealType __sp = __g() - _URNG::min();
-    for (size_t __i = 1; __i < __k; ++__i, __base *= __rp)
-        __sp += (__g() - _URNG::min()) * __base;
-    return __sp / __base;
+  const size_t __k     = __b / __log_r + (__b % __log_r != 0) + (__b == 0);
+  const _RealType __rp = static_cast<_RealType>(_URNG::max() - _URNG::min()) + _RealType(1);
+  _RealType __base     = __rp;
+  _RealType __sp       = __g() - _URNG::min();
+  for (size_t __i = 1; __i < __k; ++__i, __base *= __rp)
+    __sp += (__g() - _URNG::min()) * __base;
+  return __sp / __base;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/geometric_distribution.h b/third_party/libcxx/__random/geometric_distribution.h
index 8f9bdffc7..cecd7e57c 100644
--- a/third_party/libcxx/__random/geometric_distribution.h
+++ b/third_party/libcxx/__random/geometric_distribution.h
@@ -24,116 +24,93 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS geometric_distribution
-{
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
+template <class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS geometric_distribution {
+  static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
+
 public:
-    // types
-    typedef _IntType result_type;
+  // types
+  typedef _IntType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        double __p_;
-    public:
-        typedef geometric_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    double __p_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(double __p = 0.5) : __p_(__p) {}
+  public:
+    typedef geometric_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        double p() const {return __p_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(double __p = 0.5) : __p_(__p) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__p_ == __y.__p_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI double p() const { return __p_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__p_ == __y.__p_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructors and reset functions
+  // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    geometric_distribution() : geometric_distribution(0.5) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit geometric_distribution(double __p)
-        : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI geometric_distribution() : geometric_distribution(0.5) {}
+  _LIBCPP_HIDE_FROM_ABI explicit geometric_distribution(double __p) : __p_(__p) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit geometric_distribution(double __p = 0.5)
-        : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI explicit geometric_distribution(double __p = 0.5) : __p_(__p) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g, const param_type& __p)
-        {return negative_binomial_distribution<result_type>(1, __p.p())(__g);}
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p) {
+    return negative_binomial_distribution<result_type>(1, __p.p())(__g);
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    double p() const {return __p_.p();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI double p() const { return __p_.p(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::max();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::max(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const geometric_distribution& __x,
-                        const geometric_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const geometric_distribution& __x,
-                        const geometric_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const geometric_distribution& __x, const geometric_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const geometric_distribution& __x, const geometric_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _CharT, class _Traits, class _IntType>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const geometric_distribution<_IntType>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    return __os << __x.p();
+operator<<(basic_ostream<_CharT, _Traits>& __os, const geometric_distribution<_IntType>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  return __os << __x.p();
 }
 
 template <class _CharT, class _Traits, class _IntType>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           geometric_distribution<_IntType>& __x)
-{
-    typedef geometric_distribution<_IntType> _Eng;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    double __p;
-    __is >> __p;
-    if (!__is.fail())
-        __x.param(param_type(__p));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, geometric_distribution<_IntType>& __x) {
+  typedef geometric_distribution<_IntType> _Eng;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  double __p;
+  __is >> __p;
+  if (!__is.fail())
+    __x.param(param_type(__p));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/independent_bits_engine.h b/third_party/libcxx/__random/independent_bits_engine.h
index a86c22157..0f4a7b82b 100644
--- a/third_party/libcxx/__random/independent_bits_engine.h
+++ b/third_party/libcxx/__random/independent_bits_engine.h
@@ -10,6 +10,8 @@
 #define _LIBCPP___RANDOM_INDEPENDENT_BITS_ENGINE_H
 
 #include <__config>
+#include <__fwd/istream.h>
+#include <__fwd/ostream.h>
 #include <__random/is_seed_sequence.h>
 #include <__random/log2.h>
 #include <__type_traits/conditional.h>
@@ -17,7 +19,6 @@
 #include <__type_traits/is_convertible.h>
 #include <__utility/move.h>
 #include <cstddef>
-#include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -29,238 +30,172 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Engine, size_t __w, class _UIntType>
-class _LIBCPP_TEMPLATE_VIS independent_bits_engine
-{
-    template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
-    class __get_n
-    {
-        static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
-        static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
-        static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
-        static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
-    public:
-        static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
-    };
+template <class _Engine, size_t __w, class _UIntType>
+class _LIBCPP_TEMPLATE_VIS independent_bits_engine {
+  template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
+  class __get_n {
+    static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
+    static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
+    static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
+    static _LIBCPP_CONSTEXPR const _UInt _Y0  = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
+
+  public:
+    static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
+  };
+
 public:
-    // types
-    typedef _UIntType result_type;
+  // types
+  typedef _UIntType result_type;
 
 private:
-    _Engine __e_;
+  _Engine __e_;
 
-    static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
-    static_assert(  0 <  __w, "independent_bits_engine invalid parameters");
-    static_assert(__w <= _Dt, "independent_bits_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
+  static_assert(0 < __w, "independent_bits_engine invalid parameters");
+  static_assert(__w <= _Dt, "independent_bits_engine invalid parameters");
 
-    typedef typename _Engine::result_type _Engine_result_type;
-    typedef __conditional_t<sizeof(_Engine_result_type) <= sizeof(result_type), result_type, _Engine_result_type>
-        _Working_result_type;
+  typedef typename _Engine::result_type _Engine_result_type;
+  typedef __conditional_t<sizeof(_Engine_result_type) <= sizeof(result_type), result_type, _Engine_result_type>
+      _Working_result_type;
 #ifdef _LIBCPP_CXX03_LANG
-    static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
-                                          + _Working_result_type(1);
+  static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min + _Working_result_type(1);
 #else
-    static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
-                                                            + _Working_result_type(1);
+  static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min() + _Working_result_type(1);
 #endif
-    static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
-    static _LIBCPP_CONSTEXPR const size_t __n = __get_n<_Working_result_type, _Rp, __w, __m>::value;
-    static _LIBCPP_CONSTEXPR const size_t __w0 = __w / __n;
-    static _LIBCPP_CONSTEXPR const size_t __n0 = __n - __w % __n;
-    static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
-    static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
-    static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 :
-                                                               (_Rp >> __w0) << __w0;
-    static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 :
-                                                               (_Rp >> (__w0+1)) << (__w0+1);
-    static _LIBCPP_CONSTEXPR const _Engine_result_type __mask0 = __w0 > 0 ?
-                                _Engine_result_type(~0) >> (_EDt - __w0) :
-                                _Engine_result_type(0);
-    static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 = __w0 < _EDt - 1 ?
-                                _Engine_result_type(~0) >> (_EDt - (__w0 + 1)) :
-                                _Engine_result_type(~0);
+  static _LIBCPP_CONSTEXPR const size_t __m                = __log2<_Working_result_type, _Rp>::value;
+  static _LIBCPP_CONSTEXPR const size_t __n                = __get_n<_Working_result_type, _Rp, __w, __m>::value;
+  static _LIBCPP_CONSTEXPR const size_t __w0               = __w / __n;
+  static _LIBCPP_CONSTEXPR const size_t __n0               = __n - __w % __n;
+  static _LIBCPP_CONSTEXPR const size_t _WDt               = numeric_limits<_Working_result_type>::digits;
+  static _LIBCPP_CONSTEXPR const size_t _EDt               = numeric_limits<_Engine_result_type>::digits;
+  static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 : (_Rp >> __w0) << __w0;
+  static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 : (_Rp >> (__w0 + 1)) << (__w0 + 1);
+  static _LIBCPP_CONSTEXPR const
+      _Engine_result_type __mask0 = __w0 > 0 ? _Engine_result_type(~0) >> (_EDt - __w0) : _Engine_result_type(0);
+  static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 =
+      __w0 < _EDt - 1 ? _Engine_result_type(~0) >> (_EDt - (__w0 + 1)) : _Engine_result_type(~0);
+
 public:
-    static _LIBCPP_CONSTEXPR const result_type _Min = 0;
-    static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
-                                                      (result_type(1) << __w) - result_type(1);
-    static_assert(_Min < _Max, "independent_bits_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Min = 0;
+  static _LIBCPP_CONSTEXPR const result_type _Max =
+      __w == _Dt ? result_type(~0) : (result_type(1) << __w) - result_type(1);
+  static_assert(_Min < _Max, "independent_bits_engine invalid parameters");
 
-    // engine characteristics
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
+  // engine characteristics
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
 
-    // constructors and seeding functions
-    _LIBCPP_INLINE_VISIBILITY
-    independent_bits_engine() {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit independent_bits_engine(const _Engine& __e)
-        : __e_(__e) {}
+  // constructors and seeding functions
+  _LIBCPP_HIDE_FROM_ABI independent_bits_engine() {}
+  _LIBCPP_HIDE_FROM_ABI explicit independent_bits_engine(const _Engine& __e) : __e_(__e) {}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit independent_bits_engine(_Engine&& __e)
-        : __e_(_VSTD::move(__e)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit independent_bits_engine(_Engine&& __e) : __e_(std::move(__e)) {}
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit independent_bits_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value &&
-                           !is_convertible<_Sseq, _Engine>::value>::type* = 0)
-         : __e_(__q) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed() {__e_.seed();}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(result_type __sd) {__e_.seed(__sd);}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, independent_bits_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q) {__e_.seed(__q);}
+  _LIBCPP_HIDE_FROM_ABI explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
+  template <
+      class _Sseq,
+      __enable_if_t<__is_seed_sequence<_Sseq, independent_bits_engine>::value && !is_convertible<_Sseq, _Engine>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit independent_bits_engine(_Sseq& __q) : __e_(__q) {}
+  _LIBCPP_HIDE_FROM_ABI void seed() { __e_.seed(); }
+  _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd) { __e_.seed(__sd); }
+  template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, independent_bits_engine>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) {
+    __e_.seed(__q);
+  }
 
-    // generating functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  // generating functions
+  _LIBCPP_HIDE_FROM_ABI result_type operator()() { return __eval(integral_constant<bool, _Rp != 0>()); }
+  _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    const _Engine& base() const _NOEXCEPT {return __e_;}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI const _Engine& base() const _NOEXCEPT { return __e_; }
 
-    template<class _Eng, size_t _Wp, class _UInt>
-    friend
-    bool
-    operator==(
-        const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
-        const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
+  template <class _Eng, size_t _Wp, class _UInt>
+  friend bool operator==(const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
+                         const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
 
-    template<class _Eng, size_t _Wp, class _UInt>
-    friend
-    bool
-    operator!=(
-        const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
-        const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
+  template <class _Eng, size_t _Wp, class _UInt>
+  friend bool operator!=(const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
+                         const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Wp, class _UInt>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const independent_bits_engine<_Eng, _Wp, _UInt>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt>
+  friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const independent_bits_engine<_Eng, _Wp, _UInt>& __x);
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Wp, class _UInt>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               independent_bits_engine<_Eng, _Wp, _UInt>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, independent_bits_engine<_Eng, _Wp, _UInt>& __x);
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    result_type __eval(false_type);
-    _LIBCPP_HIDE_FROM_ABI result_type __eval(true_type);
+  _LIBCPP_HIDE_FROM_ABI result_type __eval(false_type);
+  _LIBCPP_HIDE_FROM_ABI result_type __eval(true_type);
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            __count < _Dt,
-            result_type
-        >::type
-        __lshift(result_type __x) {return __x << __count;}
+  template <size_t __count,
+            __enable_if_t<__count< _Dt, int> = 0> _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type __x) {
+    return __x << __count;
+  }
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            (__count >= _Dt),
-            result_type
-        >::type
-        __lshift(result_type) {return result_type(0);}
+  template <size_t __count, __enable_if_t<(__count >= _Dt), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type) {
+    return result_type(0);
+  }
 };
 
-template<class _Engine, size_t __w, class _UIntType>
-inline
-_UIntType
-independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type)
-{
-    return static_cast<result_type>(__e_() & __mask0);
+template <class _Engine, size_t __w, class _UIntType>
+inline _UIntType independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type) {
+  return static_cast<result_type>(__e_() & __mask0);
 }
 
-template<class _Engine, size_t __w, class _UIntType>
-_UIntType
-independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type)
-{
-    result_type __sp = 0;
-    for (size_t __k = 0; __k < __n0; ++__k)
-    {
-        _Engine_result_type __u;
-        do
-        {
-            __u = __e_() - _Engine::min();
-        } while (__u >= __y0);
-        __sp = static_cast<result_type>(__lshift<__w0>(__sp) + (__u & __mask0));
-    }
-    for (size_t __k = __n0; __k < __n; ++__k)
-    {
-        _Engine_result_type __u;
-        do
-        {
-            __u = __e_() - _Engine::min();
-        } while (__u >= __y1);
-        __sp = static_cast<result_type>(__lshift<__w0+1>(__sp) + (__u & __mask1));
-    }
-    return __sp;
+template <class _Engine, size_t __w, class _UIntType>
+_UIntType independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type) {
+  result_type __sp = 0;
+  for (size_t __k = 0; __k < __n0; ++__k) {
+    _Engine_result_type __u;
+    do {
+      __u = __e_() - _Engine::min();
+    } while (__u >= __y0);
+    __sp = static_cast<result_type>(__lshift<__w0>(__sp) + (__u & __mask0));
+  }
+  for (size_t __k = __n0; __k < __n; ++__k) {
+    _Engine_result_type __u;
+    do {
+      __u = __e_() - _Engine::min();
+    } while (__u >= __y1);
+    __sp = static_cast<result_type>(__lshift<__w0 + 1>(__sp) + (__u & __mask1));
+  }
+  return __sp;
 }
 
-template<class _Eng, size_t _Wp, class _UInt>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(
-    const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
-    const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
-{
-    return __x.base() == __y.base();
+template <class _Eng, size_t _Wp, class _UInt>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const independent_bits_engine<_Eng, _Wp, _UInt>& __x, const independent_bits_engine<_Eng, _Wp, _UInt>& __y) {
+  return __x.base() == __y.base();
 }
 
-template<class _Eng, size_t _Wp, class _UInt>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(
-    const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
-    const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
-{
-    return !(__x == __y);
+template <class _Eng, size_t _Wp, class _UInt>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const independent_bits_engine<_Eng, _Wp, _UInt>& __x, const independent_bits_engine<_Eng, _Wp, _UInt>& __y) {
+  return !(__x == __y);
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Wp, class _UInt>
+template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const independent_bits_engine<_Eng, _Wp, _UInt>& __x)
-{
-    return __os << __x.base();
+operator<<(basic_ostream<_CharT, _Traits>& __os, const independent_bits_engine<_Eng, _Wp, _UInt>& __x) {
+  return __os << __x.base();
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Wp, class _UInt>
+template <class _CharT, class _Traits, class _Eng, size_t _Wp, class _UInt>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           independent_bits_engine<_Eng, _Wp, _UInt>& __x)
-{
-    _Eng __e;
-    __is >> __e;
-    if (!__is.fail())
-        __x.__e_ = __e;
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, independent_bits_engine<_Eng, _Wp, _UInt>& __x) {
+  _Eng __e;
+  __is >> __e;
+  if (!__is.fail())
+    __x.__e_ = __e;
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/is_seed_sequence.h b/third_party/libcxx/__random/is_seed_sequence.h
index 06621c3ce..c7171cff2 100644
--- a/third_party/libcxx/__random/is_seed_sequence.h
+++ b/third_party/libcxx/__random/is_seed_sequence.h
@@ -21,11 +21,9 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Sseq, class _Engine>
-struct __is_seed_sequence
-{
-    static _LIBCPP_CONSTEXPR const bool value =
-              !is_convertible<_Sseq, typename _Engine::result_type>::value &&
-              !is_same<__remove_cv_t<_Sseq>, _Engine>::value;
+struct __is_seed_sequence {
+  static _LIBCPP_CONSTEXPR const bool value =
+      !is_convertible<_Sseq, typename _Engine::result_type>::value && !is_same<__remove_cv_t<_Sseq>, _Engine>::value;
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/is_valid.h b/third_party/libcxx/__random/is_valid.h
index 113452bc5..a3e0f143a 100644
--- a/third_party/libcxx/__random/is_valid.h
+++ b/third_party/libcxx/__random/is_valid.h
@@ -23,28 +23,55 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+// [rand.req.genl]/1.4:
+// The effect of instantiating a template that has a template type parameter
+// named RealType is undefined unless the corresponding template argument is
+// cv-unqualified and is one of float, double, or long double.
+
+template <class>
+struct __libcpp_random_is_valid_realtype : false_type {};
+template <>
+struct __libcpp_random_is_valid_realtype<float> : true_type {};
+template <>
+struct __libcpp_random_is_valid_realtype<double> : true_type {};
+template <>
+struct __libcpp_random_is_valid_realtype<long double> : true_type {};
+
 // [rand.req.genl]/1.5:
 // The effect of instantiating a template that has a template type parameter
 // named IntType is undefined unless the corresponding template argument is
 // cv-unqualified and is one of short, int, long, long long, unsigned short,
 // unsigned int, unsigned long, or unsigned long long.
 
-template<class> struct __libcpp_random_is_valid_inttype : false_type {};
-template<> struct __libcpp_random_is_valid_inttype<int8_t> : true_type {}; // extension
-template<> struct __libcpp_random_is_valid_inttype<short> : true_type {};
-template<> struct __libcpp_random_is_valid_inttype<int> : true_type {};
-template<> struct __libcpp_random_is_valid_inttype<long> : true_type {};
-template<> struct __libcpp_random_is_valid_inttype<long long> : true_type {};
-template<> struct __libcpp_random_is_valid_inttype<uint8_t> : true_type {}; // extension
-template<> struct __libcpp_random_is_valid_inttype<unsigned short> : true_type {};
-template<> struct __libcpp_random_is_valid_inttype<unsigned int> : true_type {};
-template<> struct __libcpp_random_is_valid_inttype<unsigned long> : true_type {};
-template<> struct __libcpp_random_is_valid_inttype<unsigned long long> : true_type {};
+template <class>
+struct __libcpp_random_is_valid_inttype : false_type {};
+template <>
+struct __libcpp_random_is_valid_inttype<int8_t> : true_type {}; // extension
+template <>
+struct __libcpp_random_is_valid_inttype<short> : true_type {};
+template <>
+struct __libcpp_random_is_valid_inttype<int> : true_type {};
+template <>
+struct __libcpp_random_is_valid_inttype<long> : true_type {};
+template <>
+struct __libcpp_random_is_valid_inttype<long long> : true_type {};
+template <>
+struct __libcpp_random_is_valid_inttype<uint8_t> : true_type {}; // extension
+template <>
+struct __libcpp_random_is_valid_inttype<unsigned short> : true_type {};
+template <>
+struct __libcpp_random_is_valid_inttype<unsigned int> : true_type {};
+template <>
+struct __libcpp_random_is_valid_inttype<unsigned long> : true_type {};
+template <>
+struct __libcpp_random_is_valid_inttype<unsigned long long> : true_type {};
 
 #ifndef _LIBCPP_HAS_NO_INT128
-template<> struct __libcpp_random_is_valid_inttype<__int128_t> : true_type {}; // extension
-template<> struct __libcpp_random_is_valid_inttype<__uint128_t> : true_type {}; // extension
-#endif // _LIBCPP_HAS_NO_INT128
+template <>
+struct __libcpp_random_is_valid_inttype<__int128_t> : true_type {}; // extension
+template <>
+struct __libcpp_random_is_valid_inttype<__uint128_t> : true_type {}; // extension
+#endif                                                               // _LIBCPP_HAS_NO_INT128
 
 // [rand.req.urng]/3:
 // A class G meets the uniform random bit generator requirements if G models
@@ -54,11 +81,13 @@ template<> struct __libcpp_random_is_valid_inttype<__uint128_t> : true_type {};
 // (In particular, reject URNGs with signed result_types; our distributions cannot
 // handle such generator types.)
 
-template<class, class = void> struct __libcpp_random_is_valid_urng : false_type {};
-template<class _Gp> struct __libcpp_random_is_valid_urng<_Gp, __enable_if_t<
-    is_unsigned<typename _Gp::result_type>::value &&
-    _IsSame<decltype(std::declval<_Gp&>()()), typename _Gp::result_type>::value
-> > : true_type {};
+template <class, class = void>
+struct __libcpp_random_is_valid_urng : false_type {};
+template <class _Gp>
+struct __libcpp_random_is_valid_urng<
+    _Gp,
+    __enable_if_t< is_unsigned<typename _Gp::result_type>::value &&
+                   _IsSame<decltype(std::declval<_Gp&>()()), typename _Gp::result_type>::value > > : true_type {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__random/linear_congruential_engine.h b/third_party/libcxx/__random/linear_congruential_engine.h
index 2c2276ecc..9d77649e9 100644
--- a/third_party/libcxx/__random/linear_congruential_engine.h
+++ b/third_party/libcxx/__random/linear_congruential_engine.h
@@ -26,372 +26,359 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <unsigned long long __a, unsigned long long __c,
-          unsigned long long __m, unsigned long long _Mp,
-          bool _MightOverflow = (__a != 0 && __m != 0 && __m-1 > (_Mp-__c)/__a),
-          bool _OverflowOK = ((__m | (__m-1)) > __m), // m = 2^n
-          bool _SchrageOK = (__a != 0 && __m != 0 && __m % __a <= __m / __a)> // r <= q
-struct __lce_alg_picker
-{
-    static_assert(__a != 0 || __m != 0 || !_MightOverflow || _OverflowOK || _SchrageOK,
-                  "The current values of a, c, and m cannot generate a number "
-                  "within bounds of linear_congruential_engine.");
-
-    static _LIBCPP_CONSTEXPR const bool __use_schrage = _MightOverflow &&
-                                                        !_OverflowOK &&
-                                                        _SchrageOK;
+enum __lce_alg_type {
+  _LCE_Full,
+  _LCE_Part,
+  _LCE_Schrage,
+  _LCE_Promote,
 };
 
-template <unsigned long long __a, unsigned long long __c,
-          unsigned long long __m, unsigned long long _Mp,
-          bool _UseSchrage = __lce_alg_picker<__a, __c, __m, _Mp>::__use_schrage>
+template <unsigned long long __a,
+          unsigned long long __c,
+          unsigned long long __m,
+          unsigned long long _Mp,
+          bool _HasOverflow = (__a != 0ull && (__m & (__m - 1ull)) != 0ull),      // a != 0, m != 0, m != 2^n
+          bool _Full        = (!_HasOverflow || __m - 1ull <= (_Mp - __c) / __a), // (a * x + c) % m works
+          bool _Part        = (!_HasOverflow || __m - 1ull <= _Mp / __a),         // (a * x) % m works
+          bool _Schrage     = (_HasOverflow && __m % __a <= __m / __a)>               // r <= q
+struct __lce_alg_picker {
+  static _LIBCPP_CONSTEXPR const __lce_alg_type __mode =
+      _Full      ? _LCE_Full
+      : _Part    ? _LCE_Part
+      : _Schrage ? _LCE_Schrage
+                 : _LCE_Promote;
+
+#ifdef _LIBCPP_HAS_NO_INT128
+  static_assert(_Mp != (unsigned long long)(-1) || _Full || _Part || _Schrage,
+                "The current values for a, c, and m are not currently supported on platforms without __int128");
+#endif
+};
+
+template <unsigned long long __a,
+          unsigned long long __c,
+          unsigned long long __m,
+          unsigned long long _Mp,
+          __lce_alg_type _Mode = __lce_alg_picker<__a, __c, __m, _Mp>::__mode>
 struct __lce_ta;
 
 // 64
 
+#ifndef _LIBCPP_HAS_NO_INT128
+template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
+struct __lce_ta<_Ap, _Cp, _Mp, (unsigned long long)(-1), _LCE_Promote> {
+  typedef unsigned long long result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __xp) {
+    __extension__ using __calc_type = unsigned __int128;
+    const __calc_type __a           = static_cast<__calc_type>(_Ap);
+    const __calc_type __c           = static_cast<__calc_type>(_Cp);
+    const __calc_type __m           = static_cast<__calc_type>(_Mp);
+    const __calc_type __x           = static_cast<__calc_type>(__xp);
+    return static_cast<result_type>((__a * __x + __c) % __m);
+  }
+};
+#endif
+
 template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
-struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), true>
-{
-    typedef unsigned long long result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        // Schrage's algorithm
-        const result_type __q = __m / __a;
-        const result_type __r = __m % __a;
-        const result_type __t0 = __a * (__x % __q);
-        const result_type __t1 = __r * (__x / __q);
-        __x = __t0 + (__t0 < __t1) * __m - __t1;
-        __x += __c - (__x >= __m - __c) * __m;
-        return __x;
-    }
+struct __lce_ta<__a, __c, __m, (unsigned long long)(-1), _LCE_Schrage> {
+  typedef unsigned long long result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) {
+    // Schrage's algorithm
+    const result_type __q  = __m / __a;
+    const result_type __r  = __m % __a;
+    const result_type __t0 = __a * (__x % __q);
+    const result_type __t1 = __r * (__x / __q);
+    __x                    = __t0 + (__t0 < __t1) * __m - __t1;
+    __x += __c - (__x >= __m - __c) * __m;
+    return __x;
+  }
 };
 
 template <unsigned long long __a, unsigned long long __m>
-struct __lce_ta<__a, 0, __m, (unsigned long long)(~0), true>
-{
-    typedef unsigned long long result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        // Schrage's algorithm
-        const result_type __q = __m / __a;
-        const result_type __r = __m % __a;
-        const result_type __t0 = __a * (__x % __q);
-        const result_type __t1 = __r * (__x / __q);
-        __x = __t0 + (__t0 < __t1) * __m - __t1;
-        return __x;
-    }
+struct __lce_ta<__a, 0ull, __m, (unsigned long long)(-1), _LCE_Schrage> {
+  typedef unsigned long long result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) {
+    // Schrage's algorithm
+    const result_type __q  = __m / __a;
+    const result_type __r  = __m % __a;
+    const result_type __t0 = __a * (__x % __q);
+    const result_type __t1 = __r * (__x / __q);
+    __x                    = __t0 + (__t0 < __t1) * __m - __t1;
+    return __x;
+  }
 };
 
 template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
-struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), false>
-{
-    typedef unsigned long long result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        return (__a * __x + __c) % __m;
-    }
+struct __lce_ta<__a, __c, __m, (unsigned long long)(-1), _LCE_Part> {
+  typedef unsigned long long result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) {
+    // Use (((a*x) % m) + c) % m
+    __x = (__a * __x) % __m;
+    __x += __c - (__x >= __m - __c) * __m;
+    return __x;
+  }
+};
+
+template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
+struct __lce_ta<__a, __c, __m, (unsigned long long)(-1), _LCE_Full> {
+  typedef unsigned long long result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { return (__a * __x + __c) % __m; }
 };
 
 template <unsigned long long __a, unsigned long long __c>
-struct __lce_ta<__a, __c, 0, (unsigned long long)(~0), false>
-{
-    typedef unsigned long long result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        return __a * __x + __c;
-    }
+struct __lce_ta<__a, __c, 0ull, (unsigned long long)(-1), _LCE_Full> {
+  typedef unsigned long long result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) { return __a * __x + __c; }
 };
 
 // 32
 
+template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
+struct __lce_ta<__a, __c, __m, unsigned(-1), _LCE_Promote> {
+  typedef unsigned result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) {
+    return static_cast<result_type>(__lce_ta<__a, __c, __m, (unsigned long long)(-1)>::next(__x));
+  }
+};
+
 template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
-struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), true>
-{
-    typedef unsigned result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        const result_type __a = static_cast<result_type>(_Ap);
-        const result_type __c = static_cast<result_type>(_Cp);
-        const result_type __m = static_cast<result_type>(_Mp);
-        // Schrage's algorithm
-        const result_type __q = __m / __a;
-        const result_type __r = __m % __a;
-        const result_type __t0 = __a * (__x % __q);
-        const result_type __t1 = __r * (__x / __q);
-        __x = __t0 + (__t0 < __t1) * __m - __t1;
-        __x += __c - (__x >= __m - __c) * __m;
-        return __x;
-    }
+struct __lce_ta<_Ap, _Cp, _Mp, unsigned(-1), _LCE_Schrage> {
+  typedef unsigned result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) {
+    const result_type __a = static_cast<result_type>(_Ap);
+    const result_type __c = static_cast<result_type>(_Cp);
+    const result_type __m = static_cast<result_type>(_Mp);
+    // Schrage's algorithm
+    const result_type __q  = __m / __a;
+    const result_type __r  = __m % __a;
+    const result_type __t0 = __a * (__x % __q);
+    const result_type __t1 = __r * (__x / __q);
+    __x                    = __t0 + (__t0 < __t1) * __m - __t1;
+    __x += __c - (__x >= __m - __c) * __m;
+    return __x;
+  }
 };
 
 template <unsigned long long _Ap, unsigned long long _Mp>
-struct __lce_ta<_Ap, 0, _Mp, unsigned(~0), true>
-{
-    typedef unsigned result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        const result_type __a = static_cast<result_type>(_Ap);
-        const result_type __m = static_cast<result_type>(_Mp);
-        // Schrage's algorithm
-        const result_type __q = __m / __a;
-        const result_type __r = __m % __a;
-        const result_type __t0 = __a * (__x % __q);
-        const result_type __t1 = __r * (__x / __q);
-        __x = __t0 + (__t0 < __t1) * __m - __t1;
-        return __x;
-    }
+struct __lce_ta<_Ap, 0ull, _Mp, unsigned(-1), _LCE_Schrage> {
+  typedef unsigned result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) {
+    const result_type __a = static_cast<result_type>(_Ap);
+    const result_type __m = static_cast<result_type>(_Mp);
+    // Schrage's algorithm
+    const result_type __q  = __m / __a;
+    const result_type __r  = __m % __a;
+    const result_type __t0 = __a * (__x % __q);
+    const result_type __t1 = __r * (__x / __q);
+    __x                    = __t0 + (__t0 < __t1) * __m - __t1;
+    return __x;
+  }
 };
 
 template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
-struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), false>
-{
-    typedef unsigned result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        const result_type __a = static_cast<result_type>(_Ap);
-        const result_type __c = static_cast<result_type>(_Cp);
-        const result_type __m = static_cast<result_type>(_Mp);
-        return (__a * __x + __c) % __m;
-    }
+struct __lce_ta<_Ap, _Cp, _Mp, unsigned(-1), _LCE_Part> {
+  typedef unsigned result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) {
+    const result_type __a = static_cast<result_type>(_Ap);
+    const result_type __c = static_cast<result_type>(_Cp);
+    const result_type __m = static_cast<result_type>(_Mp);
+    // Use (((a*x) % m) + c) % m
+    __x = (__a * __x) % __m;
+    __x += __c - (__x >= __m - __c) * __m;
+    return __x;
+  }
+};
+
+template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
+struct __lce_ta<_Ap, _Cp, _Mp, unsigned(-1), _LCE_Full> {
+  typedef unsigned result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) {
+    const result_type __a = static_cast<result_type>(_Ap);
+    const result_type __c = static_cast<result_type>(_Cp);
+    const result_type __m = static_cast<result_type>(_Mp);
+    return (__a * __x + __c) % __m;
+  }
 };
 
 template <unsigned long long _Ap, unsigned long long _Cp>
-struct __lce_ta<_Ap, _Cp, 0, unsigned(~0), false>
-{
-    typedef unsigned result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        const result_type __a = static_cast<result_type>(_Ap);
-        const result_type __c = static_cast<result_type>(_Cp);
-        return __a * __x + __c;
-    }
+struct __lce_ta<_Ap, _Cp, 0ull, unsigned(-1), _LCE_Full> {
+  typedef unsigned result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) {
+    const result_type __a = static_cast<result_type>(_Ap);
+    const result_type __c = static_cast<result_type>(_Cp);
+    return __a * __x + __c;
+  }
 };
 
 // 16
 
-template <unsigned long long __a, unsigned long long __c, unsigned long long __m, bool __b>
-struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b>
-{
-    typedef unsigned short result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type next(result_type __x)
-    {
-        return static_cast<result_type>(__lce_ta<__a, __c, __m, unsigned(~0)>::next(__x));
-    }
+template <unsigned long long __a, unsigned long long __c, unsigned long long __m, __lce_alg_type __mode>
+struct __lce_ta<__a, __c, __m, (unsigned short)(-1), __mode> {
+  typedef unsigned short result_type;
+  _LIBCPP_HIDE_FROM_ABI static result_type next(result_type __x) {
+    return static_cast<result_type>(__lce_ta<__a, __c, __m, unsigned(-1)>::next(__x));
+  }
 };
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
 class _LIBCPP_TEMPLATE_VIS linear_congruential_engine;
 
-template <class _CharT, class _Traits,
-          class _Up, _Up _Ap, _Up _Cp, _Up _Np>
-_LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
+template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
 
-template <class _CharT, class _Traits,
-          class _Up, _Up _Ap, _Up _Cp, _Up _Np>
+template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
+operator>>(basic_istream<_CharT, _Traits>& __is, linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-class _LIBCPP_TEMPLATE_VIS linear_congruential_engine
-{
+class _LIBCPP_TEMPLATE_VIS linear_congruential_engine {
 public:
-    // types
-    typedef _UIntType result_type;
+  // types
+  typedef _UIntType result_type;
 
 private:
-    result_type __x_;
+  result_type __x_;
 
-    static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0);
+  static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(-1);
+
+  static_assert(__m == 0 || __a < __m, "linear_congruential_engine invalid parameters");
+  static_assert(__m == 0 || __c < __m, "linear_congruential_engine invalid parameters");
+  static_assert(is_unsigned<_UIntType>::value, "_UIntType must be unsigned type");
 
-    static_assert(__m == 0 || __a < __m, "linear_congruential_engine invalid parameters");
-    static_assert(__m == 0 || __c < __m, "linear_congruential_engine invalid parameters");
-    static_assert(is_unsigned<_UIntType>::value, "_UIntType must be unsigned type");
 public:
-    static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u : 0u;
-    static _LIBCPP_CONSTEXPR const result_type _Max = __m - _UIntType(1u);
-    static_assert(_Min < _Max,           "linear_congruential_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u : 0u;
+  static _LIBCPP_CONSTEXPR const result_type _Max = __m - _UIntType(1u);
+  static_assert(_Min < _Max, "linear_congruential_engine invalid parameters");
 
-    // engine characteristics
-    static _LIBCPP_CONSTEXPR const result_type multiplier = __a;
-    static _LIBCPP_CONSTEXPR const result_type increment = __c;
-    static _LIBCPP_CONSTEXPR const result_type modulus = __m;
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
-    static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
+  // engine characteristics
+  static _LIBCPP_CONSTEXPR const result_type multiplier = __a;
+  static _LIBCPP_CONSTEXPR const result_type increment  = __c;
+  static _LIBCPP_CONSTEXPR const result_type modulus    = __m;
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
+  static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
 
-    // constructors and seeding functions
+  // constructors and seeding functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    linear_congruential_engine() : linear_congruential_engine(default_seed) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit linear_congruential_engine(result_type __s) { seed(__s); }
+  _LIBCPP_HIDE_FROM_ABI linear_congruential_engine() : linear_congruential_engine(default_seed) {}
+  _LIBCPP_HIDE_FROM_ABI explicit linear_congruential_engine(result_type __s) { seed(__s); }
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit linear_congruential_engine(result_type __s = default_seed) {
-      seed(__s);
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit linear_congruential_engine(result_type __s = default_seed) { seed(__s); }
 #endif
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit linear_congruential_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
-        {seed(__q);}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(result_type __s = default_seed)
-        {seed(integral_constant<bool, __m == 0>(),
-              integral_constant<bool, __c == 0>(), __s);}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, linear_congruential_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q)
-            {__seed(__q, integral_constant<unsigned,
-                1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1)/32
-                             :  (__m > 0x100000000ull))>());}
+  template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, linear_congruential_engine>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit linear_congruential_engine(_Sseq& __q) {
+    seed(__q);
+  }
+  _LIBCPP_HIDE_FROM_ABI void seed(result_type __s = default_seed) {
+    seed(integral_constant<bool, __m == 0>(), integral_constant<bool, __c == 0>(), __s);
+  }
+  template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, linear_congruential_engine>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) {
+    __seed(
+        __q,
+        integral_constant<unsigned,
+                          1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1) / 32 : (__m > 0x100000000ull))>());
+  }
 
-    // generating functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type operator()()
-        {return __x_ = static_cast<result_type>(__lce_ta<__a, __c, __m, _Mp>::next(__x_));}
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  // generating functions
+  _LIBCPP_HIDE_FROM_ABI result_type operator()() {
+    return __x_ = static_cast<result_type>(__lce_ta<__a, __c, __m, _Mp>::next(__x_));
+  }
+  _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const linear_congruential_engine& __x,
-                    const linear_congruential_engine& __y)
-        {return __x.__x_ == __y.__x_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const linear_congruential_engine& __x,
-                    const linear_congruential_engine& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const linear_congruential_engine& __x, const linear_congruential_engine& __y) {
+    return __x.__x_ == __y.__x_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const linear_congruential_engine& __x, const linear_congruential_engine& __y) {
+    return !(__x == __y);
+  }
 
 private:
+  _LIBCPP_HIDE_FROM_ABI void seed(true_type, true_type, result_type __s) { __x_ = __s == 0 ? 1 : __s; }
+  _LIBCPP_HIDE_FROM_ABI void seed(true_type, false_type, result_type __s) { __x_ = __s; }
+  _LIBCPP_HIDE_FROM_ABI void seed(false_type, true_type, result_type __s) { __x_ = __s % __m == 0 ? 1 : __s % __m; }
+  _LIBCPP_HIDE_FROM_ABI void seed(false_type, false_type, result_type __s) { __x_ = __s % __m; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(true_type, false_type, result_type __s) {__x_ = __s;}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ?
-                                                                 1 : __s % __m;}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;}
+  template <class _Sseq>
+  _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
+  template <class _Sseq>
+  _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
 
-    template<class _Sseq>
-    _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
-    template<class _Sseq>
-    _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
+  template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np>
+  friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
 
-    template <class _CharT, class _Traits,
-              class _Up, _Up _Ap, _Up _Cp, _Up _Np>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
-
-    template <class _CharT, class _Traits,
-              class _Up, _Up _Ap, _Up _Cp, _Up _Np>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
+  template <class _CharT, class _Traits, class _Up, _Up _Ap, _Up _Cp, _Up _Np>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
 };
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
     linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
     linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
     linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-    _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
+_LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
     linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-template<class _Sseq>
-void
-linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
-                                                 integral_constant<unsigned, 1>)
-{
-    const unsigned __k = 1;
-    uint32_t __ar[__k+3];
-    __q.generate(__ar, __ar + __k + 3);
-    result_type __s = static_cast<result_type>(__ar[3] % __m);
-    __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
+template <class _Sseq>
+void linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q, integral_constant<unsigned, 1>) {
+  const unsigned __k = 1;
+  uint32_t __ar[__k + 3];
+  __q.generate(__ar, __ar + __k + 3);
+  result_type __s = static_cast<result_type>(__ar[3] % __m);
+  __x_            = __c == 0 && __s == 0 ? result_type(1) : __s;
 }
 
 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-template<class _Sseq>
-void
-linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
-                                                 integral_constant<unsigned, 2>)
-{
-    const unsigned __k = 2;
-    uint32_t __ar[__k+3];
-    __q.generate(__ar, __ar + __k + 3);
-    result_type __s = static_cast<result_type>((__ar[3] +
-                                              ((uint64_t)__ar[4] << 32)) % __m);
-    __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
+template <class _Sseq>
+void linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q, integral_constant<unsigned, 2>) {
+  const unsigned __k = 2;
+  uint32_t __ar[__k + 3];
+  __q.generate(__ar, __ar + __k + 3);
+  result_type __s = static_cast<result_type>((__ar[3] + ((uint64_t)__ar[4] << 32)) % __m);
+  __x_            = __c == 0 && __s == 0 ? result_type(1) : __s;
 }
 
-template <class _CharT, class _Traits,
-          class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    __os.fill(__os.widen(' '));
-    return __os << __x.__x_;
+template <class _CharT, class _Traits, class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const linear_congruential_engine<_UIntType, __a, __c, __m>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _Ostream;
+  __os.flags(_Ostream::dec | _Ostream::left);
+  __os.fill(__os.widen(' '));
+  return __os << __x.__x_;
 }
 
-template <class _CharT, class _Traits,
-          class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
+template <class _CharT, class _Traits, class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    _UIntType __t;
-    __is >> __t;
-    if (!__is.fail())
-        __x.__x_ = __t;
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, linear_congruential_engine<_UIntType, __a, __c, __m>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  _UIntType __t;
+  __is >> __t;
+  if (!__is.fail())
+    __x.__x_ = __t;
+  return __is;
 }
 
-typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
-                                                                   minstd_rand0;
-typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
-                                                                    minstd_rand;
+typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647> minstd_rand0;
+typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647> minstd_rand;
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__random/log2.h b/third_party/libcxx/__random/log2.h
index 4ccd1ddc9..74b4889c6 100644
--- a/third_party/libcxx/__random/log2.h
+++ b/third_party/libcxx/__random/log2.h
@@ -23,47 +23,42 @@ template <class _UIntType, _UIntType _Xp, size_t _Rp>
 struct __log2_imp;
 
 template <unsigned long long _Xp, size_t _Rp>
-struct __log2_imp<unsigned long long, _Xp, _Rp>
-{
-    static const size_t value = _Xp & ((unsigned long long)(1) << _Rp) ? _Rp
-                                           : __log2_imp<unsigned long long, _Xp, _Rp - 1>::value;
+struct __log2_imp<unsigned long long, _Xp, _Rp> {
+  static const size_t value =
+      _Xp & ((unsigned long long)(1) << _Rp) ? _Rp : __log2_imp<unsigned long long, _Xp, _Rp - 1>::value;
 };
 
 template <unsigned long long _Xp>
-struct __log2_imp<unsigned long long, _Xp, 0>
-{
-    static const size_t value = 0;
+struct __log2_imp<unsigned long long, _Xp, 0> {
+  static const size_t value = 0;
 };
 
 template <size_t _Rp>
-struct __log2_imp<unsigned long long, 0, _Rp>
-{
-    static const size_t value = _Rp + 1;
+struct __log2_imp<unsigned long long, 0, _Rp> {
+  static const size_t value = _Rp + 1;
 };
 
 #ifndef _LIBCPP_HAS_NO_INT128
 
 template <__uint128_t _Xp, size_t _Rp>
-struct __log2_imp<__uint128_t, _Xp, _Rp>
-{
-    static const size_t value = (_Xp >> 64)
-        ? (64 + __log2_imp<unsigned long long, (_Xp >> 64), 63>::value)
-        : __log2_imp<unsigned long long, _Xp, 63>::value;
+struct __log2_imp<__uint128_t, _Xp, _Rp> {
+  static const size_t value =
+      (_Xp >> 64) ? (64 + __log2_imp<unsigned long long, (_Xp >> 64), 63>::value)
+                  : __log2_imp<unsigned long long, _Xp, 63>::value;
 };
 
 #endif // _LIBCPP_HAS_NO_INT128
 
 template <class _UIntType, _UIntType _Xp>
-struct __log2
-{
-    static const size_t value = __log2_imp<
+struct __log2 {
+  static const size_t value = __log2_imp<
 #ifndef _LIBCPP_HAS_NO_INT128
-        __conditional_t<sizeof(_UIntType) <= sizeof(unsigned long long), unsigned long long, __uint128_t>,
+      __conditional_t<sizeof(_UIntType) <= sizeof(unsigned long long), unsigned long long, __uint128_t>,
 #else
-        unsigned long long,
+      unsigned long long,
 #endif // _LIBCPP_HAS_NO_INT128
-        _Xp,
-        sizeof(_UIntType) * __CHAR_BIT__ - 1>::value;
+      _Xp,
+      sizeof(_UIntType) * __CHAR_BIT__ - 1>::value;
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/lognormal_distribution.h b/third_party/libcxx/__random/lognormal_distribution.h
index 1e8ac39db..d8724f8bc 100644
--- a/third_party/libcxx/__random/lognormal_distribution.h
+++ b/third_party/libcxx/__random/lognormal_distribution.h
@@ -10,6 +10,7 @@
 #define _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
 
 #include <__config>
+#include <__random/is_valid.h>
 #include <__random/normal_distribution.h>
 #include <cmath>
 #include <iosfwd>
@@ -24,134 +25,98 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS lognormal_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS lognormal_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __m_;
-        result_type __s_;
-    public:
-        typedef lognormal_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __m_;
+    result_type __s_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __m = 0, result_type __s = 1)
-            : __m_(__m), __s_(__s) {}
+  public:
+    typedef lognormal_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type m() const {return __m_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type s() const {return __s_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __m = 0, result_type __s = 1) : __m_(__m), __s_(__s) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__m_ == __y.__m_ && __x.__s_ == __y.__s_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type m() const { return __m_; }
+    _LIBCPP_HIDE_FROM_ABI result_type s() const { return __s_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__m_ == __y.__m_ && __x.__s_ == __y.__s_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    normal_distribution<result_type> __nd_;
+  normal_distribution<result_type> __nd_;
 
 public:
-    // constructor and reset functions
+  // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    lognormal_distribution() : lognormal_distribution(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit lognormal_distribution(result_type __m, result_type __s = 1)
-        : __nd_(__m, __s) {}
+  _LIBCPP_HIDE_FROM_ABI lognormal_distribution() : lognormal_distribution(0) {}
+  _LIBCPP_HIDE_FROM_ABI explicit lognormal_distribution(result_type __m, result_type __s = 1) : __nd_(__m, __s) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit lognormal_distribution(result_type __m = 0,
-                                    result_type __s = 1)
-        : __nd_(__m, __s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit lognormal_distribution(result_type __m = 0, result_type __s = 1) : __nd_(__m, __s) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit lognormal_distribution(const param_type& __p)
-        : __nd_(__p.m(), __p.s()) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {__nd_.reset();}
+  _LIBCPP_HIDE_FROM_ABI explicit lognormal_distribution(const param_type& __p) : __nd_(__p.m(), __p.s()) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() { __nd_.reset(); }
 
-    // generating functions
-    template<class _URNG>
-    _LIBCPP_INLINE_VISIBILITY
-    result_type operator()(_URNG& __g)
-    {
-        return _VSTD::exp(__nd_(__g));
-    }
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return std::exp(__nd_(__g));
+  }
 
-    template<class _URNG>
-    _LIBCPP_INLINE_VISIBILITY
-    result_type operator()(_URNG& __g, const param_type& __p)
-    {
-        typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s());
-        return _VSTD::exp(__nd_(__g, __pn));
-    }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p) {
+    typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s());
+    return std::exp(__nd_(__g, __pn));
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type m() const {return __nd_.mean();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type s() const {return __nd_.stddev();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type m() const { return __nd_.mean(); }
+  _LIBCPP_HIDE_FROM_ABI result_type s() const { return __nd_.stddev(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return param_type(__nd_.mean(), __nd_.stddev());}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p)
-    {
-        typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s());
-        __nd_.param(__pn);
-    }
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return param_type(__nd_.mean(), __nd_.stddev()); }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) {
+    typename normal_distribution<result_type>::param_type __pn(__p.m(), __p.s());
+    __nd_.param(__pn);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const lognormal_distribution& __x,
-                        const lognormal_distribution& __y)
-        {return __x.__nd_ == __y.__nd_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const lognormal_distribution& __x,
-                        const lognormal_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const lognormal_distribution& __x, const lognormal_distribution& __y) {
+    return __x.__nd_ == __y.__nd_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const lognormal_distribution& __x, const lognormal_distribution& __y) {
+    return !(__x == __y);
+  }
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const lognormal_distribution<_RT>& __x);
+  template <class _CharT, class _Traits, class _RT>
+  friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const lognormal_distribution<_RT>& __x);
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               lognormal_distribution<_RT>& __x);
+  template <class _CharT, class _Traits, class _RT>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, lognormal_distribution<_RT>& __x);
 };
 
 template <class _CharT, class _Traits, class _RT>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const lognormal_distribution<_RT>& __x)
-{
-    return __os << __x.__nd_;
+inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, const lognormal_distribution<_RT>& __x) {
+  return __os << __x.__nd_;
 }
 
 template <class _CharT, class _Traits, class _RT>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           lognormal_distribution<_RT>& __x)
-{
-    return __is >> __x.__nd_;
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is, lognormal_distribution<_RT>& __x) {
+  return __is >> __x.__nd_;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/mersenne_twister_engine.h b/third_party/libcxx/__random/mersenne_twister_engine.h
index 663a6c704..65280d7c5 100644
--- a/third_party/libcxx/__random/mersenne_twister_engine.h
+++ b/third_party/libcxx/__random/mersenne_twister_engine.h
@@ -27,504 +27,885 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
 class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine;
 
-template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+template <class _UInt,
+          size_t _Wp,
+          size_t _Np,
+          size_t _Mp,
+          size_t _Rp,
+          _UInt _Ap,
+          size_t _Up,
+          _UInt _Dp,
+          size_t _Sp,
+          _UInt _Bp,
+          size_t _Tp,
+          _UInt _Cp,
+          size_t _Lp,
+          _UInt _Fp>
 _LIBCPP_HIDE_FROM_ABI bool
-operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
 
-template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+template <class _UInt,
+          size_t _Wp,
+          size_t _Np,
+          size_t _Mp,
+          size_t _Rp,
+          _UInt _Ap,
+          size_t _Up,
+          _UInt _Dp,
+          size_t _Sp,
+          _UInt _Bp,
+          size_t _Tp,
+          _UInt _Cp,
+          size_t _Lp,
+          _UInt _Fp>
+_LIBCPP_HIDE_FROM_ABI bool
+operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+template <class _CharT,
+          class _Traits,
+          class _UInt,
+          size_t _Wp,
+          size_t _Np,
+          size_t _Mp,
+          size_t _Rp,
+          _UInt _Ap,
+          size_t _Up,
+          _UInt _Dp,
+          size_t _Sp,
+          _UInt _Bp,
+          size_t _Tp,
+          _UInt _Cp,
+          size_t _Lp,
+          _UInt _Fp>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+template <class _CharT,
+          class _Traits,
+          class _UInt,
+          size_t _Wp,
+          size_t _Np,
+          size_t _Mp,
+          size_t _Rp,
+          _UInt _Ap,
+          size_t _Up,
+          _UInt _Dp,
+          size_t _Sp,
+          _UInt _Bp,
+          size_t _Tp,
+          _UInt _Cp,
+          size_t _Lp,
+          _UInt _Fp>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                   _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+           mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine
-{
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine {
 public:
-    // types
-    typedef _UIntType result_type;
+  // types
+  typedef _UIntType result_type;
 
 private:
-    result_type __x_[__n];
-    size_t      __i_;
+  result_type __x_[__n];
+  size_t __i_;
+
+  static_assert(0 < __m, "mersenne_twister_engine invalid parameters");
+  static_assert(__m <= __n, "mersenne_twister_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
+  static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters");
+  static_assert(2 <= __w, "mersenne_twister_engine invalid parameters");
+  static_assert(__r <= __w, "mersenne_twister_engine invalid parameters");
+  static_assert(__u <= __w, "mersenne_twister_engine invalid parameters");
+  static_assert(__s <= __w, "mersenne_twister_engine invalid parameters");
+  static_assert(__t <= __w, "mersenne_twister_engine invalid parameters");
+  static_assert(__l <= __w, "mersenne_twister_engine invalid parameters");
 
-    static_assert(  0 <  __m, "mersenne_twister_engine invalid parameters");
-    static_assert(__m <= __n, "mersenne_twister_engine invalid parameters");
-    static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
-    static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters");
-    static_assert(  2 <= __w, "mersenne_twister_engine invalid parameters");
-    static_assert(__r <= __w, "mersenne_twister_engine invalid parameters");
-    static_assert(__u <= __w, "mersenne_twister_engine invalid parameters");
-    static_assert(__s <= __w, "mersenne_twister_engine invalid parameters");
-    static_assert(__t <= __w, "mersenne_twister_engine invalid parameters");
-    static_assert(__l <= __w, "mersenne_twister_engine invalid parameters");
 public:
-    static _LIBCPP_CONSTEXPR const result_type _Min = 0;
-    static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
-                                                      (result_type(1) << __w) - result_type(1);
-    static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters");
-    static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters");
-    static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters");
-    static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters");
-    static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters");
-    static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Min = 0;
+  static _LIBCPP_CONSTEXPR const result_type _Max =
+      __w == _Dt ? result_type(~0) : (result_type(1) << __w) - result_type(1);
+  static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters");
+  static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters");
+  static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters");
+  static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters");
+  static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters");
+  static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters");
 
-    // engine characteristics
-    static _LIBCPP_CONSTEXPR const size_t word_size = __w;
-    static _LIBCPP_CONSTEXPR const size_t state_size = __n;
-    static _LIBCPP_CONSTEXPR const size_t shift_size = __m;
-    static _LIBCPP_CONSTEXPR const size_t mask_bits = __r;
-    static _LIBCPP_CONSTEXPR const result_type xor_mask = __a;
-    static _LIBCPP_CONSTEXPR const size_t tempering_u = __u;
-    static _LIBCPP_CONSTEXPR const result_type tempering_d = __d;
-    static _LIBCPP_CONSTEXPR const size_t tempering_s = __s;
-    static _LIBCPP_CONSTEXPR const result_type tempering_b = __b;
-    static _LIBCPP_CONSTEXPR const size_t tempering_t = __t;
-    static _LIBCPP_CONSTEXPR const result_type tempering_c = __c;
-    static _LIBCPP_CONSTEXPR const size_t tempering_l = __l;
-    static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
-    static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
+  // engine characteristics
+  static _LIBCPP_CONSTEXPR const size_t word_size                      = __w;
+  static _LIBCPP_CONSTEXPR const size_t state_size                     = __n;
+  static _LIBCPP_CONSTEXPR const size_t shift_size                     = __m;
+  static _LIBCPP_CONSTEXPR const size_t mask_bits                      = __r;
+  static _LIBCPP_CONSTEXPR const result_type xor_mask                  = __a;
+  static _LIBCPP_CONSTEXPR const size_t tempering_u                    = __u;
+  static _LIBCPP_CONSTEXPR const result_type tempering_d               = __d;
+  static _LIBCPP_CONSTEXPR const size_t tempering_s                    = __s;
+  static _LIBCPP_CONSTEXPR const result_type tempering_b               = __b;
+  static _LIBCPP_CONSTEXPR const size_t tempering_t                    = __t;
+  static _LIBCPP_CONSTEXPR const result_type tempering_c               = __c;
+  static _LIBCPP_CONSTEXPR const size_t tempering_l                    = __l;
+  static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
+  static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
 
-    // constructors and seeding functions
+  // constructors and seeding functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit mersenne_twister_engine(result_type __sd) { seed(__sd); }
+  _LIBCPP_HIDE_FROM_ABI mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
+  _LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(result_type __sd) { seed(__sd); }
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit mersenne_twister_engine(result_type __sd = default_seed) {
-      seed(__sd);
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(result_type __sd = default_seed) { seed(__sd); }
 #endif
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit mersenne_twister_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
-        {seed(__q);}
-    _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd = default_seed);
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, mersenne_twister_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q)
-            {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
+  template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(_Sseq& __q) {
+    seed(__q);
+  }
+  _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd = default_seed);
+  template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) {
+    __seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());
+  }
 
-    // generating functions
-    _LIBCPP_HIDE_FROM_ABI result_type operator()();
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  // generating functions
+  _LIBCPP_HIDE_FROM_ABI result_type operator()();
+  _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-              _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-              _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-    friend
-    bool
-    operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                             _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-               const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                             _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+  template <class _UInt,
+            size_t _Wp,
+            size_t _Np,
+            size_t _Mp,
+            size_t _Rp,
+            _UInt _Ap,
+            size_t _Up,
+            _UInt _Dp,
+            size_t _Sp,
+            _UInt _Bp,
+            size_t _Tp,
+            _UInt _Cp,
+            size_t _Lp,
+            _UInt _Fp>
+  friend bool operator==(
+      const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+      const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
 
-    template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-              _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-              _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-    friend
-    bool
-    operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                             _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-               const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                             _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
+  template <class _UInt,
+            size_t _Wp,
+            size_t _Np,
+            size_t _Mp,
+            size_t _Rp,
+            _UInt _Ap,
+            size_t _Up,
+            _UInt _Dp,
+            size_t _Sp,
+            _UInt _Bp,
+            size_t _Tp,
+            _UInt _Cp,
+            size_t _Lp,
+            _UInt _Fp>
+  friend bool operator!=(
+      const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+      const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
 
-    template <class _CharT, class _Traits,
-              class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-              _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-              _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                             _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+  template <class _CharT,
+            class _Traits,
+            class _UInt,
+            size_t _Wp,
+            size_t _Np,
+            size_t _Mp,
+            size_t _Rp,
+            _UInt _Ap,
+            size_t _Up,
+            _UInt _Dp,
+            size_t _Sp,
+            _UInt _Bp,
+            size_t _Tp,
+            _UInt _Cp,
+            size_t _Lp,
+            _UInt _Fp>
+  friend basic_ostream<_CharT, _Traits>& operator<<(
+      basic_ostream<_CharT, _Traits>& __os,
+      const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
+
+  template <class _CharT,
+            class _Traits,
+            class _UInt,
+            size_t _Wp,
+            size_t _Np,
+            size_t _Mp,
+            size_t _Rp,
+            _UInt _Ap,
+            size_t _Up,
+            _UInt _Dp,
+            size_t _Sp,
+            _UInt _Bp,
+            size_t _Tp,
+            _UInt _Cp,
+            size_t _Lp,
+            _UInt _Fp>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is,
+             mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 
-    template <class _CharT, class _Traits,
-              class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-              _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-              _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                       _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 private:
+  template <class _Sseq>
+  _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
+  template <class _Sseq>
+  _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
 
-    template<class _Sseq>
-    _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
-    template<class _Sseq>
-    _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
+  template <size_t __count,
+            __enable_if_t<__count< __w, int> = 0> _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type __x) {
+    return (__x << __count) & _Max;
+  }
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            __count < __w,
-            result_type
-        >::type
-        __lshift(result_type __x) {return (__x << __count) & _Max;}
+  template <size_t __count, __enable_if_t<(__count >= __w), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type) {
+    return result_type(0);
+  }
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            (__count >= __w),
-            result_type
-        >::type
-        __lshift(result_type) {return result_type(0);}
+  template <size_t __count,
+            __enable_if_t<__count< _Dt, int> = 0> _LIBCPP_HIDE_FROM_ABI static result_type __rshift(result_type __x) {
+    return __x >> __count;
+  }
 
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            __count < _Dt,
-            result_type
-        >::type
-        __rshift(result_type __x) {return __x >> __count;}
-
-    template <size_t __count>
-        _LIBCPP_INLINE_VISIBILITY
-        static
-        typename enable_if
-        <
-            (__count >= _Dt),
-            result_type
-        >::type
-        __rshift(result_type) {return result_type(0);}
+  template <size_t __count, __enable_if_t<(__count >= _Dt), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static result_type __rshift(result_type) {
+    return result_type(0);
+  }
 };
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType,
+    __w,
+    __n,
+    __m,
+    __r,
+    __a,
+    __u,
+    __d,
+    __s,
+    __b,
+    __t,
+    __c,
+    __l,
+    __f>::result_type
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType,
+    __w,
+    __n,
+    __m,
+    __r,
+    __a,
+    __u,
+    __d,
+    __s,
+    __b,
+    __t,
+    __c,
+    __l,
+    __f>::result_type
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType,
+    __w,
+    __n,
+    __m,
+    __r,
+    __a,
+    __u,
+    __d,
+    __s,
+    __b,
+    __t,
+    __c,
+    __l,
+    __f>::result_type
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType,
+    __w,
+    __n,
+    __m,
+    __r,
+    __a,
+    __u,
+    __d,
+    __s,
+    __b,
+    __t,
+    __c,
+    __l,
+    __f>::result_type
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const size_t
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const size_t
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
-    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::initialization_multiplier;
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType,
+    __w,
+    __n,
+    __m,
+    __r,
+    __a,
+    __u,
+    __d,
+    __s,
+    __b,
+    __t,
+    __c,
+    __l,
+    __f>::result_type
+    mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::
+        initialization_multiplier;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-    _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+_LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
+    _UIntType,
+    __w,
+    __n,
+    __m,
+    __r,
+    __a,
+    __u,
+    __d,
+    __s,
+    __b,
+    __t,
+    __c,
+    __l,
+    __f>::result_type
     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed;
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-void
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
-    __t, __c, __l, __f>::seed(result_type __sd)
-    _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-{   // __w >= 2
-    __x_[0] = __sd & _Max;
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::seed(
+    result_type __sd) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { // __w >= 2
+  __x_[0] = __sd & _Max;
+  for (size_t __i = 1; __i < __n; ++__i)
+    __x_[__i] = (__f * (__x_[__i - 1] ^ __rshift<__w - 2>(__x_[__i - 1])) + __i) & _Max;
+  __i_ = 0;
+}
+
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+template <class _Sseq>
+void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::__seed(
+    _Sseq& __q, integral_constant<unsigned, 1>) {
+  const unsigned __k = 1;
+  uint32_t __ar[__n * __k];
+  __q.generate(__ar, __ar + __n * __k);
+  for (size_t __i = 0; __i < __n; ++__i)
+    __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
+  const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
+  __i_                     = 0;
+  if ((__x_[0] & ~__mask) == 0) {
     for (size_t __i = 1; __i < __n; ++__i)
-        __x_[__i] = (__f * (__x_[__i-1] ^ __rshift<__w - 2>(__x_[__i-1])) + __i) & _Max;
-    __i_ = 0;
+      if (__x_[__i] != 0)
+        return;
+    __x_[0] = result_type(1) << (__w - 1);
+  }
 }
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-template<class _Sseq>
-void
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
-    __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 1>)
-{
-    const unsigned __k = 1;
-    uint32_t __ar[__n * __k];
-    __q.generate(__ar, __ar + __n * __k);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
-    const result_type __mask = __r == _Dt ? result_type(~0) :
-                                       (result_type(1) << __r) - result_type(1);
-    __i_ = 0;
-    if ((__x_[0] & ~__mask) == 0)
-    {
-        for (size_t __i = 1; __i < __n; ++__i)
-            if (__x_[__i] != 0)
-                return;
-        __x_[0] = result_type(1) << (__w - 1);
-    }
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
+template <class _Sseq>
+void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::__seed(
+    _Sseq& __q, integral_constant<unsigned, 2>) {
+  const unsigned __k = 2;
+  uint32_t __ar[__n * __k];
+  __q.generate(__ar, __ar + __n * __k);
+  for (size_t __i = 0; __i < __n; ++__i)
+    __x_[__i] = static_cast<result_type>((__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
+  const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
+  __i_                     = 0;
+  if ((__x_[0] & ~__mask) == 0) {
+    for (size_t __i = 1; __i < __n; ++__i)
+      if (__x_[__i] != 0)
+        return;
+    __x_[0] = result_type(1) << (__w - 1);
+  }
 }
 
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
-template<class _Sseq>
-void
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
-    __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 2>)
-{
-    const unsigned __k = 2;
-    uint32_t __ar[__n * __k];
-    __q.generate(__ar, __ar + __n * __k);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __x_[__i] = static_cast<result_type>(
-            (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
-    const result_type __mask = __r == _Dt ? result_type(~0) :
-                                       (result_type(1) << __r) - result_type(1);
-    __i_ = 0;
-    if ((__x_[0] & ~__mask) == 0)
-    {
-        for (size_t __i = 1; __i < __n; ++__i)
-            if (__x_[__i] != 0)
-                return;
-        __x_[0] = result_type(1) << (__w - 1);
-    }
-}
-
-template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
-          _UIntType __a, size_t __u, _UIntType __d, size_t __s,
-          _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
+template <class _UIntType,
+          size_t __w,
+          size_t __n,
+          size_t __m,
+          size_t __r,
+          _UIntType __a,
+          size_t __u,
+          _UIntType __d,
+          size_t __s,
+          _UIntType __b,
+          size_t __t,
+          _UIntType __c,
+          size_t __l,
+          _UIntType __f>
 _UIntType
-mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
-    __t, __c, __l, __f>::operator()()
-{
-    const size_t __j = (__i_ + 1) % __n;
-    const result_type __mask = __r == _Dt ? result_type(~0) :
-                                       (result_type(1) << __r) - result_type(1);
-    const result_type __yp = (__x_[__i_] & ~__mask) | (__x_[__j] & __mask);
-    const size_t __k = (__i_ + __m) % __n;
-    __x_[__i_] = __x_[__k] ^ __rshift<1>(__yp) ^ (__a * (__yp & 1));
-    result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
-    __i_ = __j;
-    __z ^= __lshift<__s>(__z) & __b;
-    __z ^= __lshift<__t>(__z) & __c;
-    return __z ^ __rshift<__l>(__z);
+mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::operator()() {
+  const size_t __j         = (__i_ + 1) % __n;
+  const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
+  const result_type __yp   = (__x_[__i_] & ~__mask) | (__x_[__j] & __mask);
+  const size_t __k         = (__i_ + __m) % __n;
+  __x_[__i_]               = __x_[__k] ^ __rshift<1>(__yp) ^ (__a * (__yp & 1));
+  result_type __z          = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
+  __i_                     = __j;
+  __z ^= __lshift<__s>(__z) & __b;
+  __z ^= __lshift<__t>(__z) & __c;
+  return __z ^ __rshift<__l>(__z);
 }
 
-template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+template <class _UInt,
+          size_t _Wp,
+          size_t _Np,
+          size_t _Mp,
+          size_t _Rp,
+          _UInt _Ap,
+          size_t _Up,
+          _UInt _Dp,
+          size_t _Sp,
+          _UInt _Bp,
+          size_t _Tp,
+          _UInt _Cp,
+          size_t _Lp,
+          _UInt _Fp>
 _LIBCPP_HIDE_FROM_ABI bool
-operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
-{
-    if (__x.__i_ == __y.__i_)
-        return _VSTD::equal(__x.__x_, __x.__x_ + _Np, __y.__x_);
-    if (__x.__i_ == 0 || __y.__i_ == 0)
-    {
-        size_t __j = _VSTD::min(_Np - __x.__i_, _Np - __y.__i_);
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
-                         __y.__x_ + __y.__i_))
-            return false;
-        if (__x.__i_ == 0)
-            return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_);
-        return _VSTD::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j);
-    }
-    if (__x.__i_ < __y.__i_)
-    {
-        size_t __j = _Np - __y.__i_;
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
-                         __y.__x_ + __y.__i_))
-            return false;
-        if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np,
-                         __y.__x_))
-            return false;
-        return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
-                           __y.__x_ + (_Np - (__x.__i_ + __j)));
-    }
-    size_t __j = _Np - __x.__i_;
-    if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
-                     __x.__x_ + __x.__i_))
-        return false;
-    if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np,
-                     __x.__x_))
-        return false;
-    return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
-                       __x.__x_ + (_Np - (__y.__i_ + __j)));
+operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y) {
+  if (__x.__i_ == __y.__i_)
+    return std::equal(__x.__x_, __x.__x_ + _Np, __y.__x_);
+  if (__x.__i_ == 0 || __y.__i_ == 0) {
+    size_t __j = std::min(_Np - __x.__i_, _Np - __y.__i_);
+    if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, __y.__x_ + __y.__i_))
+      return false;
+    if (__x.__i_ == 0)
+      return std::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_);
+    return std::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j);
+  }
+  if (__x.__i_ < __y.__i_) {
+    size_t __j = _Np - __y.__i_;
+    if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), __y.__x_ + __y.__i_))
+      return false;
+    if (!std::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np, __y.__x_))
+      return false;
+    return std::equal(__x.__x_, __x.__x_ + __x.__i_, __y.__x_ + (_Np - (__x.__i_ + __j)));
+  }
+  size_t __j = _Np - __x.__i_;
+  if (!std::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), __x.__x_ + __x.__i_))
+    return false;
+  if (!std::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np, __x.__x_))
+    return false;
+  return std::equal(__y.__x_, __y.__x_ + __y.__i_, __x.__x_ + (_Np - (__y.__i_ + __j)));
 }
 
-template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
-{
-    return !(__x == __y);
+template <class _UInt,
+          size_t _Wp,
+          size_t _Np,
+          size_t _Mp,
+          size_t _Rp,
+          _UInt _Ap,
+          size_t _Up,
+          _UInt _Dp,
+          size_t _Sp,
+          _UInt _Bp,
+          size_t _Tp,
+          _UInt _Cp,
+          size_t _Lp,
+          _UInt _Fp>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
+           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y) {
+  return !(__x == __y);
 }
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+template <class _CharT,
+          class _Traits,
+          class _UInt,
+          size_t _Wp,
+          size_t _Np,
+          size_t _Mp,
+          size_t _Rp,
+          _UInt _Ap,
+          size_t _Up,
+          _UInt _Dp,
+          size_t _Sp,
+          _UInt _Bp,
+          size_t _Tp,
+          _UInt _Cp,
+          size_t _Lp,
+          _UInt _Fp>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                         _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.__x_[__x.__i_];
-    for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j)
-        __os << __sp << __x.__x_[__j];
-    for (size_t __j = 0; __j < __x.__i_; ++__j)
-        __os << __sp << __x.__x_[__j];
-    return __os;
+           const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _Ostream;
+  __os.flags(_Ostream::dec | _Ostream::left);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  __os << __x.__x_[__x.__i_];
+  for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j)
+    __os << __sp << __x.__x_[__j];
+  for (size_t __j = 0; __j < __x.__i_; ++__j)
+    __os << __sp << __x.__x_[__j];
+  return __os;
 }
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
-          _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
-          _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
+template <class _CharT,
+          class _Traits,
+          class _UInt,
+          size_t _Wp,
+          size_t _Np,
+          size_t _Mp,
+          size_t _Rp,
+          _UInt _Ap,
+          size_t _Up,
+          _UInt _Dp,
+          size_t _Sp,
+          _UInt _Bp,
+          size_t _Tp,
+          _UInt _Cp,
+          size_t _Lp,
+          _UInt _Fp>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is,
-           mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
-                                   _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    _UInt __t[_Np];
+           mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  _UInt __t[_Np];
+  for (size_t __i = 0; __i < _Np; ++__i)
+    __is >> __t[__i];
+  if (!__is.fail()) {
     for (size_t __i = 0; __i < _Np; ++__i)
-        __is >> __t[__i];
-    if (!__is.fail())
-    {
-        for (size_t __i = 0; __i < _Np; ++__i)
-            __x.__x_[__i] = __t[__i];
-        __x.__i_ = 0;
-    }
-    return __is;
+      __x.__x_[__i] = __t[__i];
+    __x.__i_ = 0;
+  }
+  return __is;
 }
 
-typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
-                                0x9908b0df, 11, 0xffffffff,
-                                7,  0x9d2c5680,
-                                15, 0xefc60000,
-                                18, 1812433253>                         mt19937;
-typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
-                                0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL,
-                                17, 0x71d67fffeda60000ULL,
-                                37, 0xfff7eee000000000ULL,
-                                43, 6364136223846793005ULL>          mt19937_64;
+typedef mersenne_twister_engine<
+    uint_fast32_t,
+    32,
+    624,
+    397,
+    31,
+    0x9908b0df,
+    11,
+    0xffffffff,
+    7,
+    0x9d2c5680,
+    15,
+    0xefc60000,
+    18,
+    1812433253>
+    mt19937;
+typedef mersenne_twister_engine<
+    uint_fast64_t,
+    64,
+    312,
+    156,
+    31,
+    0xb5026f5aa96619e9ULL,
+    29,
+    0x5555555555555555ULL,
+    17,
+    0x71d67fffeda60000ULL,
+    37,
+    0xfff7eee000000000ULL,
+    43,
+    6364136223846793005ULL>
+    mt19937_64;
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__random/negative_binomial_distribution.h b/third_party/libcxx/__random/negative_binomial_distribution.h
index 450ff0979..6d0055d01 100644
--- a/third_party/libcxx/__random/negative_binomial_distribution.h
+++ b/third_party/libcxx/__random/negative_binomial_distribution.h
@@ -9,6 +9,7 @@
 #ifndef _LIBCPP___RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_H
 
+#include <__assert>
 #include <__config>
 #include <__random/bernoulli_distribution.h>
 #include <__random/gamma_distribution.h>
@@ -26,155 +27,127 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution
-{
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
+template <class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution {
+  static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
+
 public:
-    // types
-    typedef _IntType result_type;
+  // types
+  typedef _IntType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __k_;
-        double __p_;
-    public:
-        typedef negative_binomial_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __k_;
+    double __p_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __k = 1, double __p = 0.5)
-            : __k_(__k), __p_(__p) {}
+  public:
+    typedef negative_binomial_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type k() const {return __k_;}
-        _LIBCPP_INLINE_VISIBILITY
-        double p() const {return __p_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __k = 1, double __p = 0.5) : __k_(__k), __p_(__p) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type k() const { return __k_; }
+    _LIBCPP_HIDE_FROM_ABI double p() const { return __p_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructor and reset functions
+  // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    negative_binomial_distribution() : negative_binomial_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit negative_binomial_distribution(result_type __k, double __p = 0.5)
-        : __p_(__k, __p) {}
+  _LIBCPP_HIDE_FROM_ABI negative_binomial_distribution() : negative_binomial_distribution(1) {}
+  _LIBCPP_HIDE_FROM_ABI explicit negative_binomial_distribution(result_type __k, double __p = 0.5) : __p_(__k, __p) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit negative_binomial_distribution(result_type __k = 1,
-                                            double __p = 0.5)
-        : __p_(__k, __p) {}
+  _LIBCPP_HIDE_FROM_ABI explicit negative_binomial_distribution(result_type __k = 1, double __p = 0.5)
+      : __p_(__k, __p) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type k() const {return __p_.k();}
-    _LIBCPP_INLINE_VISIBILITY
-    double p() const {return __p_.p();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type k() const { return __p_.k(); }
+  _LIBCPP_HIDE_FROM_ABI double p() const { return __p_.p(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::max();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::max(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const negative_binomial_distribution& __x,
-                        const negative_binomial_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const negative_binomial_distribution& __x,
-                        const negative_binomial_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const negative_binomial_distribution& __x, const negative_binomial_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const negative_binomial_distribution& __x, const negative_binomial_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _IntType>
-template<class _URNG>
-_IntType
-negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    result_type __k = __pr.k();
-    double __p = __pr.p();
-    // When the number of bits in _IntType is small, we are too likely to
-    // overflow __f below to use this technique.
-    if (__k <= 21 * __p && sizeof(_IntType) > 1)
-    {
-        bernoulli_distribution __gen(__p);
-        result_type __f = 0;
-        result_type __s = 0;
-        while (__s < __k)
-        {
-            if (__gen(__urng))
-                ++__s;
-            else
-                ++__f;
-        }
-        _LIBCPP_ASSERT(__f >= 0, "std::negative_binomial_distribution should never produce negative values. "
-                                 "This is almost certainly a signed integer overflow issue on __f.");
-        return __f;
+template <class _URNG>
+_IntType negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  result_type __k = __pr.k();
+  double __p      = __pr.p();
+  // When the number of bits in _IntType is small, we are too likely to
+  // overflow __f below to use this technique.
+  if (__k <= 21 * __p && sizeof(_IntType) > 1) {
+    bernoulli_distribution __gen(__p);
+    result_type __f = 0;
+    result_type __s = 0;
+    while (__s < __k) {
+      if (__gen(__urng))
+        ++__s;
+      else
+        ++__f;
     }
-    return poisson_distribution<result_type>(gamma_distribution<double>
-                                            (__k, (1-__p)/__p)(__urng))(__urng);
+    _LIBCPP_ASSERT_INTERNAL(__f >= 0,
+                            "std::negative_binomial_distribution should never produce negative values. "
+                            "This is almost certainly a signed integer overflow issue on __f.");
+    return __f;
+  }
+  return poisson_distribution<result_type>(gamma_distribution<double>(__k, (1 - __p) / __p)(__urng))(__urng);
 }
 
 template <class _CharT, class _Traits, class _IntType>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const negative_binomial_distribution<_IntType>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.k() << __sp << __x.p();
+operator<<(basic_ostream<_CharT, _Traits>& __os, const negative_binomial_distribution<_IntType>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  return __os << __x.k() << __sp << __x.p();
 }
 
 template <class _CharT, class _Traits, class _IntType>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           negative_binomial_distribution<_IntType>& __x)
-{
-    typedef negative_binomial_distribution<_IntType> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __k;
-    double __p;
-    __is >> __k >> __p;
-    if (!__is.fail())
-        __x.param(param_type(__k, __p));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, negative_binomial_distribution<_IntType>& __x) {
+  typedef negative_binomial_distribution<_IntType> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __k;
+  double __p;
+  __is >> __k >> __p;
+  if (!__is.fail())
+    __x.param(param_type(__k, __p));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/normal_distribution.h b/third_party/libcxx/__random/normal_distribution.h
index e2bf041b7..889f189e4 100644
--- a/third_party/libcxx/__random/normal_distribution.h
+++ b/third_party/libcxx/__random/normal_distribution.h
@@ -25,183 +25,148 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS normal_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS normal_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __mean_;
-        result_type __stddev_;
-    public:
-        typedef normal_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __mean_;
+    result_type __stddev_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __mean = 0, result_type __stddev = 1)
-            : __mean_(__mean), __stddev_(__stddev) {}
+  public:
+    typedef normal_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type mean() const {return __mean_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type stddev() const {return __stddev_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __mean = 0, result_type __stddev = 1)
+        : __mean_(__mean), __stddev_(__stddev) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type mean() const { return __mean_; }
+    _LIBCPP_HIDE_FROM_ABI result_type stddev() const { return __stddev_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
-    result_type __v_;
-    bool __v_hot_;
+  param_type __p_;
+  result_type __v_;
+  bool __v_hot_;
 
 public:
-    // constructors and reset functions
+  // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    normal_distribution() : normal_distribution(0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit normal_distribution(result_type __mean, result_type __stddev = 1)
-        : __p_(param_type(__mean, __stddev)), __v_hot_(false) {}
+  _LIBCPP_HIDE_FROM_ABI normal_distribution() : normal_distribution(0) {}
+  _LIBCPP_HIDE_FROM_ABI explicit normal_distribution(result_type __mean, result_type __stddev = 1)
+      : __p_(param_type(__mean, __stddev)), __v_hot_(false) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit normal_distribution(result_type __mean = 0,
-                                 result_type __stddev = 1)
-        : __p_(param_type(__mean, __stddev)), __v_hot_(false) {}
+  _LIBCPP_HIDE_FROM_ABI explicit normal_distribution(result_type __mean = 0, result_type __stddev = 1)
+      : __p_(param_type(__mean, __stddev)), __v_hot_(false) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit normal_distribution(const param_type& __p)
-        : __p_(__p), __v_hot_(false) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {__v_hot_ = false;}
+  _LIBCPP_HIDE_FROM_ABI explicit normal_distribution(const param_type& __p) : __p_(__p), __v_hot_(false) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() { __v_hot_ = false; }
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type mean() const {return __p_.mean();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type stddev() const {return __p_.stddev();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type mean() const { return __p_.mean(); }
+  _LIBCPP_HIDE_FROM_ABI result_type stddev() const { return __p_.stddev(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return -numeric_limits<result_type>::infinity();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return -numeric_limits<result_type>::infinity(); }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const normal_distribution& __x,
-                        const normal_distribution& __y)
-        {return __x.__p_ == __y.__p_ && __x.__v_hot_ == __y.__v_hot_ &&
-                (!__x.__v_hot_ || __x.__v_ == __y.__v_);}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const normal_distribution& __x,
-                        const normal_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const normal_distribution& __x, const normal_distribution& __y) {
+    return __x.__p_ == __y.__p_ && __x.__v_hot_ == __y.__v_hot_ && (!__x.__v_hot_ || __x.__v_ == __y.__v_);
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const normal_distribution& __x, const normal_distribution& __y) {
+    return !(__x == __y);
+  }
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const normal_distribution<_RT>& __x);
+  template <class _CharT, class _Traits, class _RT>
+  friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const normal_distribution<_RT>& __x);
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               normal_distribution<_RT>& __x);
+  template <class _CharT, class _Traits, class _RT>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, normal_distribution<_RT>& __x);
 };
 
 template <class _RealType>
-template<class _URNG>
-_RealType
-normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    result_type __up;
-    if (__v_hot_)
-    {
-        __v_hot_ = false;
-        __up = __v_;
-    }
-    else
-    {
-        uniform_real_distribution<result_type> __uni(-1, 1);
-        result_type __u;
-        result_type __v;
-        result_type __s;
-        do
-        {
-            __u = __uni(__g);
-            __v = __uni(__g);
-            __s = __u * __u + __v * __v;
-        } while (__s > 1 || __s == 0);
-        result_type __fp = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s);
-        __v_ = __v * __fp;
-        __v_hot_ = true;
-        __up = __u * __fp;
-    }
-    return __up * __p.stddev() + __p.mean();
+template <class _URNG>
+_RealType normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  result_type __up;
+  if (__v_hot_) {
+    __v_hot_ = false;
+    __up     = __v_;
+  } else {
+    uniform_real_distribution<result_type> __uni(-1, 1);
+    result_type __u;
+    result_type __v;
+    result_type __s;
+    do {
+      __u = __uni(__g);
+      __v = __uni(__g);
+      __s = __u * __u + __v * __v;
+    } while (__s > 1 || __s == 0);
+    result_type __fp = std::sqrt(-2 * std::log(__s) / __s);
+    __v_             = __v * __fp;
+    __v_hot_         = true;
+    __up             = __u * __fp;
+  }
+  return __up * __p.stddev() + __p.mean();
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const normal_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.mean() << __sp << __x.stddev() << __sp << __x.__v_hot_;
-    if (__x.__v_hot_)
-        __os << __sp << __x.__v_;
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const normal_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  __os << __x.mean() << __sp << __x.stddev() << __sp << __x.__v_hot_;
+  if (__x.__v_hot_)
+    __os << __sp << __x.__v_;
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           normal_distribution<_RT>& __x)
-{
-    typedef normal_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __mean;
-    result_type __stddev;
-    result_type __vp = 0;
-    bool __v_hot = false;
-    __is >> __mean >> __stddev >> __v_hot;
-    if (__v_hot)
-        __is >> __vp;
-    if (!__is.fail())
-    {
-        __x.param(param_type(__mean, __stddev));
-        __x.__v_hot_ = __v_hot;
-        __x.__v_ = __vp;
-    }
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, normal_distribution<_RT>& __x) {
+  typedef normal_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __mean;
+  result_type __stddev;
+  result_type __vp = 0;
+  bool __v_hot     = false;
+  __is >> __mean >> __stddev >> __v_hot;
+  if (__v_hot)
+    __is >> __vp;
+  if (!__is.fail()) {
+    __x.param(param_type(__mean, __stddev));
+    __x.__v_hot_ = __v_hot;
+    __x.__v_     = __vp;
+  }
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/piecewise_constant_distribution.h b/third_party/libcxx/__random/piecewise_constant_distribution.h
index 5b26ab65e..e19380f97 100644
--- a/third_party/libcxx/__random/piecewise_constant_distribution.h
+++ b/third_party/libcxx/__random/piecewise_constant_distribution.h
@@ -26,330 +26,273 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        vector<result_type> __b_;
-        vector<result_type> __densities_;
-        vector<result_type> __areas_;
-    public:
-        typedef piecewise_constant_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    vector<result_type> __b_;
+    vector<result_type> __densities_;
+    vector<result_type> __areas_;
 
-        _LIBCPP_HIDE_FROM_ABI param_type();
-        template<class _InputIteratorB, class _InputIteratorW>
-        _LIBCPP_HIDE_FROM_ABI param_type(_InputIteratorB __f_b, _InputIteratorB __l_b,
-                       _InputIteratorW __f_w);
+  public:
+    typedef piecewise_constant_distribution distribution_type;
+
+    _LIBCPP_HIDE_FROM_ABI param_type();
+    template <class _InputIteratorB, class _InputIteratorW>
+    _LIBCPP_HIDE_FROM_ABI param_type(_InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w);
 #ifndef _LIBCPP_CXX03_LANG
-        template<class _UnaryOperation>
-        _LIBCPP_HIDE_FROM_ABI param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
+    template <class _UnaryOperation>
+    _LIBCPP_HIDE_FROM_ABI param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
 #endif // _LIBCPP_CXX03_LANG
-        template<class _UnaryOperation>
-        _LIBCPP_HIDE_FROM_ABI param_type(size_t __nw, result_type __xmin, result_type __xmax,
-                       _UnaryOperation __fw);
-        _LIBCPP_HIDE_FROM_ABI param_type(param_type const&) = default;
-        _LIBCPP_HIDE_FROM_ABI param_type & operator=(const param_type& __rhs);
+    template <class _UnaryOperation>
+    _LIBCPP_HIDE_FROM_ABI param_type(size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw);
+    _LIBCPP_HIDE_FROM_ABI param_type(param_type const&) = default;
+    _LIBCPP_HIDE_FROM_ABI param_type& operator=(const param_type& __rhs);
 
-        _LIBCPP_INLINE_VISIBILITY
-        vector<result_type> intervals() const {return __b_;}
-        _LIBCPP_INLINE_VISIBILITY
-        vector<result_type> densities() const {return __densities_;}
+    _LIBCPP_HIDE_FROM_ABI vector<result_type> intervals() const { return __b_; }
+    _LIBCPP_HIDE_FROM_ABI vector<result_type> densities() const { return __densities_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
 
-    private:
-        _LIBCPP_HIDE_FROM_ABI void __init();
+  private:
+    _LIBCPP_HIDE_FROM_ABI void __init();
 
-        friend class piecewise_constant_distribution;
+    friend class piecewise_constant_distribution;
 
-        template <class _CharT, class _Traits, class _RT>
-        friend
-        basic_ostream<_CharT, _Traits>&
-        operator<<(basic_ostream<_CharT, _Traits>& __os,
-                   const piecewise_constant_distribution<_RT>& __x);
+    template <class _CharT, class _Traits, class _RT>
+    friend basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const piecewise_constant_distribution<_RT>& __x);
 
-        template <class _CharT, class _Traits, class _RT>
-        friend
-        basic_istream<_CharT, _Traits>&
-        operator>>(basic_istream<_CharT, _Traits>& __is,
-                   piecewise_constant_distribution<_RT>& __x);
-    };
+    template <class _CharT, class _Traits, class _RT>
+    friend basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, piecewise_constant_distribution<_RT>& __x);
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructor and reset functions
-    _LIBCPP_INLINE_VISIBILITY
-    piecewise_constant_distribution() {}
-    template<class _InputIteratorB, class _InputIteratorW>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_constant_distribution(_InputIteratorB __f_b,
-                                        _InputIteratorB __l_b,
-                                        _InputIteratorW __f_w)
-        : __p_(__f_b, __l_b, __f_w) {}
+  // constructor and reset functions
+  _LIBCPP_HIDE_FROM_ABI piecewise_constant_distribution() {}
+  template <class _InputIteratorB, class _InputIteratorW>
+  _LIBCPP_HIDE_FROM_ABI
+  piecewise_constant_distribution(_InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w)
+      : __p_(__f_b, __l_b, __f_w) {}
 
 #ifndef _LIBCPP_CXX03_LANG
-    template<class _UnaryOperation>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_constant_distribution(initializer_list<result_type> __bl,
-                                        _UnaryOperation __fw)
-        : __p_(__bl, __fw) {}
+  template <class _UnaryOperation>
+  _LIBCPP_HIDE_FROM_ABI piecewise_constant_distribution(initializer_list<result_type> __bl, _UnaryOperation __fw)
+      : __p_(__bl, __fw) {}
 #endif // _LIBCPP_CXX03_LANG
 
-    template<class _UnaryOperation>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_constant_distribution(size_t __nw, result_type __xmin,
-                                        result_type __xmax, _UnaryOperation __fw)
-        : __p_(__nw, __xmin, __xmax, __fw) {}
+  template <class _UnaryOperation>
+  _LIBCPP_HIDE_FROM_ABI
+  piecewise_constant_distribution(size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
+      : __p_(__nw, __xmin, __xmax, __fw) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit piecewise_constant_distribution(const param_type& __p)
-        : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI explicit piecewise_constant_distribution(const param_type& __p) : __p_(__p) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    vector<result_type> intervals() const {return __p_.intervals();}
-    _LIBCPP_INLINE_VISIBILITY
-    vector<result_type> densities() const {return __p_.densities();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI vector<result_type> intervals() const { return __p_.intervals(); }
+  _LIBCPP_HIDE_FROM_ABI vector<result_type> densities() const { return __p_.densities(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return __p_.__b_.front();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return __p_.__b_.back();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return __p_.__b_.front(); }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return __p_.__b_.back(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const piecewise_constant_distribution& __x,
-                        const piecewise_constant_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const piecewise_constant_distribution& __x,
-                           const piecewise_constant_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const piecewise_constant_distribution& __x, const piecewise_constant_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const piecewise_constant_distribution& __x, const piecewise_constant_distribution& __y) {
+    return !(__x == __y);
+  }
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const piecewise_constant_distribution<_RT>& __x);
+  template <class _CharT, class _Traits, class _RT>
+  friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const piecewise_constant_distribution<_RT>& __x);
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               piecewise_constant_distribution<_RT>& __x);
+  template <class _CharT, class _Traits, class _RT>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, piecewise_constant_distribution<_RT>& __x);
 };
 
-template<class _RealType>
-typename piecewise_constant_distribution<_RealType>::param_type &
-piecewise_constant_distribution<_RealType>::param_type::operator=
-                                                       (const param_type& __rhs)
-{
-//  These can throw
-    __b_.reserve        (__rhs.__b_.size ());
-    __densities_.reserve(__rhs.__densities_.size());
-    __areas_.reserve    (__rhs.__areas_.size());
+template <class _RealType>
+typename piecewise_constant_distribution<_RealType>::param_type&
+piecewise_constant_distribution<_RealType>::param_type::operator=(const param_type& __rhs) {
+  //  These can throw
+  __b_.reserve(__rhs.__b_.size());
+  __densities_.reserve(__rhs.__densities_.size());
+  __areas_.reserve(__rhs.__areas_.size());
 
-//  These can not throw
-    __b_         = __rhs.__b_;
-    __densities_ = __rhs.__densities_;
-    __areas_     =  __rhs.__areas_;
-    return *this;
+  //  These can not throw
+  __b_         = __rhs.__b_;
+  __densities_ = __rhs.__densities_;
+  __areas_     = __rhs.__areas_;
+  return *this;
 }
 
-template<class _RealType>
-void
-piecewise_constant_distribution<_RealType>::param_type::__init()
-{
-    // __densities_ contains non-normalized areas
-    result_type __total_area = _VSTD::accumulate(__densities_.begin(),
-                                                __densities_.end(),
-                                                result_type());
-    for (size_t __i = 0; __i < __densities_.size(); ++__i)
-        __densities_[__i] /= __total_area;
-    // __densities_ contains normalized areas
-    __areas_.assign(__densities_.size(), result_type());
-    _VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1,
-                                                          __areas_.begin() + 1);
-    // __areas_ contains partial sums of normalized areas: [0, __densities_ - 1]
-    __densities_.back() = 1 - __areas_.back();  // correct round off error
-    for (size_t __i = 0; __i < __densities_.size(); ++__i)
-        __densities_[__i] /= (__b_[__i+1] - __b_[__i]);
-    // __densities_ now contains __densities_
+template <class _RealType>
+void piecewise_constant_distribution<_RealType>::param_type::__init() {
+  // __densities_ contains non-normalized areas
+  result_type __total_area = std::accumulate(__densities_.begin(), __densities_.end(), result_type());
+  for (size_t __i = 0; __i < __densities_.size(); ++__i)
+    __densities_[__i] /= __total_area;
+  // __densities_ contains normalized areas
+  __areas_.assign(__densities_.size(), result_type());
+  std::partial_sum(__densities_.begin(), __densities_.end() - 1, __areas_.begin() + 1);
+  // __areas_ contains partial sums of normalized areas: [0, __densities_ - 1]
+  __densities_.back() = 1 - __areas_.back(); // correct round off error
+  for (size_t __i = 0; __i < __densities_.size(); ++__i)
+    __densities_[__i] /= (__b_[__i + 1] - __b_[__i]);
+  // __densities_ now contains __densities_
 }
 
-template<class _RealType>
-piecewise_constant_distribution<_RealType>::param_type::param_type()
-    : __b_(2),
-      __densities_(1, 1.0),
-      __areas_(1, 0.0)
-{
-    __b_[1] = 1;
+template <class _RealType>
+piecewise_constant_distribution<_RealType>::param_type::param_type() : __b_(2), __densities_(1, 1.0), __areas_(1, 0.0) {
+  __b_[1] = 1;
 }
 
-template<class _RealType>
-template<class _InputIteratorB, class _InputIteratorW>
+template <class _RealType>
+template <class _InputIteratorB, class _InputIteratorW>
 piecewise_constant_distribution<_RealType>::param_type::param_type(
-        _InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w)
-    : __b_(__f_b, __l_b)
-{
-    if (__b_.size() < 2)
-    {
-        __b_.resize(2);
-        __b_[0] = 0;
-        __b_[1] = 1;
-        __densities_.assign(1, 1.0);
-        __areas_.assign(1, 0.0);
-    }
-    else
-    {
-        __densities_.reserve(__b_.size() - 1);
-        for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__f_w)
-            __densities_.push_back(*__f_w);
-        __init();
-    }
+    _InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w)
+    : __b_(__f_b, __l_b) {
+  if (__b_.size() < 2) {
+    __b_.resize(2);
+    __b_[0] = 0;
+    __b_[1] = 1;
+    __densities_.assign(1, 1.0);
+    __areas_.assign(1, 0.0);
+  } else {
+    __densities_.reserve(__b_.size() - 1);
+    for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__f_w)
+      __densities_.push_back(*__f_w);
+    __init();
+  }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template<class _RealType>
-template<class _UnaryOperation>
+template <class _RealType>
+template <class _UnaryOperation>
 piecewise_constant_distribution<_RealType>::param_type::param_type(
-        initializer_list<result_type> __bl, _UnaryOperation __fw)
-    : __b_(__bl.begin(), __bl.end())
-{
-    if (__b_.size() < 2)
-    {
-        __b_.resize(2);
-        __b_[0] = 0;
-        __b_[1] = 1;
-        __densities_.assign(1, 1.0);
-        __areas_.assign(1, 0.0);
-    }
-    else
-    {
-        __densities_.reserve(__b_.size() - 1);
-        for (size_t __i = 0; __i < __b_.size() - 1; ++__i)
-            __densities_.push_back(__fw((__b_[__i+1] + __b_[__i])*.5));
-        __init();
-    }
+    initializer_list<result_type> __bl, _UnaryOperation __fw)
+    : __b_(__bl.begin(), __bl.end()) {
+  if (__b_.size() < 2) {
+    __b_.resize(2);
+    __b_[0] = 0;
+    __b_[1] = 1;
+    __densities_.assign(1, 1.0);
+    __areas_.assign(1, 0.0);
+  } else {
+    __densities_.reserve(__b_.size() - 1);
+    for (size_t __i = 0; __i < __b_.size() - 1; ++__i)
+      __densities_.push_back(__fw((__b_[__i + 1] + __b_[__i]) * .5));
+    __init();
+  }
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
-template<class _RealType>
-template<class _UnaryOperation>
+template <class _RealType>
+template <class _UnaryOperation>
 piecewise_constant_distribution<_RealType>::param_type::param_type(
-        size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
-    : __b_(__nw == 0 ? 2 : __nw + 1)
-{
-    size_t __n = __b_.size() - 1;
-    result_type __d = (__xmax - __xmin) / __n;
-    __densities_.reserve(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-    {
-        __b_[__i] = __xmin + __i * __d;
-        __densities_.push_back(__fw(__b_[__i] + __d*.5));
-    }
-    __b_[__n] = __xmax;
-    __init();
+    size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
+    : __b_(__nw == 0 ? 2 : __nw + 1) {
+  size_t __n      = __b_.size() - 1;
+  result_type __d = (__xmax - __xmin) / __n;
+  __densities_.reserve(__n);
+  for (size_t __i = 0; __i < __n; ++__i) {
+    __b_[__i] = __xmin + __i * __d;
+    __densities_.push_back(__fw(__b_[__i] + __d * .5));
+  }
+  __b_[__n] = __xmax;
+  __init();
 }
 
-template<class _RealType>
-template<class _URNG>
-_RealType
-piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    typedef uniform_real_distribution<result_type> _Gen;
-    result_type __u = _Gen()(__g);
-    ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
-                                      __u) - __p.__areas_.begin() - 1;
-    return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
+template <class _RealType>
+template <class _URNG>
+_RealType piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  typedef uniform_real_distribution<result_type> _Gen;
+  result_type __u = _Gen()(__g);
+  ptrdiff_t __k   = std::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), __u) - __p.__areas_.begin() - 1;
+  return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const piecewise_constant_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    size_t __n = __x.__p_.__b_.size();
-    __os << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__b_[__i];
-    __n = __x.__p_.__densities_.size();
-    __os << __sp << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__densities_[__i];
-    __n = __x.__p_.__areas_.size();
-    __os << __sp << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__areas_[__i];
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const piecewise_constant_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  size_t __n = __x.__p_.__b_.size();
+  __os << __n;
+  for (size_t __i = 0; __i < __n; ++__i)
+    __os << __sp << __x.__p_.__b_[__i];
+  __n = __x.__p_.__densities_.size();
+  __os << __sp << __n;
+  for (size_t __i = 0; __i < __n; ++__i)
+    __os << __sp << __x.__p_.__densities_[__i];
+  __n = __x.__p_.__areas_.size();
+  __os << __sp << __n;
+  for (size_t __i = 0; __i < __n; ++__i)
+    __os << __sp << __x.__p_.__areas_[__i];
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           piecewise_constant_distribution<_RT>& __x)
-{
-    typedef piecewise_constant_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    size_t __n;
-    __is >> __n;
-    vector<result_type> __b(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __b[__i];
-    __is >> __n;
-    vector<result_type> __densities(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __densities[__i];
-    __is >> __n;
-    vector<result_type> __areas(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __areas[__i];
-    if (!__is.fail())
-    {
-        swap(__x.__p_.__b_, __b);
-        swap(__x.__p_.__densities_, __densities);
-        swap(__x.__p_.__areas_, __areas);
-    }
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, piecewise_constant_distribution<_RT>& __x) {
+  typedef piecewise_constant_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  size_t __n;
+  __is >> __n;
+  vector<result_type> __b(__n);
+  for (size_t __i = 0; __i < __n; ++__i)
+    __is >> __b[__i];
+  __is >> __n;
+  vector<result_type> __densities(__n);
+  for (size_t __i = 0; __i < __n; ++__i)
+    __is >> __densities[__i];
+  __is >> __n;
+  vector<result_type> __areas(__n);
+  for (size_t __i = 0; __i < __n; ++__i)
+    __is >> __areas[__i];
+  if (!__is.fail()) {
+    swap(__x.__p_.__b_, __b);
+    swap(__x.__p_.__densities_, __densities);
+    swap(__x.__p_.__areas_, __areas);
+  }
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/piecewise_linear_distribution.h b/third_party/libcxx/__random/piecewise_linear_distribution.h
index 6be44b29f..43769dc82 100644
--- a/third_party/libcxx/__random/piecewise_linear_distribution.h
+++ b/third_party/libcxx/__random/piecewise_linear_distribution.h
@@ -13,8 +13,8 @@
 #include <__config>
 #include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
+#include <cmath>
 #include <iosfwd>
-#include <numeric>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -26,346 +26,286 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        vector<result_type> __b_;
-        vector<result_type> __densities_;
-        vector<result_type> __areas_;
-    public:
-        typedef piecewise_linear_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    vector<result_type> __b_;
+    vector<result_type> __densities_;
+    vector<result_type> __areas_;
 
-        _LIBCPP_HIDE_FROM_ABI param_type();
-        template<class _InputIteratorB, class _InputIteratorW>
-        _LIBCPP_HIDE_FROM_ABI param_type(_InputIteratorB __f_b, _InputIteratorB __l_b,
-                       _InputIteratorW __f_w);
+  public:
+    typedef piecewise_linear_distribution distribution_type;
+
+    _LIBCPP_HIDE_FROM_ABI param_type();
+    template <class _InputIteratorB, class _InputIteratorW>
+    _LIBCPP_HIDE_FROM_ABI param_type(_InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w);
 #ifndef _LIBCPP_CXX03_LANG
-        template<class _UnaryOperation>
-        _LIBCPP_HIDE_FROM_ABI param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
+    template <class _UnaryOperation>
+    _LIBCPP_HIDE_FROM_ABI param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
 #endif // _LIBCPP_CXX03_LANG
-        template<class _UnaryOperation>
-        _LIBCPP_HIDE_FROM_ABI param_type(size_t __nw, result_type __xmin, result_type __xmax,
-                       _UnaryOperation __fw);
-        _LIBCPP_HIDE_FROM_ABI param_type(param_type const&) = default;
-        _LIBCPP_HIDE_FROM_ABI param_type & operator=(const param_type& __rhs);
+    template <class _UnaryOperation>
+    _LIBCPP_HIDE_FROM_ABI param_type(size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw);
+    _LIBCPP_HIDE_FROM_ABI param_type(param_type const&) = default;
+    _LIBCPP_HIDE_FROM_ABI param_type& operator=(const param_type& __rhs);
 
-        _LIBCPP_INLINE_VISIBILITY
-        vector<result_type> intervals() const {return __b_;}
-        _LIBCPP_INLINE_VISIBILITY
-        vector<result_type> densities() const {return __densities_;}
+    _LIBCPP_HIDE_FROM_ABI vector<result_type> intervals() const { return __b_; }
+    _LIBCPP_HIDE_FROM_ABI vector<result_type> densities() const { return __densities_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
 
-    private:
-        _LIBCPP_HIDE_FROM_ABI void __init();
+  private:
+    _LIBCPP_HIDE_FROM_ABI void __init();
 
-        friend class piecewise_linear_distribution;
+    friend class piecewise_linear_distribution;
 
-        template <class _CharT, class _Traits, class _RT>
-        friend
-        basic_ostream<_CharT, _Traits>&
-        operator<<(basic_ostream<_CharT, _Traits>& __os,
-                   const piecewise_linear_distribution<_RT>& __x);
+    template <class _CharT, class _Traits, class _RT>
+    friend basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const piecewise_linear_distribution<_RT>& __x);
 
-        template <class _CharT, class _Traits, class _RT>
-        friend
-        basic_istream<_CharT, _Traits>&
-        operator>>(basic_istream<_CharT, _Traits>& __is,
-                   piecewise_linear_distribution<_RT>& __x);
-    };
+    template <class _CharT, class _Traits, class _RT>
+    friend basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, piecewise_linear_distribution<_RT>& __x);
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructor and reset functions
-    _LIBCPP_INLINE_VISIBILITY
-    piecewise_linear_distribution() {}
-    template<class _InputIteratorB, class _InputIteratorW>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_linear_distribution(_InputIteratorB __f_b,
-                                      _InputIteratorB __l_b,
-                                      _InputIteratorW __f_w)
-        : __p_(__f_b, __l_b, __f_w) {}
+  // constructor and reset functions
+  _LIBCPP_HIDE_FROM_ABI piecewise_linear_distribution() {}
+  template <class _InputIteratorB, class _InputIteratorW>
+  _LIBCPP_HIDE_FROM_ABI
+  piecewise_linear_distribution(_InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w)
+      : __p_(__f_b, __l_b, __f_w) {}
 
 #ifndef _LIBCPP_CXX03_LANG
-    template<class _UnaryOperation>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_linear_distribution(initializer_list<result_type> __bl,
-                                      _UnaryOperation __fw)
-        : __p_(__bl, __fw) {}
+  template <class _UnaryOperation>
+  _LIBCPP_HIDE_FROM_ABI piecewise_linear_distribution(initializer_list<result_type> __bl, _UnaryOperation __fw)
+      : __p_(__bl, __fw) {}
 #endif // _LIBCPP_CXX03_LANG
 
-    template<class _UnaryOperation>
-        _LIBCPP_INLINE_VISIBILITY
-        piecewise_linear_distribution(size_t __nw, result_type __xmin,
-                                      result_type __xmax, _UnaryOperation __fw)
-        : __p_(__nw, __xmin, __xmax, __fw) {}
+  template <class _UnaryOperation>
+  _LIBCPP_HIDE_FROM_ABI
+  piecewise_linear_distribution(size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
+      : __p_(__nw, __xmin, __xmax, __fw) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit piecewise_linear_distribution(const param_type& __p)
-        : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI explicit piecewise_linear_distribution(const param_type& __p) : __p_(__p) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    vector<result_type> intervals() const {return __p_.intervals();}
-    _LIBCPP_INLINE_VISIBILITY
-    vector<result_type> densities() const {return __p_.densities();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI vector<result_type> intervals() const { return __p_.intervals(); }
+  _LIBCPP_HIDE_FROM_ABI vector<result_type> densities() const { return __p_.densities(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return __p_.__b_.front();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return __p_.__b_.back();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return __p_.__b_.front(); }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return __p_.__b_.back(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const piecewise_linear_distribution& __x,
-                        const piecewise_linear_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const piecewise_linear_distribution& __x,
-                        const piecewise_linear_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const piecewise_linear_distribution& __x, const piecewise_linear_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const piecewise_linear_distribution& __x, const piecewise_linear_distribution& __y) {
+    return !(__x == __y);
+  }
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const piecewise_linear_distribution<_RT>& __x);
+  template <class _CharT, class _Traits, class _RT>
+  friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const piecewise_linear_distribution<_RT>& __x);
 
-    template <class _CharT, class _Traits, class _RT>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               piecewise_linear_distribution<_RT>& __x);
+  template <class _CharT, class _Traits, class _RT>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, piecewise_linear_distribution<_RT>& __x);
 };
 
-template<class _RealType>
-typename piecewise_linear_distribution<_RealType>::param_type &
-piecewise_linear_distribution<_RealType>::param_type::operator=
-                                                       (const param_type& __rhs)
-{
-//  These can throw
-    __b_.reserve        (__rhs.__b_.size ());
-    __densities_.reserve(__rhs.__densities_.size());
-    __areas_.reserve    (__rhs.__areas_.size());
+template <class _RealType>
+typename piecewise_linear_distribution<_RealType>::param_type&
+piecewise_linear_distribution<_RealType>::param_type::operator=(const param_type& __rhs) {
+  //  These can throw
+  __b_.reserve(__rhs.__b_.size());
+  __densities_.reserve(__rhs.__densities_.size());
+  __areas_.reserve(__rhs.__areas_.size());
 
-//  These can not throw
-    __b_         = __rhs.__b_;
-    __densities_ = __rhs.__densities_;
-    __areas_     =  __rhs.__areas_;
-    return *this;
+  //  These can not throw
+  __b_         = __rhs.__b_;
+  __densities_ = __rhs.__densities_;
+  __areas_     = __rhs.__areas_;
+  return *this;
 }
 
-
-template<class _RealType>
-void
-piecewise_linear_distribution<_RealType>::param_type::__init()
-{
-    __areas_.assign(__densities_.size() - 1, result_type());
-    result_type __sp = 0;
-    for (size_t __i = 0; __i < __areas_.size(); ++__i)
-    {
-        __areas_[__i] = (__densities_[__i+1] + __densities_[__i]) *
-                        (__b_[__i+1] - __b_[__i]) * .5;
-        __sp += __areas_[__i];
-    }
-    for (size_t __i = __areas_.size(); __i > 1;)
-    {
-        --__i;
-        __areas_[__i] = __areas_[__i-1] / __sp;
-    }
-    __areas_[0] = 0;
-    for (size_t __i = 1; __i < __areas_.size(); ++__i)
-        __areas_[__i] += __areas_[__i-1];
-    for (size_t __i = 0; __i < __densities_.size(); ++__i)
-        __densities_[__i] /= __sp;
+template <class _RealType>
+void piecewise_linear_distribution<_RealType>::param_type::__init() {
+  __areas_.assign(__densities_.size() - 1, result_type());
+  result_type __sp = 0;
+  for (size_t __i = 0; __i < __areas_.size(); ++__i) {
+    __areas_[__i] = (__densities_[__i + 1] + __densities_[__i]) * (__b_[__i + 1] - __b_[__i]) * .5;
+    __sp += __areas_[__i];
+  }
+  for (size_t __i = __areas_.size(); __i > 1;) {
+    --__i;
+    __areas_[__i] = __areas_[__i - 1] / __sp;
+  }
+  __areas_[0] = 0;
+  for (size_t __i = 1; __i < __areas_.size(); ++__i)
+    __areas_[__i] += __areas_[__i - 1];
+  for (size_t __i = 0; __i < __densities_.size(); ++__i)
+    __densities_[__i] /= __sp;
 }
 
-template<class _RealType>
-piecewise_linear_distribution<_RealType>::param_type::param_type()
-    : __b_(2),
-      __densities_(2, 1.0),
-      __areas_(1, 0.0)
-{
-    __b_[1] = 1;
+template <class _RealType>
+piecewise_linear_distribution<_RealType>::param_type::param_type() : __b_(2), __densities_(2, 1.0), __areas_(1, 0.0) {
+  __b_[1] = 1;
 }
 
-template<class _RealType>
-template<class _InputIteratorB, class _InputIteratorW>
+template <class _RealType>
+template <class _InputIteratorB, class _InputIteratorW>
 piecewise_linear_distribution<_RealType>::param_type::param_type(
-        _InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w)
-    : __b_(__f_b, __l_b)
-{
-    if (__b_.size() < 2)
-    {
-        __b_.resize(2);
-        __b_[0] = 0;
-        __b_[1] = 1;
-        __densities_.assign(2, 1.0);
-        __areas_.assign(1, 0.0);
-    }
-    else
-    {
-        __densities_.reserve(__b_.size());
-        for (size_t __i = 0; __i < __b_.size(); ++__i, ++__f_w)
-            __densities_.push_back(*__f_w);
-        __init();
-    }
+    _InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w)
+    : __b_(__f_b, __l_b) {
+  if (__b_.size() < 2) {
+    __b_.resize(2);
+    __b_[0] = 0;
+    __b_[1] = 1;
+    __densities_.assign(2, 1.0);
+    __areas_.assign(1, 0.0);
+  } else {
+    __densities_.reserve(__b_.size());
+    for (size_t __i = 0; __i < __b_.size(); ++__i, ++__f_w)
+      __densities_.push_back(*__f_w);
+    __init();
+  }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template<class _RealType>
-template<class _UnaryOperation>
+template <class _RealType>
+template <class _UnaryOperation>
 piecewise_linear_distribution<_RealType>::param_type::param_type(
-        initializer_list<result_type> __bl, _UnaryOperation __fw)
-    : __b_(__bl.begin(), __bl.end())
-{
-    if (__b_.size() < 2)
-    {
-        __b_.resize(2);
-        __b_[0] = 0;
-        __b_[1] = 1;
-        __densities_.assign(2, 1.0);
-        __areas_.assign(1, 0.0);
-    }
-    else
-    {
-        __densities_.reserve(__b_.size());
-        for (size_t __i = 0; __i < __b_.size(); ++__i)
-            __densities_.push_back(__fw(__b_[__i]));
-        __init();
-    }
+    initializer_list<result_type> __bl, _UnaryOperation __fw)
+    : __b_(__bl.begin(), __bl.end()) {
+  if (__b_.size() < 2) {
+    __b_.resize(2);
+    __b_[0] = 0;
+    __b_[1] = 1;
+    __densities_.assign(2, 1.0);
+    __areas_.assign(1, 0.0);
+  } else {
+    __densities_.reserve(__b_.size());
+    for (size_t __i = 0; __i < __b_.size(); ++__i)
+      __densities_.push_back(__fw(__b_[__i]));
+    __init();
+  }
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
-template<class _RealType>
-template<class _UnaryOperation>
+template <class _RealType>
+template <class _UnaryOperation>
 piecewise_linear_distribution<_RealType>::param_type::param_type(
-        size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
-    : __b_(__nw == 0 ? 2 : __nw + 1)
-{
-    size_t __n = __b_.size() - 1;
-    result_type __d = (__xmax - __xmin) / __n;
-    __densities_.reserve(__b_.size());
-    for (size_t __i = 0; __i < __n; ++__i)
-    {
-        __b_[__i] = __xmin + __i * __d;
-        __densities_.push_back(__fw(__b_[__i]));
-    }
-    __b_[__n] = __xmax;
-    __densities_.push_back(__fw(__b_[__n]));
-    __init();
+    size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
+    : __b_(__nw == 0 ? 2 : __nw + 1) {
+  size_t __n      = __b_.size() - 1;
+  result_type __d = (__xmax - __xmin) / __n;
+  __densities_.reserve(__b_.size());
+  for (size_t __i = 0; __i < __n; ++__i) {
+    __b_[__i] = __xmin + __i * __d;
+    __densities_.push_back(__fw(__b_[__i]));
+  }
+  __b_[__n] = __xmax;
+  __densities_.push_back(__fw(__b_[__n]));
+  __init();
 }
 
-template<class _RealType>
-template<class _URNG>
-_RealType
-piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    typedef uniform_real_distribution<result_type> _Gen;
-    result_type __u = _Gen()(__g);
-    ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
-                                      __u) - __p.__areas_.begin() - 1;
-    __u -= __p.__areas_[__k];
-    const result_type __dk = __p.__densities_[__k];
-    const result_type __dk1 = __p.__densities_[__k+1];
-    const result_type __deltad = __dk1 - __dk;
-    const result_type __bk = __p.__b_[__k];
-    if (__deltad == 0)
-        return __u / __dk + __bk;
-    const result_type __bk1 = __p.__b_[__k+1];
-    const result_type __deltab = __bk1 - __bk;
-    return (__bk * __dk1 - __bk1 * __dk +
-        _VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
-        __deltad;
+template <class _RealType>
+template <class _URNG>
+_RealType piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  typedef uniform_real_distribution<result_type> _Gen;
+  result_type __u = _Gen()(__g);
+  ptrdiff_t __k   = std::upper_bound(__p.__areas_.begin(), __p.__areas_.end(), __u) - __p.__areas_.begin() - 1;
+  __u -= __p.__areas_[__k];
+  const result_type __dk     = __p.__densities_[__k];
+  const result_type __dk1    = __p.__densities_[__k + 1];
+  const result_type __deltad = __dk1 - __dk;
+  const result_type __bk     = __p.__b_[__k];
+  if (__deltad == 0)
+    return __u / __dk + __bk;
+  const result_type __bk1    = __p.__b_[__k + 1];
+  const result_type __deltab = __bk1 - __bk;
+  return (__bk * __dk1 - __bk1 * __dk + std::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) / __deltad;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const piecewise_linear_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    size_t __n = __x.__p_.__b_.size();
-    __os << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__b_[__i];
-    __n = __x.__p_.__densities_.size();
-    __os << __sp << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__densities_[__i];
-    __n = __x.__p_.__areas_.size();
-    __os << __sp << __n;
-    for (size_t __i = 0; __i < __n; ++__i)
-        __os << __sp << __x.__p_.__areas_[__i];
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const piecewise_linear_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  size_t __n = __x.__p_.__b_.size();
+  __os << __n;
+  for (size_t __i = 0; __i < __n; ++__i)
+    __os << __sp << __x.__p_.__b_[__i];
+  __n = __x.__p_.__densities_.size();
+  __os << __sp << __n;
+  for (size_t __i = 0; __i < __n; ++__i)
+    __os << __sp << __x.__p_.__densities_[__i];
+  __n = __x.__p_.__areas_.size();
+  __os << __sp << __n;
+  for (size_t __i = 0; __i < __n; ++__i)
+    __os << __sp << __x.__p_.__areas_[__i];
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           piecewise_linear_distribution<_RT>& __x)
-{
-    typedef piecewise_linear_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    size_t __n;
-    __is >> __n;
-    vector<result_type> __b(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __b[__i];
-    __is >> __n;
-    vector<result_type> __densities(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __densities[__i];
-    __is >> __n;
-    vector<result_type> __areas(__n);
-    for (size_t __i = 0; __i < __n; ++__i)
-        __is >> __areas[__i];
-    if (!__is.fail())
-    {
-        swap(__x.__p_.__b_, __b);
-        swap(__x.__p_.__densities_, __densities);
-        swap(__x.__p_.__areas_, __areas);
-    }
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, piecewise_linear_distribution<_RT>& __x) {
+  typedef piecewise_linear_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  size_t __n;
+  __is >> __n;
+  vector<result_type> __b(__n);
+  for (size_t __i = 0; __i < __n; ++__i)
+    __is >> __b[__i];
+  __is >> __n;
+  vector<result_type> __densities(__n);
+  for (size_t __i = 0; __i < __n; ++__i)
+    __is >> __densities[__i];
+  __is >> __n;
+  vector<result_type> __areas(__n);
+  for (size_t __i = 0; __i < __n; ++__i)
+    __is >> __areas[__i];
+  if (!__is.fail()) {
+    swap(__x.__p_.__b_, __b);
+    swap(__x.__p_.__densities_, __densities);
+    swap(__x.__p_.__areas_, __areas);
+  }
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/poisson_distribution.h b/third_party/libcxx/__random/poisson_distribution.h
index eed120ebb..61a092ef9 100644
--- a/third_party/libcxx/__random/poisson_distribution.h
+++ b/third_party/libcxx/__random/poisson_distribution.h
@@ -28,250 +28,210 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _IntType = int>
-class _LIBCPP_TEMPLATE_VIS poisson_distribution
-{
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
+template <class _IntType = int>
+class _LIBCPP_TEMPLATE_VIS poisson_distribution {
+  static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
+
 public:
-    // types
-    typedef _IntType result_type;
+  // types
+  typedef _IntType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        double __mean_;
-        double __s_;
-        double __d_;
-        double __l_;
-        double __omega_;
-        double __c0_;
-        double __c1_;
-        double __c2_;
-        double __c3_;
-        double __c_;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    double __mean_;
+    double __s_;
+    double __d_;
+    double __l_;
+    double __omega_;
+    double __c0_;
+    double __c1_;
+    double __c2_;
+    double __c3_;
+    double __c_;
 
-    public:
-        typedef poisson_distribution distribution_type;
+  public:
+    typedef poisson_distribution distribution_type;
 
-        _LIBCPP_HIDE_FROM_ABI explicit param_type(double __mean = 1.0);
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(double __mean = 1.0);
 
-        _LIBCPP_INLINE_VISIBILITY
-        double mean() const {return __mean_;}
+    _LIBCPP_HIDE_FROM_ABI double mean() const { return __mean_; }
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__mean_ == __y.__mean_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__mean_ == __y.__mean_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
 
-        friend class poisson_distribution;
-    };
+    friend class poisson_distribution;
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructors and reset functions
+  // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    poisson_distribution() : poisson_distribution(1.0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit poisson_distribution(double __mean)
-        : __p_(__mean) {}
+  _LIBCPP_HIDE_FROM_ABI poisson_distribution() : poisson_distribution(1.0) {}
+  _LIBCPP_HIDE_FROM_ABI explicit poisson_distribution(double __mean) : __p_(__mean) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit poisson_distribution(double __mean = 1.0)
-        : __p_(__mean) {}
+  _LIBCPP_HIDE_FROM_ABI explicit poisson_distribution(double __mean = 1.0) : __p_(__mean) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    double mean() const {return __p_.mean();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI double mean() const { return __p_.mean(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::max();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::max(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const poisson_distribution& __x,
-                        const poisson_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const poisson_distribution& __x,
-                        const poisson_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const poisson_distribution& __x, const poisson_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const poisson_distribution& __x, const poisson_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
-template<class _IntType>
+template <class _IntType>
 poisson_distribution<_IntType>::param_type::param_type(double __mean)
     // According to the standard `inf` is a valid input, but it causes the
     // distribution to hang, so we replace it with the maximum representable
     // mean.
-    : __mean_(isinf(__mean) ? numeric_limits<double>::max() : __mean)
-{
-    if (__mean_ < 10)
-    {
-        __s_ = 0;
-        __d_ = 0;
-        __l_ = _VSTD::exp(-__mean_);
-        __omega_ = 0;
-        __c3_ = 0;
-        __c2_ = 0;
-        __c1_ = 0;
-        __c0_ = 0;
-        __c_ = 0;
-    }
-    else
-    {
-        __s_ = _VSTD::sqrt(__mean_);
-        __d_ = 6 * __mean_ * __mean_;
-        __l_ = _VSTD::trunc(__mean_ - 1.1484);
-        __omega_ = .3989423 / __s_;
-        double __b1 = .4166667E-1 / __mean_;
-        double __b2 = .3 * __b1 * __b1;
-        __c3_ = .1428571 * __b1 * __b2;
-        __c2_ = __b2 - 15. * __c3_;
-        __c1_ = __b1 - 6. * __b2 + 45. * __c3_;
-        __c0_ = 1. - __b1 + 3. * __b2 - 15. * __c3_;
-        __c_ = .1069 / __mean_;
-    }
+    : __mean_(isinf(__mean) ? numeric_limits<double>::max() : __mean) {
+  if (__mean_ < 10) {
+    __s_     = 0;
+    __d_     = 0;
+    __l_     = std::exp(-__mean_);
+    __omega_ = 0;
+    __c3_    = 0;
+    __c2_    = 0;
+    __c1_    = 0;
+    __c0_    = 0;
+    __c_     = 0;
+  } else {
+    __s_        = std::sqrt(__mean_);
+    __d_        = 6 * __mean_ * __mean_;
+    __l_        = std::trunc(__mean_ - 1.1484);
+    __omega_    = .3989423 / __s_;
+    double __b1 = .4166667E-1 / __mean_;
+    double __b2 = .3 * __b1 * __b1;
+    __c3_       = .1428571 * __b1 * __b2;
+    __c2_       = __b2 - 15. * __c3_;
+    __c1_       = __b1 - 6. * __b2 + 45. * __c3_;
+    __c0_       = 1. - __b1 + 3. * __b2 - 15. * __c3_;
+    __c_        = .1069 / __mean_;
+  }
 }
 
 template <class _IntType>
-template<class _URNG>
-_IntType
-poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    double __tx;
-    uniform_real_distribution<double> __urd;
-    if (__pr.__mean_ < 10)
-    {
-         __tx = 0;
-        for (double __p = __urd(__urng); __p > __pr.__l_; ++__tx)
-            __p *= __urd(__urng);
+template <class _URNG>
+_IntType poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  double __tx;
+  uniform_real_distribution<double> __urd;
+  if (__pr.__mean_ < 10) {
+    __tx = 0;
+    for (double __p = __urd(__urng); __p > __pr.__l_; ++__tx)
+      __p *= __urd(__urng);
+  } else {
+    double __difmuk;
+    double __g = __pr.__mean_ + __pr.__s_ * normal_distribution<double>()(__urng);
+    double __u;
+    if (__g > 0) {
+      __tx = std::trunc(__g);
+      if (__tx >= __pr.__l_)
+        return std::__clamp_to_integral<result_type>(__tx);
+      __difmuk = __pr.__mean_ - __tx;
+      __u      = __urd(__urng);
+      if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk)
+        return std::__clamp_to_integral<result_type>(__tx);
     }
-    else
-    {
-        double __difmuk;
-        double __g = __pr.__mean_ + __pr.__s_ * normal_distribution<double>()(__urng);
-        double __u;
-        if (__g > 0)
-        {
-            __tx = _VSTD::trunc(__g);
-            if (__tx >= __pr.__l_)
-                return _VSTD::__clamp_to_integral<result_type>(__tx);
-            __difmuk = __pr.__mean_ - __tx;
-            __u = __urd(__urng);
-            if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk)
-                return _VSTD::__clamp_to_integral<result_type>(__tx);
-        }
-        exponential_distribution<double> __edist;
-        for (bool __using_exp_dist = false; true; __using_exp_dist = true)
-        {
-            double __e;
-            if (__using_exp_dist || __g <= 0)
-            {
-                double __t;
-                do
-                {
-                    __e = __edist(__urng);
-                    __u = __urd(__urng);
-                    __u += __u - 1;
-                    __t = 1.8 + (__u < 0 ? -__e : __e);
-                } while (__t <= -.6744);
-                __tx = _VSTD::trunc(__pr.__mean_ + __pr.__s_ * __t);
-                __difmuk = __pr.__mean_ - __tx;
-                __using_exp_dist = true;
-            }
-            double __px;
-            double __py;
-            if (__tx < 10 && __tx >= 0)
-            {
-                const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
-                                             40320, 362880};
-                __px = -__pr.__mean_;
-                __py = _VSTD::pow(__pr.__mean_, (double)__tx) / __fac[static_cast<int>(__tx)];
-            }
-            else
-            {
-                double __del = .8333333E-1 / __tx;
-                __del -= 4.8 * __del * __del * __del;
-                double __v = __difmuk / __tx;
-                if (_VSTD::abs(__v) > 0.25)
-                    __px = __tx * _VSTD::log(1 + __v) - __difmuk - __del;
-                else
-                    __px = __tx * __v * __v * (((((((.1250060 * __v + -.1384794) *
-                           __v + .1421878) * __v + -.1661269) * __v + .2000118) *
-                           __v + -.2500068) * __v + .3333333) * __v + -.5) - __del;
-                __py = .3989423 / _VSTD::sqrt(__tx);
-            }
-            double __r = (0.5 - __difmuk) / __pr.__s_;
-            double __r2 = __r * __r;
-            double __fx = -0.5 * __r2;
-            double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) *
-                                        __r2 + __pr.__c1_) * __r2 + __pr.__c0_);
-            if (__using_exp_dist)
-            {
-                if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) -
-                                                   __fy * _VSTD::exp(__fx + __e))
-                    break;
-            }
-            else
-            {
-                if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx))
-                    break;
-            }
-        }
+    exponential_distribution<double> __edist;
+    for (bool __using_exp_dist = false; true; __using_exp_dist = true) {
+      double __e;
+      if (__using_exp_dist || __g <= 0) {
+        double __t;
+        do {
+          __e = __edist(__urng);
+          __u = __urd(__urng);
+          __u += __u - 1;
+          __t = 1.8 + (__u < 0 ? -__e : __e);
+        } while (__t <= -.6744);
+        __tx             = std::trunc(__pr.__mean_ + __pr.__s_ * __t);
+        __difmuk         = __pr.__mean_ - __tx;
+        __using_exp_dist = true;
+      }
+      double __px;
+      double __py;
+      if (__tx < 10 && __tx >= 0) {
+        const double __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
+        __px                 = -__pr.__mean_;
+        __py                 = std::pow(__pr.__mean_, (double)__tx) / __fac[static_cast<int>(__tx)];
+      } else {
+        double __del = .8333333E-1 / __tx;
+        __del -= 4.8 * __del * __del * __del;
+        double __v = __difmuk / __tx;
+        if (std::abs(__v) > 0.25)
+          __px = __tx * std::log(1 + __v) - __difmuk - __del;
+        else
+          __px = __tx * __v * __v *
+                     (((((((.1250060 * __v + -.1384794) * __v + .1421878) * __v + -.1661269) * __v + .2000118) * __v +
+                        -.2500068) *
+                           __v +
+                       .3333333) *
+                          __v +
+                      -.5) -
+                 __del;
+        __py = .3989423 / std::sqrt(__tx);
+      }
+      double __r  = (0.5 - __difmuk) / __pr.__s_;
+      double __r2 = __r * __r;
+      double __fx = -0.5 * __r2;
+      double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) * __r2 + __pr.__c1_) * __r2 + __pr.__c0_);
+      if (__using_exp_dist) {
+        if (__pr.__c_ * std::abs(__u) <= __py * std::exp(__px + __e) - __fy * std::exp(__fx + __e))
+          break;
+      } else {
+        if (__fy - __u * __fy <= __py * std::exp(__px - __fx))
+          break;
+      }
     }
-    return _VSTD::__clamp_to_integral<result_type>(__tx);
+  }
+  return std::__clamp_to_integral<result_type>(__tx);
 }
 
 template <class _CharT, class _Traits, class _IntType>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const poisson_distribution<_IntType>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    return __os << __x.mean();
+operator<<(basic_ostream<_CharT, _Traits>& __os, const poisson_distribution<_IntType>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  return __os << __x.mean();
 }
 
 template <class _CharT, class _Traits, class _IntType>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           poisson_distribution<_IntType>& __x)
-{
-    typedef poisson_distribution<_IntType> _Eng;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    double __mean;
-    __is >> __mean;
-    if (!__is.fail())
-        __x.param(param_type(__mean));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, poisson_distribution<_IntType>& __x) {
+  typedef poisson_distribution<_IntType> _Eng;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  double __mean;
+  __is >> __mean;
+  if (!__is.fail())
+    __x.param(param_type(__mean));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/random_device.h b/third_party/libcxx/__random/random_device.h
index e16afeafc..52407943d 100644
--- a/third_party/libcxx/__random/random_device.h
+++ b/third_party/libcxx/__random/random_device.h
@@ -23,56 +23,53 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_HAS_NO_RANDOM_DEVICE)
 
-class _LIBCPP_TYPE_VIS random_device
-{
-#ifdef _LIBCPP_USING_DEV_RANDOM
-    int __f_;
-#elif !defined(_LIBCPP_ABI_NO_RANDOM_DEVICE_COMPATIBILITY_LAYOUT)
-    _LIBCPP_DIAGNOSTIC_PUSH
-    _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wunused-private-field")
+class _LIBCPP_EXPORTED_FROM_ABI random_device {
+#  ifdef _LIBCPP_USING_DEV_RANDOM
+  int __f_;
+#  elif !defined(_LIBCPP_ABI_NO_RANDOM_DEVICE_COMPATIBILITY_LAYOUT)
+  _LIBCPP_DIAGNOSTIC_PUSH
+  _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wunused-private-field")
 
-    // Apple platforms used to use the `_LIBCPP_USING_DEV_RANDOM` code path, and now
-    // use `arc4random()` as of this comment. In order to avoid breaking the ABI, we
-    // retain the same layout as before.
-#   if defined(__APPLE__)
-    int __padding_; // padding to fake the `__f_` field above
-#   endif
+  // Apple platforms used to use the `_LIBCPP_USING_DEV_RANDOM` code path, and now
+  // use `arc4random()` as of this comment. In order to avoid breaking the ABI, we
+  // retain the same layout as before.
+#    if defined(__APPLE__)
+  int __padding_; // padding to fake the `__f_` field above
+#    endif
 
-    // ... vendors can add workarounds here if they switch to a different representation ...
+  // ... vendors can add workarounds here if they switch to a different representation ...
 
-    _LIBCPP_DIAGNOSTIC_POP
-#endif
+  _LIBCPP_DIAGNOSTIC_POP
+#  endif
 
 public:
-    // types
-    typedef unsigned result_type;
+  // types
+  typedef unsigned result_type;
 
-    // generator characteristics
-    static _LIBCPP_CONSTEXPR const result_type _Min = 0;
-    static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
+  // generator characteristics
+  static _LIBCPP_CONSTEXPR const result_type _Min = 0;
+  static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
 
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Max;}
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
 
-    // constructors
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI random_device() : random_device("/dev/urandom") {}
-    explicit random_device(const string& __token);
-#else
-    explicit random_device(const string& __token = "/dev/urandom");
-#endif
-    ~random_device();
+  // constructors
+#  ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI random_device() : random_device("/dev/urandom") {}
+  explicit random_device(const string& __token);
+#  else
+  explicit random_device(const string& __token = "/dev/urandom");
+#  endif
+  ~random_device();
 
-    // generating functions
-    result_type operator()();
+  // generating functions
+  result_type operator()();
 
-    // property functions
-    double entropy() const _NOEXCEPT;
+  // property functions
+  double entropy() const _NOEXCEPT;
 
-    random_device(const random_device&) = delete;
-    void operator=(const random_device&) = delete;
+  random_device(const random_device&)  = delete;
+  void operator=(const random_device&) = delete;
 };
 
 #endif // !_LIBCPP_HAS_NO_RANDOM_DEVICE
diff --git a/third_party/libcxx/__random/ranlux.h b/third_party/libcxx/__random/ranlux.h
index e44cece39..952afde91 100644
--- a/third_party/libcxx/__random/ranlux.h
+++ b/third_party/libcxx/__random/ranlux.h
@@ -21,7 +21,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base;
-typedef subtract_with_carry_engine<uint_fast64_t, 48,  5, 12> ranlux48_base;
+typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base;
 
 typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
 typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
diff --git a/third_party/libcxx/__random/seed_seq.h b/third_party/libcxx/__random/seed_seq.h
index 506b979cf..5cf84aeb8 100644
--- a/third_party/libcxx/__random/seed_seq.h
+++ b/third_party/libcxx/__random/seed_seq.h
@@ -14,6 +14,7 @@
 #include <__algorithm/max.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__type_traits/is_unsigned.h>
 #include <cstdint>
 #include <initializer_list>
 #include <vector>
@@ -27,149 +28,135 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TEMPLATE_VIS seed_seq
-{
+class _LIBCPP_TEMPLATE_VIS seed_seq {
 public:
-    // types
-    typedef uint32_t result_type;
+  // types
+  typedef uint32_t result_type;
 
-    // constructors
-    _LIBCPP_INLINE_VISIBILITY
-    seed_seq() _NOEXCEPT {}
+  // constructors
+  _LIBCPP_HIDE_FROM_ABI seed_seq() _NOEXCEPT {}
 #ifndef _LIBCPP_CXX03_LANG
-    template<class _Tp, __enable_if_t<is_integral<_Tp>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    seed_seq(initializer_list<_Tp> __il) {
-        __init(__il.begin(), __il.end());
-    }
+  template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI seed_seq(initializer_list<_Tp> __il) {
+    __init(__il.begin(), __il.end());
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-    template<class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-    seed_seq(_InputIterator __first, _InputIterator __last) {
-        static_assert(is_integral<typename iterator_traits<_InputIterator>::value_type>::value,
-            "Mandates: iterator_traits<InputIterator>::value_type is an integer type");
-        __init(__first, __last);
-    }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI seed_seq(_InputIterator __first, _InputIterator __last) {
+    static_assert(is_integral<typename iterator_traits<_InputIterator>::value_type>::value,
+                  "Mandates: iterator_traits<InputIterator>::value_type is an integer type");
+    __init(__first, __last);
+  }
 
-    // generating functions
-    template<class _RandomAccessIterator>
-    _LIBCPP_HIDE_FROM_ABI void generate(_RandomAccessIterator __first, _RandomAccessIterator __last);
+  // generating functions
+  template <class _RandomAccessIterator>
+  _LIBCPP_HIDE_FROM_ABI void generate(_RandomAccessIterator __first, _RandomAccessIterator __last);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const _NOEXCEPT {return __v_.size();}
-    template<class _OutputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        void param(_OutputIterator __dest) const
-            {_VSTD::copy(__v_.begin(), __v_.end(), __dest);}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI size_t size() const _NOEXCEPT { return __v_.size(); }
+  template <class _OutputIterator>
+  _LIBCPP_HIDE_FROM_ABI void param(_OutputIterator __dest) const {
+    std::copy(__v_.begin(), __v_.end(), __dest);
+  }
 
-    seed_seq(const seed_seq&) = delete;
-    void operator=(const seed_seq&) = delete;
+  seed_seq(const seed_seq&)       = delete;
+  void operator=(const seed_seq&) = delete;
 
-    _LIBCPP_INLINE_VISIBILITY
-    static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);}
+  _LIBCPP_HIDE_FROM_ABI static result_type _Tp(result_type __x) { return __x ^ (__x >> 27); }
 
 private:
-    template<class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI void __init(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void __init(_InputIterator __first, _InputIterator __last);
 
-    vector<result_type> __v_;
+  vector<result_type> __v_;
 };
 
-template<class _InputIterator>
-void
-seed_seq::__init(_InputIterator __first, _InputIterator __last)
-{
-    for (_InputIterator __s = __first; __s != __last; ++__s)
-        __v_.push_back(*__s & 0xFFFFFFFF);
+template <class _InputIterator>
+void seed_seq::__init(_InputIterator __first, _InputIterator __last) {
+  for (_InputIterator __s = __first; __s != __last; ++__s)
+    __v_.push_back(*__s & 0xFFFFFFFF);
 }
 
-template<class _RandomAccessIterator>
-void
-seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
-{
-    if (__first != __last)
+template <class _RandomAccessIterator>
+void seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last) {
+  using _ValueType = typename iterator_traits<_RandomAccessIterator>::value_type;
+  static_assert(is_unsigned<_ValueType>::value && sizeof(_ValueType) >= sizeof(uint32_t),
+                "[rand.util.seedseq]/7 requires the value_type of the iterator to be an unsigned "
+                "integer capable of accommodating 32-bit quantities.");
+
+  if (__first != __last) {
+    std::fill(__first, __last, 0x8b8b8b8b);
+    const size_t __n = static_cast<size_t>(__last - __first);
+    const size_t __s = __v_.size();
+    const size_t __t = (__n >= 623) ? 11 : (__n >= 68) ? 7 : (__n >= 39) ? 5 : (__n >= 7) ? 3 : (__n - 1) / 2;
+    const size_t __p = (__n - __t) / 2;
+    const size_t __q = __p + __t;
+    const size_t __m = std::max(__s + 1, __n);
+    // __k = 0;
     {
-        _VSTD::fill(__first, __last, 0x8b8b8b8b);
-        const size_t __n = static_cast<size_t>(__last - __first);
-        const size_t __s = __v_.size();
-        const size_t __t = (__n >= 623) ? 11
-                         : (__n >= 68) ? 7
-                         : (__n >= 39) ? 5
-                         : (__n >= 7)  ? 3
-                         : (__n - 1) / 2;
-        const size_t __p = (__n - __t) / 2;
-        const size_t __q = __p + __t;
-        const size_t __m = _VSTD::max(__s + 1, __n);
-        // __k = 0;
-        {
-            result_type __r = 1664525 * _Tp(__first[0] ^ __first[__p]
-                                                      ^  __first[__n - 1]);
-            __first[__p] += __r;
-            __r += __s;
-            __first[__q] += __r;
-            __first[0] = __r;
-        }
-        // Initialize indexing terms used with if statements as an optimization to
-        // avoid calculating modulo n on every loop iteration for each term.
-        size_t __kmodn = 0;          // __k % __n
-        size_t __k1modn = __n - 1;   // (__k - 1) % __n
-        size_t __kpmodn = __p % __n; // (__k + __p) % __n
-        size_t __kqmodn = __q % __n; // (__k + __q) % __n
-
-        for (size_t __k = 1; __k <= __s; ++__k)
-        {
-          if (++__kmodn == __n)
-            __kmodn = 0;
-          if (++__k1modn == __n)
-            __k1modn = 0;
-          if (++__kpmodn == __n)
-            __kpmodn = 0;
-          if (++__kqmodn == __n)
-            __kqmodn = 0;
-
-          result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] ^ __first[__k1modn]);
-          __first[__kpmodn] += __r;
-          __r += __kmodn + __v_[__k - 1];
-          __first[__kqmodn] += __r;
-          __first[__kmodn] = __r;
-        }
-        for (size_t __k = __s + 1; __k < __m; ++__k)
-        {
-          if (++__kmodn == __n)
-            __kmodn = 0;
-          if (++__k1modn == __n)
-            __k1modn = 0;
-          if (++__kpmodn == __n)
-            __kpmodn = 0;
-          if (++__kqmodn == __n)
-            __kqmodn = 0;
-
-          result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] ^ __first[__k1modn]);
-          __first[__kpmodn] += __r;
-          __r += __kmodn;
-          __first[__kqmodn] += __r;
-          __first[__kmodn] = __r;
-        }
-        for (size_t __k = __m; __k < __m + __n; ++__k)
-        {
-          if (++__kmodn == __n)
-            __kmodn = 0;
-          if (++__k1modn == __n)
-            __k1modn = 0;
-          if (++__kpmodn == __n)
-            __kpmodn = 0;
-          if (++__kqmodn == __n)
-            __kqmodn = 0;
-
-          result_type __r = 1566083941 * _Tp(__first[__kmodn] + __first[__kpmodn] + __first[__k1modn]);
-          __first[__kpmodn] ^= __r;
-          __r -= __kmodn;
-          __first[__kqmodn] ^= __r;
-          __first[__kmodn] = __r;
-        }
+      result_type __r = 1664525 * _Tp(__first[0] ^ __first[__p] ^ __first[__n - 1]);
+      __first[__p] += __r;
+      __r += __s;
+      __first[__q] += __r;
+      __first[0] = __r;
     }
+    // Initialize indexing terms used with if statements as an optimization to
+    // avoid calculating modulo n on every loop iteration for each term.
+    size_t __kmodn  = 0;         // __k % __n
+    size_t __k1modn = __n - 1;   // (__k - 1) % __n
+    size_t __kpmodn = __p % __n; // (__k + __p) % __n
+    size_t __kqmodn = __q % __n; // (__k + __q) % __n
+
+    for (size_t __k = 1; __k <= __s; ++__k) {
+      if (++__kmodn == __n)
+        __kmodn = 0;
+      if (++__k1modn == __n)
+        __k1modn = 0;
+      if (++__kpmodn == __n)
+        __kpmodn = 0;
+      if (++__kqmodn == __n)
+        __kqmodn = 0;
+
+      result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] ^ __first[__k1modn]);
+      __first[__kpmodn] += __r;
+      __r += __kmodn + __v_[__k - 1];
+      __first[__kqmodn] += __r;
+      __first[__kmodn] = __r;
+    }
+    for (size_t __k = __s + 1; __k < __m; ++__k) {
+      if (++__kmodn == __n)
+        __kmodn = 0;
+      if (++__k1modn == __n)
+        __k1modn = 0;
+      if (++__kpmodn == __n)
+        __kpmodn = 0;
+      if (++__kqmodn == __n)
+        __kqmodn = 0;
+
+      result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn] ^ __first[__k1modn]);
+      __first[__kpmodn] += __r;
+      __r += __kmodn;
+      __first[__kqmodn] += __r;
+      __first[__kmodn] = __r;
+    }
+    for (size_t __k = __m; __k < __m + __n; ++__k) {
+      if (++__kmodn == __n)
+        __kmodn = 0;
+      if (++__k1modn == __n)
+        __k1modn = 0;
+      if (++__kpmodn == __n)
+        __kpmodn = 0;
+      if (++__kqmodn == __n)
+        __kqmodn = 0;
+
+      result_type __r = 1566083941 * _Tp(__first[__kmodn] + __first[__kpmodn] + __first[__k1modn]);
+      __first[__kpmodn] ^= __r;
+      __r -= __kmodn;
+      __first[__kqmodn] ^= __r;
+      __first[__kmodn] = __r;
+    }
+  }
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/shuffle_order_engine.h b/third_party/libcxx/__random/shuffle_order_engine.h
index e07f230d2..f54ed17e3 100644
--- a/third_party/libcxx/__random/shuffle_order_engine.h
+++ b/third_party/libcxx/__random/shuffle_order_engine.h
@@ -30,253 +30,197 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <uint64_t _Xp, uint64_t _Yp>
-struct __ugcd
-{
-    static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value;
+struct __ugcd {
+  static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value;
 };
 
 template <uint64_t _Xp>
-struct __ugcd<_Xp, 0>
-{
-    static _LIBCPP_CONSTEXPR const uint64_t value = _Xp;
+struct __ugcd<_Xp, 0> {
+  static _LIBCPP_CONSTEXPR const uint64_t value = _Xp;
 };
 
 template <uint64_t _Np, uint64_t _Dp>
-class __uratio
-{
-    static_assert(_Dp != 0, "__uratio divide by 0");
-    static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value;
-public:
-    static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd;
-    static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd;
+class __uratio {
+  static_assert(_Dp != 0, "__uratio divide by 0");
+  static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value;
 
-    typedef __uratio<num, den> type;
+public:
+  static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd;
+  static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd;
+
+  typedef __uratio<num, den> type;
 };
 
-template<class _Engine, size_t __k>
-class _LIBCPP_TEMPLATE_VIS shuffle_order_engine
-{
-    static_assert(0 < __k, "shuffle_order_engine invalid parameters");
+template <class _Engine, size_t __k>
+class _LIBCPP_TEMPLATE_VIS shuffle_order_engine {
+  static_assert(0 < __k, "shuffle_order_engine invalid parameters");
+
 public:
-    // types
-    typedef typename _Engine::result_type result_type;
+  // types
+  typedef typename _Engine::result_type result_type;
 
 private:
-    _Engine __e_;
-    result_type __v_[__k];
-    result_type __y_;
+  _Engine __e_;
+  result_type __v_[__k];
+  result_type __y_;
 
 public:
-    // engine characteristics
-    static _LIBCPP_CONSTEXPR const size_t table_size = __k;
+  // engine characteristics
+  static _LIBCPP_CONSTEXPR const size_t table_size = __k;
 
 #ifdef _LIBCPP_CXX03_LANG
-    static const result_type _Min = _Engine::_Min;
-    static const result_type _Max = _Engine::_Max;
+  static const result_type _Min = _Engine::_Min;
+  static const result_type _Max = _Engine::_Max;
 #else
-    static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
-    static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
+  static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
+  static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
 #endif
-    static_assert(_Min < _Max, "shuffle_order_engine invalid parameters");
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
+  static_assert(_Min < _Max, "shuffle_order_engine invalid parameters");
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
 
-    static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull;
+  static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull;
 
-    // constructors and seeding functions
-    _LIBCPP_INLINE_VISIBILITY
-    shuffle_order_engine() {__init();}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit shuffle_order_engine(const _Engine& __e)
-        : __e_(__e) {__init();}
+  // constructors and seeding functions
+  _LIBCPP_HIDE_FROM_ABI shuffle_order_engine() { __init(); }
+  _LIBCPP_HIDE_FROM_ABI explicit shuffle_order_engine(const _Engine& __e) : __e_(__e) { __init(); }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit shuffle_order_engine(_Engine&& __e)
-        : __e_(_VSTD::move(__e)) {__init();}
+  _LIBCPP_HIDE_FROM_ABI explicit shuffle_order_engine(_Engine&& __e) : __e_(std::move(__e)) { __init(); }
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit shuffle_order_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value &&
-                           !is_convertible<_Sseq, _Engine>::value>::type* = 0)
-         : __e_(__q) {__init();}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed() {__e_.seed(); __init();}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(result_type __sd) {__e_.seed(__sd); __init();}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, shuffle_order_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q) {__e_.seed(__q); __init();}
+  _LIBCPP_HIDE_FROM_ABI explicit shuffle_order_engine(result_type __sd) : __e_(__sd) { __init(); }
+  template <
+      class _Sseq,
+      __enable_if_t<__is_seed_sequence<_Sseq, shuffle_order_engine>::value && !is_convertible<_Sseq, _Engine>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit shuffle_order_engine(_Sseq& __q) : __e_(__q) {
+    __init();
+  }
+  _LIBCPP_HIDE_FROM_ABI void seed() {
+    __e_.seed();
+    __init();
+  }
+  _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd) {
+    __e_.seed(__sd);
+    __init();
+  }
+  template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, shuffle_order_engine>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) {
+    __e_.seed(__q);
+    __init();
+  }
 
-    // generating functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  // generating functions
+  _LIBCPP_HIDE_FROM_ABI result_type operator()() { return __eval(integral_constant<bool, _Rp != 0>()); }
+  _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    const _Engine& base() const _NOEXCEPT {return __e_;}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI const _Engine& base() const _NOEXCEPT { return __e_; }
 
 private:
-    template<class _Eng, size_t _Kp>
-    friend
-    bool
-    operator==(
-        const shuffle_order_engine<_Eng, _Kp>& __x,
-        const shuffle_order_engine<_Eng, _Kp>& __y);
+  template <class _Eng, size_t _Kp>
+  friend bool operator==(const shuffle_order_engine<_Eng, _Kp>& __x, const shuffle_order_engine<_Eng, _Kp>& __y);
 
-    template<class _Eng, size_t _Kp>
-    friend
-    bool
-    operator!=(
-        const shuffle_order_engine<_Eng, _Kp>& __x,
-        const shuffle_order_engine<_Eng, _Kp>& __y);
+  template <class _Eng, size_t _Kp>
+  friend bool operator!=(const shuffle_order_engine<_Eng, _Kp>& __x, const shuffle_order_engine<_Eng, _Kp>& __y);
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Kp>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const shuffle_order_engine<_Eng, _Kp>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Kp>
+  friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const shuffle_order_engine<_Eng, _Kp>& __x);
 
-    template <class _CharT, class _Traits,
-              class _Eng, size_t _Kp>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               shuffle_order_engine<_Eng, _Kp>& __x);
+  template <class _CharT, class _Traits, class _Eng, size_t _Kp>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, shuffle_order_engine<_Eng, _Kp>& __x);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __init()
-    {
-        for (size_t __i = 0; __i < __k; ++__i)
-            __v_[__i] = __e_();
-        __y_ = __e_();
-    }
+  _LIBCPP_HIDE_FROM_ABI void __init() {
+    for (size_t __i = 0; __i < __k; ++__i)
+      __v_[__i] = __e_();
+    __y_ = __e_();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type __eval(false_type) {return __eval2(integral_constant<bool, __k & 1>());}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());}
+  _LIBCPP_HIDE_FROM_ABI result_type __eval(false_type) { return __eval2(integral_constant<bool, __k & 1>()); }
+  _LIBCPP_HIDE_FROM_ABI result_type __eval(true_type) { return __eval(__uratio<__k, _Rp>()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type __eval2(true_type) {return __evalf<__k, 0>();}
+  _LIBCPP_HIDE_FROM_ABI result_type __eval2(false_type) { return __eval(__uratio<__k / 2, 0x8000000000000000ull>()); }
+  _LIBCPP_HIDE_FROM_ABI result_type __eval2(true_type) { return __evalf<__k, 0>(); }
 
-    template <uint64_t _Np, uint64_t _Dp>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            (__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)),
-            result_type
-        >::type
-        __eval(__uratio<_Np, _Dp>)
-            {return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();}
+  template <uint64_t _Np,
+            uint64_t _Dp,
+            __enable_if_t<(__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI result_type __eval(__uratio<_Np, _Dp>) {
+    return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();
+  }
 
-    template <uint64_t _Np, uint64_t _Dp>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min),
-            result_type
-        >::type
-        __eval(__uratio<_Np, _Dp>)
-        {
-            const size_t __j = static_cast<size_t>(__uratio<_Np, _Dp>::num * (__y_ - _Min)
-                                                   / __uratio<_Np, _Dp>::den);
-            __y_ = __v_[__j];
-            __v_[__j] = __e_();
-            return __y_;
-        }
+  template <uint64_t _Np,
+            uint64_t _Dp,
+            __enable_if_t<__uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI result_type __eval(__uratio<_Np, _Dp>) {
+    const size_t __j = static_cast<size_t>(__uratio<_Np, _Dp>::num * (__y_ - _Min) / __uratio<_Np, _Dp>::den);
+    __y_             = __v_[__j];
+    __v_[__j]        = __e_();
+    return __y_;
+  }
 
-    template <uint64_t __n, uint64_t __d>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type __evalf()
-        {
-            const double __fp = __d == 0 ?
-                __n / (2. * 0x8000000000000000ull) :
-                __n / (double)__d;
-            const size_t __j = static_cast<size_t>(__fp * (__y_ - _Min));
-            __y_ = __v_[__j];
-            __v_[__j] = __e_();
-            return __y_;
-        }
+  template <uint64_t __n, uint64_t __d>
+  _LIBCPP_HIDE_FROM_ABI result_type __evalf() {
+    const double __fp = __d == 0 ? __n / (2. * 0x8000000000000000ull) : __n / (double)__d;
+    const size_t __j  = static_cast<size_t>(__fp * (__y_ - _Min));
+    __y_              = __v_[__j];
+    __v_[__j]         = __e_();
+    return __y_;
+  }
 };
 
-template<class _Engine, size_t __k>
-    _LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size;
+template <class _Engine, size_t __k>
+_LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size;
 
-template<class _Eng, size_t _Kp>
+template <class _Eng, size_t _Kp>
 _LIBCPP_HIDE_FROM_ABI bool
-operator==(
-    const shuffle_order_engine<_Eng, _Kp>& __x,
-    const shuffle_order_engine<_Eng, _Kp>& __y)
-{
-    return __x.__y_ == __y.__y_ && _VSTD::equal(__x.__v_, __x.__v_ + _Kp, __y.__v_) &&
-           __x.__e_ == __y.__e_;
+operator==(const shuffle_order_engine<_Eng, _Kp>& __x, const shuffle_order_engine<_Eng, _Kp>& __y) {
+  return __x.__y_ == __y.__y_ && std::equal(__x.__v_, __x.__v_ + _Kp, __y.__v_) && __x.__e_ == __y.__e_;
 }
 
-template<class _Eng, size_t _Kp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(
-    const shuffle_order_engine<_Eng, _Kp>& __x,
-    const shuffle_order_engine<_Eng, _Kp>& __y)
-{
-    return !(__x == __y);
+template <class _Eng, size_t _Kp>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const shuffle_order_engine<_Eng, _Kp>& __x, const shuffle_order_engine<_Eng, _Kp>& __y) {
+  return !(__x == __y);
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Kp>
+template <class _CharT, class _Traits, class _Eng, size_t _Kp>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const shuffle_order_engine<_Eng, _Kp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.__e_ << __sp << __x.__v_[0];
-    for (size_t __i = 1; __i < _Kp; ++__i)
-        __os << __sp << __x.__v_[__i];
-    return __os << __sp << __x.__y_;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const shuffle_order_engine<_Eng, _Kp>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _Ostream;
+  __os.flags(_Ostream::dec | _Ostream::left);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  __os << __x.__e_ << __sp << __x.__v_[0];
+  for (size_t __i = 1; __i < _Kp; ++__i)
+    __os << __sp << __x.__v_[__i];
+  return __os << __sp << __x.__y_;
 }
 
-template <class _CharT, class _Traits,
-          class _Eng, size_t _Kp>
+template <class _CharT, class _Traits, class _Eng, size_t _Kp>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           shuffle_order_engine<_Eng, _Kp>& __x)
-{
-    typedef typename shuffle_order_engine<_Eng, _Kp>::result_type result_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    _Eng __e;
-    result_type __vp[_Kp+1];
-    __is >> __e;
-    for (size_t __i = 0; __i < _Kp+1; ++__i)
-        __is >> __vp[__i];
-    if (!__is.fail())
-    {
-        __x.__e_ = __e;
-        for (size_t __i = 0; __i < _Kp; ++__i)
-            __x.__v_[__i] = __vp[__i];
-        __x.__y_ = __vp[_Kp];
-    }
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, shuffle_order_engine<_Eng, _Kp>& __x) {
+  typedef typename shuffle_order_engine<_Eng, _Kp>::result_type result_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  _Eng __e;
+  result_type __vp[_Kp + 1];
+  __is >> __e;
+  for (size_t __i = 0; __i < _Kp + 1; ++__i)
+    __is >> __vp[__i];
+  if (!__is.fail()) {
+    __x.__e_ = __e;
+    for (size_t __i = 0; __i < _Kp; ++__i)
+      __x.__v_[__i] = __vp[__i];
+    __x.__y_ = __vp[_Kp];
+  }
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/student_t_distribution.h b/third_party/libcxx/__random/student_t_distribution.h
index 2d2be2365..110a856ee 100644
--- a/third_party/libcxx/__random/student_t_distribution.h
+++ b/third_party/libcxx/__random/student_t_distribution.h
@@ -26,127 +26,103 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS student_t_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS student_t_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __n_;
-    public:
-        typedef student_t_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __n_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __n = 1) : __n_(__n) {}
+  public:
+    typedef student_t_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type n() const {return __n_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __n = 1) : __n_(__n) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__n_ == __y.__n_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type n() const { return __n_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__n_ == __y.__n_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
-    normal_distribution<result_type> __nd_;
+  param_type __p_;
+  normal_distribution<result_type> __nd_;
 
 public:
-    // constructor and reset functions
+  // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    student_t_distribution() : student_t_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit student_t_distribution(result_type __n)
-        : __p_(param_type(__n)) {}
+  _LIBCPP_HIDE_FROM_ABI student_t_distribution() : student_t_distribution(1) {}
+  _LIBCPP_HIDE_FROM_ABI explicit student_t_distribution(result_type __n) : __p_(param_type(__n)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit student_t_distribution(result_type __n = 1)
-        : __p_(param_type(__n)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit student_t_distribution(result_type __n = 1) : __p_(param_type(__n)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit student_t_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {__nd_.reset();}
+  _LIBCPP_HIDE_FROM_ABI explicit student_t_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() { __nd_.reset(); }
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type n() const {return __p_.n();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type n() const { return __p_.n(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return -numeric_limits<result_type>::infinity();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return -numeric_limits<result_type>::infinity(); }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const student_t_distribution& __x,
-                        const student_t_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const student_t_distribution& __x,
-                        const student_t_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const student_t_distribution& __x, const student_t_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const student_t_distribution& __x, const student_t_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _RealType>
-template<class _URNG>
-_RealType
-student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    gamma_distribution<result_type> __gd(__p.n() * .5, 2);
-    return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
+template <class _URNG>
+_RealType student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  gamma_distribution<result_type> __gd(__p.n() * .5, 2);
+  return __nd_(__g) * std::sqrt(__p.n() / __gd(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const student_t_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    __os << __x.n();
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const student_t_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  __os << __x.n();
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           student_t_distribution<_RT>& __x)
-{
-    typedef student_t_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __n;
-    __is >> __n;
-    if (!__is.fail())
-        __x.param(param_type(__n));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, student_t_distribution<_RT>& __x) {
+  typedef student_t_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __n;
+  __is >> __n;
+  if (!__is.fail())
+    __x.param(param_type(__n));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/subtract_with_carry_engine.h b/third_party/libcxx/__random/subtract_with_carry_engine.h
index c8954ca11..ec25fed49 100644
--- a/third_party/libcxx/__random/subtract_with_carry_engine.h
+++ b/third_party/libcxx/__random/subtract_with_carry_engine.h
@@ -28,320 +28,245 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
 class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine;
 
-template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-_LIBCPP_HIDE_FROM_ABI bool
-operator==(
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
+template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+_LIBCPP_HIDE_FROM_ABI bool operator==(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+                                      const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
 
-template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
+template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+_LIBCPP_HIDE_FROM_ABI bool operator!=(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+                                      const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
+operator<<(basic_ostream<_CharT, _Traits>& __os, const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
+operator>>(basic_istream<_CharT, _Traits>& __is, subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine
-{
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine {
 public:
-    // types
-    typedef _UIntType result_type;
+  // types
+  typedef _UIntType result_type;
 
 private:
-    result_type __x_[__r];
-    result_type  __c_;
-    size_t      __i_;
+  result_type __x_[__r];
+  result_type __c_;
+  size_t __i_;
+
+  static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
+  static_assert(0 < __w, "subtract_with_carry_engine invalid parameters");
+  static_assert(__w <= _Dt, "subtract_with_carry_engine invalid parameters");
+  static_assert(0 < __s, "subtract_with_carry_engine invalid parameters");
+  static_assert(__s < __r, "subtract_with_carry_engine invalid parameters");
 
-    static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
-    static_assert(  0 <  __w, "subtract_with_carry_engine invalid parameters");
-    static_assert(__w <= _Dt, "subtract_with_carry_engine invalid parameters");
-    static_assert(  0 <  __s, "subtract_with_carry_engine invalid parameters");
-    static_assert(__s <  __r, "subtract_with_carry_engine invalid parameters");
 public:
-    static _LIBCPP_CONSTEXPR const result_type _Min = 0;
-    static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
-                                                      (result_type(1) << __w) - result_type(1);
-    static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters");
+  static _LIBCPP_CONSTEXPR const result_type _Min = 0;
+  static _LIBCPP_CONSTEXPR const result_type _Max =
+      __w == _Dt ? result_type(~0) : (result_type(1) << __w) - result_type(1);
+  static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters");
 
-    // engine characteristics
-    static _LIBCPP_CONSTEXPR const size_t word_size = __w;
-    static _LIBCPP_CONSTEXPR const size_t short_lag = __s;
-    static _LIBCPP_CONSTEXPR const size_t long_lag = __r;
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
-    static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
+  // engine characteristics
+  static _LIBCPP_CONSTEXPR const size_t word_size = __w;
+  static _LIBCPP_CONSTEXPR const size_t short_lag = __s;
+  static _LIBCPP_CONSTEXPR const size_t long_lag  = __r;
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
+  static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
 
-    // constructors and seeding functions
+  // constructors and seeding functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); }
+  _LIBCPP_HIDE_FROM_ABI subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
+  _LIBCPP_HIDE_FROM_ABI explicit subtract_with_carry_engine(result_type __sd) { seed(__sd); }
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit subtract_with_carry_engine(result_type __sd = default_seed) {
-      seed(__sd);
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit subtract_with_carry_engine(result_type __sd = default_seed) { seed(__sd); }
 #endif
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit subtract_with_carry_engine(_Sseq& __q,
-        typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
-        {seed(__q);}
-    _LIBCPP_INLINE_VISIBILITY
-    void seed(result_type __sd = default_seed)
-        {seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
-    template<class _Sseq>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __is_seed_sequence<_Sseq, subtract_with_carry_engine>::value,
-            void
-        >::type
-        seed(_Sseq& __q)
-            {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
+  template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit subtract_with_carry_engine(_Sseq& __q) {
+    seed(__q);
+  }
+  _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd = default_seed) {
+    seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());
+  }
+  template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) {
+    __seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());
+  }
 
-    // generating functions
-    _LIBCPP_HIDE_FROM_ABI result_type operator()();
-    _LIBCPP_INLINE_VISIBILITY
-    void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
+  // generating functions
+  _LIBCPP_HIDE_FROM_ABI result_type operator()();
+  _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) {
+    for (; __z; --__z)
+      operator()();
+  }
 
-    template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-    friend
-    bool
-    operator==(
-        const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
-        const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
+  template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+  friend bool operator==(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+                         const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
 
-    template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-    friend
-    bool
-    operator!=(
-        const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
-        const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
+  template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+  friend bool operator!=(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+                         const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
 
-    template <class _CharT, class _Traits,
-              class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os,
-               const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
+  template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+  friend basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
 
-    template <class _CharT, class _Traits,
-              class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is,
-               subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
+  template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+  friend basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
 
 private:
-
-    _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd, integral_constant<unsigned, 1>);
-    _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd, integral_constant<unsigned, 2>);
-    template<class _Sseq>
-    _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
-    template<class _Sseq>
-    _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
+  _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd, integral_constant<unsigned, 1>);
+  _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd, integral_constant<unsigned, 2>);
+  template <class _Sseq>
+  _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
+  template <class _Sseq>
+  _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
 };
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-    _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+_LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-    _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+_LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-    _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+_LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-    _LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+_LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type
     subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
-        integral_constant<unsigned, 1>)
-{
-    linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
-        __e(__sd == 0u ? default_seed : __sd);
-    for (size_t __i = 0; __i < __r; ++__i)
-        __x_[__i] = static_cast<result_type>(__e() & _Max);
-    __c_ = __x_[__r-1] == 0;
-    __i_ = 0;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+void subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd, integral_constant<unsigned, 1>) {
+  linear_congruential_engine<result_type, 40014u, 0u, 2147483563u> __e(__sd == 0u ? default_seed : __sd);
+  for (size_t __i = 0; __i < __r; ++__i)
+    __x_[__i] = static_cast<result_type>(__e() & _Max);
+  __c_ = __x_[__r - 1] == 0;
+  __i_ = 0;
 }
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
-        integral_constant<unsigned, 2>)
-{
-    linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
-        __e(__sd == 0u ? default_seed : __sd);
-    for (size_t __i = 0; __i < __r; ++__i)
-    {
-        result_type __e0 = __e();
-        __x_[__i] = static_cast<result_type>(
-                                    (__e0 + ((uint64_t)__e() << 32)) & _Max);
-    }
-    __c_ = __x_[__r-1] == 0;
-    __i_ = 0;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+void subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd, integral_constant<unsigned, 2>) {
+  linear_congruential_engine<result_type, 40014u, 0u, 2147483563u> __e(__sd == 0u ? default_seed : __sd);
+  for (size_t __i = 0; __i < __r; ++__i) {
+    result_type __e0 = __e();
+    __x_[__i]        = static_cast<result_type>((__e0 + ((uint64_t)__e() << 32)) & _Max);
+  }
+  __c_ = __x_[__r - 1] == 0;
+  __i_ = 0;
 }
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-template<class _Sseq>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
-        integral_constant<unsigned, 1>)
-{
-    const unsigned __k = 1;
-    uint32_t __ar[__r * __k];
-    __q.generate(__ar, __ar + __r * __k);
-    for (size_t __i = 0; __i < __r; ++__i)
-        __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
-    __c_ = __x_[__r-1] == 0;
-    __i_ = 0;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+template <class _Sseq>
+void subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q, integral_constant<unsigned, 1>) {
+  const unsigned __k = 1;
+  uint32_t __ar[__r * __k];
+  __q.generate(__ar, __ar + __r * __k);
+  for (size_t __i = 0; __i < __r; ++__i)
+    __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
+  __c_ = __x_[__r - 1] == 0;
+  __i_ = 0;
 }
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-template<class _Sseq>
-void
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
-        integral_constant<unsigned, 2>)
-{
-    const unsigned __k = 2;
-    uint32_t __ar[__r * __k];
-    __q.generate(__ar, __ar + __r * __k);
-    for (size_t __i = 0; __i < __r; ++__i)
-        __x_[__i] = static_cast<result_type>(
-                  (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
-    __c_ = __x_[__r-1] == 0;
-    __i_ = 0;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+template <class _Sseq>
+void subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q, integral_constant<unsigned, 2>) {
+  const unsigned __k = 2;
+  uint32_t __ar[__r * __k];
+  __q.generate(__ar, __ar + __r * __k);
+  for (size_t __i = 0; __i < __r; ++__i)
+    __x_[__i] = static_cast<result_type>((__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
+  __c_ = __x_[__r - 1] == 0;
+  __i_ = 0;
 }
 
-template<class _UIntType, size_t __w, size_t __s, size_t __r>
-_UIntType
-subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()()
-{
-    const result_type& __xs = __x_[(__i_ + (__r - __s)) % __r];
-    result_type& __xr = __x_[__i_];
-    result_type __new_c = __c_ == 0 ? __xs < __xr : __xs != 0 ? __xs <= __xr : 1;
-    __xr = (__xs - __xr - __c_) & _Max;
-    __c_ = __new_c;
-    __i_ = (__i_ + 1) % __r;
-    return __xr;
+template <class _UIntType, size_t __w, size_t __s, size_t __r>
+_UIntType subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()() {
+  const result_type& __xs = __x_[(__i_ + (__r - __s)) % __r];
+  result_type& __xr       = __x_[__i_];
+  result_type __new_c     = __c_ == 0 ? __xs < __xr : __xs != 0 ? __xs <= __xr : 1;
+  __xr                    = (__xs - __xr - __c_) & _Max;
+  __c_                    = __new_c;
+  __i_                    = (__i_ + 1) % __r;
+  return __xr;
 }
 
-template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-_LIBCPP_HIDE_FROM_ABI bool
-operator==(
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
-{
-    if (__x.__c_ != __y.__c_)
-        return false;
-    if (__x.__i_ == __y.__i_)
-        return _VSTD::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_);
-    if (__x.__i_ == 0 || __y.__i_ == 0)
-    {
-        size_t __j = _VSTD::min(_Rp - __x.__i_, _Rp - __y.__i_);
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
-                         __y.__x_ + __y.__i_))
-            return false;
-        if (__x.__i_ == 0)
-            return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_);
-        return _VSTD::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j);
-    }
-    if (__x.__i_ < __y.__i_)
-    {
-        size_t __j = _Rp - __y.__i_;
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
-                         __y.__x_ + __y.__i_))
-            return false;
-        if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp,
-                         __y.__x_))
-            return false;
-        return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
-                           __y.__x_ + (_Rp - (__x.__i_ + __j)));
-    }
-    size_t __j = _Rp - __x.__i_;
-    if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
-                     __x.__x_ + __x.__i_))
-        return false;
-    if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp,
-                     __x.__x_))
-        return false;
-    return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
-                       __x.__x_ + (_Rp - (__y.__i_ + __j)));
+template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+_LIBCPP_HIDE_FROM_ABI bool operator==(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+                                      const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y) {
+  if (__x.__c_ != __y.__c_)
+    return false;
+  if (__x.__i_ == __y.__i_)
+    return std::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_);
+  if (__x.__i_ == 0 || __y.__i_ == 0) {
+    size_t __j = std::min(_Rp - __x.__i_, _Rp - __y.__i_);
+    if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, __y.__x_ + __y.__i_))
+      return false;
+    if (__x.__i_ == 0)
+      return std::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_);
+    return std::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j);
+  }
+  if (__x.__i_ < __y.__i_) {
+    size_t __j = _Rp - __y.__i_;
+    if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), __y.__x_ + __y.__i_))
+      return false;
+    if (!std::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp, __y.__x_))
+      return false;
+    return std::equal(__x.__x_, __x.__x_ + __x.__i_, __y.__x_ + (_Rp - (__x.__i_ + __j)));
+  }
+  size_t __j = _Rp - __x.__i_;
+  if (!std::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), __x.__x_ + __x.__i_))
+    return false;
+  if (!std::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp, __x.__x_))
+    return false;
+  return std::equal(__y.__x_, __y.__x_ + __y.__i_, __x.__x_ + (_Rp - (__y.__i_ + __j)));
 }
 
-template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
-    const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
-{
-    return !(__x == __y);
+template <class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
+                                             const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y) {
+  return !(__x == __y);
 }
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.__x_[__x.__i_];
-    for (size_t __j = __x.__i_ + 1; __j < _Rp; ++__j)
-        __os << __sp << __x.__x_[__j];
-    for (size_t __j = 0; __j < __x.__i_; ++__j)
-        __os << __sp << __x.__x_[__j];
-    __os << __sp << __x.__c_;
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _Ostream;
+  __os.flags(_Ostream::dec | _Ostream::left);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  __os << __x.__x_[__x.__i_];
+  for (size_t __j = __x.__i_ + 1; __j < _Rp; ++__j)
+    __os << __sp << __x.__x_[__j];
+  for (size_t __j = 0; __j < __x.__i_; ++__j)
+    __os << __sp << __x.__x_[__j];
+  __os << __sp << __x.__c_;
+  return __os;
 }
 
-template <class _CharT, class _Traits,
-          class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
+template <class _CharT, class _Traits, class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    _UInt __t[_Rp+1];
-    for (size_t __i = 0; __i < _Rp+1; ++__i)
-        __is >> __t[__i];
-    if (!__is.fail())
-    {
-        for (size_t __i = 0; __i < _Rp; ++__i)
-            __x.__x_[__i] = __t[__i];
-        __x.__c_ = __t[_Rp];
-        __x.__i_ = 0;
-    }
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  _UInt __t[_Rp + 1];
+  for (size_t __i = 0; __i < _Rp + 1; ++__i)
+    __is >> __t[__i];
+  if (!__is.fail()) {
+    for (size_t __i = 0; __i < _Rp; ++__i)
+      __x.__x_[__i] = __t[__i];
+    __x.__c_ = __t[_Rp];
+    __x.__i_ = 0;
+  }
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/uniform_int_distribution.h b/third_party/libcxx/__random/uniform_int_distribution.h
index 3a2b95c03..4e3ca3efe 100644
--- a/third_party/libcxx/__random/uniform_int_distribution.h
+++ b/third_party/libcxx/__random/uniform_int_distribution.h
@@ -29,263 +29,232 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Engine, class _UIntType>
-class __independent_bits_engine
-{
+template <class _Engine, class _UIntType>
+class __independent_bits_engine {
 public:
-    // types
-    typedef _UIntType result_type;
+  // types
+  typedef _UIntType result_type;
 
 private:
-    typedef typename _Engine::result_type _Engine_result_type;
-    typedef __conditional_t<sizeof(_Engine_result_type) <= sizeof(result_type), result_type, _Engine_result_type>
-        _Working_result_type;
+  typedef typename _Engine::result_type _Engine_result_type;
+  typedef __conditional_t<sizeof(_Engine_result_type) <= sizeof(result_type), result_type, _Engine_result_type>
+      _Working_result_type;
 
-    _Engine& __e_;
-    size_t __w_;
-    size_t __w0_;
-    size_t __n_;
-    size_t __n0_;
-    _Working_result_type __y0_;
-    _Working_result_type __y1_;
-    _Engine_result_type __mask0_;
-    _Engine_result_type __mask1_;
+  _Engine& __e_;
+  size_t __w_;
+  size_t __w0_;
+  size_t __n_;
+  size_t __n0_;
+  _Working_result_type __y0_;
+  _Working_result_type __y1_;
+  _Engine_result_type __mask0_;
+  _Engine_result_type __mask1_;
 
 #ifdef _LIBCPP_CXX03_LANG
-    static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
-                                          + _Working_result_type(1);
+  static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min + _Working_result_type(1);
 #else
-    static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
-                                                      + _Working_result_type(1);
+  static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min() + _Working_result_type(1);
 #endif
-    static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
-    static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
-    static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
+  static _LIBCPP_CONSTEXPR const size_t __m  = __log2<_Working_result_type, _Rp>::value;
+  static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
+  static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
 
 public:
-    // constructors and seeding functions
-    _LIBCPP_HIDE_FROM_ABI __independent_bits_engine(_Engine& __e, size_t __w);
+  // constructors and seeding functions
+  _LIBCPP_HIDE_FROM_ABI __independent_bits_engine(_Engine& __e, size_t __w);
 
-    // generating functions
-    _LIBCPP_HIDE_FROM_ABI result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
+  // generating functions
+  _LIBCPP_HIDE_FROM_ABI result_type operator()() { return __eval(integral_constant<bool, _Rp != 0>()); }
 
 private:
-    _LIBCPP_HIDE_FROM_ABI result_type __eval(false_type);
-    _LIBCPP_HIDE_FROM_ABI result_type __eval(true_type);
+  _LIBCPP_HIDE_FROM_ABI result_type __eval(false_type);
+  _LIBCPP_HIDE_FROM_ABI result_type __eval(true_type);
 };
 
-template<class _Engine, class _UIntType>
-__independent_bits_engine<_Engine, _UIntType>
-    ::__independent_bits_engine(_Engine& __e, size_t __w)
-        : __e_(__e),
-          __w_(__w)
-{
-    __n_ = __w_ / __m + (__w_ % __m != 0);
+template <class _Engine, class _UIntType>
+__independent_bits_engine<_Engine, _UIntType>::__independent_bits_engine(_Engine& __e, size_t __w)
+    : __e_(__e), __w_(__w) {
+  __n_  = __w_ / __m + (__w_ % __m != 0);
+  __w0_ = __w_ / __n_;
+  if (_Rp == 0)
+    __y0_ = _Rp;
+  else if (__w0_ < _WDt)
+    __y0_ = (_Rp >> __w0_) << __w0_;
+  else
+    __y0_ = 0;
+  if (_Rp - __y0_ > __y0_ / __n_) {
+    ++__n_;
     __w0_ = __w_ / __n_;
-    if (_Rp == 0)
-        __y0_ = _Rp;
-    else if (__w0_ < _WDt)
-        __y0_ = (_Rp >> __w0_) << __w0_;
+    if (__w0_ < _WDt)
+      __y0_ = (_Rp >> __w0_) << __w0_;
     else
-        __y0_ = 0;
-    if (_Rp - __y0_ > __y0_ / __n_)
-    {
-        ++__n_;
-        __w0_ = __w_ / __n_;
-        if (__w0_ < _WDt)
-            __y0_ = (_Rp >> __w0_) << __w0_;
-        else
-            __y0_ = 0;
-    }
-    __n0_ = __n_ - __w_ % __n_;
-    if (__w0_ < _WDt - 1)
-        __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1);
+      __y0_ = 0;
+  }
+  __n0_ = __n_ - __w_ % __n_;
+  if (__w0_ < _WDt - 1)
+    __y1_ = (_Rp >> (__w0_ + 1)) << (__w0_ + 1);
+  else
+    __y1_ = 0;
+  __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) : _Engine_result_type(0);
+  __mask1_ = __w0_ < _EDt - 1 ? _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) : _Engine_result_type(~0);
+}
+
+template <class _Engine, class _UIntType>
+inline _UIntType __independent_bits_engine<_Engine, _UIntType>::__eval(false_type) {
+  return static_cast<result_type>(__e_() & __mask0_);
+}
+
+template <class _Engine, class _UIntType>
+_UIntType __independent_bits_engine<_Engine, _UIntType>::__eval(true_type) {
+  const size_t __w_rt = numeric_limits<result_type>::digits;
+  result_type __sp    = 0;
+  for (size_t __k = 0; __k < __n0_; ++__k) {
+    _Engine_result_type __u;
+    do {
+      __u = __e_() - _Engine::min();
+    } while (__u >= __y0_);
+    if (__w0_ < __w_rt)
+      __sp <<= __w0_;
     else
-        __y1_ = 0;
-    __mask0_ = __w0_ > 0 ? _Engine_result_type(~0) >> (_EDt - __w0_) :
-                          _Engine_result_type(0);
-    __mask1_ = __w0_ < _EDt - 1 ?
-                               _Engine_result_type(~0) >> (_EDt - (__w0_ + 1)) :
-                               _Engine_result_type(~0);
+      __sp = 0;
+    __sp += __u & __mask0_;
+  }
+  for (size_t __k = __n0_; __k < __n_; ++__k) {
+    _Engine_result_type __u;
+    do {
+      __u = __e_() - _Engine::min();
+    } while (__u >= __y1_);
+    if (__w0_ < __w_rt - 1)
+      __sp <<= __w0_ + 1;
+    else
+      __sp = 0;
+    __sp += __u & __mask1_;
+  }
+  return __sp;
 }
 
-template<class _Engine, class _UIntType>
-inline
-_UIntType
-__independent_bits_engine<_Engine, _UIntType>::__eval(false_type)
-{
-    return static_cast<result_type>(__e_() & __mask0_);
-}
+template <class _IntType = int>
+class uniform_int_distribution {
+  static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
 
-template<class _Engine, class _UIntType>
-_UIntType
-__independent_bits_engine<_Engine, _UIntType>::__eval(true_type)
-{
-    const size_t __w_rt = numeric_limits<result_type>::digits;
-    result_type __sp = 0;
-    for (size_t __k = 0; __k < __n0_; ++__k)
-    {
-        _Engine_result_type __u;
-        do
-        {
-            __u = __e_() - _Engine::min();
-        } while (__u >= __y0_);
-        if (__w0_ < __w_rt)
-            __sp <<= __w0_;
-        else
-            __sp = 0;
-        __sp += __u & __mask0_;
-    }
-    for (size_t __k = __n0_; __k < __n_; ++__k)
-    {
-        _Engine_result_type __u;
-        do
-        {
-            __u = __e_() - _Engine::min();
-        } while (__u >= __y1_);
-        if (__w0_ < __w_rt - 1)
-            __sp <<= __w0_ + 1;
-        else
-            __sp = 0;
-        __sp += __u & __mask1_;
-    }
-    return __sp;
-}
-
-template<class _IntType = int>
-class uniform_int_distribution
-{
-    static_assert(__libcpp_random_is_valid_inttype<_IntType>::value, "IntType must be a supported integer type");
 public:
-    // types
-    typedef _IntType result_type;
+  // types
+  typedef _IntType result_type;
 
-    class param_type
-    {
-        result_type __a_;
-        result_type __b_;
-    public:
-        typedef uniform_int_distribution distribution_type;
+  class param_type {
+    result_type __a_;
+    result_type __b_;
 
-        _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 0,
-                            result_type __b = numeric_limits<result_type>::max())
-            : __a_(__a), __b_(__b) {}
+  public:
+    typedef uniform_int_distribution distribution_type;
 
-        _LIBCPP_HIDE_FROM_ABI result_type a() const {return __a_;}
-        _LIBCPP_HIDE_FROM_ABI result_type b() const {return __b_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = numeric_limits<result_type>::max())
+        : __a_(__a), __b_(__b) {}
 
-        _LIBCPP_HIDE_FROM_ABI
-        friend bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
-        _LIBCPP_HIDE_FROM_ABI
-        friend bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type a() const { return __a_; }
+    _LIBCPP_HIDE_FROM_ABI result_type b() const { return __b_; }
+
+    _LIBCPP_HIDE_FROM_ABI friend bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;
+    }
+    _LIBCPP_HIDE_FROM_ABI friend bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructors and reset functions
+  // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI uniform_int_distribution() : uniform_int_distribution(0) {}
-    _LIBCPP_HIDE_FROM_ABI explicit uniform_int_distribution(
-        result_type __a, result_type __b = numeric_limits<result_type>::max())
-        : __p_(param_type(__a, __b)) {}
+  _LIBCPP_HIDE_FROM_ABI uniform_int_distribution() : uniform_int_distribution(0) {}
+  _LIBCPP_HIDE_FROM_ABI explicit uniform_int_distribution(
+      result_type __a, result_type __b = numeric_limits<result_type>::max())
+      : __p_(param_type(__a, __b)) {}
 #else
-    explicit uniform_int_distribution(
-        result_type __a = 0,
-        result_type __b = numeric_limits<result_type>::max())
-        : __p_(param_type(__a, __b)) {}
+  explicit uniform_int_distribution(result_type __a = 0, result_type __b = numeric_limits<result_type>::max())
+      : __p_(param_type(__a, __b)) {}
 #endif
-    _LIBCPP_HIDE_FROM_ABI explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_HIDE_FROM_ABI void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit uniform_int_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-    _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_HIDE_FROM_ABI result_type a() const {return __p_.a();}
-    _LIBCPP_HIDE_FROM_ABI result_type b() const {return __p_.b();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type a() const { return __p_.a(); }
+  _LIBCPP_HIDE_FROM_ABI result_type b() const { return __p_.b(); }
 
-    _LIBCPP_HIDE_FROM_ABI param_type param() const {return __p_;}
-    _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_HIDE_FROM_ABI result_type min() const {return a();}
-    _LIBCPP_HIDE_FROM_ABI result_type max() const {return b();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return a(); }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return b(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend bool operator==(const uniform_int_distribution& __x,
-                           const uniform_int_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    _LIBCPP_HIDE_FROM_ABI
-    friend bool operator!=(const uniform_int_distribution& __x,
-                           const uniform_int_distribution& __y)
-            {return !(__x == __y);}
+  _LIBCPP_HIDE_FROM_ABI friend bool
+  operator==(const uniform_int_distribution& __x, const uniform_int_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  _LIBCPP_HIDE_FROM_ABI friend bool
+  operator!=(const uniform_int_distribution& __x, const uniform_int_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
-template<class _IntType>
-template<class _URNG>
-typename uniform_int_distribution<_IntType>::result_type
-uniform_int_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
-_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    typedef __conditional_t<sizeof(result_type) <= sizeof(uint32_t), uint32_t, __make_unsigned_t<result_type> >
-        _UIntType;
-    const _UIntType __rp = _UIntType(__p.b()) - _UIntType(__p.a()) + _UIntType(1);
-    if (__rp == 1)
-        return __p.a();
-    const size_t __dt = numeric_limits<_UIntType>::digits;
-    typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
-    if (__rp == 0)
-        return static_cast<result_type>(_Eng(__g, __dt)());
-    size_t __w = __dt - std::__countl_zero(__rp) - 1;
-    if ((__rp & (numeric_limits<_UIntType>::max() >> (__dt - __w))) != 0)
-        ++__w;
-    _Eng __e(__g, __w);
-    _UIntType __u;
-    do
-    {
-        __u = __e();
-    } while (__u >= __rp);
-    return static_cast<result_type>(__u + __p.a());
+template <class _IntType>
+template <class _URNG>
+typename uniform_int_distribution<_IntType>::result_type uniform_int_distribution<_IntType>::operator()(
+    _URNG& __g, const param_type& __p) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  typedef __conditional_t<sizeof(result_type) <= sizeof(uint32_t), uint32_t, __make_unsigned_t<result_type> > _UIntType;
+  const _UIntType __rp = _UIntType(__p.b()) - _UIntType(__p.a()) + _UIntType(1);
+  if (__rp == 1)
+    return __p.a();
+  const size_t __dt = numeric_limits<_UIntType>::digits;
+  typedef __independent_bits_engine<_URNG, _UIntType> _Eng;
+  if (__rp == 0)
+    return static_cast<result_type>(_Eng(__g, __dt)());
+  size_t __w = __dt - std::__countl_zero(__rp) - 1;
+  if ((__rp & (numeric_limits<_UIntType>::max() >> (__dt - __w))) != 0)
+    ++__w;
+  _Eng __e(__g, __w);
+  _UIntType __u;
+  do {
+    __u = __e();
+  } while (__u >= __rp);
+  return static_cast<result_type>(__u + __p.a());
 }
 
 template <class _CharT, class _Traits, class _IT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const uniform_int_distribution<_IT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _Ostream;
-    __os.flags(_Ostream::dec | _Ostream::left);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.a() << __sp << __x.b();
+operator<<(basic_ostream<_CharT, _Traits>& __os, const uniform_int_distribution<_IT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _Ostream;
+  __os.flags(_Ostream::dec | _Ostream::left);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  return __os << __x.a() << __sp << __x.b();
 }
 
 template <class _CharT, class _Traits, class _IT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           uniform_int_distribution<_IT>& __x)
-{
-    typedef uniform_int_distribution<_IT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __a;
-    result_type __b;
-    __is >> __a >> __b;
-    if (!__is.fail())
-        __x.param(param_type(__a, __b));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, uniform_int_distribution<_IT>& __x) {
+  typedef uniform_int_distribution<_IT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __a;
+  result_type __b;
+  __is >> __a >> __b;
+  if (!__is.fail())
+    __x.param(param_type(__a, __b));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/uniform_random_bit_generator.h b/third_party/libcxx/__random/uniform_random_bit_generator.h
index ddb3158ee..4076f19b2 100644
--- a/third_party/libcxx/__random/uniform_random_bit_generator.h
+++ b/third_party/libcxx/__random/uniform_random_bit_generator.h
@@ -28,14 +28,12 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 // [rand.req.urng]
-template<class _Gen>
-concept uniform_random_bit_generator =
-  invocable<_Gen&> && unsigned_integral<invoke_result_t<_Gen&>> &&
-  requires {
-    { _Gen::min() } -> same_as<invoke_result_t<_Gen&>>;
-    { _Gen::max() } -> same_as<invoke_result_t<_Gen&>>;
-    requires bool_constant<(_Gen::min() < _Gen::max())>::value;
-  };
+template <class _Gen>
+concept uniform_random_bit_generator = invocable<_Gen&> && unsigned_integral<invoke_result_t<_Gen&>> && requires {
+  { _Gen::min() } -> same_as<invoke_result_t<_Gen&>>;
+  { _Gen::max() } -> same_as<invoke_result_t<_Gen&>>;
+  requires bool_constant<(_Gen::min() < _Gen::max())>::value;
+};
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__random/uniform_real_distribution.h b/third_party/libcxx/__random/uniform_real_distribution.h
index 1388cef95..250cb8bab 100644
--- a/third_party/libcxx/__random/uniform_real_distribution.h
+++ b/third_party/libcxx/__random/uniform_real_distribution.h
@@ -24,134 +24,111 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS uniform_real_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS uniform_real_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __a_;
-        result_type __b_;
-    public:
-        typedef uniform_real_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __a_;
+    result_type __b_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __a = 0,
-                            result_type __b = 1)
-            : __a_(__a), __b_(__b) {}
+  public:
+    typedef uniform_real_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type a() const {return __a_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type b() const {return __b_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 0, result_type __b = 1) : __a_(__a), __b_(__b) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type a() const { return __a_; }
+    _LIBCPP_HIDE_FROM_ABI result_type b() const { return __b_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructors and reset functions
+  // constructors and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    uniform_real_distribution() : uniform_real_distribution(0) {}
-    _LIBCPP_HIDE_FROM_ABI explicit uniform_real_distribution(result_type __a, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
+  _LIBCPP_HIDE_FROM_ABI uniform_real_distribution() : uniform_real_distribution(0) {}
+  _LIBCPP_HIDE_FROM_ABI explicit uniform_real_distribution(result_type __a, result_type __b = 1)
+      : __p_(param_type(__a, __b)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
+      : __p_(param_type(__a, __b)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p);
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type a() const {return __p_.a();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type b() const {return __p_.b();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type a() const { return __p_.a(); }
+  _LIBCPP_HIDE_FROM_ABI result_type b() const { return __p_.b(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return a();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return b();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return a(); }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return b(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const uniform_real_distribution& __x,
-                        const uniform_real_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const uniform_real_distribution& __x,
-                        const uniform_real_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const uniform_real_distribution& __x, const uniform_real_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const uniform_real_distribution& __x, const uniform_real_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
-template<class _RealType>
-template<class _URNG>
-inline
-typename uniform_real_distribution<_RealType>::result_type
-uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
-{
-    static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
-    return (__p.b() - __p.a())
-        * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
-        + __p.a();
+template <class _RealType>
+template <class _URNG>
+inline typename uniform_real_distribution<_RealType>::result_type
+uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p) {
+  static_assert(__libcpp_random_is_valid_urng<_URNG>::value, "");
+  return (__p.b() - __p.a()) * std::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g) + __p.a();
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const uniform_real_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    return __os << __x.a() << __sp << __x.b();
+operator<<(basic_ostream<_CharT, _Traits>& __os, const uniform_real_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  return __os << __x.a() << __sp << __x.b();
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           uniform_real_distribution<_RT>& __x)
-{
-    typedef uniform_real_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __a;
-    result_type __b;
-    __is >> __a >> __b;
-    if (!__is.fail())
-        __x.param(param_type(__a, __b));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, uniform_real_distribution<_RT>& __x) {
+  typedef uniform_real_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __a;
+  result_type __b;
+  __is >> __a >> __b;
+  if (!__is.fail())
+    __x.param(param_type(__a, __b));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__random/weibull_distribution.h b/third_party/libcxx/__random/weibull_distribution.h
index df834e655..aa3d63c8e 100644
--- a/third_party/libcxx/__random/weibull_distribution.h
+++ b/third_party/libcxx/__random/weibull_distribution.h
@@ -11,6 +11,7 @@
 
 #include <__config>
 #include <__random/exponential_distribution.h>
+#include <__random/is_valid.h>
 #include <cmath>
 #include <iosfwd>
 #include <limits>
@@ -24,128 +25,104 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _RealType = double>
-class _LIBCPP_TEMPLATE_VIS weibull_distribution
-{
+template <class _RealType = double>
+class _LIBCPP_TEMPLATE_VIS weibull_distribution {
+  static_assert(__libcpp_random_is_valid_realtype<_RealType>::value,
+                "RealType must be a supported floating-point type");
+
 public:
-    // types
-    typedef _RealType result_type;
+  // types
+  typedef _RealType result_type;
 
-    class _LIBCPP_TEMPLATE_VIS param_type
-    {
-        result_type __a_;
-        result_type __b_;
-    public:
-        typedef weibull_distribution distribution_type;
+  class _LIBCPP_TEMPLATE_VIS param_type {
+    result_type __a_;
+    result_type __b_;
 
-        _LIBCPP_INLINE_VISIBILITY
-        explicit param_type(result_type __a = 1, result_type __b = 1)
-            : __a_(__a), __b_(__b) {}
+  public:
+    typedef weibull_distribution distribution_type;
 
-        _LIBCPP_INLINE_VISIBILITY
-        result_type a() const {return __a_;}
-        _LIBCPP_INLINE_VISIBILITY
-        result_type b() const {return __b_;}
+    _LIBCPP_HIDE_FROM_ABI explicit param_type(result_type __a = 1, result_type __b = 1) : __a_(__a), __b_(__b) {}
 
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator==(const param_type& __x, const param_type& __y)
-            {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
-        friend _LIBCPP_INLINE_VISIBILITY
-            bool operator!=(const param_type& __x, const param_type& __y)
-            {return !(__x == __y);}
-    };
+    _LIBCPP_HIDE_FROM_ABI result_type a() const { return __a_; }
+    _LIBCPP_HIDE_FROM_ABI result_type b() const { return __b_; }
+
+    friend _LIBCPP_HIDE_FROM_ABI bool operator==(const param_type& __x, const param_type& __y) {
+      return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;
+    }
+    friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const param_type& __x, const param_type& __y) { return !(__x == __y); }
+  };
 
 private:
-    param_type __p_;
+  param_type __p_;
 
 public:
-    // constructor and reset functions
+  // constructor and reset functions
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    weibull_distribution() : weibull_distribution(1) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit weibull_distribution(result_type __a, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
+  _LIBCPP_HIDE_FROM_ABI weibull_distribution() : weibull_distribution(1) {}
+  _LIBCPP_HIDE_FROM_ABI explicit weibull_distribution(result_type __a, result_type __b = 1)
+      : __p_(param_type(__a, __b)) {}
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
-        : __p_(param_type(__a, __b)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
+      : __p_(param_type(__a, __b)) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit weibull_distribution(const param_type& __p)
-        : __p_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void reset() {}
+  _LIBCPP_HIDE_FROM_ABI explicit weibull_distribution(const param_type& __p) : __p_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI void reset() {}
 
-    // generating functions
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g)
-        {return (*this)(__g, __p_);}
-    template<class _URNG>
-        _LIBCPP_INLINE_VISIBILITY
-        result_type operator()(_URNG& __g, const param_type& __p)
-        {return __p.b() *
-            _VSTD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
+  // generating functions
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g) {
+    return (*this)(__g, __p_);
+  }
+  template <class _URNG>
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(_URNG& __g, const param_type& __p) {
+    return __p.b() * std::pow(exponential_distribution<result_type>()(__g), 1 / __p.a());
+  }
 
-    // property functions
-    _LIBCPP_INLINE_VISIBILITY
-    result_type a() const {return __p_.a();}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type b() const {return __p_.b();}
+  // property functions
+  _LIBCPP_HIDE_FROM_ABI result_type a() const { return __p_.a(); }
+  _LIBCPP_HIDE_FROM_ABI result_type b() const { return __p_.b(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    param_type param() const {return __p_;}
-    _LIBCPP_INLINE_VISIBILITY
-    void param(const param_type& __p) {__p_ = __p;}
+  _LIBCPP_HIDE_FROM_ABI param_type param() const { return __p_; }
+  _LIBCPP_HIDE_FROM_ABI void param(const param_type& __p) { __p_ = __p; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    result_type min() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    result_type max() const {return numeric_limits<result_type>::infinity();}
+  _LIBCPP_HIDE_FROM_ABI result_type min() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI result_type max() const { return numeric_limits<result_type>::infinity(); }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const weibull_distribution& __x,
-                        const weibull_distribution& __y)
-        {return __x.__p_ == __y.__p_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const weibull_distribution& __x,
-                        const weibull_distribution& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const weibull_distribution& __x, const weibull_distribution& __y) {
+    return __x.__p_ == __y.__p_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const weibull_distribution& __x, const weibull_distribution& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const weibull_distribution<_RT>& __x)
-{
-    __save_flags<_CharT, _Traits> __lx(__os);
-    typedef basic_ostream<_CharT, _Traits> _OStream;
-    __os.flags(_OStream::dec | _OStream::left | _OStream::fixed |
-               _OStream::scientific);
-    _CharT __sp = __os.widen(' ');
-    __os.fill(__sp);
-    __os << __x.a() << __sp << __x.b();
-    return __os;
+operator<<(basic_ostream<_CharT, _Traits>& __os, const weibull_distribution<_RT>& __x) {
+  __save_flags<_CharT, _Traits> __lx(__os);
+  typedef basic_ostream<_CharT, _Traits> _OStream;
+  __os.flags(_OStream::dec | _OStream::left | _OStream::fixed | _OStream::scientific);
+  _CharT __sp = __os.widen(' ');
+  __os.fill(__sp);
+  __os << __x.a() << __sp << __x.b();
+  return __os;
 }
 
 template <class _CharT, class _Traits, class _RT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           weibull_distribution<_RT>& __x)
-{
-    typedef weibull_distribution<_RT> _Eng;
-    typedef typename _Eng::result_type result_type;
-    typedef typename _Eng::param_type param_type;
-    __save_flags<_CharT, _Traits> __lx(__is);
-    typedef basic_istream<_CharT, _Traits> _Istream;
-    __is.flags(_Istream::dec | _Istream::skipws);
-    result_type __a;
-    result_type __b;
-    __is >> __a >> __b;
-    if (!__is.fail())
-        __x.param(param_type(__a, __b));
-    return __is;
+operator>>(basic_istream<_CharT, _Traits>& __is, weibull_distribution<_RT>& __x) {
+  typedef weibull_distribution<_RT> _Eng;
+  typedef typename _Eng::result_type result_type;
+  typedef typename _Eng::param_type param_type;
+  __save_flags<_CharT, _Traits> __lx(__is);
+  typedef basic_istream<_CharT, _Traits> _Istream;
+  __is.flags(_Istream::dec | _Istream::skipws);
+  result_type __a;
+  result_type __b;
+  __is >> __a >> __b;
+  if (!__is.fail())
+    __x.param(param_type(__a, __b));
+  return __is;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__ranges/access.h b/third_party/libcxx/__ranges/access.h
index 502bd5e95..c0a40c5e1 100644
--- a/third_party/libcxx/__ranges/access.h
+++ b/third_party/libcxx/__ranges/access.h
@@ -32,138 +32,119 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template <class _Tp>
-  concept __can_borrow =
-    is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp>>;
+template <class _Tp>
+concept __can_borrow = is_lvalue_reference_v<_Tp> || enable_borrowed_range<remove_cvref_t<_Tp>>;
 } // namespace ranges
 
 // [range.access.begin]
 
 namespace ranges {
 namespace __begin {
-  template <class _Tp>
-  concept __member_begin =
-    __can_borrow<_Tp> &&
-    __workaround_52970<_Tp> &&
-    requires(_Tp&& __t) {
-      { _LIBCPP_AUTO_CAST(__t.begin()) } -> input_or_output_iterator;
-    };
+template <class _Tp>
+concept __member_begin = __can_borrow<_Tp> && requires(_Tp&& __t) {
+  { _LIBCPP_AUTO_CAST(__t.begin()) } -> input_or_output_iterator;
+};
 
-  void begin(auto&) = delete;
-  void begin(const auto&) = delete;
+void begin() = delete;
 
-  template <class _Tp>
-  concept __unqualified_begin =
-    !__member_begin<_Tp> &&
-    __can_borrow<_Tp> &&
-    __class_or_enum<remove_cvref_t<_Tp>> &&
-    requires(_Tp && __t) {
+template <class _Tp>
+concept __unqualified_begin =
+    !__member_begin<_Tp> && __can_borrow<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
       { _LIBCPP_AUTO_CAST(begin(__t)) } -> input_or_output_iterator;
     };
 
-  struct __fn {
-    template <class _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[]) const noexcept
-      requires (sizeof(_Tp) >= 0)  // Disallow incomplete element types.
-    {
-      return __t + 0;
-    }
+struct __fn {
+  template <class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[]) const noexcept
+    requires(sizeof(_Tp) >= 0) // Disallow incomplete element types.
+  {
+    return __t + 0;
+  }
 
-    template <class _Tp, size_t _Np>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
-      requires (sizeof(_Tp) >= 0)  // Disallow incomplete element types.
-    {
-      return __t + 0;
-    }
+  template <class _Tp, size_t _Np>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
+    requires(sizeof(_Tp) >= 0) // Disallow incomplete element types.
+  {
+    return __t + 0;
+  }
 
-    template <class _Tp>
-      requires __member_begin<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.begin())))
-    {
-      return _LIBCPP_AUTO_CAST(__t.begin());
-    }
+  template <class _Tp>
+    requires __member_begin<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.begin()))) {
+    return _LIBCPP_AUTO_CAST(__t.begin());
+  }
 
-    template <class _Tp>
-      requires __unqualified_begin<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(_LIBCPP_AUTO_CAST(begin(__t))))
-    {
-      return _LIBCPP_AUTO_CAST(begin(__t));
-    }
+  template <class _Tp>
+    requires __unqualified_begin<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(begin(__t)))) {
+    return _LIBCPP_AUTO_CAST(begin(__t));
+  }
 
-    void operator()(auto&&) const = delete;
-  };
+  void operator()(auto&&) const = delete;
+};
 } // namespace __begin
 
 inline namespace __cpo {
-  inline constexpr auto begin = __begin::__fn{};
+inline constexpr auto begin = __begin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
 // [range.range]
 
 namespace ranges {
-  template <class _Tp>
-  using iterator_t = decltype(ranges::begin(std::declval<_Tp&>()));
+template <class _Tp>
+using iterator_t = decltype(ranges::begin(std::declval<_Tp&>()));
 } // namespace ranges
 
 // [range.access.end]
 
 namespace ranges {
 namespace __end {
-  template <class _Tp>
-  concept __member_end =
-    __can_borrow<_Tp> &&
-    __workaround_52970<_Tp> &&
-    requires(_Tp&& __t) {
-      typename iterator_t<_Tp>;
-      { _LIBCPP_AUTO_CAST(__t.end()) } -> sentinel_for<iterator_t<_Tp>>;
-    };
+template <class _Tp>
+concept __member_end = __can_borrow<_Tp> && requires(_Tp&& __t) {
+  typename iterator_t<_Tp>;
+  { _LIBCPP_AUTO_CAST(__t.end()) } -> sentinel_for<iterator_t<_Tp>>;
+};
 
-  void end(auto&) = delete;
-  void end(const auto&) = delete;
+void end() = delete;
 
-  template <class _Tp>
-  concept __unqualified_end =
-    !__member_end<_Tp> &&
-    __can_borrow<_Tp> &&
-    __class_or_enum<remove_cvref_t<_Tp>> &&
-    requires(_Tp && __t) {
+template <class _Tp>
+concept __unqualified_end =
+    !__member_end<_Tp> && __can_borrow<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
       typename iterator_t<_Tp>;
       { _LIBCPP_AUTO_CAST(end(__t)) } -> sentinel_for<iterator_t<_Tp>>;
     };
 
-  struct __fn {
-    template <class _Tp, size_t _Np>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
-      requires (sizeof(_Tp) >= 0)  // Disallow incomplete element types.
-    {
-      return __t + _Np;
-    }
+struct __fn {
+  template <class _Tp, size_t _Np>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp (&__t)[_Np]) const noexcept
+    requires(sizeof(_Tp) >= 0) // Disallow incomplete element types.
+  {
+    return __t + _Np;
+  }
 
-    template <class _Tp>
-      requires __member_end<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.end())))
-    {
-      return _LIBCPP_AUTO_CAST(__t.end());
-    }
+  template <class _Tp>
+    requires __member_end<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.end()))) {
+    return _LIBCPP_AUTO_CAST(__t.end());
+  }
 
-    template <class _Tp>
-      requires __unqualified_end<_Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(_LIBCPP_AUTO_CAST(end(__t))))
-    {
-      return _LIBCPP_AUTO_CAST(end(__t));
-    }
+  template <class _Tp>
+    requires __unqualified_end<_Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(end(__t)))) {
+    return _LIBCPP_AUTO_CAST(end(__t));
+  }
 
-    void operator()(auto&&) const = delete;
-  };
+  void operator()(auto&&) const = delete;
+};
 } // namespace __end
 
 inline namespace __cpo {
-  inline constexpr auto end = __end::__fn{};
+inline constexpr auto end = __end::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -171,27 +152,27 @@ inline namespace __cpo {
 
 namespace ranges {
 namespace __cbegin {
-  struct __fn {
-    template <class _Tp>
-      requires is_lvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+struct __fn {
+  template <class _Tp>
+    requires is_lvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t))))
-      -> decltype(      ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t)))
-      { return          ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+          -> decltype(ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t))) {
+    return ranges::begin(static_cast<const remove_reference_t<_Tp>&>(__t));
+  }
 
-    template <class _Tp>
-      requires is_rvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+  template <class _Tp>
+    requires is_rvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::begin(static_cast<const _Tp&&>(__t))))
-      -> decltype(      ranges::begin(static_cast<const _Tp&&>(__t)))
-      { return          ranges::begin(static_cast<const _Tp&&>(__t)); }
-  };
+          -> decltype(ranges::begin(static_cast<const _Tp&&>(__t))) {
+    return ranges::begin(static_cast<const _Tp&&>(__t));
+  }
+};
 } // namespace __cbegin
 
 inline namespace __cpo {
-  inline constexpr auto cbegin = __cbegin::__fn{};
+inline constexpr auto cbegin = __cbegin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -199,27 +180,26 @@ inline namespace __cpo {
 
 namespace ranges {
 namespace __cend {
-  struct __fn {
-    template <class _Tp>
-      requires is_lvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+struct __fn {
+  template <class _Tp>
+    requires is_lvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t))))
-      -> decltype(      ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t)))
-      { return          ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+          -> decltype(ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t))) {
+    return ranges::end(static_cast<const remove_reference_t<_Tp>&>(__t));
+  }
 
-    template <class _Tp>
-      requires is_rvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(ranges::end(static_cast<const _Tp&&>(__t))))
-      -> decltype(      ranges::end(static_cast<const _Tp&&>(__t)))
-      { return          ranges::end(static_cast<const _Tp&&>(__t)); }
-  };
+  template <class _Tp>
+    requires is_rvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const noexcept(
+      noexcept(ranges::end(static_cast<const _Tp&&>(__t)))) -> decltype(ranges::end(static_cast<const _Tp&&>(__t))) {
+    return ranges::end(static_cast<const _Tp&&>(__t));
+  }
+};
 } // namespace __cend
 
 inline namespace __cpo {
-  inline constexpr auto cend = __cend::__fn{};
+inline constexpr auto cend = __cend::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__ranges/all.h b/third_party/libcxx/__ranges/all.h
index ecf908df1..023cee6ca 100644
--- a/third_party/libcxx/__ranges/all.h
+++ b/third_party/libcxx/__ranges/all.h
@@ -11,6 +11,8 @@
 #define _LIBCPP___RANGES_ALL_H
 
 #include <__config>
+#include <__functional/compose.h>         // TODO(modules): Those should not be required
+#include <__functional/perfect_forward.h> //
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
@@ -34,45 +36,37 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges::views {
 
 namespace __all {
-  struct __fn : __range_adaptor_closure<__fn> {
-    template<class _Tp>
-      requires ranges::view<decay_t<_Tp>>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Tp>(__t))))
-      -> decltype(_LIBCPP_AUTO_CAST(std::forward<_Tp>(__t)))
-    {
-      return _LIBCPP_AUTO_CAST(std::forward<_Tp>(__t));
-    }
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Tp>
+    requires ranges::view<decay_t<_Tp>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const noexcept(
+      noexcept(_LIBCPP_AUTO_CAST(std::forward<_Tp>(__t)))) -> decltype(_LIBCPP_AUTO_CAST(std::forward<_Tp>(__t))) {
+    return _LIBCPP_AUTO_CAST(std::forward<_Tp>(__t));
+  }
 
-    template<class _Tp>
-      requires (!ranges::view<decay_t<_Tp>>) &&
-               requires (_Tp&& __t) { ranges::ref_view{std::forward<_Tp>(__t)}; }
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(ranges::ref_view{std::forward<_Tp>(__t)}))
-    {
-      return ranges::ref_view{std::forward<_Tp>(__t)};
-    }
+  template <class _Tp>
+    requires(!ranges::view<decay_t<_Tp>>) && requires(_Tp&& __t) { ranges::ref_view{std::forward<_Tp>(__t)}; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::ref_view{std::forward<_Tp>(__t)})) {
+    return ranges::ref_view{std::forward<_Tp>(__t)};
+  }
 
-    template<class _Tp>
-      requires (!ranges::view<decay_t<_Tp>> &&
-                !requires (_Tp&& __t) { ranges::ref_view{std::forward<_Tp>(__t)}; } &&
-                 requires (_Tp&& __t) { ranges::owning_view{std::forward<_Tp>(__t)}; })
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(ranges::owning_view{std::forward<_Tp>(__t)}))
-    {
-      return ranges::owning_view{std::forward<_Tp>(__t)};
-    }
-  };
+  template <class _Tp>
+    requires(
+        !ranges::view<decay_t<_Tp>> && !requires(_Tp&& __t) { ranges::ref_view{std::forward<_Tp>(__t)}; } &&
+        requires(_Tp&& __t) { ranges::owning_view{std::forward<_Tp>(__t)}; })
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::owning_view{std::forward<_Tp>(__t)})) {
+    return ranges::owning_view{std::forward<_Tp>(__t)};
+  }
+};
 } // namespace __all
 
 inline namespace __cpo {
-  inline constexpr auto all = __all::__fn{};
+inline constexpr auto all = __all::__fn{};
 } // namespace __cpo
 
-template<ranges::viewable_range _Range>
+template <ranges::viewable_range _Range>
 using all_t = decltype(views::all(std::declval<_Range>()));
 
 } // namespace ranges::views
diff --git a/third_party/libcxx/__ranges/as_rvalue_view.h b/third_party/libcxx/__ranges/as_rvalue_view.h
index c4b1a51b5..5849a6c36 100644
--- a/third_party/libcxx/__ranges/as_rvalue_view.h
+++ b/third_party/libcxx/__ranges/as_rvalue_view.h
@@ -28,6 +28,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 23
 
 _LIBCPP_BEGIN_NAMESPACE_STD
@@ -108,18 +111,18 @@ namespace views {
 namespace __as_rvalue {
 struct __fn : __range_adaptor_closure<__fn> {
   template <class _Range>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
-      noexcept(noexcept(/**/ as_rvalue_view(std::forward<_Range>(__range))))
-          -> decltype(/*--*/ as_rvalue_view(std::forward<_Range>(__range))) {
-    return /*-------------*/ as_rvalue_view(std::forward<_Range>(__range));
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  operator()(_Range&& __range) noexcept(noexcept(as_rvalue_view(std::forward<_Range>(__range))))
+      -> decltype(/*--------------------------*/ as_rvalue_view(std::forward<_Range>(__range))) {
+    return /*---------------------------------*/ as_rvalue_view(std::forward<_Range>(__range));
   }
 
   template <class _Range>
     requires same_as<range_rvalue_reference_t<_Range>, range_reference_t<_Range>>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
-      noexcept(noexcept(/**/ views::all(std::forward<_Range>(__range))))
-          -> decltype(/*--*/ views::all(std::forward<_Range>(__range))) {
-    return /*-------------*/ views::all(std::forward<_Range>(__range));
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  operator()(_Range&& __range) noexcept(noexcept(views::all(std::forward<_Range>(__range))))
+      -> decltype(/*--------------------------*/ views::all(std::forward<_Range>(__range))) {
+    return /*---------------------------------*/ views::all(std::forward<_Range>(__range));
   }
 };
 } // namespace __as_rvalue
@@ -134,4 +137,6 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 23
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_AS_RVALUE_H
diff --git a/third_party/libcxx/__ranges/chunk_by_view.h b/third_party/libcxx/__ranges/chunk_by_view.h
new file mode 100644
index 000000000..00014d9f1
--- /dev/null
+++ b/third_party/libcxx/__ranges/chunk_by_view.h
@@ -0,0 +1,235 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_CHUNK_BY_VIEW_H
+#define _LIBCPP___RANGES_CHUNK_BY_VIEW_H
+
+#include <__algorithm/ranges_adjacent_find.h>
+#include <__assert>
+#include <__concepts/constructible.h>
+#include <__config>
+#include <__functional/bind_back.h>
+#include <__functional/invoke.h>
+#include <__iterator/concepts.h>
+#include <__iterator/default_sentinel.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/next.h>
+#include <__iterator/prev.h>
+#include <__memory/addressof.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/movable_box.h>
+#include <__ranges/non_propagating_cache.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/reverse_view.h>
+#include <__ranges/subrange.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_object.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+
+template <forward_range _View, indirect_binary_predicate<iterator_t<_View>, iterator_t<_View>> _Pred>
+  requires view<_View> && is_object_v<_Pred>
+class _LIBCPP_ABI_LLVM18_NO_UNIQUE_ADDRESS chunk_by_view : public view_interface<chunk_by_view<_View, _Pred>> {
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
+
+  // We cache the result of begin() to allow providing an amortized O(1).
+  using _Cache = __non_propagating_cache<iterator_t<_View>>;
+  _Cache __cached_begin_;
+
+  class __iterator;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> __find_next(iterator_t<_View> __current) {
+    // Note: this duplicates a check in `optional` but provides a better error message.
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __pred_.__has_value(), "Trying to call __find_next() on a chunk_by_view that does not have a valid predicate.");
+    auto __reversed_pred = [this]<class _Tp, class _Up>(_Tp&& __x, _Up&& __y) -> bool {
+      return !std::invoke(*__pred_, std::forward<_Tp>(__x), std::forward<_Up>(__y));
+    };
+    return ranges::next(
+        ranges::adjacent_find(__current, ranges::end(__base_), __reversed_pred), 1, ranges::end(__base_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> __find_prev(iterator_t<_View> __current)
+    requires bidirectional_range<_View>
+  {
+    // Attempting to decrement a begin iterator is a no-op (`__find_prev` would return the same argument given to it).
+    _LIBCPP_ASSERT_PEDANTIC(__current != ranges::begin(__base_), "Trying to call __find_prev() on a begin iterator.");
+    // Note: this duplicates a check in `optional` but provides a better error message.
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __pred_.__has_value(), "Trying to call __find_prev() on a chunk_by_view that does not have a valid predicate.");
+
+    auto __first = ranges::begin(__base_);
+    reverse_view __reversed{subrange{__first, __current}};
+    auto __reversed_pred = [this]<class _Tp, class _Up>(_Tp&& __x, _Up&& __y) -> bool {
+      return !std::invoke(*__pred_, std::forward<_Up>(__y), std::forward<_Tp>(__x));
+    };
+    return ranges::prev(ranges::adjacent_find(__reversed, __reversed_pred).base(), 1, std::move(__first));
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI chunk_by_view()
+    requires default_initializable<_View> && default_initializable<_Pred>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit chunk_by_view(_View __base, _Pred __pred)
+      : __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Pred& pred() const { return *__pred_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() {
+    // Note: this duplicates a check in `optional` but provides a better error message.
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __pred_.__has_value(), "Trying to call begin() on a chunk_by_view that does not have a valid predicate.");
+
+    auto __first = ranges::begin(__base_);
+    if (!__cached_begin_.__has_value()) {
+      __cached_begin_.__emplace(__find_next(__first));
+    }
+    return {*this, std::move(__first), *__cached_begin_};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
+    if constexpr (common_range<_View>) {
+      return __iterator{*this, ranges::end(__base_), ranges::end(__base_)};
+    } else {
+      return default_sentinel;
+    }
+  }
+};
+
+template <class _Range, class _Pred>
+chunk_by_view(_Range&&, _Pred) -> chunk_by_view<views::all_t<_Range>, _Pred>;
+
+template <forward_range _View, indirect_binary_predicate<iterator_t<_View>, iterator_t<_View>> _Pred>
+  requires view<_View> && is_object_v<_Pred>
+class chunk_by_view<_View, _Pred>::__iterator {
+  friend chunk_by_view;
+
+  chunk_by_view* __parent_                               = nullptr;
+  _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __current_ = iterator_t<_View>();
+  _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __next_    = iterator_t<_View>();
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(
+      chunk_by_view& __parent, iterator_t<_View> __current, iterator_t<_View> __next)
+      : __parent_(std::addressof(__parent)), __current_(__current), __next_(__next) {}
+
+public:
+  using value_type        = subrange<iterator_t<_View>>;
+  using difference_type   = range_difference_t<_View>;
+  using iterator_category = input_iterator_tag;
+  using iterator_concept  = conditional_t<bidirectional_range<_View>, bidirectional_iterator_tag, forward_iterator_tag>;
+
+  _LIBCPP_HIDE_FROM_ABI __iterator() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type operator*() const {
+    // If the iterator is at end, this would return an empty range which can be checked by the calling code and doesn't
+    // necessarily lead to a bad access.
+    _LIBCPP_ASSERT_PEDANTIC(__current_ != __next_, "Trying to dereference past-the-end chunk_by_view iterator.");
+    return {__current_, __next_};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    // Attempting to increment an end iterator is a no-op (`__find_next` would return the same argument given to it).
+    _LIBCPP_ASSERT_PEDANTIC(__current_ != __next_, "Trying to increment past end chunk_by_view iterator.");
+    __current_ = __next_;
+    __next_    = __parent_->__find_next(__current_);
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int) {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires bidirectional_range<_View>
+  {
+    __next_    = __current_;
+    __current_ = __parent_->__find_prev(__next_);
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires bidirectional_range<_View>
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) {
+    return __x.__current_ == __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, default_sentinel_t) {
+    return __x.__current_ == __x.__next_;
+  }
+};
+
+namespace views {
+namespace __chunk_by {
+struct __fn {
+  template <class _Range, class _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Pred&& __pred) const
+      noexcept(noexcept(/**/ chunk_by_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred))))
+          -> decltype(/*--*/ chunk_by_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred))) {
+    return /*-------------*/ chunk_by_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred));
+  }
+
+  template <class _Pred>
+    requires constructible_from<decay_t<_Pred>, _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pred&& __pred) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Pred>, _Pred>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pred>(__pred)));
+  }
+};
+} // namespace __chunk_by
+
+inline namespace __cpo {
+inline constexpr auto chunk_by = __chunk_by::__fn{};
+} // namespace __cpo
+} // namespace views
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_CHUNK_BY_VIEW_H
diff --git a/third_party/libcxx/__ranges/common_view.h b/third_party/libcxx/__ranges/common_view.h
index 8fc68bada..133236dd1 100644
--- a/third_party/libcxx/__ranges/common_view.h
+++ b/third_party/libcxx/__ranges/common_view.h
@@ -29,102 +29,106 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
 
-template<view _View>
-  requires (!common_range<_View> && copyable<iterator_t<_View>>)
+template <view _View>
+  requires(!common_range<_View> && copyable<iterator_t<_View>>)
 class common_view : public view_interface<common_view<_View>> {
   _View __base_ = _View();
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  common_view() requires default_initializable<_View> = default;
+  _LIBCPP_HIDE_FROM_ABI common_view()
+    requires default_initializable<_View>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit common_view(_View __v) : __base_(std::move(__v)) { }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit common_view(_View __v) : __base_(std::move(__v)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() && { return std::move(__base_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() {
     if constexpr (random_access_range<_View> && sized_range<_View>)
       return ranges::begin(__base_);
     else
       return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::begin(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() const requires range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _View>
+  {
     if constexpr (random_access_range<const _View> && sized_range<const _View>)
       return ranges::begin(__base_);
     else
       return common_iterator<iterator_t<const _View>, sentinel_t<const _View>>(ranges::begin(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
     if constexpr (random_access_range<_View> && sized_range<_View>)
       return ranges::begin(__base_) + ranges::size(__base_);
     else
       return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::end(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() const requires range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
     if constexpr (random_access_range<const _View> && sized_range<const _View>)
       return ranges::begin(__base_) + ranges::size(__base_);
     else
       return common_iterator<iterator_t<const _View>, sentinel_t<const _View>>(ranges::end(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() requires sized_range<_View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
     return ranges::size(__base_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() const requires sized_range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
     return ranges::size(__base_);
   }
 };
 
-template<class _Range>
-common_view(_Range&&)
-  -> common_view<views::all_t<_Range>>;
+template <class _Range>
+common_view(_Range&&) -> common_view<views::all_t<_Range>>;
 
-template<class _View>
+template <class _View>
 inline constexpr bool enable_borrowed_range<common_view<_View>> = enable_borrowed_range<_View>;
 
 namespace views {
 namespace __common {
-  struct __fn : __range_adaptor_closure<__fn> {
-    template<class _Range>
-      requires common_range<_Range>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Range&& __range) const
-      noexcept(noexcept(views::all(std::forward<_Range>(__range))))
-      -> decltype(      views::all(std::forward<_Range>(__range)))
-      { return          views::all(std::forward<_Range>(__range)); }
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Range>
+    requires common_range<_Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const noexcept(
+      noexcept(views::all(std::forward<_Range>(__range)))) -> decltype(views::all(std::forward<_Range>(__range))) {
+    return views::all(std::forward<_Range>(__range));
+  }
 
-    template<class _Range>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Range&& __range) const
-      noexcept(noexcept(common_view{std::forward<_Range>(__range)}))
-      -> decltype(      common_view{std::forward<_Range>(__range)})
-      { return          common_view{std::forward<_Range>(__range)}; }
-  };
+  template <class _Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const noexcept(noexcept(common_view{
+      std::forward<_Range>(__range)})) -> decltype(common_view{std::forward<_Range>(__range)}) {
+    return common_view{std::forward<_Range>(__range)};
+  }
+};
 } // namespace __common
 
 inline namespace __cpo {
-  inline constexpr auto common = __common::__fn{};
+inline constexpr auto common = __common::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
@@ -133,4 +137,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_COMMON_VIEW_H
diff --git a/third_party/libcxx/__ranges/concepts.h b/third_party/libcxx/__ranges/concepts.h
index b87a71460..674a3f359 100644
--- a/third_party/libcxx/__ranges/concepts.h
+++ b/third_party/libcxx/__ranges/concepts.h
@@ -41,100 +41,92 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-  // [range.range]
+// [range.range]
 
-  template <class _Tp>
-  concept range = requires(_Tp& __t) {
-    ranges::begin(__t); // sometimes equality-preserving
-    ranges::end(__t);
-  };
+template <class _Tp>
+concept range = requires(_Tp& __t) {
+  ranges::begin(__t); // sometimes equality-preserving
+  ranges::end(__t);
+};
 
-  template <class _Tp>
-  concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
+template <class _Tp>
+concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;
 
-  template<class _Range>
-  concept borrowed_range = range<_Range> &&
-    (is_lvalue_reference_v<_Range> || enable_borrowed_range<remove_cvref_t<_Range>>);
+template <class _Range>
+concept borrowed_range =
+    range<_Range> && (is_lvalue_reference_v<_Range> || enable_borrowed_range<remove_cvref_t<_Range>>);
 
-  // `iterator_t` defined in <__ranges/access.h>
+// `iterator_t` defined in <__ranges/access.h>
 
-  template <range _Rp>
-  using sentinel_t = decltype(ranges::end(std::declval<_Rp&>()));
+template <range _Rp>
+using sentinel_t = decltype(ranges::end(std::declval<_Rp&>()));
 
-  template <range _Rp>
-  using range_difference_t = iter_difference_t<iterator_t<_Rp>>;
+template <range _Rp>
+using range_difference_t = iter_difference_t<iterator_t<_Rp>>;
 
-  template <range _Rp>
-  using range_value_t = iter_value_t<iterator_t<_Rp>>;
+template <range _Rp>
+using range_value_t = iter_value_t<iterator_t<_Rp>>;
 
-  template <range _Rp>
-  using range_reference_t = iter_reference_t<iterator_t<_Rp>>;
+template <range _Rp>
+using range_reference_t = iter_reference_t<iterator_t<_Rp>>;
 
-  template <range _Rp>
-  using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<_Rp>>;
+template <range _Rp>
+using range_rvalue_reference_t = iter_rvalue_reference_t<iterator_t<_Rp>>;
 
-  template <range _Rp>
-  using range_common_reference_t = iter_common_reference_t<iterator_t<_Rp>>;
+template <range _Rp>
+using range_common_reference_t = iter_common_reference_t<iterator_t<_Rp>>;
 
-  // [range.sized]
-  template <class _Tp>
-  concept sized_range = range<_Tp> && requires(_Tp& __t) { ranges::size(__t); };
+// [range.sized]
+template <class _Tp>
+concept sized_range = range<_Tp> && requires(_Tp& __t) { ranges::size(__t); };
 
-  template<sized_range _Rp>
-  using range_size_t = decltype(ranges::size(std::declval<_Rp&>()));
+template <sized_range _Rp>
+using range_size_t = decltype(ranges::size(std::declval<_Rp&>()));
 
-  // `disable_sized_range` defined in `<__ranges/size.h>`
+// `disable_sized_range` defined in `<__ranges/size.h>`
 
-  // [range.view], views
+// [range.view], views
 
-  // `enable_view` defined in <__ranges/enable_view.h>
-  // `view_base` defined in <__ranges/enable_view.h>
+// `enable_view` defined in <__ranges/enable_view.h>
+// `view_base` defined in <__ranges/enable_view.h>
 
-  template <class _Tp>
-  concept view =
-    range<_Tp> &&
-    movable<_Tp> &&
-    enable_view<_Tp>;
+template <class _Tp>
+concept view = range<_Tp> && movable<_Tp> && enable_view<_Tp>;
 
-  template <class _Range>
-  concept __simple_view =
-    view<_Range> && range<const _Range> &&
-    same_as<iterator_t<_Range>, iterator_t<const _Range>> &&
+template <class _Range>
+concept __simple_view =
+    view<_Range> && range<const _Range> && same_as<iterator_t<_Range>, iterator_t<const _Range>> &&
     same_as<sentinel_t<_Range>, sentinel_t<const _Range>>;
 
-  // [range.refinements], other range refinements
-  template <class _Rp, class _Tp>
-  concept output_range = range<_Rp> && output_iterator<iterator_t<_Rp>, _Tp>;
+// [range.refinements], other range refinements
+template <class _Rp, class _Tp>
+concept output_range = range<_Rp> && output_iterator<iterator_t<_Rp>, _Tp>;
 
-  template <class _Tp>
-  concept forward_range = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
+template <class _Tp>
+concept forward_range = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;
 
-  template <class _Tp>
-  concept bidirectional_range = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;
+template <class _Tp>
+concept bidirectional_range = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;
 
-  template <class _Tp>
-  concept random_access_range =
-      bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;
+template <class _Tp>
+concept random_access_range = bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;
 
-  template<class _Tp>
-  concept contiguous_range =
-    random_access_range<_Tp> &&
-    contiguous_iterator<iterator_t<_Tp>> &&
-    requires(_Tp& __t) {
-      { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
-    };
+template <class _Tp>
+concept contiguous_range = random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>> && requires(_Tp& __t) {
+  { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
+};
 
-  template <class _Tp>
-  concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
+template <class _Tp>
+concept common_range = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;
 
-  template <class _Tp>
-  inline constexpr bool __is_std_initializer_list = false;
+template <class _Tp>
+inline constexpr bool __is_std_initializer_list = false;
 
-  template <class _Ep>
-  inline constexpr bool __is_std_initializer_list<initializer_list<_Ep>> = true;
+template <class _Ep>
+inline constexpr bool __is_std_initializer_list<initializer_list<_Ep>> = true;
 
-  template <class _Tp>
-  concept viewable_range =
+template <class _Tp>
+concept viewable_range =
     range<_Tp> &&
     ((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>) ||
      (!view<remove_cvref_t<_Tp>> &&
diff --git a/third_party/libcxx/__ranges/copyable_box.h b/third_party/libcxx/__ranges/copyable_box.h
deleted file mode 100644
index 9fbbb1eae..000000000
--- a/third_party/libcxx/__ranges/copyable_box.h
+++ /dev/null
@@ -1,182 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___RANGES_COPYABLE_BOX_H
-#define _LIBCPP___RANGES_COPYABLE_BOX_H
-
-#include <__concepts/constructible.h>
-#include <__concepts/copyable.h>
-#include <__concepts/movable.h>
-#include <__config>
-#include <__memory/addressof.h>
-#include <__memory/construct_at.h>
-#include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_nothrow_copy_constructible.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__utility/move.h>
-#include <optional>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 20
-
-// __copyable_box allows turning a type that is copy-constructible (but maybe not copy-assignable) into
-// a type that is both copy-constructible and copy-assignable. It does that by introducing an empty state
-// and basically doing destroy-then-copy-construct in the assignment operator. The empty state is necessary
-// to handle the case where the copy construction fails after destroying the object.
-//
-// In some cases, we can completely avoid the use of an empty state; we provide a specialization of
-// __copyable_box that does this, see below for the details.
-
-template<class _Tp>
-concept __copy_constructible_object = copy_constructible<_Tp> && is_object_v<_Tp>;
-
-namespace ranges {
-  // Primary template - uses std::optional and introduces an empty state in case assignment fails.
-  template<__copy_constructible_object _Tp>
-  class __copyable_box {
-    _LIBCPP_NO_UNIQUE_ADDRESS optional<_Tp> __val_;
-
-  public:
-    template<class ..._Args>
-      requires is_constructible_v<_Tp, _Args...>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __copyable_box(in_place_t, _Args&& ...__args)
-      noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
-      : __val_(in_place, std::forward<_Args>(__args)...)
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
-      requires default_initializable<_Tp>
-      : __val_(in_place)
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box const&) = default;
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box&&) = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box const& __other)
-      noexcept(is_nothrow_copy_constructible_v<_Tp>)
-    {
-      if (this != std::addressof(__other)) {
-        if (__other.__has_value()) __val_.emplace(*__other);
-        else                       __val_.reset();
-      }
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    __copyable_box& operator=(__copyable_box&&) requires movable<_Tp> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box&& __other)
-      noexcept(is_nothrow_move_constructible_v<_Tp>)
-    {
-      if (this != std::addressof(__other)) {
-        if (__other.__has_value()) __val_.emplace(std::move(*__other));
-        else                       __val_.reset();
-      }
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return *__val_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return *__val_; }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return __val_.operator->(); }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return __val_.operator->(); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return __val_.has_value(); }
-  };
-
-  // This partial specialization implements an optimization for when we know we don't need to store
-  // an empty state to represent failure to perform an assignment. For copy-assignment, this happens:
-  //
-  // 1. If the type is copyable (which includes copy-assignment), we can use the type's own assignment operator
-  //    directly and avoid using std::optional.
-  // 2. If the type is not copyable, but it is nothrow-copy-constructible, then we can implement assignment as
-  //    destroy-and-then-construct and we know it will never fail, so we don't need an empty state.
-  //
-  // The exact same reasoning can be applied for move-assignment, with copyable replaced by movable and
-  // nothrow-copy-constructible replaced by nothrow-move-constructible. This specialization is enabled
-  // whenever we can apply any of these optimizations for both the copy assignment and the move assignment
-  // operator.
-  template<class _Tp>
-  concept __doesnt_need_empty_state_for_copy = copyable<_Tp> || is_nothrow_copy_constructible_v<_Tp>;
-
-  template<class _Tp>
-  concept __doesnt_need_empty_state_for_move = movable<_Tp> || is_nothrow_move_constructible_v<_Tp>;
-
-  template<__copy_constructible_object _Tp>
-    requires __doesnt_need_empty_state_for_copy<_Tp> && __doesnt_need_empty_state_for_move<_Tp>
-  class __copyable_box<_Tp> {
-    _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_;
-
-  public:
-    template<class ..._Args>
-      requires is_constructible_v<_Tp, _Args...>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __copyable_box(in_place_t, _Args&& ...__args)
-      noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
-      : __val_(std::forward<_Args>(__args)...)
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
-      requires default_initializable<_Tp>
-      : __val_()
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box const&) = default;
-    _LIBCPP_HIDE_FROM_ABI __copyable_box(__copyable_box&&) = default;
-
-    // Implementation of assignment operators in case we perform optimization (1)
-    _LIBCPP_HIDE_FROM_ABI __copyable_box& operator=(__copyable_box const&) requires copyable<_Tp> = default;
-    _LIBCPP_HIDE_FROM_ABI __copyable_box& operator=(__copyable_box&&) requires movable<_Tp> = default;
-
-    // Implementation of assignment operators in case we perform optimization (2)
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box const& __other) noexcept {
-      static_assert(is_nothrow_copy_constructible_v<_Tp>);
-      if (this != std::addressof(__other)) {
-        std::destroy_at(std::addressof(__val_));
-        std::construct_at(std::addressof(__val_), __other.__val_);
-      }
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __copyable_box& operator=(__copyable_box&& __other) noexcept {
-      static_assert(is_nothrow_move_constructible_v<_Tp>);
-      if (this != std::addressof(__other)) {
-        std::destroy_at(std::addressof(__val_));
-        std::construct_at(std::addressof(__val_), std::move(__other.__val_));
-      }
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return __val_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return __val_; }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Tp *operator->() const noexcept { return std::addressof(__val_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Tp *operator->() noexcept { return std::addressof(__val_); }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return true; }
-  };
-} // namespace ranges
-
-#endif // _LIBCPP_STD_VER >= 20
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___RANGES_COPYABLE_BOX_H
diff --git a/third_party/libcxx/__ranges/counted.h b/third_party/libcxx/__ranges/counted.h
index 882f90b1e..e365deca4 100644
--- a/third_party/libcxx/__ranges/counted.h
+++ b/third_party/libcxx/__ranges/counted.h
@@ -29,6 +29,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -37,41 +40,42 @@ namespace ranges::views {
 
 namespace __counted {
 
-  struct __fn {
-    template<contiguous_iterator _It>
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
-      noexcept(noexcept(span(std::to_address(__it), static_cast<size_t>(__count))))
-      // Deliberately omit return-type SFINAE, because to_address is not SFINAE-friendly
-      { return          span(std::to_address(__it), static_cast<size_t>(__count)); }
+struct __fn {
+  template <contiguous_iterator _It>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  __go(_It __it,
+       iter_difference_t<_It> __count) noexcept(noexcept(span(std::to_address(__it), static_cast<size_t>(__count))))
+  // Deliberately omit return-type SFINAE, because to_address is not SFINAE-friendly
+  {
+    return span(std::to_address(__it), static_cast<size_t>(__count));
+  }
 
-    template<random_access_iterator _It>
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
-      noexcept(noexcept(subrange(__it, __it + __count)))
-      -> decltype(      subrange(__it, __it + __count))
-      { return          subrange(__it, __it + __count); }
+  template <random_access_iterator _It>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_It __it, iter_difference_t<_It> __count) noexcept(
+      noexcept(subrange(__it, __it + __count))) -> decltype(subrange(__it, __it + __count)) {
+    return subrange(__it, __it + __count);
+  }
 
-    template<class _It>
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr auto __go(_It __it, iter_difference_t<_It> __count)
-      noexcept(noexcept(subrange(counted_iterator(std::move(__it), __count), default_sentinel)))
-      -> decltype(      subrange(counted_iterator(std::move(__it), __count), default_sentinel))
-      { return          subrange(counted_iterator(std::move(__it), __count), default_sentinel); }
+  template <class _It>
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __go(_It __it, iter_difference_t<_It> __count) noexcept(
+      noexcept(subrange(counted_iterator(std::move(__it), __count), default_sentinel)))
+      -> decltype(subrange(counted_iterator(std::move(__it), __count), default_sentinel)) {
+    return subrange(counted_iterator(std::move(__it), __count), default_sentinel);
+  }
 
-    template<class _It, convertible_to<iter_difference_t<_It>> _Diff>
-      requires input_or_output_iterator<decay_t<_It>>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_It&& __it, _Diff&& __count) const
+  template <class _It, convertible_to<iter_difference_t<_It>> _Diff>
+    requires input_or_output_iterator<decay_t<_It>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_It&& __it, _Diff&& __count) const
       noexcept(noexcept(__go(std::forward<_It>(__it), std::forward<_Diff>(__count))))
-      -> decltype(      __go(std::forward<_It>(__it), std::forward<_Diff>(__count)))
-      { return          __go(std::forward<_It>(__it), std::forward<_Diff>(__count)); }
-  };
+          -> decltype(__go(std::forward<_It>(__it), std::forward<_Diff>(__count))) {
+    return __go(std::forward<_It>(__it), std::forward<_Diff>(__count));
+  }
+};
 
 } // namespace __counted
 
 inline namespace __cpo {
-  inline constexpr auto counted = __counted::__fn{};
+inline constexpr auto counted = __counted::__fn{};
 } // namespace __cpo
 
 } // namespace ranges::views
@@ -80,4 +84,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_COUNTED_H
diff --git a/third_party/libcxx/__ranges/data.h b/third_party/libcxx/__ranges/data.h
index 6c099085a..50db3cffe 100644
--- a/third_party/libcxx/__ranges/data.h
+++ b/third_party/libcxx/__ranges/data.h
@@ -36,44 +36,35 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __data {
-  template <class _Tp>
-  concept __ptr_to_object = is_pointer_v<_Tp> && is_object_v<remove_pointer_t<_Tp>>;
+template <class _Tp>
+concept __ptr_to_object = is_pointer_v<_Tp> && is_object_v<remove_pointer_t<_Tp>>;
 
-  template <class _Tp>
-  concept __member_data =
-    __can_borrow<_Tp> &&
-    __workaround_52970<_Tp> &&
-    requires(_Tp&& __t) {
-      { _LIBCPP_AUTO_CAST(__t.data()) } -> __ptr_to_object;
-    };
+template <class _Tp>
+concept __member_data = __can_borrow<_Tp> && requires(_Tp&& __t) {
+  { _LIBCPP_AUTO_CAST(__t.data()) } -> __ptr_to_object;
+};
 
-  template <class _Tp>
-  concept __ranges_begin_invocable =
-    !__member_data<_Tp> &&
-    __can_borrow<_Tp> &&
-    requires(_Tp&& __t) {
-      { ranges::begin(__t) } -> contiguous_iterator;
-    };
+template <class _Tp>
+concept __ranges_begin_invocable = !__member_data<_Tp> && __can_borrow<_Tp> && requires(_Tp&& __t) {
+  { ranges::begin(__t) } -> contiguous_iterator;
+};
 
-  struct __fn {
-    template <__member_data _Tp>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-        noexcept(noexcept(__t.data())) {
-      return __t.data();
-    }
+struct __fn {
+  template <__member_data _Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const noexcept(noexcept(__t.data())) {
+    return __t.data();
+  }
 
-    template<__ranges_begin_invocable _Tp>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-        noexcept(noexcept(std::to_address(ranges::begin(__t)))) {
-      return std::to_address(ranges::begin(__t));
-    }
-  };
+  template <__ranges_begin_invocable _Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(std::to_address(ranges::begin(__t)))) {
+    return std::to_address(ranges::begin(__t));
+  }
+};
 } // namespace __data
 
 inline namespace __cpo {
-  inline constexpr auto data = __data::__fn{};
+inline constexpr auto data = __data::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -81,27 +72,26 @@ inline namespace __cpo {
 
 namespace ranges {
 namespace __cdata {
-  struct __fn {
-    template <class _Tp>
-      requires is_lvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
+struct __fn {
+  template <class _Tp>
+    requires is_lvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
       noexcept(noexcept(ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t))))
-      -> decltype(      ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t)))
-      { return          ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+          -> decltype(ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t))) {
+    return ranges::data(static_cast<const remove_reference_t<_Tp>&>(__t));
+  }
 
-    template <class _Tp>
-      requires is_rvalue_reference_v<_Tp&&>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Tp&& __t) const
-      noexcept(noexcept(ranges::data(static_cast<const _Tp&&>(__t))))
-      -> decltype(      ranges::data(static_cast<const _Tp&&>(__t)))
-      { return          ranges::data(static_cast<const _Tp&&>(__t)); }
-  };
+  template <class _Tp>
+    requires is_rvalue_reference_v<_Tp&&>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const noexcept(
+      noexcept(ranges::data(static_cast<const _Tp&&>(__t)))) -> decltype(ranges::data(static_cast<const _Tp&&>(__t))) {
+    return ranges::data(static_cast<const _Tp&&>(__t));
+  }
+};
 } // namespace __cdata
 
 inline namespace __cpo {
-  inline constexpr auto cdata = __cdata::__fn{};
+inline constexpr auto cdata = __cdata::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__ranges/drop_view.h b/third_party/libcxx/__ranges/drop_view.h
index 0df8ab46b..853e22a40 100644
--- a/third_party/libcxx/__ranges/drop_view.h
+++ b/third_party/libcxx/__ranges/drop_view.h
@@ -30,6 +30,7 @@
 #include <__ranges/iota_view.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
+#include <__ranges/repeat_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>
@@ -55,89 +56,96 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<view _View>
-  class drop_view
-    : public view_interface<drop_view<_View>>
-  {
-    // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
-    // amortized O(1) begin() method. If this is an input_range, then we cannot cache
-    // begin because begin is not equality preserving.
-    // Note: drop_view<input-range>::begin() is still trivially amortized O(1) because
-    // one can't call begin() on it more than once.
-    static constexpr bool _UseCache = forward_range<_View> && !(random_access_range<_View> && sized_range<_View>);
-    using _Cache = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
-    range_difference_t<_View> __count_ = 0;
-    _View __base_ = _View();
+template <view _View>
+class drop_view : public view_interface<drop_view<_View>> {
+  // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
+  // amortized O(1) begin() method. If this is an input_range, then we cannot cache
+  // begin because begin is not equality preserving.
+  // Note: drop_view<input-range>::begin() is still trivially amortized O(1) because
+  // one can't call begin() on it more than once.
+  static constexpr bool _UseCache = forward_range<_View> && !(random_access_range<_View> && sized_range<_View>);
+  using _Cache                    = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
+  range_difference_t<_View> __count_               = 0;
+  _View __base_                                    = _View();
 
 public:
-    _LIBCPP_HIDE_FROM_ABI drop_view() requires default_initializable<_View> = default;
+  _LIBCPP_HIDE_FROM_ABI drop_view()
+    requires default_initializable<_View>
+  = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 drop_view(_View __base, range_difference_t<_View> __count)
-      : __count_(__count)
-      , __base_(std::move(__base))
-    {
-      _LIBCPP_ASSERT(__count_ >= 0, "count must be greater than or equal to zero.");
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23
+  drop_view(_View __base, range_difference_t<_View> __count)
+      : __count_(__count), __base_(std::move(__base)) {
+    _LIBCPP_ASSERT_UNCATEGORIZED(__count_ >= 0, "count must be greater than or equal to zero.");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!(__simple_view<_View> && random_access_range<const _View> && sized_range<const _View>))
+  {
+    if constexpr (random_access_range<_View> && sized_range<_View>) {
+      const auto __dist = std::min(ranges::distance(__base_), __count_);
+      return ranges::begin(__base_) + __dist;
     }
+    if constexpr (_UseCache)
+      if (__cached_begin_.__has_value())
+        return *__cached_begin_;
 
-    _LIBCPP_HIDE_FROM_ABI constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+    auto __tmp = ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
+    if constexpr (_UseCache)
+      __cached_begin_.__emplace(__tmp);
+    return __tmp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto begin()
-      requires (!(__simple_view<_View> &&
-                  random_access_range<const _View> && sized_range<const _View>))
-    {
-      if constexpr (_UseCache)
-        if (__cached_begin_.__has_value())
-          return *__cached_begin_;
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires random_access_range<const _View> && sized_range<const _View>
+  {
+    const auto __dist = std::min(ranges::distance(__base_), __count_);
+    return ranges::begin(__base_) + __dist;
+  }
 
-      auto __tmp = ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
-      if constexpr (_UseCache)
-        __cached_begin_.__emplace(__tmp);
-      return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View>)
+  {
+    return ranges::end(__base_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto begin() const
-      requires random_access_range<const _View> && sized_range<const _View>
-    {
-      return ranges::next(ranges::begin(__base_), __count_, ranges::end(__base_));
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
+    return ranges::end(__base_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end()
-      requires (!__simple_view<_View>)
-    { return ranges::end(__base_); }
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __size(auto& __self) {
+    const auto __s = ranges::size(__self.__base_);
+    const auto __c = static_cast<decltype(__s)>(__self.__count_);
+    return __s < __c ? 0 : __s - __c;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() const
-      requires range<const _View>
-    { return ranges::end(__base_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    return __size(*this);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr auto __size(auto& __self) {
-      const auto __s = ranges::size(__self.__base_);
-      const auto __c = static_cast<decltype(__s)>(__self.__count_);
-      return __s < __c ? 0 : __s - __c;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    return __size(*this);
+  }
+};
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size()
-      requires sized_range<_View>
-    { return __size(*this); }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() const
-      requires sized_range<const _View>
-    { return __size(*this); }
-  };
-
-template<class _Range>
+template <class _Range>
 drop_view(_Range&&, range_difference_t<_Range>) -> drop_view<views::all_t<_Range>>;
 
-template<class _Tp>
+template <class _Tp>
 inline constexpr bool enable_borrowed_range<drop_view<_Tp>> = enable_borrowed_range<_Tp>;
 
 namespace views {
@@ -202,103 +210,111 @@ struct __fn {
   // [range.drop.overview]: the `empty_view` case.
   template <class _Range, convertible_to<range_difference_t<_Range>> _Np>
     requires __is_empty_view<remove_cvref_t<_Range>>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range, _Np&&) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
-    -> decltype(      _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)))
-    { return          _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&&) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
+          -> decltype(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))) {
+    return _LIBCPP_AUTO_CAST(std::forward<_Range>(__range));
+  }
 
   // [range.drop.overview]: the `span | basic_string_view | iota_view | subrange (StoreSize == false)` case.
   template <class _Range,
             convertible_to<range_difference_t<_Range>> _Np,
             class _RawRange = remove_cvref_t<_Range>,
-            class _Dist = range_difference_t<_Range>>
-    requires (!__is_empty_view<_RawRange> &&
-              random_access_range<_RawRange> &&
-              sized_range<_RawRange> &&
-              __is_passthrough_specialization<_RawRange>)
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __rng, _Np&& __n) const
-    noexcept(noexcept(__passthrough_type_t<_RawRange>(
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
-                              ranges::end(__rng)
-                              )))
-    -> decltype(      __passthrough_type_t<_RawRange>(
-                              // Note: deliberately not forwarding `__rng` to guard against double moves.
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
-                              ranges::end(__rng)
-                              ))
-    { return          __passthrough_type_t<_RawRange>(
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
-                              ranges::end(__rng)
-                              ); }
+            class _Dist     = range_difference_t<_Range>>
+    requires(!__is_empty_view<_RawRange> && random_access_range<_RawRange> && sized_range<_RawRange> &&
+             __is_passthrough_specialization<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __rng, _Np&& __n) const
+      noexcept(noexcept(__passthrough_type_t<_RawRange>(
+          ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)), ranges::end(__rng))))
+          -> decltype(__passthrough_type_t<_RawRange>(
+              // Note: deliberately not forwarding `__rng` to guard against double moves.
+              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
+              ranges::end(__rng))) {
+    return __passthrough_type_t<_RawRange>(
+        ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)), ranges::end(__rng));
+  }
 
   // [range.drop.overview]: the `subrange (StoreSize == true)` case.
   template <class _Range,
             convertible_to<range_difference_t<_Range>> _Np,
             class _RawRange = remove_cvref_t<_Range>,
-            class _Dist = range_difference_t<_Range>>
-    requires (!__is_empty_view<_RawRange> &&
-              random_access_range<_RawRange> &&
-              sized_range<_RawRange> &&
-              __is_subrange_specialization_with_store_size<_RawRange>)
+            class _Dist     = range_difference_t<_Range>>
+    requires(!__is_empty_view<_RawRange> && random_access_range<_RawRange> && sized_range<_RawRange> &&
+             __is_subrange_specialization_with_store_size<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __rng, _Np&& __n) const noexcept(noexcept(
+      _RawRange(ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
+                ranges::end(__rng),
+                std::__to_unsigned_like(ranges::distance(__rng) -
+                                        std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))))))
+      -> decltype(_RawRange(
+          // Note: deliberately not forwarding `__rng` to guard against double moves.
+          ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
+          ranges::end(__rng),
+          std::__to_unsigned_like(ranges::distance(__rng) -
+                                  std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))))) {
+    // Introducing local variables avoids calculating `min` and `distance` twice (at the cost of diverging from the
+    // expression used in the `noexcept` clause and the return statement).
+    auto __dist    = ranges::distance(__rng);
+    auto __clamped = std::min<_Dist>(__dist, std::forward<_Np>(__n));
+    return _RawRange(ranges::begin(__rng) + __clamped, ranges::end(__rng), std::__to_unsigned_like(__dist - __clamped));
+  }
+  // clang-format off
+#if _LIBCPP_STD_VER >= 23
+  // [range.drop.overview]: the `repeat_view` "_RawRange models sized_range" case.
+  template <class _Range,
+            convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>,
+            class _Dist     = range_difference_t<_Range>>
+    requires (__is_repeat_specialization<_RawRange> && sized_range<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+    noexcept(noexcept(views::repeat(*__range.__value_, ranges::distance(__range) - std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))))
+    -> decltype(      views::repeat(*__range.__value_, ranges::distance(__range) - std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n))))
+    { return          views::repeat(*__range.__value_, ranges::distance(__range) - std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n))); }
+
+  // [range.drop.overview]: the `repeat_view` "otherwise" case.
+  template <class _Range,
+            convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>,
+            class _Dist     = range_difference_t<_Range>>
+    requires (__is_repeat_specialization<_RawRange> && !sized_range<_RawRange>)
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __rng, _Np&& __n) const
-    noexcept(noexcept(_RawRange(
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
-                              ranges::end(__rng),
-                              std::__to_unsigned_like(ranges::distance(__rng) -
-                                  std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
-                              )))
-    -> decltype(      _RawRange(
-                              // Note: deliberately not forwarding `__rng` to guard against double moves.
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)),
-                              ranges::end(__rng),
-                              std::__to_unsigned_like(ranges::distance(__rng) -
-                                  std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
-                              ))
-    {
-      // Introducing local variables avoids calculating `min` and `distance` twice (at the cost of diverging from the
-      // expression used in the `noexcept` clause and the return statement).
-      auto __dist = ranges::distance(__rng);
-      auto __clamped = std::min<_Dist>(__dist, std::forward<_Np>(__n));
-      return          _RawRange(
-                              ranges::begin(__rng) + __clamped,
-                              ranges::end(__rng),
-                              std::__to_unsigned_like(__dist - __clamped)
-                              );}
+  constexpr auto operator()(_Range&& __range, _Np&&) const
+    noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
+    -> decltype(      _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)))
+    { return          _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)); }
+#endif
+  // clang-format on
 
   // [range.drop.overview]: the "otherwise" case.
-  template <class _Range, convertible_to<range_difference_t<_Range>> _Np,
-            class _RawRange = remove_cvref_t<_Range>>
-    // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
-    // overloads.
-    requires (!(__is_empty_view<_RawRange> ||
-               (__is_subrange_specialization_with_store_size<_RawRange> &&
-               sized_range<_RawRange> &&
+  template <class _Range, convertible_to<range_difference_t<_Range>> _Np, class _RawRange = remove_cvref_t<_Range>>
+  // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
+  // overloads.
+    requires(!(__is_empty_view<_RawRange> ||
+#  if _LIBCPP_STD_VER >= 23
+               __is_repeat_specialization<_RawRange> ||
+#  endif
+               (__is_subrange_specialization_with_store_size<_RawRange> && sized_range<_RawRange> &&
                 random_access_range<_RawRange>) ||
-               (__is_passthrough_specialization<_RawRange> &&
-                sized_range<_RawRange> &&
-                random_access_range<_RawRange>)
-             ))
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range, _Np&& __n) const
-    noexcept(noexcept(drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
-    -> decltype(      drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n)))
-    { return          drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n)); }
+               (__is_passthrough_specialization<_RawRange> && sized_range<_RawRange> &&
+                random_access_range<_RawRange>)))
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+      noexcept(noexcept(drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
+          -> decltype(drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n))) {
+    return drop_view(std::forward<_Range>(__range), std::forward<_Np>(__n));
+  }
 
   template <class _Np>
     requires constructible_from<decay_t<_Np>, _Np>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Np&& __n) const
-    noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>)
-  { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n))); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Np&& __n) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n)));
+  }
 };
 
 } // namespace __drop
 
 inline namespace __cpo {
-  inline constexpr auto drop = __drop::__fn{};
+inline constexpr auto drop = __drop::__fn{};
 } // namespace __cpo
 } // namespace views
 
diff --git a/third_party/libcxx/__ranges/drop_while_view.h b/third_party/libcxx/__ranges/drop_while_view.h
index 518feae4e..92f48bd0e 100644
--- a/third_party/libcxx/__ranges/drop_while_view.h
+++ b/third_party/libcxx/__ranges/drop_while_view.h
@@ -20,8 +20,8 @@
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
-#include <__ranges/copyable_box.h>
 #include <__ranges/enable_borrowed_range.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
@@ -37,6 +37,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -45,7 +48,7 @@ namespace ranges {
 
 template <view _View, class _Pred>
   requires input_range<_View> && is_object_v<_Pred> && indirect_unary_predicate<const _Pred, iterator_t<_View>>
-class drop_while_view : public view_interface<drop_while_view<_View, _Pred>> {
+class _LIBCPP_ABI_LLVM18_NO_UNIQUE_ADDRESS drop_while_view : public view_interface<drop_while_view<_View, _Pred>> {
 public:
   _LIBCPP_HIDE_FROM_ABI drop_while_view()
     requires default_initializable<_View> && default_initializable<_Pred>
@@ -65,9 +68,11 @@ public:
   _LIBCPP_HIDE_FROM_ABI constexpr const _Pred& pred() const { return *__pred_; }
 
   _LIBCPP_HIDE_FROM_ABI constexpr auto begin() {
-    _LIBCPP_ASSERT(__pred_.__has_value(),
-                   "drop_while_view needs to have a non-empty predicate before calling begin() -- did a previous "
-                   "assignment to this drop_while_view fail?");
+    // Note: this duplicates a check in `optional` but provides a better error message.
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __pred_.__has_value(),
+        "drop_while_view needs to have a non-empty predicate before calling begin() -- did a previous "
+        "assignment to this drop_while_view fail?");
     if constexpr (_UseCache) {
       if (!__cached_begin_.__has_value()) {
         __cached_begin_.__emplace(ranges::find_if_not(__base_, std::cref(*__pred_)));
@@ -82,7 +87,7 @@ public:
 
 private:
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-  _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
 
   static constexpr bool _UseCache = forward_range<_View>;
   using _Cache                    = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
@@ -126,4 +131,6 @@ inline constexpr auto drop_while = __drop_while::__fn{};
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_DROP_WHILE_VIEW_H
diff --git a/third_party/libcxx/__ranges/elements_view.h b/third_party/libcxx/__ranges/elements_view.h
index 325e4c9dc..f159f53dc 100644
--- a/third_party/libcxx/__ranges/elements_view.h
+++ b/third_party/libcxx/__ranges/elements_view.h
@@ -16,7 +16,7 @@
 #include <__concepts/derived_from.h>
 #include <__concepts/equality_comparable.h>
 #include <__config>
-#include <__fwd/get.h>
+#include <__fwd/complex.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__ranges/access.h>
@@ -43,6 +43,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -410,4 +413,6 @@ inline constexpr auto values   = elements<1>;
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_ELEMENTS_VIEW_H
diff --git a/third_party/libcxx/__ranges/empty.h b/third_party/libcxx/__ranges/empty.h
index 64996f4a6..5c1004042 100644
--- a/third_party/libcxx/__ranges/empty.h
+++ b/third_party/libcxx/__ranges/empty.h
@@ -28,50 +28,39 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 namespace __empty {
-  template <class _Tp>
-  concept __member_empty =
-    __workaround_52970<_Tp> &&
-    requires(_Tp&& __t) {
-      bool(__t.empty());
-    };
+template <class _Tp>
+concept __member_empty = requires(_Tp&& __t) { bool(__t.empty()); };
 
-  template<class _Tp>
-  concept __can_invoke_size =
-    !__member_empty<_Tp> &&
-    requires(_Tp&& __t) { ranges::size(__t); };
+template <class _Tp>
+concept __can_invoke_size = !__member_empty<_Tp> && requires(_Tp&& __t) { ranges::size(__t); };
 
-  template <class _Tp>
-  concept __can_compare_begin_end =
-    !__member_empty<_Tp> &&
-    !__can_invoke_size<_Tp> &&
-    requires(_Tp&& __t) {
-      bool(ranges::begin(__t) == ranges::end(__t));
-      { ranges::begin(__t) } -> forward_iterator;
-    };
+template <class _Tp>
+concept __can_compare_begin_end = !__member_empty<_Tp> && !__can_invoke_size<_Tp> && requires(_Tp&& __t) {
+  bool(ranges::begin(__t) == ranges::end(__t));
+  { ranges::begin(__t) } -> forward_iterator;
+};
 
-  struct __fn {
-    template <__member_empty _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
-        noexcept(noexcept(bool(__t.empty()))) {
-      return bool(__t.empty());
-    }
+struct __fn {
+  template <__member_empty _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const noexcept(noexcept(bool(__t.empty()))) {
+    return bool(__t.empty());
+  }
 
-    template <__can_invoke_size _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
-        noexcept(noexcept(ranges::size(__t))) {
-      return ranges::size(__t) == 0;
-    }
+  template <__can_invoke_size _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const noexcept(noexcept(ranges::size(__t))) {
+    return ranges::size(__t) == 0;
+  }
 
-    template<__can_compare_begin_end _Tp>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
-        noexcept(noexcept(bool(ranges::begin(__t) == ranges::end(__t)))) {
-      return ranges::begin(__t) == ranges::end(__t);
-    }
-  };
+  template <__can_compare_begin_end _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_Tp&& __t) const
+      noexcept(noexcept(bool(ranges::begin(__t) == ranges::end(__t)))) {
+    return ranges::begin(__t) == ranges::end(__t);
+  }
+};
 } // namespace __empty
 
 inline namespace __cpo {
-  inline constexpr auto empty = __empty::__fn{};
+inline constexpr auto empty = __empty::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__ranges/empty_view.h b/third_party/libcxx/__ranges/empty_view.h
index bb445b4e6..6c04b0200 100644
--- a/third_party/libcxx/__ranges/empty_view.h
+++ b/third_party/libcxx/__ranges/empty_view.h
@@ -25,26 +25,26 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<class _Tp>
-    requires is_object_v<_Tp>
-  class empty_view : public view_interface<empty_view<_Tp>> {
-  public:
-    _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; }
-    _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; }
-    _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; }
-    _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; }
-    _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; }
-  };
+template <class _Tp>
+  requires is_object_v<_Tp>
+class empty_view : public view_interface<empty_view<_Tp>> {
+public:
+  _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; }
+};
 
-  template<class _Tp>
-  inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
+template <class _Tp>
+inline constexpr bool enable_borrowed_range<empty_view<_Tp>> = true;
 
-  namespace views {
+namespace views {
 
-  template <class _Tp>
-  inline constexpr empty_view<_Tp> empty{};
+template <class _Tp>
+inline constexpr empty_view<_Tp> empty{};
 
-  } // namespace views
+} // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__ranges/enable_view.h b/third_party/libcxx/__ranges/enable_view.h
index 0c1dff382..f570926eb 100644
--- a/third_party/libcxx/__ranges/enable_view.h
+++ b/third_party/libcxx/__ranges/enable_view.h
@@ -27,19 +27,20 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-struct view_base { };
+struct view_base {};
 
-template<class _Derived>
+template <class _Derived>
   requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
 class view_interface;
 
-template<class _Op, class _Yp>
+template <class _Op, class _Yp>
   requires is_convertible_v<_Op*, view_interface<_Yp>*>
 void __is_derived_from_view_interface(const _Op*, const view_interface<_Yp>*);
 
 template <class _Tp>
-inline constexpr bool enable_view = derived_from<_Tp, view_base> ||
-  requires { ranges::__is_derived_from_view_interface((_Tp*)nullptr, (_Tp*)nullptr); };
+inline constexpr bool enable_view = derived_from<_Tp, view_base> || requires {
+  ranges::__is_derived_from_view_interface((_Tp*)nullptr, (_Tp*)nullptr);
+};
 
 } // namespace ranges
 
diff --git a/third_party/libcxx/__ranges/filter_view.h b/third_party/libcxx/__ranges/filter_view.h
index 4acbfad54..5b938dd4c 100644
--- a/third_party/libcxx/__ranges/filter_view.h
+++ b/third_party/libcxx/__ranges/filter_view.h
@@ -11,12 +11,12 @@
 #define _LIBCPP___RANGES_FILTER_VIEW_H
 
 #include <__algorithm/ranges_find_if.h>
+#include <__assert>
 #include <__concepts/constructible.h>
 #include <__concepts/copyable.h>
 #include <__concepts/derived_from.h>
 #include <__concepts/equality_comparable.h>
 #include <__config>
-#include <__debug>
 #include <__functional/bind_back.h>
 #include <__functional/invoke.h>
 #include <__functional/reference_wrapper.h>
@@ -28,7 +28,7 @@
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
-#include <__ranges/copyable_box.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/non_propagating_cache.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
@@ -44,215 +44,208 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
-    requires view<_View> && is_object_v<_Pred>
-  class filter_view : public view_interface<filter_view<_View, _Pred>> {
-    _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-    _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
+template <input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+  requires view<_View> && is_object_v<_Pred>
+class _LIBCPP_ABI_LLVM18_NO_UNIQUE_ADDRESS filter_view : public view_interface<filter_view<_View, _Pred>> {
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
 
-    // We cache the result of begin() to allow providing an amortized O(1) begin() whenever
-    // the underlying range is at least a forward_range.
-    static constexpr bool _UseCache = forward_range<_View>;
-    using _Cache = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
+  // We cache the result of begin() to allow providing an amortized O(1) begin() whenever
+  // the underlying range is at least a forward_range.
+  static constexpr bool _UseCache = forward_range<_View>;
+  using _Cache                    = _If<_UseCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
 
-    class __iterator;
-    class __sentinel;
+  class __iterator;
+  class __sentinel;
 
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    filter_view() requires default_initializable<_View> && default_initializable<_Pred> = default;
+public:
+  _LIBCPP_HIDE_FROM_ABI filter_view()
+    requires default_initializable<_View> && default_initializable<_Pred>
+  = default;
 
-    _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 filter_view(_View __base, _Pred __pred)
-        : __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 filter_view(_View __base, _Pred __pred)
+      : __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}
 
-    template<class _Vp = _View>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() const& requires copy_constructible<_Vp> { return __base_; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() && { return std::move(__base_); }
+  template <class _Vp = _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_Vp>
+  {
+    return __base_;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Pred const& pred() const { return *__pred_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Pred const& pred() const { return *__pred_; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator begin() {
-      _LIBCPP_ASSERT(__pred_.__has_value(), "Trying to call begin() on a filter_view that does not have a valid predicate.");
-      if constexpr (_UseCache) {
-        if (!__cached_begin_.__has_value()) {
-          __cached_begin_.__emplace(ranges::find_if(__base_, std::ref(*__pred_)));
-        }
-        return {*this, *__cached_begin_};
-      } else {
-        return {*this, ranges::find_if(__base_, std::ref(*__pred_))};
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() {
+    // Note: this duplicates a check in `optional` but provides a better error message.
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __pred_.__has_value(), "Trying to call begin() on a filter_view that does not have a valid predicate.");
+    if constexpr (_UseCache) {
+      if (!__cached_begin_.__has_value()) {
+        __cached_begin_.__emplace(ranges::find_if(__base_, std::ref(*__pred_)));
       }
+      return {*this, *__cached_begin_};
+    } else {
+      return {*this, ranges::find_if(__base_, std::ref(*__pred_))};
     }
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() {
-      if constexpr (common_range<_View>)
-        return __iterator{*this, ranges::end(__base_)};
-      else
-        return __sentinel{*this};
-    }
-  };
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
+    if constexpr (common_range<_View>)
+      return __iterator{*this, ranges::end(__base_)};
+    else
+      return __sentinel{*this};
+  }
+};
 
-  template<class _Range, class _Pred>
-  filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
+template <class _Range, class _Pred>
+filter_view(_Range&&, _Pred) -> filter_view<views::all_t<_Range>, _Pred>;
 
-  template<class _View>
-  struct __filter_iterator_category { };
+template <class _View>
+struct __filter_iterator_category {};
 
-  template<forward_range _View>
-  struct __filter_iterator_category<_View> {
-    using _Cat = typename iterator_traits<iterator_t<_View>>::iterator_category;
-    using iterator_category =
-      _If<derived_from<_Cat, bidirectional_iterator_tag>, bidirectional_iterator_tag,
-      _If<derived_from<_Cat, forward_iterator_tag>,       forward_iterator_tag,
-      /* else */                                          _Cat
-    >>;
-  };
+template <forward_range _View>
+struct __filter_iterator_category<_View> {
+  using _Cat = typename iterator_traits<iterator_t<_View>>::iterator_category;
+  using iterator_category =
+      _If<derived_from<_Cat, bidirectional_iterator_tag>,
+          bidirectional_iterator_tag,
+          _If<derived_from<_Cat, forward_iterator_tag>,
+              forward_iterator_tag,
+              /* else */ _Cat >>;
+};
 
-  template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
-    requires view<_View> && is_object_v<_Pred>
-  class filter_view<_View, _Pred>::__iterator : public __filter_iterator_category<_View> {
+template <input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+  requires view<_View> && is_object_v<_Pred>
+class filter_view<_View, _Pred>::__iterator : public __filter_iterator_category<_View> {
+public:
+  _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __current_ = iterator_t<_View>();
+  _LIBCPP_NO_UNIQUE_ADDRESS filter_view* __parent_       = nullptr;
 
-  public:
-    _LIBCPP_NO_UNIQUE_ADDRESS iterator_t<_View> __current_ = iterator_t<_View>();
-    _LIBCPP_NO_UNIQUE_ADDRESS filter_view* __parent_ = nullptr;
+  using iterator_concept =
+      _If<bidirectional_range<_View>,
+          bidirectional_iterator_tag,
+          _If<forward_range<_View>,
+              forward_iterator_tag,
+              /* else */ input_iterator_tag >>;
+  // using iterator_category = inherited;
+  using value_type      = range_value_t<_View>;
+  using difference_type = range_difference_t<_View>;
 
-    using iterator_concept =
-      _If<bidirectional_range<_View>, bidirectional_iterator_tag,
-      _If<forward_range<_View>,       forward_iterator_tag,
-      /* else */                      input_iterator_tag
-    >>;
-    // using iterator_category = inherited;
-    using value_type = range_value_t<_View>;
-    using difference_type = range_difference_t<_View>;
+  _LIBCPP_HIDE_FROM_ABI __iterator()
+    requires default_initializable<iterator_t<_View>>
+  = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    __iterator() requires default_initializable<iterator_t<_View>> = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(filter_view& __parent, iterator_t<_View> __current)
+      : __current_(std::move(__current)), __parent_(std::addressof(__parent)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator(filter_view& __parent, iterator_t<_View> __current)
-      : __current_(std::move(__current)), __parent_(std::addressof(__parent))
-    { }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> const& base() const& noexcept { return __current_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> base() && { return std::move(__current_); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator_t<_View> const& base() const& noexcept { return __current_; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator_t<_View> base() && { return std::move(__current_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr range_reference_t<_View> operator*() const { return *__current_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> operator->() const
+    requires __has_arrow<iterator_t<_View>> && copyable<iterator_t<_View>>
+  {
+    return __current_;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr range_reference_t<_View> operator*() const { return *__current_; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator_t<_View> operator->() const
-      requires __has_arrow<iterator_t<_View>> && copyable<iterator_t<_View>>
-    {
-      return __current_;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    __current_ =
+        ranges::find_if(std::move(++__current_), ranges::end(__parent_->__base_), std::ref(*__parent_->__pred_));
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
+    requires forward_range<_View>
+  {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator& operator++() {
-      __current_ = ranges::find_if(std::move(++__current_), ranges::end(__parent_->__base_),
-                                   std::ref(*__parent_->__pred_));
-      return *this;
-    }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator++(int) { ++*this; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator operator++(int) requires forward_range<_View> {
-      auto __tmp = *this;
-      ++*this;
-      return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires bidirectional_range<_View>
+  {
+    do {
+      --__current_;
+    } while (!std::invoke(*__parent_->__pred_, *__current_));
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires bidirectional_range<_View>
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator& operator--() requires bidirectional_range<_View> {
-      do {
-        --__current_;
-      } while (!std::invoke(*__parent_->__pred_, *__current_));
-      return *this;
-    }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator operator--(int) requires bidirectional_range<_View> {
-      auto __tmp = *this;
-      --*this;
-      return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(__iterator const& __x, __iterator const& __y)
+    requires equality_comparable<iterator_t<_View>>
+  {
+    return __x.__current_ == __y.__current_;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(__iterator const& __x, __iterator const& __y)
-      requires equality_comparable<iterator_t<_View>>
-    {
-      return __x.__current_ == __y.__current_;
-    }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_rvalue_reference_t<_View>
+  iter_move(__iterator const& __it) noexcept(noexcept(ranges::iter_move(__it.__current_))) {
+    return ranges::iter_move(__it.__current_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr range_rvalue_reference_t<_View> iter_move(__iterator const& __it)
-      noexcept(noexcept(ranges::iter_move(__it.__current_)))
-    {
-      return ranges::iter_move(__it.__current_);
-    }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void
+  iter_swap(__iterator const& __x,
+            __iterator const& __y) noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
+    requires indirectly_swappable<iterator_t<_View>>
+  {
+    return ranges::iter_swap(__x.__current_, __y.__current_);
+  }
+};
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr void iter_swap(__iterator const& __x, __iterator const& __y)
-      noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_)))
-      requires indirectly_swappable<iterator_t<_View>>
-    {
-      return ranges::iter_swap(__x.__current_, __y.__current_);
-    }
-  };
+template <input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
+  requires view<_View> && is_object_v<_Pred>
+class filter_view<_View, _Pred>::__sentinel {
+public:
+  sentinel_t<_View> __end_ = sentinel_t<_View>();
 
-  template<input_range _View, indirect_unary_predicate<iterator_t<_View>> _Pred>
-    requires view<_View> && is_object_v<_Pred>
-  class filter_view<_View, _Pred>::__sentinel {
-  public:
-    sentinel_t<_View> __end_ = sentinel_t<_View>();
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    __sentinel() = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(filter_view& __parent) : __end_(ranges::end(__parent.__base_)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __sentinel(filter_view& __parent)
-      : __end_(ranges::end(__parent.__base_))
-    { }
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_View> base() const { return __end_; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr sentinel_t<_View> base() const { return __end_; }
-
-    _LIBCPP_HIDE_FROM_ABI friend constexpr bool
-    operator==(__iterator const& __x, __sentinel const& __y) {
-      return __x.__current_ == __y.__end_;
-    }
-  };
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(__iterator const& __x, __sentinel const& __y) {
+    return __x.__current_ == __y.__end_;
+  }
+};
 
 namespace views {
 namespace __filter {
-  struct __fn {
-    template<class _Range, class _Pred>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Range&& __range, _Pred&& __pred) const
+struct __fn {
+  template <class _Range, class _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Pred&& __pred) const
       noexcept(noexcept(filter_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred))))
-      -> decltype(      filter_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred)))
-      { return          filter_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred)); }
+          -> decltype(filter_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred))) {
+    return filter_view(std::forward<_Range>(__range), std::forward<_Pred>(__pred));
+  }
 
-    template<class _Pred>
-      requires constructible_from<decay_t<_Pred>, _Pred>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Pred&& __pred) const
-      noexcept(is_nothrow_constructible_v<decay_t<_Pred>, _Pred>)
-    { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pred>(__pred))); }
-  };
+  template <class _Pred>
+    requires constructible_from<decay_t<_Pred>, _Pred>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pred&& __pred) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Pred>, _Pred>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pred>(__pred)));
+  }
+};
 } // namespace __filter
 
 inline namespace __cpo {
-  inline constexpr auto filter = __filter::__fn{};
+inline constexpr auto filter = __filter::__fn{};
 } // namespace __cpo
 } // namespace views
 
@@ -262,4 +255,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_FILTER_VIEW_H
diff --git a/third_party/libcxx/__ranges/iota_view.h b/third_party/libcxx/__ranges/iota_view.h
index ebfa02200..b2fa958a0 100644
--- a/third_party/libcxx/__ranges/iota_view.h
+++ b/third_party/libcxx/__ranges/iota_view.h
@@ -22,16 +22,15 @@
 #include <__concepts/semiregular.h>
 #include <__concepts/totally_ordered.h>
 #include <__config>
-#include <__functional/ranges_operations.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/unreachable_sentinel.h>
-#include <__ranges/copyable_box.h>
 #include <__ranges/enable_borrowed_range.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/conditional.h>
-#include <__type_traits/is_nothrow_copy_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/make_unsigned.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
@@ -41,41 +40,47 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<class _Int>
-  struct __get_wider_signed {
-    consteval static auto __call() {
-           if constexpr (sizeof(_Int) < sizeof(short)) return type_identity<short>{};
-      else if constexpr (sizeof(_Int) < sizeof(int))   return type_identity<int>{};
-      else if constexpr (sizeof(_Int) < sizeof(long))  return type_identity<long>{};
-      else                                             return type_identity<long long>{};
+template <class _Int>
+struct __get_wider_signed {
+  consteval static auto __call() {
+    if constexpr (sizeof(_Int) < sizeof(short))
+      return type_identity<short>{};
+    else if constexpr (sizeof(_Int) < sizeof(int))
+      return type_identity<int>{};
+    else if constexpr (sizeof(_Int) < sizeof(long))
+      return type_identity<long>{};
+    else
+      return type_identity<long long>{};
 
-      static_assert(sizeof(_Int) <= sizeof(long long),
-        "Found integer-like type that is bigger than largest integer like type.");
-    }
+    static_assert(
+        sizeof(_Int) <= sizeof(long long), "Found integer-like type that is bigger than largest integer like type.");
+  }
 
-    using type = typename decltype(__call())::type;
-  };
+  using type = typename decltype(__call())::type;
+};
 
-  template<class _Start>
-  using _IotaDiffT = typename _If<
-      (!integral<_Start> || sizeof(iter_difference_t<_Start>) > sizeof(_Start)),
-      type_identity<iter_difference_t<_Start>>,
-      __get_wider_signed<_Start>
-    >::type;
+template <class _Start>
+using _IotaDiffT =
+    typename _If< (!integral<_Start> || sizeof(iter_difference_t<_Start>) > sizeof(_Start)),
+                  type_identity<iter_difference_t<_Start>>,
+                  __get_wider_signed<_Start> >::type;
 
-  template<class _Iter>
-  concept __decrementable = incrementable<_Iter> && requires(_Iter __i) {
-    { --__i } -> same_as<_Iter&>;
-    { __i-- } -> same_as<_Iter>;
-  };
+template <class _Iter>
+concept __decrementable = incrementable<_Iter> && requires(_Iter __i) {
+  { --__i } -> same_as<_Iter&>;
+  { __i-- } -> same_as<_Iter>;
+};
 
-  template<class _Iter>
-  concept __advanceable =
+template <class _Iter>
+concept __advanceable =
     __decrementable<_Iter> && totally_ordered<_Iter> &&
     requires(_Iter __i, const _Iter __j, const _IotaDiffT<_Iter> __n) {
       { __i += __n } -> same_as<_Iter&>;
@@ -86,323 +91,306 @@ namespace ranges {
       { __j - __j } -> convertible_to<_IotaDiffT<_Iter>>;
     };
 
-  template<class>
-  struct __iota_iterator_category {};
+template <class>
+struct __iota_iterator_category {};
 
-  template<incrementable _Tp>
-  struct __iota_iterator_category<_Tp> {
-    using iterator_category = input_iterator_tag;
-  };
+template <incrementable _Tp>
+struct __iota_iterator_category<_Tp> {
+  using iterator_category = input_iterator_tag;
+};
 
-  template <weakly_incrementable _Start, semiregular _BoundSentinel = unreachable_sentinel_t>
-    requires __weakly_equality_comparable_with<_Start, _BoundSentinel> && copyable<_Start>
-  class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {
-    struct __iterator : public __iota_iterator_category<_Start> {
-      friend class iota_view;
+template <weakly_incrementable _Start, semiregular _BoundSentinel = unreachable_sentinel_t>
+  requires __weakly_equality_comparable_with<_Start, _BoundSentinel> && copyable<_Start>
+class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {
+  struct __iterator : public __iota_iterator_category<_Start> {
+    friend class iota_view;
 
-      using iterator_concept =
-        _If<__advanceable<_Start>,   random_access_iterator_tag,
-        _If<__decrementable<_Start>, bidirectional_iterator_tag,
-        _If<incrementable<_Start>,   forward_iterator_tag,
-        /*Else*/                     input_iterator_tag>>>;
+    using iterator_concept =
+        _If<__advanceable<_Start>,
+            random_access_iterator_tag,
+            _If<__decrementable<_Start>,
+                bidirectional_iterator_tag,
+                _If<incrementable<_Start>,
+                    forward_iterator_tag,
+                    /*Else*/ input_iterator_tag>>>;
 
-      using value_type = _Start;
-      using difference_type = _IotaDiffT<_Start>;
-
-      _Start __value_ = _Start();
-
-      _LIBCPP_HIDE_FROM_ABI
-      __iterator() requires default_initializable<_Start> = default;
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr explicit __iterator(_Start __value) : __value_(std::move(__value)) {}
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr _Start operator*() const noexcept(is_nothrow_copy_constructible_v<_Start>) {
-        return __value_;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator++() {
-        ++__value_;
-        return *this;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr void operator++(int) { ++*this; }
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator operator++(int) requires incrementable<_Start> {
-        auto __tmp = *this;
-        ++*this;
-        return __tmp;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator--() requires __decrementable<_Start> {
-        --__value_;
-        return *this;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator  operator--(int) requires __decrementable<_Start> {
-        auto __tmp = *this;
-        --*this;
-        return __tmp;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator+=(difference_type __n)
-        requires __advanceable<_Start>
-      {
-        if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
-          if (__n >= difference_type(0)) {
-            __value_ += static_cast<_Start>(__n);
-          } else {
-            __value_ -= static_cast<_Start>(-__n);
-          }
-        } else {
-          __value_ += __n;
-        }
-        return *this;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __iterator& operator-=(difference_type __n)
-        requires __advanceable<_Start>
-      {
-        if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
-          if (__n >= difference_type(0)) {
-            __value_ -= static_cast<_Start>(__n);
-          } else {
-            __value_ += static_cast<_Start>(-__n);
-          }
-        } else {
-          __value_ -= __n;
-        }
-        return *this;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr _Start operator[](difference_type __n) const
-        requires __advanceable<_Start>
-      {
-        return _Start(__value_ + __n);
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
-        requires equality_comparable<_Start>
-      {
-        return __x.__value_ == __y.__value_;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return __x.__value_ < __y.__value_;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return __y < __x;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return !(__y < __x);
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start>
-      {
-        return !(__x < __y);
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
-        requires totally_ordered<_Start> && three_way_comparable<_Start>
-      {
-        return __x.__value_ <=> __y.__value_;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr __iterator operator+(__iterator __i, difference_type __n)
-        requires __advanceable<_Start>
-      {
-        __i += __n;
-        return __i;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr __iterator operator+(difference_type __n, __iterator __i)
-        requires __advanceable<_Start>
-      {
-        return __i + __n;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr __iterator operator-(__iterator __i, difference_type __n)
-        requires __advanceable<_Start>
-      {
-        __i -= __n;
-        return __i;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
-        requires __advanceable<_Start>
-      {
-        if constexpr (__integer_like<_Start>) {
-          if constexpr (__signed_integer_like<_Start>) {
-            return difference_type(difference_type(__x.__value_) - difference_type(__y.__value_));
-          }
-          if (__y.__value_ > __x.__value_) {
-            return difference_type(-difference_type(__y.__value_ - __x.__value_));
-          }
-          return difference_type(__x.__value_ - __y.__value_);
-        }
-        return __x.__value_ - __y.__value_;
-      }
-    };
-
-    struct __sentinel {
-      friend class iota_view;
-
-    private:
-      _BoundSentinel __bound_sentinel_ = _BoundSentinel();
-
-    public:
-      _LIBCPP_HIDE_FROM_ABI
-      __sentinel() = default;
-      _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(_BoundSentinel __bound_sentinel)
-          : __bound_sentinel_(std::move(__bound_sentinel)) {}
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr bool operator==(const __iterator& __x, const __sentinel& __y) {
-        return __x.__value_ == __y.__bound_sentinel_;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr iter_difference_t<_Start> operator-(const __iterator& __x, const __sentinel& __y)
-        requires sized_sentinel_for<_BoundSentinel, _Start>
-      {
-        return __x.__value_ - __y.__bound_sentinel_;
-      }
-
-      _LIBCPP_HIDE_FROM_ABI
-      friend constexpr iter_difference_t<_Start> operator-(const __sentinel& __x, const __iterator& __y)
-        requires sized_sentinel_for<_BoundSentinel, _Start>
-      {
-        return -(__y - __x);
-      }
-    };
+    using value_type      = _Start;
+    using difference_type = _IotaDiffT<_Start>;
 
     _Start __value_ = _Start();
+
+    _LIBCPP_HIDE_FROM_ABI __iterator()
+      requires default_initializable<_Start>
+    = default;
+
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(_Start __value) : __value_(std::move(__value)) {}
+
+    _LIBCPP_HIDE_FROM_ABI constexpr _Start operator*() const noexcept(is_nothrow_copy_constructible_v<_Start>) {
+      return __value_;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+      ++__value_;
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
+      requires incrementable<_Start>
+    {
+      auto __tmp = *this;
+      ++*this;
+      return __tmp;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+      requires __decrementable<_Start>
+    {
+      --__value_;
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+      requires __decrementable<_Start>
+    {
+      auto __tmp = *this;
+      --*this;
+      return __tmp;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __n)
+      requires __advanceable<_Start>
+    {
+      if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
+        if (__n >= difference_type(0)) {
+          __value_ += static_cast<_Start>(__n);
+        } else {
+          __value_ -= static_cast<_Start>(-__n);
+        }
+      } else {
+        __value_ += __n;
+      }
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __n)
+      requires __advanceable<_Start>
+    {
+      if constexpr (__integer_like<_Start> && !__signed_integer_like<_Start>) {
+        if (__n >= difference_type(0)) {
+          __value_ -= static_cast<_Start>(__n);
+        } else {
+          __value_ += static_cast<_Start>(-__n);
+        }
+      } else {
+        __value_ -= __n;
+      }
+      return *this;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI constexpr _Start operator[](difference_type __n) const
+      requires __advanceable<_Start>
+    {
+      return _Start(__value_ + __n);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+      requires equality_comparable<_Start>
+    {
+      return __x.__value_ == __y.__value_;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+      requires totally_ordered<_Start>
+    {
+      return __x.__value_ < __y.__value_;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+      requires totally_ordered<_Start>
+    {
+      return __y < __x;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+      requires totally_ordered<_Start>
+    {
+      return !(__y < __x);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+      requires totally_ordered<_Start>
+    {
+      return !(__x < __y);
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+      requires totally_ordered<_Start> && three_way_comparable<_Start>
+    {
+      return __x.__value_ <=> __y.__value_;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(__iterator __i, difference_type __n)
+      requires __advanceable<_Start>
+    {
+      __i += __n;
+      return __i;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, __iterator __i)
+      requires __advanceable<_Start>
+    {
+      return __i + __n;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(__iterator __i, difference_type __n)
+      requires __advanceable<_Start>
+    {
+      __i -= __n;
+      return __i;
+    }
+
+    _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+      requires __advanceable<_Start>
+    {
+      if constexpr (__integer_like<_Start>) {
+        if constexpr (__signed_integer_like<_Start>) {
+          return difference_type(difference_type(__x.__value_) - difference_type(__y.__value_));
+        }
+        if (__y.__value_ > __x.__value_) {
+          return difference_type(-difference_type(__y.__value_ - __x.__value_));
+        }
+        return difference_type(__x.__value_ - __y.__value_);
+      }
+      return __x.__value_ - __y.__value_;
+    }
+  };
+
+  struct __sentinel {
+    friend class iota_view;
+
+  private:
     _BoundSentinel __bound_sentinel_ = _BoundSentinel();
 
   public:
-    _LIBCPP_HIDE_FROM_ABI
-    iota_view() requires default_initializable<_Start> = default;
+    _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(_BoundSentinel __bound_sentinel)
+        : __bound_sentinel_(std::move(__bound_sentinel)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit iota_view(_Start __value) : __value_(std::move(__value)) { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(type_identity_t<_Start> __value, type_identity_t<_BoundSentinel> __bound_sentinel)
-        : __value_(std::move(__value)), __bound_sentinel_(std::move(__bound_sentinel)) {
-      // Validate the precondition if possible.
-      if constexpr (totally_ordered_with<_Start, _BoundSentinel>) {
-        _LIBCPP_ASSERT(ranges::less_equal()(__value_, __bound_sentinel_),
-                       "Precondition violated: value is greater than bound.");
-      }
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __sentinel& __y) {
+      return __x.__value_ == __y.__bound_sentinel_;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, __iterator __last)
-      requires same_as<_Start, _BoundSentinel>
-    : iota_view(std::move(__first.__value_), std::move(__last.__value_)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, _BoundSentinel __last)
-      requires same_as<_BoundSentinel, unreachable_sentinel_t>
-    : iota_view(std::move(__first.__value_), std::move(__last)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, __sentinel __last)
-      requires(!same_as<_Start, _BoundSentinel> && !same_as<_BoundSentinel, unreachable_sentinel_t>)
-    : iota_view(std::move(__first.__value_), std::move(__last.__bound_sentinel_)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator begin() const { return __iterator{__value_}; }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() const {
-      if constexpr (same_as<_BoundSentinel, unreachable_sentinel_t>)
-        return unreachable_sentinel;
-      else
-        return __sentinel{__bound_sentinel_};
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator end() const
-      requires same_as<_Start, _BoundSentinel>
+    _LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_Start>
+    operator-(const __iterator& __x, const __sentinel& __y)
+      requires sized_sentinel_for<_BoundSentinel, _Start>
     {
-      return __iterator{__bound_sentinel_};
+      return __x.__value_ - __y.__bound_sentinel_;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() const
-      requires(same_as<_Start, _BoundSentinel> && __advanceable<_Start>) ||
-              (integral<_Start> && integral<_BoundSentinel>) || sized_sentinel_for<_BoundSentinel, _Start>
+    _LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_Start>
+    operator-(const __sentinel& __x, const __iterator& __y)
+      requires sized_sentinel_for<_BoundSentinel, _Start>
     {
-      if constexpr (__integer_like<_Start> && __integer_like<_BoundSentinel>) {
-        if (__value_ < 0) {
-          if (__bound_sentinel_ < 0) {
-            return std::__to_unsigned_like(-__value_) - std::__to_unsigned_like(-__bound_sentinel_);
-          }
-          return std::__to_unsigned_like(__bound_sentinel_) + std::__to_unsigned_like(-__value_);
-        }
-        return std::__to_unsigned_like(__bound_sentinel_) - std::__to_unsigned_like(__value_);
-      }
+      return -(__y - __x);
+    }
+  };
+
+  _Start __value_                  = _Start();
+  _BoundSentinel __bound_sentinel_ = _BoundSentinel();
+
+public:
+  _LIBCPP_HIDE_FROM_ABI iota_view()
+    requires default_initializable<_Start>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit iota_view(_Start __value) : __value_(std::move(__value)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23
+  iota_view(type_identity_t<_Start> __value, type_identity_t<_BoundSentinel> __bound_sentinel)
+      : __value_(std::move(__value)), __bound_sentinel_(std::move(__bound_sentinel)) {
+    // Validate the precondition if possible.
+    if constexpr (totally_ordered_with<_Start, _BoundSentinel>) {
+      _LIBCPP_ASSERT_VALID_INPUT_RANGE(
+          bool(__value_ <= __bound_sentinel_), "iota_view: bound must be reachable from value");
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, __iterator __last)
+    requires same_as<_Start, _BoundSentinel>
+      : iota_view(std::move(__first.__value_), std::move(__last.__value_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, _BoundSentinel __last)
+    requires same_as<_BoundSentinel, unreachable_sentinel_t>
+      : iota_view(std::move(__first.__value_), std::move(__last)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, __sentinel __last)
+    requires(!same_as<_Start, _BoundSentinel> && !same_as<_BoundSentinel, unreachable_sentinel_t>)
+      : iota_view(std::move(__first.__value_), std::move(__last.__bound_sentinel_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() const { return __iterator{__value_}; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const {
+    if constexpr (same_as<_BoundSentinel, unreachable_sentinel_t>)
+      return unreachable_sentinel;
+    else
+      return __sentinel{__bound_sentinel_};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator end() const
+    requires same_as<_Start, _BoundSentinel>
+  {
+    return __iterator{__bound_sentinel_};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const { return __value_ == __bound_sentinel_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires(same_as<_Start, _BoundSentinel> && __advanceable<_Start>) ||
+            (integral<_Start> && integral<_BoundSentinel>) || sized_sentinel_for<_BoundSentinel, _Start>
+  {
+    if constexpr (__integer_like<_Start> && __integer_like<_BoundSentinel>) {
+      return (__value_ < 0)
+               ? ((__bound_sentinel_ < 0)
+                      ? std::__to_unsigned_like(-__value_) - std::__to_unsigned_like(-__bound_sentinel_)
+                      : std::__to_unsigned_like(__bound_sentinel_) + std::__to_unsigned_like(-__value_))
+               : std::__to_unsigned_like(__bound_sentinel_) - std::__to_unsigned_like(__value_);
+    } else {
       return std::__to_unsigned_like(__bound_sentinel_ - __value_);
     }
-  };
+  }
+};
 
-  template <class _Start, class _BoundSentinel>
-    requires(!__integer_like<_Start> || !__integer_like<_BoundSentinel> ||
-             (__signed_integer_like<_Start> == __signed_integer_like<_BoundSentinel>))
-  iota_view(_Start, _BoundSentinel) -> iota_view<_Start, _BoundSentinel>;
+template <class _Start, class _BoundSentinel>
+  requires(!__integer_like<_Start> || !__integer_like<_BoundSentinel> ||
+           (__signed_integer_like<_Start> == __signed_integer_like<_BoundSentinel>))
+iota_view(_Start, _BoundSentinel) -> iota_view<_Start, _BoundSentinel>;
 
-  template <class _Start, class _BoundSentinel>
-  inline constexpr bool enable_borrowed_range<iota_view<_Start, _BoundSentinel>> = true;
+template <class _Start, class _BoundSentinel>
+inline constexpr bool enable_borrowed_range<iota_view<_Start, _BoundSentinel>> = true;
 
- namespace views {
- namespace __iota {
-  struct __fn {
-    template<class _Start>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Start&& __start) const
+namespace views {
+namespace __iota {
+struct __fn {
+  template <class _Start>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start) const
       noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start))))
-      -> decltype(      ranges::iota_view(std::forward<_Start>(__start)))
-      { return          ranges::iota_view(std::forward<_Start>(__start)); }
+          -> decltype(ranges::iota_view(std::forward<_Start>(__start))) {
+    return ranges::iota_view(std::forward<_Start>(__start));
+  }
 
-    template <class _Start, class _BoundSentinel>
-    _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start, _BoundSentinel&& __bound_sentinel) const
-      noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))))
-      -> decltype(      ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel)))
-      { return          ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel)); }
-  };
+  template <class _Start, class _BoundSentinel>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start, _BoundSentinel&& __bound_sentinel) const noexcept(
+      noexcept(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))))
+      -> decltype(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))) {
+    return ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel));
+  }
+};
 } // namespace __iota
 
 inline namespace __cpo {
-  inline constexpr auto iota = __iota::__fn{};
+inline constexpr auto iota = __iota::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
@@ -411,4 +399,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_IOTA_VIEW_H
diff --git a/third_party/libcxx/__ranges/istream_view.h b/third_party/libcxx/__ranges/istream_view.h
index 66cd91527..cd7096d35 100644
--- a/third_party/libcxx/__ranges/istream_view.h
+++ b/third_party/libcxx/__ranges/istream_view.h
@@ -14,6 +14,8 @@
 #include <__concepts/derived_from.h>
 #include <__concepts/movable.h>
 #include <__config>
+#include <__fwd/istream.h>
+#include <__fwd/string.h>
 #include <__iterator/default_sentinel.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
@@ -21,7 +23,6 @@
 #include <__type_traits/remove_cvref.h>
 #include <__utility/forward.h>
 #include <cstddef>
-#include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -65,8 +66,7 @@ public:
   using difference_type  = ptrdiff_t;
   using value_type       = _Val;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(
-      basic_istream_view<_Val, _CharT, _Traits>& __parent) noexcept
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(basic_istream_view<_Val, _CharT, _Traits>& __parent) noexcept
       : __parent_(std::addressof(__parent)) {}
 
   __iterator(const __iterator&)                  = delete;
diff --git a/third_party/libcxx/__ranges/join_view.h b/third_party/libcxx/__ranges/join_view.h
index e6240dfd2..9c2c77995 100644
--- a/third_party/libcxx/__ranges/join_view.h
+++ b/third_party/libcxx/__ranges/join_view.h
@@ -32,6 +32,8 @@
 #include <__ranges/view_interface.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/maybe_const.h>
+#include <__utility/as_lvalue.h>
+#include <__utility/empty.h>
 #include <__utility/forward.h>
 #include <optional>
 
@@ -39,366 +41,342 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-// Note: `join_view` is still marked experimental because there is an ABI-breaking change that affects `join_view` in
-// the pipeline (https://isocpp.org/files/papers/D2770R0.html).
-// TODO: make `join_view` non-experimental once D2770 is implemented.
-#if _LIBCPP_STD_VER >= 20 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+#if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<class>
-  struct __join_view_iterator_category {};
+template <class>
+struct __join_view_iterator_category {};
 
-  template<class _View>
-    requires is_reference_v<range_reference_t<_View>> &&
-             forward_range<_View> &&
-             forward_range<range_reference_t<_View>>
-  struct __join_view_iterator_category<_View> {
-    using _OuterC = typename iterator_traits<iterator_t<_View>>::iterator_category;
-    using _InnerC = typename iterator_traits<iterator_t<range_reference_t<_View>>>::iterator_category;
+template <class _View>
+  requires is_reference_v<range_reference_t<_View>> && forward_range<_View> && forward_range<range_reference_t<_View>>
+struct __join_view_iterator_category<_View> {
+  using _OuterC = typename iterator_traits<iterator_t<_View>>::iterator_category;
+  using _InnerC = typename iterator_traits<iterator_t<range_reference_t<_View>>>::iterator_category;
 
-    using iterator_category = _If<
-      derived_from<_OuterC, bidirectional_iterator_tag> && derived_from<_InnerC, bidirectional_iterator_tag> &&
-        common_range<range_reference_t<_View>>,
-      bidirectional_iterator_tag,
-      _If<
-        derived_from<_OuterC, forward_iterator_tag> && derived_from<_InnerC, forward_iterator_tag>,
-        forward_iterator_tag,
-        input_iterator_tag
-      >
-    >;
-  };
+  using iterator_category =
+      _If< derived_from<_OuterC, bidirectional_iterator_tag> && derived_from<_InnerC, bidirectional_iterator_tag> &&
+               common_range<range_reference_t<_View>>,
+           bidirectional_iterator_tag,
+           _If< derived_from<_OuterC, forward_iterator_tag> && derived_from<_InnerC, forward_iterator_tag>,
+                forward_iterator_tag,
+                input_iterator_tag > >;
+};
 
-  template<input_range _View>
-    requires view<_View> && input_range<range_reference_t<_View>>
-  class join_view
-    : public view_interface<join_view<_View>> {
-  private:
-    using _InnerRange = range_reference_t<_View>;
+template <input_range _View>
+  requires view<_View> && input_range<range_reference_t<_View>>
+class join_view : public view_interface<join_view<_View>> {
+private:
+  using _InnerRange = range_reference_t<_View>;
 
-    template<bool> struct __iterator;
+  template <bool>
+  struct __iterator;
 
-    template<bool> struct __sentinel;
+  template <bool>
+  struct __sentinel;
 
-    template <class>
-    friend struct std::__segmented_iterator_traits;
+  template <class>
+  friend struct std::__segmented_iterator_traits;
 
-    static constexpr bool _UseCache = !is_reference_v<_InnerRange>;
-    using _Cache = _If<_UseCache, __non_propagating_cache<remove_cvref_t<_InnerRange>>, __empty_cache>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cache_;
-    _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
 
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    join_view() requires default_initializable<_View> = default;
+  static constexpr bool _UseOuterCache = !forward_range<_View>;
+  using _OuterCache                    = _If<_UseOuterCache, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _OuterCache __outer_;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit join_view(_View __base)
-      : __base_(std::move(__base)) {}
+  static constexpr bool _UseInnerCache = !is_reference_v<_InnerRange>;
+  using _InnerCache = _If<_UseInnerCache, __non_propagating_cache<remove_cvref_t<_InnerRange>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _InnerCache __inner_;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+public:
+  _LIBCPP_HIDE_FROM_ABI join_view()
+    requires default_initializable<_View>
+  = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() && { return std::move(__base_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit join_view(_View __base) : __base_(std::move(__base)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto begin() {
-      constexpr bool __use_const = __simple_view<_View> &&
-                                   is_reference_v<range_reference_t<_View>>;
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() {
+    if constexpr (forward_range<_View>) {
+      constexpr bool __use_const = __simple_view<_View> && is_reference_v<range_reference_t<_View>>;
       return __iterator<__use_const>{*this, ranges::begin(__base_)};
+    } else {
+      __outer_.__emplace(ranges::begin(__base_));
+      return __iterator<false>{*this};
     }
+  }
 
-    template<class _V2 = _View>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto begin() const
-      requires input_range<const _V2> &&
-               is_reference_v<range_reference_t<const _V2>>
-    {
-      return __iterator<true>{*this, ranges::begin(__base_)};
+  template <class _V2 = _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires forward_range<const _V2> && is_reference_v<range_reference_t<const _V2>> &&
+             input_range<range_reference_t<const _V2>>
+  {
+    return __iterator<true>{*this, ranges::begin(__base_)};
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
+    if constexpr (forward_range<_View> && is_reference_v<_InnerRange> && forward_range<_InnerRange> &&
+                  common_range<_View> && common_range<_InnerRange>)
+      return __iterator<__simple_view<_View>>{*this, ranges::end(__base_)};
+    else
+      return __sentinel<__simple_view<_View>>{*this};
+  }
+
+  template <class _V2 = _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires forward_range<const _V2> && is_reference_v<range_reference_t<const _V2>> &&
+             input_range<range_reference_t<const _V2>>
+  {
+    using _ConstInnerRange = range_reference_t<const _View>;
+    if constexpr (forward_range<_ConstInnerRange> && common_range<const _View> && common_range<_ConstInnerRange>) {
+      return __iterator<true>{*this, ranges::end(__base_)};
+    } else {
+      return __sentinel<true>{*this};
     }
+  }
+};
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() {
-      if constexpr (forward_range<_View> &&
-                    is_reference_v<_InnerRange> &&
-                    forward_range<_InnerRange> &&
-                    common_range<_View> &&
-                    common_range<_InnerRange>)
-        return __iterator<__simple_view<_View>>{*this, ranges::end(__base_)};
-      else
-        return __sentinel<__simple_view<_View>>{*this};
-    }
+template <input_range _View>
+  requires view<_View> && input_range<range_reference_t<_View>>
+template <bool _Const>
+struct join_view<_View>::__sentinel {
+private:
+  template <bool>
+  friend struct __sentinel;
 
-    template<class _V2 = _View>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() const
-      requires input_range<const _V2> &&
-               is_reference_v<range_reference_t<const _V2>>
-    {
-      using _ConstInnerRange = range_reference_t<const _View>;
-      if constexpr (forward_range<const _View> &&
-                    is_reference_v<_ConstInnerRange> &&
-                    forward_range<_ConstInnerRange> &&
-                    common_range<const _View> &&
-                    common_range<_ConstInnerRange>) {
-        return __iterator<true>{*this, ranges::end(__base_)};
-      } else {
-        return __sentinel<true>{*this};
-      }
-    }
-  };
+  using _Parent            = __maybe_const<_Const, join_view>;
+  using _Base              = __maybe_const<_Const, _View>;
+  sentinel_t<_Base> __end_ = sentinel_t<_Base>();
 
-  template<input_range _View>
-    requires view<_View> && input_range<range_reference_t<_View>>
-  template<bool _Const>
-  struct join_view<_View>::__sentinel {
-  template<bool>
-    friend struct __sentinel;
+public:
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
 
-  private:
-    using _Parent = __maybe_const<_Const, join_view<_View>>;
-    using _Base = __maybe_const<_Const, _View>;
-    sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(_Parent& __parent) : __end_(ranges::end(__parent.__base_)) {}
 
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    __sentinel() = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __sentinel(_Parent& __parent)
-      : __end_(ranges::end(__parent.__base_)) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __sentinel(__sentinel<!_Const> __s)
-      requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __s)
+    requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
       : __end_(std::move(__s.__end_)) {}
 
-    template<bool _OtherConst>
-      requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
-      return __x.__outer_ == __y.__end_;
-    }
-  };
+  template <bool _OtherConst>
+    requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+    return __x.__get_outer() == __y.__end_;
+  }
+};
 
-  // https://reviews.llvm.org/D142811#inline-1383022
-  // To simplify the segmented iterator traits specialization,
-  // make the iterator `final`
-  template<input_range _View>
-    requires view<_View> && input_range<range_reference_t<_View>>
-  template<bool _Const>
-  struct join_view<_View>::__iterator final
-    : public __join_view_iterator_category<__maybe_const<_Const, _View>> {
+// https://reviews.llvm.org/D142811#inline-1383022
+// To simplify the segmented iterator traits specialization,
+// make the iterator `final`
+template <input_range _View>
+  requires view<_View> && input_range<range_reference_t<_View>>
+template <bool _Const>
+struct join_view<_View>::__iterator final : public __join_view_iterator_category<__maybe_const<_Const, _View>> {
+  friend join_view;
 
-    template<bool>
-    friend struct __iterator;
+  template <class>
+  friend struct std::__segmented_iterator_traits;
 
-    template <class>
-    friend struct std::__segmented_iterator_traits;
+  static constexpr bool __is_join_view_iterator = true;
 
-    static constexpr bool __is_join_view_iterator = true;
+private:
+  using _Parent     = __maybe_const<_Const, join_view<_View>>;
+  using _Base       = __maybe_const<_Const, _View>;
+  using _Outer      = iterator_t<_Base>;
+  using _Inner      = iterator_t<range_reference_t<_Base>>;
+  using _InnerRange = range_reference_t<_View>;
 
-  private:
-    using _Parent = __maybe_const<_Const, join_view<_View>>;
-    using _Base = __maybe_const<_Const, _View>;
-    using _Outer = iterator_t<_Base>;
-    using _Inner = iterator_t<range_reference_t<_Base>>;
-    using _InnerRange = range_reference_t<_View>;
+  static_assert(!_Const || forward_range<_Base>, "Const can only be true when Base models forward_range.");
 
-    static constexpr bool __ref_is_glvalue = is_reference_v<range_reference_t<_Base>>;
+  static constexpr bool __ref_is_glvalue = is_reference_v<range_reference_t<_Base>>;
 
-  public:
-    _Outer __outer_ = _Outer();
+  static constexpr bool _OuterPresent           = forward_range<_Base>;
+  using _OuterType                              = _If<_OuterPresent, _Outer, std::__empty>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _OuterType __outer_ = _OuterType();
 
-  private:
-    optional<_Inner> __inner_;
-    _Parent *__parent_ = nullptr;
+  optional<_Inner> __inner_;
+  _Parent* __parent_ = nullptr;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void __satisfy() {
-      for (; __outer_ != ranges::end(__parent_->__base_); ++__outer_) {
-        auto&& __inner = [&]() -> auto&& {
-          if constexpr (__ref_is_glvalue)
-            return *__outer_;
-          else
-            return __parent_->__cache_.__emplace_from([&]() -> decltype(auto) { return *__outer_; });
-        }();
-        __inner_ = ranges::begin(__inner);
-        if (*__inner_ != ranges::end(__inner))
-          return;
-      }
-
-      if constexpr (__ref_is_glvalue)
-        __inner_.reset();
+  _LIBCPP_HIDE_FROM_ABI constexpr void __satisfy() {
+    for (; __get_outer() != ranges::end(__parent_->__base_); ++__get_outer()) {
+      auto&& __inner = [this]() -> auto&& {
+        if constexpr (__ref_is_glvalue)
+          return *__get_outer();
+        else
+          return __parent_->__inner_.__emplace_from([&]() -> decltype(auto) { return *__get_outer(); });
+      }();
+      __inner_ = ranges::begin(__inner);
+      if (*__inner_ != ranges::end(__inner))
+        return;
     }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent* __parent, _Outer __outer, _Inner __inner)
+    if constexpr (__ref_is_glvalue)
+      __inner_.reset();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Outer& __get_outer() {
+    if constexpr (forward_range<_Base>) {
+      return __outer_;
+    } else {
+      return *__parent_->__outer_;
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Outer& __get_outer() const {
+    if constexpr (forward_range<_Base>) {
+      return __outer_;
+    } else {
+      return *__parent_->__outer_;
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent& __parent, _Outer __outer)
+    requires forward_range<_Base>
+      : __outer_(std::move(__outer)), __parent_(std::addressof(__parent)) {
+    __satisfy();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(_Parent& __parent)
+    requires(!forward_range<_Base>)
+      : __parent_(std::addressof(__parent)) {
+    __satisfy();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent* __parent, _Outer __outer, _Inner __inner)
+    requires forward_range<_Base>
       : __outer_(std::move(__outer)), __inner_(std::move(__inner)), __parent_(__parent) {}
 
-  public:
-    using iterator_concept = _If<
-      __ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<range_reference_t<_Base>> &&
-          common_range<range_reference_t<_Base>>,
-      bidirectional_iterator_tag,
-      _If<
-        __ref_is_glvalue && forward_range<_Base> && forward_range<range_reference_t<_Base>>,
-        forward_iterator_tag,
-        input_iterator_tag
-      >
-    >;
+public:
+  using iterator_concept =
+      _If< __ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<range_reference_t<_Base>> &&
+               common_range<range_reference_t<_Base>>,
+           bidirectional_iterator_tag,
+           _If< __ref_is_glvalue && forward_range<_Base> && forward_range<range_reference_t<_Base>>,
+                forward_iterator_tag,
+                input_iterator_tag > >;
 
-    using value_type = range_value_t<range_reference_t<_Base>>;
+  using value_type = range_value_t<range_reference_t<_Base>>;
 
-    using difference_type = common_type_t<
-      range_difference_t<_Base>, range_difference_t<range_reference_t<_Base>>>;
+  using difference_type = common_type_t< range_difference_t<_Base>, range_difference_t<range_reference_t<_Base>>>;
 
-    _LIBCPP_HIDE_FROM_ABI
-    __iterator() requires default_initializable<_Outer> = default;
+  _LIBCPP_HIDE_FROM_ABI __iterator() = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator(_Parent& __parent, _Outer __outer)
-      : __outer_(std::move(__outer))
-      , __parent_(std::addressof(__parent)) {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
+    requires _Const && convertible_to<iterator_t<_View>, _Outer> && convertible_to<iterator_t<_InnerRange>, _Inner>
+      : __outer_(std::move(__i.__outer_)), __inner_(std::move(__i.__inner_)), __parent_(__i.__parent_) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const { return **__inner_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Inner operator->() const
+    requires __has_arrow<_Inner> && copyable<_Inner>
+  {
+    return *__inner_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    auto __get_inner_range = [&]() -> decltype(auto) {
+      if constexpr (__ref_is_glvalue)
+        return *__get_outer();
+      else
+        return *__parent_->__inner_;
+    };
+    if (++*__inner_ == ranges::end(std::__as_lvalue(__get_inner_range()))) {
+      ++__get_outer();
       __satisfy();
     }
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator(__iterator<!_Const> __i)
-      requires _Const &&
-               convertible_to<iterator_t<_View>, _Outer> &&
-               convertible_to<iterator_t<_InnerRange>, _Inner>
-      : __outer_(std::move(__i.__outer_))
-      , __inner_(std::move(__i.__inner_))
-      , __parent_(__i.__parent_) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator*() const {
-      return **__inner_;
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
+    requires __ref_is_glvalue && forward_range<_Base> && forward_range<range_reference_t<_Base>>
+  {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires __ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<range_reference_t<_Base>> &&
+             common_range<range_reference_t<_Base>>
+  {
+    if (__outer_ == ranges::end(__parent_->__base_))
+      __inner_ = ranges::end(std::__as_lvalue(*--__outer_));
+
+    // Skip empty inner ranges when going backwards.
+    while (*__inner_ == ranges::begin(std::__as_lvalue(*__outer_))) {
+      __inner_ = ranges::end(std::__as_lvalue(*--__outer_));
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Inner operator->() const
-      requires __has_arrow<_Inner> && copyable<_Inner>
-    {
-      return *__inner_;
-    }
+    --*__inner_;
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator& operator++() {
-      auto&& __inner = [&]() -> auto&& {
-        if constexpr (__ref_is_glvalue)
-          return *__outer_;
-        else
-          return *__parent_->__cache_;
-      }();
-      if (++*__inner_ == ranges::end(__inner)) {
-        ++__outer_;
-        __satisfy();
-      }
-      return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires __ref_is_glvalue && bidirectional_range<_Base> && bidirectional_range<range_reference_t<_Base>> &&
+             common_range<range_reference_t<_Base>>
+  {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void operator++(int) {
-      ++*this;
-    }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+    requires __ref_is_glvalue && forward_range<_Base> && equality_comparable<iterator_t<range_reference_t<_Base>>>
+  {
+    return __x.__outer_ == __y.__outer_ && __x.__inner_ == __y.__inner_;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator operator++(int)
-      requires __ref_is_glvalue &&
-               forward_range<_Base> &&
-               forward_range<range_reference_t<_Base>>
-    {
-      auto __tmp = *this;
-      ++*this;
-      return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr decltype(auto)
+  iter_move(const __iterator& __i) noexcept(noexcept(ranges::iter_move(*__i.__inner_))) {
+    return ranges::iter_move(*__i.__inner_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator& operator--()
-      requires __ref_is_glvalue &&
-               bidirectional_range<_Base> &&
-               bidirectional_range<range_reference_t<_Base>> &&
-               common_range<range_reference_t<_Base>>
-    {
-      if (__outer_ == ranges::end(__parent_->__base_))
-        __inner_ = ranges::end(*--__outer_);
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void
+  iter_swap(const __iterator& __x,
+            const __iterator& __y) noexcept(noexcept(ranges::iter_swap(*__x.__inner_, *__y.__inner_)))
+    requires indirectly_swappable<_Inner>
+  {
+    return ranges::iter_swap(*__x.__inner_, *__y.__inner_);
+  }
+};
 
-      // Skip empty inner ranges when going backwards.
-      while (*__inner_ == ranges::begin(*__outer_)) {
-        __inner_ = ranges::end(*--__outer_);
-      }
-
-      --*__inner_;
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __iterator operator--(int)
-      requires __ref_is_glvalue &&
-               bidirectional_range<_Base> &&
-               bidirectional_range<range_reference_t<_Base>> &&
-               common_range<range_reference_t<_Base>>
-    {
-      auto __tmp = *this;
-      --*this;
-      return __tmp;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
-      requires __ref_is_glvalue &&
-               equality_comparable<iterator_t<_Base>> &&
-               equality_comparable<iterator_t<range_reference_t<_Base>>>
-    {
-      return __x.__outer_ == __y.__outer_ && __x.__inner_ == __y.__inner_;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr decltype(auto) iter_move(const __iterator& __i)
-      noexcept(noexcept(ranges::iter_move(*__i.__inner_)))
-    {
-      return ranges::iter_move(*__i.__inner_);
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr void iter_swap(const __iterator& __x, const __iterator& __y)
-      noexcept(noexcept(ranges::iter_swap(*__x.__inner_, *__y.__inner_)))
-      requires indirectly_swappable<_Inner>
-    {
-      return ranges::iter_swap(*__x.__inner_, *__y.__inner_);
-    }
-  };
-
-  template<class _Range>
-  explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
+template <class _Range>
+explicit join_view(_Range&&) -> join_view<views::all_t<_Range>>;
 
 namespace views {
 namespace __join_view {
 struct __fn : __range_adaptor_closure<__fn> {
-  template<class _Range>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range) const
-    noexcept(noexcept(join_view<all_t<_Range&&>>(std::forward<_Range>(__range))))
-    -> decltype(      join_view<all_t<_Range&&>>(std::forward<_Range>(__range)))
-    { return          join_view<all_t<_Range&&>>(std::forward<_Range>(__range)); }
+  template <class _Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(join_view<all_t<_Range&&>>(std::forward<_Range>(__range))))
+          -> decltype(join_view<all_t<_Range&&>>(std::forward<_Range>(__range))) {
+    return join_view<all_t<_Range&&>>(std::forward<_Range>(__range));
+  }
 };
 } // namespace __join_view
 inline namespace __cpo {
-  inline constexpr auto join = __join_view::__fn{};
+inline constexpr auto join = __join_view::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
 
 template <class _JoinViewIterator>
-  requires(_JoinViewIterator::__is_join_view_iterator &&
-           ranges::common_range<typename _JoinViewIterator::_Parent> &&
+  requires(_JoinViewIterator::__is_join_view_iterator && ranges::common_range<typename _JoinViewIterator::_Parent> &&
            __has_random_access_iterator_category<typename _JoinViewIterator::_Outer>::value &&
            __has_random_access_iterator_category<typename _JoinViewIterator::_Inner>::value)
 struct __segmented_iterator_traits<_JoinViewIterator> {
-
   using __segment_iterator =
       _LIBCPP_NODEBUG __iterator_with_data<typename _JoinViewIterator::_Outer, typename _JoinViewIterator::_Parent*>;
   using __local_iterator = typename _JoinViewIterator::_Inner;
@@ -406,38 +384,40 @@ struct __segmented_iterator_traits<_JoinViewIterator> {
   // TODO: Would it make sense to enable the optimization for other iterator types?
 
   static constexpr _LIBCPP_HIDE_FROM_ABI __segment_iterator __segment(_JoinViewIterator __iter) {
-      if (ranges::empty(__iter.__parent_->__base_))
-        return {};
-      if (!__iter.__inner_.has_value())
-        return __segment_iterator(--__iter.__outer_, __iter.__parent_);
-      return __segment_iterator(__iter.__outer_, __iter.__parent_);
+    if (ranges::empty(__iter.__parent_->__base_))
+      return {};
+    if (!__iter.__inner_.has_value())
+      return __segment_iterator(--__iter.__outer_, __iter.__parent_);
+    return __segment_iterator(__iter.__outer_, __iter.__parent_);
   }
 
   static constexpr _LIBCPP_HIDE_FROM_ABI __local_iterator __local(_JoinViewIterator __iter) {
-      if (ranges::empty(__iter.__parent_->__base_))
-        return {};
-      if (!__iter.__inner_.has_value())
-        return ranges::end(*--__iter.__outer_);
-      return *__iter.__inner_;
+    if (ranges::empty(__iter.__parent_->__base_))
+      return {};
+    if (!__iter.__inner_.has_value())
+      return ranges::end(*--__iter.__outer_);
+    return *__iter.__inner_;
   }
 
   static constexpr _LIBCPP_HIDE_FROM_ABI __local_iterator __begin(__segment_iterator __iter) {
-      return ranges::begin(*__iter.__get_iter());
+    return ranges::begin(*__iter.__get_iter());
   }
 
   static constexpr _LIBCPP_HIDE_FROM_ABI __local_iterator __end(__segment_iterator __iter) {
-      return ranges::end(*__iter.__get_iter());
+    return ranges::end(*__iter.__get_iter());
   }
 
   static constexpr _LIBCPP_HIDE_FROM_ABI _JoinViewIterator
   __compose(__segment_iterator __seg_iter, __local_iterator __local_iter) {
-      return _JoinViewIterator(
-          std::move(__seg_iter).__get_data(), std::move(__seg_iter).__get_iter(), std::move(__local_iter));
+    return _JoinViewIterator(
+        std::move(__seg_iter).__get_data(), std::move(__seg_iter).__get_iter(), std::move(__local_iter));
   }
 };
 
-#endif // #if _LIBCPP_STD_VER >= 20 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+#endif // #if _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_JOIN_VIEW_H
diff --git a/third_party/libcxx/__ranges/lazy_split_view.h b/third_party/libcxx/__ranges/lazy_split_view.h
index 186a0af32..db031fe5f 100644
--- a/third_party/libcxx/__ranges/lazy_split_view.h
+++ b/third_party/libcxx/__ranges/lazy_split_view.h
@@ -47,79 +47,82 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
 
-template <auto> struct __require_constant;
+template <auto>
+struct __require_constant;
 
 template <class _Range>
-concept __tiny_range =
-  sized_range<_Range> &&
-  requires { typename __require_constant<remove_reference_t<_Range>::size()>; } &&
-  (remove_reference_t<_Range>::size() <= 1);
+concept __tiny_range = sized_range<_Range> && requires {
+  typename __require_constant<remove_reference_t<_Range>::size()>;
+} && (remove_reference_t<_Range>::size() <= 1);
 
 template <input_range _View, forward_range _Pattern>
   requires view<_View> && view<_Pattern> &&
            indirectly_comparable<iterator_t<_View>, iterator_t<_Pattern>, ranges::equal_to> &&
            (forward_range<_View> || __tiny_range<_Pattern>)
 class lazy_split_view : public view_interface<lazy_split_view<_View, _Pattern>> {
-
-  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_       = _View();
   _LIBCPP_NO_UNIQUE_ADDRESS _Pattern __pattern_ = _Pattern();
 
   using _MaybeCurrent = _If<!forward_range<_View>, __non_propagating_cache<iterator_t<_View>>, __empty_cache>;
   _LIBCPP_NO_UNIQUE_ADDRESS _MaybeCurrent __current_ = _MaybeCurrent();
 
-  template <bool> struct __outer_iterator;
-  template <bool> struct __inner_iterator;
+  template <bool>
+  struct __outer_iterator;
+  template <bool>
+  struct __inner_iterator;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  lazy_split_view()
-    requires default_initializable<_View> && default_initializable<_Pattern> = default;
+  _LIBCPP_HIDE_FROM_ABI lazy_split_view()
+    requires default_initializable<_View> && default_initializable<_Pattern>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 lazy_split_view(_View __base, _Pattern __pattern)
-    : __base_(std::move(__base)), __pattern_(std::move(__pattern)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 lazy_split_view(_View __base, _Pattern __pattern)
+      : __base_(std::move(__base)), __pattern_(std::move(__pattern)) {}
 
   template <input_range _Range>
     requires constructible_from<_View, views::all_t<_Range>> &&
-             constructible_from<_Pattern, single_view<range_value_t<_Range>>>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
-    : __base_(views::all(std::forward<_Range>(__r)))
-    , __pattern_(views::single(std::move(__e))) {}
+                 constructible_from<_Pattern, single_view<range_value_t<_Range>>>
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
+      : __base_(views::all(std::forward<_Range>(__r))), __pattern_(views::single(std::move(__e))) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() && { return std::move(__base_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() {
     if constexpr (forward_range<_View>) {
-      return __outer_iterator<__simple_view<_View> && __simple_view<_Pattern>>{*this, ranges::begin(__base_)};
+      return __outer_iterator < __simple_view<_View> && __simple_view < _Pattern >> {*this, ranges::begin(__base_)};
     } else {
       __current_.__emplace(ranges::begin(__base_));
       return __outer_iterator<false>{*this};
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() const requires forward_range<_View> && forward_range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires forward_range<_View> && forward_range<const _View>
+  {
     return __outer_iterator<true>{*this, ranges::begin(__base_)};
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() requires forward_range<_View> && common_range<_View> {
-    return __outer_iterator<__simple_view<_View> && __simple_view<_Pattern>>{*this, ranges::end(__base_)};
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires forward_range<_View> && common_range<_View>
+  {
+    return __outer_iterator < __simple_view<_View> && __simple_view < _Pattern >> {*this, ranges::end(__base_)};
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() const {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const {
     if constexpr (forward_range<_View> && forward_range<const _View> && common_range<const _View>) {
       return __outer_iterator<true>{*this, ranges::end(__base_)};
     } else {
@@ -128,7 +131,6 @@ public:
   }
 
 private:
-
   template <class>
   struct __outer_iterator_category {};
 
@@ -145,15 +147,14 @@ private:
     friend __outer_iterator<true>;
 
     using _Parent = __maybe_const<_Const, lazy_split_view>;
-    using _Base = __maybe_const<_Const, _View>;
+    using _Base   = __maybe_const<_Const, _View>;
 
-    _Parent* __parent_ = nullptr;
-    using _MaybeCurrent = _If<forward_range<_View>, iterator_t<_Base>, __empty_cache>;
+    _Parent* __parent_                                 = nullptr;
+    using _MaybeCurrent                                = _If<forward_range<_View>, iterator_t<_Base>, __empty_cache>;
     _LIBCPP_NO_UNIQUE_ADDRESS _MaybeCurrent __current_ = _MaybeCurrent();
-    bool __trailing_empty_ = false;
+    bool __trailing_empty_                             = false;
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto& __current() noexcept {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto& __current() noexcept {
       if constexpr (forward_range<_View>) {
         return __current_;
       } else {
@@ -161,8 +162,7 @@ private:
       }
     }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr const auto& __current() const noexcept {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const auto& __current() const noexcept {
       if constexpr (forward_range<_View>) {
         return __current_;
       } else {
@@ -172,56 +172,42 @@ private:
 
     // Workaround for the GCC issue that doesn't allow calling `__parent_->__base_` from friend functions (because
     // `__base_` is private).
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto& __parent_base() const noexcept {
-      return __parent_->__base_;
-    }
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto& __parent_base() const noexcept { return __parent_->__base_; }
 
   public:
     // using iterator_category = inherited;
     using iterator_concept = conditional_t<forward_range<_Base>, forward_iterator_tag, input_iterator_tag>;
-    using difference_type = range_difference_t<_Base>;
+    using difference_type  = range_difference_t<_Base>;
 
     struct value_type : view_interface<value_type> {
     private:
       __outer_iterator __i_ = __outer_iterator();
 
     public:
-      _LIBCPP_HIDE_FROM_ABI
-      value_type() = default;
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr explicit value_type(__outer_iterator __i)
-        : __i_(std::move(__i)) {}
+      _LIBCPP_HIDE_FROM_ABI value_type() = default;
+      _LIBCPP_HIDE_FROM_ABI constexpr explicit value_type(__outer_iterator __i) : __i_(std::move(__i)) {}
 
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr __inner_iterator<_Const> begin() const { return __inner_iterator<_Const>{__i_}; }
-      _LIBCPP_HIDE_FROM_ABI
-      constexpr default_sentinel_t end() const noexcept { return default_sentinel; }
+      _LIBCPP_HIDE_FROM_ABI constexpr __inner_iterator<_Const> begin() const { return __inner_iterator<_Const>{__i_}; }
+      _LIBCPP_HIDE_FROM_ABI constexpr default_sentinel_t end() const noexcept { return default_sentinel; }
     };
 
-    _LIBCPP_HIDE_FROM_ABI
-    __outer_iterator() = default;
+    _LIBCPP_HIDE_FROM_ABI __outer_iterator() = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __outer_iterator(_Parent& __parent)
-      requires (!forward_range<_Base>)
-      : __parent_(std::addressof(__parent)) {}
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __outer_iterator(_Parent& __parent)
+      requires(!forward_range<_Base>)
+        : __parent_(std::addressof(__parent)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __outer_iterator(_Parent& __parent, iterator_t<_Base> __current)
+    _LIBCPP_HIDE_FROM_ABI constexpr __outer_iterator(_Parent& __parent, iterator_t<_Base> __current)
       requires forward_range<_Base>
-      : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
+        : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __outer_iterator(__outer_iterator<!_Const> __i)
+    _LIBCPP_HIDE_FROM_ABI constexpr __outer_iterator(__outer_iterator<!_Const> __i)
       requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
-      : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
+        : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr value_type operator*() const { return value_type{*this}; }
+    _LIBCPP_HIDE_FROM_ABI constexpr value_type operator*() const { return value_type{*this}; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __outer_iterator& operator++() {
+    _LIBCPP_HIDE_FROM_ABI constexpr __outer_iterator& operator++() {
       const auto __end = ranges::end(__parent_->__base_);
       if (__current() == __end) {
         __trailing_empty_ = false;
@@ -260,8 +246,7 @@ private:
       return *this;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator++(int) {
+    _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator++(int) {
       if constexpr (forward_range<_Base>) {
         auto __tmp = *this;
         ++*this;
@@ -272,15 +257,14 @@ private:
       }
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __outer_iterator& __x, const __outer_iterator& __y)
-      requires forward_range<_Base> {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __outer_iterator& __x, const __outer_iterator& __y)
+      requires forward_range<_Base>
+    {
       return __x.__current_ == __y.__current_ && __x.__trailing_empty_ == __y.__trailing_empty_;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __outer_iterator& __x, default_sentinel_t) {
-      _LIBCPP_ASSERT(__x.__parent_, "Cannot call comparison on a default-constructed iterator.");
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __outer_iterator& __x, default_sentinel_t) {
+      _LIBCPP_ASSERT_NON_NULL(__x.__parent_ != nullptr, "Cannot call comparison on a default-constructed iterator.");
       return __x.__current() == ranges::end(__x.__parent_base()) && !__x.__trailing_empty_;
     }
   };
@@ -290,11 +274,10 @@ private:
 
   template <forward_range _Tp>
   struct __inner_iterator_category<_Tp> {
-    using iterator_category = _If<
-      derived_from<typename iterator_traits<iterator_t<_Tp>>::iterator_category, forward_iterator_tag>,
-      forward_iterator_tag,
-      typename iterator_traits<iterator_t<_Tp>>::iterator_category
-    >;
+    using iterator_category =
+        _If< derived_from<typename iterator_traits<iterator_t<_Tp>>::iterator_category, forward_iterator_tag>,
+             forward_iterator_tag,
+             typename iterator_traits<iterator_t<_Tp>>::iterator_category >;
   };
 
   template <bool _Const>
@@ -303,18 +286,17 @@ private:
     using _Base = __maybe_const<_Const, _View>;
     // Workaround for a GCC issue.
     static constexpr bool _OuterConst = _Const;
-    __outer_iterator<_Const> __i_ = __outer_iterator<_OuterConst>();
-    bool __incremented_ = false;
+    __outer_iterator<_Const> __i_     = __outer_iterator<_OuterConst>();
+    bool __incremented_               = false;
 
     // Note: these private functions are necessary because GCC doesn't allow calls to private members of `__i_` from
     // free functions that are friends of `inner-iterator`.
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr bool __is_done() const {
-      _LIBCPP_ASSERT(__i_.__parent_, "Cannot call comparison on a default-constructed iterator.");
+    _LIBCPP_HIDE_FROM_ABI constexpr bool __is_done() const {
+      _LIBCPP_ASSERT_NON_NULL(__i_.__parent_ != nullptr, "Cannot call comparison on a default-constructed iterator.");
 
       auto [__pcur, __pend] = ranges::subrange{__i_.__parent_->__pattern_};
-      auto __end = ranges::end(__i_.__parent_->__base_);
+      auto __end            = ranges::end(__i_.__parent_->__base_);
 
       if constexpr (__tiny_range<_Pattern>) {
         const auto& __cur = __i_.__current();
@@ -343,40 +325,32 @@ private:
       }
     }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto& __outer_current() noexcept {
-      return __i_.__current();
-    }
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto& __outer_current() noexcept { return __i_.__current(); }
 
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr const auto& __outer_current() const noexcept {
+    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const auto& __outer_current() const noexcept {
       return __i_.__current();
     }
 
   public:
     // using iterator_category = inherited;
     using iterator_concept = typename __outer_iterator<_Const>::iterator_concept;
-    using value_type = range_value_t<_Base>;
-    using difference_type = range_difference_t<_Base>;
+    using value_type       = range_value_t<_Base>;
+    using difference_type  = range_difference_t<_Base>;
 
-    _LIBCPP_HIDE_FROM_ABI
-    __inner_iterator() = default;
+    _LIBCPP_HIDE_FROM_ABI __inner_iterator() = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit __inner_iterator(__outer_iterator<_Const> __i)
-      : __i_(std::move(__i)) {}
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __inner_iterator(__outer_iterator<_Const> __i) : __i_(std::move(__i)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr const iterator_t<_Base>& base() const& noexcept { return __i_.__current(); }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator_t<_Base> base() &&
-      requires forward_range<_View> { return std::move(__i_.__current()); }
+    _LIBCPP_HIDE_FROM_ABI constexpr const iterator_t<_Base>& base() const& noexcept { return __i_.__current(); }
+    _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Base> base() &&
+      requires forward_range<_View>
+    {
+      return std::move(__i_.__current());
+    }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator*() const { return *__i_.__current(); }
+    _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const { return *__i_.__current(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __inner_iterator& operator++() {
+    _LIBCPP_HIDE_FROM_ABI constexpr __inner_iterator& operator++() {
       __incremented_ = true;
 
       if constexpr (!forward_range<_Base>) {
@@ -389,8 +363,7 @@ private:
       return *this;
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator++(int) {
+    _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator++(int) {
       if constexpr (forward_range<_Base>) {
         auto __tmp = *this;
         ++*this;
@@ -401,54 +374,51 @@ private:
       }
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __inner_iterator& __x, const __inner_iterator& __y)
-      requires forward_range<_Base> {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __inner_iterator& __x, const __inner_iterator& __y)
+      requires forward_range<_Base>
+    {
       return __x.__outer_current() == __y.__outer_current();
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr bool operator==(const __inner_iterator& __x, default_sentinel_t) {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __inner_iterator& __x, default_sentinel_t) {
       return __x.__is_done();
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr decltype(auto) iter_move(const __inner_iterator& __i)
-        noexcept(noexcept(ranges::iter_move(__i.__outer_current()))) {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr decltype(auto)
+    iter_move(const __inner_iterator& __i) noexcept(noexcept(ranges::iter_move(__i.__outer_current()))) {
       return ranges::iter_move(__i.__outer_current());
     }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend constexpr void iter_swap(const __inner_iterator& __x, const __inner_iterator& __y)
-        noexcept(noexcept(ranges::iter_swap(__x.__outer_current(), __y.__outer_current())))
-        requires indirectly_swappable<iterator_t<_Base>> {
+    _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(
+        const __inner_iterator& __x,
+        const __inner_iterator& __y) noexcept(noexcept(ranges::iter_swap(__x.__outer_current(), __y.__outer_current())))
+      requires indirectly_swappable<iterator_t<_Base>>
+    {
       ranges::iter_swap(__x.__outer_current(), __y.__outer_current());
     }
   };
-
 };
 
 template <class _Range, class _Pattern>
 lazy_split_view(_Range&&, _Pattern&&) -> lazy_split_view<views::all_t<_Range>, views::all_t<_Pattern>>;
 
 template <input_range _Range>
-lazy_split_view(_Range&&, range_value_t<_Range>)
-  -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
+lazy_split_view(_Range&&,
+                range_value_t<_Range>) -> lazy_split_view<views::all_t<_Range>, single_view<range_value_t<_Range>>>;
 
 namespace views {
 namespace __lazy_split_view {
-struct __fn : __range_adaptor_closure<__fn> {
+struct __fn {
   template <class _Range, class _Pattern>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range, _Pattern&& __pattern) const
-    noexcept(noexcept(lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))))
-    -> decltype(      lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)))
-    { return          lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Pattern&& __pattern) const
+      noexcept(noexcept(lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))))
+          -> decltype(lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))) {
+    return lazy_split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern));
+  }
 
   template <class _Pattern>
     requires constructible_from<decay_t<_Pattern>, _Pattern>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Pattern&& __pattern) const
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pattern&& __pattern) const
       noexcept(is_nothrow_constructible_v<decay_t<_Pattern>, _Pattern>) {
     return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pattern>(__pattern)));
   }
@@ -456,7 +426,7 @@ struct __fn : __range_adaptor_closure<__fn> {
 } // namespace __lazy_split_view
 
 inline namespace __cpo {
-  inline constexpr auto lazy_split = __lazy_split_view::__fn{};
+inline constexpr auto lazy_split = __lazy_split_view::__fn{};
 } // namespace __cpo
 } // namespace views
 
@@ -466,4 +436,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_LAZY_SPLIT_VIEW_H
diff --git a/third_party/libcxx/__ranges/movable_box.h b/third_party/libcxx/__ranges/movable_box.h
new file mode 100644
index 000000000..5a456cc3a
--- /dev/null
+++ b/third_party/libcxx/__ranges/movable_box.h
@@ -0,0 +1,247 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_MOVABLE_BOX_H
+#define _LIBCPP___RANGES_MOVABLE_BOX_H
+
+#include <__concepts/constructible.h>
+#include <__concepts/copyable.h>
+#include <__concepts/movable.h>
+#include <__config>
+#include <__memory/addressof.h>
+#include <__memory/construct_at.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__utility/move.h>
+#include <optional>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+// __movable_box allows turning a type that is move-constructible (but maybe not move-assignable) into
+// a type that is both move-constructible and move-assignable. It does that by introducing an empty state
+// and basically doing destroy-then-copy-construct in the assignment operator. The empty state is necessary
+// to handle the case where the copy construction fails after destroying the object.
+//
+// In some cases, we can completely avoid the use of an empty state; we provide a specialization of
+// __movable_box that does this, see below for the details.
+
+// until C++23, `__movable_box` was named `__copyable_box` and required the stored type to be copy-constructible, not
+// just move-constructible; we preserve the old behavior in pre-C++23 modes.
+template <class _Tp>
+concept __movable_box_object =
+#  if _LIBCPP_STD_VER >= 23
+    move_constructible<_Tp>
+#  else
+    copy_constructible<_Tp>
+#  endif
+    && is_object_v<_Tp>;
+
+namespace ranges {
+// Primary template - uses std::optional and introduces an empty state in case assignment fails.
+template <__movable_box_object _Tp>
+class __movable_box {
+  _LIBCPP_NO_UNIQUE_ADDRESS optional<_Tp> __val_;
+
+public:
+  template <class... _Args>
+    requires is_constructible_v<_Tp, _Args...>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __movable_box(in_place_t, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, _Args...>)
+      : __val_(in_place, std::forward<_Args>(__args)...) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
+    requires default_initializable<_Tp>
+      : __val_(in_place) {}
+
+  _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box const&) = default;
+  _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box&&)      = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box&
+  operator=(__movable_box const& __other) noexcept(is_nothrow_copy_constructible_v<_Tp>)
+#  if _LIBCPP_STD_VER >= 23
+    requires copy_constructible<_Tp>
+#  endif
+  {
+    if (this != std::addressof(__other)) {
+      if (__other.__has_value())
+        __val_.emplace(*__other);
+      else
+        __val_.reset();
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __movable_box& operator=(__movable_box&&)
+    requires movable<_Tp>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box&
+  operator=(__movable_box&& __other) noexcept(is_nothrow_move_constructible_v<_Tp>) {
+    if (this != std::addressof(__other)) {
+      if (__other.__has_value())
+        __val_.emplace(std::move(*__other));
+      else
+        __val_.reset();
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return *__val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return *__val_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* operator->() const noexcept { return __val_.operator->(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* operator->() noexcept { return __val_.operator->(); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return __val_.has_value(); }
+};
+
+// This partial specialization implements an optimization for when we know we don't need to store
+// an empty state to represent failure to perform an assignment. For copy-assignment, this happens:
+//
+// 1. If the type is copyable (which includes copy-assignment), we can use the type's own assignment operator
+//    directly and avoid using std::optional.
+// 2. If the type is not copyable, but it is nothrow-copy-constructible, then we can implement assignment as
+//    destroy-and-then-construct and we know it will never fail, so we don't need an empty state.
+//
+// The exact same reasoning can be applied for move-assignment, with copyable replaced by movable and
+// nothrow-copy-constructible replaced by nothrow-move-constructible. This specialization is enabled
+// whenever we can apply any of these optimizations for both the copy assignment and the move assignment
+// operator.
+
+#  if _LIBCPP_STD_VER >= 23
+template <class _Tp>
+concept __doesnt_need_empty_state =
+    (copy_constructible<_Tp>
+         // 1. If copy_constructible<T> is true, movable-box<T> should store only a T if either T models
+         //    copyable, or is_nothrow_move_constructible_v<T> && is_nothrow_copy_constructible_v<T> is true.
+         ? copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp> && is_nothrow_copy_constructible_v<_Tp>)
+         // 2. Otherwise, movable-box<T> should store only a T if either T models movable or
+         //    is_nothrow_move_constructible_v<T> is true.
+         : movable<_Tp> || is_nothrow_move_constructible_v<_Tp>);
+
+// When _Tp doesn't have an assignment operator, we must implement __movable_box's assignment operator
+// by doing destroy_at followed by construct_at. However, that implementation strategy leads to UB if the nested
+// _Tp is potentially overlapping, as it is doing a non-transparent replacement of the sub-object, which means that
+// we're not considered "nested" inside the movable-box anymore, and since we're not nested within it, [basic.life]/1.5
+// says that we essentially just reused the storage of the movable-box for a completely unrelated object and ended the
+// movable-box's lifetime.
+// https://github.com/llvm/llvm-project/issues/70494#issuecomment-1845646490
+//
+// Hence, when the _Tp doesn't have an assignment operator, we can't risk making it a potentially-overlapping
+// subobject because of the above, and we don't use [[no_unique_address]] in that case.
+template <class _Tp>
+concept __can_use_no_unique_address = (copy_constructible<_Tp> ? copyable<_Tp> : movable<_Tp>);
+
+#  else
+
+template <class _Tp>
+concept __doesnt_need_empty_state_for_copy = copyable<_Tp> || is_nothrow_copy_constructible_v<_Tp>;
+
+template <class _Tp>
+concept __doesnt_need_empty_state_for_move = movable<_Tp> || is_nothrow_move_constructible_v<_Tp>;
+
+template <class _Tp>
+concept __doesnt_need_empty_state = __doesnt_need_empty_state_for_copy<_Tp> && __doesnt_need_empty_state_for_move<_Tp>;
+
+template <class _Tp>
+concept __can_use_no_unique_address = copyable<_Tp>;
+#  endif
+
+template <class _Tp>
+struct __movable_box_holder {
+  _Tp __val_;
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __movable_box_holder(in_place_t, _Args&&... __args)
+      : __val_(std::forward<_Args>(__args)...) {}
+};
+
+template <class _Tp>
+  requires __can_use_no_unique_address<_Tp>
+struct __movable_box_holder<_Tp> {
+  _LIBCPP_NO_UNIQUE_ADDRESS _Tp __val_;
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __movable_box_holder(in_place_t, _Args&&... __args)
+      : __val_(std::forward<_Args>(__args)...) {}
+};
+
+template <__movable_box_object _Tp>
+  requires __doesnt_need_empty_state<_Tp>
+class __movable_box<_Tp> {
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box_holder<_Tp> __holder_;
+
+public:
+  template <class... _Args>
+    requires is_constructible_v<_Tp, _Args...>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __movable_box(in_place_t __inplace, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, _Args...>)
+      : __holder_(__inplace, std::forward<_Args>(__args)...) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box() noexcept(is_nothrow_default_constructible_v<_Tp>)
+    requires default_initializable<_Tp>
+      : __holder_(in_place_t{}) {}
+
+  _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box const&) = default;
+  _LIBCPP_HIDE_FROM_ABI __movable_box(__movable_box&&)      = default;
+
+  // Implementation of assignment operators in case we perform optimization (1)
+  _LIBCPP_HIDE_FROM_ABI __movable_box& operator=(__movable_box const&)
+    requires copyable<_Tp>
+  = default;
+  _LIBCPP_HIDE_FROM_ABI __movable_box& operator=(__movable_box&&)
+    requires movable<_Tp>
+  = default;
+
+  // Implementation of assignment operators in case we perform optimization (2)
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box& operator=(__movable_box const& __other) noexcept {
+    static_assert(is_nothrow_copy_constructible_v<_Tp>);
+    static_assert(!__can_use_no_unique_address<_Tp>);
+    if (this != std::addressof(__other)) {
+      std::destroy_at(std::addressof(__holder_.__val_));
+      std::construct_at(std::addressof(__holder_.__val_), __other.__holder_.__val_);
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __movable_box& operator=(__movable_box&& __other) noexcept {
+    static_assert(is_nothrow_move_constructible_v<_Tp>);
+    static_assert(!__can_use_no_unique_address<_Tp>);
+    if (this != std::addressof(__other)) {
+      std::destroy_at(std::addressof(__holder_.__val_));
+      std::construct_at(std::addressof(__holder_.__val_), std::move(__other.__holder_.__val_));
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const noexcept { return __holder_.__val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() noexcept { return __holder_.__val_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* operator->() const noexcept { return std::addressof(__holder_.__val_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* operator->() noexcept { return std::addressof(__holder_.__val_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const noexcept { return true; }
+};
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_MOVABLE_BOX_H
diff --git a/third_party/libcxx/__ranges/non_propagating_cache.h b/third_party/libcxx/__ranges/non_propagating_cache.h
index f52239620..b2de2d2ae 100644
--- a/third_party/libcxx/__ranges/non_propagating_cache.h
+++ b/third_party/libcxx/__ranges/non_propagating_cache.h
@@ -26,85 +26,74 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  // __non_propagating_cache is a helper type that allows storing an optional value in it,
-  // but which does not copy the source's value when it is copy constructed/assigned to,
-  // and which resets the source's value when it is moved-from.
-  //
-  // This type is used as an implementation detail of some views that need to cache the
-  // result of `begin()` in order to provide an amortized O(1) begin() method. Typically,
-  // we don't want to propagate the value of the cache upon copy because the cached iterator
-  // may refer to internal details of the source view.
-  template<class _Tp>
-    requires is_object_v<_Tp>
-  class _LIBCPP_TEMPLATE_VIS __non_propagating_cache {
-    struct __from_tag { };
-    struct __forward_tag { };
+// __non_propagating_cache is a helper type that allows storing an optional value in it,
+// but which does not copy the source's value when it is copy constructed/assigned to,
+// and which resets the source's value when it is moved-from.
+//
+// This type is used as an implementation detail of some views that need to cache the
+// result of `begin()` in order to provide an amortized O(1) begin() method. Typically,
+// we don't want to propagate the value of the cache upon copy because the cached iterator
+// may refer to internal details of the source view.
+template <class _Tp>
+  requires is_object_v<_Tp>
+class _LIBCPP_TEMPLATE_VIS __non_propagating_cache {
+  struct __from_tag {};
+  struct __forward_tag {};
 
-    // This helper class is needed to perform copy and move elision when
-    // constructing the contained type from an iterator.
-    struct __wrapper {
-      template <class... _Args>
-      _LIBCPP_HIDE_FROM_ABI constexpr explicit __wrapper(__forward_tag, _Args&&... __args)
-          : __t_(std::forward<_Args>(__args)...) {}
-      template <class _Fn>
-      _LIBCPP_HIDE_FROM_ABI constexpr explicit __wrapper(__from_tag, _Fn const& __f) : __t_(__f()) {}
-      _Tp __t_;
-    };
-
-    optional<__wrapper> __value_ = nullopt;
-
-  public:
-    _LIBCPP_HIDE_FROM_ABI __non_propagating_cache() = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __non_propagating_cache(__non_propagating_cache const&) noexcept
-      : __value_(nullopt)
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __non_propagating_cache(__non_propagating_cache&& __other) noexcept
-      : __value_(nullopt)
-    {
-      __other.__value_.reset();
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __non_propagating_cache& operator=(__non_propagating_cache const& __other) noexcept {
-      if (this != std::addressof(__other)) {
-        __value_.reset();
-      }
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr __non_propagating_cache& operator=(__non_propagating_cache&& __other) noexcept {
-      __value_.reset();
-      __other.__value_.reset();
-      return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp& operator*() { return __value_->__t_; }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp const& operator*() const { return __value_->__t_; }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr bool __has_value() const { return __value_.has_value(); }
-
-    template<class _Fn>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp& __emplace_from(_Fn const& __f) {
-      return __value_.emplace(__from_tag{}, __f).__t_;
-    }
-
-    template<class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp& __emplace(_Args&& ...__args) {
-      return __value_.emplace(__forward_tag{}, std::forward<_Args>(__args)...).__t_;
-    }
+  // This helper class is needed to perform copy and move elision when
+  // constructing the contained type from an iterator.
+  struct __wrapper {
+    template <class... _Args>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __wrapper(__forward_tag, _Args&&... __args)
+        : __t_(std::forward<_Args>(__args)...) {}
+    template <class _Fn>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit __wrapper(__from_tag, _Fn const& __f) : __t_(__f()) {}
+    _Tp __t_;
   };
 
-  struct __empty_cache { };
+  optional<__wrapper> __value_ = nullopt;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __non_propagating_cache() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __non_propagating_cache(__non_propagating_cache const&) noexcept
+      : __value_(nullopt) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __non_propagating_cache(__non_propagating_cache&& __other) noexcept
+      : __value_(nullopt) {
+    __other.__value_.reset();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __non_propagating_cache& operator=(__non_propagating_cache const& __other) noexcept {
+    if (this != std::addressof(__other)) {
+      __value_.reset();
+    }
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __non_propagating_cache& operator=(__non_propagating_cache&& __other) noexcept {
+    __value_.reset();
+    __other.__value_.reset();
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() { return __value_->__t_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& operator*() const { return __value_->__t_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool __has_value() const { return __value_.has_value(); }
+
+  template <class _Fn>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& __emplace_from(_Fn const& __f) {
+    return __value_.emplace(__from_tag{}, __f).__t_;
+  }
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp& __emplace(_Args&&... __args) {
+    return __value_.emplace(__forward_tag{}, std::forward<_Args>(__args)...).__t_;
+  }
+};
+
+struct __empty_cache {};
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__ranges/owning_view.h b/third_party/libcxx/__ranges/owning_view.h
index a5deed3b3..254bdb432 100644
--- a/third_party/libcxx/__ranges/owning_view.h
+++ b/third_party/libcxx/__ranges/owning_view.h
@@ -27,52 +27,83 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<range _Rp>
-    requires movable<_Rp> && (!__is_std_initializer_list<remove_cvref_t<_Rp>>)
-  class owning_view : public view_interface<owning_view<_Rp>> {
-    _Rp __r_ = _Rp();
+template <range _Rp>
+  requires movable<_Rp> && (!__is_std_initializer_list<remove_cvref_t<_Rp>>)
+class owning_view : public view_interface<owning_view<_Rp>> {
+  _Rp __r_ = _Rp();
 
 public:
-    _LIBCPP_HIDE_FROM_ABI owning_view() requires default_initializable<_Rp> = default;
-    _LIBCPP_HIDE_FROM_ABI constexpr owning_view(_Rp&& __r) : __r_(std::move(__r)) {}
+  _LIBCPP_HIDE_FROM_ABI owning_view()
+    requires default_initializable<_Rp>
+  = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr owning_view(_Rp&& __r) : __r_(std::move(__r)) {}
 
-    _LIBCPP_HIDE_FROM_ABI owning_view(owning_view&&) = default;
-    _LIBCPP_HIDE_FROM_ABI owning_view& operator=(owning_view&&) = default;
+  _LIBCPP_HIDE_FROM_ABI owning_view(owning_view&&)            = default;
+  _LIBCPP_HIDE_FROM_ABI owning_view& operator=(owning_view&&) = default;
 
-    _LIBCPP_HIDE_FROM_ABI constexpr _Rp& base() & noexcept { return __r_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Rp& base() const& noexcept { return __r_; }
-    _LIBCPP_HIDE_FROM_ABI constexpr _Rp&& base() && noexcept { return std::move(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr const _Rp&& base() const&& noexcept { return std::move(__r_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Rp& base() & noexcept { return __r_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Rp& base() const& noexcept { return __r_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Rp&& base() && noexcept { return std::move(__r_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Rp&& base() const&& noexcept { return std::move(__r_); }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Rp> begin() { return ranges::begin(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Rp> end() { return ranges::end(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const requires range<const _Rp> { return ranges::begin(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr auto end() const requires range<const _Rp> { return ranges::end(__r_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Rp> begin() { return ranges::begin(__r_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Rp> end() { return ranges::end(__r_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _Rp>
+  {
+    return ranges::begin(__r_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _Rp>
+  {
+    return ranges::end(__r_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr bool empty() requires requires { ranges::empty(__r_); }
-      { return ranges::empty(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const requires requires { ranges::empty(__r_); }
-      { return ranges::empty(__r_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool empty()
+    requires requires { ranges::empty(__r_); }
+  {
+    return ranges::empty(__r_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const
+    requires requires { ranges::empty(__r_); }
+  {
+    return ranges::empty(__r_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr auto size() requires sized_range<_Rp>
-      { return ranges::size(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr auto size() const requires sized_range<const _Rp>
-      { return ranges::size(__r_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_Rp>
+  {
+    return ranges::size(__r_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _Rp>
+  {
+    return ranges::size(__r_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr auto data() requires contiguous_range<_Rp>
-      { return ranges::data(__r_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr auto data() const requires contiguous_range<const _Rp>
-      { return ranges::data(__r_); }
-  };
-  _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(owning_view);
+  _LIBCPP_HIDE_FROM_ABI constexpr auto data()
+    requires contiguous_range<_Rp>
+  {
+    return ranges::data(__r_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto data() const
+    requires contiguous_range<const _Rp>
+  {
+    return ranges::data(__r_);
+  }
+};
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(owning_view);
 
-  template<class _Tp>
-  inline constexpr bool enable_borrowed_range<owning_view<_Tp>> = enable_borrowed_range<_Tp>;
+template <class _Tp>
+inline constexpr bool enable_borrowed_range<owning_view<_Tp>> = enable_borrowed_range<_Tp>;
 
 } // namespace ranges
 
@@ -80,4 +111,6 @@ public:
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_OWNING_VIEW_H
diff --git a/third_party/libcxx/__ranges/range_adaptor.h b/third_party/libcxx/__ranges/range_adaptor.h
index da78d3bd8..2da246f24 100644
--- a/third_party/libcxx/__ranges/range_adaptor.h
+++ b/third_party/libcxx/__ranges/range_adaptor.h
@@ -19,6 +19,7 @@
 #include <__functional/invoke.h>
 #include <__ranges/concepts.h>
 #include <__type_traits/decay.h>
+#include <__type_traits/is_class.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/forward.h>
@@ -28,52 +29,73 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
+namespace ranges {
+
 // CRTP base that one can derive from in order to be considered a range adaptor closure
 // by the library. When deriving from this class, a pipe operator will be provided to
 // make the following hold:
 // - `x | f` is equivalent to `f(x)`
 // - `f1 | f2` is an adaptor closure `g` such that `g(x)` is equivalent to `f2(f1(x))`
 template <class _Tp>
+  requires is_class_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
 struct __range_adaptor_closure;
 
 // Type that wraps an arbitrary function object and makes it into a range adaptor closure,
 // i.e. something that can be called via the `x | f` notation.
 template <class _Fn>
 struct __range_adaptor_closure_t : _Fn, __range_adaptor_closure<__range_adaptor_closure_t<_Fn>> {
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit __range_adaptor_closure_t(_Fn&& __f) : _Fn(std::move(__f)) { }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __range_adaptor_closure_t(_Fn&& __f) : _Fn(std::move(__f)) {}
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__range_adaptor_closure_t);
 
 template <class _Tp>
-concept _RangeAdaptorClosure = derived_from<remove_cvref_t<_Tp>, __range_adaptor_closure<remove_cvref_t<_Tp>>>;
+_Tp __derived_from_range_adaptor_closure(__range_adaptor_closure<_Tp>*);
 
 template <class _Tp>
-struct __range_adaptor_closure {
-    template <ranges::viewable_range _View, _RangeAdaptorClosure _Closure>
-        requires same_as<_Tp, remove_cvref_t<_Closure>> &&
-                 invocable<_Closure, _View>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    friend constexpr decltype(auto) operator|(_View&& __view, _Closure&& __closure)
-        noexcept(is_nothrow_invocable_v<_Closure, _View>)
-    { return std::invoke(std::forward<_Closure>(__closure), std::forward<_View>(__view)); }
-
-    template <_RangeAdaptorClosure _Closure, _RangeAdaptorClosure _OtherClosure>
-        requires same_as<_Tp, remove_cvref_t<_Closure>> &&
-                 constructible_from<decay_t<_Closure>, _Closure> &&
-                 constructible_from<decay_t<_OtherClosure>, _OtherClosure>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    friend constexpr auto operator|(_Closure&& __c1, _OtherClosure&& __c2)
-        noexcept(is_nothrow_constructible_v<decay_t<_Closure>, _Closure> &&
-                 is_nothrow_constructible_v<decay_t<_OtherClosure>, _OtherClosure>)
-    { return __range_adaptor_closure_t(std::__compose(std::forward<_OtherClosure>(__c2), std::forward<_Closure>(__c1))); }
+concept _RangeAdaptorClosure = !ranges::range<remove_cvref_t<_Tp>> && requires {
+  // Ensure that `remove_cvref_t<_Tp>` is derived from `__range_adaptor_closure<remove_cvref_t<_Tp>>` and isn't derived
+  // from `__range_adaptor_closure<U>` for any other type `U`.
+  { ranges::__derived_from_range_adaptor_closure((remove_cvref_t<_Tp>*)nullptr) } -> same_as<remove_cvref_t<_Tp>>;
 };
 
+template <ranges::range _Range, _RangeAdaptorClosure _Closure>
+  requires invocable<_Closure, _Range>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto)
+operator|(_Range&& __range, _Closure&& __closure) noexcept(is_nothrow_invocable_v<_Closure, _Range>) {
+  return std::invoke(std::forward<_Closure>(__closure), std::forward<_Range>(__range));
+}
+
+template <_RangeAdaptorClosure _Closure, _RangeAdaptorClosure _OtherClosure>
+  requires constructible_from<decay_t<_Closure>, _Closure> && constructible_from<decay_t<_OtherClosure>, _OtherClosure>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator|(_Closure&& __c1, _OtherClosure&& __c2) noexcept(
+    is_nothrow_constructible_v<decay_t<_Closure>, _Closure> &&
+    is_nothrow_constructible_v<decay_t<_OtherClosure>, _OtherClosure>) {
+  return __range_adaptor_closure_t(std::__compose(std::forward<_OtherClosure>(__c2), std::forward<_Closure>(__c1)));
+}
+
+template <class _Tp>
+  requires is_class_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
+struct __range_adaptor_closure {};
+
+#  if _LIBCPP_STD_VER >= 23
+template <class _Tp>
+  requires is_class_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>>
+class range_adaptor_closure : public __range_adaptor_closure<_Tp> {};
+#  endif // _LIBCPP_STD_VER >= 23
+
+} // namespace ranges
+
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_RANGE_ADAPTOR_H
diff --git a/third_party/libcxx/__ranges/rbegin.h b/third_party/libcxx/__ranges/rbegin.h
index 1ceb1116d..12e739e1a 100644
--- a/third_party/libcxx/__ranges/rbegin.h
+++ b/third_party/libcxx/__ranges/rbegin.h
@@ -36,57 +36,43 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __rbegin {
 template <class _Tp>
-concept __member_rbegin =
-  __can_borrow<_Tp> &&
-  __workaround_52970<_Tp> &&
-  requires(_Tp&& __t) {
-    { _LIBCPP_AUTO_CAST(__t.rbegin()) } -> input_or_output_iterator;
-  };
+concept __member_rbegin = __can_borrow<_Tp> && requires(_Tp&& __t) {
+  { _LIBCPP_AUTO_CAST(__t.rbegin()) } -> input_or_output_iterator;
+};
 
-void rbegin(auto&) = delete;
-void rbegin(const auto&) = delete;
+void rbegin() = delete;
 
 template <class _Tp>
 concept __unqualified_rbegin =
-  !__member_rbegin<_Tp> &&
-  __can_borrow<_Tp> &&
-  __class_or_enum<remove_cvref_t<_Tp>> &&
-  requires(_Tp&& __t) {
-    { _LIBCPP_AUTO_CAST(rbegin(__t)) } -> input_or_output_iterator;
-  };
+    !__member_rbegin<_Tp> && __can_borrow<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+      { _LIBCPP_AUTO_CAST(rbegin(__t)) } -> input_or_output_iterator;
+    };
 
 template <class _Tp>
 concept __can_reverse =
-  __can_borrow<_Tp> &&
-  !__member_rbegin<_Tp> &&
-  !__unqualified_rbegin<_Tp> &&
-  requires(_Tp&& __t) {
-    { ranges::begin(__t) } -> same_as<decltype(ranges::end(__t))>;
-    { ranges::begin(__t) } -> bidirectional_iterator;
-  };
+    __can_borrow<_Tp> && !__member_rbegin<_Tp> && !__unqualified_rbegin<_Tp> && requires(_Tp&& __t) {
+      { ranges::begin(__t) } -> same_as<decltype(ranges::end(__t))>;
+      { ranges::begin(__t) } -> bidirectional_iterator;
+    };
 
 struct __fn {
   template <class _Tp>
     requires __member_rbegin<_Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.rbegin())))
-  {
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.rbegin()))) {
     return _LIBCPP_AUTO_CAST(__t.rbegin());
   }
 
   template <class _Tp>
     requires __unqualified_rbegin<_Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(rbegin(__t))))
-  {
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(rbegin(__t)))) {
     return _LIBCPP_AUTO_CAST(rbegin(__t));
   }
 
   template <class _Tp>
     requires __can_reverse<_Tp>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::end(__t)))
-  {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const noexcept(noexcept(ranges::end(__t))) {
     return std::make_reverse_iterator(ranges::end(__t));
   }
 
@@ -95,7 +81,7 @@ struct __fn {
 } // namespace __rbegin
 
 inline namespace __cpo {
-  inline constexpr auto rbegin = __rbegin::__fn{};
+inline constexpr auto rbegin = __rbegin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -106,24 +92,24 @@ namespace __crbegin {
 struct __fn {
   template <class _Tp>
     requires is_lvalue_reference_v<_Tp&&>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t))))
-    -> decltype(      ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t)))
-    { return          ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t))))
+          -> decltype(ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t))) {
+    return ranges::rbegin(static_cast<const remove_reference_t<_Tp>&>(__t));
+  }
 
   template <class _Tp>
     requires is_rvalue_reference_v<_Tp&&>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::rbegin(static_cast<const _Tp&&>(__t))))
-    -> decltype(      ranges::rbegin(static_cast<const _Tp&&>(__t)))
-    { return          ranges::rbegin(static_cast<const _Tp&&>(__t)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::rbegin(static_cast<const _Tp&&>(__t))))
+          -> decltype(ranges::rbegin(static_cast<const _Tp&&>(__t))) {
+    return ranges::rbegin(static_cast<const _Tp&&>(__t));
+  }
 };
 } // namespace __crbegin
 
 inline namespace __cpo {
-  inline constexpr auto crbegin = __crbegin::__fn{};
+inline constexpr auto crbegin = __crbegin::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__ranges/ref_view.h b/third_party/libcxx/__ranges/ref_view.h
index be32b8124..5329d778d 100644
--- a/third_party/libcxx/__ranges/ref_view.h
+++ b/third_party/libcxx/__ranges/ref_view.h
@@ -37,49 +37,49 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<range _Range>
-    requires is_object_v<_Range>
-  class ref_view : public view_interface<ref_view<_Range>> {
-    _Range *__range_;
+template <range _Range>
+  requires is_object_v<_Range>
+class ref_view : public view_interface<ref_view<_Range>> {
+  _Range* __range_;
 
-    static void __fun(_Range&);
-    static void __fun(_Range&&) = delete;
+  static void __fun(_Range&);
+  static void __fun(_Range&&) = delete; // NOLINT(modernize-use-equals-delete) ; This is llvm.org/PR54276
 
 public:
-    template<class _Tp>
-      requires __different_from<_Tp, ref_view> &&
-        convertible_to<_Tp, _Range&> && requires { __fun(std::declval<_Tp>()); }
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr ref_view(_Tp&& __t)
-      : __range_(std::addressof(static_cast<_Range&>(std::forward<_Tp>(__t))))
-    {}
+  template <class _Tp>
+    requires __different_from<_Tp, ref_view> && convertible_to<_Tp, _Range&> && requires { __fun(std::declval<_Tp>()); }
+  _LIBCPP_HIDE_FROM_ABI constexpr ref_view(_Tp&& __t)
+      : __range_(std::addressof(static_cast<_Range&>(std::forward<_Tp>(__t)))) {}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr _Range& base() const { return *__range_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Range& base() const { return *__range_; }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }
-    _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Range> end() const { return ranges::end(*__range_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Range> end() const { return ranges::end(*__range_); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr bool empty() const
-      requires requires { ranges::empty(*__range_); }
-    { return ranges::empty(*__range_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const
+    requires requires { ranges::empty(*__range_); }
+  {
+    return ranges::empty(*__range_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() const
-      requires sized_range<_Range>
-    { return ranges::size(*__range_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<_Range>
+  {
+    return ranges::size(*__range_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto data() const
-      requires contiguous_range<_Range>
-    { return ranges::data(*__range_); }
-  };
+  _LIBCPP_HIDE_FROM_ABI constexpr auto data() const
+    requires contiguous_range<_Range>
+  {
+    return ranges::data(*__range_);
+  }
+};
 
-  template<class _Range>
-  ref_view(_Range&) -> ref_view<_Range>;
+template <class _Range>
+ref_view(_Range&) -> ref_view<_Range>;
 
-  template<class _Tp>
-  inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
+template <class _Tp>
+inline constexpr bool enable_borrowed_range<ref_view<_Tp>> = true;
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
diff --git a/third_party/libcxx/__ranges/rend.h b/third_party/libcxx/__ranges/rend.h
index 7ee574ccf..02b4c5999 100644
--- a/third_party/libcxx/__ranges/rend.h
+++ b/third_party/libcxx/__ranges/rend.h
@@ -37,60 +37,46 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 namespace __rend {
 template <class _Tp>
-concept __member_rend =
-  __can_borrow<_Tp> &&
-  __workaround_52970<_Tp> &&
-  requires(_Tp&& __t) {
-    ranges::rbegin(__t);
-    { _LIBCPP_AUTO_CAST(__t.rend()) } -> sentinel_for<decltype(ranges::rbegin(__t))>;
-  };
+concept __member_rend = __can_borrow<_Tp> && requires(_Tp&& __t) {
+  ranges::rbegin(__t);
+  { _LIBCPP_AUTO_CAST(__t.rend()) } -> sentinel_for<decltype(ranges::rbegin(__t))>;
+};
 
-void rend(auto&) = delete;
-void rend(const auto&) = delete;
+void rend() = delete;
 
 template <class _Tp>
 concept __unqualified_rend =
-  !__member_rend<_Tp> &&
-  __can_borrow<_Tp> &&
-  __class_or_enum<remove_cvref_t<_Tp>> &&
-  requires(_Tp&& __t) {
-    ranges::rbegin(__t);
-    { _LIBCPP_AUTO_CAST(rend(__t)) } -> sentinel_for<decltype(ranges::rbegin(__t))>;
-  };
+    !__member_rend<_Tp> && __can_borrow<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+      ranges::rbegin(__t);
+      { _LIBCPP_AUTO_CAST(rend(__t)) } -> sentinel_for<decltype(ranges::rbegin(__t))>;
+    };
 
 template <class _Tp>
-concept __can_reverse =
-  __can_borrow<_Tp> &&
-  !__member_rend<_Tp> &&
-  !__unqualified_rend<_Tp> &&
-  requires(_Tp&& __t) {
-    { ranges::begin(__t) } -> same_as<decltype(ranges::end(__t))>;
-    { ranges::begin(__t) } -> bidirectional_iterator;
-  };
+concept __can_reverse = __can_borrow<_Tp> && !__member_rend<_Tp> && !__unqualified_rend<_Tp> && requires(_Tp&& __t) {
+  { ranges::begin(__t) } -> same_as<decltype(ranges::end(__t))>;
+  { ranges::begin(__t) } -> bidirectional_iterator;
+};
 
 class __fn {
 public:
   template <class _Tp>
     requires __member_rend<_Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.rend())))
-  {
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(__t.rend()))) {
     return _LIBCPP_AUTO_CAST(__t.rend());
   }
 
   template <class _Tp>
     requires __unqualified_rend<_Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(rend(__t))))
-  {
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(rend(__t)))) {
     return _LIBCPP_AUTO_CAST(rend(__t));
   }
 
   template <class _Tp>
     requires __can_reverse<_Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::begin(__t)))
-  {
+      noexcept(noexcept(ranges::begin(__t))) {
     return std::make_reverse_iterator(ranges::begin(__t));
   }
 
@@ -99,7 +85,7 @@ public:
 } // namespace __rend
 
 inline namespace __cpo {
-  inline constexpr auto rend = __rend::__fn{};
+inline constexpr auto rend = __rend::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -110,24 +96,23 @@ namespace __crend {
 struct __fn {
   template <class _Tp>
     requires is_lvalue_reference_v<_Tp&&>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t))))
-    -> decltype(      ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t)))
-    { return          ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
+      noexcept(noexcept(ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t))))
+          -> decltype(ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t))) {
+    return ranges::rend(static_cast<const remove_reference_t<_Tp>&>(__t));
+  }
 
   template <class _Tp>
     requires is_rvalue_reference_v<_Tp&&>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::rend(static_cast<const _Tp&&>(__t))))
-    -> decltype(      ranges::rend(static_cast<const _Tp&&>(__t)))
-    { return          ranges::rend(static_cast<const _Tp&&>(__t)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const noexcept(
+      noexcept(ranges::rend(static_cast<const _Tp&&>(__t)))) -> decltype(ranges::rend(static_cast<const _Tp&&>(__t))) {
+    return ranges::rend(static_cast<const _Tp&&>(__t));
+  }
 };
 } // namespace __crend
 
 inline namespace __cpo {
-  inline constexpr auto crend = __crend::__fn{};
+inline constexpr auto crend = __crend::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__ranges/repeat_view.h b/third_party/libcxx/__ranges/repeat_view.h
new file mode 100644
index 000000000..53e4beb27
--- /dev/null
+++ b/third_party/libcxx/__ranges/repeat_view.h
@@ -0,0 +1,266 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_REPEAT_VIEW_H
+#define _LIBCPP___RANGES_REPEAT_VIEW_H
+
+#include <__assert>
+#include <__concepts/constructible.h>
+#include <__concepts/same_as.h>
+#include <__concepts/semiregular.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/unreachable_sentinel.h>
+#include <__memory/addressof.h>
+#include <__ranges/iota_view.h>
+#include <__ranges/movable_box.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_object.h>
+#include <__type_traits/make_unsigned.h>
+#include <__type_traits/remove_cv.h>
+#include <__utility/forward.h>
+#include <__utility/in_place.h>
+#include <__utility/move.h>
+#include <__utility/piecewise_construct.h>
+#include <tuple>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+
+template <class _Tp>
+concept __integer_like_with_usable_difference_type =
+    __signed_integer_like<_Tp> || (__integer_like<_Tp> && weakly_incrementable<_Tp>);
+
+template <class _Tp>
+struct __repeat_view_iterator_difference {
+  using type = _IotaDiffT<_Tp>;
+};
+
+template <__signed_integer_like _Tp>
+struct __repeat_view_iterator_difference<_Tp> {
+  using type = _Tp;
+};
+
+template <class _Tp>
+using __repeat_view_iterator_difference_t = typename __repeat_view_iterator_difference<_Tp>::type;
+
+namespace views::__drop {
+struct __fn;
+} // namespace views::__drop
+
+namespace views::__take {
+struct __fn;
+} // namespace views::__take
+
+template <move_constructible _Tp, semiregular _Bound = unreachable_sentinel_t>
+  requires(is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>> &&
+           (__integer_like_with_usable_difference_type<_Bound> || same_as<_Bound, unreachable_sentinel_t>))
+class _LIBCPP_ABI_LLVM18_NO_UNIQUE_ADDRESS repeat_view : public view_interface<repeat_view<_Tp, _Bound>> {
+  friend struct views::__take::__fn;
+  friend struct views::__drop::__fn;
+  class __iterator;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI repeat_view()
+    requires default_initializable<_Tp>
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit repeat_view(const _Tp& __value, _Bound __bound_sentinel = _Bound())
+    requires copy_constructible<_Tp>
+      : __value_(in_place, __value), __bound_(__bound_sentinel) {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT_UNCATEGORIZED(__bound_ >= 0, "The value of bound must be greater than or equal to 0");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit repeat_view(_Tp&& __value, _Bound __bound_sentinel = _Bound())
+      : __value_(in_place, std::move(__value)), __bound_(__bound_sentinel) {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT_UNCATEGORIZED(__bound_ >= 0, "The value of bound must be greater than or equal to 0");
+  }
+
+  template <class... _TpArgs, class... _BoundArgs>
+    requires(constructible_from<_Tp, _TpArgs...> && constructible_from<_Bound, _BoundArgs...>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit repeat_view(
+      piecewise_construct_t, tuple<_TpArgs...> __value_args, tuple<_BoundArgs...> __bound_args = tuple<>{})
+      : __value_(in_place, std::make_from_tuple<_Tp>(std::move(__value_args))),
+        __bound_(std::make_from_tuple<_Bound>(std::move(__bound_args))) {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT_UNCATEGORIZED(
+          __bound_ >= 0, "The behavior is undefined if Bound is not unreachable_sentinel_t and bound is negative");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() const { return __iterator(std::addressof(*__value_)); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator end() const
+    requires(!same_as<_Bound, unreachable_sentinel_t>)
+  {
+    return __iterator(std::addressof(*__value_), __bound_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr unreachable_sentinel_t end() const noexcept { return unreachable_sentinel; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires(!same_as<_Bound, unreachable_sentinel_t>)
+  {
+    return std::__to_unsigned_like(__bound_);
+  }
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Tp> __value_;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Bound __bound_ = _Bound();
+};
+
+template <class _Tp, class _Bound = unreachable_sentinel_t>
+repeat_view(_Tp, _Bound = _Bound()) -> repeat_view<_Tp, _Bound>;
+
+// [range.repeat.iterator]
+template <move_constructible _Tp, semiregular _Bound>
+  requires(is_object_v<_Tp> && same_as<_Tp, remove_cv_t<_Tp>> &&
+           (__integer_like_with_usable_difference_type<_Bound> || same_as<_Bound, unreachable_sentinel_t>))
+class repeat_view<_Tp, _Bound>::__iterator {
+  friend class repeat_view;
+
+  using _IndexT = conditional_t<same_as<_Bound, unreachable_sentinel_t>, ptrdiff_t, _Bound>;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(const _Tp* __value, _IndexT __bound_sentinel = _IndexT())
+      : __value_(__value), __current_(__bound_sentinel) {}
+
+public:
+  using iterator_concept  = random_access_iterator_tag;
+  using iterator_category = random_access_iterator_tag;
+  using value_type        = _Tp;
+  using difference_type   = __repeat_view_iterator_difference_t<_IndexT>;
+
+  _LIBCPP_HIDE_FROM_ABI __iterator() = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const noexcept { return *__value_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
+    ++__current_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int) {
+    auto __tmp = *this;
+    ++*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--() {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT_UNCATEGORIZED(__current_ > 0, "The value of bound must be greater than or equal to 0");
+    --__current_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int) {
+    auto __tmp = *this;
+    --*this;
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __n) {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT_UNCATEGORIZED(__current_ + __n >= 0, "The value of bound must be greater than or equal to 0");
+    __current_ += __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __n) {
+    if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
+      _LIBCPP_ASSERT_UNCATEGORIZED(__current_ - __n >= 0, "The value of bound must be greater than or equal to 0");
+    __current_ -= __n;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator[](difference_type __n) const noexcept { return *(*this + __n); }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) {
+    return __x.__current_ == __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y) {
+    return __x.__current_ <=> __y.__current_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(__iterator __i, difference_type __n) {
+    __i += __n;
+    return __i;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, __iterator __i) {
+    __i += __n;
+    return __i;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(__iterator __i, difference_type __n) {
+    __i -= __n;
+    return __i;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y) {
+    return static_cast<difference_type>(__x.__current_) - static_cast<difference_type>(__y.__current_);
+  }
+
+private:
+  const _Tp* __value_ = nullptr;
+  _IndexT __current_  = _IndexT();
+};
+
+// clang-format off
+namespace views {
+namespace __repeat {
+struct __fn {
+  template <class _Tp>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Tp&& __value)
+    noexcept(noexcept(ranges::repeat_view<decay_t<_Tp>>(std::forward<_Tp>(__value))))
+    -> decltype(      ranges::repeat_view<decay_t<_Tp>>(std::forward<_Tp>(__value)))
+    { return          ranges::repeat_view<decay_t<_Tp>>(std::forward<_Tp>(__value)); }
+
+  template <class _Tp, class _Bound>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Tp&& __value, _Bound&& __bound_sentinel)
+    noexcept(noexcept(ranges::repeat_view(std::forward<_Tp>(__value), std::forward<_Bound>(__bound_sentinel))))
+    -> decltype(      ranges::repeat_view(std::forward<_Tp>(__value), std::forward<_Bound>(__bound_sentinel)))
+    { return          ranges::repeat_view(std::forward<_Tp>(__value), std::forward<_Bound>(__bound_sentinel)); }
+};
+} // namespace __repeat
+// clang-format on
+
+inline namespace __cpo {
+inline constexpr auto repeat = __repeat::__fn{};
+} // namespace __cpo
+} // namespace views
+
+template <class _Tp>
+inline constexpr bool __is_repeat_specialization = false;
+
+template <class _Tp, class _Bound>
+inline constexpr bool __is_repeat_specialization<repeat_view<_Tp, _Bound>> = true;
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_REPEAT_VIEW_H
diff --git a/third_party/libcxx/__ranges/reverse_view.h b/third_party/libcxx/__ranges/reverse_view.h
index 01d1b97b3..796f5be22 100644
--- a/third_party/libcxx/__ranges/reverse_view.h
+++ b/third_party/libcxx/__ranges/reverse_view.h
@@ -33,160 +33,171 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<view _View>
-    requires bidirectional_range<_View>
-  class reverse_view : public view_interface<reverse_view<_View>> {
-    // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
-    // amortized O(1) begin() method.
-    static constexpr bool _UseCache = !random_access_range<_View> && !common_range<_View>;
-    using _Cache = _If<_UseCache, __non_propagating_cache<reverse_iterator<iterator_t<_View>>>, __empty_cache>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
-    _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
+template <view _View>
+  requires bidirectional_range<_View>
+class reverse_view : public view_interface<reverse_view<_View>> {
+  // We cache begin() whenever ranges::next is not guaranteed O(1) to provide an
+  // amortized O(1) begin() method.
+  static constexpr bool _UseCache = !random_access_range<_View> && !common_range<_View>;
+  using _Cache = _If<_UseCache, __non_propagating_cache<reverse_iterator<iterator_t<_View>>>, __empty_cache>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
+  _LIBCPP_NO_UNIQUE_ADDRESS _View __base_          = _View();
 
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    reverse_view() requires default_initializable<_View> = default;
+public:
+  _LIBCPP_HIDE_FROM_ABI reverse_view()
+    requires default_initializable<_View>
+  = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit reverse_view(_View __view) : __base_(std::move(__view)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit reverse_view(_View __view) : __base_(std::move(__view)) {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _View base() && { return std::move(__base_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr reverse_iterator<iterator_t<_View>> begin() {
-      if constexpr (_UseCache)
-        if (__cached_begin_.__has_value())
-          return *__cached_begin_;
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator<iterator_t<_View>> begin() {
+    if constexpr (_UseCache)
+      if (__cached_begin_.__has_value())
+        return *__cached_begin_;
 
-      auto __tmp = std::make_reverse_iterator(ranges::next(ranges::begin(__base_), ranges::end(__base_)));
-      if constexpr (_UseCache)
-        __cached_begin_.__emplace(__tmp);
-      return __tmp;
-    }
+    auto __tmp = std::make_reverse_iterator(ranges::next(ranges::begin(__base_), ranges::end(__base_)));
+    if constexpr (_UseCache)
+      __cached_begin_.__emplace(__tmp);
+    return __tmp;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr reverse_iterator<iterator_t<_View>> begin() requires common_range<_View> {
-      return std::make_reverse_iterator(ranges::end(__base_));
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator<iterator_t<_View>> begin()
+    requires common_range<_View>
+  {
+    return std::make_reverse_iterator(ranges::end(__base_));
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto begin() const requires common_range<const _View> {
-      return std::make_reverse_iterator(ranges::end(__base_));
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires common_range<const _View>
+  {
+    return std::make_reverse_iterator(ranges::end(__base_));
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr reverse_iterator<iterator_t<_View>> end() {
-      return std::make_reverse_iterator(ranges::begin(__base_));
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator<iterator_t<_View>> end() {
+    return std::make_reverse_iterator(ranges::begin(__base_));
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto end() const requires common_range<const _View> {
-      return std::make_reverse_iterator(ranges::begin(__base_));
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires common_range<const _View>
+  {
+    return std::make_reverse_iterator(ranges::begin(__base_));
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() requires sized_range<_View> {
-      return ranges::size(__base_);
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    return ranges::size(__base_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr auto size() const requires sized_range<const _View> {
-      return ranges::size(__base_);
-    }
-  };
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    return ranges::size(__base_);
+  }
+};
 
-  template<class _Range>
-  reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
+template <class _Range>
+reverse_view(_Range&&) -> reverse_view<views::all_t<_Range>>;
 
-  template<class _Tp>
-  inline constexpr bool enable_borrowed_range<reverse_view<_Tp>> = enable_borrowed_range<_Tp>;
+template <class _Tp>
+inline constexpr bool enable_borrowed_range<reverse_view<_Tp>> = enable_borrowed_range<_Tp>;
 
-  namespace views {
-  namespace __reverse {
-    template<class _Tp>
-    inline constexpr bool __is_reverse_view = false;
+namespace views {
+namespace __reverse {
+template <class _Tp>
+inline constexpr bool __is_reverse_view = false;
 
-    template<class _Tp>
-    inline constexpr bool __is_reverse_view<reverse_view<_Tp>> = true;
+template <class _Tp>
+inline constexpr bool __is_reverse_view<reverse_view<_Tp>> = true;
 
-    template<class _Tp>
-    inline constexpr bool __is_sized_reverse_subrange = false;
+template <class _Tp>
+inline constexpr bool __is_sized_reverse_subrange = false;
 
-    template<class _Iter>
-    inline constexpr bool __is_sized_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, subrange_kind::sized>> = true;
+template <class _Iter>
+inline constexpr bool
+    __is_sized_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, subrange_kind::sized>> =
+        true;
 
-    template<class _Tp>
-    inline constexpr bool __is_unsized_reverse_subrange = false;
+template <class _Tp>
+inline constexpr bool __is_unsized_reverse_subrange = false;
 
-    template<class _Iter, subrange_kind _Kind>
-    inline constexpr bool __is_unsized_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, _Kind>> = _Kind == subrange_kind::unsized;
+template <class _Iter, subrange_kind _Kind>
+inline constexpr bool __is_unsized_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, _Kind>> =
+    _Kind == subrange_kind::unsized;
 
-    template<class _Tp>
-    struct __unwrapped_reverse_subrange {
-      using type = void; // avoid SFINAE-ing out the overload below -- let the concept requirements do it for better diagnostics
-    };
+template <class _Tp>
+struct __unwrapped_reverse_subrange {
+  using type =
+      void; // avoid SFINAE-ing out the overload below -- let the concept requirements do it for better diagnostics
+};
 
-    template<class _Iter, subrange_kind _Kind>
-    struct __unwrapped_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, _Kind>> {
-      using type = subrange<_Iter, _Iter, _Kind>;
-    };
+template <class _Iter, subrange_kind _Kind>
+struct __unwrapped_reverse_subrange<subrange<reverse_iterator<_Iter>, reverse_iterator<_Iter>, _Kind>> {
+  using type = subrange<_Iter, _Iter, _Kind>;
+};
 
-    struct __fn : __range_adaptor_closure<__fn> {
-      template<class _Range>
-        requires __is_reverse_view<remove_cvref_t<_Range>>
-      [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-      constexpr auto operator()(_Range&& __range) const
-        noexcept(noexcept(std::forward<_Range>(__range).base()))
-        -> decltype(      std::forward<_Range>(__range).base())
-        { return          std::forward<_Range>(__range).base(); }
+struct __fn : __range_adaptor_closure<__fn> {
+  template <class _Range>
+    requires __is_reverse_view<remove_cvref_t<_Range>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(std::forward<_Range>(__range).base())) -> decltype(std::forward<_Range>(__range).base()) {
+    return std::forward<_Range>(__range).base();
+  }
 
-      template<class _Range,
-               class _UnwrappedSubrange = typename __unwrapped_reverse_subrange<remove_cvref_t<_Range>>::type>
-        requires __is_sized_reverse_subrange<remove_cvref_t<_Range>>
-      [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-      constexpr auto operator()(_Range&& __range) const
-        noexcept(noexcept(_UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size())))
-        -> decltype(      _UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size()))
-        { return          _UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size()); }
+  template <class _Range,
+            class _UnwrappedSubrange = typename __unwrapped_reverse_subrange<remove_cvref_t<_Range>>::type>
+    requires __is_sized_reverse_subrange<remove_cvref_t<_Range>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(_UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size())))
+          -> decltype(_UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size())) {
+    return _UnwrappedSubrange(__range.end().base(), __range.begin().base(), __range.size());
+  }
 
-      template<class _Range,
-               class _UnwrappedSubrange = typename __unwrapped_reverse_subrange<remove_cvref_t<_Range>>::type>
-        requires __is_unsized_reverse_subrange<remove_cvref_t<_Range>>
-      [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-      constexpr auto operator()(_Range&& __range) const
-        noexcept(noexcept(_UnwrappedSubrange(__range.end().base(), __range.begin().base())))
-        -> decltype(      _UnwrappedSubrange(__range.end().base(), __range.begin().base()))
-        { return          _UnwrappedSubrange(__range.end().base(), __range.begin().base()); }
+  template <class _Range,
+            class _UnwrappedSubrange = typename __unwrapped_reverse_subrange<remove_cvref_t<_Range>>::type>
+    requires __is_unsized_reverse_subrange<remove_cvref_t<_Range>>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(_UnwrappedSubrange(__range.end().base(), __range.begin().base())))
+          -> decltype(_UnwrappedSubrange(__range.end().base(), __range.begin().base())) {
+    return _UnwrappedSubrange(__range.end().base(), __range.begin().base());
+  }
 
-      template<class _Range>
-        requires (!__is_reverse_view<remove_cvref_t<_Range>> &&
-                  !__is_sized_reverse_subrange<remove_cvref_t<_Range>> &&
-                  !__is_unsized_reverse_subrange<remove_cvref_t<_Range>>)
-      [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-      constexpr auto operator()(_Range&& __range) const
-        noexcept(noexcept(reverse_view{std::forward<_Range>(__range)}))
-        -> decltype(      reverse_view{std::forward<_Range>(__range)})
-        { return          reverse_view{std::forward<_Range>(__range)}; }
-    };
-  } // namespace __reverse
+  template <class _Range>
+    requires(!__is_reverse_view<remove_cvref_t<_Range>> && !__is_sized_reverse_subrange<remove_cvref_t<_Range>> &&
+             !__is_unsized_reverse_subrange<remove_cvref_t<_Range>>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const noexcept(noexcept(reverse_view{
+      std::forward<_Range>(__range)})) -> decltype(reverse_view{std::forward<_Range>(__range)}) {
+    return reverse_view{std::forward<_Range>(__range)};
+  }
+};
+} // namespace __reverse
 
-  inline namespace __cpo {
-    inline constexpr auto reverse = __reverse::__fn{};
-  } // namespace __cpo
-  } // namespace views
+inline namespace __cpo {
+inline constexpr auto reverse = __reverse::__fn{};
+} // namespace __cpo
+} // namespace views
 } // namespace ranges
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_REVERSE_VIEW_H
diff --git a/third_party/libcxx/__ranges/single_view.h b/third_party/libcxx/__ranges/single_view.h
index ccab2c166..45244f349 100644
--- a/third_party/libcxx/__ranges/single_view.h
+++ b/third_party/libcxx/__ranges/single_view.h
@@ -12,7 +12,7 @@
 
 #include <__concepts/constructible.h>
 #include <__config>
-#include <__ranges/copyable_box.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/decay.h>
@@ -26,72 +26,77 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<copy_constructible _Tp>
-    requires is_object_v<_Tp>
-  class single_view : public view_interface<single_view<_Tp>> {
-    __copyable_box<_Tp> __value_;
+#  if _LIBCPP_STD_VER >= 23
+template <move_constructible _Tp>
+#  else
+template <copy_constructible _Tp>
+#  endif
+  requires is_object_v<_Tp>
+class _LIBCPP_ABI_LLVM18_NO_UNIQUE_ADDRESS single_view : public view_interface<single_view<_Tp>> {
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Tp> __value_;
 
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    single_view() requires default_initializable<_Tp> = default;
+public:
+  _LIBCPP_HIDE_FROM_ABI single_view()
+    requires default_initializable<_Tp>
+  = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit single_view(const _Tp& __t) : __value_(in_place, __t) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit single_view(const _Tp& __t)
+#  if _LIBCPP_STD_VER >= 23
+    requires copy_constructible<_Tp>
+#  endif
+      : __value_(in_place, __t) {
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit single_view(_Tp&& __t) : __value_(in_place, std::move(__t)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit single_view(_Tp&& __t) : __value_(in_place, std::move(__t)) {}
 
-    template<class... _Args>
-      requires constructible_from<_Tp, _Args...>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr explicit single_view(in_place_t, _Args&&... __args)
+  template <class... _Args>
+    requires constructible_from<_Tp, _Args...>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit single_view(in_place_t, _Args&&... __args)
       : __value_{in_place, std::forward<_Args>(__args)...} {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp* begin() noexcept { return data(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* begin() noexcept { return data(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr const _Tp* begin() const noexcept { return data(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* begin() const noexcept { return data(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp* end() noexcept { return data() + 1; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* end() noexcept { return data() + 1; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr const _Tp* end() const noexcept { return data() + 1; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* end() const noexcept { return data() + 1; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr size_t size() noexcept { return 1; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return false; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Tp* data() noexcept { return __value_.operator->(); }
+  _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 1; }
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr const _Tp* data() const noexcept { return __value_.operator->(); }
-  };
+  _LIBCPP_HIDE_FROM_ABI constexpr _Tp* data() noexcept { return __value_.operator->(); }
 
-template<class _Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* data() const noexcept { return __value_.operator->(); }
+};
+
+template <class _Tp>
 single_view(_Tp) -> single_view<_Tp>;
 
 namespace views {
 namespace __single_view {
 
 struct __fn : __range_adaptor_closure<__fn> {
-  template<class _Range>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range) const
-    noexcept(noexcept(single_view<decay_t<_Range&&>>(std::forward<_Range>(__range))))
-    -> decltype(      single_view<decay_t<_Range&&>>(std::forward<_Range>(__range)))
-    { return          single_view<decay_t<_Range&&>>(std::forward<_Range>(__range)); }
+  template <class _Range>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range) const
+      noexcept(noexcept(single_view<decay_t<_Range&&>>(std::forward<_Range>(__range))))
+          -> decltype(single_view<decay_t<_Range&&>>(std::forward<_Range>(__range))) {
+    return single_view<decay_t<_Range&&>>(std::forward<_Range>(__range));
+  }
 };
 } // namespace __single_view
 
 inline namespace __cpo {
-  inline constexpr auto single = __single_view::__fn{};
+inline constexpr auto single = __single_view::__fn{};
 } // namespace __cpo
 
 } // namespace views
@@ -101,4 +106,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_SINGLE_VIEW_H
diff --git a/third_party/libcxx/__ranges/size.h b/third_party/libcxx/__ranges/size.h
index f22dd1ff7..40b0c6b6a 100644
--- a/third_party/libcxx/__ranges/size.h
+++ b/third_party/libcxx/__ranges/size.h
@@ -33,49 +33,38 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<class>
-  inline constexpr bool disable_sized_range = false;
+template <class>
+inline constexpr bool disable_sized_range = false;
 } // namespace ranges
 
 // [range.prim.size]
 
 namespace ranges {
 namespace __size {
-void size(auto&) = delete;
-void size(const auto&) = delete;
+void size() = delete;
 
 template <class _Tp>
 concept __size_enabled = !disable_sized_range<remove_cvref_t<_Tp>>;
 
 template <class _Tp>
-concept __member_size =
-  __size_enabled<_Tp> &&
-  __workaround_52970<_Tp> &&
-  requires(_Tp&& __t) {
-    { _LIBCPP_AUTO_CAST(__t.size()) } -> __integer_like;
-  };
+concept __member_size = __size_enabled<_Tp> && requires(_Tp&& __t) {
+  { _LIBCPP_AUTO_CAST(__t.size()) } -> __integer_like;
+};
 
 template <class _Tp>
 concept __unqualified_size =
-  __size_enabled<_Tp> &&
-  !__member_size<_Tp> &&
-  __class_or_enum<remove_cvref_t<_Tp>> &&
-  requires(_Tp&& __t) {
-    { _LIBCPP_AUTO_CAST(size(__t)) } -> __integer_like;
-  };
+    __size_enabled<_Tp> && !__member_size<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+      { _LIBCPP_AUTO_CAST(size(__t)) } -> __integer_like;
+    };
 
 template <class _Tp>
 concept __difference =
-  !__member_size<_Tp> &&
-  !__unqualified_size<_Tp> &&
-  __class_or_enum<remove_cvref_t<_Tp>> &&
-  requires(_Tp&& __t) {
-    { ranges::begin(__t) } -> forward_iterator;
-    { ranges::end(__t) } -> sized_sentinel_for<decltype(ranges::begin(std::declval<_Tp>()))>;
-  };
+    !__member_size<_Tp> && !__unqualified_size<_Tp> && __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
+      { ranges::begin(__t) } -> forward_iterator;
+      { ranges::end(__t) } -> sized_sentinel_for<decltype(ranges::begin(std::declval<_Tp>()))>;
+    };
 
 struct __fn {
-
   // `[range.prim.size]`: the array case (for rvalues).
   template <class _Tp, size_t _Sz>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t operator()(_Tp (&&)[_Sz]) const noexcept {
@@ -105,16 +94,16 @@ struct __fn {
   // [range.prim.size]: the `to-unsigned-like` case.
   template <__difference _Tp>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Tp&& __t) const
-    noexcept(noexcept(std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t))))
-    -> decltype(      std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t)))
-    { return          std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
+      noexcept(noexcept(std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t))))
+          -> decltype(std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t))) {
+    return std::__to_unsigned_like(ranges::end(__t) - ranges::begin(__t));
   }
 };
 
 } // namespace __size
 
 inline namespace __cpo {
-  inline constexpr auto size = __size::__fn{};
+inline constexpr auto size = __size::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
@@ -123,10 +112,10 @@ inline namespace __cpo {
 namespace ranges {
 namespace __ssize {
 struct __fn {
-  template<class _Tp>
-    requires requires (_Tp&& __t) { ranges::size(__t); }
+  template <class _Tp>
+    requires requires(_Tp&& __t) { ranges::size(__t); }
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr integral auto operator()(_Tp&& __t) const
-    noexcept(noexcept(ranges::size(__t))) {
+      noexcept(noexcept(ranges::size(__t))) {
     using _Signed = make_signed_t<decltype(ranges::size(__t))>;
     if constexpr (sizeof(ptrdiff_t) > sizeof(_Signed))
       return static_cast<ptrdiff_t>(ranges::size(__t));
@@ -137,7 +126,7 @@ struct __fn {
 } // namespace __ssize
 
 inline namespace __cpo {
-  inline constexpr auto ssize = __ssize::__fn{};
+inline constexpr auto ssize = __ssize::__fn{};
 } // namespace __cpo
 } // namespace ranges
 
diff --git a/third_party/libcxx/__ranges/split_view.h b/third_party/libcxx/__ranges/split_view.h
index a27ac4ef7..ce3606aed 100644
--- a/third_party/libcxx/__ranges/split_view.h
+++ b/third_party/libcxx/__ranges/split_view.h
@@ -36,6 +36,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -194,10 +197,10 @@ public:
 
 namespace views {
 namespace __split_view {
-struct __fn : __range_adaptor_closure<__fn> {
+struct __fn {
   // clang-format off
   template <class _Range, class _Pattern>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
   constexpr auto operator()(_Range&& __range, _Pattern&& __pattern) const
     noexcept(noexcept(split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern))))
     -> decltype(      split_view(std::forward<_Range>(__range), std::forward<_Pattern>(__pattern)))
@@ -206,7 +209,7 @@ struct __fn : __range_adaptor_closure<__fn> {
 
   template <class _Pattern>
     requires constructible_from<decay_t<_Pattern>, _Pattern>
-  _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pattern&& __pattern) const
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Pattern&& __pattern) const
       noexcept(is_nothrow_constructible_v<decay_t<_Pattern>, _Pattern>) {
     return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Pattern>(__pattern)));
   }
@@ -224,4 +227,6 @@ inline constexpr auto split = __split_view::__fn{};
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_SPLIT_VIEW_H
diff --git a/third_party/libcxx/__ranges/subrange.h b/third_party/libcxx/__ranges/subrange.h
index a51364de6..aba584ef9 100644
--- a/third_party/libcxx/__ranges/subrange.h
+++ b/third_party/libcxx/__ranges/subrange.h
@@ -17,7 +17,6 @@
 #include <__concepts/derived_from.h>
 #include <__concepts/different_from.h>
 #include <__config>
-#include <__fwd/get.h>
 #include <__fwd/subrange.h>
 #include <__iterator/advance.h>
 #include <__iterator/concepts.h>
@@ -29,8 +28,8 @@
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
-#include <__tuple/pair_like.h>
 #include <__tuple/tuple_element.h>
+#include <__tuple/tuple_like_no_subrange.h>
 #include <__tuple/tuple_size.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/decay.h>
@@ -46,213 +45,194 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
-  template<class _From, class _To>
-  concept __uses_nonqualification_pointer_conversion =
+template <class _From, class _To>
+concept __uses_nonqualification_pointer_conversion =
     is_pointer_v<_From> && is_pointer_v<_To> &&
-    !convertible_to<remove_pointer_t<_From>(*)[], remove_pointer_t<_To>(*)[]>;
+    !convertible_to<remove_pointer_t<_From> (*)[], remove_pointer_t<_To> (*)[]>;
 
-  template<class _From, class _To>
-  concept __convertible_to_non_slicing =
-    convertible_to<_From, _To> &&
-    !__uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>;
+template <class _From, class _To>
+concept __convertible_to_non_slicing =
+    convertible_to<_From, _To> && !__uses_nonqualification_pointer_conversion<decay_t<_From>, decay_t<_To>>;
 
-  template<class _Pair, class _Iter, class _Sent>
-  concept __pair_like_convertible_from =
-    !range<_Pair> && __pair_like<_Pair> &&
-    constructible_from<_Pair, _Iter, _Sent> &&
-    __convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> &&
-    convertible_to<_Sent, tuple_element_t<1, _Pair>>;
+template <class _Pair, class _Iter, class _Sent>
+concept __pair_like_convertible_from =
+    !range<_Pair> && __pair_like_no_subrange<_Pair> && constructible_from<_Pair, _Iter, _Sent> &&
+    __convertible_to_non_slicing<_Iter, tuple_element_t<0, _Pair>> && convertible_to<_Sent, tuple_element_t<1, _Pair>>;
 
-  template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
-           subrange_kind _Kind = sized_sentinel_for<_Sent, _Iter>
-             ? subrange_kind::sized
-             : subrange_kind::unsized>
-    requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
-  class _LIBCPP_TEMPLATE_VIS subrange
-    : public view_interface<subrange<_Iter, _Sent, _Kind>>
-  {
-  public:
-    // Note: this is an internal implementation detail that is public only for internal usage.
-    static constexpr bool _StoreSize = (_Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>);
+template <input_or_output_iterator _Iter,
+          sentinel_for<_Iter> _Sent = _Iter,
+          subrange_kind _Kind       = sized_sentinel_for<_Sent, _Iter> ? subrange_kind::sized : subrange_kind::unsized>
+  requires(_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _Iter>)
+class _LIBCPP_TEMPLATE_VIS subrange : public view_interface<subrange<_Iter, _Sent, _Kind>> {
+public:
+  // Note: this is an internal implementation detail that is public only for internal usage.
+  static constexpr bool _StoreSize = (_Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _Iter>);
 
-  private:
-    static constexpr bool _MustProvideSizeAtConstruction = !_StoreSize; // just to improve compiler diagnostics
-    struct _Empty { _LIBCPP_HIDE_FROM_ABI constexpr _Empty(auto) noexcept { } };
-    using _Size = conditional_t<_StoreSize, make_unsigned_t<iter_difference_t<_Iter>>, _Empty>;
-    _LIBCPP_NO_UNIQUE_ADDRESS _Iter __begin_ = _Iter();
-    _LIBCPP_NO_UNIQUE_ADDRESS _Sent __end_ = _Sent();
-    _LIBCPP_NO_UNIQUE_ADDRESS _Size __size_ = 0;
-
-  public:
-    _LIBCPP_HIDE_FROM_ABI
-    subrange() requires default_initializable<_Iter> = default;
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent)
-      requires _MustProvideSizeAtConstruction
-      : __begin_(std::move(__iter)), __end_(std::move(__sent))
-    { }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent,
-                       make_unsigned_t<iter_difference_t<_Iter>> __n)
-      requires (_Kind == subrange_kind::sized)
-      : __begin_(std::move(__iter)), __end_(std::move(__sent)), __size_(__n)
-    {
-      if constexpr (sized_sentinel_for<_Sent, _Iter>)
-        _LIBCPP_ASSERT((__end_ - __begin_) == static_cast<iter_difference_t<_Iter>>(__n),
-          "std::ranges::subrange was passed an invalid size hint");
-    }
-
-    template<__different_from<subrange> _Range>
-      requires borrowed_range<_Range> &&
-               __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
-               convertible_to<sentinel_t<_Range>, _Sent>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange(_Range&& __range)
-      requires (!_StoreSize)
-      : subrange(ranges::begin(__range), ranges::end(__range))
-    { }
-
-    template<__different_from<subrange> _Range>
-      requires borrowed_range<_Range> &&
-               __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
-               convertible_to<sentinel_t<_Range>, _Sent>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange(_Range&& __range)
-      requires _StoreSize && sized_range<_Range>
-      : subrange(__range, ranges::size(__range))
-    { }
-
-    template<borrowed_range _Range>
-      requires __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
-               convertible_to<sentinel_t<_Range>, _Sent>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange(_Range&& __range, make_unsigned_t<iter_difference_t<_Iter>> __n)
-      requires (_Kind == subrange_kind::sized)
-      : subrange(ranges::begin(__range), ranges::end(__range), __n)
-    { }
-
-    template<__different_from<subrange> _Pair>
-      requires __pair_like_convertible_from<_Pair, const _Iter&, const _Sent&>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr operator _Pair() const {
-      return _Pair(__begin_, __end_);
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Iter begin() const requires copyable<_Iter> {
-      return __begin_;
-    }
-
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter begin() requires (!copyable<_Iter>) {
-      return std::move(__begin_);
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Sent end() const {
-      return __end_;
-    }
-
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const {
-      return __begin_ == __end_;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr make_unsigned_t<iter_difference_t<_Iter>> size() const
-      requires (_Kind == subrange_kind::sized)
-    {
-      if constexpr (_StoreSize)
-        return __size_;
-      else
-        return std::__to_unsigned_like(__end_ - __begin_);
-    }
-
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) const&
-      requires forward_iterator<_Iter>
-    {
-      auto __tmp = *this;
-      __tmp.advance(__n);
-      return __tmp;
-    }
-
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) && {
-      advance(__n);
-      return std::move(*this);
-    }
-
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange prev(iter_difference_t<_Iter> __n = 1) const
-      requires bidirectional_iterator<_Iter>
-    {
-      auto __tmp = *this;
-      __tmp.advance(-__n);
-      return __tmp;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr subrange& advance(iter_difference_t<_Iter> __n) {
-      if constexpr (bidirectional_iterator<_Iter>) {
-        if (__n < 0) {
-          ranges::advance(__begin_, __n);
-          if constexpr (_StoreSize)
-            __size_ += std::__to_unsigned_like(-__n);
-          return *this;
-        }
-      }
-
-      auto __d = __n - ranges::advance(__begin_, __n, __end_);
-      if constexpr (_StoreSize)
-        __size_ -= std::__to_unsigned_like(__d);
-      return *this;
-    }
+private:
+  static constexpr bool _MustProvideSizeAtConstruction = !_StoreSize; // just to improve compiler diagnostics
+  struct _Empty {
+    _LIBCPP_HIDE_FROM_ABI constexpr _Empty(auto) noexcept {}
   };
+  using _Size = conditional_t<_StoreSize, make_unsigned_t<iter_difference_t<_Iter>>, _Empty>;
+  _LIBCPP_NO_UNIQUE_ADDRESS _Iter __begin_ = _Iter();
+  _LIBCPP_NO_UNIQUE_ADDRESS _Sent __end_   = _Sent();
+  _LIBCPP_NO_UNIQUE_ADDRESS _Size __size_  = 0;
 
-  template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
-  subrange(_Iter, _Sent) -> subrange<_Iter, _Sent>;
+public:
+  _LIBCPP_HIDE_FROM_ABI subrange()
+    requires default_initializable<_Iter>
+  = default;
 
-  template<input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
-  subrange(_Iter, _Sent, make_unsigned_t<iter_difference_t<_Iter>>)
-    -> subrange<_Iter, _Sent, subrange_kind::sized>;
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange(__convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent)
+    requires _MustProvideSizeAtConstruction
+      : __begin_(std::move(__iter)), __end_(std::move(__sent)) {}
 
-  template<borrowed_range _Range>
-  subrange(_Range&&) -> subrange<iterator_t<_Range>, sentinel_t<_Range>,
-                                 (sized_range<_Range> || sized_sentinel_for<sentinel_t<_Range>, iterator_t<_Range>>)
-                                   ? subrange_kind::sized : subrange_kind::unsized>;
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange(
+      __convertible_to_non_slicing<_Iter> auto __iter, _Sent __sent, make_unsigned_t<iter_difference_t<_Iter>> __n)
+    requires(_Kind == subrange_kind::sized)
+      : __begin_(std::move(__iter)), __end_(std::move(__sent)), __size_(__n) {
+    if constexpr (sized_sentinel_for<_Sent, _Iter>)
+      _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS((__end_ - __begin_) == static_cast<iter_difference_t<_Iter>>(__n),
+                                          "std::ranges::subrange was passed an invalid size hint");
+  }
 
-  template<borrowed_range _Range>
-  subrange(_Range&&, make_unsigned_t<range_difference_t<_Range>>)
+  template <__different_from<subrange> _Range>
+    requires borrowed_range<_Range> && __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+             convertible_to<sentinel_t<_Range>, _Sent>
+             _LIBCPP_HIDE_FROM_ABI constexpr subrange(_Range&& __range)
+               requires(!_StoreSize)
+      : subrange(ranges::begin(__range), ranges::end(__range)) {}
+
+  template <__different_from<subrange> _Range>
+    requires borrowed_range<_Range> && __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+             convertible_to<sentinel_t<_Range>, _Sent>
+             _LIBCPP_HIDE_FROM_ABI constexpr subrange(_Range&& __range)
+               requires _StoreSize && sized_range<_Range>
+      : subrange(__range, ranges::size(__range)) {}
+
+  template <borrowed_range _Range>
+    requires __convertible_to_non_slicing<iterator_t<_Range>, _Iter> &&
+             convertible_to<sentinel_t<_Range>, _Sent>
+             _LIBCPP_HIDE_FROM_ABI constexpr subrange(_Range&& __range, make_unsigned_t<iter_difference_t<_Iter>> __n)
+               requires(_Kind == subrange_kind::sized)
+      : subrange(ranges::begin(__range), ranges::end(__range), __n) {}
+
+  template <__pair_like_convertible_from<const _Iter&, const _Sent&> _Pair>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator _Pair() const {
+    return _Pair(__begin_, __end_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Iter begin() const
+    requires copyable<_Iter>
+  {
+    return __begin_;
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Iter begin()
+    requires(!copyable<_Iter>)
+  {
+    return std::move(__begin_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr _Sent end() const { return __end_; }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const { return __begin_ == __end_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr make_unsigned_t<iter_difference_t<_Iter>> size() const
+    requires(_Kind == subrange_kind::sized)
+  {
+    if constexpr (_StoreSize)
+      return __size_;
+    else
+      return std::__to_unsigned_like(__end_ - __begin_);
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) const&
+    requires forward_iterator<_Iter>
+  {
+    auto __tmp = *this;
+    __tmp.advance(__n);
+    return __tmp;
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange next(iter_difference_t<_Iter> __n = 1) && {
+    advance(__n);
+    return std::move(*this);
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr subrange prev(iter_difference_t<_Iter> __n = 1) const
+    requires bidirectional_iterator<_Iter>
+  {
+    auto __tmp = *this;
+    __tmp.advance(-__n);
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr subrange& advance(iter_difference_t<_Iter> __n) {
+    if constexpr (bidirectional_iterator<_Iter>) {
+      if (__n < 0) {
+        ranges::advance(__begin_, __n);
+        if constexpr (_StoreSize)
+          __size_ += std::__to_unsigned_like(-__n);
+        return *this;
+      }
+    }
+
+    auto __d = __n - ranges::advance(__begin_, __n, __end_);
+    if constexpr (_StoreSize)
+      __size_ -= std::__to_unsigned_like(__d);
+    return *this;
+  }
+};
+
+template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+subrange(_Iter, _Sent) -> subrange<_Iter, _Sent>;
+
+template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
+subrange(_Iter, _Sent, make_unsigned_t<iter_difference_t<_Iter>>) -> subrange<_Iter, _Sent, subrange_kind::sized>;
+
+template <borrowed_range _Range>
+subrange(_Range&&) -> subrange<iterator_t<_Range>,
+                               sentinel_t<_Range>,
+                               (sized_range<_Range> || sized_sentinel_for<sentinel_t<_Range>, iterator_t<_Range>>)
+                                   ? subrange_kind::sized
+                                   : subrange_kind::unsized>;
+
+template <borrowed_range _Range>
+subrange(_Range&&, make_unsigned_t<range_difference_t<_Range>>)
     -> subrange<iterator_t<_Range>, sentinel_t<_Range>, subrange_kind::sized>;
 
-  template<size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
-    requires ((_Index == 0 && copyable<_Iter>) || _Index == 1)
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange) {
-    if constexpr (_Index == 0)
-      return __subrange.begin();
-    else
-      return __subrange.end();
-  }
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+  requires((_Index == 0 && copyable<_Iter>) || _Index == 1)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(const subrange<_Iter, _Sent, _Kind>& __subrange) {
+  if constexpr (_Index == 0)
+    return __subrange.begin();
+  else
+    return __subrange.end();
+}
 
-  template<size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
-    requires (_Index < 2)
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange) {
-    if constexpr (_Index == 0)
-      return __subrange.begin();
-    else
-      return __subrange.end();
-  }
+template <size_t _Index, class _Iter, class _Sent, subrange_kind _Kind>
+  requires(_Index < 2)
+_LIBCPP_HIDE_FROM_ABI constexpr auto get(subrange<_Iter, _Sent, _Kind>&& __subrange) {
+  if constexpr (_Index == 0)
+    return __subrange.begin();
+  else
+    return __subrange.end();
+}
 
-  template<class _Ip, class _Sp, subrange_kind _Kp>
-  inline constexpr bool enable_borrowed_range<subrange<_Ip, _Sp, _Kp>> = true;
+template <class _Ip, class _Sp, subrange_kind _Kp>
+inline constexpr bool enable_borrowed_range<subrange<_Ip, _Sp, _Kp>> = true;
 
-  template<range _Rp>
-  using borrowed_subrange_t = _If<borrowed_range<_Rp>, subrange<iterator_t<_Rp>>, dangling>;
+template <range _Rp>
+using borrowed_subrange_t = _If<borrowed_range<_Rp>, subrange<iterator_t<_Rp>>, dangling>;
 } // namespace ranges
 
 // [range.subrange.general]
@@ -261,25 +241,25 @@ using ranges::get;
 
 // [ranges.syn]
 
-template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
 struct tuple_size<ranges::subrange<_Ip, _Sp, _Kp>> : integral_constant<size_t, 2> {};
 
-template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
 struct tuple_element<0, ranges::subrange<_Ip, _Sp, _Kp>> {
   using type = _Ip;
 };
 
-template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
 struct tuple_element<1, ranges::subrange<_Ip, _Sp, _Kp>> {
   using type = _Sp;
 };
 
-template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
 struct tuple_element<0, const ranges::subrange<_Ip, _Sp, _Kp>> {
   using type = _Ip;
 };
 
-template<class _Ip, class _Sp, ranges::subrange_kind _Kp>
+template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
 struct tuple_element<1, const ranges::subrange<_Ip, _Sp, _Kp>> {
   using type = _Sp;
 };
@@ -288,4 +268,6 @@ struct tuple_element<1, const ranges::subrange<_Ip, _Sp, _Kp>> {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_SUBRANGE_H
diff --git a/third_party/libcxx/__ranges/take_view.h b/third_party/libcxx/__ranges/take_view.h
index 111e7e5ba..27ca8155a 100644
--- a/third_party/libcxx/__ranges/take_view.h
+++ b/third_party/libcxx/__ranges/take_view.h
@@ -31,6 +31,7 @@
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/iota_view.h>
 #include <__ranges/range_adaptor.h>
+#include <__ranges/repeat_view.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/view_interface.h>
@@ -56,37 +57,42 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-template<view _View>
+template <view _View>
 class take_view : public view_interface<take_view<_View>> {
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-  range_difference_t<_View> __count_ = 0;
+  range_difference_t<_View> __count_      = 0;
 
-  template<bool> class __sentinel;
+  template <bool>
+  class __sentinel;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  take_view() requires default_initializable<_View> = default;
+  _LIBCPP_HIDE_FROM_ABI take_view()
+    requires default_initializable<_View>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 take_view(_View __base, range_difference_t<_View> __count)
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23
+  take_view(_View __base, range_difference_t<_View> __count)
       : __base_(std::move(__base)), __count_(__count) {
-    _LIBCPP_ASSERT(__count >= 0, "count has to be greater than or equal to zero");
+    _LIBCPP_ASSERT_UNCATEGORIZED(__count >= 0, "count has to be greater than or equal to zero");
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
+  }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() && { return std::move(__base_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() requires (!__simple_view<_View>) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!__simple_view<_View>)
+  {
     if constexpr (sized_range<_View>) {
       if constexpr (random_access_range<_View>) {
         return ranges::begin(__base_);
       } else {
         using _DifferenceT = range_difference_t<_View>;
-        auto __size = size();
+        auto __size        = size();
         return counted_iterator(ranges::begin(__base_), static_cast<_DifferenceT>(__size));
       }
     } else {
@@ -94,14 +100,15 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() const requires range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires range<const _View>
+  {
     if constexpr (sized_range<const _View>) {
       if constexpr (random_access_range<const _View>) {
         return ranges::begin(__base_);
       } else {
         using _DifferenceT = range_difference_t<const _View>;
-        auto __size = size();
+        auto __size        = size();
         return counted_iterator(ranges::begin(__base_), static_cast<_DifferenceT>(__size));
       }
     } else {
@@ -109,8 +116,9 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() requires (!__simple_view<_View>) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!__simple_view<_View>)
+  {
     if constexpr (sized_range<_View>) {
       if constexpr (random_access_range<_View>) {
         return ranges::begin(__base_) + size();
@@ -122,8 +130,9 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() const requires range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires range<const _View>
+  {
     if constexpr (sized_range<const _View>) {
       if constexpr (random_access_range<const _View>) {
         return ranges::begin(__base_) + size();
@@ -135,62 +144,58 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() requires sized_range<_View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
     auto __n = ranges::size(__base_);
     return ranges::min(__n, static_cast<decltype(__n)>(__count_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() const requires sized_range<const _View> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
     auto __n = ranges::size(__base_);
     return ranges::min(__n, static_cast<decltype(__n)>(__count_));
   }
 };
 
-template<view _View>
-template<bool _Const>
+template <view _View>
+template <bool _Const>
 class take_view<_View>::__sentinel {
   using _Base = __maybe_const<_Const, _View>;
-  template<bool _OtherConst>
-  using _Iter = counted_iterator<iterator_t<__maybe_const<_OtherConst, _View>>>;
+  template <bool _OtherConst>
+  using _Iter                                        = counted_iterator<iterator_t<__maybe_const<_OtherConst, _View>>>;
   _LIBCPP_NO_UNIQUE_ADDRESS sentinel_t<_Base> __end_ = sentinel_t<_Base>();
 
-  template<bool>
+  template <bool>
   friend class take_view<_View>::__sentinel;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  __sentinel() = default;
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(std::move(__end)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(std::move(__end)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel(__sentinel<!_Const> __s)
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __s)
     requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
-    : __end_(std::move(__s.__end_)) {}
+      : __end_(std::move(__s.__end_)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr sentinel_t<_Base> base() const { return __end_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Base> base() const { return __end_; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
     return __lhs.count() == 0 || __lhs.base() == __rhs.__end_;
   }
 
-  template<bool _OtherConst = !_Const>
+  template <bool _OtherConst = !_Const>
     requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const _Iter<_OtherConst>& __lhs, const __sentinel& __rhs) {
     return __lhs.count() == 0 || __lhs.base() == __rhs.__end_;
   }
 };
 
-template<class _Range>
+template <class _Range>
 take_view(_Range&&, range_difference_t<_Range>) -> take_view<views::all_t<_Range>>;
 
-template<class _Tp>
+template <class _Tp>
 inline constexpr bool enable_borrowed_range<take_view<_Tp>> = enable_borrowed_range<_Tp>;
 
 namespace views {
@@ -234,7 +239,7 @@ struct __passthrough_type<basic_string_view<_CharT, _Traits>> {
 };
 
 template <class _Iter, class _Sent, subrange_kind _Kind>
-  requires requires{typename subrange<_Iter>;}
+  requires requires { typename subrange<_Iter>; }
 struct __passthrough_type<subrange<_Iter, _Sent, _Kind>> {
   using type = subrange<_Iter>;
 };
@@ -246,42 +251,36 @@ struct __fn {
   // [range.take.overview]: the `empty_view` case.
   template <class _Range, convertible_to<range_difference_t<_Range>> _Np>
     requires __is_empty_view<remove_cvref_t<_Range>>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range, _Np&&) const
-    noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
-    -> decltype(      _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)))
-    { return          _LIBCPP_AUTO_CAST(std::forward<_Range>(__range)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&&) const
+      noexcept(noexcept(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))))
+          -> decltype(_LIBCPP_AUTO_CAST(std::forward<_Range>(__range))) {
+    return _LIBCPP_AUTO_CAST(std::forward<_Range>(__range));
+  }
 
   // [range.take.overview]: the `span | basic_string_view | subrange` case.
   template <class _Range,
             convertible_to<range_difference_t<_Range>> _Np,
             class _RawRange = remove_cvref_t<_Range>,
-            class _Dist = range_difference_t<_Range>>
-    requires (!__is_empty_view<_RawRange> &&
-              random_access_range<_RawRange> &&
-              sized_range<_RawRange> &&
-              __is_passthrough_specialization<_RawRange>)
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __rng, _Np&& __n) const
-    noexcept(noexcept(__passthrough_type_t<_RawRange>(
-                              ranges::begin(__rng),
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
-                              )))
-    -> decltype(      __passthrough_type_t<_RawRange>(
-                              // Note: deliberately not forwarding `__rng` to guard against double moves.
-                              ranges::begin(__rng),
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
-                              ))
-    { return          __passthrough_type_t<_RawRange>(
-                              ranges::begin(__rng),
-                              ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
-                              ); }
+            class _Dist     = range_difference_t<_Range>>
+    requires(!__is_empty_view<_RawRange> && random_access_range<_RawRange> && sized_range<_RawRange> &&
+             __is_passthrough_specialization<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto
+  operator()(_Range&& __rng, _Np&& __n) const noexcept(noexcept(__passthrough_type_t<_RawRange>(
+      ranges::begin(__rng), ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))))
+      -> decltype(__passthrough_type_t<_RawRange>(
+          // Note: deliberately not forwarding `__rng` to guard against double moves.
+          ranges::begin(__rng),
+          ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))) {
+    return __passthrough_type_t<_RawRange>(
+        ranges::begin(__rng), ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)));
+  }
 
   // [range.take.overview]: the `iota_view` case.
+  // clang-format off
   template <class _Range,
             convertible_to<range_difference_t<_Range>> _Np,
             class _RawRange = remove_cvref_t<_Range>,
-            class _Dist = range_difference_t<_Range>>
+            class _Dist     = range_difference_t<_Range>>
     requires (!__is_empty_view<_RawRange> &&
               random_access_range<_RawRange> &&
               sized_range<_RawRange> &&
@@ -290,49 +289,72 @@ struct __fn {
   constexpr auto operator()(_Range&& __rng, _Np&& __n) const
     noexcept(noexcept(ranges::iota_view(
                               *ranges::begin(__rng),
-                              *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
+                              *(ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
                               )))
     -> decltype(      ranges::iota_view(
                               // Note: deliberately not forwarding `__rng` to guard against double moves.
                               *ranges::begin(__rng),
-                              *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
+                              *(ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
                               ))
     { return          ranges::iota_view(
                               *ranges::begin(__rng),
-                              *ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n))
+                              *(ranges::begin(__rng) + std::min<_Dist>(ranges::distance(__rng), std::forward<_Np>(__n)))
                               ); }
 
+#if _LIBCPP_STD_VER >= 23
+  // [range.take.overview]: the `repeat_view` "_RawRange models sized_range" case.
+  template <class _Range,
+            convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>,
+            class _Dist     = range_difference_t<_Range>>
+    requires(__is_repeat_specialization<_RawRange> && sized_range<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+    noexcept(noexcept(views::repeat(*__range.__value_, std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n)))))
+    -> decltype(      views::repeat(*__range.__value_, std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n))))
+    { return          views::repeat(*__range.__value_, std::min<_Dist>(ranges::distance(__range), std::forward<_Np>(__n))); }
+
+  // [range.take.overview]: the `repeat_view` "otherwise" case.
+  template <class _Range,
+            convertible_to<range_difference_t<_Range>> _Np,
+            class _RawRange = remove_cvref_t<_Range>,
+            class _Dist     = range_difference_t<_Range>>
+    requires(__is_repeat_specialization<_RawRange> && !sized_range<_RawRange>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+    noexcept(noexcept(views::repeat(*__range.__value_, static_cast<_Dist>(__n))))
+    -> decltype(      views::repeat(*__range.__value_, static_cast<_Dist>(__n)))
+    { return          views::repeat(*__range.__value_, static_cast<_Dist>(__n)); }
+#endif
+  // clang-format on
+
   // [range.take.overview]: the "otherwise" case.
-  template <class _Range, convertible_to<range_difference_t<_Range>> _Np,
-            class _RawRange = remove_cvref_t<_Range>>
-    // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
-    // overloads.
-    requires (!(__is_empty_view<_RawRange> ||
-               (__is_iota_specialization<_RawRange> &&
-                sized_range<_RawRange> &&
-                random_access_range<_RawRange>) ||
-               (__is_passthrough_specialization<_RawRange> &&
-                sized_range<_RawRange> &&
-                random_access_range<_RawRange>)
-             ))
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Range&& __range, _Np&& __n) const
-    noexcept(noexcept(take_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
-    -> decltype(      take_view(std::forward<_Range>(__range), std::forward<_Np>(__n)))
-    { return          take_view(std::forward<_Range>(__range), std::forward<_Np>(__n)); }
+  template <class _Range, convertible_to<range_difference_t<_Range>> _Np, class _RawRange = remove_cvref_t<_Range>>
+  // Note: without specifically excluding the other cases, GCC sees this overload as ambiguous with the other
+  // overloads.
+    requires(!(__is_empty_view<_RawRange> ||
+#  if _LIBCPP_STD_VER >= 23
+               __is_repeat_specialization<_RawRange> ||
+#  endif
+               (__is_iota_specialization<_RawRange> && sized_range<_RawRange> && random_access_range<_RawRange>) ||
+               (__is_passthrough_specialization<_RawRange> && sized_range<_RawRange> &&
+                random_access_range<_RawRange>)))
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Np&& __n) const
+      noexcept(noexcept(take_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
+          -> decltype(take_view(std::forward<_Range>(__range), std::forward<_Np>(__n))) {
+    return take_view(std::forward<_Range>(__range), std::forward<_Np>(__n));
+  }
 
   template <class _Np>
     requires constructible_from<decay_t<_Np>, _Np>
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator()(_Np&& __n) const
-    noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>)
-  { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n))); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Np&& __n) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Np>(__n)));
+  }
 };
 
 } // namespace __take
 
 inline namespace __cpo {
-  inline constexpr auto take = __take::__fn{};
+inline constexpr auto take = __take::__fn{};
 } // namespace __cpo
 } // namespace views
 
diff --git a/third_party/libcxx/__ranges/take_while_view.h b/third_party/libcxx/__ranges/take_while_view.h
index d1f1bfe75..77ea9f7bb 100644
--- a/third_party/libcxx/__ranges/take_while_view.h
+++ b/third_party/libcxx/__ranges/take_while_view.h
@@ -20,7 +20,7 @@
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
-#include <__ranges/copyable_box.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/view_interface.h>
 #include <__type_traits/decay.h>
@@ -35,32 +35,23 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
 
-// The spec uses the unnamed requirement inside the `begin` and `end` member functions:
-//     constexpr auto begin() const
-//       requires range<const V> && indirect_unary_predicate<const Pred, iterator_t<const V>>
-// However, due to a clang-14 and clang-15 bug, the above produces a hard error when `const V` is not a range.
-// The workaround is to create a named concept and use the concept instead.
-// As of take_while_view is implemented, the clang-trunk has already fixed the bug.
-// It is OK to remove the workaround once our CI no longer uses clang-14, clang-15 based compilers,
-// because we don't actually expect a lot of vendors to ship a new libc++ with an old clang.
-template <class _View, class _Pred>
-concept __take_while_const_is_range =
-    range<const _View> && indirect_unary_predicate<const _Pred, iterator_t<const _View>>;
-
 template <view _View, class _Pred>
   requires input_range<_View> && is_object_v<_Pred> && indirect_unary_predicate<const _Pred, iterator_t<_View>>
-class take_while_view : public view_interface<take_while_view<_View, _Pred>> {
+class _LIBCPP_ABI_LLVM18_NO_UNIQUE_ADDRESS take_while_view : public view_interface<take_while_view<_View, _Pred>> {
   template <bool>
   class __sentinel;
 
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
-  _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Pred> __pred_;
 
 public:
   _LIBCPP_HIDE_FROM_ABI take_while_view()
@@ -87,7 +78,7 @@ public:
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
-    requires __take_while_const_is_range<_View, _Pred>
+    requires range<const _View> && indirect_unary_predicate<const _Pred, iterator_t<const _View>>
   {
     return ranges::begin(__base_);
   }
@@ -99,7 +90,7 @@ public:
   }
 
   _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
-    requires __take_while_const_is_range<_View, _Pred>
+    requires range<const _View> && indirect_unary_predicate<const _Pred, iterator_t<const _View>>
   {
     return __sentinel</*_Const=*/true>(ranges::end(__base_), std::addressof(*__pred_));
   }
@@ -174,4 +165,6 @@ inline constexpr auto take_while = __take_while::__fn{};
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_TAKE_WHILE_VIEW_H
diff --git a/third_party/libcxx/__ranges/to.h b/third_party/libcxx/__ranges/to.h
new file mode 100644
index 000000000..e0abe6290
--- /dev/null
+++ b/third_party/libcxx/__ranges/to.h
@@ -0,0 +1,245 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___RANGES_TO_H
+#define _LIBCPP___RANGES_TO_H
+
+#include <__algorithm/ranges_copy.h>
+#include <__concepts/constructible.h>
+#include <__concepts/convertible_to.h>
+#include <__concepts/derived_from.h>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__functional/bind_back.h>
+#include <__iterator/back_insert_iterator.h>
+#include <__iterator/insert_iterator.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/from_range.h>
+#include <__ranges/range_adaptor.h>
+#include <__ranges/ref_view.h>
+#include <__ranges/size.h>
+#include <__ranges/transform_view.h>
+#include <__type_traits/add_pointer.h>
+#include <__type_traits/is_const.h>
+#include <__type_traits/is_volatile.h>
+#include <__type_traits/type_identity.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+
+template <class _Container>
+constexpr bool __reservable_container =
+    sized_range<_Container> && requires(_Container& __c, range_size_t<_Container> __n) {
+      __c.reserve(__n);
+      { __c.capacity() } -> same_as<decltype(__n)>;
+      { __c.max_size() } -> same_as<decltype(__n)>;
+    };
+
+template <class _Container, class _Ref>
+constexpr bool __container_insertable = requires(_Container& __c, _Ref&& __ref) {
+  requires(
+      requires { __c.push_back(std::forward<_Ref>(__ref)); } ||
+      requires { __c.insert(__c.end(), std::forward<_Ref>(__ref)); });
+};
+
+template <class _Ref, class _Container>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __container_inserter(_Container& __c) {
+  if constexpr (requires { __c.push_back(std::declval<_Ref>()); }) {
+    return std::back_inserter(__c);
+  } else {
+    return std::inserter(__c, __c.end());
+  }
+}
+
+// Note: making this a concept allows short-circuiting the second condition.
+template <class _Container, class _Range>
+concept __try_non_recursive_conversion =
+    !input_range<_Container> || convertible_to<range_reference_t<_Range>, range_value_t<_Container>>;
+
+template <class _Container, class _Range, class... _Args>
+concept __constructible_from_iter_pair =
+    common_range<_Range> && requires { typename iterator_traits<iterator_t<_Range>>::iterator_category; } &&
+    derived_from<typename iterator_traits<iterator_t<_Range>>::iterator_category, input_iterator_tag> &&
+    constructible_from<_Container, iterator_t<_Range>, sentinel_t<_Range>, _Args...>;
+
+template <class>
+concept __always_false = false;
+
+// `ranges::to` base template -- the `_Container` type is a simple type template parameter.
+template <class _Container, input_range _Range, class... _Args>
+  requires(!view<_Container>)
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Container to(_Range&& __range, _Args&&... __args) {
+  // Mandates: C is a cv-unqualified class type.
+  static_assert(!is_const_v<_Container>, "The target container cannot be const-qualified, please remove the const");
+  static_assert(
+      !is_volatile_v<_Container>, "The target container cannot be volatile-qualified, please remove the volatile");
+
+  // First see if the non-recursive case applies -- the conversion target is either:
+  // - a range with a convertible value type;
+  // - a non-range type which might support being created from the input argument(s) (e.g. an `optional`).
+  if constexpr (__try_non_recursive_conversion<_Container, _Range>) {
+    // Case 1 -- construct directly from the given range.
+    if constexpr (constructible_from<_Container, _Range, _Args...>) {
+      return _Container(std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+    }
+
+    // Case 2 -- construct using the `from_range_t` tagged constructor.
+    else if constexpr (constructible_from<_Container, from_range_t, _Range, _Args...>) {
+      return _Container(from_range, std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+    }
+
+    // Case 3 -- construct from a begin-end iterator pair.
+    else if constexpr (__constructible_from_iter_pair<_Container, _Range, _Args...>) {
+      return _Container(ranges::begin(__range), ranges::end(__range), std::forward<_Args>(__args)...);
+    }
+
+    // Case 4 -- default-construct (or construct from the extra arguments) and insert, reserving the size if possible.
+    else if constexpr (constructible_from<_Container, _Args...> &&
+                       __container_insertable<_Container, range_reference_t<_Range>>) {
+      _Container __result(std::forward<_Args>(__args)...);
+      if constexpr (sized_range<_Range> && __reservable_container<_Container>) {
+        __result.reserve(static_cast<range_size_t<_Container>>(ranges::size(__range)));
+      }
+
+      ranges::copy(__range, ranges::__container_inserter<range_reference_t<_Range>>(__result));
+
+      return __result;
+
+    } else {
+      static_assert(__always_false<_Container>, "ranges::to: unable to convert to the given container type.");
+    }
+
+    // Try the recursive case.
+  } else if constexpr (input_range<range_reference_t<_Range>>) {
+    return ranges::to<_Container>(
+        ref_view(__range) | views::transform([](auto&& __elem) {
+          return ranges::to<range_value_t<_Container>>(std::forward<decltype(__elem)>(__elem));
+        }),
+        std::forward<_Args>(__args)...);
+
+  } else {
+    static_assert(__always_false<_Container>, "ranges::to: unable to convert to the given container type.");
+  }
+}
+
+template <class _Range>
+struct __minimal_input_iterator {
+  using iterator_category = input_iterator_tag;
+  using value_type        = range_value_t<_Range>;
+  using difference_type   = ptrdiff_t;
+  using pointer           = add_pointer_t<range_reference_t<_Range>>;
+  using reference         = range_reference_t<_Range>;
+
+  reference operator*() const;
+  pointer operator->() const;
+  __minimal_input_iterator& operator++();
+  __minimal_input_iterator operator++(int);
+  bool operator==(const __minimal_input_iterator&) const;
+};
+
+// Deduces the full type of the container from the given template template parameter.
+template <template <class...> class _Container, input_range _Range, class... _Args>
+struct _Deducer {
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __deduce_func() {
+    using _InputIter = __minimal_input_iterator<_Range>;
+
+    // Case 1 -- can construct directly from the given range.
+    if constexpr (requires { _Container(std::declval<_Range>(), std::declval<_Args>()...); }) {
+      using _Result = decltype( //
+          _Container(std::declval<_Range>(), std::declval<_Args>()...));
+      return type_identity<_Result>{};
+
+      // Case 2 -- can construct from the given range using the `from_range_t` tagged constructor.
+    } else if constexpr ( //
+        requires { _Container(from_range, std::declval<_Range>(), std::declval<_Args>()...); }) {
+      using _Result = //
+          decltype(_Container(from_range, std::declval<_Range>(), std::declval<_Args>()...));
+      return type_identity<_Result>{};
+
+      // Case 3 -- can construct from a begin-end iterator pair.
+    } else if constexpr ( //
+        requires { _Container(std::declval<_InputIter>(), std::declval<_InputIter>(), std::declval<_Args>()...); }) {
+      using _Result =
+          decltype(_Container(std::declval<_InputIter>(), std::declval<_InputIter>(), std::declval<_Args>()...));
+      return type_identity<_Result>{};
+
+    } else {
+      static_assert(__always_false<_Range>,
+                    "ranges::to: unable to deduce the container type from the template template argument.");
+    }
+  }
+
+  using type = typename decltype(__deduce_func())::type;
+};
+
+// `ranges::to` specialization -- `_Container` is a template template parameter requiring deduction to figure out the
+// container element type.
+template <template <class...> class _Container, input_range _Range, class... _Args>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto to(_Range&& __range, _Args&&... __args) {
+  using _DeduceExpr = typename _Deducer<_Container, _Range, _Args...>::type;
+  return ranges::to<_DeduceExpr>(std::forward<_Range>(__range), std::forward<_Args>(__args)...);
+}
+
+// Range adaptor closure object 1 -- wrapping the `ranges::to` version where `_Container` is a simple type template
+// parameter.
+template <class _Container, class... _Args>
+  requires(!view<_Container>)
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto to(_Args&&... __args) {
+  // Mandates: C is a cv-unqualified class type.
+  static_assert(!is_const_v<_Container>, "The target container cannot be const-qualified, please remove the const");
+  static_assert(
+      !is_volatile_v<_Container>, "The target container cannot be volatile-qualified, please remove the volatile");
+
+  auto __to_func = []<input_range _Range, class... _Tail>(_Range&& __range, _Tail&&... __tail) static
+    requires requires { //
+      /**/ ranges::to<_Container>(std::forward<_Range>(__range), std::forward<_Tail>(__tail)...);
+    }
+  { return ranges::to<_Container>(std::forward<_Range>(__range), std::forward<_Tail>(__tail)...); };
+
+  return __range_adaptor_closure_t(std::__bind_back(__to_func, std::forward<_Args>(__args)...));
+}
+
+// Range adaptor closure object 2 -- wrapping the `ranges::to` version where `_Container` is a template template
+// parameter.
+template <template <class...> class _Container, class... _Args>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto to(_Args&&... __args) {
+  // clang-format off
+  auto __to_func = []<input_range _Range, class... _Tail,
+                      class _DeducedExpr = typename _Deducer<_Container, _Range, _Tail...>::type>
+    (_Range&& __range, _Tail&& ... __tail) static
+      requires requires { //
+      /**/ ranges::to<_DeducedExpr>(std::forward<_Range>(__range), std::forward<_Tail>(__tail)...);
+    }
+  {
+    return ranges::to<_DeducedExpr>(std::forward<_Range>(__range), std::forward<_Tail>(__tail)...);
+  };
+  // clang-format on
+
+  return __range_adaptor_closure_t(std::__bind_back(__to_func, std::forward<_Args>(__args)...));
+}
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___RANGES_TO_H
diff --git a/third_party/libcxx/__ranges/transform_view.h b/third_party/libcxx/__ranges/transform_view.h
index 8bdfa9735..dc3aaa59e 100644
--- a/third_party/libcxx/__ranges/transform_view.h
+++ b/third_party/libcxx/__ranges/transform_view.h
@@ -20,14 +20,15 @@
 #include <__config>
 #include <__functional/bind_back.h>
 #include <__functional/invoke.h>
+#include <__functional/perfect_forward.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__ranges/access.h>
 #include <__ranges/all.h>
 #include <__ranges/concepts.h>
-#include <__ranges/copyable_box.h>
 #include <__ranges/empty.h>
+#include <__ranges/movable_box.h>
 #include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
@@ -46,188 +47,183 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
 namespace ranges {
 
-template<class _Fn, class _View>
-concept __regular_invocable_with_range_ref =
-  regular_invocable<_Fn, range_reference_t<_View>>;
+template <class _Fn, class _View>
+concept __regular_invocable_with_range_ref = regular_invocable<_Fn, range_reference_t<_View>>;
 
-template<class _View, class _Fn>
+template <class _View, class _Fn>
 concept __transform_view_constraints =
-  view<_View> && is_object_v<_Fn> &&
-  regular_invocable<_Fn&, range_reference_t<_View>> &&
-  __can_reference<invoke_result_t<_Fn&, range_reference_t<_View>>>;
+    view<_View> && is_object_v<_Fn> && regular_invocable<_Fn&, range_reference_t<_View>> &&
+    __can_reference<invoke_result_t<_Fn&, range_reference_t<_View>>>;
 
-template<input_range _View, copy_constructible _Fn>
+#  if _LIBCPP_STD_VER >= 23
+template <input_range _View, move_constructible _Fn>
+#  else
+template <input_range _View, copy_constructible _Fn>
+#  endif
   requires __transform_view_constraints<_View, _Fn>
-class transform_view : public view_interface<transform_view<_View, _Fn>> {
-  template<bool> class __iterator;
-  template<bool> class __sentinel;
+class _LIBCPP_ABI_LLVM18_NO_UNIQUE_ADDRESS transform_view : public view_interface<transform_view<_View, _Fn>> {
+  template <bool>
+  class __iterator;
+  template <bool>
+  class __sentinel;
 
-  _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Fn> __func_;
+  _LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Fn> __func_;
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  transform_view()
-    requires default_initializable<_View> && default_initializable<_Fn> = default;
+  _LIBCPP_HIDE_FROM_ABI transform_view()
+    requires default_initializable<_View> && default_initializable<_Fn>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 transform_view(_View __base, _Fn __func)
-    : __func_(std::in_place, std::move(__func)), __base_(std::move(__base)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 transform_view(_View __base, _Fn __func)
+      : __func_(std::in_place, std::move(__func)), __base_(std::move(__base)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _View base() && { return std::move(__base_); }
-
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator<false> begin() {
-    return __iterator<false>{*this, ranges::begin(__base_)};
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
+    requires copy_constructible<_View>
+  {
+    return __base_;
   }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator<true> begin() const
-    requires range<const _View> &&
-             __regular_invocable_with_range_ref<const _Fn&, const _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator<false> begin() { return __iterator<false>{*this, ranges::begin(__base_)}; }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator<true> begin() const
+    requires range<const _View> && __regular_invocable_with_range_ref<const _Fn&, const _View>
   {
     return __iterator<true>(*this, ranges::begin(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel<false> end() {
-    return __sentinel<false>(ranges::end(__base_));
-  }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator<false> end()
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel<false> end() { return __sentinel<false>(ranges::end(__base_)); }
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator<false> end()
     requires common_range<_View>
   {
     return __iterator<false>(*this, ranges::end(__base_));
   }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel<true> end() const
-    requires range<const _View> &&
-             __regular_invocable_with_range_ref<const _Fn&, const _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel<true> end() const
+    requires range<const _View> && __regular_invocable_with_range_ref<const _Fn&, const _View>
   {
     return __sentinel<true>(ranges::end(__base_));
   }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator<true> end() const
-    requires common_range<const _View> &&
-             __regular_invocable_with_range_ref<const _Fn&, const _View>
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator<true> end() const
+    requires common_range<const _View> && __regular_invocable_with_range_ref<const _Fn&, const _View>
   {
     return __iterator<true>(*this, ranges::end(__base_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() requires sized_range<_View> { return ranges::size(__base_); }
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() const requires sized_range<const _View> { return ranges::size(__base_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires sized_range<_View>
+  {
+    return ranges::size(__base_);
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires sized_range<const _View>
+  {
+    return ranges::size(__base_);
+  }
 };
 
-template<class _Range, class _Fn>
+template <class _Range, class _Fn>
 transform_view(_Range&&, _Fn) -> transform_view<views::all_t<_Range>, _Fn>;
 
-template<class _View>
-struct __transform_view_iterator_concept { using type = input_iterator_tag; };
+template <class _View>
+struct __transform_view_iterator_concept {
+  using type = input_iterator_tag;
+};
 
-template<random_access_range _View>
-struct __transform_view_iterator_concept<_View> { using type = random_access_iterator_tag; };
+template <random_access_range _View>
+struct __transform_view_iterator_concept<_View> {
+  using type = random_access_iterator_tag;
+};
 
-template<bidirectional_range _View>
-struct __transform_view_iterator_concept<_View> { using type = bidirectional_iterator_tag; };
+template <bidirectional_range _View>
+struct __transform_view_iterator_concept<_View> {
+  using type = bidirectional_iterator_tag;
+};
 
-template<forward_range _View>
-struct __transform_view_iterator_concept<_View> { using type = forward_iterator_tag; };
+template <forward_range _View>
+struct __transform_view_iterator_concept<_View> {
+  using type = forward_iterator_tag;
+};
 
-template<class, class>
+template <class, class>
 struct __transform_view_iterator_category_base {};
 
-template<forward_range _View, class _Fn>
+template <forward_range _View, class _Fn>
 struct __transform_view_iterator_category_base<_View, _Fn> {
   using _Cat = typename iterator_traits<iterator_t<_View>>::iterator_category;
 
-  using iterator_category = conditional_t<
-    is_reference_v<invoke_result_t<_Fn&, range_reference_t<_View>>>,
-    conditional_t<
-      derived_from<_Cat, contiguous_iterator_tag>,
-      random_access_iterator_tag,
-      _Cat
-    >,
-    input_iterator_tag
-  >;
+  using iterator_category =
+      conditional_t< is_reference_v<invoke_result_t<_Fn&, range_reference_t<_View>>>,
+                     conditional_t< derived_from<_Cat, contiguous_iterator_tag>, random_access_iterator_tag, _Cat >,
+                     input_iterator_tag >;
 };
 
-template<input_range _View, copy_constructible _Fn>
+#  if _LIBCPP_STD_VER >= 23
+template <input_range _View, move_constructible _Fn>
+#  else
+template <input_range _View, copy_constructible _Fn>
+#  endif
   requires __transform_view_constraints<_View, _Fn>
-template<bool _Const>
-class transform_view<_View, _Fn>::__iterator
-  : public __transform_view_iterator_category_base<_View, _Fn> {
+template <bool _Const>
+class transform_view<_View, _Fn>::__iterator : public __transform_view_iterator_category_base<_View, _Fn> {
 
   using _Parent = __maybe_const<_Const, transform_view>;
-  using _Base = __maybe_const<_Const, _View>;
+  using _Base   = __maybe_const<_Const, _View>;
 
-  _Parent *__parent_ = nullptr;
+  _Parent* __parent_ = nullptr;
 
-  template<bool>
+  template <bool>
   friend class transform_view<_View, _Fn>::__iterator;
 
-  template<bool>
+  template <bool>
   friend class transform_view<_View, _Fn>::__sentinel;
 
 public:
   iterator_t<_Base> __current_ = iterator_t<_Base>();
 
   using iterator_concept = typename __transform_view_iterator_concept<_View>::type;
-  using value_type = remove_cvref_t<invoke_result_t<_Fn&, range_reference_t<_Base>>>;
-  using difference_type = range_difference_t<_Base>;
+  using value_type       = remove_cvref_t<invoke_result_t<_Fn&, range_reference_t<_Base>>>;
+  using difference_type  = range_difference_t<_Base>;
 
-  _LIBCPP_HIDE_FROM_ABI
-  __iterator() requires default_initializable<iterator_t<_Base>> = default;
+  _LIBCPP_HIDE_FROM_ABI __iterator()
+    requires default_initializable<iterator_t<_Base>>
+  = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator(_Parent& __parent, iterator_t<_Base> __current)
-    : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent& __parent, iterator_t<_Base> __current)
+      : __parent_(std::addressof(__parent)), __current_(std::move(__current)) {}
 
   // Note: `__i` should always be `__iterator<false>`, but directly using
   // `__iterator<false>` is ill-formed when `_Const` is false
   // (see http://wg21.link/class.copy.ctor#5).
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator(__iterator<!_Const> __i)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
     requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>>
-    : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
+      : __parent_(__i.__parent_), __current_(std::move(__i.__current_)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr const iterator_t<_Base>& base() const& noexcept {
-    return __current_;
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr const iterator_t<_Base>& base() const& noexcept { return __current_; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr iterator_t<_Base> base() && {
-    return std::move(__current_);
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Base> base() && { return std::move(__current_); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator*() const
-    noexcept(noexcept(std::invoke(*__parent_->__func_, *__current_)))
-  {
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const
+      noexcept(noexcept(std::invoke(*__parent_->__func_, *__current_))) {
     return std::invoke(*__parent_->__func_, *__current_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator++() {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
     ++__current_;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr void operator++(int) { ++__current_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++__current_; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator operator++(int)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
     requires forward_range<_Base>
   {
     auto __tmp = *this;
@@ -235,16 +231,14 @@ public:
     return __tmp;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator--()
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
     requires bidirectional_range<_Base>
   {
     --__current_;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator operator--(int)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
     requires bidirectional_range<_Base>
   {
     auto __tmp = *this;
@@ -252,104 +246,88 @@ public:
     return __tmp;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator+=(difference_type __n)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __n)
     requires random_access_range<_Base>
   {
     __current_ += __n;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator-=(difference_type __n)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __n)
     requires random_access_range<_Base>
   {
     __current_ -= __n;
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator[](difference_type __n) const
-    noexcept(noexcept(std::invoke(*__parent_->__func_, __current_[__n])))
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type __n) const
+      noexcept(noexcept(std::invoke(*__parent_->__func_, __current_[__n])))
     requires random_access_range<_Base>
   {
     return std::invoke(*__parent_->__func_, __current_[__n]);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
     requires equality_comparable<iterator_t<_Base>>
   {
     return __x.__current_ == __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ < __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ > __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ <= __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base>
   {
     return __x.__current_ >= __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
     requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
   {
     return __x.__current_ <=> __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator+(__iterator __i, difference_type __n)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(__iterator __i, difference_type __n)
     requires random_access_range<_Base>
   {
     return __iterator{*__i.__parent_, __i.__current_ + __n};
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator+(difference_type __n, __iterator __i)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, __iterator __i)
     requires random_access_range<_Base>
   {
     return __iterator{*__i.__parent_, __i.__current_ + __n};
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator-(__iterator __i, difference_type __n)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(__iterator __i, difference_type __n)
     requires random_access_range<_Base>
   {
     return __iterator{*__i.__parent_, __i.__current_ - __n};
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
     requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
   {
     return __x.__current_ - __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr decltype(auto) iter_move(const __iterator& __i)
-    noexcept(noexcept(*__i))
-  {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr decltype(auto) iter_move(const __iterator& __i) noexcept(noexcept(*__i)) {
     if constexpr (is_lvalue_reference_v<decltype(*__i)>)
       return std::move(*__i);
     else
@@ -357,58 +335,55 @@ public:
   }
 };
 
-template<input_range _View, copy_constructible _Fn>
+#  if _LIBCPP_STD_VER >= 23
+template <input_range _View, move_constructible _Fn>
+#  else
+template <input_range _View, copy_constructible _Fn>
+#  endif
   requires __transform_view_constraints<_View, _Fn>
-template<bool _Const>
+template <bool _Const>
 class transform_view<_View, _Fn>::__sentinel {
   using _Parent = __maybe_const<_Const, transform_view>;
-  using _Base = __maybe_const<_Const, _View>;
+  using _Base   = __maybe_const<_Const, _View>;
 
   sentinel_t<_Base> __end_ = sentinel_t<_Base>();
 
-  template<bool>
+  template <bool>
   friend class transform_view<_View, _Fn>::__iterator;
 
-  template<bool>
+  template <bool>
   friend class transform_view<_View, _Fn>::__sentinel;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  __sentinel() = default;
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(__end) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(sentinel_t<_Base> __end) : __end_(__end) {}
 
   // Note: `__i` should always be `__sentinel<false>`, but directly using
   // `__sentinel<false>` is ill-formed when `_Const` is false
   // (see http://wg21.link/class.copy.ctor#5).
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel(__sentinel<!_Const> __i)
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __i)
     requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
-    : __end_(std::move(__i.__end_)) {}
+      : __end_(std::move(__i.__end_)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr sentinel_t<_Base> base() const { return __end_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Base> base() const { return __end_; }
 
-  template<bool _OtherConst>
+  template <bool _OtherConst>
     requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
     return __x.__current_ == __y.__end_;
   }
 
-  template<bool _OtherConst>
+  template <bool _OtherConst>
     requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
   operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
     return __x.__current_ - __y.__end_;
   }
 
-  template<bool _OtherConst>
+  template <bool _OtherConst>
     requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
+  _LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
   operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {
     return __x.__end_ - __y.__current_;
   }
@@ -416,25 +391,25 @@ public:
 
 namespace views {
 namespace __transform {
-  struct __fn {
-    template<class _Range, class _Fn>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Range&& __range, _Fn&& __f) const
+struct __fn {
+  template <class _Range, class _Fn>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Range&& __range, _Fn&& __f) const
       noexcept(noexcept(transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f))))
-      -> decltype(      transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f)))
-      { return          transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f)); }
+          -> decltype(transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f))) {
+    return transform_view(std::forward<_Range>(__range), std::forward<_Fn>(__f));
+  }
 
-    template<class _Fn>
-      requires constructible_from<decay_t<_Fn>, _Fn>
-    [[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-    constexpr auto operator()(_Fn&& __f) const
-      noexcept(is_nothrow_constructible_v<decay_t<_Fn>, _Fn>)
-    { return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Fn>(__f))); }
-  };
+  template <class _Fn>
+    requires constructible_from<decay_t<_Fn>, _Fn>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&& __f) const
+      noexcept(is_nothrow_constructible_v<decay_t<_Fn>, _Fn>) {
+    return __range_adaptor_closure_t(std::__bind_back(*this, std::forward<_Fn>(__f)));
+  }
+};
 } // namespace __transform
 
 inline namespace __cpo {
-  inline constexpr auto transform = __transform::__fn{};
+inline constexpr auto transform = __transform::__fn{};
 } // namespace __cpo
 } // namespace views
 
@@ -444,4 +419,6 @@ inline namespace __cpo {
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___RANGES_TRANSFORM_VIEW_H
diff --git a/third_party/libcxx/__ranges/view_interface.h b/third_party/libcxx/__ranges/view_interface.h
index 0a14d0df2..3bcfbaf3a 100644
--- a/third_party/libcxx/__ranges/view_interface.h
+++ b/third_party/libcxx/__ranges/view_interface.h
@@ -21,6 +21,7 @@
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/empty.h>
+#include <__ranges/size.h>
 #include <__type_traits/is_class.h>
 #include <__type_traits/make_unsigned.h>
 #include <__type_traits/remove_cv.h>
@@ -35,135 +36,127 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-template<class _Derived>
+template <class _Derived>
   requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
 class view_interface {
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Derived& __derived() noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Derived& __derived() noexcept {
     static_assert(sizeof(_Derived) && derived_from<_Derived, view_interface> && view<_Derived>);
     return static_cast<_Derived&>(*this);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr _Derived const& __derived() const noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr _Derived const& __derived() const noexcept {
     static_assert(sizeof(_Derived) && derived_from<_Derived, view_interface> && view<_Derived>);
     return static_cast<_Derived const&>(*this);
   }
 
 public:
-  template<class _D2 = _Derived>
+  template <class _D2 = _Derived>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty()
-    requires forward_range<_D2>
+    requires sized_range<_D2> || forward_range<_D2>
   {
-    return ranges::begin(__derived()) == ranges::end(__derived());
+    if constexpr (sized_range<_D2>) {
+      return ranges::size(__derived()) == 0;
+    } else {
+      return ranges::begin(__derived()) == ranges::end(__derived());
+    }
   }
 
-  template<class _D2 = _Derived>
+  template <class _D2 = _Derived>
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const
-    requires forward_range<const _D2>
+    requires sized_range<const _D2> || forward_range<const _D2>
   {
-    return ranges::begin(__derived()) == ranges::end(__derived());
+    if constexpr (sized_range<const _D2>) {
+      return ranges::size(__derived()) == 0;
+    } else {
+      return ranges::begin(__derived()) == ranges::end(__derived());
+    }
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit operator bool()
-    requires requires (_D2& __t) { ranges::empty(__t); }
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool()
+    requires requires(_D2& __t) { ranges::empty(__t); }
   {
     return !ranges::empty(__derived());
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit operator bool() const
-    requires requires (const _D2& __t) { ranges::empty(__t); }
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const
+    requires requires(const _D2& __t) { ranges::empty(__t); }
   {
     return !ranges::empty(__derived());
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto data()
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto data()
     requires contiguous_iterator<iterator_t<_D2>>
   {
     return std::to_address(ranges::begin(__derived()));
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto data() const
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto data() const
     requires range<const _D2> && contiguous_iterator<iterator_t<const _D2>>
   {
     return std::to_address(ranges::begin(__derived()));
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size()
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
     requires forward_range<_D2> && sized_sentinel_for<sentinel_t<_D2>, iterator_t<_D2>>
   {
     return std::__to_unsigned_like(ranges::end(__derived()) - ranges::begin(__derived()));
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() const
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
     requires forward_range<const _D2> && sized_sentinel_for<sentinel_t<const _D2>, iterator_t<const _D2>>
   {
     return std::__to_unsigned_like(ranges::end(__derived()) - ranges::begin(__derived()));
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) front()
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) front()
     requires forward_range<_D2>
   {
-    _LIBCPP_ASSERT(!empty(),
-        "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !empty(), "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
     return *ranges::begin(__derived());
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) front() const
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) front() const
     requires forward_range<const _D2>
   {
-    _LIBCPP_ASSERT(!empty(),
-        "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !empty(), "Precondition `!empty()` not satisfied. `.front()` called on an empty view.");
     return *ranges::begin(__derived());
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) back()
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) back()
     requires bidirectional_range<_D2> && common_range<_D2>
   {
-    _LIBCPP_ASSERT(!empty(),
-        "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !empty(), "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
     return *ranges::prev(ranges::end(__derived()));
   }
 
-  template<class _D2 = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) back() const
+  template <class _D2 = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) back() const
     requires bidirectional_range<const _D2> && common_range<const _D2>
   {
-    _LIBCPP_ASSERT(!empty(),
-        "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        !empty(), "Precondition `!empty()` not satisfied. `.back()` called on an empty view.");
     return *ranges::prev(ranges::end(__derived()));
   }
 
-  template<random_access_range _RARange = _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator[](range_difference_t<_RARange> __index)
-  {
+  template <random_access_range _RARange = _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) {
     return ranges::begin(__derived())[__index];
   }
 
-  template<random_access_range _RARange = const _Derived>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const
-  {
+  template <random_access_range _RARange = const _Derived>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const {
     return ranges::begin(__derived())[__index];
   }
 };
diff --git a/third_party/libcxx/__ranges/views.h b/third_party/libcxx/__ranges/views.h
index 906c4e46c..a4de2a5e5 100644
--- a/third_party/libcxx/__ranges/views.h
+++ b/third_party/libcxx/__ranges/views.h
@@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace ranges {
 
-namespace views { }
+namespace views {}
 
 } // namespace ranges
 
diff --git a/third_party/libcxx/__ranges/zip_view.h b/third_party/libcxx/__ranges/zip_view.h
index 2fd1fb304..fe3c87a93 100644
--- a/third_party/libcxx/__ranges/zip_view.h
+++ b/third_party/libcxx/__ranges/zip_view.h
@@ -30,12 +30,13 @@
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/make_unsigned.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 #include <tuple>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -52,9 +53,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 namespace ranges {
 
 template <class... _Ranges>
-concept __zip_is_common = (sizeof...(_Ranges) == 1 && (common_range<_Ranges> && ...)) ||
-                          (!(bidirectional_range<_Ranges> && ...) && (common_range<_Ranges> && ...)) ||
-                          ((random_access_range<_Ranges> && ...) && (sized_range<_Ranges> && ...));
+concept __zip_is_common =
+    (sizeof...(_Ranges) == 1 && (common_range<_Ranges> && ...)) ||
+    (!(bidirectional_range<_Ranges> && ...) && (common_range<_Ranges> && ...)) ||
+    ((random_access_range<_Ranges> && ...) && (sized_range<_Ranges> && ...));
 
 template <typename _Tp, typename _Up>
 auto __tuple_or_pair_test() -> pair<_Tp, _Up>;
@@ -87,31 +89,39 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __tuple_for_each(_Fun&& __f, _Tuple&& __tup
 
 template <class _Fun, class _Tuple1, class _Tuple2, size_t... _Indices>
 _LIBCPP_HIDE_FROM_ABI constexpr __tuple_or_pair<
-    invoke_result_t<_Fun&, typename tuple_element<_Indices, remove_cvref_t<_Tuple1>>::type,
+    invoke_result_t<_Fun&,
+                    typename tuple_element<_Indices, remove_cvref_t<_Tuple1>>::type,
                     typename tuple_element<_Indices, remove_cvref_t<_Tuple2>>::type>...>
 __tuple_zip_transform(_Fun&& __f, _Tuple1&& __tuple1, _Tuple2&& __tuple2, index_sequence<_Indices...>) {
-  return {std::invoke(__f, std::get<_Indices>(std::forward<_Tuple1>(__tuple1)),
+  return {std::invoke(__f,
+                      std::get<_Indices>(std::forward<_Tuple1>(__tuple1)),
                       std::get<_Indices>(std::forward<_Tuple2>(__tuple2)))...};
 }
 
 template <class _Fun, class _Tuple1, class _Tuple2>
 _LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_zip_transform(_Fun&& __f, _Tuple1&& __tuple1, _Tuple2&& __tuple2) {
-  return ranges::__tuple_zip_transform(__f, std::forward<_Tuple1>(__tuple1), std::forward<_Tuple2>(__tuple2),
-                                       std::make_index_sequence<tuple_size<remove_cvref_t<_Tuple1>>::value>());
+  return ranges::__tuple_zip_transform(
+      __f,
+      std::forward<_Tuple1>(__tuple1),
+      std::forward<_Tuple2>(__tuple2),
+      std::make_index_sequence<tuple_size<remove_cvref_t<_Tuple1>>::value>());
 }
 
 template <class _Fun, class _Tuple1, class _Tuple2, size_t... _Indices>
-_LIBCPP_HIDE_FROM_ABI constexpr void __tuple_zip_for_each(_Fun&& __f, _Tuple1&& __tuple1, _Tuple2&& __tuple2,
-                                                          index_sequence<_Indices...>) {
-  (std::invoke(__f, std::get<_Indices>(std::forward<_Tuple1>(__tuple1)),
-               std::get<_Indices>(std::forward<_Tuple2>(__tuple2))),
+_LIBCPP_HIDE_FROM_ABI constexpr void
+__tuple_zip_for_each(_Fun&& __f, _Tuple1&& __tuple1, _Tuple2&& __tuple2, index_sequence<_Indices...>) {
+  (std::invoke(
+       __f, std::get<_Indices>(std::forward<_Tuple1>(__tuple1)), std::get<_Indices>(std::forward<_Tuple2>(__tuple2))),
    ...);
 }
 
 template <class _Fun, class _Tuple1, class _Tuple2>
 _LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_zip_for_each(_Fun&& __f, _Tuple1&& __tuple1, _Tuple2&& __tuple2) {
-  return ranges::__tuple_zip_for_each(__f, std::forward<_Tuple1>(__tuple1), std::forward<_Tuple2>(__tuple2),
-                                      std::make_index_sequence<tuple_size<remove_cvref_t<_Tuple1>>::value>());
+  return ranges::__tuple_zip_for_each(
+      __f,
+      std::forward<_Tuple1>(__tuple1),
+      std::forward<_Tuple2>(__tuple2),
+      std::make_index_sequence<tuple_size<remove_cvref_t<_Tuple1>>::value>());
 }
 
 template <class _Tuple1, class _Tuple2>
@@ -130,7 +140,6 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Tp __abs(_Tp __t) {
 template <input_range... _Views>
   requires(view<_Views> && ...) && (sizeof...(_Views) > 0)
 class zip_view : public view_interface<zip_view<_Views...>> {
-
   _LIBCPP_NO_UNIQUE_ADDRESS tuple<_Views...> __views_;
 
   template <bool>
@@ -140,27 +149,25 @@ class zip_view : public view_interface<zip_view<_Views...>> {
   class __sentinel;
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  zip_view() = default;
+  _LIBCPP_HIDE_FROM_ABI zip_view() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit zip_view(_Views... __views) : __views_(std::move(__views)...) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit zip_view(_Views... __views) : __views_(std::move(__views)...) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin()
-    requires(!(__simple_view<_Views> && ...)) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
+    requires(!(__simple_view<_Views> && ...))
+  {
     return __iterator<false>(ranges::__tuple_transform(ranges::begin, __views_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto begin() const
-    requires(range<const _Views> && ...) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
+    requires(range<const _Views> && ...)
+  {
     return __iterator<true>(ranges::__tuple_transform(ranges::begin, __views_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end()
-    requires(!(__simple_view<_Views> && ...)) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end()
+    requires(!(__simple_view<_Views> && ...))
+  {
     if constexpr (!__zip_is_common<_Views...>) {
       return __sentinel<false>(ranges::__tuple_transform(ranges::end, __views_));
     } else if constexpr ((random_access_range<_Views> && ...)) {
@@ -170,9 +177,9 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto end() const
-    requires(range<const _Views> && ...) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
+    requires(range<const _Views> && ...)
+  {
     if constexpr (!__zip_is_common<const _Views...>) {
       return __sentinel<true>(ranges::__tuple_transform(ranges::end, __views_));
     } else if constexpr ((random_access_range<const _Views> && ...)) {
@@ -182,9 +189,9 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size()
-    requires(sized_range<_Views> && ...) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size()
+    requires(sized_range<_Views> && ...)
+  {
     return std::apply(
         [](auto... __sizes) {
           using _CT = make_unsigned_t<common_type_t<decltype(__sizes)...>>;
@@ -193,9 +200,9 @@ public:
         ranges::__tuple_transform(ranges::size, __views_));
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto size() const
-    requires(sized_range<const _Views> && ...) {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+    requires(sized_range<const _Views> && ...)
+  {
     return std::apply(
         [](auto... __sizes) {
           using _CT = make_unsigned_t<common_type_t<decltype(__sizes)...>>;
@@ -243,11 +250,10 @@ template <input_range... _Views>
   requires(view<_Views> && ...) && (sizeof...(_Views) > 0)
 template <bool _Const>
 class zip_view<_Views...>::__iterator : public __zip_view_iterator_category_base<_Const, _Views...> {
-
   __tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current_;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit __iterator(__tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(
+      __tuple_or_pair<iterator_t<__maybe_const<_Const, _Views>>...> __current)
       : __current_(std::move(__current)) {}
 
   template <bool>
@@ -260,78 +266,73 @@ class zip_view<_Views...>::__iterator : public __zip_view_iterator_category_base
 
 public:
   using iterator_concept = decltype(__get_zip_view_iterator_tag<_Const, _Views...>());
-  using value_type = __tuple_or_pair<range_value_t<__maybe_const<_Const, _Views>>...>;
-  using difference_type = common_type_t<range_difference_t<__maybe_const<_Const, _Views>>...>;
+  using value_type       = __tuple_or_pair<range_value_t<__maybe_const<_Const, _Views>>...>;
+  using difference_type  = common_type_t<range_difference_t<__maybe_const<_Const, _Views>>...>;
 
-  _LIBCPP_HIDE_FROM_ABI
-  __iterator() = default;
+  _LIBCPP_HIDE_FROM_ABI __iterator() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator(__iterator<!_Const> __i)
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
     requires _Const && (convertible_to<iterator_t<_Views>, iterator_t<__maybe_const<_Const, _Views>>> && ...)
-  : __current_(std::move(__i.__current_)) {}
+      : __current_(std::move(__i.__current_)) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator*() const {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator*() const {
     return ranges::__tuple_transform([](auto& __i) -> decltype(auto) { return *__i; }, __current_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator++() {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
     ranges::__tuple_for_each([](auto& __i) { ++__i; }, __current_);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr void operator++(int) { ++*this; }
+  _LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator operator++(int)
-    requires __zip_all_forward<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
+    requires __zip_all_forward<_Const, _Views...>
+  {
     auto __tmp = *this;
     ++*this;
     return __tmp;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator--()
-    requires __zip_all_bidirectional<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
+    requires __zip_all_bidirectional<_Const, _Views...>
+  {
     ranges::__tuple_for_each([](auto& __i) { --__i; }, __current_);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator operator--(int)
-    requires __zip_all_bidirectional<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
+    requires __zip_all_bidirectional<_Const, _Views...>
+  {
     auto __tmp = *this;
     --*this;
     return __tmp;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator+=(difference_type __x)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __x)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     ranges::__tuple_for_each([&]<class _Iter>(_Iter& __i) { __i += iter_difference_t<_Iter>(__x); }, __current_);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __iterator& operator-=(difference_type __x)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __x)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     ranges::__tuple_for_each([&]<class _Iter>(_Iter& __i) { __i -= iter_difference_t<_Iter>(__x); }, __current_);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto operator[](difference_type __n) const
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI constexpr auto operator[](difference_type __n) const
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return ranges::__tuple_transform(
         [&]<class _Iter>(_Iter& __i) -> decltype(auto) { return __i[iter_difference_t<_Iter>(__n)]; }, __current_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
-    requires(equality_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...) {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
+    requires(equality_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...)
+  {
     if constexpr (__zip_all_bidirectional<_Const, _Views...>) {
       return __x.__current_ == __y.__current_;
     } else {
@@ -339,85 +340,85 @@ public:
     }
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return __x.__current_ < __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return __y < __x;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return !(__y < __x);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return !(__x < __y);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
     requires __zip_all_random_access<_Const, _Views...> &&
-             (three_way_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...) {
+             (three_way_comparable<iterator_t<__maybe_const<_Const, _Views>>> && ...)
+  {
     return __x.__current_ <=> __y.__current_;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     auto __r = __i;
     __r += __n;
     return __r;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     return __i + __n;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)
-    requires __zip_all_random_access<_Const, _Views...> {
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)
+    requires __zip_all_random_access<_Const, _Views...>
+  {
     auto __r = __i;
     __r -= __n;
     return __r;
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
     requires(sized_sentinel_for<iterator_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_Const, _Views>>> &&
-             ...) {
+             ...)
+  {
     const auto __diffs = ranges::__tuple_zip_transform(minus<>(), __x.__current_, __y.__current_);
     return std::apply(
         [](auto... __ds) {
-          return ranges::min({difference_type(__ds)...},
-                             [](auto __a, auto __b) { return ranges::__abs(__a) < ranges::__abs(__b); });
+          return ranges::min({difference_type(__ds)...}, [](auto __a, auto __b) {
+            return ranges::__abs(__a) < ranges::__abs(__b);
+          });
         },
         __diffs);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr auto iter_move(const __iterator& __i) noexcept(
+  _LIBCPP_HIDE_FROM_ABI friend constexpr auto iter_move(const __iterator& __i) noexcept(
       (noexcept(ranges::iter_move(std::declval<const iterator_t<__maybe_const<_Const, _Views>>&>())) && ...) &&
       (is_nothrow_move_constructible_v<range_rvalue_reference_t<__maybe_const<_Const, _Views>>> && ...)) {
     return ranges::__tuple_transform(ranges::iter_move, __i.__current_);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  friend constexpr void iter_swap(const __iterator& __l, const __iterator& __r) noexcept(
+  _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(const __iterator& __l, const __iterator& __r) noexcept(
       (noexcept(ranges::iter_swap(std::declval<const iterator_t<__maybe_const<_Const, _Views>>&>(),
                                   std::declval<const iterator_t<__maybe_const<_Const, _Views>>&>())) &&
        ...))
-    requires(indirectly_swappable<iterator_t<__maybe_const<_Const, _Views>>> && ...) {
+    requires(indirectly_swappable<iterator_t<__maybe_const<_Const, _Views>>> && ...)
+  {
     ranges::__tuple_zip_for_each(ranges::iter_swap, __l.__current_, __r.__current_);
   }
 };
@@ -426,11 +427,11 @@ template <input_range... _Views>
   requires(view<_Views> && ...) && (sizeof...(_Views) > 0)
 template <bool _Const>
 class zip_view<_Views...>::__sentinel {
-
   __tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end_;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit __sentinel(__tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end) : __end_(__end) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(
+      __tuple_or_pair<sentinel_t<__maybe_const<_Const, _Views>>...> __end)
+      : __end_(__end) {}
 
   friend class zip_view<_Views...>;
 
@@ -442,13 +443,11 @@ class zip_view<_Views...>::__sentinel {
   }
 
 public:
-  _LIBCPP_HIDE_FROM_ABI
-  __sentinel() = default;
+  _LIBCPP_HIDE_FROM_ABI __sentinel() = default;
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __sentinel(__sentinel<!_Const> __i)
+  _LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __i)
     requires _Const && (convertible_to<sentinel_t<_Views>, sentinel_t<__maybe_const<_Const, _Views>>> && ...)
-  : __end_(std::move(__i.__end_)) {}
+      : __end_(std::move(__i.__end_)) {}
 
   template <bool _OtherConst>
     requires(sentinel_for<sentinel_t<__maybe_const<_Const, _Views>>, iterator_t<__maybe_const<_OtherConst, _Views>>> &&
@@ -467,8 +466,9 @@ public:
     return std::apply(
         [](auto... __ds) {
           using _Diff = common_type_t<range_difference_t<__maybe_const<_OtherConst, _Views>>...>;
-          return ranges::min({_Diff(__ds)...},
-                             [](auto __a, auto __b) { return ranges::__abs(__a) < ranges::__abs(__b); });
+          return ranges::min({_Diff(__ds)...}, [](auto __a, auto __b) {
+            return ranges::__abs(__a) < ranges::__abs(__b);
+          });
         },
         __diffs);
   }
@@ -490,19 +490,19 @@ namespace views {
 namespace __zip {
 
 struct __fn {
-  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()() const noexcept { return empty_view<tuple<>>{}; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto operator()() noexcept { return empty_view<tuple<>>{}; }
 
   template <class... _Ranges>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ranges&&... __rs) const
-      noexcept(noexcept(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)))
-          -> decltype(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)) {
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  operator()(_Ranges&&... __rs) noexcept(noexcept(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)))
+      -> decltype(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)) {
     return zip_view<all_t<_Ranges>...>(std::forward<_Ranges>(__rs)...);
   }
 };
 
 } // namespace __zip
 inline namespace __cpo {
-  inline constexpr auto zip = __zip::__fn{};
+inline constexpr auto zip = __zip::__fn{};
 } // namespace __cpo
 } // namespace views
 } // namespace ranges
diff --git a/third_party/libcxx/__split_buffer b/third_party/libcxx/__split_buffer
index 6854f6a4b..bab724d1b 100644
--- a/third_party/libcxx/__split_buffer
+++ b/third_party/libcxx/__split_buffer
@@ -24,13 +24,14 @@
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__type_traits/add_lvalue_reference.h>
+#include <__type_traits/conditional.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_swappable.h>
 #include <__type_traits/is_trivially_destructible.h>
+#include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
@@ -43,7 +44,6 @@
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // __split_buffer allocates a contiguous chunk of memory and stores objects in the range [__begin_, __end_).
@@ -51,8 +51,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // it to grow both in the front and back without having to move the data.
 
 template <class _Tp, class _Allocator = allocator<_Tp> >
-struct __split_buffer
-{
+struct __split_buffer {
 public:
   using value_type      = _Tp;
   using allocator_type  = _Allocator;
@@ -67,6 +66,15 @@ public:
   using iterator        = pointer;
   using const_iterator  = const_pointer;
 
+  // A __split_buffer contains the following members which may be trivially relocatable:
+  // - pointer: may be trivially relocatable, so it's checked
+  // - allocator_type: may be trivially relocatable, so it's checked
+  // __split_buffer doesn't have any self-references, so it's trivially relocatable if its members are.
+  using __trivially_relocatable = __conditional_t<
+      __libcpp_is_trivially_relocatable<pointer>::value && __libcpp_is_trivially_relocatable<allocator_type>::value,
+      __split_buffer,
+      void>;
+
   pointer __first_;
   pointer __begin_;
   pointer __end_;
@@ -75,7 +83,7 @@ public:
   using __alloc_ref       = __add_lvalue_reference_t<allocator_type>;
   using __alloc_const_ref = __add_lvalue_reference_t<allocator_type>;
 
-  __split_buffer(const __split_buffer&) = delete;
+  __split_buffer(const __split_buffer&)            = delete;
   __split_buffer& operator=(const __split_buffer&) = delete;
 
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __split_buffer()
@@ -160,23 +168,20 @@ public:
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_at_end(size_type __n);
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_at_end(size_type __n, const_reference __x);
 
-  template <class _InputIter>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-      __enable_if_t<__has_exactly_input_iterator_category<_InputIter>::value>
-      __construct_at_end(_InputIter __first, _InputIter __last);
+  template <class _InputIter, __enable_if_t<__has_exactly_input_iterator_category<_InputIter>::value, int> = 0>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_at_end(_InputIter __first, _InputIter __last);
 
-  template <class _ForwardIterator>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-      __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value>
-      __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);
 
   template <class _Iterator, class _Sentinel>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __construct_at_end_with_sentinel(_Iterator __first, _Sentinel __last);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __construct_at_end_with_sentinel(_Iterator __first, _Sentinel __last);
 
   template <class _Iterator>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __construct_at_end_with_size(_Iterator __first, size_type __n);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __construct_at_end_with_size(_Iterator __first, size_type __n);
 
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __destruct_at_begin(pointer __new_begin) {
     __destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());
@@ -193,21 +198,21 @@ public:
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __destruct_at_end(pointer __new_last, true_type) _NOEXCEPT;
 
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void swap(__split_buffer& __x)
-      _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable<__alloc_rr>::value);
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<__alloc_rr>);
 
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool __invariants() const;
 
 private:
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__split_buffer& __c, true_type)
       _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
-    __alloc() = _VSTD::move(__c.__alloc());
+    __alloc() = std::move(__c.__alloc());
   }
 
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__split_buffer&, false_type) _NOEXCEPT {}
 
   struct _ConstructTransaction {
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit _ConstructTransaction(
-        pointer* __p, size_type __n) _NOEXCEPT
+    _LIBCPP_CONSTEXPR_SINCE_CXX20
+    _LIBCPP_HIDE_FROM_ABI explicit _ConstructTransaction(pointer* __p, size_type __n) _NOEXCEPT
         : __pos_(*__p),
           __end_(*__p + __n),
           __dest_(__p) {}
@@ -223,29 +228,23 @@ private:
 };
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-__split_buffer<_Tp, _Allocator>::__invariants() const
-{
-    if (__first_ == nullptr)
-    {
-        if (__begin_ != nullptr)
-            return false;
-        if (__end_ != nullptr)
-            return false;
-        if (__end_cap() != nullptr)
-            return false;
-    }
-    else
-    {
-        if (__begin_ < __first_)
-            return false;
-        if (__end_ < __begin_)
-            return false;
-        if (__end_cap() < __end_)
-            return false;
-    }
-    return true;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 bool __split_buffer<_Tp, _Allocator>::__invariants() const {
+  if (__first_ == nullptr) {
+    if (__begin_ != nullptr)
+      return false;
+    if (__end_ != nullptr)
+      return false;
+    if (__end_cap() != nullptr)
+      return false;
+  } else {
+    if (__begin_ < __first_)
+      return false;
+    if (__end_ < __begin_)
+      return false;
+    if (__end_cap() < __end_)
+      return false;
+  }
+  return true;
 }
 
 //  Default constructs __n objects starting at __end_
@@ -254,14 +253,11 @@ __split_buffer<_Tp, _Allocator>::__invariants() const
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
-{
-    _ConstructTransaction __tx(&this->__end_, __n);
-    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
-        __alloc_traits::construct(this->__alloc(), _VSTD::__to_address(__tx.__pos_));
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n) {
+  _ConstructTransaction __tx(&this->__end_, __n);
+  for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
+    __alloc_traits::construct(this->__alloc(), std::__to_address(__tx.__pos_));
+  }
 }
 
 //  Copy constructs __n objects starting at __end_ from __x
@@ -271,413 +267,315 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
 //  Postcondition:  size() == old size() + __n
 //  Postcondition:  [i] == __x for all i in [size() - __n, __n)
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
-{
-    _ConstructTransaction __tx(&this->__end_, __n);
-    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
-        __alloc_traits::construct(this->__alloc(),
-            _VSTD::__to_address(__tx.__pos_), __x);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x) {
+  _ConstructTransaction __tx(&this->__end_, __n);
+  for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
+    __alloc_traits::construct(this->__alloc(), std::__to_address(__tx.__pos_), __x);
+  }
 }
 
 template <class _Tp, class _Allocator>
-template <class _InputIter>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 __enable_if_t<__has_exactly_input_iterator_category<_InputIter>::value>
-__split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIter __last)
-{
+template <class _InputIter, __enable_if_t<__has_exactly_input_iterator_category<_InputIter>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIter __last) {
   __construct_at_end_with_sentinel(__first, __last);
 }
 
 template <class _Tp, class _Allocator>
 template <class _Iterator, class _Sentinel>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void __split_buffer<_Tp, _Allocator>::__construct_at_end_with_sentinel(_Iterator __first, _Sentinel __last) {
-    __alloc_rr& __a = this->__alloc();
-    for (; __first != __last; ++__first)
-    {
-        if (__end_ == __end_cap())
-        {
-            size_type __old_cap = __end_cap() - __first_;
-            size_type __new_cap = _VSTD::max<size_type>(2 * __old_cap, 8);
-            __split_buffer __buf(__new_cap, 0, __a);
-            for (pointer __p = __begin_; __p != __end_; ++__p, (void) ++__buf.__end_)
-                __alloc_traits::construct(__buf.__alloc(),
-                        _VSTD::__to_address(__buf.__end_), _VSTD::move(*__p));
-            swap(__buf);
-        }
-        __alloc_traits::construct(__a, _VSTD::__to_address(this->__end_), *__first);
-        ++this->__end_;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+__split_buffer<_Tp, _Allocator>::__construct_at_end_with_sentinel(_Iterator __first, _Sentinel __last) {
+  __alloc_rr& __a = this->__alloc();
+  for (; __first != __last; ++__first) {
+    if (__end_ == __end_cap()) {
+      size_type __old_cap = __end_cap() - __first_;
+      size_type __new_cap = std::max<size_type>(2 * __old_cap, 8);
+      __split_buffer __buf(__new_cap, 0, __a);
+      for (pointer __p = __begin_; __p != __end_; ++__p, (void)++__buf.__end_)
+        __alloc_traits::construct(__buf.__alloc(), std::__to_address(__buf.__end_), std::move(*__p));
+      swap(__buf);
     }
+    __alloc_traits::construct(__a, std::__to_address(this->__end_), *__first);
+    ++this->__end_;
+  }
 }
 template <class _Tp, class _Allocator>
-template <class _ForwardIterator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value>
-__split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
-{
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last) {
   __construct_at_end_with_size(__first, std::distance(__first, __last));
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void __split_buffer<_Tp, _Allocator>::__construct_at_end_with_size(_ForwardIterator __first, size_type __n) {
-    _ConstructTransaction __tx(&this->__end_, __n);
-    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void) ++__first) {
-        __alloc_traits::construct(this->__alloc(),
-            _VSTD::__to_address(__tx.__pos_), *__first);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+__split_buffer<_Tp, _Allocator>::__construct_at_end_with_size(_ForwardIterator __first, size_type __n) {
+  _ConstructTransaction __tx(&this->__end_, __n);
+  for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__first) {
+    __alloc_traits::construct(this->__alloc(), std::__to_address(__tx.__pos_), *__first);
+  }
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline
-void
-__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type)
-{
-    while (__begin_ != __new_begin)
-        __alloc_traits::destroy(__alloc(), _VSTD::__to_address(__begin_++));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline void
+__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type) {
+  while (__begin_ != __new_begin)
+    __alloc_traits::destroy(__alloc(), std::__to_address(__begin_++));
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline
-void
-__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_type)
-{
-    __begin_ = __new_begin;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline void
+__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_type) {
+  __begin_ = __new_begin;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-void
-__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT
-{
-    while (__new_last != __end_)
-        __alloc_traits::destroy(__alloc(), _VSTD::__to_address(--__end_));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void
+__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT {
+  while (__new_last != __end_)
+    __alloc_traits::destroy(__alloc(), std::__to_address(--__end_));
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-void
-__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) _NOEXCEPT
-{
-    __end_ = __new_last;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void
+__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) _NOEXCEPT {
+  __end_ = __new_last;
 }
 
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __start, __alloc_rr& __a)
-    : __end_cap_(nullptr, __a)
-{
-    if (__cap == 0) {
-        __first_ = nullptr;
-    } else {
-        auto __allocation = std::__allocate_at_least(__alloc(), __cap);
-        __first_ = __allocation.ptr;
-        __cap = __allocation.count;
-    }
-    __begin_ = __end_ = __first_ + __start;
-    __end_cap() = __first_ + __cap;
+    : __end_cap_(nullptr, __a) {
+  if (__cap == 0) {
+    __first_ = nullptr;
+  } else {
+    auto __allocation = std::__allocate_at_least(__alloc(), __cap);
+    __first_          = __allocation.ptr;
+    __cap             = __allocation.count;
+  }
+  __begin_ = __end_ = __first_ + __start;
+  __end_cap()       = __first_ + __cap;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-__split_buffer<_Tp, _Allocator>::~__split_buffer()
-{
-    clear();
-    if (__first_)
-        __alloc_traits::deallocate(__alloc(), __first_, capacity());
+_LIBCPP_CONSTEXPR_SINCE_CXX20 __split_buffer<_Tp, _Allocator>::~__split_buffer() {
+  clear();
+  if (__first_)
+    __alloc_traits::deallocate(__alloc(), __first_, capacity());
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-__split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
+_LIBCPP_CONSTEXPR_SINCE_CXX20 __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
-    : __first_(_VSTD::move(__c.__first_)),
-      __begin_(_VSTD::move(__c.__begin_)),
-      __end_(_VSTD::move(__c.__end_)),
-      __end_cap_(_VSTD::move(__c.__end_cap_))
-{
-    __c.__first_ = nullptr;
-    __c.__begin_ = nullptr;
-    __c.__end_ = nullptr;
-    __c.__end_cap() = nullptr;
+    : __first_(std::move(__c.__first_)),
+      __begin_(std::move(__c.__begin_)),
+      __end_(std::move(__c.__end_)),
+      __end_cap_(std::move(__c.__end_cap_)) {
+  __c.__first_    = nullptr;
+  __c.__begin_    = nullptr;
+  __c.__end_      = nullptr;
+  __c.__end_cap() = nullptr;
 }
 
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __alloc_rr& __a)
-    : __end_cap_(nullptr, __a)
-{
-    if (__a == __c.__alloc())
-    {
-        __first_ = __c.__first_;
-        __begin_ = __c.__begin_;
-        __end_ = __c.__end_;
-        __end_cap() = __c.__end_cap();
-        __c.__first_ = nullptr;
-        __c.__begin_ = nullptr;
-        __c.__end_ = nullptr;
-        __c.__end_cap() = nullptr;
-    }
-    else
-    {
-        auto __allocation = std::__allocate_at_least(__alloc(), __c.size());
-        __first_ = __allocation.ptr;
-        __begin_ = __end_ = __first_;
-        __end_cap() = __first_ + __allocation.count;
-        typedef move_iterator<iterator> _Ip;
-        __construct_at_end(_Ip(__c.begin()), _Ip(__c.end()));
-    }
+    : __end_cap_(nullptr, __a) {
+  if (__a == __c.__alloc()) {
+    __first_        = __c.__first_;
+    __begin_        = __c.__begin_;
+    __end_          = __c.__end_;
+    __end_cap()     = __c.__end_cap();
+    __c.__first_    = nullptr;
+    __c.__begin_    = nullptr;
+    __c.__end_      = nullptr;
+    __c.__end_cap() = nullptr;
+  } else {
+    auto __allocation = std::__allocate_at_least(__alloc(), __c.size());
+    __first_          = __allocation.ptr;
+    __begin_ = __end_ = __first_;
+    __end_cap()       = __first_ + __allocation.count;
+    typedef move_iterator<iterator> _Ip;
+    __construct_at_end(_Ip(__c.begin()), _Ip(__c.end()));
+  }
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-__split_buffer<_Tp, _Allocator>&
+_LIBCPP_CONSTEXPR_SINCE_CXX20 __split_buffer<_Tp, _Allocator>&
 __split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c)
     _NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
                 is_nothrow_move_assignable<allocator_type>::value) ||
-               !__alloc_traits::propagate_on_container_move_assignment::value)
-{
-    clear();
-    shrink_to_fit();
-    __first_ = __c.__first_;
-    __begin_ = __c.__begin_;
-    __end_ = __c.__end_;
-    __end_cap() = __c.__end_cap();
-    __move_assign_alloc(__c,
-        integral_constant<bool,
-                          __alloc_traits::propagate_on_container_move_assignment::value>());
-    __c.__first_ = __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
-    return *this;
+               !__alloc_traits::propagate_on_container_move_assignment::value) {
+  clear();
+  shrink_to_fit();
+  __first_    = __c.__first_;
+  __begin_    = __c.__begin_;
+  __end_      = __c.__end_;
+  __end_cap() = __c.__end_cap();
+  __move_assign_alloc(__c, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
+  __c.__first_ = __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
+  return *this;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
-                   __is_nothrow_swappable<__alloc_rr>::value)
-{
-    _VSTD::swap(__first_, __x.__first_);
-    _VSTD::swap(__begin_, __x.__begin_);
-    _VSTD::swap(__end_, __x.__end_);
-    _VSTD::swap(__end_cap(), __x.__end_cap());
-    _VSTD::__swap_allocator(__alloc(), __x.__alloc());
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)
+    _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<__alloc_rr>) {
+  std::swap(__first_, __x.__first_);
+  std::swap(__begin_, __x.__begin_);
+  std::swap(__end_, __x.__end_);
+  std::swap(__end_cap(), __x.__end_cap());
+  std::__swap_allocator(__alloc(), __x.__alloc());
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__split_buffer<_Tp, _Allocator>::reserve(size_type __n)
-{
-    if (__n < capacity())
-    {
-        __split_buffer<value_type, __alloc_rr&> __t(__n, 0, __alloc());
-        __t.__construct_at_end(move_iterator<pointer>(__begin_),
-                               move_iterator<pointer>(__end_));
-        _VSTD::swap(__first_, __t.__first_);
-        _VSTD::swap(__begin_, __t.__begin_);
-        _VSTD::swap(__end_, __t.__end_);
-        _VSTD::swap(__end_cap(), __t.__end_cap());
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::reserve(size_type __n) {
+  if (__n < capacity()) {
+    __split_buffer<value_type, __alloc_rr&> __t(__n, 0, __alloc());
+    __t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));
+    std::swap(__first_, __t.__first_);
+    std::swap(__begin_, __t.__begin_);
+    std::swap(__end_, __t.__end_);
+    std::swap(__end_cap(), __t.__end_cap());
+  }
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
-{
-    if (capacity() > size())
-    {
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT {
+  if (capacity() > size()) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            __split_buffer<value_type, __alloc_rr&> __t(size(), 0, __alloc());
-            __t.__construct_at_end(move_iterator<pointer>(__begin_),
-                                   move_iterator<pointer>(__end_));
-            __t.__end_ = __t.__begin_ + (__end_ - __begin_);
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
+      __split_buffer<value_type, __alloc_rr&> __t(size(), 0, __alloc());
+      __t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));
+      __t.__end_ = __t.__begin_ + (__end_ - __begin_);
+      std::swap(__first_, __t.__first_);
+      std::swap(__begin_, __t.__begin_);
+      std::swap(__end_, __t.__end_);
+      std::swap(__end_cap(), __t.__end_cap());
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-        }
+    } catch (...) {
+    }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
+  }
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
-{
-    if (__begin_ == __first_)
-    {
-        if (__end_ < __end_cap())
-        {
-            difference_type __d = __end_cap() - __end_;
-            __d = (__d + 1) / 2;
-            __begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d);
-            __end_ += __d;
-        }
-        else
-        {
-            size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
-            __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
-            __t.__construct_at_end(move_iterator<pointer>(__begin_),
-                                   move_iterator<pointer>(__end_));
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::push_front(const_reference __x) {
+  if (__begin_ == __first_) {
+    if (__end_ < __end_cap()) {
+      difference_type __d = __end_cap() - __end_;
+      __d                 = (__d + 1) / 2;
+      __begin_            = std::move_backward(__begin_, __end_, __end_ + __d);
+      __end_ += __d;
+    } else {
+      size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+      __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
+      __t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));
+      std::swap(__first_, __t.__first_);
+      std::swap(__begin_, __t.__begin_);
+      std::swap(__end_, __t.__end_);
+      std::swap(__end_cap(), __t.__end_cap());
     }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_address(__begin_-1), __x);
-    --__begin_;
+  }
+  __alloc_traits::construct(__alloc(), std::__to_address(__begin_ - 1), __x);
+  --__begin_;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
-{
-    if (__begin_ == __first_)
-    {
-        if (__end_ < __end_cap())
-        {
-            difference_type __d = __end_cap() - __end_;
-            __d = (__d + 1) / 2;
-            __begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d);
-            __end_ += __d;
-        }
-        else
-        {
-            size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
-            __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
-            __t.__construct_at_end(move_iterator<pointer>(__begin_),
-                                   move_iterator<pointer>(__end_));
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x) {
+  if (__begin_ == __first_) {
+    if (__end_ < __end_cap()) {
+      difference_type __d = __end_cap() - __end_;
+      __d                 = (__d + 1) / 2;
+      __begin_            = std::move_backward(__begin_, __end_, __end_ + __d);
+      __end_ += __d;
+    } else {
+      size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+      __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
+      __t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));
+      std::swap(__first_, __t.__first_);
+      std::swap(__begin_, __t.__begin_);
+      std::swap(__end_, __t.__end_);
+      std::swap(__end_cap(), __t.__end_cap());
     }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_address(__begin_-1),
-            _VSTD::move(__x));
-    --__begin_;
+  }
+  __alloc_traits::construct(__alloc(), std::__to_address(__begin_ - 1), std::move(__x));
+  --__begin_;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-void
-__split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
-{
-    if (__end_ == __end_cap())
-    {
-        if (__begin_ > __first_)
-        {
-            difference_type __d = __begin_ - __first_;
-            __d = (__d + 1) / 2;
-            __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
-            __begin_ -= __d;
-        }
-        else
-        {
-            size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
-            __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
-            __t.__construct_at_end(move_iterator<pointer>(__begin_),
-                                   move_iterator<pointer>(__end_));
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void
+__split_buffer<_Tp, _Allocator>::push_back(const_reference __x) {
+  if (__end_ == __end_cap()) {
+    if (__begin_ > __first_) {
+      difference_type __d = __begin_ - __first_;
+      __d                 = (__d + 1) / 2;
+      __end_              = std::move(__begin_, __end_, __begin_ - __d);
+      __begin_ -= __d;
+    } else {
+      size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+      __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
+      __t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));
+      std::swap(__first_, __t.__first_);
+      std::swap(__begin_, __t.__begin_);
+      std::swap(__end_, __t.__end_);
+      std::swap(__end_cap(), __t.__end_cap());
     }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_), __x);
-    ++__end_;
+  }
+  __alloc_traits::construct(__alloc(), std::__to_address(__end_), __x);
+  ++__end_;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
-{
-    if (__end_ == __end_cap())
-    {
-        if (__begin_ > __first_)
-        {
-            difference_type __d = __begin_ - __first_;
-            __d = (__d + 1) / 2;
-            __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
-            __begin_ -= __d;
-        }
-        else
-        {
-            size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
-            __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
-            __t.__construct_at_end(move_iterator<pointer>(__begin_),
-                                   move_iterator<pointer>(__end_));
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x) {
+  if (__end_ == __end_cap()) {
+    if (__begin_ > __first_) {
+      difference_type __d = __begin_ - __first_;
+      __d                 = (__d + 1) / 2;
+      __end_              = std::move(__begin_, __end_, __begin_ - __d);
+      __begin_ -= __d;
+    } else {
+      size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+      __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
+      __t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));
+      std::swap(__first_, __t.__first_);
+      std::swap(__begin_, __t.__begin_);
+      std::swap(__end_, __t.__end_);
+      std::swap(__end_cap(), __t.__end_cap());
     }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_),
-            _VSTD::move(__x));
-    ++__end_;
+  }
+  __alloc_traits::construct(__alloc(), std::__to_address(__end_), std::move(__x));
+  ++__end_;
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-__split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
-{
-    if (__end_ == __end_cap())
-    {
-        if (__begin_ > __first_)
-        {
-            difference_type __d = __begin_ - __first_;
-            __d = (__d + 1) / 2;
-            __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
-            __begin_ -= __d;
-        }
-        else
-        {
-            size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
-            __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
-            __t.__construct_at_end(move_iterator<pointer>(__begin_),
-                                   move_iterator<pointer>(__end_));
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args) {
+  if (__end_ == __end_cap()) {
+    if (__begin_ > __first_) {
+      difference_type __d = __begin_ - __first_;
+      __d                 = (__d + 1) / 2;
+      __end_              = std::move(__begin_, __end_, __begin_ - __d);
+      __begin_ -= __d;
+    } else {
+      size_type __c = std::max<size_type>(2 * static_cast<size_t>(__end_cap() - __first_), 1);
+      __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
+      __t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));
+      std::swap(__first_, __t.__first_);
+      std::swap(__begin_, __t.__begin_);
+      std::swap(__end_, __t.__end_);
+      std::swap(__end_cap(), __t.__end_cap());
     }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_address(__end_),
-                              _VSTD::forward<_Args>(__args)...);
-    ++__end_;
+  }
+  __alloc_traits::construct(__alloc(), std::__to_address(__end_), std::forward<_Args>(__args)...);
+  ++__end_;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-void
-swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y)
-        _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void
+swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__stop_token/atomic_unique_lock.h b/third_party/libcxx/__stop_token/atomic_unique_lock.h
index f21c74263..13e59f9f0 100644
--- a/third_party/libcxx/__stop_token/atomic_unique_lock.h
+++ b/third_party/libcxx/__stop_token/atomic_unique_lock.h
@@ -27,8 +27,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // where State contains a lock bit and might contain other data,
 // and LockedBit is the value of State when the lock bit is set, e.g  1 << 2
 template <class _State, _State _LockedBit>
-class __atomic_unique_lock {
-  static_assert(std::popcount(_LockedBit) == 1, "LockedBit must be an integer where only one bit is set");
+class _LIBCPP_AVAILABILITY_SYNC __atomic_unique_lock {
+  static_assert(std::__libcpp_popcount(static_cast<unsigned long long>(_LockedBit)) == 1,
+                "LockedBit must be an integer where only one bit is set");
 
   std::atomic<_State>& __state_;
   bool __is_locked_;
diff --git a/third_party/libcxx/__stop_token/intrusive_list_view.h b/third_party/libcxx/__stop_token/intrusive_list_view.h
index 88c8f7e29..11a3e267e 100644
--- a/third_party/libcxx/__stop_token/intrusive_list_view.h
+++ b/third_party/libcxx/__stop_token/intrusive_list_view.h
@@ -67,7 +67,7 @@ struct __intrusive_list_view {
         __node->__next_->__prev_ = __node->__prev_;
       }
     } else {
-      _LIBCPP_ASSERT(__node == __head_, "Node to be removed has no prev node, so it has to be the head");
+      _LIBCPP_ASSERT_INTERNAL(__node == __head_, "Node to be removed has no prev node, so it has to be the head");
       __pop_front();
     }
   }
diff --git a/third_party/libcxx/__stop_token/intrusive_shared_ptr.h b/third_party/libcxx/__stop_token/intrusive_shared_ptr.h
index 68a57bfad..f00cea5bc 100644
--- a/third_party/libcxx/__stop_token/intrusive_shared_ptr.h
+++ b/third_party/libcxx/__stop_token/intrusive_shared_ptr.h
@@ -10,6 +10,7 @@
 #ifndef _LIBCPP___STOP_TOKEN_INTRUSIVE_SHARED_PTR_H
 #define _LIBCPP___STOP_TOKEN_INTRUSIVE_SHARED_PTR_H
 
+#include <__atomic/atomic.h>
 #include <__atomic/memory_order.h>
 #include <__config>
 #include <__type_traits/is_reference.h>
@@ -21,6 +22,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
@@ -125,4 +129,6 @@ private:
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___STOP_TOKEN_INTRUSIVE_SHARED_PTR_H
diff --git a/third_party/libcxx/__stop_token/stop_callback.h b/third_party/libcxx/__stop_token/stop_callback.h
new file mode 100644
index 000000000..760cf2bb5
--- /dev/null
+++ b/third_party/libcxx/__stop_token/stop_callback.h
@@ -0,0 +1,102 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___STOP_TOKEN_STOP_CALLBACK_H
+#define _LIBCPP___STOP_TOKEN_STOP_CALLBACK_H
+
+#include <__concepts/constructible.h>
+#include <__concepts/destructible.h>
+#include <__concepts/invocable.h>
+#include <__config>
+#include <__stop_token/intrusive_shared_ptr.h>
+#include <__stop_token/stop_state.h>
+#include <__stop_token/stop_token.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <__utility/private_constructor_tag.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)
+
+template <class _Callback>
+class _LIBCPP_AVAILABILITY_SYNC stop_callback : private __stop_callback_base {
+  static_assert(invocable<_Callback>,
+                "Mandates: stop_callback is instantiated with an argument for the template parameter Callback that "
+                "satisfies invocable.");
+  static_assert(destructible<_Callback>,
+                "Mandates: stop_callback is instantiated with an argument for the template parameter Callback that "
+                "satisfies destructible.");
+
+public:
+  using callback_type = _Callback;
+
+  template <class _Cb>
+    requires constructible_from<_Callback, _Cb>
+  _LIBCPP_HIDE_FROM_ABI explicit stop_callback(const stop_token& __st,
+                                               _Cb&& __cb) noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
+      : stop_callback(__private_constructor_tag{}, __st.__state_, std::forward<_Cb>(__cb)) {}
+
+  template <class _Cb>
+    requires constructible_from<_Callback, _Cb>
+  _LIBCPP_HIDE_FROM_ABI explicit stop_callback(stop_token&& __st,
+                                               _Cb&& __cb) noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
+      : stop_callback(__private_constructor_tag{}, std::move(__st.__state_), std::forward<_Cb>(__cb)) {}
+
+  _LIBCPP_HIDE_FROM_ABI ~stop_callback() {
+    if (__state_) {
+      __state_->__remove_callback(this);
+    }
+  }
+
+  stop_callback(const stop_callback&)            = delete;
+  stop_callback(stop_callback&&)                 = delete;
+  stop_callback& operator=(const stop_callback&) = delete;
+  stop_callback& operator=(stop_callback&&)      = delete;
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS _Callback __callback_;
+  __intrusive_shared_ptr<__stop_state> __state_;
+
+  friend __stop_callback_base;
+
+  template <class _StatePtr, class _Cb>
+  _LIBCPP_HIDE_FROM_ABI explicit stop_callback(__private_constructor_tag, _StatePtr&& __state, _Cb&& __cb) noexcept(
+      is_nothrow_constructible_v<_Callback, _Cb>)
+      : __stop_callback_base([](__stop_callback_base* __cb_base) noexcept {
+          // stop callback is supposed to only be called once
+          std::forward<_Callback>(static_cast<stop_callback*>(__cb_base)->__callback_)();
+        }),
+        __callback_(std::forward<_Cb>(__cb)),
+        __state_() {
+    if (__state && __state->__add_callback(this)) {
+      // st.stop_requested() was false and this is successfully added to the linked list
+      __state_ = std::forward<_StatePtr>(__state);
+    }
+  }
+};
+
+template <class _Callback>
+_LIBCPP_AVAILABILITY_SYNC stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)
diff --git a/third_party/libcxx/__stop_token/stop_source.h b/third_party/libcxx/__stop_token/stop_source.h
new file mode 100644
index 000000000..706974627
--- /dev/null
+++ b/third_party/libcxx/__stop_token/stop_source.h
@@ -0,0 +1,91 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___STOP_TOKEN_STOP_SOURCE_H
+#define _LIBCPP___STOP_TOKEN_STOP_SOURCE_H
+
+#include <__config>
+#include <__stop_token/intrusive_shared_ptr.h>
+#include <__stop_token/stop_state.h>
+#include <__stop_token/stop_token.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)
+
+struct nostopstate_t {
+  explicit nostopstate_t() = default;
+};
+
+inline constexpr nostopstate_t nostopstate{};
+
+class _LIBCPP_AVAILABILITY_SYNC stop_source {
+public:
+  _LIBCPP_HIDE_FROM_ABI stop_source() : __state_(new __stop_state()) { __state_->__increment_stop_source_counter(); }
+
+  _LIBCPP_HIDE_FROM_ABI explicit stop_source(nostopstate_t) noexcept : __state_(nullptr) {}
+
+  _LIBCPP_HIDE_FROM_ABI stop_source(const stop_source& __other) noexcept : __state_(__other.__state_) {
+    if (__state_) {
+      __state_->__increment_stop_source_counter();
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI stop_source(stop_source&& __other) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI stop_source& operator=(const stop_source& __other) noexcept {
+    // increment `__other` first so that we don't hit 0 in case of self-assignment
+    if (__other.__state_) {
+      __other.__state_->__increment_stop_source_counter();
+    }
+    if (__state_) {
+      __state_->__decrement_stop_source_counter();
+    }
+    __state_ = __other.__state_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI stop_source& operator=(stop_source&&) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI ~stop_source() {
+    if (__state_) {
+      __state_->__decrement_stop_source_counter();
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(stop_source& __other) noexcept { __state_.swap(__other.__state_); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI stop_token get_token() const noexcept { return stop_token(__state_); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool stop_possible() const noexcept { return __state_ != nullptr; }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool stop_requested() const noexcept {
+    return __state_ != nullptr && __state_->__stop_requested();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool request_stop() noexcept { return __state_ && __state_->__request_stop(); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend bool operator==(const stop_source&, const stop_source&) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI friend void swap(stop_source& __lhs, stop_source& __rhs) noexcept { __lhs.swap(__rhs); }
+
+private:
+  __intrusive_shared_ptr<__stop_state> __state_;
+};
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)
diff --git a/third_party/libcxx/__stop_token/stop_state.h b/third_party/libcxx/__stop_token/stop_state.h
new file mode 100644
index 000000000..b0eed13a1
--- /dev/null
+++ b/third_party/libcxx/__stop_token/stop_state.h
@@ -0,0 +1,236 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___STOP_TOKEN_STOP_STATE_H
+#define _LIBCPP___STOP_TOKEN_STOP_STATE_H
+
+#include <__assert>
+#include <__config>
+#include <__stop_token/atomic_unique_lock.h>
+#include <__stop_token/intrusive_list_view.h>
+#include <__thread/id.h>
+#include <atomic>
+#include <cstdint>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_THREADS)
+
+struct __stop_callback_base : __intrusive_node_base<__stop_callback_base> {
+  using __callback_fn_t = void(__stop_callback_base*) noexcept;
+  _LIBCPP_HIDE_FROM_ABI explicit __stop_callback_base(__callback_fn_t* __callback_fn) : __callback_fn_(__callback_fn) {}
+
+  _LIBCPP_HIDE_FROM_ABI void __invoke() noexcept { __callback_fn_(this); }
+
+  __callback_fn_t* __callback_fn_;
+  atomic<bool> __completed_ = false;
+  bool* __destroyed_        = nullptr;
+};
+
+class __stop_state {
+  static constexpr uint32_t __stop_requested_bit        = 1;
+  static constexpr uint32_t __callback_list_locked_bit  = 1 << 1;
+  static constexpr uint32_t __stop_source_counter_shift = 2;
+
+  // The "stop_source counter" is not used for lifetime reference counting.
+  // When the number of stop_source reaches 0, the remaining stop_tokens's
+  // stop_possible will return false. We need this counter to track this.
+  //
+  // The "callback list locked" bit implements the atomic_unique_lock to
+  // guard the operations on the callback list
+  //
+  //       31 - 2          |  1                   |    0           |
+  //  stop_source counter  | callback list locked | stop_requested |
+  atomic<uint32_t> __state_ = 0;
+
+  // Reference count for stop_token + stop_callback + stop_source
+  // When the counter reaches zero, the state is destroyed
+  // It is used by __intrusive_shared_ptr, but it is stored here for better layout
+  atomic<uint32_t> __ref_count_ = 0;
+
+  using __state_t            = uint32_t;
+  using __callback_list_lock = __atomic_unique_lock<__state_t, __callback_list_locked_bit>;
+  using __callback_list      = __intrusive_list_view<__stop_callback_base>;
+
+  __callback_list __callback_list_;
+  __thread_id __requesting_thread_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __stop_state() noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI void __increment_stop_source_counter() noexcept {
+    _LIBCPP_ASSERT_UNCATEGORIZED(
+        __state_.load(std::memory_order_relaxed) <= static_cast<__state_t>(~(1 << __stop_source_counter_shift)),
+        "stop_source's counter reaches the maximum. Incrementing the counter will overflow");
+    __state_.fetch_add(1 << __stop_source_counter_shift, std::memory_order_relaxed);
+  }
+
+  // We are not destroying the object after counter decrements to zero, nor do we have
+  // operations depend on the ordering of decrementing the counter. relaxed is enough.
+  _LIBCPP_HIDE_FROM_ABI void __decrement_stop_source_counter() noexcept {
+    _LIBCPP_ASSERT_UNCATEGORIZED(
+        __state_.load(std::memory_order_relaxed) >= static_cast<__state_t>(1 << __stop_source_counter_shift),
+        "stop_source's counter is 0. Decrementing the counter will underflow");
+    __state_.fetch_sub(1 << __stop_source_counter_shift, std::memory_order_relaxed);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool __stop_requested() const noexcept {
+    // acquire because [thread.stoptoken.intro] A call to request_stop that returns true
+    // synchronizes with a call to stop_requested on an associated stop_token or stop_source
+    // object that returns true.
+    // request_stop's compare_exchange_weak has release which syncs with this acquire
+    return (__state_.load(std::memory_order_acquire) & __stop_requested_bit) != 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool __stop_possible_for_stop_token() const noexcept {
+    // [stoptoken.mem] false if "a stop request was not made and there are no associated stop_source objects"
+    // Todo: Can this be std::memory_order_relaxed as the standard does not say anything except not to introduce data
+    // race?
+    __state_t __curent_state = __state_.load(std::memory_order_acquire);
+    return ((__curent_state & __stop_requested_bit) != 0) || ((__curent_state >> __stop_source_counter_shift) != 0);
+  }
+
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool __request_stop() noexcept {
+    auto __cb_list_lock = __try_lock_for_request_stop();
+    if (!__cb_list_lock.__owns_lock()) {
+      return false;
+    }
+    __requesting_thread_ = this_thread::get_id();
+
+    while (!__callback_list_.__empty()) {
+      auto __cb = __callback_list_.__pop_front();
+
+      // allow other callbacks to be removed while invoking the current callback
+      __cb_list_lock.__unlock();
+
+      bool __destroyed   = false;
+      __cb->__destroyed_ = &__destroyed;
+
+      __cb->__invoke();
+
+      // __cb's invoke function could potentially delete itself. We need to check before accessing __cb's member
+      if (!__destroyed) {
+        // needs to set __destroyed_ pointer to nullptr, otherwise it points to a local variable
+        // which is to be destroyed at the end of the loop
+        __cb->__destroyed_ = nullptr;
+
+        // [stopcallback.cons] If callback is concurrently executing on another thread, then the return
+        // from the invocation of callback strongly happens before ([intro.races]) callback is destroyed.
+        // this release syncs with the acquire in the remove_callback
+        __cb->__completed_.store(true, std::memory_order_release);
+        __cb->__completed_.notify_all();
+      }
+
+      __cb_list_lock.__lock();
+    }
+
+    return true;
+  }
+
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool __add_callback(__stop_callback_base* __cb) noexcept {
+    // If it is already stop_requested. Do not try to request it again.
+    const auto __give_up_trying_to_lock_condition = [__cb](__state_t __state) {
+      if ((__state & __stop_requested_bit) != 0) {
+        // already stop requested, synchronously run the callback and no need to lock the list again
+        __cb->__invoke();
+        return true;
+      }
+      // no stop source. no need to lock the list to add the callback as it can never be invoked
+      return (__state >> __stop_source_counter_shift) == 0;
+    };
+
+    __callback_list_lock __cb_list_lock(__state_, __give_up_trying_to_lock_condition);
+
+    if (!__cb_list_lock.__owns_lock()) {
+      return false;
+    }
+
+    __callback_list_.__push_front(__cb);
+
+    return true;
+    // unlock here: [thread.stoptoken.intro] Registration of a callback synchronizes with the invocation of
+    // that callback.
+    // Note: this release sync with the acquire in the request_stop' __try_lock_for_request_stop
+  }
+
+  // called by the destructor of stop_callback
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void __remove_callback(__stop_callback_base* __cb) noexcept {
+    __callback_list_lock __cb_list_lock(__state_);
+
+    // under below condition, the request_stop call just popped __cb from the list and could execute it now
+    bool __potentially_executing_now = __cb->__prev_ == nullptr && !__callback_list_.__is_head(__cb);
+
+    if (__potentially_executing_now) {
+      auto __requested_thread = __requesting_thread_;
+      __cb_list_lock.__unlock();
+
+      if (std::this_thread::get_id() != __requested_thread) {
+        // [stopcallback.cons] If callback is concurrently executing on another thread, then the return
+        // from the invocation of callback strongly happens before ([intro.races]) callback is destroyed.
+        __cb->__completed_.wait(false, std::memory_order_acquire);
+      } else {
+        // The destructor of stop_callback runs on the same thread of the thread that invokes the callback.
+        // The callback is potentially invoking its own destuctor. Set the flag to avoid accessing destroyed
+        // members on the invoking side
+        if (__cb->__destroyed_) {
+          *__cb->__destroyed_ = true;
+        }
+      }
+    } else {
+      __callback_list_.__remove(__cb);
+    }
+  }
+
+private:
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI __callback_list_lock __try_lock_for_request_stop() noexcept {
+    // If it is already stop_requested, do not try to request stop or lock the list again.
+    const auto __lock_fail_condition = [](__state_t __state) { return (__state & __stop_requested_bit) != 0; };
+
+    // set locked and requested bit at the same time
+    const auto __after_lock_state = [](__state_t __state) {
+      return __state | __callback_list_locked_bit | __stop_requested_bit;
+    };
+
+    // acq because [thread.stoptoken.intro] Registration of a callback synchronizes with the invocation of that
+    //     callback. We are going to invoke the callback after getting the lock, acquire so that we can see the
+    //     registration of a callback (and other writes that happens-before the add_callback)
+    //     Note: the rel (unlock) in the add_callback syncs with this acq
+    // rel because [thread.stoptoken.intro] A call to request_stop that returns true synchronizes with a call
+    //     to stop_requested on an associated stop_token or stop_source object that returns true.
+    //     We need to make sure that all writes (including user code) before request_stop will be made visible
+    //     to the threads that waiting for `stop_requested == true`
+    //     Note: this rel syncs with the acq in `stop_requested`
+    const auto __locked_ordering = std::memory_order_acq_rel;
+
+    return __callback_list_lock(__state_, __lock_fail_condition, __after_lock_state, __locked_ordering);
+  }
+
+  template <class _Tp>
+  friend struct __intrusive_shared_ptr_traits;
+};
+
+template <class _Tp>
+struct __intrusive_shared_ptr_traits;
+
+template <>
+struct __intrusive_shared_ptr_traits<__stop_state> {
+  _LIBCPP_HIDE_FROM_ABI static atomic<uint32_t>& __get_atomic_ref_count(__stop_state& __state) {
+    return __state.__ref_count_;
+  }
+};
+
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_THREADS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___STOP_TOKEN_STOP_STATE_H
diff --git a/third_party/libcxx/__stop_token/stop_token.h b/third_party/libcxx/__stop_token/stop_token.h
new file mode 100644
index 000000000..1bd75cbbf
--- /dev/null
+++ b/third_party/libcxx/__stop_token/stop_token.h
@@ -0,0 +1,63 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___STOP_TOKEN_STOP_TOKEN_H
+#define _LIBCPP___STOP_TOKEN_STOP_TOKEN_H
+
+#include <__config>
+#include <__stop_token/intrusive_shared_ptr.h>
+#include <__stop_token/stop_state.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)
+
+class _LIBCPP_AVAILABILITY_SYNC stop_token {
+public:
+  _LIBCPP_HIDE_FROM_ABI stop_token() noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI stop_token(const stop_token&) noexcept            = default;
+  _LIBCPP_HIDE_FROM_ABI stop_token(stop_token&&) noexcept                 = default;
+  _LIBCPP_HIDE_FROM_ABI stop_token& operator=(const stop_token&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI stop_token& operator=(stop_token&&) noexcept      = default;
+  _LIBCPP_HIDE_FROM_ABI ~stop_token()                                     = default;
+
+  _LIBCPP_HIDE_FROM_ABI void swap(stop_token& __other) noexcept { __state_.swap(__other.__state_); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool stop_requested() const noexcept {
+    return __state_ != nullptr && __state_->__stop_requested();
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool stop_possible() const noexcept {
+    return __state_ != nullptr && __state_->__stop_possible_for_stop_token();
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend bool operator==(const stop_token&, const stop_token&) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI friend void swap(stop_token& __lhs, stop_token& __rhs) noexcept { __lhs.swap(__rhs); }
+
+private:
+  __intrusive_shared_ptr<__stop_state> __state_;
+
+  friend class stop_source;
+  template <class _Tp>
+  friend class stop_callback;
+
+  _LIBCPP_HIDE_FROM_ABI explicit stop_token(const __intrusive_shared_ptr<__stop_state>& __state) : __state_(__state) {}
+};
+
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && !defined(_LIBCPP_HAS_NO_THREADS)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___STOP_TOKEN_STOP_TOKEN_H
diff --git a/third_party/libcxx/__string/char_traits.h b/third_party/libcxx/__string/char_traits.h
index 61975ccec..2660ac2ed 100644
--- a/third_party/libcxx/__string/char_traits.h
+++ b/third_party/libcxx/__string/char_traits.h
@@ -9,24 +9,27 @@
 #ifndef _LIBCPP___STRING_CHAR_TRAITS_H
 #define _LIBCPP___STRING_CHAR_TRAITS_H
 
-#include <__algorithm/copy_n.h>
 #include <__algorithm/fill_n.h>
+#include <__algorithm/find.h>
 #include <__algorithm/find_end.h>
 #include <__algorithm/find_first_of.h>
 #include <__algorithm/min.h>
+#include <__assert>
 #include <__compare/ordering.h>
 #include <__config>
 #include <__functional/hash.h>
+#include <__functional/identity.h>
 #include <__iterator/iterator_traits.h>
 #include <__string/constexpr_c_functions.h>
 #include <__type_traits/is_constant_evaluated.h>
+#include <__utility/is_pointer_in_range.h>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
 #include <iosfwd>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-#   include <cwchar> // for wmemcpy
+#  include <cwchar> // for wmemcpy
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -71,235 +74,168 @@ exposition-only to document what members a char_traits specialization should pro
 };
 */
 
-//
-// Temporary extension to provide a base template for std::char_traits.
-// TODO(LLVM-18): Remove this class.
-//
-template <class _CharT>
-struct _LIBCPP_DEPRECATED_("char_traits<T> for T not equal to char, wchar_t, char8_t, char16_t or char32_t is non-standard and is provided for a temporary period. It will be removed in LLVM 18, so please migrate off of it.")
-    char_traits
-{
-    using char_type  = _CharT;
-    using int_type   = int;
-    using off_type   = streamoff;
-    using pos_type   = streampos;
-    using state_type = mbstate_t;
-
-    static inline void _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI
-        assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
-        {return __c1 < __c2;}
-
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    int compare(const char_type* __s1, const char_type* __s2, size_t __n) {
-        for (; __n; --__n, ++__s1, ++__s2)
-        {
-            if (lt(*__s1, *__s2))
-                return -1;
-            if (lt(*__s2, *__s1))
-                return 1;
-        }
-        return 0;
-    }
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
-    size_t length(const char_type* __s) {
-        size_t __len = 0;
-        for (; !eq(*__s, char_type(0)); ++__s)
-            ++__len;
-        return __len;
-    }
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) {
-        for (; __n; --__n)
-        {
-            if (eq(*__s, __a))
-                return __s;
-            ++__s;
-        }
-        return nullptr;
-    }
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) {
-        if (__n == 0) return __s1;
-        char_type* __r = __s1;
-        if (__s1 < __s2)
-        {
-            for (; __n; --__n, ++__s1, ++__s2)
-                assign(*__s1, *__s2);
-        }
-        else if (__s2 < __s1)
-        {
-            __s1 += __n;
-            __s2 += __n;
-            for (; __n; --__n)
-                assign(*--__s1, *--__s2);
-        }
-        return __r;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) {
-        if (!__libcpp_is_constant_evaluated()) {
-            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
-        }
-        char_type* __r = __s1;
-        for (; __n; --__n, ++__s1, ++__s2)
-            assign(*__s1, *__s2);
-        return __r;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    static _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type*       assign(char_type* __s, size_t __n, char_type __a) {
-        char_type* __r = __s;
-        for (; __n; --__n, ++__s)
-            assign(*__s, __a);
-        return __r;
-    }
-
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
-        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
-        {return char_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type  to_int_type(char_type __c) _NOEXCEPT
-        {return int_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool      eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type  eof() _NOEXCEPT
-        {return int_type(EOF);}
-};
-
-template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI static inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-_CharT* __char_traits_move(_CharT* __dest, const _CharT* __source, size_t __n) _NOEXCEPT
-{
-#ifdef _LIBCPP_COMPILER_GCC
-  if (__libcpp_is_constant_evaluated()) {
-    if (__n == 0)
-      return __dest;
-    _CharT* __allocation = new _CharT[__n];
-    std::copy_n(__source, __n, __allocation);
-    std::copy_n(static_cast<const _CharT*>(__allocation), __n, __dest);
-    delete[] __allocation;
-    return __dest;
-  }
-#endif
-  ::__builtin_memmove(__dest, __source, __n * sizeof(_CharT));
-  return __dest;
-}
-
 // char_traits<char>
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS char_traits<char>
-{
-    using char_type           = char;
-    using int_type            = int;
-    using off_type            = streamoff;
-    using pos_type            = streampos;
-    using state_type          = mbstate_t;
+struct _LIBCPP_TEMPLATE_VIS char_traits<char> {
+  using char_type  = char;
+  using int_type   = int;
+  using off_type   = streamoff;
+  using pos_type   = streampos;
+  using state_type = mbstate_t;
 #if _LIBCPP_STD_VER >= 20
-    using comparison_category = strong_ordering;
+  using comparison_category = strong_ordering;
 #endif
 
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
+  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 void
+  assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {
+    __c1 = __c2;
+  }
 
-    // TODO: Make this _LIBCPP_HIDE_FROM_ABI
-    static inline _LIBCPP_HIDDEN _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
-            {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
-        {return (unsigned char)__c1 < (unsigned char)__c2;}
+  // TODO: Make this _LIBCPP_HIDE_FROM_ABI
+  static inline _LIBCPP_HIDDEN _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT {
+    return __c1 == __c2;
+  }
+  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT {
+    return (unsigned char)__c1 < (unsigned char)__c2;
+  }
 
-    // __constexpr_memcmp requires a trivially lexicographically comparable type, but char is not when char is a signed type
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 int
-    compare(const char_type* __lhs, const char_type* __rhs, size_t __count) _NOEXCEPT {
-      if (__libcpp_is_constant_evaluated()) {
+  // __constexpr_memcmp requires a trivially lexicographically comparable type, but char is not when char is a signed
+  // type
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+  compare(const char_type* __lhs, const char_type* __rhs, size_t __count) _NOEXCEPT {
+    if (__libcpp_is_constant_evaluated()) {
 #ifdef _LIBCPP_COMPILER_CLANG_BASED
-        return __builtin_memcmp(__lhs, __rhs, __count);
+      return __builtin_memcmp(__lhs, __rhs, __count);
 #else
-        while (__count != 0) {
-          if (lt(*__lhs, *__rhs))
-            return -1;
-          if (lt(*__rhs, *__lhs))
-            return 1;
+      while (__count != 0) {
+        if (lt(*__lhs, *__rhs))
+          return -1;
+        if (lt(*__rhs, *__lhs))
+          return 1;
 
-          __count -= sizeof(char_type);
-          ++__lhs;
-          ++__rhs;
-        }
-        return 0;
-#endif // _LIBCPP_COMPILER_CLANG_BASED
-      } else {
-        return __builtin_memcmp(__lhs, __rhs, __count);
+        __count -= sizeof(char_type);
+        ++__lhs;
+        ++__rhs;
       }
+      return 0;
+#endif // _LIBCPP_COMPILER_CLANG_BASED
+    } else {
+      return __builtin_memcmp(__lhs, __rhs, __count);
     }
+  }
 
-    static inline _LIBCPP_HIDE_FROM_ABI size_t _LIBCPP_CONSTEXPR_SINCE_CXX17 length(const char_type* __s)  _NOEXCEPT {
-      return std::__constexpr_strlen(__s);
-    }
+  static inline _LIBCPP_HIDE_FROM_ABI size_t _LIBCPP_CONSTEXPR_SINCE_CXX17 length(const char_type* __s) _NOEXCEPT {
+    return std::__constexpr_strlen(__s);
+  }
 
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
-      if (__n == 0)
-          return nullptr;
-      return std::__constexpr_memchr(__s, __a, __n);
-    }
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
+  find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
+    if (__n == 0)
+      return nullptr;
+    return std::__constexpr_memchr(__s, __a, __n);
+  }
 
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        return std::__char_traits_move(__s1, __s2, __n);
-    }
+  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 char_type*
+  move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
+    return std::__constexpr_memmove(__s1, __s2, __element_count(__n));
+  }
 
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        if (!__libcpp_is_constant_evaluated())
-            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
-        std::copy_n(__s2, __n, __s1);
-        return __s1;
-    }
+  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 char_type*
+  copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_OVERLAPPING_RANGES(!std::__is_pointer_in_range(__s1, __s1 + __n, __s2),
+                                          "char_traits::copy: source and destination ranges overlap");
+    std::__constexpr_memmove(__s1, __s2, __element_count(__n));
+    return __s1;
+  }
 
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
-        std::fill_n(__s, __n, __a);
-        return __s;
-    }
+  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 char_type*
+  assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
+    std::fill_n(__s, __n, __a);
+    return __s;
+  }
 
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
-        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
-        {return char_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
-        {return int_type((unsigned char)__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type  eof() _NOEXCEPT
-        {return int_type(EOF);}
+  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT {
+    return eq_int_type(__c, eof()) ? ~eof() : __c;
+  }
+  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT {
+    return char_type(__c);
+  }
+  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT {
+    return int_type((unsigned char)__c);
+  }
+  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT {
+    return __c1 == __c2;
+  }
+  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT { return int_type(EOF); }
+};
+
+template <class _CharT, class _IntT, _IntT _EOFVal>
+struct __char_traits_base {
+  using char_type  = _CharT;
+  using int_type   = _IntT;
+  using off_type   = streamoff;
+  using state_type = mbstate_t;
+#if _LIBCPP_STD_VER >= 20
+  using comparison_category = strong_ordering;
+#endif
+
+  // There are different aliases for the different char types, but they are all aliases to this type
+  using pos_type = fpos<mbstate_t>;
+
+  _LIBCPP_HIDE_FROM_ABI static inline _LIBCPP_CONSTEXPR_SINCE_CXX17 void
+  assign(char_type& __lhs, const char_type& __rhs) _NOEXCEPT {
+    __lhs = __rhs;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR bool eq(char_type __lhs, char_type __rhs) _NOEXCEPT {
+    return __lhs == __rhs;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR bool lt(char_type __lhs, char_type __rhs) _NOEXCEPT {
+    return __lhs < __rhs;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX20 char_type*
+  move(char_type* __dest, const char_type* __src, size_t __n) _NOEXCEPT {
+    return std::__constexpr_memmove(__dest, __src, __element_count(__n));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX20 char_type*
+  copy(char_type* __dest, const char_type* __src, size_t __n) _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_OVERLAPPING_RANGES(!std::__is_pointer_in_range(__dest, __dest + __n, __src),
+                                          "char_traits::copy: source and destination ranges overlap");
+    return std::__constexpr_memmove(__dest, __src, __element_count(__n));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX20 char_type*
+  assign(char_type* __str, size_t __n, char_type __fill_char) _NOEXCEPT {
+    std::fill_n(__str, __n, __fill_char);
+    return __str;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT {
+    return char_type(__c);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT { return int_type(__c); }
+
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR bool eq_int_type(int_type __lhs, int_type __rhs) _NOEXCEPT {
+    return __lhs == __rhs;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT { return _EOFVal; }
+
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT {
+    return eq_int_type(__c, eof()) ? static_cast<int_type>(~eof()) : __c;
+  }
 };
 
 // char_traits<wchar_t>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
-{
-    using char_type           = wchar_t;
-    using int_type            = wint_t;
-    using off_type            = streamoff;
-    using pos_type            = streampos;
-    using state_type          = mbstate_t;
-#if _LIBCPP_STD_VER >= 20
-    using comparison_category = strong_ordering;
-#endif
-
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
-        {return __c1 < __c2;}
-
+struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t> : __char_traits_base<wchar_t, wint_t, static_cast<wint_t>(WEOF)> {
   static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 int
   compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
     if (__n == 0)
@@ -311,42 +247,12 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
     return std::__constexpr_wcslen(__s);
   }
 
-  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-  const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
+  find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
     if (__n == 0)
-        return nullptr;
+      return nullptr;
     return std::__constexpr_wmemchr(__s, __a, __n);
   }
-
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        return std::__char_traits_move(__s1, __s2, __n);
-    }
-
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        if (!__libcpp_is_constant_evaluated())
-            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
-        std::copy_n(__s2, __n, __s1);
-        return __s1;
-    }
-
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
-        std::fill_n(__s, __n, __a);
-        return __s;
-    }
-
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
-        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
-        {return char_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
-        {return int_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
-        {return int_type(WEOF);}
 };
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
@@ -354,298 +260,111 @@ struct _LIBCPP_TEMPLATE_VIS char_traits<wchar_t>
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t>
-{
-    using char_type           = char8_t;
-    using int_type            = unsigned int;
-    using off_type            = streamoff;
-    using pos_type            = u8streampos;
-    using state_type          = mbstate_t;
-#if _LIBCPP_STD_VER >= 20
-    using comparison_category = strong_ordering;
-#endif
-
-    static inline _LIBCPP_HIDE_FROM_ABI constexpr void assign(char_type& __c1, const char_type& __c2) noexcept
-        {__c1 = __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI constexpr bool eq(char_type __c1, char_type __c2) noexcept
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI constexpr bool lt(char_type __c1, char_type __c2) noexcept
-        {return __c1 < __c2;}
-
+    : __char_traits_base<char8_t, unsigned int, static_cast<unsigned int>(EOF)> {
   static _LIBCPP_HIDE_FROM_ABI constexpr int
-  compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-      return std::__constexpr_memcmp(__s1, __s2, __n);
+  compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept {
+    return std::__constexpr_memcmp(__s1, __s2, __element_count(__n));
   }
 
-    static _LIBCPP_HIDE_FROM_ABI constexpr
-    size_t           length(const char_type* __s) _NOEXCEPT;
+  static _LIBCPP_HIDE_FROM_ABI constexpr size_t length(const char_type* __str) noexcept {
+    return std::__constexpr_strlen(__str);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY static constexpr
-    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
-
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        return std::__char_traits_move(__s1, __s2, __n);
-    }
-
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        if (!__libcpp_is_constant_evaluated())
-            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
-        std::copy_n(__s2, __n, __s1);
-        return __s1;
-    }
-
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    char_type*       assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
-        std::fill_n(__s, __n, __a);
-        return __s;
-    }
-
-    static inline _LIBCPP_HIDE_FROM_ABI constexpr int_type  not_eof(int_type __c) noexcept
-        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
-    static inline _LIBCPP_HIDE_FROM_ABI constexpr char_type to_char_type(int_type __c) noexcept
-        {return char_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI constexpr int_type to_int_type(char_type __c) noexcept
-        {return int_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI constexpr bool eq_int_type(int_type __c1, int_type __c2) noexcept
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI constexpr int_type eof() noexcept
-        {return int_type(EOF);}
+  _LIBCPP_HIDE_FROM_ABI static constexpr const char_type*
+  find(const char_type* __s, size_t __n, const char_type& __a) noexcept {
+    return std::__constexpr_memchr(__s, __a, __n);
+  }
 };
 
-// TODO use '__builtin_strlen' if it ever supports char8_t ??
-inline constexpr
-size_t
-char_traits<char8_t>::length(const char_type* __s) _NOEXCEPT
-{
-    size_t __len = 0;
-    for (; !eq(*__s, char_type(0)); ++__s)
-        ++__len;
-    return __len;
-}
-
-// TODO use '__builtin_char_memchr' if it ever supports char8_t ??
-inline constexpr
-const char8_t*
-char_traits<char8_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
-{
-    for (; __n; --__n)
-    {
-        if (eq(*__s, __a))
-            return __s;
-        ++__s;
-    }
-    return nullptr;
-}
-
 #endif // _LIBCPP_HAS_NO_CHAR8_T
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
-{
-    using char_type           = char16_t;
-    using int_type            = uint_least16_t;
-    using off_type            = streamoff;
-    using pos_type            = u16streampos;
-    using state_type          = mbstate_t;
-#if _LIBCPP_STD_VER >= 20
-    using comparison_category = strong_ordering;
-#endif
+    : __char_traits_base<char16_t, uint_least16_t, static_cast<uint_least16_t>(0xFFFF)> {
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+  compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t length(const char_type* __s) _NOEXCEPT;
 
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
-        {return __c1 < __c2;}
-
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
-    int              compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
-    size_t           length(const char_type* __s) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        return std::__char_traits_move(__s1, __s2, __n);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        if (!__libcpp_is_constant_evaluated())
-            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
-        std::copy_n(__s2, __n, __s1);
-        return __s1;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static char_type*       assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
-        std::fill_n(__s, __n, __a);
-        return __s;
-    }
-
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
-        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
-        {return char_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
-        {return int_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
-        {return int_type(0xFFFF);}
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
+  find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
+    __identity __proj;
+    const char_type* __match = std::__find(__s, __s + __n, __a, __proj);
+    if (__match == __s + __n)
+      return nullptr;
+    return __match;
+  }
 };
 
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17
-int
-char_traits<char16_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
-{
-    for (; __n; --__n, ++__s1, ++__s2)
-    {
-        if (lt(*__s1, *__s2))
-            return -1;
-        if (lt(*__s2, *__s1))
-            return 1;
-    }
-    return 0;
+inline _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+char_traits<char16_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
+  for (; __n; --__n, ++__s1, ++__s2) {
+    if (lt(*__s1, *__s2))
+      return -1;
+    if (lt(*__s2, *__s1))
+      return 1;
+  }
+  return 0;
 }
 
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17
-size_t
-char_traits<char16_t>::length(const char_type* __s) _NOEXCEPT
-{
-    size_t __len = 0;
-    for (; !eq(*__s, char_type(0)); ++__s)
-        ++__len;
-    return __len;
-}
-
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17
-const char16_t*
-char_traits<char16_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
-{
-    for (; __n; --__n)
-    {
-        if (eq(*__s, __a))
-            return __s;
-        ++__s;
-    }
-    return nullptr;
+inline _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t char_traits<char16_t>::length(const char_type* __s) _NOEXCEPT {
+  size_t __len = 0;
+  for (; !eq(*__s, char_type(0)); ++__s)
+    ++__len;
+  return __len;
 }
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char32_t>
-{
-    using char_type           = char32_t;
-    using int_type            = uint_least32_t;
-    using off_type            = streamoff;
-    using pos_type            = u32streampos;
-    using state_type          = mbstate_t;
-#if _LIBCPP_STD_VER >= 20
-    using comparison_category = strong_ordering;
-#endif
+    : __char_traits_base<char32_t, uint_least32_t, static_cast<uint_least32_t>(0xFFFFFFFF)> {
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+  compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t length(const char_type* __s) _NOEXCEPT;
 
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17
-    void assign(char_type& __c1, const char_type& __c2) _NOEXCEPT {__c1 = __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT
-        {return __c1 < __c2;}
-
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
-    int              compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
-    size_t           length(const char_type* __s) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const char_type* find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT;
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        return std::__char_traits_move(__s1, __s2, __n);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
-        std::copy_n(__s2, __n, __s1);
-        return __s1;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static char_type*       assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT {
-        std::fill_n(__s, __n, __a);
-        return __s;
-    }
-
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type  not_eof(int_type __c) _NOEXCEPT
-        {return eq_int_type(__c, eof()) ? ~eof() : __c;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT
-        {return char_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT
-        {return int_type(__c);}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT
-        {return __c1 == __c2;}
-    static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT
-        {return int_type(0xFFFFFFFF);}
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
+  find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
+    __identity __proj;
+    const char_type* __match = std::__find(__s, __s + __n, __a, __proj);
+    if (__match == __s + __n)
+      return nullptr;
+    return __match;
+  }
 };
 
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17
-int
-char_traits<char32_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
-{
-    for (; __n; --__n, ++__s1, ++__s2)
-    {
-        if (lt(*__s1, *__s2))
-            return -1;
-        if (lt(*__s2, *__s1))
-            return 1;
-    }
-    return 0;
+inline _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+char_traits<char32_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
+  for (; __n; --__n, ++__s1, ++__s2) {
+    if (lt(*__s1, *__s2))
+      return -1;
+    if (lt(*__s2, *__s1))
+      return 1;
+  }
+  return 0;
 }
 
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17
-size_t
-char_traits<char32_t>::length(const char_type* __s) _NOEXCEPT
-{
-    size_t __len = 0;
-    for (; !eq(*__s, char_type(0)); ++__s)
-        ++__len;
-    return __len;
-}
-
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17
-const char32_t*
-char_traits<char32_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
-{
-    for (; __n; --__n)
-    {
-        if (eq(*__s, __a))
-            return __s;
-        ++__s;
-    }
-    return nullptr;
+inline _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t char_traits<char32_t>::length(const char_type* __s) _NOEXCEPT {
+  size_t __len = 0;
+  for (; !eq(*__s, char_type(0)); ++__s)
+    ++__len;
+  return __len;
 }
 
 // helper fns for basic_string and string_view
 
 // __str_find
-template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-__str_find(const _CharT *__p, _SizeT __sz,
-             _CharT __c, _SizeT __pos) _NOEXCEPT
-{
-    if (__pos >= __sz)
-        return __npos;
-    const _CharT* __r = _Traits::find(__p + __pos, __sz - __pos, __c);
-    if (__r == nullptr)
-        return __npos;
-    return static_cast<_SizeT>(__r - __p);
+template <class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+__str_find(const _CharT* __p, _SizeT __sz, _CharT __c, _SizeT __pos) _NOEXCEPT {
+  if (__pos >= __sz)
+    return __npos;
+  const _CharT* __r = _Traits::find(__p + __pos, __sz - __pos, __c);
+  if (__r == nullptr)
+    return __npos;
+  return static_cast<_SizeT>(__r - __p);
 }
 
 template <class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX14 const _CharT *
-__search_substring(const _CharT *__first1, const _CharT *__last1,
-                   const _CharT *__first2, const _CharT *__last2) _NOEXCEPT {
+_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX14 const _CharT* __search_substring(
+    const _CharT* __first1, const _CharT* __last1, const _CharT* __first2, const _CharT* __last2) _NOEXCEPT {
   // Take advantage of knowing source and pattern lengths.
   // Stop short when source is smaller than pattern.
   const ptrdiff_t __len2 = __last2 - __first2;
@@ -681,173 +400,140 @@ __search_substring(const _CharT *__first1, const _CharT *__last1,
   }
 }
 
-template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-__str_find(const _CharT *__p, _SizeT __sz,
-       const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
-{
-    if (__pos > __sz)
-        return __npos;
+template <class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+__str_find(const _CharT* __p, _SizeT __sz, const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT {
+  if (__pos > __sz)
+    return __npos;
 
-    if (__n == 0) // There is nothing to search, just return __pos.
-        return __pos;
+  if (__n == 0) // There is nothing to search, just return __pos.
+    return __pos;
 
-    const _CharT *__r = std::__search_substring<_CharT, _Traits>(
-        __p + __pos, __p + __sz, __s, __s + __n);
+  const _CharT* __r = std::__search_substring<_CharT, _Traits>(__p + __pos, __p + __sz, __s, __s + __n);
 
-    if (__r == __p + __sz)
-        return __npos;
-    return static_cast<_SizeT>(__r - __p);
+  if (__r == __p + __sz)
+    return __npos;
+  return static_cast<_SizeT>(__r - __p);
 }
 
-
 // __str_rfind
 
-template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-__str_rfind(const _CharT *__p, _SizeT __sz,
-              _CharT __c, _SizeT __pos) _NOEXCEPT
-{
-    if (__sz < 1)
-        return __npos;
-    if (__pos < __sz)
-        ++__pos;
-    else
-        __pos = __sz;
-    for (const _CharT* __ps = __p + __pos; __ps != __p;)
-    {
-        if (_Traits::eq(*--__ps, __c))
-            return static_cast<_SizeT>(__ps - __p);
-    }
+template <class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+__str_rfind(const _CharT* __p, _SizeT __sz, _CharT __c, _SizeT __pos) _NOEXCEPT {
+  if (__sz < 1)
     return __npos;
+  if (__pos < __sz)
+    ++__pos;
+  else
+    __pos = __sz;
+  for (const _CharT* __ps = __p + __pos; __ps != __p;) {
+    if (_Traits::eq(*--__ps, __c))
+      return static_cast<_SizeT>(__ps - __p);
+  }
+  return __npos;
 }
 
-template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-__str_rfind(const _CharT *__p, _SizeT __sz,
-        const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
-{
-    __pos = _VSTD::min(__pos, __sz);
-    if (__n < __sz - __pos)
-        __pos += __n;
-    else
-        __pos = __sz;
-    const _CharT* __r = std::__find_end_classic(__p, __p + __pos, __s, __s + __n, _Traits::eq);
-    if (__n > 0 && __r == __p + __pos)
-        return __npos;
-    return static_cast<_SizeT>(__r - __p);
+template <class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+__str_rfind(const _CharT* __p, _SizeT __sz, const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT {
+  __pos = std::min(__pos, __sz);
+  if (__n < __sz - __pos)
+    __pos += __n;
+  else
+    __pos = __sz;
+  const _CharT* __r = std::__find_end_classic(__p, __p + __pos, __s, __s + __n, _Traits::eq);
+  if (__n > 0 && __r == __p + __pos)
+    return __npos;
+  return static_cast<_SizeT>(__r - __p);
 }
 
 // __str_find_first_of
-template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-__str_find_first_of(const _CharT *__p, _SizeT __sz,
-                const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
-{
-    if (__pos >= __sz || __n == 0)
-        return __npos;
-    const _CharT* __r = _VSTD::__find_first_of_ce
-        (__p + __pos, __p + __sz, __s, __s + __n, _Traits::eq );
-    if (__r == __p + __sz)
-        return __npos;
-    return static_cast<_SizeT>(__r - __p);
+template <class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+__str_find_first_of(const _CharT* __p, _SizeT __sz, const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT {
+  if (__pos >= __sz || __n == 0)
+    return __npos;
+  const _CharT* __r = std::__find_first_of_ce(__p + __pos, __p + __sz, __s, __s + __n, _Traits::eq);
+  if (__r == __p + __sz)
+    return __npos;
+  return static_cast<_SizeT>(__r - __p);
 }
 
-
 // __str_find_last_of
-template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-__str_find_last_of(const _CharT *__p, _SizeT __sz,
-               const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
-    {
-    if (__n != 0)
-    {
-        if (__pos < __sz)
-            ++__pos;
-        else
-            __pos = __sz;
-        for (const _CharT* __ps = __p + __pos; __ps != __p;)
-        {
-            const _CharT* __r = _Traits::find(__s, __n, *--__ps);
-            if (__r)
-                return static_cast<_SizeT>(__ps - __p);
-        }
+template <class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+__str_find_last_of(const _CharT* __p, _SizeT __sz, const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT {
+  if (__n != 0) {
+    if (__pos < __sz)
+      ++__pos;
+    else
+      __pos = __sz;
+    for (const _CharT* __ps = __p + __pos; __ps != __p;) {
+      const _CharT* __r = _Traits::find(__s, __n, *--__ps);
+      if (__r)
+        return static_cast<_SizeT>(__ps - __p);
     }
-    return __npos;
+  }
+  return __npos;
 }
 
-
 // __str_find_first_not_of
-template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-__str_find_first_not_of(const _CharT *__p, _SizeT __sz,
-                    const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
-{
-    if (__pos < __sz)
-    {
-        const _CharT* __pe = __p + __sz;
-        for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
-            if (_Traits::find(__s, __n, *__ps) == nullptr)
-                return static_cast<_SizeT>(__ps - __p);
-    }
-    return __npos;
+template <class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+__str_find_first_not_of(const _CharT* __p, _SizeT __sz, const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT {
+  if (__pos < __sz) {
+    const _CharT* __pe = __p + __sz;
+    for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
+      if (_Traits::find(__s, __n, *__ps) == nullptr)
+        return static_cast<_SizeT>(__ps - __p);
+  }
+  return __npos;
 }
 
-
-template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-__str_find_first_not_of(const _CharT *__p, _SizeT __sz,
-                          _CharT __c, _SizeT __pos) _NOEXCEPT
-{
-    if (__pos < __sz)
-    {
-        const _CharT* __pe = __p + __sz;
-        for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
-            if (!_Traits::eq(*__ps, __c))
-                return static_cast<_SizeT>(__ps - __p);
-    }
-    return __npos;
+template <class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+__str_find_first_not_of(const _CharT* __p, _SizeT __sz, _CharT __c, _SizeT __pos) _NOEXCEPT {
+  if (__pos < __sz) {
+    const _CharT* __pe = __p + __sz;
+    for (const _CharT* __ps = __p + __pos; __ps != __pe; ++__ps)
+      if (!_Traits::eq(*__ps, __c))
+        return static_cast<_SizeT>(__ps - __p);
+  }
+  return __npos;
 }
 
-
 // __str_find_last_not_of
-template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-__str_find_last_not_of(const _CharT *__p, _SizeT __sz,
-                   const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT
-{
-    if (__pos < __sz)
-        ++__pos;
-    else
-        __pos = __sz;
-    for (const _CharT* __ps = __p + __pos; __ps != __p;)
-        if (_Traits::find(__s, __n, *--__ps) == nullptr)
-            return static_cast<_SizeT>(__ps - __p);
-    return __npos;
+template <class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+__str_find_last_not_of(const _CharT* __p, _SizeT __sz, const _CharT* __s, _SizeT __pos, _SizeT __n) _NOEXCEPT {
+  if (__pos < __sz)
+    ++__pos;
+  else
+    __pos = __sz;
+  for (const _CharT* __ps = __p + __pos; __ps != __p;)
+    if (_Traits::find(__s, __n, *--__ps) == nullptr)
+      return static_cast<_SizeT>(__ps - __p);
+  return __npos;
 }
 
-
-template<class _CharT, class _SizeT, class _Traits, _SizeT __npos>
-inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-__str_find_last_not_of(const _CharT *__p, _SizeT __sz,
-                         _CharT __c, _SizeT __pos) _NOEXCEPT
-{
-    if (__pos < __sz)
-        ++__pos;
-    else
-        __pos = __sz;
-    for (const _CharT* __ps = __p + __pos; __ps != __p;)
-        if (!_Traits::eq(*--__ps, __c))
-            return static_cast<_SizeT>(__ps - __p);
-    return __npos;
+template <class _CharT, class _SizeT, class _Traits, _SizeT __npos>
+inline _SizeT _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+__str_find_last_not_of(const _CharT* __p, _SizeT __sz, _CharT __c, _SizeT __pos) _NOEXCEPT {
+  if (__pos < __sz)
+    ++__pos;
+  else
+    __pos = __sz;
+  for (const _CharT* __ps = __p + __pos; __ps != __p;)
+    if (!_Traits::eq(*--__ps, __c))
+      return static_cast<_SizeT>(__ps - __p);
+  return __npos;
 }
 
-template<class _Ptr>
-inline _LIBCPP_INLINE_VISIBILITY
-size_t __do_string_hash(_Ptr __p, _Ptr __e)
-{
-    typedef typename iterator_traits<_Ptr>::value_type value_type;
-    return __murmur2_or_cityhash<size_t>()(__p, (__e-__p)*sizeof(value_type));
+template <class _Ptr>
+inline _LIBCPP_HIDE_FROM_ABI size_t __do_string_hash(_Ptr __p, _Ptr __e) {
+  typedef typename iterator_traits<_Ptr>::value_type value_type;
+  return __murmur2_or_cityhash<size_t>()(__p, (__e - __p) * sizeof(value_type));
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__string/constexpr_c_functions.h b/third_party/libcxx/__string/constexpr_c_functions.h
index 9a768cf2d..a978f816f 100644
--- a/third_party/libcxx/__string/constexpr_c_functions.h
+++ b/third_party/libcxx/__string/constexpr_c_functions.h
@@ -10,11 +10,19 @@
 #define _LIBCPP___STRING_CONSTEXPR_C_FUNCTIONS_H
 
 #include <__config>
+#include <__memory/addressof.h>
+#include <__memory/construct_at.h>
+#include <__type_traits/datasizeof.h>
+#include <__type_traits/is_always_bitcastable.h>
+#include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constant_evaluated.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/is_equality_comparable.h>
 #include <__type_traits/is_same.h>
+#include <__type_traits/is_trivially_copyable.h>
 #include <__type_traits/is_trivially_lexicographically_comparable.h>
 #include <__type_traits/remove_cv.h>
+#include <__utility/is_pointer_in_range.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -23,18 +31,37 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 size_t __constexpr_strlen(const char* __str) {
+// Type used to encode that a function takes an integer that represents a number
+// of elements as opposed to a number of bytes.
+enum class __element_count : size_t {};
+
+template <class _Tp>
+inline const bool __is_char_type = false;
+
+template <>
+inline const bool __is_char_type<char> = true;
+
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+template <>
+inline const bool __is_char_type<char8_t> = true;
+#endif
+
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 size_t __constexpr_strlen(const _Tp* __str) _NOEXCEPT {
+  static_assert(__is_char_type<_Tp>, "__constexpr_strlen only works with char and char8_t");
   // GCC currently doesn't support __builtin_strlen for heap-allocated memory during constant evaluation.
   // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70816
-#ifdef _LIBCPP_COMPILER_GCC
   if (__libcpp_is_constant_evaluated()) {
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_COMPILER_CLANG_BASED)
+    if constexpr (is_same_v<_Tp, char>)
+      return __builtin_strlen(__str);
+#endif
     size_t __i = 0;
     for (; __str[__i] != '\0'; ++__i)
       ;
     return __i;
   }
-#endif
-  return __builtin_strlen(__str);
+  return __builtin_strlen(reinterpret_cast<const char*>(__str));
 }
 
 // Because of __libcpp_is_trivially_lexicographically_comparable we know that comparing the object representations is
@@ -42,14 +69,16 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 size_t __constexpr_st
 // of invoking it on every object individually.
 template <class _Tp, class _Up>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int
-__constexpr_memcmp(const _Tp* __lhs, const _Up* __rhs, size_t __count) {
+__constexpr_memcmp(const _Tp* __lhs, const _Up* __rhs, __element_count __n) {
   static_assert(__libcpp_is_trivially_lexicographically_comparable<_Tp, _Up>::value,
                 "_Tp and _Up have to be trivially lexicographically comparable");
 
+  auto __count = static_cast<size_t>(__n);
+
   if (__libcpp_is_constant_evaluated()) {
 #ifdef _LIBCPP_COMPILER_CLANG_BASED
     if (sizeof(_Tp) == 1 && !is_same<_Tp, bool>::value)
-      return __builtin_memcmp(__lhs, __rhs, __count);
+      return __builtin_memcmp(__lhs, __rhs, __count * sizeof(_Tp));
 #endif
 
     while (__count != 0) {
@@ -58,13 +87,13 @@ __constexpr_memcmp(const _Tp* __lhs, const _Up* __rhs, size_t __count) {
       if (*__rhs < *__lhs)
         return 1;
 
-      __count -= sizeof(_Tp);
+      --__count;
       ++__lhs;
       ++__rhs;
     }
     return 0;
   } else {
-    return __builtin_memcmp(__lhs, __rhs, __count);
+    return __builtin_memcmp(__lhs, __rhs, __count * sizeof(_Tp));
   }
 }
 
@@ -73,26 +102,28 @@ __constexpr_memcmp(const _Tp* __lhs, const _Up* __rhs, size_t __count) {
 // of invoking it on every object individually.
 template <class _Tp, class _Up>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
-__constexpr_memcmp_equal(const _Tp* __lhs, const _Up* __rhs, size_t __count) {
+__constexpr_memcmp_equal(const _Tp* __lhs, const _Up* __rhs, __element_count __n) {
   static_assert(__libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
                 "_Tp and _Up have to be trivially equality comparable");
 
+  auto __count = static_cast<size_t>(__n);
+
   if (__libcpp_is_constant_evaluated()) {
 #ifdef _LIBCPP_COMPILER_CLANG_BASED
     if (sizeof(_Tp) == 1 && is_integral<_Tp>::value && !is_same<_Tp, bool>::value)
-      return __builtin_memcmp(__lhs, __rhs, __count) == 0;
+      return __builtin_memcmp(__lhs, __rhs, __count * sizeof(_Tp)) == 0;
 #endif
     while (__count != 0) {
       if (*__lhs != *__rhs)
         return false;
 
-      __count -= sizeof(_Tp);
+      --__count;
       ++__lhs;
       ++__rhs;
     }
     return true;
   } else {
-    return __builtin_memcmp(__lhs, __rhs, __count) == 0;
+    return ::__builtin_memcmp(__lhs, __rhs, __count * sizeof(_Tp)) == 0;
   }
 }
 
@@ -121,6 +152,83 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __constexpr_memchr(_Tp*
   }
 }
 
+// This function performs an assignment to an existing, already alive TriviallyCopyable object
+// from another TriviallyCopyable object.
+//
+// It basically works around the fact that TriviallyCopyable objects are not required to be
+// syntactically copy/move constructible or copy/move assignable. Technically, only one of the
+// four operations is required to be syntactically valid -- but at least one definitely has to
+// be valid.
+//
+// This is necessary in order to implement __constexpr_memmove below in a way that mirrors as
+// closely as possible what the compiler's __builtin_memmove is able to do.
+template <class _Tp, class _Up, __enable_if_t<is_assignable<_Tp&, _Up const&>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp& __assign_trivially_copyable(_Tp& __dest, _Up const& __src) {
+  __dest = __src;
+  return __dest;
+}
+
+// clang-format off
+template <class _Tp, class _Up, __enable_if_t<!is_assignable<_Tp&, _Up const&>::value &&
+                                               is_assignable<_Tp&, _Up&&>::value, int> = 0>
+// clang-format on
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp& __assign_trivially_copyable(_Tp& __dest, _Up& __src) {
+  __dest =
+      static_cast<_Up&&>(__src); // this is safe, we're not actually moving anything since the assignment is trivial
+  return __dest;
+}
+
+// clang-format off
+template <class _Tp, class _Up, __enable_if_t<!is_assignable<_Tp&, _Up const&>::value &&
+                                              !is_assignable<_Tp&, _Up&&>::value &&
+                                               is_constructible<_Tp, _Up const&>::value, int> = 0>
+// clang-format on
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& __assign_trivially_copyable(_Tp& __dest, _Up const& __src) {
+  // _Tp is trivially destructible, so we don't need to call its destructor to end the lifetime of the object
+  // that was there previously
+  std::__construct_at(std::addressof(__dest), __src);
+  return __dest;
+}
+
+// clang-format off
+template <class _Tp, class _Up, __enable_if_t<!is_assignable<_Tp&, _Up const&>::value &&
+                                              !is_assignable<_Tp&, _Up&&>::value &&
+                                              !is_constructible<_Tp, _Up const&>::value &&
+                                               is_constructible<_Tp, _Up&&>::value, int> = 0>
+// clang-format on
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& __assign_trivially_copyable(_Tp& __dest, _Up& __src) {
+  // _Tp is trivially destructible, so we don't need to call its destructor to end the lifetime of the object
+  // that was there previously
+  std::__construct_at(
+      std::addressof(__dest),
+      static_cast<_Up&&>(__src)); // this is safe, we're not actually moving anything since the constructor is trivial
+  return __dest;
+}
+
+template <class _Tp, class _Up, __enable_if_t<__is_always_bitcastable<_Up, _Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp*
+__constexpr_memmove(_Tp* __dest, _Up* __src, __element_count __n) {
+  size_t __count = static_cast<size_t>(__n);
+  if (__libcpp_is_constant_evaluated()) {
+#ifdef _LIBCPP_COMPILER_CLANG_BASED
+    if (is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up> >::value) {
+      ::__builtin_memmove(__dest, __src, __count * sizeof(_Tp));
+      return __dest;
+    }
+#endif
+    if (std::__is_pointer_in_range(__src, __src + __count, __dest)) {
+      for (; __count > 0; --__count)
+        std::__assign_trivially_copyable(__dest[__count - 1], __src[__count - 1]);
+    } else {
+      for (size_t __i = 0; __i != __count; ++__i)
+        std::__assign_trivially_copyable(__dest[__i], __src[__i]);
+    }
+  } else if (__count > 0) {
+    ::__builtin_memmove(__dest, __src, (__count - 1) * sizeof(_Tp) + __datasizeof_v<_Tp>);
+  }
+  return __dest;
+}
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___STRING_CONSTEXPR_C_FUNCTIONS_H
diff --git a/third_party/libcxx/__string/extern_template_lists.h b/third_party/libcxx/__string/extern_template_lists.h
index edbda7cbd..cc536e514 100644
--- a/third_party/libcxx/__string/extern_template_lists.h
+++ b/third_party/libcxx/__string/extern_template_lists.h
@@ -15,6 +15,8 @@
 #  pragma GCC system_header
 #endif
 
+// clang-format off
+
 // We maintain 2 ABI lists:
 // - _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST
 // - _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST
@@ -28,104 +30,104 @@
 // functions supporting new c++ version / API changes. Typically entries
 // must never be removed from the stable list.
 #define _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&, allocator<_CharType> const&)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::~basic_string()) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_not_of(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::operator=(value_type)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS const _CharType& basic_string<_CharType>::at(size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_of(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::reserve(size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(basic_string const&, size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::copy(value_type*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&, size_type, size_type, allocator<_CharType> const&)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_of(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by(size_type, size_type, size_type, size_type, size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by_and_replace(size_type, size_type, size_type, size_type, size_type, size_type, value_type const*)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::push_back(value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS const basic_string<_CharType>::size_type basic_string<_CharType>::npos) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::erase(size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(basic_string const&, size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(value_type const*) const) \
-  _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*) const) \
-  _Func(_LIBCPP_FUNC_VIS _CharType& basic_string<_CharType>::at(size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(value_type const*)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, basic_string const&, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::operator=(basic_string const&)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::resize(size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::basic_string(basic_string const&)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::basic_string(basic_string const&, allocator<_CharType> const&)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::~basic_string()) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_first_not_of(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::operator=(value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__init(value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI const _CharType& basic_string<_CharType>::at(size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_first_of(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::assign(value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::reserve(size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::assign(basic_string const&, size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::copy(value_type*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::basic_string(basic_string const&, size_type, size_type, allocator<_CharType> const&)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__init(size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_last_of(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__grow_by(size_type, size_type, size_type, size_type, size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__grow_by_and_replace(size_type, size_type, size_type, size_type, size_type, size_type, value_type const*)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::push_back(value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI const basic_string<_CharType>::size_type basic_string<_CharType>::npos) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::assign(size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::erase(size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(basic_string const&, size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI int basic_string<_CharType>::compare(value_type const*) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI int basic_string<_CharType>::compare(size_type, size_type, value_type const*) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI _CharType& basic_string<_CharType>::at(size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::assign(value_type const*)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI int basic_string<_CharType>::compare(size_type, size_type, basic_string const&, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::operator=(basic_string const&)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::resize(size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
 
 #define _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_Func, _CharType) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::~basic_string()) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_not_of(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::operator=(value_type)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init_copy_ctor_external(value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS const _CharType& basic_string<_CharType>::at(size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_first_of(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_external(value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_external(value_type const*)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::reserve(size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(basic_string const&, size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::copy(value_type*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::basic_string(basic_string const&, size_type, size_type, allocator<_CharType> const&)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__init(size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find_last_of(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by(size_type, size_type, size_type, size_type, size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__grow_by_and_replace(size_type, size_type, size_type, size_type, size_type, size_type, value_type const*)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_no_alias<false>(value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::__assign_no_alias<true>(value_type const*, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::push_back(value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS const basic_string<_CharType>::size_type basic_string<_CharType>::npos) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::assign(size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::__erase_external_with_move(size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(basic_string const&, size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(value_type const*) const) \
-  _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*) const) \
-  _Func(_LIBCPP_FUNC_VIS _CharType& basic_string<_CharType>::at(size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type const*, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, basic_string const&, size_type, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS void basic_string<_CharType>::resize(size_type, value_type)) \
-  _Func(_LIBCPP_FUNC_VIS basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__init(value_type const*, size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, value_type const*)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_last_not_of(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::~basic_string()) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_first_not_of(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::operator=(value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__init(value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__init_copy_ctor_external(value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI const _CharType& basic_string<_CharType>::at(size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_first_of(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::__assign_external(value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::__assign_external(value_type const*)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::reserve(size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::assign(basic_string const&, size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::copy(value_type*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::basic_string(basic_string const&, size_type, size_type, allocator<_CharType> const&)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__init(size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, value_type const*)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find_last_of(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__grow_by_and_replace(size_type, size_type, size_type, size_type, size_type, size_type, value_type const*)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::__assign_no_alias<false>(value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::__assign_no_alias<true>(value_type const*, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::push_back(value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::rfind(value_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI const basic_string<_CharType>::size_type basic_string<_CharType>::npos) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::assign(size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::__erase_external_with_move(size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(basic_string const&, size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI int basic_string<_CharType>::compare(value_type const*) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI int basic_string<_CharType>::compare(size_type, size_type, value_type const*) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI _CharType& basic_string<_CharType>::at(size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::size_type basic_string<_CharType>::find(value_type const*, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI int basic_string<_CharType>::compare(size_type, size_type, basic_string const&, size_type, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI int basic_string<_CharType>::compare(size_type, size_type, value_type const*, size_type) const) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::append(value_type const*)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::replace(size_type, size_type, basic_string const&, size_type, size_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>::iterator basic_string<_CharType>::insert(basic_string::const_iterator, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI void basic_string<_CharType>::resize(size_type, value_type)) \
+  _Func(_LIBCPP_EXPORTED_FROM_ABI basic_string<_CharType>& basic_string<_CharType>::insert(size_type, basic_string const&, size_type, size_type))
 
+// clang-format on
 
 #endif // _LIBCPP___STRING_EXTERN_TEMPLATE_LISTS_H
diff --git a/third_party/libcxx/__support/android/locale_bionic.h b/third_party/libcxx/__support/android/locale_bionic.h
deleted file mode 100644
index 30e345cf9..000000000
--- a/third_party/libcxx/__support/android/locale_bionic.h
+++ /dev/null
@@ -1,72 +0,0 @@
-// -*- C++ -*-
-//===-----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___SUPPORT_ANDROID_LOCALE_BIONIC_H
-#define _LIBCPP___SUPPORT_ANDROID_LOCALE_BIONIC_H
-
-#if defined(__BIONIC__)
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdlib.h>
-#include <xlocale.h>
-
-#ifdef __cplusplus
-}
-#endif
-
-#if defined(__ANDROID__)
-
-#include <android/api-level.h>
-#if __ANDROID_API__ < 21
-#include <__support/xlocale/__posix_l_fallback.h>
-#endif
-
-// If we do not have this header, we are in a platform build rather than an NDK
-// build, which will always be at least as new as the ToT NDK, in which case we
-// don't need any of the inlines below since libc provides them.
-#if __has_include(<android/ndk-version.h>)
-#include <android/ndk-version.h>
-// In NDK versions later than 16, locale-aware functions are provided by
-// legacy_stdlib_inlines.h
-#if __NDK_MAJOR__ <= 16
-#if __ANDROID_API__ < 21
-#include <__support/xlocale/__strtonum_fallback.h>
-#elif __ANDROID_API__ < 26
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-inline _LIBCPP_HIDE_FROM_ABI_C float strtof_l(const char* __nptr, char** __endptr, locale_t) {
-  return ::strtof(__nptr, __endptr);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI_C double strtod_l(const char* __nptr, char** __endptr, locale_t) {
-  return ::strtod(__nptr, __endptr);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI_C long strtol_l(const char* __nptr, char** __endptr, int __base, locale_t) {
-  return ::strtol(__nptr, __endptr, __base);
-}
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif // __ANDROID_API__ < 26
-
-#endif // __NDK_MAJOR__ <= 16
-#endif // __has_include(<android/ndk-version.h>)
-#endif // defined(__ANDROID__)
-
-#endif // defined(__BIONIC__)
-#endif // _LIBCPP___SUPPORT_ANDROID_LOCALE_BIONIC_H
diff --git a/third_party/libcxx/__support/fuchsia/xlocale.h b/third_party/libcxx/__support/fuchsia/xlocale.h
deleted file mode 100644
index 1e4ece8dd..000000000
--- a/third_party/libcxx/__support/fuchsia/xlocale.h
+++ /dev/null
@@ -1,22 +0,0 @@
-// -*- C++ -*-
-//===-----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___SUPPORT_FUCHSIA_XLOCALE_H
-#define _LIBCPP___SUPPORT_FUCHSIA_XLOCALE_H
-
-#if defined(__Fuchsia__)
-
-#include <cstdlib>
-#include <cwchar>
-#include <__support/xlocale/__posix_l_fallback.h>
-#include <__support/xlocale/__strtonum_fallback.h>
-
-#endif // defined(__Fuchsia__)
-
-#endif // _LIBCPP___SUPPORT_FUCHSIA_XLOCALE_H
diff --git a/third_party/libcxx/__support/ibm/gettod_zos.h b/third_party/libcxx/__support/ibm/gettod_zos.h
deleted file mode 100644
index fe7dc8bc1..000000000
--- a/third_party/libcxx/__support/ibm/gettod_zos.h
+++ /dev/null
@@ -1,54 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___SUPPORT_IBM_GETTOD_ZOS_H
-#define _LIBCPP___SUPPORT_IBM_GETTOD_ZOS_H
-
-#include <time.h>
-
-inline _LIBCPP_HIDE_FROM_ABI int
-gettimeofdayMonotonic(struct timespec64* Output) {
-
-  // The POSIX gettimeofday() function is not available on z/OS. Therefore,
-  // we will call stcke and other hardware instructions in implement equivalent.
-  // Note that nanoseconds alone will overflow when reaching new epoch in 2042.
-
-  struct _t {
-    uint64_t Hi;
-    uint64_t Lo;
-  };
-  struct _t Value = {0, 0};
-  uint64_t CC = 0;
-  asm(" stcke %0\n"
-      " ipm %1\n"
-      " srlg %1,%1,28\n"
-      : "=m"(Value), "+r"(CC)::);
-
-  if (CC != 0) {
-    errno = EMVSTODNOTSET;
-    return CC;
-  }
-  uint64_t us = (Value.Hi >> 4);
-  uint64_t ns = ((Value.Hi & 0x0F) << 8) + (Value.Lo >> 56);
-  ns = (ns * 1000) >> 12;
-  us = us - 2208988800000000;
-
-  register uint64_t DivPair0 asm("r0"); // dividend (upper half), remainder
-  DivPair0 = 0;
-  register uint64_t DivPair1 asm("r1"); // dividend (lower half), quotient
-  DivPair1 = us;
-  uint64_t Divisor = 1000000;
-  asm(" dlgr %0,%2" : "+r"(DivPair0), "+r"(DivPair1) : "r"(Divisor) :);
-
-  Output->tv_sec = DivPair1;
-  Output->tv_nsec = DivPair0 * 1000 + ns;
-  return 0;
-}
-
-#endif // _LIBCPP___SUPPORT_IBM_GETTOD_ZOS_H
diff --git a/third_party/libcxx/__support/ibm/locale_mgmt_zos.h b/third_party/libcxx/__support/ibm/locale_mgmt_zos.h
deleted file mode 100644
index 179f563eb..000000000
--- a/third_party/libcxx/__support/ibm/locale_mgmt_zos.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___SUPPORT_IBM_LOCALE_MGMT_ZOS_H
-#define _LIBCPP___SUPPORT_IBM_LOCALE_MGMT_ZOS_H
-
-#if defined(__MVS__)
-#include <locale.h>
-#include <string>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define _LC_MAX           LC_MESSAGES          /* highest real category */
-#define _NCAT             (_LC_MAX + 1)        /* maximum + 1 */
-
-#define _CATMASK(n)       (1 << (n))
-#define LC_COLLATE_MASK   _CATMASK(LC_COLLATE)
-#define LC_CTYPE_MASK     _CATMASK(LC_CTYPE)
-#define LC_MONETARY_MASK  _CATMASK(LC_MONETARY)
-#define LC_NUMERIC_MASK   _CATMASK(LC_NUMERIC)
-#define LC_TIME_MASK      _CATMASK(LC_TIME)
-#define LC_MESSAGES_MASK  _CATMASK(LC_MESSAGES)
-#define LC_ALL_MASK       (_CATMASK(_NCAT) - 1)
-
-typedef struct locale_struct {
-  int category_mask;
-  std::string lc_collate;
-  std::string lc_ctype;
-  std::string lc_monetary;
-  std::string lc_numeric;
-  std::string lc_time;
-  std::string lc_messages;
-} * locale_t;
-
-// z/OS does not have newlocale, freelocale and uselocale.
-// The functions below are workarounds in single thread mode.
-locale_t newlocale(int category_mask, const char* locale, locale_t base);
-void freelocale(locale_t locobj);
-locale_t uselocale(locale_t newloc);
-
-#ifdef __cplusplus
-}
-#endif
-#endif // defined(__MVS__)
-#endif // _LIBCPP___SUPPORT_IBM_LOCALE_MGMT_ZOS_H
diff --git a/third_party/libcxx/__support/ibm/nanosleep.h b/third_party/libcxx/__support/ibm/nanosleep.h
deleted file mode 100644
index 7a32c66c1..000000000
--- a/third_party/libcxx/__support/ibm/nanosleep.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___SUPPORT_IBM_NANOSLEEP_H
-#define _LIBCPP___SUPPORT_IBM_NANOSLEEP_H
-
-#include <unistd.h>
-
-inline int nanosleep(const struct timespec* __req, struct timespec* __rem) {
-  // The nanosleep() function is not available on z/OS. Therefore, we will call
-  // sleep() to sleep for whole seconds and usleep() to sleep for any remaining
-  // fraction of a second. Any remaining nanoseconds will round up to the next
-  // microsecond.
-  if (__req->tv_sec < 0 || __req->tv_nsec < 0 || __req->tv_nsec > 999999999) {
-    errno = EINVAL;
-    return -1;
-  }
-  long __micro_sec = (__req->tv_nsec + 999) / 1000;
-  time_t __sec = __req->tv_sec;
-  if (__micro_sec > 999999) {
-    ++__sec;
-    __micro_sec -= 1000000;
-  }
-  __sec = static_cast<time_t>(sleep(static_cast<unsigned int>(__sec)));
-  if (__sec) {
-    if (__rem) {
-      // Updating the remaining time to sleep in case of unsuccessful call to sleep().
-      __rem->tv_sec = __sec;
-      __rem->tv_nsec = __micro_sec * 1000;
-    }
-    errno = EINTR;
-    return -1;
-  }
-  if (__micro_sec) {
-    int __rt = usleep(static_cast<unsigned int>(__micro_sec));
-    if (__rt != 0 && __rem) {
-      // The usleep() does not provide the amount of remaining time upon its failure,
-      // so the time slept will be ignored.
-      __rem->tv_sec = 0;
-      __rem->tv_nsec = __micro_sec * 1000;
-      // The errno is already set.
-      return -1;
-    }
-    return __rt;
-  }
-  return 0;
-}
-
-#endif // _LIBCPP___SUPPORT_IBM_NANOSLEEP_H
diff --git a/third_party/libcxx/__support/ibm/xlocale.h b/third_party/libcxx/__support/ibm/xlocale.h
deleted file mode 100644
index 03302b0d4..000000000
--- a/third_party/libcxx/__support/ibm/xlocale.h
+++ /dev/null
@@ -1,129 +0,0 @@
-// -*- C++ -*-
-//===-----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___SUPPORT_IBM_XLOCALE_H
-#define _LIBCPP___SUPPORT_IBM_XLOCALE_H
-
-#if defined(__MVS__)
-#include <__support/ibm/locale_mgmt_zos.h>
-#endif // defined(__MVS__)
-
-#include <stdarg.h>
-
-#include "cstdlib"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if defined(__MVS__)
-#include <wctype.h>
-// POSIX routines
-#include <__support/xlocale/__posix_l_fallback.h>
-#endif // defined(__MVS__)
-
-namespace {
-
-struct __setAndRestore {
-  explicit __setAndRestore(locale_t locale) {
-    if (locale == (locale_t)0) {
-      __cloc = newlocale(LC_ALL_MASK, "C", /* base */ (locale_t)0);
-      __stored = uselocale(__cloc);
-    } else {
-      __stored = uselocale(locale);
-    }
-  }
-
-  ~__setAndRestore() {
-    uselocale(__stored);
-    if (__cloc)
-      freelocale(__cloc);
-  }
-
-private:
-  locale_t __stored = (locale_t)0;
-  locale_t __cloc = (locale_t)0;
-};
-
-} // namespace
-
-// The following are not POSIX routines.  These are quick-and-dirty hacks
-// to make things pretend to work
-inline _LIBCPP_HIDE_FROM_ABI long long
-strtoll_l(const char *__nptr, char **__endptr, int __base, locale_t locale) {
-  __setAndRestore __newloc(locale);
-  return ::strtoll(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long
-strtol_l(const char *__nptr, char **__endptr, int __base, locale_t locale) {
-  __setAndRestore __newloc(locale);
-  return ::strtol(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI double
-strtod_l(const char *__nptr, char **__endptr, locale_t locale) {
-  __setAndRestore __newloc(locale);
-  return ::strtod(__nptr, __endptr);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI float
-strtof_l(const char *__nptr, char **__endptr, locale_t locale) {
-  __setAndRestore __newloc(locale);
-  return ::strtof(__nptr, __endptr);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double
-strtold_l(const char *__nptr, char **__endptr, locale_t locale) {
-  __setAndRestore __newloc(locale);
-  return ::strtold(__nptr, __endptr);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI unsigned long long
-strtoull_l(const char *__nptr, char **__endptr, int __base, locale_t locale) {
-  __setAndRestore __newloc(locale);
-  return ::strtoull(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI unsigned long
-strtoul_l(const char *__nptr, char **__endptr, int __base, locale_t locale) {
-  __setAndRestore __newloc(locale);
-  return ::strtoul(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI int
-vasprintf(char **strp, const char *fmt, va_list ap) {
-  const size_t buff_size = 256;
-  if ((*strp = (char *)malloc(buff_size)) == NULL) {
-    return -1;
-  }
-
-  va_list ap_copy;
-  // va_copy may not be provided by the C library in C++ 03 mode.
-#if defined(_LIBCPP_CXX03_LANG) && __has_builtin(__builtin_va_copy)
-  __builtin_va_copy(ap_copy, ap);
-#else
-  va_copy(ap_copy, ap);
-#endif
-  int str_size = vsnprintf(*strp, buff_size, fmt,  ap_copy);
-  va_end(ap_copy);
-
-  if ((size_t) str_size >= buff_size) {
-    if ((*strp = (char *)realloc(*strp, str_size + 1)) == NULL) {
-      return -1;
-    }
-    str_size = vsnprintf(*strp, str_size + 1, fmt,  ap);
-  }
-  return str_size;
-}
-
-#ifdef __cplusplus
-}
-#endif
-#endif // _LIBCPP___SUPPORT_IBM_XLOCALE_H
diff --git a/third_party/libcxx/__support/musl/xlocale.h b/third_party/libcxx/__support/musl/xlocale.h
deleted file mode 100644
index fe1dcf61a..000000000
--- a/third_party/libcxx/__support/musl/xlocale.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- C++ -*-
-//===-----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// This adds support for the extended locale functions that are currently
-// missing from the Musl C library.
-//
-// This only works when the specified locale is "C" or "POSIX", but that's
-// about as good as we can do without implementing full xlocale support
-// in Musl.
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___SUPPORT_MUSL_XLOCALE_H
-#define _LIBCPP___SUPPORT_MUSL_XLOCALE_H
-
-#include <cstdlib>
-#include <cwchar>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-inline _LIBCPP_HIDE_FROM_ABI_C long long strtoll_l(const char* __nptr, char** __endptr, int __base, locale_t) {
-  return ::strtoll(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI_C unsigned long long
-strtoull_l(const char* __nptr, char** __endptr, int __base, locale_t) {
-  return ::strtoull(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI_C long long wcstoll_l(const wchar_t* __nptr, wchar_t** __endptr, int __base, locale_t) {
-  return ::wcstoll(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI_C long long wcstoull_l(const wchar_t* __nptr, wchar_t** __endptr, int __base, locale_t) {
-  return ::wcstoull(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI_C long double wcstold_l(const wchar_t* __nptr, wchar_t** __endptr, locale_t) {
-  return ::wcstold(__nptr, __endptr);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // _LIBCPP___SUPPORT_MUSL_XLOCALE_H
diff --git a/third_party/libcxx/__support/newlib/xlocale.h b/third_party/libcxx/__support/newlib/xlocale.h
deleted file mode 100644
index 4e546500f..000000000
--- a/third_party/libcxx/__support/newlib/xlocale.h
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___SUPPORT_NEWLIB_XLOCALE_H
-#define _LIBCPP___SUPPORT_NEWLIB_XLOCALE_H
-
-#if defined(_NEWLIB_VERSION)
-
-#if !defined(__NEWLIB__) || __NEWLIB__ < 2 || \
-    __NEWLIB__ == 2 && __NEWLIB_MINOR__ < 5
-#include <__support/xlocale/__nop_locale_mgmt.h>
-#include <__support/xlocale/__posix_l_fallback.h>
-#include <__support/xlocale/__strtonum_fallback.h>
-#endif
-
-#endif // _NEWLIB_VERSION
-
-#endif
diff --git a/third_party/libcxx/__support/openbsd/xlocale.h b/third_party/libcxx/__support/openbsd/xlocale.h
deleted file mode 100644
index b969ae9d1..000000000
--- a/third_party/libcxx/__support/openbsd/xlocale.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// -*- C++ -*-
-//===-----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___SUPPORT_OPENBSD_XLOCALE_H
-#define _LIBCPP___SUPPORT_OPENBSD_XLOCALE_H
-
-#include <__support/xlocale/__strtonum_fallback.h>
-#include <clocale>
-#include <cstdlib>
-#include <ctype.h>
-#include <cwctype>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-inline _LIBCPP_HIDE_FROM_ABI_C long strtol_l(const char* __nptr, char** __endptr, int __base, locale_t) {
-  return ::strtol(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI_C unsigned long strtoul_l(const char* __nptr, char** __endptr, int __base, locale_t) {
-  return ::strtoul(__nptr, __endptr, __base);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/third_party/libcxx/__support/win32/locale_win32.h b/third_party/libcxx/__support/win32/locale_win32.h
deleted file mode 100644
index b8908049e..000000000
--- a/third_party/libcxx/__support/win32/locale_win32.h
+++ /dev/null
@@ -1,282 +0,0 @@
-// -*- C++ -*-
-//===-----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___SUPPORT_WIN32_LOCALE_WIN32_H
-#define _LIBCPP___SUPPORT_WIN32_LOCALE_WIN32_H
-
-#include <__config>
-#include <cstddef>
-#include <locale.h> // _locale_t
-#include <stdio.h>
-#include <string>
-
-#define _X_ALL LC_ALL
-#define _X_COLLATE LC_COLLATE
-#define _X_CTYPE LC_CTYPE
-#define _X_MONETARY LC_MONETARY
-#define _X_NUMERIC LC_NUMERIC
-#define _X_TIME LC_TIME
-#define _X_MAX LC_MAX
-#define _X_MESSAGES 6
-#define _NCAT (_X_MESSAGES + 1)
-
-#define _CATMASK(n) ((1 << (n)) >> 1)
-#define _M_COLLATE _CATMASK(_X_COLLATE)
-#define _M_CTYPE _CATMASK(_X_CTYPE)
-#define _M_MONETARY _CATMASK(_X_MONETARY)
-#define _M_NUMERIC _CATMASK(_X_NUMERIC)
-#define _M_TIME _CATMASK(_X_TIME)
-#define _M_MESSAGES _CATMASK(_X_MESSAGES)
-#define _M_ALL (_CATMASK(_NCAT) - 1)
-
-#define LC_COLLATE_MASK _M_COLLATE
-#define LC_CTYPE_MASK _M_CTYPE
-#define LC_MONETARY_MASK _M_MONETARY
-#define LC_NUMERIC_MASK _M_NUMERIC
-#define LC_TIME_MASK _M_TIME
-#define LC_MESSAGES_MASK _M_MESSAGES
-#define LC_ALL_MASK (  LC_COLLATE_MASK \
-                     | LC_CTYPE_MASK \
-                     | LC_MESSAGES_MASK \
-                     | LC_MONETARY_MASK \
-                     | LC_NUMERIC_MASK \
-                     | LC_TIME_MASK )
-
-class __lconv_storage {
-public:
-    __lconv_storage(const lconv *__lc_input) {
-        __lc_ = *__lc_input;
-
-        __decimal_point_ = __lc_input->decimal_point;
-        __thousands_sep_ = __lc_input->thousands_sep;
-        __grouping_ = __lc_input->grouping;
-        __int_curr_symbol_ = __lc_input->int_curr_symbol;
-        __currency_symbol_ = __lc_input->currency_symbol;
-        __mon_decimal_point_ = __lc_input->mon_decimal_point;
-        __mon_thousands_sep_ = __lc_input->mon_thousands_sep;
-        __mon_grouping_ = __lc_input->mon_grouping;
-        __positive_sign_ = __lc_input->positive_sign;
-        __negative_sign_ = __lc_input->negative_sign;
-
-        __lc_.decimal_point = const_cast<char *>(__decimal_point_.c_str());
-        __lc_.thousands_sep = const_cast<char *>(__thousands_sep_.c_str());
-        __lc_.grouping = const_cast<char *>(__grouping_.c_str());
-        __lc_.int_curr_symbol = const_cast<char *>(__int_curr_symbol_.c_str());
-        __lc_.currency_symbol = const_cast<char *>(__currency_symbol_.c_str());
-        __lc_.mon_decimal_point = const_cast<char *>(__mon_decimal_point_.c_str());
-        __lc_.mon_thousands_sep = const_cast<char *>(__mon_thousands_sep_.c_str());
-        __lc_.mon_grouping = const_cast<char *>(__mon_grouping_.c_str());
-        __lc_.positive_sign = const_cast<char *>(__positive_sign_.c_str());
-        __lc_.negative_sign = const_cast<char *>(__negative_sign_.c_str());
-    }
-
-    lconv *__get() {
-        return &__lc_;
-    }
-private:
-    lconv __lc_;
-    std::string __decimal_point_;
-    std::string __thousands_sep_;
-    std::string __grouping_;
-    std::string __int_curr_symbol_;
-    std::string __currency_symbol_;
-    std::string __mon_decimal_point_;
-    std::string __mon_thousands_sep_;
-    std::string __mon_grouping_;
-    std::string __positive_sign_;
-    std::string __negative_sign_;
-};
-
-class locale_t {
-public:
-    locale_t()
-        : __locale_(nullptr), __locale_str_(nullptr), __lc_(nullptr) {}
-    locale_t(std::nullptr_t)
-        : __locale_(nullptr), __locale_str_(nullptr), __lc_(nullptr) {}
-    locale_t(_locale_t __xlocale, const char* __xlocale_str)
-        : __locale_(__xlocale), __locale_str_(__xlocale_str), __lc_(nullptr) {}
-    locale_t(const locale_t &__l)
-        : __locale_(__l.__locale_), __locale_str_(__l.__locale_str_), __lc_(nullptr) {}
-
-    ~locale_t() {
-        delete __lc_;
-    }
-
-    locale_t &operator =(const locale_t &__l) {
-        __locale_ = __l.__locale_;
-        __locale_str_ = __l.__locale_str_;
-        // __lc_ not copied
-        return *this;
-    }
-
-    friend bool operator==(const locale_t& __left, const locale_t& __right) {
-        return __left.__locale_ == __right.__locale_;
-    }
-
-    friend bool operator==(const locale_t& __left, int __right) {
-        return __left.__locale_ == nullptr && __right == 0;
-    }
-
-    friend bool operator==(const locale_t& __left, long long __right) {
-        return __left.__locale_ == nullptr && __right == 0;
-    }
-
-    friend bool operator==(const locale_t& __left, std::nullptr_t) {
-        return __left.__locale_ == nullptr;
-    }
-
-    friend bool operator==(int __left, const locale_t& __right) {
-        return __left == 0 && nullptr == __right.__locale_;
-    }
-
-    friend bool operator==(std::nullptr_t, const locale_t& __right) {
-        return nullptr == __right.__locale_;
-    }
-
-    friend bool operator!=(const locale_t& __left, const locale_t& __right) {
-        return !(__left == __right);
-    }
-
-    friend bool operator!=(const locale_t& __left, int __right) {
-        return !(__left == __right);
-    }
-
-    friend bool operator!=(const locale_t& __left, long long __right) {
-        return !(__left == __right);
-    }
-
-    friend bool operator!=(const locale_t& __left, std::nullptr_t __right) {
-        return !(__left == __right);
-    }
-
-    friend bool operator!=(int __left, const locale_t& __right) {
-        return !(__left == __right);
-    }
-
-    friend bool operator!=(std::nullptr_t __left, const locale_t& __right) {
-        return !(__left == __right);
-    }
-
-    operator bool() const {
-        return __locale_ != nullptr;
-    }
-
-    const char* __get_locale() const { return __locale_str_; }
-
-    operator _locale_t() const {
-        return __locale_;
-    }
-
-    lconv *__store_lconv(const lconv *__input_lc) {
-        delete __lc_;
-        __lc_ = new __lconv_storage(__input_lc);
-        return __lc_->__get();
-    }
-private:
-    _locale_t __locale_;
-    const char* __locale_str_;
-    __lconv_storage *__lc_ = nullptr;
-};
-
-// Locale management functions
-#define freelocale _free_locale
-// FIXME: base currently unused. Needs manual work to construct the new locale
-locale_t newlocale( int __mask, const char * __locale, locale_t __base );
-// uselocale can't be implemented on Windows because Windows allows partial modification
-// of thread-local locale and so _get_current_locale() returns a copy while uselocale does
-// not create any copies.
-// We can still implement raii even without uselocale though.
-
-
-lconv *localeconv_l( locale_t & __loc );
-size_t mbrlen_l( const char *__restrict __s, size_t __n,
-                 mbstate_t *__restrict __ps, locale_t __loc);
-size_t mbsrtowcs_l( wchar_t *__restrict __dst, const char **__restrict __src,
-                    size_t __len, mbstate_t *__restrict __ps, locale_t __loc );
-size_t wcrtomb_l( char *__restrict __s, wchar_t __wc, mbstate_t *__restrict __ps,
-                  locale_t __loc);
-size_t mbrtowc_l( wchar_t *__restrict __pwc, const char *__restrict __s,
-                  size_t __n, mbstate_t *__restrict __ps, locale_t __loc);
-size_t mbsnrtowcs_l( wchar_t *__restrict __dst, const char **__restrict __src,
-                     size_t __nms, size_t __len, mbstate_t *__restrict __ps, locale_t __loc);
-size_t wcsnrtombs_l( char *__restrict __dst, const wchar_t **__restrict __src,
-                     size_t __nwc, size_t __len, mbstate_t *__restrict __ps, locale_t __loc);
-wint_t btowc_l( int __c, locale_t __loc );
-int wctob_l( wint_t __c, locale_t __loc );
-
-decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l );
-
-// the *_l functions are prefixed on Windows, only available for msvcr80+, VS2005+
-#define mbtowc_l _mbtowc_l
-#define strtoll_l _strtoi64_l
-#define strtoull_l _strtoui64_l
-#define strtod_l _strtod_l
-#if defined(_LIBCPP_MSVCRT)
-#define strtof_l _strtof_l
-#define strtold_l _strtold_l
-#else
-_LIBCPP_FUNC_VIS float strtof_l(const char*, char**, locale_t);
-_LIBCPP_FUNC_VIS long double strtold_l(const char*, char**, locale_t);
-#endif
-inline _LIBCPP_HIDE_FROM_ABI int
-islower_l(int __c, _locale_t __loc)
-{
- return _islower_l((int)__c, __loc);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI int
-isupper_l(int __c, _locale_t __loc)
-{
- return _isupper_l((int)__c, __loc);
-}
-
-#define isdigit_l _isdigit_l
-#define isxdigit_l _isxdigit_l
-#define strcoll_l _strcoll_l
-#define strxfrm_l _strxfrm_l
-#define wcscoll_l _wcscoll_l
-#define wcsxfrm_l _wcsxfrm_l
-#define toupper_l _toupper_l
-#define tolower_l _tolower_l
-#define iswspace_l _iswspace_l
-#define iswprint_l _iswprint_l
-#define iswcntrl_l _iswcntrl_l
-#define iswupper_l _iswupper_l
-#define iswlower_l _iswlower_l
-#define iswalpha_l _iswalpha_l
-#define iswdigit_l _iswdigit_l
-#define iswpunct_l _iswpunct_l
-#define iswxdigit_l _iswxdigit_l
-#define towupper_l _towupper_l
-#define towlower_l _towlower_l
-#if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0800
-_LIBCPP_FUNC_VIS size_t strftime_l(char *ret, size_t n, const char *format,
-                                   const struct tm *tm, locale_t loc);
-#else
-#define strftime_l _strftime_l
-#endif
-#define sscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
-#define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ )
-#define vsprintf_l( __s, __l, __f, ... ) _vsprintf_l( __s, __f, __l, __VA_ARGS__ )
-#define vsnprintf_l( __s, __n, __l, __f, ... ) _vsnprintf_l( __s, __n, __f, __l, __VA_ARGS__ )
-_LIBCPP_FUNC_VIS int snprintf_l(char *__ret, size_t __n, locale_t __loc, const char *__format, ...);
-_LIBCPP_FUNC_VIS int asprintf_l( char **__ret, locale_t __loc, const char *__format, ... );
-_LIBCPP_FUNC_VIS int vasprintf_l( char **__ret, locale_t __loc, const char *__format, va_list __ap );
-
-// not-so-pressing FIXME: use locale to determine blank characters
-inline int isblank_l( int __c, locale_t /*loc*/ )
-{
-    return ( __c == ' ' || __c == '\t' );
-}
-inline int iswblank_l( wint_t __c, locale_t /*loc*/ )
-{
-    return ( __c == L' ' || __c == L'\t' );
-}
-
-#endif // _LIBCPP___SUPPORT_WIN32_LOCALE_WIN32_H
diff --git a/third_party/libcxx/__support/xlocale/__nop_locale_mgmt.h b/third_party/libcxx/__support/xlocale/__nop_locale_mgmt.h
index 4b3caa895..b9ffcbe16 100644
--- a/third_party/libcxx/__support/xlocale/__nop_locale_mgmt.h
+++ b/third_party/libcxx/__support/xlocale/__nop_locale_mgmt.h
@@ -12,36 +12,24 @@
 
 #include <__config>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 // Patch over lack of extended locale support
-typedef void *locale_t;
+typedef void* locale_t;
 
-inline _LIBCPP_HIDE_FROM_ABI_C locale_t duplocale(locale_t) { return NULL; }
+inline _LIBCPP_HIDE_FROM_ABI locale_t duplocale(locale_t) { return NULL; }
 
-inline _LIBCPP_HIDE_FROM_ABI_C void freelocale(locale_t) {}
+inline _LIBCPP_HIDE_FROM_ABI void freelocale(locale_t) {}
 
-inline _LIBCPP_HIDE_FROM_ABI_C locale_t newlocale(int, const char*, locale_t) { return NULL; }
+inline _LIBCPP_HIDE_FROM_ABI locale_t newlocale(int, const char*, locale_t) { return NULL; }
 
-inline _LIBCPP_HIDE_FROM_ABI_C locale_t uselocale(locale_t) { return NULL; }
+inline _LIBCPP_HIDE_FROM_ABI locale_t uselocale(locale_t) { return NULL; }
 
-#define LC_COLLATE_MASK  (1 << LC_COLLATE)
-#define LC_CTYPE_MASK    (1 << LC_CTYPE)
+#define LC_COLLATE_MASK (1 << LC_COLLATE)
+#define LC_CTYPE_MASK (1 << LC_CTYPE)
 #define LC_MESSAGES_MASK (1 << LC_MESSAGES)
 #define LC_MONETARY_MASK (1 << LC_MONETARY)
-#define LC_NUMERIC_MASK  (1 << LC_NUMERIC)
-#define LC_TIME_MASK     (1 << LC_TIME)
-#define LC_ALL_MASK (LC_COLLATE_MASK|\
-                     LC_CTYPE_MASK|\
-                     LC_MONETARY_MASK|\
-                     LC_NUMERIC_MASK|\
-                     LC_TIME_MASK|\
-                     LC_MESSAGES_MASK)
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
+#define LC_NUMERIC_MASK (1 << LC_NUMERIC)
+#define LC_TIME_MASK (1 << LC_TIME)
+#define LC_ALL_MASK                                                                                                    \
+  (LC_COLLATE_MASK | LC_CTYPE_MASK | LC_MONETARY_MASK | LC_NUMERIC_MASK | LC_TIME_MASK | LC_MESSAGES_MASK)
 
 #endif // _LIBCPP___SUPPORT_XLOCALE_NOP_LOCALE_MGMT_H
diff --git a/third_party/libcxx/__support/xlocale/__posix_l_fallback.h b/third_party/libcxx/__support/xlocale/__posix_l_fallback.h
index 774081a8a..bf6181c78 100644
--- a/third_party/libcxx/__support/xlocale/__posix_l_fallback.h
+++ b/third_party/libcxx/__support/xlocale/__posix_l_fallback.h
@@ -17,99 +17,92 @@
 
 #include <__config>
 #include <ctype.h>
+#include <string.h>
+#include "libc/str/locale.h"
 #include <time.h>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  include <wchar.h>
 #  include <wctype.h>
 #endif
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+inline _LIBCPP_HIDE_FROM_ABI int isalnum_l(int __c, locale_t) { return ::isalnum(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int isalnum_l(int __c, locale_t) { return ::isalnum(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int isalpha_l(int __c, locale_t) { return ::isalpha(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int isalpha_l(int __c, locale_t) { return ::isalpha(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iscntrl_l(int __c, locale_t) { return ::iscntrl(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int isblank_l(int __c, locale_t) { return ::isblank(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int isdigit_l(int __c, locale_t) { return ::isdigit(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iscntrl_l(int __c, locale_t) { return ::iscntrl(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int isgraph_l(int __c, locale_t) { return ::isgraph(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int isdigit_l(int __c, locale_t) { return ::isdigit(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int islower_l(int __c, locale_t) { return ::islower(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int isgraph_l(int __c, locale_t) { return ::isgraph(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int isprint_l(int __c, locale_t) { return ::isprint(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int islower_l(int __c, locale_t) { return ::islower(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int ispunct_l(int __c, locale_t) { return ::ispunct(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int isprint_l(int __c, locale_t) { return ::isprint(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int isspace_l(int __c, locale_t) { return ::isspace(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int ispunct_l(int __c, locale_t) { return ::ispunct(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int isupper_l(int __c, locale_t) { return ::isupper(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int isspace_l(int __c, locale_t) { return ::isspace(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int isxdigit_l(int __c, locale_t) { return ::isxdigit(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int isupper_l(int __c, locale_t) { return ::isupper(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int toupper_l(int __c, locale_t) { return ::toupper(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int isxdigit_l(int __c, locale_t) { return ::isxdigit(__c); }
-
-inline _LIBCPP_HIDE_FROM_ABI_C int toupper_l(int __c, locale_t) { return ::toupper(__c); }
-
-inline _LIBCPP_HIDE_FROM_ABI_C int tolower_l(int __c, locale_t) { return ::tolower(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int tolower_l(int __c, locale_t) { return ::tolower(__c); }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-inline _LIBCPP_HIDE_FROM_ABI_C int iswalnum_l(wint_t __c, locale_t) { return ::iswalnum(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswalnum_l(wint_t __c, locale_t) { return ::iswalnum(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswalpha_l(wint_t __c, locale_t) { return ::iswalpha(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswalpha_l(wint_t __c, locale_t) { return ::iswalpha(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswblank_l(wint_t __c, locale_t) { return ::iswblank(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswblank_l(wint_t __c, locale_t) { return ::iswblank(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswcntrl_l(wint_t __c, locale_t) { return ::iswcntrl(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswcntrl_l(wint_t __c, locale_t) { return ::iswcntrl(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswdigit_l(wint_t __c, locale_t) { return ::iswdigit(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswdigit_l(wint_t __c, locale_t) { return ::iswdigit(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswgraph_l(wint_t __c, locale_t) { return ::iswgraph(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswgraph_l(wint_t __c, locale_t) { return ::iswgraph(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswlower_l(wint_t __c, locale_t) { return ::iswlower(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswlower_l(wint_t __c, locale_t) { return ::iswlower(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswprint_l(wint_t __c, locale_t) { return ::iswprint(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswprint_l(wint_t __c, locale_t) { return ::iswprint(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswpunct_l(wint_t __c, locale_t) { return ::iswpunct(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswpunct_l(wint_t __c, locale_t) { return ::iswpunct(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswspace_l(wint_t __c, locale_t) { return ::iswspace(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswspace_l(wint_t __c, locale_t) { return ::iswspace(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswupper_l(wint_t __c, locale_t) { return ::iswupper(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswupper_l(wint_t __c, locale_t) { return ::iswupper(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C int iswxdigit_l(wint_t __c, locale_t) { return ::iswxdigit(__c); }
+inline _LIBCPP_HIDE_FROM_ABI int iswxdigit_l(wint_t __c, locale_t) { return ::iswxdigit(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C wint_t towupper_l(wint_t __c, locale_t) { return ::towupper(__c); }
+inline _LIBCPP_HIDE_FROM_ABI wint_t towupper_l(wint_t __c, locale_t) { return ::towupper(__c); }
 
-inline _LIBCPP_HIDE_FROM_ABI_C wint_t towlower_l(wint_t __c, locale_t) { return ::towlower(__c); }
+inline _LIBCPP_HIDE_FROM_ABI wint_t towlower_l(wint_t __c, locale_t) { return ::towlower(__c); }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
-inline _LIBCPP_HIDE_FROM_ABI_C int strcoll_l(const char* __s1, const char* __s2, locale_t) {
+inline _LIBCPP_HIDE_FROM_ABI int strcoll_l(const char* __s1, const char* __s2, locale_t) {
   return ::strcoll(__s1, __s2);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI_C size_t strxfrm_l(char* __dest, const char* __src, size_t __n, locale_t) {
+inline _LIBCPP_HIDE_FROM_ABI size_t strxfrm_l(char* __dest, const char* __src, size_t __n, locale_t) {
   return ::strxfrm(__dest, __src, __n);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI_C size_t
+inline _LIBCPP_HIDE_FROM_ABI size_t
 strftime_l(char* __s, size_t __max, const char* __format, const struct tm* __tm, locale_t) {
   return ::strftime(__s, __max, __format, __tm);
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-inline _LIBCPP_HIDE_FROM_ABI_C int wcscoll_l(const wchar_t* __ws1, const wchar_t* __ws2, locale_t) {
+inline _LIBCPP_HIDE_FROM_ABI int wcscoll_l(const wchar_t* __ws1, const wchar_t* __ws2, locale_t) {
   return ::wcscoll(__ws1, __ws2);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI_C size_t wcsxfrm_l(wchar_t* __dest, const wchar_t* __src, size_t __n, locale_t) {
+inline _LIBCPP_HIDE_FROM_ABI size_t wcsxfrm_l(wchar_t* __dest, const wchar_t* __src, size_t __n, locale_t) {
   return ::wcsxfrm(__dest, __src, __n);
 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif // _LIBCPP___SUPPORT_XLOCALE_POSIX_L_FALLBACK_H
diff --git a/third_party/libcxx/__support/xlocale/__strtonum_fallback.h b/third_party/libcxx/__support/xlocale/__strtonum_fallback.h
index ae8e13a75..5701984aa 100644
--- a/third_party/libcxx/__support/xlocale/__strtonum_fallback.h
+++ b/third_party/libcxx/__support/xlocale/__strtonum_fallback.h
@@ -16,54 +16,31 @@
 #define _LIBCPP___SUPPORT_XLOCALE_STRTONUM_FALLBACK_H
 
 #include <__config>
+#include "libc/str/locale.h"
 #include <stdlib.h>
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 #  include <wchar.h>
 #endif
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-inline _LIBCPP_HIDE_FROM_ABI_C float strtof_l(const char* __nptr, char** __endptr, locale_t) {
+inline _LIBCPP_HIDE_FROM_ABI float strtof_l(const char* __nptr, char** __endptr, locale_t) {
   return ::strtof(__nptr, __endptr);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI_C double strtod_l(const char* __nptr, char** __endptr, locale_t) {
+inline _LIBCPP_HIDE_FROM_ABI double strtod_l(const char* __nptr, char** __endptr, locale_t) {
   return ::strtod(__nptr, __endptr);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI_C long double strtold_l(const char* __nptr, char** __endptr, locale_t) {
+inline _LIBCPP_HIDE_FROM_ABI long double strtold_l(const char* __nptr, char** __endptr, locale_t) {
   return ::strtold(__nptr, __endptr);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI_C long long strtoll_l(const char* __nptr, char** __endptr, int __base, locale_t) {
+inline _LIBCPP_HIDE_FROM_ABI long long strtoll_l(const char* __nptr, char** __endptr, int __base, locale_t) {
   return ::strtoll(__nptr, __endptr, __base);
 }
 
-inline _LIBCPP_HIDE_FROM_ABI_C unsigned long long
-strtoull_l(const char* __nptr, char** __endptr, int __base, locale_t) {
+inline _LIBCPP_HIDE_FROM_ABI unsigned long long strtoull_l(const char* __nptr, char** __endptr, int __base, locale_t) {
   return ::strtoull(__nptr, __endptr, __base);
 }
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-inline _LIBCPP_HIDE_FROM_ABI_C long long wcstoll_l(const wchar_t* __nptr, wchar_t** __endptr, int __base, locale_t) {
-  return ::wcstoll(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI_C unsigned long long
-wcstoull_l(const wchar_t* __nptr, wchar_t** __endptr, int __base, locale_t) {
-  return ::wcstoull(__nptr, __endptr, __base);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI_C long double wcstold_l(const wchar_t* __nptr, wchar_t** __endptr, locale_t) {
-  return ::wcstold(__nptr, __endptr);
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-#ifdef __cplusplus
-}
-#endif
-
 #endif // _LIBCPP___SUPPORT_XLOCALE_STRTONUM_FALLBACK_H
diff --git a/third_party/libcxx/__system_error/errc.h b/third_party/libcxx/__system_error/errc.h
index a3c13fe4d..8f6532ec9 100644
--- a/third_party/libcxx/__system_error/errc.h
+++ b/third_party/libcxx/__system_error/errc.h
@@ -58,18 +58,18 @@ enum class errc
     no_child_process,                   // ECHILD
     no_link,                            // ENOLINK
     no_lock_available,                  // ENOLCK
-    no_message_available,               // ENODATA
+    no_message_available,               // ENODATA         // deprecated
     no_message,                         // ENOMSG
     no_protocol_option,                 // ENOPROTOOPT
     no_space_on_device,                 // ENOSPC
-    no_stream_resources,                // ENOSR
+    no_stream_resources,                // ENOSR           // deprecated
     no_such_device_or_address,          // ENXIO
     no_such_device,                     // ENODEV
     no_such_file_or_directory,          // ENOENT
     no_such_process,                    // ESRCH
     not_a_directory,                    // ENOTDIR
     not_a_socket,                       // ENOTSOCK
-    not_a_stream,                       // ENOSTR
+    not_a_stream,                       // ENOSTR          // deprecated
     not_connected,                      // ENOTCONN
     not_enough_memory,                  // ENOMEM
     not_supported,                      // ENOTSUP
@@ -87,7 +87,7 @@ enum class errc
     resource_unavailable_try_again,     // EAGAIN
     result_out_of_range,                // ERANGE
     state_not_recoverable,              // ENOTRECOVERABLE
-    stream_timeout,                     // ETIME
+    stream_timeout,                     // ETIME           // deprecated
     text_file_busy,                     // ETXTBSY
     timed_out,                          // ETIMEDOUT
     too_many_files_open_in_system,      // ENFILE
@@ -107,111 +107,124 @@ enum class errc
 #  pragma GCC system_header
 #endif
 
+// The method of pushing and popping the diagnostics fails for GCC.  GCC does
+// not recognize the pragma's used to generate deprecated diagnostics for
+// macros. So GCC does not need the pushing and popping.
+//
+// TODO Remove this when the deprecated constants are removed.
+//
+// Note based on the post-review comments in
+// https://github.com/llvm/llvm-project/pull/80542 libc++ no longer deprecates
+// the macros. Since C libraries may start to deprecate these POSIX macros the
+// deprecation warning avoidance is kept.
+#if defined(_LIBCPP_COMPILER_CLANG_BASED)
+#  define _LIBCPP_SUPPRESS_DEPRECATED_ERRC_PUSH _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+#  define _LIBCPP_SUPPRESS_DEPRECATED_ERRC_POP _LIBCPP_SUPPRESS_DEPRECATED_POP
+#else
+#  define _LIBCPP_SUPPRESS_DEPRECATED_ERRC_PUSH
+#  define _LIBCPP_SUPPRESS_DEPRECATED_ERRC_POP
+#endif
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Some error codes are not present on all platforms, so we provide equivalents
 // for them:
 
-//enum class errc
-_LIBCPP_DECLARE_STRONG_ENUM(errc) // [jart]
-{
-    address_family_not_supported        ,//= EAFNOSUPPORT,
-    address_in_use                      ,//= EADDRINUSE,
-    address_not_available               ,//= EADDRNOTAVAIL,
-    already_connected                   ,//= EISCONN,
-    argument_list_too_long              ,//= E2BIG,
-    argument_out_of_domain              ,//= EDOM,
-    bad_address                         ,//= EFAULT,
-    bad_file_descriptor                 ,//= EBADF,
-    bad_message                         ,//= EBADMSG,
-    broken_pipe                         ,//= EPIPE,
-    connection_aborted                  ,//= ECONNABORTED,
-    connection_already_in_progress      ,//= EALREADY,
-    connection_refused                  ,//= ECONNREFUSED,
-    connection_reset                    ,//= ECONNRESET,
-    cross_device_link                   ,//= EXDEV,
-    destination_address_required        ,//= EDESTADDRREQ,
-    device_or_resource_busy             ,//= EBUSY,
-    directory_not_empty                 ,//= ENOTEMPTY,
-    executable_format_error             ,//= ENOEXEC,
-    file_exists                         ,//= EEXIST,
-    file_too_large                      ,//= EFBIG,
-    filename_too_long                   ,//= ENAMETOOLONG,
-    function_not_supported              ,//= ENOSYS,
-    host_unreachable                    ,//= EHOSTUNREACH,
-    identifier_removed                  ,//= EIDRM,
-    illegal_byte_sequence               ,//= EILSEQ,
-    inappropriate_io_control_operation  ,//= ENOTTY,
-    interrupted                         ,//= EINTR,
-    invalid_argument                    ,//= EINVAL,
-    invalid_seek                        ,//= ESPIPE,
-    io_error                            ,//= EIO,
-    is_a_directory                      ,//= EISDIR,
-    message_size                        ,//= EMSGSIZE,
-    network_down                        ,//= ENETDOWN,
-    network_reset                       ,//= ENETRESET,
-    network_unreachable                 ,//= ENETUNREACH,
-    no_buffer_space                     ,//= ENOBUFS,
-    no_child_process                    ,//= ECHILD,
-    no_link                             ,//= ENOLINK,
-    no_lock_available                   ,//= ENOLCK,
-#ifdef ENODATA
-    no_message_available                ,//= ENODATA,
-#else
-    no_message_available                ,//= ENOMSG,
-#endif
-    no_message                          ,//= ENOMSG,
-    no_protocol_option                  ,//= ENOPROTOOPT,
-    no_space_on_device                  ,//= ENOSPC,
-#ifdef ENOSR
-    no_stream_resources                 ,//= ENOSR,
-#else
-    no_stream_resources                 ,//= ENOMEM,
-#endif
-    no_such_device_or_address           ,//= ENXIO,
-    no_such_device                      ,//= ENODEV,
-    no_such_file_or_directory           ,//= ENOENT,
-    no_such_process                     ,//= ESRCH,
-    not_a_directory                     ,//= ENOTDIR,
-    not_a_socket                        ,//= ENOTSOCK,
-#ifdef ENOSTR
-    not_a_stream                        ,//= ENOSTR,
-#else
-    not_a_stream                        ,//= EINVAL,
-#endif
-    not_connected                       ,//= ENOTCONN,
-    not_enough_memory                   ,//= ENOMEM,
-    not_supported                       ,//= ENOTSUP,
-    operation_canceled                  ,//= ECANCELED,
-    operation_in_progress               ,//= EINPROGRESS,
-    operation_not_permitted             ,//= EPERM,
-    operation_not_supported             ,//= EOPNOTSUPP,
-    operation_would_block               ,//= EWOULDBLOCK,
-    owner_dead                          ,//= EOWNERDEAD,
-    permission_denied                   ,//= EACCES,
-    protocol_error                      ,//= EPROTO,
-    protocol_not_supported              ,//= EPROTONOSUPPORT,
-    read_only_file_system               ,//= EROFS,
-    resource_deadlock_would_occur       ,//= EDEADLK,
-    resource_unavailable_try_again      ,//= EAGAIN,
-    result_out_of_range                 ,//= ERANGE,
-    state_not_recoverable               ,//= ENOTRECOVERABLE,
-#ifdef ETIME
-    stream_timeout                      ,//= ETIME,
-#else
-    stream_timeout                      ,//= ETIMEDOUT,
-#endif
-    text_file_busy                      ,//= ETXTBSY,
-    timed_out                           ,//= ETIMEDOUT,
-    too_many_files_open_in_system       ,//= ENFILE,
-    too_many_files_open                 ,//= EMFILE,
-    too_many_links                      ,//= EMLINK,
-    too_many_symbolic_link_levels       ,//= ELOOP,
-    value_too_large                     ,//= EOVERFLOW,
-    wrong_protocol_type                 ,//= EPROTOTYPE
-};
+// enum class errc
+//
+// LWG3869 deprecates the UNIX STREAMS macros and enum values.
+// This makes the code clumbersome:
+// - the enum value is deprecated and should show a diagnostic,
+// - the macro is deprecated and should _not_ show a diagnostic in this
+//   context, and
+// - the macro is not always available.
+// This leads to the odd pushing and popping of the deprecated
+// diagnostic.
+_LIBCPP_DECLARE_STRONG_ENUM(errc){
+  success = 0,
+    address_family_not_supported = 65536, //       = EAFNOSUPPORT,
+          address_in_use, //                     = EADDRINUSE,
+          address_not_available, //              = EADDRNOTAVAIL,
+          already_connected, //                  = EISCONN,
+          argument_list_too_long, //             = E2BIG,
+          argument_out_of_domain, //             = EDOM,
+          bad_address, //                        = EFAULT,
+          bad_file_descriptor, //                = EBADF,
+          bad_message, //                        = EBADMSG,
+          broken_pipe, //                        = EPIPE,
+          connection_aborted, //                 = ECONNABORTED,
+          connection_already_in_progress, //     = EALREADY,
+          connection_refused, //                 = ECONNREFUSED,
+          connection_reset, //                   = ECONNRESET,
+          cross_device_link, //                  = EXDEV,
+          destination_address_required, //       = EDESTADDRREQ,
+          device_or_resource_busy, //            = EBUSY,
+          directory_not_empty, //                = ENOTEMPTY,
+          executable_format_error, //            = ENOEXEC,
+          file_exists, //                        = EEXIST,
+          file_too_large, //                     = EFBIG,
+          filename_too_long, //                  = ENAMETOOLONG,
+          function_not_supported, //             = ENOSYS,
+          host_unreachable, //                   = EHOSTUNREACH,
+          identifier_removed, //                 = EIDRM,
+          illegal_byte_sequence, //              = EILSEQ,
+          inappropriate_io_control_operation, // = ENOTTY,
+          interrupted, //                        = EINTR,
+          invalid_argument, //                   = EINVAL,
+          invalid_seek, //                       = ESPIPE,
+          io_error, //                           = EIO,
+          is_a_directory, //                     = EISDIR,
+          message_size, //                       = EMSGSIZE,
+          network_down, //                       = ENETDOWN,
+          network_reset, //                      = ENETRESET,
+          network_unreachable, //                = ENETUNREACH,
+          no_buffer_space, //                    = ENOBUFS,
+          no_child_process, //                   = ECHILD,
+          no_link, //                            = ENOLINK,
+          no_lock_available, //                  = ENOLCK,
+        no_message_available,
+          no_message, //         = ENOMSG,
+          no_protocol_option, // = ENOPROTOOPT,
+          no_space_on_device, // = ENOSPC,
+        no_stream_resources,
+          no_such_device_or_address, // = ENXIO,
+          no_such_device, //            = ENODEV,
+          no_such_file_or_directory, // = ENOENT,
+          no_such_process, //           = ESRCH,
+          not_a_directory, //           = ENOTDIR,
+          not_a_socket, //              = ENOTSOCK,
+        not_a_stream,
+          not_connected, //                  = ENOTCONN,
+          not_enough_memory, //              = ENOMEM,
+          not_supported, //                  = ENOTSUP,
+          operation_canceled, //             = ECANCELED,
+          operation_in_progress, //          = EINPROGRESS,
+          operation_not_permitted, //        = EPERM,
+          operation_not_supported, //        = EOPNOTSUPP,
+          operation_would_block, //          = EWOULDBLOCK,
+          owner_dead, //                     = EOWNERDEAD,
+          permission_denied, //              = EACCES,
+          protocol_error, //                 = EPROTO,
+          protocol_not_supported, //         = EPROTONOSUPPORT,
+          read_only_file_system, //          = EROFS,
+          resource_deadlock_would_occur, //  = EDEADLK,
+          resource_unavailable_try_again, // = EAGAIN,
+          result_out_of_range, //            = ERANGE,
+        state_not_recoverable, //          = ENOTRECOVERABLE,
+        stream_timeout,
+          text_file_busy, //                = ETXTBSY,
+          timed_out, //                     = ETIMEDOUT,
+          too_many_files_open_in_system, // = ENFILE,
+          too_many_files_open, //           = EMFILE,
+          too_many_links, //                = EMLINK,
+          too_many_symbolic_link_levels, // = ELOOP,
+          value_too_large, //               = EOVERFLOW,
+    wrong_protocol_type};
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
 
+errc __err_to_errc(int) noexcept;
+int __errc_to_err(errc) noexcept;
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ERRC
diff --git a/third_party/libcxx/__system_error/error_category.h b/third_party/libcxx/__system_error/error_category.h
index 47cc9e230..bfe7bc24a 100644
--- a/third_party/libcxx/__system_error/error_category.h
+++ b/third_party/libcxx/__system_error/error_category.h
@@ -20,12 +20,12 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TYPE_VIS error_condition;
-class _LIBCPP_TYPE_VIS error_code;
+class _LIBCPP_EXPORTED_FROM_ABI error_condition;
+class _LIBCPP_EXPORTED_FROM_ABI error_code;
 
 class _LIBCPP_HIDDEN __do_message;
 
-class _LIBCPP_TYPE_VIS error_category {
+class _LIBCPP_EXPORTED_FROM_ABI error_category {
 public:
   virtual ~error_category() _NOEXCEPT;
 
@@ -67,8 +67,8 @@ public:
   string message(int __ev) const override;
 };
 
-_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
-_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
+__attribute__((__const__)) _LIBCPP_EXPORTED_FROM_ABI const error_category& generic_category() _NOEXCEPT;
+__attribute__((__const__)) _LIBCPP_EXPORTED_FROM_ABI const error_category& system_category() _NOEXCEPT;
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__system_error/error_code.h b/third_party/libcxx/__system_error/error_code.h
index 78abe5ac4..4f6e14945 100644
--- a/third_party/libcxx/__system_error/error_code.h
+++ b/third_party/libcxx/__system_error/error_code.h
@@ -40,18 +40,18 @@ namespace __adl_only {
 void make_error_code() = delete;
 } // namespace __adl_only
 
-class _LIBCPP_TYPE_VIS error_code {
+class _LIBCPP_EXPORTED_FROM_ABI error_code {
   int __val_;
   const error_category* __cat_;
 
 public:
   _LIBCPP_HIDE_FROM_ABI error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
+  _LIBCPP_HIDE_FROM_ABI error_code(errc __val) _NOEXCEPT : __val_(__errc_to_err(__val)), __cat_(&system_category()) {}
+  _LIBCPP_HIDE_FROM_ABI error_code(int __val, const error_category& __cat) _NOEXCEPT : __val_(__errc_to_err((errc)__val)), __cat_(&__cat) {}
+  _LIBCPP_HIDE_FROM_ABI error_code(errc __val, const error_category& __cat) _NOEXCEPT : __val_(__errc_to_err(__val)), __cat_(&__cat) {}
 
-  _LIBCPP_HIDE_FROM_ABI error_code(int __val, const error_category& __cat) _NOEXCEPT : __val_(__val), __cat_(&__cat) {}
-
-  template <class _Ep>
-  _LIBCPP_HIDE_FROM_ABI
-  error_code(_Ep __e, typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr) _NOEXCEPT {
+  template <class _Ep, __enable_if_t<is_error_code_enum<_Ep>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI error_code(_Ep __e) _NOEXCEPT {
     using __adl_only::make_error_code;
     *this = make_error_code(__e);
   }
@@ -61,9 +61,8 @@ public:
     __cat_ = &__cat;
   }
 
-  template <class _Ep>
-  _LIBCPP_HIDE_FROM_ABI typename enable_if< is_error_code_enum<_Ep>::value, error_code& >::type
-  operator=(_Ep __e) _NOEXCEPT {
+  template <class _Ep, __enable_if_t<is_error_code_enum<_Ep>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI error_code& operator=(_Ep __e) _NOEXCEPT {
     using __adl_only::make_error_code;
     *this = make_error_code(__e);
     return *this;
@@ -74,7 +73,7 @@ public:
     __cat_ = &system_category();
   }
 
-  _LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __val_; }
+  _LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __errc_to_err((errc)__val_); }
 
   _LIBCPP_HIDE_FROM_ABI const error_category& category() const _NOEXCEPT { return *__cat_; }
 
@@ -88,13 +87,17 @@ public:
 };
 
 inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(errc __e) _NOEXCEPT {
-  return error_code(static_cast<int>(__e), generic_category());
+  return error_code(__e, generic_category());
 }
 
 inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_code& __x, const error_code& __y) _NOEXCEPT {
   return __x.category() == __y.category() && __x.value() == __y.value();
 }
 
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_code& __x, errc __y) _NOEXCEPT {
+  return __x == error_code(__y, __x.category());
+}
+
 inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT {
   return __x.category().equivalent(__x.value(), __y) || __y.category().equivalent(__x, __y.value());
 }
diff --git a/third_party/libcxx/__system_error/error_condition.h b/third_party/libcxx/__system_error/error_condition.h
index e3181d135..9003bc919 100644
--- a/third_party/libcxx/__system_error/error_condition.h
+++ b/third_party/libcxx/__system_error/error_condition.h
@@ -12,6 +12,7 @@
 
 #include <__compare/ordering.h>
 #include <__config>
+#include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__system_error/errc.h>
 #include <__system_error/error_category.h>
@@ -46,20 +47,23 @@ namespace __adl_only {
 void make_error_condition() = delete;
 } // namespace __adl_only
 
-class _LIBCPP_TYPE_VIS error_condition {
+class _LIBCPP_EXPORTED_FROM_ABI error_condition {
   int __val_;
   const error_category* __cat_;
 
 public:
   _LIBCPP_HIDE_FROM_ABI error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
 
-  _LIBCPP_HIDE_FROM_ABI error_condition(int __val, const error_category& __cat) _NOEXCEPT
-      : __val_(__val),
+  _LIBCPP_HIDE_FROM_ABI error_condition(errc __val, const error_category& __cat) _NOEXCEPT
+      : __val_(__errc_to_err(__val)),
         __cat_(&__cat) {}
 
-  template <class _Ep>
-  _LIBCPP_HIDE_FROM_ABI
-  error_condition(_Ep __e, typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI error_condition(int __val, const error_category& __cat) _NOEXCEPT
+      : __val_(__errc_to_err((errc)__val)),
+        __cat_(&__cat) {}
+
+  template <class _Ep, __enable_if_t<is_error_condition_enum<_Ep>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI error_condition(_Ep __e) _NOEXCEPT {
     using __adl_only::make_error_condition;
     *this = make_error_condition(__e);
   }
@@ -69,9 +73,8 @@ public:
     __cat_ = &__cat;
   }
 
-  template <class _Ep>
-  _LIBCPP_HIDE_FROM_ABI typename enable_if< is_error_condition_enum<_Ep>::value, error_condition& >::type
-  operator=(_Ep __e) _NOEXCEPT {
+  template <class _Ep, __enable_if_t<is_error_condition_enum<_Ep>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI error_condition& operator=(_Ep __e) _NOEXCEPT {
     using __adl_only::make_error_condition;
     *this = make_error_condition(__e);
     return *this;
@@ -82,7 +85,7 @@ public:
     __cat_ = &generic_category();
   }
 
-  _LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __val_; }
+  _LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __errc_to_err((errc)__val_); }
 
   _LIBCPP_HIDE_FROM_ABI const error_category& category() const _NOEXCEPT { return *__cat_; }
   string message() const;
@@ -91,7 +94,7 @@ public:
 };
 
 inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(errc __e) _NOEXCEPT {
-  return error_condition(static_cast<int>(__e), generic_category());
+  return error_condition(__e, generic_category());
 }
 
 inline _LIBCPP_HIDE_FROM_ABI bool operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT {
diff --git a/third_party/libcxx/__system_error/system_error.h b/third_party/libcxx/__system_error/system_error.h
index 13c5c24a8..ff41ea9a7 100644
--- a/third_party/libcxx/__system_error/system_error.h
+++ b/third_party/libcxx/__system_error/system_error.h
@@ -11,8 +11,10 @@
 #define _LIBCPP___SYSTEM_ERROR_SYSTEM_ERROR_H
 
 #include <__config>
+#include <__system_error/errc.h>
 #include <__system_error/error_category.h>
 #include <__system_error/error_code.h>
+#include <__verbose_abort>
 #include <stdexcept>
 #include <string>
 
@@ -22,7 +24,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TYPE_VIS system_error : public runtime_error {
+class _LIBCPP_EXPORTED_FROM_ABI system_error : public runtime_error {
   error_code __ec_;
 
 public:
@@ -36,12 +38,17 @@ public:
   ~system_error() _NOEXCEPT override;
 
   _LIBCPP_HIDE_FROM_ABI const error_code& code() const _NOEXCEPT { return __ec_; }
-
-private:
-  static string __init(const error_code&, string);
 };
 
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_system_error(int __ev, const char* __what_arg);
+_LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_system_error(int __ev, const char* __what_arg);
+_LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void __throw_system_error(error_code __ec, const char* __what_arg) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw system_error(__ec, __what_arg);
+#else
+  _LIBCPP_VERBOSE_ABORT(
+      "system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", __ec.value(), __what_arg);
+#endif
+}
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__thread/formatter.h b/third_party/libcxx/__thread/formatter.h
new file mode 100644
index 000000000..9b54036dc
--- /dev/null
+++ b/third_party/libcxx/__thread/formatter.h
@@ -0,0 +1,80 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___THREAD_FORMATTER_H
+#define _LIBCPP___THREAD_FORMATTER_H
+
+#include <__concepts/arithmetic.h>
+#include <__config>
+#include <__format/concepts.h>
+#include <__format/format_parse_context.h>
+#include <__format/formatter.h>
+#include <__format/formatter_integral.h>
+#include <__format/parser_std_format_spec.h>
+#include <__thread/id.h>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_pointer.h>
+#include <__type_traits/is_same.h>
+#include <cstdint>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#  ifndef _LIBCPP_HAS_NO_THREADS
+
+template <__fmt_char_type _CharT>
+struct _LIBCPP_TEMPLATE_VIS formatter<__thread_id, _CharT> {
+public:
+  template <class _ParseContext>
+  _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
+    return __parser_.__parse(__ctx, __format_spec::__fields_fill_align_width);
+  }
+
+  template <class _FormatContext>
+  _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(__thread_id __id, _FormatContext& __ctx) const {
+    // In __thread/support/pthread.h, __libcpp_thread_id is either a
+    // unsigned long long or a pthread_t.
+    //
+    // The type of pthread_t is left unspecified in POSIX so it can be any
+    // type. The most logical types are an integral or pointer.
+    // On Linux systems pthread_t is an unsigned long long.
+    // On Apple systems pthread_t is a pointer type.
+    //
+    // Note the output should match what the stream operator does. Since
+    // the ostream operator has been shipped years before this formatter
+    // was added to the Standard, this formatter does what the stream
+    // operator does. This may require platform specific changes.
+
+    using _Tp = decltype(__get_underlying_id(__id));
+    using _Cp = conditional_t<integral<_Tp>, _Tp, conditional_t<is_pointer_v<_Tp>, uintptr_t, void>>;
+    static_assert(!is_same_v<_Cp, void>, "unsupported thread::id type, please file a bug report");
+
+    __format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
+    if constexpr (is_pointer_v<_Tp>) {
+      __specs.__std_.__alternate_form_ = true;
+      __specs.__std_.__type_           = __format_spec::__type::__hexadecimal_lower_case;
+    }
+    return __formatter::__format_integer(reinterpret_cast<_Cp>(__get_underlying_id(__id)), __ctx, __specs);
+  }
+
+  __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__right};
+};
+
+#  endif // !_LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___THREAD_FORMATTER_H
diff --git a/third_party/libcxx/__thread/id.h b/third_party/libcxx/__thread/id.h
new file mode 100644
index 000000000..6db0ccbfe
--- /dev/null
+++ b/third_party/libcxx/__thread/id.h
@@ -0,0 +1,121 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___THREAD_ID_H
+#define _LIBCPP___THREAD_ID_H
+
+#include <__compare/ordering.h>
+#include <__config>
+#include <__fwd/functional.h>
+#include <__fwd/ostream.h>
+#include <__thread/support.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+class _LIBCPP_EXPORTED_FROM_ABI __thread_id;
+
+namespace this_thread {
+
+_LIBCPP_HIDE_FROM_ABI __thread_id get_id() _NOEXCEPT;
+
+} // namespace this_thread
+
+template <>
+struct hash<__thread_id>;
+
+class _LIBCPP_TEMPLATE_VIS __thread_id {
+  // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
+  // NULL is the no-thread value on Darwin.  Someone needs to check
+  // on other platforms.  We assume 0 works everywhere for now.
+  __libcpp_thread_id __id_;
+
+  static _LIBCPP_HIDE_FROM_ABI bool
+  __lt_impl(__thread_id __x, __thread_id __y) _NOEXCEPT { // id==0 is always less than any other thread_id
+    if (__x.__id_ == 0)
+      return __y.__id_ != 0;
+    if (__y.__id_ == 0)
+      return false;
+    return __libcpp_thread_id_less(__x.__id_, __y.__id_);
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __thread_id() _NOEXCEPT : __id_(0) {}
+
+  _LIBCPP_HIDE_FROM_ABI void __reset() { __id_ = 0; }
+
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT;
+#  if _LIBCPP_STD_VER <= 17
+  friend _LIBCPP_HIDE_FROM_ABI bool operator<(__thread_id __x, __thread_id __y) _NOEXCEPT;
+#  else  // _LIBCPP_STD_VER <= 17
+  friend _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(__thread_id __x, __thread_id __y) noexcept;
+#  endif // _LIBCPP_STD_VER <= 17
+
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id);
+
+private:
+  _LIBCPP_HIDE_FROM_ABI __thread_id(__libcpp_thread_id __id) : __id_(__id) {}
+
+  _LIBCPP_HIDE_FROM_ABI friend __libcpp_thread_id __get_underlying_id(const __thread_id __id) { return __id.__id_; }
+
+  friend __thread_id this_thread::get_id() _NOEXCEPT;
+  friend class _LIBCPP_EXPORTED_FROM_ABI thread;
+  friend struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>;
+};
+
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT {
+  // Don't pass id==0 to underlying routines
+  if (__x.__id_ == 0)
+    return __y.__id_ == 0;
+  if (__y.__id_ == 0)
+    return false;
+  return __libcpp_thread_id_equal(__x.__id_, __y.__id_);
+}
+
+#  if _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__x == __y); }
+
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(__thread_id __x, __thread_id __y) _NOEXCEPT {
+  return __thread_id::__lt_impl(__x.__id_, __y.__id_);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__y < __x); }
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(__thread_id __x, __thread_id __y) _NOEXCEPT { return __y < __x; }
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__x < __y); }
+
+#  else // _LIBCPP_STD_VER <= 17
+
+inline _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(__thread_id __x, __thread_id __y) noexcept {
+  if (__x == __y)
+    return strong_ordering::equal;
+  if (__thread_id::__lt_impl(__x, __y))
+    return strong_ordering::less;
+  return strong_ordering::greater;
+}
+
+#  endif // _LIBCPP_STD_VER <= 17
+
+namespace this_thread {
+
+inline _LIBCPP_HIDE_FROM_ABI __thread_id get_id() _NOEXCEPT { return __libcpp_thread_get_current_id(); }
+
+} // namespace this_thread
+
+#endif // !_LIBCPP_HAS_NO_THREADS
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___THREAD_ID_H
diff --git a/third_party/libcxx/__thread/jthread.h b/third_party/libcxx/__thread/jthread.h
new file mode 100644
index 000000000..b3d5c25fb
--- /dev/null
+++ b/third_party/libcxx/__thread/jthread.h
@@ -0,0 +1,134 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___THREAD_JTHREAD_H
+#define _LIBCPP___THREAD_JTHREAD_H
+
+#include <__config>
+#include <__functional/invoke.h>
+#include <__stop_token/stop_source.h>
+#include <__stop_token/stop_token.h>
+#include <__thread/support.h>
+#include <__thread/thread.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_AVAILABILITY_SYNC jthread {
+public:
+  // types
+  using id                 = thread::id;
+  using native_handle_type = thread::native_handle_type;
+
+  // [thread.jthread.cons], constructors, move, and assignment
+  _LIBCPP_HIDE_FROM_ABI jthread() noexcept : __stop_source_(std::nostopstate) {}
+
+  template <class _Fun, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI explicit jthread(_Fun&& __fun, _Args&&... __args)
+    requires(!std::is_same_v<remove_cvref_t<_Fun>, jthread>)
+      : __stop_source_(),
+        __thread_(__init_thread(__stop_source_, std::forward<_Fun>(__fun), std::forward<_Args>(__args)...)) {
+    static_assert(is_constructible_v<decay_t<_Fun>, _Fun>);
+    static_assert((is_constructible_v<decay_t<_Args>, _Args> && ...));
+    static_assert(is_invocable_v<decay_t<_Fun>, decay_t<_Args>...> ||
+                  is_invocable_v<decay_t<_Fun>, stop_token, decay_t<_Args>...>);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI ~jthread() {
+    if (joinable()) {
+      request_stop();
+      join();
+    }
+  }
+
+  jthread(const jthread&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI jthread(jthread&&) noexcept = default;
+
+  jthread& operator=(const jthread&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI jthread& operator=(jthread&& __other) noexcept {
+    if (this != &__other) {
+      if (joinable()) {
+        request_stop();
+        join();
+      }
+      __stop_source_ = std::move(__other.__stop_source_);
+      __thread_      = std::move(__other.__thread_);
+    }
+
+    return *this;
+  }
+
+  // [thread.jthread.mem], members
+  _LIBCPP_HIDE_FROM_ABI void swap(jthread& __other) noexcept {
+    std::swap(__stop_source_, __other.__stop_source_);
+    std::swap(__thread_, __other.__thread_);
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool joinable() const noexcept { return get_id() != id(); }
+
+  _LIBCPP_HIDE_FROM_ABI void join() { __thread_.join(); }
+
+  _LIBCPP_HIDE_FROM_ABI void detach() { __thread_.detach(); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI id get_id() const noexcept { return __thread_.get_id(); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return __thread_.native_handle(); }
+
+  // [thread.jthread.stop], stop token handling
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI stop_source get_stop_source() noexcept { return __stop_source_; }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI stop_token get_stop_token() const noexcept { return __stop_source_.get_token(); }
+
+  _LIBCPP_HIDE_FROM_ABI bool request_stop() noexcept { return __stop_source_.request_stop(); }
+
+  // [thread.jthread.special], specialized algorithms
+  _LIBCPP_HIDE_FROM_ABI friend void swap(jthread& __lhs, jthread& __rhs) noexcept { __lhs.swap(__rhs); }
+
+  // [thread.jthread.static], static members
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static unsigned int hardware_concurrency() noexcept {
+    return thread::hardware_concurrency();
+  }
+
+private:
+  template <class _Fun, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI static thread __init_thread(const stop_source& __ss, _Fun&& __fun, _Args&&... __args) {
+    if constexpr (is_invocable_v<decay_t<_Fun>, stop_token, decay_t<_Args>...>) {
+      return thread(std::forward<_Fun>(__fun), __ss.get_token(), std::forward<_Args>(__args)...);
+    } else {
+      return thread(std::forward<_Fun>(__fun), std::forward<_Args>(__args)...);
+    }
+  }
+
+  stop_source __stop_source_;
+  thread __thread_;
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___THREAD_JTHREAD_H
diff --git a/third_party/libcxx/__thread/poll_with_backoff.h b/third_party/libcxx/__thread/poll_with_backoff.h
index d027a2779..4f961fe3f 100644
--- a/third_party/libcxx/__thread/poll_with_backoff.h
+++ b/third_party/libcxx/__thread/poll_with_backoff.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___THREAD_POLL_WITH_BACKOFF_H
 #define _LIBCPP___THREAD_POLL_WITH_BACKOFF_H
 
-#include <__availability>
 #include <__chrono/duration.h>
 #include <__chrono/high_resolution_clock.h>
 #include <__config>
@@ -26,31 +25,31 @@ static _LIBCPP_CONSTEXPR const int __libcpp_polling_count = 64;
 // Polls a thread for a condition given by a predicate, and backs off based on a backoff policy
 // before polling again.
 //
-// - __f is the "test function" that should return true if polling succeeded, and false if it failed.
+// - __poll is the "test function" that should return true if polling succeeded, and false if it failed.
 //
-// - __bf is the "backoff policy", which is called with the duration since we started polling. It should
+// - __backoff is the "backoff policy", which is called with the duration since we started polling. It should
 //   return false in order to resume polling, and true if polling should stop entirely for some reason.
 //   In general, backoff policies sleep for some time before returning control to the polling loop.
 //
 // - __max_elapsed is the maximum duration to try polling for. If the maximum duration is exceeded,
 //   the polling loop will return false to report a timeout.
-template<class _Fn, class _BFn>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
-bool __libcpp_thread_poll_with_backoff(_Fn&& __f, _BFn&& __bf, chrono::nanoseconds __max_elapsed = chrono::nanoseconds::zero()) {
-    auto const __start = chrono::high_resolution_clock::now();
-    for (int __count = 0;;) {
-      if (__f())
-        return true; // _Fn completion means success
-      if (__count < __libcpp_polling_count) {
-        __count += 1;
-        continue;
-      }
-      chrono::nanoseconds const __elapsed = chrono::high_resolution_clock::now() - __start;
-      if (__max_elapsed != chrono::nanoseconds::zero() && __max_elapsed < __elapsed)
-          return false; // timeout failure
-      if (__bf(__elapsed))
-        return false; // _BFn completion means failure
+template <class _Poll, class _Backoff>
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool __libcpp_thread_poll_with_backoff(
+    _Poll&& __poll, _Backoff&& __backoff, chrono::nanoseconds __max_elapsed = chrono::nanoseconds::zero()) {
+  auto const __start = chrono::high_resolution_clock::now();
+  for (int __count = 0;;) {
+    if (__poll())
+      return true; // __poll completion means success
+    if (__count < __libcpp_polling_count) {
+      __count += 1;
+      continue;
     }
+    chrono::nanoseconds const __elapsed = chrono::high_resolution_clock::now() - __start;
+    if (__max_elapsed != chrono::nanoseconds::zero() && __max_elapsed < __elapsed)
+      return false; // timeout failure
+    if (__backoff(__elapsed))
+      return false; // __backoff completion means failure
+  }
 }
 
 // A trivial backoff policy that always immediately returns the control to
@@ -60,10 +59,7 @@ bool __libcpp_thread_poll_with_backoff(_Fn&& __f, _BFn&& __bf, chrono::nanosecon
 // so this should most likely only be used on single-threaded systems where there
 // are no other threads to compete with.
 struct __spinning_backoff_policy {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-  bool operator()(chrono::nanoseconds const&) const {
-      return false;
-  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator()(chrono::nanoseconds const&) const { return false; }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__thread/support.h b/third_party/libcxx/__thread/support.h
new file mode 100644
index 000000000..9f161e48a
--- /dev/null
+++ b/third_party/libcxx/__thread/support.h
@@ -0,0 +1,123 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___THREAD_SUPPORT_H
+#define _LIBCPP___THREAD_SUPPORT_H
+
+#include <__config>
+
+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
+#  pragma GCC system_header
+#endif
+
+/*
+
+//
+// The library supports multiple implementations of the basic threading functionality.
+// The following functionality must be provided by any implementation:
+//
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+using __libcpp_timespec_t = ...;
+
+//
+// Mutex
+//
+using __libcpp_mutex_t = ...;
+#define _LIBCPP_MUTEX_INITIALIZER ...
+
+using __libcpp_recursive_mutex_t = ...;
+
+int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t*);
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t*);
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t*);
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t*);
+int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t*);
+
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_mutex_lock(__libcpp_mutex_t*);
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS bool __libcpp_mutex_trylock(__libcpp_mutex_t*);
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_mutex_unlock(__libcpp_mutex_t*);
+int __libcpp_mutex_destroy(__libcpp_mutex_t*);
+
+//
+// Condition Variable
+//
+using __libcpp_condvar_t = ...;
+#define _LIBCPP_CONDVAR_INITIALIZER ...
+
+int __libcpp_condvar_signal(__libcpp_condvar_t*);
+int __libcpp_condvar_broadcast(__libcpp_condvar_t*);
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_condvar_wait(__libcpp_condvar_t*, __libcpp_mutex_t*);
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS
+int __libcpp_condvar_timedwait(__libcpp_condvar_t*, __libcpp_mutex_t*, __libcpp_timespec_t*);
+int __libcpp_condvar_destroy(__libcpp_condvar_t*);
+
+//
+// Execute once
+//
+using __libcpp_exec_once_flag = ...;
+#define _LIBCPP_EXEC_ONCE_INITIALIZER ...
+
+int __libcpp_execute_once(__libcpp_exec_once_flag*, void (*__init_routine)());
+
+//
+// Thread id
+//
+using __libcpp_thread_id = ...;
+
+bool __libcpp_thread_id_equal(__libcpp_thread_id, __libcpp_thread_id);
+bool __libcpp_thread_id_less(__libcpp_thread_id, __libcpp_thread_id);
+
+//
+// Thread
+//
+#define _LIBCPP_NULL_THREAD ...
+using __libcpp_thread_t = ...;
+
+bool __libcpp_thread_isnull(const __libcpp_thread_t*);
+int __libcpp_thread_create(__libcpp_thread_t*, void* (*__func)(void*), void* __arg);
+__libcpp_thread_id __libcpp_thread_get_current_id();
+__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t*);
+int __libcpp_thread_join(__libcpp_thread_t*);
+int __libcpp_thread_detach(__libcpp_thread_t*);
+void __libcpp_thread_yield();
+void __libcpp_thread_sleep_for(const chrono::nanoseconds&);
+
+//
+// Thread local storage
+//
+#define _LIBCPP_TLS_DESTRUCTOR_CC ...
+using __libcpp_tls_key = ...;
+
+int __libcpp_tls_create(__libcpp_tls_key*, void (*__at_exit)(void*));
+void* __libcpp_tls_get(__libcpp_tls_key);
+int __libcpp_tls_set(__libcpp_tls_key, void*);
+
+_LIBCPP_END_NAMESPACE_STD
+
+*/
+
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+
+#  if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
+// #    include <__thread/support/external.h>
+#  elif defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
+#    include <__thread/support/pthread.h>
+#  elif defined(_LIBCPP_HAS_THREAD_API_C11)
+// #    include <__thread/support/c11.h>
+#  elif defined(_LIBCPP_HAS_THREAD_API_WIN32)
+// #    include <__thread/support/windows.h>
+#  else
+#    error "No threading API was selected"
+#  endif
+
+#endif // !_LIBCPP_HAS_NO_THREADS
+
+#endif // _LIBCPP___THREAD_SUPPORT_H
diff --git a/third_party/libcxx/__thread/support/pthread.h b/third_party/libcxx/__thread/support/pthread.h
new file mode 100644
index 000000000..f176c053f
--- /dev/null
+++ b/third_party/libcxx/__thread/support/pthread.h
@@ -0,0 +1,217 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___THREAD_SUPPORT_PTHREAD_H
+#define _LIBCPP___THREAD_SUPPORT_PTHREAD_H
+
+#include <__chrono/convert_to_timespec.h>
+#include <__chrono/duration.h>
+#include <__config>
+#include <ctime>
+#include <errno.h>
+#include <pthread.h>
+#include <sched.h>
+
+// Some platforms require <bits/atomic_wide_counter.h> in order for
+// PTHREAD_COND_INITIALIZER to be expanded. Normally that would come
+// in via <pthread.h>, but it's a non-modular header on those platforms,
+// so libc++'s <math.h> usually absorbs atomic_wide_counter.h into the
+// module with <math.h> and makes atomic_wide_counter.h invisible.
+// Include <math.h> here to work around that.
+// This checks wheter a Clang module is built
+#if __building_module(std)
+#  include <math.h>
+#endif
+
+#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+using __libcpp_timespec_t = ::timespec;
+
+//
+// Mutex
+//
+typedef pthread_mutex_t __libcpp_mutex_t;
+#define _LIBCPP_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
+
+typedef pthread_mutex_t __libcpp_recursive_mutex_t;
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t* __m) {
+  pthread_mutexattr_t __attr;
+  int __ec = pthread_mutexattr_init(&__attr);
+  if (__ec)
+    return __ec;
+  __ec = pthread_mutexattr_settype(&__attr, PTHREAD_MUTEX_RECURSIVE);
+  if (__ec) {
+    pthread_mutexattr_destroy(&__attr);
+    return __ec;
+  }
+  __ec = pthread_mutex_init(__m, &__attr);
+  if (__ec) {
+    pthread_mutexattr_destroy(&__attr);
+    return __ec;
+  }
+  __ec = pthread_mutexattr_destroy(&__attr);
+  if (__ec) {
+    pthread_mutex_destroy(__m);
+    return __ec;
+  }
+  return 0;
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int
+__libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t* __m) {
+  return pthread_mutex_lock(__m);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS bool
+__libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t* __m) {
+  return pthread_mutex_trylock(__m) == 0;
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int
+__libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t* __m) {
+  return pthread_mutex_unlock(__m);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t* __m) {
+  return pthread_mutex_destroy(__m);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_mutex_lock(__libcpp_mutex_t* __m) {
+  return pthread_mutex_lock(__m);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS bool __libcpp_mutex_trylock(__libcpp_mutex_t* __m) {
+  return pthread_mutex_trylock(__m) == 0;
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_mutex_unlock(__libcpp_mutex_t* __m) {
+  return pthread_mutex_unlock(__m);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_mutex_destroy(__libcpp_mutex_t* __m) { return pthread_mutex_destroy(__m); }
+
+//
+// Condition Variable
+//
+typedef pthread_cond_t __libcpp_condvar_t;
+#define _LIBCPP_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_condvar_signal(__libcpp_condvar_t* __cv) { return pthread_cond_signal(__cv); }
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv) {
+  return pthread_cond_broadcast(__cv);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int
+__libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m) {
+  return pthread_cond_wait(__cv, __m);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int
+__libcpp_condvar_timedwait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m, __libcpp_timespec_t* __ts) {
+  return pthread_cond_timedwait(__cv, __m, __ts);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv) {
+  return pthread_cond_destroy(__cv);
+}
+
+//
+// Execute once
+//
+typedef pthread_once_t __libcpp_exec_once_flag;
+#define _LIBCPP_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_execute_once(__libcpp_exec_once_flag* __flag, void (*__init_routine)()) {
+  return pthread_once(__flag, __init_routine);
+}
+
+//
+// Thread id
+//
+#if defined(__MVS__)
+typedef unsigned long long __libcpp_thread_id;
+#else
+typedef pthread_t __libcpp_thread_id;
+#endif
+
+// Returns non-zero if the thread ids are equal, otherwise 0
+inline _LIBCPP_HIDE_FROM_ABI bool __libcpp_thread_id_equal(__libcpp_thread_id __t1, __libcpp_thread_id __t2) {
+  return __t1 == __t2;
+}
+
+// Returns non-zero if t1 < t2, otherwise 0
+inline _LIBCPP_HIDE_FROM_ABI bool __libcpp_thread_id_less(__libcpp_thread_id __t1, __libcpp_thread_id __t2) {
+  return __t1 < __t2;
+}
+
+//
+// Thread
+//
+#define _LIBCPP_NULL_THREAD ((__libcpp_thread_t()))
+typedef pthread_t __libcpp_thread_t;
+
+inline _LIBCPP_HIDE_FROM_ABI __libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t* __t) {
+#if defined(__MVS__)
+  return __t->__;
+#else
+  return *__t;
+#endif
+}
+
+inline _LIBCPP_HIDE_FROM_ABI bool __libcpp_thread_isnull(const __libcpp_thread_t* __t) {
+  return __libcpp_thread_get_id(__t) == 0;
+}
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_thread_create(__libcpp_thread_t* __t, void* (*__func)(void*), void* __arg) {
+  return pthread_create(__t, nullptr, __func, __arg);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI __libcpp_thread_id __libcpp_thread_get_current_id() {
+  const __libcpp_thread_t __current_thread = pthread_self();
+  return __libcpp_thread_get_id(&__current_thread);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_thread_join(__libcpp_thread_t* __t) { return pthread_join(*__t, nullptr); }
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_thread_detach(__libcpp_thread_t* __t) { return pthread_detach(*__t); }
+
+inline _LIBCPP_HIDE_FROM_ABI void __libcpp_thread_yield() { sched_yield(); }
+
+inline _LIBCPP_HIDE_FROM_ABI void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns) {
+  __libcpp_timespec_t __ts = std::__convert_to_timespec<__libcpp_timespec_t>(__ns);
+  while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR)
+    ;
+}
+
+//
+// Thread local storage
+//
+#define _LIBCPP_TLS_DESTRUCTOR_CC /* nothing */
+
+typedef pthread_key_t __libcpp_tls_key;
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_tls_create(__libcpp_tls_key* __key, void (*__at_exit)(void*)) {
+  return pthread_key_create(__key, __at_exit);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI void* __libcpp_tls_get(__libcpp_tls_key __key) { return pthread_getspecific(__key); }
+
+inline _LIBCPP_HIDE_FROM_ABI int __libcpp_tls_set(__libcpp_tls_key __key, void* __p) {
+  return pthread_setspecific(__key, __p);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___THREAD_SUPPORT_PTHREAD_H
diff --git a/third_party/libcxx/__thread/this_thread.h b/third_party/libcxx/__thread/this_thread.h
new file mode 100644
index 000000000..de7eea282
--- /dev/null
+++ b/third_party/libcxx/__thread/this_thread.h
@@ -0,0 +1,74 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___THREAD_THIS_THREAD_H
+#define _LIBCPP___THREAD_THIS_THREAD_H
+
+#include <__chrono/steady_clock.h>
+#include <__chrono/time_point.h>
+#include <__condition_variable/condition_variable.h>
+#include <__config>
+#include <__mutex/mutex.h>
+#include <__mutex/unique_lock.h>
+#include <__thread/support.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace this_thread {
+
+_LIBCPP_EXPORTED_FROM_ABI void sleep_for(const chrono::nanoseconds& __ns);
+
+template <class _Rep, class _Period>
+_LIBCPP_HIDE_FROM_ABI void sleep_for(const chrono::duration<_Rep, _Period>& __d) {
+  if (__d > chrono::duration<_Rep, _Period>::zero()) {
+    // The standard guarantees a 64bit signed integer resolution for nanoseconds,
+    // so use INT64_MAX / 1e9 as cut-off point. Use a constant to avoid <climits>
+    // and issues with long double folding on PowerPC with GCC.
+    _LIBCPP_CONSTEXPR chrono::duration<long double> __max = chrono::duration<long double>(9223372036.0L);
+    chrono::nanoseconds __ns;
+    if (__d < __max) {
+      __ns = chrono::duration_cast<chrono::nanoseconds>(__d);
+      if (__ns < __d)
+        ++__ns;
+    } else
+      __ns = chrono::nanoseconds::max();
+    this_thread::sleep_for(__ns);
+  }
+}
+
+template <class _Clock, class _Duration>
+_LIBCPP_HIDE_FROM_ABI void sleep_until(const chrono::time_point<_Clock, _Duration>& __t) {
+  mutex __mut;
+  condition_variable __cv;
+  unique_lock<mutex> __lk(__mut);
+  while (_Clock::now() < __t)
+    __cv.wait_until(__lk, __t);
+}
+
+template <class _Duration>
+inline _LIBCPP_HIDE_FROM_ABI void sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t) {
+  this_thread::sleep_for(__t - chrono::steady_clock::now());
+}
+
+inline _LIBCPP_HIDE_FROM_ABI void yield() _NOEXCEPT { __libcpp_thread_yield(); }
+
+} // namespace this_thread
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___THREAD_THIS_THREAD_H
diff --git a/third_party/libcxx/__thread/thread.h b/third_party/libcxx/__thread/thread.h
new file mode 100644
index 000000000..d2254a695
--- /dev/null
+++ b/third_party/libcxx/__thread/thread.h
@@ -0,0 +1,258 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___THREAD_THREAD_H
+#define _LIBCPP___THREAD_THREAD_H
+
+#include <__condition_variable/condition_variable.h>
+#include <__config>
+#include <__exception/terminate.h>
+#include <__functional/hash.h>
+#include <__functional/unary_function.h>
+#include <__memory/unique_ptr.h>
+#include <__mutex/mutex.h>
+#include <__system_error/system_error.h>
+#include <__thread/id.h>
+#include <__thread/support.h>
+#include <__utility/forward.h>
+#include <tuple>
+
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+#  include <locale>
+#  include <sstream>
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+class __thread_specific_ptr;
+class _LIBCPP_EXPORTED_FROM_ABI __thread_struct;
+class _LIBCPP_HIDDEN __thread_struct_imp;
+class __assoc_sub_state;
+
+_LIBCPP_EXPORTED_FROM_ABI __thread_specific_ptr<__thread_struct>& __thread_local_data();
+
+class _LIBCPP_EXPORTED_FROM_ABI __thread_struct {
+  __thread_struct_imp* __p_;
+
+  __thread_struct(const __thread_struct&);
+  __thread_struct& operator=(const __thread_struct&);
+
+public:
+  __thread_struct();
+  ~__thread_struct();
+
+  void notify_all_at_thread_exit(condition_variable*, mutex*);
+  void __make_ready_at_thread_exit(__assoc_sub_state*);
+};
+
+template <class _Tp>
+class __thread_specific_ptr {
+  __libcpp_tls_key __key_;
+
+  // Only __thread_local_data() may construct a __thread_specific_ptr
+  // and only with _Tp == __thread_struct.
+  static_assert(is_same<_Tp, __thread_struct>::value, "");
+  __thread_specific_ptr();
+  friend _LIBCPP_EXPORTED_FROM_ABI __thread_specific_ptr<__thread_struct>& __thread_local_data();
+
+  _LIBCPP_HIDDEN static void _LIBCPP_TLS_DESTRUCTOR_CC __at_thread_exit(void*);
+
+public:
+  typedef _Tp* pointer;
+
+  __thread_specific_ptr(const __thread_specific_ptr&)            = delete;
+  __thread_specific_ptr& operator=(const __thread_specific_ptr&) = delete;
+  ~__thread_specific_ptr();
+
+  _LIBCPP_HIDE_FROM_ABI pointer get() const { return static_cast<_Tp*>(__libcpp_tls_get(__key_)); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator*() const { return *get(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return get(); }
+  void set_pointer(pointer __p);
+};
+
+template <class _Tp>
+void _LIBCPP_TLS_DESTRUCTOR_CC __thread_specific_ptr<_Tp>::__at_thread_exit(void* __p) {
+  delete static_cast<pointer>(__p);
+}
+
+template <class _Tp>
+__thread_specific_ptr<_Tp>::__thread_specific_ptr() {
+  int __ec = __libcpp_tls_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
+  if (__ec)
+    __throw_system_error(__ec, "__thread_specific_ptr construction failed");
+}
+
+template <class _Tp>
+__thread_specific_ptr<_Tp>::~__thread_specific_ptr() {
+  // __thread_specific_ptr is only created with a static storage duration
+  // so this destructor is only invoked during program termination. Invoking
+  // pthread_key_delete(__key_) may prevent other threads from deleting their
+  // thread local data. For this reason we leak the key.
+}
+
+template <class _Tp>
+void __thread_specific_ptr<_Tp>::set_pointer(pointer __p) {
+  _LIBCPP_ASSERT_INTERNAL(get() == nullptr, "Attempting to overwrite thread local data");
+  std::__libcpp_tls_set(__key_, __p);
+}
+
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<__thread_id> : public __unary_function<__thread_id, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(__thread_id __v) const _NOEXCEPT {
+    return hash<__libcpp_thread_id>()(__v.__id_);
+  }
+};
+
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id) {
+  // [thread.thread.id]/9
+  //   Effects: Inserts the text representation for charT of id into out.
+  //
+  // [thread.thread.id]/2
+  //   The text representation for the character type charT of an
+  //   object of type thread::id is an unspecified sequence of charT
+  //   such that, for two objects of type thread::id x and y, if
+  //   x == y is true, the thread::id objects have the same text
+  //   representation, and if x != y is true, the thread::id objects
+  //   have distinct text representations.
+  //
+  // Since various flags in the output stream can affect how the
+  // thread id is represented (e.g. numpunct or showbase), we
+  // use a temporary stream instead and just output the thread
+  // id representation as a string.
+
+  basic_ostringstream<_CharT, _Traits> __sstr;
+  __sstr.imbue(locale::classic());
+  __sstr << __id.__id_;
+  return __os << __sstr.str();
+}
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
+
+class _LIBCPP_EXPORTED_FROM_ABI thread {
+  __libcpp_thread_t __t_;
+
+  thread(const thread&);
+  thread& operator=(const thread&);
+
+public:
+  typedef __thread_id id;
+  typedef __libcpp_thread_t native_handle_type;
+
+  _LIBCPP_HIDE_FROM_ABI thread() _NOEXCEPT : __t_(_LIBCPP_NULL_THREAD) {}
+#ifndef _LIBCPP_CXX03_LANG
+  template <class _Fp, class... _Args, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, thread>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS explicit thread(_Fp&& __f, _Args&&... __args);
+#else // _LIBCPP_CXX03_LANG
+  template <class _Fp>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS explicit thread(_Fp __f);
+#endif
+  ~thread();
+
+  _LIBCPP_HIDE_FROM_ABI thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) { __t.__t_ = _LIBCPP_NULL_THREAD; }
+
+  _LIBCPP_HIDE_FROM_ABI thread& operator=(thread&& __t) _NOEXCEPT {
+    if (!__libcpp_thread_isnull(&__t_))
+      terminate();
+    __t_     = __t.__t_;
+    __t.__t_ = _LIBCPP_NULL_THREAD;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(thread& __t) _NOEXCEPT { std::swap(__t_, __t.__t_); }
+
+  _LIBCPP_HIDE_FROM_ABI bool joinable() const _NOEXCEPT { return !__libcpp_thread_isnull(&__t_); }
+  void join();
+  void detach();
+  _LIBCPP_HIDE_FROM_ABI id get_id() const _NOEXCEPT { return __libcpp_thread_get_id(&__t_); }
+  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() _NOEXCEPT { return __t_; }
+
+  static unsigned hardware_concurrency() _NOEXCEPT;
+};
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _TSp, class _Fp, class... _Args, size_t... _Indices>
+inline _LIBCPP_HIDE_FROM_ABI void __thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __tuple_indices<_Indices...>) {
+  std::__invoke(std::move(std::get<1>(__t)), std::move(std::get<_Indices>(__t))...);
+}
+
+template <class _Fp>
+_LIBCPP_HIDE_FROM_ABI void* __thread_proxy(void* __vp) {
+  // _Fp = tuple< unique_ptr<__thread_struct>, Functor, Args...>
+  unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
+  __thread_local_data().set_pointer(std::get<0>(*__p.get()).release());
+  typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 2>::type _Index;
+  std::__thread_execute(*__p.get(), _Index());
+  return nullptr;
+}
+
+template <class _Fp, class... _Args, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, thread>::value, int> >
+thread::thread(_Fp&& __f, _Args&&... __args) {
+  typedef unique_ptr<__thread_struct> _TSPtr;
+  _TSPtr __tsp(new __thread_struct);
+  typedef tuple<_TSPtr, __decay_t<_Fp>, __decay_t<_Args>...> _Gp;
+  unique_ptr<_Gp> __p(new _Gp(std::move(__tsp), std::forward<_Fp>(__f), std::forward<_Args>(__args)...));
+  int __ec = std::__libcpp_thread_create(&__t_, &__thread_proxy<_Gp>, __p.get());
+  if (__ec == 0)
+    __p.release();
+  else
+    __throw_system_error(__ec, "thread constructor failed");
+}
+
+#else // _LIBCPP_CXX03_LANG
+
+template <class _Fp>
+struct __thread_invoke_pair {
+  // This type is used to pass memory for thread local storage and a functor
+  // to a newly created thread because std::pair doesn't work with
+  // std::unique_ptr in C++03.
+  _LIBCPP_HIDE_FROM_ABI __thread_invoke_pair(_Fp& __f) : __tsp_(new __thread_struct), __fn_(__f) {}
+  unique_ptr<__thread_struct> __tsp_;
+  _Fp __fn_;
+};
+
+template <class _Fp>
+_LIBCPP_HIDE_FROM_ABI void* __thread_proxy_cxx03(void* __vp) {
+  unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
+  __thread_local_data().set_pointer(__p->__tsp_.release());
+  (__p->__fn_)();
+  return nullptr;
+}
+
+template <class _Fp>
+thread::thread(_Fp __f) {
+  typedef __thread_invoke_pair<_Fp> _InvokePair;
+  typedef unique_ptr<_InvokePair> _PairPtr;
+  _PairPtr __pp(new _InvokePair(__f));
+  int __ec = std::__libcpp_thread_create(&__t_, &__thread_proxy_cxx03<_InvokePair>, __pp.get());
+  if (__ec == 0)
+    __pp.release();
+  else
+    __throw_system_error(__ec, "thread constructor failed");
+}
+
+#endif // _LIBCPP_CXX03_LANG
+
+inline _LIBCPP_HIDE_FROM_ABI void swap(thread& __x, thread& __y) _NOEXCEPT { __x.swap(__y); }
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___THREAD_THREAD_H
diff --git a/third_party/libcxx/__thread/timed_backoff_policy.h b/third_party/libcxx/__thread/timed_backoff_policy.h
index a54b296ae..838c918a5 100644
--- a/third_party/libcxx/__thread/timed_backoff_policy.h
+++ b/third_party/libcxx/__thread/timed_backoff_policy.h
@@ -15,27 +15,25 @@
 #ifndef _LIBCPP_HAS_NO_THREADS
 
 #  include <__chrono/duration.h>
-#  include <__threading_support>
+#  include <__thread/support.h>
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 struct __libcpp_timed_backoff_policy {
-  _LIBCPP_INLINE_VISIBILITY
-  bool operator()(chrono::nanoseconds __elapsed) const
-  {
-      if(__elapsed > chrono::milliseconds(128))
-          __libcpp_thread_sleep_for(chrono::milliseconds(8));
-      else if(__elapsed > chrono::microseconds(64))
-          __libcpp_thread_sleep_for(__elapsed / 2);
-      else if(__elapsed > chrono::microseconds(4))
-        __libcpp_thread_yield();
-      else
-        {} // poll
-      return false;
+  _LIBCPP_HIDE_FROM_ABI bool operator()(chrono::nanoseconds __elapsed) const {
+    if (__elapsed > chrono::milliseconds(128))
+      __libcpp_thread_sleep_for(chrono::milliseconds(8));
+    else if (__elapsed > chrono::microseconds(64))
+      __libcpp_thread_sleep_for(__elapsed / 2);
+    else if (__elapsed > chrono::microseconds(4))
+      __libcpp_thread_yield();
+    else {
+    } // poll
+    return false;
   }
 };
 
diff --git a/third_party/libcxx/__threading_support b/third_party/libcxx/__threading_support
deleted file mode 100644
index 08dfd73c0..000000000
--- a/third_party/libcxx/__threading_support
+++ /dev/null
@@ -1,708 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___THREADING_SUPPORT
-#define _LIBCPP___THREADING_SUPPORT
-
-#include <__availability>
-#include <__chrono/convert_to_timespec.h>
-#include <__chrono/duration.h>
-#include <__compare/ordering.h>
-#include <__config>
-#include <__fwd/hash.h>
-#include <__thread/poll_with_backoff.h>
-#include <errno.h>
-#include <iosfwd>
-#include <limits>
-
-#ifdef __MVS__
-# include <__support/ibm/nanosleep.h>
-#endif
-
-#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
-#  pragma GCC system_header
-#endif
-
-#if defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
-# include <__external_threading>
-#elif !defined(_LIBCPP_HAS_NO_THREADS)
-
-#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
-# include <pthread.h>
-# include <sched.h>
-#elif defined(_LIBCPP_HAS_THREAD_API_C11)
-# include <threads.h>
-#endif
-
-#if defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \
-    defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL) || \
-    defined(_LIBCPP_HAS_THREAD_API_WIN32)
-#define _LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_FUNC_VIS
-#else
-#define _LIBCPP_THREAD_ABI_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY
-#endif
-
-#if defined(__FreeBSD__) && defined(__clang__) && __has_attribute(no_thread_safety_analysis)
-#define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS __attribute__((no_thread_safety_analysis))
-#else
-#define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
-#endif
-
-typedef ::timespec __libcpp_timespec_t;
-#endif // !defined(_LIBCPP_HAS_NO_THREADS)
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-
-#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
-// Mutex
-typedef pthread_mutex_t __libcpp_mutex_t;
-#define _LIBCPP_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
-
-typedef pthread_mutex_t __libcpp_recursive_mutex_t;
-
-// Condition Variable
-typedef pthread_cond_t __libcpp_condvar_t;
-#define _LIBCPP_CONDVAR_INITIALIZER PTHREAD_COND_INITIALIZER
-
-// Execute once
-typedef pthread_once_t __libcpp_exec_once_flag;
-#define _LIBCPP_EXEC_ONCE_INITIALIZER PTHREAD_ONCE_INIT
-
-// Thread id
-#if defined(__MVS__)
-  typedef unsigned long long __libcpp_thread_id;
-#else
-  typedef pthread_t __libcpp_thread_id;
-#endif
-
-// Thread
-#define _LIBCPP_NULL_THREAD ((__libcpp_thread_t()))
-typedef pthread_t __libcpp_thread_t;
-
-// Thread Local Storage
-typedef pthread_key_t __libcpp_tls_key;
-
-#define _LIBCPP_TLS_DESTRUCTOR_CC
-#elif defined(_LIBCPP_HAS_THREAD_API_C11)
-// Mutex
-typedef mtx_t __libcpp_mutex_t;
-// mtx_t is a struct so using {} for initialization is valid.
-#define _LIBCPP_MUTEX_INITIALIZER {}
-
-typedef mtx_t __libcpp_recursive_mutex_t;
-
-// Condition Variable
-typedef cnd_t __libcpp_condvar_t;
-// cnd_t is a struct so using {} for initialization is valid.
-#define _LIBCPP_CONDVAR_INITIALIZER {}
-
-// Execute once
-typedef once_flag __libcpp_exec_once_flag;
-#define _LIBCPP_EXEC_ONCE_INITIALIZER ONCE_FLAG_INIT
-
-// Thread id
-typedef thrd_t __libcpp_thread_id;
-
-// Thread
-#define _LIBCPP_NULL_THREAD 0U
-
-typedef thrd_t __libcpp_thread_t;
-
-// Thread Local Storage
-typedef tss_t __libcpp_tls_key;
-
-#define _LIBCPP_TLS_DESTRUCTOR_CC
-#elif !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
-// Mutex
-typedef void* __libcpp_mutex_t;
-#define _LIBCPP_MUTEX_INITIALIZER 0
-
-#if defined(_M_IX86) || defined(__i386__) || defined(_M_ARM) || defined(__arm__)
-typedef void* __libcpp_recursive_mutex_t[6];
-#elif defined(_M_AMD64) || defined(__x86_64__) || defined(_M_ARM64) || defined(__aarch64__)
-typedef void* __libcpp_recursive_mutex_t[5];
-#else
-# error Unsupported architecture
-#endif
-
-// Condition Variable
-typedef void* __libcpp_condvar_t;
-#define _LIBCPP_CONDVAR_INITIALIZER 0
-
-// Execute Once
-typedef void* __libcpp_exec_once_flag;
-#define _LIBCPP_EXEC_ONCE_INITIALIZER 0
-
-// Thread ID
-typedef long __libcpp_thread_id;
-
-// Thread
-#define _LIBCPP_NULL_THREAD 0U
-
-typedef void* __libcpp_thread_t;
-
-// Thread Local Storage
-typedef long __libcpp_tls_key;
-
-#define _LIBCPP_TLS_DESTRUCTOR_CC __stdcall
-#endif // !defined(_LIBCPP_HAS_THREAD_API_PTHREAD) && !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
-
-#if !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
-// Mutex
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m);
-
-_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
-int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m);
-
-_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
-bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m);
-
-_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
-int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m);
-
-_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
-int __libcpp_mutex_lock(__libcpp_mutex_t *__m);
-
-_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
-bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m);
-
-_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
-int __libcpp_mutex_unlock(__libcpp_mutex_t *__m);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_mutex_destroy(__libcpp_mutex_t *__m);
-
-// Condition variable
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_condvar_signal(__libcpp_condvar_t* __cv);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv);
-
-_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
-int __libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m);
-
-_LIBCPP_THREAD_ABI_VISIBILITY _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
-int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
-                               __libcpp_timespec_t *__ts);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);
-
-// Execute once
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_execute_once(__libcpp_exec_once_flag *__flag,
-                          void (*__init_routine)());
-
-// Thread id
-_LIBCPP_THREAD_ABI_VISIBILITY
-bool __libcpp_thread_id_equal(__libcpp_thread_id __t1, __libcpp_thread_id __t2);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-bool __libcpp_thread_id_less(__libcpp_thread_id __t1, __libcpp_thread_id __t2);
-
-// Thread
-_LIBCPP_THREAD_ABI_VISIBILITY
-bool __libcpp_thread_isnull(const __libcpp_thread_t *__t);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),
-                           void *__arg);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-__libcpp_thread_id __libcpp_thread_get_current_id();
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_thread_join(__libcpp_thread_t *__t);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_thread_detach(__libcpp_thread_t *__t);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-void __libcpp_thread_yield();
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns);
-
-// Thread local storage
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_tls_create(__libcpp_tls_key* __key,
-                        void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*));
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-void *__libcpp_tls_get(__libcpp_tls_key __key);
-
-_LIBCPP_THREAD_ABI_VISIBILITY
-int __libcpp_tls_set(__libcpp_tls_key __key, void *__p);
-
-#endif // !defined(_LIBCPP_HAS_THREAD_API_EXTERNAL)
-
-#if (!defined(_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL) || \
-     defined(_LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL))
-
-#if defined(_LIBCPP_HAS_THREAD_API_PTHREAD)
-
-int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
-{
-  pthread_mutexattr_t __attr;
-  int __ec = pthread_mutexattr_init(&__attr);
-  if (__ec)
-    return __ec;
-  __ec = pthread_mutexattr_settype(&__attr, PTHREAD_MUTEX_RECURSIVE);
-  if (__ec) {
-    pthread_mutexattr_destroy(&__attr);
-    return __ec;
-  }
-  __ec = pthread_mutex_init(__m, &__attr);
-  if (__ec) {
-    pthread_mutexattr_destroy(&__attr);
-    return __ec;
-  }
-  __ec = pthread_mutexattr_destroy(&__attr);
-  if (__ec) {
-    pthread_mutex_destroy(__m);
-    return __ec;
-  }
-  return 0;
-}
-
-int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m)
-{
-  return pthread_mutex_lock(__m);
-}
-
-bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m)
-{
-  return pthread_mutex_trylock(__m) == 0;
-}
-
-int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m)
-{
-  return pthread_mutex_unlock(__m);
-}
-
-int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m)
-{
-  return pthread_mutex_destroy(__m);
-}
-
-int __libcpp_mutex_lock(__libcpp_mutex_t *__m)
-{
-  return pthread_mutex_lock(__m);
-}
-
-bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m)
-{
-  return pthread_mutex_trylock(__m) == 0;
-}
-
-int __libcpp_mutex_unlock(__libcpp_mutex_t *__m)
-{
-  return pthread_mutex_unlock(__m);
-}
-
-int __libcpp_mutex_destroy(__libcpp_mutex_t *__m)
-{
-  return pthread_mutex_destroy(__m);
-}
-
-// Condition Variable
-int __libcpp_condvar_signal(__libcpp_condvar_t *__cv)
-{
-  return pthread_cond_signal(__cv);
-}
-
-int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv)
-{
-  return pthread_cond_broadcast(__cv);
-}
-
-int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m)
-{
-  return pthread_cond_wait(__cv, __m);
-}
-
-int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
-                               __libcpp_timespec_t *__ts)
-{
-  return pthread_cond_timedwait(__cv, __m, __ts);
-}
-
-int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
-{
-  return pthread_cond_destroy(__cv);
-}
-
-// Execute once
-int __libcpp_execute_once(__libcpp_exec_once_flag *__flag,
-                          void (*__init_routine)()) {
-  return pthread_once(__flag, __init_routine);
-}
-
-// Thread id
-// Returns non-zero if the thread ids are equal, otherwise 0
-bool __libcpp_thread_id_equal(__libcpp_thread_id __t1, __libcpp_thread_id __t2)
-{
-  return __t1 == __t2;
-}
-
-// Returns non-zero if t1 < t2, otherwise 0
-bool __libcpp_thread_id_less(__libcpp_thread_id __t1, __libcpp_thread_id __t2)
-{
-  return __t1 < __t2;
-}
-
-// Thread
-bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) {
-  return __libcpp_thread_get_id(__t) == 0;
-}
-
-int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),
-                           void *__arg)
-{
-  return pthread_create(__t, nullptr, __func, __arg);
-}
-
-__libcpp_thread_id __libcpp_thread_get_current_id()
-{
-  const __libcpp_thread_t __current_thread = pthread_self();
-  return __libcpp_thread_get_id(&__current_thread);
-}
-
-__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t)
-{
-#if defined(__MVS__)
-  return __t->__;
-#else
-  return *__t;
-#endif
-}
-
-int __libcpp_thread_join(__libcpp_thread_t *__t)
-{
-  return pthread_join(*__t, nullptr);
-}
-
-int __libcpp_thread_detach(__libcpp_thread_t *__t)
-{
-  return pthread_detach(*__t);
-}
-
-void __libcpp_thread_yield()
-{
-  sched_yield();
-}
-
-void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)
-{
-   __libcpp_timespec_t __ts = _VSTD::__convert_to_timespec<__libcpp_timespec_t>(__ns);
-   while (nanosleep(&__ts, &__ts) == -1 && errno == EINTR);
-}
-
-// Thread local storage
-int __libcpp_tls_create(__libcpp_tls_key *__key, void (*__at_exit)(void *))
-{
-  return pthread_key_create(__key, __at_exit);
-}
-
-void *__libcpp_tls_get(__libcpp_tls_key __key)
-{
-  return pthread_getspecific(__key);
-}
-
-int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
-{
-    return pthread_setspecific(__key, __p);
-}
-
-#elif defined(_LIBCPP_HAS_THREAD_API_C11)
-
-int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
-{
-  return mtx_init(__m, mtx_plain | mtx_recursive) == thrd_success ? 0 : EINVAL;
-}
-
-int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m)
-{
-  return mtx_lock(__m) == thrd_success ? 0 : EINVAL;
-}
-
-bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m)
-{
-  return mtx_trylock(__m) == thrd_success;
-}
-
-int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m)
-{
-  return mtx_unlock(__m) == thrd_success ? 0 : EINVAL;
-}
-
-int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m)
-{
-  mtx_destroy(__m);
-  return 0;
-}
-
-int __libcpp_mutex_lock(__libcpp_mutex_t *__m)
-{
-  return mtx_lock(__m) == thrd_success ? 0 : EINVAL;
-}
-
-bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m)
-{
-  return mtx_trylock(__m) == thrd_success;
-}
-
-int __libcpp_mutex_unlock(__libcpp_mutex_t *__m)
-{
-  return mtx_unlock(__m) == thrd_success ? 0 : EINVAL;
-}
-
-int __libcpp_mutex_destroy(__libcpp_mutex_t *__m)
-{
-  mtx_destroy(__m);
-  return 0;
-}
-
-// Condition Variable
-int __libcpp_condvar_signal(__libcpp_condvar_t *__cv)
-{
-  return cnd_signal(__cv) == thrd_success ? 0 : EINVAL;
-}
-
-int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv)
-{
-  return cnd_broadcast(__cv) == thrd_success ? 0 : EINVAL;
-}
-
-int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m)
-{
-  return cnd_wait(__cv, __m) == thrd_success ? 0 : EINVAL;
-}
-
-int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
-                               timespec *__ts)
-{
-  int __ec = cnd_timedwait(__cv, __m, __ts);
-  return __ec == thrd_timedout ? ETIMEDOUT : __ec;
-}
-
-int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
-{
-  cnd_destroy(__cv);
-  return 0;
-}
-
-// Execute once
-int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
-                          void (*init_routine)(void)) {
-  ::call_once(flag, init_routine);
-  return 0;
-}
-
-// Thread id
-// Returns non-zero if the thread ids are equal, otherwise 0
-bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2)
-{
-  return thrd_equal(t1, t2) != 0;
-}
-
-// Returns non-zero if t1 < t2, otherwise 0
-bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2)
-{
-  return t1 < t2;
-}
-
-// Thread
-bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) {
-  return __libcpp_thread_get_id(__t) == 0;
-}
-
-int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),
-                           void *__arg)
-{
-  int __ec = thrd_create(__t, reinterpret_cast<thrd_start_t>(__func), __arg);
-  return __ec == thrd_nomem ? ENOMEM : __ec;
-}
-
-__libcpp_thread_id __libcpp_thread_get_current_id()
-{
-  return thrd_current();
-}
-
-__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t)
-{
-  return *__t;
-}
-
-int __libcpp_thread_join(__libcpp_thread_t *__t)
-{
-  return thrd_join(*__t, nullptr) == thrd_success ? 0 : EINVAL;
-}
-
-int __libcpp_thread_detach(__libcpp_thread_t *__t)
-{
-  return thrd_detach(*__t) == thrd_success ? 0 : EINVAL;
-}
-
-void __libcpp_thread_yield()
-{
-  thrd_yield();
-}
-
-void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)
-{
-   __libcpp_timespec_t __ts = _VSTD::__convert_to_timespec<__libcpp_timespec_t>(__ns);
-  thrd_sleep(&__ts, nullptr);
-}
-
-// Thread local storage
-int __libcpp_tls_create(__libcpp_tls_key *__key, void (*__at_exit)(void *))
-{
-  return tss_create(__key, __at_exit) == thrd_success ? 0 : EINVAL;
-}
-
-void *__libcpp_tls_get(__libcpp_tls_key __key)
-{
-  return tss_get(__key);
-}
-
-int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
-{
-  return tss_set(__key, __p) == thrd_success ? 0 : EINVAL;
-}
-
-#endif
-
-
-#endif // !_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL || _LIBCPP_BUILDING_THREAD_LIBRARY_EXTERNAL
-
-class _LIBCPP_TYPE_VIS thread;
-class _LIBCPP_TYPE_VIS __thread_id;
-
-namespace this_thread
-{
-
-_LIBCPP_INLINE_VISIBILITY __thread_id get_id() _NOEXCEPT;
-
-} // namespace this_thread
-
-template<> struct hash<__thread_id>;
-
-class _LIBCPP_TEMPLATE_VIS __thread_id
-{
-    // FIXME: pthread_t is a pointer on Darwin but a long on Linux.
-    // NULL is the no-thread value on Darwin.  Someone needs to check
-    // on other platforms.  We assume 0 works everywhere for now.
-    __libcpp_thread_id __id_;
-
-    static _LIBCPP_HIDE_FROM_ABI
-        bool __lt_impl(__thread_id __x, __thread_id __y) _NOEXCEPT
-        { // id==0 is always less than any other thread_id
-        if (__x.__id_ == 0) return __y.__id_ != 0;
-        if (__y.__id_ == 0) return false;
-        return  __libcpp_thread_id_less(__x.__id_, __y.__id_);
-        }
-
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    __thread_id() _NOEXCEPT : __id_(0) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __reset() { __id_ = 0; }
-
-    friend _LIBCPP_HIDE_FROM_ABI bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT;
-#if _LIBCPP_STD_VER <= 17
-    friend _LIBCPP_HIDE_FROM_ABI bool operator<(__thread_id __x, __thread_id __y) _NOEXCEPT;
-#else // _LIBCPP_STD_VER <= 17
-    friend _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(__thread_id __x, __thread_id __y) noexcept;
-#endif // _LIBCPP_STD_VER <= 17
-
-    template<class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id);
-
-private:
-    _LIBCPP_INLINE_VISIBILITY
-    __thread_id(__libcpp_thread_id __id) : __id_(__id) {}
-
-    _LIBCPP_HIDE_FROM_ABI friend __libcpp_thread_id __get_underlying_id(const __thread_id __id) { return __id.__id_; }
-
-    friend __thread_id this_thread::get_id() _NOEXCEPT;
-    friend class _LIBCPP_TYPE_VIS thread;
-    friend struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>;
-};
-
-inline _LIBCPP_HIDE_FROM_ABI
-bool operator==(__thread_id __x, __thread_id __y) _NOEXCEPT {
-  // Don't pass id==0 to underlying routines
-  if (__x.__id_ == 0)
-    return __y.__id_ == 0;
-  if (__y.__id_ == 0)
-    return false;
-  return __libcpp_thread_id_equal(__x.__id_, __y.__id_);
-}
-
-#if _LIBCPP_STD_VER <= 17
-
-inline _LIBCPP_HIDE_FROM_ABI
-bool operator!=(__thread_id __x, __thread_id __y) _NOEXCEPT {
-  return !(__x == __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI
-bool operator<(__thread_id __x, __thread_id __y) _NOEXCEPT {
-  return __thread_id::__lt_impl(__x.__id_, __y.__id_);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI bool operator<=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__y < __x); }
-inline _LIBCPP_HIDE_FROM_ABI bool operator>(__thread_id __x, __thread_id __y) _NOEXCEPT { return __y < __x; }
-inline _LIBCPP_HIDE_FROM_ABI bool operator>=(__thread_id __x, __thread_id __y) _NOEXCEPT { return !(__x < __y); }
-
-#else // _LIBCPP_STD_VER <= 17
-
-inline _LIBCPP_HIDE_FROM_ABI
-strong_ordering operator<=>(__thread_id __x, __thread_id __y) noexcept {
-  if (__x == __y)
-    return strong_ordering::equal;
-  if (__thread_id::__lt_impl(__x, __y))
-    return strong_ordering::less;
-  return strong_ordering::greater;
-}
-
-#endif // _LIBCPP_STD_VER <= 17
-
-namespace this_thread
-{
-
-inline _LIBCPP_INLINE_VISIBILITY
-__thread_id
-get_id() _NOEXCEPT
-{
-    return __libcpp_thread_get_current_id();
-}
-
-} // namespace this_thread
-
-#endif // !_LIBCPP_HAS_NO_THREADS
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___THREADING_SUPPORT
diff --git a/third_party/libcxx/__tree b/third_party/libcxx/__tree
index 25c86ca01..1990fa602 100644
--- a/third_party/libcxx/__tree
+++ b/third_party/libcxx/__tree
@@ -13,7 +13,6 @@
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__config>
-#include <__debug>
 #include <__functional/invoke.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
@@ -27,11 +26,9 @@
 #include <__type_traits/can_extract_key.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_const.h>
-#include <__type_traits/is_copy_constructible.h>
-#include <__type_traits/is_nothrow_copy_constructible.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
@@ -42,7 +39,6 @@
 #include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <limits>
-#include <stdexcept>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -51,30 +47,40 @@
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class, class, class, class> class _LIBCPP_TEMPLATE_VIS map;
-template <class, class, class, class> class _LIBCPP_TEMPLATE_VIS multimap;
-template <class, class, class> class _LIBCPP_TEMPLATE_VIS set;
-template <class, class, class> class _LIBCPP_TEMPLATE_VIS multiset;
+template <class, class, class, class>
+class _LIBCPP_TEMPLATE_VIS map;
+template <class, class, class, class>
+class _LIBCPP_TEMPLATE_VIS multimap;
+template <class, class, class>
+class _LIBCPP_TEMPLATE_VIS set;
+template <class, class, class>
+class _LIBCPP_TEMPLATE_VIS multiset;
 
-template <class _Tp, class _Compare, class _Allocator> class __tree;
+template <class _Tp, class _Compare, class _Allocator>
+class __tree;
 template <class _Tp, class _NodePtr, class _DiffType>
-    class _LIBCPP_TEMPLATE_VIS __tree_iterator;
+class _LIBCPP_TEMPLATE_VIS __tree_iterator;
 template <class _Tp, class _ConstNodePtr, class _DiffType>
-    class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
+class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
 
-template <class _Pointer> class __tree_end_node;
-template <class _VoidPtr> class __tree_node_base;
-template <class _Tp, class _VoidPtr> class __tree_node;
+template <class _Pointer>
+class __tree_end_node;
+template <class _VoidPtr>
+class __tree_node_base;
+template <class _Tp, class _VoidPtr>
+class __tree_node;
 
 template <class _Key, class _Value>
 struct __value_type;
 
-template <class _Allocator> class __map_node_destructor;
-template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_iterator;
-template <class _TreeIterator> class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
+template <class _Allocator>
+class __map_node_destructor;
+template <class _TreeIterator>
+class _LIBCPP_TEMPLATE_VIS __map_iterator;
+template <class _TreeIterator>
+class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
 
 /*
 
@@ -100,198 +106,167 @@ __root, have a non-null __parent_ field.
 // Returns:  true if __x is a left child of its parent, else false
 // Precondition:  __x != nullptr.
 template <class _NodePtr>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-__tree_is_left_child(_NodePtr __x) _NOEXCEPT
-{
-    return __x == __x->__parent_->__left_;
+inline _LIBCPP_HIDE_FROM_ABI bool __tree_is_left_child(_NodePtr __x) _NOEXCEPT {
+  return __x == __x->__parent_->__left_;
 }
 
 // Determines if the subtree rooted at __x is a proper red black subtree.  If
 //    __x is a proper subtree, returns the black height (null counts as 1).  If
 //    __x is an improper subtree, returns 0.
 template <class _NodePtr>
-unsigned
-__tree_sub_invariant(_NodePtr __x)
-{
-    if (__x == nullptr)
-        return 1;
-    // parent consistency checked by caller
-    // check __x->__left_ consistency
-    if (__x->__left_ != nullptr && __x->__left_->__parent_ != __x)
-        return 0;
-    // check __x->__right_ consistency
-    if (__x->__right_ != nullptr && __x->__right_->__parent_ != __x)
-        return 0;
-    // check __x->__left_ != __x->__right_ unless both are nullptr
-    if (__x->__left_ == __x->__right_ && __x->__left_ != nullptr)
-        return 0;
-    // If this is red, neither child can be red
-    if (!__x->__is_black_)
-    {
-        if (__x->__left_ && !__x->__left_->__is_black_)
-            return 0;
-        if (__x->__right_ && !__x->__right_->__is_black_)
-            return 0;
-    }
-    unsigned __h = _VSTD::__tree_sub_invariant(__x->__left_);
-    if (__h == 0)
-        return 0;  // invalid left subtree
-    if (__h != _VSTD::__tree_sub_invariant(__x->__right_))
-        return 0;  // invalid or different height right subtree
-    return __h + __x->__is_black_;  // return black height of this node
+unsigned __tree_sub_invariant(_NodePtr __x) {
+  if (__x == nullptr)
+    return 1;
+  // parent consistency checked by caller
+  // check __x->__left_ consistency
+  if (__x->__left_ != nullptr && __x->__left_->__parent_ != __x)
+    return 0;
+  // check __x->__right_ consistency
+  if (__x->__right_ != nullptr && __x->__right_->__parent_ != __x)
+    return 0;
+  // check __x->__left_ != __x->__right_ unless both are nullptr
+  if (__x->__left_ == __x->__right_ && __x->__left_ != nullptr)
+    return 0;
+  // If this is red, neither child can be red
+  if (!__x->__is_black_) {
+    if (__x->__left_ && !__x->__left_->__is_black_)
+      return 0;
+    if (__x->__right_ && !__x->__right_->__is_black_)
+      return 0;
+  }
+  unsigned __h = std::__tree_sub_invariant(__x->__left_);
+  if (__h == 0)
+    return 0; // invalid left subtree
+  if (__h != std::__tree_sub_invariant(__x->__right_))
+    return 0;                    // invalid or different height right subtree
+  return __h + __x->__is_black_; // return black height of this node
 }
 
 // Determines if the red black tree rooted at __root is a proper red black tree.
 //    __root == nullptr is a proper tree.  Returns true is __root is a proper
 //    red black tree, else returns false.
 template <class _NodePtr>
-_LIBCPP_HIDE_FROM_ABI bool
-__tree_invariant(_NodePtr __root)
-{
-    if (__root == nullptr)
-        return true;
-    // check __x->__parent_ consistency
-    if (__root->__parent_ == nullptr)
-        return false;
-    if (!_VSTD::__tree_is_left_child(__root))
-        return false;
-    // root must be black
-    if (!__root->__is_black_)
-        return false;
-    // do normal node checks
-    return _VSTD::__tree_sub_invariant(__root) != 0;
+_LIBCPP_HIDE_FROM_ABI bool __tree_invariant(_NodePtr __root) {
+  if (__root == nullptr)
+    return true;
+  // check __x->__parent_ consistency
+  if (__root->__parent_ == nullptr)
+    return false;
+  if (!std::__tree_is_left_child(__root))
+    return false;
+  // root must be black
+  if (!__root->__is_black_)
+    return false;
+  // do normal node checks
+  return std::__tree_sub_invariant(__root) != 0;
 }
 
 // Returns:  pointer to the left-most node under __x.
 template <class _NodePtr>
-inline _LIBCPP_INLINE_VISIBILITY
-_NodePtr
-__tree_min(_NodePtr __x) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__x != nullptr, "Root node shouldn't be null");
-    while (__x->__left_ != nullptr)
-        __x = __x->__left_;
-    return __x;
+inline _LIBCPP_HIDE_FROM_ABI _NodePtr __tree_min(_NodePtr __x) _NOEXCEPT {
+  _LIBCPP_ASSERT_INTERNAL(__x != nullptr, "Root node shouldn't be null");
+  while (__x->__left_ != nullptr)
+    __x = __x->__left_;
+  return __x;
 }
 
 // Returns:  pointer to the right-most node under __x.
 template <class _NodePtr>
-inline _LIBCPP_INLINE_VISIBILITY
-_NodePtr
-__tree_max(_NodePtr __x) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__x != nullptr, "Root node shouldn't be null");
-    while (__x->__right_ != nullptr)
-        __x = __x->__right_;
-    return __x;
+inline _LIBCPP_HIDE_FROM_ABI _NodePtr __tree_max(_NodePtr __x) _NOEXCEPT {
+  _LIBCPP_ASSERT_INTERNAL(__x != nullptr, "Root node shouldn't be null");
+  while (__x->__right_ != nullptr)
+    __x = __x->__right_;
+  return __x;
 }
 
 // Returns:  pointer to the next in-order node after __x.
 template <class _NodePtr>
-_LIBCPP_HIDE_FROM_ABI _NodePtr
-__tree_next(_NodePtr __x) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__x != nullptr, "node shouldn't be null");
-    if (__x->__right_ != nullptr)
-        return _VSTD::__tree_min(__x->__right_);
-    while (!_VSTD::__tree_is_left_child(__x))
-        __x = __x->__parent_unsafe();
-    return __x->__parent_unsafe();
+_LIBCPP_HIDE_FROM_ABI _NodePtr __tree_next(_NodePtr __x) _NOEXCEPT {
+  _LIBCPP_ASSERT_INTERNAL(__x != nullptr, "node shouldn't be null");
+  if (__x->__right_ != nullptr)
+    return std::__tree_min(__x->__right_);
+  while (!std::__tree_is_left_child(__x))
+    __x = __x->__parent_unsafe();
+  return __x->__parent_unsafe();
 }
 
 template <class _EndNodePtr, class _NodePtr>
-inline _LIBCPP_INLINE_VISIBILITY
-_EndNodePtr
-__tree_next_iter(_NodePtr __x) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__x != nullptr, "node shouldn't be null");
-    if (__x->__right_ != nullptr)
-        return static_cast<_EndNodePtr>(_VSTD::__tree_min(__x->__right_));
-    while (!_VSTD::__tree_is_left_child(__x))
-        __x = __x->__parent_unsafe();
-    return static_cast<_EndNodePtr>(__x->__parent_);
+inline _LIBCPP_HIDE_FROM_ABI _EndNodePtr __tree_next_iter(_NodePtr __x) _NOEXCEPT {
+  _LIBCPP_ASSERT_INTERNAL(__x != nullptr, "node shouldn't be null");
+  if (__x->__right_ != nullptr)
+    return static_cast<_EndNodePtr>(std::__tree_min(__x->__right_));
+  while (!std::__tree_is_left_child(__x))
+    __x = __x->__parent_unsafe();
+  return static_cast<_EndNodePtr>(__x->__parent_);
 }
 
 // Returns:  pointer to the previous in-order node before __x.
 // Note: __x may be the end node.
 template <class _NodePtr, class _EndNodePtr>
-inline _LIBCPP_INLINE_VISIBILITY
-_NodePtr
-__tree_prev_iter(_EndNodePtr __x) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__x != nullptr, "node shouldn't be null");
-    if (__x->__left_ != nullptr)
-        return _VSTD::__tree_max(__x->__left_);
-    _NodePtr __xx = static_cast<_NodePtr>(__x);
-    while (_VSTD::__tree_is_left_child(__xx))
-        __xx = __xx->__parent_unsafe();
-    return __xx->__parent_unsafe();
+inline _LIBCPP_HIDE_FROM_ABI _NodePtr __tree_prev_iter(_EndNodePtr __x) _NOEXCEPT {
+  _LIBCPP_ASSERT_INTERNAL(__x != nullptr, "node shouldn't be null");
+  if (__x->__left_ != nullptr)
+    return std::__tree_max(__x->__left_);
+  _NodePtr __xx = static_cast<_NodePtr>(__x);
+  while (std::__tree_is_left_child(__xx))
+    __xx = __xx->__parent_unsafe();
+  return __xx->__parent_unsafe();
 }
 
 // Returns:  pointer to a node which has no children
 template <class _NodePtr>
-_LIBCPP_HIDE_FROM_ABI _NodePtr
-__tree_leaf(_NodePtr __x) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__x != nullptr, "node shouldn't be null");
-    while (true)
-    {
-        if (__x->__left_ != nullptr)
-        {
-            __x = __x->__left_;
-            continue;
-        }
-        if (__x->__right_ != nullptr)
-        {
-            __x = __x->__right_;
-            continue;
-        }
-        break;
+_LIBCPP_HIDE_FROM_ABI _NodePtr __tree_leaf(_NodePtr __x) _NOEXCEPT {
+  _LIBCPP_ASSERT_INTERNAL(__x != nullptr, "node shouldn't be null");
+  while (true) {
+    if (__x->__left_ != nullptr) {
+      __x = __x->__left_;
+      continue;
     }
-    return __x;
+    if (__x->__right_ != nullptr) {
+      __x = __x->__right_;
+      continue;
+    }
+    break;
+  }
+  return __x;
 }
 
 // Effects:  Makes __x->__right_ the subtree root with __x as its left child
 //           while preserving in-order order.
 template <class _NodePtr>
-_LIBCPP_HIDE_FROM_ABI void
-__tree_left_rotate(_NodePtr __x) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__x != nullptr, "node shouldn't be null");
-    _LIBCPP_ASSERT(__x->__right_ != nullptr, "node should have a right child");
-    _NodePtr __y = __x->__right_;
-    __x->__right_ = __y->__left_;
-    if (__x->__right_ != nullptr)
-        __x->__right_->__set_parent(__x);
-    __y->__parent_ = __x->__parent_;
-    if (_VSTD::__tree_is_left_child(__x))
-        __x->__parent_->__left_ = __y;
-    else
-        __x->__parent_unsafe()->__right_ = __y;
-    __y->__left_ = __x;
-    __x->__set_parent(__y);
+_LIBCPP_HIDE_FROM_ABI void __tree_left_rotate(_NodePtr __x) _NOEXCEPT {
+  _LIBCPP_ASSERT_INTERNAL(__x != nullptr, "node shouldn't be null");
+  _LIBCPP_ASSERT_INTERNAL(__x->__right_ != nullptr, "node should have a right child");
+  _NodePtr __y  = __x->__right_;
+  __x->__right_ = __y->__left_;
+  if (__x->__right_ != nullptr)
+    __x->__right_->__set_parent(__x);
+  __y->__parent_ = __x->__parent_;
+  if (std::__tree_is_left_child(__x))
+    __x->__parent_->__left_ = __y;
+  else
+    __x->__parent_unsafe()->__right_ = __y;
+  __y->__left_ = __x;
+  __x->__set_parent(__y);
 }
 
 // Effects:  Makes __x->__left_ the subtree root with __x as its right child
 //           while preserving in-order order.
 template <class _NodePtr>
-_LIBCPP_HIDE_FROM_ABI void
-__tree_right_rotate(_NodePtr __x) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__x != nullptr, "node shouldn't be null");
-    _LIBCPP_ASSERT(__x->__left_ != nullptr, "node should have a left child");
-    _NodePtr __y = __x->__left_;
-    __x->__left_ = __y->__right_;
-    if (__x->__left_ != nullptr)
-        __x->__left_->__set_parent(__x);
-    __y->__parent_ = __x->__parent_;
-    if (_VSTD::__tree_is_left_child(__x))
-        __x->__parent_->__left_ = __y;
-    else
-        __x->__parent_unsafe()->__right_ = __y;
-    __y->__right_ = __x;
-    __x->__set_parent(__y);
+_LIBCPP_HIDE_FROM_ABI void __tree_right_rotate(_NodePtr __x) _NOEXCEPT {
+  _LIBCPP_ASSERT_INTERNAL(__x != nullptr, "node shouldn't be null");
+  _LIBCPP_ASSERT_INTERNAL(__x->__left_ != nullptr, "node should have a left child");
+  _NodePtr __y = __x->__left_;
+  __x->__left_ = __y->__right_;
+  if (__x->__left_ != nullptr)
+    __x->__left_->__set_parent(__x);
+  __y->__parent_ = __x->__parent_;
+  if (std::__tree_is_left_child(__x))
+    __x->__parent_->__left_ = __y;
+  else
+    __x->__parent_unsafe()->__right_ = __y;
+  __y->__right_ = __x;
+  __x->__set_parent(__y);
 }
 
 // Effects:  Rebalances __root after attaching __x to a leaf.
@@ -302,68 +277,54 @@ __tree_right_rotate(_NodePtr __x) _NOEXCEPT
 // Postcondition: __tree_invariant(end_node->__left_) == true.  end_node->__left_
 //                may be different than the value passed in as __root.
 template <class _NodePtr>
-_LIBCPP_HIDE_FROM_ABI void
-__tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__root != nullptr, "Root of the tree shouldn't be null");
-    _LIBCPP_ASSERT(__x != nullptr, "Can't attach null node to a leaf");
-    __x->__is_black_ = __x == __root;
-    while (__x != __root && !__x->__parent_unsafe()->__is_black_)
-    {
-        // __x->__parent_ != __root because __x->__parent_->__is_black == false
-        if (_VSTD::__tree_is_left_child(__x->__parent_unsafe()))
-        {
-            _NodePtr __y = __x->__parent_unsafe()->__parent_unsafe()->__right_;
-            if (__y != nullptr && !__y->__is_black_)
-            {
-                __x = __x->__parent_unsafe();
-                __x->__is_black_ = true;
-                __x = __x->__parent_unsafe();
-                __x->__is_black_ = __x == __root;
-                __y->__is_black_ = true;
-            }
-            else
-            {
-                if (!_VSTD::__tree_is_left_child(__x))
-                {
-                    __x = __x->__parent_unsafe();
-                    _VSTD::__tree_left_rotate(__x);
-                }
-                __x = __x->__parent_unsafe();
-                __x->__is_black_ = true;
-                __x = __x->__parent_unsafe();
-                __x->__is_black_ = false;
-                _VSTD::__tree_right_rotate(__x);
-                break;
-            }
+_LIBCPP_HIDE_FROM_ABI void __tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT {
+  _LIBCPP_ASSERT_INTERNAL(__root != nullptr, "Root of the tree shouldn't be null");
+  _LIBCPP_ASSERT_INTERNAL(__x != nullptr, "Can't attach null node to a leaf");
+  __x->__is_black_ = __x == __root;
+  while (__x != __root && !__x->__parent_unsafe()->__is_black_) {
+    // __x->__parent_ != __root because __x->__parent_->__is_black == false
+    if (std::__tree_is_left_child(__x->__parent_unsafe())) {
+      _NodePtr __y = __x->__parent_unsafe()->__parent_unsafe()->__right_;
+      if (__y != nullptr && !__y->__is_black_) {
+        __x              = __x->__parent_unsafe();
+        __x->__is_black_ = true;
+        __x              = __x->__parent_unsafe();
+        __x->__is_black_ = __x == __root;
+        __y->__is_black_ = true;
+      } else {
+        if (!std::__tree_is_left_child(__x)) {
+          __x = __x->__parent_unsafe();
+          std::__tree_left_rotate(__x);
         }
-        else
-        {
-            _NodePtr __y = __x->__parent_unsafe()->__parent_->__left_;
-            if (__y != nullptr && !__y->__is_black_)
-            {
-                __x = __x->__parent_unsafe();
-                __x->__is_black_ = true;
-                __x = __x->__parent_unsafe();
-                __x->__is_black_ = __x == __root;
-                __y->__is_black_ = true;
-            }
-            else
-            {
-                if (_VSTD::__tree_is_left_child(__x))
-                {
-                    __x = __x->__parent_unsafe();
-                    _VSTD::__tree_right_rotate(__x);
-                }
-                __x = __x->__parent_unsafe();
-                __x->__is_black_ = true;
-                __x = __x->__parent_unsafe();
-                __x->__is_black_ = false;
-                _VSTD::__tree_left_rotate(__x);
-                break;
-            }
+        __x              = __x->__parent_unsafe();
+        __x->__is_black_ = true;
+        __x              = __x->__parent_unsafe();
+        __x->__is_black_ = false;
+        std::__tree_right_rotate(__x);
+        break;
+      }
+    } else {
+      _NodePtr __y = __x->__parent_unsafe()->__parent_->__left_;
+      if (__y != nullptr && !__y->__is_black_) {
+        __x              = __x->__parent_unsafe();
+        __x->__is_black_ = true;
+        __x              = __x->__parent_unsafe();
+        __x->__is_black_ = __x == __root;
+        __y->__is_black_ = true;
+      } else {
+        if (std::__tree_is_left_child(__x)) {
+          __x = __x->__parent_unsafe();
+          std::__tree_right_rotate(__x);
         }
+        __x              = __x->__parent_unsafe();
+        __x->__is_black_ = true;
+        __x              = __x->__parent_unsafe();
+        __x->__is_black_ = false;
+        std::__tree_left_rotate(__x);
+        break;
+      }
     }
+  }
 }
 
 // Precondition:  __z == __root or == a direct or indirect child of __root.
@@ -372,205 +333,178 @@ __tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
 //                nor any of its children refer to __z.  end_node->__left_
 //                may be different than the value passed in as __root.
 template <class _NodePtr>
-_LIBCPP_HIDE_FROM_ABI void
-__tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__root != nullptr, "Root node should not be null");
-    _LIBCPP_ASSERT(__z != nullptr, "The node to remove should not be null");
-    _LIBCPP_DEBUG_ASSERT(std::__tree_invariant(__root), "The tree invariants should hold");
-    // __z will be removed from the tree.  Client still needs to destruct/deallocate it
-    // __y is either __z, or if __z has two children, __tree_next(__z).
-    // __y will have at most one child.
-    // __y will be the initial hole in the tree (make the hole at a leaf)
-    _NodePtr __y = (__z->__left_ == nullptr || __z->__right_ == nullptr) ?
-                    __z : _VSTD::__tree_next(__z);
-    // __x is __y's possibly null single child
-    _NodePtr __x = __y->__left_ != nullptr ? __y->__left_ : __y->__right_;
-    // __w is __x's possibly null uncle (will become __x's sibling)
-    _NodePtr __w = nullptr;
-    // link __x to __y's parent, and find __w
-    if (__x != nullptr)
-        __x->__parent_ = __y->__parent_;
-    if (_VSTD::__tree_is_left_child(__y))
-    {
-        __y->__parent_->__left_ = __x;
-        if (__y != __root)
-            __w = __y->__parent_unsafe()->__right_;
-        else
-            __root = __x;  // __w == nullptr
-    }
+_LIBCPP_HIDE_FROM_ABI void __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT {
+  _LIBCPP_ASSERT_INTERNAL(__root != nullptr, "Root node should not be null");
+  _LIBCPP_ASSERT_INTERNAL(__z != nullptr, "The node to remove should not be null");
+  _LIBCPP_ASSERT_INTERNAL(std::__tree_invariant(__root), "The tree invariants should hold");
+  // __z will be removed from the tree.  Client still needs to destruct/deallocate it
+  // __y is either __z, or if __z has two children, __tree_next(__z).
+  // __y will have at most one child.
+  // __y will be the initial hole in the tree (make the hole at a leaf)
+  _NodePtr __y = (__z->__left_ == nullptr || __z->__right_ == nullptr) ? __z : std::__tree_next(__z);
+  // __x is __y's possibly null single child
+  _NodePtr __x = __y->__left_ != nullptr ? __y->__left_ : __y->__right_;
+  // __w is __x's possibly null uncle (will become __x's sibling)
+  _NodePtr __w = nullptr;
+  // link __x to __y's parent, and find __w
+  if (__x != nullptr)
+    __x->__parent_ = __y->__parent_;
+  if (std::__tree_is_left_child(__y)) {
+    __y->__parent_->__left_ = __x;
+    if (__y != __root)
+      __w = __y->__parent_unsafe()->__right_;
     else
-    {
-        __y->__parent_unsafe()->__right_ = __x;
-        // __y can't be root if it is a right child
-        __w = __y->__parent_->__left_;
-    }
-    bool __removed_black = __y->__is_black_;
-    // If we didn't remove __z, do so now by splicing in __y for __z,
-    //    but copy __z's color.  This does not impact __x or __w.
-    if (__y != __z)
-    {
-        // __z->__left_ != nulptr but __z->__right_ might == __x == nullptr
-        __y->__parent_ = __z->__parent_;
-        if (_VSTD::__tree_is_left_child(__z))
-            __y->__parent_->__left_ = __y;
-        else
-            __y->__parent_unsafe()->__right_ = __y;
-        __y->__left_ = __z->__left_;
-        __y->__left_->__set_parent(__y);
-        __y->__right_ = __z->__right_;
-        if (__y->__right_ != nullptr)
-            __y->__right_->__set_parent(__y);
-        __y->__is_black_ = __z->__is_black_;
-        if (__root == __z)
-            __root = __y;
-    }
-    // There is no need to rebalance if we removed a red, or if we removed
-    //     the last node.
-    if (__removed_black && __root != nullptr)
-    {
-        // Rebalance:
-        // __x has an implicit black color (transferred from the removed __y)
-        //    associated with it, no matter what its color is.
-        // If __x is __root (in which case it can't be null), it is supposed
-        //    to be black anyway, and if it is doubly black, then the double
-        //    can just be ignored.
-        // If __x is red (in which case it can't be null), then it can absorb
-        //    the implicit black just by setting its color to black.
-        // Since __y was black and only had one child (which __x points to), __x
-        //   is either red with no children, else null, otherwise __y would have
-        //   different black heights under left and right pointers.
-        // if (__x == __root || __x != nullptr && !__x->__is_black_)
-        if (__x != nullptr)
-            __x->__is_black_ = true;
-        else
+      __root = __x; // __w == nullptr
+  } else {
+    __y->__parent_unsafe()->__right_ = __x;
+    // __y can't be root if it is a right child
+    __w = __y->__parent_->__left_;
+  }
+  bool __removed_black = __y->__is_black_;
+  // If we didn't remove __z, do so now by splicing in __y for __z,
+  //    but copy __z's color.  This does not impact __x or __w.
+  if (__y != __z) {
+    // __z->__left_ != nulptr but __z->__right_ might == __x == nullptr
+    __y->__parent_ = __z->__parent_;
+    if (std::__tree_is_left_child(__z))
+      __y->__parent_->__left_ = __y;
+    else
+      __y->__parent_unsafe()->__right_ = __y;
+    __y->__left_ = __z->__left_;
+    __y->__left_->__set_parent(__y);
+    __y->__right_ = __z->__right_;
+    if (__y->__right_ != nullptr)
+      __y->__right_->__set_parent(__y);
+    __y->__is_black_ = __z->__is_black_;
+    if (__root == __z)
+      __root = __y;
+  }
+  // There is no need to rebalance if we removed a red, or if we removed
+  //     the last node.
+  if (__removed_black && __root != nullptr) {
+    // Rebalance:
+    // __x has an implicit black color (transferred from the removed __y)
+    //    associated with it, no matter what its color is.
+    // If __x is __root (in which case it can't be null), it is supposed
+    //    to be black anyway, and if it is doubly black, then the double
+    //    can just be ignored.
+    // If __x is red (in which case it can't be null), then it can absorb
+    //    the implicit black just by setting its color to black.
+    // Since __y was black and only had one child (which __x points to), __x
+    //   is either red with no children, else null, otherwise __y would have
+    //   different black heights under left and right pointers.
+    // if (__x == __root || __x != nullptr && !__x->__is_black_)
+    if (__x != nullptr)
+      __x->__is_black_ = true;
+    else {
+      //  Else __x isn't root, and is "doubly black", even though it may
+      //     be null.  __w can not be null here, else the parent would
+      //     see a black height >= 2 on the __x side and a black height
+      //     of 1 on the __w side (__w must be a non-null black or a red
+      //     with a non-null black child).
+      while (true) {
+        if (!std::__tree_is_left_child(__w)) // if x is left child
         {
-            //  Else __x isn't root, and is "doubly black", even though it may
-            //     be null.  __w can not be null here, else the parent would
-            //     see a black height >= 2 on the __x side and a black height
-            //     of 1 on the __w side (__w must be a non-null black or a red
-            //     with a non-null black child).
-            while (true)
-            {
-                if (!_VSTD::__tree_is_left_child(__w))  // if x is left child
-                {
-                    if (!__w->__is_black_)
-                    {
-                        __w->__is_black_ = true;
-                        __w->__parent_unsafe()->__is_black_ = false;
-                        _VSTD::__tree_left_rotate(__w->__parent_unsafe());
-                        // __x is still valid
-                        // reset __root only if necessary
-                        if (__root == __w->__left_)
-                            __root = __w;
-                        // reset sibling, and it still can't be null
-                        __w = __w->__left_->__right_;
-                    }
-                    // __w->__is_black_ is now true, __w may have null children
-                    if ((__w->__left_  == nullptr || __w->__left_->__is_black_) &&
-                        (__w->__right_ == nullptr || __w->__right_->__is_black_))
-                    {
-                        __w->__is_black_ = false;
-                        __x = __w->__parent_unsafe();
-                        // __x can no longer be null
-                        if (__x == __root || !__x->__is_black_)
-                        {
-                            __x->__is_black_ = true;
-                            break;
-                        }
-                        // reset sibling, and it still can't be null
-                        __w = _VSTD::__tree_is_left_child(__x) ?
-                                    __x->__parent_unsafe()->__right_ :
-                                    __x->__parent_->__left_;
-                        // continue;
-                    }
-                    else  // __w has a red child
-                    {
-                        if (__w->__right_ == nullptr || __w->__right_->__is_black_)
-                        {
-                            // __w left child is non-null and red
-                            __w->__left_->__is_black_ = true;
-                            __w->__is_black_ = false;
-                            _VSTD::__tree_right_rotate(__w);
-                            // __w is known not to be root, so root hasn't changed
-                            // reset sibling, and it still can't be null
-                            __w = __w->__parent_unsafe();
-                        }
-                        // __w has a right red child, left child may be null
-                        __w->__is_black_ = __w->__parent_unsafe()->__is_black_;
-                        __w->__parent_unsafe()->__is_black_ = true;
-                        __w->__right_->__is_black_ = true;
-                        _VSTD::__tree_left_rotate(__w->__parent_unsafe());
-                        break;
-                    }
-                }
-                else
-                {
-                    if (!__w->__is_black_)
-                    {
-                        __w->__is_black_ = true;
-                        __w->__parent_unsafe()->__is_black_ = false;
-                        _VSTD::__tree_right_rotate(__w->__parent_unsafe());
-                        // __x is still valid
-                        // reset __root only if necessary
-                        if (__root == __w->__right_)
-                            __root = __w;
-                        // reset sibling, and it still can't be null
-                        __w = __w->__right_->__left_;
-                    }
-                    // __w->__is_black_ is now true, __w may have null children
-                    if ((__w->__left_  == nullptr || __w->__left_->__is_black_) &&
-                        (__w->__right_ == nullptr || __w->__right_->__is_black_))
-                    {
-                        __w->__is_black_ = false;
-                        __x = __w->__parent_unsafe();
-                        // __x can no longer be null
-                        if (!__x->__is_black_ || __x == __root)
-                        {
-                            __x->__is_black_ = true;
-                            break;
-                        }
-                        // reset sibling, and it still can't be null
-                        __w = _VSTD::__tree_is_left_child(__x) ?
-                                    __x->__parent_unsafe()->__right_ :
-                                    __x->__parent_->__left_;
-                        // continue;
-                    }
-                    else  // __w has a red child
-                    {
-                        if (__w->__left_ == nullptr || __w->__left_->__is_black_)
-                        {
-                            // __w right child is non-null and red
-                            __w->__right_->__is_black_ = true;
-                            __w->__is_black_ = false;
-                            _VSTD::__tree_left_rotate(__w);
-                            // __w is known not to be root, so root hasn't changed
-                            // reset sibling, and it still can't be null
-                            __w = __w->__parent_unsafe();
-                        }
-                        // __w has a left red child, right child may be null
-                        __w->__is_black_ = __w->__parent_unsafe()->__is_black_;
-                        __w->__parent_unsafe()->__is_black_ = true;
-                        __w->__left_->__is_black_ = true;
-                        _VSTD::__tree_right_rotate(__w->__parent_unsafe());
-                        break;
-                    }
-                }
+          if (!__w->__is_black_) {
+            __w->__is_black_                    = true;
+            __w->__parent_unsafe()->__is_black_ = false;
+            std::__tree_left_rotate(__w->__parent_unsafe());
+            // __x is still valid
+            // reset __root only if necessary
+            if (__root == __w->__left_)
+              __root = __w;
+            // reset sibling, and it still can't be null
+            __w = __w->__left_->__right_;
+          }
+          // __w->__is_black_ is now true, __w may have null children
+          if ((__w->__left_ == nullptr || __w->__left_->__is_black_) &&
+              (__w->__right_ == nullptr || __w->__right_->__is_black_)) {
+            __w->__is_black_ = false;
+            __x              = __w->__parent_unsafe();
+            // __x can no longer be null
+            if (__x == __root || !__x->__is_black_) {
+              __x->__is_black_ = true;
+              break;
             }
+            // reset sibling, and it still can't be null
+            __w = std::__tree_is_left_child(__x) ? __x->__parent_unsafe()->__right_ : __x->__parent_->__left_;
+            // continue;
+          } else // __w has a red child
+          {
+            if (__w->__right_ == nullptr || __w->__right_->__is_black_) {
+              // __w left child is non-null and red
+              __w->__left_->__is_black_ = true;
+              __w->__is_black_          = false;
+              std::__tree_right_rotate(__w);
+              // __w is known not to be root, so root hasn't changed
+              // reset sibling, and it still can't be null
+              __w = __w->__parent_unsafe();
+            }
+            // __w has a right red child, left child may be null
+            __w->__is_black_                    = __w->__parent_unsafe()->__is_black_;
+            __w->__parent_unsafe()->__is_black_ = true;
+            __w->__right_->__is_black_          = true;
+            std::__tree_left_rotate(__w->__parent_unsafe());
+            break;
+          }
+        } else {
+          if (!__w->__is_black_) {
+            __w->__is_black_                    = true;
+            __w->__parent_unsafe()->__is_black_ = false;
+            std::__tree_right_rotate(__w->__parent_unsafe());
+            // __x is still valid
+            // reset __root only if necessary
+            if (__root == __w->__right_)
+              __root = __w;
+            // reset sibling, and it still can't be null
+            __w = __w->__right_->__left_;
+          }
+          // __w->__is_black_ is now true, __w may have null children
+          if ((__w->__left_ == nullptr || __w->__left_->__is_black_) &&
+              (__w->__right_ == nullptr || __w->__right_->__is_black_)) {
+            __w->__is_black_ = false;
+            __x              = __w->__parent_unsafe();
+            // __x can no longer be null
+            if (!__x->__is_black_ || __x == __root) {
+              __x->__is_black_ = true;
+              break;
+            }
+            // reset sibling, and it still can't be null
+            __w = std::__tree_is_left_child(__x) ? __x->__parent_unsafe()->__right_ : __x->__parent_->__left_;
+            // continue;
+          } else // __w has a red child
+          {
+            if (__w->__left_ == nullptr || __w->__left_->__is_black_) {
+              // __w right child is non-null and red
+              __w->__right_->__is_black_ = true;
+              __w->__is_black_           = false;
+              std::__tree_left_rotate(__w);
+              // __w is known not to be root, so root hasn't changed
+              // reset sibling, and it still can't be null
+              __w = __w->__parent_unsafe();
+            }
+            // __w has a left red child, right child may be null
+            __w->__is_black_                    = __w->__parent_unsafe()->__is_black_;
+            __w->__parent_unsafe()->__is_black_ = true;
+            __w->__left_->__is_black_           = true;
+            std::__tree_right_rotate(__w->__parent_unsafe());
+            break;
+          }
         }
+      }
     }
+  }
 }
 
 // node traits
 
-
 template <class _Tp>
 struct __is_tree_value_type_imp : false_type {};
 
 template <class _Key, class _Value>
 struct __is_tree_value_type_imp<__value_type<_Key, _Value> > : true_type {};
 
-template <class ..._Args>
+template <class... _Args>
 struct __is_tree_value_type : false_type {};
 
 template <class _One>
@@ -583,81 +517,55 @@ struct __tree_key_value_types {
   typedef _Tp __container_value_type;
   static const bool __is_map = false;
 
-  _LIBCPP_INLINE_VISIBILITY
-  static key_type const& __get_key(_Tp const& __v) {
-    return __v;
-  }
-  _LIBCPP_INLINE_VISIBILITY
-  static __container_value_type const& __get_value(__node_value_type const& __v) {
-    return __v;
-  }
-  _LIBCPP_INLINE_VISIBILITY
-  static __container_value_type* __get_ptr(__node_value_type& __n) {
-    return _VSTD::addressof(__n);
-  }
-  _LIBCPP_INLINE_VISIBILITY
-  static __container_value_type&& __move(__node_value_type& __v) {
-    return _VSTD::move(__v);
-  }
+  _LIBCPP_HIDE_FROM_ABI static key_type const& __get_key(_Tp const& __v) { return __v; }
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type const& __get_value(__node_value_type const& __v) { return __v; }
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type* __get_ptr(__node_value_type& __n) { return std::addressof(__n); }
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type&& __move(__node_value_type& __v) { return std::move(__v); }
 };
 
 template <class _Key, class _Tp>
 struct __tree_key_value_types<__value_type<_Key, _Tp> > {
-  typedef _Key                                         key_type;
-  typedef _Tp                                          mapped_type;
-  typedef __value_type<_Key, _Tp>                      __node_value_type;
-  typedef pair<const _Key, _Tp>                        __container_value_type;
-  typedef __container_value_type                       __map_value_type;
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef __value_type<_Key, _Tp> __node_value_type;
+  typedef pair<const _Key, _Tp> __container_value_type;
+  typedef __container_value_type __map_value_type;
   static const bool __is_map = true;
 
-  _LIBCPP_INLINE_VISIBILITY
-  static key_type const&
-  __get_key(__node_value_type const& __t) {
+  _LIBCPP_HIDE_FROM_ABI static key_type const& __get_key(__node_value_type const& __t) {
     return __t.__get_value().first;
   }
 
-  template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY
-  static __enable_if_t<__is_same_uncvref<_Up, __container_value_type>::value, key_type const&>
-  __get_key(_Up& __t) {
+  template <class _Up, __enable_if_t<__is_same_uncvref<_Up, __container_value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static key_type const& __get_key(_Up& __t) {
     return __t.first;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  static __container_value_type const&
-  __get_value(__node_value_type const& __t) {
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type const& __get_value(__node_value_type const& __t) {
     return __t.__get_value();
   }
 
-  template <class _Up>
-  _LIBCPP_INLINE_VISIBILITY
-  static __enable_if_t<__is_same_uncvref<_Up, __container_value_type>::value, __container_value_type const&>
-  __get_value(_Up& __t) {
+  template <class _Up, __enable_if_t<__is_same_uncvref<_Up, __container_value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type const& __get_value(_Up& __t) {
     return __t;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  static __container_value_type* __get_ptr(__node_value_type& __n) {
-    return _VSTD::addressof(__n.__get_value());
+  _LIBCPP_HIDE_FROM_ABI static __container_value_type* __get_ptr(__node_value_type& __n) {
+    return std::addressof(__n.__get_value());
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  static pair<key_type&&, mapped_type&&> __move(__node_value_type& __v) {
-    return __v.__move();
-  }
+  _LIBCPP_HIDE_FROM_ABI static pair<key_type&&, mapped_type&&> __move(__node_value_type& __v) { return __v.__move(); }
 };
 
 template <class _VoidPtr>
 struct __tree_node_base_types {
-  typedef _VoidPtr                                               __void_pointer;
+  typedef _VoidPtr __void_pointer;
 
-  typedef __tree_node_base<__void_pointer>                      __node_base_type;
-  typedef __rebind_pointer_t<_VoidPtr, __node_base_type>
-                                                             __node_base_pointer;
+  typedef __tree_node_base<__void_pointer> __node_base_type;
+  typedef __rebind_pointer_t<_VoidPtr, __node_base_type> __node_base_pointer;
 
-  typedef __tree_end_node<__node_base_pointer>                  __end_node_type;
-  typedef __rebind_pointer_t<_VoidPtr, __end_node_type>
-                                                             __end_node_pointer;
+  typedef __tree_end_node<__node_base_pointer> __end_node_type;
+  typedef __rebind_pointer_t<_VoidPtr, __end_node_type> __end_node_pointer;
 #if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB)
   typedef __end_node_pointer __parent_pointer;
 #else
@@ -666,21 +574,18 @@ struct __tree_node_base_types {
 #endif
 
 private:
-  static_assert((is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value),
-                  "_VoidPtr does not point to unqualified void type");
+  static_assert(is_same<typename pointer_traits<_VoidPtr>::element_type, void>::value,
+                "_VoidPtr does not point to unqualified void type");
 };
 
-template <class _Tp, class _AllocPtr, class _KVTypes = __tree_key_value_types<_Tp>,
-         bool = _KVTypes::__is_map>
+template <class _Tp, class _AllocPtr, class _KVTypes = __tree_key_value_types<_Tp>, bool = _KVTypes::__is_map>
 struct __tree_map_pointer_types {};
 
 template <class _Tp, class _AllocPtr, class _KVTypes>
 struct __tree_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> {
-  typedef typename _KVTypes::__map_value_type   _Mv;
-  typedef __rebind_pointer_t<_AllocPtr, _Mv>
-                                                       __map_value_type_pointer;
-  typedef __rebind_pointer_t<_AllocPtr, const _Mv>
-                                                 __const_map_value_type_pointer;
+  typedef typename _KVTypes::__map_value_type _Mv;
+  typedef __rebind_pointer_t<_AllocPtr, _Mv> __map_value_type_pointer;
+  typedef __rebind_pointer_t<_AllocPtr, const _Mv> __const_map_value_type_pointer;
 };
 
 template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>
@@ -688,907 +593,770 @@ struct __tree_node_types;
 
 template <class _NodePtr, class _Tp, class _VoidPtr>
 struct __tree_node_types<_NodePtr, __tree_node<_Tp, _VoidPtr> >
-    : public __tree_node_base_types<_VoidPtr>,
-             __tree_key_value_types<_Tp>,
-             __tree_map_pointer_types<_Tp, _VoidPtr>
-{
+    : public __tree_node_base_types<_VoidPtr>, __tree_key_value_types<_Tp>, __tree_map_pointer_types<_Tp, _VoidPtr> {
   typedef __tree_node_base_types<_VoidPtr> __base;
-  typedef __tree_key_value_types<_Tp>      __key_base;
+  typedef __tree_key_value_types<_Tp> __key_base;
   typedef __tree_map_pointer_types<_Tp, _VoidPtr> __map_pointer_base;
+
 public:
+  typedef typename pointer_traits<_NodePtr>::element_type __node_type;
+  typedef _NodePtr __node_pointer;
 
-  typedef typename pointer_traits<_NodePtr>::element_type       __node_type;
-  typedef _NodePtr                                              __node_pointer;
-
-  typedef _Tp                                                 __node_value_type;
-  typedef __rebind_pointer_t<_VoidPtr, __node_value_type>
-                                                      __node_value_type_pointer;
-  typedef __rebind_pointer_t<_VoidPtr, const __node_value_type>
-                                                __const_node_value_type_pointer;
+  typedef _Tp __node_value_type;
+  typedef __rebind_pointer_t<_VoidPtr, __node_value_type> __node_value_type_pointer;
+  typedef __rebind_pointer_t<_VoidPtr, const __node_value_type> __const_node_value_type_pointer;
 #if defined(_LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB)
   typedef typename __base::__end_node_pointer __iter_pointer;
 #else
   typedef __conditional_t< is_pointer<__node_pointer>::value, typename __base::__end_node_pointer, __node_pointer>
       __iter_pointer;
 #endif
+
 private:
-    static_assert(!is_const<__node_type>::value,
-                "_NodePtr should never be a pointer to const");
-    static_assert((is_same<__rebind_pointer_t<_VoidPtr, __node_type>,
-                          _NodePtr>::value), "_VoidPtr does not rebind to _NodePtr.");
+  static_assert(!is_const<__node_type>::value, "_NodePtr should never be a pointer to const");
+  static_assert(is_same<__rebind_pointer_t<_VoidPtr, __node_type>, _NodePtr>::value,
+                "_VoidPtr does not rebind to _NodePtr.");
 };
 
 template <class _ValueTp, class _VoidPtr>
 struct __make_tree_node_types {
-  typedef __rebind_pointer_t<_VoidPtr, __tree_node<_ValueTp, _VoidPtr> >
-                                                                        _NodePtr;
+  typedef __rebind_pointer_t<_VoidPtr, __tree_node<_ValueTp, _VoidPtr> > _NodePtr;
   typedef __tree_node_types<_NodePtr> type;
 };
 
 // node
 
 template <class _Pointer>
-class __tree_end_node
-{
+class __tree_end_node {
 public:
-    typedef _Pointer pointer;
-    pointer __left_;
+  typedef _Pointer pointer;
+  pointer __left_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_end_node() _NOEXCEPT : __left_() {}
+  _LIBCPP_HIDE_FROM_ABI __tree_end_node() _NOEXCEPT : __left_() {}
 };
 
 template <class _VoidPtr>
-class _LIBCPP_STANDALONE_DEBUG __tree_node_base
-    : public __tree_node_base_types<_VoidPtr>::__end_node_type
-{
-    typedef __tree_node_base_types<_VoidPtr> _NodeBaseTypes;
+class _LIBCPP_STANDALONE_DEBUG __tree_node_base : public __tree_node_base_types<_VoidPtr>::__end_node_type {
+  typedef __tree_node_base_types<_VoidPtr> _NodeBaseTypes;
 
 public:
-    typedef typename _NodeBaseTypes::__node_base_pointer pointer;
-    typedef typename _NodeBaseTypes::__parent_pointer __parent_pointer;
+  typedef typename _NodeBaseTypes::__node_base_pointer pointer;
+  typedef typename _NodeBaseTypes::__parent_pointer __parent_pointer;
 
-    pointer          __right_;
-    __parent_pointer __parent_;
-    bool __is_black_;
+  pointer __right_;
+  __parent_pointer __parent_;
+  bool __is_black_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    pointer __parent_unsafe() const { return static_cast<pointer>(__parent_);}
+  _LIBCPP_HIDE_FROM_ABI pointer __parent_unsafe() const { return static_cast<pointer>(__parent_); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __set_parent(pointer __p) {
-        __parent_ = static_cast<__parent_pointer>(__p);
-    }
+  _LIBCPP_HIDE_FROM_ABI void __set_parent(pointer __p) { __parent_ = static_cast<__parent_pointer>(__p); }
 
-private:
-  ~__tree_node_base() = delete;
-  __tree_node_base(__tree_node_base const&) = delete;
+  ~__tree_node_base()                                  = delete;
+  __tree_node_base(__tree_node_base const&)            = delete;
   __tree_node_base& operator=(__tree_node_base const&) = delete;
 };
 
 template <class _Tp, class _VoidPtr>
-class _LIBCPP_STANDALONE_DEBUG __tree_node
-    : public __tree_node_base<_VoidPtr>
-{
+class _LIBCPP_STANDALONE_DEBUG __tree_node : public __tree_node_base<_VoidPtr> {
 public:
-    typedef _Tp __node_value_type;
+  typedef _Tp __node_value_type;
 
-    __node_value_type __value_;
+  __node_value_type __value_;
 
-private:
-  ~__tree_node() = delete;
-  __tree_node(__tree_node const&) = delete;
+  _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return __value_; }
+
+  ~__tree_node()                             = delete;
+  __tree_node(__tree_node const&)            = delete;
   __tree_node& operator=(__tree_node const&) = delete;
 };
 
-
 template <class _Allocator>
-class __tree_node_destructor
-{
-    typedef _Allocator                                      allocator_type;
-    typedef allocator_traits<allocator_type>                __alloc_traits;
+class __tree_node_destructor {
+  typedef _Allocator allocator_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
 
 public:
-    typedef typename __alloc_traits::pointer                pointer;
+  typedef typename __alloc_traits::pointer pointer;
+
 private:
-    typedef __tree_node_types<pointer> _NodeTypes;
-    allocator_type& __na_;
-
+  typedef __tree_node_types<pointer> _NodeTypes;
+  allocator_type& __na_;
 
 public:
-    bool __value_constructed;
+  bool __value_constructed;
 
+  _LIBCPP_HIDE_FROM_ABI __tree_node_destructor(const __tree_node_destructor&) = default;
+  __tree_node_destructor& operator=(const __tree_node_destructor&)            = delete;
 
-    _LIBCPP_HIDE_FROM_ABI __tree_node_destructor(const __tree_node_destructor &) = default;
-    __tree_node_destructor& operator=(const __tree_node_destructor&) = delete;
+  _LIBCPP_HIDE_FROM_ABI explicit __tree_node_destructor(allocator_type& __na, bool __val = false) _NOEXCEPT
+      : __na_(__na),
+        __value_constructed(__val) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_node_destructor(allocator_type& __na, bool __val = false) _NOEXCEPT
-        : __na_(__na),
-          __value_constructed(__val)
-        {}
+  _LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {
+    if (__value_constructed)
+      __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
+    if (__p)
+      __alloc_traits::deallocate(__na_, __p, 1);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
-    {
-        if (__value_constructed)
-            __alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__value_));
-        if (__p)
-            __alloc_traits::deallocate(__na_, __p, 1);
-    }
-
-    template <class> friend class __map_node_destructor;
+  template <class>
+  friend class __map_node_destructor;
 };
 
 #if _LIBCPP_STD_VER >= 17
 template <class _NodeType, class _Alloc>
 struct __generic_container_node_destructor;
 template <class _Tp, class _VoidPtr, class _Alloc>
-struct __generic_container_node_destructor<__tree_node<_Tp, _VoidPtr>, _Alloc>
-    : __tree_node_destructor<_Alloc>
-{
-    using __tree_node_destructor<_Alloc>::__tree_node_destructor;
+struct __generic_container_node_destructor<__tree_node<_Tp, _VoidPtr>, _Alloc> : __tree_node_destructor<_Alloc> {
+  using __tree_node_destructor<_Alloc>::__tree_node_destructor;
 };
 #endif
 
 template <class _Tp, class _NodePtr, class _DiffType>
-class _LIBCPP_TEMPLATE_VIS __tree_iterator
-{
-    typedef __tree_node_types<_NodePtr>                     _NodeTypes;
-    typedef _NodePtr                                        __node_pointer;
-    typedef typename _NodeTypes::__node_base_pointer        __node_base_pointer;
-    typedef typename _NodeTypes::__end_node_pointer         __end_node_pointer;
-    typedef typename _NodeTypes::__iter_pointer             __iter_pointer;
-    typedef pointer_traits<__node_pointer> __pointer_traits;
+class _LIBCPP_TEMPLATE_VIS __tree_iterator {
+  typedef __tree_node_types<_NodePtr> _NodeTypes;
+  typedef _NodePtr __node_pointer;
+  typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
+  typedef typename _NodeTypes::__end_node_pointer __end_node_pointer;
+  typedef typename _NodeTypes::__iter_pointer __iter_pointer;
+  typedef pointer_traits<__node_pointer> __pointer_traits;
 
-    __iter_pointer __ptr_;
+  __iter_pointer __ptr_;
 
 public:
-    typedef bidirectional_iterator_tag                     iterator_category;
-    typedef _Tp                                            value_type;
-    typedef _DiffType                                      difference_type;
-    typedef value_type&                                    reference;
-    typedef typename _NodeTypes::__node_value_type_pointer pointer;
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef _Tp value_type;
+  typedef _DiffType difference_type;
+  typedef value_type& reference;
+  typedef typename _NodeTypes::__node_value_type_pointer pointer;
 
-    _LIBCPP_INLINE_VISIBILITY __tree_iterator() _NOEXCEPT
+  _LIBCPP_HIDE_FROM_ABI __tree_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER >= 14
-    : __ptr_(nullptr)
+      : __ptr_(nullptr)
 #endif
-    {}
+  {
+  }
 
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const
-        {return __get_np()->__value_;}
-    _LIBCPP_INLINE_VISIBILITY pointer operator->() const
-        {return pointer_traits<pointer>::pointer_to(__get_np()->__value_);}
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__value_; }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__get_np()->__value_); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_iterator& operator++() {
-      __ptr_ = static_cast<__iter_pointer>(
-          _VSTD::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_)));
-      return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_iterator operator++(int)
-        {__tree_iterator __t(*this); ++(*this); return __t;}
+  _LIBCPP_HIDE_FROM_ABI __tree_iterator& operator++() {
+    __ptr_ = static_cast<__iter_pointer>(
+        std::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_)));
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __tree_iterator operator++(int) {
+    __tree_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_iterator& operator--() {
-      __ptr_ = static_cast<__iter_pointer>(_VSTD::__tree_prev_iter<__node_base_pointer>(
-          static_cast<__end_node_pointer>(__ptr_)));
-      return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_iterator operator--(int)
-        {__tree_iterator __t(*this); --(*this); return __t;}
+  _LIBCPP_HIDE_FROM_ABI __tree_iterator& operator--() {
+    __ptr_ = static_cast<__iter_pointer>(
+        std::__tree_prev_iter<__node_base_pointer>(static_cast<__end_node_pointer>(__ptr_)));
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __tree_iterator operator--(int) {
+    __tree_iterator __t(*this);
+    --(*this);
+    return __t;
+  }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const __tree_iterator& __x, const __tree_iterator& __y)
-        {return __x.__ptr_ == __y.__ptr_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const __tree_iterator& __x, const __tree_iterator& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __tree_iterator& __x, const __tree_iterator& __y) {
+    return __x.__ptr_ == __y.__ptr_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __tree_iterator& __x, const __tree_iterator& __y) {
+    return !(__x == __y);
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_iterator(__end_node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
-    template <class, class, class> friend class __tree;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __map_iterator;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
+  _LIBCPP_HIDE_FROM_ABI explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __tree_iterator(__end_node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
+  template <class, class, class>
+  friend class __tree;
+  template <class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __map_iterator;
+  template <class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS map;
+  template <class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS multimap;
+  template <class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS set;
+  template <class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS multiset;
 };
 
 template <class _Tp, class _NodePtr, class _DiffType>
-class _LIBCPP_TEMPLATE_VIS __tree_const_iterator
-{
-    typedef __tree_node_types<_NodePtr>                     _NodeTypes;
-    typedef typename _NodeTypes::__node_pointer             __node_pointer;
-    typedef typename _NodeTypes::__node_base_pointer        __node_base_pointer;
-    typedef typename _NodeTypes::__end_node_pointer         __end_node_pointer;
-    typedef typename _NodeTypes::__iter_pointer             __iter_pointer;
-    typedef pointer_traits<__node_pointer> __pointer_traits;
+class _LIBCPP_TEMPLATE_VIS __tree_const_iterator {
+  typedef __tree_node_types<_NodePtr> _NodeTypes;
+  typedef typename _NodeTypes::__node_pointer __node_pointer;
+  typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
+  typedef typename _NodeTypes::__end_node_pointer __end_node_pointer;
+  typedef typename _NodeTypes::__iter_pointer __iter_pointer;
+  typedef pointer_traits<__node_pointer> __pointer_traits;
 
-    __iter_pointer __ptr_;
+  __iter_pointer __ptr_;
 
 public:
-    typedef bidirectional_iterator_tag                           iterator_category;
-    typedef _Tp                                                  value_type;
-    typedef _DiffType                                            difference_type;
-    typedef const value_type&                                    reference;
-    typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef _Tp value_type;
+  typedef _DiffType difference_type;
+  typedef const value_type& reference;
+  typedef typename _NodeTypes::__const_node_value_type_pointer pointer;
 
-    _LIBCPP_INLINE_VISIBILITY __tree_const_iterator() _NOEXCEPT
+  _LIBCPP_HIDE_FROM_ABI __tree_const_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER >= 14
-    : __ptr_(nullptr)
+      : __ptr_(nullptr)
 #endif
-    {}
+  {
+  }
 
 private:
-    typedef __tree_iterator<value_type, __node_pointer, difference_type>
-                                                           __non_const_iterator;
+  typedef __tree_iterator<value_type, __node_pointer, difference_type> __non_const_iterator;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_const_iterator(__non_const_iterator __p) _NOEXCEPT
-        : __ptr_(__p.__ptr_) {}
+  _LIBCPP_HIDE_FROM_ABI __tree_const_iterator(__non_const_iterator __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}
 
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const
-        {return __get_np()->__value_;}
-    _LIBCPP_INLINE_VISIBILITY pointer operator->() const
-        {return pointer_traits<pointer>::pointer_to(__get_np()->__value_);}
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__value_; }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__get_np()->__value_); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_const_iterator& operator++() {
-      __ptr_ = static_cast<__iter_pointer>(
-          _VSTD::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_)));
-      return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI __tree_const_iterator& operator++() {
+    __ptr_ = static_cast<__iter_pointer>(
+        std::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_)));
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_const_iterator operator++(int)
-        {__tree_const_iterator __t(*this); ++(*this); return __t;}
+  _LIBCPP_HIDE_FROM_ABI __tree_const_iterator operator++(int) {
+    __tree_const_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_const_iterator& operator--() {
-      __ptr_ = static_cast<__iter_pointer>(_VSTD::__tree_prev_iter<__node_base_pointer>(
-          static_cast<__end_node_pointer>(__ptr_)));
-      return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI __tree_const_iterator& operator--() {
+    __ptr_ = static_cast<__iter_pointer>(
+        std::__tree_prev_iter<__node_base_pointer>(static_cast<__end_node_pointer>(__ptr_)));
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __tree_const_iterator operator--(int)
-        {__tree_const_iterator __t(*this); --(*this); return __t;}
+  _LIBCPP_HIDE_FROM_ABI __tree_const_iterator operator--(int) {
+    __tree_const_iterator __t(*this);
+    --(*this);
+    return __t;
+  }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
-        {return __x.__ptr_ == __y.__ptr_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const __tree_const_iterator& __x, const __tree_const_iterator& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __tree_const_iterator& __x, const __tree_const_iterator& __y) {
+    return __x.__ptr_ == __y.__ptr_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __tree_const_iterator& __x, const __tree_const_iterator& __y) {
+    return !(__x == __y);
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT
-        : __ptr_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_const_iterator(__end_node_pointer __p) _NOEXCEPT
-        : __ptr_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
-
-    template <class, class, class> friend class __tree;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS set;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS multiset;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
+  _LIBCPP_HIDE_FROM_ABI explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __tree_const_iterator(__end_node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI __node_pointer __get_np() const { return static_cast<__node_pointer>(__ptr_); }
 
+  template <class, class, class>
+  friend class __tree;
+  template <class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS map;
+  template <class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS multimap;
+  template <class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS set;
+  template <class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS multiset;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
 };
 
-template<class _Tp, class _Compare>
+template <class _Tp, class _Compare>
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_DIAGNOSE_WARNING(!__invokable<_Compare const&, _Tp const&, _Tp const&>::value,
-        "the specified comparator type does not provide a viable const call operator")
+_LIBCPP_DIAGNOSE_WARNING(!__invokable<_Compare const&, _Tp const&, _Tp const&>::value,
+                         "the specified comparator type does not provide a viable const call operator")
 #endif
 int __diagnose_non_const_comparator();
 
 template <class _Tp, class _Compare, class _Allocator>
-class __tree
-{
+class __tree {
 public:
-    typedef _Tp                                      value_type;
-    typedef _Compare                                 value_compare;
-    typedef _Allocator                               allocator_type;
+  typedef _Tp value_type;
+  typedef _Compare value_compare;
+  typedef _Allocator allocator_type;
 
 private:
-    typedef allocator_traits<allocator_type>         __alloc_traits;
-    typedef typename __make_tree_node_types<value_type,
-        typename __alloc_traits::void_pointer>::type
-                                                    _NodeTypes;
-    typedef typename _NodeTypes::key_type           key_type;
-public:
-    typedef typename _NodeTypes::__node_value_type      __node_value_type;
-    typedef typename _NodeTypes::__container_value_type __container_value_type;
-
-    typedef typename __alloc_traits::pointer         pointer;
-    typedef typename __alloc_traits::const_pointer   const_pointer;
-    typedef typename __alloc_traits::size_type       size_type;
-    typedef typename __alloc_traits::difference_type difference_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
+  typedef typename __make_tree_node_types<value_type, typename __alloc_traits::void_pointer>::type _NodeTypes;
+  typedef typename _NodeTypes::key_type key_type;
 
 public:
-    typedef typename _NodeTypes::__void_pointer        __void_pointer;
+  typedef typename _NodeTypes::__node_value_type __node_value_type;
+  typedef typename _NodeTypes::__container_value_type __container_value_type;
 
-    typedef typename _NodeTypes::__node_type           __node;
-    typedef typename _NodeTypes::__node_pointer        __node_pointer;
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
+  typedef typename __alloc_traits::size_type size_type;
+  typedef typename __alloc_traits::difference_type difference_type;
 
-    typedef typename _NodeTypes::__node_base_type      __node_base;
-    typedef typename _NodeTypes::__node_base_pointer   __node_base_pointer;
+public:
+  typedef typename _NodeTypes::__void_pointer __void_pointer;
 
-    typedef typename _NodeTypes::__end_node_type       __end_node_t;
-    typedef typename _NodeTypes::__end_node_pointer    __end_node_ptr;
+  typedef typename _NodeTypes::__node_type __node;
+  typedef typename _NodeTypes::__node_pointer __node_pointer;
 
-    typedef typename _NodeTypes::__parent_pointer      __parent_pointer;
-    typedef typename _NodeTypes::__iter_pointer        __iter_pointer;
+  typedef typename _NodeTypes::__node_base_type __node_base;
+  typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;
 
-    typedef __rebind_alloc<__alloc_traits, __node> __node_allocator;
-    typedef allocator_traits<__node_allocator>         __node_traits;
+  typedef typename _NodeTypes::__end_node_type __end_node_t;
+  typedef typename _NodeTypes::__end_node_pointer __end_node_ptr;
+
+  typedef typename _NodeTypes::__parent_pointer __parent_pointer;
+  typedef typename _NodeTypes::__iter_pointer __iter_pointer;
+
+  typedef __rebind_alloc<__alloc_traits, __node> __node_allocator;
+  typedef allocator_traits<__node_allocator> __node_traits;
 
 private:
-    // check for sane allocator pointer rebinding semantics. Rebinding the
-    // allocator for a new pointer type should be exactly the same as rebinding
-    // the pointer using 'pointer_traits'.
-    static_assert((is_same<__node_pointer, typename __node_traits::pointer>::value),
-                  "Allocator does not rebind pointers in a sane manner.");
-    typedef __rebind_alloc<__node_traits, __node_base> __node_base_allocator;
-    typedef allocator_traits<__node_base_allocator> __node_base_traits;
-    static_assert((is_same<__node_base_pointer, typename __node_base_traits::pointer>::value),
-                 "Allocator does not rebind pointers in a sane manner.");
+  // check for sane allocator pointer rebinding semantics. Rebinding the
+  // allocator for a new pointer type should be exactly the same as rebinding
+  // the pointer using 'pointer_traits'.
+  static_assert(is_same<__node_pointer, typename __node_traits::pointer>::value,
+                "Allocator does not rebind pointers in a sane manner.");
+  typedef __rebind_alloc<__node_traits, __node_base> __node_base_allocator;
+  typedef allocator_traits<__node_base_allocator> __node_base_traits;
+  static_assert(is_same<__node_base_pointer, typename __node_base_traits::pointer>::value,
+                "Allocator does not rebind pointers in a sane manner.");
 
 private:
-    __iter_pointer                                     __begin_node_;
-    __compressed_pair<__end_node_t, __node_allocator>  __pair1_;
-    __compressed_pair<size_type, value_compare>        __pair3_;
+  __iter_pointer __begin_node_;
+  __compressed_pair<__end_node_t, __node_allocator> __pair1_;
+  __compressed_pair<size_type, value_compare> __pair3_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __iter_pointer __end_node() _NOEXCEPT
-    {
-        return static_cast<__iter_pointer>(
-                pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first())
-        );
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __iter_pointer __end_node() const _NOEXCEPT
-    {
-        return static_cast<__iter_pointer>(
-            pointer_traits<__end_node_ptr>::pointer_to(
-                const_cast<__end_node_t&>(__pair1_.first())
-            )
-        );
-    }
-    _LIBCPP_INLINE_VISIBILITY
-          __node_allocator& __node_alloc() _NOEXCEPT {return __pair1_.second();}
+  _LIBCPP_HIDE_FROM_ABI __iter_pointer __end_node() _NOEXCEPT {
+    return static_cast<__iter_pointer>(pointer_traits<__end_node_ptr>::pointer_to(__pair1_.first()));
+  }
+  _LIBCPP_HIDE_FROM_ABI __iter_pointer __end_node() const _NOEXCEPT {
+    return static_cast<__iter_pointer>(
+        pointer_traits<__end_node_ptr>::pointer_to(const_cast<__end_node_t&>(__pair1_.first())));
+  }
+  _LIBCPP_HIDE_FROM_ABI __node_allocator& __node_alloc() _NOEXCEPT { return __pair1_.second(); }
+
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    const __node_allocator& __node_alloc() const _NOEXCEPT
-        {return __pair1_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-          __iter_pointer& __begin_node() _NOEXCEPT {return __begin_node_;}
-    _LIBCPP_INLINE_VISIBILITY
-    const __iter_pointer& __begin_node() const _NOEXCEPT {return __begin_node_;}
+  _LIBCPP_HIDE_FROM_ABI const __node_allocator& __node_alloc() const _NOEXCEPT { return __pair1_.second(); }
+  _LIBCPP_HIDE_FROM_ABI __iter_pointer& __begin_node() _NOEXCEPT { return __begin_node_; }
+  _LIBCPP_HIDE_FROM_ABI const __iter_pointer& __begin_node() const _NOEXCEPT { return __begin_node_; }
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type __alloc() const _NOEXCEPT
-        {return allocator_type(__node_alloc());}
+  _LIBCPP_HIDE_FROM_ABI allocator_type __alloc() const _NOEXCEPT { return allocator_type(__node_alloc()); }
+
 private:
-    _LIBCPP_INLINE_VISIBILITY
-          size_type& size() _NOEXCEPT {return __pair3_.first();}
+  _LIBCPP_HIDE_FROM_ABI size_type& size() _NOEXCEPT { return __pair3_.first(); }
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    const size_type& size() const _NOEXCEPT {return __pair3_.first();}
-    _LIBCPP_INLINE_VISIBILITY
-          value_compare& value_comp() _NOEXCEPT {return __pair3_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const value_compare& value_comp() const _NOEXCEPT
-        {return __pair3_.second();}
+  _LIBCPP_HIDE_FROM_ABI const size_type& size() const _NOEXCEPT { return __pair3_.first(); }
+  _LIBCPP_HIDE_FROM_ABI value_compare& value_comp() _NOEXCEPT { return __pair3_.second(); }
+  _LIBCPP_HIDE_FROM_ABI const value_compare& value_comp() const _NOEXCEPT { return __pair3_.second(); }
+
 public:
+  _LIBCPP_HIDE_FROM_ABI __node_pointer __root() const _NOEXCEPT {
+    return static_cast<__node_pointer>(__end_node()->__left_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __root() const _NOEXCEPT
-        {return static_cast<__node_pointer>(__end_node()->__left_);}
+  _LIBCPP_HIDE_FROM_ABI __node_base_pointer* __root_ptr() const _NOEXCEPT {
+    return std::addressof(__end_node()->__left_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI __node_base_pointer* __root_ptr() const _NOEXCEPT {
-        return _VSTD::addressof(__end_node()->__left_);
-    }
+  typedef __tree_iterator<value_type, __node_pointer, difference_type> iterator;
+  typedef __tree_const_iterator<value_type, __node_pointer, difference_type> const_iterator;
 
-    typedef __tree_iterator<value_type, __node_pointer, difference_type>             iterator;
-    typedef __tree_const_iterator<value_type, __node_pointer, difference_type> const_iterator;
+  _LIBCPP_HIDE_FROM_ABI explicit __tree(const value_compare& __comp) _NOEXCEPT_(
+      is_nothrow_default_constructible<__node_allocator>::value&& is_nothrow_copy_constructible<value_compare>::value);
+  _LIBCPP_HIDE_FROM_ABI explicit __tree(const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI __tree(const value_compare& __comp, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI __tree(const __tree& __t);
+  _LIBCPP_HIDE_FROM_ABI __tree& operator=(const __tree& __t);
+  template <class _ForwardIterator>
+  _LIBCPP_HIDE_FROM_ABI void __assign_unique(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void __assign_multi(_InputIterator __first, _InputIterator __last);
+  _LIBCPP_HIDE_FROM_ABI __tree(__tree&& __t) _NOEXCEPT_(
+      is_nothrow_move_constructible<__node_allocator>::value&& is_nothrow_move_constructible<value_compare>::value);
+  _LIBCPP_HIDE_FROM_ABI __tree(__tree&& __t, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI __tree& operator=(__tree&& __t) _NOEXCEPT_(
+      __node_traits::propagate_on_container_move_assignment::value&& is_nothrow_move_assignable<value_compare>::value&&
+          is_nothrow_move_assignable<__node_allocator>::value);
+  _LIBCPP_HIDE_FROM_ABI ~__tree();
 
-    _LIBCPP_HIDE_FROM_ABI explicit __tree(const value_compare& __comp)
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<__node_allocator>::value &&
-            is_nothrow_copy_constructible<value_compare>::value);
-    _LIBCPP_HIDE_FROM_ABI explicit __tree(const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI __tree(const value_compare& __comp, const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI __tree(const __tree& __t);
-    _LIBCPP_HIDE_FROM_ABI __tree& operator=(const __tree& __t);
-    template <class _ForwardIterator>
-    _LIBCPP_HIDE_FROM_ABI void __assign_unique(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI void __assign_multi(_InputIterator __first, _InputIterator __last);
-    _LIBCPP_HIDE_FROM_ABI __tree(__tree&& __t)
-        _NOEXCEPT_(
-            is_nothrow_move_constructible<__node_allocator>::value &&
-            is_nothrow_move_constructible<value_compare>::value);
-    _LIBCPP_HIDE_FROM_ABI __tree(__tree&& __t, const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI __tree& operator=(__tree&& __t)
-        _NOEXCEPT_(
-            __node_traits::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<value_compare>::value &&
-            is_nothrow_move_assignable<__node_allocator>::value);
-    _LIBCPP_HIDE_FROM_ABI ~__tree();
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return iterator(__begin_node()); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return const_iterator(__begin_node()); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return iterator(__end_node()); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return const_iterator(__end_node()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-          iterator begin()  _NOEXCEPT {return       iterator(__begin_node());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return const_iterator(__begin_node());}
-    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT {return       iterator(__end_node());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT {return const_iterator(__end_node());}
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+    return std::min<size_type>(__node_traits::max_size(__node_alloc()), numeric_limits<difference_type >::max());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT
-        {return _VSTD::min<size_type>(
-                __node_traits::max_size(__node_alloc()),
-                numeric_limits<difference_type >::max());}
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT;
-
-    _LIBCPP_HIDE_FROM_ABI void swap(__tree& __t)
+  _LIBCPP_HIDE_FROM_ABI void swap(__tree& __t)
 #if _LIBCPP_STD_VER <= 11
-        _NOEXCEPT_(
-            __is_nothrow_swappable<value_compare>::value
-            && (!__node_traits::propagate_on_container_swap::value ||
-                 __is_nothrow_swappable<__node_allocator>::value)
-            );
+      _NOEXCEPT_(__is_nothrow_swappable_v<value_compare> &&
+                 (!__node_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<__node_allocator>));
 #else
-        _NOEXCEPT_(__is_nothrow_swappable<value_compare>::value);
+      _NOEXCEPT_(__is_nothrow_swappable_v<value_compare>);
 #endif
 
-    template <class _Key, class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI pair<iterator, bool>
-    __emplace_unique_key_args(_Key const&, _Args&&... __args);
-    template <class _Key, class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI pair<iterator, bool>
-    __emplace_hint_unique_key_args(const_iterator, _Key const&, _Args&&...);
+  template <class _Key, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_key_args(_Key const&, _Args&&... __args);
+  template <class _Key, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_hint_unique_key_args(const_iterator, _Key const&, _Args&&...);
 
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);
 
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_unique_impl(const_iterator __p, _Args&&... __args);
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_unique_impl(const_iterator __p, _Args&&... __args);
 
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI iterator __emplace_multi(_Args&&... __args);
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator __emplace_multi(_Args&&... __args);
 
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __emplace_unique(_Pp&& __x) {
-        return __emplace_unique_extract_key(_VSTD::forward<_Pp>(__x),
-                                            __can_extract_key<_Pp, key_type>());
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_Pp&& __x) {
+    return __emplace_unique_extract_key(std::forward<_Pp>(__x), __can_extract_key<_Pp, key_type>());
+  }
 
-    template <class _First, class _Second>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__can_extract_map_key<_First, key_type, __container_value_type>::value, pair<iterator, bool> >
-    __emplace_unique(_First&& __f, _Second&& __s) {
-        return __emplace_unique_key_args(__f, _VSTD::forward<_First>(__f),
-                                              _VSTD::forward<_Second>(__s));
-    }
+  template <class _First,
+            class _Second,
+            __enable_if_t<__can_extract_map_key<_First, key_type, __container_value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_First&& __f, _Second&& __s) {
+    return __emplace_unique_key_args(__f, std::forward<_First>(__f), std::forward<_Second>(__s));
+  }
 
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __emplace_unique(_Args&&... __args) {
-        return __emplace_unique_impl(_VSTD::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_Args&&... __args) {
+    return __emplace_unique_impl(std::forward<_Args>(__args)...);
+  }
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool>
-    __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {
-      return __emplace_unique_impl(_VSTD::forward<_Pp>(__x));
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {
+    return __emplace_unique_impl(std::forward<_Pp>(__x));
+  }
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool>
-    __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {
-      return __emplace_unique_key_args(__x, _VSTD::forward<_Pp>(__x));
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {
+    return __emplace_unique_key_args(__x, std::forward<_Pp>(__x));
+  }
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool>
-    __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {
-      return __emplace_unique_key_args(__x.first, _VSTD::forward<_Pp>(__x));
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {
+    return __emplace_unique_key_args(__x.first, std::forward<_Pp>(__x));
+  }
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __emplace_hint_unique(const_iterator __p, _Pp&& __x) {
-        return __emplace_hint_unique_extract_key(__p, _VSTD::forward<_Pp>(__x),
-                                            __can_extract_key<_Pp, key_type>());
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_unique(const_iterator __p, _Pp&& __x) {
+    return __emplace_hint_unique_extract_key(__p, std::forward<_Pp>(__x), __can_extract_key<_Pp, key_type>());
+  }
 
-    template <class _First, class _Second>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__can_extract_map_key<_First, key_type, __container_value_type>::value, iterator>
-    __emplace_hint_unique(const_iterator __p, _First&& __f, _Second&& __s) {
-        return __emplace_hint_unique_key_args(__p, __f,
-                                              _VSTD::forward<_First>(__f),
-                                              _VSTD::forward<_Second>(__s)).first;
-    }
+  template <class _First,
+            class _Second,
+            __enable_if_t<__can_extract_map_key<_First, key_type, __container_value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_unique(const_iterator __p, _First&& __f, _Second&& __s) {
+    return __emplace_hint_unique_key_args(__p, __f, std::forward<_First>(__f), std::forward<_Second>(__s)).first;
+  }
 
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __emplace_hint_unique(const_iterator __p, _Args&&... __args) {
-        return __emplace_hint_unique_impl(__p, _VSTD::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_unique(const_iterator __p, _Args&&... __args) {
+    return __emplace_hint_unique_impl(__p, std::forward<_Args>(__args)...);
+  }
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator
-    __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_fail_tag) {
-      return __emplace_hint_unique_impl(__p, _VSTD::forward<_Pp>(__x));
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI iterator
+  __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_fail_tag) {
+    return __emplace_hint_unique_impl(__p, std::forward<_Pp>(__x));
+  }
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator
-    __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_self_tag) {
-      return __emplace_hint_unique_key_args(__p, __x, _VSTD::forward<_Pp>(__x)).first;
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI iterator
+  __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_self_tag) {
+    return __emplace_hint_unique_key_args(__p, __x, std::forward<_Pp>(__x)).first;
+  }
 
-    template <class _Pp>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator
-    __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_first_tag) {
-      return __emplace_hint_unique_key_args(__p, __x.first, _VSTD::forward<_Pp>(__x)).first;
-    }
+  template <class _Pp>
+  _LIBCPP_HIDE_FROM_ABI iterator
+  __emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_first_tag) {
+    return __emplace_hint_unique_key_args(__p, __x.first, std::forward<_Pp>(__x)).first;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __insert_unique(const __container_value_type& __v) {
-        return __emplace_unique_key_args(_NodeTypes::__get_key(__v), __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __insert_unique(const __container_value_type& __v) {
+    return __emplace_unique_key_args(_NodeTypes::__get_key(__v), __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __insert_unique(const_iterator __p, const __container_value_type& __v) {
-        return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), __v).first;
-    }
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_unique(const_iterator __p, const __container_value_type& __v) {
+    return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), __v).first;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __insert_unique(__container_value_type&& __v) {
-        return __emplace_unique_key_args(_NodeTypes::__get_key(__v), _VSTD::move(__v));
-    }
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __insert_unique(__container_value_type&& __v) {
+    return __emplace_unique_key_args(_NodeTypes::__get_key(__v), std::move(__v));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __insert_unique(const_iterator __p, __container_value_type&& __v) {
-        return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), _VSTD::move(__v)).first;
-    }
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_unique(const_iterator __p, __container_value_type&& __v) {
+    return __emplace_hint_unique_key_args(__p, _NodeTypes::__get_key(__v), std::move(__v)).first;
+  }
 
-    template <class _Vp,
-              class = __enable_if_t<!is_same<__remove_const_ref_t<_Vp>, __container_value_type>::value> >
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __insert_unique(_Vp&& __v) {
-        return __emplace_unique(_VSTD::forward<_Vp>(__v));
-    }
+  template <class _Vp, __enable_if_t<!is_same<__remove_const_ref_t<_Vp>, __container_value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __insert_unique(_Vp&& __v) {
+    return __emplace_unique(std::forward<_Vp>(__v));
+  }
 
-    template <class _Vp,
-              class = __enable_if_t<!is_same<__remove_const_ref_t<_Vp>, __container_value_type>::value> >
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __insert_unique(const_iterator __p, _Vp&& __v) {
-        return __emplace_hint_unique(__p, _VSTD::forward<_Vp>(__v));
-    }
+  template <class _Vp, __enable_if_t<!is_same<__remove_const_ref_t<_Vp>, __container_value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_unique(const_iterator __p, _Vp&& __v) {
+    return __emplace_hint_unique(__p, std::forward<_Vp>(__v));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __insert_multi(__container_value_type&& __v) {
-        return __emplace_multi(_VSTD::move(__v));
-    }
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_multi(__container_value_type&& __v) {
+    return __emplace_multi(std::move(__v));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __insert_multi(const_iterator __p, __container_value_type&& __v) {
-        return __emplace_hint_multi(__p, _VSTD::move(__v));
-    }
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_multi(const_iterator __p, __container_value_type&& __v) {
+    return __emplace_hint_multi(__p, std::move(__v));
+  }
 
-    template <class _Vp>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __insert_multi(_Vp&& __v) {
-        return __emplace_multi(_VSTD::forward<_Vp>(__v));
-    }
+  template <class _Vp>
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_multi(_Vp&& __v) {
+    return __emplace_multi(std::forward<_Vp>(__v));
+  }
 
-    template <class _Vp>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __insert_multi(const_iterator __p, _Vp&& __v) {
-        return __emplace_hint_multi(__p, _VSTD::forward<_Vp>(__v));
-    }
+  template <class _Vp>
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_multi(const_iterator __p, _Vp&& __v) {
+    return __emplace_hint_multi(__p, std::forward<_Vp>(__v));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> __node_assign_unique(const __container_value_type& __v, __node_pointer __dest);
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool>
+  __node_assign_unique(const __container_value_type& __v, __node_pointer __dest);
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __node_insert_multi(__node_pointer __nd);
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __node_insert_multi(const_iterator __p, __node_pointer __nd);
+  _LIBCPP_HIDE_FROM_ABI iterator __node_insert_multi(__node_pointer __nd);
+  _LIBCPP_HIDE_FROM_ABI iterator __node_insert_multi(const_iterator __p, __node_pointer __nd);
 
-
-    _LIBCPP_INLINE_VISIBILITY iterator
-    __remove_node_pointer(__node_pointer) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI iterator __remove_node_pointer(__node_pointer) _NOEXCEPT;
 
 #if _LIBCPP_STD_VER >= 17
-    template <class _NodeHandle, class _InsertReturnType>
-    _LIBCPP_INLINE_VISIBILITY
-    _InsertReturnType __node_handle_insert_unique(_NodeHandle&&);
-    template <class _NodeHandle>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __node_handle_insert_unique(const_iterator, _NodeHandle&&);
-    template <class _Tree>
-    _LIBCPP_INLINE_VISIBILITY
-    void __node_handle_merge_unique(_Tree& __source);
+  template <class _NodeHandle, class _InsertReturnType>
+  _LIBCPP_HIDE_FROM_ABI _InsertReturnType __node_handle_insert_unique(_NodeHandle&&);
+  template <class _NodeHandle>
+  _LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_unique(const_iterator, _NodeHandle&&);
+  template <class _Tree>
+  _LIBCPP_HIDE_FROM_ABI void __node_handle_merge_unique(_Tree& __source);
 
-    template <class _NodeHandle>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __node_handle_insert_multi(_NodeHandle&&);
-    template <class _NodeHandle>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator __node_handle_insert_multi(const_iterator, _NodeHandle&&);
-    template <class _Tree>
-    _LIBCPP_INLINE_VISIBILITY
-    void __node_handle_merge_multi(_Tree& __source);
+  template <class _NodeHandle>
+  _LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_multi(_NodeHandle&&);
+  template <class _NodeHandle>
+  _LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_multi(const_iterator, _NodeHandle&&);
+  template <class _Tree>
+  _LIBCPP_HIDE_FROM_ABI void __node_handle_merge_multi(_Tree& __source);
 
-
-    template <class _NodeHandle>
-    _LIBCPP_INLINE_VISIBILITY
-    _NodeHandle __node_handle_extract(key_type const&);
-    template <class _NodeHandle>
-    _LIBCPP_INLINE_VISIBILITY
-    _NodeHandle __node_handle_extract(const_iterator);
+  template <class _NodeHandle>
+  _LIBCPP_HIDE_FROM_ABI _NodeHandle __node_handle_extract(key_type const&);
+  template <class _NodeHandle>
+  _LIBCPP_HIDE_FROM_ABI _NodeHandle __node_handle_extract(const_iterator);
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
-    _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l);
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI size_type __erase_unique(const _Key& __k);
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI size_type __erase_multi(const _Key& __k);
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI size_type __erase_unique(const _Key& __k);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI size_type __erase_multi(const _Key& __k);
 
-    _LIBCPP_HIDE_FROM_ABI void __insert_node_at(__parent_pointer     __parent,
-                          __node_base_pointer& __child,
-                          __node_base_pointer __new_node) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void
+  __insert_node_at(__parent_pointer __parent, __node_base_pointer& __child, __node_base_pointer __new_node) _NOEXCEPT;
 
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI iterator find(const _Key& __v);
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI const_iterator find(const _Key& __v) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI iterator find(const _Key& __v);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _Key& __v) const;
 
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI size_type __count_unique(const _Key& __k) const;
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI size_type __count_multi(const _Key& __k) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI size_type __count_unique(const _Key& __k) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI size_type __count_multi(const _Key& __k) const;
 
-    template <class _Key>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator lower_bound(const _Key& __v)
-            {return __lower_bound(__v, __root(), __end_node());}
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI iterator __lower_bound(const _Key& __v,
-                               __node_pointer __root,
-                               __iter_pointer __result);
-    template <class _Key>
-        _LIBCPP_INLINE_VISIBILITY
-        const_iterator lower_bound(const _Key& __v) const
-            {return __lower_bound(__v, __root(), __end_node());}
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI const_iterator __lower_bound(const _Key& __v,
-                                     __node_pointer __root,
-                                     __iter_pointer __result) const;
-    template <class _Key>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator upper_bound(const _Key& __v)
-            {return __upper_bound(__v, __root(), __end_node());}
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI iterator __upper_bound(const _Key& __v,
-                               __node_pointer __root,
-                               __iter_pointer __result);
-    template <class _Key>
-        _LIBCPP_INLINE_VISIBILITY
-        const_iterator upper_bound(const _Key& __v) const
-            {return __upper_bound(__v, __root(), __end_node());}
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI const_iterator __upper_bound(const _Key& __v,
-                                     __node_pointer __root,
-                                     __iter_pointer __result) const;
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator>
-        __equal_range_unique(const _Key& __k);
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator>
-        __equal_range_unique(const _Key& __k) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _Key& __v) {
+    return __lower_bound(__v, __root(), __end_node());
+  }
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI iterator __lower_bound(const _Key& __v, __node_pointer __root, __iter_pointer __result);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _Key& __v) const {
+    return __lower_bound(__v, __root(), __end_node());
+  }
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI const_iterator
+  __lower_bound(const _Key& __v, __node_pointer __root, __iter_pointer __result) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _Key& __v) {
+    return __upper_bound(__v, __root(), __end_node());
+  }
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI iterator __upper_bound(const _Key& __v, __node_pointer __root, __iter_pointer __result);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _Key& __v) const {
+    return __upper_bound(__v, __root(), __end_node());
+  }
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI const_iterator
+  __upper_bound(const _Key& __v, __node_pointer __root, __iter_pointer __result) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> __equal_range_unique(const _Key& __k);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> __equal_range_unique(const _Key& __k) const;
 
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator>
-        __equal_range_multi(const _Key& __k);
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator>
-        __equal_range_multi(const _Key& __k) const;
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> __equal_range_multi(const _Key& __k);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> __equal_range_multi(const _Key& __k) const;
 
-    typedef __tree_node_destructor<__node_allocator> _Dp;
-    typedef unique_ptr<__node, _Dp> __node_holder;
+  typedef __tree_node_destructor<__node_allocator> _Dp;
+  typedef unique_ptr<__node, _Dp> __node_holder;
+
+  _LIBCPP_HIDE_FROM_ABI __node_holder remove(const_iterator __p) _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI __node_holder remove(const_iterator __p) _NOEXCEPT;
 private:
-    _LIBCPP_HIDE_FROM_ABI __node_base_pointer& __find_leaf_low(__parent_pointer& __parent, const key_type& __v);
-    _LIBCPP_HIDE_FROM_ABI __node_base_pointer& __find_leaf_high(__parent_pointer& __parent, const key_type& __v);
-    _LIBCPP_HIDE_FROM_ABI __node_base_pointer&
-    __find_leaf(const_iterator __hint, __parent_pointer& __parent, const key_type& __v);
-    // FIXME: Make this function const qualified. Unfortunately doing so
-    // breaks existing code which uses non-const callable comparators.
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI __node_base_pointer& __find_equal(__parent_pointer& __parent, const _Key& __v);
-    template <class _Key>
-    _LIBCPP_INLINE_VISIBILITY __node_base_pointer&
-    __find_equal(__parent_pointer& __parent, const _Key& __v) const {
-      return const_cast<__tree*>(this)->__find_equal(__parent, __v);
+  _LIBCPP_HIDE_FROM_ABI __node_base_pointer& __find_leaf_low(__parent_pointer& __parent, const key_type& __v);
+  _LIBCPP_HIDE_FROM_ABI __node_base_pointer& __find_leaf_high(__parent_pointer& __parent, const key_type& __v);
+  _LIBCPP_HIDE_FROM_ABI __node_base_pointer&
+  __find_leaf(const_iterator __hint, __parent_pointer& __parent, const key_type& __v);
+  // FIXME: Make this function const qualified. Unfortunately doing so
+  // breaks existing code which uses non-const callable comparators.
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI __node_base_pointer& __find_equal(__parent_pointer& __parent, const _Key& __v);
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI __node_base_pointer& __find_equal(__parent_pointer& __parent, const _Key& __v) const {
+    return const_cast<__tree*>(this)->__find_equal(__parent, __v);
+  }
+  template <class _Key>
+  _LIBCPP_HIDE_FROM_ABI __node_base_pointer&
+  __find_equal(const_iterator __hint, __parent_pointer& __parent, __node_base_pointer& __dummy, const _Key& __v);
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node(_Args&&... __args);
+
+  // TODO: Make this _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDDEN void destroy(__node_pointer __nd) _NOEXCEPT;
+
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __tree& __t) {
+    __copy_assign_alloc(__t, integral_constant<bool, __node_traits::propagate_on_container_copy_assignment::value>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __tree& __t, true_type) {
+    if (__node_alloc() != __t.__node_alloc())
+      clear();
+    __node_alloc() = __t.__node_alloc();
+  }
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __tree&, false_type) {}
+
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(__tree& __t, false_type);
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(__tree& __t, true_type) _NOEXCEPT_(
+      is_nothrow_move_assignable<value_compare>::value&& is_nothrow_move_assignable<__node_allocator>::value);
+
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__tree& __t)
+      _NOEXCEPT_(!__node_traits::propagate_on_container_move_assignment::value ||
+                 is_nothrow_move_assignable<__node_allocator>::value) {
+    __move_assign_alloc(__t, integral_constant<bool, __node_traits::propagate_on_container_move_assignment::value>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__tree& __t, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value) {
+    __node_alloc() = std::move(__t.__node_alloc());
+  }
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__tree&, false_type) _NOEXCEPT {}
+
+  struct _DetachedTreeCache {
+    _LIBCPP_HIDE_FROM_ABI explicit _DetachedTreeCache(__tree* __t) _NOEXCEPT
+        : __t_(__t),
+          __cache_root_(__detach_from_tree(__t)) {
+      __advance();
     }
-    template <class _Key>
-    _LIBCPP_HIDE_FROM_ABI __node_base_pointer&
-        __find_equal(const_iterator __hint, __parent_pointer& __parent,
-                     __node_base_pointer& __dummy,
-                     const _Key& __v);
 
-    template <class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node(_Args&& ...__args);
+    _LIBCPP_HIDE_FROM_ABI __node_pointer __get() const _NOEXCEPT { return __cache_elem_; }
 
-    // TODO: Make this _LIBCPP_HIDE_FROM_ABI
-    _LIBCPP_HIDDEN void destroy(__node_pointer __nd) _NOEXCEPT;
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const __tree& __t)
-        {__copy_assign_alloc(__t, integral_constant<bool,
-             __node_traits::propagate_on_container_copy_assignment::value>());}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const __tree& __t, true_type)
-        {
-        if (__node_alloc() != __t.__node_alloc())
-            clear();
-        __node_alloc() = __t.__node_alloc();
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const __tree&, false_type) {}
-
-    _LIBCPP_HIDE_FROM_ABI void __move_assign(__tree& __t, false_type);
-    _LIBCPP_HIDE_FROM_ABI void __move_assign(__tree& __t, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
-                   is_nothrow_move_assignable<__node_allocator>::value);
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__tree& __t)
-        _NOEXCEPT_(
-            !__node_traits::propagate_on_container_move_assignment::value ||
-            is_nothrow_move_assignable<__node_allocator>::value)
-        {__move_assign_alloc(__t, integral_constant<bool,
-             __node_traits::propagate_on_container_move_assignment::value>());}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__tree& __t, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
-        {__node_alloc() = _VSTD::move(__t.__node_alloc());}
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__tree&, false_type) _NOEXCEPT {}
-
-    struct _DetachedTreeCache {
-      _LIBCPP_INLINE_VISIBILITY
-      explicit _DetachedTreeCache(__tree *__t) _NOEXCEPT : __t_(__t),
-        __cache_root_(__detach_from_tree(__t)) {
-          __advance();
-        }
-
-      _LIBCPP_INLINE_VISIBILITY
-      __node_pointer __get() const _NOEXCEPT {
-        return __cache_elem_;
+    _LIBCPP_HIDE_FROM_ABI void __advance() _NOEXCEPT {
+      __cache_elem_ = __cache_root_;
+      if (__cache_root_) {
+        __cache_root_ = __detach_next(__cache_root_);
       }
+    }
 
-      _LIBCPP_INLINE_VISIBILITY
-      void __advance() _NOEXCEPT {
-        __cache_elem_ = __cache_root_;
-        if (__cache_root_) {
-          __cache_root_ = __detach_next(__cache_root_);
-        }
+    _LIBCPP_HIDE_FROM_ABI ~_DetachedTreeCache() {
+      __t_->destroy(__cache_elem_);
+      if (__cache_root_) {
+        while (__cache_root_->__parent_ != nullptr)
+          __cache_root_ = static_cast<__node_pointer>(__cache_root_->__parent_);
+        __t_->destroy(__cache_root_);
       }
+    }
 
-      _LIBCPP_INLINE_VISIBILITY
-      ~_DetachedTreeCache() {
-        __t_->destroy(__cache_elem_);
-        if (__cache_root_) {
-          while (__cache_root_->__parent_ != nullptr)
-            __cache_root_ = static_cast<__node_pointer>(__cache_root_->__parent_);
-          __t_->destroy(__cache_root_);
-        }
-      }
+    _DetachedTreeCache(_DetachedTreeCache const&)            = delete;
+    _DetachedTreeCache& operator=(_DetachedTreeCache const&) = delete;
 
-       _DetachedTreeCache(_DetachedTreeCache const&) = delete;
-       _DetachedTreeCache& operator=(_DetachedTreeCache const&) = delete;
+  private:
+    _LIBCPP_HIDE_FROM_ABI static __node_pointer __detach_from_tree(__tree* __t) _NOEXCEPT;
+    _LIBCPP_HIDE_FROM_ABI static __node_pointer __detach_next(__node_pointer) _NOEXCEPT;
 
-    private:
-      _LIBCPP_INLINE_VISIBILITY
-      static __node_pointer __detach_from_tree(__tree *__t) _NOEXCEPT;
-      _LIBCPP_INLINE_VISIBILITY
-      static __node_pointer __detach_next(__node_pointer) _NOEXCEPT;
+    __tree* __t_;
+    __node_pointer __cache_root_;
+    __node_pointer __cache_elem_;
+  };
 
-      __tree *__t_;
-      __node_pointer __cache_root_;
-      __node_pointer __cache_elem_;
-    };
-
-
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
+  template <class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS map;
+  template <class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS multimap;
 };
 
 template <class _Tp, class _Compare, class _Allocator>
-__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<__node_allocator>::value &&
-            is_nothrow_copy_constructible<value_compare>::value)
-    : __pair3_(0, __comp)
-{
-    __begin_node() = __end_node();
+__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp) _NOEXCEPT_(
+    is_nothrow_default_constructible<__node_allocator>::value&& is_nothrow_copy_constructible<value_compare>::value)
+    : __pair3_(0, __comp) {
+  __begin_node() = __end_node();
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const allocator_type& __a)
     : __begin_node_(__iter_pointer()),
       __pair1_(__default_init_tag(), __node_allocator(__a)),
-      __pair3_(0, __default_init_tag())
-{
-    __begin_node() = __end_node();
+      __pair3_(0, __default_init_tag()) {
+  __begin_node() = __end_node();
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp,
-                                           const allocator_type& __a)
-    : __begin_node_(__iter_pointer()),
-      __pair1_(__default_init_tag(), __node_allocator(__a)),
-      __pair3_(0, __comp)
-{
-    __begin_node() = __end_node();
+__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp, const allocator_type& __a)
+    : __begin_node_(__iter_pointer()), __pair1_(__default_init_tag(), __node_allocator(__a)), __pair3_(0, __comp) {
+  __begin_node() = __end_node();
 }
 
 // Precondition:  size() != 0
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_pointer
-__tree<_Tp, _Compare, _Allocator>::_DetachedTreeCache::__detach_from_tree(__tree *__t) _NOEXCEPT
-{
-    __node_pointer __cache = static_cast<__node_pointer>(__t->__begin_node());
-    __t->__begin_node() = __t->__end_node();
-    __t->__end_node()->__left_->__parent_ = nullptr;
-    __t->__end_node()->__left_ = nullptr;
-    __t->size() = 0;
-    // __cache->__left_ == nullptr
-    if (__cache->__right_ != nullptr)
-        __cache = static_cast<__node_pointer>(__cache->__right_);
-    // __cache->__left_ == nullptr
-    // __cache->__right_ == nullptr
-    return __cache;
+__tree<_Tp, _Compare, _Allocator>::_DetachedTreeCache::__detach_from_tree(__tree* __t) _NOEXCEPT {
+  __node_pointer __cache                = static_cast<__node_pointer>(__t->__begin_node());
+  __t->__begin_node()                   = __t->__end_node();
+  __t->__end_node()->__left_->__parent_ = nullptr;
+  __t->__end_node()->__left_            = nullptr;
+  __t->size()                           = 0;
+  // __cache->__left_ == nullptr
+  if (__cache->__right_ != nullptr)
+    __cache = static_cast<__node_pointer>(__cache->__right_);
+  // __cache->__left_ == nullptr
+  // __cache->__right_ == nullptr
+  return __cache;
 }
 
 // Precondition:  __cache != nullptr
@@ -1597,259 +1365,214 @@ __tree<_Tp, _Compare, _Allocator>::_DetachedTreeCache::__detach_from_tree(__tree
 //    This is no longer a red-black tree
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_pointer
-__tree<_Tp, _Compare, _Allocator>::_DetachedTreeCache::__detach_next(__node_pointer __cache) _NOEXCEPT
-{
-    if (__cache->__parent_ == nullptr)
-        return nullptr;
-    if (_VSTD::__tree_is_left_child(static_cast<__node_base_pointer>(__cache)))
-    {
-        __cache->__parent_->__left_ = nullptr;
-        __cache = static_cast<__node_pointer>(__cache->__parent_);
-        if (__cache->__right_ == nullptr)
-            return __cache;
-        return static_cast<__node_pointer>(_VSTD::__tree_leaf(__cache->__right_));
-    }
-    // __cache is right child
-    __cache->__parent_unsafe()->__right_ = nullptr;
-    __cache = static_cast<__node_pointer>(__cache->__parent_);
-    if (__cache->__left_ == nullptr)
-        return __cache;
-    return static_cast<__node_pointer>(_VSTD::__tree_leaf(__cache->__left_));
+__tree<_Tp, _Compare, _Allocator>::_DetachedTreeCache::__detach_next(__node_pointer __cache) _NOEXCEPT {
+  if (__cache->__parent_ == nullptr)
+    return nullptr;
+  if (std::__tree_is_left_child(static_cast<__node_base_pointer>(__cache))) {
+    __cache->__parent_->__left_ = nullptr;
+    __cache                     = static_cast<__node_pointer>(__cache->__parent_);
+    if (__cache->__right_ == nullptr)
+      return __cache;
+    return static_cast<__node_pointer>(std::__tree_leaf(__cache->__right_));
+  }
+  // __cache is right child
+  __cache->__parent_unsafe()->__right_ = nullptr;
+  __cache                              = static_cast<__node_pointer>(__cache->__parent_);
+  if (__cache->__left_ == nullptr)
+    return __cache;
+  return static_cast<__node_pointer>(std::__tree_leaf(__cache->__left_));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-__tree<_Tp, _Compare, _Allocator>&
-__tree<_Tp, _Compare, _Allocator>::operator=(const __tree& __t)
-{
-    if (this != _VSTD::addressof(__t))
-    {
-        value_comp() = __t.value_comp();
-        __copy_assign_alloc(__t);
-        __assign_multi(__t.begin(), __t.end());
-    }
-    return *this;
+__tree<_Tp, _Compare, _Allocator>& __tree<_Tp, _Compare, _Allocator>::operator=(const __tree& __t) {
+  if (this != std::addressof(__t)) {
+    value_comp() = __t.value_comp();
+    __copy_assign_alloc(__t);
+    __assign_multi(__t.begin(), __t.end());
+  }
+  return *this;
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _ForwardIterator>
-void
-__tree<_Tp, _Compare, _Allocator>::__assign_unique(_ForwardIterator __first, _ForwardIterator __last)
-{
-    typedef iterator_traits<_ForwardIterator> _ITraits;
-    typedef typename _ITraits::value_type _ItValueType;
-    static_assert((is_same<_ItValueType, __container_value_type>::value),
-                  "__assign_unique may only be called with the containers value type");
-    static_assert(__has_forward_iterator_category<_ForwardIterator>::value,
-                  "__assign_unique requires a forward iterator");
-    if (size() != 0)
-    {
-        _DetachedTreeCache __cache(this);
-          for (; __cache.__get() != nullptr && __first != __last; ++__first) {
-              if (__node_assign_unique(*__first, __cache.__get()).second)
-                  __cache.__advance();
-            }
+void __tree<_Tp, _Compare, _Allocator>::__assign_unique(_ForwardIterator __first, _ForwardIterator __last) {
+  typedef iterator_traits<_ForwardIterator> _ITraits;
+  typedef typename _ITraits::value_type _ItValueType;
+  static_assert(is_same<_ItValueType, __container_value_type>::value,
+                "__assign_unique may only be called with the containers value type");
+  static_assert(
+      __has_forward_iterator_category<_ForwardIterator>::value, "__assign_unique requires a forward iterator");
+  if (size() != 0) {
+    _DetachedTreeCache __cache(this);
+    for (; __cache.__get() != nullptr && __first != __last; ++__first) {
+      if (__node_assign_unique(*__first, __cache.__get()).second)
+        __cache.__advance();
     }
-    for (; __first != __last; ++__first)
-        __insert_unique(*__first);
+  }
+  for (; __first != __last; ++__first)
+    __insert_unique(*__first);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _InputIterator>
-void
-__tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _InputIterator __last)
-{
-    typedef iterator_traits<_InputIterator> _ITraits;
-    typedef typename _ITraits::value_type _ItValueType;
-    static_assert((is_same<_ItValueType, __container_value_type>::value ||
-                  is_same<_ItValueType, __node_value_type>::value),
-                  "__assign_multi may only be called with the containers value type"
-                  " or the nodes value type");
-    if (size() != 0)
-    {
-        _DetachedTreeCache __cache(this);
-        for (; __cache.__get() && __first != __last; ++__first) {
-            __cache.__get()->__value_ = *__first;
-            __node_insert_multi(__cache.__get());
-            __cache.__advance();
-        }
+void __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _InputIterator __last) {
+  typedef iterator_traits<_InputIterator> _ITraits;
+  typedef typename _ITraits::value_type _ItValueType;
+  static_assert(
+      (is_same<_ItValueType, __container_value_type>::value || is_same<_ItValueType, __node_value_type>::value),
+      "__assign_multi may only be called with the containers value type"
+      " or the nodes value type");
+  if (size() != 0) {
+    _DetachedTreeCache __cache(this);
+    for (; __cache.__get() && __first != __last; ++__first) {
+      __cache.__get()->__value_ = *__first;
+      __node_insert_multi(__cache.__get());
+      __cache.__advance();
     }
-    for (; __first != __last; ++__first)
-        __insert_multi(_NodeTypes::__get_value(*__first));
+  }
+  for (; __first != __last; ++__first)
+    __insert_multi(_NodeTypes::__get_value(*__first));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)
     : __begin_node_(__iter_pointer()),
       __pair1_(__default_init_tag(), __node_traits::select_on_container_copy_construction(__t.__node_alloc())),
-      __pair3_(0, __t.value_comp())
-{
-    __begin_node() = __end_node();
+      __pair3_(0, __t.value_comp()) {
+  __begin_node() = __end_node();
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
-    _NOEXCEPT_(
-        is_nothrow_move_constructible<__node_allocator>::value &&
-        is_nothrow_move_constructible<value_compare>::value)
-    : __begin_node_(_VSTD::move(__t.__begin_node_)),
-      __pair1_(_VSTD::move(__t.__pair1_)),
-      __pair3_(_VSTD::move(__t.__pair3_))
-{
-    if (size() == 0)
-        __begin_node() = __end_node();
-    else
-    {
-        __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
-        __t.__begin_node() = __t.__end_node();
-        __t.__end_node()->__left_ = nullptr;
-        __t.size() = 0;
-    }
+__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t) _NOEXCEPT_(
+    is_nothrow_move_constructible<__node_allocator>::value&& is_nothrow_move_constructible<value_compare>::value)
+    : __begin_node_(std::move(__t.__begin_node_)),
+      __pair1_(std::move(__t.__pair1_)),
+      __pair3_(std::move(__t.__pair3_)) {
+  if (size() == 0)
+    __begin_node() = __end_node();
+  else {
+    __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
+    __t.__begin_node()               = __t.__end_node();
+    __t.__end_node()->__left_        = nullptr;
+    __t.size()                       = 0;
+  }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)
-    : __pair1_(__default_init_tag(), __node_allocator(__a)),
-      __pair3_(0, _VSTD::move(__t.value_comp()))
-{
-    if (__a == __t.__alloc())
-    {
-        if (__t.size() == 0)
-            __begin_node() = __end_node();
-        else
-        {
-            __begin_node() = __t.__begin_node();
-            __end_node()->__left_ = __t.__end_node()->__left_;
-            __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
-            size() = __t.size();
-            __t.__begin_node() = __t.__end_node();
-            __t.__end_node()->__left_ = nullptr;
-            __t.size() = 0;
-        }
-    }
-    else
-    {
-        __begin_node() = __end_node();
+    : __pair1_(__default_init_tag(), __node_allocator(__a)), __pair3_(0, std::move(__t.value_comp())) {
+  if (__a == __t.__alloc()) {
+    if (__t.size() == 0)
+      __begin_node() = __end_node();
+    else {
+      __begin_node()                   = __t.__begin_node();
+      __end_node()->__left_            = __t.__end_node()->__left_;
+      __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
+      size()                           = __t.size();
+      __t.__begin_node()               = __t.__end_node();
+      __t.__end_node()->__left_        = nullptr;
+      __t.size()                       = 0;
     }
+  } else {
+    __begin_node() = __end_node();
+  }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-void
-__tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
-    _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
-               is_nothrow_move_assignable<__node_allocator>::value)
-{
-    destroy(static_cast<__node_pointer>(__end_node()->__left_));
-    __begin_node_ = __t.__begin_node_;
-    __pair1_.first() = __t.__pair1_.first();
-    __move_assign_alloc(__t);
-    __pair3_ = _VSTD::move(__t.__pair3_);
-    if (size() == 0)
-        __begin_node() = __end_node();
-    else
-    {
-        __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
-        __t.__begin_node() = __t.__end_node();
-        __t.__end_node()->__left_ = nullptr;
-        __t.size() = 0;
-    }
+void __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
+    _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value&& is_nothrow_move_assignable<__node_allocator>::value) {
+  destroy(static_cast<__node_pointer>(__end_node()->__left_));
+  __begin_node_    = __t.__begin_node_;
+  __pair1_.first() = __t.__pair1_.first();
+  __move_assign_alloc(__t);
+  __pair3_ = std::move(__t.__pair3_);
+  if (size() == 0)
+    __begin_node() = __end_node();
+  else {
+    __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
+    __t.__begin_node()               = __t.__end_node();
+    __t.__end_node()->__left_        = nullptr;
+    __t.size()                       = 0;
+  }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-void
-__tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
-{
-    if (__node_alloc() == __t.__node_alloc())
-        __move_assign(__t, true_type());
-    else
-    {
-        value_comp() = _VSTD::move(__t.value_comp());
-        const_iterator __e = end();
-        if (size() != 0)
-        {
-            _DetachedTreeCache __cache(this);
-            while (__cache.__get() != nullptr && __t.size() != 0) {
-              __cache.__get()->__value_ = _VSTD::move(__t.remove(__t.begin())->__value_);
-              __node_insert_multi(__cache.__get());
-              __cache.__advance();
-            }
-        }
-        while (__t.size() != 0)
-            __insert_multi(__e, _NodeTypes::__move(__t.remove(__t.begin())->__value_));
+void __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type) {
+  if (__node_alloc() == __t.__node_alloc())
+    __move_assign(__t, true_type());
+  else {
+    value_comp()       = std::move(__t.value_comp());
+    const_iterator __e = end();
+    if (size() != 0) {
+      _DetachedTreeCache __cache(this);
+      while (__cache.__get() != nullptr && __t.size() != 0) {
+        __cache.__get()->__value_ = std::move(__t.remove(__t.begin())->__value_);
+        __node_insert_multi(__cache.__get());
+        __cache.__advance();
+      }
     }
+    while (__t.size() != 0)
+      __insert_multi(__e, _NodeTypes::__move(__t.remove(__t.begin())->__value_));
+  }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-__tree<_Tp, _Compare, _Allocator>&
-__tree<_Tp, _Compare, _Allocator>::operator=(__tree&& __t)
-    _NOEXCEPT_(
-        __node_traits::propagate_on_container_move_assignment::value &&
-        is_nothrow_move_assignable<value_compare>::value &&
+__tree<_Tp, _Compare, _Allocator>& __tree<_Tp, _Compare, _Allocator>::operator=(__tree&& __t) _NOEXCEPT_(
+    __node_traits::propagate_on_container_move_assignment::value&& is_nothrow_move_assignable<value_compare>::value&&
         is_nothrow_move_assignable<__node_allocator>::value)
 
 {
-    __move_assign(__t, integral_constant<bool,
-                  __node_traits::propagate_on_container_move_assignment::value>());
-    return *this;
+  __move_assign(__t, integral_constant<bool, __node_traits::propagate_on_container_move_assignment::value>());
+  return *this;
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-__tree<_Tp, _Compare, _Allocator>::~__tree()
-{
-    static_assert((is_copy_constructible<value_compare>::value),
-                 "Comparator must be copy-constructible.");
+__tree<_Tp, _Compare, _Allocator>::~__tree() {
+  static_assert(is_copy_constructible<value_compare>::value, "Comparator must be copy-constructible.");
   destroy(__root());
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-void
-__tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
-{
-    if (__nd != nullptr)
-    {
-        destroy(static_cast<__node_pointer>(__nd->__left_));
-        destroy(static_cast<__node_pointer>(__nd->__right_));
-        __node_allocator& __na = __node_alloc();
-        __node_traits::destroy(__na, _NodeTypes::__get_ptr(__nd->__value_));
-        __node_traits::deallocate(__na, __nd, 1);
-    }
+void __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT {
+  if (__nd != nullptr) {
+    destroy(static_cast<__node_pointer>(__nd->__left_));
+    destroy(static_cast<__node_pointer>(__nd->__right_));
+    __node_allocator& __na = __node_alloc();
+    __node_traits::destroy(__na, _NodeTypes::__get_ptr(__nd->__value_));
+    __node_traits::deallocate(__na, __nd, 1);
+  }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-void
-__tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
+void __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
 #if _LIBCPP_STD_VER <= 11
-        _NOEXCEPT_(
-            __is_nothrow_swappable<value_compare>::value
-            && (!__node_traits::propagate_on_container_swap::value ||
-                 __is_nothrow_swappable<__node_allocator>::value)
-            )
+    _NOEXCEPT_(__is_nothrow_swappable_v<value_compare> &&
+               (!__node_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<__node_allocator>))
 #else
-        _NOEXCEPT_(__is_nothrow_swappable<value_compare>::value)
+    _NOEXCEPT_(__is_nothrow_swappable_v<value_compare>)
 #endif
 {
-    using _VSTD::swap;
-    swap(__begin_node_, __t.__begin_node_);
-    swap(__pair1_.first(), __t.__pair1_.first());
-    _VSTD::__swap_allocator(__node_alloc(), __t.__node_alloc());
-    __pair3_.swap(__t.__pair3_);
-    if (size() == 0)
-        __begin_node() = __end_node();
-    else
-        __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
-    if (__t.size() == 0)
-        __t.__begin_node() = __t.__end_node();
-    else
-        __t.__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__t.__end_node());
+  using std::swap;
+  swap(__begin_node_, __t.__begin_node_);
+  swap(__pair1_.first(), __t.__pair1_.first());
+  std::__swap_allocator(__node_alloc(), __t.__node_alloc());
+  __pair3_.swap(__t.__pair3_);
+  if (size() == 0)
+    __begin_node() = __end_node();
+  else
+    __end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__end_node());
+  if (__t.size() == 0)
+    __t.__begin_node() = __t.__end_node();
+  else
+    __t.__end_node()->__left_->__parent_ = static_cast<__parent_pointer>(__t.__end_node());
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-void
-__tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT
-{
-    destroy(__root());
-    size() = 0;
-    __begin_node() = __end_node();
-    __end_node()->__left_ = nullptr;
+void __tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT {
+  destroy(__root());
+  size()                = 0;
+  __begin_node()        = __end_node();
+  __end_node()->__left_ = nullptr;
 }
 
 // Find lower_bound place to insert
@@ -1857,38 +1580,29 @@ __tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(__parent_pointer& __parent,
-                                                   const key_type& __v)
-{
-    __node_pointer __nd = __root();
-    if (__nd != nullptr)
-    {
-        while (true)
-        {
-            if (value_comp()(__nd->__value_, __v))
-            {
-                if (__nd->__right_ != nullptr)
-                    __nd = static_cast<__node_pointer>(__nd->__right_);
-                else
-                {
-                    __parent = static_cast<__parent_pointer>(__nd);
-                    return __nd->__right_;
-                }
-            }
-            else
-            {
-                if (__nd->__left_ != nullptr)
-                    __nd = static_cast<__node_pointer>(__nd->__left_);
-                else
-                {
-                    __parent = static_cast<__parent_pointer>(__nd);
-                    return __parent->__left_;
-                }
-            }
+__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(__parent_pointer& __parent, const key_type& __v) {
+  __node_pointer __nd = __root();
+  if (__nd != nullptr) {
+    while (true) {
+      if (value_comp()(__nd->__value_, __v)) {
+        if (__nd->__right_ != nullptr)
+          __nd = static_cast<__node_pointer>(__nd->__right_);
+        else {
+          __parent = static_cast<__parent_pointer>(__nd);
+          return __nd->__right_;
         }
+      } else {
+        if (__nd->__left_ != nullptr)
+          __nd = static_cast<__node_pointer>(__nd->__left_);
+        else {
+          __parent = static_cast<__parent_pointer>(__nd);
+          return __parent->__left_;
+        }
+      }
     }
-    __parent = static_cast<__parent_pointer>(__end_node());
-    return __parent->__left_;
+  }
+  __parent = static_cast<__parent_pointer>(__end_node());
+  return __parent->__left_;
 }
 
 // Find upper_bound place to insert
@@ -1896,38 +1610,29 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(__parent_pointer& __parent,
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__parent_pointer& __parent,
-                                                    const key_type& __v)
-{
-    __node_pointer __nd = __root();
-    if (__nd != nullptr)
-    {
-        while (true)
-        {
-            if (value_comp()(__v, __nd->__value_))
-            {
-                if (__nd->__left_ != nullptr)
-                    __nd = static_cast<__node_pointer>(__nd->__left_);
-                else
-                {
-                    __parent = static_cast<__parent_pointer>(__nd);
-                    return __parent->__left_;
-                }
-            }
-            else
-            {
-                if (__nd->__right_ != nullptr)
-                    __nd = static_cast<__node_pointer>(__nd->__right_);
-                else
-                {
-                    __parent = static_cast<__parent_pointer>(__nd);
-                    return __nd->__right_;
-                }
-            }
+__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__parent_pointer& __parent, const key_type& __v) {
+  __node_pointer __nd = __root();
+  if (__nd != nullptr) {
+    while (true) {
+      if (value_comp()(__v, __nd->__value_)) {
+        if (__nd->__left_ != nullptr)
+          __nd = static_cast<__node_pointer>(__nd->__left_);
+        else {
+          __parent = static_cast<__parent_pointer>(__nd);
+          return __parent->__left_;
         }
+      } else {
+        if (__nd->__right_ != nullptr)
+          __nd = static_cast<__node_pointer>(__nd->__right_);
+        else {
+          __parent = static_cast<__parent_pointer>(__nd);
+          return __nd->__right_;
+        }
+      }
     }
-    __parent = static_cast<__parent_pointer>(__end_node());
-    return __parent->__left_;
+  }
+  __parent = static_cast<__parent_pointer>(__end_node());
+  return __parent->__left_;
 }
 
 // Find leaf place to insert closest to __hint
@@ -1938,33 +1643,26 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__parent_pointer& __parent,
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
-                                               __parent_pointer& __parent,
-                                               const key_type& __v)
-{
-    if (__hint == end() || !value_comp()(*__hint, __v))  // check before
-    {
-        // __v <= *__hint
-        const_iterator __prior = __hint;
-        if (__prior == begin() || !value_comp()(__v, *--__prior))
-        {
-            // *prev(__hint) <= __v <= *__hint
-            if (__hint.__ptr_->__left_ == nullptr)
-            {
-                __parent = static_cast<__parent_pointer>(__hint.__ptr_);
-                return __parent->__left_;
-            }
-            else
-            {
-                __parent = static_cast<__parent_pointer>(__prior.__ptr_);
-                return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
-            }
-        }
-        // __v < *prev(__hint)
-        return __find_leaf_high(__parent, __v);
+__tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint, __parent_pointer& __parent, const key_type& __v) {
+  if (__hint == end() || !value_comp()(*__hint, __v)) // check before
+  {
+    // __v <= *__hint
+    const_iterator __prior = __hint;
+    if (__prior == begin() || !value_comp()(__v, *--__prior)) {
+      // *prev(__hint) <= __v <= *__hint
+      if (__hint.__ptr_->__left_ == nullptr) {
+        __parent = static_cast<__parent_pointer>(__hint.__ptr_);
+        return __parent->__left_;
+      } else {
+        __parent = static_cast<__parent_pointer>(__prior.__ptr_);
+        return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
+      }
     }
-    // else __v > *__hint
-    return __find_leaf_low(__parent, __v);
+    // __v < *prev(__hint)
+    return __find_leaf_high(__parent, __v);
+  }
+  // else __v > *__hint
+  return __find_leaf_low(__parent, __v);
 }
 
 // Find place to insert if __v doesn't exist
@@ -1974,44 +1672,35 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_equal(__parent_pointer& __parent,
-                                                const _Key& __v)
-{
-    __node_pointer __nd = __root();
-    __node_base_pointer* __nd_ptr = __root_ptr();
-    if (__nd != nullptr)
-    {
-        while (true)
-        {
-            if (value_comp()(__v, __nd->__value_))
-            {
-                if (__nd->__left_ != nullptr) {
-                    __nd_ptr = _VSTD::addressof(__nd->__left_);
-                    __nd = static_cast<__node_pointer>(__nd->__left_);
-                } else {
-                    __parent = static_cast<__parent_pointer>(__nd);
-                    return __parent->__left_;
-                }
-            }
-            else if (value_comp()(__nd->__value_, __v))
-            {
-                if (__nd->__right_ != nullptr) {
-                    __nd_ptr = _VSTD::addressof(__nd->__right_);
-                    __nd = static_cast<__node_pointer>(__nd->__right_);
-                } else {
-                    __parent = static_cast<__parent_pointer>(__nd);
-                    return __nd->__right_;
-                }
-            }
-            else
-            {
-                __parent = static_cast<__parent_pointer>(__nd);
-                return *__nd_ptr;
-            }
+__tree<_Tp, _Compare, _Allocator>::__find_equal(__parent_pointer& __parent, const _Key& __v) {
+  __node_pointer __nd           = __root();
+  __node_base_pointer* __nd_ptr = __root_ptr();
+  if (__nd != nullptr) {
+    while (true) {
+      if (value_comp()(__v, __nd->__value_)) {
+        if (__nd->__left_ != nullptr) {
+          __nd_ptr = std::addressof(__nd->__left_);
+          __nd     = static_cast<__node_pointer>(__nd->__left_);
+        } else {
+          __parent = static_cast<__parent_pointer>(__nd);
+          return __parent->__left_;
         }
+      } else if (value_comp()(__nd->__value_, __v)) {
+        if (__nd->__right_ != nullptr) {
+          __nd_ptr = std::addressof(__nd->__right_);
+          __nd     = static_cast<__node_pointer>(__nd->__right_);
+        } else {
+          __parent = static_cast<__parent_pointer>(__nd);
+          return __nd->__right_;
+        }
+      } else {
+        __parent = static_cast<__parent_pointer>(__nd);
+        return *__nd_ptr;
+      }
     }
-    __parent = static_cast<__parent_pointer>(__end_node());
-    return __parent->__left_;
+  }
+  __parent = static_cast<__parent_pointer>(__end_node());
+  return __parent->__left_;
 }
 
 // Find place to insert if __v doesn't exist
@@ -2023,731 +1712,584 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(__parent_pointer& __parent,
 // If __v exists, set parent to node of __v and return reference to node of __v
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
-                                                __parent_pointer& __parent,
-                                                __node_base_pointer& __dummy,
-                                                const _Key& __v)
-{
-    if (__hint == end() || value_comp()(__v, *__hint))  // check before
-    {
-        // __v < *__hint
-        const_iterator __prior = __hint;
-        if (__prior == begin() || value_comp()(*--__prior, __v))
-        {
-            // *prev(__hint) < __v < *__hint
-            if (__hint.__ptr_->__left_ == nullptr)
-            {
-                __parent = static_cast<__parent_pointer>(__hint.__ptr_);
-                return __parent->__left_;
-            }
-            else
-            {
-                __parent = static_cast<__parent_pointer>(__prior.__ptr_);
-                return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
-            }
-        }
-        // __v <= *prev(__hint)
-        return __find_equal(__parent, __v);
+typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer& __tree<_Tp, _Compare, _Allocator>::__find_equal(
+    const_iterator __hint, __parent_pointer& __parent, __node_base_pointer& __dummy, const _Key& __v) {
+  if (__hint == end() || value_comp()(__v, *__hint)) // check before
+  {
+    // __v < *__hint
+    const_iterator __prior = __hint;
+    if (__prior == begin() || value_comp()(*--__prior, __v)) {
+      // *prev(__hint) < __v < *__hint
+      if (__hint.__ptr_->__left_ == nullptr) {
+        __parent = static_cast<__parent_pointer>(__hint.__ptr_);
+        return __parent->__left_;
+      } else {
+        __parent = static_cast<__parent_pointer>(__prior.__ptr_);
+        return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
+      }
     }
-    else if (value_comp()(*__hint, __v))  // check after
-    {
-        // *__hint < __v
-        const_iterator __next = _VSTD::next(__hint);
-        if (__next == end() || value_comp()(__v, *__next))
-        {
-            // *__hint < __v < *_VSTD::next(__hint)
-            if (__hint.__get_np()->__right_ == nullptr)
-            {
-                __parent = static_cast<__parent_pointer>(__hint.__ptr_);
-                return static_cast<__node_base_pointer>(__hint.__ptr_)->__right_;
-            }
-            else
-            {
-                __parent = static_cast<__parent_pointer>(__next.__ptr_);
-                return __parent->__left_;
-            }
-        }
-        // *next(__hint) <= __v
-        return __find_equal(__parent, __v);
+    // __v <= *prev(__hint)
+    return __find_equal(__parent, __v);
+  } else if (value_comp()(*__hint, __v)) // check after
+  {
+    // *__hint < __v
+    const_iterator __next = std::next(__hint);
+    if (__next == end() || value_comp()(__v, *__next)) {
+      // *__hint < __v < *std::next(__hint)
+      if (__hint.__get_np()->__right_ == nullptr) {
+        __parent = static_cast<__parent_pointer>(__hint.__ptr_);
+        return static_cast<__node_base_pointer>(__hint.__ptr_)->__right_;
+      } else {
+        __parent = static_cast<__parent_pointer>(__next.__ptr_);
+        return __parent->__left_;
+      }
     }
-    // else __v == *__hint
-    __parent = static_cast<__parent_pointer>(__hint.__ptr_);
-    __dummy = static_cast<__node_base_pointer>(__hint.__ptr_);
-    return __dummy;
+    // *next(__hint) <= __v
+    return __find_equal(__parent, __v);
+  }
+  // else __v == *__hint
+  __parent = static_cast<__parent_pointer>(__hint.__ptr_);
+  __dummy  = static_cast<__node_base_pointer>(__hint.__ptr_);
+  return __dummy;
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 void __tree<_Tp, _Compare, _Allocator>::__insert_node_at(
-    __parent_pointer __parent, __node_base_pointer& __child,
-    __node_base_pointer __new_node) _NOEXCEPT
-{
-    __new_node->__left_   = nullptr;
-    __new_node->__right_  = nullptr;
-    __new_node->__parent_ = __parent;
-    // __new_node->__is_black_ is initialized in __tree_balance_after_insert
-    __child = __new_node;
-    if (__begin_node()->__left_ != nullptr)
-        __begin_node() = static_cast<__iter_pointer>(__begin_node()->__left_);
-    _VSTD::__tree_balance_after_insert(__end_node()->__left_, __child);
-    ++size();
+    __parent_pointer __parent, __node_base_pointer& __child, __node_base_pointer __new_node) _NOEXCEPT {
+  __new_node->__left_   = nullptr;
+  __new_node->__right_  = nullptr;
+  __new_node->__parent_ = __parent;
+  // __new_node->__is_black_ is initialized in __tree_balance_after_insert
+  __child = __new_node;
+  if (__begin_node()->__left_ != nullptr)
+    __begin_node() = static_cast<__iter_pointer>(__begin_node()->__left_);
+  std::__tree_balance_after_insert(__end_node()->__left_, __child);
+  ++size();
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key, class... _Args>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
-__tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args)
-{
-    __parent_pointer __parent;
-    __node_base_pointer& __child = __find_equal(__parent, __k);
-    __node_pointer __r = static_cast<__node_pointer>(__child);
-    bool __inserted = false;
-    if (__child == nullptr)
-    {
-        __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-        __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-        __r = __h.release();
-        __inserted = true;
-    }
-    return pair<iterator, bool>(iterator(__r), __inserted);
+__tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args) {
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __find_equal(__parent, __k);
+  __node_pointer __r           = static_cast<__node_pointer>(__child);
+  bool __inserted              = false;
+  if (__child == nullptr) {
+    __node_holder __h = __construct_node(std::forward<_Args>(__args)...);
+    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
+    __r        = __h.release();
+    __inserted = true;
+  }
+  return pair<iterator, bool>(iterator(__r), __inserted);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key, class... _Args>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
 __tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_key_args(
-    const_iterator __p, _Key const& __k, _Args&&... __args)
-{
-    __parent_pointer __parent;
-    __node_base_pointer __dummy;
-    __node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __k);
-    __node_pointer __r = static_cast<__node_pointer>(__child);
-    bool __inserted = false;
-    if (__child == nullptr)
-    {
-        __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-        __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-        __r = __h.release();
-        __inserted = true;
-    }
-    return pair<iterator, bool>(iterator(__r), __inserted);
+    const_iterator __p, _Key const& __k, _Args&&... __args) {
+  __parent_pointer __parent;
+  __node_base_pointer __dummy;
+  __node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __k);
+  __node_pointer __r           = static_cast<__node_pointer>(__child);
+  bool __inserted              = false;
+  if (__child == nullptr) {
+    __node_holder __h = __construct_node(std::forward<_Args>(__args)...);
+    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
+    __r        = __h.release();
+    __inserted = true;
+  }
+  return pair<iterator, bool>(iterator(__r), __inserted);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-template <class ..._Args>
+template <class... _Args>
 typename __tree<_Tp, _Compare, _Allocator>::__node_holder
-__tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&& ...__args)
-{
-    static_assert(!__is_tree_value_type<_Args...>::value,
-                  "Cannot construct from __value_type");
-    __node_allocator& __na = __node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), _VSTD::forward<_Args>(__args)...);
-    __h.get_deleter().__value_constructed = true;
-    return __h;
+__tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&&... __args) {
+  static_assert(!__is_tree_value_type<_Args...>::value, "Cannot construct from __value_type");
+  __node_allocator& __na = __node_alloc();
+  __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
+  __node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__value_), std::forward<_Args>(__args)...);
+  __h.get_deleter().__value_constructed = true;
+  return __h;
 }
 
-
 template <class _Tp, class _Compare, class _Allocator>
 template <class... _Args>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
-__tree<_Tp, _Compare, _Allocator>::__emplace_unique_impl(_Args&&... __args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    __parent_pointer __parent;
-    __node_base_pointer& __child = __find_equal(__parent, __h->__value_);
-    __node_pointer __r = static_cast<__node_pointer>(__child);
-    bool __inserted = false;
-    if (__child == nullptr)
-    {
-        __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-        __r = __h.release();
-        __inserted = true;
-    }
-    return pair<iterator, bool>(iterator(__r), __inserted);
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class... _Args>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_impl(const_iterator __p, _Args&&... __args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    __parent_pointer __parent;
-    __node_base_pointer __dummy;
-    __node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__value_);
-    __node_pointer __r = static_cast<__node_pointer>(__child);
-    if (__child == nullptr)
-    {
-        __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-        __r = __h.release();
-    }
-    return iterator(__r);
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class... _Args>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    __parent_pointer __parent;
-    __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__h->__value_));
+__tree<_Tp, _Compare, _Allocator>::__emplace_unique_impl(_Args&&... __args) {
+  __node_holder __h = __construct_node(std::forward<_Args>(__args)...);
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __find_equal(__parent, __h->__value_);
+  __node_pointer __r           = static_cast<__node_pointer>(__child);
+  bool __inserted              = false;
+  if (__child == nullptr) {
     __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-    return iterator(static_cast<__node_pointer>(__h.release()));
+    __r        = __h.release();
+    __inserted = true;
+  }
+  return pair<iterator, bool>(iterator(__r), __inserted);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class... _Args>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p,
-                                                        _Args&&... __args)
-{
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
-    __parent_pointer __parent;
-    __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__h->__value_));
+__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_impl(const_iterator __p, _Args&&... __args) {
+  __node_holder __h = __construct_node(std::forward<_Args>(__args)...);
+  __parent_pointer __parent;
+  __node_base_pointer __dummy;
+  __node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__value_);
+  __node_pointer __r           = static_cast<__node_pointer>(__child);
+  if (__child == nullptr) {
     __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-    return iterator(static_cast<__node_pointer>(__h.release()));
+    __r = __h.release();
+  }
+  return iterator(__r);
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+template <class... _Args>
+typename __tree<_Tp, _Compare, _Allocator>::iterator
+__tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args) {
+  __node_holder __h = __construct_node(std::forward<_Args>(__args)...);
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__h->__value_));
+  __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
+  return iterator(static_cast<__node_pointer>(__h.release()));
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+template <class... _Args>
+typename __tree<_Tp, _Compare, _Allocator>::iterator
+__tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p, _Args&&... __args) {
+  __node_holder __h = __construct_node(std::forward<_Args>(__args)...);
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__h->__value_));
+  __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
+  return iterator(static_cast<__node_pointer>(__h.release()));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
-__tree<_Tp, _Compare, _Allocator>::__node_assign_unique(const __container_value_type& __v, __node_pointer __nd)
-{
-    __parent_pointer __parent;
-    __node_base_pointer& __child = __find_equal(__parent, _NodeTypes::__get_key(__v));
-    __node_pointer __r = static_cast<__node_pointer>(__child);
-    bool __inserted = false;
-    if (__child == nullptr)
-    {
-        __nd->__value_ = __v;
-        __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
-        __r = __nd;
-        __inserted = true;
-    }
-    return pair<iterator, bool>(iterator(__r), __inserted);
-}
-
-
-template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(__node_pointer __nd)
-{
-    __parent_pointer __parent;
-    __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__nd->__value_));
+__tree<_Tp, _Compare, _Allocator>::__node_assign_unique(const __container_value_type& __v, __node_pointer __nd) {
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __find_equal(__parent, _NodeTypes::__get_key(__v));
+  __node_pointer __r           = static_cast<__node_pointer>(__child);
+  bool __inserted              = false;
+  if (__child == nullptr) {
+    __nd->__value_ = __v;
     __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
-    return iterator(__nd);
+    __r        = __nd;
+    __inserted = true;
+  }
+  return pair<iterator, bool>(iterator(__r), __inserted);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(const_iterator __p,
-                                                       __node_pointer __nd)
-{
-    __parent_pointer __parent;
-    __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__nd->__value_));
-    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
-    return iterator(__nd);
+__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(__node_pointer __nd) {
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__nd->__value_));
+  __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
+  return iterator(__nd);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__remove_node_pointer(__node_pointer __ptr) _NOEXCEPT
-{
-    iterator __r(__ptr);
-    ++__r;
-    if (__begin_node() == __ptr)
-        __begin_node() = __r.__ptr_;
-    --size();
-    _VSTD::__tree_remove(__end_node()->__left_,
-                         static_cast<__node_base_pointer>(__ptr));
-    return __r;
+__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(const_iterator __p, __node_pointer __nd) {
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __find_leaf(__p, __parent, _NodeTypes::__get_key(__nd->__value_));
+  __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
+  return iterator(__nd);
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+typename __tree<_Tp, _Compare, _Allocator>::iterator
+__tree<_Tp, _Compare, _Allocator>::__remove_node_pointer(__node_pointer __ptr) _NOEXCEPT {
+  iterator __r(__ptr);
+  ++__r;
+  if (__begin_node() == __ptr)
+    __begin_node() = __r.__ptr_;
+  --size();
+  std::__tree_remove(__end_node()->__left_, static_cast<__node_base_pointer>(__ptr));
+  return __r;
 }
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp, class _Compare, class _Allocator>
 template <class _NodeHandle, class _InsertReturnType>
-_LIBCPP_INLINE_VISIBILITY
-_InsertReturnType
-__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(
-    _NodeHandle&& __nh)
-{
-    if (__nh.empty())
-        return _InsertReturnType{end(), false, _NodeHandle()};
+_LIBCPP_HIDE_FROM_ABI _InsertReturnType
+__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(_NodeHandle&& __nh) {
+  if (__nh.empty())
+    return _InsertReturnType{end(), false, _NodeHandle()};
 
-    __node_pointer __ptr = __nh.__ptr_;
+  __node_pointer __ptr = __nh.__ptr_;
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __find_equal(__parent, __ptr->__value_);
+  if (__child != nullptr)
+    return _InsertReturnType{iterator(static_cast<__node_pointer>(__child)), false, std::move(__nh)};
+
+  __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
+  __nh.__release_ptr();
+  return _InsertReturnType{iterator(__ptr), true, _NodeHandle()};
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+template <class _NodeHandle>
+_LIBCPP_HIDE_FROM_ABI typename __tree<_Tp, _Compare, _Allocator>::iterator
+__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(const_iterator __hint, _NodeHandle&& __nh) {
+  if (__nh.empty())
+    return end();
+
+  __node_pointer __ptr = __nh.__ptr_;
+  __parent_pointer __parent;
+  __node_base_pointer __dummy;
+  __node_base_pointer& __child = __find_equal(__hint, __parent, __dummy, __ptr->__value_);
+  __node_pointer __r           = static_cast<__node_pointer>(__child);
+  if (__child == nullptr) {
+    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
+    __r = __ptr;
+    __nh.__release_ptr();
+  }
+  return iterator(__r);
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+template <class _NodeHandle>
+_LIBCPP_HIDE_FROM_ABI _NodeHandle __tree<_Tp, _Compare, _Allocator>::__node_handle_extract(key_type const& __key) {
+  iterator __it = find(__key);
+  if (__it == end())
+    return _NodeHandle();
+  return __node_handle_extract<_NodeHandle>(__it);
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+template <class _NodeHandle>
+_LIBCPP_HIDE_FROM_ABI _NodeHandle __tree<_Tp, _Compare, _Allocator>::__node_handle_extract(const_iterator __p) {
+  __node_pointer __np = __p.__get_np();
+  __remove_node_pointer(__np);
+  return _NodeHandle(__np, __alloc());
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+template <class _Tree>
+_LIBCPP_HIDE_FROM_ABI void __tree<_Tp, _Compare, _Allocator>::__node_handle_merge_unique(_Tree& __source) {
+  static_assert(is_same<typename _Tree::__node_pointer, __node_pointer>::value, "");
+
+  for (typename _Tree::iterator __i = __source.begin(); __i != __source.end();) {
+    __node_pointer __src_ptr = __i.__get_np();
     __parent_pointer __parent;
-    __node_base_pointer& __child = __find_equal(__parent,
-                                                __ptr->__value_);
+    __node_base_pointer& __child = __find_equal(__parent, _NodeTypes::__get_key(__src_ptr->__value_));
+    ++__i;
     if (__child != nullptr)
-        return _InsertReturnType{
-            iterator(static_cast<__node_pointer>(__child)),
-            false, _VSTD::move(__nh)};
-
-    __insert_node_at(__parent, __child,
-                     static_cast<__node_base_pointer>(__ptr));
-    __nh.__release_ptr();
-    return _InsertReturnType{iterator(__ptr), true, _NodeHandle()};
+      continue;
+    __source.__remove_node_pointer(__src_ptr);
+    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__src_ptr));
+  }
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _NodeHandle>
-_LIBCPP_INLINE_VISIBILITY
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(
-    const_iterator __hint, _NodeHandle&& __nh)
-{
-    if (__nh.empty())
-        return end();
-
-    __node_pointer __ptr = __nh.__ptr_;
-    __parent_pointer __parent;
-    __node_base_pointer __dummy;
-    __node_base_pointer& __child = __find_equal(__hint, __parent, __dummy,
-                                                __ptr->__value_);
-    __node_pointer __r = static_cast<__node_pointer>(__child);
-    if (__child == nullptr)
-    {
-        __insert_node_at(__parent, __child,
-                         static_cast<__node_base_pointer>(__ptr));
-        __r = __ptr;
-        __nh.__release_ptr();
-    }
-    return iterator(__r);
+_LIBCPP_HIDE_FROM_ABI typename __tree<_Tp, _Compare, _Allocator>::iterator
+__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(_NodeHandle&& __nh) {
+  if (__nh.empty())
+    return end();
+  __node_pointer __ptr = __nh.__ptr_;
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__ptr->__value_));
+  __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
+  __nh.__release_ptr();
+  return iterator(__ptr);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _NodeHandle>
-_LIBCPP_INLINE_VISIBILITY
-_NodeHandle
-__tree<_Tp, _Compare, _Allocator>::__node_handle_extract(key_type const& __key)
-{
-    iterator __it = find(__key);
-    if (__it == end())
-        return _NodeHandle();
-    return __node_handle_extract<_NodeHandle>(__it);
-}
+_LIBCPP_HIDE_FROM_ABI typename __tree<_Tp, _Compare, _Allocator>::iterator
+__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(const_iterator __hint, _NodeHandle&& __nh) {
+  if (__nh.empty())
+    return end();
 
-template <class _Tp, class _Compare, class _Allocator>
-template <class _NodeHandle>
-_LIBCPP_INLINE_VISIBILITY
-_NodeHandle
-__tree<_Tp, _Compare, _Allocator>::__node_handle_extract(const_iterator __p)
-{
-    __node_pointer __np = __p.__get_np();
-    __remove_node_pointer(__np);
-    return _NodeHandle(__np, __alloc());
+  __node_pointer __ptr = __nh.__ptr_;
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __find_leaf(__hint, __parent, _NodeTypes::__get_key(__ptr->__value_));
+  __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
+  __nh.__release_ptr();
+  return iterator(__ptr);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Tree>
-_LIBCPP_INLINE_VISIBILITY
-void
-__tree<_Tp, _Compare, _Allocator>::__node_handle_merge_unique(_Tree& __source)
-{
-    static_assert(is_same<typename _Tree::__node_pointer, __node_pointer>::value, "");
+_LIBCPP_HIDE_FROM_ABI void __tree<_Tp, _Compare, _Allocator>::__node_handle_merge_multi(_Tree& __source) {
+  static_assert(is_same<typename _Tree::__node_pointer, __node_pointer>::value, "");
 
-    for (typename _Tree::iterator __i = __source.begin();
-         __i != __source.end();)
-    {
-        __node_pointer __src_ptr = __i.__get_np();
-        __parent_pointer __parent;
-        __node_base_pointer& __child =
-            __find_equal(__parent, _NodeTypes::__get_key(__src_ptr->__value_));
-        ++__i;
-        if (__child != nullptr)
-            continue;
-        __source.__remove_node_pointer(__src_ptr);
-        __insert_node_at(__parent, __child,
-                         static_cast<__node_base_pointer>(__src_ptr));
-    }
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _NodeHandle>
-_LIBCPP_INLINE_VISIBILITY
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(_NodeHandle&& __nh)
-{
-    if (__nh.empty())
-        return end();
-    __node_pointer __ptr = __nh.__ptr_;
+  for (typename _Tree::iterator __i = __source.begin(); __i != __source.end();) {
+    __node_pointer __src_ptr = __i.__get_np();
     __parent_pointer __parent;
-    __node_base_pointer& __child = __find_leaf_high(
-        __parent, _NodeTypes::__get_key(__ptr->__value_));
-    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
-    __nh.__release_ptr();
-    return iterator(__ptr);
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _NodeHandle>
-_LIBCPP_INLINE_VISIBILITY
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(
-    const_iterator __hint, _NodeHandle&& __nh)
-{
-    if (__nh.empty())
-        return end();
-
-    __node_pointer __ptr = __nh.__ptr_;
-    __parent_pointer __parent;
-    __node_base_pointer& __child = __find_leaf(__hint, __parent,
-                                               _NodeTypes::__get_key(__ptr->__value_));
-    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
-    __nh.__release_ptr();
-    return iterator(__ptr);
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _Tree>
-_LIBCPP_INLINE_VISIBILITY
-void
-__tree<_Tp, _Compare, _Allocator>::__node_handle_merge_multi(_Tree& __source)
-{
-    static_assert(is_same<typename _Tree::__node_pointer, __node_pointer>::value, "");
-
-    for (typename _Tree::iterator __i = __source.begin();
-         __i != __source.end();)
-    {
-        __node_pointer __src_ptr = __i.__get_np();
-        __parent_pointer __parent;
-        __node_base_pointer& __child = __find_leaf_high(
-            __parent, _NodeTypes::__get_key(__src_ptr->__value_));
-        ++__i;
-        __source.__remove_node_pointer(__src_ptr);
-        __insert_node_at(__parent, __child,
-                         static_cast<__node_base_pointer>(__src_ptr));
-    }
+    __node_base_pointer& __child = __find_leaf_high(__parent, _NodeTypes::__get_key(__src_ptr->__value_));
+    ++__i;
+    __source.__remove_node_pointer(__src_ptr);
+    __insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__src_ptr));
+  }
 }
 
 #endif // _LIBCPP_STD_VER >= 17
 
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
-{
-    __node_pointer __np = __p.__get_np();
-    iterator __r = __remove_node_pointer(__np);
-    __node_allocator& __na = __node_alloc();
-    __node_traits::destroy(__na, _NodeTypes::__get_ptr(
-        const_cast<__node_value_type&>(*__p)));
-    __node_traits::deallocate(__na, __np, 1);
-    return __r;
+typename __tree<_Tp, _Compare, _Allocator>::iterator __tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p) {
+  __node_pointer __np    = __p.__get_np();
+  iterator __r           = __remove_node_pointer(__np);
+  __node_allocator& __na = __node_alloc();
+  __node_traits::destroy(__na, _NodeTypes::__get_ptr(const_cast<__node_value_type&>(*__p)));
+  __node_traits::deallocate(__na, __np, 1);
+  return __r;
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::erase(const_iterator __f, const_iterator __l)
-{
-    while (__f != __l)
-        __f = erase(__f);
-    return iterator(__l.__ptr_);
+__tree<_Tp, _Compare, _Allocator>::erase(const_iterator __f, const_iterator __l) {
+  while (__f != __l)
+    __f = erase(__f);
+  return iterator(__l.__ptr_);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::size_type
-__tree<_Tp, _Compare, _Allocator>::__erase_unique(const _Key& __k)
-{
-    iterator __i = find(__k);
-    if (__i == end())
-        return 0;
-    erase(__i);
-    return 1;
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::size_type
-__tree<_Tp, _Compare, _Allocator>::__erase_multi(const _Key& __k)
-{
-    pair<iterator, iterator> __p = __equal_range_multi(__k);
-    size_type __r = 0;
-    for (; __p.first != __p.second; ++__r)
-        __p.first = erase(__p.first);
-    return __r;
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::find(const _Key& __v)
-{
-    iterator __p = __lower_bound(__v, __root(), __end_node());
-    if (__p != end() && !value_comp()(__v, *__p))
-        return __p;
-    return end();
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::const_iterator
-__tree<_Tp, _Compare, _Allocator>::find(const _Key& __v) const
-{
-    const_iterator __p = __lower_bound(__v, __root(), __end_node());
-    if (__p != end() && !value_comp()(__v, *__p))
-        return __p;
-    return end();
-}
-
-template <class _Tp, class _Compare, class _Allocator>
-template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::size_type
-__tree<_Tp, _Compare, _Allocator>::__count_unique(const _Key& __k) const
-{
-    __node_pointer __rt = __root();
-    while (__rt != nullptr)
-    {
-        if (value_comp()(__k, __rt->__value_))
-        {
-            __rt = static_cast<__node_pointer>(__rt->__left_);
-        }
-        else if (value_comp()(__rt->__value_, __k))
-            __rt = static_cast<__node_pointer>(__rt->__right_);
-        else
-            return 1;
-    }
+__tree<_Tp, _Compare, _Allocator>::__erase_unique(const _Key& __k) {
+  iterator __i = find(__k);
+  if (__i == end())
     return 0;
+  erase(__i);
+  return 1;
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::size_type
-__tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const
-{
-    __iter_pointer __result = __end_node();
-    __node_pointer __rt = __root();
-    while (__rt != nullptr)
-    {
-        if (value_comp()(__k, __rt->__value_))
-        {
-            __result = static_cast<__iter_pointer>(__rt);
-            __rt = static_cast<__node_pointer>(__rt->__left_);
-        }
-        else if (value_comp()(__rt->__value_, __k))
-            __rt = static_cast<__node_pointer>(__rt->__right_);
-        else
-            return _VSTD::distance(
-                __lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
-                __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result)
-            );
-    }
-    return 0;
+__tree<_Tp, _Compare, _Allocator>::__erase_multi(const _Key& __k) {
+  pair<iterator, iterator> __p = __equal_range_multi(__k);
+  size_type __r                = 0;
+  for (; __p.first != __p.second; ++__r)
+    __p.first = erase(__p.first);
+  return __r;
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v,
-                                                 __node_pointer __root,
-                                                 __iter_pointer __result)
-{
-    while (__root != nullptr)
-    {
-        if (!value_comp()(__root->__value_, __v))
-        {
-            __result = static_cast<__iter_pointer>(__root);
-            __root = static_cast<__node_pointer>(__root->__left_);
-        }
-        else
-            __root = static_cast<__node_pointer>(__root->__right_);
-    }
-    return iterator(__result);
+typename __tree<_Tp, _Compare, _Allocator>::iterator __tree<_Tp, _Compare, _Allocator>::find(const _Key& __v) {
+  iterator __p = __lower_bound(__v, __root(), __end_node());
+  if (__p != end() && !value_comp()(__v, *__p))
+    return __p;
+  return end();
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::const_iterator
-__tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v,
-                                                 __node_pointer __root,
-                                                 __iter_pointer __result) const
-{
-    while (__root != nullptr)
-    {
-        if (!value_comp()(__root->__value_, __v))
-        {
-            __result = static_cast<__iter_pointer>(__root);
-            __root = static_cast<__node_pointer>(__root->__left_);
-        }
-        else
-            __root = static_cast<__node_pointer>(__root->__right_);
-    }
-    return const_iterator(__result);
+__tree<_Tp, _Compare, _Allocator>::find(const _Key& __v) const {
+  const_iterator __p = __lower_bound(__v, __root(), __end_node());
+  if (__p != end() && !value_comp()(__v, *__p))
+    return __p;
+  return end();
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+template <class _Key>
+typename __tree<_Tp, _Compare, _Allocator>::size_type
+__tree<_Tp, _Compare, _Allocator>::__count_unique(const _Key& __k) const {
+  __node_pointer __rt = __root();
+  while (__rt != nullptr) {
+    if (value_comp()(__k, __rt->__value_)) {
+      __rt = static_cast<__node_pointer>(__rt->__left_);
+    } else if (value_comp()(__rt->__value_, __k))
+      __rt = static_cast<__node_pointer>(__rt->__right_);
+    else
+      return 1;
+  }
+  return 0;
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+template <class _Key>
+typename __tree<_Tp, _Compare, _Allocator>::size_type
+__tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const {
+  __iter_pointer __result = __end_node();
+  __node_pointer __rt     = __root();
+  while (__rt != nullptr) {
+    if (value_comp()(__k, __rt->__value_)) {
+      __result = static_cast<__iter_pointer>(__rt);
+      __rt     = static_cast<__node_pointer>(__rt->__left_);
+    } else if (value_comp()(__rt->__value_, __k))
+      __rt = static_cast<__node_pointer>(__rt->__right_);
+    else
+      return std::distance(
+          __lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
+          __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
+  }
+  return 0;
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
-__tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v,
-                                                 __node_pointer __root,
-                                                 __iter_pointer __result)
-{
-    while (__root != nullptr)
-    {
-        if (value_comp()(__v, __root->__value_))
-        {
-            __result = static_cast<__iter_pointer>(__root);
-            __root = static_cast<__node_pointer>(__root->__left_);
-        }
-        else
-            __root = static_cast<__node_pointer>(__root->__right_);
-    }
-    return iterator(__result);
+__tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v, __node_pointer __root, __iter_pointer __result) {
+  while (__root != nullptr) {
+    if (!value_comp()(__root->__value_, __v)) {
+      __result = static_cast<__iter_pointer>(__root);
+      __root   = static_cast<__node_pointer>(__root->__left_);
+    } else
+      __root = static_cast<__node_pointer>(__root->__right_);
+  }
+  return iterator(__result);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::const_iterator
-__tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v,
-                                                 __node_pointer __root,
-                                                 __iter_pointer __result) const
-{
-    while (__root != nullptr)
-    {
-        if (value_comp()(__v, __root->__value_))
-        {
-            __result = static_cast<__iter_pointer>(__root);
-            __root = static_cast<__node_pointer>(__root->__left_);
-        }
-        else
-            __root = static_cast<__node_pointer>(__root->__right_);
-    }
-    return const_iterator(__result);
+typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare, _Allocator>::__lower_bound(
+    const _Key& __v, __node_pointer __root, __iter_pointer __result) const {
+  while (__root != nullptr) {
+    if (!value_comp()(__root->__value_, __v)) {
+      __result = static_cast<__iter_pointer>(__root);
+      __root   = static_cast<__node_pointer>(__root->__left_);
+    } else
+      __root = static_cast<__node_pointer>(__root->__right_);
+  }
+  return const_iterator(__result);
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-pair<typename __tree<_Tp, _Compare, _Allocator>::iterator,
-     typename __tree<_Tp, _Compare, _Allocator>::iterator>
-__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k)
-{
-    typedef pair<iterator, iterator> _Pp;
-    __iter_pointer __result = __end_node();
-    __node_pointer __rt = __root();
-    while (__rt != nullptr)
-    {
-        if (value_comp()(__k, __rt->__value_))
-        {
-            __result = static_cast<__iter_pointer>(__rt);
-            __rt = static_cast<__node_pointer>(__rt->__left_);
-        }
-        else if (value_comp()(__rt->__value_, __k))
-            __rt = static_cast<__node_pointer>(__rt->__right_);
-        else
-            return _Pp(iterator(__rt),
-                      iterator(
-                          __rt->__right_ != nullptr ?
-                              static_cast<__iter_pointer>(_VSTD::__tree_min(__rt->__right_))
-                            : __result));
-    }
-    return _Pp(iterator(__result), iterator(__result));
+typename __tree<_Tp, _Compare, _Allocator>::iterator
+__tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v, __node_pointer __root, __iter_pointer __result) {
+  while (__root != nullptr) {
+    if (value_comp()(__v, __root->__value_)) {
+      __result = static_cast<__iter_pointer>(__root);
+      __root   = static_cast<__node_pointer>(__root->__left_);
+    } else
+      __root = static_cast<__node_pointer>(__root->__right_);
+  }
+  return iterator(__result);
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+template <class _Key>
+typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare, _Allocator>::__upper_bound(
+    const _Key& __v, __node_pointer __root, __iter_pointer __result) const {
+  while (__root != nullptr) {
+    if (value_comp()(__v, __root->__value_)) {
+      __result = static_cast<__iter_pointer>(__root);
+      __root   = static_cast<__node_pointer>(__root->__left_);
+    } else
+      __root = static_cast<__node_pointer>(__root->__right_);
+  }
+  return const_iterator(__result);
+}
+
+template <class _Tp, class _Compare, class _Allocator>
+template <class _Key>
+pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, typename __tree<_Tp, _Compare, _Allocator>::iterator>
+__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) {
+  typedef pair<iterator, iterator> _Pp;
+  __iter_pointer __result = __end_node();
+  __node_pointer __rt     = __root();
+  while (__rt != nullptr) {
+    if (value_comp()(__k, __rt->__value_)) {
+      __result = static_cast<__iter_pointer>(__rt);
+      __rt     = static_cast<__node_pointer>(__rt->__left_);
+    } else if (value_comp()(__rt->__value_, __k))
+      __rt = static_cast<__node_pointer>(__rt->__right_);
+    else
+      return _Pp(iterator(__rt),
+                 iterator(__rt->__right_ != nullptr ? static_cast<__iter_pointer>(std::__tree_min(__rt->__right_))
+                                                    : __result));
+  }
+  return _Pp(iterator(__result), iterator(__result));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
 pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
      typename __tree<_Tp, _Compare, _Allocator>::const_iterator>
-__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const
-{
-    typedef pair<const_iterator, const_iterator> _Pp;
-    __iter_pointer __result = __end_node();
-    __node_pointer __rt = __root();
-    while (__rt != nullptr)
-    {
-        if (value_comp()(__k, __rt->__value_))
-        {
-            __result = static_cast<__iter_pointer>(__rt);
-            __rt = static_cast<__node_pointer>(__rt->__left_);
-        }
-        else if (value_comp()(__rt->__value_, __k))
-            __rt = static_cast<__node_pointer>(__rt->__right_);
-        else
-            return _Pp(const_iterator(__rt),
-                      const_iterator(
-                          __rt->__right_ != nullptr ?
-                              static_cast<__iter_pointer>(_VSTD::__tree_min(__rt->__right_))
-                            : __result));
-    }
-    return _Pp(const_iterator(__result), const_iterator(__result));
+__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const {
+  typedef pair<const_iterator, const_iterator> _Pp;
+  __iter_pointer __result = __end_node();
+  __node_pointer __rt     = __root();
+  while (__rt != nullptr) {
+    if (value_comp()(__k, __rt->__value_)) {
+      __result = static_cast<__iter_pointer>(__rt);
+      __rt     = static_cast<__node_pointer>(__rt->__left_);
+    } else if (value_comp()(__rt->__value_, __k))
+      __rt = static_cast<__node_pointer>(__rt->__right_);
+    else
+      return _Pp(
+          const_iterator(__rt),
+          const_iterator(
+              __rt->__right_ != nullptr ? static_cast<__iter_pointer>(std::__tree_min(__rt->__right_)) : __result));
+  }
+  return _Pp(const_iterator(__result), const_iterator(__result));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-pair<typename __tree<_Tp, _Compare, _Allocator>::iterator,
-     typename __tree<_Tp, _Compare, _Allocator>::iterator>
-__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k)
-{
-    typedef pair<iterator, iterator> _Pp;
-    __iter_pointer __result = __end_node();
-    __node_pointer __rt = __root();
-    while (__rt != nullptr)
-    {
-        if (value_comp()(__k, __rt->__value_))
-        {
-            __result = static_cast<__iter_pointer>(__rt);
-            __rt = static_cast<__node_pointer>(__rt->__left_);
-        }
-        else if (value_comp()(__rt->__value_, __k))
-            __rt = static_cast<__node_pointer>(__rt->__right_);
-        else
-            return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
-                      __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
-    }
-    return _Pp(iterator(__result), iterator(__result));
+pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, typename __tree<_Tp, _Compare, _Allocator>::iterator>
+__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) {
+  typedef pair<iterator, iterator> _Pp;
+  __iter_pointer __result = __end_node();
+  __node_pointer __rt     = __root();
+  while (__rt != nullptr) {
+    if (value_comp()(__k, __rt->__value_)) {
+      __result = static_cast<__iter_pointer>(__rt);
+      __rt     = static_cast<__node_pointer>(__rt->__left_);
+    } else if (value_comp()(__rt->__value_, __k))
+      __rt = static_cast<__node_pointer>(__rt->__right_);
+    else
+      return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
+                 __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
+  }
+  return _Pp(iterator(__result), iterator(__result));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
 pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
      typename __tree<_Tp, _Compare, _Allocator>::const_iterator>
-__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const
-{
-    typedef pair<const_iterator, const_iterator> _Pp;
-    __iter_pointer __result = __end_node();
-    __node_pointer __rt = __root();
-    while (__rt != nullptr)
-    {
-        if (value_comp()(__k, __rt->__value_))
-        {
-            __result = static_cast<__iter_pointer>(__rt);
-            __rt = static_cast<__node_pointer>(__rt->__left_);
-        }
-        else if (value_comp()(__rt->__value_, __k))
-            __rt = static_cast<__node_pointer>(__rt->__right_);
-        else
-            return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
-                      __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
-    }
-    return _Pp(const_iterator(__result), const_iterator(__result));
+__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const {
+  typedef pair<const_iterator, const_iterator> _Pp;
+  __iter_pointer __result = __end_node();
+  __node_pointer __rt     = __root();
+  while (__rt != nullptr) {
+    if (value_comp()(__k, __rt->__value_)) {
+      __result = static_cast<__iter_pointer>(__rt);
+      __rt     = static_cast<__node_pointer>(__rt->__left_);
+    } else if (value_comp()(__rt->__value_, __k))
+      __rt = static_cast<__node_pointer>(__rt->__right_);
+    else
+      return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__iter_pointer>(__rt)),
+                 __upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));
+  }
+  return _Pp(const_iterator(__result), const_iterator(__result));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_holder
-__tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT
-{
-    __node_pointer __np = __p.__get_np();
-    if (__begin_node() == __p.__ptr_)
-    {
-        if (__np->__right_ != nullptr)
-            __begin_node() = static_cast<__iter_pointer>(__np->__right_);
-        else
-            __begin_node() = static_cast<__iter_pointer>(__np->__parent_);
-    }
-    --size();
-    _VSTD::__tree_remove(__end_node()->__left_,
-                         static_cast<__node_base_pointer>(__np));
-    return __node_holder(__np, _Dp(__node_alloc(), true));
+__tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT {
+  __node_pointer __np = __p.__get_np();
+  if (__begin_node() == __p.__ptr_) {
+    if (__np->__right_ != nullptr)
+      __begin_node() = static_cast<__iter_pointer>(__np->__right_);
+    else
+      __begin_node() = static_cast<__iter_pointer>(__np->__parent_);
+  }
+  --size();
+  std::__tree_remove(__end_node()->__left_, static_cast<__node_base_pointer>(__np));
+  return __node_holder(__np, _Dp(__node_alloc(), true));
 }
 
 template <class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(__tree<_Tp, _Compare, _Allocator>& __x,
-     __tree<_Tp, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void swap(__tree<_Tp, _Compare, _Allocator>& __x, __tree<_Tp, _Compare, _Allocator>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__tuple/find_index.h b/third_party/libcxx/__tuple/find_index.h
new file mode 100644
index 000000000..133b00419
--- /dev/null
+++ b/third_party/libcxx/__tuple/find_index.h
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TUPLE_FIND_INDEX_H
+#define _LIBCPP___TUPLE_FIND_INDEX_H
+
+#include <__config>
+#include <__type_traits/is_same.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 14
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __find_detail {
+
+static constexpr size_t __not_found = static_cast<size_t>(-1);
+static constexpr size_t __ambiguous = __not_found - 1;
+
+inline _LIBCPP_HIDE_FROM_ABI constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
+  return !__matches ? __res : (__res == __not_found ? __curr_i : __ambiguous);
+}
+
+template <size_t _Nx>
+inline _LIBCPP_HIDE_FROM_ABI constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
+  return __i == _Nx
+           ? __not_found
+           : __find_detail::__find_idx_return(__i, __find_detail::__find_idx(__i + 1, __matches), __matches[__i]);
+}
+
+template <class _T1, class... _Args>
+struct __find_exactly_one_checked {
+  static constexpr bool __matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...};
+  static constexpr size_t value                     = __find_detail::__find_idx(0, __matches);
+  static_assert(value != __not_found, "type not found in type list");
+  static_assert(value != __ambiguous, "type occurs more than once in type list");
+};
+
+template <class _T1>
+struct __find_exactly_one_checked<_T1> {
+  static_assert(!is_same<_T1, _T1>::value, "type not in empty type list");
+};
+
+} // namespace __find_detail
+
+template <typename _T1, typename... _Args>
+struct __find_exactly_one_t : public __find_detail::__find_exactly_one_checked<_T1, _Args...> {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 14
+
+#endif // _LIBCPP___TUPLE_FIND_INDEX_H
diff --git a/third_party/libcxx/__tuple/ignore.h b/third_party/libcxx/__tuple/ignore.h
new file mode 100644
index 000000000..43cce5387
--- /dev/null
+++ b/third_party/libcxx/__tuple/ignore.h
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TUPLE_IGNORE_H
+#define _LIBCPP___TUPLE_IGNORE_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#ifndef _LIBCPP_CXX03_LANG
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct __ignore_type {
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const __ignore_type& operator=(const _Tp&) const noexcept {
+    return *this;
+  }
+};
+
+#  if _LIBCPP_STD_VER >= 17
+inline constexpr __ignore_type ignore;
+#  else
+constexpr __ignore_type ignore;
+#  endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_CXX03_LANG
+
+#endif // _LIBCPP___TUPLE_IGNORE_H
diff --git a/third_party/libcxx/__tuple/make_tuple_types.h b/third_party/libcxx/__tuple/make_tuple_types.h
index aee2bde89..9e0fefae2 100644
--- a/third_party/libcxx/__tuple/make_tuple_types.h
+++ b/third_party/libcxx/__tuple/make_tuple_types.h
@@ -16,7 +16,7 @@
 #include <__tuple/tuple_indices.h>
 #include <__tuple/tuple_size.h>
 #include <__tuple/tuple_types.h>
-#include <__type_traits/apply_cv.h>
+#include <__type_traits/copy_cvref.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_reference.h>
 #include <cstddef>
@@ -37,38 +37,38 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _TupleTypes, class _TupleIndices>
 struct __make_tuple_types_flat;
 
-template <template <class...> class _Tuple, class ..._Types, size_t ..._Idx>
+template <template <class...> class _Tuple, class... _Types, size_t... _Idx>
 struct __make_tuple_types_flat<_Tuple<_Types...>, __tuple_indices<_Idx...>> {
   // Specialization for pair, tuple, and __tuple_types
   template <class _Tp>
-  using __apply_quals _LIBCPP_NODEBUG = __tuple_types<__apply_cv_t<_Tp, __type_pack_element<_Idx, _Types...>>...>;
+  using __apply_quals _LIBCPP_NODEBUG = __tuple_types<__copy_cvref_t<_Tp, __type_pack_element<_Idx, _Types...>>...>;
 };
 
-template <class _Vt, size_t _Np, size_t ..._Idx>
+template <class _Vt, size_t _Np, size_t... _Idx>
 struct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>> {
   template <size_t>
   using __value_type = _Vt;
   template <class _Tp>
-  using __apply_quals = __tuple_types<__apply_cv_t<_Tp, __value_type<_Idx>>...>;
+  using __apply_quals = __tuple_types<__copy_cvref_t<_Tp, __value_type<_Idx>>...>;
 };
 
-template <class _Tp, size_t _Ep = tuple_size<__libcpp_remove_reference_t<_Tp> >::value,
-          size_t _Sp = 0,
+template <class _Tp,
+          size_t _Ep     = tuple_size<__libcpp_remove_reference_t<_Tp> >::value,
+          size_t _Sp     = 0,
           bool _SameSize = (_Ep == tuple_size<__libcpp_remove_reference_t<_Tp> >::value)>
-struct __make_tuple_types
-{
-    static_assert(_Sp <= _Ep, "__make_tuple_types input error");
-    using _RawTp = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >;
-    using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>;
-    using type = typename _Maker::template __apply_quals<_Tp>;
+struct __make_tuple_types {
+  static_assert(_Sp <= _Ep, "__make_tuple_types input error");
+  using _RawTp = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >;
+  using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>;
+  using type   = typename _Maker::template __apply_quals<_Tp>;
 };
 
-template <class ..._Types, size_t _Ep>
+template <class... _Types, size_t _Ep>
 struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> {
   typedef _LIBCPP_NODEBUG __tuple_types<_Types...> type;
 };
 
-template <class ..._Types, size_t _Ep>
+template <class... _Types, size_t _Ep>
 struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> {
   typedef _LIBCPP_NODEBUG __tuple_types<_Types...> type;
 };
diff --git a/third_party/libcxx/__tuple/pair_like.h b/third_party/libcxx/__tuple/pair_like.h
deleted file mode 100644
index 192682dc7..000000000
--- a/third_party/libcxx/__tuple/pair_like.h
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TUPLE_PAIR_LIKE_H
-#define _LIBCPP___TUPLE_PAIR_LIKE_H
-
-#include <__config>
-#include <__tuple/tuple_like.h>
-#include <__tuple/tuple_size.h>
-#include <__type_traits/remove_cvref.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 20
-
-template <class _Tp>
-concept __pair_like = __tuple_like<_Tp> && tuple_size<remove_cvref_t<_Tp>>::value == 2;
-
-#endif // _LIBCPP_STD_VER >= 20
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TUPLE_PAIR_LIKE_H
diff --git a/third_party/libcxx/__tuple/sfinae_helpers.h b/third_party/libcxx/__tuple/sfinae_helpers.h
index 384e3ca5a..c7145e0b0 100644
--- a/third_party/libcxx/__tuple/sfinae_helpers.h
+++ b/third_party/libcxx/__tuple/sfinae_helpers.h
@@ -16,11 +16,10 @@
 #include <__tuple/tuple_like_ext.h>
 #include <__tuple/tuple_size.h>
 #include <__tuple/tuple_types.h>
+#include <__type_traits/conjunction.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
-#include <__type_traits/is_convertible.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
@@ -34,90 +33,50 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template <bool ..._Preds>
-struct __all_dummy;
-
-template <bool ..._Pred>
-struct __all : _IsSame<__all_dummy<_Pred...>, __all_dummy<((void)_Pred, true)...>> {};
-
 struct __tuple_sfinae_base {
-  template <template <class, class...> class _Trait,
-            class ..._LArgs, class ..._RArgs>
-  static auto __do_test(__tuple_types<_LArgs...>, __tuple_types<_RArgs...>)
-    -> __all<__enable_if_t<_Trait<_LArgs, _RArgs>::value, bool>{true}...>;
+  template <template <class, class...> class _Trait, class... _LArgs, class... _RArgs>
+  static auto __do_test(__tuple_types<_LArgs...>,
+                        __tuple_types<_RArgs...>) -> __all<__enable_if_t<_Trait<_LArgs, _RArgs>::value, bool>{true}...>;
   template <template <class...> class>
   static auto __do_test(...) -> false_type;
 
   template <class _FromArgs, class _ToArgs>
   using __constructible = decltype(__do_test<is_constructible>(_ToArgs{}, _FromArgs{}));
-  template <class _FromArgs, class _ToArgs>
-  using __convertible = decltype(__do_test<is_convertible>(_FromArgs{}, _ToArgs{}));
-  template <class _FromArgs, class _ToArgs>
-  using __assignable = decltype(__do_test<is_assignable>(_ToArgs{}, _FromArgs{}));
 };
 
-// __tuple_convertible
-
-template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
-                                bool = __tuple_like_ext<_Up>::value>
-struct __tuple_convertible
-    : public false_type {};
-
-template <class _Tp, class _Up>
-struct __tuple_convertible<_Tp, _Up, true, true>
-    : public __tuple_sfinae_base::__convertible<
-      typename __make_tuple_types<_Tp>::type
-    , typename __make_tuple_types<_Up>::type
-    >
-{};
-
 // __tuple_constructible
 
-template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
-                                bool = __tuple_like_ext<_Up>::value>
-struct __tuple_constructible
-    : public false_type {};
+template <class _Tp,
+          class _Up,
+          bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
+          bool = __tuple_like_ext<_Up>::value>
+struct __tuple_constructible : public false_type {};
 
 template <class _Tp, class _Up>
 struct __tuple_constructible<_Tp, _Up, true, true>
-    : public __tuple_sfinae_base::__constructible<
-      typename __make_tuple_types<_Tp>::type
-    , typename __make_tuple_types<_Up>::type
-    >
-{};
+    : public __tuple_sfinae_base::__constructible< typename __make_tuple_types<_Tp>::type,
+                                                   typename __make_tuple_types<_Up>::type > {};
 
-// __tuple_assignable
-
-template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
-                                bool = __tuple_like_ext<_Up>::value>
-struct __tuple_assignable
-    : public false_type {};
-
-template <class _Tp, class _Up>
-struct __tuple_assignable<_Tp, _Up, true, true>
-    : public __tuple_sfinae_base::__assignable<
-      typename __make_tuple_types<_Tp>::type
-    , typename __make_tuple_types<_Up&>::type
-    >
-{};
-
-
-template <size_t _Ip, class ..._Tp>
-struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> >
-{
-    typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
+template <size_t _Ip, class... _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> > {
+  typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
 };
 
-struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
-
-    static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() { return false; }
-    static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() { return false; }
-    template <class ...>
-    static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit() { return false; }
-    template <class ...>
-    static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit() { return false; }
-    template <class ...>
-    static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_assign() { return false; }
+struct _LIBCPP_EXPORTED_FROM_ABI __check_tuple_constructor_fail {
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() { return false; }
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() { return false; }
+  template <class...>
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit() {
+    return false;
+  }
+  template <class...>
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit() {
+    return false;
+  }
+  template <class...>
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_assign() {
+    return false;
+  }
 };
 #endif // !defined(_LIBCPP_CXX03_LANG)
 
@@ -127,54 +86,54 @@ template <bool _CanCopy, bool _CanMove>
 struct __sfinae_ctor_base {};
 template <>
 struct __sfinae_ctor_base<false, false> {
-  __sfinae_ctor_base() = default;
-  __sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
-  __sfinae_ctor_base(__sfinae_ctor_base &&) = delete;
+  __sfinae_ctor_base()                                     = default;
+  __sfinae_ctor_base(__sfinae_ctor_base const&)            = delete;
+  __sfinae_ctor_base(__sfinae_ctor_base&&)                 = delete;
   __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
-  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
+  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&)      = default;
 };
 template <>
 struct __sfinae_ctor_base<true, false> {
-  __sfinae_ctor_base() = default;
-  __sfinae_ctor_base(__sfinae_ctor_base const&) = default;
-  __sfinae_ctor_base(__sfinae_ctor_base &&) = delete;
+  __sfinae_ctor_base()                                     = default;
+  __sfinae_ctor_base(__sfinae_ctor_base const&)            = default;
+  __sfinae_ctor_base(__sfinae_ctor_base&&)                 = delete;
   __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
-  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
+  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&)      = default;
 };
 template <>
 struct __sfinae_ctor_base<false, true> {
-  __sfinae_ctor_base() = default;
-  __sfinae_ctor_base(__sfinae_ctor_base const&) = delete;
-  __sfinae_ctor_base(__sfinae_ctor_base &&) = default;
+  __sfinae_ctor_base()                                     = default;
+  __sfinae_ctor_base(__sfinae_ctor_base const&)            = delete;
+  __sfinae_ctor_base(__sfinae_ctor_base&&)                 = default;
   __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default;
-  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default;
+  __sfinae_ctor_base& operator=(__sfinae_ctor_base&&)      = default;
 };
 
 template <bool _CanCopy, bool _CanMove>
 struct __sfinae_assign_base {};
 template <>
 struct __sfinae_assign_base<false, false> {
-  __sfinae_assign_base() = default;
-  __sfinae_assign_base(__sfinae_assign_base const&) = default;
-  __sfinae_assign_base(__sfinae_assign_base &&) = default;
+  __sfinae_assign_base()                                       = default;
+  __sfinae_assign_base(__sfinae_assign_base const&)            = default;
+  __sfinae_assign_base(__sfinae_assign_base&&)                 = default;
   __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
-  __sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete;
+  __sfinae_assign_base& operator=(__sfinae_assign_base&&)      = delete;
 };
 template <>
 struct __sfinae_assign_base<true, false> {
-  __sfinae_assign_base() = default;
-  __sfinae_assign_base(__sfinae_assign_base const&) = default;
-  __sfinae_assign_base(__sfinae_assign_base &&) = default;
+  __sfinae_assign_base()                                       = default;
+  __sfinae_assign_base(__sfinae_assign_base const&)            = default;
+  __sfinae_assign_base(__sfinae_assign_base&&)                 = default;
   __sfinae_assign_base& operator=(__sfinae_assign_base const&) = default;
-  __sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete;
+  __sfinae_assign_base& operator=(__sfinae_assign_base&&)      = delete;
 };
 template <>
 struct __sfinae_assign_base<false, true> {
-  __sfinae_assign_base() = default;
-  __sfinae_assign_base(__sfinae_assign_base const&) = default;
-  __sfinae_assign_base(__sfinae_assign_base &&) = default;
+  __sfinae_assign_base()                                       = default;
+  __sfinae_assign_base(__sfinae_assign_base const&)            = default;
+  __sfinae_assign_base(__sfinae_assign_base&&)                 = default;
   __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete;
-  __sfinae_assign_base& operator=(__sfinae_assign_base&&) = default;
+  __sfinae_assign_base& operator=(__sfinae_assign_base&&)      = default;
 };
 #endif // _LIBCPP_STD_VER >= 17
 
diff --git a/third_party/libcxx/__tuple/tuple_element.h b/third_party/libcxx/__tuple/tuple_element.h
index 478dd089d..9127c47dc 100644
--- a/third_party/libcxx/__tuple/tuple_element.h
+++ b/third_party/libcxx/__tuple/tuple_element.h
@@ -12,9 +12,6 @@
 #include <__config>
 #include <__tuple/tuple_indices.h>
 #include <__tuple/tuple_types.h>
-#include <__type_traits/add_const.h>
-#include <__type_traits/add_cv.h>
-#include <__type_traits/add_volatile.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -23,68 +20,36 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <size_t _Ip, class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_element;
+template <size_t _Ip, class _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_element;
 
 template <size_t _Ip, class _Tp>
-struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp>
-{
-    typedef _LIBCPP_NODEBUG typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp> {
+  typedef _LIBCPP_NODEBUG const typename tuple_element<_Ip, _Tp>::type type;
 };
 
 template <size_t _Ip, class _Tp>
-struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp>
-{
-    typedef _LIBCPP_NODEBUG typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp> {
+  typedef _LIBCPP_NODEBUG volatile typename tuple_element<_Ip, _Tp>::type type;
 };
 
 template <size_t _Ip, class _Tp>
-struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp>
-{
-    typedef _LIBCPP_NODEBUG typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp> {
+  typedef _LIBCPP_NODEBUG const volatile typename tuple_element<_Ip, _Tp>::type type;
 };
 
 #ifndef _LIBCPP_CXX03_LANG
 
-#if !__has_builtin(__type_pack_element)
-
-namespace __indexer_detail {
-
-template <size_t _Idx, class _Tp>
-struct __indexed { using type _LIBCPP_NODEBUG = _Tp; };
-
-template <class _Types, class _Indexes> struct __indexer;
-
-template <class ..._Types, size_t ..._Idx>
-struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>>
-    : __indexed<_Idx, _Types>...
-{};
-
-template <size_t _Idx, class _Tp>
-__indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&);
-
-} // namespace __indexer_detail
-
-template <size_t _Idx, class ..._Types>
-using __type_pack_element _LIBCPP_NODEBUG = typename decltype(
-    __indexer_detail::__at_index<_Idx>(
-        __indexer_detail::__indexer<
-            __tuple_types<_Types...>,
-            typename __make_tuple_indices<sizeof...(_Types)>::type
-        >{})
-  )::type;
-#endif
-
-template <size_t _Ip, class ..._Types>
-struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...> >
-{
-    static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
-    typedef _LIBCPP_NODEBUG __type_pack_element<_Ip, _Types...> type;
+template <size_t _Ip, class... _Types>
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...> > {
+  static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
+  typedef _LIBCPP_NODEBUG __type_pack_element<_Ip, _Types...> type;
 };
 
-#if _LIBCPP_STD_VER >= 14
-template <size_t _Ip, class ..._Tp>
-using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element <_Ip, _Tp...>::type;
-#endif
+#  if _LIBCPP_STD_VER >= 14
+template <size_t _Ip, class... _Tp>
+using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element<_Ip, _Tp...>::type;
+#  endif
 
 #endif // _LIBCPP_CXX03_LANG
 
diff --git a/third_party/libcxx/__tuple/tuple_indices.h b/third_party/libcxx/__tuple/tuple_indices.h
index 18666d594..501e71125 100644
--- a/third_party/libcxx/__tuple/tuple_indices.h
+++ b/third_party/libcxx/__tuple/tuple_indices.h
@@ -21,13 +21,13 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <size_t...> struct __tuple_indices {};
+template <size_t...>
+struct __tuple_indices {};
 
 template <size_t _Ep, size_t _Sp = 0>
-struct __make_tuple_indices
-{
-    static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
-    typedef __make_indices_imp<_Ep, _Sp> type;
+struct __make_tuple_indices {
+  static_assert(_Sp <= _Ep, "__make_tuple_indices input error");
+  typedef __make_indices_imp<_Ep, _Sp> type;
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__tuple/tuple_like.h b/third_party/libcxx/__tuple/tuple_like.h
index dab395be6..c080a3dcf 100644
--- a/third_party/libcxx/__tuple/tuple_like.h
+++ b/third_party/libcxx/__tuple/tuple_like.h
@@ -10,13 +10,10 @@
 #define _LIBCPP___TUPLE_TUPLE_LIKE_H
 
 #include <__config>
-#include <__fwd/array.h>
-#include <__fwd/pair.h>
 #include <__fwd/subrange.h>
-#include <__fwd/tuple.h>
-#include <__type_traits/integral_constant.h>
+#include <__tuple/tuple_like_no_subrange.h>
+#include <__tuple/tuple_size.h>
 #include <__type_traits/remove_cvref.h>
-#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -27,22 +24,16 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 
 template <class _Tp>
-struct __tuple_like_impl : false_type {};
+inline constexpr bool __is_ranges_subrange_v = false;
 
-template <class... _Tp>
-struct __tuple_like_impl<tuple<_Tp...> > : true_type {};
-
-template <class _T1, class _T2>
-struct __tuple_like_impl<pair<_T1, _T2> > : true_type {};
-
-template <class _Tp, size_t _Size>
-struct __tuple_like_impl<array<_Tp, _Size> > : true_type {};
-
-template <class _Ip, class _Sp, ranges::subrange_kind _Kp>
-struct __tuple_like_impl<ranges::subrange<_Ip, _Sp, _Kp> > : true_type {};
+template <class _Iter, class _Sent, ranges::subrange_kind _Kind>
+inline constexpr bool __is_ranges_subrange_v<ranges::subrange<_Iter, _Sent, _Kind>> = true;
 
 template <class _Tp>
-concept __tuple_like = __tuple_like_impl<remove_cvref_t<_Tp>>::value;
+concept __tuple_like = __tuple_like_no_subrange<_Tp> || __is_ranges_subrange_v<remove_cvref_t<_Tp>>;
+
+// As of writing this comment every use of `pair-like` in the standard excludes `ranges::subrange`, so
+// you most likely want to use `__pair_like_no_subrange` if you're looking for `pair-like`.
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__tuple/tuple_like_ext.h b/third_party/libcxx/__tuple/tuple_like_ext.h
index 36f5c4896..0cc21e0b7 100644
--- a/third_party/libcxx/__tuple/tuple_like_ext.h
+++ b/third_party/libcxx/__tuple/tuple_like_ext.h
@@ -23,21 +23,29 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct __tuple_like_ext : false_type {};
+template <class _Tp>
+struct __tuple_like_ext : false_type {};
 
-template <class _Tp> struct __tuple_like_ext<const _Tp> : public __tuple_like_ext<_Tp> {};
-template <class _Tp> struct __tuple_like_ext<volatile _Tp> : public __tuple_like_ext<_Tp> {};
-template <class _Tp> struct __tuple_like_ext<const volatile _Tp> : public __tuple_like_ext<_Tp> {};
+template <class _Tp>
+struct __tuple_like_ext<const _Tp> : public __tuple_like_ext<_Tp> {};
+template <class _Tp>
+struct __tuple_like_ext<volatile _Tp> : public __tuple_like_ext<_Tp> {};
+template <class _Tp>
+struct __tuple_like_ext<const volatile _Tp> : public __tuple_like_ext<_Tp> {};
 
 #ifndef _LIBCPP_CXX03_LANG
-template <class... _Tp> struct __tuple_like_ext<tuple<_Tp...> > : true_type {};
+template <class... _Tp>
+struct __tuple_like_ext<tuple<_Tp...> > : true_type {};
 #endif
 
-template <class _T1, class _T2> struct __tuple_like_ext<pair<_T1, _T2> > : true_type {};
+template <class _T1, class _T2>
+struct __tuple_like_ext<pair<_T1, _T2> > : true_type {};
 
-template <class _Tp, size_t _Size> struct __tuple_like_ext<array<_Tp, _Size> > : true_type {};
+template <class _Tp, size_t _Size>
+struct __tuple_like_ext<array<_Tp, _Size> > : true_type {};
 
-template <class... _Tp> struct __tuple_like_ext<__tuple_types<_Tp...> > : true_type {};
+template <class... _Tp>
+struct __tuple_like_ext<__tuple_types<_Tp...> > : true_type {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__tuple/tuple_like_no_subrange.h b/third_party/libcxx/__tuple/tuple_like_no_subrange.h
new file mode 100644
index 000000000..274b0bf18
--- /dev/null
+++ b/third_party/libcxx/__tuple/tuple_like_no_subrange.h
@@ -0,0 +1,61 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TUPLE_TUPLE_LIKE_NO_SUBRANGE_H
+#define _LIBCPP___TUPLE_TUPLE_LIKE_NO_SUBRANGE_H
+
+#include <__config>
+#include <__fwd/array.h>
+#include <__fwd/complex.h>
+#include <__fwd/pair.h>
+#include <__fwd/tuple.h>
+#include <__tuple/tuple_size.h>
+#include <__type_traits/remove_cvref.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp>
+inline constexpr bool __tuple_like_no_subrange_impl = false;
+
+template <class... _Tp>
+inline constexpr bool __tuple_like_no_subrange_impl<tuple<_Tp...>> = true;
+
+template <class _T1, class _T2>
+inline constexpr bool __tuple_like_no_subrange_impl<pair<_T1, _T2>> = true;
+
+template <class _Tp, size_t _Size>
+inline constexpr bool __tuple_like_no_subrange_impl<array<_Tp, _Size>> = true;
+
+#  if _LIBCPP_STD_VER >= 26
+
+template <class _Tp>
+inline constexpr bool __tuple_like_no_subrange_impl<complex<_Tp>> = true;
+
+#  endif
+
+template <class _Tp>
+concept __tuple_like_no_subrange = __tuple_like_no_subrange_impl<remove_cvref_t<_Tp>>;
+
+// This is equivalent to the exposition-only type trait `pair-like`, except that it is false for specializations of
+// `ranges::subrange`. This is more useful than the pair-like concept in the standard because every use of `pair-like`
+// excludes `ranges::subrange`.
+template <class _Tp>
+concept __pair_like_no_subrange = __tuple_like_no_subrange<_Tp> && tuple_size<remove_cvref_t<_Tp>>::value == 2;
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TUPLE_TUPLE_LIKE_NO_SUBRANGE_H
diff --git a/third_party/libcxx/__tuple/tuple_size.h b/third_party/libcxx/__tuple/tuple_size.h
index 26f9d9725..18a17fd4d 100644
--- a/third_party/libcxx/__tuple/tuple_size.h
+++ b/third_party/libcxx/__tuple/tuple_size.h
@@ -22,51 +22,51 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size;
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_size;
 
 #if !defined(_LIBCPP_CXX03_LANG)
 template <class _Tp, class...>
 using __enable_if_tuple_size_imp = _Tp;
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
-    const _Tp,
-    __enable_if_t<!is_volatile<_Tp>::value>,
-    integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
+struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< const _Tp,
+                                                                   __enable_if_t<!is_volatile<_Tp>::value>,
+                                                                   integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
     : public integral_constant<size_t, tuple_size<_Tp>::value> {};
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
-    volatile _Tp,
-    __enable_if_t<!is_const<_Tp>::value>,
-    integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
+struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< volatile _Tp,
+                                                                   __enable_if_t<!is_const<_Tp>::value>,
+                                                                   integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
     : public integral_constant<size_t, tuple_size<_Tp>::value> {};
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp<
-    const volatile _Tp,
-    integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
+struct _LIBCPP_TEMPLATE_VIS
+tuple_size<__enable_if_tuple_size_imp<const volatile _Tp, integral_constant<size_t, sizeof(tuple_size<_Tp>)>>>
     : public integral_constant<size_t, tuple_size<_Tp>::value> {};
 
 #else
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template <class ..._Tp>
-struct _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> >
-    : public integral_constant<size_t, sizeof...(_Tp)>
-{
-};
+template <class... _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> {};
 
-template <class ..._Tp>
-struct _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> >
-    : public integral_constant<size_t, sizeof...(_Tp)>
-{
-};
+template <class... _Tp>
+struct _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> {};
+
+#  if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
+#  endif
 
 #endif // _LIBCPP_CXX03_LANG
 
diff --git a/third_party/libcxx/__tuple/tuple_types.h b/third_party/libcxx/__tuple/tuple_types.h
index c5be81cce..7e1256cf8 100644
--- a/third_party/libcxx/__tuple/tuple_types.h
+++ b/third_party/libcxx/__tuple/tuple_types.h
@@ -17,7 +17,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class ..._Tp> struct __tuple_types {};
+template <class... _Tp>
+struct __tuple_types {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/add_const.h b/third_party/libcxx/__type_traits/add_const.h
index 44d4058ba..9a6f1c102 100644
--- a/third_party/libcxx/__type_traits/add_const.h
+++ b/third_party/libcxx/__type_traits/add_const.h
@@ -17,12 +17,14 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_const {
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS add_const {
   typedef _LIBCPP_NODEBUG const _Tp type;
 };
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using add_const_t = typename add_const<_Tp>::type;
+template <class _Tp>
+using add_const_t = typename add_const<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/add_cv.h b/third_party/libcxx/__type_traits/add_cv.h
index ee821b329..9e23e5ceb 100644
--- a/third_party/libcxx/__type_traits/add_cv.h
+++ b/third_party/libcxx/__type_traits/add_cv.h
@@ -17,12 +17,14 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_cv {
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS add_cv {
   typedef _LIBCPP_NODEBUG const volatile _Tp type;
 };
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
+template <class _Tp>
+using add_cv_t = typename add_cv<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/add_lvalue_reference.h b/third_party/libcxx/__type_traits/add_lvalue_reference.h
index 848cc21f6..a633e3904 100644
--- a/third_party/libcxx/__type_traits/add_lvalue_reference.h
+++ b/third_party/libcxx/__type_traits/add_lvalue_reference.h
@@ -45,7 +45,8 @@ struct add_lvalue_reference {
 };
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using add_lvalue_reference_t = __add_lvalue_reference_t<_Tp>;
+template <class _Tp>
+using add_lvalue_reference_t = __add_lvalue_reference_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/add_pointer.h b/third_party/libcxx/__type_traits/add_pointer.h
index 1e74dafaf..5aac7d5cf 100644
--- a/third_party/libcxx/__type_traits/add_pointer.h
+++ b/third_party/libcxx/__type_traits/add_pointer.h
@@ -11,9 +11,7 @@
 
 #include <__config>
 #include <__type_traits/is_referenceable.h>
-#include <__type_traits/is_same.h>
 #include <__type_traits/is_void.h>
-#include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_reference.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -28,13 +26,14 @@ template <class _Tp>
 using __add_pointer_t = __add_pointer(_Tp);
 
 #else
-template <class _Tp,
-          bool = __libcpp_is_referenceable<_Tp>::value || is_void<_Tp>::value>
+template <class _Tp, bool = __libcpp_is_referenceable<_Tp>::value || is_void<_Tp>::value>
 struct __add_pointer_impl {
   typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp>* type;
 };
-template <class _Tp> struct __add_pointer_impl<_Tp, false>
-    {typedef _LIBCPP_NODEBUG _Tp type;};
+template <class _Tp>
+struct __add_pointer_impl<_Tp, false> {
+  typedef _LIBCPP_NODEBUG _Tp type;
+};
 
 template <class _Tp>
 using __add_pointer_t = typename __add_pointer_impl<_Tp>::type;
@@ -47,7 +46,8 @@ struct add_pointer {
 };
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using add_pointer_t = __add_pointer_t<_Tp>;
+template <class _Tp>
+using add_pointer_t = __add_pointer_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/add_volatile.h b/third_party/libcxx/__type_traits/add_volatile.h
index f4fc42f69..56b7dfaac 100644
--- a/third_party/libcxx/__type_traits/add_volatile.h
+++ b/third_party/libcxx/__type_traits/add_volatile.h
@@ -17,12 +17,14 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_volatile {
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS add_volatile {
   typedef _LIBCPP_NODEBUG volatile _Tp type;
 };
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using add_volatile_t = typename add_volatile<_Tp>::type;
+template <class _Tp>
+using add_volatile_t = typename add_volatile<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/aligned_storage.h b/third_party/libcxx/__type_traits/aligned_storage.h
index 29938d286..46aae1283 100644
--- a/third_party/libcxx/__type_traits/aligned_storage.h
+++ b/third_party/libcxx/__type_traits/aligned_storage.h
@@ -23,59 +23,63 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct __align_type
-{
-    static const size_t value = _LIBCPP_PREFERRED_ALIGNOF(_Tp);
-    typedef _Tp type;
+struct __align_type {
+  static const size_t value = _LIBCPP_PREFERRED_ALIGNOF(_Tp);
+  typedef _Tp type;
 };
 
-struct __struct_double {long double __lx;};
-struct __struct_double4 {double __lx[4];};
+struct __struct_double {
+  long double __lx;
+};
+struct __struct_double4 {
+  double __lx[4];
+};
 
-typedef
-    __type_list<__align_type<unsigned char>,
-    __type_list<__align_type<unsigned short>,
-    __type_list<__align_type<unsigned int>,
-    __type_list<__align_type<unsigned long>,
-    __type_list<__align_type<unsigned long long>,
-    __type_list<__align_type<double>,
-    __type_list<__align_type<long double>,
-    __type_list<__align_type<__struct_double>,
-    __type_list<__align_type<__struct_double4>,
-    __type_list<__align_type<int*>,
-    __nat
-    > > > > > > > > > > __all_types;
+// clang-format off
+typedef __type_list<__align_type<unsigned char>,
+        __type_list<__align_type<unsigned short>,
+        __type_list<__align_type<unsigned int>,
+        __type_list<__align_type<unsigned long>,
+        __type_list<__align_type<unsigned long long>,
+        __type_list<__align_type<double>,
+        __type_list<__align_type<long double>,
+        __type_list<__align_type<__struct_double>,
+        __type_list<__align_type<__struct_double4>,
+        __type_list<__align_type<int*>,
+        __nat
+        > > > > > > > > > > __all_types;
+// clang-format on
 
 template <size_t _Align>
 struct _ALIGNAS(_Align) __fallback_overaligned {};
 
-template <class _TL, size_t _Align> struct __find_pod;
+template <class _TL, size_t _Align>
+struct __find_pod;
 
 template <class _Hp, size_t _Align>
-struct __find_pod<__type_list<_Hp, __nat>, _Align>
-{
-    typedef __conditional_t<_Align == _Hp::value, typename _Hp::type, __fallback_overaligned<_Align> > type;
+struct __find_pod<__type_list<_Hp, __nat>, _Align> {
+  typedef __conditional_t<_Align == _Hp::value, typename _Hp::type, __fallback_overaligned<_Align> > type;
 };
 
 template <class _Hp, class _Tp, size_t _Align>
-struct __find_pod<__type_list<_Hp, _Tp>, _Align>
-{
-    typedef __conditional_t<_Align == _Hp::value, typename _Hp::type, typename __find_pod<_Tp, _Align>::type> type;
+struct __find_pod<__type_list<_Hp, _Tp>, _Align> {
+  typedef __conditional_t<_Align == _Hp::value, typename _Hp::type, typename __find_pod<_Tp, _Align>::type> type;
 };
 
-template <class _TL, size_t _Len> struct __find_max_align;
+template <class _TL, size_t _Len>
+struct __find_max_align;
 
 template <class _Hp, size_t _Len>
 struct __find_max_align<__type_list<_Hp, __nat>, _Len> : public integral_constant<size_t, _Hp::value> {};
 
 template <size_t _Len, size_t _A1, size_t _A2>
-struct __select_align
-{
+struct __select_align {
 private:
-    static const size_t __min = _A2 < _A1 ? _A2 : _A1;
-    static const size_t __max = _A1 < _A2 ? _A2 : _A1;
+  static const size_t __min = _A2 < _A1 ? _A2 : _A1;
+  static const size_t __max = _A1 < _A2 ? _A2 : _A1;
+
 public:
-    static const size_t value = _Len < __max ? __min : __max;
+  static const size_t value = _Len < __max ? __min : __max;
 };
 
 template <class _Hp, class _Tp, size_t _Len>
@@ -83,22 +87,20 @@ struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
     : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};
 
 template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
-struct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_TEMPLATE_VIS aligned_storage
-{
-    typedef typename __find_pod<__all_types, _Align>::type _Aligner;
-    union type
-    {
-        _Aligner __align;
-        unsigned char __data[(_Len + _Align - 1)/_Align * _Align];
-    };
+struct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_TEMPLATE_VIS aligned_storage {
+  typedef typename __find_pod<__all_types, _Align>::type _Aligner;
+  union type {
+    _Aligner __align;
+    unsigned char __data[(_Len + _Align - 1) / _Align * _Align];
+  };
 };
 
 #if _LIBCPP_STD_VER >= 14
 
-  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
-    using aligned_storage_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_storage<_Len, _Align>::type;
-  _LIBCPP_SUPPRESS_DEPRECATED_POP
+using aligned_storage_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_storage<_Len, _Align>::type;
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
 #endif
 
diff --git a/third_party/libcxx/__type_traits/aligned_union.h b/third_party/libcxx/__type_traits/aligned_union.h
index dd1515a69..005ed9a09 100644
--- a/third_party/libcxx/__type_traits/aligned_union.h
+++ b/third_party/libcxx/__type_traits/aligned_union.h
@@ -20,30 +20,25 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <size_t _I0, size_t ..._In>
+template <size_t _I0, size_t... _In>
 struct __static_max;
 
 template <size_t _I0>
-struct __static_max<_I0>
-{
-    static const size_t value = _I0;
+struct __static_max<_I0> {
+  static const size_t value = _I0;
 };
 
-template <size_t _I0, size_t _I1, size_t ..._In>
-struct __static_max<_I0, _I1, _In...>
-{
-    static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value :
-                                             __static_max<_I1, _In...>::value;
+template <size_t _I0, size_t _I1, size_t... _In>
+struct __static_max<_I0, _I1, _In...> {
+  static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value : __static_max<_I1, _In...>::value;
 };
 
-template <size_t _Len, class _Type0, class ..._Types>
-struct _LIBCPP_DEPRECATED_IN_CXX23 aligned_union
-{
-    static const size_t alignment_value = __static_max<_LIBCPP_PREFERRED_ALIGNOF(_Type0),
-                                                       _LIBCPP_PREFERRED_ALIGNOF(_Types)...>::value;
-    static const size_t __len = __static_max<_Len, sizeof(_Type0),
-                                             sizeof(_Types)...>::value;
-    typedef typename aligned_storage<__len, alignment_value>::type type;
+template <size_t _Len, class _Type0, class... _Types>
+struct _LIBCPP_DEPRECATED_IN_CXX23 aligned_union {
+  static const size_t alignment_value =
+      __static_max<_LIBCPP_PREFERRED_ALIGNOF(_Type0), _LIBCPP_PREFERRED_ALIGNOF(_Types)...>::value;
+  static const size_t __len = __static_max<_Len, sizeof(_Type0), sizeof(_Types)...>::value;
+  typedef typename aligned_storage<__len, alignment_value>::type type;
 };
 
 #if _LIBCPP_STD_VER >= 14
diff --git a/third_party/libcxx/__type_traits/alignment_of.h b/third_party/libcxx/__type_traits/alignment_of.h
index d7851aefe..f2d069bf2 100644
--- a/third_party/libcxx/__type_traits/alignment_of.h
+++ b/third_party/libcxx/__type_traits/alignment_of.h
@@ -19,8 +19,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of
-    : public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS alignment_of : public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/apply_cv.h b/third_party/libcxx/__type_traits/apply_cv.h
deleted file mode 100644
index 7c6aabec8..000000000
--- a/third_party/libcxx/__type_traits/apply_cv.h
+++ /dev/null
@@ -1,78 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_APPLY_CV_H
-#define _LIBCPP___TYPE_TRAITS_APPLY_CV_H
-
-#include <__config>
-#include <__type_traits/is_const.h>
-#include <__type_traits/is_volatile.h>
-#include <__type_traits/remove_reference.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp,
-          bool = is_const<__libcpp_remove_reference_t<_Tp> >::value,
-          bool = is_volatile<__libcpp_remove_reference_t<_Tp> >::value>
-struct __apply_cv_impl {
-  template <class _Up>
-  using __apply _LIBCPP_NODEBUG = _Up;
-};
-
-template <class _Tp>
-struct __apply_cv_impl<_Tp, true, false> {
-  template <class _Up>
-  using __apply _LIBCPP_NODEBUG = const _Up;
-};
-
-template <class _Tp>
-struct __apply_cv_impl<_Tp, false, true> {
-  template <class _Up>
-  using __apply _LIBCPP_NODEBUG = volatile _Up;
-};
-
-template <class _Tp>
-struct __apply_cv_impl<_Tp, true, true> {
-  template <class _Up>
-  using __apply _LIBCPP_NODEBUG = const volatile _Up;
-};
-
-template <class _Tp>
-struct __apply_cv_impl<_Tp&, false, false> {
-  template <class _Up>
-  using __apply _LIBCPP_NODEBUG = _Up&;
-};
-
-template <class _Tp>
-struct __apply_cv_impl<_Tp&, true, false> {
-  template <class _Up>
-  using __apply _LIBCPP_NODEBUG = const _Up&;
-};
-
-template <class _Tp>
-struct __apply_cv_impl<_Tp&, false, true> {
-  template <class _Up>
-  using __apply _LIBCPP_NODEBUG = volatile _Up&;
-};
-
-template <class _Tp>
-struct __apply_cv_impl<_Tp&, true, true> {
-  template <class _Up>
-  using __apply _LIBCPP_NODEBUG = const volatile _Up&;
-};
-
-template <class _Tp, class _Up>
-using __apply_cv_t _LIBCPP_NODEBUG = typename __apply_cv_impl<_Tp>::template __apply<_Up>;
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_APPLY_CV_H
diff --git a/third_party/libcxx/__type_traits/can_extract_key.h b/third_party/libcxx/__type_traits/can_extract_key.h
index 454c56bfa..b8359d070 100644
--- a/third_party/libcxx/__type_traits/can_extract_key.h
+++ b/third_party/libcxx/__type_traits/can_extract_key.h
@@ -40,16 +40,13 @@ struct __can_extract_key<_Pair, _Key, pair<_First, _Second> >
 // __can_extract_map_key uses true_type/false_type instead of the tags.
 // It returns true if _Key != _ContainerValueTy (the container is a map not a set)
 // and _ValTy == _Key.
-template <class _ValTy, class _Key, class _ContainerValueTy,
-          class _RawValTy = __remove_const_ref_t<_ValTy> >
-struct __can_extract_map_key
-    : integral_constant<bool, _IsSame<_RawValTy, _Key>::value> {};
+template <class _ValTy, class _Key, class _ContainerValueTy, class _RawValTy = __remove_const_ref_t<_ValTy> >
+struct __can_extract_map_key : integral_constant<bool, _IsSame<_RawValTy, _Key>::value> {};
 
 // This specialization returns __extract_key_fail_tag for non-map containers
 // because _Key == _ContainerValueTy
 template <class _ValTy, class _Key, class _RawValTy>
-struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy>
-    : false_type {};
+struct __can_extract_map_key<_ValTy, _Key, _Key, _RawValTy> : false_type {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/common_reference.h b/third_party/libcxx/__type_traits/common_reference.h
index 59b3dfbe1..c802902eb 100644
--- a/third_party/libcxx/__type_traits/common_reference.h
+++ b/third_party/libcxx/__type_traits/common_reference.h
@@ -30,8 +30,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 // Let COND_RES(X, Y) be:
 template <class _Xp, class _Yp>
-using __cond_res =
-    decltype(false ? std::declval<_Xp(&)()>()() : std::declval<_Yp(&)()>()());
+using __cond_res = decltype(false ? std::declval<_Xp (&)()>()() : std::declval<_Yp (&)()>()());
 
 // Let `XREF(A)` denote a unary alias template `T` such that `T<U>` denotes the same type as `U`
 // with the addition of `A`'s cv and reference qualifiers, for a non-reference cv-unqualified type
@@ -39,47 +38,49 @@ using __cond_res =
 // [Note: `XREF(A)` is `__xref<A>::template __apply`]
 template <class _Tp>
 struct __xref {
-  template<class _Up>
+  template <class _Up>
   using __apply = __copy_cvref_t<_Tp, _Up>;
 };
 
 // Given types A and B, let X be remove_reference_t<A>, let Y be remove_reference_t<B>,
 // and let COMMON-REF(A, B) be:
-template<class _Ap, class _Bp, class _Xp = remove_reference_t<_Ap>, class _Yp = remove_reference_t<_Bp>>
+template <class _Ap, class _Bp, class _Xp = remove_reference_t<_Ap>, class _Yp = remove_reference_t<_Bp>>
 struct __common_ref;
 
-template<class _Xp, class _Yp>
+template <class _Xp, class _Yp>
 using __common_ref_t = typename __common_ref<_Xp, _Yp>::__type;
 
-template<class _Xp, class _Yp>
+template <class _Xp, class _Yp>
 using __cv_cond_res = __cond_res<__copy_cv_t<_Xp, _Yp>&, __copy_cv_t<_Yp, _Xp>&>;
 
-
 //    If A and B are both lvalue reference types, COMMON-REF(A, B) is
 //    COND-RES(COPYCV(X, Y)&, COPYCV(Y, X)&) if that type exists and is a reference type.
-template<class _Ap, class _Bp, class _Xp, class _Yp>
-requires requires { typename __cv_cond_res<_Xp, _Yp>; } && is_reference_v<__cv_cond_res<_Xp, _Yp>>
-struct __common_ref<_Ap&, _Bp&, _Xp, _Yp>
-{
-    using __type = __cv_cond_res<_Xp, _Yp>;
+// clang-format off
+template <class _Ap, class _Bp, class _Xp, class _Yp>
+  requires
+    requires { typename __cv_cond_res<_Xp, _Yp>; } &&
+    is_reference_v<__cv_cond_res<_Xp, _Yp>>
+struct __common_ref<_Ap&, _Bp&, _Xp, _Yp> {
+  using __type = __cv_cond_res<_Xp, _Yp>;
 };
+// clang-format on
 
 //    Otherwise, let C be remove_reference_t<COMMON-REF(X&, Y&)>&&. ...
 template <class _Xp, class _Yp>
 using __common_ref_C = remove_reference_t<__common_ref_t<_Xp&, _Yp&>>&&;
 
-
 //    .... If A and B are both rvalue reference types, C is well-formed, and
 //    is_convertible_v<A, C> && is_convertible_v<B, C> is true, then COMMON-REF(A, B) is C.
-template<class _Ap, class _Bp, class _Xp, class _Yp>
-requires
-  requires { typename __common_ref_C<_Xp, _Yp>; } &&
-  is_convertible_v<_Ap&&, __common_ref_C<_Xp, _Yp>> &&
-  is_convertible_v<_Bp&&, __common_ref_C<_Xp, _Yp>>
-struct __common_ref<_Ap&&, _Bp&&, _Xp, _Yp>
-{
-    using __type = __common_ref_C<_Xp, _Yp>;
+// clang-format off
+template <class _Ap, class _Bp, class _Xp, class _Yp>
+  requires
+    requires { typename __common_ref_C<_Xp, _Yp>; } &&
+    is_convertible_v<_Ap&&, __common_ref_C<_Xp, _Yp>> &&
+    is_convertible_v<_Bp&&, __common_ref_C<_Xp, _Yp>>
+struct __common_ref<_Ap&&, _Bp&&, _Xp, _Yp> {
+  using __type = __common_ref_C<_Xp, _Yp>;
 };
+// clang-format on
 
 //    Otherwise, let D be COMMON-REF(const X&, Y&). ...
 template <class _Tp, class _Up>
@@ -87,21 +88,23 @@ using __common_ref_D = __common_ref_t<const _Tp&, _Up&>;
 
 //    ... If A is an rvalue reference and B is an lvalue reference and D is well-formed and
 //    is_convertible_v<A, D> is true, then COMMON-REF(A, B) is D.
-template<class _Ap, class _Bp, class _Xp, class _Yp>
-requires requires { typename __common_ref_D<_Xp, _Yp>; } &&
-         is_convertible_v<_Ap&&, __common_ref_D<_Xp, _Yp>>
-struct __common_ref<_Ap&&, _Bp&, _Xp, _Yp>
-{
-    using __type = __common_ref_D<_Xp, _Yp>;
+// clang-format off
+template <class _Ap, class _Bp, class _Xp, class _Yp>
+  requires
+    requires { typename __common_ref_D<_Xp, _Yp>; } &&
+    is_convertible_v<_Ap&&, __common_ref_D<_Xp, _Yp>>
+struct __common_ref<_Ap&&, _Bp&, _Xp, _Yp> {
+  using __type = __common_ref_D<_Xp, _Yp>;
 };
+// clang-format on
 
 //    Otherwise, if A is an lvalue reference and B is an rvalue reference, then
 //    COMMON-REF(A, B) is COMMON-REF(B, A).
-template<class _Ap, class _Bp, class _Xp, class _Yp>
+template <class _Ap, class _Bp, class _Xp, class _Yp>
 struct __common_ref<_Ap&, _Bp&&, _Xp, _Yp> : __common_ref<_Bp&&, _Ap&> {};
 
 //    Otherwise, COMMON-REF(A, B) is ill-formed.
-template<class _Ap, class _Bp, class _Xp, class _Yp>
+template <class _Ap, class _Bp, class _Xp, class _Yp>
 struct __common_ref {};
 
 // Note C: For the common_reference trait applied to a parameter pack [...]
@@ -113,73 +116,75 @@ template <class... _Types>
 using common_reference_t = typename common_reference<_Types...>::type;
 
 // bullet 1 - sizeof...(T) == 0
-template<>
+template <>
 struct common_reference<> {};
 
 // bullet 2 - sizeof...(T) == 1
 template <class _Tp>
-struct common_reference<_Tp>
-{
-    using type = _Tp;
+struct common_reference<_Tp> {
+  using type = _Tp;
 };
 
 // bullet 3 - sizeof...(T) == 2
-template <class _Tp, class _Up> struct __common_reference_sub_bullet3;
-template <class _Tp, class _Up> struct __common_reference_sub_bullet2 : __common_reference_sub_bullet3<_Tp, _Up> {};
-template <class _Tp, class _Up> struct __common_reference_sub_bullet1 : __common_reference_sub_bullet2<_Tp, _Up> {};
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet3;
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet2 : __common_reference_sub_bullet3<_Tp, _Up> {};
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet1 : __common_reference_sub_bullet2<_Tp, _Up> {};
 
 // sub-bullet 1 - If T1 and T2 are reference types and COMMON-REF(T1, T2) is well-formed, then
 // the member typedef `type` denotes that type.
-template <class _Tp, class _Up> struct common_reference<_Tp, _Up> : __common_reference_sub_bullet1<_Tp, _Up> {};
+template <class _Tp, class _Up>
+struct common_reference<_Tp, _Up> : __common_reference_sub_bullet1<_Tp, _Up> {};
 
 template <class _Tp, class _Up>
-requires is_reference_v<_Tp> && is_reference_v<_Up> && requires { typename __common_ref_t<_Tp, _Up>; }
-struct __common_reference_sub_bullet1<_Tp, _Up>
-{
-    using type = __common_ref_t<_Tp, _Up>;
+  requires is_reference_v<_Tp> && is_reference_v<_Up> && requires { typename __common_ref_t<_Tp, _Up>; }
+struct __common_reference_sub_bullet1<_Tp, _Up> {
+  using type = __common_ref_t<_Tp, _Up>;
 };
 
 // sub-bullet 2 - Otherwise, if basic_common_reference<remove_cvref_t<T1>, remove_cvref_t<T2>, XREF(T1), XREF(T2)>::type
 // is well-formed, then the member typedef `type` denotes that type.
-template <class, class, template <class> class, template <class> class> struct basic_common_reference {};
+template <class, class, template <class> class, template <class> class>
+struct basic_common_reference {};
 
 template <class _Tp, class _Up>
-using __basic_common_reference_t = typename basic_common_reference<
-    remove_cvref_t<_Tp>, remove_cvref_t<_Up>,
-    __xref<_Tp>::template __apply, __xref<_Up>::template __apply>::type;
+using __basic_common_reference_t =
+    typename basic_common_reference<remove_cvref_t<_Tp>,
+                                    remove_cvref_t<_Up>,
+                                    __xref<_Tp>::template __apply,
+                                    __xref<_Up>::template __apply>::type;
 
 template <class _Tp, class _Up>
-requires requires { typename __basic_common_reference_t<_Tp, _Up>; }
-struct __common_reference_sub_bullet2<_Tp, _Up>
-{
-    using type = __basic_common_reference_t<_Tp, _Up>;
+  requires requires { typename __basic_common_reference_t<_Tp, _Up>; }
+struct __common_reference_sub_bullet2<_Tp, _Up> {
+  using type = __basic_common_reference_t<_Tp, _Up>;
 };
 
 // sub-bullet 3 - Otherwise, if COND-RES(T1, T2) is well-formed,
 // then the member typedef `type` denotes that type.
 template <class _Tp, class _Up>
-requires requires { typename __cond_res<_Tp, _Up>; }
-struct __common_reference_sub_bullet3<_Tp, _Up>
-{
-    using type = __cond_res<_Tp, _Up>;
+  requires requires { typename __cond_res<_Tp, _Up>; }
+struct __common_reference_sub_bullet3<_Tp, _Up> {
+  using type = __cond_res<_Tp, _Up>;
 };
 
-
 // sub-bullet 4 & 5 - Otherwise, if common_type_t<T1, T2> is well-formed,
 //                    then the member typedef `type` denotes that type.
 //                  - Otherwise, there shall be no member `type`.
-template <class _Tp, class _Up> struct __common_reference_sub_bullet3 : common_type<_Tp, _Up> {};
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet3 : common_type<_Tp, _Up> {};
 
 // bullet 4 - If there is such a type `C`, the member typedef type shall denote the same type, if
 //            any, as `common_reference_t<C, Rest...>`.
 template <class _Tp, class _Up, class _Vp, class... _Rest>
-requires requires { typename common_reference_t<_Tp, _Up>; }
-struct common_reference<_Tp, _Up, _Vp, _Rest...>
-    : common_reference<common_reference_t<_Tp, _Up>, _Vp, _Rest...>
-{};
+  requires requires { typename common_reference_t<_Tp, _Up>; }
+struct common_reference<_Tp, _Up, _Vp, _Rest...> : common_reference<common_reference_t<_Tp, _Up>, _Vp, _Rest...> {};
 
 // bullet 5 - Otherwise, there shall be no member `type`.
-template <class...> struct common_reference {};
+template <class...>
+struct common_reference {};
 
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__type_traits/common_type.h b/third_party/libcxx/__type_traits/common_type.h
index d6f73f645..f6bd9ed71 100644
--- a/third_party/libcxx/__type_traits/common_type.h
+++ b/third_party/libcxx/__type_traits/common_type.h
@@ -33,9 +33,8 @@ struct __common_type3 {};
 
 // sub-bullet 4 - "if COND_RES(CREF(D1), CREF(D2)) denotes a type..."
 template <class _Tp, class _Up>
-struct __common_type3<_Tp, _Up, void_t<__cond_type<const _Tp&, const _Up&>>>
-{
-    using type = remove_cvref_t<__cond_type<const _Tp&, const _Up&>>;
+struct __common_type3<_Tp, _Up, void_t<__cond_type<const _Tp&, const _Up&>>> {
+  using type = remove_cvref_t<__cond_type<const _Tp&, const _Up&>>;
 };
 
 template <class _Tp, class _Up, class = void>
@@ -47,11 +46,8 @@ struct __common_type2_imp {};
 
 // sub-bullet 3 - "if decay_t<decltype(false ? declval<D1>() : declval<D2>())> ..."
 template <class _Tp, class _Up>
-struct __common_type2_imp<_Tp, _Up, __void_t<decltype(true ? std::declval<_Tp>() : std::declval<_Up>())> >
-{
-  typedef _LIBCPP_NODEBUG __decay_t<decltype(
-                         true ? std::declval<_Tp>() : std::declval<_Up>()
-                         )> type;
+struct __common_type2_imp<_Tp, _Up, __void_t<decltype(true ? std::declval<_Tp>() : std::declval<_Up>())> > {
+  typedef _LIBCPP_NODEBUG __decay_t<decltype(true ? std::declval<_Tp>() : std::declval<_Up>())> type;
 };
 
 template <class, class = void>
@@ -63,19 +59,13 @@ template <class... _Tp>
 struct _LIBCPP_TEMPLATE_VIS common_type;
 
 template <class _Tp, class _Up>
-struct __common_type_impl<
-    __common_types<_Tp, _Up>, __void_t<typename common_type<_Tp, _Up>::type> >
-{
+struct __common_type_impl< __common_types<_Tp, _Up>, __void_t<typename common_type<_Tp, _Up>::type> > {
   typedef typename common_type<_Tp, _Up>::type type;
 };
 
 template <class _Tp, class _Up, class _Vp, class... _Rest>
-struct __common_type_impl<
-    __common_types<_Tp, _Up, _Vp, _Rest...>,
-    __void_t<typename common_type<_Tp, _Up>::type> >
-    : __common_type_impl<__common_types<typename common_type<_Tp, _Up>::type,
-                                        _Vp, _Rest...> > {
-};
+struct __common_type_impl<__common_types<_Tp, _Up, _Vp, _Rest...>, __void_t<typename common_type<_Tp, _Up>::type> >
+    : __common_type_impl<__common_types<typename common_type<_Tp, _Up>::type, _Vp, _Rest...> > {};
 
 // bullet 1 - sizeof...(Tp) == 0
 
@@ -85,31 +75,26 @@ struct _LIBCPP_TEMPLATE_VIS common_type<> {};
 // bullet 2 - sizeof...(Tp) == 1
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS common_type<_Tp>
-    : public common_type<_Tp, _Tp> {};
+struct _LIBCPP_TEMPLATE_VIS common_type<_Tp> : public common_type<_Tp, _Tp> {};
 
 // bullet 3 - sizeof...(Tp) == 2
 
 // sub-bullet 1 - "If is_same_v<T1, D1> is false or ..."
 template <class _Tp, class _Up>
 struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up>
-    : conditional<
-        _IsSame<_Tp, __decay_t<_Tp> >::value && _IsSame<_Up, __decay_t<_Up> >::value,
-        __common_type2_imp<_Tp, _Up>,
-        common_type<__decay_t<_Tp>, __decay_t<_Up> >
-    >::type
-{};
+    : __conditional_t<_IsSame<_Tp, __decay_t<_Tp> >::value && _IsSame<_Up, __decay_t<_Up> >::value,
+                      __common_type2_imp<_Tp, _Up>,
+                      common_type<__decay_t<_Tp>, __decay_t<_Up> > > {};
 
 // bullet 4 - sizeof...(Tp) > 2
 
 template <class _Tp, class _Up, class _Vp, class... _Rest>
-struct _LIBCPP_TEMPLATE_VIS
-    common_type<_Tp, _Up, _Vp, _Rest...>
-    : __common_type_impl<
-          __common_types<_Tp, _Up, _Vp, _Rest...> > {};
+struct _LIBCPP_TEMPLATE_VIS common_type<_Tp, _Up, _Vp, _Rest...>
+    : __common_type_impl<__common_types<_Tp, _Up, _Vp, _Rest...> > {};
 
 #if _LIBCPP_STD_VER >= 14
-template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type;
+template <class... _Tp>
+using common_type_t = typename common_type<_Tp...>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/conjunction.h b/third_party/libcxx/__type_traits/conjunction.h
index 4bfa5a273..c2995591b 100644
--- a/third_party/libcxx/__type_traits/conjunction.h
+++ b/third_party/libcxx/__type_traits/conjunction.h
@@ -13,6 +13,7 @@
 #include <__type_traits/conditional.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
+#include <__type_traits/is_same.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -37,6 +38,12 @@ false_type __and_helper(...);
 template <class... _Pred>
 using _And _LIBCPP_NODEBUG = decltype(std::__and_helper<_Pred...>(0));
 
+template <bool... _Preds>
+struct __all_dummy;
+
+template <bool... _Pred>
+struct __all : _IsSame<__all_dummy<_Pred...>, __all_dummy<((void)_Pred, true)...> > {};
+
 #if _LIBCPP_STD_VER >= 17
 
 template <class...>
diff --git a/third_party/libcxx/__type_traits/copy_cv.h b/third_party/libcxx/__type_traits/copy_cv.h
index 8e9bfe0a5..d482cb42b 100644
--- a/third_party/libcxx/__type_traits/copy_cv.h
+++ b/third_party/libcxx/__type_traits/copy_cv.h
@@ -10,9 +10,6 @@
 #define _LIBCPP___TYPE_TRAITS_COPY_CV_H
 
 #include <__config>
-#include <__type_traits/add_const.h>
-#include <__type_traits/add_cv.h>
-#include <__type_traits/add_volatile.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -22,32 +19,32 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Let COPYCV(FROM, TO) be an alias for type TO with the addition of FROM's
 // top-level cv-qualifiers.
-template <class _From, class _To>
-struct __copy_cv
-{
-    using type = _To;
+template <class _From>
+struct __copy_cv {
+  template <class _To>
+  using __apply = _To;
+};
+
+template <class _From>
+struct __copy_cv<const _From> {
+  template <class _To>
+  using __apply = const _To;
+};
+
+template <class _From>
+struct __copy_cv<volatile _From> {
+  template <class _To>
+  using __apply = volatile _To;
+};
+
+template <class _From>
+struct __copy_cv<const volatile _From> {
+  template <class _To>
+  using __apply = const volatile _To;
 };
 
 template <class _From, class _To>
-struct __copy_cv<const _From, _To>
-{
-    using type = typename add_const<_To>::type;
-};
-
-template <class _From, class _To>
-struct __copy_cv<volatile _From, _To>
-{
-    using type = typename add_volatile<_To>::type;
-};
-
-template <class _From, class _To>
-struct __copy_cv<const volatile _From, _To>
-{
-    using type = typename add_cv<_To>::type;
-};
-
-template <class _From, class _To>
-using __copy_cv_t = typename __copy_cv<_From, _To>::type;
+using __copy_cv_t = typename __copy_cv<_From>::template __apply<_To>;
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/copy_cvref.h b/third_party/libcxx/__type_traits/copy_cvref.h
index 8ec59b95a..8bbf8efdf 100644
--- a/third_party/libcxx/__type_traits/copy_cvref.h
+++ b/third_party/libcxx/__type_traits/copy_cvref.h
@@ -21,21 +21,18 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _From, class _To>
-struct __copy_cvref
-{
-    using type = __copy_cv_t<_From, _To>;
+struct __copy_cvref {
+  using type = __copy_cv_t<_From, _To>;
 };
 
 template <class _From, class _To>
-struct __copy_cvref<_From&, _To>
-{
-    using type = __add_lvalue_reference_t<__copy_cv_t<_From, _To> >;
+struct __copy_cvref<_From&, _To> {
+  using type = __add_lvalue_reference_t<__copy_cv_t<_From, _To> >;
 };
 
 template <class _From, class _To>
-struct __copy_cvref<_From&&, _To>
-{
-    using type = __add_rvalue_reference_t<__copy_cv_t<_From, _To> >;
+struct __copy_cvref<_From&&, _To> {
+  using type = __add_rvalue_reference_t<__copy_cv_t<_From, _To> >;
 };
 
 template <class _From, class _To>
diff --git a/third_party/libcxx/__type_traits/datasizeof.h b/third_party/libcxx/__type_traits/datasizeof.h
new file mode 100644
index 000000000..a27baf67c
--- /dev/null
+++ b/third_party/libcxx/__type_traits/datasizeof.h
@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_DATASIZEOF_H
+#define _LIBCPP___TYPE_TRAITS_DATASIZEOF_H
+
+#include <__config>
+#include <__type_traits/is_class.h>
+#include <__type_traits/is_final.h>
+#include <cstddef>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+// This trait provides the size of a type excluding any tail padding.
+//
+// It is useful in contexts where performing an operation using the full size of the class (including padding) may
+// have unintended side effects, such as overwriting a derived class' member when writing the tail padding of a class
+// through a pointer-to-base.
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if __has_keyword(__datasizeof) || __has_extension(datasizeof)
+template <class _Tp>
+inline const size_t __datasizeof_v = __datasizeof(_Tp);
+#else
+// NOLINTNEXTLINE(readability-redundant-preprocessor) This is https://llvm.org/PR64825
+#  if __has_cpp_attribute(__no_unique_address__)
+template <class _Tp>
+struct _FirstPaddingByte {
+  [[__no_unique_address__]] _Tp __v_;
+  char __first_padding_byte_;
+};
+#  else
+template <class _Tp, bool = __libcpp_is_final<_Tp>::value || !is_class<_Tp>::value>
+struct _FirstPaddingByte : _Tp {
+  char __first_padding_byte_;
+};
+
+template <class _Tp>
+struct _FirstPaddingByte<_Tp, true> {
+  _Tp __v_;
+  char __first_padding_byte_;
+};
+#  endif // __has_cpp_attribute(__no_unique_address__)
+
+// _FirstPaddingByte<> is sometimes non-standard layout. Using `offsetof` is UB in that case, but GCC and Clang allow
+// the use as an extension.
+_LIBCPP_DIAGNOSTIC_PUSH
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Winvalid-offsetof")
+_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Winvalid-offsetof")
+template <class _Tp>
+inline const size_t __datasizeof_v = offsetof(_FirstPaddingByte<_Tp>, __first_padding_byte_);
+_LIBCPP_DIAGNOSTIC_POP
+#endif   // __has_extension(datasizeof)
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_DATASIZEOF_H
diff --git a/third_party/libcxx/__type_traits/decay.h b/third_party/libcxx/__type_traits/decay.h
index a32c140e3..7412044f9 100644
--- a/third_party/libcxx/__type_traits/decay.h
+++ b/third_party/libcxx/__type_traits/decay.h
@@ -37,30 +37,24 @@ struct decay {
 #else
 template <class _Up, bool>
 struct __decay {
-    typedef _LIBCPP_NODEBUG __remove_cv_t<_Up> type;
+  typedef _LIBCPP_NODEBUG __remove_cv_t<_Up> type;
 };
 
 template <class _Up>
 struct __decay<_Up, true> {
 public:
-    typedef _LIBCPP_NODEBUG typename conditional
-                     <
-                         is_array<_Up>::value,
-                         __add_pointer_t<__remove_extent_t<_Up> >,
-                         typename conditional
-                         <
-                              is_function<_Up>::value,
-                              typename add_pointer<_Up>::type,
-                              __remove_cv_t<_Up>
-                         >::type
-                     >::type type;
+  typedef _LIBCPP_NODEBUG
+      __conditional_t<is_array<_Up>::value,
+                      __add_pointer_t<__remove_extent_t<_Up> >,
+                      __conditional_t<is_function<_Up>::value, typename add_pointer<_Up>::type, __remove_cv_t<_Up> > >
+          type;
 };
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS decay
-{
+struct _LIBCPP_TEMPLATE_VIS decay {
 private:
-    typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up;
+  typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up;
+
 public:
   typedef _LIBCPP_NODEBUG typename __decay<_Up, __libcpp_is_referenceable<_Up>::value>::type type;
 };
@@ -70,7 +64,8 @@ using __decay_t = typename decay<_Tp>::type;
 #endif // __has_builtin(__decay)
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using decay_t = __decay_t<_Tp>;
+template <class _Tp>
+using decay_t = __decay_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/desugars_to.h b/third_party/libcxx/__type_traits/desugars_to.h
new file mode 100644
index 000000000..97a2ee544
--- /dev/null
+++ b/third_party/libcxx/__type_traits/desugars_to.h
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_DESUGARS_TO_H
+#define _LIBCPP___TYPE_TRAITS_DESUGARS_TO_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// Tags to represent the canonical operations
+struct __equal_tag {};
+struct __plus_tag {};
+struct __less_tag {};
+
+// This class template is used to determine whether an operation "desugars"
+// (or boils down) to a given canonical operation.
+//
+// For example, `std::equal_to<>`, our internal `std::__equal_to` helper and
+// `ranges::equal_to` are all just fancy ways of representing a transparent
+// equality operation, so they all desugar to `__equal_tag`.
+//
+// This is useful to optimize some functions in cases where we know e.g. the
+// predicate being passed is actually going to call a builtin operator, or has
+// some specific semantics.
+template <class _CanonicalTag, class _Operation, class... _Args>
+inline const bool __desugars_to_v = false;
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_DESUGARS_TO_H
diff --git a/third_party/libcxx/__type_traits/enable_if.h b/third_party/libcxx/__type_traits/enable_if.h
index 4859981f1..77da9622c 100644
--- a/third_party/libcxx/__type_traits/enable_if.h
+++ b/third_party/libcxx/__type_traits/enable_if.h
@@ -17,13 +17,19 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <bool, class _Tp = void> struct _LIBCPP_TEMPLATE_VIS enable_if {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS enable_if<true, _Tp> {typedef _Tp type;};
+template <bool, class _Tp = void>
+struct _LIBCPP_TEMPLATE_VIS enable_if {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS enable_if<true, _Tp> {
+  typedef _Tp type;
+};
 
-template <bool _Bp, class _Tp = void> using __enable_if_t _LIBCPP_NODEBUG = typename enable_if<_Bp, _Tp>::type;
+template <bool _Bp, class _Tp = void>
+using __enable_if_t _LIBCPP_NODEBUG = typename enable_if<_Bp, _Tp>::type;
 
 #if _LIBCPP_STD_VER >= 14
-template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
+template <bool _Bp, class _Tp = void>
+using enable_if_t = typename enable_if<_Bp, _Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/extent.h b/third_party/libcxx/__type_traits/extent.h
index a031f5ed1..bab03fe99 100644
--- a/third_party/libcxx/__type_traits/extent.h
+++ b/third_party/libcxx/__type_traits/extent.h
@@ -21,32 +21,31 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__array_extent)
 
-template<class _Tp, size_t _Dim = 0>
-struct _LIBCPP_TEMPLATE_VIS extent
-    : integral_constant<size_t, __array_extent(_Tp, _Dim)> { };
+template <class _Tp, size_t _Dim = 0>
+struct _LIBCPP_TEMPLATE_VIS extent : integral_constant<size_t, __array_extent(_Tp, _Dim)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp, unsigned _Ip = 0>
 inline constexpr size_t extent_v = __array_extent(_Tp, _Ip);
-#endif
+#  endif
 
 #else // __has_builtin(__array_extent)
 
-template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS extent
-    : public integral_constant<size_t, 0> {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0>
-    : public integral_constant<size_t, 0> {};
-template <class _Tp, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], _Ip>
-    : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], 0>
-    : public integral_constant<size_t, _Np> {};
-template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], _Ip>
-    : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
+template <class _Tp, unsigned _Ip = 0>
+struct _LIBCPP_TEMPLATE_VIS extent : public integral_constant<size_t, 0> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0> : public integral_constant<size_t, 0> {};
+template <class _Tp, unsigned _Ip>
+struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], _Ip> : public integral_constant<size_t, extent<_Tp, _Ip - 1>::value> {};
+template <class _Tp, size_t _Np>
+struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], 0> : public integral_constant<size_t, _Np> {};
+template <class _Tp, size_t _Np, unsigned _Ip>
+struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], _Ip> : public integral_constant<size_t, extent<_Tp, _Ip - 1>::value> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp, unsigned _Ip = 0>
 inline constexpr size_t extent_v = extent<_Tp, _Ip>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__array_extent)
 
diff --git a/third_party/libcxx/__type_traits/has_unique_object_representation.h b/third_party/libcxx/__type_traits/has_unique_object_representation.h
index aa45bbb14..98c440c16 100644
--- a/third_party/libcxx/__type_traits/has_unique_object_representation.h
+++ b/third_party/libcxx/__type_traits/has_unique_object_representation.h
@@ -12,7 +12,6 @@
 #include <__config>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/remove_all_extents.h>
-#include <__type_traits/remove_cv.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -22,12 +21,17 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_unique_object_representations
-    : public integral_constant<bool,
-       __has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS has_unique_object_representations
+    // TODO: We work around a Clang and GCC bug in __has_unique_object_representations by using remove_all_extents
+    //       even though it should not be necessary. This was reported to the compilers:
+    //         - Clang: https://github.com/llvm/llvm-project/issues/95311
+    //         - GCC: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115476
+    //       remove_all_extents_t can be removed once all the compilers we support have fixed this bug.
+    : public integral_constant<bool, __has_unique_object_representations(remove_all_extents_t<_Tp>)> {};
 
 template <class _Tp>
-inline constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value;
+inline constexpr bool has_unique_object_representations_v = __has_unique_object_representations(_Tp);
 
 #endif
 
diff --git a/third_party/libcxx/__type_traits/has_virtual_destructor.h b/third_party/libcxx/__type_traits/has_virtual_destructor.h
index ae3137e9d..4ce96e649 100644
--- a/third_party/libcxx/__type_traits/has_virtual_destructor.h
+++ b/third_party/libcxx/__type_traits/has_virtual_destructor.h
@@ -18,8 +18,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor
-    : public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor : public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/integral_constant.h b/third_party/libcxx/__type_traits/integral_constant.h
index 0951ab5ad..23e87e27f 100644
--- a/third_party/libcxx/__type_traits/integral_constant.h
+++ b/third_party/libcxx/__type_traits/integral_constant.h
@@ -18,23 +18,20 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, _Tp __v>
-struct _LIBCPP_TEMPLATE_VIS integral_constant
-{
-  static _LIBCPP_CONSTEXPR const _Tp      value = __v;
-  typedef _Tp               value_type;
+struct _LIBCPP_TEMPLATE_VIS integral_constant {
+  static _LIBCPP_CONSTEXPR const _Tp value = __v;
+  typedef _Tp value_type;
   typedef integral_constant type;
-  _LIBCPP_INLINE_VISIBILITY
-  _LIBCPP_CONSTEXPR operator value_type() const _NOEXCEPT {return value;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR operator value_type() const _NOEXCEPT { return value; }
 #if _LIBCPP_STD_VER >= 14
-  _LIBCPP_INLINE_VISIBILITY
-  constexpr value_type operator ()() const _NOEXCEPT {return value;}
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type operator()() const _NOEXCEPT { return value; }
 #endif
 };
 
 template <class _Tp, _Tp __v>
 _LIBCPP_CONSTEXPR const _Tp integral_constant<_Tp, __v>::value;
 
-typedef integral_constant<bool, true>  true_type;
+typedef integral_constant<bool, true> true_type;
 typedef integral_constant<bool, false> false_type;
 
 template <bool _Val>
diff --git a/third_party/libcxx/__type_traits/invoke.h b/third_party/libcxx/__type_traits/invoke.h
index bc1852ca7..71db32ae6 100644
--- a/third_party/libcxx/__type_traits/invoke.h
+++ b/third_party/libcxx/__type_traits/invoke.h
@@ -11,21 +11,17 @@
 #define _LIBCPP___TYPE_TRAITS_INVOKE_H
 
 #include <__config>
-#include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/apply_cv.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_base_of.h>
 #include <__type_traits/is_core_convertible.h>
-#include <__type_traits/is_member_function_pointer.h>
-#include <__type_traits/is_member_object_pointer.h>
+#include <__type_traits/is_member_pointer.h>
 #include <__type_traits/is_reference_wrapper.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/nat.h>
-#include <__type_traits/remove_cv.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
 
@@ -35,226 +31,6 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct __any
-{
-    __any(...);
-};
-
-template <class _MP, bool _IsMemberFunctionPtr, bool _IsMemberObjectPtr>
-struct __member_pointer_traits_imp
-{
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...), true, false>
-{
-    typedef _Class _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...), true, false>
-{
-    typedef _Class _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const, true, false>
-{
-    typedef _Class const _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const, true, false>
-{
-    typedef _Class const _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile, true, false>
-{
-    typedef _Class volatile _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile, true, false>
-{
-    typedef _Class volatile _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile, true, false>
-{
-    typedef _Class const volatile _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile, true, false>
-{
-    typedef _Class const volatile _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &, true, false>
-{
-    typedef _Class& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) &, true, false>
-{
-    typedef _Class& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&, true, false>
-{
-    typedef _Class const& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const&, true, false>
-{
-    typedef _Class const& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&, true, false>
-{
-    typedef _Class volatile& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile&, true, false>
-{
-    typedef _Class volatile& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&, true, false>
-{
-    typedef _Class const volatile& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile&, true, false>
-{
-    typedef _Class const volatile& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) &&, true, false>
-{
-    typedef _Class&& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) &&, true, false>
-{
-    typedef _Class&& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const&&, true, false>
-{
-    typedef _Class const&& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const&&, true, false>
-{
-    typedef _Class const&& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) volatile&&, true, false>
-{
-    typedef _Class volatile&& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) volatile&&, true, false>
-{
-    typedef _Class volatile&& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param...) const volatile&&, true, false>
-{
-    typedef _Class const volatile&& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param...);
-};
-
-template <class _Rp, class _Class, class ..._Param>
-struct __member_pointer_traits_imp<_Rp (_Class::*)(_Param..., ...) const volatile&&, true, false>
-{
-    typedef _Class const volatile&& _ClassType;
-    typedef _Rp _ReturnType;
-    typedef _Rp (_FnType) (_Param..., ...);
-};
-
-template <class _Rp, class _Class>
-struct __member_pointer_traits_imp<_Rp _Class::*, false, true>
-{
-    typedef _Class _ClassType;
-    typedef _Rp _ReturnType;
-};
-
-template <class _MP>
-struct __member_pointer_traits
-    : public __member_pointer_traits_imp<__remove_cv_t<_MP>,
-                    is_member_function_pointer<_MP>::value,
-                    is_member_object_pointer<_MP>::value>
-{
-//     typedef ... _ClassType;
-//     typedef ... _ReturnType;
-//     typedef ... _FnType;
-};
-
 template <class _DecayedFp>
 struct __member_pointer_class_type {};
 
@@ -263,268 +39,226 @@ struct __member_pointer_class_type<_Ret _ClassType::*> {
   typedef _ClassType type;
 };
 
-template <class _Fp, class _A0,
-         class _DecayFp = __decay_t<_Fp>,
-         class _DecayA0 = __decay_t<_A0>,
-         class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
-using __enable_if_bullet1 = typename enable_if
-    <
-        is_member_function_pointer<_DecayFp>::value
-        && is_base_of<_ClassT, _DecayA0>::value
-    >::type;
+template <class _Fp,
+          class _A0,
+          class _DecayFp = __decay_t<_Fp>,
+          class _DecayA0 = __decay_t<_A0>,
+          class _ClassT  = typename __member_pointer_class_type<_DecayFp>::type>
+using __enable_if_bullet1 =
+    __enable_if_t<is_member_function_pointer<_DecayFp>::value &&
+                  (is_same<_ClassT, _DecayA0>::value || is_base_of<_ClassT, _DecayA0>::value)>;
 
-template <class _Fp, class _A0,
-         class _DecayFp = __decay_t<_Fp>,
-         class _DecayA0 = __decay_t<_A0> >
-using __enable_if_bullet2 = typename enable_if
-    <
-        is_member_function_pointer<_DecayFp>::value
-        && __is_reference_wrapper<_DecayA0>::value
-    >::type;
+template <class _Fp, class _A0, class _DecayFp = __decay_t<_Fp>, class _DecayA0 = __decay_t<_A0> >
+using __enable_if_bullet2 =
+    __enable_if_t<is_member_function_pointer<_DecayFp>::value && __is_reference_wrapper<_DecayA0>::value>;
 
-template <class _Fp, class _A0,
-         class _DecayFp = __decay_t<_Fp>,
-         class _DecayA0 = __decay_t<_A0>,
-         class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
-using __enable_if_bullet3 = typename enable_if
-    <
-        is_member_function_pointer<_DecayFp>::value
-        && !is_base_of<_ClassT, _DecayA0>::value
-        && !__is_reference_wrapper<_DecayA0>::value
-    >::type;
+template <class _Fp,
+          class _A0,
+          class _DecayFp = __decay_t<_Fp>,
+          class _DecayA0 = __decay_t<_A0>,
+          class _ClassT  = typename __member_pointer_class_type<_DecayFp>::type>
+using __enable_if_bullet3 =
+    __enable_if_t<is_member_function_pointer<_DecayFp>::value &&
+                  !(is_same<_ClassT, _DecayA0>::value || is_base_of<_ClassT, _DecayA0>::value) &&
+                  !__is_reference_wrapper<_DecayA0>::value>;
 
-template <class _Fp, class _A0,
-         class _DecayFp = __decay_t<_Fp>,
-         class _DecayA0 = __decay_t<_A0>,
-         class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
-using __enable_if_bullet4 = typename enable_if
-    <
-        is_member_object_pointer<_DecayFp>::value
-        && is_base_of<_ClassT, _DecayA0>::value
-    >::type;
+template <class _Fp,
+          class _A0,
+          class _DecayFp = __decay_t<_Fp>,
+          class _DecayA0 = __decay_t<_A0>,
+          class _ClassT  = typename __member_pointer_class_type<_DecayFp>::type>
+using __enable_if_bullet4 =
+    __enable_if_t<is_member_object_pointer<_DecayFp>::value &&
+                  (is_same<_ClassT, _DecayA0>::value || is_base_of<_ClassT, _DecayA0>::value)>;
 
-template <class _Fp, class _A0,
-         class _DecayFp = __decay_t<_Fp>,
-         class _DecayA0 = __decay_t<_A0> >
-using __enable_if_bullet5 = typename enable_if
-    <
-        is_member_object_pointer<_DecayFp>::value
-        && __is_reference_wrapper<_DecayA0>::value
-    >::type;
+template <class _Fp, class _A0, class _DecayFp = __decay_t<_Fp>, class _DecayA0 = __decay_t<_A0> >
+using __enable_if_bullet5 =
+    __enable_if_t<is_member_object_pointer<_DecayFp>::value && __is_reference_wrapper<_DecayA0>::value>;
 
-template <class _Fp, class _A0,
-         class _DecayFp = __decay_t<_Fp>,
-         class _DecayA0 = __decay_t<_A0>,
-         class _ClassT = typename __member_pointer_class_type<_DecayFp>::type>
-using __enable_if_bullet6 = typename enable_if
-    <
-        is_member_object_pointer<_DecayFp>::value
-        && !is_base_of<_ClassT, _DecayA0>::value
-        && !__is_reference_wrapper<_DecayA0>::value
-    >::type;
+template <class _Fp,
+          class _A0,
+          class _DecayFp = __decay_t<_Fp>,
+          class _DecayA0 = __decay_t<_A0>,
+          class _ClassT  = typename __member_pointer_class_type<_DecayFp>::type>
+using __enable_if_bullet6 =
+    __enable_if_t<is_member_object_pointer<_DecayFp>::value &&
+                  !(is_same<_ClassT, _DecayA0>::value || is_base_of<_ClassT, _DecayA0>::value) &&
+                  !__is_reference_wrapper<_DecayA0>::value>;
 
 // __invoke forward declarations
 
 // fall back - none of the bullets
 
-template <class ..._Args>
-__nat __invoke(__any, _Args&& ...__args);
+template <class... _Args>
+__nat __invoke(_Args&&... __args);
 
 // bullets 1, 2 and 3
 
-template <class _Fp, class _A0, class ..._Args,
-          class = __enable_if_bullet1<_Fp, _A0> >
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR decltype((std::declval<_A0>().*std::declval<_Fp>())(std::declval<_Args>()...))
-__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
+// clang-format off
+template <class _Fp, class _A0, class... _Args, class = __enable_if_bullet1<_Fp, _A0> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+decltype((std::declval<_A0>().*std::declval<_Fp>())(std::declval<_Args>()...))
+__invoke(_Fp&& __f, _A0&& __a0, _Args&&... __args)
     _NOEXCEPT_(noexcept((static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...)))
-    { return           (static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...); }
+               { return (static_cast<_A0&&>(__a0).*__f)(static_cast<_Args&&>(__args)...); }
 
-template <class _Fp, class _A0, class ..._Args,
-          class = __enable_if_bullet2<_Fp, _A0> >
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR decltype((std::declval<_A0>().get().*std::declval<_Fp>())(std::declval<_Args>()...))
-__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
+template <class _Fp, class _A0, class... _Args, class = __enable_if_bullet2<_Fp, _A0> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+decltype((std::declval<_A0>().get().*std::declval<_Fp>())(std::declval<_Args>()...))
+__invoke(_Fp&& __f, _A0&& __a0, _Args&&... __args)
     _NOEXCEPT_(noexcept((__a0.get().*__f)(static_cast<_Args&&>(__args)...)))
-    { return          (__a0.get().*__f)(static_cast<_Args&&>(__args)...); }
+               { return (__a0.get().*__f)(static_cast<_Args&&>(__args)...); }
 
-template <class _Fp, class _A0, class ..._Args,
-          class = __enable_if_bullet3<_Fp, _A0> >
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR decltype(((*std::declval<_A0>()).*std::declval<_Fp>())(std::declval<_Args>()...))
-__invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
+template <class _Fp, class _A0, class... _Args, class = __enable_if_bullet3<_Fp, _A0> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+decltype(((*std::declval<_A0>()).*std::declval<_Fp>())(std::declval<_Args>()...))
+__invoke(_Fp&& __f, _A0&& __a0, _Args&&... __args)
     _NOEXCEPT_(noexcept(((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...)))
-    { return          ((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...); }
+               { return ((*static_cast<_A0&&>(__a0)).*__f)(static_cast<_Args&&>(__args)...); }
 
 // bullets 4, 5 and 6
 
-template <class _Fp, class _A0,
-          class = __enable_if_bullet4<_Fp, _A0> >
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR decltype(std::declval<_A0>().*std::declval<_Fp>())
+template <class _Fp, class _A0, class = __enable_if_bullet4<_Fp, _A0> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+decltype(std::declval<_A0>().*std::declval<_Fp>())
 __invoke(_Fp&& __f, _A0&& __a0)
     _NOEXCEPT_(noexcept(static_cast<_A0&&>(__a0).*__f))
-    { return          static_cast<_A0&&>(__a0).*__f; }
+               { return static_cast<_A0&&>(__a0).*__f; }
 
-template <class _Fp, class _A0,
-          class = __enable_if_bullet5<_Fp, _A0> >
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR decltype(std::declval<_A0>().get().*std::declval<_Fp>())
+template <class _Fp, class _A0, class = __enable_if_bullet5<_Fp, _A0> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+decltype(std::declval<_A0>().get().*std::declval<_Fp>())
 __invoke(_Fp&& __f, _A0&& __a0)
     _NOEXCEPT_(noexcept(__a0.get().*__f))
-    { return          __a0.get().*__f; }
+               { return __a0.get().*__f; }
 
-template <class _Fp, class _A0,
-          class = __enable_if_bullet6<_Fp, _A0> >
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR decltype((*std::declval<_A0>()).*std::declval<_Fp>())
+template <class _Fp, class _A0, class = __enable_if_bullet6<_Fp, _A0> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+decltype((*std::declval<_A0>()).*std::declval<_Fp>())
 __invoke(_Fp&& __f, _A0&& __a0)
     _NOEXCEPT_(noexcept((*static_cast<_A0&&>(__a0)).*__f))
-    { return          (*static_cast<_A0&&>(__a0)).*__f; }
+               { return (*static_cast<_A0&&>(__a0)).*__f; }
 
 // bullet 7
 
-template <class _Fp, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR decltype(std::declval<_Fp>()(std::declval<_Args>()...))
-__invoke(_Fp&& __f, _Args&& ...__args)
+template <class _Fp, class... _Args>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+decltype(std::declval<_Fp>()(std::declval<_Args>()...))
+__invoke(_Fp&& __f, _Args&&... __args)
     _NOEXCEPT_(noexcept(static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...)))
-    { return          static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...); }
+               { return static_cast<_Fp&&>(__f)(static_cast<_Args&&>(__args)...); }
+// clang-format on
 
 // __invokable
-template <class _Ret, class _Fp, class ..._Args>
-struct __invokable_r
-{
-  template <class _XFp, class ..._XArgs>
+template <class _Ret, class _Fp, class... _Args>
+struct __invokable_r {
+  template <class _XFp, class... _XArgs>
   static decltype(std::__invoke(std::declval<_XFp>(), std::declval<_XArgs>()...)) __try_call(int);
-  template <class _XFp, class ..._XArgs>
+  template <class _XFp, class... _XArgs>
   static __nat __try_call(...);
 
   // FIXME: Check that _Ret, _Fp, and _Args... are all complete types, cv void,
   // or incomplete array types as required by the standard.
   using _Result = decltype(__try_call<_Fp, _Args...>(0));
 
-  using type = __conditional_t<
-      _IsNotSame<_Result, __nat>::value,
-      __conditional_t<is_void<_Ret>::value, true_type, __is_core_convertible<_Result, _Ret> >,
-      false_type>;
+  using type              = __conditional_t<_IsNotSame<_Result, __nat>::value,
+                                            __conditional_t<is_void<_Ret>::value, true_type, __is_core_convertible<_Result, _Ret> >,
+                                            false_type>;
   static const bool value = type::value;
 };
-template <class _Fp, class ..._Args>
+template <class _Fp, class... _Args>
 using __invokable = __invokable_r<void, _Fp, _Args...>;
 
-template <bool _IsInvokable, bool _IsCVVoid, class _Ret, class _Fp, class ..._Args>
+template <bool _IsInvokable, bool _IsCVVoid, class _Ret, class _Fp, class... _Args>
 struct __nothrow_invokable_r_imp {
   static const bool value = false;
 };
 
-template <class _Ret, class _Fp, class ..._Args>
-struct __nothrow_invokable_r_imp<true, false, _Ret, _Fp, _Args...>
-{
-    typedef __nothrow_invokable_r_imp _ThisT;
+template <class _Ret, class _Fp, class... _Args>
+struct __nothrow_invokable_r_imp<true, false, _Ret, _Fp, _Args...> {
+  typedef __nothrow_invokable_r_imp _ThisT;
 
-    template <class _Tp>
-    static void __test_noexcept(_Tp) _NOEXCEPT;
+  template <class _Tp>
+  static void __test_noexcept(_Tp) _NOEXCEPT;
 
 #ifdef _LIBCPP_CXX03_LANG
-    static const bool value = false;
+  static const bool value = false;
 #else
-    static const bool value = noexcept(_ThisT::__test_noexcept<_Ret>(
-        _VSTD::__invoke(std::declval<_Fp>(), std::declval<_Args>()...)));
+  static const bool value =
+      noexcept(_ThisT::__test_noexcept<_Ret>(std::__invoke(std::declval<_Fp>(), std::declval<_Args>()...)));
 #endif
 };
 
-template <class _Ret, class _Fp, class ..._Args>
-struct __nothrow_invokable_r_imp<true, true, _Ret, _Fp, _Args...>
-{
+template <class _Ret, class _Fp, class... _Args>
+struct __nothrow_invokable_r_imp<true, true, _Ret, _Fp, _Args...> {
 #ifdef _LIBCPP_CXX03_LANG
-    static const bool value = false;
+  static const bool value = false;
 #else
-    static const bool value = noexcept(
-        _VSTD::__invoke(std::declval<_Fp>(), std::declval<_Args>()...));
+  static const bool value = noexcept(std::__invoke(std::declval<_Fp>(), std::declval<_Args>()...));
 #endif
 };
 
-template <class _Ret, class _Fp, class ..._Args>
+template <class _Ret, class _Fp, class... _Args>
 using __nothrow_invokable_r =
-    __nothrow_invokable_r_imp<
-            __invokable_r<_Ret, _Fp, _Args...>::value,
-            is_void<_Ret>::value,
-            _Ret, _Fp, _Args...
-    >;
+    __nothrow_invokable_r_imp<__invokable_r<_Ret, _Fp, _Args...>::value, is_void<_Ret>::value, _Ret, _Fp, _Args...>;
 
-template <class _Fp, class ..._Args>
-using __nothrow_invokable =
-    __nothrow_invokable_r_imp<
-            __invokable<_Fp, _Args...>::value,
-            true, void, _Fp, _Args...
-    >;
+template <class _Fp, class... _Args>
+using __nothrow_invokable = __nothrow_invokable_r_imp<__invokable<_Fp, _Args...>::value, true, void, _Fp, _Args...>;
 
-template <class _Fp, class ..._Args>
+template <class _Fp, class... _Args>
 struct __invoke_of
-    : public enable_if<
-        __invokable<_Fp, _Args...>::value,
-        typename __invokable_r<void, _Fp, _Args...>::_Result>
-{
-};
+    : public enable_if<__invokable<_Fp, _Args...>::value, typename __invokable_r<void, _Fp, _Args...>::_Result> {};
 
 template <class _Ret, bool = is_void<_Ret>::value>
-struct __invoke_void_return_wrapper
-{
-    template <class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static _Ret __call(_Args&&... __args) {
-        return std::__invoke(std::forward<_Args>(__args)...);
-    }
+struct __invoke_void_return_wrapper {
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static _Ret __call(_Args&&... __args) {
+    return std::__invoke(std::forward<_Args>(__args)...);
+  }
 };
 
 template <class _Ret>
-struct __invoke_void_return_wrapper<_Ret, true>
-{
-    template <class ..._Args>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void __call(_Args&&... __args) {
-        std::__invoke(std::forward<_Args>(__args)...);
-    }
+struct __invoke_void_return_wrapper<_Ret, true> {
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void __call(_Args&&... __args) {
+    std::__invoke(std::forward<_Args>(__args)...);
+  }
 };
 
 #if _LIBCPP_STD_VER >= 17
 
 // is_invocable
 
-template <class _Fn, class ..._Args>
-struct _LIBCPP_TEMPLATE_VIS is_invocable
-    : integral_constant<bool, __invokable<_Fn, _Args...>::value> {};
+template <class _Fn, class... _Args>
+struct _LIBCPP_TEMPLATE_VIS is_invocable : integral_constant<bool, __invokable<_Fn, _Args...>::value> {};
 
-template <class _Ret, class _Fn, class ..._Args>
-struct _LIBCPP_TEMPLATE_VIS is_invocable_r
-    : integral_constant<bool, __invokable_r<_Ret, _Fn, _Args...>::value> {};
+template <class _Ret, class _Fn, class... _Args>
+struct _LIBCPP_TEMPLATE_VIS is_invocable_r : integral_constant<bool, __invokable_r<_Ret, _Fn, _Args...>::value> {};
 
-template <class _Fn, class ..._Args>
+template <class _Fn, class... _Args>
 inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
 
-template <class _Ret, class _Fn, class ..._Args>
+template <class _Ret, class _Fn, class... _Args>
 inline constexpr bool is_invocable_r_v = is_invocable_r<_Ret, _Fn, _Args...>::value;
 
 // is_nothrow_invocable
 
-template <class _Fn, class ..._Args>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable
-    : integral_constant<bool, __nothrow_invokable<_Fn, _Args...>::value> {};
+template <class _Fn, class... _Args>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable : integral_constant<bool, __nothrow_invokable<_Fn, _Args...>::value> {
+};
 
-template <class _Ret, class _Fn, class ..._Args>
+template <class _Ret, class _Fn, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_invocable_r
     : integral_constant<bool, __nothrow_invokable_r<_Ret, _Fn, _Args...>::value> {};
 
-template <class _Fn, class ..._Args>
+template <class _Fn, class... _Args>
 inline constexpr bool is_nothrow_invocable_v = is_nothrow_invocable<_Fn, _Args...>::value;
 
-template <class _Ret, class _Fn, class ..._Args>
+template <class _Ret, class _Fn, class... _Args>
 inline constexpr bool is_nothrow_invocable_r_v = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
 
 template <class _Fn, class... _Args>
-struct _LIBCPP_TEMPLATE_VIS invoke_result
-    : __invoke_of<_Fn, _Args...>
-{
-};
+struct _LIBCPP_TEMPLATE_VIS invoke_result : __invoke_of<_Fn, _Args...> {};
 
 template <class _Fn, class... _Args>
 using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
diff --git a/third_party/libcxx/__type_traits/is_abstract.h b/third_party/libcxx/__type_traits/is_abstract.h
index 5e886bb8d..4aa456be1 100644
--- a/third_party/libcxx/__type_traits/is_abstract.h
+++ b/third_party/libcxx/__type_traits/is_abstract.h
@@ -18,8 +18,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_abstract
-    : public integral_constant<bool, __is_abstract(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_abstract : public integral_constant<bool, __is_abstract(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_aggregate.h b/third_party/libcxx/__type_traits/is_aggregate.h
index 3b0942048..4e0988071 100644
--- a/third_party/libcxx/__type_traits/is_aggregate.h
+++ b/third_party/libcxx/__type_traits/is_aggregate.h
@@ -20,8 +20,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
-is_aggregate : public integral_constant<bool, __is_aggregate(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_aggregate : public integral_constant<bool, __is_aggregate(_Tp)> {};
 
 template <class _Tp>
 inline constexpr bool is_aggregate_v = __is_aggregate(_Tp);
diff --git a/third_party/libcxx/__type_traits/is_allocator.h b/third_party/libcxx/__type_traits/is_allocator.h
index ee4154d7e..144ffac4d 100644
--- a/third_party/libcxx/__type_traits/is_allocator.h
+++ b/third_party/libcxx/__type_traits/is_allocator.h
@@ -21,15 +21,13 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<typename _Alloc, typename = void, typename = void>
+template <typename _Alloc, typename = void, typename = void>
 struct __is_allocator : false_type {};
 
-template<typename _Alloc>
+template <typename _Alloc>
 struct __is_allocator<_Alloc,
-       __void_t<typename _Alloc::value_type>,
-       __void_t<decltype(std::declval<_Alloc&>().allocate(size_t(0)))>
-     >
-   : true_type {};
+                      __void_t<typename _Alloc::value_type>,
+                      __void_t<decltype(std::declval<_Alloc&>().allocate(size_t(0)))> > : true_type {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_always_bitcastable.h b/third_party/libcxx/__type_traits/is_always_bitcastable.h
index 63304eb49..5bc650b41 100644
--- a/third_party/libcxx/__type_traits/is_always_bitcastable.h
+++ b/third_party/libcxx/__type_traits/is_always_bitcastable.h
@@ -32,49 +32,52 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _From, class _To>
 struct __is_always_bitcastable {
   using _UnqualFrom = __remove_cv_t<_From>;
-  using _UnqualTo = __remove_cv_t<_To>;
+  using _UnqualTo   = __remove_cv_t<_To>;
 
+  // clang-format off
   static const bool value =
-    // First, the simple case -- `From` and `To` are the same object type.
-    (is_same<_UnqualFrom, _UnqualTo>::value && is_trivially_copyable<_UnqualFrom>::value) ||
+      // First, the simple case -- `From` and `To` are the same object type.
+      (is_same<_UnqualFrom, _UnqualTo>::value && is_trivially_copyable<_UnqualFrom>::value) ||
 
-    // Beyond the simple case, we say that one type is "always bit-castable" to another if:
-    // - (1) `From` and `To` have the same value representation, and in addition every possible value of `From` has
-    //   a corresponding value in the `To` type (in other words, the set of values of `To` is a superset of the set of
-    //   values of `From`);
-    // - (2) When the corresponding values are not the same value (as, for example, between an unsigned and a signed
-    //   integer, where a large positive value of the unsigned integer corresponds to a negative value in the signed
-    //   integer type), the value of `To` that results from a bitwise copy of `From` is the same what would be produced
-    //   by the built-in assignment (if it were defined for the two types, to which there are minor exceptions, e.g.
-    //   built-in arrays).
-    //
-    // In practice, that means:
-    // - all integral types (except `bool`, see below) -- that is, character types and `int` types, both signed and
-    //   unsigned...
-    // - as well as arrays of such types...
-    // - ...that have the same size.
-    //
-    // Other trivially-copyable types can't be validly bit-cast outside of their own type:
-    // - floating-point types normally have different sizes and thus aren't bit-castable between each other (fails #1);
-    // - integral types and floating-point types use different representations, so for example bit-casting an integral
-    //   `1` to `float` results in a very small less-than-one value, unlike built-in assignment that produces `1.0`
-    //   (fails #2);
-    // - booleans normally use only a single bit of their object representation; bit-casting an integer to a boolean
-    //   will result in a boolean object with an incorrect representation, which is undefined behavior (fails #2).
-    //   Bit-casting from a boolean into an integer, however, is valid;
-    // - enumeration types may have different ranges of possible values (fails #1);
-    // - for pointers, it is not guaranteed that pointers to different types use the same set of values to represent
-    //   addresses, and the conversion results are explicitly unspecified for types with different alignments
-    //   (fails #1);
-    // - for structs and unions it is impossible to determine whether the set of values of one of them is a subset of
-    //   the other (fails #1);
-    // - there is no need to consider `nullptr_t` for practical purposes.
-    (
-      sizeof(_From) == sizeof(_To) &&
-      is_integral<_From>::value &&
-      is_integral<_To>::value &&
-      !is_same<_UnqualTo, bool>::value
-    );
+      // Beyond the simple case, we say that one type is "always bit-castable" to another if:
+      // - (1) `From` and `To` have the same value representation, and in addition every possible value of `From` has
+      //   a corresponding value in the `To` type (in other words, the set of values of `To` is a superset of the set of
+      //   values of `From`);
+      // - (2) When the corresponding values are not the same value (as, for example, between an unsigned and a signed
+      //   integer, where a large positive value of the unsigned integer corresponds to a negative value in the signed
+      //   integer type), the value of `To` that results from a bitwise copy of `From` is the same what would be
+      //   produced by the built-in assignment (if it were defined for the two types, to which there are minor
+      //   exceptions, e.g. built-in arrays).
+      //
+      // In practice, that means:
+      // - all integral types (except `bool`, see below) -- that is, character types and `int` types, both signed and
+      //   unsigned...
+      // - as well as arrays of such types...
+      // - ...that have the same size.
+      //
+      // Other trivially-copyable types can't be validly bit-cast outside of their own type:
+      // - floating-point types normally have different sizes and thus aren't bit-castable between each other (fails
+      // #1);
+      // - integral types and floating-point types use different representations, so for example bit-casting an integral
+      //   `1` to `float` results in a very small less-than-one value, unlike built-in assignment that produces `1.0`
+      //   (fails #2);
+      // - booleans normally use only a single bit of their object representation; bit-casting an integer to a boolean
+      //   will result in a boolean object with an incorrect representation, which is undefined behavior (fails #2).
+      //   Bit-casting from a boolean into an integer, however, is valid;
+      // - enumeration types may have different ranges of possible values (fails #1);
+      // - for pointers, it is not guaranteed that pointers to different types use the same set of values to represent
+      //   addresses, and the conversion results are explicitly unspecified for types with different alignments
+      //   (fails #1);
+      // - for structs and unions it is impossible to determine whether the set of values of one of them is a subset of
+      //   the other (fails #1);
+      // - there is no need to consider `nullptr_t` for practical purposes.
+      (
+        sizeof(_From) == sizeof(_To) &&
+        is_integral<_From>::value &&
+        is_integral<_To>::value &&
+        !is_same<_UnqualTo, bool>::value
+      );
+  // clang-format on
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/is_arithmetic.h b/third_party/libcxx/__type_traits/is_arithmetic.h
index 03218c816..c9713e184 100644
--- a/third_party/libcxx/__type_traits/is_arithmetic.h
+++ b/third_party/libcxx/__type_traits/is_arithmetic.h
@@ -20,9 +20,9 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_arithmetic
-    : public integral_constant<bool, is_integral<_Tp>::value      ||
-                                     is_floating_point<_Tp>::value> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_arithmetic
+    : public integral_constant<bool, is_integral<_Tp>::value || is_floating_point<_Tp>::value> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_array.h b/third_party/libcxx/__type_traits/is_array.h
index 827517666..dc23de28d 100644
--- a/third_party/libcxx/__type_traits/is_array.h
+++ b/third_party/libcxx/__type_traits/is_array.h
@@ -19,31 +19,30 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-// TODO: Clang incorrectly reports that __is_array is true for T[0].
-//       Re-enable the branch once https://llvm.org/PR54705 is fixed.
-#if __has_builtin(__is_array) && 0
+#if __has_builtin(__is_array) &&                                                                                       \
+    (!defined(_LIBCPP_COMPILER_CLANG_BASED) || (defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 1900))
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_array : _BoolConstant<__is_array(_Tp)> { };
+struct _LIBCPP_TEMPLATE_VIS is_array : _BoolConstant<__is_array(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_array_v = __is_array(_Tp);
-#endif
+#  endif
 
 #else
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array
-    : public false_type {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]>
-    : public true_type {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[_Np]>
-    : public true_type {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_array : public false_type {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]> : public true_type {};
+template <class _Tp, size_t _Np>
+struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[_Np]> : public true_type {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_array_v = is_array<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_array)
 
diff --git a/third_party/libcxx/__type_traits/is_assignable.h b/third_party/libcxx/__type_traits/is_assignable.h
index 3ee3e21bf..cfb469977 100644
--- a/third_party/libcxx/__type_traits/is_assignable.h
+++ b/third_party/libcxx/__type_traits/is_assignable.h
@@ -10,6 +10,8 @@
 #define _LIBCPP___TYPE_TRAITS_IS_ASSIGNABLE_H
 
 #include <__config>
+#include <__type_traits/add_lvalue_reference.h>
+#include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -18,14 +20,33 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp, class _Up>
-struct _LIBCPP_TEMPLATE_VIS is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> { };
+template <class _Tp, class _Up>
+struct _LIBCPP_TEMPLATE_VIS is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp, class _Arg>
 inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Arg);
 #endif
 
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_copy_assignable
+    : public integral_constant<bool,
+                               __is_assignable(__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<const _Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
+#endif
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_move_assignable
+    : public integral_constant<bool, __is_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_ASSIGNABLE_H
diff --git a/third_party/libcxx/__type_traits/is_base_of.h b/third_party/libcxx/__type_traits/is_base_of.h
index 3338fffe2..090abeeb5 100644
--- a/third_party/libcxx/__type_traits/is_base_of.h
+++ b/third_party/libcxx/__type_traits/is_base_of.h
@@ -19,8 +19,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Bp, class _Dp>
-struct _LIBCPP_TEMPLATE_VIS is_base_of
-    : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
+struct _LIBCPP_TEMPLATE_VIS is_base_of : public integral_constant<bool, __is_base_of(_Bp, _Dp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Bp, class _Dp>
diff --git a/third_party/libcxx/__type_traits/is_bounded_array.h b/third_party/libcxx/__type_traits/is_bounded_array.h
index 46da83a56..211403d63 100644
--- a/third_party/libcxx/__type_traits/is_bounded_array.h
+++ b/third_party/libcxx/__type_traits/is_bounded_array.h
@@ -19,17 +19,20 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class>                 struct _LIBCPP_TEMPLATE_VIS __libcpp_is_bounded_array           : false_type {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_bounded_array<_Tp[_Np]> : true_type {};
+template <class>
+struct _LIBCPP_TEMPLATE_VIS __libcpp_is_bounded_array : false_type {};
+template <class _Tp, size_t _Np>
+struct _LIBCPP_TEMPLATE_VIS __libcpp_is_bounded_array<_Tp[_Np]> : true_type {};
 
 #if _LIBCPP_STD_VER >= 20
 
-template <class>                 struct _LIBCPP_TEMPLATE_VIS is_bounded_array           : false_type {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_bounded_array<_Tp[_Np]> : true_type {};
+template <class>
+struct _LIBCPP_TEMPLATE_VIS is_bounded_array : false_type {};
+template <class _Tp, size_t _Np>
+struct _LIBCPP_TEMPLATE_VIS is_bounded_array<_Tp[_Np]> : true_type {};
 
 template <class _Tp>
-inline constexpr
-bool is_bounded_array_v  = is_bounded_array<_Tp>::value;
+inline constexpr bool is_bounded_array_v = is_bounded_array<_Tp>::value;
 
 #endif
 
diff --git a/third_party/libcxx/__type_traits/is_callable.h b/third_party/libcxx/__type_traits/is_callable.h
index 445373c43..49724fe89 100644
--- a/third_party/libcxx/__type_traits/is_callable.h
+++ b/third_party/libcxx/__type_traits/is_callable.h
@@ -19,12 +19,12 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Func, class... _Args, class = decltype(std::declval<_Func>()(std::declval<_Args>()...))>
+template <class _Func, class... _Args, class = decltype(std::declval<_Func>()(std::declval<_Args>()...))>
 true_type __is_callable_helper(int);
-template<class...>
+template <class...>
 false_type __is_callable_helper(...);
 
-template<class _Func, class... _Args>
+template <class _Func, class... _Args>
 struct __is_callable : decltype(std::__is_callable_helper<_Func, _Args...>(0)) {};
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/is_class.h b/third_party/libcxx/__type_traits/is_class.h
index 62bf6d9cf..034f76a78 100644
--- a/third_party/libcxx/__type_traits/is_class.h
+++ b/third_party/libcxx/__type_traits/is_class.h
@@ -18,8 +18,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class
-    : public integral_constant<bool, __is_class(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_class : public integral_constant<bool, __is_class(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_compound.h b/third_party/libcxx/__type_traits/is_compound.h
index 73d830c80..cd208ceab 100644
--- a/third_party/libcxx/__type_traits/is_compound.h
+++ b/third_party/libcxx/__type_traits/is_compound.h
@@ -21,23 +21,23 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_compound)
 
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_compound : _BoolConstant<__is_compound(_Tp)> { };
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_compound : _BoolConstant<__is_compound(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_compound_v = __is_compound(_Tp);
-#endif
+#  endif
 
 #else // __has_builtin(__is_compound)
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_compound
-    : public integral_constant<bool, !is_fundamental<_Tp>::value> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_compound : public integral_constant<bool, !is_fundamental<_Tp>::value> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_compound_v = is_compound<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_compound)
 
diff --git a/third_party/libcxx/__type_traits/is_const.h b/third_party/libcxx/__type_traits/is_const.h
index fad360286..47ef70872 100644
--- a/third_party/libcxx/__type_traits/is_const.h
+++ b/third_party/libcxx/__type_traits/is_const.h
@@ -21,22 +21,24 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if __has_builtin(__is_const)
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_const : _BoolConstant<__is_const(_Tp)> { };
+struct _LIBCPP_TEMPLATE_VIS is_const : _BoolConstant<__is_const(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_const_v = __is_const(_Tp);
-#endif
+#  endif
 
 #else
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const            : public false_type {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_const : public false_type {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_const_v = is_const<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_const)
 
diff --git a/third_party/libcxx/__type_traits/is_constant_evaluated.h b/third_party/libcxx/__type_traits/is_constant_evaluated.h
index d6278f521..05e070a74 100644
--- a/third_party/libcxx/__type_traits/is_constant_evaluated.h
+++ b/third_party/libcxx/__type_traits/is_constant_evaluated.h
@@ -18,14 +18,14 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
-_LIBCPP_INLINE_VISIBILITY
-inline constexpr bool is_constant_evaluated() noexcept {
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_constant_evaluated() noexcept {
   return __builtin_is_constant_evaluated();
 }
 #endif
 
-_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR
-bool __libcpp_is_constant_evaluated() _NOEXCEPT { return __builtin_is_constant_evaluated(); }
+_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR bool __libcpp_is_constant_evaluated() _NOEXCEPT {
+  return __builtin_is_constant_evaluated();
+}
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_constructible.h b/third_party/libcxx/__type_traits/is_constructible.h
index ebe7bfd37..567bd165c 100644
--- a/third_party/libcxx/__type_traits/is_constructible.h
+++ b/third_party/libcxx/__type_traits/is_constructible.h
@@ -10,6 +10,8 @@
 #define _LIBCPP___TYPE_IS_CONSTRUCTIBLE_H
 
 #include <__config>
+#include <__type_traits/add_lvalue_reference.h>
+#include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -18,16 +20,40 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class ..._Args>
-struct _LIBCPP_TEMPLATE_VIS is_constructible
-    : public integral_constant<bool, __is_constructible(_Tp, _Args...)>
-{ };
+template <class _Tp, class... _Args>
+struct _LIBCPP_TEMPLATE_VIS is_constructible : public integral_constant<bool, __is_constructible(_Tp, _Args...)> {};
 
 #if _LIBCPP_STD_VER >= 17
-template <class _Tp, class ..._Args>
+template <class _Tp, class... _Args>
 inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...);
 #endif
 
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_copy_constructible
+    : public integral_constant<bool, __is_constructible(_Tp, __add_lvalue_reference_t<const _Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
+#endif
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_move_constructible
+    : public integral_constant<bool, __is_constructible(_Tp, __add_rvalue_reference_t<_Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value;
+#endif
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_default_constructible : public integral_constant<bool, __is_constructible(_Tp)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_default_constructible_v = __is_constructible(_Tp);
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_IS_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_convertible.h b/third_party/libcxx/__type_traits/is_convertible.h
index 749d6fd47..414c2a6d6 100644
--- a/third_party/libcxx/__type_traits/is_convertible.h
+++ b/third_party/libcxx/__type_traits/is_convertible.h
@@ -11,12 +11,6 @@
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_array.h>
-#include <__type_traits/is_function.h>
-#include <__type_traits/is_void.h>
-#include <__type_traits/remove_reference.h>
-#include <__utility/declval.h>
-#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -24,90 +18,12 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__is_convertible) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
-
 template <class _T1, class _T2>
 struct _LIBCPP_TEMPLATE_VIS is_convertible : public integral_constant<bool, __is_convertible(_T1, _T2)> {};
 
-#elif __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
-
-template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible
-    : public integral_constant<bool, __is_convertible_to(_T1, _T2)> {};
-
-// TODO: Remove this fallback when GCC < 13 support is no longer required.
-// GCC 13 has the __is_convertible built-in.
-#else  // __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
-
-namespace __is_convertible_imp
-{
-template <class _Tp> void  __test_convert(_Tp);
-
-template <class _From, class _To, class = void>
-struct __is_convertible_test : public false_type {};
-
-template <class _From, class _To>
-struct __is_convertible_test<_From, _To,
-    decltype(__is_convertible_imp::__test_convert<_To>(std::declval<_From>()))> : public true_type
-{};
-
-template <class _Tp, bool _IsArray =    is_array<_Tp>::value,
-                     bool _IsFunction = is_function<_Tp>::value,
-                     bool _IsVoid =     is_void<_Tp>::value>
-                     struct __is_array_function_or_void                          {enum {value = 0};};
-template <class _Tp> struct __is_array_function_or_void<_Tp, true, false, false> {enum {value = 1};};
-template <class _Tp> struct __is_array_function_or_void<_Tp, false, true, false> {enum {value = 2};};
-template <class _Tp> struct __is_array_function_or_void<_Tp, false, false, true> {enum {value = 3};};
-}
-
-template <class _Tp,
-    unsigned = __is_convertible_imp::__is_array_function_or_void<__libcpp_remove_reference_t<_Tp> >::value>
-struct __is_convertible_check
-{
-    static const size_t __v = 0;
-};
-
-template <class _Tp>
-struct __is_convertible_check<_Tp, 0>
-{
-    static const size_t __v = sizeof(_Tp);
-};
-
-template <class _T1, class _T2,
-    unsigned _T1_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T1>::value,
-    unsigned _T2_is_array_function_or_void = __is_convertible_imp::__is_array_function_or_void<_T2>::value>
-struct __is_convertible
-    : public integral_constant<bool,
-        __is_convertible_imp::__is_convertible_test<_T1, _T2>::value
-    >
-{};
-
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 1> : public false_type {};
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 1> : public false_type {};
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 1> : public false_type {};
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 1> : public false_type {};
-
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 2> : public false_type {};
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 2> : public false_type {};
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 2> : public false_type {};
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 2> : public false_type {};
-
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 0, 3> : public false_type {};
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 1, 3> : public false_type {};
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 2, 3> : public false_type {};
-template <class _T1, class _T2> struct __is_convertible<_T1, _T2, 3, 3> : public true_type {};
-
-template <class _T1, class _T2> struct _LIBCPP_TEMPLATE_VIS is_convertible
-    : public __is_convertible<_T1, _T2>
-{
-    static const size_t __complete_check1 = __is_convertible_check<_T1>::__v;
-    static const size_t __complete_check2 = __is_convertible_check<_T2>::__v;
-};
-
-#endif // __has_builtin(__is_convertible_to) && !defined(_LIBCPP_USE_IS_CONVERTIBLE_FALLBACK)
-
 #if _LIBCPP_STD_VER >= 17
 template <class _From, class _To>
-inline constexpr bool is_convertible_v = is_convertible<_From, _To>::value;
+inline constexpr bool is_convertible_v = __is_convertible(_From, _To);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/is_copy_assignable.h b/third_party/libcxx/__type_traits/is_copy_assignable.h
deleted file mode 100644
index 245ae4b28..000000000
--- a/third_party/libcxx/__type_traits/is_copy_assignable.h
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H
-
-#include <__config>
-#include <__type_traits/add_const.h>
-#include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_copy_assignable
-    : public integral_constant<
-          bool,
-          __is_assignable(__add_lvalue_reference_t<_Tp>,
-                          __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H
diff --git a/third_party/libcxx/__type_traits/is_copy_constructible.h b/third_party/libcxx/__type_traits/is_copy_constructible.h
deleted file mode 100644
index 07e2c93ec..000000000
--- a/third_party/libcxx/__type_traits/is_copy_constructible.h
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H
-
-#include <__config>
-#include <__type_traits/add_const.h>
-#include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_copy_constructible
-    : public integral_constant<
-          bool,
-          __is_constructible(_Tp, __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_core_convertible.h b/third_party/libcxx/__type_traits/is_core_convertible.h
index 1ce407913..0de177c77 100644
--- a/third_party/libcxx/__type_traits/is_core_convertible.h
+++ b/third_party/libcxx/__type_traits/is_core_convertible.h
@@ -27,9 +27,8 @@ template <class _Tp, class _Up, class = void>
 struct __is_core_convertible : public false_type {};
 
 template <class _Tp, class _Up>
-struct __is_core_convertible<_Tp, _Up, decltype(
-    static_cast<void(*)(_Up)>(0) ( static_cast<_Tp(*)()>(0)() )
-)> : public true_type {};
+struct __is_core_convertible<_Tp, _Up, decltype(static_cast<void (*)(_Up)>(0)(static_cast<_Tp (*)()>(0)()))>
+    : public true_type {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_default_constructible.h b/third_party/libcxx/__type_traits/is_default_constructible.h
deleted file mode 100644
index 7bc21f572..000000000
--- a/third_party/libcxx/__type_traits/is_default_constructible.h
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H
-
-#include <__config>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_default_constructible
-    : public integral_constant<bool, __is_constructible(_Tp)>
-    {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_default_constructible_v = __is_constructible(_Tp);
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_destructible.h b/third_party/libcxx/__type_traits/is_destructible.h
index d785b4b47..3248b07d3 100644
--- a/third_party/libcxx/__type_traits/is_destructible.h
+++ b/third_party/libcxx/__type_traits/is_destructible.h
@@ -24,13 +24,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_destructible)
 
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_destructible : _BoolConstant<__is_destructible(_Tp)> { };
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_destructible : _BoolConstant<__is_destructible(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_destructible_v = __is_destructible(_Tp);
-#endif
+#  endif
 
 #else // __has_builtin(__is_destructible)
 
@@ -42,19 +42,19 @@ inline constexpr bool is_destructible_v = __is_destructible(_Tp);
 //    where _Up is remove_all_extents<_Tp>::type
 
 template <class>
-struct __is_destructible_apply { typedef int type; };
+struct __is_destructible_apply {
+  typedef int type;
+};
 
 template <typename _Tp>
 struct __is_destructor_wellformed {
-    template <typename _Tp1>
-    static true_type  __test (
-        typename __is_destructible_apply<decltype(std::declval<_Tp1&>().~_Tp1())>::type
-    );
+  template <typename _Tp1>
+  static true_type __test(typename __is_destructible_apply<decltype(std::declval<_Tp1&>().~_Tp1())>::type);
 
-    template <typename _Tp1>
-    static false_type __test (...);
+  template <typename _Tp1>
+  static false_type __test(...);
 
-    static const bool value = decltype(__test<_Tp>(12))::value;
+  static const bool value = decltype(__test<_Tp>(12))::value;
 };
 
 template <class _Tp, bool>
@@ -62,12 +62,10 @@ struct __destructible_imp;
 
 template <class _Tp>
 struct __destructible_imp<_Tp, false>
-   : public integral_constant<bool,
-        __is_destructor_wellformed<__remove_all_extents_t<_Tp> >::value> {};
+    : public integral_constant<bool, __is_destructor_wellformed<__remove_all_extents_t<_Tp> >::value> {};
 
 template <class _Tp>
-struct __destructible_imp<_Tp, true>
-    : public true_type {};
+struct __destructible_imp<_Tp, true> : public true_type {};
 
 template <class _Tp, bool>
 struct __destructible_false;
@@ -79,21 +77,18 @@ template <class _Tp>
 struct __destructible_false<_Tp, true> : public false_type {};
 
 template <class _Tp>
-struct is_destructible
-    : public __destructible_false<_Tp, is_function<_Tp>::value> {};
+struct is_destructible : public __destructible_false<_Tp, is_function<_Tp>::value> {};
 
 template <class _Tp>
-struct is_destructible<_Tp[]>
-    : public false_type {};
+struct is_destructible<_Tp[]> : public false_type {};
 
 template <>
-struct is_destructible<void>
-    : public false_type {};
+struct is_destructible<void> : public false_type {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_destructible)
 
diff --git a/third_party/libcxx/__type_traits/is_empty.h b/third_party/libcxx/__type_traits/is_empty.h
index 46518e190..951d93b5a 100644
--- a/third_party/libcxx/__type_traits/is_empty.h
+++ b/third_party/libcxx/__type_traits/is_empty.h
@@ -19,8 +19,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_empty
-    : public integral_constant<bool, __is_empty(_Tp)> {};
+struct _LIBCPP_TEMPLATE_VIS is_empty : public integral_constant<bool, __is_empty(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_enum.h b/third_party/libcxx/__type_traits/is_enum.h
index 7b7221d40..2fab6db2c 100644
--- a/third_party/libcxx/__type_traits/is_enum.h
+++ b/third_party/libcxx/__type_traits/is_enum.h
@@ -18,14 +18,24 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
-    : public integral_constant<bool, __is_enum(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_enum : public integral_constant<bool, __is_enum(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_enum_v = __is_enum(_Tp);
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_scoped_enum : bool_constant<__is_scoped_enum(_Tp)> {};
+
+template <class _Tp>
+inline constexpr bool is_scoped_enum_v = __is_scoped_enum(_Tp);
+
+#endif // _LIBCPP_STD_VER >= 23
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_ENUM_H
diff --git a/third_party/libcxx/__type_traits/is_equality_comparable.h b/third_party/libcxx/__type_traits/is_equality_comparable.h
index 381108365..4397f743e 100644
--- a/third_party/libcxx/__type_traits/is_equality_comparable.h
+++ b/third_party/libcxx/__type_traits/is_equality_comparable.h
@@ -6,16 +6,17 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef _LIBCPP___TYPE_TRAITS_IS_EQUAILITY_COMPARABLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_EQUAILITY_COMPARABLE_H
+#ifndef _LIBCPP___TYPE_TRAITS_IS_EQUALITY_COMPARABLE_H
+#define _LIBCPP___TYPE_TRAITS_IS_EQUALITY_COMPARABLE_H
 
 #include <__config>
+#include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_integral.h>
 #include <__type_traits/is_same.h>
+#include <__type_traits/is_signed.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/remove_cv.h>
-#include <__type_traits/remove_cvref.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 
@@ -43,8 +44,10 @@ struct __is_equality_comparable<_Tp, _Up, __void_t<decltype(std::declval<_Tp>()
 // pointers that don't have the same type (ignoring cv-qualifiers): pointers to virtual bases are equality comparable,
 //   but don't have the same bit-pattern. An exception to this is comparing to a void-pointer. There the bit-pattern is
 //   always compared.
+// objects with padding bytes: since objects with padding bytes may compare equal, even though their object
+//   representation may not be equivalent.
 
-template <class _Tp, class _Up>
+template <class _Tp, class _Up, class = void>
 struct __libcpp_is_trivially_equality_comparable_impl : false_type {};
 
 template <class _Tp>
@@ -57,6 +60,13 @@ struct __libcpp_is_trivially_equality_comparable_impl<_Tp, _Tp>
 };
 #endif // __has_builtin(__is_trivially_equality_comparable)
 
+template <class _Tp, class _Up>
+struct __libcpp_is_trivially_equality_comparable_impl<
+    _Tp,
+    _Up,
+    __enable_if_t<is_integral<_Tp>::value && is_integral<_Up>::value && !is_same<_Tp, _Up>::value &&
+                  is_signed<_Tp>::value == is_signed<_Up>::value && sizeof(_Tp) == sizeof(_Up)> > : true_type {};
+
 template <class _Tp>
 struct __libcpp_is_trivially_equality_comparable_impl<_Tp*, _Tp*> : true_type {};
 
@@ -75,4 +85,4 @@ using __libcpp_is_trivially_equality_comparable =
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP___TYPE_TRAITS_IS_EQUAILITY_COMPARABLE_H
+#endif // _LIBCPP___TYPE_TRAITS_IS_EQUALITY_COMPARABLE_H
diff --git a/third_party/libcxx/__type_traits/is_final.h b/third_party/libcxx/__type_traits/is_final.h
index ad03b213b..499c5e3a1 100644
--- a/third_party/libcxx/__type_traits/is_final.h
+++ b/third_party/libcxx/__type_traits/is_final.h
@@ -18,12 +18,12 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
-__libcpp_is_final : public integral_constant<bool, __is_final(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS __libcpp_is_final : public integral_constant<bool, __is_final(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS
-is_final : public integral_constant<bool, __is_final(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_final : public integral_constant<bool, __is_final(_Tp)> {};
 #endif
 
 #if _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/__type_traits/is_floating_point.h b/third_party/libcxx/__type_traits/is_floating_point.h
index 2789943a7..add34782d 100644
--- a/third_party/libcxx/__type_traits/is_floating_point.h
+++ b/third_party/libcxx/__type_traits/is_floating_point.h
@@ -19,13 +19,15 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+// clang-format off
 template <class _Tp> struct __libcpp_is_floating_point              : public false_type {};
 template <>          struct __libcpp_is_floating_point<float>       : public true_type {};
 template <>          struct __libcpp_is_floating_point<double>      : public true_type {};
 template <>          struct __libcpp_is_floating_point<long double> : public true_type {};
+// clang-format on
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_floating_point
-    : public __libcpp_is_floating_point<__remove_cv_t<_Tp> > {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_floating_point : public __libcpp_is_floating_point<__remove_cv_t<_Tp> > {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_function.h b/third_party/libcxx/__type_traits/is_function.h
index f09f19adf..98fedd0ad 100644
--- a/third_party/libcxx/__type_traits/is_function.h
+++ b/third_party/libcxx/__type_traits/is_function.h
@@ -11,8 +11,6 @@
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_const.h>
-#include <__type_traits/is_reference.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -20,22 +18,12 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__is_function)
-
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_function : integral_constant<bool, __is_function(_Tp)> {};
 
-#else
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_function
-    : public integral_constant<bool, !(is_reference<_Tp>::value || is_const<const _Tp>::value)> {};
-
-#endif // __has_builtin(__is_function)
-
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
-inline constexpr bool is_function_v = is_function<_Tp>::value;
+inline constexpr bool is_function_v = __is_function(_Tp);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/is_fundamental.h b/third_party/libcxx/__type_traits/is_fundamental.h
index b38c675ba..b7f6aafc7 100644
--- a/third_party/libcxx/__type_traits/is_fundamental.h
+++ b/third_party/libcxx/__type_traits/is_fundamental.h
@@ -23,25 +23,24 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_fundamental)
 
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_fundamental : _BoolConstant<__is_fundamental(_Tp)> { };
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_fundamental : _BoolConstant<__is_fundamental(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_fundamental_v = __is_fundamental(_Tp);
-#endif
+#  endif
 
 #else // __has_builtin(__is_fundamental)
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fundamental
-    : public integral_constant<bool, is_void<_Tp>::value        ||
-                                     __is_nullptr_t<_Tp>::value ||
-                                     is_arithmetic<_Tp>::value> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_fundamental
+    : public integral_constant<bool, is_void<_Tp>::value || __is_null_pointer_v<_Tp> || is_arithmetic<_Tp>::value> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_fundamental)
 
diff --git a/third_party/libcxx/__type_traits/is_implicitly_default_constructible.h b/third_party/libcxx/__type_traits/is_implicitly_default_constructible.h
index b77f94845..d5dadd7b8 100644
--- a/third_party/libcxx/__type_traits/is_implicitly_default_constructible.h
+++ b/third_party/libcxx/__type_traits/is_implicitly_default_constructible.h
@@ -11,7 +11,7 @@
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_default_constructible.h>
+#include <__type_traits/is_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -28,19 +28,17 @@ template <class _Tp>
 void __test_implicit_default_constructible(_Tp);
 
 template <class _Tp, class = void, class = typename is_default_constructible<_Tp>::type>
-struct __is_implicitly_default_constructible
-    : false_type
-{ };
+struct __is_implicitly_default_constructible : false_type {};
 
 template <class _Tp>
-struct __is_implicitly_default_constructible<_Tp, decltype(std::__test_implicit_default_constructible<_Tp const&>({})), true_type>
-    : true_type
-{ };
+struct __is_implicitly_default_constructible<_Tp,
+                                             decltype(std::__test_implicit_default_constructible<_Tp const&>({})),
+                                             true_type> : true_type {};
 
 template <class _Tp>
-struct __is_implicitly_default_constructible<_Tp, decltype(std::__test_implicit_default_constructible<_Tp const&>({})), false_type>
-    : false_type
-{ };
+struct __is_implicitly_default_constructible<_Tp,
+                                             decltype(std::__test_implicit_default_constructible<_Tp const&>({})),
+                                             false_type> : false_type {};
 #endif // !C++03
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/is_integral.h b/third_party/libcxx/__type_traits/is_integral.h
index c4803cb03..26969885a 100644
--- a/third_party/libcxx/__type_traits/is_integral.h
+++ b/third_party/libcxx/__type_traits/is_integral.h
@@ -19,6 +19,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+// clang-format off
 template <class _Tp> struct __libcpp_is_integral                     { enum { value = 0 }; };
 template <>          struct __libcpp_is_integral<bool>               { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<char>               { enum { value = 1 }; };
@@ -44,26 +45,27 @@ template <>          struct __libcpp_is_integral<unsigned long long> { enum { va
 template <>          struct __libcpp_is_integral<__int128_t>         { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<__uint128_t>        { enum { value = 1 }; };
 #endif
+// clang-format on
 
 #if __has_builtin(__is_integral)
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_integral : _BoolConstant<__is_integral(_Tp)> { };
+struct _LIBCPP_TEMPLATE_VIS is_integral : _BoolConstant<__is_integral(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_integral_v = __is_integral(_Tp);
-#endif
+#  endif
 
 #else
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral
-    : public _BoolConstant<__libcpp_is_integral<__remove_cv_t<_Tp> >::value> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_integral : public _BoolConstant<__libcpp_is_integral<__remove_cv_t<_Tp> >::value> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_integral_v = is_integral<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_integral)
 
diff --git a/third_party/libcxx/__type_traits/is_literal_type.h b/third_party/libcxx/__type_traits/is_literal_type.h
index 624fa5dbc..10e23bcef 100644
--- a/third_party/libcxx/__type_traits/is_literal_type.h
+++ b/third_party/libcxx/__type_traits/is_literal_type.h
@@ -19,15 +19,15 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 is_literal_type
-    : public integral_constant<bool, __is_literal_type(_Tp)>
-    {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS
+_LIBCPP_DEPRECATED_IN_CXX17 is_literal_type : public integral_constant<bool, __is_literal_type(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 _LIBCPP_DEPRECATED_IN_CXX17 inline constexpr bool is_literal_type_v = __is_literal_type(_Tp);
-#endif // _LIBCPP_STD_VER >= 17
-#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
+#  endif // _LIBCPP_STD_VER >= 17
+#endif   // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_member_function_pointer.h b/third_party/libcxx/__type_traits/is_member_function_pointer.h
deleted file mode 100644
index 72f84bdaf..000000000
--- a/third_party/libcxx/__type_traits/is_member_function_pointer.h
+++ /dev/null
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H
-#define _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H
-
-#include <__config>
-#include <__type_traits/integral_constant.h>
-#include <__type_traits/is_function.h>
-#include <__type_traits/remove_cv.h>
-#include <cstddef>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp> struct __libcpp_is_member_pointer {
-  enum {
-    __is_member = false,
-    __is_func = false,
-    __is_obj = false
-  };
-};
-template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> {
-  enum {
-    __is_member = true,
-    __is_func = is_function<_Tp>::value,
-    __is_obj = !__is_func,
-  };
-};
-
-#if __has_builtin(__is_member_function_pointer)
-
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
-    : _BoolConstant<__is_member_function_pointer(_Tp)> { };
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Tp);
-#endif
-
-#else // __has_builtin(__is_member_function_pointer)
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
-    : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_func > {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value;
-#endif
-
-#endif // __has_builtin(__is_member_function_pointer)
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H
diff --git a/third_party/libcxx/__type_traits/is_member_object_pointer.h b/third_party/libcxx/__type_traits/is_member_object_pointer.h
deleted file mode 100644
index 603bc6668..000000000
--- a/third_party/libcxx/__type_traits/is_member_object_pointer.h
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_MEMBER_OBJECT_POINTER_H
-#define _LIBCPP___TYPE_TRAITS_IS_MEMBER_OBJECT_POINTER_H
-
-#include <__config>
-#include <__type_traits/remove_cv.h>
-#include <__type_traits/is_member_function_pointer.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if __has_builtin(__is_member_object_pointer)
-
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
-    : _BoolConstant<__is_member_object_pointer(_Tp)> { };
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Tp);
-#endif
-
-#else // __has_builtin(__is_member_object_pointer)
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
-    : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_obj >  {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value;
-#endif
-
-#endif // __has_builtin(__is_member_object_pointer)
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H
diff --git a/third_party/libcxx/__type_traits/is_member_pointer.h b/third_party/libcxx/__type_traits/is_member_pointer.h
index 5339fb050..cc125e318 100644
--- a/third_party/libcxx/__type_traits/is_member_pointer.h
+++ b/third_party/libcxx/__type_traits/is_member_pointer.h
@@ -11,7 +11,6 @@
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_member_function_pointer.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -19,27 +18,25 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__is_member_pointer)
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> {};
 
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> { };
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer : _BoolConstant<__is_member_object_pointer(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer : _BoolConstant<__is_member_function_pointer(_Tp)> {};
+
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp);
-#endif
 
-#else // __has_builtin(__is_member_pointer)
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer
- : public _BoolConstant< __libcpp_is_member_pointer<__remove_cv_t<_Tp> >::__is_member > {};
-
-#if _LIBCPP_STD_VER >= 17
 template <class _Tp>
-inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
-#endif
+inline constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Tp);
 
-#endif // __has_builtin(__is_member_pointer)
+template <class _Tp>
+inline constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Tp);
+#  endif
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_move_assignable.h b/third_party/libcxx/__type_traits/is_move_assignable.h
deleted file mode 100644
index 8c4c82084..000000000
--- a/third_party/libcxx/__type_traits/is_move_assignable.h
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H
-
-#include <__config>
-#include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/add_rvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_move_assignable
-    : public integral_constant<
-          bool,
-          __is_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H
diff --git a/third_party/libcxx/__type_traits/is_move_constructible.h b/third_party/libcxx/__type_traits/is_move_constructible.h
deleted file mode 100644
index d908e4986..000000000
--- a/third_party/libcxx/__type_traits/is_move_constructible.h
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H
-
-#include <__config>
-#include <__type_traits/add_rvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_move_constructible
-    : public integral_constant<bool, __is_constructible(_Tp, __add_rvalue_reference_t<_Tp>)>
-    {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_nothrow_assignable.h b/third_party/libcxx/__type_traits/is_nothrow_assignable.h
index 4d17b9fc9..7e00c741f 100644
--- a/third_party/libcxx/__type_traits/is_nothrow_assignable.h
+++ b/third_party/libcxx/__type_traits/is_nothrow_assignable.h
@@ -10,6 +10,8 @@
 #define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_ASSIGNABLE_H
 
 #include <__config>
+#include <__type_traits/add_lvalue_reference.h>
+#include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -19,14 +21,36 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Arg>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
-    : public integral_constant<bool, __is_nothrow_assignable(_Tp, _Arg)> {};
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable : public integral_constant<bool, __is_nothrow_assignable(_Tp, _Arg)> {
+};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp, class _Arg>
 inline constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_Tp, _Arg);
 #endif
 
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable
+    : public integral_constant<
+          bool,
+          __is_nothrow_assignable(__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<const _Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value;
+#endif
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable
+    : public integral_constant<bool,
+                               __is_nothrow_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {
+};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value;
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_ASSIGNABLE_H
diff --git a/third_party/libcxx/__type_traits/is_nothrow_constructible.h b/third_party/libcxx/__type_traits/is_nothrow_constructible.h
index a967bc879..58d2b2475 100644
--- a/third_party/libcxx/__type_traits/is_nothrow_constructible.h
+++ b/third_party/libcxx/__type_traits/is_nothrow_constructible.h
@@ -10,11 +10,9 @@
 #define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H
 
 #include <__config>
+#include <__type_traits/add_lvalue_reference.h>
+#include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_constructible.h>
-#include <__type_traits/is_reference.h>
-#include <__utility/declval.h>
-#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -22,57 +20,42 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__is_nothrow_constructible)
-
-template <
-    class _Tp, class... _Args>
+template < class _Tp, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
     : public integral_constant<bool, __is_nothrow_constructible(_Tp, _Args...)> {};
-#else
-
-template <bool, bool, class _Tp, class... _Args> struct __libcpp_is_nothrow_constructible;
-
-template <class _Tp, class... _Args>
-struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/false, _Tp, _Args...>
-    : public integral_constant<bool, noexcept(_Tp(std::declval<_Args>()...))>
-{
-};
-
-template <class _Tp>
-void __implicit_conversion_to(_Tp) noexcept { }
-
-template <class _Tp, class _Arg>
-struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/true, _Tp, _Arg>
-    : public integral_constant<bool, noexcept(_VSTD::__implicit_conversion_to<_Tp>(std::declval<_Arg>()))>
-{
-};
-
-template <class _Tp, bool _IsReference, class... _Args>
-struct __libcpp_is_nothrow_constructible</*is constructible*/false, _IsReference, _Tp, _Args...>
-    : public false_type
-{
-};
-
-template <class _Tp, class... _Args>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
-    : __libcpp_is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, is_reference<_Tp>::value, _Tp, _Args...>
-{
-};
-
-template <class _Tp, size_t _Ns>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible<_Tp[_Ns]>
-    : __libcpp_is_nothrow_constructible<is_constructible<_Tp>::value, is_reference<_Tp>::value, _Tp>
-{
-};
-
-#endif // __has_builtin(__is_nothrow_constructible)
-
 
 #if _LIBCPP_STD_VER >= 17
-template <class _Tp, class ..._Args>
+template <class _Tp, class... _Args>
 inline constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Tp, _Args...>::value;
 #endif
 
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
+    : public integral_constant< bool, __is_nothrow_constructible(_Tp, __add_lvalue_reference_t<const _Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value;
+#endif
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
+    : public integral_constant<bool, __is_nothrow_constructible(_Tp, __add_rvalue_reference_t<_Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value;
+#endif
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_default_constructible
+    : public integral_constant<bool, __is_nothrow_constructible(_Tp)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp);
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_nothrow_convertible.h b/third_party/libcxx/__type_traits/is_nothrow_convertible.h
index 64f75e1fd..bfc5a94cb 100644
--- a/third_party/libcxx/__type_traits/is_nothrow_convertible.h
+++ b/third_party/libcxx/__type_traits/is_nothrow_convertible.h
@@ -26,26 +26,35 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
+#  if __has_builtin(__is_nothrow_convertible)
+
+template <class _Tp, class _Up>
+struct is_nothrow_convertible : bool_constant<__is_nothrow_convertible(_Tp, _Up)> {};
+
+template <class _Tp, class _Up>
+inline constexpr bool is_nothrow_convertible_v = __is_nothrow_convertible(_Tp, _Up);
+
+#  else // __has_builtin(__is_nothrow_convertible)
+
 template <typename _Tp>
 void __test_noexcept(_Tp) noexcept;
 
-template<typename _Fm, typename _To>
-bool_constant<noexcept(_VSTD::__test_noexcept<_To>(std::declval<_Fm>()))>
-__is_nothrow_convertible_test();
+template <typename _Fm, typename _To>
+bool_constant<noexcept(std::__test_noexcept<_To>(std::declval<_Fm>()))> __is_nothrow_convertible_test();
 
 template <typename _Fm, typename _To>
-struct __is_nothrow_convertible_helper: decltype(__is_nothrow_convertible_test<_Fm, _To>())
-{ };
+struct __is_nothrow_convertible_helper : decltype(__is_nothrow_convertible_test<_Fm, _To>()) {};
 
 template <typename _Fm, typename _To>
-struct is_nothrow_convertible : _Or<
-    _And<is_void<_To>, is_void<_Fm>>,
-    _Lazy<_And, is_convertible<_Fm, _To>, __is_nothrow_convertible_helper<_Fm, _To>>
->::type { };
+struct is_nothrow_convertible
+    : _Or<_And<is_void<_To>, is_void<_Fm>>,
+          _Lazy<_And, is_convertible<_Fm, _To>, __is_nothrow_convertible_helper<_Fm, _To> > >::type {};
 
 template <typename _Fm, typename _To>
 inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<_Fm, _To>::value;
 
+#  endif // __has_builtin(__is_nothrow_convertible)
+
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/is_nothrow_copy_assignable.h b/third_party/libcxx/__type_traits/is_nothrow_copy_assignable.h
deleted file mode 100644
index d11ec1c01..000000000
--- a/third_party/libcxx/__type_traits/is_nothrow_copy_assignable.h
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H
-
-#include <__config>
-#include <__type_traits/add_const.h>
-#include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable
-    : public integral_constant<
-          bool,
-          __is_nothrow_assignable(
-              __add_lvalue_reference_t<_Tp>,
-              __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H
diff --git a/third_party/libcxx/__type_traits/is_nothrow_copy_constructible.h b/third_party/libcxx/__type_traits/is_nothrow_copy_constructible.h
deleted file mode 100644
index de4e27227..000000000
--- a/third_party/libcxx/__type_traits/is_nothrow_copy_constructible.h
+++ /dev/null
@@ -1,48 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H
-
-#include <__config>
-#include <__type_traits/add_const.h>
-#include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-#include <__type_traits/is_nothrow_constructible.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// TODO: remove this implementation once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is fixed
-#ifdef _LIBCPP_COMPILER_GCC
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
-    : public is_nothrow_constructible<_Tp,
-                  __add_lvalue_reference_t<typename add_const<_Tp>::type> > {};
-
-#else // _LIBCPP_COMPILER_GCC
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
-    : public integral_constant<
-          bool,
-          __is_nothrow_constructible(_Tp, typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {};
-
-#endif // _LIBCPP_COMPILER_GCC
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_nothrow_default_constructible.h b/third_party/libcxx/__type_traits/is_nothrow_default_constructible.h
deleted file mode 100644
index 446808f44..000000000
--- a/third_party/libcxx/__type_traits/is_nothrow_default_constructible.h
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_H
-
-#include <__config>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_default_constructible
-    : public integral_constant<bool, __is_nothrow_constructible(_Tp)>
-    {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp);
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_nothrow_destructible.h b/third_party/libcxx/__type_traits/is_nothrow_destructible.h
index e842465a3..c2d5ca872 100644
--- a/third_party/libcxx/__type_traits/is_nothrow_destructible.h
+++ b/third_party/libcxx/__type_traits/is_nothrow_destructible.h
@@ -12,9 +12,6 @@
 #include <__config>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_destructible.h>
-#include <__type_traits/is_reference.h>
-#include <__type_traits/is_scalar.h>
-#include <__type_traits/remove_all_extents.h>
 #include <__utility/declval.h>
 #include <cstddef>
 
@@ -24,60 +21,37 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if !defined(_LIBCPP_CXX03_LANG)
-
-template <bool, class _Tp> struct __libcpp_is_nothrow_destructible;
+#if __has_builtin(__is_nothrow_destructible)
 
 template <class _Tp>
-struct __libcpp_is_nothrow_destructible<false, _Tp>
-    : public false_type
-{
-};
-
-template <class _Tp>
-struct __libcpp_is_nothrow_destructible<true, _Tp>
-    : public integral_constant<bool, noexcept(std::declval<_Tp>().~_Tp()) >
-{
-};
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
-    : public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp>
-{
-};
-
-template <class _Tp, size_t _Ns>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[_Ns]>
-    : public is_nothrow_destructible<_Tp>
-{
-};
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&>
-    : public true_type
-{
-};
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&&>
-    : public true_type
-{
-};
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible : integral_constant<bool, __is_nothrow_destructible(_Tp)> {};
 
 #else
 
-template <class _Tp> struct __libcpp_nothrow_destructor
-    : public integral_constant<bool, is_scalar<_Tp>::value ||
-                                     is_reference<_Tp>::value> {};
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
-    : public __libcpp_nothrow_destructor<__remove_all_extents_t<_Tp> > {};
+template <bool, class _Tp>
+struct __libcpp_is_nothrow_destructible;
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[]>
-    : public false_type {};
+struct __libcpp_is_nothrow_destructible<false, _Tp> : public false_type {};
 
-#endif
+template <class _Tp>
+struct __libcpp_is_nothrow_destructible<true, _Tp>
+    : public integral_constant<bool, noexcept(std::declval<_Tp>().~_Tp()) > {};
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible
+    : public __libcpp_is_nothrow_destructible<is_destructible<_Tp>::value, _Tp> {};
+
+template <class _Tp, size_t _Ns>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp[_Ns]> : public is_nothrow_destructible<_Tp> {};
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&> : public true_type {};
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_destructible<_Tp&&> : public true_type {};
+
+#endif // __has_builtin(__is_nothrow_destructible)
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_nothrow_move_assignable.h b/third_party/libcxx/__type_traits/is_nothrow_move_assignable.h
deleted file mode 100644
index 7649a3fcd..000000000
--- a/third_party/libcxx/__type_traits/is_nothrow_move_assignable.h
+++ /dev/null
@@ -1,37 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H
-
-#include <__config>
-#include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/add_rvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable
-    : public integral_constant<
-          bool,
-          __is_nothrow_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {
-};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H
diff --git a/third_party/libcxx/__type_traits/is_nothrow_move_constructible.h b/third_party/libcxx/__type_traits/is_nothrow_move_constructible.h
deleted file mode 100644
index 21a22bbb8..000000000
--- a/third_party/libcxx/__type_traits/is_nothrow_move_constructible.h
+++ /dev/null
@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H
-
-#include <__config>
-#include <__type_traits/add_rvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-#include <__type_traits/is_nothrow_constructible.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// TODO: remove this implementation once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is fixed
-#ifndef _LIBCPP_COMPILER_GCC
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
-    : public integral_constant<bool, __is_nothrow_constructible(_Tp, __add_rvalue_reference_t<_Tp>)>
-    {};
-
-#else // _LIBCPP_COMPILER_GCC
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
-    : public is_nothrow_constructible<_Tp, __add_rvalue_reference_t<_Tp> >
-    {};
-
-#endif // _LIBCPP_COMPILER_GCC
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_null_pointer.h b/third_party/libcxx/__type_traits/is_null_pointer.h
index 3a94fce1b..9f5697e23 100644
--- a/third_party/libcxx/__type_traits/is_null_pointer.h
+++ b/third_party/libcxx/__type_traits/is_null_pointer.h
@@ -11,7 +11,6 @@
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/remove_cv.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -20,20 +19,17 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct __is_nullptr_t_impl       : public false_type {};
-template <>          struct __is_nullptr_t_impl<nullptr_t> : public true_type {};
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __is_nullptr_t
-    : public __is_nullptr_t_impl<__remove_cv_t<_Tp> > {};
+template <class _Tp>
+inline const bool __is_null_pointer_v = __is_same(__remove_cv(_Tp), nullptr_t);
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_null_pointer
-    : public __is_nullptr_t_impl<__remove_cv_t<_Tp> > {};
-
-#if _LIBCPP_STD_VER >= 17
 template <class _Tp>
-inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
-#endif
+struct _LIBCPP_TEMPLATE_VIS is_null_pointer : integral_constant<bool, __is_null_pointer_v<_Tp>> {};
+
+#  if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_null_pointer_v = __is_null_pointer_v<_Tp>;
+#  endif
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/is_object.h b/third_party/libcxx/__type_traits/is_object.h
index 4d038c3e6..ec0450840 100644
--- a/third_party/libcxx/__type_traits/is_object.h
+++ b/third_party/libcxx/__type_traits/is_object.h
@@ -11,10 +11,6 @@
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_array.h>
-#include <__type_traits/is_class.h>
-#include <__type_traits/is_scalar.h>
-#include <__type_traits/is_union.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -22,31 +18,14 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__is_object)
-
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_object : _BoolConstant<__is_object(_Tp)> { };
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_object : _BoolConstant<__is_object(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_object_v = __is_object(_Tp);
 #endif
 
-#else // __has_builtin(__is_object)
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_object
-    : public integral_constant<bool, is_scalar<_Tp>::value ||
-                                     is_array<_Tp>::value  ||
-                                     is_union<_Tp>::value  ||
-                                     is_class<_Tp>::value  > {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_object_v = is_object<_Tp>::value;
-#endif
-
-#endif // __has_builtin(__is_object)
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_OBJECT_H
diff --git a/third_party/libcxx/__type_traits/is_pod.h b/third_party/libcxx/__type_traits/is_pod.h
index 851cbd165..5888fbf45 100644
--- a/third_party/libcxx/__type_traits/is_pod.h
+++ b/third_party/libcxx/__type_traits/is_pod.h
@@ -18,8 +18,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod
-    : public integral_constant<bool, __is_pod(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_pod : public integral_constant<bool, __is_pod(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_pointer.h b/third_party/libcxx/__type_traits/is_pointer.h
index 51c628f45..38eb7996c 100644
--- a/third_party/libcxx/__type_traits/is_pointer.h
+++ b/third_party/libcxx/__type_traits/is_pointer.h
@@ -21,34 +21,42 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_pointer)
 
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_pointer : _BoolConstant<__is_pointer(_Tp)> { };
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_pointer : _BoolConstant<__is_pointer(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_pointer_v = __is_pointer(_Tp);
-#endif
+#  endif
 
 #else // __has_builtin(__is_pointer)
 
-template <class _Tp> struct __libcpp_is_pointer       : public false_type {};
-template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};
+template <class _Tp>
+struct __libcpp_is_pointer : public false_type {};
+template <class _Tp>
+struct __libcpp_is_pointer<_Tp*> : public true_type {};
 
-template <class _Tp> struct __libcpp_remove_objc_qualifiers { typedef _Tp type; };
-#if defined(_LIBCPP_HAS_OBJC_ARC)
+template <class _Tp>
+struct __libcpp_remove_objc_qualifiers {
+  typedef _Tp type;
+};
+#  if defined(_LIBCPP_HAS_OBJC_ARC)
+// clang-format off
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; };
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; };
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; };
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; };
-#endif
+// clang-format on
+#  endif
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_pointer
     : public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<__remove_cv_t<_Tp> >::type> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_pointer)
 
diff --git a/third_party/libcxx/__type_traits/is_polymorphic.h b/third_party/libcxx/__type_traits/is_polymorphic.h
index 21b3cdcdc..d122e1c87 100644
--- a/third_party/libcxx/__type_traits/is_polymorphic.h
+++ b/third_party/libcxx/__type_traits/is_polymorphic.h
@@ -19,8 +19,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_polymorphic
-    : public integral_constant<bool, __is_polymorphic(_Tp)> {};
+struct _LIBCPP_TEMPLATE_VIS is_polymorphic : public integral_constant<bool, __is_polymorphic(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_primary_template.h b/third_party/libcxx/__type_traits/is_primary_template.h
index a9bebcf7e..f308dfadc 100644
--- a/third_party/libcxx/__type_traits/is_primary_template.h
+++ b/third_party/libcxx/__type_traits/is_primary_template.h
@@ -21,13 +21,10 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-using __test_for_primary_template = __enable_if_t<
-    _IsSame<_Tp, typename _Tp::__primary_template>::value
-  >;
+using __test_for_primary_template = __enable_if_t<_IsSame<_Tp, typename _Tp::__primary_template>::value>;
+
 template <class _Tp>
-using __is_primary_template = _IsValidExpansion<
-    __test_for_primary_template, _Tp
-  >;
+using __is_primary_template = _IsValidExpansion<__test_for_primary_template, _Tp>;
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_reference.h b/third_party/libcxx/__type_traits/is_reference.h
index 3334c60cc..cc157a438 100644
--- a/third_party/libcxx/__type_traits/is_reference.h
+++ b/third_party/libcxx/__type_traits/is_reference.h
@@ -18,52 +18,50 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__is_lvalue_reference) && \
-    __has_builtin(__is_rvalue_reference) && \
-    __has_builtin(__is_reference)
-
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> { };
-
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> { };
-
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_reference : _BoolConstant<__is_reference(_Tp)> { };
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_reference : _BoolConstant<__is_reference(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_reference_v = __is_reference(_Tp);
+#endif
+
+#if __has_builtin(__is_lvalue_reference) && __has_builtin(__is_rvalue_reference)
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> {};
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> {};
+
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_lvalue_reference_v = __is_lvalue_reference(_Tp);
 template <class _Tp>
 inline constexpr bool is_rvalue_reference_v = __is_rvalue_reference(_Tp);
-#endif
+#  endif
 
-#else // __has_builtin(__is_lvalue_reference) && etc...
+#else // __has_builtin(__is_lvalue_reference)
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference       : public false_type {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {};
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference        : public false_type {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference<_Tp&&> : public true_type {};
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference        : public false_type {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&>  : public true_type {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&&> : public true_type {};
-
-#if _LIBCPP_STD_VER >= 17
 template <class _Tp>
-inline constexpr bool is_reference_v = is_reference<_Tp>::value;
+struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference : public false_type {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {};
 
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference : public false_type {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference<_Tp&&> : public true_type {};
+
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value;
 
 template <class _Tp>
 inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value;
-#endif
+#  endif
 
-#endif // __has_builtin(__is_lvalue_reference) && etc...
+#endif // __has_builtin(__is_lvalue_reference)
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_reference_wrapper.h b/third_party/libcxx/__type_traits/is_reference_wrapper.h
index d187eec1e..310a91004 100644
--- a/third_party/libcxx/__type_traits/is_reference_wrapper.h
+++ b/third_party/libcxx/__type_traits/is_reference_wrapper.h
@@ -10,6 +10,7 @@
 #define _LIBCPP___TYPE_TRAITS_IS_REFERENCE_WRAPPER_H
 
 #include <__config>
+#include <__fwd/functional.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/remove_cv.h>
 
@@ -19,12 +20,12 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS reference_wrapper;
-
-template <class _Tp> struct __is_reference_wrapper_impl : public false_type {};
-template <class _Tp> struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {};
-template <class _Tp> struct __is_reference_wrapper
-    : public __is_reference_wrapper_impl<__remove_cv_t<_Tp> > {};
+template <class _Tp>
+struct __is_reference_wrapper_impl : public false_type {};
+template <class _Tp>
+struct __is_reference_wrapper_impl<reference_wrapper<_Tp> > : public true_type {};
+template <class _Tp>
+struct __is_reference_wrapper : public __is_reference_wrapper_impl<__remove_cv_t<_Tp> > {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_same.h b/third_party/libcxx/__type_traits/is_same.h
index c598f0d40..9561b7b5d 100644
--- a/third_party/libcxx/__type_traits/is_same.h
+++ b/third_party/libcxx/__type_traits/is_same.h
@@ -19,7 +19,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Up>
-struct _LIBCPP_TEMPLATE_VIS is_same : _BoolConstant<__is_same(_Tp, _Up)> { };
+struct _LIBCPP_TEMPLATE_VIS is_same : _BoolConstant<__is_same(_Tp, _Up)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp, class _Up>
diff --git a/third_party/libcxx/__type_traits/is_scalar.h b/third_party/libcxx/__type_traits/is_scalar.h
index 9892ae089..455200de4 100644
--- a/third_party/libcxx/__type_traits/is_scalar.h
+++ b/third_party/libcxx/__type_traits/is_scalar.h
@@ -25,35 +25,42 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_scalar)
 
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_scalar : _BoolConstant<__is_scalar(_Tp)> { };
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_scalar : _BoolConstant<__is_scalar(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_scalar_v = __is_scalar(_Tp);
-#endif
+#  endif
 
 #else // __has_builtin(__is_scalar)
 
-template <class _Tp> struct __is_block : false_type {};
-#if defined(_LIBCPP_HAS_EXTENSION_BLOCKS)
-template <class _Rp, class ..._Args> struct __is_block<_Rp (^)(_Args...)> : true_type {};
-#endif
+template <class _Tp>
+struct __is_block : false_type {};
+#  if defined(_LIBCPP_HAS_EXTENSION_BLOCKS)
+template <class _Rp, class... _Args>
+struct __is_block<_Rp (^)(_Args...)> : true_type {};
+#  endif
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_scalar
-    : public integral_constant<bool, is_arithmetic<_Tp>::value     ||
-                                     is_member_pointer<_Tp>::value ||
-                                     is_pointer<_Tp>::value        ||
-                                     __is_nullptr_t<_Tp>::value    ||
-                                     __is_block<_Tp>::value        ||
-                                     is_enum<_Tp>::value           > {};
+// clang-format off
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_scalar
+    : public integral_constant<
+          bool, is_arithmetic<_Tp>::value ||
+                is_member_pointer<_Tp>::value ||
+                is_pointer<_Tp>::value ||
+                __is_null_pointer_v<_Tp> ||
+                __is_block<_Tp>::value ||
+                is_enum<_Tp>::value> {};
+// clang-format on
 
-template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {};
+template <>
+struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_scalar)
 
diff --git a/third_party/libcxx/__type_traits/is_scoped_enum.h b/third_party/libcxx/__type_traits/is_scoped_enum.h
deleted file mode 100644
index 3f0fd589a..000000000
--- a/third_party/libcxx/__type_traits/is_scoped_enum.h
+++ /dev/null
@@ -1,42 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_SCOPED_ENUM_H
-#define _LIBCPP___TYPE_TRAITS_IS_SCOPED_ENUM_H
-
-#include <__config>
-#include <__type_traits/integral_constant.h>
-#include <__type_traits/is_convertible.h>
-#include <__type_traits/is_enum.h>
-#include <__type_traits/underlying_type.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if _LIBCPP_STD_VER >= 23
-template <class _Tp, bool = is_enum_v<_Tp> >
-struct __is_scoped_enum_helper : false_type {};
-
-template <class _Tp>
-struct __is_scoped_enum_helper<_Tp, true>
-    : public bool_constant<!is_convertible_v<_Tp, underlying_type_t<_Tp> > > {};
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_scoped_enum
-    : public __is_scoped_enum_helper<_Tp> {};
-
-template <class _Tp>
-inline constexpr bool is_scoped_enum_v = is_scoped_enum<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_SCOPED_ENUM_H
diff --git a/third_party/libcxx/__type_traits/is_signed.h b/third_party/libcxx/__type_traits/is_signed.h
index ebd3873d5..fd6f93e18 100644
--- a/third_party/libcxx/__type_traits/is_signed.h
+++ b/third_party/libcxx/__type_traits/is_signed.h
@@ -22,13 +22,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_signed)
 
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_signed : _BoolConstant<__is_signed(_Tp)> { };
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_signed : _BoolConstant<__is_signed(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_signed_v = __is_signed(_Tp);
-#endif
+#  endif
 
 #else // __has_builtin(__is_signed)
 
@@ -36,19 +36,21 @@ template <class _Tp, bool = is_integral<_Tp>::value>
 struct __libcpp_is_signed_impl : public _BoolConstant<(_Tp(-1) < _Tp(0))> {};
 
 template <class _Tp>
-struct __libcpp_is_signed_impl<_Tp, false> : public true_type {};  // floating point
+struct __libcpp_is_signed_impl<_Tp, false> : public true_type {}; // floating point
 
 template <class _Tp, bool = is_arithmetic<_Tp>::value>
 struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {};
 
-template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {};
+template <class _Tp>
+struct __libcpp_is_signed<_Tp, false> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_signed : public __libcpp_is_signed<_Tp> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_signed : public __libcpp_is_signed<_Tp> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_signed_v = is_signed<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_signed)
 
diff --git a/third_party/libcxx/__type_traits/is_signed_integer.h b/third_party/libcxx/__type_traits/is_signed_integer.h
index 95aa11bfa..467548d0a 100644
--- a/third_party/libcxx/__type_traits/is_signed_integer.h
+++ b/third_party/libcxx/__type_traits/is_signed_integer.h
@@ -18,15 +18,17 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct __libcpp_is_signed_integer : public false_type {};
-template <> struct __libcpp_is_signed_integer<signed char>      : public true_type {};
-template <> struct __libcpp_is_signed_integer<signed short>     : public true_type {};
-template <> struct __libcpp_is_signed_integer<signed int>       : public true_type {};
-template <> struct __libcpp_is_signed_integer<signed long>      : public true_type {};
-template <> struct __libcpp_is_signed_integer<signed long long> : public true_type {};
+// clang-format off
+template <class _Tp> struct __libcpp_is_signed_integer                   : public false_type {};
+template <>          struct __libcpp_is_signed_integer<signed char>      : public true_type {};
+template <>          struct __libcpp_is_signed_integer<signed short>     : public true_type {};
+template <>          struct __libcpp_is_signed_integer<signed int>       : public true_type {};
+template <>          struct __libcpp_is_signed_integer<signed long>      : public true_type {};
+template <>          struct __libcpp_is_signed_integer<signed long long> : public true_type {};
 #ifndef _LIBCPP_HAS_NO_INT128
-template <> struct __libcpp_is_signed_integer<__int128_t>       : public true_type {};
+template <>          struct __libcpp_is_signed_integer<__int128_t>       : public true_type {};
 #endif
+// clang-format on
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_standard_layout.h b/third_party/libcxx/__type_traits/is_standard_layout.h
index aae533b45..76484f3e2 100644
--- a/third_party/libcxx/__type_traits/is_standard_layout.h
+++ b/third_party/libcxx/__type_traits/is_standard_layout.h
@@ -18,9 +18,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_standard_layout
-    : public integral_constant<bool, __is_standard_layout(_Tp)>
-    {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_standard_layout : public integral_constant<bool, __is_standard_layout(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_swappable.h b/third_party/libcxx/__type_traits/is_swappable.h
index 5a78f4708..0b817e650 100644
--- a/third_party/libcxx/__type_traits/is_swappable.h
+++ b/third_party/libcxx/__type_traits/is_swappable.h
@@ -11,16 +11,12 @@
 
 #include <__config>
 #include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/conditional.h>
 #include <__type_traits/enable_if.h>
-#include <__type_traits/is_move_assignable.h>
-#include <__type_traits/is_move_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
-#include <__type_traits/is_referenceable.h>
-#include <__type_traits/is_same.h>
-#include <__type_traits/is_void.h>
-#include <__type_traits/nat.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <cstddef>
 
@@ -30,133 +26,76 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct __is_swappable;
-template <class _Tp> struct __is_nothrow_swappable;
+template <class _Tp, class _Up, class = void>
+inline const bool __is_swappable_with_v = false;
 
+template <class _Tp>
+inline const bool __is_swappable_v = __is_swappable_with_v<_Tp&, _Tp&>;
+
+template <class _Tp, class _Up, bool = __is_swappable_with_v<_Tp, _Up> >
+inline const bool __is_nothrow_swappable_with_v = false;
+
+template <class _Tp>
+inline const bool __is_nothrow_swappable_v = __is_nothrow_swappable_with_v<_Tp&, _Tp&>;
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp>
-using __swap_result_t = typename enable_if<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>::type;
+using __swap_result_t = __enable_if_t<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>;
 #else
 template <class>
 using __swap_result_t = void;
 #endif
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX20 __swap_result_t<_Tp>
-swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
-                                    is_nothrow_move_assignable<_Tp>::value);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __swap_result_t<_Tp> swap(_Tp& __x, _Tp& __y)
+    _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value&& is_nothrow_move_assignable<_Tp>::value);
 
-template<class _Tp, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if<
-    __is_swappable<_Tp>::value
->::type
-swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value);
+template <class _Tp, size_t _Np, __enable_if_t<__is_swappable_v<_Tp>, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable_v<_Tp>);
 
-namespace __detail
-{
 // ALL generic swap overloads MUST already have a declaration available at this point.
 
-template <class _Tp, class _Up = _Tp,
-          bool _NotVoid = !is_void<_Tp>::value && !is_void<_Up>::value>
-struct __swappable_with
-{
-    template <class _LHS, class _RHS>
-    static decltype(swap(std::declval<_LHS>(), std::declval<_RHS>()))
-    __test_swap(int);
-    template <class, class>
-    static __nat __test_swap(long);
-
-    // Extra parens are needed for the C++03 definition of decltype.
-    typedef decltype((__test_swap<_Tp, _Up>(0))) __swap1;
-    typedef decltype((__test_swap<_Up, _Tp>(0))) __swap2;
-
-    static const bool value = _IsNotSame<__swap1, __nat>::value
-                           && _IsNotSame<__swap2, __nat>::value;
-};
-
 template <class _Tp, class _Up>
-struct __swappable_with<_Tp, _Up,  false> : false_type {};
+inline const bool __is_swappable_with_v<_Tp,
+                                        _Up,
+                                        __void_t<decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
+                                                 decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> > = true;
 
-template <class _Tp, class _Up = _Tp, bool _Swappable = __swappable_with<_Tp, _Up>::value>
-struct __nothrow_swappable_with {
-  static const bool value =
-#ifndef _LIBCPP_HAS_NO_NOEXCEPT
-      noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
-  &&  noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()));
-#else
-      false;
+#ifndef _LIBCPP_CXX03_LANG // C++03 doesn't have noexcept, so things are never nothrow swappable
+template <class _Tp, class _Up>
+inline const bool __is_nothrow_swappable_with_v<_Tp, _Up, true> =
+    noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) &&
+    noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()));
 #endif
-};
-
-template <class _Tp, class _Up>
-struct __nothrow_swappable_with<_Tp, _Up, false> : false_type {};
-
-} // namespace __detail
-
-template <class _Tp>
-struct __is_swappable
-    : public integral_constant<bool, __detail::__swappable_with<_Tp&>::value>
-{
-};
-
-template <class _Tp>
-struct __is_nothrow_swappable
-    : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp&>::value>
-{
-};
 
 #if _LIBCPP_STD_VER >= 17
 
 template <class _Tp, class _Up>
-struct _LIBCPP_TEMPLATE_VIS is_swappable_with
-    : public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value>
-{
-};
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_swappable
-    : public __conditional_t<
-        __libcpp_is_referenceable<_Tp>::value,
-        is_swappable_with<
-            __add_lvalue_reference_t<_Tp>,
-            __add_lvalue_reference_t<_Tp> >,
-        false_type
-    >
-{
-};
+inline constexpr bool is_swappable_with_v = __is_swappable_with_v<_Tp, _Up>;
 
 template <class _Tp, class _Up>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable_with
-    : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value>
-{
-};
+struct _LIBCPP_TEMPLATE_VIS is_swappable_with : bool_constant<is_swappable_with_v<_Tp, _Up>> {};
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable
-    : public __conditional_t<
-        __libcpp_is_referenceable<_Tp>::value,
-        is_nothrow_swappable_with<
-            __add_lvalue_reference_t<_Tp>,
-            __add_lvalue_reference_t<_Tp> >,
-        false_type
-    >
-{
-};
+inline constexpr bool is_swappable_v =
+    is_swappable_with_v<__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<_Tp>>;
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_swappable : bool_constant<is_swappable_v<_Tp>> {};
 
 template <class _Tp, class _Up>
-inline constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value;
-
-template <class _Tp>
-inline constexpr bool is_swappable_v = is_swappable<_Tp>::value;
+inline constexpr bool is_nothrow_swappable_with_v = __is_nothrow_swappable_with_v<_Tp, _Up>;
 
 template <class _Tp, class _Up>
-inline constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<_Tp, _Up>::value;
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable_with : bool_constant<is_nothrow_swappable_with_v<_Tp, _Up>> {};
 
 template <class _Tp>
-inline constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value;
+inline constexpr bool is_nothrow_swappable_v =
+    is_nothrow_swappable_with_v<__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<_Tp>>;
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable : bool_constant<is_nothrow_swappable_v<_Tp>> {};
 
 #endif // _LIBCPP_STD_VER >= 17
 
diff --git a/third_party/libcxx/__type_traits/is_trivial.h b/third_party/libcxx/__type_traits/is_trivial.h
index f43904891..0007c7446 100644
--- a/third_party/libcxx/__type_traits/is_trivial.h
+++ b/third_party/libcxx/__type_traits/is_trivial.h
@@ -18,9 +18,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivial
-    : public integral_constant<bool, __is_trivial(_Tp)>
-    {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivial : public integral_constant<bool, __is_trivial(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_trivially_assignable.h b/third_party/libcxx/__type_traits/is_trivially_assignable.h
index c16d17732..201333b0f 100644
--- a/third_party/libcxx/__type_traits/is_trivially_assignable.h
+++ b/third_party/libcxx/__type_traits/is_trivially_assignable.h
@@ -10,6 +10,9 @@
 #define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_ASSIGNABLE_H
 
 #include <__config>
+#include <__type_traits/add_const.h>
+#include <__type_traits/add_lvalue_reference.h>
+#include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -19,15 +22,35 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Arg>
-struct is_trivially_assignable
-    : integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)>
-{ };
+struct is_trivially_assignable : integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp, class _Arg>
 inline constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_Tp, _Arg);
 #endif
 
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable
+    : public integral_constant<
+          bool,
+          __is_trivially_assignable(__add_lvalue_reference_t<_Tp>, __add_lvalue_reference_t<const _Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value;
+#endif
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable
+    : public integral_constant<
+          bool,
+          __is_trivially_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value;
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_ASSIGNABLE_H
diff --git a/third_party/libcxx/__type_traits/is_trivially_constructible.h b/third_party/libcxx/__type_traits/is_trivially_constructible.h
index a71a49bae..3a77e9fe1 100644
--- a/third_party/libcxx/__type_traits/is_trivially_constructible.h
+++ b/third_party/libcxx/__type_traits/is_trivially_constructible.h
@@ -10,6 +10,8 @@
 #define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_CONSTRUCTIBLE_H
 
 #include <__config>
+#include <__type_traits/add_lvalue_reference.h>
+#include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -20,15 +22,40 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible
-    : integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)>
-{
-};
+    : integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp, class... _Args>
 inline constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Tp, _Args...);
 #endif
 
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_constructible
+    : public integral_constant<bool, __is_trivially_constructible(_Tp, __add_lvalue_reference_t<const _Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value;
+#endif
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible
+    : public integral_constant<bool, __is_trivially_constructible(_Tp, __add_rvalue_reference_t<_Tp>)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value;
+#endif
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_default_constructible
+    : public integral_constant<bool, __is_trivially_constructible(_Tp)> {};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+inline constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Tp);
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_trivially_copy_assignable.h b/third_party/libcxx/__type_traits/is_trivially_copy_assignable.h
deleted file mode 100644
index b38ab7ef4..000000000
--- a/third_party/libcxx/__type_traits/is_trivially_copy_assignable.h
+++ /dev/null
@@ -1,38 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H
-
-#include <__config>
-#include <__type_traits/add_const.h>
-#include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable
-    : public integral_constant<
-          bool,
-          __is_trivially_assignable(
-              __add_lvalue_reference_t<_Tp>,
-              __add_lvalue_reference_t<typename add_const<_Tp>::type>)> {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H
diff --git a/third_party/libcxx/__type_traits/is_trivially_copy_constructible.h b/third_party/libcxx/__type_traits/is_trivially_copy_constructible.h
deleted file mode 100644
index c6c96a051..000000000
--- a/third_party/libcxx/__type_traits/is_trivially_copy_constructible.h
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE_H
-
-#include <__config>
-#include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_constructible
-    : public integral_constant<bool, __is_trivially_constructible(_Tp, __add_lvalue_reference_t<const _Tp>)>
-    {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_trivially_copyable.h b/third_party/libcxx/__type_traits/is_trivially_copyable.h
index a725a0beb..e92af126e 100644
--- a/third_party/libcxx/__type_traits/is_trivially_copyable.h
+++ b/third_party/libcxx/__type_traits/is_trivially_copyable.h
@@ -19,9 +19,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copyable
-    : public integral_constant<bool, __is_trivially_copyable(_Tp)>
-    {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_copyable : public integral_constant<bool, __is_trivially_copyable(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_trivially_default_constructible.h b/third_party/libcxx/__type_traits/is_trivially_default_constructible.h
deleted file mode 100644
index 2b64a69a7..000000000
--- a/third_party/libcxx/__type_traits/is_trivially_default_constructible.h
+++ /dev/null
@@ -1,32 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_H
-
-#include <__config>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_default_constructible
-    : public integral_constant<bool, __is_trivially_constructible(_Tp)>
-    {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Tp);
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_trivially_destructible.h b/third_party/libcxx/__type_traits/is_trivially_destructible.h
index e718af015..5f9652f2a 100644
--- a/third_party/libcxx/__type_traits/is_trivially_destructible.h
+++ b/third_party/libcxx/__type_traits/is_trivially_destructible.h
@@ -21,17 +21,19 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_trivially_destructible)
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
     : public integral_constant<bool, __is_trivially_destructible(_Tp)> {};
 
 #elif __has_builtin(__has_trivial_destructor)
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
-    : public integral_constant<bool, is_destructible<_Tp>::value && __has_trivial_destructor(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
+    : public integral_constant<bool, is_destructible<_Tp>::value&& __has_trivial_destructor(_Tp)> {};
 
 #else
 
-#error is_trivially_destructible is not implemented
+#  error is_trivially_destructible is not implemented
 
 #endif // __has_builtin(__is_trivially_destructible)
 
diff --git a/third_party/libcxx/__type_traits/is_trivially_move_assignable.h b/third_party/libcxx/__type_traits/is_trivially_move_assignable.h
deleted file mode 100644
index daf890b26..000000000
--- a/third_party/libcxx/__type_traits/is_trivially_move_assignable.h
+++ /dev/null
@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H
-
-#include <__config>
-#include <__type_traits/add_lvalue_reference.h>
-#include <__type_traits/add_rvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable
-    : public integral_constant<
-          bool,
-          __is_trivially_assignable(__add_lvalue_reference_t<_Tp>, __add_rvalue_reference_t<_Tp>)> {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H
diff --git a/third_party/libcxx/__type_traits/is_trivially_move_constructible.h b/third_party/libcxx/__type_traits/is_trivially_move_constructible.h
deleted file mode 100644
index 71e6f898f..000000000
--- a/third_party/libcxx/__type_traits/is_trivially_move_constructible.h
+++ /dev/null
@@ -1,33 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE_H
-#define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE_H
-
-#include <__config>
-#include <__type_traits/add_rvalue_reference.h>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible
-    : public integral_constant<bool, __is_trivially_constructible(_Tp, __add_rvalue_reference_t<_Tp>)> {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE_H
diff --git a/third_party/libcxx/__type_traits/is_trivially_relocatable.h b/third_party/libcxx/__type_traits/is_trivially_relocatable.h
new file mode 100644
index 000000000..c0871731c
--- /dev/null
+++ b/third_party/libcxx/__type_traits/is_trivially_relocatable.h
@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_RELOCATABLE_H
+#define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_RELOCATABLE_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_trivially_copyable.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// A type is trivially relocatable if a move construct + destroy of the original object is equivalent to
+// `memcpy(dst, src, sizeof(T))`.
+
+#if __has_builtin(__is_trivially_relocatable)
+template <class _Tp, class = void>
+struct __libcpp_is_trivially_relocatable : integral_constant<bool, __is_trivially_relocatable(_Tp)> {};
+#else
+template <class _Tp, class = void>
+struct __libcpp_is_trivially_relocatable : is_trivially_copyable<_Tp> {};
+#endif
+
+template <class _Tp>
+struct __libcpp_is_trivially_relocatable<_Tp,
+                                         __enable_if_t<is_same<_Tp, typename _Tp::__trivially_relocatable>::value> >
+    : true_type {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_RELOCATABLE_H
diff --git a/third_party/libcxx/__type_traits/is_unbounded_array.h b/third_party/libcxx/__type_traits/is_unbounded_array.h
index 16bc62d17..d58bb09e1 100644
--- a/third_party/libcxx/__type_traits/is_unbounded_array.h
+++ b/third_party/libcxx/__type_traits/is_unbounded_array.h
@@ -18,17 +18,20 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class>     struct _LIBCPP_TEMPLATE_VIS __libcpp_is_unbounded_array        : false_type {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS __libcpp_is_unbounded_array<_Tp[]> : true_type {};
+template <class>
+struct _LIBCPP_TEMPLATE_VIS __libcpp_is_unbounded_array : false_type {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS __libcpp_is_unbounded_array<_Tp[]> : true_type {};
 
 #if _LIBCPP_STD_VER >= 20
 
-template <class>     struct _LIBCPP_TEMPLATE_VIS is_unbounded_array        : false_type {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unbounded_array<_Tp[]> : true_type {};
+template <class>
+struct _LIBCPP_TEMPLATE_VIS is_unbounded_array : false_type {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_unbounded_array<_Tp[]> : true_type {};
 
 template <class _Tp>
-inline constexpr
-bool is_unbounded_array_v  = is_unbounded_array<_Tp>::value;
+inline constexpr bool is_unbounded_array_v = is_unbounded_array<_Tp>::value;
 
 #endif
 
diff --git a/third_party/libcxx/__type_traits/is_union.h b/third_party/libcxx/__type_traits/is_union.h
index 6d2f47a11..1f009d993 100644
--- a/third_party/libcxx/__type_traits/is_union.h
+++ b/third_party/libcxx/__type_traits/is_union.h
@@ -18,8 +18,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union
-    : public integral_constant<bool, __is_union(_Tp)> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_union : public integral_constant<bool, __is_union(_Tp)> {};
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
diff --git a/third_party/libcxx/__type_traits/is_unsigned.h b/third_party/libcxx/__type_traits/is_unsigned.h
index d955106d5..48c5751ed 100644
--- a/third_party/libcxx/__type_traits/is_unsigned.h
+++ b/third_party/libcxx/__type_traits/is_unsigned.h
@@ -22,13 +22,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_unsigned)
 
-template<class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_unsigned : _BoolConstant<__is_unsigned(_Tp)> { };
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_unsigned : _BoolConstant<__is_unsigned(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_unsigned_v = __is_unsigned(_Tp);
-#endif
+#  endif
 
 #else // __has_builtin(__is_unsigned)
 
@@ -36,19 +36,21 @@ template <class _Tp, bool = is_integral<_Tp>::value>
 struct __libcpp_is_unsigned_impl : public _BoolConstant<(_Tp(0) < _Tp(-1))> {};
 
 template <class _Tp>
-struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {};  // floating point
+struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {}; // floating point
 
 template <class _Tp, bool = is_arithmetic<_Tp>::value>
 struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {};
 
-template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {};
+template <class _Tp>
+struct __libcpp_is_unsigned<_Tp, false> : public false_type {};
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unsigned : public __libcpp_is_unsigned<_Tp> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_unsigned : public __libcpp_is_unsigned<_Tp> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_unsigned)
 
diff --git a/third_party/libcxx/__type_traits/is_unsigned_integer.h b/third_party/libcxx/__type_traits/is_unsigned_integer.h
index 54b29acd9..265894b32 100644
--- a/third_party/libcxx/__type_traits/is_unsigned_integer.h
+++ b/third_party/libcxx/__type_traits/is_unsigned_integer.h
@@ -18,15 +18,17 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct __libcpp_is_unsigned_integer : public false_type {};
-template <> struct __libcpp_is_unsigned_integer<unsigned char>      : public true_type {};
-template <> struct __libcpp_is_unsigned_integer<unsigned short>     : public true_type {};
-template <> struct __libcpp_is_unsigned_integer<unsigned int>       : public true_type {};
-template <> struct __libcpp_is_unsigned_integer<unsigned long>      : public true_type {};
-template <> struct __libcpp_is_unsigned_integer<unsigned long long> : public true_type {};
+// clang-format off
+template <class _Tp> struct __libcpp_is_unsigned_integer                     : public false_type {};
+template <>          struct __libcpp_is_unsigned_integer<unsigned char>      : public true_type {};
+template <>          struct __libcpp_is_unsigned_integer<unsigned short>     : public true_type {};
+template <>          struct __libcpp_is_unsigned_integer<unsigned int>       : public true_type {};
+template <>          struct __libcpp_is_unsigned_integer<unsigned long>      : public true_type {};
+template <>          struct __libcpp_is_unsigned_integer<unsigned long long> : public true_type {};
 #ifndef _LIBCPP_HAS_NO_INT128
-template <> struct __libcpp_is_unsigned_integer<__uint128_t>        : public true_type {};
+template <>          struct __libcpp_is_unsigned_integer<__uint128_t>        : public true_type {};
 #endif
+// clang-format on
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_valid_expansion.h b/third_party/libcxx/__type_traits/is_valid_expansion.h
index db7d7e5f1..346bc98b1 100644
--- a/third_party/libcxx/__type_traits/is_valid_expansion.h
+++ b/third_party/libcxx/__type_traits/is_valid_expansion.h
@@ -18,12 +18,12 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <template <class...> class _Templ, class ..._Args, class = _Templ<_Args...> >
+template <template <class...> class _Templ, class... _Args, class = _Templ<_Args...> >
 true_type __sfinae_test_impl(int);
-template <template <class...> class, class ...>
+template <template <class...> class, class...>
 false_type __sfinae_test_impl(...);
 
-template <template <class ...> class _Templ, class ..._Args>
+template <template <class...> class _Templ, class... _Args>
 using _IsValidExpansion _LIBCPP_NODEBUG = decltype(std::__sfinae_test_impl<_Templ, _Args...>(0));
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/is_void.h b/third_party/libcxx/__type_traits/is_void.h
index 7e8b8b641..46316b0d3 100644
--- a/third_party/libcxx/__type_traits/is_void.h
+++ b/third_party/libcxx/__type_traits/is_void.h
@@ -11,8 +11,6 @@
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_same.h>
-#include <__type_traits/remove_cv.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -20,27 +18,13 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__is_void)
-
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_void : _BoolConstant<__is_void(_Tp)> { };
+struct _LIBCPP_TEMPLATE_VIS is_void : _BoolConstant<__is_same(__remove_cv(_Tp), void)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
-inline constexpr bool is_void_v = __is_void(_Tp);
-#endif
-
-#else
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void
-    : public is_same<__remove_cv_t<_Tp>, void> {};
-
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr bool is_void_v = is_void<_Tp>::value;
-#endif
-
-#endif // __has_builtin(__is_void)
+inline constexpr bool is_void_v = __is_same(__remove_cv(_Tp), void);
+#  endif
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/is_volatile.h b/third_party/libcxx/__type_traits/is_volatile.h
index c020220e0..87960a819 100644
--- a/third_party/libcxx/__type_traits/is_volatile.h
+++ b/third_party/libcxx/__type_traits/is_volatile.h
@@ -21,22 +21,24 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if __has_builtin(__is_volatile)
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS is_volatile : _BoolConstant<__is_volatile(_Tp)> { };
+struct _LIBCPP_TEMPLATE_VIS is_volatile : _BoolConstant<__is_volatile(_Tp)> {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_volatile_v = __is_volatile(_Tp);
-#endif
+#  endif
 
 #else
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile               : public false_type {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_volatile : public false_type {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {};
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
-#endif
+#  endif
 
 #endif // __has_builtin(__is_volatile)
 
diff --git a/third_party/libcxx/__type_traits/lazy.h b/third_party/libcxx/__type_traits/lazy.h
index 6874b06f3..80826f1d6 100644
--- a/third_party/libcxx/__type_traits/lazy.h
+++ b/third_party/libcxx/__type_traits/lazy.h
@@ -17,7 +17,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <template <class...> class _Func, class ..._Args>
+template <template <class...> class _Func, class... _Args>
 struct _Lazy : _Func<_Args...> {};
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/make_32_64_or_128_bit.h b/third_party/libcxx/__type_traits/make_32_64_or_128_bit.h
index 30595712b..f7f2e8173 100644
--- a/third_party/libcxx/__type_traits/make_32_64_or_128_bit.h
+++ b/third_party/libcxx/__type_traits/make_32_64_or_128_bit.h
@@ -28,20 +28,21 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 /// The restriction is the same as the integral version of to_char.
 template <class _Tp>
 #if _LIBCPP_STD_VER >= 20
-  requires (is_signed_v<_Tp> || is_unsigned_v<_Tp> || is_same_v<_Tp, char>)
+  requires(is_signed_v<_Tp> || is_unsigned_v<_Tp> || is_same_v<_Tp, char>)
 #endif
+// clang-format off
 using __make_32_64_or_128_bit_t =
-  __copy_unsigned_t<_Tp,
-    __conditional_t<sizeof(_Tp) <= sizeof(int32_t),    int32_t,
-    __conditional_t<sizeof(_Tp) <= sizeof(int64_t),    int64_t,
+    __copy_unsigned_t<_Tp,
+        __conditional_t<sizeof(_Tp) <= sizeof(int32_t),    int32_t,
+        __conditional_t<sizeof(_Tp) <= sizeof(int64_t),    int64_t,
 #ifndef _LIBCPP_HAS_NO_INT128
-    __conditional_t<sizeof(_Tp) <= sizeof(__int128_t), __int128_t,
-    /* else */                                         void>
+        __conditional_t<sizeof(_Tp) <= sizeof(__int128_t), __int128_t,
+        /* else */                                         void>
 #else
-    /* else */                                         void
+        /* else */                                         void
 #endif
-    > >
-  >;
+    > > >;
+// clang-format on
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/make_const_lvalue_ref.h b/third_party/libcxx/__type_traits/make_const_lvalue_ref.h
index deea40d5e..469d4cb31 100644
--- a/third_party/libcxx/__type_traits/make_const_lvalue_ref.h
+++ b/third_party/libcxx/__type_traits/make_const_lvalue_ref.h
@@ -18,7 +18,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp>
+template <class _Tp>
 using __make_const_lvalue_ref = const __libcpp_remove_reference_t<_Tp>&;
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/make_signed.h b/third_party/libcxx/__type_traits/make_signed.h
index a8142a43c..d09d6ed4a 100644
--- a/third_party/libcxx/__type_traits/make_signed.h
+++ b/third_party/libcxx/__type_traits/make_signed.h
@@ -10,7 +10,7 @@
 #define _LIBCPP___TYPE_TRAITS_MAKE_SIGNED_H
 
 #include <__config>
-#include <__type_traits/apply_cv.h>
+#include <__type_traits/copy_cv.h>
 #include <__type_traits/is_enum.h>
 #include <__type_traits/is_integral.h>
 #include <__type_traits/nat.h>
@@ -29,30 +29,31 @@ template <class _Tp>
 using __make_signed_t = __make_signed(_Tp);
 
 #else
-typedef
-    __type_list<signed char,
-    __type_list<signed short,
-    __type_list<signed int,
-    __type_list<signed long,
-    __type_list<signed long long,
+// clang-format off
+typedef __type_list<signed char,
+        __type_list<signed short,
+        __type_list<signed int,
+        __type_list<signed long,
+        __type_list<signed long long,
 #  ifndef _LIBCPP_HAS_NO_INT128
-    __type_list<__int128_t,
+        __type_list<__int128_t,
 #  endif
-    __nat
+        __nat
 #  ifndef _LIBCPP_HAS_NO_INT128
-    >
+        >
 #  endif
-    > > > > > __signed_types;
+        > > > > > __signed_types;
+// clang-format on
 
 template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
-struct __make_signed {};
+struct __make_signed{};
 
 template <class _Tp>
-struct __make_signed<_Tp, true>
-{
-    typedef typename __find_first<__signed_types, sizeof(_Tp)>::type type;
+struct __make_signed<_Tp, true> {
+  typedef typename __find_first<__signed_types, sizeof(_Tp)>::type type;
 };
 
+// clang-format off
 template <> struct __make_signed<bool,               true> {};
 template <> struct __make_signed<  signed short,     true> {typedef short     type;};
 template <> struct __make_signed<unsigned short,     true> {typedef short     type;};
@@ -66,9 +67,10 @@ template <> struct __make_signed<unsigned long long, true> {typedef long long ty
 template <> struct __make_signed<__int128_t,         true> {typedef __int128_t type;};
 template <> struct __make_signed<__uint128_t,        true> {typedef __int128_t type;};
 #  endif
+// clang-format on
 
 template <class _Tp>
-using __make_signed_t = __apply_cv_t<_Tp, typename __make_signed<__remove_cv_t<_Tp> >::type>;
+using __make_signed_t = __copy_cv_t<_Tp, typename __make_signed<__remove_cv_t<_Tp> >::type>;
 
 #endif // __has_builtin(__make_signed)
 
@@ -78,7 +80,8 @@ struct make_signed {
 };
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using make_signed_t = __make_signed_t<_Tp>;
+template <class _Tp>
+using make_signed_t = __make_signed_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/make_unsigned.h b/third_party/libcxx/__type_traits/make_unsigned.h
index 0ee4347a7..282cd2d91 100644
--- a/third_party/libcxx/__type_traits/make_unsigned.h
+++ b/third_party/libcxx/__type_traits/make_unsigned.h
@@ -10,8 +10,8 @@
 #define _LIBCPP___TYPE_TRAITS_MAKE_UNSIGNED_H
 
 #include <__config>
-#include <__type_traits/apply_cv.h>
 #include <__type_traits/conditional.h>
+#include <__type_traits/copy_cv.h>
 #include <__type_traits/is_enum.h>
 #include <__type_traits/is_integral.h>
 #include <__type_traits/is_unsigned.h>
@@ -31,30 +31,31 @@ template <class _Tp>
 using __make_unsigned_t = __make_unsigned(_Tp);
 
 #else
-typedef
-    __type_list<unsigned char,
-    __type_list<unsigned short,
-    __type_list<unsigned int,
-    __type_list<unsigned long,
-    __type_list<unsigned long long,
+// clang-format off
+typedef __type_list<unsigned char,
+        __type_list<unsigned short,
+        __type_list<unsigned int,
+        __type_list<unsigned long,
+        __type_list<unsigned long long,
 #  ifndef _LIBCPP_HAS_NO_INT128
-    __type_list<__uint128_t,
+        __type_list<__uint128_t,
 #  endif
-    __nat
+        __nat
 #  ifndef _LIBCPP_HAS_NO_INT128
-    >
+        >
 #  endif
-    > > > > > __unsigned_types;
+        > > > > > __unsigned_types;
+// clang-format on
 
 template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
-struct __make_unsigned {};
+struct __make_unsigned{};
 
 template <class _Tp>
-struct __make_unsigned<_Tp, true>
-{
-    typedef typename __find_first<__unsigned_types, sizeof(_Tp)>::type type;
+struct __make_unsigned<_Tp, true> {
+  typedef typename __find_first<__unsigned_types, sizeof(_Tp)>::type type;
 };
 
+// clang-format off
 template <> struct __make_unsigned<bool,               true> {};
 template <> struct __make_unsigned<  signed short,     true> {typedef unsigned short     type;};
 template <> struct __make_unsigned<unsigned short,     true> {typedef unsigned short     type;};
@@ -68,9 +69,10 @@ template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned l
 template <> struct __make_unsigned<__int128_t,         true> {typedef __uint128_t        type;};
 template <> struct __make_unsigned<__uint128_t,        true> {typedef __uint128_t        type;};
 #  endif
+// clang-format on
 
 template <class _Tp>
-using __make_unsigned_t = __apply_cv_t<_Tp, typename __make_unsigned<__remove_cv_t<_Tp> >::type>;
+using __make_unsigned_t = __copy_cv_t<_Tp, typename __make_unsigned<__remove_cv_t<_Tp> >::type>;
 
 #endif // __has_builtin(__make_unsigned)
 
@@ -80,14 +82,14 @@ struct make_unsigned {
 };
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using make_unsigned_t = __make_unsigned_t<_Tp>;
+template <class _Tp>
+using make_unsigned_t = __make_unsigned_t<_Tp>;
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr
-__make_unsigned_t<_Tp> __to_unsigned_like(_Tp __x) noexcept {
-    return static_cast<__make_unsigned_t<_Tp> >(__x);
+_LIBCPP_HIDE_FROM_ABI constexpr __make_unsigned_t<_Tp> __to_unsigned_like(_Tp __x) noexcept {
+  return static_cast<__make_unsigned_t<_Tp> >(__x);
 }
 #endif
 
diff --git a/third_party/libcxx/__type_traits/maybe_const.h b/third_party/libcxx/__type_traits/maybe_const.h
index 8403f6aba..25fba58fb 100644
--- a/third_party/libcxx/__type_traits/maybe_const.h
+++ b/third_party/libcxx/__type_traits/maybe_const.h
@@ -18,7 +18,7 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<bool _Const, class _Tp>
+template <bool _Const, class _Tp>
 using __maybe_const = __conditional_t<_Const, const _Tp, _Tp>;
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/nat.h b/third_party/libcxx/__type_traits/nat.h
index 5216ef520..9f39b8068 100644
--- a/third_party/libcxx/__type_traits/nat.h
+++ b/third_party/libcxx/__type_traits/nat.h
@@ -17,13 +17,12 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct __nat
-{
+struct __nat {
 #ifndef _LIBCPP_CXX03_LANG
-    __nat() = delete;
-    __nat(const __nat&) = delete;
-    __nat& operator=(const __nat&) = delete;
-    ~__nat() = delete;
+  __nat()                        = delete;
+  __nat(const __nat&)            = delete;
+  __nat& operator=(const __nat&) = delete;
+  ~__nat()                       = delete;
 #endif
 };
 
diff --git a/third_party/libcxx/__type_traits/negation.h b/third_party/libcxx/__type_traits/negation.h
index 3a70ef140..a72e62d3f 100644
--- a/third_party/libcxx/__type_traits/negation.h
+++ b/third_party/libcxx/__type_traits/negation.h
@@ -24,7 +24,7 @@ struct _Not : _BoolConstant<!_Pred::value> {};
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 struct negation : _Not<_Tp> {};
-template<class _Tp>
+template <class _Tp>
 inline constexpr bool negation_v = !_Tp::value;
 #endif // _LIBCPP_STD_VER >= 17
 
diff --git a/third_party/libcxx/__type_traits/noexcept_move_assign_container.h b/third_party/libcxx/__type_traits/noexcept_move_assign_container.h
index 65384d05a..baaf36d99 100644
--- a/third_party/libcxx/__type_traits/noexcept_move_assign_container.h
+++ b/third_party/libcxx/__type_traits/noexcept_move_assign_container.h
@@ -12,7 +12,7 @@
 #include <__config>
 #include <__memory/allocator_traits.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_nothrow_assignable.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -20,15 +20,17 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <typename _Alloc, typename _Traits=allocator_traits<_Alloc> >
-struct __noexcept_move_assign_container : public integral_constant<bool,
-    _Traits::propagate_on_container_move_assignment::value
+template <typename _Alloc, typename _Traits = allocator_traits<_Alloc> >
+struct __noexcept_move_assign_container
+    : public integral_constant<bool,
+                               _Traits::propagate_on_container_move_assignment::value
 #if _LIBCPP_STD_VER >= 17
-        || _Traits::is_always_equal::value
+                                   || _Traits::is_always_equal::value
 #else
-        && is_nothrow_move_assignable<_Alloc>::value
+                                   && is_nothrow_move_assignable<_Alloc>::value
 #endif
-    > {};
+                               > {
+};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/predicate_traits.h b/third_party/libcxx/__type_traits/predicate_traits.h
deleted file mode 100644
index 872608e6a..000000000
--- a/third_party/libcxx/__type_traits/predicate_traits.h
+++ /dev/null
@@ -1,26 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___TYPE_TRAITS_PREDICATE_TRAITS
-#define _LIBCPP___TYPE_TRAITS_PREDICATE_TRAITS
-
-#include <__config>
-#include <__type_traits/integral_constant.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Pred, class _Lhs, class _Rhs>
-struct __is_trivial_equality_predicate : false_type {};
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP___TYPE_TRAITS_PREDICATE_TRAITS
diff --git a/third_party/libcxx/__type_traits/promote.h b/third_party/libcxx/__type_traits/promote.h
index e01e7781c..2b2a6843b 100644
--- a/third_party/libcxx/__type_traits/promote.h
+++ b/third_party/libcxx/__type_traits/promote.h
@@ -11,8 +11,12 @@
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_same.h>
-#include <__utility/declval.h>
+#include <__type_traits/is_arithmetic.h>
+
+#if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER == 1700
+#  include <__type_traits/is_same.h>
+#  include <__utility/declval.h>
+#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -20,79 +24,105 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp>
-struct __numeric_type
-{
-   static void __test(...);
-   static float __test(float);
-   static double __test(char);
-   static double __test(int);
-   static double __test(unsigned);
-   static double __test(long);
-   static double __test(unsigned long);
-   static double __test(long long);
-   static double __test(unsigned long long);
-#ifndef _LIBCPP_HAS_NO_INT128
-   static double __test(__int128_t);
-   static double __test(__uint128_t);
-#endif
-   static double __test(double);
-   static long double __test(long double);
+// TODO(LLVM-20): Remove this workaround
+#if !defined(_LIBCPP_CLANG_VER) || _LIBCPP_CLANG_VER != 1700
 
-   typedef decltype(__test(std::declval<_Tp>())) type;
-   static const bool value = _IsNotSame<type, void>::value;
+template <class... _Args>
+class __promote {
+  static_assert((is_arithmetic<_Args>::value && ...));
+
+  static float __test(float);
+  static double __test(char);
+  static double __test(int);
+  static double __test(unsigned);
+  static double __test(long);
+  static double __test(unsigned long);
+  static double __test(long long);
+  static double __test(unsigned long long);
+#  ifndef _LIBCPP_HAS_NO_INT128
+  static double __test(__int128_t);
+  static double __test(__uint128_t);
+#  endif
+  static double __test(double);
+  static long double __test(long double);
+
+public:
+  using type = decltype((__test(_Args()) + ...));
+};
+
+#else
+
+template <class _Tp>
+struct __numeric_type {
+  static void __test(...);
+  static float __test(float);
+  static double __test(char);
+  static double __test(int);
+  static double __test(unsigned);
+  static double __test(long);
+  static double __test(unsigned long);
+  static double __test(long long);
+  static double __test(unsigned long long);
+#  ifndef _LIBCPP_HAS_NO_INT128
+  static double __test(__int128_t);
+  static double __test(__uint128_t);
+#  endif
+  static double __test(double);
+  static long double __test(long double);
+
+  typedef decltype(__test(std::declval<_Tp>())) type;
+  static const bool value = _IsNotSame<type, void>::value;
 };
 
 template <>
-struct __numeric_type<void>
-{
-   static const bool value = true;
+struct __numeric_type<void> {
+  static const bool value = true;
 };
 
-template <class _A1, class _A2 = void, class _A3 = void,
-          bool = __numeric_type<_A1>::value &&
-                 __numeric_type<_A2>::value &&
-                 __numeric_type<_A3>::value>
-class __promote_imp
-{
+template <class _A1,
+          class _A2 = void,
+          class _A3 = void,
+          bool      = __numeric_type<_A1>::value && __numeric_type<_A2>::value && __numeric_type<_A3>::value>
+class __promote_imp {
 public:
-    static const bool value = false;
+  static const bool value = false;
 };
 
 template <class _A1, class _A2, class _A3>
-class __promote_imp<_A1, _A2, _A3, true>
-{
+class __promote_imp<_A1, _A2, _A3, true> {
 private:
-    typedef typename __promote_imp<_A1>::type __type1;
-    typedef typename __promote_imp<_A2>::type __type2;
-    typedef typename __promote_imp<_A3>::type __type3;
+  typedef typename __promote_imp<_A1>::type __type1;
+  typedef typename __promote_imp<_A2>::type __type2;
+  typedef typename __promote_imp<_A3>::type __type3;
+
 public:
-    typedef decltype(__type1() + __type2() + __type3()) type;
-    static const bool value = true;
+  typedef decltype(__type1() + __type2() + __type3()) type;
+  static const bool value = true;
 };
 
 template <class _A1, class _A2>
-class __promote_imp<_A1, _A2, void, true>
-{
+class __promote_imp<_A1, _A2, void, true> {
 private:
-    typedef typename __promote_imp<_A1>::type __type1;
-    typedef typename __promote_imp<_A2>::type __type2;
+  typedef typename __promote_imp<_A1>::type __type1;
+  typedef typename __promote_imp<_A2>::type __type2;
+
 public:
-    typedef decltype(__type1() + __type2()) type;
-    static const bool value = true;
+  typedef decltype(__type1() + __type2()) type;
+  static const bool value = true;
 };
 
 template <class _A1>
-class __promote_imp<_A1, void, void, true>
-{
+class __promote_imp<_A1, void, void, true> {
 public:
-    typedef typename __numeric_type<_A1>::type type;
-    static const bool value = true;
+  typedef typename __numeric_type<_A1>::type type;
+  static const bool value = true;
 };
 
 template <class _A1, class _A2 = void, class _A3 = void>
 class __promote : public __promote_imp<_A1, _A2, _A3> {};
 
+#endif // !defined(_LIBCPP_CLANG_VER) || _LIBCPP_CLANG_VER >= 1700
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_PROMOTE_H
diff --git a/third_party/libcxx/__type_traits/rank.h b/third_party/libcxx/__type_traits/rank.h
index 5f3fab89d..7f6fad1c5 100644
--- a/third_party/libcxx/__type_traits/rank.h
+++ b/third_party/libcxx/__type_traits/rank.h
@@ -27,12 +27,12 @@ struct rank : integral_constant<size_t, __array_rank(_Tp)> {};
 
 #else
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank
-    : public integral_constant<size_t, 0> {};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[]>
-    : public integral_constant<size_t, rank<_Tp>::value + 1> {};
-template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[_Np]>
-    : public integral_constant<size_t, rank<_Tp>::value + 1> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS rank : public integral_constant<size_t, 0> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS rank<_Tp[]> : public integral_constant<size_t, rank<_Tp>::value + 1> {};
+template <class _Tp, size_t _Np>
+struct _LIBCPP_TEMPLATE_VIS rank<_Tp[_Np]> : public integral_constant<size_t, rank<_Tp>::value + 1> {};
 
 #endif // __has_builtin(__array_rank)
 
diff --git a/third_party/libcxx/__type_traits/remove_all_extents.h b/third_party/libcxx/__type_traits/remove_all_extents.h
index f7e32251c..d5373b51f 100644
--- a/third_party/libcxx/__type_traits/remove_all_extents.h
+++ b/third_party/libcxx/__type_traits/remove_all_extents.h
@@ -27,19 +27,26 @@ struct remove_all_extents {
 template <class _Tp>
 using __remove_all_extents_t = __remove_all_extents(_Tp);
 #else
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents
-    {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[]>
-    {typedef typename remove_all_extents<_Tp>::type type;};
-template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[_Np]>
-    {typedef typename remove_all_extents<_Tp>::type type;};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_all_extents {
+  typedef _Tp type;
+};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[]> {
+  typedef typename remove_all_extents<_Tp>::type type;
+};
+template <class _Tp, size_t _Np>
+struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[_Np]> {
+  typedef typename remove_all_extents<_Tp>::type type;
+};
 
 template <class _Tp>
 using __remove_all_extents_t = typename remove_all_extents<_Tp>::type;
 #endif // __has_builtin(__remove_all_extents)
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using remove_all_extents_t = __remove_all_extents_t<_Tp>;
+template <class _Tp>
+using remove_all_extents_t = __remove_all_extents_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/remove_const.h b/third_party/libcxx/__type_traits/remove_const.h
index 37f0609e4..a3f0648c4 100644
--- a/third_party/libcxx/__type_traits/remove_const.h
+++ b/third_party/libcxx/__type_traits/remove_const.h
@@ -26,15 +26,22 @@ struct remove_const {
 template <class _Tp>
 using __remove_const_t = __remove_const(_Tp);
 #else
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const            {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_const {
+  typedef _Tp type;
+};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {
+  typedef _Tp type;
+};
 
 template <class _Tp>
 using __remove_const_t = typename remove_const<_Tp>::type;
 #endif // __has_builtin(__remove_const)
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using remove_const_t = __remove_const_t<_Tp>;
+template <class _Tp>
+using remove_const_t = __remove_const_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/remove_cv.h b/third_party/libcxx/__type_traits/remove_cv.h
index 7eb894074..50e9f3e8a 100644
--- a/third_party/libcxx/__type_traits/remove_cv.h
+++ b/third_party/libcxx/__type_traits/remove_cv.h
@@ -10,8 +10,6 @@
 #define _LIBCPP___TYPE_TRAITS_REMOVE_CV_H
 
 #include <__config>
-#include <__type_traits/remove_const.h>
-#include <__type_traits/remove_volatile.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -19,24 +17,22 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__remove_cv)
 template <class _Tp>
 struct remove_cv {
   using type _LIBCPP_NODEBUG = __remove_cv(_Tp);
 };
 
+#if defined(_LIBCPP_COMPILER_GCC)
+template <class _Tp>
+using __remove_cv_t = typename remove_cv<_Tp>::type;
+#else
 template <class _Tp>
 using __remove_cv_t = __remove_cv(_Tp);
-#else
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
-{typedef __remove_volatile_t<__remove_const_t<_Tp> > type;};
-
-template <class _Tp>
-using __remove_cv_t = __remove_volatile_t<__remove_const_t<_Tp> >;
-#endif // __has_builtin(__remove_cv)
+#endif
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using remove_cv_t = __remove_cv_t<_Tp>;
+template <class _Tp>
+using remove_cv_t = __remove_cv_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/remove_cvref.h b/third_party/libcxx/__type_traits/remove_cvref.h
index f1111fd94..55f894dbd 100644
--- a/third_party/libcxx/__type_traits/remove_cvref.h
+++ b/third_party/libcxx/__type_traits/remove_cvref.h
@@ -20,24 +20,30 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__remove_cvref)
+#if defined(_LIBCPP_COMPILER_GCC)
 template <class _Tp>
-using __remove_cvref_t _LIBCPP_NODEBUG = __remove_cvref(_Tp);
+struct __remove_cvref_gcc {
+  using type = __remove_cvref(_Tp);
+};
+
+template <class _Tp>
+using __remove_cvref_t _LIBCPP_NODEBUG = typename __remove_cvref_gcc<_Tp>::type;
 #else
 template <class _Tp>
-using __remove_cvref_t _LIBCPP_NODEBUG = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >;
+using __remove_cvref_t _LIBCPP_NODEBUG = __remove_cvref(_Tp);
 #endif // __has_builtin(__remove_cvref)
 
 template <class _Tp, class _Up>
-struct __is_same_uncvref : _IsSame<__remove_cvref_t<_Tp>, __remove_cvref_t<_Up> > {};
+using __is_same_uncvref = _IsSame<__remove_cvref_t<_Tp>, __remove_cvref_t<_Up> >;
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp>
 struct remove_cvref {
-    using type _LIBCPP_NODEBUG = __remove_cvref_t<_Tp>;
+  using type _LIBCPP_NODEBUG = __remove_cvref(_Tp);
 };
 
-template <class _Tp> using remove_cvref_t = __remove_cvref_t<_Tp>;
+template <class _Tp>
+using remove_cvref_t = __remove_cvref_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/remove_extent.h b/third_party/libcxx/__type_traits/remove_extent.h
index 65dfcdc00..fe37b5c72 100644
--- a/third_party/libcxx/__type_traits/remove_extent.h
+++ b/third_party/libcxx/__type_traits/remove_extent.h
@@ -27,19 +27,26 @@ struct remove_extent {
 template <class _Tp>
 using __remove_extent_t = __remove_extent(_Tp);
 #else
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent
-    {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[]>
-    {typedef _Tp type;};
-template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[_Np]>
-    {typedef _Tp type;};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_extent {
+  typedef _Tp type;
+};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[]> {
+  typedef _Tp type;
+};
+template <class _Tp, size_t _Np>
+struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[_Np]> {
+  typedef _Tp type;
+};
 
 template <class _Tp>
 using __remove_extent_t = typename remove_extent<_Tp>::type;
 #endif // __has_builtin(__remove_extent)
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using remove_extent_t = __remove_extent_t<_Tp>;
+template <class _Tp>
+using remove_extent_t = __remove_extent_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/remove_pointer.h b/third_party/libcxx/__type_traits/remove_pointer.h
index 8b3a9c7c0..1048f6705 100644
--- a/third_party/libcxx/__type_traits/remove_pointer.h
+++ b/third_party/libcxx/__type_traits/remove_pointer.h
@@ -23,21 +23,29 @@ struct remove_pointer {
   using type _LIBCPP_NODEBUG = __remove_pointer(_Tp);
 };
 
+#  ifdef _LIBCPP_COMPILER_GCC
+template <class _Tp>
+using __remove_pointer_t = typename remove_pointer<_Tp>::type;
+#  else
 template <class _Tp>
 using __remove_pointer_t = __remove_pointer(_Tp);
+#  endif
 #else
+// clang-format off
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer                      {typedef _LIBCPP_NODEBUG _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp*>                {typedef _LIBCPP_NODEBUG _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const>          {typedef _LIBCPP_NODEBUG _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* volatile>       {typedef _LIBCPP_NODEBUG _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
+// clang-format on
 
 template <class _Tp>
 using __remove_pointer_t = typename remove_pointer<_Tp>::type;
 #endif // !defined(_LIBCPP_WORKAROUND_OBJCXX_COMPILER_INTRINSICS) && __has_builtin(__remove_pointer)
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using remove_pointer_t = __remove_pointer_t<_Tp>;
+template <class _Tp>
+using remove_pointer_t = __remove_pointer_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/remove_reference.h b/third_party/libcxx/__type_traits/remove_reference.h
index 1d510c248..ba6789175 100644
--- a/third_party/libcxx/__type_traits/remove_reference.h
+++ b/third_party/libcxx/__type_traits/remove_reference.h
@@ -10,7 +10,6 @@
 #define _LIBCPP___TYPE_TRAITS_REMOVE_REFERENCE_H
 
 #include <__config>
-#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -26,17 +25,21 @@ struct remove_reference {
 
 template <class _Tp>
 using __libcpp_remove_reference_t = __remove_reference_t(_Tp);
-#else
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference        {typedef _LIBCPP_NODEBUG _Tp type;};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&>  {typedef _LIBCPP_NODEBUG _Tp type;};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG _Tp type;};
+#elif __has_builtin(__remove_reference)
+template <class _Tp>
+struct remove_reference {
+  using type _LIBCPP_NODEBUG = __remove_reference(_Tp);
+};
 
 template <class _Tp>
 using __libcpp_remove_reference_t = typename remove_reference<_Tp>::type;
+#else
+#  error "remove_reference not implemented!"
 #endif // __has_builtin(__remove_reference_t)
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using remove_reference_t = __libcpp_remove_reference_t<_Tp>;
+template <class _Tp>
+using remove_reference_t = __libcpp_remove_reference_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/remove_volatile.h b/third_party/libcxx/__type_traits/remove_volatile.h
index cc9fb55e0..7600ae0ec 100644
--- a/third_party/libcxx/__type_traits/remove_volatile.h
+++ b/third_party/libcxx/__type_traits/remove_volatile.h
@@ -26,15 +26,22 @@ struct remove_volatile {
 template <class _Tp>
 using __remove_volatile_t = __remove_volatile(_Tp);
 #else
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile               {typedef _Tp type;};
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_volatile {
+  typedef _Tp type;
+};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {
+  typedef _Tp type;
+};
 
 template <class _Tp>
 using __remove_volatile_t = typename remove_volatile<_Tp>::type;
 #endif // __has_builtin(__remove_volatile)
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using remove_volatile_t = __remove_volatile_t<_Tp>;
+template <class _Tp>
+using remove_volatile_t = __remove_volatile_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/result_of.h b/third_party/libcxx/__type_traits/result_of.h
index dff28286e..f00fa8e9b 100644
--- a/third_party/libcxx/__type_traits/result_of.h
+++ b/third_party/libcxx/__type_traits/result_of.h
@@ -21,18 +21,17 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // result_of
 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
-template <class _Callable> class _LIBCPP_DEPRECATED_IN_CXX17 result_of;
+template <class _Callable>
+class _LIBCPP_DEPRECATED_IN_CXX17 result_of;
 
-template <class _Fp, class ..._Args>
-class _LIBCPP_TEMPLATE_VIS result_of<_Fp(_Args...)>
-    : public __invoke_of<_Fp, _Args...>
-{
-};
+template <class _Fp, class... _Args>
+class _LIBCPP_TEMPLATE_VIS result_of<_Fp(_Args...)> : public __invoke_of<_Fp, _Args...> {};
 
-#if _LIBCPP_STD_VER >= 14
-template <class _Tp> using result_of_t _LIBCPP_DEPRECATED_IN_CXX17 = typename result_of<_Tp>::type;
-#endif // _LIBCPP_STD_VER >= 14
-#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
+#  if _LIBCPP_STD_VER >= 14
+template <class _Tp>
+using result_of_t _LIBCPP_DEPRECATED_IN_CXX17 = typename result_of<_Tp>::type;
+#  endif // _LIBCPP_STD_VER >= 14
+#endif   // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/strip_signature.h b/third_party/libcxx/__type_traits/strip_signature.h
index 2bb7393c1..3fe79592f 100644
--- a/third_party/libcxx/__type_traits/strip_signature.h
+++ b/third_party/libcxx/__type_traits/strip_signature.h
@@ -19,23 +19,24 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Fp>
+template <class _Fp>
 struct __strip_signature;
 
 #  if defined(__cpp_static_call_operator) && __cpp_static_call_operator >= 202207L
 
 template <class _Rp, class... _Args>
-struct __strip_signature<_Rp(*)(_Args...)> {
+struct __strip_signature<_Rp (*)(_Args...)> {
   using type = _Rp(_Args...);
 };
 
 template <class _Rp, class... _Args>
-struct __strip_signature<_Rp(*)(_Args...) noexcept> {
+struct __strip_signature<_Rp (*)(_Args...) noexcept> {
   using type = _Rp(_Args...);
 };
 
 #  endif // defined(__cpp_static_call_operator) && __cpp_static_call_operator >= 202207L
 
+// clang-format off
 template<class _Rp, class _Gp, class ..._Ap>
 struct __strip_signature<_Rp (_Gp::*) (_Ap...)> { using type = _Rp(_Ap...); };
 template<class _Rp, class _Gp, class ..._Ap>
@@ -71,6 +72,7 @@ template<class _Rp, class _Gp, class ..._Ap>
 struct __strip_signature<_Rp (_Gp::*) (_Ap...) volatile & noexcept> { using type = _Rp(_Ap...); };
 template<class _Rp, class _Gp, class ..._Ap>
 struct __strip_signature<_Rp (_Gp::*) (_Ap...) const volatile & noexcept> { using type = _Rp(_Ap...); };
+// clang-format on
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/type_identity.h b/third_party/libcxx/__type_traits/type_identity.h
index 92f288f4c..b0b5a1277 100644
--- a/third_party/libcxx/__type_traits/type_identity.h
+++ b/third_party/libcxx/__type_traits/type_identity.h
@@ -18,14 +18,20 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct __type_identity { typedef _Tp type; };
+struct __type_identity {
+  typedef _Tp type;
+};
 
 template <class _Tp>
 using __type_identity_t _LIBCPP_NODEBUG = typename __type_identity<_Tp>::type;
 
 #if _LIBCPP_STD_VER >= 20
-template<class _Tp> struct type_identity { typedef _Tp type; };
-template<class _Tp> using type_identity_t = typename type_identity<_Tp>::type;
+template <class _Tp>
+struct type_identity {
+  typedef _Tp type;
+};
+template <class _Tp>
+using type_identity_t = typename type_identity<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/type_list.h b/third_party/libcxx/__type_traits/type_list.h
index 5a9e3319a..02905707e 100644
--- a/third_party/libcxx/__type_traits/type_list.h
+++ b/third_party/libcxx/__type_traits/type_list.h
@@ -19,24 +19,22 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Hp, class _Tp>
-struct __type_list
-{
-    typedef _Hp _Head;
-    typedef _Tp _Tail;
+struct __type_list {
+  typedef _Hp _Head;
+  typedef _Tp _Tail;
 };
 
-template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeList::_Head)> struct __find_first;
+template <class _TypeList, size_t _Size, bool = _Size <= sizeof(typename _TypeList::_Head)>
+struct __find_first;
 
 template <class _Hp, class _Tp, size_t _Size>
-struct __find_first<__type_list<_Hp, _Tp>, _Size, true>
-{
-    typedef _LIBCPP_NODEBUG _Hp type;
+struct __find_first<__type_list<_Hp, _Tp>, _Size, true> {
+  typedef _LIBCPP_NODEBUG _Hp type;
 };
 
 template <class _Hp, class _Tp, size_t _Size>
-struct __find_first<__type_list<_Hp, _Tp>, _Size, false>
-{
-    typedef _LIBCPP_NODEBUG typename __find_first<_Tp, _Size>::type type;
+struct __find_first<__type_list<_Hp, _Tp>, _Size, false> {
+  typedef _LIBCPP_NODEBUG typename __find_first<_Tp, _Size>::type type;
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/underlying_type.h b/third_party/libcxx/__type_traits/underlying_type.h
index 6f52d678b..16e7501de 100644
--- a/third_party/libcxx/__type_traits/underlying_type.h
+++ b/third_party/libcxx/__type_traits/underlying_type.h
@@ -18,22 +18,23 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, bool = is_enum<_Tp>::value> struct __underlying_type_impl;
+template <class _Tp, bool = is_enum<_Tp>::value>
+struct __underlying_type_impl;
 
 template <class _Tp>
 struct __underlying_type_impl<_Tp, false> {};
 
 template <class _Tp>
-struct __underlying_type_impl<_Tp, true>
-{
-    typedef __underlying_type(_Tp) type;
+struct __underlying_type_impl<_Tp, true> {
+  typedef __underlying_type(_Tp) type;
 };
 
 template <class _Tp>
 struct underlying_type : __underlying_type_impl<_Tp, is_enum<_Tp>::value> {};
 
 #if _LIBCPP_STD_VER >= 14
-template <class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;
+template <class _Tp>
+using underlying_type_t = typename underlying_type<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__type_traits/unwrap_ref.h b/third_party/libcxx/__type_traits/unwrap_ref.h
index 94cc8ea72..6bd74550f 100644
--- a/third_party/libcxx/__type_traits/unwrap_ref.h
+++ b/third_party/libcxx/__type_traits/unwrap_ref.h
@@ -10,6 +10,7 @@
 #define _LIBCPP___TYPE_TRAITS_UNWRAP_REF_H
 
 #include <__config>
+#include <__fwd/functional.h>
 #include <__type_traits/decay.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -19,26 +20,24 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct __unwrap_reference { typedef _LIBCPP_NODEBUG _Tp type; };
+struct __unwrap_reference {
+  typedef _LIBCPP_NODEBUG _Tp type;
+};
 
 template <class _Tp>
-class reference_wrapper;
-
-template <class _Tp>
-struct __unwrap_reference<reference_wrapper<_Tp> > { typedef _LIBCPP_NODEBUG _Tp& type; };
-
-template <class _Tp>
-struct decay;
+struct __unwrap_reference<reference_wrapper<_Tp> > {
+  typedef _LIBCPP_NODEBUG _Tp& type;
+};
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp>
-struct unwrap_reference : __unwrap_reference<_Tp> { };
+struct unwrap_reference : __unwrap_reference<_Tp> {};
 
 template <class _Tp>
 using unwrap_reference_t = typename unwrap_reference<_Tp>::type;
 
 template <class _Tp>
-struct unwrap_ref_decay : unwrap_reference<__decay_t<_Tp> > { };
+struct unwrap_ref_decay : unwrap_reference<__decay_t<_Tp> > {};
 
 template <class _Tp>
 using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
@@ -51,7 +50,8 @@ struct __unwrap_ref_decay
 #else
     : __unwrap_reference<__decay_t<_Tp> >
 #endif
-{ };
+{
+};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__type_traits/void_t.h b/third_party/libcxx/__type_traits/void_t.h
index 2fe438cf3..985bba02e 100644
--- a/third_party/libcxx/__type_traits/void_t.h
+++ b/third_party/libcxx/__type_traits/void_t.h
@@ -18,7 +18,8 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
-template <class...> using void_t = void;
+template <class...>
+using void_t = void;
 #endif
 
 template <class...>
diff --git a/third_party/libcxx/__undef_macros b/third_party/libcxx/__undef_macros
index 3bacbbacb..29ab327e1 100644
--- a/third_party/libcxx/__undef_macros
+++ b/third_party/libcxx/__undef_macros
@@ -14,3 +14,15 @@
 #ifdef max
 #  undef max
 #endif
+
+#ifdef refresh
+#  undef refresh
+#endif
+
+#ifdef move
+#  undef move
+#endif
+
+#ifdef erase
+#  undef erase
+#endif
diff --git a/third_party/libcxx/__utility/as_const.h b/third_party/libcxx/__utility/as_const.h
index b5c6091ec..582dd42f4 100644
--- a/third_party/libcxx/__utility/as_const.h
+++ b/third_party/libcxx/__utility/as_const.h
@@ -22,7 +22,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept { return __t; }
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr add_const_t<_Tp>& as_const(_Tp& __t) noexcept {
+  return __t;
+}
 
 template <class _Tp>
 void as_const(const _Tp&&) = delete;
diff --git a/third_party/libcxx/__utility/as_lvalue.h b/third_party/libcxx/__utility/as_lvalue.h
new file mode 100644
index 000000000..159f45dad
--- /dev/null
+++ b/third_party/libcxx/__utility/as_lvalue.h
@@ -0,0 +1,37 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___UTILITY_AS_LVALUE_H
+#define _LIBCPP___UTILITY_AS_LVALUE_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp& __as_lvalue(_LIBCPP_LIFETIMEBOUND _Tp&& __t) {
+  return static_cast<_Tp&>(__t);
+}
+
+#endif // !_LIBCPP_CXX03_LANG
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___UTILITY_AS_LVALUE_H
diff --git a/third_party/libcxx/__utility/cmp.h b/third_party/libcxx/__utility/cmp.h
index 7b7b90136..b7c1ed614 100644
--- a/third_party/libcxx/__utility/cmp.h
+++ b/third_party/libcxx/__utility/cmp.h
@@ -9,14 +9,10 @@
 #ifndef _LIBCPP___UTILITY_CMP_H
 #define _LIBCPP___UTILITY_CMP_H
 
+#include <__concepts/arithmetic.h>
 #include <__config>
-#include <__type_traits/disjunction.h>
-#include <__type_traits/is_integral.h>
-#include <__type_traits/is_same.h>
 #include <__type_traits/is_signed.h>
 #include <__type_traits/make_unsigned.h>
-#include <__utility/forward.h>
-#include <__utility/move.h>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -29,24 +25,9 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
-template<class _Tp, class... _Up>
-struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {};
 
-template<class _Tp>
-concept __is_safe_integral_cmp = is_integral_v<_Tp> &&
-                      !_IsSameAsAny<_Tp, bool, char, char16_t, char32_t
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-                                    , char8_t
-#endif
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-                                    , wchar_t
-#endif
-                                    >::value;
-
-template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool cmp_equal(_Tp __t, _Up __u) noexcept
-{
+template <__libcpp_integer _Tp, __libcpp_integer _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept {
   if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
     return __t == __u;
   else if constexpr (is_signed_v<_Tp>)
@@ -55,17 +36,13 @@ bool cmp_equal(_Tp __t, _Up __u) noexcept
     return __u < 0 ? false : __t == make_unsigned_t<_Up>(__u);
 }
 
-template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool cmp_not_equal(_Tp __t, _Up __u) noexcept
-{
-  return !_VSTD::cmp_equal(__t, __u);
+template <__libcpp_integer _Tp, __libcpp_integer _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_not_equal(_Tp __t, _Up __u) noexcept {
+  return !std::cmp_equal(__t, __u);
 }
 
-template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool cmp_less(_Tp __t, _Up __u) noexcept
-{
+template <__libcpp_integer _Tp, __libcpp_integer _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less(_Tp __t, _Up __u) noexcept {
   if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
     return __t < __u;
   else if constexpr (is_signed_v<_Tp>)
@@ -74,34 +51,27 @@ bool cmp_less(_Tp __t, _Up __u) noexcept
     return __u < 0 ? false : __t < make_unsigned_t<_Up>(__u);
 }
 
-template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool cmp_greater(_Tp __t, _Up __u) noexcept
-{
-  return _VSTD::cmp_less(__u, __t);
+template <__libcpp_integer _Tp, __libcpp_integer _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater(_Tp __t, _Up __u) noexcept {
+  return std::cmp_less(__u, __t);
 }
 
-template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool cmp_less_equal(_Tp __t, _Up __u) noexcept
-{
-  return !_VSTD::cmp_greater(__t, __u);
+template <__libcpp_integer _Tp, __libcpp_integer _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less_equal(_Tp __t, _Up __u) noexcept {
+  return !std::cmp_greater(__t, __u);
 }
 
-template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool cmp_greater_equal(_Tp __t, _Up __u) noexcept
-{
-  return !_VSTD::cmp_less(__t, __u);
+template <__libcpp_integer _Tp, __libcpp_integer _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater_equal(_Tp __t, _Up __u) noexcept {
+  return !std::cmp_less(__t, __u);
 }
 
-template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool in_range(_Up __u) noexcept
-{
-  return _VSTD::cmp_less_equal(__u, numeric_limits<_Tp>::max()) &&
-         _VSTD::cmp_greater_equal(__u, numeric_limits<_Tp>::min());
+template <__libcpp_integer _Tp, __libcpp_integer _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr bool in_range(_Up __u) noexcept {
+  return std::cmp_less_equal(__u, numeric_limits<_Tp>::max()) &&
+         std::cmp_greater_equal(__u, numeric_limits<_Tp>::min());
 }
+
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/__utility/convert_to_integral.h b/third_party/libcxx/__utility/convert_to_integral.h
index 0cc858ad1..f1fcdd980 100644
--- a/third_party/libcxx/__utility/convert_to_integral.h
+++ b/third_party/libcxx/__utility/convert_to_integral.h
@@ -21,51 +21,47 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-int __convert_to_integral(int __val) { return __val; }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __convert_to_integral(int __val) { return __val; }
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-unsigned __convert_to_integral(unsigned __val) { return __val; }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unsigned __convert_to_integral(unsigned __val) { return __val; }
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-long __convert_to_integral(long __val) { return __val; }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long __convert_to_integral(long __val) { return __val; }
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-unsigned long __convert_to_integral(unsigned long __val) { return __val; }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unsigned long __convert_to_integral(unsigned long __val) {
+  return __val;
+}
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-long long __convert_to_integral(long long __val) { return __val; }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long long __convert_to_integral(long long __val) { return __val; }
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-unsigned long long __convert_to_integral(unsigned long long __val) {return __val; }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR unsigned long long __convert_to_integral(unsigned long long __val) {
+  return __val;
+}
 
-template<typename _Fp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename enable_if<is_floating_point<_Fp>::value, long long>::type
- __convert_to_integral(_Fp __val) { return __val; }
+template <typename _Fp, __enable_if_t<is_floating_point<_Fp>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long long __convert_to_integral(_Fp __val) {
+  return __val;
+}
 
 #ifndef _LIBCPP_HAS_NO_INT128
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-__int128_t __convert_to_integral(__int128_t __val) { return __val; }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __int128_t __convert_to_integral(__int128_t __val) { return __val; }
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-__uint128_t __convert_to_integral(__uint128_t __val) { return __val; }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __uint128_t __convert_to_integral(__uint128_t __val) { return __val; }
 #endif
 
 template <class _Tp, bool = is_enum<_Tp>::value>
-struct __sfinae_underlying_type
-{
-    typedef typename underlying_type<_Tp>::type type;
-    typedef decltype(((type)1) + 0) __promoted_type;
+struct __sfinae_underlying_type {
+  typedef typename underlying_type<_Tp>::type type;
+  typedef decltype(((type)1) + 0) __promoted_type;
 };
 
 template <class _Tp>
 struct __sfinae_underlying_type<_Tp, false> {};
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-typename __sfinae_underlying_type<_Tp>::__promoted_type
-__convert_to_integral(_Tp __val) { return __val; }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename __sfinae_underlying_type<_Tp>::__promoted_type
+__convert_to_integral(_Tp __val) {
+  return __val;
+}
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__utility/declval.h b/third_party/libcxx/__utility/declval.h
index c2f4bec13..d0856b8af 100644
--- a/third_party/libcxx/__utility/declval.h
+++ b/third_party/libcxx/__utility/declval.h
@@ -27,7 +27,11 @@ _Tp __declval(long);
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 template <class _Tp>
-decltype(std::__declval<_Tp>(0)) declval() _NOEXCEPT;
+_LIBCPP_HIDE_FROM_ABI decltype(std::__declval<_Tp>(0)) declval() _NOEXCEPT {
+  static_assert(!__is_same(_Tp, _Tp),
+                "std::declval can only be used in an unevaluated context. "
+                "It's likely that your current usage is trying to extract a value from the function.");
+}
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__utility/empty.h b/third_party/libcxx/__utility/empty.h
new file mode 100644
index 000000000..8cca19714
--- /dev/null
+++ b/third_party/libcxx/__utility/empty.h
@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___UTILITY_EMPTY_H
+#define _LIBCPP___UTILITY_EMPTY_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct __empty {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___UTILITY_EMPTY_H
diff --git a/third_party/libcxx/__utility/exception_guard.h b/third_party/libcxx/__utility/exception_guard.h
index 1db8f8af1..9f732ca26 100644
--- a/third_party/libcxx/__utility/exception_guard.h
+++ b/third_party/libcxx/__utility/exception_guard.h
@@ -11,7 +11,7 @@
 
 #include <__assert>
 #include <__config>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__utility/exchange.h>
 #include <__utility/move.h>
 
@@ -19,6 +19,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // __exception_guard is a helper class for writing code with the strong exception guarantee.
@@ -93,8 +96,8 @@ _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__exception_guard_exceptions);
 template <class _Rollback>
 struct __exception_guard_noexceptions {
   __exception_guard_noexceptions() = delete;
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-      _LIBCPP_NODEBUG explicit __exception_guard_noexceptions(_Rollback) {}
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NODEBUG explicit __exception_guard_noexceptions(_Rollback) {}
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NODEBUG
   __exception_guard_noexceptions(__exception_guard_noexceptions&& __other)
@@ -112,7 +115,7 @@ struct __exception_guard_noexceptions {
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NODEBUG ~__exception_guard_noexceptions() {
-    _LIBCPP_ASSERT(__completed_, "__exception_guard not completed with exceptions disabled");
+    _LIBCPP_ASSERT_INTERNAL(__completed_, "__exception_guard not completed with exceptions disabled");
   }
 
 private:
@@ -136,4 +139,6 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __exception_guard<_Rollback> __make_exce
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___UTILITY_TRANSACTION_H
diff --git a/third_party/libcxx/__utility/exchange.h b/third_party/libcxx/__utility/exchange.h
index 4cc5e0451..957e9d0ac 100644
--- a/third_party/libcxx/__utility/exchange.h
+++ b/third_party/libcxx/__utility/exchange.h
@@ -11,7 +11,7 @@
 
 #include <__config>
 #include <__type_traits/is_nothrow_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 
@@ -19,20 +19,23 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 14
-template<class _T1, class _T2 = _T1>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_T1 exchange(_T1& __obj, _T2&& __new_value)
-    noexcept(is_nothrow_move_constructible<_T1>::value && is_nothrow_assignable<_T1&, _T2>::value)
-{
-    _T1 __old_value = _VSTD::move(__obj);
-    __obj = _VSTD::forward<_T2>(__new_value);
-    return __old_value;
+template <class _T1, class _T2 = _T1>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _T1 exchange(_T1& __obj, _T2&& __new_value) noexcept(
+    is_nothrow_move_constructible<_T1>::value && is_nothrow_assignable<_T1&, _T2>::value) {
+  _T1 __old_value = std::move(__obj);
+  __obj           = std::forward<_T2>(__new_value);
+  return __old_value;
 }
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___UTILITY_EXCHANGE_H
diff --git a/third_party/libcxx/__utility/forward.h b/third_party/libcxx/__utility/forward.h
index 010f2362b..d5275dcbd 100644
--- a/third_party/libcxx/__utility/forward.h
+++ b/third_party/libcxx/__utility/forward.h
@@ -21,13 +21,13 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp&&
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp&&
 forward(_LIBCPP_LIFETIMEBOUND __libcpp_remove_reference_t<_Tp>& __t) _NOEXCEPT {
   return static_cast<_Tp&&>(__t);
 }
 
 template <class _Tp>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp&&
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp&&
 forward(_LIBCPP_LIFETIMEBOUND __libcpp_remove_reference_t<_Tp>&& __t) _NOEXCEPT {
   static_assert(!is_lvalue_reference<_Tp>::value, "cannot forward an rvalue as an lvalue");
   return static_cast<_Tp&&>(__t);
diff --git a/third_party/libcxx/__utility/forward_like.h b/third_party/libcxx/__utility/forward_like.h
index ce11b640f..0206ce23a 100644
--- a/third_party/libcxx/__utility/forward_like.h
+++ b/third_party/libcxx/__utility/forward_like.h
@@ -34,8 +34,8 @@ template <class _Ap, class _Bp>
 using _ForwardLike = _OverrideRef<_Ap&&, _CopyConst<remove_reference_t<_Ap>, remove_reference_t<_Bp>>>;
 
 template <class _Tp, class _Up>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto forward_like(_LIBCPP_LIFETIMEBOUND _Up&& __ux) noexcept
-    -> _ForwardLike<_Tp, _Up> {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto
+forward_like(_LIBCPP_LIFETIMEBOUND _Up&& __ux) noexcept -> _ForwardLike<_Tp, _Up> {
   return static_cast<_ForwardLike<_Tp, _Up>>(__ux);
 }
 
diff --git a/third_party/libcxx/__utility/in_place.h b/third_party/libcxx/__utility/in_place.h
index ba8aa227f..fa7a2f4bf 100644
--- a/third_party/libcxx/__utility/in_place.h
+++ b/third_party/libcxx/__utility/in_place.h
@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-struct _LIBCPP_TYPE_VIS in_place_t {
+struct _LIBCPP_EXPORTED_FROM_ABI in_place_t {
   explicit in_place_t() = default;
 };
 inline constexpr in_place_t in_place{};
@@ -40,14 +40,18 @@ struct _LIBCPP_TEMPLATE_VIS in_place_index_t {
 template <size_t _Idx>
 inline constexpr in_place_index_t<_Idx> in_place_index{};
 
-template <class _Tp> struct __is_inplace_type_imp : false_type {};
-template <class _Tp> struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {};
+template <class _Tp>
+struct __is_inplace_type_imp : false_type {};
+template <class _Tp>
+struct __is_inplace_type_imp<in_place_type_t<_Tp>> : true_type {};
 
 template <class _Tp>
 using __is_inplace_type = __is_inplace_type_imp<__remove_cvref_t<_Tp>>;
 
-template <class _Tp> struct __is_inplace_index_imp : false_type {};
-template <size_t _Idx> struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {};
+template <class _Tp>
+struct __is_inplace_index_imp : false_type {};
+template <size_t _Idx>
+struct __is_inplace_index_imp<in_place_index_t<_Idx>> : true_type {};
 
 template <class _Tp>
 using __is_inplace_index = __is_inplace_index_imp<__remove_cvref_t<_Tp>>;
diff --git a/third_party/libcxx/__utility/integer_sequence.h b/third_party/libcxx/__utility/integer_sequence.h
index 633b387d0..ccce9433e 100644
--- a/third_party/libcxx/__utility/integer_sequence.h
+++ b/third_party/libcxx/__utility/integer_sequence.h
@@ -19,7 +19,8 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <size_t...> struct __tuple_indices;
+template <size_t...>
+struct __tuple_indices;
 
 template <class _IdxType, _IdxType... _Values>
 struct __integer_sequence {
@@ -30,119 +31,55 @@ struct __integer_sequence {
   using __to_tuple_indices = __tuple_indices<(_Values + _Sp)...>;
 };
 
-#if !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
-
-namespace __detail {
-
-template<typename _Tp, size_t ..._Extra> struct __repeat;
-template<typename _Tp, _Tp ..._Np, size_t ..._Extra> struct __repeat<__integer_sequence<_Tp, _Np...>, _Extra...> {
-  typedef _LIBCPP_NODEBUG __integer_sequence<_Tp,
-                           _Np...,
-                           sizeof...(_Np) + _Np...,
-                           2 * sizeof...(_Np) + _Np...,
-                           3 * sizeof...(_Np) + _Np...,
-                           4 * sizeof...(_Np) + _Np...,
-                           5 * sizeof...(_Np) + _Np...,
-                           6 * sizeof...(_Np) + _Np...,
-                           7 * sizeof...(_Np) + _Np...,
-                           _Extra...> type;
-};
-
-template<size_t _Np> struct __parity;
-template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};
-
-template<> struct __make<0> { typedef __integer_sequence<size_t> type; };
-template<> struct __make<1> { typedef __integer_sequence<size_t, 0> type; };
-template<> struct __make<2> { typedef __integer_sequence<size_t, 0, 1> type; };
-template<> struct __make<3> { typedef __integer_sequence<size_t, 0, 1, 2> type; };
-template<> struct __make<4> { typedef __integer_sequence<size_t, 0, 1, 2, 3> type; };
-template<> struct __make<5> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4> type; };
-template<> struct __make<6> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; };
-template<> struct __make<7> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; };
-
-template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };
-template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };
-template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };
-template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };
-template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
-template<> struct __parity<5> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
-template<> struct __parity<6> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
-template<> struct __parity<7> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };
-
-} // namespace detail
-
-#endif
-
 #if __has_builtin(__make_integer_seq)
 template <size_t _Ep, size_t _Sp>
 using __make_indices_imp =
-    typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template
-    __to_tuple_indices<_Sp>;
-#else
+    typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template __to_tuple_indices<_Sp>;
+#elif __has_builtin(__integer_pack)
 template <size_t _Ep, size_t _Sp>
 using __make_indices_imp =
-    typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>;
-
+    typename __integer_sequence<size_t, __integer_pack(_Ep - _Sp)...>::template __to_tuple_indices<_Sp>;
+#else
+#  error "No known way to get an integer pack from the compiler"
 #endif
 
 #if _LIBCPP_STD_VER >= 14
 
-template<class _Tp, _Tp... _Ip>
-struct _LIBCPP_TEMPLATE_VIS integer_sequence
-{
-    typedef _Tp value_type;
-    static_assert( is_integral<_Tp>::value,
-                  "std::integer_sequence can only be instantiated with an integral type" );
-    static
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    size_t
-    size() noexcept { return sizeof...(_Ip); }
+template <class _Tp, _Tp... _Ip>
+struct _LIBCPP_TEMPLATE_VIS integer_sequence {
+  typedef _Tp value_type;
+  static_assert(is_integral<_Tp>::value, "std::integer_sequence can only be instantiated with an integral type");
+  static _LIBCPP_HIDE_FROM_ABI constexpr size_t size() noexcept { return sizeof...(_Ip); }
 };
 
-template<size_t... _Ip>
-    using index_sequence = integer_sequence<size_t, _Ip...>;
+template <size_t... _Ip>
+using index_sequence = integer_sequence<size_t, _Ip...>;
 
-#if __has_builtin(__make_integer_seq) && !defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)
+#  if __has_builtin(__make_integer_seq)
 
 template <class _Tp, _Tp _Ep>
-using __make_integer_sequence _LIBCPP_NODEBUG = __make_integer_seq<integer_sequence, _Tp, _Ep>;
+using make_integer_sequence _LIBCPP_NODEBUG = __make_integer_seq<integer_sequence, _Tp, _Ep>;
 
-#else
+#  elif __has_builtin(__integer_pack)
 
-template<typename _Tp, _Tp _Np> using __make_integer_sequence_unchecked _LIBCPP_NODEBUG =
-  typename __detail::__make<_Np>::type::template __convert<integer_sequence, _Tp>;
+template <class _Tp, _Tp _SequenceSize>
+using make_integer_sequence _LIBCPP_NODEBUG = integer_sequence<_Tp, __integer_pack(_SequenceSize)...>;
 
-template <class _Tp, _Tp _Ep>
-struct __make_integer_sequence_checked
-{
-    static_assert(is_integral<_Tp>::value,
-                  "std::make_integer_sequence can only be instantiated with an integral type" );
-    static_assert(0 <= _Ep, "std::make_integer_sequence must have a non-negative sequence length");
-    // Workaround GCC bug by preventing bad installations when 0 <= _Ep
-    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68929
-    typedef _LIBCPP_NODEBUG __make_integer_sequence_unchecked<_Tp, 0 <= _Ep ? _Ep : 0> type;
-};
+#  else
+#    error "No known way to get an integer pack from the compiler"
+#  endif
 
-template <class _Tp, _Tp _Ep>
-using __make_integer_sequence _LIBCPP_NODEBUG = typename __make_integer_sequence_checked<_Tp, _Ep>::type;
+template <size_t _Np>
+using make_index_sequence = make_integer_sequence<size_t, _Np>;
 
-#endif
-
-template<class _Tp, _Tp _Np>
-    using make_integer_sequence = __make_integer_sequence<_Tp, _Np>;
-
-template<size_t _Np>
-    using make_index_sequence = make_integer_sequence<size_t, _Np>;
-
-template<class... _Tp>
-    using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;
+template <class... _Tp>
+using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;
 
 #  if _LIBCPP_STD_VER >= 20
 // Executes __func for every element in an index_sequence.
 template <size_t... _Index, class _Function>
 _LIBCPP_HIDE_FROM_ABI constexpr void __for_each_index_sequence(index_sequence<_Index...>, _Function __func) {
-    (__func.template operator()<_Index>(), ...);
+  (__func.template operator()<_Index>(), ...);
 }
 #  endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/__utility/is_pointer_in_range.h b/third_party/libcxx/__utility/is_pointer_in_range.h
new file mode 100644
index 000000000..4130b4ac7
--- /dev/null
+++ b/third_party/libcxx/__utility/is_pointer_in_range.h
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___UTILITY_IS_POINTER_IN_RANGE_H
+#define _LIBCPP___UTILITY_IS_POINTER_IN_RANGE_H
+
+#include <__algorithm/comp.h>
+#include <__assert>
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_constant_evaluated.h>
+#include <__type_traits/void_t.h>
+#include <__utility/declval.h>
+#include <__utility/is_valid_range.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, class _Up, class = void>
+struct __is_less_than_comparable : false_type {};
+
+template <class _Tp, class _Up>
+struct __is_less_than_comparable<_Tp, _Up, __void_t<decltype(std::declval<_Tp>() < std::declval<_Up>())> > : true_type {
+};
+
+template <class _Tp, class _Up, __enable_if_t<__is_less_than_comparable<const _Tp*, const _Up*>::value, int> = 0>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_SANITIZE("address") bool
+__is_pointer_in_range(const _Tp* __begin, const _Tp* __end, const _Up* __ptr) {
+  _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__begin, __end), "[__begin, __end) is not a valid range");
+
+  if (__libcpp_is_constant_evaluated()) {
+    // If this is not a constant during constant evaluation we know that __ptr is not part of the allocation where
+    // [__begin, __end) is.
+    if (!__builtin_constant_p(__begin <= __ptr && __ptr < __end))
+      return false;
+  }
+
+  return !__less<>()(__ptr, __begin) && __less<>()(__ptr, __end);
+}
+
+template <class _Tp, class _Up, __enable_if_t<!__is_less_than_comparable<const _Tp*, const _Up*>::value, int> = 0>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_SANITIZE("address") bool
+__is_pointer_in_range(const _Tp* __begin, const _Tp* __end, const _Up* __ptr) {
+  if (__libcpp_is_constant_evaluated())
+    return false;
+
+  return reinterpret_cast<const char*>(__begin) <= reinterpret_cast<const char*>(__ptr) &&
+         reinterpret_cast<const char*>(__ptr) < reinterpret_cast<const char*>(__end);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___UTILITY_IS_POINTER_IN_RANGE_H
diff --git a/third_party/libcxx/__utility/is_valid_range.h b/third_party/libcxx/__utility/is_valid_range.h
new file mode 100644
index 000000000..7286662db
--- /dev/null
+++ b/third_party/libcxx/__utility/is_valid_range.h
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___UTILITY_IS_VALID_RANGE_H
+#define _LIBCPP___UTILITY_IS_VALID_RANGE_H
+
+#include <__algorithm/comp.h>
+#include <__config>
+#include <__type_traits/is_constant_evaluated.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_SANITIZE("address") bool
+__is_valid_range(const _Tp* __first, const _Tp* __last) {
+  if (__libcpp_is_constant_evaluated()) {
+    // If this is not a constant during constant evaluation, that is because __first and __last are not
+    // part of the same allocation. If they are part of the same allocation, we must still make sure they
+    // are ordered properly.
+    return __builtin_constant_p(__first <= __last) && __first <= __last;
+  }
+
+  return !__less<>()(__last, __first);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___UTILITY_IS_VALID_RANGE_H
diff --git a/third_party/libcxx/__utility/move.h b/third_party/libcxx/__utility/move.h
index 4859c39e8..b6a42db05 100644
--- a/third_party/libcxx/__utility/move.h
+++ b/third_party/libcxx/__utility/move.h
@@ -12,18 +12,21 @@
 
 #include <__config>
 #include <__type_traits/conditional.h>
-#include <__type_traits/is_copy_constructible.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/remove_reference.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __libcpp_remove_reference_t<_Tp>&&
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __libcpp_remove_reference_t<_Tp>&&
 move(_LIBCPP_LIFETIMEBOUND _Tp&& __t) _NOEXCEPT {
   typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up;
   return static_cast<_Up&&>(__t);
@@ -34,11 +37,13 @@ using __move_if_noexcept_result_t =
     __conditional_t<!is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, const _Tp&, _Tp&&>;
 
 template <class _Tp>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __move_if_noexcept_result_t<_Tp>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __move_if_noexcept_result_t<_Tp>
 move_if_noexcept(_LIBCPP_LIFETIMEBOUND _Tp& __x) _NOEXCEPT {
   return std::move(__x);
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___UTILITY_MOVE_H
diff --git a/third_party/libcxx/__utility/no_destroy.h b/third_party/libcxx/__utility/no_destroy.h
new file mode 100644
index 000000000..8edd19457
--- /dev/null
+++ b/third_party/libcxx/__utility/no_destroy.h
@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___UTILITY_NO_DESTROY_H
+#define _LIBCPP___UTILITY_NO_DESTROY_H
+
+#include <__config>
+#include <__type_traits/is_constant_evaluated.h>
+#include <__utility/forward.h>
+#include <new>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct __uninitialized_tag {};
+
+// This class stores an object of type _Tp but never destroys it.
+//
+// This is akin to using __attribute__((no_destroy)), except that it is possible
+// to control the lifetime of the object with more flexibility by deciding e.g.
+// whether to initialize the object at construction or to defer to a later
+// initialization using __emplace.
+template <class _Tp>
+struct __no_destroy {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __no_destroy(__uninitialized_tag) : __obj_() {}
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI explicit __no_destroy(_Args&&... __args) {
+    ::new ((void*)__obj_) _Tp(std::forward<_Args>(__args)...);
+  }
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI _Tp& __emplace(_Args&&... __args) {
+    return *(::new ((void*)__obj_) _Tp(std::forward<_Args>(__args)...));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _Tp& __get() { return *reinterpret_cast<_Tp*>(__obj_); }
+  _LIBCPP_HIDE_FROM_ABI _Tp const& __get() const { return *reinterpret_cast<const _Tp*>(__obj_); }
+
+private:
+  _ALIGNAS_TYPE(_Tp) char __obj_[sizeof(_Tp)];
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___UTILITY_NO_DESTROY_H
diff --git a/third_party/libcxx/__utility/pair.h b/third_party/libcxx/__utility/pair.h
index bb4b75ab8..c0002b7ab 100644
--- a/third_party/libcxx/__utility/pair.h
+++ b/third_party/libcxx/__utility/pair.h
@@ -14,13 +14,12 @@
 #include <__concepts/different_from.h>
 #include <__config>
 #include <__fwd/array.h>
-#include <__fwd/get.h>
-#include <__fwd/subrange.h>
+#include <__fwd/pair.h>
 #include <__fwd/tuple.h>
-#include <__tuple/pair_like.h>
 #include <__tuple/sfinae_helpers.h>
 #include <__tuple/tuple_element.h>
 #include <__tuple/tuple_indices.h>
+#include <__tuple/tuple_like_no_subrange.h>
 #include <__tuple/tuple_size.h>
 #include <__type_traits/common_reference.h>
 #include <__type_traits/common_type.h>
@@ -30,18 +29,13 @@
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
-#include <__type_traits/is_copy_assignable.h>
-#include <__type_traits/is_default_constructible.h>
 #include <__type_traits/is_implicitly_default_constructible.h>
-#include <__type_traits/is_move_assignable.h>
 #include <__type_traits/is_nothrow_assignable.h>
 #include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_nothrow_copy_assignable.h>
-#include <__type_traits/is_nothrow_copy_constructible.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_reference.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
+#include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/nat.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/unwrap_ref.h>
@@ -55,842 +49,670 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class, class>
 struct __non_trivially_copyable_base {
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI
-  __non_trivially_copyable_base() _NOEXCEPT {}
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI __non_trivially_copyable_base() _NOEXCEPT {}
   _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
   __non_trivially_copyable_base(__non_trivially_copyable_base const&) _NOEXCEPT {}
 };
 
-#if _LIBCPP_STD_VER >= 23
-template <class _Tp>
-struct __is_specialization_of_subrange : false_type {};
-
-template <class _Iter, class _Sent, ranges::subrange_kind _Kind>
-struct __is_specialization_of_subrange<ranges::subrange<_Iter, _Sent, _Kind>> : true_type {};
-#endif
-
 template <class _T1, class _T2>
 struct _LIBCPP_TEMPLATE_VIS pair
 #if defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
-: private __non_trivially_copyable_base<_T1, _T2>
+    : private __non_trivially_copyable_base<_T1, _T2>
 #endif
 {
-    using first_type = _T1;
-    using second_type = _T2;
+  using first_type  = _T1;
+  using second_type = _T2;
 
-    _T1 first;
-    _T2 second;
+  _T1 first;
+  _T2 second;
 
-    _LIBCPP_HIDE_FROM_ABI pair(pair const&) = default;
-    _LIBCPP_HIDE_FROM_ABI pair(pair&&) = default;
+  using __trivially_relocatable =
+      __conditional_t<__libcpp_is_trivially_relocatable<_T1>::value && __libcpp_is_trivially_relocatable<_T2>::value,
+                      pair,
+                      void>;
+
+  _LIBCPP_HIDE_FROM_ABI pair(pair const&) = default;
+  _LIBCPP_HIDE_FROM_ABI pair(pair&&)      = default;
+
+  // When we are requested for pair to be trivially copyable by the ABI macro, we use defaulted members
+  // if it is both legal to do it (i.e. no references) and we have a way to actually implement it, which requires
+  // the __enable_if__ attribute before C++20.
+#ifdef _LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR
+  // FIXME: This should really just be a static constexpr variable. It's in a struct to avoid gdb printing the value
+  // when printing a pair
+  struct __has_defaulted_members {
+    static const bool value = !is_reference<first_type>::value && !is_reference<second_type>::value;
+  };
+#  if _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI constexpr pair& operator=(const pair&)
+    requires __has_defaulted_members::value
+  = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr pair& operator=(pair&&)
+    requires __has_defaulted_members::value
+  = default;
+#  elif __has_attribute(__enable_if__)
+  _LIBCPP_HIDE_FROM_ABI pair& operator=(const pair&)
+      __attribute__((__enable_if__(__has_defaulted_members::value, ""))) = default;
+
+  _LIBCPP_HIDE_FROM_ABI pair& operator=(pair&&)
+      __attribute__((__enable_if__(__has_defaulted_members::value, ""))) = default;
+#  else
+#    error "_LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR isn't supported with this compiler"
+#  endif
+#else
+  struct __has_defaulted_members {
+    static const bool value = false;
+  };
+#endif // defined(_LIBCPP_ABI_TRIVIALLY_COPYABLE_PAIR) && __has_attribute(__enable_if__)
 
 #ifdef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI
-    pair() : first(), second() {}
+  _LIBCPP_HIDE_FROM_ABI pair() : first(), second() {}
 
-    _LIBCPP_HIDE_FROM_ABI
-    pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {}
+  _LIBCPP_HIDE_FROM_ABI pair(_T1 const& __t1, _T2 const& __t2) : first(__t1), second(__t2) {}
+
+  template <class _U1, class _U2>
+  _LIBCPP_HIDE_FROM_ABI pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
+
+  _LIBCPP_HIDE_FROM_ABI pair& operator=(pair const& __p) {
+    first  = __p.first;
+    second = __p.second;
+    return *this;
+  }
+
+  // Extension: This is provided in C++03 because it allows properly handling the
+  //            assignment to a pair containing references, which would be a hard
+  //            error otherwise.
+  template <
+      class _U1,
+      class _U2,
+      __enable_if_t<is_assignable<first_type&, _U1 const&>::value && is_assignable<second_type&, _U2 const&>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair& operator=(pair<_U1, _U2> const& __p) {
+    first  = __p.first;
+    second = __p.second;
+    return *this;
+  }
+#else
+  struct _CheckArgs {
+    template <int&...>
+    static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() {
+      return __is_implicitly_default_constructible<_T1>::value && __is_implicitly_default_constructible<_T2>::value;
+    }
+
+    template <int&...>
+    static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_default() {
+      return is_default_constructible<_T1>::value && is_default_constructible<_T2>::value;
+    }
 
     template <class _U1, class _U2>
-    _LIBCPP_HIDE_FROM_ABI
-    pair(const pair<_U1, _U2>& __p) : first(__p.first), second(__p.second) {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    pair& operator=(pair const& __p) {
-        first = __p.first;
-        second = __p.second;
-        return *this;
+    static _LIBCPP_HIDE_FROM_ABI constexpr bool __is_pair_constructible() {
+      return is_constructible<first_type, _U1>::value && is_constructible<second_type, _U2>::value;
     }
 
-    // Extension: This is provided in C++03 because it allows properly handling the
-    //            assignment to a pair containing references, which would be a hard
-    //            error otherwise.
-    template <class _U1, class _U2, class = __enable_if_t<
-        is_assignable<first_type&, _U1 const&>::value &&
-        is_assignable<second_type&, _U2 const&>::value
-    > >
-    _LIBCPP_HIDE_FROM_ABI
-    pair& operator=(pair<_U1, _U2> const& __p) {
-        first = __p.first;
-        second = __p.second;
-        return *this;
+    template <class _U1, class _U2>
+    static _LIBCPP_HIDE_FROM_ABI constexpr bool __is_implicit() {
+      return is_convertible<_U1, first_type>::value && is_convertible<_U2, second_type>::value;
     }
-#else
-    struct _CheckArgs {
-      template <int&...>
-      static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() {
-          return is_default_constructible<_T1>::value
-              && is_default_constructible<_T2>::value
-              && !__enable_implicit_default<>();
-      }
+  };
 
-      template <int&...>
-      static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() {
-          return __is_implicitly_default_constructible<_T1>::value
-              && __is_implicitly_default_constructible<_T2>::value;
-      }
+  template <bool _MaybeEnable>
+  using _CheckArgsDep _LIBCPP_NODEBUG =
+      typename conditional< _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
 
-      template <class _U1, class _U2>
-      static _LIBCPP_HIDE_FROM_ABI constexpr bool __is_pair_constructible() {
-          return is_constructible<first_type, _U1>::value
-              && is_constructible<second_type, _U2>::value;
-      }
+  template <bool _Dummy = true, __enable_if_t<_CheckArgsDep<_Dummy>::__enable_default(), int> = 0>
+  explicit(!_CheckArgsDep<_Dummy>::__enable_implicit_default()) _LIBCPP_HIDE_FROM_ABI constexpr pair() noexcept(
+      is_nothrow_default_constructible<first_type>::value && is_nothrow_default_constructible<second_type>::value)
+      : first(), second() {}
 
-      template <class _U1, class _U2>
-      static _LIBCPP_HIDE_FROM_ABI constexpr bool __is_implicit() {
-          return is_convertible<_U1, first_type>::value
-              && is_convertible<_U2, second_type>::value;
-      }
+  template <bool _Dummy = true,
+            __enable_if_t<_CheckArgsDep<_Dummy>::template __is_pair_constructible<_T1 const&, _T2 const&>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(!_CheckArgsDep<_Dummy>::template __is_implicit<_T1 const&, _T2 const&>())
+      pair(_T1 const& __t1, _T2 const& __t2) noexcept(is_nothrow_copy_constructible<first_type>::value &&
+                                                      is_nothrow_copy_constructible<second_type>::value)
+      : first(__t1), second(__t2) {}
 
-      template <class _U1, class _U2>
-      static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit() {
-          return __is_pair_constructible<_U1, _U2>() && !__is_implicit<_U1, _U2>();
-      }
-
-      template <class _U1, class _U2>
-      static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit() {
-          return __is_pair_constructible<_U1, _U2>() && __is_implicit<_U1, _U2>();
-      }
-    };
-
-    template <bool _MaybeEnable>
-    using _CheckArgsDep _LIBCPP_NODEBUG = typename conditional<
-      _MaybeEnable, _CheckArgs, __check_tuple_constructor_fail>::type;
-
-    template<bool _Dummy = true, typename enable_if<
-            _CheckArgsDep<_Dummy>::__enable_explicit_default()
-    >::type* = nullptr>
-    explicit _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-    pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
-                      is_nothrow_default_constructible<second_type>::value)
-        : first(), second() {}
-
-    template<bool _Dummy = true, typename enable_if<
-            _CheckArgsDep<_Dummy>::__enable_implicit_default()
-    >::type* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-    pair() _NOEXCEPT_(is_nothrow_default_constructible<first_type>::value &&
-                      is_nothrow_default_constructible<second_type>::value)
-        : first(), second() {}
-
-    template <bool _Dummy = true, typename enable_if<
-             _CheckArgsDep<_Dummy>::template __enable_explicit<_T1 const&, _T2 const&>()
-    >::type* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit pair(_T1 const& __t1, _T2 const& __t2)
-        _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
-                   is_nothrow_copy_constructible<second_type>::value)
-        : first(__t1), second(__t2) {}
-
-    template<bool _Dummy = true, typename enable_if<
-            _CheckArgsDep<_Dummy>::template __enable_implicit<_T1 const&, _T2 const&>()
-    >::type* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair(_T1 const& __t1, _T2 const& __t2)
-        _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
-                   is_nothrow_copy_constructible<second_type>::value)
-        : first(__t1), second(__t2) {}
-
-    template <
-#if _LIBCPP_STD_VER >= 23 // http://wg21.link/P1951
-        class _U1 = _T1, class _U2 = _T2,
-#else
-        class _U1, class _U2,
-#endif
-        typename enable_if<_CheckArgs::template __enable_explicit<_U1, _U2>()>::type* = nullptr
-    >
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit pair(_U1&& __u1, _U2&& __u2)
-        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
-                    is_nothrow_constructible<second_type, _U2>::value))
-        : first(std::forward<_U1>(__u1)), second(std::forward<_U2>(__u2)) {}
-
-    template <
-#if _LIBCPP_STD_VER >= 23 // http://wg21.link/P1951
-        class _U1 = _T1, class _U2 = _T2,
-#else
-        class _U1, class _U2,
-#endif
-        typename enable_if<_CheckArgs::template __enable_implicit<_U1, _U2>()>::type* = nullptr
-    >
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair(_U1&& __u1, _U2&& __u2)
-        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1>::value &&
-                    is_nothrow_constructible<second_type, _U2>::value))
-        : first(std::forward<_U1>(__u1)), second(std::forward<_U2>(__u2)) {}
-
-#if _LIBCPP_STD_VER >= 23
-    template<class _U1, class _U2, __enable_if_t<
-            _CheckArgs::template __is_pair_constructible<_U1&, _U2&>()
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    explicit(!_CheckArgs::template __is_implicit<_U1&, _U2&>()) pair(pair<_U1, _U2>& __p)
-        noexcept((is_nothrow_constructible<first_type, _U1&>::value &&
-                  is_nothrow_constructible<second_type, _U2&>::value))
-        : first(__p.first), second(__p.second) {}
-#endif
-
-    template<class _U1, class _U2, typename enable_if<
-            _CheckArgs::template __enable_explicit<_U1 const&, _U2 const&>()
-    >::type* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit pair(pair<_U1, _U2> const& __p)
-        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
-                    is_nothrow_constructible<second_type, _U2 const&>::value))
-        : first(__p.first), second(__p.second) {}
-
-    template<class _U1, class _U2, typename enable_if<
-            _CheckArgs::template __enable_implicit<_U1 const&, _U2 const&>()
-    >::type* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair(pair<_U1, _U2> const& __p)
-        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1 const&>::value &&
-                    is_nothrow_constructible<second_type, _U2 const&>::value))
-        : first(__p.first), second(__p.second) {}
-
-    template<class _U1, class _U2, typename enable_if<
-            _CheckArgs::template __enable_explicit<_U1, _U2>()
-    >::type* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit pair(pair<_U1, _U2>&&__p)
-        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
-                    is_nothrow_constructible<second_type, _U2&&>::value))
-        : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) {}
-
-    template<class _U1, class _U2, typename enable_if<
-            _CheckArgs::template __enable_implicit<_U1, _U2>()
-    >::type* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair(pair<_U1, _U2>&& __p)
-        _NOEXCEPT_((is_nothrow_constructible<first_type, _U1&&>::value &&
-                    is_nothrow_constructible<second_type, _U2&&>::value))
-        : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) {}
-
-#if _LIBCPP_STD_VER >= 23
-    template<class _U1, class _U2, __enable_if_t<
-            _CheckArgs::template __is_pair_constructible<const _U1&&, const _U2&&>()
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    explicit(!_CheckArgs::template __is_implicit<const _U1&&, const _U2&&>())
-    pair(const pair<_U1, _U2>&& __p)
-        noexcept(is_nothrow_constructible<first_type, const _U1&&>::value &&
-                 is_nothrow_constructible<second_type, const _U2&&>::value)
-        : first(std::move(__p.first)), second(std::move(__p.second)) {}
-#endif
+  template <
+#  if _LIBCPP_STD_VER >= 23 // http://wg21.link/P1951
+      class _U1 = _T1,
+      class _U2 = _T2,
+#  else
+      class _U1,
+      class _U2,
+#  endif
+      __enable_if_t<_CheckArgs::template __is_pair_constructible<_U1, _U2>(), int> = 0 >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(!_CheckArgs::template __is_implicit<_U1, _U2>())
+      pair(_U1&& __u1, _U2&& __u2) noexcept(is_nothrow_constructible<first_type, _U1>::value &&
+                                            is_nothrow_constructible<second_type, _U2>::value)
+      : first(std::forward<_U1>(__u1)), second(std::forward<_U2>(__u2)) {
+  }
 
 #  if _LIBCPP_STD_VER >= 23
-    // This is a workaround for http://llvm.org/PR60710. We should be able to remove it once Clang is fixed.
-    template <class _PairLike, bool _Enable = tuple_size<remove_cvref_t<_PairLike>>::value == 2>
-    _LIBCPP_HIDE_FROM_ABI static constexpr bool __pair_like_explicit_wknd() {
-        if constexpr (tuple_size<remove_cvref_t<_PairLike>>::value == 2) {
-            return !is_convertible_v<decltype(std::get<0>(std::declval<_PairLike&&>())), first_type> ||
-                   !is_convertible_v<decltype(std::get<1>(std::declval<_PairLike&&>())), second_type>;
-        }
-        return false;
-    }
-
-    template <__pair_like _PairLike>
-      requires(is_constructible_v<first_type, decltype(std::get<0>(std::declval<_PairLike&&>()))> &&
-               is_constructible_v<second_type, decltype(std::get<1>(std::declval<_PairLike&&>()))>)
-    _LIBCPP_HIDE_FROM_ABI constexpr explicit(__pair_like_explicit_wknd<_PairLike>())
-        pair(_PairLike&& __p)
-        : first(std::get<0>(std::forward<_PairLike>(__p))), second(std::get<1>(std::forward<_PairLike>(__p))) {}
+  template <class _U1, class _U2, __enable_if_t<_CheckArgs::template __is_pair_constructible<_U1&, _U2&>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_CheckArgs::template __is_implicit<_U1&, _U2&>())
+      pair(pair<_U1, _U2>& __p) noexcept((is_nothrow_constructible<first_type, _U1&>::value &&
+                                          is_nothrow_constructible<second_type, _U2&>::value))
+      : first(__p.first), second(__p.second) {}
 #  endif
 
-    template <class... _Args1, class... _Args2>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    pair(piecewise_construct_t __pc,
-         tuple<_Args1...> __first_args, tuple<_Args2...> __second_args)
-        _NOEXCEPT_((is_nothrow_constructible<first_type, _Args1...>::value &&
-                    is_nothrow_constructible<second_type, _Args2...>::value))
-        : pair(__pc, __first_args, __second_args,
-                typename __make_tuple_indices<sizeof...(_Args1)>::type(),
-                typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
+  template <class _U1,
+            class _U2,
+            __enable_if_t<_CheckArgs::template __is_pair_constructible<_U1 const&, _U2 const&>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(!_CheckArgs::template __is_implicit<_U1 const&, _U2 const&>())
+      pair(pair<_U1, _U2> const& __p) noexcept(is_nothrow_constructible<first_type, _U1 const&>::value &&
+                                               is_nothrow_constructible<second_type, _U2 const&>::value)
+      : first(__p.first), second(__p.second) {}
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    pair& operator=(__conditional_t<
-                        is_copy_assignable<first_type>::value &&
-                        is_copy_assignable<second_type>::value,
-                    pair, __nat> const& __p)
-        _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
-                   is_nothrow_copy_assignable<second_type>::value)
-    {
-        first = __p.first;
-        second = __p.second;
-        return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    pair& operator=(__conditional_t<
-                        is_move_assignable<first_type>::value &&
-                        is_move_assignable<second_type>::value,
-                    pair, __nat>&& __p)
-        _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
-                   is_nothrow_move_assignable<second_type>::value)
-    {
-        first = std::forward<first_type>(__p.first);
-        second = std::forward<second_type>(__p.second);
-        return *this;
-    }
-
-    template <class _U1, class _U2, __enable_if_t<
-        is_assignable<first_type&, _U1 const&>::value &&
-        is_assignable<second_type&, _U2 const&>::value
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    pair& operator=(pair<_U1, _U2> const& __p) {
-        first = __p.first;
-        second = __p.second;
-        return *this;
-    }
-
-    template <class _U1, class _U2, __enable_if_t<
-        is_assignable<first_type&, _U1>::value &&
-        is_assignable<second_type&, _U2>::value
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    pair& operator=(pair<_U1, _U2>&& __p) {
-        first = std::forward<_U1>(__p.first);
-        second = std::forward<_U2>(__p.second);
-        return *this;
-    }
+  template <class _U1, class _U2, __enable_if_t<_CheckArgs::template __is_pair_constructible<_U1, _U2>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(!_CheckArgs::template __is_implicit<_U1, _U2>())
+      pair(pair<_U1, _U2>&& __p) noexcept(is_nothrow_constructible<first_type, _U1&&>::value &&
+                                          is_nothrow_constructible<second_type, _U2&&>::value)
+      : first(std::forward<_U1>(__p.first)), second(std::forward<_U2>(__p.second)) {}
 
 #  if _LIBCPP_STD_VER >= 23
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    const pair& operator=(pair const& __p) const
-      noexcept(is_nothrow_copy_assignable_v<const first_type> &&
-               is_nothrow_copy_assignable_v<const second_type>)
-      requires(is_copy_assignable_v<const first_type> &&
-               is_copy_assignable_v<const second_type>) {
-        first = __p.first;
-        second = __p.second;
-        return *this;
-    }
+  template <class _U1,
+            class _U2,
+            __enable_if_t<_CheckArgs::template __is_pair_constructible<const _U1&&, const _U2&&>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_CheckArgs::template __is_implicit<const _U1&&, const _U2&&>())
+      pair(const pair<_U1, _U2>&& __p) noexcept(is_nothrow_constructible<first_type, const _U1&&>::value &&
+                                                is_nothrow_constructible<second_type, const _U2&&>::value)
+      : first(std::move(__p.first)), second(std::move(__p.second)) {}
+#  endif
 
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    const pair& operator=(pair&& __p) const
+#  if _LIBCPP_STD_VER >= 23
+  // TODO: Remove this workaround in LLVM 20. The bug got fixed in Clang 18.
+  // This is a workaround for http://llvm.org/PR60710. We should be able to remove it once Clang is fixed.
+  template <class _PairLike>
+  _LIBCPP_HIDE_FROM_ABI static constexpr bool __pair_like_explicit_wknd() {
+    if constexpr (__pair_like_no_subrange<_PairLike>) {
+      return !is_convertible_v<decltype(std::get<0>(std::declval<_PairLike&&>())), first_type> ||
+             !is_convertible_v<decltype(std::get<1>(std::declval<_PairLike&&>())), second_type>;
+    }
+    return false;
+  }
+
+  template <__pair_like_no_subrange _PairLike>
+    requires(is_constructible_v<first_type, decltype(std::get<0>(std::declval<_PairLike &&>()))> &&
+             is_constructible_v<second_type, decltype(std::get<1>(std::declval<_PairLike &&>()))>)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(__pair_like_explicit_wknd<_PairLike>()) pair(_PairLike&& __p)
+      : first(std::get<0>(std::forward<_PairLike>(__p))), second(std::get<1>(std::forward<_PairLike>(__p))) {}
+#  endif
+
+  template <class... _Args1, class... _Args2>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, tuple<_Args2...> __second_args) noexcept(
+      is_nothrow_constructible<first_type, _Args1...>::value && is_nothrow_constructible<second_type, _Args2...>::value)
+      : pair(__pc,
+             __first_args,
+             __second_args,
+             typename __make_tuple_indices<sizeof...(_Args1)>::type(),
+             typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair&
+  operator=(__conditional_t<!__has_defaulted_members::value && is_copy_assignable<first_type>::value &&
+                                is_copy_assignable<second_type>::value,
+                            pair,
+                            __nat> const& __p) noexcept(is_nothrow_copy_assignable<first_type>::value &&
+                                                        is_nothrow_copy_assignable<second_type>::value) {
+    first  = __p.first;
+    second = __p.second;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair&
+  operator=(__conditional_t<!__has_defaulted_members::value && is_move_assignable<first_type>::value &&
+                                is_move_assignable<second_type>::value,
+                            pair,
+                            __nat>&& __p) noexcept(is_nothrow_move_assignable<first_type>::value &&
+                                                   is_nothrow_move_assignable<second_type>::value) {
+    first  = std::forward<first_type>(__p.first);
+    second = std::forward<second_type>(__p.second);
+    return *this;
+  }
+
+  template <
+      class _U1,
+      class _U2,
+      __enable_if_t<is_assignable<first_type&, _U1 const&>::value && is_assignable<second_type&, _U2 const&>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair& operator=(pair<_U1, _U2> const& __p) {
+    first  = __p.first;
+    second = __p.second;
+    return *this;
+  }
+
+  template <class _U1,
+            class _U2,
+            __enable_if_t<is_assignable<first_type&, _U1>::value && is_assignable<second_type&, _U2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair& operator=(pair<_U1, _U2>&& __p) {
+    first  = std::forward<_U1>(__p.first);
+    second = std::forward<_U2>(__p.second);
+    return *this;
+  }
+
+#  if _LIBCPP_STD_VER >= 23
+  template <class = void>
+  _LIBCPP_HIDE_FROM_ABI constexpr const pair& operator=(pair const& __p) const
+      noexcept(is_nothrow_copy_assignable_v<const first_type> && is_nothrow_copy_assignable_v<const second_type>)
+    requires(is_copy_assignable_v<const first_type> && is_copy_assignable_v<const second_type>)
+  {
+    first  = __p.first;
+    second = __p.second;
+    return *this;
+  }
+
+  template <class = void>
+  _LIBCPP_HIDE_FROM_ABI constexpr const pair& operator=(pair&& __p) const
       noexcept(is_nothrow_assignable_v<const first_type&, first_type> &&
                is_nothrow_assignable_v<const second_type&, second_type>)
-      requires(is_assignable_v<const first_type&, first_type> &&
-               is_assignable_v<const second_type&, second_type>) {
-        first = std::forward<first_type>(__p.first);
-        second = std::forward<second_type>(__p.second);
-        return *this;
-    }
+    requires(is_assignable_v<const first_type&, first_type> && is_assignable_v<const second_type&, second_type>)
+  {
+    first  = std::forward<first_type>(__p.first);
+    second = std::forward<second_type>(__p.second);
+    return *this;
+  }
 
-    template<class _U1, class _U2>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    const pair& operator=(const pair<_U1, _U2>& __p) const
-      requires(is_assignable_v<const first_type&, const _U1&> &&
-               is_assignable_v<const second_type&, const _U2&>) {
-        first = __p.first;
-        second = __p.second;
-        return *this;
-    }
+  template <class _U1, class _U2>
+  _LIBCPP_HIDE_FROM_ABI constexpr const pair& operator=(const pair<_U1, _U2>& __p) const
+    requires(is_assignable_v<const first_type&, const _U1&> && is_assignable_v<const second_type&, const _U2&>)
+  {
+    first  = __p.first;
+    second = __p.second;
+    return *this;
+  }
 
-    template<class _U1, class _U2>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    const pair& operator=(pair<_U1, _U2>&& __p) const
-      requires(is_assignable_v<const first_type&, _U1> &&
-               is_assignable_v<const second_type&, _U2>) {
-        first = std::forward<_U1>(__p.first);
-        second = std::forward<_U2>(__p.second);
-        return *this;
-    }
+  template <class _U1, class _U2>
+  _LIBCPP_HIDE_FROM_ABI constexpr const pair& operator=(pair<_U1, _U2>&& __p) const
+    requires(is_assignable_v<const first_type&, _U1> && is_assignable_v<const second_type&, _U2>)
+  {
+    first  = std::forward<_U1>(__p.first);
+    second = std::forward<_U2>(__p.second);
+    return *this;
+  }
 
-    template <__pair_like _PairLike>
-      requires(__different_from<_PairLike, pair> &&
-               !__is_specialization_of_subrange<remove_cvref_t<_PairLike>>::value &&
-               is_assignable_v<first_type&, decltype(std::get<0>(std::declval<_PairLike>()))> &&
-               is_assignable_v<second_type&, decltype(std::get<1>(std::declval<_PairLike>()))>)
-    _LIBCPP_HIDE_FROM_ABI constexpr pair& operator=(_PairLike&& __p) {
-        first  = std::get<0>(std::forward<_PairLike>(__p));
-        second = std::get<1>(std::forward<_PairLike>(__p));
-        return *this;
-    }
+  template <__pair_like_no_subrange _PairLike>
+    requires(__different_from<_PairLike, pair> &&
+             is_assignable_v<first_type&, decltype(std::get<0>(std::declval<_PairLike>()))> &&
+             is_assignable_v<second_type&, decltype(std::get<1>(std::declval<_PairLike>()))>)
+  _LIBCPP_HIDE_FROM_ABI constexpr pair& operator=(_PairLike&& __p) {
+    first  = std::get<0>(std::forward<_PairLike>(__p));
+    second = std::get<1>(std::forward<_PairLike>(__p));
+    return *this;
+  }
 
-    template <__pair_like _PairLike>
-      requires(__different_from<_PairLike, pair> &&
-               !__is_specialization_of_subrange<remove_cvref_t<_PairLike>>::value &&
-               is_assignable_v<first_type const&, decltype(std::get<0>(std::declval<_PairLike>()))> &&
-               is_assignable_v<second_type const&, decltype(std::get<1>(std::declval<_PairLike>()))>)
-    _LIBCPP_HIDE_FROM_ABI constexpr pair const& operator=(_PairLike&& __p) const {
-        first  = std::get<0>(std::forward<_PairLike>(__p));
-        second = std::get<1>(std::forward<_PairLike>(__p));
-        return *this;
-    }
+  template <__pair_like_no_subrange _PairLike>
+    requires(__different_from<_PairLike, pair> &&
+             is_assignable_v<first_type const&, decltype(std::get<0>(std::declval<_PairLike>()))> &&
+             is_assignable_v<second_type const&, decltype(std::get<1>(std::declval<_PairLike>()))>)
+  _LIBCPP_HIDE_FROM_ABI constexpr pair const& operator=(_PairLike&& __p) const {
+    first  = std::get<0>(std::forward<_PairLike>(__p));
+    second = std::get<1>(std::forward<_PairLike>(__p));
+    return *this;
+  }
 #  endif // _LIBCPP_STD_VER >= 23
 
-    // Prior to C++23, we provide an approximation of constructors and assignment operators from
-    // pair-like types. This was historically provided as an extension.
-#if _LIBCPP_STD_VER < 23
-    // from std::tuple
-    template<class _U1, class _U2, __enable_if_t<
-        is_convertible<_U1 const&, _T1>::value &&
-        is_convertible<_U2 const&, _T2>::value
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair(tuple<_U1, _U2> const& __p)
-        : first(std::get<0>(__p)),
-          second(std::get<1>(__p)) {}
+  // Prior to C++23, we provide an approximation of constructors and assignment operators from
+  // pair-like types. This was historically provided as an extension.
+#  if _LIBCPP_STD_VER < 23
+  // from std::tuple
+  template <class _U1,
+            class _U2,
+            __enable_if_t<is_convertible<_U1 const&, _T1>::value && is_convertible<_U2 const&, _T2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(tuple<_U1, _U2> const& __p)
+      : first(std::get<0>(__p)), second(std::get<1>(__p)) {}
 
-    template<class _U1, class _U2, __enable_if_t<
-        is_constructible<_T1, _U1 const&>::value &&
-        is_constructible<_T2, _U2 const&>::value &&
-        !(is_convertible<_U1 const&, _T1>::value &&
-          is_convertible<_U2 const&, _T2>::value)
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit
-    pair(tuple<_U1, _U2> const& __p)
-        : first(std::get<0>(__p)),
-          second(std::get<1>(__p)) {}
+  template < class _U1,
+             class _U2,
+             __enable_if_t<is_constructible<_T1, _U1 const&>::value && is_constructible<_T2, _U2 const&>::value &&
+                               !(is_convertible<_U1 const&, _T1>::value && is_convertible<_U2 const&, _T2>::value),
+                           int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(tuple<_U1, _U2> const& __p)
+      : first(std::get<0>(__p)), second(std::get<1>(__p)) {}
 
-    template<class _U1, class _U2, __enable_if_t<
-        is_convertible<_U1, _T1>::value &&
-        is_convertible<_U2, _T2>::value
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair(tuple<_U1, _U2>&& __p)
-        : first(std::get<0>(std::move(__p))),
-          second(std::get<1>(std::move(__p))) {}
+  template <class _U1,
+            class _U2,
+            __enable_if_t<is_convertible<_U1, _T1>::value && is_convertible<_U2, _T2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(tuple<_U1, _U2>&& __p)
+      : first(std::get<0>(std::move(__p))), second(std::get<1>(std::move(__p))) {}
 
-    template<class _U1, class _U2, __enable_if_t<
-        is_constructible<_T1, _U1>::value &&
-        is_constructible<_T2, _U2>::value &&
-        !(is_convertible<_U1, _T1>::value &&
-          is_convertible<_U2, _T2>::value)
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit
-    pair(tuple<_U1, _U2>&& __p)
-        : first(std::get<0>(std::move(__p))),
-          second(std::get<1>(std::move(__p))) {}
+  template <class _U1,
+            class _U2,
+            __enable_if_t<is_constructible<_T1, _U1>::value && is_constructible<_T2, _U2>::value &&
+                          !(is_convertible<_U1, _T1>::value && is_convertible<_U2, _T2>::value) > = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(tuple<_U1, _U2>&& __p)
+      : first(std::get<0>(std::move(__p))), second(std::get<1>(std::move(__p))) {}
 
+  template <class _U1,
+            class _U2,
+            __enable_if_t<is_assignable<_T1&, _U1 const&>::value && is_assignable<_T2&, _U2 const&>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair& operator=(tuple<_U1, _U2> const& __p) {
+    first  = std::get<0>(__p);
+    second = std::get<1>(__p);
+    return *this;
+  }
 
-    template<class _U1, class _U2, __enable_if_t<
-        is_assignable<_T1&, _U1 const&>::value &&
-        is_assignable<_T2&, _U2 const&>::value
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair& operator=(tuple<_U1, _U2> const& __p) {
-        first = std::get<0>(__p);
-        second = std::get<1>(__p);
-        return *this;
-    }
+  template <class _U1,
+            class _U2,
+            __enable_if_t<is_assignable<_T1&, _U1&&>::value && is_assignable<_T2&, _U2&&>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair& operator=(tuple<_U1, _U2>&& __p) {
+    first  = std::get<0>(std::move(__p));
+    second = std::get<1>(std::move(__p));
+    return *this;
+  }
 
-    template<class _U1, class _U2, __enable_if_t<
-        is_assignable<_T1&, _U1&&>::value &&
-        is_assignable<_T2&, _U2&&>::value
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair& operator=(tuple<_U1, _U2>&& __p) {
-        first = std::get<0>(std::move(__p));
-        second = std::get<1>(std::move(__p));
-        return *this;
-    }
+  // from std::array
+  template <class _Up,
+            __enable_if_t<is_convertible<_Up const&, _T1>::value && is_convertible<_Up const&, _T2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(array<_Up, 2> const& __p) : first(__p[0]), second(__p[1]) {}
 
-    // from std::array
-    template<class _Up, __enable_if_t<
-        is_convertible<_Up const&, _T1>::value &&
-        is_convertible<_Up const&, _T2>::value
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair(array<_Up, 2> const& __p)
-        : first(__p[0]),
-          second(__p[1]) {}
+  template <class _Up,
+            __enable_if_t<is_constructible<_T1, _Up const&>::value && is_constructible<_T2, _Up const&>::value &&
+                              !(is_convertible<_Up const&, _T1>::value && is_convertible<_Up const&, _T2>::value),
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(array<_Up, 2> const& __p)
+      : first(__p[0]), second(__p[1]) {}
 
-    template<class _Up, __enable_if_t<
-        is_constructible<_T1, _Up const&>::value &&
-        is_constructible<_T2, _Up const&>::value &&
-        !(is_convertible<_Up const&, _T1>::value &&
-          is_convertible<_Up const&, _T2>::value)
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit
-    pair(array<_Up, 2> const& __p)
-        : first(__p[0]),
-          second(__p[1]) {}
+  template <class _Up, __enable_if_t< is_convertible<_Up, _T1>::value && is_convertible<_Up, _T2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair(array<_Up, 2>&& __p)
+      : first(std::move(__p)[0]), second(std::move(__p)[1]) {}
 
-    template<class _Up, __enable_if_t<
-        is_convertible<_Up, _T1>::value &&
-        is_convertible<_Up, _T2>::value
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair(array<_Up, 2>&& __p)
-        : first(std::move(__p)[0]),
-          second(std::move(__p)[1]) {}
+  template <class _Up,
+            __enable_if_t<is_constructible<_T1, _Up>::value && is_constructible<_T2, _Up>::value &&
+                              !(is_convertible<_Up, _T1>::value && is_convertible<_Up, _T2>::value),
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit pair(array<_Up, 2>&& __p)
+      : first(std::move(__p)[0]), second(std::move(__p)[1]) {}
 
-    template<class _Up, __enable_if_t<
-        is_constructible<_T1, _Up>::value &&
-        is_constructible<_T2, _Up>::value &&
-        !(is_convertible<_Up, _T1>::value &&
-          is_convertible<_Up, _T2>::value)
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit
-    pair(array<_Up, 2>&& __p)
-        : first(std::move(__p)[0]),
-          second(std::move(__p)[1]) {}
+  template <class _Up,
+            __enable_if_t<is_assignable<_T1&, _Up const&>::value && is_assignable<_T2&, _Up const&>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair& operator=(array<_Up, 2> const& __p) {
+    first  = std::get<0>(__p);
+    second = std::get<1>(__p);
+    return *this;
+  }
 
+  template <class _Up, __enable_if_t<is_assignable<_T1&, _Up>::value && is_assignable<_T2&, _Up>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair& operator=(array<_Up, 2>&& __p) {
+    first  = std::get<0>(std::move(__p));
+    second = std::get<1>(std::move(__p));
+    return *this;
+  }
+#  endif // _LIBCPP_STD_VER < 23
+#endif   // _LIBCPP_CXX03_LANG
 
-    template<class _Up, __enable_if_t<
-        is_assignable<_T1&, _Up const&>::value &&
-        is_assignable<_T2&, _Up const&>::value
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair& operator=(array<_Up, 2> const& __p) {
-        first = std::get<0>(__p);
-        second = std::get<1>(__p);
-        return *this;
-    }
-
-    template<class _Up, __enable_if_t<
-        is_assignable<_T1&, _Up>::value &&
-        is_assignable<_T2&, _Up>::value
-    >* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    pair& operator=(array<_Up, 2>&& __p) {
-        first = std::get<0>(std::move(__p));
-        second = std::get<1>(std::move(__p));
-        return *this;
-    }
-#endif // _LIBCPP_STD_VER < 23
-#endif // _LIBCPP_CXX03_LANG
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void
-    swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
-                               __is_nothrow_swappable<second_type>::value)
-    {
-        using std::swap;
-        swap(first,  __p.first);
-        swap(second, __p.second);
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(pair& __p)
+      _NOEXCEPT_(__is_nothrow_swappable_v<first_type>&& __is_nothrow_swappable_v<second_type>) {
+    using std::swap;
+    swap(first, __p.first);
+    swap(second, __p.second);
+  }
 
 #if _LIBCPP_STD_VER >= 23
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    void swap(const pair& __p) const
-        noexcept(__is_nothrow_swappable<const first_type>::value &&
-                 __is_nothrow_swappable<const second_type>::value)
-    {
-        using std::swap;
-        swap(first,  __p.first);
-        swap(second, __p.second);
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr void swap(const pair& __p) const
+      noexcept(__is_nothrow_swappable_v<const first_type> && __is_nothrow_swappable_v<const second_type>) {
+    using std::swap;
+    swap(first, __p.first);
+    swap(second, __p.second);
+  }
 #endif
-private:
 
+private:
 #ifndef _LIBCPP_CXX03_LANG
-    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    pair(piecewise_construct_t,
-         tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
-         __tuple_indices<_I1...>, __tuple_indices<_I2...>);
+  template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  pair(piecewise_construct_t,
+       tuple<_Args1...>& __first_args,
+       tuple<_Args2...>& __second_args,
+       __tuple_indices<_I1...>,
+       __tuple_indices<_I2...>)
+      : first(std::forward<_Args1>(std::get<_I1>(__first_args))...),
+        second(std::forward<_Args2>(std::get<_I2>(__second_args))...) {}
 #endif
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _T1, class _T2>
+template <class _T1, class _T2>
 pair(_T1, _T2) -> pair<_T1, _T2>;
 #endif
 
 // [pairs.spec], specialized algorithms
 
 template <class _T1, class _T2, class _U1, class _U2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator==(const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
-{
-    return __x.first == __y.first && __x.second == __y.second;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator==(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) {
+  return __x.first == __y.first && __x.second == __y.second;
 }
 
 #if _LIBCPP_STD_VER >= 20
 
 template <class _T1, class _T2, class _U1, class _U2>
-_LIBCPP_HIDE_FROM_ABI constexpr
-common_comparison_category_t<
-        __synth_three_way_result<_T1, _U1>,
-        __synth_three_way_result<_T2, _U2> >
-operator<=>(const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
-{
-    if (auto __c = std::__synth_three_way(__x.first, __y.first); __c != 0) {
-      return __c;
-    }
-    return std::__synth_three_way(__x.second, __y.second);
+_LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t< __synth_three_way_result<_T1, _U1>,
+                                                              __synth_three_way_result<_T2, _U2> >
+operator<=>(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) {
+  if (auto __c = std::__synth_three_way(__x.first, __y.first); __c != 0) {
+    return __c;
+  }
+  return std::__synth_three_way(__x.second, __y.second);
 }
 
 #else // _LIBCPP_STD_VER >= 20
 
 template <class _T1, class _T2, class _U1, class _U2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator!=(const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator!=(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) {
+  return !(__x == __y);
 }
 
 template <class _T1, class _T2, class _U1, class _U2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator< (const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
-{
-    return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator<(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) {
+  return __x.first < __y.first || (!(__y.first < __x.first) && __x.second < __y.second);
 }
 
 template <class _T1, class _T2, class _U1, class _U2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator> (const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator>(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) {
+  return __y < __x;
 }
 
 template <class _T1, class _T2, class _U1, class _U2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator>=(const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator>=(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) {
+  return !(__x < __y);
 }
 
 template <class _T1, class _T2, class _U1, class _U2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator<=(const pair<_T1,_T2>& __x, const pair<_U1,_U2>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator<=(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y) {
+  return !(__y < __x);
 }
 
 #endif // _LIBCPP_STD_VER >= 20
 
 #if _LIBCPP_STD_VER >= 23
-template <class _T1, class _T2, class _U1, class _U2, template<class> class _TQual, template<class> class _UQual>
-    requires requires { typename pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
-                                      common_reference_t<_TQual<_T2>, _UQual<_U2>>>; }
+template <class _T1, class _T2, class _U1, class _U2, template <class> class _TQual, template <class> class _UQual>
+  requires requires {
+    typename pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>, common_reference_t<_TQual<_T2>, _UQual<_U2>>>;
+  }
 struct basic_common_reference<pair<_T1, _T2>, pair<_U1, _U2>, _TQual, _UQual> {
-    using type = pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
-                      common_reference_t<_TQual<_T2>, _UQual<_U2>>>;
+  using type = pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>, common_reference_t<_TQual<_T2>, _UQual<_U2>>>;
 };
 
 template <class _T1, class _T2, class _U1, class _U2>
-    requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; }
+  requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; }
 struct common_type<pair<_T1, _T2>, pair<_U1, _U2>> {
-    using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>;
+  using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>;
 };
 #endif // _LIBCPP_STD_VER >= 23
 
-template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __is_swappable<_T1>::value &&
-    __is_swappable<_T2>::value,
-    void
->::type
-swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
-                     _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
-                                 __is_nothrow_swappable<_T2>::value))
-{
-    __x.swap(__y);
+template <class _T1, class _T2, __enable_if_t<__is_swappable_v<_T1> && __is_swappable_v<_T2>, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
+    _NOEXCEPT_(__is_nothrow_swappable_v<_T1>&& __is_nothrow_swappable_v<_T2>) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 23
 template <class _T1, class _T2>
-  requires (__is_swappable<const _T1>::value &&
-            __is_swappable<const _T2>::value)
-_LIBCPP_HIDE_FROM_ABI constexpr
-void swap(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
-    noexcept(noexcept(__x.swap(__y)))
-{
-    __x.swap(__y);
+  requires(__is_swappable_v<const _T1> && __is_swappable_v<const _T2>)
+_LIBCPP_HIDE_FROM_ABI constexpr void
+swap(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) noexcept(noexcept(__x.swap(__y))) {
+  __x.swap(__y);
 }
 #endif
 
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
-make_pair(_T1&& __t1, _T2&& __t2)
-{
-    return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
-               (std::forward<_T1>(__t1), std::forward<_T2>(__t2));
+inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX14 pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>
+make_pair(_T1&& __t1, _T2&& __t2) {
+  return pair<typename __unwrap_ref_decay<_T1>::type, typename __unwrap_ref_decay<_T2>::type>(
+      std::forward<_T1>(__t1), std::forward<_T2>(__t2));
 }
 
 template <class _T1, class _T2>
-  struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> >
-    : public integral_constant<size_t, 2> {};
+struct _LIBCPP_TEMPLATE_VIS tuple_size<pair<_T1, _T2> > : public integral_constant<size_t, 2> {};
 
 template <size_t _Ip, class _T1, class _T2>
-struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> >
-{
-    static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, pair<_T1, _T2> > {
+  static_assert(_Ip < 2, "Index out of bounds in std::tuple_element<std::pair<T1, T2>>");
 };
 
 template <class _T1, class _T2>
-struct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> >
-{
-    using type _LIBCPP_NODEBUG = _T1;
+struct _LIBCPP_TEMPLATE_VIS tuple_element<0, pair<_T1, _T2> > {
+  using type _LIBCPP_NODEBUG = _T1;
 };
 
 template <class _T1, class _T2>
-struct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> >
-{
-    using type _LIBCPP_NODEBUG = _T2;
+struct _LIBCPP_TEMPLATE_VIS tuple_element<1, pair<_T1, _T2> > {
+  using type _LIBCPP_NODEBUG = _T2;
 };
 
-template <size_t _Ip> struct __get_pair;
+template <size_t _Ip>
+struct __get_pair;
 
 template <>
-struct __get_pair<0>
-{
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    _T1&
-    get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
+struct __get_pair<0> {
+  template <class _T1, class _T2>
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _T1& get(pair<_T1, _T2>& __p) _NOEXCEPT {
+    return __p.first;
+  }
 
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const _T1&
-    get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
+  template <class _T1, class _T2>
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _T1& get(const pair<_T1, _T2>& __p) _NOEXCEPT {
+    return __p.first;
+  }
 
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    _T1&&
-    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward<_T1>(__p.first);}
+  template <class _T1, class _T2>
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _T1&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {
+    return std::forward<_T1>(__p.first);
+  }
 
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const _T1&&
-    get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward<const _T1>(__p.first);}
+  template <class _T1, class _T2>
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _T1&& get(const pair<_T1, _T2>&& __p) _NOEXCEPT {
+    return std::forward<const _T1>(__p.first);
+  }
 };
 
 template <>
-struct __get_pair<1>
-{
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    _T2&
-    get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
+struct __get_pair<1> {
+  template <class _T1, class _T2>
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _T2& get(pair<_T1, _T2>& __p) _NOEXCEPT {
+    return __p.second;
+  }
 
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const _T2&
-    get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
+  template <class _T1, class _T2>
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _T2& get(const pair<_T1, _T2>& __p) _NOEXCEPT {
+    return __p.second;
+  }
 
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    _T2&&
-    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward<_T2>(__p.second);}
+  template <class _T1, class _T2>
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _T2&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {
+    return std::forward<_T2>(__p.second);
+  }
 
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const _T2&&
-    get(const pair<_T1, _T2>&& __p) _NOEXCEPT {return std::forward<const _T2>(__p.second);}
+  template <class _T1, class _T2>
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _T2&& get(const pair<_T1, _T2>&& __p) _NOEXCEPT {
+    return std::forward<const _T2>(__p.second);
+  }
 };
 
 template <size_t _Ip, class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(pair<_T1, _T2>& __p) _NOEXCEPT
-{
-    return __get_pair<_Ip>::get(__p);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
+get(pair<_T1, _T2>& __p) _NOEXCEPT {
+  return __get_pair<_Ip>::get(__p);
 }
 
 template <size_t _Ip, class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(const pair<_T1, _T2>& __p) _NOEXCEPT
-{
-    return __get_pair<_Ip>::get(__p);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
+get(const pair<_T1, _T2>& __p) _NOEXCEPT {
+  return __get_pair<_Ip>::get(__p);
 }
 
 template <size_t _Ip, class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
-get(pair<_T1, _T2>&& __p) _NOEXCEPT
-{
-    return __get_pair<_Ip>::get(std::move(__p));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+get(pair<_T1, _T2>&& __p) _NOEXCEPT {
+  return __get_pair<_Ip>::get(std::move(__p));
 }
 
 template <size_t _Ip, class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
-get(const pair<_T1, _T2>&& __p) _NOEXCEPT
-{
-    return __get_pair<_Ip>::get(std::move(__p));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+get(const pair<_T1, _T2>&& __p) _NOEXCEPT {
+  return __get_pair<_Ip>::get(std::move(__p));
 }
 
 #if _LIBCPP_STD_VER >= 14
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr _T1 & get(pair<_T1, _T2>& __p) _NOEXCEPT
-{
-    return __get_pair<0>::get(__p);
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(pair<_T1, _T2>& __p) _NOEXCEPT {
+  return __get_pair<0>::get(__p);
 }
 
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr _T1 const & get(pair<_T1, _T2> const& __p) _NOEXCEPT
-{
-    return __get_pair<0>::get(__p);
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(pair<_T1, _T2> const& __p) _NOEXCEPT {
+  return __get_pair<0>::get(__p);
 }
 
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr _T1 && get(pair<_T1, _T2>&& __p) _NOEXCEPT
-{
-    return __get_pair<0>::get(std::move(__p));
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {
+  return __get_pair<0>::get(std::move(__p));
 }
 
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr _T1 const && get(pair<_T1, _T2> const&& __p) _NOEXCEPT
-{
-    return __get_pair<0>::get(std::move(__p));
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(pair<_T1, _T2> const&& __p) _NOEXCEPT {
+  return __get_pair<0>::get(std::move(__p));
 }
 
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr _T1 & get(pair<_T2, _T1>& __p) _NOEXCEPT
-{
-    return __get_pair<1>::get(__p);
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(pair<_T2, _T1>& __p) _NOEXCEPT {
+  return __get_pair<1>::get(__p);
 }
 
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr _T1 const & get(pair<_T2, _T1> const& __p) _NOEXCEPT
-{
-    return __get_pair<1>::get(__p);
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(pair<_T2, _T1> const& __p) _NOEXCEPT {
+  return __get_pair<1>::get(__p);
 }
 
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr _T1 && get(pair<_T2, _T1>&& __p) _NOEXCEPT
-{
-    return __get_pair<1>::get(std::move(__p));
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(pair<_T2, _T1>&& __p) _NOEXCEPT {
+  return __get_pair<1>::get(std::move(__p));
 }
 
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr _T1 const && get(pair<_T2, _T1> const&& __p) _NOEXCEPT
-{
-    return __get_pair<1>::get(std::move(__p));
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(pair<_T2, _T1> const&& __p) _NOEXCEPT {
+  return __get_pair<1>::get(std::move(__p));
 }
 
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___UTILITY_PAIR_H
diff --git a/third_party/libcxx/__utility/piecewise_construct.h b/third_party/libcxx/__utility/piecewise_construct.h
index ad86badb6..52b19d791 100644
--- a/third_party/libcxx/__utility/piecewise_construct.h
+++ b/third_party/libcxx/__utility/piecewise_construct.h
@@ -17,7 +17,9 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct _LIBCPP_TEMPLATE_VIS piecewise_construct_t { explicit piecewise_construct_t() = default; };
+struct _LIBCPP_TEMPLATE_VIS piecewise_construct_t {
+  explicit piecewise_construct_t() = default;
+};
 
 #if _LIBCPP_STD_VER >= 17
 inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
diff --git a/third_party/libcxx/__utility/priority_tag.h b/third_party/libcxx/__utility/priority_tag.h
index e51ba6bfc..a159ce7f1 100644
--- a/third_party/libcxx/__utility/priority_tag.h
+++ b/third_party/libcxx/__utility/priority_tag.h
@@ -18,8 +18,10 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<size_t _Ip> struct __priority_tag : __priority_tag<_Ip - 1> {};
-template<> struct __priority_tag<0> {};
+template <size_t _Ip>
+struct __priority_tag : __priority_tag<_Ip - 1> {};
+template <>
+struct __priority_tag<0> {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/__utility/private_constructor_tag.h b/third_party/libcxx/__utility/private_constructor_tag.h
new file mode 100644
index 000000000..462cab48c
--- /dev/null
+++ b/third_party/libcxx/__utility/private_constructor_tag.h
@@ -0,0 +1,28 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP__UTILITY_PRIVATE_CONSTRUCTOR_TAG_H
+#define _LIBCPP__UTILITY_PRIVATE_CONSTRUCTOR_TAG_H
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// This tag allows defining non-standard exposition-only constructors while
+// preventing users from being able to use them, since this reserved-name tag
+// needs to be used.
+struct __private_constructor_tag {};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP__UTILITY_PRIVATE_CONSTRUCTOR_TAG_H
diff --git a/third_party/libcxx/__utility/rel_ops.h b/third_party/libcxx/__utility/rel_ops.h
index 5f8d42c0b..a8caf5bde 100644
--- a/third_party/libcxx/__utility/rel_ops.h
+++ b/third_party/libcxx/__utility/rel_ops.h
@@ -17,39 +17,26 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace rel_ops
-{
+namespace rel_ops {
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const _Tp& __x, const _Tp& __y)
-{
-    return !(__x == __y);
+template <class _Tp>
+inline _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI bool operator!=(const _Tp& __x, const _Tp& __y) {
+  return !(__x == __y);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator> (const _Tp& __x, const _Tp& __y)
-{
-    return __y < __x;
+template <class _Tp>
+inline _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI bool operator>(const _Tp& __x, const _Tp& __y) {
+  return __y < __x;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const _Tp& __x, const _Tp& __y)
-{
-    return !(__y < __x);
+template <class _Tp>
+inline _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI bool operator<=(const _Tp& __x, const _Tp& __y) {
+  return !(__y < __x);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const _Tp& __x, const _Tp& __y)
-{
-    return !(__x < __y);
+template <class _Tp>
+inline _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI bool operator>=(const _Tp& __x, const _Tp& __y) {
+  return !(__x < __y);
 }
 
 } // namespace rel_ops
diff --git a/third_party/libcxx/__utility/small_buffer.h b/third_party/libcxx/__utility/small_buffer.h
new file mode 100644
index 000000000..9e1379757
--- /dev/null
+++ b/third_party/libcxx/__utility/small_buffer.h
@@ -0,0 +1,99 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___UTILITY_SMALL_BUFFER_H
+#define _LIBCPP___UTILITY_SMALL_BUFFER_H
+
+#include <__config>
+#include <__memory/construct_at.h>
+#include <__type_traits/decay.h>
+#include <__type_traits/is_trivially_constructible.h>
+#include <__type_traits/is_trivially_destructible.h>
+#include <__utility/exception_guard.h>
+#include <__utility/forward.h>
+#include <cstddef>
+#include <new>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+
+// __small_buffer is a helper class to perform the well known SBO (small buffer optimization). It is mainly useful to
+// allow type-erasing classes like move_only_function to store small objects in a local buffer without requiring an
+// allocation.
+//
+// This small buffer class only allows storing trivially relocatable objects inside the local storage to allow
+// __small_buffer to be trivially relocatable itself. Since the buffer doesn't know what's stored inside it, the user
+// has to manage the object's lifetime, in particular the destruction of the object.
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <size_t _BufferSize, size_t _BufferAlignment>
+  requires(_BufferSize > 0 && _BufferAlignment > 0)
+class __small_buffer {
+public:
+  template <class _Tp, class _Decayed = decay_t<_Tp>>
+  static constexpr bool __fits_in_buffer =
+      is_trivially_move_constructible_v<_Decayed> && is_trivially_destructible_v<_Decayed> &&
+      sizeof(_Decayed) <= _BufferSize && alignof(_Decayed) <= _BufferAlignment;
+
+  _LIBCPP_HIDE_FROM_ABI __small_buffer()           = default;
+  __small_buffer(const __small_buffer&)            = delete;
+  __small_buffer& operator=(const __small_buffer&) = delete;
+  _LIBCPP_HIDE_FROM_ABI ~__small_buffer()          = default;
+
+  // Relocates the buffer - __delete() should never be called on a moved-from __small_buffer
+  _LIBCPP_HIDE_FROM_ABI __small_buffer(__small_buffer&&)            = default;
+  _LIBCPP_HIDE_FROM_ABI __small_buffer& operator=(__small_buffer&&) = default;
+
+  template <class _Stored>
+  _LIBCPP_HIDE_FROM_ABI _Stored* __get() {
+    if constexpr (__fits_in_buffer<_Stored>)
+      return std::launder(reinterpret_cast<_Stored*>(__buffer_));
+    else
+      return *std::launder(reinterpret_cast<_Stored**>(__buffer_));
+  }
+
+  template <class _Stored>
+  _LIBCPP_HIDE_FROM_ABI _Stored* __alloc() {
+    if constexpr (__fits_in_buffer<_Stored>) {
+      return std::launder(reinterpret_cast<_Stored*>(__buffer_));
+    } else {
+      byte* __allocation = static_cast<byte*>(::operator new[](sizeof(_Stored), align_val_t{alignof(_Stored)}));
+      std::construct_at(reinterpret_cast<byte**>(__buffer_), __allocation);
+      return std::launder(reinterpret_cast<_Stored*>(__allocation));
+    }
+  }
+
+  template <class _Stored>
+  _LIBCPP_HIDE_FROM_ABI void __dealloc() noexcept {
+    if constexpr (!__fits_in_buffer<_Stored>)
+      ::operator delete[](*reinterpret_cast<void**>(__buffer_), sizeof(_Stored), align_val_t{alignof(_Stored)});
+  }
+
+  template <class _Stored, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void __construct(_Args&&... __args) {
+    _Stored* __buffer = __alloc<_Stored>();
+    auto __guard      = std::__make_exception_guard([&] { __dealloc<_Stored>(); });
+    std::construct_at(__buffer, std::forward<_Args>(__args)...);
+    __guard.__complete();
+  }
+
+private:
+  alignas(_BufferAlignment) byte __buffer_[_BufferSize];
+};
+
+#  undef _LIBCPP_SMALL_BUFFER_TRIVIAL_ABI
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 23
+
+#endif // _LIBCPP___UTILITY_SMALL_BUFFER_H
diff --git a/third_party/libcxx/__utility/swap.h b/third_party/libcxx/__utility/swap.h
index 0843b35a8..ab88b8e0a 100644
--- a/third_party/libcxx/__utility/swap.h
+++ b/third_party/libcxx/__utility/swap.h
@@ -10,10 +10,10 @@
 #define _LIBCPP___UTILITY_SWAP_H
 
 #include <__config>
-#include <__type_traits/is_move_assignable.h>
-#include <__type_traits/is_move_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_swappable.h>
 #include <__utility/declval.h>
 #include <__utility/move.h>
@@ -23,27 +23,30 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp>
-using __swap_result_t = typename enable_if<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>::type;
+using __swap_result_t = __enable_if_t<is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value>;
 #else
 template <class>
 using __swap_result_t = void;
 #endif
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY __swap_result_t<_Tp> _LIBCPP_CONSTEXPR_SINCE_CXX20 swap(_Tp& __x, _Tp& __y)
+inline _LIBCPP_HIDE_FROM_ABI __swap_result_t<_Tp> _LIBCPP_CONSTEXPR_SINCE_CXX20 swap(_Tp& __x, _Tp& __y)
     _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value&& is_nothrow_move_assignable<_Tp>::value) {
-  _Tp __t(_VSTD::move(__x));
-  __x = _VSTD::move(__y);
-  __y = _VSTD::move(__t);
+  _Tp __t(std::move(__x));
+  __x = std::move(__y);
+  __y = std::move(__t);
 }
 
-template <class _Tp, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 typename enable_if<__is_swappable<_Tp>::value>::type
-swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
+template <class _Tp, size_t _Np, __enable_if_t<__is_swappable_v<_Tp>, int> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np])
+    _NOEXCEPT_(__is_nothrow_swappable_v<_Tp>) {
   for (size_t __i = 0; __i != _Np; ++__i) {
     swap(__a[__i], __b[__i]);
   }
@@ -51,4 +54,6 @@ swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::v
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #endif // _LIBCPP___UTILITY_SWAP_H
diff --git a/third_party/libcxx/__utility/terminate_on_exception.h b/third_party/libcxx/__utility/terminate_on_exception.h
deleted file mode 100644
index b539db6be..000000000
--- a/third_party/libcxx/__utility/terminate_on_exception.h
+++ /dev/null
@@ -1,47 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP___UTILITY_TERMINATE_ON_EXCEPTION_H
-#define _LIBCPP___UTILITY_TERMINATE_ON_EXCEPTION_H
-
-#include <__config>
-#include <__exception/terminate.h>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if _LIBCPP_STD_VER >= 17
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-
-template <class _Func>
-_LIBCPP_HIDE_FROM_ABI auto __terminate_on_exception(_Func __func) {
-  try {
-    return __func();
-  } catch (...) {
-    std::terminate();
-  }
-}
-
-#  else // _LIBCPP_HAS_NO_EXCEPTIONS
-
-template <class _Func>
-_LIBCPP_HIDE_FROM_ABI auto __terminate_on_exception(_Func __func) {
-  return __func();
-}
-
-#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP_STD_VER >= 17
-
-#endif // _LIBCPP___UTILITY_TERMINATE_ON_EXCEPTION_H
diff --git a/third_party/libcxx/__utility/to_underlying.h b/third_party/libcxx/__utility/to_underlying.h
index b70f70a74..77587108f 100644
--- a/third_party/libcxx/__utility/to_underlying.h
+++ b/third_party/libcxx/__utility/to_underlying.h
@@ -21,17 +21,15 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr typename underlying_type<_Tp>::type
-__to_underlying(_Tp __val) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr typename underlying_type<_Tp>::type __to_underlying(_Tp __val) noexcept {
   return static_cast<typename underlying_type<_Tp>::type>(__val);
 }
 #endif // !_LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER >= 23
 template <class _Tp>
-_LIBCPP_NODISCARD_EXT _LIBCPP_INLINE_VISIBILITY constexpr underlying_type_t<_Tp>
-to_underlying(_Tp __val) noexcept {
-  return _VSTD::__to_underlying(__val);
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr underlying_type_t<_Tp> to_underlying(_Tp __val) noexcept {
+  return std::__to_underlying(__val);
 }
 #endif
 
diff --git a/third_party/libcxx/__utility/unreachable.h b/third_party/libcxx/__utility/unreachable.h
index bd1c6bea0..d833f74c2 100644
--- a/third_party/libcxx/__utility/unreachable.h
+++ b/third_party/libcxx/__utility/unreachable.h
@@ -19,8 +19,8 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI inline void __libcpp_unreachable() {
-    _LIBCPP_ASSERT(false, "std::unreachable() was reached");
-    __builtin_unreachable();
+  _LIBCPP_ASSERT_INTERNAL(false, "std::unreachable() was reached");
+  __builtin_unreachable();
 }
 
 #if _LIBCPP_STD_VER >= 23
diff --git a/third_party/libcxx/__variant/monostate.h b/third_party/libcxx/__variant/monostate.h
index 8fec34008..16f156609 100644
--- a/third_party/libcxx/__variant/monostate.h
+++ b/third_party/libcxx/__variant/monostate.h
@@ -25,32 +25,32 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 struct _LIBCPP_TEMPLATE_VIS monostate {};
 
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(monostate, monostate) noexcept { return true; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator==(monostate, monostate) noexcept { return true; }
 
 #  if _LIBCPP_STD_VER >= 20
 
-_LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
+_LIBCPP_HIDE_FROM_ABI inline constexpr strong_ordering operator<=>(monostate, monostate) noexcept {
   return strong_ordering::equal;
 }
 
 #  else // _LIBCPP_STD_VER >= 20
 
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(monostate, monostate) noexcept { return false; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator!=(monostate, monostate) noexcept { return false; }
 
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(monostate, monostate) noexcept { return false; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator<(monostate, monostate) noexcept { return false; }
 
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(monostate, monostate) noexcept { return false; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator>(monostate, monostate) noexcept { return false; }
 
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(monostate, monostate) noexcept { return true; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator<=(monostate, monostate) noexcept { return true; }
 
-_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(monostate, monostate) noexcept { return true; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr bool operator>=(monostate, monostate) noexcept { return true; }
 
 #  endif // _LIBCPP_STD_VER >= 20
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<monostate> {
   using argument_type = monostate;
-  using result_type = size_t;
+  using result_type   = size_t;
 
   inline _LIBCPP_HIDE_FROM_ABI result_type operator()(const argument_type&) const _NOEXCEPT {
     return 66740831; // return a fundamentally attractive random value.
diff --git a/third_party/libcxx/__verbose_abort b/third_party/libcxx/__verbose_abort
index a38284b71..195ce65b7 100644
--- a/third_party/libcxx/__verbose_abort
+++ b/third_party/libcxx/__verbose_abort
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP___VERBOSE_ABORT
 #define _LIBCPP___VERBOSE_ABORT
 
-#include <__availability>
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -21,8 +20,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // This function should never be called directly from the code -- it should only be called through
 // the _LIBCPP_VERBOSE_ABORT macro.
-_LIBCPP_NORETURN _LIBCPP_AVAILABILITY_VERBOSE_ABORT _LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 2)
-void __libcpp_verbose_abort(const char *__format, ...);
+_LIBCPP_NORETURN _LIBCPP_AVAILABILITY_VERBOSE_ABORT _LIBCPP_OVERRIDABLE_FUNC_VIS
+_LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 2) void __libcpp_verbose_abort(const char* __format, ...);
 
 // _LIBCPP_VERBOSE_ABORT(format, args...)
 //
@@ -38,14 +37,7 @@ void __libcpp_verbose_abort(const char *__format, ...);
 // make sure that the program terminates but without taking any complex dependencies in this header.
 #if !defined(_LIBCPP_VERBOSE_ABORT)
 
-// Support _LIBCPP_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED until LLVM 18, but tell people
-// to move to customizing _LIBCPP_VERBOSE_ABORT instead.
-#  if defined(_LIBCPP_AVAILABILITY_HAS_NO_VERBOSE_ABORT) && defined(_LIBCPP_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED)
-#    undef _LIBCPP_AVAILABILITY_HAS_NO_VERBOSE_ABORT
-#    warning _LIBCPP_AVAILABILITY_CUSTOM_VERBOSE_ABORT_PROVIDED is deprecated, please customize _LIBCPP_VERBOSE_ABORT instead
-#  endif
-
-#  if defined(_LIBCPP_AVAILABILITY_HAS_NO_VERBOSE_ABORT)
+#  if !_LIBCPP_AVAILABILITY_HAS_VERBOSE_ABORT
 // The decltype is there to suppress -Wunused warnings in this configuration.
 void __use(const char*, ...);
 #    define _LIBCPP_VERBOSE_ABORT(...) (decltype(::std::__use(__VA_ARGS__))(), __builtin_abort())
diff --git a/third_party/libcxx/algorithm b/third_party/libcxx/algorithm
index 0f52da9a1..698e6f5cb 100644
--- a/third_party/libcxx/algorithm
+++ b/third_party/libcxx/algorithm
@@ -42,6 +42,9 @@ namespace ranges {
   template <class I>
     struct in_found_result;              // since C++20
 
+  template <class I, class T>
+    struct in_value_result;              // since C++23
+
   template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
     indirect_strict_weak_order<projected<I, Proj>> Comp = ranges::less>                                   // since C++20
   constexpr I min_element(I first, S last, Comp comp = {}, Proj proj = {});
@@ -99,6 +102,31 @@ namespace ranges {
     constexpr borrowed_iterator_t<R>
       find_if_not(R&& r, Pred pred, Proj proj = {});                                                      // since C++20
 
+  template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+    constexpr subrange<I> find_last(I first, S last, const T& value, Proj proj = {});                     // since C++23
+
+  template<forward_range R, class T, class Proj = identity>
+    requires
+      indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+    constexpr borrowed_subrange_t<R> find_last(R&& r, const T& value, Proj proj = {});                   // since C++23
+
+  template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+           indirect_unary_predicate<projected<I, Proj>> Pred>
+    constexpr subrange<I> find_last_if(I first, S last, Pred pred, Proj proj = {});                      // since C++23
+
+  template<forward_range R, class Proj = identity,
+           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+    constexpr borrowed_subrange_t<R> find_last_if(R&& r, Pred pred, Proj proj = {});                     // since C++23
+
+  template<forward_iterator I, sentinel_for<I> S, class Proj = identity,
+           indirect_unary_predicate<projected<I, Proj>> Pred>
+    constexpr subrange<I> find_last_if_not(I first, S last, Pred pred, Proj proj = {});                  // since C++23
+
+  template<forward_range R, class Proj = identity,
+           indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
+    constexpr borrowed_subrange_t<R> find_last_if_not(R&& r, Pred pred, Proj proj = {});                 // since C++23
+
   template<class T, class Proj = identity,
            indirect_strict_weak_order<projected<const T*, Proj>> Comp = ranges::less>
     constexpr const T& min(const T& a, const T& b, Comp comp = {}, Proj proj = {});                       // since C++20
@@ -214,6 +242,19 @@ namespace ranges {
     constexpr ranges::minmax_element_result<borrowed_iterator_t<R>>
       minmax_element(R&& r, Comp comp = {}, Proj proj = {});                                              // since C++20
 
+  template<forward_iterator I1, sentinel_for<I1> S1,
+           forward_iterator I2, sentinel_for<I2> S2,
+           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+    requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+    constexpr bool contains_subrange(I1 first1, S1 last1, I2 first2, S2 last2,
+                                     Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {});                // since C++23
+
+  template<forward_range R1, forward_range R2,
+           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+    requires indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+    constexpr bool contains_subrange(R1&& r1, R2&& r2, Pred pred = {},
+                                     Proj1 proj1 = {}, Proj2 proj2 = {});                                // since C++23
+
   template<class I, class O>
     using copy_result = in_out_result<I, O>;                                                // since C++20
 
@@ -226,6 +267,14 @@ namespace ranges {
   template<class I1, class I2>
     using copy_backward_result = in_out_result<I1, I2>;                                     // since C++20
 
+  template<input_iterator I, sentinel_for<I> S, class T, class Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<I, Proj>, const T*>
+    constexpr bool ranges::contains(I first, S last, const T& value, Proj proj = {});       // since C++23
+
+  template<input_range R, class T, class Proj = identity>
+    requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<R>, Proj>, const T*>
+    constexpr bool ranges::contains(R&& r, const T& value, Proj proj = {});                 // since C++23
+
   template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
     requires indirectly_copyable<I, O>
     constexpr ranges::copy_result<I, O> ranges::copy(I first, S last, O result);            // since C++20
@@ -401,6 +450,11 @@ namespace ranges {
     requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
     constexpr O generate(O first, S last, F gen);                                           // since C++20
 
+  template<class ExecutionPolicy, class ForwardIterator, class Generator>
+    void generate(ExecutionPolicy&& exec,
+                  ForwardIterator first, ForwardIterator last,
+                  Generator gen);                                                           // since C++17
+
   template<class R, copy_constructible F>
     requires invocable<F&> && output_range<R, invoke_result_t<F&>>
     constexpr borrowed_iterator_t<R> generate(R&& r, F gen);                                // since C++20
@@ -409,6 +463,10 @@ namespace ranges {
     requires invocable<F&> && indirectly_writable<O, invoke_result_t<F&>>
     constexpr O generate_n(O first, iter_difference_t<O> n, F gen);                         // since C++20
 
+  template<class ExecutionPolicy, class ForwardIterator, class Size, class Generator>
+    ForwardIterator generate_n(ExecutionPolicy&& exec,
+                               ForwardIterator first, Size n, Generator gen);               // since C++17
+
  template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
           class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
    requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
@@ -438,6 +496,22 @@ namespace ranges {
            indirect_unary_predicate<projected<iterator_t<R>, Proj>> Pred>
     constexpr bool ranges::any_of(R&& r, Pred pred, Proj proj = {});                        // since C++20
 
+  template<input_iterator I1, sentinel_for<I1> S1, input_iterator I2, sentinel_for<I2> S2,
+          class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
+    requires (forward_iterator<I1> || sized_sentinel_for<S1, I1>) &&
+           (forward_iterator<I2> || sized_sentinel_for<S2, I2>) &&
+           indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
+    constexpr bool ranges::ends_with(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
+                                   Proj1 proj1 = {}, Proj2 proj2 = {});                     // since C++23
+
+  template<input_range R1, input_range R2, class Pred = ranges::equal_to, class Proj1 = identity,
+          class Proj2 = identity>
+    requires (forward_range<R1> || sized_range<R1>) &&
+           (forward_range<R2> || sized_range<R2>) &&
+           indirectly_comparable<iterator_t<R1>, iterator_t<R2>, Pred, Proj1, Proj2>
+    constexpr bool ranges::ends_with(R1&& r1, R2&& r2, Pred pred = {},
+                                   Proj1 proj1 = {}, Proj2 proj2 = {});                     // since C++23
+
   template<input_iterator I, sentinel_for<I> S, class Proj = identity,
            indirect_unary_predicate<projected<I, Proj>> Pred>
     constexpr bool ranges::none_of(I first, S last, Pred pred, Proj proj = {});             // since C++20
@@ -848,6 +922,23 @@ namespace ranges {
       ranges::search_n(R&& r, range_difference_t<R> count,
                        const T& value, Pred pred = {}, Proj proj = {});                             // since C++20
 
+  template<input_iterator I, sentinel_for<I> S, class T,
+           indirectly-binary-left-foldable<T, I> F>
+    constexpr auto ranges::fold_left(I first, S last, T init, F f);                                 // since C++23
+
+  template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
+    constexpr auto fold_left(R&& r, T init, F f);                                                   // since C++23
+
+  template<class I, class T>
+    using fold_left_with_iter_result = in_value_result<I, T>;                                       // since C++23
+
+  template<input_iterator I, sentinel_for<I> S, class T,
+           indirectly-binary-left-foldable<T, I> F>
+    constexpr see below fold_left_with_iter(I first, S last, T init, F f);                          // since C++23
+
+  template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
+    constexpr see below fold_left_with_iter(R&& r, T init, F f);                                    // since C++23
+
   template<forward_iterator I1, sentinel_for<I1> S1, forward_iterator I2, sentinel_for<I2> S2,
            class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity>
     requires indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
@@ -1727,19 +1818,12 @@ template <class BidirectionalIterator, class Compare>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__debug>
-#include <cstddef>
-#include <version>
 
 #include <__algorithm/adjacent_find.h>
 #include <__algorithm/all_of.h>
 #include <__algorithm/any_of.h>
 #include <__algorithm/binary_search.h>
-#include <__algorithm/clamp.h>
-#include <__algorithm/comp.h>
-#include <__algorithm/comp_ref_type.h>
 #include <__algorithm/copy.h>
 #include <__algorithm/copy_backward.h>
 #include <__algorithm/copy_if.h>
@@ -1756,16 +1840,8 @@ template <class BidirectionalIterator, class Compare>
 #include <__algorithm/find_if.h>
 #include <__algorithm/find_if_not.h>
 #include <__algorithm/for_each.h>
-#include <__algorithm/for_each_n.h>
 #include <__algorithm/generate.h>
 #include <__algorithm/generate_n.h>
-#include <__algorithm/half_positive.h>
-#include <__algorithm/in_found_result.h>
-#include <__algorithm/in_fun_result.h>
-#include <__algorithm/in_in_out_result.h>
-#include <__algorithm/in_in_result.h>
-#include <__algorithm/in_out_out_result.h>
-#include <__algorithm/in_out_result.h>
 #include <__algorithm/includes.h>
 #include <__algorithm/inplace_merge.h>
 #include <__algorithm/is_heap.h>
@@ -1776,7 +1852,6 @@ template <class BidirectionalIterator, class Compare>
 #include <__algorithm/is_sorted_until.h>
 #include <__algorithm/iter_swap.h>
 #include <__algorithm/lexicographical_compare.h>
-#include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/lower_bound.h>
 #include <__algorithm/make_heap.h>
 #include <__algorithm/max.h>
@@ -1784,7 +1859,6 @@ template <class BidirectionalIterator, class Compare>
 #include <__algorithm/merge.h>
 #include <__algorithm/min.h>
 #include <__algorithm/min_element.h>
-#include <__algorithm/min_max_result.h>
 #include <__algorithm/minmax.h>
 #include <__algorithm/minmax_element.h>
 #include <__algorithm/mismatch.h>
@@ -1800,100 +1874,7 @@ template <class BidirectionalIterator, class Compare>
 #include <__algorithm/partition_point.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/prev_permutation.h>
-#include <__algorithm/pstl_any_all_none_of.h>
-#include <__algorithm/pstl_copy.h>
-#include <__algorithm/pstl_fill.h>
-#include <__algorithm/pstl_find.h>
-#include <__algorithm/pstl_for_each.h>
-#include <__algorithm/pstl_merge.h>
-#include <__algorithm/pstl_transform.h>
 #include <__algorithm/push_heap.h>
-#include <__algorithm/ranges_adjacent_find.h>
-#include <__algorithm/ranges_all_of.h>
-#include <__algorithm/ranges_any_of.h>
-#include <__algorithm/ranges_binary_search.h>
-#include <__algorithm/ranges_clamp.h>
-#include <__algorithm/ranges_copy.h>
-#include <__algorithm/ranges_copy_backward.h>
-#include <__algorithm/ranges_copy_if.h>
-#include <__algorithm/ranges_copy_n.h>
-#include <__algorithm/ranges_count.h>
-#include <__algorithm/ranges_count_if.h>
-#include <__algorithm/ranges_equal.h>
-#include <__algorithm/ranges_equal_range.h>
-#include <__algorithm/ranges_fill.h>
-#include <__algorithm/ranges_fill_n.h>
-#include <__algorithm/ranges_find.h>
-#include <__algorithm/ranges_find_end.h>
-#include <__algorithm/ranges_find_first_of.h>
-#include <__algorithm/ranges_find_if.h>
-#include <__algorithm/ranges_find_if_not.h>
-#include <__algorithm/ranges_for_each.h>
-#include <__algorithm/ranges_for_each_n.h>
-#include <__algorithm/ranges_generate.h>
-#include <__algorithm/ranges_generate_n.h>
-#include <__algorithm/ranges_includes.h>
-#include <__algorithm/ranges_inplace_merge.h>
-#include <__algorithm/ranges_is_heap.h>
-#include <__algorithm/ranges_is_heap_until.h>
-#include <__algorithm/ranges_is_partitioned.h>
-#include <__algorithm/ranges_is_permutation.h>
-#include <__algorithm/ranges_is_sorted.h>
-#include <__algorithm/ranges_is_sorted_until.h>
-#include <__algorithm/ranges_lexicographical_compare.h>
-#include <__algorithm/ranges_lower_bound.h>
-#include <__algorithm/ranges_make_heap.h>
-#include <__algorithm/ranges_max.h>
-#include <__algorithm/ranges_max_element.h>
-#include <__algorithm/ranges_merge.h>
-#include <__algorithm/ranges_min.h>
-#include <__algorithm/ranges_min_element.h>
-#include <__algorithm/ranges_minmax.h>
-#include <__algorithm/ranges_minmax_element.h>
-#include <__algorithm/ranges_mismatch.h>
-#include <__algorithm/ranges_move.h>
-#include <__algorithm/ranges_move_backward.h>
-#include <__algorithm/ranges_next_permutation.h>
-#include <__algorithm/ranges_none_of.h>
-#include <__algorithm/ranges_nth_element.h>
-#include <__algorithm/ranges_partial_sort.h>
-#include <__algorithm/ranges_partial_sort_copy.h>
-#include <__algorithm/ranges_partition.h>
-#include <__algorithm/ranges_partition_copy.h>
-#include <__algorithm/ranges_partition_point.h>
-#include <__algorithm/ranges_pop_heap.h>
-#include <__algorithm/ranges_prev_permutation.h>
-#include <__algorithm/ranges_push_heap.h>
-#include <__algorithm/ranges_remove.h>
-#include <__algorithm/ranges_remove_copy.h>
-#include <__algorithm/ranges_remove_copy_if.h>
-#include <__algorithm/ranges_remove_if.h>
-#include <__algorithm/ranges_replace.h>
-#include <__algorithm/ranges_replace_copy.h>
-#include <__algorithm/ranges_replace_copy_if.h>
-#include <__algorithm/ranges_replace_if.h>
-#include <__algorithm/ranges_reverse.h>
-#include <__algorithm/ranges_reverse_copy.h>
-#include <__algorithm/ranges_rotate.h>
-#include <__algorithm/ranges_rotate_copy.h>
-#include <__algorithm/ranges_sample.h>
-#include <__algorithm/ranges_search.h>
-#include <__algorithm/ranges_search_n.h>
-#include <__algorithm/ranges_set_difference.h>
-#include <__algorithm/ranges_set_intersection.h>
-#include <__algorithm/ranges_set_symmetric_difference.h>
-#include <__algorithm/ranges_set_union.h>
-#include <__algorithm/ranges_shuffle.h>
-#include <__algorithm/ranges_sort.h>
-#include <__algorithm/ranges_sort_heap.h>
-#include <__algorithm/ranges_stable_partition.h>
-#include <__algorithm/ranges_stable_sort.h>
-#include <__algorithm/ranges_starts_with.h>
-#include <__algorithm/ranges_swap_ranges.h>
-#include <__algorithm/ranges_transform.h>
-#include <__algorithm/ranges_unique.h>
-#include <__algorithm/ranges_unique_copy.h>
-#include <__algorithm/ranges_upper_bound.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_copy.h>
 #include <__algorithm/remove_copy_if.h>
@@ -1906,17 +1887,13 @@ template <class BidirectionalIterator, class Compare>
 #include <__algorithm/reverse_copy.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/rotate_copy.h>
-#include <__algorithm/sample.h>
 #include <__algorithm/search.h>
 #include <__algorithm/search_n.h>
 #include <__algorithm/set_difference.h>
 #include <__algorithm/set_intersection.h>
 #include <__algorithm/set_symmetric_difference.h>
 #include <__algorithm/set_union.h>
-#include <__algorithm/shift_left.h>
-#include <__algorithm/shift_right.h>
 #include <__algorithm/shuffle.h>
-#include <__algorithm/sift_down.h>
 #include <__algorithm/sort.h>
 #include <__algorithm/sort_heap.h>
 #include <__algorithm/stable_partition.h>
@@ -1925,9 +1902,124 @@ template <class BidirectionalIterator, class Compare>
 #include <__algorithm/transform.h>
 #include <__algorithm/unique.h>
 #include <__algorithm/unique_copy.h>
-#include <__algorithm/unwrap_iter.h>
 #include <__algorithm/upper_bound.h>
 
+#if _LIBCPP_STD_VER >= 17
+#  include <__algorithm/clamp.h>
+#  include <__algorithm/for_each_n.h>
+#  include <__algorithm/pstl.h>
+#  include <__algorithm/sample.h>
+#endif // _LIBCPP_STD_VER >= 17
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__algorithm/in_found_result.h>
+#  include <__algorithm/in_fun_result.h>
+#  include <__algorithm/in_in_out_result.h>
+#  include <__algorithm/in_in_result.h>
+#  include <__algorithm/in_out_out_result.h>
+#  include <__algorithm/in_out_result.h>
+#  include <__algorithm/lexicographical_compare_three_way.h>
+#  include <__algorithm/min_max_result.h>
+#  include <__algorithm/ranges_adjacent_find.h>
+#  include <__algorithm/ranges_all_of.h>
+#  include <__algorithm/ranges_any_of.h>
+#  include <__algorithm/ranges_binary_search.h>
+#  include <__algorithm/ranges_clamp.h>
+#  include <__algorithm/ranges_contains.h>
+#  include <__algorithm/ranges_copy.h>
+#  include <__algorithm/ranges_copy_backward.h>
+#  include <__algorithm/ranges_copy_if.h>
+#  include <__algorithm/ranges_copy_n.h>
+#  include <__algorithm/ranges_count.h>
+#  include <__algorithm/ranges_count_if.h>
+#  include <__algorithm/ranges_equal.h>
+#  include <__algorithm/ranges_equal_range.h>
+#  include <__algorithm/ranges_fill.h>
+#  include <__algorithm/ranges_fill_n.h>
+#  include <__algorithm/ranges_find.h>
+#  include <__algorithm/ranges_find_end.h>
+#  include <__algorithm/ranges_find_first_of.h>
+#  include <__algorithm/ranges_find_if.h>
+#  include <__algorithm/ranges_find_if_not.h>
+#  include <__algorithm/ranges_for_each.h>
+#  include <__algorithm/ranges_for_each_n.h>
+#  include <__algorithm/ranges_generate.h>
+#  include <__algorithm/ranges_generate_n.h>
+#  include <__algorithm/ranges_includes.h>
+#  include <__algorithm/ranges_inplace_merge.h>
+#  include <__algorithm/ranges_is_heap.h>
+#  include <__algorithm/ranges_is_heap_until.h>
+#  include <__algorithm/ranges_is_partitioned.h>
+#  include <__algorithm/ranges_is_permutation.h>
+#  include <__algorithm/ranges_is_sorted.h>
+#  include <__algorithm/ranges_is_sorted_until.h>
+#  include <__algorithm/ranges_lexicographical_compare.h>
+#  include <__algorithm/ranges_lower_bound.h>
+#  include <__algorithm/ranges_make_heap.h>
+#  include <__algorithm/ranges_max.h>
+#  include <__algorithm/ranges_max_element.h>
+#  include <__algorithm/ranges_merge.h>
+#  include <__algorithm/ranges_min.h>
+#  include <__algorithm/ranges_min_element.h>
+#  include <__algorithm/ranges_minmax.h>
+#  include <__algorithm/ranges_minmax_element.h>
+#  include <__algorithm/ranges_mismatch.h>
+#  include <__algorithm/ranges_move.h>
+#  include <__algorithm/ranges_move_backward.h>
+#  include <__algorithm/ranges_next_permutation.h>
+#  include <__algorithm/ranges_none_of.h>
+#  include <__algorithm/ranges_nth_element.h>
+#  include <__algorithm/ranges_partial_sort.h>
+#  include <__algorithm/ranges_partial_sort_copy.h>
+#  include <__algorithm/ranges_partition.h>
+#  include <__algorithm/ranges_partition_copy.h>
+#  include <__algorithm/ranges_partition_point.h>
+#  include <__algorithm/ranges_pop_heap.h>
+#  include <__algorithm/ranges_prev_permutation.h>
+#  include <__algorithm/ranges_push_heap.h>
+#  include <__algorithm/ranges_remove.h>
+#  include <__algorithm/ranges_remove_copy.h>
+#  include <__algorithm/ranges_remove_copy_if.h>
+#  include <__algorithm/ranges_remove_if.h>
+#  include <__algorithm/ranges_replace.h>
+#  include <__algorithm/ranges_replace_copy.h>
+#  include <__algorithm/ranges_replace_copy_if.h>
+#  include <__algorithm/ranges_replace_if.h>
+#  include <__algorithm/ranges_reverse.h>
+#  include <__algorithm/ranges_reverse_copy.h>
+#  include <__algorithm/ranges_rotate.h>
+#  include <__algorithm/ranges_rotate_copy.h>
+#  include <__algorithm/ranges_sample.h>
+#  include <__algorithm/ranges_search.h>
+#  include <__algorithm/ranges_search_n.h>
+#  include <__algorithm/ranges_set_difference.h>
+#  include <__algorithm/ranges_set_intersection.h>
+#  include <__algorithm/ranges_set_symmetric_difference.h>
+#  include <__algorithm/ranges_set_union.h>
+#  include <__algorithm/ranges_shuffle.h>
+#  include <__algorithm/ranges_sort.h>
+#  include <__algorithm/ranges_sort_heap.h>
+#  include <__algorithm/ranges_stable_partition.h>
+#  include <__algorithm/ranges_stable_sort.h>
+#  include <__algorithm/ranges_swap_ranges.h>
+#  include <__algorithm/ranges_transform.h>
+#  include <__algorithm/ranges_unique.h>
+#  include <__algorithm/ranges_unique_copy.h>
+#  include <__algorithm/ranges_upper_bound.h>
+#  include <__algorithm/shift_left.h>
+#  include <__algorithm/shift_right.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+#  include <__algorithm/fold.h>
+#  include <__algorithm/ranges_contains_subrange.h>
+#  include <__algorithm/ranges_ends_with.h>
+#  include <__algorithm/ranges_find_last.h>
+#  include <__algorithm/ranges_starts_with.h>
+#endif // _LIBCPP_STD_VER >= 23
+
+#include <version>
+
 // standard-mandated includes
 
 // [algorithm.syn]
@@ -1937,6 +2029,10 @@ template <class BidirectionalIterator, class Compare>
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER == 14
+#  include <execution>
+#endif
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <bit>
diff --git a/third_party/libcxx/src/algorithm.cpp b/third_party/libcxx/algorithm.cpp
similarity index 93%
rename from third_party/libcxx/src/algorithm.cpp
rename to third_party/libcxx/algorithm.cpp
index 5a47558fd..af9d60a8e 100644
--- a/third_party/libcxx/src/algorithm.cpp
+++ b/third_party/libcxx/algorithm.cpp
@@ -19,9 +19,10 @@ void __sort(RandomAccessIterator first, RandomAccessIterator last, Comp comp) {
   // that the default comparator is in use so that we are sure that there are no
   // branches in the comparator.
   std::__introsort<_ClassicAlgPolicy,
-                   Comp&,
+                   ranges::less,
                    RandomAccessIterator,
-                   __use_branchless_sort<Comp, RandomAccessIterator>::value>(first, last, comp, depth_limit);
+                   __use_branchless_sort<ranges::less, RandomAccessIterator>::value>(
+      first, last, ranges::less{}, depth_limit);
 }
 
 // clang-format off
diff --git a/third_party/libcxx/any b/third_party/libcxx/any
index e056444f8..5def14dc8 100644
--- a/third_party/libcxx/any
+++ b/third_party/libcxx/any
@@ -80,8 +80,6 @@ namespace std {
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__availability>
 #include <__config>
 #include <__memory/allocator.h>
 #include <__memory/allocator_destructor.h>
@@ -90,15 +88,14 @@ namespace std {
 #include <__type_traits/add_const.h>
 #include <__type_traits/add_pointer.h>
 #include <__type_traits/aligned_storage.h>
-#include <__type_traits/alignment_of.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_constructible.h>
-#include <__type_traits/is_copy_constructible.h>
 #include <__type_traits/is_function.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_same.h>
+#include <__type_traits/is_void.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
@@ -115,11 +112,13 @@ namespace std {
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 namespace std {
-class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
-{
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast {
 public:
-    const char* what() const _NOEXCEPT override;
+  const char* what() const _NOEXCEPT override;
 };
 } // namespace std
 
@@ -127,589 +126,475 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
-void __throw_bad_any_cast()
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw bad_any_cast();
-#else
-    _LIBCPP_VERBOSE_ABORT("bad_any_cast was thrown in -fno-exceptions mode");
-#endif
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST void __throw_bad_any_cast() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw bad_any_cast();
+#  else
+  _LIBCPP_VERBOSE_ABORT("bad_any_cast was thrown in -fno-exceptions mode");
+#  endif
 }
 
 // Forward declarations
 class _LIBCPP_TEMPLATE_VIS any;
 
 template <class _ValueType>
-_LIBCPP_INLINE_VISIBILITY
-add_pointer_t<add_const_t<_ValueType>>
-any_cast(any const *) _NOEXCEPT;
+_LIBCPP_HIDE_FROM_ABI add_pointer_t<add_const_t<_ValueType>> any_cast(any const*) _NOEXCEPT;
 
 template <class _ValueType>
-_LIBCPP_INLINE_VISIBILITY
-add_pointer_t<_ValueType> any_cast(any *) _NOEXCEPT;
+_LIBCPP_HIDE_FROM_ABI add_pointer_t<_ValueType> any_cast(any*) _NOEXCEPT;
 
-namespace __any_imp
-{
-  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-  using _Buffer = aligned_storage_t<3*sizeof(void*), alignment_of<void*>::value>;
-  _LIBCPP_SUPPRESS_DEPRECATED_POP
+namespace __any_imp {
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+using _Buffer = aligned_storage_t<3 * sizeof(void*), alignof(void*)>;
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
-  template <class _Tp>
-  using _IsSmallObject = integral_constant<bool
-        , sizeof(_Tp) <= sizeof(_Buffer)
-          && alignment_of<_Buffer>::value
-             % alignment_of<_Tp>::value == 0
-          && is_nothrow_move_constructible<_Tp>::value
-        >;
+template <class _Tp>
+using _IsSmallObject =
+    integral_constant<bool,
+                      sizeof(_Tp) <= sizeof(_Buffer) && alignof(_Buffer) % alignof(_Tp) == 0 &&
+                          is_nothrow_move_constructible<_Tp>::value >;
 
-  enum class _Action {
-    _Destroy,
-    _Copy,
-    _Move,
-    _Get,
-    _TypeInfo
-  };
+enum class _Action { _Destroy, _Copy, _Move, _Get, _TypeInfo };
 
-  template <class _Tp> struct _SmallHandler;
-  template <class _Tp> struct _LargeHandler;
+template <class _Tp>
+struct _SmallHandler;
+template <class _Tp>
+struct _LargeHandler;
 
-  template <class _Tp>
-  struct  _LIBCPP_TEMPLATE_VIS __unique_typeinfo { static constexpr int __id = 0; };
-  template <class _Tp> constexpr int __unique_typeinfo<_Tp>::__id;
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS __unique_typeinfo {
+  static constexpr int __id = 0;
+};
+template <class _Tp>
+constexpr int __unique_typeinfo<_Tp>::__id;
 
-  template <class _Tp>
-  inline _LIBCPP_INLINE_VISIBILITY
-  constexpr const void* __get_fallback_typeid() {
-      return &__unique_typeinfo<remove_cv_t<remove_reference_t<_Tp>>>::__id;
-  }
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI constexpr const void* __get_fallback_typeid() {
+  return &__unique_typeinfo<remove_cv_t<remove_reference_t<_Tp>>>::__id;
+}
 
-  template <class _Tp>
-  inline _LIBCPP_INLINE_VISIBILITY
-  bool __compare_typeid(type_info const* __id, const void* __fallback_id)
-  {
-#if !defined(_LIBCPP_HAS_NO_RTTI)
-      if (__id && *__id == typeid(_Tp))
-          return true;
-#endif
-      if (!__id && __fallback_id == __any_imp::__get_fallback_typeid<_Tp>())
-          return true;
-      return false;
-  }
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI bool __compare_typeid(type_info const* __id, const void* __fallback_id) {
+#  if !defined(_LIBCPP_HAS_NO_RTTI)
+  if (__id && *__id == typeid(_Tp))
+    return true;
+#  endif
+  return !__id && __fallback_id == __any_imp::__get_fallback_typeid<_Tp>();
+}
 
-  template <class _Tp>
-  using _Handler = conditional_t<
-    _IsSmallObject<_Tp>::value, _SmallHandler<_Tp>, _LargeHandler<_Tp>>;
+template <class _Tp>
+using _Handler = conditional_t< _IsSmallObject<_Tp>::value, _SmallHandler<_Tp>, _LargeHandler<_Tp>>;
 
 } // namespace __any_imp
 
-class _LIBCPP_TEMPLATE_VIS any
-{
+class _LIBCPP_TEMPLATE_VIS any {
 public:
   // construct/destruct
-  _LIBCPP_INLINE_VISIBILITY
-  constexpr any() _NOEXCEPT : __h_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr any() _NOEXCEPT : __h_(nullptr) {}
 
-  _LIBCPP_INLINE_VISIBILITY
-  any(any const & __other) : __h_(nullptr)
-  {
-    if (__other.__h_) __other.__call(_Action::_Copy, this);
+  _LIBCPP_HIDE_FROM_ABI any(any const& __other) : __h_(nullptr) {
+    if (__other.__h_)
+      __other.__call(_Action::_Copy, this);
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  any(any && __other) _NOEXCEPT : __h_(nullptr)
-  {
-    if (__other.__h_) __other.__call(_Action::_Move, this);
+  _LIBCPP_HIDE_FROM_ABI any(any&& __other) _NOEXCEPT : __h_(nullptr) {
+    if (__other.__h_)
+      __other.__call(_Action::_Move, this);
   }
 
-  template <
-      class _ValueType
-    , class _Tp = decay_t<_ValueType>
-    , class = enable_if_t<
-        !is_same<_Tp, any>::value &&
-        !__is_inplace_type<_ValueType>::value &&
-        is_copy_constructible<_Tp>::value>
-    >
-  _LIBCPP_INLINE_VISIBILITY
-  any(_ValueType && __value);
+  template < class _ValueType,
+             class _Tp = decay_t<_ValueType>,
+             class     = enable_if_t< !is_same<_Tp, any>::value && !__is_inplace_type<_ValueType>::value &&
+                                      is_copy_constructible<_Tp>::value> >
+  _LIBCPP_HIDE_FROM_ABI any(_ValueType&& __value);
 
-  template <class _ValueType, class ..._Args,
-    class _Tp = decay_t<_ValueType>,
-    class = enable_if_t<
-        is_constructible<_Tp, _Args...>::value &&
-        is_copy_constructible<_Tp>::value
-    >
-  >
-  _LIBCPP_INLINE_VISIBILITY
-  explicit any(in_place_type_t<_ValueType>, _Args&&... __args);
+  template <class _ValueType,
+            class... _Args,
+            class _Tp = decay_t<_ValueType>,
+            class     = enable_if_t< is_constructible<_Tp, _Args...>::value && is_copy_constructible<_Tp>::value > >
+  _LIBCPP_HIDE_FROM_ABI explicit any(in_place_type_t<_ValueType>, _Args&&... __args);
 
-  template <class _ValueType, class _Up, class ..._Args,
-    class _Tp = decay_t<_ValueType>,
-    class = enable_if_t<
-        is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
-        is_copy_constructible<_Tp>::value>
-  >
-  _LIBCPP_INLINE_VISIBILITY
-  explicit any(in_place_type_t<_ValueType>, initializer_list<_Up>, _Args&&... __args);
+  template <class _ValueType,
+            class _Up,
+            class... _Args,
+            class _Tp = decay_t<_ValueType>,
+            class     = enable_if_t< is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
+                                     is_copy_constructible<_Tp>::value> >
+  _LIBCPP_HIDE_FROM_ABI explicit any(in_place_type_t<_ValueType>, initializer_list<_Up>, _Args&&... __args);
 
-  _LIBCPP_INLINE_VISIBILITY
-  ~any() { this->reset(); }
+  _LIBCPP_HIDE_FROM_ABI ~any() { this->reset(); }
 
   // assignments
-  _LIBCPP_INLINE_VISIBILITY
-  any & operator=(any const & __rhs) {
+  _LIBCPP_HIDE_FROM_ABI any& operator=(any const& __rhs) {
     any(__rhs).swap(*this);
     return *this;
   }
 
-  _LIBCPP_INLINE_VISIBILITY
-  any & operator=(any && __rhs) _NOEXCEPT {
-    any(_VSTD::move(__rhs)).swap(*this);
+  _LIBCPP_HIDE_FROM_ABI any& operator=(any&& __rhs) _NOEXCEPT {
+    any(std::move(__rhs)).swap(*this);
     return *this;
   }
 
-  template <
-      class _ValueType
-    , class _Tp = decay_t<_ValueType>
-    , class = enable_if_t<
-          !is_same<_Tp, any>::value
-          && is_copy_constructible<_Tp>::value>
-    >
-  _LIBCPP_INLINE_VISIBILITY
-  any & operator=(_ValueType && __rhs);
+  template < class _ValueType,
+             class _Tp = decay_t<_ValueType>,
+             class     = enable_if_t< !is_same<_Tp, any>::value && is_copy_constructible<_Tp>::value> >
+  _LIBCPP_HIDE_FROM_ABI any& operator=(_ValueType&& __rhs);
 
-  template <class _ValueType, class ..._Args,
-    class _Tp = decay_t<_ValueType>,
-    class = enable_if_t<
-        is_constructible<_Tp, _Args...>::value &&
-        is_copy_constructible<_Tp>::value>
-    >
-  _LIBCPP_INLINE_VISIBILITY
-  _Tp& emplace(_Args&&...);
+  template <class _ValueType,
+            class... _Args,
+            class _Tp = decay_t<_ValueType>,
+            class     = enable_if_t< is_constructible<_Tp, _Args...>::value && is_copy_constructible<_Tp>::value> >
+  _LIBCPP_HIDE_FROM_ABI _Tp& emplace(_Args&&...);
 
-  template <class _ValueType, class _Up, class ..._Args,
-    class _Tp = decay_t<_ValueType>,
-    class = enable_if_t<
-        is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
-        is_copy_constructible<_Tp>::value>
-  >
-  _LIBCPP_INLINE_VISIBILITY
-  _Tp& emplace(initializer_list<_Up>, _Args&&...);
+  template <class _ValueType,
+            class _Up,
+            class... _Args,
+            class _Tp = decay_t<_ValueType>,
+            class     = enable_if_t< is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
+                                     is_copy_constructible<_Tp>::value> >
+  _LIBCPP_HIDE_FROM_ABI _Tp& emplace(initializer_list<_Up>, _Args&&...);
 
   // 6.3.3 any modifiers
-  _LIBCPP_INLINE_VISIBILITY
-  void reset() _NOEXCEPT { if (__h_) this->__call(_Action::_Destroy); }
+  _LIBCPP_HIDE_FROM_ABI void reset() _NOEXCEPT {
+    if (__h_)
+      this->__call(_Action::_Destroy);
+  }
 
-  _LIBCPP_INLINE_VISIBILITY
-  void swap(any & __rhs) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void swap(any& __rhs) _NOEXCEPT;
 
   // 6.3.4 any observers
-  _LIBCPP_INLINE_VISIBILITY
-  bool has_value() const _NOEXCEPT { return __h_ != nullptr; }
+  _LIBCPP_HIDE_FROM_ABI bool has_value() const _NOEXCEPT { return __h_ != nullptr; }
 
-#if !defined(_LIBCPP_HAS_NO_RTTI)
-  _LIBCPP_INLINE_VISIBILITY
-  const type_info & type() const _NOEXCEPT {
+#  if !defined(_LIBCPP_HAS_NO_RTTI)
+  _LIBCPP_HIDE_FROM_ABI const type_info& type() const _NOEXCEPT {
     if (__h_) {
-        return *static_cast<type_info const *>(this->__call(_Action::_TypeInfo));
+      return *static_cast<type_info const*>(this->__call(_Action::_TypeInfo));
     } else {
-        return typeid(void);
+      return typeid(void);
     }
   }
-#endif
+#  endif
 
 private:
-    typedef __any_imp::_Action _Action;
-    using _HandleFuncPtr =  void* (*)(_Action, any const *, any *, const type_info *,
-      const void* __fallback_info);
+  typedef __any_imp::_Action _Action;
+  using _HandleFuncPtr = void* (*)(_Action, any const*, any*, const type_info*, const void* __fallback_info);
 
-    union _Storage {
-        _LIBCPP_HIDE_FROM_ABI constexpr _Storage() : __ptr(nullptr) {}
-        void *  __ptr;
-        __any_imp::_Buffer __buf;
-    };
+  union _Storage {
+    _LIBCPP_HIDE_FROM_ABI constexpr _Storage() : __ptr(nullptr) {}
+    void* __ptr;
+    __any_imp::_Buffer __buf;
+  };
 
-    _LIBCPP_INLINE_VISIBILITY
-    void * __call(_Action __a, any * __other = nullptr,
-                  type_info const * __info = nullptr,
-                   const void* __fallback_info = nullptr) const
-    {
-        return __h_(__a, this, __other, __info, __fallback_info);
-    }
+  _LIBCPP_HIDE_FROM_ABI void*
+  __call(_Action __a, any* __other = nullptr, type_info const* __info = nullptr, const void* __fallback_info = nullptr)
+      const {
+    return __h_(__a, this, __other, __info, __fallback_info);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void * __call(_Action __a, any * __other = nullptr,
-                  type_info const * __info = nullptr,
-                  const void* __fallback_info = nullptr)
-    {
-        return __h_(__a, this, __other, __info, __fallback_info);
-    }
+  _LIBCPP_HIDE_FROM_ABI void* __call(
+      _Action __a, any* __other = nullptr, type_info const* __info = nullptr, const void* __fallback_info = nullptr) {
+    return __h_(__a, this, __other, __info, __fallback_info);
+  }
 
-    template <class>
-    friend struct __any_imp::_SmallHandler;
-    template <class>
-    friend struct __any_imp::_LargeHandler;
+  template <class>
+  friend struct __any_imp::_SmallHandler;
+  template <class>
+  friend struct __any_imp::_LargeHandler;
 
-    template <class _ValueType>
-    friend add_pointer_t<add_const_t<_ValueType>>
-    any_cast(any const *) _NOEXCEPT;
+  template <class _ValueType>
+  friend add_pointer_t<add_const_t<_ValueType>> any_cast(any const*) _NOEXCEPT;
 
-    template <class _ValueType>
-    friend add_pointer_t<_ValueType>
-    any_cast(any *) _NOEXCEPT;
+  template <class _ValueType>
+  friend add_pointer_t<_ValueType> any_cast(any*) _NOEXCEPT;
 
-    _HandleFuncPtr __h_ = nullptr;
-    _Storage __s_;
+  _HandleFuncPtr __h_ = nullptr;
+  _Storage __s_;
 };
 
-namespace __any_imp
-{
-  template <class _Tp>
-  struct _LIBCPP_TEMPLATE_VIS _SmallHandler
-  {
-     _LIBCPP_INLINE_VISIBILITY
-     static void* __handle(_Action __act, any const * __this, any * __other,
-                           type_info const * __info, const void* __fallback_info)
-     {
-        switch (__act)
-        {
-        case _Action::_Destroy:
-          __destroy(const_cast<any &>(*__this));
-          return nullptr;
-        case _Action::_Copy:
-            __copy(*__this, *__other);
-            return nullptr;
-        case _Action::_Move:
-          __move(const_cast<any &>(*__this), *__other);
-          return nullptr;
-        case _Action::_Get:
-            return __get(const_cast<any &>(*__this), __info, __fallback_info);
-        case _Action::_TypeInfo:
-          return __type_info();
-        }
-        __libcpp_unreachable();
+namespace __any_imp {
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS _SmallHandler {
+  _LIBCPP_HIDE_FROM_ABI static void*
+  __handle(_Action __act, any const* __this, any* __other, type_info const* __info, const void* __fallback_info) {
+    switch (__act) {
+    case _Action::_Destroy:
+      __destroy(const_cast<any&>(*__this));
+      return nullptr;
+    case _Action::_Copy:
+      __copy(*__this, *__other);
+      return nullptr;
+    case _Action::_Move:
+      __move(const_cast<any&>(*__this), *__other);
+      return nullptr;
+    case _Action::_Get:
+      return __get(const_cast<any&>(*__this), __info, __fallback_info);
+    case _Action::_TypeInfo:
+      return __type_info();
     }
+    __libcpp_unreachable();
+  }
 
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
-    static _Tp& __create(any & __dest, _Args&&... __args) {
-        typedef allocator<_Tp> _Alloc;
-        typedef allocator_traits<_Alloc> _ATraits;
-        _Alloc __a;
-        _Tp * __ret = static_cast<_Tp*>(static_cast<void*>(&__dest.__s_.__buf));
-        _ATraits::construct(__a, __ret, _VSTD::forward<_Args>(__args)...);
-        __dest.__h_ = &_SmallHandler::__handle;
-        return *__ret;
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI static _Tp& __create(any& __dest, _Args&&... __args) {
+    typedef allocator<_Tp> _Alloc;
+    typedef allocator_traits<_Alloc> _ATraits;
+    _Alloc __a;
+    _Tp* __ret = static_cast<_Tp*>(static_cast<void*>(&__dest.__s_.__buf));
+    _ATraits::construct(__a, __ret, std::forward<_Args>(__args)...);
+    __dest.__h_ = &_SmallHandler::__handle;
+    return *__ret;
+  }
+
+private:
+  _LIBCPP_HIDE_FROM_ABI static void __destroy(any& __this) {
+    typedef allocator<_Tp> _Alloc;
+    typedef allocator_traits<_Alloc> _ATraits;
+    _Alloc __a;
+    _Tp* __p = static_cast<_Tp*>(static_cast<void*>(&__this.__s_.__buf));
+    _ATraits::destroy(__a, __p);
+    __this.__h_ = nullptr;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static void __copy(any const& __this, any& __dest) {
+    _SmallHandler::__create(__dest, *static_cast<_Tp const*>(static_cast<void const*>(&__this.__s_.__buf)));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static void __move(any& __this, any& __dest) {
+    _SmallHandler::__create(__dest, std::move(*static_cast<_Tp*>(static_cast<void*>(&__this.__s_.__buf))));
+    __destroy(__this);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static void* __get(any& __this, type_info const* __info, const void* __fallback_id) {
+    if (__any_imp::__compare_typeid<_Tp>(__info, __fallback_id))
+      return static_cast<void*>(&__this.__s_.__buf);
+    return nullptr;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static void* __type_info() {
+#  if !defined(_LIBCPP_HAS_NO_RTTI)
+    return const_cast<void*>(static_cast<void const*>(&typeid(_Tp)));
+#  else
+    return nullptr;
+#  endif
+  }
+};
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS _LargeHandler {
+  _LIBCPP_HIDE_FROM_ABI static void*
+  __handle(_Action __act, any const* __this, any* __other, type_info const* __info, void const* __fallback_info) {
+    switch (__act) {
+    case _Action::_Destroy:
+      __destroy(const_cast<any&>(*__this));
+      return nullptr;
+    case _Action::_Copy:
+      __copy(*__this, *__other);
+      return nullptr;
+    case _Action::_Move:
+      __move(const_cast<any&>(*__this), *__other);
+      return nullptr;
+    case _Action::_Get:
+      return __get(const_cast<any&>(*__this), __info, __fallback_info);
+    case _Action::_TypeInfo:
+      return __type_info();
     }
+    __libcpp_unreachable();
+  }
 
-  private:
-    _LIBCPP_INLINE_VISIBILITY
-    static void __destroy(any & __this) {
-        typedef allocator<_Tp> _Alloc;
-        typedef allocator_traits<_Alloc> _ATraits;
-        _Alloc __a;
-        _Tp * __p = static_cast<_Tp *>(static_cast<void*>(&__this.__s_.__buf));
-        _ATraits::destroy(__a, __p);
-        __this.__h_ = nullptr;
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI static _Tp& __create(any& __dest, _Args&&... __args) {
+    typedef allocator<_Tp> _Alloc;
+    typedef allocator_traits<_Alloc> _ATraits;
+    typedef __allocator_destructor<_Alloc> _Dp;
+    _Alloc __a;
+    unique_ptr<_Tp, _Dp> __hold(_ATraits::allocate(__a, 1), _Dp(__a, 1));
+    _Tp* __ret = __hold.get();
+    _ATraits::construct(__a, __ret, std::forward<_Args>(__args)...);
+    __dest.__s_.__ptr = __hold.release();
+    __dest.__h_       = &_LargeHandler::__handle;
+    return *__ret;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    static void __copy(any const & __this, any & __dest) {
-        _SmallHandler::__create(__dest, *static_cast<_Tp const *>(
-            static_cast<void const *>(&__this.__s_.__buf)));
-    }
+private:
+  _LIBCPP_HIDE_FROM_ABI static void __destroy(any& __this) {
+    typedef allocator<_Tp> _Alloc;
+    typedef allocator_traits<_Alloc> _ATraits;
+    _Alloc __a;
+    _Tp* __p = static_cast<_Tp*>(__this.__s_.__ptr);
+    _ATraits::destroy(__a, __p);
+    _ATraits::deallocate(__a, __p, 1);
+    __this.__h_ = nullptr;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    static void __move(any & __this, any & __dest) {
-        _SmallHandler::__create(__dest, _VSTD::move(
-            *static_cast<_Tp*>(static_cast<void*>(&__this.__s_.__buf))));
-        __destroy(__this);
-    }
+  _LIBCPP_HIDE_FROM_ABI static void __copy(any const& __this, any& __dest) {
+    _LargeHandler::__create(__dest, *static_cast<_Tp const*>(__this.__s_.__ptr));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    static void* __get(any & __this,
-                       type_info const * __info,
-                       const void* __fallback_id)
-    {
-        if (__any_imp::__compare_typeid<_Tp>(__info, __fallback_id))
-            return static_cast<void*>(&__this.__s_.__buf);
-        return nullptr;
-    }
+  _LIBCPP_HIDE_FROM_ABI static void __move(any& __this, any& __dest) {
+    __dest.__s_.__ptr = __this.__s_.__ptr;
+    __dest.__h_       = &_LargeHandler::__handle;
+    __this.__h_       = nullptr;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    static void* __type_info()
-    {
-#if !defined(_LIBCPP_HAS_NO_RTTI)
-        return const_cast<void*>(static_cast<void const *>(&typeid(_Tp)));
-#else
-        return nullptr;
-#endif
-    }
-  };
+  _LIBCPP_HIDE_FROM_ABI static void* __get(any& __this, type_info const* __info, void const* __fallback_info) {
+    if (__any_imp::__compare_typeid<_Tp>(__info, __fallback_info))
+      return static_cast<void*>(__this.__s_.__ptr);
+    return nullptr;
+  }
 
-  template <class _Tp>
-  struct _LIBCPP_TEMPLATE_VIS _LargeHandler
-  {
-    _LIBCPP_INLINE_VISIBILITY
-    static void* __handle(_Action __act, any const * __this,
-                          any * __other, type_info const * __info,
-                          void const* __fallback_info)
-    {
-        switch (__act)
-        {
-        case _Action::_Destroy:
-          __destroy(const_cast<any &>(*__this));
-          return nullptr;
-        case _Action::_Copy:
-          __copy(*__this, *__other);
-          return nullptr;
-        case _Action::_Move:
-          __move(const_cast<any &>(*__this), *__other);
-          return nullptr;
-        case _Action::_Get:
-            return __get(const_cast<any &>(*__this), __info, __fallback_info);
-        case _Action::_TypeInfo:
-          return __type_info();
-        }
-        __libcpp_unreachable();
-    }
-
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
-    static _Tp& __create(any & __dest, _Args&&... __args) {
-        typedef allocator<_Tp> _Alloc;
-        typedef allocator_traits<_Alloc> _ATraits;
-        typedef __allocator_destructor<_Alloc> _Dp;
-        _Alloc __a;
-        unique_ptr<_Tp, _Dp> __hold(_ATraits::allocate(__a, 1), _Dp(__a, 1));
-        _Tp * __ret = __hold.get();
-        _ATraits::construct(__a, __ret, _VSTD::forward<_Args>(__args)...);
-        __dest.__s_.__ptr = __hold.release();
-        __dest.__h_ = &_LargeHandler::__handle;
-        return *__ret;
-    }
-
-  private:
-
-    _LIBCPP_INLINE_VISIBILITY
-    static void __destroy(any & __this){
-        typedef allocator<_Tp> _Alloc;
-        typedef allocator_traits<_Alloc> _ATraits;
-        _Alloc __a;
-        _Tp * __p = static_cast<_Tp *>(__this.__s_.__ptr);
-        _ATraits::destroy(__a, __p);
-        _ATraits::deallocate(__a, __p, 1);
-        __this.__h_ = nullptr;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    static void __copy(any const & __this, any & __dest) {
-        _LargeHandler::__create(__dest, *static_cast<_Tp const *>(__this.__s_.__ptr));
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    static void __move(any & __this, any & __dest) {
-      __dest.__s_.__ptr = __this.__s_.__ptr;
-      __dest.__h_ = &_LargeHandler::__handle;
-      __this.__h_ = nullptr;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    static void* __get(any & __this, type_info const * __info,
-                       void const* __fallback_info)
-    {
-        if (__any_imp::__compare_typeid<_Tp>(__info, __fallback_info))
-            return static_cast<void*>(__this.__s_.__ptr);
-        return nullptr;
-
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    static void* __type_info()
-    {
-#if !defined(_LIBCPP_HAS_NO_RTTI)
-        return const_cast<void*>(static_cast<void const *>(&typeid(_Tp)));
-#else
-        return nullptr;
-#endif
-    }
-  };
+  _LIBCPP_HIDE_FROM_ABI static void* __type_info() {
+#  if !defined(_LIBCPP_HAS_NO_RTTI)
+    return const_cast<void*>(static_cast<void const*>(&typeid(_Tp)));
+#  else
+    return nullptr;
+#  endif
+  }
+};
 
 } // namespace __any_imp
 
-
 template <class _ValueType, class _Tp, class>
-any::any(_ValueType && __v) : __h_(nullptr)
-{
-  __any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_ValueType>(__v));
+any::any(_ValueType&& __v) : __h_(nullptr) {
+  __any_imp::_Handler<_Tp>::__create(*this, std::forward<_ValueType>(__v));
 }
 
-template <class _ValueType, class ..._Args, class _Tp, class>
+template <class _ValueType, class... _Args, class _Tp, class>
 any::any(in_place_type_t<_ValueType>, _Args&&... __args) {
-  __any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_Args>(__args)...);
+  __any_imp::_Handler<_Tp>::__create(*this, std::forward<_Args>(__args)...);
 }
 
-template <class _ValueType, class _Up, class ..._Args, class _Tp, class>
+template <class _ValueType, class _Up, class... _Args, class _Tp, class>
 any::any(in_place_type_t<_ValueType>, initializer_list<_Up> __il, _Args&&... __args) {
-  __any_imp::_Handler<_Tp>::__create(*this, __il, _VSTD::forward<_Args>(__args)...);
+  __any_imp::_Handler<_Tp>::__create(*this, __il, std::forward<_Args>(__args)...);
 }
 
 template <class _ValueType, class, class>
-inline _LIBCPP_INLINE_VISIBILITY
-any & any::operator=(_ValueType && __v)
-{
-  any(_VSTD::forward<_ValueType>(__v)).swap(*this);
+inline _LIBCPP_HIDE_FROM_ABI any& any::operator=(_ValueType&& __v) {
+  any(std::forward<_ValueType>(__v)).swap(*this);
   return *this;
 }
 
-template <class _ValueType, class ..._Args, class _Tp, class>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp& any::emplace(_Args&&... __args) {
+template <class _ValueType, class... _Args, class _Tp, class>
+inline _LIBCPP_HIDE_FROM_ABI _Tp& any::emplace(_Args&&... __args) {
   reset();
-  return __any_imp::_Handler<_Tp>::__create(*this, _VSTD::forward<_Args>(__args)...);
+  return __any_imp::_Handler<_Tp>::__create(*this, std::forward<_Args>(__args)...);
 }
 
-template <class _ValueType, class _Up, class ..._Args, class _Tp, class>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp& any::emplace(initializer_list<_Up> __il, _Args&&... __args) {
+template <class _ValueType, class _Up, class... _Args, class _Tp, class>
+inline _LIBCPP_HIDE_FROM_ABI _Tp& any::emplace(initializer_list<_Up> __il, _Args&&... __args) {
   reset();
-  return __any_imp::_Handler<_Tp>::__create(*this, __il, _VSTD::forward<_Args>(__args)...);
+  return __any_imp::_Handler<_Tp>::__create(*this, __il, std::forward<_Args>(__args)...);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-void any::swap(any & __rhs) _NOEXCEPT
-{
-    if (this == &__rhs)
-      return;
-    if (__h_ && __rhs.__h_) {
-        any __tmp;
-        __rhs.__call(_Action::_Move, &__tmp);
-        this->__call(_Action::_Move, &__rhs);
-        __tmp.__call(_Action::_Move, this);
-    }
-    else if (__h_) {
-        this->__call(_Action::_Move, &__rhs);
-    }
-    else if (__rhs.__h_) {
-        __rhs.__call(_Action::_Move, this);
-    }
+inline _LIBCPP_HIDE_FROM_ABI void any::swap(any& __rhs) _NOEXCEPT {
+  if (this == &__rhs)
+    return;
+  if (__h_ && __rhs.__h_) {
+    any __tmp;
+    __rhs.__call(_Action::_Move, &__tmp);
+    this->__call(_Action::_Move, &__rhs);
+    __tmp.__call(_Action::_Move, this);
+  } else if (__h_) {
+    this->__call(_Action::_Move, &__rhs);
+  } else if (__rhs.__h_) {
+    __rhs.__call(_Action::_Move, this);
+  }
 }
 
 // 6.4 Non-member functions
 
-inline _LIBCPP_INLINE_VISIBILITY
-void swap(any & __lhs, any & __rhs) _NOEXCEPT
-{
-    __lhs.swap(__rhs);
+inline _LIBCPP_HIDE_FROM_ABI void swap(any& __lhs, any& __rhs) _NOEXCEPT { __lhs.swap(__rhs); }
+
+template <class _Tp, class... _Args>
+inline _LIBCPP_HIDE_FROM_ABI any make_any(_Args&&... __args) {
+  return any(in_place_type<_Tp>, std::forward<_Args>(__args)...);
 }
 
-template <class _Tp, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-any make_any(_Args&&... __args) {
-    return any(in_place_type<_Tp>, _VSTD::forward<_Args>(__args)...);
-}
-
-template <class _Tp, class _Up, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-any make_any(initializer_list<_Up> __il, _Args&&... __args) {
-    return any(in_place_type<_Tp>, __il, _VSTD::forward<_Args>(__args)...);
+template <class _Tp, class _Up, class... _Args>
+inline _LIBCPP_HIDE_FROM_ABI any make_any(initializer_list<_Up> __il, _Args&&... __args) {
+  return any(in_place_type<_Tp>, __il, std::forward<_Args>(__args)...);
 }
 
 template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
-_ValueType any_cast(any const & __v)
-{
-    using _RawValueType = __remove_cvref_t<_ValueType>;
-    static_assert(is_constructible<_ValueType, _RawValueType const &>::value,
-                  "ValueType is required to be a const lvalue reference "
-                  "or a CopyConstructible type");
-    auto __tmp = _VSTD::any_cast<add_const_t<_RawValueType>>(&__v);
-    if (__tmp == nullptr)
-        __throw_bad_any_cast();
-    return static_cast<_ValueType>(*__tmp);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _ValueType any_cast(any const& __v) {
+  using _RawValueType = __remove_cvref_t<_ValueType>;
+  static_assert(is_constructible<_ValueType, _RawValueType const&>::value,
+                "ValueType is required to be a const lvalue reference "
+                "or a CopyConstructible type");
+  auto __tmp = std::any_cast<add_const_t<_RawValueType>>(&__v);
+  if (__tmp == nullptr)
+    __throw_bad_any_cast();
+  return static_cast<_ValueType>(*__tmp);
 }
 
 template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
-_ValueType any_cast(any & __v)
-{
-    using _RawValueType = __remove_cvref_t<_ValueType>;
-    static_assert(is_constructible<_ValueType, _RawValueType &>::value,
-                  "ValueType is required to be an lvalue reference "
-                  "or a CopyConstructible type");
-    auto __tmp = _VSTD::any_cast<_RawValueType>(&__v);
-    if (__tmp == nullptr)
-        __throw_bad_any_cast();
-    return static_cast<_ValueType>(*__tmp);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _ValueType any_cast(any& __v) {
+  using _RawValueType = __remove_cvref_t<_ValueType>;
+  static_assert(is_constructible<_ValueType, _RawValueType&>::value,
+                "ValueType is required to be an lvalue reference "
+                "or a CopyConstructible type");
+  auto __tmp = std::any_cast<_RawValueType>(&__v);
+  if (__tmp == nullptr)
+    __throw_bad_any_cast();
+  return static_cast<_ValueType>(*__tmp);
 }
 
 template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST
-_ValueType any_cast(any && __v)
-{
-    using _RawValueType = __remove_cvref_t<_ValueType>;
-    static_assert(is_constructible<_ValueType, _RawValueType>::value,
-                  "ValueType is required to be an rvalue reference "
-                  "or a CopyConstructible type");
-    auto __tmp = _VSTD::any_cast<_RawValueType>(&__v);
-    if (__tmp == nullptr)
-        __throw_bad_any_cast();
-    return static_cast<_ValueType>(_VSTD::move(*__tmp));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _ValueType any_cast(any&& __v) {
+  using _RawValueType = __remove_cvref_t<_ValueType>;
+  static_assert(is_constructible<_ValueType, _RawValueType>::value,
+                "ValueType is required to be an rvalue reference "
+                "or a CopyConstructible type");
+  auto __tmp = std::any_cast<_RawValueType>(&__v);
+  if (__tmp == nullptr)
+    __throw_bad_any_cast();
+  return static_cast<_ValueType>(std::move(*__tmp));
 }
 
 template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-add_pointer_t<add_const_t<_ValueType>>
-any_cast(any const * __any) _NOEXCEPT
-{
-    static_assert(!is_reference<_ValueType>::value,
-                  "_ValueType may not be a reference.");
-    return _VSTD::any_cast<_ValueType>(const_cast<any *>(__any));
+inline _LIBCPP_HIDE_FROM_ABI add_pointer_t<add_const_t<_ValueType>> any_cast(any const* __any) _NOEXCEPT {
+  static_assert(!is_void_v<_ValueType>, "_ValueType may not be void.");
+  static_assert(!is_reference<_ValueType>::value, "_ValueType may not be a reference.");
+  return std::any_cast<_ValueType>(const_cast<any*>(__any));
 }
 
 template <class _RetType>
-inline _LIBCPP_INLINE_VISIBILITY
-_RetType __pointer_or_func_cast(void* __p, /*IsFunction*/false_type) noexcept {
+inline _LIBCPP_HIDE_FROM_ABI _RetType __pointer_or_func_cast(void* __p, /*IsFunction*/ false_type) noexcept {
   return static_cast<_RetType>(__p);
 }
 
 template <class _RetType>
-inline _LIBCPP_INLINE_VISIBILITY
-_RetType __pointer_or_func_cast(void*, /*IsFunction*/true_type) noexcept {
+inline _LIBCPP_HIDE_FROM_ABI _RetType __pointer_or_func_cast(void*, /*IsFunction*/ true_type) noexcept {
   return nullptr;
 }
 
 template <class _ValueType>
-_LIBCPP_HIDE_FROM_ABI
-add_pointer_t<_ValueType>
-any_cast(any * __any) _NOEXCEPT
-{
-    using __any_imp::_Action;
-    static_assert(!is_reference<_ValueType>::value,
-                  "_ValueType may not be a reference.");
-    typedef add_pointer_t<_ValueType> _ReturnType;
-    if (__any && __any->__h_) {
-      void *__p = __any->__call(_Action::_Get, nullptr,
-#if !defined(_LIBCPP_HAS_NO_RTTI)
-                          &typeid(_ValueType),
-#else
-                          nullptr,
-#endif
-                          __any_imp::__get_fallback_typeid<_ValueType>());
-        return _VSTD::__pointer_or_func_cast<_ReturnType>(
-            __p, is_function<_ValueType>{});
-    }
-    return nullptr;
+_LIBCPP_HIDE_FROM_ABI add_pointer_t<_ValueType> any_cast(any* __any) _NOEXCEPT {
+  using __any_imp::_Action;
+  static_assert(!is_void_v<_ValueType>, "_ValueType may not be void.");
+  static_assert(!is_reference<_ValueType>::value, "_ValueType may not be a reference.");
+  typedef add_pointer_t<_ValueType> _ReturnType;
+  if (__any && __any->__h_) {
+    void* __p = __any->__call(
+        _Action::_Get,
+        nullptr,
+#  if !defined(_LIBCPP_HAS_NO_RTTI)
+        &typeid(_ValueType),
+#  else
+        nullptr,
+#  endif
+        __any_imp::__get_fallback_typeid<_ValueType>());
+    return std::__pointer_or_func_cast<_ReturnType>(__p, is_function<_ValueType>{});
+  }
+  return nullptr;
 }
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
diff --git a/third_party/libcxx/any.cpp b/third_party/libcxx/any.cpp
new file mode 100644
index 000000000..b0ad69566
--- /dev/null
+++ b/third_party/libcxx/any.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <any>
+
+namespace std {
+const char* bad_any_cast::what() const noexcept { return "bad any cast"; }
+} // namespace std
+
+#include <experimental/__config>
+
+//  Preserve std::experimental::any_bad_cast for ABI compatibility
+//  Even though it no longer exists in a header file
+_LIBCPP_BEGIN_NAMESPACE_LFTS
+
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast {
+public:
+  virtual const char* what() const noexcept;
+};
+
+const char* bad_any_cast::what() const noexcept { return "bad any cast"; }
+
+_LIBCPP_END_NAMESPACE_LFTS
diff --git a/third_party/libcxx/array b/third_party/libcxx/array
index 5a8a1acca..6ffde852f 100644
--- a/third_party/libcxx/array
+++ b/third_party/libcxx/array
@@ -116,20 +116,23 @@ template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexce
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/swap_ranges.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
+#include <__fwd/array.h>
 #include <__iterator/reverse_iterator.h>
+#include <__iterator/wrap_iter.h>
 #include <__tuple/sfinae_helpers.h>
 #include <__type_traits/conditional.h>
+#include <__type_traits/conjunction.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_const.h>
 #include <__type_traits/is_constructible.h>
-#include <__type_traits/is_move_constructible.h>
 #include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
+#include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/remove_cv.h>
+#include <__utility/empty.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/unreachable.h>
@@ -157,279 +160,261 @@ template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexce
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS array
-{
-    // types:
-    typedef array __self;
-    typedef _Tp                                   value_type;
-    typedef value_type&                           reference;
-    typedef const value_type&                     const_reference;
-    typedef value_type*                           iterator;
-    typedef const value_type*                     const_iterator;
-    typedef value_type*                           pointer;
-    typedef const value_type*                     const_pointer;
-    typedef size_t                                size_type;
-    typedef ptrdiff_t                             difference_type;
-    typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
+struct _LIBCPP_TEMPLATE_VIS array {
+  using __trivially_relocatable = __conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, array, void>;
 
-    _Tp __elems_[_Size];
+  // types:
+  using __self          = array;
+  using value_type      = _Tp;
+  using reference       = value_type&;
+  using const_reference = const value_type&;
+  using pointer         = value_type*;
+  using const_pointer   = const value_type*;
+#if defined(_LIBCPP_ABI_USE_WRAP_ITER_IN_STD_ARRAY)
+  using iterator       = __wrap_iter<pointer>;
+  using const_iterator = __wrap_iter<const_pointer>;
+#else
+  using iterator       = pointer;
+  using const_iterator = const_pointer;
+#endif
+  using size_type              = size_t;
+  using difference_type        = ptrdiff_t;
+  using reverse_iterator       = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-    // No explicit construct/copy/destroy for aggregate type
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void fill(const value_type& __u) {
-        _VSTD::fill_n(data(), _Size, __u);
-    }
+  _Tp __elems_[_Size];
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
-        _VSTD::swap_ranges(data(), data() + _Size, __a.data());
-    }
+  // No explicit construct/copy/destroy for aggregate type
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void fill(const value_type& __u) {
+    std::fill_n(data(), _Size, __u);
+  }
 
-    // iterators:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    iterator begin() _NOEXCEPT {return iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    iterator end() _NOEXCEPT {return iterator(data() + _Size);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_iterator end() const _NOEXCEPT {return const_iterator(data() + _Size);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable_v<_Tp>) {
+    std::swap_ranges(data(), data() + _Size, __a.data());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
+  // iterators:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator begin() _NOEXCEPT { return iterator(data()); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator begin() const _NOEXCEPT {
+    return const_iterator(data());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator end() _NOEXCEPT { return iterator(data() + _Size); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator end() const _NOEXCEPT {
+    return const_iterator(data() + _Size);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_iterator cbegin() const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rbegin() _NOEXCEPT {
+    return reverse_iterator(end());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator rbegin() const _NOEXCEPT {
+    return const_reverse_iterator(end());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rend() _NOEXCEPT {
+    return reverse_iterator(begin());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator rend() const _NOEXCEPT {
+    return const_reverse_iterator(begin());
+  }
 
-    // capacity:
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return _Size;}
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return _Size;}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return _Size == 0;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cend() const _NOEXCEPT { return end(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator crbegin() const _NOEXCEPT {
+    return rbegin();
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
 
-    // element access:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference operator[](size_type __n) _NOEXCEPT {
-        _LIBCPP_ASSERT(__n < _Size, "out-of-bounds access in std::array<T, N>");
-        return __elems_[__n];
-    }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const_reference operator[](size_type __n) const _NOEXCEPT {
-        _LIBCPP_ASSERT(__n < _Size, "out-of-bounds access in std::array<T, N>");
-        return __elems_[__n];
-    }
+  // capacity:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT { return _Size; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT { return _Size; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT { return _Size == 0; }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference at(size_type __n)
-    {
-        if (__n >= _Size)
-            __throw_out_of_range("array::at");
-        return __elems_[__n];
-    }
+  // element access:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](size_type __n) _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < _Size, "out-of-bounds access in std::array<T, N>");
+    return __elems_[__n];
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference operator[](size_type __n) const _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < _Size, "out-of-bounds access in std::array<T, N>");
+    return __elems_[__n];
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference at(size_type __n) const
-    {
-        if (__n >= _Size)
-            __throw_out_of_range("array::at");
-        return __elems_[__n];
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference at(size_type __n) {
+    if (__n >= _Size)
+      __throw_out_of_range("array::at");
+    return __elems_[__n];
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 reference front()             _NOEXCEPT {return (*this)[0];}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference front() const _NOEXCEPT {return (*this)[0];}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17 reference back()              _NOEXCEPT {return (*this)[_Size - 1];}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference back() const  _NOEXCEPT {return (*this)[_Size - 1];}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference at(size_type __n) const {
+    if (__n >= _Size)
+      __throw_out_of_range("array::at");
+    return __elems_[__n];
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    value_type* data() _NOEXCEPT {return __elems_;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const value_type* data() const _NOEXCEPT {return __elems_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference front() _NOEXCEPT { return (*this)[0]; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference front() const _NOEXCEPT { return (*this)[0]; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference back() _NOEXCEPT { return (*this)[_Size - 1]; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference back() const _NOEXCEPT {
+    return (*this)[_Size - 1];
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 value_type* data() _NOEXCEPT { return __elems_; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const value_type* data() const _NOEXCEPT { return __elems_; }
 };
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0>
-{
-    // types:
-    typedef array __self;
-    typedef _Tp                                   value_type;
-    typedef value_type&                           reference;
-    typedef const value_type&                     const_reference;
-    typedef value_type*                           iterator;
-    typedef const value_type*                     const_iterator;
-    typedef value_type*                           pointer;
-    typedef const value_type*                     const_pointer;
-    typedef size_t                                size_type;
-    typedef ptrdiff_t                             difference_type;
-    typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
+struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0> {
+  // types:
+  typedef array __self;
+  typedef _Tp value_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef value_type* iterator;
+  typedef const value_type* const_iterator;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
-    typedef __conditional_t<is_const<_Tp>::value, const char, char> _CharType;
+  typedef __conditional_t<is_const<_Tp>::value, const __empty, __empty> _EmptyType;
 
-    struct  _ArrayInStructT { _Tp __data_[1]; };
-    _ALIGNAS_TYPE(_ArrayInStructT) _CharType __elems_[sizeof(_ArrayInStructT)];
+  struct _ArrayInStructT {
+    _Tp __data_[1];
+  };
+  _ALIGNAS_TYPE(_ArrayInStructT) _EmptyType __elems_[sizeof(_ArrayInStructT)];
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    value_type* data() _NOEXCEPT {return nullptr;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const value_type* data() const _NOEXCEPT {return nullptr;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 value_type* data() _NOEXCEPT { return nullptr; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const value_type* data() const _NOEXCEPT { return nullptr; }
 
-    // No explicit construct/copy/destroy for aggregate type
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void fill(const value_type&) {
-      static_assert(!is_const<_Tp>::value,
-                    "cannot fill zero-sized array of type 'const T'");
-    }
+  // No explicit construct/copy/destroy for aggregate type
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void fill(const value_type&) {
+    static_assert(!is_const<_Tp>::value, "cannot fill zero-sized array of type 'const T'");
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void swap(array&) _NOEXCEPT {
-      static_assert(!is_const<_Tp>::value,
-                    "cannot swap zero-sized array of type 'const T'");
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(array&) _NOEXCEPT {
+    static_assert(!is_const<_Tp>::value, "cannot swap zero-sized array of type 'const T'");
+  }
 
-    // iterators:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    iterator begin() _NOEXCEPT {return iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_iterator begin() const _NOEXCEPT {return const_iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    iterator end() _NOEXCEPT {return iterator(data());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_iterator end() const _NOEXCEPT {return const_iterator(data());}
+  // iterators:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator begin() _NOEXCEPT { return iterator(data()); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator begin() const _NOEXCEPT {
+    return const_iterator(data());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator end() _NOEXCEPT { return iterator(data()); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator end() const _NOEXCEPT {
+    return const_iterator(data());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rbegin() _NOEXCEPT {
+    return reverse_iterator(end());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator rbegin() const _NOEXCEPT {
+    return const_reverse_iterator(end());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rend() _NOEXCEPT {
+    return reverse_iterator(begin());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator rend() const _NOEXCEPT {
+    return const_reverse_iterator(begin());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_iterator cbegin() const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cend() const _NOEXCEPT { return end(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator crbegin() const _NOEXCEPT {
+    return rbegin();
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
 
-    // capacity:
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT {return 0; }
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT {return 0;}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT {return true;}
+  // capacity:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT { return 0; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT { return 0; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT { return true; }
 
-    // element access:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference operator[](size_type) _NOEXCEPT {
-      _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
-      __libcpp_unreachable();
-    }
+  // element access:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](size_type) _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
+    __libcpp_unreachable();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const_reference operator[](size_type) const _NOEXCEPT {
-      _LIBCPP_ASSERT(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
-      __libcpp_unreachable();
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference operator[](size_type) const _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
+    __libcpp_unreachable();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference at(size_type) {
-      __throw_out_of_range("array<T, 0>::at");
-      __libcpp_unreachable();
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference at(size_type) {
+    __throw_out_of_range("array<T, 0>::at");
+    __libcpp_unreachable();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const_reference at(size_type) const {
-      __throw_out_of_range("array<T, 0>::at");
-      __libcpp_unreachable();
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference at(size_type) const {
+    __throw_out_of_range("array<T, 0>::at");
+    __libcpp_unreachable();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference front() _NOEXCEPT {
-      _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
-      __libcpp_unreachable();
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference front() _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::front() on a zero-sized array");
+    __libcpp_unreachable();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const_reference front() const _NOEXCEPT {
-      _LIBCPP_ASSERT(false, "cannot call array<T, 0>::front() on a zero-sized array");
-      __libcpp_unreachable();
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference front() const _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::front() on a zero-sized array");
+    __libcpp_unreachable();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
-    reference back() _NOEXCEPT {
-      _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
-      __libcpp_unreachable();
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference back() _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::back() on a zero-sized array");
+    __libcpp_unreachable();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const_reference back() const _NOEXCEPT {
-      _LIBCPP_ASSERT(false, "cannot call array<T, 0>::back() on a zero-sized array");
-      __libcpp_unreachable();
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference back() const _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::back() on a zero-sized array");
+    __libcpp_unreachable();
+  }
 };
 
-
 #if _LIBCPP_STD_VER >= 17
-template<class _Tp, class... _Args,
-         class = enable_if_t<__all<_IsSame<_Tp, _Args>::value...>::value>
-         >
-array(_Tp, _Args...)
-  -> array<_Tp, 1 + sizeof...(_Args)>;
+template <class _Tp, class... _Args, class = enable_if_t<__all<_IsSame<_Tp, _Args>::value...>::value> >
+array(_Tp, _Args...) -> array<_Tp, 1 + sizeof...(_Args)>;
 #endif
 
 template <class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
-{
-    return _VSTD::equal(__x.begin(), __x.end(), __y.begin());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
+operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
+  return std::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 #if _LIBCPP_STD_VER <= 17
 
 template <class _Tp, size_t _Size>
 inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
-    return !(__x == __y);
+  return !(__x == __y);
 }
 
 template <class _Tp, size_t _Size>
 inline _LIBCPP_HIDE_FROM_ABI bool operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+  return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, size_t _Size>
 inline _LIBCPP_HIDE_FROM_ABI bool operator>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
-    return __y < __x;
+  return __y < __x;
 }
 
 template <class _Tp, size_t _Size>
 inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
-    return !(__y < __x);
+  return !(__y < __x);
 }
 
 template <class _Tp, size_t _Size>
 inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
-    return !(__x < __y);
+  return !(__x < __y);
 }
 
 #else // _LIBCPP_STD_VER <= 17
@@ -437,111 +422,87 @@ inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const array<_Tp, _Size>& __x, const
 template <class _Tp, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI constexpr __synth_three_way_result<_Tp>
 operator<=>(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y) {
-    return std::lexicographical_compare_three_way(
-        __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way<_Tp, _Tp>);
+  return std::lexicographical_compare_three_way(
+      __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
 }
 
 #endif // _LIBCPP_STD_VER <= 17
 
-template <class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-__enable_if_t<_Size == 0 || __is_swappable<_Tp>::value, void>
-swap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y)
-                                  _NOEXCEPT_(noexcept(__x.swap(__y)))
-{
-    __x.swap(__y);
+template <class _Tp, size_t _Size, __enable_if_t<_Size == 0 || __is_swappable_v<_Tp>, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(array<_Tp, _Size>& __x, array<_Tp, _Size>& __y)
+    _NOEXCEPT_(noexcept(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 template <class _Tp, size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS tuple_size<array<_Tp, _Size> >
-    : public integral_constant<size_t, _Size> {};
+struct _LIBCPP_TEMPLATE_VIS tuple_size<array<_Tp, _Size> > : public integral_constant<size_t, _Size> {};
 
 template <size_t _Ip, class _Tp, size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, array<_Tp, _Size> >
-{
-    static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::array)");
-    typedef _Tp type;
+struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, array<_Tp, _Size> > {
+  static_assert(_Ip < _Size, "Index out of bounds in std::tuple_element<> (std::array)");
+  typedef _Tp type;
 };
 
 template <size_t _Ip, class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp&
-get(array<_Tp, _Size>& __a) _NOEXCEPT
-{
-    static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array)");
-    return __a.__elems_[_Ip];
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp& get(array<_Tp, _Size>& __a) _NOEXCEPT {
+  static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array)");
+  return __a.__elems_[_Ip];
 }
 
 template <size_t _Ip, class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const _Tp&
-get(const array<_Tp, _Size>& __a) _NOEXCEPT
-{
-    static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array)");
-    return __a.__elems_[_Ip];
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp& get(const array<_Tp, _Size>& __a) _NOEXCEPT {
+  static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array)");
+  return __a.__elems_[_Ip];
 }
 
 template <size_t _Ip, class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp&&
-get(array<_Tp, _Size>&& __a) _NOEXCEPT
-{
-    static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)");
-    return _VSTD::move(__a.__elems_[_Ip]);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp&& get(array<_Tp, _Size>&& __a) _NOEXCEPT {
+  static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)");
+  return std::move(__a.__elems_[_Ip]);
 }
 
 template <size_t _Ip, class _Tp, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const _Tp&&
-get(const array<_Tp, _Size>&& __a) _NOEXCEPT
-{
-    static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)");
-    return _VSTD::move(__a.__elems_[_Ip]);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp&& get(const array<_Tp, _Size>&& __a) _NOEXCEPT {
+  static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)");
+  return std::move(__a.__elems_[_Ip]);
 }
 
 #if _LIBCPP_STD_VER >= 20
 
 template <typename _Tp, size_t _Size, size_t... _Index>
-_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>
+_LIBCPP_HIDE_FROM_ABI constexpr array<remove_cv_t<_Tp>, _Size>
 __to_array_lvalue_impl(_Tp (&__arr)[_Size], index_sequence<_Index...>) {
   return {{__arr[_Index]...}};
 }
 
 template <typename _Tp, size_t _Size, size_t... _Index>
-_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>
-__to_array_rvalue_impl(_Tp(&&__arr)[_Size], index_sequence<_Index...>) {
-  return {{_VSTD::move(__arr[_Index])...}};
+_LIBCPP_HIDE_FROM_ABI constexpr array<remove_cv_t<_Tp>, _Size>
+__to_array_rvalue_impl(_Tp (&&__arr)[_Size], index_sequence<_Index...>) {
+  return {{std::move(__arr[_Index])...}};
 }
 
 template <typename _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>
+_LIBCPP_HIDE_FROM_ABI constexpr array<remove_cv_t<_Tp>, _Size>
 to_array(_Tp (&__arr)[_Size]) noexcept(is_nothrow_constructible_v<_Tp, _Tp&>) {
-  static_assert(
-      !is_array_v<_Tp>,
-      "[array.creation]/1: to_array does not accept multidimensional arrays.");
-  static_assert(
-      is_constructible_v<_Tp, _Tp&>,
-      "[array.creation]/1: to_array requires copy constructible elements.");
-  return _VSTD::__to_array_lvalue_impl(__arr, make_index_sequence<_Size>());
+  static_assert(!is_array_v<_Tp>, "[array.creation]/1: to_array does not accept multidimensional arrays.");
+  static_assert(is_constructible_v<_Tp, _Tp&>, "[array.creation]/1: to_array requires copy constructible elements.");
+  return std::__to_array_lvalue_impl(__arr, make_index_sequence<_Size>());
 }
 
 template <typename _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY constexpr array<remove_cv_t<_Tp>, _Size>
-to_array(_Tp(&&__arr)[_Size]) noexcept(is_nothrow_move_constructible_v<_Tp>) {
-  static_assert(
-      !is_array_v<_Tp>,
-      "[array.creation]/4: to_array does not accept multidimensional arrays.");
-  static_assert(
-      is_move_constructible_v<_Tp>,
-      "[array.creation]/4: to_array requires move constructible elements.");
-  return _VSTD::__to_array_rvalue_impl(_VSTD::move(__arr),
-                                       make_index_sequence<_Size>());
+_LIBCPP_HIDE_FROM_ABI constexpr array<remove_cv_t<_Tp>, _Size>
+to_array(_Tp (&&__arr)[_Size]) noexcept(is_nothrow_move_constructible_v<_Tp>) {
+  static_assert(!is_array_v<_Tp>, "[array.creation]/4: to_array does not accept multidimensional arrays.");
+  static_assert(is_move_constructible_v<_Tp>, "[array.creation]/4: to_array requires move constructible elements.");
+  return std::__to_array_rvalue_impl(std::move(__arr), make_index_sequence<_Size>());
 }
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <concepts>
diff --git a/third_party/libcxx/atomic b/third_party/libcxx/atomic
index 2f122a707..0d13619d6 100644
--- a/third_party/libcxx/atomic
+++ b/third_party/libcxx/atomic
@@ -262,6 +262,72 @@ struct atomic<T*>
     void notify_all() noexcept;
 };
 
+template<>
+struct atomic<floating-point-type> {  // since C++20
+  using value_type = floating-point-type;
+  using difference_type = value_type;
+
+  static constexpr bool is_always_lock_free = implementation-defined;
+  bool is_lock_free() const volatile noexcept;
+  bool is_lock_free() const noexcept;
+
+  constexpr atomic() noexcept;
+  constexpr atomic(floating-point-type) noexcept;
+  atomic(const atomic&) = delete;
+  atomic& operator=(const atomic&) = delete;
+  atomic& operator=(const atomic&) volatile = delete;
+
+  void store(floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
+  void store(floating-point-type, memory_order = memory_order::seq_cst) noexcept;
+  floating-point-type operator=(floating-point-type) volatile noexcept;
+  floating-point-type operator=(floating-point-type) noexcept;
+  floating-point-type load(memory_order = memory_order::seq_cst) volatile noexcept;
+  floating-point-type load(memory_order = memory_order::seq_cst) noexcept;
+  operator floating-point-type() volatile noexcept;
+  operator floating-point-type() noexcept;
+
+  floating-point-type exchange(floating-point-type,
+                               memory_order = memory_order::seq_cst) volatile noexcept;
+  floating-point-type exchange(floating-point-type,
+                               memory_order = memory_order::seq_cst) noexcept;
+  bool compare_exchange_weak(floating-point-type&, floating-point-type,
+                             memory_order, memory_order) volatile noexcept;
+  bool compare_exchange_weak(floating-point-type&, floating-point-type,
+                             memory_order, memory_order) noexcept;
+  bool compare_exchange_strong(floating-point-type&, floating-point-type,
+                               memory_order, memory_order) volatile noexcept;
+  bool compare_exchange_strong(floating-point-type&, floating-point-type,
+                               memory_order, memory_order) noexcept;
+  bool compare_exchange_weak(floating-point-type&, floating-point-type,
+                             memory_order = memory_order::seq_cst) volatile noexcept;
+  bool compare_exchange_weak(floating-point-type&, floating-point-type,
+                             memory_order = memory_order::seq_cst) noexcept;
+  bool compare_exchange_strong(floating-point-type&, floating-point-type,
+                               memory_order = memory_order::seq_cst) volatile noexcept;
+  bool compare_exchange_strong(floating-point-type&, floating-point-type,
+                               memory_order = memory_order::seq_cst) noexcept;
+
+  floating-point-type fetch_add(floating-point-type,
+                                memory_order = memory_order::seq_cst) volatile noexcept;
+  floating-point-type fetch_add(floating-point-type,
+                                memory_order = memory_order::seq_cst) noexcept;
+  floating-point-type fetch_sub(floating-point-type,
+                                memory_order = memory_order::seq_cst) volatile noexcept;
+  floating-point-type fetch_sub(floating-point-type,
+                                memory_order = memory_order::seq_cst) noexcept;
+
+  floating-point-type operator+=(floating-point-type) volatile noexcept;
+  floating-point-type operator+=(floating-point-type) noexcept;
+  floating-point-type operator-=(floating-point-type) volatile noexcept;
+  floating-point-type operator-=(floating-point-type) noexcept;
+
+  void wait(floating-point-type, memory_order = memory_order::seq_cst) const volatile noexcept;
+  void wait(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
+  void notify_one() volatile noexcept;
+  void notify_one() noexcept;
+  void notify_all() volatile noexcept;
+  void notify_all() noexcept;
+};
 
 // [atomics.nonmembers], non-member functions
 template<class T>
@@ -448,6 +514,9 @@ typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
 typedef atomic<intmax_t>  atomic_intmax_t;
 typedef atomic<uintmax_t> atomic_uintmax_t;
 
+typedef see-below         atomic_signed_lock_free;   // since C++20
+typedef see-below         atomic_unsigned_lock_free; // since C++20
+
 // flag type and operations
 
 typedef struct atomic_flag
@@ -518,7 +587,12 @@ template <class T>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__config>
+
+#if _LIBCPP_STD_VER < 23 && defined(_LIBCPP_STDATOMIC_H)
+#  error <atomic> is incompatible with <stdatomic.h> before C++23. Please compile with -std=c++23.
+#endif
+
 #include <__atomic/aliases.h>
 #include <__atomic/atomic.h>
 #include <__atomic/atomic_base.h>
@@ -533,9 +607,12 @@ template <class T>
 #include <__atomic/is_always_lock_free.h>
 #include <__atomic/kill_dependency.h>
 #include <__atomic/memory_order.h>
-#include <__config>
 #include <version>
 
+#if _LIBCPP_STD_VER >= 20
+#  include <__atomic/atomic_ref.h>
+#endif
+
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
@@ -544,13 +621,10 @@ template <class T>
 #  error <atomic> is not implemented
 #endif
 
-#ifdef kill_dependency
-#  error <atomic> is incompatible with <stdatomic.h> before C++23. Please compile with -std=c++23.
-#endif
-
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <cmath>
 #  include <compare>
+#  include <cstdlib>
 #  include <cstring>
 #  include <type_traits>
 #endif
diff --git a/third_party/libcxx/atomic.cpp b/third_party/libcxx/atomic.cpp
new file mode 100644
index 000000000..7e127f8b8
--- /dev/null
+++ b/third_party/libcxx/atomic.cpp
@@ -0,0 +1,205 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__thread/timed_backoff_policy.h>
+#include <atomic>
+#include <climits>
+#include <functional>
+#include <thread>
+
+#ifdef __linux__
+
+#  include <linux/futex.h>
+#  include <sys/syscall.h>
+#  include <unistd.h>
+
+// libc++ uses SYS_futex as a universal syscall name. However, on 32 bit architectures
+// with a 64 bit time_t, we need to specify SYS_futex_time64.
+#  if !defined(SYS_futex) && defined(SYS_futex_time64)
+#    define SYS_futex SYS_futex_time64
+#  endif
+#  define _LIBCPP_FUTEX(...) syscall(SYS_futex, __VA_ARGS__)
+
+#elif defined(__FreeBSD__)
+
+#  include <sys/types.h>
+#  include <sys/umtx.h>
+
+#  define _LIBCPP_FUTEX(...) syscall(SYS_futex, __VA_ARGS__)
+
+#elif defined(__OpenBSD__)
+
+#  include <sys/futex.h>
+
+// OpenBSD has no indirect syscalls
+#  define _LIBCPP_FUTEX(...) futex(__VA_ARGS__)
+
+#else // <- Add other operating systems here
+
+// Baseline needs no new headers
+
+#  define _LIBCPP_FUTEX(...) syscall(SYS_futex, __VA_ARGS__)
+
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifdef __linux__
+
+static void
+__libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr, __cxx_contention_t __val) {
+  static constexpr timespec __timeout = {2, 0};
+  _LIBCPP_FUTEX(__ptr, FUTEX_WAIT_PRIVATE, __val, &__timeout, 0, 0);
+}
+
+static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr, bool __notify_one) {
+  _LIBCPP_FUTEX(__ptr, FUTEX_WAKE_PRIVATE, __notify_one ? 1 : INT_MAX, 0, 0, 0);
+}
+
+#elif defined(__APPLE__) && defined(_LIBCPP_USE_ULOCK)
+
+extern "C" int __ulock_wait(
+    uint32_t operation, void* addr, uint64_t value, uint32_t timeout); /* timeout is specified in microseconds */
+extern "C" int __ulock_wake(uint32_t operation, void* addr, uint64_t wake_value);
+
+// https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/sys/ulock.h#L82
+#  define UL_COMPARE_AND_WAIT64 5
+#  define ULF_WAKE_ALL 0x00000100
+
+static void
+__libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr, __cxx_contention_t __val) {
+  static_assert(sizeof(__cxx_atomic_contention_t) == 8, "Waiting on 8 bytes value");
+  __ulock_wait(UL_COMPARE_AND_WAIT64, const_cast<__cxx_atomic_contention_t*>(__ptr), __val, 0);
+}
+
+static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr, bool __notify_one) {
+  static_assert(sizeof(__cxx_atomic_contention_t) == 8, "Waking up on 8 bytes value");
+  __ulock_wake(
+      UL_COMPARE_AND_WAIT64 | (__notify_one ? 0 : ULF_WAKE_ALL), const_cast<__cxx_atomic_contention_t*>(__ptr), 0);
+}
+
+#elif defined(__FreeBSD__) && __SIZEOF_LONG__ == 8
+/*
+ * Since __cxx_contention_t is int64_t even on 32bit FreeBSD
+ * platforms, we have to use umtx ops that work on the long type, and
+ * limit its use to architectures where long and int64_t are synonyms.
+ */
+
+static void
+__libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr, __cxx_contention_t __val) {
+  _umtx_op(const_cast<__cxx_atomic_contention_t*>(__ptr), UMTX_OP_WAIT, __val, NULL, NULL);
+}
+
+static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr, bool __notify_one) {
+  _umtx_op(const_cast<__cxx_atomic_contention_t*>(__ptr), UMTX_OP_WAKE, __notify_one ? 1 : INT_MAX, NULL, NULL);
+}
+
+#else // <- Add other operating systems here
+
+// Baseline is just a timed backoff
+
+static void
+__libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr, __cxx_contention_t __val) {
+  __libcpp_thread_poll_with_backoff(
+      [=]() -> bool { return !__cxx_nonatomic_compare_equal(__cxx_atomic_load(__ptr, memory_order_relaxed), __val); },
+      __libcpp_timed_backoff_policy());
+}
+
+static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile*, bool) {}
+
+#endif // __linux__
+
+static constexpr size_t __libcpp_contention_table_size = (1 << 8); /* < there's no magic in this number */
+
+struct alignas(64) /*  aim to avoid false sharing */ __libcpp_contention_table_entry {
+  __cxx_atomic_contention_t __contention_state;
+  __cxx_atomic_contention_t __platform_state;
+  inline constexpr __libcpp_contention_table_entry() : __contention_state(0), __platform_state(0) {}
+};
+
+static __libcpp_contention_table_entry __libcpp_contention_table[__libcpp_contention_table_size];
+
+static hash<void const volatile*> __libcpp_contention_hasher;
+
+static __libcpp_contention_table_entry* __libcpp_contention_state(void const volatile* p) {
+  return &__libcpp_contention_table[__libcpp_contention_hasher(p) & (__libcpp_contention_table_size - 1)];
+}
+
+/* Given an atomic to track contention and an atomic to actually wait on, which may be
+   the same atomic, we try to detect contention to avoid spuriously calling the platform. */
+
+static void __libcpp_contention_notify(__cxx_atomic_contention_t volatile* __contention_state,
+                                       __cxx_atomic_contention_t const volatile* __platform_state,
+                                       bool __notify_one) {
+  if (0 != __cxx_atomic_load(__contention_state, memory_order_seq_cst))
+    // We only call 'wake' if we consumed a contention bit here.
+    __libcpp_platform_wake_by_address(__platform_state, __notify_one);
+}
+static __cxx_contention_t
+__libcpp_contention_monitor_for_wait(__cxx_atomic_contention_t volatile* /*__contention_state*/,
+                                     __cxx_atomic_contention_t const volatile* __platform_state) {
+  // We will monitor this value.
+  return __cxx_atomic_load(__platform_state, memory_order_acquire);
+}
+static void __libcpp_contention_wait(__cxx_atomic_contention_t volatile* __contention_state,
+                                     __cxx_atomic_contention_t const volatile* __platform_state,
+                                     __cxx_contention_t __old_value) {
+  __cxx_atomic_fetch_add(__contention_state, __cxx_contention_t(1), memory_order_seq_cst);
+  // We sleep as long as the monitored value hasn't changed.
+  __libcpp_platform_wait_on_address(__platform_state, __old_value);
+  __cxx_atomic_fetch_sub(__contention_state, __cxx_contention_t(1), memory_order_release);
+}
+
+/* When the incoming atomic is the wrong size for the platform wait size, need to
+   launder the value sequence through an atomic from our table. */
+
+static void __libcpp_atomic_notify(void const volatile* __location) {
+  auto const __entry = __libcpp_contention_state(__location);
+  // The value sequence laundering happens on the next line below.
+  __cxx_atomic_fetch_add(&__entry->__platform_state, __cxx_contention_t(1), memory_order_release);
+  __libcpp_contention_notify(
+      &__entry->__contention_state,
+      &__entry->__platform_state,
+      false /* when laundering, we can't handle notify_one */);
+}
+_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(void const volatile* __location) noexcept {
+  __libcpp_atomic_notify(__location);
+}
+_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(void const volatile* __location) noexcept {
+  __libcpp_atomic_notify(__location);
+}
+_LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t __libcpp_atomic_monitor(void const volatile* __location) noexcept {
+  auto const __entry = __libcpp_contention_state(__location);
+  return __libcpp_contention_monitor_for_wait(&__entry->__contention_state, &__entry->__platform_state);
+}
+_LIBCPP_EXPORTED_FROM_ABI void
+__libcpp_atomic_wait(void const volatile* __location, __cxx_contention_t __old_value) noexcept {
+  auto const __entry = __libcpp_contention_state(__location);
+  __libcpp_contention_wait(&__entry->__contention_state, &__entry->__platform_state, __old_value);
+}
+
+/* When the incoming atomic happens to be the platform wait size, we still need to use the
+   table for the contention detection, but we can use the atomic directly for the wait. */
+
+_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile* __location) noexcept {
+  __libcpp_contention_notify(&__libcpp_contention_state(__location)->__contention_state, __location, true);
+}
+_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(__cxx_atomic_contention_t const volatile* __location) noexcept {
+  __libcpp_contention_notify(&__libcpp_contention_state(__location)->__contention_state, __location, false);
+}
+// This function is never used, but still exported for ABI compatibility.
+_LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t
+__libcpp_atomic_monitor(__cxx_atomic_contention_t const volatile* __location) noexcept {
+  return __libcpp_contention_monitor_for_wait(&__libcpp_contention_state(__location)->__contention_state, __location);
+}
+_LIBCPP_EXPORTED_FROM_ABI void
+__libcpp_atomic_wait(__cxx_atomic_contention_t const volatile* __location, __cxx_contention_t __old_value) noexcept {
+  __libcpp_contention_wait(&__libcpp_contention_state(__location)->__contention_state, __location, __old_value);
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/atomic_support.h b/third_party/libcxx/atomic_support.h
new file mode 100644
index 000000000..9ce41b322
--- /dev/null
+++ b/third_party/libcxx/atomic_support.h
@@ -0,0 +1,132 @@
+//===----------------------------------------------------------------------===////
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===////
+
+#ifndef ATOMIC_SUPPORT_H
+#define ATOMIC_SUPPORT_H
+
+#include <__config>
+#include <memory> // for __libcpp_relaxed_load
+
+#if defined(__clang__) && __has_builtin(__atomic_load_n) && __has_builtin(__atomic_store_n) &&                         \
+    __has_builtin(__atomic_add_fetch) && __has_builtin(__atomic_exchange_n) &&                                         \
+    __has_builtin(__atomic_compare_exchange_n) && defined(__ATOMIC_RELAXED) && defined(__ATOMIC_CONSUME) &&            \
+    defined(__ATOMIC_ACQUIRE) && defined(__ATOMIC_RELEASE) && defined(__ATOMIC_ACQ_REL) && defined(__ATOMIC_SEQ_CST)
+#  define _LIBCPP_HAS_ATOMIC_BUILTINS
+#elif defined(_LIBCPP_COMPILER_GCC)
+#  define _LIBCPP_HAS_ATOMIC_BUILTINS
+#endif
+
+#if !defined(_LIBCPP_HAS_ATOMIC_BUILTINS) && !defined(_LIBCPP_HAS_NO_THREADS)
+#  if defined(_LIBCPP_WARNING)
+_LIBCPP_WARNING("Building libc++ without __atomic builtins is unsupported")
+#  else
+#    warning Building libc++ without __atomic builtins is unsupported
+#  endif
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace {
+
+#if defined(_LIBCPP_HAS_ATOMIC_BUILTINS) && !defined(_LIBCPP_HAS_NO_THREADS)
+
+enum __libcpp_atomic_order {
+  _AO_Relaxed = __ATOMIC_RELAXED,
+  _AO_Consume = __ATOMIC_CONSUME,
+  _AO_Acquire = __ATOMIC_ACQUIRE,
+  _AO_Release = __ATOMIC_RELEASE,
+  _AO_Acq_Rel = __ATOMIC_ACQ_REL,
+  _AO_Seq     = __ATOMIC_SEQ_CST
+};
+
+template <class _ValueType, class _FromType>
+inline _LIBCPP_HIDE_FROM_ABI void __libcpp_atomic_store(_ValueType* __dest, _FromType __val, int __order = _AO_Seq) {
+  __atomic_store_n(__dest, __val, __order);
+}
+
+template <class _ValueType, class _FromType>
+inline _LIBCPP_HIDE_FROM_ABI void __libcpp_relaxed_store(_ValueType* __dest, _FromType __val) {
+  __atomic_store_n(__dest, __val, _AO_Relaxed);
+}
+
+template <class _ValueType>
+inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_atomic_load(_ValueType const* __val, int __order = _AO_Seq) {
+  return __atomic_load_n(__val, __order);
+}
+
+template <class _ValueType, class _AddType>
+inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_atomic_add(_ValueType* __val, _AddType __a, int __order = _AO_Seq) {
+  return __atomic_add_fetch(__val, __a, __order);
+}
+
+template <class _ValueType>
+inline _LIBCPP_HIDE_FROM_ABI _ValueType
+__libcpp_atomic_exchange(_ValueType* __target, _ValueType __value, int __order = _AO_Seq) {
+  return __atomic_exchange_n(__target, __value, __order);
+}
+
+template <class _ValueType>
+inline _LIBCPP_HIDE_FROM_ABI bool __libcpp_atomic_compare_exchange(
+    _ValueType* __val,
+    _ValueType* __expected,
+    _ValueType __after,
+    int __success_order = _AO_Seq,
+    int __fail_order    = _AO_Seq) {
+  return __atomic_compare_exchange_n(__val, __expected, __after, true, __success_order, __fail_order);
+}
+
+#else // _LIBCPP_HAS_NO_THREADS
+
+enum __libcpp_atomic_order { _AO_Relaxed, _AO_Consume, _AO_Acquire, _AO_Release, _AO_Acq_Rel, _AO_Seq };
+
+template <class _ValueType, class _FromType>
+inline _LIBCPP_HIDE_FROM_ABI void __libcpp_atomic_store(_ValueType* __dest, _FromType __val, int = 0) {
+  *__dest = __val;
+}
+
+template <class _ValueType, class _FromType>
+inline _LIBCPP_HIDE_FROM_ABI void __libcpp_relaxed_store(_ValueType* __dest, _FromType __val) {
+  *__dest = __val;
+}
+
+template <class _ValueType>
+inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_atomic_load(_ValueType const* __val, int = 0) {
+  return *__val;
+}
+
+template <class _ValueType, class _AddType>
+inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_atomic_add(_ValueType* __val, _AddType __a, int = 0) {
+  return *__val += __a;
+}
+
+template <class _ValueType>
+inline _LIBCPP_HIDE_FROM_ABI _ValueType
+__libcpp_atomic_exchange(_ValueType* __target, _ValueType __value, int = _AO_Seq) {
+  _ValueType old = *__target;
+  *__target      = __value;
+  return old;
+}
+
+template <class _ValueType>
+inline _LIBCPP_HIDE_FROM_ABI bool
+__libcpp_atomic_compare_exchange(_ValueType* __val, _ValueType* __expected, _ValueType __after, int = 0, int = 0) {
+  if (*__val == *__expected) {
+    *__val = __after;
+    return true;
+  }
+  *__expected = *__val;
+  return false;
+}
+
+#endif // _LIBCPP_HAS_NO_THREADS
+
+} // end namespace
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // ATOMIC_SUPPORT_H
diff --git a/third_party/libcxx/barrier b/third_party/libcxx/barrier
index 2ef232d46..edee18127 100644
--- a/third_party/libcxx/barrier
+++ b/third_party/libcxx/barrier
@@ -45,44 +45,38 @@ namespace std
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__atomic/atomic_base.h>
-#include <__atomic/memory_order.h>
-#include <__availability>
 #include <__config>
-#include <__memory/unique_ptr.h>
-#include <__thread/poll_with_backoff.h>
-#include <__thread/timed_backoff_policy.h>
-#include <__utility/move.h>
-#include <cstddef>
-#include <cstdint>
-#include <limits>
-#include <version>
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#if !defined(_LIBCPP_HAS_NO_THREADS)
 
-#ifdef _LIBCPP_HAS_NO_THREADS
-# error "<barrier> is not supported since libc++ has been configured without support for threads."
-#endif
+#  include <__assert>
+#  include <__atomic/atomic_base.h>
+#  include <__atomic/memory_order.h>
+#  include <__memory/unique_ptr.h>
+#  include <__thread/poll_with_backoff.h>
+#  include <__thread/timed_backoff_policy.h>
+#  include <__utility/move.h>
+#  include <cstddef>
+#  include <cstdint>
+#  include <limits>
+#  include <version>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 _LIBCPP_PUSH_MACROS
-#include <__undef_macros>
+#  include <__undef_macros>
 
-#if _LIBCPP_STD_VER >= 14
+#  if _LIBCPP_STD_VER >= 14
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct __empty_completion
-{
-    inline _LIBCPP_INLINE_VISIBILITY
-    void operator()() noexcept
-    {
-    }
+struct __empty_completion {
+  inline _LIBCPP_HIDE_FROM_ABI void operator()() noexcept {}
 };
 
-#ifndef _LIBCPP_HAS_NO_TREE_BARRIER
+#    ifndef _LIBCPP_HAS_NO_TREE_BARRIER
 
 /*
 
@@ -102,70 +96,61 @@ using __barrier_phase_t = uint8_t;
 
 class __barrier_algorithm_base;
 
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI
-__barrier_algorithm_base* __construct_barrier_algorithm_base(ptrdiff_t& __expected);
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI __barrier_algorithm_base*
+__construct_barrier_algorithm_base(ptrdiff_t& __expected);
 
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI
-bool __arrive_barrier_algorithm_base(__barrier_algorithm_base* __barrier,
-                                     __barrier_phase_t __old_phase);
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI bool
+__arrive_barrier_algorithm_base(__barrier_algorithm_base* __barrier, __barrier_phase_t __old_phase) noexcept;
 
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI
-void __destroy_barrier_algorithm_base(__barrier_algorithm_base* __barrier);
+_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void
+__destroy_barrier_algorithm_base(__barrier_algorithm_base* __barrier) noexcept;
 
-template<class _CompletionF>
+template <class _CompletionF>
 class __barrier_base {
-    ptrdiff_t                                               __expected_;
-    unique_ptr<__barrier_algorithm_base,
-               void (*)(__barrier_algorithm_base*)>         __base_;
-    __atomic_base<ptrdiff_t>                                __expected_adjustment_;
-    _CompletionF                                            __completion_;
-    __atomic_base<__barrier_phase_t>                        __phase_;
+  ptrdiff_t __expected_;
+  unique_ptr<__barrier_algorithm_base, void (*)(__barrier_algorithm_base*)> __base_;
+  __atomic_base<ptrdiff_t> __expected_adjustment_;
+  _CompletionF __completion_;
+  __atomic_base<__barrier_phase_t> __phase_;
 
 public:
-    using arrival_token = __barrier_phase_t;
+  using arrival_token = __barrier_phase_t;
 
-    static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept {
-        return numeric_limits<ptrdiff_t>::max();
-    }
+  static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept { return numeric_limits<ptrdiff_t>::max(); }
 
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
-            : __expected_(__expected), __base_(std::__construct_barrier_algorithm_base(this->__expected_),
-                                               &__destroy_barrier_algorithm_base),
-              __expected_adjustment_(0), __completion_(std::move(__completion)), __phase_(0)
-    {
-    }
-    [[__nodiscard__]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    arrival_token arrive(ptrdiff_t __update)
-    {
-        auto const __old_phase = __phase_.load(memory_order_relaxed);
-        for(; __update; --__update)
-            if(__arrive_barrier_algorithm_base(__base_.get(), __old_phase)) {
-                __completion_();
-                __expected_ += __expected_adjustment_.load(memory_order_relaxed);
-                __expected_adjustment_.store(0, memory_order_relaxed);
-                __phase_.store(__old_phase + 2, memory_order_release);
-                __phase_.notify_all();
-            }
-        return __old_phase;
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void wait(arrival_token&& __old_phase) const
-    {
-        auto const __test_fn = [this, __old_phase]() -> bool {
-            return __phase_.load(memory_order_acquire) != __old_phase;
-        };
-        std::__libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void arrive_and_drop()
-    {
-        __expected_adjustment_.fetch_sub(1, memory_order_relaxed);
-        (void)arrive(1);
-    }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
+  __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
+      : __expected_(__expected),
+        __base_(std::__construct_barrier_algorithm_base(this->__expected_), &__destroy_barrier_algorithm_base),
+        __expected_adjustment_(0),
+        __completion_(std::move(__completion)),
+        __phase_(0) {}
+  _LIBCPP_NODISCARD _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI arrival_token arrive(ptrdiff_t __update) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __update <= __expected_, "update is greater than the expected count for the current barrier phase");
+
+    auto const __old_phase = __phase_.load(memory_order_relaxed);
+    for (; __update; --__update)
+      if (__arrive_barrier_algorithm_base(__base_.get(), __old_phase)) {
+        __completion_();
+        __expected_ += __expected_adjustment_.load(memory_order_relaxed);
+        __expected_adjustment_.store(0, memory_order_relaxed);
+        __phase_.store(__old_phase + 2, memory_order_release);
+        __phase_.notify_all();
+      }
+    return __old_phase;
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(arrival_token&& __old_phase) const {
+    auto const __test_fn = [this, __old_phase]() -> bool { return __phase_.load(memory_order_acquire) != __old_phase; };
+    std::__libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_drop() {
+    __expected_adjustment_.fetch_sub(1, memory_order_relaxed);
+    (void)arrive(1);
+  }
 };
 
-#else
+#    else
 
 /*
 
@@ -180,159 +165,137 @@ Two versions of this algorithm are provided:
 
 */
 
-template<class _CompletionF>
+template <class _CompletionF>
 class __barrier_base {
+  __atomic_base<ptrdiff_t> __expected;
+  __atomic_base<ptrdiff_t> __arrived;
+  _CompletionF __completion;
+  __atomic_base<bool> __phase;
 
-    __atomic_base<ptrdiff_t> __expected;
-    __atomic_base<ptrdiff_t> __arrived;
-    _CompletionF             __completion;
-    __atomic_base<bool>      __phase;
 public:
-    using arrival_token = bool;
+  using arrival_token = bool;
 
-    static constexpr ptrdiff_t max() noexcept {
-        return numeric_limits<ptrdiff_t>::max();
-    }
+  static constexpr ptrdiff_t max() noexcept { return numeric_limits<ptrdiff_t>::max(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
-        : __expected(__expected), __arrived(__expected), __completion(std::move(__completion)), __phase(false)
-    {
-    }
-    [[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    arrival_token arrive(ptrdiff_t update)
-    {
-        auto const __old_phase = __phase.load(memory_order_relaxed);
-        auto const __result = __arrived.fetch_sub(update, memory_order_acq_rel) - update;
-        auto const new_expected = __expected.load(memory_order_relaxed);
-        if(0 == __result) {
-            __completion();
-            __arrived.store(new_expected, memory_order_relaxed);
-            __phase.store(!__old_phase, memory_order_release);
-            __phase.notify_all();
-        }
-        return __old_phase;
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void wait(arrival_token&& __old_phase) const
-    {
-        __phase.wait(__old_phase, memory_order_acquire);
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void arrive_and_drop()
-    {
-        __expected.fetch_sub(1, memory_order_relaxed);
-        (void)arrive(1);
+  _LIBCPP_HIDE_FROM_ABI __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
+      : __expected(__expected), __arrived(__expected), __completion(std::move(__completion)), __phase(false) {}
+  [[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI arrival_token arrive(ptrdiff_t update) {
+    auto const __old_phase  = __phase.load(memory_order_relaxed);
+    auto const __result     = __arrived.fetch_sub(update, memory_order_acq_rel) - update;
+    auto const new_expected = __expected.load(memory_order_relaxed);
+
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        update <= new_expected, "update is greater than the expected count for the current barrier phase");
+
+    if (0 == __result) {
+      __completion();
+      __arrived.store(new_expected, memory_order_relaxed);
+      __phase.store(!__old_phase, memory_order_release);
+      __phase.notify_all();
     }
+    return __old_phase;
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(arrival_token&& __old_phase) const {
+    __phase.wait(__old_phase, memory_order_acquire);
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_drop() {
+    __expected.fetch_sub(1, memory_order_relaxed);
+    (void)arrive(1);
+  }
 };
 
-template<>
+template <>
 class __barrier_base<__empty_completion> {
+  static constexpr uint64_t __expected_unit = 1ull;
+  static constexpr uint64_t __arrived_unit  = 1ull << 32;
+  static constexpr uint64_t __expected_mask = __arrived_unit - 1;
+  static constexpr uint64_t __phase_bit     = 1ull << 63;
+  static constexpr uint64_t __arrived_mask  = (__phase_bit - 1) & ~__expected_mask;
 
-    static constexpr uint64_t __expected_unit = 1ull;
-    static constexpr uint64_t __arrived_unit = 1ull << 32;
-    static constexpr uint64_t __expected_mask = __arrived_unit - 1;
-    static constexpr uint64_t __phase_bit = 1ull << 63;
-    static constexpr uint64_t __arrived_mask = (__phase_bit - 1) & ~__expected_mask;
+  __atomic_base<uint64_t> __phase_arrived_expected;
 
-    __atomic_base<uint64_t>   __phase_arrived_expected;
-
-    static _LIBCPP_INLINE_VISIBILITY
-    constexpr uint64_t __init(ptrdiff_t __count) _NOEXCEPT
-    {
-        return ((uint64_t(1u << 31) - __count) << 32)
-              | (uint64_t(1u << 31) - __count);
-    }
+  static _LIBCPP_HIDE_FROM_ABI constexpr uint64_t __init(ptrdiff_t __count) _NOEXCEPT {
+    return ((uint64_t(1u << 31) - __count) << 32) | (uint64_t(1u << 31) - __count);
+  }
 
 public:
-    using arrival_token = uint64_t;
+  using arrival_token = uint64_t;
 
-    static constexpr ptrdiff_t max() noexcept {
-        return ptrdiff_t(1u << 31) - 1;
-    }
+  static constexpr ptrdiff_t max() noexcept { return ptrdiff_t(1u << 31) - 1; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit inline __barrier_base(ptrdiff_t __count, __empty_completion = __empty_completion())
-        : __phase_arrived_expected(__init(__count))
-    {
-    }
-    [[nodiscard]] inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    arrival_token arrive(ptrdiff_t update)
-    {
-        auto const __inc = __arrived_unit * update;
-        auto const __old = __phase_arrived_expected.fetch_add(__inc, memory_order_acq_rel);
-        if((__old ^ (__old + __inc)) & __phase_bit) {
-            __phase_arrived_expected.fetch_add((__old & __expected_mask) << 32, memory_order_relaxed);
-            __phase_arrived_expected.notify_all();
-        }
-        return __old & __phase_bit;
-    }
-    inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void wait(arrival_token&& __phase) const
-    {
-        auto const __test_fn = [=]() -> bool {
-            uint64_t const __current = __phase_arrived_expected.load(memory_order_acquire);
-            return ((__current & __phase_bit) != __phase);
-        };
-        __libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
-    }
-    inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void arrive_and_drop()
-    {
-        __phase_arrived_expected.fetch_add(__expected_unit, memory_order_relaxed);
-        (void)arrive(1);
+  _LIBCPP_HIDE_FROM_ABI explicit inline __barrier_base(ptrdiff_t __count, __empty_completion = __empty_completion())
+      : __phase_arrived_expected(__init(__count)) {}
+  [[nodiscard]] inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI arrival_token arrive(ptrdiff_t update) {
+    auto const __inc = __arrived_unit * update;
+    auto const __old = __phase_arrived_expected.fetch_add(__inc, memory_order_acq_rel);
+
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        update <= __old, "update is greater than the expected count for the current barrier phase");
+
+    if ((__old ^ (__old + __inc)) & __phase_bit) {
+      __phase_arrived_expected.fetch_add((__old & __expected_mask) << 32, memory_order_relaxed);
+      __phase_arrived_expected.notify_all();
     }
+    return __old & __phase_bit;
+  }
+  inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(arrival_token&& __phase) const {
+    auto const __test_fn = [=]() -> bool {
+      uint64_t const __current = __phase_arrived_expected.load(memory_order_acquire);
+      return ((__current & __phase_bit) != __phase);
+    };
+    __libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
+  }
+  inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_drop() {
+    __phase_arrived_expected.fetch_add(__expected_unit, memory_order_relaxed);
+    (void)arrive(1);
+  }
 };
 
-#endif // !_LIBCPP_HAS_NO_TREE_BARRIER
+#    endif // !_LIBCPP_HAS_NO_TREE_BARRIER
 
-template<class _CompletionF = __empty_completion>
-class barrier {
+template <class _CompletionF = __empty_completion>
+class _LIBCPP_DEPRECATED_ATOMIC_SYNC barrier {
+  __barrier_base<_CompletionF> __b_;
 
-    __barrier_base<_CompletionF> __b_;
 public:
-    using arrival_token = typename __barrier_base<_CompletionF>::arrival_token;
+  using arrival_token = typename __barrier_base<_CompletionF>::arrival_token;
 
-    static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept {
-        return __barrier_base<_CompletionF>::max();
-    }
+  static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept { return __barrier_base<_CompletionF>::max(); }
 
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    barrier(ptrdiff_t __count, _CompletionF __completion = _CompletionF())
-        : __b_(__count, _VSTD::move(__completion)) {
-    }
+  _LIBCPP_AVAILABILITY_SYNC
+  _LIBCPP_HIDE_FROM_ABI explicit barrier(ptrdiff_t __count, _CompletionF __completion = _CompletionF())
+      : __b_(__count, std::move(__completion)) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __count >= 0,
+        "barrier::barrier(ptrdiff_t, CompletionFunction): barrier cannot be initialized with a negative value");
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __count <= max(),
+        "barrier::barrier(ptrdiff_t, CompletionFunction): barrier cannot be initialized with "
+        "a value greater than max()");
+  }
 
-    barrier(barrier const&) = delete;
-    barrier& operator=(barrier const&) = delete;
+  barrier(barrier const&)            = delete;
+  barrier& operator=(barrier const&) = delete;
 
-    [[__nodiscard__]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    arrival_token arrive(ptrdiff_t __update = 1)
-    {
-        return __b_.arrive(__update);
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void wait(arrival_token&& __phase) const
-    {
-        __b_.wait(_VSTD::move(__phase));
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void arrive_and_wait()
-    {
-        wait(arrive());
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void arrive_and_drop()
-    {
-        __b_.arrive_and_drop();
-    }
+  _LIBCPP_NODISCARD _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI arrival_token arrive(ptrdiff_t __update = 1) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update > 0, "barrier:arrive must be called with a value greater than 0");
+    return __b_.arrive(__update);
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(arrival_token&& __phase) const {
+    __b_.wait(std::move(__phase));
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_wait() { wait(arrive()); }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_drop() { __b_.arrive_and_drop(); }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_STD_VER >= 14
+#  endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
+#endif // !defined(_LIBCPP_HAS_NO_THREADS)
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
diff --git a/third_party/libcxx/barrier.cpp b/third_party/libcxx/barrier.cpp
new file mode 100644
index 000000000..69601bfee
--- /dev/null
+++ b/third_party/libcxx/barrier.cpp
@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <barrier>
+#include <thread>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if !defined(_LIBCPP_HAS_NO_TREE_BARRIER)
+
+class __barrier_algorithm_base {
+public:
+  struct alignas(64) /* naturally-align the heap state */ __state_t {
+    struct {
+      __atomic_base<__barrier_phase_t> __phase{0};
+    } __tickets[64];
+  };
+
+  ptrdiff_t& __expected_;
+  unique_ptr<__state_t[]> __state_;
+
+  _LIBCPP_HIDDEN __barrier_algorithm_base(ptrdiff_t& __expected) : __expected_(__expected) {
+    size_t const __count = (__expected + 1) >> 1;
+    __state_             = unique_ptr<__state_t[]>(new __state_t[__count]);
+  }
+  _LIBCPP_HIDDEN bool __arrive(__barrier_phase_t __old_phase) {
+    __barrier_phase_t const __half_step = __old_phase + 1, __full_step = __old_phase + 2;
+    size_t __current_expected = __expected_,
+           __current          = hash<thread::id>()(this_thread::get_id()) % ((__expected_ + 1) >> 1);
+    for (int __round = 0;; ++__round) {
+      if (__current_expected <= 1)
+        return true;
+      size_t const __end_node = ((__current_expected + 1) >> 1), __last_node = __end_node - 1;
+      for (;; ++__current) {
+        if (__current == __end_node)
+          __current = 0;
+        __barrier_phase_t expect = __old_phase;
+        if (__current == __last_node && (__current_expected & 1)) {
+          if (__state_[__current].__tickets[__round].__phase.compare_exchange_strong(
+                  expect, __full_step, memory_order_acq_rel))
+            break; // I'm 1 in 1, go to next __round
+        } else if (__state_[__current].__tickets[__round].__phase.compare_exchange_strong(
+                       expect, __half_step, memory_order_acq_rel)) {
+          return false; // I'm 1 in 2, done with arrival
+        } else if (expect == __half_step) {
+          if (__state_[__current].__tickets[__round].__phase.compare_exchange_strong(
+                  expect, __full_step, memory_order_acq_rel))
+            break; // I'm 2 in 2, go to next __round
+        }
+      }
+      __current_expected = __last_node + 1;
+      __current >>= 1;
+    }
+  }
+};
+
+_LIBCPP_EXPORTED_FROM_ABI __barrier_algorithm_base* __construct_barrier_algorithm_base(ptrdiff_t& __expected) {
+  return new __barrier_algorithm_base(__expected);
+}
+_LIBCPP_EXPORTED_FROM_ABI bool
+__arrive_barrier_algorithm_base(__barrier_algorithm_base* __barrier, __barrier_phase_t __old_phase) noexcept {
+  return __barrier->__arrive(__old_phase);
+}
+_LIBCPP_EXPORTED_FROM_ABI void __destroy_barrier_algorithm_base(__barrier_algorithm_base* __barrier) noexcept {
+  delete __barrier;
+}
+
+#endif // !defined(_LIBCPP_HAS_NO_TREE_BARRIER)
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/bind.cpp b/third_party/libcxx/bind.cpp
new file mode 100644
index 000000000..e05739584
--- /dev/null
+++ b/third_party/libcxx/bind.cpp
@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <functional>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace placeholders {
+
+const __ph<1> _1{};
+const __ph<2> _2{};
+const __ph<3> _3{};
+const __ph<4> _4{};
+const __ph<5> _5{};
+const __ph<6> _6{};
+const __ph<7> _7{};
+const __ph<8> _8{};
+const __ph<9> _9{};
+const __ph<10> _10{};
+
+} // namespace placeholders
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/bit b/third_party/libcxx/bit
index 6b35bb2c7..94387d101 100644
--- a/third_party/libcxx/bit
+++ b/third_party/libcxx/bit
@@ -34,9 +34,9 @@ namespace std {
 
   // [bit.rotate], rotating
   template<class T>
-    constexpr T rotl(T x, unsigned int s) noexcept; // C++20
+    constexpr T rotl(T x, int s) noexcept; // C++20
   template<class T>
-    constexpr T rotr(T x, unsigned int s) noexcept; // C++20
+    constexpr T rotr(T x, int s) noexcept; // C++20
 
   // [bit.count], counting
   template<class T>
@@ -61,27 +61,36 @@ namespace std {
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__bit/bit_cast.h>
-#include <__bit/bit_ceil.h>
-#include <__bit/bit_floor.h>
-#include <__bit/bit_log2.h>
-#include <__bit/bit_width.h>
-#include <__bit/blsr.h>
-#include <__bit/byteswap.h>
-#include <__bit/countl.h>
-#include <__bit/countr.h>
-#include <__bit/endian.h>
-#include <__bit/has_single_bit.h>
-#include <__bit/popcount.h>
-#include <__bit/rotate.h>
 #include <__config>
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__bit/bit_cast.h>
+#  include <__bit/bit_ceil.h>
+#  include <__bit/bit_floor.h>
+#  include <__bit/bit_log2.h>
+#  include <__bit/bit_width.h>
+#  include <__bit/countl.h>
+#  include <__bit/countr.h>
+#  include <__bit/endian.h>
+#  include <__bit/has_single_bit.h>
+#  include <__bit/popcount.h>
+#  include <__bit/rotate.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+#  include <__bit/byteswap.h>
+#endif
+
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <cstdint>
+#endif
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <cstdlib>
 #  include <iosfwd>
diff --git a/third_party/libcxx/bitset b/third_party/libcxx/bitset
index fc8ffb882..6bd7bfe58 100644
--- a/third_party/libcxx/bitset
+++ b/third_party/libcxx/bitset
@@ -10,6 +10,8 @@
 #ifndef _LIBCPP_BITSET
 #define _LIBCPP_BITSET
 
+// clang-format off
+
 /*
     bitset synopsis
 
@@ -40,15 +42,25 @@ public:
     constexpr bitset() noexcept;
     constexpr bitset(unsigned long long val) noexcept;
     template <class charT>
-        explicit bitset(const charT* str,
-                        typename basic_string<charT>::size_type n = basic_string<charT>::npos,
-                        charT zero = charT('0'), charT one = charT('1')); // constexpr since C++23
+        constexpr explicit bitset(const charT* str,
+            typename basic_string<charT>::size_type n = basic_string<charT>::npos,
+            charT zero = charT('0'), charT one = charT('1'));                                // until C++26, constexpr since C++23
+    template <class charT>
+        constexpr explicit bitset(const charT* str,
+            typename basic_string_view<charT>::size_type n = basic_string_view<charT>::npos,
+            charT zero = charT('0'), charT one = charT('1'));                                // since C++26
+    template<class charT, class traits>
+        explicit bitset(
+            const basic_string_view<charT,traits>& str,
+            typename basic_string_view<charT,traits>::size_type pos = 0,
+            typename basic_string_view<charT,traits>::size_type n = basic_string_view<charT,traits>::npos,
+            charT zero = charT('0'), charT one = charT('1'));                                // since C++26
     template<class charT, class traits, class Allocator>
-        explicit bitset(const basic_string<charT,traits,Allocator>& str,
-                        typename basic_string<charT,traits,Allocator>::size_type pos = 0,
-                        typename basic_string<charT,traits,Allocator>::size_type n =
-                                 basic_string<charT,traits,Allocator>::npos,
-                        charT zero = charT('0'), charT one = charT('1')); // constexpr since C++23
+        constexpr explicit bitset(
+            const basic_string<charT,traits,Allocator>& str,
+            typename basic_string<charT,traits,Allocator>::size_type pos = 0,
+            typename basic_string<charT,traits,Allocator>::size_type n = basic_string<charT,traits,Allocator>::npos,
+            charT zero = charT('0'), charT one = charT('1'));                                // constexpr since C++23
 
     // 23.3.5.2 bitset operations:
     bitset& operator&=(const bitset& rhs) noexcept; // constexpr since C++23
@@ -79,7 +91,7 @@ public:
     size_t count() const noexcept;                     // constexpr since C++23
     constexpr size_t size() const noexcept;            // constexpr since C++23
     bool operator==(const bitset& rhs) const noexcept; // constexpr since C++23
-    bool operator!=(const bitset& rhs) const noexcept; // constexpr since C++23
+    bool operator!=(const bitset& rhs) const noexcept; // removed in C++20
     bool test(size_t pos) const;                       // constexpr since C++23
     bool all() const noexcept;                         // constexpr since C++23
     bool any() const noexcept;                         // constexpr since C++23
@@ -112,8 +124,11 @@ template <size_t N> struct hash<std::bitset<N>>;
 
 */
 
+// clang-format on
+
+#include <__algorithm/count.h>
 #include <__algorithm/fill.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__algorithm/find.h>
 #include <__bit_reference>
 #include <__config>
 #include <__functional/hash.h>
@@ -122,6 +137,7 @@ template <size_t N> struct hash<std::bitset<N>>;
 #include <climits>
 #include <cstddef>
 #include <stdexcept>
+#include <string_view>
 #include <version>
 
 // standard-mandated includes
@@ -137,1007 +153,799 @@ template <size_t N> struct hash<std::bitset<N>>;
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <size_t _N_words, size_t _Size>
 class __bitset;
 
 template <size_t _N_words, size_t _Size>
-struct __has_storage_type<__bitset<_N_words, _Size> >
-{
-    static const bool value = true;
+struct __has_storage_type<__bitset<_N_words, _Size> > {
+  static const bool value = true;
 };
 
 template <size_t _N_words, size_t _Size>
-class __bitset
-{
+class __bitset {
 public:
-    typedef ptrdiff_t              difference_type;
-    typedef size_t                 size_type;
-    typedef size_type              __storage_type;
+  typedef ptrdiff_t difference_type;
+  typedef size_t size_type;
+  typedef size_type __storage_type;
+
 protected:
-    typedef __bitset __self;
-    typedef       __storage_type*  __storage_pointer;
-    typedef const __storage_type*  __const_storage_pointer;
-    static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
+  typedef __bitset __self;
+  typedef __storage_type* __storage_pointer;
+  typedef const __storage_type* __const_storage_pointer;
+  static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
 
-    friend class __bit_reference<__bitset>;
-    friend class __bit_const_reference<__bitset>;
-    friend class __bit_iterator<__bitset, false>;
-    friend class __bit_iterator<__bitset, true>;
-    friend struct __bit_array<__bitset>;
+  friend class __bit_reference<__bitset>;
+  friend class __bit_const_reference<__bitset>;
+  friend class __bit_iterator<__bitset, false>;
+  friend class __bit_iterator<__bitset, true>;
+  friend struct __bit_array<__bitset>;
 
-    __storage_type __first_[_N_words];
+  __storage_type __first_[_N_words];
 
-    typedef __bit_reference<__bitset>                  reference;
-    typedef __bit_const_reference<__bitset>            const_reference;
-    typedef __bit_iterator<__bitset, false>            iterator;
-    typedef __bit_iterator<__bitset, true>             const_iterator;
+  typedef __bit_reference<__bitset> reference;
+  typedef __bit_const_reference<__bitset> const_reference;
+  typedef __bit_iterator<__bitset, false> iterator;
+  typedef __bit_iterator<__bitset, true> const_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 reference __make_ref(size_t __pos) _NOEXCEPT
-        {return reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT
-        {return const_reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 iterator __make_iter(size_t __pos) _NOEXCEPT
-        {return iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 const_iterator __make_iter(size_t __pos) const _NOEXCEPT
-        {return const_iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference __make_ref(size_t __pos) _NOEXCEPT {
+    return reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT {
+    return const_reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 iterator __make_iter(size_t __pos) _NOEXCEPT {
+    return iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 const_iterator __make_iter(size_t __pos) const _NOEXCEPT {
+    return const_iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    void operator&=(const __bitset& __v) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    void operator|=(const __bitset& __v) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    void operator^=(const __bitset& __v) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator&=(const __bitset& __v) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator|=(const __bitset& __v) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator^=(const __bitset& __v) _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void flip() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const
-        {return to_ulong(integral_constant<bool, _Size < sizeof(unsigned long) * CHAR_BIT>());}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const
-        {return to_ullong(integral_constant<bool, _Size < sizeof(unsigned long long) * CHAR_BIT>());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void flip() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const {
+    return to_ulong(integral_constant < bool, _Size< sizeof(unsigned long) * CHAR_BIT>());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const {
+    return to_ullong(integral_constant < bool, _Size< sizeof(unsigned long long) * CHAR_BIT>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI size_t __hash_code() const _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    size_t __hash_code() const _NOEXCEPT;
 private:
 #ifdef _LIBCPP_CXX03_LANG
-    void __init(unsigned long long __v, false_type) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    void __init(unsigned long long __v, true_type) _NOEXCEPT;
+  void __init(unsigned long long __v, false_type) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void __init(unsigned long long __v, true_type) _NOEXCEPT;
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long to_ulong(false_type) const;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long to_ulong(true_type) const;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long long to_ullong(false_type) const;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long long to_ullong(true_type) const;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long long to_ullong(true_type, false_type) const;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long long to_ullong(true_type, true_type) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong(false_type) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong(true_type) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong(false_type) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong(true_type) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong(true_type, false_type) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong(true_type, true_type) const;
 };
 
 template <size_t _N_words, size_t _Size>
-inline
-_LIBCPP_CONSTEXPR
-__bitset<_N_words, _Size>::__bitset() _NOEXCEPT
+inline _LIBCPP_CONSTEXPR __bitset<_N_words, _Size>::__bitset() _NOEXCEPT
 #ifndef _LIBCPP_CXX03_LANG
     : __first_{0}
 #endif
 {
 #ifdef _LIBCPP_CXX03_LANG
-    _VSTD::fill_n(__first_, _N_words, __storage_type(0));
+  std::fill_n(__first_, _N_words, __storage_type(0));
 #endif
 }
 
 #ifdef _LIBCPP_CXX03_LANG
 
 template <size_t _N_words, size_t _Size>
-void
-__bitset<_N_words, _Size>::__init(unsigned long long __v, false_type) _NOEXCEPT
-{
-    __storage_type __t[sizeof(unsigned long long) / sizeof(__storage_type)];
-    size_t __sz = _Size;
-    for (size_t __i = 0; __i < sizeof(__t)/sizeof(__t[0]); ++__i, __v >>= __bits_per_word, __sz -= __bits_per_word )
-        if ( __sz < __bits_per_word)
-            __t[__i] = static_cast<__storage_type>(__v) & ( 1ULL << __sz ) - 1;
-        else
-            __t[__i] = static_cast<__storage_type>(__v);
+void __bitset<_N_words, _Size>::__init(unsigned long long __v, false_type) _NOEXCEPT {
+  __storage_type __t[sizeof(unsigned long long) / sizeof(__storage_type)];
+  size_t __sz = _Size;
+  for (size_t __i = 0; __i < sizeof(__t) / sizeof(__t[0]); ++__i, __v >>= __bits_per_word, __sz -= __bits_per_word)
+    if (__sz < __bits_per_word)
+      __t[__i] = static_cast<__storage_type>(__v) & (1ULL << __sz) - 1;
+    else
+      __t[__i] = static_cast<__storage_type>(__v);
 
-    _VSTD::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_);
-    _VSTD::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]),
-               __storage_type(0));
+  std::copy(__t, __t + sizeof(__t) / sizeof(__t[0]), __first_);
+  std::fill(
+      __first_ + sizeof(__t) / sizeof(__t[0]), __first_ + sizeof(__first_) / sizeof(__first_[0]), __storage_type(0));
 }
 
 template <size_t _N_words, size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-__bitset<_N_words, _Size>::__init(unsigned long long __v, true_type) _NOEXCEPT
-{
-    __first_[0] = __v;
-    if (_Size < __bits_per_word)
-        __first_[0] &= ( 1ULL << _Size ) - 1;
+inline _LIBCPP_HIDE_FROM_ABI void __bitset<_N_words, _Size>::__init(unsigned long long __v, true_type) _NOEXCEPT {
+  __first_[0] = __v;
+  if (_Size < __bits_per_word)
+    __first_[0] &= (1ULL << _Size) - 1;
 
-    _VSTD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
+  std::fill(__first_ + 1, __first_ + sizeof(__first_) / sizeof(__first_[0]), __storage_type(0));
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <size_t _N_words, size_t _Size>
-inline
-_LIBCPP_CONSTEXPR
-__bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
+inline _LIBCPP_CONSTEXPR __bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
 #ifndef _LIBCPP_CXX03_LANG
-#if __SIZEOF_SIZE_T__ == 8
+#  if __SIZEOF_SIZE_T__ == 8
     : __first_{__v}
-#elif __SIZEOF_SIZE_T__ == 4
+#  elif __SIZEOF_SIZE_T__ == 4
     : __first_{static_cast<__storage_type>(__v),
-                _Size >= 2 * __bits_per_word ? static_cast<__storage_type>(__v >> __bits_per_word)
-                : static_cast<__storage_type>((__v >> __bits_per_word) & (__storage_type(1) << (_Size - __bits_per_word)) - 1)}
-#else
-#error This constructor has not been ported to this platform
-#endif
+               _Size >= 2 * __bits_per_word
+                   ? static_cast<__storage_type>(__v >> __bits_per_word)
+                   : static_cast<__storage_type>((__v >> __bits_per_word) &
+                                                 (__storage_type(1) << (_Size - __bits_per_word)) - 1)}
+#  else
+#    error This constructor has not been ported to this platform
+#  endif
 #endif
 {
 #ifdef _LIBCPP_CXX03_LANG
-    __init(__v, integral_constant<bool, sizeof(unsigned long long) == sizeof(__storage_type)>());
+  __init(__v, integral_constant<bool, sizeof(unsigned long long) == sizeof(__storage_type)>());
 #endif
 }
 
 template <size_t _N_words, size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
-__bitset<_N_words, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
-{
-    for (size_type __i = 0; __i < _N_words; ++__i)
-        __first_[__i] &= __v.__first_[__i];
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
+__bitset<_N_words, _Size>::operator&=(const __bitset& __v) _NOEXCEPT {
+  for (size_type __i = 0; __i < _N_words; ++__i)
+    __first_[__i] &= __v.__first_[__i];
 }
 
 template <size_t _N_words, size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
-__bitset<_N_words, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
-{
-    for (size_type __i = 0; __i < _N_words; ++__i)
-        __first_[__i] |= __v.__first_[__i];
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
+__bitset<_N_words, _Size>::operator|=(const __bitset& __v) _NOEXCEPT {
+  for (size_type __i = 0; __i < _N_words; ++__i)
+    __first_[__i] |= __v.__first_[__i];
 }
 
 template <size_t _N_words, size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
-__bitset<_N_words, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
-{
-    for (size_type __i = 0; __i < _N_words; ++__i)
-        __first_[__i] ^= __v.__first_[__i];
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
+__bitset<_N_words, _Size>::operator^=(const __bitset& __v) _NOEXCEPT {
+  for (size_type __i = 0; __i < _N_words; ++__i)
+    __first_[__i] ^= __v.__first_[__i];
 }
 
 template <size_t _N_words, size_t _Size>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
-__bitset<_N_words, _Size>::flip() _NOEXCEPT
-{
-    // do middle whole words
-    size_type __n = _Size;
-    __storage_pointer __p = __first_;
-    for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
-        *__p = ~*__p;
-    // do last partial word
-    if (__n > 0)
-    {
-        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __storage_type __b = *__p & __m;
-        *__p &= ~__m;
-        *__p |= ~__b & __m;
-    }
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void __bitset<_N_words, _Size>::flip() _NOEXCEPT {
+  // do middle whole words
+  size_type __n         = _Size;
+  __storage_pointer __p = __first_;
+  for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
+    *__p = ~*__p;
+  // do last partial word
+  if (__n > 0) {
+    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+    __storage_type __b = *__p & __m;
+    *__p &= ~__m;
+    *__p |= ~__b & __m;
+  }
 }
 
 template <size_t _N_words, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long
-__bitset<_N_words, _Size>::to_ulong(false_type) const
-{
-    const_iterator __e = __make_iter(_Size);
-    const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
-    if (__i != __e)
-        __throw_overflow_error("bitset to_ulong overflow error");
+__bitset<_N_words, _Size>::to_ulong(false_type) const {
+  const_iterator __e = __make_iter(_Size);
+  const_iterator __i = std::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
+  if (__i != __e)
+    __throw_overflow_error("bitset to_ulong overflow error");
 
-    return __first_[0];
+  return __first_[0];
 }
 
 template <size_t _N_words, size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long
-__bitset<_N_words, _Size>::to_ulong(true_type) const
-{
-    return __first_[0];
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long
+__bitset<_N_words, _Size>::to_ulong(true_type) const {
+  return __first_[0];
 }
 
 template <size_t _N_words, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
-__bitset<_N_words, _Size>::to_ullong(false_type) const
-{
-    const_iterator __e = __make_iter(_Size);
-    const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
-    if (__i != __e)
-        __throw_overflow_error("bitset to_ullong overflow error");
+__bitset<_N_words, _Size>::to_ullong(false_type) const {
+  const_iterator __e = __make_iter(_Size);
+  const_iterator __i = std::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
+  if (__i != __e)
+    __throw_overflow_error("bitset to_ullong overflow error");
 
-    return to_ullong(true_type());
+  return to_ullong(true_type());
 }
 
 template <size_t _N_words, size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
-__bitset<_N_words, _Size>::to_ullong(true_type) const
-{
-    return to_ullong(true_type(), integral_constant<bool, sizeof(__storage_type) < sizeof(unsigned long long)>());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
+__bitset<_N_words, _Size>::to_ullong(true_type) const {
+  return to_ullong(true_type(), integral_constant<bool, sizeof(__storage_type) < sizeof(unsigned long long)>());
 }
 
 template <size_t _N_words, size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
-__bitset<_N_words, _Size>::to_ullong(true_type, false_type) const
-{
-    return __first_[0];
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
+__bitset<_N_words, _Size>::to_ullong(true_type, false_type) const {
+  return __first_[0];
 }
 
 template <size_t _N_words, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
-__bitset<_N_words, _Size>::to_ullong(true_type, true_type) const
-{
-    unsigned long long __r = __first_[0];
-    for (size_t __i = 1; __i < sizeof(unsigned long long) / sizeof(__storage_type); ++__i)
-        __r |= static_cast<unsigned long long>(__first_[__i]) << (sizeof(__storage_type) * CHAR_BIT);
-    return __r;
+__bitset<_N_words, _Size>::to_ullong(true_type, true_type) const {
+  unsigned long long __r = __first_[0];
+  _LIBCPP_DIAGNOSTIC_PUSH
+  _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wshift-count-overflow")
+  for (size_t __i = 1; __i < sizeof(unsigned long long) / sizeof(__storage_type); ++__i)
+    __r |= static_cast<unsigned long long>(__first_[__i]) << (sizeof(__storage_type) * CHAR_BIT);
+  _LIBCPP_DIAGNOSTIC_POP
+  return __r;
 }
 
 template <size_t _N_words, size_t _Size>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-__bitset<_N_words, _Size>::all() const _NOEXCEPT
-{
-    // do middle whole words
-    size_type __n = _Size;
-    __const_storage_pointer __p = __first_;
-    for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
-        if (~*__p)
-            return false;
-    // do last partial word
-    if (__n > 0)
-    {
-        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        if (~*__p & __m)
-            return false;
-    }
-    return true;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool __bitset<_N_words, _Size>::all() const _NOEXCEPT {
+  // do middle whole words
+  size_type __n               = _Size;
+  __const_storage_pointer __p = __first_;
+  for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
+    if (~*__p)
+      return false;
+  // do last partial word
+  if (__n > 0) {
+    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+    if (~*__p & __m)
+      return false;
+  }
+  return true;
 }
 
 template <size_t _N_words, size_t _Size>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-__bitset<_N_words, _Size>::any() const _NOEXCEPT
-{
-    // do middle whole words
-    size_type __n = _Size;
-    __const_storage_pointer __p = __first_;
-    for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
-        if (*__p)
-            return true;
-    // do last partial word
-    if (__n > 0)
-    {
-        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        if (*__p & __m)
-            return true;
-    }
-    return false;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool __bitset<_N_words, _Size>::any() const _NOEXCEPT {
+  // do middle whole words
+  size_type __n               = _Size;
+  __const_storage_pointer __p = __first_;
+  for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
+    if (*__p)
+      return true;
+  // do last partial word
+  if (__n > 0) {
+    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+    if (*__p & __m)
+      return true;
+  }
+  return false;
 }
 
 template <size_t _N_words, size_t _Size>
-inline
-size_t
-__bitset<_N_words, _Size>::__hash_code() const _NOEXCEPT
-{
-    size_t __h = 0;
-    for (size_type __i = 0; __i < _N_words; ++__i)
-        __h ^= __first_[__i];
-    return __h;
+inline size_t __bitset<_N_words, _Size>::__hash_code() const _NOEXCEPT {
+  size_t __h = 0;
+  for (size_type __i = 0; __i < _N_words; ++__i)
+    __h ^= __first_[__i];
+  return __h;
 }
 
 template <size_t _Size>
-class __bitset<1, _Size>
-{
+class __bitset<1, _Size> {
 public:
-    typedef ptrdiff_t              difference_type;
-    typedef size_t                 size_type;
-    typedef size_type              __storage_type;
+  typedef ptrdiff_t difference_type;
+  typedef size_t size_type;
+  typedef size_type __storage_type;
+
 protected:
-    typedef __bitset __self;
-    typedef       __storage_type*  __storage_pointer;
-    typedef const __storage_type*  __const_storage_pointer;
-    static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
+  typedef __bitset __self;
+  typedef __storage_type* __storage_pointer;
+  typedef const __storage_type* __const_storage_pointer;
+  static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
 
-    friend class __bit_reference<__bitset>;
-    friend class __bit_const_reference<__bitset>;
-    friend class __bit_iterator<__bitset, false>;
-    friend class __bit_iterator<__bitset, true>;
-    friend struct __bit_array<__bitset>;
+  friend class __bit_reference<__bitset>;
+  friend class __bit_const_reference<__bitset>;
+  friend class __bit_iterator<__bitset, false>;
+  friend class __bit_iterator<__bitset, true>;
+  friend struct __bit_array<__bitset>;
 
-    __storage_type __first_;
+  __storage_type __first_;
 
-    typedef __bit_reference<__bitset>                  reference;
-    typedef __bit_const_reference<__bitset>            const_reference;
-    typedef __bit_iterator<__bitset, false>            iterator;
-    typedef __bit_iterator<__bitset, true>             const_iterator;
+  typedef __bit_reference<__bitset> reference;
+  typedef __bit_const_reference<__bitset> const_reference;
+  typedef __bit_iterator<__bitset, false> iterator;
+  typedef __bit_iterator<__bitset, true> const_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 reference __make_ref(size_t __pos) _NOEXCEPT
-        {return reference(&__first_, __storage_type(1) << __pos);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT
-        {return const_reference(&__first_, __storage_type(1) << __pos);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 iterator __make_iter(size_t __pos) _NOEXCEPT
-        {return iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 const_iterator __make_iter(size_t __pos) const _NOEXCEPT
-        {return const_iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference __make_ref(size_t __pos) _NOEXCEPT {
+    return reference(&__first_, __storage_type(1) << __pos);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT {
+    return const_reference(&__first_, __storage_type(1) << __pos);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 iterator __make_iter(size_t __pos) _NOEXCEPT {
+    return iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 const_iterator __make_iter(size_t __pos) const _NOEXCEPT {
+    return const_iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    void operator&=(const __bitset& __v) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    void operator|=(const __bitset& __v) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    void operator^=(const __bitset& __v) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator&=(const __bitset& __v) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator|=(const __bitset& __v) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator^=(const __bitset& __v) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    void flip() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void flip() _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long to_ulong() const;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long long to_ullong() const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bool all() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bool any() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t __hash_code() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI size_t __hash_code() const _NOEXCEPT;
 };
 
 template <size_t _Size>
-inline
-_LIBCPP_CONSTEXPR
-__bitset<1, _Size>::__bitset() _NOEXCEPT
-    : __first_(0)
-{
+inline _LIBCPP_CONSTEXPR __bitset<1, _Size>::__bitset() _NOEXCEPT : __first_(0) {}
+
+template <size_t _Size>
+inline _LIBCPP_CONSTEXPR __bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
+    : __first_(_Size == __bits_per_word ? static_cast<__storage_type>(__v)
+                                        : static_cast<__storage_type>(__v) & ((__storage_type(1) << _Size) - 1)) {}
+
+template <size_t _Size>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
+__bitset<1, _Size>::operator&=(const __bitset& __v) _NOEXCEPT {
+  __first_ &= __v.__first_;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_CONSTEXPR
-__bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
-    : __first_(
-        _Size == __bits_per_word ? static_cast<__storage_type>(__v)
-                                 : static_cast<__storage_type>(__v) & ((__storage_type(1) << _Size) - 1)
-    )
-{
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
+__bitset<1, _Size>::operator|=(const __bitset& __v) _NOEXCEPT {
+  __first_ |= __v.__first_;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
-__bitset<1, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
-{
-    __first_ &= __v.__first_;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
+__bitset<1, _Size>::operator^=(const __bitset& __v) _NOEXCEPT {
+  __first_ ^= __v.__first_;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
-__bitset<1, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
-{
-    __first_ |= __v.__first_;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void __bitset<1, _Size>::flip() _NOEXCEPT {
+  __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
+  __first_           = ~__first_;
+  __first_ &= __m;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
-__bitset<1, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
-{
-    __first_ ^= __v.__first_;
+inline _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long __bitset<1, _Size>::to_ulong() const {
+  return __first_;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
-__bitset<1, _Size>::flip() _NOEXCEPT
-{
-    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
-    __first_ = ~__first_;
-    __first_ &= __m;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long __bitset<1, _Size>::to_ullong() const {
+  return __first_;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long
-__bitset<1, _Size>::to_ulong() const
-{
-    return __first_;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool __bitset<1, _Size>::all() const _NOEXCEPT {
+  __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
+  return !(~__first_ & __m);
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long
-__bitset<1, _Size>::to_ullong() const
-{
-    return __first_;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool __bitset<1, _Size>::any() const _NOEXCEPT {
+  __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
+  return __first_ & __m;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-__bitset<1, _Size>::all() const _NOEXCEPT
-{
-    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
-    return !(~__first_ & __m);
-}
-
-template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
-__bitset<1, _Size>::any() const _NOEXCEPT
-{
-    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
-    return __first_ & __m;
-}
-
-template <size_t _Size>
-inline
-size_t
-__bitset<1, _Size>::__hash_code() const _NOEXCEPT
-{
-    return __first_;
+inline size_t __bitset<1, _Size>::__hash_code() const _NOEXCEPT {
+  return __first_;
 }
 
 template <>
-class __bitset<0, 0>
-{
+class __bitset<0, 0> {
 public:
-    typedef ptrdiff_t              difference_type;
-    typedef size_t                 size_type;
-    typedef size_type              __storage_type;
+  typedef ptrdiff_t difference_type;
+  typedef size_t size_type;
+  typedef size_type __storage_type;
+
 protected:
-    typedef __bitset __self;
-    typedef       __storage_type*  __storage_pointer;
-    typedef const __storage_type*  __const_storage_pointer;
-    static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
+  typedef __bitset __self;
+  typedef __storage_type* __storage_pointer;
+  typedef const __storage_type* __const_storage_pointer;
+  static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
 
-    friend class __bit_reference<__bitset>;
-    friend class __bit_const_reference<__bitset>;
-    friend class __bit_iterator<__bitset, false>;
-    friend class __bit_iterator<__bitset, true>;
-    friend struct __bit_array<__bitset>;
+  friend class __bit_reference<__bitset>;
+  friend class __bit_const_reference<__bitset>;
+  friend class __bit_iterator<__bitset, false>;
+  friend class __bit_iterator<__bitset, true>;
+  friend struct __bit_array<__bitset>;
 
-    typedef __bit_reference<__bitset>                  reference;
-    typedef __bit_const_reference<__bitset>            const_reference;
-    typedef __bit_iterator<__bitset, false>            iterator;
-    typedef __bit_iterator<__bitset, true>             const_iterator;
+  typedef __bit_reference<__bitset> reference;
+  typedef __bit_const_reference<__bitset> const_reference;
+  typedef __bit_iterator<__bitset, false> iterator;
+  typedef __bit_iterator<__bitset, true> const_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 reference __make_ref(size_t) _NOEXCEPT
-        {return reference(nullptr, 1);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t) const _NOEXCEPT
-        {return const_reference(nullptr, 1);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 iterator __make_iter(size_t) _NOEXCEPT
-        {return iterator(nullptr, 0);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 const_iterator __make_iter(size_t) const _NOEXCEPT
-        {return const_iterator(nullptr, 0);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference __make_ref(size_t) _NOEXCEPT {
+    return reference(nullptr, 1);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference __make_ref(size_t) const _NOEXCEPT {
+    return const_reference(nullptr, 1);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 iterator __make_iter(size_t) _NOEXCEPT {
+    return iterator(nullptr, 0);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 const_iterator __make_iter(size_t) const _NOEXCEPT {
+    return const_iterator(nullptr, 0);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator&=(const __bitset&) _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator|=(const __bitset&) _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator^=(const __bitset&) _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator&=(const __bitset&) _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator|=(const __bitset&) _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator^=(const __bitset&) _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 void flip() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void flip() _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const {return 0;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const {return 0;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const { return 0; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const { return 0; }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT {return true;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT {return false;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT { return true; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT { return false; }
 
-    _LIBCPP_INLINE_VISIBILITY size_t __hash_code() const _NOEXCEPT {return 0;}
+  _LIBCPP_HIDE_FROM_ABI size_t __hash_code() const _NOEXCEPT { return 0; }
 };
 
-inline
-_LIBCPP_CONSTEXPR
-__bitset<0, 0>::__bitset() _NOEXCEPT
-{
-}
+inline _LIBCPP_CONSTEXPR __bitset<0, 0>::__bitset() _NOEXCEPT {}
 
-inline
-_LIBCPP_CONSTEXPR
-__bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT
-{
-}
+inline _LIBCPP_CONSTEXPR __bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT {}
 
-template <size_t _Size> class _LIBCPP_TEMPLATE_VIS bitset;
-template <size_t _Size> struct hash<bitset<_Size> >;
+template <size_t _Size>
+class _LIBCPP_TEMPLATE_VIS bitset;
+template <size_t _Size>
+struct hash<bitset<_Size> >;
 
 template <size_t _Size>
 class _LIBCPP_TEMPLATE_VIS bitset
-    : private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size>
-{
+    : private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size> {
 public:
-    static const unsigned __n_words = _Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1;
-    typedef __bitset<__n_words, _Size> base;
+  static const unsigned __n_words = _Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1;
+  typedef __bitset<__n_words, _Size> base;
 
 public:
-    typedef typename base::reference       reference;
-    typedef typename base::const_reference const_reference;
+  typedef typename base::reference reference;
+  typedef typename base::const_reference const_reference;
 
-    // 23.3.5.1 constructors:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bitset() _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-        bitset(unsigned long long __v) _NOEXCEPT : base(__v) {}
-    template<class _CharT, class = __enable_if_t<_IsCharLikeType<_CharT>::value> >
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-        explicit bitset(const _CharT* __str,
-                        typename basic_string<_CharT>::size_type __n = basic_string<_CharT>::npos,
-                        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
-    template<class _CharT, class _Traits, class _Allocator>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-        explicit bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
-                        typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos = 0,
-                        typename basic_string<_CharT,_Traits,_Allocator>::size_type __n =
-                                (basic_string<_CharT,_Traits,_Allocator>::npos),
-                        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
-
-    // 23.3.5.2 bitset operations:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& operator&=(const bitset& __rhs) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& operator|=(const bitset& __rhs) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& operator^=(const bitset& __rhs) _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& operator<<=(size_t __pos) _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& operator>>=(size_t __pos) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& set() _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& set(size_t __pos, bool __val = true);
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& reset() _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& reset(size_t __pos);
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset  operator~() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& flip() _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset& flip(size_t __pos);
-
-    // element access:
-#ifdef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR            bool operator[](size_t __p) const {return base::__make_ref(__p);}
+  // 23.3.5.1 constructors:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bitset() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bitset(unsigned long long __v) _NOEXCEPT : base(__v) {}
+  template <class _CharT, __enable_if_t<_IsCharLikeType<_CharT>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit bitset(
+      const _CharT* __str,
+#if _LIBCPP_STD_VER >= 26
+      typename basic_string_view<_CharT>::size_type __n = basic_string_view<_CharT>::npos,
 #else
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference operator[](size_t __p) const {return base::__make_ref(__p);}
+      typename basic_string<_CharT>::size_type __n = basic_string<_CharT>::npos,
 #endif
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference operator[](size_t __p)       {return base::__make_ref(__p);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long to_ulong() const;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    unsigned long long to_ullong() const;
-    template <class _CharT, class _Traits, class _Allocator>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-        basic_string<_CharT, _Traits, _Allocator> to_string(_CharT __zero = _CharT('0'),
-                                                            _CharT __one = _CharT('1')) const;
-    template <class _CharT, class _Traits>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-        basic_string<_CharT, _Traits, allocator<_CharT> > to_string(_CharT __zero = _CharT('0'),
-                                                                    _CharT __one = _CharT('1')) const;
-    template <class _CharT>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-        basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > to_string(_CharT __zero = _CharT('0'),
-                                                                                _CharT __one = _CharT('1')) const;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    basic_string<char, char_traits<char>, allocator<char> > to_string(char __zero = '0',
-                                                                      char __one = '1') const;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    size_t count() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR size_t size() const _NOEXCEPT {return _Size;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bool operator==(const bitset& __rhs) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bool operator!=(const bitset& __rhs) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bool test(size_t __pos) const;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bool all() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bool any() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23 bool none() const _NOEXCEPT {return !any();}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset operator<<(size_t __pos) const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bitset operator>>(size_t __pos) const _NOEXCEPT;
+      _CharT __zero = _CharT('0'),
+      _CharT __one  = _CharT('1')) {
+
+    size_t __rlen = std::min(__n, char_traits<_CharT>::length(__str));
+    __init_from_string_view(basic_string_view<_CharT>(__str, __rlen), __zero, __one);
+  }
+#if _LIBCPP_STD_VER >= 26
+  template <class _CharT, class _Traits>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit bitset(
+      basic_string_view<_CharT, _Traits> __str,
+      typename basic_string_view<_CharT, _Traits>::size_type __pos = 0,
+      typename basic_string_view<_CharT, _Traits>::size_type __n   = basic_string_view<_CharT, _Traits>::npos,
+      _CharT __zero                                                = _CharT('0'),
+      _CharT __one                                                 = _CharT('1')) {
+    if (__pos > __str.size())
+      __throw_out_of_range("bitset string pos out of range");
+
+    size_t __rlen = std::min(__n, __str.size() - __pos);
+    __init_from_string_view(basic_string_view<_CharT, _Traits>(__str.data() + __pos, __rlen), __zero, __one);
+  }
+#endif
+  template <class _CharT, class _Traits, class _Allocator>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit bitset(
+      const basic_string<_CharT, _Traits, _Allocator>& __str,
+      typename basic_string<_CharT, _Traits, _Allocator>::size_type __pos = 0,
+      typename basic_string<_CharT, _Traits, _Allocator>::size_type __n =
+          basic_string<_CharT, _Traits, _Allocator>::npos,
+      _CharT __zero = _CharT('0'),
+      _CharT __one  = _CharT('1')) {
+    if (__pos > __str.size())
+      std::__throw_out_of_range("bitset string pos out of range");
+
+    size_t __rlen = std::min(__n, __str.size() - __pos);
+    __init_from_string_view(basic_string_view<_CharT, _Traits>(__str.data() + __pos, __rlen), __zero, __one);
+  }
+
+  // 23.3.5.2 bitset operations:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& operator&=(const bitset& __rhs) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& operator|=(const bitset& __rhs) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& operator^=(const bitset& __rhs) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& operator<<=(size_t __pos) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& operator>>=(size_t __pos) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& set() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& set(size_t __pos, bool __val = true);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& reset() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& reset(size_t __pos);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator~() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& flip() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& flip(size_t __pos);
+
+  // element access:
+#ifdef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator[](size_t __p) const { return base::__make_ref(__p); }
+#else
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const_reference operator[](size_t __p) const { return base::__make_ref(__p); }
+#endif
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference operator[](size_t __p) { return base::__make_ref(__p); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const;
+  template <class _CharT, class _Traits, class _Allocator>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, _Allocator>
+  to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const;
+  template <class _CharT, class _Traits>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, allocator<_CharT> >
+  to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const;
+  template <class _CharT>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
+  to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<char, char_traits<char>, allocator<char> >
+  to_string(char __zero = '0', char __one = '1') const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 size_t count() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_t size() const _NOEXCEPT { return _Size; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator==(const bitset& __rhs) const _NOEXCEPT;
+#if _LIBCPP_STD_VER <= 17
+  _LIBCPP_HIDE_FROM_ABI bool operator!=(const bitset& __rhs) const _NOEXCEPT;
+#endif
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool test(size_t __pos) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool none() const _NOEXCEPT { return !any(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator<<(size_t __pos) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator>>(size_t __pos) const _NOEXCEPT;
 
 private:
+  template <class _CharT, class _Traits>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
+  __init_from_string_view(basic_string_view<_CharT, _Traits> __str, _CharT __zero, _CharT __one) {
+    for (size_t __i = 0; __i < __str.size(); ++__i)
+      if (!_Traits::eq(__str[__i], __zero) && !_Traits::eq(__str[__i], __one))
+        std::__throw_invalid_argument("bitset string ctor has invalid argument");
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t __hash_code() const _NOEXCEPT {return base::__hash_code();}
+    size_t __mp = std::min(__str.size(), _Size);
+    size_t __i  = 0;
+    for (; __i < __mp; ++__i) {
+      _CharT __c   = __str[__mp - 1 - __i];
+      (*this)[__i] = _Traits::eq(__c, __one);
+    }
+    std::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
+  }
 
-    friend struct hash<bitset>;
+  _LIBCPP_HIDE_FROM_ABI size_t __hash_code() const _NOEXCEPT { return base::__hash_code(); }
+
+  friend struct hash<bitset>;
 };
 
 template <size_t _Size>
-template<class _CharT, class>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>::bitset(const _CharT* __str,
-                      typename basic_string<_CharT>::size_type __n,
-                      _CharT __zero, _CharT __one)
-{
-    size_t __rlen = _VSTD::min(__n, char_traits<_CharT>::length(__str));
-    for (size_t __i = 0; __i < __rlen; ++__i)
-        if (__str[__i] != __zero && __str[__i] != __one)
-            __throw_invalid_argument("bitset string ctor has invalid argument");
-
-    size_t __mp = _VSTD::min(__rlen, _Size);
-    size_t __i = 0;
-    for (; __i < __mp; ++__i)
-    {
-        _CharT __c = __str[__mp - 1 - __i];
-        (*this)[__i] = (__c == __one);
-    }
-    _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>&
+bitset<_Size>::operator&=(const bitset& __rhs) _NOEXCEPT {
+  base::operator&=(__rhs);
+  return *this;
 }
 
 template <size_t _Size>
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
-       typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos,
-       typename basic_string<_CharT,_Traits,_Allocator>::size_type __n,
-       _CharT __zero, _CharT __one)
-{
-    if (__pos > __str.size())
-        __throw_out_of_range("bitset string pos out of range");
-
-    size_t __rlen = _VSTD::min(__n, __str.size() - __pos);
-    for (size_t __i = __pos; __i < __pos + __rlen; ++__i)
-        if (!_Traits::eq(__str[__i], __zero) && !_Traits::eq(__str[__i], __one))
-            __throw_invalid_argument("bitset string ctor has invalid argument");
-
-    size_t __mp = _VSTD::min(__rlen, _Size);
-    size_t __i = 0;
-    for (; __i < __mp; ++__i)
-    {
-        _CharT __c = __str[__pos + __mp - 1 - __i];
-        (*this)[__i] = _Traits::eq(__c, __one);
-    }
-    _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>&
+bitset<_Size>::operator|=(const bitset& __rhs) _NOEXCEPT {
+  base::operator|=(__rhs);
+  return *this;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::operator&=(const bitset& __rhs) _NOEXCEPT
-{
-    base::operator&=(__rhs);
-    return *this;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>&
+bitset<_Size>::operator^=(const bitset& __rhs) _NOEXCEPT {
+  base::operator^=(__rhs);
+  return *this;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::operator|=(const bitset& __rhs) _NOEXCEPT
-{
-    base::operator|=(__rhs);
-    return *this;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::operator<<=(size_t __pos) _NOEXCEPT {
+  __pos = std::min(__pos, _Size);
+  std::copy_backward(base::__make_iter(0), base::__make_iter(_Size - __pos), base::__make_iter(_Size));
+  std::fill_n(base::__make_iter(0), __pos, false);
+  return *this;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::operator^=(const bitset& __rhs) _NOEXCEPT
-{
-    base::operator^=(__rhs);
-    return *this;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::operator>>=(size_t __pos) _NOEXCEPT {
+  __pos = std::min(__pos, _Size);
+  std::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0));
+  std::fill_n(base::__make_iter(_Size - __pos), __pos, false);
+  return *this;
 }
 
 template <size_t _Size>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::operator<<=(size_t __pos) _NOEXCEPT
-{
-    __pos = _VSTD::min(__pos, _Size);
-    _VSTD::copy_backward(base::__make_iter(0), base::__make_iter(_Size - __pos), base::__make_iter(_Size));
-    _VSTD::fill_n(base::__make_iter(0), __pos, false);
-    return *this;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::set() _NOEXCEPT {
+  std::fill_n(base::__make_iter(0), _Size, true);
+  return *this;
 }
 
 template <size_t _Size>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::operator>>=(size_t __pos) _NOEXCEPT
-{
-    __pos = _VSTD::min(__pos, _Size);
-    _VSTD::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0));
-    _VSTD::fill_n(base::__make_iter(_Size - __pos), __pos, false);
-    return *this;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::set(size_t __pos, bool __val) {
+  if (__pos >= _Size)
+    __throw_out_of_range("bitset set argument out of range");
+
+  (*this)[__pos] = __val;
+  return *this;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::set() _NOEXCEPT
-{
-    _VSTD::fill_n(base::__make_iter(0), _Size, true);
-    return *this;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::reset() _NOEXCEPT {
+  std::fill_n(base::__make_iter(0), _Size, false);
+  return *this;
 }
 
 template <size_t _Size>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::set(size_t __pos, bool __val)
-{
-    if (__pos >= _Size)
-        __throw_out_of_range("bitset set argument out of range");
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::reset(size_t __pos) {
+  if (__pos >= _Size)
+    __throw_out_of_range("bitset reset argument out of range");
 
-    (*this)[__pos] = __val;
-    return *this;
+  (*this)[__pos] = false;
+  return *this;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::reset() _NOEXCEPT
-{
-    _VSTD::fill_n(base::__make_iter(0), _Size, false);
-    return *this;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size> bitset<_Size>::operator~() const _NOEXCEPT {
+  bitset __x(*this);
+  __x.flip();
+  return __x;
 }
 
 template <size_t _Size>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::reset(size_t __pos)
-{
-    if (__pos >= _Size)
-        __throw_out_of_range("bitset reset argument out of range");
-
-    (*this)[__pos] = false;
-    return *this;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::flip() _NOEXCEPT {
+  base::flip();
+  return *this;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>
-bitset<_Size>::operator~() const _NOEXCEPT
-{
-    bitset __x(*this);
-    __x.flip();
-    return __x;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::flip(size_t __pos) {
+  if (__pos >= _Size)
+    __throw_out_of_range("bitset flip argument out of range");
+
+  reference __r = base::__make_ref(__pos);
+  __r           = ~__r;
+  return *this;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::flip() _NOEXCEPT
-{
-    base::flip();
-    return *this;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long bitset<_Size>::to_ulong() const {
+  return base::to_ulong();
 }
 
 template <size_t _Size>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>&
-bitset<_Size>::flip(size_t __pos)
-{
-    if (__pos >= _Size)
-        __throw_out_of_range("bitset flip argument out of range");
-
-    reference __r = base::__make_ref(__pos);
-    __r = ~__r;
-    return *this;
-}
-
-template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-unsigned long
-bitset<_Size>::to_ulong() const
-{
-    return base::to_ulong();
-}
-
-template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-unsigned long long
-bitset<_Size>::to_ullong() const
-{
-    return base::to_ullong();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long bitset<_Size>::to_ullong() const {
+  return base::to_ullong();
 }
 
 template <size_t _Size>
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-basic_string<_CharT, _Traits, _Allocator>
-bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
-{
-    basic_string<_CharT, _Traits, _Allocator> __r(_Size, __zero);
-    for (size_t __i = 0; __i != _Size; ++__i)
-    {
-        if ((*this)[__i])
-            __r[_Size - 1 - __i] = __one;
-    }
-    return __r;
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, _Allocator>
+bitset<_Size>::to_string(_CharT __zero, _CharT __one) const {
+  basic_string<_CharT, _Traits, _Allocator> __r(_Size, __zero);
+  for (size_t __i = 0; __i != _Size; ++__i) {
+    if ((*this)[__i])
+      __r[_Size - 1 - __i] = __one;
+  }
+  return __r;
 }
 
 template <size_t _Size>
 template <class _CharT, class _Traits>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-basic_string<_CharT, _Traits, allocator<_CharT> >
-bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
-{
-    return to_string<_CharT, _Traits, allocator<_CharT> >(__zero, __one);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, allocator<_CharT> >
+bitset<_Size>::to_string(_CharT __zero, _CharT __one) const {
+  return to_string<_CharT, _Traits, allocator<_CharT> >(__zero, __one);
 }
 
 template <size_t _Size>
 template <class _CharT>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
-bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
-{
-    return to_string<_CharT, char_traits<_CharT>, allocator<_CharT> >(__zero, __one);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
+bitset<_Size>::to_string(_CharT __zero, _CharT __one) const {
+  return to_string<_CharT, char_traits<_CharT>, allocator<_CharT> >(__zero, __one);
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-basic_string<char, char_traits<char>, allocator<char> >
-bitset<_Size>::to_string(char __zero, char __one) const
-{
-    return to_string<char, char_traits<char>, allocator<char> >(__zero, __one);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<char, char_traits<char>, allocator<char> >
+bitset<_Size>::to_string(char __zero, char __one) const {
+  return to_string<char, char_traits<char>, allocator<char> >(__zero, __one);
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-size_t
-bitset<_Size>::count() const _NOEXCEPT
-{
-    return static_cast<size_t>(_VSTD::__count_bool_true(base::__make_iter(0), _Size));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 size_t bitset<_Size>::count() const _NOEXCEPT {
+  return static_cast<size_t>(std::count(base::__make_iter(0), base::__make_iter(_Size), true));
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bool
-bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT
-{
-    return _VSTD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
+bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT {
+  return std::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
+}
+
+#if _LIBCPP_STD_VER <= 17
+
+template <size_t _Size>
+inline _LIBCPP_HIDE_FROM_ABI bool bitset<_Size>::operator!=(const bitset& __rhs) const _NOEXCEPT {
+  return !(*this == __rhs);
+}
+
+#endif
+
+template <size_t _Size>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool bitset<_Size>::test(size_t __pos) const {
+  if (__pos >= _Size)
+    __throw_out_of_range("bitset test argument out of range");
+
+  return (*this)[__pos];
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bool
-bitset<_Size>::operator!=(const bitset& __rhs) const _NOEXCEPT
-{
-    return !(*this == __rhs);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool bitset<_Size>::all() const _NOEXCEPT {
+  return base::all();
 }
 
 template <size_t _Size>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bool
-bitset<_Size>::test(size_t __pos) const
-{
-    if (__pos >= _Size)
-        __throw_out_of_range("bitset test argument out of range");
-
-    return (*this)[__pos];
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool bitset<_Size>::any() const _NOEXCEPT {
+  return base::any();
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bool
-bitset<_Size>::all() const _NOEXCEPT
-{
-    return base::all();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
+bitset<_Size>::operator<<(size_t __pos) const _NOEXCEPT {
+  bitset __r = *this;
+  __r <<= __pos;
+  return __r;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bool
-bitset<_Size>::any() const _NOEXCEPT
-{
-    return base::any();
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
+bitset<_Size>::operator>>(size_t __pos) const _NOEXCEPT {
+  bitset __r = *this;
+  __r >>= __pos;
+  return __r;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>
-bitset<_Size>::operator<<(size_t __pos) const _NOEXCEPT
-{
-    bitset __r = *this;
-    __r <<= __pos;
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
+operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
+  bitset<_Size> __r = __x;
+  __r &= __y;
+  return __r;
 }
 
 template <size_t _Size>
-inline
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>
-bitset<_Size>::operator>>(size_t __pos) const _NOEXCEPT
-{
-    bitset __r = *this;
-    __r >>= __pos;
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
+operator|(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
+  bitset<_Size> __r = __x;
+  __r |= __y;
+  return __r;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>
-operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
-{
-    bitset<_Size> __r = __x;
-    __r &= __y;
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
+operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
+  bitset<_Size> __r = __x;
+  __r ^= __y;
+  return __r;
 }
 
 template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>
-operator|(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
-{
-    bitset<_Size> __r = __x;
-    __r |= __y;
-    return __r;
-}
-
-template <size_t _Size>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-bitset<_Size>
-operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
-{
-    bitset<_Size> __r = __x;
-    __r ^= __y;
-    return __r;
-}
-
-template <size_t _Size>
-struct _LIBCPP_TEMPLATE_VIS hash<bitset<_Size> >
-    : public __unary_function<bitset<_Size>, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT
-        {return __bs.__hash_code();}
+struct _LIBCPP_TEMPLATE_VIS hash<bitset<_Size> > : public __unary_function<bitset<_Size>, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT { return __bs.__hash_code(); }
 };
 
 template <class _CharT, class _Traits, size_t _Size>
diff --git a/third_party/libcxx/call_once.cpp b/third_party/libcxx/call_once.cpp
new file mode 100644
index 000000000..93f192547
--- /dev/null
+++ b/third_party/libcxx/call_once.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__mutex/once_flag.h>
+#include <__utility/exception_guard.h>
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+#  include <__thread/support.h>
+#endif
+
+#include "atomic_support.h"
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// If dispatch_once_f ever handles C++ exceptions, and if one can get to it
+// without illegal macros (unexpected macros not beginning with _UpperCase or
+// __lowercase), and if it stops spinning waiting threads, then call_once should
+// call into dispatch_once_f instead of here. Relevant radar this code needs to
+// keep in sync with:  7741191.
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+static constinit __libcpp_mutex_t mut  = _LIBCPP_MUTEX_INITIALIZER;
+static constinit __libcpp_condvar_t cv = _LIBCPP_CONDVAR_INITIALIZER;
+#endif
+
+void __call_once(volatile once_flag::_State_type& flag, void* arg, void (*func)(void*)) {
+#if defined(_LIBCPP_HAS_NO_THREADS)
+
+  if (flag == once_flag::_Unset) {
+    auto guard = std::__make_exception_guard([&flag] { flag = once_flag::_Unset; });
+    flag       = once_flag::_Pending;
+    func(arg);
+    flag = once_flag::_Complete;
+    guard.__complete();
+  }
+
+#else // !_LIBCPP_HAS_NO_THREADS
+
+  __libcpp_mutex_lock(&mut);
+  while (flag == once_flag::_Pending)
+    __libcpp_condvar_wait(&cv, &mut);
+  if (flag == once_flag::_Unset) {
+    auto guard = std::__make_exception_guard([&flag] {
+      __libcpp_mutex_lock(&mut);
+      __libcpp_relaxed_store(&flag, once_flag::_Unset);
+      __libcpp_mutex_unlock(&mut);
+      __libcpp_condvar_broadcast(&cv);
+    });
+
+    __libcpp_relaxed_store(&flag, once_flag::_Pending);
+    __libcpp_mutex_unlock(&mut);
+    func(arg);
+    __libcpp_mutex_lock(&mut);
+    __libcpp_atomic_store(&flag, once_flag::_Complete, _AO_Release);
+    __libcpp_mutex_unlock(&mut);
+    __libcpp_condvar_broadcast(&cv);
+    guard.__complete();
+  } else {
+    __libcpp_mutex_unlock(&mut);
+  }
+
+#endif // !_LIBCPP_HAS_NO_THREADS
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/cassert b/third_party/libcxx/cassert
index 761f57dee..6fec37dc6 100644
--- a/third_party/libcxx/cassert
+++ b/third_party/libcxx/cassert
@@ -16,7 +16,6 @@ Macros:
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 // <assert.h> is not provided by libc++
diff --git a/third_party/libcxx/ccomplex b/third_party/libcxx/ccomplex
index cf05c7a91..94d2c8d7d 100644
--- a/third_party/libcxx/ccomplex
+++ b/third_party/libcxx/ccomplex
@@ -17,7 +17,6 @@
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <complex>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
diff --git a/third_party/libcxx/cctype b/third_party/libcxx/cctype
index 867e7d5b0..d7af7e084 100644
--- a/third_party/libcxx/cctype
+++ b/third_party/libcxx/cctype
@@ -34,7 +34,6 @@ int toupper(int c);
 }  // std
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #include <ctype.h>
@@ -53,62 +52,61 @@ int toupper(int c);
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifdef isalnum
-#undef isalnum
+#  undef isalnum
 #endif
 
 #ifdef isalpha
-#undef isalpha
+#  undef isalpha
 #endif
 
 #ifdef isblank
-#undef isblank
+#  undef isblank
 #endif
 
 #ifdef iscntrl
-#undef iscntrl
+#  undef iscntrl
 #endif
 
 #ifdef isdigit
-#undef isdigit
+#  undef isdigit
 #endif
 
 #ifdef isgraph
-#undef isgraph
+#  undef isgraph
 #endif
 
 #ifdef islower
-#undef islower
+#  undef islower
 #endif
 
 #ifdef isprint
-#undef isprint
+#  undef isprint
 #endif
 
 #ifdef ispunct
-#undef ispunct
+#  undef ispunct
 #endif
 
 #ifdef isspace
-#undef isspace
+#  undef isspace
 #endif
 
 #ifdef isupper
-#undef isupper
+#  undef isupper
 #endif
 
 #ifdef isxdigit
-#undef isxdigit
+#  undef isxdigit
 #endif
 
 #ifdef tolower
-#undef tolower
+#  undef tolower
 #endif
 
 #ifdef toupper
-#undef toupper
+#  undef toupper
 #endif
 
-
 using ::isalnum _LIBCPP_USING_IF_EXISTS;
 using ::isalpha _LIBCPP_USING_IF_EXISTS;
 using ::isblank _LIBCPP_USING_IF_EXISTS;
diff --git a/third_party/libcxx/cerrno b/third_party/libcxx/cerrno
index 937ec23c6..f1295680f 100644
--- a/third_party/libcxx/cerrno
+++ b/third_party/libcxx/cerrno
@@ -22,7 +22,6 @@ Macros:
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #include <errno.h>
@@ -39,4 +38,11 @@ Macros:
 #  pragma GCC system_header
 #endif
 
+// LWG3869 Deprecate std::errc constants related to UNIX STREAMS
+//
+// This LWG issue deprecates the POSIX macros ENODATA, ENOSR, ENOSTR, and ETIME. These were
+// deprecated in libc++ in https://github.com/llvm/llvm-project/pull/80542.
+// Based on the post commit feedback the macro are no longer deprecated.
+// Instead libc++ leaves the deprecation to the provider of errno.h.
+
 #endif // _LIBCPP_CERRNO
diff --git a/third_party/libcxx/cfenv b/third_party/libcxx/cfenv
index 16b3761ee..f8cacd562 100644
--- a/third_party/libcxx/cfenv
+++ b/third_party/libcxx/cfenv
@@ -52,7 +52,6 @@ int feupdateenv(const fenv_t* envp);
 }  // std
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #include <fenv.h>
diff --git a/third_party/libcxx/cfloat b/third_party/libcxx/cfloat
index 4f991dd49..5d1b38c55 100644
--- a/third_party/libcxx/cfloat
+++ b/third_party/libcxx/cfloat
@@ -69,7 +69,6 @@ Macros:
     LDBL_TRUE_MIN       // C11
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #include <float.h>
diff --git a/third_party/libcxx/charconv b/third_party/libcxx/charconv
index 3b14237c0..a2e270e93 100644
--- a/third_party/libcxx/charconv
+++ b/third_party/libcxx/charconv
@@ -28,6 +28,7 @@ namespace std {
     char* ptr;
     errc ec;
     friend bool operator==(const to_chars_result&, const to_chars_result&) = default; // since C++20
+    constexpr explicit operator bool() const noexcept { return ec == errc{}; }        // since C++26
   };
 
   constexpr to_chars_result to_chars(char* first, char* last, see below value,
@@ -58,6 +59,7 @@ namespace std {
     const char* ptr;
     errc ec;
     friend bool operator==(const from_chars_result&, const from_chars_result&) = default; // since C++20
+    constexpr explicit operator bool() const noexcept { return ec == errc{}; }            // since C++26
   };
 
   constexpr from_chars_result from_chars(const char* first, const char* last,
@@ -67,23 +69,22 @@ namespace std {
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__charconv/chars_format.h>
-#include <__charconv/from_chars_integral.h>
-#include <__charconv/from_chars_result.h>
-#include <__charconv/tables.h>
-#include <__charconv/to_chars.h>
-#include <__charconv/to_chars_base_10.h>
-#include <__charconv/to_chars_floating_point.h>
-#include <__charconv/to_chars_integral.h>
-#include <__charconv/to_chars_result.h>
-#include <__charconv/traits.h>
 #include <__config>
-#include <__debug>
-#include <__system_error/errc.h>
-#include <cmath> // for log2f
-#include <cstdint>
-#include <limits>
+
+#if _LIBCPP_STD_VER >= 17
+#  include <__charconv/chars_format.h>
+#  include <__charconv/from_chars_integral.h>
+#  include <__charconv/from_chars_result.h>
+#  include <__charconv/tables.h>
+#  include <__charconv/to_chars.h>
+#  include <__charconv/to_chars_base_10.h>
+#  include <__charconv/to_chars_floating_point.h>
+#  include <__charconv/to_chars_integral.h>
+#  include <__charconv/to_chars_result.h>
+#  include <__charconv/traits.h>
+#endif // _LIBCPP_STD_VER >= 17
+
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -93,11 +94,21 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 14
+#  include <cerrno>
+#  include <cstddef>
+#  include <initializer_list>
+#  include <new>
+#endif
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cmath>
 #  include <concepts>
+#  include <cstdint>
 #  include <cstdlib>
 #  include <cstring>
 #  include <iosfwd>
+#  include <limits>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/charconv.cpp b/third_party/libcxx/charconv.cpp
new file mode 100644
index 000000000..c7209e2fd
--- /dev/null
+++ b/third_party/libcxx/charconv.cpp
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <charconv>
+#include <string.h>
+
+#include "to_chars_floating_point.h"
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
+
+namespace __itoa {
+
+_LIBCPP_EXPORTED_FROM_ABI char* __u32toa(uint32_t value, char* buffer) noexcept { return __base_10_u32(buffer, value); }
+
+_LIBCPP_EXPORTED_FROM_ABI char* __u64toa(uint64_t value, char* buffer) noexcept { return __base_10_u64(buffer, value); }
+
+} // namespace __itoa
+
+#endif // _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
+
+// The original version of floating-point to_chars was written by Microsoft and
+// contributed with the following license.
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This implementation is dedicated to the memory of Mary and Thavatchai.
+
+to_chars_result to_chars(char* __first, char* __last, float __value) {
+  return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(__first, __last, __value, chars_format{}, 0);
+}
+
+to_chars_result to_chars(char* __first, char* __last, double __value) {
+  return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(__first, __last, __value, chars_format{}, 0);
+}
+
+to_chars_result to_chars(char* __first, char* __last, long double __value) {
+  return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(
+      __first, __last, static_cast<double>(__value), chars_format{}, 0);
+}
+
+to_chars_result to_chars(char* __first, char* __last, float __value, chars_format __fmt) {
+  return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(__first, __last, __value, __fmt, 0);
+}
+
+to_chars_result to_chars(char* __first, char* __last, double __value, chars_format __fmt) {
+  return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(__first, __last, __value, __fmt, 0);
+}
+
+to_chars_result to_chars(char* __first, char* __last, long double __value, chars_format __fmt) {
+  return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(
+      __first, __last, static_cast<double>(__value), __fmt, 0);
+}
+
+to_chars_result to_chars(char* __first, char* __last, float __value, chars_format __fmt, int __precision) {
+  return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(
+      __first, __last, __value, __fmt, __precision);
+}
+
+to_chars_result to_chars(char* __first, char* __last, double __value, chars_format __fmt, int __precision) {
+  return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(
+      __first, __last, __value, __fmt, __precision);
+}
+
+to_chars_result to_chars(char* __first, char* __last, long double __value, chars_format __fmt, int __precision) {
+  return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(
+      __first, __last, static_cast<double>(__value), __fmt, __precision);
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/chrono b/third_party/libcxx/chrono
index ab9b553f2..990c415ec 100644
--- a/third_party/libcxx/chrono
+++ b/third_party/libcxx/chrono
@@ -10,6 +10,8 @@
 #ifndef _LIBCPP_CHRONO
 #define _LIBCPP_CHRONO
 
+// clang-format off
+
 /*
     chrono synopsis
 
@@ -56,7 +58,7 @@ public:
         constexpr explicit duration(const Rep2& r,
             typename enable_if
             <
-               is_convertible<Rep2, rep>::value &&
+               is_convertible<const Rep2&, rep>::value &&
                (treat_as_floating_point<rep>::value ||
                !treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value)
             >::type* = 0);
@@ -294,6 +296,10 @@ template<class charT, class traits, class Duration>     // C++20
   basic_ostream<charT, traits>&
     operator<<(basic_ostream<charT, traits>& os, const sys_time<Duration>& tp);
 
+template<class charT, class traits>                    // C++20
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const sys_days& dp);
+
 class file_clock                                        // C++20
 {
 public:
@@ -390,7 +396,6 @@ template<class charT, class traits>
 class weekday;
 
 constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
-constexpr bool operator!=(const weekday& x, const weekday& y) noexcept;
 constexpr weekday operator+(const weekday& x, const days&    y) noexcept;
 constexpr weekday operator+(const days&    x, const weekday& y) noexcept;
 constexpr weekday operator-(const weekday& x, const days&    y) noexcept;
@@ -403,7 +408,6 @@ template<class charT, class traits>
 
 class weekday_indexed;
 constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
-constexpr bool operator!=(const weekday_indexed& x, const weekday_indexed& y) noexcept;
 
 template<class charT, class traits>
   basic_ostream<charT, traits>&
@@ -413,7 +417,6 @@ template<class charT, class traits>
 class weekday_last;
 
 constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
-constexpr bool operator!=(const weekday_last& x, const weekday_last& y) noexcept;
 
 template<class charT, class traits>
   basic_ostream<charT, traits>&
@@ -443,7 +446,6 @@ template<class charT, class traits>
 class month_weekday;
 
 constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
-constexpr bool operator!=(const month_weekday& x, const month_weekday& y) noexcept;
 
 template<class charT, class traits>
   basic_ostream<charT, traits>&
@@ -453,7 +455,6 @@ template<class charT, class traits>
 class month_weekday_last;
 
 constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
-constexpr bool operator!=(const month_weekday_last& x, const month_weekday_last& y) noexcept;
 
 template<class charT, class traits>
   basic_ostream<charT, traits>&
@@ -523,8 +524,6 @@ class year_month_weekday;
 
 constexpr bool operator==(const year_month_weekday& x,
                           const year_month_weekday& y) noexcept;
-constexpr bool operator!=(const year_month_weekday& x,
-                          const year_month_weekday& y) noexcept;
 
 constexpr year_month_weekday
   operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
@@ -548,8 +547,6 @@ class year_month_weekday_last;
 
 constexpr bool operator==(const year_month_weekday_last& x,
                           const year_month_weekday_last& y) noexcept;
-constexpr bool operator!=(const year_month_weekday_last& x,
-                          const year_month_weekday_last& y) noexcept;
 constexpr year_month_weekday_last
   operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
 constexpr year_month_weekday_last
@@ -686,15 +683,179 @@ constexpr bool is_pm(hours const& h) noexcept;
 constexpr hours make12(const hours& h) noexcept;
 constexpr hours make24(const hours& h, bool is_pm) noexcept;
 
-// 25.10.5, class time_zone    // C++20
+// [time.zone.db], time zone database
+struct tzdb {                                                                    // C++20
+  string                 version;
+  vector<time_zone>      zones;
+  vector<time_zone_link> links;
+  vector<leap_second>    leap_seconds;
+
+  const time_zone* locate_zone(string_view tz_name) const;
+  const time_zone* current_zone() const;
+};
+
+class tzdb_list {                                                                // C++20
+public:
+  tzdb_list(const tzdb_list&) = delete;
+  tzdb_list& operator=(const tzdb_list&) = delete;
+
+  // unspecified additional constructors
+
+  class const_iterator;
+
+  const tzdb& front() const noexcept;
+
+  const_iterator erase_after(const_iterator p);
+
+  const_iterator begin() const noexcept;
+  const_iterator end()   const noexcept;
+
+  const_iterator cbegin() const noexcept;
+  const_iterator cend()   const noexcept;
+};
+
+// [time.zone.db.access], time zone database access
+const tzdb& get_tzdb();                                                          // C++20
+tzdb_list& get_tzdb_list();                                                      // C++20
+const time_zone* locate_zone(string_view tz_name);                               // C++20
+const time_zone* current_zone()                                                  // C++20
+
+// [time.zone.db.remote], remote time zone database support
+const tzdb& reload_tzdb();                                                       // C++20
+string remote_version();                                                         // C++20
+
+// [time.zone.exception], exception classes
+class nonexistent_local_time;                                                    // C++20
+class ambiguous_local_time;                                                      // C++20
+
+// [time.zone.info], information classes
+struct sys_info {                                                                // C++20
+  sys_seconds   begin;
+  sys_seconds   end;
+  seconds       offset;
+  minutes       save;
+  string        abbrev;
+};
+
+template<class charT, class traits>                                              // C++20
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const sys_info& si);
+
+struct local_info {                                                             // C++20
+  static constexpr int unique      = 0;
+  static constexpr int nonexistent = 1;
+  static constexpr int ambiguous   = 2;
+
+  int result;
+  sys_info first;
+  sys_info second;
+};
+
+template<class charT, class traits>                                              // C++20
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os, const local_info& li);
+
+// 25.10.5, class time_zone                                                      // C++20
 enum class choose {earliest, latest};
-class time_zone;
-bool operator==(const time_zone& x, const time_zone& y) noexcept;
-bool operator!=(const time_zone& x, const time_zone& y) noexcept;
-bool operator<(const time_zone& x, const time_zone& y) noexcept;
-bool operator>(const time_zone& x, const time_zone& y) noexcept;
-bool operator<=(const time_zone& x, const time_zone& y) noexcept;
-bool operator>=(const time_zone& x, const time_zone& y) noexcept;
+class time_zone {
+  time_zone(time_zone&&) = default;
+  time_zone& operator=(time_zone&&) = default;
+
+  // unspecified additional constructors
+
+  string_view name() const noexcept;
+
+  template<class Duration>
+  sys_info get_info(const sys_time<Duration>& st) const;
+
+  template<class Duration>
+  local_info get_info(const local_time<Duration>& tp) const;
+
+  template<class Duration>
+  sys_time<common_type_t<Duration, seconds>>
+    to_sys(const local_time<Duration>& tp) const;
+
+  template<class Duration>
+  sys_time<common_type_t<Duration, seconds>>
+    to_sys(const local_time<Duration>& tp, choose z) const;
+
+  template<class Duration>
+  local_time<common_type_t<Duration, seconds>>
+    to_local(const sys_time<Duration>& tp) const;
+};
+bool operator==(const time_zone& x, const time_zone& y) noexcept;                // C++20
+strong_ordering operator<=>(const time_zone& x, const time_zone& y) noexcept;    // C++20
+
+// [time.zone.zonedtraits], class template zoned_traits
+template<class T> struct zoned_traits;                                           // C++20
+
+// [time.zone.zonedtime], class template zoned_time
+template<class Duration, class TimeZonePtr = const time_zone*>                   // C++20
+class zoned_time;
+
+using zoned_seconds = zoned_time<seconds>;                                       // C++20
+
+template<class Duration1, class Duration2, class TimeZonePtr>                    // C++20
+  bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,
+                  const zoned_time<Duration2, TimeZonePtr>& y);
+
+template<class charT, class traits, class Duration, class TimeZonePtr>           // C++20
+  basic_ostream<charT, traits>&
+    operator<<(basic_ostream<charT, traits>& os,
+               const zoned_time<Duration, TimeZonePtr>& t);
+
+// [time.zone.leap], leap second support
+class leap_second {                                                              // C++20
+public:
+  leap_second(const leap_second&)            = default;
+  leap_second& operator=(const leap_second&) = default;
+
+  // unspecified additional constructors
+
+  constexpr sys_seconds date() const noexcept;
+  constexpr seconds value() const noexcept;
+};
+
+constexpr bool operator==(const leap_second& x, const leap_second& y);           // C++20
+constexpr strong_ordering operator<=>(const leap_second& x, const leap_second& y);
+
+template<class Duration>                                                         // C++20
+  constexpr bool operator==(const leap_second& x, const sys_time<Duration>& y);
+template<class Duration>                                                         // C++20
+  constexpr bool operator< (const leap_second& x, const sys_time<Duration>& y);
+template<class Duration>                                                         // C++20
+  constexpr bool operator< (const sys_time<Duration>& x, const leap_second& y);
+template<class Duration>                                                         // C++20
+  constexpr bool operator> (const leap_second& x, const sys_time<Duration>& y);
+template<class Duration>                                                         // C++20
+  constexpr bool operator> (const sys_time<Duration>& x, const leap_second& y);
+template<class Duration>                                                         // C++20
+  constexpr bool operator<=(const leap_second& x, const sys_time<Duration>& y);
+template<class Duration>                                                         // C++20
+  constexpr bool operator<=(const sys_time<Duration>& x, const leap_second& y);
+template<class Duration>                                                         // C++20
+  constexpr bool operator>=(const leap_second& x, const sys_time<Duration>& y);
+template<class Duration>                                                         // C++20
+  constexpr bool operator>=(const sys_time<Duration>& x, const leap_second& y);
+template<class Duration>                                                         // C++20
+  requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
+  constexpr auto operator<=>(const leap_second& x, const sys_time<Duration>& y);
+
+// [time.zone.link], class time_zone_link
+class time_zone_link {                                                           // C++20
+public:
+  time_zone_link(time_zone_link&&)            = default;
+  time_zone_link& operator=(time_zone_link&&) = default;
+
+  // unspecified additional constructors
+
+  string_view name()   const noexcept;
+  string_view target() const noexcept;
+};
+
+bool operator==(const time_zone_link& x, const time_zone_link& y);               // C++20
+strong_ordering operator<=>(const time_zone_link& x, const time_zone_link& y);   // C++20
+
 }  // chrono
 
 namespace std {
@@ -723,6 +884,10 @@ namespace std {
   template<class charT> struct formatter<chrono::year_month_weekday_last, charT>; // C++20
   template<class Rep, class Period, class charT>
     struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, charT>;             // C++20
+  template<class charT> struct formatter<chrono::sys_info, charT>;                // C++20
+  template<class charT> struct formatter<chrono::local_info, charT>;              // C++20
+  template<class Duration, class TimeZonePtr, class charT>                        // C++20
+    struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, charT>;
 } // namespace std
 
 namespace chrono {
@@ -772,28 +937,53 @@ constexpr chrono::year                                  operator ""y(unsigned lo
 }  // std
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__chrono/calendar.h>
-#include <__chrono/convert_to_timespec.h>
-#include <__chrono/convert_to_tm.h>
-#include <__chrono/day.h>
+// clang-format on
+
+#include <__config>
+
 #include <__chrono/duration.h>
 #include <__chrono/file_clock.h>
-#include <__chrono/hh_mm_ss.h>
 #include <__chrono/high_resolution_clock.h>
-#include <__chrono/literals.h>
-#include <__chrono/month.h>
-#include <__chrono/month_weekday.h>
-#include <__chrono/monthday.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/system_clock.h>
 #include <__chrono/time_point.h>
-#include <__chrono/weekday.h>
-#include <__chrono/year.h>
-#include <__chrono/year_month.h>
-#include <__chrono/year_month_day.h>
-#include <__chrono/year_month_weekday.h>
-#include <__config>
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__chrono/calendar.h>
+#  include <__chrono/day.h>
+#  include <__chrono/exception.h>
+#  include <__chrono/hh_mm_ss.h>
+#  include <__chrono/literals.h>
+#  include <__chrono/local_info.h>
+#  include <__chrono/month.h>
+#  include <__chrono/month_weekday.h>
+#  include <__chrono/monthday.h>
+#  include <__chrono/sys_info.h>
+#  include <__chrono/weekday.h>
+#  include <__chrono/year.h>
+#  include <__chrono/year_month.h>
+#  include <__chrono/year_month_day.h>
+#  include <__chrono/year_month_weekday.h>
+
+#  if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#    include <__chrono/formatter.h>
+#    include <__chrono/ostream.h>
+#    include <__chrono/parser_std_format_spec.h>
+#    include <__chrono/statically_widen.h>
+#  endif
+
+#  if !defined(_LIBCPP_HAS_NO_TIME_ZONE_DATABASE) && !defined(_LIBCPP_HAS_NO_FILESYSTEM) &&                            \
+      !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#    include <__chrono/leap_second.h>
+#    include <__chrono/time_zone.h>
+#    include <__chrono/time_zone_link.h>
+#    include <__chrono/tzdb.h>
+#    include <__chrono/tzdb_list.h>
+#    include <__chrono/zoned_time.h>
+#  endif
+
+#endif
+
 #include <version>
 
 // standard-mandated includes
@@ -801,26 +991,32 @@ constexpr chrono::year                                  operator ""y(unsigned lo
 // [time.syn]
 #include <compare>
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && _LIBCPP_STD_VER >= 20
-#  include <__chrono/formatter.h>
-#  include <__chrono/ostream.h>
-#  include <__chrono/parser_std_format_spec.h>
-#  include <__chrono/statically_widen.h>
-#endif
-
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <cstdint>
+#  include <stdexcept>
+#  include <string_view>
+#  include <vector>
+#endif
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <bit>
 #  include <concepts>
 #  include <cstring>
+#  include <forward_list>
+#  include <string>
+#  include <tuple>
 #endif
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER == 20
 #  include <charconv>
+#  if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#    include <locale>
+#  endif
+#  include <ostream>
 #endif
 
 #endif // _LIBCPP_CHRONO
diff --git a/third_party/libcxx/chrono.cpp b/third_party/libcxx/chrono.cpp
new file mode 100644
index 000000000..d98081205
--- /dev/null
+++ b/third_party/libcxx/chrono.cpp
@@ -0,0 +1,231 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#if defined(__MVS__)
+// As part of monotonic clock support on z/OS we need macro _LARGE_TIME_API
+// to be defined before any system header to include definition of struct timespec64.
+#  define _LARGE_TIME_API
+#endif
+
+#include <__system_error/system_error.h>
+#include <cerrno> // errno
+#include <chrono>
+
+#include <time.h> // clock_gettime and CLOCK_{MONOTONIC,REALTIME,MONOTONIC_RAW}
+
+#if __has_include(<unistd.h>)
+#  include <unistd.h> // _POSIX_TIMERS
+#endif
+
+#if __has_include(<sys/time.h>)
+#  include <sys/time.h> // for gettimeofday and timeval
+#endif
+
+// OpenBSD does not have a fully conformant suite of POSIX timers, but
+// it does have clock_gettime and CLOCK_MONOTONIC which is all we need.
+#if defined(__APPLE__) || defined(__gnu_hurd__) || defined(__OpenBSD__) || (defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0)
+#  define _LIBCPP_HAS_CLOCK_GETTIME
+#endif
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define VC_EXTRA_LEAN
+#  include <windows.h>
+#  if _WIN32_WINNT >= _WIN32_WINNT_WIN8
+#    include <winapifamily.h>
+#  endif
+#endif // defined(_LIBCPP_WIN32API)
+
+#if defined(__Fuchsia__)
+#  include <zircon/syscalls.h>
+#endif
+
+#if __has_include(<mach/mach_time.h>)
+#  include <mach/mach_time.h>
+#endif
+
+#if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
+#  pragma comment(lib, "rt")
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace chrono {
+
+//
+// system_clock
+//
+
+#if defined(_LIBCPP_WIN32API)
+
+#  if _WIN32_WINNT < _WIN32_WINNT_WIN8
+
+namespace {
+
+typedef void(WINAPI* GetSystemTimeAsFileTimePtr)(LPFILETIME);
+
+class GetSystemTimeInit {
+public:
+  GetSystemTimeInit() {
+    fp = (GetSystemTimeAsFileTimePtr)(void*)GetProcAddress(
+        GetModuleHandleW(L"kernel32.dll"), "GetSystemTimePreciseAsFileTime");
+    if (fp == nullptr)
+      fp = GetSystemTimeAsFileTime;
+  }
+  GetSystemTimeAsFileTimePtr fp;
+};
+
+// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
+// attribute with a value that's reserved for the implementation (we're the implementation).
+#    include "chrono_system_time_init.h"
+} // namespace
+
+#  endif
+
+static system_clock::time_point __libcpp_system_clock_now() {
+  // FILETIME is in 100ns units
+  using filetime_duration =
+      std::chrono::duration<__int64, std::ratio_multiply<std::ratio<100, 1>, nanoseconds::period>>;
+
+  // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970.
+  static constexpr const seconds nt_to_unix_epoch{11644473600};
+
+  FILETIME ft;
+#  if (_WIN32_WINNT >= _WIN32_WINNT_WIN8 && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)) ||                      \
+      (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
+  GetSystemTimePreciseAsFileTime(&ft);
+#  elif !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+  GetSystemTimeAsFileTime(&ft);
+#  else
+  GetSystemTimeAsFileTimeFunc.fp(&ft);
+#  endif
+
+  filetime_duration d{(static_cast<__int64>(ft.dwHighDateTime) << 32) | static_cast<__int64>(ft.dwLowDateTime)};
+  return system_clock::time_point(duration_cast<system_clock::duration>(d - nt_to_unix_epoch));
+}
+
+#elif defined(_LIBCPP_HAS_CLOCK_GETTIME)
+
+static system_clock::time_point __libcpp_system_clock_now() {
+  struct timespec tp;
+  if (0 != clock_gettime(CLOCK_REALTIME, &tp))
+    __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
+  return system_clock::time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000));
+}
+
+#else
+
+static system_clock::time_point __libcpp_system_clock_now() {
+  timeval tv;
+  gettimeofday(&tv, 0);
+  return system_clock::time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
+}
+
+#endif
+
+const bool system_clock::is_steady;
+
+system_clock::time_point system_clock::now() noexcept { return __libcpp_system_clock_now(); }
+
+time_t system_clock::to_time_t(const time_point& t) noexcept {
+  return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
+}
+
+system_clock::time_point system_clock::from_time_t(time_t t) noexcept { return system_clock::time_point(seconds(t)); }
+
+//
+// steady_clock
+//
+// Warning:  If this is not truly steady, then it is non-conforming.  It is
+//  better for it to not exist and have the rest of libc++ use system_clock
+//  instead.
+//
+
+#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
+
+#  if defined(__APPLE__)
+
+// On Apple platforms, only CLOCK_UPTIME_RAW, CLOCK_MONOTONIC_RAW or
+// mach_absolute_time are able to time functions in the nanosecond range.
+// Furthermore, only CLOCK_MONOTONIC_RAW is truly monotonic, because it
+// also counts cycles when the system is asleep. Thus, it is the only
+// acceptable implementation of steady_clock.
+static steady_clock::time_point __libcpp_steady_clock_now() {
+  struct timespec tp;
+  if (0 != clock_gettime(CLOCK_MONOTONIC_RAW, &tp))
+    __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC_RAW) failed");
+  return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
+}
+
+#  elif defined(_LIBCPP_WIN32API)
+
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx says:
+//    If the function fails, the return value is zero. <snip>
+//    On systems that run Windows XP or later, the function will always succeed
+//      and will thus never return zero.
+
+static LARGE_INTEGER __QueryPerformanceFrequency() {
+  LARGE_INTEGER val;
+  (void)QueryPerformanceFrequency(&val);
+  return val;
+}
+
+static steady_clock::time_point __libcpp_steady_clock_now() {
+  static const LARGE_INTEGER freq = __QueryPerformanceFrequency();
+
+  LARGE_INTEGER counter;
+  (void)QueryPerformanceCounter(&counter);
+  auto seconds   = counter.QuadPart / freq.QuadPart;
+  auto fractions = counter.QuadPart % freq.QuadPart;
+  auto dur       = seconds * nano::den + fractions * nano::den / freq.QuadPart;
+  return steady_clock::time_point(steady_clock::duration(dur));
+}
+
+#  elif defined(__MVS__)
+
+static steady_clock::time_point __libcpp_steady_clock_now() {
+  struct timespec64 ts;
+  if (0 != gettimeofdayMonotonic(&ts))
+    __throw_system_error(errno, "failed to obtain time of day");
+
+  return steady_clock::time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
+}
+
+#  elif defined(__Fuchsia__)
+
+static steady_clock::time_point __libcpp_steady_clock_now() noexcept {
+  // Implicitly link against the vDSO system call ABI without
+  // requiring the final link to specify -lzircon explicitly when
+  // statically linking libc++.
+#    pragma comment(lib, "zircon")
+
+  return steady_clock::time_point(nanoseconds(_zx_clock_get_monotonic()));
+}
+
+#  elif defined(_LIBCPP_HAS_CLOCK_GETTIME)
+
+static steady_clock::time_point __libcpp_steady_clock_now() {
+  struct timespec tp;
+  if (0 != clock_gettime(CLOCK_MONOTONIC, &tp))
+    __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed");
+  return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
+}
+
+#  else
+#    error "Monotonic clock not implemented on this platform"
+#  endif
+
+const bool steady_clock::is_steady;
+
+steady_clock::time_point steady_clock::now() noexcept { return __libcpp_steady_clock_now(); }
+
+#endif // !_LIBCPP_HAS_NO_MONOTONIC_CLOCK
+
+} // namespace chrono
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/chrono_system_time_init.h b/third_party/libcxx/chrono_system_time_init.h
similarity index 100%
rename from third_party/libcxx/src/chrono_system_time_init.h
rename to third_party/libcxx/chrono_system_time_init.h
diff --git a/third_party/libcxx/cinttypes b/third_party/libcxx/cinttypes
index a5b9558ab..52663a4f3 100644
--- a/third_party/libcxx/cinttypes
+++ b/third_party/libcxx/cinttypes
@@ -234,7 +234,6 @@ uintmax_t wcstoumax(const wchar_t* restrict nptr, wchar_t** restrict endptr, int
 }  // std
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 // standard-mandated includes
diff --git a/third_party/libcxx/ciso646 b/third_party/libcxx/ciso646
index e0cd72249..1d859f08f 100644
--- a/third_party/libcxx/ciso646
+++ b/third_party/libcxx/ciso646
@@ -15,7 +15,6 @@
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
diff --git a/third_party/libcxx/climits b/third_party/libcxx/climits
index d773af50d..bcd8b4a56 100644
--- a/third_party/libcxx/climits
+++ b/third_party/libcxx/climits
@@ -37,19 +37,10 @@ Macros:
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #include <limits.h>
 
-#ifndef _LIBCPP_LIMITS_H
-#   error <climits> tried including <limits.h> but didn't find libc++'s <limits.h> header. \
-          This usually means that your header search paths are not configured properly. \
-          The header search paths should contain the C++ Standard Library headers before \
-          any C Standard Library, and you are probably using compiler flags that make that \
-          not be the case.
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
diff --git a/third_party/libcxx/clocale b/third_party/libcxx/clocale
index e2ace355d..c689a64be 100644
--- a/third_party/libcxx/clocale
+++ b/third_party/libcxx/clocale
@@ -34,7 +34,6 @@ lconv* localeconv();
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #include <locale.h>
diff --git a/third_party/libcxx/cmath b/third_party/libcxx/cmath
index e815b3a4e..3c22604a6 100644
--- a/third_party/libcxx/cmath
+++ b/third_party/libcxx/cmath
@@ -204,6 +204,14 @@ floating_point fmin (arithmetic x, arithmetic y);
 float          fminf(float x, float y);
 long double    fminl(long double x, long double y);
 
+double         hermite(unsigned n, double x);                    // C++17
+float          hermite(unsigned n, float x);                     // C++17
+long double    hermite(unsigned n, long double x);               // C++17
+float          hermitef(unsigned n, float x);                    // C++17
+long double    hermitel(unsigned n, long double x);              // C++17
+template <class Integer>
+double         hermite(unsigned n, Integer x);                   // C++17
+
 floating_point hypot (arithmetic x, arithmetic y);
 float          hypotf(float x, float y);
 long double    hypotl(long double x, long double y);
@@ -304,7 +312,6 @@ constexpr long double lerp(long double a, long double b, long double t) noexcept
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_arithmetic.h>
@@ -313,8 +320,10 @@ constexpr long double lerp(long double a, long double b, long double t) noexcept
 #include <__type_traits/is_same.h>
 #include <__type_traits/promote.h>
 #include <__type_traits/remove_cv.h>
+#include <limits>
 #include <version>
 
+#include <__math/special_functions.h>
 #include <math.h>
 
 #ifndef _LIBCPP_MATH_H
@@ -545,284 +554,107 @@ using ::tgammal _LIBCPP_USING_IF_EXISTS;
 using ::truncl _LIBCPP_USING_IF_EXISTS;
 
 #if _LIBCPP_STD_VER >= 17
-inline _LIBCPP_INLINE_VISIBILITY float       hypot(       float __x,       float __y,       float __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
-inline _LIBCPP_INLINE_VISIBILITY double      hypot(      double __x,      double __y,      double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
-inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double __x, long double __y, long double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
+inline _LIBCPP_HIDE_FROM_ABI float hypot(float __x, float __y, float __z) {
+  return sqrt(__x * __x + __y * __y + __z * __z);
+}
+inline _LIBCPP_HIDE_FROM_ABI double hypot(double __x, double __y, double __z) {
+  return sqrt(__x * __x + __y * __y + __z * __z);
+}
+inline _LIBCPP_HIDE_FROM_ABI long double hypot(long double __x, long double __y, long double __z) {
+  return sqrt(__x * __x + __y * __y + __z * __z);
+}
 
 template <class _A1, class _A2, class _A3>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if_t
-<
-    is_arithmetic<_A1>::value &&
-    is_arithmetic<_A2>::value &&
-    is_arithmetic<_A3>::value,
-    __promote<_A1, _A2, _A3>
->::type
-hypot(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
-{
-    typedef typename __promote<_A1, _A2, _A3>::type __result_type;
-    static_assert((!(is_same<_A1, __result_type>::value &&
-                     is_same<_A2, __result_type>::value &&
-                     is_same<_A3, __result_type>::value)), "");
-    return std::hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
+inline _LIBCPP_HIDE_FROM_ABI
+typename enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value && is_arithmetic<_A3>::value,
+                      __promote<_A1, _A2, _A3> >::type
+hypot(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT {
+  typedef typename __promote<_A1, _A2, _A3>::type __result_type;
+  static_assert(
+      !(is_same<_A1, __result_type>::value && is_same<_A2, __result_type>::value && is_same<_A3, __result_type>::value),
+      "");
+  return std::hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
 }
 #endif
 
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
-__constexpr_isnan(_A1 __lcpp_x) _NOEXCEPT
-{
+template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __constexpr_isnan(_A1 __lcpp_x) _NOEXCEPT {
 #if __has_builtin(__builtin_isnan)
-    return __builtin_isnan(__lcpp_x);
+  return __builtin_isnan(__lcpp_x);
 #else
-    return isnan(__lcpp_x);
+  return isnan(__lcpp_x);
 #endif
 }
 
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
-__constexpr_isnan(_A1 __lcpp_x) _NOEXCEPT
-{
-    return std::isnan(__lcpp_x);
+template <class _A1, __enable_if_t<!is_floating_point<_A1>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __constexpr_isnan(_A1 __lcpp_x) _NOEXCEPT {
+  return std::isnan(__lcpp_x);
 }
 
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
-__constexpr_isinf(_A1 __lcpp_x) _NOEXCEPT
-{
+template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __constexpr_isinf(_A1 __lcpp_x) _NOEXCEPT {
 #if __has_builtin(__builtin_isinf)
-    return __builtin_isinf(__lcpp_x);
+  return __builtin_isinf(__lcpp_x);
 #else
-    return isinf(__lcpp_x);
+  return isinf(__lcpp_x);
 #endif
 }
 
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
-__constexpr_isinf(_A1 __lcpp_x) _NOEXCEPT
-{
-    return std::isinf(__lcpp_x);
+template <class _A1, __enable_if_t<!is_floating_point<_A1>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __constexpr_isinf(_A1 __lcpp_x) _NOEXCEPT {
+  return std::isinf(__lcpp_x);
 }
 
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<is_floating_point<_A1>::value, bool>::type
-__constexpr_isfinite(_A1 __lcpp_x) _NOEXCEPT
-{
+template <class _A1, __enable_if_t<is_floating_point<_A1>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __constexpr_isfinite(_A1 __lcpp_x) _NOEXCEPT {
 #if __has_builtin(__builtin_isfinite)
-    return __builtin_isfinite(__lcpp_x);
+  return __builtin_isfinite(__lcpp_x);
 #else
-    return isfinite(__lcpp_x);
+  return isfinite(__lcpp_x);
 #endif
 }
 
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
-__constexpr_isfinite(_A1 __lcpp_x) _NOEXCEPT
-{
-    return __builtin_isfinite(__lcpp_x);
-}
-
-_LIBCPP_CONSTEXPR inline _LIBCPP_HIDE_FROM_ABI float __constexpr_copysign(float __x, float __y) _NOEXCEPT {
-    return __builtin_copysignf(__x, __y);
-}
-
-_LIBCPP_CONSTEXPR inline _LIBCPP_HIDE_FROM_ABI double __constexpr_copysign(double __x, double __y) _NOEXCEPT {
-    return __builtin_copysign(__x, __y);
-}
-
-_LIBCPP_CONSTEXPR inline _LIBCPP_HIDE_FROM_ABI long double
-__constexpr_copysign(long double __x, long double __y) _NOEXCEPT {
-    return __builtin_copysignl(__x, __y);
-}
-
-template <class _A1, class _A2>
-_LIBCPP_CONSTEXPR inline _LIBCPP_HIDE_FROM_ABI
-    typename std::__enable_if_t<std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value,
-                                std::__promote<_A1, _A2> >::type
-    __constexpr_copysign(_A1 __x, _A2 __y) _NOEXCEPT {
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), "");
-    return __builtin_copysign((__result_type)__x, (__result_type)__y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR float __constexpr_fabs(float __x) _NOEXCEPT {
-    return __builtin_fabsf(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double __constexpr_fabs(double __x) _NOEXCEPT {
-    return __builtin_fabs(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long double __constexpr_fabs(long double __x) _NOEXCEPT {
-    return __builtin_fabsl(__x);
-}
-
-template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double __constexpr_fabs(_Tp __x) _NOEXCEPT {
-    return __builtin_fabs(static_cast<double>(__x));
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 float __constexpr_fmax(float __x, float __y) _NOEXCEPT {
-#if !__has_constexpr_builtin(__builtin_fmaxf)
-  if (__libcpp_is_constant_evaluated()) {
-    if (std::__constexpr_isnan(__x))
-      return __y;
-    if (std::__constexpr_isnan(__y))
-      return __x;
-    return __x < __y ? __y : __x;
-  }
-#endif
-  return __builtin_fmaxf(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 double __constexpr_fmax(double __x, double __y) _NOEXCEPT {
-#if !__has_constexpr_builtin(__builtin_fmax)
-  if (__libcpp_is_constant_evaluated()) {
-    if (std::__constexpr_isnan(__x))
-      return __y;
-    if (std::__constexpr_isnan(__y))
-      return __x;
-    return __x < __y ? __y : __x;
-  }
-#endif
-  return __builtin_fmax(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 long double
-__constexpr_fmax(long double __x, long double __y) _NOEXCEPT {
-#if !__has_constexpr_builtin(__builtin_fmaxl)
-  if (__libcpp_is_constant_evaluated()) {
-    if (std::__constexpr_isnan(__x))
-      return __y;
-    if (std::__constexpr_isnan(__y))
-      return __x;
-    return __x < __y ? __y : __x;
-  }
-#endif
-  return __builtin_fmaxl(__x, __y);
-}
-
-template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename __promote<_Tp, _Up>::type
-__constexpr_fmax(_Tp __x, _Up __y) _NOEXCEPT {
-  using __result_type = typename __promote<_Tp, _Up>::type;
-  return std::__constexpr_fmax(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __constexpr_logb(_Tp __x) {
-#if !__has_constexpr_builtin(__builtin_logb)
-  if (__libcpp_is_constant_evaluated()) {
-    if (__x == _Tp(0)) {
-      // raise FE_DIVBYZERO
-      return -numeric_limits<_Tp>::infinity();
-    }
-
-    if (std::__constexpr_isinf(__x))
-      return numeric_limits<_Tp>::infinity();
-
-    if (std::__constexpr_isnan(__x))
-      return numeric_limits<_Tp>::quiet_NaN();
-
-    __x = std::__constexpr_fabs(__x);
-    unsigned long long __exp = 0;
-    while (__x >= numeric_limits<_Tp>::radix) {
-      __x /= numeric_limits<_Tp>::radix;
-      __exp += 1;
-    }
-    return _Tp(__exp);
-  }
-#endif // !__has_constexpr_builtin(__builtin_logb)
-  return __builtin_logb(__x);
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp __constexpr_scalbn(_Tp __x, int __exp) {
-#if !__has_constexpr_builtin(__builtin_scalbln)
-  if (__libcpp_is_constant_evaluated()) {
-    if (__x == _Tp(0))
-      return __x;
-
-    if (std::__constexpr_isinf(__x))
-      return __x;
-
-    if (__exp == _Tp(0))
-      return __x;
-
-    if (std::__constexpr_isnan(__x))
-      return numeric_limits<_Tp>::quiet_NaN();
-
-    _Tp __mult(1);
-    if (__exp > 0) {
-      __mult = numeric_limits<_Tp>::radix;
-      --__exp;
-    } else {
-      ++__exp;
-      __exp = -__exp;
-      __mult /= numeric_limits<_Tp>::radix;
-    }
-
-    while (__exp > 0) {
-      if (!(__exp & 1)) {
-        __mult *= __mult;
-        __exp >>= 1;
-      } else {
-        __x *= __mult;
-        --__exp;
-      }
-    }
-    return __x;
-  }
-#endif // !__has_constexpr_builtin(__builtin_scalbln)
-  return __builtin_scalbn(__x, __exp);
+template <class _A1, __enable_if_t<!is_floating_point<_A1>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __constexpr_isfinite(_A1 __lcpp_x) _NOEXCEPT {
+  return __builtin_isfinite(__lcpp_x);
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <typename _Fp>
-_LIBCPP_HIDE_FROM_ABI constexpr
-_Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept {
-    if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
-        return __t * __b + (1 - __t) * __a;
+_LIBCPP_HIDE_FROM_ABI constexpr _Fp __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept {
+  if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
+    return __t * __b + (1 - __t) * __a;
 
-    if (__t == 1) return __b;
-    const _Fp __x = __a + __t * (__b - __a);
-    if ((__t > 1) == (__b > __a))
-        return __b < __x ? __x : __b;
-    else
-        return __x < __b ? __x : __b;
+  if (__t == 1)
+    return __b;
+  const _Fp __x = __a + __t * (__b - __a);
+  if ((__t > 1) == (__b > __a))
+    return __b < __x ? __x : __b;
+  else
+    return __x < __b ? __x : __b;
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr float
-lerp(float __a, float __b, float __t)                   _NOEXCEPT { return __lerp(__a, __b, __t); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr float lerp(float __a, float __b, float __t) _NOEXCEPT {
+  return __lerp(__a, __b, __t);
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr double
-lerp(double __a, double __b, double __t)                _NOEXCEPT { return __lerp(__a, __b, __t); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr double lerp(double __a, double __b, double __t) _NOEXCEPT {
+  return __lerp(__a, __b, __t);
+}
 
-_LIBCPP_HIDE_FROM_ABI constexpr long double
-lerp(long double __a, long double __b, long double __t) _NOEXCEPT { return __lerp(__a, __b, __t); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr long double lerp(long double __a, long double __b, long double __t) _NOEXCEPT {
+  return __lerp(__a, __b, __t);
+}
 
 template <class _A1, class _A2, class _A3>
-inline _LIBCPP_HIDE_FROM_ABI
-constexpr typename enable_if_t
-<
-    is_arithmetic<_A1>::value &&
-    is_arithmetic<_A2>::value &&
-    is_arithmetic<_A3>::value,
-    __promote<_A1, _A2, _A3>
->::type
-lerp(_A1 __a, _A2 __b, _A3 __t) noexcept
-{
-    typedef typename __promote<_A1, _A2, _A3>::type __result_type;
-    static_assert(!(_IsSame<_A1, __result_type>::value &&
-                    _IsSame<_A2, __result_type>::value &&
-                    _IsSame<_A3, __result_type>::value));
-    return std::__lerp((__result_type)__a, (__result_type)__b, (__result_type)__t);
+inline _LIBCPP_HIDE_FROM_ABI constexpr
+    typename enable_if_t< is_arithmetic<_A1>::value && is_arithmetic<_A2>::value && is_arithmetic<_A3>::value,
+                          __promote<_A1, _A2, _A3> >::type
+    lerp(_A1 __a, _A2 __b, _A3 __t) noexcept {
+  typedef typename __promote<_A1, _A2, _A3>::type __result_type;
+  static_assert(!(
+      _IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value && _IsSame<_A3, __result_type>::value));
+  return std::__lerp((__result_type)__a, (__result_type)__b, (__result_type)__t);
 }
 #endif // _LIBCPP_STD_VER >= 20
 
diff --git a/third_party/libcxx/codecvt b/third_party/libcxx/codecvt
index ce378c8d1..65cd752d6 100644
--- a/third_party/libcxx/codecvt
+++ b/third_party/libcxx/codecvt
@@ -54,7 +54,6 @@ class codecvt_utf8_utf16
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__locale>
 #include <version>
@@ -63,496 +62,522 @@ class codecvt_utf8_utf16
 #  pragma GCC system_header
 #endif
 
+#if _LIBCPP_STD_VER < 26 || defined(_LIBCPP_BUILDING_LIBRARY) || defined(_LIBCPP_ENABLE_CXX26_REMOVED_CODECVT)
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-enum _LIBCPP_DEPRECATED_IN_CXX17 codecvt_mode
-{
-    consume_header = 4,
-    generate_header = 2,
-    little_endian = 1
-};
+enum _LIBCPP_DEPRECATED_IN_CXX17 codecvt_mode { consume_header = 4, generate_header = 2, little_endian = 1 };
 
 // codecvt_utf8
 
-template <class _Elem> class __codecvt_utf8;
+template <class _Elem>
+class __codecvt_utf8;
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf8<wchar_t>
-    : public codecvt<wchar_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    codecvt_mode __mode_;
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-public:
-    typedef wchar_t   intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf8<wchar_t> : public codecvt<wchar_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  codecvt_mode __mode_;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
+public:
+  typedef wchar_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<wchar_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<wchar_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
-    result do_out(state_type& __st,
-                  const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                  extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-    result do_in(state_type& __st,
-                 const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                 intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-    result do_unshift(state_type& __st,
-                      extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-    int do_encoding() const _NOEXCEPT override;
-    bool do_always_noconv() const _NOEXCEPT override;
-    int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-    int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf8<char16_t>
-    : public codecvt<char16_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-    codecvt_mode __mode_;
-public:
-    typedef char16_t  intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf8<char16_t> : public codecvt<char16_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  codecvt_mode __mode_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<char16_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+public:
+  typedef char16_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<char16_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf8<char32_t>
-    : public codecvt<char32_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-    codecvt_mode __mode_;
-public:
-    typedef char32_t  intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf8<char32_t> : public codecvt<char32_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  codecvt_mode __mode_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<char32_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+public:
+  typedef char32_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<char32_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-template <class _Elem, unsigned long _Maxcode = 0x10ffff,
-          codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf8
-    : public __codecvt_utf8<_Elem>
-{
+template <class _Elem, unsigned long _Maxcode = 0x10ffff, codecvt_mode _Mode = (codecvt_mode)0>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf8 : public __codecvt_utf8<_Elem> {
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt_utf8(size_t __refs = 0)
-        : __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt_utf8(size_t __refs = 0) : __codecvt_utf8<_Elem>(__refs, _Maxcode, _Mode) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~codecvt_utf8() {}
+  _LIBCPP_HIDE_FROM_ABI ~codecvt_utf8() {}
 };
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 // codecvt_utf16
 
-template <class _Elem, bool _LittleEndian> class __codecvt_utf16;
+template <class _Elem, bool _LittleEndian>
+class __codecvt_utf16;
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, false>
-    : public codecvt<wchar_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    codecvt_mode __mode_;
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-public:
-    typedef wchar_t   intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf16<wchar_t, false> : public codecvt<wchar_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  codecvt_mode __mode_;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
+public:
+  typedef wchar_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<wchar_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<wchar_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end,
-                          size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
 
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf16<wchar_t, true>
-    : public codecvt<wchar_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    codecvt_mode __mode_;
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-public:
-    typedef wchar_t   intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf16<wchar_t, true> : public codecvt<wchar_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  codecvt_mode __mode_;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
+public:
+  typedef wchar_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<wchar_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<wchar_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, false>
-    : public codecvt<char16_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-    codecvt_mode __mode_;
-public:
-    typedef char16_t  intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf16<char16_t, false> : public codecvt<char16_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  codecvt_mode __mode_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<char16_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+public:
+  typedef char16_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<char16_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, true>
-    : public codecvt<char16_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-    codecvt_mode __mode_;
-public:
-    typedef char16_t  intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf16<char16_t, true> : public codecvt<char16_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  codecvt_mode __mode_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<char16_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+public:
+  typedef char16_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<char16_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, false>
-    : public codecvt<char32_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-    codecvt_mode __mode_;
-public:
-    typedef char32_t  intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf16<char32_t, false> : public codecvt<char32_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  codecvt_mode __mode_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<char32_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+public:
+  typedef char32_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<char32_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, true>
-    : public codecvt<char32_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-    codecvt_mode __mode_;
-public:
-    typedef char32_t  intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf16<char32_t, true> : public codecvt<char32_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  codecvt_mode __mode_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<char32_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+public:
+  typedef char32_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<char32_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-template <class _Elem, unsigned long _Maxcode = 0x10ffff,
-          codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf16
-    : public __codecvt_utf16<_Elem, _Mode & little_endian>
-{
+template <class _Elem, unsigned long _Maxcode = 0x10ffff, codecvt_mode _Mode = (codecvt_mode)0>
+class _LIBCPP_TEMPLATE_VIS
+_LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf16 : public __codecvt_utf16<_Elem, _Mode & little_endian> {
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt_utf16(size_t __refs = 0)
-        : __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt_utf16(size_t __refs = 0)
+      : __codecvt_utf16<_Elem, _Mode & little_endian>(__refs, _Maxcode, _Mode) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~codecvt_utf16() {}
+  _LIBCPP_HIDE_FROM_ABI ~codecvt_utf16() {}
 };
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 // codecvt_utf8_utf16
 
-template <class _Elem> class __codecvt_utf8_utf16;
+template <class _Elem>
+class __codecvt_utf8_utf16;
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<wchar_t>
-    : public codecvt<wchar_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    codecvt_mode __mode_;
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-public:
-    typedef wchar_t   intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf8_utf16<wchar_t> : public codecvt<wchar_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  codecvt_mode __mode_;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
+public:
+  typedef wchar_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<wchar_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<wchar_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char32_t>
-    : public codecvt<char32_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-    codecvt_mode __mode_;
-public:
-    typedef char32_t  intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf8_utf16<char32_t> : public codecvt<char32_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  codecvt_mode __mode_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<char32_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+public:
+  typedef char32_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<char32_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
-class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char16_t>
-    : public codecvt<char16_t, char, mbstate_t>
-{
-    unsigned long __maxcode_;
-    codecvt_mode __mode_;
-public:
-    typedef char16_t  intern_type;
-    typedef char      extern_type;
-    typedef mbstate_t state_type;
+class _LIBCPP_EXPORTED_FROM_ABI __codecvt_utf8_utf16<char16_t> : public codecvt<char16_t, char, mbstate_t> {
+  unsigned long __maxcode_;
+  codecvt_mode __mode_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode,
-                            codecvt_mode __mode)
-        : codecvt<char16_t, char, mbstate_t>(__refs), __maxcode_(__maxcode),
-          __mode_(__mode) {}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+public:
+  typedef char16_t intern_type;
+  typedef char extern_type;
+  typedef mbstate_t state_type;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode, codecvt_mode __mode)
+      : codecvt<char16_t, char, mbstate_t>(__refs), __maxcode_(__maxcode), __mode_(__mode) {}
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 protected:
-     result do_out(state_type& __st,
-                   const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
-                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     result do_in(state_type& __st,
-                  const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
-                  intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const override;
-     result do_unshift(state_type& __st,
-                       extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
-     int do_encoding() const _NOEXCEPT override;
-     bool do_always_noconv() const _NOEXCEPT override;
-     int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
-     int do_max_length() const _NOEXCEPT override;
+  result do_out(state_type& __st,
+                const intern_type* __frm,
+                const intern_type* __frm_end,
+                const intern_type*& __frm_nxt,
+                extern_type* __to,
+                extern_type* __to_end,
+                extern_type*& __to_nxt) const override;
+  result do_in(state_type& __st,
+               const extern_type* __frm,
+               const extern_type* __frm_end,
+               const extern_type*& __frm_nxt,
+               intern_type* __to,
+               intern_type* __to_end,
+               intern_type*& __to_nxt) const override;
+  result do_unshift(state_type& __st, extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const override;
+  int do_encoding() const _NOEXCEPT override;
+  bool do_always_noconv() const _NOEXCEPT override;
+  int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const override;
+  int do_max_length() const _NOEXCEPT override;
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-template <class _Elem, unsigned long _Maxcode = 0x10ffff,
-          codecvt_mode _Mode = (codecvt_mode)0>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf8_utf16
-    : public __codecvt_utf8_utf16<_Elem>
-{
+template <class _Elem, unsigned long _Maxcode = 0x10ffff, codecvt_mode _Mode = (codecvt_mode)0>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 codecvt_utf8_utf16 : public __codecvt_utf8_utf16<_Elem> {
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit codecvt_utf8_utf16(size_t __refs = 0)
-        : __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {}
+  _LIBCPP_HIDE_FROM_ABI explicit codecvt_utf8_utf16(size_t __refs = 0)
+      : __codecvt_utf8_utf16<_Elem>(__refs, _Maxcode, _Mode) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~codecvt_utf8_utf16() {}
+  _LIBCPP_HIDE_FROM_ABI ~codecvt_utf8_utf16() {}
 };
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 _LIBCPP_END_NAMESPACE_STD
 
+#endif // _LIBCPP_STD_VER < 26 || defined(_LIBCPP_BUILDING_LIBRARY) || defined(_LIBCPP_ENABLE_CXX26_REMOVED_CODECVT)
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
@@ -562,6 +587,7 @@ _LIBCPP_END_NAMESPACE_STD
 #  include <initializer_list>
 #  include <iosfwd>
 #  include <limits>
+#  include <mutex>
 #  include <new>
 #  include <stdexcept>
 #  include <type_traits>
diff --git a/third_party/libcxx/compare b/third_party/libcxx/compare
index 626c7435f..8a41835b1 100644
--- a/third_party/libcxx/compare
+++ b/third_party/libcxx/compare
@@ -140,28 +140,38 @@ namespace std {
 }
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__compare/common_comparison_category.h>
-#include <__compare/compare_partial_order_fallback.h>
-#include <__compare/compare_strong_order_fallback.h>
-#include <__compare/compare_three_way.h>
-#include <__compare/compare_three_way_result.h>
-#include <__compare/compare_weak_order_fallback.h>
-#include <__compare/is_eq.h>
-#include <__compare/ordering.h>
-#include <__compare/partial_order.h>
-#include <__compare/strong_order.h>
-#include <__compare/synth_three_way.h>
-#include <__compare/three_way_comparable.h>
-#include <__compare/weak_order.h>
 #include <__config>
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__compare/common_comparison_category.h>
+#  include <__compare/compare_partial_order_fallback.h>
+#  include <__compare/compare_strong_order_fallback.h>
+#  include <__compare/compare_three_way.h>
+#  include <__compare/compare_three_way_result.h>
+#  include <__compare/compare_weak_order_fallback.h>
+#  include <__compare/is_eq.h>
+#  include <__compare/ordering.h>
+#  include <__compare/partial_order.h>
+#  include <__compare/strong_order.h>
+#  include <__compare/synth_three_way.h>
+#  include <__compare/three_way_comparable.h>
+#  include <__compare/weak_order.h>
+#endif // _LIBCPP_STD_VER >= 20
+
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <cstddef>
+#  include <cstdint>
+#  include <limits>
+#endif
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cmath>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/complex b/third_party/libcxx/complex
index 26f189d8b..22271acaf 100644
--- a/third_party/libcxx/complex
+++ b/third_party/libcxx/complex
@@ -148,12 +148,12 @@ template<class T> complex<T> operator/(const complex<T>&, const T&);          //
 template<class T> complex<T> operator/(const T&, const complex<T>&);          // constexpr in C++20
 template<class T> complex<T> operator+(const complex<T>&);                    // constexpr in C++20
 template<class T> complex<T> operator-(const complex<T>&);                    // constexpr in C++20
-template<class T> bool operator==(const complex<T>&, const complex<T>&); // constexpr in C++14
-template<class T> bool operator==(const complex<T>&, const T&); // constexpr in C++14
-template<class T> bool operator==(const T&, const complex<T>&); // constexpr in C++14
-template<class T> bool operator!=(const complex<T>&, const complex<T>&); // constexpr in C++14
-template<class T> bool operator!=(const complex<T>&, const T&); // constexpr in C++14
-template<class T> bool operator!=(const T&, const complex<T>&); // constexpr in C++14
+template<class T> bool operator==(const complex<T>&, const complex<T>&);      // constexpr in C++14
+template<class T> bool operator==(const complex<T>&, const T&);               // constexpr in C++14
+template<class T> bool operator==(const T&, const complex<T>&);               // constexpr in C++14, removed in C++20
+template<class T> bool operator!=(const complex<T>&, const complex<T>&);      // constexpr in C++14, removed in C++20
+template<class T> bool operator!=(const complex<T>&, const T&);               // constexpr in C++14, removed in C++20
+template<class T> bool operator!=(const T&, const complex<T>&);               // constexpr in C++14, removed in C++20
 
 template<class T, class charT, class traits>
   basic_istream<charT, traits>&
@@ -227,1344 +227,1250 @@ template<class T> complex<T> sqrt (const complex<T>&);
 template<class T> complex<T> tan (const complex<T>&);
 template<class T> complex<T> tanh (const complex<T>&);
 
+  // [complex.tuple], tuple interface
+  template<class T> struct tuple_size;                               // Since C++26
+  template<size_t I, class T> struct tuple_element;                  // Since C++26
+  template<class T> struct tuple_size<complex<T>>;                   // Since C++26
+  template<size_t I, class T> struct tuple_element<I, complex<T>>;   // Since C++26
+  template<size_t I, class T>
+    constexpr T& get(complex<T>&) noexcept;                          // Since C++26
+  template<size_t I, class T>
+    constexpr T&& get(complex<T>&&) noexcept;                        // Since C++26
+  template<size_t I, class T>
+    constexpr const T& get(const complex<T>&) noexcept;              // Since C++26
+  template<size_t I, class T>
+    constexpr const T&& get(const complex<T>&&) noexcept;            // Since C++26
+
+  // [complex.literals], complex literals
+  inline namespace literals {
+  inline namespace complex_literals {
+    constexpr complex<long double> operator""il(long double);        // Since C++14
+    constexpr complex<long double> operator""il(unsigned long long); // Since C++14
+    constexpr complex<double> operator""i(long double);              // Since C++14
+    constexpr complex<double> operator""i(unsigned long long);       // Since C++14
+    constexpr complex<float> operator""if(long double);              // Since C++14
+    constexpr complex<float> operator""if(unsigned long long);       // Since C++14
+  }
+  }
 }  // std
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
+#include <__fwd/complex.h>
+#include <__fwd/tuple.h>
+#include <__tuple/tuple_element.h>
+#include <__tuple/tuple_size.h>
+#include <__type_traits/conditional.h>
+#include <__utility/move.h>
 #include <cmath>
-#include <iosfwd>
-#include <stdexcept>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <sstream> // for std::basic_ostringstream
+#  include <sstream> // for std::basic_ostringstream
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp> class _LIBCPP_TEMPLATE_VIS complex;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS complex;
 
-template<class _Tp> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
-template<class _Tp> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
+template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
 
-template<class _Tp>
-class _LIBCPP_TEMPLATE_VIS complex
-{
+template <class _Tp, __enable_if_t<!is_floating_point<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator*(const complex<_Tp>& __z, const complex<_Tp>& __w);
+
+template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
+
+template <class _Tp, __enable_if_t<!is_floating_point<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator/(const complex<_Tp>& __x, const complex<_Tp>& __y);
+
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS complex {
 public:
-    typedef _Tp value_type;
+  typedef _Tp value_type;
+
 private:
-    value_type __re_;
-    value_type __im_;
+  value_type __re_;
+  value_type __im_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    complex(const value_type& __re = value_type(), const value_type& __im = value_type())
-        : __re_(__re), __im_(__im) {}
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    complex(const complex<_Xp>& __c)
-        : __re_(__c.real()), __im_(__c.imag()) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
+  complex(const value_type& __re = value_type(), const value_type& __im = value_type())
+      : __re_(__re), __im_(__im) {}
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 complex(const complex<_Xp>& __c)
+      : __re_(__c.real()), __im_(__c.imag()) {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type real() const {return __re_;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type imag() const {return __im_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type real() const { return __re_; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type imag() const { return __im_; }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const value_type& __re)
-        {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const value_type& __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const value_type& __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const value_type& __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const value_type& __re) {__re_ /= __re; __im_ /= __re; return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(const value_type& __re) {
+    __re_ = __re;
+    __im_ = value_type();
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const value_type& __re) {
+    __re_ += __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const value_type& __re) {
+    __re_ -= __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const value_type& __re) {
+    __re_ *= __re;
+    __im_ *= __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const value_type& __re) {
+    __re_ /= __re;
+    __im_ /= __re;
+    return *this;
+  }
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
-        {
-            __re_ = __c.real();
-            __im_ = __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
-        {
-            __re_ += __c.real();
-            __im_ += __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
-        {
-            __re_ -= __c.real();
-            __im_ -= __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
-        {
-            *this = *this * complex(__c.real(), __c.imag());
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
-        {
-            *this = *this / complex(__c.real(), __c.imag());
-            return *this;
-        }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(const complex<_Xp>& __c) {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c) {
+    __re_ += __c.real();
+    __im_ += __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c) {
+    __re_ -= __c.real();
+    __im_ -= __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c) {
+    *this = *this * complex(__c.real(), __c.imag());
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) {
+    *this = *this / complex(__c.real(), __c.imag());
+    return *this;
+  }
+
+#if _LIBCPP_STD_VER >= 26
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&&) noexcept;
+#endif
 };
 
-template<> class _LIBCPP_TEMPLATE_VIS complex<double>;
-template<> class _LIBCPP_TEMPLATE_VIS complex<long double>;
+template <>
+class _LIBCPP_TEMPLATE_VIS complex<double>;
+template <>
+class _LIBCPP_TEMPLATE_VIS complex<long double>;
+
+struct __from_builtin_tag {};
+
+template <class _Tp>
+using __complex_t =
+    __conditional_t<is_same<_Tp, float>::value,
+                    _Complex float,
+                    __conditional_t<is_same<_Tp, double>::value, _Complex double, _Complex long double> >;
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __complex_t<_Tp> __make_complex(_Tp __re, _Tp __im) {
+#if __has_builtin(__builtin_complex)
+  return __builtin_complex(__re, __im);
+#else
+  return __complex_t<_Tp>{__re, __im};
+#endif
+}
+
+template <>
+class _LIBCPP_TEMPLATE_VIS complex<float> {
+  float __re_;
+  float __im_;
 
-template<>
-class _LIBCPP_TEMPLATE_VIS complex<float>
-{
-    float __re_;
-    float __im_;
 public:
-    typedef float value_type;
+  typedef float value_type;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f)
-        : __re_(__re), __im_(__im) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
-    _LIBCPP_INLINE_VISIBILITY
-    explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(float __re = 0.0f, float __im = 0.0f) : __re_(__re), __im_(__im) {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float real() const {return __re_;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR float imag() const {return __im_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(__from_builtin_tag, _Complex float __v)
+      : __re_(__real__ __v), __im_(__imag__ __v) {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
+  _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
+  _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (float __re)
-        {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(float __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(float __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(float __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(float __re) {__re_ /= __re; __im_ /= __re; return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR float real() const { return __re_; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR float imag() const { return __im_; }
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
-        {
-            __re_ = __c.real();
-            __im_ = __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
-        {
-            __re_ += __c.real();
-            __im_ += __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
-        {
-            __re_ -= __c.real();
-            __im_ -= __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
-        {
-            *this = *this * complex(__c.real(), __c.imag());
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
-        {
-            *this = *this / complex(__c.real(), __c.imag());
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Complex float __builtin() const { return std::__make_complex(__re_, __im_); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __builtin(_Complex float __f) {
+    __re_ = __real__ __f;
+    __im_ = __imag__ __f;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(float __re) {
+    __re_ = __re;
+    __im_ = value_type();
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(float __re) {
+    __re_ += __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(float __re) {
+    __re_ -= __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(float __re) {
+    __re_ *= __re;
+    __im_ *= __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(float __re) {
+    __re_ /= __re;
+    __im_ /= __re;
+    return *this;
+  }
+
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(const complex<_Xp>& __c) {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c) {
+    __re_ += __c.real();
+    __im_ += __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c) {
+    __re_ -= __c.real();
+    __im_ -= __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c) {
+    *this = *this * complex(__c.real(), __c.imag());
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) {
+    *this = *this / complex(__c.real(), __c.imag());
+    return *this;
+  }
+
+#if _LIBCPP_STD_VER >= 26
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&&) noexcept;
+#endif
 };
 
-template<>
-class _LIBCPP_TEMPLATE_VIS complex<double>
-{
-    double __re_;
-    double __im_;
+template <>
+class _LIBCPP_TEMPLATE_VIS complex<double> {
+  double __re_;
+  double __im_;
+
 public:
-    typedef double value_type;
+  typedef double value_type;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0)
-        : __re_(__re), __im_(__im) {}
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
-    _LIBCPP_INLINE_VISIBILITY
-    explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(double __re = 0.0, double __im = 0.0) : __re_(__re), __im_(__im) {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double real() const {return __re_;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR double imag() const {return __im_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(__from_builtin_tag, _Complex double __v)
+      : __re_(__real__ __v), __im_(__imag__ __v) {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
+  _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (double __re)
-        {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(double __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(double __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(double __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(double __re) {__re_ /= __re; __im_ /= __re; return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double real() const { return __re_; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double imag() const { return __im_; }
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
-        {
-            __re_ = __c.real();
-            __im_ = __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
-        {
-            __re_ += __c.real();
-            __im_ += __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
-        {
-            __re_ -= __c.real();
-            __im_ -= __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
-        {
-            *this = *this * complex(__c.real(), __c.imag());
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
-        {
-            *this = *this / complex(__c.real(), __c.imag());
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Complex double __builtin() const {
+    return std::__make_complex(__re_, __im_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __builtin(_Complex double __f) {
+    __re_ = __real__ __f;
+    __im_ = __imag__ __f;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(double __re) {
+    __re_ = __re;
+    __im_ = value_type();
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(double __re) {
+    __re_ += __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(double __re) {
+    __re_ -= __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(double __re) {
+    __re_ *= __re;
+    __im_ *= __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(double __re) {
+    __re_ /= __re;
+    __im_ /= __re;
+    return *this;
+  }
+
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(const complex<_Xp>& __c) {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c) {
+    __re_ += __c.real();
+    __im_ += __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c) {
+    __re_ -= __c.real();
+    __im_ -= __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c) {
+    *this = *this * complex(__c.real(), __c.imag());
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) {
+    *this = *this / complex(__c.real(), __c.imag());
+    return *this;
+  }
+
+#if _LIBCPP_STD_VER >= 26
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&&) noexcept;
+#endif
 };
 
-template<>
-class _LIBCPP_TEMPLATE_VIS complex<long double>
-{
-    long double __re_;
-    long double __im_;
+template <>
+class _LIBCPP_TEMPLATE_VIS complex<long double> {
+  long double __re_;
+  long double __im_;
+
 public:
-    typedef long double value_type;
+  typedef long double value_type;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
-        : __re_(__re), __im_(__im) {}
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(long double __re = 0.0L, long double __im = 0.0L)
+      : __re_(__re), __im_(__im) {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double real() const {return __re_;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR long double imag() const {return __im_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(__from_builtin_tag, _Complex long double __v)
+      : __re_(__real__ __v), __im_(__imag__ __v) {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) {__re_ = __re;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) {__im_ = __im;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (long double __re)
-        {__re_ = __re; __im_ = value_type(); return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(long double __re) {__re_ += __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(long double __re) {__re_ -= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(long double __re) {__re_ *= __re; __im_ *= __re; return *this;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(long double __re) {__re_ /= __re; __im_ /= __re; return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long double real() const { return __re_; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long double imag() const { return __im_; }
 
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator= (const complex<_Xp>& __c)
-        {
-            __re_ = __c.real();
-            __im_ = __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c)
-        {
-            __re_ += __c.real();
-            __im_ += __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c)
-        {
-            __re_ -= __c.real();
-            __im_ -= __c.imag();
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c)
-        {
-            *this = *this * complex(__c.real(), __c.imag());
-            return *this;
-        }
-    template<class _Xp> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c)
-        {
-            *this = *this / complex(__c.real(), __c.imag());
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Complex long double __builtin() const {
+    return std::__make_complex(__re_, __im_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __builtin(_Complex long double __f) {
+    __re_ = __real__ __f;
+    __im_ = __imag__ __f;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(long double __re) {
+    __re_ = __re;
+    __im_ = value_type();
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(long double __re) {
+    __re_ += __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(long double __re) {
+    __re_ -= __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(long double __re) {
+    __re_ *= __re;
+    __im_ *= __re;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(long double __re) {
+    __re_ /= __re;
+    __im_ /= __re;
+    return *this;
+  }
+
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator=(const complex<_Xp>& __c) {
+    __re_ = __c.real();
+    __im_ = __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator+=(const complex<_Xp>& __c) {
+    __re_ += __c.real();
+    __im_ += __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator-=(const complex<_Xp>& __c) {
+    __re_ -= __c.real();
+    __im_ -= __c.imag();
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator*=(const complex<_Xp>& __c) {
+    *this = *this * complex(__c.real(), __c.imag());
+    return *this;
+  }
+  template <class _Xp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex& operator/=(const complex<_Xp>& __c) {
+    *this = *this / complex(__c.real(), __c.imag());
+    return *this;
+  }
+
+#if _LIBCPP_STD_VER >= 26
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>&) noexcept;
+
+  template <size_t _Ip, class _Xp>
+  friend _LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&&) noexcept;
+#endif
 };
 
-inline
-_LIBCPP_CONSTEXPR
-complex<float>::complex(const complex<double>& __c)
+inline _LIBCPP_CONSTEXPR complex<float>::complex(const complex<double>& __c) : __re_(__c.real()), __im_(__c.imag()) {}
+
+inline _LIBCPP_CONSTEXPR complex<float>::complex(const complex<long double>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
-inline
-_LIBCPP_CONSTEXPR
-complex<float>::complex(const complex<long double>& __c)
+inline _LIBCPP_CONSTEXPR complex<double>::complex(const complex<float>& __c) : __re_(__c.real()), __im_(__c.imag()) {}
+
+inline _LIBCPP_CONSTEXPR complex<double>::complex(const complex<long double>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
-inline
-_LIBCPP_CONSTEXPR
-complex<double>::complex(const complex<float>& __c)
+inline _LIBCPP_CONSTEXPR complex<long double>::complex(const complex<float>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
-inline
-_LIBCPP_CONSTEXPR
-complex<double>::complex(const complex<long double>& __c)
-    : __re_(__c.real()), __im_(__c.imag()) {}
-
-inline
-_LIBCPP_CONSTEXPR
-complex<long double>::complex(const complex<float>& __c)
-    : __re_(__c.real()), __im_(__c.imag()) {}
-
-inline
-_LIBCPP_CONSTEXPR
-complex<long double>::complex(const complex<double>& __c)
+inline _LIBCPP_CONSTEXPR complex<long double>::complex(const complex<double>& __c)
     : __re_(__c.real()), __im_(__c.imag()) {}
 
 // 26.3.6 operators:
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
-{
-    complex<_Tp> __t(__x);
-    __t += __y;
-    return __t;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) {
+  complex<_Tp> __t(__x);
+  __t += __y;
+  return __t;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator+(const complex<_Tp>& __x, const _Tp& __y)
-{
-    complex<_Tp> __t(__x);
-    __t += __y;
-    return __t;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator+(const complex<_Tp>& __x, const _Tp& __y) {
+  complex<_Tp> __t(__x);
+  __t += __y;
+  return __t;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator+(const _Tp& __x, const complex<_Tp>& __y)
-{
-    complex<_Tp> __t(__y);
-    __t += __x;
-    return __t;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator+(const _Tp& __x, const complex<_Tp>& __y) {
+  complex<_Tp> __t(__y);
+  __t += __x;
+  return __t;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
-{
-    complex<_Tp> __t(__x);
-    __t -= __y;
-    return __t;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) {
+  complex<_Tp> __t(__x);
+  __t -= __y;
+  return __t;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator-(const complex<_Tp>& __x, const _Tp& __y)
-{
-    complex<_Tp> __t(__x);
-    __t -= __y;
-    return __t;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator-(const complex<_Tp>& __x, const _Tp& __y) {
+  complex<_Tp> __t(__x);
+  __t -= __y;
+  return __t;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator-(const _Tp& __x, const complex<_Tp>& __y)
-{
-    complex<_Tp> __t(-__y);
-    __t += __x;
-    return __t;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator-(const _Tp& __x, const complex<_Tp>& __y) {
+  complex<_Tp> __t(-__y);
+  __t += __x;
+  return __t;
 }
 
-template<class _Tp>
+template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> >
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
-operator*(const complex<_Tp>& __z, const complex<_Tp>& __w)
-{
-    _Tp __a = __z.real();
-    _Tp __b = __z.imag();
-    _Tp __c = __w.real();
-    _Tp __d = __w.imag();
-
-    // Avoid floating point operations that are invalid during constant evaluation
-    if (__libcpp_is_constant_evaluated()) {
-        bool __z_zero = __a == _Tp(0) && __b == _Tp(0);
-        bool __w_zero = __c == _Tp(0) && __d == _Tp(0);
-        bool __z_inf = std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b);
-        bool __w_inf = std::__constexpr_isinf(__c) || std::__constexpr_isinf(__d);
-        bool __z_nan = !__z_inf && (
-            (std::__constexpr_isnan(__a) && std::__constexpr_isnan(__b))
-            || (std::__constexpr_isnan(__a) && __b == _Tp(0))
-            || (__a == _Tp(0) && std::__constexpr_isnan(__b))
-        );
-        bool __w_nan = !__w_inf && (
-            (std::__constexpr_isnan(__c) && std::__constexpr_isnan(__d))
-            || (std::__constexpr_isnan(__c) && __d == _Tp(0))
-            || (__c == _Tp(0) && std::__constexpr_isnan(__d))
-        );
-        if (__z_nan || __w_nan) {
-            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
-        }
-        if (__z_inf || __w_inf) {
-            if (__z_zero || __w_zero) {
-                return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
-            }
-            return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
-        }
-        bool __z_nonzero_nan = !__z_inf && !__z_nan && (std::__constexpr_isnan(__a) || std::__constexpr_isnan(__b));
-        bool __w_nonzero_nan = !__w_inf && !__w_nan && (std::__constexpr_isnan(__c) || std::__constexpr_isnan(__d));
-        if (__z_nonzero_nan || __w_nonzero_nan) {
-            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
-        }
-    }
-
-    _Tp __ac = __a * __c;
-    _Tp __bd = __b * __d;
-    _Tp __ad = __a * __d;
-    _Tp __bc = __b * __c;
-    _Tp __x = __ac - __bd;
-    _Tp __y = __ad + __bc;
-    if (std::__constexpr_isnan(__x) && std::__constexpr_isnan(__y))
-    {
-        bool __recalc = false;
-        if (std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b))
-        {
-            __a = std::__constexpr_copysign(std::__constexpr_isinf(__a) ? _Tp(1) : _Tp(0), __a);
-            __b = std::__constexpr_copysign(std::__constexpr_isinf(__b) ? _Tp(1) : _Tp(0), __b);
-            if (std::__constexpr_isnan(__c))
-                __c = std::__constexpr_copysign(_Tp(0), __c);
-            if (std::__constexpr_isnan(__d))
-                __d = std::__constexpr_copysign(_Tp(0), __d);
-            __recalc = true;
-        }
-        if (std::__constexpr_isinf(__c) || std::__constexpr_isinf(__d))
-        {
-            __c = std::__constexpr_copysign(std::__constexpr_isinf(__c) ? _Tp(1) : _Tp(0), __c);
-            __d = std::__constexpr_copysign(std::__constexpr_isinf(__d) ? _Tp(1) : _Tp(0), __d);
-            if (std::__constexpr_isnan(__a))
-                __a = std::__constexpr_copysign(_Tp(0), __a);
-            if (std::__constexpr_isnan(__b))
-                __b = std::__constexpr_copysign(_Tp(0), __b);
-            __recalc = true;
-        }
-        if (!__recalc && (std::__constexpr_isinf(__ac) || std::__constexpr_isinf(__bd) ||
-                          std::__constexpr_isinf(__ad) || std::__constexpr_isinf(__bc)))
-        {
-            if (std::__constexpr_isnan(__a))
-                __a = std::__constexpr_copysign(_Tp(0), __a);
-            if (std::__constexpr_isnan(__b))
-                __b = std::__constexpr_copysign(_Tp(0), __b);
-            if (std::__constexpr_isnan(__c))
-                __c = std::__constexpr_copysign(_Tp(0), __c);
-            if (std::__constexpr_isnan(__d))
-                __d = std::__constexpr_copysign(_Tp(0), __d);
-            __recalc = true;
-        }
-        if (__recalc)
-        {
-            __x = _Tp(INFINITY) * (__a * __c - __b * __d);
-            __y = _Tp(INFINITY) * (__a * __d + __b * __c);
-        }
-    }
-    return complex<_Tp>(__x, __y);
+operator*(const complex<_Tp>& __lhs, const complex<_Tp>& __rhs) {
+  return complex<_Tp>(__from_builtin_tag(), __lhs.__builtin() * __rhs.__builtin());
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator*(const complex<_Tp>& __x, const _Tp& __y)
-{
-    complex<_Tp> __t(__x);
-    __t *= __y;
-    return __t;
-}
-
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator*(const _Tp& __x, const complex<_Tp>& __y)
-{
-    complex<_Tp> __t(__y);
-    __t *= __x;
-    return __t;
-}
-
-template<class _Tp>
+template <class _Tp, __enable_if_t<!is_floating_point<_Tp>::value, int> >
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
-operator/(const complex<_Tp>& __z, const complex<_Tp>& __w)
-{
-    int __ilogbw = 0;
-    _Tp __a = __z.real();
-    _Tp __b = __z.imag();
-    _Tp __c = __w.real();
-    _Tp __d = __w.imag();
-    _Tp __logbw = std::__constexpr_logb(std::__constexpr_fmax(std::__constexpr_fabs(__c), std::__constexpr_fabs(__d)));
-    if (std::__constexpr_isfinite(__logbw))
-    {
-        __ilogbw = static_cast<int>(__logbw);
-        __c = std::__constexpr_scalbn(__c, -__ilogbw);
-        __d = std::__constexpr_scalbn(__d, -__ilogbw);
-    }
+operator*(const complex<_Tp>& __z, const complex<_Tp>& __w) {
+  _Tp __a = __z.real();
+  _Tp __b = __z.imag();
+  _Tp __c = __w.real();
+  _Tp __d = __w.imag();
 
-    // Avoid floating point operations that are invalid during constant evaluation
-    if (__libcpp_is_constant_evaluated()) {
-        bool __z_zero = __a == _Tp(0) && __b == _Tp(0);
-        bool __w_zero = __c == _Tp(0) && __d == _Tp(0);
-        bool __z_inf = std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b);
-        bool __w_inf = std::__constexpr_isinf(__c) || std::__constexpr_isinf(__d);
-        bool __z_nan = !__z_inf && (
-            (std::__constexpr_isnan(__a) && std::__constexpr_isnan(__b))
-            || (std::__constexpr_isnan(__a) && __b == _Tp(0))
-            || (__a == _Tp(0) && std::__constexpr_isnan(__b))
-        );
-        bool __w_nan = !__w_inf && (
-            (std::__constexpr_isnan(__c) && std::__constexpr_isnan(__d))
-            || (std::__constexpr_isnan(__c) && __d == _Tp(0))
-            || (__c == _Tp(0) && std::__constexpr_isnan(__d))
-        );
-        if ((__z_nan || __w_nan) || (__z_inf && __w_inf)) {
-            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
-        }
-        bool __z_nonzero_nan = !__z_inf && !__z_nan && (std::__constexpr_isnan(__a) || std::__constexpr_isnan(__b));
-        bool __w_nonzero_nan = !__w_inf && !__w_nan && (std::__constexpr_isnan(__c) || std::__constexpr_isnan(__d));
-        if (__z_nonzero_nan || __w_nonzero_nan) {
-            if (__w_zero) {
-                return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
-            }
-            return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
-        }
-        if (__w_inf) {
-            return complex<_Tp>(_Tp(0), _Tp(0));
-        }
-        if (__z_inf) {
-            return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
-        }
-        if (__w_zero) {
-            if (__z_zero) {
-                return complex<_Tp>(_Tp(numeric_limits<_Tp>::quiet_NaN()), _Tp(0));
-            }
-            return complex<_Tp>(_Tp(numeric_limits<_Tp>::infinity()), _Tp(numeric_limits<_Tp>::infinity()));
-        }
-    }
-
-    _Tp __denom = __c * __c + __d * __d;
-    _Tp __x = std::__constexpr_scalbn((__a * __c + __b * __d) / __denom, -__ilogbw);
-    _Tp __y = std::__constexpr_scalbn((__b * __c - __a * __d) / __denom, -__ilogbw);
-    if (std::__constexpr_isnan(__x) && std::__constexpr_isnan(__y))
-    {
-        if ((__denom == _Tp(0)) && (!std::__constexpr_isnan(__a) || !std::__constexpr_isnan(__b)))
-        {
-            __x = std::__constexpr_copysign(_Tp(INFINITY), __c) * __a;
-            __y = std::__constexpr_copysign(_Tp(INFINITY), __c) * __b;
-        } else if ((std::__constexpr_isinf(__a) || std::__constexpr_isinf(__b)) && std::__constexpr_isfinite(__c) &&
-                   std::__constexpr_isfinite(__d)) {
-            __a = std::__constexpr_copysign(std::__constexpr_isinf(__a) ? _Tp(1) : _Tp(0), __a);
-            __b = std::__constexpr_copysign(std::__constexpr_isinf(__b) ? _Tp(1) : _Tp(0), __b);
-            __x = _Tp(INFINITY) * (__a * __c + __b * __d);
-            __y = _Tp(INFINITY) * (__b * __c - __a * __d);
-        } else if (std::__constexpr_isinf(__logbw) && __logbw > _Tp(0) && std::__constexpr_isfinite(__a) &&
-                   std::__constexpr_isfinite(__b)) {
-            __c = std::__constexpr_copysign(std::__constexpr_isinf(__c) ? _Tp(1) : _Tp(0), __c);
-            __d = std::__constexpr_copysign(std::__constexpr_isinf(__d) ? _Tp(1) : _Tp(0), __d);
-            __x = _Tp(0) * (__a * __c + __b * __d);
-            __y = _Tp(0) * (__b * __c - __a * __d);
-        }
-    }
-    return complex<_Tp>(__x, __y);
+  return complex<_Tp>((__a * __c) - (__b * __d), (__a * __d) + (__b * __c));
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator/(const complex<_Tp>& __x, const _Tp& __y)
-{
-    return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator*(const complex<_Tp>& __x, const _Tp& __y) {
+  complex<_Tp> __t(__x);
+  __t *= __y;
+  return __t;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator/(const _Tp& __x, const complex<_Tp>& __y)
-{
-    complex<_Tp> __t(__x);
-    __t /= __y;
-    return __t;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator*(const _Tp& __x, const complex<_Tp>& __y) {
+  complex<_Tp> __t(__y);
+  __t *= __x;
+  return __t;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator+(const complex<_Tp>& __x)
-{
-    return __x;
+template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> >
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator/(const complex<_Tp>& __lhs, const complex<_Tp>& __rhs) {
+  return complex<_Tp>(__from_builtin_tag(), __lhs.__builtin() / __rhs.__builtin());
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-operator-(const complex<_Tp>& __x)
-{
-    return complex<_Tp>(-__x.real(), -__x.imag());
+template <class _Tp, __enable_if_t<!is_floating_point<_Tp>::value, int> >
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator/(const complex<_Tp>& __z, const complex<_Tp>& __w) {
+  _Tp __a = __z.real();
+  _Tp __b = __z.imag();
+  _Tp __c = __w.real();
+  _Tp __d = __w.imag();
+
+  _Tp __denom = __c * __c + __d * __d;
+  return complex<_Tp>((__a * __c + __b * __d) / __denom, (__b * __c - __a * __d) / __denom);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
-{
-    return __x.real() == __y.real() && __x.imag() == __y.imag();
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator/(const complex<_Tp>& __x, const _Tp& __y) {
+  return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator==(const complex<_Tp>& __x, const _Tp& __y)
-{
-    return __x.real() == __y && __x.imag() == 0;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator/(const _Tp& __x, const complex<_Tp>& __y) {
+  complex<_Tp> __t(__x);
+  __t /= __y;
+  return __t;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator==(const _Tp& __x, const complex<_Tp>& __y)
-{
-    return __x == __y.real() && 0 == __y.imag();
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator+(const complex<_Tp>& __x) {
+  return __x;
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
-{
-    return !(__x == __y);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator-(const complex<_Tp>& __x) {
+  return complex<_Tp>(-__x.real(), -__x.imag());
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator!=(const complex<_Tp>& __x, const _Tp& __y)
-{
-    return !(__x == __y);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator==(const complex<_Tp>& __x, const complex<_Tp>& __y) {
+  return __x.real() == __y.real() && __x.imag() == __y.imag();
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator!=(const _Tp& __x, const complex<_Tp>& __y)
-{
-    return !(__x == __y);
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator==(const complex<_Tp>& __x, const _Tp& __y) {
+  return __x.real() == __y && __x.imag() == 0;
 }
 
+#if _LIBCPP_STD_VER <= 17
+
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator==(const _Tp& __x, const complex<_Tp>& __y) {
+  return __x == __y.real() && 0 == __y.imag();
+}
+
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y) {
+  return !(__x == __y);
+}
+
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator!=(const complex<_Tp>& __x, const _Tp& __y) {
+  return !(__x == __y);
+}
+
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator!=(const _Tp& __x, const complex<_Tp>& __y) {
+  return !(__x == __y);
+}
+
+#endif
+
 // 26.3.7 values:
 
-template <class _Tp, bool = is_integral<_Tp>::value,
-                     bool = is_floating_point<_Tp>::value
-                     >
+template <class _Tp, bool = is_integral<_Tp>::value, bool = is_floating_point<_Tp>::value >
 struct __libcpp_complex_overload_traits {};
 
 // Integral Types
 template <class _Tp>
-struct __libcpp_complex_overload_traits<_Tp, true, false>
-{
-    typedef double _ValueType;
-    typedef complex<double> _ComplexType;
+struct __libcpp_complex_overload_traits<_Tp, true, false> {
+  typedef double _ValueType;
+  typedef complex<double> _ComplexType;
 };
 
 // Floating point types
 template <class _Tp>
-struct __libcpp_complex_overload_traits<_Tp, false, true>
-{
-    typedef _Tp _ValueType;
-    typedef complex<_Tp> _ComplexType;
+struct __libcpp_complex_overload_traits<_Tp, false, true> {
+  typedef _Tp _ValueType;
+  typedef complex<_Tp> _ComplexType;
 };
 
 // real
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp
-real(const complex<_Tp>& __c)
-{
-    return __c.real();
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp real(const complex<_Tp>& __c) {
+  return __c.real();
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename __libcpp_complex_overload_traits<_Tp>::_ValueType
-real(_Tp __re)
-{
-    return __re;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
+real(_Tp __re) {
+  return __re;
 }
 
 // imag
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-_Tp
-imag(const complex<_Tp>& __c)
-{
-    return __c.imag();
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp imag(const complex<_Tp>& __c) {
+  return __c.imag();
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename __libcpp_complex_overload_traits<_Tp>::_ValueType
-imag(_Tp)
-{
-    return 0;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
+imag(_Tp) {
+  return 0;
 }
 
 // abs
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp
-abs(const complex<_Tp>& __c)
-{
-    return std::hypot(__c.real(), __c.imag());
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _Tp abs(const complex<_Tp>& __c) {
+  return std::hypot(__c.real(), __c.imag());
 }
 
 // arg
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp
-arg(const complex<_Tp>& __c)
-{
-    return std::atan2(__c.imag(), __c.real());
-}
-
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<
-    is_same<_Tp, long double>::value,
-    long double
->::type
-arg(_Tp __re)
-{
-    return std::atan2l(0.L, __re);
+inline _LIBCPP_HIDE_FROM_ABI _Tp arg(const complex<_Tp>& __c) {
+  return std::atan2(__c.imag(), __c.real());
 }
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_integral<_Tp>::value || is_same<_Tp, double>::value,
-    double
->::type
-arg(_Tp __re)
-{
-    return std::atan2(0., __re);
+template <class _Tp, __enable_if_t<is_same<_Tp, long double>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI long double arg(_Tp __re) {
+  return std::atan2l(0.L, __re);
 }
 
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<
-    is_same<_Tp, float>::value,
-    float
->::type
-arg(_Tp __re)
-{
-    return std::atan2f(0.F, __re);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value || is_same<_Tp, double>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double arg(_Tp __re) {
+  return std::atan2(0., __re);
+}
+
+template <class _Tp, __enable_if_t<is_same<_Tp, float>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI float arg(_Tp __re) {
+  return std::atan2f(0.F, __re);
 }
 
 // norm
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-_Tp
-norm(const complex<_Tp>& __c)
-{
-    if (std::__constexpr_isinf(__c.real()))
-        return std::abs(__c.real());
-    if (std::__constexpr_isinf(__c.imag()))
-        return std::abs(__c.imag());
-    return __c.real() * __c.real() + __c.imag() * __c.imag();
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp norm(const complex<_Tp>& __c) {
+  if (std::__constexpr_isinf(__c.real()))
+    return std::abs(__c.real());
+  if (std::__constexpr_isinf(__c.imag()))
+    return std::abs(__c.imag());
+  return __c.real() * __c.real() + __c.imag() * __c.imag();
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename __libcpp_complex_overload_traits<_Tp>::_ValueType
-norm(_Tp __re)
-{
-    typedef typename __libcpp_complex_overload_traits<_Tp>::_ValueType _ValueType;
-    return static_cast<_ValueType>(__re) * __re;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
+norm(_Tp __re) {
+  typedef typename __libcpp_complex_overload_traits<_Tp>::_ValueType _ValueType;
+  return static_cast<_ValueType>(__re) * __re;
 }
 
 // conj
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-complex<_Tp>
-conj(const complex<_Tp>& __c)
-{
-    return complex<_Tp>(__c.real(), -__c.imag());
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> conj(const complex<_Tp>& __c) {
+  return complex<_Tp>(__c.real(), -__c.imag());
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
-conj(_Tp __re)
-{
-    typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
-    return _ComplexType(__re);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
+conj(_Tp __re) {
+  typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
+  return _ComplexType(__re);
 }
 
-
-
 // proj
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-complex<_Tp>
-proj(const complex<_Tp>& __c)
-{
-    complex<_Tp> __r = __c;
-    if (std::__constexpr_isinf(__c.real()) || std::__constexpr_isinf(__c.imag()))
-        __r = complex<_Tp>(INFINITY, std::copysign(_Tp(0), __c.imag()));
-    return __r;
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> proj(const complex<_Tp>& __c) {
+  complex<_Tp> __r = __c;
+  if (std::__constexpr_isinf(__c.real()) || std::__constexpr_isinf(__c.imag()))
+    __r = complex<_Tp>(INFINITY, std::copysign(_Tp(0), __c.imag()));
+  return __r;
 }
 
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_floating_point<_Tp>::value,
-    typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
->::type
-proj(_Tp __re)
-{
-    if (std::__constexpr_isinf(__re))
-        __re = std::abs(__re);
-    return complex<_Tp>(__re);
+template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __libcpp_complex_overload_traits<_Tp>::_ComplexType proj(_Tp __re) {
+  if (std::__constexpr_isinf(__re))
+    __re = std::abs(__re);
+  return complex<_Tp>(__re);
 }
 
-template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_integral<_Tp>::value,
-    typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
->::type
-proj(_Tp __re)
-{
-    typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
-    return _ComplexType(__re);
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI typename __libcpp_complex_overload_traits<_Tp>::_ComplexType proj(_Tp __re) {
+  typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
+  return _ComplexType(__re);
 }
 
 // polar
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-polar(const _Tp& __rho, const _Tp& __theta = _Tp())
-{
-    if (std::__constexpr_isnan(__rho) || std::signbit(__rho))
-        return complex<_Tp>(_Tp(NAN), _Tp(NAN));
-    if (std::__constexpr_isnan(__theta))
-    {
-        if (std::__constexpr_isinf(__rho))
-            return complex<_Tp>(__rho, __theta);
-        return complex<_Tp>(__theta, __theta);
-    }
-    if (std::__constexpr_isinf(__theta))
-    {
-        if (std::__constexpr_isinf(__rho))
-            return complex<_Tp>(__rho, _Tp(NAN));
-        return complex<_Tp>(_Tp(NAN), _Tp(NAN));
-    }
-    _Tp __x = __rho * std::cos(__theta);
-    if (std::__constexpr_isnan(__x))
-        __x = 0;
-    _Tp __y = __rho * std::sin(__theta);
-    if (std::__constexpr_isnan(__y))
-        __y = 0;
-    return complex<_Tp>(__x, __y);
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> polar(const _Tp& __rho, const _Tp& __theta = _Tp()) {
+  if (std::__constexpr_isnan(__rho) || std::signbit(__rho))
+    return complex<_Tp>(_Tp(NAN), _Tp(NAN));
+  if (std::__constexpr_isnan(__theta)) {
+    if (std::__constexpr_isinf(__rho))
+      return complex<_Tp>(__rho, __theta);
+    return complex<_Tp>(__theta, __theta);
+  }
+  if (std::__constexpr_isinf(__theta)) {
+    if (std::__constexpr_isinf(__rho))
+      return complex<_Tp>(__rho, _Tp(NAN));
+    return complex<_Tp>(_Tp(NAN), _Tp(NAN));
+  }
+  _Tp __x = __rho * std::cos(__theta);
+  if (std::__constexpr_isnan(__x))
+    __x = 0;
+  _Tp __y = __rho * std::sin(__theta);
+  if (std::__constexpr_isnan(__y))
+    __y = 0;
+  return complex<_Tp>(__x, __y);
 }
 
 // log
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-complex<_Tp>
-log(const complex<_Tp>& __x)
-{
-    return complex<_Tp>(std::log(std::abs(__x)), std::arg(__x));
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> log(const complex<_Tp>& __x) {
+  return complex<_Tp>(std::log(std::abs(__x)), std::arg(__x));
 }
 
 // log10
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-complex<_Tp>
-log10(const complex<_Tp>& __x)
-{
-    return std::log(__x) / std::log(_Tp(10));
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> log10(const complex<_Tp>& __x) {
+  return std::log(__x) / std::log(_Tp(10));
 }
 
 // sqrt
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-sqrt(const complex<_Tp>& __x)
-{
-    if (std::__constexpr_isinf(__x.imag()))
-        return complex<_Tp>(_Tp(INFINITY), __x.imag());
-    if (std::__constexpr_isinf(__x.real()))
-    {
-        if (__x.real() > _Tp(0))
-            return complex<_Tp>(__x.real(), std::__constexpr_isnan(__x.imag()) ? __x.imag() : std::copysign(_Tp(0), __x.imag()));
-        return complex<_Tp>(std::__constexpr_isnan(__x.imag()) ? __x.imag() : _Tp(0), std::copysign(__x.real(), __x.imag()));
-    }
-    return std::polar(std::sqrt(std::abs(__x)), std::arg(__x) / _Tp(2));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> sqrt(const complex<_Tp>& __x) {
+  if (std::__constexpr_isinf(__x.imag()))
+    return complex<_Tp>(_Tp(INFINITY), __x.imag());
+  if (std::__constexpr_isinf(__x.real())) {
+    if (__x.real() > _Tp(0))
+      return complex<_Tp>(
+          __x.real(), std::__constexpr_isnan(__x.imag()) ? __x.imag() : std::copysign(_Tp(0), __x.imag()));
+    return complex<_Tp>(
+        std::__constexpr_isnan(__x.imag()) ? __x.imag() : _Tp(0), std::copysign(__x.real(), __x.imag()));
+  }
+  return std::polar(std::sqrt(std::abs(__x)), std::arg(__x) / _Tp(2));
 }
 
 // exp
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-exp(const complex<_Tp>& __x)
-{
-    _Tp __i = __x.imag();
-    if (__i == 0) {
-        return complex<_Tp>(std::exp(__x.real()), std::copysign(_Tp(0), __x.imag()));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> exp(const complex<_Tp>& __x) {
+  _Tp __i = __x.imag();
+  if (__i == 0) {
+    return complex<_Tp>(std::exp(__x.real()), std::copysign(_Tp(0), __x.imag()));
+  }
+  if (std::__constexpr_isinf(__x.real())) {
+    if (__x.real() < _Tp(0)) {
+      if (!std::__constexpr_isfinite(__i))
+        __i = _Tp(1);
+    } else if (__i == 0 || !std::__constexpr_isfinite(__i)) {
+      if (std::__constexpr_isinf(__i))
+        __i = _Tp(NAN);
+      return complex<_Tp>(__x.real(), __i);
     }
-    if (std::__constexpr_isinf(__x.real()))
-    {
-        if (__x.real() < _Tp(0))
-        {
-            if (!std::__constexpr_isfinite(__i))
-                __i = _Tp(1);
-        }
-        else if (__i == 0 || !std::__constexpr_isfinite(__i))
-        {
-            if (std::__constexpr_isinf(__i))
-                __i = _Tp(NAN);
-            return complex<_Tp>(__x.real(), __i);
-        }
-    }
-    _Tp __e = std::exp(__x.real());
-    return complex<_Tp>(__e * std::cos(__i), __e * std::sin(__i));
+  }
+  _Tp __e = std::exp(__x.real());
+  return complex<_Tp>(__e * std::cos(__i), __e * std::sin(__i));
 }
 
 // pow
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-complex<_Tp>
-pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
-{
-    return std::exp(__y * std::log(__x));
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> pow(const complex<_Tp>& __x, const complex<_Tp>& __y) {
+  return std::exp(__y * std::log(__x));
 }
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-complex<typename __promote<_Tp, _Up>::type>
-pow(const complex<_Tp>& __x, const complex<_Up>& __y)
-{
-    typedef complex<typename __promote<_Tp, _Up>::type> result_type;
-    return _VSTD::pow(result_type(__x), result_type(__y));
+template <class _Tp, class _Up>
+inline _LIBCPP_HIDE_FROM_ABI complex<typename __promote<_Tp, _Up>::type>
+pow(const complex<_Tp>& __x, const complex<_Up>& __y) {
+  typedef complex<typename __promote<_Tp, _Up>::type> result_type;
+  return std::pow(result_type(__x), result_type(__y));
 }
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_arithmetic<_Up>::value,
-    complex<typename __promote<_Tp, _Up>::type>
->::type
-pow(const complex<_Tp>& __x, const _Up& __y)
-{
-    typedef complex<typename __promote<_Tp, _Up>::type> result_type;
-    return _VSTD::pow(result_type(__x), result_type(__y));
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Up>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI complex<typename __promote<_Tp, _Up>::type> pow(const complex<_Tp>& __x, const _Up& __y) {
+  typedef complex<typename __promote<_Tp, _Up>::type> result_type;
+  return std::pow(result_type(__x), result_type(__y));
 }
 
-template<class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_arithmetic<_Tp>::value,
-    complex<typename __promote<_Tp, _Up>::type>
->::type
-pow(const _Tp& __x, const complex<_Up>& __y)
-{
-    typedef complex<typename __promote<_Tp, _Up>::type> result_type;
-    return _VSTD::pow(result_type(__x), result_type(__y));
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI complex<typename __promote<_Tp, _Up>::type> pow(const _Tp& __x, const complex<_Up>& __y) {
+  typedef complex<typename __promote<_Tp, _Up>::type> result_type;
+  return std::pow(result_type(__x), result_type(__y));
 }
 
 // __sqr, computes pow(x, 2)
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-complex<_Tp>
-__sqr(const complex<_Tp>& __x)
-{
-    return complex<_Tp>((__x.real() - __x.imag()) * (__x.real() + __x.imag()),
-                        _Tp(2) * __x.real() * __x.imag());
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> __sqr(const complex<_Tp>& __x) {
+  return complex<_Tp>((__x.real() - __x.imag()) * (__x.real() + __x.imag()), _Tp(2) * __x.real() * __x.imag());
 }
 
 // asinh
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-asinh(const complex<_Tp>& __x)
-{
-    const _Tp __pi(atan2(+0., -0.));
-    if (std::__constexpr_isinf(__x.real()))
-    {
-        if (std::__constexpr_isnan(__x.imag()))
-            return __x;
-        if (std::__constexpr_isinf(__x.imag()))
-            return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
-        return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
-    }
-    if (std::__constexpr_isnan(__x.real()))
-    {
-        if (std::__constexpr_isinf(__x.imag()))
-            return complex<_Tp>(__x.imag(), __x.real());
-        if (__x.imag() == 0)
-            return __x;
-        return complex<_Tp>(__x.real(), __x.real());
-    }
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> asinh(const complex<_Tp>& __x) {
+  const _Tp __pi(atan2(+0., -0.));
+  if (std::__constexpr_isinf(__x.real())) {
+    if (std::__constexpr_isnan(__x.imag()))
+      return __x;
     if (std::__constexpr_isinf(__x.imag()))
-        return complex<_Tp>(std::copysign(__x.imag(), __x.real()), std::copysign(__pi/_Tp(2), __x.imag()));
-    complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) + _Tp(1)));
-    return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
+      return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
+    return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
+  }
+  if (std::__constexpr_isnan(__x.real())) {
+    if (std::__constexpr_isinf(__x.imag()))
+      return complex<_Tp>(__x.imag(), __x.real());
+    if (__x.imag() == 0)
+      return __x;
+    return complex<_Tp>(__x.real(), __x.real());
+  }
+  if (std::__constexpr_isinf(__x.imag()))
+    return complex<_Tp>(std::copysign(__x.imag(), __x.real()), std::copysign(__pi / _Tp(2), __x.imag()));
+  complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) + _Tp(1)));
+  return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
 }
 
 // acosh
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-acosh(const complex<_Tp>& __x)
-{
-    const _Tp __pi(atan2(+0., -0.));
-    if (std::__constexpr_isinf(__x.real()))
-    {
-        if (std::__constexpr_isnan(__x.imag()))
-            return complex<_Tp>(std::abs(__x.real()), __x.imag());
-        if (std::__constexpr_isinf(__x.imag()))
-        {
-            if (__x.real() > 0)
-                return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
-            else
-                return complex<_Tp>(-__x.real(), std::copysign(__pi * _Tp(0.75), __x.imag()));
-        }
-        if (__x.real() < 0)
-            return complex<_Tp>(-__x.real(), std::copysign(__pi, __x.imag()));
-        return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
-    }
-    if (std::__constexpr_isnan(__x.real()))
-    {
-        if (std::__constexpr_isinf(__x.imag()))
-            return complex<_Tp>(std::abs(__x.imag()), __x.real());
-        return complex<_Tp>(__x.real(), __x.real());
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> acosh(const complex<_Tp>& __x) {
+  const _Tp __pi(atan2(+0., -0.));
+  if (std::__constexpr_isinf(__x.real())) {
+    if (std::__constexpr_isnan(__x.imag()))
+      return complex<_Tp>(std::abs(__x.real()), __x.imag());
+    if (std::__constexpr_isinf(__x.imag())) {
+      if (__x.real() > 0)
+        return complex<_Tp>(__x.real(), std::copysign(__pi * _Tp(0.25), __x.imag()));
+      else
+        return complex<_Tp>(-__x.real(), std::copysign(__pi * _Tp(0.75), __x.imag()));
     }
+    if (__x.real() < 0)
+      return complex<_Tp>(-__x.real(), std::copysign(__pi, __x.imag()));
+    return complex<_Tp>(__x.real(), std::copysign(_Tp(0), __x.imag()));
+  }
+  if (std::__constexpr_isnan(__x.real())) {
     if (std::__constexpr_isinf(__x.imag()))
-        return complex<_Tp>(std::abs(__x.imag()), std::copysign(__pi/_Tp(2), __x.imag()));
-    complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
-    return complex<_Tp>(std::copysign(__z.real(), _Tp(0)), std::copysign(__z.imag(), __x.imag()));
+      return complex<_Tp>(std::abs(__x.imag()), __x.real());
+    return complex<_Tp>(__x.real(), __x.real());
+  }
+  if (std::__constexpr_isinf(__x.imag()))
+    return complex<_Tp>(std::abs(__x.imag()), std::copysign(__pi / _Tp(2), __x.imag()));
+  complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
+  return complex<_Tp>(std::copysign(__z.real(), _Tp(0)), std::copysign(__z.imag(), __x.imag()));
 }
 
 // atanh
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-atanh(const complex<_Tp>& __x)
-{
-    const _Tp __pi(atan2(+0., -0.));
-    if (std::__constexpr_isinf(__x.imag()))
-    {
-        return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi/_Tp(2), __x.imag()));
-    }
-    if (std::__constexpr_isnan(__x.imag()))
-    {
-        if (std::__constexpr_isinf(__x.real()) || __x.real() == 0)
-            return complex<_Tp>(std::copysign(_Tp(0), __x.real()), __x.imag());
-        return complex<_Tp>(__x.imag(), __x.imag());
-    }
-    if (std::__constexpr_isnan(__x.real()))
-    {
-        return complex<_Tp>(__x.real(), __x.real());
-    }
-    if (std::__constexpr_isinf(__x.real()))
-    {
-        return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi/_Tp(2), __x.imag()));
-    }
-    if (std::abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0))
-    {
-        return complex<_Tp>(std::copysign(_Tp(INFINITY), __x.real()), std::copysign(_Tp(0), __x.imag()));
-    }
-    complex<_Tp> __z = std::log((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);
-    return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> atanh(const complex<_Tp>& __x) {
+  const _Tp __pi(atan2(+0., -0.));
+  if (std::__constexpr_isinf(__x.imag())) {
+    return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi / _Tp(2), __x.imag()));
+  }
+  if (std::__constexpr_isnan(__x.imag())) {
+    if (std::__constexpr_isinf(__x.real()) || __x.real() == 0)
+      return complex<_Tp>(std::copysign(_Tp(0), __x.real()), __x.imag());
+    return complex<_Tp>(__x.imag(), __x.imag());
+  }
+  if (std::__constexpr_isnan(__x.real())) {
+    return complex<_Tp>(__x.real(), __x.real());
+  }
+  if (std::__constexpr_isinf(__x.real())) {
+    return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi / _Tp(2), __x.imag()));
+  }
+  if (std::abs(__x.real()) == _Tp(1) && __x.imag() == _Tp(0)) {
+    return complex<_Tp>(std::copysign(_Tp(INFINITY), __x.real()), std::copysign(_Tp(0), __x.imag()));
+  }
+  complex<_Tp> __z = std::log((_Tp(1) + __x) / (_Tp(1) - __x)) / _Tp(2);
+  return complex<_Tp>(std::copysign(__z.real(), __x.real()), std::copysign(__z.imag(), __x.imag()));
 }
 
 // sinh
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-sinh(const complex<_Tp>& __x)
-{
-    if (std::__constexpr_isinf(__x.real()) && !std::__constexpr_isfinite(__x.imag()))
-        return complex<_Tp>(__x.real(), _Tp(NAN));
-    if (__x.real() == 0 && !std::__constexpr_isfinite(__x.imag()))
-        return complex<_Tp>(__x.real(), _Tp(NAN));
-    if (__x.imag() == 0 && !std::__constexpr_isfinite(__x.real()))
-        return __x;
-    return complex<_Tp>(std::sinh(__x.real()) * std::cos(__x.imag()), std::cosh(__x.real()) * std::sin(__x.imag()));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> sinh(const complex<_Tp>& __x) {
+  if (std::__constexpr_isinf(__x.real()) && !std::__constexpr_isfinite(__x.imag()))
+    return complex<_Tp>(__x.real(), _Tp(NAN));
+  if (__x.real() == 0 && !std::__constexpr_isfinite(__x.imag()))
+    return complex<_Tp>(__x.real(), _Tp(NAN));
+  if (__x.imag() == 0 && !std::__constexpr_isfinite(__x.real()))
+    return __x;
+  return complex<_Tp>(std::sinh(__x.real()) * std::cos(__x.imag()), std::cosh(__x.real()) * std::sin(__x.imag()));
 }
 
 // cosh
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-cosh(const complex<_Tp>& __x)
-{
-    if (std::__constexpr_isinf(__x.real()) && !std::__constexpr_isfinite(__x.imag()))
-        return complex<_Tp>(std::abs(__x.real()), _Tp(NAN));
-    if (__x.real() == 0 && !std::__constexpr_isfinite(__x.imag()))
-        return complex<_Tp>(_Tp(NAN), __x.real());
-    if (__x.real() == 0 && __x.imag() == 0)
-        return complex<_Tp>(_Tp(1), __x.imag());
-    if (__x.imag() == 0 && !std::__constexpr_isfinite(__x.real()))
-        return complex<_Tp>(std::abs(__x.real()), __x.imag());
-    return complex<_Tp>(std::cosh(__x.real()) * std::cos(__x.imag()), std::sinh(__x.real()) * std::sin(__x.imag()));
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> cosh(const complex<_Tp>& __x) {
+  if (std::__constexpr_isinf(__x.real()) && !std::__constexpr_isfinite(__x.imag()))
+    return complex<_Tp>(std::abs(__x.real()), _Tp(NAN));
+  if (__x.real() == 0 && !std::__constexpr_isfinite(__x.imag()))
+    return complex<_Tp>(_Tp(NAN), __x.real());
+  if (__x.real() == 0 && __x.imag() == 0)
+    return complex<_Tp>(_Tp(1), __x.imag());
+  if (__x.imag() == 0 && !std::__constexpr_isfinite(__x.real()))
+    return complex<_Tp>(std::abs(__x.real()), __x.imag());
+  return complex<_Tp>(std::cosh(__x.real()) * std::cos(__x.imag()), std::sinh(__x.real()) * std::sin(__x.imag()));
 }
 
 // tanh
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-tanh(const complex<_Tp>& __x)
-{
-    if (std::__constexpr_isinf(__x.real()))
-    {
-        if (!std::__constexpr_isfinite(__x.imag()))
-            return complex<_Tp>(std::copysign(_Tp(1), __x.real()), _Tp(0));
-        return complex<_Tp>(std::copysign(_Tp(1), __x.real()), std::copysign(_Tp(0), std::sin(_Tp(2) * __x.imag())));
-    }
-    if (std::__constexpr_isnan(__x.real()) && __x.imag() == 0)
-        return __x;
-    _Tp __2r(_Tp(2) * __x.real());
-    _Tp __2i(_Tp(2) * __x.imag());
-    _Tp __d(std::cosh(__2r) + std::cos(__2i));
-    _Tp __2rsh(std::sinh(__2r));
-    if (std::__constexpr_isinf(__2rsh) && std::__constexpr_isinf(__d))
-        return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1),
-                            __2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
-    return  complex<_Tp>(__2rsh/__d, std::sin(__2i)/__d);
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> tanh(const complex<_Tp>& __x) {
+  if (std::__constexpr_isinf(__x.real())) {
+    if (!std::__constexpr_isfinite(__x.imag()))
+      return complex<_Tp>(std::copysign(_Tp(1), __x.real()), _Tp(0));
+    return complex<_Tp>(std::copysign(_Tp(1), __x.real()), std::copysign(_Tp(0), std::sin(_Tp(2) * __x.imag())));
+  }
+  if (std::__constexpr_isnan(__x.real()) && __x.imag() == 0)
+    return __x;
+  _Tp __2r(_Tp(2) * __x.real());
+  _Tp __2i(_Tp(2) * __x.imag());
+  _Tp __d(std::cosh(__2r) + std::cos(__2i));
+  _Tp __2rsh(std::sinh(__2r));
+  if (std::__constexpr_isinf(__2rsh) && std::__constexpr_isinf(__d))
+    return complex<_Tp>(__2rsh > _Tp(0) ? _Tp(1) : _Tp(-1), __2i > _Tp(0) ? _Tp(0) : _Tp(-0.));
+  return complex<_Tp>(__2rsh / __d, std::sin(__2i) / __d);
 }
 
 // asin
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-asin(const complex<_Tp>& __x)
-{
-    complex<_Tp> __z = std::asinh(complex<_Tp>(-__x.imag(), __x.real()));
-    return complex<_Tp>(__z.imag(), -__z.real());
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> asin(const complex<_Tp>& __x) {
+  complex<_Tp> __z = std::asinh(complex<_Tp>(-__x.imag(), __x.real()));
+  return complex<_Tp>(__z.imag(), -__z.real());
 }
 
 // acos
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-acos(const complex<_Tp>& __x)
-{
-    const _Tp __pi(atan2(+0., -0.));
-    if (std::__constexpr_isinf(__x.real()))
-    {
-        if (std::__constexpr_isnan(__x.imag()))
-            return complex<_Tp>(__x.imag(), __x.real());
-        if (std::__constexpr_isinf(__x.imag()))
-        {
-            if (__x.real() < _Tp(0))
-                return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
-            return complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());
-        }
-        if (__x.real() < _Tp(0))
-            return complex<_Tp>(__pi, std::signbit(__x.imag()) ? -__x.real() : __x.real());
-        return complex<_Tp>(_Tp(0), std::signbit(__x.imag()) ? __x.real() : -__x.real());
-    }
-    if (std::__constexpr_isnan(__x.real()))
-    {
-        if (std::__constexpr_isinf(__x.imag()))
-            return complex<_Tp>(__x.real(), -__x.imag());
-        return complex<_Tp>(__x.real(), __x.real());
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> acos(const complex<_Tp>& __x) {
+  const _Tp __pi(atan2(+0., -0.));
+  if (std::__constexpr_isinf(__x.real())) {
+    if (std::__constexpr_isnan(__x.imag()))
+      return complex<_Tp>(__x.imag(), __x.real());
+    if (std::__constexpr_isinf(__x.imag())) {
+      if (__x.real() < _Tp(0))
+        return complex<_Tp>(_Tp(0.75) * __pi, -__x.imag());
+      return complex<_Tp>(_Tp(0.25) * __pi, -__x.imag());
     }
+    if (__x.real() < _Tp(0))
+      return complex<_Tp>(__pi, std::signbit(__x.imag()) ? -__x.real() : __x.real());
+    return complex<_Tp>(_Tp(0), std::signbit(__x.imag()) ? __x.real() : -__x.real());
+  }
+  if (std::__constexpr_isnan(__x.real())) {
     if (std::__constexpr_isinf(__x.imag()))
-        return complex<_Tp>(__pi/_Tp(2), -__x.imag());
-    if (__x.real() == 0 && (__x.imag() == 0 || std::isnan(__x.imag())))
-        return complex<_Tp>(__pi/_Tp(2), -__x.imag());
-    complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
-    if (std::signbit(__x.imag()))
-        return complex<_Tp>(std::abs(__z.imag()), std::abs(__z.real()));
-    return complex<_Tp>(std::abs(__z.imag()), -std::abs(__z.real()));
+      return complex<_Tp>(__x.real(), -__x.imag());
+    return complex<_Tp>(__x.real(), __x.real());
+  }
+  if (std::__constexpr_isinf(__x.imag()))
+    return complex<_Tp>(__pi / _Tp(2), -__x.imag());
+  if (__x.real() == 0 && (__x.imag() == 0 || std::isnan(__x.imag())))
+    return complex<_Tp>(__pi / _Tp(2), -__x.imag());
+  complex<_Tp> __z = std::log(__x + std::sqrt(std::__sqr(__x) - _Tp(1)));
+  if (std::signbit(__x.imag()))
+    return complex<_Tp>(std::abs(__z.imag()), std::abs(__z.real()));
+  return complex<_Tp>(std::abs(__z.imag()), -std::abs(__z.real()));
 }
 
 // atan
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-atan(const complex<_Tp>& __x)
-{
-    complex<_Tp> __z = std::atanh(complex<_Tp>(-__x.imag(), __x.real()));
-    return complex<_Tp>(__z.imag(), -__z.real());
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> atan(const complex<_Tp>& __x) {
+  complex<_Tp> __z = std::atanh(complex<_Tp>(-__x.imag(), __x.real()));
+  return complex<_Tp>(__z.imag(), -__z.real());
 }
 
 // sin
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-sin(const complex<_Tp>& __x)
-{
-    complex<_Tp> __z = std::sinh(complex<_Tp>(-__x.imag(), __x.real()));
-    return complex<_Tp>(__z.imag(), -__z.real());
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> sin(const complex<_Tp>& __x) {
+  complex<_Tp> __z = std::sinh(complex<_Tp>(-__x.imag(), __x.real()));
+  return complex<_Tp>(__z.imag(), -__z.real());
 }
 
 // cos
 
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-complex<_Tp>
-cos(const complex<_Tp>& __x)
-{
-    return std::cosh(complex<_Tp>(-__x.imag(), __x.real()));
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> cos(const complex<_Tp>& __x) {
+  return std::cosh(complex<_Tp>(-__x.imag(), __x.real()));
 }
 
 // tan
 
-template<class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp>
-tan(const complex<_Tp>& __x)
-{
-    complex<_Tp> __z = std::tanh(complex<_Tp>(-__x.imag(), __x.real()));
-    return complex<_Tp>(__z.imag(), -__z.real());
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI complex<_Tp> tan(const complex<_Tp>& __x) {
+  complex<_Tp> __z = std::tanh(complex<_Tp>(-__x.imag(), __x.real()));
+  return complex<_Tp>(__z.imag(), -__z.real());
 }
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-template<class _Tp, class _CharT, class _Traits>
+template <class _Tp, class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
-{
-    if (__is.good())
-    {
+operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x) {
+  if (__is.good()) {
+    std::ws(__is);
+    if (__is.peek() == _CharT('(')) {
+      __is.get();
+      _Tp __r;
+      __is >> __r;
+      if (!__is.fail()) {
         std::ws(__is);
-        if (__is.peek() == _CharT('('))
-        {
-            __is.get();
-            _Tp __r;
-            __is >> __r;
-            if (!__is.fail())
-            {
-                std::ws(__is);
-                _CharT __c = __is.peek();
-                if (__c == _CharT(','))
-                {
-                    __is.get();
-                    _Tp __i;
-                    __is >> __i;
-                    if (!__is.fail())
-                    {
-                        std::ws(__is);
-                        __c = __is.peek();
-                        if (__c == _CharT(')'))
-                        {
-                            __is.get();
-                            __x = complex<_Tp>(__r, __i);
-                        }
-                        else
-                            __is.setstate(__is.failbit);
-                    }
-                    else
-                        __is.setstate(__is.failbit);
-                }
-                else if (__c == _CharT(')'))
-                {
-                    __is.get();
-                    __x = complex<_Tp>(__r, _Tp(0));
-                }
-                else
-                    __is.setstate(__is.failbit);
-            }
-            else
-                __is.setstate(__is.failbit);
-        }
-        else
-        {
-            _Tp __r;
-            __is >> __r;
-            if (!__is.fail())
-                __x = complex<_Tp>(__r, _Tp(0));
-            else
-                __is.setstate(__is.failbit);
-        }
-    }
-    else
+        _CharT __c = __is.peek();
+        if (__c == _CharT(',')) {
+          __is.get();
+          _Tp __i;
+          __is >> __i;
+          if (!__is.fail()) {
+            std::ws(__is);
+            __c = __is.peek();
+            if (__c == _CharT(')')) {
+              __is.get();
+              __x = complex<_Tp>(__r, __i);
+            } else
+              __is.setstate(__is.failbit);
+          } else
+            __is.setstate(__is.failbit);
+        } else if (__c == _CharT(')')) {
+          __is.get();
+          __x = complex<_Tp>(__r, _Tp(0));
+        } else
+          __is.setstate(__is.failbit);
+      } else
         __is.setstate(__is.failbit);
-    return __is;
+    } else {
+      _Tp __r;
+      __is >> __r;
+      if (!__is.fail())
+        __x = complex<_Tp>(__r, _Tp(0));
+      else
+        __is.setstate(__is.failbit);
+    }
+  } else
+    __is.setstate(__is.failbit);
+  return __is;
 }
 
-template<class _Tp, class _CharT, class _Traits>
+template <class _Tp, class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
-{
-    basic_ostringstream<_CharT, _Traits> __s;
-    __s.flags(__os.flags());
-    __s.imbue(__os.getloc());
-    __s.precision(__os.precision());
-    __s << '(' << __x.real() << ',' << __x.imag() << ')';
-    return __os << __s.str();
+operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x) {
+  basic_ostringstream<_CharT, _Traits> __s;
+  __s.flags(__os.flags());
+  __s.imbue(__os.getloc());
+  __s.precision(__os.precision());
+  __s << '(' << __x.real() << ',' << __x.imag() << ')';
+  return __os << __s.str();
 }
 #endif // !_LIBCPP_HAS_NO_LOCALIZATION
 
+#if _LIBCPP_STD_VER >= 26
+
+// [complex.tuple], tuple interface
+
+template <class _Tp>
+struct tuple_size<complex<_Tp>> : integral_constant<size_t, 2> {};
+
+template <size_t _Ip, class _Tp>
+struct tuple_element<_Ip, complex<_Tp>> {
+  static_assert(_Ip < 2, "Index value is out of range.");
+  using type = _Tp;
+};
+
+template <size_t _Ip, class _Xp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>& __z) noexcept {
+  static_assert(_Ip < 2, "Index value is out of range.");
+  if constexpr (_Ip == 0) {
+    return __z.__re_;
+  } else {
+    return __z.__im_;
+  }
+}
+
+template <size_t _Ip, class _Xp>
+_LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&& __z) noexcept {
+  static_assert(_Ip < 2, "Index value is out of range.");
+  if constexpr (_Ip == 0) {
+    return std::move(__z.__re_);
+  } else {
+    return std::move(__z.__im_);
+  }
+}
+
+template <size_t _Ip, class _Xp>
+_LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>& __z) noexcept {
+  static_assert(_Ip < 2, "Index value is out of range.");
+  if constexpr (_Ip == 0) {
+    return __z.__re_;
+  } else {
+    return __z.__im_;
+  }
+}
+
+template <size_t _Ip, class _Xp>
+_LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&& __z) noexcept {
+  static_assert(_Ip < 2, "Index value is out of range.");
+  if constexpr (_Ip == 0) {
+    return std::move(__z.__re_);
+  } else {
+    return std::move(__z.__im_);
+  }
+}
+
+#endif // _LIBCPP_STD_VER >= 26
+
 #if _LIBCPP_STD_VER >= 14
 // Literal suffix for complex number literals [complex.literals]
-inline namespace literals
-{
-  inline namespace complex_literals
-  {
-    _LIBCPP_HIDE_FROM_ABI constexpr complex<long double> operator""il(long double __im)
-    {
-        return { 0.0l, __im };
-    }
+inline namespace literals {
+inline namespace complex_literals {
+_LIBCPP_HIDE_FROM_ABI inline constexpr complex<long double> operator""il(long double __im) { return {0.0l, __im}; }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr complex<long double> operator""il(unsigned long long __im)
-    {
-        return { 0.0l, static_cast<long double>(__im) };
-    }
+_LIBCPP_HIDE_FROM_ABI inline constexpr complex<long double> operator""il(unsigned long long __im) {
+  return {0.0l, static_cast<long double>(__im)};
+}
 
+_LIBCPP_HIDE_FROM_ABI inline constexpr complex<double> operator""i(long double __im) {
+  return {0.0, static_cast<double>(__im)};
+}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr complex<double> operator""i(long double __im)
-    {
-        return { 0.0, static_cast<double>(__im) };
-    }
+_LIBCPP_HIDE_FROM_ABI inline constexpr complex<double> operator""i(unsigned long long __im) {
+  return {0.0, static_cast<double>(__im)};
+}
 
-    _LIBCPP_HIDE_FROM_ABI constexpr complex<double> operator""i(unsigned long long __im)
-    {
-        return { 0.0, static_cast<double>(__im) };
-    }
+_LIBCPP_HIDE_FROM_ABI inline constexpr complex<float> operator""if(long double __im) {
+  return {0.0f, static_cast<float>(__im)};
+}
 
-
-    _LIBCPP_HIDE_FROM_ABI constexpr complex<float> operator""if(long double __im)
-    {
-        return { 0.0f, static_cast<float>(__im) };
-    }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr complex<float> operator""if(unsigned long long __im)
-    {
-        return { 0.0f, static_cast<float>(__im) };
-    }
-  } // namespace complex_literals
+_LIBCPP_HIDE_FROM_ABI inline constexpr complex<float> operator""if(unsigned long long __im) {
+  return {0.0f, static_cast<float>(__im)};
+}
+} // namespace complex_literals
 } // namespace literals
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <iosfwd>
+#  include <stdexcept>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/concepts b/third_party/libcxx/concepts
index 196fa2e0e..e89d216a5 100644
--- a/third_party/libcxx/concepts
+++ b/third_party/libcxx/concepts
@@ -129,33 +129,40 @@ namespace std {
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__concepts/arithmetic.h>
-#include <__concepts/assignable.h>
-#include <__concepts/boolean_testable.h>
-#include <__concepts/class_or_enum.h>
-#include <__concepts/common_reference_with.h>
-#include <__concepts/common_with.h>
-#include <__concepts/constructible.h>
-#include <__concepts/convertible_to.h>
-#include <__concepts/copyable.h>
-#include <__concepts/derived_from.h>
-#include <__concepts/destructible.h>
-#include <__concepts/different_from.h>
-#include <__concepts/equality_comparable.h>
-#include <__concepts/invocable.h>
-#include <__concepts/movable.h>
-#include <__concepts/predicate.h>
-#include <__concepts/regular.h>
-#include <__concepts/relation.h>
-#include <__concepts/same_as.h>
-#include <__concepts/semiregular.h>
-#include <__concepts/swappable.h>
-#include <__concepts/totally_ordered.h>
 #include <__config>
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__concepts/arithmetic.h>
+#  include <__concepts/assignable.h>
+#  include <__concepts/boolean_testable.h>
+#  include <__concepts/class_or_enum.h>
+#  include <__concepts/common_reference_with.h>
+#  include <__concepts/common_with.h>
+#  include <__concepts/constructible.h>
+#  include <__concepts/convertible_to.h>
+#  include <__concepts/copyable.h>
+#  include <__concepts/derived_from.h>
+#  include <__concepts/destructible.h>
+#  include <__concepts/different_from.h>
+#  include <__concepts/equality_comparable.h>
+#  include <__concepts/invocable.h>
+#  include <__concepts/movable.h>
+#  include <__concepts/predicate.h>
+#  include <__concepts/regular.h>
+#  include <__concepts/relation.h>
+#  include <__concepts/same_as.h>
+#  include <__concepts/semiregular.h>
+#  include <__concepts/swappable.h>
+#  include <__concepts/totally_ordered.h>
+#endif // _LIBCPP_STD_VER >= 20
+
 #include <version>
 
-#if _LIBCPP_STD_VER <= 20 && !defined(_LIPCPP_REMOVE_TRANSITIVE_INCLUDES)
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <cstddef>
+#endif
+
+#if _LIBCPP_STD_VER <= 20 && !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES)
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/condition_variable b/third_party/libcxx/condition_variable
index 825114b68..5195cd605 100644
--- a/third_party/libcxx/condition_variable
+++ b/third_party/libcxx/condition_variable
@@ -100,24 +100,36 @@ public:
         wait_for(Lock& lock,
                  const chrono::duration<Rep, Period>& rel_time,
                  Predicate pred);
+
+    // [thread.condvarany.intwait], interruptible waits
+    template <class Lock, class Predicate>
+      bool wait(Lock& lock, stop_token stoken, Predicate pred);                               // since C++20
+
+    template <class Lock, class Clock, class Duration, class Predicate>
+      bool wait_until(Lock& lock, stop_token stoken,
+                      const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);   // since C++20
+
+    template <class Lock, class Rep, class Period, class Predicate>
+      bool wait_for(Lock& lock, stop_token stoken,
+                    const chrono::duration<Rep, Period>& rel_time, Predicate pred);           // since C++20
 };
 
 }  // std
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__chrono/duration.h>
 #include <__chrono/steady_clock.h>
 #include <__chrono/time_point.h>
 #include <__condition_variable/condition_variable.h>
 #include <__config>
 #include <__memory/shared_ptr.h>
-#include <__memory/unique_ptr.h>
 #include <__mutex/lock_guard.h>
 #include <__mutex/mutex.h>
 #include <__mutex/tag_types.h>
 #include <__mutex/unique_lock.h>
+#include <__stop_token/stop_callback.h>
+#include <__stop_token/stop_token.h>
 #include <__utility/move.h>
 #include <version>
 
@@ -125,157 +137,220 @@ public:
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #ifndef _LIBCPP_HAS_NO_THREADS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TYPE_VIS condition_variable_any
-{
-    condition_variable __cv_;
-    shared_ptr<mutex>  __mut_;
+class _LIBCPP_EXPORTED_FROM_ABI condition_variable_any {
+  condition_variable __cv_;
+  shared_ptr<mutex> __mut_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    condition_variable_any();
+  _LIBCPP_HIDE_FROM_ABI condition_variable_any();
 
-    _LIBCPP_INLINE_VISIBILITY
-    void notify_one() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    void notify_all() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT;
 
-    template <class _Lock>
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-        void wait(_Lock& __lock);
-    template <class _Lock, class _Predicate>
-        _LIBCPP_INLINE_VISIBILITY
-        void wait(_Lock& __lock, _Predicate __pred);
+  template <class _Lock>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS void wait(_Lock& __lock);
+  template <class _Lock, class _Predicate>
+  _LIBCPP_HIDE_FROM_ABI void wait(_Lock& __lock, _Predicate __pred);
 
-    template <class _Lock, class _Clock, class _Duration>
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-        cv_status
-        wait_until(_Lock& __lock,
-                   const chrono::time_point<_Clock, _Duration>& __t);
+  template <class _Lock, class _Clock, class _Duration>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS cv_status
+  wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t);
 
-    template <class _Lock, class _Clock, class _Duration, class _Predicate>
-        bool
-        _LIBCPP_INLINE_VISIBILITY
-        wait_until(_Lock& __lock,
-                   const chrono::time_point<_Clock, _Duration>& __t,
-                   _Predicate __pred);
+  template <class _Lock, class _Clock, class _Duration, class _Predicate>
+  bool _LIBCPP_HIDE_FROM_ABI
+  wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred);
 
-    template <class _Lock, class _Rep, class _Period>
-        cv_status
-        _LIBCPP_INLINE_VISIBILITY
-        wait_for(_Lock& __lock,
-                 const chrono::duration<_Rep, _Period>& __d);
+  template <class _Lock, class _Rep, class _Period>
+  cv_status _LIBCPP_HIDE_FROM_ABI wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d);
 
-    template <class _Lock, class _Rep, class _Period, class _Predicate>
-        bool
-        _LIBCPP_INLINE_VISIBILITY
-        wait_for(_Lock& __lock,
-                 const chrono::duration<_Rep, _Period>& __d,
-                 _Predicate __pred);
+  template <class _Lock, class _Rep, class _Period, class _Predicate>
+  bool _LIBCPP_HIDE_FROM_ABI wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred);
+
+#  if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+
+  template <class _Lock, class _Predicate>
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait(_Lock& __lock, stop_token __stoken, _Predicate __pred);
+
+  template <class _Lock, class _Clock, class _Duration, class _Predicate>
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait_until(
+      _Lock& __lock, stop_token __stoken, const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred);
+
+  template <class _Lock, class _Rep, class _Period, class _Predicate>
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool
+  wait_for(_Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred);
+
+#  endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
 };
 
-inline
-condition_variable_any::condition_variable_any()
-    : __mut_(make_shared<mutex>()) {}
+inline condition_variable_any::condition_variable_any() : __mut_(make_shared<mutex>()) {}
 
-inline
-void
-condition_variable_any::notify_one() _NOEXCEPT
-{
-    {lock_guard<mutex> __lx(*__mut_);}
-    __cv_.notify_one();
+inline void condition_variable_any::notify_one() _NOEXCEPT {
+  { lock_guard<mutex> __lx(*__mut_); }
+  __cv_.notify_one();
 }
 
-inline
-void
-condition_variable_any::notify_all() _NOEXCEPT
-{
-    {lock_guard<mutex> __lx(*__mut_);}
-    __cv_.notify_all();
+inline void condition_variable_any::notify_all() _NOEXCEPT {
+  { lock_guard<mutex> __lx(*__mut_); }
+  __cv_.notify_all();
 }
 
-struct __lock_external
-{
-    template <class _Lock>
-    _LIBCPP_HIDE_FROM_ABI void operator()(_Lock* __m) {__m->lock();}
+template <class _Lock>
+struct __unlock_guard {
+  _Lock& __lock_;
+
+  _LIBCPP_HIDE_FROM_ABI __unlock_guard(_Lock& __lock) : __lock_(__lock) { __lock_.unlock(); }
+
+  _LIBCPP_HIDE_FROM_ABI ~__unlock_guard() _NOEXCEPT // turns exception to std::terminate
+  {
+    __lock_.lock();
+  }
+
+  __unlock_guard(const __unlock_guard&)            = delete;
+  __unlock_guard& operator=(const __unlock_guard&) = delete;
 };
 
 template <class _Lock>
-void
-condition_variable_any::wait(_Lock& __lock)
-{
-    shared_ptr<mutex> __mut = __mut_;
-    unique_lock<mutex> __lk(*__mut);
-    __lock.unlock();
-    unique_ptr<_Lock, __lock_external> __lxx(&__lock);
-    lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock_t());
-    __cv_.wait(__lk);
-}  // __mut_.unlock(), __lock.lock()
+void condition_variable_any::wait(_Lock& __lock) {
+  shared_ptr<mutex> __mut = __mut_;
+  unique_lock<mutex> __lk(*__mut);
+  __unlock_guard<_Lock> __unlock(__lock);
+  lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock_t());
+  __cv_.wait(__lk);
+} // __mut_.unlock(), __lock.lock()
 
 template <class _Lock, class _Predicate>
-inline
-void
-condition_variable_any::wait(_Lock& __lock, _Predicate __pred)
-{
-    while (!__pred())
-        wait(__lock);
+inline void condition_variable_any::wait(_Lock& __lock, _Predicate __pred) {
+  while (!__pred())
+    wait(__lock);
 }
 
 template <class _Lock, class _Clock, class _Duration>
-cv_status
-condition_variable_any::wait_until(_Lock& __lock,
-                                   const chrono::time_point<_Clock, _Duration>& __t)
-{
-    shared_ptr<mutex> __mut = __mut_;
-    unique_lock<mutex> __lk(*__mut);
-    __lock.unlock();
-    unique_ptr<_Lock, __lock_external> __lxx(&__lock);
-    lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock_t());
-    return __cv_.wait_until(__lk, __t);
-}  // __mut_.unlock(), __lock.lock()
+cv_status condition_variable_any::wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t) {
+  shared_ptr<mutex> __mut = __mut_;
+  unique_lock<mutex> __lk(*__mut);
+  __unlock_guard<_Lock> __unlock(__lock);
+  lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock_t());
+  return __cv_.wait_until(__lk, __t);
+} // __mut_.unlock(), __lock.lock()
 
 template <class _Lock, class _Clock, class _Duration, class _Predicate>
-inline
-bool
-condition_variable_any::wait_until(_Lock& __lock,
-                                   const chrono::time_point<_Clock, _Duration>& __t,
-                                   _Predicate __pred)
-{
-    while (!__pred())
-        if (wait_until(__lock, __t) == cv_status::timeout)
-            return __pred();
-    return true;
+inline bool
+condition_variable_any::wait_until(_Lock& __lock, const chrono::time_point<_Clock, _Duration>& __t, _Predicate __pred) {
+  while (!__pred())
+    if (wait_until(__lock, __t) == cv_status::timeout)
+      return __pred();
+  return true;
 }
 
 template <class _Lock, class _Rep, class _Period>
-inline
-cv_status
-condition_variable_any::wait_for(_Lock& __lock,
-                                 const chrono::duration<_Rep, _Period>& __d)
-{
-    return wait_until(__lock, chrono::steady_clock::now() + __d);
+inline cv_status condition_variable_any::wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d) {
+  return wait_until(__lock, chrono::steady_clock::now() + __d);
 }
 
 template <class _Lock, class _Rep, class _Period, class _Predicate>
-inline
-bool
-condition_variable_any::wait_for(_Lock& __lock,
-                                 const chrono::duration<_Rep, _Period>& __d,
-                                 _Predicate __pred)
-{
-    return wait_until(__lock, chrono::steady_clock::now() + __d,
-                      _VSTD::move(__pred));
+inline bool
+condition_variable_any::wait_for(_Lock& __lock, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred) {
+  return wait_until(__lock, chrono::steady_clock::now() + __d, std::move(__pred));
 }
 
-_LIBCPP_FUNC_VIS
-void notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);
+#  if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+
+template <class _Lock, class _Predicate>
+bool condition_variable_any::wait(_Lock& __user_lock, stop_token __stoken, _Predicate __pred) {
+  if (__stoken.stop_requested())
+    return __pred();
+
+  // Per https://eel.is/c++draft/thread.condition.condvarany#general-note-2,
+  // we do need to take a copy of the shared pointer __mut_
+  // This ensures that a thread can call the destructor immediately after calling
+  // notify_all, without waiting all the wait calls.
+  // A thread can also safely call the destructor immediately after calling
+  // request_stop, as the call to request_stop would evaluate the callback,
+  // which accesses the internal condition variable, immediately on the same thread.
+  // In this situation, it is OK even without copying a shared ownership the internal
+  // condition variable. However, this needs the evaluation of stop_callback to
+  // happen-before the destruction.
+  // The spec only says "Only the notification to unblock the wait needs to happen
+  // before destruction". To make this work, we need to copy the shared ownership of
+  // the internal condition variable inside this function, which is not possible
+  // with the current ABI.
+  shared_ptr<mutex> __mut = __mut_;
+
+  stop_callback __cb(__stoken, [this] { notify_all(); });
+
+  while (true) {
+    if (__pred())
+      return true;
+
+    // We need to take the internal lock before checking stop_requested,
+    // so that the notification cannot come in between the stop_requested
+    // check and entering the wait.
+    // Note that the stop_callback takes the same internal lock before notifying
+    unique_lock<mutex> __internal_lock(*__mut);
+    if (__stoken.stop_requested())
+      break;
+
+    __unlock_guard<_Lock> __unlock(__user_lock);
+    unique_lock<mutex> __internal_lock2(
+        std::move(__internal_lock)); // switch unlock order between __internal_lock and __user_lock
+    __cv_.wait(__internal_lock2);
+  } // __internal_lock2.unlock(), __user_lock.lock()
+  return __pred();
+}
+
+template <class _Lock, class _Clock, class _Duration, class _Predicate>
+bool condition_variable_any::wait_until(
+    _Lock& __user_lock,
+    stop_token __stoken,
+    const chrono::time_point<_Clock, _Duration>& __abs_time,
+    _Predicate __pred) {
+  if (__stoken.stop_requested())
+    return __pred();
+
+  shared_ptr<mutex> __mut = __mut_;
+  stop_callback __cb(__stoken, [this] { notify_all(); });
+
+  while (true) {
+    if (__pred())
+      return true;
+
+    unique_lock<mutex> __internal_lock(*__mut);
+    if (__stoken.stop_requested())
+      break;
+
+    __unlock_guard<_Lock> __unlock(__user_lock);
+    unique_lock<mutex> __internal_lock2(
+        std::move(__internal_lock)); // switch unlock order between __internal_lock and __user_lock
+
+    if (__cv_.wait_until(__internal_lock2, __abs_time) == cv_status::timeout)
+      break;
+  } // __internal_lock2.unlock(), __user_lock.lock()
+  return __pred();
+}
+
+template <class _Lock, class _Rep, class _Period, class _Predicate>
+bool condition_variable_any::wait_for(
+    _Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred) {
+  return wait_until(__lock, std::move(__stoken), chrono::steady_clock::now() + __rel_time, std::move(__pred));
+}
+
+#  endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
+
+_LIBCPP_EXPORTED_FROM_ABI void notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // !_LIBCPP_HAS_NO_THREADS
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
@@ -283,6 +358,7 @@ _LIBCPP_END_NAMESPACE_STD
 #  include <cstdlib>
 #  include <cstring>
 #  include <initializer_list>
+#  include <iosfwd>
 #  include <new>
 #  include <stdexcept>
 #  include <system_error>
diff --git a/third_party/libcxx/condition_variable.cpp b/third_party/libcxx/condition_variable.cpp
new file mode 100644
index 000000000..db60571cf
--- /dev/null
+++ b/third_party/libcxx/condition_variable.cpp
@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <condition_variable>
+#include <thread>
+
+#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#  pragma comment(lib, "pthread")
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// ~condition_variable is defined elsewhere.
+
+void condition_variable::notify_one() noexcept { __libcpp_condvar_signal(&__cv_); }
+
+void condition_variable::notify_all() noexcept { __libcpp_condvar_broadcast(&__cv_); }
+
+void condition_variable::wait(unique_lock<mutex>& lk) noexcept {
+  if (!lk.owns_lock())
+    __throw_system_error(EPERM, "condition_variable::wait: mutex not locked");
+  int ec = __libcpp_condvar_wait(&__cv_, lk.mutex()->native_handle());
+  if (ec)
+    __throw_system_error(ec, "condition_variable wait failed");
+}
+
+void condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
+                                         chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp) noexcept {
+  using namespace chrono;
+  if (!lk.owns_lock())
+    __throw_system_error(EPERM, "condition_variable::timed wait: mutex not locked");
+  nanoseconds d = tp.time_since_epoch();
+  if (d > nanoseconds(0x59682F000000E941))
+    d = nanoseconds(0x59682F000000E941);
+  __libcpp_timespec_t ts;
+  seconds s = duration_cast<seconds>(d);
+  typedef decltype(ts.tv_sec) ts_sec;
+  constexpr ts_sec ts_sec_max = numeric_limits<ts_sec>::max();
+  if (s.count() < ts_sec_max) {
+    ts.tv_sec  = static_cast<ts_sec>(s.count());
+    ts.tv_nsec = static_cast<decltype(ts.tv_nsec)>((d - s).count());
+  } else {
+    ts.tv_sec  = ts_sec_max;
+    ts.tv_nsec = giga::num - 1;
+  }
+  int ec = __libcpp_condvar_timedwait(&__cv_, lk.mutex()->native_handle(), &ts);
+  if (ec != 0 && ec != ETIMEDOUT)
+    __throw_system_error(ec, "condition_variable timed_wait failed");
+}
+
+void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk) {
+  auto& tl_ptr = __thread_local_data();
+  // If this thread was not created using std::thread then it will not have
+  // previously allocated.
+  if (tl_ptr.get() == nullptr) {
+    tl_ptr.set_pointer(new __thread_struct);
+  }
+  __thread_local_data()->notify_all_at_thread_exit(&cond, lk.release());
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/condition_variable_destructor.cpp b/third_party/libcxx/condition_variable_destructor.cpp
new file mode 100644
index 000000000..59811ed7f
--- /dev/null
+++ b/third_party/libcxx/condition_variable_destructor.cpp
@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Define ~condition_variable.
+//
+// On some platforms ~condition_variable has been made trivial and the
+// definition is only provided for ABI compatibility.
+
+#include <__config>
+#include <__thread/support.h>
+
+#if _LIBCPP_ABI_VERSION == 1 || !defined(_LIBCPP_HAS_TRIVIAL_CONDVAR_DESTRUCTION)
+#  define NEEDS_CONDVAR_DESTRUCTOR
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifdef NEEDS_CONDVAR_DESTRUCTOR
+
+class _LIBCPP_EXPORTED_FROM_ABI condition_variable {
+  __libcpp_condvar_t __cv_ = _LIBCPP_CONDVAR_INITIALIZER;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr condition_variable() noexcept = default;
+
+  ~condition_variable();
+
+  condition_variable(const condition_variable&)            = delete;
+  condition_variable& operator=(const condition_variable&) = delete;
+};
+
+condition_variable::~condition_variable() { __libcpp_condvar_destroy(&__cv_); }
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/include/config_elast.h b/third_party/libcxx/config_elast.h
similarity index 97%
rename from third_party/libcxx/src/include/config_elast.h
rename to third_party/libcxx/config_elast.h
index 06f0d042b..d47a53f2e 100644
--- a/third_party/libcxx/src/include/config_elast.h
+++ b/third_party/libcxx/config_elast.h
@@ -32,7 +32,7 @@
 #elif defined(__EMSCRIPTEN__)
 // No _LIBCPP_ELAST needed on Emscripten
 #elif defined(__COSMOPOLITAN__)
-#define _LIBCPP_ELAST 65535
+// No _LIBCPP_ELAST needed on Cosmopolitan
 #elif defined(__linux__) || defined(_LIBCPP_HAS_MUSL_LIBC)
 #define _LIBCPP_ELAST 4095
 #elif defined(__APPLE__)
diff --git a/third_party/libcxx/coroutine b/third_party/libcxx/coroutine
index f26457012..ee54388ad 100644
--- a/third_party/libcxx/coroutine
+++ b/third_party/libcxx/coroutine
@@ -38,12 +38,15 @@ struct suspend_always;
 
  */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__coroutine/coroutine_handle.h>
-#include <__coroutine/coroutine_traits.h>
-#include <__coroutine/noop_coroutine_handle.h>
-#include <__coroutine/trivial_awaitables.h>
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__coroutine/coroutine_handle.h>
+#  include <__coroutine/coroutine_traits.h>
+#  include <__coroutine/noop_coroutine_handle.h>
+#  include <__coroutine/trivial_awaitables.h>
+#endif // _LIBCPP_STD_VER >= 20
+
 #include <version>
 
 // standard-mandated includes
@@ -57,6 +60,7 @@ struct suspend_always;
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iosfwd>
+#  include <limits>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/csetjmp b/third_party/libcxx/csetjmp
index 4c64e8327..7ba900687 100644
--- a/third_party/libcxx/csetjmp
+++ b/third_party/libcxx/csetjmp
@@ -30,17 +30,14 @@ void longjmp(jmp_buf env, int val);
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
-#include <setjmp.h>
-
-#ifndef _LIBCPP_SETJMP_H
-#   error <csetjmp> tried including <setjmp.h> but didn't find libc++'s <setjmp.h> header. \
-          This usually means that your header search paths are not configured properly. \
-          The header search paths should contain the C++ Standard Library headers before \
-          any C Standard Library, and you are probably using compiler flags that make that \
-          not be the case.
+// <setjmp.h> is not provided by libc++
+#if __has_include(<setjmp.h>)
+#  include <setjmp.h>
+#  ifdef _LIBCPP_SETJMP_H
+#    error "If libc++ starts defining <setjmp.h>, the __has_include check should move to libc++'s <setjmp.h>"
+#  endif
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
diff --git a/third_party/libcxx/csignal b/third_party/libcxx/csignal
index cf45f5075..804a7f95a 100644
--- a/third_party/libcxx/csignal
+++ b/third_party/libcxx/csignal
@@ -39,7 +39,6 @@ int raise(int sig);
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 // <signal.h> is not provided by libc++
diff --git a/third_party/libcxx/cstdarg b/third_party/libcxx/cstdarg
index 3a4291f45..4642eb7b5 100644
--- a/third_party/libcxx/cstdarg
+++ b/third_party/libcxx/cstdarg
@@ -31,7 +31,6 @@ Types:
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 // <stdarg.h> is not provided by libc++
diff --git a/third_party/libcxx/cstdbool b/third_party/libcxx/cstdbool
index ce608033a..ef731c021 100644
--- a/third_party/libcxx/cstdbool
+++ b/third_party/libcxx/cstdbool
@@ -19,7 +19,6 @@ Macros:
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
diff --git a/third_party/libcxx/cstddef b/third_party/libcxx/cstddef
index a364e6e55..1a4049e4d 100644
--- a/third_party/libcxx/cstddef
+++ b/third_party/libcxx/cstddef
@@ -33,7 +33,6 @@ Types:
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
@@ -67,77 +66,65 @@ using ::max_align_t _LIBCPP_USING_IF_EXISTS;
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
-namespace std  // purposefully not versioned
+namespace std // purposefully not versioned
 {
 enum class byte : unsigned char {};
 
-_LIBCPP_HIDE_FROM_ABI constexpr byte  operator| (byte  __lhs, byte __rhs) noexcept
-{
-    return static_cast<byte>(
-      static_cast<unsigned char>(
-         static_cast<unsigned int>(__lhs) | static_cast<unsigned int>(__rhs)
-    ));
+_LIBCPP_HIDE_FROM_ABI inline constexpr byte operator|(byte __lhs, byte __rhs) noexcept {
+  return static_cast<byte>(
+      static_cast<unsigned char>(static_cast<unsigned int>(__lhs) | static_cast<unsigned int>(__rhs)));
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr byte& operator|=(byte& __lhs, byte __rhs) noexcept
-{ return __lhs = __lhs | __rhs; }
-
-_LIBCPP_HIDE_FROM_ABI constexpr byte  operator& (byte  __lhs, byte __rhs) noexcept
-{
-    return static_cast<byte>(
-      static_cast<unsigned char>(
-         static_cast<unsigned int>(__lhs) & static_cast<unsigned int>(__rhs)
-    ));
+_LIBCPP_HIDE_FROM_ABI inline constexpr byte& operator|=(byte& __lhs, byte __rhs) noexcept {
+  return __lhs = __lhs | __rhs;
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr byte& operator&=(byte& __lhs, byte __rhs) noexcept
-{ return __lhs = __lhs & __rhs; }
-
-_LIBCPP_HIDE_FROM_ABI constexpr byte  operator^ (byte  __lhs, byte __rhs) noexcept
-{
-    return static_cast<byte>(
-      static_cast<unsigned char>(
-         static_cast<unsigned int>(__lhs) ^ static_cast<unsigned int>(__rhs)
-    ));
+_LIBCPP_HIDE_FROM_ABI inline constexpr byte operator&(byte __lhs, byte __rhs) noexcept {
+  return static_cast<byte>(
+      static_cast<unsigned char>(static_cast<unsigned int>(__lhs) & static_cast<unsigned int>(__rhs)));
 }
 
-_LIBCPP_HIDE_FROM_ABI constexpr byte& operator^=(byte& __lhs, byte __rhs) noexcept
-{ return __lhs = __lhs ^ __rhs; }
-
-_LIBCPP_HIDE_FROM_ABI constexpr byte  operator~ (byte __b) noexcept
-{
-    return static_cast<byte>(
-      static_cast<unsigned char>(
-        ~static_cast<unsigned int>(__b)
-    ));
+_LIBCPP_HIDE_FROM_ABI inline constexpr byte& operator&=(byte& __lhs, byte __rhs) noexcept {
+  return __lhs = __lhs & __rhs;
 }
 
-template <class _Tp>
-using _EnableByteOverload = __enable_if_t<is_integral<_Tp>::value, byte>;
+_LIBCPP_HIDE_FROM_ABI inline constexpr byte operator^(byte __lhs, byte __rhs) noexcept {
+  return static_cast<byte>(
+      static_cast<unsigned char>(static_cast<unsigned int>(__lhs) ^ static_cast<unsigned int>(__rhs)));
+}
 
-template <class _Integer>
-_LIBCPP_HIDE_FROM_ABI constexpr _EnableByteOverload<_Integer> &
-  operator<<=(byte& __lhs, _Integer __shift) noexcept
-  { return __lhs = __lhs << __shift; }
+_LIBCPP_HIDE_FROM_ABI inline constexpr byte& operator^=(byte& __lhs, byte __rhs) noexcept {
+  return __lhs = __lhs ^ __rhs;
+}
 
-template <class _Integer>
-_LIBCPP_HIDE_FROM_ABI constexpr _EnableByteOverload<_Integer>
-  operator<< (byte  __lhs, _Integer __shift) noexcept
-  { return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) << __shift)); }
+_LIBCPP_HIDE_FROM_ABI inline constexpr byte operator~(byte __b) noexcept {
+  return static_cast<byte>(static_cast<unsigned char>(~static_cast<unsigned int>(__b)));
+}
 
-template <class _Integer>
-_LIBCPP_HIDE_FROM_ABI constexpr _EnableByteOverload<_Integer> &
-  operator>>=(byte& __lhs, _Integer __shift) noexcept
-  { return __lhs = __lhs >> __shift; }
+template <class _Integer, __enable_if_t<is_integral<_Integer>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr byte& operator<<=(byte& __lhs, _Integer __shift) noexcept {
+  return __lhs = __lhs << __shift;
+}
 
-template <class _Integer>
-_LIBCPP_HIDE_FROM_ABI constexpr _EnableByteOverload<_Integer>
-  operator>> (byte  __lhs, _Integer __shift) noexcept
-  { return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) >> __shift)); }
+template <class _Integer, __enable_if_t<is_integral<_Integer>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr byte operator<<(byte __lhs, _Integer __shift) noexcept {
+  return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) << __shift));
+}
 
-template <class _Integer, class = _EnableByteOverload<_Integer> >
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI constexpr _Integer
-  to_integer(byte __b) noexcept { return static_cast<_Integer>(__b); }
+template <class _Integer, __enable_if_t<is_integral<_Integer>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr byte& operator>>=(byte& __lhs, _Integer __shift) noexcept {
+  return __lhs = __lhs >> __shift;
+}
+
+template <class _Integer, __enable_if_t<is_integral<_Integer>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI constexpr byte operator>>(byte __lhs, _Integer __shift) noexcept {
+  return static_cast<byte>(static_cast<unsigned char>(static_cast<unsigned int>(__lhs) >> __shift));
+}
+
+template <class _Integer, __enable_if_t<is_integral<_Integer>::value, int> = 0>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Integer to_integer(byte __b) noexcept {
+  return static_cast<_Integer>(__b);
+}
 
 } // namespace std
 
diff --git a/third_party/libcxx/cstdint b/third_party/libcxx/cstdint
index 829d9398f..8c4782859 100644
--- a/third_party/libcxx/cstdint
+++ b/third_party/libcxx/cstdint
@@ -140,7 +140,6 @@ Types:
 }  // std
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #include <stdint.h>
diff --git a/third_party/libcxx/cstdio b/third_party/libcxx/cstdio
index 221b0b314..7f9437108 100644
--- a/third_party/libcxx/cstdio
+++ b/third_party/libcxx/cstdio
@@ -95,7 +95,6 @@ void perror(const char* s);
 }  // std
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #include <stdio.h>
@@ -141,13 +140,9 @@ using ::putc _LIBCPP_USING_IF_EXISTS;
 using ::ungetc _LIBCPP_USING_IF_EXISTS;
 using ::fread _LIBCPP_USING_IF_EXISTS;
 using ::fwrite _LIBCPP_USING_IF_EXISTS;
-#ifndef _LIBCPP_HAS_NO_FGETPOS_FSETPOS
 using ::fgetpos _LIBCPP_USING_IF_EXISTS;
-#endif
 using ::fseek _LIBCPP_USING_IF_EXISTS;
-#ifndef _LIBCPP_HAS_NO_FGETPOS_FSETPOS
 using ::fsetpos _LIBCPP_USING_IF_EXISTS;
-#endif
 using ::ftell _LIBCPP_USING_IF_EXISTS;
 using ::rewind _LIBCPP_USING_IF_EXISTS;
 using ::clearerr _LIBCPP_USING_IF_EXISTS;
@@ -163,7 +158,7 @@ using ::tmpfile _LIBCPP_USING_IF_EXISTS;
 using ::tmpnam _LIBCPP_USING_IF_EXISTS;
 
 using ::getchar _LIBCPP_USING_IF_EXISTS;
-#if _LIBCPP_STD_VER <= 11 && !defined(_LIBCPP_C_HAS_NO_GETS)
+#if _LIBCPP_STD_VER <= 11
 using ::gets _LIBCPP_USING_IF_EXISTS;
 #endif
 using ::scanf _LIBCPP_USING_IF_EXISTS;
diff --git a/third_party/libcxx/cstdlib b/third_party/libcxx/cstdlib
index ab2c159c7..c817fd8f4 100644
--- a/third_party/libcxx/cstdlib
+++ b/third_party/libcxx/cstdlib
@@ -81,7 +81,6 @@ void *aligned_alloc(size_t alignment, size_t size);                       // C11
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #include <stdlib.h>
@@ -136,10 +135,12 @@ using ::div _LIBCPP_USING_IF_EXISTS;
 using ::ldiv _LIBCPP_USING_IF_EXISTS;
 using ::lldiv _LIBCPP_USING_IF_EXISTS;
 using ::mblen _LIBCPP_USING_IF_EXISTS;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 using ::mbtowc _LIBCPP_USING_IF_EXISTS;
 using ::wctomb _LIBCPP_USING_IF_EXISTS;
 using ::mbstowcs _LIBCPP_USING_IF_EXISTS;
 using ::wcstombs _LIBCPP_USING_IF_EXISTS;
+#endif
 #if !defined(_LIBCPP_CXX03_LANG)
 using ::at_quick_exit _LIBCPP_USING_IF_EXISTS;
 using ::quick_exit _LIBCPP_USING_IF_EXISTS;
diff --git a/third_party/libcxx/cstring b/third_party/libcxx/cstring
index a9bdf4ff2..c2c92b02e 100644
--- a/third_party/libcxx/cstring
+++ b/third_party/libcxx/cstring
@@ -56,7 +56,6 @@ size_t strlen(const char* s);
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__type_traits/is_constant_evaluated.h>
 
diff --git a/third_party/libcxx/ctgmath b/third_party/libcxx/ctgmath
index bfcf2f98d..6237979be 100644
--- a/third_party/libcxx/ctgmath
+++ b/third_party/libcxx/ctgmath
@@ -18,7 +18,6 @@
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <ccomplex>
 #include <cmath>
 
diff --git a/third_party/libcxx/ctime b/third_party/libcxx/ctime
index b61e19d64..f47b49a43 100644
--- a/third_party/libcxx/ctime
+++ b/third_party/libcxx/ctime
@@ -45,7 +45,6 @@ int timespec_get( struct timespec *ts, int base); // C++17
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 // <time.h> is not provided by libc++
diff --git a/third_party/libcxx/ctype.h b/third_party/libcxx/ctype.h
index 728173ed6..448e4410c 100644
--- a/third_party/libcxx/ctype.h
+++ b/third_party/libcxx/ctype.h
@@ -41,20 +41,20 @@ int toupper(int c);
 
 #ifdef __cplusplus
 
-#undef isalnum
-#undef isalpha
-#undef isblank
-#undef iscntrl
-#undef isdigit
-#undef isgraph
-#undef islower
-#undef isprint
-#undef ispunct
-#undef isspace
-#undef isupper
-#undef isxdigit
-#undef tolower
-#undef toupper
+#  undef isalnum
+#  undef isalpha
+#  undef isblank
+#  undef iscntrl
+#  undef isdigit
+#  undef isgraph
+#  undef islower
+#  undef isprint
+#  undef ispunct
+#  undef isspace
+#  undef isupper
+#  undef isxdigit
+#  undef tolower
+#  undef toupper
 
 #endif
 
diff --git a/third_party/libcxx/cuchar b/third_party/libcxx/cuchar
index 93e657e84..f0015be27 100644
--- a/third_party/libcxx/cuchar
+++ b/third_party/libcxx/cuchar
@@ -36,7 +36,6 @@ size_t c32rtomb(char* s, char32_t c32, mbstate_t* ps);
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #include <uchar.h>
@@ -73,4 +72,4 @@ using ::c32rtomb _LIBCPP_USING_IF_EXISTS;
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif  // _LIBCPP_CUCHAR
+#endif // _LIBCPP_CUCHAR
diff --git a/third_party/libcxx/cwchar b/third_party/libcxx/cwchar
index 122af2428..08cfac58c 100644
--- a/third_party/libcxx/cwchar
+++ b/third_party/libcxx/cwchar
@@ -102,9 +102,8 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__type_traits/apply_cv.h>
+#include <__type_traits/copy_cv.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_equality_comparable.h>
 #include <__type_traits/is_same.h>
@@ -237,7 +236,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __constexpr_wmemchr(_Tp
     wchar_t __value_buffer = 0;
     __builtin_memcpy(&__value_buffer, &__value, sizeof(wchar_t));
     return reinterpret_cast<_Tp*>(
-        __builtin_wmemchr(reinterpret_cast<__apply_cv_t<_Tp, wchar_t>*>(__str), __value_buffer, __count));
+        __builtin_wmemchr(reinterpret_cast<__copy_cv_t<_Tp, wchar_t>*>(__str), __value_buffer, __count));
   }
 #  if _LIBCPP_STD_VER >= 17
   else if constexpr (is_same_v<remove_cv_t<_Tp>, wchar_t>)
@@ -255,4 +254,8 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __constexpr_wmemchr(_Tp
 
 _LIBCPP_END_NAMESPACE_STD
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstddef>
+#endif
+
 #endif // _LIBCPP_CWCHAR
diff --git a/third_party/libcxx/cwctype b/third_party/libcxx/cwctype
index 5a2d2427d..04abfabef 100644
--- a/third_party/libcxx/cwctype
+++ b/third_party/libcxx/cwctype
@@ -49,7 +49,6 @@ wctrans_t wctrans(const char* property);
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cctype>
 
diff --git a/third_party/libcxx/deque b/third_party/libcxx/deque
index 175e56e0f..4fc994a6e 100644
--- a/third_party/libcxx/deque
+++ b/third_party/libcxx/deque
@@ -188,9 +188,11 @@ template <class T, class Allocator, class Predicate>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/unwrap_iter.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
+#include <__debug_utils/sanitizers.h>
 #include <__format/enable_insertable.h>
+#include <__fwd/deque.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
@@ -212,6 +214,7 @@ template <class T, class Allocator, class Predicate>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_same.h>
+#include <__type_traits/is_swappable.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
@@ -241,183 +244,170 @@ template <class T, class Allocator, class Predicate>
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _Allocator = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS deque;
-
 template <class _ValueType, class _DiffType>
 struct __deque_block_size {
   static const _DiffType value = sizeof(_ValueType) < 256 ? 4096 / sizeof(_ValueType) : 16;
 };
 
-template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
-          class _DiffType, _DiffType _BS =
+template <class _ValueType,
+          class _Pointer,
+          class _Reference,
+          class _MapPointer,
+          class _DiffType,
+          _DiffType _BS =
 #ifdef _LIBCPP_ABI_INCOMPLETE_TYPES_IN_DEQUE
-// Keep template parameter to avoid changing all template declarations thoughout
-// this file.
-                               0
+              // Keep template parameter to avoid changing all template declarations thoughout
+              // this file.
+          0
 #else
-                               __deque_block_size<_ValueType, _DiffType>::value
+              __deque_block_size<_ValueType, _DiffType>::value
 #endif
           >
-class _LIBCPP_TEMPLATE_VIS __deque_iterator
-{
-    typedef _MapPointer __map_iterator;
+class _LIBCPP_TEMPLATE_VIS __deque_iterator {
+  typedef _MapPointer __map_iterator;
+
 public:
-    typedef _Pointer  pointer;
-    typedef _DiffType difference_type;
+  typedef _Pointer pointer;
+  typedef _DiffType difference_type;
+
 private:
-    __map_iterator __m_iter_;
-    pointer        __ptr_;
+  __map_iterator __m_iter_;
+  pointer __ptr_;
+
+  static const difference_type __block_size;
 
-    static const difference_type __block_size;
 public:
-    typedef _ValueType                  value_type;
-    typedef random_access_iterator_tag  iterator_category;
-    typedef _Reference                  reference;
+  typedef _ValueType value_type;
+  typedef random_access_iterator_tag iterator_category;
+  typedef _Reference reference;
 
-    _LIBCPP_HIDE_FROM_ABI __deque_iterator() _NOEXCEPT
+  _LIBCPP_HIDE_FROM_ABI __deque_iterator() _NOEXCEPT
 #if _LIBCPP_STD_VER >= 14
-     : __m_iter_(nullptr), __ptr_(nullptr)
+      : __m_iter_(nullptr),
+        __ptr_(nullptr)
 #endif
-     {}
+  {
+  }
 
-    template <class _Pp, class _Rp, class _MP>
-    _LIBCPP_HIDE_FROM_ABI
-    __deque_iterator(const __deque_iterator<value_type, _Pp, _Rp, _MP, difference_type, _BS>& __it,
-                typename enable_if<is_convertible<_Pp, pointer>::value>::type* = 0) _NOEXCEPT
-        : __m_iter_(__it.__m_iter_), __ptr_(__it.__ptr_) {}
+  template <class _Pp, class _Rp, class _MP, __enable_if_t<is_convertible<_Pp, pointer>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  __deque_iterator(const __deque_iterator<value_type, _Pp, _Rp, _MP, difference_type, _BS>& __it) _NOEXCEPT
+      : __m_iter_(__it.__m_iter_),
+        __ptr_(__it.__ptr_) {}
 
-    _LIBCPP_HIDE_FROM_ABI reference operator*() const {return *__ptr_;}
-    _LIBCPP_HIDE_FROM_ABI pointer operator->() const {return __ptr_;}
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return *__ptr_; }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return __ptr_; }
 
-    _LIBCPP_HIDE_FROM_ABI __deque_iterator& operator++()
-    {
-        if (++__ptr_ - *__m_iter_ == __block_size)
-        {
-            ++__m_iter_;
-            __ptr_ = *__m_iter_;
-        }
-        return *this;
+  _LIBCPP_HIDE_FROM_ABI __deque_iterator& operator++() {
+    if (++__ptr_ - *__m_iter_ == __block_size) {
+      ++__m_iter_;
+      __ptr_ = *__m_iter_;
     }
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI __deque_iterator operator++(int)
-    {
-        __deque_iterator __tmp = *this;
-        ++(*this);
-        return __tmp;
+  _LIBCPP_HIDE_FROM_ABI __deque_iterator operator++(int) {
+    __deque_iterator __tmp = *this;
+    ++(*this);
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __deque_iterator& operator--() {
+    if (__ptr_ == *__m_iter_) {
+      --__m_iter_;
+      __ptr_ = *__m_iter_ + __block_size;
     }
+    --__ptr_;
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI __deque_iterator& operator--()
-    {
-        if (__ptr_ == *__m_iter_)
-        {
-            --__m_iter_;
-            __ptr_ = *__m_iter_ + __block_size;
-        }
-        --__ptr_;
-        return *this;
+  _LIBCPP_HIDE_FROM_ABI __deque_iterator operator--(int) {
+    __deque_iterator __tmp = *this;
+    --(*this);
+    return __tmp;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __deque_iterator& operator+=(difference_type __n) {
+    if (__n != 0) {
+      __n += __ptr_ - *__m_iter_;
+      if (__n > 0) {
+        __m_iter_ += __n / __block_size;
+        __ptr_ = *__m_iter_ + __n % __block_size;
+      } else // (__n < 0)
+      {
+        difference_type __z = __block_size - 1 - __n;
+        __m_iter_ -= __z / __block_size;
+        __ptr_ = *__m_iter_ + (__block_size - 1 - __z % __block_size);
+      }
     }
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI __deque_iterator operator--(int)
-    {
-        __deque_iterator __tmp = *this;
-        --(*this);
-        return __tmp;
-    }
+  _LIBCPP_HIDE_FROM_ABI __deque_iterator& operator-=(difference_type __n) { return *this += -__n; }
 
-    _LIBCPP_HIDE_FROM_ABI __deque_iterator& operator+=(difference_type __n)
-    {
-        if (__n != 0)
-        {
-            __n += __ptr_ - *__m_iter_;
-            if (__n > 0)
-            {
-                __m_iter_ += __n / __block_size;
-                __ptr_ = *__m_iter_ + __n % __block_size;
-            }
-            else // (__n < 0)
-            {
-                difference_type __z = __block_size - 1 - __n;
-                __m_iter_ -= __z / __block_size;
-                __ptr_ = *__m_iter_ + (__block_size - 1 - __z % __block_size);
-            }
-        }
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI __deque_iterator operator+(difference_type __n) const {
+    __deque_iterator __t(*this);
+    __t += __n;
+    return __t;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI __deque_iterator& operator-=(difference_type __n)
-    {
-        return *this += -__n;
-    }
+  _LIBCPP_HIDE_FROM_ABI __deque_iterator operator-(difference_type __n) const {
+    __deque_iterator __t(*this);
+    __t -= __n;
+    return __t;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI __deque_iterator operator+(difference_type __n) const
-    {
-        __deque_iterator __t(*this);
-        __t += __n;
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI friend __deque_iterator operator+(difference_type __n, const __deque_iterator& __it) {
+    return __it + __n;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI __deque_iterator operator-(difference_type __n) const
-    {
-        __deque_iterator __t(*this);
-        __t -= __n;
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI friend difference_type operator-(const __deque_iterator& __x, const __deque_iterator& __y) {
+    if (__x != __y)
+      return (__x.__m_iter_ - __y.__m_iter_) * __block_size + (__x.__ptr_ - *__x.__m_iter_) -
+             (__y.__ptr_ - *__y.__m_iter_);
+    return 0;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend __deque_iterator operator+(difference_type __n, const __deque_iterator& __it)
-        {return __it + __n;}
+  _LIBCPP_HIDE_FROM_ABI reference operator[](difference_type __n) const { return *(*this + __n); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    friend difference_type operator-(const __deque_iterator& __x, const __deque_iterator& __y)
-    {
-        if (__x != __y)
-            return (__x.__m_iter_ - __y.__m_iter_) * __block_size
-                 + (__x.__ptr_ - *__x.__m_iter_)
-                 - (__y.__ptr_ - *__y.__m_iter_);
-        return 0;
-    }
+  _LIBCPP_HIDE_FROM_ABI friend bool operator==(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return __x.__ptr_ == __y.__ptr_;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI reference operator[](difference_type __n) const
-        {return *(*this + __n);}
+  _LIBCPP_HIDE_FROM_ABI friend bool operator!=(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return !(__x == __y);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI friend
-        bool operator==(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return __x.__ptr_ == __y.__ptr_;}
+  _LIBCPP_HIDE_FROM_ABI friend bool operator<(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return __x.__m_iter_ < __y.__m_iter_ || (__x.__m_iter_ == __y.__m_iter_ && __x.__ptr_ < __y.__ptr_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI friend
-        bool operator!=(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return !(__x == __y);}
+  _LIBCPP_HIDE_FROM_ABI friend bool operator>(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return __y < __x;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI friend
-        bool operator<(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return __x.__m_iter_ < __y.__m_iter_ ||
-               (__x.__m_iter_ == __y.__m_iter_ && __x.__ptr_ < __y.__ptr_);}
+  _LIBCPP_HIDE_FROM_ABI friend bool operator<=(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return !(__y < __x);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI friend
-        bool operator>(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return __y < __x;}
-
-    _LIBCPP_HIDE_FROM_ABI friend
-        bool operator<=(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return !(__y < __x);}
-
-    _LIBCPP_HIDE_FROM_ABI friend
-        bool operator>=(const __deque_iterator& __x, const __deque_iterator& __y)
-        {return !(__x < __y);}
+  _LIBCPP_HIDE_FROM_ABI friend bool operator>=(const __deque_iterator& __x, const __deque_iterator& __y) {
+    return !(__x < __y);
+  }
 
 private:
-    _LIBCPP_HIDE_FROM_ABI explicit __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT
-        : __m_iter_(__m), __ptr_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __deque_iterator(__map_iterator __m, pointer __p) _NOEXCEPT
+      : __m_iter_(__m),
+        __ptr_(__p) {}
 
-    template <class _Tp, class _Ap> friend class _LIBCPP_TEMPLATE_VIS deque;
-    template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp>
-        friend class _LIBCPP_TEMPLATE_VIS __deque_iterator;
+  template <class _Tp, class _Ap>
+  friend class _LIBCPP_TEMPLATE_VIS deque;
+  template <class _Vp, class _Pp, class _Rp, class _MP, class _Dp, _Dp>
+  friend class _LIBCPP_TEMPLATE_VIS __deque_iterator;
 
-    template <class>
-    friend struct __segmented_iterator_traits;
+  template <class>
+  friend struct __segmented_iterator_traits;
 };
 
 template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize>
@@ -428,45 +418,42 @@ private:
 
 public:
   using __is_segmented_iterator = true_type;
-  using __segment_iterator = _MapPointer;
-  using __local_iterator = _Pointer;
+  using __segment_iterator      = _MapPointer;
+  using __local_iterator        = _Pointer;
 
   static _LIBCPP_HIDE_FROM_ABI __segment_iterator __segment(_Iterator __iter) { return __iter.__m_iter_; }
   static _LIBCPP_HIDE_FROM_ABI __local_iterator __local(_Iterator __iter) { return __iter.__ptr_; }
   static _LIBCPP_HIDE_FROM_ABI __local_iterator __begin(__segment_iterator __iter) { return *__iter; }
 
   static _LIBCPP_HIDE_FROM_ABI __local_iterator __end(__segment_iterator __iter) {
-        return *__iter + _Iterator::__block_size;
+    return *__iter + _Iterator::__block_size;
   }
 
   static _LIBCPP_HIDE_FROM_ABI _Iterator __compose(__segment_iterator __segment, __local_iterator __local) {
-        if (__local == __end(__segment)) {
-            ++__segment;
-            return _Iterator(__segment, *__segment);
-        }
-        return _Iterator(__segment, __local);
+    if (__segment && __local == __end(__segment)) {
+      ++__segment;
+      return _Iterator(__segment, *__segment);
+    }
+    return _Iterator(__segment, __local);
   }
 };
 
-template <class _ValueType, class _Pointer, class _Reference, class _MapPointer,
-          class _DiffType, _DiffType _BlockSize>
-const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer,
-                                 _DiffType, _BlockSize>::__block_size =
+template <class _ValueType, class _Pointer, class _Reference, class _MapPointer, class _DiffType, _DiffType _BlockSize>
+const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer, _DiffType, _BlockSize>::__block_size =
     __deque_block_size<_ValueType, _DiffType>::value;
 
 template <class _Tp, class _Allocator /*= allocator<_Tp>*/>
-class _LIBCPP_TEMPLATE_VIS deque
-{
+class _LIBCPP_TEMPLATE_VIS deque {
 public:
-    // types:
+  // types:
 
   using value_type = _Tp;
 
-  static_assert((is_same<typename _Allocator::value_type, value_type>::value),
-                "Allocator::value_type must be same type as value_type");
-
   using allocator_type = _Allocator;
   using __alloc_traits = allocator_traits<allocator_type>;
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
+  static_assert(is_same<typename allocator_type::value_type, value_type>::value,
+                "Allocator::value_type must be same type as value_type");
 
   using size_type       = typename __alloc_traits::size_type;
   using difference_type = typename __alloc_traits::difference_type;
@@ -480,6 +467,7 @@ public:
   using __map_alloc_traits        = allocator_traits<__pointer_allocator>;
   using __map_pointer             = typename __map_alloc_traits::pointer;
   using __map_const_pointer       = typename allocator_traits<__const_pointer_allocator>::const_pointer;
+  using __map_const_iterator      = typename __map::const_iterator;
 
   using reference       = value_type&;
   using const_reference = const value_type&;
@@ -490,20 +478,28 @@ public:
   using reverse_iterator       = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
-  static_assert(is_same<allocator_type, __rebind_alloc<__alloc_traits, value_type> >::value,
-                "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                "original allocator");
+  // A deque contains the following members which may be trivially relocatable:
+  // - __map: is a `__split_buffer`, see `__split_buffer` for more information on when it is trivially relocatable
+  // - size_type: is always trivially relocatable, since it is required to be an integral type
+  // - allocator_type: may not be trivially relocatable, so it's checked
+  // None of these are referencing the `deque` itself, so if all of them are trivially relocatable, `deque` is too.
+  using __trivially_relocatable = __conditional_t<
+      __libcpp_is_trivially_relocatable<__map>::value && __libcpp_is_trivially_relocatable<allocator_type>::value,
+      deque,
+      void>;
+
   static_assert(is_nothrow_default_constructible<allocator_type>::value ==
                     is_nothrow_default_constructible<__pointer_allocator>::value,
-                "rebinding an allocator should not change excpetion guarantees");
+                "rebinding an allocator should not change exception guarantees");
   static_assert(is_nothrow_move_constructible<allocator_type>::value ==
                     is_nothrow_move_constructible<typename __map::allocator_type>::value,
-                "rebinding an allocator should not change excpetion guarantees");
+                "rebinding an allocator should not change exception guarantees");
 
 private:
   struct __deque_block_range {
-    explicit _LIBCPP_HIDE_FROM_ABI
-    __deque_block_range(pointer __b, pointer __e) _NOEXCEPT : __begin_(__b), __end_(__e) {}
+    explicit _LIBCPP_HIDE_FROM_ABI __deque_block_range(pointer __b, pointer __e) _NOEXCEPT
+        : __begin_(__b),
+          __end_(__e) {}
     const pointer __begin_;
     const pointer __end_;
   };
@@ -512,22 +508,15 @@ private:
     iterator __pos_;
     const iterator __end_;
 
-    _LIBCPP_HIDE_FROM_ABI __deque_range(iterator __pos, iterator __e) _NOEXCEPT
-      : __pos_(__pos), __end_(__e) {}
+    _LIBCPP_HIDE_FROM_ABI __deque_range(iterator __pos, iterator __e) _NOEXCEPT : __pos_(__pos), __end_(__e) {}
 
-    explicit _LIBCPP_HIDE_FROM_ABI operator bool() const _NOEXCEPT {
-      return __pos_ != __end_;
-    }
+    explicit _LIBCPP_HIDE_FROM_ABI operator bool() const _NOEXCEPT { return __pos_ != __end_; }
 
-    _LIBCPP_HIDE_FROM_ABI __deque_range begin() const {
-      return *this;
-    }
+    _LIBCPP_HIDE_FROM_ABI __deque_range begin() const { return *this; }
 
-    _LIBCPP_HIDE_FROM_ABI __deque_range end() const {
-      return __deque_range(__end_, __end_);
-    }
+    _LIBCPP_HIDE_FROM_ABI __deque_range end() const { return __deque_range(__end_, __end_); }
     _LIBCPP_HIDE_FROM_ABI __deque_block_range operator*() const _NOEXCEPT {
-        if (__pos_.__m_iter_ == __end_.__m_iter_) {
+      if (__pos_.__m_iter_ == __end_.__m_iter_) {
         return __deque_block_range(__pos_.__ptr_, __end_.__ptr_);
       }
       return __deque_block_range(__pos_.__ptr_, *__pos_.__m_iter_ + __block_size);
@@ -543,7 +532,6 @@ private:
       return *this;
     }
 
-
     _LIBCPP_HIDE_FROM_ABI friend bool operator==(__deque_range const& __lhs, __deque_range const& __rhs) {
       return __lhs.__pos_ == __rhs.__pos_;
     }
@@ -554,15 +542,13 @@ private:
 
   struct _ConstructTransaction {
     _LIBCPP_HIDE_FROM_ABI _ConstructTransaction(deque* __db, __deque_block_range& __r)
-      : __pos_(__r.__begin_), __end_(__r.__end_), __begin_(__r.__begin_), __base_(__db) {}
+        : __pos_(__r.__begin_), __end_(__r.__end_), __begin_(__r.__begin_), __base_(__db) {}
 
-
-    _LIBCPP_HIDE_FROM_ABI ~_ConstructTransaction() {
-      __base_->__size() += (__pos_ - __begin_);
-    }
+    _LIBCPP_HIDE_FROM_ABI ~_ConstructTransaction() { __base_->__size() += (__pos_ - __begin_); }
 
     pointer __pos_;
     const pointer __end_;
+
   private:
     const pointer __begin_;
     deque* const __base_;
@@ -575,49 +561,49 @@ private:
   __compressed_pair<size_type, allocator_type> __size_;
 
 public:
+  // construct/copy/destroy:
+  _LIBCPP_HIDE_FROM_ABI deque() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
+      : __start_(0), __size_(0, __default_init_tag()) {
+    __annotate_new(0);
+  }
 
-    // construct/copy/destroy:
-    _LIBCPP_HIDE_FROM_ABI
-    deque() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
-        : __start_(0), __size_(0, __default_init_tag()) {}
+  _LIBCPP_HIDE_FROM_ABI ~deque() {
+    clear();
+    __annotate_delete();
+    typename __map::iterator __i = __map_.begin();
+    typename __map::iterator __e = __map_.end();
+    for (; __i != __e; ++__i)
+      __alloc_traits::deallocate(__alloc(), *__i, __block_size);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI ~deque() {
-      clear();
-      typename __map::iterator __i = __map_.begin();
-      typename __map::iterator __e = __map_.end();
-      for (; __i != __e; ++__i)
-          __alloc_traits::deallocate(__alloc(), *__i, __block_size);
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit deque(const allocator_type& __a)
+      : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
+    __annotate_new(0);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI explicit deque(const allocator_type& __a)
-        : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {}
-
-    explicit _LIBCPP_HIDE_FROM_ABI deque(size_type __n);
+  explicit _LIBCPP_HIDE_FROM_ABI deque(size_type __n);
 #if _LIBCPP_STD_VER >= 14
-    explicit _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const _Allocator& __a);
+  explicit _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const _Allocator& __a);
 #endif
-    _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v);
+  _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v);
 
-    template <class = __enable_if_t<__is_allocator<_Allocator>::value> >
-    _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v, const allocator_type& __a)
-        : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
-    {
-        if (__n > 0)
-            __append(__n, __v);
-    }
+  template <__enable_if_t<__is_allocator<_Allocator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v, const allocator_type& __a)
+      : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
+    __annotate_new(0);
+    if (__n > 0)
+      __append(__n, __v);
+  }
 
-    template <class _InputIter>
-    _LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l,
-              typename enable_if<__has_input_iterator_category<_InputIter>::value>::type* = 0);
-    template <class _InputIter>
-    _LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
-              typename enable_if<__has_input_iterator_category<_InputIter>::value>::type* = 0);
+  template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l);
+  template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI deque(_InputIter __f, _InputIter __l, const allocator_type& __a);
 
 #if _LIBCPP_STD_VER >= 23
   template <_ContainerCompatibleRange<_Tp> _Range>
-  _LIBCPP_HIDE_FROM_ABI deque(from_range_t, _Range&& __range,
-      const allocator_type& __a = allocator_type())
-    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
+  _LIBCPP_HIDE_FROM_ABI deque(from_range_t, _Range&& __range, const allocator_type& __a = allocator_type())
+      : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
     if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
       __append_with_size(ranges::begin(__range), ranges::distance(__range));
 
@@ -629,427 +615,590 @@ public:
   }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI deque(const deque& __c);
-    _LIBCPP_HIDE_FROM_ABI deque(const deque& __c, const __type_identity_t<allocator_type>& __a);
+  _LIBCPP_HIDE_FROM_ABI deque(const deque& __c);
+  _LIBCPP_HIDE_FROM_ABI deque(const deque& __c, const __type_identity_t<allocator_type>& __a);
 
-    _LIBCPP_HIDE_FROM_ABI deque& operator=(const deque& __c);
+  _LIBCPP_HIDE_FROM_ABI deque& operator=(const deque& __c);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI deque(initializer_list<value_type> __il);
-    _LIBCPP_HIDE_FROM_ABI deque(initializer_list<value_type> __il, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI deque(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI deque(initializer_list<value_type> __il, const allocator_type& __a);
 
-    _LIBCPP_HIDE_FROM_ABI
-    deque& operator=(initializer_list<value_type> __il) {assign(__il); return *this;}
+  _LIBCPP_HIDE_FROM_ABI deque& operator=(initializer_list<value_type> __il) {
+    assign(__il);
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    deque(deque&& __c) _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
-    _LIBCPP_HIDE_FROM_ABI
-    deque(deque&& __c, const __type_identity_t<allocator_type>& __a);
-    _LIBCPP_HIDE_FROM_ABI
-    deque& operator=(deque&& __c)
-        _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
-                   is_nothrow_move_assignable<allocator_type>::value);
+  _LIBCPP_HIDE_FROM_ABI deque(deque&& __c) noexcept(is_nothrow_move_constructible<allocator_type>::value);
+  _LIBCPP_HIDE_FROM_ABI deque(deque&& __c, const __type_identity_t<allocator_type>& __a);
+  _LIBCPP_HIDE_FROM_ABI deque&
+  operator=(deque&& __c) noexcept(__alloc_traits::propagate_on_container_move_assignment::value &&
+                                  is_nothrow_move_assignable<allocator_type>::value);
 
-    _LIBCPP_HIDE_FROM_ABI
-    void assign(initializer_list<value_type> __il) {assign(__il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI void assign(initializer_list<value_type> __il) { assign(__il.begin(), __il.end()); }
 #endif // _LIBCPP_CXX03_LANG
 
-    template <class _InputIter>
-    _LIBCPP_HIDE_FROM_ABI void assign(_InputIter __f, _InputIter __l,
-                    typename enable_if<__has_input_iterator_category<_InputIter>::value &&
-                                      !__has_random_access_iterator_category<_InputIter>::value>::type* = 0);
-    template <class _RAIter>
-    _LIBCPP_HIDE_FROM_ABI void assign(_RAIter __f, _RAIter __l,
-                    typename enable_if<__has_random_access_iterator_category<_RAIter>::value>::type* = 0);
+  template <class _InputIter,
+            __enable_if_t<__has_input_iterator_category<_InputIter>::value &&
+                              !__has_random_access_iterator_category<_InputIter>::value,
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void assign(_InputIter __f, _InputIter __l);
+  template <class _RAIter, __enable_if_t<__has_random_access_iterator_category<_RAIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void assign(_RAIter __f, _RAIter __l);
 
 #if _LIBCPP_STD_VER >= 23
-    template <_ContainerCompatibleRange<_Tp> _Range>
-    _LIBCPP_HIDE_FROM_ABI
-    void assign_range(_Range&& __range) {
-      if constexpr (ranges::random_access_range<_Range>) {
-        auto __n = static_cast<size_type>(ranges::distance(__range));
-        __assign_with_size_random_access(ranges::begin(__range), __n);
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void assign_range(_Range&& __range) {
+    if constexpr (ranges::random_access_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      __assign_with_size_random_access(ranges::begin(__range), __n);
 
-      } else if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
-        auto __n = static_cast<size_type>(ranges::distance(__range));
-        __assign_with_size(ranges::begin(__range), __n);
+    } else if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      __assign_with_size(ranges::begin(__range), __n);
 
-      } else {
-        __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
-      }
+    } else {
+      __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
     }
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __v);
+  _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __v);
 
-    _LIBCPP_HIDE_FROM_ABI
-    allocator_type get_allocator() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI allocator_type& __alloc() _NOEXCEPT { return __size_.second(); }
   _LIBCPP_HIDE_FROM_ABI const allocator_type& __alloc() const _NOEXCEPT { return __size_.second(); }
 
   // iterators:
 
   _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT {
-      __map_pointer __mp = __map_.begin() + __start_ / __block_size;
-      return iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);
+    __map_pointer __mp = __map_.begin() + __start_ / __block_size;
+    return iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);
   }
 
   _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT {
-      __map_const_pointer __mp =
-          static_cast<__map_const_pointer>(__map_.begin() + __start_ / __block_size);
-      return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);
+    __map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __start_ / __block_size);
+    return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);
   }
 
   _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT {
-      size_type __p      = size() + __start_;
-      __map_pointer __mp = __map_.begin() + __p / __block_size;
-      return iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
+    size_type __p      = size() + __start_;
+    __map_pointer __mp = __map_.begin() + __p / __block_size;
+    return iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
   }
 
   _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT {
-      size_type __p            = size() + __start_;
-      __map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __block_size);
-      return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
+    size_type __p            = size() + __start_;
+    __map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __block_size);
+    return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
   }
 
-    _LIBCPP_HIDE_FROM_ABI
-    reverse_iterator       rbegin() _NOEXCEPT
-        {return       reverse_iterator(end());}
-    _LIBCPP_HIDE_FROM_ABI
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_HIDE_FROM_ABI
-    reverse_iterator       rend() _NOEXCEPT
-        {return       reverse_iterator(begin());}
-    _LIBCPP_HIDE_FROM_ABI
-    const_reverse_iterator rend()   const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    const_iterator         cbegin()  const _NOEXCEPT
-        {return begin();}
-    _LIBCPP_HIDE_FROM_ABI
-    const_iterator         cend()    const _NOEXCEPT
-        {return end();}
-    _LIBCPP_HIDE_FROM_ABI
-    const_reverse_iterator crbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_HIDE_FROM_ABI
-    const_reverse_iterator crend()   const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return const_reverse_iterator(begin()); }
 
-    // capacity:
-    _LIBCPP_HIDE_FROM_ABI
-    size_type size() const _NOEXCEPT {return __size();}
+  // capacity:
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size(); }
 
   _LIBCPP_HIDE_FROM_ABI size_type& __size() _NOEXCEPT { return __size_.first(); }
   _LIBCPP_HIDE_FROM_ABI const size_type& __size() const _NOEXCEPT { return __size_.first(); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    size_type max_size() const _NOEXCEPT
-        {return _VSTD::min<size_type>(
-            __alloc_traits::max_size(__alloc()),
-            numeric_limits<difference_type>::max());}
-    _LIBCPP_HIDE_FROM_ABI void resize(size_type __n);
-    _LIBCPP_HIDE_FROM_ABI void resize(size_type __n, const value_type& __v);
-    _LIBCPP_HIDE_FROM_ABI void shrink_to_fit() _NOEXCEPT;
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI
-    bool empty() const _NOEXCEPT {return size() == 0;}
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+    return std::min<size_type>(__alloc_traits::max_size(__alloc()), numeric_limits<difference_type>::max());
+  }
+  _LIBCPP_HIDE_FROM_ABI void resize(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI void resize(size_type __n, const value_type& __v);
+  _LIBCPP_HIDE_FROM_ABI void shrink_to_fit() _NOEXCEPT;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return size() == 0; }
 
-    // element access:
-    _LIBCPP_HIDE_FROM_ABI
-    reference operator[](size_type __i) _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI
-    const_reference operator[](size_type __i) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI
-    reference at(size_type __i);
-    _LIBCPP_HIDE_FROM_ABI
-    const_reference at(size_type __i) const;
-    _LIBCPP_HIDE_FROM_ABI
-    reference front() _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI
-    const_reference front() const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI
-    reference back() _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI
-    const_reference back() const _NOEXCEPT;
+  // element access:
+  _LIBCPP_HIDE_FROM_ABI reference operator[](size_type __i) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __i) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI reference at(size_type __i);
+  _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __i) const;
+  _LIBCPP_HIDE_FROM_ABI reference front() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI reference back() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT;
 
-    // 23.2.2.3 modifiers:
-    _LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __v);
-    _LIBCPP_HIDE_FROM_ABI void push_back(const value_type& __v);
+  // 23.2.2.3 modifiers:
+  _LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __v);
+  _LIBCPP_HIDE_FROM_ABI void push_back(const value_type& __v);
 #ifndef _LIBCPP_CXX03_LANG
-#if _LIBCPP_STD_VER >= 17
-    template <class... _Args> _LIBCPP_HIDE_FROM_ABI reference emplace_front(_Args&&... __args);
-    template <class... _Args> _LIBCPP_HIDE_FROM_ABI reference emplace_back (_Args&&... __args);
-#else
-    template <class... _Args> _LIBCPP_HIDE_FROM_ABI void      emplace_front(_Args&&... __args);
-    template <class... _Args> _LIBCPP_HIDE_FROM_ABI void      emplace_back (_Args&&... __args);
-#endif
-    template <class... _Args> _LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __p, _Args&&... __args);
+#  if _LIBCPP_STD_VER >= 17
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI reference emplace_front(_Args&&... __args);
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI reference emplace_back(_Args&&... __args);
+#  else
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void emplace_front(_Args&&... __args);
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void emplace_back(_Args&&... __args);
+#  endif
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __p, _Args&&... __args);
 
-    _LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __v);
-    _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __v);
+  _LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __v);
+  _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __v);
 
-#if _LIBCPP_STD_VER >= 23
-    template <_ContainerCompatibleRange<_Tp> _Range>
-    _LIBCPP_HIDE_FROM_ABI
-    void prepend_range(_Range&& __range) {
-      insert_range(begin(), std::forward<_Range>(__range));
-    }
+#  if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void prepend_range(_Range&& __range) {
+    insert_range(begin(), std::forward<_Range>(__range));
+  }
 
-    template <_ContainerCompatibleRange<_Tp> _Range>
-    _LIBCPP_HIDE_FROM_ABI
-    void append_range(_Range&& __range) {
-      insert_range(end(), std::forward<_Range>(__range));
-    }
-#endif
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void append_range(_Range&& __range) {
+    insert_range(end(), std::forward<_Range>(__range));
+  }
+#  endif
 
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v);
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v);
 
-    _LIBCPP_HIDE_FROM_ABI
-    iterator insert(const_iterator __p, initializer_list<value_type> __il)
-        {return insert(__p, __il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, initializer_list<value_type> __il) {
+    return insert(__p, __il.begin(), __il.end());
+  }
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v);
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, size_type __n, const value_type& __v);
-    template <class _InputIter>
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _InputIter __f, _InputIter __l,
-                         typename enable_if<__has_exactly_input_iterator_category<_InputIter>::value>::type* = 0);
-    template <class _ForwardIterator>
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
-                        typename enable_if<__has_exactly_forward_iterator_category<_ForwardIterator>::value>::type* = 0);
-    template <class _BiIter>
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _BiIter __f, _BiIter __l,
-                         typename enable_if<__has_bidirectional_iterator_category<_BiIter>::value>::type* = 0);
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v);
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, size_type __n, const value_type& __v);
+  template <class _InputIter, __enable_if_t<__has_exactly_input_iterator_category<_InputIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _InputIter __f, _InputIter __l);
+  template <class _ForwardIterator,
+            __enable_if_t<__has_exactly_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l);
+  template <class _BiIter, __enable_if_t<__has_bidirectional_iterator_category<_BiIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _BiIter __f, _BiIter __l);
 
 #if _LIBCPP_STD_VER >= 23
-    template <_ContainerCompatibleRange<_Tp> _Range>
-    _LIBCPP_HIDE_FROM_ABI
-    iterator insert_range(const_iterator __position, _Range&& __range) {
-      if constexpr (ranges::bidirectional_range<_Range>) {
-        auto __n = static_cast<size_type>(ranges::distance(__range));
-        return __insert_bidirectional(__position, ranges::begin(__range), ranges::end(__range), __n);
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI iterator insert_range(const_iterator __position, _Range&& __range) {
+    if constexpr (ranges::bidirectional_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      return __insert_bidirectional(__position, ranges::begin(__range), ranges::end(__range), __n);
 
-      } else if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
-        auto __n = static_cast<size_type>(ranges::distance(__range));
-        return __insert_with_size(__position, ranges::begin(__range), __n);
+    } else if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      return __insert_with_size(__position, ranges::begin(__range), __n);
 
-      } else {
-        return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
-      }
+    } else {
+      return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
     }
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI void pop_front();
-    _LIBCPP_HIDE_FROM_ABI void pop_back();
-    _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
-    _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l);
+  _LIBCPP_HIDE_FROM_ABI void pop_front();
+  _LIBCPP_HIDE_FROM_ABI void pop_back();
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l);
 
-    _LIBCPP_HIDE_FROM_ABI
-    void swap(deque& __c)
+  _LIBCPP_HIDE_FROM_ABI void swap(deque& __c)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT;
+      _NOEXCEPT;
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                   __is_nothrow_swappable<allocator_type>::value);
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>);
 #endif
-    _LIBCPP_HIDE_FROM_ABI
-    void clear() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI
-    bool __invariants() const {
-        if (!__map_.__invariants())
-            return false;
-        if (__map_.size() >= size_type(-1) / __block_size)
-            return false;
-        for (typename __map::const_iterator __i = __map_.begin(), __e = __map_.end();
-            __i != __e; ++__i)
-            if (*__i == nullptr)
-                return false;
-        if (__map_.size() != 0)
-        {
-            if (size() >= __map_.size() * __block_size)
-                return false;
-            if (__start_ >= __map_.size() * __block_size - size())
-                return false;
-        }
-        else
-        {
-            if (size() != 0)
-                return false;
-            if (__start_ != 0)
-                return false;
-        }
-        return true;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    void __move_assign_alloc(deque& __c)
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_move_assignment::value ||
-                   is_nothrow_move_assignable<allocator_type>::value)
-        {__move_assign_alloc(__c, integral_constant<bool,
-                      __alloc_traits::propagate_on_container_move_assignment::value>());}
-
-    _LIBCPP_HIDE_FROM_ABI
-    void __move_assign_alloc(deque& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-        {
-            __alloc() = _VSTD::move(__c.__alloc());
-        }
-
-    _LIBCPP_HIDE_FROM_ABI
-    void __move_assign_alloc(deque&, false_type) _NOEXCEPT
-        {}
-
-    _LIBCPP_HIDE_FROM_ABI
-    void __move_assign(deque& __c)
-        _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
-                   is_nothrow_move_assignable<allocator_type>::value)
-    {
-        __map_ = _VSTD::move(__c.__map_);
-        __start_ = __c.__start_;
-        __size() = __c.size();
-        __move_assign_alloc(__c);
-        __c.__start_ = __c.__size() = 0;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    static size_type __recommend_blocks(size_type __n)
-    {
-        return __n / __block_size + (__n % __block_size != 0);
-    }
-    _LIBCPP_HIDE_FROM_ABI
-    size_type __capacity() const
-    {
-        return __map_.size() == 0 ? 0 : __map_.size() * __block_size - 1;
-    }
-    _LIBCPP_HIDE_FROM_ABI
-    size_type __block_count() const
-    {
-        return __map_.size();
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    size_type __front_spare() const
-    {
-        return __start_;
-    }
-    _LIBCPP_HIDE_FROM_ABI
-    size_type __front_spare_blocks() const {
-      return __front_spare() / __block_size;
-    }
-    _LIBCPP_HIDE_FROM_ABI
-    size_type __back_spare() const
-    {
-        return __capacity() - (__start_ + size());
-    }
-    _LIBCPP_HIDE_FROM_ABI
-    size_type __back_spare_blocks() const {
-      return __back_spare() / __block_size;
-    }
-
- private:
-    _LIBCPP_HIDE_FROM_ABI
-    bool __maybe_remove_front_spare(bool __keep_one = true) {
-      if (__front_spare_blocks() >= 2 || (!__keep_one && __front_spare_blocks())) {
-        __alloc_traits::deallocate(__alloc(), __map_.front(),
-                                   __block_size);
-        __map_.pop_front();
-        __start_ -= __block_size;
-        return true;
-      }
+  _LIBCPP_HIDE_FROM_ABI bool __invariants() const {
+    if (!__map_.__invariants())
       return false;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI
-    bool __maybe_remove_back_spare(bool __keep_one = true) {
-      if (__back_spare_blocks() >= 2 || (!__keep_one && __back_spare_blocks())) {
-        __alloc_traits::deallocate(__alloc(), __map_.back(),
-                                   __block_size);
-        __map_.pop_back();
-        return true;
-      }
+    if (__map_.size() >= size_type(-1) / __block_size)
       return false;
+    for (__map_const_iterator __i = __map_.begin(), __e = __map_.end(); __i != __e; ++__i)
+      if (*__i == nullptr)
+        return false;
+    if (__map_.size() != 0) {
+      if (size() >= __map_.size() * __block_size)
+        return false;
+      if (__start_ >= __map_.size() * __block_size - size())
+        return false;
+    } else {
+      if (size() != 0)
+        return false;
+      if (__start_ != 0)
+        return false;
+    }
+    return true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(deque& __c)
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_move_assignment::value ||
+                 is_nothrow_move_assignable<allocator_type>::value) {
+    __move_assign_alloc(__c, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(deque& __c, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
+    __alloc() = std::move(__c.__alloc());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(deque&, false_type) _NOEXCEPT {}
+
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(deque& __c)
+      _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value&&
+                     is_nothrow_move_assignable<allocator_type>::value) {
+    __map_   = std::move(__c.__map_);
+    __start_ = __c.__start_;
+    __size() = __c.size();
+    __move_assign_alloc(__c);
+    __c.__start_ = __c.__size() = 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI static size_type __recommend_blocks(size_type __n) {
+    return __n / __block_size + (__n % __block_size != 0);
+  }
+  _LIBCPP_HIDE_FROM_ABI size_type __capacity() const {
+    return __map_.size() == 0 ? 0 : __map_.size() * __block_size - 1;
+  }
+  _LIBCPP_HIDE_FROM_ABI size_type __block_count() const { return __map_.size(); }
+
+  _LIBCPP_HIDE_FROM_ABI size_type __front_spare() const { return __start_; }
+  _LIBCPP_HIDE_FROM_ABI size_type __front_spare_blocks() const { return __front_spare() / __block_size; }
+  _LIBCPP_HIDE_FROM_ABI size_type __back_spare() const { return __capacity() - (__start_ + size()); }
+  _LIBCPP_HIDE_FROM_ABI size_type __back_spare_blocks() const { return __back_spare() / __block_size; }
+
+private:
+  enum __asan_annotation_type { __asan_unposion, __asan_poison };
+
+  enum __asan_annotation_place {
+    __asan_front_moved,
+    __asan_back_moved,
+  };
+
+  _LIBCPP_HIDE_FROM_ABI void __annotate_from_to(
+      size_type __beg,
+      size_type __end,
+      __asan_annotation_type __annotation_type,
+      __asan_annotation_place __place) const _NOEXCEPT {
+    (void)__beg;
+    (void)__end;
+    (void)__annotation_type;
+    (void)__place;
+#ifndef _LIBCPP_HAS_NO_ASAN
+    // __beg - index of the first item to annotate
+    // __end - index behind the last item to annotate (so last item + 1)
+    // __annotation_type - __asan_unposion or __asan_poison
+    // __place - __asan_front_moved or __asan_back_moved
+    // Note: All indexes in __map_
+    if (__beg == __end)
+      return;
+    // __annotations_beg_map - first chunk which annotations we want to modify
+    // __annotations_end_map - last chunk which annotations we want to modify
+    // NOTE: if __end % __block_size == 0, __annotations_end_map points at the next block, which may not exist
+    __map_const_iterator __annotations_beg_map = __map_.begin() + __beg / __block_size;
+    __map_const_iterator __annotations_end_map = __map_.begin() + __end / __block_size;
+
+    bool const __poisoning = __annotation_type == __asan_poison;
+    // __old_c_beg_index - index of the first element in old container
+    // __old_c_end_index - index of the end of old container (last + 1)
+    // Note: may be outside the area we are annotating
+    size_t __old_c_beg_index = (__poisoning && __place == __asan_front_moved) ? __beg : __start_;
+    size_t __old_c_end_index = (__poisoning && __place == __asan_back_moved) ? __end : __start_ + size();
+    bool const __front       = __place == __asan_front_moved;
+
+    if (__poisoning && empty()) {
+      // Special case: we shouldn't trust __start_
+      __old_c_beg_index = __beg;
+      __old_c_end_index = __end;
+    }
+    // __old_c_beg_map - memory block (chunk) with first element
+    // __old_c_end_map - memory block (chunk) with end of old container
+    // Note: if __old_c_end_index % __block_size == 0, __old_c_end_map points at the next block,
+    // which may not exist
+    __map_const_iterator __old_c_beg_map = __map_.begin() + __old_c_beg_index / __block_size;
+    __map_const_iterator __old_c_end_map = __map_.begin() + __old_c_end_index / __block_size;
+
+    // One edge (front/end) of the container was moved and one was not modified.
+    // __new_edge_index - index of new edge
+    // __new_edge_map    - memory block (chunk) with new edge, it always equals to
+    //                    __annotations_beg_map or __annotations_end_map
+    // __old_edge_map    - memory block (chunk) with old edge, it always equals to
+    //                    __old_c_beg_map or __old_c_end_map
+    size_t __new_edge_index             = (__poisoning ^ __front) ? __beg : __end;
+    __map_const_iterator __new_edge_map = __map_.begin() + __new_edge_index / __block_size;
+    __map_const_iterator __old_edge_map = __front ? __old_c_end_map : __old_c_beg_map;
+
+    // We iterate over map pointers (chunks) and fully poison all memory blocks between the first and the last.
+    // First and last chunk may be partially poisoned.
+    // __annotate_end_map may point at not existing chunk, therefore we have to have a check for it.
+    for (__map_const_iterator __map_it = __annotations_beg_map; __map_it <= __annotations_end_map; ++__map_it) {
+      if (__map_it == __annotations_end_map && __end % __block_size == 0)
+        // Chunk may not exist, but nothing to do here anyway
+        break;
+
+      // The beginning and the end of the current memory block
+      const void* __mem_beg = std::__to_address(*__map_it);
+      const void* __mem_end = std::__to_address(*__map_it + __block_size);
+
+      // The beginning of memory-in-use in the memory block before container modification
+      const void* __old_beg =
+          (__map_it == __old_c_beg_map) ? std::__to_address(*__map_it + (__old_c_beg_index % __block_size)) : __mem_beg;
+
+      // The end of memory-in-use in the memory block before container modification
+      const void* __old_end;
+      if (__map_it < __old_c_beg_map || __map_it > __old_c_end_map || (!__poisoning && empty()))
+        __old_end = __old_beg;
+      else
+        __old_end = (__map_it == __old_c_end_map)
+                      ? std::__to_address(*__map_it + (__old_c_end_index % __block_size))
+                      : __mem_end;
+
+      // New edge of the container in current memory block
+      // If the edge is in a different chunk it points on corresponding end of the memory block
+      const void* __new_edge;
+      if (__map_it == __new_edge_map)
+        __new_edge = std::__to_address(*__map_it + (__new_edge_index % __block_size));
+      else
+        __new_edge = (__poisoning ^ __front) ? __mem_beg : __mem_end;
+
+      // Not modified edge of the container
+      // If the edge is in a different chunk it points on corresponding end of the memory block
+      const void* __old_edge;
+      if (__map_it == __old_edge_map)
+        __old_edge = __front ? __old_end : __old_beg;
+      else
+        __old_edge = __front ? __mem_end : __mem_beg;
+
+      // __new_beg - the beginning of memory-in-use in the memory block after container modification
+      // __new_end - the end of memory-in-use in the memory block after container modification
+      const void* __new_beg = __front ? __new_edge : __old_edge;
+      const void* __new_end = __front ? __old_edge : __new_edge;
+
+      std::__annotate_double_ended_contiguous_container<_Allocator>(
+          __mem_beg, __mem_end, __old_beg, __old_end, __new_beg, __new_end);
+    }
+#endif // !_LIBCPP_HAS_NO_ASAN
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __annotate_new(size_type __current_size) const _NOEXCEPT {
+    (void)__current_size;
+#ifndef _LIBCPP_HAS_NO_ASAN
+    if (__current_size == 0)
+      __annotate_from_to(0, __map_.size() * __block_size, __asan_poison, __asan_back_moved);
+    else {
+      __annotate_from_to(0, __start_, __asan_poison, __asan_front_moved);
+      __annotate_from_to(__start_ + __current_size, __map_.size() * __block_size, __asan_poison, __asan_back_moved);
+    }
+#endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __annotate_delete() const _NOEXCEPT {
+#ifndef _LIBCPP_HAS_NO_ASAN
+    if (empty()) {
+      for (size_t __i = 0; __i < __map_.size(); ++__i) {
+        __annotate_whole_block(__i, __asan_unposion);
+      }
+    } else {
+      __annotate_from_to(0, __start_, __asan_unposion, __asan_front_moved);
+      __annotate_from_to(__start_ + size(), __map_.size() * __block_size, __asan_unposion, __asan_back_moved);
+    }
+#endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __annotate_increase_front(size_type __n) const _NOEXCEPT {
+    (void)__n;
+#ifndef _LIBCPP_HAS_NO_ASAN
+    __annotate_from_to(__start_ - __n, __start_, __asan_unposion, __asan_front_moved);
+#endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __annotate_increase_back(size_type __n) const _NOEXCEPT {
+    (void)__n;
+#ifndef _LIBCPP_HAS_NO_ASAN
+    __annotate_from_to(__start_ + size(), __start_ + size() + __n, __asan_unposion, __asan_back_moved);
+#endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __annotate_shrink_front(size_type __old_size, size_type __old_start) const _NOEXCEPT {
+    (void)__old_size;
+    (void)__old_start;
+#ifndef _LIBCPP_HAS_NO_ASAN
+    __annotate_from_to(__old_start, __old_start + (__old_size - size()), __asan_poison, __asan_front_moved);
+#endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __annotate_shrink_back(size_type __old_size, size_type __old_start) const _NOEXCEPT {
+    (void)__old_size;
+    (void)__old_start;
+#ifndef _LIBCPP_HAS_NO_ASAN
+    __annotate_from_to(__old_start + size(), __old_start + __old_size, __asan_poison, __asan_back_moved);
+#endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __annotate_poison_block(const void* __beginning, const void* __end) const _NOEXCEPT {
+    std::__annotate_double_ended_contiguous_container<_Allocator>(__beginning, __end, __beginning, __end, __end, __end);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void
+  __annotate_whole_block(size_t __block_index, __asan_annotation_type __annotation_type) const _NOEXCEPT {
+    (void)__block_index;
+    (void)__annotation_type;
+#ifndef _LIBCPP_HAS_NO_ASAN
+    __map_const_iterator __block_it = __map_.begin() + __block_index;
+    const void* __block_start       = std::__to_address(*__block_it);
+    const void* __block_end         = std::__to_address(*__block_it + __block_size);
+
+    if (__annotation_type == __asan_poison)
+      __annotate_poison_block(__block_start, __block_end);
+    else {
+      std::__annotate_double_ended_contiguous_container<_Allocator>(
+          __block_start, __block_end, __block_start, __block_start, __block_start, __block_end);
+    }
+#endif
+  }
+#if !defined(_LIBCPP_HAS_NO_ASAN)
+
+public:
+  _LIBCPP_HIDE_FROM_ABI bool __verify_asan_annotations() const _NOEXCEPT {
+    // This function tests deque object annotations.
+    if (empty()) {
+      for (__map_const_iterator __it = __map_.begin(); __it != __map_.end(); ++__it) {
+        if (!__sanitizer_verify_double_ended_contiguous_container(
+                std::__to_address(*__it),
+                std::__to_address(*__it),
+                std::__to_address(*__it),
+                std::__to_address(*__it + __block_size)))
+          return false;
+      }
+
+      return true;
     }
 
-    template <class _Iterator, class _Sentinel>
-    _LIBCPP_HIDE_FROM_ABI
-    void __assign_with_sentinel(_Iterator __f, _Sentinel __l);
+    size_type __end                 = __start_ + size();
+    __map_const_iterator __first_mp = __map_.begin() + __start_ / __block_size;
+    __map_const_iterator __last_mp  = __map_.begin() + (__end - 1) / __block_size;
 
-    template <class _RandomAccessIterator>
-    _LIBCPP_HIDE_FROM_ABI
-    void __assign_with_size_random_access(_RandomAccessIterator __f, difference_type __n);
-    template <class _Iterator>
-    _LIBCPP_HIDE_FROM_ABI
-    void __assign_with_size(_Iterator __f, difference_type __n);
+    // Pointers to first and after last elements
+    // Those can be in different deque blocks
+    const void* __p_beg = std::__to_address(*__first_mp + (__start_ % __block_size));
+    const void* __p_end =
+        std::__to_address(*__last_mp + ((__end % __block_size == 0) ? __block_size : __end % __block_size));
 
-    template <class _Iterator, class _Sentinel>
-    _LIBCPP_HIDE_FROM_ABI
-    iterator __insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l);
+    for (__map_const_iterator __it = __map_.begin(); __it != __map_.end(); ++__it) {
+      // Go over all blocks, find the place we are in and verify its annotations
+      // Note that __p_end points *behind* the last item.
 
-    template <class _Iterator>
-    _LIBCPP_HIDE_FROM_ABI
-    iterator __insert_with_size(const_iterator __p, _Iterator __f, size_type __n);
+      // - blocks before the first block with container elements
+      // - first block with items
+      // - last block with items
+      // - blocks after last block with ciontainer elements
 
-    template <class _BiIter, class _Sentinel>
-    _LIBCPP_HIDE_FROM_ABI
-    iterator __insert_bidirectional(const_iterator __p, _BiIter __f, _Sentinel __sent, size_type __n);
-    template <class _BiIter>
-    _LIBCPP_HIDE_FROM_ABI
-    iterator __insert_bidirectional(const_iterator __p, _BiIter __f, _BiIter __l, size_type __n);
-
-    template <class _InpIter>
-    _LIBCPP_HIDE_FROM_ABI void __append(_InpIter __f, _InpIter __l,
-                 typename enable_if<__has_exactly_input_iterator_category<_InpIter>::value>::type* = 0);
-    template <class _ForIter>
-    _LIBCPP_HIDE_FROM_ABI void __append(_ForIter __f, _ForIter __l,
-                      typename enable_if<__has_forward_iterator_category<_ForIter>::value>::type* = 0);
-
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI void __append_with_size(_InputIterator __from, size_type __n);
-    template <class _InputIterator, class _Sentinel>
-    _LIBCPP_HIDE_FROM_ABI void __append_with_sentinel(_InputIterator __f, _Sentinel __l);
-
-    _LIBCPP_HIDE_FROM_ABI void __append(size_type __n);
-    _LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const value_type& __v);
-    _LIBCPP_HIDE_FROM_ABI void __erase_to_end(const_iterator __f);
-    _LIBCPP_HIDE_FROM_ABI void __add_front_capacity();
-    _LIBCPP_HIDE_FROM_ABI void __add_front_capacity(size_type __n);
-    _LIBCPP_HIDE_FROM_ABI void __add_back_capacity();
-    _LIBCPP_HIDE_FROM_ABI void __add_back_capacity(size_type __n);
-    _LIBCPP_HIDE_FROM_ABI iterator __move_and_check(iterator __f, iterator __l, iterator __r,
-                              const_pointer& __vt);
-    _LIBCPP_HIDE_FROM_ABI iterator __move_backward_and_check(iterator __f, iterator __l, iterator __r,
-                                       const_pointer& __vt);
-    _LIBCPP_HIDE_FROM_ABI void __move_construct_and_check(iterator __f, iterator __l,
-                                    iterator __r, const_pointer& __vt);
-    _LIBCPP_HIDE_FROM_ABI void __move_construct_backward_and_check(iterator __f, iterator __l,
-                                             iterator __r, const_pointer& __vt);
-
-    _LIBCPP_HIDE_FROM_ABI
-    void __copy_assign_alloc(const deque& __c)
-        {__copy_assign_alloc(__c, integral_constant<bool,
-                      __alloc_traits::propagate_on_container_copy_assignment::value>());}
-
-    _LIBCPP_HIDE_FROM_ABI
-    void __copy_assign_alloc(const deque& __c, true_type)
-        {
-            if (__alloc() != __c.__alloc())
-            {
-                clear();
-                shrink_to_fit();
-            }
-            __alloc() = __c.__alloc();
-            __map_.__alloc() = __c.__map_.__alloc();
+      // Is the block before or after deque blocks that contain elements?
+      if (__it < __first_mp || __it > __last_mp) {
+        if (!__sanitizer_verify_double_ended_contiguous_container(
+                std::__to_address(*__it),
+                std::__to_address(*__it),
+                std::__to_address(*__it),
+                std::__to_address(*__it + __block_size)))
+          return false;
+      } else {
+        const void* __containers_buffer_beg = (__it == __first_mp) ? __p_beg : (const void*)std::__to_address(*__it);
+        const void* __containers_buffer_end =
+            (__it == __last_mp) ? __p_end : (const void*)std::__to_address(*__it + __block_size);
+        if (!__sanitizer_verify_double_ended_contiguous_container(
+                std::__to_address(*__it),
+                __containers_buffer_beg,
+                __containers_buffer_end,
+                std::__to_address(*__it + __block_size))) {
+          return false;
         }
+      }
+    }
+    return true;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI
-    void __copy_assign_alloc(const deque&, false_type)
-        {}
+private:
+#endif // _LIBCPP_VERIFY_ASAN_DEQUE_ANNOTATIONS
+  _LIBCPP_HIDE_FROM_ABI bool __maybe_remove_front_spare(bool __keep_one = true) {
+    if (__front_spare_blocks() >= 2 || (!__keep_one && __front_spare_blocks())) {
+      __annotate_whole_block(0, __asan_unposion);
+      __alloc_traits::deallocate(__alloc(), __map_.front(), __block_size);
+      __map_.pop_front();
+      __start_ -= __block_size;
+      return true;
+    }
+    return false;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI void __move_assign(deque& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
-    _LIBCPP_HIDE_FROM_ABI void __move_assign(deque& __c, false_type);
+  _LIBCPP_HIDE_FROM_ABI bool __maybe_remove_back_spare(bool __keep_one = true) {
+    if (__back_spare_blocks() >= 2 || (!__keep_one && __back_spare_blocks())) {
+      __annotate_whole_block(__map_.size() - 1, __asan_unposion);
+      __alloc_traits::deallocate(__alloc(), __map_.back(), __block_size);
+      __map_.pop_back();
+      return true;
+    }
+    return false;
+  }
+
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI void __assign_with_sentinel(_Iterator __f, _Sentinel __l);
+
+  template <class _RandomAccessIterator>
+  _LIBCPP_HIDE_FROM_ABI void __assign_with_size_random_access(_RandomAccessIterator __f, difference_type __n);
+  template <class _Iterator>
+  _LIBCPP_HIDE_FROM_ABI void __assign_with_size(_Iterator __f, difference_type __n);
+
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l);
+
+  template <class _Iterator>
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_with_size(const_iterator __p, _Iterator __f, size_type __n);
+
+  template <class _BiIter, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI iterator
+  __insert_bidirectional(const_iterator __p, _BiIter __f, _Sentinel __sent, size_type __n);
+  template <class _BiIter>
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_bidirectional(const_iterator __p, _BiIter __f, _BiIter __l, size_type __n);
+
+  template <class _InpIter, __enable_if_t<__has_exactly_input_iterator_category<_InpIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void __append(_InpIter __f, _InpIter __l);
+  template <class _ForIter, __enable_if_t<__has_forward_iterator_category<_ForIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void __append(_ForIter __f, _ForIter __l);
+
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void __append_with_size(_InputIterator __from, size_type __n);
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI void __append_with_sentinel(_InputIterator __f, _Sentinel __l);
+
+  _LIBCPP_HIDE_FROM_ABI void __append(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const value_type& __v);
+  _LIBCPP_HIDE_FROM_ABI void __erase_to_end(const_iterator __f);
+  _LIBCPP_HIDE_FROM_ABI void __add_front_capacity();
+  _LIBCPP_HIDE_FROM_ABI void __add_front_capacity(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI void __add_back_capacity();
+  _LIBCPP_HIDE_FROM_ABI void __add_back_capacity(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI iterator __move_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt);
+  _LIBCPP_HIDE_FROM_ABI iterator
+  __move_backward_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt);
+  _LIBCPP_HIDE_FROM_ABI void __move_construct_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt);
+  _LIBCPP_HIDE_FROM_ABI void
+  __move_construct_backward_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt);
+
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const deque& __c) {
+    __copy_assign_alloc(__c, integral_constant<bool, __alloc_traits::propagate_on_container_copy_assignment::value>());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const deque& __c, true_type) {
+    if (__alloc() != __c.__alloc()) {
+      clear();
+      shrink_to_fit();
+    }
+    __alloc()        = __c.__alloc();
+    __map_.__alloc() = __c.__map_.__alloc();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const deque&, false_type) {}
+
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(deque& __c, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(deque& __c, false_type);
 };
 
 template <class _Tp, class _Alloc>
@@ -1057,240 +1206,199 @@ _LIBCPP_CONSTEXPR const typename allocator_traits<_Alloc>::difference_type deque
     __deque_block_size<value_type, difference_type>::value;
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Alloc = allocator<__iter_value_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Alloc>::value>
-         >
-deque(_InputIterator, _InputIterator)
-  -> deque<__iter_value_type<_InputIterator>, _Alloc>;
+template <class _InputIterator,
+          class _Alloc = allocator<__iter_value_type<_InputIterator>>,
+          class        = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+deque(_InputIterator, _InputIterator) -> deque<__iter_value_type<_InputIterator>, _Alloc>;
 
-template<class _InputIterator,
-         class _Alloc,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Alloc>::value>
-         >
-deque(_InputIterator, _InputIterator, _Alloc)
-  -> deque<__iter_value_type<_InputIterator>, _Alloc>;
+template <class _InputIterator,
+          class _Alloc,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Alloc>::value> >
+deque(_InputIterator, _InputIterator, _Alloc) -> deque<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
 #if _LIBCPP_STD_VER >= 23
 template <ranges::input_range _Range,
           class _Alloc = allocator<ranges::range_value_t<_Range>>,
-          class = enable_if_t<__is_allocator<_Alloc>::value>
-          >
-deque(from_range_t, _Range&&, _Alloc = _Alloc())
-  -> deque<ranges::range_value_t<_Range>, _Alloc>;
+          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+deque(from_range_t, _Range&&, _Alloc = _Alloc()) -> deque<ranges::range_value_t<_Range>, _Alloc>;
 #endif
 
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>::deque(size_type __n)
-    : __start_(0), __size_(0, __default_init_tag())
-{
-    if (__n > 0)
-        __append(__n);
+deque<_Tp, _Allocator>::deque(size_type __n) : __start_(0), __size_(0, __default_init_tag()) {
+  __annotate_new(0);
+  if (__n > 0)
+    __append(__n);
 }
 
 #if _LIBCPP_STD_VER >= 14
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(size_type __n, const _Allocator& __a)
-    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
-{
-    if (__n > 0)
-        __append(__n);
+    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
+  __annotate_new(0);
+  if (__n > 0)
+    __append(__n);
 }
 #endif
 
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v)
-    : __start_(0), __size_(0, __default_init_tag())
-{
-    if (__n > 0)
-        __append(__n, __v);
+deque<_Tp, _Allocator>::deque(size_type __n, const value_type& __v) : __start_(0), __size_(0, __default_init_tag()) {
+  __annotate_new(0);
+  if (__n > 0)
+    __append(__n, __v);
 }
 
 template <class _Tp, class _Allocator>
-template <class _InputIter>
-deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l,
-              typename enable_if<__has_input_iterator_category<_InputIter>::value>::type*)
-    : __start_(0), __size_(0, __default_init_tag())
-{
-    __append(__f, __l);
+template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> >
+deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l) : __start_(0), __size_(0, __default_init_tag()) {
+  __annotate_new(0);
+  __append(__f, __l);
 }
 
 template <class _Tp, class _Allocator>
-template <class _InputIter>
-deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l, const allocator_type& __a,
-              typename enable_if<__has_input_iterator_category<_InputIter>::value>::type*)
-    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
-{
-    __append(__f, __l);
+template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> >
+deque<_Tp, _Allocator>::deque(_InputIter __f, _InputIter __l, const allocator_type& __a)
+    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
+  __annotate_new(0);
+  __append(__f, __l);
 }
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(const deque& __c)
     : __map_(__pointer_allocator(__alloc_traits::select_on_container_copy_construction(__c.__alloc()))),
       __start_(0),
-      __size_(0, __map_.__alloc())
-{
-    __append(__c.begin(), __c.end());
+      __size_(0, __map_.__alloc()) {
+  __annotate_new(0);
+  __append(__c.begin(), __c.end());
 }
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(const deque& __c, const __type_identity_t<allocator_type>& __a)
-    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
-{
-    __append(__c.begin(), __c.end());
+    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
+  __annotate_new(0);
+  __append(__c.begin(), __c.end());
 }
 
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>&
-deque<_Tp, _Allocator>::operator=(const deque& __c)
-{
-    if (this != _VSTD::addressof(__c))
-    {
-        __copy_assign_alloc(__c);
-        assign(__c.begin(), __c.end());
-    }
-    return *this;
+deque<_Tp, _Allocator>& deque<_Tp, _Allocator>::operator=(const deque& __c) {
+  if (this != std::addressof(__c)) {
+    __copy_assign_alloc(__c);
+    assign(__c.begin(), __c.end());
+  }
+  return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
-deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il)
-    : __start_(0), __size_(0, __default_init_tag())
-{
-    __append(__il.begin(), __il.end());
+deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il) : __start_(0), __size_(0, __default_init_tag()) {
+  __annotate_new(0);
+  __append(__il.begin(), __il.end());
 }
 
 template <class _Tp, class _Allocator>
 deque<_Tp, _Allocator>::deque(initializer_list<value_type> __il, const allocator_type& __a)
-    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a)
-{
-    __append(__il.begin(), __il.end());
+    : __map_(__pointer_allocator(__a)), __start_(0), __size_(0, __a) {
+  __annotate_new(0);
+  __append(__il.begin(), __il.end());
 }
 
 template <class _Tp, class _Allocator>
-inline
-deque<_Tp, _Allocator>::deque(deque&& __c)
-    _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
-    : __map_(std::move(__c.__map_)), __start_(std::move(__c.__start_)), __size_(std::move(__c.__size_))
-{
+inline deque<_Tp, _Allocator>::deque(deque&& __c) noexcept(is_nothrow_move_constructible<allocator_type>::value)
+    : __map_(std::move(__c.__map_)), __start_(std::move(__c.__start_)), __size_(std::move(__c.__size_)) {
   __c.__start_ = 0;
   __c.__size() = 0;
 }
 
 template <class _Tp, class _Allocator>
-inline
-deque<_Tp, _Allocator>::deque(deque&& __c, const __type_identity_t<allocator_type>& __a)
+inline deque<_Tp, _Allocator>::deque(deque&& __c, const __type_identity_t<allocator_type>& __a)
     : __map_(std::move(__c.__map_), __pointer_allocator(__a)),
       __start_(std::move(__c.__start_)),
-      __size_(std::move(__c.__size()), __a)
-{
-    if (__a == __c.__alloc())
-    {
-        __c.__start_ = 0;
-        __c.__size() = 0;
-    }
-    else
-    {
-        __map_.clear();
-        __start_ = 0;
-        __size() = 0;
-        typedef move_iterator<iterator> _Ip;
-        assign(_Ip(__c.begin()), _Ip(__c.end()));
-    }
+      __size_(std::move(__c.__size()), __a) {
+  if (__a == __c.__alloc()) {
+    __c.__start_ = 0;
+    __c.__size() = 0;
+  } else {
+    __map_.clear();
+    __start_ = 0;
+    __size() = 0;
+    typedef move_iterator<iterator> _Ip;
+    assign(_Ip(__c.begin()), _Ip(__c.end()));
+  }
 }
 
 template <class _Tp, class _Allocator>
-inline
-deque<_Tp, _Allocator>&
-deque<_Tp, _Allocator>::operator=(deque&& __c)
-        _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
-                   is_nothrow_move_assignable<allocator_type>::value)
-{
-    __move_assign(__c, integral_constant<bool,
-          __alloc_traits::propagate_on_container_move_assignment::value>());
-    return *this;
+inline deque<_Tp, _Allocator>& deque<_Tp, _Allocator>::operator=(deque&& __c) noexcept(
+    __alloc_traits::propagate_on_container_move_assignment::value &&
+    is_nothrow_move_assignable<allocator_type>::value) {
+  __move_assign(__c, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
+  return *this;
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__move_assign(deque& __c, false_type)
-{
-    if (__alloc() != __c.__alloc())
-    {
-        typedef move_iterator<iterator> _Ip;
-        assign(_Ip(__c.begin()), _Ip(__c.end()));
-    }
-    else
-        __move_assign(__c, true_type());
+void deque<_Tp, _Allocator>::__move_assign(deque& __c, false_type) {
+  if (__alloc() != __c.__alloc()) {
+    typedef move_iterator<iterator> _Ip;
+    assign(_Ip(__c.begin()), _Ip(__c.end()));
+  } else
+    __move_assign(__c, true_type());
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__move_assign(deque& __c, true_type)
-    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-{
-    clear();
-    shrink_to_fit();
-    __move_assign(__c);
+void deque<_Tp, _Allocator>::__move_assign(deque& __c,
+                                           true_type) noexcept(is_nothrow_move_assignable<allocator_type>::value) {
+  clear();
+  shrink_to_fit();
+  __move_assign(__c);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
-template <class _InputIter>
-void
-deque<_Tp, _Allocator>::assign(_InputIter __f, _InputIter __l,
-                               typename enable_if<__has_input_iterator_category<_InputIter>::value &&
-                                                 !__has_random_access_iterator_category<_InputIter>::value>::type*)
-{
+template <class _InputIter,
+          __enable_if_t<__has_input_iterator_category<_InputIter>::value &&
+                            !__has_random_access_iterator_category<_InputIter>::value,
+                        int> >
+void deque<_Tp, _Allocator>::assign(_InputIter __f, _InputIter __l) {
   __assign_with_sentinel(__f, __l);
 }
 
 template <class _Tp, class _Allocator>
 template <class _Iterator, class _Sentinel>
-_LIBCPP_HIDE_FROM_ABI
-void deque<_Tp, _Allocator>::__assign_with_sentinel(_Iterator __f, _Sentinel __l) {
-    iterator __i = begin();
-    iterator __e = end();
-    for (; __f != __l && __i != __e; ++__f, (void) ++__i)
-        *__i = *__f;
-    if (__f != __l)
-        __append_with_sentinel(std::move(__f), std::move(__l));
-    else
-        __erase_to_end(__i);
+_LIBCPP_HIDE_FROM_ABI void deque<_Tp, _Allocator>::__assign_with_sentinel(_Iterator __f, _Sentinel __l) {
+  iterator __i = begin();
+  iterator __e = end();
+  for (; __f != __l && __i != __e; ++__f, (void)++__i)
+    *__i = *__f;
+  if (__f != __l)
+    __append_with_sentinel(std::move(__f), std::move(__l));
+  else
+    __erase_to_end(__i);
 }
 
 template <class _Tp, class _Allocator>
-template <class _RAIter>
-void
-deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l,
-                               typename enable_if<__has_random_access_iterator_category<_RAIter>::value>::type*)
-{
+template <class _RAIter, __enable_if_t<__has_random_access_iterator_category<_RAIter>::value, int> >
+void deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l) {
   __assign_with_size_random_access(__f, __l - __f);
 }
 
 template <class _Tp, class _Allocator>
 template <class _RandomAccessIterator>
-_LIBCPP_HIDE_FROM_ABI
-void deque<_Tp, _Allocator>::__assign_with_size_random_access(_RandomAccessIterator __f, difference_type __n) {
-    if (static_cast<size_type>(__n) > size())
-    {
-        auto __l = __f + size();
-        std::copy(__f, __l, begin());
-        __append_with_size(__l, __n - size());
-    }
-    else
-        __erase_to_end(std::copy_n(__f, __n, begin()));
+_LIBCPP_HIDE_FROM_ABI void
+deque<_Tp, _Allocator>::__assign_with_size_random_access(_RandomAccessIterator __f, difference_type __n) {
+  if (static_cast<size_type>(__n) > size()) {
+    auto __l = __f + size();
+    std::copy(__f, __l, begin());
+    __append_with_size(__l, __n - size());
+  } else
+    __erase_to_end(std::copy_n(__f, __n, begin()));
 }
 
 template <class _Tp, class _Allocator>
 template <class _Iterator>
-_LIBCPP_HIDE_FROM_ABI
-void deque<_Tp, _Allocator>::__assign_with_size(_Iterator __f, difference_type __n) {
+_LIBCPP_HIDE_FROM_ABI void deque<_Tp, _Allocator>::__assign_with_size(_Iterator __f, difference_type __n) {
   if (static_cast<size_type>(__n) > size()) {
     auto __added_size = __n - size();
 
@@ -1307,1297 +1415,1114 @@ void deque<_Tp, _Allocator>::__assign_with_size(_Iterator __f, difference_type _
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v)
-{
-    if (__n > size())
-    {
-        _VSTD::fill_n(begin(), size(), __v);
-        __n -= size();
-        __append(__n, __v);
+void deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v) {
+  if (__n > size()) {
+    std::fill_n(begin(), size(), __v);
+    __n -= size();
+    __append(__n, __v);
+  } else
+    __erase_to_end(std::fill_n(begin(), __n, __v));
+}
+
+template <class _Tp, class _Allocator>
+inline _Allocator deque<_Tp, _Allocator>::get_allocator() const _NOEXCEPT {
+  return __alloc();
+}
+
+template <class _Tp, class _Allocator>
+void deque<_Tp, _Allocator>::resize(size_type __n) {
+  if (__n > size())
+    __append(__n - size());
+  else if (__n < size())
+    __erase_to_end(begin() + __n);
+}
+
+template <class _Tp, class _Allocator>
+void deque<_Tp, _Allocator>::resize(size_type __n, const value_type& __v) {
+  if (__n > size())
+    __append(__n - size(), __v);
+  else if (__n < size())
+    __erase_to_end(begin() + __n);
+}
+
+template <class _Tp, class _Allocator>
+void deque<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT {
+  allocator_type& __a = __alloc();
+  if (empty()) {
+    __annotate_delete();
+    while (__map_.size() > 0) {
+      __alloc_traits::deallocate(__a, __map_.back(), __block_size);
+      __map_.pop_back();
     }
-    else
-        __erase_to_end(_VSTD::fill_n(begin(), __n, __v));
+    __start_ = 0;
+  } else {
+    __maybe_remove_front_spare(/*__keep_one=*/false);
+    __maybe_remove_back_spare(/*__keep_one=*/false);
+  }
+  __map_.shrink_to_fit();
 }
 
 template <class _Tp, class _Allocator>
-inline
-_Allocator
-deque<_Tp, _Allocator>::get_allocator() const _NOEXCEPT
-{
-    return __alloc();
+inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::operator[](size_type __i) _NOEXCEPT {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < size(), "deque::operator[] index out of bounds");
+  size_type __p = __start_ + __i;
+  return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::resize(size_type __n)
-{
-    if (__n > size())
-        __append(__n - size());
-    else if (__n < size())
-        __erase_to_end(begin() + __n);
+inline typename deque<_Tp, _Allocator>::const_reference
+deque<_Tp, _Allocator>::operator[](size_type __i) const _NOEXCEPT {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < size(), "deque::operator[] index out of bounds");
+  size_type __p = __start_ + __i;
+  return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::resize(size_type __n, const value_type& __v)
-{
-    if (__n > size())
-        __append(__n - size(), __v);
-    else if (__n < size())
-        __erase_to_end(begin() + __n);
+inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::at(size_type __i) {
+  if (__i >= size())
+    std::__throw_out_of_range("deque");
+  size_type __p = __start_ + __i;
+  return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
-{
-    allocator_type& __a = __alloc();
-    if (empty())
-    {
-        while (__map_.size() > 0)
-        {
-            __alloc_traits::deallocate(__a, __map_.back(), __block_size);
-            __map_.pop_back();
-        }
-        __start_ = 0;
-    }
-    else
-    {
-      __maybe_remove_front_spare(/*__keep_one=*/false);
-      __maybe_remove_back_spare(/*__keep_one=*/false);
-    }
-    __map_.shrink_to_fit();
+inline typename deque<_Tp, _Allocator>::const_reference deque<_Tp, _Allocator>::at(size_type __i) const {
+  if (__i >= size())
+    std::__throw_out_of_range("deque");
+  size_type __p = __start_ + __i;
+  return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::reference
-deque<_Tp, _Allocator>::operator[](size_type __i) _NOEXCEPT
-{
-    size_type __p = __start_ + __i;
-    return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
+inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::front() _NOEXCEPT {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "deque::front called on an empty deque");
+  return *(*(__map_.begin() + __start_ / __block_size) + __start_ % __block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::const_reference
-deque<_Tp, _Allocator>::operator[](size_type __i) const _NOEXCEPT
-{
-    size_type __p = __start_ + __i;
-    return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
+inline typename deque<_Tp, _Allocator>::const_reference deque<_Tp, _Allocator>::front() const _NOEXCEPT {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "deque::front called on an empty deque");
+  return *(*(__map_.begin() + __start_ / __block_size) + __start_ % __block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::reference
-deque<_Tp, _Allocator>::at(size_type __i)
-{
-    if (__i >= size())
-        _VSTD::__throw_out_of_range("deque");
-    size_type __p = __start_ + __i;
-    return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
+inline typename deque<_Tp, _Allocator>::reference deque<_Tp, _Allocator>::back() _NOEXCEPT {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "deque::back called on an empty deque");
+  size_type __p = size() + __start_ - 1;
+  return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::const_reference
-deque<_Tp, _Allocator>::at(size_type __i) const
-{
-    if (__i >= size())
-        _VSTD::__throw_out_of_range("deque");
-    size_type __p = __start_ + __i;
-    return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
+inline typename deque<_Tp, _Allocator>::const_reference deque<_Tp, _Allocator>::back() const _NOEXCEPT {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "deque::back called on an empty deque");
+  size_type __p = size() + __start_ - 1;
+  return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::reference
-deque<_Tp, _Allocator>::front() _NOEXCEPT
-{
-    return *(*(__map_.begin() + __start_ / __block_size)
-                                    + __start_ % __block_size);
+void deque<_Tp, _Allocator>::push_back(const value_type& __v) {
+  allocator_type& __a = __alloc();
+  if (__back_spare() == 0)
+    __add_back_capacity();
+  // __back_spare() >= 1
+  __annotate_increase_back(1);
+  __alloc_traits::construct(__a, std::addressof(*end()), __v);
+  ++__size();
 }
 
 template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::const_reference
-deque<_Tp, _Allocator>::front() const _NOEXCEPT
-{
-    return *(*(__map_.begin() + __start_ / __block_size)
-                                      + __start_ % __block_size);
-}
-
-template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::reference
-deque<_Tp, _Allocator>::back() _NOEXCEPT
-{
-    size_type __p = size() + __start_ - 1;
-    return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
-}
-
-template <class _Tp, class _Allocator>
-inline
-typename deque<_Tp, _Allocator>::const_reference
-deque<_Tp, _Allocator>::back() const _NOEXCEPT
-{
-    size_type __p = size() + __start_ - 1;
-    return *(*(__map_.begin() + __p / __block_size) + __p % __block_size);
-}
-
-template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::push_back(const value_type& __v)
-{
-    allocator_type& __a = __alloc();
-    if (__back_spare() == 0)
-        __add_back_capacity();
-    // __back_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*end()), __v);
-    ++__size();
-}
-
-template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::push_front(const value_type& __v)
-{
-    allocator_type& __a = __alloc();
-    if (__front_spare() == 0)
-        __add_front_capacity();
-    // __front_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), __v);
-    --__start_;
-    ++__size();
+void deque<_Tp, _Allocator>::push_front(const value_type& __v) {
+  allocator_type& __a = __alloc();
+  if (__front_spare() == 0)
+    __add_front_capacity();
+  // __front_spare() >= 1
+  __annotate_increase_front(1);
+  __alloc_traits::construct(__a, std::addressof(*--begin()), __v);
+  --__start_;
+  ++__size();
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::push_back(value_type&& __v)
-{
-    allocator_type& __a = __alloc();
-    if (__back_spare() == 0)
-        __add_back_capacity();
-    // __back_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*end()), _VSTD::move(__v));
-    ++__size();
+void deque<_Tp, _Allocator>::push_back(value_type&& __v) {
+  allocator_type& __a = __alloc();
+  if (__back_spare() == 0)
+    __add_back_capacity();
+  // __back_spare() >= 1
+  __annotate_increase_back(1);
+  __alloc_traits::construct(__a, std::addressof(*end()), std::move(__v));
+  ++__size();
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 typename deque<_Tp, _Allocator>::reference
-#else
+#  else
 void
-#endif
-deque<_Tp, _Allocator>::emplace_back(_Args&&... __args)
-{
-    allocator_type& __a = __alloc();
-    if (__back_spare() == 0)
-        __add_back_capacity();
-    // __back_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*end()),
-                              _VSTD::forward<_Args>(__args)...);
-    ++__size();
-#if _LIBCPP_STD_VER >= 17
-    return *--end();
-#endif
+#  endif
+deque<_Tp, _Allocator>::emplace_back(_Args&&... __args) {
+  allocator_type& __a = __alloc();
+  if (__back_spare() == 0)
+    __add_back_capacity();
+  // __back_spare() >= 1
+  __annotate_increase_back(1);
+  __alloc_traits::construct(__a, std::addressof(*end()), std::forward<_Args>(__args)...);
+  ++__size();
+#  if _LIBCPP_STD_VER >= 17
+  return *--end();
+#  endif
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::push_front(value_type&& __v)
-{
-    allocator_type& __a = __alloc();
-    if (__front_spare() == 0)
-        __add_front_capacity();
-    // __front_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::move(__v));
-    --__start_;
-    ++__size();
+void deque<_Tp, _Allocator>::push_front(value_type&& __v) {
+  allocator_type& __a = __alloc();
+  if (__front_spare() == 0)
+    __add_front_capacity();
+  // __front_spare() >= 1
+  __annotate_increase_front(1);
+  __alloc_traits::construct(__a, std::addressof(*--begin()), std::move(__v));
+  --__start_;
+  ++__size();
 }
 
-
 template <class _Tp, class _Allocator>
 template <class... _Args>
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 typename deque<_Tp, _Allocator>::reference
-#else
+#  else
 void
-#endif
-deque<_Tp, _Allocator>::emplace_front(_Args&&... __args)
-{
-    allocator_type& __a = __alloc();
-    if (__front_spare() == 0)
-        __add_front_capacity();
-    // __front_spare() >= 1
-    __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::forward<_Args>(__args)...);
-    --__start_;
-    ++__size();
-#if _LIBCPP_STD_VER >= 17
-    return *begin();
-#endif
+#  endif
+deque<_Tp, _Allocator>::emplace_front(_Args&&... __args) {
+  allocator_type& __a = __alloc();
+  if (__front_spare() == 0)
+    __add_front_capacity();
+  // __front_spare() >= 1
+  __annotate_increase_front(1);
+  __alloc_traits::construct(__a, std::addressof(*--begin()), std::forward<_Args>(__args)...);
+  --__start_;
+  ++__size();
+#  if _LIBCPP_STD_VER >= 17
+  return *begin();
+#  endif
 }
 
 template <class _Tp, class _Allocator>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
-{
-    size_type __pos = __p - begin();
-    size_type __to_end = size() - __pos;
-    allocator_type& __a = __alloc();
-    if (__pos < __to_end)
-    {   // insert by shifting things backward
-        if (__front_spare() == 0)
-            __add_front_capacity();
-        // __front_spare() >= 1
-        if (__pos == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::move(__v));
-            --__start_;
-            ++__size();
-        }
-        else
-        {
-            iterator __b = begin();
-            iterator __bm1 = _VSTD::prev(__b);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
-            --__start_;
-            ++__size();
-            if (__pos > 1)
-                __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
-            *__b = _VSTD::move(__v);
-        }
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v) {
+  size_type __pos     = __p - begin();
+  size_type __to_end  = size() - __pos;
+  allocator_type& __a = __alloc();
+  if (__pos < __to_end) { // insert by shifting things backward
+    if (__front_spare() == 0)
+      __add_front_capacity();
+    // __front_spare() >= 1
+    __annotate_increase_front(1);
+    if (__pos == 0) {
+      __alloc_traits::construct(__a, std::addressof(*--begin()), std::move(__v));
+      --__start_;
+      ++__size();
+    } else {
+      iterator __b   = begin();
+      iterator __bm1 = std::prev(__b);
+      __alloc_traits::construct(__a, std::addressof(*__bm1), std::move(*__b));
+      --__start_;
+      ++__size();
+      if (__pos > 1)
+        __b = std::move(std::next(__b), __b + __pos, __b);
+      *__b = std::move(__v);
     }
-    else
-    {   // insert by shifting things forward
-        if (__back_spare() == 0)
-            __add_back_capacity();
-        // __back_capacity >= 1
-        size_type __de = size() - __pos;
-        if (__de == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*end()), _VSTD::move(__v));
-            ++__size();
-        }
-        else
-        {
-            iterator __e = end();
-            iterator __em1 = _VSTD::prev(__e);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
-            ++__size();
-            if (__de > 1)
-                __e = _VSTD::move_backward(__e - __de, __em1, __e);
-            *--__e = _VSTD::move(__v);
-        }
+  } else { // insert by shifting things forward
+    if (__back_spare() == 0)
+      __add_back_capacity();
+    // __back_capacity >= 1
+    __annotate_increase_back(1);
+    size_type __de = size() - __pos;
+    if (__de == 0) {
+      __alloc_traits::construct(__a, std::addressof(*end()), std::move(__v));
+      ++__size();
+    } else {
+      iterator __e   = end();
+      iterator __em1 = std::prev(__e);
+      __alloc_traits::construct(__a, std::addressof(*__e), std::move(*__em1));
+      ++__size();
+      if (__de > 1)
+        __e = std::move_backward(__e - __de, __em1, __e);
+      *--__e = std::move(__v);
     }
-    return begin() + __pos;
+  }
+  return begin() + __pos;
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
-{
-    size_type __pos = __p - begin();
-    size_type __to_end = size() - __pos;
-    allocator_type& __a = __alloc();
-    if (__pos < __to_end)
-    {   // insert by shifting things backward
-        if (__front_spare() == 0)
-            __add_front_capacity();
-        // __front_spare() >= 1
-        if (__pos == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), _VSTD::forward<_Args>(__args)...);
-            --__start_;
-            ++__size();
-        }
-        else
-        {
-            __temp_value<value_type, _Allocator> __tmp(__alloc(), _VSTD::forward<_Args>(__args)...);
-            iterator __b = begin();
-            iterator __bm1 = _VSTD::prev(__b);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
-            --__start_;
-            ++__size();
-            if (__pos > 1)
-                __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
-            *__b = _VSTD::move(__tmp.get());
-        }
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args) {
+  size_type __pos     = __p - begin();
+  size_type __to_end  = size() - __pos;
+  allocator_type& __a = __alloc();
+  if (__pos < __to_end) { // insert by shifting things backward
+    if (__front_spare() == 0)
+      __add_front_capacity();
+    // __front_spare() >= 1
+    __annotate_increase_front(1);
+    if (__pos == 0) {
+      __alloc_traits::construct(__a, std::addressof(*--begin()), std::forward<_Args>(__args)...);
+      --__start_;
+      ++__size();
+    } else {
+      __temp_value<value_type, _Allocator> __tmp(__alloc(), std::forward<_Args>(__args)...);
+      iterator __b   = begin();
+      iterator __bm1 = std::prev(__b);
+      __alloc_traits::construct(__a, std::addressof(*__bm1), std::move(*__b));
+      --__start_;
+      ++__size();
+      if (__pos > 1)
+        __b = std::move(std::next(__b), __b + __pos, __b);
+      *__b = std::move(__tmp.get());
     }
-    else
-    {   // insert by shifting things forward
-        if (__back_spare() == 0)
-            __add_back_capacity();
-        // __back_capacity >= 1
-        size_type __de = size() - __pos;
-        if (__de == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*end()), _VSTD::forward<_Args>(__args)...);
-            ++__size();
-        }
-        else
-        {
-            __temp_value<value_type, _Allocator> __tmp(__alloc(), _VSTD::forward<_Args>(__args)...);
-            iterator __e = end();
-            iterator __em1 = _VSTD::prev(__e);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
-            ++__size();
-            if (__de > 1)
-                __e = _VSTD::move_backward(__e - __de, __em1, __e);
-            *--__e = _VSTD::move(__tmp.get());
-        }
+  } else { // insert by shifting things forward
+    if (__back_spare() == 0)
+      __add_back_capacity();
+    // __back_capacity >= 1
+    __annotate_increase_back(1);
+    size_type __de = size() - __pos;
+    if (__de == 0) {
+      __alloc_traits::construct(__a, std::addressof(*end()), std::forward<_Args>(__args)...);
+      ++__size();
+    } else {
+      __temp_value<value_type, _Allocator> __tmp(__alloc(), std::forward<_Args>(__args)...);
+      iterator __e   = end();
+      iterator __em1 = std::prev(__e);
+      __alloc_traits::construct(__a, std::addressof(*__e), std::move(*__em1));
+      ++__size();
+      if (__de > 1)
+        __e = std::move_backward(__e - __de, __em1, __e);
+      *--__e = std::move(__tmp.get());
     }
-    return begin() + __pos;
+  }
+  return begin() + __pos;
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
-
 template <class _Tp, class _Allocator>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
-{
-    size_type __pos = __p - begin();
-    size_type __to_end = size() - __pos;
-    allocator_type& __a = __alloc();
-    if (__pos < __to_end)
-    {   // insert by shifting things backward
-        if (__front_spare() == 0)
-            __add_front_capacity();
-        // __front_spare() >= 1
-        if (__pos == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*--begin()), __v);
-            --__start_;
-            ++__size();
-        }
-        else
-        {
-            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
-            iterator __b = begin();
-            iterator __bm1 = _VSTD::prev(__b);
-            if (__vt == pointer_traits<const_pointer>::pointer_to(*__b))
-                __vt = pointer_traits<const_pointer>::pointer_to(*__bm1);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
-            --__start_;
-            ++__size();
-            if (__pos > 1)
-                __b = __move_and_check(_VSTD::next(__b), __b + __pos, __b, __vt);
-            *__b = *__vt;
-        }
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v) {
+  size_type __pos     = __p - begin();
+  size_type __to_end  = size() - __pos;
+  allocator_type& __a = __alloc();
+  if (__pos < __to_end) { // insert by shifting things backward
+    if (__front_spare() == 0)
+      __add_front_capacity();
+    // __front_spare() >= 1
+    __annotate_increase_front(1);
+    if (__pos == 0) {
+      __alloc_traits::construct(__a, std::addressof(*--begin()), __v);
+      --__start_;
+      ++__size();
+    } else {
+      const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
+      iterator __b       = begin();
+      iterator __bm1     = std::prev(__b);
+      if (__vt == pointer_traits<const_pointer>::pointer_to(*__b))
+        __vt = pointer_traits<const_pointer>::pointer_to(*__bm1);
+      __alloc_traits::construct(__a, std::addressof(*__bm1), std::move(*__b));
+      --__start_;
+      ++__size();
+      if (__pos > 1)
+        __b = __move_and_check(std::next(__b), __b + __pos, __b, __vt);
+      *__b = *__vt;
     }
-    else
-    {   // insert by shifting things forward
-        if (__back_spare() == 0)
-            __add_back_capacity();
-        // __back_capacity >= 1
-        size_type __de = size() - __pos;
-        if (__de == 0)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*end()), __v);
-            ++__size();
-        }
-        else
-        {
-            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
-            iterator __e = end();
-            iterator __em1 = _VSTD::prev(__e);
-            if (__vt == pointer_traits<const_pointer>::pointer_to(*__em1))
-                __vt = pointer_traits<const_pointer>::pointer_to(*__e);
-            __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
-            ++__size();
-            if (__de > 1)
-                __e = __move_backward_and_check(__e - __de, __em1, __e, __vt);
-            *--__e = *__vt;
-        }
+  } else { // insert by shifting things forward
+    if (__back_spare() == 0)
+      __add_back_capacity();
+    // __back_capacity >= 1
+    __annotate_increase_back(1);
+    size_type __de = size() - __pos;
+    if (__de == 0) {
+      __alloc_traits::construct(__a, std::addressof(*end()), __v);
+      ++__size();
+    } else {
+      const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
+      iterator __e       = end();
+      iterator __em1     = std::prev(__e);
+      if (__vt == pointer_traits<const_pointer>::pointer_to(*__em1))
+        __vt = pointer_traits<const_pointer>::pointer_to(*__e);
+      __alloc_traits::construct(__a, std::addressof(*__e), std::move(*__em1));
+      ++__size();
+      if (__de > 1)
+        __e = __move_backward_and_check(__e - __de, __em1, __e, __vt);
+      *--__e = *__vt;
     }
-    return begin() + __pos;
+  }
+  return begin() + __pos;
 }
 
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_type& __v)
-{
-    size_type __pos = __p - begin();
-    size_type __to_end = __size() - __pos;
-    allocator_type& __a = __alloc();
-    if (__pos < __to_end)
-    {   // insert by shifting things backward
-        if (__n > __front_spare())
-            __add_front_capacity(__n - __front_spare());
-        // __n <= __front_spare()
-        iterator __old_begin = begin();
-        iterator __i = __old_begin;
-        if (__n > __pos)
-        {
-            for (size_type __m = __n - __pos; __m; --__m, --__start_, ++__size())
-                __alloc_traits::construct(__a, _VSTD::addressof(*--__i), __v);
-            __n = __pos;
-        }
-        if (__n > 0)
-        {
-            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
-            iterator __obn = __old_begin + __n;
-            __move_construct_backward_and_check(__old_begin, __obn, __i, __vt);
-            if (__n < __pos)
-                __old_begin = __move_and_check(__obn, __old_begin + __pos, __old_begin, __vt);
-            _VSTD::fill_n(__old_begin, __n, *__vt);
-        }
+deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_type& __v) {
+  size_type __pos     = __p - begin();
+  size_type __to_end  = __size() - __pos;
+  allocator_type& __a = __alloc();
+  if (__pos < __to_end) { // insert by shifting things backward
+    if (__n > __front_spare())
+      __add_front_capacity(__n - __front_spare());
+    // __n <= __front_spare()
+    __annotate_increase_front(__n);
+    iterator __old_begin = begin();
+    iterator __i         = __old_begin;
+    if (__n > __pos) {
+      for (size_type __m = __n - __pos; __m; --__m, --__start_, ++__size())
+        __alloc_traits::construct(__a, std::addressof(*--__i), __v);
+      __n = __pos;
     }
-    else
-    {   // insert by shifting things forward
-        size_type __back_capacity = __back_spare();
-        if (__n > __back_capacity)
-            __add_back_capacity(__n - __back_capacity);
-        // __n <= __back_capacity
-        iterator __old_end = end();
-        iterator __i = __old_end;
-        size_type __de = size() - __pos;
-        if (__n > __de)
-        {
-            for (size_type __m = __n - __de; __m; --__m, (void) ++__i, ++__size())
-                __alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);
-            __n = __de;
-        }
-        if (__n > 0)
-        {
-            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
-            iterator __oen = __old_end - __n;
-            __move_construct_and_check(__oen, __old_end, __i, __vt);
-            if (__n < __de)
-                __old_end = __move_backward_and_check(__old_end - __de, __oen, __old_end, __vt);
-            _VSTD::fill_n(__old_end - __n, __n, *__vt);
-        }
+    if (__n > 0) {
+      const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
+      iterator __obn     = __old_begin + __n;
+      __move_construct_backward_and_check(__old_begin, __obn, __i, __vt);
+      if (__n < __pos)
+        __old_begin = __move_and_check(__obn, __old_begin + __pos, __old_begin, __vt);
+      std::fill_n(__old_begin, __n, *__vt);
     }
-    return begin() + __pos;
+  } else { // insert by shifting things forward
+    size_type __back_capacity = __back_spare();
+    if (__n > __back_capacity)
+      __add_back_capacity(__n - __back_capacity);
+    // __n <= __back_capacity
+    __annotate_increase_back(__n);
+    iterator __old_end = end();
+    iterator __i       = __old_end;
+    size_type __de     = size() - __pos;
+    if (__n > __de) {
+      for (size_type __m = __n - __de; __m; --__m, (void)++__i, ++__size())
+        __alloc_traits::construct(__a, std::addressof(*__i), __v);
+      __n = __de;
+    }
+    if (__n > 0) {
+      const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
+      iterator __oen     = __old_end - __n;
+      __move_construct_and_check(__oen, __old_end, __i, __vt);
+      if (__n < __de)
+        __old_end = __move_backward_and_check(__old_end - __de, __oen, __old_end, __vt);
+      std::fill_n(__old_end - __n, __n, *__vt);
+    }
+  }
+  return begin() + __pos;
 }
 
 template <class _Tp, class _Allocator>
-template <class _InputIter>
+template <class _InputIter, __enable_if_t<__has_exactly_input_iterator_category<_InputIter>::value, int> >
 typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __l,
-                               typename enable_if<__has_exactly_input_iterator_category<_InputIter>::value>::type*)
-{
+deque<_Tp, _Allocator>::insert(const_iterator __p, _InputIter __f, _InputIter __l) {
   return __insert_with_sentinel(__p, __f, __l);
 }
 
 template <class _Tp, class _Allocator>
 template <class _Iterator, class _Sentinel>
-_LIBCPP_HIDE_FROM_ABI
-typename deque<_Tp, _Allocator>::iterator
+_LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::__insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l) {
-    __split_buffer<value_type, allocator_type&> __buf(__alloc());
-    __buf.__construct_at_end_with_sentinel(std::move(__f), std::move(__l));
-    typedef typename __split_buffer<value_type, allocator_type&>::iterator __bi;
-    return insert(__p, move_iterator<__bi>(__buf.begin()), move_iterator<__bi>(__buf.end()));
+  __split_buffer<value_type, allocator_type&> __buf(__alloc());
+  __buf.__construct_at_end_with_sentinel(std::move(__f), std::move(__l));
+  typedef typename __split_buffer<value_type, allocator_type&>::iterator __bi;
+  return insert(__p, move_iterator<__bi>(__buf.begin()), move_iterator<__bi>(__buf.end()));
 }
 
 template <class _Tp, class _Allocator>
-template <class _ForwardIterator>
+template <class _ForwardIterator, __enable_if_t<__has_exactly_forward_iterator_category<_ForwardIterator>::value, int> >
 typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l,
-                               typename enable_if<__has_exactly_forward_iterator_category<_ForwardIterator>::value>::type*)
-{
+deque<_Tp, _Allocator>::insert(const_iterator __p, _ForwardIterator __f, _ForwardIterator __l) {
   return __insert_with_size(__p, __f, std::distance(__f, __l));
 }
 
 template <class _Tp, class _Allocator>
 template <class _Iterator>
-_LIBCPP_HIDE_FROM_ABI
-typename deque<_Tp, _Allocator>::iterator
+_LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::__insert_with_size(const_iterator __p, _Iterator __f, size_type __n) {
-    __split_buffer<value_type, allocator_type&> __buf(__n, 0, __alloc());
-    __buf.__construct_at_end_with_size(__f, __n);
-    typedef typename __split_buffer<value_type, allocator_type&>::iterator __fwd;
-    return insert(__p, move_iterator<__fwd>(__buf.begin()), move_iterator<__fwd>(__buf.end()));
+  __split_buffer<value_type, allocator_type&> __buf(__n, 0, __alloc());
+  __buf.__construct_at_end_with_size(__f, __n);
+  typedef typename __split_buffer<value_type, allocator_type&>::iterator __fwd;
+  return insert(__p, move_iterator<__fwd>(__buf.begin()), move_iterator<__fwd>(__buf.end()));
 }
 
 template <class _Tp, class _Allocator>
-template <class _BiIter>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
-                               typename enable_if<__has_bidirectional_iterator_category<_BiIter>::value>::type*)
-{
+template <class _BiIter, __enable_if_t<__has_bidirectional_iterator_category<_BiIter>::value, int> >
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l) {
   return __insert_bidirectional(__p, __f, __l, std::distance(__f, __l));
 }
 
 template <class _Tp, class _Allocator>
 template <class _BiIter, class _Sentinel>
-_LIBCPP_HIDE_FROM_ABI
-typename deque<_Tp, _Allocator>::iterator
+_LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::__insert_bidirectional(const_iterator __p, _BiIter __f, _Sentinel, size_type __n) {
   return __insert_bidirectional(__p, __f, std::next(__f, __n), __n);
 }
 
 template <class _Tp, class _Allocator>
 template <class _BiIter>
-_LIBCPP_HIDE_FROM_ABI
-typename deque<_Tp, _Allocator>::iterator
+_LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::__insert_bidirectional(const_iterator __p, _BiIter __f, _BiIter __l, size_type __n) {
-    size_type __pos = __p - begin();
-    size_type __to_end = size() - __pos;
-    allocator_type& __a = __alloc();
-    if (__pos < __to_end)
-    {   // insert by shifting things backward
-        if (__n > __front_spare())
-            __add_front_capacity(__n - __front_spare());
-        // __n <= __front_spare()
-        iterator __old_begin = begin();
-        iterator __i = __old_begin;
-        _BiIter __m = __f;
-        if (__n > __pos)
-        {
-            __m = __pos < __n / 2 ? _VSTD::prev(__l, __pos) : _VSTD::next(__f, __n - __pos);
-            for (_BiIter __j = __m; __j != __f; --__start_, ++__size())
-                __alloc_traits::construct(__a, _VSTD::addressof(*--__i), *--__j);
-            __n = __pos;
-        }
-        if (__n > 0)
-        {
-            iterator __obn = __old_begin + __n;
-            for (iterator __j = __obn; __j != __old_begin;)
-            {
-                __alloc_traits::construct(__a, _VSTD::addressof(*--__i), _VSTD::move(*--__j));
-                --__start_;
-                ++__size();
-            }
-            if (__n < __pos)
-                __old_begin = _VSTD::move(__obn, __old_begin + __pos, __old_begin);
-            _VSTD::copy(__m, __l, __old_begin);
-        }
+  size_type __pos     = __p - begin();
+  size_type __to_end  = size() - __pos;
+  allocator_type& __a = __alloc();
+  if (__pos < __to_end) { // insert by shifting things backward
+    if (__n > __front_spare())
+      __add_front_capacity(__n - __front_spare());
+    // __n <= __front_spare()
+    __annotate_increase_front(__n);
+    iterator __old_begin = begin();
+    iterator __i         = __old_begin;
+    _BiIter __m          = __f;
+    if (__n > __pos) {
+      __m = __pos < __n / 2 ? std::prev(__l, __pos) : std::next(__f, __n - __pos);
+      for (_BiIter __j = __m; __j != __f; --__start_, ++__size())
+        __alloc_traits::construct(__a, std::addressof(*--__i), *--__j);
+      __n = __pos;
     }
-    else
-    {   // insert by shifting things forward
-        size_type __back_capacity = __back_spare();
-        if (__n > __back_capacity)
-            __add_back_capacity(__n - __back_capacity);
-        // __n <= __back_capacity
-        iterator __old_end = end();
-        iterator __i = __old_end;
-        _BiIter __m = __l;
-        size_type __de = size() - __pos;
-        if (__n > __de)
-        {
-            __m = __de < __n / 2 ? _VSTD::next(__f, __de) : _VSTD::prev(__l, __n - __de);
-            for (_BiIter __j = __m; __j != __l; ++__i, (void) ++__j, ++__size())
-                __alloc_traits::construct(__a, _VSTD::addressof(*__i), *__j);
-            __n = __de;
-        }
-        if (__n > 0)
-        {
-            iterator __oen = __old_end - __n;
-            for (iterator __j = __oen; __j != __old_end; ++__i, (void) ++__j, ++__size())
-                __alloc_traits::construct(__a, _VSTD::addressof(*__i), _VSTD::move(*__j));
-            if (__n < __de)
-                __old_end = _VSTD::move_backward(__old_end - __de, __oen, __old_end);
-            _VSTD::copy_backward(__f, __m, __old_end);
-        }
+    if (__n > 0) {
+      iterator __obn = __old_begin + __n;
+      for (iterator __j = __obn; __j != __old_begin;) {
+        __alloc_traits::construct(__a, std::addressof(*--__i), std::move(*--__j));
+        --__start_;
+        ++__size();
+      }
+      if (__n < __pos)
+        __old_begin = std::move(__obn, __old_begin + __pos, __old_begin);
+      std::copy(__m, __l, __old_begin);
     }
-    return begin() + __pos;
+  } else { // insert by shifting things forward
+    size_type __back_capacity = __back_spare();
+    if (__n > __back_capacity)
+      __add_back_capacity(__n - __back_capacity);
+    // __n <= __back_capacity
+    __annotate_increase_back(__n);
+    iterator __old_end = end();
+    iterator __i       = __old_end;
+    _BiIter __m        = __l;
+    size_type __de     = size() - __pos;
+    if (__n > __de) {
+      __m = __de < __n / 2 ? std::next(__f, __de) : std::prev(__l, __n - __de);
+      for (_BiIter __j = __m; __j != __l; ++__i, (void)++__j, ++__size())
+        __alloc_traits::construct(__a, std::addressof(*__i), *__j);
+      __n = __de;
+    }
+    if (__n > 0) {
+      iterator __oen = __old_end - __n;
+      for (iterator __j = __oen; __j != __old_end; ++__i, (void)++__j, ++__size())
+        __alloc_traits::construct(__a, std::addressof(*__i), std::move(*__j));
+      if (__n < __de)
+        __old_end = std::move_backward(__old_end - __de, __oen, __old_end);
+      std::copy_backward(__f, __m, __old_end);
+    }
+  }
+  return begin() + __pos;
 }
 
 template <class _Tp, class _Allocator>
-template <class _InpIter>
-void
-deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l,
-                                 typename enable_if<__has_exactly_input_iterator_category<_InpIter>::value>::type*)
-{
+template <class _InpIter, __enable_if_t<__has_exactly_input_iterator_category<_InpIter>::value, int> >
+void deque<_Tp, _Allocator>::__append(_InpIter __f, _InpIter __l) {
   __append_with_sentinel(__f, __l);
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIterator, class _Sentinel>
-_LIBCPP_HIDE_FROM_ABI
-void deque<_Tp, _Allocator>::__append_with_sentinel(_InputIterator __f, _Sentinel __l) {
-    for (; __f != __l; ++__f)
+_LIBCPP_HIDE_FROM_ABI void deque<_Tp, _Allocator>::__append_with_sentinel(_InputIterator __f, _Sentinel __l) {
+  for (; __f != __l; ++__f)
 #ifdef _LIBCPP_CXX03_LANG
-        push_back(*__f);
+    push_back(*__f);
 #else
-        emplace_back(*__f);
+    emplace_back(*__f);
 #endif
 }
 
 template <class _Tp, class _Allocator>
-template <class _ForIter>
-void
-deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
-                                 typename enable_if<__has_forward_iterator_category<_ForIter>::value>::type*)
-{
-    __append_with_size(__f, std::distance(__f, __l));
+template <class _ForIter, __enable_if_t<__has_forward_iterator_category<_ForIter>::value, int> >
+void deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l) {
+  __append_with_size(__f, std::distance(__f, __l));
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIterator>
-_LIBCPP_HIDE_FROM_ABI
-void deque<_Tp, _Allocator>::__append_with_size(_InputIterator __f, size_type __n) {
-    allocator_type& __a = __alloc();
-    size_type __back_capacity = __back_spare();
-    if (__n > __back_capacity)
-        __add_back_capacity(__n - __back_capacity);
+_LIBCPP_HIDE_FROM_ABI void deque<_Tp, _Allocator>::__append_with_size(_InputIterator __f, size_type __n) {
+  allocator_type& __a       = __alloc();
+  size_type __back_capacity = __back_spare();
+  if (__n > __back_capacity)
+    __add_back_capacity(__n - __back_capacity);
 
-    // __n <= __back_capacity
-    for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
-      _ConstructTransaction __tx(this, __br);
-      for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__f) {
-        __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), *__f);
-      }
+  // __n <= __back_capacity
+  __annotate_increase_back(__n);
+  for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
+    _ConstructTransaction __tx(this, __br);
+    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__f) {
+      __alloc_traits::construct(__a, std::__to_address(__tx.__pos_), *__f);
     }
+  }
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__append(size_type __n)
-{
-    allocator_type& __a = __alloc();
-    size_type __back_capacity = __back_spare();
-    if (__n > __back_capacity)
-        __add_back_capacity(__n - __back_capacity);
-    // __n <= __back_capacity
-    for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
-      _ConstructTransaction __tx(this, __br);
-      for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
-        __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_));
-      }
+void deque<_Tp, _Allocator>::__append(size_type __n) {
+  allocator_type& __a       = __alloc();
+  size_type __back_capacity = __back_spare();
+  if (__n > __back_capacity)
+    __add_back_capacity(__n - __back_capacity);
+  // __n <= __back_capacity
+  __annotate_increase_back(__n);
+  for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
+    _ConstructTransaction __tx(this, __br);
+    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
+      __alloc_traits::construct(__a, std::__to_address(__tx.__pos_));
     }
+  }
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)
-{
-    allocator_type& __a = __alloc();
-    size_type __back_capacity = __back_spare();
-    if (__n > __back_capacity)
-        __add_back_capacity(__n - __back_capacity);
-    // __n <= __back_capacity
-    for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
-      _ConstructTransaction __tx(this, __br);
-      for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
-        __alloc_traits::construct(__a, _VSTD::__to_address(__tx.__pos_), __v);
-      }
+void deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v) {
+  allocator_type& __a       = __alloc();
+  size_type __back_capacity = __back_spare();
+  if (__n > __back_capacity)
+    __add_back_capacity(__n - __back_capacity);
+  // __n <= __back_capacity
+  __annotate_increase_back(__n);
+  for (__deque_block_range __br : __deque_range(end(), end() + __n)) {
+    _ConstructTransaction __tx(this, __br);
+    for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
+      __alloc_traits::construct(__a, std::__to_address(__tx.__pos_), __v);
     }
-
+  }
 }
 
 // Create front capacity for one block of elements.
 // Strong guarantee.  Either do it or don't touch anything.
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__add_front_capacity()
-{
-    allocator_type& __a = __alloc();
-    if (__back_spare() >= __block_size)
-    {
-        __start_ += __block_size;
-        pointer __pt = __map_.back();
-        __map_.pop_back();
-        __map_.push_front(__pt);
+void deque<_Tp, _Allocator>::__add_front_capacity() {
+  allocator_type& __a = __alloc();
+  if (__back_spare() >= __block_size) {
+    __start_ += __block_size;
+    pointer __pt = __map_.back();
+    __map_.pop_back();
+    __map_.push_front(__pt);
+  }
+  // Else if __map_.size() < __map_.capacity() then we need to allocate 1 buffer
+  else if (__map_.size() < __map_.capacity()) { // we can put the new buffer into the map, but don't shift things around
+    // until all buffers are allocated.  If we throw, we don't need to fix
+    // anything up (any added buffers are undetectible)
+    if (__map_.__front_spare() > 0)
+      __map_.push_front(__alloc_traits::allocate(__a, __block_size));
+    else {
+      __map_.push_back(__alloc_traits::allocate(__a, __block_size));
+      // Done allocating, reorder capacity
+      pointer __pt = __map_.back();
+      __map_.pop_back();
+      __map_.push_front(__pt);
     }
-    // Else if __map_.size() < __map_.capacity() then we need to allocate 1 buffer
-    else if (__map_.size() < __map_.capacity())
-    {   // we can put the new buffer into the map, but don't shift things around
-        // until all buffers are allocated.  If we throw, we don't need to fix
-        // anything up (any added buffers are undetectible)
-        if (__map_.__front_spare() > 0)
-            __map_.push_front(__alloc_traits::allocate(__a, __block_size));
-        else
-        {
-            __map_.push_back(__alloc_traits::allocate(__a, __block_size));
-            // Done allocating, reorder capacity
-            pointer __pt = __map_.back();
-            __map_.pop_back();
-            __map_.push_front(__pt);
-        }
-        __start_ = __map_.size() == 1 ?
-                               __block_size / 2 :
-                               __start_ + __block_size;
-    }
-    // Else need to allocate 1 buffer, *and* we need to reallocate __map_.
-    else
-    {
-        __split_buffer<pointer, __pointer_allocator&>
-            __buf(std::max<size_type>(2 * __map_.capacity(), 1),
-                  0, __map_.__alloc());
+    __start_ = __map_.size() == 1 ? __block_size / 2 : __start_ + __block_size;
+  }
+  // Else need to allocate 1 buffer, *and* we need to reallocate __map_.
+  else {
+    __split_buffer<pointer, __pointer_allocator&> __buf(
+        std::max<size_type>(2 * __map_.capacity(), 1), 0, __map_.__alloc());
 
-        typedef __allocator_destructor<_Allocator> _Dp;
-        unique_ptr<pointer, _Dp> __hold(
-            __alloc_traits::allocate(__a, __block_size),
-                _Dp(__a, __block_size));
-        __buf.push_back(__hold.get());
-        __hold.release();
+    typedef __allocator_destructor<_Allocator> _Dp;
+    unique_ptr<pointer, _Dp> __hold(__alloc_traits::allocate(__a, __block_size), _Dp(__a, __block_size));
+    __buf.push_back(__hold.get());
+    __hold.release();
 
-        for (__map_pointer __i = __map_.begin();
-                __i != __map_.end(); ++__i)
-            __buf.push_back(*__i);
-        _VSTD::swap(__map_.__first_, __buf.__first_);
-        _VSTD::swap(__map_.__begin_, __buf.__begin_);
-        _VSTD::swap(__map_.__end_, __buf.__end_);
-        _VSTD::swap(__map_.__end_cap(), __buf.__end_cap());
-        __start_ = __map_.size() == 1 ?
-                               __block_size / 2 :
-                               __start_ + __block_size;
-    }
+    for (__map_pointer __i = __map_.begin(); __i != __map_.end(); ++__i)
+      __buf.push_back(*__i);
+    std::swap(__map_.__first_, __buf.__first_);
+    std::swap(__map_.__begin_, __buf.__begin_);
+    std::swap(__map_.__end_, __buf.__end_);
+    std::swap(__map_.__end_cap(), __buf.__end_cap());
+    __start_ = __map_.size() == 1 ? __block_size / 2 : __start_ + __block_size;
+  }
+  __annotate_whole_block(0, __asan_poison);
 }
 
 // Create front capacity for __n elements.
 // Strong guarantee.  Either do it or don't touch anything.
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
-{
-    allocator_type& __a = __alloc();
-    size_type __nb = __recommend_blocks(__n + __map_.empty());
-    // Number of unused blocks at back:
-    size_type __back_capacity = __back_spare() / __block_size;
-    __back_capacity = _VSTD::min(__back_capacity, __nb);  // don't take more than you need
-    __nb -= __back_capacity;  // number of blocks need to allocate
-    // If __nb == 0, then we have sufficient capacity.
-    if (__nb == 0)
-    {
-        __start_ += __block_size * __back_capacity;
-        for (; __back_capacity > 0; --__back_capacity)
-        {
-            pointer __pt = __map_.back();
-            __map_.pop_back();
-            __map_.push_front(__pt);
-        }
+void deque<_Tp, _Allocator>::__add_front_capacity(size_type __n) {
+  allocator_type& __a = __alloc();
+  size_type __nb      = __recommend_blocks(__n + __map_.empty());
+  // Number of unused blocks at back:
+  size_type __back_capacity = __back_spare() / __block_size;
+  __back_capacity           = std::min(__back_capacity, __nb); // don't take more than you need
+  __nb -= __back_capacity;                                     // number of blocks need to allocate
+  // If __nb == 0, then we have sufficient capacity.
+  if (__nb == 0) {
+    __start_ += __block_size * __back_capacity;
+    for (; __back_capacity > 0; --__back_capacity) {
+      pointer __pt = __map_.back();
+      __map_.pop_back();
+      __map_.push_front(__pt);
     }
-    // Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
-    else if (__nb <= __map_.capacity() - __map_.size())
-    {   // we can put the new buffers into the map, but don't shift things around
-        // until all buffers are allocated.  If we throw, we don't need to fix
-        // anything up (any added buffers are undetectible)
-        for (; __nb > 0; --__nb, __start_ += __block_size - (__map_.size() == 1))
-        {
-            if (__map_.__front_spare() == 0)
-                break;
-            __map_.push_front(__alloc_traits::allocate(__a, __block_size));
-        }
-        for (; __nb > 0; --__nb, ++__back_capacity)
-            __map_.push_back(__alloc_traits::allocate(__a, __block_size));
-        // Done allocating, reorder capacity
-        __start_ += __back_capacity * __block_size;
-        for (; __back_capacity > 0; --__back_capacity)
-        {
-            pointer __pt = __map_.back();
-            __map_.pop_back();
-            __map_.push_front(__pt);
-        }
+  }
+  // Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
+  else if (__nb <= __map_.capacity() -
+                       __map_.size()) { // we can put the new buffers into the map, but don't shift things around
+    // until all buffers are allocated.  If we throw, we don't need to fix
+    // anything up (any added buffers are undetectible)
+    for (; __nb > 0; --__nb, __start_ += __block_size - (__map_.size() == 1)) {
+      if (__map_.__front_spare() == 0)
+        break;
+      __map_.push_front(__alloc_traits::allocate(__a, __block_size));
+      __annotate_whole_block(0, __asan_poison);
     }
-    // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
-    else
-    {
-        size_type __ds = (__nb + __back_capacity) * __block_size - __map_.empty();
-        __split_buffer<pointer, __pointer_allocator&>
-            __buf(std::max<size_type>(2* __map_.capacity(),
-                                      __nb + __map_.size()),
-                  0, __map_.__alloc());
+    for (; __nb > 0; --__nb, ++__back_capacity)
+      __map_.push_back(__alloc_traits::allocate(__a, __block_size));
+    // Done allocating, reorder capacity
+    __start_ += __back_capacity * __block_size;
+    for (; __back_capacity > 0; --__back_capacity) {
+      pointer __pt = __map_.back();
+      __map_.pop_back();
+      __map_.push_front(__pt);
+      __annotate_whole_block(0, __asan_poison);
+    }
+  }
+  // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
+  else {
+    size_type __ds = (__nb + __back_capacity) * __block_size - __map_.empty();
+    __split_buffer<pointer, __pointer_allocator&> __buf(
+        std::max<size_type>(2 * __map_.capacity(), __nb + __map_.size()), 0, __map_.__alloc());
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (; __nb > 0; --__nb)
-                __buf.push_back(__alloc_traits::allocate(__a, __block_size));
+      for (; __nb > 0; --__nb) {
+        __buf.push_back(__alloc_traits::allocate(__a, __block_size));
+        // ASan: this is empty container, we have to poison whole block
+        __annotate_poison_block(std::__to_address(__buf.back()), std::__to_address(__buf.back() + __block_size));
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            for (__map_pointer __i = __buf.begin();
-                    __i != __buf.end(); ++__i)
-                __alloc_traits::deallocate(__a, *__i, __block_size);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        for (; __back_capacity > 0; --__back_capacity)
-        {
-            __buf.push_back(__map_.back());
-            __map_.pop_back();
-        }
-        for (__map_pointer __i = __map_.begin();
-                __i != __map_.end(); ++__i)
-            __buf.push_back(*__i);
-        _VSTD::swap(__map_.__first_, __buf.__first_);
-        _VSTD::swap(__map_.__begin_, __buf.__begin_);
-        _VSTD::swap(__map_.__end_, __buf.__end_);
-        _VSTD::swap(__map_.__end_cap(), __buf.__end_cap());
-        __start_ += __ds;
+    } catch (...) {
+      __annotate_delete();
+      for (__map_pointer __i = __buf.begin(); __i != __buf.end(); ++__i)
+        __alloc_traits::deallocate(__a, *__i, __block_size);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    for (; __back_capacity > 0; --__back_capacity) {
+      __buf.push_back(__map_.back());
+      __map_.pop_back();
+    }
+    for (__map_pointer __i = __map_.begin(); __i != __map_.end(); ++__i)
+      __buf.push_back(*__i);
+    std::swap(__map_.__first_, __buf.__first_);
+    std::swap(__map_.__begin_, __buf.__begin_);
+    std::swap(__map_.__end_, __buf.__end_);
+    std::swap(__map_.__end_cap(), __buf.__end_cap());
+    __start_ += __ds;
+  }
 }
 
 // Create back capacity for one block of elements.
 // Strong guarantee.  Either do it or don't touch anything.
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__add_back_capacity()
-{
-    allocator_type& __a = __alloc();
-    if (__front_spare() >= __block_size)
-    {
-        __start_ -= __block_size;
-        pointer __pt = __map_.front();
-        __map_.pop_front();
-        __map_.push_back(__pt);
+void deque<_Tp, _Allocator>::__add_back_capacity() {
+  allocator_type& __a = __alloc();
+  if (__front_spare() >= __block_size) {
+    __start_ -= __block_size;
+    pointer __pt = __map_.front();
+    __map_.pop_front();
+    __map_.push_back(__pt);
+  }
+  // Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
+  else if (__map_.size() < __map_.capacity()) { // we can put the new buffer into the map, but don't shift things around
+    // until it is allocated.  If we throw, we don't need to fix
+    // anything up (any added buffers are undetectible)
+    if (__map_.__back_spare() != 0)
+      __map_.push_back(__alloc_traits::allocate(__a, __block_size));
+    else {
+      __map_.push_front(__alloc_traits::allocate(__a, __block_size));
+      // Done allocating, reorder capacity
+      pointer __pt = __map_.front();
+      __map_.pop_front();
+      __map_.push_back(__pt);
     }
-    // Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
-    else if (__map_.size() < __map_.capacity())
-    {   // we can put the new buffer into the map, but don't shift things around
-        // until it is allocated.  If we throw, we don't need to fix
-        // anything up (any added buffers are undetectible)
-        if (__map_.__back_spare() != 0)
-            __map_.push_back(__alloc_traits::allocate(__a, __block_size));
-        else
-        {
-            __map_.push_front(__alloc_traits::allocate(__a, __block_size));
-            // Done allocating, reorder capacity
-            pointer __pt = __map_.front();
-            __map_.pop_front();
-            __map_.push_back(__pt);
-        }
-    }
-    // Else need to allocate 1 buffer, *and* we need to reallocate __map_.
-    else
-    {
-        __split_buffer<pointer, __pointer_allocator&>
-            __buf(std::max<size_type>(2* __map_.capacity(), 1),
-                  __map_.size(),
-                  __map_.__alloc());
+    __annotate_whole_block(__map_.size() - 1, __asan_poison);
+  }
+  // Else need to allocate 1 buffer, *and* we need to reallocate __map_.
+  else {
+    __split_buffer<pointer, __pointer_allocator&> __buf(
+        std::max<size_type>(2 * __map_.capacity(), 1), __map_.size(), __map_.__alloc());
 
-        typedef __allocator_destructor<_Allocator> _Dp;
-        unique_ptr<pointer, _Dp> __hold(
-            __alloc_traits::allocate(__a, __block_size),
-                _Dp(__a, __block_size));
-        __buf.push_back(__hold.get());
-        __hold.release();
+    typedef __allocator_destructor<_Allocator> _Dp;
+    unique_ptr<pointer, _Dp> __hold(__alloc_traits::allocate(__a, __block_size), _Dp(__a, __block_size));
+    __buf.push_back(__hold.get());
+    __hold.release();
 
-        for (__map_pointer __i = __map_.end();
-                __i != __map_.begin();)
-            __buf.push_front(*--__i);
-        _VSTD::swap(__map_.__first_, __buf.__first_);
-        _VSTD::swap(__map_.__begin_, __buf.__begin_);
-        _VSTD::swap(__map_.__end_, __buf.__end_);
-        _VSTD::swap(__map_.__end_cap(), __buf.__end_cap());
-    }
+    for (__map_pointer __i = __map_.end(); __i != __map_.begin();)
+      __buf.push_front(*--__i);
+    std::swap(__map_.__first_, __buf.__first_);
+    std::swap(__map_.__begin_, __buf.__begin_);
+    std::swap(__map_.__end_, __buf.__end_);
+    std::swap(__map_.__end_cap(), __buf.__end_cap());
+    __annotate_whole_block(__map_.size() - 1, __asan_poison);
+  }
 }
 
 // Create back capacity for __n elements.
 // Strong guarantee.  Either do it or don't touch anything.
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
-{
-    allocator_type& __a = __alloc();
-    size_type __nb = __recommend_blocks(__n + __map_.empty());
-    // Number of unused blocks at front:
-    size_type __front_capacity = __front_spare() / __block_size;
-    __front_capacity = _VSTD::min(__front_capacity, __nb);  // don't take more than you need
-    __nb -= __front_capacity;  // number of blocks need to allocate
-    // If __nb == 0, then we have sufficient capacity.
-    if (__nb == 0)
-    {
-        __start_ -= __block_size * __front_capacity;
-        for (; __front_capacity > 0; --__front_capacity)
-        {
-            pointer __pt = __map_.front();
-            __map_.pop_front();
-            __map_.push_back(__pt);
-        }
+void deque<_Tp, _Allocator>::__add_back_capacity(size_type __n) {
+  allocator_type& __a = __alloc();
+  size_type __nb      = __recommend_blocks(__n + __map_.empty());
+  // Number of unused blocks at front:
+  size_type __front_capacity = __front_spare() / __block_size;
+  __front_capacity           = std::min(__front_capacity, __nb); // don't take more than you need
+  __nb -= __front_capacity;                                      // number of blocks need to allocate
+  // If __nb == 0, then we have sufficient capacity.
+  if (__nb == 0) {
+    __start_ -= __block_size * __front_capacity;
+    for (; __front_capacity > 0; --__front_capacity) {
+      pointer __pt = __map_.front();
+      __map_.pop_front();
+      __map_.push_back(__pt);
     }
-    // Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
-    else if (__nb <= __map_.capacity() - __map_.size())
-    {   // we can put the new buffers into the map, but don't shift things around
-        // until all buffers are allocated.  If we throw, we don't need to fix
-        // anything up (any added buffers are undetectible)
-        for (; __nb > 0; --__nb)
-        {
-            if (__map_.__back_spare() == 0)
-                break;
-            __map_.push_back(__alloc_traits::allocate(__a, __block_size));
-        }
-        for (; __nb > 0; --__nb, ++__front_capacity, __start_ +=
-                                 __block_size - (__map_.size() == 1))
-            __map_.push_front(__alloc_traits::allocate(__a, __block_size));
-        // Done allocating, reorder capacity
-        __start_ -= __block_size * __front_capacity;
-        for (; __front_capacity > 0; --__front_capacity)
-        {
-            pointer __pt = __map_.front();
-            __map_.pop_front();
-            __map_.push_back(__pt);
-        }
+  }
+  // Else if __nb <= __map_.capacity() - __map_.size() then we need to allocate __nb buffers
+  else if (__nb <= __map_.capacity() -
+                       __map_.size()) { // we can put the new buffers into the map, but don't shift things around
+    // until all buffers are allocated.  If we throw, we don't need to fix
+    // anything up (any added buffers are undetectible)
+    for (; __nb > 0; --__nb) {
+      if (__map_.__back_spare() == 0)
+        break;
+      __map_.push_back(__alloc_traits::allocate(__a, __block_size));
+      __annotate_whole_block(__map_.size() - 1, __asan_poison);
     }
-    // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
-    else
-    {
-        size_type __ds = __front_capacity * __block_size;
-        __split_buffer<pointer, __pointer_allocator&>
-            __buf(std::max<size_type>(2* __map_.capacity(),
-                                      __nb + __map_.size()),
-                  __map_.size() - __front_capacity,
-                  __map_.__alloc());
+    for (; __nb > 0; --__nb, ++__front_capacity, __start_ += __block_size - (__map_.size() == 1)) {
+      __map_.push_front(__alloc_traits::allocate(__a, __block_size));
+      __annotate_whole_block(0, __asan_poison);
+    }
+    // Done allocating, reorder capacity
+    __start_ -= __block_size * __front_capacity;
+    for (; __front_capacity > 0; --__front_capacity) {
+      pointer __pt = __map_.front();
+      __map_.pop_front();
+      __map_.push_back(__pt);
+    }
+  }
+  // Else need to allocate __nb buffers, *and* we need to reallocate __map_.
+  else {
+    size_type __ds = __front_capacity * __block_size;
+    __split_buffer<pointer, __pointer_allocator&> __buf(
+        std::max<size_type>(2 * __map_.capacity(), __nb + __map_.size()),
+        __map_.size() - __front_capacity,
+        __map_.__alloc());
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (; __nb > 0; --__nb)
-                __buf.push_back(__alloc_traits::allocate(__a, __block_size));
+      for (; __nb > 0; --__nb) {
+        __buf.push_back(__alloc_traits::allocate(__a, __block_size));
+        // ASan: this is an empty container, we have to poison the whole block
+        __annotate_poison_block(std::__to_address(__buf.back()), std::__to_address(__buf.back() + __block_size));
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            for (__map_pointer __i = __buf.begin();
-                    __i != __buf.end(); ++__i)
-                __alloc_traits::deallocate(__a, *__i, __block_size);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        for (; __front_capacity > 0; --__front_capacity)
-        {
-            __buf.push_back(__map_.front());
-            __map_.pop_front();
-        }
-        for (__map_pointer __i = __map_.end();
-                __i != __map_.begin();)
-            __buf.push_front(*--__i);
-        _VSTD::swap(__map_.__first_, __buf.__first_);
-        _VSTD::swap(__map_.__begin_, __buf.__begin_);
-        _VSTD::swap(__map_.__end_, __buf.__end_);
-        _VSTD::swap(__map_.__end_cap(), __buf.__end_cap());
-        __start_ -= __ds;
+    } catch (...) {
+      __annotate_delete();
+      for (__map_pointer __i = __buf.begin(); __i != __buf.end(); ++__i)
+        __alloc_traits::deallocate(__a, *__i, __block_size);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    for (; __front_capacity > 0; --__front_capacity) {
+      __buf.push_back(__map_.front());
+      __map_.pop_front();
+    }
+    for (__map_pointer __i = __map_.end(); __i != __map_.begin();)
+      __buf.push_front(*--__i);
+    std::swap(__map_.__first_, __buf.__first_);
+    std::swap(__map_.__begin_, __buf.__begin_);
+    std::swap(__map_.__end_, __buf.__end_);
+    std::swap(__map_.__end_cap(), __buf.__end_cap());
+    __start_ -= __ds;
+  }
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::pop_front()
-{
-    allocator_type& __a = __alloc();
-    __alloc_traits::destroy(__a, _VSTD::__to_address(*(__map_.begin() +
-                                                    __start_ / __block_size) +
-                                                    __start_ % __block_size));
-    --__size();
-    ++__start_;
-    __maybe_remove_front_spare();
+void deque<_Tp, _Allocator>::pop_front() {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "deque::pop_front called on an empty deque");
+  size_type __old_sz    = size();
+  size_type __old_start = __start_;
+  allocator_type& __a   = __alloc();
+  __alloc_traits::destroy(
+      __a, std::__to_address(*(__map_.begin() + __start_ / __block_size) + __start_ % __block_size));
+  --__size();
+  ++__start_;
+  __annotate_shrink_front(__old_sz, __old_start);
+  __maybe_remove_front_spare();
 }
 
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::pop_back()
-{
-    _LIBCPP_ASSERT(!empty(), "deque::pop_back called on an empty deque");
-    allocator_type& __a = __alloc();
-    size_type __p = size() + __start_ - 1;
-    __alloc_traits::destroy(__a, _VSTD::__to_address(*(__map_.begin() +
-                                                    __p / __block_size) +
-                                                    __p % __block_size));
-    --__size();
-    __maybe_remove_back_spare();
+void deque<_Tp, _Allocator>::pop_back() {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "deque::pop_back called on an empty deque");
+  size_type __old_sz    = size();
+  size_type __old_start = __start_;
+  allocator_type& __a   = __alloc();
+  size_type __p         = size() + __start_ - 1;
+  __alloc_traits::destroy(__a, std::__to_address(*(__map_.begin() + __p / __block_size) + __p % __block_size));
+  --__size();
+  __annotate_shrink_back(__old_sz, __old_start);
+  __maybe_remove_back_spare();
 }
 
 // move assign [__f, __l) to [__r, __r + (__l-__f)).
 // If __vt points into [__f, __l), then subtract (__f - __r) from __vt.
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l, iterator __r,
-                                         const_pointer& __vt)
-{
-    // as if
-    //   for (; __f != __l; ++__f, ++__r)
-    //       *__r = _VSTD::move(*__f);
-    difference_type __n = __l - __f;
-    while (__n > 0)
-    {
-        pointer __fb = __f.__ptr_;
-        pointer __fe = *__f.__m_iter_ + __block_size;
-        difference_type __bs = __fe - __fb;
-        if (__bs > __n)
-        {
-            __bs = __n;
-            __fe = __fb + __bs;
-        }
-        if (__fb <= __vt && __vt < __fe)
-            __vt = (const_iterator(static_cast<__map_const_pointer>(__f.__m_iter_), __vt) -= __f - __r).__ptr_;
-        __r = _VSTD::move(__fb, __fe, __r);
-        __n -= __bs;
-        __f += __bs;
+deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt) {
+  // as if
+  //   for (; __f != __l; ++__f, ++__r)
+  //       *__r = std::move(*__f);
+  difference_type __n = __l - __f;
+  while (__n > 0) {
+    pointer __fb         = __f.__ptr_;
+    pointer __fe         = *__f.__m_iter_ + __block_size;
+    difference_type __bs = __fe - __fb;
+    if (__bs > __n) {
+      __bs = __n;
+      __fe = __fb + __bs;
     }
-    return __r;
+    if (__fb <= __vt && __vt < __fe)
+      __vt = (const_iterator(static_cast<__map_const_pointer>(__f.__m_iter_), __vt) -= __f - __r).__ptr_;
+    __r = std::move(__fb, __fe, __r);
+    __n -= __bs;
+    __f += __bs;
+  }
+  return __r;
 }
 
 // move assign [__f, __l) to [__r - (__l-__f), __r) backwards.
 // If __vt points into [__f, __l), then add (__r - __l) to __vt.
 template <class _Tp, class _Allocator>
 typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::__move_backward_and_check(iterator __f, iterator __l, iterator __r,
-                                                  const_pointer& __vt)
-{
-    // as if
-    //   while (__f != __l)
-    //       *--__r = _VSTD::move(*--__l);
-    difference_type __n = __l - __f;
-    while (__n > 0)
-    {
-        --__l;
-        pointer __lb = *__l.__m_iter_;
-        pointer __le = __l.__ptr_ + 1;
-        difference_type __bs = __le - __lb;
-        if (__bs > __n)
-        {
-            __bs = __n;
-            __lb = __le - __bs;
-        }
-        if (__lb <= __vt && __vt < __le)
-            __vt = (const_iterator(static_cast<__map_const_pointer>(__l.__m_iter_), __vt) += __r - __l - 1).__ptr_;
-        __r = _VSTD::move_backward(__lb, __le, __r);
-        __n -= __bs;
-        __l -= __bs - 1;
+deque<_Tp, _Allocator>::__move_backward_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt) {
+  // as if
+  //   while (__f != __l)
+  //       *--__r = std::move(*--__l);
+  difference_type __n = __l - __f;
+  while (__n > 0) {
+    --__l;
+    pointer __lb         = *__l.__m_iter_;
+    pointer __le         = __l.__ptr_ + 1;
+    difference_type __bs = __le - __lb;
+    if (__bs > __n) {
+      __bs = __n;
+      __lb = __le - __bs;
     }
-    return __r;
+    if (__lb <= __vt && __vt < __le)
+      __vt = (const_iterator(static_cast<__map_const_pointer>(__l.__m_iter_), __vt) += __r - __l - 1).__ptr_;
+    __r = std::move_backward(__lb, __le, __r);
+    __n -= __bs;
+    __l -= __bs - 1;
+  }
+  return __r;
 }
 
 // move construct [__f, __l) to [__r, __r + (__l-__f)).
 // If __vt points into [__f, __l), then add (__r - __f) to __vt.
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
-                                                   iterator __r, const_pointer& __vt)
-{
-    allocator_type& __a = __alloc();
-    // as if
-    //   for (; __f != __l; ++__r, ++__f, ++__size())
-    //       __alloc_traits::construct(__a, _VSTD::addressof(*__r), _VSTD::move(*__f));
-    difference_type __n = __l - __f;
-    while (__n > 0)
-    {
-        pointer __fb = __f.__ptr_;
-        pointer __fe = *__f.__m_iter_ + __block_size;
-        difference_type __bs = __fe - __fb;
-        if (__bs > __n)
-        {
-            __bs = __n;
-            __fe = __fb + __bs;
-        }
-        if (__fb <= __vt && __vt < __fe)
-            __vt = (const_iterator(static_cast<__map_const_pointer>(__f.__m_iter_), __vt) += __r - __f).__ptr_;
-        for (; __fb != __fe; ++__fb, ++__r, ++__size())
-            __alloc_traits::construct(__a, _VSTD::addressof(*__r), _VSTD::move(*__fb));
-        __n -= __bs;
-        __f += __bs;
+void deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l, iterator __r, const_pointer& __vt) {
+  allocator_type& __a = __alloc();
+  // as if
+  //   for (; __f != __l; ++__r, ++__f, ++__size())
+  //       __alloc_traits::construct(__a, std::addressof(*__r), std::move(*__f));
+  difference_type __n = __l - __f;
+  while (__n > 0) {
+    pointer __fb         = __f.__ptr_;
+    pointer __fe         = *__f.__m_iter_ + __block_size;
+    difference_type __bs = __fe - __fb;
+    if (__bs > __n) {
+      __bs = __n;
+      __fe = __fb + __bs;
     }
+    if (__fb <= __vt && __vt < __fe)
+      __vt = (const_iterator(static_cast<__map_const_pointer>(__f.__m_iter_), __vt) += __r - __f).__ptr_;
+    for (; __fb != __fe; ++__fb, ++__r, ++__size())
+      __alloc_traits::construct(__a, std::addressof(*__r), std::move(*__fb));
+    __n -= __bs;
+    __f += __bs;
+  }
 }
 
 // move construct [__f, __l) to [__r - (__l-__f), __r) backwards.
 // If __vt points into [__f, __l), then subtract (__l - __r) from __vt.
 template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterator __l,
-                                                            iterator __r, const_pointer& __vt)
-{
+void deque<_Tp, _Allocator>::__move_construct_backward_and_check(
+    iterator __f, iterator __l, iterator __r, const_pointer& __vt) {
+  allocator_type& __a = __alloc();
+  // as if
+  //   for (iterator __j = __l; __j != __f;)
+  //   {
+  //       __alloc_traitsconstruct(__a, std::addressof(*--__r), std::move(*--__j));
+  //       --__start_;
+  //       ++__size();
+  //   }
+  difference_type __n = __l - __f;
+  while (__n > 0) {
+    --__l;
+    pointer __lb         = *__l.__m_iter_;
+    pointer __le         = __l.__ptr_ + 1;
+    difference_type __bs = __le - __lb;
+    if (__bs > __n) {
+      __bs = __n;
+      __lb = __le - __bs;
+    }
+    if (__lb <= __vt && __vt < __le)
+      __vt = (const_iterator(static_cast<__map_const_pointer>(__l.__m_iter_), __vt) -= __l - __r + 1).__ptr_;
+    while (__le != __lb) {
+      __alloc_traits::construct(__a, std::addressof(*--__r), std::move(*--__le));
+      --__start_;
+      ++__size();
+    }
+    __n -= __bs;
+    __l -= __bs - 1;
+  }
+}
+
+template <class _Tp, class _Allocator>
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::erase(const_iterator __f) {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+      __f != end(), "deque::erase(iterator) called with a non-dereferenceable iterator");
+  size_type __old_sz    = size();
+  size_type __old_start = __start_;
+  iterator __b          = begin();
+  difference_type __pos = __f - __b;
+  iterator __p          = __b + __pos;
+  allocator_type& __a   = __alloc();
+  if (static_cast<size_t>(__pos) <= (size() - 1) / 2) { // erase from front
+    std::move_backward(__b, __p, std::next(__p));
+    __alloc_traits::destroy(__a, std::addressof(*__b));
+    --__size();
+    ++__start_;
+    __annotate_shrink_front(__old_sz, __old_start);
+    __maybe_remove_front_spare();
+  } else { // erase from back
+    iterator __i = std::move(std::next(__p), end(), __p);
+    __alloc_traits::destroy(__a, std::addressof(*__i));
+    --__size();
+    __annotate_shrink_back(__old_sz, __old_start);
+    __maybe_remove_back_spare();
+  }
+  return begin() + __pos;
+}
+
+template <class _Tp, class _Allocator>
+typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l) {
+  _LIBCPP_ASSERT_VALID_INPUT_RANGE(__f <= __l, "deque::erase(first, last) called with an invalid range");
+  size_type __old_sz    = size();
+  size_type __old_start = __start_;
+  difference_type __n   = __l - __f;
+  iterator __b          = begin();
+  difference_type __pos = __f - __b;
+  iterator __p          = __b + __pos;
+  if (__n > 0) {
     allocator_type& __a = __alloc();
-    // as if
-    //   for (iterator __j = __l; __j != __f;)
-    //   {
-    //       __alloc_traitsconstruct(__a, _VSTD::addressof(*--__r), _VSTD::move(*--__j));
-    //       --__start_;
-    //       ++__size();
-    //   }
-    difference_type __n = __l - __f;
-    while (__n > 0)
-    {
-        --__l;
-        pointer __lb = *__l.__m_iter_;
-        pointer __le = __l.__ptr_ + 1;
-        difference_type __bs = __le - __lb;
-        if (__bs > __n)
-        {
-            __bs = __n;
-            __lb = __le - __bs;
-        }
-        if (__lb <= __vt && __vt < __le)
-            __vt = (const_iterator(static_cast<__map_const_pointer>(__l.__m_iter_), __vt) -= __l - __r + 1).__ptr_;
-        while (__le != __lb)
-        {
-            __alloc_traits::construct(__a, _VSTD::addressof(*--__r), _VSTD::move(*--__le));
-            --__start_;
-            ++__size();
-        }
-        __n -= __bs;
-        __l -= __bs - 1;
+    if (static_cast<size_t>(__pos) <= (size() - __n) / 2) { // erase from front
+      iterator __i = std::move_backward(__b, __p, __p + __n);
+      for (; __b != __i; ++__b)
+        __alloc_traits::destroy(__a, std::addressof(*__b));
+      __size() -= __n;
+      __start_ += __n;
+      __annotate_shrink_front(__old_sz, __old_start);
+      while (__maybe_remove_front_spare()) {
+      }
+    } else { // erase from back
+      iterator __i = std::move(__p + __n, end(), __p);
+      for (iterator __e = end(); __i != __e; ++__i)
+        __alloc_traits::destroy(__a, std::addressof(*__i));
+      __size() -= __n;
+      __annotate_shrink_back(__old_sz, __old_start);
+      while (__maybe_remove_back_spare()) {
+      }
     }
+  }
+  return begin() + __pos;
 }
 
 template <class _Tp, class _Allocator>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::erase(const_iterator __f)
-{
-    iterator __b = begin();
+void deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f) {
+  size_type __old_sz    = size();
+  size_type __old_start = __start_;
+  iterator __e          = end();
+  difference_type __n   = __e - __f;
+  if (__n > 0) {
+    allocator_type& __a   = __alloc();
+    iterator __b          = begin();
     difference_type __pos = __f - __b;
-    iterator __p = __b + __pos;
-    allocator_type& __a = __alloc();
-    if (static_cast<size_t>(__pos) <= (size() - 1) / 2)
-    {   // erase from front
-        _VSTD::move_backward(__b, __p, _VSTD::next(__p));
-        __alloc_traits::destroy(__a, _VSTD::addressof(*__b));
-        --__size();
-        ++__start_;
-        __maybe_remove_front_spare();
+    for (iterator __p = __b + __pos; __p != __e; ++__p)
+      __alloc_traits::destroy(__a, std::addressof(*__p));
+    __size() -= __n;
+    __annotate_shrink_back(__old_sz, __old_start);
+    while (__maybe_remove_back_spare()) {
     }
-    else
-    {   // erase from back
-        iterator __i = _VSTD::move(_VSTD::next(__p), end(), __p);
-        __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
-        --__size();
-        __maybe_remove_back_spare();
-    }
-    return begin() + __pos;
+  }
 }
 
 template <class _Tp, class _Allocator>
-typename deque<_Tp, _Allocator>::iterator
-deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
-{
-    difference_type __n = __l - __f;
-    iterator __b = begin();
-    difference_type __pos = __f - __b;
-    iterator __p = __b + __pos;
-    if (__n > 0)
-    {
-        allocator_type& __a = __alloc();
-        if (static_cast<size_t>(__pos) <= (size() - __n) / 2)
-        {   // erase from front
-            iterator __i = _VSTD::move_backward(__b, __p, __p + __n);
-            for (; __b != __i; ++__b)
-                __alloc_traits::destroy(__a, _VSTD::addressof(*__b));
-            __size() -= __n;
-            __start_ += __n;
-            while (__maybe_remove_front_spare()) {
-            }
-        }
-        else
-        {   // erase from back
-            iterator __i = _VSTD::move(__p + __n, end(), __p);
-            for (iterator __e = end(); __i != __e; ++__i)
-                __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
-            __size() -= __n;
-            while (__maybe_remove_back_spare()) {
-            }
-        }
-    }
-    return begin() + __pos;
-}
-
-template <class _Tp, class _Allocator>
-void
-deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)
-{
-    iterator __e = end();
-    difference_type __n = __e - __f;
-    if (__n > 0)
-    {
-        allocator_type& __a = __alloc();
-        iterator __b = begin();
-        difference_type __pos = __f - __b;
-        for (iterator __p = __b + __pos; __p != __e; ++__p)
-            __alloc_traits::destroy(__a, _VSTD::addressof(*__p));
-        __size() -= __n;
-        while (__maybe_remove_back_spare()) {
-        }
-    }
-}
-
-template <class _Tp, class _Allocator>
-inline
-void
-deque<_Tp, _Allocator>::swap(deque& __c)
+inline void deque<_Tp, _Allocator>::swap(deque& __c)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT
+    _NOEXCEPT
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<allocator_type>::value)
+    _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>)
 #endif
 {
-    __map_.swap(__c.__map_);
-    _VSTD::swap(__start_, __c.__start_);
-    _VSTD::swap(__size(), __c.__size());
-    _VSTD::__swap_allocator(__alloc(), __c.__alloc());
+  __map_.swap(__c.__map_);
+  std::swap(__start_, __c.__start_);
+  std::swap(__size(), __c.__size());
+  std::__swap_allocator(__alloc(), __c.__alloc());
 }
 
 template <class _Tp, class _Allocator>
-inline
-void
-deque<_Tp, _Allocator>::clear() _NOEXCEPT
-{
-    allocator_type& __a = __alloc();
-    for (iterator __i = begin(), __e = end(); __i != __e; ++__i)
-        __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
-    __size() = 0;
-    while (__map_.size() > 2)
-    {
-        __alloc_traits::deallocate(__a, __map_.front(), __block_size);
-        __map_.pop_front();
-    }
-    switch (__map_.size())
-    {
-    case 1:
-        __start_ = __block_size / 2;
-        break;
-    case 2:
-        __start_ = __block_size;
-        break;
-    }
+inline void deque<_Tp, _Allocator>::clear() _NOEXCEPT {
+  __annotate_delete();
+  allocator_type& __a = __alloc();
+  for (iterator __i = begin(), __e = end(); __i != __e; ++__i)
+    __alloc_traits::destroy(__a, std::addressof(*__i));
+  __size() = 0;
+  while (__map_.size() > 2) {
+    __alloc_traits::deallocate(__a, __map_.front(), __block_size);
+    __map_.pop_front();
+  }
+  switch (__map_.size()) {
+  case 1:
+    __start_ = __block_size / 2;
+    break;
+  case 2:
+    __start_ = __block_size;
+    break;
+  }
+  __annotate_new(0);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    const typename deque<_Tp, _Allocator>::size_type __sz = __x.size();
-    return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
+  const typename deque<_Tp, _Allocator>::size_type __sz = __x.size();
+  return __sz == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 #if _LIBCPP_STD_VER <= 17
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator!=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
+  return !(__x == __y);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator< (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
+  return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator> (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
+  return __y < __x;
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator>=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
+  return !(__x < __y);
 }
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator<=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
+  return !(__y < __x);
 }
 
 #else // _LIBCPP_STD_VER <= 17
@@ -2605,19 +2530,16 @@ operator<=(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 template <class _Tp, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI __synth_three_way_result<_Tp>
 operator<=>(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y) {
-    return std::lexicographical_compare_three_way(
-        __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way<_Tp, _Tp>);
+  return std::lexicographical_compare_three_way(
+      __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
 }
 
 #endif // _LIBCPP_STD_VER <= 17
 
 template <class _Tp, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-void
-swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void swap(deque<_Tp, _Allocator>& __x, deque<_Tp, _Allocator>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
@@ -2625,7 +2547,7 @@ template <class _Tp, class _Allocator, class _Up>
 inline _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::size_type
 erase(deque<_Tp, _Allocator>& __c, const _Up& __v) {
   auto __old_size = __c.size();
-  __c.erase(_VSTD::remove(__c.begin(), __c.end(), __v), __c.end());
+  __c.erase(std::remove(__c.begin(), __c.end(), __v), __c.end());
   return __old_size - __c.size();
 }
 
@@ -2633,16 +2555,16 @@ template <class _Tp, class _Allocator, class _Predicate>
 inline _LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::size_type
 erase_if(deque<_Tp, _Allocator>& __c, _Predicate __pred) {
   auto __old_size = __c.size();
-  __c.erase(_VSTD::remove_if(__c.begin(), __c.end(), __pred), __c.end());
+  __c.erase(std::remove_if(__c.begin(), __c.end(), __pred), __c.end());
   return __old_size - __c.size();
 }
 
 template <>
 inline constexpr bool __format::__enable_insertable<std::deque<char>> = true;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
 inline constexpr bool __format::__enable_insertable<std::deque<wchar_t>> = true;
-#endif
+#  endif
 
 #endif // _LIBCPP_STD_VER >= 20
 
@@ -2652,7 +2574,7 @@ _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _ValueT>
-using deque = std::deque<_ValueT, polymorphic_allocator<_ValueT>>;
+using deque _LIBCPP_AVAILABILITY_PMR = std::deque<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
diff --git a/third_party/libcxx/errc.cpp b/third_party/libcxx/errc.cpp
new file mode 100644
index 000000000..101fe97d6
--- /dev/null
+++ b/third_party/libcxx/errc.cpp
@@ -0,0 +1,185 @@
+#include <__system_error/errc.h>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+static std::errc __err_to_errc_impl(int err) noexcept {
+  if (err == EAFNOSUPPORT) return errc::address_family_not_supported;
+  if (err == EADDRINUSE) return errc::address_in_use;
+  if (err == EADDRNOTAVAIL) return errc::address_not_available;
+  if (err == EISCONN) return errc::already_connected;
+  if (err == E2BIG) return errc::argument_list_too_long;
+  if (err == EDOM) return errc::argument_out_of_domain;
+  if (err == EFAULT) return errc::bad_address;
+  if (err == EBADF) return errc::bad_file_descriptor;
+  if (err == EBADMSG) return errc::bad_message;
+  if (err == EPIPE) return errc::broken_pipe;
+  if (err == ECONNABORTED) return errc::connection_aborted;
+  if (err == EALREADY) return errc::connection_already_in_progress;
+  if (err == ECONNREFUSED) return errc::connection_refused;
+  if (err == ECONNRESET) return errc::connection_reset;
+  if (err == EXDEV) return errc::cross_device_link;
+  if (err == EDESTADDRREQ) return errc::destination_address_required;
+  if (err == EBUSY) return errc::device_or_resource_busy;
+  if (err == ENOTEMPTY) return errc::directory_not_empty;
+  if (err == ENOEXEC) return errc::executable_format_error;
+  if (err == EEXIST) return errc::file_exists;
+  if (err == EFBIG) return errc::file_too_large;
+  if (err == ENAMETOOLONG) return errc::filename_too_long;
+  if (err == ENOSYS) return errc::function_not_supported;
+  if (err == EHOSTUNREACH) return errc::host_unreachable;
+  if (err == EIDRM) return errc::identifier_removed;
+  if (err == EILSEQ) return errc::illegal_byte_sequence;
+  if (err == ENOTTY) return errc::inappropriate_io_control_operation;
+  if (err == EINTR) return errc::interrupted;
+  if (err == EINVAL) return errc::invalid_argument;
+  if (err == ESPIPE) return errc::invalid_seek;
+  if (err == EIO) return errc::io_error;
+  if (err == EISDIR) return errc::is_a_directory;
+  if (err == EMSGSIZE) return errc::message_size;
+  if (err == ENETDOWN) return errc::network_down;
+  if (err == ENETRESET) return errc::network_reset;
+  if (err == ENETUNREACH) return errc::network_unreachable;
+  if (err == ENOBUFS) return errc::no_buffer_space;
+  if (err == ECHILD) return errc::no_child_process;
+  if (err == ENOLINK) return errc::no_link;
+  if (err == ENOLCK) return errc::no_lock_available;
+  if (err == ENOMSG) return errc::no_message;
+  if (err == (ENODATA ? ENODATA : ENOMSG)) return errc::no_message_available;
+  if (err == ENOPROTOOPT) return errc::no_protocol_option;
+  if (err == ENOSPC) return errc::no_space_on_device;
+  if (err == ENOMEM) return errc::not_enough_memory;
+  if (err == (ENOSR ? ENOSR : ENOMEM)) return errc::no_stream_resources;
+  if (err == ENXIO) return errc::no_such_device_or_address;
+  if (err == ENODEV) return errc::no_such_device;
+  if (err == ENOENT) return errc::no_such_file_or_directory;
+  if (err == ESRCH) return errc::no_such_process;
+  if (err == ENOTDIR) return errc::not_a_directory;
+  if (err == ENOTSOCK) return errc::not_a_socket;
+  if (err == (ENOSTR ? ENOSTR : EINVAL)) return errc::not_a_stream;
+  if (err == ENOTCONN) return errc::not_connected;
+  if (err == ENOTSUP) return errc::not_supported;
+  if (err == ECANCELED) return errc::operation_canceled;
+  if (err == EINPROGRESS) return errc::operation_in_progress;
+  if (err == EPERM) return errc::operation_not_permitted;
+  if (err == EOPNOTSUPP) return errc::operation_not_supported;
+  if (err == EWOULDBLOCK) return errc::operation_would_block;
+  if (err == EOWNERDEAD) return errc::owner_dead;
+  if (err == EACCES) return errc::permission_denied;
+  if (err == EPROTO) return errc::protocol_error;
+  if (err == EPROTONOSUPPORT) return errc::protocol_not_supported;
+  if (err == EROFS) return errc::read_only_file_system;
+  if (err == EDEADLK) return errc::resource_deadlock_would_occur;
+  if (err == EAGAIN) return errc::resource_unavailable_try_again;
+  if (err == ERANGE) return errc::result_out_of_range;
+  if (err == ENOTRECOVERABLE) return errc::state_not_recoverable;
+  if (err == ETIME) return errc::stream_timeout;
+  if (err == ETXTBSY) return errc::text_file_busy;
+  if (err == ETIMEDOUT) return errc::timed_out;
+  if (err == ENFILE) return errc::too_many_files_open_in_system;
+  if (err == EMFILE) return errc::too_many_files_open;
+  if (err == EMLINK) return errc::too_many_links;
+  if (err == ELOOP) return errc::too_many_symbolic_link_levels;
+  if (err == EOVERFLOW) return errc::value_too_large;
+  if (err == EPROTOTYPE) return errc::wrong_protocol_type;
+  return errc::not_supported;
+}
+
+static int __errc_to_err_impl(std::errc err) noexcept {
+  if (err == errc::address_family_not_supported) return EAFNOSUPPORT;
+  if (err == errc::address_in_use) return EADDRINUSE;
+  if (err == errc::address_not_available) return EADDRNOTAVAIL;
+  if (err == errc::already_connected) return EISCONN;
+  if (err == errc::argument_list_too_long) return E2BIG;
+  if (err == errc::argument_out_of_domain) return EDOM;
+  if (err == errc::bad_address) return EFAULT;
+  if (err == errc::bad_file_descriptor) return EBADF;
+  if (err == errc::bad_message) return EBADMSG;
+  if (err == errc::broken_pipe) return EPIPE;
+  if (err == errc::connection_aborted) return ECONNABORTED;
+  if (err == errc::connection_already_in_progress) return EALREADY;
+  if (err == errc::connection_refused) return ECONNREFUSED;
+  if (err == errc::connection_reset) return ECONNRESET;
+  if (err == errc::cross_device_link) return EXDEV;
+  if (err == errc::destination_address_required) return EDESTADDRREQ;
+  if (err == errc::device_or_resource_busy) return EBUSY;
+  if (err == errc::directory_not_empty) return ENOTEMPTY;
+  if (err == errc::executable_format_error) return ENOEXEC;
+  if (err == errc::file_exists) return EEXIST;
+  if (err == errc::file_too_large) return EFBIG;
+  if (err == errc::filename_too_long) return ENAMETOOLONG;
+  if (err == errc::function_not_supported) return ENOSYS;
+  if (err == errc::host_unreachable) return EHOSTUNREACH;
+  if (err == errc::identifier_removed) return EIDRM;
+  if (err == errc::illegal_byte_sequence) return EILSEQ;
+  if (err == errc::inappropriate_io_control_operation) return ENOTTY;
+  if (err == errc::interrupted) return EINTR;
+  if (err == errc::invalid_argument) return EINVAL;
+  if (err == errc::invalid_seek) return ESPIPE;
+  if (err == errc::io_error) return EIO;
+  if (err == errc::is_a_directory) return EISDIR;
+  if (err == errc::message_size) return EMSGSIZE;
+  if (err == errc::network_down) return ENETDOWN;
+  if (err == errc::network_reset) return ENETRESET;
+  if (err == errc::network_unreachable) return ENETUNREACH;
+  if (err == errc::no_buffer_space) return ENOBUFS;
+  if (err == errc::no_child_process) return ECHILD;
+  if (err == errc::no_link) return ENOLINK;
+  if (err == errc::no_lock_available) return ENOLCK;
+  if (err == errc::no_message) return ENOMSG;
+  if (err == errc::no_message_available) return (ENODATA ? ENODATA : ENOMSG);
+  if (err == errc::no_protocol_option) return ENOPROTOOPT;
+  if (err == errc::no_space_on_device) return ENOSPC;
+  if (err == errc::not_enough_memory) return ENOMEM;
+  if (err == errc::no_stream_resources) return (ENOSR ? ENOSR : ENOMEM);
+  if (err == errc::no_such_device_or_address) return ENXIO;
+  if (err == errc::no_such_device) return ENODEV;
+  if (err == errc::no_such_file_or_directory) return ENOENT;
+  if (err == errc::no_such_process) return ESRCH;
+  if (err == errc::not_a_directory) return ENOTDIR;
+  if (err == errc::not_a_socket) return ENOTSOCK;
+  if (err == errc::not_a_stream) return (ENOSTR ? ENOSTR : EINVAL);
+  if (err == errc::not_connected) return ENOTCONN;
+  if (err == errc::not_supported) return ENOTSUP;
+  if (err == errc::operation_canceled) return ECANCELED;
+  if (err == errc::operation_in_progress) return EINPROGRESS;
+  if (err == errc::operation_not_permitted) return EPERM;
+  if (err == errc::operation_not_supported) return EOPNOTSUPP;
+  if (err == errc::operation_would_block) return EWOULDBLOCK;
+  if (err == errc::owner_dead) return EOWNERDEAD;
+  if (err == errc::permission_denied) return EACCES;
+  if (err == errc::protocol_error) return EPROTO;
+  if (err == errc::protocol_not_supported) return EPROTONOSUPPORT;
+  if (err == errc::read_only_file_system) return EROFS;
+  if (err == errc::resource_deadlock_would_occur) return EDEADLK;
+  if (err == errc::resource_unavailable_try_again) return EAGAIN;
+  if (err == errc::result_out_of_range) return ERANGE;
+  if (err == errc::state_not_recoverable) return ENOTRECOVERABLE;
+  if (err == errc::stream_timeout) return ETIME;
+  if (err == errc::text_file_busy) return ETXTBSY;
+  if (err == errc::timed_out) return ETIMEDOUT;
+  if (err == errc::too_many_files_open_in_system) return ENFILE;
+  if (err == errc::too_many_files_open) return EMFILE;
+  if (err == errc::too_many_links) return EMLINK;
+  if (err == errc::too_many_symbolic_link_levels) return ELOOP;
+  if (err == errc::value_too_large) return EOVERFLOW;
+  if (err == errc::wrong_protocol_type) return EPROTOTYPE;
+  return ENOTSUP;
+}
+
+std::errc __err_to_errc(int err) noexcept {
+  if (!err)
+    return (std::errc)0;
+  if (err >= 65536)
+    return (std::errc)err;
+  return __err_to_errc_impl(err);
+}
+
+int __errc_to_err(std::errc err) noexcept {
+  if (!(int)err)
+    return 0;
+  if ((int)err < 65536)
+    return (int)err;
+  return __errc_to_err_impl(err);
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/errno.h b/third_party/libcxx/errno.h
index 7b02d2b47..e657ad84f 100644
--- a/third_party/libcxx/errno.h
+++ b/third_party/libcxx/errno.h
@@ -34,365 +34,365 @@ Macros:
 
 #ifdef __cplusplus
 
-#if !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
+#  if !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
 
-#ifdef ELAST
+#    ifdef ELAST
 
-static const int __elast1 = ELAST+1;
-static const int __elast2 = ELAST+2;
+static const int __elast1 = ELAST + 1;
+static const int __elast2 = ELAST + 2;
 
-#else
+#    else
 
 static const int __elast1 = 104;
 static const int __elast2 = 105;
 
-#endif
+#    endif
 
-#ifdef ENOTRECOVERABLE
+#    ifdef ENOTRECOVERABLE
 
-#define EOWNERDEAD __elast1
+#      define EOWNERDEAD __elast1
 
-#ifdef ELAST
-#undef ELAST
-#define ELAST EOWNERDEAD
-#endif
+#      ifdef ELAST
+#        undef ELAST
+#        define ELAST EOWNERDEAD
+#      endif
 
-#elif defined(EOWNERDEAD)
+#    elif defined(EOWNERDEAD)
 
-#define ENOTRECOVERABLE __elast1
-#ifdef ELAST
-#undef ELAST
-#define ELAST ENOTRECOVERABLE
-#endif
+#      define ENOTRECOVERABLE __elast1
+#      ifdef ELAST
+#        undef ELAST
+#        define ELAST ENOTRECOVERABLE
+#      endif
 
-#else  // defined(EOWNERDEAD)
+#    else // defined(EOWNERDEAD)
 
-#define EOWNERDEAD __elast1
-#define ENOTRECOVERABLE __elast2
-#ifdef ELAST
-#undef ELAST
-#define ELAST ENOTRECOVERABLE
-#endif
+#      define EOWNERDEAD __elast1
+#      define ENOTRECOVERABLE __elast2
+#      ifdef ELAST
+#        undef ELAST
+#        define ELAST ENOTRECOVERABLE
+#      endif
 
-#endif // defined(EOWNERDEAD)
+#    endif // defined(EOWNERDEAD)
 
-#endif // !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
+#  endif // !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)
 
 //  supply errno values likely to be missing, particularly on Windows
 
-#ifndef EAFNOSUPPORT
-#define EAFNOSUPPORT 9901
-#endif
+#  ifndef EAFNOSUPPORT
+#    define EAFNOSUPPORT 9901
+#  endif
 
-#ifndef EADDRINUSE
-#define EADDRINUSE 9902
-#endif
+#  ifndef EADDRINUSE
+#    define EADDRINUSE 9902
+#  endif
 
-#ifndef EADDRNOTAVAIL
-#define EADDRNOTAVAIL 9903
-#endif
+#  ifndef EADDRNOTAVAIL
+#    define EADDRNOTAVAIL 9903
+#  endif
 
-#ifndef EISCONN
-#define EISCONN 9904
-#endif
+#  ifndef EISCONN
+#    define EISCONN 9904
+#  endif
 
-#ifndef EBADMSG
-#define EBADMSG 9905
-#endif
+#  ifndef EBADMSG
+#    define EBADMSG 9905
+#  endif
 
-#ifndef ECONNABORTED
-#define ECONNABORTED 9906
-#endif
+#  ifndef ECONNABORTED
+#    define ECONNABORTED 9906
+#  endif
 
-#ifndef EALREADY
-#define EALREADY 9907
-#endif
+#  ifndef EALREADY
+#    define EALREADY 9907
+#  endif
 
-#ifndef ECONNREFUSED
-#define ECONNREFUSED 9908
-#endif
+#  ifndef ECONNREFUSED
+#    define ECONNREFUSED 9908
+#  endif
 
-#ifndef ECONNRESET
-#define ECONNRESET 9909
-#endif
+#  ifndef ECONNRESET
+#    define ECONNRESET 9909
+#  endif
 
-#ifndef EDESTADDRREQ
-#define EDESTADDRREQ 9910
-#endif
+#  ifndef EDESTADDRREQ
+#    define EDESTADDRREQ 9910
+#  endif
 
-#ifndef EHOSTUNREACH
-#define EHOSTUNREACH 9911
-#endif
+#  ifndef EHOSTUNREACH
+#    define EHOSTUNREACH 9911
+#  endif
 
-#ifndef EIDRM
-#define EIDRM 9912
-#endif
+#  ifndef EIDRM
+#    define EIDRM 9912
+#  endif
 
-#ifndef EMSGSIZE
-#define EMSGSIZE 9913
-#endif
+#  ifndef EMSGSIZE
+#    define EMSGSIZE 9913
+#  endif
 
-#ifndef ENETDOWN
-#define ENETDOWN 9914
-#endif
+#  ifndef ENETDOWN
+#    define ENETDOWN 9914
+#  endif
 
-#ifndef ENETRESET
-#define ENETRESET 9915
-#endif
+#  ifndef ENETRESET
+#    define ENETRESET 9915
+#  endif
 
-#ifndef ENETUNREACH
-#define ENETUNREACH 9916
-#endif
+#  ifndef ENETUNREACH
+#    define ENETUNREACH 9916
+#  endif
 
-#ifndef ENOBUFS
-#define ENOBUFS 9917
-#endif
+#  ifndef ENOBUFS
+#    define ENOBUFS 9917
+#  endif
 
-#ifndef ENOLINK
-#define ENOLINK 9918
-#endif
+#  ifndef ENOLINK
+#    define ENOLINK 9918
+#  endif
 
-#ifndef ENODATA
-#define ENODATA 9919
-#endif
+#  ifndef ENODATA
+#    define ENODATA 9919
+#  endif
 
-#ifndef ENOMSG
-#define ENOMSG 9920
-#endif
+#  ifndef ENOMSG
+#    define ENOMSG 9920
+#  endif
 
-#ifndef ENOPROTOOPT
-#define ENOPROTOOPT 9921
-#endif
+#  ifndef ENOPROTOOPT
+#    define ENOPROTOOPT 9921
+#  endif
 
-#ifndef ENOSR
-#define ENOSR 9922
-#endif
+#  ifndef ENOSR
+#    define ENOSR 9922
+#  endif
 
-#ifndef ENOTSOCK
-#define ENOTSOCK 9923
-#endif
+#  ifndef ENOTSOCK
+#    define ENOTSOCK 9923
+#  endif
 
-#ifndef ENOSTR
-#define ENOSTR 9924
-#endif
+#  ifndef ENOSTR
+#    define ENOSTR 9924
+#  endif
 
-#ifndef ENOTCONN
-#define ENOTCONN 9925
-#endif
+#  ifndef ENOTCONN
+#    define ENOTCONN 9925
+#  endif
 
-#ifndef ENOTSUP
-#define ENOTSUP 9926
-#endif
+#  ifndef ENOTSUP
+#    define ENOTSUP 9926
+#  endif
 
-#ifndef ECANCELED
-#define ECANCELED 9927
-#endif
+#  ifndef ECANCELED
+#    define ECANCELED 9927
+#  endif
 
-#ifndef EINPROGRESS
-#define EINPROGRESS 9928
-#endif
+#  ifndef EINPROGRESS
+#    define EINPROGRESS 9928
+#  endif
 
-#ifndef EOPNOTSUPP
-#define EOPNOTSUPP 9929
-#endif
+#  ifndef EOPNOTSUPP
+#    define EOPNOTSUPP 9929
+#  endif
 
-#ifndef EWOULDBLOCK
-#define EWOULDBLOCK 9930
-#endif
+#  ifndef EWOULDBLOCK
+#    define EWOULDBLOCK 9930
+#  endif
 
-#ifndef EOWNERDEAD
-#define EOWNERDEAD  9931
-#endif
+#  ifndef EOWNERDEAD
+#    define EOWNERDEAD 9931
+#  endif
 
-#ifndef EPROTO
-#define EPROTO 9932
-#endif
+#  ifndef EPROTO
+#    define EPROTO 9932
+#  endif
 
-#ifndef EPROTONOSUPPORT
-#define EPROTONOSUPPORT 9933
-#endif
+#  ifndef EPROTONOSUPPORT
+#    define EPROTONOSUPPORT 9933
+#  endif
 
-#ifndef ENOTRECOVERABLE
-#define ENOTRECOVERABLE 9934
-#endif
+#  ifndef ENOTRECOVERABLE
+#    define ENOTRECOVERABLE 9934
+#  endif
 
-#ifndef ETIME
-#define ETIME 9935
-#endif
+#  ifndef ETIME
+#    define ETIME 9935
+#  endif
 
-#ifndef ETXTBSY
-#define ETXTBSY 9936
-#endif
+#  ifndef ETXTBSY
+#    define ETXTBSY 9936
+#  endif
 
-#ifndef ETIMEDOUT
-#define ETIMEDOUT 9938
-#endif
+#  ifndef ETIMEDOUT
+#    define ETIMEDOUT 9938
+#  endif
 
-#ifndef ELOOP
-#define ELOOP 9939
-#endif
+#  ifndef ELOOP
+#    define ELOOP 9939
+#  endif
 
-#ifndef EOVERFLOW
-#define EOVERFLOW 9940
-#endif
+#  ifndef EOVERFLOW
+#    define EOVERFLOW 9940
+#  endif
 
-#ifndef EPROTOTYPE
-#define EPROTOTYPE 9941
-#endif
+#  ifndef EPROTOTYPE
+#    define EPROTOTYPE 9941
+#  endif
 
-#ifndef ENOSYS
-#define ENOSYS 9942
-#endif
+#  ifndef ENOSYS
+#    define ENOSYS 9942
+#  endif
 
-#ifndef EINVAL
-#define EINVAL 9943
-#endif
+#  ifndef EINVAL
+#    define EINVAL 9943
+#  endif
 
-#ifndef ERANGE
-#define ERANGE 9944
-#endif
+#  ifndef ERANGE
+#    define ERANGE 9944
+#  endif
 
-#ifndef EILSEQ
-#define EILSEQ 9945
-#endif
+#  ifndef EILSEQ
+#    define EILSEQ 9945
+#  endif
 
 //  Windows Mobile doesn't appear to define these:
 
-#ifndef E2BIG
-#define E2BIG 9946
-#endif
+#  ifndef E2BIG
+#    define E2BIG 9946
+#  endif
 
-#ifndef EDOM
-#define EDOM 9947
-#endif
+#  ifndef EDOM
+#    define EDOM 9947
+#  endif
 
-#ifndef EFAULT
-#define EFAULT 9948
-#endif
+#  ifndef EFAULT
+#    define EFAULT 9948
+#  endif
 
-#ifndef EBADF
-#define EBADF 9949
-#endif
+#  ifndef EBADF
+#    define EBADF 9949
+#  endif
 
-#ifndef EPIPE
-#define EPIPE 9950
-#endif
+#  ifndef EPIPE
+#    define EPIPE 9950
+#  endif
 
-#ifndef EXDEV
-#define EXDEV 9951
-#endif
+#  ifndef EXDEV
+#    define EXDEV 9951
+#  endif
 
-#ifndef EBUSY
-#define EBUSY 9952
-#endif
+#  ifndef EBUSY
+#    define EBUSY 9952
+#  endif
 
-#ifndef ENOTEMPTY
-#define ENOTEMPTY 9953
-#endif
+#  ifndef ENOTEMPTY
+#    define ENOTEMPTY 9953
+#  endif
 
-#ifndef ENOEXEC
-#define ENOEXEC 9954
-#endif
+#  ifndef ENOEXEC
+#    define ENOEXEC 9954
+#  endif
 
-#ifndef EEXIST
-#define EEXIST 9955
-#endif
+#  ifndef EEXIST
+#    define EEXIST 9955
+#  endif
 
-#ifndef EFBIG
-#define EFBIG 9956
-#endif
+#  ifndef EFBIG
+#    define EFBIG 9956
+#  endif
 
-#ifndef ENAMETOOLONG
-#define ENAMETOOLONG 9957
-#endif
+#  ifndef ENAMETOOLONG
+#    define ENAMETOOLONG 9957
+#  endif
 
-#ifndef ENOTTY
-#define ENOTTY 9958
-#endif
+#  ifndef ENOTTY
+#    define ENOTTY 9958
+#  endif
 
-#ifndef EINTR
-#define EINTR 9959
-#endif
+#  ifndef EINTR
+#    define EINTR 9959
+#  endif
 
-#ifndef ESPIPE
-#define ESPIPE 9960
-#endif
+#  ifndef ESPIPE
+#    define ESPIPE 9960
+#  endif
 
-#ifndef EIO
-#define EIO 9961
-#endif
+#  ifndef EIO
+#    define EIO 9961
+#  endif
 
-#ifndef EISDIR
-#define EISDIR 9962
-#endif
+#  ifndef EISDIR
+#    define EISDIR 9962
+#  endif
 
-#ifndef ECHILD
-#define ECHILD 9963
-#endif
+#  ifndef ECHILD
+#    define ECHILD 9963
+#  endif
 
-#ifndef ENOLCK
-#define ENOLCK 9964
-#endif
+#  ifndef ENOLCK
+#    define ENOLCK 9964
+#  endif
 
-#ifndef ENOSPC
-#define ENOSPC 9965
-#endif
+#  ifndef ENOSPC
+#    define ENOSPC 9965
+#  endif
 
-#ifndef ENXIO
-#define ENXIO 9966
-#endif
+#  ifndef ENXIO
+#    define ENXIO 9966
+#  endif
 
-#ifndef ENODEV
-#define ENODEV 9967
-#endif
+#  ifndef ENODEV
+#    define ENODEV 9967
+#  endif
 
-#ifndef ENOENT
-#define ENOENT 9968
-#endif
+#  ifndef ENOENT
+#    define ENOENT 9968
+#  endif
 
-#ifndef ESRCH
-#define ESRCH 9969
-#endif
+#  ifndef ESRCH
+#    define ESRCH 9969
+#  endif
 
-#ifndef ENOTDIR
-#define ENOTDIR 9970
-#endif
+#  ifndef ENOTDIR
+#    define ENOTDIR 9970
+#  endif
 
-#ifndef ENOMEM
-#define ENOMEM 9971
-#endif
+#  ifndef ENOMEM
+#    define ENOMEM 9971
+#  endif
 
-#ifndef EPERM
-#define EPERM 9972
-#endif
+#  ifndef EPERM
+#    define EPERM 9972
+#  endif
 
-#ifndef EACCES
-#define EACCES 9973
-#endif
+#  ifndef EACCES
+#    define EACCES 9973
+#  endif
 
-#ifndef EROFS
-#define EROFS 9974
-#endif
+#  ifndef EROFS
+#    define EROFS 9974
+#  endif
 
-#ifndef EDEADLK
-#define EDEADLK 9975
-#endif
+#  ifndef EDEADLK
+#    define EDEADLK 9975
+#  endif
 
-#ifndef EAGAIN
-#define EAGAIN 9976
-#endif
+#  ifndef EAGAIN
+#    define EAGAIN 9976
+#  endif
 
-#ifndef ENFILE
-#define ENFILE 9977
-#endif
+#  ifndef ENFILE
+#    define ENFILE 9977
+#  endif
 
-#ifndef EMFILE
-#define EMFILE 9978
-#endif
+#  ifndef EMFILE
+#    define EMFILE 9978
+#  endif
 
-#ifndef EMLINK
-#define EMLINK 9979
-#endif
+#  ifndef EMLINK
+#    define EMLINK 9979
+#  endif
 
 #endif // __cplusplus
 
diff --git a/third_party/libcxx/error_category.cpp b/third_party/libcxx/error_category.cpp
new file mode 100644
index 000000000..8ae460fb5
--- /dev/null
+++ b/third_party/libcxx/error_category.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+
+#ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
+#  define _LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS
+#endif
+
+#include <system_error>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// class error_category
+
+#if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
+error_category::error_category() noexcept {}
+#endif
+
+error_category::~error_category() noexcept {}
+
+error_condition error_category::default_error_condition(int ev) const noexcept { return error_condition(ev, *this); }
+
+bool error_category::equivalent(int code, const error_condition& condition) const noexcept {
+  return default_error_condition(code) == condition;
+}
+
+bool error_category::equivalent(const error_code& code, int condition) const noexcept {
+  return *this == code.category() && code.value() == condition;
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/exception b/third_party/libcxx/exception
index 97fee9776..5eff8e3f8 100644
--- a/third_party/libcxx/exception
+++ b/third_party/libcxx/exception
@@ -76,7 +76,6 @@ template <class E> void rethrow_if_nested(const E& e);
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__exception/exception.h>
 #include <__exception/exception_ptr.h>
diff --git a/third_party/libcxx/exception.cpp b/third_party/libcxx/exception.cpp
new file mode 100644
index 000000000..b9f98c0d5
--- /dev/null
+++ b/third_party/libcxx/exception.cpp
@@ -0,0 +1,18 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <exception>
+#include <new>
+#include <typeinfo>
+
+#  include <cxxabi.h>
+using namespace __cxxabiv1;
+#  define HAVE_DEPENDENT_EH_ABI 1
+
+#include "exception_libcxxabi.h"
+#include "exception_pointer_cxxabi.h"
diff --git a/third_party/libcxx/exception_libcxxabi.h b/third_party/libcxx/exception_libcxxabi.h
new file mode 100644
index 000000000..df6bd6574
--- /dev/null
+++ b/third_party/libcxx/exception_libcxxabi.h
@@ -0,0 +1,26 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPPABI_VERSION
+#  error this header can only be used with libc++abi
+#endif
+
+namespace std {
+
+bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
+
+int uncaught_exceptions() noexcept {
+#if _LIBCPPABI_VERSION > 1001
+  return __cxa_uncaught_exceptions();
+#else
+  return __cxa_uncaught_exception() ? 1 : 0;
+#endif
+}
+
+} // namespace std
diff --git a/third_party/libcxx/exception_pointer_cxxabi.h b/third_party/libcxx/exception_pointer_cxxabi.h
new file mode 100644
index 000000000..bdb17b999
--- /dev/null
+++ b/third_party/libcxx/exception_pointer_cxxabi.h
@@ -0,0 +1,64 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef HAVE_DEPENDENT_EH_ABI
+#  error this header may only be used with libc++abi or libcxxrt
+#endif
+
+namespace std {
+
+exception_ptr::~exception_ptr() noexcept { __cxa_decrement_exception_refcount(__ptr_); }
+
+exception_ptr::exception_ptr(const exception_ptr& other) noexcept : __ptr_(other.__ptr_) {
+  __cxa_increment_exception_refcount(__ptr_);
+}
+
+exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept {
+  if (__ptr_ != other.__ptr_) {
+    __cxa_increment_exception_refcount(other.__ptr_);
+    __cxa_decrement_exception_refcount(__ptr_);
+    __ptr_ = other.__ptr_;
+  }
+  return *this;
+}
+
+exception_ptr exception_ptr::__from_native_exception_pointer(void* __e) noexcept {
+  exception_ptr ptr;
+  ptr.__ptr_ = __e;
+  __cxa_increment_exception_refcount(ptr.__ptr_);
+
+  return ptr;
+}
+
+nested_exception::nested_exception() noexcept : __ptr_(current_exception()) {}
+
+nested_exception::~nested_exception() noexcept {}
+
+_LIBCPP_NORETURN void nested_exception::rethrow_nested() const {
+  if (__ptr_ == nullptr)
+    terminate();
+  rethrow_exception(__ptr_);
+}
+
+exception_ptr current_exception() noexcept {
+  // be nicer if there was a constructor that took a ptr, then
+  // this whole function would be just:
+  //    return exception_ptr(__cxa_current_primary_exception());
+  exception_ptr ptr;
+  ptr.__ptr_ = __cxa_current_primary_exception();
+  return ptr;
+}
+
+_LIBCPP_NORETURN void rethrow_exception(exception_ptr p) {
+  __cxa_rethrow_primary_exception(p.__ptr_);
+  // if p.__ptr_ is NULL, above returns so we terminate
+  terminate();
+}
+
+} // namespace std
diff --git a/third_party/libcxx/execution b/third_party/libcxx/execution
index 56facc873..94d434b2e 100644
--- a/third_party/libcxx/execution
+++ b/third_party/libcxx/execution
@@ -32,7 +32,6 @@ namespace std {
 }
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__type_traits/is_execution_policy.h>
 #include <__type_traits/is_same.h>
@@ -143,4 +142,8 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // !defined(_LIBCPP_HAS_NO_INCOMPLETE_PSTL) && _LIBCPP_STD_VER >= 17
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstddef>
+#endif
+
 #endif // _LIBCPP_EXECUTION
diff --git a/third_party/libcxx/expected b/third_party/libcxx/expected
index 486d0a21d..6a2f12f2b 100644
--- a/third_party/libcxx/expected
+++ b/third_party/libcxx/expected
@@ -38,17 +38,25 @@ namespace std {
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__expected/bad_expected_access.h>
-#include <__expected/expected.h>
-#include <__expected/unexpect.h>
-#include <__expected/unexpected.h>
+
+#if _LIBCPP_STD_VER >= 23
+#  include <__expected/bad_expected_access.h>
+#  include <__expected/expected.h>
+#  include <__expected/unexpect.h>
+#  include <__expected/unexpected.h>
+#endif
+
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#endif // _LIBCPP_EXPECTED
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstddef>
+#  include <initializer_list>
+#  include <new>
+#endif
 
+#endif // _LIBCPP_EXPECTED
diff --git a/third_party/libcxx/expected.cpp b/third_party/libcxx/expected.cpp
new file mode 100644
index 000000000..f30efb516
--- /dev/null
+++ b/third_party/libcxx/expected.cpp
@@ -0,0 +1,13 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <expected>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+const char* bad_expected_access<void>::what() const noexcept { return "bad access to std::expected"; }
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/experimental/__config b/third_party/libcxx/experimental/__config
index 839b80aa6..7b2379151 100644
--- a/third_party/libcxx/experimental/__config
+++ b/third_party/libcxx/experimental/__config
@@ -16,39 +16,30 @@
 #  pragma GCC system_header
 #endif
 
-#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace std { namespace experimental {
-#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL  } }
-#define _VSTD_EXPERIMENTAL std::experimental
+#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL                                                                           \
+  namespace std {                                                                                                      \
+  namespace experimental {
+#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL                                                                             \
+  }                                                                                                                    \
+  }
 
 #define _LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v1 {
-#define _LIBCPP_END_NAMESPACE_LFTS  } } }
-#define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v1
+#define _LIBCPP_END_NAMESPACE_LFTS                                                                                     \
+  }                                                                                                                    \
+  }                                                                                                                    \
+  }
 
 #define _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 {
-#define _LIBCPP_END_NAMESPACE_LFTS_V2  } } }
-#define _VSTD_LFTS_V2 _VSTD_EXPERIMENTAL::fundamentals_v2
-
-#define _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS namespace pmr {
-#define _LIBCPP_END_NAMESPACE_LFTS_PMR _LIBCPP_END_NAMESPACE_LFTS }
-#define _VSTD_LFTS_PMR _VSTD_LFTS::pmr
-
-#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD \
-    _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace parallelism_v2 {
-
-#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD \
-    } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
-
-#define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI \
-    _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD namespace simd_abi {
-
-#define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI \
-    } _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
+#define _LIBCPP_END_NAMESPACE_LFTS_V2                                                                                  \
+  }                                                                                                                    \
+  }                                                                                                                    \
+  }
 
 // TODO: support more targets
 #if defined(__AVX__)
-#define _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES 32
+#  define _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES 32
 #else
-#define _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES 16
+#  define _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES 16
 #endif
 
 #endif
diff --git a/third_party/libcxx/experimental/__memory b/third_party/libcxx/experimental/__memory
deleted file mode 100644
index b11369632..000000000
--- a/third_party/libcxx/experimental/__memory
+++ /dev/null
@@ -1,120 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL___MEMORY
-#define _LIBCPP_EXPERIMENTAL___MEMORY
-
-#include <__memory/allocator_arg_t.h>
-#include <__memory/uses_allocator.h>
-#include <__type_traits/conditional.h>
-#include <__type_traits/is_constructible.h>
-#include <__type_traits/is_convertible.h>
-#include <__type_traits/is_same.h>
-#include <experimental/__config>
-#include <experimental/utility> // for erased_type
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS
-
-template <
-    class _Tp, class _Alloc
-  , bool = uses_allocator<_Tp, _Alloc>::value
-  , bool = __has_allocator_type<_Tp>::value
-  >
-struct __lfts_uses_allocator : public false_type {};
-
-template <class _Tp, class _Alloc>
-struct __lfts_uses_allocator<_Tp, _Alloc, false, false> : public false_type {};
-
-template <class _Tp, class _Alloc, bool HasAlloc>
-struct __lfts_uses_allocator<_Tp, _Alloc, true, HasAlloc> : public true_type {};
-
-template <class _Tp, class _Alloc>
-struct __lfts_uses_allocator<_Tp, _Alloc, false, true>
-  : public integral_constant<bool
-    , is_convertible<_Alloc, typename _Tp::allocator_type>::value
-      || is_same<erased_type, typename _Tp::allocator_type>::value
-    >
-{};
-
-template <bool _UsesAlloc, class _Tp, class _Alloc, class ..._Args>
-struct __lfts_uses_alloc_ctor_imp
-{
-    static const int value = 0;
-};
-
-template <class _Tp, class _Alloc, class ..._Args>
-struct __lfts_uses_alloc_ctor_imp<true, _Tp, _Alloc, _Args...>
-{
-    static const bool __ic_first
-        = is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
-
-    static const bool __ic_second =
-        __conditional_t<
-            __ic_first,
-            false_type,
-            is_constructible<_Tp, _Args..., _Alloc>
-        >::value;
-
-    static_assert(__ic_first || __ic_second,
-                  "Request for uses allocator construction is ill-formed");
-
-    static const int value = __ic_first ? 1 : 2;
-};
-
-template <class _Tp, class _Alloc, class ..._Args>
-struct __lfts_uses_alloc_ctor
-  : integral_constant<int,
-        __lfts_uses_alloc_ctor_imp<
-            __lfts_uses_allocator<_Tp, _Alloc>::value
-          , _Tp, _Alloc, _Args...
-        >::value
-    >
-{};
-
-template <class _Tp, class _Allocator, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args )
-{
-    new (__storage) _Tp (_VSTD::forward<_Args>(__args)...);
-}
-
-// FIXME: This should have a version which takes a non-const alloc.
-template <class _Tp, class _Allocator, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
-{
-    new (__storage) _Tp (allocator_arg_t(), __a, _VSTD::forward<_Args>(__args)...);
-}
-
-// FIXME: This should have a version which takes a non-const alloc.
-template <class _Tp, class _Allocator, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
-{
-    new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a);
-}
-
-template <class _Tp, class _Alloc, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __lfts_user_alloc_construct(
-    _Tp * __store, const _Alloc & __a, _Args &&... __args)
-{
-    ::std::experimental::fundamentals_v1::__user_alloc_construct_impl(
-        typename __lfts_uses_alloc_ctor<_Tp, _Alloc, _Args...>::type()
-       , __store, __a, _VSTD::forward<_Args>(__args)...
-       );
-}
-
-_LIBCPP_END_NAMESPACE_LFTS
-
-#endif /* _LIBCPP_EXPERIMENTAL___MEMORY */
diff --git a/third_party/libcxx/experimental/__simd/aligned_tag.h b/third_party/libcxx/experimental/__simd/aligned_tag.h
new file mode 100644
index 000000000..31d2b50aa
--- /dev/null
+++ b/third_party/libcxx/experimental/__simd/aligned_tag.h
@@ -0,0 +1,75 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_ALIGNED_TAG_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_ALIGNED_TAG_H
+
+#include <__memory/assume_aligned.h>
+#include <__type_traits/remove_const.h>
+#include <cstddef>
+#include <experimental/__config>
+#include <experimental/__simd/traits.h>
+
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+inline namespace parallelism_v2 {
+// memory alignment
+struct element_aligned_tag {
+  template <class _Tp, class _Up = typename _Tp::value_type>
+  static constexpr size_t __alignment = alignof(_Up);
+
+  template <class _Tp, class _Up>
+  static _LIBCPP_HIDE_FROM_ABI constexpr _Up* __apply(_Up* __ptr) {
+    return __ptr;
+  }
+};
+
+template <>
+inline constexpr bool is_simd_flag_type_v<element_aligned_tag> = true;
+
+struct vector_aligned_tag {
+  template <class _Tp, class _Up = typename _Tp::value_type>
+  static constexpr size_t __alignment = memory_alignment_v<_Tp, remove_const_t<_Up>>;
+
+  template <class _Tp, class _Up>
+  static _LIBCPP_HIDE_FROM_ABI constexpr _Up* __apply(_Up* __ptr) {
+    return std::__assume_aligned<__alignment<_Tp, _Up>, _Up>(__ptr);
+  }
+};
+
+template <>
+inline constexpr bool is_simd_flag_type_v<vector_aligned_tag> = true;
+
+template <size_t _Np>
+struct overaligned_tag {
+  template <class _Tp, class _Up = typename _Tp::value_type>
+  static constexpr size_t __alignment = _Np;
+
+  template <class _Tp, class _Up>
+  static _LIBCPP_HIDE_FROM_ABI constexpr _Up* __apply(_Up* __ptr) {
+    return std::__assume_aligned<__alignment<_Tp, _Up>, _Up>(__ptr);
+  }
+};
+
+template <size_t _Np>
+inline constexpr bool is_simd_flag_type_v<overaligned_tag<_Np>> = true;
+
+inline constexpr element_aligned_tag element_aligned{};
+
+inline constexpr vector_aligned_tag vector_aligned{};
+
+template <size_t _Np>
+inline constexpr overaligned_tag<_Np> overaligned{};
+
+} // namespace parallelism_v2
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+#endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_ALIGNED_TAG_H
diff --git a/third_party/libcxx/experimental/__simd/declaration.h b/third_party/libcxx/experimental/__simd/declaration.h
new file mode 100644
index 000000000..7b45d035c
--- /dev/null
+++ b/third_party/libcxx/experimental/__simd/declaration.h
@@ -0,0 +1,81 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_DECLARATION_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_DECLARATION_H
+
+#include <cstddef>
+#include <experimental/__config>
+
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+inline namespace parallelism_v2 {
+namespace simd_abi {
+template <int>
+struct __vec_ext;
+struct __scalar;
+
+using scalar = __scalar;
+
+// TODO: make this platform dependent
+template <int _Np>
+using fixed_size = __vec_ext<_Np>;
+
+template <class _Tp>
+inline constexpr int max_fixed_size = 32;
+
+// TODO: make this platform dependent
+template <class _Tp>
+using compatible = __vec_ext<16 / sizeof(_Tp)>;
+
+// TODO: make this platform dependent
+template <class _Tp>
+using native = __vec_ext<_LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
+
+// TODO: make this platform dependent
+template <class _Tp, size_t _Np, class... _Abis>
+struct deduce {
+  using type = fixed_size<_Np>;
+};
+
+// TODO: make this platform dependent
+template <class _Tp, size_t _Np, class... _Abis>
+using deduce_t = typename deduce<_Tp, _Np, _Abis...>::type;
+
+} // namespace simd_abi
+
+template <class _Tp, class _Abi>
+struct __simd_storage;
+
+template <class _Tp, class _Abi>
+struct __mask_storage;
+
+template <class _Tp, class _Abi>
+struct __simd_operations;
+
+template <class _Tp, class _Abi>
+struct __mask_operations;
+
+struct element_aligned_tag;
+struct vector_aligned_tag;
+template <size_t>
+struct overaligned_tag;
+
+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
+class simd;
+
+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
+class simd_mask;
+
+} // namespace parallelism_v2
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+#endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_DECLARATION_H
diff --git a/third_party/libcxx/experimental/__simd/reference.h b/third_party/libcxx/experimental/__simd/reference.h
new file mode 100644
index 000000000..af61dbcc2
--- /dev/null
+++ b/third_party/libcxx/experimental/__simd/reference.h
@@ -0,0 +1,105 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_REFERENCE_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_REFERENCE_H
+
+#include <__type_traits/is_assignable.h>
+#include <__type_traits/is_same.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+#include <cstddef>
+#include <experimental/__config>
+#include <experimental/__simd/utility.h>
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+inline namespace parallelism_v2 {
+template <class _Tp, class _Storage, class _Vp>
+class __simd_reference {
+  template <class, class>
+  friend class simd;
+  template <class, class>
+  friend class simd_mask;
+
+  _Storage& __s_;
+  size_t __idx_;
+
+  _LIBCPP_HIDE_FROM_ABI __simd_reference(_Storage& __s, size_t __idx) : __s_(__s), __idx_(__idx) {}
+
+  _LIBCPP_HIDE_FROM_ABI _Vp __get() const noexcept { return __s_.__get(__idx_); }
+
+  _LIBCPP_HIDE_FROM_ABI void __set(_Vp __v) {
+    if constexpr (is_same_v<_Vp, bool>)
+      __s_.__set(__idx_, experimental::__set_all_bits<_Tp>(__v));
+    else
+      __s_.__set(__idx_, __v);
+  }
+
+public:
+  using value_type = _Vp;
+
+  __simd_reference()                        = delete;
+  __simd_reference(const __simd_reference&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI operator value_type() const noexcept { return __get(); }
+
+  template <class _Up, enable_if_t<is_assignable_v<value_type&, _Up&&>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI __simd_reference operator=(_Up&& __v) && noexcept {
+    __set(static_cast<value_type>(std::forward<_Up>(__v)));
+    return {__s_, __idx_};
+  }
+
+  // Note: This approach might not fully align with the specification,
+  // which might be a wording defect. (https://wg21.link/N4808 section 9.6.3)
+  template <class _Tp1, class _Storage1, class _Vp1>
+  friend void
+  swap(__simd_reference<_Tp1, _Storage1, _Vp1>&& __a, __simd_reference<_Tp1, _Storage1, _Vp1>&& __b) noexcept;
+
+  template <class _Tp1, class _Storage1, class _Vp1>
+  friend void swap(_Vp1& __a, __simd_reference<_Tp1, _Storage1, _Vp1>&& __b) noexcept;
+
+  template <class _Tp1, class _Storage1, class _Vp1>
+  friend void swap(__simd_reference<_Tp1, _Storage1, _Vp1>&& __a, _Vp1& __b) noexcept;
+};
+
+template <class _Tp, class _Storage, class _Vp>
+_LIBCPP_HIDE_FROM_ABI void
+swap(__simd_reference<_Tp, _Storage, _Vp>&& __a, __simd_reference<_Tp, _Storage, _Vp>&& __b) noexcept {
+  _Vp __tmp(std::move(__a));
+  std::move(__a) = std::move(__b);
+  std::move(__b) = std::move(__tmp);
+}
+
+template <class _Tp, class _Storage, class _Vp>
+_LIBCPP_HIDE_FROM_ABI void swap(_Vp& __a, __simd_reference<_Tp, _Storage, _Vp>&& __b) noexcept {
+  _Vp __tmp(std::move(__a));
+  __a            = std::move(__b);
+  std::move(__b) = std::move(__tmp);
+}
+
+template <class _Tp, class _Storage, class _Vp>
+_LIBCPP_HIDE_FROM_ABI void swap(__simd_reference<_Tp, _Storage, _Vp>&& __a, _Vp& __b) noexcept {
+  _Vp __tmp(std::move(__a));
+  std::move(__a) = std::move(__b);
+  __b            = std::move(__tmp);
+}
+
+} // namespace parallelism_v2
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+#endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_REFERENCE_H
diff --git a/third_party/libcxx/experimental/__simd/scalar.h b/third_party/libcxx/experimental/__simd/scalar.h
new file mode 100644
index 000000000..1add46532
--- /dev/null
+++ b/third_party/libcxx/experimental/__simd/scalar.h
@@ -0,0 +1,87 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_SCALAR_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_SCALAR_H
+
+#include <__assert>
+#include <cstddef>
+#include <experimental/__config>
+#include <experimental/__simd/declaration.h>
+#include <experimental/__simd/traits.h>
+
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+inline namespace parallelism_v2 {
+namespace simd_abi {
+struct __scalar {
+  static constexpr size_t __simd_size = 1;
+};
+} // namespace simd_abi
+
+template <>
+inline constexpr bool is_abi_tag_v<simd_abi::__scalar> = true;
+
+template <class _Tp>
+struct __simd_storage<_Tp, simd_abi::__scalar> {
+  _Tp __data;
+
+  _LIBCPP_HIDE_FROM_ABI _Tp __get([[maybe_unused]] size_t __idx) const noexcept {
+    _LIBCPP_ASSERT_UNCATEGORIZED(__idx == 0, "Index is out of bounds");
+    return __data;
+  }
+  _LIBCPP_HIDE_FROM_ABI void __set([[maybe_unused]] size_t __idx, _Tp __v) noexcept {
+    _LIBCPP_ASSERT_UNCATEGORIZED(__idx == 0, "Index is out of bounds");
+    __data = __v;
+  }
+};
+
+template <class _Tp>
+struct __mask_storage<_Tp, simd_abi::__scalar> : __simd_storage<bool, simd_abi::__scalar> {};
+
+template <class _Tp>
+struct __simd_operations<_Tp, simd_abi::__scalar> {
+  using _SimdStorage = __simd_storage<_Tp, simd_abi::__scalar>;
+  using _MaskStorage = __mask_storage<_Tp, simd_abi::__scalar>;
+
+  static _LIBCPP_HIDE_FROM_ABI _SimdStorage __broadcast(_Tp __v) noexcept { return {__v}; }
+
+  template <class _Generator>
+  static _LIBCPP_HIDE_FROM_ABI _SimdStorage __generate(_Generator&& __g) noexcept {
+    return {__g(std::integral_constant<size_t, 0>())};
+  }
+
+  template <class _Up>
+  static _LIBCPP_HIDE_FROM_ABI void __load(_SimdStorage& __s, const _Up* __mem) noexcept {
+    __s.__data = static_cast<_Tp>(__mem[0]);
+  }
+
+  template <class _Up>
+  static _LIBCPP_HIDE_FROM_ABI void __store(_SimdStorage __s, _Up* __mem) noexcept {
+    *__mem = static_cast<_Up>(__s.__data);
+  }
+};
+
+template <class _Tp>
+struct __mask_operations<_Tp, simd_abi::__scalar> {
+  using _MaskStorage = __mask_storage<_Tp, simd_abi::__scalar>;
+
+  static _LIBCPP_HIDE_FROM_ABI _MaskStorage __broadcast(bool __v) noexcept { return {__v}; }
+
+  static _LIBCPP_HIDE_FROM_ABI void __load(_MaskStorage& __s, const bool* __mem) noexcept { __s.__data = __mem[0]; }
+
+  static _LIBCPP_HIDE_FROM_ABI void __store(_MaskStorage __s, bool* __mem) noexcept { __mem[0] = __s.__data; }
+};
+
+} // namespace parallelism_v2
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+#endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_SCALAR_H
diff --git a/third_party/libcxx/experimental/__simd/simd.h b/third_party/libcxx/experimental/__simd/simd.h
new file mode 100644
index 000000000..37e334aad
--- /dev/null
+++ b/third_party/libcxx/experimental/__simd/simd.h
@@ -0,0 +1,102 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_SIMD_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_SIMD_H
+
+#include <__type_traits/is_same.h>
+#include <__type_traits/remove_cvref.h>
+#include <__utility/forward.h>
+#include <cstddef>
+#include <experimental/__config>
+#include <experimental/__simd/declaration.h>
+#include <experimental/__simd/reference.h>
+#include <experimental/__simd/traits.h>
+#include <experimental/__simd/utility.h>
+
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+inline namespace parallelism_v2 {
+
+// class template simd [simd.class]
+// TODO: implement simd class
+template <class _Tp, class _Abi>
+class simd {
+  using _Impl    = __simd_operations<_Tp, _Abi>;
+  using _Storage = typename _Impl::_SimdStorage;
+
+  _Storage __s_;
+
+public:
+  using value_type = _Tp;
+  using reference  = __simd_reference<_Tp, _Storage, value_type>;
+  using mask_type  = simd_mask<_Tp, _Abi>;
+  using abi_type   = _Abi;
+
+  static _LIBCPP_HIDE_FROM_ABI constexpr size_t size() noexcept { return simd_size_v<value_type, abi_type>; }
+
+  _LIBCPP_HIDE_FROM_ABI simd() noexcept = default;
+
+  // broadcast constructor
+  template <class _Up, enable_if_t<__can_broadcast_v<value_type, __remove_cvref_t<_Up>>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI simd(_Up&& __v) noexcept : __s_(_Impl::__broadcast(static_cast<value_type>(__v))) {}
+
+  // implicit type conversion constructor
+  template <class _Up,
+            enable_if_t<!is_same_v<_Up, _Tp> && is_same_v<abi_type, simd_abi::fixed_size<size()>> &&
+                            __is_non_narrowing_convertible_v<_Up, value_type>,
+                        int> = 0>
+  _LIBCPP_HIDE_FROM_ABI simd(const simd<_Up, simd_abi::fixed_size<size()>>& __v) noexcept {
+    for (size_t __i = 0; __i < size(); __i++) {
+      (*this)[__i] = static_cast<value_type>(__v[__i]);
+    }
+  }
+
+  // generator constructor
+  template <class _Generator, enable_if_t<__can_generate_v<value_type, _Generator, size()>, int> = 0>
+  explicit _LIBCPP_HIDE_FROM_ABI simd(_Generator&& __g) noexcept
+      : __s_(_Impl::__generate(std::forward<_Generator>(__g))) {}
+
+  // load constructor
+  template <class _Up, class _Flags, enable_if_t<__is_vectorizable_v<_Up> && is_simd_flag_type_v<_Flags>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI simd(const _Up* __mem, _Flags) {
+    _Impl::__load(__s_, _Flags::template __apply<simd>(__mem));
+  }
+
+  // copy functions
+  template <class _Up, class _Flags, enable_if_t<__is_vectorizable_v<_Up> && is_simd_flag_type_v<_Flags>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void copy_from(const _Up* __mem, _Flags) {
+    _Impl::__load(__s_, _Flags::template __apply<simd>(__mem));
+  }
+
+  template <class _Up, class _Flags, enable_if_t<__is_vectorizable_v<_Up> && is_simd_flag_type_v<_Flags>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void copy_to(_Up* __mem, _Flags) const {
+    _Impl::__store(__s_, _Flags::template __apply<simd>(__mem));
+  }
+
+  // scalar access [simd.subscr]
+  _LIBCPP_HIDE_FROM_ABI reference operator[](size_t __i) noexcept { return reference(__s_, __i); }
+  _LIBCPP_HIDE_FROM_ABI value_type operator[](size_t __i) const noexcept { return __s_.__get(__i); }
+};
+
+template <class _Tp, class _Abi>
+inline constexpr bool is_simd_v<simd<_Tp, _Abi>> = true;
+
+template <class _Tp>
+using native_simd = simd<_Tp, simd_abi::native<_Tp>>;
+
+template <class _Tp, int _Np>
+using fixed_size_simd = simd<_Tp, simd_abi::fixed_size<_Np>>;
+
+} // namespace parallelism_v2
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+#endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_SIMD_H
diff --git a/third_party/libcxx/experimental/__simd/simd_mask.h b/third_party/libcxx/experimental/__simd/simd_mask.h
new file mode 100644
index 000000000..fd6dee2e2
--- /dev/null
+++ b/third_party/libcxx/experimental/__simd/simd_mask.h
@@ -0,0 +1,90 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_SIMD_MASK_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_SIMD_MASK_H
+
+#include <__type_traits/is_same.h>
+#include <cstddef>
+#include <experimental/__config>
+#include <experimental/__simd/declaration.h>
+#include <experimental/__simd/reference.h>
+#include <experimental/__simd/traits.h>
+
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+inline namespace parallelism_v2 {
+
+// class template simd_mask [simd.mask.class]
+// TODO: implement simd_mask class
+template <class _Tp, class _Abi>
+class simd_mask {
+  using _Impl    = __mask_operations<_Tp, _Abi>;
+  using _Storage = typename _Impl::_MaskStorage;
+
+  _Storage __s_;
+
+public:
+  using value_type = bool;
+  using reference  = __simd_reference<_Tp, _Storage, value_type>;
+  using simd_type  = simd<_Tp, _Abi>;
+  using abi_type   = _Abi;
+
+  static _LIBCPP_HIDE_FROM_ABI constexpr size_t size() noexcept { return simd_type::size(); }
+
+  _LIBCPP_HIDE_FROM_ABI simd_mask() noexcept = default;
+
+  // broadcast constructor
+  _LIBCPP_HIDE_FROM_ABI explicit simd_mask(value_type __v) noexcept : __s_(_Impl::__broadcast(__v)) {}
+
+  // implicit type conversion constructor
+  template <class _Up, enable_if_t<!is_same_v<_Up, _Tp> && is_same_v<abi_type, simd_abi::fixed_size<size()>>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI simd_mask(const simd_mask<_Up, simd_abi::fixed_size<size()>>& __v) noexcept {
+    for (size_t __i = 0; __i < size(); __i++) {
+      (*this)[__i] = __v[__i];
+    }
+  }
+
+  // load constructor
+  template <class _Flags, enable_if_t<is_simd_flag_type_v<_Flags>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI simd_mask(const value_type* __mem, _Flags) {
+    _Impl::__load(__s_, _Flags::template __apply<simd_mask>(__mem));
+  }
+
+  // copy functions
+  template <class _Flags, enable_if_t<is_simd_flag_type_v<_Flags>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void copy_from(const value_type* __mem, _Flags) {
+    _Impl::__load(__s_, _Flags::template __apply<simd_mask>(__mem));
+  }
+
+  template <class _Flags, enable_if_t<is_simd_flag_type_v<_Flags>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void copy_to(value_type* __mem, _Flags) const {
+    _Impl::__store(__s_, _Flags::template __apply<simd_mask>(__mem));
+  }
+
+  // scalar access [simd.mask.subscr]
+  _LIBCPP_HIDE_FROM_ABI reference operator[](size_t __i) noexcept { return reference(__s_, __i); }
+  _LIBCPP_HIDE_FROM_ABI value_type operator[](size_t __i) const noexcept { return __s_.__get(__i); }
+};
+
+template <class _Tp, class _Abi>
+inline constexpr bool is_simd_mask_v<simd_mask<_Tp, _Abi>> = true;
+
+template <class _Tp>
+using native_simd_mask = simd_mask<_Tp, simd_abi::native<_Tp>>;
+
+template <class _Tp, int _Np>
+using fixed_size_simd_mask = simd_mask<_Tp, simd_abi::fixed_size<_Np>>;
+
+} // namespace parallelism_v2
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+#endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_SIMD_MASK_H
diff --git a/third_party/libcxx/experimental/__simd/traits.h b/third_party/libcxx/experimental/__simd/traits.h
new file mode 100644
index 000000000..ec25b4bfa
--- /dev/null
+++ b/third_party/libcxx/experimental/__simd/traits.h
@@ -0,0 +1,75 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_TRAITS_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_TRAITS_H
+
+#include <__bit/bit_ceil.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_same.h>
+#include <cstddef>
+#include <experimental/__config>
+#include <experimental/__simd/declaration.h>
+#include <experimental/__simd/utility.h>
+
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+inline namespace parallelism_v2 {
+
+// traits [simd.traits]
+template <class _Tp>
+inline constexpr bool is_abi_tag_v = false;
+
+template <class _Tp>
+struct is_abi_tag : bool_constant<is_abi_tag_v<_Tp>> {};
+
+template <class _Tp>
+inline constexpr bool is_simd_v = false;
+
+template <class _Tp>
+struct is_simd : bool_constant<is_simd_v<_Tp>> {};
+
+template <class _Tp>
+inline constexpr bool is_simd_mask_v = false;
+
+template <class _Tp>
+struct is_simd_mask : bool_constant<is_simd_mask_v<_Tp>> {};
+
+template <class _Tp>
+inline constexpr bool is_simd_flag_type_v = false;
+
+template <class _Tp>
+struct is_simd_flag_type : bool_constant<is_simd_flag_type_v<_Tp>> {};
+
+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>, bool = (__is_vectorizable_v<_Tp> && is_abi_tag_v<_Abi>)>
+struct simd_size : integral_constant<size_t, _Abi::__simd_size> {};
+
+template <class _Tp, class _Abi>
+struct simd_size<_Tp, _Abi, false> {};
+
+template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
+inline constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value;
+
+template <class _Tp,
+          class _Up = typename _Tp::value_type,
+          bool      = (is_simd_v<_Tp> && __is_vectorizable_v<_Up>) || (is_simd_mask_v<_Tp> && is_same_v<_Up, bool>)>
+struct memory_alignment : integral_constant<size_t, std::__bit_ceil(sizeof(_Up) * _Tp::size())> {};
+
+template <class _Tp, class _Up>
+struct memory_alignment<_Tp, _Up, false> {};
+
+template <class _Tp, class _Up = typename _Tp::value_type>
+inline constexpr size_t memory_alignment_v = memory_alignment<_Tp, _Up>::value;
+
+} // namespace parallelism_v2
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+#endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_TRAITS_H
diff --git a/third_party/libcxx/experimental/__simd/utility.h b/third_party/libcxx/experimental/__simd/utility.h
new file mode 100644
index 000000000..708fa3d8f
--- /dev/null
+++ b/third_party/libcxx/experimental/__simd/utility.h
@@ -0,0 +1,103 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H
+
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_const.h>
+#include <__type_traits/is_constant_evaluated.h>
+#include <__type_traits/is_convertible.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/is_unsigned.h>
+#include <__type_traits/is_volatile.h>
+#include <__type_traits/void_t.h>
+#include <__utility/declval.h>
+#include <__utility/integer_sequence.h>
+#include <cstddef>
+#include <cstdint>
+#include <experimental/__config>
+#include <limits>
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+inline namespace parallelism_v2 {
+template <class _Tp>
+inline constexpr bool __is_vectorizable_v =
+    is_arithmetic_v<_Tp> && !is_const_v<_Tp> && !is_volatile_v<_Tp> && !is_same_v<_Tp, bool>;
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI auto __choose_mask_type() {
+  if constexpr (sizeof(_Tp) == 1) {
+    return uint8_t{};
+  } else if constexpr (sizeof(_Tp) == 2) {
+    return uint16_t{};
+  } else if constexpr (sizeof(_Tp) == 4) {
+    return uint32_t{};
+  } else if constexpr (sizeof(_Tp) == 8) {
+    return uint64_t{};
+  }
+#  ifndef _LIBCPP_HAS_NO_INT128
+  else if constexpr (sizeof(_Tp) == 16) {
+    return __uint128_t{};
+  }
+#  endif
+  else
+    static_assert(sizeof(_Tp) == 0, "Unexpected size");
+}
+
+template <class _Tp>
+_LIBCPP_HIDE_FROM_ABI auto constexpr __set_all_bits(bool __v) {
+  return __v ? (numeric_limits<decltype(__choose_mask_type<_Tp>())>::max()) : 0;
+}
+
+template <class _From, class _To, class = void>
+inline constexpr bool __is_non_narrowing_convertible_v = false;
+
+template <class _From, class _To>
+inline constexpr bool __is_non_narrowing_convertible_v<_From, _To, std::void_t<decltype(_To{std::declval<_From>()})>> =
+    true;
+
+template <class _Tp, class _Up>
+inline constexpr bool __can_broadcast_v =
+    (__is_vectorizable_v<_Up> && __is_non_narrowing_convertible_v<_Up, _Tp>) ||
+    (!__is_vectorizable_v<_Up> && is_convertible_v<_Up, _Tp>) || is_same_v<_Up, int> ||
+    (is_same_v<_Up, unsigned int> && is_unsigned_v<_Tp>);
+
+template <class _Tp, class _Generator, std::size_t _Idx, class = void>
+inline constexpr bool __is_well_formed = false;
+
+template <class _Tp, class _Generator, std::size_t _Idx>
+inline constexpr bool
+    __is_well_formed<_Tp,
+                     _Generator,
+                     _Idx,
+                     std::void_t<decltype(std::declval<_Generator>()(integral_constant<size_t, _Idx>()))>> =
+        __can_broadcast_v<_Tp, decltype(std::declval<_Generator>()(integral_constant<size_t, _Idx>()))>;
+
+template <class _Tp, class _Generator, std::size_t... _Idxes>
+_LIBCPP_HIDE_FROM_ABI constexpr bool __can_generate(index_sequence<_Idxes...>) {
+  return (true && ... && __is_well_formed<_Tp, _Generator, _Idxes>);
+}
+
+template <class _Tp, class _Generator, std::size_t _Size>
+inline constexpr bool __can_generate_v = experimental::__can_generate<_Tp, _Generator>(make_index_sequence<_Size>());
+
+} // namespace parallelism_v2
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+#endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_UTILITY_H
diff --git a/third_party/libcxx/experimental/__simd/vec_ext.h b/third_party/libcxx/experimental/__simd/vec_ext.h
new file mode 100644
index 000000000..316866b84
--- /dev/null
+++ b/third_party/libcxx/experimental/__simd/vec_ext.h
@@ -0,0 +1,119 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL___SIMD_VEC_EXT_H
+#define _LIBCPP_EXPERIMENTAL___SIMD_VEC_EXT_H
+
+#include <__assert>
+#include <__bit/bit_ceil.h>
+#include <__utility/forward.h>
+#include <__utility/integer_sequence.h>
+#include <cstddef>
+#include <experimental/__config>
+#include <experimental/__simd/declaration.h>
+#include <experimental/__simd/traits.h>
+#include <experimental/__simd/utility.h>
+
+#if _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+
+_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
+inline namespace parallelism_v2 {
+namespace simd_abi {
+template <int _Np>
+struct __vec_ext {
+  static constexpr size_t __simd_size = _Np;
+};
+} // namespace simd_abi
+
+template <int _Np>
+inline constexpr bool is_abi_tag_v<simd_abi::__vec_ext<_Np>> = _Np > 0 && _Np <= 32;
+
+template <class _Tp, int _Np>
+struct __simd_storage<_Tp, simd_abi::__vec_ext<_Np>> {
+  _Tp __data __attribute__((__vector_size__(std::__bit_ceil((sizeof(_Tp) * _Np)))));
+
+  _LIBCPP_HIDE_FROM_ABI _Tp __get(size_t __idx) const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__idx >= 0 && __idx < _Np, "Index is out of bounds");
+    return __data[__idx];
+  }
+  _LIBCPP_HIDE_FROM_ABI void __set(size_t __idx, _Tp __v) noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__idx >= 0 && __idx < _Np, "Index is out of bounds");
+    __data[__idx] = __v;
+  }
+};
+
+template <class _Tp, int _Np>
+struct __mask_storage<_Tp, simd_abi::__vec_ext<_Np>>
+    : __simd_storage<decltype(experimental::__choose_mask_type<_Tp>()), simd_abi::__vec_ext<_Np>> {};
+
+template <class _Tp, int _Np>
+struct __simd_operations<_Tp, simd_abi::__vec_ext<_Np>> {
+  using _SimdStorage = __simd_storage<_Tp, simd_abi::__vec_ext<_Np>>;
+  using _MaskStorage = __mask_storage<_Tp, simd_abi::__vec_ext<_Np>>;
+
+  static _LIBCPP_HIDE_FROM_ABI _SimdStorage __broadcast(_Tp __v) noexcept {
+    _SimdStorage __result;
+    for (int __i = 0; __i < _Np; ++__i) {
+      __result.__set(__i, __v);
+    }
+    return __result;
+  }
+
+  template <class _Generator, size_t... _Is>
+  static _LIBCPP_HIDE_FROM_ABI _SimdStorage __generate_init(_Generator&& __g, std::index_sequence<_Is...>) {
+    return _SimdStorage{{__g(std::integral_constant<size_t, _Is>())...}};
+  }
+
+  template <class _Generator>
+  static _LIBCPP_HIDE_FROM_ABI _SimdStorage __generate(_Generator&& __g) noexcept {
+    return __generate_init(std::forward<_Generator>(__g), std::make_index_sequence<_Np>());
+  }
+
+  template <class _Up>
+  static _LIBCPP_HIDE_FROM_ABI void __load(_SimdStorage& __s, const _Up* __mem) noexcept {
+    for (size_t __i = 0; __i < _Np; __i++)
+      __s.__data[__i] = static_cast<_Tp>(__mem[__i]);
+  }
+
+  template <class _Up>
+  static _LIBCPP_HIDE_FROM_ABI void __store(_SimdStorage __s, _Up* __mem) noexcept {
+    for (size_t __i = 0; __i < _Np; __i++)
+      __mem[__i] = static_cast<_Up>(__s.__data[__i]);
+  }
+};
+
+template <class _Tp, int _Np>
+struct __mask_operations<_Tp, simd_abi::__vec_ext<_Np>> {
+  using _MaskStorage = __mask_storage<_Tp, simd_abi::__vec_ext<_Np>>;
+
+  static _LIBCPP_HIDE_FROM_ABI _MaskStorage __broadcast(bool __v) noexcept {
+    _MaskStorage __result;
+    auto __all_bits_v = experimental::__set_all_bits<_Tp>(__v);
+    for (int __i = 0; __i < _Np; ++__i) {
+      __result.__set(__i, __all_bits_v);
+    }
+    return __result;
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI void __load(_MaskStorage& __s, const bool* __mem) noexcept {
+    for (size_t __i = 0; __i < _Np; __i++)
+      __s.__data[__i] = experimental::__set_all_bits<_Tp>(__mem[__i]);
+  }
+
+  static _LIBCPP_HIDE_FROM_ABI void __store(_MaskStorage __s, bool* __mem) noexcept {
+    for (size_t __i = 0; __i < _Np; __i++)
+      __mem[__i] = static_cast<bool>(__s.__data[__i]);
+  }
+};
+
+} // namespace parallelism_v2
+_LIBCPP_END_NAMESPACE_EXPERIMENTAL
+
+#endif // _LIBCPP_STD_VER >= 17 && defined(_LIBCPP_ENABLE_EXPERIMENTAL)
+#endif // _LIBCPP_EXPERIMENTAL___SIMD_VEC_EXT_H
diff --git a/third_party/libcxx/experimental/deque b/third_party/libcxx/experimental/deque
deleted file mode 100644
index 46962afbb..000000000
--- a/third_party/libcxx/experimental/deque
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_DEQUE
-#define _LIBCPP_EXPERIMENTAL_DEQUE
-
-/*
-    experimental/deque synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class T>
-  using deque = std::deque<T,polymorphic_allocator<T>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <deque>
-#include <experimental/__config>
-#include <experimental/memory_resource>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _ValueT>
-using deque = _VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_DEQUE */
diff --git a/third_party/libcxx/experimental/forward_list b/third_party/libcxx/experimental/forward_list
deleted file mode 100644
index 5d2686deb..000000000
--- a/third_party/libcxx/experimental/forward_list
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_FORWARD_LIST
-#define _LIBCPP_EXPERIMENTAL_FORWARD_LIST
-
-/*
-    experimental/forward_list synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class T>
-  using forward_list = std::forward_list<T,polymorphic_allocator<T>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <forward_list>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _ValueT>
-using forward_list = _VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_FORWARD_LIST */
diff --git a/third_party/libcxx/experimental/iterator b/third_party/libcxx/experimental/iterator
index a5e3dffba..de82da2d3 100644
--- a/third_party/libcxx/experimental/iterator
+++ b/third_party/libcxx/experimental/iterator
@@ -52,19 +52,20 @@ namespace std {
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__memory/addressof.h>
 #include <__type_traits/decay.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <experimental/__config>
-#include <iosfwd> // char_traits
 #include <iterator>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 14
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS
@@ -72,54 +73,54 @@ _LIBCPP_BEGIN_NAMESPACE_LFTS
 template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
 class ostream_joiner {
 public:
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef basic_ostream<char_type, traits_type> ostream_type;
+  typedef output_iterator_tag iterator_category;
+  typedef void value_type;
+  typedef void difference_type;
+  typedef void pointer;
+  typedef void reference;
 
-    typedef _CharT                               char_type;
-    typedef _Traits                              traits_type;
-    typedef basic_ostream<char_type,traits_type> ostream_type;
-    typedef output_iterator_tag                  iterator_category;
-    typedef void                                 value_type;
-    typedef void                                 difference_type;
-    typedef void                                 pointer;
-    typedef void                                 reference;
+  _LIBCPP_HIDE_FROM_ABI ostream_joiner(ostream_type& __os, _Delim&& __d)
+      : __output_iter_(std::addressof(__os)), __delim_(std::move(__d)), __first_(true) {}
 
-    _LIBCPP_HIDE_FROM_ABI ostream_joiner(ostream_type& __os, _Delim&& __d)
-        : __output_iter_(_VSTD::addressof(__os)), __delim_(_VSTD::move(__d)), __first_(true) {}
+  _LIBCPP_HIDE_FROM_ABI ostream_joiner(ostream_type& __os, const _Delim& __d)
+      : __output_iter_(std::addressof(__os)), __delim_(__d), __first_(true) {}
 
-    _LIBCPP_HIDE_FROM_ABI ostream_joiner(ostream_type& __os, const _Delim& __d)
-        : __output_iter_(_VSTD::addressof(__os)), __delim_(__d), __first_(true) {}
+  template <typename _Tp>
+  _LIBCPP_HIDE_FROM_ABI ostream_joiner& operator=(const _Tp& __v) {
+    if (!__first_)
+      *__output_iter_ << __delim_;
+    __first_ = false;
+    *__output_iter_ << __v;
+    return *this;
+  }
 
-
-    template<typename _Tp>
-    _LIBCPP_HIDE_FROM_ABI ostream_joiner& operator=(const _Tp& __v)
-    {
-        if (!__first_)
-            *__output_iter_ << __delim_;
-        __first_ = false;
-        *__output_iter_ << __v;
-        return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI ostream_joiner& operator*()     _NOEXCEPT { return *this; }
-    _LIBCPP_HIDE_FROM_ABI ostream_joiner& operator++()    _NOEXCEPT { return *this; }
-    _LIBCPP_HIDE_FROM_ABI ostream_joiner& operator++(int) _NOEXCEPT { return *this; }
+  _LIBCPP_HIDE_FROM_ABI ostream_joiner& operator*() _NOEXCEPT { return *this; }
+  _LIBCPP_HIDE_FROM_ABI ostream_joiner& operator++() _NOEXCEPT { return *this; }
+  _LIBCPP_HIDE_FROM_ABI ostream_joiner& operator++(int) _NOEXCEPT { return *this; }
 
 private:
-    ostream_type*   __output_iter_;
-    _Delim          __delim_;
-    bool            __first_;
+  ostream_type* __output_iter_;
+  _Delim __delim_;
+  bool __first_;
 };
 
-
 template <class _CharT, class _Traits, class _Delim>
 _LIBCPP_HIDE_FROM_ABI ostream_joiner<__decay_t<_Delim>, _CharT, _Traits>
-make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d)
-{ return ostream_joiner<__decay_t<_Delim>, _CharT, _Traits>(__os, _VSTD::forward<_Delim>(__d)); }
+make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim&& __d) {
+  return ostream_joiner<__decay_t<_Delim>, _CharT, _Traits>(__os, std::forward<_Delim>(__d));
+}
 
 _LIBCPP_END_NAMESPACE_LFTS
 
 #endif // _LIBCPP_STD_VER >= 14
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <iosfwd>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/experimental/list b/third_party/libcxx/experimental/list
deleted file mode 100644
index 06abe8702..000000000
--- a/third_party/libcxx/experimental/list
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_LIST
-#define _LIBCPP_EXPERIMENTAL_LIST
-
-/*
-    experimental/list synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class T>
-  using list = std::list<T,polymorphic_allocator<T>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <list>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _ValueT>
-using list = _VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_LIST */
diff --git a/third_party/libcxx/experimental/map b/third_party/libcxx/experimental/map
deleted file mode 100644
index 8ec94e4a5..000000000
--- a/third_party/libcxx/experimental/map
+++ /dev/null
@@ -1,62 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_MAP
-#define _LIBCPP_EXPERIMENTAL_MAP
-
-/*
-    experimental/map synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class Key, class T, class Compare = less<Key>>
-  using map = std::map<Key, T, Compare,
-                       polymorphic_allocator<pair<const Key,T>>>;
-
-  template <class Key, class T, class Compare = less<Key>>
-  using multimap = std::multimap<Key, T, Compare,
-                                 polymorphic_allocator<pair<const Key,T>>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <map>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Key, class _Value, class  _Compare = less<_Key>>
-using map = _VSTD::map<_Key, _Value, _Compare,
-                        polymorphic_allocator<pair<const _Key, _Value>>>;
-
-template <class _Key, class _Value, class  _Compare = less<_Key>>
-using multimap = _VSTD::multimap<_Key, _Value, _Compare,
-                        polymorphic_allocator<pair<const _Key, _Value>>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_MAP */
diff --git a/third_party/libcxx/experimental/memory b/third_party/libcxx/experimental/memory
new file mode 100644
index 000000000..e9663d43a
--- /dev/null
+++ b/third_party/libcxx/experimental/memory
@@ -0,0 +1,198 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_EXPERIMENTAL_MEMORY
+#define _LIBCPP_EXPERIMENTAL_MEMORY
+
+/*
+    experimental/memory synopsis
+
+namespace std::experimental::inline fundamentals_v2  {
+
+template <class W> class observer_ptr {
+public:
+    using element_type = W;
+    using pointer = add_pointer_t<W>; // exposition-only
+    using reference = add_lvalue_reference_t<W>; // exposition-only
+
+    // default ctor
+    constexpr observer_ptr() noexcept;
+
+    // pointer-accepting ctors
+    constexpr observer_ptr(nullptr_t) noexcept;
+    constexpr explicit observer_ptr(pointer) noexcept;
+
+    // copying ctors (in addition to compiler-generated copy ctor)
+    template <class W2> constexpr observer_ptr(observer_ptr<W2>) noexcept;
+
+    // observers
+    constexpr pointer get() const noexcept;
+    constexpr reference operator*() const;
+    constexpr pointer operator->() const noexcept;
+    constexpr explicit operator bool() const noexcept;
+
+    // conversions
+    constexpr explicit operator pointer() const noexcept;
+
+    // modifiers
+    constexpr pointer release() noexcept;
+    constexpr void reset(pointer = nullptr) noexcept;
+    constexpr void swap(observer_ptr&) noexcept;
+};
+
+}
+*/
+
+#include <__functional/hash.h>
+#include <__functional/operations.h>
+#include <__type_traits/add_lvalue_reference.h>
+#include <__type_traits/add_pointer.h>
+#include <__type_traits/common_type.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_convertible.h>
+#include <cstddef>
+#include <experimental/__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#ifdef _LIBCPP_ENABLE_EXPERIMENTAL
+
+_LIBCPP_BEGIN_NAMESPACE_LFTS_V2
+
+#  if _LIBCPP_STD_VER >= 17
+
+template <class _Wp>
+class observer_ptr {
+public:
+  using element_type = _Wp;
+
+  // constructors
+  _LIBCPP_HIDE_FROM_ABI constexpr observer_ptr() noexcept : __ptr_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr observer_ptr(nullptr_t) noexcept : __ptr_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit observer_ptr(element_type* __p) noexcept : __ptr_(__p) {}
+
+  template <class _W2, __enable_if_t<is_convertible<_W2*, _Wp*>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI constexpr observer_ptr(observer_ptr<_W2> __other) noexcept : __ptr_(__other.get()) {}
+
+  // observers
+  _LIBCPP_HIDE_FROM_ABI constexpr element_type* get() const noexcept { return __ptr_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr add_lvalue_reference_t<_Wp> operator*() const { return *__ptr_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr element_type* operator->() const noexcept { return __ptr_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __ptr_ != nullptr; }
+
+  // conversions
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator element_type*() const noexcept { return __ptr_; }
+
+  // modifiers
+  _LIBCPP_HIDE_FROM_ABI constexpr void reset(element_type* __p = nullptr) noexcept { __ptr_ = __p; }
+  _LIBCPP_HIDE_FROM_ABI constexpr void swap(observer_ptr& __other) noexcept {
+    observer_ptr __tmp = __other;
+    __other            = *this;
+    *this              = __tmp;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr element_type* release() noexcept {
+    observer_ptr __p;
+    __p.swap(*this);
+    return __p.get();
+  }
+
+private:
+  element_type* __ptr_;
+};
+
+// specializations
+
+template <class _Wp>
+_LIBCPP_HIDE_FROM_ABI constexpr void swap(observer_ptr<_Wp>& __a, observer_ptr<_Wp>& __b) noexcept {
+  __a.swap(__b);
+}
+
+template <class _Wp>
+_LIBCPP_HIDE_FROM_ABI observer_ptr<_Wp> make_observer(_Wp* __ptr) noexcept {
+  return observer_ptr<_Wp>{__ptr};
+}
+
+template <class _W1, class _W2>
+_LIBCPP_HIDE_FROM_ABI bool operator==(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
+  return __a.get() == __b.get();
+}
+
+template <class _W1, class _W2>
+_LIBCPP_HIDE_FROM_ABI bool operator!=(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
+  return !(__a == __b);
+}
+
+template <class _Wp>
+_LIBCPP_HIDE_FROM_ABI bool operator==(observer_ptr<_Wp> __p, nullptr_t) {
+  return !__p;
+}
+
+template <class _Wp>
+_LIBCPP_HIDE_FROM_ABI bool operator==(nullptr_t, observer_ptr<_Wp> __p) {
+  return !__p;
+}
+
+template <class _Wp>
+_LIBCPP_HIDE_FROM_ABI bool operator!=(observer_ptr<_Wp> __p, nullptr_t) {
+  return (bool)__p;
+}
+
+template <class _Wp>
+_LIBCPP_HIDE_FROM_ABI bool operator!=(nullptr_t, observer_ptr<_Wp> __p) {
+  return (bool)__p;
+}
+
+template <class _W1, class _W2>
+_LIBCPP_HIDE_FROM_ABI bool operator<(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
+  return std::less<typename std::common_type<_W1*, _W2*>::type>()(__a.get(), __b.get());
+}
+
+template <class _W1, class _W2>
+_LIBCPP_HIDE_FROM_ABI bool operator>(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
+  return __b < __a;
+}
+
+template <class _W1, class _W2>
+_LIBCPP_HIDE_FROM_ABI bool operator<=(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
+  return !(__a > __b);
+}
+
+template <class _W1, class _W2>
+_LIBCPP_HIDE_FROM_ABI bool operator>=(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
+  return !(__a < __b);
+}
+
+#  endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_END_NAMESPACE_LFTS_V2
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// hash
+
+#  if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+struct hash<experimental::observer_ptr<_Tp>> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const experimental::observer_ptr<_Tp>& __ptr) const noexcept {
+    return hash<_Tp*>()(__ptr.get());
+  }
+};
+#  endif // _LIBCPP_STD_VER >= 17
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_ENABLE_EXPERIMENTAL
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <limits>
+#endif
+
+#endif /* _LIBCPP_EXPERIMENTAL_MEMORY */
diff --git a/third_party/libcxx/experimental/memory_resource b/third_party/libcxx/experimental/memory_resource
deleted file mode 100644
index 4dc9845dc..000000000
--- a/third_party/libcxx/experimental/memory_resource
+++ /dev/null
@@ -1,444 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE
-#define _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE
-
-/**
-    experimental/memory_resource synopsis
-
-// C++1y
-
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  class memory_resource;
-
-  bool operator==(const memory_resource& a,
-                  const memory_resource& b) noexcept;
-  bool operator!=(const memory_resource& a,
-                  const memory_resource& b) noexcept;
-
-  template <class Tp> class polymorphic_allocator;
-
-  template <class T1, class T2>
-  bool operator==(const polymorphic_allocator<T1>& a,
-                  const polymorphic_allocator<T2>& b) noexcept;
-  template <class T1, class T2>
-  bool operator!=(const polymorphic_allocator<T1>& a,
-                  const polymorphic_allocator<T2>& b) noexcept;
-
-  // The name resource_adaptor_imp is for exposition only.
-  template <class Allocator> class resource_adaptor_imp;
-
-  template <class Allocator>
-    using resource_adaptor = resource_adaptor_imp<
-      allocator_traits<Allocator>::rebind_alloc<char>>;
-
-  // Global memory resources
-  memory_resource* new_delete_resource() noexcept;
-  memory_resource* null_memory_resource() noexcept;
-
-  // The default memory resource
-  memory_resource* set_default_resource(memory_resource* r) noexcept;
-  memory_resource* get_default_resource() noexcept;
-
-  // Standard memory resources
-  struct pool_options;
-  class synchronized_pool_resource;
-  class unsynchronized_pool_resource;
-  class monotonic_buffer_resource;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__memory/allocator_traits.h>
-#include <__type_traits/aligned_storage.h>
-#include <__utility/move.h>
-#include <cstddef>
-#include <experimental/__config>
-#include <experimental/__memory>
-#include <limits>
-#include <new>
-#include <stdexcept>
-#include <tuple>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#define _LIBCPP_DEPCREATED_MEMORY_RESOURCE(name)                                                                       \
-  _LIBCPP_DEPRECATED_("'std::experimental::pmr::" name                                                                 \
-                      "' is deprecated and will be removed in LLVM 18. Use 'std::pmr::" name "' instead.")
-
-#ifndef _LIBCPP_CXX03_LANG
-
-// Round __s up to next multiple of __a.
-inline _LIBCPP_INLINE_VISIBILITY
-size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__s + __a > __s, "aligned allocation size overflows");
-    return (__s + __a - 1) & ~(__a - 1);
-}
-
-// 8.5, memory.resource
-class _LIBCPP_DEPCREATED_MEMORY_RESOURCE("memory_resource") _LIBCPP_TYPE_VIS memory_resource
-{
-    static const size_t __max_align = _LIBCPP_ALIGNOF(max_align_t);
-
-// 8.5.2, memory.resource.public
-public:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual ~memory_resource() = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    void* allocate(size_t __bytes, size_t __align = __max_align)
-        { return do_allocate(__bytes, __align); }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
-        { do_deallocate(__p, __bytes, __align); }
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool is_equal(memory_resource const & __other) const _NOEXCEPT
-        { return do_is_equal(__other); }
-
-// 8.5.3, memory.resource.priv
-private:
-    virtual void* do_allocate(size_t, size_t) = 0;
-    virtual void do_deallocate(void*, size_t, size_t) = 0;
-    virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
-};
-
-// 8.5.4, memory.resource.eq
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator==(memory_resource, memory_resource)") inline _LIBCPP_INLINE_VISIBILITY
-bool operator==(memory_resource const & __lhs,
-                memory_resource const & __rhs) _NOEXCEPT
-{
-    return &__lhs == &__rhs || __lhs.is_equal(__rhs);
-}
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator!=(memory_resource, memory_resource)") inline _LIBCPP_INLINE_VISIBILITY
-bool operator!=(memory_resource const & __lhs,
-                memory_resource const & __rhs) _NOEXCEPT
-{
-    return !(__lhs == __rhs);
-}
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("new_delete_resource()") _LIBCPP_FUNC_VIS
-memory_resource * new_delete_resource() _NOEXCEPT;
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("null_memory_resource()") _LIBCPP_FUNC_VIS
-memory_resource * null_memory_resource() _NOEXCEPT;
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("get_default_resource()") _LIBCPP_FUNC_VIS
-memory_resource * get_default_resource() _NOEXCEPT;
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("set_default_resource()") _LIBCPP_FUNC_VIS
-memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT;
-
-// 8.6, memory.polymorphic.allocator.class
-
-// 8.6.1, memory.polymorphic.allocator.overview
-template <class _ValueType>
-class _LIBCPP_DEPCREATED_MEMORY_RESOURCE("polymorphic_allocator") _LIBCPP_TEMPLATE_VIS polymorphic_allocator
-{
-public:
-    typedef _ValueType value_type;
-
-    // 8.6.2, memory.polymorphic.allocator.ctor
-    _LIBCPP_INLINE_VISIBILITY
-    polymorphic_allocator() _NOEXCEPT
-      : __res_(_VSTD_LFTS_PMR::get_default_resource())
-    {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    polymorphic_allocator(memory_resource * __r) _NOEXCEPT
-      : __res_(__r)
-    {}
-
-    _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(polymorphic_allocator const &) = default;
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY
-    polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT
-      : __res_(__other.resource())
-    {}
-
-    polymorphic_allocator &
-    operator=(polymorphic_allocator const &) = delete;
-
-    // 8.6.3, memory.polymorphic.allocator.mem
-    _LIBCPP_INLINE_VISIBILITY
-    _ValueType* allocate(size_t __n) {
-        if (__n > __max_size())
-            __throw_bad_array_new_length();
-        return static_cast<_ValueType*>(
-            __res_->allocate(__n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType))
-        );
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
-        _LIBCPP_ASSERT(__n <= __max_size(),
-                       "deallocate called for size which exceeds max_size()");
-        __res_->deallocate(__p, __n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType));
-    }
-
-    template <class _Tp, class ..._Ts>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(_Tp* __p, _Ts &&... __args)
-    {
-        _VSTD_LFTS::__lfts_user_alloc_construct(
-            __p, *this, _VSTD::forward<_Ts>(__args)...
-          );
-    }
-
-    template <class _T1, class _T2, class ..._Args1, class ..._Args2>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
-                   tuple<_Args1...> __x, tuple<_Args2...> __y)
-    {
-        ::new ((void*)__p) pair<_T1, _T2>(piecewise_construct
-          , __transform_tuple(
-              typename __lfts_uses_alloc_ctor<
-                  _T1, polymorphic_allocator&, _Args1...
-              >::type()
-            , _VSTD::move(__x)
-            , typename __make_tuple_indices<sizeof...(_Args1)>::type{}
-          )
-          , __transform_tuple(
-              typename __lfts_uses_alloc_ctor<
-                  _T2, polymorphic_allocator&, _Args2...
-              >::type()
-            , _VSTD::move(__y)
-            , typename __make_tuple_indices<sizeof...(_Args2)>::type{}
-          )
-        );
-    }
-
-    template <class _T1, class _T2>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(pair<_T1, _T2>* __p) {
-        construct(__p, piecewise_construct, tuple<>(), tuple<>());
-    }
-
-    template <class _T1, class _T2, class _Up, class _Vp>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) {
-        construct(__p, piecewise_construct
-          , _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u))
-          , _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v)));
-    }
-
-    template <class _T1, class _T2, class _U1, class _U2>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) {
-        construct(__p, piecewise_construct
-            , _VSTD::forward_as_tuple(__pr.first)
-            , _VSTD::forward_as_tuple(__pr.second));
-    }
-
-    template <class _T1, class _T2, class _U1, class _U2>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){
-        construct(__p, piecewise_construct
-            , _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first))
-            , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second)));
-    }
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY
-    void destroy(_Tp * __p) _NOEXCEPT
-        { __p->~_Tp(); }
-
-    _LIBCPP_INLINE_VISIBILITY
-    polymorphic_allocator
-    select_on_container_copy_construction() const _NOEXCEPT
-        { return polymorphic_allocator(); }
-
-    _LIBCPP_INLINE_VISIBILITY
-    memory_resource * resource() const _NOEXCEPT
-        { return __res_; }
-
-private:
-    template <class ..._Args, size_t ..._Idx>
-    _LIBCPP_INLINE_VISIBILITY
-    tuple<_Args&&...>
-    __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
-                      __tuple_indices<_Idx...>) const
-    {
-        return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...);
-    }
-
-    template <class ..._Args, size_t ..._Idx>
-    _LIBCPP_INLINE_VISIBILITY
-    tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>
-    __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
-                      __tuple_indices<_Idx...>)
-    {
-        using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>;
-        return _Tup(allocator_arg, *this,
-                    _VSTD::get<_Idx>(_VSTD::move(__t))...);
-    }
-
-    template <class ..._Args, size_t ..._Idx>
-    _LIBCPP_INLINE_VISIBILITY
-    tuple<_Args&&..., polymorphic_allocator&>
-    __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
-                      __tuple_indices<_Idx...>)
-    {
-        using _Tup = tuple<_Args&&..., polymorphic_allocator&>;
-        return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    size_t __max_size() const _NOEXCEPT
-        { return numeric_limits<size_t>::max() / sizeof(value_type); }
-
-    memory_resource * __res_;
-};
-
-// 8.6.4, memory.polymorphic.allocator.eq
-
-template <class _Tp, class _Up>
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator==(const polymorphic_allocator&, const polymorphic_allocator&)")
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator==(polymorphic_allocator<_Tp> const & __lhs,
-                polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
-{
-    return *__lhs.resource() == *__rhs.resource();
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator!=(const polymorphic_allocator&, const polymorphic_allocator&)")
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
-                polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
-{
-    return !(__lhs == __rhs);
-}
-
-// 8.7, memory.resource.adaptor
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-// 8.7.1, memory.resource.adaptor.overview
-template <class _CharAlloc>
-class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp
-  : public memory_resource
-{
-    using _CTraits = allocator_traits<_CharAlloc>;
-    static_assert(is_same<typename _CTraits::value_type, char>::value
-               && is_same<typename _CTraits::pointer, char*>::value
-               && is_same<typename _CTraits::void_pointer, void*>::value, "");
-
-    static const size_t _MaxAlign = _LIBCPP_ALIGNOF(max_align_t);
-
-    using _Alloc = typename _CTraits::template rebind_alloc<
-            typename aligned_storage<_MaxAlign, _MaxAlign>::type
-        >;
-
-    using _ValueType = typename _Alloc::value_type;
-
-    _Alloc __alloc_;
-
-public:
-    typedef _CharAlloc allocator_type;
-
-    _LIBCPP_HIDE_FROM_ABI __resource_adaptor_imp() = default;
-    _LIBCPP_HIDE_FROM_ABI __resource_adaptor_imp(__resource_adaptor_imp const &) = default;
-    _LIBCPP_HIDE_FROM_ABI __resource_adaptor_imp(__resource_adaptor_imp &&) = default;
-
-    // 8.7.2, memory.resource.adaptor.ctor
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __resource_adaptor_imp(allocator_type const & __a)
-      : __alloc_(__a)
-    {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __resource_adaptor_imp(allocator_type && __a)
-      : __alloc_(_VSTD::move(__a))
-    {}
-
-    _LIBCPP_HIDE_FROM_ABI __resource_adaptor_imp &
-    operator=(__resource_adaptor_imp const &) = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const
-    { return __alloc_; }
-
-// 8.7.3, memory.resource.adaptor.mem
-private:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void * do_allocate(size_t __bytes, size_t) override
-    {
-        if (__bytes > __max_size())
-            __throw_bad_array_new_length();
-        size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
-        return __alloc_.allocate(__s);
-    }
-
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void do_deallocate(void * __p, size_t __bytes, size_t) override
-    {
-        _LIBCPP_ASSERT(__bytes <= __max_size(),
-            "do_deallocate called for size which exceeds the maximum allocation size");
-        size_t __s = __aligned_allocation_size(__bytes, _MaxAlign) / _MaxAlign;
-        __alloc_.deallocate((_ValueType*)__p, __s);
-    }
-
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL bool do_is_equal(memory_resource const & __other) const _NOEXCEPT override {
-        __resource_adaptor_imp const * __p
-          = dynamic_cast<__resource_adaptor_imp const *>(&__other);
-        return __p  ? __alloc_ == __p->__alloc_ : false;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    size_t __max_size() const _NOEXCEPT {
-        return numeric_limits<size_t>::max() - _MaxAlign;
-    }
-};
-
-template <class _Alloc>
-using resource_adaptor = __resource_adaptor_imp<
-    typename allocator_traits<_Alloc>::template rebind_alloc<char>
-  >;
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-_LIBCPP_POP_MACROS
-
-#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-#  include <atomic>
-#  include <climits>
-#  include <concepts>
-#  include <cstdlib>
-#  include <cstring>
-#  include <ctime>
-#  include <iterator>
-#  include <memory>
-#  include <ratio>
-#  include <type_traits>
-#  include <variant>
-#endif
-
-#endif /* _LIBCPP_EXPERIMENTAL_MEMORY_RESOURCE */
diff --git a/third_party/libcxx/experimental/propagate_const b/third_party/libcxx/experimental/propagate_const
index acdc16cda..d7a695d83 100644
--- a/third_party/libcxx/experimental/propagate_const
+++ b/third_party/libcxx/experimental/propagate_const
@@ -19,8 +19,8 @@
     template <class T> class propagate_const;
 
     // [propagate_const.underlying], underlying pointer access
-    constexpr const _Tp& _VSTD_LFTS_V2::get_underlying(const propagate_const<T>& pt) noexcept;
-    constexpr T& _VSTD_LFTS_V2::get_underlying(propagate_const<T>& pt) noexcept;
+    constexpr const _Tp& get_underlying(const propagate_const<T>& pt) noexcept;
+    constexpr T& get_underlying(propagate_const<T>& pt) noexcept;
 
     // [propagate_const.relational], relational operators
     template <class T> constexpr bool operator==(const propagate_const<T>& pt, nullptr_t);
@@ -93,23 +93,22 @@
   } // namespace experimental
 
   // [propagate_const.hash], hash support
-  template <class T> struct hash<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct hash<experimental::propagate_const<T>>;
 
   // [propagate_const.comparison_function_objects], comparison function objects
-  template <class T> struct equal_to<experimental::fundamentals_v2::propagate_const<T>>;
-  template <class T> struct not_equal_to<experimental::fundamentals_v2::propagate_const<T>>;
-  template <class T> struct less<experimental::fundamentals_v2::propagate_const<T>>;
-  template <class T> struct greater<experimental::fundamentals_v2::propagate_const<T>>;
-  template <class T> struct less_equal<experimental::fundamentals_v2::propagate_const<T>>;
-  template <class T> struct greater_equal<experimental::fundamentals_v2::propagate_const<T>>;
+  template <class T> struct equal_to<experimental::propagate_const<T>>;
+  template <class T> struct not_equal_to<experimental::propagate_const<T>>;
+  template <class T> struct less<experimental::propagate_const<T>>;
+  template <class T> struct greater<experimental::propagate_const<T>>;
+  template <class T> struct less_equal<experimental::propagate_const<T>>;
+  template <class T> struct greater_equal<experimental::propagate_const<T>>;
 
 } // namespace std
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__functional/operations.h>
-#include <__fwd/hash.h>
+#include <__fwd/functional.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/enable_if.h>
@@ -135,6 +134,9 @@
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 #if _LIBCPP_STD_VER >= 14
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2
@@ -143,356 +145,255 @@ template <class _Tp>
 class propagate_const;
 
 template <class _Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
+inline _LIBCPP_HIDE_FROM_ABI constexpr const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
 
 template <class _Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-_Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
+inline _LIBCPP_HIDE_FROM_ABI constexpr _Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
 
 template <class _Tp>
-class propagate_const
-{
+class propagate_const {
 public:
   typedef remove_reference_t<decltype(*std::declval<_Tp&>())> element_type;
 
-  static_assert(!is_array<_Tp>::value,
-      "Instantiation of propagate_const with an array type is ill-formed.");
-  static_assert(!is_reference<_Tp>::value,
-      "Instantiation of propagate_const with a reference type is ill-formed.");
+  static_assert(!is_array<_Tp>::value, "Instantiation of propagate_const with an array type is ill-formed.");
+  static_assert(!is_reference<_Tp>::value, "Instantiation of propagate_const with a reference type is ill-formed.");
   static_assert(!(is_pointer<_Tp>::value && is_function<__remove_pointer_t<_Tp> >::value),
-      "Instantiation of propagate_const with a function-pointer type is ill-formed.");
+                "Instantiation of propagate_const with a function-pointer type is ill-formed.");
   static_assert(!(is_pointer<_Tp>::value && is_same<__remove_cv_t<__remove_pointer_t<_Tp> >, void>::value),
-      "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");
+                "Instantiation of propagate_const with a pointer to (possibly cv-qualified) void is ill-formed.");
 
 private:
   template <class _Up>
-  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up* __u)
-  {
+  static _LIBCPP_HIDE_FROM_ABI constexpr element_type* __get_pointer(_Up* __u) {
     return __u;
   }
 
   template <class _Up>
-  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type* __get_pointer(_Up& __u)
-  {
+  static _LIBCPP_HIDE_FROM_ABI constexpr element_type* __get_pointer(_Up& __u) {
     return __get_pointer(__u.get());
   }
 
   template <class _Up>
-  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up* __u)
-  {
+  static _LIBCPP_HIDE_FROM_ABI constexpr const element_type* __get_pointer(const _Up* __u) {
     return __u;
   }
 
   template <class _Up>
-  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type* __get_pointer(const _Up& __u)
-  {
+  static _LIBCPP_HIDE_FROM_ABI constexpr const element_type* __get_pointer(const _Up& __u) {
     return __get_pointer(__u.get());
   }
 
   template <class _Up>
-  struct __is_propagate_const : false_type
-  {
-  };
+  struct __is_propagate_const : false_type {};
 
   template <class _Up>
-  struct __is_propagate_const<propagate_const<_Up>> : true_type
-  {
-  };
+  struct __is_propagate_const<propagate_const<_Up>> : true_type {};
 
   _Tp __t_;
 
 public:
+  template <class _Up>
+  friend constexpr const _Up& experimental::fundamentals_v2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
+  template <class _Up>
+  friend constexpr _Up& experimental::fundamentals_v2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
 
-  template <class _Up> friend _LIBCPP_CONSTEXPR const _Up& ::_VSTD_LFTS_V2::get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
-  template <class _Up> friend _LIBCPP_CONSTEXPR _Up& ::_VSTD_LFTS_V2::get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
-
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const() = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr propagate_const() = default;
 
   propagate_const(const propagate_const&) = delete;
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const(propagate_const&&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(propagate_const&&) = default;
 
-  template <class _Up, enable_if_t<!is_convertible<_Up, _Tp>::value &&
-                                 is_constructible<_Tp, _Up&&>::value,bool> = true>
-  explicit _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
-      : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
-  {
-  }
+  template <class _Up,
+            enable_if_t<!is_convertible<_Up, _Tp>::value && is_constructible<_Tp, _Up&&>::value, bool> = true>
+  explicit _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(propagate_const<_Up>&& __pu)
+      : __t_(std::move(experimental::get_underlying(__pu))) {}
 
-  template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
-                                 is_constructible<_Tp, _Up&&>::value,bool> = false>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const(propagate_const<_Up>&& __pu)
-      : __t_(std::move(_VSTD_LFTS_V2::get_underlying(__pu)))
-  {
-  }
+  template <class _Up,
+            enable_if_t<is_convertible<_Up&&, _Tp>::value && is_constructible<_Tp, _Up&&>::value, bool> = false>
+  _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(propagate_const<_Up>&& __pu)
+      : __t_(std::move(experimental::get_underlying(__pu))) {}
 
-  template <class _Up, enable_if_t<!is_convertible<_Up&&, _Tp>::value &&
-                                 is_constructible<_Tp, _Up&&>::value &&
-                                 !__is_propagate_const<decay_t<_Up>>::value,bool> = true>
-  explicit _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
-      : __t_(std::forward<_Up>(__u))
-  {
-  }
+  template <class _Up,
+            enable_if_t<!is_convertible<_Up&&, _Tp>::value && is_constructible<_Tp, _Up&&>::value &&
+                            !__is_propagate_const<decay_t<_Up>>::value,
+                        bool> = true>
+  explicit _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(_Up&& __u) : __t_(std::forward<_Up>(__u)) {}
 
-  template <class _Up, enable_if_t<is_convertible<_Up&&, _Tp>::value &&
-                                 is_constructible<_Tp, _Up&&>::value &&
-                                 !__is_propagate_const<decay_t<_Up>>::value,bool> = false>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const(_Up&& __u)
-      : __t_(std::forward<_Up>(__u))
-  {
-  }
+  template <class _Up,
+            enable_if_t<is_convertible<_Up&&, _Tp>::value && is_constructible<_Tp, _Up&&>::value &&
+                            !__is_propagate_const<decay_t<_Up>>::value,
+                        bool> = false>
+  _LIBCPP_HIDE_FROM_ABI constexpr propagate_const(_Up&& __u) : __t_(std::forward<_Up>(__u)) {}
 
   propagate_const& operator=(const propagate_const&) = delete;
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const&&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr propagate_const& operator=(propagate_const&&) = default;
 
   template <class _Up>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const& operator=(propagate_const<_Up>&& __pu)
-  {
-    __t_ = std::move(_VSTD_LFTS_V2::get_underlying(__pu));
+  _LIBCPP_HIDE_FROM_ABI constexpr propagate_const& operator=(propagate_const<_Up>&& __pu) {
+    __t_ = std::move(experimental::get_underlying(__pu));
     return *this;
   }
 
   template <class _Up, class _Vp = enable_if_t<!__is_propagate_const<decay_t<_Up>>::value>>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR propagate_const& operator=(_Up&& __u)
-  {
+  _LIBCPP_HIDE_FROM_ABI constexpr propagate_const& operator=(_Up&& __u) {
     __t_ = std::forward<_Up>(__u);
     return *this;
   }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type* get() const
-  {
-    return __get_pointer(__t_);
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr const element_type* get() const { return __get_pointer(__t_); }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type* get()
-  {
-    return __get_pointer(__t_);
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr element_type* get() { return __get_pointer(__t_); }
 
-  _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR operator bool() const
-  {
-    return get() != nullptr;
-  }
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr operator bool() const { return get() != nullptr; }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type* operator->() const
-  {
+  _LIBCPP_HIDE_FROM_ABI constexpr const element_type* operator->() const { return get(); }
+
+  template <class _Dummy = _Tp, class _Up = enable_if_t<is_convertible< const _Dummy, const element_type*>::value>>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator const element_type*() const {
     return get();
   }
 
-  template <class _Tp_ = _Tp, class _Up = enable_if_t<is_convertible<
-                                  const _Tp_, const element_type *>::value>>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR operator const element_type *() const {
+  _LIBCPP_HIDE_FROM_ABI constexpr const element_type& operator*() const { return *get(); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr element_type* operator->() { return get(); }
+
+  template <class _Dummy = _Tp, class _Up = enable_if_t< is_convertible<_Dummy, element_type*>::value>>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator element_type*() {
     return get();
   }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const element_type& operator*() const
-  {
-    return *get();
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr element_type& operator*() { return *get(); }
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type* operator->()
-  {
-    return get();
-  }
-
-  template <class _Tp_ = _Tp, class _Up = enable_if_t<
-                                  is_convertible<_Tp_, element_type *>::value>>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR operator element_type *() {
-    return get();
-  }
-
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR element_type& operator*()
-  {
-    return *get();
-  }
-
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR void swap(propagate_const& __pt)
-      _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value) {
-    using _VSTD::swap;
+  _LIBCPP_HIDE_FROM_ABI constexpr void swap(propagate_const& __pt) noexcept(__is_nothrow_swappable_v<_Tp>) {
+    using std::swap;
     swap(__t_, __pt.__t_);
   }
 };
 
-
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, nullptr_t)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) == nullptr;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const propagate_const<_Tp>& __pt, nullptr_t) {
+  return experimental::get_underlying(__pt) == nullptr;
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator==(nullptr_t, const propagate_const<_Tp>& __pt)
-{
-  return nullptr == _VSTD_LFTS_V2::get_underlying(__pt);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(nullptr_t, const propagate_const<_Tp>& __pt) {
+  return nullptr == experimental::get_underlying(__pt);
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) != nullptr;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const propagate_const<_Tp>& __pt, nullptr_t) {
+  return experimental::get_underlying(__pt) != nullptr;
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt)
-{
-  return nullptr != _VSTD_LFTS_V2::get_underlying(__pt);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(nullptr_t, const propagate_const<_Tp>& __pt) {
+  return nullptr != experimental::get_underlying(__pt);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt,
-                          const propagate_const<_Up>& __pu)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) == _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
+  return experimental::get_underlying(__pt) == experimental::get_underlying(__pu);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt,
-                          const propagate_const<_Up>& __pu)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) != _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
+  return experimental::get_underlying(__pt) != experimental::get_underlying(__pu);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt,
-                         const propagate_const<_Up>& __pu)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) < _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
+  return experimental::get_underlying(__pt) < experimental::get_underlying(__pu);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt,
-                         const propagate_const<_Up>& __pu)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) > _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
+  return experimental::get_underlying(__pt) > experimental::get_underlying(__pu);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt,
-                          const propagate_const<_Up>& __pu)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) <= _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
+  return experimental::get_underlying(__pt) <= experimental::get_underlying(__pu);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt,
-                          const propagate_const<_Up>& __pu)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) >= _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const propagate_const<_Tp>& __pt, const propagate_const<_Up>& __pu) {
+  return experimental::get_underlying(__pt) >= experimental::get_underlying(__pu);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) == __u;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const propagate_const<_Tp>& __pt, const _Up& __u) {
+  return experimental::get_underlying(__pt) == __u;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) != __u;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const propagate_const<_Tp>& __pt, const _Up& __u) {
+  return experimental::get_underlying(__pt) != __u;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) < __u;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const propagate_const<_Tp>& __pt, const _Up& __u) {
+  return experimental::get_underlying(__pt) < __u;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) > __u;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const propagate_const<_Tp>& __pt, const _Up& __u) {
+  return experimental::get_underlying(__pt) > __u;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) <= __u;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const propagate_const<_Tp>& __pt, const _Up& __u) {
+  return experimental::get_underlying(__pt) <= __u;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u)
-{
-  return _VSTD_LFTS_V2::get_underlying(__pt) >= __u;
-}
-
-
-template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu)
-{
-  return __t == _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const propagate_const<_Tp>& __pt, const _Up& __u) {
+  return experimental::get_underlying(__pt) >= __u;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu)
-{
-  return __t != _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const _Tp& __t, const propagate_const<_Up>& __pu) {
+  return __t == experimental::get_underlying(__pu);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu)
-{
-  return __t < _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const _Tp& __t, const propagate_const<_Up>& __pu) {
+  return __t != experimental::get_underlying(__pu);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu)
-{
-  return __t > _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const _Tp& __t, const propagate_const<_Up>& __pu) {
+  return __t < experimental::get_underlying(__pu);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu)
-{
-  return __t <= _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const _Tp& __t, const propagate_const<_Up>& __pu) {
+  return __t > experimental::get_underlying(__pu);
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu)
-{
-  return __t >= _VSTD_LFTS_V2::get_underlying(__pu);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const _Tp& __t, const propagate_const<_Up>& __pu) {
+  return __t <= experimental::get_underlying(__pu);
+}
+
+template <class _Tp, class _Up>
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const _Tp& __t, const propagate_const<_Up>& __pu) {
+  return __t >= experimental::get_underlying(__pu);
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR void swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
-{
+_LIBCPP_HIDE_FROM_ABI constexpr void
+swap(propagate_const<_Tp>& __pc1, propagate_const<_Tp>& __pc2) noexcept(__is_nothrow_swappable_v<_Tp>) {
   __pc1.swap(__pc2);
 }
 
 template <class _Tp>
-_LIBCPP_CONSTEXPR const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT
-{
+constexpr const _Tp& get_underlying(const propagate_const<_Tp>& __pt) _NOEXCEPT {
   return __pt.__t_;
 }
 
 template <class _Tp>
-_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT
-{
+constexpr _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT {
   return __pt.__t_;
 }
 
@@ -501,92 +402,78 @@ _LIBCPP_END_NAMESPACE_LFTS_V2
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct hash<experimental::fundamentals_v2::propagate_const<_Tp>>
-{
+struct hash<experimental::propagate_const<_Tp>> {
   typedef size_t result_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type;
+  typedef experimental::propagate_const<_Tp> argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const
-  {
-    return std::hash<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1));
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const experimental::propagate_const<_Tp>& __pc1) const {
+    return std::hash<_Tp>()(experimental::get_underlying(__pc1));
   }
 };
 
 template <class _Tp>
-struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
-{
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+struct equal_to<experimental::propagate_const<_Tp>> {
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
-  {
-    return std::equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  _LIBCPP_HIDE_FROM_ABI bool
+  operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
+    return std::equal_to<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
   }
 };
 
 template <class _Tp>
-struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
-{
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+struct not_equal_to<experimental::propagate_const<_Tp>> {
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
-  {
-    return std::not_equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  _LIBCPP_HIDE_FROM_ABI bool
+  operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
+    return std::not_equal_to<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
   }
 };
 
 template <class _Tp>
-struct less<experimental::fundamentals_v2::propagate_const<_Tp>>
-{
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+struct less<experimental::propagate_const<_Tp>> {
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
-  {
-    return std::less<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  _LIBCPP_HIDE_FROM_ABI bool
+  operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
+    return std::less<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
   }
 };
 
 template <class _Tp>
-struct greater<experimental::fundamentals_v2::propagate_const<_Tp>>
-{
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+struct greater<experimental::propagate_const<_Tp>> {
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
-  {
-    return std::greater<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  _LIBCPP_HIDE_FROM_ABI bool
+  operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
+    return std::greater<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
   }
 };
 
 template <class _Tp>
-struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
-{
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+struct less_equal<experimental::propagate_const<_Tp>> {
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
-  {
-    return std::less_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  _LIBCPP_HIDE_FROM_ABI bool
+  operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
+    return std::less_equal<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
   }
 };
 
 template <class _Tp>
-struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
-{
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+struct greater_equal<experimental::propagate_const<_Tp>> {
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
-  {
-    return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
+  _LIBCPP_HIDE_FROM_ABI bool
+  operator()(const experimental::propagate_const<_Tp>& __pc1, const experimental::propagate_const<_Tp>& __pc2) const {
+    return std::greater_equal<_Tp>()(experimental::get_underlying(__pc1), experimental::get_underlying(__pc2));
   }
 };
 
@@ -594,6 +481,8 @@ _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <type_traits>
 #endif
diff --git a/third_party/libcxx/experimental/regex b/third_party/libcxx/experimental/regex
deleted file mode 100644
index 0c871f366..000000000
--- a/third_party/libcxx/experimental/regex
+++ /dev/null
@@ -1,69 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_REGEX
-#define _LIBCPP_EXPERIMENTAL_REGEX
-
-/*
-    experimental/regex synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class BidirectionalIterator>
-  using match_results =
-    std::match_results<BidirectionalIterator,
-                       polymorphic_allocator<sub_match<BidirectionalIterator>>>;
-
-  typedef match_results<const char*> cmatch;
-  typedef match_results<const wchar_t*> wcmatch;
-  typedef match_results<string::const_iterator> smatch;
-  typedef match_results<wstring::const_iterator> wsmatch;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <experimental/string>
-#include <regex>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _BiDirIter>
-using match_results =
-    _VSTD::match_results<_BiDirIter,
-        polymorphic_allocator<_VSTD::sub_match<_BiDirIter>>>;
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("cmatch") typedef match_results<const char*> cmatch;
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("smatch") typedef match_results<_VSTD_LFTS_PMR::string::const_iterator> smatch;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("wcmatch") typedef match_results<const wchar_t*> wcmatch;
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("wsmatch") typedef match_results<_VSTD_LFTS_PMR::wstring::const_iterator> wsmatch;
-#endif
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_REGEX */
diff --git a/third_party/libcxx/experimental/set b/third_party/libcxx/experimental/set
deleted file mode 100644
index cd61e6449..000000000
--- a/third_party/libcxx/experimental/set
+++ /dev/null
@@ -1,62 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_SET
-#define _LIBCPP_EXPERIMENTAL_SET
-
-/*
-    experimental/set synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class Key, class T, class Compare = less<Key>>
-  using set = std::set<Key, T, Compare,
-                       polymorphic_allocator<pair<const Key,T>>>;
-
-  template <class Key, class T, class Compare = less<Key>>
-  using multiset = std::multiset<Key, T, Compare,
-                                 polymorphic_allocator<pair<const Key,T>>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <set>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Value, class  _Compare = less<_Value>>
-using set = _VSTD::set<_Value, _Compare,
-                        polymorphic_allocator<_Value>>;
-
-template <class _Value, class  _Compare = less<_Value>>
-using multiset = _VSTD::multiset<_Value, _Compare,
-                        polymorphic_allocator<_Value>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_SET */
diff --git a/third_party/libcxx/experimental/simd b/third_party/libcxx/experimental/simd
index 11047d12f..484543b81 100644
--- a/third_party/libcxx/experimental/simd
+++ b/third_party/libcxx/experimental/simd
@@ -14,1572 +14,75 @@
     experimental/simd synopsis
 
 namespace std::experimental {
-
 inline namespace parallelism_v2 {
-
-namespace simd_abi {
-
-struct scalar {};
-template <int N> struct fixed_size {};
-template <typename T> inline constexpr int max_fixed_size = implementation-defined;
-template <typename T> using compatible = implementation-defined;
-template <typename T> using native = implementation-defined;
-
-} // simd_abi
-
-struct element_aligned_tag {};
-struct vector_aligned_tag {};
-template <size_t> struct overaligned_tag {};
-inline constexpr element_aligned_tag element_aligned{};
-inline constexpr vector_aligned_tag vector_aligned{};
-template <size_t N> inline constexpr overaligned_tag<N> overaligned{};
-
-// traits [simd.traits]
-template <class T> struct is_abi_tag;
-template <class T> inline constexpr bool is_abi_tag_v = is_abi_tag<T>::value;
-
-template <class T> struct is_simd;
-template <class T> inline constexpr bool is_simd_v = is_simd<T>::value;
-
-template <class T> struct is_simd_mask;
-template <class T> inline constexpr bool is_simd_mask_v = is_simd_mask<T>::value;
-
-template <class T> struct is_simd_flag_type;
-template <class T> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<T>::value;
-
-template <class T, size_t N> struct abi_for_size { using type = see below; };
-template <class T, size_t N> using abi_for_size_t = typename abi_for_size<T, N>::type;
-
-template <class T, class Abi = simd_abi::compatible<T>> struct simd_size;
-template <class T, class Abi = simd_abi::compatible<T>>
-inline constexpr size_t simd_size_v = simd_size<T, Abi>::value;
-
-template <class T, class U = typename T::value_type> struct memory_alignment;
-template <class T, class U = typename T::value_type>
-inline constexpr size_t memory_alignment_v = memory_alignment<T, U>::value;
-
-// class template simd [simd.class]
-template <class T, class Abi = simd_abi::compatible<T>> class simd;
-template <class T> using native_simd = simd<T, simd_abi::native<T>>;
-template <class T, int N> using fixed_size_simd = simd<T, simd_abi::fixed_size<N>>;
-
-// class template simd_mask [simd.mask.class]
-template <class T, class Abi = simd_abi::compatible<T>> class simd_mask;
-template <class T> using native_simd_mask = simd_mask<T, simd_abi::native<T>>;
-template <class T, int N> using fixed_size_simd_mask = simd_mask<T, simd_abi::fixed_size<N>>;
-
-// casts [simd.casts]
-template <class T, class U, class Abi> see below simd_cast(const simd<U, Abi>&);
-template <class T, class U, class Abi> see below static_simd_cast(const simd<U, Abi>&);
-
-template <class T, class Abi>
-fixed_size_simd<T, simd_size_v<T, Abi>> to_fixed_size(const simd<T, Abi>&) noexcept;
-template <class T, class Abi>
-fixed_size_simd_mask<T, simd_size_v<T, Abi>> to_fixed_size(const simd_mask<T, Abi>&) noexcept;
-template <class T, size_t N> native_simd<T> to_native(const fixed_size_simd<T, N>&) noexcept;
-template <class T, size_t N>
-native_simd_mask<T> to_native(const fixed_size_simd_mask<T, N>> &) noexcept;
-template <class T, size_t N> simd<T> to_compatible(const fixed_size_simd<T, N>&) noexcept;
-template <class T, size_t N> simd_mask<T> to_compatible(const fixed_size_simd_mask<T, N>&) noexcept;
-
-template <size_t... Sizes, class T, class Abi>
-tuple<simd<T, abi_for_size_t<Sizes>>...> split(const simd<T, Abi>&);
-template <size_t... Sizes, class T, class Abi>
-tuple<simd_mask<T, abi_for_size_t<Sizes>>...> split(const simd_mask<T, Abi>&);
-template <class V, class Abi>
-array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(
-const simd<typename V::value_type, Abi>&);
-template <class V, class Abi>
-array<V, simd_size_v<typename V::value_type, Abi> / V::size()> split(
-const simd_mask<typename V::value_type, Abi>&);
-
-template <class T, class... Abis>
-simd<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>> concat(const simd<T, Abis>&...);
-template <class T, class... Abis>
-simd_mask<T, abi_for_size_t<T, (simd_size_v<T, Abis> + ...)>> concat(const simd_mask<T, Abis>&...);
-
-// reductions [simd.mask.reductions]
-template <class T, class Abi> bool all_of(const simd_mask<T, Abi>&) noexcept;
-template <class T, class Abi> bool any_of(const simd_mask<T, Abi>&) noexcept;
-template <class T, class Abi> bool none_of(const simd_mask<T, Abi>&) noexcept;
-template <class T, class Abi> bool some_of(const simd_mask<T, Abi>&) noexcept;
-template <class T, class Abi> int popcount(const simd_mask<T, Abi>&) noexcept;
-template <class T, class Abi> int find_first_set(const simd_mask<T, Abi>&);
-template <class T, class Abi> int find_last_set(const simd_mask<T, Abi>&);
-
-bool all_of(see below) noexcept;
-bool any_of(see below) noexcept;
-bool none_of(see below) noexcept;
-bool some_of(see below) noexcept;
-int popcount(see below) noexcept;
-int find_first_set(see below) noexcept;
-int find_last_set(see below) noexcept;
-
-// masked assignment [simd.whereexpr]
-template <class M, class T> class const_where_expression;
-template <class M, class T> class where_expression;
-
-// masked assignment [simd.mask.where]
-template <class T> struct nodeduce { using type = T; }; // exposition only
-
-template <class T> using nodeduce_t = typename nodeduce<T>::type; // exposition only
-
-template <class T, class Abi>
-where_expression<simd_mask<T, Abi>, simd<T, Abi>>
-where(const typename simd<T, Abi>::mask_type&, simd<T, Abi>&) noexcept;
-
-template <class T, class Abi>
-const_where_expression<simd_mask<T, Abi>, const simd<T, Abi>>
-where(const typename simd<T, Abi>::mask_type&, const simd<T, Abi>&) noexcept;
-
-template <class T, class Abi>
-where_expression<simd_mask<T, Abi>, simd_mask<T, Abi>>
-where(const nodeduce_t<simd_mask<T, Abi>>&, simd_mask<T, Abi>&) noexcept;
-
-template <class T, class Abi>
-const_where_expression<simd_mask<T, Abi>, const simd_mask<T, Abi>>
-where(const nodeduce_t<simd_mask<T, Abi>>&, const simd_mask<T, Abi>&) noexcept;
-
-template <class T> where_expression<bool, T> where(see below k, T& d) noexcept;
-
-template <class T>
-const_where_expression<bool, const T> where(see below k, const T& d) noexcept;
-
-// reductions [simd.reductions]
-template <class T, class Abi, class BinaryOperation = std::plus<>>
-T reduce(const simd<T, Abi>&, BinaryOperation = BinaryOperation());
-
-template <class M, class V, class BinaryOperation>
-typename V::value_type reduce(const const_where_expression<M, V>& x,
-typename V::value_type neutral_element, BinaryOperation binary_op);
-
-template <class M, class V>
-typename V::value_type reduce(const const_where_expression<M, V>& x, plus<> binary_op = plus<>());
-
-template <class M, class V>
-typename V::value_type reduce(const const_where_expression<M, V>& x, multiplies<> binary_op);
-
-template <class M, class V>
-typename V::value_type reduce(const const_where_expression<M, V>& x, bit_and<> binary_op);
-
-template <class M, class V>
-typename V::value_type reduce(const const_where_expression<M, V>& x, bit_or<> binary_op);
-
-template <class M, class V>
-typename V::value_type reduce(const const_where_expression<M, V>& x, bit_xor<> binary_op);
-
-template <class T, class Abi> T hmin(const simd<T, Abi>&);
-template <class M, class V> T hmin(const const_where_expression<M, V>&);
-template <class T, class Abi> T hmax(const simd<T, Abi>&);
-template <class M, class V> T hmax(const const_where_expression<M, V>&);
-
-// algorithms [simd.alg]
-template <class T, class Abi> simd<T, Abi> min(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
-
-template <class T, class Abi> simd<T, Abi> max(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
-
-template <class T, class Abi>
-std::pair<simd<T, Abi>, simd<T, Abi>> minmax(const simd<T, Abi>&, const simd<T, Abi>&) noexcept;
-
-template <class T, class Abi>
-simd<T, Abi> clamp(const simd<T, Abi>& v, const simd<T, Abi>& lo, const simd<T, Abi>& hi);
-
-// [simd.whereexpr]
-template <class M, class T>
-class const_where_expression {
-  const M& mask; // exposition only
-  T& data; // exposition only
-public:
-  const_where_expression(const const_where_expression&) = delete;
-  const_where_expression& operator=(const const_where_expression&) = delete;
-  remove_const_t<T> operator-() const &&;
-  template <class U, class Flags> void copy_to(U* mem, Flags f) const &&;
-};
-
-template <class M, class T>
-class where_expression : public const_where_expression<M, T> {
-public:
-  where_expression(const where_expression&) = delete;
-  where_expression& operator=(const where_expression&) = delete;
-  template <class U> void operator=(U&& x);
-  template <class U> void operator+=(U&& x);
-  template <class U> void operator-=(U&& x);
-  template <class U> void operator*=(U&& x);
-  template <class U> void operator/=(U&& x);
-  template <class U> void operator%=(U&& x);
-  template <class U> void operator&=(U&& x);
-  template <class U> void operator|=(U&& x);
-  template <class U> void operator^=(U&& x);
-  template <class U> void operator<<=(U&& x);
-  template <class U> void operator>>=(U&& x);
-  void operator++();
-  void operator++(int);
-  void operator--();
-  void operator--(int);
-  template <class U, class Flags> void copy_from(const U* mem, Flags);
-};
-
-// [simd.class]
-template <class T, class Abi> class simd {
-public:
-  using value_type = T;
-  using reference = see below;
-  using mask_type = simd_mask<T, Abi>;
-
-  using abi_type = Abi;
-  static constexpr size_t size() noexcept;
-  simd() = default;
-
-  // implicit type conversion constructor
-  template <class U> simd(const simd<U, simd_abi::fixed_size<size()>>&);
-
-  // implicit broadcast constructor (see below for constraints)
-  template <class U> simd(U&& value);
-
-  // generator constructor (see below for constraints)
-  template <class G> explicit simd(G&& gen);
-
-  // load constructor
-  template <class U, class Flags> simd(const U* mem, Flags f);
-
-  // loads [simd.load]
-  template <class U, class Flags> void copy_from(const U* mem, Flags f);
-
-  // stores [simd.store]
-  template <class U, class Flags> void copy_to(U* mem, Flags f) const;
-
-  // scalar access [simd.subscr]
-  reference operator[](size_t);
-  value_type operator[](size_t) const;
-
-  // unary operators [simd.unary]
-  simd& operator++();
-  simd operator++(int);
-  simd& operator--();
-  simd operator--(int);
-  mask_type operator!() const;
-  simd operator~() const; // see below
-  simd operator+() const;
-  simd operator-() const;
-
-  // binary operators [simd.binary]
-  friend simd operator+ (const simd&, const simd&);
-  friend simd operator- (const simd&, const simd&);
-  friend simd operator* (const simd&, const simd&);
-  friend simd operator/ (const simd&, const simd&);
-  friend simd operator% (const simd&, const simd&);
-  friend simd operator& (const simd&, const simd&);
-  friend simd operator| (const simd&, const simd&);
-  friend simd operator^ (const simd&, const simd&);
-  friend simd operator<<(const simd&, const simd&);
-  friend simd operator>>(const simd&, const simd&);
-  friend simd operator<<(const simd&, int);
-  friend simd operator>>(const simd&, int);
-
-  // compound assignment [simd.cassign]
-  friend simd& operator+= (simd&, const simd&);
-  friend simd& operator-= (simd&, const simd&);
-  friend simd& operator*= (simd&, const simd&);
-  friend simd& operator/= (simd&, const simd&);
-  friend simd& operator%= (simd&, const simd&);
-
-  friend simd& operator&= (simd&, const simd&);
-  friend simd& operator|= (simd&, const simd&);
-  friend simd& operator^= (simd&, const simd&);
-  friend simd& operator<<=(simd&, const simd&);
-  friend simd& operator>>=(simd&, const simd&);
-  friend simd& operator<<=(simd&, int);
-  friend simd& operator>>=(simd&, int);
-
-  // compares [simd.comparison]
-  friend mask_type operator==(const simd&, const simd&);
-  friend mask_type operator!=(const simd&, const simd&);
-  friend mask_type operator>=(const simd&, const simd&);
-  friend mask_type operator<=(const simd&, const simd&);
-  friend mask_type operator> (const simd&, const simd&);
-  friend mask_type operator< (const simd&, const simd&);
-};
-
-// [simd.math]
-template <class Abi> using scharv = simd<signed char, Abi>; // exposition only
-template <class Abi> using shortv = simd<short, Abi>; // exposition only
-template <class Abi> using intv = simd<int, Abi>; // exposition only
-template <class Abi> using longv = simd<long int, Abi>; // exposition only
-template <class Abi> using llongv = simd<long long int, Abi>; // exposition only
-template <class Abi> using floatv = simd<float, Abi>; // exposition only
-template <class Abi> using doublev = simd<double, Abi>; // exposition only
-template <class Abi> using ldoublev = simd<long double, Abi>; // exposition only
-template <class T, class V> using samesize = fixed_size_simd<T, V::size()>; // exposition only
-
-template <class Abi> floatv<Abi> acos(floatv<Abi> x);
-template <class Abi> doublev<Abi> acos(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> acos(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> asin(floatv<Abi> x);
-template <class Abi> doublev<Abi> asin(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> asin(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> atan(floatv<Abi> x);
-template <class Abi> doublev<Abi> atan(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> atan(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> atan2(floatv<Abi> y, floatv<Abi> x);
-template <class Abi> doublev<Abi> atan2(doublev<Abi> y, doublev<Abi> x);
-template <class Abi> ldoublev<Abi> atan2(ldoublev<Abi> y, ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> cos(floatv<Abi> x);
-template <class Abi> doublev<Abi> cos(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> cos(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> sin(floatv<Abi> x);
-template <class Abi> doublev<Abi> sin(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> sin(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> tan(floatv<Abi> x);
-template <class Abi> doublev<Abi> tan(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> tan(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> acosh(floatv<Abi> x);
-template <class Abi> doublev<Abi> acosh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> acosh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> asinh(floatv<Abi> x);
-template <class Abi> doublev<Abi> asinh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> asinh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> atanh(floatv<Abi> x);
-template <class Abi> doublev<Abi> atanh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> atanh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> cosh(floatv<Abi> x);
-template <class Abi> doublev<Abi> cosh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> cosh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> sinh(floatv<Abi> x);
-template <class Abi> doublev<Abi> sinh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> sinh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> tanh(floatv<Abi> x);
-template <class Abi> doublev<Abi> tanh(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> tanh(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> exp(floatv<Abi> x);
-template <class Abi> doublev<Abi> exp(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> exp(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> exp2(floatv<Abi> x);
-template <class Abi> doublev<Abi> exp2(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> exp2(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> expm1(floatv<Abi> x);
-template <class Abi> doublev<Abi> expm1(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> expm1(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> frexp(floatv<Abi> value, samesize<int, floatv<Abi>>* exp);
-template <class Abi> doublev<Abi> frexp(doublev<Abi> value, samesize<int, doublev<Abi>>* exp);
-template <class Abi> ldoublev<Abi> frexp(ldoublev<Abi> value, samesize<int, ldoublev<Abi>>* exp);
-
-template <class Abi> samesize<int, floatv<Abi>> ilogb(floatv<Abi> x);
-template <class Abi> samesize<int, doublev<Abi>> ilogb(doublev<Abi> x);
-template <class Abi> samesize<int, ldoublev<Abi>> ilogb(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> ldexp(floatv<Abi> x, samesize<int, floatv<Abi>> exp);
-template <class Abi> doublev<Abi> ldexp(doublev<Abi> x, samesize<int, doublev<Abi>> exp);
-template <class Abi> ldoublev<Abi> ldexp(ldoublev<Abi> x, samesize<int, ldoublev<Abi>> exp);
-
-template <class Abi> floatv<Abi> log(floatv<Abi> x);
-template <class Abi> doublev<Abi> log(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> log(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> log10(floatv<Abi> x);
-template <class Abi> doublev<Abi> log10(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> log10(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> log1p(floatv<Abi> x);
-template <class Abi> doublev<Abi> log1p(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> log1p(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> log2(floatv<Abi> x);
-template <class Abi> doublev<Abi> log2(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> log2(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> logb(floatv<Abi> x);
-template <class Abi> doublev<Abi> logb(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> logb(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> modf(floatv<Abi> value, floatv<Abi>* iptr);
-template <class Abi> doublev<Abi> modf(doublev<Abi> value, doublev<Abi>* iptr);
-template <class Abi> ldoublev<Abi> modf(ldoublev<Abi> value, ldoublev<Abi>* iptr);
-
-template <class Abi> floatv<Abi> scalbn(floatv<Abi> x, samesize<int, floatv<Abi>> n);
-template <class Abi> doublev<Abi> scalbn(doublev<Abi> x, samesize<int, doublev<Abi>> n);
-template <class Abi> ldoublev<Abi> scalbn(ldoublev<Abi> x, samesize<int, ldoublev<Abi>> n);
-template <class Abi> floatv<Abi> scalbln(floatv<Abi> x, samesize<long int, floatv<Abi>> n);
-template <class Abi> doublev<Abi> scalbln(doublev<Abi> x, samesize<long int, doublev<Abi>> n);
-template <class Abi> ldoublev<Abi> scalbln(ldoublev<Abi> x, samesize<long int, ldoublev<Abi>> n);
-
-template <class Abi> floatv<Abi> cbrt(floatv<Abi> x);
-template <class Abi> doublev<Abi> cbrt(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> cbrt(ldoublev<Abi> x);
-
-template <class Abi> scharv<Abi> abs(scharv<Abi> j);
-template <class Abi> shortv<Abi> abs(shortv<Abi> j);
-template <class Abi> intv<Abi> abs(intv<Abi> j);
-template <class Abi> longv<Abi> abs(longv<Abi> j);
-template <class Abi> llongv<Abi> abs(llongv<Abi> j);
-template <class Abi> floatv<Abi> abs(floatv<Abi> j);
-template <class Abi> doublev<Abi> abs(doublev<Abi> j);
-template <class Abi> ldoublev<Abi> abs(ldoublev<Abi> j);
-
-template <class Abi> floatv<Abi> hypot(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> floatv<Abi> hypot(floatv<Abi> x, floatv<Abi> y, floatv<Abi> z);
-template <class Abi> doublev<Abi> hypot(doublev<Abi> x, doublev<Abi> y, doublev<Abi> z);
-template <class Abi> ldoublev<Abi> hypot(ldoublev<Abi> x, ldoublev<Abi> y, ldoublev<Abi> z);
-
-template <class Abi> floatv<Abi> pow(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> pow(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> pow(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> sqrt(floatv<Abi> x);
-template <class Abi> doublev<Abi> sqrt(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> sqrt(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> erf(floatv<Abi> x);
-template <class Abi> doublev<Abi> erf(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> erf(ldoublev<Abi> x);
-template <class Abi> floatv<Abi> erfc(floatv<Abi> x);
-template <class Abi> doublev<Abi> erfc(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> erfc(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> lgamma(floatv<Abi> x);
-template <class Abi> doublev<Abi> lgamma(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> lgamma(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> tgamma(floatv<Abi> x);
-template <class Abi> doublev<Abi> tgamma(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> tgamma(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> ceil(floatv<Abi> x);
-template <class Abi> doublev<Abi> ceil(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> ceil(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> floor(floatv<Abi> x);
-template <class Abi> doublev<Abi> floor(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> floor(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> nearbyint(floatv<Abi> x);
-template <class Abi> doublev<Abi> nearbyint(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> nearbyint(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> rint(floatv<Abi> x);
-template <class Abi> doublev<Abi> rint(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> rint(ldoublev<Abi> x);
-
-template <class Abi> samesize<long int, floatv<Abi>> lrint(floatv<Abi> x);
-template <class Abi> samesize<long int, doublev<Abi>> lrint(doublev<Abi> x);
-template <class Abi> samesize<long int, ldoublev<Abi>> lrint(ldoublev<Abi> x);
-template <class Abi> samesize<long long int, floatv<Abi>> llrint(floatv<Abi> x);
-template <class Abi> samesize<long long int, doublev<Abi>> llrint(doublev<Abi> x);
-template <class Abi> samesize<long long int, ldoublev<Abi>> llrint(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> round(floatv<Abi> x);
-template <class Abi> doublev<Abi> round(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> round(ldoublev<Abi> x);
-template <class Abi> samesize<long int, floatv<Abi>> lround(floatv<Abi> x);
-template <class Abi> samesize<long int, doublev<Abi>> lround(doublev<Abi> x);
-template <class Abi> samesize<long int, ldoublev<Abi>> lround(ldoublev<Abi> x);
-template <class Abi> samesize<long long int, floatv<Abi>> llround(floatv<Abi> x);
-template <class Abi> samesize<long long int, doublev<Abi>> llround(doublev<Abi> x);
-template <class Abi> samesize<long long int, ldoublev<Abi>> llround(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> trunc(floatv<Abi> x);
-template <class Abi> doublev<Abi> trunc(doublev<Abi> x);
-template <class Abi> ldoublev<Abi> trunc(ldoublev<Abi> x);
-
-template <class Abi> floatv<Abi> fmod(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> fmod(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> fmod(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> remainder(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> remainder(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> remainder(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> remquo(floatv<Abi> x, floatv<Abi> y, samesize<int, floatv<Abi>>* quo);
-template <class Abi> doublev<Abi> remquo(doublev<Abi> x, doublev<Abi> y, samesize<int, doublev<Abi>>* quo);
-template <class Abi> ldoublev<Abi> remquo(ldoublev<Abi> x, ldoublev<Abi> y, samesize<int, ldoublev<Abi>>* quo);
-
-template <class Abi> floatv<Abi> copysign(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> copysign(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> copysign(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> doublev<Abi> nan(const char* tagp);
-template <class Abi> floatv<Abi> nanf(const char* tagp);
-template <class Abi> ldoublev<Abi> nanl(const char* tagp);
-
-template <class Abi> floatv<Abi> nextafter(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> nextafter(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> nextafter(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> nexttoward(floatv<Abi> x, ldoublev<Abi> y);
-template <class Abi> doublev<Abi> nexttoward(doublev<Abi> x, ldoublev<Abi> y);
-template <class Abi> ldoublev<Abi> nexttoward(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> fdim(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> fdim(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> fdim(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> fmax(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> fmax(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> fmax(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> fmin(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> doublev<Abi> fmin(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> ldoublev<Abi> fmin(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> floatv<Abi> fma(floatv<Abi> x, floatv<Abi> y, floatv<Abi> z);
-template <class Abi> doublev<Abi> fma(doublev<Abi> x, doublev<Abi> y, doublev<Abi> z);
-template <class Abi> ldoublev<Abi> fma(ldoublev<Abi> x, ldoublev<Abi> y, ldoublev<Abi> z);
-
-template <class Abi> samesize<int, floatv<Abi>> fpclassify(floatv<Abi> x);
-template <class Abi> samesize<int, doublev<Abi>> fpclassify(doublev<Abi> x);
-template <class Abi> samesize<int, ldoublev<Abi>> fpclassify(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> isfinite(floatv<Abi> x);
-template <class Abi> simd_mask<double, Abi> isfinite(doublev<Abi> x);
-template <class Abi> simd_mask<long double, Abi> isfinite(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> isinf(floatv<Abi> x);
-template <class Abi> simd_mask<double, Abi> isinf(doublev<Abi> x);
-template <class Abi> simd_mask<long double, Abi> isinf(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> isnan(floatv<Abi> x);
-template <class Abi> simd_mask<double, Abi> isnan(doublev<Abi> x);
-template <class Abi> simd_mask<long double, Abi> isnan(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> isnormal(floatv<Abi> x);
-template <class Abi> simd_mask<double, Abi> isnormal(doublev<Abi> x);
-template <class Abi> simd_mask<long double, Abi> isnormal(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> signbit(floatv<Abi> x);
-template <class Abi> simd_mask<double, Abi> signbit(doublev<Abi> x);
-template <class Abi> simd_mask<long double, Abi> signbit(ldoublev<Abi> x);
-
-template <class Abi> simd_mask<float, Abi> isgreater(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> isgreater(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> isgreater(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> simd_mask<float, Abi> isgreaterequal(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> isgreaterequal(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> isgreaterequal(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> simd_mask<float, Abi> isless(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> isless(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> isless(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> simd_mask<float, Abi> islessequal(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> islessequal(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> islessequal(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> simd_mask<float, Abi> islessgreater(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> islessgreater(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> islessgreater(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class Abi> simd_mask<float, Abi> isunordered(floatv<Abi> x, floatv<Abi> y);
-template <class Abi> simd_mask<double, Abi> isunordered(doublev<Abi> x, doublev<Abi> y);
-template <class Abi> simd_mask<long double, Abi> isunordered(ldoublev<Abi> x, ldoublev<Abi> y);
-
-template <class V> struct simd_div_t { V quot, rem; };
-template <class Abi> simd_div_t<scharv<Abi>> div(scharv<Abi> numer, scharv<Abi> denom);
-template <class Abi> simd_div_t<shortv<Abi>> div(shortv<Abi> numer, shortv<Abi> denom);
-template <class Abi> simd_div_t<intv<Abi>> div(intv<Abi> numer, intv<Abi> denom);
-template <class Abi> simd_div_t<longv<Abi>> div(longv<Abi> numer, longv<Abi> denom);
-template <class Abi> simd_div_t<llongv<Abi>> div(llongv<Abi> numer, llongv<Abi> denom);
-
-// [simd.mask.class]
-template <class T, class Abi>
-class simd_mask {
-public:
-  using value_type = bool;
-  using reference = see below;
-  using simd_type = simd<T, Abi>;
-  using abi_type = Abi;
-  static constexpr size_t size() noexcept;
-  simd_mask() = default;
-
-  // broadcast constructor
-  explicit simd_mask(value_type) noexcept;
-
-  // implicit type conversion constructor
-  template <class U> simd_mask(const simd_mask<U, simd_abi::fixed_size<size()>>&) noexcept;
-
-  // load constructor
-  template <class Flags> simd_mask(const value_type* mem, Flags);
-
-  // loads [simd.mask.copy]
-  template <class Flags> void copy_from(const value_type* mem, Flags);
-  template <class Flags> void copy_to(value_type* mem, Flags) const;
-
-  // scalar access [simd.mask.subscr]
-  reference operator[](size_t);
-  value_type operator[](size_t) const;
-
-  // unary operators [simd.mask.unary]
-  simd_mask operator!() const noexcept;
-
-  // simd_mask binary operators [simd.mask.binary]
-  friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator||(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator& (const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator| (const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator^ (const simd_mask&, const simd_mask&) noexcept;
-
-  // simd_mask compound assignment [simd.mask.cassign]
-  friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask& operator|=(simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept;
-
-  // simd_mask compares [simd.mask.comparison]
-  friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
-};
-
-} // parallelism_v2
-} // std::experimental
+  namespace simd_abi {
+    using scalar = see below;
+    template<int N> using fixed_size = see below;
+    template<class T> inline constexpr int max_fixed_size = implementation-defined;
+    template<class T> using compatible = implementation-defined;
+    template<class T> using native = implementation-defined;
+
+    template<class T, size_t N, class... Abis> struct deduce { using type = see below; };
+    template<class T, size_t N, class... Abis> using deduce_t =
+      typename deduce<T, N, Abis...>::type;
+  } // namespace simd_abi
+
+  // class template simd [simd.class]
+  template <class T, class Abi = simd_abi::compatible<T>> class simd;
+  template <class T> using native_simd = simd<T, simd_abi::native<T>>;
+  template <class T, int N> using fixed_size_simd = simd<T, simd_abi::fixed_size<N>>;
+
+  // class template simd_mask [simd.mask.class]
+  template <class T, class Abi = simd_abi::compatible<T>> class simd_mask;
+  template <class T> using native_simd_mask = simd_mask<T, simd_abi::native<T>>;
+  template <class T, int N> using fixed_size_simd_mask = simd_mask<T, simd_abi::fixed_size<N>>;
+
+  // memory alignment
+  struct element_aligned_tag {};
+  struct vector_aligned_tag {};
+  template <size_t> struct overaligned_tag {};
+  inline constexpr element_aligned_tag element_aligned{};
+  inline constexpr vector_aligned_tag vector_aligned{};
+  template <size_t N> inline constexpr overaligned_tag<N> overaligned{};
+
+  // traits [simd.traits]
+  template<class T> struct is_abi_tag;
+  template<class T> inline constexpr bool is_abi_tag_v = is_abi_tag<T>::value;
+
+  template <class T> struct is_simd;
+  template <class T> inline constexpr bool is_simd_v = is_simd<T>::value;
+
+  template <class T> struct is_simd_mask;
+  template <class T> inline constexpr bool is_simd_mask_v = is_simd_mask<T>::value;
+
+  template<class T> struct is_simd_flag_type;
+  template<class T> inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<T>::value;
+
+  template<class T, class Abi = simd_abi::compatible<T>> struct simd_size;
+  template<class T, class Abi = simd_abi::compatible<T>>
+    inline constexpr size_t simd_size_v = simd_size<T,Abi>::value;
+
+  template<class T, class U = typename T::value_type> struct memory_alignment;
+  template<class T, class U = typename T::value_type>
+    inline constexpr size_t memory_alignment_v = memory_alignment<T,U>::value;
+
+} // namespace parallelism_v2
+} // namespace std::experimental
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__functional/operations.h>
-#include <array>
-#include <cstddef>
-#include <experimental/__config>
-#include <tuple>
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
-
-#if _LIBCPP_STD_VER >= 17
-
-enum class _StorageKind {
-  _Scalar,
-  _Array,
-  _VecExt,
-};
-
-template <_StorageKind __kind, int _Np>
-struct __simd_abi {};
-
-template <class _Tp, class _Abi>
-class __simd_storage {};
-
-template <class _Tp, int __num_element>
-class __simd_storage<_Tp, __simd_abi<_StorageKind::_Array, __num_element>> {
-  std::array<_Tp, __num_element> __storage_;
-
-  template <class, class>
-  friend struct simd;
-
-  template <class, class>
-  friend struct simd_mask;
-
-public:
-  _LIBCPP_HIDE_FROM_ABI _Tp __get(size_t __index) const noexcept { return __storage_[__index]; }
-  _LIBCPP_HIDE_FROM_ABI void __set(size_t __index, _Tp __val) noexcept {
-    __storage_[__index] = __val;
-  }
-};
-
-template <class _Tp>
-class __simd_storage<_Tp, __simd_abi<_StorageKind::_Scalar, 1>> {
-  _Tp __storage_;
-
-  template <class, class>
-  friend struct simd;
-
-  template <class, class>
-  friend struct simd_mask;
-
-public:
-  _LIBCPP_HIDE_FROM_ABI _Tp __get(size_t __index) const noexcept { return (&__storage_)[__index]; }
-  _LIBCPP_HIDE_FROM_ABI void __set(size_t __index, _Tp __val) noexcept {
-    (&__storage_)[__index] = __val;
-  }
-};
-
-#ifndef _LIBCPP_HAS_NO_VECTOR_EXTENSION
-
-_LIBCPP_HIDE_FROM_ABI constexpr size_t __floor_pow_of_2(size_t __val) {
-  return ((__val - 1) & __val) == 0 ? __val
-                                    : __floor_pow_of_2((__val - 1) & __val);
-}
-
-_LIBCPP_HIDE_FROM_ABI constexpr size_t __ceil_pow_of_2(size_t __val) {
-  return __val == 1 ? 1 : __floor_pow_of_2(__val - 1) << 1;
-}
-
-template <class _Tp, size_t __bytes>
-struct __vec_ext_traits {
-#if !defined(_LIBCPP_COMPILER_CLANG_BASED)
-  typedef _Tp type __attribute__((vector_size(__ceil_pow_of_2(__bytes))));
-#endif
-};
-
-#if defined(_LIBCPP_COMPILER_CLANG_BASED)
-#define _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, _NUM_ELEMENT)                        \
-  template <>                                                                  \
-  struct __vec_ext_traits<_TYPE, sizeof(_TYPE) * _NUM_ELEMENT> {               \
-    using type =                                                               \
-        _TYPE __attribute__((vector_size(sizeof(_TYPE) * _NUM_ELEMENT)));      \
-  }
-
-#define _LIBCPP_SPECIALIZE_VEC_EXT_32(_TYPE)                                   \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 1);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 2);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 3);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 4);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 5);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 6);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 7);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 8);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 9);                                        \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 10);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 11);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 12);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 13);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 14);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 15);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 16);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 17);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 18);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 19);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 20);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 21);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 22);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 23);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 24);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 25);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 26);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 27);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 28);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 29);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 30);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 31);                                       \
-  _LIBCPP_SPECIALIZE_VEC_EXT(_TYPE, 32)
-
-_LIBCPP_SPECIALIZE_VEC_EXT_32(char);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(char16_t);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(char32_t);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(wchar_t);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(signed char);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(signed short);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(signed int);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(signed long);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(signed long long);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(unsigned char);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(unsigned short);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(unsigned int);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(unsigned long);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(unsigned long long);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(float);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(double);
-_LIBCPP_SPECIALIZE_VEC_EXT_32(long double);
-
-#undef _LIBCPP_SPECIALIZE_VEC_EXT_32
-#undef _LIBCPP_SPECIALIZE_VEC_EXT
-#endif
-
-template <class _Tp, int __num_element>
-class __simd_storage<_Tp, __simd_abi<_StorageKind::_VecExt, __num_element>> {
-  using _StorageType =
-      typename __vec_ext_traits<_Tp, sizeof(_Tp) * __num_element>::type;
-
-  _StorageType __storage_;
-
-  template <class, class>
-  friend struct simd;
-
-  template <class, class>
-  friend struct simd_mask;
-
-public:
-  _LIBCPP_HIDE_FROM_ABI _Tp __get(size_t __index) const noexcept { return __storage_[__index]; }
-  _LIBCPP_HIDE_FROM_ABI void __set(size_t __index, _Tp __val) noexcept {
-    __storage_[__index] = __val;
-  }
-};
-
-#endif // _LIBCPP_HAS_NO_VECTOR_EXTENSION
-
-template <class _Vp, class _Tp, class _Abi>
-class __simd_reference {
-  static_assert(std::is_same<_Vp, _Tp>::value, "");
-
-  template <class, class>
-  friend struct simd;
-
-  template <class, class>
-  friend struct simd_mask;
-
-  __simd_storage<_Tp, _Abi>* __ptr_;
-  size_t __index_;
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference(__simd_storage<_Tp, _Abi>* __ptr, size_t __index)
-      : __ptr_(__ptr), __index_(__index) {}
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference(const __simd_reference&) = default;
-
-public:
-  __simd_reference() = delete;
-  __simd_reference& operator=(const __simd_reference&) = delete;
-
-  _LIBCPP_HIDE_FROM_ABI operator _Vp() const { return __ptr_->__get(__index_); }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator=(_Vp __value) && {
-    __ptr_->__set(__index_, __value);
-    return *this;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator++() && {
-    return std::move(*this) = __ptr_->__get(__index_) + 1;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI _Vp operator++(int) && {
-    auto __val = __ptr_->__get(__index_);
-    __ptr_->__set(__index_, __val + 1);
-    return __val;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator--() && {
-    return std::move(*this) = __ptr_->__get(__index_) - 1;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI _Vp operator--(int) && {
-    auto __val = __ptr_->__get(__index_);
-    __ptr_->__set(__index_, __val - 1);
-    return __val;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator+=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) + __value;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator-=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) - __value;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator*=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) * __value;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator/=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) / __value;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator%=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) % __value;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator>>=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) >> __value;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator<<=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) << __value;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator&=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) & __value;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator|=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) | __value;
-  }
-
-  _LIBCPP_HIDE_FROM_ABI __simd_reference operator^=(_Vp __value) && {
-    return std::move(*this) = __ptr_->__get(__index_) ^ __value;
-  }
-};
-
-template <class _To, class _From>
-_LIBCPP_HIDE_FROM_ABI constexpr decltype(_To{std::declval<_From>()}, true)
-__is_non_narrowing_convertible_impl(_From) {
-  return true;
-}
-
-template <class _To>
-_LIBCPP_HIDE_FROM_ABI constexpr bool __is_non_narrowing_convertible_impl(...) {
-  return false;
-}
-
-template <class _From, class _To>
-_LIBCPP_HIDE_FROM_ABI
-constexpr typename std::enable_if<std::is_arithmetic<_To>::value &&
-                                      std::is_arithmetic<_From>::value,
-                                  bool>::type
-__is_non_narrowing_arithmetic_convertible() {
-  return experimental::__is_non_narrowing_convertible_impl<_To>(_From{});
-}
-
-template <class _From, class _To>
-_LIBCPP_HIDE_FROM_ABI
-constexpr typename std::enable_if<!(std::is_arithmetic<_To>::value &&
-                                    std::is_arithmetic<_From>::value),
-                                  bool>::type
-__is_non_narrowing_arithmetic_convertible() {
-  return false;
-}
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp __variadic_sum() {
-  return _Tp{};
-}
-
-template <class _Tp, class _Up, class... _Args>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp __variadic_sum(_Up __first, _Args... __rest) {
-  return static_cast<_Tp>(__first) + experimental::__variadic_sum<_Tp>(__rest...);
-}
-
-template <class _Tp>
-struct __nodeduce {
-  using type = _Tp;
-};
-
-template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr bool __vectorizable() {
-  return std::is_arithmetic<_Tp>::value && !std::is_const<_Tp>::value &&
-         !std::is_volatile<_Tp>::value && !std::is_same<_Tp, bool>::value;
-}
-
-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI
-
-using scalar = __simd_abi<_StorageKind::_Scalar, 1>;
-
-template <int _Np>
-using fixed_size = __simd_abi<_StorageKind::_Array, _Np>;
-
-template <class _Tp>
-inline constexpr size_t max_fixed_size = 32;
-
-template <class _Tp>
-using compatible = fixed_size<16 / sizeof(_Tp)>;
-
-#ifndef _LIBCPP_HAS_NO_VECTOR_EXTENSION
-template <class _Tp>
-using native = __simd_abi<_StorageKind::_VecExt,
-                          _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
-#else
-template <class _Tp>
-using native =
-    fixed_size<_Tp, _LIBCPP_NATIVE_SIMD_WIDTH_IN_BYTES / sizeof(_Tp)>;
-#endif // _LIBCPP_HAS_NO_VECTOR_EXTENSION
-
-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD_ABI
-_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD
-
-template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
-class simd;
-template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
-class simd_mask;
-
-struct element_aligned_tag {};
-struct vector_aligned_tag {};
-template <size_t>
-struct overaligned_tag {};
-inline constexpr element_aligned_tag element_aligned{};
-inline constexpr vector_aligned_tag vector_aligned{};
-template <size_t _Np>
-inline constexpr overaligned_tag<_Np> overaligned{};
-
-// traits [simd.traits]
-template <class _Tp>
-struct is_abi_tag : std::integral_constant<bool, false> {};
-
-template <_StorageKind __kind, int _Np>
-struct is_abi_tag<__simd_abi<__kind, _Np>>
-    : std::integral_constant<bool, true> {};
-
-template <class _Tp>
-struct is_simd : std::integral_constant<bool, false> {};
-
-template <class _Tp, class _Abi>
-struct is_simd<simd<_Tp, _Abi>> : std::integral_constant<bool, true> {};
-
-template <class _Tp>
-struct is_simd_mask : std::integral_constant<bool, false> {};
-
-template <class _Tp, class _Abi>
-struct is_simd_mask<simd_mask<_Tp, _Abi>> : std::integral_constant<bool, true> {
-};
-
-template <class _Tp>
-struct is_simd_flag_type : std::integral_constant<bool, false> {};
-
-template <>
-struct is_simd_flag_type<element_aligned_tag>
-    : std::integral_constant<bool, true> {};
-
-template <>
-struct is_simd_flag_type<vector_aligned_tag>
-    : std::integral_constant<bool, true> {};
-
-template <size_t _Align>
-struct is_simd_flag_type<overaligned_tag<_Align>>
-    : std::integral_constant<bool, true> {};
-
-template <class _Tp>
-inline constexpr bool is_abi_tag_v = is_abi_tag<_Tp>::value;
-template <class _Tp>
-inline constexpr bool is_simd_v = is_simd<_Tp>::value;
-template <class _Tp>
-inline constexpr bool is_simd_mask_v = is_simd_mask<_Tp>::value;
-template <class _Tp>
-inline constexpr bool is_simd_flag_type_v = is_simd_flag_type<_Tp>::value;
-template <class _Tp, size_t _Np>
-struct abi_for_size {
-  using type = simd_abi::fixed_size<_Np>;
-};
-template <class _Tp, size_t _Np>
-using abi_for_size_t = typename abi_for_size<_Tp, _Np>::type;
-
-template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
-struct simd_size;
-
-template <class _Tp, _StorageKind __kind, int _Np>
-struct simd_size<_Tp, __simd_abi<__kind, _Np>>
-    : std::integral_constant<size_t, _Np> {
-  static_assert(
-      std::is_arithmetic<_Tp>::value &&
-          !std::is_same<__remove_const_t<_Tp>, bool>::value,
-      "Element type should be vectorizable");
-};
-
-// TODO: implement it.
-template <class _Tp, class _Up = typename _Tp::value_type>
-struct memory_alignment;
-
-template <class _Tp, class _Abi = simd_abi::compatible<_Tp>>
-inline constexpr size_t simd_size_v = simd_size<_Tp, _Abi>::value;
-
-template <class _Tp, class _Up = typename _Tp::value_type>
-inline constexpr size_t memory_alignment_v = memory_alignment<_Tp, _Up>::value;
-
-// class template simd [simd.class]
-template <class _Tp>
-using native_simd = simd<_Tp, simd_abi::native<_Tp>>;
-template <class _Tp, int _Np>
-using fixed_size_simd = simd<_Tp, simd_abi::fixed_size<_Np>>;
-
-// class template simd_mask [simd.mask.class]
-template <class _Tp>
-using native_simd_mask = simd_mask<_Tp, simd_abi::native<_Tp>>;
-
-template <class _Tp, int _Np>
-using fixed_size_simd_mask = simd_mask<_Tp, simd_abi::fixed_size<_Np>>;
-
-// casts [simd.casts]
-template <class _Tp>
-struct __static_simd_cast_traits {
-  template <class _Up, class _Abi>
-  static simd<_Tp, _Abi> __apply(const simd<_Up, _Abi>& __v);
-};
-
-template <class _Tp, class _NewAbi>
-struct __static_simd_cast_traits<simd<_Tp, _NewAbi>> {
-  template <class _Up, class _Abi>
-  static typename std::enable_if<simd<_Up, _Abi>::size() ==
-                                     simd<_Tp, _NewAbi>::size(),
-                                 simd<_Tp, _NewAbi>>::type
-  __apply(const simd<_Up, _Abi>& __v);
-};
-
-template <class _Tp>
-struct __simd_cast_traits {
-  template <class _Up, class _Abi>
-  static typename std::enable_if<
-      __is_non_narrowing_arithmetic_convertible<_Up, _Tp>(),
-      simd<_Tp, _Abi>>::type
-  __apply(const simd<_Up, _Abi>& __v);
-};
-
-template <class _Tp, class _NewAbi>
-struct __simd_cast_traits<simd<_Tp, _NewAbi>> {
-  template <class _Up, class _Abi>
-  static typename std::enable_if<
-      __is_non_narrowing_arithmetic_convertible<_Up, _Tp>() &&
-          simd<_Up, _Abi>::size() == simd<_Tp, _NewAbi>::size(),
-      simd<_Tp, _NewAbi>>::type
-  __apply(const simd<_Up, _Abi>& __v);
-};
-
-template <class _Tp, class _Up, class _Abi>
-_LIBCPP_HIDE_FROM_ABI auto simd_cast(const simd<_Up, _Abi>& __v)
-    -> decltype(__simd_cast_traits<_Tp>::__apply(__v)) {
-  return __simd_cast_traits<_Tp>::__apply(__v);
-}
-
-template <class _Tp, class _Up, class _Abi>
-_LIBCPP_HIDE_FROM_ABI auto static_simd_cast(const simd<_Up, _Abi>& __v)
-    -> decltype(__static_simd_cast_traits<_Tp>::__apply(__v)) {
-  return __static_simd_cast_traits<_Tp>::__apply(__v);
-}
-
-template <class _Tp, class _Abi>
-fixed_size_simd<_Tp, simd_size<_Tp, _Abi>::value>
-to_fixed_size(const simd<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-fixed_size_simd_mask<_Tp, simd_size<_Tp, _Abi>::value>
-to_fixed_size(const simd_mask<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, size_t _Np>
-native_simd<_Tp> to_native(const fixed_size_simd<_Tp, _Np>&) noexcept;
-
-template <class _Tp, size_t _Np>
-native_simd_mask<_Tp> to_native(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
-
-template <class _Tp, size_t _Np>
-simd<_Tp> to_compatible(const fixed_size_simd<_Tp, _Np>&) noexcept;
-
-template <class _Tp, size_t _Np>
-simd_mask<_Tp> to_compatible(const fixed_size_simd_mask<_Tp, _Np>&) noexcept;
-
-template <size_t... __sizes, class _Tp, class _Abi>
-tuple<simd<_Tp, abi_for_size_t<_Tp, __sizes>>...> split(const simd<_Tp, _Abi>&);
-
-template <size_t... __sizes, class _Tp, class _Abi>
-tuple<simd_mask<_Tp, abi_for_size_t<_Tp, __sizes>>...>
-split(const simd_mask<_Tp, _Abi>&);
-
-template <class _SimdType, class _Abi>
-array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
-                     _SimdType::size()>
-split(const simd<typename _SimdType::value_type, _Abi>&);
-
-template <class _SimdType, class _Abi>
-array<_SimdType, simd_size<typename _SimdType::value_type, _Abi>::value /
-                     _SimdType::size()>
-split(const simd_mask<typename _SimdType::value_type, _Abi>&);
-
-template <class _Tp, class... _Abis>
-simd<_Tp, abi_for_size_t<_Tp, experimental::__variadic_sum(simd_size<_Tp, _Abis>::value...)>>
-concat(const simd<_Tp, _Abis>&...);
-
-template <class _Tp, class... _Abis>
-simd_mask<_Tp,
-          abi_for_size_t<_Tp, experimental::__variadic_sum(simd_size<_Tp, _Abis>::value...)>>
-concat(const simd_mask<_Tp, _Abis>&...);
-
-// reductions [simd.mask.reductions]
-template <class _Tp, class _Abi>
-bool all_of(const simd_mask<_Tp, _Abi>&) noexcept;
-template <class _Tp, class _Abi>
-bool any_of(const simd_mask<_Tp, _Abi>&) noexcept;
-template <class _Tp, class _Abi>
-bool none_of(const simd_mask<_Tp, _Abi>&) noexcept;
-template <class _Tp, class _Abi>
-bool some_of(const simd_mask<_Tp, _Abi>&) noexcept;
-template <class _Tp, class _Abi>
-int popcount(const simd_mask<_Tp, _Abi>&) noexcept;
-template <class _Tp, class _Abi>
-int find_first_set(const simd_mask<_Tp, _Abi>&);
-template <class _Tp, class _Abi>
-int find_last_set(const simd_mask<_Tp, _Abi>&);
-bool all_of(bool) noexcept;
-bool any_of(bool) noexcept;
-bool none_of(bool) noexcept;
-bool some_of(bool) noexcept;
-int popcount(bool) noexcept;
-int find_first_set(bool) noexcept;
-int find_last_set(bool) noexcept;
-
-// masked assignment [simd.whereexpr]
-template <class _MaskType, class _Tp>
-class const_where_expression;
-template <class _MaskType, class _Tp>
-class where_expression;
-
-// masked assignment [simd.mask.where]
-template <class _Tp, class _Abi>
-where_expression<simd_mask<_Tp, _Abi>, simd<_Tp, _Abi>>
-where(const typename simd<_Tp, _Abi>::mask_type&, simd<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-const_where_expression<simd_mask<_Tp, _Abi>, const simd<_Tp, _Abi>>
-where(const typename simd<_Tp, _Abi>::mask_type&,
-      const simd<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-where_expression<simd_mask<_Tp, _Abi>, simd_mask<_Tp, _Abi>>
-where(const typename __nodeduce<simd_mask<_Tp, _Abi>>::type&,
-      simd_mask<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-const_where_expression<simd_mask<_Tp, _Abi>, const simd_mask<_Tp, _Abi>>
-where(const typename __nodeduce<simd_mask<_Tp, _Abi>>::type&,
-      const simd_mask<_Tp, _Abi>&) noexcept;
-
-template <class _Tp>
-where_expression<bool, _Tp> where(bool, _Tp&) noexcept;
-
-template <class _Tp>
-const_where_expression<bool, const _Tp> where(bool, const _Tp&) noexcept;
-
-// reductions [simd.reductions]
-template <class _Tp, class _Abi, class _BinaryOp = std::plus<_Tp>>
-_Tp reduce(const simd<_Tp, _Abi>&, _BinaryOp = _BinaryOp());
-
-template <class _MaskType, class _SimdType, class _BinaryOp>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       typename _SimdType::value_type __neutral_element, _BinaryOp);
-
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       plus<typename _SimdType::value_type> = {});
-
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       multiplies<typename _SimdType::value_type>);
-
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       bit_and<typename _SimdType::value_type>);
-
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       bit_or<typename _SimdType::value_type>);
-
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-reduce(const const_where_expression<_MaskType, _SimdType>&,
-       bit_xor<typename _SimdType::value_type>);
-
-template <class _Tp, class _Abi>
-_Tp hmin(const simd<_Tp, _Abi>&);
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-hmin(const const_where_expression<_MaskType, _SimdType>&);
-template <class _Tp, class _Abi>
-_Tp hmax(const simd<_Tp, _Abi>&);
-template <class _MaskType, class _SimdType>
-typename _SimdType::value_type
-hmax(const const_where_expression<_MaskType, _SimdType>&);
-
-// algorithms [simd.alg]
-template <class _Tp, class _Abi>
-simd<_Tp, _Abi> min(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-simd<_Tp, _Abi> max(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-std::pair<simd<_Tp, _Abi>, simd<_Tp, _Abi>>
-minmax(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&) noexcept;
-
-template <class _Tp, class _Abi>
-simd<_Tp, _Abi> clamp(const simd<_Tp, _Abi>&, const simd<_Tp, _Abi>&,
-                      const simd<_Tp, _Abi>&);
-
-// [simd.whereexpr]
-// TODO implement where expressions.
-template <class _MaskType, class _Tp>
-class const_where_expression {
-public:
-  const_where_expression(const const_where_expression&) = delete;
-  const_where_expression& operator=(const const_where_expression&) = delete;
-  __remove_const_t<_Tp> operator-() const&&;
-  template <class _Up, class _Flags>
-  void copy_to(_Up*, _Flags) const&&;
-};
-
-template <class _MaskType, class _Tp>
-class where_expression : public const_where_expression<_MaskType, _Tp> {
-public:
-  where_expression(const where_expression&) = delete;
-  where_expression& operator=(const where_expression&) = delete;
-  template <class _Up>
-  void operator=(_Up&&);
-  template <class _Up>
-  void operator+=(_Up&&);
-  template <class _Up>
-  void operator-=(_Up&&);
-  template <class _Up>
-  void operator*=(_Up&&);
-  template <class _Up>
-  void operator/=(_Up&&);
-  template <class _Up>
-  void operator%=(_Up&&);
-  template <class _Up>
-  void operator&=(_Up&&);
-  template <class _Up>
-  void operator|=(_Up&&);
-  template <class _Up>
-  void operator^=(_Up&&);
-  template <class _Up>
-  void operator<<=(_Up&&);
-  template <class _Up>
-  void operator>>=(_Up&&);
-  void operator++();
-  void operator++(int);
-  void operator--();
-  void operator--(int);
-  template <class _Up, class _Flags>
-  void copy_from(const _Up*, _Flags);
-};
-
-// [simd.class]
-// TODO: implement simd
-template <class _Tp, class _Abi>
-class simd {
-public:
-  using value_type = _Tp;
-  using reference = __simd_reference<_Tp, _Tp, _Abi>;
-  using mask_type = simd_mask<_Tp, _Abi>;
-  using abi_type = _Abi;
-
-  _LIBCPP_HIDE_FROM_ABI simd() = default;
-  _LIBCPP_HIDE_FROM_ABI simd(const simd&) = default;
-  _LIBCPP_HIDE_FROM_ABI simd& operator=(const simd&) = default;
-
-  static _LIBCPP_HIDE_FROM_ABI constexpr size_t size() noexcept {
-    return simd_size<_Tp, _Abi>::value;
-  }
-
-private:
-  __simd_storage<_Tp, _Abi> __s_;
-
-  template <class _Up>
-  static _LIBCPP_HIDE_FROM_ABI constexpr bool __can_broadcast() {
-    return (std::is_arithmetic<_Up>::value &&
-            __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()) ||
-           (!std::is_arithmetic<_Up>::value &&
-            std::is_convertible<_Up, _Tp>::value) ||
-           std::is_same<__remove_const_t<_Up>, int>::value ||
-           (std::is_same<__remove_const_t<_Up>,
-                         unsigned int>::value &&
-            std::is_unsigned<_Tp>::value);
-  }
-
-  template <class _Generator, size_t... __indicies>
-  static _LIBCPP_HIDE_FROM_ABI constexpr decltype(
-      std::forward_as_tuple(std::declval<_Generator>()(
-          std::integral_constant<size_t, __indicies>())...),
-      bool())
-  __can_generate(std::index_sequence<__indicies...>) {
-    return !experimental::__variadic_sum<bool>(
-        !__can_broadcast<decltype(std::declval<_Generator>()(
-            std::integral_constant<size_t, __indicies>()))>()...);
-  }
-
-  template <class _Generator>
-  static _LIBCPP_HIDE_FROM_ABI bool __can_generate(...) {
-    return false;
-  }
-
-  template <class _Generator, size_t... __indicies>
-  _LIBCPP_HIDE_FROM_ABI void __generator_init(_Generator&& __g, std::index_sequence<__indicies...>) {
-    int __not_used[]{((*this)[__indicies] =
-                          __g(std::integral_constant<size_t, __indicies>()),
-                      0)...};
-    (void)__not_used;
-  }
-
-public:
-  // implicit type conversion constructor
-  template <class _Up,
-            class = typename std::enable_if<
-                std::is_same<_Abi, simd_abi::fixed_size<size()>>::value &&
-                __is_non_narrowing_arithmetic_convertible<_Up, _Tp>()>::type>
-  _LIBCPP_HIDE_FROM_ABI simd(const simd<_Up, simd_abi::fixed_size<size()>>& __v) {
-    for (size_t __i = 0; __i < size(); __i++) {
-      (*this)[__i] = static_cast<_Tp>(__v[__i]);
-    }
-  }
-
-  // implicit broadcast constructor
-  template <class _Up,
-            class = typename std::enable_if<__can_broadcast<_Up>()>::type>
-  _LIBCPP_HIDE_FROM_ABI simd(_Up&& __rv) {
-    auto __v = static_cast<_Tp>(__rv);
-    for (size_t __i = 0; __i < size(); __i++) {
-      (*this)[__i] = __v;
-    }
-  }
-
-  // generator constructor
-  template <class _Generator,
-            int = typename std::enable_if<
-                __can_generate<_Generator>(std::make_index_sequence<size()>()),
-                int>::type()>
-  explicit _LIBCPP_HIDE_FROM_ABI simd(_Generator&& __g) {
-    __generator_init(std::forward<_Generator>(__g),
-                     std::make_index_sequence<size()>());
-  }
-
-  // load constructor
-  template <
-      class _Up, class _Flags,
-      class = typename std::enable_if<__vectorizable<_Up>()>::type,
-      class = typename std::enable_if<is_simd_flag_type<_Flags>::value>::type>
-  _LIBCPP_HIDE_FROM_ABI simd(const _Up* __buffer, _Flags) {
-    // TODO: optimize for overaligned flags
-    for (size_t __i = 0; __i < size(); __i++) {
-      (*this)[__i] = static_cast<_Tp>(__buffer[__i]);
-    }
-  }
-
-  // loads [simd.load]
-  template <class _Up, class _Flags>
-  typename std::enable_if<__vectorizable<_Up>() &&
-                          is_simd_flag_type<_Flags>::value>::type
-  _LIBCPP_HIDE_FROM_ABI copy_from(const _Up* __buffer, _Flags) {
-    *this = simd(__buffer, _Flags());
-  }
-
-  // stores [simd.store]
-  template <class _Up, class _Flags>
-  typename std::enable_if<__vectorizable<_Up>() &&
-                          is_simd_flag_type<_Flags>::value>::type
-  _LIBCPP_HIDE_FROM_ABI copy_to(_Up* __buffer, _Flags) const {
-    // TODO: optimize for overaligned flags
-    for (size_t __i = 0; __i < size(); __i++) {
-      __buffer[__i] = static_cast<_Up>((*this)[__i]);
-    }
-  }
-
-  // scalar access [simd.subscr]
-  _LIBCPP_HIDE_FROM_ABI reference operator[](size_t __i) { return reference(&__s_, __i); }
-
-  _LIBCPP_HIDE_FROM_ABI value_type operator[](size_t __i) const { return __s_.__get(__i); }
-
-  // unary operators [simd.unary]
-  simd& operator++();
-  simd operator++(int);
-  simd& operator--();
-  simd operator--(int);
-  mask_type operator!() const;
-  simd operator~() const;
-  simd operator+() const;
-  simd operator-() const;
-
-#if 0
-  // binary operators [simd.binary]
-  friend simd operator+(const simd&, const simd&);
-  friend simd operator-(const simd&, const simd&);
-  friend simd operator*(const simd&, const simd&);
-  friend simd operator/(const simd&, const simd&);
-  friend simd operator%(const simd&, const simd&);
-  friend simd operator&(const simd&, const simd&);
-  friend simd operator|(const simd&, const simd&);
-  friend simd operator^(const simd&, const simd&);
-  friend simd operator<<(const simd&, const simd&);
-  friend simd operator>>(const simd&, const simd&);
-  friend simd operator<<(const simd&, int);
-  friend simd operator>>(const simd&, int);
-
-  // compound assignment [simd.cassign]
-  friend simd& operator+=(simd&, const simd&);
-  friend simd& operator-=(simd&, const simd&);
-  friend simd& operator*=(simd&, const simd&);
-  friend simd& operator/=(simd&, const simd&);
-  friend simd& operator%=(simd&, const simd&);
-
-  friend simd& operator&=(simd&, const simd&);
-  friend simd& operator|=(simd&, const simd&);
-  friend simd& operator^=(simd&, const simd&);
-  friend simd& operator<<=(simd&, const simd&);
-  friend simd& operator>>=(simd&, const simd&);
-  friend simd& operator<<=(simd&, int);
-  friend simd& operator>>=(simd&, int);
-
-  // compares [simd.comparison]
-  friend mask_type operator==(const simd&, const simd&);
-  friend mask_type operator!=(const simd&, const simd&);
-  friend mask_type operator>=(const simd&, const simd&);
-  friend mask_type operator<=(const simd&, const simd&);
-  friend mask_type operator>(const simd&, const simd&);
-  friend mask_type operator<(const simd&, const simd&);
-#endif
-};
-
-// [simd.mask.class]
-template <class _Tp, class _Abi>
-// TODO: implement simd_mask
-class simd_mask {
-public:
-  using value_type = bool;
-  // TODO: this is strawman implementation. Turn it into a proxy type.
-  using reference = bool&;
-  using simd_type = simd<_Tp, _Abi>;
-  using abi_type = _Abi;
-  static constexpr size_t size() noexcept;
-  _LIBCPP_HIDE_FROM_ABI simd_mask() = default;
-
-  // broadcast constructor
-  explicit simd_mask(value_type) noexcept;
-
-  // implicit type conversion constructor
-  template <class _Up>
-  simd_mask(const simd_mask<_Up, simd_abi::fixed_size<size()>>&) noexcept;
-
-  // load constructor
-  template <class _Flags>
-  simd_mask(const value_type*, _Flags);
-
-  // loads [simd.mask.copy]
-  template <class _Flags>
-  void copy_from(const value_type*, _Flags);
-  template <class _Flags>
-  void copy_to(value_type*, _Flags) const;
-
-  // scalar access [simd.mask.subscr]
-  reference operator[](size_t);
-  value_type operator[](size_t) const;
-
-  // unary operators [simd.mask.unary]
-  simd_mask operator!() const noexcept;
-
-#if 0
-  // simd_mask binary operators [simd.mask.binary]
-  friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator||(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator&(const simd_mask&, const simd_mask&)noexcept;
-  friend simd_mask operator|(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator^(const simd_mask&, const simd_mask&) noexcept;
-
-  // simd_mask compound assignment [simd.mask.cassign]
-  friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask& operator|=(simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept;
-
-  // simd_mask compares [simd.mask.comparison]
-  friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;
-  friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
-#endif
-};
-
-#endif // _LIBCPP_STD_VER >= 17
-
-_LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
-
-_LIBCPP_POP_MACROS
-
-#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-#  include <algorithm>
-#  include <functional>
-#endif
+#include <experimental/__config>
+#include <experimental/__simd/aligned_tag.h>
+#include <experimental/__simd/declaration.h>
+#include <experimental/__simd/reference.h>
+#include <experimental/__simd/scalar.h>
+#include <experimental/__simd/simd.h>
+#include <experimental/__simd/simd_mask.h>
+#include <experimental/__simd/traits.h>
+#include <experimental/__simd/vec_ext.h>
 
 #endif /* _LIBCPP_EXPERIMENTAL_SIMD */
diff --git a/third_party/libcxx/experimental/string b/third_party/libcxx/experimental/string
deleted file mode 100644
index 4edbf98b5..000000000
--- a/third_party/libcxx/experimental/string
+++ /dev/null
@@ -1,73 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_STRING
-#define _LIBCPP_EXPERIMENTAL_STRING
-
-/*
-    experimental/string synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  // basic_string using polymorphic allocator in namespace pmr
-  template <class charT, class traits = char_traits<charT>>
-   using basic_string =
-     std::basic_string<charT, traits, polymorphic_allocator<charT>>;
-
-  // basic_string typedef names using polymorphic allocator in namespace
-  // std::experimental::pmr
-  typedef basic_string<char> string;
-  typedef basic_string<char16_t> u16string;
-  typedef basic_string<char32_t> u32string;
-  typedef basic_string<wchar_t> wstring;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <string>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-
-template <class _CharT, class _Traits = char_traits<_CharT>>
-using basic_string =
-    _VSTD::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("string") typedef basic_string<char> string;
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("u16string") typedef basic_string<char16_t> u16string;
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("u32string") typedef basic_string<char32_t> u32string;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("wstring") typedef basic_string<wchar_t> wstring;
-#endif
-
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_STRING */
diff --git a/third_party/libcxx/experimental/type_traits b/third_party/libcxx/experimental/type_traits
index d1cc2e5c8..31b041bc9 100644
--- a/third_party/libcxx/experimental/type_traits
+++ b/third_party/libcxx/experimental/type_traits
@@ -68,17 +68,16 @@ inline namespace fundamentals_v1 {
 
  */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 
 #if _LIBCPP_STD_VER >= 14
 
-#include <initializer_list>
-#include <type_traits>
+#  include <initializer_list>
+#  include <type_traits>
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
@@ -104,49 +103,48 @@ using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type;
 */
 
 // 3.3.4, Detection idiom
-template <class...> using void_t = void;
+template <class...>
+using void_t = void;
 
 struct nonesuch : private __nat { // make nonesuch "not an aggregate"
-  ~nonesuch() = delete;
-  nonesuch      (nonesuch const&) = delete;
+  ~nonesuch()                     = delete;
+  nonesuch(nonesuch const&)       = delete;
   void operator=(nonesuch const&) = delete;
-  };
+};
 
 template <class _Default, class _AlwaysVoid, template <class...> class _Op, class... _Args>
 struct _DETECTOR {
-   using value_t = false_type;
-   using type = _Default;
-   };
+  using value_t = false_type;
+  using type    = _Default;
+};
 
 template <class _Default, template <class...> class _Op, class... _Args>
 struct _DETECTOR<_Default, void_t<_Op<_Args...>>, _Op, _Args...> {
-   using value_t = true_type;
-   using type = _Op<_Args...>;
-   };
+  using value_t = true_type;
+  using type    = _Op<_Args...>;
+};
 
+template <template <class...> class _Op, class... _Args>
+using is_detected = typename _DETECTOR<nonesuch, void, _Op, _Args...>::value_t;
+template <template <class...> class _Op, class... _Args>
+using detected_t = typename _DETECTOR<nonesuch, void, _Op, _Args...>::type;
+template <template <class...> class _Op, class... _Args>
+constexpr bool is_detected_v = is_detected<_Op, _Args...>::value;
 
-template <template<class...> class _Op, class... _Args>
-  using is_detected = typename _DETECTOR<nonesuch, void, _Op, _Args...>::value_t;
-template <template<class...> class _Op, class... _Args>
-  using detected_t = typename _DETECTOR<nonesuch, void, _Op, _Args...>::type;
-template <template<class...> class _Op, class... _Args>
-  _LIBCPP_CONSTEXPR bool is_detected_v = is_detected<_Op, _Args...>::value;
+template <class _Default, template <class...> class _Op, class... _Args>
+using detected_or = _DETECTOR<_Default, void, _Op, _Args...>;
+template <class _Default, template <class...> class _Op, class... _Args>
+using detected_or_t = typename detected_or<_Default, _Op, _Args...>::type;
 
-template <class Default, template<class...> class _Op, class... _Args>
-  using detected_or = _DETECTOR<Default, void, _Op, _Args...>;
-template <class Default, template<class...> class _Op, class... _Args>
-  using detected_or_t = typename detected_or<Default, _Op, _Args...>::type;
-
-template <class Expected, template<class...> class _Op, class... _Args>
-  using is_detected_exact = is_same<Expected, detected_t<_Op, _Args...>>;
-template <class Expected, template<class...> class _Op, class... _Args>
-  _LIBCPP_CONSTEXPR bool is_detected_exact_v = is_detected_exact<Expected, _Op, _Args...>::value;
-
-template <class To, template<class...> class _Op, class... _Args>
-  using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, To>;
-template <class To, template<class...> class _Op, class... _Args>
-  _LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<To, _Op, _Args...>::value;
+template <class _Expected, template <class...> class _Op, class... _Args>
+using is_detected_exact = is_same<_Expected, detected_t<_Op, _Args...>>;
+template <class _Expected, template <class...> class _Op, class... _Args>
+constexpr bool is_detected_exact_v = is_detected_exact<_Expected, _Op, _Args...>::value;
 
+template <class _To, template <class...> class _Op, class... _Args>
+using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, _To>;
+template <class _To, template <class...> class _Op, class... _Args>
+constexpr bool is_detected_convertible_v = is_detected_convertible<_To, _Op, _Args...>::value;
 
 _LIBCPP_END_NAMESPACE_LFTS
 
diff --git a/third_party/libcxx/experimental/unordered_map b/third_party/libcxx/experimental/unordered_map
deleted file mode 100644
index d2801822a..000000000
--- a/third_party/libcxx/experimental/unordered_map
+++ /dev/null
@@ -1,78 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_UNORDERED_MAP
-#define _LIBCPP_EXPERIMENTAL_UNORDERED_MAP
-
-/*
-    experimental/unordered_map synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class Key, class T,
-            class Hash = hash<Key>,
-            class Pred = equal_to<Key>>
-  using unordered_map =
-    std::unordered_map<Key, T, Hash, Pred,
-                       polymorphic_allocator<pair<const Key,T>>>;
-
-  template <class Key, class T,
-            class Hash = hash<Key>,
-            class Pred = equal_to<Key>>
-  using unordered_multimap =
-    std::unordered_multimap<Key, T, Hash, Pred,
-                            polymorphic_allocator<pair<const Key,T>>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <unordered_map>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Key, class _Value,
-          class _Hash = hash<_Key>, class _Pred = equal_to<_Key>>
-using unordered_map = _VSTD::unordered_map<_Key, _Value, _Hash, _Pred,
-                        polymorphic_allocator<pair<const _Key, _Value>>>;
-
-template <class _Key, class _Value,
-          class _Hash = hash<_Key>, class _Pred = equal_to<_Key>>
-using unordered_multimap = _VSTD::unordered_multimap<_Key, _Value, _Hash, _Pred,
-                        polymorphic_allocator<pair<const _Key, _Value>>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-#  include <algorithm>
-#  include <array>
-#  include <bit>
-#  include <functional>
-#  include <vector>
-#endif
-
-#endif /* _LIBCPP_EXPERIMENTAL_UNORDERED_MAP */
diff --git a/third_party/libcxx/experimental/unordered_set b/third_party/libcxx/experimental/unordered_set
deleted file mode 100644
index 493e3a09e..000000000
--- a/third_party/libcxx/experimental/unordered_set
+++ /dev/null
@@ -1,64 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_UNORDERED_SET
-#define _LIBCPP_EXPERIMENTAL_UNORDERED_SET
-
-/*
-    experimental/unordered_set synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class T, class Hash = hash<T>, class Pred = equal_to<T>>
-  using unordered_set = std::unordered_set<T, Hash, Pred,
-                       polymorphic_allocator<T>>;
-
-  template <class T, class Hash = hash<T>, class Pred = equal_to<T>>
-  using unordered_multiset = std::unordered_multiset<T, Hash, Pred,
-                       polymorphic_allocator<T>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <unordered_set>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Value,
-          class _Hash = hash<_Value>, class _Pred = equal_to<_Value>>
-using unordered_set = _VSTD::unordered_set<_Value, _Hash, _Pred,
-                        polymorphic_allocator<_Value>>;
-
-template <class _Value,
-          class _Hash = hash<_Value>, class _Pred = equal_to<_Value>>
-using unordered_multiset = _VSTD::unordered_multiset<_Value, _Hash, _Pred,
-                        polymorphic_allocator<_Value>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_UNORDERED_SET */
diff --git a/third_party/libcxx/experimental/utility b/third_party/libcxx/experimental/utility
index 576b8be46..8bd0a055b 100644
--- a/third_party/libcxx/experimental/utility
+++ b/third_party/libcxx/experimental/utility
@@ -30,7 +30,6 @@ inline namespace fundamentals_v1 {
 
  */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <experimental/__config>
 #include <utility>
 
@@ -40,7 +39,7 @@ inline namespace fundamentals_v1 {
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
-  struct _LIBCPP_TEMPLATE_VIS erased_type { };
+struct _LIBCPP_TEMPLATE_VIS erased_type {};
 
 _LIBCPP_END_NAMESPACE_LFTS
 
diff --git a/third_party/libcxx/experimental/vector b/third_party/libcxx/experimental/vector
deleted file mode 100644
index 2e9d77e41..000000000
--- a/third_party/libcxx/experimental/vector
+++ /dev/null
@@ -1,52 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_VECTOR
-#define _LIBCPP_EXPERIMENTAL_VECTOR
-
-/*
-    experimental/vector synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class T>
-  using vector = std::vector<T, polymorphic_allocator<T>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <vector>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _ValueT>
-using vector = _VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_VECTOR */
diff --git a/third_party/libcxx/ext/__hash b/third_party/libcxx/ext/__hash
index f5893afbf..67f7e3517 100644
--- a/third_party/libcxx/ext/__hash
+++ b/third_party/libcxx/ext/__hash
@@ -10,6 +10,8 @@
 #ifndef _LIBCPP_EXT_HASH
 #define _LIBCPP_EXT_HASH
 
+#pragma GCC system_header
+
 #include <__config>
 #include <cstring>
 #include <stddef.h>
@@ -17,116 +19,66 @@
 
 namespace __gnu_cxx {
 
-template <typename _Tp> struct _LIBCPP_TEMPLATE_VIS hash { };
+template <typename _Tp>
+struct _LIBCPP_TEMPLATE_VIS hash {};
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<const char*>
- : public std::__unary_function<const char*, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const char *__c) const _NOEXCEPT
-    {
-        return std::__do_string_hash(__c, __c + strlen(__c));
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<const char*> : public std::__unary_function<const char*, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const char* __c) const _NOEXCEPT {
+    return std::__do_string_hash(__c, __c + strlen(__c));
+  }
 };
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<char *>
- : public std::__unary_function<char*, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(char *__c) const _NOEXCEPT
-    {
-        return std::__do_string_hash<const char *>(__c, __c + strlen(__c));
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<char*> : public std::__unary_function<char*, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(char* __c) const _NOEXCEPT {
+    return std::__do_string_hash<const char*>(__c, __c + strlen(__c));
+  }
 };
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<char>
- : public std::__unary_function<char, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(char __c) const _NOEXCEPT
-    {
-        return __c;
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<char> : public std::__unary_function<char, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(char __c) const _NOEXCEPT { return __c; }
 };
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<signed char>
- : public std::__unary_function<signed char, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(signed char __c) const _NOEXCEPT
-    {
-        return __c;
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<signed char> : public std::__unary_function<signed char, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(signed char __c) const _NOEXCEPT { return __c; }
 };
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned char>
- : public std::__unary_function<unsigned char, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(unsigned char __c) const _NOEXCEPT
-    {
-        return __c;
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned char> : public std::__unary_function<unsigned char, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(unsigned char __c) const _NOEXCEPT { return __c; }
 };
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<short>
- : public std::__unary_function<short, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(short __c) const _NOEXCEPT
-    {
-        return __c;
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<short> : public std::__unary_function<short, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(short __c) const _NOEXCEPT { return __c; }
 };
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned short>
- : public std::__unary_function<unsigned short, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(unsigned short __c) const _NOEXCEPT
-    {
-        return __c;
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned short> : public std::__unary_function<unsigned short, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(unsigned short __c) const _NOEXCEPT { return __c; }
 };
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<int>
-    : public std::__unary_function<int, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(int __c) const _NOEXCEPT
-    {
-        return __c;
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<int> : public std::__unary_function<int, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(int __c) const _NOEXCEPT { return __c; }
 };
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned int>
-    : public std::__unary_function<unsigned int, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(unsigned int __c) const _NOEXCEPT
-    {
-        return __c;
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned int> : public std::__unary_function<unsigned int, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(unsigned int __c) const _NOEXCEPT { return __c; }
 };
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<long>
-    : public std::__unary_function<long, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(long __c) const _NOEXCEPT
-    {
-        return __c;
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<long> : public std::__unary_function<long, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(long __c) const _NOEXCEPT { return __c; }
 };
 
-template <> struct _LIBCPP_TEMPLATE_VIS hash<unsigned long>
-    : public std::__unary_function<unsigned long, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(unsigned long __c) const _NOEXCEPT
-    {
-        return __c;
-    }
+template <>
+struct _LIBCPP_TEMPLATE_VIS hash<unsigned long> : public std::__unary_function<unsigned long, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(unsigned long __c) const _NOEXCEPT { return __c; }
 };
 } // namespace __gnu_cxx
 
diff --git a/third_party/libcxx/ext/hash_map b/third_party/libcxx/ext/hash_map
new file mode 100644
index 000000000..7b5b31c40
--- /dev/null
+++ b/third_party/libcxx/ext/hash_map
@@ -0,0 +1,872 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_HASH_MAP
+#define _LIBCPP_HASH_MAP
+
+/*
+
+    hash_map synopsis
+
+namespace __gnu_cxx
+{
+
+template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+          class Alloc = allocator<pair<const Key, T>>>
+class hash_map
+{
+public:
+    // types
+    typedef Key                                                        key_type;
+    typedef T                                                          mapped_type;
+    typedef Hash                                                       hasher;
+    typedef Pred                                                       key_equal;
+    typedef Alloc                                                      allocator_type;
+    typedef pair<const key_type, mapped_type>                          value_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    typedef typename allocator_traits<allocator_type>::pointer         pointer;
+    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
+    typedef typename allocator_traits<allocator_type>::size_type       size_type;
+    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+
+    typedef /unspecified/ iterator;
+    typedef /unspecified/ const_iterator;
+
+    hash_map();
+    explicit hash_map(size_type n, const hasher& hf = hasher(),
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& a = allocator_type());
+    template <class InputIterator>
+    hash_map(InputIterator f, InputIterator l);
+    template <class InputIterator>
+    hash_map(InputIterator f, InputIterator l,
+                size_type n, const hasher& hf = hasher(),
+                const key_equal& eql = key_equal(),
+                const allocator_type& a = allocator_type());
+    hash_map(const hash_map&);
+    ~hash_map();
+    hash_map& operator=(const hash_map&);
+
+    allocator_type get_allocator() const;
+
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;
+
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+
+    pair<iterator, bool> insert(const value_type& obj);
+    template <class InputIterator>
+        void insert(InputIterator first, InputIterator last);
+
+    void erase(const_iterator position);
+    size_type erase(const key_type& k);
+    void erase(const_iterator first, const_iterator last);
+    void clear();
+
+    void swap(hash_map&);
+
+    hasher hash_funct() const;
+    key_equal key_eq() const;
+
+    iterator       find(const key_type& k);
+    const_iterator find(const key_type& k) const;
+    size_type count(const key_type& k) const;
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+
+    mapped_type& operator[](const key_type& k);
+
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;
+
+    size_type elems_in_bucket(size_type n) const;
+
+    void resize(size_type n);
+};
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    void swap(hash_map<Key, T, Hash, Pred, Alloc>& x,
+              hash_map<Key, T, Hash, Pred, Alloc>& y);
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    bool
+    operator==(const hash_map<Key, T, Hash, Pred, Alloc>& x,
+               const hash_map<Key, T, Hash, Pred, Alloc>& y);
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    bool
+    operator!=(const hash_map<Key, T, Hash, Pred, Alloc>& x,
+               const hash_map<Key, T, Hash, Pred, Alloc>& y);
+
+template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+          class Alloc = allocator<pair<const Key, T>>>
+class hash_multimap
+{
+public:
+    // types
+    typedef Key                                                        key_type;
+    typedef T                                                          mapped_type;
+    typedef Hash                                                       hasher;
+    typedef Pred                                                       key_equal;
+    typedef Alloc                                                      allocator_type;
+    typedef pair<const key_type, mapped_type>                          value_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    typedef typename allocator_traits<allocator_type>::pointer         pointer;
+    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
+    typedef typename allocator_traits<allocator_type>::size_type       size_type;
+    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+
+    typedef /unspecified/ iterator;
+    typedef /unspecified/ const_iterator;
+
+    explicit hash_multimap(size_type n = 193, const hasher& hf = hasher(),
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& a = allocator_type());
+    template <class InputIterator>
+        hash_multimap(InputIterator f, InputIterator l,
+                      size_type n = 193, const hasher& hf = hasher(),
+                      const key_equal& eql = key_equal(),
+                      const allocator_type& a = allocator_type());
+    explicit hash_multimap(const allocator_type&);
+    hash_multimap(const hash_multimap&);
+    ~hash_multimap();
+    hash_multimap& operator=(const hash_multimap&);
+
+    allocator_type get_allocator() const;
+
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;
+
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+
+    iterator insert(const value_type& obj);
+    template <class InputIterator>
+        void insert(InputIterator first, InputIterator last);
+
+    void erase(const_iterator position);
+    size_type erase(const key_type& k);
+    void erase(const_iterator first, const_iterator last);
+    void clear();
+
+    void swap(hash_multimap&);
+
+    hasher hash_funct() const;
+    key_equal key_eq() const;
+
+    iterator       find(const key_type& k);
+    const_iterator find(const key_type& k) const;
+    size_type count(const key_type& k) const;
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;
+
+    size_type elems_in_bucket(size_type n) const;
+
+    void resize(size_type n);
+};
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    void swap(hash_multimap<Key, T, Hash, Pred, Alloc>& x,
+              hash_multimap<Key, T, Hash, Pred, Alloc>& y);
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    bool
+    operator==(const hash_multimap<Key, T, Hash, Pred, Alloc>& x,
+               const hash_multimap<Key, T, Hash, Pred, Alloc>& y);
+
+template <class Key, class T, class Hash, class Pred, class Alloc>
+    bool
+    operator!=(const hash_multimap<Key, T, Hash, Pred, Alloc>& x,
+               const hash_multimap<Key, T, Hash, Pred, Alloc>& y);
+
+}  // __gnu_cxx
+
+*/
+
+#include <__config>
+#include <__hash_table>
+#include <algorithm>
+#include <ext/__hash>
+#include <functional>
+
+#if defined(__DEPRECATED) && __DEPRECATED
+#  if defined(_LIBCPP_WARNING)
+_LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")
+#  else
+#    warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>
+#  endif
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+namespace __gnu_cxx {
+
+template <class _Tp, class _Hash, bool = std::is_empty<_Hash>::value && !std::__libcpp_is_final<_Hash>::value >
+class __hash_map_hasher : private _Hash {
+public:
+  _LIBCPP_HIDE_FROM_ABI __hash_map_hasher() : _Hash() {}
+  _LIBCPP_HIDE_FROM_ABI __hash_map_hasher(const _Hash& __h) : _Hash(__h) {}
+  _LIBCPP_HIDE_FROM_ABI const _Hash& hash_function() const { return *this; }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _Tp& __x) const { return static_cast<const _Hash&>(*this)(__x.first); }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const typename _Tp::first_type& __x) const {
+    return static_cast<const _Hash&>(*this)(__x);
+  }
+};
+
+template <class _Tp, class _Hash>
+class __hash_map_hasher<_Tp, _Hash, false> {
+  _Hash __hash_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __hash_map_hasher() : __hash_() {}
+  _LIBCPP_HIDE_FROM_ABI __hash_map_hasher(const _Hash& __h) : __hash_(__h) {}
+  _LIBCPP_HIDE_FROM_ABI const _Hash& hash_function() const { return __hash_; }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _Tp& __x) const { return __hash_(__x.first); }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const typename _Tp::first_type& __x) const { return __hash_(__x); }
+};
+
+template <class _Tp, class _Pred, bool = std::is_empty<_Pred>::value && !std::__libcpp_is_final<_Pred>::value >
+class __hash_map_equal : private _Pred {
+public:
+  _LIBCPP_HIDE_FROM_ABI __hash_map_equal() : _Pred() {}
+  _LIBCPP_HIDE_FROM_ABI __hash_map_equal(const _Pred& __p) : _Pred(__p) {}
+  _LIBCPP_HIDE_FROM_ABI const _Pred& key_eq() const { return *this; }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
+    return static_cast<const _Pred&>(*this)(__x.first, __y.first);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const {
+    return static_cast<const _Pred&>(*this)(__x, __y.first);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const {
+    return static_cast<const _Pred&>(*this)(__x.first, __y);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool
+  operator()(const typename _Tp::first_type& __x, const typename _Tp::first_type& __y) const {
+    return static_cast<const _Pred&>(*this)(__x, __y);
+  }
+};
+
+template <class _Tp, class _Pred>
+class __hash_map_equal<_Tp, _Pred, false> {
+  _Pred __pred_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __hash_map_equal() : __pred_() {}
+  _LIBCPP_HIDE_FROM_ABI __hash_map_equal(const _Pred& __p) : __pred_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI const _Pred& key_eq() const { return __pred_; }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const { return __pred_(__x.first, __y.first); }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const {
+    return __pred_(__x, __y.first);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const {
+    return __pred_(__x.first, __y);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool
+  operator()(const typename _Tp::first_type& __x, const typename _Tp::first_type& __y) const {
+    return __pred_(__x, __y);
+  }
+};
+
+template <class _Alloc>
+class __hash_map_node_destructor {
+  typedef _Alloc allocator_type;
+  typedef std::allocator_traits<allocator_type> __alloc_traits;
+  typedef typename __alloc_traits::value_type::__node_value_type value_type;
+
+public:
+  typedef typename __alloc_traits::pointer pointer;
+
+private:
+  typedef typename value_type::first_type first_type;
+  typedef typename value_type::second_type second_type;
+
+  allocator_type& __na_;
+
+public:
+  bool __first_constructed;
+  bool __second_constructed;
+
+  _LIBCPP_HIDE_FROM_ABI __hash_map_node_destructor(__hash_map_node_destructor const&) = default;
+  __hash_map_node_destructor& operator=(const __hash_map_node_destructor&)            = delete;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __hash_map_node_destructor(allocator_type& __na)
+      : __na_(__na), __first_constructed(false), __second_constructed(false) {}
+
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI __hash_map_node_destructor(std::__hash_node_destructor<allocator_type>&& __x)
+      : __na_(__x.__na_), __first_constructed(__x.__value_constructed), __second_constructed(__x.__value_constructed) {
+    __x.__value_constructed = false;
+  }
+#else  // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI __hash_map_node_destructor(const std::__hash_node_destructor<allocator_type>& __x)
+      : __na_(__x.__na_), __first_constructed(__x.__value_constructed), __second_constructed(__x.__value_constructed) {
+    const_cast<bool&>(__x.__value_constructed) = false;
+  }
+#endif // _LIBCPP_CXX03_LANG
+
+  _LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) {
+    if (__second_constructed)
+      __alloc_traits::destroy(__na_, std::addressof(__p->__get_value().second));
+    if (__first_constructed)
+      __alloc_traits::destroy(__na_, std::addressof(__p->__get_value().first));
+    if (__p)
+      __alloc_traits::deallocate(__na_, __p, 1);
+  }
+};
+
+template <class _HashIterator>
+class _LIBCPP_TEMPLATE_VIS __hash_map_iterator {
+  _HashIterator __i_;
+
+  typedef const typename _HashIterator::value_type::first_type key_type;
+  typedef typename _HashIterator::value_type::second_type mapped_type;
+
+public:
+  typedef std::forward_iterator_tag iterator_category;
+  typedef std::pair<key_type, mapped_type> value_type;
+  typedef typename _HashIterator::difference_type difference_type;
+  typedef value_type& reference;
+  typedef std::__rebind_pointer_t<typename _HashIterator::pointer, value_type> pointer;
+
+  _LIBCPP_HIDE_FROM_ABI __hash_map_iterator() {}
+
+  _LIBCPP_HIDE_FROM_ABI __hash_map_iterator(_HashIterator __i) : __i_(__i) {}
+
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return *operator->(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return (pointer)__i_.operator->(); }
+
+  _LIBCPP_HIDE_FROM_ABI __hash_map_iterator& operator++() {
+    ++__i_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __hash_map_iterator operator++(int) {
+    __hash_map_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
+
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y) {
+    return __x.__i_ == __y.__i_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y) {
+    return __x.__i_ != __y.__i_;
+  }
+
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS hash_map;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS hash_multimap;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
+};
+
+template <class _HashIterator>
+class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator {
+  _HashIterator __i_;
+
+  typedef const typename _HashIterator::value_type::first_type key_type;
+  typedef typename _HashIterator::value_type::second_type mapped_type;
+
+public:
+  typedef std::forward_iterator_tag iterator_category;
+  typedef std::pair<key_type, mapped_type> value_type;
+  typedef typename _HashIterator::difference_type difference_type;
+  typedef const value_type& reference;
+  typedef std::__rebind_pointer_t<typename _HashIterator::pointer, const value_type> pointer;
+
+  _LIBCPP_HIDE_FROM_ABI __hash_map_const_iterator() {}
+
+  _LIBCPP_HIDE_FROM_ABI __hash_map_const_iterator(_HashIterator __i) : __i_(__i) {}
+  _LIBCPP_HIDE_FROM_ABI __hash_map_const_iterator(__hash_map_iterator<typename _HashIterator::__non_const_iterator> __i)
+      : __i_(__i.__i_) {}
+
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return *operator->(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return (pointer)__i_.operator->(); }
+
+  _LIBCPP_HIDE_FROM_ABI __hash_map_const_iterator& operator++() {
+    ++__i_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __hash_map_const_iterator operator++(int) {
+    __hash_map_const_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
+
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) {
+    return __x.__i_ == __y.__i_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) {
+    return __x.__i_ != __y.__i_;
+  }
+
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS hash_map;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS hash_multimap;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+};
+
+template <class _Key,
+          class _Tp,
+          class _Hash  = hash<_Key>,
+          class _Pred  = std::equal_to<_Key>,
+          class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+class _LIBCPP_TEMPLATE_VIS hash_map {
+public:
+  // types
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef _Tp data_type;
+  typedef _Hash hasher;
+  typedef _Pred key_equal;
+  typedef _Alloc allocator_type;
+  typedef std::pair<const key_type, mapped_type> value_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+
+private:
+  typedef std::pair<key_type, mapped_type> __value_type;
+  typedef __hash_map_hasher<__value_type, hasher> __hasher;
+  typedef __hash_map_equal<__value_type, key_equal> __key_equal;
+  typedef std::__rebind_alloc<std::allocator_traits<allocator_type>, __value_type> __allocator_type;
+
+  typedef std::__hash_table<__value_type, __hasher, __key_equal, __allocator_type> __table;
+
+  __table __table_;
+
+  typedef typename __table::__node_pointer __node_pointer;
+  typedef typename __table::__node_const_pointer __node_const_pointer;
+  typedef typename __table::__node_traits __node_traits;
+  typedef typename __table::__node_allocator __node_allocator;
+  typedef typename __table::__node __node;
+  typedef __hash_map_node_destructor<__node_allocator> _Dp;
+  typedef std::unique_ptr<__node, _Dp> __node_holder;
+  typedef std::allocator_traits<allocator_type> __alloc_traits;
+
+public:
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
+  typedef typename __alloc_traits::size_type size_type;
+  typedef typename __alloc_traits::difference_type difference_type;
+
+  typedef __hash_map_iterator<typename __table::iterator> iterator;
+  typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
+
+  _LIBCPP_HIDE_FROM_ABI hash_map() {}
+  explicit _LIBCPP_HIDE_FROM_ABI
+  hash_map(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI hash_map(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI hash_map(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  hash_map(_InputIterator __first,
+           _InputIterator __last,
+           size_type __n,
+           const hasher& __hf     = hasher(),
+           const key_equal& __eql = key_equal());
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  hash_map(_InputIterator __first,
+           _InputIterator __last,
+           size_type __n,
+           const hasher& __hf,
+           const key_equal& __eql,
+           const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI hash_map(const hash_map& __u);
+
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const { return allocator_type(__table_.__node_alloc()); }
+
+  _LIBCPP_HIDE_FROM_ABI bool empty() const { return __table_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const { return __table_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const { return __table_.max_size(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator begin() { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const { return __table_.end(); }
+
+  _LIBCPP_HIDE_FROM_ABI std::pair<iterator, bool> insert(const value_type& __x) {
+    return __table_.__insert_unique(__x);
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, const value_type& __x) { return insert(__x).first; }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last);
+
+  _LIBCPP_HIDE_FROM_ABI void erase(const_iterator __p) { __table_.erase(__p.__i_); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __table_.__erase_unique(__k); }
+  _LIBCPP_HIDE_FROM_ABI void erase(const_iterator __first, const_iterator __last) {
+    __table_.erase(__first.__i_, __last.__i_);
+  }
+  _LIBCPP_HIDE_FROM_ABI void clear() { __table_.clear(); }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(hash_map& __u) { __table_.swap(__u.__table_); }
+
+  _LIBCPP_HIDE_FROM_ABI hasher hash_funct() const { return __table_.hash_function().hash_function(); }
+  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq().key_eq(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_unique(__k); }
+  _LIBCPP_HIDE_FROM_ABI std::pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __table_.__equal_range_unique(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI std::pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __table_.__equal_range_unique(__k);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](const key_type& __k);
+
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const { return __table_.bucket_count(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const { return __table_.max_bucket_count(); }
+
+  _LIBCPP_HIDE_FROM_ABI size_type elems_in_bucket(size_type __n) const { return __table_.bucket_size(__n); }
+
+  _LIBCPP_HIDE_FROM_ABI void resize(size_type __n) { __table_.__rehash_unique(__n); }
+
+private:
+  _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node(const key_type& __k);
+};
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_unique(__n);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
+    size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_unique(__n);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(_InputIterator __first, _InputIterator __last) {
+  insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
+    _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_unique(__n);
+  insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
+    _InputIterator __first,
+    _InputIterator __last,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_unique(__n);
+  insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(const hash_map& __u) : __table_(__u.__table_) {
+  __table_.__rehash_unique(__u.bucket_count());
+  insert(__u.begin(), __u.end());
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+typename hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k) {
+  __node_allocator& __na = __table_.__node_alloc();
+  __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
+  __node_traits::construct(__na, std::addressof(__h->__get_value().first), __k);
+  __h.get_deleter().__first_constructed = true;
+  __node_traits::construct(__na, std::addressof(__h->__get_value().second));
+  __h.get_deleter().__second_constructed = true;
+  return __h;
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline void hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last) {
+  for (; __first != __last; ++__first)
+    __table_.__insert_unique(*__first);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+_Tp& hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k) {
+  iterator __i = find(__k);
+  if (__i != end())
+    return __i->second;
+  __node_holder __h             = __construct_node(__k);
+  std::pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
+  __h.release();
+  return __r.first->second;
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) {
+  __x.swap(__y);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+_LIBCPP_HIDE_FROM_ABI bool
+operator==(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) {
+  if (__x.size() != __y.size())
+    return false;
+  typedef typename hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator const_iterator;
+  for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end(); __i != __ex; ++__i) {
+    const_iterator __j = __y.find(__i->first);
+    if (__j == __ey || !(*__i == *__j))
+      return false;
+  }
+  return true;
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, const hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) {
+  return !(__x == __y);
+}
+
+template <class _Key,
+          class _Tp,
+          class _Hash  = hash<_Key>,
+          class _Pred  = std::equal_to<_Key>,
+          class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+class _LIBCPP_TEMPLATE_VIS hash_multimap {
+public:
+  // types
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef _Tp data_type;
+  typedef _Hash hasher;
+  typedef _Pred key_equal;
+  typedef _Alloc allocator_type;
+  typedef std::pair<const key_type, mapped_type> value_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+
+private:
+  typedef std::pair<key_type, mapped_type> __value_type;
+  typedef __hash_map_hasher<__value_type, hasher> __hasher;
+  typedef __hash_map_equal<__value_type, key_equal> __key_equal;
+  typedef std::__rebind_alloc<std::allocator_traits<allocator_type>, __value_type> __allocator_type;
+
+  typedef std::__hash_table<__value_type, __hasher, __key_equal, __allocator_type> __table;
+
+  __table __table_;
+
+  typedef typename __table::__node_traits __node_traits;
+  typedef typename __table::__node_allocator __node_allocator;
+  typedef typename __table::__node __node;
+  typedef __hash_map_node_destructor<__node_allocator> _Dp;
+  typedef std::unique_ptr<__node, _Dp> __node_holder;
+  typedef std::allocator_traits<allocator_type> __alloc_traits;
+
+public:
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
+  typedef typename __alloc_traits::size_type size_type;
+  typedef typename __alloc_traits::difference_type difference_type;
+
+  typedef __hash_map_iterator<typename __table::iterator> iterator;
+  typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
+
+  _LIBCPP_HIDE_FROM_ABI hash_multimap() {}
+  explicit _LIBCPP_HIDE_FROM_ABI
+  hash_multimap(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI
+  hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI hash_multimap(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  hash_multimap(_InputIterator __first,
+                _InputIterator __last,
+                size_type __n,
+                const hasher& __hf     = hasher(),
+                const key_equal& __eql = key_equal());
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI hash_multimap(
+      _InputIterator __first,
+      _InputIterator __last,
+      size_type __n,
+      const hasher& __hf,
+      const key_equal& __eql,
+      const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI hash_multimap(const hash_multimap& __u);
+
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const { return allocator_type(__table_.__node_alloc()); }
+
+  _LIBCPP_HIDE_FROM_ABI bool empty() const { return __table_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const { return __table_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const { return __table_.max_size(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator begin() { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const { return __table_.end(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return __table_.__insert_multi(__x); }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, const value_type& __x) { return insert(__x); }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last);
+
+  _LIBCPP_HIDE_FROM_ABI void erase(const_iterator __p) { __table_.erase(__p.__i_); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __table_.__erase_multi(__k); }
+  _LIBCPP_HIDE_FROM_ABI void erase(const_iterator __first, const_iterator __last) {
+    __table_.erase(__first.__i_, __last.__i_);
+  }
+  _LIBCPP_HIDE_FROM_ABI void clear() { __table_.clear(); }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(hash_multimap& __u) { __table_.swap(__u.__table_); }
+
+  _LIBCPP_HIDE_FROM_ABI hasher hash_funct() const { return __table_.hash_function().hash_function(); }
+  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq().key_eq(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_multi(__k); }
+  _LIBCPP_HIDE_FROM_ABI std::pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __table_.__equal_range_multi(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI std::pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __table_.__equal_range_multi(__k);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const { return __table_.bucket_count(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const { return __table_.max_bucket_count(); }
+
+  _LIBCPP_HIDE_FROM_ABI size_type elems_in_bucket(size_type __n) const { return __table_.bucket_size(__n); }
+
+  _LIBCPP_HIDE_FROM_ABI void resize(size_type __n) { __table_.__rehash_multi(__n); }
+};
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_multi(__n);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
+    size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_multi(__n);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(_InputIterator __first, _InputIterator __last) {
+  insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
+    _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_multi(__n);
+  insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
+    _InputIterator __first,
+    _InputIterator __last,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_multi(__n);
+  insert(__first, __last);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(const hash_multimap& __u) : __table_(__u.__table_) {
+  __table_.__rehash_multi(__u.bucket_count());
+  insert(__u.begin(), __u.end());
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline void hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last) {
+  for (; __first != __last; ++__first)
+    __table_.__insert_multi(*__first);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) {
+  __x.swap(__y);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+_LIBCPP_HIDE_FROM_ABI bool operator==(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+                                      const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) {
+  if (__x.size() != __y.size())
+    return false;
+  typedef typename hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator const_iterator;
+  typedef std::pair<const_iterator, const_iterator> _EqRng;
+  for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;) {
+    _EqRng __xeq = __x.equal_range(__i->first);
+    _EqRng __yeq = __y.equal_range(__i->first);
+    if (std::distance(__xeq.first, __xeq.second) != std::distance(__yeq.first, __yeq.second) ||
+        !std::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+      return false;
+    __i = __xeq.second;
+  }
+  return true;
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+                                             const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) {
+  return !(__x == __y);
+}
+
+} // namespace __gnu_cxx
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <concepts>
+#  include <iterator>
+#  include <type_traits>
+#endif
+
+#endif // _LIBCPP_HASH_MAP
diff --git a/third_party/libcxx/ext/hash_set b/third_party/libcxx/ext/hash_set
new file mode 100644
index 000000000..1ab259b59
--- /dev/null
+++ b/third_party/libcxx/ext/hash_set
@@ -0,0 +1,584 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_HASH_SET
+#define _LIBCPP_HASH_SET
+
+/*
+
+    hash_set synopsis
+
+namespace __gnu_cxx
+{
+
+template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+          class Alloc = allocator<Value>>
+class hash_set
+{
+public:
+    // types
+    typedef Value                                                      key_type;
+    typedef key_type                                                   value_type;
+    typedef Hash                                                       hasher;
+    typedef Pred                                                       key_equal;
+    typedef Alloc                                                      allocator_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    typedef typename allocator_traits<allocator_type>::pointer         pointer;
+    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
+    typedef typename allocator_traits<allocator_type>::size_type       size_type;
+    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+
+    typedef /unspecified/ iterator;
+    typedef /unspecified/ const_iterator;
+
+    explicit hash_set(size_type n = 193, const hasher& hf = hasher(),
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& a = allocator_type());
+    template <class InputIterator>
+        hash_set(InputIterator f, InputIterator l,
+                      size_type n = 193, const hasher& hf = hasher(),
+                      const key_equal& eql = key_equal(),
+                      const allocator_type& a = allocator_type());
+    hash_set(const hash_set&);
+    ~hash_set();
+    hash_set& operator=(const hash_set&);
+
+    allocator_type get_allocator() const;
+
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;
+
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+
+    pair<iterator, bool> insert(const value_type& obj);
+    template <class InputIterator>
+        void insert(InputIterator first, InputIterator last);
+
+    void erase(const_iterator position);
+    size_type erase(const key_type& k);
+    void erase(const_iterator first, const_iterator last);
+    void clear();
+
+    void swap(hash_set&);
+
+    hasher hash_funct() const;
+    key_equal key_eq() const;
+
+    iterator       find(const key_type& k);
+    const_iterator find(const key_type& k) const;
+    size_type count(const key_type& k) const;
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;
+
+    size_type elems_in_bucket(size_type n) const;
+
+    void resize(size_type n);
+};
+
+template <class Value, class Hash, class Pred, class Alloc>
+    void swap(hash_set<Value, Hash, Pred, Alloc>& x,
+              hash_set<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator==(const hash_set<Value, Hash, Pred, Alloc>& x,
+               const hash_set<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator!=(const hash_set<Value, Hash, Pred, Alloc>& x,
+               const hash_set<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
+          class Alloc = allocator<Value>>
+class hash_multiset
+{
+public:
+    // types
+    typedef Value                                                      key_type;
+    typedef key_type                                                   value_type;
+    typedef Hash                                                       hasher;
+    typedef Pred                                                       key_equal;
+    typedef Alloc                                                      allocator_type;
+    typedef value_type&                                                reference;
+    typedef const value_type&                                          const_reference;
+    typedef typename allocator_traits<allocator_type>::pointer         pointer;
+    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
+    typedef typename allocator_traits<allocator_type>::size_type       size_type;
+    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
+
+    typedef /unspecified/ iterator;
+    typedef /unspecified/ const_iterator;
+
+    explicit hash_multiset(size_type n = 193, const hasher& hf = hasher(),
+                           const key_equal& eql = key_equal(),
+                           const allocator_type& a = allocator_type());
+    template <class InputIterator>
+        hash_multiset(InputIterator f, InputIterator l,
+                      size_type n = 193, const hasher& hf = hasher(),
+                      const key_equal& eql = key_equal(),
+                      const allocator_type& a = allocator_type());
+    hash_multiset(const hash_multiset&);
+    ~hash_multiset();
+    hash_multiset& operator=(const hash_multiset&);
+
+    allocator_type get_allocator() const;
+
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;
+
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+
+    iterator insert(const value_type& obj);
+    template <class InputIterator>
+        void insert(InputIterator first, InputIterator last);
+
+    void erase(const_iterator position);
+    size_type erase(const key_type& k);
+    void erase(const_iterator first, const_iterator last);
+    void clear();
+
+    void swap(hash_multiset&);
+
+    hasher hash_funct() const;
+    key_equal key_eq() const;
+
+    iterator       find(const key_type& k);
+    const_iterator find(const key_type& k) const;
+    size_type count(const key_type& k) const;
+    pair<iterator, iterator>             equal_range(const key_type& k);
+    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
+
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;
+
+    size_type elems_in_bucket(size_type n) const;
+
+    void resize(size_type n);
+};
+
+template <class Value, class Hash, class Pred, class Alloc>
+    void swap(hash_multiset<Value, Hash, Pred, Alloc>& x,
+              hash_multiset<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator==(const hash_multiset<Value, Hash, Pred, Alloc>& x,
+               const hash_multiset<Value, Hash, Pred, Alloc>& y);
+
+template <class Value, class Hash, class Pred, class Alloc>
+    bool
+    operator!=(const hash_multiset<Value, Hash, Pred, Alloc>& x,
+               const hash_multiset<Value, Hash, Pred, Alloc>& y);
+}  // __gnu_cxx
+
+*/
+
+#include <__config>
+#include <__hash_table>
+#include <algorithm>
+#include <ext/__hash>
+#include <functional>
+
+#if defined(__DEPRECATED) && __DEPRECATED
+#  if defined(_LIBCPP_WARNING)
+_LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>")
+#  else
+#    warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>
+#  endif
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+namespace __gnu_cxx {
+
+template <class _Value,
+          class _Hash  = hash<_Value>,
+          class _Pred  = std::equal_to<_Value>,
+          class _Alloc = std::allocator<_Value> >
+class _LIBCPP_TEMPLATE_VIS hash_set {
+public:
+  // types
+  typedef _Value key_type;
+  typedef key_type value_type;
+  typedef _Hash hasher;
+  typedef _Pred key_equal;
+  typedef _Alloc allocator_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+
+private:
+  typedef std::__hash_table<value_type, hasher, key_equal, allocator_type> __table;
+
+  __table __table_;
+
+public:
+  typedef typename __table::pointer pointer;
+  typedef typename __table::const_pointer const_pointer;
+  typedef typename __table::size_type size_type;
+  typedef typename __table::difference_type difference_type;
+
+  typedef typename __table::const_iterator iterator;
+  typedef typename __table::const_iterator const_iterator;
+
+  _LIBCPP_HIDE_FROM_ABI hash_set() {}
+  _LIBCPP_HIDE_FROM_ABI explicit hash_set(
+      size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI hash_set(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI hash_set(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  hash_set(_InputIterator __first,
+           _InputIterator __last,
+           size_type __n,
+           const hasher& __hf     = hasher(),
+           const key_equal& __eql = key_equal());
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  hash_set(_InputIterator __first,
+           _InputIterator __last,
+           size_type __n,
+           const hasher& __hf,
+           const key_equal& __eql,
+           const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI hash_set(const hash_set& __u);
+
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const { return allocator_type(__table_.__node_alloc()); }
+
+  _LIBCPP_HIDE_FROM_ABI bool empty() const { return __table_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const { return __table_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const { return __table_.max_size(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator begin() { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const { return __table_.end(); }
+
+  _LIBCPP_HIDE_FROM_ABI std::pair<iterator, bool> insert(const value_type& __x) {
+    return __table_.__insert_unique(__x);
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, const value_type& __x) { return insert(__x).first; }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last);
+
+  _LIBCPP_HIDE_FROM_ABI void erase(const_iterator __p) { __table_.erase(__p); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __table_.__erase_unique(__k); }
+  _LIBCPP_HIDE_FROM_ABI void erase(const_iterator __first, const_iterator __last) { __table_.erase(__first, __last); }
+  _LIBCPP_HIDE_FROM_ABI void clear() { __table_.clear(); }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(hash_set& __u) { __table_.swap(__u.__table_); }
+
+  _LIBCPP_HIDE_FROM_ABI hasher hash_funct() const { return __table_.hash_function(); }
+  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_unique(__k); }
+  _LIBCPP_HIDE_FROM_ABI std::pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __table_.__equal_range_unique(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI std::pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __table_.__equal_range_unique(__k);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const { return __table_.bucket_count(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const { return __table_.max_bucket_count(); }
+
+  _LIBCPP_HIDE_FROM_ABI size_type elems_in_bucket(size_type __n) const { return __table_.bucket_size(__n); }
+
+  _LIBCPP_HIDE_FROM_ABI void resize(size_type __n) { __table_.__rehash_unique(__n); }
+};
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_unique(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
+    size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_unique(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(_InputIterator __first, _InputIterator __last) {
+  insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
+    _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_unique(__n);
+  insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
+    _InputIterator __first,
+    _InputIterator __last,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_unique(__n);
+  insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(const hash_set& __u) : __table_(__u.__table_) {
+  __table_.__rehash_unique(__u.bucket_count());
+  insert(__u.begin(), __u.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline void hash_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last) {
+  for (; __first != __last; ++__first)
+    __table_.__insert_unique(*__first);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(hash_set<_Value, _Hash, _Pred, _Alloc>& __x, hash_set<_Value, _Hash, _Pred, _Alloc>& __y) {
+  __x.swap(__y);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+_LIBCPP_HIDE_FROM_ABI bool
+operator==(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x, const hash_set<_Value, _Hash, _Pred, _Alloc>& __y) {
+  if (__x.size() != __y.size())
+    return false;
+  typedef typename hash_set<_Value, _Hash, _Pred, _Alloc>::const_iterator const_iterator;
+  for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end(); __i != __ex; ++__i) {
+    const_iterator __j = __y.find(*__i);
+    if (__j == __ey || !(*__i == *__j))
+      return false;
+  }
+  return true;
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const hash_set<_Value, _Hash, _Pred, _Alloc>& __x, const hash_set<_Value, _Hash, _Pred, _Alloc>& __y) {
+  return !(__x == __y);
+}
+
+template <class _Value,
+          class _Hash  = hash<_Value>,
+          class _Pred  = std::equal_to<_Value>,
+          class _Alloc = std::allocator<_Value> >
+class _LIBCPP_TEMPLATE_VIS hash_multiset {
+public:
+  // types
+  typedef _Value key_type;
+  typedef key_type value_type;
+  typedef _Hash hasher;
+  typedef _Pred key_equal;
+  typedef _Alloc allocator_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+
+private:
+  typedef std::__hash_table<value_type, hasher, key_equal, allocator_type> __table;
+
+  __table __table_;
+
+public:
+  typedef typename __table::pointer pointer;
+  typedef typename __table::const_pointer const_pointer;
+  typedef typename __table::size_type size_type;
+  typedef typename __table::difference_type difference_type;
+
+  typedef typename __table::const_iterator iterator;
+  typedef typename __table::const_iterator const_iterator;
+
+  _LIBCPP_HIDE_FROM_ABI hash_multiset() {}
+  explicit _LIBCPP_HIDE_FROM_ABI
+  hash_multiset(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI
+  hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI hash_multiset(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  hash_multiset(_InputIterator __first,
+                _InputIterator __last,
+                size_type __n,
+                const hasher& __hf     = hasher(),
+                const key_equal& __eql = key_equal());
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI hash_multiset(
+      _InputIterator __first,
+      _InputIterator __last,
+      size_type __n,
+      const hasher& __hf,
+      const key_equal& __eql,
+      const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI hash_multiset(const hash_multiset& __u);
+
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const { return allocator_type(__table_.__node_alloc()); }
+
+  _LIBCPP_HIDE_FROM_ABI bool empty() const { return __table_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const { return __table_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const { return __table_.max_size(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator begin() { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const { return __table_.end(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return __table_.__insert_multi(__x); }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, const value_type& __x) { return insert(__x); }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last);
+
+  _LIBCPP_HIDE_FROM_ABI void erase(const_iterator __p) { __table_.erase(__p); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __table_.__erase_multi(__k); }
+  _LIBCPP_HIDE_FROM_ABI void erase(const_iterator __first, const_iterator __last) { __table_.erase(__first, __last); }
+  _LIBCPP_HIDE_FROM_ABI void clear() { __table_.clear(); }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(hash_multiset& __u) { __table_.swap(__u.__table_); }
+
+  _LIBCPP_HIDE_FROM_ABI hasher hash_funct() const { return __table_.hash_function(); }
+  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_multi(__k); }
+  _LIBCPP_HIDE_FROM_ABI std::pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __table_.__equal_range_multi(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI std::pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __table_.__equal_range_multi(__k);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const { return __table_.bucket_count(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const { return __table_.max_bucket_count(); }
+
+  _LIBCPP_HIDE_FROM_ABI size_type elems_in_bucket(size_type __n) const { return __table_.bucket_size(__n); }
+
+  _LIBCPP_HIDE_FROM_ABI void resize(size_type __n) { __table_.__rehash_multi(__n); }
+};
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_multi(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
+    size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_multi(__n);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(_InputIterator __first, _InputIterator __last) {
+  insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
+    _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_multi(__n);
+  insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
+    _InputIterator __first,
+    _InputIterator __last,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_multi(__n);
+  insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(const hash_multiset& __u) : __table_(__u.__table_) {
+  __table_.__rehash_multi(__u.bucket_count());
+  insert(__u.begin(), __u.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline void hash_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last) {
+  for (; __first != __last; ++__first)
+    __table_.__insert_multi(*__first);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x, hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y) {
+  __x.swap(__y);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+_LIBCPP_HIDE_FROM_ABI bool operator==(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+                                      const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y) {
+  if (__x.size() != __y.size())
+    return false;
+  typedef typename hash_multiset<_Value, _Hash, _Pred, _Alloc>::const_iterator const_iterator;
+  typedef std::pair<const_iterator, const_iterator> _EqRng;
+  for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;) {
+    _EqRng __xeq = __x.equal_range(*__i);
+    _EqRng __yeq = __y.equal_range(*__i);
+    if (std::distance(__xeq.first, __xeq.second) != std::distance(__yeq.first, __yeq.second) ||
+        !std::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+      return false;
+    __i = __xeq.second;
+  }
+  return true;
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+                                             const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y) {
+  return !(__x == __y);
+}
+
+} // namespace __gnu_cxx
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <concepts>
+#  include <iterator>
+#  include <type_traits>
+#endif
+
+#endif // _LIBCPP_HASH_SET
diff --git a/third_party/libcxx/fenv.h b/third_party/libcxx/fenv.h
index 15e41568c..5647f2b33 100644
--- a/third_party/libcxx/fenv.h
+++ b/third_party/libcxx/fenv.h
@@ -10,7 +10,6 @@
 #ifndef _LIBCPP_FENV_H
 #define _LIBCPP_FENV_H
 
-
 /*
     fenv.h synopsis
 
@@ -64,52 +63,49 @@ int feupdateenv(const fenv_t* envp);
 
 extern "C++" {
 
-#ifdef feclearexcept
-#undef feclearexcept
-#endif
+#  ifdef feclearexcept
+#    undef feclearexcept
+#  endif
 
-#ifdef fegetexceptflag
-#undef fegetexceptflag
-#endif
+#  ifdef fegetexceptflag
+#    undef fegetexceptflag
+#  endif
 
+#  ifdef feraiseexcept
+#    undef feraiseexcept
+#  endif
 
-#ifdef feraiseexcept
-#undef feraiseexcept
-#endif
+#  ifdef fesetexceptflag
+#    undef fesetexceptflag
+#  endif
 
-#ifdef fesetexceptflag
-#undef fesetexceptflag
-#endif
+#  ifdef fetestexcept
+#    undef fetestexcept
+#  endif
 
+#  ifdef fegetround
+#    undef fegetround
+#  endif
 
-#ifdef fetestexcept
-#undef fetestexcept
-#endif
+#  ifdef fesetround
+#    undef fesetround
+#  endif
 
-#ifdef fegetround
-#undef fegetround
-#endif
+#  ifdef fegetenv
+#    undef fegetenv
+#  endif
 
-#ifdef fesetround
-#undef fesetround
-#endif
+#  ifdef feholdexcept
+#    undef feholdexcept
+#  endif
 
-#ifdef fegetenv
-#undef fegetenv
-#endif
+#  ifdef fesetenv
+#    undef fesetenv
+#  endif
 
-#ifdef feholdexcept
-#undef feholdexcept
-#endif
-
-
-#ifdef fesetenv
-#undef fesetenv
-#endif
-
-#ifdef feupdateenv
-#undef feupdateenv
-#endif
+#  ifdef feupdateenv
+#    undef feupdateenv
+#  endif
 
 } // extern "C++"
 
diff --git a/third_party/libcxx/filesystem b/third_party/libcxx/filesystem
index b10555d1c..6ea04df0a 100644
--- a/third_party/libcxx/filesystem
+++ b/third_party/libcxx/filesystem
@@ -236,19 +236,120 @@
       friend class directory_iterator;    // exposition only
     };
 
-    class directory_iterator;
+  class directory_iterator {
+  public:
+    using iterator_category = input_iterator_tag;
+    using value_type        = directory_entry;
+    using difference_type   = ptrdiff_t;
+    using pointer           = const directory_entry*;
+    using reference         = const directory_entry&;
+
+    // [fs.dir.itr.members], member functions
+    directory_iterator() noexcept;
+    explicit directory_iterator(const path& p);
+    directory_iterator(const path& p, directory_options options);
+    directory_iterator(const path& p, error_code& ec);
+    directory_iterator(const path& p, directory_options options,
+                       error_code& ec);
+    directory_iterator(const directory_iterator& rhs);
+    directory_iterator(directory_iterator&& rhs) noexcept;
+    ~directory_iterator();
+
+    directory_iterator& operator=(const directory_iterator& rhs);
+    directory_iterator& operator=(directory_iterator&& rhs) noexcept;
+
+    const directory_entry& operator*() const;
+    const directory_entry* operator->() const;
+    directory_iterator&    operator++();
+    directory_iterator&    increment(error_code& ec);
+
+    bool operator==(default_sentinel_t) const noexcept {          // since C++20
+      return *this == directory_iterator();
+    }
+
+    // other members as required by [input.iterators], input iterators
+  };
 
     // enable directory_iterator range-based for statements
     directory_iterator begin(directory_iterator iter) noexcept;
     directory_iterator end(directory_iterator) noexcept;
 
-    class recursive_directory_iterator;
+class recursive_directory_iterator {
+  public:
+    using iterator_category = input_iterator_tag;
+    using value_type        = directory_entry;
+    using difference_type   = ptrdiff_t;
+    using pointer           = const directory_entry*;
+    using reference         = const directory_entry&;
+
+    // [fs.rec.dir.itr.members], constructors and destructor
+    recursive_directory_iterator() noexcept;
+    explicit recursive_directory_iterator(const path& p);
+    recursive_directory_iterator(const path& p, directory_options options);
+    recursive_directory_iterator(const path& p, directory_options options,
+                                 error_code& ec);
+    recursive_directory_iterator(const path& p, error_code& ec);
+    recursive_directory_iterator(const recursive_directory_iterator& rhs);
+    recursive_directory_iterator(recursive_directory_iterator&& rhs) noexcept;
+    ~recursive_directory_iterator();
+
+    // [fs.rec.dir.itr.members], observers
+    directory_options  options() const;
+    int                depth() const;
+    bool               recursion_pending() const;
+
+    const directory_entry& operator*() const;
+    const directory_entry* operator->() const;
+
+    // [fs.rec.dir.itr.members], modifiers
+    recursive_directory_iterator&
+      operator=(const recursive_directory_iterator& rhs);
+    recursive_directory_iterator&
+      operator=(recursive_directory_iterator&& rhs) noexcept;
+
+    recursive_directory_iterator& operator++();
+    recursive_directory_iterator& increment(error_code& ec);
+
+    void pop();
+    void pop(error_code& ec);
+    void disable_recursion_pending();
+
+    bool operator==(default_sentinel_t) const noexcept {          // since C++20
+      return *this == recursive_directory_iterator();
+    }
+
+    // other members as required by [input.iterators], input iterators
+  };
 
     // enable recursive_directory_iterator range-based for statements
     recursive_directory_iterator begin(recursive_directory_iterator iter) noexcept;
     recursive_directory_iterator end(recursive_directory_iterator) noexcept;
 
-    class file_status;
+  class file_status {
+  public:
+    // [fs.file.status.cons], constructors and destructor
+    file_status() noexcept : file_status(file_type::none) {}
+    explicit file_status(file_type ft,
+                         perms prms = perms::unknown) noexcept;
+    file_status(const file_status&) noexcept = default;
+    file_status(file_status&&) noexcept = default;
+    ~file_status();
+
+    // assignments
+    file_status& operator=(const file_status&) noexcept = default;
+    file_status& operator=(file_status&&) noexcept = default;
+
+    // [fs.file.status.mods], modifiers
+    void       type(file_type ft) noexcept;
+    void       permissions(perms prms) noexcept;
+
+    // [fs.file.status.obs], observers
+    file_type  type() const noexcept;
+    perms      permissions() const noexcept;
+
+    friend bool operator==(const file_status& lhs, const file_status& rhs) noexcept
+      { return lhs.type() == rhs.type() && lhs.permissions() == rhs.permissions(); } // C++20
+  };
 
     struct space_info
     {
@@ -432,24 +533,27 @@ inline constexpr bool std::ranges::enable_view<std::filesystem::recursive_direct
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__filesystem/copy_options.h>
-#include <__filesystem/directory_entry.h>
-#include <__filesystem/directory_iterator.h>
-#include <__filesystem/directory_options.h>
-#include <__filesystem/file_status.h>
-#include <__filesystem/file_time_type.h>
-#include <__filesystem/file_type.h>
-#include <__filesystem/filesystem_error.h>
-#include <__filesystem/operations.h>
-#include <__filesystem/path.h>
-#include <__filesystem/path_iterator.h>
-#include <__filesystem/perm_options.h>
-#include <__filesystem/perms.h>
-#include <__filesystem/recursive_directory_iterator.h>
-#include <__filesystem/space_info.h>
-#include <__filesystem/u8path.h>
+
+#if _LIBCPP_STD_VER >= 17
+#  include <__filesystem/copy_options.h>
+#  include <__filesystem/directory_entry.h>
+#  include <__filesystem/directory_iterator.h>
+#  include <__filesystem/directory_options.h>
+#  include <__filesystem/file_status.h>
+#  include <__filesystem/file_time_type.h>
+#  include <__filesystem/file_type.h>
+#  include <__filesystem/filesystem_error.h>
+#  include <__filesystem/operations.h>
+#  include <__filesystem/path.h>
+#  include <__filesystem/path_iterator.h>
+#  include <__filesystem/perm_options.h>
+#  include <__filesystem/perms.h>
+#  include <__filesystem/recursive_directory_iterator.h>
+#  include <__filesystem/space_info.h>
+#  include <__filesystem/u8path.h>
+#endif
+
 #include <version>
 
 // standard-mandated includes
@@ -457,10 +561,6 @@ inline constexpr bool std::ranges::enable_view<std::filesystem::recursive_direct
 // [fs.filesystem.syn]
 #include <compare>
 
-#if defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-# error "The <filesystem> library is not supported since libc++ has been configured without support for a filesystem."
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
@@ -468,6 +568,9 @@ inline constexpr bool std::ranges::enable_view<std::filesystem::recursive_direct
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstdlib>
+#  include <cstring>
+#  include <iosfwd>
+#  include <new>
 #  include <system_error>
 #endif
 
diff --git a/third_party/libcxx/float.h b/third_party/libcxx/float.h
index 9e5f711fa..d572866c1 100644
--- a/third_party/libcxx/float.h
+++ b/third_party/libcxx/float.h
@@ -82,13 +82,13 @@ Macros:
 
 #ifdef __cplusplus
 
-#ifndef FLT_EVAL_METHOD
-#define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
-#endif
+#  ifndef FLT_EVAL_METHOD
+#    define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
+#  endif
 
-#ifndef DECIMAL_DIG
-#define DECIMAL_DIG __DECIMAL_DIG__
-#endif
+#  ifndef DECIMAL_DIG
+#    define DECIMAL_DIG __DECIMAL_DIG__
+#  endif
 
 #endif // __cplusplus
 
diff --git a/third_party/libcxx/format b/third_party/libcxx/format
index c48bcf6e8..c3f2b45f0 100644
--- a/third_party/libcxx/format
+++ b/third_party/libcxx/format
@@ -31,6 +31,7 @@ namespace std {
 
     public:
       template<class T> consteval basic_format_string(const T& s);
+      basic_format_string(runtime-format-string<charT> s) noexcept : str(s.str) {}   // since C++26
 
       constexpr basic_string_view<charT> get() const noexcept { return str; }
     };
@@ -41,6 +42,24 @@ namespace std {
     using wformat_string =                                      // since C++23, exposition only before C++23
       basic_format_string<wchar_t, type_identity_t<Args>...>;
 
+  template<class charT> struct runtime-format-string {          // since C++26, exposition-only
+  private:
+    basic_string_view<charT> str;                               // exposition-only
+
+  public:
+    runtime-format-string(basic_string_view<charT> s) noexcept : str(s) {}
+
+    runtime-format-string(const runtime-format-string&) = delete;
+    runtime-format-string& operator=(const runtime-format-string&) = delete;
+  };
+
+  runtime-format-string<char> runtime_format(string_view fmt) noexcept {
+    return fmt;
+  }
+  runtime-format-string<wchar_t> runtime_format(wstring_view fmt) noexcept {
+    return fmt;
+  }
+
   // [format.functions], formatting functions
   template<class... Args>
     string format(format-string<Args...> fmt, Args&&... args);
@@ -151,17 +170,17 @@ namespace std {
   template<class Context> class basic_format_arg;
 
   template<class Visitor, class Context>
-    see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
+    see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg); // Deprecated in C++26
 
   // [format.arg.store], class template format-arg-store
   template<class Context, class... Args> struct format-arg-store;      // exposition only
 
   template<class Context = format_context, class... Args>
     format-arg-store<Context, Args...>
-      make_format_args(Args&&... args);
+      make_format_args(Args&... args);
   template<class... Args>
     format-arg-store<wformat_context, Args...>
-      make_wformat_args(Args&&... args);
+      make_wformat_args(Args&... args);
 
   // [format.error], class format_error
   class format_error;
@@ -169,38 +188,70 @@ namespace std {
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__format/buffer.h>
-#include <__format/concepts.h>
-#include <__format/container_adaptor.h>
-#include <__format/enable_insertable.h>
-#include <__format/format_arg.h>
-#include <__format/format_arg_store.h>
-#include <__format/format_args.h>
-#include <__format/format_context.h>
-#include <__format/format_error.h>
-#include <__format/format_functions.h>
-#include <__format/format_fwd.h>
-#include <__format/format_parse_context.h>
-#include <__format/format_string.h>
-#include <__format/format_to_n_result.h>
-#include <__format/formatter.h>
-#include <__format/formatter_bool.h>
-#include <__format/formatter_char.h>
-#include <__format/formatter_floating_point.h>
-#include <__format/formatter_integer.h>
-#include <__format/formatter_pointer.h>
-#include <__format/formatter_string.h>
-#include <__format/formatter_tuple.h>
-#include <__format/parser_std_format_spec.h>
-#include <__format/range_default_formatter.h>
-#include <__format/range_formatter.h>
-#include <__format/unicode.h>
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__format/buffer.h>
+#  include <__format/concepts.h>
+#  include <__format/container_adaptor.h>
+#  include <__format/enable_insertable.h>
+#  include <__format/escaped_output_table.h>
+#  include <__format/extended_grapheme_cluster_table.h>
+#  include <__format/format_arg.h>
+#  include <__format/format_arg_store.h>
+#  include <__format/format_args.h>
+#  include <__format/format_context.h>
+#  include <__format/format_error.h>
+#  include <__format/format_functions.h>
+#  include <__format/format_parse_context.h>
+#  include <__format/format_string.h>
+#  include <__format/format_to_n_result.h>
+#  include <__format/formatter.h>
+#  include <__format/formatter_bool.h>
+#  include <__format/formatter_char.h>
+#  include <__format/formatter_floating_point.h>
+#  include <__format/formatter_integer.h>
+#  include <__format/formatter_pointer.h>
+#  include <__format/formatter_string.h>
+#  include <__format/formatter_tuple.h>
+#  include <__format/parser_std_format_spec.h>
+#  include <__format/range_default_formatter.h>
+#  include <__format/range_formatter.h>
+#  include <__format/unicode.h>
+#  include <__fwd/format.h>
+#endif
+
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <array>
+#  include <cctype>
+#  include <cerrno>
+#  include <clocale>
+#  include <cmath>
+#  include <cstddef>
+#  include <cstdint>
+#  include <cstdlib>
+#  include <cstring>
+#  include <cwchar>
+#  include <initializer_list>
+#  include <limits>
+#  include <new>
+#  include <optional>
+#  include <stdexcept>
+#  include <string>
+#  include <string_view>
+#  include <tuple>
+#endif
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <locale>
+#  include <queue>
+#  include <stack>
+#endif
+
 #endif // _LIBCPP_FORMAT
diff --git a/third_party/libcxx/forward_list b/third_party/libcxx/forward_list
index 5625a0b9b..b14d2cb6c 100644
--- a/third_party/libcxx/forward_list
+++ b/third_party/libcxx/forward_list
@@ -44,6 +44,8 @@ public:
         forward_list(InputIterator first, InputIterator last);
     template <class InputIterator>
         forward_list(InputIterator first, InputIterator last, const allocator_type& a);
+    template<container-compatible-range<T> R>
+        forward_list(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
     forward_list(const forward_list& x);
     forward_list(const forward_list& x, const allocator_type& a);
     forward_list(forward_list&& x)
@@ -63,6 +65,8 @@ public:
 
     template <class InputIterator>
         void assign(InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      void assign_range(R&& rg); // C++23
     void assign(size_type n, const value_type& v);
     void assign(initializer_list<value_type> il);
 
@@ -89,6 +93,8 @@ public:
     template <class... Args> reference emplace_front(Args&&... args);  // reference in C++17
     void push_front(const value_type& v);
     void push_front(value_type&& v);
+    template<container-compatible-range<T> R>
+      void prepend_range(R&& rg); // C++23
 
     void pop_front();
 
@@ -100,6 +106,8 @@ public:
     template <class InputIterator>
         iterator insert_after(const_iterator p,
                               InputIterator first, InputIterator last);
+    template<container-compatible-range<T> R>
+      iterator insert_range_after(const_iterator position, R&& rg); // C++23
     iterator insert_after(const_iterator p, initializer_list<value_type> il);
 
     iterator erase_after(const_iterator p);
@@ -140,6 +148,10 @@ template <class InputIterator, class Allocator = allocator<typename iterator_tra
     forward_list(InputIterator, InputIterator, Allocator = Allocator())
     -> forward_list<typename iterator_traits<InputIterator>::value_type, Allocator>;  // C++17
 
+template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+  forward_list(from_range_t, R&&, Allocator = Allocator())
+      -> forward_list<ranges::range_value_t<R>, Allocator>; // C++23
+
 template <class T, class Allocator>
     bool operator==(const forward_list<T, Allocator>& x,
                     const forward_list<T, Allocator>& y);
@@ -187,33 +199,37 @@ template <class T, class Allocator, class Predicate>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/min.h>
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/move_iterator.h>
 #include <__iterator/next.h>
 #include <__memory/addressof.h>
+#include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
-#include <__memory/allocator_destructor.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
+#include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
-#include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_const.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_same.h>
+#include <__type_traits/is_swappable.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <limits>
+#include <new> // __launder
 #include <version>
 
 // standard-mandated includes
@@ -236,12 +252,12 @@ template <class T, class Allocator, class Predicate>
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _VoidPtr> struct __forward_list_node;
-template <class _NodePtr> struct __forward_begin_node;
-
+template <class _Tp, class _VoidPtr>
+struct __forward_list_node;
+template <class _NodePtr>
+struct __forward_begin_node;
 
 template <class>
 struct __forward_list_node_value_type;
@@ -253,944 +269,820 @@ struct __forward_list_node_value_type<__forward_list_node<_Tp, _VoidPtr> > {
 
 template <class _NodePtr>
 struct __forward_node_traits {
-
-  typedef __remove_cv_t<
-        typename pointer_traits<_NodePtr>::element_type>        __node;
-  typedef typename __forward_list_node_value_type<__node>::type __node_value_type;
-  typedef _NodePtr                                              __node_pointer;
-  typedef __forward_begin_node<_NodePtr>                        __begin_node;
-  typedef __rebind_pointer_t<_NodePtr, __begin_node>            __begin_node_pointer;
-  typedef __rebind_pointer_t<_NodePtr, void>                    __void_pointer;
+  typedef __remove_cv_t<typename pointer_traits<_NodePtr>::element_type> __node_type;
+  typedef typename __forward_list_node_value_type<__node_type>::type __node_value_type;
+  typedef _NodePtr __node_pointer;
+  typedef __forward_begin_node<_NodePtr> __begin_node;
+  typedef __rebind_pointer_t<_NodePtr, __begin_node> __begin_node_pointer;
+  typedef __rebind_pointer_t<_NodePtr, void> __void_pointer;
 
 #if defined(_LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB)
   typedef __begin_node_pointer __iter_node_pointer;
 #else
-  typedef __conditional_t<is_pointer<__void_pointer>::value, __begin_node_pointer, __node_pointer>
-      __iter_node_pointer;
+  typedef __conditional_t<is_pointer<__void_pointer>::value, __begin_node_pointer, __node_pointer> __iter_node_pointer;
 #endif
 
   typedef __conditional_t<is_same<__iter_node_pointer, __node_pointer>::value, __begin_node_pointer, __node_pointer>
       __non_iter_node_pointer;
 
-  _LIBCPP_INLINE_VISIBILITY
-  static __iter_node_pointer __as_iter_node(__iter_node_pointer __p) {
-      return __p;
-  }
-  _LIBCPP_INLINE_VISIBILITY
-  static __iter_node_pointer __as_iter_node(__non_iter_node_pointer __p) {
-      return static_cast<__iter_node_pointer>(static_cast<__void_pointer>(__p));
+  _LIBCPP_HIDE_FROM_ABI static __iter_node_pointer __as_iter_node(__iter_node_pointer __p) { return __p; }
+  _LIBCPP_HIDE_FROM_ABI static __iter_node_pointer __as_iter_node(__non_iter_node_pointer __p) {
+    return static_cast<__iter_node_pointer>(static_cast<__void_pointer>(__p));
   }
 };
 
 template <class _NodePtr>
-struct __forward_begin_node
-{
-    typedef _NodePtr pointer;
-    typedef __rebind_pointer_t<_NodePtr, __forward_begin_node> __begin_node_pointer;
+struct __forward_begin_node {
+  typedef _NodePtr pointer;
+  typedef __rebind_pointer_t<_NodePtr, __forward_begin_node> __begin_node_pointer;
 
-    pointer __next_;
+  pointer __next_;
 
-    _LIBCPP_INLINE_VISIBILITY __forward_begin_node() : __next_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI __forward_begin_node() : __next_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __forward_begin_node(pointer __n) : __next_(__n) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __begin_node_pointer __next_as_begin() const {
-        return static_cast<__begin_node_pointer>(__next_);
-    }
+  _LIBCPP_HIDE_FROM_ABI __begin_node_pointer __next_as_begin() const {
+    return static_cast<__begin_node_pointer>(__next_);
+  }
 };
 
 template <class _Tp, class _VoidPtr>
 using __begin_node_of = __forward_begin_node<__rebind_pointer_t<_VoidPtr, __forward_list_node<_Tp, _VoidPtr> > >;
 
 template <class _Tp, class _VoidPtr>
-struct _LIBCPP_STANDALONE_DEBUG __forward_list_node
-    : public __begin_node_of<_Tp, _VoidPtr>
-{
-    typedef _Tp value_type;
+struct __forward_list_node : public __begin_node_of<_Tp, _VoidPtr> {
+  typedef _Tp value_type;
+  typedef __begin_node_of<_Tp, _VoidPtr> _Base;
+  typedef typename _Base::pointer _NodePtr;
 
-    value_type __value_;
-};
+  // We allow starting the lifetime of nodes without initializing the value held by the node,
+  // since that is handled by the list itself in order to be allocator-aware.
+#ifndef _LIBCPP_CXX03_LANG
 
-
-template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS forward_list;
-template<class _NodeConstPtr> class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;
-
-template <class _NodePtr>
-class _LIBCPP_TEMPLATE_VIS __forward_list_iterator
-{
-    typedef __forward_node_traits<_NodePtr>         __traits;
-    typedef typename __traits::__node_pointer       __node_pointer;
-    typedef typename __traits::__begin_node_pointer __begin_node_pointer;
-    typedef typename __traits::__iter_node_pointer  __iter_node_pointer;
-    typedef typename __traits::__void_pointer       __void_pointer;
-
-    __iter_node_pointer __ptr_;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __begin_node_pointer __get_begin() const {
-        return static_cast<__begin_node_pointer>(
-                static_cast<__void_pointer>(__ptr_));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __get_unsafe_node_pointer() const {
-        return static_cast<__node_pointer>(
-                static_cast<__void_pointer>(__ptr_));
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_iterator(nullptr_t) _NOEXCEPT : __ptr_(nullptr) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_iterator(__begin_node_pointer __p) _NOEXCEPT
-        : __ptr_(__traits::__as_iter_node(__p)) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT
-        : __ptr_(__traits::__as_iter_node(__p)) {}
-
-    template<class, class> friend class _LIBCPP_TEMPLATE_VIS forward_list;
-    template<class> friend class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;
+private:
+  union {
+    _Tp __value_;
+  };
 
 public:
-    typedef forward_iterator_tag                              iterator_category;
-    typedef typename __traits::__node_value_type              value_type;
-    typedef value_type&                                       reference;
-    typedef typename pointer_traits<__node_pointer>::difference_type
-                                                              difference_type;
-    typedef __rebind_pointer_t<__node_pointer, value_type> pointer;
+  _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return __value_; }
+#else
 
-    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_iterator() _NOEXCEPT : __ptr_(nullptr) {}
+private:
+  _ALIGNAS_TYPE(_Tp) char __buffer_[sizeof(_Tp)];
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return __get_unsafe_node_pointer()->__value_;}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {
-        return pointer_traits<pointer>::pointer_to(__get_unsafe_node_pointer()->__value_);
-    }
+public:
+  _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return *std::__launder(reinterpret_cast<_Tp*>(&__buffer_)); }
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_iterator& operator++()
-    {
-        __ptr_ = __traits::__as_iter_node(__ptr_->__next_);
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_iterator operator++(int)
-    {
-        __forward_list_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit __forward_list_node(_NodePtr __next) : _Base(__next) {}
+  _LIBCPP_HIDE_FROM_ABI ~__forward_list_node() {}
+};
 
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __forward_list_iterator& __x,
-                    const __forward_list_iterator& __y)
-        {return __x.__ptr_ == __y.__ptr_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __forward_list_iterator& __x,
-                    const __forward_list_iterator& __y)
-        {return !(__x == __y);}
+template <class _Tp, class _Alloc = allocator<_Tp> >
+class _LIBCPP_TEMPLATE_VIS forward_list;
+template <class _NodeConstPtr>
+class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;
+
+template <class _NodePtr>
+class _LIBCPP_TEMPLATE_VIS __forward_list_iterator {
+  typedef __forward_node_traits<_NodePtr> __traits;
+  typedef typename __traits::__node_pointer __node_pointer;
+  typedef typename __traits::__begin_node_pointer __begin_node_pointer;
+  typedef typename __traits::__iter_node_pointer __iter_node_pointer;
+  typedef typename __traits::__void_pointer __void_pointer;
+
+  __iter_node_pointer __ptr_;
+
+  _LIBCPP_HIDE_FROM_ABI __begin_node_pointer __get_begin() const {
+    return static_cast<__begin_node_pointer>(static_cast<__void_pointer>(__ptr_));
+  }
+  _LIBCPP_HIDE_FROM_ABI __node_pointer __get_unsafe_node_pointer() const {
+    return static_cast<__node_pointer>(static_cast<__void_pointer>(__ptr_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI explicit __forward_list_iterator(nullptr_t) _NOEXCEPT : __ptr_(nullptr) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit __forward_list_iterator(__begin_node_pointer __p) _NOEXCEPT
+      : __ptr_(__traits::__as_iter_node(__p)) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT
+      : __ptr_(__traits::__as_iter_node(__p)) {}
+
+  template <class, class>
+  friend class _LIBCPP_TEMPLATE_VIS forward_list;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator;
+
+public:
+  typedef forward_iterator_tag iterator_category;
+  typedef typename __traits::__node_value_type value_type;
+  typedef value_type& reference;
+  typedef typename pointer_traits<__node_pointer>::difference_type difference_type;
+  typedef __rebind_pointer_t<__node_pointer, value_type> pointer;
+
+  _LIBCPP_HIDE_FROM_ABI __forward_list_iterator() _NOEXCEPT : __ptr_(nullptr) {}
+
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_unsafe_node_pointer()->__get_value(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const {
+    return pointer_traits<pointer>::pointer_to(__get_unsafe_node_pointer()->__get_value());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __forward_list_iterator& operator++() {
+    __ptr_ = __traits::__as_iter_node(__ptr_->__next_);
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __forward_list_iterator operator++(int) {
+    __forward_list_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
+
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __forward_list_iterator& __x, const __forward_list_iterator& __y) {
+    return __x.__ptr_ == __y.__ptr_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __forward_list_iterator& __x, const __forward_list_iterator& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _NodeConstPtr>
-class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator
-{
-    static_assert((!is_const<typename pointer_traits<_NodeConstPtr>::element_type>::value), "");
-    typedef _NodeConstPtr _NodePtr;
+class _LIBCPP_TEMPLATE_VIS __forward_list_const_iterator {
+  static_assert(!is_const<typename pointer_traits<_NodeConstPtr>::element_type>::value, "");
+  typedef _NodeConstPtr _NodePtr;
 
-    typedef __forward_node_traits<_NodePtr>         __traits;
-    typedef typename __traits::__node               __node;
-    typedef typename __traits::__node_pointer       __node_pointer;
-    typedef typename __traits::__begin_node_pointer __begin_node_pointer;
-    typedef typename __traits::__iter_node_pointer  __iter_node_pointer;
-    typedef typename __traits::__void_pointer       __void_pointer;
+  typedef __forward_node_traits<_NodePtr> __traits;
+  typedef typename __traits::__node_type __node_type;
+  typedef typename __traits::__node_pointer __node_pointer;
+  typedef typename __traits::__begin_node_pointer __begin_node_pointer;
+  typedef typename __traits::__iter_node_pointer __iter_node_pointer;
+  typedef typename __traits::__void_pointer __void_pointer;
 
-    __iter_node_pointer __ptr_;
+  __iter_node_pointer __ptr_;
 
-    _LIBCPP_HIDE_FROM_ABI __begin_node_pointer __get_begin() const {
-        return static_cast<__begin_node_pointer>(
-                static_cast<__void_pointer>(__ptr_));
-    }
-    _LIBCPP_HIDE_FROM_ABI __node_pointer __get_unsafe_node_pointer() const {
-        return static_cast<__node_pointer>(
-                static_cast<__void_pointer>(__ptr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __begin_node_pointer __get_begin() const {
+    return static_cast<__begin_node_pointer>(static_cast<__void_pointer>(__ptr_));
+  }
+  _LIBCPP_HIDE_FROM_ABI __node_pointer __get_unsafe_node_pointer() const {
+    return static_cast<__node_pointer>(static_cast<__void_pointer>(__ptr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_const_iterator(nullptr_t) _NOEXCEPT
-        : __ptr_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __forward_list_const_iterator(nullptr_t) _NOEXCEPT : __ptr_(nullptr) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_const_iterator(__begin_node_pointer __p) _NOEXCEPT
-        : __ptr_(__traits::__as_iter_node(__p)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __forward_list_const_iterator(__begin_node_pointer __p) _NOEXCEPT
+      : __ptr_(__traits::__as_iter_node(__p)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_const_iterator(__node_pointer __p) _NOEXCEPT
-        : __ptr_(__traits::__as_iter_node(__p)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __forward_list_const_iterator(__node_pointer __p) _NOEXCEPT
+      : __ptr_(__traits::__as_iter_node(__p)) {}
 
-
-    template<class, class> friend class forward_list;
+  template <class, class>
+  friend class forward_list;
 
 public:
-    typedef forward_iterator_tag                              iterator_category;
-    typedef typename __traits::__node_value_type              value_type;
-    typedef const value_type&                                 reference;
-    typedef typename pointer_traits<__node_pointer>::difference_type
-                                                              difference_type;
-    typedef __rebind_pointer_t<__node_pointer, const value_type>
-                                                              pointer;
+  typedef forward_iterator_tag iterator_category;
+  typedef typename __traits::__node_value_type value_type;
+  typedef const value_type& reference;
+  typedef typename pointer_traits<__node_pointer>::difference_type difference_type;
+  typedef __rebind_pointer_t<__node_pointer, const value_type> pointer;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_const_iterator() _NOEXCEPT : __ptr_(nullptr) {}
-    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_const_iterator(__forward_list_iterator<__node_pointer> __p) _NOEXCEPT
-        : __ptr_(__p.__ptr_) {}
+  _LIBCPP_HIDE_FROM_ABI __forward_list_const_iterator() _NOEXCEPT : __ptr_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI __forward_list_const_iterator(__forward_list_iterator<__node_pointer> __p) _NOEXCEPT
+      : __ptr_(__p.__ptr_) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return __get_unsafe_node_pointer()->__value_;}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return pointer_traits<pointer>::pointer_to(
-                __get_unsafe_node_pointer()->__value_);}
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_unsafe_node_pointer()->__get_value(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const {
+    return pointer_traits<pointer>::pointer_to(__get_unsafe_node_pointer()->__get_value());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_const_iterator& operator++()
-    {
-        __ptr_ = __traits::__as_iter_node(__ptr_->__next_);
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_const_iterator operator++(int)
-    {
-        __forward_list_const_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI __forward_list_const_iterator& operator++() {
+    __ptr_ = __traits::__as_iter_node(__ptr_->__next_);
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __forward_list_const_iterator operator++(int) {
+    __forward_list_const_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __forward_list_const_iterator& __x,
-                    const __forward_list_const_iterator& __y)
-        {return __x.__ptr_ == __y.__ptr_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __forward_list_const_iterator& __x,
-                           const __forward_list_const_iterator& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const __forward_list_const_iterator& __x, const __forward_list_const_iterator& __y) {
+    return __x.__ptr_ == __y.__ptr_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const __forward_list_const_iterator& __x, const __forward_list_const_iterator& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _Tp, class _Alloc>
-class __forward_list_base
-{
+class __forward_list_base {
 protected:
-    typedef _Tp    value_type;
-    typedef _Alloc allocator_type;
+  typedef _Tp value_type;
+  typedef _Alloc allocator_type;
 
-    typedef typename allocator_traits<allocator_type>::void_pointer  void_pointer;
-    typedef __forward_list_node<value_type, void_pointer>            __node;
-    typedef __begin_node_of<value_type, void_pointer>                __begin_node;
-    typedef __rebind_alloc<allocator_traits<allocator_type>, __node> __node_allocator;
-    typedef allocator_traits<__node_allocator>        __node_traits;
-    typedef typename __node_traits::pointer           __node_pointer;
+  typedef typename allocator_traits<allocator_type>::void_pointer void_pointer;
+  typedef __forward_list_node<value_type, void_pointer> __node_type;
+  typedef __begin_node_of<value_type, void_pointer> __begin_node;
+  typedef __rebind_alloc<allocator_traits<allocator_type>, __node_type> __node_allocator;
+  typedef allocator_traits<__node_allocator> __node_traits;
+  typedef typename __node_traits::pointer __node_pointer;
 
-    typedef __rebind_alloc<allocator_traits<allocator_type>, __begin_node> __begin_node_allocator;
-    typedef typename allocator_traits<__begin_node_allocator>::pointer
-                                                      __begin_node_pointer;
+  typedef __rebind_alloc<allocator_traits<allocator_type>, __begin_node> __begin_node_allocator;
+  typedef typename allocator_traits<__begin_node_allocator>::pointer __begin_node_pointer;
 
-    __compressed_pair<__begin_node, __node_allocator> __before_begin_;
+  __compressed_pair<__begin_node, __node_allocator> __before_begin_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __begin_node_pointer        __before_begin() _NOEXCEPT
-        {return pointer_traits<__begin_node_pointer>::pointer_to(__before_begin_.first());}
-    _LIBCPP_INLINE_VISIBILITY
-    __begin_node_pointer __before_begin() const _NOEXCEPT
-        {return pointer_traits<__begin_node_pointer>::pointer_to(const_cast<__begin_node&>(__before_begin_.first()));}
+  _LIBCPP_HIDE_FROM_ABI __begin_node_pointer __before_begin() _NOEXCEPT {
+    return pointer_traits<__begin_node_pointer>::pointer_to(__before_begin_.first());
+  }
+  _LIBCPP_HIDE_FROM_ABI __begin_node_pointer __before_begin() const _NOEXCEPT {
+    return pointer_traits<__begin_node_pointer>::pointer_to(const_cast<__begin_node&>(__before_begin_.first()));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-          __node_allocator& __alloc() _NOEXCEPT
-            {return __before_begin_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const __node_allocator& __alloc() const _NOEXCEPT
-        {return __before_begin_.second();}
+  _LIBCPP_HIDE_FROM_ABI __node_allocator& __alloc() _NOEXCEPT { return __before_begin_.second(); }
+  _LIBCPP_HIDE_FROM_ABI const __node_allocator& __alloc() const _NOEXCEPT { return __before_begin_.second(); }
 
-    typedef __forward_list_iterator<__node_pointer>             iterator;
-    typedef __forward_list_const_iterator<__node_pointer>       const_iterator;
+  typedef __forward_list_iterator<__node_pointer> iterator;
+  typedef __forward_list_const_iterator<__node_pointer> const_iterator;
+
+  _LIBCPP_HIDE_FROM_ABI __forward_list_base() _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
+      : __before_begin_(__begin_node(), __default_init_tag()) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __forward_list_base(const allocator_type& __a)
+      : __before_begin_(__begin_node(), __node_allocator(__a)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __forward_list_base(const __node_allocator& __a)
+      : __before_begin_(__begin_node(), __a) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_base()
-        _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
-        : __before_begin_(__begin_node(), __default_init_tag()) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_base(const allocator_type& __a)
-        : __before_begin_(__begin_node(), __node_allocator(__a)) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_base(const __node_allocator& __a)
-        : __before_begin_(__begin_node(), __a) {}
-#ifndef _LIBCPP_CXX03_LANG
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_base(__forward_list_base&& __x)
-        _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_base(__forward_list_base&& __x, const allocator_type& __a);
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI
+  __forward_list_base(__forward_list_base&& __x) noexcept(is_nothrow_move_constructible<__node_allocator>::value);
+  _LIBCPP_HIDE_FROM_ABI __forward_list_base(__forward_list_base&& __x, const allocator_type& __a);
 #endif // _LIBCPP_CXX03_LANG
 
-private:
-    __forward_list_base(const __forward_list_base&);
-    __forward_list_base& operator=(const __forward_list_base&);
+  __forward_list_base(const __forward_list_base&)            = delete;
+  __forward_list_base& operator=(const __forward_list_base&) = delete;
 
-public:
-    _LIBCPP_HIDE_FROM_ABI ~__forward_list_base();
+  _LIBCPP_HIDE_FROM_ABI ~__forward_list_base();
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const __forward_list_base& __x)
-        {__copy_assign_alloc(__x, integral_constant<bool,
-              __node_traits::propagate_on_container_copy_assignment::value>());}
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __forward_list_base& __x) {
+    __copy_assign_alloc(__x, integral_constant<bool, __node_traits::propagate_on_container_copy_assignment::value>());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__forward_list_base& __x)
-        _NOEXCEPT_(!__node_traits::propagate_on_container_move_assignment::value ||
-                   is_nothrow_move_assignable<__node_allocator>::value)
-        {__move_assign_alloc(__x, integral_constant<bool,
-              __node_traits::propagate_on_container_move_assignment::value>());}
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__forward_list_base& __x)
+      _NOEXCEPT_(!__node_traits::propagate_on_container_move_assignment::value ||
+                 is_nothrow_move_assignable<__node_allocator>::value) {
+    __move_assign_alloc(__x, integral_constant<bool, __node_traits::propagate_on_container_move_assignment::value>());
+  }
 
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(__forward_list_base& __x)
-#if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT;
-#else
-        _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<__node_allocator>::value);
-#endif
-protected:
-    _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT;
-
-private:
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const __forward_list_base&, false_type) {}
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const __forward_list_base& __x, true_type)
-    {
-        if (__alloc() != __x.__alloc())
-            clear();
-        __alloc() = __x.__alloc();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__forward_list_base&, false_type) _NOEXCEPT
-        {}
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__forward_list_base& __x, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
-        {__alloc() = _VSTD::move(__x.__alloc());}
-};
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Tp, class _Alloc>
-inline
-__forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
-        _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
-    : __before_begin_(_VSTD::move(__x.__before_begin_))
-{
-    __x.__before_begin()->__next_ = nullptr;
-}
-
-template <class _Tp, class _Alloc>
-inline
-__forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x,
-                                                      const allocator_type& __a)
-    : __before_begin_(__begin_node(), __node_allocator(__a))
-{
-    if (__alloc() == __x.__alloc())
-    {
-        __before_begin()->__next_ = __x.__before_begin()->__next_;
-        __x.__before_begin()->__next_ = nullptr;
-    }
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
-template <class _Tp, class _Alloc>
-__forward_list_base<_Tp, _Alloc>::~__forward_list_base()
-{
-    clear();
-}
-
-template <class _Tp, class _Alloc>
-inline
-void
-__forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x)
-#if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT
-#else
-        _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<__node_allocator>::value)
-#endif
-{
-    _VSTD::__swap_allocator(__alloc(), __x.__alloc(),
-            integral_constant<bool, __node_traits::propagate_on_container_swap::value>());
-    using _VSTD::swap;
-    swap(__before_begin()->__next_, __x.__before_begin()->__next_);
-}
-
-template <class _Tp, class _Alloc>
-void
-__forward_list_base<_Tp, _Alloc>::clear() _NOEXCEPT
-{
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI __node_pointer __create_node(__node_pointer __next, _Args&&... __args) {
     __node_allocator& __a = __alloc();
-    for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;)
-    {
-        __node_pointer __next = __p->__next_;
-        __node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
-        __node_traits::deallocate(__a, __p, 1);
-        __p = __next;
-    }
-    __before_begin()->__next_ = nullptr;
+    __allocation_guard<__node_allocator> __guard(__a, 1);
+    // Begin the lifetime of the node itself. Note that this doesn't begin the lifetime of the value
+    // held inside the node, since we need to use the allocator's construct() method for that.
+    //
+    // We don't use the allocator's construct() method to construct the node itself since the
+    // Cpp17FooInsertable named requirements don't require the allocator's construct() method
+    // to work on anything other than the value_type.
+    std::__construct_at(std::addressof(*__guard.__get()), __next);
+
+    // Now construct the value_type using the allocator's construct() method.
+    __node_traits::construct(__a, std::addressof(__guard.__get()->__get_value()), std::forward<_Args>(__args)...);
+    return __guard.__release_ptr();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __delete_node(__node_pointer __node) {
+    // For the same reason as above, we use the allocator's destroy() method for the value_type,
+    // but not for the node itself.
+    __node_allocator& __a = __alloc();
+    __node_traits::destroy(__a, std::addressof(__node->__get_value()));
+    std::__destroy_at(std::addressof(*__node));
+    __node_traits::deallocate(__a, __node, 1);
+  }
+
+public:
+  _LIBCPP_HIDE_FROM_ABI void swap(__forward_list_base& __x)
+#if _LIBCPP_STD_VER >= 14
+      _NOEXCEPT;
+#else
+      _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<__node_allocator>);
+#endif
+
+protected:
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT;
+
+private:
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __forward_list_base&, false_type) {}
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __forward_list_base& __x, true_type) {
+    if (__alloc() != __x.__alloc())
+      clear();
+    __alloc() = __x.__alloc();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__forward_list_base&, false_type) _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__forward_list_base& __x, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value) {
+    __alloc() = std::move(__x.__alloc());
+  }
+};
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Tp, class _Alloc>
+inline __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x) noexcept(
+    is_nothrow_move_constructible<__node_allocator>::value)
+    : __before_begin_(std::move(__x.__before_begin_)) {
+  __x.__before_begin()->__next_ = nullptr;
+}
+
+template <class _Tp, class _Alloc>
+inline __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x, const allocator_type& __a)
+    : __before_begin_(__begin_node(), __node_allocator(__a)) {
+  if (__alloc() == __x.__alloc()) {
+    __before_begin()->__next_     = __x.__before_begin()->__next_;
+    __x.__before_begin()->__next_ = nullptr;
+  }
+}
+
+#endif // _LIBCPP_CXX03_LANG
+
+template <class _Tp, class _Alloc>
+__forward_list_base<_Tp, _Alloc>::~__forward_list_base() {
+  clear();
+}
+
+template <class _Tp, class _Alloc>
+inline void __forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x)
+#if _LIBCPP_STD_VER >= 14
+    _NOEXCEPT
+#else
+    _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<__node_allocator>)
+#endif
+{
+  std::__swap_allocator(
+      __alloc(), __x.__alloc(), integral_constant<bool, __node_traits::propagate_on_container_swap::value>());
+  using std::swap;
+  swap(__before_begin()->__next_, __x.__before_begin()->__next_);
+}
+
+template <class _Tp, class _Alloc>
+void __forward_list_base<_Tp, _Alloc>::clear() _NOEXCEPT {
+  for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;) {
+    __node_pointer __next = __p->__next_;
+    __delete_node(__p);
+    __p = __next;
+  }
+  __before_begin()->__next_ = nullptr;
 }
 
 template <class _Tp, class _Alloc /*= allocator<_Tp>*/>
-class _LIBCPP_TEMPLATE_VIS forward_list
-    : private __forward_list_base<_Tp, _Alloc>
-{
-    typedef __forward_list_base<_Tp, _Alloc> base;
-    typedef typename base::__node_allocator  __node_allocator;
-    typedef typename base::__node               __node;
-    typedef typename base::__node_traits        __node_traits;
-    typedef typename base::__node_pointer       __node_pointer;
-    typedef typename base::__begin_node_pointer __begin_node_pointer;
+class _LIBCPP_TEMPLATE_VIS forward_list : private __forward_list_base<_Tp, _Alloc> {
+  typedef __forward_list_base<_Tp, _Alloc> base;
+  typedef typename base::__node_allocator __node_allocator;
+  typedef typename base::__node_type __node_type;
+  typedef typename base::__node_traits __node_traits;
+  typedef typename base::__node_pointer __node_pointer;
+  typedef typename base::__begin_node_pointer __begin_node_pointer;
 
 public:
-    typedef _Tp    value_type;
-    typedef _Alloc allocator_type;
+  typedef _Tp value_type;
+  typedef _Alloc allocator_type;
 
-    static_assert(is_same<value_type, typename allocator_type::value_type>::value,
-                  "Allocator::value_type must be same type as value_type");
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
 
-    static_assert(is_same<allocator_type, __rebind_alloc<allocator_traits<allocator_type>, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
+  static_assert(is_same<value_type, typename allocator_type::value_type>::value,
+                "Allocator::value_type must be same type as value_type");
 
-    static_assert((!is_same<allocator_type, __node_allocator>::value),
-                  "internal allocator type must differ from user-specified "
-                  "type; otherwise overload resolution breaks");
+  static_assert(!is_same<allocator_type, __node_allocator>::value,
+                "internal allocator type must differ from user-specified type; otherwise overload resolution breaks");
 
-    typedef value_type&                                                 reference;
-    typedef const value_type&                                           const_reference;
-    typedef typename allocator_traits<allocator_type>::pointer          pointer;
-    typedef typename allocator_traits<allocator_type>::const_pointer    const_pointer;
-    typedef typename allocator_traits<allocator_type>::size_type        size_type;
-    typedef typename allocator_traits<allocator_type>::difference_type  difference_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef typename allocator_traits<allocator_type>::pointer pointer;
+  typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
+  typedef typename allocator_traits<allocator_type>::size_type size_type;
+  typedef typename allocator_traits<allocator_type>::difference_type difference_type;
 
-    typedef typename base::iterator       iterator;
-    typedef typename base::const_iterator const_iterator;
+  typedef typename base::iterator iterator;
+  typedef typename base::const_iterator const_iterator;
 #if _LIBCPP_STD_VER >= 20
-    typedef size_type                                __remove_return_type;
+  typedef size_type __remove_return_type;
 #else
-    typedef void                                     __remove_return_type;
+  typedef void __remove_return_type;
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    forward_list()
-        _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
-        {} // = default;
-    _LIBCPP_INLINE_VISIBILITY
-    explicit forward_list(const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI explicit forward_list(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI forward_list() _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value) {
+  } // = default;
+  _LIBCPP_HIDE_FROM_ABI explicit forward_list(const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI explicit forward_list(size_type __n);
 #if _LIBCPP_STD_VER >= 14
-    _LIBCPP_HIDE_FROM_ABI explicit forward_list(size_type __n, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI explicit forward_list(size_type __n, const allocator_type& __a);
 #endif
-    _LIBCPP_HIDE_FROM_ABI forward_list(size_type __n, const value_type& __v);
+  _LIBCPP_HIDE_FROM_ABI forward_list(size_type __n, const value_type& __v);
 
-    template <class = __enable_if_t<__is_allocator<_Alloc>::value> >
-    _LIBCPP_HIDE_FROM_ABI forward_list(size_type __n, const value_type& __v, const allocator_type& __a) : base(__a)
-    {
-        insert_after(cbefore_begin(), __n, __v);
-    }
+  template <__enable_if_t<__is_allocator<_Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI forward_list(size_type __n, const value_type& __v, const allocator_type& __a) : base(__a) {
+    insert_after(cbefore_begin(), __n, __v);
+  }
 
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI forward_list(_InputIterator __f, _InputIterator __l,
-                     __enable_if_t<__has_input_iterator_category<_InputIterator>::value>* = nullptr);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI forward_list(_InputIterator __f, _InputIterator __l,
-                     const allocator_type& __a,
-                     __enable_if_t<__has_input_iterator_category<_InputIterator>::value>* = nullptr);
-    _LIBCPP_HIDE_FROM_ABI forward_list(const forward_list& __x);
-    _LIBCPP_HIDE_FROM_ABI forward_list(const forward_list& __x, const __type_identity_t<allocator_type>& __a);
+  template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI forward_list(_InputIterator __f, _InputIterator __l);
 
-    _LIBCPP_HIDE_FROM_ABI forward_list& operator=(const forward_list& __x);
+  template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI forward_list(_InputIterator __f, _InputIterator __l, const allocator_type& __a);
 
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    forward_list(forward_list&& __x)
-        _NOEXCEPT_(is_nothrow_move_constructible<base>::value)
-        : base(_VSTD::move(__x)) {}
-    _LIBCPP_HIDE_FROM_ABI forward_list(forward_list&& __x, const __type_identity_t<allocator_type>& __a);
-
-    _LIBCPP_HIDE_FROM_ABI forward_list(initializer_list<value_type> __il);
-    _LIBCPP_HIDE_FROM_ABI forward_list(initializer_list<value_type> __il, const allocator_type& __a);
-
-    _LIBCPP_INLINE_VISIBILITY
-    forward_list& operator=(forward_list&& __x)
-        _NOEXCEPT_(
-             __node_traits::propagate_on_container_move_assignment::value &&
-             is_nothrow_move_assignable<allocator_type>::value);
-
-    _LIBCPP_INLINE_VISIBILITY
-    forward_list& operator=(initializer_list<value_type> __il);
-
-    _LIBCPP_INLINE_VISIBILITY
-    void assign(initializer_list<value_type> __il);
-#endif // _LIBCPP_CXX03_LANG
-
-    // ~forward_list() = default;
-
-    template <class _InputIterator>
-    __enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>
-    _LIBCPP_HIDE_FROM_ABI assign(_InputIterator __f, _InputIterator __l);
-    _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __v);
-
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT
-        {return allocator_type(base::__alloc());}
-
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT
-        {return       iterator(base::__before_begin()->__next_);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT
-        {return const_iterator(base::__before_begin()->__next_);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT
-        {return       iterator(nullptr);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT
-        {return const_iterator(nullptr);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT
-        {return const_iterator(base::__before_begin()->__next_);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT
-        {return const_iterator(nullptr);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       before_begin() _NOEXCEPT
-        {return       iterator(base::__before_begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator before_begin() const _NOEXCEPT
-        {return const_iterator(base::__before_begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbefore_begin() const _NOEXCEPT
-        {return const_iterator(base::__before_begin());}
-
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT
-        {return base::__before_begin()->__next_ == nullptr;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {
-        return _VSTD::min<size_type>(
-            __node_traits::max_size(base::__alloc()),
-            numeric_limits<difference_type>::max());
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    reference       front()       {return base::__before_begin()->__next_->__value_;}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference front() const {return base::__before_begin()->__next_->__value_;}
-
-#ifndef _LIBCPP_CXX03_LANG
-#if _LIBCPP_STD_VER >= 17
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI reference emplace_front(_Args&&... __args);
-#else
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI void      emplace_front(_Args&&... __args);
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI forward_list(from_range_t, _Range&& __range, const allocator_type& __a = allocator_type())
+      : base(__a) {
+    prepend_range(std::forward<_Range>(__range));
+  }
 #endif
-    _LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __v);
-#endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __v);
 
-    _LIBCPP_HIDE_FROM_ABI void pop_front();
+  _LIBCPP_HIDE_FROM_ABI forward_list(const forward_list& __x);
+  _LIBCPP_HIDE_FROM_ABI forward_list(const forward_list& __x, const __type_identity_t<allocator_type>& __a);
+
+  _LIBCPP_HIDE_FROM_ABI forward_list& operator=(const forward_list& __x);
 
 #ifndef _LIBCPP_CXX03_LANG
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI iterator emplace_after(const_iterator __p, _Args&&... __args);
+  _LIBCPP_HIDE_FROM_ABI forward_list(forward_list&& __x) noexcept(is_nothrow_move_constructible<base>::value)
+      : base(std::move(__x)) {}
+  _LIBCPP_HIDE_FROM_ABI forward_list(forward_list&& __x, const __type_identity_t<allocator_type>& __a);
 
-    _LIBCPP_HIDE_FROM_ABI iterator insert_after(const_iterator __p, value_type&& __v);
-    _LIBCPP_HIDE_FROM_ABI iterator insert_after(const_iterator __p, initializer_list<value_type> __il)
-        {return insert_after(__p, __il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI forward_list(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI forward_list(initializer_list<value_type> __il, const allocator_type& __a);
+
+  _LIBCPP_HIDE_FROM_ABI forward_list& operator=(forward_list&& __x) noexcept(
+      __node_traits::propagate_on_container_move_assignment::value &&
+      is_nothrow_move_assignable<allocator_type>::value);
+
+  _LIBCPP_HIDE_FROM_ABI forward_list& operator=(initializer_list<value_type> __il);
+
+  _LIBCPP_HIDE_FROM_ABI void assign(initializer_list<value_type> __il);
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI iterator insert_after(const_iterator __p, const value_type& __v);
-    _LIBCPP_HIDE_FROM_ABI iterator insert_after(const_iterator __p, size_type __n, const value_type& __v);
-    template <class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__has_input_iterator_category<_InputIterator>::value, iterator>
-        insert_after(const_iterator __p, _InputIterator __f, _InputIterator __l);
 
-    _LIBCPP_HIDE_FROM_ABI iterator erase_after(const_iterator __p);
-    _LIBCPP_HIDE_FROM_ABI iterator erase_after(const_iterator __f, const_iterator __l);
+  // ~forward_list() = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(forward_list& __x)
+  template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI assign(_InputIterator __f, _InputIterator __l);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void assign_range(_Range&& __range) {
+    __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
+  }
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __v);
+
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return allocator_type(base::__alloc()); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return iterator(base::__before_begin()->__next_); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT {
+    return const_iterator(base::__before_begin()->__next_);
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return iterator(nullptr); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return const_iterator(nullptr); }
+
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
+    return const_iterator(base::__before_begin()->__next_);
+  }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return const_iterator(nullptr); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator before_begin() _NOEXCEPT { return iterator(base::__before_begin()); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator before_begin() const _NOEXCEPT { return const_iterator(base::__before_begin()); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbefore_begin() const _NOEXCEPT {
+    return const_iterator(base::__before_begin());
+  }
+
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT {
+    return base::__before_begin()->__next_ == nullptr;
+  }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+    return std::min<size_type>(__node_traits::max_size(base::__alloc()), numeric_limits<difference_type>::max());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI reference front() { return base::__before_begin()->__next_->__get_value(); }
+  _LIBCPP_HIDE_FROM_ABI const_reference front() const { return base::__before_begin()->__next_->__get_value(); }
+
+#ifndef _LIBCPP_CXX03_LANG
+#  if _LIBCPP_STD_VER >= 17
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI reference emplace_front(_Args&&... __args);
+#  else
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void emplace_front(_Args&&... __args);
+#  endif
+  _LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __v);
+#endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __v);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void prepend_range(_Range&& __range) {
+    insert_range_after(cbefore_begin(), std::forward<_Range>(__range));
+  }
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI void pop_front();
+
+#ifndef _LIBCPP_CXX03_LANG
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace_after(const_iterator __p, _Args&&... __args);
+
+  _LIBCPP_HIDE_FROM_ABI iterator insert_after(const_iterator __p, value_type&& __v);
+  _LIBCPP_HIDE_FROM_ABI iterator insert_after(const_iterator __p, initializer_list<value_type> __il) {
+    return insert_after(__p, __il.begin(), __il.end());
+  }
+#endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI iterator insert_after(const_iterator __p, const value_type& __v);
+  _LIBCPP_HIDE_FROM_ABI iterator insert_after(const_iterator __p, size_type __n, const value_type& __v);
+  template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert_after(const_iterator __p, _InputIterator __f, _InputIterator __l);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI iterator insert_range_after(const_iterator __position, _Range&& __range) {
+    return __insert_after_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
+  }
+#endif
+
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_after_with_sentinel(const_iterator __p, _InputIterator __f, _Sentinel __l);
+
+  _LIBCPP_HIDE_FROM_ABI iterator erase_after(const_iterator __p);
+  _LIBCPP_HIDE_FROM_ABI iterator erase_after(const_iterator __f, const_iterator __l);
+
+  _LIBCPP_HIDE_FROM_ABI void swap(forward_list& __x)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT
+      _NOEXCEPT
 #else
-        _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value ||
-                   __is_nothrow_swappable<__node_allocator>::value)
+      _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<__node_allocator>)
 #endif
-        {base::swap(__x);}
+  {
+    base::swap(__x);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI void resize(size_type __n);
-    _LIBCPP_HIDE_FROM_ABI void resize(size_type __n, const value_type& __v);
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {base::clear();}
+  _LIBCPP_HIDE_FROM_ABI void resize(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI void resize(size_type __n, const value_type& __v);
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { base::clear(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void splice_after(const_iterator __p, forward_list&& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    void splice_after(const_iterator __p, forward_list&& __x, const_iterator __i);
-    _LIBCPP_INLINE_VISIBILITY
-    void splice_after(const_iterator __p, forward_list&& __x,
-                      const_iterator __f, const_iterator __l);
-    _LIBCPP_HIDE_FROM_ABI void splice_after(const_iterator __p, forward_list& __x);
-    _LIBCPP_HIDE_FROM_ABI void splice_after(const_iterator __p, forward_list& __x, const_iterator __i);
-    _LIBCPP_HIDE_FROM_ABI void splice_after(const_iterator __p, forward_list& __x,
-                      const_iterator __f, const_iterator __l);
-    _LIBCPP_HIDE_FROM_ABI __remove_return_type remove(const value_type& __v);
-    template <class _Predicate>
-    _LIBCPP_HIDE_FROM_ABI __remove_return_type remove_if(_Predicate __pred);
-    _LIBCPP_INLINE_VISIBILITY
-    __remove_return_type unique() { return unique(__equal_to()); }
-    template <class _BinaryPredicate>
-    _LIBCPP_HIDE_FROM_ABI __remove_return_type unique(_BinaryPredicate __binary_pred);
+  _LIBCPP_HIDE_FROM_ABI void splice_after(const_iterator __p, forward_list&& __x);
+  _LIBCPP_HIDE_FROM_ABI void splice_after(const_iterator __p, forward_list&& __x, const_iterator __i);
+  _LIBCPP_HIDE_FROM_ABI void
+  splice_after(const_iterator __p, forward_list&& __x, const_iterator __f, const_iterator __l);
+  _LIBCPP_HIDE_FROM_ABI void splice_after(const_iterator __p, forward_list& __x);
+  _LIBCPP_HIDE_FROM_ABI void splice_after(const_iterator __p, forward_list& __x, const_iterator __i);
+  _LIBCPP_HIDE_FROM_ABI void
+  splice_after(const_iterator __p, forward_list& __x, const_iterator __f, const_iterator __l);
+  _LIBCPP_HIDE_FROM_ABI __remove_return_type remove(const value_type& __v);
+  template <class _Predicate>
+  _LIBCPP_HIDE_FROM_ABI __remove_return_type remove_if(_Predicate __pred);
+  _LIBCPP_HIDE_FROM_ABI __remove_return_type unique() { return unique(__equal_to()); }
+  template <class _BinaryPredicate>
+  _LIBCPP_HIDE_FROM_ABI __remove_return_type unique(_BinaryPredicate __binary_pred);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(forward_list&& __x) {merge(__x, __less<value_type>());}
-    template <class _Compare>
-        _LIBCPP_INLINE_VISIBILITY
-        void merge(forward_list&& __x, _Compare __comp)
-        {merge(__x, _VSTD::move(__comp));}
+  _LIBCPP_HIDE_FROM_ABI void merge(forward_list&& __x) { merge(__x, __less<>()); }
+  template <class _Compare>
+  _LIBCPP_HIDE_FROM_ABI void merge(forward_list&& __x, _Compare __comp) {
+    merge(__x, std::move(__comp));
+  }
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(forward_list& __x) {merge(__x, __less<value_type>());}
-    template <class _Compare>
-    _LIBCPP_HIDE_FROM_ABI void merge(forward_list& __x, _Compare __comp);
-    _LIBCPP_INLINE_VISIBILITY
-    void sort() {sort(__less<value_type>());}
-    template <class _Compare> _LIBCPP_INLINE_VISIBILITY void sort(_Compare __comp);
-    _LIBCPP_HIDE_FROM_ABI void reverse() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void merge(forward_list& __x) { merge(__x, __less<>()); }
+  template <class _Compare>
+  _LIBCPP_HIDE_FROM_ABI void merge(forward_list& __x, _Compare __comp);
+  _LIBCPP_HIDE_FROM_ABI void sort() { sort(__less<>()); }
+  template <class _Compare>
+  _LIBCPP_HIDE_FROM_ABI void sort(_Compare __comp);
+  _LIBCPP_HIDE_FROM_ABI void reverse() _NOEXCEPT;
 
 private:
-
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI void __move_assign(forward_list& __x, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
-    _LIBCPP_HIDE_FROM_ABI void __move_assign(forward_list& __x, false_type);
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(forward_list& __x, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(forward_list& __x, false_type);
 #endif // _LIBCPP_CXX03_LANG
 
-    template <class _Compare>
-    static _LIBCPP_HIDE_FROM_ABI
-        __node_pointer
-        __merge(__node_pointer __f1, __node_pointer __f2, _Compare& __comp);
+  template <class _Iter, class _Sent>
+  _LIBCPP_HIDE_FROM_ABI void __assign_with_sentinel(_Iter __f, _Sent __l);
 
-    // TODO: Make this _LIBCPP_HIDE_FROM_ABI
-    template <class _Compare>
-    static _LIBCPP_HIDDEN
-        __node_pointer
-        __sort(__node_pointer __f, difference_type __sz, _Compare& __comp);
+  template <class _Compare>
+  static _LIBCPP_HIDE_FROM_ABI __node_pointer __merge(__node_pointer __f1, __node_pointer __f2, _Compare& __comp);
+
+  // TODO: Make this _LIBCPP_HIDE_FROM_ABI
+  template <class _Compare>
+  static _LIBCPP_HIDDEN __node_pointer __sort(__node_pointer __f, difference_type __sz, _Compare& __comp);
 };
 
-
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Alloc = allocator<__iter_value_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Alloc>::value>
-         >
-forward_list(_InputIterator, _InputIterator)
-  -> forward_list<__iter_value_type<_InputIterator>, _Alloc>;
+template <class _InputIterator,
+          class _Alloc = allocator<__iter_value_type<_InputIterator>>,
+          class        = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+forward_list(_InputIterator, _InputIterator) -> forward_list<__iter_value_type<_InputIterator>, _Alloc>;
 
-template<class _InputIterator,
-         class _Alloc,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Alloc>::value>
-         >
-forward_list(_InputIterator, _InputIterator, _Alloc)
-  -> forward_list<__iter_value_type<_InputIterator>, _Alloc>;
+template <class _InputIterator,
+          class _Alloc,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Alloc>::value> >
+forward_list(_InputIterator, _InputIterator, _Alloc) -> forward_list<__iter_value_type<_InputIterator>, _Alloc>;
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Alloc = allocator<ranges::range_value_t<_Range>>,
+          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+forward_list(from_range_t, _Range&&, _Alloc = _Alloc()) -> forward_list<ranges::range_value_t<_Range>, _Alloc>;
 #endif
 
 template <class _Tp, class _Alloc>
-inline
-forward_list<_Tp, _Alloc>::forward_list(const allocator_type& __a)
-    : base(__a)
-{
-}
+inline forward_list<_Tp, _Alloc>::forward_list(const allocator_type& __a) : base(__a) {}
 
 template <class _Tp, class _Alloc>
-forward_list<_Tp, _Alloc>::forward_list(size_type __n)
-{
-    if (__n > 0)
-    {
-        __node_allocator& __a = base::__alloc();
-        typedef __allocator_destructor<__node_allocator> _Dp;
-        unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
-        for (__begin_node_pointer __p = base::__before_begin(); __n > 0; --__n,
-                                                             __p = __p->__next_as_begin())
-        {
-            __h.reset(__node_traits::allocate(__a, 1));
-            __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
-            __h->__next_ = nullptr;
-            __p->__next_ = __h.release();
-        }
+forward_list<_Tp, _Alloc>::forward_list(size_type __n) {
+  if (__n > 0) {
+    for (__begin_node_pointer __p = base::__before_begin(); __n > 0; --__n, __p = __p->__next_as_begin()) {
+      __p->__next_ = this->__create_node(/* next = */ nullptr);
     }
+  }
 }
 
 #if _LIBCPP_STD_VER >= 14
 template <class _Tp, class _Alloc>
-forward_list<_Tp, _Alloc>::forward_list(size_type __n,
-                                        const allocator_type& __base_alloc)
-    : base ( __base_alloc )
-{
-    if (__n > 0)
-    {
-        __node_allocator& __a = base::__alloc();
-        typedef __allocator_destructor<__node_allocator> _Dp;
-        unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
-        for (__begin_node_pointer __p = base::__before_begin(); __n > 0; --__n,
-                                                             __p = __p->__next_as_begin())
-        {
-            __h.reset(__node_traits::allocate(__a, 1));
-            __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
-            __h->__next_ = nullptr;
-            __p->__next_ = __h.release();
-        }
+forward_list<_Tp, _Alloc>::forward_list(size_type __n, const allocator_type& __base_alloc) : base(__base_alloc) {
+  if (__n > 0) {
+    for (__begin_node_pointer __p = base::__before_begin(); __n > 0; --__n, __p = __p->__next_as_begin()) {
+      __p->__next_ = this->__create_node(/* next = */ nullptr);
     }
+  }
 }
 #endif
 
 template <class _Tp, class _Alloc>
-forward_list<_Tp, _Alloc>::forward_list(size_type __n, const value_type& __v)
-{
-    insert_after(cbefore_begin(), __n, __v);
+forward_list<_Tp, _Alloc>::forward_list(size_type __n, const value_type& __v) {
+  insert_after(cbefore_begin(), __n, __v);
 }
 
 template <class _Tp, class _Alloc>
-template <class _InputIterator>
-forward_list<_Tp, _Alloc>::forward_list(_InputIterator __f, _InputIterator __l,
-                                        __enable_if_t<__has_input_iterator_category<_InputIterator>::value>*)
-{
-    insert_after(cbefore_begin(), __f, __l);
+template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> >
+forward_list<_Tp, _Alloc>::forward_list(_InputIterator __f, _InputIterator __l) {
+  insert_after(cbefore_begin(), __f, __l);
 }
 
 template <class _Tp, class _Alloc>
-template <class _InputIterator>
-forward_list<_Tp, _Alloc>::forward_list(_InputIterator __f, _InputIterator __l,
-                                        const allocator_type& __a,
-                                        __enable_if_t<__has_input_iterator_category<_InputIterator>::value>*)
-    : base(__a)
-{
-    insert_after(cbefore_begin(), __f, __l);
+template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> >
+forward_list<_Tp, _Alloc>::forward_list(_InputIterator __f, _InputIterator __l, const allocator_type& __a) : base(__a) {
+  insert_after(cbefore_begin(), __f, __l);
 }
 
 template <class _Tp, class _Alloc>
 forward_list<_Tp, _Alloc>::forward_list(const forward_list& __x)
-    : base(
-          __node_traits::select_on_container_copy_construction(__x.__alloc())) {
+    : base(__node_traits::select_on_container_copy_construction(__x.__alloc())) {
   insert_after(cbefore_begin(), __x.begin(), __x.end());
 }
 
 template <class _Tp, class _Alloc>
-forward_list<_Tp, _Alloc>::forward_list(const forward_list& __x,
-                                        const __type_identity_t<allocator_type>& __a)
-    : base(__a)
-{
-    insert_after(cbefore_begin(), __x.begin(), __x.end());
+forward_list<_Tp, _Alloc>::forward_list(const forward_list& __x, const __type_identity_t<allocator_type>& __a)
+    : base(__a) {
+  insert_after(cbefore_begin(), __x.begin(), __x.end());
 }
 
 template <class _Tp, class _Alloc>
-forward_list<_Tp, _Alloc>&
-forward_list<_Tp, _Alloc>::operator=(const forward_list& __x)
-{
-    if (this != _VSTD::addressof(__x))
-    {
-        base::__copy_assign_alloc(__x);
-        assign(__x.begin(), __x.end());
-    }
-    return *this;
+forward_list<_Tp, _Alloc>& forward_list<_Tp, _Alloc>::operator=(const forward_list& __x) {
+  if (this != std::addressof(__x)) {
+    base::__copy_assign_alloc(__x);
+    assign(__x.begin(), __x.end());
+  }
+  return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Alloc>
-forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x,
-                                        const __type_identity_t<allocator_type>& __a)
-    : base(_VSTD::move(__x), __a)
-{
-    if (base::__alloc() != __x.__alloc())
-    {
-        typedef move_iterator<iterator> _Ip;
-        insert_after(cbefore_begin(), _Ip(__x.begin()), _Ip(__x.end()));
-    }
+forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x, const __type_identity_t<allocator_type>& __a)
+    : base(std::move(__x), __a) {
+  if (base::__alloc() != __x.__alloc()) {
+    typedef move_iterator<iterator> _Ip;
+    insert_after(cbefore_begin(), _Ip(__x.begin()), _Ip(__x.end()));
+  }
 }
 
 template <class _Tp, class _Alloc>
-forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il)
-{
-    insert_after(cbefore_begin(), __il.begin(), __il.end());
+forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il) {
+  insert_after(cbefore_begin(), __il.begin(), __il.end());
 }
 
 template <class _Tp, class _Alloc>
-forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il,
-                                        const allocator_type& __a)
-    : base(__a)
-{
-    insert_after(cbefore_begin(), __il.begin(), __il.end());
+forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il, const allocator_type& __a) : base(__a) {
+  insert_after(cbefore_begin(), __il.begin(), __il.end());
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::__move_assign(forward_list& __x, true_type)
-    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-{
-    clear();
-    base::__move_assign_alloc(__x);
-    base::__before_begin()->__next_ = __x.__before_begin()->__next_;
-    __x.__before_begin()->__next_ = nullptr;
+void forward_list<_Tp, _Alloc>::__move_assign(forward_list& __x, true_type)
+    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
+  clear();
+  base::__move_assign_alloc(__x);
+  base::__before_begin()->__next_ = __x.__before_begin()->__next_;
+  __x.__before_begin()->__next_   = nullptr;
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::__move_assign(forward_list& __x, false_type)
-{
-    if (base::__alloc() == __x.__alloc())
-        __move_assign(__x, true_type());
-    else
-    {
-        typedef move_iterator<iterator> _Ip;
-        assign(_Ip(__x.begin()), _Ip(__x.end()));
-    }
+void forward_list<_Tp, _Alloc>::__move_assign(forward_list& __x, false_type) {
+  if (base::__alloc() == __x.__alloc())
+    __move_assign(__x, true_type());
+  else {
+    typedef move_iterator<iterator> _Ip;
+    assign(_Ip(__x.begin()), _Ip(__x.end()));
+  }
 }
 
 template <class _Tp, class _Alloc>
-inline
-forward_list<_Tp, _Alloc>&
-forward_list<_Tp, _Alloc>::operator=(forward_list&& __x)
-    _NOEXCEPT_(
-             __node_traits::propagate_on_container_move_assignment::value &&
-             is_nothrow_move_assignable<allocator_type>::value)
-{
-    __move_assign(__x, integral_constant<bool,
-          __node_traits::propagate_on_container_move_assignment::value>());
-    return *this;
+inline forward_list<_Tp, _Alloc>& forward_list<_Tp, _Alloc>::operator=(forward_list&& __x) _NOEXCEPT_(
+    __node_traits::propagate_on_container_move_assignment::value&& is_nothrow_move_assignable<allocator_type>::value) {
+  __move_assign(__x, integral_constant<bool, __node_traits::propagate_on_container_move_assignment::value>());
+  return *this;
 }
 
 template <class _Tp, class _Alloc>
-inline
-forward_list<_Tp, _Alloc>&
-forward_list<_Tp, _Alloc>::operator=(initializer_list<value_type> __il)
-{
-    assign(__il.begin(), __il.end());
-    return *this;
+inline forward_list<_Tp, _Alloc>& forward_list<_Tp, _Alloc>::operator=(initializer_list<value_type> __il) {
+  assign(__il.begin(), __il.end());
+  return *this;
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
-template <class _InputIterator>
-__enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>
-forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l)
-{
-    iterator __i = before_begin();
-    iterator __j = _VSTD::next(__i);
-    iterator __e = end();
-    for (; __j != __e && __f != __l; ++__i, (void) ++__j, ++__f)
-        *__j = *__f;
-    if (__j == __e)
-        insert_after(__i, __f, __l);
-    else
-        erase_after(__i, __e);
+template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> >
+void forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l) {
+  __assign_with_sentinel(__f, __l);
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
-{
-    iterator __i = before_begin();
-    iterator __j = _VSTD::next(__i);
-    iterator __e = end();
-    for (; __j != __e && __n > 0; --__n, ++__i, ++__j)
-        *__j = __v;
-    if (__j == __e)
-        insert_after(__i, __n, __v);
-    else
-        erase_after(__i, __e);
+template <class _Iter, class _Sent>
+_LIBCPP_HIDE_FROM_ABI void forward_list<_Tp, _Alloc>::__assign_with_sentinel(_Iter __f, _Sent __l) {
+  iterator __i = before_begin();
+  iterator __j = std::next(__i);
+  iterator __e = end();
+  for (; __j != __e && __f != __l; ++__i, (void)++__j, ++__f)
+    *__j = *__f;
+  if (__j == __e)
+    __insert_after_with_sentinel(__i, std::move(__f), std::move(__l));
+  else
+    erase_after(__i, __e);
+}
+
+template <class _Tp, class _Alloc>
+void forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v) {
+  iterator __i = before_begin();
+  iterator __j = std::next(__i);
+  iterator __e = end();
+  for (; __j != __e && __n > 0; --__n, ++__i, ++__j)
+    *__j = __v;
+  if (__j == __e)
+    insert_after(__i, __n, __v);
+  else
+    erase_after(__i, __e);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
-inline
-void
-forward_list<_Tp, _Alloc>::assign(initializer_list<value_type> __il)
-{
-    assign(__il.begin(), __il.end());
+inline void forward_list<_Tp, _Alloc>::assign(initializer_list<value_type> __il) {
+  assign(__il.begin(), __il.end());
 }
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 typename forward_list<_Tp, _Alloc>::reference
-#else
+#  else
 void
-#endif
-forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
-{
-    __node_allocator& __a = base::__alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
-    __node_traits::construct(__a, _VSTD::addressof(__h->__value_),
-                                  _VSTD::forward<_Args>(__args)...);
-    __h->__next_ = base::__before_begin()->__next_;
-    base::__before_begin()->__next_ = __h.release();
-#if _LIBCPP_STD_VER >= 17
-    return base::__before_begin()->__next_->__value_;
-#endif
+#  endif
+forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args) {
+  base::__before_begin()->__next_ =
+      this->__create_node(/* next = */ base::__before_begin()->__next_, std::forward<_Args>(__args)...);
+#  if _LIBCPP_STD_VER >= 17
+  return base::__before_begin()->__next_->__get_value();
+#  endif
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
-{
-    __node_allocator& __a = base::__alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
-    __node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
-    __h->__next_ = base::__before_begin()->__next_;
-    base::__before_begin()->__next_ = __h.release();
+void forward_list<_Tp, _Alloc>::push_front(value_type&& __v) {
+  base::__before_begin()->__next_ = this->__create_node(/* next = */ base::__before_begin()->__next_, std::move(__v));
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::push_front(const value_type& __v)
-{
-    __node_allocator& __a = base::__alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
-    __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
-    __h->__next_ = base::__before_begin()->__next_;
-    base::__before_begin()->__next_ = __h.release();
+void forward_list<_Tp, _Alloc>::push_front(const value_type& __v) {
+  base::__before_begin()->__next_ = this->__create_node(/* next = */ base::__before_begin()->__next_, __v);
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::pop_front()
-{
-    __node_allocator& __a = base::__alloc();
-    __node_pointer __p = base::__before_begin()->__next_;
-    base::__before_begin()->__next_ = __p->__next_;
-    __node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
-    __node_traits::deallocate(__a, __p, 1);
+void forward_list<_Tp, _Alloc>::pop_front() {
+  __node_pointer __p              = base::__before_begin()->__next_;
+  base::__before_begin()->__next_ = __p->__next_;
+  this->__delete_node(__p);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
@@ -1198,578 +1090,427 @@ forward_list<_Tp, _Alloc>::pop_front()
 template <class _Tp, class _Alloc>
 template <class... _Args>
 typename forward_list<_Tp, _Alloc>::iterator
-forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args)
-{
-    __begin_node_pointer const __r = __p.__get_begin();
-    __node_allocator& __a = base::__alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
-    __node_traits::construct(__a, _VSTD::addressof(__h->__value_),
-                                  _VSTD::forward<_Args>(__args)...);
-    __h->__next_ = __r->__next_;
-    __r->__next_ = __h.release();
-    return iterator(__r->__next_);
+forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args) {
+  __begin_node_pointer const __r = __p.__get_begin();
+  __r->__next_                   = this->__create_node(/* next = */ __r->__next_, std::forward<_Args>(__args)...);
+  return iterator(__r->__next_);
 }
 
 template <class _Tp, class _Alloc>
 typename forward_list<_Tp, _Alloc>::iterator
-forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
-{
-    __begin_node_pointer const __r = __p.__get_begin();
-    __node_allocator& __a = base::__alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
-    __node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
-    __h->__next_ = __r->__next_;
-    __r->__next_ = __h.release();
-    return iterator(__r->__next_);
+forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v) {
+  __begin_node_pointer const __r = __p.__get_begin();
+  __r->__next_                   = this->__create_node(/* next = */ __r->__next_, std::move(__v));
+  return iterator(__r->__next_);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
 typename forward_list<_Tp, _Alloc>::iterator
-forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, const value_type& __v)
-{
-    __begin_node_pointer const __r = __p.__get_begin();
-    __node_allocator& __a = base::__alloc();
-    typedef __allocator_destructor<__node_allocator> _Dp;
-    unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
-    __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
-    __h->__next_ = __r->__next_;
-    __r->__next_ = __h.release();
-    return iterator(__r->__next_);
+forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, const value_type& __v) {
+  __begin_node_pointer const __r = __p.__get_begin();
+  __r->__next_                   = this->__create_node(/* next = */ __r->__next_, __v);
+  return iterator(__r->__next_);
 }
 
 template <class _Tp, class _Alloc>
 typename forward_list<_Tp, _Alloc>::iterator
-forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
-                                        const value_type& __v)
-{
-    __begin_node_pointer __r = __p.__get_begin();
-    if (__n > 0)
-    {
-        __node_allocator& __a = base::__alloc();
-        typedef __allocator_destructor<__node_allocator> _Dp;
-        unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
-        __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
-        __node_pointer __first = __h.release();
-        __node_pointer __last = __first;
+forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n, const value_type& __v) {
+  __begin_node_pointer __r = __p.__get_begin();
+  if (__n > 0) {
+    __node_pointer __first = this->__create_node(/* next = */ nullptr, __v);
+    __node_pointer __last  = __first;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (--__n; __n != 0; --__n, __last = __last->__next_)
-            {
-                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
-                __last->__next_ = __h.release();
-            }
+      for (--__n; __n != 0; --__n, __last = __last->__next_) {
+        __last->__next_ = this->__create_node(/* next = */ nullptr, __v);
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            while (__first != nullptr)
-            {
-                __node_pointer __next = __first->__next_;
-                __node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
-                __node_traits::deallocate(__a, __first, 1);
-                __first = __next;
-            }
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __last->__next_ = __r->__next_;
-        __r->__next_ = __first;
-        __r = static_cast<__begin_node_pointer>(__last);
+    } catch (...) {
+      while (__first != nullptr) {
+        __node_pointer __next = __first->__next_;
+        this->__delete_node(__first);
+        __first = __next;
+      }
+      throw;
     }
-    return iterator(__r);
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __last->__next_ = __r->__next_;
+    __r->__next_    = __first;
+    __r             = static_cast<__begin_node_pointer>(__last);
+  }
+  return iterator(__r);
 }
 
 template <class _Tp, class _Alloc>
-template <class _InputIterator>
-__enable_if_t<__has_input_iterator_category<_InputIterator>::value, typename forward_list<_Tp, _Alloc>::iterator>
-forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
-                                        _InputIterator __f, _InputIterator __l)
-{
-    __begin_node_pointer __r = __p.__get_begin();
-    if (__f != __l)
-    {
-        __node_allocator& __a = base::__alloc();
-        typedef __allocator_destructor<__node_allocator> _Dp;
-        unique_ptr<__node, _Dp> __h(__node_traits::allocate(__a, 1), _Dp(__a, 1));
-        __node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
-        __node_pointer __first = __h.release();
-        __node_pointer __last = __first;
+template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> >
+typename forward_list<_Tp, _Alloc>::iterator
+forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, _InputIterator __f, _InputIterator __l) {
+  return __insert_after_with_sentinel(__p, std::move(__f), std::move(__l));
+}
+
+template <class _Tp, class _Alloc>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI typename forward_list<_Tp, _Alloc>::iterator
+forward_list<_Tp, _Alloc>::__insert_after_with_sentinel(const_iterator __p, _InputIterator __f, _Sentinel __l) {
+  __begin_node_pointer __r = __p.__get_begin();
+
+  if (__f != __l) {
+    __node_pointer __first = this->__create_node(/* next = */ nullptr, *__f);
+    __node_pointer __last  = __first;
+
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (++__f; __f != __l; ++__f, ((void)(__last = __last->__next_)))
-            {
-                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
-                __last->__next_ = __h.release();
-            }
+      for (++__f; __f != __l; ++__f, ((void)(__last = __last->__next_))) {
+        __last->__next_ = this->__create_node(/* next = */ nullptr, *__f);
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            while (__first != nullptr)
-            {
-                __node_pointer __next = __first->__next_;
-                __node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
-                __node_traits::deallocate(__a, __first, 1);
-                __first = __next;
-            }
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __last->__next_ = __r->__next_;
-        __r->__next_ = __first;
-        __r = static_cast<__begin_node_pointer>(__last);
+    } catch (...) {
+      while (__first != nullptr) {
+        __node_pointer __next = __first->__next_;
+        this->__delete_node(__first);
+        __first = __next;
+      }
+      throw;
     }
-    return iterator(__r);
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+
+    __last->__next_ = __r->__next_;
+    __r->__next_    = __first;
+    __r             = static_cast<__begin_node_pointer>(__last);
+  }
+
+  return iterator(__r);
+}
+
+template <class _Tp, class _Alloc>
+typename forward_list<_Tp, _Alloc>::iterator forward_list<_Tp, _Alloc>::erase_after(const_iterator __f) {
+  __begin_node_pointer __p = __f.__get_begin();
+  __node_pointer __n       = __p->__next_;
+  __p->__next_             = __n->__next_;
+  this->__delete_node(__n);
+  return iterator(__p->__next_);
 }
 
 template <class _Tp, class _Alloc>
 typename forward_list<_Tp, _Alloc>::iterator
-forward_list<_Tp, _Alloc>::erase_after(const_iterator __f)
-{
-    __begin_node_pointer __p = __f.__get_begin();
-    __node_pointer __n = __p->__next_;
-    __p->__next_ = __n->__next_;
-    __node_allocator& __a = base::__alloc();
-    __node_traits::destroy(__a, _VSTD::addressof(__n->__value_));
-    __node_traits::deallocate(__a, __n, 1);
-    return iterator(__p->__next_);
-}
+forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l) {
+  __node_pointer __e = __l.__get_unsafe_node_pointer();
+  if (__f != __l) {
+    __begin_node_pointer __bp = __f.__get_begin();
 
-template <class _Tp, class _Alloc>
-typename forward_list<_Tp, _Alloc>::iterator
-forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l)
-{
-    __node_pointer __e = __l.__get_unsafe_node_pointer();
-    if (__f != __l)
-    {
-        __begin_node_pointer __bp = __f.__get_begin();
-
-        __node_pointer __n = __bp->__next_;
-        if (__n != __e)
-        {
-            __bp->__next_ = __e;
-            __node_allocator& __a = base::__alloc();
-            do
-            {
-                __node_pointer __tmp = __n->__next_;
-                __node_traits::destroy(__a, _VSTD::addressof(__n->__value_));
-                __node_traits::deallocate(__a, __n, 1);
-                __n = __tmp;
-            } while (__n != __e);
-        }
+    __node_pointer __n = __bp->__next_;
+    if (__n != __e) {
+      __bp->__next_ = __e;
+      do {
+        __node_pointer __tmp = __n->__next_;
+        this->__delete_node(__n);
+        __n = __tmp;
+      } while (__n != __e);
     }
-    return iterator(__e);
+  }
+  return iterator(__e);
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::resize(size_type __n)
-{
-    size_type __sz = 0;
-    iterator __p = before_begin();
-    iterator __i = begin();
-    iterator __e = end();
-    for (; __i != __e && __sz < __n; ++__p, ++__i, ++__sz)
-        ;
-    if (__i != __e)
-        erase_after(__p, __e);
-    else
-    {
-        __n -= __sz;
-        if (__n > 0)
-        {
-            __node_allocator& __a = base::__alloc();
-            typedef __allocator_destructor<__node_allocator> _Dp;
-            unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
-            for (__begin_node_pointer __ptr = __p.__get_begin(); __n > 0; --__n,
-                                                         __ptr = __ptr->__next_as_begin())
-            {
-                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
-                __h->__next_ = nullptr;
-                __ptr->__next_ = __h.release();
-            }
-        }
+void forward_list<_Tp, _Alloc>::resize(size_type __n) {
+  size_type __sz = 0;
+  iterator __p   = before_begin();
+  iterator __i   = begin();
+  iterator __e   = end();
+  for (; __i != __e && __sz < __n; ++__p, ++__i, ++__sz)
+    ;
+  if (__i != __e)
+    erase_after(__p, __e);
+  else {
+    __n -= __sz;
+    if (__n > 0) {
+      for (__begin_node_pointer __ptr = __p.__get_begin(); __n > 0; --__n, __ptr = __ptr->__next_as_begin()) {
+        __ptr->__next_ = this->__create_node(/* next = */ nullptr);
+      }
     }
+  }
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
-{
-    size_type __sz = 0;
-    iterator __p = before_begin();
-    iterator __i = begin();
-    iterator __e = end();
-    for (; __i != __e && __sz < __n; ++__p, ++__i, ++__sz)
-        ;
-    if (__i != __e)
-        erase_after(__p, __e);
-    else
-    {
-        __n -= __sz;
-        if (__n > 0)
-        {
-            __node_allocator& __a = base::__alloc();
-            typedef __allocator_destructor<__node_allocator> _Dp;
-            unique_ptr<__node, _Dp> __h(nullptr, _Dp(__a, 1));
-            for (__begin_node_pointer __ptr = __p.__get_begin(); __n > 0; --__n,
-                                                         __ptr = __ptr->__next_as_begin())
-            {
-                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
-                __h->__next_ = nullptr;
-                __ptr->__next_ = __h.release();
-            }
-        }
+void forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v) {
+  size_type __sz = 0;
+  iterator __p   = before_begin();
+  iterator __i   = begin();
+  iterator __e   = end();
+  for (; __i != __e && __sz < __n; ++__p, ++__i, ++__sz)
+    ;
+  if (__i != __e)
+    erase_after(__p, __e);
+  else {
+    __n -= __sz;
+    if (__n > 0) {
+      for (__begin_node_pointer __ptr = __p.__get_begin(); __n > 0; --__n, __ptr = __ptr->__next_as_begin()) {
+        __ptr->__next_ = this->__create_node(/* next = */ nullptr, __v);
+      }
     }
+  }
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-                                        forward_list& __x)
-{
-    if (!__x.empty())
-    {
-        if (__p.__get_begin()->__next_ != nullptr)
-        {
-            const_iterator __lm1 = __x.before_begin();
-            while (__lm1.__get_begin()->__next_ != nullptr)
-                ++__lm1;
-            __lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
-        }
-        __p.__get_begin()->__next_ = __x.__before_begin()->__next_;
-        __x.__before_begin()->__next_ = nullptr;
+void forward_list<_Tp, _Alloc>::splice_after(const_iterator __p, forward_list& __x) {
+  if (!__x.empty()) {
+    if (__p.__get_begin()->__next_ != nullptr) {
+      const_iterator __lm1 = __x.before_begin();
+      while (__lm1.__get_begin()->__next_ != nullptr)
+        ++__lm1;
+      __lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
     }
+    __p.__get_begin()->__next_    = __x.__before_begin()->__next_;
+    __x.__before_begin()->__next_ = nullptr;
+  }
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-                                        forward_list& /*__other*/,
-                                        const_iterator __i)
-{
-    const_iterator __lm1 = _VSTD::next(__i);
-    if (__p != __i && __p != __lm1)
-    {
-        __i.__get_begin()->__next_ = __lm1.__get_begin()->__next_;
-        __lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
-        __p.__get_begin()->__next_ = __lm1.__get_unsafe_node_pointer();
+void forward_list<_Tp, _Alloc>::splice_after(const_iterator __p, forward_list& /*__other*/, const_iterator __i) {
+  const_iterator __lm1 = std::next(__i);
+  if (__p != __i && __p != __lm1) {
+    __i.__get_begin()->__next_   = __lm1.__get_begin()->__next_;
+    __lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
+    __p.__get_begin()->__next_   = __lm1.__get_unsafe_node_pointer();
+  }
+}
+
+template <class _Tp, class _Alloc>
+void forward_list<_Tp, _Alloc>::splice_after(
+    const_iterator __p, forward_list& /*__other*/, const_iterator __f, const_iterator __l) {
+  if (__f != __l && __p != __f) {
+    const_iterator __lm1 = __f;
+    while (__lm1.__get_begin()->__next_ != __l.__get_begin())
+      ++__lm1;
+    if (__f != __lm1) {
+      __lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
+      __p.__get_begin()->__next_   = __f.__get_begin()->__next_;
+      __f.__get_begin()->__next_   = __l.__get_unsafe_node_pointer();
     }
+  }
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-                                        forward_list& /*__other*/,
-                                        const_iterator __f, const_iterator __l)
-{
-    if (__f != __l && __p != __f)
-    {
-        const_iterator __lm1 = __f;
-        while (__lm1.__get_begin()->__next_ != __l.__get_begin())
-            ++__lm1;
-        if (__f != __lm1)
-        {
-            __lm1.__get_begin()->__next_ = __p.__get_begin()->__next_;
-            __p.__get_begin()->__next_ = __f.__get_begin()->__next_;
-            __f.__get_begin()->__next_ = __l.__get_unsafe_node_pointer();
-        }
-    }
+inline _LIBCPP_HIDE_FROM_ABI void forward_list<_Tp, _Alloc>::splice_after(const_iterator __p, forward_list&& __x) {
+  splice_after(__p, __x);
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-                                        forward_list&& __x)
-{
-    splice_after(__p, __x);
+inline _LIBCPP_HIDE_FROM_ABI void
+forward_list<_Tp, _Alloc>::splice_after(const_iterator __p, forward_list&& __x, const_iterator __i) {
+  splice_after(__p, __x, __i);
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-                                        forward_list&& __x,
-                                        const_iterator __i)
-{
-    splice_after(__p, __x, __i);
+inline _LIBCPP_HIDE_FROM_ABI void forward_list<_Tp, _Alloc>::splice_after(
+    const_iterator __p, forward_list&& __x, const_iterator __f, const_iterator __l) {
+  splice_after(__p, __x, __f, __l);
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-                                        forward_list&& __x,
-                                        const_iterator __f, const_iterator __l)
-{
-    splice_after(__p, __x, __f, __l);
-}
+typename forward_list<_Tp, _Alloc>::__remove_return_type forward_list<_Tp, _Alloc>::remove(const value_type& __v) {
+  forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
+  typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
+  const iterator __e                                            = end();
+  for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;) {
+    if (__i.__get_begin()->__next_->__get_value() == __v) {
+      ++__count_removed;
+      iterator __j = std::next(__i, 2);
+      for (; __j != __e && *__j == __v; ++__j)
+        ++__count_removed;
+      __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
+      if (__j == __e)
+        break;
+      __i = __j;
+    } else
+      ++__i;
+  }
 
-template <class _Tp, class _Alloc>
-typename forward_list<_Tp, _Alloc>::__remove_return_type
-forward_list<_Tp, _Alloc>::remove(const value_type& __v)
-{
-    forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
-    typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
-    const iterator __e = end();
-    for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
-    {
-        if (__i.__get_begin()->__next_->__value_ == __v)
-        {
-            ++__count_removed;
-            iterator __j = _VSTD::next(__i, 2);
-            for (; __j != __e && *__j == __v; ++__j)
-                ++__count_removed;
-            __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
-            if (__j == __e)
-                break;
-            __i = __j;
-        }
-        else
-            ++__i;
-    }
-
-    return (__remove_return_type) __count_removed;
+  return (__remove_return_type)__count_removed;
 }
 
 template <class _Tp, class _Alloc>
 template <class _Predicate>
-typename forward_list<_Tp, _Alloc>::__remove_return_type
-forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
-{
-    forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
-    typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
-    const iterator __e = end();
-    for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
-    {
-        if (__pred(__i.__get_begin()->__next_->__value_))
-        {
-            ++__count_removed;
-            iterator __j = _VSTD::next(__i, 2);
-            for (; __j != __e && __pred(*__j); ++__j)
-                ++__count_removed;
-            __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
-            if (__j == __e)
-                break;
-            __i = __j;
-        }
-        else
-            ++__i;
-    }
+typename forward_list<_Tp, _Alloc>::__remove_return_type forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred) {
+  forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
+  typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
+  const iterator __e                                            = end();
+  for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;) {
+    if (__pred(__i.__get_begin()->__next_->__get_value())) {
+      ++__count_removed;
+      iterator __j = std::next(__i, 2);
+      for (; __j != __e && __pred(*__j); ++__j)
+        ++__count_removed;
+      __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
+      if (__j == __e)
+        break;
+      __i = __j;
+    } else
+      ++__i;
+  }
 
-    return (__remove_return_type) __count_removed;
+  return (__remove_return_type)__count_removed;
 }
 
 template <class _Tp, class _Alloc>
 template <class _BinaryPredicate>
 typename forward_list<_Tp, _Alloc>::__remove_return_type
-forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
-{
-    forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
-    typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
-    for (iterator __i = begin(), __e = end(); __i != __e;)
-    {
-        iterator __j = _VSTD::next(__i);
-        for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
-            ++__count_removed;
-        if (__i.__get_begin()->__next_ != __j.__get_unsafe_node_pointer())
-            __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
-        __i = __j;
-    }
+forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred) {
+  forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
+  typename forward_list<_Tp, _Alloc>::size_type __count_removed = 0;
+  for (iterator __i = begin(), __e = end(); __i != __e;) {
+    iterator __j = std::next(__i);
+    for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
+      ++__count_removed;
+    if (__i.__get_begin()->__next_ != __j.__get_unsafe_node_pointer())
+      __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
+    __i = __j;
+  }
 
-    return (__remove_return_type) __count_removed;
+  return (__remove_return_type)__count_removed;
 }
 
 template <class _Tp, class _Alloc>
 template <class _Compare>
-void
-forward_list<_Tp, _Alloc>::merge(forward_list& __x, _Compare __comp)
-{
-    if (this != _VSTD::addressof(__x))
-    {
-        base::__before_begin()->__next_ = __merge(base::__before_begin()->__next_,
-                                                    __x.__before_begin()->__next_,
-                                                    __comp);
-        __x.__before_begin()->__next_ = nullptr;
-    }
+void forward_list<_Tp, _Alloc>::merge(forward_list& __x, _Compare __comp) {
+  if (this != std::addressof(__x)) {
+    base::__before_begin()->__next_ = __merge(base::__before_begin()->__next_, __x.__before_begin()->__next_, __comp);
+    __x.__before_begin()->__next_   = nullptr;
+  }
 }
 
 template <class _Tp, class _Alloc>
 template <class _Compare>
 typename forward_list<_Tp, _Alloc>::__node_pointer
-forward_list<_Tp, _Alloc>::__merge(__node_pointer __f1, __node_pointer __f2,
-                                   _Compare& __comp)
-{
-    if (__f1 == nullptr)
-        return __f2;
-    if (__f2 == nullptr)
-        return __f1;
-    __node_pointer __r;
-    if (__comp(__f2->__value_, __f1->__value_))
-    {
-        __node_pointer __t = __f2;
-        while (__t->__next_ != nullptr &&
-                             __comp(__t->__next_->__value_, __f1->__value_))
-            __t = __t->__next_;
-        __r = __f2;
-        __f2 = __t->__next_;
-        __t->__next_ = __f1;
+forward_list<_Tp, _Alloc>::__merge(__node_pointer __f1, __node_pointer __f2, _Compare& __comp) {
+  if (__f1 == nullptr)
+    return __f2;
+  if (__f2 == nullptr)
+    return __f1;
+  __node_pointer __r;
+  if (__comp(__f2->__get_value(), __f1->__get_value())) {
+    __node_pointer __t = __f2;
+    while (__t->__next_ != nullptr && __comp(__t->__next_->__get_value(), __f1->__get_value()))
+      __t = __t->__next_;
+    __r          = __f2;
+    __f2         = __t->__next_;
+    __t->__next_ = __f1;
+  } else
+    __r = __f1;
+  __node_pointer __p = __f1;
+  __f1               = __f1->__next_;
+  while (__f1 != nullptr && __f2 != nullptr) {
+    if (__comp(__f2->__get_value(), __f1->__get_value())) {
+      __node_pointer __t = __f2;
+      while (__t->__next_ != nullptr && __comp(__t->__next_->__get_value(), __f1->__get_value()))
+        __t = __t->__next_;
+      __p->__next_ = __f2;
+      __f2         = __t->__next_;
+      __t->__next_ = __f1;
     }
-    else
-        __r = __f1;
-    __node_pointer __p = __f1;
+    __p  = __f1;
     __f1 = __f1->__next_;
-    while (__f1 != nullptr && __f2 != nullptr)
-    {
-        if (__comp(__f2->__value_, __f1->__value_))
-        {
-            __node_pointer __t = __f2;
-            while (__t->__next_ != nullptr &&
-                                 __comp(__t->__next_->__value_, __f1->__value_))
-                __t = __t->__next_;
-            __p->__next_ = __f2;
-            __f2 = __t->__next_;
-            __t->__next_ = __f1;
-        }
-        __p = __f1;
-        __f1 = __f1->__next_;
-    }
-    if (__f2 != nullptr)
-        __p->__next_ = __f2;
-    return __r;
+  }
+  if (__f2 != nullptr)
+    __p->__next_ = __f2;
+  return __r;
 }
 
 template <class _Tp, class _Alloc>
 template <class _Compare>
-inline
-void
-forward_list<_Tp, _Alloc>::sort(_Compare __comp)
-{
-    base::__before_begin()->__next_ = __sort(base::__before_begin()->__next_,
-                                       _VSTD::distance(begin(), end()), __comp);
+inline void forward_list<_Tp, _Alloc>::sort(_Compare __comp) {
+  base::__before_begin()->__next_ = __sort(base::__before_begin()->__next_, std::distance(begin(), end()), __comp);
 }
 
 template <class _Tp, class _Alloc>
 template <class _Compare>
 typename forward_list<_Tp, _Alloc>::__node_pointer
-forward_list<_Tp, _Alloc>::__sort(__node_pointer __f1, difference_type __sz,
-                                  _Compare& __comp)
-{
-    switch (__sz)
-    {
-    case 0:
-    case 1:
-        return __f1;
-    case 2:
-        if (__comp(__f1->__next_->__value_, __f1->__value_))
-        {
-            __node_pointer __t = __f1->__next_;
-            __t->__next_ = __f1;
-            __f1->__next_ = nullptr;
-            __f1 = __t;
-        }
-        return __f1;
+forward_list<_Tp, _Alloc>::__sort(__node_pointer __f1, difference_type __sz, _Compare& __comp) {
+  switch (__sz) {
+  case 0:
+  case 1:
+    return __f1;
+  case 2:
+    if (__comp(__f1->__next_->__get_value(), __f1->__get_value())) {
+      __node_pointer __t = __f1->__next_;
+      __t->__next_       = __f1;
+      __f1->__next_      = nullptr;
+      __f1               = __t;
     }
-    difference_type __sz1 = __sz / 2;
-    difference_type __sz2 = __sz - __sz1;
-    __node_pointer __t = _VSTD::next(iterator(__f1), __sz1 - 1).__get_unsafe_node_pointer();
-    __node_pointer __f2 = __t->__next_;
-    __t->__next_ = nullptr;
-    return __merge(__sort(__f1, __sz1, __comp),
-                   __sort(__f2, __sz2, __comp), __comp);
+    return __f1;
+  }
+  difference_type __sz1 = __sz / 2;
+  difference_type __sz2 = __sz - __sz1;
+  __node_pointer __t    = std::next(iterator(__f1), __sz1 - 1).__get_unsafe_node_pointer();
+  __node_pointer __f2   = __t->__next_;
+  __t->__next_          = nullptr;
+  return __merge(__sort(__f1, __sz1, __comp), __sort(__f2, __sz2, __comp), __comp);
 }
 
 template <class _Tp, class _Alloc>
-void
-forward_list<_Tp, _Alloc>::reverse() _NOEXCEPT
-{
-    __node_pointer __p = base::__before_begin()->__next_;
-    if (__p != nullptr)
-    {
-        __node_pointer __f = __p->__next_;
-        __p->__next_ = nullptr;
-        while (__f != nullptr)
-        {
-            __node_pointer __t = __f->__next_;
-            __f->__next_ = __p;
-            __p = __f;
-            __f = __t;
-        }
-        base::__before_begin()->__next_ = __p;
+void forward_list<_Tp, _Alloc>::reverse() _NOEXCEPT {
+  __node_pointer __p = base::__before_begin()->__next_;
+  if (__p != nullptr) {
+    __node_pointer __f = __p->__next_;
+    __p->__next_       = nullptr;
+    while (__f != nullptr) {
+      __node_pointer __t = __f->__next_;
+      __f->__next_       = __p;
+      __p                = __f;
+      __f                = __t;
     }
+    base::__before_begin()->__next_ = __p;
+  }
 }
 
 template <class _Tp, class _Alloc>
-_LIBCPP_HIDE_FROM_ABI
-bool operator==(const forward_list<_Tp, _Alloc>& __x,
-                const forward_list<_Tp, _Alloc>& __y)
-{
-    typedef forward_list<_Tp, _Alloc> _Cp;
-    typedef typename _Cp::const_iterator _Ip;
-    _Ip __ix = __x.begin();
-    _Ip __ex = __x.end();
-    _Ip __iy = __y.begin();
-    _Ip __ey = __y.end();
-    for (; __ix != __ex && __iy != __ey; ++__ix, ++__iy)
-        if (!(*__ix == *__iy))
-            return false;
-    return (__ix == __ex) == (__iy == __ey);
+_LIBCPP_HIDE_FROM_ABI bool operator==(const forward_list<_Tp, _Alloc>& __x, const forward_list<_Tp, _Alloc>& __y) {
+  typedef forward_list<_Tp, _Alloc> _Cp;
+  typedef typename _Cp::const_iterator _Ip;
+  _Ip __ix = __x.begin();
+  _Ip __ex = __x.end();
+  _Ip __iy = __y.begin();
+  _Ip __ey = __y.end();
+  for (; __ix != __ex && __iy != __ey; ++__ix, ++__iy)
+    if (!(*__ix == *__iy))
+      return false;
+  return (__ix == __ex) == (__iy == __ey);
 }
 
 #if _LIBCPP_STD_VER <= 17
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator!=(const forward_list<_Tp, _Alloc>& __x,
-                const forward_list<_Tp, _Alloc>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const forward_list<_Tp, _Alloc>& __x, const forward_list<_Tp, _Alloc>& __y) {
+  return !(__x == __y);
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator< (const forward_list<_Tp, _Alloc>& __x,
-                const forward_list<_Tp, _Alloc>& __y)
-{
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(),
-                                         __y.begin(), __y.end());
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(const forward_list<_Tp, _Alloc>& __x, const forward_list<_Tp, _Alloc>& __y) {
+  return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator> (const forward_list<_Tp, _Alloc>& __x,
-                const forward_list<_Tp, _Alloc>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(const forward_list<_Tp, _Alloc>& __x, const forward_list<_Tp, _Alloc>& __y) {
+  return __y < __x;
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator>=(const forward_list<_Tp, _Alloc>& __x,
-                const forward_list<_Tp, _Alloc>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(const forward_list<_Tp, _Alloc>& __x, const forward_list<_Tp, _Alloc>& __y) {
+  return !(__x < __y);
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator<=(const forward_list<_Tp, _Alloc>& __x,
-                const forward_list<_Tp, _Alloc>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(const forward_list<_Tp, _Alloc>& __x, const forward_list<_Tp, _Alloc>& __y) {
+  return !(__y < __x);
 }
 
 #else // #if _LIBCPP_STD_VER <= 17
@@ -1777,34 +1518,29 @@ bool operator<=(const forward_list<_Tp, _Alloc>& __x,
 template <class _Tp, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI __synth_three_way_result<_Tp>
 operator<=>(const forward_list<_Tp, _Allocator>& __x, const forward_list<_Tp, _Allocator>& __y) {
-    return std::lexicographical_compare_three_way(
-        __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way<_Tp, _Tp>);
+  return std::lexicographical_compare_three_way(
+      __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
 }
 
 #endif // #if _LIBCPP_STD_VER <= 17
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-    typename forward_list<_Tp, _Allocator>::size_type
-    erase_if(forward_list<_Tp, _Allocator>& __c, _Predicate __pred) {
+inline _LIBCPP_HIDE_FROM_ABI typename forward_list<_Tp, _Allocator>::size_type
+erase_if(forward_list<_Tp, _Allocator>& __c, _Predicate __pred) {
   return __c.remove_if(__pred);
 }
 
 template <class _Tp, class _Allocator, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY
-    typename forward_list<_Tp, _Allocator>::size_type
-    erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v) {
-  return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
+inline _LIBCPP_HIDE_FROM_ABI typename forward_list<_Tp, _Allocator>::size_type
+erase(forward_list<_Tp, _Allocator>& __c, const _Up& __v) {
+  return std::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
 }
 #endif
 
@@ -1814,7 +1550,7 @@ _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _ValueT>
-using forward_list = std::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
+using forward_list _LIBCPP_AVAILABILITY_PMR = std::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
@@ -1825,10 +1561,13 @@ _LIBCPP_POP_MACROS
 #  include <algorithm>
 #  include <atomic>
 #  include <concepts>
+#  include <cstdint>
 #  include <cstdlib>
+#  include <cstring>
 #  include <functional>
 #  include <iosfwd>
 #  include <iterator>
+#  include <stdexcept>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
diff --git a/third_party/libcxx/fs/directory_entry.cpp b/third_party/libcxx/fs/directory_entry.cpp
new file mode 100644
index 000000000..152715243
--- /dev/null
+++ b/third_party/libcxx/fs/directory_entry.cpp
@@ -0,0 +1,73 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+#include <cstdint>
+#include <filesystem>
+#include <system_error>
+
+#include "file_descriptor.h"
+#include "posix_compat.h"
+#include "time_utils.h"
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+error_code directory_entry::__do_refresh() noexcept {
+  __data_.__reset();
+  error_code failure_ec;
+
+  detail::StatT full_st;
+  file_status st = detail::posix_lstat(__p_, full_st, &failure_ec);
+  if (!status_known(st)) {
+    __data_.__reset();
+    return failure_ec;
+  }
+
+  if (!filesystem::exists(st) || !filesystem::is_symlink(st)) {
+    __data_.__cache_type_    = directory_entry::_RefreshNonSymlink;
+    __data_.__type_          = st.type();
+    __data_.__non_sym_perms_ = st.permissions();
+  } else { // we have a symlink
+    __data_.__sym_perms_ = st.permissions();
+    // Get the information about the linked entity.
+    // Ignore errors from stat, since we don't want errors regarding symlink
+    // resolution to be reported to the user.
+    error_code ignored_ec;
+    st = detail::posix_stat(__p_, full_st, &ignored_ec);
+
+    __data_.__type_          = st.type();
+    __data_.__non_sym_perms_ = st.permissions();
+
+    // If we failed to resolve the link, then only partially populate the
+    // cache.
+    if (!status_known(st)) {
+      __data_.__cache_type_ = directory_entry::_RefreshSymlinkUnresolved;
+      return error_code{};
+    }
+    // Otherwise, we resolved the link, potentially as not existing.
+    // That's OK.
+    __data_.__cache_type_ = directory_entry::_RefreshSymlink;
+  }
+
+  if (filesystem::is_regular_file(st))
+    __data_.__size_ = static_cast<uintmax_t>(full_st.st_size);
+
+  if (filesystem::exists(st)) {
+    __data_.__nlink_ = static_cast<uintmax_t>(full_st.st_nlink);
+
+    // Attempt to extract the mtime, and fail if it's not representable using
+    // file_time_type. For now we ignore the error, as we'll report it when
+    // the value is actually used.
+    error_code ignored_ec;
+    __data_.__write_time_ = detail::__extract_last_write_time(__p_, full_st, &ignored_ec);
+  }
+
+  return failure_ec;
+}
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
diff --git a/third_party/libcxx/fs/directory_iterator.cpp b/third_party/libcxx/fs/directory_iterator.cpp
new file mode 100644
index 000000000..a82816c60
--- /dev/null
+++ b/third_party/libcxx/fs/directory_iterator.cpp
@@ -0,0 +1,322 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__assert>
+#include <__config>
+#include <errno.h>
+#include <filesystem>
+#include <stack>
+#include <utility>
+
+#include "error.h"
+#include "file_descriptor.h"
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <windows.h>
+#else
+#  include <dirent.h> // for DIR & friends
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+using detail::ErrorHandler;
+
+#if defined(_LIBCPP_WIN32API)
+class __dir_stream {
+public:
+  __dir_stream()                               = delete;
+  __dir_stream& operator=(const __dir_stream&) = delete;
+
+  __dir_stream(__dir_stream&& __ds) noexcept
+      : __stream_(__ds.__stream_), __root_(std::move(__ds.__root_)), __entry_(std::move(__ds.__entry_)) {
+    __ds.__stream_ = INVALID_HANDLE_VALUE;
+  }
+
+  __dir_stream(const path& root, directory_options opts, error_code& ec)
+      : __stream_(INVALID_HANDLE_VALUE), __root_(root) {
+    if (root.native().empty()) {
+      ec = make_error_code(errc::no_such_file_or_directory);
+      return;
+    }
+    __stream_ = ::FindFirstFileW((root / "*").c_str(), &__data_);
+    if (__stream_ == INVALID_HANDLE_VALUE) {
+      ec                                  = detail::make_windows_error(GetLastError());
+      const bool ignore_permission_denied = bool(opts & directory_options::skip_permission_denied);
+      if (ignore_permission_denied && ec == errc::permission_denied)
+        ec.clear();
+      return;
+    }
+    if (!assign())
+      advance(ec);
+  }
+
+  ~__dir_stream() noexcept {
+    if (__stream_ == INVALID_HANDLE_VALUE)
+      return;
+    close();
+  }
+
+  bool good() const noexcept { return __stream_ != INVALID_HANDLE_VALUE; }
+
+  bool advance(error_code& ec) {
+    while (::FindNextFileW(__stream_, &__data_)) {
+      if (assign())
+        return true;
+    }
+    close();
+    return false;
+  }
+
+  bool assign() {
+    if (!wcscmp(__data_.cFileName, L".") || !wcscmp(__data_.cFileName, L".."))
+      return false;
+    // FIXME: Cache more of this
+    // directory_entry::__cached_data cdata;
+    // cdata.__type_ = get_file_type(__data_);
+    // cdata.__size_ = get_file_size(__data_);
+    // cdata.__write_time_ = get_write_time(__data_);
+    __entry_.__assign_iter_entry(
+        __root_ / __data_.cFileName, directory_entry::__create_iter_result(detail::get_file_type(__data_)));
+    return true;
+  }
+
+private:
+  error_code close() noexcept {
+    error_code ec;
+    if (!::FindClose(__stream_))
+      ec = detail::make_windows_error(GetLastError());
+    __stream_ = INVALID_HANDLE_VALUE;
+    return ec;
+  }
+
+  HANDLE __stream_{INVALID_HANDLE_VALUE};
+  WIN32_FIND_DATAW __data_;
+
+public:
+  path __root_;
+  directory_entry __entry_;
+};
+#else
+class __dir_stream {
+public:
+  __dir_stream()                               = delete;
+  __dir_stream& operator=(const __dir_stream&) = delete;
+
+  __dir_stream(__dir_stream&& other) noexcept
+      : __stream_(other.__stream_), __root_(std::move(other.__root_)), __entry_(std::move(other.__entry_)) {
+    other.__stream_ = nullptr;
+  }
+
+  __dir_stream(const path& root, directory_options opts, error_code& ec) : __stream_(nullptr), __root_(root) {
+    if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
+      ec                      = detail::capture_errno();
+      const bool allow_eacces = bool(opts & directory_options::skip_permission_denied);
+      if (allow_eacces && ec == errc::permission_denied)
+        ec.clear();
+      return;
+    }
+    advance(ec);
+  }
+
+  ~__dir_stream() noexcept {
+    if (__stream_)
+      close();
+  }
+
+  bool good() const noexcept { return __stream_ != nullptr; }
+
+  bool advance(error_code& ec) {
+    while (true) {
+      auto str_type_pair = detail::posix_readdir(__stream_, ec);
+      auto& str          = str_type_pair.first;
+      if (str == "." || str == "..") {
+        continue;
+      } else if (ec || str.empty()) {
+        close();
+        return false;
+      } else {
+        __entry_.__assign_iter_entry(__root_ / str, directory_entry::__create_iter_result(str_type_pair.second));
+        return true;
+      }
+    }
+  }
+
+private:
+  error_code close() noexcept {
+    error_code m_ec;
+    if (::closedir(__stream_) == -1)
+      m_ec = detail::capture_errno();
+    __stream_ = nullptr;
+    return m_ec;
+  }
+
+  DIR* __stream_{nullptr};
+
+public:
+  path __root_;
+  directory_entry __entry_;
+};
+#endif
+
+// directory_iterator
+
+directory_iterator::directory_iterator(const path& p, error_code* ec, directory_options opts) {
+  ErrorHandler<void> err("directory_iterator::directory_iterator(...)", ec, &p);
+
+  error_code m_ec;
+  __imp_ = make_shared<__dir_stream>(p, opts, m_ec);
+  if (ec)
+    *ec = m_ec;
+  if (!__imp_->good()) {
+    __imp_.reset();
+    if (m_ec)
+      err.report(m_ec);
+  }
+}
+
+directory_iterator& directory_iterator::__increment(error_code* ec) {
+  _LIBCPP_ASSERT_NON_NULL(__imp_ != nullptr, "Attempting to increment an invalid iterator");
+  ErrorHandler<void> err("directory_iterator::operator++()", ec);
+
+  error_code m_ec;
+  if (!__imp_->advance(m_ec)) {
+    path root = std::move(__imp_->__root_);
+    __imp_.reset();
+    if (m_ec)
+      err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str());
+  }
+  return *this;
+}
+
+directory_entry const& directory_iterator::__dereference() const {
+  _LIBCPP_ASSERT_NON_NULL(__imp_ != nullptr, "Attempting to dereference an invalid iterator");
+  return __imp_->__entry_;
+}
+
+// recursive_directory_iterator
+
+struct recursive_directory_iterator::__shared_imp {
+  stack<__dir_stream> __stack_;
+  directory_options __options_;
+};
+
+recursive_directory_iterator::recursive_directory_iterator(const path& p, directory_options opt, error_code* ec)
+    : __imp_(nullptr), __rec_(true) {
+  ErrorHandler<void> err("recursive_directory_iterator", ec, &p);
+
+  error_code m_ec;
+  __dir_stream new_s(p, opt, m_ec);
+  if (m_ec)
+    err.report(m_ec);
+  if (m_ec || !new_s.good())
+    return;
+
+  __imp_             = make_shared<__shared_imp>();
+  __imp_->__options_ = opt;
+  __imp_->__stack_.push(std::move(new_s));
+}
+
+void recursive_directory_iterator::__pop(error_code* ec) {
+  _LIBCPP_ASSERT_NON_NULL(__imp_ != nullptr, "Popping the end iterator");
+  if (ec)
+    ec->clear();
+  __imp_->__stack_.pop();
+  if (__imp_->__stack_.size() == 0)
+    __imp_.reset();
+  else
+    __advance(ec);
+}
+
+directory_options recursive_directory_iterator::options() const { return __imp_->__options_; }
+
+int recursive_directory_iterator::depth() const { return __imp_->__stack_.size() - 1; }
+
+const directory_entry& recursive_directory_iterator::__dereference() const { return __imp_->__stack_.top().__entry_; }
+
+recursive_directory_iterator& recursive_directory_iterator::__increment(error_code* ec) {
+  if (ec)
+    ec->clear();
+  if (recursion_pending()) {
+    if (__try_recursion(ec) || (ec && *ec))
+      return *this;
+  }
+  __rec_ = true;
+  __advance(ec);
+  return *this;
+}
+
+void recursive_directory_iterator::__advance(error_code* ec) {
+  ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec);
+
+  const directory_iterator end_it;
+  auto& stack = __imp_->__stack_;
+  error_code m_ec;
+  while (stack.size() > 0) {
+    if (stack.top().advance(m_ec))
+      return;
+    if (m_ec)
+      break;
+    stack.pop();
+  }
+
+  if (m_ec) {
+    path root = std::move(stack.top().__root_);
+    __imp_.reset();
+    err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str());
+  } else {
+    __imp_.reset();
+  }
+}
+
+bool recursive_directory_iterator::__try_recursion(error_code* ec) {
+  ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec);
+
+  bool rec_sym = bool(options() & directory_options::follow_directory_symlink);
+
+  auto& curr_it = __imp_->__stack_.top();
+
+  bool skip_rec = false;
+  error_code m_ec;
+  if (!rec_sym) {
+    file_status st(curr_it.__entry_.__get_sym_ft(&m_ec));
+    if (m_ec && status_known(st))
+      m_ec.clear();
+    if (m_ec || is_symlink(st) || !is_directory(st))
+      skip_rec = true;
+  } else {
+    file_status st(curr_it.__entry_.__get_ft(&m_ec));
+    if (m_ec && status_known(st))
+      m_ec.clear();
+    if (m_ec || !is_directory(st))
+      skip_rec = true;
+  }
+
+  if (!skip_rec) {
+    __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
+    if (new_it.good()) {
+      __imp_->__stack_.push(std::move(new_it));
+      return true;
+    }
+  }
+  if (m_ec) {
+    const bool allow_eacess = bool(__imp_->__options_ & directory_options::skip_permission_denied);
+    if (m_ec == errc::permission_denied && allow_eacess) {
+      if (ec)
+        ec->clear();
+    } else {
+      path at_ent = std::move(curr_it.__entry_.__p_);
+      __imp_.reset();
+      err.report(m_ec, "attempting recursion into " PATH_CSTR_FMT, at_ent.c_str());
+    }
+  }
+  return false;
+}
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
diff --git a/third_party/libcxx/fs/error.h b/third_party/libcxx/fs/error.h
new file mode 100644
index 000000000..ecbfc1f3f
--- /dev/null
+++ b/third_party/libcxx/fs/error.h
@@ -0,0 +1,232 @@
+//===----------------------------------------------------------------------===////
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===////
+
+#ifndef FILESYSTEM_ERROR_H
+#define FILESYSTEM_ERROR_H
+
+#include <__assert>
+#include <__config>
+#include <cerrno>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <filesystem>
+#include <string>
+#include <system_error>
+#include <utility> // __libcpp_unreachable
+
+#include "format_string.h"
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <windows.h> // ERROR_* macros
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+namespace detail {
+
+#if defined(_LIBCPP_WIN32API)
+
+inline errc __win_err_to_errc(int err) {
+  constexpr struct {
+    DWORD win;
+    errc errc;
+  } win_error_mapping[] = {
+      {ERROR_ACCESS_DENIED, errc::permission_denied},
+      {ERROR_ALREADY_EXISTS, errc::file_exists},
+      {ERROR_BAD_NETPATH, errc::no_such_file_or_directory},
+      {ERROR_BAD_PATHNAME, errc::no_such_file_or_directory},
+      {ERROR_BAD_UNIT, errc::no_such_device},
+      {ERROR_BROKEN_PIPE, errc::broken_pipe},
+      {ERROR_BUFFER_OVERFLOW, errc::filename_too_long},
+      {ERROR_BUSY, errc::device_or_resource_busy},
+      {ERROR_BUSY_DRIVE, errc::device_or_resource_busy},
+      {ERROR_CANNOT_MAKE, errc::permission_denied},
+      {ERROR_CANTOPEN, errc::io_error},
+      {ERROR_CANTREAD, errc::io_error},
+      {ERROR_CANTWRITE, errc::io_error},
+      {ERROR_CURRENT_DIRECTORY, errc::permission_denied},
+      {ERROR_DEV_NOT_EXIST, errc::no_such_device},
+      {ERROR_DEVICE_IN_USE, errc::device_or_resource_busy},
+      {ERROR_DIR_NOT_EMPTY, errc::directory_not_empty},
+      {ERROR_DIRECTORY, errc::invalid_argument},
+      {ERROR_DISK_FULL, errc::no_space_on_device},
+      {ERROR_FILE_EXISTS, errc::file_exists},
+      {ERROR_FILE_NOT_FOUND, errc::no_such_file_or_directory},
+      {ERROR_HANDLE_DISK_FULL, errc::no_space_on_device},
+      {ERROR_INVALID_ACCESS, errc::permission_denied},
+      {ERROR_INVALID_DRIVE, errc::no_such_device},
+      {ERROR_INVALID_FUNCTION, errc::function_not_supported},
+      {ERROR_INVALID_HANDLE, errc::invalid_argument},
+      {ERROR_INVALID_NAME, errc::no_such_file_or_directory},
+      {ERROR_INVALID_PARAMETER, errc::invalid_argument},
+      {ERROR_LOCK_VIOLATION, errc::no_lock_available},
+      {ERROR_LOCKED, errc::no_lock_available},
+      {ERROR_NEGATIVE_SEEK, errc::invalid_argument},
+      {ERROR_NOACCESS, errc::permission_denied},
+      {ERROR_NOT_ENOUGH_MEMORY, errc::not_enough_memory},
+      {ERROR_NOT_READY, errc::resource_unavailable_try_again},
+      {ERROR_NOT_SAME_DEVICE, errc::cross_device_link},
+      {ERROR_NOT_SUPPORTED, errc::not_supported},
+      {ERROR_OPEN_FAILED, errc::io_error},
+      {ERROR_OPEN_FILES, errc::device_or_resource_busy},
+      {ERROR_OPERATION_ABORTED, errc::operation_canceled},
+      {ERROR_OUTOFMEMORY, errc::not_enough_memory},
+      {ERROR_PATH_NOT_FOUND, errc::no_such_file_or_directory},
+      {ERROR_READ_FAULT, errc::io_error},
+      {ERROR_REPARSE_TAG_INVALID, errc::invalid_argument},
+      {ERROR_RETRY, errc::resource_unavailable_try_again},
+      {ERROR_SEEK, errc::io_error},
+      {ERROR_SHARING_VIOLATION, errc::permission_denied},
+      {ERROR_TOO_MANY_OPEN_FILES, errc::too_many_files_open},
+      {ERROR_WRITE_FAULT, errc::io_error},
+      {ERROR_WRITE_PROTECT, errc::permission_denied},
+  };
+
+  for (const auto& pair : win_error_mapping)
+    if (pair.win == static_cast<DWORD>(err))
+      return pair.errc;
+  return errc::invalid_argument;
+}
+
+#endif // _LIBCPP_WIN32API
+
+inline error_code capture_errno() {
+  _LIBCPP_ASSERT_INTERNAL(errno != 0, "Expected errno to be non-zero");
+  return error_code(__errc_to_err((errc)errno), generic_category());
+}
+
+#if defined(_LIBCPP_WIN32API)
+inline error_code make_windows_error(int err) { return make_error_code(__win_err_to_errc(err)); }
+#endif
+
+template <class T>
+T error_value();
+template <>
+inline constexpr void error_value<void>() {}
+template <>
+inline bool error_value<bool>() {
+  return false;
+}
+#if __SIZEOF_SIZE_T__ != __SIZEOF_LONG_LONG__
+template <>
+inline size_t error_value<size_t>() {
+  return size_t(-1);
+}
+#endif
+template <>
+inline uintmax_t error_value<uintmax_t>() {
+  return uintmax_t(-1);
+}
+template <>
+inline constexpr file_time_type error_value<file_time_type>() {
+  return file_time_type::min();
+}
+template <>
+inline path error_value<path>() {
+  return {};
+}
+
+template <class T>
+struct ErrorHandler {
+  const char* func_name_;
+  error_code* ec_ = nullptr;
+  const path* p1_ = nullptr;
+  const path* p2_ = nullptr;
+
+  ErrorHandler(const char* fname, error_code* ec, const path* p1 = nullptr, const path* p2 = nullptr)
+      : func_name_(fname), ec_(ec), p1_(p1), p2_(p2) {
+    if (ec_)
+      ec_->clear();
+  }
+
+  T report(const error_code& ec) const {
+    if (ec_) {
+      *ec_ = ec;
+      return error_value<T>();
+    }
+    string what = string("in ") + func_name_;
+    switch (bool(p1_) + bool(p2_)) {
+    case 0:
+      __throw_filesystem_error(what, ec);
+    case 1:
+      __throw_filesystem_error(what, *p1_, ec);
+    case 2:
+      __throw_filesystem_error(what, *p1_, *p2_, ec);
+    }
+    __libcpp_unreachable();
+  }
+
+  _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 0)
+  void report_impl(const error_code& ec, const char* msg, va_list ap) const {
+    if (ec_) {
+      *ec_ = ec;
+      return;
+    }
+    string what = string("in ") + func_name_ + ": " + detail::vformat_string(msg, ap);
+    switch (bool(p1_) + bool(p2_)) {
+    case 0:
+      __throw_filesystem_error(what, ec);
+    case 1:
+      __throw_filesystem_error(what, *p1_, ec);
+    case 2:
+      __throw_filesystem_error(what, *p1_, *p2_, ec);
+    }
+    __libcpp_unreachable();
+  }
+
+  _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4)
+  T report(const error_code& ec, const char* msg, ...) const {
+    va_list ap;
+    va_start(ap, msg);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      report_impl(ec, msg, ap);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      va_end(ap);
+      throw;
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    va_end(ap);
+    return error_value<T>();
+  }
+
+  T report(errc const& err) const { return report(make_error_code(err)); }
+
+  _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4)
+  T report(errc const& err, const char* msg, ...) const {
+    va_list ap;
+    va_start(ap, msg);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      report_impl(make_error_code(err), msg, ap);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      va_end(ap);
+      throw;
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    va_end(ap);
+    return error_value<T>();
+  }
+
+private:
+  ErrorHandler(ErrorHandler const&)            = delete;
+  ErrorHandler& operator=(ErrorHandler const&) = delete;
+};
+
+} // end namespace detail
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
+
+#endif // FILESYSTEM_ERROR_H
diff --git a/third_party/libcxx/fs/file_descriptor.h b/third_party/libcxx/fs/file_descriptor.h
new file mode 100644
index 000000000..55c313658
--- /dev/null
+++ b/third_party/libcxx/fs/file_descriptor.h
@@ -0,0 +1,292 @@
+//===----------------------------------------------------------------------===////
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===////
+
+#ifndef FILESYSTEM_FILE_DESCRIPTOR_H
+#define FILESYSTEM_FILE_DESCRIPTOR_H
+
+#include <__config>
+#include <cstdint>
+#include <filesystem>
+#include <string_view>
+#include <system_error>
+#include <utility>
+
+#include "error.h"
+#include "posix_compat.h"
+#include "time_utils.h"
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <windows.h>
+#else
+#  include <dirent.h> // for DIR & friends
+#  include <fcntl.h>  // values for fchmodat
+#  include <sys/stat.h>
+#  include <sys/statvfs.h>
+#  include <unistd.h>
+#endif // defined(_LIBCPP_WIN32API)
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+namespace detail {
+
+#if !defined(_LIBCPP_WIN32API)
+
+#  if defined(DT_BLK)
+template <class DirEntT, class = decltype(DirEntT::d_type)>
+file_type get_file_type(DirEntT* ent, int) {
+  switch (ent->d_type) {
+  case DT_BLK:
+    return file_type::block;
+  case DT_CHR:
+    return file_type::character;
+  case DT_DIR:
+    return file_type::directory;
+  case DT_FIFO:
+    return file_type::fifo;
+  case DT_LNK:
+    return file_type::symlink;
+  case DT_REG:
+    return file_type::regular;
+  case DT_SOCK:
+    return file_type::socket;
+  // Unlike in lstat, hitting "unknown" here simply means that the underlying
+  // filesystem doesn't support d_type. Report is as 'none' so we correctly
+  // set the cache to empty.
+  case DT_UNKNOWN:
+    break;
+  }
+  return file_type::none;
+}
+#  endif // defined(DT_BLK)
+
+template <class DirEntT>
+file_type get_file_type(DirEntT*, long) {
+  return file_type::none;
+}
+
+inline pair<string_view, file_type> posix_readdir(DIR* dir_stream, error_code& ec) {
+  struct dirent* dir_entry_ptr = nullptr;
+  errno                        = 0; // zero errno in order to detect errors
+  ec.clear();
+  if ((dir_entry_ptr = ::readdir(dir_stream)) == nullptr) {
+    if (errno)
+      ec = capture_errno();
+    return {};
+  } else {
+    return {dir_entry_ptr->d_name, get_file_type(dir_entry_ptr, 0)};
+  }
+}
+
+#else // _LIBCPP_WIN32API
+
+inline file_type get_file_type(const WIN32_FIND_DATAW& data) {
+  if (data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT && data.dwReserved0 == IO_REPARSE_TAG_SYMLINK)
+    return file_type::symlink;
+  if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+    return file_type::directory;
+  return file_type::regular;
+}
+inline uintmax_t get_file_size(const WIN32_FIND_DATAW& data) {
+  return (static_cast<uint64_t>(data.nFileSizeHigh) << 32) + data.nFileSizeLow;
+}
+inline file_time_type get_write_time(const WIN32_FIND_DATAW& data) {
+  ULARGE_INTEGER tmp;
+  const FILETIME& time = data.ftLastWriteTime;
+  tmp.u.LowPart        = time.dwLowDateTime;
+  tmp.u.HighPart       = time.dwHighDateTime;
+  return file_time_type(file_time_type::duration(tmp.QuadPart));
+}
+
+#endif // !_LIBCPP_WIN32API
+
+//                       POSIX HELPERS
+
+using value_type  = path::value_type;
+using string_type = path::string_type;
+
+struct FileDescriptor {
+  const path& name;
+  int fd = -1;
+  StatT m_stat;
+  file_status m_status;
+
+  template <class... Args>
+  static FileDescriptor create(const path* p, error_code& ec, Args... args) {
+    ec.clear();
+    int fd;
+#ifdef _LIBCPP_WIN32API
+    // TODO: most of the filesystem implementation uses native Win32 calls
+    // (mostly via posix_compat.h). However, here we use the C-runtime APIs to
+    // open a file, because we subsequently pass the C-runtime fd to
+    // `std::[io]fstream::__open(int fd)` in order to implement copy_file.
+    //
+    // Because we're calling the windows C-runtime, win32 error codes are
+    // translated into C error numbers by the C runtime, and returned in errno,
+    // rather than being accessible directly via GetLastError.
+    //
+    // Ideally copy_file should be calling the Win32 CopyFile2 function, which
+    // works on paths, not open files -- at which point this FileDescriptor type
+    // will no longer be needed on windows at all.
+    fd = ::_wopen(p->c_str(), args...);
+#else
+    fd = open(p->c_str(), args...);
+#endif
+
+    if (fd == -1) {
+      ec = capture_errno();
+      return FileDescriptor{p};
+    }
+    return FileDescriptor(p, fd);
+  }
+
+  template <class... Args>
+  static FileDescriptor create_with_status(const path* p, error_code& ec, Args... args) {
+    FileDescriptor fd = create(p, ec, args...);
+    if (!ec)
+      fd.refresh_status(ec);
+
+    return fd;
+  }
+
+  file_status get_status() const { return m_status; }
+  StatT const& get_stat() const { return m_stat; }
+
+  bool status_known() const { return filesystem::status_known(m_status); }
+
+  file_status refresh_status(error_code& ec);
+
+  void close() noexcept {
+    if (fd != -1) {
+#ifdef _LIBCPP_WIN32API
+      ::_close(fd);
+#else
+      ::close(fd);
+#endif
+      // FIXME: shouldn't this return an error_code?
+    }
+    fd = -1;
+  }
+
+  FileDescriptor(FileDescriptor&& other)
+      : name(other.name), fd(other.fd), m_stat(other.m_stat), m_status(other.m_status) {
+    other.fd       = -1;
+    other.m_status = file_status{};
+  }
+
+  ~FileDescriptor() { close(); }
+
+  FileDescriptor(FileDescriptor const&)            = delete;
+  FileDescriptor& operator=(FileDescriptor const&) = delete;
+
+private:
+  explicit FileDescriptor(const path* p, int descriptor = -1) : name(*p), fd(descriptor) {}
+};
+
+inline perms posix_get_perms(const StatT& st) noexcept { return static_cast<perms>(st.st_mode) & perms::mask; }
+
+inline file_status create_file_status(error_code& m_ec, path const& p, const StatT& path_stat, error_code* ec) {
+  if (ec)
+    *ec = m_ec;
+  if (m_ec && (m_ec == errc::no_such_file_or_directory ||
+               m_ec == errc::not_a_directory)) {
+    return file_status(file_type::not_found);
+  } else if (m_ec) {
+    ErrorHandler<void> err("posix_stat", ec, &p);
+    err.report(m_ec, "failed to determine attributes for the specified path");
+    return file_status(file_type::none);
+  }
+  // else
+
+  file_status fs_tmp;
+  auto const mode = path_stat.st_mode;
+  if (S_ISLNK(mode))
+    fs_tmp.type(file_type::symlink);
+  else if (S_ISREG(mode))
+    fs_tmp.type(file_type::regular);
+  else if (S_ISDIR(mode))
+    fs_tmp.type(file_type::directory);
+  else if (S_ISBLK(mode))
+    fs_tmp.type(file_type::block);
+  else if (S_ISCHR(mode))
+    fs_tmp.type(file_type::character);
+  else if (S_ISFIFO(mode))
+    fs_tmp.type(file_type::fifo);
+  else if (S_ISSOCK(mode))
+    fs_tmp.type(file_type::socket);
+  else
+    fs_tmp.type(file_type::unknown);
+
+  fs_tmp.permissions(detail::posix_get_perms(path_stat));
+  return fs_tmp;
+}
+
+inline file_status posix_stat(path const& p, StatT& path_stat, error_code* ec) {
+  error_code m_ec;
+  if (detail::stat(p.c_str(), &path_stat) == -1)
+    m_ec = detail::capture_errno();
+  return create_file_status(m_ec, p, path_stat, ec);
+}
+
+inline file_status posix_stat(path const& p, error_code* ec) {
+  StatT path_stat;
+  return posix_stat(p, path_stat, ec);
+}
+
+inline file_status posix_lstat(path const& p, StatT& path_stat, error_code* ec) {
+  error_code m_ec;
+  if (detail::lstat(p.c_str(), &path_stat) == -1)
+    m_ec = detail::capture_errno();
+  return create_file_status(m_ec, p, path_stat, ec);
+}
+
+inline file_status posix_lstat(path const& p, error_code* ec) {
+  StatT path_stat;
+  return posix_lstat(p, path_stat, ec);
+}
+
+// http://pubs.opengroup.org/onlinepubs/9699919799/functions/ftruncate.html
+inline bool posix_ftruncate(const FileDescriptor& fd, off_t to_size, error_code& ec) {
+  if (detail::ftruncate(fd.fd, to_size) == -1) {
+    ec = capture_errno();
+    return true;
+  }
+  ec.clear();
+  return false;
+}
+
+inline bool posix_fchmod(const FileDescriptor& fd, const StatT& st, error_code& ec) {
+  if (detail::fchmod(fd.fd, st.st_mode) == -1) {
+    ec = capture_errno();
+    return true;
+  }
+  ec.clear();
+  return false;
+}
+
+inline bool stat_equivalent(const StatT& st1, const StatT& st2) {
+  return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
+}
+
+inline file_status FileDescriptor::refresh_status(error_code& ec) {
+  // FD must be open and good.
+  m_status = file_status{};
+  m_stat   = {};
+  error_code m_ec;
+  if (detail::fstat(fd, &m_stat) == -1)
+    m_ec = capture_errno();
+  m_status = create_file_status(m_ec, name, m_stat, &ec);
+  return m_status;
+}
+
+} // end namespace detail
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
+
+#endif // FILESYSTEM_FILE_DESCRIPTOR_H
diff --git a/third_party/libcxx/fs/filesystem_clock.cpp b/third_party/libcxx/fs/filesystem_clock.cpp
new file mode 100644
index 000000000..e13b2853e
--- /dev/null
+++ b/third_party/libcxx/fs/filesystem_clock.cpp
@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+#include <chrono>
+#include <filesystem>
+#include <time.h>
+
+#if defined(_LIBCPP_WIN32API)
+#  include "time_utils.h"
+#endif
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <windows.h>
+#endif
+
+#if __has_include(<unistd.h>)
+#  include <unistd.h> // _POSIX_TIMERS
+#endif
+
+#if __has_include(<sys/time.h>)
+#  include <sys/time.h> // for gettimeofday and timeval
+#endif
+
+#if defined(__APPLE__) || defined(__gnu_hurd__) || (defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0)
+#  define _LIBCPP_HAS_CLOCK_GETTIME
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+const bool _FilesystemClock::is_steady;
+
+_FilesystemClock::time_point _FilesystemClock::now() noexcept {
+  typedef chrono::duration<rep> __secs;
+#if defined(_LIBCPP_WIN32API)
+  typedef chrono::duration<rep, nano> __nsecs;
+  FILETIME time;
+  GetSystemTimeAsFileTime(&time);
+  detail::TimeSpec tp = detail::filetime_to_timespec(time);
+  return time_point(__secs(tp.tv_sec) + chrono::duration_cast<duration>(__nsecs(tp.tv_nsec)));
+#elif defined(_LIBCPP_HAS_CLOCK_GETTIME)
+  typedef chrono::duration<rep, nano> __nsecs;
+  struct timespec tp;
+  if (0 != clock_gettime(CLOCK_REALTIME, &tp))
+    __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
+  return time_point(__secs(tp.tv_sec) + chrono::duration_cast<duration>(__nsecs(tp.tv_nsec)));
+#else
+  typedef chrono::duration<rep, micro> __microsecs;
+  timeval tv;
+  gettimeofday(&tv, 0);
+  return time_point(__secs(tv.tv_sec) + __microsecs(tv.tv_usec));
+#endif
+}
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
diff --git a/third_party/libcxx/fs/filesystem_error.cpp b/third_party/libcxx/fs/filesystem_error.cpp
new file mode 100644
index 000000000..456b902c3
--- /dev/null
+++ b/third_party/libcxx/fs/filesystem_error.cpp
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+#include <__utility/unreachable.h>
+#include <filesystem>
+#include <system_error>
+
+#include "format_string.h"
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+filesystem_error::~filesystem_error() {}
+
+void filesystem_error::__create_what(int __num_paths) {
+  const char* derived_what = system_error::what();
+  __storage_->__what_      = [&]() -> string {
+    switch (__num_paths) {
+    case 0:
+      return detail::format_string("filesystem error: %s", derived_what);
+    case 1:
+      return detail::format_string("filesystem error: %s [" PATH_CSTR_FMT "]", derived_what, path1().c_str());
+    case 2:
+      return detail::format_string(
+          "filesystem error: %s [" PATH_CSTR_FMT "] [" PATH_CSTR_FMT "]",
+          derived_what,
+          path1().c_str(),
+          path2().c_str());
+    }
+    __libcpp_unreachable();
+  }();
+}
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
diff --git a/third_party/libcxx/fs/format_string.h b/third_party/libcxx/fs/format_string.h
new file mode 100644
index 000000000..a44def86f
--- /dev/null
+++ b/third_party/libcxx/fs/format_string.h
@@ -0,0 +1,77 @@
+//===----------------------------------------------------------------------===////
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===////
+
+#ifndef FILESYSTEM_FORMAT_STRING_H
+#define FILESYSTEM_FORMAT_STRING_H
+
+#include <__assert>
+#include <__config>
+#include <array>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdio>
+#include <string>
+
+#if defined(_LIBCPP_WIN32API)
+#  define PATHSTR(x) (L##x)
+#  define PATH_CSTR_FMT "\"%ls\""
+#else
+#  define PATHSTR(x) (x)
+#  define PATH_CSTR_FMT "\"%s\""
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+namespace detail {
+
+inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 0) string vformat_string(const char* msg, va_list ap) {
+  array<char, 256> buf;
+
+  va_list apcopy;
+  va_copy(apcopy, ap);
+  int ret = ::vsnprintf(buf.data(), buf.size(), msg, apcopy);
+  va_end(apcopy);
+
+  string result;
+  if (static_cast<size_t>(ret) < buf.size()) {
+    result.assign(buf.data(), static_cast<size_t>(ret));
+  } else {
+    // we did not provide a long enough buffer on our first attempt. The
+    // return value is the number of bytes (excluding the null byte) that are
+    // needed for formatting.
+    size_t size_with_null = static_cast<size_t>(ret) + 1;
+    result.__resize_default_init(size_with_null - 1);
+    ret = ::vsnprintf(&result[0], size_with_null, msg, ap);
+    _LIBCPP_ASSERT_INTERNAL(static_cast<size_t>(ret) == (size_with_null - 1), "TODO");
+  }
+  return result;
+}
+
+inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 2) string format_string(const char* msg, ...) {
+  string ret;
+  va_list ap;
+  va_start(ap, msg);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    ret = detail::vformat_string(msg, ap);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    va_end(ap);
+    throw;
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  va_end(ap);
+  return ret;
+}
+
+} // end namespace detail
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
+
+#endif // FILESYSTEM_FORMAT_STRING_H
diff --git a/third_party/libcxx/src/filesystem/int128_builtins.cpp b/third_party/libcxx/fs/int128_builtins.cpp
similarity index 79%
rename from third_party/libcxx/src/filesystem/int128_builtins.cpp
rename to third_party/libcxx/fs/int128_builtins.cpp
index f003da27a..72b7cb4a8 100644
--- a/third_party/libcxx/src/filesystem/int128_builtins.cpp
+++ b/third_party/libcxx/fs/int128_builtins.cpp
@@ -18,13 +18,13 @@
 
 #if !defined(_LIBCPP_HAS_NO_INT128)
 
-extern "C" __attribute__((no_sanitize("undefined"))) _LIBCPP_FUNC_VIS
-__int128_t __muloti4(__int128_t a, __int128_t b, int* overflow) {
-  const int N = (int)(sizeof(__int128_t) * CHAR_BIT);
+extern "C" __attribute__((no_sanitize("undefined"))) _LIBCPP_EXPORTED_FROM_ABI __int128_t
+__muloti4(__int128_t a, __int128_t b, int* overflow) {
+  const int N          = (int)(sizeof(__int128_t) * CHAR_BIT);
   const __int128_t MIN = (__int128_t)1 << (N - 1);
   const __int128_t MAX = ~MIN;
-  *overflow = 0;
-  __int128_t result = a * b;
+  *overflow            = 0;
+  __int128_t result    = a * b;
   if (a == MIN) {
     if (b != 0 && b != 1)
       *overflow = 1;
@@ -35,9 +35,9 @@ __int128_t __muloti4(__int128_t a, __int128_t b, int* overflow) {
       *overflow = 1;
     return result;
   }
-  __int128_t sa = a >> (N - 1);
+  __int128_t sa    = a >> (N - 1);
   __int128_t abs_a = (a ^ sa) - sa;
-  __int128_t sb = b >> (N - 1);
+  __int128_t sb    = b >> (N - 1);
   __int128_t abs_b = (b ^ sb) - sb;
   if (abs_a < 2 || abs_b < 2)
     return result;
diff --git a/third_party/libcxx/fs/operations.cpp b/third_party/libcxx/fs/operations.cpp
new file mode 100644
index 000000000..07f661412
--- /dev/null
+++ b/third_party/libcxx/fs/operations.cpp
@@ -0,0 +1,968 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__assert>
+#include <__config>
+#include <__utility/unreachable.h>
+#include <array>
+#include <climits>
+#include <cstdlib>
+#include <filesystem>
+#include <iterator>
+#include <string_view>
+#include <type_traits>
+#include <vector>
+
+#include "error.h"
+#include "file_descriptor.h"
+#include "path_parser.h"
+#include "posix_compat.h"
+#include "time_utils.h"
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <windows.h>
+#else
+#  include <dirent.h>
+#  include <sys/stat.h>
+#  include <sys/statvfs.h>
+#  include <unistd.h>
+#endif
+#include <fcntl.h> /* values for fchmodat */
+#include <time.h>
+
+#if defined(__COSMOPOLITAN__)
+#  include <fstream>
+#  define _LIBCPP_FILESYSTEM_USE_FSTREAM
+#elif __has_include(<sys/sendfile.h>)
+#  include <sys/sendfile.h>
+#  define _LIBCPP_FILESYSTEM_USE_SENDFILE
+#elif defined(__APPLE__) || __has_include(<copyfile.h>)
+#  include <copyfile.h>
+#  define _LIBCPP_FILESYSTEM_USE_COPYFILE
+#else
+#  include <fstream>
+#  define _LIBCPP_FILESYSTEM_USE_FSTREAM
+#endif
+
+#if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
+#  pragma comment(lib, "rt")
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+using detail::capture_errno;
+using detail::ErrorHandler;
+using detail::StatT;
+using detail::TimeSpec;
+using parser::createView;
+using parser::PathParser;
+using parser::string_view_t;
+
+static path __do_absolute(const path& p, path* cwd, error_code* ec) {
+  if (ec)
+    ec->clear();
+  if (p.is_absolute())
+    return p;
+  *cwd = __current_path(ec);
+  if (ec && *ec)
+    return {};
+  return (*cwd) / p;
+}
+
+path __absolute(const path& p, error_code* ec) {
+  path cwd;
+  return __do_absolute(p, &cwd, ec);
+}
+
+path __canonical(path const& orig_p, error_code* ec) {
+  path cwd;
+  ErrorHandler<path> err("canonical", ec, &orig_p, &cwd);
+
+  path p = __do_absolute(orig_p, &cwd, ec);
+#if (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112) || defined(_LIBCPP_WIN32API)
+  std::unique_ptr<path::value_type, decltype(&::free)> hold(detail::realpath(p.c_str(), nullptr), &::free);
+  if (hold.get() == nullptr)
+    return err.report(capture_errno());
+  return {hold.get()};
+#else
+#  if defined(__MVS__) && !defined(PATH_MAX)
+  path::value_type buff[_XOPEN_PATH_MAX + 1];
+#  else
+  path::value_type buff[PATH_MAX + 1];
+#  endif
+  path::value_type* ret;
+  if ((ret = detail::realpath(p.c_str(), buff)) == nullptr)
+    return err.report(capture_errno());
+  return {ret};
+#endif
+}
+
+void __copy(const path& from, const path& to, copy_options options, error_code* ec) {
+  ErrorHandler<void> err("copy", ec, &from, &to);
+
+  const bool sym_status = bool(options & (copy_options::create_symlinks | copy_options::skip_symlinks));
+
+  const bool sym_status2 = bool(options & copy_options::copy_symlinks);
+
+  error_code m_ec1;
+  StatT f_st;
+  const file_status f =
+      sym_status || sym_status2 ? detail::posix_lstat(from, f_st, &m_ec1) : detail::posix_stat(from, f_st, &m_ec1);
+  if (m_ec1)
+    return err.report(m_ec1);
+
+  StatT t_st;
+  const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec1) : detail::posix_stat(to, t_st, &m_ec1);
+
+  if (not status_known(t))
+    return err.report(m_ec1);
+
+  if (!exists(f) || is_other(f) || is_other(t) || (is_directory(f) && is_regular_file(t)) ||
+      (exists(t) && detail::stat_equivalent(f_st, t_st))) {
+    return err.report(errc::function_not_supported);
+  }
+
+  if (is_symlink(f)) {
+    if (bool(copy_options::skip_symlinks & options)) {
+      // do nothing
+    } else if (not exists(t)) {
+      __copy_symlink(from, to, ec);
+    } else {
+      return err.report(errc::file_exists);
+    }
+    return;
+  } else if (is_regular_file(f)) {
+    if (bool(copy_options::directories_only & options)) {
+      // do nothing
+    } else if (bool(copy_options::create_symlinks & options)) {
+      __create_symlink(from, to, ec);
+    } else if (bool(copy_options::create_hard_links & options)) {
+      __create_hard_link(from, to, ec);
+    } else if (is_directory(t)) {
+      __copy_file(from, to / from.filename(), options, ec);
+    } else {
+      __copy_file(from, to, options, ec);
+    }
+    return;
+  } else if (is_directory(f) && bool(copy_options::create_symlinks & options)) {
+    return err.report(errc::is_a_directory);
+  } else if (is_directory(f) && (bool(copy_options::recursive & options) || copy_options::none == options)) {
+    if (!exists(t)) {
+      // create directory to with attributes from 'from'.
+      __create_directory(to, from, ec);
+      if (ec && *ec) {
+        return;
+      }
+    }
+    directory_iterator it = ec ? directory_iterator(from, *ec) : directory_iterator(from);
+    if (ec && *ec) {
+      return;
+    }
+    error_code m_ec2;
+    for (; !m_ec2 && it != directory_iterator(); it.increment(m_ec2)) {
+      __copy(it->path(), to / it->path().filename(), options | copy_options::__in_recursive_copy, ec);
+      if (ec && *ec) {
+        return;
+      }
+    }
+    if (m_ec2) {
+      return err.report(m_ec2);
+    }
+  }
+}
+
+namespace detail {
+namespace {
+
+#if defined(_LIBCPP_FILESYSTEM_USE_SENDFILE)
+bool copy_file_impl(FileDescriptor& read_fd, FileDescriptor& write_fd, error_code& ec) {
+  size_t count = read_fd.get_stat().st_size;
+  do {
+    ssize_t res;
+    if ((res = ::sendfile(write_fd.fd, read_fd.fd, nullptr, count)) == -1) {
+      ec = capture_errno();
+      return false;
+    }
+    count -= res;
+  } while (count > 0);
+
+  ec.clear();
+
+  return true;
+}
+#elif defined(_LIBCPP_FILESYSTEM_USE_COPYFILE)
+bool copy_file_impl(FileDescriptor& read_fd, FileDescriptor& write_fd, error_code& ec) {
+  struct CopyFileState {
+    copyfile_state_t state;
+    CopyFileState() { state = copyfile_state_alloc(); }
+    ~CopyFileState() { copyfile_state_free(state); }
+
+  private:
+    CopyFileState(CopyFileState const&)            = delete;
+    CopyFileState& operator=(CopyFileState const&) = delete;
+  };
+
+  CopyFileState cfs;
+  if (fcopyfile(read_fd.fd, write_fd.fd, cfs.state, COPYFILE_DATA) < 0) {
+    ec = capture_errno();
+    return false;
+  }
+
+  ec.clear();
+  return true;
+}
+#elif defined(_LIBCPP_FILESYSTEM_USE_FSTREAM)
+bool copy_file_impl(FileDescriptor& read_fd, FileDescriptor& write_fd, error_code& ec) {
+  ifstream in;
+  in.__open(read_fd.fd, ios::binary);
+  if (!in.is_open()) {
+    // This assumes that __open didn't reset the error code.
+    ec = capture_errno();
+    return false;
+  }
+  read_fd.fd = -1;
+  ofstream out;
+  out.__open(write_fd.fd, ios::binary);
+  if (!out.is_open()) {
+    ec = capture_errno();
+    return false;
+  }
+  write_fd.fd = -1;
+
+  if (in.good() && out.good()) {
+    using InIt  = istreambuf_iterator<char>;
+    using OutIt = ostreambuf_iterator<char>;
+    InIt bin(in);
+    InIt ein;
+    OutIt bout(out);
+    copy(bin, ein, bout);
+  }
+  if (out.fail() || in.fail()) {
+    ec = make_error_code(errc::io_error);
+    return false;
+  }
+
+  ec.clear();
+  return true;
+}
+#else
+#  error "Unknown implementation for copy_file_impl"
+#endif // copy_file_impl implementation
+
+} // end anonymous namespace
+} // end namespace detail
+
+bool __copy_file(const path& from, const path& to, copy_options options, error_code* ec) {
+  using detail::FileDescriptor;
+  ErrorHandler<bool> err("copy_file", ec, &to, &from);
+
+  error_code m_ec;
+  FileDescriptor from_fd = FileDescriptor::create_with_status(&from, m_ec, O_RDONLY | O_NONBLOCK | O_BINARY);
+  if (m_ec)
+    return err.report(m_ec);
+
+  auto from_st           = from_fd.get_status();
+  StatT const& from_stat = from_fd.get_stat();
+  if (!is_regular_file(from_st)) {
+    if (not m_ec)
+      m_ec = make_error_code(errc::not_supported);
+    return err.report(m_ec);
+  }
+
+  const bool skip_existing      = bool(copy_options::skip_existing & options);
+  const bool update_existing    = bool(copy_options::update_existing & options);
+  const bool overwrite_existing = bool(copy_options::overwrite_existing & options);
+
+  StatT to_stat_path;
+  file_status to_st = detail::posix_stat(to, to_stat_path, &m_ec);
+  if (!status_known(to_st))
+    return err.report(m_ec);
+
+  const bool to_exists = exists(to_st);
+  if (to_exists && !is_regular_file(to_st))
+    return err.report(errc::not_supported);
+
+  if (to_exists && detail::stat_equivalent(from_stat, to_stat_path))
+    return err.report(errc::file_exists);
+
+  if (to_exists && skip_existing)
+    return false;
+
+  bool ShouldCopy = [&]() {
+    if (to_exists && update_existing) {
+      auto from_time = detail::extract_mtime(from_stat);
+      auto to_time   = detail::extract_mtime(to_stat_path);
+      if (from_time.tv_sec < to_time.tv_sec)
+        return false;
+      if (from_time.tv_sec == to_time.tv_sec && from_time.tv_nsec <= to_time.tv_nsec)
+        return false;
+      return true;
+    }
+    if (!to_exists || overwrite_existing)
+      return true;
+    return err.report(errc::file_exists);
+  }();
+  if (!ShouldCopy)
+    return false;
+
+  // Don't truncate right away. We may not be opening the file we originally
+  // looked at; we'll check this later.
+  int to_open_flags = O_WRONLY | O_BINARY;
+  if (!to_exists)
+    to_open_flags |= O_CREAT;
+  FileDescriptor to_fd = FileDescriptor::create_with_status(&to, m_ec, to_open_flags, from_stat.st_mode);
+  if (m_ec)
+    return err.report(m_ec);
+
+  if (to_exists) {
+    // Check that the file we initially stat'ed is equivalent to the one
+    // we opened.
+    // FIXME: report this better.
+    if (!detail::stat_equivalent(to_stat_path, to_fd.get_stat()))
+      return err.report(errc::bad_file_descriptor);
+
+    // Set the permissions and truncate the file we opened.
+    if (detail::posix_fchmod(to_fd, from_stat, m_ec))
+      return err.report(m_ec);
+    if (detail::posix_ftruncate(to_fd, 0, m_ec))
+      return err.report(m_ec);
+  }
+
+  if (!detail::copy_file_impl(from_fd, to_fd, m_ec)) {
+    // FIXME: Remove the dest file if we failed, and it didn't exist previously.
+    return err.report(m_ec);
+  }
+
+  return true;
+}
+
+void __copy_symlink(const path& existing_symlink, const path& new_symlink, error_code* ec) {
+  const path real_path(__read_symlink(existing_symlink, ec));
+  if (ec && *ec) {
+    return;
+  }
+#if defined(_LIBCPP_WIN32API)
+  error_code local_ec;
+  if (is_directory(real_path, local_ec))
+    __create_directory_symlink(real_path, new_symlink, ec);
+  else
+#endif
+    __create_symlink(real_path, new_symlink, ec);
+}
+
+bool __create_directories(const path& p, error_code* ec) {
+  ErrorHandler<bool> err("create_directories", ec, &p);
+
+  error_code m_ec;
+  auto const st = detail::posix_stat(p, &m_ec);
+  if (!status_known(st))
+    return err.report(m_ec);
+  else if (is_directory(st))
+    return false;
+  else if (exists(st))
+    return err.report(errc::file_exists);
+
+  const path parent = p.parent_path();
+  if (!parent.empty()) {
+    const file_status parent_st = status(parent, m_ec);
+    if (not status_known(parent_st))
+      return err.report(m_ec);
+    if (not exists(parent_st)) {
+      if (parent == p)
+        return err.report(errc::invalid_argument);
+      __create_directories(parent, ec);
+      if (ec && *ec) {
+        return false;
+      }
+    } else if (not is_directory(parent_st))
+      return err.report(errc::not_a_directory);
+  }
+  bool ret = __create_directory(p, &m_ec);
+  if (m_ec)
+    return err.report(m_ec);
+  return ret;
+}
+
+bool __create_directory(const path& p, error_code* ec) {
+  ErrorHandler<bool> err("create_directory", ec, &p);
+
+  if (detail::mkdir(p.c_str(), static_cast<int>(perms::all)) == 0)
+    return true;
+
+  if (errno != EEXIST)
+    return err.report(capture_errno());
+  error_code mec = capture_errno();
+  error_code ignored_ec;
+  const file_status st = status(p, ignored_ec);
+  if (!is_directory(st))
+    return err.report(mec);
+  return false;
+}
+
+bool __create_directory(path const& p, path const& attributes, error_code* ec) {
+  ErrorHandler<bool> err("create_directory", ec, &p, &attributes);
+
+  StatT attr_stat;
+  error_code mec;
+  file_status st = detail::posix_stat(attributes, attr_stat, &mec);
+  if (!status_known(st))
+    return err.report(mec);
+  if (!is_directory(st))
+    return err.report(errc::not_a_directory, "the specified attribute path is invalid");
+
+  if (detail::mkdir(p.c_str(), attr_stat.st_mode) == 0)
+    return true;
+
+  if (errno != EEXIST)
+    return err.report(capture_errno());
+
+  mec = capture_errno();
+  error_code ignored_ec;
+  st = status(p, ignored_ec);
+  if (!is_directory(st))
+    return err.report(mec);
+  return false;
+}
+
+void __create_directory_symlink(path const& from, path const& to, error_code* ec) {
+  ErrorHandler<void> err("create_directory_symlink", ec, &from, &to);
+  if (detail::symlink_dir(from.c_str(), to.c_str()) == -1)
+    return err.report(capture_errno());
+}
+
+void __create_hard_link(const path& from, const path& to, error_code* ec) {
+  ErrorHandler<void> err("create_hard_link", ec, &from, &to);
+  if (detail::link(from.c_str(), to.c_str()) == -1)
+    return err.report(capture_errno());
+}
+
+void __create_symlink(path const& from, path const& to, error_code* ec) {
+  ErrorHandler<void> err("create_symlink", ec, &from, &to);
+  if (detail::symlink_file(from.c_str(), to.c_str()) == -1)
+    return err.report(capture_errno());
+}
+
+path __current_path(error_code* ec) {
+  ErrorHandler<path> err("current_path", ec);
+
+#if defined(_LIBCPP_WIN32API) || defined(__GLIBC__) || defined(__APPLE__)
+  // Common extension outside of POSIX getcwd() spec, without needing to
+  // preallocate a buffer. Also supported by a number of other POSIX libcs.
+  int size              = 0;
+  path::value_type* ptr = nullptr;
+  typedef decltype(&::free) Deleter;
+  Deleter deleter = &::free;
+#else
+  errno     = 0; // Note: POSIX mandates that modifying `errno` is thread-safe.
+  auto size = ::pathconf(".", _PC_PATH_MAX);
+  if (size == -1) {
+    if (errno != 0) {
+      return err.report(capture_errno(), "call to pathconf failed");
+
+      // `pathconf` returns `-1` without an error to indicate no limit.
+    } else {
+#  if defined(__MVS__) && !defined(PATH_MAX)
+      size = _XOPEN_PATH_MAX + 1;
+#  else
+      size = PATH_MAX + 1;
+#  endif
+    }
+  }
+
+  auto buff             = unique_ptr<path::value_type[]>(new path::value_type[size + 1]);
+  path::value_type* ptr = buff.get();
+
+  // Preallocated buffer, don't free the buffer in the second unique_ptr
+  // below.
+  struct Deleter {
+    void operator()(void*) const {}
+  };
+  Deleter deleter;
+#endif
+
+  unique_ptr<path::value_type, Deleter> hold(detail::getcwd(ptr, size), deleter);
+  if (hold.get() == nullptr)
+    return err.report(capture_errno(), "call to getcwd failed");
+
+  return {hold.get()};
+}
+
+void __current_path(const path& p, error_code* ec) {
+  ErrorHandler<void> err("current_path", ec, &p);
+  if (detail::chdir(p.c_str()) == -1)
+    err.report(capture_errno());
+}
+
+bool __equivalent(const path& p1, const path& p2, error_code* ec) {
+  ErrorHandler<bool> err("equivalent", ec, &p1, &p2);
+
+  error_code ec1, ec2;
+  StatT st1 = {}, st2 = {};
+  auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
+  if (!exists(s1))
+    return err.report(errc::not_supported);
+  auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
+  if (!exists(s2))
+    return err.report(errc::not_supported);
+
+  return detail::stat_equivalent(st1, st2);
+}
+
+uintmax_t __file_size(const path& p, error_code* ec) {
+  ErrorHandler<uintmax_t> err("file_size", ec, &p);
+
+  error_code m_ec;
+  StatT st;
+  file_status fst = detail::posix_stat(p, st, &m_ec);
+  if (!exists(fst) || !is_regular_file(fst)) {
+    errc error_kind = is_directory(fst) ? errc::is_a_directory : errc::not_supported;
+    if (!m_ec)
+      m_ec = make_error_code(error_kind);
+    return err.report(m_ec);
+  }
+  // is_regular_file(p) == true
+  return static_cast<uintmax_t>(st.st_size);
+}
+
+uintmax_t __hard_link_count(const path& p, error_code* ec) {
+  ErrorHandler<uintmax_t> err("hard_link_count", ec, &p);
+
+  error_code m_ec;
+  StatT st;
+  detail::posix_stat(p, st, &m_ec);
+  if (m_ec)
+    return err.report(m_ec);
+  return static_cast<uintmax_t>(st.st_nlink);
+}
+
+bool __fs_is_empty(const path& p, error_code* ec) {
+  ErrorHandler<bool> err("is_empty", ec, &p);
+
+  error_code m_ec;
+  StatT pst;
+  auto st = detail::posix_stat(p, pst, &m_ec);
+  if (m_ec)
+    return err.report(m_ec);
+  else if (!is_directory(st) && !is_regular_file(st))
+    return err.report(errc::not_supported);
+  else if (is_directory(st)) {
+    auto it = ec ? directory_iterator(p, *ec) : directory_iterator(p);
+    if (ec && *ec)
+      return false;
+    return it == directory_iterator{};
+  } else if (is_regular_file(st))
+    return static_cast<uintmax_t>(pst.st_size) == 0;
+
+  __libcpp_unreachable();
+}
+
+file_time_type __last_write_time(const path& p, error_code* ec) {
+  using namespace chrono;
+  ErrorHandler<file_time_type> err("last_write_time", ec, &p);
+
+  error_code m_ec;
+  StatT st;
+  detail::posix_stat(p, st, &m_ec);
+  if (m_ec)
+    return err.report(m_ec);
+  return detail::__extract_last_write_time(p, st, ec);
+}
+
+void __last_write_time(const path& p, file_time_type new_time, error_code* ec) {
+  using detail::fs_time;
+  ErrorHandler<void> err("last_write_time", ec, &p);
+
+#if defined(_LIBCPP_WIN32API)
+  TimeSpec ts;
+  if (!fs_time::convert_to_timespec(ts, new_time))
+    return err.report(errc::value_too_large);
+  detail::WinHandle h(p.c_str(), FILE_WRITE_ATTRIBUTES, 0);
+  if (!h)
+    return err.report(detail::make_windows_error(GetLastError()));
+  FILETIME last_write = timespec_to_filetime(ts);
+  if (!SetFileTime(h, nullptr, nullptr, &last_write))
+    return err.report(detail::make_windows_error(GetLastError()));
+#else
+  error_code m_ec;
+  array<TimeSpec, 2> tbuf;
+#  if !defined(_LIBCPP_USE_UTIMENSAT)
+  // This implementation has a race condition between determining the
+  // last access time and attempting to set it to the same value using
+  // ::utimes
+  StatT st;
+  file_status fst = detail::posix_stat(p, st, &m_ec);
+  if (m_ec)
+    return err.report(m_ec);
+  tbuf[0] = detail::extract_atime(st);
+#  else
+  tbuf[0].tv_sec  = 0;
+  tbuf[0].tv_nsec = UTIME_OMIT;
+#  endif
+  if (!fs_time::convert_to_timespec(tbuf[1], new_time))
+    return err.report(errc::value_too_large);
+
+  detail::set_file_times(p, tbuf, m_ec);
+  if (m_ec)
+    return err.report(m_ec);
+#endif
+}
+
+void __permissions(const path& p, perms prms, perm_options opts, error_code* ec) {
+  ErrorHandler<void> err("permissions", ec, &p);
+
+  auto has_opt                = [&](perm_options o) { return bool(o & opts); };
+  const bool resolve_symlinks = !has_opt(perm_options::nofollow);
+  const bool add_perms        = has_opt(perm_options::add);
+  const bool remove_perms     = has_opt(perm_options::remove);
+  _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+      (add_perms + remove_perms + has_opt(perm_options::replace)) == 1,
+      "One and only one of the perm_options constants 'replace', 'add', or 'remove' must be present in opts");
+
+  bool set_sym_perms = false;
+  prms &= perms::mask;
+  if (!resolve_symlinks || (add_perms || remove_perms)) {
+    error_code m_ec;
+    file_status st = resolve_symlinks ? detail::posix_stat(p, &m_ec) : detail::posix_lstat(p, &m_ec);
+    set_sym_perms  = is_symlink(st);
+    if (m_ec)
+      return err.report(m_ec);
+    // TODO(hardening): double-check this assertion -- it might be a valid (if rare) case when the permissions are
+    // unknown.
+    _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(st.permissions() != perms::unknown, "Permissions unexpectedly unknown");
+    if (add_perms)
+      prms |= st.permissions();
+    else if (remove_perms)
+      prms = st.permissions() & ~prms;
+  }
+  const auto real_perms = static_cast<detail::ModeT>(prms & perms::mask);
+
+#if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
+  const int flags = set_sym_perms ? AT_SYMLINK_NOFOLLOW : 0;
+  if (detail::fchmodat(AT_FDCWD, p.c_str(), real_perms, flags) == -1) {
+    return err.report(capture_errno());
+  }
+#else
+  if (set_sym_perms)
+    return err.report(errc::operation_not_supported);
+  if (::chmod(p.c_str(), real_perms) == -1) {
+    return err.report(capture_errno());
+  }
+#endif
+}
+
+path __read_symlink(const path& p, error_code* ec) {
+  ErrorHandler<path> err("read_symlink", ec, &p);
+
+#if defined(PATH_MAX) || defined(MAX_SYMLINK_SIZE)
+  struct NullDeleter {
+    void operator()(void*) const {}
+  };
+#  ifdef MAX_SYMLINK_SIZE
+  const size_t size = MAX_SYMLINK_SIZE + 1;
+#  else
+  const size_t size = PATH_MAX + 1;
+#  endif
+  path::value_type stack_buff[size];
+  auto buff = std::unique_ptr<path::value_type[], NullDeleter>(stack_buff);
+#else
+  StatT sb;
+  if (detail::lstat(p.c_str(), &sb) == -1) {
+    return err.report(capture_errno());
+  }
+  const size_t size = sb.st_size + 1;
+  auto buff         = unique_ptr<path::value_type[]>(new path::value_type[size]);
+#endif
+  detail::SSizeT ret;
+  if ((ret = detail::readlink(p.c_str(), buff.get(), size)) == -1)
+    return err.report(capture_errno());
+  // Note that `ret` returning `0` would work, resulting in a valid empty string being returned.
+  if (static_cast<size_t>(ret) >= size)
+    return err.report(errc::value_too_large);
+  buff[ret] = 0;
+  return {buff.get()};
+}
+
+bool __remove(const path& p, error_code* ec) {
+  ErrorHandler<bool> err("remove", ec, &p);
+  if (detail::remove(p.c_str()) == -1) {
+    if (errno != ENOENT)
+      err.report(capture_errno());
+    return false;
+  }
+  return true;
+}
+
+// We currently have two implementations of `__remove_all`. The first one is general and
+// used on platforms where we don't have access to the `openat()` family of POSIX functions.
+// That implementation uses `directory_iterator`, however it is vulnerable to some race
+// conditions, see https://reviews.llvm.org/D118134 for details.
+//
+// The second implementation is used on platforms where `openat()` & friends are available,
+// and it threads file descriptors through recursive calls to avoid such race conditions.
+#if defined(_LIBCPP_WIN32API) || defined(__MVS__)
+#  define REMOVE_ALL_USE_DIRECTORY_ITERATOR
+#endif
+
+#if defined(REMOVE_ALL_USE_DIRECTORY_ITERATOR)
+
+namespace {
+
+uintmax_t remove_all_impl(path const& p, error_code& ec) {
+  const auto npos      = static_cast<uintmax_t>(-1);
+  const file_status st = __symlink_status(p, &ec);
+  if (ec)
+    return npos;
+  uintmax_t count = 1;
+  if (is_directory(st)) {
+    for (directory_iterator it(p, ec); !ec && it != directory_iterator(); it.increment(ec)) {
+      auto other_count = remove_all_impl(it->path(), ec);
+      if (ec)
+        return npos;
+      count += other_count;
+    }
+    if (ec)
+      return npos;
+  }
+  if (!__remove(p, &ec))
+    return npos;
+  return count;
+}
+
+} // end namespace
+
+uintmax_t __remove_all(const path& p, error_code* ec) {
+  ErrorHandler<uintmax_t> err("remove_all", ec, &p);
+
+  error_code mec;
+  auto count = remove_all_impl(p, mec);
+  if (mec) {
+    if (mec == errc::no_such_file_or_directory)
+      return 0;
+    return err.report(mec);
+  }
+  return count;
+}
+
+#else // !REMOVE_ALL_USE_DIRECTORY_ITERATOR
+
+namespace {
+
+template <class Cleanup>
+struct scope_exit {
+  explicit scope_exit(Cleanup const& cleanup) : cleanup_(cleanup) {}
+
+  ~scope_exit() { cleanup_(); }
+
+private:
+  Cleanup cleanup_;
+};
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scope_exit);
+
+uintmax_t remove_all_impl(int parent_directory, const path& p, error_code& ec) {
+  // First, try to open the path as a directory.
+  const int options = O_CLOEXEC | O_RDONLY | O_DIRECTORY | O_NOFOLLOW;
+  int fd            = ::openat(parent_directory, p.c_str(), options);
+  if (fd != -1) {
+    // If that worked, iterate over the contents of the directory and
+    // remove everything in it, recursively.
+    DIR* stream = ::fdopendir(fd);
+    if (stream == nullptr) {
+      ::close(fd);
+      ec = detail::capture_errno();
+      return 0;
+    }
+    // Note: `::closedir` will also close the associated file descriptor, so
+    // there should be no call to `close(fd)`.
+    scope_exit close_stream([=] { ::closedir(stream); });
+
+    uintmax_t count = 0;
+    while (true) {
+      auto [str, type] = detail::posix_readdir(stream, ec);
+      static_assert(std::is_same_v<decltype(str), std::string_view>);
+      if (str == "." || str == "..") {
+        continue;
+      } else if (ec || str.empty()) {
+        break; // we're done iterating through the directory
+      } else {
+        count += remove_all_impl(fd, str, ec);
+      }
+    }
+
+    // Then, remove the now-empty directory itself.
+    if (::unlinkat(parent_directory, p.c_str(), AT_REMOVEDIR) == -1) {
+      ec = detail::capture_errno();
+      return count;
+    }
+
+    return count + 1; // the contents of the directory + the directory itself
+  }
+
+  ec = detail::capture_errno();
+
+  // If we failed to open `p` because it didn't exist, it's not an
+  // error -- it might have moved or have been deleted already.
+  if (ec == errc::no_such_file_or_directory) {
+    ec.clear();
+    return 0;
+  }
+
+  // If opening `p` failed because it wasn't a directory, remove it as
+  // a normal file instead. Note that `openat()` can return either ENOTDIR
+  // or ELOOP depending on the exact reason of the failure. On FreeBSD it
+  // may return EMLINK instead of ELOOP, contradicting POSIX.
+  if (ec == errc::not_a_directory || ec == errc::too_many_symbolic_link_levels || ec == errc::too_many_links) {
+    ec.clear();
+    if (::unlinkat(parent_directory, p.c_str(), /* flags = */ 0) == -1) {
+      ec = detail::capture_errno();
+      return 0;
+    }
+    return 1;
+  }
+
+  // Otherwise, it's a real error -- we don't remove anything.
+  return 0;
+}
+
+} // end namespace
+
+uintmax_t __remove_all(const path& p, error_code* ec) {
+  ErrorHandler<uintmax_t> err("remove_all", ec, &p);
+  error_code mec;
+  uintmax_t count = remove_all_impl(AT_FDCWD, p, mec);
+  if (mec)
+    return err.report(mec);
+  return count;
+}
+
+#endif // REMOVE_ALL_USE_DIRECTORY_ITERATOR
+
+void __rename(const path& from, const path& to, error_code* ec) {
+  ErrorHandler<void> err("rename", ec, &from, &to);
+  if (detail::rename(from.c_str(), to.c_str()) == -1)
+    err.report(capture_errno());
+}
+
+void __resize_file(const path& p, uintmax_t size, error_code* ec) {
+  ErrorHandler<void> err("resize_file", ec, &p);
+  if (detail::truncate(p.c_str(), static_cast< ::off_t>(size)) == -1)
+    return err.report(capture_errno());
+}
+
+space_info __space(const path& p, error_code* ec) {
+  ErrorHandler<void> err("space", ec, &p);
+  space_info si;
+  detail::StatVFS m_svfs = {};
+  if (detail::statvfs(p.c_str(), &m_svfs) == -1) {
+    err.report(capture_errno());
+    si.capacity = si.free = si.available = static_cast<uintmax_t>(-1);
+    return si;
+  }
+  // Multiply with overflow checking.
+  auto do_mult = [&](uintmax_t& out, uintmax_t other) {
+    out = other * m_svfs.f_frsize;
+    if (other == 0 || out / other != m_svfs.f_frsize)
+      out = static_cast<uintmax_t>(-1);
+  };
+  do_mult(si.capacity, m_svfs.f_blocks);
+  do_mult(si.free, m_svfs.f_bfree);
+  do_mult(si.available, m_svfs.f_bavail);
+  return si;
+}
+
+file_status __status(const path& p, error_code* ec) { return detail::posix_stat(p, ec); }
+
+file_status __symlink_status(const path& p, error_code* ec) { return detail::posix_lstat(p, ec); }
+
+path __temp_directory_path(error_code* ec) {
+  ErrorHandler<path> err("temp_directory_path", ec);
+
+#if defined(_LIBCPP_WIN32API)
+  wchar_t buf[MAX_PATH];
+  DWORD retval = GetTempPathW(MAX_PATH, buf);
+  if (!retval)
+    return err.report(detail::make_windows_error(GetLastError()));
+  if (retval > MAX_PATH)
+    return err.report(errc::filename_too_long);
+  // GetTempPathW returns a path with a trailing slash, which we
+  // shouldn't include for consistency.
+  if (buf[retval - 1] == L'\\')
+    buf[retval - 1] = L'\0';
+  path p(buf);
+#else
+  const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
+  const char* ret         = nullptr;
+
+  for (auto& ep : env_paths)
+    if ((ret = getenv(ep)))
+      break;
+  if (ret == nullptr) {
+#  if defined(__ANDROID__)
+    ret = "/data/local/tmp";
+#  else
+    ret = "/tmp";
+#  endif
+  }
+
+  path p(ret);
+#endif
+  error_code m_ec;
+  file_status st = detail::posix_stat(p, &m_ec);
+  if (!status_known(st))
+    return err.report(m_ec, "cannot access path " PATH_CSTR_FMT, p.c_str());
+
+  if (!exists(st) || !is_directory(st))
+    return err.report(errc::not_a_directory, "path " PATH_CSTR_FMT " is not a directory", p.c_str());
+
+  return p;
+}
+
+path __weakly_canonical(const path& p, error_code* ec) {
+  ErrorHandler<path> err("weakly_canonical", ec, &p);
+
+  if (p.empty())
+    return __canonical("", ec);
+
+  path result;
+  path tmp;
+  tmp.__reserve(p.native().size());
+  auto PP = PathParser::CreateEnd(p.native());
+  --PP;
+  vector<string_view_t> DNEParts;
+
+  error_code m_ec;
+  while (PP.State_ != PathParser::PS_BeforeBegin) {
+    tmp.assign(createView(p.native().data(), &PP.RawEntry.back()));
+    file_status st = __status(tmp, &m_ec);
+    if (!status_known(st)) {
+      return err.report(m_ec);
+    } else if (exists(st)) {
+      result = __canonical(tmp, &m_ec);
+      if (m_ec) {
+        return err.report(m_ec);
+      }
+      break;
+    }
+    DNEParts.push_back(*PP);
+    --PP;
+  }
+  if (PP.State_ == PathParser::PS_BeforeBegin) {
+    result = __canonical("", &m_ec);
+    if (m_ec) {
+      return err.report(m_ec);
+    }
+  }
+  if (DNEParts.empty())
+    return result;
+  for (auto It = DNEParts.rbegin(); It != DNEParts.rend(); ++It)
+    result /= *It;
+  return result.lexically_normal();
+}
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
diff --git a/third_party/libcxx/fs/path.cpp b/third_party/libcxx/fs/path.cpp
new file mode 100644
index 000000000..b20195213
--- /dev/null
+++ b/third_party/libcxx/fs/path.cpp
@@ -0,0 +1,441 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+#include <filesystem>
+#include <vector>
+
+#include "error.h"
+#include "path_parser.h"
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+using detail::ErrorHandler;
+using parser::createView;
+using parser::PathParser;
+using parser::string_view_t;
+
+///////////////////////////////////////////////////////////////////////////////
+//                            path definitions
+///////////////////////////////////////////////////////////////////////////////
+
+constexpr path::value_type path::preferred_separator;
+
+path& path::replace_extension(path const& replacement) {
+  path p = extension();
+  if (not p.empty()) {
+    __pn_.erase(__pn_.size() - p.native().size());
+  }
+  if (!replacement.empty()) {
+    if (replacement.native()[0] != '.') {
+      __pn_ += PATHSTR(".");
+    }
+    __pn_.append(replacement.__pn_);
+  }
+  return *this;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// path.decompose
+
+string_view_t path::__root_name() const {
+  auto PP = PathParser::CreateBegin(__pn_);
+  if (PP.State_ == PathParser::PS_InRootName)
+    return *PP;
+  return {};
+}
+
+string_view_t path::__root_directory() const {
+  auto PP = PathParser::CreateBegin(__pn_);
+  if (PP.State_ == PathParser::PS_InRootName)
+    ++PP;
+  if (PP.State_ == PathParser::PS_InRootDir)
+    return *PP;
+  return {};
+}
+
+string_view_t path::__root_path_raw() const {
+  auto PP = PathParser::CreateBegin(__pn_);
+  if (PP.State_ == PathParser::PS_InRootName) {
+    auto NextCh = PP.peek();
+    if (NextCh && isSeparator(*NextCh)) {
+      ++PP;
+      return createView(__pn_.data(), &PP.RawEntry.back());
+    }
+    return PP.RawEntry;
+  }
+  if (PP.State_ == PathParser::PS_InRootDir)
+    return *PP;
+  return {};
+}
+
+static bool ConsumeRootName(PathParser* PP) {
+  static_assert(PathParser::PS_BeforeBegin == 1 && PathParser::PS_InRootName == 2, "Values for enums are incorrect");
+  while (PP->State_ <= PathParser::PS_InRootName)
+    ++(*PP);
+  return PP->State_ == PathParser::PS_AtEnd;
+}
+
+static bool ConsumeRootDir(PathParser* PP) {
+  static_assert(PathParser::PS_BeforeBegin == 1 && PathParser::PS_InRootName == 2 && PathParser::PS_InRootDir == 3,
+                "Values for enums are incorrect");
+  while (PP->State_ <= PathParser::PS_InRootDir)
+    ++(*PP);
+  return PP->State_ == PathParser::PS_AtEnd;
+}
+
+string_view_t path::__relative_path() const {
+  auto PP = PathParser::CreateBegin(__pn_);
+  if (ConsumeRootDir(&PP))
+    return {};
+  return createView(PP.RawEntry.data(), &__pn_.back());
+}
+
+string_view_t path::__parent_path() const {
+  if (empty())
+    return {};
+  // Determine if we have a root path but not a relative path. In that case
+  // return *this.
+  {
+    auto PP = PathParser::CreateBegin(__pn_);
+    if (ConsumeRootDir(&PP))
+      return __pn_;
+  }
+  // Otherwise remove a single element from the end of the path, and return
+  // a string representing that path
+  {
+    auto PP = PathParser::CreateEnd(__pn_);
+    --PP;
+    if (PP.RawEntry.data() == __pn_.data())
+      return {};
+    --PP;
+    return createView(__pn_.data(), &PP.RawEntry.back());
+  }
+}
+
+string_view_t path::__filename() const {
+  if (empty())
+    return {};
+  {
+    PathParser PP = PathParser::CreateBegin(__pn_);
+    if (ConsumeRootDir(&PP))
+      return {};
+  }
+  return *(--PathParser::CreateEnd(__pn_));
+}
+
+string_view_t path::__stem() const { return parser::separate_filename(__filename()).first; }
+
+string_view_t path::__extension() const { return parser::separate_filename(__filename()).second; }
+
+////////////////////////////////////////////////////////////////////////////
+// path.gen
+
+enum PathPartKind : unsigned char { PK_None, PK_RootSep, PK_Filename, PK_Dot, PK_DotDot, PK_TrailingSep };
+
+static PathPartKind ClassifyPathPart(string_view_t Part) {
+  if (Part.empty())
+    return PK_TrailingSep;
+  if (Part == PATHSTR("."))
+    return PK_Dot;
+  if (Part == PATHSTR(".."))
+    return PK_DotDot;
+  if (Part == PATHSTR("/"))
+    return PK_RootSep;
+#if defined(_LIBCPP_WIN32API)
+  if (Part == PATHSTR("\\"))
+    return PK_RootSep;
+#endif
+  return PK_Filename;
+}
+
+path path::lexically_normal() const {
+  if (__pn_.empty())
+    return *this;
+
+  using PartKindPair = pair<string_view_t, PathPartKind>;
+  vector<PartKindPair> Parts;
+  // Guess as to how many elements the path has to avoid reallocating.
+  Parts.reserve(32);
+
+  // Track the total size of the parts as we collect them. This allows the
+  // resulting path to reserve the correct amount of memory.
+  size_t NewPathSize = 0;
+  auto AddPart       = [&](PathPartKind K, string_view_t P) {
+    NewPathSize += P.size();
+    Parts.emplace_back(P, K);
+  };
+  auto LastPartKind = [&]() {
+    if (Parts.empty())
+      return PK_None;
+    return Parts.back().second;
+  };
+
+  bool MaybeNeedTrailingSep = false;
+  // Build a stack containing the remaining elements of the path, popping off
+  // elements which occur before a '..' entry.
+  for (auto PP = PathParser::CreateBegin(__pn_); PP; ++PP) {
+    auto Part         = *PP;
+    PathPartKind Kind = ClassifyPathPart(Part);
+    switch (Kind) {
+    case PK_Filename:
+    case PK_RootSep: {
+      // Add all non-dot and non-dot-dot elements to the stack of elements.
+      AddPart(Kind, Part);
+      MaybeNeedTrailingSep = false;
+      break;
+    }
+    case PK_DotDot: {
+      // Only push a ".." element if there are no elements preceding the "..",
+      // or if the preceding element is itself "..".
+      auto LastKind = LastPartKind();
+      if (LastKind == PK_Filename) {
+        NewPathSize -= Parts.back().first.size();
+        Parts.pop_back();
+      } else if (LastKind != PK_RootSep)
+        AddPart(PK_DotDot, PATHSTR(".."));
+      MaybeNeedTrailingSep = LastKind == PK_Filename;
+      break;
+    }
+    case PK_Dot:
+    case PK_TrailingSep: {
+      MaybeNeedTrailingSep = true;
+      break;
+    }
+    case PK_None:
+      __libcpp_unreachable();
+    }
+  }
+  // [fs.path.generic]p6.8: If the path is empty, add a dot.
+  if (Parts.empty())
+    return PATHSTR(".");
+
+  // [fs.path.generic]p6.7: If the last filename is dot-dot, remove any
+  // trailing directory-separator.
+  bool NeedTrailingSep = MaybeNeedTrailingSep && LastPartKind() == PK_Filename;
+
+  path Result;
+  Result.__pn_.reserve(Parts.size() + NewPathSize + NeedTrailingSep);
+  for (auto& PK : Parts)
+    Result /= PK.first;
+
+  if (NeedTrailingSep)
+    Result /= PATHSTR("");
+
+  Result.make_preferred();
+  return Result;
+}
+
+static int DetermineLexicalElementCount(PathParser PP) {
+  int Count = 0;
+  for (; PP; ++PP) {
+    auto Elem = *PP;
+    if (Elem == PATHSTR(".."))
+      --Count;
+    else if (Elem != PATHSTR(".") && Elem != PATHSTR(""))
+      ++Count;
+  }
+  return Count;
+}
+
+path path::lexically_relative(const path& base) const {
+  { // perform root-name/root-directory mismatch checks
+    auto PP                      = PathParser::CreateBegin(__pn_);
+    auto PPBase                  = PathParser::CreateBegin(base.__pn_);
+    auto CheckIterMismatchAtBase = [&]() {
+      return PP.State_ != PPBase.State_ && (PP.inRootPath() || PPBase.inRootPath());
+    };
+    if (PP.inRootName() && PPBase.inRootName()) {
+      if (*PP != *PPBase)
+        return {};
+    } else if (CheckIterMismatchAtBase())
+      return {};
+
+    if (PP.inRootPath())
+      ++PP;
+    if (PPBase.inRootPath())
+      ++PPBase;
+    if (CheckIterMismatchAtBase())
+      return {};
+  }
+
+  // Find the first mismatching element
+  auto PP     = PathParser::CreateBegin(__pn_);
+  auto PPBase = PathParser::CreateBegin(base.__pn_);
+  while (PP && PPBase && PP.State_ == PPBase.State_ && *PP == *PPBase) {
+    ++PP;
+    ++PPBase;
+  }
+
+  // If there is no mismatch, return ".".
+  if (!PP && !PPBase)
+    return ".";
+
+  // Otherwise, determine the number of elements, 'n', which are not dot or
+  // dot-dot minus the number of dot-dot elements.
+  int ElemCount = DetermineLexicalElementCount(PPBase);
+  if (ElemCount < 0)
+    return {};
+
+  // if n == 0 and (a == end() || a->empty()), returns path("."); otherwise
+  if (ElemCount == 0 && (PP.atEnd() || *PP == PATHSTR("")))
+    return PATHSTR(".");
+
+  // return a path constructed with 'n' dot-dot elements, followed by the
+  // elements of '*this' after the mismatch.
+  path Result;
+  // FIXME: Reserve enough room in Result that it won't have to re-allocate.
+  while (ElemCount--)
+    Result /= PATHSTR("..");
+  for (; PP; ++PP)
+    Result /= *PP;
+  return Result;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// path.comparisons
+static int CompareRootName(PathParser* LHS, PathParser* RHS) {
+  if (!LHS->inRootName() && !RHS->inRootName())
+    return 0;
+
+  auto GetRootName = [](PathParser* Parser) -> string_view_t { return Parser->inRootName() ? **Parser : PATHSTR(""); };
+  int res          = GetRootName(LHS).compare(GetRootName(RHS));
+  ConsumeRootName(LHS);
+  ConsumeRootName(RHS);
+  return res;
+}
+
+static int CompareRootDir(PathParser* LHS, PathParser* RHS) {
+  if (!LHS->inRootDir() && RHS->inRootDir())
+    return -1;
+  else if (LHS->inRootDir() && !RHS->inRootDir())
+    return 1;
+  else {
+    ConsumeRootDir(LHS);
+    ConsumeRootDir(RHS);
+    return 0;
+  }
+}
+
+static int CompareRelative(PathParser* LHSPtr, PathParser* RHSPtr) {
+  auto& LHS = *LHSPtr;
+  auto& RHS = *RHSPtr;
+
+  int res;
+  while (LHS && RHS) {
+    if ((res = (*LHS).compare(*RHS)) != 0)
+      return res;
+    ++LHS;
+    ++RHS;
+  }
+  return 0;
+}
+
+static int CompareEndState(PathParser* LHS, PathParser* RHS) {
+  if (LHS->atEnd() && !RHS->atEnd())
+    return -1;
+  else if (!LHS->atEnd() && RHS->atEnd())
+    return 1;
+  return 0;
+}
+
+int path::__compare(string_view_t __s) const {
+  auto LHS = PathParser::CreateBegin(__pn_);
+  auto RHS = PathParser::CreateBegin(__s);
+  int res;
+
+  if ((res = CompareRootName(&LHS, &RHS)) != 0)
+    return res;
+
+  if ((res = CompareRootDir(&LHS, &RHS)) != 0)
+    return res;
+
+  if ((res = CompareRelative(&LHS, &RHS)) != 0)
+    return res;
+
+  return CompareEndState(&LHS, &RHS);
+}
+
+////////////////////////////////////////////////////////////////////////////
+// path.nonmembers
+size_t hash_value(const path& __p) noexcept {
+  auto PP           = PathParser::CreateBegin(__p.native());
+  size_t hash_value = 0;
+  hash<string_view_t> hasher;
+  while (PP) {
+    hash_value = __hash_combine(hash_value, hasher(*PP));
+    ++PP;
+  }
+  return hash_value;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// path.itr
+path::iterator path::begin() const {
+  auto PP = PathParser::CreateBegin(__pn_);
+  iterator it;
+  it.__path_ptr_ = this;
+  it.__state_    = static_cast<path::iterator::_ParserState>(PP.State_);
+  it.__entry_    = PP.RawEntry;
+  it.__stashed_elem_.__assign_view(*PP);
+  return it;
+}
+
+path::iterator path::end() const {
+  iterator it{};
+  it.__state_    = path::iterator::_AtEnd;
+  it.__path_ptr_ = this;
+  return it;
+}
+
+path::iterator& path::iterator::__increment() {
+  PathParser PP(__path_ptr_->native(), __entry_, __state_);
+  ++PP;
+  __state_ = static_cast<_ParserState>(PP.State_);
+  __entry_ = PP.RawEntry;
+  __stashed_elem_.__assign_view(*PP);
+  return *this;
+}
+
+path::iterator& path::iterator::__decrement() {
+  PathParser PP(__path_ptr_->native(), __entry_, __state_);
+  --PP;
+  __state_ = static_cast<_ParserState>(PP.State_);
+  __entry_ = PP.RawEntry;
+  __stashed_elem_.__assign_view(*PP);
+  return *this;
+}
+
+#if defined(_LIBCPP_WIN32API)
+////////////////////////////////////////////////////////////////////////////
+// Windows path conversions
+size_t __wide_to_char(const wstring& str, char* out, size_t outlen) {
+  if (str.empty())
+    return 0;
+  ErrorHandler<size_t> err("__wide_to_char", nullptr);
+  UINT codepage     = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
+  BOOL used_default = FALSE;
+  int ret           = WideCharToMultiByte(codepage, 0, str.data(), str.size(), out, outlen, nullptr, &used_default);
+  if (ret <= 0 || used_default)
+    return err.report(errc::illegal_byte_sequence);
+  return ret;
+}
+
+size_t __char_to_wide(const string& str, wchar_t* out, size_t outlen) {
+  if (str.empty())
+    return 0;
+  ErrorHandler<size_t> err("__char_to_wide", nullptr);
+  UINT codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
+  int ret       = MultiByteToWideChar(codepage, MB_ERR_INVALID_CHARS, str.data(), str.size(), out, outlen);
+  if (ret <= 0)
+    return err.report(errc::illegal_byte_sequence);
+  return ret;
+}
+#endif
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
diff --git a/third_party/libcxx/fs/path_parser.h b/third_party/libcxx/fs/path_parser.h
new file mode 100644
index 000000000..066236964
--- /dev/null
+++ b/third_party/libcxx/fs/path_parser.h
@@ -0,0 +1,352 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef PATH_PARSER_H
+#define PATH_PARSER_H
+
+#include <__config>
+#include <__utility/unreachable.h>
+#include <cstddef>
+#include <filesystem>
+#include <utility>
+
+#include "format_string.h"
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+inline bool isSeparator(path::value_type C) {
+  if (C == '/')
+    return true;
+#if defined(_LIBCPP_WIN32API)
+  if (C == '\\')
+    return true;
+#endif
+  return false;
+}
+
+inline bool isDriveLetter(path::value_type C) { return (C >= 'a' && C <= 'z') || (C >= 'A' && C <= 'Z'); }
+
+namespace parser {
+
+using string_view_t    = path::__string_view;
+using string_view_pair = pair<string_view_t, string_view_t>;
+using PosPtr           = path::value_type const*;
+
+struct PathParser {
+  enum ParserState : unsigned char {
+    // Zero is a special sentinel value used by default constructed iterators.
+    PS_BeforeBegin   = path::iterator::_BeforeBegin,
+    PS_InRootName    = path::iterator::_InRootName,
+    PS_InRootDir     = path::iterator::_InRootDir,
+    PS_InFilenames   = path::iterator::_InFilenames,
+    PS_InTrailingSep = path::iterator::_InTrailingSep,
+    PS_AtEnd         = path::iterator::_AtEnd
+  };
+
+  const string_view_t Path;
+  string_view_t RawEntry;
+  ParserState State_;
+
+private:
+  PathParser(string_view_t P, ParserState State) noexcept : Path(P), State_(State) {}
+
+public:
+  PathParser(string_view_t P, string_view_t E, unsigned char S)
+      : Path(P), RawEntry(E), State_(static_cast<ParserState>(S)) {
+    // S cannot be '0' or PS_BeforeBegin.
+  }
+
+  static PathParser CreateBegin(string_view_t P) noexcept {
+    PathParser PP(P, PS_BeforeBegin);
+    PP.increment();
+    return PP;
+  }
+
+  static PathParser CreateEnd(string_view_t P) noexcept {
+    PathParser PP(P, PS_AtEnd);
+    return PP;
+  }
+
+  PosPtr peek() const noexcept {
+    auto TkEnd = getNextTokenStartPos();
+    auto End   = getAfterBack();
+    return TkEnd == End ? nullptr : TkEnd;
+  }
+
+  void increment() noexcept {
+    const PosPtr End   = getAfterBack();
+    const PosPtr Start = getNextTokenStartPos();
+    if (Start == End)
+      return makeState(PS_AtEnd);
+
+    switch (State_) {
+    case PS_BeforeBegin: {
+      PosPtr TkEnd = consumeRootName(Start, End);
+      if (TkEnd)
+        return makeState(PS_InRootName, Start, TkEnd);
+    }
+      _LIBCPP_FALLTHROUGH();
+    case PS_InRootName: {
+      PosPtr TkEnd = consumeAllSeparators(Start, End);
+      if (TkEnd)
+        return makeState(PS_InRootDir, Start, TkEnd);
+      else
+        return makeState(PS_InFilenames, Start, consumeName(Start, End));
+    }
+    case PS_InRootDir:
+      return makeState(PS_InFilenames, Start, consumeName(Start, End));
+
+    case PS_InFilenames: {
+      PosPtr SepEnd = consumeAllSeparators(Start, End);
+      if (SepEnd != End) {
+        PosPtr TkEnd = consumeName(SepEnd, End);
+        if (TkEnd)
+          return makeState(PS_InFilenames, SepEnd, TkEnd);
+      }
+      return makeState(PS_InTrailingSep, Start, SepEnd);
+    }
+
+    case PS_InTrailingSep:
+      return makeState(PS_AtEnd);
+
+    case PS_AtEnd:
+      __libcpp_unreachable();
+    }
+  }
+
+  void decrement() noexcept {
+    const PosPtr REnd   = getBeforeFront();
+    const PosPtr RStart = getCurrentTokenStartPos() - 1;
+    if (RStart == REnd) // we're decrementing the begin
+      return makeState(PS_BeforeBegin);
+
+    switch (State_) {
+    case PS_AtEnd: {
+      // Try to consume a trailing separator or root directory first.
+      if (PosPtr SepEnd = consumeAllSeparators(RStart, REnd)) {
+        if (SepEnd == REnd)
+          return makeState(PS_InRootDir, Path.data(), RStart + 1);
+        PosPtr TkStart = consumeRootName(SepEnd, REnd);
+        if (TkStart == REnd)
+          return makeState(PS_InRootDir, RStart, RStart + 1);
+        return makeState(PS_InTrailingSep, SepEnd + 1, RStart + 1);
+      } else {
+        PosPtr TkStart = consumeRootName(RStart, REnd);
+        if (TkStart == REnd)
+          return makeState(PS_InRootName, TkStart + 1, RStart + 1);
+        TkStart = consumeName(RStart, REnd);
+        return makeState(PS_InFilenames, TkStart + 1, RStart + 1);
+      }
+    }
+    case PS_InTrailingSep:
+      return makeState(PS_InFilenames, consumeName(RStart, REnd) + 1, RStart + 1);
+    case PS_InFilenames: {
+      PosPtr SepEnd = consumeAllSeparators(RStart, REnd);
+      if (SepEnd == REnd)
+        return makeState(PS_InRootDir, Path.data(), RStart + 1);
+      PosPtr TkStart = consumeRootName(SepEnd ? SepEnd : RStart, REnd);
+      if (TkStart == REnd) {
+        if (SepEnd)
+          return makeState(PS_InRootDir, SepEnd + 1, RStart + 1);
+        return makeState(PS_InRootName, TkStart + 1, RStart + 1);
+      }
+      TkStart = consumeName(SepEnd, REnd);
+      return makeState(PS_InFilenames, TkStart + 1, SepEnd + 1);
+    }
+    case PS_InRootDir:
+      return makeState(PS_InRootName, Path.data(), RStart + 1);
+    case PS_InRootName:
+    case PS_BeforeBegin:
+      __libcpp_unreachable();
+    }
+  }
+
+  /// \brief Return a view with the "preferred representation" of the current
+  ///   element. For example trailing separators are represented as a '.'
+  string_view_t operator*() const noexcept {
+    switch (State_) {
+    case PS_BeforeBegin:
+    case PS_AtEnd:
+      return PATHSTR("");
+    case PS_InRootDir:
+      if (RawEntry[0] == '\\')
+        return PATHSTR("\\");
+      else
+        return PATHSTR("/");
+    case PS_InTrailingSep:
+      return PATHSTR("");
+    case PS_InRootName:
+    case PS_InFilenames:
+      return RawEntry;
+    }
+    __libcpp_unreachable();
+  }
+
+  explicit operator bool() const noexcept { return State_ != PS_BeforeBegin && State_ != PS_AtEnd; }
+
+  PathParser& operator++() noexcept {
+    increment();
+    return *this;
+  }
+
+  PathParser& operator--() noexcept {
+    decrement();
+    return *this;
+  }
+
+  bool atEnd() const noexcept { return State_ == PS_AtEnd; }
+
+  bool inRootDir() const noexcept { return State_ == PS_InRootDir; }
+
+  bool inRootName() const noexcept { return State_ == PS_InRootName; }
+
+  bool inRootPath() const noexcept { return inRootName() || inRootDir(); }
+
+private:
+  void makeState(ParserState NewState, PosPtr Start, PosPtr End) noexcept {
+    State_    = NewState;
+    RawEntry = string_view_t(Start, End - Start);
+  }
+  void makeState(ParserState NewState) noexcept {
+    State_    = NewState;
+    RawEntry = {};
+  }
+
+  PosPtr getAfterBack() const noexcept { return Path.data() + Path.size(); }
+
+  PosPtr getBeforeFront() const noexcept { return Path.data() - 1; }
+
+  /// \brief Return a pointer to the first character after the currently
+  ///   lexed element.
+  PosPtr getNextTokenStartPos() const noexcept {
+    switch (State_) {
+    case PS_BeforeBegin:
+      return Path.data();
+    case PS_InRootName:
+    case PS_InRootDir:
+    case PS_InFilenames:
+      return &RawEntry.back() + 1;
+    case PS_InTrailingSep:
+    case PS_AtEnd:
+      return getAfterBack();
+    }
+    __libcpp_unreachable();
+  }
+
+  /// \brief Return a pointer to the first character in the currently lexed
+  ///   element.
+  PosPtr getCurrentTokenStartPos() const noexcept {
+    switch (State_) {
+    case PS_BeforeBegin:
+    case PS_InRootName:
+      return &Path.front();
+    case PS_InRootDir:
+    case PS_InFilenames:
+    case PS_InTrailingSep:
+      return &RawEntry.front();
+    case PS_AtEnd:
+      return &Path.back() + 1;
+    }
+    __libcpp_unreachable();
+  }
+
+  // Consume all consecutive separators.
+  PosPtr consumeAllSeparators(PosPtr P, PosPtr End) const noexcept {
+    if (P == nullptr || P == End || !isSeparator(*P))
+      return nullptr;
+    const int Inc = P < End ? 1 : -1;
+    P += Inc;
+    while (P != End && isSeparator(*P))
+      P += Inc;
+    return P;
+  }
+
+  // Consume exactly N separators, or return nullptr.
+  PosPtr consumeNSeparators(PosPtr P, PosPtr End, int N) const noexcept {
+    PosPtr Ret = consumeAllSeparators(P, End);
+    if (Ret == nullptr)
+      return nullptr;
+    if (P < End) {
+      if (Ret == P + N)
+        return Ret;
+    } else {
+      if (Ret == P - N)
+        return Ret;
+    }
+    return nullptr;
+  }
+
+  PosPtr consumeName(PosPtr P, PosPtr End) const noexcept {
+    PosPtr Start = P;
+    if (P == nullptr || P == End || isSeparator(*P))
+      return nullptr;
+    const int Inc = P < End ? 1 : -1;
+    P += Inc;
+    while (P != End && !isSeparator(*P))
+      P += Inc;
+    if (P == End && Inc < 0) {
+      // Iterating backwards and consumed all the rest of the input.
+      // Check if the start of the string would have been considered
+      // a root name.
+      PosPtr RootEnd = consumeRootName(End + 1, Start);
+      if (RootEnd)
+        return RootEnd - 1;
+    }
+    return P;
+  }
+
+  PosPtr consumeDriveLetter(PosPtr P, PosPtr End) const noexcept {
+    if (P == End)
+      return nullptr;
+    if (P < End) {
+      if (P + 1 == End || !isDriveLetter(P[0]) || P[1] != ':')
+        return nullptr;
+      return P + 2;
+    } else {
+      if (P - 1 == End || !isDriveLetter(P[-1]) || P[0] != ':')
+        return nullptr;
+      return P - 2;
+    }
+  }
+
+  PosPtr consumeNetworkRoot(PosPtr P, PosPtr End) const noexcept {
+    if (P == End)
+      return nullptr;
+    if (P < End)
+      return consumeName(consumeNSeparators(P, End, 2), End);
+    else
+      return consumeNSeparators(consumeName(P, End), End, 2);
+  }
+
+  PosPtr consumeRootName(PosPtr P, PosPtr End) const noexcept {
+#if defined(_LIBCPP_WIN32API)
+    if (PosPtr Ret = consumeDriveLetter(P, End))
+      return Ret;
+    if (PosPtr Ret = consumeNetworkRoot(P, End))
+      return Ret;
+#endif
+    return nullptr;
+  }
+};
+
+inline string_view_pair separate_filename(string_view_t const& s) {
+  if (s == PATHSTR(".") || s == PATHSTR("..") || s.empty())
+    return string_view_pair{s, PATHSTR("")};
+  auto pos = s.find_last_of('.');
+  if (pos == string_view_t::npos || pos == 0)
+    return string_view_pair{s, string_view_t{}};
+  return string_view_pair{s.substr(0, pos), s.substr(pos)};
+}
+
+inline string_view_t createView(PosPtr S, PosPtr E) noexcept { return {S, static_cast<size_t>(E - S) + 1}; }
+
+} // namespace parser
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
+
+#endif // PATH_PARSER_H
diff --git a/third_party/libcxx/fs/posix_compat.h b/third_party/libcxx/fs/posix_compat.h
new file mode 100644
index 000000000..760cdb65d
--- /dev/null
+++ b/third_party/libcxx/fs/posix_compat.h
@@ -0,0 +1,497 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+//
+// POSIX-like portability helper functions.
+//
+// These generally behave like the proper posix functions, with these
+// exceptions:
+// On Windows, they take paths in wchar_t* form, instead of char* form.
+// The symlink() function is split into two frontends, symlink_file()
+// and symlink_dir().
+//
+// These are provided within an anonymous namespace within the detail
+// namespace - callers need to include this header and call them as
+// detail::function(), regardless of platform.
+//
+
+#ifndef POSIX_COMPAT_H
+#define POSIX_COMPAT_H
+
+#include <__assert>
+#include <__config>
+#include <filesystem>
+
+#include "error.h"
+#include "time_utils.h"
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <io.h>
+#  include <windows.h>
+#  include <winioctl.h>
+#else
+#  include <fcntl.h>
+#  include <sys/stat.h>
+#  include <sys/statvfs.h>
+#  include <sys/time.h>
+#  include <unistd.h>
+#endif
+#include <stdlib.h>
+#include <time.h>
+
+#if defined(_LIBCPP_WIN32API)
+// This struct isn't defined in the normal Windows SDK, but only in the
+// Windows Driver Kit.
+struct LIBCPP_REPARSE_DATA_BUFFER {
+  unsigned long ReparseTag;
+  unsigned short ReparseDataLength;
+  unsigned short Reserved;
+  union {
+    struct {
+      unsigned short SubstituteNameOffset;
+      unsigned short SubstituteNameLength;
+      unsigned short PrintNameOffset;
+      unsigned short PrintNameLength;
+      unsigned long Flags;
+      wchar_t PathBuffer[1];
+    } SymbolicLinkReparseBuffer;
+    struct {
+      unsigned short SubstituteNameOffset;
+      unsigned short SubstituteNameLength;
+      unsigned short PrintNameOffset;
+      unsigned short PrintNameLength;
+      wchar_t PathBuffer[1];
+    } MountPointReparseBuffer;
+    struct {
+      unsigned char DataBuffer[1];
+    } GenericReparseBuffer;
+  };
+};
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+namespace detail {
+
+#if defined(_LIBCPP_WIN32API)
+
+// Various C runtime header sets provide more or less of these. As we
+// provide our own implementation, undef all potential defines from the
+// C runtime headers and provide a complete set of macros of our own.
+
+#  undef _S_IFMT
+#  undef _S_IFDIR
+#  undef _S_IFCHR
+#  undef _S_IFIFO
+#  undef _S_IFREG
+#  undef _S_IFBLK
+#  undef _S_IFLNK
+#  undef _S_IFSOCK
+
+#  define _S_IFMT 0xF000
+#  define _S_IFDIR 0x4000
+#  define _S_IFCHR 0x2000
+#  define _S_IFIFO 0x1000
+#  define _S_IFREG 0x8000
+#  define _S_IFBLK 0x6000
+#  define _S_IFLNK 0xA000
+#  define _S_IFSOCK 0xC000
+
+#  undef S_ISDIR
+#  undef S_ISFIFO
+#  undef S_ISCHR
+#  undef S_ISREG
+#  undef S_ISLNK
+#  undef S_ISBLK
+#  undef S_ISSOCK
+
+#  define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)
+#  define S_ISCHR(m) (((m) & _S_IFMT) == _S_IFCHR)
+#  define S_ISFIFO(m) (((m) & _S_IFMT) == _S_IFIFO)
+#  define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)
+#  define S_ISBLK(m) (((m) & _S_IFMT) == _S_IFBLK)
+#  define S_ISLNK(m) (((m) & _S_IFMT) == _S_IFLNK)
+#  define S_ISSOCK(m) (((m) & _S_IFMT) == _S_IFSOCK)
+
+#  define O_NONBLOCK 0
+
+inline int set_errno(int e = GetLastError()) {
+  errno = static_cast<int>(__win_err_to_errc(e));
+  return -1;
+}
+
+class WinHandle {
+public:
+  WinHandle(const wchar_t* p, DWORD access, DWORD flags) {
+    h = CreateFileW(
+        p,
+        access,
+        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+        nullptr,
+        OPEN_EXISTING,
+        FILE_FLAG_BACKUP_SEMANTICS | flags,
+        nullptr);
+  }
+  ~WinHandle() {
+    if (h != INVALID_HANDLE_VALUE)
+      CloseHandle(h);
+  }
+  operator HANDLE() const { return h; }
+  operator bool() const { return h != INVALID_HANDLE_VALUE; }
+
+private:
+  HANDLE h;
+};
+
+inline int stat_handle(HANDLE h, StatT* buf) {
+  FILE_BASIC_INFO basic;
+  if (!GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic)))
+    return set_errno();
+  memset(buf, 0, sizeof(*buf));
+  buf->st_mtim = filetime_to_timespec(basic.LastWriteTime);
+  buf->st_atim = filetime_to_timespec(basic.LastAccessTime);
+  buf->st_mode = 0555; // Read-only
+  if (!(basic.FileAttributes & FILE_ATTRIBUTE_READONLY))
+    buf->st_mode |= 0222; // Write
+  if (basic.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+    buf->st_mode |= _S_IFDIR;
+  } else {
+    buf->st_mode |= _S_IFREG;
+  }
+  if (basic.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+    FILE_ATTRIBUTE_TAG_INFO tag;
+    if (!GetFileInformationByHandleEx(h, FileAttributeTagInfo, &tag, sizeof(tag)))
+      return set_errno();
+    if (tag.ReparseTag == IO_REPARSE_TAG_SYMLINK)
+      buf->st_mode = (buf->st_mode & ~_S_IFMT) | _S_IFLNK;
+  }
+  FILE_STANDARD_INFO standard;
+  if (!GetFileInformationByHandleEx(h, FileStandardInfo, &standard, sizeof(standard)))
+    return set_errno();
+  buf->st_nlink = standard.NumberOfLinks;
+  buf->st_size  = standard.EndOfFile.QuadPart;
+  BY_HANDLE_FILE_INFORMATION info;
+  if (!GetFileInformationByHandle(h, &info))
+    return set_errno();
+  buf->st_dev = info.dwVolumeSerialNumber;
+  memcpy(&buf->st_ino.id[0], &info.nFileIndexHigh, 4);
+  memcpy(&buf->st_ino.id[4], &info.nFileIndexLow, 4);
+  return 0;
+}
+
+inline int stat_file(const wchar_t* path, StatT* buf, DWORD flags) {
+  WinHandle h(path, FILE_READ_ATTRIBUTES, flags);
+  if (!h)
+    return set_errno();
+  int ret = stat_handle(h, buf);
+  return ret;
+}
+
+inline int stat(const wchar_t* path, StatT* buf) { return stat_file(path, buf, 0); }
+
+inline int lstat(const wchar_t* path, StatT* buf) { return stat_file(path, buf, FILE_FLAG_OPEN_REPARSE_POINT); }
+
+inline int fstat(int fd, StatT* buf) {
+  HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
+  return stat_handle(h, buf);
+}
+
+inline int mkdir(const wchar_t* path, int permissions) {
+  (void)permissions;
+  if (!CreateDirectoryW(path, nullptr))
+    return set_errno();
+  return 0;
+}
+
+inline int symlink_file_dir(const wchar_t* oldname, const wchar_t* newname, bool is_dir) {
+  path dest(oldname);
+  dest.make_preferred();
+  oldname     = dest.c_str();
+  DWORD flags = is_dir ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
+  if (CreateSymbolicLinkW(newname, oldname, flags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE))
+    return 0;
+  int e = GetLastError();
+  if (e != ERROR_INVALID_PARAMETER)
+    return set_errno(e);
+  if (CreateSymbolicLinkW(newname, oldname, flags))
+    return 0;
+  return set_errno();
+}
+
+inline int symlink_file(const wchar_t* oldname, const wchar_t* newname) {
+  return symlink_file_dir(oldname, newname, false);
+}
+
+inline int symlink_dir(const wchar_t* oldname, const wchar_t* newname) {
+  return symlink_file_dir(oldname, newname, true);
+}
+
+inline int link(const wchar_t* oldname, const wchar_t* newname) {
+  if (CreateHardLinkW(newname, oldname, nullptr))
+    return 0;
+  return set_errno();
+}
+
+inline int remove(const wchar_t* path) {
+  detail::WinHandle h(path, DELETE, FILE_FLAG_OPEN_REPARSE_POINT);
+  if (!h)
+    return set_errno();
+  FILE_DISPOSITION_INFO info;
+  info.DeleteFile = TRUE;
+  if (!SetFileInformationByHandle(h, FileDispositionInfo, &info, sizeof(info)))
+    return set_errno();
+  return 0;
+}
+
+inline int truncate_handle(HANDLE h, off_t length) {
+  LARGE_INTEGER size_param;
+  size_param.QuadPart = length;
+  if (!SetFilePointerEx(h, size_param, 0, FILE_BEGIN))
+    return set_errno();
+  if (!SetEndOfFile(h))
+    return set_errno();
+  return 0;
+}
+
+inline int ftruncate(int fd, off_t length) {
+  HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
+  return truncate_handle(h, length);
+}
+
+inline int truncate(const wchar_t* path, off_t length) {
+  detail::WinHandle h(path, GENERIC_WRITE, 0);
+  if (!h)
+    return set_errno();
+  return truncate_handle(h, length);
+}
+
+inline int rename(const wchar_t* from, const wchar_t* to) {
+  if (!(MoveFileExW(from, to, MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH)))
+    return set_errno();
+  return 0;
+}
+
+inline int chdir(const wchar_t* path) {
+  if (!SetCurrentDirectoryW(path))
+    return set_errno();
+  return 0;
+}
+
+struct StatVFS {
+  uint64_t f_frsize;
+  uint64_t f_blocks;
+  uint64_t f_bfree;
+  uint64_t f_bavail;
+};
+
+inline int statvfs(const wchar_t* p, StatVFS* buf) {
+  path dir = p;
+  while (true) {
+    error_code local_ec;
+    const file_status st = status(dir, local_ec);
+    if (!exists(st) || is_directory(st))
+      break;
+    path parent = dir.parent_path();
+    if (parent == dir) {
+      errno = ENOENT;
+      return -1;
+    }
+    dir = parent;
+  }
+  ULARGE_INTEGER free_bytes_available_to_caller, total_number_of_bytes, total_number_of_free_bytes;
+  if (!GetDiskFreeSpaceExW(
+          dir.c_str(), &free_bytes_available_to_caller, &total_number_of_bytes, &total_number_of_free_bytes))
+    return set_errno();
+  buf->f_frsize = 1;
+  buf->f_blocks = total_number_of_bytes.QuadPart;
+  buf->f_bfree  = total_number_of_free_bytes.QuadPart;
+  buf->f_bavail = free_bytes_available_to_caller.QuadPart;
+  return 0;
+}
+
+inline wchar_t* getcwd([[maybe_unused]] wchar_t* in_buf, [[maybe_unused]] size_t in_size) {
+  // Only expected to be used with us allocating the buffer.
+  _LIBCPP_ASSERT_INTERNAL(in_buf == nullptr, "Windows getcwd() assumes in_buf==nullptr");
+  _LIBCPP_ASSERT_INTERNAL(in_size == 0, "Windows getcwd() assumes in_size==0");
+
+  size_t buff_size = MAX_PATH + 10;
+  std::unique_ptr<wchar_t, decltype(&::free)> buff(static_cast<wchar_t*>(malloc(buff_size * sizeof(wchar_t))), &::free);
+  DWORD retval = GetCurrentDirectoryW(buff_size, buff.get());
+  if (retval > buff_size) {
+    buff_size = retval;
+    buff.reset(static_cast<wchar_t*>(malloc(buff_size * sizeof(wchar_t))));
+    retval = GetCurrentDirectoryW(buff_size, buff.get());
+  }
+  if (!retval) {
+    set_errno();
+    return nullptr;
+  }
+  return buff.release();
+}
+
+inline wchar_t* realpath(const wchar_t* path, [[maybe_unused]] wchar_t* resolved_name) {
+  // Only expected to be used with us allocating the buffer.
+  _LIBCPP_ASSERT_INTERNAL(resolved_name == nullptr, "Windows realpath() assumes a null resolved_name");
+
+  WinHandle h(path, FILE_READ_ATTRIBUTES, 0);
+  if (!h) {
+    set_errno();
+    return nullptr;
+  }
+  size_t buff_size = MAX_PATH + 10;
+  std::unique_ptr<wchar_t, decltype(&::free)> buff(static_cast<wchar_t*>(malloc(buff_size * sizeof(wchar_t))), &::free);
+  DWORD retval = GetFinalPathNameByHandleW(h, buff.get(), buff_size, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
+  if (retval > buff_size) {
+    buff_size = retval;
+    buff.reset(static_cast<wchar_t*>(malloc(buff_size * sizeof(wchar_t))));
+    retval = GetFinalPathNameByHandleW(h, buff.get(), buff_size, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
+  }
+  if (!retval) {
+    set_errno();
+    return nullptr;
+  }
+  wchar_t* ptr = buff.get();
+  if (!wcsncmp(ptr, L"\\\\?\\", 4)) {
+    if (ptr[5] == ':') { // \\?\X: -> X:
+      memmove(&ptr[0], &ptr[4], (wcslen(&ptr[4]) + 1) * sizeof(wchar_t));
+    } else if (!wcsncmp(&ptr[4], L"UNC\\", 4)) { // \\?\UNC\server -> \\server
+      wcscpy(&ptr[0], L"\\\\");
+      memmove(&ptr[2], &ptr[8], (wcslen(&ptr[8]) + 1) * sizeof(wchar_t));
+    }
+  }
+  return buff.release();
+}
+
+#  define AT_FDCWD -1
+#  define AT_SYMLINK_NOFOLLOW 1
+using ModeT = int;
+
+inline int fchmod_handle(HANDLE h, int perms) {
+  FILE_BASIC_INFO basic;
+  if (!GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic)))
+    return set_errno();
+  DWORD orig_attributes = basic.FileAttributes;
+  basic.FileAttributes &= ~FILE_ATTRIBUTE_READONLY;
+  if ((perms & 0222) == 0)
+    basic.FileAttributes |= FILE_ATTRIBUTE_READONLY;
+  if (basic.FileAttributes != orig_attributes && !SetFileInformationByHandle(h, FileBasicInfo, &basic, sizeof(basic)))
+    return set_errno();
+  return 0;
+}
+
+inline int fchmodat(int /*fd*/, const wchar_t* path, int perms, int flag) {
+  DWORD attributes = GetFileAttributesW(path);
+  if (attributes == INVALID_FILE_ATTRIBUTES)
+    return set_errno();
+  if (attributes & FILE_ATTRIBUTE_REPARSE_POINT && !(flag & AT_SYMLINK_NOFOLLOW)) {
+    // If the file is a symlink, and we are supposed to operate on the target
+    // of the symlink, we need to open a handle to it, without the
+    // FILE_FLAG_OPEN_REPARSE_POINT flag, to open the destination of the
+    // symlink, and operate on it via the handle.
+    detail::WinHandle h(path, FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES, 0);
+    if (!h)
+      return set_errno();
+    return fchmod_handle(h, perms);
+  } else {
+    // For a non-symlink, or if operating on the symlink itself instead of
+    // its target, we can use SetFileAttributesW, saving a few calls.
+    DWORD orig_attributes = attributes;
+    attributes &= ~FILE_ATTRIBUTE_READONLY;
+    if ((perms & 0222) == 0)
+      attributes |= FILE_ATTRIBUTE_READONLY;
+    if (attributes != orig_attributes && !SetFileAttributesW(path, attributes))
+      return set_errno();
+  }
+  return 0;
+}
+
+inline int fchmod(int fd, int perms) {
+  HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
+  return fchmod_handle(h, perms);
+}
+
+#  define MAX_SYMLINK_SIZE MAXIMUM_REPARSE_DATA_BUFFER_SIZE
+using SSizeT = ::int64_t;
+
+inline SSizeT readlink(const wchar_t* path, wchar_t* ret_buf, size_t bufsize) {
+  uint8_t buf[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
+  detail::WinHandle h(path, FILE_READ_ATTRIBUTES, FILE_FLAG_OPEN_REPARSE_POINT);
+  if (!h)
+    return set_errno();
+  DWORD out;
+  if (!DeviceIoControl(h, FSCTL_GET_REPARSE_POINT, nullptr, 0, buf, sizeof(buf), &out, 0))
+    return set_errno();
+  const auto* reparse    = reinterpret_cast<LIBCPP_REPARSE_DATA_BUFFER*>(buf);
+  size_t path_buf_offset = offsetof(LIBCPP_REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer[0]);
+  if (out < path_buf_offset) {
+    errno = EINVAL;
+    return -1;
+  }
+  if (reparse->ReparseTag != IO_REPARSE_TAG_SYMLINK) {
+    errno = EINVAL;
+    return -1;
+  }
+  const auto& symlink = reparse->SymbolicLinkReparseBuffer;
+  unsigned short name_offset, name_length;
+  if (symlink.PrintNameLength == 0) {
+    name_offset = symlink.SubstituteNameOffset;
+    name_length = symlink.SubstituteNameLength;
+  } else {
+    name_offset = symlink.PrintNameOffset;
+    name_length = symlink.PrintNameLength;
+  }
+  // name_offset/length are expressed in bytes, not in wchar_t
+  if (path_buf_offset + name_offset + name_length > out) {
+    errno = EINVAL;
+    return -1;
+  }
+  if (name_length / sizeof(wchar_t) > bufsize) {
+    errno = ENOMEM;
+    return -1;
+  }
+  memcpy(ret_buf, &symlink.PathBuffer[name_offset / sizeof(wchar_t)], name_length);
+  return name_length / sizeof(wchar_t);
+}
+
+#else
+inline int symlink_file(const char* oldname, const char* newname) { return ::symlink(oldname, newname); }
+inline int symlink_dir(const char* oldname, const char* newname) { return ::symlink(oldname, newname); }
+using ::chdir;
+using ::fchmod;
+#  if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
+using ::fchmodat;
+#  endif
+using ::fstat;
+using ::ftruncate;
+using ::getcwd;
+using ::link;
+using ::lstat;
+using ::mkdir;
+using ::readlink;
+using ::realpath;
+using ::remove;
+using ::rename;
+using ::stat;
+using ::statvfs;
+using ::truncate;
+
+#  define O_BINARY 0
+
+using StatVFS = struct statvfs;
+using ModeT   = ::mode_t;
+using SSizeT  = ::ssize_t;
+
+#endif
+
+} // end namespace detail
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
+
+#endif // POSIX_COMPAT_H
diff --git a/third_party/libcxx/fs/time_utils.h b/third_party/libcxx/fs/time_utils.h
new file mode 100644
index 000000000..e05f25286
--- /dev/null
+++ b/third_party/libcxx/fs/time_utils.h
@@ -0,0 +1,351 @@
+//===----------------------------------------------------------------------===////
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===////
+
+#ifndef FILESYSTEM_TIME_UTILS_H
+#define FILESYSTEM_TIME_UTILS_H
+
+#include <__config>
+#include <array>
+#include <chrono>
+#include <filesystem>
+#include <limits>
+#include <ratio>
+#include <system_error>
+#include <type_traits>
+#include <utility>
+
+#include "error.h"
+#include "format_string.h"
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <windows.h>
+#else
+#  include <fcntl.h>
+#  include <sys/stat.h>
+#  include <sys/time.h> // for ::utimes as used in __last_write_time
+#endif
+
+// We can use the presence of UTIME_OMIT to detect platforms that provide utimensat.
+#if defined(UTIME_OMIT)
+#  define _LIBCPP_USE_UTIMENSAT
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+namespace detail {
+
+#if defined(_LIBCPP_WIN32API)
+// Various C runtime versions (UCRT, or the legacy msvcrt.dll used by
+// some mingw toolchains) provide different stat function implementations,
+// with a number of limitations with respect to what we want from the
+// stat function. Instead provide our own which does exactly what we want,
+// along with our own stat structure and flag macros.
+
+struct TimeSpec {
+  int64_t tv_sec;
+  int64_t tv_nsec;
+};
+struct StatT {
+  unsigned st_mode;
+  TimeSpec st_atim;
+  TimeSpec st_mtim;
+  uint64_t st_dev; // FILE_ID_INFO::VolumeSerialNumber
+  struct FileIdStruct {
+    unsigned char id[16]; // FILE_ID_INFO::FileId
+    bool operator==(const FileIdStruct& other) const {
+      for (int i = 0; i < 16; i++)
+        if (id[i] != other.id[i])
+          return false;
+      return true;
+    }
+  } st_ino;
+  uint32_t st_nlink;
+  uintmax_t st_size;
+};
+
+// There were 369 years and 89 leap days from the Windows epoch
+// (1601) to the Unix epoch (1970).
+#  define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60))
+
+inline TimeSpec filetime_to_timespec(LARGE_INTEGER li) {
+  TimeSpec ret;
+  ret.tv_sec  = li.QuadPart / 10000000 - FILE_TIME_OFFSET_SECS;
+  ret.tv_nsec = (li.QuadPart % 10000000) * 100;
+  return ret;
+}
+
+inline TimeSpec filetime_to_timespec(FILETIME ft) {
+  LARGE_INTEGER li;
+  li.LowPart  = ft.dwLowDateTime;
+  li.HighPart = ft.dwHighDateTime;
+  return filetime_to_timespec(li);
+}
+
+inline FILETIME timespec_to_filetime(TimeSpec ts) {
+  LARGE_INTEGER li;
+  li.QuadPart = ts.tv_nsec / 100 + (ts.tv_sec + FILE_TIME_OFFSET_SECS) * 10000000;
+  FILETIME ft;
+  ft.dwLowDateTime  = li.LowPart;
+  ft.dwHighDateTime = li.HighPart;
+  return ft;
+}
+
+#else
+using TimeSpec = struct timespec;
+using TimeVal  = struct timeval;
+using StatT    = struct stat;
+
+inline TimeVal make_timeval(TimeSpec const& ts) {
+  using namespace chrono;
+  auto Convert = [](long nsec) {
+    using int_type = decltype(std::declval<TimeVal>().tv_usec);
+    auto dur       = duration_cast<microseconds>(nanoseconds(nsec)).count();
+    return static_cast<int_type>(dur);
+  };
+  TimeVal TV = {};
+  TV.tv_sec  = ts.tv_sec;
+  TV.tv_usec = Convert(ts.tv_nsec);
+  return TV;
+}
+#endif
+
+using chrono::duration;
+using chrono::duration_cast;
+
+template <class FileTimeT, class TimeT, bool IsFloat = is_floating_point<typename FileTimeT::rep>::value>
+struct time_util_base {
+  using rep             = typename FileTimeT::rep;
+  using fs_duration     = typename FileTimeT::duration;
+  using fs_seconds      = duration<rep>;
+  using fs_nanoseconds  = duration<rep, nano>;
+  using fs_microseconds = duration<rep, micro>;
+
+  static constexpr rep max_seconds = duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
+
+  static constexpr rep max_nsec =
+      duration_cast<fs_nanoseconds>(FileTimeT::duration::max() - fs_seconds(max_seconds)).count();
+
+  static constexpr rep min_seconds = duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
+
+  static constexpr rep min_nsec_timespec =
+      duration_cast<fs_nanoseconds>((FileTimeT::duration::min() - fs_seconds(min_seconds)) + fs_seconds(1)).count();
+
+private:
+  static constexpr fs_duration get_min_nsecs() {
+    return duration_cast<fs_duration>(fs_nanoseconds(min_nsec_timespec) - duration_cast<fs_nanoseconds>(fs_seconds(1)));
+  }
+  // Static assert that these values properly round trip.
+  static_assert(fs_seconds(min_seconds) + get_min_nsecs() == FileTimeT::duration::min(), "value doesn't roundtrip");
+
+  static constexpr bool check_range() {
+    // This kinda sucks, but it's what happens when we don't have __int128_t.
+    if (sizeof(TimeT) == sizeof(rep)) {
+      typedef duration<long long, ratio<3600 * 24 * 365> > Years;
+      return duration_cast<Years>(fs_seconds(max_seconds)) > Years(250) &&
+             duration_cast<Years>(fs_seconds(min_seconds)) < Years(-250);
+    }
+    return max_seconds >= numeric_limits<TimeT>::max() && min_seconds <= numeric_limits<TimeT>::min();
+  }
+#if _LIBCPP_STD_VER >= 14
+  static_assert(check_range(), "the representable range is unacceptable small");
+#endif
+};
+
+template <class FileTimeT, class TimeT>
+struct time_util_base<FileTimeT, TimeT, true> {
+  using rep             = typename FileTimeT::rep;
+  using fs_duration     = typename FileTimeT::duration;
+  using fs_seconds      = duration<rep>;
+  using fs_nanoseconds  = duration<rep, nano>;
+  using fs_microseconds = duration<rep, micro>;
+
+  static const rep max_seconds;
+  static const rep max_nsec;
+  static const rep min_seconds;
+  static const rep min_nsec_timespec;
+};
+
+template <class FileTimeT, class TimeT>
+const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::max_seconds =
+    duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
+
+template <class FileTimeT, class TimeT>
+const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::max_nsec =
+    duration_cast<fs_nanoseconds>(FileTimeT::duration::max() - fs_seconds(max_seconds)).count();
+
+template <class FileTimeT, class TimeT>
+const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::min_seconds =
+    duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
+
+template <class FileTimeT, class TimeT>
+const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::min_nsec_timespec =
+    duration_cast<fs_nanoseconds>((FileTimeT::duration::min() - fs_seconds(min_seconds)) + fs_seconds(1)).count();
+
+template <class FileTimeT, class TimeT, class TimeSpecT>
+struct time_util : time_util_base<FileTimeT, TimeT> {
+  using Base = time_util_base<FileTimeT, TimeT>;
+  using Base::max_nsec;
+  using Base::max_seconds;
+  using Base::min_nsec_timespec;
+  using Base::min_seconds;
+
+  using typename Base::fs_duration;
+  using typename Base::fs_microseconds;
+  using typename Base::fs_nanoseconds;
+  using typename Base::fs_seconds;
+
+public:
+  template <class CType, class ChronoType>
+  static constexpr bool checked_set(CType* out, ChronoType time) {
+    using Lim = numeric_limits<CType>;
+    if (time > Lim::max() || time < Lim::min())
+      return false;
+    *out = static_cast<CType>(time);
+    return true;
+  }
+
+  static constexpr bool is_representable(TimeSpecT tm) {
+    if (tm.tv_sec >= 0) {
+      return tm.tv_sec < max_seconds || (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
+    } else if (tm.tv_sec == (min_seconds - 1)) {
+      return tm.tv_nsec >= min_nsec_timespec;
+    } else {
+      return tm.tv_sec >= min_seconds;
+    }
+  }
+
+  static constexpr bool is_representable(FileTimeT tm) {
+    auto secs  = duration_cast<fs_seconds>(tm.time_since_epoch());
+    auto nsecs = duration_cast<fs_nanoseconds>(tm.time_since_epoch() - secs);
+    if (nsecs.count() < 0) {
+      secs  = secs + fs_seconds(1);
+      nsecs = nsecs + fs_seconds(1);
+    }
+    using TLim = numeric_limits<TimeT>;
+    if (secs.count() >= 0)
+      return secs.count() <= TLim::max();
+    return secs.count() >= TLim::min();
+  }
+
+  static constexpr FileTimeT convert_from_timespec(TimeSpecT tm) {
+    if (tm.tv_sec >= 0 || tm.tv_nsec == 0) {
+      return FileTimeT(fs_seconds(tm.tv_sec) + duration_cast<fs_duration>(fs_nanoseconds(tm.tv_nsec)));
+    } else { // tm.tv_sec < 0
+      auto adj_subsec = duration_cast<fs_duration>(fs_seconds(1) - fs_nanoseconds(tm.tv_nsec));
+      auto Dur        = fs_seconds(tm.tv_sec + 1) - adj_subsec;
+      return FileTimeT(Dur);
+    }
+  }
+
+  template <class SubSecT>
+  static constexpr bool set_times_checked(TimeT* sec_out, SubSecT* subsec_out, FileTimeT tp) {
+    auto dur        = tp.time_since_epoch();
+    auto sec_dur    = duration_cast<fs_seconds>(dur);
+    auto subsec_dur = duration_cast<fs_nanoseconds>(dur - sec_dur);
+    // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
+    if (subsec_dur.count() < 0) {
+      if (sec_dur.count() > min_seconds) {
+        sec_dur    = sec_dur - fs_seconds(1);
+        subsec_dur = subsec_dur + fs_seconds(1);
+      } else {
+        subsec_dur = fs_nanoseconds::zero();
+      }
+    }
+    return checked_set(sec_out, sec_dur.count()) && checked_set(subsec_out, subsec_dur.count());
+  }
+  static constexpr bool convert_to_timespec(TimeSpecT& dest, FileTimeT tp) {
+    if (!is_representable(tp))
+      return false;
+    return set_times_checked(&dest.tv_sec, &dest.tv_nsec, tp);
+  }
+};
+
+#if defined(_LIBCPP_WIN32API)
+using fs_time = time_util<file_time_type, int64_t, TimeSpec>;
+#else
+using fs_time = time_util<file_time_type, time_t, TimeSpec>;
+#endif
+
+#if defined(__APPLE__)
+inline TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; }
+inline TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; }
+#elif defined(__MVS__)
+inline TimeSpec extract_mtime(StatT const& st) {
+  TimeSpec TS = {st.st_mtime, 0};
+  return TS;
+}
+inline TimeSpec extract_atime(StatT const& st) {
+  TimeSpec TS = {st.st_atime, 0};
+  return TS;
+}
+#elif defined(_AIX)
+inline TimeSpec extract_mtime(StatT const& st) {
+  TimeSpec TS = {st.st_mtime, st.st_mtime_n};
+  return TS;
+}
+inline TimeSpec extract_atime(StatT const& st) {
+  TimeSpec TS = {st.st_atime, st.st_atime_n};
+  return TS;
+}
+#else
+inline TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; }
+inline TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
+#endif
+
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM
+
+#  if !defined(_LIBCPP_WIN32API)
+inline bool posix_utimes(const path& p, std::array<TimeSpec, 2> const& TS, error_code& ec) {
+  TimeVal ConvertedTS[2] = {make_timeval(TS[0]), make_timeval(TS[1])};
+  if (::utimes(p.c_str(), ConvertedTS) == -1) {
+    ec = capture_errno();
+    return true;
+  }
+  return false;
+}
+
+#    if defined(_LIBCPP_USE_UTIMENSAT)
+inline bool posix_utimensat(const path& p, std::array<TimeSpec, 2> const& TS, error_code& ec) {
+  if (::utimensat(AT_FDCWD, p.c_str(), TS.data(), 0) == -1) {
+    ec = capture_errno();
+    return true;
+  }
+  return false;
+}
+#    endif
+
+inline bool set_file_times(const path& p, std::array<TimeSpec, 2> const& TS, error_code& ec) {
+#    if !defined(_LIBCPP_USE_UTIMENSAT)
+  return posix_utimes(p, TS, ec);
+#    else
+  return posix_utimensat(p, TS, ec);
+#    endif
+}
+
+#  endif // !_LIBCPP_WIN32API
+
+inline file_time_type __extract_last_write_time(const path& p, const StatT& st, error_code* ec) {
+  using detail::fs_time;
+  ErrorHandler<file_time_type> err("last_write_time", ec, &p);
+
+  auto ts = detail::extract_mtime(st);
+  if (!fs_time::is_representable(ts))
+    return err.report(errc::value_too_large);
+
+  return fs_time::convert_from_timespec(ts);
+}
+
+#endif // !_LIBCPP_HAS_NO_FILESYSTEM
+
+} // end namespace detail
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM
+
+#endif // FILESYSTEM_TIME_UTILS_H
diff --git a/third_party/libcxx/fstream b/third_party/libcxx/fstream
index 1aa541415..ab5ebf8e2 100644
--- a/third_party/libcxx/fstream
+++ b/third_party/libcxx/fstream
@@ -73,18 +73,20 @@ public:
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
+    using native_handle_type = typename basic_filebuf<charT, traits>::native_handle_type; // Since C++26
 
     basic_ifstream();
     explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in);
     explicit basic_ifstream(const string& s, ios_base::openmode mode = ios_base::in);
-    explicit basic_ifstream(const filesystem::path& p,
-                            ios_base::openmode mode = ios_base::in); // C++17
+    template<class T>
+    explicit basic_ifstream(const T& s, ios_base::openmode mode = ios_base::in); // Since C++17
     basic_ifstream(basic_ifstream&& rhs);
 
     basic_ifstream& operator=(basic_ifstream&& rhs);
     void swap(basic_ifstream& rhs);
 
     basic_filebuf<char_type, traits_type>* rdbuf() const;
+    native_handle_type native_handle() const noexcept; // Since C++26
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::in);
     void open(const string& s, ios_base::openmode mode = ios_base::in);
@@ -110,18 +112,21 @@ public:
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
+    using native_handle_type = typename basic_filebuf<charT, traits>::native_handle_type; // Since C++26
 
     basic_ofstream();
     explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out);
     explicit basic_ofstream(const string& s, ios_base::openmode mode = ios_base::out);
-    explicit basic_ofstream(const filesystem::path& p,
-                            ios_base::openmode mode = ios_base::out); // C++17
+    template<class T>
+    explicit basic_ofstream(const T& s, ios_base::openmode mode = ios_base::out); // Since C++17
     basic_ofstream(basic_ofstream&& rhs);
 
     basic_ofstream& operator=(basic_ofstream&& rhs);
     void swap(basic_ofstream& rhs);
 
     basic_filebuf<char_type, traits_type>* rdbuf() const;
+    native_handle_type native_handle() const noexcept; // Since C++26
+
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::out);
     void open(const string& s, ios_base::openmode mode = ios_base::out);
@@ -148,18 +153,20 @@ public:
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
+    using native_handle_type = typename basic_filebuf<charT, traits>::native_handle_type; // Since C++26
 
     basic_fstream();
     explicit basic_fstream(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out);
     explicit basic_fstream(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out);
-    explicit basic_fstream(const filesystem::path& p,
-                           ios_base::openmode mode = ios_base::in|ios_base::out); C++17
+    template<class T>
+    explicit basic_fstream(const T& s, ios_base::openmode mode = ios_base::in | ios_base::out); // Since C++17
     basic_fstream(basic_fstream&& rhs);
 
     basic_fstream& operator=(basic_fstream&& rhs);
     void swap(basic_fstream& rhs);
 
     basic_filebuf<char_type, traits_type>* rdbuf() const;
+    native_handle_type native_handle() const noexcept; // Since C++26
     bool is_open() const;
     void open(const char* s, ios_base::openmode mode = ios_base::in|ios_base::out);
     void open(const string& s, ios_base::openmode mode = ios_base::in|ios_base::out);
@@ -180,24 +187,22 @@ typedef basic_fstream<wchar_t> wfstream;
 */
 
 #include <__algorithm/max.h>
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__availability>
+#include <__assert>
 #include <__config>
 #include <__fwd/fstream.h>
 #include <__locale>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_same.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <cstdio>
+#include <filesystem>
 #include <istream>
 #include <ostream>
 #include <typeinfo>
 #include <version>
 
-#if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-#   include <filesystem>
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
@@ -209,68 +214,87 @@ _LIBCPP_PUSH_MACROS
 #  define _LIBCPP_HAS_NO_OFF_T_FUNCTIONS
 #endif
 
-#if !defined(_LIBCPP_HAS_NO_FSTREAM)
+#if !defined(_LIBCPP_HAS_NO_FILESYSTEM)
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#  if _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_WIN32API)
+_LIBCPP_EXPORTED_FROM_ABI void* __filebuf_windows_native_handle(FILE* __file) noexcept;
+#  endif
+
 template <class _CharT, class _Traits>
-class _LIBCPP_TEMPLATE_VIS basic_filebuf
-    : public basic_streambuf<_CharT, _Traits>
-{
+class _LIBCPP_TEMPLATE_VIS basic_filebuf : public basic_streambuf<_CharT, _Traits> {
 public:
-    typedef _CharT                           char_type;
-    typedef _Traits                          traits_type;
-    typedef typename traits_type::int_type   int_type;
-    typedef typename traits_type::pos_type   pos_type;
-    typedef typename traits_type::off_type   off_type;
-    typedef typename traits_type::state_type state_type;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+  typedef typename traits_type::state_type state_type;
+#  if _LIBCPP_STD_VER >= 26
+#    if defined(_LIBCPP_WIN32API)
+  using native_handle_type = void*; // HANDLE
+#    elif __has_include(<unistd.h>)
+  using native_handle_type = int; // POSIX file descriptor
+#    else
+#      error "Provide a native file handle!"
+#    endif
+#  endif
 
-    // 27.9.1.2 Constructors/destructor:
-    basic_filebuf();
-    basic_filebuf(basic_filebuf&& __rhs);
-    ~basic_filebuf() override;
+  // 27.9.1.2 Constructors/destructor:
+  basic_filebuf();
+  basic_filebuf(basic_filebuf&& __rhs);
+  ~basic_filebuf() override;
 
-    // 27.9.1.3 Assign/swap:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_filebuf& operator=(basic_filebuf&& __rhs);
-    void swap(basic_filebuf& __rhs);
+  // 27.9.1.3 Assign/swap:
+  _LIBCPP_HIDE_FROM_ABI basic_filebuf& operator=(basic_filebuf&& __rhs);
+  void swap(basic_filebuf& __rhs);
 
-    // 27.9.1.4 Members:
-    _LIBCPP_INLINE_VISIBILITY
-    bool is_open() const;
-    basic_filebuf* open(const char* __s, ios_base::openmode __mode);
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-    basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode);
-#endif
-    _LIBCPP_INLINE_VISIBILITY
-    basic_filebuf* open(const string& __s, ios_base::openmode __mode);
+  // 27.9.1.4 Members:
+  _LIBCPP_HIDE_FROM_ABI bool is_open() const;
+  basic_filebuf* open(const char* __s, ios_base::openmode __mode);
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+  basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode);
+#  endif
+  _LIBCPP_HIDE_FROM_ABI basic_filebuf* open(const string& __s, ios_base::openmode __mode);
 
-#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
-    basic_filebuf* open(const _VSTD_FS::path& __p, ios_base::openmode __mode) {
-      return open(__p.c_str(), __mode);
-    }
-#endif
-    _LIBCPP_INLINE_VISIBILITY
-    basic_filebuf* __open(int __fd, ios_base::openmode __mode);
-    basic_filebuf* close();
+#  if _LIBCPP_STD_VER >= 17
+  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI basic_filebuf*
+  open(const filesystem::path& __p, ios_base::openmode __mode) {
+    return open(__p.c_str(), __mode);
+  }
+#  endif
+  _LIBCPP_HIDE_FROM_ABI basic_filebuf* __open(int __fd, ios_base::openmode __mode);
+  basic_filebuf* close();
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept {
+    _LIBCPP_ASSERT_UNCATEGORIZED(this->is_open(), "File must be opened");
+#    if defined(_LIBCPP_WIN32API)
+    return std::__filebuf_windows_native_handle(__file_);
+#    elif __has_include(<unistd.h>)
+    return fileno(__file_);
+#    else
+#      error "Provide a way to determine the file native handle!"
+#    endif
+  }
+#  endif //  _LIBCPP_STD_VER >= 26
 
-    _LIBCPP_INLINE_VISIBILITY
-    inline static const char*
-    __make_mdstring(ios_base::openmode __mode) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI inline static const char* __make_mdstring(ios_base::openmode __mode) _NOEXCEPT;
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+  _LIBCPP_HIDE_FROM_ABI inline static const wchar_t* __make_mdwstring(ios_base::openmode __mode) _NOEXCEPT;
+#  endif
 
-  protected:
-    // 27.9.1.5 Overridden virtual functions:
-    int_type underflow() override;
-    int_type pbackfail(int_type __c = traits_type::eof()) override;
-    int_type overflow (int_type __c = traits_type::eof()) override;
-    basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n) override;
-    pos_type seekoff(off_type __off, ios_base::seekdir __way,
-                     ios_base::openmode __wch = ios_base::in | ios_base::out) override;
-    pos_type seekpos(pos_type __sp,
-                     ios_base::openmode __wch = ios_base::in | ios_base::out) override;
-    int sync() override;
-    void imbue(const locale& __loc) override;
+protected:
+  // 27.9.1.5 Overridden virtual functions:
+  int_type underflow() override;
+  int_type pbackfail(int_type __c = traits_type::eof()) override;
+  int_type overflow(int_type __c = traits_type::eof()) override;
+  basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n) override;
+  pos_type
+  seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __wch = ios_base::in | ios_base::out) override;
+  pos_type seekpos(pos_type __sp, ios_base::openmode __wch = ios_base::in | ios_base::out) override;
+  int sync() override;
+  void imbue(const locale& __loc) override;
 
 private:
   char* __extbuf_;
@@ -285,6 +309,43 @@ private:
   state_type __st_;
   state_type __st_last_;
   ios_base::openmode __om_;
+  // There have been no file operations yet, which allows setting unbuffered
+  // I/O mode.
+  static const ios_base::openmode __no_io_operations = ios_base::trunc;
+  // Unbuffered I/O mode has been requested.
+  static const ios_base::openmode __use_unbuffered_io = ios_base::ate;
+  // Used to track the currently used mode and track whether the output should
+  // be unbuffered.
+  // [filebuf.virtuals]/12
+  //   If setbuf(0, 0) is called on a stream before any I/O has occurred on
+  //   that stream, the stream becomes unbuffered. Otherwise the results are
+  //   implementation-defined.
+  // This allows calling setbuf(0, 0)
+  // - before opening a file,
+  // - after opening a file, before
+  //   - a read
+  //   - a write
+  //   - a seek.
+  // Note that opening a file with ios_base::ate does a seek operation.
+  // Normally underflow, overflow, and sync change this flag to ios_base::in,
+  // ios_base_out, or 0.
+  //
+  // The ios_base::trunc and ios_base::ate flags are not used in __cm_. They
+  // are used to track the state of the unbuffered request. For readability
+  // they have the aliases __no_io_operations and __use_unbuffered_io
+  // respectively.
+  //
+  // The __no_io_operations and __use_unbuffered_io flags are used in the
+  // following way:
+  // - __no_io_operations is set upon construction to indicate the unbuffered
+  //   state can be set.
+  // - When requesting unbuffered output:
+  //   - If the file is open it sets the mode.
+  //   - Else places a request by adding the __use_unbuffered_io flag.
+  // - When a file is opened it checks whether both __no_io_operations and
+  //   __use_unbuffered_io are set. If so switches to unbuffered mode.
+  // - All file I/O operations change the mode effectively clearing the
+  //   __no_io_operations and __use_unbuffered_io flags.
   ios_base::openmode __cm_;
   bool __owns_eb_;
   bool __owns_ib_;
@@ -292,6 +353,48 @@ private:
 
   bool __read_mode();
   void __write_mode();
+
+  _LIBCPP_EXPORTED_FROM_ABI friend FILE* __get_ostream_file(ostream&);
+
+  // There are multiple (__)open function, they use different C-API open
+  // function. After that call these functions behave the same. This function
+  // does that part and determines the final return value.
+  _LIBCPP_HIDE_FROM_ABI basic_filebuf* __do_open(FILE* __file, ios_base::openmode __mode) {
+    __file_ = __file;
+    if (!__file_)
+      return nullptr;
+
+    __om_ = __mode;
+    if (__cm_ == (__no_io_operations | __use_unbuffered_io)) {
+      std::setbuf(__file_, nullptr);
+      __cm_ = 0;
+    }
+
+    if (__mode & ios_base::ate) {
+      __cm_ = 0;
+      if (fseek(__file_, 0, SEEK_END)) {
+        fclose(__file_);
+        __file_ = nullptr;
+        return nullptr;
+      }
+    }
+
+    return this;
+  }
+
+  // If the file is already open, switch to unbuffered mode. Otherwise, record
+  // the request to use unbuffered mode so that we use that mode when we
+  // eventually open the file.
+  _LIBCPP_HIDE_FROM_ABI void __request_unbuffered_mode(char_type* __s, streamsize __n) {
+    if (__cm_ == __no_io_operations && __s == nullptr && __n == 0) {
+      if (__file_) {
+        std::setbuf(__file_, nullptr);
+        __cm_ = 0;
+      } else {
+        __cm_ = __no_io_operations | __use_unbuffered_io;
+      }
+    }
+  }
 };
 
 template <class _CharT, class _Traits>
@@ -307,223 +410,176 @@ basic_filebuf<_CharT, _Traits>::basic_filebuf()
       __st_(),
       __st_last_(),
       __om_(0),
-      __cm_(0),
+      __cm_(__no_io_operations),
       __owns_eb_(false),
       __owns_ib_(false),
-      __always_noconv_(false)
-{
-    if (std::has_facet<codecvt<char_type, char, state_type> >(this->getloc()))
-    {
-        __cv_ = &std::use_facet<codecvt<char_type, char, state_type> >(this->getloc());
-        __always_noconv_ = __cv_->always_noconv();
-    }
-    setbuf(nullptr, 4096);
+      __always_noconv_(false) {
+  if (std::has_facet<codecvt<char_type, char, state_type> >(this->getloc())) {
+    __cv_            = &std::use_facet<codecvt<char_type, char, state_type> >(this->getloc());
+    __always_noconv_ = __cv_->always_noconv();
+  }
+  setbuf(nullptr, 4096);
 }
 
 template <class _CharT, class _Traits>
-basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs)
-    : basic_streambuf<_CharT, _Traits>(__rhs)
-{
-    if (__rhs.__extbuf_ == __rhs.__extbuf_min_)
-    {
-        __extbuf_ = __extbuf_min_;
-        __extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_);
-        __extbufend_ = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_);
-    }
+basic_filebuf<_CharT, _Traits>::basic_filebuf(basic_filebuf&& __rhs) : basic_streambuf<_CharT, _Traits>(__rhs) {
+  if (__rhs.__extbuf_ == __rhs.__extbuf_min_) {
+    __extbuf_     = __extbuf_min_;
+    __extbufnext_ = __extbuf_ + (__rhs.__extbufnext_ - __rhs.__extbuf_);
+    __extbufend_  = __extbuf_ + (__rhs.__extbufend_ - __rhs.__extbuf_);
+  } else {
+    __extbuf_     = __rhs.__extbuf_;
+    __extbufnext_ = __rhs.__extbufnext_;
+    __extbufend_  = __rhs.__extbufend_;
+  }
+  __ebs_           = __rhs.__ebs_;
+  __intbuf_        = __rhs.__intbuf_;
+  __ibs_           = __rhs.__ibs_;
+  __file_          = __rhs.__file_;
+  __cv_            = __rhs.__cv_;
+  __st_            = __rhs.__st_;
+  __st_last_       = __rhs.__st_last_;
+  __om_            = __rhs.__om_;
+  __cm_            = __rhs.__cm_;
+  __owns_eb_       = __rhs.__owns_eb_;
+  __owns_ib_       = __rhs.__owns_ib_;
+  __always_noconv_ = __rhs.__always_noconv_;
+  if (__rhs.pbase()) {
+    if (__rhs.pbase() == __rhs.__intbuf_)
+      this->setp(__intbuf_, __intbuf_ + (__rhs.epptr() - __rhs.pbase()));
     else
-    {
-        __extbuf_ = __rhs.__extbuf_;
-        __extbufnext_ = __rhs.__extbufnext_;
-        __extbufend_ = __rhs.__extbufend_;
-    }
-    __ebs_ = __rhs.__ebs_;
-    __intbuf_ = __rhs.__intbuf_;
-    __ibs_ = __rhs.__ibs_;
-    __file_ = __rhs.__file_;
-    __cv_ = __rhs.__cv_;
-    __st_ = __rhs.__st_;
-    __st_last_ = __rhs.__st_last_;
-    __om_ = __rhs.__om_;
-    __cm_ = __rhs.__cm_;
-    __owns_eb_ = __rhs.__owns_eb_;
-    __owns_ib_ = __rhs.__owns_ib_;
-    __always_noconv_ = __rhs.__always_noconv_;
-    if (__rhs.pbase())
-    {
-        if (__rhs.pbase() == __rhs.__intbuf_)
-            this->setp(__intbuf_, __intbuf_ + (__rhs. epptr() - __rhs.pbase()));
-        else
-            this->setp((char_type*)__extbuf_,
-                       (char_type*)__extbuf_ + (__rhs. epptr() - __rhs.pbase()));
-        this->__pbump(__rhs. pptr() - __rhs.pbase());
-    }
-    else if (__rhs.eback())
-    {
-        if (__rhs.eback() == __rhs.__intbuf_)
-            this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()),
-                                  __intbuf_ + (__rhs.egptr() - __rhs.eback()));
-        else
-            this->setg((char_type*)__extbuf_,
-                       (char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()),
-                       (char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback()));
-    }
-    __rhs.__extbuf_ = nullptr;
-    __rhs.__extbufnext_ = nullptr;
-    __rhs.__extbufend_ = nullptr;
-    __rhs.__ebs_ = 0;
-    __rhs.__intbuf_ = 0;
-    __rhs.__ibs_ = 0;
-    __rhs.__file_ = nullptr;
-    __rhs.__st_ = state_type();
-    __rhs.__st_last_ = state_type();
-    __rhs.__om_ = 0;
-    __rhs.__cm_ = 0;
-    __rhs.__owns_eb_ = false;
-    __rhs.__owns_ib_ = false;
-    __rhs.setg(0, 0, 0);
-    __rhs.setp(0, 0);
+      this->setp((char_type*)__extbuf_, (char_type*)__extbuf_ + (__rhs.epptr() - __rhs.pbase()));
+    this->__pbump(__rhs.pptr() - __rhs.pbase());
+  } else if (__rhs.eback()) {
+    if (__rhs.eback() == __rhs.__intbuf_)
+      this->setg(__intbuf_, __intbuf_ + (__rhs.gptr() - __rhs.eback()), __intbuf_ + (__rhs.egptr() - __rhs.eback()));
+    else
+      this->setg((char_type*)__extbuf_,
+                 (char_type*)__extbuf_ + (__rhs.gptr() - __rhs.eback()),
+                 (char_type*)__extbuf_ + (__rhs.egptr() - __rhs.eback()));
+  }
+  __rhs.__extbuf_     = nullptr;
+  __rhs.__extbufnext_ = nullptr;
+  __rhs.__extbufend_  = nullptr;
+  __rhs.__ebs_        = 0;
+  __rhs.__intbuf_     = 0;
+  __rhs.__ibs_        = 0;
+  __rhs.__file_       = nullptr;
+  __rhs.__st_         = state_type();
+  __rhs.__st_last_    = state_type();
+  __rhs.__om_         = 0;
+  __rhs.__cm_         = 0;
+  __rhs.__owns_eb_    = false;
+  __rhs.__owns_ib_    = false;
+  __rhs.setg(0, 0, 0);
+  __rhs.setp(0, 0);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_filebuf<_CharT, _Traits>&
-basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs)
-{
+inline basic_filebuf<_CharT, _Traits>& basic_filebuf<_CharT, _Traits>::operator=(basic_filebuf&& __rhs) {
+  close();
+  swap(__rhs);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_filebuf<_CharT, _Traits>::~basic_filebuf() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
     close();
-    swap(__rhs);
-    return *this;
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+  }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  if (__owns_eb_)
+    delete[] __extbuf_;
+  if (__owns_ib_)
+    delete[] __intbuf_;
 }
 
 template <class _CharT, class _Traits>
-basic_filebuf<_CharT, _Traits>::~basic_filebuf()
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        close();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+void basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs) {
+  basic_streambuf<char_type, traits_type>::swap(__rhs);
+  if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) {
+    // Neither *this nor __rhs uses the small buffer, so we can simply swap the pointers.
+    std::swap(__extbuf_, __rhs.__extbuf_);
+    std::swap(__extbufnext_, __rhs.__extbufnext_);
+    std::swap(__extbufend_, __rhs.__extbufend_);
+  } else {
+    ptrdiff_t __ln = __extbufnext_ ? __extbufnext_ - __extbuf_ : 0;
+    ptrdiff_t __le = __extbufend_ ? __extbufend_ - __extbuf_ : 0;
+    ptrdiff_t __rn = __rhs.__extbufnext_ ? __rhs.__extbufnext_ - __rhs.__extbuf_ : 0;
+    ptrdiff_t __re = __rhs.__extbufend_ ? __rhs.__extbufend_ - __rhs.__extbuf_ : 0;
+    if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_) {
+      // *this uses the small buffer, but __rhs doesn't.
+      __extbuf_       = __rhs.__extbuf_;
+      __rhs.__extbuf_ = __rhs.__extbuf_min_;
+      std::memmove(__rhs.__extbuf_min_, __extbuf_min_, sizeof(__extbuf_min_));
+    } else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_) {
+      // *this doesn't use the small buffer, but __rhs does.
+      __rhs.__extbuf_ = __extbuf_;
+      __extbuf_       = __extbuf_min_;
+      std::memmove(__extbuf_min_, __rhs.__extbuf_min_, sizeof(__extbuf_min_));
+    } else {
+      // Both *this and __rhs use the small buffer.
+      char __tmp[sizeof(__extbuf_min_)];
+      std::memmove(__tmp, __extbuf_min_, sizeof(__extbuf_min_));
+      std::memmove(__extbuf_min_, __rhs.__extbuf_min_, sizeof(__extbuf_min_));
+      std::memmove(__rhs.__extbuf_min_, __tmp, sizeof(__extbuf_min_));
     }
-    catch (...)
-    {
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    if (__owns_eb_)
-        delete [] __extbuf_;
-    if (__owns_ib_)
-        delete [] __intbuf_;
+    __extbufnext_       = __extbuf_ + __rn;
+    __extbufend_        = __extbuf_ + __re;
+    __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln;
+    __rhs.__extbufend_  = __rhs.__extbuf_ + __le;
+  }
+  std::swap(__ebs_, __rhs.__ebs_);
+  std::swap(__intbuf_, __rhs.__intbuf_);
+  std::swap(__ibs_, __rhs.__ibs_);
+  std::swap(__file_, __rhs.__file_);
+  std::swap(__cv_, __rhs.__cv_);
+  std::swap(__st_, __rhs.__st_);
+  std::swap(__st_last_, __rhs.__st_last_);
+  std::swap(__om_, __rhs.__om_);
+  std::swap(__cm_, __rhs.__cm_);
+  std::swap(__owns_eb_, __rhs.__owns_eb_);
+  std::swap(__owns_ib_, __rhs.__owns_ib_);
+  std::swap(__always_noconv_, __rhs.__always_noconv_);
+  if (this->eback() == (char_type*)__rhs.__extbuf_min_) {
+    ptrdiff_t __n = this->gptr() - this->eback();
+    ptrdiff_t __e = this->egptr() - this->eback();
+    this->setg((char_type*)__extbuf_min_, (char_type*)__extbuf_min_ + __n, (char_type*)__extbuf_min_ + __e);
+  } else if (this->pbase() == (char_type*)__rhs.__extbuf_min_) {
+    ptrdiff_t __n = this->pptr() - this->pbase();
+    ptrdiff_t __e = this->epptr() - this->pbase();
+    this->setp((char_type*)__extbuf_min_, (char_type*)__extbuf_min_ + __e);
+    this->__pbump(__n);
+  }
+  if (__rhs.eback() == (char_type*)__extbuf_min_) {
+    ptrdiff_t __n = __rhs.gptr() - __rhs.eback();
+    ptrdiff_t __e = __rhs.egptr() - __rhs.eback();
+    __rhs.setg(
+        (char_type*)__rhs.__extbuf_min_, (char_type*)__rhs.__extbuf_min_ + __n, (char_type*)__rhs.__extbuf_min_ + __e);
+  } else if (__rhs.pbase() == (char_type*)__extbuf_min_) {
+    ptrdiff_t __n = __rhs.pptr() - __rhs.pbase();
+    ptrdiff_t __e = __rhs.epptr() - __rhs.pbase();
+    __rhs.setp((char_type*)__rhs.__extbuf_min_, (char_type*)__rhs.__extbuf_min_ + __e);
+    __rhs.__pbump(__n);
+  }
 }
 
 template <class _CharT, class _Traits>
-void
-basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
-{
-    basic_streambuf<char_type, traits_type>::swap(__rhs);
-    if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_)
-    {
-        // Neither *this nor __rhs uses the small buffer, so we can simply swap the pointers.
-        std::swap(__extbuf_, __rhs.__extbuf_);
-        std::swap(__extbufnext_, __rhs.__extbufnext_);
-        std::swap(__extbufend_, __rhs.__extbufend_);
-    }
-    else
-    {
-        ptrdiff_t __ln = __extbufnext_       ? __extbufnext_ - __extbuf_             : 0;
-        ptrdiff_t __le = __extbufend_        ? __extbufend_ - __extbuf_              : 0;
-        ptrdiff_t __rn = __rhs.__extbufnext_ ? __rhs.__extbufnext_ - __rhs.__extbuf_ : 0;
-        ptrdiff_t __re = __rhs.__extbufend_  ? __rhs.__extbufend_ - __rhs.__extbuf_  : 0;
-        if (__extbuf_ == __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_)
-        {
-            // *this uses the small buffer, but __rhs doesn't.
-            __extbuf_ = __rhs.__extbuf_;
-            __rhs.__extbuf_ = __rhs.__extbuf_min_;
-            std::memmove(__rhs.__extbuf_min_, __extbuf_min_, sizeof(__extbuf_min_));
-        }
-        else if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ == __rhs.__extbuf_min_)
-        {
-            // *this doesn't use the small buffer, but __rhs does.
-            __rhs.__extbuf_ = __extbuf_;
-            __extbuf_ = __extbuf_min_;
-            std::memmove(__extbuf_min_, __rhs.__extbuf_min_, sizeof(__extbuf_min_));
-        }
-        else
-        {
-            // Both *this and __rhs use the small buffer.
-            char __tmp[sizeof(__extbuf_min_)];
-            std::memmove(__tmp, __extbuf_min_, sizeof(__extbuf_min_));
-            std::memmove(__extbuf_min_, __rhs.__extbuf_min_, sizeof(__extbuf_min_));
-            std::memmove(__rhs.__extbuf_min_, __tmp, sizeof(__extbuf_min_));
-        }
-        __extbufnext_ = __extbuf_ + __rn;
-        __extbufend_ = __extbuf_ + __re;
-        __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln;
-        __rhs.__extbufend_ = __rhs.__extbuf_ + __le;
-    }
-    _VSTD::swap(__ebs_, __rhs.__ebs_);
-    _VSTD::swap(__intbuf_, __rhs.__intbuf_);
-    _VSTD::swap(__ibs_, __rhs.__ibs_);
-    _VSTD::swap(__file_, __rhs.__file_);
-    _VSTD::swap(__cv_, __rhs.__cv_);
-    _VSTD::swap(__st_, __rhs.__st_);
-    _VSTD::swap(__st_last_, __rhs.__st_last_);
-    _VSTD::swap(__om_, __rhs.__om_);
-    _VSTD::swap(__cm_, __rhs.__cm_);
-    _VSTD::swap(__owns_eb_, __rhs.__owns_eb_);
-    _VSTD::swap(__owns_ib_, __rhs.__owns_ib_);
-    _VSTD::swap(__always_noconv_, __rhs.__always_noconv_);
-    if (this->eback() == (char_type*)__rhs.__extbuf_min_)
-    {
-        ptrdiff_t __n = this->gptr() - this->eback();
-        ptrdiff_t __e = this->egptr() - this->eback();
-        this->setg((char_type*)__extbuf_min_,
-                   (char_type*)__extbuf_min_ + __n,
-                   (char_type*)__extbuf_min_ + __e);
-    }
-    else if (this->pbase() == (char_type*)__rhs.__extbuf_min_)
-    {
-        ptrdiff_t __n = this->pptr() - this->pbase();
-        ptrdiff_t __e = this->epptr() - this->pbase();
-        this->setp((char_type*)__extbuf_min_,
-                   (char_type*)__extbuf_min_ + __e);
-        this->__pbump(__n);
-    }
-    if (__rhs.eback() == (char_type*)__extbuf_min_)
-    {
-        ptrdiff_t __n = __rhs.gptr() - __rhs.eback();
-        ptrdiff_t __e = __rhs.egptr() - __rhs.eback();
-        __rhs.setg((char_type*)__rhs.__extbuf_min_,
-                   (char_type*)__rhs.__extbuf_min_ + __n,
-                   (char_type*)__rhs.__extbuf_min_ + __e);
-    }
-    else if (__rhs.pbase() == (char_type*)__extbuf_min_)
-    {
-        ptrdiff_t __n = __rhs.pptr() - __rhs.pbase();
-        ptrdiff_t __e = __rhs.epptr() - __rhs.pbase();
-        __rhs.setp((char_type*)__rhs.__extbuf_min_,
-                   (char_type*)__rhs.__extbuf_min_ + __e);
-        __rhs.__pbump(__n);
-    }
+inline _LIBCPP_HIDE_FROM_ABI void swap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y) {
+  __x.swap(__y);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(basic_filebuf<_CharT, _Traits>& __x, basic_filebuf<_CharT, _Traits>& __y)
-{
-    __x.swap(__y);
+inline bool basic_filebuf<_CharT, _Traits>::is_open() const {
+  return __file_ != nullptr;
 }
 
 template <class _CharT, class _Traits>
-inline
-bool
-basic_filebuf<_CharT, _Traits>::is_open() const
-{
-    return __file_ != nullptr;
-}
-
-template <class _CharT, class _Traits>
-const char* basic_filebuf<_CharT, _Traits>::__make_mdstring(
-    ios_base::openmode __mode) _NOEXCEPT {
+const char* basic_filebuf<_CharT, _Traits>::__make_mdstring(ios_base::openmode __mode) _NOEXCEPT {
   switch (__mode & ~ios_base::ate) {
   case ios_base::out:
   case ios_base::out | ios_base::trunc:
@@ -555,781 +611,618 @@ const char* basic_filebuf<_CharT, _Traits>::__make_mdstring(
   case ios_base::in | ios_base::out | ios_base::app | ios_base::binary:
   case ios_base::in | ios_base::app | ios_base::binary:
     return "a+b" _LIBCPP_FOPEN_CLOEXEC_MODE;
+#  if _LIBCPP_STD_VER >= 23
+  case ios_base::out | ios_base::noreplace:
+  case ios_base::out | ios_base::trunc | ios_base::noreplace:
+    return "wx" _LIBCPP_FOPEN_CLOEXEC_MODE;
+  case ios_base::in | ios_base::out | ios_base::trunc | ios_base::noreplace:
+    return "w+x" _LIBCPP_FOPEN_CLOEXEC_MODE;
+  case ios_base::out | ios_base::binary | ios_base::noreplace:
+  case ios_base::out | ios_base::trunc | ios_base::binary | ios_base::noreplace:
+    return "wbx" _LIBCPP_FOPEN_CLOEXEC_MODE;
+  case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary | ios_base::noreplace:
+    return "w+bx" _LIBCPP_FOPEN_CLOEXEC_MODE;
+#  endif // _LIBCPP_STD_VER >= 23
   default:
     return nullptr;
   }
   __libcpp_unreachable();
 }
 
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
 template <class _CharT, class _Traits>
-basic_filebuf<_CharT, _Traits>*
-basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
-{
-    basic_filebuf<_CharT, _Traits>* __rt = nullptr;
-    if (__file_ == nullptr)
-    {
-      if (const char* __mdstr = __make_mdstring(__mode)) {
-        __rt = this;
-        __file_ = fopen(__s, __mdstr);
-        if (__file_) {
-          __om_ = __mode;
-          if (__mode & ios_base::ate) {
-            if (fseek(__file_, 0, SEEK_END)) {
-              fclose(__file_);
-              __file_ = nullptr;
-              __rt = nullptr;
-            }
-          }
-        } else
-          __rt = nullptr;
-      }
-    }
-    return __rt;
+const wchar_t* basic_filebuf<_CharT, _Traits>::__make_mdwstring(ios_base::openmode __mode) _NOEXCEPT {
+  switch (__mode & ~ios_base::ate) {
+  case ios_base::out:
+  case ios_base::out | ios_base::trunc:
+    return L"w";
+  case ios_base::out | ios_base::app:
+  case ios_base::app:
+    return L"a";
+  case ios_base::in:
+    return L"r";
+  case ios_base::in | ios_base::out:
+    return L"r+";
+  case ios_base::in | ios_base::out | ios_base::trunc:
+    return L"w+";
+  case ios_base::in | ios_base::out | ios_base::app:
+  case ios_base::in | ios_base::app:
+    return L"a+";
+  case ios_base::out | ios_base::binary:
+  case ios_base::out | ios_base::trunc | ios_base::binary:
+    return L"wb";
+  case ios_base::out | ios_base::app | ios_base::binary:
+  case ios_base::app | ios_base::binary:
+    return L"ab";
+  case ios_base::in | ios_base::binary:
+    return L"rb";
+  case ios_base::in | ios_base::out | ios_base::binary:
+    return L"r+b";
+  case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
+    return L"w+b";
+  case ios_base::in | ios_base::out | ios_base::app | ios_base::binary:
+  case ios_base::in | ios_base::app | ios_base::binary:
+    return L"a+b";
+#    if _LIBCPP_STD_VER >= 23
+  case ios_base::out | ios_base::noreplace:
+  case ios_base::out | ios_base::trunc | ios_base::noreplace:
+    return L"wx";
+  case ios_base::in | ios_base::out | ios_base::trunc | ios_base::noreplace:
+    return L"w+x";
+  case ios_base::out | ios_base::binary | ios_base::noreplace:
+  case ios_base::out | ios_base::trunc | ios_base::binary | ios_base::noreplace:
+    return L"wbx";
+  case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary | ios_base::noreplace:
+    return L"w+bx";
+#    endif // _LIBCPP_STD_VER >= 23
+  default:
+    return nullptr;
+  }
+  __libcpp_unreachable();
+}
+#  endif
+
+template <class _CharT, class _Traits>
+basic_filebuf<_CharT, _Traits>* basic_filebuf<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) {
+  if (__file_)
+    return nullptr;
+  const char* __mdstr = __make_mdstring(__mode);
+  if (!__mdstr)
+    return nullptr;
+
+  return __do_open(fopen(__s, __mdstr), __mode);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_filebuf<_CharT, _Traits>*
-basic_filebuf<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) {
+inline basic_filebuf<_CharT, _Traits>* basic_filebuf<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) {
+  if (__file_)
+    return nullptr;
+  const char* __mdstr = __make_mdstring(__mode);
+  if (!__mdstr)
+    return nullptr;
+
+  return __do_open(fdopen(__fd, __mdstr), __mode);
+}
+
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+// This is basically the same as the char* overload except that it uses _wfopen
+// and long mode strings.
+template <class _CharT, class _Traits>
+basic_filebuf<_CharT, _Traits>* basic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) {
+  if (__file_)
+    return nullptr;
+  const wchar_t* __mdstr = __make_mdwstring(__mode);
+  if (!__mdstr)
+    return nullptr;
+
+  return __do_open(_wfopen(__s, __mdstr), __mode);
+}
+#  endif
+
+template <class _CharT, class _Traits>
+inline basic_filebuf<_CharT, _Traits>*
+basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) {
+  return open(__s.c_str(), __mode);
+}
+
+template <class _CharT, class _Traits>
+basic_filebuf<_CharT, _Traits>* basic_filebuf<_CharT, _Traits>::close() {
   basic_filebuf<_CharT, _Traits>* __rt = nullptr;
-  if (__file_ == nullptr) {
-    if (const char* __mdstr = __make_mdstring(__mode)) {
-      __rt = this;
-      __file_ = fdopen(__fd, __mdstr);
-      if (__file_) {
-        __om_ = __mode;
-        if (__mode & ios_base::ate) {
-          if (fseek(__file_, 0, SEEK_END)) {
-            fclose(__file_);
-            __file_ = nullptr;
-            __rt = nullptr;
-          }
-        }
-      } else
-        __rt = nullptr;
-    }
+  if (__file_) {
+    __rt = this;
+    unique_ptr<FILE, int (*)(FILE*)> __h(__file_, fclose);
+    if (sync())
+      __rt = nullptr;
+    if (fclose(__h.release()))
+      __rt = nullptr;
+    __file_ = nullptr;
+    setbuf(0, 0);
   }
   return __rt;
 }
 
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-// This is basically the same as the char* overload except that it uses _wfopen
-// and long mode strings.
 template <class _CharT, class _Traits>
-basic_filebuf<_CharT, _Traits>*
-basic_filebuf<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
-{
-    basic_filebuf<_CharT, _Traits>* __rt = nullptr;
-    if (__file_ == nullptr)
-    {
-        __rt = this;
-        const wchar_t* __mdstr;
-        switch (__mode & ~ios_base::ate)
-        {
-        case ios_base::out:
-        case ios_base::out | ios_base::trunc:
-            __mdstr = L"w";
-            break;
-        case ios_base::out | ios_base::app:
-        case ios_base::app:
-            __mdstr = L"a";
-            break;
-        case ios_base::in:
-            __mdstr = L"r";
-            break;
-        case ios_base::in | ios_base::out:
-            __mdstr = L"r+";
-            break;
-        case ios_base::in | ios_base::out | ios_base::trunc:
-            __mdstr = L"w+";
-            break;
-        case ios_base::in | ios_base::out | ios_base::app:
-        case ios_base::in | ios_base::app:
-            __mdstr = L"a+";
-            break;
-        case ios_base::out | ios_base::binary:
-        case ios_base::out | ios_base::trunc | ios_base::binary:
-            __mdstr = L"wb";
-            break;
-        case ios_base::out | ios_base::app | ios_base::binary:
-        case ios_base::app | ios_base::binary:
-            __mdstr = L"ab";
-            break;
-        case ios_base::in | ios_base::binary:
-            __mdstr = L"rb";
-            break;
-        case ios_base::in | ios_base::out | ios_base::binary:
-            __mdstr = L"r+b";
-            break;
-        case ios_base::in | ios_base::out | ios_base::trunc | ios_base::binary:
-            __mdstr = L"w+b";
-            break;
-        case ios_base::in | ios_base::out | ios_base::app | ios_base::binary:
-        case ios_base::in | ios_base::app | ios_base::binary:
-            __mdstr = L"a+b";
-            break;
-        default:
-            __rt = nullptr;
-            break;
-        }
-        if (__rt)
-        {
-            __file_ = _wfopen(__s, __mdstr);
-            if (__file_)
-            {
-                __om_ = __mode;
-                if (__mode & ios_base::ate)
-                {
-                    if (fseek(__file_, 0, SEEK_END))
-                    {
-                        fclose(__file_);
-                        __file_ = nullptr;
-                        __rt = nullptr;
-                    }
-                }
-            }
-            else
-                __rt = nullptr;
-        }
-    }
-    return __rt;
-}
-#endif
-
-template <class _CharT, class _Traits>
-inline
-basic_filebuf<_CharT, _Traits>*
-basic_filebuf<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
-{
-    return open(__s.c_str(), __mode);
-}
-
-template <class _CharT, class _Traits>
-basic_filebuf<_CharT, _Traits>*
-basic_filebuf<_CharT, _Traits>::close()
-{
-    basic_filebuf<_CharT, _Traits>* __rt = nullptr;
-    if (__file_)
-    {
-        __rt = this;
-        unique_ptr<FILE, int(*)(FILE*)> __h(__file_, fclose);
-        if (sync())
-            __rt = nullptr;
-        if (fclose(__h.release()))
-            __rt = nullptr;
-        __file_ = nullptr;
-        setbuf(0, 0);
-    }
-    return __rt;
-}
-
-template <class _CharT, class _Traits>
-typename basic_filebuf<_CharT, _Traits>::int_type
-basic_filebuf<_CharT, _Traits>::underflow()
-{
-    if (__file_ == nullptr)
-        return traits_type::eof();
-    bool __initial = __read_mode();
-    char_type __1buf;
-    if (this->gptr() == nullptr)
-        this->setg(&__1buf, &__1buf+1, &__1buf+1);
-    const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4);
-    int_type __c = traits_type::eof();
-    if (this->gptr() == this->egptr())
-    {
-        _VSTD::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
-        if (__always_noconv_)
-        {
-            size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz);
-            __nmemb = ::fread(this->eback() + __unget_sz, 1, __nmemb, __file_);
-            if (__nmemb != 0)
-            {
-                this->setg(this->eback(),
-                           this->eback() + __unget_sz,
-                           this->eback() + __unget_sz + __nmemb);
-                __c = traits_type::to_int_type(*this->gptr());
-            }
-        }
-        else
-        {
-            if (__extbufend_ != __extbufnext_) {
-                _LIBCPP_ASSERT(__extbufnext_ != nullptr, "underflow moving from nullptr");
-                _LIBCPP_ASSERT(__extbuf_ != nullptr, "underflow moving into nullptr");
-                _VSTD::memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
-            }
-            __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
-            __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
-            size_t __nmemb = _VSTD::min(static_cast<size_t>(__ibs_ - __unget_sz),
-                                 static_cast<size_t>(__extbufend_ - __extbufnext_));
-            codecvt_base::result __r;
-            __st_last_ = __st_;
-            size_t __nr = fread((void*) const_cast<char *>(__extbufnext_), 1, __nmemb, __file_);
-            if (__nr != 0)
-            {
-                if (!__cv_)
-                    __throw_bad_cast();
-
-                __extbufend_ = __extbufnext_ + __nr;
-                char_type*  __inext;
-                __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,
-                                       this->eback() + __unget_sz,
-                                       this->eback() + __ibs_, __inext);
-                if (__r == codecvt_base::noconv)
-                {
-                    this->setg((char_type*)__extbuf_, (char_type*)__extbuf_,
-                                          (char_type*)const_cast<char *>(__extbufend_));
-                    __c = traits_type::to_int_type(*this->gptr());
-                }
-                else if (__inext != this->eback() + __unget_sz)
-                {
-                    this->setg(this->eback(), this->eback() + __unget_sz, __inext);
-                    __c = traits_type::to_int_type(*this->gptr());
-                }
-            }
-        }
-    }
-    else
-        __c = traits_type::to_int_type(*this->gptr());
-    if (this->eback() == &__1buf)
-        this->setg(nullptr, nullptr, nullptr);
-    return __c;
-}
-
-template <class _CharT, class _Traits>
-typename basic_filebuf<_CharT, _Traits>::int_type
-basic_filebuf<_CharT, _Traits>::pbackfail(int_type __c)
-{
-    if (__file_ && this->eback() < this->gptr())
-    {
-        if (traits_type::eq_int_type(__c, traits_type::eof()))
-        {
-            this->gbump(-1);
-            return traits_type::not_eof(__c);
-        }
-        if ((__om_ & ios_base::out) ||
-            traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
-        {
-            this->gbump(-1);
-            *this->gptr() = traits_type::to_char_type(__c);
-            return __c;
-        }
-    }
+typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>::underflow() {
+  if (__file_ == nullptr)
     return traits_type::eof();
+  bool __initial = __read_mode();
+  char_type __1buf;
+  if (this->gptr() == nullptr)
+    this->setg(&__1buf, &__1buf + 1, &__1buf + 1);
+  const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4);
+  int_type __c            = traits_type::eof();
+  if (this->gptr() == this->egptr()) {
+    std::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
+    if (__always_noconv_) {
+      size_t __nmemb = static_cast<size_t>(this->egptr() - this->eback() - __unget_sz);
+      __nmemb        = ::fread(this->eback() + __unget_sz, 1, __nmemb, __file_);
+      if (__nmemb != 0) {
+        this->setg(this->eback(), this->eback() + __unget_sz, this->eback() + __unget_sz + __nmemb);
+        __c = traits_type::to_int_type(*this->gptr());
+      }
+    } else {
+      if (__extbufend_ != __extbufnext_) {
+        _LIBCPP_ASSERT_NON_NULL(__extbufnext_ != nullptr, "underflow moving from nullptr");
+        _LIBCPP_ASSERT_NON_NULL(__extbuf_ != nullptr, "underflow moving into nullptr");
+        std::memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
+      }
+      __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
+      __extbufend_  = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
+      size_t __nmemb =
+          std::min(static_cast<size_t>(__ibs_ - __unget_sz), static_cast<size_t>(__extbufend_ - __extbufnext_));
+      codecvt_base::result __r;
+      __st_last_  = __st_;
+      size_t __nr = fread((void*)const_cast<char*>(__extbufnext_), 1, __nmemb, __file_);
+      if (__nr != 0) {
+        if (!__cv_)
+          __throw_bad_cast();
+
+        __extbufend_ = __extbufnext_ + __nr;
+        char_type* __inext;
+        __r = __cv_->in(
+            __st_, __extbuf_, __extbufend_, __extbufnext_, this->eback() + __unget_sz, this->eback() + __ibs_, __inext);
+        if (__r == codecvt_base::noconv) {
+          this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, (char_type*)const_cast<char*>(__extbufend_));
+          __c = traits_type::to_int_type(*this->gptr());
+        } else if (__inext != this->eback() + __unget_sz) {
+          this->setg(this->eback(), this->eback() + __unget_sz, __inext);
+          __c = traits_type::to_int_type(*this->gptr());
+        }
+      }
+    }
+  } else
+    __c = traits_type::to_int_type(*this->gptr());
+  if (this->eback() == &__1buf)
+    this->setg(nullptr, nullptr, nullptr);
+  return __c;
 }
 
 template <class _CharT, class _Traits>
-typename basic_filebuf<_CharT, _Traits>::int_type
-basic_filebuf<_CharT, _Traits>::overflow(int_type __c)
-{
-    if (__file_ == nullptr)
+typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>::pbackfail(int_type __c) {
+  if (__file_ && this->eback() < this->gptr()) {
+    if (traits_type::eq_int_type(__c, traits_type::eof())) {
+      this->gbump(-1);
+      return traits_type::not_eof(__c);
+    }
+    if ((__om_ & ios_base::out) || traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) {
+      this->gbump(-1);
+      *this->gptr() = traits_type::to_char_type(__c);
+      return __c;
+    }
+  }
+  return traits_type::eof();
+}
+
+template <class _CharT, class _Traits>
+typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>::overflow(int_type __c) {
+  if (__file_ == nullptr)
+    return traits_type::eof();
+  __write_mode();
+  char_type __1buf;
+  char_type* __pb_save  = this->pbase();
+  char_type* __epb_save = this->epptr();
+  if (!traits_type::eq_int_type(__c, traits_type::eof())) {
+    if (this->pptr() == nullptr)
+      this->setp(&__1buf, &__1buf + 1);
+    *this->pptr() = traits_type::to_char_type(__c);
+    this->pbump(1);
+  }
+  if (this->pptr() != this->pbase()) {
+    if (__always_noconv_) {
+      size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
+      if (std::fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb)
         return traits_type::eof();
-    __write_mode();
-    char_type __1buf;
-    char_type* __pb_save = this->pbase();
-    char_type* __epb_save = this->epptr();
-    if (!traits_type::eq_int_type(__c, traits_type::eof()))
-    {
-        if (this->pptr() == nullptr)
-            this->setp(&__1buf, &__1buf+1);
-        *this->pptr() = traits_type::to_char_type(__c);
-        this->pbump(1);
-    }
-    if (this->pptr() != this->pbase())
-    {
-        if (__always_noconv_)
-        {
-            size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
-            if (std::fwrite(this->pbase(), sizeof(char_type), __nmemb, __file_) != __nmemb)
-                return traits_type::eof();
-        }
-        else
-        {
-            char* __extbe = __extbuf_;
-            codecvt_base::result __r;
-            do
-            {
-                if (!__cv_)
-                    __throw_bad_cast();
+    } else {
+      char* __extbe = __extbuf_;
+      codecvt_base::result __r;
+      do {
+        if (!__cv_)
+          __throw_bad_cast();
 
-                const char_type* __e;
-                __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
-                                        __extbuf_, __extbuf_ + __ebs_, __extbe);
-                if (__e == this->pbase())
-                    return traits_type::eof();
-                if (__r == codecvt_base::noconv)
-                {
-                    size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
-                    if (std::fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb)
-                        return traits_type::eof();
-                }
-                else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
-                {
-                    size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
-                    if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
-                        return traits_type::eof();
-                    if (__r == codecvt_base::partial)
-                    {
-                        this->setp(const_cast<char_type*>(__e), this->pptr());
-                        this->__pbump(this->epptr() - this->pbase());
-                    }
-                }
-                else
-                    return traits_type::eof();
-            } while (__r == codecvt_base::partial);
-        }
-        this->setp(__pb_save, __epb_save);
+        const char_type* __e;
+        __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, __extbuf_, __extbuf_ + __ebs_, __extbe);
+        if (__e == this->pbase())
+          return traits_type::eof();
+        if (__r == codecvt_base::noconv) {
+          size_t __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
+          if (std::fwrite(this->pbase(), 1, __nmemb, __file_) != __nmemb)
+            return traits_type::eof();
+        } else if (__r == codecvt_base::ok || __r == codecvt_base::partial) {
+          size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
+          if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
+            return traits_type::eof();
+          if (__r == codecvt_base::partial) {
+            this->setp(const_cast<char_type*>(__e), this->pptr());
+            this->__pbump(this->epptr() - this->pbase());
+          }
+        } else
+          return traits_type::eof();
+      } while (__r == codecvt_base::partial);
     }
-    return traits_type::not_eof(__c);
+    this->setp(__pb_save, __epb_save);
+  }
+  return traits_type::not_eof(__c);
 }
 
 template <class _CharT, class _Traits>
-basic_streambuf<_CharT, _Traits>*
-basic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n)
-{
+basic_streambuf<_CharT, _Traits>* basic_filebuf<_CharT, _Traits>::setbuf(char_type* __s, streamsize __n) {
+  this->setg(nullptr, nullptr, nullptr);
+  this->setp(nullptr, nullptr);
+  __request_unbuffered_mode(__s, __n);
+  if (__owns_eb_)
+    delete[] __extbuf_;
+  if (__owns_ib_)
+    delete[] __intbuf_;
+  __ebs_ = __n;
+  if (__ebs_ > sizeof(__extbuf_min_)) {
+    if (__always_noconv_ && __s) {
+      __extbuf_  = (char*)__s;
+      __owns_eb_ = false;
+    } else {
+      __extbuf_  = new char[__ebs_];
+      __owns_eb_ = true;
+    }
+  } else {
+    __extbuf_  = __extbuf_min_;
+    __ebs_     = sizeof(__extbuf_min_);
+    __owns_eb_ = false;
+  }
+  if (!__always_noconv_) {
+    __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_));
+    if (__s && __ibs_ > sizeof(__extbuf_min_)) {
+      __intbuf_  = __s;
+      __owns_ib_ = false;
+    } else {
+      __intbuf_  = new char_type[__ibs_];
+      __owns_ib_ = true;
+    }
+  } else {
+    __ibs_     = 0;
+    __intbuf_  = nullptr;
+    __owns_ib_ = false;
+  }
+  return this;
+}
+
+template <class _CharT, class _Traits>
+typename basic_filebuf<_CharT, _Traits>::pos_type
+basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode) {
+  if (!__cv_)
+    __throw_bad_cast();
+
+  int __width = __cv_->encoding();
+  if (__file_ == nullptr || (__width <= 0 && __off != 0) || sync())
+    return pos_type(off_type(-1));
+  // __width > 0 || __off == 0
+  int __whence;
+  switch (__way) {
+  case ios_base::beg:
+    __whence = SEEK_SET;
+    break;
+  case ios_base::cur:
+    __whence = SEEK_CUR;
+    break;
+  case ios_base::end:
+    __whence = SEEK_END;
+    break;
+  default:
+    return pos_type(off_type(-1));
+  }
+#  if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
+  if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence))
+    return pos_type(off_type(-1));
+  pos_type __r = ftell(__file_);
+#  else
+  if (::fseeko(__file_, __width > 0 ? __width * __off : 0, __whence))
+    return pos_type(off_type(-1));
+  pos_type __r = ftello(__file_);
+#  endif
+  __r.state(__st_);
+  return __r;
+}
+
+template <class _CharT, class _Traits>
+typename basic_filebuf<_CharT, _Traits>::pos_type
+basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode) {
+  if (__file_ == nullptr || sync())
+    return pos_type(off_type(-1));
+#  if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
+  if (fseek(__file_, __sp, SEEK_SET))
+    return pos_type(off_type(-1));
+#  else
+  if (::fseeko(__file_, __sp, SEEK_SET))
+    return pos_type(off_type(-1));
+#  endif
+  __st_ = __sp.state();
+  return __sp;
+}
+
+template <class _CharT, class _Traits>
+int basic_filebuf<_CharT, _Traits>::sync() {
+  if (__file_ == nullptr)
+    return 0;
+  if (!__cv_)
+    __throw_bad_cast();
+
+  if (__cm_ & ios_base::out) {
+    if (this->pptr() != this->pbase())
+      if (overflow() == traits_type::eof())
+        return -1;
+    codecvt_base::result __r;
+    do {
+      char* __extbe;
+      __r            = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe);
+      size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
+      if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
+        return -1;
+    } while (__r == codecvt_base::partial);
+    if (__r == codecvt_base::error)
+      return -1;
+    if (fflush(__file_))
+      return -1;
+  } else if (__cm_ & ios_base::in) {
+    off_type __c;
+    state_type __state = __st_last_;
+    bool __update_st   = false;
+    if (__always_noconv_)
+      __c = this->egptr() - this->gptr();
+    else {
+      int __width = __cv_->encoding();
+      __c         = __extbufend_ - __extbufnext_;
+      if (__width > 0)
+        __c += __width * (this->egptr() - this->gptr());
+      else {
+        if (this->gptr() != this->egptr()) {
+          const int __off = __cv_->length(__state, __extbuf_, __extbufnext_, this->gptr() - this->eback());
+          __c += __extbufnext_ - __extbuf_ - __off;
+          __update_st = true;
+        }
+      }
+    }
+#  if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
+    if (fseek(__file_, -__c, SEEK_CUR))
+      return -1;
+#  else
+    if (::fseeko(__file_, -__c, SEEK_CUR))
+      return -1;
+#  endif
+    if (__update_st)
+      __st_ = __state;
+    __extbufnext_ = __extbufend_ = __extbuf_;
+    this->setg(nullptr, nullptr, nullptr);
+    __cm_ = 0;
+  }
+  return 0;
+}
+
+template <class _CharT, class _Traits>
+void basic_filebuf<_CharT, _Traits>::imbue(const locale& __loc) {
+  sync();
+  __cv_            = &std::use_facet<codecvt<char_type, char, state_type> >(__loc);
+  bool __old_anc   = __always_noconv_;
+  __always_noconv_ = __cv_->always_noconv();
+  if (__old_anc != __always_noconv_) {
     this->setg(nullptr, nullptr, nullptr);
     this->setp(nullptr, nullptr);
-    if (__owns_eb_)
-        delete [] __extbuf_;
-    if (__owns_ib_)
-        delete [] __intbuf_;
-    __ebs_ = __n;
-    if (__ebs_ > sizeof(__extbuf_min_))
+    // invariant, char_type is char, else we couldn't get here
+    if (__always_noconv_) // need to dump __intbuf_
     {
-        if (__always_noconv_ && __s)
-        {
-            __extbuf_ = (char*)__s;
-            __owns_eb_ = false;
-        }
-        else
-        {
-            __extbuf_ = new char[__ebs_];
-            __owns_eb_ = true;
-        }
-    }
-    else
-    {
-        __extbuf_ = __extbuf_min_;
-        __ebs_ = sizeof(__extbuf_min_);
-        __owns_eb_ = false;
-    }
-    if (!__always_noconv_)
-    {
-        __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_));
-        if (__s && __ibs_ >= sizeof(__extbuf_min_))
-        {
-            __intbuf_ = __s;
-            __owns_ib_ = false;
-        }
-        else
-        {
-            __intbuf_ = new char_type[__ibs_];
-            __owns_ib_ = true;
-        }
-    }
-    else
-    {
-        __ibs_ = 0;
-        __intbuf_ = nullptr;
+      if (__owns_eb_)
+        delete[] __extbuf_;
+      __owns_eb_ = __owns_ib_;
+      __ebs_     = __ibs_;
+      __extbuf_  = (char*)__intbuf_;
+      __ibs_     = 0;
+      __intbuf_  = nullptr;
+      __owns_ib_ = false;
+    } else // need to obtain an __intbuf_.
+    {      // If __extbuf_ is user-supplied, use it, else new __intbuf_
+      if (!__owns_eb_ && __extbuf_ != __extbuf_min_) {
+        __ibs_     = __ebs_;
+        __intbuf_  = (char_type*)__extbuf_;
         __owns_ib_ = false;
+        __extbuf_  = new char[__ebs_];
+        __owns_eb_ = true;
+      } else {
+        __ibs_     = __ebs_;
+        __intbuf_  = new char_type[__ibs_];
+        __owns_ib_ = true;
+      }
     }
-    return this;
+  }
 }
 
 template <class _CharT, class _Traits>
-typename basic_filebuf<_CharT, _Traits>::pos_type
-basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way,
-                                        ios_base::openmode)
-{
-    if (!__cv_)
-        __throw_bad_cast();
-
-    int __width = __cv_->encoding();
-    if (__file_ == nullptr || (__width <= 0 && __off != 0) || sync())
-        return pos_type(off_type(-1));
-    // __width > 0 || __off == 0
-    int __whence;
-    switch (__way)
-    {
-    case ios_base::beg:
-        __whence = SEEK_SET;
-        break;
-    case ios_base::cur:
-        __whence = SEEK_CUR;
-        break;
-    case ios_base::end:
-        __whence = SEEK_END;
-        break;
-    default:
-        return pos_type(off_type(-1));
-    }
-#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
-    if (fseek(__file_, __width > 0 ? __width * __off : 0, __whence))
-        return pos_type(off_type(-1));
-    pos_type __r = ftell(__file_);
-#else
-    if (::fseeko(__file_, __width > 0 ? __width * __off : 0, __whence))
-        return pos_type(off_type(-1));
-    pos_type __r = ftello(__file_);
-#endif
-    __r.state(__st_);
-    return __r;
+bool basic_filebuf<_CharT, _Traits>::__read_mode() {
+  if (!(__cm_ & ios_base::in)) {
+    this->setp(nullptr, nullptr);
+    if (__always_noconv_)
+      this->setg((char_type*)__extbuf_, (char_type*)__extbuf_ + __ebs_, (char_type*)__extbuf_ + __ebs_);
+    else
+      this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
+    __cm_ = ios_base::in;
+    return true;
+  }
+  return false;
 }
 
 template <class _CharT, class _Traits>
-typename basic_filebuf<_CharT, _Traits>::pos_type
-basic_filebuf<_CharT, _Traits>::seekpos(pos_type __sp, ios_base::openmode)
-{
-    if (__file_ == nullptr || sync())
-        return pos_type(off_type(-1));
-#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
-    if (fseek(__file_, __sp, SEEK_SET))
-        return pos_type(off_type(-1));
-#else
-    if (::fseeko(__file_, __sp, SEEK_SET))
-        return pos_type(off_type(-1));
-#endif
-    __st_ = __sp.state();
-    return __sp;
-}
-
-template <class _CharT, class _Traits>
-int
-basic_filebuf<_CharT, _Traits>::sync()
-{
-    if (__file_ == nullptr)
-        return 0;
-    if (!__cv_)
-        __throw_bad_cast();
-
-    if (__cm_ & ios_base::out)
-    {
-        if (this->pptr() != this->pbase())
-            if (overflow() == traits_type::eof())
-                return -1;
-        codecvt_base::result __r;
-        do
-        {
-            char* __extbe;
-            __r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe);
-            size_t __nmemb = static_cast<size_t>(__extbe - __extbuf_);
-            if (fwrite(__extbuf_, 1, __nmemb, __file_) != __nmemb)
-                return -1;
-        } while (__r == codecvt_base::partial);
-        if (__r == codecvt_base::error)
-            return -1;
-        if (fflush(__file_))
-            return -1;
-    }
-    else if (__cm_ & ios_base::in)
-    {
-        off_type __c;
-        state_type __state = __st_last_;
-        bool __update_st = false;
-        if (__always_noconv_)
-            __c = this->egptr() - this->gptr();
-        else
-        {
-            int __width = __cv_->encoding();
-            __c = __extbufend_ - __extbufnext_;
-            if (__width > 0)
-                __c += __width * (this->egptr() - this->gptr());
-            else
-            {
-                if (this->gptr() != this->egptr())
-                {
-                    const int __off =  __cv_->length(__state, __extbuf_,
-                                                     __extbufnext_,
-                                                     this->gptr() - this->eback());
-                    __c += __extbufnext_ - __extbuf_ - __off;
-                    __update_st = true;
-                }
-            }
-        }
-#if defined(_LIBCPP_HAS_NO_OFF_T_FUNCTIONS)
-        if (fseek(__file_, -__c, SEEK_CUR))
-            return -1;
-#else
-        if (::fseeko(__file_, -__c, SEEK_CUR))
-            return -1;
-#endif
-        if (__update_st)
-            __st_ = __state;
-        __extbufnext_ = __extbufend_ = __extbuf_;
-        this->setg(nullptr, nullptr, nullptr);
-        __cm_ = 0;
-    }
-    return 0;
-}
-
-template <class _CharT, class _Traits>
-void
-basic_filebuf<_CharT, _Traits>::imbue(const locale& __loc)
-{
-    sync();
-    __cv_ = &std::use_facet<codecvt<char_type, char, state_type> >(__loc);
-    bool __old_anc = __always_noconv_;
-    __always_noconv_ = __cv_->always_noconv();
-    if (__old_anc != __always_noconv_)
-    {
-        this->setg(nullptr, nullptr, nullptr);
-        this->setp(nullptr, nullptr);
-        // invariant, char_type is char, else we couldn't get here
-        if (__always_noconv_)  // need to dump __intbuf_
-        {
-            if (__owns_eb_)
-                delete [] __extbuf_;
-            __owns_eb_ = __owns_ib_;
-            __ebs_ = __ibs_;
-            __extbuf_ = (char*)__intbuf_;
-            __ibs_ = 0;
-            __intbuf_ = nullptr;
-            __owns_ib_ = false;
-        }
-        else  // need to obtain an __intbuf_.
-        {     // If __extbuf_ is user-supplied, use it, else new __intbuf_
-            if (!__owns_eb_ && __extbuf_ != __extbuf_min_)
-            {
-                __ibs_ = __ebs_;
-                __intbuf_ = (char_type*)__extbuf_;
-                __owns_ib_ = false;
-                __extbuf_ = new char[__ebs_];
-                __owns_eb_ = true;
-            }
-            else
-            {
-                __ibs_ = __ebs_;
-                __intbuf_ = new char_type[__ibs_];
-                __owns_ib_ = true;
-            }
-        }
-    }
-}
-
-template <class _CharT, class _Traits>
-bool
-basic_filebuf<_CharT, _Traits>::__read_mode()
-{
-    if (!(__cm_ & ios_base::in))
-    {
-        this->setp(nullptr, nullptr);
-        if (__always_noconv_)
-            this->setg((char_type*)__extbuf_,
-                       (char_type*)__extbuf_ + __ebs_,
-                       (char_type*)__extbuf_ + __ebs_);
-        else
-            this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
-        __cm_ = ios_base::in;
-        return true;
-    }
-    return false;
-}
-
-template <class _CharT, class _Traits>
-void
-basic_filebuf<_CharT, _Traits>::__write_mode()
-{
-    if (!(__cm_ & ios_base::out))
-    {
-        this->setg(nullptr, nullptr, nullptr);
-        if (__ebs_ > sizeof(__extbuf_min_))
-        {
-            if (__always_noconv_)
-                this->setp((char_type*)__extbuf_,
-                           (char_type*)__extbuf_ + (__ebs_ - 1));
-            else
-                this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1));
-        }
-        else
-            this->setp(nullptr, nullptr);
-        __cm_ = ios_base::out;
-    }
+void basic_filebuf<_CharT, _Traits>::__write_mode() {
+  if (!(__cm_ & ios_base::out)) {
+    this->setg(nullptr, nullptr, nullptr);
+    if (__ebs_ > sizeof(__extbuf_min_)) {
+      if (__always_noconv_)
+        this->setp((char_type*)__extbuf_, (char_type*)__extbuf_ + (__ebs_ - 1));
+      else
+        this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1));
+    } else
+      this->setp(nullptr, nullptr);
+    __cm_ = ios_base::out;
+  }
 }
 
 // basic_ifstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TEMPLATE_VIS basic_ifstream
-    : public basic_istream<_CharT, _Traits>
-{
+class _LIBCPP_TEMPLATE_VIS basic_ifstream : public basic_istream<_CharT, _Traits> {
 public:
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+#  if _LIBCPP_STD_VER >= 26
+  using native_handle_type = typename basic_filebuf<_CharT, _Traits>::native_handle_type;
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ifstream();
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in);
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
-#endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
-#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ifstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in)
+  _LIBCPP_HIDE_FROM_ABI basic_ifstream();
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in);
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ifstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
+#  endif
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
+#  if _LIBCPP_STD_VER >= 17
+  template <class _Tp, class = enable_if_t<is_same_v<_Tp, filesystem::path>>>
+  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
+      _LIBCPP_HIDE_FROM_ABI explicit basic_ifstream(const _Tp& __p, ios_base::openmode __mode = ios_base::in)
       : basic_ifstream(__p.c_str(), __mode) {}
-#endif // _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ifstream(basic_ifstream&& __rhs);
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ifstream& operator=(basic_ifstream&& __rhs);
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(basic_ifstream& __rhs);
+#  endif // _LIBCPP_STD_VER >= 17
+  _LIBCPP_HIDE_FROM_ABI basic_ifstream(basic_ifstream&& __rhs);
+  _LIBCPP_HIDE_FROM_ABI basic_ifstream& operator=(basic_ifstream&& __rhs);
+  _LIBCPP_HIDE_FROM_ABI void swap(basic_ifstream& __rhs);
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_filebuf<char_type, traits_type>* rdbuf() const;
-    _LIBCPP_INLINE_VISIBILITY
-    bool is_open() const;
-    void open(const char* __s, ios_base::openmode __mode = ios_base::in);
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-    void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
-#endif
-    void open(const string& __s, ios_base::openmode __mode = ios_base::in);
-#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
-    void open(const filesystem::path& __p,
-              ios_base::openmode __mode = ios_base::in) {
-      return open(__p.c_str(), __mode);
-    }
-#endif // _LIBCPP_STD_VER >= 17
+  _LIBCPP_HIDE_FROM_ABI basic_filebuf<char_type, traits_type>* rdbuf() const;
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept { return rdbuf()->native_handle(); }
+#  endif
+  _LIBCPP_HIDE_FROM_ABI bool is_open() const;
+  void open(const char* __s, ios_base::openmode __mode = ios_base::in);
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+  void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
+#  endif
+  void open(const string& __s, ios_base::openmode __mode = ios_base::in);
+#  if _LIBCPP_STD_VER >= 17
+  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI void
+  open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in) {
+    return open(__p.c_str(), __mode);
+  }
+#  endif // _LIBCPP_STD_VER >= 17
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __open(int __fd, ios_base::openmode __mode);
-    _LIBCPP_INLINE_VISIBILITY
-    void close();
+  _LIBCPP_HIDE_FROM_ABI void __open(int __fd, ios_base::openmode __mode);
+  _LIBCPP_HIDE_FROM_ABI void close();
 
 private:
-    basic_filebuf<char_type, traits_type> __sb_;
+  basic_filebuf<char_type, traits_type> __sb_;
 };
 
 template <class _CharT, class _Traits>
-inline
-basic_ifstream<_CharT, _Traits>::basic_ifstream()
-    : basic_istream<char_type, traits_type>(&__sb_)
-{
+inline basic_ifstream<_CharT, _Traits>::basic_ifstream() : basic_istream<char_type, traits_type>(&__sb_) {}
+
+template <class _CharT, class _Traits>
+inline basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode)
+    : basic_istream<char_type, traits_type>(&__sb_) {
+  if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
+    this->setstate(ios_base::failbit);
+}
+
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+inline basic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode)
+    : basic_istream<char_type, traits_type>(&__sb_) {
+  if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
+    this->setstate(ios_base::failbit);
+}
+#  endif
+
+template <class _CharT, class _Traits>
+inline basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode)
+    : basic_istream<char_type, traits_type>(&__sb_) {
+  if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
+    this->setstate(ios_base::failbit);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_ifstream<_CharT, _Traits>::basic_ifstream(const char* __s, ios_base::openmode __mode)
-    : basic_istream<char_type, traits_type>(&__sb_)
-{
-    if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
-        this->setstate(ios_base::failbit);
-}
-
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-template <class _CharT, class _Traits>
-inline
-basic_ifstream<_CharT, _Traits>::basic_ifstream(const wchar_t* __s, ios_base::openmode __mode)
-    : basic_istream<char_type, traits_type>(&__sb_)
-{
-    if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
-        this->setstate(ios_base::failbit);
-}
-#endif
-
-template <class _CharT, class _Traits>
-inline
-basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::openmode __mode)
-    : basic_istream<char_type, traits_type>(&__sb_)
-{
-    if (__sb_.open(__s, __mode | ios_base::in) == nullptr)
-        this->setstate(ios_base::failbit);
+inline basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
+    : basic_istream<char_type, traits_type>(std::move(__rhs)), __sb_(std::move(__rhs.__sb_)) {
+  this->set_rdbuf(&__sb_);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
-    : basic_istream<char_type, traits_type>(_VSTD::move(__rhs)),
-      __sb_(_VSTD::move(__rhs.__sb_))
-{
-    this->set_rdbuf(&__sb_);
+inline basic_ifstream<_CharT, _Traits>& basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs) {
+  basic_istream<char_type, traits_type>::operator=(std::move(__rhs));
+  __sb_ = std::move(__rhs.__sb_);
+  return *this;
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_ifstream<_CharT, _Traits>&
-basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
-{
-    basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
-    __sb_ = _VSTD::move(__rhs.__sb_);
-    return *this;
+inline void basic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs) {
+  basic_istream<char_type, traits_type>::swap(__rhs);
+  __sb_.swap(__rhs.__sb_);
 }
 
 template <class _CharT, class _Traits>
-inline
-void
-basic_ifstream<_CharT, _Traits>::swap(basic_ifstream& __rhs)
-{
-    basic_istream<char_type, traits_type>::swap(__rhs);
-    __sb_.swap(__rhs.__sb_);
+inline _LIBCPP_HIDE_FROM_ABI void swap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y) {
+  __x.swap(__y);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(basic_ifstream<_CharT, _Traits>& __x, basic_ifstream<_CharT, _Traits>& __y)
-{
-    __x.swap(__y);
+inline basic_filebuf<_CharT, _Traits>* basic_ifstream<_CharT, _Traits>::rdbuf() const {
+  return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_filebuf<_CharT, _Traits>*
-basic_ifstream<_CharT, _Traits>::rdbuf() const
-{
-    return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
+inline bool basic_ifstream<_CharT, _Traits>::is_open() const {
+  return __sb_.is_open();
 }
 
 template <class _CharT, class _Traits>
-inline
-bool
-basic_ifstream<_CharT, _Traits>::is_open() const
-{
-    return __sb_.is_open();
+void basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) {
+  if (__sb_.open(__s, __mode | ios_base::in))
+    this->clear();
+  else
+    this->setstate(ios_base::failbit);
+}
+
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+void basic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) {
+  if (__sb_.open(__s, __mode | ios_base::in))
+    this->clear();
+  else
+    this->setstate(ios_base::failbit);
+}
+#  endif
+
+template <class _CharT, class _Traits>
+void basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) {
+  if (__sb_.open(__s, __mode | ios_base::in))
+    this->clear();
+  else
+    this->setstate(ios_base::failbit);
 }
 
 template <class _CharT, class _Traits>
-void
-basic_ifstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
-{
-    if (__sb_.open(__s, __mode | ios_base::in))
-        this->clear();
-    else
-        this->setstate(ios_base::failbit);
-}
-
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-template <class _CharT, class _Traits>
-void
-basic_ifstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
-{
-    if (__sb_.open(__s, __mode | ios_base::in))
-        this->clear();
-    else
-        this->setstate(ios_base::failbit);
-}
-#endif
-
-template <class _CharT, class _Traits>
-void
-basic_ifstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
-{
-    if (__sb_.open(__s, __mode | ios_base::in))
-        this->clear();
-    else
-        this->setstate(ios_base::failbit);
-}
-
-template <class _CharT, class _Traits>
-inline
-void basic_ifstream<_CharT, _Traits>::__open(int __fd,
-                                             ios_base::openmode __mode) {
+inline void basic_ifstream<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) {
   if (__sb_.__open(__fd, __mode | ios_base::in))
     this->clear();
   else
@@ -1337,200 +1230,156 @@ void basic_ifstream<_CharT, _Traits>::__open(int __fd,
 }
 
 template <class _CharT, class _Traits>
-inline
-void
-basic_ifstream<_CharT, _Traits>::close()
-{
-    if (__sb_.close() == 0)
-        this->setstate(ios_base::failbit);
+inline void basic_ifstream<_CharT, _Traits>::close() {
+  if (__sb_.close() == 0)
+    this->setstate(ios_base::failbit);
 }
 
 // basic_ofstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TEMPLATE_VIS basic_ofstream
-    : public basic_ostream<_CharT, _Traits>
-{
+class _LIBCPP_TEMPLATE_VIS basic_ofstream : public basic_ostream<_CharT, _Traits> {
 public:
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+#  if _LIBCPP_STD_VER >= 26
+  using native_handle_type = typename basic_filebuf<_CharT, _Traits>::native_handle_type;
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ofstream();
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
-#endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
+  _LIBCPP_HIDE_FROM_ABI basic_ofstream();
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ofstream(const char* __s, ios_base::openmode __mode = ios_base::out);
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ofstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
+#  endif
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ofstream(const string& __s, ios_base::openmode __mode = ios_base::out);
 
-#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ofstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out)
+#  if _LIBCPP_STD_VER >= 17
+  template <class _Tp, class = enable_if_t<is_same_v<_Tp, filesystem::path>>>
+  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
+      _LIBCPP_HIDE_FROM_ABI explicit basic_ofstream(const _Tp& __p, ios_base::openmode __mode = ios_base::out)
       : basic_ofstream(__p.c_str(), __mode) {}
-#endif // _LIBCPP_STD_VER >= 17
+#  endif // _LIBCPP_STD_VER >= 17
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ofstream(basic_ofstream&& __rhs);
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ofstream& operator=(basic_ofstream&& __rhs);
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(basic_ofstream& __rhs);
+  _LIBCPP_HIDE_FROM_ABI basic_ofstream(basic_ofstream&& __rhs);
+  _LIBCPP_HIDE_FROM_ABI basic_ofstream& operator=(basic_ofstream&& __rhs);
+  _LIBCPP_HIDE_FROM_ABI void swap(basic_ofstream& __rhs);
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_filebuf<char_type, traits_type>* rdbuf() const;
-    _LIBCPP_INLINE_VISIBILITY
-    bool is_open() const;
-    void open(const char* __s, ios_base::openmode __mode = ios_base::out);
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-    void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
-#endif
-    void open(const string& __s, ios_base::openmode __mode = ios_base::out);
+  _LIBCPP_HIDE_FROM_ABI basic_filebuf<char_type, traits_type>* rdbuf() const;
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept { return rdbuf()->native_handle(); }
+#  endif
+  _LIBCPP_HIDE_FROM_ABI bool is_open() const;
+  void open(const char* __s, ios_base::openmode __mode = ios_base::out);
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+  void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
+#  endif
+  void open(const string& __s, ios_base::openmode __mode = ios_base::out);
 
-#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
-    void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out)
-    { return open(__p.c_str(), __mode); }
-#endif // _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
+  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI void
+  open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) {
+    return open(__p.c_str(), __mode);
+  }
+#  endif // _LIBCPP_STD_VER >= 17
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __open(int __fd, ios_base::openmode __mode);
-    _LIBCPP_INLINE_VISIBILITY
-    void close();
+  _LIBCPP_HIDE_FROM_ABI void __open(int __fd, ios_base::openmode __mode);
+  _LIBCPP_HIDE_FROM_ABI void close();
 
 private:
-    basic_filebuf<char_type, traits_type> __sb_;
+  basic_filebuf<char_type, traits_type> __sb_;
 };
 
 template <class _CharT, class _Traits>
-inline
-basic_ofstream<_CharT, _Traits>::basic_ofstream()
-    : basic_ostream<char_type, traits_type>(&__sb_)
-{
+inline basic_ofstream<_CharT, _Traits>::basic_ofstream() : basic_ostream<char_type, traits_type>(&__sb_) {}
+
+template <class _CharT, class _Traits>
+inline basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode)
+    : basic_ostream<char_type, traits_type>(&__sb_) {
+  if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
+    this->setstate(ios_base::failbit);
+}
+
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+inline basic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode)
+    : basic_ostream<char_type, traits_type>(&__sb_) {
+  if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
+    this->setstate(ios_base::failbit);
+}
+#  endif
+
+template <class _CharT, class _Traits>
+inline basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode)
+    : basic_ostream<char_type, traits_type>(&__sb_) {
+  if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
+    this->setstate(ios_base::failbit);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_ofstream<_CharT, _Traits>::basic_ofstream(const char* __s, ios_base::openmode __mode)
-    : basic_ostream<char_type, traits_type>(&__sb_)
-{
-    if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
-        this->setstate(ios_base::failbit);
-}
-
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-template <class _CharT, class _Traits>
-inline
-basic_ofstream<_CharT, _Traits>::basic_ofstream(const wchar_t* __s, ios_base::openmode __mode)
-    : basic_ostream<char_type, traits_type>(&__sb_)
-{
-    if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
-        this->setstate(ios_base::failbit);
-}
-#endif
-
-template <class _CharT, class _Traits>
-inline
-basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::openmode __mode)
-    : basic_ostream<char_type, traits_type>(&__sb_)
-{
-    if (__sb_.open(__s, __mode | ios_base::out) == nullptr)
-        this->setstate(ios_base::failbit);
+inline basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
+    : basic_ostream<char_type, traits_type>(std::move(__rhs)), __sb_(std::move(__rhs.__sb_)) {
+  this->set_rdbuf(&__sb_);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
-    : basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)),
-      __sb_(_VSTD::move(__rhs.__sb_))
-{
-    this->set_rdbuf(&__sb_);
+inline basic_ofstream<_CharT, _Traits>& basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs) {
+  basic_ostream<char_type, traits_type>::operator=(std::move(__rhs));
+  __sb_ = std::move(__rhs.__sb_);
+  return *this;
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_ofstream<_CharT, _Traits>&
-basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
-{
-    basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
-    __sb_ = _VSTD::move(__rhs.__sb_);
-    return *this;
+inline void basic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs) {
+  basic_ostream<char_type, traits_type>::swap(__rhs);
+  __sb_.swap(__rhs.__sb_);
 }
 
 template <class _CharT, class _Traits>
-inline
-void
-basic_ofstream<_CharT, _Traits>::swap(basic_ofstream& __rhs)
-{
-    basic_ostream<char_type, traits_type>::swap(__rhs);
-    __sb_.swap(__rhs.__sb_);
+inline _LIBCPP_HIDE_FROM_ABI void swap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y) {
+  __x.swap(__y);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(basic_ofstream<_CharT, _Traits>& __x, basic_ofstream<_CharT, _Traits>& __y)
-{
-    __x.swap(__y);
+inline basic_filebuf<_CharT, _Traits>* basic_ofstream<_CharT, _Traits>::rdbuf() const {
+  return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_filebuf<_CharT, _Traits>*
-basic_ofstream<_CharT, _Traits>::rdbuf() const
-{
-    return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
+inline bool basic_ofstream<_CharT, _Traits>::is_open() const {
+  return __sb_.is_open();
 }
 
 template <class _CharT, class _Traits>
-inline
-bool
-basic_ofstream<_CharT, _Traits>::is_open() const
-{
-    return __sb_.is_open();
+void basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) {
+  if (__sb_.open(__s, __mode | ios_base::out))
+    this->clear();
+  else
+    this->setstate(ios_base::failbit);
+}
+
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+void basic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) {
+  if (__sb_.open(__s, __mode | ios_base::out))
+    this->clear();
+  else
+    this->setstate(ios_base::failbit);
+}
+#  endif
+
+template <class _CharT, class _Traits>
+void basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) {
+  if (__sb_.open(__s, __mode | ios_base::out))
+    this->clear();
+  else
+    this->setstate(ios_base::failbit);
 }
 
 template <class _CharT, class _Traits>
-void
-basic_ofstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
-{
-    if (__sb_.open(__s, __mode | ios_base::out))
-        this->clear();
-    else
-        this->setstate(ios_base::failbit);
-}
-
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-template <class _CharT, class _Traits>
-void
-basic_ofstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
-{
-    if (__sb_.open(__s, __mode | ios_base::out))
-        this->clear();
-    else
-        this->setstate(ios_base::failbit);
-}
-#endif
-
-template <class _CharT, class _Traits>
-void
-basic_ofstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
-{
-    if (__sb_.open(__s, __mode | ios_base::out))
-        this->clear();
-    else
-        this->setstate(ios_base::failbit);
-}
-
-template <class _CharT, class _Traits>
-inline
-void basic_ofstream<_CharT, _Traits>::__open(int __fd,
-                                             ios_base::openmode __mode) {
+inline void basic_ofstream<_CharT, _Traits>::__open(int __fd, ios_base::openmode __mode) {
   if (__sb_.__open(__fd, __mode | ios_base::out))
     this->clear();
   else
@@ -1538,214 +1387,173 @@ void basic_ofstream<_CharT, _Traits>::__open(int __fd,
 }
 
 template <class _CharT, class _Traits>
-inline
-void
-basic_ofstream<_CharT, _Traits>::close()
-{
-    if (__sb_.close() == nullptr)
-        this->setstate(ios_base::failbit);
+inline void basic_ofstream<_CharT, _Traits>::close() {
+  if (__sb_.close() == nullptr)
+    this->setstate(ios_base::failbit);
 }
 
 // basic_fstream
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TEMPLATE_VIS basic_fstream
-    : public basic_iostream<_CharT, _Traits>
-{
+class _LIBCPP_TEMPLATE_VIS basic_fstream : public basic_iostream<_CharT, _Traits> {
 public:
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+#  if _LIBCPP_STD_VER >= 26
+  using native_handle_type = typename basic_filebuf<_CharT, _Traits>::native_handle_type;
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_fstream();
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_fstream(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_fstream(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
-#endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_fstream(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
+  _LIBCPP_HIDE_FROM_ABI basic_fstream();
+  _LIBCPP_HIDE_FROM_ABI explicit basic_fstream(const char* __s,
+                                               ios_base::openmode __mode = ios_base::in | ios_base::out);
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+  _LIBCPP_HIDE_FROM_ABI explicit basic_fstream(const wchar_t* __s,
+                                               ios_base::openmode __mode = ios_base::in | ios_base::out);
+#  endif
+  _LIBCPP_HIDE_FROM_ABI explicit basic_fstream(const string& __s,
+                                               ios_base::openmode __mode = ios_base::in | ios_base::out);
 
-#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
-    explicit basic_fstream(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in | ios_base::out)
+#  if _LIBCPP_STD_VER >= 17
+  template <class _Tp, class = enable_if_t<is_same_v<_Tp, filesystem::path>>>
+  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI explicit basic_fstream(
+      const _Tp& __p, ios_base::openmode __mode = ios_base::in | ios_base::out)
       : basic_fstream(__p.c_str(), __mode) {}
-#endif // _LIBCPP_STD_VER >= 17
+#  endif // _LIBCPP_STD_VER >= 17
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_fstream(basic_fstream&& __rhs);
+  _LIBCPP_HIDE_FROM_ABI basic_fstream(basic_fstream&& __rhs);
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_fstream& operator=(basic_fstream&& __rhs);
+  _LIBCPP_HIDE_FROM_ABI basic_fstream& operator=(basic_fstream&& __rhs);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(basic_fstream& __rhs);
+  _LIBCPP_HIDE_FROM_ABI void swap(basic_fstream& __rhs);
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_filebuf<char_type, traits_type>* rdbuf() const;
-    _LIBCPP_INLINE_VISIBILITY
-    bool is_open() const;
-    _LIBCPP_HIDE_FROM_ABI void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-    void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
-#endif
-    _LIBCPP_HIDE_FROM_ABI void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
+  _LIBCPP_HIDE_FROM_ABI basic_filebuf<char_type, traits_type>* rdbuf() const;
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept { return rdbuf()->native_handle(); }
+#  endif
+  _LIBCPP_HIDE_FROM_ABI bool is_open() const;
+  _LIBCPP_HIDE_FROM_ABI void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+  void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
+#  endif
+  _LIBCPP_HIDE_FROM_ABI void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 
-#if _LIBCPP_STD_VER >= 17 && !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-    _LIBCPP_AVAILABILITY_FILESYSTEM _LIBCPP_INLINE_VISIBILITY
-    void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in|ios_base::out)
-    { return open(__p.c_str(), __mode); }
-#endif // _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
+  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI void
+  open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in | ios_base::out) {
+    return open(__p.c_str(), __mode);
+  }
+#  endif // _LIBCPP_STD_VER >= 17
 
-    _LIBCPP_INLINE_VISIBILITY
-    void close();
+  _LIBCPP_HIDE_FROM_ABI void close();
 
 private:
-    basic_filebuf<char_type, traits_type> __sb_;
+  basic_filebuf<char_type, traits_type> __sb_;
 };
 
 template <class _CharT, class _Traits>
-inline
-basic_fstream<_CharT, _Traits>::basic_fstream()
-    : basic_iostream<char_type, traits_type>(&__sb_)
-{
+inline basic_fstream<_CharT, _Traits>::basic_fstream() : basic_iostream<char_type, traits_type>(&__sb_) {}
+
+template <class _CharT, class _Traits>
+inline basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode)
+    : basic_iostream<char_type, traits_type>(&__sb_) {
+  if (__sb_.open(__s, __mode) == nullptr)
+    this->setstate(ios_base::failbit);
+}
+
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+inline basic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode)
+    : basic_iostream<char_type, traits_type>(&__sb_) {
+  if (__sb_.open(__s, __mode) == nullptr)
+    this->setstate(ios_base::failbit);
+}
+#  endif
+
+template <class _CharT, class _Traits>
+inline basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode)
+    : basic_iostream<char_type, traits_type>(&__sb_) {
+  if (__sb_.open(__s, __mode) == nullptr)
+    this->setstate(ios_base::failbit);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_fstream<_CharT, _Traits>::basic_fstream(const char* __s, ios_base::openmode __mode)
-    : basic_iostream<char_type, traits_type>(&__sb_)
-{
-    if (__sb_.open(__s, __mode) == nullptr)
-        this->setstate(ios_base::failbit);
-}
-
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-template <class _CharT, class _Traits>
-inline
-basic_fstream<_CharT, _Traits>::basic_fstream(const wchar_t* __s, ios_base::openmode __mode)
-    : basic_iostream<char_type, traits_type>(&__sb_)
-{
-    if (__sb_.open(__s, __mode) == nullptr)
-        this->setstate(ios_base::failbit);
-}
-#endif
-
-template <class _CharT, class _Traits>
-inline
-basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openmode __mode)
-    : basic_iostream<char_type, traits_type>(&__sb_)
-{
-    if (__sb_.open(__s, __mode) == nullptr)
-        this->setstate(ios_base::failbit);
+inline basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
+    : basic_iostream<char_type, traits_type>(std::move(__rhs)), __sb_(std::move(__rhs.__sb_)) {
+  this->set_rdbuf(&__sb_);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
-    : basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)),
-      __sb_(_VSTD::move(__rhs.__sb_))
-{
-    this->set_rdbuf(&__sb_);
+inline basic_fstream<_CharT, _Traits>& basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs) {
+  basic_iostream<char_type, traits_type>::operator=(std::move(__rhs));
+  __sb_ = std::move(__rhs.__sb_);
+  return *this;
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_fstream<_CharT, _Traits>&
-basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
-{
-    basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
-    __sb_ = _VSTD::move(__rhs.__sb_);
-    return *this;
+inline void basic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs) {
+  basic_iostream<char_type, traits_type>::swap(__rhs);
+  __sb_.swap(__rhs.__sb_);
 }
 
 template <class _CharT, class _Traits>
-inline
-void
-basic_fstream<_CharT, _Traits>::swap(basic_fstream& __rhs)
-{
-    basic_iostream<char_type, traits_type>::swap(__rhs);
-    __sb_.swap(__rhs.__sb_);
+inline _LIBCPP_HIDE_FROM_ABI void swap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y) {
+  __x.swap(__y);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(basic_fstream<_CharT, _Traits>& __x, basic_fstream<_CharT, _Traits>& __y)
-{
-    __x.swap(__y);
+inline basic_filebuf<_CharT, _Traits>* basic_fstream<_CharT, _Traits>::rdbuf() const {
+  return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
 }
 
 template <class _CharT, class _Traits>
-inline
-basic_filebuf<_CharT, _Traits>*
-basic_fstream<_CharT, _Traits>::rdbuf() const
-{
-    return const_cast<basic_filebuf<char_type, traits_type>*>(&__sb_);
+inline bool basic_fstream<_CharT, _Traits>::is_open() const {
+  return __sb_.is_open();
 }
 
 template <class _CharT, class _Traits>
-inline
-bool
-basic_fstream<_CharT, _Traits>::is_open() const
-{
-    return __sb_.is_open();
+void basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode) {
+  if (__sb_.open(__s, __mode))
+    this->clear();
+  else
+    this->setstate(ios_base::failbit);
+}
+
+#  ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
+template <class _CharT, class _Traits>
+void basic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode) {
+  if (__sb_.open(__s, __mode))
+    this->clear();
+  else
+    this->setstate(ios_base::failbit);
+}
+#  endif
+
+template <class _CharT, class _Traits>
+void basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode) {
+  if (__sb_.open(__s, __mode))
+    this->clear();
+  else
+    this->setstate(ios_base::failbit);
 }
 
 template <class _CharT, class _Traits>
-void
-basic_fstream<_CharT, _Traits>::open(const char* __s, ios_base::openmode __mode)
-{
-    if (__sb_.open(__s, __mode))
-        this->clear();
-    else
-        this->setstate(ios_base::failbit);
+inline void basic_fstream<_CharT, _Traits>::close() {
+  if (__sb_.close() == nullptr)
+    this->setstate(ios_base::failbit);
 }
 
-#ifdef _LIBCPP_HAS_OPEN_WITH_WCHAR
-template <class _CharT, class _Traits>
-void
-basic_fstream<_CharT, _Traits>::open(const wchar_t* __s, ios_base::openmode __mode)
-{
-    if (__sb_.open(__s, __mode))
-        this->clear();
-    else
-        this->setstate(ios_base::failbit);
-}
-#endif
-
-template <class _CharT, class _Traits>
-void
-basic_fstream<_CharT, _Traits>::open(const string& __s, ios_base::openmode __mode)
-{
-    if (__sb_.open(__s, __mode))
-        this->clear();
-    else
-        this->setstate(ios_base::failbit);
-}
-
-template <class _CharT, class _Traits>
-inline
-void
-basic_fstream<_CharT, _Traits>::close()
-{
-    if (__sb_.close() == nullptr)
-        this->setstate(ios_base::failbit);
-}
-
-#if defined(_LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1)
+#  if _LIBCPP_AVAILABILITY_HAS_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ifstream<char>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ofstream<char>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_filebuf<char>;
-#endif
+#  endif
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_HAS_NO_FSTREAM
+#endif // _LIBCPP_HAS_NO_FILESYSTEM
 
 _LIBCPP_POP_MACROS
 
@@ -1755,6 +1563,7 @@ _LIBCPP_POP_MACROS
 #  include <cstdlib>
 #  include <iosfwd>
 #  include <limits>
+#  include <mutex>
 #  include <new>
 #  include <stdexcept>
 #  include <type_traits>
diff --git a/third_party/libcxx/fstream.cpp b/third_party/libcxx/fstream.cpp
new file mode 100644
index 000000000..55a4442b9
--- /dev/null
+++ b/third_party/libcxx/fstream.cpp
@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+#include <cstdio>
+#include <fstream>
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <io.h>
+#  include <windows.h>
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCPP_WIN32API)
+
+// Confirm that `HANDLE` is `void*` as implemented in `basic_filebuf`
+static_assert(std::same_as<HANDLE, void*>);
+
+_LIBCPP_EXPORTED_FROM_ABI void* __filebuf_windows_native_handle(FILE* __file) noexcept {
+  // https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/get-osfhandle?view=msvc-170
+  intptr_t __handle = _get_osfhandle(fileno(__file));
+  if (__handle == -1)
+    return nullptr;
+  return reinterpret_cast<void*>(__handle);
+}
+
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/functional b/third_party/libcxx/functional
index 63af88750..3d39f654d 100644
--- a/third_party/libcxx/functional
+++ b/third_party/libcxx/functional
@@ -34,7 +34,7 @@ struct binary_function
 template <class T>
 class reference_wrapper
     : public unary_function<T1, R> // if wrapping a unary functor
-    : public binary_function<T1, T2, R> // if wraping a binary functor
+    : public binary_function<T1, T2, R> // if wrapping a binary functor
 {
 public:
     // types
@@ -77,6 +77,15 @@ template <class T> struct unwrap_ref_decay : unwrap_reference<decay_t<T>> { };
 template <class T> using unwrap_reference_t = typename unwrap_reference<T>::type; // since C++20
 template <class T> using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type; // since C++20
 
+// [refwrap.comparisons], comparisons
+friend constexpr bool operator==(reference_wrapper, reference_wrapper);           // Since C++26
+friend constexpr bool operator==(reference_wrapper, const T&);                    // Since C++26
+friend constexpr bool operator==(reference_wrapper, reference_wrapper<const T>);  // Since C++26
+
+friend constexpr auto operator<=>(reference_wrapper, reference_wrapper);          // Since C++26
+friend constexpr auto operator<=>(reference_wrapper, const T&);                   // Since C++26
+friend constexpr auto operator<=>(reference_wrapper, reference_wrapper<const T>); // Since C++26
+
 template <class T> // <class T=void> in C++14
 struct plus {
     T operator()(const T& x, const T& y) const;
@@ -207,6 +216,12 @@ binary_negate<Predicate> not2(const Predicate& pred);
 template <class F>
 constexpr unspecified not_fn(F&& f); // C++17, constexpr in C++20
 
+// [func.bind.partial], function templates bind_front and bind_back
+template<class F, class... Args>
+  constexpr unspecified bind_front(F&&, Args&&...); // C++20
+template<class F, class... Args>
+  constexpr unspecified bind_back(F&&, Args&&...);  // C++23
+
 template<class T> struct is_bind_expression;
 template<class T> struct is_placeholder;
 
@@ -456,13 +471,13 @@ template <class R, class ... ArgTypes>
   bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
 
 template <class R, class ... ArgTypes>
-  bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
+  bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept; // removed in C++20
 
 template <class R, class ... ArgTypes>
-  bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
+  bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept; // removed in C++20
 
 template <class  R, class ... ArgTypes>
-  bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
+  bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept; // removed in C++20
 
 // specialized algorithms:
 template <class  R, class ... ArgTypes>
@@ -512,52 +527,71 @@ POLICY:  For non-variadic implementations, the number of arguments is limited
 
 */
 
-#include <__algorithm/search.h>
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__compare/compare_three_way.h>
 #include <__config>
-#include <__debug>
+
 #include <__functional/binary_function.h>
 #include <__functional/binary_negate.h>
 #include <__functional/bind.h>
-#include <__functional/bind_back.h>
-#include <__functional/bind_front.h>
 #include <__functional/binder1st.h>
 #include <__functional/binder2nd.h>
-#include <__functional/boyer_moore_searcher.h>
-#include <__functional/compose.h>
-#include <__functional/default_searcher.h>
-#include <__functional/function.h>
 #include <__functional/hash.h>
-#include <__functional/identity.h>
-#include <__functional/invoke.h>
 #include <__functional/mem_fn.h> // TODO: deprecate
 #include <__functional/mem_fun_ref.h>
-#include <__functional/not_fn.h>
 #include <__functional/operations.h>
 #include <__functional/pointer_to_binary_function.h>
 #include <__functional/pointer_to_unary_function.h>
-#include <__functional/ranges_operations.h>
 #include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h>
 #include <__functional/unary_negate.h>
-#include <__type_traits/unwrap_ref.h>
-#include <__utility/forward.h>
-#include <memory> // TODO: find out why removing this breaks the modules build
-#include <typeinfo>
+
+#ifndef _LIBCPP_CXX03_LANG
+#  include <__functional/function.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 17
+#  include <__functional/boyer_moore_searcher.h>
+#  include <__functional/default_searcher.h>
+#  include <__functional/invoke.h>
+#  include <__functional/not_fn.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__functional/bind_back.h>
+#  include <__functional/bind_front.h>
+#  include <__functional/identity.h>
+#  include <__functional/ranges_operations.h>
+#  include <__type_traits/unwrap_ref.h>
+#endif
+
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && defined(_LIBCPP_CXX03_LANG)
+#  include <limits>
+#  include <new>
+#endif
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 14
+#  include <array>
+#  include <initializer_list>
+#  include <unordered_map>
+#  include <vector>
+#endif
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstdlib>
 #  include <exception>
+#  include <iosfwd>
+#  include <memory>
+#  include <stdexcept>
 #  include <tuple>
 #  include <type_traits>
+#  include <typeinfo>
 #  include <utility>
 #endif
 
diff --git a/third_party/libcxx/functional.cpp b/third_party/libcxx/functional.cpp
new file mode 100644
index 000000000..ef53e3e84
--- /dev/null
+++ b/third_party/libcxx/functional.cpp
@@ -0,0 +1,19 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <functional>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+bad_function_call::~bad_function_call() noexcept {}
+
+#ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
+const char* bad_function_call::what() const noexcept { return "std::bad_function_call"; }
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/future b/third_party/libcxx/future
index 1f17aae6b..0be326201 100644
--- a/third_party/libcxx/future
+++ b/third_party/libcxx/future
@@ -44,14 +44,15 @@ error_condition make_error_condition(future_errc e) noexcept;
 
 const error_category& future_category() noexcept;
 
-class future_error
-    : public logic_error
-{
+class future_error : public logic_error {
 public:
-    future_error(error_code ec);  // exposition only
-    explicit future_error(future_errc); // C++17
+    explicit future_error(future_errc e); // since C++17
+
     const error_code& code() const noexcept;
     const char*       what() const noexcept;
+
+private:
+    error_code ec_;             // exposition only
 };
 
 template <class R>
@@ -361,2106 +362,1691 @@ template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__availability>
-#include <__chrono/duration.h>
-#include <__chrono/time_point.h>
 #include <__config>
-#include <__exception/exception_ptr.h>
-#include <__memory/allocator.h>
-#include <__memory/allocator_arg_t.h>
-#include <__memory/allocator_destructor.h>
-#include <__memory/allocator_traits.h>
-#include <__memory/compressed_pair.h>
-#include <__memory/pointer_traits.h>
-#include <__memory/shared_ptr.h>
-#include <__memory/unique_ptr.h>
-#include <__memory/uses_allocator.h>
-#include <__system_error/error_category.h>
-#include <__system_error/error_code.h>
-#include <__system_error/error_condition.h>
-#include <__type_traits/aligned_storage.h>
-#include <__type_traits/alignment_of.h>
-#include <__type_traits/strip_signature.h>
-#include <__utility/auto_cast.h>
-#include <__utility/forward.h>
-#include <__utility/move.h>
-#include <mutex>
-#include <new>
-#include <stdexcept>
-#include <thread>
-#include <version>
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#if !defined(_LIBCPP_HAS_NO_THREADS)
 
-#ifdef _LIBCPP_HAS_NO_THREADS
-# error "<future> is not supported since libc++ has been configured without support for threads."
-#endif
+#  include <__assert>
+#  include <__chrono/duration.h>
+#  include <__chrono/time_point.h>
+#  include <__exception/exception_ptr.h>
+#  include <__memory/addressof.h>
+#  include <__memory/allocator.h>
+#  include <__memory/allocator_arg_t.h>
+#  include <__memory/allocator_destructor.h>
+#  include <__memory/allocator_traits.h>
+#  include <__memory/compressed_pair.h>
+#  include <__memory/pointer_traits.h>
+#  include <__memory/shared_ptr.h>
+#  include <__memory/unique_ptr.h>
+#  include <__memory/uses_allocator.h>
+#  include <__system_error/error_category.h>
+#  include <__system_error/error_code.h>
+#  include <__system_error/error_condition.h>
+#  include <__type_traits/aligned_storage.h>
+#  include <__type_traits/strip_signature.h>
+#  include <__utility/auto_cast.h>
+#  include <__utility/forward.h>
+#  include <__utility/move.h>
+#  include <mutex>
+#  include <new>
+#  include <stdexcept>
+#  include <thread>
+#  include <version>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_PUSH_MACROS
+#  include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-//enum class future_errc
-_LIBCPP_DECLARE_STRONG_ENUM(future_errc)
-{
-    future_already_retrieved = 1,
-    promise_already_satisfied,
-    no_state,
-    broken_promise
-};
+// enum class future_errc
+_LIBCPP_DECLARE_STRONG_ENUM(future_errc){
+    future_already_retrieved = 1, promise_already_satisfied, no_state, broken_promise};
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc> : public true_type {};
 
-#ifdef _LIBCPP_CXX03_LANG
+#  ifdef _LIBCPP_CXX03_LANG
 template <>
-struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type { };
-#endif
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type {};
+#  endif
 
-//enum class launch
-_LIBCPP_DECLARE_STRONG_ENUM(launch)
-{
-    async = 1,
-    deferred = 2,
-    any = async | deferred
-};
+// enum class launch
+_LIBCPP_DECLARE_STRONG_ENUM(launch){async = 1, deferred = 2, any = async | deferred};
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)
 
-#ifndef _LIBCPP_CXX03_LANG
+#  ifndef _LIBCPP_CXX03_LANG
 
 typedef underlying_type<launch>::type __launch_underlying_type;
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-launch
-operator&(launch __x, launch __y)
-{
-    return static_cast<launch>(static_cast<__launch_underlying_type>(__x) &
-                               static_cast<__launch_underlying_type>(__y));
+inline _LIBCPP_HIDE_FROM_ABI constexpr launch operator&(launch __x, launch __y) {
+  return static_cast<launch>(static_cast<__launch_underlying_type>(__x) & static_cast<__launch_underlying_type>(__y));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-launch
-operator|(launch __x, launch __y)
-{
-    return static_cast<launch>(static_cast<__launch_underlying_type>(__x) |
-                               static_cast<__launch_underlying_type>(__y));
+inline _LIBCPP_HIDE_FROM_ABI constexpr launch operator|(launch __x, launch __y) {
+  return static_cast<launch>(static_cast<__launch_underlying_type>(__x) | static_cast<__launch_underlying_type>(__y));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-launch
-operator^(launch __x, launch __y)
-{
-    return static_cast<launch>(static_cast<__launch_underlying_type>(__x) ^
-                               static_cast<__launch_underlying_type>(__y));
+inline _LIBCPP_HIDE_FROM_ABI constexpr launch operator^(launch __x, launch __y) {
+  return static_cast<launch>(static_cast<__launch_underlying_type>(__x) ^ static_cast<__launch_underlying_type>(__y));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-launch
-operator~(launch __x)
-{
-    return static_cast<launch>(~static_cast<__launch_underlying_type>(__x) & 3);
+inline _LIBCPP_HIDE_FROM_ABI constexpr launch operator~(launch __x) {
+  return static_cast<launch>(~static_cast<__launch_underlying_type>(__x) & 3);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-launch&
-operator&=(launch& __x, launch __y)
-{
-    __x = __x & __y; return __x;
+inline _LIBCPP_HIDE_FROM_ABI launch& operator&=(launch& __x, launch __y) {
+  __x = __x & __y;
+  return __x;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-launch&
-operator|=(launch& __x, launch __y)
-{
-    __x = __x | __y; return __x;
+inline _LIBCPP_HIDE_FROM_ABI launch& operator|=(launch& __x, launch __y) {
+  __x = __x | __y;
+  return __x;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-launch&
-operator^=(launch& __x, launch __y)
-{
-    __x = __x ^ __y; return __x;
+inline _LIBCPP_HIDE_FROM_ABI launch& operator^=(launch& __x, launch __y) {
+  __x = __x ^ __y;
+  return __x;
 }
 
-#endif // !_LIBCPP_CXX03_LANG
+#  endif // !_LIBCPP_CXX03_LANG
 
-//enum class future_status
-_LIBCPP_DECLARE_STRONG_ENUM(future_status)
-{
-    ready,
-    timeout,
-    deferred
-};
+// enum class future_status
+_LIBCPP_DECLARE_STRONG_ENUM(future_status){ready, timeout, deferred};
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)
 
-_LIBCPP_FUNC_VIS
-const error_category& future_category() _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI const error_category& future_category() _NOEXCEPT;
 
-inline _LIBCPP_INLINE_VISIBILITY
-error_code
-make_error_code(future_errc __e) _NOEXCEPT
-{
-    return error_code(static_cast<int>(__e), future_category());
+inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(future_errc __e) _NOEXCEPT {
+  return error_code(static_cast<int>(__e), future_category());
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-error_condition
-make_error_condition(future_errc __e) _NOEXCEPT
-{
-    return error_condition(static_cast<int>(__e), future_category());
+inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(future_errc __e) _NOEXCEPT {
+  return error_condition(static_cast<int>(__e), future_category());
 }
 
-class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_FUTURE_ERROR future_error
-    : public logic_error
-{
-    error_code __ec_;
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_future_error(future_errc __ev);
+
+class _LIBCPP_EXPORTED_FROM_ABI future_error : public logic_error {
+  error_code __ec_;
+
+  future_error(error_code);
+  friend void __throw_future_error(future_errc);
+  template <class>
+  friend class promise;
+
 public:
-    future_error(error_code __ec);
+#  if _LIBCPP_STD_VER >= 17
+  _LIBCPP_HIDE_FROM_ABI explicit future_error(future_errc __ec) : future_error(std::make_error_code(__ec)) {}
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    const error_code& code() const _NOEXCEPT {return __ec_;}
+  _LIBCPP_HIDE_FROM_ABI const error_code& code() const _NOEXCEPT { return __ec_; }
 
-    _LIBCPP_HIDE_FROM_ABI future_error(const future_error&) _NOEXCEPT = default;
-    ~future_error() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI future_error(const future_error&) _NOEXCEPT = default;
+  ~future_error() _NOEXCEPT override;
 };
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-_LIBCPP_AVAILABILITY_FUTURE_ERROR
-#endif
-void __throw_future_error(future_errc __ev)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw future_error(make_error_code(__ev));
-#else
-    (void)__ev;
-    _LIBCPP_VERBOSE_ABORT("future_error was thrown in -fno-exceptions mode");
-#endif
+// Declared above std::future_error
+void __throw_future_error(future_errc __ev) {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw future_error(make_error_code(__ev));
+#  else
+  (void)__ev;
+  _LIBCPP_VERBOSE_ABORT("future_error was thrown in -fno-exceptions mode");
+#  endif
 }
 
-class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state
-    : public __shared_count
-{
+class _LIBCPP_EXPORTED_FROM_ABI __assoc_sub_state : public __shared_count {
 protected:
-    exception_ptr __exception_;
-    mutable mutex __mut_;
-    mutable condition_variable __cv_;
-    unsigned __state_;
+  exception_ptr __exception_;
+  mutable mutex __mut_;
+  mutable condition_variable __cv_;
+  unsigned __state_;
+
+  void __on_zero_shared() _NOEXCEPT override;
+  void __sub_wait(unique_lock<mutex>& __lk);
 
-    void __on_zero_shared() _NOEXCEPT override;
-    void __sub_wait(unique_lock<mutex>& __lk);
 public:
-    enum
-    {
-        __constructed = 1,
-        __future_attached = 2,
-        ready = 4,
-        deferred = 8
-    };
+  enum { __constructed = 1, __future_attached = 2, ready = 4, deferred = 8 };
 
-    _LIBCPP_INLINE_VISIBILITY
-    __assoc_sub_state() : __state_(0) {}
+  _LIBCPP_HIDE_FROM_ABI __assoc_sub_state() : __state_(0) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool __has_value() const
-        {return (__state_ & __constructed) || (__exception_ != nullptr);}
+  _LIBCPP_HIDE_FROM_ABI bool __has_value() const { return (__state_ & __constructed) || (__exception_ != nullptr); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __attach_future() {
-        lock_guard<mutex> __lk(__mut_);
-        bool __has_future_attached = (__state_ & __future_attached) != 0;
-        if (__has_future_attached)
-            __throw_future_error(future_errc::future_already_retrieved);
-        this->__add_shared();
-        __state_ |= __future_attached;
-    }
+  _LIBCPP_HIDE_FROM_ABI void __attach_future() {
+    lock_guard<mutex> __lk(__mut_);
+    bool __has_future_attached = (__state_ & __future_attached) != 0;
+    if (__has_future_attached)
+      __throw_future_error(future_errc::future_already_retrieved);
+    this->__add_shared();
+    __state_ |= __future_attached;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __set_deferred() {__state_ |= deferred;}
+  _LIBCPP_HIDE_FROM_ABI void __set_deferred() { __state_ |= deferred; }
 
-    void __make_ready();
-    _LIBCPP_INLINE_VISIBILITY
-    bool __is_ready() const {return (__state_ & ready) != 0;}
+  void __make_ready();
+  _LIBCPP_HIDE_FROM_ABI bool __is_ready() const { return (__state_ & ready) != 0; }
 
-    void set_value();
-    void set_value_at_thread_exit();
+  void set_value();
+  void set_value_at_thread_exit();
 
-    void set_exception(exception_ptr __p);
-    void set_exception_at_thread_exit(exception_ptr __p);
+  void set_exception(exception_ptr __p);
+  void set_exception_at_thread_exit(exception_ptr __p);
 
-    void copy();
+  void copy();
 
-    void wait();
-    template <class _Rep, class _Period>
-        future_status
-        _LIBCPP_INLINE_VISIBILITY
-        wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const;
-    template <class _Clock, class _Duration>
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-        future_status
-        wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;
+  void wait();
+  template <class _Rep, class _Period>
+  future_status _LIBCPP_HIDE_FROM_ABI wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const;
+  template <class _Clock, class _Duration>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS future_status
+  wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;
 
-    virtual void __execute();
+  virtual void __execute();
 };
 
 template <class _Clock, class _Duration>
-future_status
-__assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
-{
-    unique_lock<mutex> __lk(__mut_);
-    if (__state_ & deferred)
-        return future_status::deferred;
-    while (!(__state_ & ready) && _Clock::now() < __abs_time)
-        __cv_.wait_until(__lk, __abs_time);
-    if (__state_ & ready)
-        return future_status::ready;
-    return future_status::timeout;
+future_status __assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {
+  unique_lock<mutex> __lk(__mut_);
+  if (__state_ & deferred)
+    return future_status::deferred;
+  while (!(__state_ & ready) && _Clock::now() < __abs_time)
+    __cv_.wait_until(__lk, __abs_time);
+  if (__state_ & ready)
+    return future_status::ready;
+  return future_status::timeout;
 }
 
 template <class _Rep, class _Period>
-inline
-future_status
-__assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
-{
-    return wait_until(chrono::steady_clock::now() + __rel_time);
+inline future_status __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {
+  return wait_until(chrono::steady_clock::now() + __rel_time);
 }
 
 template <class _Rp>
-class _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_HIDDEN __assoc_state
-    : public __assoc_sub_state
-{
-    typedef __assoc_sub_state base;
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+class _LIBCPP_HIDDEN __assoc_state : public __assoc_sub_state {
+  typedef __assoc_sub_state base;
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  typedef typename aligned_storage<sizeof(_Rp), _LIBCPP_ALIGNOF(_Rp)>::type _Up;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
 protected:
-    _Up __value_;
+  _Up __value_;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 public:
+  template <class _Arg>
+  _LIBCPP_HIDE_FROM_ABI void set_value(_Arg&& __arg);
 
-    template <class _Arg>
-    _LIBCPP_HIDE_FROM_ABI void set_value(_Arg&& __arg);
+  template <class _Arg>
+  _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Arg&& __arg);
 
-    template <class _Arg>
-    _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Arg&& __arg);
-
-    _LIBCPP_HIDE_FROM_ABI _Rp move();
-    _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<_Rp> copy();
+  _LIBCPP_HIDE_FROM_ABI _Rp move();
+  _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<_Rp> copy();
 };
 
 template <class _Rp>
-void
-__assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT
-{
-    if (this->__state_ & base::__constructed)
-        reinterpret_cast<_Rp*>(&__value_)->~_Rp();
-    delete this;
+void __assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT {
+  if (this->__state_ & base::__constructed)
+    reinterpret_cast<_Rp*>(&__value_)->~_Rp();
+  delete this;
 }
 
 template <class _Rp>
 template <class _Arg>
-_LIBCPP_AVAILABILITY_FUTURE
-void
-__assoc_state<_Rp>::set_value(_Arg&& __arg)
-{
-    unique_lock<mutex> __lk(this->__mut_);
-    if (this->__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-    ::new ((void*)&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
-    this->__state_ |= base::__constructed | base::ready;
-    __cv_.notify_all();
+void __assoc_state<_Rp>::set_value(_Arg&& __arg) {
+  unique_lock<mutex> __lk(this->__mut_);
+  if (this->__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+  ::new ((void*)&__value_) _Rp(std::forward<_Arg>(__arg));
+  this->__state_ |= base::__constructed | base::ready;
+  __cv_.notify_all();
 }
 
 template <class _Rp>
 template <class _Arg>
-void
-__assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg)
-{
-    unique_lock<mutex> __lk(this->__mut_);
-    if (this->__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-    ::new ((void*)&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
-    this->__state_ |= base::__constructed;
-    __thread_local_data()->__make_ready_at_thread_exit(this);
+void __assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg) {
+  unique_lock<mutex> __lk(this->__mut_);
+  if (this->__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+  ::new ((void*)&__value_) _Rp(std::forward<_Arg>(__arg));
+  this->__state_ |= base::__constructed;
+  __thread_local_data()->__make_ready_at_thread_exit(this);
 }
 
 template <class _Rp>
-_Rp
-__assoc_state<_Rp>::move()
-{
-    unique_lock<mutex> __lk(this->__mut_);
-    this->__sub_wait(__lk);
-    if (this->__exception_ != nullptr)
-        std::rethrow_exception(this->__exception_);
-    return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_));
+_Rp __assoc_state<_Rp>::move() {
+  unique_lock<mutex> __lk(this->__mut_);
+  this->__sub_wait(__lk);
+  if (this->__exception_ != nullptr)
+    std::rethrow_exception(this->__exception_);
+  return std::move(*reinterpret_cast<_Rp*>(&__value_));
 }
 
 template <class _Rp>
-__add_lvalue_reference_t<_Rp>
-__assoc_state<_Rp>::copy()
-{
-    unique_lock<mutex> __lk(this->__mut_);
-    this->__sub_wait(__lk);
-    if (this->__exception_ != nullptr)
-        std::rethrow_exception(this->__exception_);
-    return *reinterpret_cast<_Rp*>(&__value_);
+__add_lvalue_reference_t<_Rp> __assoc_state<_Rp>::copy() {
+  unique_lock<mutex> __lk(this->__mut_);
+  this->__sub_wait(__lk);
+  if (this->__exception_ != nullptr)
+    std::rethrow_exception(this->__exception_);
+  return *reinterpret_cast<_Rp*>(&__value_);
 }
 
 template <class _Rp>
-class _LIBCPP_AVAILABILITY_FUTURE __assoc_state<_Rp&>
-    : public __assoc_sub_state
-{
-    typedef __assoc_sub_state base;
-    typedef _Rp* _Up;
+class __assoc_state<_Rp&> : public __assoc_sub_state {
+  typedef __assoc_sub_state base;
+  typedef _Rp* _Up;
+
 protected:
-    _Up __value_;
+  _Up __value_;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 public:
+  _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __arg);
+  _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp& __arg);
 
-    _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __arg);
-    _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp& __arg);
-
-    _LIBCPP_HIDE_FROM_ABI _Rp& copy();
+  _LIBCPP_HIDE_FROM_ABI _Rp& copy();
 };
 
 template <class _Rp>
-void
-__assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT
-{
-    delete this;
+void __assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT {
+  delete this;
 }
 
 template <class _Rp>
-void
-__assoc_state<_Rp&>::set_value(_Rp& __arg)
-{
-    unique_lock<mutex> __lk(this->__mut_);
-    if (this->__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-    __value_ = _VSTD::addressof(__arg);
-    this->__state_ |= base::__constructed | base::ready;
-    __cv_.notify_all();
+void __assoc_state<_Rp&>::set_value(_Rp& __arg) {
+  unique_lock<mutex> __lk(this->__mut_);
+  if (this->__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+  __value_ = std::addressof(__arg);
+  this->__state_ |= base::__constructed | base::ready;
+  __cv_.notify_all();
 }
 
 template <class _Rp>
-void
-__assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg)
-{
-    unique_lock<mutex> __lk(this->__mut_);
-    if (this->__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-    __value_ = _VSTD::addressof(__arg);
-    this->__state_ |= base::__constructed;
-    __thread_local_data()->__make_ready_at_thread_exit(this);
+void __assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg) {
+  unique_lock<mutex> __lk(this->__mut_);
+  if (this->__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+  __value_ = std::addressof(__arg);
+  this->__state_ |= base::__constructed;
+  __thread_local_data()->__make_ready_at_thread_exit(this);
 }
 
 template <class _Rp>
-_Rp&
-__assoc_state<_Rp&>::copy()
-{
-    unique_lock<mutex> __lk(this->__mut_);
-    this->__sub_wait(__lk);
-    if (this->__exception_ != nullptr)
-        std::rethrow_exception(this->__exception_);
-    return *__value_;
+_Rp& __assoc_state<_Rp&>::copy() {
+  unique_lock<mutex> __lk(this->__mut_);
+  this->__sub_wait(__lk);
+  if (this->__exception_ != nullptr)
+    std::rethrow_exception(this->__exception_);
+  return *__value_;
 }
 
 template <class _Rp, class _Alloc>
-class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc
-    : public __assoc_state<_Rp>
-{
-    typedef __assoc_state<_Rp> base;
-    _Alloc __alloc_;
+class __assoc_state_alloc : public __assoc_state<_Rp> {
+  typedef __assoc_state<_Rp> base;
+  _Alloc __alloc_;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __assoc_state_alloc(const _Alloc& __a)
-        : __alloc_(__a) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __assoc_state_alloc(const _Alloc& __a) : __alloc_(__a) {}
 };
 
 template <class _Rp, class _Alloc>
-void
-__assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT
-{
-    if (this->__state_ & base::__constructed)
-        reinterpret_cast<_Rp*>(_VSTD::addressof(this->__value_))->~_Rp();
-    typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
-    typedef allocator_traits<_Al> _ATraits;
-    typedef pointer_traits<typename _ATraits::pointer> _PTraits;
-    _Al __a(__alloc_);
-    this->~__assoc_state_alloc();
-    __a.deallocate(_PTraits::pointer_to(*this), 1);
+void __assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT {
+  if (this->__state_ & base::__constructed)
+    reinterpret_cast<_Rp*>(std::addressof(this->__value_))->~_Rp();
+  typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
+  typedef allocator_traits<_Al> _ATraits;
+  typedef pointer_traits<typename _ATraits::pointer> _PTraits;
+  _Al __a(__alloc_);
+  this->~__assoc_state_alloc();
+  __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template <class _Rp, class _Alloc>
-class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc<_Rp&, _Alloc>
-    : public __assoc_state<_Rp&>
-{
-    typedef __assoc_state<_Rp&> base;
-    _Alloc __alloc_;
+class __assoc_state_alloc<_Rp&, _Alloc> : public __assoc_state<_Rp&> {
+  typedef __assoc_state<_Rp&> base;
+  _Alloc __alloc_;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __assoc_state_alloc(const _Alloc& __a)
-        : __alloc_(__a) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __assoc_state_alloc(const _Alloc& __a) : __alloc_(__a) {}
 };
 
 template <class _Rp, class _Alloc>
-void
-__assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT
-{
-    typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
-    typedef allocator_traits<_Al> _ATraits;
-    typedef pointer_traits<typename _ATraits::pointer> _PTraits;
-    _Al __a(__alloc_);
-    this->~__assoc_state_alloc();
-    __a.deallocate(_PTraits::pointer_to(*this), 1);
+void __assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT {
+  typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
+  typedef allocator_traits<_Al> _ATraits;
+  typedef pointer_traits<typename _ATraits::pointer> _PTraits;
+  _Al __a(__alloc_);
+  this->~__assoc_state_alloc();
+  __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template <class _Alloc>
-class _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state_alloc
-    : public __assoc_sub_state
-{
-    typedef __assoc_sub_state base;
-    _Alloc __alloc_;
+class __assoc_sub_state_alloc : public __assoc_sub_state {
+  typedef __assoc_sub_state base;
+  _Alloc __alloc_;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __assoc_sub_state_alloc(const _Alloc& __a)
-        : __alloc_(__a) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __assoc_sub_state_alloc(const _Alloc& __a) : __alloc_(__a) {}
 };
 
 template <class _Alloc>
-void
-__assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT
-{
-    typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _Al;
-    typedef allocator_traits<_Al> _ATraits;
-    typedef pointer_traits<typename _ATraits::pointer> _PTraits;
-    _Al __a(__alloc_);
-    this->~__assoc_sub_state_alloc();
-    __a.deallocate(_PTraits::pointer_to(*this), 1);
+void __assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT {
+  typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _Al;
+  typedef allocator_traits<_Al> _ATraits;
+  typedef pointer_traits<typename _ATraits::pointer> _PTraits;
+  _Al __a(__alloc_);
+  this->~__assoc_sub_state_alloc();
+  __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template <class _Rp, class _Fp>
-class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state
-    : public __assoc_state<_Rp>
-{
-    typedef __assoc_state<_Rp> base;
+class __deferred_assoc_state : public __assoc_state<_Rp> {
+  typedef __assoc_state<_Rp> base;
 
-    _Fp __func_;
+  _Fp __func_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __deferred_assoc_state(_Fp&& __f);
+  _LIBCPP_HIDE_FROM_ABI explicit __deferred_assoc_state(_Fp&& __f);
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __execute();
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __execute();
 };
 
 template <class _Rp, class _Fp>
-inline
-__deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f)
-    : __func_(_VSTD::forward<_Fp>(__f))
-{
-    this->__set_deferred();
+inline __deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) {
+  this->__set_deferred();
 }
 
 template <class _Rp, class _Fp>
-void
-__deferred_assoc_state<_Rp, _Fp>::__execute()
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        this->set_value(__func_());
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->set_exception(current_exception());
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+void __deferred_assoc_state<_Rp, _Fp>::__execute() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    this->set_value(__func_());
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->set_exception(current_exception());
+  }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
 template <class _Fp>
-class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state<void, _Fp>
-    : public __assoc_sub_state
-{
-    typedef __assoc_sub_state base;
+class __deferred_assoc_state<void, _Fp> : public __assoc_sub_state {
+  typedef __assoc_sub_state base;
 
-    _Fp __func_;
+  _Fp __func_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __deferred_assoc_state(_Fp&& __f);
+  _LIBCPP_HIDE_FROM_ABI explicit __deferred_assoc_state(_Fp&& __f);
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __execute() override;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __execute() override;
 };
 
 template <class _Fp>
-inline
-__deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f)
-    : __func_(_VSTD::forward<_Fp>(__f))
-{
-    this->__set_deferred();
+inline __deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) {
+  this->__set_deferred();
 }
 
 template <class _Fp>
-void
-__deferred_assoc_state<void, _Fp>::__execute()
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __func_();
-        this->set_value();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->set_exception(current_exception());
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+void __deferred_assoc_state<void, _Fp>::__execute() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __func_();
+    this->set_value();
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->set_exception(current_exception());
+  }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
 template <class _Rp, class _Fp>
-class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state
-    : public __assoc_state<_Rp>
-{
-    typedef __assoc_state<_Rp> base;
+class __async_assoc_state : public __assoc_state<_Rp> {
+  typedef __assoc_state<_Rp> base;
 
-    _Fp __func_;
+  _Fp __func_;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __async_assoc_state(_Fp&& __f);
+  _LIBCPP_HIDE_FROM_ABI explicit __async_assoc_state(_Fp&& __f);
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __execute();
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __execute();
 };
 
 template <class _Rp, class _Fp>
-inline
-__async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f)
-    : __func_(_VSTD::forward<_Fp>(__f))
-{
+inline __async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) {}
+
+template <class _Rp, class _Fp>
+void __async_assoc_state<_Rp, _Fp>::__execute() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    this->set_value(__func_());
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->set_exception(current_exception());
+  }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
 template <class _Rp, class _Fp>
-void
-__async_assoc_state<_Rp, _Fp>::__execute()
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        this->set_value(__func_());
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->set_exception(current_exception());
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-}
-
-template <class _Rp, class _Fp>
-void
-__async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT
-{
-    this->wait();
-    base::__on_zero_shared();
+void __async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT {
+  this->wait();
+  base::__on_zero_shared();
 }
 
 template <class _Fp>
-class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state<void, _Fp>
-    : public __assoc_sub_state
-{
-    typedef __assoc_sub_state base;
+class __async_assoc_state<void, _Fp> : public __assoc_sub_state {
+  typedef __assoc_sub_state base;
 
-    _Fp __func_;
+  _Fp __func_;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __async_assoc_state(_Fp&& __f);
+  _LIBCPP_HIDE_FROM_ABI explicit __async_assoc_state(_Fp&& __f);
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __execute() override;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __execute() override;
 };
 
 template <class _Fp>
-inline
-__async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f)
-    : __func_(_VSTD::forward<_Fp>(__f))
-{
+inline __async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) {}
+
+template <class _Fp>
+void __async_assoc_state<void, _Fp>::__execute() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __func_();
+    this->set_value();
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    this->set_exception(current_exception());
+  }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
 template <class _Fp>
-void
-__async_assoc_state<void, _Fp>::__execute()
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __func_();
-        this->set_value();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->set_exception(current_exception());
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+void __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT {
+  this->wait();
+  base::__on_zero_shared();
 }
 
-template <class _Fp>
-void
-__async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT
-{
-    this->wait();
-    base::__on_zero_shared();
-}
-
-template <class _Rp> class _LIBCPP_TEMPLATE_VIS promise;
-template <class _Rp> class _LIBCPP_TEMPLATE_VIS shared_future;
+template <class _Rp>
+class _LIBCPP_TEMPLATE_VIS promise;
+template <class _Rp>
+class _LIBCPP_TEMPLATE_VIS shared_future;
 
 // future
 
-template <class _Rp> class _LIBCPP_TEMPLATE_VIS future;
+template <class _Rp>
+class _LIBCPP_TEMPLATE_VIS future;
 
 template <class _Rp, class _Fp>
-_LIBCPP_INLINE_VISIBILITY future<_Rp>
-__make_deferred_assoc_state(_Fp&& __f);
+_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_deferred_assoc_state(_Fp&& __f);
 
 template <class _Rp, class _Fp>
-_LIBCPP_INLINE_VISIBILITY future<_Rp>
-__make_async_assoc_state(_Fp&& __f);
+_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_async_assoc_state(_Fp&& __f);
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future
-{
-    __assoc_state<_Rp>* __state_;
+class _LIBCPP_TEMPLATE_VIS future {
+  __assoc_state<_Rp>* __state_;
 
-    explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp>* __state);
+  explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp>* __state);
 
-    template <class> friend class promise;
-    template <class> friend class shared_future;
+  template <class>
+  friend class promise;
+  template <class>
+  friend class shared_future;
 
-    template <class _R1, class _Fp>
-        friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
-    template <class _R1, class _Fp>
-        friend future<_R1> __make_async_assoc_state(_Fp&& __f);
+  template <class _R1, class _Fp>
+  friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
+  template <class _R1, class _Fp>
+  friend future<_R1> __make_async_assoc_state(_Fp&& __f);
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    future() _NOEXCEPT : __state_(nullptr) {}
-    _LIBCPP_INLINE_VISIBILITY
-    future(future&& __rhs) _NOEXCEPT
-        : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
-    future(const future&) = delete;
-    future& operator=(const future&) = delete;
-    _LIBCPP_INLINE_VISIBILITY
-    future& operator=(future&& __rhs) _NOEXCEPT
-        {
-            future(_VSTD::move(__rhs)).swap(*this);
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI future() _NOEXCEPT : __state_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }
+  future(const future&)            = delete;
+  future& operator=(const future&) = delete;
+  _LIBCPP_HIDE_FROM_ABI future& operator=(future&& __rhs) _NOEXCEPT {
+    future(std::move(__rhs)).swap(*this);
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI ~future();
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future<_Rp> share() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI ~future();
+  _LIBCPP_HIDE_FROM_ABI shared_future<_Rp> share() _NOEXCEPT;
 
-    // retrieving the value
-    _LIBCPP_HIDE_FROM_ABI _Rp get();
+  // retrieving the value
+  _LIBCPP_HIDE_FROM_ABI _Rp get();
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
 
-    // functions to check state
-    _LIBCPP_INLINE_VISIBILITY
-    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
+  // functions to check state
+  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void wait() const {__state_->wait();}
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
-            {return __state_->wait_for(__rel_time);}
-    template <class _Clock, class _Duration>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
-            {return __state_->wait_until(__abs_time);}
+  _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {
+    return __state_->wait_for(__rel_time);
+  }
+  template <class _Clock, class _Duration>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {
+    return __state_->wait_until(__abs_time);
+  }
 };
 
 template <class _Rp>
-future<_Rp>::future(__assoc_state<_Rp>* __state)
-    : __state_(__state)
-{
-    __state_->__attach_future();
+future<_Rp>::future(__assoc_state<_Rp>* __state) : __state_(__state) {
+  __state_->__attach_future();
 }
 
-struct __release_shared_count
-{
-    _LIBCPP_HIDE_FROM_ABI void operator()(__shared_count* __p) {__p->__release_shared();}
+struct __release_shared_count {
+  _LIBCPP_HIDE_FROM_ABI void operator()(__shared_count* __p) { __p->__release_shared(); }
 };
 
 template <class _Rp>
-future<_Rp>::~future()
-{
-    if (__state_)
-        __state_->__release_shared();
+future<_Rp>::~future() {
+  if (__state_)
+    __state_->__release_shared();
 }
 
 template <class _Rp>
-_Rp
-future<_Rp>::get()
-{
-    unique_ptr<__shared_count, __release_shared_count> __guard(__state_);
-    __assoc_state<_Rp>* __s = __state_;
-    __state_ = nullptr;
-    return __s->move();
+_Rp future<_Rp>::get() {
+  unique_ptr<__shared_count, __release_shared_count> __guard(__state_);
+  __assoc_state<_Rp>* __s = __state_;
+  __state_                = nullptr;
+  return __s->move();
 }
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future<_Rp&>
-{
-    __assoc_state<_Rp&>* __state_;
+class _LIBCPP_TEMPLATE_VIS future<_Rp&> {
+  __assoc_state<_Rp&>* __state_;
 
-    explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp&>* __state);
+  explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp&>* __state);
 
-    template <class> friend class promise;
-    template <class> friend class shared_future;
+  template <class>
+  friend class promise;
+  template <class>
+  friend class shared_future;
 
-    template <class _R1, class _Fp>
-        friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
-    template <class _R1, class _Fp>
-        friend future<_R1> __make_async_assoc_state(_Fp&& __f);
+  template <class _R1, class _Fp>
+  friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
+  template <class _R1, class _Fp>
+  friend future<_R1> __make_async_assoc_state(_Fp&& __f);
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    future() _NOEXCEPT : __state_(nullptr) {}
-    _LIBCPP_INLINE_VISIBILITY
-    future(future&& __rhs) _NOEXCEPT
-        : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
-    future(const future&) = delete;
-    future& operator=(const future&) = delete;
-    _LIBCPP_INLINE_VISIBILITY
-    future& operator=(future&& __rhs) _NOEXCEPT
-        {
-            future(_VSTD::move(__rhs)).swap(*this);
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI future() _NOEXCEPT : __state_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }
+  future(const future&)            = delete;
+  future& operator=(const future&) = delete;
+  _LIBCPP_HIDE_FROM_ABI future& operator=(future&& __rhs) _NOEXCEPT {
+    future(std::move(__rhs)).swap(*this);
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI ~future();
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future<_Rp&> share() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI ~future();
+  _LIBCPP_HIDE_FROM_ABI shared_future<_Rp&> share() _NOEXCEPT;
 
-    // retrieving the value
-    _LIBCPP_HIDE_FROM_ABI _Rp& get();
+  // retrieving the value
+  _LIBCPP_HIDE_FROM_ABI _Rp& get();
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
 
-    // functions to check state
-    _LIBCPP_INLINE_VISIBILITY
-    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
+  // functions to check state
+  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void wait() const {__state_->wait();}
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
-            {return __state_->wait_for(__rel_time);}
-    template <class _Clock, class _Duration>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
-            {return __state_->wait_until(__abs_time);}
+  _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {
+    return __state_->wait_for(__rel_time);
+  }
+  template <class _Clock, class _Duration>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {
+    return __state_->wait_until(__abs_time);
+  }
 };
 
 template <class _Rp>
-future<_Rp&>::future(__assoc_state<_Rp&>* __state)
-    : __state_(__state)
-{
-    __state_->__attach_future();
+future<_Rp&>::future(__assoc_state<_Rp&>* __state) : __state_(__state) {
+  __state_->__attach_future();
 }
 
 template <class _Rp>
-future<_Rp&>::~future()
-{
-    if (__state_)
-        __state_->__release_shared();
+future<_Rp&>::~future() {
+  if (__state_)
+    __state_->__release_shared();
 }
 
 template <class _Rp>
-_Rp&
-future<_Rp&>::get()
-{
-    unique_ptr<__shared_count, __release_shared_count> __guard(__state_);
-    __assoc_state<_Rp&>* __s = __state_;
-    __state_ = nullptr;
-    return __s->copy();
+_Rp& future<_Rp&>::get() {
+  unique_ptr<__shared_count, __release_shared_count> __guard(__state_);
+  __assoc_state<_Rp&>* __s = __state_;
+  __state_                 = nullptr;
+  return __s->copy();
 }
 
 template <>
-class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE future<void>
-{
-    __assoc_sub_state* __state_;
+class _LIBCPP_EXPORTED_FROM_ABI future<void> {
+  __assoc_sub_state* __state_;
 
-    explicit future(__assoc_sub_state* __state);
+  explicit future(__assoc_sub_state* __state);
 
-    template <class> friend class promise;
-    template <class> friend class shared_future;
+  template <class>
+  friend class promise;
+  template <class>
+  friend class shared_future;
 
-    template <class _R1, class _Fp>
-        friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
-    template <class _R1, class _Fp>
-        friend future<_R1> __make_async_assoc_state(_Fp&& __f);
+  template <class _R1, class _Fp>
+  friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
+  template <class _R1, class _Fp>
+  friend future<_R1> __make_async_assoc_state(_Fp&& __f);
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    future() _NOEXCEPT : __state_(nullptr) {}
-    _LIBCPP_INLINE_VISIBILITY
-    future(future&& __rhs) _NOEXCEPT
-        : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
-    future(const future&) = delete;
-    future& operator=(const future&) = delete;
-    _LIBCPP_INLINE_VISIBILITY
-    future& operator=(future&& __rhs) _NOEXCEPT
-        {
-            future(_VSTD::move(__rhs)).swap(*this);
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI future() _NOEXCEPT : __state_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }
+  future(const future&)            = delete;
+  future& operator=(const future&) = delete;
+  _LIBCPP_HIDE_FROM_ABI future& operator=(future&& __rhs) _NOEXCEPT {
+    future(std::move(__rhs)).swap(*this);
+    return *this;
+  }
 
-    ~future();
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future<void> share() _NOEXCEPT;
+  ~future();
+  _LIBCPP_HIDE_FROM_ABI shared_future<void> share() _NOEXCEPT;
 
-    // retrieving the value
-    void get();
+  // retrieving the value
+  void get();
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
 
-    // functions to check state
-    _LIBCPP_INLINE_VISIBILITY
-    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
+  // functions to check state
+  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void wait() const {__state_->wait();}
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
-            {return __state_->wait_for(__rel_time);}
-    template <class _Clock, class _Duration>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
-            {return __state_->wait_until(__abs_time);}
+  _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {
+    return __state_->wait_for(__rel_time);
+  }
+  template <class _Clock, class _Duration>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {
+    return __state_->wait_until(__abs_time);
+  }
 };
 
 template <class _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT {
+  __x.swap(__y);
 }
 
 // promise<R>
 
-template <class _Callable> class packaged_task;
+template <class _Callable>
+class packaged_task;
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise
-{
-    __assoc_state<_Rp>* __state_;
+class _LIBCPP_TEMPLATE_VIS promise {
+  __assoc_state<_Rp>* __state_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
+
+  template <class>
+  friend class packaged_task;
 
-    template <class> friend class packaged_task;
 public:
-    _LIBCPP_HIDE_FROM_ABI promise();
-    template <class _Alloc>
-    _LIBCPP_HIDE_FROM_ABI promise(allocator_arg_t, const _Alloc& __a);
-    _LIBCPP_INLINE_VISIBILITY
-    promise(promise&& __rhs) _NOEXCEPT
-        : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
-    promise(const promise& __rhs) = delete;
-    _LIBCPP_HIDE_FROM_ABI ~promise();
+  _LIBCPP_HIDE_FROM_ABI promise();
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI promise(allocator_arg_t, const _Alloc& __a);
+  _LIBCPP_HIDE_FROM_ABI promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }
+  promise(const promise& __rhs) = delete;
+  _LIBCPP_HIDE_FROM_ABI ~promise();
 
-    // assignment
-    _LIBCPP_INLINE_VISIBILITY
-    promise& operator=(promise&& __rhs) _NOEXCEPT
-        {
-            promise(_VSTD::move(__rhs)).swap(*this);
-            return *this;
-        }
-    promise& operator=(const promise& __rhs) = delete;
+  // assignment
+  _LIBCPP_HIDE_FROM_ABI promise& operator=(promise&& __rhs) _NOEXCEPT {
+    promise(std::move(__rhs)).swap(*this);
+    return *this;
+  }
+  promise& operator=(const promise& __rhs) = delete;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
 
-    // retrieving the result
-    _LIBCPP_HIDE_FROM_ABI future<_Rp> get_future();
+  // retrieving the result
+  _LIBCPP_HIDE_FROM_ABI future<_Rp> get_future();
 
-    // setting the result
-    _LIBCPP_HIDE_FROM_ABI void set_value(const _Rp& __r);
-    _LIBCPP_HIDE_FROM_ABI void set_value(_Rp&& __r);
-    _LIBCPP_HIDE_FROM_ABI void set_exception(exception_ptr __p);
+  // setting the result
+  _LIBCPP_HIDE_FROM_ABI void set_value(const _Rp& __r);
+  _LIBCPP_HIDE_FROM_ABI void set_value(_Rp&& __r);
+  _LIBCPP_HIDE_FROM_ABI void set_exception(exception_ptr __p);
 
-    // setting the result with deferred notification
-    _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(const _Rp& __r);
-    _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp&& __r);
-    _LIBCPP_HIDE_FROM_ABI void set_exception_at_thread_exit(exception_ptr __p);
+  // setting the result with deferred notification
+  _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(const _Rp& __r);
+  _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp&& __r);
+  _LIBCPP_HIDE_FROM_ABI void set_exception_at_thread_exit(exception_ptr __p);
 };
 
 template <class _Rp>
-promise<_Rp>::promise()
-    : __state_(new __assoc_state<_Rp>)
-{
-}
+promise<_Rp>::promise() : __state_(new __assoc_state<_Rp>) {}
 
 template <class _Rp>
 template <class _Alloc>
-promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0)
-{
-    typedef __assoc_state_alloc<_Rp, _Alloc> _State;
-    typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
-    typedef __allocator_destructor<_A2> _D2;
-    _A2 __a(__a0);
-    unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
-    ::new ((void*)_VSTD::addressof(*__hold.get())) _State(__a0);
-    __state_ = _VSTD::addressof(*__hold.release());
+promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0) {
+  typedef __assoc_state_alloc<_Rp, _Alloc> _State;
+  typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
+  typedef __allocator_destructor<_A2> _D2;
+  _A2 __a(__a0);
+  unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
+  ::new ((void*)std::addressof(*__hold.get())) _State(__a0);
+  __state_ = std::addressof(*__hold.release());
 }
 
 template <class _Rp>
-promise<_Rp>::~promise()
-{
-    if (__state_)
-    {
-        if (!__state_->__has_value() && __state_->use_count() > 1)
-            __state_->set_exception(make_exception_ptr(
-                      future_error(make_error_code(future_errc::broken_promise))
-                                                      ));
-        __state_->__release_shared();
-    }
+promise<_Rp>::~promise() {
+  if (__state_) {
+    if (!__state_->__has_value() && __state_->use_count() > 1)
+      __state_->set_exception(make_exception_ptr(future_error(make_error_code(future_errc::broken_promise))));
+    __state_->__release_shared();
+  }
 }
 
 template <class _Rp>
-future<_Rp>
-promise<_Rp>::get_future()
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    return future<_Rp>(__state_);
+future<_Rp> promise<_Rp>::get_future() {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  return future<_Rp>(__state_);
 }
 
 template <class _Rp>
-void
-promise<_Rp>::set_value(const _Rp& __r)
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_value(__r);
+void promise<_Rp>::set_value(const _Rp& __r) {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_value(__r);
 }
 
 template <class _Rp>
-void
-promise<_Rp>::set_value(_Rp&& __r)
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_value(_VSTD::move(__r));
+void promise<_Rp>::set_value(_Rp&& __r) {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_value(std::move(__r));
 }
 
 template <class _Rp>
-void
-promise<_Rp>::set_exception(exception_ptr __p)
-{
-    _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" );
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_exception(__p);
+void promise<_Rp>::set_exception(exception_ptr __p) {
+  _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception: received nullptr");
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_exception(__p);
 }
 
 template <class _Rp>
-void
-promise<_Rp>::set_value_at_thread_exit(const _Rp& __r)
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_value_at_thread_exit(__r);
+void promise<_Rp>::set_value_at_thread_exit(const _Rp& __r) {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_value_at_thread_exit(__r);
 }
 
 template <class _Rp>
-void
-promise<_Rp>::set_value_at_thread_exit(_Rp&& __r)
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_value_at_thread_exit(_VSTD::move(__r));
+void promise<_Rp>::set_value_at_thread_exit(_Rp&& __r) {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_value_at_thread_exit(std::move(__r));
 }
 
 template <class _Rp>
-void
-promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p)
-{
-    _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_exception_at_thread_exit(__p);
+void promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p) {
+  _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception_at_thread_exit: received nullptr");
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_exception_at_thread_exit(__p);
 }
 
 // promise<R&>
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<_Rp&>
-{
-    __assoc_state<_Rp&>* __state_;
+class _LIBCPP_TEMPLATE_VIS promise<_Rp&> {
+  __assoc_state<_Rp&>* __state_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
-    template <class> friend class packaged_task;
+  template <class>
+  friend class packaged_task;
 
 public:
-    _LIBCPP_HIDE_FROM_ABI promise();
-    template <class _Allocator>
-    _LIBCPP_HIDE_FROM_ABI promise(allocator_arg_t, const _Allocator& __a);
-    _LIBCPP_INLINE_VISIBILITY
-    promise(promise&& __rhs) _NOEXCEPT
-        : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
-    promise(const promise& __rhs) = delete;
-    _LIBCPP_HIDE_FROM_ABI ~promise();
+  _LIBCPP_HIDE_FROM_ABI promise();
+  template <class _Allocator>
+  _LIBCPP_HIDE_FROM_ABI promise(allocator_arg_t, const _Allocator& __a);
+  _LIBCPP_HIDE_FROM_ABI promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }
+  promise(const promise& __rhs) = delete;
+  _LIBCPP_HIDE_FROM_ABI ~promise();
 
-    // assignment
-    _LIBCPP_INLINE_VISIBILITY
-    promise& operator=(promise&& __rhs) _NOEXCEPT
-        {
-            promise(_VSTD::move(__rhs)).swap(*this);
-            return *this;
-        }
-    promise& operator=(const promise& __rhs) = delete;
+  // assignment
+  _LIBCPP_HIDE_FROM_ABI promise& operator=(promise&& __rhs) _NOEXCEPT {
+    promise(std::move(__rhs)).swap(*this);
+    return *this;
+  }
+  promise& operator=(const promise& __rhs) = delete;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
 
-    // retrieving the result
-    _LIBCPP_HIDE_FROM_ABI future<_Rp&> get_future();
+  // retrieving the result
+  _LIBCPP_HIDE_FROM_ABI future<_Rp&> get_future();
 
-    // setting the result
-    _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __r);
-    _LIBCPP_HIDE_FROM_ABI void set_exception(exception_ptr __p);
+  // setting the result
+  _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __r);
+  _LIBCPP_HIDE_FROM_ABI void set_exception(exception_ptr __p);
 
-    // setting the result with deferred notification
-    _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp&);
-    _LIBCPP_HIDE_FROM_ABI void set_exception_at_thread_exit(exception_ptr __p);
+  // setting the result with deferred notification
+  _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp&);
+  _LIBCPP_HIDE_FROM_ABI void set_exception_at_thread_exit(exception_ptr __p);
 };
 
 template <class _Rp>
-promise<_Rp&>::promise()
-    : __state_(new __assoc_state<_Rp&>)
-{
-}
+promise<_Rp&>::promise() : __state_(new __assoc_state<_Rp&>) {}
 
 template <class _Rp>
 template <class _Alloc>
-promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0)
-{
-    typedef __assoc_state_alloc<_Rp&, _Alloc> _State;
-    typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
-    typedef __allocator_destructor<_A2> _D2;
-    _A2 __a(__a0);
-    unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
-    ::new ((void*)_VSTD::addressof(*__hold.get())) _State(__a0);
-    __state_ = _VSTD::addressof(*__hold.release());
+promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0) {
+  typedef __assoc_state_alloc<_Rp&, _Alloc> _State;
+  typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
+  typedef __allocator_destructor<_A2> _D2;
+  _A2 __a(__a0);
+  unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
+  ::new ((void*)std::addressof(*__hold.get())) _State(__a0);
+  __state_ = std::addressof(*__hold.release());
 }
 
 template <class _Rp>
-promise<_Rp&>::~promise()
-{
-    if (__state_)
-    {
-        if (!__state_->__has_value() && __state_->use_count() > 1)
-            __state_->set_exception(make_exception_ptr(
-                      future_error(make_error_code(future_errc::broken_promise))
-                                                      ));
-        __state_->__release_shared();
-    }
+promise<_Rp&>::~promise() {
+  if (__state_) {
+    if (!__state_->__has_value() && __state_->use_count() > 1)
+      __state_->set_exception(make_exception_ptr(future_error(make_error_code(future_errc::broken_promise))));
+    __state_->__release_shared();
+  }
 }
 
 template <class _Rp>
-future<_Rp&>
-promise<_Rp&>::get_future()
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    return future<_Rp&>(__state_);
+future<_Rp&> promise<_Rp&>::get_future() {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  return future<_Rp&>(__state_);
 }
 
 template <class _Rp>
-void
-promise<_Rp&>::set_value(_Rp& __r)
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_value(__r);
+void promise<_Rp&>::set_value(_Rp& __r) {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_value(__r);
 }
 
 template <class _Rp>
-void
-promise<_Rp&>::set_exception(exception_ptr __p)
-{
-    _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" );
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_exception(__p);
+void promise<_Rp&>::set_exception(exception_ptr __p) {
+  _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception: received nullptr");
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_exception(__p);
 }
 
 template <class _Rp>
-void
-promise<_Rp&>::set_value_at_thread_exit(_Rp& __r)
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_value_at_thread_exit(__r);
+void promise<_Rp&>::set_value_at_thread_exit(_Rp& __r) {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_value_at_thread_exit(__r);
 }
 
 template <class _Rp>
-void
-promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p)
-{
-    _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_exception_at_thread_exit(__p);
+void promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p) {
+  _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception_at_thread_exit: received nullptr");
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_exception_at_thread_exit(__p);
 }
 
 // promise<void>
 
 template <>
-class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<void>
-{
-    __assoc_sub_state* __state_;
+class _LIBCPP_EXPORTED_FROM_ABI promise<void> {
+  __assoc_sub_state* __state_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
 
-    template <class> friend class packaged_task;
+  template <class>
+  friend class packaged_task;
 
 public:
-    promise();
-    template <class _Allocator>
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-        promise(allocator_arg_t, const _Allocator& __a);
-    _LIBCPP_INLINE_VISIBILITY
-    promise(promise&& __rhs) _NOEXCEPT
-        : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
-    promise(const promise& __rhs) = delete;
-    ~promise();
+  promise();
+  template <class _Allocator>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS promise(allocator_arg_t, const _Allocator& __a);
+  _LIBCPP_HIDE_FROM_ABI promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }
+  promise(const promise& __rhs) = delete;
+  ~promise();
 
-    // assignment
-    _LIBCPP_INLINE_VISIBILITY
-    promise& operator=(promise&& __rhs) _NOEXCEPT
-        {
-            promise(_VSTD::move(__rhs)).swap(*this);
-            return *this;
-        }
-    promise& operator=(const promise& __rhs) = delete;
+  // assignment
+  _LIBCPP_HIDE_FROM_ABI promise& operator=(promise&& __rhs) _NOEXCEPT {
+    promise(std::move(__rhs)).swap(*this);
+    return *this;
+  }
+  promise& operator=(const promise& __rhs) = delete;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
 
-    // retrieving the result
-    future<void> get_future();
+  // retrieving the result
+  future<void> get_future();
 
-    // setting the result
-    void set_value();
-    void set_exception(exception_ptr __p);
+  // setting the result
+  void set_value();
+  void set_exception(exception_ptr __p);
 
-    // setting the result with deferred notification
-    void set_value_at_thread_exit();
-    void set_exception_at_thread_exit(exception_ptr __p);
+  // setting the result with deferred notification
+  void set_value_at_thread_exit();
+  void set_exception_at_thread_exit(exception_ptr __p);
 };
 
 template <class _Alloc>
-promise<void>::promise(allocator_arg_t, const _Alloc& __a0)
-{
-    typedef __assoc_sub_state_alloc<_Alloc> _State;
-    typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
-    typedef __allocator_destructor<_A2> _D2;
-    _A2 __a(__a0);
-    unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
-    ::new ((void*)_VSTD::addressof(*__hold.get())) _State(__a0);
-    __state_ = _VSTD::addressof(*__hold.release());
+promise<void>::promise(allocator_arg_t, const _Alloc& __a0) {
+  typedef __assoc_sub_state_alloc<_Alloc> _State;
+  typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
+  typedef __allocator_destructor<_A2> _D2;
+  _A2 __a(__a0);
+  unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
+  ::new ((void*)std::addressof(*__hold.get())) _State(__a0);
+  __state_ = std::addressof(*__hold.release());
 }
 
 template <class _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT {
+  __x.swap(__y);
 }
 
 template <class _Rp, class _Alloc>
-    struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc>
-        : public true_type {};
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc> : public true_type {};
 
 // packaged_task
 
-template<class _Fp> class __packaged_task_base;
-
-template<class _Rp, class ..._ArgTypes>
-class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_base<_Rp(_ArgTypes...)>
-{
-    __packaged_task_base(const __packaged_task_base&);
-    __packaged_task_base& operator=(const __packaged_task_base&);
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    __packaged_task_base() {}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL
-    virtual ~__packaged_task_base() {}
-    virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;
-    virtual void destroy() = 0;
-    virtual void destroy_deallocate() = 0;
-    virtual _Rp operator()(_ArgTypes&& ...) = 0;
-};
-
-template<class _FD, class _Alloc, class _FB> class __packaged_task_func;
-
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>
-    : public  __packaged_task_base<_Rp(_ArgTypes...)>
-{
-    __compressed_pair<_Fp, _Alloc> __f_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __packaged_task_func(const _Fp& __f) : __f_(__f, __default_init_tag()) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f), __default_init_tag()) {}
-    _LIBCPP_INLINE_VISIBILITY
-    __packaged_task_func(const _Fp& __f, const _Alloc& __a)
-        : __f_(__f, __a) {}
-    _LIBCPP_INLINE_VISIBILITY
-    __packaged_task_func(_Fp&& __f, const _Alloc& __a)
-        : __f_(_VSTD::move(__f), __a) {}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy();
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy_deallocate();
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual _Rp operator()(_ArgTypes&& ... __args);
-};
-
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-void
-__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(
-                              __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT
-{
-    ::new ((void*)__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
-}
-
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-void
-__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy()
-{
-    __f_.~__compressed_pair<_Fp, _Alloc>();
-}
-
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-void
-__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate()
-{
-    typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap;
-    typedef allocator_traits<_Ap> _ATraits;
-    typedef pointer_traits<typename _ATraits::pointer> _PTraits;
-    _Ap __a(__f_.second());
-    __f_.~__compressed_pair<_Fp, _Alloc>();
-    __a.deallocate(_PTraits::pointer_to(*this), 1);
-}
-
-template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
-_Rp
-__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
-{
-    return _VSTD::__invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
-}
-
-template <class _Callable> class __packaged_task_function;
-
-template<class _Rp, class ..._ArgTypes>
-class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_function<_Rp(_ArgTypes...)>
-{
-    typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_NO_CFI
-    __base* __get_buf() { return (__base*)&__buf_; }
-
-    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    typename aligned_storage<3*sizeof(void*)>::type __buf_;
-    _LIBCPP_SUPPRESS_DEPRECATED_POP
-    __base* __f_;
-
-public:
-    typedef _Rp result_type;
-
-    // construct/copy/destroy:
-    _LIBCPP_INLINE_VISIBILITY
-    __packaged_task_function() _NOEXCEPT : __f_(nullptr) {}
-    template<class _Fp>
-    _LIBCPP_HIDE_FROM_ABI __packaged_task_function(_Fp&& __f);
-    template<class _Fp, class _Alloc>
-    _LIBCPP_HIDE_FROM_ABI __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f);
-
-    _LIBCPP_HIDE_FROM_ABI __packaged_task_function(__packaged_task_function&&) _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI __packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT;
-
-    __packaged_task_function(const __packaged_task_function&) =  delete;
-    __packaged_task_function& operator=(const __packaged_task_function&) =  delete;
-
-    _LIBCPP_HIDE_FROM_ABI ~__packaged_task_function();
-
-    _LIBCPP_HIDE_FROM_ABI void swap(__packaged_task_function&) _NOEXCEPT;
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes...) const;
-};
-
-template<class _Rp, class ..._ArgTypes>
-__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT
-{
-    if (__f.__f_ == nullptr)
-        __f_ = nullptr;
-    else if (__f.__f_ == __f.__get_buf())
-    {
-        __f.__f_->__move_to(__get_buf());
-        __f_ = (__base*)&__buf_;
-    }
-    else
-    {
-        __f_ = __f.__f_;
-        __f.__f_ = nullptr;
-    }
-}
-
-template<class _Rp, class ..._ArgTypes>
 template <class _Fp>
-__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f)
-    : __f_(nullptr)
-{
-    typedef __libcpp_remove_reference_t<__decay_t<_Fp> > _FR;
-    typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF;
-    if (sizeof(_FF) <= sizeof(__buf_))
-    {
-        ::new ((void*)&__buf_) _FF(_VSTD::forward<_Fp>(__f));
-        __f_ = (__base*)&__buf_;
-    }
-    else
-    {
-        typedef allocator<_FF> _Ap;
-        _Ap __a;
-        typedef __allocator_destructor<_Ap> _Dp;
-        unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
-        ::new ((void*)__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a));
-        __f_ = __hold.release();
-    }
+class __packaged_task_base;
+
+template <class _Rp, class... _ArgTypes>
+class __packaged_task_base<_Rp(_ArgTypes...)> {
+public:
+  _LIBCPP_HIDE_FROM_ABI __packaged_task_base() {}
+  __packaged_task_base(const __packaged_task_base&)            = delete;
+  __packaged_task_base& operator=(const __packaged_task_base&) = delete;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  virtual ~__packaged_task_base() {}
+  virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;
+  virtual void destroy()                                  = 0;
+  virtual void destroy_deallocate()                       = 0;
+  virtual _Rp operator()(_ArgTypes&&...)                  = 0;
+};
+
+template <class _FD, class _Alloc, class _FB>
+class __packaged_task_func;
+
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+class __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)> : public __packaged_task_base<_Rp(_ArgTypes...)> {
+  __compressed_pair<_Fp, _Alloc> __f_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit __packaged_task_func(const _Fp& __f) : __f_(__f, __default_init_tag()) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __packaged_task_func(_Fp&& __f) : __f_(std::move(__f), __default_init_tag()) {}
+  _LIBCPP_HIDE_FROM_ABI __packaged_task_func(const _Fp& __f, const _Alloc& __a) : __f_(__f, __a) {}
+  _LIBCPP_HIDE_FROM_ABI __packaged_task_func(_Fp&& __f, const _Alloc& __a) : __f_(std::move(__f), __a) {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy();
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy_deallocate();
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual _Rp operator()(_ArgTypes&&... __args);
+};
+
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+void __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(
+    __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT {
+  ::new ((void*)__p) __packaged_task_func(std::move(__f_.first()), std::move(__f_.second()));
 }
 
-template<class _Rp, class ..._ArgTypes>
-template <class _Fp, class _Alloc>
-__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(
-                                  allocator_arg_t, const _Alloc& __a0, _Fp&& __f)
-    : __f_(nullptr)
-{
-    typedef __libcpp_remove_reference_t<__decay_t<_Fp> > _FR;
-    typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF;
-    if (sizeof(_FF) <= sizeof(__buf_))
-    {
-        __f_ = (__base*)&__buf_;
-        ::new ((void*)__f_) _FF(_VSTD::forward<_Fp>(__f));
-    }
-    else
-    {
-        typedef typename __allocator_traits_rebind<_Alloc, _FF>::type _Ap;
-        _Ap __a(__a0);
-        typedef __allocator_destructor<_Ap> _Dp;
-        unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
-        ::new ((void*)_VSTD::addressof(*__hold.get()))
-            _FF(_VSTD::forward<_Fp>(__f), _Alloc(__a));
-        __f_ = _VSTD::addressof(*__hold.release());
-    }
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+void __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() {
+  __f_.~__compressed_pair<_Fp, _Alloc>();
 }
 
-template<class _Rp, class ..._ArgTypes>
-__packaged_task_function<_Rp(_ArgTypes...)>&
-__packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) _NOEXCEPT
-{
-    if (__f_ == __get_buf())
-        __f_->destroy();
-    else if (__f_)
-        __f_->destroy_deallocate();
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+void __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() {
+  typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap;
+  typedef allocator_traits<_Ap> _ATraits;
+  typedef pointer_traits<typename _ATraits::pointer> _PTraits;
+  _Ap __a(__f_.second());
+  __f_.~__compressed_pair<_Fp, _Alloc>();
+  __a.deallocate(_PTraits::pointer_to(*this), 1);
+}
+
+template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>
+_Rp __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&&... __arg) {
+  return std::__invoke(__f_.first(), std::forward<_ArgTypes>(__arg)...);
+}
+
+template <class _Callable>
+class __packaged_task_function;
+
+template <class _Rp, class... _ArgTypes>
+class __packaged_task_function<_Rp(_ArgTypes...)> {
+  typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI __base* __get_buf() { return (__base*)&__buf_; }
+
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  typename aligned_storage<3 * sizeof(void*)>::type __buf_;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+  __base* __f_;
+
+public:
+  typedef _Rp result_type;
+
+  // construct/copy/destroy:
+  _LIBCPP_HIDE_FROM_ABI __packaged_task_function() _NOEXCEPT : __f_(nullptr) {}
+  template <class _Fp>
+  _LIBCPP_HIDE_FROM_ABI __packaged_task_function(_Fp&& __f);
+  template <class _Fp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f);
+
+  _LIBCPP_HIDE_FROM_ABI __packaged_task_function(__packaged_task_function&&) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI __packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT;
+
+  __packaged_task_function(const __packaged_task_function&)            = delete;
+  __packaged_task_function& operator=(const __packaged_task_function&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI ~__packaged_task_function();
+
+  _LIBCPP_HIDE_FROM_ABI void swap(__packaged_task_function&) _NOEXCEPT;
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes...) const;
+};
+
+template <class _Rp, class... _ArgTypes>
+__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT {
+  if (__f.__f_ == nullptr)
     __f_ = nullptr;
-    if (__f.__f_ == nullptr)
-        __f_ = nullptr;
-    else if (__f.__f_ == __f.__get_buf())
-    {
-        __f.__f_->__move_to(__get_buf());
-        __f_ = __get_buf();
-    }
-    else
-    {
-        __f_ = __f.__f_;
-        __f.__f_ = nullptr;
-    }
+  else if (__f.__f_ == __f.__get_buf()) {
+    __f.__f_->__move_to(__get_buf());
+    __f_ = (__base*)&__buf_;
+  } else {
+    __f_     = __f.__f_;
+    __f.__f_ = nullptr;
+  }
+}
+
+template <class _Rp, class... _ArgTypes>
+template <class _Fp>
+__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f) : __f_(nullptr) {
+  typedef __libcpp_remove_reference_t<__decay_t<_Fp> > _FR;
+  typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF;
+  if (sizeof(_FF) <= sizeof(__buf_)) {
+    ::new ((void*)&__buf_) _FF(std::forward<_Fp>(__f));
+    __f_ = (__base*)&__buf_;
+  } else {
+    typedef allocator<_FF> _Ap;
+    _Ap __a;
+    typedef __allocator_destructor<_Ap> _Dp;
+    unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
+    ::new ((void*)__hold.get()) _FF(std::forward<_Fp>(__f), allocator<_FR>(__a));
+    __f_ = __hold.release();
+  }
+}
+
+template <class _Rp, class... _ArgTypes>
+template <class _Fp, class _Alloc>
+__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(allocator_arg_t, const _Alloc& __a0, _Fp&& __f)
+    : __f_(nullptr) {
+  typedef __libcpp_remove_reference_t<__decay_t<_Fp> > _FR;
+  typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF;
+  if (sizeof(_FF) <= sizeof(__buf_)) {
+    __f_ = (__base*)&__buf_;
+    ::new ((void*)__f_) _FF(std::forward<_Fp>(__f));
+  } else {
+    typedef typename __allocator_traits_rebind<_Alloc, _FF>::type _Ap;
+    _Ap __a(__a0);
+    typedef __allocator_destructor<_Ap> _Dp;
+    unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
+    ::new ((void*)std::addressof(*__hold.get())) _FF(std::forward<_Fp>(__f), _Alloc(__a));
+    __f_ = std::addressof(*__hold.release());
+  }
+}
+
+template <class _Rp, class... _ArgTypes>
+__packaged_task_function<_Rp(_ArgTypes...)>&
+__packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) _NOEXCEPT {
+  if (__f_ == __get_buf())
+    __f_->destroy();
+  else if (__f_)
+    __f_->destroy_deallocate();
+  __f_ = nullptr;
+  if (__f.__f_ == nullptr)
+    __f_ = nullptr;
+  else if (__f.__f_ == __f.__get_buf()) {
+    __f.__f_->__move_to(__get_buf());
+    __f_ = __get_buf();
+  } else {
+    __f_     = __f.__f_;
+    __f.__f_ = nullptr;
+  }
+  return *this;
+}
+
+template <class _Rp, class... _ArgTypes>
+__packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function() {
+  if (__f_ == __get_buf())
+    __f_->destroy();
+  else if (__f_)
+    __f_->destroy_deallocate();
+}
+
+template <class _Rp, class... _ArgTypes>
+_LIBCPP_NO_CFI void __packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT {
+  if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) {
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
+    __base* __t = (__base*)&__tempbuf;
+    __f_->__move_to(__t);
+    __f_->destroy();
+    __f_ = nullptr;
+    __f.__f_->__move_to((__base*)&__buf_);
+    __f.__f_->destroy();
+    __f.__f_ = nullptr;
+    __f_     = (__base*)&__buf_;
+    __t->__move_to((__base*)&__f.__buf_);
+    __t->destroy();
+    __f.__f_ = (__base*)&__f.__buf_;
+  } else if (__f_ == (__base*)&__buf_) {
+    __f_->__move_to((__base*)&__f.__buf_);
+    __f_->destroy();
+    __f_     = __f.__f_;
+    __f.__f_ = (__base*)&__f.__buf_;
+  } else if (__f.__f_ == (__base*)&__f.__buf_) {
+    __f.__f_->__move_to((__base*)&__buf_);
+    __f.__f_->destroy();
+    __f.__f_ = __f_;
+    __f_     = (__base*)&__buf_;
+  } else
+    std::swap(__f_, __f.__f_);
+}
+
+template <class _Rp, class... _ArgTypes>
+inline _Rp __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const {
+  return (*__f_)(std::forward<_ArgTypes>(__arg)...);
+}
+
+template <class _Rp, class... _ArgTypes>
+class _LIBCPP_TEMPLATE_VIS packaged_task<_Rp(_ArgTypes...)> {
+public:
+  typedef _Rp result_type; // extension
+
+private:
+  __packaged_task_function<result_type(_ArgTypes...)> __f_;
+  promise<result_type> __p_;
+
+public:
+  // construction and destruction
+  _LIBCPP_HIDE_FROM_ABI packaged_task() _NOEXCEPT : __p_(nullptr) {}
+
+  template <class _Fp, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit packaged_task(_Fp&& __f) : __f_(std::forward<_Fp>(__f)) {}
+
+  template <class _Fp, class _Allocator, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
+      : __f_(allocator_arg_t(), __a, std::forward<_Fp>(__f)), __p_(allocator_arg_t(), __a) {}
+  // ~packaged_task() = default;
+
+  // no copy
+  packaged_task(const packaged_task&)            = delete;
+  packaged_task& operator=(const packaged_task&) = delete;
+
+  // move support
+  _LIBCPP_HIDE_FROM_ABI packaged_task(packaged_task&& __other) _NOEXCEPT
+      : __f_(std::move(__other.__f_)),
+        __p_(std::move(__other.__p_)) {}
+  _LIBCPP_HIDE_FROM_ABI packaged_task& operator=(packaged_task&& __other) _NOEXCEPT {
+    __f_ = std::move(__other.__f_);
+    __p_ = std::move(__other.__p_);
     return *this;
-}
+  }
+  _LIBCPP_HIDE_FROM_ABI void swap(packaged_task& __other) _NOEXCEPT {
+    __f_.swap(__other.__f_);
+    __p_.swap(__other.__p_);
+  }
 
-template<class _Rp, class ..._ArgTypes>
-__packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function()
-{
-    if (__f_ == __get_buf())
-        __f_->destroy();
-    else if (__f_)
-        __f_->destroy_deallocate();
-}
+  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __p_.__state_ != nullptr; }
 
-template<class _Rp, class ..._ArgTypes>
-_LIBCPP_NO_CFI
-void
-__packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT
-{
-    if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
-    {
-        _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-        typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
-        _LIBCPP_SUPPRESS_DEPRECATED_POP
-        __base* __t = (__base*)&__tempbuf;
-        __f_->__move_to(__t);
-        __f_->destroy();
-        __f_ = nullptr;
-        __f.__f_->__move_to((__base*)&__buf_);
-        __f.__f_->destroy();
-        __f.__f_ = nullptr;
-        __f_ = (__base*)&__buf_;
-        __t->__move_to((__base*)&__f.__buf_);
-        __t->destroy();
-        __f.__f_ = (__base*)&__f.__buf_;
-    }
-    else if (__f_ == (__base*)&__buf_)
-    {
-        __f_->__move_to((__base*)&__f.__buf_);
-        __f_->destroy();
-        __f_ = __f.__f_;
-        __f.__f_ = (__base*)&__f.__buf_;
-    }
-    else if (__f.__f_ == (__base*)&__f.__buf_)
-    {
-        __f.__f_->__move_to((__base*)&__buf_);
-        __f.__f_->destroy();
-        __f.__f_ = __f_;
-        __f_ = (__base*)&__buf_;
-    }
-    else
-        _VSTD::swap(__f_, __f.__f_);
-}
+  // result retrieval
+  _LIBCPP_HIDE_FROM_ABI future<result_type> get_future() { return __p_.get_future(); }
 
-template<class _Rp, class ..._ArgTypes>
-inline
-_Rp
-__packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
-{
-    return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
-}
+  // execution
+  _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args);
+  _LIBCPP_HIDE_FROM_ABI void make_ready_at_thread_exit(_ArgTypes... __args);
 
-template<class _Rp, class ..._ArgTypes>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<_Rp(_ArgTypes...)>
-{
-public:
-    typedef _Rp result_type; // extension
-
-private:
-    __packaged_task_function<result_type(_ArgTypes...)> __f_;
-    promise<result_type>                                __p_;
-
-public:
-    // construction and destruction
-    _LIBCPP_INLINE_VISIBILITY
-    packaged_task() _NOEXCEPT : __p_(nullptr) {}
-    template <class _Fp,
-              class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
-    template <class _Fp, class _Allocator,
-              class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
-             : __f_(allocator_arg_t(), __a, _VSTD::forward<_Fp>(__f)),
-               __p_(allocator_arg_t(), __a) {}
-    // ~packaged_task() = default;
-
-    // no copy
-    packaged_task(const packaged_task&) = delete;
-    packaged_task& operator=(const packaged_task&) = delete;
-
-    // move support
-    _LIBCPP_INLINE_VISIBILITY
-    packaged_task(packaged_task&& __other) _NOEXCEPT
-        : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
-    _LIBCPP_INLINE_VISIBILITY
-    packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
-    {
-        __f_ = _VSTD::move(__other.__f_);
-        __p_ = _VSTD::move(__other.__p_);
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(packaged_task& __other) _NOEXCEPT
-    {
-        __f_.swap(__other.__f_);
-        __p_.swap(__other.__p_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
-
-    // result retrieval
-    _LIBCPP_INLINE_VISIBILITY
-    future<result_type> get_future() {return __p_.get_future();}
-
-    // execution
-    _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args);
-    _LIBCPP_HIDE_FROM_ABI void make_ready_at_thread_exit(_ArgTypes... __args);
-
-    _LIBCPP_HIDE_FROM_ABI void reset();
+  _LIBCPP_HIDE_FROM_ABI void reset();
 };
 
-template<class _Rp, class ..._ArgTypes>
-void
-packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args)
-{
-    if (__p_.__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    if (__p_.__state_->__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __p_.set_exception(current_exception());
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+template <class _Rp, class... _ArgTypes>
+void packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args) {
+  if (__p_.__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  if (__p_.__state_->__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __p_.set_value(__f_(std::forward<_ArgTypes>(__args)...));
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    __p_.set_exception(current_exception());
+  }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
-template<class _Rp, class ..._ArgTypes>
-void
-packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
-{
-    if (__p_.__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    if (__p_.__state_->__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __p_.set_exception_at_thread_exit(current_exception());
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+template <class _Rp, class... _ArgTypes>
+void packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) {
+  if (__p_.__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  if (__p_.__state_->__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __p_.set_value_at_thread_exit(__f_(std::forward<_ArgTypes>(__args)...));
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    __p_.set_exception_at_thread_exit(current_exception());
+  }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
-template<class _Rp, class ..._ArgTypes>
-void
-packaged_task<_Rp(_ArgTypes...)>::reset()
-{
-    if (!valid())
-        __throw_future_error(future_errc::no_state);
-    __p_ = promise<result_type>();
+template <class _Rp, class... _ArgTypes>
+void packaged_task<_Rp(_ArgTypes...)>::reset() {
+  if (!valid())
+    __throw_future_error(future_errc::no_state);
+  __p_ = promise<result_type>();
 }
 
-template<class ..._ArgTypes>
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<void(_ArgTypes...)>
-{
+template <class... _ArgTypes>
+class _LIBCPP_TEMPLATE_VIS packaged_task<void(_ArgTypes...)> {
 public:
-    typedef void result_type; // extension
+  typedef void result_type; // extension
 
 private:
-    __packaged_task_function<result_type(_ArgTypes...)> __f_;
-    promise<result_type>                                __p_;
+  __packaged_task_function<result_type(_ArgTypes...)> __f_;
+  promise<result_type> __p_;
 
 public:
-    // construction and destruction
-    _LIBCPP_INLINE_VISIBILITY
-    packaged_task() _NOEXCEPT : __p_(nullptr) {}
-    template <class _Fp,
-              class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
-    template <class _Fp, class _Allocator,
-              class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
-             : __f_(allocator_arg_t(), __a, _VSTD::forward<_Fp>(__f)),
-               __p_(allocator_arg_t(), __a) {}
-    // ~packaged_task() = default;
+  // construction and destruction
+  _LIBCPP_HIDE_FROM_ABI packaged_task() _NOEXCEPT : __p_(nullptr) {}
+  template <class _Fp, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit packaged_task(_Fp&& __f) : __f_(std::forward<_Fp>(__f)) {}
+  template <class _Fp, class _Allocator, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
+      : __f_(allocator_arg_t(), __a, std::forward<_Fp>(__f)), __p_(allocator_arg_t(), __a) {}
+  // ~packaged_task() = default;
 
-    // no copy
-    packaged_task(const packaged_task&) = delete;
-    packaged_task& operator=(const packaged_task&) = delete;
+  // no copy
+  packaged_task(const packaged_task&)            = delete;
+  packaged_task& operator=(const packaged_task&) = delete;
 
-    // move support
-    _LIBCPP_INLINE_VISIBILITY
-    packaged_task(packaged_task&& __other) _NOEXCEPT
-        : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
-    _LIBCPP_INLINE_VISIBILITY
-    packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
-    {
-        __f_ = _VSTD::move(__other.__f_);
-        __p_ = _VSTD::move(__other.__p_);
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(packaged_task& __other) _NOEXCEPT
-    {
-        __f_.swap(__other.__f_);
-        __p_.swap(__other.__p_);
-    }
+  // move support
+  _LIBCPP_HIDE_FROM_ABI packaged_task(packaged_task&& __other) _NOEXCEPT
+      : __f_(std::move(__other.__f_)),
+        __p_(std::move(__other.__p_)) {}
+  _LIBCPP_HIDE_FROM_ABI packaged_task& operator=(packaged_task&& __other) _NOEXCEPT {
+    __f_ = std::move(__other.__f_);
+    __p_ = std::move(__other.__p_);
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI void swap(packaged_task& __other) _NOEXCEPT {
+    __f_.swap(__other.__f_);
+    __p_.swap(__other.__p_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
+  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __p_.__state_ != nullptr; }
 
-    // result retrieval
-    _LIBCPP_INLINE_VISIBILITY
-    future<result_type> get_future() {return __p_.get_future();}
+  // result retrieval
+  _LIBCPP_HIDE_FROM_ABI future<result_type> get_future() { return __p_.get_future(); }
 
-    // execution
-    _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args);
-    _LIBCPP_HIDE_FROM_ABI void make_ready_at_thread_exit(_ArgTypes... __args);
+  // execution
+  _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args);
+  _LIBCPP_HIDE_FROM_ABI void make_ready_at_thread_exit(_ArgTypes... __args);
 
-    _LIBCPP_HIDE_FROM_ABI void reset();
+  _LIBCPP_HIDE_FROM_ABI void reset();
 };
 
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 
 template <class _Rp, class... _Args>
-packaged_task(_Rp(*)(_Args...)) -> packaged_task<_Rp(_Args...)>;
+packaged_task(_Rp (*)(_Args...)) -> packaged_task<_Rp(_Args...)>;
 
 template <class _Fp, class _Stripped = typename __strip_signature<decltype(&_Fp::operator())>::type>
 packaged_task(_Fp) -> packaged_task<_Stripped>;
 
-#endif
+#  endif
 
-template<class ..._ArgTypes>
-void
-packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
-{
-    if (__p_.__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    if (__p_.__state_->__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __f_(_VSTD::forward<_ArgTypes>(__args)...);
-        __p_.set_value();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __p_.set_exception(current_exception());
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+template <class... _ArgTypes>
+void packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args) {
+  if (__p_.__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  if (__p_.__state_->__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __f_(std::forward<_ArgTypes>(__args)...);
+    __p_.set_value();
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    __p_.set_exception(current_exception());
+  }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
-template<class ..._ArgTypes>
-void
-packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
-{
-    if (__p_.__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    if (__p_.__state_->__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __f_(_VSTD::forward<_ArgTypes>(__args)...);
-        __p_.set_value_at_thread_exit();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __p_.set_exception_at_thread_exit(current_exception());
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+template <class... _ArgTypes>
+void packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) {
+  if (__p_.__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  if (__p_.__state_->__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __f_(std::forward<_ArgTypes>(__args)...);
+    __p_.set_value_at_thread_exit();
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    __p_.set_exception_at_thread_exit(current_exception());
+  }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
-template<class ..._ArgTypes>
-void
-packaged_task<void(_ArgTypes...)>::reset()
-{
-    if (!valid())
-        __throw_future_error(future_errc::no_state);
-    __p_ = promise<result_type>();
+template <class... _ArgTypes>
+void packaged_task<void(_ArgTypes...)>::reset() {
+  if (!valid())
+    __throw_future_error(future_errc::no_state);
+  __p_ = promise<result_type>();
 }
 
 template <class _Rp, class... _ArgTypes>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(packaged_task<_Rp(_ArgTypes...)>& __x, packaged_task<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(packaged_task<_Rp(_ArgTypes...)>& __x, packaged_task<_Rp(_ArgTypes...)>& __y) _NOEXCEPT {
+  __x.swap(__y);
 }
 
 template <class _Callable, class _Alloc>
-struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc>
-    : public true_type {};
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc> : public true_type {};
 
 template <class _Rp, class _Fp>
-_LIBCPP_INLINE_VISIBILITY future<_Rp>
-__make_deferred_assoc_state(_Fp&& __f)
-{
-    unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count>
-        __h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
-    return future<_Rp>(__h.get());
+_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_deferred_assoc_state(_Fp&& __f) {
+  unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count> __h(
+      new __deferred_assoc_state<_Rp, _Fp>(std::forward<_Fp>(__f)));
+  return future<_Rp>(__h.get());
 }
 
 template <class _Rp, class _Fp>
-_LIBCPP_INLINE_VISIBILITY future<_Rp>
-__make_async_assoc_state(_Fp&& __f)
-{
-    unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count>
-        __h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
-    _VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
-    return future<_Rp>(__h.get());
+_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_async_assoc_state(_Fp&& __f) {
+  unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count> __h(
+      new __async_assoc_state<_Rp, _Fp>(std::forward<_Fp>(__f)));
+  std::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
+  return future<_Rp>(__h.get());
 }
 
-#ifndef _LIBCPP_CXX03_LANG
+#  ifndef _LIBCPP_CXX03_LANG
 
 template <class _Fp, class... _Args>
-class _LIBCPP_HIDDEN __async_func
-{
-    tuple<_Fp, _Args...> __f_;
+class _LIBCPP_HIDDEN __async_func {
+  tuple<_Fp, _Args...> __f_;
 
 public:
-    typedef typename __invoke_of<_Fp, _Args...>::type _Rp;
+  typedef typename __invoke_of<_Fp, _Args...>::type _Rp;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __async_func(_Fp&& __f, _Args&&... __args)
-        : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __async_func(_Fp&& __f, _Args&&... __args)
+      : __f_(std::move(__f), std::move(__args)...) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {}
+  _LIBCPP_HIDE_FROM_ABI __async_func(__async_func&& __f) : __f_(std::move(__f.__f_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI _Rp operator()() {
+    typedef typename __make_tuple_indices<1 + sizeof...(_Args), 1>::type _Index;
+    return __execute(_Index());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _Rp operator()()
-    {
-        typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index;
-        return __execute(_Index());
-    }
 private:
-    template <size_t ..._Indices>
-    _LIBCPP_HIDE_FROM_ABI _Rp
-    __execute(__tuple_indices<_Indices...>)
-    {
-        return _VSTD::__invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
-    }
+  template <size_t... _Indices>
+  _LIBCPP_HIDE_FROM_ABI _Rp __execute(__tuple_indices<_Indices...>) {
+    return std::__invoke(std::move(std::get<0>(__f_)), std::move(std::get<_Indices>(__f_))...);
+  }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY bool __does_policy_contain(launch __policy, launch __value )
-{ return (int(__policy) & int(__value)) != 0; }
-
-template <class _Fp, class... _Args>
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI
-future<typename __invoke_of<__decay_t<_Fp>, __decay_t<_Args>...>::type>
-async(launch __policy, _Fp&& __f, _Args&&... __args)
-{
-    typedef __async_func<__decay_t<_Fp>, __decay_t<_Args>...> _BF;
-    typedef typename _BF::_Rp _Rp;
-
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif
-        if (__does_policy_contain(__policy, launch::async))
-        return _VSTD::__make_async_assoc_state<_Rp>(_BF(_LIBCPP_AUTO_CAST(_VSTD::forward<_Fp>(__f)),
-                                                        _LIBCPP_AUTO_CAST(_VSTD::forward<_Args>(__args))...));
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch ( ... ) { if (__policy == launch::async) throw ; }
-#endif
-
-    if (__does_policy_contain(__policy, launch::deferred))
-        return _VSTD::__make_deferred_assoc_state<_Rp>(_BF(_LIBCPP_AUTO_CAST(_VSTD::forward<_Fp>(__f)),
-                                                           _LIBCPP_AUTO_CAST(_VSTD::forward<_Args>(__args))...));
-    return future<_Rp>{};
+inline _LIBCPP_HIDE_FROM_ABI bool __does_policy_contain(launch __policy, launch __value) {
+  return (int(__policy) & int(__value)) != 0;
 }
 
 template <class _Fp, class... _Args>
-_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
-future<typename __invoke_of<__decay_t<_Fp>, __decay_t<_Args>...>::type>
-async(_Fp&& __f, _Args&&... __args)
-{
-    return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f),
-                                    _VSTD::forward<_Args>(__args)...);
+_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI future<typename __invoke_of<__decay_t<_Fp>, __decay_t<_Args>...>::type>
+async(launch __policy, _Fp&& __f, _Args&&... __args) {
+  typedef __async_func<__decay_t<_Fp>, __decay_t<_Args>...> _BF;
+  typedef typename _BF::_Rp _Rp;
+
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#    endif
+    if (__does_policy_contain(__policy, launch::async))
+      return std::__make_async_assoc_state<_Rp>(
+          _BF(_LIBCPP_AUTO_CAST(std::forward<_Fp>(__f)), _LIBCPP_AUTO_CAST(std::forward<_Args>(__args))...));
+#    ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    if (__policy == launch::async)
+      throw;
+  }
+#    endif
+
+  if (__does_policy_contain(__policy, launch::deferred))
+    return std::__make_deferred_assoc_state<_Rp>(
+        _BF(_LIBCPP_AUTO_CAST(std::forward<_Fp>(__f)), _LIBCPP_AUTO_CAST(std::forward<_Args>(__args))...));
+  return future<_Rp>{};
 }
 
-#endif // C++03
+template <class _Fp, class... _Args>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI future<typename __invoke_of<__decay_t<_Fp>, __decay_t<_Args>...>::type>
+async(_Fp&& __f, _Args&&... __args) {
+  return std::async(launch::any, std::forward<_Fp>(__f), std::forward<_Args>(__args)...);
+}
+
+#  endif // C++03
 
 // shared_future
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS shared_future
-{
-    __assoc_state<_Rp>* __state_;
+class _LIBCPP_TEMPLATE_VIS shared_future {
+  __assoc_state<_Rp>* __state_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future() _NOEXCEPT : __state_(nullptr) {}
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future(const shared_future& __rhs)  _NOEXCEPT : __state_(__rhs.__state_)
-        {if (__state_) __state_->__add_shared();}
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future(future<_Rp>&& __f) _NOEXCEPT : __state_(__f.__state_)
-        {__f.__state_ = nullptr;}
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
-        {__rhs.__state_ = nullptr;}
-    _LIBCPP_HIDE_FROM_ABI ~shared_future();
-    _LIBCPP_HIDE_FROM_ABI shared_future& operator=(const shared_future& __rhs) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
-        {
-            shared_future(_VSTD::move(__rhs)).swap(*this);
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI shared_future() _NOEXCEPT : __state_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI shared_future(const shared_future& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {
+    if (__state_)
+      __state_->__add_shared();
+  }
+  _LIBCPP_HIDE_FROM_ABI shared_future(future<_Rp>&& __f) _NOEXCEPT : __state_(__f.__state_) { __f.__state_ = nullptr; }
+  _LIBCPP_HIDE_FROM_ABI shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {
+    __rhs.__state_ = nullptr;
+  }
+  _LIBCPP_HIDE_FROM_ABI ~shared_future();
+  _LIBCPP_HIDE_FROM_ABI shared_future& operator=(const shared_future& __rhs) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI shared_future& operator=(shared_future&& __rhs) _NOEXCEPT {
+    shared_future(std::move(__rhs)).swap(*this);
+    return *this;
+  }
 
-    // retrieving the value
-    _LIBCPP_INLINE_VISIBILITY
-    const _Rp& get() const {return __state_->copy();}
+  // retrieving the value
+  _LIBCPP_HIDE_FROM_ABI const _Rp& get() const { return __state_->copy(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
 
-    // functions to check state
-    _LIBCPP_INLINE_VISIBILITY
-    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
+  // functions to check state
+  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void wait() const {__state_->wait();}
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
-            {return __state_->wait_for(__rel_time);}
-    template <class _Clock, class _Duration>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
-            {return __state_->wait_until(__abs_time);}
+  _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {
+    return __state_->wait_for(__rel_time);
+  }
+  template <class _Clock, class _Duration>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {
+    return __state_->wait_until(__abs_time);
+  }
 };
 
 template <class _Rp>
-shared_future<_Rp>::~shared_future()
-{
-    if (__state_)
-        __state_->__release_shared();
+shared_future<_Rp>::~shared_future() {
+  if (__state_)
+    __state_->__release_shared();
 }
 
 template <class _Rp>
-shared_future<_Rp>&
-shared_future<_Rp>::operator=(const shared_future& __rhs) _NOEXCEPT
-{
-    if (__rhs.__state_)
-        __rhs.__state_->__add_shared();
-    if (__state_)
-        __state_->__release_shared();
-    __state_ = __rhs.__state_;
-    return *this;
+shared_future<_Rp>& shared_future<_Rp>::operator=(const shared_future& __rhs) _NOEXCEPT {
+  if (__rhs.__state_)
+    __rhs.__state_->__add_shared();
+  if (__state_)
+    __state_->__release_shared();
+  __state_ = __rhs.__state_;
+  return *this;
 }
 
 template <class _Rp>
-class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&>
-{
-    __assoc_state<_Rp&>* __state_;
+class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&> {
+  __assoc_state<_Rp&>* __state_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future() _NOEXCEPT : __state_(nullptr) {}
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
-        {if (__state_) __state_->__add_shared();}
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future(future<_Rp&>&& __f) _NOEXCEPT : __state_(__f.__state_)
-        {__f.__state_ = nullptr;}
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
-        {__rhs.__state_ = nullptr;}
-    _LIBCPP_HIDE_FROM_ABI ~shared_future();
-    _LIBCPP_HIDE_FROM_ABI shared_future& operator=(const shared_future& __rhs);
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
-        {
-            shared_future(_VSTD::move(__rhs)).swap(*this);
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI shared_future() _NOEXCEPT : __state_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) {
+    if (__state_)
+      __state_->__add_shared();
+  }
+  _LIBCPP_HIDE_FROM_ABI shared_future(future<_Rp&>&& __f) _NOEXCEPT : __state_(__f.__state_) { __f.__state_ = nullptr; }
+  _LIBCPP_HIDE_FROM_ABI shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {
+    __rhs.__state_ = nullptr;
+  }
+  _LIBCPP_HIDE_FROM_ABI ~shared_future();
+  _LIBCPP_HIDE_FROM_ABI shared_future& operator=(const shared_future& __rhs);
+  _LIBCPP_HIDE_FROM_ABI shared_future& operator=(shared_future&& __rhs) _NOEXCEPT {
+    shared_future(std::move(__rhs)).swap(*this);
+    return *this;
+  }
 
-    // retrieving the value
-    _LIBCPP_INLINE_VISIBILITY
-    _Rp& get() const {return __state_->copy();}
+  // retrieving the value
+  _LIBCPP_HIDE_FROM_ABI _Rp& get() const { return __state_->copy(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
 
-    // functions to check state
-    _LIBCPP_INLINE_VISIBILITY
-    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
+  // functions to check state
+  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void wait() const {__state_->wait();}
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
-            {return __state_->wait_for(__rel_time);}
-    template <class _Clock, class _Duration>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
-            {return __state_->wait_until(__abs_time);}
+  _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {
+    return __state_->wait_for(__rel_time);
+  }
+  template <class _Clock, class _Duration>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {
+    return __state_->wait_until(__abs_time);
+  }
 };
 
 template <class _Rp>
-shared_future<_Rp&>::~shared_future()
-{
-    if (__state_)
-        __state_->__release_shared();
+shared_future<_Rp&>::~shared_future() {
+  if (__state_)
+    __state_->__release_shared();
 }
 
 template <class _Rp>
-shared_future<_Rp&>&
-shared_future<_Rp&>::operator=(const shared_future& __rhs)
-{
-    if (__rhs.__state_)
-        __rhs.__state_->__add_shared();
-    if (__state_)
-        __state_->__release_shared();
-    __state_ = __rhs.__state_;
-    return *this;
+shared_future<_Rp&>& shared_future<_Rp&>::operator=(const shared_future& __rhs) {
+  if (__rhs.__state_)
+    __rhs.__state_->__add_shared();
+  if (__state_)
+    __state_->__release_shared();
+  __state_ = __rhs.__state_;
+  return *this;
 }
 
 template <>
-class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_FUTURE shared_future<void>
-{
-    __assoc_sub_state* __state_;
+class _LIBCPP_EXPORTED_FROM_ABI shared_future<void> {
+  __assoc_sub_state* __state_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future() _NOEXCEPT : __state_(nullptr) {}
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
-        {if (__state_) __state_->__add_shared();}
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future(future<void>&& __f) _NOEXCEPT : __state_(__f.__state_)
-        {__f.__state_ = nullptr;}
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
-        {__rhs.__state_ = nullptr;}
-    ~shared_future();
-    shared_future& operator=(const shared_future& __rhs);
-    _LIBCPP_INLINE_VISIBILITY
-    shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
-        {
-            shared_future(_VSTD::move(__rhs)).swap(*this);
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI shared_future() _NOEXCEPT : __state_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) {
+    if (__state_)
+      __state_->__add_shared();
+  }
+  _LIBCPP_HIDE_FROM_ABI shared_future(future<void>&& __f) _NOEXCEPT : __state_(__f.__state_) { __f.__state_ = nullptr; }
+  _LIBCPP_HIDE_FROM_ABI shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {
+    __rhs.__state_ = nullptr;
+  }
+  ~shared_future();
+  shared_future& operator=(const shared_future& __rhs);
+  _LIBCPP_HIDE_FROM_ABI shared_future& operator=(shared_future&& __rhs) _NOEXCEPT {
+    shared_future(std::move(__rhs)).swap(*this);
+    return *this;
+  }
 
-    // retrieving the value
-    _LIBCPP_INLINE_VISIBILITY
-    void get() const {__state_->copy();}
+  // retrieving the value
+  _LIBCPP_HIDE_FROM_ABI void get() const { __state_->copy(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
 
-    // functions to check state
-    _LIBCPP_INLINE_VISIBILITY
-    bool valid() const _NOEXCEPT {return __state_ != nullptr;}
+  // functions to check state
+  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void wait() const {__state_->wait();}
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
-            {return __state_->wait_for(__rel_time);}
-    template <class _Clock, class _Duration>
-        _LIBCPP_INLINE_VISIBILITY
-        future_status
-        wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
-            {return __state_->wait_until(__abs_time);}
+  _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {
+    return __state_->wait_for(__rel_time);
+  }
+  template <class _Clock, class _Duration>
+  _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {
+    return __state_->wait_until(__abs_time);
+  }
 };
 
 template <class _Rp>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void swap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT {
+  __x.swap(__y);
 }
 
 template <class _Rp>
-inline
-shared_future<_Rp>
-future<_Rp>::share() _NOEXCEPT
-{
-    return shared_future<_Rp>(_VSTD::move(*this));
+inline shared_future<_Rp> future<_Rp>::share() _NOEXCEPT {
+  return shared_future<_Rp>(std::move(*this));
 }
 
 template <class _Rp>
-inline
-shared_future<_Rp&>
-future<_Rp&>::share() _NOEXCEPT
-{
-    return shared_future<_Rp&>(_VSTD::move(*this));
+inline shared_future<_Rp&> future<_Rp&>::share() _NOEXCEPT {
+  return shared_future<_Rp&>(std::move(*this));
 }
 
-inline
-shared_future<void>
-future<void>::share() _NOEXCEPT
-{
-    return shared_future<void>(_VSTD::move(*this));
-}
+inline shared_future<void> future<void>::share() _NOEXCEPT { return shared_future<void>(std::move(*this)); }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
+#endif // !defined(_LIBCPP_HAS_NO_THREADS)
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
@@ -2469,6 +2055,7 @@ _LIBCPP_END_NAMESPACE_STD
 #  include <atomic>
 #  include <cstdlib>
 #  include <exception>
+#  include <iosfwd>
 #  include <system_error>
 #endif
 
diff --git a/third_party/libcxx/future.cpp b/third_party/libcxx/future.cpp
new file mode 100644
index 000000000..e2c14c832
--- /dev/null
+++ b/third_party/libcxx/future.cpp
@@ -0,0 +1,197 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <future>
+#include <string>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_HIDDEN __future_error_category : public __do_message {
+public:
+  virtual const char* name() const noexcept;
+  virtual string message(int ev) const;
+};
+
+const char* __future_error_category::name() const noexcept { return "future"; }
+
+_LIBCPP_DIAGNOSTIC_PUSH
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wswitch")
+_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wswitch")
+
+string __future_error_category::message(int ev) const {
+  switch (static_cast<future_errc>(ev)) {
+  case future_errc(0): // For backwards compatibility with C++11 (LWG 2056)
+  case future_errc::broken_promise:
+    return string("The associated promise has been destructed prior "
+                  "to the associated state becoming ready.");
+  case future_errc::future_already_retrieved:
+    return string("The future has already been retrieved from "
+                  "the promise or packaged_task.");
+  case future_errc::promise_already_satisfied:
+    return string("The state of the promise has already been set.");
+  case future_errc::no_state:
+    return string("Operation not permitted on an object without "
+                  "an associated state.");
+  }
+  return string("unspecified future_errc value\n");
+}
+
+_LIBCPP_DIAGNOSTIC_POP
+
+const error_category& future_category() noexcept {
+  union AvoidDestroyingFutureCategory {
+    __future_error_category future_error_category;
+    constexpr explicit AvoidDestroyingFutureCategory() : future_error_category() {}
+    ~AvoidDestroyingFutureCategory() {}
+  };
+  constinit static AvoidDestroyingFutureCategory helper;
+  return helper.future_error_category;
+}
+
+future_error::future_error(error_code __ec) : logic_error(__ec.message()), __ec_(__ec) {}
+
+future_error::~future_error() noexcept {}
+
+void __assoc_sub_state::__on_zero_shared() noexcept { delete this; }
+
+void __assoc_sub_state::set_value() {
+  unique_lock<mutex> __lk(__mut_);
+  if (__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+  __state_ |= __constructed | ready;
+  __cv_.notify_all();
+}
+
+void __assoc_sub_state::set_value_at_thread_exit() {
+  unique_lock<mutex> __lk(__mut_);
+  if (__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+  __state_ |= __constructed;
+  __thread_local_data()->__make_ready_at_thread_exit(this);
+}
+
+void __assoc_sub_state::set_exception(exception_ptr __p) {
+  unique_lock<mutex> __lk(__mut_);
+  if (__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+  __exception_ = __p;
+  __state_ |= ready;
+  __cv_.notify_all();
+}
+
+void __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p) {
+  unique_lock<mutex> __lk(__mut_);
+  if (__has_value())
+    __throw_future_error(future_errc::promise_already_satisfied);
+  __exception_ = __p;
+  __thread_local_data()->__make_ready_at_thread_exit(this);
+}
+
+void __assoc_sub_state::__make_ready() {
+  unique_lock<mutex> __lk(__mut_);
+  __state_ |= ready;
+  __cv_.notify_all();
+}
+
+void __assoc_sub_state::copy() {
+  unique_lock<mutex> __lk(__mut_);
+  __sub_wait(__lk);
+  if (__exception_ != nullptr)
+    rethrow_exception(__exception_);
+}
+
+void __assoc_sub_state::wait() {
+  unique_lock<mutex> __lk(__mut_);
+  __sub_wait(__lk);
+}
+
+void __assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk) {
+  if (!__is_ready()) {
+    if (__state_ & static_cast<unsigned>(deferred)) {
+      __state_ &= ~static_cast<unsigned>(deferred);
+      __lk.unlock();
+      __execute();
+    } else
+      while (!__is_ready())
+        __cv_.wait(__lk);
+  }
+}
+
+void __assoc_sub_state::__execute() { __throw_future_error(future_errc::no_state); }
+
+future<void>::future(__assoc_sub_state* __state) : __state_(__state) { __state_->__attach_future(); }
+
+future<void>::~future() {
+  if (__state_)
+    __state_->__release_shared();
+}
+
+void future<void>::get() {
+  unique_ptr<__shared_count, __release_shared_count> __(__state_);
+  __assoc_sub_state* __s = __state_;
+  __state_               = nullptr;
+  __s->copy();
+}
+
+promise<void>::promise() : __state_(new __assoc_sub_state) {}
+
+promise<void>::~promise() {
+  if (__state_) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    if (!__state_->__has_value() && __state_->use_count() > 1)
+      __state_->set_exception(make_exception_ptr(future_error(future_errc::broken_promise)));
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __state_->__release_shared();
+  }
+}
+
+future<void> promise<void>::get_future() {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  return future<void>(__state_);
+}
+
+void promise<void>::set_value() {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_value();
+}
+
+void promise<void>::set_exception(exception_ptr __p) {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_exception(__p);
+}
+
+void promise<void>::set_value_at_thread_exit() {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_value_at_thread_exit();
+}
+
+void promise<void>::set_exception_at_thread_exit(exception_ptr __p) {
+  if (__state_ == nullptr)
+    __throw_future_error(future_errc::no_state);
+  __state_->set_exception_at_thread_exit(__p);
+}
+
+shared_future<void>::~shared_future() {
+  if (__state_)
+    __state_->__release_shared();
+}
+
+shared_future<void>& shared_future<void>::operator=(const shared_future& __rhs) {
+  if (__rhs.__state_)
+    __rhs.__state_->__add_shared();
+  if (__state_)
+    __state_->__release_shared();
+  __state_ = __rhs.__state_;
+  return *this;
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/hash.cpp b/third_party/libcxx/hash.cpp
new file mode 100644
index 000000000..34b02b8ea
--- /dev/null
+++ b/third_party/libcxx/hash.cpp
@@ -0,0 +1,452 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__hash_table>
+#include <algorithm>
+#include <stdexcept>
+#include <type_traits>
+
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wtautological-constant-out-of-range-compare")
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace {
+
+// handle all next_prime(i) for i in [1, 210), special case 0
+const unsigned small_primes[] = {
+    0,   2,   3,   5,   7,   11,  13,  17,  19,  23,  29,  31,  37,  41,  43,  47,
+    53,  59,  61,  67,  71,  73,  79,  83,  89,  97,  101, 103, 107, 109, 113, 127,
+    131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211};
+
+// potential primes = 210*k + indices[i], k >= 1
+//   these numbers are not divisible by 2, 3, 5 or 7
+//   (or any integer 2 <= j <= 10 for that matter).
+const unsigned indices[] = {
+    1,   11,  13,  17,  19,  23,  29,  31,  37,  41,  43,  47,  53,  59,  61,  67,
+    71,  73,  79,  83,  89,  97,  101, 103, 107, 109, 113, 121, 127, 131, 137, 139,
+    143, 149, 151, 157, 163, 167, 169, 173, 179, 181, 187, 191, 193, 197, 199, 209};
+
+} // namespace
+
+// Returns:  If n == 0, returns 0.  Else returns the lowest prime number that
+// is greater than or equal to n.
+//
+// The algorithm creates a list of small primes, plus an open-ended list of
+// potential primes.  All prime numbers are potential prime numbers.  However
+// some potential prime numbers are not prime.  In an ideal world, all potential
+// prime numbers would be prime.  Candidate prime numbers are chosen as the next
+// highest potential prime.  Then this number is tested for prime by dividing it
+// by all potential prime numbers less than the sqrt of the candidate.
+//
+// This implementation defines potential primes as those numbers not divisible
+// by 2, 3, 5, and 7.  Other (common) implementations define potential primes
+// as those not divisible by 2.  A few other implementations define potential
+// primes as those not divisible by 2 or 3.  By raising the number of small
+// primes which the potential prime is not divisible by, the set of potential
+// primes more closely approximates the set of prime numbers.  And thus there
+// are fewer potential primes to search, and fewer potential primes to divide
+// against.
+
+template <size_t _Sz = sizeof(size_t)>
+inline _LIBCPP_HIDE_FROM_ABI typename enable_if<_Sz == 4, void>::type __check_for_overflow(size_t N) {
+  if (N > 0xFFFFFFFB)
+    __throw_overflow_error("__next_prime overflow");
+}
+
+template <size_t _Sz = sizeof(size_t)>
+inline _LIBCPP_HIDE_FROM_ABI typename enable_if<_Sz == 8, void>::type __check_for_overflow(size_t N) {
+  if (N > 0xFFFFFFFFFFFFFFC5ull)
+    __throw_overflow_error("__next_prime overflow");
+}
+
+size_t __next_prime(size_t n) {
+  const size_t L = 210;
+  const size_t N = sizeof(small_primes) / sizeof(small_primes[0]);
+  // If n is small enough, search in small_primes
+  if (n <= small_primes[N - 1])
+    return *std::lower_bound(small_primes, small_primes + N, n);
+  // Else n > largest small_primes
+  // Check for overflow
+  __check_for_overflow(n);
+  // Start searching list of potential primes: L * k0 + indices[in]
+  const size_t M = sizeof(indices) / sizeof(indices[0]);
+  // Select first potential prime >= n
+  //   Known a-priori n >= L
+  size_t k0 = n / L;
+  size_t in = static_cast<size_t>(std::lower_bound(indices, indices + M, n - k0 * L) - indices);
+  n         = L * k0 + indices[in];
+  while (true) {
+    // Divide n by all primes or potential primes (i) until:
+    //    1.  The division is even, so try next potential prime.
+    //    2.  The i > sqrt(n), in which case n is prime.
+    // It is known a-priori that n is not divisible by 2, 3, 5 or 7,
+    //    so don't test those (j == 5 ->  divide by 11 first).  And the
+    //    potential primes start with 211, so don't test against the last
+    //    small prime.
+    for (size_t j = 5; j < N - 1; ++j) {
+      const std::size_t p = small_primes[j];
+      const std::size_t q = n / p;
+      if (q < p)
+        return n;
+      if (n == q * p)
+        goto next;
+    }
+    // n wasn't divisible by small primes, try potential primes
+    {
+      size_t i = 211;
+      while (true) {
+        std::size_t q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 10;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 8;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 8;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 6;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 4;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 2;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        i += 10;
+        q = n / i;
+        if (q < i)
+          return n;
+        if (n == q * i)
+          break;
+
+        // This will loop i to the next "plane" of potential primes
+        i += 2;
+      }
+    }
+  next:
+    // n is not prime.  Increment n to next potential prime.
+    if (++in == M) {
+      ++k0;
+      in = 0;
+    }
+    n = L * k0 + indices[in];
+  }
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/initializer_list b/third_party/libcxx/initializer_list
index d97572214..680ca1cd2 100644
--- a/third_party/libcxx/initializer_list
+++ b/third_party/libcxx/initializer_list
@@ -42,7 +42,6 @@ template<class E> const E* end(initializer_list<E> il) noexcept; // constexpr in
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <cstddef>
 
@@ -50,65 +49,46 @@ template<class E> const E* end(initializer_list<E> il) noexcept; // constexpr in
 #  pragma GCC system_header
 #endif
 
-namespace std  // purposefully not versioned
+namespace std // purposefully not versioned
 {
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template<class _Ep>
-class _LIBCPP_TEMPLATE_VIS initializer_list
-{
-    const _Ep* __begin_;
-    size_t    __size_;
+template <class _Ep>
+class _LIBCPP_TEMPLATE_VIS initializer_list {
+  const _Ep* __begin_;
+  size_t __size_;
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 initializer_list(const _Ep* __b, size_t __s) _NOEXCEPT
+      : __begin_(__b),
+        __size_(__s) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX14
-    initializer_list(const _Ep* __b, size_t __s) _NOEXCEPT
-        : __begin_(__b),
-          __size_(__s)
-        {}
 public:
-    typedef _Ep        value_type;
-    typedef const _Ep& reference;
-    typedef const _Ep& const_reference;
-    typedef size_t    size_type;
+  typedef _Ep value_type;
+  typedef const _Ep& reference;
+  typedef const _Ep& const_reference;
+  typedef size_t size_type;
 
-    typedef const _Ep* iterator;
-    typedef const _Ep* const_iterator;
+  typedef const _Ep* iterator;
+  typedef const _Ep* const_iterator;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX14
-    initializer_list() _NOEXCEPT : __begin_(nullptr), __size_(0) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 initializer_list() _NOEXCEPT : __begin_(nullptr), __size_(0) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX14
-    size_t    size()  const _NOEXCEPT {return __size_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 size_t size() const _NOEXCEPT { return __size_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const _Ep* begin() const _NOEXCEPT {return __begin_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Ep* begin() const _NOEXCEPT { return __begin_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const _Ep* end()   const _NOEXCEPT {return __begin_ + __size_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Ep* end() const _NOEXCEPT { return __begin_ + __size_; }
 };
 
-template<class _Ep>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX14
-const _Ep*
-begin(initializer_list<_Ep> __il) _NOEXCEPT
-{
-    return __il.begin();
+template <class _Ep>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Ep* begin(initializer_list<_Ep> __il) _NOEXCEPT {
+  return __il.begin();
 }
 
-template<class _Ep>
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR_SINCE_CXX14
-const _Ep*
-end(initializer_list<_Ep> __il) _NOEXCEPT
-{
-    return __il.end();
+template <class _Ep>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Ep* end(initializer_list<_Ep> __il) _NOEXCEPT {
+  return __il.end();
 }
 
 #endif // !defined(_LIBCPP_CXX03_LANG)
diff --git a/third_party/libcxx/inttypes.h b/third_party/libcxx/inttypes.h
index b755526b8..8664412bd 100644
--- a/third_party/libcxx/inttypes.h
+++ b/third_party/libcxx/inttypes.h
@@ -12,7 +12,7 @@
 // is defined until an inclusion of it without _STD_TYPES_T occurs, in which
 // case the header guard macro is defined.
 #if !defined(_AIX) || !defined(_STD_TYPES_T)
-#define _LIBCPP_INTTYPES_H
+#  define _LIBCPP_INTTYPES_H
 #endif // _STD_TYPES_T
 
 /*
@@ -245,7 +245,7 @@ uintmax_t wcstoumax(const wchar_t* restrict nptr, wchar_t** restrict endptr, int
    for C++11 unless __STDC_FORMAT_MACROS is defined
 */
 #if defined(__cplusplus) && !defined(__STDC_FORMAT_MACROS)
-#   define __STDC_FORMAT_MACROS
+#  define __STDC_FORMAT_MACROS
 #endif
 
 #if __has_include_next(<inttypes.h>)
@@ -254,10 +254,10 @@ uintmax_t wcstoumax(const wchar_t* restrict nptr, wchar_t** restrict endptr, int
 
 #ifdef __cplusplus
 
-#include <stdint.h>
+#  include <stdint.h>
 
-#undef imaxabs
-#undef imaxdiv
+#  undef imaxabs
+#  undef imaxdiv
 
 #endif // __cplusplus
 
diff --git a/third_party/libcxx/iomanip b/third_party/libcxx/iomanip
index 53445c72b..fb4f15b9a 100644
--- a/third_party/libcxx/iomanip
+++ b/third_party/libcxx/iomanip
@@ -42,7 +42,6 @@ template <class charT, class traits, class Allocator>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <istream>
 #include <version>
@@ -55,601 +54,485 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // resetiosflags
 
-class __iom_t1
-{
-    ios_base::fmtflags __mask_;
+class __iom_t1 {
+  ios_base::fmtflags __mask_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __iom_t1(ios_base::fmtflags __m) : __mask_(__m) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __iom_t1(ios_base::fmtflags __m) : __mask_(__m) {}
 
-    template <class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t1& __x)
-    {
-        __is.unsetf(__x.__mask_);
-        return __is;
-    }
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t1& __x) {
+    __is.unsetf(__x.__mask_);
+    return __is;
+  }
 
-    template <class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t1& __x)
-    {
-        __os.unsetf(__x.__mask_);
-        return __os;
-    }
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t1& __x) {
+    __os.unsetf(__x.__mask_);
+    return __os;
+  }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
-__iom_t1
-resetiosflags(ios_base::fmtflags __mask)
-{
-    return __iom_t1(__mask);
-}
+inline _LIBCPP_HIDE_FROM_ABI __iom_t1 resetiosflags(ios_base::fmtflags __mask) { return __iom_t1(__mask); }
 
 // setiosflags
 
-class __iom_t2
-{
-    ios_base::fmtflags __mask_;
+class __iom_t2 {
+  ios_base::fmtflags __mask_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __iom_t2(ios_base::fmtflags __m) : __mask_(__m) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __iom_t2(ios_base::fmtflags __m) : __mask_(__m) {}
 
-    template <class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t2& __x)
-    {
-        __is.setf(__x.__mask_);
-        return __is;
-    }
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t2& __x) {
+    __is.setf(__x.__mask_);
+    return __is;
+  }
 
-    template <class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t2& __x)
-    {
-        __os.setf(__x.__mask_);
-        return __os;
-    }
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t2& __x) {
+    __os.setf(__x.__mask_);
+    return __os;
+  }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
-__iom_t2
-setiosflags(ios_base::fmtflags __mask)
-{
-    return __iom_t2(__mask);
-}
+inline _LIBCPP_HIDE_FROM_ABI __iom_t2 setiosflags(ios_base::fmtflags __mask) { return __iom_t2(__mask); }
 
 // setbase
 
-class __iom_t3
-{
-    int __base_;
+class __iom_t3 {
+  int __base_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __iom_t3(int __b) : __base_(__b) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __iom_t3(int __b) : __base_(__b) {}
 
-    template <class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t3& __x)
-    {
-        __is.setf(__x.__base_ == 8  ? ios_base::oct :
-                  __x.__base_ == 10 ? ios_base::dec :
-                  __x.__base_ == 16 ? ios_base::hex :
-                  ios_base::fmtflags(0), ios_base::basefield);
-        return __is;
-    }
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t3& __x) {
+    __is.setf(__x.__base_ == 8    ? ios_base::oct
+              : __x.__base_ == 10 ? ios_base::dec
+              : __x.__base_ == 16 ? ios_base::hex
+                                  : ios_base::fmtflags(0),
+              ios_base::basefield);
+    return __is;
+  }
 
-    template <class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t3& __x)
-    {
-        __os.setf(__x.__base_ == 8  ? ios_base::oct :
-                  __x.__base_ == 10 ? ios_base::dec :
-                  __x.__base_ == 16 ? ios_base::hex :
-                  ios_base::fmtflags(0), ios_base::basefield);
-        return __os;
-    }
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t3& __x) {
+    __os.setf(__x.__base_ == 8    ? ios_base::oct
+              : __x.__base_ == 10 ? ios_base::dec
+              : __x.__base_ == 16 ? ios_base::hex
+                                  : ios_base::fmtflags(0),
+              ios_base::basefield);
+    return __os;
+  }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
-__iom_t3
-setbase(int __base)
-{
-    return __iom_t3(__base);
-}
+inline _LIBCPP_HIDE_FROM_ABI __iom_t3 setbase(int __base) { return __iom_t3(__base); }
 
 // setfill
 
-template<class _CharT>
-class __iom_t4
-{
-    _CharT __fill_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __iom_t4(_CharT __c) : __fill_(__c) {}
+template <class _CharT>
+class __iom_t4 {
+  _CharT __fill_;
 
-    template <class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t4& __x)
-    {
-        __os.fill(__x.__fill_);
-        return __os;
-    }
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit __iom_t4(_CharT __c) : __fill_(__c) {}
+
+  template <class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t4& __x) {
+    __os.fill(__x.__fill_);
+    return __os;
+  }
 };
 
-template<class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-__iom_t4<_CharT>
-setfill(_CharT __c)
-{
-    return __iom_t4<_CharT>(__c);
+template <class _CharT>
+inline _LIBCPP_HIDE_FROM_ABI __iom_t4<_CharT> setfill(_CharT __c) {
+  return __iom_t4<_CharT>(__c);
 }
 
 // setprecision
 
-class __iom_t5
-{
-    int __n_;
+class __iom_t5 {
+  int __n_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __iom_t5(int __n) : __n_(__n) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __iom_t5(int __n) : __n_(__n) {}
 
-    template <class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t5& __x)
-    {
-        __is.precision(__x.__n_);
-        return __is;
-    }
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t5& __x) {
+    __is.precision(__x.__n_);
+    return __is;
+  }
 
-    template <class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t5& __x)
-    {
-        __os.precision(__x.__n_);
-        return __os;
-    }
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t5& __x) {
+    __os.precision(__x.__n_);
+    return __os;
+  }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
-__iom_t5
-setprecision(int __n)
-{
-    return __iom_t5(__n);
-}
+inline _LIBCPP_HIDE_FROM_ABI __iom_t5 setprecision(int __n) { return __iom_t5(__n); }
 
 // setw
 
-class __iom_t6
-{
-    int __n_;
+class __iom_t6 {
+  int __n_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __iom_t6(int __n) : __n_(__n) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __iom_t6(int __n) : __n_(__n) {}
 
-    template <class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t6& __x)
-    {
-        __is.width(__x.__n_);
-        return __is;
-    }
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t6& __x) {
+    __is.width(__x.__n_);
+    return __is;
+  }
 
-    template <class _CharT, class _Traits>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t6& __x)
-    {
-        __os.width(__x.__n_);
-        return __os;
-    }
+  template <class _CharT, class _Traits>
+  friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t6& __x) {
+    __os.width(__x.__n_);
+    return __os;
+  }
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
-__iom_t6
-setw(int __n)
-{
-    return __iom_t6(__n);
-}
+inline _LIBCPP_HIDE_FROM_ABI __iom_t6 setw(int __n) { return __iom_t6(__n); }
 
 // get_money
 
-template <class _MoneyT> class __iom_t7;
+template <class _MoneyT>
+class __iom_t7;
 
 template <class _CharT, class _Traits, class _MoneyT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x);
 
 template <class _MoneyT>
-class __iom_t7
-{
-    _MoneyT& __mon_;
-    bool __intl_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    __iom_t7(_MoneyT& __mon, bool __intl)
-        : __mon_(__mon), __intl_(__intl) {}
+class __iom_t7 {
+  _MoneyT& __mon_;
+  bool __intl_;
 
-    template <class _CharT, class _Traits, class _Mp>
-    friend
-    basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_Mp>& __x);
+public:
+  _LIBCPP_HIDE_FROM_ABI __iom_t7(_MoneyT& __mon, bool __intl) : __mon_(__mon), __intl_(__intl) {}
+
+  template <class _CharT, class _Traits, class _Mp>
+  friend basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_Mp>& __x);
 };
 
 template <class _CharT, class _Traits, class _MoneyT>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x)
-{
+operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t7<_MoneyT>& __x) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
+  try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        typename basic_istream<_CharT, _Traits>::sentry __s(__is);
-        if (__s)
-        {
-            typedef istreambuf_iterator<_CharT, _Traits> _Ip;
-            typedef money_get<_CharT, _Ip> _Fp;
-            ios_base::iostate __err = ios_base::goodbit;
-            const _Fp& __mf = std::use_facet<_Fp>(__is.getloc());
-            __mf.get(_Ip(__is), _Ip(), __x.__intl_, __is, __err, __x.__mon_);
-            __is.setstate(__err);
-        }
+    typename basic_istream<_CharT, _Traits>::sentry __s(__is);
+    if (__s) {
+      typedef istreambuf_iterator<_CharT, _Traits> _Ip;
+      typedef money_get<_CharT, _Ip> _Fp;
+      ios_base::iostate __err = ios_base::goodbit;
+      const _Fp& __mf         = std::use_facet<_Fp>(__is.getloc());
+      __mf.get(_Ip(__is), _Ip(), __x.__intl_, __is, __err, __x.__mon_);
+      __is.setstate(__err);
+    }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __is.__set_badbit_and_consider_rethrow();
-    }
+  } catch (...) {
+    __is.__set_badbit_and_consider_rethrow();
+  }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return __is;
+  return __is;
 }
 
 template <class _MoneyT>
-inline _LIBCPP_INLINE_VISIBILITY
-__iom_t7<_MoneyT>
-get_money(_MoneyT& __mon, bool __intl = false)
-{
-    return __iom_t7<_MoneyT>(__mon, __intl);
+inline _LIBCPP_HIDE_FROM_ABI __iom_t7<_MoneyT> get_money(_MoneyT& __mon, bool __intl = false) {
+  return __iom_t7<_MoneyT>(__mon, __intl);
 }
 
 // put_money
 
-template <class _MoneyT> class __iom_t8;
+template <class _MoneyT>
+class __iom_t8;
 
 template <class _CharT, class _Traits, class _MoneyT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x);
 
 template <class _MoneyT>
-class __iom_t8
-{
-    const _MoneyT& __mon_;
-    bool __intl_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    __iom_t8(const _MoneyT& __mon, bool __intl)
-        : __mon_(__mon), __intl_(__intl) {}
+class __iom_t8 {
+  const _MoneyT& __mon_;
+  bool __intl_;
 
-    template <class _CharT, class _Traits, class _Mp>
-    friend
-    basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_Mp>& __x);
+public:
+  _LIBCPP_HIDE_FROM_ABI __iom_t8(const _MoneyT& __mon, bool __intl) : __mon_(__mon), __intl_(__intl) {}
+
+  template <class _CharT, class _Traits, class _Mp>
+  friend basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_Mp>& __x);
 };
 
 template <class _CharT, class _Traits, class _MoneyT>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x)
-{
+operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t8<_MoneyT>& __x) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
+  try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
-        if (__s)
-        {
-            typedef ostreambuf_iterator<_CharT, _Traits> _Op;
-            typedef money_put<_CharT, _Op> _Fp;
-            const _Fp& __mf = std::use_facet<_Fp>(__os.getloc());
-            if (__mf.put(_Op(__os), __x.__intl_, __os, __os.fill(), __x.__mon_).failed())
-                __os.setstate(ios_base::badbit);
-        }
+    typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
+    if (__s) {
+      typedef ostreambuf_iterator<_CharT, _Traits> _Op;
+      typedef money_put<_CharT, _Op> _Fp;
+      const _Fp& __mf = std::use_facet<_Fp>(__os.getloc());
+      if (__mf.put(_Op(__os), __x.__intl_, __os, __os.fill(), __x.__mon_).failed())
+        __os.setstate(ios_base::badbit);
+    }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __os.__set_badbit_and_consider_rethrow();
-    }
+  } catch (...) {
+    __os.__set_badbit_and_consider_rethrow();
+  }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return __os;
+  return __os;
 }
 
 template <class _MoneyT>
-inline _LIBCPP_INLINE_VISIBILITY
-__iom_t8<_MoneyT>
-put_money(const _MoneyT& __mon, bool __intl = false)
-{
-    return __iom_t8<_MoneyT>(__mon, __intl);
+inline _LIBCPP_HIDE_FROM_ABI __iom_t8<_MoneyT> put_money(const _MoneyT& __mon, bool __intl = false) {
+  return __iom_t8<_MoneyT>(__mon, __intl);
 }
 
 // get_time
 
-template <class _CharT> class __iom_t9;
+template <class _CharT>
+class __iom_t9;
 
 template <class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x);
 
 template <class _CharT>
-class __iom_t9
-{
-    tm* __tm_;
-    const _CharT* __fmt_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    __iom_t9(tm* __tm, const _CharT* __fmt)
-        : __tm_(__tm), __fmt_(__fmt) {}
+class __iom_t9 {
+  tm* __tm_;
+  const _CharT* __fmt_;
 
-    template <class _Cp, class _Traits>
-    friend
-    basic_istream<_Cp, _Traits>&
-    operator>>(basic_istream<_Cp, _Traits>& __is, const __iom_t9<_Cp>& __x);
+public:
+  _LIBCPP_HIDE_FROM_ABI __iom_t9(tm* __tm, const _CharT* __fmt) : __tm_(__tm), __fmt_(__fmt) {}
+
+  template <class _Cp, class _Traits>
+  friend basic_istream<_Cp, _Traits>& operator>>(basic_istream<_Cp, _Traits>& __is, const __iom_t9<_Cp>& __x);
 };
 
 template <class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x)
-{
+operator>>(basic_istream<_CharT, _Traits>& __is, const __iom_t9<_CharT>& __x) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
+  try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        typename basic_istream<_CharT, _Traits>::sentry __s(__is);
-        if (__s)
-        {
-            typedef istreambuf_iterator<_CharT, _Traits> _Ip;
-            typedef time_get<_CharT, _Ip> _Fp;
-            ios_base::iostate __err = ios_base::goodbit;
-            const _Fp& __tf = std::use_facet<_Fp>(__is.getloc());
-            __tf.get(_Ip(__is), _Ip(), __is, __err, __x.__tm_,
-                     __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_));
-            __is.setstate(__err);
-        }
+    typename basic_istream<_CharT, _Traits>::sentry __s(__is);
+    if (__s) {
+      typedef istreambuf_iterator<_CharT, _Traits> _Ip;
+      typedef time_get<_CharT, _Ip> _Fp;
+      ios_base::iostate __err = ios_base::goodbit;
+      const _Fp& __tf         = std::use_facet<_Fp>(__is.getloc());
+      __tf.get(_Ip(__is), _Ip(), __is, __err, __x.__tm_, __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_));
+      __is.setstate(__err);
+    }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __is.__set_badbit_and_consider_rethrow();
-    }
+  } catch (...) {
+    __is.__set_badbit_and_consider_rethrow();
+  }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return __is;
+  return __is;
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-__iom_t9<_CharT>
-get_time(tm* __tm, const _CharT* __fmt)
-{
-    return __iom_t9<_CharT>(__tm, __fmt);
+inline _LIBCPP_HIDE_FROM_ABI __iom_t9<_CharT> get_time(tm* __tm, const _CharT* __fmt) {
+  return __iom_t9<_CharT>(__tm, __fmt);
 }
 
 // put_time
 
-template <class _CharT> class __iom_t10;
+template <class _CharT>
+class __iom_t10;
 
 template <class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x);
 
 template <class _CharT>
-class __iom_t10
-{
-    const tm* __tm_;
-    const _CharT* __fmt_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    __iom_t10(const tm* __tm, const _CharT* __fmt)
-        : __tm_(__tm), __fmt_(__fmt) {}
+class __iom_t10 {
+  const tm* __tm_;
+  const _CharT* __fmt_;
 
-    template <class _Cp, class _Traits>
-    friend
-    basic_ostream<_Cp, _Traits>&
-    operator<<(basic_ostream<_Cp, _Traits>& __os, const __iom_t10<_Cp>& __x);
+public:
+  _LIBCPP_HIDE_FROM_ABI __iom_t10(const tm* __tm, const _CharT* __fmt) : __tm_(__tm), __fmt_(__fmt) {}
+
+  template <class _Cp, class _Traits>
+  friend basic_ostream<_Cp, _Traits>& operator<<(basic_ostream<_Cp, _Traits>& __os, const __iom_t10<_Cp>& __x);
 };
 
 template <class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x)
-{
+operator<<(basic_ostream<_CharT, _Traits>& __os, const __iom_t10<_CharT>& __x) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
+  try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
-        if (__s)
-        {
-            typedef ostreambuf_iterator<_CharT, _Traits> _Op;
-            typedef time_put<_CharT, _Op> _Fp;
-            const _Fp& __tf = std::use_facet<_Fp>(__os.getloc());
-            if (__tf.put(_Op(__os), __os, __os.fill(), __x.__tm_,
-                         __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_)).failed())
-                __os.setstate(ios_base::badbit);
-        }
+    typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
+    if (__s) {
+      typedef ostreambuf_iterator<_CharT, _Traits> _Op;
+      typedef time_put<_CharT, _Op> _Fp;
+      const _Fp& __tf = std::use_facet<_Fp>(__os.getloc());
+      if (__tf.put(_Op(__os), __os, __os.fill(), __x.__tm_, __x.__fmt_, __x.__fmt_ + _Traits::length(__x.__fmt_))
+              .failed())
+        __os.setstate(ios_base::badbit);
+    }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __os.__set_badbit_and_consider_rethrow();
-    }
+  } catch (...) {
+    __os.__set_badbit_and_consider_rethrow();
+  }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return __os;
+  return __os;
 }
 
 template <class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-__iom_t10<_CharT>
-put_time(const tm* __tm, const _CharT* __fmt)
-{
-    return __iom_t10<_CharT>(__tm, __fmt);
+inline _LIBCPP_HIDE_FROM_ABI __iom_t10<_CharT> put_time(const tm* __tm, const _CharT* __fmt) {
+  return __iom_t10<_CharT>(__tm, __fmt);
 }
 
 template <class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-__quoted_output(basic_ostream<_CharT, _Traits>& __os,
-                const _CharT *__first, const _CharT *__last, _CharT __delim, _CharT __escape)
-{
-    basic_string<_CharT, _Traits> __str;
-    __str.push_back(__delim);
-    for (; __first != __last; ++__first) {
-        if (_Traits::eq(*__first, __escape) || _Traits::eq(*__first, __delim))
-            __str.push_back(__escape);
-        __str.push_back(*__first);
-    }
-    __str.push_back(__delim);
-    return _VSTD::__put_character_sequence(__os, __str.data(), __str.size());
+_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& __quoted_output(
+    basic_ostream<_CharT, _Traits>& __os,
+    const _CharT* __first,
+    const _CharT* __last,
+    _CharT __delim,
+    _CharT __escape) {
+  basic_string<_CharT, _Traits> __str;
+  __str.push_back(__delim);
+  for (; __first != __last; ++__first) {
+    if (_Traits::eq(*__first, __escape) || _Traits::eq(*__first, __delim))
+      __str.push_back(__escape);
+    __str.push_back(*__first);
+  }
+  __str.push_back(__delim);
+  return std::__put_character_sequence(__os, __str.data(), __str.size());
 }
 
 template <class _CharT, class _Traits, class _String>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-__quoted_input(basic_istream<_CharT, _Traits>& __is, _String& __string, _CharT __delim, _CharT __escape)
-{
-    __string.clear();
-    _CharT __c;
+__quoted_input(basic_istream<_CharT, _Traits>& __is, _String& __string, _CharT __delim, _CharT __escape) {
+  __string.clear();
+  _CharT __c;
+  __is >> __c;
+  if (__is.fail())
+    return __is;
+
+  if (!_Traits::eq(__c, __delim)) {
+    // no delimiter, read the whole string
+    __is.unget();
+    __is >> __string;
+    return __is;
+  }
+
+  __save_flags<_CharT, _Traits> __sf(__is);
+  std::noskipws(__is);
+  while (true) {
     __is >> __c;
     if (__is.fail())
-        return __is;
-
-    if (!_Traits::eq(__c, __delim)) {
-        // no delimiter, read the whole string
-        __is.unget();
-        __is >> __string;
-        return __is;
-    }
-
-    __save_flags<_CharT, _Traits> __sf(__is);
-    std::noskipws(__is);
-    while (true) {
-        __is >> __c;
-        if (__is.fail())
-            break;
-        if (_Traits::eq(__c, __escape)) {
-            __is >> __c;
-            if (__is.fail())
-                break;
-        } else if (_Traits::eq(__c, __delim))
-            break;
-        __string.push_back(__c);
-    }
-    return __is;
+      break;
+    if (_Traits::eq(__c, __escape)) {
+      __is >> __c;
+      if (__is.fail())
+        break;
+    } else if (_Traits::eq(__c, __delim))
+      break;
+    __string.push_back(__c);
+  }
+  return __is;
 }
 
 template <class _CharT, class _Traits>
-struct _LIBCPP_HIDDEN __quoted_output_proxy
-{
-    const _CharT *__first_;
-    const _CharT *__last_;
-    _CharT __delim_;
-    _CharT __escape_;
+struct _LIBCPP_HIDDEN __quoted_output_proxy {
+  const _CharT* __first_;
+  const _CharT* __last_;
+  _CharT __delim_;
+  _CharT __escape_;
 
-    _LIBCPP_HIDE_FROM_ABI
-    explicit __quoted_output_proxy(const _CharT *__f, const _CharT *__l, _CharT __d, _CharT __e)
-        : __first_(__f), __last_(__l), __delim_(__d), __escape_(__e) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __quoted_output_proxy(const _CharT* __f, const _CharT* __l, _CharT __d, _CharT __e)
+      : __first_(__f), __last_(__l), __delim_(__d), __escape_(__e) {}
 
-    template<class _T2, __enable_if_t<_IsSame<_Traits, void>::value || _IsSame<_Traits, _T2>::value>* = nullptr>
-    friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _T2>&
-    operator<<(basic_ostream<_CharT, _T2>& __os, const __quoted_output_proxy& __p) {
-        return std::__quoted_output(__os, __p.__first_, __p.__last_, __p.__delim_, __p.__escape_);
-    }
+  template <class _T2, __enable_if_t<_IsSame<_Traits, void>::value || _IsSame<_Traits, _T2>::value, int> = 0>
+  friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _T2>&
+  operator<<(basic_ostream<_CharT, _T2>& __os, const __quoted_output_proxy& __p) {
+    return std::__quoted_output(__os, __p.__first_, __p.__last_, __p.__delim_, __p.__escape_);
+  }
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-struct _LIBCPP_HIDDEN __quoted_proxy
-{
-    basic_string<_CharT, _Traits, _Allocator>& __string_;
-    _CharT __delim_;
-    _CharT __escape_;
+struct _LIBCPP_HIDDEN __quoted_proxy {
+  basic_string<_CharT, _Traits, _Allocator>& __string_;
+  _CharT __delim_;
+  _CharT __escape_;
 
-    _LIBCPP_HIDE_FROM_ABI
-    explicit __quoted_proxy(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __d, _CharT __e)
-        : __string_(__s), __delim_(__d), __escape_(__e) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __quoted_proxy(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __d, _CharT __e)
+      : __string_(__s), __delim_(__d), __escape_(__e) {}
 
-    friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-    operator<<(basic_ostream<_CharT, _Traits>& __os, const __quoted_proxy& __p) {
-        return std::__quoted_output(__os, __p.__string_.data(), __p.__string_.data() + __p.__string_.size(), __p.__delim_, __p.__escape_);
-    }
+  friend _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
+  operator<<(basic_ostream<_CharT, _Traits>& __os, const __quoted_proxy& __p) {
+    return std::__quoted_output(
+        __os, __p.__string_.data(), __p.__string_.data() + __p.__string_.size(), __p.__delim_, __p.__escape_);
+  }
 
-    friend _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-    operator>>(basic_istream<_CharT, _Traits>& __is, const __quoted_proxy& __p) {
-        return std::__quoted_input(__is, __p.__string_, __p.__delim_, __p.__escape_);
-    }
+  friend _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+  operator>>(basic_istream<_CharT, _Traits>& __is, const __quoted_proxy& __p) {
+    return std::__quoted_input(__is, __p.__string_, __p.__delim_, __p.__escape_);
+  }
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI
-__quoted_output_proxy<_CharT, _Traits>
-__quoted(const basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
-{
-    return __quoted_output_proxy<_CharT, _Traits>(__s.data(), __s.data() + __s.size(), __delim, __escape);
+_LIBCPP_HIDE_FROM_ABI __quoted_output_proxy<_CharT, _Traits>
+__quoted(const basic_string<_CharT, _Traits, _Allocator>& __s,
+         _CharT __delim  = _CharT('"'),
+         _CharT __escape = _CharT('\\')) {
+  return __quoted_output_proxy<_CharT, _Traits>(__s.data(), __s.data() + __s.size(), __delim, __escape);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI
-__quoted_proxy<_CharT, _Traits, _Allocator>
-__quoted(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
-{
-    return __quoted_proxy<_CharT, _Traits, _Allocator>(__s, __delim, __escape);
+_LIBCPP_HIDE_FROM_ABI __quoted_proxy<_CharT, _Traits, _Allocator>
+__quoted(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) {
+  return __quoted_proxy<_CharT, _Traits, _Allocator>(__s, __delim, __escape);
 }
 
 #if _LIBCPP_STD_VER >= 14
 
 template <class _CharT>
-_LIBCPP_HIDE_FROM_ABI
-auto quoted(const _CharT *__s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
-{
-    const _CharT *__end = __s;
-    while (*__end) ++__end;
-    return __quoted_output_proxy<_CharT, void>(__s, __end, __delim, __escape);
+_LIBCPP_HIDE_FROM_ABI auto quoted(const _CharT* __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) {
+  const _CharT* __end = __s;
+  while (*__end)
+    ++__end;
+  return __quoted_output_proxy<_CharT, void>(__s, __end, __delim, __escape);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI
-auto quoted(const basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
-{
-    return __quoted_output_proxy<_CharT, _Traits>(__s.data(), __s.data() + __s.size(), __delim, __escape);
+_LIBCPP_HIDE_FROM_ABI auto
+quoted(const basic_string<_CharT, _Traits, _Allocator>& __s,
+       _CharT __delim  = _CharT('"'),
+       _CharT __escape = _CharT('\\')) {
+  return __quoted_output_proxy<_CharT, _Traits>(__s.data(), __s.data() + __s.size(), __delim, __escape);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI
-auto quoted(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
-{
-    return __quoted_proxy<_CharT, _Traits, _Allocator>(__s, __delim, __escape);
+_LIBCPP_HIDE_FROM_ABI auto
+quoted(basic_string<_CharT, _Traits, _Allocator>& __s, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) {
+  return __quoted_proxy<_CharT, _Traits, _Allocator>(__s, __delim, __escape);
 }
 
 template <class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI
-auto quoted(basic_string_view<_CharT, _Traits> __sv, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
-{
-    return __quoted_output_proxy<_CharT, _Traits>(__sv.data(), __sv.data() + __sv.size(), __delim, __escape);
+_LIBCPP_HIDE_FROM_ABI auto
+quoted(basic_string_view<_CharT, _Traits> __sv, _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\')) {
+  return __quoted_output_proxy<_CharT, _Traits>(__sv.data(), __sv.data() + __sv.size(), __delim, __escape);
 }
 
 #endif // _LIBCPP_STD_VER >= 14
diff --git a/third_party/libcxx/ios b/third_party/libcxx/ios
index 5464ba58f..92c32f203 100644
--- a/third_party/libcxx/ios
+++ b/third_party/libcxx/ios
@@ -13,6 +13,7 @@
 /*
     ios synopsis
 
+#include "third_party/libcxx/__system_error/error_code.h"
 #include <iosfwd>
 
 namespace std
@@ -58,6 +59,7 @@ public:
     static constexpr openmode ate;
     static constexpr openmode binary;
     static constexpr openmode in;
+    static constexpr openmode noreplace; // since C++23
     static constexpr openmode out;
     static constexpr openmode trunc;
 
@@ -212,842 +214,663 @@ storage-class-specifier const error_category& iostream_category() noexcept;
 
 #include <__config>
 
-#if defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   error "The iostreams library is not supported since libc++ has been configured without support for localization."
-#endif
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__fwd/ios.h>
-#include <__ios/fpos.h>
-#include <__locale>
-#include <__system_error/error_category.h>
-#include <__system_error/error_code.h>
-#include <__system_error/error_condition.h>
-#include <__system_error/system_error.h>
-#include <__utility/swap.h>
-#include <__verbose_abort>
-#include <version>
+#  include <__fwd/ios.h>
+#  include <__ios/fpos.h>
+#  include <__locale>
+#  include <__system_error/error_category.h>
+#  include <__system_error/error_code.h>
+#  include <__system_error/error_condition.h>
+#  include <__system_error/system_error.h>
+#  include <__utility/swap.h>
+#  include <__verbose_abort>
+#  include <version>
 
 // standard-mandated includes
 
 // [ios.syn]
-#include <iosfwd>
+#  include <iosfwd>
 
-#if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
-#  include <__atomic/atomic.h> // for __xindex_
-#endif
+#  if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
+#    include <__atomic/atomic.h> // for __xindex_
+#  endif
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+_LIBCPP_PUSH_MACROS
+#  include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 typedef ptrdiff_t streamsize;
 
-class _LIBCPP_TYPE_VIS ios_base
-{
+class _LIBCPP_EXPORTED_FROM_ABI ios_base {
 public:
-    class _LIBCPP_EXCEPTION_ABI failure;
+  class _LIBCPP_EXPORTED_FROM_ABI failure;
 
-    typedef unsigned int fmtflags;
-    static const fmtflags boolalpha   = 0x0001;
-    static const fmtflags dec         = 0x0002;
-    static const fmtflags fixed       = 0x0004;
-    static const fmtflags hex         = 0x0008;
-    static const fmtflags internal    = 0x0010;
-    static const fmtflags left        = 0x0020;
-    static const fmtflags oct         = 0x0040;
-    static const fmtflags right       = 0x0080;
-    static const fmtflags scientific  = 0x0100;
-    static const fmtflags showbase    = 0x0200;
-    static const fmtflags showpoint   = 0x0400;
-    static const fmtflags showpos     = 0x0800;
-    static const fmtflags skipws      = 0x1000;
-    static const fmtflags unitbuf     = 0x2000;
-    static const fmtflags uppercase   = 0x4000;
-    static const fmtflags adjustfield = left | right | internal;
-    static const fmtflags basefield   = dec | oct | hex;
-    static const fmtflags floatfield  = scientific | fixed;
+  typedef unsigned int fmtflags;
+  static const fmtflags boolalpha   = 0x0001;
+  static const fmtflags dec         = 0x0002;
+  static const fmtflags fixed       = 0x0004;
+  static const fmtflags hex         = 0x0008;
+  static const fmtflags internal    = 0x0010;
+  static const fmtflags left        = 0x0020;
+  static const fmtflags oct         = 0x0040;
+  static const fmtflags right       = 0x0080;
+  static const fmtflags scientific  = 0x0100;
+  static const fmtflags showbase    = 0x0200;
+  static const fmtflags showpoint   = 0x0400;
+  static const fmtflags showpos     = 0x0800;
+  static const fmtflags skipws      = 0x1000;
+  static const fmtflags unitbuf     = 0x2000;
+  static const fmtflags uppercase   = 0x4000;
+  static const fmtflags adjustfield = left | right | internal;
+  static const fmtflags basefield   = dec | oct | hex;
+  static const fmtflags floatfield  = scientific | fixed;
 
-    typedef unsigned int iostate;
-    static const iostate badbit  = 0x1;
-    static const iostate eofbit  = 0x2;
-    static const iostate failbit = 0x4;
-    static const iostate goodbit = 0x0;
+  typedef unsigned int iostate;
+  static const iostate badbit  = 0x1;
+  static const iostate eofbit  = 0x2;
+  static const iostate failbit = 0x4;
+  static const iostate goodbit = 0x0;
 
-    typedef unsigned int openmode;
-    static const openmode app    = 0x01;
-    static const openmode ate    = 0x02;
-    static const openmode binary = 0x04;
-    static const openmode in     = 0x08;
-    static const openmode out    = 0x10;
-    static const openmode trunc  = 0x20;
+  typedef unsigned int openmode;
+  static const openmode app    = 0x01;
+  static const openmode ate    = 0x02;
+  static const openmode binary = 0x04;
+  static const openmode in     = 0x08;
+  static const openmode out    = 0x10;
+  static const openmode trunc  = 0x20;
+#  if _LIBCPP_STD_VER >= 23
+  static const openmode noreplace = 0x40;
+#  endif
 
-    enum seekdir {beg, cur, end};
+  enum seekdir { beg, cur, end };
 
-#if _LIBCPP_STD_VER <= 14
-    typedef iostate      io_state;
-    typedef openmode     open_mode;
-    typedef seekdir      seek_dir;
+#  if _LIBCPP_STD_VER <= 14
+  typedef iostate io_state;
+  typedef openmode open_mode;
+  typedef seekdir seek_dir;
 
-    typedef _VSTD::streamoff streamoff;
-    typedef _VSTD::streampos streampos;
-#endif
+  typedef std::streamoff streamoff;
+  typedef std::streampos streampos;
+#  endif
 
-    class _LIBCPP_TYPE_VIS Init;
+  class _LIBCPP_EXPORTED_FROM_ABI Init;
 
-    // 27.5.2.2 fmtflags state:
-    _LIBCPP_INLINE_VISIBILITY fmtflags flags() const;
-    _LIBCPP_INLINE_VISIBILITY fmtflags flags(fmtflags __fmtfl);
-    _LIBCPP_INLINE_VISIBILITY fmtflags setf(fmtflags __fmtfl);
-    _LIBCPP_INLINE_VISIBILITY fmtflags setf(fmtflags __fmtfl, fmtflags __mask);
-    _LIBCPP_INLINE_VISIBILITY void unsetf(fmtflags __mask);
+  // 27.5.2.2 fmtflags state:
+  _LIBCPP_HIDE_FROM_ABI fmtflags flags() const;
+  _LIBCPP_HIDE_FROM_ABI fmtflags flags(fmtflags __fmtfl);
+  _LIBCPP_HIDE_FROM_ABI fmtflags setf(fmtflags __fmtfl);
+  _LIBCPP_HIDE_FROM_ABI fmtflags setf(fmtflags __fmtfl, fmtflags __mask);
+  _LIBCPP_HIDE_FROM_ABI void unsetf(fmtflags __mask);
 
-    _LIBCPP_INLINE_VISIBILITY streamsize precision() const;
-    _LIBCPP_INLINE_VISIBILITY streamsize precision(streamsize __prec);
-    _LIBCPP_INLINE_VISIBILITY streamsize width() const;
-    _LIBCPP_INLINE_VISIBILITY streamsize width(streamsize __wide);
+  _LIBCPP_HIDE_FROM_ABI streamsize precision() const;
+  _LIBCPP_HIDE_FROM_ABI streamsize precision(streamsize __prec);
+  _LIBCPP_HIDE_FROM_ABI streamsize width() const;
+  _LIBCPP_HIDE_FROM_ABI streamsize width(streamsize __wide);
 
-    // 27.5.2.3 locales:
-    locale imbue(const locale& __loc);
-    locale getloc() const;
+  // 27.5.2.3 locales:
+  locale imbue(const locale& __loc);
+  locale getloc() const;
 
-    // 27.5.2.5 storage:
-    static int xalloc();
-    long& iword(int __index);
-    void*& pword(int __index);
+  // 27.5.2.5 storage:
+  static int xalloc();
+  long& iword(int __index);
+  void*& pword(int __index);
 
-    // destructor
-    virtual ~ios_base();
+  // destructor
+  virtual ~ios_base();
 
-    // 27.5.2.6 callbacks;
-    enum event { erase_event, imbue_event, copyfmt_event };
-    typedef void (*event_callback)(event, ios_base&, int __index);
-    void register_callback(event_callback __fn, int __index);
+  // 27.5.2.6 callbacks;
+  enum event { erase_event, imbue_event, copyfmt_event };
+  typedef void (*event_callback)(event, ios_base&, int __index);
+  void register_callback(event_callback __fn, int __index);
 
-    ios_base(const ios_base&) = delete;
-    ios_base& operator=(const ios_base&) = delete;
+  ios_base(const ios_base&)            = delete;
+  ios_base& operator=(const ios_base&) = delete;
 
-    static bool sync_with_stdio(bool __sync = true);
+  static bool sync_with_stdio(bool __sync = true);
 
-    _LIBCPP_INLINE_VISIBILITY iostate rdstate() const;
-    void clear(iostate __state = goodbit);
-    _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state);
+  _LIBCPP_HIDE_FROM_ABI iostate rdstate() const;
+  void clear(iostate __state = goodbit);
+  _LIBCPP_HIDE_FROM_ABI void setstate(iostate __state);
 
-    _LIBCPP_INLINE_VISIBILITY bool good() const;
-    _LIBCPP_INLINE_VISIBILITY bool eof() const;
-    _LIBCPP_INLINE_VISIBILITY bool fail() const;
-    _LIBCPP_INLINE_VISIBILITY bool bad() const;
+  _LIBCPP_HIDE_FROM_ABI bool good() const;
+  _LIBCPP_HIDE_FROM_ABI bool eof() const;
+  _LIBCPP_HIDE_FROM_ABI bool fail() const;
+  _LIBCPP_HIDE_FROM_ABI bool bad() const;
 
-    _LIBCPP_INLINE_VISIBILITY iostate exceptions() const;
-    _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate);
+  _LIBCPP_HIDE_FROM_ABI iostate exceptions() const;
+  _LIBCPP_HIDE_FROM_ABI void exceptions(iostate __iostate);
 
-    void __set_badbit_and_consider_rethrow();
-    void __set_failbit_and_consider_rethrow();
+  void __set_badbit_and_consider_rethrow();
+  void __set_failbit_and_consider_rethrow();
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __setstate_nothrow(iostate __state)
-    {
-        if (__rdbuf_)
-            __rdstate_ |= __state;
-        else
-            __rdstate_ |= __state | ios_base::badbit;
-    }
+  _LIBCPP_HIDE_FROM_ABI void __setstate_nothrow(iostate __state) {
+    if (__rdbuf_)
+      __rdstate_ |= __state;
+    else
+      __rdstate_ |= __state | ios_base::badbit;
+  }
 
 protected:
-    _LIBCPP_INLINE_VISIBILITY
-    ios_base() {// purposefully does no initialization
-               }
+  _LIBCPP_HIDE_FROM_ABI ios_base() : __loc_(nullptr) {
+    // Purposefully does no initialization
+    //
+    // Except for the locale, this is a sentinel to avoid destroying
+    // an uninitialized object. See
+    // test/libcxx/input.output/iostreams.base/ios.base/ios.base.cons/dtor.uninitialized.pass.cpp
+    // for the details.
+  }
 
-    void init(void* __sb);
-    _LIBCPP_INLINE_VISIBILITY void* rdbuf() const {return __rdbuf_;}
+  void init(void* __sb);
+  _LIBCPP_HIDE_FROM_ABI void* rdbuf() const { return __rdbuf_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void rdbuf(void* __sb)
-    {
-        __rdbuf_ = __sb;
-        clear();
-    }
+  _LIBCPP_HIDE_FROM_ABI void rdbuf(void* __sb) {
+    __rdbuf_ = __sb;
+    clear();
+  }
 
-    void __call_callbacks(event);
-    void copyfmt(const ios_base&);
-    void move(ios_base&);
-    void swap(ios_base&) _NOEXCEPT;
+  void __call_callbacks(event);
+  void copyfmt(const ios_base&);
+  void move(ios_base&);
+  void swap(ios_base&) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void set_rdbuf(void* __sb)
-    {
-        __rdbuf_ = __sb;
-    }
+  _LIBCPP_HIDE_FROM_ABI void set_rdbuf(void* __sb) { __rdbuf_ = __sb; }
 
 private:
-    // All data members must be scalars
-    fmtflags        __fmtflags_;
-    streamsize      __precision_;
-    streamsize      __width_;
-    iostate         __rdstate_;
-    iostate         __exceptions_;
-    void*           __rdbuf_;
-    void*           __loc_;
-    event_callback* __fn_;
-    int*            __index_;
-    size_t          __event_size_;
-    size_t          __event_cap_;
+  // All data members must be scalars
+  fmtflags __fmtflags_;
+  streamsize __precision_;
+  streamsize __width_;
+  iostate __rdstate_;
+  iostate __exceptions_;
+  void* __rdbuf_;
+  void* __loc_;
+  event_callback* __fn_;
+  int* __index_;
+  size_t __event_size_;
+  size_t __event_cap_;
 // TODO(EricWF): Enable this for both Clang and GCC. Currently it is only
 // enabled with clang.
-#if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
-    static atomic<int> __xindex_;
-#else
-    static int      __xindex_;
-#endif
-    long*           __iarray_;
-    size_t          __iarray_size_;
-    size_t          __iarray_cap_;
-    void**          __parray_;
-    size_t          __parray_size_;
-    size_t          __parray_cap_;
+#  if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
+  static atomic<int> __xindex_;
+#  else
+  static int __xindex_;
+#  endif
+  long* __iarray_;
+  size_t __iarray_size_;
+  size_t __iarray_cap_;
+  void** __parray_;
+  size_t __parray_size_;
+  size_t __parray_cap_;
 };
 
-//enum class io_errc
-_LIBCPP_DECLARE_STRONG_ENUM(io_errc)
-{
-    stream = 1
-};
+// enum class io_errc
+_LIBCPP_DECLARE_STRONG_ENUM(io_errc){stream = 1};
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(io_errc)
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type { };
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc> : public true_type {};
 
-#ifdef _LIBCPP_CXX03_LANG
+#  ifdef _LIBCPP_CXX03_LANG
 template <>
-struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type { };
-#endif
+struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<io_errc::__lx> : public true_type {};
+#  endif
 
-_LIBCPP_FUNC_VIS
-const error_category& iostream_category() _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI const error_category& iostream_category() _NOEXCEPT;
 
-inline _LIBCPP_INLINE_VISIBILITY
-error_code
-make_error_code(io_errc __e) _NOEXCEPT
-{
-    return error_code(static_cast<int>(__e), iostream_category());
+inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(io_errc __e) _NOEXCEPT {
+  return error_code(static_cast<int>(__e), iostream_category());
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-error_condition
-make_error_condition(io_errc __e) _NOEXCEPT
-{
-    return error_condition(static_cast<int>(__e), iostream_category());
+inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(io_errc __e) _NOEXCEPT {
+  return error_condition(static_cast<int>(__e), iostream_category());
 }
 
-class _LIBCPP_EXCEPTION_ABI ios_base::failure
-    : public system_error
-{
+class _LIBCPP_EXPORTED_FROM_ABI ios_base::failure : public system_error {
 public:
-    explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
-    explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
-    _LIBCPP_HIDE_FROM_ABI failure(const failure&) _NOEXCEPT = default;
-    ~failure() _NOEXCEPT override;
+  explicit failure(const string& __msg, const error_code& __ec = io_errc::stream);
+  explicit failure(const char* __msg, const error_code& __ec = io_errc::stream);
+  _LIBCPP_HIDE_FROM_ABI failure(const failure&) _NOEXCEPT = default;
+  ~failure() _NOEXCEPT override;
 };
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_failure(char const* __msg) {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw ios_base::failure(__msg);
-#else
-    _LIBCPP_VERBOSE_ABORT("ios_base::failure was thrown in -fno-exceptions mode with message \"%s\"", __msg);
-#endif
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_failure(char const* __msg) {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw ios_base::failure(__msg);
+#  else
+  _LIBCPP_VERBOSE_ABORT("ios_base::failure was thrown in -fno-exceptions mode with message \"%s\"", __msg);
+#  endif
 }
 
-class _LIBCPP_TYPE_VIS ios_base::Init
-{
+class _LIBCPP_EXPORTED_FROM_ABI ios_base::Init {
 public:
-    Init();
-    ~Init();
+  Init();
+  ~Init();
 };
 
 // fmtflags
 
-inline _LIBCPP_INLINE_VISIBILITY
-ios_base::fmtflags
-ios_base::flags() const
-{
-    return __fmtflags_;
+inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::flags() const { return __fmtflags_; }
+
+inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::flags(fmtflags __fmtfl) {
+  fmtflags __r = __fmtflags_;
+  __fmtflags_  = __fmtfl;
+  return __r;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-ios_base::fmtflags
-ios_base::flags(fmtflags __fmtfl)
-{
-    fmtflags __r = __fmtflags_;
-    __fmtflags_ = __fmtfl;
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::setf(fmtflags __fmtfl) {
+  fmtflags __r = __fmtflags_;
+  __fmtflags_ |= __fmtfl;
+  return __r;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-ios_base::fmtflags
-ios_base::setf(fmtflags __fmtfl)
-{
-    fmtflags __r = __fmtflags_;
-    __fmtflags_ |= __fmtfl;
-    return __r;
-}
+inline _LIBCPP_HIDE_FROM_ABI void ios_base::unsetf(fmtflags __mask) { __fmtflags_ &= ~__mask; }
 
-inline _LIBCPP_INLINE_VISIBILITY
-void
-ios_base::unsetf(fmtflags __mask)
-{
-    __fmtflags_ &= ~__mask;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-ios_base::fmtflags
-ios_base::setf(fmtflags __fmtfl, fmtflags __mask)
-{
-    fmtflags __r = __fmtflags_;
-    unsetf(__mask);
-    __fmtflags_ |= __fmtfl & __mask;
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI ios_base::fmtflags ios_base::setf(fmtflags __fmtfl, fmtflags __mask) {
+  fmtflags __r = __fmtflags_;
+  unsetf(__mask);
+  __fmtflags_ |= __fmtfl & __mask;
+  return __r;
 }
 
 // precision
 
-inline _LIBCPP_INLINE_VISIBILITY
-streamsize
-ios_base::precision() const
-{
-    return __precision_;
-}
+inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::precision() const { return __precision_; }
 
-inline _LIBCPP_INLINE_VISIBILITY
-streamsize
-ios_base::precision(streamsize __prec)
-{
-    streamsize __r = __precision_;
-    __precision_ = __prec;
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::precision(streamsize __prec) {
+  streamsize __r = __precision_;
+  __precision_   = __prec;
+  return __r;
 }
 
 // width
 
-inline _LIBCPP_INLINE_VISIBILITY
-streamsize
-ios_base::width() const
-{
-    return __width_;
-}
+inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::width() const { return __width_; }
 
-inline _LIBCPP_INLINE_VISIBILITY
-streamsize
-ios_base::width(streamsize __wide)
-{
-    streamsize __r = __width_;
-    __width_ = __wide;
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI streamsize ios_base::width(streamsize __wide) {
+  streamsize __r = __width_;
+  __width_       = __wide;
+  return __r;
 }
 
 // iostate
 
-inline _LIBCPP_INLINE_VISIBILITY
-ios_base::iostate
-ios_base::rdstate() const
-{
-    return __rdstate_;
+inline _LIBCPP_HIDE_FROM_ABI ios_base::iostate ios_base::rdstate() const { return __rdstate_; }
+
+inline _LIBCPP_HIDE_FROM_ABI void ios_base::setstate(iostate __state) { clear(__rdstate_ | __state); }
+
+inline _LIBCPP_HIDE_FROM_ABI bool ios_base::good() const { return __rdstate_ == 0; }
+
+inline _LIBCPP_HIDE_FROM_ABI bool ios_base::eof() const { return (__rdstate_ & eofbit) != 0; }
+
+inline _LIBCPP_HIDE_FROM_ABI bool ios_base::fail() const { return (__rdstate_ & (failbit | badbit)) != 0; }
+
+inline _LIBCPP_HIDE_FROM_ABI bool ios_base::bad() const { return (__rdstate_ & badbit) != 0; }
+
+inline _LIBCPP_HIDE_FROM_ABI ios_base::iostate ios_base::exceptions() const { return __exceptions_; }
+
+inline _LIBCPP_HIDE_FROM_ABI void ios_base::exceptions(iostate __iostate) {
+  __exceptions_ = __iostate;
+  clear(__rdstate_);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-void
-ios_base::setstate(iostate __state)
-{
-    clear(__rdstate_ | __state);
-}
+template <class _Traits>
+// Attribute 'packed' is used to keep the layout compatible with the previous
+// definition of the '__fill_' and '_set_' pair in basic_ios on AIX & z/OS.
+struct _LIBCPP_PACKED _FillHelper {
+  _LIBCPP_HIDE_FROM_ABI void __init() { __set_ = false; }
+  _LIBCPP_HIDE_FROM_ABI _FillHelper& operator=(typename _Traits::int_type __x) {
+    __set_      = true;
+    __fill_val_ = __x;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI bool __is_set() const { return __set_; }
+  _LIBCPP_HIDE_FROM_ABI typename _Traits::int_type __get() const { return __fill_val_; }
 
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-ios_base::good() const
-{
-    return __rdstate_ == 0;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-ios_base::eof() const
-{
-    return (__rdstate_ & eofbit) != 0;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-ios_base::fail() const
-{
-    return (__rdstate_ & (failbit | badbit)) != 0;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-ios_base::bad() const
-{
-    return (__rdstate_ & badbit) != 0;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-ios_base::iostate
-ios_base::exceptions() const
-{
-    return __exceptions_;
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-void
-ios_base::exceptions(iostate __iostate)
-{
-    __exceptions_ = __iostate;
-    clear(__rdstate_);
-}
-
-template <class _CharT, class _Traits>
-class _LIBCPP_TEMPLATE_VIS basic_ios
-    : public ios_base
-{
-public:
-    // types:
-    typedef _CharT char_type;
-    typedef _Traits traits_type;
-
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
-
-    static_assert((is_same<_CharT, typename traits_type::char_type>::value),
-                  "traits_type::char_type must be the same type as CharT");
-
-#ifdef _LIBCPP_CXX03_LANG
-    // Preserve the ability to compare with literal 0,
-    // and implicitly convert to bool, but not implicitly convert to int.
-    _LIBCPP_INLINE_VISIBILITY
-    operator void*() const {return fail() ? nullptr : (void*)this;}
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const {return !fail();}
-#endif
-
-    _LIBCPP_INLINE_VISIBILITY bool operator!() const    {return  fail();}
-    _LIBCPP_INLINE_VISIBILITY iostate rdstate() const   {return ios_base::rdstate();}
-    _LIBCPP_INLINE_VISIBILITY void clear(iostate __state = goodbit) {ios_base::clear(__state);}
-    _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state) {ios_base::setstate(__state);}
-    _LIBCPP_INLINE_VISIBILITY bool good() const {return ios_base::good();}
-    _LIBCPP_INLINE_VISIBILITY bool eof() const  {return ios_base::eof();}
-    _LIBCPP_INLINE_VISIBILITY bool fail() const {return ios_base::fail();}
-    _LIBCPP_INLINE_VISIBILITY bool bad() const  {return ios_base::bad();}
-
-    _LIBCPP_INLINE_VISIBILITY iostate exceptions() const {return ios_base::exceptions();}
-    _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __iostate) {ios_base::exceptions(__iostate);}
-
-    // 27.5.4.1 Constructor/destructor:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ios(basic_streambuf<char_type,traits_type>* __sb);
-    ~basic_ios() override;
-
-    // 27.5.4.2 Members:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<char_type, traits_type>* tie() const;
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);
-
-    _LIBCPP_INLINE_VISIBILITY
-    basic_streambuf<char_type, traits_type>* rdbuf() const;
-    _LIBCPP_INLINE_VISIBILITY
-    basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb);
-
-    basic_ios& copyfmt(const basic_ios& __rhs);
-
-    _LIBCPP_INLINE_VISIBILITY
-    char_type fill() const;
-    _LIBCPP_INLINE_VISIBILITY
-    char_type fill(char_type __ch);
-
-    _LIBCPP_INLINE_VISIBILITY
-    locale imbue(const locale& __loc);
-
-    _LIBCPP_INLINE_VISIBILITY
-    char narrow(char_type __c, char __dfault) const;
-    _LIBCPP_INLINE_VISIBILITY
-    char_type widen(char __c) const;
-
-protected:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ios() {// purposefully does no initialization
-                }
-    _LIBCPP_INLINE_VISIBILITY
-    void init(basic_streambuf<char_type, traits_type>* __sb);
-
-    _LIBCPP_INLINE_VISIBILITY
-    void move(basic_ios& __rhs);
-    _LIBCPP_INLINE_VISIBILITY
-    void move(basic_ios&& __rhs) {move(__rhs);}
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(basic_ios& __rhs) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);
 private:
-    basic_ostream<char_type, traits_type>* __tie_;
-    mutable int_type __fill_;
+  typename _Traits::int_type __fill_val_;
+  bool __set_;
+};
+
+template <class _Traits>
+struct _LIBCPP_PACKED _SentinelValueFill {
+  _LIBCPP_HIDE_FROM_ABI void __init() { __fill_val_ = _Traits::eof(); }
+  _LIBCPP_HIDE_FROM_ABI _SentinelValueFill& operator=(typename _Traits::int_type __x) {
+    __fill_val_ = __x;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI bool __is_set() const { return __fill_val_ != _Traits::eof(); }
+  _LIBCPP_HIDE_FROM_ABI typename _Traits::int_type __get() const { return __fill_val_; }
+
+private:
+  typename _Traits::int_type __fill_val_;
 };
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type,traits_type>* __sb)
-{
-    init(__sb);
+class _LIBCPP_TEMPLATE_VIS basic_ios : public ios_base {
+public:
+  // types:
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+
+  static_assert(is_same<_CharT, typename traits_type::char_type>::value,
+                "traits_type::char_type must be the same type as CharT");
+
+#  ifdef _LIBCPP_CXX03_LANG
+  // Preserve the ability to compare with literal 0,
+  // and implicitly convert to bool, but not implicitly convert to int.
+  _LIBCPP_HIDE_FROM_ABI operator void*() const { return fail() ? nullptr : (void*)this; }
+#  else
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return !fail(); }
+#  endif
+
+  _LIBCPP_HIDE_FROM_ABI bool operator!() const { return fail(); }
+  _LIBCPP_HIDE_FROM_ABI iostate rdstate() const { return ios_base::rdstate(); }
+  _LIBCPP_HIDE_FROM_ABI void clear(iostate __state = goodbit) { ios_base::clear(__state); }
+  _LIBCPP_HIDE_FROM_ABI void setstate(iostate __state) { ios_base::setstate(__state); }
+  _LIBCPP_HIDE_FROM_ABI bool good() const { return ios_base::good(); }
+  _LIBCPP_HIDE_FROM_ABI bool eof() const { return ios_base::eof(); }
+  _LIBCPP_HIDE_FROM_ABI bool fail() const { return ios_base::fail(); }
+  _LIBCPP_HIDE_FROM_ABI bool bad() const { return ios_base::bad(); }
+
+  _LIBCPP_HIDE_FROM_ABI iostate exceptions() const { return ios_base::exceptions(); }
+  _LIBCPP_HIDE_FROM_ABI void exceptions(iostate __iostate) { ios_base::exceptions(__iostate); }
+
+  // 27.5.4.1 Constructor/destructor:
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ios(basic_streambuf<char_type, traits_type>* __sb);
+  ~basic_ios() override;
+
+  // 27.5.4.2 Members:
+  _LIBCPP_HIDE_FROM_ABI basic_ostream<char_type, traits_type>* tie() const;
+  _LIBCPP_HIDE_FROM_ABI basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);
+
+  _LIBCPP_HIDE_FROM_ABI basic_streambuf<char_type, traits_type>* rdbuf() const;
+  _LIBCPP_HIDE_FROM_ABI basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb);
+
+  basic_ios& copyfmt(const basic_ios& __rhs);
+
+  _LIBCPP_HIDE_FROM_ABI char_type fill() const;
+  _LIBCPP_HIDE_FROM_ABI char_type fill(char_type __ch);
+
+  _LIBCPP_HIDE_FROM_ABI locale imbue(const locale& __loc);
+
+  _LIBCPP_HIDE_FROM_ABI char narrow(char_type __c, char __dfault) const;
+  _LIBCPP_HIDE_FROM_ABI char_type widen(char __c) const;
+
+protected:
+  _LIBCPP_HIDE_FROM_ABI basic_ios() {
+    // purposefully does no initialization
+    // since the destructor does nothing this does not have ios_base issues.
+  }
+  _LIBCPP_HIDE_FROM_ABI void init(basic_streambuf<char_type, traits_type>* __sb);
+
+  _LIBCPP_HIDE_FROM_ABI void move(basic_ios& __rhs);
+  _LIBCPP_HIDE_FROM_ABI void move(basic_ios&& __rhs) { move(__rhs); }
+  _LIBCPP_HIDE_FROM_ABI void swap(basic_ios& __rhs) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);
+
+private:
+  basic_ostream<char_type, traits_type>* __tie_;
+
+#if defined(_LIBCPP_ABI_IOS_ALLOW_ARBITRARY_FILL_VALUE)
+  using _FillType = _FillHelper<traits_type>;
+#else
+  using _FillType = _SentinelValueFill<traits_type>;
+#endif
+  mutable _FillType __fill_;
+};
+
+template <class _CharT, class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI basic_ios<_CharT, _Traits>::basic_ios(basic_streambuf<char_type, traits_type>* __sb) {
+  init(__sb);
 }
 
 template <class _CharT, class _Traits>
-basic_ios<_CharT, _Traits>::~basic_ios()
-{
+basic_ios<_CharT, _Traits>::~basic_ios() {}
+
+template <class _CharT, class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI void basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb) {
+  ios_base::init(__sb);
+  __tie_  = nullptr;
+  __fill_.__init();
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_ios<_CharT, _Traits>::init(basic_streambuf<char_type, traits_type>* __sb)
-{
-    ios_base::init(__sb);
-    __tie_ = nullptr;
-    __fill_ = traits_type::eof();
+inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>* basic_ios<_CharT, _Traits>::tie() const {
+  return __tie_;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>*
-basic_ios<_CharT, _Traits>::tie() const
-{
-    return __tie_;
+inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>*
+basic_ios<_CharT, _Traits>::tie(basic_ostream<char_type, traits_type>* __tiestr) {
+  basic_ostream<char_type, traits_type>* __r = __tie_;
+  __tie_                                     = __tiestr;
+  return __r;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>*
-basic_ios<_CharT, _Traits>::tie(basic_ostream<char_type, traits_type>* __tiestr)
-{
-    basic_ostream<char_type, traits_type>* __r = __tie_;
-    __tie_ = __tiestr;
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI basic_streambuf<_CharT, _Traits>* basic_ios<_CharT, _Traits>::rdbuf() const {
+  return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf());
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_streambuf<_CharT, _Traits>*
-basic_ios<_CharT, _Traits>::rdbuf() const
-{
-    return static_cast<basic_streambuf<char_type, traits_type>*>(ios_base::rdbuf());
+inline _LIBCPP_HIDE_FROM_ABI basic_streambuf<_CharT, _Traits>*
+basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<char_type, traits_type>* __sb) {
+  basic_streambuf<char_type, traits_type>* __r = rdbuf();
+  ios_base::rdbuf(__sb);
+  return __r;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_streambuf<_CharT, _Traits>*
-basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<char_type, traits_type>* __sb)
-{
-    basic_streambuf<char_type, traits_type>* __r = rdbuf();
-    ios_base::rdbuf(__sb);
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI locale basic_ios<_CharT, _Traits>::imbue(const locale& __loc) {
+  locale __r = getloc();
+  ios_base::imbue(__loc);
+  if (rdbuf())
+    rdbuf()->pubimbue(__loc);
+  return __r;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-locale
-basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
-{
-    locale __r = getloc();
-    ios_base::imbue(__loc);
-    if (rdbuf())
-        rdbuf()->pubimbue(__loc);
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI char basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const {
+  return std::use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-char
-basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
-{
-    return std::use_facet<ctype<char_type> >(getloc()).narrow(__c, __dfault);
+inline _LIBCPP_HIDE_FROM_ABI _CharT basic_ios<_CharT, _Traits>::widen(char __c) const {
+  return std::use_facet<ctype<char_type> >(getloc()).widen(__c);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-_CharT
-basic_ios<_CharT, _Traits>::widen(char __c) const
-{
-    return std::use_facet<ctype<char_type> >(getloc()).widen(__c);
+inline _LIBCPP_HIDE_FROM_ABI _CharT basic_ios<_CharT, _Traits>::fill() const {
+  if (!__fill_.__is_set())
+    __fill_ = widen(' ');
+  return __fill_.__get();
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-_CharT
-basic_ios<_CharT, _Traits>::fill() const
-{
-    if (traits_type::eq_int_type(traits_type::eof(), __fill_))
-        __fill_ = widen(' ');
-    return __fill_;
+inline _LIBCPP_HIDE_FROM_ABI _CharT basic_ios<_CharT, _Traits>::fill(char_type __ch) {
+  if (!__fill_.__is_set())
+    __fill_ = widen(' ');
+  char_type __r = __fill_.__get();
+  __fill_       = __ch;
+  return __r;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-_CharT
-basic_ios<_CharT, _Traits>::fill(char_type __ch)
-{
-    if (traits_type::eq_int_type(traits_type::eof(), __fill_))
-        __fill_ = widen(' ');
-    char_type __r = __fill_;
-    __fill_ = __ch;
-    return __r;
-}
-
-template <class _CharT, class _Traits>
-basic_ios<_CharT, _Traits>&
-basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
-{
-    if (this != &__rhs)
-    {
-        __call_callbacks(erase_event);
-        ios_base::copyfmt(__rhs);
-        __tie_ = __rhs.__tie_;
-        __fill_ = __rhs.__fill_;
-        __call_callbacks(copyfmt_event);
-        exceptions(__rhs.exceptions());
-    }
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_ios<_CharT, _Traits>::move(basic_ios& __rhs)
-{
-    ios_base::move(__rhs);
-    __tie_ = __rhs.__tie_;
-    __rhs.__tie_ = nullptr;
+basic_ios<_CharT, _Traits>& basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) {
+  if (this != &__rhs) {
+    __call_callbacks(erase_event);
+    ios_base::copyfmt(__rhs);
+    __tie_  = __rhs.__tie_;
     __fill_ = __rhs.__fill_;
+    __call_callbacks(copyfmt_event);
+    exceptions(__rhs.exceptions());
+  }
+  return *this;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs) _NOEXCEPT
-{
-    ios_base::swap(__rhs);
-    _VSTD::swap(__tie_, __rhs.__tie_);
-    _VSTD::swap(__fill_, __rhs.__fill_);
+inline _LIBCPP_HIDE_FROM_ABI void basic_ios<_CharT, _Traits>::move(basic_ios& __rhs) {
+  ios_base::move(__rhs);
+  __tie_       = __rhs.__tie_;
+  __rhs.__tie_ = nullptr;
+  __fill_      = __rhs.__fill_;
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb)
-{
-    ios_base::set_rdbuf(__sb);
+inline _LIBCPP_HIDE_FROM_ABI void basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs) _NOEXCEPT {
+  ios_base::swap(__rhs);
+  std::swap(__tie_, __rhs.__tie_);
+  std::swap(__fill_, __rhs.__fill_);
+}
+
+template <class _CharT, class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI void basic_ios<_CharT, _Traits>::set_rdbuf(basic_streambuf<char_type, traits_type>* __sb) {
+  ios_base::set_rdbuf(__sb);
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<char>;
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ios<wchar_t>;
-#endif
+#  endif
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-boolalpha(ios_base& __str)
-{
-    __str.setf(ios_base::boolalpha);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& boolalpha(ios_base& __str) {
+  __str.setf(ios_base::boolalpha);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-noboolalpha(ios_base& __str)
-{
-    __str.unsetf(ios_base::boolalpha);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& noboolalpha(ios_base& __str) {
+  __str.unsetf(ios_base::boolalpha);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-showbase(ios_base& __str)
-{
-    __str.setf(ios_base::showbase);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& showbase(ios_base& __str) {
+  __str.setf(ios_base::showbase);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-noshowbase(ios_base& __str)
-{
-    __str.unsetf(ios_base::showbase);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& noshowbase(ios_base& __str) {
+  __str.unsetf(ios_base::showbase);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-showpoint(ios_base& __str)
-{
-    __str.setf(ios_base::showpoint);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& showpoint(ios_base& __str) {
+  __str.setf(ios_base::showpoint);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-noshowpoint(ios_base& __str)
-{
-    __str.unsetf(ios_base::showpoint);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& noshowpoint(ios_base& __str) {
+  __str.unsetf(ios_base::showpoint);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-showpos(ios_base& __str)
-{
-    __str.setf(ios_base::showpos);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& showpos(ios_base& __str) {
+  __str.setf(ios_base::showpos);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-noshowpos(ios_base& __str)
-{
-    __str.unsetf(ios_base::showpos);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& noshowpos(ios_base& __str) {
+  __str.unsetf(ios_base::showpos);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-skipws(ios_base& __str)
-{
-    __str.setf(ios_base::skipws);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& skipws(ios_base& __str) {
+  __str.setf(ios_base::skipws);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-noskipws(ios_base& __str)
-{
-    __str.unsetf(ios_base::skipws);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& noskipws(ios_base& __str) {
+  __str.unsetf(ios_base::skipws);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-uppercase(ios_base& __str)
-{
-    __str.setf(ios_base::uppercase);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& uppercase(ios_base& __str) {
+  __str.setf(ios_base::uppercase);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-nouppercase(ios_base& __str)
-{
-    __str.unsetf(ios_base::uppercase);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& nouppercase(ios_base& __str) {
+  __str.unsetf(ios_base::uppercase);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-unitbuf(ios_base& __str)
-{
-    __str.setf(ios_base::unitbuf);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& unitbuf(ios_base& __str) {
+  __str.setf(ios_base::unitbuf);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-nounitbuf(ios_base& __str)
-{
-    __str.unsetf(ios_base::unitbuf);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& nounitbuf(ios_base& __str) {
+  __str.unsetf(ios_base::unitbuf);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-internal(ios_base& __str)
-{
-    __str.setf(ios_base::internal, ios_base::adjustfield);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& internal(ios_base& __str) {
+  __str.setf(ios_base::internal, ios_base::adjustfield);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-left(ios_base& __str)
-{
-    __str.setf(ios_base::left, ios_base::adjustfield);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& left(ios_base& __str) {
+  __str.setf(ios_base::left, ios_base::adjustfield);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-right(ios_base& __str)
-{
-    __str.setf(ios_base::right, ios_base::adjustfield);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& right(ios_base& __str) {
+  __str.setf(ios_base::right, ios_base::adjustfield);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-dec(ios_base& __str)
-{
-    __str.setf(ios_base::dec, ios_base::basefield);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& dec(ios_base& __str) {
+  __str.setf(ios_base::dec, ios_base::basefield);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-hex(ios_base& __str)
-{
-    __str.setf(ios_base::hex, ios_base::basefield);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& hex(ios_base& __str) {
+  __str.setf(ios_base::hex, ios_base::basefield);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-oct(ios_base& __str)
-{
-    __str.setf(ios_base::oct, ios_base::basefield);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& oct(ios_base& __str) {
+  __str.setf(ios_base::oct, ios_base::basefield);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-fixed(ios_base& __str)
-{
-    __str.setf(ios_base::fixed, ios_base::floatfield);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& fixed(ios_base& __str) {
+  __str.setf(ios_base::fixed, ios_base::floatfield);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-scientific(ios_base& __str)
-{
-    __str.setf(ios_base::scientific, ios_base::floatfield);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& scientific(ios_base& __str) {
+  __str.setf(ios_base::scientific, ios_base::floatfield);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-hexfloat(ios_base& __str)
-{
-    __str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& hexfloat(ios_base& __str) {
+  __str.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
+  return __str;
 }
 
-_LIBCPP_HIDE_FROM_ABI inline
-ios_base&
-defaultfloat(ios_base& __str)
-{
-    __str.unsetf(ios_base::floatfield);
-    return __str;
+_LIBCPP_HIDE_FROM_ABI inline ios_base& defaultfloat(ios_base& __str) {
+  __str.unsetf(ios_base::floatfield);
+  return __str;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
+#endif // !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
@@ -1056,6 +879,7 @@ _LIBCPP_END_NAMESPACE_STD
 #  include <cstring>
 #  include <initializer_list>
 #  include <limits>
+#  include <mutex>
 #  include <new>
 #  include <stdexcept>
 #  include <system_error>
diff --git a/third_party/libcxx/ios.cpp b/third_party/libcxx/ios.cpp
new file mode 100644
index 000000000..e95f155fb
--- /dev/null
+++ b/third_party/libcxx/ios.cpp
@@ -0,0 +1,387 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+#include <__locale>
+#include <algorithm>
+#include <ios>
+#include <limits>
+#include <memory>
+#include <new>
+#include <stdlib.h>
+#include <string>
+
+#include "config_elast.h"
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+class _LIBCPP_HIDDEN __iostream_category : public __do_message {
+public:
+  virtual const char* name() const noexcept;
+  virtual string message(int ev) const;
+};
+
+const char* __iostream_category::name() const noexcept { return "iostream"; }
+
+string __iostream_category::message(int ev) const {
+  if (ev != static_cast<int>(io_errc::stream)
+#ifdef _LIBCPP_ELAST
+      && ev <= _LIBCPP_ELAST
+#endif // _LIBCPP_ELAST
+  )
+    return __do_message::message(ev);
+  return string("unspecified iostream_category error");
+}
+
+const error_category& iostream_category() noexcept {
+  union AvoidDestroyingIostreamCategory {
+    __iostream_category iostream_error_category;
+    constexpr explicit AvoidDestroyingIostreamCategory() : iostream_error_category() {}
+    ~AvoidDestroyingIostreamCategory() {}
+  };
+  constinit static AvoidDestroyingIostreamCategory helper;
+  return helper.iostream_error_category;
+}
+
+// ios_base::failure
+
+ios_base::failure::failure(const string& msg, const error_code& ec) : system_error(ec, msg) {}
+
+ios_base::failure::failure(const char* msg, const error_code& ec) : system_error(ec, msg) {}
+
+ios_base::failure::~failure() throw() {}
+
+// ios_base locale
+
+const ios_base::fmtflags ios_base::boolalpha;
+const ios_base::fmtflags ios_base::dec;
+const ios_base::fmtflags ios_base::fixed;
+const ios_base::fmtflags ios_base::hex;
+const ios_base::fmtflags ios_base::internal;
+const ios_base::fmtflags ios_base::left;
+const ios_base::fmtflags ios_base::oct;
+const ios_base::fmtflags ios_base::right;
+const ios_base::fmtflags ios_base::scientific;
+const ios_base::fmtflags ios_base::showbase;
+const ios_base::fmtflags ios_base::showpoint;
+const ios_base::fmtflags ios_base::showpos;
+const ios_base::fmtflags ios_base::skipws;
+const ios_base::fmtflags ios_base::unitbuf;
+const ios_base::fmtflags ios_base::uppercase;
+const ios_base::fmtflags ios_base::adjustfield;
+const ios_base::fmtflags ios_base::basefield;
+const ios_base::fmtflags ios_base::floatfield;
+
+const ios_base::iostate ios_base::badbit;
+const ios_base::iostate ios_base::eofbit;
+const ios_base::iostate ios_base::failbit;
+const ios_base::iostate ios_base::goodbit;
+
+const ios_base::openmode ios_base::app;
+const ios_base::openmode ios_base::ate;
+const ios_base::openmode ios_base::binary;
+const ios_base::openmode ios_base::in;
+const ios_base::openmode ios_base::out;
+const ios_base::openmode ios_base::trunc;
+
+void ios_base::__call_callbacks(event ev) {
+  for (size_t i = __event_size_; i;) {
+    --i;
+    __fn_[i](ev, *this, __index_[i]);
+  }
+}
+
+// locale
+
+locale ios_base::imbue(const locale& newloc) {
+  static_assert(sizeof(locale) == sizeof(__loc_), "");
+  locale& loc_storage = *reinterpret_cast<locale*>(&__loc_);
+  locale oldloc       = loc_storage;
+  loc_storage         = newloc;
+  __call_callbacks(imbue_event);
+  return oldloc;
+}
+
+locale ios_base::getloc() const {
+  const locale& loc_storage = *reinterpret_cast<const locale*>(&__loc_);
+  return loc_storage;
+}
+
+// xalloc
+#if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
+atomic<int> ios_base::__xindex_{0};
+#else
+int ios_base::__xindex_ = 0;
+#endif
+
+template <typename _Tp>
+static size_t __ios_new_cap(size_t __req_size, size_t __current_cap) { // Precondition: __req_size > __current_cap
+  const size_t mx = std::numeric_limits<size_t>::max() / sizeof(_Tp);
+  if (__req_size < mx / 2)
+    return std::max(2 * __current_cap, __req_size);
+  else
+    return mx;
+}
+
+int ios_base::xalloc() { return __xindex_++; }
+
+long& ios_base::iword(int index) {
+  size_t req_size = static_cast<size_t>(index) + 1;
+  if (req_size > __iarray_cap_) {
+    size_t newcap = __ios_new_cap<long>(req_size, __iarray_cap_);
+    long* iarray  = static_cast<long*>(realloc(__iarray_, newcap * sizeof(long)));
+    if (iarray == 0) {
+      setstate(badbit);
+      static long error;
+      error = 0;
+      return error;
+    }
+    __iarray_ = iarray;
+    for (long* p = __iarray_ + __iarray_size_; p < __iarray_ + newcap; ++p)
+      *p = 0;
+    __iarray_cap_ = newcap;
+  }
+  __iarray_size_ = max<size_t>(__iarray_size_, req_size);
+  return __iarray_[index];
+}
+
+void*& ios_base::pword(int index) {
+  size_t req_size = static_cast<size_t>(index) + 1;
+  if (req_size > __parray_cap_) {
+    size_t newcap = __ios_new_cap<void*>(req_size, __iarray_cap_);
+    void** parray = static_cast<void**>(realloc(__parray_, newcap * sizeof(void*)));
+    if (parray == 0) {
+      setstate(badbit);
+      static void* error;
+      error = 0;
+      return error;
+    }
+    __parray_ = parray;
+    for (void** p = __parray_ + __parray_size_; p < __parray_ + newcap; ++p)
+      *p = 0;
+    __parray_cap_ = newcap;
+  }
+  __parray_size_ = max<size_t>(__parray_size_, req_size);
+  return __parray_[index];
+}
+
+// register_callback
+
+void ios_base::register_callback(event_callback fn, int index) {
+  size_t req_size = __event_size_ + 1;
+  if (req_size > __event_cap_) {
+    size_t newcap       = __ios_new_cap<event_callback>(req_size, __event_cap_);
+    event_callback* fns = static_cast<event_callback*>(realloc(__fn_, newcap * sizeof(event_callback)));
+    if (fns == 0)
+      setstate(badbit);
+    __fn_      = fns;
+    int* indxs = static_cast<int*>(realloc(__index_, newcap * sizeof(int)));
+    if (indxs == 0)
+      setstate(badbit);
+    __index_     = indxs;
+    __event_cap_ = newcap;
+  }
+  __fn_[__event_size_]    = fn;
+  __index_[__event_size_] = index;
+  ++__event_size_;
+}
+
+ios_base::~ios_base() {
+  // Avoid UB when not properly initialized. See ios_base::ios_base for
+  // more information.
+  if (!__loc_)
+    return;
+  __call_callbacks(erase_event);
+  locale& loc_storage = *reinterpret_cast<locale*>(&__loc_);
+  loc_storage.~locale();
+  free(__fn_);
+  free(__index_);
+  free(__iarray_);
+  free(__parray_);
+}
+
+// iostate
+
+void ios_base::clear(iostate state) {
+  if (__rdbuf_)
+    __rdstate_ = state;
+  else
+    __rdstate_ = state | badbit;
+
+  if (((state | (__rdbuf_ ? goodbit : badbit)) & __exceptions_) != 0)
+    __throw_failure("ios_base::clear");
+}
+
+// init
+
+void ios_base::init(void* sb) {
+  __rdbuf_       = sb;
+  __rdstate_     = __rdbuf_ ? goodbit : badbit;
+  __exceptions_  = goodbit;
+  __fmtflags_    = skipws | dec;
+  __width_       = 0;
+  __precision_   = 6;
+  __fn_          = 0;
+  __index_       = 0;
+  __event_size_  = 0;
+  __event_cap_   = 0;
+  __iarray_      = 0;
+  __iarray_size_ = 0;
+  __iarray_cap_  = 0;
+  __parray_      = 0;
+  __parray_size_ = 0;
+  __parray_cap_  = 0;
+  ::new (&__loc_) locale;
+}
+
+void ios_base::copyfmt(const ios_base& rhs) {
+  // If we can't acquire the needed resources, throw bad_alloc (can't set badbit)
+  // Don't alter *this until all needed resources are acquired
+  unique_ptr<event_callback, void (*)(void*)> new_callbacks(0, free);
+  unique_ptr<int, void (*)(void*)> new_ints(0, free);
+  unique_ptr<long, void (*)(void*)> new_longs(0, free);
+  unique_ptr<void*, void (*)(void*)> new_pointers(0, free);
+  if (__event_cap_ < rhs.__event_size_) {
+    size_t newesize = sizeof(event_callback) * rhs.__event_size_;
+    new_callbacks.reset(static_cast<event_callback*>(malloc(newesize)));
+    if (!new_callbacks)
+      __throw_bad_alloc();
+
+    size_t newisize = sizeof(int) * rhs.__event_size_;
+    new_ints.reset(static_cast<int*>(malloc(newisize)));
+    if (!new_ints)
+      __throw_bad_alloc();
+  }
+  if (__iarray_cap_ < rhs.__iarray_size_) {
+    size_t newsize = sizeof(long) * rhs.__iarray_size_;
+    new_longs.reset(static_cast<long*>(malloc(newsize)));
+    if (!new_longs)
+      __throw_bad_alloc();
+  }
+  if (__parray_cap_ < rhs.__parray_size_) {
+    size_t newsize = sizeof(void*) * rhs.__parray_size_;
+    new_pointers.reset(static_cast<void**>(malloc(newsize)));
+    if (!new_pointers)
+      __throw_bad_alloc();
+  }
+  // Got everything we need.  Copy everything but __rdstate_, __rdbuf_ and __exceptions_
+  __fmtflags_           = rhs.__fmtflags_;
+  __precision_          = rhs.__precision_;
+  __width_              = rhs.__width_;
+  locale& lhs_loc       = *reinterpret_cast<locale*>(&__loc_);
+  const locale& rhs_loc = *reinterpret_cast<const locale*>(&rhs.__loc_);
+  lhs_loc               = rhs_loc;
+  if (__event_cap_ < rhs.__event_size_) {
+    free(__fn_);
+    __fn_ = new_callbacks.release();
+    free(__index_);
+    __index_     = new_ints.release();
+    __event_cap_ = rhs.__event_size_;
+  }
+  for (__event_size_ = 0; __event_size_ < rhs.__event_size_; ++__event_size_) {
+    __fn_[__event_size_]    = rhs.__fn_[__event_size_];
+    __index_[__event_size_] = rhs.__index_[__event_size_];
+  }
+  if (__iarray_cap_ < rhs.__iarray_size_) {
+    free(__iarray_);
+    __iarray_     = new_longs.release();
+    __iarray_cap_ = rhs.__iarray_size_;
+  }
+  for (__iarray_size_ = 0; __iarray_size_ < rhs.__iarray_size_; ++__iarray_size_)
+    __iarray_[__iarray_size_] = rhs.__iarray_[__iarray_size_];
+  if (__parray_cap_ < rhs.__parray_size_) {
+    free(__parray_);
+    __parray_     = new_pointers.release();
+    __parray_cap_ = rhs.__parray_size_;
+  }
+  for (__parray_size_ = 0; __parray_size_ < rhs.__parray_size_; ++__parray_size_)
+    __parray_[__parray_size_] = rhs.__parray_[__parray_size_];
+}
+
+void ios_base::move(ios_base& rhs) {
+  // *this is uninitialized
+  __fmtflags_     = rhs.__fmtflags_;
+  __precision_    = rhs.__precision_;
+  __width_        = rhs.__width_;
+  __rdstate_      = rhs.__rdstate_;
+  __exceptions_   = rhs.__exceptions_;
+  __rdbuf_        = 0;
+  locale& rhs_loc = *reinterpret_cast<locale*>(&rhs.__loc_);
+  ::new (&__loc_) locale(rhs_loc);
+  __fn_              = rhs.__fn_;
+  rhs.__fn_          = 0;
+  __index_           = rhs.__index_;
+  rhs.__index_       = 0;
+  __event_size_      = rhs.__event_size_;
+  rhs.__event_size_  = 0;
+  __event_cap_       = rhs.__event_cap_;
+  rhs.__event_cap_   = 0;
+  __iarray_          = rhs.__iarray_;
+  rhs.__iarray_      = 0;
+  __iarray_size_     = rhs.__iarray_size_;
+  rhs.__iarray_size_ = 0;
+  __iarray_cap_      = rhs.__iarray_cap_;
+  rhs.__iarray_cap_  = 0;
+  __parray_          = rhs.__parray_;
+  rhs.__parray_      = 0;
+  __parray_size_     = rhs.__parray_size_;
+  rhs.__parray_size_ = 0;
+  __parray_cap_      = rhs.__parray_cap_;
+  rhs.__parray_cap_  = 0;
+}
+
+void ios_base::swap(ios_base& rhs) noexcept {
+  std::swap(__fmtflags_, rhs.__fmtflags_);
+  std::swap(__precision_, rhs.__precision_);
+  std::swap(__width_, rhs.__width_);
+  std::swap(__rdstate_, rhs.__rdstate_);
+  std::swap(__exceptions_, rhs.__exceptions_);
+  locale& lhs_loc = *reinterpret_cast<locale*>(&__loc_);
+  locale& rhs_loc = *reinterpret_cast<locale*>(&rhs.__loc_);
+  std::swap(lhs_loc, rhs_loc);
+  std::swap(__fn_, rhs.__fn_);
+  std::swap(__index_, rhs.__index_);
+  std::swap(__event_size_, rhs.__event_size_);
+  std::swap(__event_cap_, rhs.__event_cap_);
+  std::swap(__iarray_, rhs.__iarray_);
+  std::swap(__iarray_size_, rhs.__iarray_size_);
+  std::swap(__iarray_cap_, rhs.__iarray_cap_);
+  std::swap(__parray_, rhs.__parray_);
+  std::swap(__parray_size_, rhs.__parray_size_);
+  std::swap(__parray_cap_, rhs.__parray_cap_);
+}
+
+void ios_base::__set_badbit_and_consider_rethrow() {
+  __rdstate_ |= badbit;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  if (__exceptions_ & badbit)
+    throw;
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+}
+
+void ios_base::__set_failbit_and_consider_rethrow() {
+  __rdstate_ |= failbit;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  if (__exceptions_ & failbit)
+    throw;
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+}
+
+bool ios_base::sync_with_stdio(bool sync) {
+  static bool previous_state = true;
+  bool r                     = previous_state;
+  previous_state             = sync;
+  return r;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/src/ios.instantiations.cpp b/third_party/libcxx/ios.instantiations.cpp
similarity index 93%
rename from third_party/libcxx/src/ios.instantiations.cpp
rename to third_party/libcxx/ios.instantiations.cpp
index ca77ce11f..aac7a6868 100644
--- a/third_party/libcxx/src/ios.instantiations.cpp
+++ b/third_party/libcxx/ios.instantiations.cpp
@@ -31,13 +31,13 @@ template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ostream<wchar_t>;
 #endif
 
 // Additional instantiations added later. Whether programs rely on these being
-// available is protected by _LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1.
+// available is protected by _LIBCPP_AVAILABILITY_HAS_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1.
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_stringbuf<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_stringstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ostringstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_istringstream<char>;
 
-#ifndef _LIBCPP_HAS_NO_FSTREAM
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ifstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_ofstream<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS basic_filebuf<char>;
diff --git a/third_party/libcxx/iosfwd b/third_party/libcxx/iosfwd
index e3cd9faa7..051c73995 100644
--- a/third_party/libcxx/iosfwd
+++ b/third_party/libcxx/iosfwd
@@ -25,7 +25,6 @@ template<>            struct char_traits<wchar_t>;
 
 template<class T>     class allocator;
 
-class ios_base;
 template <class charT, class traits = char_traits<charT> > class basic_ios;
 
 template <class charT, class traits = char_traits<charT> > class basic_streambuf;
@@ -90,15 +89,27 @@ using u8streampos = fpos<char_traits<char8_t>::state_type>; // C++20
 using u16streampos = fpos<char_traits<char16_t>::state_type>;
 using u32streampos = fpos<char_traits<char32_t>::state_type>;
 
+template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
+    class basic_syncbuf;                          // C++20
+
+using syncbuf = basic_syncbuf<char>;              // C++20
+using wsyncbuf = basic_syncbuf<wchar_t>;          // C++20
+
+template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
+    class basic_osyncstream;                      // C++20
+
+using osyncstream = basic_osyncstream<char>;      // C++20
+using wosyncstream = basic_osyncstream<wchar_t>;  // C++20
+
 }  // std
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__fwd/fstream.h>
 #include <__fwd/ios.h>
 #include <__fwd/istream.h>
+#include <__fwd/memory.h>
 #include <__fwd/ostream.h>
 #include <__fwd/sstream.h>
 #include <__fwd/streambuf.h>
@@ -112,51 +123,62 @@ using u32streampos = fpos<char_traits<char32_t>::state_type>;
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TYPE_VIS ios_base;
-
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TEMPLATE_VIS istreambuf_iterator;
+class _LIBCPP_TEMPLATE_VIS istreambuf_iterator;
 template <class _CharT, class _Traits = char_traits<_CharT> >
-    class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator;
+class _LIBCPP_TEMPLATE_VIS ostreambuf_iterator;
 
-template <class _State>             class _LIBCPP_TEMPLATE_VIS fpos;
-typedef fpos<mbstate_t>    streampos;
-typedef fpos<mbstate_t>    wstreampos;
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-typedef fpos<mbstate_t>    u8streampos;
+template <class _State>
+class _LIBCPP_TEMPLATE_VIS fpos;
+typedef fpos<mbstate_t> streampos;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+typedef fpos<mbstate_t> wstreampos;
 #endif
-typedef fpos<mbstate_t>    u16streampos;
-typedef fpos<mbstate_t>    u32streampos;
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+typedef fpos<mbstate_t> u8streampos;
+#endif
+typedef fpos<mbstate_t> u16streampos;
+typedef fpos<mbstate_t> u32streampos;
 
-// Include other forward declarations here
-template <class _Tp, class _Alloc = allocator<_Tp> >
-class _LIBCPP_TEMPLATE_VIS vector;
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_SYNCSTREAM)
+
+template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT>>
+class basic_syncbuf;
+
+using syncbuf = basic_syncbuf<char>;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using wsyncbuf = basic_syncbuf<wchar_t>;
+#  endif
+
+template <class _CharT, class _Traits = char_traits<_CharT>, class _Allocator = allocator<_CharT>>
+class basic_osyncstream;
+
+using osyncstream = basic_osyncstream<char>;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using wosyncstream = basic_osyncstream<wchar_t>;
+#  endif
+
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_SYNCSTREAM)
 
 template <class _CharT, class _Traits>
-class __save_flags
-{
-    typedef basic_ios<_CharT, _Traits> __stream_type;
-    typedef typename __stream_type::fmtflags fmtflags;
+class __save_flags {
+  typedef basic_ios<_CharT, _Traits> __stream_type;
+  typedef typename __stream_type::fmtflags fmtflags;
 
-    __stream_type& __stream_;
-    fmtflags       __fmtflags_;
-    _CharT         __fill_;
+  __stream_type& __stream_;
+  fmtflags __fmtflags_;
+  _CharT __fill_;
 
-    __save_flags(const __save_flags&);
-    __save_flags& operator=(const __save_flags&);
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __save_flags(__stream_type& __stream)
-        : __stream_(__stream),
-          __fmtflags_(__stream.flags()),
-          __fill_(__stream.fill())
-        {}
-    _LIBCPP_INLINE_VISIBILITY
-    ~__save_flags()
-    {
-        __stream_.flags(__fmtflags_);
-        __stream_.fill(__fill_);
-    }
+    __save_flags(const __save_flags&) = delete;
+    __save_flags& operator=(const __save_flags&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __save_flags(__stream_type& __stream)
+      : __stream_(__stream), __fmtflags_(__stream.flags()), __fill_(__stream.fill()) {}
+  _LIBCPP_HIDE_FROM_ABI ~__save_flags() {
+    __stream_.flags(__fmtflags_);
+    __stream_.fill(__fill_);
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/iostream b/third_party/libcxx/iostream
index d679d9932..5df45c6d3 100644
--- a/third_party/libcxx/iostream
+++ b/third_party/libcxx/iostream
@@ -33,7 +33,6 @@ extern wostream wclog;
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <version>
 
@@ -51,16 +50,16 @@ extern wostream wclog;
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-extern _LIBCPP_FUNC_VIS istream cin;
-extern _LIBCPP_FUNC_VIS ostream cout;
-extern _LIBCPP_FUNC_VIS ostream cerr;
-extern _LIBCPP_FUNC_VIS ostream clog;
+extern _LIBCPP_EXPORTED_FROM_ABI istream cin;
+extern _LIBCPP_EXPORTED_FROM_ABI ostream cout;
+extern _LIBCPP_EXPORTED_FROM_ABI ostream cerr;
+extern _LIBCPP_EXPORTED_FROM_ABI ostream clog;
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-extern _LIBCPP_FUNC_VIS wistream wcin;
-extern _LIBCPP_FUNC_VIS wostream wcout;
-extern _LIBCPP_FUNC_VIS wostream wcerr;
-extern _LIBCPP_FUNC_VIS wostream wclog;
+extern _LIBCPP_EXPORTED_FROM_ABI wistream wcin;
+extern _LIBCPP_EXPORTED_FROM_ABI wostream wcout;
+extern _LIBCPP_EXPORTED_FROM_ABI wostream wcerr;
+extern _LIBCPP_EXPORTED_FROM_ABI wostream wclog;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/iostream.cpp b/third_party/libcxx/iostream.cpp
new file mode 100644
index 000000000..c5ad77a01
--- /dev/null
+++ b/third_party/libcxx/iostream.cpp
@@ -0,0 +1,171 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "std_stream.h"
+#include <__locale>
+#include <new>
+#include <string>
+
+#ifdef _LIBCPP_MSVCRT_LIKE
+#  include <__locale_dir/locale_base_api/locale_guard.h>
+#endif
+
+#define _str(s) #s
+#define str(s) _str(s)
+#define _LIBCPP_ABI_NAMESPACE_STR str(_LIBCPP_ABI_NAMESPACE)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+alignas(istream) _LIBCPP_EXPORTED_FROM_ABI char cin[sizeof(istream)]
+#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
+    __asm__("?cin@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_istream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR
+            "@std@@@12@A")
+#endif
+        ;
+alignas(__stdinbuf<char>) static char __cin[sizeof(__stdinbuf<char>)];
+static mbstate_t mb_cin;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+alignas(wistream) _LIBCPP_EXPORTED_FROM_ABI char wcin[sizeof(wistream)]
+#  if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
+    __asm__("?wcin@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_istream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR
+            "@std@@@12@A")
+#  endif
+        ;
+alignas(__stdinbuf<wchar_t>) static char __wcin[sizeof(__stdinbuf<wchar_t>)];
+static mbstate_t mb_wcin;
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+alignas(ostream) _LIBCPP_EXPORTED_FROM_ABI char cout[sizeof(ostream)]
+#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
+    __asm__("?cout@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR
+            "@std@@@12@A")
+#endif
+        ;
+alignas(__stdoutbuf<char>) static char __cout[sizeof(__stdoutbuf<char>)];
+static mbstate_t mb_cout;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+alignas(wostream) _LIBCPP_EXPORTED_FROM_ABI char wcout[sizeof(wostream)]
+#  if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
+    __asm__("?wcout@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR
+            "@std@@@12@A")
+#  endif
+        ;
+alignas(__stdoutbuf<wchar_t>) static char __wcout[sizeof(__stdoutbuf<wchar_t>)];
+static mbstate_t mb_wcout;
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+alignas(ostream) _LIBCPP_EXPORTED_FROM_ABI char cerr[sizeof(ostream)]
+#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
+    __asm__("?cerr@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR
+            "@std@@@12@A")
+#endif
+        ;
+alignas(__stdoutbuf<char>) static char __cerr[sizeof(__stdoutbuf<char>)];
+static mbstate_t mb_cerr;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+alignas(wostream) _LIBCPP_EXPORTED_FROM_ABI char wcerr[sizeof(wostream)]
+#  if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
+    __asm__("?wcerr@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR
+            "@std@@@12@A")
+#  endif
+        ;
+alignas(__stdoutbuf<wchar_t>) static char __wcerr[sizeof(__stdoutbuf<wchar_t>)];
+static mbstate_t mb_wcerr;
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+alignas(ostream) _LIBCPP_EXPORTED_FROM_ABI char clog[sizeof(ostream)]
+#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
+    __asm__("?clog@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR
+            "@std@@@12@A")
+#endif
+        ;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+alignas(wostream) _LIBCPP_EXPORTED_FROM_ABI char wclog[sizeof(wostream)]
+#  if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
+    __asm__("?wclog@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR
+            "@std@@@12@A")
+#  endif
+        ;
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
+// attribute with a value that's reserved for the implementation (we're the implementation).
+#include "iostream_init.h"
+
+// On Windows the TLS storage for locales needs to be initialized before we create
+// the standard streams, otherwise it may not be alive during program termination
+// when we flush the streams.
+static void force_locale_initialization() {
+#if defined(_LIBCPP_MSVCRT_LIKE)
+  static bool once = []() {
+    auto loc = newlocale(LC_ALL_MASK, "C", 0);
+    {
+      __libcpp_locale_guard g(loc); // forces initialization of locale TLS
+      ((void)g);
+    }
+    freelocale(loc);
+    return true;
+  }();
+  ((void)once);
+#endif
+}
+
+class DoIOSInit {
+public:
+  DoIOSInit();
+  ~DoIOSInit();
+};
+
+DoIOSInit::DoIOSInit() {
+  force_locale_initialization();
+
+  istream* cin_ptr  = ::new (cin) istream(::new (__cin) __stdinbuf<char>(stdin, &mb_cin));
+  ostream* cout_ptr = ::new (cout) ostream(::new (__cout) __stdoutbuf<char>(stdout, &mb_cout));
+  ostream* cerr_ptr = ::new (cerr) ostream(::new (__cerr) __stdoutbuf<char>(stderr, &mb_cerr));
+  ::new (clog) ostream(cerr_ptr->rdbuf());
+  cin_ptr->tie(cout_ptr);
+  std::unitbuf(*cerr_ptr);
+  cerr_ptr->tie(cout_ptr);
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  wistream* wcin_ptr  = ::new (wcin) wistream(::new (__wcin) __stdinbuf<wchar_t>(stdin, &mb_wcin));
+  wostream* wcout_ptr = ::new (wcout) wostream(::new (__wcout) __stdoutbuf<wchar_t>(stdout, &mb_wcout));
+  wostream* wcerr_ptr = ::new (wcerr) wostream(::new (__wcerr) __stdoutbuf<wchar_t>(stderr, &mb_wcerr));
+  ::new (wclog) wostream(wcerr_ptr->rdbuf());
+
+  wcin_ptr->tie(wcout_ptr);
+  std::unitbuf(*wcerr_ptr);
+  wcerr_ptr->tie(wcout_ptr);
+#endif
+}
+
+DoIOSInit::~DoIOSInit() {
+  ostream* cout_ptr = reinterpret_cast<ostream*>(cout);
+  cout_ptr->flush();
+  ostream* clog_ptr = reinterpret_cast<ostream*>(clog);
+  clog_ptr->flush();
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  wostream* wcout_ptr = reinterpret_cast<wostream*>(wcout);
+  wcout_ptr->flush();
+  wostream* wclog_ptr = reinterpret_cast<wostream*>(wclog);
+  wclog_ptr->flush();
+#endif
+}
+
+ios_base::Init::Init() {
+  static DoIOSInit init_the_streams; // gets initialized once
+}
+
+ios_base::Init::~Init() {}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/iostream_init.h b/third_party/libcxx/iostream_init.h
similarity index 100%
rename from third_party/libcxx/src/iostream_init.h
rename to third_party/libcxx/iostream_init.h
diff --git a/third_party/libcxx/istream b/third_party/libcxx/istream
index 8b440c036..d2b577a9a 100644
--- a/third_party/libcxx/istream
+++ b/third_party/libcxx/istream
@@ -158,16 +158,18 @@ template <class Stream, class T>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__fwd/istream.h>
 #include <__iterator/istreambuf_iterator.h>
+#include <__ostream/basic_ostream.h>
 #include <__type_traits/conjunction.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_base_of.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
-#include <ostream>
+#include <bitset>
+#include <ios>
+#include <locale>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -177,1461 +179,1178 @@ template <class Stream, class T>
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TEMPLATE_VIS basic_istream
-    : virtual public basic_ios<_CharT, _Traits>
-{
-    streamsize __gc_;
-public:
-    // types (inherited from basic_ios (27.5.4)):
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
+class _LIBCPP_TEMPLATE_VIS basic_istream : virtual public basic_ios<_CharT, _Traits> {
+  streamsize __gc_;
+
+  _LIBCPP_HIDE_FROM_ABI void __inc_gcount() {
+    if (__gc_ < numeric_limits<streamsize>::max())
+      ++__gc_;
+  }
+
+public:
+  // types (inherited from basic_ios (27.5.4)):
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+
+  // 27.7.1.1.1 Constructor/destructor:
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb)
+      : __gc_(0) {
+    this->init(__sb);
+  }
+  ~basic_istream() override;
 
-    // 27.7.1.1.1 Constructor/destructor:
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb) : __gc_(0)
-    { this->init(__sb); }
-    ~basic_istream() override;
 protected:
-    inline _LIBCPP_INLINE_VISIBILITY
-    basic_istream(basic_istream&& __rhs);
+  inline _LIBCPP_HIDE_FROM_ABI basic_istream(basic_istream&& __rhs);
 
-    // 27.7.1.1.2 Assign/swap:
-    inline _LIBCPP_INLINE_VISIBILITY
-    basic_istream& operator=(basic_istream&& __rhs);
+  // 27.7.1.1.2 Assign/swap:
+  inline _LIBCPP_HIDE_FROM_ABI basic_istream& operator=(basic_istream&& __rhs);
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    void swap(basic_istream& __rhs) {
-      _VSTD::swap(__gc_, __rhs.__gc_);
-      basic_ios<char_type, traits_type>::swap(__rhs);
-    }
-
-    basic_istream           (const basic_istream& __rhs) = delete;
-    basic_istream& operator=(const basic_istream& __rhs) = delete;
-public:
-
-    // 27.7.1.1.3 Prefix/suffix:
-    class _LIBCPP_TEMPLATE_VIS sentry;
-
-    // 27.7.1.2 Formatted input:
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&))
-    { return __pf(*this); }
-
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_istream& operator>>(basic_ios<char_type, traits_type>&
-                              (*__pf)(basic_ios<char_type, traits_type>&))
-    { __pf(*this); return *this; }
-
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_istream& operator>>(ios_base& (*__pf)(ios_base&))
-    { __pf(*this); return *this; }
-
-    basic_istream& operator>>(basic_streambuf<char_type, traits_type>* __sb);
-    basic_istream& operator>>(bool& __n);
-    basic_istream& operator>>(short& __n);
-    basic_istream& operator>>(unsigned short& __n);
-    basic_istream& operator>>(int& __n);
-    basic_istream& operator>>(unsigned int& __n);
-    basic_istream& operator>>(long& __n);
-    basic_istream& operator>>(unsigned long& __n);
-    basic_istream& operator>>(long long& __n);
-    basic_istream& operator>>(unsigned long long& __n);
-    basic_istream& operator>>(float& __f);
-    basic_istream& operator>>(double& __f);
-    basic_istream& operator>>(long double& __f);
-    basic_istream& operator>>(void*& __p);
-
-    // 27.7.1.3 Unformatted input:
-    _LIBCPP_INLINE_VISIBILITY
-    streamsize gcount() const {return __gc_;}
-    int_type get();
-
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_istream& get(char_type& __c) {
-      int_type __ch = get();
-      if (__ch != traits_type::eof())
-        __c = traits_type::to_char_type(__ch);
-      return *this;
-    }
-
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_istream& get(char_type* __s, streamsize __n)
-    { return get(__s, __n, this->widen('\n')); }
-
-    basic_istream& get(char_type* __s, streamsize __n, char_type __dlm);
-
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_istream& get(basic_streambuf<char_type, traits_type>& __sb)
-    { return get(__sb, this->widen('\n')); }
-
-    basic_istream& get(basic_streambuf<char_type, traits_type>& __sb, char_type __dlm);
-
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_istream& getline(char_type* __s, streamsize __n)
-    { return getline(__s, __n, this->widen('\n')); }
-
-    basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm);
-
-    basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof());
-    int_type peek();
-    basic_istream& read (char_type* __s, streamsize __n);
-    streamsize readsome(char_type* __s, streamsize __n);
-
-    basic_istream& putback(char_type __c);
-    basic_istream& unget();
-    int sync();
-
-    pos_type tellg();
-    basic_istream& seekg(pos_type __pos);
-    basic_istream& seekg(off_type __off, ios_base::seekdir __dir);
-};
-
-template <class _CharT, class _Traits>
-class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry
-{
-    bool __ok_;
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_istream& __rhs) {
+    std::swap(__gc_, __rhs.__gc_);
+    basic_ios<char_type, traits_type>::swap(__rhs);
+  }
 
 public:
-    explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
-//    ~sentry() = default;
+  basic_istream(const basic_istream& __rhs)            = delete;
+  basic_istream& operator=(const basic_istream& __rhs) = delete;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const {return __ok_;}
+  // 27.7.1.1.3 Prefix/suffix:
+  class _LIBCPP_TEMPLATE_VIS sentry;
 
-    sentry(const sentry&) = delete;
-    sentry& operator=(const sentry&) = delete;
-};
+  // 27.7.1.2 Formatted input:
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&)) {
+    return __pf(*this);
+  }
 
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& __is,
-                                               bool __noskipws)
-    : __ok_(false)
-{
-    if (__is.good())
-    {
-        if (__is.tie())
-            __is.tie()->flush();
-        if (!__noskipws && (__is.flags() & ios_base::skipws))
-        {
-            typedef istreambuf_iterator<_CharT, _Traits> _Ip;
-            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
-            _Ip __i(__is);
-            _Ip __eof;
-            for (; __i != __eof; ++__i)
-                if (!__ct.is(__ct.space, *__i))
-                    break;
-            if (__i == __eof)
-                __is.setstate(ios_base::failbit | ios_base::eofbit);
-        }
-        __ok_ = __is.good();
-    }
-    else
-        __is.setstate(ios_base::failbit);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>::basic_istream(basic_istream&& __rhs)
-    : __gc_(__rhs.__gc_)
-{
-    __rhs.__gc_ = 0;
-    this->move(__rhs);
-}
-
-template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs)
-{
-    swap(__rhs);
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream&
+  operator>>(basic_ios<char_type, traits_type>& (*__pf)(basic_ios<char_type, traits_type>&)) {
+    __pf(*this);
     return *this;
+  }
+
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& operator>>(ios_base& (*__pf)(ios_base&)) {
+    __pf(*this);
+    return *this;
+  }
+
+  basic_istream& operator>>(basic_streambuf<char_type, traits_type>* __sb);
+  basic_istream& operator>>(bool& __n);
+  basic_istream& operator>>(short& __n);
+  basic_istream& operator>>(unsigned short& __n);
+  basic_istream& operator>>(int& __n);
+  basic_istream& operator>>(unsigned int& __n);
+  basic_istream& operator>>(long& __n);
+  basic_istream& operator>>(unsigned long& __n);
+  basic_istream& operator>>(long long& __n);
+  basic_istream& operator>>(unsigned long long& __n);
+  basic_istream& operator>>(float& __f);
+  basic_istream& operator>>(double& __f);
+  basic_istream& operator>>(long double& __f);
+  basic_istream& operator>>(void*& __p);
+
+  // 27.7.1.3 Unformatted input:
+  _LIBCPP_HIDE_FROM_ABI streamsize gcount() const { return __gc_; }
+  int_type get();
+
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& get(char_type& __c) {
+    int_type __ch = get();
+    if (__ch != traits_type::eof())
+      __c = traits_type::to_char_type(__ch);
+    return *this;
+  }
+
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& get(char_type* __s, streamsize __n) {
+    return get(__s, __n, this->widen('\n'));
+  }
+
+  basic_istream& get(char_type* __s, streamsize __n, char_type __dlm);
+
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& get(basic_streambuf<char_type, traits_type>& __sb) {
+    return get(__sb, this->widen('\n'));
+  }
+
+  basic_istream& get(basic_streambuf<char_type, traits_type>& __sb, char_type __dlm);
+
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& getline(char_type* __s, streamsize __n) {
+    return getline(__s, __n, this->widen('\n'));
+  }
+
+  basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm);
+
+  basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof());
+  int_type peek();
+  basic_istream& read(char_type* __s, streamsize __n);
+  streamsize readsome(char_type* __s, streamsize __n);
+
+  basic_istream& putback(char_type __c);
+  basic_istream& unget();
+  int sync();
+
+  pos_type tellg();
+  basic_istream& seekg(pos_type __pos);
+  basic_istream& seekg(off_type __off, ios_base::seekdir __dir);
+};
+
+template <class _CharT, class _Traits>
+class _LIBCPP_TEMPLATE_VIS basic_istream<_CharT, _Traits>::sentry {
+  bool __ok_;
+
+public:
+  explicit sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
+  //    ~sentry() = default;
+
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return __ok_; }
+
+  sentry(const sentry&)            = delete;
+  sentry& operator=(const sentry&) = delete;
+};
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>::sentry::sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws) : __ok_(false) {
+  if (__is.good()) {
+    if (__is.tie())
+      __is.tie()->flush();
+    if (!__noskipws && (__is.flags() & ios_base::skipws)) {
+      typedef istreambuf_iterator<_CharT, _Traits> _Ip;
+      const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
+      _Ip __i(__is);
+      _Ip __eof;
+      for (; __i != __eof; ++__i)
+        if (!__ct.is(__ct.space, *__i))
+          break;
+      if (__i == __eof)
+        __is.setstate(ios_base::failbit | ios_base::eofbit);
+    }
+    __ok_ = __is.good();
+  } else
+    __is.setstate(ios_base::failbit);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>::~basic_istream()
-{
+basic_istream<_CharT, _Traits>::basic_istream(basic_istream&& __rhs) : __gc_(__rhs.__gc_) {
+  __rhs.__gc_ = 0;
+  this->move(__rhs);
 }
 
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator=(basic_istream&& __rhs) {
+  swap(__rhs);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>::~basic_istream() {}
+
 template <class _Tp, class _CharT, class _Traits>
-_LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
+_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 __input_arithmetic(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {
-    ios_base::iostate __state = ios_base::goodbit;
-    typename basic_istream<_CharT, _Traits>::sentry __s(__is);
-    if (__s)
-    {
+  ios_base::iostate __state = ios_base::goodbit;
+  typename basic_istream<_CharT, _Traits>::sentry __s(__is);
+  if (__s) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef istreambuf_iterator<_CharT, _Traits> _Ip;
-            typedef num_get<_CharT, _Ip> _Fp;
-            std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __n);
+      typedef istreambuf_iterator<_CharT, _Traits> _Ip;
+      typedef num_get<_CharT, _Ip> _Fp;
+      std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            __is.__setstate_nothrow(__state);
-            if (__is.exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif
-        __is.setstate(__state);
+    } catch (...) {
+      __state |= ios_base::badbit;
+      __is.__setstate_nothrow(__state);
+      if (__is.exceptions() & ios_base::badbit) {
+        throw;
+      }
     }
-    return __is;
+#endif
+    __is.setstate(__state);
+  }
+  return __is;
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n)
-{
-    return _VSTD::__input_arithmetic<unsigned short>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(unsigned short& __n) {
+  return std::__input_arithmetic<unsigned short>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n)
-{
-    return _VSTD::__input_arithmetic<unsigned int>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(unsigned int& __n) {
+  return std::__input_arithmetic<unsigned int>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(long& __n)
-{
-    return _VSTD::__input_arithmetic<long>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(long& __n) {
+  return std::__input_arithmetic<long>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n)
-{
-    return _VSTD::__input_arithmetic<unsigned long>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(unsigned long& __n) {
+  return std::__input_arithmetic<unsigned long>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(long long& __n)
-{
-    return _VSTD::__input_arithmetic<long long>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(long long& __n) {
+  return std::__input_arithmetic<long long>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n)
-{
-    return _VSTD::__input_arithmetic<unsigned long long>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(unsigned long long& __n) {
+  return std::__input_arithmetic<unsigned long long>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(float& __n)
-{
-    return _VSTD::__input_arithmetic<float>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(float& __n) {
+  return std::__input_arithmetic<float>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(double& __n)
-{
-    return _VSTD::__input_arithmetic<double>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(double& __n) {
+  return std::__input_arithmetic<double>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(long double& __n)
-{
-    return _VSTD::__input_arithmetic<long double>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(long double& __n) {
+  return std::__input_arithmetic<long double>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(bool& __n)
-{
-    return _VSTD::__input_arithmetic<bool>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(bool& __n) {
+  return std::__input_arithmetic<bool>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(void*& __n)
-{
-    return _VSTD::__input_arithmetic<void*>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(void*& __n) {
+  return std::__input_arithmetic<void*>(*this, __n);
 }
 
 template <class _Tp, class _CharT, class _Traits>
-_LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
+_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 __input_arithmetic_with_numeric_limits(basic_istream<_CharT, _Traits>& __is, _Tp& __n) {
-    ios_base::iostate __state = ios_base::goodbit;
-    typename basic_istream<_CharT, _Traits>::sentry __s(__is);
-    if (__s)
-    {
+  ios_base::iostate __state = ios_base::goodbit;
+  typename basic_istream<_CharT, _Traits>::sentry __s(__is);
+  if (__s) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef istreambuf_iterator<_CharT, _Traits> _Ip;
-            typedef num_get<_CharT, _Ip> _Fp;
-            long __temp;
-            std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __temp);
-            if (__temp < numeric_limits<_Tp>::min())
-            {
-                __state |= ios_base::failbit;
-                __n = numeric_limits<_Tp>::min();
-            }
-            else if (__temp > numeric_limits<_Tp>::max())
-            {
-                __state |= ios_base::failbit;
-                __n = numeric_limits<_Tp>::max();
-            }
-            else
-            {
-                __n = static_cast<_Tp>(__temp);
-            }
+      typedef istreambuf_iterator<_CharT, _Traits> _Ip;
+      typedef num_get<_CharT, _Ip> _Fp;
+      long __temp;
+      std::use_facet<_Fp>(__is.getloc()).get(_Ip(__is), _Ip(), __is, __state, __temp);
+      if (__temp < numeric_limits<_Tp>::min()) {
+        __state |= ios_base::failbit;
+        __n = numeric_limits<_Tp>::min();
+      } else if (__temp > numeric_limits<_Tp>::max()) {
+        __state |= ios_base::failbit;
+        __n = numeric_limits<_Tp>::max();
+      } else {
+        __n = static_cast<_Tp>(__temp);
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            __is.__setstate_nothrow(__state);
-            if (__is.exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __is.setstate(__state);
+    } catch (...) {
+      __state |= ios_base::badbit;
+      __is.__setstate_nothrow(__state);
+      if (__is.exceptions() & ios_base::badbit) {
+        throw;
+      }
     }
-    return __is;
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __is.setstate(__state);
+  }
+  return __is;
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(short& __n)
-{
-    return _VSTD::__input_arithmetic_with_numeric_limits<short>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(short& __n) {
+  return std::__input_arithmetic_with_numeric_limits<short>(*this, __n);
 }
 
 template <class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(int& __n)
-{
-    return _VSTD::__input_arithmetic_with_numeric_limits<int>(*this, __n);
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::operator>>(int& __n) {
+  return std::__input_arithmetic_with_numeric_limits<int>(*this, __n);
 }
 
-template<class _CharT, class _Traits>
-_LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-__input_c_string(basic_istream<_CharT, _Traits>& __is, _CharT* __p, size_t __n)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
-    if (__sen)
-    {
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+__input_c_string(basic_istream<_CharT, _Traits>& __is, _CharT* __p, size_t __n) {
+  ios_base::iostate __state = ios_base::goodbit;
+  typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
+  if (__sen) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif
-            _CharT* __s = __p;
-            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
-            while (__s != __p + (__n-1))
-            {
-                typename _Traits::int_type __i = __is.rdbuf()->sgetc();
-                if (_Traits::eq_int_type(__i, _Traits::eof()))
-                {
-                   __state |= ios_base::eofbit;
-                   break;
-                }
-                _CharT __ch = _Traits::to_char_type(__i);
-                if (__ct.is(__ct.space, __ch))
-                    break;
-                *__s++ = __ch;
-                 __is.rdbuf()->sbumpc();
-            }
-            *__s = _CharT();
-            __is.width(0);
-            if (__s == __p)
-               __state |= ios_base::failbit;
+      _CharT* __s               = __p;
+      const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
+      while (__s != __p + (__n - 1)) {
+        typename _Traits::int_type __i = __is.rdbuf()->sgetc();
+        if (_Traits::eq_int_type(__i, _Traits::eof())) {
+          __state |= ios_base::eofbit;
+          break;
+        }
+        _CharT __ch = _Traits::to_char_type(__i);
+        if (__ct.is(__ct.space, __ch))
+          break;
+        *__s++ = __ch;
+        __is.rdbuf()->sbumpc();
+      }
+      *__s = _CharT();
+      __is.width(0);
+      if (__s == __p)
+        __state |= ios_base::failbit;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            __is.__setstate_nothrow(__state);
-            if (__is.exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif
-        __is.setstate(__state);
+    } catch (...) {
+      __state |= ios_base::badbit;
+      __is.__setstate_nothrow(__state);
+      if (__is.exceptions() & ios_base::badbit) {
+        throw;
+      }
     }
-    return __is;
+#endif
+    __is.setstate(__state);
+  }
+  return __is;
 }
 
 #if _LIBCPP_STD_VER >= 20
 
-template<class _CharT, class _Traits, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, _CharT (&__buf)[_Np])
-{
-    size_t __n = _Np;
-    if (__is.width() > 0)
-        __n = _VSTD::min(size_t(__is.width()), _Np);
-    return _VSTD::__input_c_string(__is, __buf, __n);
+template <class _CharT, class _Traits, size_t _Np>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is, _CharT (&__buf)[_Np]) {
+  size_t __n = _Np;
+  if (__is.width() > 0)
+    __n = std::min(size_t(__is.width()), _Np);
+  return std::__input_c_string(__is, __buf, __n);
 }
 
-template<class _Traits, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, unsigned char (&__buf)[_Np])
-{
-    return __is >> (char(&)[_Np])__buf;
+template <class _Traits, size_t _Np>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, unsigned char (&__buf)[_Np]) {
+  return __is >> (char(&)[_Np])__buf;
 }
 
-template<class _Traits, size_t _Np>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, signed char (&__buf)[_Np])
-{
-    return __is >> (char(&)[_Np])__buf;
+template <class _Traits, size_t _Np>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, signed char (&__buf)[_Np]) {
+  return __is >> (char(&)[_Np])__buf;
 }
 
 #else
 
-template<class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s)
-{
-    streamsize __n = __is.width();
-    if (__n <= 0)
-        __n = numeric_limits<streamsize>::max() / sizeof(_CharT) - 1;
-    return _VSTD::__input_c_string(__is, __s, size_t(__n));
+template <class _CharT, class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s) {
+  streamsize __n = __is.width();
+  if (__n <= 0)
+    __n = numeric_limits<streamsize>::max() / sizeof(_CharT) - 1;
+  return std::__input_c_string(__is, __s, size_t(__n));
 }
 
-template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, unsigned char* __s)
-{
-    return __is >> (char*)__s;
+template <class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, unsigned char* __s) {
+  return __is >> (char*)__s;
 }
 
-template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, signed char* __s)
-{
-    return __is >> (char*)__s;
+template <class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, signed char* __s) {
+  return __is >> (char*)__s;
 }
 
 #endif // _LIBCPP_STD_VER >= 20
 
-template<class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
-    if (__sen)
-    {
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c) {
+  ios_base::iostate __state = ios_base::goodbit;
+  typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
+  if (__sen) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif
-            typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
-            if (_Traits::eq_int_type(__i, _Traits::eof()))
-                __state |= ios_base::eofbit | ios_base::failbit;
-            else
-                __c = _Traits::to_char_type(__i);
+      typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
+      if (_Traits::eq_int_type(__i, _Traits::eof()))
+        __state |= ios_base::eofbit | ios_base::failbit;
+      else
+        __c = _Traits::to_char_type(__i);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            __is.__setstate_nothrow(__state);
-            if (__is.exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
+    } catch (...) {
+      __state |= ios_base::badbit;
+      __is.__setstate_nothrow(__state);
+      if (__is.exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
 #endif
-        __is.setstate(__state);
-    }
-    return __is;
+    __is.setstate(__state);
+  }
+  return __is;
 }
 
-template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, unsigned char& __c)
-{
-    return __is >> (char&)__c;
+template <class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, unsigned char& __c) {
+  return __is >> (char&)__c;
 }
 
-template<class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<char, _Traits>&
-operator>>(basic_istream<char, _Traits>& __is, signed char& __c)
-{
-    return __is >> (char&)__c;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_type>* __sb)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    __gc_ = 0;
-    sentry __s(*this, true);
-    if (__s)
-    {
-        if (__sb)
-        {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            try
-            {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-                while (true)
-                {
-                    typename traits_type::int_type __i = this->rdbuf()->sgetc();
-                    if (traits_type::eq_int_type(__i, _Traits::eof()))
-                    {
-                       __state |= ios_base::eofbit;
-                       break;
-                    }
-                    if (traits_type::eq_int_type(
-                            __sb->sputc(traits_type::to_char_type(__i)),
-                            traits_type::eof()))
-                        break;
-                    ++__gc_;
-                    this->rdbuf()->sbumpc();
-                }
-                if (__gc_ == 0)
-                   __state |= ios_base::failbit;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            }
-            catch (...)
-            {
-                __state |= ios_base::badbit;
-                if (__gc_ == 0)
-                    __state |= ios_base::failbit;
-
-                this->__setstate_nothrow(__state);
-                if (this->exceptions() & ios_base::failbit || this->exceptions() & ios_base::badbit)
-                {
-                    throw;
-                }
-            }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        else
-        {
-            __state |= ios_base::failbit;
-        }
-        this->setstate(__state);
-    }
-    return *this;
-}
-
-template<class _CharT, class _Traits>
-typename basic_istream<_CharT, _Traits>::int_type
-basic_istream<_CharT, _Traits>::get()
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    __gc_ = 0;
-    int_type __r = traits_type::eof();
-    sentry __s(*this, true);
-    if (__s)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif
-            __r = this->rdbuf()->sbumpc();
-            if (traits_type::eq_int_type(__r, traits_type::eof()))
-               __state |= ios_base::failbit | ios_base::eofbit;
-            else
-                __gc_ = 1;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            this->__setstate_nothrow(this->rdstate() | ios_base::badbit);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif
-        this->setstate(__state);
-    }
-    return __r;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __dlm)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    __gc_ = 0;
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-        if (__n > 0)
-        {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            try
-            {
-#endif
-                while (__gc_ < __n-1)
-                {
-                    int_type __i = this->rdbuf()->sgetc();
-                    if (traits_type::eq_int_type(__i, traits_type::eof()))
-                    {
-                       __state |= ios_base::eofbit;
-                       break;
-                    }
-                    char_type __ch = traits_type::to_char_type(__i);
-                    if (traits_type::eq(__ch, __dlm))
-                        break;
-                    *__s++ = __ch;
-                    ++__gc_;
-                     this->rdbuf()->sbumpc();
-                }
-                if (__gc_ == 0)
-                   __state |= ios_base::failbit;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            }
-            catch (...)
-            {
-                __state |= ios_base::badbit;
-                this->__setstate_nothrow(__state);
-                if (this->exceptions() & ios_base::badbit)
-                {
-                    if (__n > 0)
-                        *__s = char_type();
-                    throw;
-                }
-            }
-#endif
-        }
-        else
-        {
-            __state |= ios_base::failbit;
-        }
-
-        if (__n > 0)
-            *__s = char_type();
-        this->setstate(__state);
-    }
-    if (__n > 0)
-        *__s = char_type();
-    return *this;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb,
-                                    char_type __dlm)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    __gc_ = 0;
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            while (true)
-            {
-                typename traits_type::int_type __i = this->rdbuf()->sgetc();
-                if (traits_type::eq_int_type(__i, traits_type::eof()))
-                {
-                   __state |= ios_base::eofbit;
-                   break;
-                }
-                char_type __ch = traits_type::to_char_type(__i);
-                if (traits_type::eq(__ch, __dlm))
-                    break;
-                if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof()))
-                    break;
-                ++__gc_;
-                this->rdbuf()->sbumpc();
-            }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            // according to the spec, exceptions here are caught but not rethrown
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        if (__gc_ == 0)
-           __state |= ios_base::failbit;
-        this->setstate(__state);
-    }
-    return *this;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    __gc_ = 0;
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            while (true)
-            {
-                typename traits_type::int_type __i = this->rdbuf()->sgetc();
-                if (traits_type::eq_int_type(__i, traits_type::eof()))
-                {
-                   __state |= ios_base::eofbit;
-                   break;
-                }
-                char_type __ch = traits_type::to_char_type(__i);
-                if (traits_type::eq(__ch, __dlm))
-                {
-                    this->rdbuf()->sbumpc();
-                    ++__gc_;
-                    break;
-                }
-                if (__gc_ >= __n-1)
-                {
-                    __state |= ios_base::failbit;
-                    break;
-                }
-                *__s++ = __ch;
-                this->rdbuf()->sbumpc();
-                ++__gc_;
-            }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                if (__n > 0)
-                    *__s = char_type();
-                if (__gc_ == 0)
-                    __state |= ios_base::failbit;
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    if (__n > 0)
-        *__s = char_type();
-    if (__gc_ == 0)
-        __state |= ios_base::failbit;
-    this->setstate(__state);
-    return *this;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    __gc_ = 0;
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            if (__n == numeric_limits<streamsize>::max())
-            {
-                while (true)
-                {
-                    typename traits_type::int_type __i = this->rdbuf()->sbumpc();
-                    if (traits_type::eq_int_type(__i, traits_type::eof()))
-                    {
-                       __state |= ios_base::eofbit;
-                       break;
-                    }
-                    ++__gc_;
-                    if (traits_type::eq_int_type(__i, __dlm))
-                        break;
-                }
-            }
-            else
-            {
-                while (__gc_ < __n)
-                {
-                    typename traits_type::int_type __i = this->rdbuf()->sbumpc();
-                    if (traits_type::eq_int_type(__i, traits_type::eof()))
-                    {
-                       __state |= ios_base::eofbit;
-                       break;
-                    }
-                    ++__gc_;
-                    if (traits_type::eq_int_type(__i, __dlm))
-                        break;
-                }
-            }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        this->setstate(__state);
-    }
-    return *this;
-}
-
-template<class _CharT, class _Traits>
-typename basic_istream<_CharT, _Traits>::int_type
-basic_istream<_CharT, _Traits>::peek()
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    __gc_ = 0;
-    int_type __r = traits_type::eof();
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            __r = this->rdbuf()->sgetc();
-            if (traits_type::eq_int_type(__r, traits_type::eof()))
-                __state |= ios_base::eofbit;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        this->setstate(__state);
-    }
-    return __r;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    __gc_ = 0;
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            __gc_ = this->rdbuf()->sgetn(__s, __n);
-            if (__gc_ != __n)
-                __state |= ios_base::failbit | ios_base::eofbit;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    else
-    {
-        __state |= ios_base::failbit;
-    }
-    this->setstate(__state);
-    return *this;
-}
-
-template<class _CharT, class _Traits>
-streamsize
-basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    __gc_ = 0;
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            streamsize __c = this->rdbuf()->in_avail();
-            switch (__c)
-            {
-            case -1:
-                __state |= ios_base::eofbit;
-                break;
-            case 0:
-                break;
-            default:
-                __n = _VSTD::min(__c, __n);
-                __gc_ = this->rdbuf()->sgetn(__s, __n);
-                if (__gc_ != __n)
-                    __state |= ios_base::failbit | ios_base::eofbit;
-                break;
-            }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    else
-    {
-        __state |= ios_base::failbit;
-    }
-    this->setstate(__state);
-    return __gc_;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::putback(char_type __c)
-{
-    ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
-    __gc_ = 0;
-    this->clear(__state);
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            if (this->rdbuf() == nullptr || this->rdbuf()->sputbackc(__c) == traits_type::eof())
-                __state |= ios_base::badbit;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    else
-    {
-        __state |= ios_base::failbit;
-    }
-    this->setstate(__state);
-    return *this;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::unget()
-{
-    ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
-    __gc_ = 0;
-    this->clear(__state);
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            if (this->rdbuf() == nullptr || this->rdbuf()->sungetc() == traits_type::eof())
-                __state |= ios_base::badbit;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    else
-    {
-        __state |= ios_base::failbit;
-    }
-    this->setstate(__state);
-    return *this;
-}
-
-template<class _CharT, class _Traits>
-int
-basic_istream<_CharT, _Traits>::sync()
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    int __r = 0;
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            if (this->rdbuf() == nullptr)
-                return -1;
-            if (this->rdbuf()->pubsync() == -1)
-            {
-                __state |= ios_base::badbit;
-                return -1;
-            }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        this->setstate(__state);
-    }
-    return __r;
-}
-
-template<class _CharT, class _Traits>
-typename basic_istream<_CharT, _Traits>::pos_type
-basic_istream<_CharT, _Traits>::tellg()
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    pos_type __r(-1);
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        this->setstate(__state);
-    }
-    return __r;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::seekg(pos_type __pos)
-{
-    ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
-    this->clear(__state);
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1))
-                __state |= ios_base::failbit;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        this->setstate(__state);
-    }
-    return *this;
-}
-
-template<class _CharT, class _Traits>
-basic_istream<_CharT, _Traits>&
-basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir)
-{
-    ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
-    this->clear(__state);
-    sentry __sen(*this, true);
-    if (__sen)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1))
-                __state |= ios_base::failbit;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            this->__setstate_nothrow(__state);
-            if (this->exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        this->setstate(__state);
-    }
-    return *this;
+template <class _Traits>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<char, _Traits>&
+operator>>(basic_istream<char, _Traits>& __is, signed char& __c) {
+  return __is >> (char&)__c;
 }
 
 template <class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-ws(basic_istream<_CharT, _Traits>& __is)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
-    if (__sen)
-    {
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_type>* __sb) {
+  ios_base::iostate __state = ios_base::goodbit;
+  __gc_                     = 0;
+  sentry __s(*this, true);
+  if (__s) {
+    if (__sb) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+      try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
-            while (true)
-            {
-                typename _Traits::int_type __i = __is.rdbuf()->sgetc();
-                if (_Traits::eq_int_type(__i, _Traits::eof()))
-                {
-                   __state |= ios_base::eofbit;
-                   break;
-                }
-                if (!__ct.is(__ct.space, _Traits::to_char_type(__i)))
-                    break;
-                __is.rdbuf()->sbumpc();
-            }
+        while (true) {
+          typename traits_type::int_type __i = this->rdbuf()->sgetc();
+          if (traits_type::eq_int_type(__i, _Traits::eof())) {
+            __state |= ios_base::eofbit;
+            break;
+          }
+          if (traits_type::eq_int_type(__sb->sputc(traits_type::to_char_type(__i)), traits_type::eof()))
+            break;
+          __inc_gcount();
+          this->rdbuf()->sbumpc();
+        }
+        if (__gc_ == 0)
+          __state |= ios_base::failbit;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      } catch (...) {
+        __state |= ios_base::badbit;
+        if (__gc_ == 0)
+          __state |= ios_base::failbit;
+
+        this->__setstate_nothrow(__state);
+        if (this->exceptions() & ios_base::failbit || this->exceptions() & ios_base::badbit) {
+          throw;
         }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            __is.__setstate_nothrow(__state);
-            if (__is.exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
+      }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __is.setstate(__state);
+    } else {
+      __state |= ios_base::failbit;
     }
-    return __is;
+    this->setstate(__state);
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+typename basic_istream<_CharT, _Traits>::int_type basic_istream<_CharT, _Traits>::get() {
+  ios_base::iostate __state = ios_base::goodbit;
+  __gc_                     = 0;
+  int_type __r              = traits_type::eof();
+  sentry __s(*this, true);
+  if (__s) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif
+      __r = this->rdbuf()->sbumpc();
+      if (traits_type::eq_int_type(__r, traits_type::eof()))
+        __state |= ios_base::failbit | ios_base::eofbit;
+      else
+        __gc_ = 1;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      this->__setstate_nothrow(this->rdstate() | ios_base::badbit);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif
+    this->setstate(__state);
+  }
+  return __r;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __dlm) {
+  ios_base::iostate __state = ios_base::goodbit;
+  __gc_                     = 0;
+  sentry __sen(*this, true);
+  if (__sen) {
+    if (__n > 0) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      try {
+#endif
+        while (__gc_ < __n - 1) {
+          int_type __i = this->rdbuf()->sgetc();
+          if (traits_type::eq_int_type(__i, traits_type::eof())) {
+            __state |= ios_base::eofbit;
+            break;
+          }
+          char_type __ch = traits_type::to_char_type(__i);
+          if (traits_type::eq(__ch, __dlm))
+            break;
+          *__s++ = __ch;
+          __inc_gcount();
+          this->rdbuf()->sbumpc();
+        }
+        if (__gc_ == 0)
+          __state |= ios_base::failbit;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      } catch (...) {
+        __state |= ios_base::badbit;
+        this->__setstate_nothrow(__state);
+        if (this->exceptions() & ios_base::badbit) {
+          if (__n > 0)
+            *__s = char_type();
+          throw;
+        }
+      }
+#endif
+    } else {
+      __state |= ios_base::failbit;
+    }
+
+    if (__n > 0)
+      *__s = char_type();
+    this->setstate(__state);
+  }
+  if (__n > 0)
+    *__s = char_type();
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __sb, char_type __dlm) {
+  ios_base::iostate __state = ios_base::goodbit;
+  __gc_                     = 0;
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      while (true) {
+        typename traits_type::int_type __i = this->rdbuf()->sgetc();
+        if (traits_type::eq_int_type(__i, traits_type::eof())) {
+          __state |= ios_base::eofbit;
+          break;
+        }
+        char_type __ch = traits_type::to_char_type(__i);
+        if (traits_type::eq(__ch, __dlm))
+          break;
+        if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof()))
+          break;
+        __inc_gcount();
+        this->rdbuf()->sbumpc();
+      }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      // according to the spec, exceptions here are caught but not rethrown
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    if (__gc_ == 0)
+      __state |= ios_base::failbit;
+    this->setstate(__state);
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>&
+basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_type __dlm) {
+  ios_base::iostate __state = ios_base::goodbit;
+  __gc_                     = 0;
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      while (true) {
+        typename traits_type::int_type __i = this->rdbuf()->sgetc();
+        if (traits_type::eq_int_type(__i, traits_type::eof())) {
+          __state |= ios_base::eofbit;
+          break;
+        }
+        char_type __ch = traits_type::to_char_type(__i);
+        if (traits_type::eq(__ch, __dlm)) {
+          this->rdbuf()->sbumpc();
+          __inc_gcount();
+          break;
+        }
+        if (__gc_ >= __n - 1) {
+          __state |= ios_base::failbit;
+          break;
+        }
+        *__s++ = __ch;
+        this->rdbuf()->sbumpc();
+        __inc_gcount();
+      }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        if (__n > 0)
+          *__s = char_type();
+        if (__gc_ == 0)
+          __state |= ios_base::failbit;
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
+  if (__n > 0)
+    *__s = char_type();
+  if (__gc_ == 0)
+    __state |= ios_base::failbit;
+  this->setstate(__state);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm) {
+  ios_base::iostate __state = ios_base::goodbit;
+  __gc_                     = 0;
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      if (__n == numeric_limits<streamsize>::max()) {
+        while (true) {
+          typename traits_type::int_type __i = this->rdbuf()->sbumpc();
+          if (traits_type::eq_int_type(__i, traits_type::eof())) {
+            __state |= ios_base::eofbit;
+            break;
+          }
+          __inc_gcount();
+          if (traits_type::eq_int_type(__i, __dlm))
+            break;
+        }
+      } else {
+        while (__gc_ < __n) {
+          typename traits_type::int_type __i = this->rdbuf()->sbumpc();
+          if (traits_type::eq_int_type(__i, traits_type::eof())) {
+            __state |= ios_base::eofbit;
+            break;
+          }
+          __inc_gcount();
+          if (traits_type::eq_int_type(__i, __dlm))
+            break;
+        }
+      }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    this->setstate(__state);
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+typename basic_istream<_CharT, _Traits>::int_type basic_istream<_CharT, _Traits>::peek() {
+  ios_base::iostate __state = ios_base::goodbit;
+  __gc_                     = 0;
+  int_type __r              = traits_type::eof();
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      __r = this->rdbuf()->sgetc();
+      if (traits_type::eq_int_type(__r, traits_type::eof()))
+        __state |= ios_base::eofbit;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    this->setstate(__state);
+  }
+  return __r;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n) {
+  ios_base::iostate __state = ios_base::goodbit;
+  __gc_                     = 0;
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      __gc_ = this->rdbuf()->sgetn(__s, __n);
+      if (__gc_ != __n)
+        __state |= ios_base::failbit | ios_base::eofbit;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  } else {
+    __state |= ios_base::failbit;
+  }
+  this->setstate(__state);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+streamsize basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n) {
+  ios_base::iostate __state = ios_base::goodbit;
+  __gc_                     = 0;
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      streamsize __c = this->rdbuf()->in_avail();
+      switch (__c) {
+      case -1:
+        __state |= ios_base::eofbit;
+        break;
+      case 0:
+        break;
+      default:
+        __n   = std::min(__c, __n);
+        __gc_ = this->rdbuf()->sgetn(__s, __n);
+        if (__gc_ != __n)
+          __state |= ios_base::failbit | ios_base::eofbit;
+        break;
+      }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  } else {
+    __state |= ios_base::failbit;
+  }
+  this->setstate(__state);
+  return __gc_;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::putback(char_type __c) {
+  ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
+  __gc_                     = 0;
+  this->clear(__state);
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      if (this->rdbuf() == nullptr || this->rdbuf()->sputbackc(__c) == traits_type::eof())
+        __state |= ios_base::badbit;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  } else {
+    __state |= ios_base::failbit;
+  }
+  this->setstate(__state);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::unget() {
+  ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
+  __gc_                     = 0;
+  this->clear(__state);
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      if (this->rdbuf() == nullptr || this->rdbuf()->sungetc() == traits_type::eof())
+        __state |= ios_base::badbit;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  } else {
+    __state |= ios_base::failbit;
+  }
+  this->setstate(__state);
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+int basic_istream<_CharT, _Traits>::sync() {
+  ios_base::iostate __state = ios_base::goodbit;
+  sentry __sen(*this, true);
+  if (this->rdbuf() == nullptr)
+    return -1;
+
+  int __r = 0;
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      if (this->rdbuf()->pubsync() == -1) {
+        __state |= ios_base::badbit;
+        __r = -1;
+      }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    this->setstate(__state);
+  }
+  return __r;
+}
+
+template <class _CharT, class _Traits>
+typename basic_istream<_CharT, _Traits>::pos_type basic_istream<_CharT, _Traits>::tellg() {
+  ios_base::iostate __state = ios_base::goodbit;
+  pos_type __r(-1);
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      __r = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    this->setstate(__state);
+  }
+  return __r;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::seekg(pos_type __pos) {
+  ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
+  this->clear(__state);
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      if (this->rdbuf()->pubseekpos(__pos, ios_base::in) == pos_type(-1))
+        __state |= ios_base::failbit;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    this->setstate(__state);
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+basic_istream<_CharT, _Traits>& basic_istream<_CharT, _Traits>::seekg(off_type __off, ios_base::seekdir __dir) {
+  ios_base::iostate __state = this->rdstate() & ~ios_base::eofbit;
+  this->clear(__state);
+  sentry __sen(*this, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::in) == pos_type(-1))
+        __state |= ios_base::failbit;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      this->__setstate_nothrow(__state);
+      if (this->exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    this->setstate(__state);
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>& ws(basic_istream<_CharT, _Traits>& __is) {
+  ios_base::iostate __state = ios_base::goodbit;
+  typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
+  if (__sen) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
+      while (true) {
+        typename _Traits::int_type __i = __is.rdbuf()->sgetc();
+        if (_Traits::eq_int_type(__i, _Traits::eof())) {
+          __state |= ios_base::eofbit;
+          break;
+        }
+        if (!__ct.is(__ct.space, _Traits::to_char_type(__i)))
+          break;
+        __is.rdbuf()->sbumpc();
+      }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __state |= ios_base::badbit;
+      __is.__setstate_nothrow(__state);
+      if (__is.exceptions() & ios_base::badbit) {
+        throw;
+      }
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __is.setstate(__state);
+  }
+  return __is;
 }
 
 template <class _Stream, class _Tp, class = void>
-struct __is_istreamable : false_type { };
+struct __is_istreamable : false_type {};
 
 template <class _Stream, class _Tp>
-struct __is_istreamable<_Stream, _Tp, decltype(
-    std::declval<_Stream>() >> std::declval<_Tp>(), void()
-)> : true_type { };
+struct __is_istreamable<_Stream, _Tp, decltype(std::declval<_Stream>() >> std::declval<_Tp>(), void())> : true_type {};
 
-template <class _Stream, class _Tp, class = typename enable_if<
-    _And<is_base_of<ios_base, _Stream>,
-         __is_istreamable<_Stream&, _Tp&&> >::value
->::type>
-_LIBCPP_INLINE_VISIBILITY
-_Stream&& operator>>(_Stream&& __is, _Tp&& __x)
-{
-    __is >> _VSTD::forward<_Tp>(__x);
-    return _VSTD::move(__is);
+template <class _Stream,
+          class _Tp,
+          __enable_if_t< _And<is_base_of<ios_base, _Stream>, __is_istreamable<_Stream&, _Tp&&> >::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _Stream&& operator>>(_Stream&& __is, _Tp&& __x) {
+  __is >> std::forward<_Tp>(__x);
+  return std::move(__is);
 }
 
 template <class _CharT, class _Traits>
 class _LIBCPP_TEMPLATE_VIS basic_iostream
     : public basic_istream<_CharT, _Traits>,
-      public basic_ostream<_CharT, _Traits>
-{
+      public basic_ostream<_CharT, _Traits> {
 public:
-    // types:
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
+  // types:
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
 
-    // constructor/destructor
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb)
-      : basic_istream<_CharT, _Traits>(__sb)
-    {}
+  // constructor/destructor
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb)
+      : basic_istream<_CharT, _Traits>(__sb) {}
+
+  ~basic_iostream() override;
 
-    ~basic_iostream() override;
 protected:
-    inline _LIBCPP_INLINE_VISIBILITY
-    basic_iostream(basic_iostream&& __rhs);
+  inline _LIBCPP_HIDE_FROM_ABI basic_iostream(basic_iostream&& __rhs);
 
-    // assign/swap
-    inline _LIBCPP_INLINE_VISIBILITY
-    basic_iostream& operator=(basic_iostream&& __rhs);
+  // assign/swap
+  inline _LIBCPP_HIDE_FROM_ABI basic_iostream& operator=(basic_iostream&& __rhs);
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    void swap(basic_iostream& __rhs)
-    { basic_istream<char_type, traits_type>::swap(__rhs); }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_iostream& __rhs) {
+    basic_istream<char_type, traits_type>::swap(__rhs);
+  }
 };
 
 template <class _CharT, class _Traits>
 basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs)
-    : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
-{
+    : basic_istream<_CharT, _Traits>(std::move(__rhs)) {}
+
+template <class _CharT, class _Traits>
+basic_iostream<_CharT, _Traits>& basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs) {
+  swap(__rhs);
+  return *this;
 }
 
 template <class _CharT, class _Traits>
-basic_iostream<_CharT, _Traits>&
-basic_iostream<_CharT, _Traits>::operator=(basic_iostream&& __rhs)
-{
-    swap(__rhs);
-    return *this;
-}
+basic_iostream<_CharT, _Traits>::~basic_iostream() {}
 
-template <class _CharT, class _Traits>
-basic_iostream<_CharT, _Traits>::~basic_iostream()
-{
-}
-
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           basic_string<_CharT, _Traits, _Allocator>& __str)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
-    if (__sen)
-    {
+operator>>(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Allocator>& __str) {
+  ios_base::iostate __state = ios_base::goodbit;
+  typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
+  if (__sen) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif
-            __str.clear();
-            streamsize __n = __is.width();
-            if (__n <= 0)
-                __n = __str.max_size();
-            if (__n <= 0)
-                __n = numeric_limits<streamsize>::max();
-            streamsize __c = 0;
-            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
-            while (__c < __n)
-            {
-                typename _Traits::int_type __i = __is.rdbuf()->sgetc();
-                if (_Traits::eq_int_type(__i, _Traits::eof()))
-                {
-                   __state |= ios_base::eofbit;
-                   break;
-                }
-                _CharT __ch = _Traits::to_char_type(__i);
-                if (__ct.is(__ct.space, __ch))
-                    break;
-                __str.push_back(__ch);
-                ++__c;
-                 __is.rdbuf()->sbumpc();
-            }
-            __is.width(0);
-            if (__c == 0)
-               __state |= ios_base::failbit;
+      __str.clear();
+      streamsize __n = __is.width();
+      if (__n <= 0)
+        __n = __str.max_size();
+      if (__n <= 0)
+        __n = numeric_limits<streamsize>::max();
+      streamsize __c            = 0;
+      const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
+      while (__c < __n) {
+        typename _Traits::int_type __i = __is.rdbuf()->sgetc();
+        if (_Traits::eq_int_type(__i, _Traits::eof())) {
+          __state |= ios_base::eofbit;
+          break;
+        }
+        _CharT __ch = _Traits::to_char_type(__i);
+        if (__ct.is(__ct.space, __ch))
+          break;
+        __str.push_back(__ch);
+        ++__c;
+        __is.rdbuf()->sbumpc();
+      }
+      __is.width(0);
+      if (__c == 0)
+        __state |= ios_base::failbit;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            __is.__setstate_nothrow(__state);
-            if (__is.exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif
-        __is.setstate(__state);
+    } catch (...) {
+      __state |= ios_base::badbit;
+      __is.__setstate_nothrow(__state);
+      if (__is.exceptions() & ios_base::badbit) {
+        throw;
+      }
     }
-    return __is;
+#endif
+    __is.setstate(__state);
+  }
+  return __is;
 }
 
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-getline(basic_istream<_CharT, _Traits>& __is,
-        basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
-    if (__sen)
-    {
+getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) {
+  ios_base::iostate __state = ios_base::goodbit;
+  typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
+  if (__sen) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif
-            __str.clear();
-            streamsize __extr = 0;
-            while (true)
-            {
-                typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
-                if (_Traits::eq_int_type(__i, _Traits::eof()))
-                {
-                   __state |= ios_base::eofbit;
-                   break;
-                }
-                ++__extr;
-                _CharT __ch = _Traits::to_char_type(__i);
-                if (_Traits::eq(__ch, __dlm))
-                    break;
-                __str.push_back(__ch);
-                if (__str.size() == __str.max_size())
-                {
-                    __state |= ios_base::failbit;
-                    break;
-                }
-            }
-            if (__extr == 0)
-               __state |= ios_base::failbit;
+      __str.clear();
+      streamsize __extr = 0;
+      while (true) {
+        typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
+        if (_Traits::eq_int_type(__i, _Traits::eof())) {
+          __state |= ios_base::eofbit;
+          break;
+        }
+        ++__extr;
+        _CharT __ch = _Traits::to_char_type(__i);
+        if (_Traits::eq(__ch, __dlm))
+          break;
+        __str.push_back(__ch);
+        if (__str.size() == __str.max_size()) {
+          __state |= ios_base::failbit;
+          break;
+        }
+      }
+      if (__extr == 0)
+        __state |= ios_base::failbit;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            __is.__setstate_nothrow(__state);
-            if (__is.exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif
-        __is.setstate(__state);
+    } catch (...) {
+      __state |= ios_base::badbit;
+      __is.__setstate_nothrow(__state);
+      if (__is.exceptions() & ios_base::badbit) {
+        throw;
+      }
     }
-    return __is;
+#endif
+    __is.setstate(__state);
+  }
+  return __is;
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-getline(basic_istream<_CharT, _Traits>& __is,
-        basic_string<_CharT, _Traits, _Allocator>& __str)
-{
-    return std::getline(__is, __str, __is.widen('\n'));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Allocator>& __str) {
+  return std::getline(__is, __str, __is.widen('\n'));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-getline(basic_istream<_CharT, _Traits>&& __is,
-        basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm)
-{
-    return std::getline(__is, __str, __dlm);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+getline(basic_istream<_CharT, _Traits>&& __is, basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm) {
+  return std::getline(__is, __str, __dlm);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_istream<_CharT, _Traits>&
-getline(basic_istream<_CharT, _Traits>&& __is,
-        basic_string<_CharT, _Traits, _Allocator>& __str)
-{
-    return std::getline(__is, __str, __is.widen('\n'));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+getline(basic_istream<_CharT, _Traits>&& __is, basic_string<_CharT, _Traits, _Allocator>& __str) {
+  return std::getline(__is, __str, __is.widen('\n'));
 }
 
 template <class _CharT, class _Traits, size_t _Size>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
-{
-    ios_base::iostate __state = ios_base::goodbit;
-    typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
-    if (__sen)
-    {
+operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x) {
+  ios_base::iostate __state = ios_base::goodbit;
+  typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
+  if (__sen) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif
-            basic_string<_CharT, _Traits> __str;
-            const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
-            size_t __c = 0;
-            _CharT __zero = __ct.widen('0');
-            _CharT __one = __ct.widen('1');
-            while (__c != _Size)
-            {
-                typename _Traits::int_type __i = __is.rdbuf()->sgetc();
-                if (_Traits::eq_int_type(__i, _Traits::eof()))
-                {
-                   __state |= ios_base::eofbit;
-                   break;
-                }
-                _CharT __ch = _Traits::to_char_type(__i);
-                if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one))
-                    break;
-                __str.push_back(__ch);
-                ++__c;
-                 __is.rdbuf()->sbumpc();
-            }
-            __x = bitset<_Size>(__str);
-            if (_Size > 0 && __c == 0)
-               __state |= ios_base::failbit;
+      basic_string<_CharT, _Traits> __str;
+      const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__is.getloc());
+      size_t __c                = 0;
+      _CharT __zero             = __ct.widen('0');
+      _CharT __one              = __ct.widen('1');
+      while (__c != _Size) {
+        typename _Traits::int_type __i = __is.rdbuf()->sgetc();
+        if (_Traits::eq_int_type(__i, _Traits::eof())) {
+          __state |= ios_base::eofbit;
+          break;
+        }
+        _CharT __ch = _Traits::to_char_type(__i);
+        if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one))
+          break;
+        __str.push_back(__ch);
+        ++__c;
+        __is.rdbuf()->sbumpc();
+      }
+      __x = bitset<_Size>(__str);
+      if (_Size > 0 && __c == 0)
+        __state |= ios_base::failbit;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __state |= ios_base::badbit;
-            __is.__setstate_nothrow(__state);
-            if (__is.exceptions() & ios_base::badbit)
-            {
-                throw;
-            }
-        }
-#endif
-        __is.setstate(__state);
+    } catch (...) {
+      __state |= ios_base::badbit;
+      __is.__setstate_nothrow(__state);
+      if (__is.exceptions() & ios_base::badbit) {
+        throw;
+      }
     }
-    return __is;
+#endif
+    __is.setstate(__state);
+  }
+  return __is;
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_istream<char>;
@@ -1644,6 +1363,8 @@ _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
+#  include <iosfwd>
+#  include <ostream>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/iterator b/third_party/libcxx/iterator
index c4bec919d..fca75f0a1 100644
--- a/third_party/libcxx/iterator
+++ b/third_party/libcxx/iterator
@@ -475,6 +475,11 @@ constexpr move_iterator<Iterator> operator+(   // constexpr in C++17
 template <class Iterator>   // constexpr in C++17
 constexpr  move_iterator<Iterator> make_move_iterator(const Iterator& i);
 
+template<class Iterator1, class Iterator2>
+    requires (!sized_sentinel_for<Iterator1, Iterator2>)
+  inline constexpr bool disable_sized_sentinel_for<move_iterator<Iterator1>,    // since C++20
+                                                    move_iterator<Iterator2>> = true;
+
 template<semiregular S>
 class move_sentinel {
 public:
@@ -634,25 +639,25 @@ public:
     bool failed() const noexcept;
 };
 
-template <class C> constexpr auto begin(C& c) -> decltype(c.begin());
-template <class C> constexpr auto begin(const C& c) -> decltype(c.begin());
-template <class C> constexpr auto end(C& c) -> decltype(c.end());
-template <class C> constexpr auto end(const C& c) -> decltype(c.end());
-template <class T, size_t N> constexpr T* begin(T (&array)[N]);
-template <class T, size_t N> constexpr T* end(T (&array)[N]);
+template <class C> constexpr auto begin(C& c) -> decltype(c.begin());                   // constexpr since C++17
+template <class C> constexpr auto begin(const C& c) -> decltype(c.begin());             // constexpr since C++17
+template <class C> constexpr auto end(C& c) -> decltype(c.end());                       // constexpr since C++17
+template <class C> constexpr auto end(const C& c) -> decltype(c.end());                 // constexpr since C++17
+template <class T, size_t N> constexpr T* begin(T (&array)[N]) noexcept;
+template <class T, size_t N> constexpr T* end(T (&array)[N]) noexcept;
 
-template <class C> auto constexpr cbegin(const C& c) -> decltype(std::begin(c));        // C++14
-template <class C> auto constexpr cend(const C& c) -> decltype(std::end(c));            // C++14
-template <class C> auto constexpr rbegin(C& c) -> decltype(c.rbegin());                 // C++14
-template <class C> auto constexpr rbegin(const C& c) -> decltype(c.rbegin());           // C++14
-template <class C> auto constexpr rend(C& c) -> decltype(c.rend());                     // C++14
-template <class C> constexpr auto rend(const C& c) -> decltype(c.rend());               // C++14
-template <class E> reverse_iterator<const E*> constexpr rbegin(initializer_list<E> il); // C++14
-template <class E> reverse_iterator<const E*> constexpr rend(initializer_list<E> il);   // C++14
-template <class T, size_t N> reverse_iterator<T*> constexpr rbegin(T (&array)[N]);      // C++14
-template <class T, size_t N> reverse_iterator<T*> constexpr rend(T (&array)[N]);        // C++14
-template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));      // C++14
-template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));          // C++14
+template <class C> constexpr auto cbegin(const C& c) noexcept(see-below) -> decltype(std::begin(c)); // C++14
+template <class C> constexpr auto cend(const C& c) noexcept(see-below) -> decltype(std::end(c));     // C++14
+template <class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());                 // C++14, constexpr since C++17
+template <class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());           // C++14, constexpr since C++17
+template <class C> constexpr auto rend(C& c) -> decltype(c.rend());                     // C++14, constexpr since C++17
+template <class C> constexpr auto rend(const C& c) -> decltype(c.rend());               // C++14, constexpr since C++17
+template <class E> constexpr reverse_iterator<const E*> rbegin(initializer_list<E> il); // C++14, constexpr since C++17
+template <class E> constexpr reverse_iterator<const E*> rend(initializer_list<E> il);   // C++14, constexpr since C++17
+template <class T, size_t N> constexpr reverse_iterator<T*> rbegin(T (&array)[N]);      // C++14, constexpr since C++17
+template <class T, size_t N> constexpr reverse_iterator<T*> rend(T (&array)[N]);        // C++14, constexpr since C++17
+template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));      // C++14, constexpr since C++17
+template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));          // C++14, constexpr since C++17
 
 // 24.8, container access:
 template <class C> constexpr auto size(const C& c) -> decltype(c.size());         // C++17
@@ -674,51 +679,53 @@ template <class E> constexpr const E* data(initializer_list<E> il) noexcept;
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__debug>
 #include <__iterator/access.h>
 #include <__iterator/advance.h>
 #include <__iterator/back_insert_iterator.h>
-#include <__iterator/bounded_iter.h>
-#include <__iterator/common_iterator.h>
-#include <__iterator/concepts.h>
-#include <__iterator/counted_iterator.h>
-#include <__iterator/data.h>
-#include <__iterator/default_sentinel.h>
 #include <__iterator/distance.h>
-#include <__iterator/empty.h>
-#include <__iterator/erase_if_container.h>
 #include <__iterator/front_insert_iterator.h>
-#include <__iterator/incrementable_traits.h>
-#include <__iterator/indirectly_comparable.h>
 #include <__iterator/insert_iterator.h>
 #include <__iterator/istream_iterator.h>
 #include <__iterator/istreambuf_iterator.h>
-#include <__iterator/iter_move.h>
-#include <__iterator/iter_swap.h>
 #include <__iterator/iterator.h>
 #include <__iterator/iterator_traits.h>
-#include <__iterator/mergeable.h>
 #include <__iterator/move_iterator.h>
-#include <__iterator/move_sentinel.h>
 #include <__iterator/next.h>
 #include <__iterator/ostream_iterator.h>
 #include <__iterator/ostreambuf_iterator.h>
-#include <__iterator/permutable.h>
 #include <__iterator/prev.h>
-#include <__iterator/projected.h>
-#include <__iterator/readable_traits.h>
-#include <__iterator/reverse_access.h>
 #include <__iterator/reverse_iterator.h>
-#include <__iterator/size.h>
-#include <__iterator/sortable.h>
-#include <__iterator/unreachable_sentinel.h>
 #include <__iterator/wrap_iter.h>
-#include <__memory/addressof.h>
-#include <__memory/pointer_traits.h>
-#include <cstddef>
-#include <initializer_list>
+
+#if _LIBCPP_STD_VER >= 14
+#  include <__iterator/reverse_access.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 17
+#  include <__iterator/data.h>
+#  include <__iterator/empty.h>
+#  include <__iterator/size.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__iterator/common_iterator.h>
+#  include <__iterator/concepts.h>
+#  include <__iterator/counted_iterator.h>
+#  include <__iterator/default_sentinel.h>
+#  include <__iterator/incrementable_traits.h>
+#  include <__iterator/indirectly_comparable.h>
+#  include <__iterator/iter_move.h>
+#  include <__iterator/iter_swap.h>
+#  include <__iterator/mergeable.h>
+#  include <__iterator/move_sentinel.h>
+#  include <__iterator/permutable.h>
+#  include <__iterator/projected.h>
+#  include <__iterator/readable_traits.h>
+#  include <__iterator/sortable.h>
+#  include <__iterator/unreachable_sentinel.h>
+#endif
+
 #include <version>
 
 // standard-mandated includes
@@ -731,6 +738,10 @@ template <class E> constexpr const E* data(initializer_list<E> il) noexcept;
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <variant>
+#endif
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <cstdlib>
 #  include <exception>
diff --git a/third_party/libcxx/latch b/third_party/libcxx/latch
index 8e1309ea8..81d6028a9 100644
--- a/third_party/libcxx/latch
+++ b/third_party/libcxx/latch
@@ -40,80 +40,88 @@ namespace std
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__atomic/atomic_base.h>
-#include <__atomic/atomic_sync.h>
-#include <__atomic/memory_order.h>
-#include <__availability>
 #include <__config>
-#include <cstddef>
-#include <limits>
-#include <version>
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#if !defined(_LIBCPP_HAS_NO_THREADS)
 
-#ifdef _LIBCPP_HAS_NO_THREADS
-# error "<latch> is not supported since libc++ has been configured without support for threads."
-#endif
+#  include <__assert>
+#  include <__atomic/atomic_base.h>
+#  include <__atomic/atomic_sync.h>
+#  include <__atomic/memory_order.h>
+#  include <cstddef>
+#  include <limits>
+#  include <version>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 _LIBCPP_PUSH_MACROS
-#include <__undef_macros>
+#  include <__undef_macros>
 
-#if _LIBCPP_STD_VER >= 14
+#  if _LIBCPP_STD_VER >= 14
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class latch
-{
-    __atomic_base<ptrdiff_t> __a_;
+class _LIBCPP_DEPRECATED_ATOMIC_SYNC latch {
+  __atomic_base<ptrdiff_t> __a_;
 
 public:
-    static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept {
-        return numeric_limits<ptrdiff_t>::max();
-    }
+  static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept { return numeric_limits<ptrdiff_t>::max(); }
 
-    inline _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit latch(ptrdiff_t __expected) : __a_(__expected) { }
+  inline _LIBCPP_HIDE_FROM_ABI constexpr explicit latch(ptrdiff_t __expected) : __a_(__expected) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __expected >= 0,
+        "latch::latch(ptrdiff_t): latch cannot be "
+        "initialized with a negative value");
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __expected <= max(),
+        "latch::latch(ptrdiff_t): latch cannot be "
+        "initialized with a value greater than max()");
+  }
 
-    _LIBCPP_HIDE_FROM_ABI ~latch() = default;
-    latch(const latch&) = delete;
-    latch& operator=(const latch&) = delete;
+  _LIBCPP_HIDE_FROM_ABI ~latch() = default;
+  latch(const latch&)            = delete;
+  latch& operator=(const latch&) = delete;
 
-    inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void count_down(ptrdiff_t __update = 1)
-    {
-        auto const __old = __a_.fetch_sub(__update, memory_order_release);
-        if(__old == __update)
-            __a_.notify_all();
-    }
-    inline _LIBCPP_INLINE_VISIBILITY
-    bool try_wait() const noexcept
-    {
-        return 0 == __a_.load(memory_order_acquire);
-    }
-    inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void wait() const
-    {
-        __cxx_atomic_wait(&__a_.__a_, [&]() -> bool {
-            return try_wait();
-        });
-    }
-    inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void arrive_and_wait(ptrdiff_t __update = 1)
-    {
-        count_down(__update);
-        wait();
-    }
+  inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void count_down(ptrdiff_t __update = 1) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update >= 0, "latch::count_down called with a negative value");
+    auto const __old = __a_.fetch_sub(__update, memory_order_release);
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __update <= __old,
+        "latch::count_down called with a value greater "
+        "than the internal counter");
+    if (__old == __update)
+      __a_.notify_all();
+  }
+  inline _LIBCPP_HIDE_FROM_ABI bool try_wait() const noexcept {
+    auto __value = __a_.load(memory_order_acquire);
+    return try_wait_impl(__value);
+  }
+  inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait() const {
+    std::__atomic_wait_unless(
+        __a_, [this](ptrdiff_t& __value) -> bool { return try_wait_impl(__value); }, memory_order_acquire);
+  }
+  inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_wait(ptrdiff_t __update = 1) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update >= 0, "latch::arrive_and_wait called with a negative value");
+    // other preconditions on __update are checked in count_down()
+
+    count_down(__update);
+    wait();
+  }
+
+private:
+  _LIBCPP_HIDE_FROM_ABI bool try_wait_impl(ptrdiff_t& __value) const noexcept { return __value == 0; }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_STD_VER >= 14
+#  endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
+#endif // !defined(_LIBCPP_HAS_NO_THREADS)
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #endif
diff --git a/third_party/libcxx/legacy_pointer_safety.cpp b/third_party/libcxx/legacy_pointer_safety.cpp
new file mode 100644
index 000000000..a9361ca87
--- /dev/null
+++ b/third_party/libcxx/legacy_pointer_safety.cpp
@@ -0,0 +1,23 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+#include <memory>
+
+// Support for garbage collection was removed in C++23 by https://wg21.link/P2186R2. Libc++ implements
+// that removal as an extension in all Standard versions. However, we still define the functions that
+// were once part of the library's ABI for backwards compatibility.
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_LIBCPP_EXPORTED_FROM_ABI void declare_reachable(void*) {}
+_LIBCPP_EXPORTED_FROM_ABI void declare_no_pointers(char*, size_t) {}
+_LIBCPP_EXPORTED_FROM_ABI void undeclare_no_pointers(char*, size_t) {}
+_LIBCPP_EXPORTED_FROM_ABI void* __undeclare_reachable(void* p) { return p; }
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/libcxx.imp b/third_party/libcxx/libcxx.imp
deleted file mode 100644
index f7decae8e..000000000
--- a/third_party/libcxx/libcxx.imp
+++ /dev/null
@@ -1,53 +0,0 @@
-[
-  { include: [ "<__hash_table>", "private", "<unordered_map>", "public" ] },
-  { include: [ "<__hash_table>", "private", "<unordered_set>", "public" ] },
-  { include: [ "<__locale>", "private", "<locale>", "public" ] },
-  { include: [ "<__node_handle>", "private", "<map>", "public" ] },
-  { include: [ "<__node_handle>", "private", "<set>", "public" ] },
-  { include: [ "<__node_handle>", "private", "<unordered_map>", "public" ] },
-  { include: [ "<__node_handle>", "private", "<unordered_set>", "public" ] },
-  { include: [ "<__split_buffer>", "private", "<deque>", "public" ] },
-  { include: [ "<__split_buffer>", "private", "<vector>", "public" ] },
-  { include: [ "<__threading_support>", "private", "<atomic>", "public" ] },
-  { include: [ "<__threading_support>", "private", "<mutex>", "public" ] },
-  { include: [ "<__threading_support>", "private", "<semaphore>", "public" ] },
-  { include: [ "<__threading_support>", "private", "<thread>", "public" ] },
-  { include: [ "<__tree>", "private", "<map>", "public" ] },
-  { include: [ "<__tree>", "private", "<set>", "public" ] },
-  { include: [ "@<__algorithm/.*>", "private", "<algorithm>", "public" ] },
-  { include: [ "@<__atomic/.*>", "private", "<atomic>", "public" ] },
-  { include: [ "@<__bit/.*>", "private", "<bit>", "public" ] },
-  { include: [ "@<__charconv/.*>", "private", "<charconv>", "public" ] },
-  { include: [ "@<__chrono/.*>", "private", "<chrono>", "public" ] },
-  { include: [ "@<__compare/.*>", "private", "<compare>", "public" ] },
-  { include: [ "@<__concepts/.*>", "private", "<concepts>", "public" ] },
-  { include: [ "@<__condition_variable/.*>", "private", "<condition_variable>", "public" ] },
-  { include: [ "@<__coroutine/.*>", "private", "<coroutine>", "public" ] },
-  { include: [ "@<__debug_utils/.*>", "private", "<debug_utils>", "public" ] },
-  { include: [ "@<__exception/.*>", "private", "<exception>", "public" ] },
-  { include: [ "@<__expected/.*>", "private", "<expected>", "public" ] },
-  { include: [ "@<__filesystem/.*>", "private", "<filesystem>", "public" ] },
-  { include: [ "@<__format/.*>", "private", "<format>", "public" ] },
-  { include: [ "@<__functional/.*>", "private", "<functional>", "public" ] },
-  { include: [ "@<__fwd/.*>", "private", "<fwd>", "public" ] },
-  { include: [ "@<__ios/.*>", "private", "<ios>", "public" ] },
-  { include: [ "@<__iterator/.*>", "private", "<iterator>", "public" ] },
-  { include: [ "@<__locale_dir/.*>", "private", "<locale>", "public" ] },
-  { include: [ "@<__mdspan/.*>", "private", "<mdspan>", "public" ] },
-  { include: [ "@<__memory/.*>", "private", "<memory>", "public" ] },
-  { include: [ "@<__memory_resource/.*>", "private", "<memory_resource>", "public" ] },
-  { include: [ "@<__mutex/.*>", "private", "<mutex>", "public" ] },
-  { include: [ "@<__numeric/.*>", "private", "<numeric>", "public" ] },
-  { include: [ "@<__pstl/.*>", "private", "<pstl>", "public" ] },
-  { include: [ "@<__random/.*>", "private", "<random>", "public" ] },
-  { include: [ "@<__ranges/.*>", "private", "<ranges>", "public" ] },
-  { include: [ "@<__stop_token/.*>", "private", "<stop_token>", "public" ] },
-  { include: [ "@<__string/.*>", "private", "<string>", "public" ] },
-  { include: [ "@<__support/.*>", "private", "<support>", "public" ] },
-  { include: [ "@<__system_error/.*>", "private", "<system_error>", "public" ] },
-  { include: [ "@<__thread/.*>", "private", "<thread>", "public" ] },
-  { include: [ "@<__tuple/.*>", "private", "<tuple>", "public" ] },
-  { include: [ "@<__type_traits/.*>", "private", "<type_traits>", "public" ] },
-  { include: [ "@<__utility/.*>", "private", "<utility>", "public" ] },
-  { include: [ "@<__variant/.*>", "private", "<variant>", "public" ] },
-]
diff --git a/third_party/libcxx/limits b/third_party/libcxx/limits
index 9f5949e63..d55c7cd75 100644
--- a/third_party/libcxx/limits
+++ b/third_party/libcxx/limits
@@ -43,8 +43,8 @@ public:
     static constexpr bool has_infinity = false;
     static constexpr bool has_quiet_NaN = false;
     static constexpr bool has_signaling_NaN = false;
-    static constexpr float_denorm_style has_denorm = denorm_absent;
-    static constexpr bool has_denorm_loss = false;
+    static constexpr float_denorm_style has_denorm = denorm_absent; // deprecated in C++23
+    static constexpr bool has_denorm_loss = false;                  // deprecated in C++23
     static constexpr T infinity() noexcept;
     static constexpr T quiet_NaN() noexcept;
     static constexpr T signaling_NaN() noexcept;
@@ -68,7 +68,7 @@ enum float_round_style
     round_toward_neg_infinity =  3
 };
 
-enum float_denorm_style
+enum float_denorm_style // deprecated in C++23
 {
     denorm_indeterminate = -1,
     denorm_absent = 0,
@@ -102,7 +102,6 @@ template<> class numeric_limits<cv long double>;
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__type_traits/is_arithmetic.h>
 #include <__type_traits/is_signed.h>
@@ -116,708 +115,463 @@ _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 #include <version>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-enum float_round_style
-{
-    round_indeterminate       = -1,
-    round_toward_zero         =  0,
-    round_to_nearest          =  1,
-    round_toward_infinity     =  2,
-    round_toward_neg_infinity =  3
+enum float_round_style {
+  round_indeterminate       = -1,
+  round_toward_zero         = 0,
+  round_to_nearest          = 1,
+  round_toward_infinity     = 2,
+  round_toward_neg_infinity = 3
 };
 
-enum float_denorm_style
-{
-    denorm_indeterminate = -1,
-    denorm_absent = 0,
-    denorm_present = 1
+enum _LIBCPP_DEPRECATED_IN_CXX23 float_denorm_style {
+  denorm_indeterminate = -1,
+  denorm_absent        = 0,
+  denorm_present       = 1
 };
 
 template <class _Tp, bool = is_arithmetic<_Tp>::value>
-class __libcpp_numeric_limits
-{
+class __libcpp_numeric_limits {
 protected:
-    typedef _Tp type;
+  typedef _Tp type;
 
-    static _LIBCPP_CONSTEXPR const  bool is_specialized = false;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return type();}
+  static _LIBCPP_CONSTEXPR const bool is_specialized = false;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type min() _NOEXCEPT { return type(); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type max() _NOEXCEPT { return type(); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT { return type(); }
 
-    static _LIBCPP_CONSTEXPR const int  digits = 0;
-    static _LIBCPP_CONSTEXPR const int  digits10 = 0;
-    static _LIBCPP_CONSTEXPR const int  max_digits10 = 0;
-    static _LIBCPP_CONSTEXPR const bool is_signed = false;
-    static _LIBCPP_CONSTEXPR const bool is_integer = false;
-    static _LIBCPP_CONSTEXPR const bool is_exact = false;
-    static _LIBCPP_CONSTEXPR const int  radix = 0;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return type();}
+  static _LIBCPP_CONSTEXPR const int digits       = 0;
+  static _LIBCPP_CONSTEXPR const int digits10     = 0;
+  static _LIBCPP_CONSTEXPR const int max_digits10 = 0;
+  static _LIBCPP_CONSTEXPR const bool is_signed   = false;
+  static _LIBCPP_CONSTEXPR const bool is_integer  = false;
+  static _LIBCPP_CONSTEXPR const bool is_exact    = false;
+  static _LIBCPP_CONSTEXPR const int radix        = 0;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT { return type(); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT { return type(); }
 
-    static _LIBCPP_CONSTEXPR const int  min_exponent = 0;
-    static _LIBCPP_CONSTEXPR const int  min_exponent10 = 0;
-    static _LIBCPP_CONSTEXPR const int  max_exponent = 0;
-    static _LIBCPP_CONSTEXPR const int  max_exponent10 = 0;
+  static _LIBCPP_CONSTEXPR const int min_exponent   = 0;
+  static _LIBCPP_CONSTEXPR const int min_exponent10 = 0;
+  static _LIBCPP_CONSTEXPR const int max_exponent   = 0;
+  static _LIBCPP_CONSTEXPR const int max_exponent10 = 0;
 
-    static _LIBCPP_CONSTEXPR const bool has_infinity = false;
-    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = false;
-    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = false;
-    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_absent;
-    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return type();}
+  static _LIBCPP_CONSTEXPR const bool has_infinity                                         = false;
+  static _LIBCPP_CONSTEXPR const bool has_quiet_NaN                                        = false;
+  static _LIBCPP_CONSTEXPR const bool has_signaling_NaN                                    = false;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_absent;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const bool has_denorm_loss          = false;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT { return type(); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT { return type(); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT { return type(); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT { return type(); }
 
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
-    static _LIBCPP_CONSTEXPR const bool is_bounded = false;
-    static _LIBCPP_CONSTEXPR const bool is_modulo = false;
+  static _LIBCPP_CONSTEXPR const bool is_iec559  = false;
+  static _LIBCPP_CONSTEXPR const bool is_bounded = false;
+  static _LIBCPP_CONSTEXPR const bool is_modulo  = false;
 
-    static _LIBCPP_CONSTEXPR const bool traps = false;
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
-    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_toward_zero;
+  static _LIBCPP_CONSTEXPR const bool traps                    = false;
+  static _LIBCPP_CONSTEXPR const bool tinyness_before          = false;
+  static _LIBCPP_CONSTEXPR const float_round_style round_style = round_toward_zero;
 };
 
 template <class _Tp, int __digits, bool _IsSigned>
-struct __libcpp_compute_min
-{
-    static _LIBCPP_CONSTEXPR const _Tp value = _Tp(_Tp(1) << __digits);
+struct __libcpp_compute_min {
+  static _LIBCPP_CONSTEXPR const _Tp value = _Tp(_Tp(1) << __digits);
 };
 
 template <class _Tp, int __digits>
-struct __libcpp_compute_min<_Tp, __digits, false>
-{
-    static _LIBCPP_CONSTEXPR const _Tp value = _Tp(0);
+struct __libcpp_compute_min<_Tp, __digits, false> {
+  static _LIBCPP_CONSTEXPR const _Tp value = _Tp(0);
 };
 
 template <class _Tp>
-class __libcpp_numeric_limits<_Tp, true>
-{
+class __libcpp_numeric_limits<_Tp, true> {
 protected:
-    typedef _Tp type;
+  typedef _Tp type;
 
-    static _LIBCPP_CONSTEXPR const bool is_specialized = true;
+  static _LIBCPP_CONSTEXPR const bool is_specialized = true;
 
-    static _LIBCPP_CONSTEXPR const bool is_signed = type(-1) < type(0);
-    static _LIBCPP_CONSTEXPR const int  digits = static_cast<int>(sizeof(type) * __CHAR_BIT__ - is_signed);
-    static _LIBCPP_CONSTEXPR const int  digits10 = digits * 3 / 10;
-    static _LIBCPP_CONSTEXPR const int  max_digits10 = 0;
-    static _LIBCPP_CONSTEXPR const type __min = __libcpp_compute_min<type, digits, is_signed>::value;
-    static _LIBCPP_CONSTEXPR const type __max = is_signed ? type(type(~0) ^ __min) : type(~0);
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __min;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __max;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return min();}
+  static _LIBCPP_CONSTEXPR const bool is_signed   = type(-1) < type(0);
+  static _LIBCPP_CONSTEXPR const int digits       = static_cast<int>(sizeof(type) * __CHAR_BIT__ - is_signed);
+  static _LIBCPP_CONSTEXPR const int digits10     = digits * 3 / 10;
+  static _LIBCPP_CONSTEXPR const int max_digits10 = 0;
+  static _LIBCPP_CONSTEXPR const type __min       = __libcpp_compute_min<type, digits, is_signed>::value;
+  static _LIBCPP_CONSTEXPR const type __max       = is_signed ? type(type(~0) ^ __min) : type(~0);
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type min() _NOEXCEPT { return __min; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type max() _NOEXCEPT { return __max; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT { return min(); }
 
-    static _LIBCPP_CONSTEXPR const bool is_integer = true;
-    static _LIBCPP_CONSTEXPR const bool is_exact = true;
-    static _LIBCPP_CONSTEXPR const int  radix = 2;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return type(0);}
+  static _LIBCPP_CONSTEXPR const bool is_integer = true;
+  static _LIBCPP_CONSTEXPR const bool is_exact   = true;
+  static _LIBCPP_CONSTEXPR const int radix       = 2;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT { return type(0); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT { return type(0); }
 
-    static _LIBCPP_CONSTEXPR const int  min_exponent = 0;
-    static _LIBCPP_CONSTEXPR const int  min_exponent10 = 0;
-    static _LIBCPP_CONSTEXPR const int  max_exponent = 0;
-    static _LIBCPP_CONSTEXPR const int  max_exponent10 = 0;
+  static _LIBCPP_CONSTEXPR const int min_exponent   = 0;
+  static _LIBCPP_CONSTEXPR const int min_exponent10 = 0;
+  static _LIBCPP_CONSTEXPR const int max_exponent   = 0;
+  static _LIBCPP_CONSTEXPR const int max_exponent10 = 0;
 
-    static _LIBCPP_CONSTEXPR const bool has_infinity = false;
-    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = false;
-    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = false;
-    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_absent;
-    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return type(0);}
+  static _LIBCPP_CONSTEXPR const bool has_infinity                                         = false;
+  static _LIBCPP_CONSTEXPR const bool has_quiet_NaN                                        = false;
+  static _LIBCPP_CONSTEXPR const bool has_signaling_NaN                                    = false;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_absent;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const bool has_denorm_loss          = false;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT { return type(0); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT { return type(0); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT { return type(0); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT { return type(0); }
 
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
-    static _LIBCPP_CONSTEXPR const bool is_bounded = true;
-    static _LIBCPP_CONSTEXPR const bool is_modulo = !_VSTD::is_signed<_Tp>::value;
+  static _LIBCPP_CONSTEXPR const bool is_iec559  = false;
+  static _LIBCPP_CONSTEXPR const bool is_bounded = true;
+  static _LIBCPP_CONSTEXPR const bool is_modulo  = !std::is_signed<_Tp>::value;
 
-#if defined(__i386__) || defined(__x86_64__) || defined(__pnacl__) || \
-    defined(__wasm__)
-    static _LIBCPP_CONSTEXPR const bool traps = true;
+#if defined(__i386__) || defined(__x86_64__) || defined(__pnacl__) || defined(__wasm__)
+  static _LIBCPP_CONSTEXPR const bool traps = true;
 #else
-    static _LIBCPP_CONSTEXPR const bool traps = false;
+  static _LIBCPP_CONSTEXPR const bool traps = false;
 #endif
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
-    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_toward_zero;
+  static _LIBCPP_CONSTEXPR const bool tinyness_before          = false;
+  static _LIBCPP_CONSTEXPR const float_round_style round_style = round_toward_zero;
 };
 
 template <>
-class __libcpp_numeric_limits<bool, true>
-{
+class __libcpp_numeric_limits<bool, true> {
 protected:
-    typedef bool type;
+  typedef bool type;
 
-    static _LIBCPP_CONSTEXPR const bool is_specialized = true;
+  static _LIBCPP_CONSTEXPR const bool is_specialized = true;
 
-    static _LIBCPP_CONSTEXPR const bool is_signed = false;
-    static _LIBCPP_CONSTEXPR const int  digits = 1;
-    static _LIBCPP_CONSTEXPR const int  digits10 = 0;
-    static _LIBCPP_CONSTEXPR const int  max_digits10 = 0;
-    static _LIBCPP_CONSTEXPR const type __min = false;
-    static _LIBCPP_CONSTEXPR const type __max = true;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __min;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __max;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return min();}
+  static _LIBCPP_CONSTEXPR const bool is_signed   = false;
+  static _LIBCPP_CONSTEXPR const int digits       = 1;
+  static _LIBCPP_CONSTEXPR const int digits10     = 0;
+  static _LIBCPP_CONSTEXPR const int max_digits10 = 0;
+  static _LIBCPP_CONSTEXPR const type __min       = false;
+  static _LIBCPP_CONSTEXPR const type __max       = true;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type min() _NOEXCEPT { return __min; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type max() _NOEXCEPT { return __max; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT { return min(); }
 
-    static _LIBCPP_CONSTEXPR const bool is_integer = true;
-    static _LIBCPP_CONSTEXPR const bool is_exact = true;
-    static _LIBCPP_CONSTEXPR const int  radix = 2;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return type(0);}
+  static _LIBCPP_CONSTEXPR const bool is_integer = true;
+  static _LIBCPP_CONSTEXPR const bool is_exact   = true;
+  static _LIBCPP_CONSTEXPR const int radix       = 2;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT { return type(0); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT { return type(0); }
 
-    static _LIBCPP_CONSTEXPR const int  min_exponent = 0;
-    static _LIBCPP_CONSTEXPR const int  min_exponent10 = 0;
-    static _LIBCPP_CONSTEXPR const int  max_exponent = 0;
-    static _LIBCPP_CONSTEXPR const int  max_exponent10 = 0;
+  static _LIBCPP_CONSTEXPR const int min_exponent   = 0;
+  static _LIBCPP_CONSTEXPR const int min_exponent10 = 0;
+  static _LIBCPP_CONSTEXPR const int max_exponent   = 0;
+  static _LIBCPP_CONSTEXPR const int max_exponent10 = 0;
 
-    static _LIBCPP_CONSTEXPR const bool has_infinity = false;
-    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = false;
-    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = false;
-    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_absent;
-    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return type(0);}
+  static _LIBCPP_CONSTEXPR const bool has_infinity                                         = false;
+  static _LIBCPP_CONSTEXPR const bool has_quiet_NaN                                        = false;
+  static _LIBCPP_CONSTEXPR const bool has_signaling_NaN                                    = false;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_absent;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const bool has_denorm_loss          = false;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT { return type(0); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT { return type(0); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT { return type(0); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT { return type(0); }
 
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
-    static _LIBCPP_CONSTEXPR const bool is_bounded = true;
-    static _LIBCPP_CONSTEXPR const bool is_modulo = false;
+  static _LIBCPP_CONSTEXPR const bool is_iec559  = false;
+  static _LIBCPP_CONSTEXPR const bool is_bounded = true;
+  static _LIBCPP_CONSTEXPR const bool is_modulo  = false;
 
-    static _LIBCPP_CONSTEXPR const bool traps = false;
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
-    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_toward_zero;
+  static _LIBCPP_CONSTEXPR const bool traps                    = false;
+  static _LIBCPP_CONSTEXPR const bool tinyness_before          = false;
+  static _LIBCPP_CONSTEXPR const float_round_style round_style = round_toward_zero;
 };
 
 template <>
-class __libcpp_numeric_limits<float, true>
-{
+class __libcpp_numeric_limits<float, true> {
 protected:
-    typedef float type;
+  typedef float type;
 
-    static _LIBCPP_CONSTEXPR const bool is_specialized = true;
+  static _LIBCPP_CONSTEXPR const bool is_specialized = true;
 
-    static _LIBCPP_CONSTEXPR const bool is_signed = true;
-    static _LIBCPP_CONSTEXPR const int  digits = __FLT_MANT_DIG__;
-    static _LIBCPP_CONSTEXPR const int  digits10 = __FLT_DIG__;
-    static _LIBCPP_CONSTEXPR const int  max_digits10 = 2+(digits * 30103l)/100000l;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __FLT_MIN__;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __FLT_MAX__;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return -max();}
+  static _LIBCPP_CONSTEXPR const bool is_signed   = true;
+  static _LIBCPP_CONSTEXPR const int digits       = __FLT_MANT_DIG__;
+  static _LIBCPP_CONSTEXPR const int digits10     = __FLT_DIG__;
+  static _LIBCPP_CONSTEXPR const int max_digits10 = 2 + (digits * 30103l) / 100000l;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type min() _NOEXCEPT { return __FLT_MIN__; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type max() _NOEXCEPT { return __FLT_MAX__; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT { return -max(); }
 
-    static _LIBCPP_CONSTEXPR const bool is_integer = false;
-    static _LIBCPP_CONSTEXPR const bool is_exact = false;
-    static _LIBCPP_CONSTEXPR const int  radix = __FLT_RADIX__;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __FLT_EPSILON__;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return 0.5F;}
+  static _LIBCPP_CONSTEXPR const bool is_integer = false;
+  static _LIBCPP_CONSTEXPR const bool is_exact   = false;
+  static _LIBCPP_CONSTEXPR const int radix       = __FLT_RADIX__;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT { return __FLT_EPSILON__; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT { return 0.5F; }
 
-    static _LIBCPP_CONSTEXPR const int  min_exponent = __FLT_MIN_EXP__;
-    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __FLT_MIN_10_EXP__;
-    static _LIBCPP_CONSTEXPR const int  max_exponent = __FLT_MAX_EXP__;
-    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __FLT_MAX_10_EXP__;
+  static _LIBCPP_CONSTEXPR const int min_exponent   = __FLT_MIN_EXP__;
+  static _LIBCPP_CONSTEXPR const int min_exponent10 = __FLT_MIN_10_EXP__;
+  static _LIBCPP_CONSTEXPR const int max_exponent   = __FLT_MAX_EXP__;
+  static _LIBCPP_CONSTEXPR const int max_exponent10 = __FLT_MAX_10_EXP__;
 
-    static _LIBCPP_CONSTEXPR const bool has_infinity = true;
-    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = true;
-    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = true;
-    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_present;
-    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __builtin_huge_valf();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __builtin_nanf("");}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __builtin_nansf("");}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __FLT_DENORM_MIN__;}
+  static _LIBCPP_CONSTEXPR const bool has_infinity                                         = true;
+  static _LIBCPP_CONSTEXPR const bool has_quiet_NaN                                        = true;
+  static _LIBCPP_CONSTEXPR const bool has_signaling_NaN                                    = true;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_present;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const bool has_denorm_loss          = false;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {
+    return __builtin_huge_valf();
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {
+    return __builtin_nanf("");
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {
+    return __builtin_nansf("");
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {
+    return __FLT_DENORM_MIN__;
+  }
 
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = true;
-    static _LIBCPP_CONSTEXPR const bool is_bounded = true;
-    static _LIBCPP_CONSTEXPR const bool is_modulo = false;
+  static _LIBCPP_CONSTEXPR const bool is_iec559  = true;
+  static _LIBCPP_CONSTEXPR const bool is_bounded = true;
+  static _LIBCPP_CONSTEXPR const bool is_modulo  = false;
 
-    static _LIBCPP_CONSTEXPR const bool traps = false;
+  static _LIBCPP_CONSTEXPR const bool traps = false;
 #if (defined(__arm__) || defined(__aarch64__))
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = true;
+  static _LIBCPP_CONSTEXPR const bool tinyness_before = true;
 #else
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
+  static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
 #endif
-    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
+  static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
 };
 
 template <>
-class __libcpp_numeric_limits<double, true>
-{
+class __libcpp_numeric_limits<double, true> {
 protected:
-    typedef double type;
+  typedef double type;
 
-    static _LIBCPP_CONSTEXPR const bool is_specialized = true;
+  static _LIBCPP_CONSTEXPR const bool is_specialized = true;
 
-    static _LIBCPP_CONSTEXPR const bool is_signed = true;
-    static _LIBCPP_CONSTEXPR const int  digits = __DBL_MANT_DIG__;
-    static _LIBCPP_CONSTEXPR const int  digits10 = __DBL_DIG__;
-    static _LIBCPP_CONSTEXPR const int  max_digits10 = 2+(digits * 30103l)/100000l;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __DBL_MIN__;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __DBL_MAX__;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return -max();}
+  static _LIBCPP_CONSTEXPR const bool is_signed   = true;
+  static _LIBCPP_CONSTEXPR const int digits       = __DBL_MANT_DIG__;
+  static _LIBCPP_CONSTEXPR const int digits10     = __DBL_DIG__;
+  static _LIBCPP_CONSTEXPR const int max_digits10 = 2 + (digits * 30103l) / 100000l;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type min() _NOEXCEPT { return __DBL_MIN__; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type max() _NOEXCEPT { return __DBL_MAX__; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT { return -max(); }
 
-    static _LIBCPP_CONSTEXPR const bool is_integer = false;
-    static _LIBCPP_CONSTEXPR const bool is_exact = false;
-    static _LIBCPP_CONSTEXPR const int  radix = __FLT_RADIX__;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __DBL_EPSILON__;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return 0.5;}
+  static _LIBCPP_CONSTEXPR const bool is_integer = false;
+  static _LIBCPP_CONSTEXPR const bool is_exact   = false;
+  static _LIBCPP_CONSTEXPR const int radix       = __FLT_RADIX__;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT { return __DBL_EPSILON__; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT { return 0.5; }
 
-    static _LIBCPP_CONSTEXPR const int  min_exponent = __DBL_MIN_EXP__;
-    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __DBL_MIN_10_EXP__;
-    static _LIBCPP_CONSTEXPR const int  max_exponent = __DBL_MAX_EXP__;
-    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __DBL_MAX_10_EXP__;
+  static _LIBCPP_CONSTEXPR const int min_exponent   = __DBL_MIN_EXP__;
+  static _LIBCPP_CONSTEXPR const int min_exponent10 = __DBL_MIN_10_EXP__;
+  static _LIBCPP_CONSTEXPR const int max_exponent   = __DBL_MAX_EXP__;
+  static _LIBCPP_CONSTEXPR const int max_exponent10 = __DBL_MAX_10_EXP__;
 
-    static _LIBCPP_CONSTEXPR const bool has_infinity = true;
-    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = true;
-    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = true;
-    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_present;
-    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __builtin_huge_val();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __builtin_nan("");}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __builtin_nans("");}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __DBL_DENORM_MIN__;}
+  static _LIBCPP_CONSTEXPR const bool has_infinity                                         = true;
+  static _LIBCPP_CONSTEXPR const bool has_quiet_NaN                                        = true;
+  static _LIBCPP_CONSTEXPR const bool has_signaling_NaN                                    = true;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_present;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const bool has_denorm_loss          = false;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {
+    return __builtin_huge_val();
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {
+    return __builtin_nan("");
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {
+    return __builtin_nans("");
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {
+    return __DBL_DENORM_MIN__;
+  }
 
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = true;
-    static _LIBCPP_CONSTEXPR const bool is_bounded = true;
-    static _LIBCPP_CONSTEXPR const bool is_modulo = false;
+  static _LIBCPP_CONSTEXPR const bool is_iec559  = true;
+  static _LIBCPP_CONSTEXPR const bool is_bounded = true;
+  static _LIBCPP_CONSTEXPR const bool is_modulo  = false;
 
-    static _LIBCPP_CONSTEXPR const bool traps = false;
+  static _LIBCPP_CONSTEXPR const bool traps = false;
 #if (defined(__arm__) || defined(__aarch64__))
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = true;
+  static _LIBCPP_CONSTEXPR const bool tinyness_before = true;
 #else
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
+  static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
 #endif
-    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
+  static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
 };
 
 template <>
-class __libcpp_numeric_limits<long double, true>
-{
+class __libcpp_numeric_limits<long double, true> {
 protected:
-    typedef long double type;
+  typedef long double type;
 
-    static _LIBCPP_CONSTEXPR const bool is_specialized = true;
+  static _LIBCPP_CONSTEXPR const bool is_specialized = true;
 
-    static _LIBCPP_CONSTEXPR const bool is_signed = true;
-    static _LIBCPP_CONSTEXPR const int  digits = __LDBL_MANT_DIG__;
-    static _LIBCPP_CONSTEXPR const int  digits10 = __LDBL_DIG__;
-    static _LIBCPP_CONSTEXPR const int  max_digits10 = 2+(digits * 30103l)/100000l;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __LDBL_MIN__;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __LDBL_MAX__;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return -max();}
+  static _LIBCPP_CONSTEXPR const bool is_signed   = true;
+  static _LIBCPP_CONSTEXPR const int digits       = __LDBL_MANT_DIG__;
+  static _LIBCPP_CONSTEXPR const int digits10     = __LDBL_DIG__;
+  static _LIBCPP_CONSTEXPR const int max_digits10 = 2 + (digits * 30103l) / 100000l;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type min() _NOEXCEPT { return __LDBL_MIN__; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type max() _NOEXCEPT { return __LDBL_MAX__; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT { return -max(); }
 
-    static _LIBCPP_CONSTEXPR const bool is_integer = false;
-    static _LIBCPP_CONSTEXPR const bool is_exact = false;
-    static _LIBCPP_CONSTEXPR const int  radix = __FLT_RADIX__;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __LDBL_EPSILON__;}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return 0.5L;}
+  static _LIBCPP_CONSTEXPR const bool is_integer = false;
+  static _LIBCPP_CONSTEXPR const bool is_exact   = false;
+  static _LIBCPP_CONSTEXPR const int radix       = __FLT_RADIX__;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT { return __LDBL_EPSILON__; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT { return 0.5L; }
 
-    static _LIBCPP_CONSTEXPR const int  min_exponent = __LDBL_MIN_EXP__;
-    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __LDBL_MIN_10_EXP__;
-    static _LIBCPP_CONSTEXPR const int  max_exponent = __LDBL_MAX_EXP__;
-    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __LDBL_MAX_10_EXP__;
+  static _LIBCPP_CONSTEXPR const int min_exponent   = __LDBL_MIN_EXP__;
+  static _LIBCPP_CONSTEXPR const int min_exponent10 = __LDBL_MIN_10_EXP__;
+  static _LIBCPP_CONSTEXPR const int max_exponent   = __LDBL_MAX_EXP__;
+  static _LIBCPP_CONSTEXPR const int max_exponent10 = __LDBL_MAX_10_EXP__;
 
-    static _LIBCPP_CONSTEXPR const bool has_infinity = true;
-    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = true;
-    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = true;
-    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_present;
-    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __builtin_huge_vall();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __builtin_nanl("");}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __builtin_nansl("");}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __LDBL_DENORM_MIN__;}
+  static _LIBCPP_CONSTEXPR const bool has_infinity                                         = true;
+  static _LIBCPP_CONSTEXPR const bool has_quiet_NaN                                        = true;
+  static _LIBCPP_CONSTEXPR const bool has_signaling_NaN                                    = true;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = denorm_present;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const bool has_denorm_loss          = false;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {
+    return __builtin_huge_vall();
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {
+    return __builtin_nanl("");
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {
+    return __builtin_nansl("");
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {
+    return __LDBL_DENORM_MIN__;
+  }
 
 #if defined(__powerpc__) && defined(__LONG_DOUBLE_IBM128__)
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
+  static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
 #else
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = true;
+  static _LIBCPP_CONSTEXPR const bool is_iec559 = true;
 #endif
-    static _LIBCPP_CONSTEXPR const bool is_bounded = true;
-    static _LIBCPP_CONSTEXPR const bool is_modulo = false;
+  static _LIBCPP_CONSTEXPR const bool is_bounded = true;
+  static _LIBCPP_CONSTEXPR const bool is_modulo  = false;
 
-    static _LIBCPP_CONSTEXPR const bool traps = false;
+  static _LIBCPP_CONSTEXPR const bool traps = false;
 #if (defined(__arm__) || defined(__aarch64__))
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = true;
+  static _LIBCPP_CONSTEXPR const bool tinyness_before = true;
 #else
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
+  static _LIBCPP_CONSTEXPR const bool tinyness_before = false;
 #endif
-    static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
+  static _LIBCPP_CONSTEXPR const float_round_style round_style = round_to_nearest;
 };
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS numeric_limits
-    : private __libcpp_numeric_limits<__remove_cv_t<_Tp> >
-{
-    typedef __libcpp_numeric_limits<__remove_cv_t<_Tp> > __base;
-    typedef typename __base::type type;
+class _LIBCPP_TEMPLATE_VIS numeric_limits : private __libcpp_numeric_limits<_Tp> {
+  typedef __libcpp_numeric_limits<_Tp> __base;
+  typedef typename __base::type type;
+
 public:
-    static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
+  static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type min() _NOEXCEPT { return __base::min(); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type max() _NOEXCEPT { return __base::max(); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT { return __base::lowest(); }
 
-    static _LIBCPP_CONSTEXPR const int  digits = __base::digits;
-    static _LIBCPP_CONSTEXPR const int  digits10 = __base::digits10;
-    static _LIBCPP_CONSTEXPR const int  max_digits10 = __base::max_digits10;
-    static _LIBCPP_CONSTEXPR const bool is_signed = __base::is_signed;
-    static _LIBCPP_CONSTEXPR const bool is_integer = __base::is_integer;
-    static _LIBCPP_CONSTEXPR const bool is_exact = __base::is_exact;
-    static _LIBCPP_CONSTEXPR const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return __base::round_error();}
+  static _LIBCPP_CONSTEXPR const int digits       = __base::digits;
+  static _LIBCPP_CONSTEXPR const int digits10     = __base::digits10;
+  static _LIBCPP_CONSTEXPR const int max_digits10 = __base::max_digits10;
+  static _LIBCPP_CONSTEXPR const bool is_signed   = __base::is_signed;
+  static _LIBCPP_CONSTEXPR const bool is_integer  = __base::is_integer;
+  static _LIBCPP_CONSTEXPR const bool is_exact    = __base::is_exact;
+  static _LIBCPP_CONSTEXPR const int radix        = __base::radix;
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {
+    return __base::epsilon();
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {
+    return __base::round_error();
+  }
 
-    static _LIBCPP_CONSTEXPR const int  min_exponent = __base::min_exponent;
-    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __base::min_exponent10;
-    static _LIBCPP_CONSTEXPR const int  max_exponent = __base::max_exponent;
-    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __base::max_exponent10;
+  static _LIBCPP_CONSTEXPR const int min_exponent   = __base::min_exponent;
+  static _LIBCPP_CONSTEXPR const int min_exponent10 = __base::min_exponent10;
+  static _LIBCPP_CONSTEXPR const int max_exponent   = __base::max_exponent;
+  static _LIBCPP_CONSTEXPR const int max_exponent10 = __base::max_exponent10;
 
-    static _LIBCPP_CONSTEXPR const bool has_infinity = __base::has_infinity;
-    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = __base::has_quiet_NaN;
-    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = __base::has_signaling_NaN;
-    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = __base::has_denorm;
-    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __base::denorm_min();}
+  static _LIBCPP_CONSTEXPR const bool has_infinity      = __base::has_infinity;
+  static _LIBCPP_CONSTEXPR const bool has_quiet_NaN     = __base::has_quiet_NaN;
+  static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = __base::has_signaling_NaN;
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = __base::has_denorm;
+  static _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_CONSTEXPR const bool has_denorm_loss          = __base::has_denorm_loss;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {
+    return __base::infinity();
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {
+    return __base::quiet_NaN();
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {
+    return __base::signaling_NaN();
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {
+    return __base::denorm_min();
+  }
 
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = __base::is_iec559;
-    static _LIBCPP_CONSTEXPR const bool is_bounded = __base::is_bounded;
-    static _LIBCPP_CONSTEXPR const bool is_modulo = __base::is_modulo;
+  static _LIBCPP_CONSTEXPR const bool is_iec559  = __base::is_iec559;
+  static _LIBCPP_CONSTEXPR const bool is_bounded = __base::is_bounded;
+  static _LIBCPP_CONSTEXPR const bool is_modulo  = __base::is_modulo;
 
-    static _LIBCPP_CONSTEXPR const bool traps = __base::traps;
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = __base::tinyness_before;
-    static _LIBCPP_CONSTEXPR const float_round_style round_style = __base::round_style;
+  static _LIBCPP_CONSTEXPR const bool traps                    = __base::traps;
+  static _LIBCPP_CONSTEXPR const bool tinyness_before          = __base::tinyness_before;
+  static _LIBCPP_CONSTEXPR const float_round_style round_style = __base::round_style;
 };
 
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_specialized;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_specialized;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::digits;
+_LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::digits;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::digits10;
+_LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::digits10;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::max_digits10;
+_LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::max_digits10;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_signed;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_signed;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_integer;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_integer;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_exact;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_exact;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::radix;
+_LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::radix;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::min_exponent;
+_LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::min_exponent;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::min_exponent10;
+_LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::min_exponent10;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::max_exponent;
+_LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::max_exponent;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::max_exponent10;
+_LIBCPP_CONSTEXPR const int numeric_limits<_Tp>::max_exponent10;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_infinity;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_infinity;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_quiet_NaN;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_quiet_NaN;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_signaling_NaN;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_signaling_NaN;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const float_denorm_style numeric_limits<_Tp>::has_denorm;
+_LIBCPP_CONSTEXPR const float_denorm_style numeric_limits<_Tp>::has_denorm;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_denorm_loss;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::has_denorm_loss;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_iec559;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_iec559;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_bounded;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_bounded;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_modulo;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::is_modulo;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::traps;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::traps;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::tinyness_before;
+_LIBCPP_CONSTEXPR const bool numeric_limits<_Tp>::tinyness_before;
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const float_round_style numeric_limits<_Tp>::round_style;
+_LIBCPP_CONSTEXPR const float_round_style numeric_limits<_Tp>::round_style;
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS numeric_limits<const _Tp>
-    : private numeric_limits<_Tp>
-{
-    typedef numeric_limits<_Tp> __base;
-    typedef _Tp type;
-public:
-    static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
-
-    static _LIBCPP_CONSTEXPR const int  digits = __base::digits;
-    static _LIBCPP_CONSTEXPR const int  digits10 = __base::digits10;
-    static _LIBCPP_CONSTEXPR const int  max_digits10 = __base::max_digits10;
-    static _LIBCPP_CONSTEXPR const bool is_signed = __base::is_signed;
-    static _LIBCPP_CONSTEXPR const bool is_integer = __base::is_integer;
-    static _LIBCPP_CONSTEXPR const bool is_exact = __base::is_exact;
-    static _LIBCPP_CONSTEXPR const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return __base::round_error();}
-
-    static _LIBCPP_CONSTEXPR const int  min_exponent = __base::min_exponent;
-    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __base::min_exponent10;
-    static _LIBCPP_CONSTEXPR const int  max_exponent = __base::max_exponent;
-    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __base::max_exponent10;
-
-    static _LIBCPP_CONSTEXPR const bool has_infinity = __base::has_infinity;
-    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = __base::has_quiet_NaN;
-    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = __base::has_signaling_NaN;
-    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = __base::has_denorm;
-    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __base::denorm_min();}
-
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = __base::is_iec559;
-    static _LIBCPP_CONSTEXPR const bool is_bounded = __base::is_bounded;
-    static _LIBCPP_CONSTEXPR const bool is_modulo = __base::is_modulo;
-
-    static _LIBCPP_CONSTEXPR const bool traps = __base::traps;
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = __base::tinyness_before;
-    static _LIBCPP_CONSTEXPR const float_round_style round_style = __base::round_style;
-};
+class _LIBCPP_TEMPLATE_VIS numeric_limits<const _Tp> : public numeric_limits<_Tp> {};
 
 template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_specialized;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::digits;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::digits10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::max_digits10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_signed;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_integer;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_exact;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::radix;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::min_exponent;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::min_exponent10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::max_exponent;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const _Tp>::max_exponent10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::has_infinity;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::has_quiet_NaN;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::has_signaling_NaN;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const float_denorm_style numeric_limits<const _Tp>::has_denorm;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::has_denorm_loss;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_iec559;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_bounded;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::is_modulo;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::traps;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const _Tp>::tinyness_before;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const float_round_style numeric_limits<const _Tp>::round_style;
+class _LIBCPP_TEMPLATE_VIS numeric_limits<volatile _Tp> : public numeric_limits<_Tp> {};
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS numeric_limits<volatile _Tp>
-    : private numeric_limits<_Tp>
-{
-    typedef numeric_limits<_Tp> __base;
-    typedef _Tp type;
-public:
-    static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
-
-    static _LIBCPP_CONSTEXPR const int  digits = __base::digits;
-    static _LIBCPP_CONSTEXPR const int  digits10 = __base::digits10;
-    static _LIBCPP_CONSTEXPR const int  max_digits10 = __base::max_digits10;
-    static _LIBCPP_CONSTEXPR const bool is_signed = __base::is_signed;
-    static _LIBCPP_CONSTEXPR const bool is_integer = __base::is_integer;
-    static _LIBCPP_CONSTEXPR const bool is_exact = __base::is_exact;
-    static _LIBCPP_CONSTEXPR const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return __base::round_error();}
-
-    static _LIBCPP_CONSTEXPR const int  min_exponent = __base::min_exponent;
-    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __base::min_exponent10;
-    static _LIBCPP_CONSTEXPR const int  max_exponent = __base::max_exponent;
-    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __base::max_exponent10;
-
-    static _LIBCPP_CONSTEXPR const bool has_infinity = __base::has_infinity;
-    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = __base::has_quiet_NaN;
-    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = __base::has_signaling_NaN;
-    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = __base::has_denorm;
-    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __base::denorm_min();}
-
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = __base::is_iec559;
-    static _LIBCPP_CONSTEXPR const bool is_bounded = __base::is_bounded;
-    static _LIBCPP_CONSTEXPR const bool is_modulo = __base::is_modulo;
-
-    static _LIBCPP_CONSTEXPR const bool traps = __base::traps;
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = __base::tinyness_before;
-    static _LIBCPP_CONSTEXPR const float_round_style round_style = __base::round_style;
-};
-
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_specialized;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::digits;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::digits10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::max_digits10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_signed;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_integer;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_exact;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::radix;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::min_exponent;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::min_exponent10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::max_exponent;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<volatile _Tp>::max_exponent10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::has_infinity;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::has_quiet_NaN;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::has_signaling_NaN;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const float_denorm_style numeric_limits<volatile _Tp>::has_denorm;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::has_denorm_loss;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_iec559;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_bounded;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::is_modulo;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::traps;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<volatile _Tp>::tinyness_before;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const float_round_style numeric_limits<volatile _Tp>::round_style;
-
-template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS numeric_limits<const volatile _Tp>
-    : private numeric_limits<_Tp>
-{
-    typedef numeric_limits<_Tp> __base;
-    typedef _Tp type;
-public:
-    static _LIBCPP_CONSTEXPR const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type lowest() _NOEXCEPT {return __base::lowest();}
-
-    static _LIBCPP_CONSTEXPR const int  digits = __base::digits;
-    static _LIBCPP_CONSTEXPR const int  digits10 = __base::digits10;
-    static _LIBCPP_CONSTEXPR const int  max_digits10 = __base::max_digits10;
-    static _LIBCPP_CONSTEXPR const bool is_signed = __base::is_signed;
-    static _LIBCPP_CONSTEXPR const bool is_integer = __base::is_integer;
-    static _LIBCPP_CONSTEXPR const bool is_exact = __base::is_exact;
-    static _LIBCPP_CONSTEXPR const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type round_error() _NOEXCEPT {return __base::round_error();}
-
-    static _LIBCPP_CONSTEXPR const int  min_exponent = __base::min_exponent;
-    static _LIBCPP_CONSTEXPR const int  min_exponent10 = __base::min_exponent10;
-    static _LIBCPP_CONSTEXPR const int  max_exponent = __base::max_exponent;
-    static _LIBCPP_CONSTEXPR const int  max_exponent10 = __base::max_exponent10;
-
-    static _LIBCPP_CONSTEXPR const bool has_infinity = __base::has_infinity;
-    static _LIBCPP_CONSTEXPR const bool has_quiet_NaN = __base::has_quiet_NaN;
-    static _LIBCPP_CONSTEXPR const bool has_signaling_NaN = __base::has_signaling_NaN;
-    static _LIBCPP_CONSTEXPR const float_denorm_style has_denorm = __base::has_denorm;
-    static _LIBCPP_CONSTEXPR const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR type denorm_min() _NOEXCEPT {return __base::denorm_min();}
-
-    static _LIBCPP_CONSTEXPR const bool is_iec559 = __base::is_iec559;
-    static _LIBCPP_CONSTEXPR const bool is_bounded = __base::is_bounded;
-    static _LIBCPP_CONSTEXPR const bool is_modulo = __base::is_modulo;
-
-    static _LIBCPP_CONSTEXPR const bool traps = __base::traps;
-    static _LIBCPP_CONSTEXPR const bool tinyness_before = __base::tinyness_before;
-    static _LIBCPP_CONSTEXPR const float_round_style round_style = __base::round_style;
-};
-
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_specialized;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::digits;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::digits10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::max_digits10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_signed;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_integer;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_exact;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::radix;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::min_exponent;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::min_exponent10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::max_exponent;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const int numeric_limits<const volatile _Tp>::max_exponent10;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::has_infinity;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::has_quiet_NaN;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::has_signaling_NaN;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const float_denorm_style numeric_limits<const volatile _Tp>::has_denorm;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::has_denorm_loss;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_iec559;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_bounded;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::is_modulo;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::traps;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const bool numeric_limits<const volatile _Tp>::tinyness_before;
-template <class _Tp>
-    _LIBCPP_CONSTEXPR const float_round_style numeric_limits<const volatile _Tp>::round_style;
+class _LIBCPP_TEMPLATE_VIS numeric_limits<const volatile _Tp> : public numeric_limits<_Tp> {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/limits.h b/third_party/libcxx/limits.h
deleted file mode 100644
index 537a4b143..000000000
--- a/third_party/libcxx/limits.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_LIMITS_H
-#define _LIBCPP_LIMITS_H
-
-/*
-    limits.h synopsis
-
-Macros:
-
-    CHAR_BIT
-    SCHAR_MIN
-    SCHAR_MAX
-    UCHAR_MAX
-    CHAR_MIN
-    CHAR_MAX
-    MB_LEN_MAX
-    SHRT_MIN
-    SHRT_MAX
-    USHRT_MAX
-    INT_MIN
-    INT_MAX
-    UINT_MAX
-    LONG_MIN
-    LONG_MAX
-    ULONG_MAX
-    LLONG_MIN   // C99
-    LLONG_MAX   // C99
-    ULLONG_MAX  // C99
-
-*/
-
-#include <__config>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#ifdef _LIBCPP_COMPILER_GCC
-
-// GCC header limits.h recursively includes itself through another header called
-// syslimits.h for some reason. This setup breaks down if we directly
-// #include_next GCC's limits.h (reasons not entirely clear to me).
-// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=107795 for more details.
-// Therefore, we manually re-create the necessary include sequence below:
-
-// Get the system limits.h defines (force recurse into the next level)
-#define _GCC_LIMITS_H_
-#define _GCC_NEXT_LIMITS_H
-#include_next <limits.h>
-
-// Get the ISO C defines
-#undef _GCC_LIMITS_H_
-#include_next <limits.h>
-
-#else
-
-#  if __has_include_next(<limits.h>)
-#    include_next <limits.h>
-#  endif
-
-#endif // _LIBCPP_COMPILER_GCC
-
-#endif // _LIBCPP_LIMITS_H
diff --git a/third_party/libcxx/list b/third_party/libcxx/list
index dd56b893c..929c84de7 100644
--- a/third_party/libcxx/list
+++ b/third_party/libcxx/list
@@ -46,6 +46,8 @@ public:
         list(Iter first, Iter last);
     template <class Iter>
         list(Iter first, Iter last, const allocator_type& a);
+    template<container-compatible-range<T> R>
+      list(from_range_t, R&& rg, const Allocator& = Allocator()); // C++23
     list(const list& x);
     list(const list&, const allocator_type& a);
     list(list&& x)
@@ -64,6 +66,8 @@ public:
     list& operator=(initializer_list<value_type>);
     template <class Iter>
         void assign(Iter first, Iter last);
+    template<container-compatible-range<T> R>
+      void assign_range(R&& rg); // C++23
     void assign(size_type n, const value_type& t);
     void assign(initializer_list<value_type>);
 
@@ -99,8 +103,12 @@ public:
     void pop_back();
     void push_front(const value_type& x);
     void push_front(value_type&& x);
+    template<container-compatible-range<T> R>
+      void prepend_range(R&& rg); // C++23
     void push_back(const value_type& x);
     void push_back(value_type&& x);
+    template<container-compatible-range<T> R>
+      void append_range(R&& rg); // C++23
     template <class... Args>
         iterator emplace(const_iterator position, Args&&... args);
     iterator insert(const_iterator position, const value_type& x);
@@ -108,6 +116,8 @@ public:
     iterator insert(const_iterator position, size_type n, const value_type& x);
     template <class Iter>
         iterator insert(const_iterator position, Iter first, Iter last);
+    template<container-compatible-range<T> R>
+      iterator insert_range(const_iterator position, R&& rg); // C++23
     iterator insert(const_iterator position, initializer_list<value_type> il);
 
     iterator erase(const_iterator position);
@@ -152,6 +162,10 @@ template <class InputIterator, class Allocator = allocator<typename iterator_tra
     list(InputIterator, InputIterator, Allocator = Allocator())
     -> list<typename iterator_traits<InputIterator>::value_type, Allocator>;  // C++17
 
+template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
+  list(from_range_t, R&&, Allocator = Allocator())
+    -> list<ranges::range_value_t<R>, Allocator>; // C++23
+
 template <class T, class Alloc>
     bool operator==(const list<T,Alloc>& x, const list<T,Alloc>& y);
 template <class T, class Alloc>
@@ -188,9 +202,8 @@ template <class T, class Allocator, class Predicate>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/min.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__format/enable_insertable.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
@@ -199,19 +212,22 @@ template <class T, class Allocator, class Predicate>
 #include <__iterator/prev.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/addressof.h>
+#include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
-#include <__memory/allocator_destructor.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
+#include <__memory/construct_at.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
-#include <__memory/unique_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/is_allocator.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/type_identity.h>
@@ -220,6 +236,7 @@ template <class T, class Allocator, class Predicate>
 #include <__utility/swap.h>
 #include <cstring>
 #include <limits>
+#include <new> // __launder
 #include <version>
 
 // standard-mandated includes
@@ -242,18 +259,17 @@ template <class T, class Allocator, class Predicate>
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _VoidPtr> struct __list_node;
-template <class _Tp, class _VoidPtr> struct __list_node_base;
+template <class _Tp, class _VoidPtr>
+struct __list_node;
+template <class _Tp, class _VoidPtr>
+struct __list_node_base;
 
 template <class _Tp, class _VoidPtr>
 struct __list_node_pointer_traits {
-  typedef __rebind_pointer_t<_VoidPtr, __list_node<_Tp, _VoidPtr> >
-        __node_pointer;
-  typedef __rebind_pointer_t<_VoidPtr, __list_node_base<_Tp, _VoidPtr> >
-        __base_pointer;
+  typedef __rebind_pointer_t<_VoidPtr, __list_node<_Tp, _VoidPtr> > __node_pointer;
+  typedef __rebind_pointer_t<_VoidPtr, __list_node_base<_Tp, _VoidPtr> > __base_pointer;
 
 #if defined(_LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB)
   typedef __base_pointer __link_pointer;
@@ -264,2083 +280,1398 @@ struct __list_node_pointer_traits {
   typedef __conditional_t<is_same<__link_pointer, __node_pointer>::value, __base_pointer, __node_pointer>
       __non_link_pointer;
 
-  static _LIBCPP_INLINE_VISIBILITY
-  __link_pointer __unsafe_link_pointer_cast(__link_pointer __p) {
-      return __p;
-  }
+  static _LIBCPP_HIDE_FROM_ABI __link_pointer __unsafe_link_pointer_cast(__link_pointer __p) { return __p; }
 
-  static _LIBCPP_INLINE_VISIBILITY
-  __link_pointer __unsafe_link_pointer_cast(__non_link_pointer __p) {
-      return static_cast<__link_pointer>(static_cast<_VoidPtr>(__p));
+  static _LIBCPP_HIDE_FROM_ABI __link_pointer __unsafe_link_pointer_cast(__non_link_pointer __p) {
+    return static_cast<__link_pointer>(static_cast<_VoidPtr>(__p));
   }
-
 };
 
 template <class _Tp, class _VoidPtr>
-struct __list_node_base
-{
-    typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
-    typedef typename _NodeTraits::__node_pointer __node_pointer;
-    typedef typename _NodeTraits::__base_pointer __base_pointer;
-    typedef typename _NodeTraits::__link_pointer __link_pointer;
+struct __list_node_base {
+  typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
+  typedef typename _NodeTraits::__node_pointer __node_pointer;
+  typedef typename _NodeTraits::__base_pointer __base_pointer;
+  typedef typename _NodeTraits::__link_pointer __link_pointer;
 
-    __link_pointer __prev_;
-    __link_pointer __next_;
+  __link_pointer __prev_;
+  __link_pointer __next_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __list_node_base() : __prev_(_NodeTraits::__unsafe_link_pointer_cast(__self())),
-                         __next_(_NodeTraits::__unsafe_link_pointer_cast(__self())) {}
+  _LIBCPP_HIDE_FROM_ABI __list_node_base()
+      : __prev_(_NodeTraits::__unsafe_link_pointer_cast(__self())),
+        __next_(_NodeTraits::__unsafe_link_pointer_cast(__self())) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __base_pointer __self() {
-        return pointer_traits<__base_pointer>::pointer_to(*this);
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit __list_node_base(__link_pointer __prev, __link_pointer __next)
+      : __prev_(__prev), __next_(__next) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __as_node() {
-        return static_cast<__node_pointer>(__self());
-    }
+  _LIBCPP_HIDE_FROM_ABI __base_pointer __self() { return pointer_traits<__base_pointer>::pointer_to(*this); }
+
+  _LIBCPP_HIDE_FROM_ABI __node_pointer __as_node() { return static_cast<__node_pointer>(__self()); }
 };
 
 template <class _Tp, class _VoidPtr>
-struct _LIBCPP_STANDALONE_DEBUG __list_node
-    : public __list_node_base<_Tp, _VoidPtr>
-{
+struct __list_node : public __list_node_base<_Tp, _VoidPtr> {
+  // We allow starting the lifetime of nodes without initializing the value held by the node,
+  // since that is handled by the list itself in order to be allocator-aware.
+#ifndef _LIBCPP_CXX03_LANG
+
+private:
+  union {
     _Tp __value_;
+  };
 
-    typedef __list_node_base<_Tp, _VoidPtr> __base;
-    typedef typename __base::__link_pointer __link_pointer;
+public:
+  _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return __value_; }
+#else
 
-    _LIBCPP_INLINE_VISIBILITY
-    __link_pointer __as_link() {
-        return static_cast<__link_pointer>(__base::__self());
-    }
+private:
+  _ALIGNAS_TYPE(_Tp) char __buffer_[sizeof(_Tp)];
+
+public:
+  _LIBCPP_HIDE_FROM_ABI _Tp& __get_value() { return *std::__launder(reinterpret_cast<_Tp*>(&__buffer_)); }
+#endif
+
+  typedef __list_node_base<_Tp, _VoidPtr> __base;
+  typedef typename __base::__link_pointer __link_pointer;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __list_node(__link_pointer __prev, __link_pointer __next) : __base(__prev, __next) {}
+  _LIBCPP_HIDE_FROM_ABI ~__list_node() {}
+
+  _LIBCPP_HIDE_FROM_ABI __link_pointer __as_link() { return static_cast<__link_pointer>(__base::__self()); }
 };
 
-template <class _Tp, class _Alloc = allocator<_Tp> > class _LIBCPP_TEMPLATE_VIS list;
-template <class _Tp, class _Alloc> class __list_imp;
-template <class _Tp, class _VoidPtr> class _LIBCPP_TEMPLATE_VIS __list_const_iterator;
+template <class _Tp, class _Alloc = allocator<_Tp> >
+class _LIBCPP_TEMPLATE_VIS list;
+template <class _Tp, class _Alloc>
+class __list_imp;
+template <class _Tp, class _VoidPtr>
+class _LIBCPP_TEMPLATE_VIS __list_const_iterator;
 
 template <class _Tp, class _VoidPtr>
-class _LIBCPP_TEMPLATE_VIS __list_iterator
-{
-    typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
-    typedef typename _NodeTraits::__link_pointer __link_pointer;
+class _LIBCPP_TEMPLATE_VIS __list_iterator {
+  typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
+  typedef typename _NodeTraits::__link_pointer __link_pointer;
 
-    __link_pointer __ptr_;
+  __link_pointer __ptr_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __list_iterator(__link_pointer __p, const void* __c) _NOEXCEPT
-        : __ptr_(__p)
-    {
-        (void)__c;
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-        __get_db()->__insert_ic(this, __c);
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit __list_iterator(__link_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+
+  template <class, class>
+  friend class list;
+  template <class, class>
+  friend class __list_imp;
+  template <class, class>
+  friend class __list_const_iterator;
 
-    template<class, class> friend class list;
-    template<class, class> friend class __list_imp;
-    template<class, class> friend class __list_const_iterator;
 public:
-    typedef bidirectional_iterator_tag       iterator_category;
-    typedef _Tp                              value_type;
-    typedef value_type&                      reference;
-    typedef __rebind_pointer_t<_VoidPtr, value_type> pointer;
-    typedef typename pointer_traits<pointer>::difference_type difference_type;
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef _Tp value_type;
+  typedef value_type& reference;
+  typedef __rebind_pointer_t<_VoidPtr, value_type> pointer;
+  typedef typename pointer_traits<pointer>::difference_type difference_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __list_iterator() _NOEXCEPT : __ptr_(nullptr)
-    {
-        _VSTD::__debug_db_insert_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI __list_iterator() _NOEXCEPT : __ptr_(nullptr) {}
 
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __ptr_->__as_node()->__get_value(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const {
+    return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__get_value());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __list_iterator(const __list_iterator& __p)
-        : __ptr_(__p.__ptr_)
-    {
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__p));
-    }
+  _LIBCPP_HIDE_FROM_ABI __list_iterator& operator++() {
+    __ptr_ = __ptr_->__next_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __list_iterator operator++(int) {
+    __list_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~__list_iterator()
-    {
-        __get_db()->__erase_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI __list_iterator& operator--() {
+    __ptr_ = __ptr_->__prev_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __list_iterator operator--(int) {
+    __list_iterator __t(*this);
+    --(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __list_iterator& operator=(const __list_iterator& __p)
-    {
-        if (this != _VSTD::addressof(__p))
-        {
-            __get_db()->__iterator_copy(this, _VSTD::addressof(__p));
-            __ptr_ = __p.__ptr_;
-        }
-        return *this;
-    }
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
-
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to dereference a non-dereferenceable list::iterator");
-        return __ptr_->__as_node()->__value_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to dereference a non-dereferenceable list::iterator");
-        return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__value_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __list_iterator& operator++()
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to increment a non-incrementable list::iterator");
-        __ptr_ = __ptr_->__next_;
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __list_iterator operator++(int) {__list_iterator __t(*this); ++(*this); return __t;}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __list_iterator& operator--()
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__decrementable(this),
-                             "Attempted to decrement a non-decrementable list::iterator");
-        __ptr_ = __ptr_->__prev_;
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __list_iterator operator--(int) {__list_iterator __t(*this); --(*this); return __t;}
-
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __list_iterator& __x, const __list_iterator& __y)
-    {
-        return __x.__ptr_ == __y.__ptr_;
-    }
-    friend _LIBCPP_INLINE_VISIBILITY
-     bool operator!=(const __list_iterator& __x, const __list_iterator& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __list_iterator& __x, const __list_iterator& __y) {
+    return __x.__ptr_ == __y.__ptr_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __list_iterator& __x, const __list_iterator& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _Tp, class _VoidPtr>
-class _LIBCPP_TEMPLATE_VIS __list_const_iterator
-{
-    typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
-    typedef typename _NodeTraits::__link_pointer __link_pointer;
+class _LIBCPP_TEMPLATE_VIS __list_const_iterator {
+  typedef __list_node_pointer_traits<_Tp, _VoidPtr> _NodeTraits;
+  typedef typename _NodeTraits::__link_pointer __link_pointer;
 
-    __link_pointer __ptr_;
+  __link_pointer __ptr_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __list_const_iterator(__link_pointer __p, const void* __c) _NOEXCEPT
-        : __ptr_(__p)
-    {
-        (void)__c;
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-        __get_db()->__insert_ic(this, __c);
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit __list_const_iterator(__link_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+
+  template <class, class>
+  friend class list;
+  template <class, class>
+  friend class __list_imp;
 
-    template<class, class> friend class list;
-    template<class, class> friend class __list_imp;
 public:
-    typedef bidirectional_iterator_tag       iterator_category;
-    typedef _Tp                              value_type;
-    typedef const value_type&                reference;
-    typedef __rebind_pointer_t<_VoidPtr, const value_type> pointer;
-    typedef typename pointer_traits<pointer>::difference_type difference_type;
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef _Tp value_type;
+  typedef const value_type& reference;
+  typedef __rebind_pointer_t<_VoidPtr, const value_type> pointer;
+  typedef typename pointer_traits<pointer>::difference_type difference_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __list_const_iterator() _NOEXCEPT : __ptr_(nullptr)
-    {
-        _VSTD::__debug_db_insert_i(this);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __list_const_iterator(const __list_iterator<_Tp, _VoidPtr>& __p) _NOEXCEPT
-        : __ptr_(__p.__ptr_)
-    {
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__p));
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI __list_const_iterator() _NOEXCEPT : __ptr_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI __list_const_iterator(const __list_iterator<_Tp, _VoidPtr>& __p) _NOEXCEPT
+      : __ptr_(__p.__ptr_) {}
 
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __ptr_->__as_node()->__get_value(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const {
+    return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__get_value());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __list_const_iterator(const __list_const_iterator& __p)
-        : __ptr_(__p.__ptr_)
-    {
-        __get_db()->__iterator_copy(this, _VSTD::addressof(__p));
-    }
+  _LIBCPP_HIDE_FROM_ABI __list_const_iterator& operator++() {
+    __ptr_ = __ptr_->__next_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __list_const_iterator operator++(int) {
+    __list_const_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~__list_const_iterator()
-    {
-        __get_db()->__erase_i(this);
-    }
+  _LIBCPP_HIDE_FROM_ABI __list_const_iterator& operator--() {
+    __ptr_ = __ptr_->__prev_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __list_const_iterator operator--(int) {
+    __list_const_iterator __t(*this);
+    --(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __list_const_iterator& operator=(const __list_const_iterator& __p)
-    {
-        if (this != _VSTD::addressof(__p))
-        {
-            __get_db()->__iterator_copy(this, _VSTD::addressof(__p));
-            __ptr_ = __p.__ptr_;
-        }
-        return *this;
-    }
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to dereference a non-dereferenceable list::const_iterator");
-        return __ptr_->__as_node()->__value_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to dereference a non-dereferenceable list::const_iterator");
-        return pointer_traits<pointer>::pointer_to(__ptr_->__as_node()->__value_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __list_const_iterator& operator++()
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(this),
-                             "Attempted to increment a non-incrementable list::const_iterator");
-        __ptr_ = __ptr_->__next_;
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __list_const_iterator operator++(int) {__list_const_iterator __t(*this); ++(*this); return __t;}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __list_const_iterator& operator--()
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__decrementable(this),
-                             "Attempted to decrement a non-decrementable list::const_iterator");
-        __ptr_ = __ptr_->__prev_;
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __list_const_iterator operator--(int) {__list_const_iterator __t(*this); --(*this); return __t;}
-
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __list_const_iterator& __x, const __list_const_iterator& __y)
-    {
-        return __x.__ptr_ == __y.__ptr_;
-    }
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __list_const_iterator& __x, const __list_const_iterator& __y)
-        {return !(__x == __y);}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __list_const_iterator& __x, const __list_const_iterator& __y) {
+    return __x.__ptr_ == __y.__ptr_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __list_const_iterator& __x, const __list_const_iterator& __y) {
+    return !(__x == __y);
+  }
 };
 
 template <class _Tp, class _Alloc>
-class __list_imp
-{
-    __list_imp(const __list_imp&);
-    __list_imp& operator=(const __list_imp&);
+class __list_imp {
 public:
-    typedef _Alloc                                                  allocator_type;
-    typedef allocator_traits<allocator_type>                        __alloc_traits;
-    typedef typename __alloc_traits::size_type                      size_type;
+  __list_imp(const __list_imp&) = delete;
+  __list_imp& operator=(const __list_imp&) = delete;
+
+  typedef _Alloc allocator_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
+  typedef typename __alloc_traits::size_type size_type;
+
 protected:
-    typedef _Tp                                                     value_type;
-    typedef typename __alloc_traits::void_pointer                   __void_pointer;
-    typedef __list_iterator<value_type, __void_pointer>             iterator;
-    typedef __list_const_iterator<value_type, __void_pointer>       const_iterator;
-    typedef __list_node_base<value_type, __void_pointer>            __node_base;
-    typedef __list_node<value_type, __void_pointer>                 __node;
-    typedef __rebind_alloc<__alloc_traits, __node>                  __node_allocator;
-    typedef allocator_traits<__node_allocator>                       __node_alloc_traits;
-    typedef typename __node_alloc_traits::pointer                    __node_pointer;
-    typedef typename __node_alloc_traits::pointer                    __node_const_pointer;
-    typedef __list_node_pointer_traits<value_type, __void_pointer> __node_pointer_traits;
-    typedef typename __node_pointer_traits::__link_pointer __link_pointer;
-    typedef __link_pointer __link_const_pointer;
-    typedef typename __alloc_traits::pointer                         pointer;
-    typedef typename __alloc_traits::const_pointer                   const_pointer;
-    typedef typename __alloc_traits::difference_type                 difference_type;
+  typedef _Tp value_type;
+  typedef typename __alloc_traits::void_pointer __void_pointer;
+  typedef __list_iterator<value_type, __void_pointer> iterator;
+  typedef __list_const_iterator<value_type, __void_pointer> const_iterator;
+  typedef __list_node_base<value_type, __void_pointer> __node_base;
+  typedef __list_node<value_type, __void_pointer> __node_type;
+  typedef __rebind_alloc<__alloc_traits, __node_type> __node_allocator;
+  typedef allocator_traits<__node_allocator> __node_alloc_traits;
+  typedef typename __node_alloc_traits::pointer __node_pointer;
+  typedef typename __node_alloc_traits::pointer __node_const_pointer;
+  typedef __list_node_pointer_traits<value_type, __void_pointer> __node_pointer_traits;
+  typedef typename __node_pointer_traits::__link_pointer __link_pointer;
+  typedef __link_pointer __link_const_pointer;
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
+  typedef typename __alloc_traits::difference_type difference_type;
 
-    typedef __rebind_alloc<__alloc_traits, __node_base>               __node_base_allocator;
-    typedef typename allocator_traits<__node_base_allocator>::pointer __node_base_pointer;
-    static_assert((!is_same<allocator_type, __node_allocator>::value),
-                  "internal allocator type must differ from user-specified "
-                  "type; otherwise overload resolution breaks");
+  typedef __rebind_alloc<__alloc_traits, __node_base> __node_base_allocator;
+  typedef typename allocator_traits<__node_base_allocator>::pointer __node_base_pointer;
+  static_assert(!is_same<allocator_type, __node_allocator>::value,
+                "internal allocator type must differ from user-specified type; otherwise overload resolution breaks");
 
-    __node_base __end_;
-    __compressed_pair<size_type, __node_allocator> __size_alloc_;
+  __node_base __end_;
+  __compressed_pair<size_type, __node_allocator> __size_alloc_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __link_pointer __end_as_link() const _NOEXCEPT {
-        return __node_pointer_traits::__unsafe_link_pointer_cast(
-                const_cast<__node_base&>(__end_).__self());
-    }
+  _LIBCPP_HIDE_FROM_ABI __link_pointer __end_as_link() const _NOEXCEPT {
+    return __node_pointer_traits::__unsafe_link_pointer_cast(const_cast<__node_base&>(__end_).__self());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-          size_type& __sz() _NOEXCEPT {return __size_alloc_.first();}
-    _LIBCPP_INLINE_VISIBILITY
-    const size_type& __sz() const _NOEXCEPT
-        {return __size_alloc_.first();}
-    _LIBCPP_INLINE_VISIBILITY
-          __node_allocator& __node_alloc() _NOEXCEPT
-          {return __size_alloc_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const __node_allocator& __node_alloc() const _NOEXCEPT
-        {return __size_alloc_.second();}
+  _LIBCPP_HIDE_FROM_ABI size_type& __sz() _NOEXCEPT { return __size_alloc_.first(); }
+  _LIBCPP_HIDE_FROM_ABI const size_type& __sz() const _NOEXCEPT { return __size_alloc_.first(); }
+  _LIBCPP_HIDE_FROM_ABI __node_allocator& __node_alloc() _NOEXCEPT { return __size_alloc_.second(); }
+  _LIBCPP_HIDE_FROM_ABI const __node_allocator& __node_alloc() const _NOEXCEPT { return __size_alloc_.second(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type __node_alloc_max_size() const _NOEXCEPT {
-        return __node_alloc_traits::max_size(__node_alloc());
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    static void __unlink_nodes(__link_pointer __f, __link_pointer __l) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI size_type __node_alloc_max_size() const _NOEXCEPT {
+    return __node_alloc_traits::max_size(__node_alloc());
+  }
+  _LIBCPP_HIDE_FROM_ABI static void __unlink_nodes(__link_pointer __f, __link_pointer __l) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __list_imp()
-        _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    __list_imp(const allocator_type& __a);
-    _LIBCPP_INLINE_VISIBILITY
-    __list_imp(const __node_allocator& __a);
+  _LIBCPP_HIDE_FROM_ABI __list_imp() _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value);
+  _LIBCPP_HIDE_FROM_ABI __list_imp(const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI __list_imp(const __node_allocator& __a);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI __list_imp(__node_allocator&& __a) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI __list_imp(__node_allocator&& __a) _NOEXCEPT;
 #endif
-    _LIBCPP_HIDE_FROM_ABI ~__list_imp();
-    _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return __sz() == 0;}
+  _LIBCPP_HIDE_FROM_ABI ~__list_imp();
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __sz() == 0; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator begin() _NOEXCEPT
-    {
-        return iterator(__end_.__next_, this);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const  _NOEXCEPT
-    {
-        return const_iterator(__end_.__next_, this);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    iterator end() _NOEXCEPT
-    {
-        return iterator(__end_as_link(), this);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT
-    {
-        return const_iterator(__end_as_link(), this);
-    }
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return iterator(__end_.__next_); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return const_iterator(__end_.__next_); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return iterator(__end_as_link()); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return const_iterator(__end_as_link()); }
 
-    _LIBCPP_HIDE_FROM_ABI void swap(__list_imp& __c)
+  _LIBCPP_HIDE_FROM_ABI void swap(__list_imp& __c)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT;
+      _NOEXCEPT;
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<allocator_type>::value);
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>);
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const __list_imp& __c)
-        {__copy_assign_alloc(__c, integral_constant<bool,
-                      __node_alloc_traits::propagate_on_container_copy_assignment::value>());}
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __list_imp& __c) {
+    __copy_assign_alloc(
+        __c, integral_constant<bool, __node_alloc_traits::propagate_on_container_copy_assignment::value>());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__list_imp& __c)
-        _NOEXCEPT_(
-            !__node_alloc_traits::propagate_on_container_move_assignment::value ||
-            is_nothrow_move_assignable<__node_allocator>::value)
-        {__move_assign_alloc(__c, integral_constant<bool,
-                      __node_alloc_traits::propagate_on_container_move_assignment::value>());}
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__list_imp& __c)
+      _NOEXCEPT_(!__node_alloc_traits::propagate_on_container_move_assignment::value ||
+                 is_nothrow_move_assignable<__node_allocator>::value) {
+    __move_assign_alloc(
+        __c, integral_constant<bool, __node_alloc_traits::propagate_on_container_move_assignment::value>());
+  }
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI __node_pointer __create_node(__link_pointer __prev, __link_pointer __next, _Args&&... __args) {
+    __node_allocator& __alloc = __node_alloc();
+    __allocation_guard<__node_allocator> __guard(__alloc, 1);
+    // Begin the lifetime of the node itself. Note that this doesn't begin the lifetime of the value
+    // held inside the node, since we need to use the allocator's construct() method for that.
+    //
+    // We don't use the allocator's construct() method to construct the node itself since the
+    // Cpp17FooInsertable named requirements don't require the allocator's construct() method
+    // to work on anything other than the value_type.
+    std::__construct_at(std::addressof(*__guard.__get()), __prev, __next);
+
+    // Now construct the value_type using the allocator's construct() method.
+    __node_alloc_traits::construct(
+        __alloc, std::addressof(__guard.__get()->__get_value()), std::forward<_Args>(__args)...);
+    return __guard.__release_ptr();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __delete_node(__node_pointer __node) {
+    // For the same reason as above, we use the allocator's destroy() method for the value_type,
+    // but not for the node itself.
+    __node_allocator& __alloc = __node_alloc();
+    __node_alloc_traits::destroy(__alloc, std::addressof(__node->__get_value()));
+    std::__destroy_at(std::addressof(*__node));
+    __node_alloc_traits::deallocate(__alloc, __node, 1);
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const __list_imp& __c, true_type)
-        {
-            if (__node_alloc() != __c.__node_alloc())
-                clear();
-            __node_alloc() = __c.__node_alloc();
-        }
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __list_imp& __c, true_type) {
+    if (__node_alloc() != __c.__node_alloc())
+      clear();
+    __node_alloc() = __c.__node_alloc();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const __list_imp&, false_type)
-        {}
+  _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __list_imp&, false_type) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__list_imp& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
-        {
-            __node_alloc() = _VSTD::move(__c.__node_alloc());
-        }
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__list_imp& __c, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value) {
+    __node_alloc() = std::move(__c.__node_alloc());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__list_imp&, false_type)
-        _NOEXCEPT
-        {}
+  _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__list_imp&, false_type) _NOEXCEPT {}
 };
 
 // Unlink nodes [__f, __l]
 template <class _Tp, class _Alloc>
-inline
-void
-__list_imp<_Tp, _Alloc>::__unlink_nodes(__link_pointer __f, __link_pointer __l)
-    _NOEXCEPT
-{
-    __f->__prev_->__next_ = __l->__next_;
-    __l->__next_->__prev_ = __f->__prev_;
+inline void __list_imp<_Tp, _Alloc>::__unlink_nodes(__link_pointer __f, __link_pointer __l) _NOEXCEPT {
+  __f->__prev_->__next_ = __l->__next_;
+  __l->__next_->__prev_ = __f->__prev_;
 }
 
 template <class _Tp, class _Alloc>
-inline
-__list_imp<_Tp, _Alloc>::__list_imp()
-        _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
-    : __size_alloc_(0, __default_init_tag())
-{
-}
+inline __list_imp<_Tp, _Alloc>::__list_imp() _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
+    : __size_alloc_(0, __default_init_tag()) {}
 
 template <class _Tp, class _Alloc>
-inline
-__list_imp<_Tp, _Alloc>::__list_imp(const allocator_type& __a)
-    : __size_alloc_(0, __node_allocator(__a))
-{
-}
+inline __list_imp<_Tp, _Alloc>::__list_imp(const allocator_type& __a) : __size_alloc_(0, __node_allocator(__a)) {}
 
 template <class _Tp, class _Alloc>
-inline __list_imp<_Tp, _Alloc>::__list_imp(const __node_allocator& __a)
-    : __size_alloc_(0, __a) {}
+inline __list_imp<_Tp, _Alloc>::__list_imp(const __node_allocator& __a) : __size_alloc_(0, __a) {}
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp, class _Alloc>
-inline __list_imp<_Tp, _Alloc>::__list_imp(__node_allocator&& __a) _NOEXCEPT
-    : __size_alloc_(0, _VSTD::move(__a)) {}
+inline __list_imp<_Tp, _Alloc>::__list_imp(__node_allocator&& __a) _NOEXCEPT : __size_alloc_(0, std::move(__a)) {}
 #endif
 
 template <class _Tp, class _Alloc>
 __list_imp<_Tp, _Alloc>::~__list_imp() {
   clear();
-  std::__debug_db_erase_c(this);
 }
 
 template <class _Tp, class _Alloc>
-void
-__list_imp<_Tp, _Alloc>::clear() _NOEXCEPT
-{
-    if (!empty())
-    {
-        __node_allocator& __na = __node_alloc();
-        __link_pointer __f = __end_.__next_;
-        __link_pointer __l = __end_as_link();
-        __unlink_nodes(__f, __l->__prev_);
-        __sz() = 0;
-        while (__f != __l)
-        {
-            __node_pointer __np = __f->__as_node();
-            __f = __f->__next_;
-            __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
-            __node_alloc_traits::deallocate(__na, __np, 1);
-        }
-        std::__debug_db_invalidate_all(this);
+void __list_imp<_Tp, _Alloc>::clear() _NOEXCEPT {
+  if (!empty()) {
+    __link_pointer __f = __end_.__next_;
+    __link_pointer __l = __end_as_link();
+    __unlink_nodes(__f, __l->__prev_);
+    __sz() = 0;
+    while (__f != __l) {
+      __node_pointer __np = __f->__as_node();
+      __f                 = __f->__next_;
+      __delete_node(__np);
     }
+  }
 }
 
 template <class _Tp, class _Alloc>
-void
-__list_imp<_Tp, _Alloc>::swap(__list_imp& __c)
+void __list_imp<_Tp, _Alloc>::swap(__list_imp& __c)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT
+    _NOEXCEPT
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<allocator_type>::value)
+    _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>)
 #endif
 {
-    _LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value ||
-                   this->__node_alloc() == __c.__node_alloc(),
-                   "list::swap: Either propagate_on_container_swap must be true"
-                   " or the allocators must compare equal");
-    using _VSTD::swap;
-    _VSTD::__swap_allocator(__node_alloc(), __c.__node_alloc());
-    swap(__sz(), __c.__sz());
-    swap(__end_, __c.__end_);
-    if (__sz() == 0)
-        __end_.__next_ = __end_.__prev_ = __end_as_link();
-    else
-        __end_.__prev_->__next_ = __end_.__next_->__prev_ = __end_as_link();
-    if (__c.__sz() == 0)
-        __c.__end_.__next_ = __c.__end_.__prev_ = __c.__end_as_link();
-    else
-        __c.__end_.__prev_->__next_ = __c.__end_.__next_->__prev_ = __c.__end_as_link();
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    __libcpp_db* __db = __get_db();
-    __c_node* __cn1 = __db->__find_c_and_lock(this);
-    __c_node* __cn2 = __db->__find_c(_VSTD::addressof(__c));
-    _VSTD::swap(__cn1->beg_, __cn2->beg_);
-    _VSTD::swap(__cn1->end_, __cn2->end_);
-    _VSTD::swap(__cn1->cap_, __cn2->cap_);
-    for (__i_node** __p = __cn1->end_; __p != __cn1->beg_;)
-    {
-        --__p;
-        const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
-        if (__i->__ptr_ == __c.__end_as_link())
-        {
-            __cn2->__add(*__p);
-            if (--__cn1->end_ != __p)
-                _VSTD::memmove(__p, __p+1, (__cn1->end_ - __p)*sizeof(__i_node*));
-        }
-        else
-            (*__p)->__c_ = __cn1;
-    }
-    for (__i_node** __p = __cn2->end_; __p != __cn2->beg_;)
-    {
-        --__p;
-        const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
-        if (__i->__ptr_ == __end_as_link())
-        {
-            __cn1->__add(*__p);
-            if (--__cn2->end_ != __p)
-                _VSTD::memmove(__p, __p+1, (__cn2->end_ - __p)*sizeof(__i_node*));
-        }
-        else
-            (*__p)->__c_ = __cn2;
-    }
-    __db->unlock();
-#endif
+  _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+      __alloc_traits::propagate_on_container_swap::value || this->__node_alloc() == __c.__node_alloc(),
+      "list::swap: Either propagate_on_container_swap must be true"
+      " or the allocators must compare equal");
+  using std::swap;
+  std::__swap_allocator(__node_alloc(), __c.__node_alloc());
+  swap(__sz(), __c.__sz());
+  swap(__end_, __c.__end_);
+  if (__sz() == 0)
+    __end_.__next_ = __end_.__prev_ = __end_as_link();
+  else
+    __end_.__prev_->__next_ = __end_.__next_->__prev_ = __end_as_link();
+  if (__c.__sz() == 0)
+    __c.__end_.__next_ = __c.__end_.__prev_ = __c.__end_as_link();
+  else
+    __c.__end_.__prev_->__next_ = __c.__end_.__next_->__prev_ = __c.__end_as_link();
 }
 
 template <class _Tp, class _Alloc /*= allocator<_Tp>*/>
-class _LIBCPP_TEMPLATE_VIS list
-    : private __list_imp<_Tp, _Alloc>
-{
-    typedef __list_imp<_Tp, _Alloc> base;
-    typedef typename base::__node              __node;
-    typedef typename base::__node_allocator    __node_allocator;
-    typedef typename base::__node_pointer      __node_pointer;
-    typedef typename base::__node_alloc_traits __node_alloc_traits;
-    typedef typename base::__node_base         __node_base;
-    typedef typename base::__node_base_pointer __node_base_pointer;
-    typedef typename base::__link_pointer __link_pointer;
+class _LIBCPP_TEMPLATE_VIS list : private __list_imp<_Tp, _Alloc> {
+  typedef __list_imp<_Tp, _Alloc> base;
+  typedef typename base::__node_type __node_type;
+  typedef typename base::__node_allocator __node_allocator;
+  typedef typename base::__node_pointer __node_pointer;
+  typedef typename base::__node_alloc_traits __node_alloc_traits;
+  typedef typename base::__node_base __node_base;
+  typedef typename base::__node_base_pointer __node_base_pointer;
+  typedef typename base::__link_pointer __link_pointer;
 
 public:
-    typedef _Tp                                            value_type;
-    typedef _Alloc                                         allocator_type;
-    static_assert((is_same<value_type, typename allocator_type::value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
-    typedef value_type&                                    reference;
-    typedef const value_type&                              const_reference;
-    typedef typename base::pointer                         pointer;
-    typedef typename base::const_pointer                   const_pointer;
-    typedef typename base::size_type                       size_type;
-    typedef typename base::difference_type                 difference_type;
-    typedef typename base::iterator                        iterator;
-    typedef typename base::const_iterator                  const_iterator;
-    typedef _VSTD::reverse_iterator<iterator>              reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator>        const_reverse_iterator;
+  typedef _Tp value_type;
+  typedef _Alloc allocator_type;
+  static_assert(__check_valid_allocator<allocator_type>::value);
+  static_assert(is_same<value_type, typename allocator_type::value_type>::value,
+                "Allocator::value_type must be same type as value_type");
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef typename base::pointer pointer;
+  typedef typename base::const_pointer const_pointer;
+  typedef typename base::size_type size_type;
+  typedef typename base::difference_type difference_type;
+  typedef typename base::iterator iterator;
+  typedef typename base::const_iterator const_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 #if _LIBCPP_STD_VER >= 20
-    typedef size_type                                      __remove_return_type;
+  typedef size_type __remove_return_type;
 #else
-    typedef void                                           __remove_return_type;
+  typedef void __remove_return_type;
 #endif
 
-    static_assert(is_same<allocator_type, __rebind_alloc<allocator_traits<allocator_type>, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
-
-    _LIBCPP_INLINE_VISIBILITY
-    list()
-        _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
-    {
-        _VSTD::__debug_db_insert_c(this);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    explicit list(const allocator_type& __a) : base(__a)
-    {
-        _VSTD::__debug_db_insert_c(this);
-    }
-    _LIBCPP_HIDE_FROM_ABI explicit list(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI list() _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value) {}
+  _LIBCPP_HIDE_FROM_ABI explicit list(const allocator_type& __a) : base(__a) {}
+  _LIBCPP_HIDE_FROM_ABI explicit list(size_type __n);
 #if _LIBCPP_STD_VER >= 14
-    _LIBCPP_HIDE_FROM_ABI explicit list(size_type __n, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI explicit list(size_type __n, const allocator_type& __a);
 #endif
-    _LIBCPP_HIDE_FROM_ABI list(size_type __n, const value_type& __x);
-    template <class = __enable_if_t<__is_allocator<_Alloc>::value> >
-    _LIBCPP_HIDE_FROM_ABI list(size_type __n, const value_type& __x, const allocator_type& __a) : base(__a)
-    {
-        _VSTD::__debug_db_insert_c(this);
-        for (; __n > 0; --__n)
-            push_back(__x);
-    }
+  _LIBCPP_HIDE_FROM_ABI list(size_type __n, const value_type& __x);
+  template <__enable_if_t<__is_allocator<_Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI list(size_type __n, const value_type& __x, const allocator_type& __a) : base(__a) {
+    for (; __n > 0; --__n)
+      push_back(__x);
+  }
 
-    template <class _InpIter>
-    _LIBCPP_HIDE_FROM_ABI list(_InpIter __f, _InpIter __l,
-             __enable_if_t<__has_input_iterator_category<_InpIter>::value>* = 0);
-    template <class _InpIter>
-    _LIBCPP_HIDE_FROM_ABI list(_InpIter __f, _InpIter __l, const allocator_type& __a,
-             __enable_if_t<__has_input_iterator_category<_InpIter>::value>* = 0);
+  template <class _InpIter, __enable_if_t<__has_input_iterator_category<_InpIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI list(_InpIter __f, _InpIter __l);
 
-    _LIBCPP_HIDE_FROM_ABI list(const list& __c);
-    _LIBCPP_HIDE_FROM_ABI list(const list& __c, const __type_identity_t<allocator_type>& __a);
-    _LIBCPP_INLINE_VISIBILITY
-    list& operator=(const list& __c);
+  template <class _InpIter, __enable_if_t<__has_input_iterator_category<_InpIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI list(_InpIter __f, _InpIter __l, const allocator_type& __a);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI list(from_range_t, _Range&& __range, const allocator_type& __a = allocator_type()) : base(__a) {
+    prepend_range(std::forward<_Range>(__range));
+  }
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI list(const list& __c);
+  _LIBCPP_HIDE_FROM_ABI list(const list& __c, const __type_identity_t<allocator_type>& __a);
+  _LIBCPP_HIDE_FROM_ABI list& operator=(const list& __c);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI list(initializer_list<value_type> __il);
-    _LIBCPP_HIDE_FROM_ABI list(initializer_list<value_type> __il, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI list(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI list(initializer_list<value_type> __il, const allocator_type& __a);
 
-    _LIBCPP_INLINE_VISIBILITY
-    list(list&& __c)
-        _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    list(list&& __c, const __type_identity_t<allocator_type>& __a);
-    _LIBCPP_INLINE_VISIBILITY
-    list& operator=(list&& __c)
-        _NOEXCEPT_(
-            __node_alloc_traits::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<__node_allocator>::value);
+  _LIBCPP_HIDE_FROM_ABI list(list&& __c) _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
+  _LIBCPP_HIDE_FROM_ABI list(list&& __c, const __type_identity_t<allocator_type>& __a);
+  _LIBCPP_HIDE_FROM_ABI list& operator=(list&& __c)
+      _NOEXCEPT_(__node_alloc_traits::propagate_on_container_move_assignment::value&&
+                     is_nothrow_move_assignable<__node_allocator>::value);
 
-    _LIBCPP_INLINE_VISIBILITY
-    list& operator=(initializer_list<value_type> __il)
-        {assign(__il.begin(), __il.end()); return *this;}
+  _LIBCPP_HIDE_FROM_ABI list& operator=(initializer_list<value_type> __il) {
+    assign(__il.begin(), __il.end());
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void assign(initializer_list<value_type> __il)
-        {assign(__il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI void assign(initializer_list<value_type> __il) { assign(__il.begin(), __il.end()); }
 #endif // _LIBCPP_CXX03_LANG
 
-    template <class _InpIter>
-    _LIBCPP_HIDE_FROM_ABI void assign(_InpIter __f, _InpIter __l,
-                    __enable_if_t<__has_input_iterator_category<_InpIter>::value>* = 0);
-    _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __x);
+  template <class _InpIter, __enable_if_t<__has_input_iterator_category<_InpIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI void assign(_InpIter __f, _InpIter __l);
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT;
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void assign_range(_Range&& __range) {
+    __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
+  }
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT     {return base::__sz();}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT         {return base::empty();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT
-        {
-            return _VSTD::min<size_type>(
-                base::__node_alloc_max_size(),
-                numeric_limits<difference_type >::max());
-        }
+  _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __x);
 
-    _LIBCPP_INLINE_VISIBILITY
-          iterator begin() _NOEXCEPT        {return base::begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT {return base::begin();}
-    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT          {return base::end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT {return base::end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return base::begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {return base::end();}
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rbegin() _NOEXCEPT
-            {return       reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin()  const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rend() _NOEXCEPT
-            {return       reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend()    const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend()   const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return base::__sz(); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return base::empty(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+    return std::min<size_type>(base::__node_alloc_max_size(), numeric_limits<difference_type >::max());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference front()
-    {
-        _LIBCPP_ASSERT(!empty(), "list::front called on empty list");
-        return base::__end_.__next_->__as_node()->__value_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference front() const
-    {
-        _LIBCPP_ASSERT(!empty(), "list::front called on empty list");
-        return base::__end_.__next_->__as_node()->__value_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    reference back()
-    {
-        _LIBCPP_ASSERT(!empty(), "list::back called on empty list");
-        return base::__end_.__prev_->__as_node()->__value_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference back() const
-    {
-        _LIBCPP_ASSERT(!empty(), "list::back called on empty list");
-        return base::__end_.__prev_->__as_node()->__value_;
-    }
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return base::begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return base::begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return base::end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return base::end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return base::begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return base::end(); }
+
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return const_reverse_iterator(begin()); }
+
+  _LIBCPP_HIDE_FROM_ABI reference front() {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::front called on empty list");
+    return base::__end_.__next_->__as_node()->__get_value();
+  }
+  _LIBCPP_HIDE_FROM_ABI const_reference front() const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::front called on empty list");
+    return base::__end_.__next_->__as_node()->__get_value();
+  }
+  _LIBCPP_HIDE_FROM_ABI reference back() {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::back called on empty list");
+    return base::__end_.__prev_->__as_node()->__get_value();
+  }
+  _LIBCPP_HIDE_FROM_ABI const_reference back() const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::back called on empty list");
+    return base::__end_.__prev_->__as_node()->__get_value();
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __x);
-    _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __x);
+  _LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __x);
+  _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __x);
 
-    template <class... _Args>
-#if _LIBCPP_STD_VER >= 17
-    _LIBCPP_HIDE_FROM_ABI reference emplace_front(_Args&&... __args);
-#else
-    _LIBCPP_HIDE_FROM_ABI void      emplace_front(_Args&&... __args);
-#endif
-    template <class... _Args>
-#if _LIBCPP_STD_VER >= 17
-    _LIBCPP_HIDE_FROM_ABI reference emplace_back(_Args&&... __args);
-#else
-    _LIBCPP_HIDE_FROM_ABI void       emplace_back(_Args&&... __args);
-#endif
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __p, _Args&&... __args);
+#  if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void prepend_range(_Range&& __range) {
+    insert_range(begin(), std::forward<_Range>(__range));
+  }
 
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __x);
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void append_range(_Range&& __range) {
+    insert_range(end(), std::forward<_Range>(__range));
+  }
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, initializer_list<value_type> __il)
-        {return insert(__p, __il.begin(), __il.end());}
+  template <class... _Args>
+#  if _LIBCPP_STD_VER >= 17
+  _LIBCPP_HIDE_FROM_ABI reference emplace_front(_Args&&... __args);
+#  else
+  _LIBCPP_HIDE_FROM_ABI void emplace_front(_Args&&... __args);
+#  endif
+  template <class... _Args>
+#  if _LIBCPP_STD_VER >= 17
+  _LIBCPP_HIDE_FROM_ABI reference emplace_back(_Args&&... __args);
+#  else
+  _LIBCPP_HIDE_FROM_ABI void emplace_back(_Args&&... __args);
+#  endif
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __p, _Args&&... __args);
+
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __x);
+
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, initializer_list<value_type> __il) {
+    return insert(__p, __il.begin(), __il.end());
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __x);
-    _LIBCPP_HIDE_FROM_ABI void push_back(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI void push_back(const value_type& __x);
 
 #ifndef _LIBCPP_CXX03_LANG
-    template <class _Arg>
-    _LIBCPP_INLINE_VISIBILITY
-    void __emplace_back(_Arg&& __arg) { emplace_back(_VSTD::forward<_Arg>(__arg)); }
+  template <class _Arg>
+  _LIBCPP_HIDE_FROM_ABI void __emplace_back(_Arg&& __arg) {
+    emplace_back(std::forward<_Arg>(__arg));
+  }
 #else
-    _LIBCPP_INLINE_VISIBILITY
-    void __emplace_back(value_type const& __arg) { push_back(__arg); }
+  _LIBCPP_HIDE_FROM_ABI void __emplace_back(value_type const& __arg) { push_back(__arg); }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __x);
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, size_type __n, const value_type& __x);
-    template <class _InpIter>
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _InpIter __f, _InpIter __l,
-                        __enable_if_t<__has_input_iterator_category<_InpIter>::value>* = 0);
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, size_type __n, const value_type& __x);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(list& __c)
+  template <class _InpIter, __enable_if_t<__has_input_iterator_category<_InpIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _InpIter __f, _InpIter __l);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI iterator insert_range(const_iterator __position, _Range&& __range) {
+    return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
+  }
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI void swap(list& __c)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT
+      _NOEXCEPT
 #else
-        _NOEXCEPT_(!__node_alloc_traits::propagate_on_container_swap::value ||
-                   __is_nothrow_swappable<__node_allocator>::value)
+      _NOEXCEPT_(!__node_alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<__node_allocator>)
 #endif
-        {base::swap(__c);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {base::clear();}
+  {
+    base::swap(__c);
+  }
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { base::clear(); }
 
-    _LIBCPP_HIDE_FROM_ABI void pop_front();
-    _LIBCPP_HIDE_FROM_ABI void pop_back();
+  _LIBCPP_HIDE_FROM_ABI void pop_front();
+  _LIBCPP_HIDE_FROM_ABI void pop_back();
 
-    _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
-    _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l);
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p);
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l);
 
-    _LIBCPP_HIDE_FROM_ABI void resize(size_type __n);
-    _LIBCPP_HIDE_FROM_ABI void resize(size_type __n, const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI void resize(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI void resize(size_type __n, const value_type& __x);
 
-    _LIBCPP_HIDE_FROM_ABI void splice(const_iterator __p, list& __c);
+  _LIBCPP_HIDE_FROM_ABI void splice(const_iterator __p, list& __c);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void splice(const_iterator __p, list&& __c) {splice(__p, __c);}
-    _LIBCPP_INLINE_VISIBILITY
-    void splice(const_iterator __p, list&& __c, const_iterator __i)
-        {splice(__p, __c, __i);}
-    _LIBCPP_INLINE_VISIBILITY
-    void splice(const_iterator __p, list&& __c, const_iterator __f, const_iterator __l)
-        {splice(__p, __c, __f, __l);}
+  _LIBCPP_HIDE_FROM_ABI void splice(const_iterator __p, list&& __c) { splice(__p, __c); }
+  _LIBCPP_HIDE_FROM_ABI void splice(const_iterator __p, list&& __c, const_iterator __i) { splice(__p, __c, __i); }
+  _LIBCPP_HIDE_FROM_ABI void splice(const_iterator __p, list&& __c, const_iterator __f, const_iterator __l) {
+    splice(__p, __c, __f, __l);
+  }
 #endif
-    _LIBCPP_HIDE_FROM_ABI void splice(const_iterator __p, list& __c, const_iterator __i);
-    _LIBCPP_HIDE_FROM_ABI void splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l);
+  _LIBCPP_HIDE_FROM_ABI void splice(const_iterator __p, list& __c, const_iterator __i);
+  _LIBCPP_HIDE_FROM_ABI void splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l);
 
-    _LIBCPP_HIDE_FROM_ABI __remove_return_type remove(const value_type& __x);
-    template <class _Pred>
-    _LIBCPP_HIDE_FROM_ABI __remove_return_type remove_if(_Pred __pred);
-    _LIBCPP_INLINE_VISIBILITY
-    __remove_return_type unique() { return unique(__equal_to()); }
-    template <class _BinaryPred>
-    _LIBCPP_HIDE_FROM_ABI __remove_return_type unique(_BinaryPred __binary_pred);
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(list& __c);
+  _LIBCPP_HIDE_FROM_ABI __remove_return_type remove(const value_type& __x);
+  template <class _Pred>
+  _LIBCPP_HIDE_FROM_ABI __remove_return_type remove_if(_Pred __pred);
+  _LIBCPP_HIDE_FROM_ABI __remove_return_type unique() { return unique(__equal_to()); }
+  template <class _BinaryPred>
+  _LIBCPP_HIDE_FROM_ABI __remove_return_type unique(_BinaryPred __binary_pred);
+  _LIBCPP_HIDE_FROM_ABI void merge(list& __c);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(list&& __c) {merge(__c);}
+  _LIBCPP_HIDE_FROM_ABI void merge(list&& __c) { merge(__c); }
 
-    template <class _Comp>
-    _LIBCPP_INLINE_VISIBILITY
-        void merge(list&& __c, _Comp __comp) {merge(__c, __comp);}
+  template <class _Comp>
+  _LIBCPP_HIDE_FROM_ABI void merge(list&& __c, _Comp __comp) {
+    merge(__c, __comp);
+  }
 #endif
-    template <class _Comp>
-    _LIBCPP_HIDE_FROM_ABI void merge(list& __c, _Comp __comp);
+  template <class _Comp>
+  _LIBCPP_HIDE_FROM_ABI void merge(list& __c, _Comp __comp);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void sort();
-    template <class _Comp>
-        _LIBCPP_INLINE_VISIBILITY
-        void sort(_Comp __comp);
+  _LIBCPP_HIDE_FROM_ABI void sort();
+  template <class _Comp>
+  _LIBCPP_HIDE_FROM_ABI void sort(_Comp __comp);
 
-    _LIBCPP_HIDE_FROM_ABI void reverse() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void reverse() _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI bool __invariants() const;
-
-    typedef __allocator_destructor<__node_allocator> __node_destructor;
-    typedef unique_ptr<__node, __node_destructor> __hold_pointer;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __hold_pointer __allocate_node(__node_allocator& __na) {
-      __node_pointer __p = __node_alloc_traits::allocate(__na, 1);
-      __p->__prev_ = nullptr;
-      return __hold_pointer(__p, __node_destructor(__na, 1));
-    }
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-    bool __dereferenceable(const const_iterator* __i) const;
-    bool __decrementable(const const_iterator* __i) const;
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI bool __invariants() const;
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    static void __link_nodes  (__link_pointer __p, __link_pointer __f, __link_pointer __l);
-    _LIBCPP_INLINE_VISIBILITY
-    void __link_nodes_at_front(__link_pointer __f, __link_pointer __l);
-    _LIBCPP_INLINE_VISIBILITY
-    void __link_nodes_at_back (__link_pointer __f, __link_pointer __l);
-    _LIBCPP_HIDE_FROM_ABI iterator __iterator(size_type __n);
-    // TODO: Make this _LIBCPP_HIDE_FROM_ABI
-    template <class _Comp>
-    _LIBCPP_HIDDEN static iterator __sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp);
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI void __assign_with_sentinel(_Iterator __f, _Sentinel __l);
 
-    _LIBCPP_HIDE_FROM_ABI void __move_assign(list& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value);
-    _LIBCPP_HIDE_FROM_ABI void __move_assign(list& __c, false_type);
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI iterator __insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l);
+
+  _LIBCPP_HIDE_FROM_ABI static void __link_nodes(__link_pointer __p, __link_pointer __f, __link_pointer __l);
+  _LIBCPP_HIDE_FROM_ABI void __link_nodes_at_front(__link_pointer __f, __link_pointer __l);
+  _LIBCPP_HIDE_FROM_ABI void __link_nodes_at_back(__link_pointer __f, __link_pointer __l);
+  _LIBCPP_HIDE_FROM_ABI iterator __iterator(size_type __n);
+  // TODO: Make this _LIBCPP_HIDE_FROM_ABI
+  template <class _Comp>
+  _LIBCPP_HIDDEN static iterator __sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp);
+
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(list& __c, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value);
+  _LIBCPP_HIDE_FROM_ABI void __move_assign(list& __c, false_type);
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Alloc = allocator<__iter_value_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Alloc>::value>
-         >
-list(_InputIterator, _InputIterator)
-  -> list<__iter_value_type<_InputIterator>, _Alloc>;
+template <class _InputIterator,
+          class _Alloc = allocator<__iter_value_type<_InputIterator>>,
+          class        = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+list(_InputIterator, _InputIterator) -> list<__iter_value_type<_InputIterator>, _Alloc>;
 
-template<class _InputIterator,
-         class _Alloc,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Alloc>::value>
-         >
-list(_InputIterator, _InputIterator, _Alloc)
-  -> list<__iter_value_type<_InputIterator>, _Alloc>;
+template <class _InputIterator,
+          class _Alloc,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Alloc>::value> >
+list(_InputIterator, _InputIterator, _Alloc) -> list<__iter_value_type<_InputIterator>, _Alloc>;
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Alloc = allocator<ranges::range_value_t<_Range>>,
+          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+list(from_range_t, _Range&&, _Alloc = _Alloc()) -> list<ranges::range_value_t<_Range>, _Alloc>;
 #endif
 
 // Link in nodes [__f, __l] just prior to __p
 template <class _Tp, class _Alloc>
-inline
-void
-list<_Tp, _Alloc>::__link_nodes(__link_pointer __p, __link_pointer __f, __link_pointer __l)
-{
-    __p->__prev_->__next_ = __f;
-    __f->__prev_ = __p->__prev_;
-    __p->__prev_ = __l;
-    __l->__next_ = __p;
+inline void list<_Tp, _Alloc>::__link_nodes(__link_pointer __p, __link_pointer __f, __link_pointer __l) {
+  __p->__prev_->__next_ = __f;
+  __f->__prev_          = __p->__prev_;
+  __p->__prev_          = __l;
+  __l->__next_          = __p;
 }
 
 // Link in nodes [__f, __l] at the front of the list
 template <class _Tp, class _Alloc>
-inline
-void
-list<_Tp, _Alloc>::__link_nodes_at_front(__link_pointer __f, __link_pointer __l)
-{
-    __f->__prev_ = base::__end_as_link();
-    __l->__next_ = base::__end_.__next_;
-    __l->__next_->__prev_ = __l;
-    base::__end_.__next_ = __f;
+inline void list<_Tp, _Alloc>::__link_nodes_at_front(__link_pointer __f, __link_pointer __l) {
+  __f->__prev_          = base::__end_as_link();
+  __l->__next_          = base::__end_.__next_;
+  __l->__next_->__prev_ = __l;
+  base::__end_.__next_  = __f;
 }
 
 // Link in nodes [__f, __l] at the back of the list
 template <class _Tp, class _Alloc>
-inline
-void
-list<_Tp, _Alloc>::__link_nodes_at_back(__link_pointer __f, __link_pointer __l)
-{
-    __l->__next_ = base::__end_as_link();
-    __f->__prev_ = base::__end_.__prev_;
-    __f->__prev_->__next_ = __f;
-    base::__end_.__prev_ = __l;
-}
-
-
-template <class _Tp, class _Alloc>
-inline
-typename list<_Tp, _Alloc>::iterator
-list<_Tp, _Alloc>::__iterator(size_type __n)
-{
-    return __n <= base::__sz() / 2 ? _VSTD::next(begin(), __n)
-                                   : _VSTD::prev(end(), base::__sz() - __n);
+inline void list<_Tp, _Alloc>::__link_nodes_at_back(__link_pointer __f, __link_pointer __l) {
+  __l->__next_          = base::__end_as_link();
+  __f->__prev_          = base::__end_.__prev_;
+  __f->__prev_->__next_ = __f;
+  base::__end_.__prev_  = __l;
 }
 
 template <class _Tp, class _Alloc>
-list<_Tp, _Alloc>::list(size_type __n)
-{
-    _VSTD::__debug_db_insert_c(this);
-    for (; __n > 0; --__n)
+inline typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>::__iterator(size_type __n) {
+  return __n <= base::__sz() / 2 ? std::next(begin(), __n) : std::prev(end(), base::__sz() - __n);
+}
+
+template <class _Tp, class _Alloc>
+list<_Tp, _Alloc>::list(size_type __n) {
+  for (; __n > 0; --__n)
 #ifndef _LIBCPP_CXX03_LANG
-        emplace_back();
+    emplace_back();
 #else
-        push_back(value_type());
+    push_back(value_type());
 #endif
 }
 
 #if _LIBCPP_STD_VER >= 14
 template <class _Tp, class _Alloc>
-list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : base(__a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    for (; __n > 0; --__n)
-        emplace_back();
+list<_Tp, _Alloc>::list(size_type __n, const allocator_type& __a) : base(__a) {
+  for (; __n > 0; --__n)
+    emplace_back();
 }
 #endif
 
 template <class _Tp, class _Alloc>
-list<_Tp, _Alloc>::list(size_type __n, const value_type& __x)
-{
-    _VSTD::__debug_db_insert_c(this);
-    for (; __n > 0; --__n)
-        push_back(__x);
+list<_Tp, _Alloc>::list(size_type __n, const value_type& __x) {
+  for (; __n > 0; --__n)
+    push_back(__x);
 }
 
 template <class _Tp, class _Alloc>
-template <class _InpIter>
-list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l,
-                        __enable_if_t<__has_input_iterator_category<_InpIter>::value>*)
-{
-    _VSTD::__debug_db_insert_c(this);
-    for (; __f != __l; ++__f)
-        __emplace_back(*__f);
+template <class _InpIter, __enable_if_t<__has_input_iterator_category<_InpIter>::value, int> >
+list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l) {
+  for (; __f != __l; ++__f)
+    __emplace_back(*__f);
 }
 
 template <class _Tp, class _Alloc>
-template <class _InpIter>
-list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l, const allocator_type& __a,
-                        __enable_if_t<__has_input_iterator_category<_InpIter>::value>*)
-    : base(__a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    for (; __f != __l; ++__f)
-        __emplace_back(*__f);
+template <class _InpIter, __enable_if_t<__has_input_iterator_category<_InpIter>::value, int> >
+list<_Tp, _Alloc>::list(_InpIter __f, _InpIter __l, const allocator_type& __a) : base(__a) {
+  for (; __f != __l; ++__f)
+    __emplace_back(*__f);
 }
 
 template <class _Tp, class _Alloc>
 list<_Tp, _Alloc>::list(const list& __c)
-    : base(__node_alloc_traits::select_on_container_copy_construction(
-          __c.__node_alloc())) {
-    _VSTD::__debug_db_insert_c(this);
-    for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i)
-        push_back(*__i);
+    : base(__node_alloc_traits::select_on_container_copy_construction(__c.__node_alloc())) {
+  for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i)
+    push_back(*__i);
 }
 
 template <class _Tp, class _Alloc>
-list<_Tp, _Alloc>::list(const list& __c, const __type_identity_t<allocator_type>& __a)
-    : base(__a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i)
-        push_back(*__i);
+list<_Tp, _Alloc>::list(const list& __c, const __type_identity_t<allocator_type>& __a) : base(__a) {
+  for (const_iterator __i = __c.begin(), __e = __c.end(); __i != __e; ++__i)
+    push_back(*__i);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
-list<_Tp, _Alloc>::list(initializer_list<value_type> __il, const allocator_type& __a)
-    : base(__a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    for (typename initializer_list<value_type>::const_iterator __i = __il.begin(),
-            __e = __il.end(); __i != __e; ++__i)
-        push_back(*__i);
+list<_Tp, _Alloc>::list(initializer_list<value_type> __il, const allocator_type& __a) : base(__a) {
+  for (typename initializer_list<value_type>::const_iterator __i = __il.begin(), __e = __il.end(); __i != __e; ++__i)
+    push_back(*__i);
 }
 
 template <class _Tp, class _Alloc>
-list<_Tp, _Alloc>::list(initializer_list<value_type> __il)
-{
-    _VSTD::__debug_db_insert_c(this);
-    for (typename initializer_list<value_type>::const_iterator __i = __il.begin(),
-            __e = __il.end(); __i != __e; ++__i)
-        push_back(*__i);
+list<_Tp, _Alloc>::list(initializer_list<value_type> __il) {
+  for (typename initializer_list<value_type>::const_iterator __i = __il.begin(), __e = __il.end(); __i != __e; ++__i)
+    push_back(*__i);
 }
 
 template <class _Tp, class _Alloc>
-inline list<_Tp, _Alloc>::list(list&& __c)
-        _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
-        : base(_VSTD::move(__c.__node_alloc())) {
-    _VSTD::__debug_db_insert_c(this);
+inline list<_Tp, _Alloc>::list(list&& __c) noexcept(is_nothrow_move_constructible<__node_allocator>::value)
+    : base(std::move(__c.__node_alloc())) {
+  splice(end(), __c);
+}
+
+template <class _Tp, class _Alloc>
+inline list<_Tp, _Alloc>::list(list&& __c, const __type_identity_t<allocator_type>& __a) : base(__a) {
+  if (__a == __c.get_allocator())
     splice(end(), __c);
+  else {
+    typedef move_iterator<iterator> _Ip;
+    assign(_Ip(__c.begin()), _Ip(__c.end()));
+  }
 }
 
 template <class _Tp, class _Alloc>
-inline
-list<_Tp, _Alloc>::list(list&& __c, const __type_identity_t<allocator_type>& __a)
-    : base(__a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    if (__a == __c.get_allocator())
-        splice(end(), __c);
-    else
-    {
-        typedef move_iterator<iterator> _Ip;
-        assign(_Ip(__c.begin()), _Ip(__c.end()));
-    }
+inline list<_Tp, _Alloc>& list<_Tp, _Alloc>::operator=(list&& __c) noexcept(
+    __node_alloc_traits::propagate_on_container_move_assignment::value &&
+    is_nothrow_move_assignable<__node_allocator>::value) {
+  __move_assign(__c, integral_constant<bool, __node_alloc_traits::propagate_on_container_move_assignment::value>());
+  return *this;
 }
 
 template <class _Tp, class _Alloc>
-inline
-list<_Tp, _Alloc>&
-list<_Tp, _Alloc>::operator=(list&& __c)
-        _NOEXCEPT_(
-            __node_alloc_traits::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<__node_allocator>::value)
-{
-    __move_assign(__c, integral_constant<bool,
-          __node_alloc_traits::propagate_on_container_move_assignment::value>());
-    return *this;
+void list<_Tp, _Alloc>::__move_assign(list& __c, false_type) {
+  if (base::__node_alloc() != __c.__node_alloc()) {
+    typedef move_iterator<iterator> _Ip;
+    assign(_Ip(__c.begin()), _Ip(__c.end()));
+  } else
+    __move_assign(__c, true_type());
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::__move_assign(list& __c, false_type)
-{
-    if (base::__node_alloc() != __c.__node_alloc())
-    {
-        typedef move_iterator<iterator> _Ip;
-        assign(_Ip(__c.begin()), _Ip(__c.end()));
-    }
-    else
-        __move_assign(__c, true_type());
-}
-
-template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::__move_assign(list& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
-{
-    clear();
-    base::__move_assign_alloc(__c);
-    splice(end(), __c);
+void list<_Tp, _Alloc>::__move_assign(list& __c,
+                                      true_type) noexcept(is_nothrow_move_assignable<__node_allocator>::value) {
+  clear();
+  base::__move_assign_alloc(__c);
+  splice(end(), __c);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
-inline
-list<_Tp, _Alloc>&
-list<_Tp, _Alloc>::operator=(const list& __c)
-{
-    if (this != _VSTD::addressof(__c))
-    {
-        base::__copy_assign_alloc(__c);
-        assign(__c.begin(), __c.end());
-    }
-    return *this;
+inline list<_Tp, _Alloc>& list<_Tp, _Alloc>::operator=(const list& __c) {
+  if (this != std::addressof(__c)) {
+    base::__copy_assign_alloc(__c);
+    assign(__c.begin(), __c.end());
+  }
+  return *this;
 }
 
 template <class _Tp, class _Alloc>
-template <class _InpIter>
-void
-list<_Tp, _Alloc>::assign(_InpIter __f, _InpIter __l,
-                          __enable_if_t<__has_input_iterator_category<_InpIter>::value>*)
-{
-    iterator __i = begin();
-    iterator __e = end();
-    for (; __f != __l && __i != __e; ++__f, (void) ++__i)
-        *__i = *__f;
-    if (__i == __e)
-        insert(__e, __f, __l);
-    else
-        erase(__i, __e);
-    std::__debug_db_invalidate_all(this);
+template <class _InpIter, __enable_if_t<__has_input_iterator_category<_InpIter>::value, int> >
+void list<_Tp, _Alloc>::assign(_InpIter __f, _InpIter __l) {
+  __assign_with_sentinel(__f, __l);
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::assign(size_type __n, const value_type& __x)
-{
-    iterator __i = begin();
-    iterator __e = end();
-    for (; __n > 0 && __i != __e; --__n, (void) ++__i)
-        *__i = __x;
-    if (__i == __e)
-        insert(__e, __n, __x);
-    else
-        erase(__i, __e);
-    std::__debug_db_invalidate_all(this);
+template <class _Iterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI void list<_Tp, _Alloc>::__assign_with_sentinel(_Iterator __f, _Sentinel __l) {
+  iterator __i = begin();
+  iterator __e = end();
+  for (; __f != __l && __i != __e; ++__f, (void)++__i)
+    *__i = *__f;
+  if (__i == __e)
+    __insert_with_sentinel(__e, std::move(__f), std::move(__l));
+  else
+    erase(__i, __e);
 }
 
 template <class _Tp, class _Alloc>
-inline
-_Alloc
-list<_Tp, _Alloc>::get_allocator() const _NOEXCEPT
-{
-    return allocator_type(base::__node_alloc());
+void list<_Tp, _Alloc>::assign(size_type __n, const value_type& __x) {
+  iterator __i = begin();
+  iterator __e = end();
+  for (; __n > 0 && __i != __e; --__n, (void)++__i)
+    *__i = __x;
+  if (__i == __e)
+    insert(__e, __n, __x);
+  else
+    erase(__i, __e);
+}
+
+template <class _Tp, class _Alloc>
+inline _Alloc list<_Tp, _Alloc>::get_allocator() const _NOEXCEPT {
+  return allocator_type(base::__node_alloc());
+}
+
+template <class _Tp, class _Alloc>
+typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x) {
+  __node_pointer __node = this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, __x);
+  __link_nodes(__p.__ptr_, __node->__as_link(), __node->__as_link());
+  ++base::__sz();
+  return iterator(__node->__as_link());
 }
 
 template <class _Tp, class _Alloc>
 typename list<_Tp, _Alloc>::iterator
-list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "list::insert(iterator, x) called with an iterator not referring to this list");
-    __node_allocator& __na = base::__node_alloc();
-    __hold_pointer __hold = __allocate_node(__na);
-    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
-    __link_nodes(__p.__ptr_, __hold->__as_link(), __hold->__as_link());
-    ++base::__sz();
-    return iterator(__hold.release()->__as_link(), this);
-}
-
-template <class _Tp, class _Alloc>
-typename list<_Tp, _Alloc>::iterator
-list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& __x)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "list::insert(iterator, n, x) called with an iterator not referring to this list");
-    iterator __r(__p.__ptr_, this);
-    if (__n > 0)
-    {
-        size_type __ds = 0;
-        __node_allocator& __na = base::__node_alloc();
-        __hold_pointer __hold = __allocate_node(__na);
-        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
-        ++__ds;
-        __r = iterator(__hold->__as_link(), this);
-        __hold.release();
-        iterator __e = __r;
+list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& __x) {
+  iterator __r(__p.__ptr_);
+  if (__n > 0) {
+    size_type __ds        = 0;
+    __node_pointer __node = this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, __x);
+    ++__ds;
+    __r          = iterator(__node->__as_link());
+    iterator __e = __r;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (--__n; __n != 0; --__n, (void) ++__e, ++__ds)
-            {
-                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
-                __e.__ptr_->__next_ = __hold->__as_link();
-                __hold->__prev_ = __e.__ptr_;
-                __hold.release();
-            }
+      for (--__n; __n != 0; --__n, (void)++__e, ++__ds) {
+        __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr, __x)->__as_link();
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            while (true)
-            {
-                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
-                __link_pointer __prev = __e.__ptr_->__prev_;
-                __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
-                if (__prev == 0)
-                    break;
-                __e = iterator(__prev, this);
-            }
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
-        base::__sz() += __ds;
+    } catch (...) {
+      while (true) {
+        __link_pointer __prev    = __e.__ptr_->__prev_;
+        __node_pointer __current = __e.__ptr_->__as_node();
+        this->__delete_node(__current);
+        if (__prev == 0)
+          break;
+        __e = iterator(__prev);
+      }
+      throw;
     }
-    return __r;
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
+    base::__sz() += __ds;
+  }
+  return __r;
 }
 
 template <class _Tp, class _Alloc>
-template <class _InpIter>
-typename list<_Tp, _Alloc>::iterator
-list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
-                          __enable_if_t<__has_input_iterator_category<_InpIter>::value>*)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "list::insert(iterator, range) called with an iterator not referring to this list");
-    iterator __r(__p.__ptr_, this);
-    if (__f != __l)
-    {
-        size_type __ds = 0;
-        __node_allocator& __na = base::__node_alloc();
-        __hold_pointer __hold = __allocate_node(__na);
-        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
-        ++__ds;
-        __r = iterator(__hold.get()->__as_link(), this);
-        __hold.release();
-        iterator __e = __r;
+template <class _InpIter, __enable_if_t<__has_input_iterator_category<_InpIter>::value, int> >
+typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l) {
+  return __insert_with_sentinel(__p, __f, __l);
+}
+
+template <class _Tp, class _Alloc>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI typename list<_Tp, _Alloc>::iterator
+list<_Tp, _Alloc>::__insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l) {
+  iterator __r(__p.__ptr_);
+  if (__f != __l) {
+    size_type __ds        = 0;
+    __node_pointer __node = this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, *__f);
+    ++__ds;
+    __r          = iterator(__node->__as_link());
+    iterator __e = __r;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (++__f; __f != __l; ++__f, (void) ++__e, ++__ds)
-            {
-                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
-                __e.__ptr_->__next_ = __hold.get()->__as_link();
-                __hold->__prev_ = __e.__ptr_;
-                __hold.release();
-            }
+      for (++__f; __f != __l; ++__f, (void)++__e, ++__ds) {
+        __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr, *__f)->__as_link();
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            while (true)
-            {
-                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
-                __link_pointer __prev = __e.__ptr_->__prev_;
-                __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
-                if (__prev == 0)
-                    break;
-                __e = iterator(__prev, this);
-            }
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
-        base::__sz() += __ds;
+    } catch (...) {
+      while (true) {
+        __link_pointer __prev    = __e.__ptr_->__prev_;
+        __node_pointer __current = __e.__ptr_->__as_node();
+        this->__delete_node(__current);
+        if (__prev == 0)
+          break;
+        __e = iterator(__prev);
+      }
+      throw;
     }
-    return __r;
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
+    base::__sz() += __ds;
+  }
+  return __r;
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::push_front(const value_type& __x)
-{
-    __node_allocator& __na = base::__node_alloc();
-    __hold_pointer __hold = __allocate_node(__na);
-    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
-    __link_pointer __nl = __hold->__as_link();
-    __link_nodes_at_front(__nl, __nl);
-    ++base::__sz();
-    __hold.release();
+void list<_Tp, _Alloc>::push_front(const value_type& __x) {
+  __node_pointer __node = this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, __x);
+  __link_pointer __nl   = __node->__as_link();
+  __link_nodes_at_front(__nl, __nl);
+  ++base::__sz();
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::push_back(const value_type& __x)
-{
-    __node_allocator& __na = base::__node_alloc();
-    __hold_pointer __hold = __allocate_node(__na);
-    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
-    __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
-    ++base::__sz();
-    __hold.release();
+void list<_Tp, _Alloc>::push_back(const value_type& __x) {
+  __node_pointer __node = this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, __x);
+  __link_pointer __nl   = __node->__as_link();
+  __link_nodes_at_back(__nl, __nl);
+  ++base::__sz();
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::push_front(value_type&& __x)
-{
-    __node_allocator& __na = base::__node_alloc();
-    __hold_pointer __hold = __allocate_node(__na);
-    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
-    __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
-    ++base::__sz();
-    __hold.release();
+void list<_Tp, _Alloc>::push_front(value_type&& __x) {
+  __node_pointer __node = this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, std::move(__x));
+  __link_pointer __nl   = __node->__as_link();
+  __link_nodes_at_front(__nl, __nl);
+  ++base::__sz();
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::push_back(value_type&& __x)
-{
-    __node_allocator& __na = base::__node_alloc();
-    __hold_pointer __hold = __allocate_node(__na);
-    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
-    __link_nodes_at_back(__hold.get()->__as_link(), __hold.get()->__as_link());
-    ++base::__sz();
-    __hold.release();
+void list<_Tp, _Alloc>::push_back(value_type&& __x) {
+  __node_pointer __node = this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, std::move(__x));
+  __link_pointer __nl   = __node->__as_link();
+  __link_nodes_at_back(__nl, __nl);
+  ++base::__sz();
 }
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 typename list<_Tp, _Alloc>::reference
-#else
+#  else
 void
-#endif
-list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
-{
-    __node_allocator& __na = base::__node_alloc();
-    __hold_pointer __hold = __allocate_node(__na);
-    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
-    __link_nodes_at_front(__hold.get()->__as_link(), __hold.get()->__as_link());
-    ++base::__sz();
-#if _LIBCPP_STD_VER >= 17
-    return __hold.release()->__value_;
-#else
-    __hold.release();
-#endif
+#  endif
+list<_Tp, _Alloc>::emplace_front(_Args&&... __args) {
+  __node_pointer __node =
+      this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, std::forward<_Args>(__args)...);
+  __link_pointer __nl = __node->__as_link();
+  __link_nodes_at_front(__nl, __nl);
+  ++base::__sz();
+#  if _LIBCPP_STD_VER >= 17
+  return __node->__get_value();
+#  endif
 }
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
-#if _LIBCPP_STD_VER >= 17
+#  if _LIBCPP_STD_VER >= 17
 typename list<_Tp, _Alloc>::reference
-#else
+#  else
 void
-#endif
-list<_Tp, _Alloc>::emplace_back(_Args&&... __args)
-{
-    __node_allocator& __na = base::__node_alloc();
-    __hold_pointer __hold = __allocate_node(__na);
-    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
-    __link_pointer __nl = __hold->__as_link();
-    __link_nodes_at_back(__nl, __nl);
-    ++base::__sz();
-#if _LIBCPP_STD_VER >= 17
-    return __hold.release()->__value_;
-#else
-    __hold.release();
-#endif
+#  endif
+list<_Tp, _Alloc>::emplace_back(_Args&&... __args) {
+  __node_pointer __node =
+      this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, std::forward<_Args>(__args)...);
+  __link_pointer __nl = __node->__as_link();
+  __link_nodes_at_back(__nl, __nl);
+  ++base::__sz();
+#  if _LIBCPP_STD_VER >= 17
+  return __node->__get_value();
+#  endif
 }
 
 template <class _Tp, class _Alloc>
 template <class... _Args>
-typename list<_Tp, _Alloc>::iterator
-list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "list::emplace(iterator, args...) called with an iterator not referring to this list");
-    __node_allocator& __na = base::__node_alloc();
-    __hold_pointer __hold = __allocate_node(__na);
-    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
-    __link_pointer __nl = __hold.get()->__as_link();
-    __link_nodes(__p.__ptr_, __nl, __nl);
-    ++base::__sz();
-    __hold.release();
-    return iterator(__nl, this);
+typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args) {
+  __node_pointer __node =
+      this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, std::forward<_Args>(__args)...);
+  __link_pointer __nl = __node->__as_link();
+  __link_nodes(__p.__ptr_, __nl, __nl);
+  ++base::__sz();
+  return iterator(__nl);
 }
 
 template <class _Tp, class _Alloc>
-typename list<_Tp, _Alloc>::iterator
-list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "list::insert(iterator, x) called with an iterator not referring to this list");
-    __node_allocator& __na = base::__node_alloc();
-    __hold_pointer __hold = __allocate_node(__na);
-    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
-    __link_pointer __nl = __hold->__as_link();
-    __link_nodes(__p.__ptr_, __nl, __nl);
-    ++base::__sz();
-    __hold.release();
-    return iterator(__nl, this);
+typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x) {
+  __node_pointer __node = this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, std::move(__x));
+  __link_pointer __nl   = __node->__as_link();
+  __link_nodes(__p.__ptr_, __nl, __nl);
+  ++base::__sz();
+  return iterator(__nl);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::pop_front()
-{
-    _LIBCPP_ASSERT(!empty(), "list::pop_front() called with empty list");
-    __node_allocator& __na = base::__node_alloc();
-    __link_pointer __n = base::__end_.__next_;
-    base::__unlink_nodes(__n, __n);
-    --base::__sz();
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    __c_node* __c = __get_db()->__find_c_and_lock(this);
-    for (__i_node** __p = __c->end_; __p != __c->beg_; )
-    {
-        --__p;
-        iterator* __i = static_cast<iterator*>((*__p)->__i_);
-        if (__i->__ptr_ == __n)
-        {
-            (*__p)->__c_ = nullptr;
-            if (--__c->end_ != __p)
-                _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
-        }
-    }
-    __get_db()->unlock();
-#endif
-    __node_pointer __np = __n->__as_node();
-    __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
-    __node_alloc_traits::deallocate(__na, __np, 1);
+void list<_Tp, _Alloc>::pop_front() {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::pop_front() called with empty list");
+  __link_pointer __n = base::__end_.__next_;
+  base::__unlink_nodes(__n, __n);
+  --base::__sz();
+  this->__delete_node(__n->__as_node());
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::pop_back()
-{
-    _LIBCPP_ASSERT(!empty(), "list::pop_back() called on an empty list");
-    __node_allocator& __na = base::__node_alloc();
-    __link_pointer __n = base::__end_.__prev_;
-    base::__unlink_nodes(__n, __n);
-    --base::__sz();
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    __c_node* __c = __get_db()->__find_c_and_lock(this);
-    for (__i_node** __p = __c->end_; __p != __c->beg_; )
-    {
-        --__p;
-        iterator* __i = static_cast<iterator*>((*__p)->__i_);
-        if (__i->__ptr_ == __n)
-        {
-            (*__p)->__c_ = nullptr;
-            if (--__c->end_ != __p)
-                _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
-        }
-    }
-    __get_db()->unlock();
-#endif
-    __node_pointer __np = __n->__as_node();
-    __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
-    __node_alloc_traits::deallocate(__na, __np, 1);
+void list<_Tp, _Alloc>::pop_back() {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::pop_back() called on an empty list");
+  __link_pointer __n = base::__end_.__prev_;
+  base::__unlink_nodes(__n, __n);
+  --base::__sz();
+  this->__delete_node(__n->__as_node());
 }
 
 template <class _Tp, class _Alloc>
-typename list<_Tp, _Alloc>::iterator
-list<_Tp, _Alloc>::erase(const_iterator __p)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "list::erase(iterator) called with an iterator not referring to this list");
-    _LIBCPP_ASSERT(__p != end(),
-        "list::erase(iterator) called with a non-dereferenceable iterator");
-    __node_allocator& __na = base::__node_alloc();
-    __link_pointer __n = __p.__ptr_;
-    __link_pointer __r = __n->__next_;
-    base::__unlink_nodes(__n, __n);
-    --base::__sz();
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    __c_node* __c = __get_db()->__find_c_and_lock(this);
-    for (__i_node** __ip = __c->end_; __ip != __c->beg_; )
-    {
-        --__ip;
-        iterator* __i = static_cast<iterator*>((*__ip)->__i_);
-        if (__i->__ptr_ == __n)
-        {
-            (*__ip)->__c_ = nullptr;
-            if (--__c->end_ != __ip)
-                _VSTD::memmove(__ip, __ip+1, (__c->end_ - __ip)*sizeof(__i_node*));
-        }
-    }
-    __get_db()->unlock();
-#endif
-    __node_pointer __np = __n->__as_node();
-    __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
-    __node_alloc_traits::deallocate(__na, __np, 1);
-    return iterator(__r, this);
+typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>::erase(const_iterator __p) {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__p != end(), "list::erase(iterator) called with a non-dereferenceable iterator");
+  __link_pointer __n = __p.__ptr_;
+  __link_pointer __r = __n->__next_;
+  base::__unlink_nodes(__n, __n);
+  --base::__sz();
+  this->__delete_node(__n->__as_node());
+  return iterator(__r);
 }
 
 template <class _Tp, class _Alloc>
-typename list<_Tp, _Alloc>::iterator
-list<_Tp, _Alloc>::erase(const_iterator __f, const_iterator __l)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__f)) == this,
-                         "list::erase(iterator, iterator) called with an iterator not referring to this list");
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__l)) == this,
-                         "list::erase(iterator, iterator) called with an iterator not referring to this list");
-    if (__f != __l)
-    {
-        __node_allocator& __na = base::__node_alloc();
-        base::__unlink_nodes(__f.__ptr_, __l.__ptr_->__prev_);
-        while (__f != __l)
-        {
-            __link_pointer __n = __f.__ptr_;
-            ++__f;
-            --base::__sz();
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-            __c_node* __c = __get_db()->__find_c_and_lock(this);
-            for (__i_node** __p = __c->end_; __p != __c->beg_; )
-            {
-                --__p;
-                iterator* __i = static_cast<iterator*>((*__p)->__i_);
-                if (__i->__ptr_ == __n)
-                {
-                    (*__p)->__c_ = nullptr;
-                    if (--__c->end_ != __p)
-                        _VSTD::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
-                }
-            }
-            __get_db()->unlock();
-#endif
-            __node_pointer __np = __n->__as_node();
-            __node_alloc_traits::destroy(__na, _VSTD::addressof(__np->__value_));
-            __node_alloc_traits::deallocate(__na, __np, 1);
-        }
+typename list<_Tp, _Alloc>::iterator list<_Tp, _Alloc>::erase(const_iterator __f, const_iterator __l) {
+  if (__f != __l) {
+    base::__unlink_nodes(__f.__ptr_, __l.__ptr_->__prev_);
+    while (__f != __l) {
+      __link_pointer __n = __f.__ptr_;
+      ++__f;
+      --base::__sz();
+      this->__delete_node(__n->__as_node());
     }
-    return iterator(__l.__ptr_, this);
+  }
+  return iterator(__l.__ptr_);
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::resize(size_type __n)
-{
-    if (__n < base::__sz())
-        erase(__iterator(__n), end());
-    else if (__n > base::__sz())
-    {
-        __n -= base::__sz();
-        size_type __ds = 0;
-        __node_allocator& __na = base::__node_alloc();
-        __hold_pointer __hold = __allocate_node(__na);
-        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
-        ++__ds;
-        iterator __r = iterator(__hold.release()->__as_link(), this);
-        iterator __e = __r;
+void list<_Tp, _Alloc>::resize(size_type __n) {
+  if (__n < base::__sz())
+    erase(__iterator(__n), end());
+  else if (__n > base::__sz()) {
+    __n -= base::__sz();
+    size_type __ds        = 0;
+    __node_pointer __node = this->__create_node(/* prev = */ nullptr, /* next = */ nullptr);
+    ++__ds;
+    iterator __r = iterator(__node->__as_link());
+    iterator __e = __r;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (--__n; __n != 0; --__n, (void) ++__e, ++__ds)
-            {
-                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
-                __e.__ptr_->__next_ = __hold.get()->__as_link();
-                __hold->__prev_ = __e.__ptr_;
-                __hold.release();
-            }
+      for (--__n; __n != 0; --__n, (void)++__e, ++__ds) {
+        __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr)->__as_link();
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            while (true)
-            {
-                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
-                __link_pointer __prev = __e.__ptr_->__prev_;
-                __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
-                if (__prev == 0)
-                    break;
-                __e = iterator(__prev, this);
-            }
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __link_nodes_at_back(__r.__ptr_, __e.__ptr_);
-        base::__sz() += __ds;
+    } catch (...) {
+      while (true) {
+        __link_pointer __prev    = __e.__ptr_->__prev_;
+        __node_pointer __current = __e.__ptr_->__as_node();
+        this->__delete_node(__current);
+        if (__prev == 0)
+          break;
+        __e = iterator(__prev);
+      }
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __link_nodes_at_back(__r.__ptr_, __e.__ptr_);
+    base::__sz() += __ds;
+  }
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
-{
-    if (__n < base::__sz())
-        erase(__iterator(__n), end());
-    else if (__n > base::__sz())
-    {
-        __n -= base::__sz();
-        size_type __ds = 0;
-        __node_allocator& __na = base::__node_alloc();
-        __hold_pointer __hold = __allocate_node(__na);
-        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
-        ++__ds;
-        __link_pointer __nl = __hold.release()->__as_link();
-        iterator __r = iterator(__nl, this);
-        iterator __e = __r;
+void list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x) {
+  if (__n < base::__sz())
+    erase(__iterator(__n), end());
+  else if (__n > base::__sz()) {
+    __n -= base::__sz();
+    size_type __ds        = 0;
+    __node_pointer __node = this->__create_node(/* prev = */ nullptr, /* next = */ nullptr, __x);
+    ++__ds;
+    __link_pointer __nl = __node->__as_link();
+    iterator __r        = iterator(__nl);
+    iterator __e        = __r;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (--__n; __n != 0; --__n, (void) ++__e, ++__ds)
-            {
-                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
-                __e.__ptr_->__next_ = __hold.get()->__as_link();
-                __hold->__prev_ = __e.__ptr_;
-                __hold.release();
-            }
+      for (--__n; __n != 0; --__n, (void)++__e, ++__ds) {
+        __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr, __x)->__as_link();
+      }
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            while (true)
-            {
-                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
-                __link_pointer __prev = __e.__ptr_->__prev_;
-                __node_alloc_traits::deallocate(__na, __e.__ptr_->__as_node(), 1);
-                if (__prev == 0)
-                    break;
-                __e = iterator(__prev, this);
-            }
-            throw;
-        }
+    } catch (...) {
+      while (true) {
+        __link_pointer __prev    = __e.__ptr_->__prev_;
+        __node_pointer __current = __e.__ptr_->__as_node();
+        this->__delete_node(__current);
+        if (__prev == 0)
+          break;
+        __e = iterator(__prev);
+      }
+      throw;
+    }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __link_nodes(base::__end_as_link(), __r.__ptr_, __e.__ptr_);
-        base::__sz() += __ds;
-    }
+    __link_nodes(base::__end_as_link(), __r.__ptr_, __e.__ptr_);
+    base::__sz() += __ds;
+  }
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::splice(const_iterator __p, list& __c)
-{
-    _LIBCPP_ASSERT(this != _VSTD::addressof(__c),
-                   "list::splice(iterator, list) called with this == &list");
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                         "list::splice(iterator, list) called with an iterator not referring to this list");
-    if (!__c.empty())
-    {
-        __link_pointer __f = __c.__end_.__next_;
-        __link_pointer __l = __c.__end_.__prev_;
-        base::__unlink_nodes(__f, __l);
-        __link_nodes(__p.__ptr_, __f, __l);
-        base::__sz() += __c.__sz();
-        __c.__sz() = 0;
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-        if (_VSTD::addressof(__c) != this) {
-            __libcpp_db* __db = __get_db();
-            __c_node* __cn1 = __db->__find_c_and_lock(this);
-            __c_node* __cn2 = __db->__find_c(_VSTD::addressof(__c));
-            for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
-            {
-                --__ip;
-                iterator* __i = static_cast<iterator*>((*__ip)->__i_);
-                if (__i->__ptr_ != __c.__end_as_link())
-                {
-                    __cn1->__add(*__ip);
-                    (*__ip)->__c_ = __cn1;
-                    if (--__cn2->end_ != __ip)
-                        _VSTD::memmove(__ip, __ip+1, (__cn2->end_ - __ip)*sizeof(__i_node*));
-                }
-            }
-            __db->unlock();
-        }
-#endif
-    }
+void list<_Tp, _Alloc>::splice(const_iterator __p, list& __c) {
+  _LIBCPP_ASSERT_VALID_INPUT_RANGE(
+      this != std::addressof(__c), "list::splice(iterator, list) called with this == &list");
+  if (!__c.empty()) {
+    __link_pointer __f = __c.__end_.__next_;
+    __link_pointer __l = __c.__end_.__prev_;
+    base::__unlink_nodes(__f, __l);
+    __link_nodes(__p.__ptr_, __f, __l);
+    base::__sz() += __c.__sz();
+    __c.__sz() = 0;
+  }
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __i)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-        "list::splice(iterator, list, iterator) called with the first iterator not referring to this list");
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__i)) == _VSTD::addressof(__c),
-        "list::splice(iterator, list, iterator) called with the second iterator not referring to the list argument");
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__dereferenceable(_VSTD::addressof(__i)),
-        "list::splice(iterator, list, iterator) called with the second iterator not dereferenceable");
-
-    if (__p.__ptr_ != __i.__ptr_ && __p.__ptr_ != __i.__ptr_->__next_)
-    {
-        __link_pointer __f = __i.__ptr_;
-        base::__unlink_nodes(__f, __f);
-        __link_nodes(__p.__ptr_, __f, __f);
-        --__c.__sz();
-        ++base::__sz();
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-        if (_VSTD::addressof(__c) != this) {
-            __libcpp_db* __db = __get_db();
-            __c_node* __cn1 = __db->__find_c_and_lock(this);
-            __c_node* __cn2 = __db->__find_c(_VSTD::addressof(__c));
-            for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
-            {
-                --__ip;
-                iterator* __j = static_cast<iterator*>((*__ip)->__i_);
-                if (__j->__ptr_ == __f)
-                {
-                    __cn1->__add(*__ip);
-                    (*__ip)->__c_ = __cn1;
-                    if (--__cn2->end_ != __ip)
-                        _VSTD::memmove(__ip, __ip+1, (__cn2->end_ - __ip)*sizeof(__i_node*));
-                }
-            }
-            __db->unlock();
-        }
-#endif
-    }
-}
-
-template <class _Iterator>
-_LIBCPP_HIDE_FROM_ABI
-bool __iterator_in_range(_Iterator __first, _Iterator __last, _Iterator __it) {
-    for (_Iterator __p = __first; __p != __last; ++__p) {
-        if (__p == __it) {
-            return true;
-        }
-    }
-    return false;
+void list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __i) {
+  if (__p.__ptr_ != __i.__ptr_ && __p.__ptr_ != __i.__ptr_->__next_) {
+    __link_pointer __f = __i.__ptr_;
+    base::__unlink_nodes(__f, __f);
+    __link_nodes(__p.__ptr_, __f, __f);
+    --__c.__sz();
+    ++base::__sz();
+  }
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-        "list::splice(iterator, list, iterator, iterator) called with first iterator not referring to this list");
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__f)) == _VSTD::addressof(__c),
-        "list::splice(iterator, list, iterator, iterator) called with second iterator not referring to the list argument");
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__l)) == _VSTD::addressof(__c),
-        "list::splice(iterator, list, iterator, iterator) called with third iterator not referring to the list argument");
-    _LIBCPP_DEBUG_ASSERT(this != std::addressof(__c) || !std::__iterator_in_range(__f, __l, __p),
-        "list::splice(iterator, list, iterator, iterator)"
-        " called with the first iterator within the range of the second and third iterators");
-
-    if (__f != __l)
-    {
-        __link_pointer __first = __f.__ptr_;
-        --__l;
-        __link_pointer __last = __l.__ptr_;
-        if (this != _VSTD::addressof(__c))
-        {
-            size_type __s = _VSTD::distance(__f, __l) + 1;
-            __c.__sz() -= __s;
-            base::__sz() += __s;
-        }
-        base::__unlink_nodes(__first, __last);
-        __link_nodes(__p.__ptr_, __first, __last);
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-        if (_VSTD::addressof(__c) != this) {
-            __libcpp_db* __db = __get_db();
-            __c_node* __cn1 = __db->__find_c_and_lock(this);
-            __c_node* __cn2 = __db->__find_c(_VSTD::addressof(__c));
-            for (__i_node** __ip = __cn2->end_; __ip != __cn2->beg_;)
-            {
-                --__ip;
-                iterator* __j = static_cast<iterator*>((*__ip)->__i_);
-                for (__link_pointer __k = __f.__ptr_;
-                                              __k != __l.__ptr_; __k = __k->__next_)
-                {
-                    if (__j->__ptr_ == __k)
-                    {
-                        __cn1->__add(*__ip);
-                        (*__ip)->__c_ = __cn1;
-                        if (--__cn2->end_ != __ip)
-                            _VSTD::memmove(__ip, __ip+1, (__cn2->end_ - __ip)*sizeof(__i_node*));
-                    }
-                }
-            }
-            __db->unlock();
-        }
-#endif
+void list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __f, const_iterator __l) {
+  if (__f != __l) {
+    __link_pointer __first = __f.__ptr_;
+    --__l;
+    __link_pointer __last = __l.__ptr_;
+    if (this != std::addressof(__c)) {
+      size_type __s = std::distance(__f, __l) + 1;
+      __c.__sz() -= __s;
+      base::__sz() += __s;
     }
+    base::__unlink_nodes(__first, __last);
+    __link_nodes(__p.__ptr_, __first, __last);
+  }
 }
 
 template <class _Tp, class _Alloc>
-typename list<_Tp, _Alloc>::__remove_return_type
-list<_Tp, _Alloc>::remove(const value_type& __x)
-{
-    list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
-    for (const_iterator __i = begin(), __e = end(); __i != __e;)
-    {
-        if (*__i == __x)
-        {
-            const_iterator __j = _VSTD::next(__i);
-            for (; __j != __e && *__j == __x; ++__j)
-                ;
-            __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j);
-            __i = __j;
-            if (__i != __e)
-                ++__i;
-        }
-        else
-            ++__i;
-    }
+typename list<_Tp, _Alloc>::__remove_return_type list<_Tp, _Alloc>::remove(const value_type& __x) {
+  list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
+  for (const_iterator __i = begin(), __e = end(); __i != __e;) {
+    if (*__i == __x) {
+      const_iterator __j = std::next(__i);
+      for (; __j != __e && *__j == __x; ++__j)
+        ;
+      __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j);
+      __i = __j;
+      if (__i != __e)
+        ++__i;
+    } else
+      ++__i;
+  }
 
-    return (__remove_return_type) __deleted_nodes.size();
+  return (__remove_return_type)__deleted_nodes.size();
 }
 
 template <class _Tp, class _Alloc>
 template <class _Pred>
-typename list<_Tp, _Alloc>::__remove_return_type
-list<_Tp, _Alloc>::remove_if(_Pred __pred)
-{
-    list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
-    for (iterator __i = begin(), __e = end(); __i != __e;)
-    {
-        if (__pred(*__i))
-        {
-            iterator __j = _VSTD::next(__i);
-            for (; __j != __e && __pred(*__j); ++__j)
-                ;
-            __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j);
-            __i = __j;
-            if (__i != __e)
-                ++__i;
-        }
-        else
-            ++__i;
-    }
+typename list<_Tp, _Alloc>::__remove_return_type list<_Tp, _Alloc>::remove_if(_Pred __pred) {
+  list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
+  for (iterator __i = begin(), __e = end(); __i != __e;) {
+    if (__pred(*__i)) {
+      iterator __j = std::next(__i);
+      for (; __j != __e && __pred(*__j); ++__j)
+        ;
+      __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j);
+      __i = __j;
+      if (__i != __e)
+        ++__i;
+    } else
+      ++__i;
+  }
 
-    return (__remove_return_type) __deleted_nodes.size();
+  return (__remove_return_type)__deleted_nodes.size();
 }
 
 template <class _Tp, class _Alloc>
 template <class _BinaryPred>
-typename list<_Tp, _Alloc>::__remove_return_type
-list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)
-{
-    list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
-    for (iterator __i = begin(), __e = end(); __i != __e;)
-    {
-        iterator __j = _VSTD::next(__i);
-        for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
-            ;
-        if (++__i != __j) {
-            __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j);
-            __i = __j;
-            }
+typename list<_Tp, _Alloc>::__remove_return_type list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred) {
+  list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
+  for (iterator __i = begin(), __e = end(); __i != __e;) {
+    iterator __j = std::next(__i);
+    for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
+      ;
+    if (++__i != __j) {
+      __deleted_nodes.splice(__deleted_nodes.end(), *this, __i, __j);
+      __i = __j;
     }
+  }
 
-    return (__remove_return_type) __deleted_nodes.size();
+  return (__remove_return_type)__deleted_nodes.size();
 }
 
 template <class _Tp, class _Alloc>
-inline
-void
-list<_Tp, _Alloc>::merge(list& __c)
-{
-    merge(__c, __less<value_type>());
+inline void list<_Tp, _Alloc>::merge(list& __c) {
+  merge(__c, __less<>());
 }
 
 template <class _Tp, class _Alloc>
 template <class _Comp>
-void
-list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
-{
-    if (this != _VSTD::addressof(__c))
-    {
-        iterator __f1 = begin();
-        iterator __e1 = end();
-        iterator __f2 = __c.begin();
-        iterator __e2 = __c.end();
-        while (__f1 != __e1 && __f2 != __e2)
-        {
-            if (__comp(*__f2, *__f1))
-            {
-                size_type __ds = 1;
-                iterator __m2 = _VSTD::next(__f2);
-                for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, (void) ++__ds)
-                    ;
-                base::__sz() += __ds;
-                __c.__sz() -= __ds;
-                __link_pointer __f = __f2.__ptr_;
-                __link_pointer __l = __m2.__ptr_->__prev_;
-                __f2 = __m2;
-                base::__unlink_nodes(__f, __l);
-                __m2 = _VSTD::next(__f1);
-                __link_nodes(__f1.__ptr_, __f, __l);
-                __f1 = __m2;
-            }
-            else
-                ++__f1;
-        }
-        splice(__e1, __c);
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-        __libcpp_db* __db = __get_db();
-        __c_node* __cn1 = __db->__find_c_and_lock(this);
-        __c_node* __cn2 = __db->__find_c(_VSTD::addressof(__c));
-        for (__i_node** __p = __cn2->end_; __p != __cn2->beg_;)
-        {
-            --__p;
-            iterator* __i = static_cast<iterator*>((*__p)->__i_);
-            if (__i->__ptr_ != __c.__end_as_link())
-            {
-                __cn1->__add(*__p);
-                (*__p)->__c_ = __cn1;
-                if (--__cn2->end_ != __p)
-                    _VSTD::memmove(__p, __p+1, (__cn2->end_ - __p)*sizeof(__i_node*));
-            }
-        }
-        __db->unlock();
-#endif
+void list<_Tp, _Alloc>::merge(list& __c, _Comp __comp) {
+  if (this != std::addressof(__c)) {
+    iterator __f1 = begin();
+    iterator __e1 = end();
+    iterator __f2 = __c.begin();
+    iterator __e2 = __c.end();
+    while (__f1 != __e1 && __f2 != __e2) {
+      if (__comp(*__f2, *__f1)) {
+        size_type __ds = 1;
+        iterator __m2  = std::next(__f2);
+        for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, (void)++__ds)
+          ;
+        base::__sz() += __ds;
+        __c.__sz() -= __ds;
+        __link_pointer __f = __f2.__ptr_;
+        __link_pointer __l = __m2.__ptr_->__prev_;
+        __f2               = __m2;
+        base::__unlink_nodes(__f, __l);
+        __m2 = std::next(__f1);
+        __link_nodes(__f1.__ptr_, __f, __l);
+        __f1 = __m2;
+      } else
+        ++__f1;
     }
+    splice(__e1, __c);
+  }
 }
 
 template <class _Tp, class _Alloc>
-inline
-void
-list<_Tp, _Alloc>::sort()
-{
-    sort(__less<value_type>());
+inline void list<_Tp, _Alloc>::sort() {
+  sort(__less<>());
 }
 
 template <class _Tp, class _Alloc>
 template <class _Comp>
-inline
-void
-list<_Tp, _Alloc>::sort(_Comp __comp)
-{
-    __sort(begin(), end(), base::__sz(), __comp);
+inline void list<_Tp, _Alloc>::sort(_Comp __comp) {
+  __sort(begin(), end(), base::__sz(), __comp);
 }
 
 template <class _Tp, class _Alloc>
 template <class _Comp>
 typename list<_Tp, _Alloc>::iterator
-list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp)
-{
-    switch (__n)
-    {
-    case 0:
-    case 1:
-        return __f1;
-    case 2:
-        if (__comp(*--__e2, *__f1))
-        {
-            __link_pointer __f = __e2.__ptr_;
-            base::__unlink_nodes(__f, __f);
-            __link_nodes(__f1.__ptr_, __f, __f);
-            return __e2;
-        }
-        return __f1;
+list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __comp) {
+  switch (__n) {
+  case 0:
+  case 1:
+    return __f1;
+  case 2:
+    if (__comp(*--__e2, *__f1)) {
+      __link_pointer __f = __e2.__ptr_;
+      base::__unlink_nodes(__f, __f);
+      __link_nodes(__f1.__ptr_, __f, __f);
+      return __e2;
     }
-    size_type __n2 = __n / 2;
-    iterator __e1 = _VSTD::next(__f1, __n2);
-    iterator  __r = __f1 = __sort(__f1, __e1, __n2, __comp);
-    iterator __f2 = __e1 = __sort(__e1, __e2, __n - __n2, __comp);
-    if (__comp(*__f2, *__f1))
-    {
-        iterator __m2 = _VSTD::next(__f2);
-        for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
-            ;
-        __link_pointer __f = __f2.__ptr_;
-        __link_pointer __l = __m2.__ptr_->__prev_;
-        __r = __f2;
-        __e1 = __f2 = __m2;
-        base::__unlink_nodes(__f, __l);
-        __m2 = _VSTD::next(__f1);
-        __link_nodes(__f1.__ptr_, __f, __l);
-        __f1 = __m2;
+    return __f1;
+  }
+  size_type __n2 = __n / 2;
+  iterator __e1  = std::next(__f1, __n2);
+  iterator __r = __f1 = __sort(__f1, __e1, __n2, __comp);
+  iterator __f2 = __e1 = __sort(__e1, __e2, __n - __n2, __comp);
+  if (__comp(*__f2, *__f1)) {
+    iterator __m2 = std::next(__f2);
+    for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
+      ;
+    __link_pointer __f = __f2.__ptr_;
+    __link_pointer __l = __m2.__ptr_->__prev_;
+    __r                = __f2;
+    __e1 = __f2 = __m2;
+    base::__unlink_nodes(__f, __l);
+    __m2 = std::next(__f1);
+    __link_nodes(__f1.__ptr_, __f, __l);
+    __f1 = __m2;
+  } else
+    ++__f1;
+  while (__f1 != __e1 && __f2 != __e2) {
+    if (__comp(*__f2, *__f1)) {
+      iterator __m2 = std::next(__f2);
+      for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
+        ;
+      __link_pointer __f = __f2.__ptr_;
+      __link_pointer __l = __m2.__ptr_->__prev_;
+      if (__e1 == __f2)
+        __e1 = __m2;
+      __f2 = __m2;
+      base::__unlink_nodes(__f, __l);
+      __m2 = std::next(__f1);
+      __link_nodes(__f1.__ptr_, __f, __l);
+      __f1 = __m2;
+    } else
+      ++__f1;
+  }
+  return __r;
+}
+
+template <class _Tp, class _Alloc>
+void list<_Tp, _Alloc>::reverse() _NOEXCEPT {
+  if (base::__sz() > 1) {
+    iterator __e = end();
+    for (iterator __i = begin(); __i.__ptr_ != __e.__ptr_;) {
+      std::swap(__i.__ptr_->__prev_, __i.__ptr_->__next_);
+      __i.__ptr_ = __i.__ptr_->__prev_;
     }
-    else
-        ++__f1;
-    while (__f1 != __e1 && __f2 != __e2)
-    {
-        if (__comp(*__f2, *__f1))
-        {
-            iterator __m2 = _VSTD::next(__f2);
-            for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
-                ;
-            __link_pointer __f = __f2.__ptr_;
-            __link_pointer __l = __m2.__ptr_->__prev_;
-            if (__e1 == __f2)
-                __e1 = __m2;
-            __f2 = __m2;
-            base::__unlink_nodes(__f, __l);
-            __m2 = _VSTD::next(__f1);
-            __link_nodes(__f1.__ptr_, __f, __l);
-            __f1 = __m2;
-        }
-        else
-            ++__f1;
-    }
-    return __r;
+    std::swap(__e.__ptr_->__prev_, __e.__ptr_->__next_);
+  }
 }
 
 template <class _Tp, class _Alloc>
-void
-list<_Tp, _Alloc>::reverse() _NOEXCEPT
-{
-    if (base::__sz() > 1)
-    {
-        iterator __e = end();
-        for (iterator __i = begin(); __i.__ptr_ != __e.__ptr_;)
-        {
-            _VSTD::swap(__i.__ptr_->__prev_, __i.__ptr_->__next_);
-            __i.__ptr_ = __i.__ptr_->__prev_;
-        }
-        _VSTD::swap(__e.__ptr_->__prev_, __e.__ptr_->__next_);
-    }
+bool list<_Tp, _Alloc>::__invariants() const {
+  return size() == std::distance(begin(), end());
 }
 
 template <class _Tp, class _Alloc>
-bool
-list<_Tp, _Alloc>::__invariants() const
-{
-    return size() == _VSTD::distance(begin(), end());
-}
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-template <class _Tp, class _Alloc>
-bool
-list<_Tp, _Alloc>::__dereferenceable(const const_iterator* __i) const
-{
-    return __i->__ptr_ != this->__end_as_link();
-}
-
-template <class _Tp, class _Alloc>
-bool
-list<_Tp, _Alloc>::__decrementable(const const_iterator* __i) const
-{
-    return !empty() &&  __i->__ptr_ != base::__end_.__next_;
-}
-
-template <class _Tp, class _Alloc>
-bool
-list<_Tp, _Alloc>::__addable(const const_iterator*, ptrdiff_t) const
-{
-    return false;
-}
-
-template <class _Tp, class _Alloc>
-bool
-list<_Tp, _Alloc>::__subscriptable(const const_iterator*, ptrdiff_t) const
-{
-    return false;
-}
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
-
-template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
-{
-    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) {
+  return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 #if _LIBCPP_STD_VER <= 17
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
-{
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) {
+  return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) {
+  return !(__x == __y);
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator> (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) {
+  return __y < __x;
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) {
+  return !(__x < __y);
 }
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) {
+  return !(__y < __x);
 }
 
 #else // _LIBCPP_STD_VER <= 17
@@ -2348,40 +1679,37 @@ operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
 template <class _Tp, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI __synth_three_way_result<_Tp>
 operator<=>(const list<_Tp, _Allocator>& __x, const list<_Tp, _Allocator>& __y) {
-    return std::lexicographical_compare_three_way(
-        __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way<_Tp, _Tp>);
+  return std::lexicographical_compare_three_way(
+      __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
 }
 
 #endif // _LIBCPP_STD_VER <= 17
 
 template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type
+inline _LIBCPP_HIDE_FROM_ABI typename list<_Tp, _Allocator>::size_type
 erase_if(list<_Tp, _Allocator>& __c, _Predicate __pred) {
   return __c.remove_if(__pred);
 }
 
 template <class _Tp, class _Allocator, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY typename list<_Tp, _Allocator>::size_type
+inline _LIBCPP_HIDE_FROM_ABI typename list<_Tp, _Allocator>::size_type
 erase(list<_Tp, _Allocator>& __c, const _Up& __v) {
-  return _VSTD::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
+  return std::erase_if(__c, [&](auto& __elem) { return __elem == __v; });
 }
 
 template <>
 inline constexpr bool __format::__enable_insertable<std::list<char>> = true;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
 inline constexpr bool __format::__enable_insertable<std::list<wchar_t>> = true;
-#endif
+#  endif
 
 #endif // _LIBCPP_STD_VER >= 20
 
@@ -2391,7 +1719,7 @@ _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _ValueT>
-using list = std::list<_ValueT, polymorphic_allocator<_ValueT>>;
+using list _LIBCPP_AVAILABILITY_PMR = std::list<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
@@ -2402,10 +1730,12 @@ _LIBCPP_POP_MACROS
 #  include <algorithm>
 #  include <atomic>
 #  include <concepts>
+#  include <cstdint>
 #  include <cstdlib>
 #  include <functional>
 #  include <iosfwd>
 #  include <iterator>
+#  include <stdexcept>
 #  include <type_traits>
 #  include <typeinfo>
 #endif
diff --git a/third_party/libcxx/locale b/third_party/libcxx/locale
index cbd471393..dbec23a2c 100644
--- a/third_party/libcxx/locale
+++ b/third_party/libcxx/locale
@@ -53,7 +53,7 @@ public:
     // locale operations:
     basic_string<char> name() const;
     bool operator==(const locale& other) const;
-    bool operator!=(const locale& other) const;
+    bool operator!=(const locale& other) const;                              // removed C++20
     template <class charT, class Traits, class Allocator>
       bool operator()(const basic_string<charT,Traits,Allocator>& s1,
                       const basic_string<charT,Traits,Allocator>& s2) const;
@@ -84,7 +84,7 @@ template <class charT> charT tolower(charT c, const locale& loc);
 template<class Codecvt, class Elem = wchar_t,
          class Wide_alloc = allocator<Elem>,
          class Byte_alloc = allocator<char>>
-class wstring_convert
+class wstring_convert                                      // Removed in C++26
 {
 public:
     typedef basic_string<char, char_traits<char>, Byte_alloc> byte_string;
@@ -119,7 +119,7 @@ public:
 };
 
 template <class Codecvt, class Elem = wchar_t, class Tr = char_traits<Elem>>
-class wbuffer_convert
+class wbuffer_convert                                               // Removed in C++26
     : public basic_streambuf<Elem, Tr>
 {
 public:
@@ -187,69 +187,70 @@ template <class charT> class messages_byname;
 
 */
 
-#include <__algorithm/copy.h>
-#include <__algorithm/equal.h>
-#include <__algorithm/find.h>
-#include <__algorithm/max.h>
-#include <__algorithm/reverse.h>
-#include <__algorithm/unwrap_iter.h>
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__debug>
-#include <__iterator/access.h>
-#include <__iterator/back_insert_iterator.h>
-#include <__iterator/istreambuf_iterator.h>
-#include <__iterator/ostreambuf_iterator.h>
-#include <__locale>
-#include <__memory/unique_ptr.h>
-#include <__type_traits/make_unsigned.h>
-#include <cerrno>
-#include <cstdio>
-#include <cstdlib>
-#include <ctime>
-#include <ios>
-#include <limits>
-#include <new>
-#include <streambuf>
-#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
+#  include <__algorithm/copy.h>
+#  include <__algorithm/equal.h>
+#  include <__algorithm/find.h>
+#  include <__algorithm/max.h>
+#  include <__algorithm/reverse.h>
+#  include <__algorithm/unwrap_iter.h>
+#  include <__assert>
+#  include <__iterator/access.h>
+#  include <__iterator/back_insert_iterator.h>
+#  include <__iterator/istreambuf_iterator.h>
+#  include <__iterator/ostreambuf_iterator.h>
+#  include <__locale>
+#  include <__memory/unique_ptr.h>
+#  include <__type_traits/make_unsigned.h>
+#  include <cerrno>
+#  include <cstdio>
+#  include <cstdlib>
+#  include <ctime>
+#  include <ios>
+#  include <limits>
+#  include <new>
+#  include <streambuf>
+#  include <version>
 
 // TODO: Fix __bsd_locale_defaults.h
 // NOLINTBEGIN(libcpp-robust-against-adl)
 
-#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+#  if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 // Most unix variants have catopen.  These are the specific ones that don't.
-#  if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__)
-#    define _LIBCPP_HAS_CATOPEN 1
-#    include <nl_types.h>
+#    if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__)
+#      define _LIBCPP_HAS_CATOPEN 1
+#      include <nl_types.h>
+#    endif
 #  endif
-#endif
 
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-#  include <__locale_dir/locale_base_api/bsd_locale_defaults.h>
-#else
-#  include <__locale_dir/locale_base_api/bsd_locale_fallbacks.h>
-#endif
+#  ifdef _LIBCPP_LOCALE__L_EXTENSIONS
+#    include <__locale_dir/locale_base_api/bsd_locale_defaults.h>
+#  else
+#    include <__locale_dir/locale_base_api/bsd_locale_fallbacks.h>
+#  endif
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 _LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
+#  include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if defined(__APPLE__) || defined(__FreeBSD__)
-#  define _LIBCPP_GET_C_LOCALE 0
-#elif defined(__NetBSD__)
-#  define _LIBCPP_GET_C_LOCALE LC_C_LOCALE
-#else
-#  define _LIBCPP_GET_C_LOCALE __cloc()
-   // Get the C locale object
-   _LIBCPP_FUNC_VIS locale_t __cloc();
-#define __cloc_defined
-#endif
+#  if defined(__APPLE__) || defined(__FreeBSD__)
+#    define _LIBCPP_GET_C_LOCALE 0
+#  elif defined(__NetBSD__)
+#    define _LIBCPP_GET_C_LOCALE LC_C_LOCALE
+#  else
+#    define _LIBCPP_GET_C_LOCALE __cloc()
+// Get the C locale object
+_LIBCPP_EXPORTED_FROM_ABI locale_t __cloc();
+#    define __cloc_defined
+#  endif
 
 // __scan_keyword
 // Scans [__b, __e) until a match is found in the basic_strings range
@@ -270,3688 +271,3154 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 //  If the input is "a", the first keyword matches and eofbit is set.
 //  If the input is "abc", no match is found and "ab" are consumed.
 template <class _InputIterator, class _ForwardIterator, class _Ctype>
-_LIBCPP_HIDE_FROM_ABI
-_ForwardIterator
-__scan_keyword(_InputIterator& __b, _InputIterator __e,
-               _ForwardIterator __kb, _ForwardIterator __ke,
-               const _Ctype& __ct, ios_base::iostate& __err,
-               bool __case_sensitive = true)
-{
-    typedef typename iterator_traits<_InputIterator>::value_type _CharT;
-    size_t __nkw = static_cast<size_t>(_VSTD::distance(__kb, __ke));
-    const unsigned char __doesnt_match = '\0';
-    const unsigned char __might_match = '\1';
-    const unsigned char __does_match = '\2';
-    unsigned char __statbuf[100];
-    unsigned char* __status = __statbuf;
-    unique_ptr<unsigned char, void(*)(void*)> __stat_hold(nullptr, free);
-    if (__nkw > sizeof(__statbuf))
-    {
-        __status = (unsigned char*)malloc(__nkw);
-        if (__status == nullptr)
-            __throw_bad_alloc();
-        __stat_hold.reset(__status);
+_LIBCPP_HIDE_FROM_ABI _ForwardIterator __scan_keyword(
+    _InputIterator& __b,
+    _InputIterator __e,
+    _ForwardIterator __kb,
+    _ForwardIterator __ke,
+    const _Ctype& __ct,
+    ios_base::iostate& __err,
+    bool __case_sensitive = true) {
+  typedef typename iterator_traits<_InputIterator>::value_type _CharT;
+  size_t __nkw                       = static_cast<size_t>(std::distance(__kb, __ke));
+  const unsigned char __doesnt_match = '\0';
+  const unsigned char __might_match  = '\1';
+  const unsigned char __does_match   = '\2';
+  unsigned char __statbuf[100];
+  unsigned char* __status = __statbuf;
+  unique_ptr<unsigned char, void (*)(void*)> __stat_hold(nullptr, free);
+  if (__nkw > sizeof(__statbuf)) {
+    __status = (unsigned char*)malloc(__nkw);
+    if (__status == nullptr)
+      __throw_bad_alloc();
+    __stat_hold.reset(__status);
+  }
+  size_t __n_might_match = __nkw; // At this point, any keyword might match
+  size_t __n_does_match  = 0;     // but none of them definitely do
+  // Initialize all statuses to __might_match, except for "" keywords are __does_match
+  unsigned char* __st = __status;
+  for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void)++__st) {
+    if (!__ky->empty())
+      *__st = __might_match;
+    else {
+      *__st = __does_match;
+      --__n_might_match;
+      ++__n_does_match;
     }
-    size_t __n_might_match = __nkw;  // At this point, any keyword might match
-    size_t __n_does_match = 0;       // but none of them definitely do
-    // Initialize all statuses to __might_match, except for "" keywords are __does_match
-    unsigned char* __st = __status;
-    for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st)
-    {
-        if (!__ky->empty())
-            *__st = __might_match;
-        else
-        {
+  }
+  // While there might be a match, test keywords against the next CharT
+  for (size_t __indx = 0; __b != __e && __n_might_match > 0; ++__indx) {
+    // Peek at the next CharT but don't consume it
+    _CharT __c = *__b;
+    if (!__case_sensitive)
+      __c = __ct.toupper(__c);
+    bool __consume = false;
+    // For each keyword which might match, see if the __indx character is __c
+    // If a match if found, consume __c
+    // If a match is found, and that is the last character in the keyword,
+    //    then that keyword matches.
+    // If the keyword doesn't match this character, then change the keyword
+    //    to doesn't match
+    __st = __status;
+    for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void)++__st) {
+      if (*__st == __might_match) {
+        _CharT __kc = (*__ky)[__indx];
+        if (!__case_sensitive)
+          __kc = __ct.toupper(__kc);
+        if (__c == __kc) {
+          __consume = true;
+          if (__ky->size() == __indx + 1) {
             *__st = __does_match;
             --__n_might_match;
             ++__n_does_match;
+          }
+        } else {
+          *__st = __doesnt_match;
+          --__n_might_match;
         }
+      }
     }
-    // While there might be a match, test keywords against the next CharT
-    for (size_t __indx = 0; __b != __e && __n_might_match > 0; ++__indx)
-    {
-        // Peek at the next CharT but don't consume it
-        _CharT __c = *__b;
-        if (!__case_sensitive)
-            __c = __ct.toupper(__c);
-        bool __consume = false;
-        // For each keyword which might match, see if the __indx character is __c
-        // If a match if found, consume __c
-        // If a match is found, and that is the last character in the keyword,
-        //    then that keyword matches.
-        // If the keyword doesn't match this character, then change the keyword
-        //    to doesn't match
+    // consume if we matched a character
+    if (__consume) {
+      ++__b;
+      // If we consumed a character and there might be a matched keyword that
+      //   was marked matched on a previous iteration, then such keywords
+      //   which are now marked as not matching.
+      if (__n_might_match + __n_does_match > 1) {
         __st = __status;
-        for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st)
-        {
-            if (*__st == __might_match)
-            {
-                _CharT __kc = (*__ky)[__indx];
-                if (!__case_sensitive)
-                    __kc = __ct.toupper(__kc);
-                if (__c == __kc)
-                {
-                    __consume = true;
-                    if (__ky->size() == __indx+1)
-                    {
-                        *__st = __does_match;
-                        --__n_might_match;
-                        ++__n_does_match;
-                    }
-                }
-                else
-                {
-                    *__st = __doesnt_match;
-                    --__n_might_match;
-                }
-            }
-        }
-        // consume if we matched a character
-        if (__consume)
-        {
-            ++__b;
-            // If we consumed a character and there might be a matched keyword that
-            //   was marked matched on a previous iteration, then such keywords
-            //   which are now marked as not matching.
-            if (__n_might_match + __n_does_match > 1)
-            {
-                __st = __status;
-                for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void) ++__st)
-                {
-                    if (*__st == __does_match && __ky->size() != __indx+1)
-                    {
-                        *__st = __doesnt_match;
-                        --__n_does_match;
-                    }
-                }
-            }
+        for (_ForwardIterator __ky = __kb; __ky != __ke; ++__ky, (void)++__st) {
+          if (*__st == __does_match && __ky->size() != __indx + 1) {
+            *__st = __doesnt_match;
+            --__n_does_match;
+          }
         }
+      }
     }
-    // We've exited the loop because we hit eof and/or we have no more "might matches".
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    // Return the first matching result
-    for (__st = __status; __kb != __ke; ++__kb, (void) ++__st)
-        if (*__st == __does_match)
-            break;
-    if (__kb == __ke)
-        __err |= ios_base::failbit;
-    return __kb;
+  }
+  // We've exited the loop because we hit eof and/or we have no more "might matches".
+  if (__b == __e)
+    __err |= ios_base::eofbit;
+  // Return the first matching result
+  for (__st = __status; __kb != __ke; ++__kb, (void)++__st)
+    if (*__st == __does_match)
+      break;
+  if (__kb == __ke)
+    __err |= ios_base::failbit;
+  return __kb;
 }
 
-struct _LIBCPP_TYPE_VIS __num_get_base
-{
-    static const int __num_get_buf_sz = 40;
+struct _LIBCPP_EXPORTED_FROM_ABI __num_get_base {
+  static const int __num_get_buf_sz = 40;
 
-    static int __get_base(ios_base&);
-    static const char __src[33];
+  static int __get_base(ios_base&);
+  static const char __src[33]; // "0123456789abcdefABCDEFxX+-pPiInN"
+  // count of leading characters in __src used for parsing integers ("012..X+-")
+  static const size_t __int_chr_cnt = 26;
+  // count of leading characters in __src used for parsing floating-point values ("012..-pP")
+  static const size_t __fp_chr_cnt = 28;
 };
 
-_LIBCPP_FUNC_VIS
-void __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
-                      ios_base::iostate& __err);
+_LIBCPP_EXPORTED_FROM_ABI void
+__check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end, ios_base::iostate& __err);
 
 template <class _CharT>
-struct __num_get
-    : protected __num_get_base
-{
-    static string __stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point,
-                                      _CharT& __thousands_sep);
+struct __num_get : protected __num_get_base {
+  static string __stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point, _CharT& __thousands_sep);
 
-    static int __stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp,
-                                   char* __a, char*& __a_end,
-                                   _CharT __decimal_point, _CharT __thousands_sep,
-                                   const string& __grouping, unsigned* __g,
-                                   unsigned*& __g_end, unsigned& __dc, _CharT* __atoms);
-#ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
-    static string __stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep);
-    static int __stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
-                  unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
-                  unsigned* __g, unsigned*& __g_end, _CharT* __atoms);
+  static int __stage2_float_loop(
+      _CharT __ct,
+      bool& __in_units,
+      char& __exp,
+      char* __a,
+      char*& __a_end,
+      _CharT __decimal_point,
+      _CharT __thousands_sep,
+      const string& __grouping,
+      unsigned* __g,
+      unsigned*& __g_end,
+      unsigned& __dc,
+      _CharT* __atoms);
+#  ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
+  static string __stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep);
+  static int __stage2_int_loop(
+      _CharT __ct,
+      int __base,
+      char* __a,
+      char*& __a_end,
+      unsigned& __dc,
+      _CharT __thousands_sep,
+      const string& __grouping,
+      unsigned* __g,
+      unsigned*& __g_end,
+      _CharT* __atoms);
 
-#else
-    static string __stage2_int_prep(ios_base& __iob, _CharT& __thousands_sep)
-    {
-        locale __loc = __iob.getloc();
-        const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
-        __thousands_sep = __np.thousands_sep();
-        return __np.grouping();
-    }
+#  else
+  static string __stage2_int_prep(ios_base& __iob, _CharT& __thousands_sep) {
+    locale __loc                 = __iob.getloc();
+    const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+    __thousands_sep              = __np.thousands_sep();
+    return __np.grouping();
+  }
 
-    const _CharT* __do_widen(ios_base& __iob, _CharT* __atoms) const
-    {
-      return __do_widen_p(__iob, __atoms);
-    }
+  const _CharT* __do_widen(ios_base& __iob, _CharT* __atoms) const { return __do_widen_p(__iob, __atoms); }
 
+  static int __stage2_int_loop(
+      _CharT __ct,
+      int __base,
+      char* __a,
+      char*& __a_end,
+      unsigned& __dc,
+      _CharT __thousands_sep,
+      const string& __grouping,
+      unsigned* __g,
+      unsigned*& __g_end,
+      const _CharT* __atoms);
 
-    static int __stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
-                  unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
-                  unsigned* __g, unsigned*& __g_end, const _CharT* __atoms);
 private:
-    template<typename _Tp>
-    const _Tp* __do_widen_p(ios_base& __iob, _Tp* __atoms) const
-    {
-      locale __loc = __iob.getloc();
-      use_facet<ctype<_Tp> >(__loc).widen(__src, __src + 26, __atoms);
-      return __atoms;
-    }
+  template <typename _Tp>
+  const _Tp* __do_widen_p(ios_base& __iob, _Tp* __atoms) const {
+    locale __loc = __iob.getloc();
+    use_facet<ctype<_Tp> >(__loc).widen(__src, __src + __int_chr_cnt, __atoms);
+    return __atoms;
+  }
 
-    const char* __do_widen_p(ios_base& __iob, char* __atoms) const
-    {
-      (void)__iob;
-      (void)__atoms;
-      return __src;
-    }
-#endif
+  const char* __do_widen_p(ios_base& __iob, char* __atoms) const {
+    (void)__iob;
+    (void)__atoms;
+    return __src;
+  }
+#  endif
 };
 
-#ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
+#  ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
 template <class _CharT>
-string
-__num_get<_CharT>::__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep)
-{
-    locale __loc = __iob.getloc();
-    std::use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 26, __atoms);
-    const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__loc);
-    __thousands_sep = __np.thousands_sep();
-    return __np.grouping();
+string __num_get<_CharT>::__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep) {
+  locale __loc = __iob.getloc();
+  std::use_facet<ctype<_CharT> >(__loc).widen(__src, __src + __int_chr_cnt, __atoms);
+  const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__loc);
+  __thousands_sep              = __np.thousands_sep();
+  return __np.grouping();
 }
-#endif
+#  endif
 
 template <class _CharT>
-string
-__num_get<_CharT>::__stage2_float_prep(ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point,
-                    _CharT& __thousands_sep)
-{
-    locale __loc = __iob.getloc();
-    std::use_facet<ctype<_CharT> >(__loc).widen(__src, __src + 32, __atoms);
-    const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__loc);
-    __decimal_point = __np.decimal_point();
-    __thousands_sep = __np.thousands_sep();
-    return __np.grouping();
+string __num_get<_CharT>::__stage2_float_prep(
+    ios_base& __iob, _CharT* __atoms, _CharT& __decimal_point, _CharT& __thousands_sep) {
+  locale __loc = __iob.getloc();
+  std::use_facet<ctype<_CharT> >(__loc).widen(__src, __src + __fp_chr_cnt, __atoms);
+  const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__loc);
+  __decimal_point              = __np.decimal_point();
+  __thousands_sep              = __np.thousands_sep();
+  return __np.grouping();
 }
 
 template <class _CharT>
 int
-#ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
+#  ifndef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
 __num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
                   unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
                   unsigned* __g, unsigned*& __g_end, _CharT* __atoms)
-#else
+#  else
 __num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*& __a_end,
                   unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
                   unsigned* __g, unsigned*& __g_end, const _CharT* __atoms)
 
-#endif
+#  endif
 {
-    if (__a_end == __a && (__ct == __atoms[24] || __ct == __atoms[25]))
-    {
-        *__a_end++ = __ct == __atoms[24] ? '+' : '-';
-        __dc = 0;
-        return 0;
-    }
-    if (__grouping.size() != 0 && __ct == __thousands_sep)
-    {
-        if (__g_end-__g < __num_get_buf_sz)
-        {
-            *__g_end++ = __dc;
-            __dc = 0;
-        }
-        return 0;
-    }
-    ptrdiff_t __f = std::find(__atoms, __atoms + 26, __ct) - __atoms;
-    if (__f >= 24)
-        return -1;
-    switch (__base)
-    {
-    case 8:
-    case 10:
-        if (__f >= __base)
-            return -1;
-        break;
-    case 16:
-        if (__f < 22)
-            break;
-        if (__a_end != __a && __a_end - __a <= 2 && __a_end[-1] == '0')
-        {
-            __dc = 0;
-            *__a_end++ = __src[__f];
-            return 0;
-        }
-        return -1;
-    }
-    *__a_end++ = __src[__f];
-    ++__dc;
+  if (__a_end == __a && (__ct == __atoms[24] || __ct == __atoms[25])) {
+    *__a_end++ = __ct == __atoms[24] ? '+' : '-';
+    __dc       = 0;
     return 0;
+  }
+  if (__grouping.size() != 0 && __ct == __thousands_sep) {
+    if (__g_end - __g < __num_get_buf_sz) {
+      *__g_end++ = __dc;
+      __dc       = 0;
+    }
+    return 0;
+  }
+  ptrdiff_t __f = std::find(__atoms, __atoms + __int_chr_cnt, __ct) - __atoms;
+  if (__f >= 24)
+    return -1;
+  switch (__base) {
+  case 8:
+  case 10:
+    if (__f >= __base)
+      return -1;
+    break;
+  case 16:
+    if (__f < 22)
+      break;
+    if (__a_end != __a && __a_end - __a <= 2 && __a_end[-1] == '0') {
+      __dc       = 0;
+      *__a_end++ = __src[__f];
+      return 0;
+    }
+    return -1;
+  }
+  *__a_end++ = __src[__f];
+  ++__dc;
+  return 0;
 }
 
 template <class _CharT>
-int
-__num_get<_CharT>::__stage2_float_loop(_CharT __ct, bool& __in_units, char& __exp, char* __a, char*& __a_end,
-                    _CharT __decimal_point, _CharT __thousands_sep, const string& __grouping,
-                    unsigned* __g, unsigned*& __g_end, unsigned& __dc, _CharT* __atoms)
-{
-    if (__ct == __decimal_point)
-    {
-        if (!__in_units)
-            return -1;
-        __in_units = false;
-        *__a_end++ = '.';
-        if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz)
-            *__g_end++ = __dc;
-        return 0;
-    }
-    if (__ct == __thousands_sep && __grouping.size() != 0)
-    {
-        if (!__in_units)
-            return -1;
-        if (__g_end-__g < __num_get_buf_sz)
-        {
-            *__g_end++ = __dc;
-            __dc = 0;
-        }
-        return 0;
-    }
-    ptrdiff_t __f = std::find(__atoms, __atoms + 32, __ct) - __atoms;
-    if (__f >= 32)
-        return -1;
-    char __x = __src[__f];
-    if (__x == '-' || __x == '+')
-    {
-        if (__a_end == __a || (std::toupper(__a_end[-1]) == std::toupper(__exp)))
-        {
-            *__a_end++ = __x;
-            return 0;
-        }
-        return -1;
-    }
-    if (__x == 'x' || __x == 'X')
-        __exp = 'P';
-    else if (std::toupper(__x) == __exp)
-    {
-        __exp = std::tolower(__exp);
-        if (__in_units)
-        {
-            __in_units = false;
-            if (__grouping.size() != 0 && __g_end-__g < __num_get_buf_sz)
-                *__g_end++ = __dc;
-        }
-    }
-    *__a_end++ = __x;
-    if (__f >= 22)
-        return 0;
-    ++__dc;
+int __num_get<_CharT>::__stage2_float_loop(
+    _CharT __ct,
+    bool& __in_units,
+    char& __exp,
+    char* __a,
+    char*& __a_end,
+    _CharT __decimal_point,
+    _CharT __thousands_sep,
+    const string& __grouping,
+    unsigned* __g,
+    unsigned*& __g_end,
+    unsigned& __dc,
+    _CharT* __atoms) {
+  if (__ct == __decimal_point) {
+    if (!__in_units)
+      return -1;
+    __in_units = false;
+    *__a_end++ = '.';
+    if (__grouping.size() != 0 && __g_end - __g < __num_get_buf_sz)
+      *__g_end++ = __dc;
     return 0;
+  }
+  if (__ct == __thousands_sep && __grouping.size() != 0) {
+    if (!__in_units)
+      return -1;
+    if (__g_end - __g < __num_get_buf_sz) {
+      *__g_end++ = __dc;
+      __dc       = 0;
+    }
+    return 0;
+  }
+  ptrdiff_t __f = std::find(__atoms, __atoms + __num_get_base::__fp_chr_cnt, __ct) - __atoms;
+  if (__f >= static_cast<ptrdiff_t>(__num_get_base::__fp_chr_cnt))
+    return -1;
+  char __x = __src[__f];
+  if (__x == '-' || __x == '+') {
+    if (__a_end == __a || (std::toupper(__a_end[-1]) == std::toupper(__exp))) {
+      *__a_end++ = __x;
+      return 0;
+    }
+    return -1;
+  }
+  if (__x == 'x' || __x == 'X')
+    __exp = 'P';
+  else if (std::toupper(__x) == __exp) {
+    __exp = std::tolower(__exp);
+    if (__in_units) {
+      __in_units = false;
+      if (__grouping.size() != 0 && __g_end - __g < __num_get_buf_sz)
+        *__g_end++ = __dc;
+    }
+  }
+  *__a_end++ = __x;
+  if (__f >= 22)
+    return 0;
+  ++__dc;
+  return 0;
 }
 
 extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_get<wchar_t>;
-#endif
+#  endif
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TEMPLATE_VIS num_get
-    : public locale::facet,
-      private __num_get<_CharT>
-{
+class _LIBCPP_TEMPLATE_VIS num_get : public locale::facet, private __num_get<_CharT> {
 public:
-    typedef _CharT char_type;
-    typedef _InputIterator iter_type;
+  typedef _CharT char_type;
+  typedef _InputIterator iter_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit num_get(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit num_get(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, bool& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, bool& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, long& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, long long& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long long& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, unsigned short& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned short& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, unsigned int& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned int& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, unsigned long& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, unsigned long long& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long long& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, float& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, float& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, double& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, double& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, long double& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long double& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, void*& __v) const
-    {
-        return do_get(__b, __e, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, void*& __v) const {
+    return do_get(__b, __e, __iob, __err, __v);
+  }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~num_get() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~num_get() override {}
 
-    template <class _Fp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    iter_type __do_get_floating_point
-                            (iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, _Fp& __v) const;
+  template <class _Fp>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS iter_type
+  __do_get_floating_point(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Fp& __v) const;
 
-    template <class _Signed>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    iter_type __do_get_signed
-                            (iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, _Signed& __v) const;
+  template <class _Signed>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS iter_type
+  __do_get_signed(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Signed& __v) const;
 
-    template <class _Unsigned>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    iter_type __do_get_unsigned
-                            (iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, _Unsigned& __v) const;
+  template <class _Unsigned>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS iter_type
+  __do_get_unsigned(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Unsigned& __v) const;
 
+  virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, bool& __v) const;
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, bool& __v) const;
+  virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long& __v) const {
+    return this->__do_get_signed(__b, __e, __iob, __err, __v);
+  }
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, long& __v) const
-    { return this->__do_get_signed ( __b, __e, __iob, __err, __v ); }
+  virtual iter_type
+  do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long long& __v) const {
+    return this->__do_get_signed(__b, __e, __iob, __err, __v);
+  }
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, long long& __v) const
-    { return this->__do_get_signed ( __b, __e, __iob, __err, __v ); }
+  virtual iter_type
+  do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned short& __v) const {
+    return this->__do_get_unsigned(__b, __e, __iob, __err, __v);
+  }
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, unsigned short& __v) const
-    { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
+  virtual iter_type
+  do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned int& __v) const {
+    return this->__do_get_unsigned(__b, __e, __iob, __err, __v);
+  }
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, unsigned int& __v) const
-    { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
+  virtual iter_type
+  do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long& __v) const {
+    return this->__do_get_unsigned(__b, __e, __iob, __err, __v);
+  }
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, unsigned long& __v) const
-    { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
+  virtual iter_type
+  do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long long& __v) const {
+    return this->__do_get_unsigned(__b, __e, __iob, __err, __v);
+  }
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, unsigned long long& __v) const
-    { return this->__do_get_unsigned ( __b, __e, __iob, __err, __v ); }
+  virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, float& __v) const {
+    return this->__do_get_floating_point(__b, __e, __iob, __err, __v);
+  }
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, float& __v) const
-    { return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }
+  virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, double& __v) const {
+    return this->__do_get_floating_point(__b, __e, __iob, __err, __v);
+  }
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, double& __v) const
-    { return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }
+  virtual iter_type
+  do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long double& __v) const {
+    return this->__do_get_floating_point(__b, __e, __iob, __err, __v);
+  }
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, long double& __v) const
-    { return this->__do_get_floating_point ( __b, __e, __iob, __err, __v ); }
-
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, void*& __v) const;
+  virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, void*& __v) const;
 };
 
 template <class _CharT, class _InputIterator>
-locale::id
-num_get<_CharT, _InputIterator>::id;
+locale::id num_get<_CharT, _InputIterator>::id;
 
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI _Tp
-__num_get_signed_integral(const char* __a, const char* __a_end,
-                          ios_base::iostate& __err, int __base)
-{
-    if (__a != __a_end)
-    {
-        __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
-        errno = 0;
-        char *__p2;
-        long long __ll = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
-        __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
-        if (__current_errno == 0)
-            errno = __save_errno;
-        if (__p2 != __a_end)
-        {
-            __err = ios_base::failbit;
-            return 0;
-        }
-        else if (__current_errno == ERANGE         ||
-                 __ll < numeric_limits<_Tp>::min() ||
-                 numeric_limits<_Tp>::max() < __ll)
-        {
-            __err = ios_base::failbit;
-            if (__ll > 0)
-                return numeric_limits<_Tp>::max();
-            else
-                return numeric_limits<_Tp>::min();
-        }
-        return static_cast<_Tp>(__ll);
+__num_get_signed_integral(const char* __a, const char* __a_end, ios_base::iostate& __err, int __base) {
+  if (__a != __a_end) {
+    __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
+    errno                                                     = 0;
+    char* __p2;
+    long long __ll                                               = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
+    __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
+    if (__current_errno == 0)
+      errno = __save_errno;
+    if (__p2 != __a_end) {
+      __err = ios_base::failbit;
+      return 0;
+    } else if (__current_errno == ERANGE || __ll < numeric_limits<_Tp>::min() || numeric_limits<_Tp>::max() < __ll) {
+      __err = ios_base::failbit;
+      if (__ll > 0)
+        return numeric_limits<_Tp>::max();
+      else
+        return numeric_limits<_Tp>::min();
     }
-    __err = ios_base::failbit;
-    return 0;
+    return static_cast<_Tp>(__ll);
+  }
+  __err = ios_base::failbit;
+  return 0;
 }
 
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI _Tp
-__num_get_unsigned_integral(const char* __a, const char* __a_end,
-                            ios_base::iostate& __err, int __base)
-{
-    if (__a != __a_end)
-    {
-        const bool __negate = *__a == '-';
-        if (__negate && ++__a == __a_end) {
-          __err = ios_base::failbit;
-          return 0;
-        }
-        __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
-        errno = 0;
-        char *__p2;
-        unsigned long long __ll = strtoull_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
-        __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
-        if (__current_errno == 0)
-            errno = __save_errno;
-        if (__p2 != __a_end)
-        {
-            __err = ios_base::failbit;
-            return 0;
-        }
-        else if (__current_errno == ERANGE || numeric_limits<_Tp>::max() < __ll)
-        {
-            __err = ios_base::failbit;
-            return numeric_limits<_Tp>::max();
-        }
-        _Tp __res = static_cast<_Tp>(__ll);
-        if (__negate) __res = -__res;
-        return __res;
+__num_get_unsigned_integral(const char* __a, const char* __a_end, ios_base::iostate& __err, int __base) {
+  if (__a != __a_end) {
+    const bool __negate = *__a == '-';
+    if (__negate && ++__a == __a_end) {
+      __err = ios_base::failbit;
+      return 0;
     }
-    __err = ios_base::failbit;
-    return 0;
+    __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
+    errno                                                     = 0;
+    char* __p2;
+    unsigned long long __ll                                      = strtoull_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
+    __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
+    if (__current_errno == 0)
+      errno = __save_errno;
+    if (__p2 != __a_end) {
+      __err = ios_base::failbit;
+      return 0;
+    } else if (__current_errno == ERANGE || numeric_limits<_Tp>::max() < __ll) {
+      __err = ios_base::failbit;
+      return numeric_limits<_Tp>::max();
+    }
+    _Tp __res = static_cast<_Tp>(__ll);
+    if (__negate)
+      __res = -__res;
+    return __res;
+  }
+  __err = ios_base::failbit;
+  return 0;
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp __do_strtod(const char* __a, char** __p2);
+_LIBCPP_HIDE_FROM_ABI _Tp __do_strtod(const char* __a, char** __p2);
 
 template <>
-inline _LIBCPP_INLINE_VISIBILITY
-float __do_strtod<float>(const char* __a, char** __p2) {
-    return strtof_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
+inline _LIBCPP_HIDE_FROM_ABI float __do_strtod<float>(const char* __a, char** __p2) {
+  return strtof_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
 }
 
 template <>
-inline _LIBCPP_INLINE_VISIBILITY
-double __do_strtod<double>(const char* __a, char** __p2) {
-    return strtod_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
+inline _LIBCPP_HIDE_FROM_ABI double __do_strtod<double>(const char* __a, char** __p2) {
+  return strtod_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
 }
 
 template <>
-inline _LIBCPP_INLINE_VISIBILITY
-long double __do_strtod<long double>(const char* __a, char** __p2) {
-    return strtold_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
+inline _LIBCPP_HIDE_FROM_ABI long double __do_strtod<long double>(const char* __a, char** __p2) {
+  return strtold_l(__a, __p2, _LIBCPP_GET_C_LOCALE);
 }
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-_Tp
-__num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
-{
-    if (__a != __a_end)
-    {
-        __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
-        errno = 0;
-        char *__p2;
-        _Tp __ld = std::__do_strtod<_Tp>(__a, &__p2);
-        __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
-        if (__current_errno == 0)
-            errno = __save_errno;
-        if (__p2 != __a_end)
-        {
-            __err = ios_base::failbit;
-            return 0;
-        }
-        else if (__current_errno == ERANGE)
-            __err = ios_base::failbit;
-        return __ld;
-    }
-    __err = ios_base::failbit;
-    return 0;
+_LIBCPP_HIDE_FROM_ABI _Tp __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err) {
+  if (__a != __a_end) {
+    __libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
+    errno                                                     = 0;
+    char* __p2;
+    _Tp __ld                                                     = std::__do_strtod<_Tp>(__a, &__p2);
+    __libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
+    if (__current_errno == 0)
+      errno = __save_errno;
+    if (__p2 != __a_end) {
+      __err = ios_base::failbit;
+      return 0;
+    } else if (__current_errno == ERANGE)
+      __err = ios_base::failbit;
+    return __ld;
+  }
+  __err = ios_base::failbit;
+  return 0;
 }
 
 template <class _CharT, class _InputIterator>
-_InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        bool& __v) const
-{
-    if ((__iob.flags() & ios_base::boolalpha) == 0)
-    {
-        long __lv = -1;
-        __b = do_get(__b, __e, __iob, __err, __lv);
-        switch (__lv)
-        {
-        case 0:
-            __v = false;
-            break;
-        case 1:
-            __v = true;
-            break;
-        default:
-            __v = true;
-            __err = ios_base::failbit;
-            break;
-        }
-        return __b;
+_InputIterator num_get<_CharT, _InputIterator>::do_get(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, bool& __v) const {
+  if ((__iob.flags() & ios_base::boolalpha) == 0) {
+    long __lv = -1;
+    __b       = do_get(__b, __e, __iob, __err, __lv);
+    switch (__lv) {
+    case 0:
+      __v = false;
+      break;
+    case 1:
+      __v = true;
+      break;
+    default:
+      __v   = true;
+      __err = ios_base::failbit;
+      break;
     }
-    const ctype<_CharT>& __ct = std::use_facet<ctype<_CharT> >(__iob.getloc());
-    const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__iob.getloc());
-    typedef typename numpunct<_CharT>::string_type string_type;
-    const string_type __names[2] = {__np.truename(), __np.falsename()};
-    const string_type* __i = _VSTD::__scan_keyword(__b, __e, __names, __names+2,
-                                                   __ct, __err);
-    __v = __i == __names;
     return __b;
+  }
+  const ctype<_CharT>& __ct    = std::use_facet<ctype<_CharT> >(__iob.getloc());
+  const numpunct<_CharT>& __np = std::use_facet<numpunct<_CharT> >(__iob.getloc());
+  typedef typename numpunct<_CharT>::string_type string_type;
+  const string_type __names[2] = {__np.truename(), __np.falsename()};
+  const string_type* __i       = std::__scan_keyword(__b, __e, __names, __names + 2, __ct, __err);
+  __v                          = __i == __names;
+  return __b;
 }
 
 // signed
 
 template <class _CharT, class _InputIterator>
 template <class _Signed>
-_InputIterator
-num_get<_CharT, _InputIterator>::__do_get_signed(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        _Signed& __v) const
-{
-    // Stage 1
-    int __base = this->__get_base(__iob);
-    // Stage 2
-    char_type __thousands_sep;
-    const int __atoms_size = 26;
-#ifdef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
-    char_type __atoms1[__atoms_size];
-    const char_type *__atoms = this->__do_widen(__iob, __atoms1);
-    string __grouping = this->__stage2_int_prep(__iob, __thousands_sep);
-#else
-    char_type __atoms[__atoms_size];
-    string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
-#endif
-    string __buf;
-    __buf.resize(__buf.capacity());
-    char* __a = &__buf[0];
-    char* __a_end = __a;
-    unsigned __g[__num_get_base::__num_get_buf_sz];
-    unsigned* __g_end = __g;
-    unsigned __dc = 0;
-    for (; __b != __e; ++__b)
-    {
-        if (__a_end == __a + __buf.size())
-        {
-            size_t __tmp = __buf.size();
-            __buf.resize(2*__buf.size());
-            __buf.resize(__buf.capacity());
-            __a = &__buf[0];
-            __a_end = __a + __tmp;
-        }
-        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
-                                    __thousands_sep, __grouping, __g, __g_end,
-                                    __atoms))
-            break;
+_InputIterator num_get<_CharT, _InputIterator>::__do_get_signed(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Signed& __v) const {
+  // Stage 1
+  int __base = this->__get_base(__iob);
+  // Stage 2
+  char_type __thousands_sep;
+  const int __atoms_size = __num_get_base::__int_chr_cnt;
+#  ifdef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
+  char_type __atoms1[__atoms_size];
+  const char_type* __atoms = this->__do_widen(__iob, __atoms1);
+  string __grouping        = this->__stage2_int_prep(__iob, __thousands_sep);
+#  else
+  char_type __atoms[__atoms_size];
+  string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
+#  endif
+  string __buf;
+  __buf.resize(__buf.capacity());
+  char* __a     = &__buf[0];
+  char* __a_end = __a;
+  unsigned __g[__num_get_base::__num_get_buf_sz];
+  unsigned* __g_end = __g;
+  unsigned __dc     = 0;
+  for (; __b != __e; ++__b) {
+    if (__a_end == __a + __buf.size()) {
+      size_t __tmp = __buf.size();
+      __buf.resize(2 * __buf.size());
+      __buf.resize(__buf.capacity());
+      __a     = &__buf[0];
+      __a_end = __a + __tmp;
     }
-    if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz)
-        *__g_end++ = __dc;
-    // Stage 3
-    __v = std::__num_get_signed_integral<_Signed>(__a, __a_end, __err, __base);
-    // Digit grouping checked
-    __check_grouping(__grouping, __g, __g_end, __err);
-    // EOF checked
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
+    if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms))
+      break;
+  }
+  if (__grouping.size() != 0 && __g_end - __g < __num_get_base::__num_get_buf_sz)
+    *__g_end++ = __dc;
+  // Stage 3
+  __v = std::__num_get_signed_integral<_Signed>(__a, __a_end, __err, __base);
+  // Digit grouping checked
+  __check_grouping(__grouping, __g, __g_end, __err);
+  // EOF checked
+  if (__b == __e)
+    __err |= ios_base::eofbit;
+  return __b;
 }
 
 // unsigned
 
 template <class _CharT, class _InputIterator>
 template <class _Unsigned>
-_InputIterator
-num_get<_CharT, _InputIterator>::__do_get_unsigned(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        _Unsigned& __v) const
-{
-    // Stage 1
-    int __base = this->__get_base(__iob);
-    // Stage 2
-    char_type __thousands_sep;
-    const int __atoms_size = 26;
-#ifdef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
-    char_type __atoms1[__atoms_size];
-    const char_type *__atoms = this->__do_widen(__iob, __atoms1);
-    string __grouping = this->__stage2_int_prep(__iob, __thousands_sep);
-#else
-    char_type __atoms[__atoms_size];
-    string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
-#endif
-    string __buf;
-    __buf.resize(__buf.capacity());
-    char* __a = &__buf[0];
-    char* __a_end = __a;
-    unsigned __g[__num_get_base::__num_get_buf_sz];
-    unsigned* __g_end = __g;
-    unsigned __dc = 0;
-    for (; __b != __e; ++__b)
-    {
-        if (__a_end == __a + __buf.size())
-        {
-            size_t __tmp = __buf.size();
-            __buf.resize(2*__buf.size());
-            __buf.resize(__buf.capacity());
-            __a = &__buf[0];
-            __a_end = __a + __tmp;
-        }
-        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
-                                    __thousands_sep, __grouping, __g, __g_end,
-                                    __atoms))
-            break;
+_InputIterator num_get<_CharT, _InputIterator>::__do_get_unsigned(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Unsigned& __v) const {
+  // Stage 1
+  int __base = this->__get_base(__iob);
+  // Stage 2
+  char_type __thousands_sep;
+  const int __atoms_size = __num_get_base::__int_chr_cnt;
+#  ifdef _LIBCPP_ABI_OPTIMIZED_LOCALE_NUM_GET
+  char_type __atoms1[__atoms_size];
+  const char_type* __atoms = this->__do_widen(__iob, __atoms1);
+  string __grouping        = this->__stage2_int_prep(__iob, __thousands_sep);
+#  else
+  char_type __atoms[__atoms_size];
+  string __grouping = this->__stage2_int_prep(__iob, __atoms, __thousands_sep);
+#  endif
+  string __buf;
+  __buf.resize(__buf.capacity());
+  char* __a     = &__buf[0];
+  char* __a_end = __a;
+  unsigned __g[__num_get_base::__num_get_buf_sz];
+  unsigned* __g_end = __g;
+  unsigned __dc     = 0;
+  for (; __b != __e; ++__b) {
+    if (__a_end == __a + __buf.size()) {
+      size_t __tmp = __buf.size();
+      __buf.resize(2 * __buf.size());
+      __buf.resize(__buf.capacity());
+      __a     = &__buf[0];
+      __a_end = __a + __tmp;
     }
-    if (__grouping.size() != 0 && __g_end-__g < __num_get_base::__num_get_buf_sz)
-        *__g_end++ = __dc;
-    // Stage 3
-    __v = std::__num_get_unsigned_integral<_Unsigned>(__a, __a_end, __err, __base);
-    // Digit grouping checked
-    __check_grouping(__grouping, __g, __g_end, __err);
-    // EOF checked
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
+    if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms))
+      break;
+  }
+  if (__grouping.size() != 0 && __g_end - __g < __num_get_base::__num_get_buf_sz)
+    *__g_end++ = __dc;
+  // Stage 3
+  __v = std::__num_get_unsigned_integral<_Unsigned>(__a, __a_end, __err, __base);
+  // Digit grouping checked
+  __check_grouping(__grouping, __g, __g_end, __err);
+  // EOF checked
+  if (__b == __e)
+    __err |= ios_base::eofbit;
+  return __b;
 }
 
 // floating point
 
 template <class _CharT, class _InputIterator>
 template <class _Fp>
-_InputIterator
-num_get<_CharT, _InputIterator>::__do_get_floating_point(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        _Fp& __v) const
-{
-    // Stage 1, nothing to do
-    // Stage 2
-    char_type __atoms[32];
-    char_type __decimal_point;
-    char_type __thousands_sep;
-    string __grouping = this->__stage2_float_prep(__iob, __atoms,
-                                                  __decimal_point,
-                                                  __thousands_sep);
-    string __buf;
-    __buf.resize(__buf.capacity());
-    char* __a = &__buf[0];
-    char* __a_end = __a;
-    unsigned __g[__num_get_base::__num_get_buf_sz];
-    unsigned* __g_end = __g;
-    unsigned __dc = 0;
-    bool __in_units = true;
-    char __exp = 'E';
-    for (; __b != __e; ++__b)
-    {
-        if (__a_end == __a + __buf.size())
-        {
-            size_t __tmp = __buf.size();
-            __buf.resize(2*__buf.size());
-            __buf.resize(__buf.capacity());
-            __a = &__buf[0];
-            __a_end = __a + __tmp;
-        }
-        if (this->__stage2_float_loop(*__b, __in_units, __exp, __a, __a_end,
-                                      __decimal_point, __thousands_sep,
-                                      __grouping, __g, __g_end,
-                                      __dc, __atoms))
-            break;
+_InputIterator num_get<_CharT, _InputIterator>::__do_get_floating_point(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Fp& __v) const {
+  // Stage 1, nothing to do
+  // Stage 2
+  char_type __atoms[__num_get_base::__fp_chr_cnt];
+  char_type __decimal_point;
+  char_type __thousands_sep;
+  string __grouping = this->__stage2_float_prep(__iob, __atoms, __decimal_point, __thousands_sep);
+  string __buf;
+  __buf.resize(__buf.capacity());
+  char* __a     = &__buf[0];
+  char* __a_end = __a;
+  unsigned __g[__num_get_base::__num_get_buf_sz];
+  unsigned* __g_end        = __g;
+  unsigned __dc            = 0;
+  bool __in_units          = true;
+  char __exp               = 'E';
+  bool __is_leading_parsed = false;
+  for (; __b != __e; ++__b) {
+    if (__a_end == __a + __buf.size()) {
+      size_t __tmp = __buf.size();
+      __buf.resize(2 * __buf.size());
+      __buf.resize(__buf.capacity());
+      __a     = &__buf[0];
+      __a_end = __a + __tmp;
     }
-    if (__grouping.size() != 0 && __in_units && __g_end-__g < __num_get_base::__num_get_buf_sz)
-        *__g_end++ = __dc;
-    // Stage 3
-    __v = std::__num_get_float<_Fp>(__a, __a_end, __err);
-    // Digit grouping checked
-    __check_grouping(__grouping, __g, __g_end, __err);
-    // EOF checked
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
+    if (this->__stage2_float_loop(
+            *__b,
+            __in_units,
+            __exp,
+            __a,
+            __a_end,
+            __decimal_point,
+            __thousands_sep,
+            __grouping,
+            __g,
+            __g_end,
+            __dc,
+            __atoms))
+      break;
+
+    // the leading character excluding the sign must be a decimal digit
+    if (!__is_leading_parsed) {
+      if (__a_end - __a >= 1 && __a[0] != '-' && __a[0] != '+') {
+        if (('0' <= __a[0] && __a[0] <= '9') || __a[0] == '.')
+          __is_leading_parsed = true;
+        else
+          break;
+      } else if (__a_end - __a >= 2 && (__a[0] == '-' || __a[0] == '+')) {
+        if (('0' <= __a[1] && __a[1] <= '9') || __a[1] == '.')
+          __is_leading_parsed = true;
+        else
+          break;
+      }
+    }
+  }
+  if (__grouping.size() != 0 && __in_units && __g_end - __g < __num_get_base::__num_get_buf_sz)
+    *__g_end++ = __dc;
+  // Stage 3
+  __v = std::__num_get_float<_Fp>(__a, __a_end, __err);
+  // Digit grouping checked
+  __check_grouping(__grouping, __g, __g_end, __err);
+  // EOF checked
+  if (__b == __e)
+    __err |= ios_base::eofbit;
+  return __b;
 }
 
 template <class _CharT, class _InputIterator>
-_InputIterator
-num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                        ios_base& __iob,
-                                        ios_base::iostate& __err,
-                                        void*& __v) const
-{
-    // Stage 1
-    int __base = 16;
-    // Stage 2
-    char_type __atoms[26];
-    char_type __thousands_sep = 0;
-    string __grouping;
-    std::use_facet<ctype<_CharT> >(__iob.getloc()).widen(__num_get_base::__src,
-                                                         __num_get_base::__src + 26, __atoms);
-    string __buf;
-    __buf.resize(__buf.capacity());
-    char* __a = &__buf[0];
-    char* __a_end = __a;
-    unsigned __g[__num_get_base::__num_get_buf_sz];
-    unsigned* __g_end = __g;
-    unsigned __dc = 0;
-    for (; __b != __e; ++__b)
-    {
-        if (__a_end == __a + __buf.size())
-        {
-            size_t __tmp = __buf.size();
-            __buf.resize(2*__buf.size());
-            __buf.resize(__buf.capacity());
-            __a = &__buf[0];
-            __a_end = __a + __tmp;
-        }
-        if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc,
-                                    __thousands_sep, __grouping,
-                                    __g, __g_end, __atoms))
-            break;
+_InputIterator num_get<_CharT, _InputIterator>::do_get(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, void*& __v) const {
+  // Stage 1
+  int __base = 16;
+  // Stage 2
+  char_type __atoms[__num_get_base::__int_chr_cnt];
+  char_type __thousands_sep = char_type();
+  string __grouping;
+  std::use_facet<ctype<_CharT> >(__iob.getloc())
+      .widen(__num_get_base::__src, __num_get_base::__src + __num_get_base::__int_chr_cnt, __atoms);
+  string __buf;
+  __buf.resize(__buf.capacity());
+  char* __a     = &__buf[0];
+  char* __a_end = __a;
+  unsigned __g[__num_get_base::__num_get_buf_sz];
+  unsigned* __g_end = __g;
+  unsigned __dc     = 0;
+  for (; __b != __e; ++__b) {
+    if (__a_end == __a + __buf.size()) {
+      size_t __tmp = __buf.size();
+      __buf.resize(2 * __buf.size());
+      __buf.resize(__buf.capacity());
+      __a     = &__buf[0];
+      __a_end = __a + __tmp;
     }
-    // Stage 3
-    __buf.resize(__a_end - __a);
-    if (__libcpp_sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
-        __err = ios_base::failbit;
-    // EOF checked
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
+    if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms))
+      break;
+  }
+  // Stage 3
+  __buf.resize(__a_end - __a);
+  if (__libcpp_sscanf_l(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
+    __err = ios_base::failbit;
+  // EOF checked
+  if (__b == __e)
+    __err |= ios_base::eofbit;
+  return __b;
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<wchar_t>;
-#endif
+#  endif
 
-struct _LIBCPP_TYPE_VIS __num_put_base
-{
+struct _LIBCPP_EXPORTED_FROM_ABI __num_put_base {
 protected:
-    static void __format_int(char* __fmt, const char* __len, bool __signd,
-                             ios_base::fmtflags __flags);
-    static bool __format_float(char* __fmt, const char* __len,
-                               ios_base::fmtflags __flags);
-    static char* __identify_padding(char* __nb, char* __ne,
-                                    const ios_base& __iob);
+  static void __format_int(char* __fmt, const char* __len, bool __signd, ios_base::fmtflags __flags);
+  static bool __format_float(char* __fmt, const char* __len, ios_base::fmtflags __flags);
+  static char* __identify_padding(char* __nb, char* __ne, const ios_base& __iob);
 };
 
 template <class _CharT>
-struct __num_put
-    : protected __num_put_base
-{
-    static void __widen_and_group_int(char* __nb, char* __np, char* __ne,
-                                      _CharT* __ob, _CharT*& __op, _CharT*& __oe,
-                                      const locale& __loc);
-    static void __widen_and_group_float(char* __nb, char* __np, char* __ne,
-                                        _CharT* __ob, _CharT*& __op, _CharT*& __oe,
-                                        const locale& __loc);
+struct __num_put : protected __num_put_base {
+  static void __widen_and_group_int(
+      char* __nb, char* __np, char* __ne, _CharT* __ob, _CharT*& __op, _CharT*& __oe, const locale& __loc);
+  static void __widen_and_group_float(
+      char* __nb, char* __np, char* __ne, _CharT* __ob, _CharT*& __op, _CharT*& __oe, const locale& __loc);
 };
 
 template <class _CharT>
-void
-__num_put<_CharT>::__widen_and_group_int(char* __nb, char* __np, char* __ne,
-                                         _CharT* __ob, _CharT*& __op, _CharT*& __oe,
-                                         const locale& __loc)
-{
-    const ctype<_CharT>&    __ct = std::use_facet<ctype<_CharT> >   (__loc);
-    const numpunct<_CharT>& __npt = std::use_facet<numpunct<_CharT> >(__loc);
-    string __grouping = __npt.grouping();
-    if (__grouping.empty())
-    {
-        __ct.widen(__nb, __ne, __ob);
-        __oe = __ob + (__ne - __nb);
+void __num_put<_CharT>::__widen_and_group_int(
+    char* __nb, char* __np, char* __ne, _CharT* __ob, _CharT*& __op, _CharT*& __oe, const locale& __loc) {
+  const ctype<_CharT>& __ct     = std::use_facet<ctype<_CharT> >(__loc);
+  const numpunct<_CharT>& __npt = std::use_facet<numpunct<_CharT> >(__loc);
+  string __grouping             = __npt.grouping();
+  if (__grouping.empty()) {
+    __ct.widen(__nb, __ne, __ob);
+    __oe = __ob + (__ne - __nb);
+  } else {
+    __oe       = __ob;
+    char* __nf = __nb;
+    if (*__nf == '-' || *__nf == '+')
+      *__oe++ = __ct.widen(*__nf++);
+    if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' || __nf[1] == 'X')) {
+      *__oe++ = __ct.widen(*__nf++);
+      *__oe++ = __ct.widen(*__nf++);
     }
-    else
-    {
-        __oe = __ob;
-        char* __nf = __nb;
-        if (*__nf == '-' || *__nf == '+')
-            *__oe++ = __ct.widen(*__nf++);
-        if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' ||
-                                                   __nf[1] == 'X'))
-        {
-            *__oe++ = __ct.widen(*__nf++);
-            *__oe++ = __ct.widen(*__nf++);
-        }
-        std::reverse(__nf, __ne);
-        _CharT __thousands_sep = __npt.thousands_sep();
-        unsigned __dc = 0;
-        unsigned __dg = 0;
-        for (char* __p = __nf; __p < __ne; ++__p)
-        {
-            if (static_cast<unsigned>(__grouping[__dg]) > 0 &&
-                __dc == static_cast<unsigned>(__grouping[__dg]))
-            {
-                *__oe++ = __thousands_sep;
-                __dc = 0;
-                if (__dg < __grouping.size()-1)
-                    ++__dg;
-            }
-            *__oe++ = __ct.widen(*__p);
-            ++__dc;
-        }
-        std::reverse(__ob + (__nf - __nb), __oe);
+    std::reverse(__nf, __ne);
+    _CharT __thousands_sep = __npt.thousands_sep();
+    unsigned __dc          = 0;
+    unsigned __dg          = 0;
+    for (char* __p = __nf; __p < __ne; ++__p) {
+      if (static_cast<unsigned>(__grouping[__dg]) > 0 && __dc == static_cast<unsigned>(__grouping[__dg])) {
+        *__oe++ = __thousands_sep;
+        __dc    = 0;
+        if (__dg < __grouping.size() - 1)
+          ++__dg;
+      }
+      *__oe++ = __ct.widen(*__p);
+      ++__dc;
     }
-    if (__np == __ne)
-        __op = __oe;
-    else
-        __op = __ob + (__np - __nb);
+    std::reverse(__ob + (__nf - __nb), __oe);
+  }
+  if (__np == __ne)
+    __op = __oe;
+  else
+    __op = __ob + (__np - __nb);
 }
 
 template <class _CharT>
-void
-__num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
-                                           _CharT* __ob, _CharT*& __op, _CharT*& __oe,
-                                           const locale& __loc)
-{
-    const ctype<_CharT>&    __ct = std::use_facet<ctype<_CharT> >   (__loc);
-    const numpunct<_CharT>& __npt = std::use_facet<numpunct<_CharT> >(__loc);
-    string __grouping = __npt.grouping();
-    __oe = __ob;
-    char* __nf = __nb;
-    if (*__nf == '-' || *__nf == '+')
-        *__oe++ = __ct.widen(*__nf++);
-    char* __ns;
-    if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' ||
-                                               __nf[1] == 'X'))
-    {
-        *__oe++ = __ct.widen(*__nf++);
-        *__oe++ = __ct.widen(*__nf++);
-        for (__ns = __nf; __ns < __ne; ++__ns)
-            if (!isxdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
-                break;
+void __num_put<_CharT>::__widen_and_group_float(
+    char* __nb, char* __np, char* __ne, _CharT* __ob, _CharT*& __op, _CharT*& __oe, const locale& __loc) {
+  const ctype<_CharT>& __ct     = std::use_facet<ctype<_CharT> >(__loc);
+  const numpunct<_CharT>& __npt = std::use_facet<numpunct<_CharT> >(__loc);
+  string __grouping             = __npt.grouping();
+  __oe                          = __ob;
+  char* __nf                    = __nb;
+  if (*__nf == '-' || *__nf == '+')
+    *__oe++ = __ct.widen(*__nf++);
+  char* __ns;
+  if (__ne - __nf >= 2 && __nf[0] == '0' && (__nf[1] == 'x' || __nf[1] == 'X')) {
+    *__oe++ = __ct.widen(*__nf++);
+    *__oe++ = __ct.widen(*__nf++);
+    for (__ns = __nf; __ns < __ne; ++__ns)
+      if (!isxdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
+        break;
+  } else {
+    for (__ns = __nf; __ns < __ne; ++__ns)
+      if (!isdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
+        break;
+  }
+  if (__grouping.empty()) {
+    __ct.widen(__nf, __ns, __oe);
+    __oe += __ns - __nf;
+  } else {
+    std::reverse(__nf, __ns);
+    _CharT __thousands_sep = __npt.thousands_sep();
+    unsigned __dc          = 0;
+    unsigned __dg          = 0;
+    for (char* __p = __nf; __p < __ns; ++__p) {
+      if (__grouping[__dg] > 0 && __dc == static_cast<unsigned>(__grouping[__dg])) {
+        *__oe++ = __thousands_sep;
+        __dc    = 0;
+        if (__dg < __grouping.size() - 1)
+          ++__dg;
+      }
+      *__oe++ = __ct.widen(*__p);
+      ++__dc;
     }
-    else
-    {
-        for (__ns = __nf; __ns < __ne; ++__ns)
-            if (!isdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
-                break;
-    }
-    if (__grouping.empty())
-    {
-        __ct.widen(__nf, __ns, __oe);
-        __oe += __ns - __nf;
-    }
-    else
-    {
-        std::reverse(__nf, __ns);
-        _CharT __thousands_sep = __npt.thousands_sep();
-        unsigned __dc = 0;
-        unsigned __dg = 0;
-        for (char* __p = __nf; __p < __ns; ++__p)
-        {
-            if (__grouping[__dg] > 0 && __dc == static_cast<unsigned>(__grouping[__dg]))
-            {
-                *__oe++ = __thousands_sep;
-                __dc = 0;
-                if (__dg < __grouping.size()-1)
-                    ++__dg;
-            }
-            *__oe++ = __ct.widen(*__p);
-            ++__dc;
-        }
-        std::reverse(__ob + (__nf - __nb), __oe);
-    }
-    for (__nf = __ns; __nf < __ne; ++__nf)
-    {
-        if (*__nf == '.')
-        {
-            *__oe++ = __npt.decimal_point();
-            ++__nf;
-            break;
-        }
-        else
-            *__oe++ = __ct.widen(*__nf);
-    }
-    __ct.widen(__nf, __ne, __oe);
-    __oe += __ne - __nf;
-    if (__np == __ne)
-        __op = __oe;
-    else
-        __op = __ob + (__np - __nb);
+    std::reverse(__ob + (__nf - __nb), __oe);
+  }
+  for (__nf = __ns; __nf < __ne; ++__nf) {
+    if (*__nf == '.') {
+      *__oe++ = __npt.decimal_point();
+      ++__nf;
+      break;
+    } else
+      *__oe++ = __ct.widen(*__nf);
+  }
+  __ct.widen(__nf, __ne, __oe);
+  __oe += __ne - __nf;
+  if (__np == __ne)
+    __op = __oe;
+  else
+    __op = __ob + (__np - __nb);
 }
 
 extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template struct _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __num_put<wchar_t>;
-#endif
+#  endif
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TEMPLATE_VIS num_put
-    : public locale::facet,
-      private __num_put<_CharT>
-{
+class _LIBCPP_TEMPLATE_VIS num_put : public locale::facet, private __num_put<_CharT> {
 public:
-    typedef _CharT char_type;
-    typedef _OutputIterator iter_type;
+  typedef _CharT char_type;
+  typedef _OutputIterator iter_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit num_put(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit num_put(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
-                  bool __v) const
-    {
-        return do_put(__s, __iob, __fl, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, bool __v) const {
+    return do_put(__s, __iob, __fl, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
-                  long __v) const
-    {
-        return do_put(__s, __iob, __fl, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, long __v) const {
+    return do_put(__s, __iob, __fl, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
-                  long long __v) const
-    {
-        return do_put(__s, __iob, __fl, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, long long __v) const {
+    return do_put(__s, __iob, __fl, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
-                  unsigned long __v) const
-    {
-        return do_put(__s, __iob, __fl, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long __v) const {
+    return do_put(__s, __iob, __fl, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
-                  unsigned long long __v) const
-    {
-        return do_put(__s, __iob, __fl, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long long __v) const {
+    return do_put(__s, __iob, __fl, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
-                  double __v) const
-    {
-        return do_put(__s, __iob, __fl, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, double __v) const {
+    return do_put(__s, __iob, __fl, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
-                  long double __v) const
-    {
-        return do_put(__s, __iob, __fl, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, long double __v) const {
+    return do_put(__s, __iob, __fl, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
-                  const void* __v) const
-    {
-        return do_put(__s, __iob, __fl, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type put(iter_type __s, ios_base& __iob, char_type __fl, const void* __v) const {
+    return do_put(__s, __iob, __fl, __v);
+  }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~num_put() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~num_put() override {}
 
-    virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
-                             bool __v) const;
-    virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
-                             long __v) const;
-    virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
-                             long long __v) const;
-    virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
-                             unsigned long) const;
-    virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
-                             unsigned long long) const;
-    virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
-                             double __v) const;
-    virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
-                             long double __v) const;
-    virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl,
-                             const void* __v) const;
+  virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, bool __v) const;
+  virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, long __v) const;
+  virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, long long __v) const;
+  virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long) const;
+  virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long long) const;
+  virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, double __v) const;
+  virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, long double __v) const;
+  virtual iter_type do_put(iter_type __s, ios_base& __iob, char_type __fl, const void* __v) const;
 
-    template <class _Integral>
-    _LIBCPP_HIDE_FROM_ABI inline
-    _OutputIterator __do_put_integral(iter_type __s, ios_base& __iob,
-                                      char_type __fl, _Integral __v,
-                                      char const* __len) const;
+  template <class _Integral>
+  _LIBCPP_HIDE_FROM_ABI inline _OutputIterator
+  __do_put_integral(iter_type __s, ios_base& __iob, char_type __fl, _Integral __v, char const* __len) const;
 
-    template <class _Float>
-    _LIBCPP_HIDE_FROM_ABI inline
-    _OutputIterator __do_put_floating_point(iter_type __s, ios_base& __iob,
-                                            char_type __fl, _Float __v,
-                                            char const* __len) const;
+  template <class _Float>
+  _LIBCPP_HIDE_FROM_ABI inline _OutputIterator
+  __do_put_floating_point(iter_type __s, ios_base& __iob, char_type __fl, _Float __v, char const* __len) const;
 };
 
 template <class _CharT, class _OutputIterator>
-locale::id
-num_put<_CharT, _OutputIterator>::id;
+locale::id num_put<_CharT, _OutputIterator>::id;
 
 template <class _CharT, class _OutputIterator>
-_LIBCPP_HIDE_FROM_ABI
-_OutputIterator
-__pad_and_output(_OutputIterator __s,
-                 const _CharT* __ob, const _CharT* __op, const _CharT* __oe,
-                 ios_base& __iob, _CharT __fl)
-{
-    streamsize __sz = __oe - __ob;
-    streamsize __ns = __iob.width();
-    if (__ns > __sz)
-        __ns -= __sz;
-    else
-        __ns = 0;
-    for (;__ob < __op; ++__ob, ++__s)
-        *__s = *__ob;
-    for (; __ns; --__ns, ++__s)
-        *__s = __fl;
-    for (; __ob < __oe; ++__ob, ++__s)
-        *__s = *__ob;
-    __iob.width(0);
-    return __s;
+_LIBCPP_HIDE_FROM_ABI _OutputIterator __pad_and_output(
+    _OutputIterator __s, const _CharT* __ob, const _CharT* __op, const _CharT* __oe, ios_base& __iob, _CharT __fl) {
+  streamsize __sz = __oe - __ob;
+  streamsize __ns = __iob.width();
+  if (__ns > __sz)
+    __ns -= __sz;
+  else
+    __ns = 0;
+  for (; __ob < __op; ++__ob, ++__s)
+    *__s = *__ob;
+  for (; __ns; --__ns, ++__s)
+    *__s = __fl;
+  for (; __ob < __oe; ++__ob, ++__s)
+    *__s = *__ob;
+  __iob.width(0);
+  return __s;
 }
 
 template <class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI
-ostreambuf_iterator<_CharT, _Traits>
-__pad_and_output(ostreambuf_iterator<_CharT, _Traits> __s,
-                 const _CharT* __ob, const _CharT* __op, const _CharT* __oe,
-                 ios_base& __iob, _CharT __fl)
-{
-    if (__s.__sbuf_ == nullptr)
-        return __s;
-    streamsize __sz = __oe - __ob;
-    streamsize __ns = __iob.width();
-    if (__ns > __sz)
-        __ns -= __sz;
-    else
-        __ns = 0;
-    streamsize __np = __op - __ob;
-    if (__np > 0)
-    {
-        if (__s.__sbuf_->sputn(__ob, __np) != __np)
-        {
-            __s.__sbuf_ = nullptr;
-            return __s;
-        }
-    }
-    if (__ns > 0)
-    {
-        basic_string<_CharT, _Traits> __sp(__ns, __fl);
-        if (__s.__sbuf_->sputn(__sp.data(), __ns) != __ns)
-        {
-            __s.__sbuf_ = nullptr;
-            return __s;
-        }
-    }
-    __np = __oe - __op;
-    if (__np > 0)
-    {
-        if (__s.__sbuf_->sputn(__op, __np) != __np)
-        {
-            __s.__sbuf_ = nullptr;
-            return __s;
-        }
-    }
-    __iob.width(0);
+_LIBCPP_HIDE_FROM_ABI ostreambuf_iterator<_CharT, _Traits> __pad_and_output(
+    ostreambuf_iterator<_CharT, _Traits> __s,
+    const _CharT* __ob,
+    const _CharT* __op,
+    const _CharT* __oe,
+    ios_base& __iob,
+    _CharT __fl) {
+  if (__s.__sbuf_ == nullptr)
     return __s;
+  streamsize __sz = __oe - __ob;
+  streamsize __ns = __iob.width();
+  if (__ns > __sz)
+    __ns -= __sz;
+  else
+    __ns = 0;
+  streamsize __np = __op - __ob;
+  if (__np > 0) {
+    if (__s.__sbuf_->sputn(__ob, __np) != __np) {
+      __s.__sbuf_ = nullptr;
+      return __s;
+    }
+  }
+  if (__ns > 0) {
+    basic_string<_CharT, _Traits> __sp(__ns, __fl);
+    if (__s.__sbuf_->sputn(__sp.data(), __ns) != __ns) {
+      __s.__sbuf_ = nullptr;
+      return __s;
+    }
+  }
+  __np = __oe - __op;
+  if (__np > 0) {
+    if (__s.__sbuf_->sputn(__op, __np) != __np) {
+      __s.__sbuf_ = nullptr;
+      return __s;
+    }
+  }
+  __iob.width(0);
+  return __s;
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
-num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
-                                         char_type __fl, bool __v) const
-{
-    if ((__iob.flags() & ios_base::boolalpha) == 0)
-        return do_put(__s, __iob, __fl, (unsigned long)__v);
-    const numpunct<char_type>& __np = std::use_facet<numpunct<char_type> >(__iob.getloc());
-    typedef typename numpunct<char_type>::string_type string_type;
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    string_type __tmp(__v ? __np.truename() : __np.falsename());
-    string_type __nm = _VSTD::move(__tmp);
-#else
-    string_type __nm = __v ? __np.truename() : __np.falsename();
-#endif
-    for (typename string_type::iterator __i = __nm.begin(); __i != __nm.end(); ++__i, ++__s)
-        *__s = *__i;
-    return __s;
+num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, bool __v) const {
+  if ((__iob.flags() & ios_base::boolalpha) == 0)
+    return do_put(__s, __iob, __fl, (unsigned long)__v);
+  const numpunct<char_type>& __np = std::use_facet<numpunct<char_type> >(__iob.getloc());
+  typedef typename numpunct<char_type>::string_type string_type;
+  string_type __nm = __v ? __np.truename() : __np.falsename();
+  for (typename string_type::iterator __i = __nm.begin(); __i != __nm.end(); ++__i, ++__s)
+    *__s = *__i;
+  return __s;
 }
 
 template <class _CharT, class _OutputIterator>
 template <class _Integral>
-_LIBCPP_HIDE_FROM_ABI inline
-_OutputIterator
-num_put<_CharT, _OutputIterator>::__do_put_integral(iter_type __s, ios_base& __iob,
-                                                    char_type __fl, _Integral __v,
-                                                    char const* __len) const
-{
-    // Stage 1 - Get number in narrow char
-    char __fmt[8] = {'%', 0};
-    this->__format_int(__fmt+1, __len, is_signed<_Integral>::value, __iob.flags());
-    // Worst case is octal, with showbase enabled. Note that octal is always
-    // printed as an unsigned value.
-    using _Unsigned = typename make_unsigned<_Integral>::type;
-    _LIBCPP_CONSTEXPR const unsigned __nbuf
-        = (numeric_limits<_Unsigned>::digits / 3)        // 1 char per 3 bits
-        + ((numeric_limits<_Unsigned>::digits % 3) != 0) // round up
-        + 2; // base prefix + terminating null character
-    char __nar[__nbuf];
-    _LIBCPP_DIAGNOSTIC_PUSH
-    _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
-    _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
-    int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
-    _LIBCPP_DIAGNOSTIC_POP
-    char* __ne = __nar + __nc;
-    char* __np = this->__identify_padding(__nar, __ne, __iob);
-    // Stage 2 - Widen __nar while adding thousands separators
-    char_type __o[2*(__nbuf-1) - 1];
-    char_type* __op;  // pad here
-    char_type* __oe;  // end of output
-    this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
-    // [__o, __oe) contains thousands_sep'd wide number
-    // Stage 3 & 4
-    return std::__pad_and_output(__s, __o, __op, __oe, __iob, __fl);
+_LIBCPP_HIDE_FROM_ABI inline _OutputIterator num_put<_CharT, _OutputIterator>::__do_put_integral(
+    iter_type __s, ios_base& __iob, char_type __fl, _Integral __v, char const* __len) const {
+  // Stage 1 - Get number in narrow char
+  char __fmt[8] = {'%', 0};
+  this->__format_int(__fmt + 1, __len, is_signed<_Integral>::value, __iob.flags());
+  // Worst case is octal, with showbase enabled. Note that octal is always
+  // printed as an unsigned value.
+  using _Unsigned = typename make_unsigned<_Integral>::type;
+  _LIBCPP_CONSTEXPR const unsigned __nbuf =
+      (numeric_limits<_Unsigned>::digits / 3)          // 1 char per 3 bits
+      + ((numeric_limits<_Unsigned>::digits % 3) != 0) // round up
+      + 2;                                             // base prefix + terminating null character
+  char __nar[__nbuf];
+  _LIBCPP_DIAGNOSTIC_PUSH
+  _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
+  _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
+  int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, __fmt, __v);
+  _LIBCPP_DIAGNOSTIC_POP
+  char* __ne = __nar + __nc;
+  char* __np = this->__identify_padding(__nar, __ne, __iob);
+  // Stage 2 - Widen __nar while adding thousands separators
+  char_type __o[2 * (__nbuf - 1) - 1];
+  char_type* __op; // pad here
+  char_type* __oe; // end of output
+  this->__widen_and_group_int(__nar, __np, __ne, __o, __op, __oe, __iob.getloc());
+  // [__o, __oe) contains thousands_sep'd wide number
+  // Stage 3 & 4
+  return std::__pad_and_output(__s, __o, __op, __oe, __iob, __fl);
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
-num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
-                                         char_type __fl, long __v) const
-{
-    return this->__do_put_integral(__s, __iob, __fl, __v, "l");
+num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, long __v) const {
+  return this->__do_put_integral(__s, __iob, __fl, __v, "l");
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
-num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
-                                         char_type __fl, long long __v) const
-{
-    return this->__do_put_integral(__s, __iob, __fl, __v, "ll");
+num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, long long __v) const {
+  return this->__do_put_integral(__s, __iob, __fl, __v, "ll");
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
-num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
-                                         char_type __fl, unsigned long __v) const
-{
-    return this->__do_put_integral(__s, __iob, __fl, __v, "l");
+num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long __v) const {
+  return this->__do_put_integral(__s, __iob, __fl, __v, "l");
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
-num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
-                                         char_type __fl, unsigned long long __v) const
-{
-    return this->__do_put_integral(__s, __iob, __fl, __v, "ll");
+num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, unsigned long long __v) const {
+  return this->__do_put_integral(__s, __iob, __fl, __v, "ll");
 }
 
 template <class _CharT, class _OutputIterator>
 template <class _Float>
-_LIBCPP_HIDE_FROM_ABI inline
-_OutputIterator
-num_put<_CharT, _OutputIterator>::__do_put_floating_point(iter_type __s, ios_base& __iob,
-                                                          char_type __fl, _Float __v,
-                                                          char const* __len) const
-{
-    // Stage 1 - Get number in narrow char
-    char __fmt[8] = {'%', 0};
-    bool __specify_precision = this->__format_float(__fmt+1, __len, __iob.flags());
-    const unsigned __nbuf = 30;
-    char __nar[__nbuf];
-    char* __nb = __nar;
-    int __nc;
-    _LIBCPP_DIAGNOSTIC_PUSH
-    _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
-    _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
+_LIBCPP_HIDE_FROM_ABI inline _OutputIterator num_put<_CharT, _OutputIterator>::__do_put_floating_point(
+    iter_type __s, ios_base& __iob, char_type __fl, _Float __v, char const* __len) const {
+  // Stage 1 - Get number in narrow char
+  char __fmt[8]            = {'%', 0};
+  bool __specify_precision = this->__format_float(__fmt + 1, __len, __iob.flags());
+  const unsigned __nbuf    = 30;
+  char __nar[__nbuf];
+  char* __nb = __nar;
+  int __nc;
+  _LIBCPP_DIAGNOSTIC_PUSH
+  _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
+  _LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
+  if (__specify_precision)
+    __nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
+  else
+    __nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
+  unique_ptr<char, void (*)(void*)> __nbh(nullptr, free);
+  if (__nc > static_cast<int>(__nbuf - 1)) {
     if (__specify_precision)
-        __nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
-                                   (int)__iob.precision(), __v);
+      __nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
     else
-        __nc = __libcpp_snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-    unique_ptr<char, void(*)(void*)> __nbh(nullptr, free);
-    if (__nc > static_cast<int>(__nbuf-1))
-    {
-        if (__specify_precision)
-            __nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
-        else
-            __nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-        if (__nc == -1)
-            __throw_bad_alloc();
-        __nbh.reset(__nb);
-    }
-    _LIBCPP_DIAGNOSTIC_POP
-    char* __ne = __nb + __nc;
-    char* __np = this->__identify_padding(__nb, __ne, __iob);
-    // Stage 2 - Widen __nar while adding thousands separators
-    char_type __o[2*(__nbuf-1) - 1];
-    char_type* __ob = __o;
-    unique_ptr<char_type, void(*)(void*)> __obh(0, free);
-    if (__nb != __nar)
-    {
-        __ob = (char_type*)malloc(2*static_cast<size_t>(__nc)*sizeof(char_type));
-        if (__ob == 0)
-            __throw_bad_alloc();
-        __obh.reset(__ob);
-    }
-    char_type* __op;  // pad here
-    char_type* __oe;  // end of output
-    this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc());
-    // [__o, __oe) contains thousands_sep'd wide number
-    // Stage 3 & 4
-    __s = std::__pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
-    return __s;
+      __nc = __libcpp_asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
+    if (__nc == -1)
+      __throw_bad_alloc();
+    __nbh.reset(__nb);
+  }
+  _LIBCPP_DIAGNOSTIC_POP
+  char* __ne = __nb + __nc;
+  char* __np = this->__identify_padding(__nb, __ne, __iob);
+  // Stage 2 - Widen __nar while adding thousands separators
+  char_type __o[2 * (__nbuf - 1) - 1];
+  char_type* __ob = __o;
+  unique_ptr<char_type, void (*)(void*)> __obh(0, free);
+  if (__nb != __nar) {
+    __ob = (char_type*)malloc(2 * static_cast<size_t>(__nc) * sizeof(char_type));
+    if (__ob == 0)
+      __throw_bad_alloc();
+    __obh.reset(__ob);
+  }
+  char_type* __op; // pad here
+  char_type* __oe; // end of output
+  this->__widen_and_group_float(__nb, __np, __ne, __ob, __op, __oe, __iob.getloc());
+  // [__o, __oe) contains thousands_sep'd wide number
+  // Stage 3 & 4
+  __s = std::__pad_and_output(__s, __ob, __op, __oe, __iob, __fl);
+  return __s;
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
-num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
-                                         char_type __fl, double __v) const
-{
-    return this->__do_put_floating_point(__s, __iob, __fl, __v, "");
+num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, double __v) const {
+  return this->__do_put_floating_point(__s, __iob, __fl, __v, "");
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
-num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
-                                         char_type __fl, long double __v) const
-{
-    return this->__do_put_floating_point(__s, __iob, __fl, __v, "L");
+num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, long double __v) const {
+  return this->__do_put_floating_point(__s, __iob, __fl, __v, "L");
 }
 
 template <class _CharT, class _OutputIterator>
 _OutputIterator
-num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
-                                         char_type __fl, const void* __v) const
-{
-    // Stage 1 - Get pointer in narrow char
-    const unsigned __nbuf = 20;
-    char __nar[__nbuf];
-    int __nc = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, "%p", __v);
-    char* __ne = __nar + __nc;
-    char* __np = this->__identify_padding(__nar, __ne, __iob);
-    // Stage 2 - Widen __nar
-    char_type __o[2*(__nbuf-1) - 1];
-    char_type* __op;  // pad here
-    char_type* __oe;  // end of output
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
-    __ct.widen(__nar, __ne, __o);
-    __oe = __o + (__ne - __nar);
-    if (__np == __ne)
-        __op = __oe;
-    else
-        __op = __o + (__np - __nar);
-    // [__o, __oe) contains wide number
-    // Stage 3 & 4
-    return std::__pad_and_output(__s, __o, __op, __oe, __iob, __fl);
+num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_type __fl, const void* __v) const {
+  // Stage 1 - Get pointer in narrow char
+  const unsigned __nbuf = 20;
+  char __nar[__nbuf];
+  int __nc   = __libcpp_snprintf_l(__nar, sizeof(__nar), _LIBCPP_GET_C_LOCALE, "%p", __v);
+  char* __ne = __nar + __nc;
+  char* __np = this->__identify_padding(__nar, __ne, __iob);
+  // Stage 2 - Widen __nar
+  char_type __o[2 * (__nbuf - 1) - 1];
+  char_type* __op; // pad here
+  char_type* __oe; // end of output
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
+  __ct.widen(__nar, __ne, __o);
+  __oe = __o + (__ne - __nar);
+  if (__np == __ne)
+    __op = __oe;
+  else
+    __op = __o + (__np - __nar);
+  // [__o, __oe) contains wide number
+  // Stage 3 & 4
+  return std::__pad_and_output(__s, __o, __op, __oe, __iob, __fl);
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_put<wchar_t>;
-#endif
+#  endif
 
 template <class _CharT, class _InputIterator>
-_LIBCPP_HIDE_FROM_ABI
-int
-__get_up_to_n_digits(_InputIterator& __b, _InputIterator __e,
-                     ios_base::iostate& __err, const ctype<_CharT>& __ct, int __n)
-{
-    // Precondition:  __n >= 1
-    if (__b == __e)
-    {
-        __err |= ios_base::eofbit | ios_base::failbit;
-        return 0;
-    }
-    // get first digit
-    _CharT __c = *__b;
+_LIBCPP_HIDE_FROM_ABI int __get_up_to_n_digits(
+    _InputIterator& __b, _InputIterator __e, ios_base::iostate& __err, const ctype<_CharT>& __ct, int __n) {
+  // Precondition:  __n >= 1
+  if (__b == __e) {
+    __err |= ios_base::eofbit | ios_base::failbit;
+    return 0;
+  }
+  // get first digit
+  _CharT __c = *__b;
+  if (!__ct.is(ctype_base::digit, __c)) {
+    __err |= ios_base::failbit;
+    return 0;
+  }
+  int __r = __ct.narrow(__c, 0) - '0';
+  for (++__b, (void)--__n; __b != __e && __n > 0; ++__b, (void)--__n) {
+    // get next digit
+    __c = *__b;
     if (!__ct.is(ctype_base::digit, __c))
-    {
-        __err |= ios_base::failbit;
-        return 0;
-    }
-    int __r = __ct.narrow(__c, 0) - '0';
-    for (++__b, (void) --__n; __b != __e && __n > 0; ++__b, (void) --__n)
-    {
-        // get next digit
-        __c = *__b;
-        if (!__ct.is(ctype_base::digit, __c))
-            return __r;
-        __r = __r * 10 + __ct.narrow(__c, 0) - '0';
-    }
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __r;
+      return __r;
+    __r = __r * 10 + __ct.narrow(__c, 0) - '0';
+  }
+  if (__b == __e)
+    __err |= ios_base::eofbit;
+  return __r;
 }
 
-class _LIBCPP_TYPE_VIS time_base
-{
+class _LIBCPP_EXPORTED_FROM_ABI time_base {
 public:
-    enum dateorder {no_order, dmy, mdy, ymd, ydm};
+  enum dateorder { no_order, dmy, mdy, ymd, ydm };
 };
 
 template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __time_get_c_storage
-{
+class _LIBCPP_TEMPLATE_VIS __time_get_c_storage {
 protected:
-    typedef basic_string<_CharT> string_type;
+  typedef basic_string<_CharT> string_type;
 
-    virtual const string_type* __weeks() const;
-    virtual const string_type* __months() const;
-    virtual const string_type* __am_pm() const;
-    virtual const string_type& __c() const;
-    virtual const string_type& __r() const;
-    virtual const string_type& __x() const;
-    virtual const string_type& __X() const;
+  virtual const string_type* __weeks() const;
+  virtual const string_type* __months() const;
+  virtual const string_type* __am_pm() const;
+  virtual const string_type& __c() const;
+  virtual const string_type& __r() const;
+  virtual const string_type& __x() const;
+  virtual const string_type& __X() const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~__time_get_c_storage() {}
+  _LIBCPP_HIDE_FROM_ABI ~__time_get_c_storage() {}
 };
 
-template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__weeks() const;
-template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__months() const;
-template <> _LIBCPP_FUNC_VIS const string* __time_get_c_storage<char>::__am_pm() const;
-template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__c() const;
-template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__r() const;
-template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__x() const;
-template <> _LIBCPP_FUNC_VIS const string& __time_get_c_storage<char>::__X() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const string* __time_get_c_storage<char>::__weeks() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const string* __time_get_c_storage<char>::__months() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const string* __time_get_c_storage<char>::__am_pm() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const string& __time_get_c_storage<char>::__c() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const string& __time_get_c_storage<char>::__r() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const string& __time_get_c_storage<char>::__x() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const string& __time_get_c_storage<char>::__X() const;
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__weeks() const;
-template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__months() const;
-template <> _LIBCPP_FUNC_VIS const wstring* __time_get_c_storage<wchar_t>::__am_pm() const;
-template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__c() const;
-template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__r() const;
-template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__x() const;
-template <> _LIBCPP_FUNC_VIS const wstring& __time_get_c_storage<wchar_t>::__X() const;
-#endif
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const wstring* __time_get_c_storage<wchar_t>::__weeks() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const wstring* __time_get_c_storage<wchar_t>::__months() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const wstring* __time_get_c_storage<wchar_t>::__am_pm() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const wstring& __time_get_c_storage<wchar_t>::__c() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const wstring& __time_get_c_storage<wchar_t>::__r() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const wstring& __time_get_c_storage<wchar_t>::__x() const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI const wstring& __time_get_c_storage<wchar_t>::__X() const;
+#  endif
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TEMPLATE_VIS time_get
-    : public locale::facet,
-      public time_base,
-      private __time_get_c_storage<_CharT>
-{
+class _LIBCPP_TEMPLATE_VIS time_get : public locale::facet, public time_base, private __time_get_c_storage<_CharT> {
 public:
-    typedef _CharT                  char_type;
-    typedef _InputIterator          iter_type;
-    typedef time_base::dateorder    dateorder;
-    typedef basic_string<char_type> string_type;
+  typedef _CharT char_type;
+  typedef _InputIterator iter_type;
+  typedef time_base::dateorder dateorder;
+  typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit time_get(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit time_get(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    dateorder date_order() const
-    {
-        return this->do_date_order();
-    }
+  _LIBCPP_HIDE_FROM_ABI dateorder date_order() const { return this->do_date_order(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get_time(iter_type __b, iter_type __e, ios_base& __iob,
-                       ios_base::iostate& __err, tm* __tm) const
-    {
-        return do_get_time(__b, __e, __iob, __err, __tm);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get_time(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
+    return do_get_time(__b, __e, __iob, __err, __tm);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get_date(iter_type __b, iter_type __e, ios_base& __iob,
-                       ios_base::iostate& __err, tm* __tm) const
-    {
-        return do_get_date(__b, __e, __iob, __err, __tm);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get_date(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
+    return do_get_date(__b, __e, __iob, __err, __tm);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get_weekday(iter_type __b, iter_type __e, ios_base& __iob,
-                          ios_base::iostate& __err, tm* __tm) const
-    {
-        return do_get_weekday(__b, __e, __iob, __err, __tm);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get_weekday(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
+    return do_get_weekday(__b, __e, __iob, __err, __tm);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get_monthname(iter_type __b, iter_type __e, ios_base& __iob,
-                            ios_base::iostate& __err, tm* __tm) const
-    {
-        return do_get_monthname(__b, __e, __iob, __err, __tm);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get_monthname(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
+    return do_get_monthname(__b, __e, __iob, __err, __tm);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get_year(iter_type __b, iter_type __e, ios_base& __iob,
-                       ios_base::iostate& __err, tm* __tm) const
-    {
-        return do_get_year(__b, __e, __iob, __err, __tm);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get_year(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
+    return do_get_year(__b, __e, __iob, __err, __tm);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, tm *__tm,
-                  char __fmt, char __mod = 0) const
-    {
-        return do_get(__b, __e, __iob, __err, __tm, __fmt, __mod);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm, char __fmt, char __mod = 0)
+      const {
+    return do_get(__b, __e, __iob, __err, __tm, __fmt, __mod);
+  }
 
-    iter_type get(iter_type __b, iter_type __e, ios_base& __iob,
-                  ios_base::iostate& __err, tm* __tm,
-                  const char_type* __fmtb, const char_type* __fmte) const;
+  iter_type
+  get(iter_type __b,
+      iter_type __e,
+      ios_base& __iob,
+      ios_base::iostate& __err,
+      tm* __tm,
+      const char_type* __fmtb,
+      const char_type* __fmte) const;
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_get() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_get() override {}
+
+  virtual dateorder do_date_order() const;
+  virtual iter_type
+  do_get_time(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const;
+  virtual iter_type
+  do_get_date(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const;
+  virtual iter_type
+  do_get_weekday(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const;
+  virtual iter_type
+  do_get_monthname(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const;
+  virtual iter_type
+  do_get_year(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const;
+  virtual iter_type do_get(
+      iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm, char __fmt, char __mod) const;
 
-    virtual dateorder do_date_order() const;
-    virtual iter_type do_get_time(iter_type __b, iter_type __e, ios_base& __iob,
-                                  ios_base::iostate& __err, tm* __tm) const;
-    virtual iter_type do_get_date(iter_type __b, iter_type __e, ios_base& __iob,
-                                  ios_base::iostate& __err, tm* __tm) const;
-    virtual iter_type do_get_weekday(iter_type __b, iter_type __e, ios_base& __iob,
-                                     ios_base::iostate& __err, tm* __tm) const;
-    virtual iter_type do_get_monthname(iter_type __b, iter_type __e, ios_base& __iob,
-                                       ios_base::iostate& __err, tm* __tm) const;
-    virtual iter_type do_get_year(iter_type __b, iter_type __e, ios_base& __iob,
-                                  ios_base::iostate& __err, tm* __tm) const;
-    virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob,
-                             ios_base::iostate& __err, tm* __tm,
-                             char __fmt, char __mod) const;
 private:
-    void __get_white_space(iter_type& __b, iter_type __e,
-                           ios_base::iostate& __err, const ctype<char_type>& __ct) const;
-    void __get_percent(iter_type& __b, iter_type __e, ios_base::iostate& __err,
-                       const ctype<char_type>& __ct) const;
+  void __get_white_space(iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void __get_percent(iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
 
-    void __get_weekdayname(int& __m,
-                           iter_type& __b, iter_type __e,
-                           ios_base::iostate& __err,
-                           const ctype<char_type>& __ct) const;
-    void __get_monthname(int& __m,
-                         iter_type& __b, iter_type __e,
-                         ios_base::iostate& __err,
-                         const ctype<char_type>& __ct) const;
-    void __get_day(int& __d,
-                   iter_type& __b, iter_type __e,
-                   ios_base::iostate& __err,
-                   const ctype<char_type>& __ct) const;
-    void __get_month(int& __m,
-                     iter_type& __b, iter_type __e,
-                     ios_base::iostate& __err,
-                     const ctype<char_type>& __ct) const;
-    void __get_year(int& __y,
-                   iter_type& __b, iter_type __e,
-                   ios_base::iostate& __err,
-                   const ctype<char_type>& __ct) const;
-    void __get_year4(int& __y,
-                    iter_type& __b, iter_type __e,
-                    ios_base::iostate& __err,
-                    const ctype<char_type>& __ct) const;
-    void __get_hour(int& __d,
-                    iter_type& __b, iter_type __e,
-                    ios_base::iostate& __err,
-                    const ctype<char_type>& __ct) const;
-    void __get_12_hour(int& __h,
-                       iter_type& __b, iter_type __e,
-                       ios_base::iostate& __err,
-                       const ctype<char_type>& __ct) const;
-    void __get_am_pm(int& __h,
-                     iter_type& __b, iter_type __e,
-                     ios_base::iostate& __err,
-                     const ctype<char_type>& __ct) const;
-    void __get_minute(int& __m,
-                      iter_type& __b, iter_type __e,
-                      ios_base::iostate& __err,
-                      const ctype<char_type>& __ct) const;
-    void __get_second(int& __s,
-                      iter_type& __b, iter_type __e,
-                      ios_base::iostate& __err,
-                      const ctype<char_type>& __ct) const;
-    void __get_weekday(int& __w,
-                       iter_type& __b, iter_type __e,
-                       ios_base::iostate& __err,
-                       const ctype<char_type>& __ct) const;
-    void __get_day_year_num(int& __w,
-                            iter_type& __b, iter_type __e,
-                            ios_base::iostate& __err,
-                            const ctype<char_type>& __ct) const;
+  void __get_weekdayname(
+      int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void __get_monthname(
+      int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void __get_day(int& __d, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void
+  __get_month(int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void
+  __get_year(int& __y, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void
+  __get_year4(int& __y, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void
+  __get_hour(int& __d, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void
+  __get_12_hour(int& __h, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void
+  __get_am_pm(int& __h, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void
+  __get_minute(int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void
+  __get_second(int& __s, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void
+  __get_weekday(int& __w, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
+  void __get_day_year_num(
+      int& __w, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const;
 };
 
 template <class _CharT, class _InputIterator>
-locale::id
-time_get<_CharT, _InputIterator>::id;
+locale::id time_get<_CharT, _InputIterator>::id;
 
 // time_get primitives
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_weekdayname(int& __w,
-                                                    iter_type& __b, iter_type __e,
-                                                    ios_base::iostate& __err,
-                                                    const ctype<char_type>& __ct) const
-{
-    // Note:  ignoring case comes from the POSIX strptime spec
-    const string_type* __wk = this->__weeks();
-    ptrdiff_t __i = _VSTD::__scan_keyword(__b, __e, __wk, __wk+14, __ct, __err, false) - __wk;
-    if (__i < 14)
-        __w = __i % 7;
+void time_get<_CharT, _InputIterator>::__get_weekdayname(
+    int& __w, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  // Note:  ignoring case comes from the POSIX strptime spec
+  const string_type* __wk = this->__weeks();
+  ptrdiff_t __i           = std::__scan_keyword(__b, __e, __wk, __wk + 14, __ct, __err, false) - __wk;
+  if (__i < 14)
+    __w = __i % 7;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_monthname(int& __m,
-                                                  iter_type& __b, iter_type __e,
-                                                  ios_base::iostate& __err,
-                                                  const ctype<char_type>& __ct) const
-{
-    // Note:  ignoring case comes from the POSIX strptime spec
-    const string_type* __month = this->__months();
-    ptrdiff_t __i = _VSTD::__scan_keyword(__b, __e, __month, __month+24, __ct, __err, false) - __month;
-    if (__i < 24)
-        __m = __i % 12;
+void time_get<_CharT, _InputIterator>::__get_monthname(
+    int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  // Note:  ignoring case comes from the POSIX strptime spec
+  const string_type* __month = this->__months();
+  ptrdiff_t __i              = std::__scan_keyword(__b, __e, __month, __month + 24, __ct, __err, false) - __month;
+  if (__i < 24)
+    __m = __i % 12;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_day(int& __d,
-                                            iter_type& __b, iter_type __e,
-                                            ios_base::iostate& __err,
-                                            const ctype<char_type>& __ct) const
-{
-    int __t = _VSTD::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
-    if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 31)
-        __d = __t;
-    else
-        __err |= ios_base::failbit;
+void time_get<_CharT, _InputIterator>::__get_day(
+    int& __d, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
+  if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 31)
+    __d = __t;
+  else
+    __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_month(int& __m,
-                                              iter_type& __b, iter_type __e,
-                                              ios_base::iostate& __err,
-                                              const ctype<char_type>& __ct) const
-{
-    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2) - 1;
-    if (!(__err & ios_base::failbit) && 0 <= __t && __t <= 11)
-        __m = __t;
-    else
-        __err |= ios_base::failbit;
+void time_get<_CharT, _InputIterator>::__get_month(
+    int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2) - 1;
+  if (!(__err & ios_base::failbit) && 0 <= __t && __t <= 11)
+    __m = __t;
+  else
+    __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_year(int& __y,
-                                             iter_type& __b, iter_type __e,
-                                             ios_base::iostate& __err,
-                                             const ctype<char_type>& __ct) const
-{
-    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 4);
-    if (!(__err & ios_base::failbit))
-    {
-        if (__t < 69)
-            __t += 2000;
-        else if (69 <= __t && __t <= 99)
-            __t += 1900;
-        __y = __t - 1900;
-    }
+void time_get<_CharT, _InputIterator>::__get_year(
+    int& __y, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 4);
+  if (!(__err & ios_base::failbit)) {
+    if (__t < 69)
+      __t += 2000;
+    else if (69 <= __t && __t <= 99)
+      __t += 1900;
+    __y = __t - 1900;
+  }
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_year4(int& __y,
-                                              iter_type& __b, iter_type __e,
-                                              ios_base::iostate& __err,
-                                              const ctype<char_type>& __ct) const
-{
-    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 4);
-    if (!(__err & ios_base::failbit))
-        __y = __t - 1900;
+void time_get<_CharT, _InputIterator>::__get_year4(
+    int& __y, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 4);
+  if (!(__err & ios_base::failbit))
+    __y = __t - 1900;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_hour(int& __h,
-                                             iter_type& __b, iter_type __e,
-                                             ios_base::iostate& __err,
-                                             const ctype<char_type>& __ct) const
-{
-    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
-    if (!(__err & ios_base::failbit) && __t <= 23)
-        __h = __t;
-    else
-        __err |= ios_base::failbit;
+void time_get<_CharT, _InputIterator>::__get_hour(
+    int& __h, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
+  if (!(__err & ios_base::failbit) && __t <= 23)
+    __h = __t;
+  else
+    __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_12_hour(int& __h,
-                                                iter_type& __b, iter_type __e,
-                                                ios_base::iostate& __err,
-                                                const ctype<char_type>& __ct) const
-{
-    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
-    if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 12)
-        __h = __t;
-    else
-        __err |= ios_base::failbit;
+void time_get<_CharT, _InputIterator>::__get_12_hour(
+    int& __h, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
+  if (!(__err & ios_base::failbit) && 1 <= __t && __t <= 12)
+    __h = __t;
+  else
+    __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_minute(int& __m,
-                                               iter_type& __b, iter_type __e,
-                                               ios_base::iostate& __err,
-                                               const ctype<char_type>& __ct) const
-{
-    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
-    if (!(__err & ios_base::failbit) && __t <= 59)
-        __m = __t;
-    else
-        __err |= ios_base::failbit;
+void time_get<_CharT, _InputIterator>::__get_minute(
+    int& __m, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
+  if (!(__err & ios_base::failbit) && __t <= 59)
+    __m = __t;
+  else
+    __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_second(int& __s,
-                                               iter_type& __b, iter_type __e,
-                                               ios_base::iostate& __err,
-                                               const ctype<char_type>& __ct) const
-{
-    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
-    if (!(__err & ios_base::failbit) && __t <= 60)
-        __s = __t;
-    else
-        __err |= ios_base::failbit;
+void time_get<_CharT, _InputIterator>::__get_second(
+    int& __s, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 2);
+  if (!(__err & ios_base::failbit) && __t <= 60)
+    __s = __t;
+  else
+    __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_weekday(int& __w,
-                                                iter_type& __b, iter_type __e,
-                                                ios_base::iostate& __err,
-                                                const ctype<char_type>& __ct) const
-{
-    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 1);
-    if (!(__err & ios_base::failbit) && __t <= 6)
-        __w = __t;
-    else
-        __err |= ios_base::failbit;
+void time_get<_CharT, _InputIterator>::__get_weekday(
+    int& __w, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 1);
+  if (!(__err & ios_base::failbit) && __t <= 6)
+    __w = __t;
+  else
+    __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_day_year_num(int& __d,
-                                                     iter_type& __b, iter_type __e,
-                                                     ios_base::iostate& __err,
-                                                     const ctype<char_type>& __ct) const
-{
-    int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 3);
-    if (!(__err & ios_base::failbit) && __t <= 365)
-        __d = __t;
-    else
-        __err |= ios_base::failbit;
+void time_get<_CharT, _InputIterator>::__get_day_year_num(
+    int& __d, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  int __t = std::__get_up_to_n_digits(__b, __e, __err, __ct, 3);
+  if (!(__err & ios_base::failbit) && __t <= 365)
+    __d = __t;
+  else
+    __err |= ios_base::failbit;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_white_space(iter_type& __b, iter_type __e,
-                                                    ios_base::iostate& __err,
-                                                    const ctype<char_type>& __ct) const
-{
-    for (; __b != __e && __ct.is(ctype_base::space, *__b); ++__b)
-        ;
-    if (__b == __e)
-        __err |= ios_base::eofbit;
+void time_get<_CharT, _InputIterator>::__get_white_space(
+    iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  for (; __b != __e && __ct.is(ctype_base::space, *__b); ++__b)
+    ;
+  if (__b == __e)
+    __err |= ios_base::eofbit;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_am_pm(int& __h,
-                                              iter_type& __b, iter_type __e,
-                                              ios_base::iostate& __err,
-                                              const ctype<char_type>& __ct) const
-{
-    const string_type* __ap = this->__am_pm();
-    if (__ap[0].size() + __ap[1].size() == 0)
-    {
-        __err |= ios_base::failbit;
-        return;
-    }
-    ptrdiff_t __i = _VSTD::__scan_keyword(__b, __e, __ap, __ap+2, __ct, __err, false) - __ap;
-    if (__i == 0 && __h == 12)
-        __h = 0;
-    else if (__i == 1 && __h < 12)
-        __h += 12;
+void time_get<_CharT, _InputIterator>::__get_am_pm(
+    int& __h, iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  const string_type* __ap = this->__am_pm();
+  if (__ap[0].size() + __ap[1].size() == 0) {
+    __err |= ios_base::failbit;
+    return;
+  }
+  ptrdiff_t __i = std::__scan_keyword(__b, __e, __ap, __ap + 2, __ct, __err, false) - __ap;
+  if (__i == 0 && __h == 12)
+    __h = 0;
+  else if (__i == 1 && __h < 12)
+    __h += 12;
 }
 
 template <class _CharT, class _InputIterator>
-void
-time_get<_CharT, _InputIterator>::__get_percent(iter_type& __b, iter_type __e,
-                                                ios_base::iostate& __err,
-                                                const ctype<char_type>& __ct) const
-{
-    if (__b == __e)
-    {
-        __err |= ios_base::eofbit | ios_base::failbit;
-        return;
-    }
-    if (__ct.narrow(*__b, 0) != '%')
-        __err |= ios_base::failbit;
-    else if(++__b == __e)
-        __err |= ios_base::eofbit;
+void time_get<_CharT, _InputIterator>::__get_percent(
+    iter_type& __b, iter_type __e, ios_base::iostate& __err, const ctype<char_type>& __ct) const {
+  if (__b == __e) {
+    __err |= ios_base::eofbit | ios_base::failbit;
+    return;
+  }
+  if (__ct.narrow(*__b, 0) != '%')
+    __err |= ios_base::failbit;
+  else if (++__b == __e)
+    __err |= ios_base::eofbit;
 }
 
 // time_get end primitives
 
 template <class _CharT, class _InputIterator>
-_InputIterator
-time_get<_CharT, _InputIterator>::get(iter_type __b, iter_type __e,
-                                      ios_base& __iob,
-                                      ios_base::iostate& __err, tm* __tm,
-                                      const char_type* __fmtb, const char_type* __fmte) const
-{
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
-    __err = ios_base::goodbit;
-    while (__fmtb != __fmte && __err == ios_base::goodbit)
-    {
-        if (__b == __e)
-        {
-            __err = ios_base::failbit;
-            break;
-        }
-        if (__ct.narrow(*__fmtb, 0) == '%')
-        {
-            if (++__fmtb == __fmte)
-            {
-                __err = ios_base::failbit;
-                break;
-            }
-            char __cmd = __ct.narrow(*__fmtb, 0);
-            char __opt = '\0';
-            if (__cmd == 'E' || __cmd == '0')
-            {
-                if (++__fmtb == __fmte)
-                {
-                    __err = ios_base::failbit;
-                    break;
-                }
-                __opt = __cmd;
-                __cmd = __ct.narrow(*__fmtb, 0);
-            }
-            __b = do_get(__b, __e, __iob, __err, __tm, __cmd, __opt);
-            ++__fmtb;
-        }
-        else if (__ct.is(ctype_base::space, *__fmtb))
-        {
-            for (++__fmtb; __fmtb != __fmte && __ct.is(ctype_base::space, *__fmtb); ++__fmtb)
-                ;
-            for (        ;    __b != __e    && __ct.is(ctype_base::space, *__b);    ++__b)
-                ;
-        }
-        else if (__ct.toupper(*__b) == __ct.toupper(*__fmtb))
-        {
-            ++__b;
-            ++__fmtb;
-        }
-        else
-            __err = ios_base::failbit;
+_InputIterator time_get<_CharT, _InputIterator>::get(
+    iter_type __b,
+    iter_type __e,
+    ios_base& __iob,
+    ios_base::iostate& __err,
+    tm* __tm,
+    const char_type* __fmtb,
+    const char_type* __fmte) const {
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
+  __err                        = ios_base::goodbit;
+  while (__fmtb != __fmte && __err == ios_base::goodbit) {
+    if (__b == __e) {
+      __err = ios_base::failbit;
+      break;
     }
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
+    if (__ct.narrow(*__fmtb, 0) == '%') {
+      if (++__fmtb == __fmte) {
+        __err = ios_base::failbit;
+        break;
+      }
+      char __cmd = __ct.narrow(*__fmtb, 0);
+      char __opt = '\0';
+      if (__cmd == 'E' || __cmd == '0') {
+        if (++__fmtb == __fmte) {
+          __err = ios_base::failbit;
+          break;
+        }
+        __opt = __cmd;
+        __cmd = __ct.narrow(*__fmtb, 0);
+      }
+      __b = do_get(__b, __e, __iob, __err, __tm, __cmd, __opt);
+      ++__fmtb;
+    } else if (__ct.is(ctype_base::space, *__fmtb)) {
+      for (++__fmtb; __fmtb != __fmte && __ct.is(ctype_base::space, *__fmtb); ++__fmtb)
+        ;
+      for (; __b != __e && __ct.is(ctype_base::space, *__b); ++__b)
+        ;
+    } else if (__ct.toupper(*__b) == __ct.toupper(*__fmtb)) {
+      ++__b;
+      ++__fmtb;
+    } else
+      __err = ios_base::failbit;
+  }
+  if (__b == __e)
+    __err |= ios_base::eofbit;
+  return __b;
 }
 
 template <class _CharT, class _InputIterator>
-typename time_get<_CharT, _InputIterator>::dateorder
-time_get<_CharT, _InputIterator>::do_date_order() const
-{
-    return mdy;
+typename time_get<_CharT, _InputIterator>::dateorder time_get<_CharT, _InputIterator>::do_date_order() const {
+  return mdy;
 }
 
 template <class _CharT, class _InputIterator>
-_InputIterator
-time_get<_CharT, _InputIterator>::do_get_time(iter_type __b, iter_type __e,
-                                              ios_base& __iob,
-                                              ios_base::iostate& __err,
-                                              tm* __tm) const
-{
-    const char_type __fmt[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'};
-    return get(__b, __e, __iob, __err, __tm, __fmt, __fmt + sizeof(__fmt)/sizeof(__fmt[0]));
+_InputIterator time_get<_CharT, _InputIterator>::do_get_time(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
+  const char_type __fmt[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'};
+  return get(__b, __e, __iob, __err, __tm, __fmt, __fmt + sizeof(__fmt) / sizeof(__fmt[0]));
 }
 
 template <class _CharT, class _InputIterator>
-_InputIterator
-time_get<_CharT, _InputIterator>::do_get_date(iter_type __b, iter_type __e,
-                                              ios_base& __iob,
-                                              ios_base::iostate& __err,
-                                              tm* __tm) const
-{
-    const string_type& __fmt = this->__x();
-    return get(__b, __e, __iob, __err, __tm, __fmt.data(), __fmt.data() + __fmt.size());
+_InputIterator time_get<_CharT, _InputIterator>::do_get_date(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
+  const string_type& __fmt = this->__x();
+  return get(__b, __e, __iob, __err, __tm, __fmt.data(), __fmt.data() + __fmt.size());
 }
 
 template <class _CharT, class _InputIterator>
-_InputIterator
-time_get<_CharT, _InputIterator>::do_get_weekday(iter_type __b, iter_type __e,
-                                                 ios_base& __iob,
-                                                 ios_base::iostate& __err,
-                                                 tm* __tm) const
-{
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
+_InputIterator time_get<_CharT, _InputIterator>::do_get_weekday(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
+  __get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
+  return __b;
+}
+
+template <class _CharT, class _InputIterator>
+_InputIterator time_get<_CharT, _InputIterator>::do_get_monthname(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
+  __get_monthname(__tm->tm_mon, __b, __e, __err, __ct);
+  return __b;
+}
+
+template <class _CharT, class _InputIterator>
+_InputIterator time_get<_CharT, _InputIterator>::do_get_year(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm) const {
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
+  __get_year(__tm->tm_year, __b, __e, __err, __ct);
+  return __b;
+}
+
+template <class _CharT, class _InputIterator>
+_InputIterator time_get<_CharT, _InputIterator>::do_get(
+    iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, tm* __tm, char __fmt, char) const {
+  __err                        = ios_base::goodbit;
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
+  switch (__fmt) {
+  case 'a':
+  case 'A':
     __get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
-    return __b;
-}
-
-template <class _CharT, class _InputIterator>
-_InputIterator
-time_get<_CharT, _InputIterator>::do_get_monthname(iter_type __b, iter_type __e,
-                                                   ios_base& __iob,
-                                                   ios_base::iostate& __err,
-                                                   tm* __tm) const
-{
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
+    break;
+  case 'b':
+  case 'B':
+  case 'h':
     __get_monthname(__tm->tm_mon, __b, __e, __err, __ct);
-    return __b;
-}
-
-template <class _CharT, class _InputIterator>
-_InputIterator
-time_get<_CharT, _InputIterator>::do_get_year(iter_type __b, iter_type __e,
-                                              ios_base& __iob,
-                                              ios_base::iostate& __err,
-                                              tm* __tm) const
-{
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
+    break;
+  case 'c': {
+    const string_type& __fm = this->__c();
+    __b                     = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size());
+  } break;
+  case 'd':
+  case 'e':
+    __get_day(__tm->tm_mday, __b, __e, __err, __ct);
+    break;
+  case 'D': {
+    const char_type __fm[] = {'%', 'm', '/', '%', 'd', '/', '%', 'y'};
+    __b                    = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm) / sizeof(__fm[0]));
+  } break;
+  case 'F': {
+    const char_type __fm[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd'};
+    __b                    = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm) / sizeof(__fm[0]));
+  } break;
+  case 'H':
+    __get_hour(__tm->tm_hour, __b, __e, __err, __ct);
+    break;
+  case 'I':
+    __get_12_hour(__tm->tm_hour, __b, __e, __err, __ct);
+    break;
+  case 'j':
+    __get_day_year_num(__tm->tm_yday, __b, __e, __err, __ct);
+    break;
+  case 'm':
+    __get_month(__tm->tm_mon, __b, __e, __err, __ct);
+    break;
+  case 'M':
+    __get_minute(__tm->tm_min, __b, __e, __err, __ct);
+    break;
+  case 'n':
+  case 't':
+    __get_white_space(__b, __e, __err, __ct);
+    break;
+  case 'p':
+    __get_am_pm(__tm->tm_hour, __b, __e, __err, __ct);
+    break;
+  case 'r': {
+    const char_type __fm[] = {'%', 'I', ':', '%', 'M', ':', '%', 'S', ' ', '%', 'p'};
+    __b                    = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm) / sizeof(__fm[0]));
+  } break;
+  case 'R': {
+    const char_type __fm[] = {'%', 'H', ':', '%', 'M'};
+    __b                    = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm) / sizeof(__fm[0]));
+  } break;
+  case 'S':
+    __get_second(__tm->tm_sec, __b, __e, __err, __ct);
+    break;
+  case 'T': {
+    const char_type __fm[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'};
+    __b                    = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm) / sizeof(__fm[0]));
+  } break;
+  case 'w':
+    __get_weekday(__tm->tm_wday, __b, __e, __err, __ct);
+    break;
+  case 'x':
+    return do_get_date(__b, __e, __iob, __err, __tm);
+  case 'X': {
+    const string_type& __fm = this->__X();
+    __b                     = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size());
+  } break;
+  case 'y':
     __get_year(__tm->tm_year, __b, __e, __err, __ct);
-    return __b;
-}
-
-template <class _CharT, class _InputIterator>
-_InputIterator
-time_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                         ios_base& __iob,
-                                         ios_base::iostate& __err, tm* __tm,
-                                         char __fmt, char) const
-{
-    __err = ios_base::goodbit;
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
-    switch (__fmt)
-    {
-    case 'a':
-    case 'A':
-        __get_weekdayname(__tm->tm_wday, __b, __e, __err, __ct);
-        break;
-    case 'b':
-    case 'B':
-    case 'h':
-        __get_monthname(__tm->tm_mon, __b, __e, __err, __ct);
-        break;
-    case 'c':
-        {
-        const string_type& __fm = this->__c();
-        __b = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size());
-        }
-        break;
-    case 'd':
-    case 'e':
-        __get_day(__tm->tm_mday, __b, __e, __err, __ct);
-        break;
-    case 'D':
-        {
-        const char_type __fm[] = {'%', 'm', '/', '%', 'd', '/', '%', 'y'};
-        __b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0]));
-        }
-        break;
-    case 'F':
-        {
-        const char_type __fm[] = {'%', 'Y', '-', '%', 'm', '-', '%', 'd'};
-        __b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0]));
-        }
-        break;
-    case 'H':
-        __get_hour(__tm->tm_hour, __b, __e, __err, __ct);
-        break;
-    case 'I':
-        __get_12_hour(__tm->tm_hour, __b, __e, __err, __ct);
-        break;
-    case 'j':
-        __get_day_year_num(__tm->tm_yday, __b, __e, __err, __ct);
-        break;
-    case 'm':
-        __get_month(__tm->tm_mon, __b, __e, __err, __ct);
-        break;
-    case 'M':
-        __get_minute(__tm->tm_min, __b, __e, __err, __ct);
-        break;
-    case 'n':
-    case 't':
-        __get_white_space(__b, __e, __err, __ct);
-        break;
-    case 'p':
-        __get_am_pm(__tm->tm_hour, __b, __e, __err, __ct);
-        break;
-    case 'r':
-        {
-        const char_type __fm[] = {'%', 'I', ':', '%', 'M', ':', '%', 'S', ' ', '%', 'p'};
-        __b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0]));
-        }
-        break;
-    case 'R':
-        {
-        const char_type __fm[] = {'%', 'H', ':', '%', 'M'};
-        __b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0]));
-        }
-        break;
-    case 'S':
-        __get_second(__tm->tm_sec, __b, __e, __err, __ct);
-        break;
-    case 'T':
-        {
-        const char_type __fm[] = {'%', 'H', ':', '%', 'M', ':', '%', 'S'};
-        __b = get(__b, __e, __iob, __err, __tm, __fm, __fm + sizeof(__fm)/sizeof(__fm[0]));
-        }
-        break;
-    case 'w':
-        __get_weekday(__tm->tm_wday, __b, __e, __err, __ct);
-        break;
-    case 'x':
-        return do_get_date(__b, __e, __iob, __err, __tm);
-    case 'X':
-        {
-        const string_type& __fm = this->__X();
-        __b = get(__b, __e, __iob, __err, __tm, __fm.data(), __fm.data() + __fm.size());
-        }
-        break;
-    case 'y':
-        __get_year(__tm->tm_year, __b, __e, __err, __ct);
-        break;
-    case 'Y':
-        __get_year4(__tm->tm_year, __b, __e, __err, __ct);
-        break;
-    case '%':
-        __get_percent(__b, __e, __err, __ct);
-        break;
-    default:
-        __err |= ios_base::failbit;
-    }
-    return __b;
+    break;
+  case 'Y':
+    __get_year4(__tm->tm_year, __b, __e, __err, __ct);
+    break;
+  case '%':
+    __get_percent(__b, __e, __err, __ct);
+    break;
+  default:
+    __err |= ios_base::failbit;
+  }
+  return __b;
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get<wchar_t>;
-#endif
+#  endif
 
-class _LIBCPP_TYPE_VIS __time_get
-{
+class _LIBCPP_EXPORTED_FROM_ABI __time_get {
 protected:
-    locale_t __loc_;
+  locale_t __loc_;
 
-    __time_get(const char* __nm);
-    __time_get(const string& __nm);
-    ~__time_get();
+  __time_get(const char* __nm);
+  __time_get(const string& __nm);
+  ~__time_get();
 };
 
 template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS __time_get_storage
-    : public __time_get
-{
+class _LIBCPP_TEMPLATE_VIS __time_get_storage : public __time_get {
 protected:
-    typedef basic_string<_CharT> string_type;
+  typedef basic_string<_CharT> string_type;
 
-    string_type __weeks_[14];
-    string_type __months_[24];
-    string_type __am_pm_[2];
-    string_type __c_;
-    string_type __r_;
-    string_type __x_;
-    string_type __X_;
+  string_type __weeks_[14];
+  string_type __months_[24];
+  string_type __am_pm_[2];
+  string_type __c_;
+  string_type __r_;
+  string_type __x_;
+  string_type __X_;
 
-    explicit __time_get_storage(const char* __nm);
-    explicit __time_get_storage(const string& __nm);
+  explicit __time_get_storage(const char* __nm);
+  explicit __time_get_storage(const string& __nm);
 
-    _LIBCPP_INLINE_VISIBILITY ~__time_get_storage() {}
+  _LIBCPP_HIDE_FROM_ABI ~__time_get_storage() {}
 
-    time_base::dateorder __do_date_order() const;
+  time_base::dateorder __do_date_order() const;
 
 private:
-    void init(const ctype<_CharT>&);
-    string_type __analyze(char __fmt, const ctype<_CharT>&);
+  void init(const ctype<_CharT>&);
+  string_type __analyze(char __fmt, const ctype<_CharT>&);
 };
 
-#define _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(_CharT) \
-template <> _LIBCPP_FUNC_VIS time_base::dateorder __time_get_storage<_CharT>::__do_date_order() const; \
-template <> _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const char*); \
-template <> _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const string&); \
-template <> _LIBCPP_FUNC_VIS void __time_get_storage<_CharT>::init(const ctype<_CharT>&); \
-template <> _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::string_type __time_get_storage<_CharT>::__analyze(char, const ctype<_CharT>&); \
-extern template _LIBCPP_FUNC_VIS time_base::dateorder __time_get_storage<_CharT>::__do_date_order() const; \
-extern template _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const char*); \
-extern template _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::__time_get_storage(const string&); \
-extern template _LIBCPP_FUNC_VIS void __time_get_storage<_CharT>::init(const ctype<_CharT>&); \
-extern template _LIBCPP_FUNC_VIS __time_get_storage<_CharT>::string_type __time_get_storage<_CharT>::__analyze(char, const ctype<_CharT>&); \
-/**/
+#  define _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(_CharT)                                                      \
+    template <>                                                                                                        \
+    _LIBCPP_EXPORTED_FROM_ABI time_base::dateorder __time_get_storage<_CharT>::__do_date_order() const;                \
+    template <>                                                                                                        \
+    _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const char*);                             \
+    template <>                                                                                                        \
+    _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const string&);                           \
+    template <>                                                                                                        \
+    _LIBCPP_EXPORTED_FROM_ABI void __time_get_storage<_CharT>::init(const ctype<_CharT>&);                             \
+    template <>                                                                                                        \
+    _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::string_type __time_get_storage<_CharT>::__analyze(           \
+        char, const ctype<_CharT>&);                                                                                   \
+    extern template _LIBCPP_EXPORTED_FROM_ABI time_base::dateorder __time_get_storage<_CharT>::__do_date_order()       \
+        const;                                                                                                         \
+    extern template _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const char*);             \
+    extern template _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const string&);           \
+    extern template _LIBCPP_EXPORTED_FROM_ABI void __time_get_storage<_CharT>::init(const ctype<_CharT>&);             \
+    extern template _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::string_type                                  \
+    __time_get_storage<_CharT>::__analyze(char, const ctype<_CharT>&);                                                 \
+    /**/
 
 _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(char)
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(wchar_t)
-#endif
-#undef _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION
+#  endif
+#  undef _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
 class _LIBCPP_TEMPLATE_VIS time_get_byname
     : public time_get<_CharT, _InputIterator>,
-      private __time_get_storage<_CharT>
-{
+      private __time_get_storage<_CharT> {
 public:
-    typedef time_base::dateorder    dateorder;
-    typedef _InputIterator          iter_type;
-    typedef _CharT                  char_type;
-    typedef basic_string<char_type> string_type;
+  typedef time_base::dateorder dateorder;
+  typedef _InputIterator iter_type;
+  typedef _CharT char_type;
+  typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit time_get_byname(const char* __nm, size_t __refs = 0)
-        : time_get<_CharT, _InputIterator>(__refs),
-          __time_get_storage<_CharT>(__nm) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit time_get_byname(const string& __nm, size_t __refs = 0)
-        : time_get<_CharT, _InputIterator>(__refs),
-          __time_get_storage<_CharT>(__nm) {}
+  _LIBCPP_HIDE_FROM_ABI explicit time_get_byname(const char* __nm, size_t __refs = 0)
+      : time_get<_CharT, _InputIterator>(__refs), __time_get_storage<_CharT>(__nm) {}
+  _LIBCPP_HIDE_FROM_ABI explicit time_get_byname(const string& __nm, size_t __refs = 0)
+      : time_get<_CharT, _InputIterator>(__refs), __time_get_storage<_CharT>(__nm) {}
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_get_byname() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_get_byname() override {}
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL dateorder do_date_order() const override { return this->__do_date_order(); }
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL dateorder do_date_order() const override {return this->__do_date_order();}
 private:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type* __weeks() const override  {return this->__weeks_;}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type* __months() const override {return this->__months_;}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type* __am_pm() const override  {return this->__am_pm_;}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __c() const override      {return this->__c_;}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __r() const override      {return this->__r_;}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __x() const override      {return this->__x_;}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __X() const override      {return this->__X_;}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type* __weeks() const override { return this->__weeks_; }
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type* __months() const override { return this->__months_; }
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type* __am_pm() const override { return this->__am_pm_; }
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __c() const override { return this->__c_; }
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __r() const override { return this->__r_; }
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __x() const override { return this->__x_; }
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL const string_type& __X() const override { return this->__X_; }
 };
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_get_byname<wchar_t>;
-#endif
+#  endif
+
+class _LIBCPP_EXPORTED_FROM_ABI __time_put {
+  locale_t __loc_;
 
-class _LIBCPP_TYPE_VIS __time_put
-{
-    locale_t __loc_;
 protected:
-    _LIBCPP_INLINE_VISIBILITY __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {}
-    __time_put(const char* __nm);
-    __time_put(const string& __nm);
-    ~__time_put();
-    void __do_put(char* __nb, char*& __ne, const tm* __tm,
-                  char __fmt, char __mod) const;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    void __do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm,
-                  char __fmt, char __mod) const;
-#endif
+  _LIBCPP_HIDE_FROM_ABI __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {}
+  __time_put(const char* __nm);
+  __time_put(const string& __nm);
+  ~__time_put();
+  void __do_put(char* __nb, char*& __ne, const tm* __tm, char __fmt, char __mod) const;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  void __do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm, char __fmt, char __mod) const;
+#  endif
 };
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TEMPLATE_VIS time_put
-    : public locale::facet,
-      private __time_put
-{
+class _LIBCPP_TEMPLATE_VIS time_put : public locale::facet, private __time_put {
 public:
-    typedef _CharT char_type;
-    typedef _OutputIterator iter_type;
+  typedef _CharT char_type;
+  typedef _OutputIterator iter_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit time_put(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit time_put(size_t __refs = 0) : locale::facet(__refs) {}
 
-    iter_type put(iter_type __s, ios_base& __iob, char_type __fl, const tm* __tm,
-                  const char_type* __pb, const char_type* __pe) const;
+  iter_type
+  put(iter_type __s, ios_base& __iob, char_type __fl, const tm* __tm, const char_type* __pb, const char_type* __pe)
+      const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, ios_base& __iob, char_type __fl,
-                  const tm* __tm, char __fmt, char __mod = 0) const
-    {
-        return do_put(__s, __iob, __fl, __tm, __fmt, __mod);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  put(iter_type __s, ios_base& __iob, char_type __fl, const tm* __tm, char __fmt, char __mod = 0) const {
+    return do_put(__s, __iob, __fl, __tm, __fmt, __mod);
+  }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_put() override {}
-    virtual iter_type do_put(iter_type __s, ios_base&, char_type, const tm* __tm,
-                             char __fmt, char __mod) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_put() override {}
+  virtual iter_type do_put(iter_type __s, ios_base&, char_type, const tm* __tm, char __fmt, char __mod) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit time_put(const char* __nm, size_t __refs)
-        : locale::facet(__refs),
-          __time_put(__nm) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit time_put(const string& __nm, size_t __refs)
-        : locale::facet(__refs),
-          __time_put(__nm) {}
+  _LIBCPP_HIDE_FROM_ABI explicit time_put(const char* __nm, size_t __refs) : locale::facet(__refs), __time_put(__nm) {}
+  _LIBCPP_HIDE_FROM_ABI explicit time_put(const string& __nm, size_t __refs)
+      : locale::facet(__refs), __time_put(__nm) {}
 };
 
 template <class _CharT, class _OutputIterator>
-locale::id
-time_put<_CharT, _OutputIterator>::id;
+locale::id time_put<_CharT, _OutputIterator>::id;
 
 template <class _CharT, class _OutputIterator>
-_OutputIterator
-time_put<_CharT, _OutputIterator>::put(iter_type __s, ios_base& __iob,
-                                       char_type __fl, const tm* __tm,
-                                       const char_type* __pb,
-                                       const char_type* __pe) const
-{
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
-    for (; __pb != __pe; ++__pb)
-    {
-        if (__ct.narrow(*__pb, 0) == '%')
-        {
-            if (++__pb == __pe)
-            {
-                *__s++ = __pb[-1];
-                break;
-            }
-            char __mod = 0;
-            char __fmt = __ct.narrow(*__pb, 0);
-            if (__fmt == 'E' || __fmt == 'O')
-            {
-                if (++__pb == __pe)
-                {
-                    *__s++ = __pb[-2];
-                    *__s++ = __pb[-1];
-                    break;
-                }
-                __mod = __fmt;
-                __fmt = __ct.narrow(*__pb, 0);
-            }
-            __s = do_put(__s, __iob, __fl, __tm, __fmt, __mod);
+_OutputIterator time_put<_CharT, _OutputIterator>::put(
+    iter_type __s, ios_base& __iob, char_type __fl, const tm* __tm, const char_type* __pb, const char_type* __pe)
+    const {
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__iob.getloc());
+  for (; __pb != __pe; ++__pb) {
+    if (__ct.narrow(*__pb, 0) == '%') {
+      if (++__pb == __pe) {
+        *__s++ = __pb[-1];
+        break;
+      }
+      char __mod = 0;
+      char __fmt = __ct.narrow(*__pb, 0);
+      if (__fmt == 'E' || __fmt == 'O') {
+        if (++__pb == __pe) {
+          *__s++ = __pb[-2];
+          *__s++ = __pb[-1];
+          break;
         }
-        else
-            *__s++ = *__pb;
-    }
-    return __s;
+        __mod = __fmt;
+        __fmt = __ct.narrow(*__pb, 0);
+      }
+      __s = do_put(__s, __iob, __fl, __tm, __fmt, __mod);
+    } else
+      *__s++ = *__pb;
+  }
+  return __s;
 }
 
 template <class _CharT, class _OutputIterator>
-_OutputIterator
-time_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base&,
-                                          char_type, const tm* __tm,
-                                          char __fmt, char __mod) const
-{
-    char_type __nar[100];
-    char_type* __nb = __nar;
-    char_type* __ne = __nb + 100;
-    __do_put(__nb, __ne, __tm, __fmt, __mod);
-    return _VSTD::copy(__nb, __ne, __s);
+_OutputIterator time_put<_CharT, _OutputIterator>::do_put(
+    iter_type __s, ios_base&, char_type, const tm* __tm, char __fmt, char __mod) const {
+  char_type __nar[100];
+  char_type* __nb = __nar;
+  char_type* __ne = __nb + 100;
+  __do_put(__nb, __ne, __tm, __fmt, __mod);
+  return std::copy(__nb, __ne, __s);
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put<wchar_t>;
-#endif
+#  endif
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TEMPLATE_VIS time_put_byname
-    : public time_put<_CharT, _OutputIterator>
-{
+class _LIBCPP_TEMPLATE_VIS time_put_byname : public time_put<_CharT, _OutputIterator> {
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit time_put_byname(const char* __nm, size_t __refs = 0)
-        : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit time_put_byname(const char* __nm, size_t __refs = 0)
+      : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit time_put_byname(const string& __nm, size_t __refs = 0)
-        : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit time_put_byname(const string& __nm, size_t __refs = 0)
+      : time_put<_CharT, _OutputIterator>(__nm, __refs) {}
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_put_byname() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~time_put_byname() override {}
 };
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS time_put_byname<wchar_t>;
-#endif
+#  endif
 
 // money_base
 
-class _LIBCPP_TYPE_VIS money_base
-{
+class _LIBCPP_EXPORTED_FROM_ABI money_base {
 public:
-    enum part {none, space, symbol, sign, value};
-    struct pattern {char field[4];};
+  enum part { none, space, symbol, sign, value };
+  struct pattern {
+    char field[4];
+  };
 
-    _LIBCPP_INLINE_VISIBILITY money_base() {}
+  _LIBCPP_HIDE_FROM_ABI money_base() {}
 };
 
 // moneypunct
 
 template <class _CharT, bool _International = false>
-class _LIBCPP_TEMPLATE_VIS moneypunct
-    : public locale::facet,
-      public money_base
-{
+class _LIBCPP_TEMPLATE_VIS moneypunct : public locale::facet, public money_base {
 public:
-    typedef _CharT                  char_type;
-    typedef basic_string<char_type> string_type;
+  typedef _CharT char_type;
+  typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit moneypunct(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit moneypunct(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY char_type   decimal_point() const {return do_decimal_point();}
-    _LIBCPP_INLINE_VISIBILITY char_type   thousands_sep() const {return do_thousands_sep();}
-    _LIBCPP_INLINE_VISIBILITY string      grouping()      const {return do_grouping();}
-    _LIBCPP_INLINE_VISIBILITY string_type curr_symbol()   const {return do_curr_symbol();}
-    _LIBCPP_INLINE_VISIBILITY string_type positive_sign() const {return do_positive_sign();}
-    _LIBCPP_INLINE_VISIBILITY string_type negative_sign() const {return do_negative_sign();}
-    _LIBCPP_INLINE_VISIBILITY int         frac_digits()   const {return do_frac_digits();}
-    _LIBCPP_INLINE_VISIBILITY pattern     pos_format()    const {return do_pos_format();}
-    _LIBCPP_INLINE_VISIBILITY pattern     neg_format()    const {return do_neg_format();}
+  _LIBCPP_HIDE_FROM_ABI char_type decimal_point() const { return do_decimal_point(); }
+  _LIBCPP_HIDE_FROM_ABI char_type thousands_sep() const { return do_thousands_sep(); }
+  _LIBCPP_HIDE_FROM_ABI string grouping() const { return do_grouping(); }
+  _LIBCPP_HIDE_FROM_ABI string_type curr_symbol() const { return do_curr_symbol(); }
+  _LIBCPP_HIDE_FROM_ABI string_type positive_sign() const { return do_positive_sign(); }
+  _LIBCPP_HIDE_FROM_ABI string_type negative_sign() const { return do_negative_sign(); }
+  _LIBCPP_HIDE_FROM_ABI int frac_digits() const { return do_frac_digits(); }
+  _LIBCPP_HIDE_FROM_ABI pattern pos_format() const { return do_pos_format(); }
+  _LIBCPP_HIDE_FROM_ABI pattern neg_format() const { return do_neg_format(); }
 
-    static locale::id id;
-    static const bool intl = _International;
+  static locale::id id;
+  static const bool intl = _International;
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~moneypunct() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~moneypunct() override {}
 
-    virtual char_type   do_decimal_point() const {return numeric_limits<char_type>::max();}
-    virtual char_type   do_thousands_sep() const {return numeric_limits<char_type>::max();}
-    virtual string      do_grouping()      const {return string();}
-    virtual string_type do_curr_symbol()   const {return string_type();}
-    virtual string_type do_positive_sign() const {return string_type();}
-    virtual string_type do_negative_sign() const {return string_type(1, '-');}
-    virtual int         do_frac_digits()   const {return 0;}
-    virtual pattern     do_pos_format()    const
-        {pattern __p = {{symbol, sign, none, value}}; return __p;}
-    virtual pattern     do_neg_format()    const
-        {pattern __p = {{symbol, sign, none, value}}; return __p;}
+  virtual char_type do_decimal_point() const { return numeric_limits<char_type>::max(); }
+  virtual char_type do_thousands_sep() const { return numeric_limits<char_type>::max(); }
+  virtual string do_grouping() const { return string(); }
+  virtual string_type do_curr_symbol() const { return string_type(); }
+  virtual string_type do_positive_sign() const { return string_type(); }
+  virtual string_type do_negative_sign() const { return string_type(1, '-'); }
+  virtual int do_frac_digits() const { return 0; }
+  virtual pattern do_pos_format() const {
+    pattern __p = {{symbol, sign, none, value}};
+    return __p;
+  }
+  virtual pattern do_neg_format() const {
+    pattern __p = {{symbol, sign, none, value}};
+    return __p;
+  }
 };
 
 template <class _CharT, bool _International>
-locale::id
-moneypunct<_CharT, _International>::id;
+locale::id moneypunct<_CharT, _International>::id;
 
 template <class _CharT, bool _International>
-const bool
-moneypunct<_CharT, _International>::intl;
+const bool moneypunct<_CharT, _International>::intl;
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, false>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<char, true>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, false>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct<wchar_t, true>;
-#endif
+#  endif
 
 // moneypunct_byname
 
 template <class _CharT, bool _International = false>
-class _LIBCPP_TEMPLATE_VIS moneypunct_byname
-    : public moneypunct<_CharT, _International>
-{
+class _LIBCPP_TEMPLATE_VIS moneypunct_byname : public moneypunct<_CharT, _International> {
 public:
-    typedef money_base::pattern  pattern;
-    typedef _CharT                  char_type;
-    typedef basic_string<char_type> string_type;
+  typedef money_base::pattern pattern;
+  typedef _CharT char_type;
+  typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit moneypunct_byname(const char* __nm, size_t __refs = 0)
-        : moneypunct<_CharT, _International>(__refs) {init(__nm);}
+  _LIBCPP_HIDE_FROM_ABI explicit moneypunct_byname(const char* __nm, size_t __refs = 0)
+      : moneypunct<_CharT, _International>(__refs) {
+    init(__nm);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit moneypunct_byname(const string& __nm, size_t __refs = 0)
-        : moneypunct<_CharT, _International>(__refs) {init(__nm.c_str());}
+  _LIBCPP_HIDE_FROM_ABI explicit moneypunct_byname(const string& __nm, size_t __refs = 0)
+      : moneypunct<_CharT, _International>(__refs) {
+    init(__nm.c_str());
+  }
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~moneypunct_byname() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~moneypunct_byname() override {}
 
-     char_type   do_decimal_point() const override {return __decimal_point_;}
-     char_type   do_thousands_sep() const override {return __thousands_sep_;}
-     string      do_grouping()      const override {return __grouping_;}
-     string_type do_curr_symbol()   const override {return __curr_symbol_;}
-     string_type do_positive_sign() const override {return __positive_sign_;}
-     string_type do_negative_sign() const override {return __negative_sign_;}
-     int         do_frac_digits()   const override {return __frac_digits_;}
-     pattern     do_pos_format()    const override {return __pos_format_;}
-     pattern     do_neg_format()    const override {return __neg_format_;}
+  char_type do_decimal_point() const override { return __decimal_point_; }
+  char_type do_thousands_sep() const override { return __thousands_sep_; }
+  string do_grouping() const override { return __grouping_; }
+  string_type do_curr_symbol() const override { return __curr_symbol_; }
+  string_type do_positive_sign() const override { return __positive_sign_; }
+  string_type do_negative_sign() const override { return __negative_sign_; }
+  int do_frac_digits() const override { return __frac_digits_; }
+  pattern do_pos_format() const override { return __pos_format_; }
+  pattern do_neg_format() const override { return __neg_format_; }
 
 private:
-    char_type   __decimal_point_;
-    char_type   __thousands_sep_;
-    string      __grouping_;
-    string_type __curr_symbol_;
-    string_type __positive_sign_;
-    string_type __negative_sign_;
-    int         __frac_digits_;
-    pattern     __pos_format_;
-    pattern     __neg_format_;
+  char_type __decimal_point_;
+  char_type __thousands_sep_;
+  string __grouping_;
+  string_type __curr_symbol_;
+  string_type __positive_sign_;
+  string_type __negative_sign_;
+  int __frac_digits_;
+  pattern __pos_format_;
+  pattern __neg_format_;
 
-    void init(const char*);
+  void init(const char*);
 };
 
-template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, false>::init(const char*);
-template<> _LIBCPP_FUNC_VIS void moneypunct_byname<char, true>::init(const char*);
+template <>
+_LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<char, false>::init(const char*);
+template <>
+_LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<char, true>::init(const char*);
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, false>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<char, true>;
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, false>::init(const char*);
-template<> _LIBCPP_FUNC_VIS void moneypunct_byname<wchar_t, true>::init(const char*);
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+_LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<wchar_t, false>::init(const char*);
+template <>
+_LIBCPP_EXPORTED_FROM_ABI void moneypunct_byname<wchar_t, true>::init(const char*);
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, false>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS moneypunct_byname<wchar_t, true>;
-#endif
+#  endif
 
 // money_get
 
 template <class _CharT>
-class __money_get
-{
+class __money_get {
 protected:
-    typedef _CharT                  char_type;
-    typedef basic_string<char_type> string_type;
+  typedef _CharT char_type;
+  typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY __money_get() {}
+  _LIBCPP_HIDE_FROM_ABI __money_get() {}
 
-    static void __gather_info(bool __intl, const locale& __loc,
-                              money_base::pattern& __pat, char_type& __dp,
-                              char_type& __ts, string& __grp,
-                              string_type& __sym, string_type& __psn,
-                              string_type& __nsn, int& __fd);
+  static void __gather_info(
+      bool __intl,
+      const locale& __loc,
+      money_base::pattern& __pat,
+      char_type& __dp,
+      char_type& __ts,
+      string& __grp,
+      string_type& __sym,
+      string_type& __psn,
+      string_type& __nsn,
+      int& __fd);
 };
 
 template <class _CharT>
-void
-__money_get<_CharT>::__gather_info(bool __intl, const locale& __loc,
-                                   money_base::pattern& __pat, char_type& __dp,
-                                   char_type& __ts, string& __grp,
-                                   string_type& __sym, string_type& __psn,
-                                   string_type& __nsn, int& __fd)
-{
-    if (__intl)
-    {
-        const moneypunct<char_type, true>& __mp =
-            std::use_facet<moneypunct<char_type, true> >(__loc);
-        __pat = __mp.neg_format();
-        __nsn = __mp.negative_sign();
-        __psn = __mp.positive_sign();
-        __dp = __mp.decimal_point();
-        __ts = __mp.thousands_sep();
-        __grp = __mp.grouping();
-        __sym = __mp.curr_symbol();
-        __fd = __mp.frac_digits();
-    }
-    else
-    {
-        const moneypunct<char_type, false>& __mp =
-            std::use_facet<moneypunct<char_type, false> >(__loc);
-        __pat = __mp.neg_format();
-        __nsn = __mp.negative_sign();
-        __psn = __mp.positive_sign();
-        __dp = __mp.decimal_point();
-        __ts = __mp.thousands_sep();
-        __grp = __mp.grouping();
-        __sym = __mp.curr_symbol();
-        __fd = __mp.frac_digits();
-    }
+void __money_get<_CharT>::__gather_info(
+    bool __intl,
+    const locale& __loc,
+    money_base::pattern& __pat,
+    char_type& __dp,
+    char_type& __ts,
+    string& __grp,
+    string_type& __sym,
+    string_type& __psn,
+    string_type& __nsn,
+    int& __fd) {
+  if (__intl) {
+    const moneypunct<char_type, true>& __mp = std::use_facet<moneypunct<char_type, true> >(__loc);
+    __pat                                   = __mp.neg_format();
+    __nsn                                   = __mp.negative_sign();
+    __psn                                   = __mp.positive_sign();
+    __dp                                    = __mp.decimal_point();
+    __ts                                    = __mp.thousands_sep();
+    __grp                                   = __mp.grouping();
+    __sym                                   = __mp.curr_symbol();
+    __fd                                    = __mp.frac_digits();
+  } else {
+    const moneypunct<char_type, false>& __mp = std::use_facet<moneypunct<char_type, false> >(__loc);
+    __pat                                    = __mp.neg_format();
+    __nsn                                    = __mp.negative_sign();
+    __psn                                    = __mp.positive_sign();
+    __dp                                     = __mp.decimal_point();
+    __ts                                     = __mp.thousands_sep();
+    __grp                                    = __mp.grouping();
+    __sym                                    = __mp.curr_symbol();
+    __fd                                     = __mp.frac_digits();
+  }
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_get<wchar_t>;
-#endif
+#  endif
 
 template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
-class _LIBCPP_TEMPLATE_VIS money_get
-    : public locale::facet,
-      private __money_get<_CharT>
-{
+class _LIBCPP_TEMPLATE_VIS money_get : public locale::facet, private __money_get<_CharT> {
 public:
-    typedef _CharT                  char_type;
-    typedef _InputIterator          iter_type;
-    typedef basic_string<char_type> string_type;
+  typedef _CharT char_type;
+  typedef _InputIterator iter_type;
+  typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit money_get(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit money_get(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob,
-                  ios_base::iostate& __err, long double& __v) const
-    {
-        return do_get(__b, __e, __intl, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, long double& __v) const {
+    return do_get(__b, __e, __intl, __iob, __err, __v);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob,
-                  ios_base::iostate& __err, string_type& __v) const
-    {
-        return do_get(__b, __e, __intl, __iob, __err, __v);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, string_type& __v) const {
+    return do_get(__b, __e, __intl, __iob, __err, __v);
+  }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~money_get() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~money_get() override {}
 
-    virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl,
-                             ios_base& __iob, ios_base::iostate& __err,
-                             long double& __v) const;
-    virtual iter_type do_get(iter_type __b, iter_type __e, bool __intl,
-                             ios_base& __iob, ios_base::iostate& __err,
-                             string_type& __v) const;
+  virtual iter_type
+  do_get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, long double& __v) const;
+  virtual iter_type
+  do_get(iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, string_type& __v) const;
 
 private:
-    static bool __do_get(iter_type& __b, iter_type __e,
-                         bool __intl, const locale& __loc,
-                         ios_base::fmtflags __flags, ios_base::iostate& __err,
-                         bool& __neg, const ctype<char_type>& __ct,
-                         unique_ptr<char_type, void(*)(void*)>& __wb,
-                         char_type*& __wn, char_type* __we);
+  static bool __do_get(
+      iter_type& __b,
+      iter_type __e,
+      bool __intl,
+      const locale& __loc,
+      ios_base::fmtflags __flags,
+      ios_base::iostate& __err,
+      bool& __neg,
+      const ctype<char_type>& __ct,
+      unique_ptr<char_type, void (*)(void*)>& __wb,
+      char_type*& __wn,
+      char_type* __we);
 };
 
 template <class _CharT, class _InputIterator>
-locale::id
-money_get<_CharT, _InputIterator>::id;
+locale::id money_get<_CharT, _InputIterator>::id;
 
-_LIBCPP_FUNC_VIS void __do_nothing(void*);
+_LIBCPP_EXPORTED_FROM_ABI void __do_nothing(void*);
 
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI
-void
-__double_or_nothing(unique_ptr<_Tp, void(*)(void*)>& __b, _Tp*& __n, _Tp*& __e)
-{
-    bool __owns = __b.get_deleter() != __do_nothing;
-    size_t __cur_cap = static_cast<size_t>(__e-__b.get()) * sizeof(_Tp);
-    size_t __new_cap = __cur_cap < numeric_limits<size_t>::max() / 2 ?
-                       2 * __cur_cap : numeric_limits<size_t>::max();
-    if (__new_cap == 0)
-        __new_cap = sizeof(_Tp);
-    size_t __n_off = static_cast<size_t>(__n - __b.get());
-    _Tp* __t = (_Tp*)std::realloc(__owns ? __b.get() : 0, __new_cap);
-    if (__t == 0)
-        __throw_bad_alloc();
-    if (__owns)
-        __b.release();
-    __b = unique_ptr<_Tp, void(*)(void*)>(__t, free);
-    __new_cap /= sizeof(_Tp);
-    __n = __b.get() + __n_off;
-    __e = __b.get() + __new_cap;
+_LIBCPP_HIDE_FROM_ABI void __double_or_nothing(unique_ptr<_Tp, void (*)(void*)>& __b, _Tp*& __n, _Tp*& __e) {
+  bool __owns      = __b.get_deleter() != __do_nothing;
+  size_t __cur_cap = static_cast<size_t>(__e - __b.get()) * sizeof(_Tp);
+  size_t __new_cap = __cur_cap < numeric_limits<size_t>::max() / 2 ? 2 * __cur_cap : numeric_limits<size_t>::max();
+  if (__new_cap == 0)
+    __new_cap = sizeof(_Tp);
+  size_t __n_off = static_cast<size_t>(__n - __b.get());
+  _Tp* __t       = (_Tp*)std::realloc(__owns ? __b.get() : 0, __new_cap);
+  if (__t == 0)
+    __throw_bad_alloc();
+  if (__owns)
+    __b.release();
+  __b = unique_ptr<_Tp, void (*)(void*)>(__t, free);
+  __new_cap /= sizeof(_Tp);
+  __n = __b.get() + __n_off;
+  __e = __b.get() + __new_cap;
 }
 
 // true == success
 template <class _CharT, class _InputIterator>
-bool
-money_get<_CharT, _InputIterator>::__do_get(iter_type& __b, iter_type __e,
-                                            bool __intl, const locale& __loc,
-                                            ios_base::fmtflags __flags,
-                                            ios_base::iostate& __err,
-                                            bool& __neg,
-                                            const ctype<char_type>& __ct,
-                                            unique_ptr<char_type, void(*)(void*)>& __wb,
-                                            char_type*& __wn, char_type* __we)
-{
-    if (__b == __e) {
+bool money_get<_CharT, _InputIterator>::__do_get(
+    iter_type& __b,
+    iter_type __e,
+    bool __intl,
+    const locale& __loc,
+    ios_base::fmtflags __flags,
+    ios_base::iostate& __err,
+    bool& __neg,
+    const ctype<char_type>& __ct,
+    unique_ptr<char_type, void (*)(void*)>& __wb,
+    char_type*& __wn,
+    char_type* __we) {
+  if (__b == __e) {
+    __err |= ios_base::failbit;
+    return false;
+  }
+  const unsigned __bz = 100;
+  unsigned __gbuf[__bz];
+  unique_ptr<unsigned, void (*)(void*)> __gb(__gbuf, __do_nothing);
+  unsigned* __gn = __gb.get();
+  unsigned* __ge = __gn + __bz;
+  money_base::pattern __pat;
+  char_type __dp;
+  char_type __ts;
+  string __grp;
+  string_type __sym;
+  string_type __psn;
+  string_type __nsn;
+  // Capture the spaces read into money_base::{space,none} so they
+  // can be compared to initial spaces in __sym.
+  string_type __spaces;
+  int __fd;
+  __money_get<_CharT>::__gather_info(__intl, __loc, __pat, __dp, __ts, __grp, __sym, __psn, __nsn, __fd);
+  const string_type* __trailing_sign = 0;
+  __wn                               = __wb.get();
+  for (unsigned __p = 0; __p < 4 && __b != __e; ++__p) {
+    switch (__pat.field[__p]) {
+    case money_base::space:
+      if (__p != 3) {
+        if (__ct.is(ctype_base::space, *__b))
+          __spaces.push_back(*__b++);
+        else {
+          __err |= ios_base::failbit;
+          return false;
+        }
+      }
+      _LIBCPP_FALLTHROUGH();
+    case money_base::none:
+      if (__p != 3) {
+        while (__b != __e && __ct.is(ctype_base::space, *__b))
+          __spaces.push_back(*__b++);
+      }
+      break;
+    case money_base::sign:
+      if (__psn.size() > 0 && *__b == __psn[0]) {
+        ++__b;
+        __neg = false;
+        if (__psn.size() > 1)
+          __trailing_sign = &__psn;
+        break;
+      }
+      if (__nsn.size() > 0 && *__b == __nsn[0]) {
+        ++__b;
+        __neg = true;
+        if (__nsn.size() > 1)
+          __trailing_sign = &__nsn;
+        break;
+      }
+      if (__psn.size() > 0 && __nsn.size() > 0) { // sign is required
         __err |= ios_base::failbit;
         return false;
-    }
-    const unsigned __bz = 100;
-    unsigned __gbuf[__bz];
-    unique_ptr<unsigned, void(*)(void*)> __gb(__gbuf, __do_nothing);
-    unsigned* __gn = __gb.get();
-    unsigned* __ge = __gn + __bz;
-    money_base::pattern __pat;
-    char_type __dp;
-    char_type __ts;
-    string __grp;
-    string_type __sym;
-    string_type __psn;
-    string_type __nsn;
-    // Capture the spaces read into money_base::{space,none} so they
-    // can be compared to initial spaces in __sym.
-    string_type __spaces;
-    int __fd;
-    __money_get<_CharT>::__gather_info(__intl, __loc, __pat, __dp, __ts, __grp,
-                                       __sym, __psn, __nsn, __fd);
-    const string_type* __trailing_sign = 0;
-    __wn = __wb.get();
-    for (unsigned __p = 0; __p < 4 && __b != __e; ++__p)
-    {
-        switch (__pat.field[__p])
-        {
-        case money_base::space:
-            if (__p != 3)
-            {
-                if (__ct.is(ctype_base::space, *__b))
-                    __spaces.push_back(*__b++);
-                else
-                {
-                    __err |= ios_base::failbit;
-                    return false;
-                }
-            }
-            _LIBCPP_FALLTHROUGH();
-        case money_base::none:
-            if (__p != 3)
-            {
-                while (__b != __e && __ct.is(ctype_base::space, *__b))
-                    __spaces.push_back(*__b++);
-            }
-            break;
-        case money_base::sign:
-            if (__psn.size() > 0 && *__b == __psn[0])
-            {
-                ++__b;
-                __neg = false;
-                if (__psn.size() > 1)
-                  __trailing_sign = &__psn;
-                break;
-            }
-            if (__nsn.size() > 0 && *__b == __nsn[0])
-            {
-                ++__b;
-                __neg = true;
-                if (__nsn.size() > 1)
-                    __trailing_sign = &__nsn;
-                break;
-            }
-            if (__psn.size() > 0 && __nsn.size() > 0)
-            {   // sign is required
-                __err |= ios_base::failbit;
-                return false;
-            }
-            if (__psn.size() == 0 && __nsn.size() == 0)
-                // locale has no way of specifying a sign. Use the initial value of __neg as a default
-                break;
-            __neg = (__nsn.size() == 0);
-            break;
-        case money_base::symbol:
-            {
-            bool __more_needed = __trailing_sign ||
-                                 (__p < 2)       ||
-                                 (__p == 2 && __pat.field[3] != static_cast<char>(money_base::none));
-            bool __sb = (__flags & ios_base::showbase) != 0;
-            if (__sb || __more_needed)
-            {
-                typename string_type::const_iterator __sym_space_end = __sym.begin();
-                if (__p > 0 && (__pat.field[__p - 1] == money_base::none ||
-                                __pat.field[__p - 1] == money_base::space)) {
-                    // Match spaces we've already read against spaces at
-                    // the beginning of __sym.
-                    while (__sym_space_end != __sym.end() &&
-                           __ct.is(ctype_base::space, *__sym_space_end))
-                        ++__sym_space_end;
-                    const size_t __num_spaces = __sym_space_end - __sym.begin();
-                    if (__num_spaces > __spaces.size() ||
-                        !std::equal(__spaces.end() - __num_spaces, __spaces.end(),
-                               __sym.begin())) {
-                        // No match. Put __sym_space_end back at the
-                        // beginning of __sym, which will prevent a
-                        // match in the next loop.
-                        __sym_space_end = __sym.begin();
-                    }
-                }
-                typename string_type::const_iterator __sym_curr_char = __sym_space_end;
-                while (__sym_curr_char != __sym.end() && __b != __e &&
-                       *__b == *__sym_curr_char) {
-                    ++__b;
-                    ++__sym_curr_char;
-                }
-                if (__sb && __sym_curr_char != __sym.end())
-                {
-                    __err |= ios_base::failbit;
-                    return false;
-                }
-            }
-            }
-            break;
-        case money_base::value:
-            {
-            unsigned __ng = 0;
-            for (; __b != __e; ++__b)
-            {
-                char_type __c = *__b;
-                if (__ct.is(ctype_base::digit, __c))
-                {
-                    if (__wn == __we)
-                        std::__double_or_nothing(__wb, __wn, __we);
-                    *__wn++ = __c;
-                    ++__ng;
-                }
-                else if (__grp.size() > 0 && __ng > 0 && __c == __ts)
-                {
-                    if (__gn == __ge)
-                        std::__double_or_nothing(__gb, __gn, __ge);
-                    *__gn++ = __ng;
-                    __ng = 0;
-                }
-                else
-                    break;
-            }
-            if (__gb.get() != __gn && __ng > 0)
-            {
-                if (__gn == __ge)
-                    std::__double_or_nothing(__gb, __gn, __ge);
-                *__gn++ = __ng;
-            }
-            if (__fd > 0)
-            {
-                if (__b == __e || *__b != __dp)
-                {
-                    __err |= ios_base::failbit;
-                    return false;
-                }
-                for (++__b; __fd > 0; --__fd, ++__b)
-                {
-                    if (__b == __e || !__ct.is(ctype_base::digit, *__b))
-                    {
-                        __err |= ios_base::failbit;
-                        return false;
-                    }
-                    if (__wn == __we)
-                        std::__double_or_nothing(__wb, __wn, __we);
-                    *__wn++ = *__b;
-                }
-            }
-            if (__wn == __wb.get())
-            {
-                __err |= ios_base::failbit;
-                return false;
-            }
-            }
-            break;
+      }
+      if (__psn.size() == 0 && __nsn.size() == 0)
+        // locale has no way of specifying a sign. Use the initial value of __neg as a default
+        break;
+      __neg = (__nsn.size() == 0);
+      break;
+    case money_base::symbol: {
+      bool __more_needed =
+          __trailing_sign || (__p < 2) || (__p == 2 && __pat.field[3] != static_cast<char>(money_base::none));
+      bool __sb = (__flags & ios_base::showbase) != 0;
+      if (__sb || __more_needed) {
+        typename string_type::const_iterator __sym_space_end = __sym.begin();
+        if (__p > 0 && (__pat.field[__p - 1] == money_base::none || __pat.field[__p - 1] == money_base::space)) {
+          // Match spaces we've already read against spaces at
+          // the beginning of __sym.
+          while (__sym_space_end != __sym.end() && __ct.is(ctype_base::space, *__sym_space_end))
+            ++__sym_space_end;
+          const size_t __num_spaces = __sym_space_end - __sym.begin();
+          if (__num_spaces > __spaces.size() ||
+              !std::equal(__spaces.end() - __num_spaces, __spaces.end(), __sym.begin())) {
+            // No match. Put __sym_space_end back at the
+            // beginning of __sym, which will prevent a
+            // match in the next loop.
+            __sym_space_end = __sym.begin();
+          }
         }
-    }
-    if (__trailing_sign)
-    {
-        for (unsigned __i = 1; __i < __trailing_sign->size(); ++__i, ++__b)
-        {
-            if (__b == __e || *__b != (*__trailing_sign)[__i])
-            {
-                __err |= ios_base::failbit;
-                return false;
-            }
+        typename string_type::const_iterator __sym_curr_char = __sym_space_end;
+        while (__sym_curr_char != __sym.end() && __b != __e && *__b == *__sym_curr_char) {
+          ++__b;
+          ++__sym_curr_char;
         }
-    }
-    if (__gb.get() != __gn)
-    {
-        ios_base::iostate __et = ios_base::goodbit;
-        __check_grouping(__grp, __gb.get(), __gn, __et);
-        if (__et)
-        {
+        if (__sb && __sym_curr_char != __sym.end()) {
+          __err |= ios_base::failbit;
+          return false;
+        }
+      }
+    } break;
+    case money_base::value: {
+      unsigned __ng = 0;
+      for (; __b != __e; ++__b) {
+        char_type __c = *__b;
+        if (__ct.is(ctype_base::digit, __c)) {
+          if (__wn == __we)
+            std::__double_or_nothing(__wb, __wn, __we);
+          *__wn++ = __c;
+          ++__ng;
+        } else if (__grp.size() > 0 && __ng > 0 && __c == __ts) {
+          if (__gn == __ge)
+            std::__double_or_nothing(__gb, __gn, __ge);
+          *__gn++ = __ng;
+          __ng    = 0;
+        } else
+          break;
+      }
+      if (__gb.get() != __gn && __ng > 0) {
+        if (__gn == __ge)
+          std::__double_or_nothing(__gb, __gn, __ge);
+        *__gn++ = __ng;
+      }
+      if (__fd > 0) {
+        if (__b == __e || *__b != __dp) {
+          __err |= ios_base::failbit;
+          return false;
+        }
+        for (++__b; __fd > 0; --__fd, ++__b) {
+          if (__b == __e || !__ct.is(ctype_base::digit, *__b)) {
             __err |= ios_base::failbit;
             return false;
+          }
+          if (__wn == __we)
+            std::__double_or_nothing(__wb, __wn, __we);
+          *__wn++ = *__b;
         }
+      }
+      if (__wn == __wb.get()) {
+        __err |= ios_base::failbit;
+        return false;
+      }
+    } break;
     }
-    return true;
+  }
+  if (__trailing_sign) {
+    for (unsigned __i = 1; __i < __trailing_sign->size(); ++__i, ++__b) {
+      if (__b == __e || *__b != (*__trailing_sign)[__i]) {
+        __err |= ios_base::failbit;
+        return false;
+      }
+    }
+  }
+  if (__gb.get() != __gn) {
+    ios_base::iostate __et = ios_base::goodbit;
+    __check_grouping(__grp, __gb.get(), __gn, __et);
+    if (__et) {
+      __err |= ios_base::failbit;
+      return false;
+    }
+  }
+  return true;
 }
 
 template <class _CharT, class _InputIterator>
-_InputIterator
-money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                          bool __intl, ios_base& __iob,
-                                          ios_base::iostate& __err,
-                                          long double& __v) const
-{
-    const int __bz = 100;
-    char_type __wbuf[__bz];
-    unique_ptr<char_type, void(*)(void*)> __wb(__wbuf, __do_nothing);
-    char_type* __wn;
-    char_type* __we = __wbuf + __bz;
-    locale __loc = __iob.getloc();
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
-    bool __neg = false;
-    if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
-                 __wb, __wn, __we))
-    {
-        const char __src[] = "0123456789";
-        char_type __atoms[sizeof(__src)-1];
-        __ct.widen(__src, __src + (sizeof(__src)-1), __atoms);
-        char __nbuf[__bz];
-        char* __nc = __nbuf;
-        unique_ptr<char, void(*)(void*)> __h(nullptr, free);
-        if (__wn - __wb.get() > __bz-2)
-        {
-            __h.reset((char*)malloc(static_cast<size_t>(__wn - __wb.get() + 2)));
-            if (__h.get() == nullptr)
-                __throw_bad_alloc();
-            __nc = __h.get();
-        }
-        if (__neg)
-            *__nc++ = '-';
-        for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc)
-            *__nc = __src[std::find(__atoms, _VSTD::end(__atoms), *__w) - __atoms];
-        *__nc = char();
-        if (sscanf(__nbuf, "%Lf", &__v) != 1)
-            __throw_runtime_error("money_get error");
+_InputIterator money_get<_CharT, _InputIterator>::do_get(
+    iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, long double& __v) const {
+  const int __bz = 100;
+  char_type __wbuf[__bz];
+  unique_ptr<char_type, void (*)(void*)> __wb(__wbuf, __do_nothing);
+  char_type* __wn;
+  char_type* __we              = __wbuf + __bz;
+  locale __loc                 = __iob.getloc();
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
+  bool __neg                   = false;
+  if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct, __wb, __wn, __we)) {
+    const char __src[] = "0123456789";
+    char_type __atoms[sizeof(__src) - 1];
+    __ct.widen(__src, __src + (sizeof(__src) - 1), __atoms);
+    char __nbuf[__bz];
+    char* __nc = __nbuf;
+    unique_ptr<char, void (*)(void*)> __h(nullptr, free);
+    if (__wn - __wb.get() > __bz - 2) {
+      __h.reset((char*)malloc(static_cast<size_t>(__wn - __wb.get() + 2)));
+      if (__h.get() == nullptr)
+        __throw_bad_alloc();
+      __nc = __h.get();
     }
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
+    if (__neg)
+      *__nc++ = '-';
+    for (const char_type* __w = __wb.get(); __w < __wn; ++__w, ++__nc)
+      *__nc = __src[std::find(__atoms, std::end(__atoms), *__w) - __atoms];
+    *__nc = char();
+    if (sscanf(__nbuf, "%Lf", &__v) != 1)
+      __throw_runtime_error("money_get error");
+  }
+  if (__b == __e)
+    __err |= ios_base::eofbit;
+  return __b;
 }
 
 template <class _CharT, class _InputIterator>
-_InputIterator
-money_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
-                                          bool __intl, ios_base& __iob,
-                                          ios_base::iostate& __err,
-                                          string_type& __v) const
-{
-    const int __bz = 100;
-    char_type __wbuf[__bz];
-    unique_ptr<char_type, void(*)(void*)> __wb(__wbuf, __do_nothing);
-    char_type* __wn;
-    char_type* __we = __wbuf + __bz;
-    locale __loc = __iob.getloc();
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
-    bool __neg = false;
-    if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct,
-                 __wb, __wn, __we))
-    {
-        __v.clear();
-        if (__neg)
-            __v.push_back(__ct.widen('-'));
-        char_type __z = __ct.widen('0');
-        char_type* __w;
-        for (__w = __wb.get(); __w < __wn-1; ++__w)
-            if (*__w != __z)
-                break;
-        __v.append(__w, __wn);
-    }
-    if (__b == __e)
-        __err |= ios_base::eofbit;
-    return __b;
+_InputIterator money_get<_CharT, _InputIterator>::do_get(
+    iter_type __b, iter_type __e, bool __intl, ios_base& __iob, ios_base::iostate& __err, string_type& __v) const {
+  const int __bz = 100;
+  char_type __wbuf[__bz];
+  unique_ptr<char_type, void (*)(void*)> __wb(__wbuf, __do_nothing);
+  char_type* __wn;
+  char_type* __we              = __wbuf + __bz;
+  locale __loc                 = __iob.getloc();
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
+  bool __neg                   = false;
+  if (__do_get(__b, __e, __intl, __loc, __iob.flags(), __err, __neg, __ct, __wb, __wn, __we)) {
+    __v.clear();
+    if (__neg)
+      __v.push_back(__ct.widen('-'));
+    char_type __z = __ct.widen('0');
+    char_type* __w;
+    for (__w = __wb.get(); __w < __wn - 1; ++__w)
+      if (*__w != __z)
+        break;
+    __v.append(__w, __wn);
+  }
+  if (__b == __e)
+    __err |= ios_base::eofbit;
+  return __b;
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_get<wchar_t>;
-#endif
+#  endif
 
 // money_put
 
 template <class _CharT>
-class __money_put
-{
+class __money_put {
 protected:
-    typedef _CharT                  char_type;
-    typedef basic_string<char_type> string_type;
+  typedef _CharT char_type;
+  typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY __money_put() {}
+  _LIBCPP_HIDE_FROM_ABI __money_put() {}
 
-    static void __gather_info(bool __intl, bool __neg, const locale& __loc,
-                              money_base::pattern& __pat, char_type& __dp,
-                              char_type& __ts, string& __grp,
-                              string_type& __sym, string_type& __sn,
-                              int& __fd);
-    static void __format(char_type* __mb, char_type*& __mi, char_type*& __me,
-                         ios_base::fmtflags __flags,
-                         const char_type* __db, const char_type* __de,
-                         const ctype<char_type>& __ct, bool __neg,
-                         const money_base::pattern& __pat, char_type __dp,
-                         char_type __ts, const string& __grp,
-                         const string_type& __sym, const string_type& __sn,
-                         int __fd);
+  static void __gather_info(
+      bool __intl,
+      bool __neg,
+      const locale& __loc,
+      money_base::pattern& __pat,
+      char_type& __dp,
+      char_type& __ts,
+      string& __grp,
+      string_type& __sym,
+      string_type& __sn,
+      int& __fd);
+  static void __format(
+      char_type* __mb,
+      char_type*& __mi,
+      char_type*& __me,
+      ios_base::fmtflags __flags,
+      const char_type* __db,
+      const char_type* __de,
+      const ctype<char_type>& __ct,
+      bool __neg,
+      const money_base::pattern& __pat,
+      char_type __dp,
+      char_type __ts,
+      const string& __grp,
+      const string_type& __sym,
+      const string_type& __sn,
+      int __fd);
 };
 
 template <class _CharT>
-void
-__money_put<_CharT>::__gather_info(bool __intl, bool __neg, const locale& __loc,
-                                   money_base::pattern& __pat, char_type& __dp,
-                                   char_type& __ts, string& __grp,
-                                   string_type& __sym, string_type& __sn,
-                                   int& __fd)
-{
-    if (__intl)
-    {
-        const moneypunct<char_type, true>& __mp =
-            std::use_facet<moneypunct<char_type, true> >(__loc);
-        if (__neg)
-        {
-            __pat = __mp.neg_format();
-            __sn = __mp.negative_sign();
-        }
-        else
-        {
-            __pat = __mp.pos_format();
-            __sn = __mp.positive_sign();
-        }
-        __dp = __mp.decimal_point();
-        __ts = __mp.thousands_sep();
-        __grp = __mp.grouping();
-        __sym = __mp.curr_symbol();
-        __fd = __mp.frac_digits();
+void __money_put<_CharT>::__gather_info(
+    bool __intl,
+    bool __neg,
+    const locale& __loc,
+    money_base::pattern& __pat,
+    char_type& __dp,
+    char_type& __ts,
+    string& __grp,
+    string_type& __sym,
+    string_type& __sn,
+    int& __fd) {
+  if (__intl) {
+    const moneypunct<char_type, true>& __mp = std::use_facet<moneypunct<char_type, true> >(__loc);
+    if (__neg) {
+      __pat = __mp.neg_format();
+      __sn  = __mp.negative_sign();
+    } else {
+      __pat = __mp.pos_format();
+      __sn  = __mp.positive_sign();
     }
-    else
-    {
-        const moneypunct<char_type, false>& __mp =
-            std::use_facet<moneypunct<char_type, false> >(__loc);
-        if (__neg)
-        {
-            __pat = __mp.neg_format();
-            __sn = __mp.negative_sign();
-        }
-        else
-        {
-            __pat = __mp.pos_format();
-            __sn = __mp.positive_sign();
-        }
-        __dp = __mp.decimal_point();
-        __ts = __mp.thousands_sep();
-        __grp = __mp.grouping();
-        __sym = __mp.curr_symbol();
-        __fd = __mp.frac_digits();
+    __dp  = __mp.decimal_point();
+    __ts  = __mp.thousands_sep();
+    __grp = __mp.grouping();
+    __sym = __mp.curr_symbol();
+    __fd  = __mp.frac_digits();
+  } else {
+    const moneypunct<char_type, false>& __mp = std::use_facet<moneypunct<char_type, false> >(__loc);
+    if (__neg) {
+      __pat = __mp.neg_format();
+      __sn  = __mp.negative_sign();
+    } else {
+      __pat = __mp.pos_format();
+      __sn  = __mp.positive_sign();
     }
+    __dp  = __mp.decimal_point();
+    __ts  = __mp.thousands_sep();
+    __grp = __mp.grouping();
+    __sym = __mp.curr_symbol();
+    __fd  = __mp.frac_digits();
+  }
 }
 
 template <class _CharT>
-void
-__money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __me,
-                              ios_base::fmtflags __flags,
-                              const char_type* __db, const char_type* __de,
-                              const ctype<char_type>& __ct, bool __neg,
-                              const money_base::pattern& __pat, char_type __dp,
-                              char_type __ts, const string& __grp,
-                              const string_type& __sym, const string_type& __sn,
-                              int __fd)
-{
-    __me = __mb;
-    for (char __p : __pat.field)
-    {
-        switch (__p)
-        {
-        case money_base::none:
-            __mi = __me;
-            break;
-        case money_base::space:
-            __mi = __me;
-            *__me++ = __ct.widen(' ');
-            break;
-        case money_base::sign:
-            if (!__sn.empty())
-                *__me++ = __sn[0];
-            break;
-        case money_base::symbol:
-            if (!__sym.empty() && (__flags & ios_base::showbase))
-                __me = _VSTD::copy(__sym.begin(), __sym.end(), __me);
-            break;
-        case money_base::value:
-            {
-            // remember start of value so we can reverse it
-            char_type* __t = __me;
-            // find beginning of digits
-            if (__neg)
-                ++__db;
-            // find end of digits
-            const char_type* __d;
-            for (__d = __db; __d < __de; ++__d)
-                if (!__ct.is(ctype_base::digit, *__d))
-                    break;
-            // print fractional part
-            if (__fd > 0)
-            {
-                int __f;
-                for (__f = __fd; __d > __db && __f > 0; --__f)
-                    *__me++ = *--__d;
-                char_type __z = __f > 0 ? __ct.widen('0') : char_type();
-                for (; __f > 0; --__f)
-                    *__me++ = __z;
-                *__me++ = __dp;
-            }
-            // print units part
-            if (__d == __db)
-            {
-                *__me++ = __ct.widen('0');
-            }
-            else
-            {
-                unsigned __ng = 0;
-                unsigned __ig = 0;
-                unsigned __gl = __grp.empty() ? numeric_limits<unsigned>::max()
-                                              : static_cast<unsigned>(__grp[__ig]);
-                while (__d != __db)
-                {
-                    if (__ng == __gl)
-                    {
-                        *__me++ = __ts;
-                        __ng = 0;
-                        if (++__ig < __grp.size())
-                            __gl = __grp[__ig] == numeric_limits<char>::max() ?
-                                        numeric_limits<unsigned>::max() :
-                                        static_cast<unsigned>(__grp[__ig]);
-                    }
-                    *__me++ = *--__d;
-                    ++__ng;
-                }
-            }
-            // reverse it
-            std::reverse(__t, __me);
-            }
-            break;
+void __money_put<_CharT>::__format(
+    char_type* __mb,
+    char_type*& __mi,
+    char_type*& __me,
+    ios_base::fmtflags __flags,
+    const char_type* __db,
+    const char_type* __de,
+    const ctype<char_type>& __ct,
+    bool __neg,
+    const money_base::pattern& __pat,
+    char_type __dp,
+    char_type __ts,
+    const string& __grp,
+    const string_type& __sym,
+    const string_type& __sn,
+    int __fd) {
+  __me = __mb;
+  for (char __p : __pat.field) {
+    switch (__p) {
+    case money_base::none:
+      __mi = __me;
+      break;
+    case money_base::space:
+      __mi    = __me;
+      *__me++ = __ct.widen(' ');
+      break;
+    case money_base::sign:
+      if (!__sn.empty())
+        *__me++ = __sn[0];
+      break;
+    case money_base::symbol:
+      if (!__sym.empty() && (__flags & ios_base::showbase))
+        __me = std::copy(__sym.begin(), __sym.end(), __me);
+      break;
+    case money_base::value: {
+      // remember start of value so we can reverse it
+      char_type* __t = __me;
+      // find beginning of digits
+      if (__neg)
+        ++__db;
+      // find end of digits
+      const char_type* __d;
+      for (__d = __db; __d < __de; ++__d)
+        if (!__ct.is(ctype_base::digit, *__d))
+          break;
+      // print fractional part
+      if (__fd > 0) {
+        int __f;
+        for (__f = __fd; __d > __db && __f > 0; --__f)
+          *__me++ = *--__d;
+        char_type __z = __f > 0 ? __ct.widen('0') : char_type();
+        for (; __f > 0; --__f)
+          *__me++ = __z;
+        *__me++ = __dp;
+      }
+      // print units part
+      if (__d == __db) {
+        *__me++ = __ct.widen('0');
+      } else {
+        unsigned __ng = 0;
+        unsigned __ig = 0;
+        unsigned __gl = __grp.empty() ? numeric_limits<unsigned>::max() : static_cast<unsigned>(__grp[__ig]);
+        while (__d != __db) {
+          if (__ng == __gl) {
+            *__me++ = __ts;
+            __ng    = 0;
+            if (++__ig < __grp.size())
+              __gl = __grp[__ig] == numeric_limits<char>::max()
+                       ? numeric_limits<unsigned>::max()
+                       : static_cast<unsigned>(__grp[__ig]);
+          }
+          *__me++ = *--__d;
+          ++__ng;
         }
+      }
+      // reverse it
+      std::reverse(__t, __me);
+    } break;
     }
-    // print rest of sign, if any
-    if (__sn.size() > 1)
-        __me = _VSTD::copy(__sn.begin()+1, __sn.end(), __me);
-    // set alignment
-    if ((__flags & ios_base::adjustfield) == ios_base::left)
-        __mi = __me;
-    else if ((__flags & ios_base::adjustfield) != ios_base::internal)
-        __mi = __mb;
+  }
+  // print rest of sign, if any
+  if (__sn.size() > 1)
+    __me = std::copy(__sn.begin() + 1, __sn.end(), __me);
+  // set alignment
+  if ((__flags & ios_base::adjustfield) == ios_base::left)
+    __mi = __me;
+  else if ((__flags & ios_base::adjustfield) != ios_base::internal)
+    __mi = __mb;
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS __money_put<wchar_t>;
-#endif
+#  endif
 
 template <class _CharT, class _OutputIterator = ostreambuf_iterator<_CharT> >
-class _LIBCPP_TEMPLATE_VIS money_put
-    : public locale::facet,
-      private __money_put<_CharT>
-{
+class _LIBCPP_TEMPLATE_VIS money_put : public locale::facet, private __money_put<_CharT> {
 public:
-    typedef _CharT                  char_type;
-    typedef _OutputIterator         iter_type;
-    typedef basic_string<char_type> string_type;
+  typedef _CharT char_type;
+  typedef _OutputIterator iter_type;
+  typedef basic_string<char_type> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit money_put(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit money_put(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl,
-                  long double __units) const
-    {
-        return do_put(__s, __intl, __iob, __fl, __units);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, long double __units) const {
+    return do_put(__s, __intl, __iob, __fl, __units);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iter_type put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl,
-                  const string_type& __digits) const
-    {
-        return do_put(__s, __intl, __iob, __fl, __digits);
-    }
+  _LIBCPP_HIDE_FROM_ABI iter_type
+  put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, const string_type& __digits) const {
+    return do_put(__s, __intl, __iob, __fl, __digits);
+  }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~money_put() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~money_put() override {}
 
-    virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob,
-                             char_type __fl, long double __units) const;
-    virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob,
-                             char_type __fl, const string_type& __digits) const;
+  virtual iter_type do_put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, long double __units) const;
+  virtual iter_type
+  do_put(iter_type __s, bool __intl, ios_base& __iob, char_type __fl, const string_type& __digits) const;
 };
 
 template <class _CharT, class _OutputIterator>
-locale::id
-money_put<_CharT, _OutputIterator>::id;
+locale::id money_put<_CharT, _OutputIterator>::id;
 
 template <class _CharT, class _OutputIterator>
-_OutputIterator
-money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
-                                           ios_base& __iob, char_type __fl,
-                                           long double __units) const
-{
-    // convert to char
-    const size_t __bs = 100;
-    char __buf[__bs];
-    char* __bb = __buf;
-    char_type __digits[__bs];
-    char_type* __db = __digits;
-    int __n = snprintf(__bb, __bs, "%.0Lf", __units);
-    unique_ptr<char, void(*)(void*)> __hn(nullptr, free);
-    unique_ptr<char_type, void(*)(void*)> __hd(0, free);
-    // secure memory for digit storage
-    if (static_cast<size_t>(__n) > __bs-1)
-    {
-        __n = __libcpp_asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units);
-        if (__n == -1)
-            __throw_bad_alloc();
-        __hn.reset(__bb);
-        __hd.reset((char_type*)malloc(static_cast<size_t>(__n) * sizeof(char_type)));
-        if (__hd == nullptr)
-            __throw_bad_alloc();
-        __db = __hd.get();
-    }
-    // gather info
-    locale __loc = __iob.getloc();
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
-    __ct.widen(__bb, __bb + __n, __db);
-    bool __neg = __n > 0 && __bb[0] == '-';
-    money_base::pattern __pat;
-    char_type __dp;
-    char_type __ts;
-    string __grp;
-    string_type __sym;
-    string_type __sn;
-    int __fd;
-    this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
-    // secure memory for formatting
-    char_type __mbuf[__bs];
-    char_type* __mb = __mbuf;
-    unique_ptr<char_type, void(*)(void*)> __hw(0, free);
-    size_t __exn = __n > __fd ?
-                   (static_cast<size_t>(__n) - static_cast<size_t>(__fd)) * 2 +
-                    __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 1
-                 : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
-    if (__exn > __bs)
-    {
-        __hw.reset((char_type*)malloc(__exn * sizeof(char_type)));
-        __mb = __hw.get();
-        if (__mb == 0)
-            __throw_bad_alloc();
-    }
-    // format
-    char_type* __mi;
-    char_type* __me;
-    this->__format(__mb, __mi, __me, __iob.flags(),
-                   __db, __db + __n, __ct,
-                   __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
-    return std::__pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
+_OutputIterator money_put<_CharT, _OutputIterator>::do_put(
+    iter_type __s, bool __intl, ios_base& __iob, char_type __fl, long double __units) const {
+  // convert to char
+  const size_t __bs = 100;
+  char __buf[__bs];
+  char* __bb = __buf;
+  char_type __digits[__bs];
+  char_type* __db = __digits;
+  int __n         = snprintf(__bb, __bs, "%.0Lf", __units);
+  unique_ptr<char, void (*)(void*)> __hn(nullptr, free);
+  unique_ptr<char_type, void (*)(void*)> __hd(0, free);
+  // secure memory for digit storage
+  if (static_cast<size_t>(__n) > __bs - 1) {
+    __n = __libcpp_asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units);
+    if (__n == -1)
+      __throw_bad_alloc();
+    __hn.reset(__bb);
+    __hd.reset((char_type*)malloc(static_cast<size_t>(__n) * sizeof(char_type)));
+    if (__hd == nullptr)
+      __throw_bad_alloc();
+    __db = __hd.get();
+  }
+  // gather info
+  locale __loc                 = __iob.getloc();
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
+  __ct.widen(__bb, __bb + __n, __db);
+  bool __neg = __n > 0 && __bb[0] == '-';
+  money_base::pattern __pat;
+  char_type __dp;
+  char_type __ts;
+  string __grp;
+  string_type __sym;
+  string_type __sn;
+  int __fd;
+  this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
+  // secure memory for formatting
+  char_type __mbuf[__bs];
+  char_type* __mb = __mbuf;
+  unique_ptr<char_type, void (*)(void*)> __hw(0, free);
+  size_t __exn = __n > __fd ? (static_cast<size_t>(__n) - static_cast<size_t>(__fd)) * 2 + __sn.size() + __sym.size() +
+                                  static_cast<size_t>(__fd) + 1
+                            : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
+  if (__exn > __bs) {
+    __hw.reset((char_type*)malloc(__exn * sizeof(char_type)));
+    __mb = __hw.get();
+    if (__mb == 0)
+      __throw_bad_alloc();
+  }
+  // format
+  char_type* __mi;
+  char_type* __me;
+  this->__format(
+      __mb, __mi, __me, __iob.flags(), __db, __db + __n, __ct, __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
+  return std::__pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
 }
 
 template <class _CharT, class _OutputIterator>
-_OutputIterator
-money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
-                                           ios_base& __iob, char_type __fl,
-                                           const string_type& __digits) const
-{
-    // gather info
-    locale __loc = __iob.getloc();
-    const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
-    bool __neg = __digits.size() > 0 && __digits[0] == __ct.widen('-');
-    money_base::pattern __pat;
-    char_type __dp;
-    char_type __ts;
-    string __grp;
-    string_type __sym;
-    string_type __sn;
-    int __fd;
-    this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
-    // secure memory for formatting
-    char_type __mbuf[100];
-    char_type* __mb = __mbuf;
-    unique_ptr<char_type, void(*)(void*)> __h(0, free);
-    size_t __exn = static_cast<int>(__digits.size()) > __fd ?
-                   (__digits.size() - static_cast<size_t>(__fd)) * 2 +
-                    __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 1
-                 : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
-    if (__exn > 100)
-    {
-        __h.reset((char_type*)malloc(__exn * sizeof(char_type)));
-        __mb = __h.get();
-        if (__mb == 0)
-            __throw_bad_alloc();
-    }
-    // format
-    char_type* __mi;
-    char_type* __me;
-    this->__format(__mb, __mi, __me, __iob.flags(),
-                   __digits.data(), __digits.data() + __digits.size(), __ct,
-                   __neg, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
-    return std::__pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
+_OutputIterator money_put<_CharT, _OutputIterator>::do_put(
+    iter_type __s, bool __intl, ios_base& __iob, char_type __fl, const string_type& __digits) const {
+  // gather info
+  locale __loc                 = __iob.getloc();
+  const ctype<char_type>& __ct = std::use_facet<ctype<char_type> >(__loc);
+  bool __neg                   = __digits.size() > 0 && __digits[0] == __ct.widen('-');
+  money_base::pattern __pat;
+  char_type __dp;
+  char_type __ts;
+  string __grp;
+  string_type __sym;
+  string_type __sn;
+  int __fd;
+  this->__gather_info(__intl, __neg, __loc, __pat, __dp, __ts, __grp, __sym, __sn, __fd);
+  // secure memory for formatting
+  char_type __mbuf[100];
+  char_type* __mb = __mbuf;
+  unique_ptr<char_type, void (*)(void*)> __h(0, free);
+  size_t __exn =
+      static_cast<int>(__digits.size()) > __fd
+          ? (__digits.size() - static_cast<size_t>(__fd)) * 2 + __sn.size() + __sym.size() + static_cast<size_t>(__fd) +
+                1
+          : __sn.size() + __sym.size() + static_cast<size_t>(__fd) + 2;
+  if (__exn > 100) {
+    __h.reset((char_type*)malloc(__exn * sizeof(char_type)));
+    __mb = __h.get();
+    if (__mb == 0)
+      __throw_bad_alloc();
+  }
+  // format
+  char_type* __mi;
+  char_type* __me;
+  this->__format(
+      __mb,
+      __mi,
+      __me,
+      __iob.flags(),
+      __digits.data(),
+      __digits.data() + __digits.size(),
+      __ct,
+      __neg,
+      __pat,
+      __dp,
+      __ts,
+      __grp,
+      __sym,
+      __sn,
+      __fd);
+  return std::__pad_and_output(__s, __mb, __mi, __me, __iob, __fl);
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS money_put<wchar_t>;
-#endif
+#  endif
 
 // messages
 
-class _LIBCPP_TYPE_VIS messages_base
-{
+class _LIBCPP_EXPORTED_FROM_ABI messages_base {
 public:
-    typedef ptrdiff_t catalog;
+  typedef intptr_t catalog;
 
-    _LIBCPP_INLINE_VISIBILITY messages_base() {}
+  _LIBCPP_HIDE_FROM_ABI messages_base() {}
 };
 
 template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS messages
-    : public locale::facet,
-      public messages_base
-{
+class _LIBCPP_TEMPLATE_VIS messages : public locale::facet, public messages_base {
 public:
-    typedef _CharT               char_type;
-    typedef basic_string<_CharT> string_type;
+  typedef _CharT char_type;
+  typedef basic_string<_CharT> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit messages(size_t __refs = 0)
-        : locale::facet(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit messages(size_t __refs = 0) : locale::facet(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    catalog open(const basic_string<char>& __nm, const locale& __loc) const
-    {
-        return do_open(__nm, __loc);
-    }
+  _LIBCPP_HIDE_FROM_ABI catalog open(const basic_string<char>& __nm, const locale& __loc) const {
+    return do_open(__nm, __loc);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    string_type get(catalog __c, int __set, int __msgid,
-                    const string_type& __dflt) const
-    {
-        return do_get(__c, __set, __msgid, __dflt);
-    }
+  _LIBCPP_HIDE_FROM_ABI string_type get(catalog __c, int __set, int __msgid, const string_type& __dflt) const {
+    return do_get(__c, __set, __msgid, __dflt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void close(catalog __c) const
-    {
-        do_close(__c);
-    }
+  _LIBCPP_HIDE_FROM_ABI void close(catalog __c) const { do_close(__c); }
 
-    static locale::id id;
+  static locale::id id;
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~messages() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~messages() override {}
 
-    virtual catalog do_open(const basic_string<char>&, const locale&) const;
-    virtual string_type do_get(catalog, int __set, int __msgid,
-                               const string_type& __dflt) const;
-    virtual void do_close(catalog) const;
+  virtual catalog do_open(const basic_string<char>&, const locale&) const;
+  virtual string_type do_get(catalog, int __set, int __msgid, const string_type& __dflt) const;
+  virtual void do_close(catalog) const;
 };
 
 template <class _CharT>
-locale::id
-messages<_CharT>::id;
+locale::id messages<_CharT>::id;
 
 template <class _CharT>
-typename messages<_CharT>::catalog
-messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const
-{
-#ifdef _LIBCPP_HAS_CATOPEN
-    catalog __cat = (catalog)catopen(__nm.c_str(), NL_CAT_LOCALE);
-    if (__cat != -1)
-        __cat = static_cast<catalog>((static_cast<size_t>(__cat) >> 1));
-    return __cat;
-#else // !_LIBCPP_HAS_CATOPEN
-    (void)__nm;
-    return -1;
-#endif // _LIBCPP_HAS_CATOPEN
+typename messages<_CharT>::catalog messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const {
+#  ifdef _LIBCPP_HAS_CATOPEN
+  return (catalog)catopen(__nm.c_str(), NL_CAT_LOCALE);
+#  else  // !_LIBCPP_HAS_CATOPEN
+  (void)__nm;
+  return -1;
+#  endif // _LIBCPP_HAS_CATOPEN
 }
 
 template <class _CharT>
 typename messages<_CharT>::string_type
-messages<_CharT>::do_get(catalog __c, int __set, int __msgid,
-                         const string_type& __dflt) const
-{
-#ifdef _LIBCPP_HAS_CATOPEN
-    string __ndflt;
-    __narrow_to_utf8<sizeof(char_type)*__CHAR_BIT__>()(std::back_inserter(__ndflt),
-                                                       __dflt.c_str(),
-                                                       __dflt.c_str() + __dflt.size());
-    if (__c != -1)
-        __c <<= 1;
-    nl_catd __cat = (nl_catd)__c;
-    char* __n = catgets(__cat, __set, __msgid, __ndflt.c_str());
-    string_type __w;
-    __widen_from_utf8<sizeof(char_type)*__CHAR_BIT__>()(std::back_inserter(__w),
-                                                        __n, __n + _VSTD::strlen(__n));
-    return __w;
-#else // !_LIBCPP_HAS_CATOPEN
-    (void)__c;
-    (void)__set;
-    (void)__msgid;
-    return __dflt;
-#endif // _LIBCPP_HAS_CATOPEN
+messages<_CharT>::do_get(catalog __c, int __set, int __msgid, const string_type& __dflt) const {
+#  ifdef _LIBCPP_HAS_CATOPEN
+  string __ndflt;
+  __narrow_to_utf8<sizeof(char_type) * __CHAR_BIT__>()(
+      std::back_inserter(__ndflt), __dflt.c_str(), __dflt.c_str() + __dflt.size());
+  nl_catd __cat = (nl_catd)__c;
+  static_assert(sizeof(catalog) >= sizeof(nl_catd), "Unexpected nl_catd type");
+  char* __n = catgets(__cat, __set, __msgid, __ndflt.c_str());
+  string_type __w;
+  __widen_from_utf8<sizeof(char_type) * __CHAR_BIT__>()(std::back_inserter(__w), __n, __n + std::strlen(__n));
+  return __w;
+#  else  // !_LIBCPP_HAS_CATOPEN
+  (void)__c;
+  (void)__set;
+  (void)__msgid;
+  return __dflt;
+#  endif // _LIBCPP_HAS_CATOPEN
 }
 
 template <class _CharT>
-void
-messages<_CharT>::do_close(catalog __c) const
-{
-#ifdef _LIBCPP_HAS_CATOPEN
-    if (__c != -1)
-        __c <<= 1;
-    nl_catd __cat = (nl_catd)__c;
-    catclose(__cat);
-#else // !_LIBCPP_HAS_CATOPEN
-    (void)__c;
-#endif // _LIBCPP_HAS_CATOPEN
+void messages<_CharT>::do_close(catalog __c) const {
+#  ifdef _LIBCPP_HAS_CATOPEN
+  catclose((nl_catd)__c);
+#  else  // !_LIBCPP_HAS_CATOPEN
+  (void)__c;
+#  endif // _LIBCPP_HAS_CATOPEN
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages<wchar_t>;
-#endif
+#  endif
 
 template <class _CharT>
-class _LIBCPP_TEMPLATE_VIS messages_byname
-    : public messages<_CharT>
-{
+class _LIBCPP_TEMPLATE_VIS messages_byname : public messages<_CharT> {
 public:
-    typedef messages_base::catalog catalog;
-    typedef basic_string<_CharT> string_type;
+  typedef messages_base::catalog catalog;
+  typedef basic_string<_CharT> string_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit messages_byname(const char*, size_t __refs = 0)
-        : messages<_CharT>(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit messages_byname(const char*, size_t __refs = 0) : messages<_CharT>(__refs) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit messages_byname(const string&, size_t __refs = 0)
-        : messages<_CharT>(__refs) {}
+  _LIBCPP_HIDE_FROM_ABI explicit messages_byname(const string&, size_t __refs = 0) : messages<_CharT>(__refs) {}
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~messages_byname() override {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL ~messages_byname() override {}
 };
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS messages_byname<wchar_t>;
-#endif
+#  endif
 
-template<class _Codecvt, class _Elem = wchar_t,
-         class _Wide_alloc = allocator<_Elem>,
-         class _Byte_alloc = allocator<char> >
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wstring_convert
-{
+#  if _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_WSTRING_CONVERT)
+
+template <class _Codecvt,
+          class _Elem      = wchar_t,
+          class _WideAlloc = allocator<_Elem>,
+          class _ByteAlloc = allocator<char> >
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wstring_convert {
 public:
-    typedef basic_string<char, char_traits<char>, _Byte_alloc>   byte_string;
-    typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
-    typedef typename _Codecvt::state_type                        state_type;
-    typedef typename wide_string::traits_type::int_type          int_type;
+  typedef basic_string<char, char_traits<char>, _ByteAlloc> byte_string;
+  typedef basic_string<_Elem, char_traits<_Elem>, _WideAlloc> wide_string;
+  typedef typename _Codecvt::state_type state_type;
+  typedef typename wide_string::traits_type::int_type int_type;
 
 private:
-    byte_string __byte_err_string_;
-    wide_string __wide_err_string_;
-    _Codecvt* __cvtptr_;
-    state_type __cvtstate_;
-    size_t __cvtcount_;
+  byte_string __byte_err_string_;
+  wide_string __wide_err_string_;
+  _Codecvt* __cvtptr_;
+  state_type __cvtstate_;
+  size_t __cvtcount_;
 
-    wstring_convert(const wstring_convert& __wc);
-    wstring_convert& operator=(const wstring_convert& __wc);
 public:
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    wstring_convert() : wstring_convert(new _Codecvt) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit wstring_convert(_Codecvt* __pcvt);
-#else
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_EXPLICIT_SINCE_CXX14
-    wstring_convert(_Codecvt* __pcvt = new _Codecvt);
-#endif
+#    ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI wstring_convert() : wstring_convert(new _Codecvt) {}
+  _LIBCPP_HIDE_FROM_ABI explicit wstring_convert(_Codecvt* __pcvt);
+#    else
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_EXPLICIT_SINCE_CXX14 wstring_convert(_Codecvt* __pcvt = new _Codecvt);
+#    endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    wstring_convert(_Codecvt* __pcvt, state_type __state);
-    _LIBCPP_EXPLICIT_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI wstring_convert(const byte_string& __byte_err,
-                    const wide_string& __wide_err = wide_string());
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    wstring_convert(wstring_convert&& __wc);
-#endif
-    _LIBCPP_HIDE_FROM_ABI ~wstring_convert();
+  _LIBCPP_HIDE_FROM_ABI wstring_convert(_Codecvt* __pcvt, state_type __state);
+  _LIBCPP_EXPLICIT_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+  wstring_convert(const byte_string& __byte_err, const wide_string& __wide_err = wide_string());
+#    ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI wstring_convert(wstring_convert&& __wc);
+#    endif
+  _LIBCPP_HIDE_FROM_ABI ~wstring_convert();
 
-    _LIBCPP_INLINE_VISIBILITY
-    wide_string from_bytes(char __byte)
-        {return from_bytes(&__byte, &__byte+1);}
-    _LIBCPP_INLINE_VISIBILITY
-    wide_string from_bytes(const char* __ptr)
-        {return from_bytes(__ptr, __ptr + char_traits<char>::length(__ptr));}
-    _LIBCPP_INLINE_VISIBILITY
-    wide_string from_bytes(const byte_string& __str)
-        {return from_bytes(__str.data(), __str.data() + __str.size());}
-    _LIBCPP_HIDE_FROM_ABI wide_string from_bytes(const char* __first, const char* __last);
+  wstring_convert(const wstring_convert& __wc)            = delete;
+  wstring_convert& operator=(const wstring_convert& __wc) = delete;
 
-    _LIBCPP_INLINE_VISIBILITY
-    byte_string to_bytes(_Elem __wchar)
-        {return to_bytes(&__wchar, &__wchar+1);}
-    _LIBCPP_INLINE_VISIBILITY
-    byte_string to_bytes(const _Elem* __wptr)
-        {return to_bytes(__wptr, __wptr + char_traits<_Elem>::length(__wptr));}
-    _LIBCPP_INLINE_VISIBILITY
-    byte_string to_bytes(const wide_string& __wstr)
-        {return to_bytes(__wstr.data(), __wstr.data() + __wstr.size());}
-    _LIBCPP_HIDE_FROM_ABI byte_string to_bytes(const _Elem* __first, const _Elem* __last);
+  _LIBCPP_HIDE_FROM_ABI wide_string from_bytes(char __byte) { return from_bytes(&__byte, &__byte + 1); }
+  _LIBCPP_HIDE_FROM_ABI wide_string from_bytes(const char* __ptr) {
+    return from_bytes(__ptr, __ptr + char_traits<char>::length(__ptr));
+  }
+  _LIBCPP_HIDE_FROM_ABI wide_string from_bytes(const byte_string& __str) {
+    return from_bytes(__str.data(), __str.data() + __str.size());
+  }
+  _LIBCPP_HIDE_FROM_ABI wide_string from_bytes(const char* __first, const char* __last);
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t converted() const _NOEXCEPT {return __cvtcount_;}
-    _LIBCPP_INLINE_VISIBILITY
-    state_type state() const {return __cvtstate_;}
+  _LIBCPP_HIDE_FROM_ABI byte_string to_bytes(_Elem __wchar) { return to_bytes(&__wchar, &__wchar + 1); }
+  _LIBCPP_HIDE_FROM_ABI byte_string to_bytes(const _Elem* __wptr) {
+    return to_bytes(__wptr, __wptr + char_traits<_Elem>::length(__wptr));
+  }
+  _LIBCPP_HIDE_FROM_ABI byte_string to_bytes(const wide_string& __wstr) {
+    return to_bytes(__wstr.data(), __wstr.data() + __wstr.size());
+  }
+  _LIBCPP_HIDE_FROM_ABI byte_string to_bytes(const _Elem* __first, const _Elem* __last);
+
+  _LIBCPP_HIDE_FROM_ABI size_t converted() const _NOEXCEPT { return __cvtcount_; }
+  _LIBCPP_HIDE_FROM_ABI state_type state() const { return __cvtstate_; }
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-inline
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
-    wstring_convert(_Codecvt* __pcvt)
-        : __cvtptr_(__pcvt), __cvtstate_(), __cvtcount_(0)
-{
-}
+template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+inline wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wstring_convert(_Codecvt* __pcvt)
+    : __cvtptr_(__pcvt), __cvtstate_(), __cvtcount_(0) {}
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-inline
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
-    wstring_convert(_Codecvt* __pcvt, state_type __state)
-        : __cvtptr_(__pcvt), __cvtstate_(__state), __cvtcount_(0)
-{
+template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+inline wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wstring_convert(_Codecvt* __pcvt, state_type __state)
+    : __cvtptr_(__pcvt), __cvtstate_(__state), __cvtcount_(0) {}
+
+template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wstring_convert(
+    const byte_string& __byte_err, const wide_string& __wide_err)
+    : __byte_err_string_(__byte_err), __wide_err_string_(__wide_err), __cvtstate_(), __cvtcount_(0) {
+  __cvtptr_ = new _Codecvt;
 }
 
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
-    wstring_convert(const byte_string& __byte_err, const wide_string& __wide_err)
-        : __byte_err_string_(__byte_err), __wide_err_string_(__wide_err),
-          __cvtstate_(), __cvtcount_(0)
-{
-    __cvtptr_ = new _Codecvt;
+#    ifndef _LIBCPP_CXX03_LANG
+
+template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+inline wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wstring_convert(wstring_convert&& __wc)
+    : __byte_err_string_(std::move(__wc.__byte_err_string_)),
+      __wide_err_string_(std::move(__wc.__wide_err_string_)),
+      __cvtptr_(__wc.__cvtptr_),
+      __cvtstate_(__wc.__cvtstate_),
+      __cvtcount_(__wc.__cvtcount_) {
+  __wc.__cvtptr_ = nullptr;
 }
 
-#ifndef _LIBCPP_CXX03_LANG
-
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-inline
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
-    wstring_convert(wstring_convert&& __wc)
-        : __byte_err_string_(_VSTD::move(__wc.__byte_err_string_)),
-          __wide_err_string_(_VSTD::move(__wc.__wide_err_string_)),
-          __cvtptr_(__wc.__cvtptr_),
-          __cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtcount_)
-{
-    __wc.__cvtptr_ = nullptr;
-}
-
-#endif // _LIBCPP_CXX03_LANG
+#    endif // _LIBCPP_CXX03_LANG
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::~wstring_convert()
-{
-    delete __cvtptr_;
+template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::~wstring_convert() {
+  delete __cvtptr_;
 }
 
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-typename wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::wide_string
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
-    from_bytes(const char* __frm, const char* __frm_end)
-{
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-    __cvtcount_ = 0;
-    if (__cvtptr_ != nullptr)
-    {
-        wide_string __ws(2*(__frm_end - __frm), _Elem());
-        if (__frm != __frm_end)
-            __ws.resize(__ws.capacity());
-        codecvt_base::result __r = codecvt_base::ok;
-        state_type __st = __cvtstate_;
-        if (__frm != __frm_end)
-        {
-            _Elem* __to = &__ws[0];
-            _Elem* __to_end = __to + __ws.size();
-            const char* __frm_nxt;
-            do
-            {
-                _Elem* __to_nxt;
-                __r = __cvtptr_->in(__st, __frm, __frm_end, __frm_nxt,
-                                          __to, __to_end, __to_nxt);
-                __cvtcount_ += __frm_nxt - __frm;
-                if (__frm_nxt == __frm)
-                {
-                    __r = codecvt_base::error;
-                }
-                else if (__r == codecvt_base::noconv)
-                {
-                    __ws.resize(__to - &__ws[0]);
-                    // This only gets executed if _Elem is char
-                    __ws.append((const _Elem*)__frm, (const _Elem*)__frm_end);
-                    __frm = __frm_nxt;
-                    __r = codecvt_base::ok;
-                }
-                else if (__r == codecvt_base::ok)
-                {
-                    __ws.resize(__to_nxt - &__ws[0]);
-                    __frm = __frm_nxt;
-                }
-                else if (__r == codecvt_base::partial)
-                {
-                    ptrdiff_t __s = __to_nxt - &__ws[0];
-                    __ws.resize(2 * __s);
-                    __to = &__ws[0] + __s;
-                    __to_end = &__ws[0] + __ws.size();
-                    __frm = __frm_nxt;
-                }
-            } while (__r == codecvt_base::partial && __frm_nxt < __frm_end);
+template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+typename wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::wide_string
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::from_bytes(const char* __frm, const char* __frm_end) {
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+  __cvtcount_ = 0;
+  if (__cvtptr_ != nullptr) {
+    wide_string __ws(2 * (__frm_end - __frm), _Elem());
+    if (__frm != __frm_end)
+      __ws.resize(__ws.capacity());
+    codecvt_base::result __r = codecvt_base::ok;
+    state_type __st          = __cvtstate_;
+    if (__frm != __frm_end) {
+      _Elem* __to     = &__ws[0];
+      _Elem* __to_end = __to + __ws.size();
+      const char* __frm_nxt;
+      do {
+        _Elem* __to_nxt;
+        __r = __cvtptr_->in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+        __cvtcount_ += __frm_nxt - __frm;
+        if (__frm_nxt == __frm) {
+          __r = codecvt_base::error;
+        } else if (__r == codecvt_base::noconv) {
+          __ws.resize(__to - &__ws[0]);
+          // This only gets executed if _Elem is char
+          __ws.append((const _Elem*)__frm, (const _Elem*)__frm_end);
+          __frm = __frm_nxt;
+          __r   = codecvt_base::ok;
+        } else if (__r == codecvt_base::ok) {
+          __ws.resize(__to_nxt - &__ws[0]);
+          __frm = __frm_nxt;
+        } else if (__r == codecvt_base::partial) {
+          ptrdiff_t __s = __to_nxt - &__ws[0];
+          __ws.resize(2 * __s);
+          __to     = &__ws[0] + __s;
+          __to_end = &__ws[0] + __ws.size();
+          __frm    = __frm_nxt;
         }
-        if (__r == codecvt_base::ok)
-            return __ws;
+      } while (__r == codecvt_base::partial && __frm_nxt < __frm_end);
     }
+    if (__r == codecvt_base::ok)
+      return __ws;
+  }
 
-    if (__wide_err_string_.empty())
-        __throw_range_error("wstring_convert: from_bytes error");
+  if (__wide_err_string_.empty())
+    __throw_range_error("wstring_convert: from_bytes error");
 
-    return __wide_err_string_;
+  return __wide_err_string_;
 }
 
-template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
-typename wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::byte_string
-wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
-    to_bytes(const _Elem* __frm, const _Elem* __frm_end)
-{
-    __cvtcount_ = 0;
-    if (__cvtptr_ != nullptr)
-    {
-        byte_string __bs(2*(__frm_end - __frm), char());
-        if (__frm != __frm_end)
-            __bs.resize(__bs.capacity());
-        codecvt_base::result __r = codecvt_base::ok;
-        state_type __st = __cvtstate_;
-        if (__frm != __frm_end)
-        {
-            char* __to = &__bs[0];
-            char* __to_end = __to + __bs.size();
-            const _Elem* __frm_nxt;
-            do
-            {
-                char* __to_nxt;
-                __r = __cvtptr_->out(__st, __frm, __frm_end, __frm_nxt,
-                                           __to, __to_end, __to_nxt);
-                __cvtcount_ += __frm_nxt - __frm;
-                if (__frm_nxt == __frm)
-                {
-                    __r = codecvt_base::error;
-                }
-                else if (__r == codecvt_base::noconv)
-                {
-                    __bs.resize(__to - &__bs[0]);
-                    // This only gets executed if _Elem is char
-                    __bs.append((const char*)__frm, (const char*)__frm_end);
-                    __frm = __frm_nxt;
-                    __r = codecvt_base::ok;
-                }
-                else if (__r == codecvt_base::ok)
-                {
-                    __bs.resize(__to_nxt - &__bs[0]);
-                    __frm = __frm_nxt;
-                }
-                else if (__r == codecvt_base::partial)
-                {
-                    ptrdiff_t __s = __to_nxt - &__bs[0];
-                    __bs.resize(2 * __s);
-                    __to = &__bs[0] + __s;
-                    __to_end = &__bs[0] + __bs.size();
-                    __frm = __frm_nxt;
-                }
-            } while (__r == codecvt_base::partial && __frm_nxt < __frm_end);
-        }
-        if (__r == codecvt_base::ok)
-        {
-            size_t __s = __bs.size();
-            __bs.resize(__bs.capacity());
-            char* __to = &__bs[0] + __s;
-            char* __to_end = __to + __bs.size();
-            do
-            {
-                char* __to_nxt;
-                __r = __cvtptr_->unshift(__st, __to, __to_end, __to_nxt);
-                if (__r == codecvt_base::noconv)
-                {
-                    __bs.resize(__to - &__bs[0]);
-                    __r = codecvt_base::ok;
-                }
-                else if (__r == codecvt_base::ok)
-                {
-                    __bs.resize(__to_nxt - &__bs[0]);
-                }
-                else if (__r == codecvt_base::partial)
-                {
-                    ptrdiff_t __sp = __to_nxt - &__bs[0];
-                    __bs.resize(2 * __sp);
-                    __to = &__bs[0] + __sp;
-                    __to_end = &__bs[0] + __bs.size();
-                }
-            } while (__r == codecvt_base::partial);
-            if (__r == codecvt_base::ok)
-                return __bs;
+template <class _Codecvt, class _Elem, class _WideAlloc, class _ByteAlloc>
+typename wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::byte_string
+wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::to_bytes(const _Elem* __frm, const _Elem* __frm_end) {
+  __cvtcount_ = 0;
+  if (__cvtptr_ != nullptr) {
+    byte_string __bs(2 * (__frm_end - __frm), char());
+    if (__frm != __frm_end)
+      __bs.resize(__bs.capacity());
+    codecvt_base::result __r = codecvt_base::ok;
+    state_type __st          = __cvtstate_;
+    if (__frm != __frm_end) {
+      char* __to     = &__bs[0];
+      char* __to_end = __to + __bs.size();
+      const _Elem* __frm_nxt;
+      do {
+        char* __to_nxt;
+        __r = __cvtptr_->out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+        __cvtcount_ += __frm_nxt - __frm;
+        if (__frm_nxt == __frm) {
+          __r = codecvt_base::error;
+        } else if (__r == codecvt_base::noconv) {
+          __bs.resize(__to - &__bs[0]);
+          // This only gets executed if _Elem is char
+          __bs.append((const char*)__frm, (const char*)__frm_end);
+          __frm = __frm_nxt;
+          __r   = codecvt_base::ok;
+        } else if (__r == codecvt_base::ok) {
+          __bs.resize(__to_nxt - &__bs[0]);
+          __frm = __frm_nxt;
+        } else if (__r == codecvt_base::partial) {
+          ptrdiff_t __s = __to_nxt - &__bs[0];
+          __bs.resize(2 * __s);
+          __to     = &__bs[0] + __s;
+          __to_end = &__bs[0] + __bs.size();
+          __frm    = __frm_nxt;
         }
+      } while (__r == codecvt_base::partial && __frm_nxt < __frm_end);
     }
+    if (__r == codecvt_base::ok) {
+      size_t __s = __bs.size();
+      __bs.resize(__bs.capacity());
+      char* __to     = &__bs[0] + __s;
+      char* __to_end = __to + __bs.size();
+      do {
+        char* __to_nxt;
+        __r = __cvtptr_->unshift(__st, __to, __to_end, __to_nxt);
+        if (__r == codecvt_base::noconv) {
+          __bs.resize(__to - &__bs[0]);
+          __r = codecvt_base::ok;
+        } else if (__r == codecvt_base::ok) {
+          __bs.resize(__to_nxt - &__bs[0]);
+        } else if (__r == codecvt_base::partial) {
+          ptrdiff_t __sp = __to_nxt - &__bs[0];
+          __bs.resize(2 * __sp);
+          __to     = &__bs[0] + __sp;
+          __to_end = &__bs[0] + __bs.size();
+        }
+      } while (__r == codecvt_base::partial);
+      if (__r == codecvt_base::ok)
+        return __bs;
+    }
+  }
 
-    if (__byte_err_string_.empty())
-        __throw_range_error("wstring_convert: to_bytes error");
+  if (__byte_err_string_.empty())
+    __throw_range_error("wstring_convert: to_bytes error");
 
-    return __byte_err_string_;
+  return __byte_err_string_;
 }
 
 template <class _Codecvt, class _Elem = wchar_t, class _Tr = char_traits<_Elem> >
-class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wbuffer_convert
-    : public basic_streambuf<_Elem, _Tr>
-{
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 wbuffer_convert : public basic_streambuf<_Elem, _Tr> {
 public:
-    // types:
-    typedef _Elem                          char_type;
-    typedef _Tr                            traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
-    typedef typename _Codecvt::state_type  state_type;
+  // types:
+  typedef _Elem char_type;
+  typedef _Tr traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+  typedef typename _Codecvt::state_type state_type;
 
 private:
-    char*       __extbuf_;
-    const char* __extbufnext_;
-    const char* __extbufend_;
-    char __extbuf_min_[8];
-    size_t __ebs_;
-    char_type* __intbuf_;
-    size_t __ibs_;
-    streambuf* __bufptr_;
-    _Codecvt* __cv_;
-    state_type __st_;
-    ios_base::openmode __cm_;
-    bool __owns_eb_;
-    bool __owns_ib_;
-    bool __always_noconv_;
-
-    wbuffer_convert(const wbuffer_convert&);
-    wbuffer_convert& operator=(const wbuffer_convert&);
+  char* __extbuf_;
+  const char* __extbufnext_;
+  const char* __extbufend_;
+  char __extbuf_min_[8];
+  size_t __ebs_;
+  char_type* __intbuf_;
+  size_t __ibs_;
+  streambuf* __bufptr_;
+  _Codecvt* __cv_;
+  state_type __st_;
+  ios_base::openmode __cm_;
+  bool __owns_eb_;
+  bool __owns_ib_;
+  bool __always_noconv_;
 
 public:
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI wbuffer_convert() : wbuffer_convert(nullptr) {}
-    explicit _LIBCPP_HIDE_FROM_ABI wbuffer_convert(streambuf* __bytebuf,
-                             _Codecvt* __pcvt = new _Codecvt,
-                             state_type __state = state_type());
-#else
-    _LIBCPP_EXPLICIT_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
-    wbuffer_convert(streambuf* __bytebuf = nullptr,
-                    _Codecvt* __pcvt = new _Codecvt,
-                    state_type __state = state_type());
-#endif
+#    ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI wbuffer_convert() : wbuffer_convert(nullptr) {}
+  explicit _LIBCPP_HIDE_FROM_ABI
+  wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt = new _Codecvt, state_type __state = state_type());
+#    else
+  _LIBCPP_EXPLICIT_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI
+  wbuffer_convert(streambuf* __bytebuf = nullptr, _Codecvt* __pcvt = new _Codecvt, state_type __state = state_type());
+#    endif
 
-    _LIBCPP_HIDE_FROM_ABI ~wbuffer_convert();
+  _LIBCPP_HIDE_FROM_ABI ~wbuffer_convert();
 
-    _LIBCPP_INLINE_VISIBILITY
-    streambuf* rdbuf() const {return __bufptr_;}
-    _LIBCPP_INLINE_VISIBILITY
-    streambuf* rdbuf(streambuf* __bytebuf)
-    {
-        streambuf* __r = __bufptr_;
-        __bufptr_ = __bytebuf;
-        return __r;
-    }
+  _LIBCPP_HIDE_FROM_ABI streambuf* rdbuf() const { return __bufptr_; }
+  _LIBCPP_HIDE_FROM_ABI streambuf* rdbuf(streambuf* __bytebuf) {
+    streambuf* __r = __bufptr_;
+    __bufptr_      = __bytebuf;
+    return __r;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    state_type state() const {return __st_;}
+  wbuffer_convert(const wbuffer_convert&)            = delete;
+  wbuffer_convert& operator=(const wbuffer_convert&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI state_type state() const { return __st_; }
 
 protected:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int_type underflow();
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int_type pbackfail(int_type __c = traits_type::eof());
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int_type overflow (int_type __c = traits_type::eof());
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s,
-                                                            streamsize __n);
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
-                             ios_base::openmode __wch = ios_base::in | ios_base::out);
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual pos_type seekpos(pos_type __sp,
-                             ios_base::openmode __wch = ios_base::in | ios_base::out);
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int sync();
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int_type underflow();
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int_type pbackfail(int_type __c = traits_type::eof());
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int_type overflow(int_type __c = traits_type::eof());
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual basic_streambuf<char_type, traits_type>* setbuf(char_type* __s, streamsize __n);
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual pos_type
+  seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __wch = ios_base::in | ios_base::out);
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual pos_type
+  seekpos(pos_type __sp, ios_base::openmode __wch = ios_base::in | ios_base::out);
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual int sync();
 
 private:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL bool __read_mode();
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __write_mode();
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL wbuffer_convert* __close();
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL bool __read_mode();
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __write_mode();
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL wbuffer_convert* __close();
 };
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Codecvt, class _Elem, class _Tr>
-wbuffer_convert<_Codecvt, _Elem, _Tr>::
-    wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt, state_type __state)
+wbuffer_convert<_Codecvt, _Elem, _Tr>::wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt, state_type __state)
     : __extbuf_(nullptr),
       __extbufnext_(nullptr),
       __extbufend_(nullptr),
@@ -3964,404 +3431,330 @@ wbuffer_convert<_Codecvt, _Elem, _Tr>::
       __cm_(0),
       __owns_eb_(false),
       __owns_ib_(false),
-      __always_noconv_(__cv_ ? __cv_->always_noconv() : false)
-{
-    setbuf(0, 4096);
+      __always_noconv_(__cv_ ? __cv_->always_noconv() : false) {
+  setbuf(0, 4096);
 }
 
 template <class _Codecvt, class _Elem, class _Tr>
-wbuffer_convert<_Codecvt, _Elem, _Tr>::~wbuffer_convert()
-{
-    __close();
-    delete __cv_;
-    if (__owns_eb_)
-        delete [] __extbuf_;
-    if (__owns_ib_)
-        delete [] __intbuf_;
+wbuffer_convert<_Codecvt, _Elem, _Tr>::~wbuffer_convert() {
+  __close();
+  delete __cv_;
+  if (__owns_eb_)
+    delete[] __extbuf_;
+  if (__owns_ib_)
+    delete[] __intbuf_;
 }
 
 template <class _Codecvt, class _Elem, class _Tr>
-typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
-wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow()
-{
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-    if (__cv_ == 0 || __bufptr_ == 0)
-        return traits_type::eof();
-    bool __initial = __read_mode();
-    char_type __1buf;
-    if (this->gptr() == 0)
-        this->setg(&__1buf, &__1buf+1, &__1buf+1);
-    const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4);
-    int_type __c = traits_type::eof();
-    if (this->gptr() == this->egptr())
-    {
-        _VSTD::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
-        if (__always_noconv_)
-        {
-            streamsize __nmemb = static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz);
-            __nmemb = __bufptr_->sgetn((char*)this->eback() + __unget_sz, __nmemb);
-            if (__nmemb != 0)
-            {
-                this->setg(this->eback(),
-                           this->eback() + __unget_sz,
-                           this->eback() + __unget_sz + __nmemb);
-                __c = *this->gptr();
-            }
-        }
-        else
-        {
-             if (__extbufend_ != __extbufnext_) {
-                _LIBCPP_ASSERT(__extbufnext_ != nullptr, "underflow moving from nullptr");
-                _LIBCPP_ASSERT(__extbuf_ != nullptr, "underflow moving into nullptr");
-                _VSTD::memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
-             }
-            __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
-            __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
-            streamsize __nmemb = _VSTD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
-                                 static_cast<streamsize>(__extbufend_ - __extbufnext_));
-            codecvt_base::result __r;
-            // FIXME: Do we ever need to restore the state here?
-            //state_type __svs = __st_;
-            streamsize __nr = __bufptr_->sgetn(const_cast<char*>(__extbufnext_), __nmemb);
-            if (__nr != 0)
-            {
-                __extbufend_ = __extbufnext_ + __nr;
-                char_type*  __inext;
-                __r = __cv_->in(__st_, __extbuf_, __extbufend_, __extbufnext_,
-                                       this->eback() + __unget_sz,
-                                       this->egptr(), __inext);
-                if (__r == codecvt_base::noconv)
-                {
-                    this->setg((char_type*)__extbuf_, (char_type*)__extbuf_,
-                               (char_type*) const_cast<char *>(__extbufend_));
-                    __c = *this->gptr();
-                }
-                else if (__inext != this->eback() + __unget_sz)
-                {
-                    this->setg(this->eback(), this->eback() + __unget_sz, __inext);
-                    __c = *this->gptr();
-                }
-            }
-        }
-    }
-    else
-        __c = *this->gptr();
-    if (this->eback() == &__1buf)
-        this->setg(0, 0, 0);
-    return __c;
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-template <class _Codecvt, class _Elem, class _Tr>
-typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
-wbuffer_convert<_Codecvt, _Elem, _Tr>::pbackfail(int_type __c)
-{
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-    if (__cv_ != 0 && __bufptr_ != 0 && this->eback() < this->gptr())
-    {
-        if (traits_type::eq_int_type(__c, traits_type::eof()))
-        {
-            this->gbump(-1);
-            return traits_type::not_eof(__c);
-        }
-        if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
-        {
-            this->gbump(-1);
-            *this->gptr() = traits_type::to_char_type(__c);
-            return __c;
-        }
-    }
+typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow() {
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+  if (__cv_ == 0 || __bufptr_ == nullptr)
     return traits_type::eof();
+  bool __initial = __read_mode();
+  char_type __1buf;
+  if (this->gptr() == 0)
+    this->setg(&__1buf, &__1buf + 1, &__1buf + 1);
+  const size_t __unget_sz = __initial ? 0 : std::min<size_t>((this->egptr() - this->eback()) / 2, 4);
+  int_type __c            = traits_type::eof();
+  if (this->gptr() == this->egptr()) {
+    std::memmove(this->eback(), this->egptr() - __unget_sz, __unget_sz * sizeof(char_type));
+    if (__always_noconv_) {
+      streamsize __nmemb = static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz);
+      __nmemb            = __bufptr_->sgetn((char*)this->eback() + __unget_sz, __nmemb);
+      if (__nmemb != 0) {
+        this->setg(this->eback(), this->eback() + __unget_sz, this->eback() + __unget_sz + __nmemb);
+        __c = *this->gptr();
+      }
+    } else {
+      if (__extbufend_ != __extbufnext_) {
+        _LIBCPP_ASSERT_NON_NULL(__extbufnext_ != nullptr, "underflow moving from nullptr");
+        _LIBCPP_ASSERT_NON_NULL(__extbuf_ != nullptr, "underflow moving into nullptr");
+        std::memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
+      }
+      __extbufnext_      = __extbuf_ + (__extbufend_ - __extbufnext_);
+      __extbufend_       = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
+      streamsize __nmemb = std::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
+                                    static_cast<streamsize>(__extbufend_ - __extbufnext_));
+      codecvt_base::result __r;
+      // FIXME: Do we ever need to restore the state here?
+      // state_type __svs = __st_;
+      streamsize __nr = __bufptr_->sgetn(const_cast<char*>(__extbufnext_), __nmemb);
+      if (__nr != 0) {
+        __extbufend_ = __extbufnext_ + __nr;
+        char_type* __inext;
+        __r = __cv_->in(
+            __st_, __extbuf_, __extbufend_, __extbufnext_, this->eback() + __unget_sz, this->egptr(), __inext);
+        if (__r == codecvt_base::noconv) {
+          this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, (char_type*)const_cast<char*>(__extbufend_));
+          __c = *this->gptr();
+        } else if (__inext != this->eback() + __unget_sz) {
+          this->setg(this->eback(), this->eback() + __unget_sz, __inext);
+          __c = *this->gptr();
+        }
+      }
+    }
+  } else
+    __c = *this->gptr();
+  if (this->eback() == &__1buf)
+    this->setg(0, 0, 0);
+  return __c;
 }
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Codecvt, class _Elem, class _Tr>
 typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type
-wbuffer_convert<_Codecvt, _Elem, _Tr>::overflow(int_type __c)
-{
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-    if (__cv_ == 0 || __bufptr_ == 0)
+wbuffer_convert<_Codecvt, _Elem, _Tr>::pbackfail(int_type __c) {
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+  if (__cv_ != 0 && __bufptr_ && this->eback() < this->gptr()) {
+    if (traits_type::eq_int_type(__c, traits_type::eof())) {
+      this->gbump(-1);
+      return traits_type::not_eof(__c);
+    }
+    if (traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) {
+      this->gbump(-1);
+      *this->gptr() = traits_type::to_char_type(__c);
+      return __c;
+    }
+  }
+  return traits_type::eof();
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+template <class _Codecvt, class _Elem, class _Tr>
+typename wbuffer_convert<_Codecvt, _Elem, _Tr>::int_type wbuffer_convert<_Codecvt, _Elem, _Tr>::overflow(int_type __c) {
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+  if (__cv_ == 0 || !__bufptr_)
+    return traits_type::eof();
+  __write_mode();
+  char_type __1buf;
+  char_type* __pb_save  = this->pbase();
+  char_type* __epb_save = this->epptr();
+  if (!traits_type::eq_int_type(__c, traits_type::eof())) {
+    if (this->pptr() == 0)
+      this->setp(&__1buf, &__1buf + 1);
+    *this->pptr() = traits_type::to_char_type(__c);
+    this->pbump(1);
+  }
+  if (this->pptr() != this->pbase()) {
+    if (__always_noconv_) {
+      streamsize __nmemb = static_cast<streamsize>(this->pptr() - this->pbase());
+      if (__bufptr_->sputn((const char*)this->pbase(), __nmemb) != __nmemb)
         return traits_type::eof();
-    __write_mode();
-    char_type __1buf;
-    char_type* __pb_save = this->pbase();
-    char_type* __epb_save = this->epptr();
-    if (!traits_type::eq_int_type(__c, traits_type::eof()))
-    {
-        if (this->pptr() == 0)
-            this->setp(&__1buf, &__1buf+1);
-        *this->pptr() = traits_type::to_char_type(__c);
-        this->pbump(1);
+    } else {
+      char* __extbe = __extbuf_;
+      codecvt_base::result __r;
+      do {
+        const char_type* __e;
+        __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, __extbuf_, __extbuf_ + __ebs_, __extbe);
+        if (__e == this->pbase())
+          return traits_type::eof();
+        if (__r == codecvt_base::noconv) {
+          streamsize __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
+          if (__bufptr_->sputn((const char*)this->pbase(), __nmemb) != __nmemb)
+            return traits_type::eof();
+        } else if (__r == codecvt_base::ok || __r == codecvt_base::partial) {
+          streamsize __nmemb = static_cast<size_t>(__extbe - __extbuf_);
+          if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb)
+            return traits_type::eof();
+          if (__r == codecvt_base::partial) {
+            this->setp(const_cast<char_type*>(__e), this->pptr());
+            this->__pbump(this->epptr() - this->pbase());
+          }
+        } else
+          return traits_type::eof();
+      } while (__r == codecvt_base::partial);
     }
-    if (this->pptr() != this->pbase())
-    {
-        if (__always_noconv_)
-        {
-            streamsize __nmemb = static_cast<streamsize>(this->pptr() - this->pbase());
-            if (__bufptr_->sputn((const char*)this->pbase(), __nmemb) != __nmemb)
-                return traits_type::eof();
-        }
-        else
-        {
-            char* __extbe = __extbuf_;
-            codecvt_base::result __r;
-            do
-            {
-                const char_type* __e;
-                __r = __cv_->out(__st_, this->pbase(), this->pptr(), __e,
-                                        __extbuf_, __extbuf_ + __ebs_, __extbe);
-                if (__e == this->pbase())
-                    return traits_type::eof();
-                if (__r == codecvt_base::noconv)
-                {
-                    streamsize __nmemb = static_cast<size_t>(this->pptr() - this->pbase());
-                    if (__bufptr_->sputn((const char*)this->pbase(), __nmemb) != __nmemb)
-                        return traits_type::eof();
-                }
-                else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
-                {
-                    streamsize __nmemb = static_cast<size_t>(__extbe - __extbuf_);
-                    if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb)
-                        return traits_type::eof();
-                    if (__r == codecvt_base::partial)
-                    {
-                        this->setp(const_cast<char_type *>(__e), this->pptr());
-                        this->__pbump(this->epptr() - this->pbase());
-                    }
-                }
-                else
-                    return traits_type::eof();
-            } while (__r == codecvt_base::partial);
-        }
-        this->setp(__pb_save, __epb_save);
-    }
-    return traits_type::not_eof(__c);
+    this->setp(__pb_save, __epb_save);
+  }
+  return traits_type::not_eof(__c);
 }
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Codecvt, class _Elem, class _Tr>
-basic_streambuf<_Elem, _Tr>*
-wbuffer_convert<_Codecvt, _Elem, _Tr>::setbuf(char_type* __s, streamsize __n)
-{
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-    this->setg(0, 0, 0);
-    this->setp(0, 0);
-    if (__owns_eb_)
-        delete [] __extbuf_;
-    if (__owns_ib_)
-        delete [] __intbuf_;
-    __ebs_ = __n;
-    if (__ebs_ > sizeof(__extbuf_min_))
-    {
-        if (__always_noconv_ && __s)
-        {
-            __extbuf_ = (char*)__s;
-            __owns_eb_ = false;
-        }
-        else
-        {
-            __extbuf_ = new char[__ebs_];
-            __owns_eb_ = true;
-        }
+basic_streambuf<_Elem, _Tr>* wbuffer_convert<_Codecvt, _Elem, _Tr>::setbuf(char_type* __s, streamsize __n) {
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+  this->setg(0, 0, 0);
+  this->setp(0, 0);
+  if (__owns_eb_)
+    delete[] __extbuf_;
+  if (__owns_ib_)
+    delete[] __intbuf_;
+  __ebs_ = __n;
+  if (__ebs_ > sizeof(__extbuf_min_)) {
+    if (__always_noconv_ && __s) {
+      __extbuf_  = (char*)__s;
+      __owns_eb_ = false;
+    } else {
+      __extbuf_  = new char[__ebs_];
+      __owns_eb_ = true;
     }
-    else
-    {
-        __extbuf_ = __extbuf_min_;
-        __ebs_ = sizeof(__extbuf_min_);
-        __owns_eb_ = false;
+  } else {
+    __extbuf_  = __extbuf_min_;
+    __ebs_     = sizeof(__extbuf_min_);
+    __owns_eb_ = false;
+  }
+  if (!__always_noconv_) {
+    __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_));
+    if (__s && __ibs_ >= sizeof(__extbuf_min_)) {
+      __intbuf_  = __s;
+      __owns_ib_ = false;
+    } else {
+      __intbuf_  = new char_type[__ibs_];
+      __owns_ib_ = true;
     }
-    if (!__always_noconv_)
-    {
-        __ibs_ = max<streamsize>(__n, sizeof(__extbuf_min_));
-        if (__s && __ibs_ >= sizeof(__extbuf_min_))
-        {
-            __intbuf_ = __s;
-            __owns_ib_ = false;
-        }
-        else
-        {
-            __intbuf_ = new char_type[__ibs_];
-            __owns_ib_ = true;
-        }
-    }
-    else
-    {
-        __ibs_ = 0;
-        __intbuf_ = 0;
-        __owns_ib_ = false;
-    }
-    return this;
+  } else {
+    __ibs_     = 0;
+    __intbuf_  = 0;
+    __owns_ib_ = false;
+  }
+  return this;
 }
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Codecvt, class _Elem, class _Tr>
 typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type
-wbuffer_convert<_Codecvt, _Elem, _Tr>::seekoff(off_type __off, ios_base::seekdir __way,
-                                        ios_base::openmode __om)
-{
-    int __width = __cv_->encoding();
-    if (__cv_ == 0 || __bufptr_ == 0 || (__width <= 0 && __off != 0) || sync())
-        return pos_type(off_type(-1));
-    // __width > 0 || __off == 0, now check __way
-    if (__way != ios_base::beg && __way != ios_base::cur && __way != ios_base::end)
-        return pos_type(off_type(-1));
-    pos_type __r = __bufptr_->pubseekoff(__width * __off, __way, __om);
-    __r.state(__st_);
-    return __r;
+wbuffer_convert<_Codecvt, _Elem, _Tr>::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __om) {
+  int __width = __cv_->encoding();
+  if (__cv_ == 0 || !__bufptr_ || (__width <= 0 && __off != 0) || sync())
+    return pos_type(off_type(-1));
+  // __width > 0 || __off == 0, now check __way
+  if (__way != ios_base::beg && __way != ios_base::cur && __way != ios_base::end)
+    return pos_type(off_type(-1));
+  pos_type __r = __bufptr_->pubseekoff(__width * __off, __way, __om);
+  __r.state(__st_);
+  return __r;
 }
 
 template <class _Codecvt, class _Elem, class _Tr>
 typename wbuffer_convert<_Codecvt, _Elem, _Tr>::pos_type
-wbuffer_convert<_Codecvt, _Elem, _Tr>::seekpos(pos_type __sp, ios_base::openmode __wch)
-{
-    if (__cv_ == 0 || __bufptr_ == 0 || sync())
-        return pos_type(off_type(-1));
-    if (__bufptr_->pubseekpos(__sp, __wch) == pos_type(off_type(-1)))
-        return pos_type(off_type(-1));
-    return __sp;
+wbuffer_convert<_Codecvt, _Elem, _Tr>::seekpos(pos_type __sp, ios_base::openmode __wch) {
+  if (__cv_ == 0 || !__bufptr_ || sync())
+    return pos_type(off_type(-1));
+  if (__bufptr_->pubseekpos(__sp, __wch) == pos_type(off_type(-1)))
+    return pos_type(off_type(-1));
+  return __sp;
 }
 
 template <class _Codecvt, class _Elem, class _Tr>
-int
-wbuffer_convert<_Codecvt, _Elem, _Tr>::sync()
-{
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-    if (__cv_ == 0 || __bufptr_ == 0)
-        return 0;
-    if (__cm_ & ios_base::out)
-    {
-        if (this->pptr() != this->pbase())
-            if (overflow() == traits_type::eof())
-                return -1;
-        codecvt_base::result __r;
-        do
-        {
-            char* __extbe;
-            __r = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe);
-            streamsize __nmemb = static_cast<streamsize>(__extbe - __extbuf_);
-            if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb)
-                return -1;
-        } while (__r == codecvt_base::partial);
-        if (__r == codecvt_base::error)
-            return -1;
-        if (__bufptr_->pubsync())
-            return -1;
-    }
-    else if (__cm_ & ios_base::in)
-    {
-        off_type __c;
-        if (__always_noconv_)
-            __c = this->egptr() - this->gptr();
-        else
-        {
-            int __width = __cv_->encoding();
-            __c = __extbufend_ - __extbufnext_;
-            if (__width > 0)
-                __c += __width * (this->egptr() - this->gptr());
-            else
-            {
-                if (this->gptr() != this->egptr())
-                {
-                    std::reverse(this->gptr(), this->egptr());
-                    codecvt_base::result __r;
-                    const char_type* __e = this->gptr();
-                    char* __extbe;
-                    do
-                    {
-                        __r = __cv_->out(__st_, __e, this->egptr(), __e,
-                                         __extbuf_, __extbuf_ + __ebs_, __extbe);
-                        switch (__r)
-                        {
-                        case codecvt_base::noconv:
-                            __c += this->egptr() - this->gptr();
-                            break;
-                        case codecvt_base::ok:
-                        case codecvt_base::partial:
-                            __c += __extbe - __extbuf_;
-                            break;
-                        default:
-                            return -1;
-                        }
-                    } while (__r == codecvt_base::partial);
-                }
-            }
-        }
-        if (__bufptr_->pubseekoff(-__c, ios_base::cur, __cm_) == pos_type(off_type(-1)))
-            return -1;
-        this->setg(0, 0, 0);
-        __cm_ = 0;
-    }
+int wbuffer_convert<_Codecvt, _Elem, _Tr>::sync() {
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+  if (__cv_ == 0 || !__bufptr_)
     return 0;
+  if (__cm_ & ios_base::out) {
+    if (this->pptr() != this->pbase())
+      if (overflow() == traits_type::eof())
+        return -1;
+    codecvt_base::result __r;
+    do {
+      char* __extbe;
+      __r                = __cv_->unshift(__st_, __extbuf_, __extbuf_ + __ebs_, __extbe);
+      streamsize __nmemb = static_cast<streamsize>(__extbe - __extbuf_);
+      if (__bufptr_->sputn(__extbuf_, __nmemb) != __nmemb)
+        return -1;
+    } while (__r == codecvt_base::partial);
+    if (__r == codecvt_base::error)
+      return -1;
+    if (__bufptr_->pubsync())
+      return -1;
+  } else if (__cm_ & ios_base::in) {
+    off_type __c;
+    if (__always_noconv_)
+      __c = this->egptr() - this->gptr();
+    else {
+      int __width = __cv_->encoding();
+      __c         = __extbufend_ - __extbufnext_;
+      if (__width > 0)
+        __c += __width * (this->egptr() - this->gptr());
+      else {
+        if (this->gptr() != this->egptr()) {
+          std::reverse(this->gptr(), this->egptr());
+          codecvt_base::result __r;
+          const char_type* __e = this->gptr();
+          char* __extbe;
+          do {
+            __r = __cv_->out(__st_, __e, this->egptr(), __e, __extbuf_, __extbuf_ + __ebs_, __extbe);
+            switch (__r) {
+            case codecvt_base::noconv:
+              __c += this->egptr() - this->gptr();
+              break;
+            case codecvt_base::ok:
+            case codecvt_base::partial:
+              __c += __extbe - __extbuf_;
+              break;
+            default:
+              return -1;
+            }
+          } while (__r == codecvt_base::partial);
+        }
+      }
+    }
+    if (__bufptr_->pubseekoff(-__c, ios_base::cur, __cm_) == pos_type(off_type(-1)))
+      return -1;
+    this->setg(0, 0, 0);
+    __cm_ = 0;
+  }
+  return 0;
 }
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Codecvt, class _Elem, class _Tr>
-bool
-wbuffer_convert<_Codecvt, _Elem, _Tr>::__read_mode()
-{
-    if (!(__cm_ & ios_base::in))
-    {
-        this->setp(0, 0);
-        if (__always_noconv_)
-            this->setg((char_type*)__extbuf_,
-                       (char_type*)__extbuf_ + __ebs_,
-                       (char_type*)__extbuf_ + __ebs_);
-        else
-            this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
-        __cm_ = ios_base::in;
-        return true;
-    }
-    return false;
+bool wbuffer_convert<_Codecvt, _Elem, _Tr>::__read_mode() {
+  if (!(__cm_ & ios_base::in)) {
+    this->setp(0, 0);
+    if (__always_noconv_)
+      this->setg((char_type*)__extbuf_, (char_type*)__extbuf_ + __ebs_, (char_type*)__extbuf_ + __ebs_);
+    else
+      this->setg(__intbuf_, __intbuf_ + __ibs_, __intbuf_ + __ibs_);
+    __cm_ = ios_base::in;
+    return true;
+  }
+  return false;
 }
 
 template <class _Codecvt, class _Elem, class _Tr>
-void
-wbuffer_convert<_Codecvt, _Elem, _Tr>::__write_mode()
-{
-    if (!(__cm_ & ios_base::out))
-    {
-        this->setg(0, 0, 0);
-        if (__ebs_ > sizeof(__extbuf_min_))
-        {
-            if (__always_noconv_)
-                this->setp((char_type*)__extbuf_,
-                           (char_type*)__extbuf_ + (__ebs_ - 1));
-            else
-                this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1));
-        }
-        else
-            this->setp(0, 0);
-        __cm_ = ios_base::out;
-    }
+void wbuffer_convert<_Codecvt, _Elem, _Tr>::__write_mode() {
+  if (!(__cm_ & ios_base::out)) {
+    this->setg(0, 0, 0);
+    if (__ebs_ > sizeof(__extbuf_min_)) {
+      if (__always_noconv_)
+        this->setp((char_type*)__extbuf_, (char_type*)__extbuf_ + (__ebs_ - 1));
+      else
+        this->setp(__intbuf_, __intbuf_ + (__ibs_ - 1));
+    } else
+      this->setp(0, 0);
+    __cm_ = ios_base::out;
+  }
 }
 
 template <class _Codecvt, class _Elem, class _Tr>
-wbuffer_convert<_Codecvt, _Elem, _Tr>*
-wbuffer_convert<_Codecvt, _Elem, _Tr>::__close()
-{
-    wbuffer_convert* __rt = nullptr;
-    if (__cv_ != nullptr && __bufptr_ != nullptr)
-    {
-        __rt = this;
-        if ((__cm_ & ios_base::out) && sync())
-            __rt = nullptr;
-    }
-    return __rt;
+wbuffer_convert<_Codecvt, _Elem, _Tr>* wbuffer_convert<_Codecvt, _Elem, _Tr>::__close() {
+  wbuffer_convert* __rt = nullptr;
+  if (__cv_ != nullptr && __bufptr_ != nullptr) {
+    __rt = this;
+    if ((__cm_ & ios_base::out) && sync())
+      __rt = nullptr;
+  }
+  return __rt;
 }
 
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
+#  endif // _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_WSTRING_CONVERT)
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 // NOLINTEND(libcpp-robust-against-adl)
 
+#endif // !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
 #  include <cstdarg>
 #  include <iterator>
+#  include <mutex>
 #  include <stdexcept>
 #  include <type_traits>
 #  include <typeinfo>
diff --git a/third_party/libcxx/locale.cpp b/third_party/libcxx/locale.cpp
new file mode 100644
index 000000000..ea8e89f7d
--- /dev/null
+++ b/third_party/libcxx/locale.cpp
@@ -0,0 +1,5648 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__utility/no_destroy.h>
+#include <algorithm>
+#include <clocale>
+#include <codecvt>
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <locale>
+#include <new>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <vector>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  include <cwctype>
+#endif
+
+#if defined(_AIX)
+#  include <sys/localedef.h> // for __lc_ctype_ptr
+#endif
+
+#if defined(_LIBCPP_MSVCRT)
+#  define _CTYPE_DISABLE_MACROS
+#endif
+
+#if !defined(_LIBCPP_MSVCRT) && !defined(__MINGW32__) && !defined(__BIONIC__) && !defined(__NuttX__)
+#  include <langinfo.h>
+#endif
+
+#include "atomic_support.h"
+#include "sso_allocator.h"
+
+// On Linux, wint_t and wchar_t have different signed-ness, and this causes
+// lots of noise in the build log, but no bugs that I know of.
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wsign-conversion")
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+struct __libcpp_unique_locale {
+  __libcpp_unique_locale(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {}
+
+  ~__libcpp_unique_locale() {
+    if (__loc_)
+      freelocale(__loc_);
+  }
+
+  explicit operator bool() const { return __loc_; }
+
+  locale_t& get() { return __loc_; }
+
+  locale_t __loc_;
+
+private:
+  __libcpp_unique_locale(__libcpp_unique_locale const&);
+  __libcpp_unique_locale& operator=(__libcpp_unique_locale const&);
+};
+
+#ifdef __cloc_defined
+locale_t __cloc() {
+  // In theory this could create a race condition. In practice
+  // the race condition is non-fatal since it will just create
+  // a little resource leak. Better approach would be appreciated.
+  static locale_t result = newlocale(LC_ALL_MASK, "C", 0);
+  return result;
+}
+#endif // __cloc_defined
+
+namespace {
+
+struct releaser {
+  void operator()(locale::facet* p) { p->__release_shared(); }
+};
+
+template <class T, class... Args>
+T& make(Args... args) {
+  alignas(T) static std::byte buf[sizeof(T)];
+  auto* obj = ::new (&buf) T(args...);
+  return *obj;
+}
+
+template <typename T, size_t N>
+inline constexpr size_t countof(const T (&)[N]) {
+  return N;
+}
+
+template <typename T>
+inline constexpr size_t countof(const T* const begin, const T* const end) {
+  return static_cast<size_t>(end - begin);
+}
+
+string build_name(const string& other, const string& one, locale::category c) {
+  if (other == "*" || one == "*")
+    return "*";
+  if (c == locale::none || other == one)
+    return other;
+
+  // FIXME: Handle the more complicated cases, such as when the locale has
+  // different names for different categories.
+  return "*";
+}
+
+} // namespace
+
+const locale::category locale::none;
+const locale::category locale::collate;
+const locale::category locale::ctype;
+const locale::category locale::monetary;
+const locale::category locale::numeric;
+const locale::category locale::time;
+const locale::category locale::messages;
+const locale::category locale::all;
+
+class _LIBCPP_HIDDEN locale::__imp : public facet {
+  enum { N = 30 };
+  vector<facet*, __sso_allocator<facet*, N> > facets_;
+  string name_;
+
+public:
+  explicit __imp(size_t refs = 0);
+  explicit __imp(const string& name, size_t refs = 0);
+  __imp(const __imp&);
+  __imp(const __imp&, const string&, locale::category c);
+  __imp(const __imp& other, const __imp& one, locale::category c);
+  __imp(const __imp&, facet* f, long id);
+  ~__imp();
+
+  const string& name() const { return name_; }
+  bool has_facet(long id) const { return static_cast<size_t>(id) < facets_.size() && facets_[static_cast<size_t>(id)]; }
+  const locale::facet* use_facet(long id) const;
+
+  void acquire();
+  void release();
+  static __no_destroy<__imp> classic_locale_imp_;
+
+private:
+  void install(facet* f, long id);
+  template <class F>
+  void install(F* f) {
+    install(f, f->id.__get());
+  }
+  template <class F>
+  void install_from(const __imp& other);
+};
+
+locale::__imp::__imp(size_t refs) : facet(refs), facets_(N), name_("C") {
+  facets_.clear();
+  install(&make<std::collate<char> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<std::collate<wchar_t> >(1u));
+#endif
+  install(&make<std::ctype<char> >(nullptr, false, 1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<std::ctype<wchar_t> >(1u));
+#endif
+  install(&make<codecvt<char, char, mbstate_t> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<codecvt<wchar_t, char, mbstate_t> >(1u));
+#endif
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  install(&make<codecvt<char16_t, char, mbstate_t> >(1u));
+  install(&make<codecvt<char32_t, char, mbstate_t> >(1u));
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+  install(&make<codecvt<char16_t, char8_t, mbstate_t> >(1u));
+  install(&make<codecvt<char32_t, char8_t, mbstate_t> >(1u));
+#endif
+  install(&make<numpunct<char> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<numpunct<wchar_t> >(1u));
+#endif
+  install(&make<num_get<char> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<num_get<wchar_t> >(1u));
+#endif
+  install(&make<num_put<char> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<num_put<wchar_t> >(1u));
+#endif
+  install(&make<moneypunct<char, false> >(1u));
+  install(&make<moneypunct<char, true> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<moneypunct<wchar_t, false> >(1u));
+  install(&make<moneypunct<wchar_t, true> >(1u));
+#endif
+  install(&make<money_get<char> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<money_get<wchar_t> >(1u));
+#endif
+  install(&make<money_put<char> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<money_put<wchar_t> >(1u));
+#endif
+  install(&make<time_get<char> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<time_get<wchar_t> >(1u));
+#endif
+  install(&make<time_put<char> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<time_put<wchar_t> >(1u));
+#endif
+  install(&make<std::messages<char> >(1u));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  install(&make<std::messages<wchar_t> >(1u));
+#endif
+}
+
+locale::__imp::__imp(const string& name, size_t refs) : facet(refs), facets_(N), name_(name) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    facets_ = locale::classic().__locale_->facets_;
+    for (unsigned i = 0; i < facets_.size(); ++i)
+      if (facets_[i])
+        facets_[i]->__add_shared();
+    install(new collate_byname<char>(name_));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    install(new collate_byname<wchar_t>(name_));
+#endif
+    install(new ctype_byname<char>(name_));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    install(new ctype_byname<wchar_t>(name_));
+#endif
+    install(new codecvt_byname<char, char, mbstate_t>(name_));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    install(new codecvt_byname<wchar_t, char, mbstate_t>(name_));
+#endif
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    install(new codecvt_byname<char16_t, char, mbstate_t>(name_));
+    install(new codecvt_byname<char32_t, char, mbstate_t>(name_));
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+    install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name_));
+    install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name_));
+#endif
+    install(new numpunct_byname<char>(name_));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    install(new numpunct_byname<wchar_t>(name_));
+#endif
+    install(new moneypunct_byname<char, false>(name_));
+    install(new moneypunct_byname<char, true>(name_));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    install(new moneypunct_byname<wchar_t, false>(name_));
+    install(new moneypunct_byname<wchar_t, true>(name_));
+#endif
+    install(new time_get_byname<char>(name_));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    install(new time_get_byname<wchar_t>(name_));
+#endif
+    install(new time_put_byname<char>(name_));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    install(new time_put_byname<wchar_t>(name_));
+#endif
+    install(new messages_byname<char>(name_));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    install(new messages_byname<wchar_t>(name_));
+#endif
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    for (unsigned i = 0; i < facets_.size(); ++i)
+      if (facets_[i])
+        facets_[i]->__release_shared();
+    throw;
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+}
+
+locale::__imp::__imp(const __imp& other) : facets_(max<size_t>(N, other.facets_.size())), name_(other.name_) {
+  facets_ = other.facets_;
+  for (unsigned i = 0; i < facets_.size(); ++i)
+    if (facets_[i])
+      facets_[i]->__add_shared();
+}
+
+locale::__imp::__imp(const __imp& other, const string& name, locale::category c)
+    : facets_(N), name_(build_name(other.name_, name, c)) {
+  facets_ = other.facets_;
+  for (unsigned i = 0; i < facets_.size(); ++i)
+    if (facets_[i])
+      facets_[i]->__add_shared();
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    if (c & locale::collate) {
+      install(new collate_byname<char>(name));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install(new collate_byname<wchar_t>(name));
+#endif
+    }
+    if (c & locale::ctype) {
+      install(new ctype_byname<char>(name));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install(new ctype_byname<wchar_t>(name));
+#endif
+      install(new codecvt_byname<char, char, mbstate_t>(name));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install(new codecvt_byname<wchar_t, char, mbstate_t>(name));
+#endif
+      _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+      install(new codecvt_byname<char16_t, char, mbstate_t>(name));
+      install(new codecvt_byname<char32_t, char, mbstate_t>(name));
+      _LIBCPP_SUPPRESS_DEPRECATED_POP
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+      install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name));
+      install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name));
+#endif
+    }
+    if (c & locale::monetary) {
+      install(new moneypunct_byname<char, false>(name));
+      install(new moneypunct_byname<char, true>(name));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install(new moneypunct_byname<wchar_t, false>(name));
+      install(new moneypunct_byname<wchar_t, true>(name));
+#endif
+    }
+    if (c & locale::numeric) {
+      install(new numpunct_byname<char>(name));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install(new numpunct_byname<wchar_t>(name));
+#endif
+    }
+    if (c & locale::time) {
+      install(new time_get_byname<char>(name));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install(new time_get_byname<wchar_t>(name));
+#endif
+      install(new time_put_byname<char>(name));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install(new time_put_byname<wchar_t>(name));
+#endif
+    }
+    if (c & locale::messages) {
+      install(new messages_byname<char>(name));
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install(new messages_byname<wchar_t>(name));
+#endif
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    for (unsigned i = 0; i < facets_.size(); ++i)
+      if (facets_[i])
+        facets_[i]->__release_shared();
+    throw;
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+}
+
+template <class F>
+inline void locale::__imp::install_from(const locale::__imp& one) {
+  long id = F::id.__get();
+  install(const_cast<F*>(static_cast<const F*>(one.use_facet(id))), id);
+}
+
+locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
+    : facets_(N), name_(build_name(other.name_, one.name_, c)) {
+  facets_ = other.facets_;
+  for (unsigned i = 0; i < facets_.size(); ++i)
+    if (facets_[i])
+      facets_[i]->__add_shared();
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    if (c & locale::collate) {
+      install_from<std::collate<char> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<std::collate<wchar_t> >(one);
+#endif
+    }
+    if (c & locale::ctype) {
+      install_from<std::ctype<char> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<std::ctype<wchar_t> >(one);
+#endif
+      install_from<std::codecvt<char, char, mbstate_t> >(one);
+      _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+      install_from<std::codecvt<char16_t, char, mbstate_t> >(one);
+      install_from<std::codecvt<char32_t, char, mbstate_t> >(one);
+      _LIBCPP_SUPPRESS_DEPRECATED_POP
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+      install_from<std::codecvt<char16_t, char8_t, mbstate_t> >(one);
+      install_from<std::codecvt<char32_t, char8_t, mbstate_t> >(one);
+#endif
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<std::codecvt<wchar_t, char, mbstate_t> >(one);
+#endif
+    }
+    if (c & locale::monetary) {
+      install_from<moneypunct<char, false> >(one);
+      install_from<moneypunct<char, true> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<moneypunct<wchar_t, false> >(one);
+      install_from<moneypunct<wchar_t, true> >(one);
+#endif
+      install_from<money_get<char> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<money_get<wchar_t> >(one);
+#endif
+      install_from<money_put<char> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<money_put<wchar_t> >(one);
+#endif
+    }
+    if (c & locale::numeric) {
+      install_from<numpunct<char> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<numpunct<wchar_t> >(one);
+#endif
+      install_from<num_get<char> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<num_get<wchar_t> >(one);
+#endif
+      install_from<num_put<char> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<num_put<wchar_t> >(one);
+#endif
+    }
+    if (c & locale::time) {
+      install_from<time_get<char> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<time_get<wchar_t> >(one);
+#endif
+      install_from<time_put<char> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<time_put<wchar_t> >(one);
+#endif
+    }
+    if (c & locale::messages) {
+      install_from<std::messages<char> >(one);
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+      install_from<std::messages<wchar_t> >(one);
+#endif
+    }
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    for (unsigned i = 0; i < facets_.size(); ++i)
+      if (facets_[i])
+        facets_[i]->__release_shared();
+    throw;
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+}
+
+locale::__imp::__imp(const __imp& other, facet* f, long id)
+    : facets_(max<size_t>(N, other.facets_.size() + 1)), name_("*") {
+  f->__add_shared();
+  unique_ptr<facet, releaser> hold(f);
+  facets_ = other.facets_;
+  for (unsigned i = 0; i < other.facets_.size(); ++i)
+    if (facets_[i])
+      facets_[i]->__add_shared();
+  install(hold.get(), id);
+}
+
+locale::__imp::~__imp() {
+  for (unsigned i = 0; i < facets_.size(); ++i)
+    if (facets_[i])
+      facets_[i]->__release_shared();
+}
+
+void locale::__imp::install(facet* f, long id) {
+  f->__add_shared();
+  unique_ptr<facet, releaser> hold(f);
+  if (static_cast<size_t>(id) >= facets_.size())
+    facets_.resize(static_cast<size_t>(id + 1));
+  if (facets_[static_cast<size_t>(id)])
+    facets_[static_cast<size_t>(id)]->__release_shared();
+  facets_[static_cast<size_t>(id)] = hold.release();
+}
+
+const locale::facet* locale::__imp::use_facet(long id) const {
+  if (!has_facet(id))
+    __throw_bad_cast();
+  return facets_[static_cast<size_t>(id)];
+}
+
+// locale
+
+// We don't do reference counting on the classic locale.
+// It's never destroyed anyway, but atomic reference counting may be very
+// expensive in parallel applications. The classic locale is used by default
+// in all streams. Note: if a new global locale is installed, then we lose
+// the benefit of no reference counting.
+constinit __no_destroy<locale::__imp>
+    locale::__imp::classic_locale_imp_(__uninitialized_tag{}); // initialized below in classic()
+
+const locale& locale::classic() {
+  static const __no_destroy<locale> classic_locale(__private_constructor_tag{}, [] {
+    // executed exactly once on first initialization of `classic_locale`
+    locale::__imp::classic_locale_imp_.__emplace(1u);
+    return &locale::__imp::classic_locale_imp_.__get();
+  }());
+  return classic_locale.__get();
+}
+
+locale& locale::__global() {
+  static __no_destroy<locale> g(locale::classic());
+  return g.__get();
+}
+
+void locale::__imp::acquire() {
+  if (this != &locale::__imp::classic_locale_imp_.__get())
+    __add_shared();
+}
+
+void locale::__imp::release() {
+  if (this != &locale::__imp::classic_locale_imp_.__get())
+    __release_shared();
+}
+
+locale::locale() noexcept : __locale_(__global().__locale_) { __locale_->acquire(); }
+
+locale::locale(const locale& l) noexcept : __locale_(l.__locale_) { __locale_->acquire(); }
+
+locale::~locale() { __locale_->release(); }
+
+const locale& locale::operator=(const locale& other) noexcept {
+  other.__locale_->acquire();
+  __locale_->release();
+  __locale_ = other.__locale_;
+  return *this;
+}
+
+locale::locale(const char* name)
+    : __locale_(name ? new __imp(name) : (__throw_runtime_error("locale constructed with null"), nullptr)) {
+  __locale_->acquire();
+}
+
+locale::locale(const string& name) : __locale_(new __imp(name)) { __locale_->acquire(); }
+
+locale::locale(const locale& other, const char* name, category c)
+    : __locale_(name ? new __imp(*other.__locale_, name, c)
+                     : (__throw_runtime_error("locale constructed with null"), nullptr)) {
+  __locale_->acquire();
+}
+
+locale::locale(const locale& other, const string& name, category c) : __locale_(new __imp(*other.__locale_, name, c)) {
+  __locale_->acquire();
+}
+
+locale::locale(const locale& other, const locale& one, category c)
+    : __locale_(new __imp(*other.__locale_, *one.__locale_, c)) {
+  __locale_->acquire();
+}
+
+string locale::name() const { return __locale_->name(); }
+
+void locale::__install_ctor(const locale& other, facet* f, long facet_id) {
+  if (f)
+    __locale_ = new __imp(*other.__locale_, f, facet_id);
+  else
+    __locale_ = other.__locale_;
+  __locale_->acquire();
+}
+
+locale locale::global(const locale& loc) {
+  locale& g = __global();
+  locale r  = g;
+  g         = loc;
+  if (g.name() != "*")
+    setlocale(LC_ALL, g.name().c_str());
+  return r;
+}
+
+bool locale::has_facet(id& x) const { return __locale_->has_facet(x.__get()); }
+
+const locale::facet* locale::use_facet(id& x) const { return __locale_->use_facet(x.__get()); }
+
+bool locale::operator==(const locale& y) const {
+  return (__locale_ == y.__locale_) || (__locale_->name() != "*" && __locale_->name() == y.__locale_->name());
+}
+
+// locale::facet
+
+locale::facet::~facet() {}
+
+void locale::facet::__on_zero_shared() noexcept { delete this; }
+
+// locale::id
+
+constinit int32_t locale::id::__next_id = 0;
+
+long locale::id::__get() {
+  call_once(__flag_, [&] { __id_ = __libcpp_atomic_add(&__next_id, 1); });
+  return __id_ - 1;
+}
+
+// template <> class collate_byname<char>
+
+collate_byname<char>::collate_byname(const char* n, size_t refs)
+    : collate<char>(refs), __l_(newlocale(LC_ALL_MASK, n, 0)) {
+  if (__l_ == 0)
+    __throw_runtime_error(
+        ("collate_byname<char>::collate_byname"
+         " failed to construct for " +
+         string(n))
+            .c_str());
+}
+
+collate_byname<char>::collate_byname(const string& name, size_t refs)
+    : collate<char>(refs), __l_(newlocale(LC_ALL_MASK, name.c_str(), 0)) {
+  if (__l_ == 0)
+    __throw_runtime_error(
+        ("collate_byname<char>::collate_byname"
+         " failed to construct for " +
+         name)
+            .c_str());
+}
+
+collate_byname<char>::~collate_byname() { freelocale(__l_); }
+
+int collate_byname<char>::do_compare(
+    const char_type* __lo1, const char_type* __hi1, const char_type* __lo2, const char_type* __hi2) const {
+  string_type lhs(__lo1, __hi1);
+  string_type rhs(__lo2, __hi2);
+  int r = strcoll_l(lhs.c_str(), rhs.c_str(), __l_);
+  if (r < 0)
+    return -1;
+  if (r > 0)
+    return 1;
+  return r;
+}
+
+collate_byname<char>::string_type collate_byname<char>::do_transform(const char_type* lo, const char_type* hi) const {
+  const string_type in(lo, hi);
+  string_type out(strxfrm_l(0, in.c_str(), 0, __l_), char());
+  strxfrm_l(const_cast<char*>(out.c_str()), in.c_str(), out.size() + 1, __l_);
+  return out;
+}
+
+// template <> class collate_byname<wchar_t>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
+    : collate<wchar_t>(refs), __l_(newlocale(LC_ALL_MASK, n, 0)) {
+  if (__l_ == 0)
+    __throw_runtime_error(
+        ("collate_byname<wchar_t>::collate_byname(size_t refs)"
+         " failed to construct for " +
+         string(n))
+            .c_str());
+}
+
+collate_byname<wchar_t>::collate_byname(const string& name, size_t refs)
+    : collate<wchar_t>(refs), __l_(newlocale(LC_ALL_MASK, name.c_str(), 0)) {
+  if (__l_ == 0)
+    __throw_runtime_error(
+        ("collate_byname<wchar_t>::collate_byname(size_t refs)"
+         " failed to construct for " +
+         name)
+            .c_str());
+}
+
+collate_byname<wchar_t>::~collate_byname() { freelocale(__l_); }
+
+int collate_byname<wchar_t>::do_compare(
+    const char_type* __lo1, const char_type* __hi1, const char_type* __lo2, const char_type* __hi2) const {
+  string_type lhs(__lo1, __hi1);
+  string_type rhs(__lo2, __hi2);
+  int r = wcscoll_l(lhs.c_str(), rhs.c_str(), __l_);
+  if (r < 0)
+    return -1;
+  if (r > 0)
+    return 1;
+  return r;
+}
+
+collate_byname<wchar_t>::string_type
+collate_byname<wchar_t>::do_transform(const char_type* lo, const char_type* hi) const {
+  const string_type in(lo, hi);
+  string_type out(wcsxfrm_l(0, in.c_str(), 0, __l_), wchar_t());
+  wcsxfrm_l(const_cast<wchar_t*>(out.c_str()), in.c_str(), out.size() + 1, __l_);
+  return out;
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+const ctype_base::mask ctype_base::space;
+const ctype_base::mask ctype_base::print;
+const ctype_base::mask ctype_base::cntrl;
+const ctype_base::mask ctype_base::upper;
+const ctype_base::mask ctype_base::lower;
+const ctype_base::mask ctype_base::alpha;
+const ctype_base::mask ctype_base::digit;
+const ctype_base::mask ctype_base::punct;
+const ctype_base::mask ctype_base::xdigit;
+const ctype_base::mask ctype_base::blank;
+const ctype_base::mask ctype_base::alnum;
+const ctype_base::mask ctype_base::graph;
+
+// template <> class ctype<wchar_t>;
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+constinit locale::id ctype<wchar_t>::id;
+
+ctype<wchar_t>::~ctype() {}
+
+bool ctype<wchar_t>::do_is(mask m, char_type c) const {
+  return isascii(c) ? (ctype<char>::classic_table()[c] & m) != 0 : false;
+}
+
+const wchar_t* ctype<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const {
+  for (; low != high; ++low, ++vec)
+    *vec = static_cast<mask>(isascii(*low) ? ctype<char>::classic_table()[*low] : 0);
+  return low;
+}
+
+const wchar_t* ctype<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const {
+  for (; low != high; ++low)
+    if (isascii(*low) && (ctype<char>::classic_table()[*low] & m))
+      break;
+  return low;
+}
+
+const wchar_t* ctype<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const {
+  for (; low != high; ++low)
+    if (!(isascii(*low) && (ctype<char>::classic_table()[*low] & m)))
+      break;
+  return low;
+}
+
+wchar_t ctype<wchar_t>::do_toupper(char_type c) const {
+#  ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
+  return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
+#  elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) || defined(__MVS__)
+  return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c;
+#  else
+  return (isascii(c) && iswlower_l(c, _LIBCPP_GET_C_LOCALE)) ? c - L'a' + L'A' : c;
+#  endif
+}
+
+const wchar_t* ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const {
+  for (; low != high; ++low)
+#  ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
+    *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
+#  elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) || defined(__MVS__)
+    *low = isascii(*low) ? ctype<char>::__classic_upper_table()[*low] : *low;
+#  else
+    *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? (*low - L'a' + L'A') : *low;
+#  endif
+  return low;
+}
+
+wchar_t ctype<wchar_t>::do_tolower(char_type c) const {
+#  ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
+  return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
+#  elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) || defined(__MVS__)
+  return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c;
+#  else
+  return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c - L'A' + 'a' : c;
+#  endif
+}
+
+const wchar_t* ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const {
+  for (; low != high; ++low)
+#  ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
+    *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
+#  elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__NetBSD__) || defined(__MVS__)
+    *low = isascii(*low) ? ctype<char>::__classic_lower_table()[*low] : *low;
+#  else
+    *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low - L'A' + L'a' : *low;
+#  endif
+  return low;
+}
+
+wchar_t ctype<wchar_t>::do_widen(char c) const { return c; }
+
+const char* ctype<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const {
+  for (; low != high; ++low, ++dest)
+    *dest = *low;
+  return low;
+}
+
+char ctype<wchar_t>::do_narrow(char_type c, char dfault) const {
+  if (isascii(c))
+    return static_cast<char>(c);
+  return dfault;
+}
+
+const wchar_t* ctype<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const {
+  for (; low != high; ++low, ++dest)
+    if (isascii(*low))
+      *dest = static_cast<char>(*low);
+    else
+      *dest = dfault;
+  return low;
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// template <> class ctype<char>;
+
+constinit locale::id ctype<char>::id;
+
+const size_t ctype<char>::table_size;
+
+ctype<char>::ctype(const mask* tab, bool del, size_t refs) : locale::facet(refs), __tab_(tab), __del_(del) {
+  if (__tab_ == 0)
+    __tab_ = classic_table();
+}
+
+ctype<char>::~ctype() {
+  if (__tab_ && __del_)
+    delete[] __tab_;
+}
+
+char ctype<char>::do_toupper(char_type c) const {
+#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
+  return isascii(c) ? static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(c)]) : c;
+#elif defined(__NetBSD__)
+  return static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]);
+#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
+  return isascii(c) ? static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]) : c;
+#else
+  return (isascii(c) && islower_l(c, _LIBCPP_GET_C_LOCALE)) ? c - 'a' + 'A' : c;
+#endif
+}
+
+const char* ctype<char>::do_toupper(char_type* low, const char_type* high) const {
+  for (; low != high; ++low)
+#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
+    *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(*low)]) : *low;
+#elif defined(__NetBSD__)
+    *low = static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(*low)]);
+#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
+    *low = isascii(*low) ? static_cast<char>(__classic_upper_table()[static_cast<size_t>(*low)]) : *low;
+#else
+    *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low - 'a' + 'A' : *low;
+#endif
+  return low;
+}
+
+char ctype<char>::do_tolower(char_type c) const {
+#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
+  return isascii(c) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(c)]) : c;
+#elif defined(__NetBSD__)
+  return static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(c)]);
+#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
+  return isascii(c) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(c)]) : c;
+#else
+  return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c - 'A' + 'a' : c;
+#endif
+}
+
+const char* ctype<char>::do_tolower(char_type* low, const char_type* high) const {
+  for (; low != high; ++low)
+#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
+    *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(*low)]) : *low;
+#elif defined(__NetBSD__)
+    *low = static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(*low)]);
+#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
+    *low = isascii(*low) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(*low)]) : *low;
+#else
+    *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low - 'A' + 'a' : *low;
+#endif
+  return low;
+}
+
+char ctype<char>::do_widen(char c) const { return c; }
+
+const char* ctype<char>::do_widen(const char* low, const char* high, char_type* dest) const {
+  for (; low != high; ++low, ++dest)
+    *dest = *low;
+  return low;
+}
+
+char ctype<char>::do_narrow(char_type c, char dfault) const {
+  if (isascii(c))
+    return static_cast<char>(c);
+  return dfault;
+}
+
+const char* ctype<char>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const {
+  for (; low != high; ++low, ++dest)
+    if (isascii(*low))
+      *dest = *low;
+    else
+      *dest = dfault;
+  return low;
+}
+
+#if defined(__EMSCRIPTEN__)
+extern "C" const unsigned short** __ctype_b_loc();
+extern "C" const int** __ctype_tolower_loc();
+extern "C" const int** __ctype_toupper_loc();
+#endif
+
+#ifdef _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
+const ctype<char>::mask* ctype<char>::classic_table() noexcept {
+  // clang-format off
+    static constexpr const ctype<char>::mask builtin_table[table_size] = {
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl | space | blank,
+        cntrl | space,                  cntrl | space,
+        cntrl | space,                  cntrl | space,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        cntrl,                          cntrl,
+        space | blank | print,          punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  punct | print,
+        digit | print | xdigit,         digit | print | xdigit,
+        digit | print | xdigit,         digit | print | xdigit,
+        digit | print | xdigit,         digit | print | xdigit,
+        digit | print | xdigit,         digit | print | xdigit,
+        digit | print | xdigit,         digit | print | xdigit,
+        punct | print,                  punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  upper | xdigit | print | alpha,
+        upper | xdigit | print | alpha, upper | xdigit | print | alpha,
+        upper | xdigit | print | alpha, upper | xdigit | print | alpha,
+        upper | xdigit | print | alpha, upper | print | alpha,
+        upper | print | alpha,          upper | print | alpha,
+        upper | print | alpha,          upper | print | alpha,
+        upper | print | alpha,          upper | print | alpha,
+        upper | print | alpha,          upper | print | alpha,
+        upper | print | alpha,          upper | print | alpha,
+        upper | print | alpha,          upper | print | alpha,
+        upper | print | alpha,          upper | print | alpha,
+        upper | print | alpha,          upper | print | alpha,
+        upper | print | alpha,          upper | print | alpha,
+        upper | print | alpha,          punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  lower | xdigit | print | alpha,
+        lower | xdigit | print | alpha, lower | xdigit | print | alpha,
+        lower | xdigit | print | alpha, lower | xdigit | print | alpha,
+        lower | xdigit | print | alpha, lower | print | alpha,
+        lower | print | alpha,          lower | print | alpha,
+        lower | print | alpha,          lower | print | alpha,
+        lower | print | alpha,          lower | print | alpha,
+        lower | print | alpha,          lower | print | alpha,
+        lower | print | alpha,          lower | print | alpha,
+        lower | print | alpha,          lower | print | alpha,
+        lower | print | alpha,          lower | print | alpha,
+        lower | print | alpha,          lower | print | alpha,
+        lower | print | alpha,          lower | print | alpha,
+        lower | print | alpha,          punct | print,
+        punct | print,                  punct | print,
+        punct | print,                  cntrl,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+  // clang-format on
+  return builtin_table;
+}
+#else
+const ctype<char>::mask* ctype<char>::classic_table() noexcept {
+#  if defined(__APPLE__) || defined(__FreeBSD__)
+  return _DefaultRuneLocale.__runetype;
+#  elif defined(__NetBSD__)
+  return _C_ctype_tab_ + 1;
+#  elif defined(__GLIBC__)
+  return _LIBCPP_GET_C_LOCALE->__ctype_b;
+#  elif defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
+  return __pctype_func();
+#  elif defined(__EMSCRIPTEN__)
+  return *__ctype_b_loc();
+#  elif defined(_NEWLIB_VERSION)
+  // Newlib has a 257-entry table in ctype_.c, where (char)0 starts at [1].
+  return _ctype_ + 1;
+#  elif defined(_AIX)
+  return (const unsigned int*)__lc_ctype_ptr->obj->mask;
+#  elif defined(__MVS__)
+#    if defined(__NATIVE_ASCII_F)
+  return const_cast<const ctype<char>::mask*>(__OBJ_DATA(__lc_ctype_a)->mask);
+#    else
+  return const_cast<const ctype<char>::mask*>(__ctypec);
+#    endif
+#  else
+  // Platform not supported: abort so the person doing the port knows what to
+  // fix
+#    warning ctype<char>::classic_table() is not implemented
+  printf("ctype<char>::classic_table() is not implemented\n");
+  abort();
+  return NULL;
+#  endif
+}
+#endif
+
+#if defined(__GLIBC__)
+const int* ctype<char>::__classic_lower_table() noexcept { return _LIBCPP_GET_C_LOCALE->__ctype_tolower; }
+
+const int* ctype<char>::__classic_upper_table() noexcept { return _LIBCPP_GET_C_LOCALE->__ctype_toupper; }
+#elif defined(__NetBSD__)
+const short* ctype<char>::__classic_lower_table() noexcept { return _C_tolower_tab_ + 1; }
+
+const short* ctype<char>::__classic_upper_table() noexcept { return _C_toupper_tab_ + 1; }
+
+#elif defined(__EMSCRIPTEN__)
+const int* ctype<char>::__classic_lower_table() noexcept { return *__ctype_tolower_loc(); }
+
+const int* ctype<char>::__classic_upper_table() noexcept { return *__ctype_toupper_loc(); }
+#elif defined(__MVS__)
+const unsigned short* ctype<char>::__classic_lower_table() _NOEXCEPT {
+#  if defined(__NATIVE_ASCII_F)
+  return const_cast<const unsigned short*>(__OBJ_DATA(__lc_ctype_a)->lower);
+#  else
+  return const_cast<const unsigned short*>(__ctype + __TOLOWER_INDEX);
+#  endif
+}
+const unsigned short* ctype<char>::__classic_upper_table() _NOEXCEPT {
+#  if defined(__NATIVE_ASCII_F)
+  return const_cast<const unsigned short*>(__OBJ_DATA(__lc_ctype_a)->upper);
+#  else
+  return const_cast<const unsigned short*>(__ctype + __TOUPPER_INDEX);
+#  endif
+}
+#endif // __GLIBC__ || __NETBSD__ || __EMSCRIPTEN__ || __MVS__
+
+// template <> class ctype_byname<char>
+
+ctype_byname<char>::ctype_byname(const char* name, size_t refs)
+    : ctype<char>(0, false, refs), __l_(newlocale(LC_ALL_MASK, name, 0)) {
+  if (__l_ == 0)
+    __throw_runtime_error(
+        ("ctype_byname<char>::ctype_byname"
+         " failed to construct for " +
+         string(name))
+            .c_str());
+}
+
+ctype_byname<char>::ctype_byname(const string& name, size_t refs)
+    : ctype<char>(0, false, refs), __l_(newlocale(LC_ALL_MASK, name.c_str(), 0)) {
+  if (__l_ == 0)
+    __throw_runtime_error(
+        ("ctype_byname<char>::ctype_byname"
+         " failed to construct for " +
+         name)
+            .c_str());
+}
+
+ctype_byname<char>::~ctype_byname() { freelocale(__l_); }
+
+char ctype_byname<char>::do_toupper(char_type c) const {
+  return static_cast<char>(toupper_l(static_cast<unsigned char>(c), __l_));
+}
+
+const char* ctype_byname<char>::do_toupper(char_type* low, const char_type* high) const {
+  for (; low != high; ++low)
+    *low = static_cast<char>(toupper_l(static_cast<unsigned char>(*low), __l_));
+  return low;
+}
+
+char ctype_byname<char>::do_tolower(char_type c) const {
+  return static_cast<char>(tolower_l(static_cast<unsigned char>(c), __l_));
+}
+
+const char* ctype_byname<char>::do_tolower(char_type* low, const char_type* high) const {
+  for (; low != high; ++low)
+    *low = static_cast<char>(tolower_l(static_cast<unsigned char>(*low), __l_));
+  return low;
+}
+
+// template <> class ctype_byname<wchar_t>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
+    : ctype<wchar_t>(refs), __l_(newlocale(LC_ALL_MASK, name, 0)) {
+  if (__l_ == 0)
+    __throw_runtime_error(
+        ("ctype_byname<wchar_t>::ctype_byname"
+         " failed to construct for " +
+         string(name))
+            .c_str());
+}
+
+ctype_byname<wchar_t>::ctype_byname(const string& name, size_t refs)
+    : ctype<wchar_t>(refs), __l_(newlocale(LC_ALL_MASK, name.c_str(), 0)) {
+  if (__l_ == 0)
+    __throw_runtime_error(
+        ("ctype_byname<wchar_t>::ctype_byname"
+         " failed to construct for " +
+         name)
+            .c_str());
+}
+
+ctype_byname<wchar_t>::~ctype_byname() { freelocale(__l_); }
+
+bool ctype_byname<wchar_t>::do_is(mask m, char_type c) const {
+#  ifdef _LIBCPP_WCTYPE_IS_MASK
+  return static_cast<bool>(iswctype_l(c, m, __l_));
+#  else
+  bool result = false;
+  wint_t ch   = static_cast<wint_t>(c);
+  if ((m & space) == space)
+    result |= (iswspace_l(ch, __l_) != 0);
+  if ((m & print) == print)
+    result |= (iswprint_l(ch, __l_) != 0);
+  if ((m & cntrl) == cntrl)
+    result |= (iswcntrl_l(ch, __l_) != 0);
+  if ((m & upper) == upper)
+    result |= (iswupper_l(ch, __l_) != 0);
+  if ((m & lower) == lower)
+    result |= (iswlower_l(ch, __l_) != 0);
+  if ((m & alpha) == alpha)
+    result |= (iswalpha_l(ch, __l_) != 0);
+  if ((m & digit) == digit)
+    result |= (iswdigit_l(ch, __l_) != 0);
+  if ((m & punct) == punct)
+    result |= (iswpunct_l(ch, __l_) != 0);
+  if ((m & xdigit) == xdigit)
+    result |= (iswxdigit_l(ch, __l_) != 0);
+  if ((m & blank) == blank)
+    result |= (iswblank_l(ch, __l_) != 0);
+  return result;
+#  endif
+}
+
+const wchar_t* ctype_byname<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const {
+  for (; low != high; ++low, ++vec) {
+    if (isascii(*low))
+      *vec = static_cast<mask>(ctype<char>::classic_table()[*low]);
+    else {
+      *vec      = 0;
+      wint_t ch = static_cast<wint_t>(*low);
+      if (iswspace_l(ch, __l_))
+        *vec |= space;
+#  ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
+      if (iswprint_l(ch, __l_))
+        *vec |= print;
+#  endif
+      if (iswcntrl_l(ch, __l_))
+        *vec |= cntrl;
+      if (iswupper_l(ch, __l_))
+        *vec |= upper;
+      if (iswlower_l(ch, __l_))
+        *vec |= lower;
+#  ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
+      if (iswalpha_l(ch, __l_))
+        *vec |= alpha;
+#  endif
+      if (iswdigit_l(ch, __l_))
+        *vec |= digit;
+      if (iswpunct_l(ch, __l_))
+        *vec |= punct;
+#  ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
+      if (iswxdigit_l(ch, __l_))
+        *vec |= xdigit;
+#  endif
+      if (iswblank_l(ch, __l_))
+        *vec |= blank;
+    }
+  }
+  return low;
+}
+
+const wchar_t* ctype_byname<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const {
+  for (; low != high; ++low) {
+#  ifdef _LIBCPP_WCTYPE_IS_MASK
+    if (iswctype_l(*low, m, __l_))
+      break;
+#  else
+    wint_t ch = static_cast<wint_t>(*low);
+    if ((m & space) == space && iswspace_l(ch, __l_))
+      break;
+    if ((m & print) == print && iswprint_l(ch, __l_))
+      break;
+    if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l_))
+      break;
+    if ((m & upper) == upper && iswupper_l(ch, __l_))
+      break;
+    if ((m & lower) == lower && iswlower_l(ch, __l_))
+      break;
+    if ((m & alpha) == alpha && iswalpha_l(ch, __l_))
+      break;
+    if ((m & digit) == digit && iswdigit_l(ch, __l_))
+      break;
+    if ((m & punct) == punct && iswpunct_l(ch, __l_))
+      break;
+    if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l_))
+      break;
+    if ((m & blank) == blank && iswblank_l(ch, __l_))
+      break;
+#  endif
+  }
+  return low;
+}
+
+const wchar_t* ctype_byname<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const {
+  for (; low != high; ++low) {
+#  ifdef _LIBCPP_WCTYPE_IS_MASK
+    if (!iswctype_l(*low, m, __l_))
+      break;
+#  else
+    wint_t ch = static_cast<wint_t>(*low);
+    if ((m & space) == space && iswspace_l(ch, __l_))
+      continue;
+    if ((m & print) == print && iswprint_l(ch, __l_))
+      continue;
+    if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l_))
+      continue;
+    if ((m & upper) == upper && iswupper_l(ch, __l_))
+      continue;
+    if ((m & lower) == lower && iswlower_l(ch, __l_))
+      continue;
+    if ((m & alpha) == alpha && iswalpha_l(ch, __l_))
+      continue;
+    if ((m & digit) == digit && iswdigit_l(ch, __l_))
+      continue;
+    if ((m & punct) == punct && iswpunct_l(ch, __l_))
+      continue;
+    if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l_))
+      continue;
+    if ((m & blank) == blank && iswblank_l(ch, __l_))
+      continue;
+    break;
+#  endif
+  }
+  return low;
+}
+
+wchar_t ctype_byname<wchar_t>::do_toupper(char_type c) const { return towupper_l(c, __l_); }
+
+const wchar_t* ctype_byname<wchar_t>::do_toupper(char_type* low, const char_type* high) const {
+  for (; low != high; ++low)
+    *low = towupper_l(*low, __l_);
+  return low;
+}
+
+wchar_t ctype_byname<wchar_t>::do_tolower(char_type c) const { return towlower_l(c, __l_); }
+
+const wchar_t* ctype_byname<wchar_t>::do_tolower(char_type* low, const char_type* high) const {
+  for (; low != high; ++low)
+    *low = towlower_l(*low, __l_);
+  return low;
+}
+
+wchar_t ctype_byname<wchar_t>::do_widen(char c) const { return __libcpp_btowc_l(c, __l_); }
+
+const char* ctype_byname<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const {
+  for (; low != high; ++low, ++dest)
+    *dest = __libcpp_btowc_l(*low, __l_);
+  return low;
+}
+
+char ctype_byname<wchar_t>::do_narrow(char_type c, char dfault) const {
+  int r = __libcpp_wctob_l(c, __l_);
+  return (r != EOF) ? static_cast<char>(r) : dfault;
+}
+
+const wchar_t*
+ctype_byname<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const {
+  for (; low != high; ++low, ++dest) {
+    int r = __libcpp_wctob_l(*low, __l_);
+    *dest = (r != EOF) ? static_cast<char>(r) : dfault;
+  }
+  return low;
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// template <> class codecvt<char, char, mbstate_t>
+
+constinit locale::id codecvt<char, char, mbstate_t>::id;
+
+codecvt<char, char, mbstate_t>::~codecvt() {}
+
+codecvt<char, char, mbstate_t>::result codecvt<char, char, mbstate_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type*,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type*,
+    extern_type*& to_nxt) const {
+  frm_nxt = frm;
+  to_nxt  = to;
+  return noconv;
+}
+
+codecvt<char, char, mbstate_t>::result codecvt<char, char, mbstate_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type*,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type*,
+    intern_type*& to_nxt) const {
+  frm_nxt = frm;
+  to_nxt  = to;
+  return noconv;
+}
+
+codecvt<char, char, mbstate_t>::result
+codecvt<char, char, mbstate_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int codecvt<char, char, mbstate_t>::do_encoding() const noexcept { return 1; }
+
+bool codecvt<char, char, mbstate_t>::do_always_noconv() const noexcept { return true; }
+
+int codecvt<char, char, mbstate_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* end, size_t mx) const {
+  return static_cast<int>(min<size_t>(mx, static_cast<size_t>(end - frm)));
+}
+
+int codecvt<char, char, mbstate_t>::do_max_length() const noexcept { return 1; }
+
+// template <> class codecvt<wchar_t, char, mbstate_t>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+constinit locale::id codecvt<wchar_t, char, mbstate_t>::id;
+
+codecvt<wchar_t, char, mbstate_t>::codecvt(size_t refs) : locale::facet(refs), __l_(_LIBCPP_GET_C_LOCALE) {}
+
+codecvt<wchar_t, char, mbstate_t>::codecvt(const char* nm, size_t refs)
+    : locale::facet(refs), __l_(newlocale(LC_ALL_MASK, nm, 0)) {
+  if (__l_ == 0)
+    __throw_runtime_error(
+        ("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
+         " failed to construct for " +
+         string(nm))
+            .c_str());
+}
+
+codecvt<wchar_t, char, mbstate_t>::~codecvt() {
+  if (__l_ != _LIBCPP_GET_C_LOCALE)
+    freelocale(__l_);
+}
+
+codecvt<wchar_t, char, mbstate_t>::result codecvt<wchar_t, char, mbstate_t>::do_out(
+    state_type& st,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  // look for first internal null in frm
+  const intern_type* fend = frm;
+  for (; fend != frm_end; ++fend)
+    if (*fend == 0)
+      break;
+  // loop over all null-terminated sequences in frm
+  to_nxt = to;
+  for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt) {
+    // save state in case it is needed to recover to_nxt on error
+    mbstate_t save_state = st;
+    size_t n             = __libcpp_wcsnrtombs_l(
+        to, &frm_nxt, static_cast<size_t>(fend - frm), static_cast<size_t>(to_end - to), &st, __l_);
+    if (n == size_t(-1)) {
+      // need to recover to_nxt
+      for (to_nxt = to; frm != frm_nxt; ++frm) {
+        n = __libcpp_wcrtomb_l(to_nxt, *frm, &save_state, __l_);
+        if (n == size_t(-1))
+          break;
+        to_nxt += n;
+      }
+      frm_nxt = frm;
+      return error;
+    }
+    if (n == 0)
+      return partial;
+    to_nxt += n;
+    if (to_nxt == to_end)
+      break;
+    if (fend != frm_end) // set up next null terminated sequence
+    {
+      // Try to write the terminating null
+      extern_type tmp[MB_LEN_MAX];
+      n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l_);
+      if (n == size_t(-1)) // on error
+        return error;
+      if (n > static_cast<size_t>(to_end - to_nxt)) // is there room?
+        return partial;
+      for (extern_type* p = tmp; n; --n) // write it
+        *to_nxt++ = *p++;
+      ++frm_nxt;
+      // look for next null in frm
+      for (fend = frm_nxt; fend != frm_end; ++fend)
+        if (*fend == 0)
+          break;
+    }
+  }
+  return frm_nxt == frm_end ? ok : partial;
+}
+
+codecvt<wchar_t, char, mbstate_t>::result codecvt<wchar_t, char, mbstate_t>::do_in(
+    state_type& st,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  // look for first internal null in frm
+  const extern_type* fend = frm;
+  for (; fend != frm_end; ++fend)
+    if (*fend == 0)
+      break;
+  // loop over all null-terminated sequences in frm
+  to_nxt = to;
+  for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt) {
+    // save state in case it is needed to recover to_nxt on error
+    mbstate_t save_state = st;
+    size_t n             = __libcpp_mbsnrtowcs_l(
+        to, &frm_nxt, static_cast<size_t>(fend - frm), static_cast<size_t>(to_end - to), &st, __l_);
+    if (n == size_t(-1)) {
+      // need to recover to_nxt
+      for (to_nxt = to; frm != frm_nxt; ++to_nxt) {
+        n = __libcpp_mbrtowc_l(to_nxt, frm, static_cast<size_t>(fend - frm), &save_state, __l_);
+        switch (n) {
+        case 0:
+          ++frm;
+          break;
+        case size_t(-1):
+          frm_nxt = frm;
+          return error;
+        case size_t(-2):
+          frm_nxt = frm;
+          return partial;
+        default:
+          frm += n;
+          break;
+        }
+      }
+      frm_nxt = frm;
+      return frm_nxt == frm_end ? ok : partial;
+    }
+    if (n == size_t(-1))
+      return error;
+    to_nxt += n;
+    if (to_nxt == to_end)
+      break;
+    if (fend != frm_end) // set up next null terminated sequence
+    {
+      // Try to write the terminating null
+      n = __libcpp_mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l_);
+      if (n != 0) // on error
+        return error;
+      ++to_nxt;
+      ++frm_nxt;
+      // look for next null in frm
+      for (fend = frm_nxt; fend != frm_end; ++fend)
+        if (*fend == 0)
+          break;
+    }
+  }
+  return frm_nxt == frm_end ? ok : partial;
+}
+
+codecvt<wchar_t, char, mbstate_t>::result codecvt<wchar_t, char, mbstate_t>::do_unshift(
+    state_type& st, extern_type* to, extern_type* to_end, extern_type*& to_nxt) const {
+  to_nxt = to;
+  extern_type tmp[MB_LEN_MAX];
+  size_t n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l_);
+  if (n == size_t(-1) || n == 0) // on error
+    return error;
+  --n;
+  if (n > static_cast<size_t>(to_end - to_nxt)) // is there room?
+    return partial;
+  for (extern_type* p = tmp; n; --n) // write it
+    *to_nxt++ = *p++;
+  return ok;
+}
+
+int codecvt<wchar_t, char, mbstate_t>::do_encoding() const noexcept {
+  if (__libcpp_mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l_) != 0)
+    return -1;
+
+  // stateless encoding
+  if (__l_ == 0 || __libcpp_mb_cur_max_l(__l_) == 1) // there are no known constant length encodings
+    return 1;                                        // which take more than 1 char to form a wchar_t
+  return 0;
+}
+
+bool codecvt<wchar_t, char, mbstate_t>::do_always_noconv() const noexcept { return false; }
+
+int codecvt<wchar_t, char, mbstate_t>::do_length(
+    state_type& st, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  int nbytes = 0;
+  for (size_t nwchar_t = 0; nwchar_t < mx && frm != frm_end; ++nwchar_t) {
+    size_t n = __libcpp_mbrlen_l(frm, static_cast<size_t>(frm_end - frm), &st, __l_);
+    switch (n) {
+    case 0:
+      ++nbytes;
+      ++frm;
+      break;
+    case size_t(-1):
+    case size_t(-2):
+      return nbytes;
+    default:
+      nbytes += n;
+      frm += n;
+      break;
+    }
+  }
+  return nbytes;
+}
+
+int codecvt<wchar_t, char, mbstate_t>::do_max_length() const noexcept {
+  return __l_ == 0 ? 1 : static_cast<int>(__libcpp_mb_cur_max_l(__l_));
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+//                                     Valid UTF ranges
+//     UTF-32               UTF-16                          UTF-8               # of code points
+//                     first      second       first   second    third   fourth
+// 000000 - 00007F  0000 - 007F               00 - 7F                                 127
+// 000080 - 0007FF  0080 - 07FF               C2 - DF, 80 - BF                       1920
+// 000800 - 000FFF  0800 - 0FFF               E0 - E0, A0 - BF, 80 - BF              2048
+// 001000 - 00CFFF  1000 - CFFF               E1 - EC, 80 - BF, 80 - BF             49152
+// 00D000 - 00D7FF  D000 - D7FF               ED - ED, 80 - 9F, 80 - BF              2048
+// 00D800 - 00DFFF                invalid
+// 00E000 - 00FFFF  E000 - FFFF               EE - EF, 80 - BF, 80 - BF              8192
+// 010000 - 03FFFF  D800 - D8BF, DC00 - DFFF  F0 - F0, 90 - BF, 80 - BF, 80 - BF   196608
+// 040000 - 0FFFFF  D8C0 - DBBF, DC00 - DFFF  F1 - F3, 80 - BF, 80 - BF, 80 - BF   786432
+// 100000 - 10FFFF  DBC0 - DBFF, DC00 - DFFF  F4 - F4, 80 - 8F, 80 - BF, 80 - BF    65536
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+static codecvt_base::result utf16_to_utf8(
+    const uint16_t* frm,
+    const uint16_t* frm_end,
+    const uint16_t*& frm_nxt,
+    uint8_t* to,
+    uint8_t* to_end,
+    uint8_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & generate_header) {
+    if (to_end - to_nxt < 3)
+      return codecvt_base::partial;
+    *to_nxt++ = static_cast<uint8_t>(0xEF);
+    *to_nxt++ = static_cast<uint8_t>(0xBB);
+    *to_nxt++ = static_cast<uint8_t>(0xBF);
+  }
+  for (; frm_nxt < frm_end; ++frm_nxt) {
+    uint16_t wc1 = *frm_nxt;
+    if (wc1 > Maxcode)
+      return codecvt_base::error;
+    if (wc1 < 0x0080) {
+      if (to_end - to_nxt < 1)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(wc1);
+    } else if (wc1 < 0x0800) {
+      if (to_end - to_nxt < 2)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
+    } else if (wc1 < 0xD800) {
+      if (to_end - to_nxt < 3)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
+    } else if (wc1 < 0xDC00) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint16_t wc2 = frm_nxt[1];
+      if ((wc2 & 0xFC00) != 0xDC00)
+        return codecvt_base::error;
+      if (to_end - to_nxt < 4)
+        return codecvt_base::partial;
+      if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) + ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
+        return codecvt_base::error;
+      ++frm_nxt;
+      uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
+      *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4) | ((wc1 & 0x003C) >> 2));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc2 & 0x003F));
+    } else if (wc1 < 0xE000) {
+      return codecvt_base::error;
+    } else {
+      if (to_end - to_nxt < 3)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
+    }
+  }
+  return codecvt_base::ok;
+}
+
+static codecvt_base::result utf16_to_utf8(
+    const uint32_t* frm,
+    const uint32_t* frm_end,
+    const uint32_t*& frm_nxt,
+    uint8_t* to,
+    uint8_t* to_end,
+    uint8_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & generate_header) {
+    if (to_end - to_nxt < 3)
+      return codecvt_base::partial;
+    *to_nxt++ = static_cast<uint8_t>(0xEF);
+    *to_nxt++ = static_cast<uint8_t>(0xBB);
+    *to_nxt++ = static_cast<uint8_t>(0xBF);
+  }
+  for (; frm_nxt < frm_end; ++frm_nxt) {
+    uint16_t wc1 = static_cast<uint16_t>(*frm_nxt);
+    if (wc1 > Maxcode)
+      return codecvt_base::error;
+    if (wc1 < 0x0080) {
+      if (to_end - to_nxt < 1)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(wc1);
+    } else if (wc1 < 0x0800) {
+      if (to_end - to_nxt < 2)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
+    } else if (wc1 < 0xD800) {
+      if (to_end - to_nxt < 3)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
+    } else if (wc1 < 0xDC00) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint16_t wc2 = static_cast<uint16_t>(frm_nxt[1]);
+      if ((wc2 & 0xFC00) != 0xDC00)
+        return codecvt_base::error;
+      if (to_end - to_nxt < 4)
+        return codecvt_base::partial;
+      if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) + ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
+        return codecvt_base::error;
+      ++frm_nxt;
+      uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
+      *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4) | ((wc1 & 0x003C) >> 2));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc2 & 0x003F));
+    } else if (wc1 < 0xE000) {
+      return codecvt_base::error;
+    } else {
+      if (to_end - to_nxt < 3)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc1 >> 12));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x003F));
+    }
+  }
+  return codecvt_base::ok;
+}
+
+static codecvt_base::result utf8_to_utf16(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    const uint8_t*& frm_nxt,
+    uint16_t* to,
+    uint16_t* to_end,
+    uint16_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
+      frm_nxt += 3;
+  }
+  for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt) {
+    uint8_t c1 = *frm_nxt;
+    if (c1 > Maxcode)
+      return codecvt_base::error;
+    if (c1 < 0x80) {
+      *to_nxt = static_cast<uint16_t>(c1);
+      ++frm_nxt;
+    } else if (c1 < 0xC2) {
+      return codecvt_base::error;
+    } else if (c1 < 0xE0) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      if ((c2 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = t;
+      frm_nxt += 2;
+    } else if (c1 < 0xF0) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      switch (c1) {
+      case 0xE0:
+        if ((c2 & 0xE0) != 0xA0)
+          return codecvt_base::error;
+        break;
+      case 0xED:
+        if ((c2 & 0xE0) != 0x80)
+          return codecvt_base::error;
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return codecvt_base::error;
+        break;
+      }
+      if (frm_end - frm_nxt < 3)
+        return codecvt_base::partial;
+      uint8_t c3 = frm_nxt[2];
+      if ((c3 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = t;
+      frm_nxt += 3;
+    } else if (c1 < 0xF5) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      switch (c1) {
+      case 0xF0:
+        if (!(0x90 <= c2 && c2 <= 0xBF))
+          return codecvt_base::error;
+        break;
+      case 0xF4:
+        if ((c2 & 0xF0) != 0x80)
+          return codecvt_base::error;
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return codecvt_base::error;
+        break;
+      }
+      if (frm_end - frm_nxt < 3)
+        return codecvt_base::partial;
+      uint8_t c3 = frm_nxt[2];
+      if ((c3 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      if (frm_end - frm_nxt < 4)
+        return codecvt_base::partial;
+      uint8_t c4 = frm_nxt[3];
+      if ((c4 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      if (to_end - to_nxt < 2)
+        return codecvt_base::partial;
+      if ((((c1 & 7UL) << 18) + ((c2 & 0x3FUL) << 12) + ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = static_cast<uint16_t>(
+          0xD800 | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6) | ((c2 & 0x0F) << 2) | ((c3 & 0x30) >> 4));
+      *++to_nxt = static_cast<uint16_t>(0xDC00 | ((c3 & 0x0F) << 6) | (c4 & 0x3F));
+      frm_nxt += 4;
+    } else {
+      return codecvt_base::error;
+    }
+  }
+  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
+}
+
+static codecvt_base::result utf8_to_utf16(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    const uint8_t*& frm_nxt,
+    uint32_t* to,
+    uint32_t* to_end,
+    uint32_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
+      frm_nxt += 3;
+  }
+  for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt) {
+    uint8_t c1 = *frm_nxt;
+    if (c1 > Maxcode)
+      return codecvt_base::error;
+    if (c1 < 0x80) {
+      *to_nxt = static_cast<uint32_t>(c1);
+      ++frm_nxt;
+    } else if (c1 < 0xC2) {
+      return codecvt_base::error;
+    } else if (c1 < 0xE0) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      if ((c2 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = static_cast<uint32_t>(t);
+      frm_nxt += 2;
+    } else if (c1 < 0xF0) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      switch (c1) {
+      case 0xE0:
+        if ((c2 & 0xE0) != 0xA0)
+          return codecvt_base::error;
+        break;
+      case 0xED:
+        if ((c2 & 0xE0) != 0x80)
+          return codecvt_base::error;
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return codecvt_base::error;
+        break;
+      }
+      if (frm_end - frm_nxt < 3)
+        return codecvt_base::partial;
+      uint8_t c3 = frm_nxt[2];
+      if ((c3 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = static_cast<uint32_t>(t);
+      frm_nxt += 3;
+    } else if (c1 < 0xF5) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      switch (c1) {
+      case 0xF0:
+        if (!(0x90 <= c2 && c2 <= 0xBF))
+          return codecvt_base::error;
+        break;
+      case 0xF4:
+        if ((c2 & 0xF0) != 0x80)
+          return codecvt_base::error;
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return codecvt_base::error;
+        break;
+      }
+      if (frm_end - frm_nxt < 3)
+        return codecvt_base::partial;
+      uint8_t c3 = frm_nxt[2];
+      if ((c3 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      if (frm_end - frm_nxt < 4)
+        return codecvt_base::partial;
+      uint8_t c4 = frm_nxt[3];
+      if ((c4 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      if (to_end - to_nxt < 2)
+        return codecvt_base::partial;
+      if ((((c1 & 7UL) << 18) + ((c2 & 0x3FUL) << 12) + ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = static_cast<uint32_t>(
+          0xD800 | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6) | ((c2 & 0x0F) << 2) | ((c3 & 0x30) >> 4));
+      *++to_nxt = static_cast<uint32_t>(0xDC00 | ((c3 & 0x0F) << 6) | (c4 & 0x3F));
+      frm_nxt += 4;
+    } else {
+      return codecvt_base::error;
+    }
+  }
+  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
+}
+
+static int utf8_to_utf16_length(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    size_t mx,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  const uint8_t* frm_nxt = frm;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
+      frm_nxt += 3;
+  }
+  for (size_t nchar16_t = 0; frm_nxt < frm_end && nchar16_t < mx; ++nchar16_t) {
+    uint8_t c1 = *frm_nxt;
+    if (c1 > Maxcode)
+      break;
+    if (c1 < 0x80) {
+      ++frm_nxt;
+    } else if (c1 < 0xC2) {
+      break;
+    } else if (c1 < 0xE0) {
+      if ((frm_end - frm_nxt < 2) || (frm_nxt[1] & 0xC0) != 0x80)
+        break;
+      uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (frm_nxt[1] & 0x3F));
+      if (t > Maxcode)
+        break;
+      frm_nxt += 2;
+    } else if (c1 < 0xF0) {
+      if (frm_end - frm_nxt < 3)
+        break;
+      uint8_t c2 = frm_nxt[1];
+      uint8_t c3 = frm_nxt[2];
+      switch (c1) {
+      case 0xE0:
+        if ((c2 & 0xE0) != 0xA0)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      case 0xED:
+        if ((c2 & 0xE0) != 0x80)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      }
+      if ((c3 & 0xC0) != 0x80)
+        break;
+      if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
+        break;
+      frm_nxt += 3;
+    } else if (c1 < 0xF5) {
+      if (frm_end - frm_nxt < 4 || mx - nchar16_t < 2)
+        break;
+      uint8_t c2 = frm_nxt[1];
+      uint8_t c3 = frm_nxt[2];
+      uint8_t c4 = frm_nxt[3];
+      switch (c1) {
+      case 0xF0:
+        if (!(0x90 <= c2 && c2 <= 0xBF))
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      case 0xF4:
+        if ((c2 & 0xF0) != 0x80)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      }
+      if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
+        break;
+      if ((((c1 & 7UL) << 18) + ((c2 & 0x3FUL) << 12) + ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
+        break;
+      ++nchar16_t;
+      frm_nxt += 4;
+    } else {
+      break;
+    }
+  }
+  return static_cast<int>(frm_nxt - frm);
+}
+
+static codecvt_base::result ucs4_to_utf8(
+    const uint32_t* frm,
+    const uint32_t* frm_end,
+    const uint32_t*& frm_nxt,
+    uint8_t* to,
+    uint8_t* to_end,
+    uint8_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & generate_header) {
+    if (to_end - to_nxt < 3)
+      return codecvt_base::partial;
+    *to_nxt++ = static_cast<uint8_t>(0xEF);
+    *to_nxt++ = static_cast<uint8_t>(0xBB);
+    *to_nxt++ = static_cast<uint8_t>(0xBF);
+  }
+  for (; frm_nxt < frm_end; ++frm_nxt) {
+    uint32_t wc = *frm_nxt;
+    if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
+      return codecvt_base::error;
+    if (wc < 0x000080) {
+      if (to_end - to_nxt < 1)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(wc);
+    } else if (wc < 0x000800) {
+      if (to_end - to_nxt < 2)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
+    } else if (wc < 0x010000) {
+      if (to_end - to_nxt < 3)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc >> 12));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x003F));
+    } else // if (wc < 0x110000)
+    {
+      if (to_end - to_nxt < 4)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xF0 | (wc >> 18));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x03F000) >> 12));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x000FC0) >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x00003F));
+    }
+  }
+  return codecvt_base::ok;
+}
+
+static codecvt_base::result utf8_to_ucs4(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    const uint8_t*& frm_nxt,
+    uint32_t* to,
+    uint32_t* to_end,
+    uint32_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
+      frm_nxt += 3;
+  }
+  for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt) {
+    uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
+    if (c1 < 0x80) {
+      if (c1 > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = static_cast<uint32_t>(c1);
+      ++frm_nxt;
+    } else if (c1 < 0xC2) {
+      return codecvt_base::error;
+    } else if (c1 < 0xE0) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      if ((c2 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      uint32_t t = static_cast<uint32_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = t;
+      frm_nxt += 2;
+    } else if (c1 < 0xF0) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      switch (c1) {
+      case 0xE0:
+        if ((c2 & 0xE0) != 0xA0)
+          return codecvt_base::error;
+        break;
+      case 0xED:
+        if ((c2 & 0xE0) != 0x80)
+          return codecvt_base::error;
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return codecvt_base::error;
+        break;
+      }
+      if (frm_end - frm_nxt < 3)
+        return codecvt_base::partial;
+      uint8_t c3 = frm_nxt[2];
+      if ((c3 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      uint32_t t = static_cast<uint32_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = t;
+      frm_nxt += 3;
+    } else if (c1 < 0xF5) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      switch (c1) {
+      case 0xF0:
+        if (!(0x90 <= c2 && c2 <= 0xBF))
+          return codecvt_base::error;
+        break;
+      case 0xF4:
+        if ((c2 & 0xF0) != 0x80)
+          return codecvt_base::error;
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return codecvt_base::error;
+        break;
+      }
+      if (frm_end - frm_nxt < 3)
+        return codecvt_base::partial;
+      uint8_t c3 = frm_nxt[2];
+      if ((c3 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      if (frm_end - frm_nxt < 4)
+        return codecvt_base::partial;
+      uint8_t c4 = frm_nxt[3];
+      if ((c4 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      uint32_t t = static_cast<uint32_t>(((c1 & 0x07) << 18) | ((c2 & 0x3F) << 12) | ((c3 & 0x3F) << 6) | (c4 & 0x3F));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = t;
+      frm_nxt += 4;
+    } else {
+      return codecvt_base::error;
+    }
+  }
+  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
+}
+
+static int utf8_to_ucs4_length(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    size_t mx,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  const uint8_t* frm_nxt = frm;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
+      frm_nxt += 3;
+  }
+  for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t) {
+    uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
+    if (c1 < 0x80) {
+      if (c1 > Maxcode)
+        break;
+      ++frm_nxt;
+    } else if (c1 < 0xC2) {
+      break;
+    } else if (c1 < 0xE0) {
+      if ((frm_end - frm_nxt < 2) || ((frm_nxt[1] & 0xC0) != 0x80))
+        break;
+      if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
+        break;
+      frm_nxt += 2;
+    } else if (c1 < 0xF0) {
+      if (frm_end - frm_nxt < 3)
+        break;
+      uint8_t c2 = frm_nxt[1];
+      uint8_t c3 = frm_nxt[2];
+      switch (c1) {
+      case 0xE0:
+        if ((c2 & 0xE0) != 0xA0)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      case 0xED:
+        if ((c2 & 0xE0) != 0x80)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      }
+      if ((c3 & 0xC0) != 0x80)
+        break;
+      if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
+        break;
+      frm_nxt += 3;
+    } else if (c1 < 0xF5) {
+      if (frm_end - frm_nxt < 4)
+        break;
+      uint8_t c2 = frm_nxt[1];
+      uint8_t c3 = frm_nxt[2];
+      uint8_t c4 = frm_nxt[3];
+      switch (c1) {
+      case 0xF0:
+        if (!(0x90 <= c2 && c2 <= 0xBF))
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      case 0xF4:
+        if ((c2 & 0xF0) != 0x80)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      }
+      if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
+        break;
+      if ((((c1 & 0x07u) << 18) | ((c2 & 0x3Fu) << 12) | ((c3 & 0x3Fu) << 6) | (c4 & 0x3Fu)) > Maxcode)
+        break;
+      frm_nxt += 4;
+    } else {
+      break;
+    }
+  }
+  return static_cast<int>(frm_nxt - frm);
+}
+
+static codecvt_base::result ucs2_to_utf8(
+    const uint16_t* frm,
+    const uint16_t* frm_end,
+    const uint16_t*& frm_nxt,
+    uint8_t* to,
+    uint8_t* to_end,
+    uint8_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & generate_header) {
+    if (to_end - to_nxt < 3)
+      return codecvt_base::partial;
+    *to_nxt++ = static_cast<uint8_t>(0xEF);
+    *to_nxt++ = static_cast<uint8_t>(0xBB);
+    *to_nxt++ = static_cast<uint8_t>(0xBF);
+  }
+  for (; frm_nxt < frm_end; ++frm_nxt) {
+    uint16_t wc = *frm_nxt;
+    if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
+      return codecvt_base::error;
+    if (wc < 0x0080) {
+      if (to_end - to_nxt < 1)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(wc);
+    } else if (wc < 0x0800) {
+      if (to_end - to_nxt < 2)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
+    } else // if (wc <= 0xFFFF)
+    {
+      if (to_end - to_nxt < 3)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(0xE0 | (wc >> 12));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
+      *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x003F));
+    }
+  }
+  return codecvt_base::ok;
+}
+
+static codecvt_base::result utf8_to_ucs2(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    const uint8_t*& frm_nxt,
+    uint16_t* to,
+    uint16_t* to_end,
+    uint16_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
+      frm_nxt += 3;
+  }
+  for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt) {
+    uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
+    if (c1 < 0x80) {
+      if (c1 > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = static_cast<uint16_t>(c1);
+      ++frm_nxt;
+    } else if (c1 < 0xC2) {
+      return codecvt_base::error;
+    } else if (c1 < 0xE0) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      if ((c2 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = t;
+      frm_nxt += 2;
+    } else if (c1 < 0xF0) {
+      if (frm_end - frm_nxt < 2)
+        return codecvt_base::partial;
+      uint8_t c2 = frm_nxt[1];
+      switch (c1) {
+      case 0xE0:
+        if ((c2 & 0xE0) != 0xA0)
+          return codecvt_base::error;
+        break;
+      case 0xED:
+        if ((c2 & 0xE0) != 0x80)
+          return codecvt_base::error;
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return codecvt_base::error;
+        break;
+      }
+      if (frm_end - frm_nxt < 3)
+        return codecvt_base::partial;
+      uint8_t c3 = frm_nxt[2];
+      if ((c3 & 0xC0) != 0x80)
+        return codecvt_base::error;
+      uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12) | ((c2 & 0x3F) << 6) | (c3 & 0x3F));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = t;
+      frm_nxt += 3;
+    } else {
+      return codecvt_base::error;
+    }
+  }
+  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
+}
+
+static int utf8_to_ucs2_length(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    size_t mx,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  const uint8_t* frm_nxt = frm;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB && frm_nxt[2] == 0xBF)
+      frm_nxt += 3;
+  }
+  for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t) {
+    uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
+    if (c1 < 0x80) {
+      if (c1 > Maxcode)
+        break;
+      ++frm_nxt;
+    } else if (c1 < 0xC2) {
+      break;
+    } else if (c1 < 0xE0) {
+      if ((frm_end - frm_nxt < 2) || ((frm_nxt[1] & 0xC0) != 0x80))
+        break;
+      if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
+        break;
+      frm_nxt += 2;
+    } else if (c1 < 0xF0) {
+      if (frm_end - frm_nxt < 3)
+        break;
+      uint8_t c2 = frm_nxt[1];
+      uint8_t c3 = frm_nxt[2];
+      switch (c1) {
+      case 0xE0:
+        if ((c2 & 0xE0) != 0xA0)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      case 0xED:
+        if ((c2 & 0xE0) != 0x80)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      default:
+        if ((c2 & 0xC0) != 0x80)
+          return static_cast<int>(frm_nxt - frm);
+        break;
+      }
+      if ((c3 & 0xC0) != 0x80)
+        break;
+      if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
+        break;
+      frm_nxt += 3;
+    } else {
+      break;
+    }
+  }
+  return static_cast<int>(frm_nxt - frm);
+}
+
+static codecvt_base::result ucs4_to_utf16be(
+    const uint32_t* frm,
+    const uint32_t* frm_end,
+    const uint32_t*& frm_nxt,
+    uint8_t* to,
+    uint8_t* to_end,
+    uint8_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & generate_header) {
+    if (to_end - to_nxt < 2)
+      return codecvt_base::partial;
+    *to_nxt++ = static_cast<uint8_t>(0xFE);
+    *to_nxt++ = static_cast<uint8_t>(0xFF);
+  }
+  for (; frm_nxt < frm_end; ++frm_nxt) {
+    uint32_t wc = *frm_nxt;
+    if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
+      return codecvt_base::error;
+    if (wc < 0x010000) {
+      if (to_end - to_nxt < 2)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(wc >> 8);
+      *to_nxt++ = static_cast<uint8_t>(wc);
+    } else {
+      if (to_end - to_nxt < 4)
+        return codecvt_base::partial;
+      uint16_t t = static_cast<uint16_t>(0xD800 | ((((wc & 0x1F0000) >> 16) - 1) << 6) | ((wc & 0x00FC00) >> 10));
+      *to_nxt++  = static_cast<uint8_t>(t >> 8);
+      *to_nxt++  = static_cast<uint8_t>(t);
+      t          = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
+      *to_nxt++  = static_cast<uint8_t>(t >> 8);
+      *to_nxt++  = static_cast<uint8_t>(t);
+    }
+  }
+  return codecvt_base::ok;
+}
+
+static codecvt_base::result utf16be_to_ucs4(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    const uint8_t*& frm_nxt,
+    uint32_t* to,
+    uint32_t* to_end,
+    uint32_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
+      frm_nxt += 2;
+  }
+  for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt) {
+    uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
+    if ((c1 & 0xFC00) == 0xDC00)
+      return codecvt_base::error;
+    if ((c1 & 0xFC00) != 0xD800) {
+      if (c1 > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = static_cast<uint32_t>(c1);
+      frm_nxt += 2;
+    } else {
+      if (frm_end - frm_nxt < 4)
+        return codecvt_base::partial;
+      uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 | frm_nxt[3]);
+      if ((c2 & 0xFC00) != 0xDC00)
+        return codecvt_base::error;
+      uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = t;
+      frm_nxt += 4;
+    }
+  }
+  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
+}
+
+static int utf16be_to_ucs4_length(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    size_t mx,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  const uint8_t* frm_nxt = frm;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
+      frm_nxt += 2;
+  }
+  for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t) {
+    uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
+    if ((c1 & 0xFC00) == 0xDC00)
+      break;
+    if ((c1 & 0xFC00) != 0xD800) {
+      if (c1 > Maxcode)
+        break;
+      frm_nxt += 2;
+    } else {
+      if (frm_end - frm_nxt < 4)
+        break;
+      uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 | frm_nxt[3]);
+      if ((c2 & 0xFC00) != 0xDC00)
+        break;
+      uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
+      if (t > Maxcode)
+        break;
+      frm_nxt += 4;
+    }
+  }
+  return static_cast<int>(frm_nxt - frm);
+}
+
+static codecvt_base::result ucs4_to_utf16le(
+    const uint32_t* frm,
+    const uint32_t* frm_end,
+    const uint32_t*& frm_nxt,
+    uint8_t* to,
+    uint8_t* to_end,
+    uint8_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & generate_header) {
+    if (to_end - to_nxt < 2)
+      return codecvt_base::partial;
+    *to_nxt++ = static_cast<uint8_t>(0xFF);
+    *to_nxt++ = static_cast<uint8_t>(0xFE);
+  }
+  for (; frm_nxt < frm_end; ++frm_nxt) {
+    uint32_t wc = *frm_nxt;
+    if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
+      return codecvt_base::error;
+    if (wc < 0x010000) {
+      if (to_end - to_nxt < 2)
+        return codecvt_base::partial;
+      *to_nxt++ = static_cast<uint8_t>(wc);
+      *to_nxt++ = static_cast<uint8_t>(wc >> 8);
+    } else {
+      if (to_end - to_nxt < 4)
+        return codecvt_base::partial;
+      uint16_t t = static_cast<uint16_t>(0xD800 | ((((wc & 0x1F0000) >> 16) - 1) << 6) | ((wc & 0x00FC00) >> 10));
+      *to_nxt++  = static_cast<uint8_t>(t);
+      *to_nxt++  = static_cast<uint8_t>(t >> 8);
+      t          = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
+      *to_nxt++  = static_cast<uint8_t>(t);
+      *to_nxt++  = static_cast<uint8_t>(t >> 8);
+    }
+  }
+  return codecvt_base::ok;
+}
+
+static codecvt_base::result utf16le_to_ucs4(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    const uint8_t*& frm_nxt,
+    uint32_t* to,
+    uint32_t* to_end,
+    uint32_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
+      frm_nxt += 2;
+  }
+  for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt) {
+    uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
+    if ((c1 & 0xFC00) == 0xDC00)
+      return codecvt_base::error;
+    if ((c1 & 0xFC00) != 0xD800) {
+      if (c1 > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = static_cast<uint32_t>(c1);
+      frm_nxt += 2;
+    } else {
+      if (frm_end - frm_nxt < 4)
+        return codecvt_base::partial;
+      uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 | frm_nxt[2]);
+      if ((c2 & 0xFC00) != 0xDC00)
+        return codecvt_base::error;
+      uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
+      if (t > Maxcode)
+        return codecvt_base::error;
+      *to_nxt = t;
+      frm_nxt += 4;
+    }
+  }
+  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
+}
+
+static int utf16le_to_ucs4_length(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    size_t mx,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  const uint8_t* frm_nxt = frm;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
+      frm_nxt += 2;
+  }
+  for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t) {
+    uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
+    if ((c1 & 0xFC00) == 0xDC00)
+      break;
+    if ((c1 & 0xFC00) != 0xD800) {
+      if (c1 > Maxcode)
+        break;
+      frm_nxt += 2;
+    } else {
+      if (frm_end - frm_nxt < 4)
+        break;
+      uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 | frm_nxt[2]);
+      if ((c2 & 0xFC00) != 0xDC00)
+        break;
+      uint32_t t = static_cast<uint32_t>(((((c1 & 0x03C0) >> 6) + 1) << 16) | ((c1 & 0x003F) << 10) | (c2 & 0x03FF));
+      if (t > Maxcode)
+        break;
+      frm_nxt += 4;
+    }
+  }
+  return static_cast<int>(frm_nxt - frm);
+}
+
+static codecvt_base::result ucs2_to_utf16be(
+    const uint16_t* frm,
+    const uint16_t* frm_end,
+    const uint16_t*& frm_nxt,
+    uint8_t* to,
+    uint8_t* to_end,
+    uint8_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & generate_header) {
+    if (to_end - to_nxt < 2)
+      return codecvt_base::partial;
+    *to_nxt++ = static_cast<uint8_t>(0xFE);
+    *to_nxt++ = static_cast<uint8_t>(0xFF);
+  }
+  for (; frm_nxt < frm_end; ++frm_nxt) {
+    uint16_t wc = *frm_nxt;
+    if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
+      return codecvt_base::error;
+    if (to_end - to_nxt < 2)
+      return codecvt_base::partial;
+    *to_nxt++ = static_cast<uint8_t>(wc >> 8);
+    *to_nxt++ = static_cast<uint8_t>(wc);
+  }
+  return codecvt_base::ok;
+}
+
+static codecvt_base::result utf16be_to_ucs2(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    const uint8_t*& frm_nxt,
+    uint16_t* to,
+    uint16_t* to_end,
+    uint16_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
+      frm_nxt += 2;
+  }
+  for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt) {
+    uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
+    if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
+      return codecvt_base::error;
+    *to_nxt = c1;
+    frm_nxt += 2;
+  }
+  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
+}
+
+static int utf16be_to_ucs2_length(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    size_t mx,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  const uint8_t* frm_nxt = frm;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
+      frm_nxt += 2;
+  }
+  for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t) {
+    uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
+    if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
+      break;
+    frm_nxt += 2;
+  }
+  return static_cast<int>(frm_nxt - frm);
+}
+
+static codecvt_base::result ucs2_to_utf16le(
+    const uint16_t* frm,
+    const uint16_t* frm_end,
+    const uint16_t*& frm_nxt,
+    uint8_t* to,
+    uint8_t* to_end,
+    uint8_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & generate_header) {
+    if (to_end - to_nxt < 2)
+      return codecvt_base::partial;
+    *to_nxt++ = static_cast<uint8_t>(0xFF);
+    *to_nxt++ = static_cast<uint8_t>(0xFE);
+  }
+  for (; frm_nxt < frm_end; ++frm_nxt) {
+    uint16_t wc = *frm_nxt;
+    if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
+      return codecvt_base::error;
+    if (to_end - to_nxt < 2)
+      return codecvt_base::partial;
+    *to_nxt++ = static_cast<uint8_t>(wc);
+    *to_nxt++ = static_cast<uint8_t>(wc >> 8);
+  }
+  return codecvt_base::ok;
+}
+
+static codecvt_base::result utf16le_to_ucs2(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    const uint8_t*& frm_nxt,
+    uint16_t* to,
+    uint16_t* to_end,
+    uint16_t*& to_nxt,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  frm_nxt = frm;
+  to_nxt  = to;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
+      frm_nxt += 2;
+  }
+  for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt) {
+    uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
+    if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
+      return codecvt_base::error;
+    *to_nxt = c1;
+    frm_nxt += 2;
+  }
+  return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
+}
+
+static int utf16le_to_ucs2_length(
+    const uint8_t* frm,
+    const uint8_t* frm_end,
+    size_t mx,
+    unsigned long Maxcode = 0x10FFFF,
+    codecvt_mode mode     = codecvt_mode(0)) {
+  const uint8_t* frm_nxt = frm;
+  frm_nxt                = frm;
+  if (mode & consume_header) {
+    if (frm_end - frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
+      frm_nxt += 2;
+  }
+  for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t) {
+    uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
+    if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
+      break;
+    frm_nxt += 2;
+  }
+  return static_cast<int>(frm_nxt - frm);
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
+// template <> class codecvt<char16_t, char, mbstate_t>
+
+constinit locale::id codecvt<char16_t, char, mbstate_t>::id;
+
+codecvt<char16_t, char, mbstate_t>::~codecvt() {}
+
+codecvt<char16_t, char, mbstate_t>::result codecvt<char16_t, char, mbstate_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
+  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+  const uint16_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+codecvt<char16_t, char, mbstate_t>::result codecvt<char16_t, char, mbstate_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
+  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
+  uint16_t* _to_nxt       = _to;
+  result r                = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+codecvt<char16_t, char, mbstate_t>::result
+codecvt<char16_t, char, mbstate_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int codecvt<char16_t, char, mbstate_t>::do_encoding() const noexcept { return 0; }
+
+bool codecvt<char16_t, char, mbstate_t>::do_always_noconv() const noexcept { return false; }
+
+int codecvt<char16_t, char, mbstate_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf8_to_utf16_length(_frm, _frm_end, mx);
+}
+
+int codecvt<char16_t, char, mbstate_t>::do_max_length() const noexcept { return 4; }
+
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+
+// template <> class codecvt<char16_t, char8_t, mbstate_t>
+
+constinit locale::id codecvt<char16_t, char8_t, mbstate_t>::id;
+
+codecvt<char16_t, char8_t, mbstate_t>::~codecvt() {}
+
+codecvt<char16_t, char8_t, mbstate_t>::result codecvt<char16_t, char8_t, mbstate_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
+  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+  const uint16_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+codecvt<char16_t, char8_t, mbstate_t>::result codecvt<char16_t, char8_t, mbstate_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
+  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
+  uint16_t* _to_nxt       = _to;
+  result r                = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+codecvt<char16_t, char8_t, mbstate_t>::result codecvt<char16_t, char8_t, mbstate_t>::do_unshift(
+    state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int codecvt<char16_t, char8_t, mbstate_t>::do_encoding() const noexcept { return 0; }
+
+bool codecvt<char16_t, char8_t, mbstate_t>::do_always_noconv() const noexcept { return false; }
+
+int codecvt<char16_t, char8_t, mbstate_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf8_to_utf16_length(_frm, _frm_end, mx);
+}
+
+int codecvt<char16_t, char8_t, mbstate_t>::do_max_length() const noexcept { return 4; }
+
+#endif
+
+// template <> class codecvt<char32_t, char, mbstate_t>
+
+constinit locale::id codecvt<char32_t, char, mbstate_t>::id;
+
+codecvt<char32_t, char, mbstate_t>::~codecvt() {}
+
+codecvt<char32_t, char, mbstate_t>::result codecvt<char32_t, char, mbstate_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
+  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+  const uint32_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+codecvt<char32_t, char, mbstate_t>::result codecvt<char32_t, char, mbstate_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
+  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
+  uint32_t* _to_nxt       = _to;
+  result r                = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+codecvt<char32_t, char, mbstate_t>::result
+codecvt<char32_t, char, mbstate_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int codecvt<char32_t, char, mbstate_t>::do_encoding() const noexcept { return 0; }
+
+bool codecvt<char32_t, char, mbstate_t>::do_always_noconv() const noexcept { return false; }
+
+int codecvt<char32_t, char, mbstate_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf8_to_ucs4_length(_frm, _frm_end, mx);
+}
+
+int codecvt<char32_t, char, mbstate_t>::do_max_length() const noexcept { return 4; }
+
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+
+// template <> class codecvt<char32_t, char8_t, mbstate_t>
+
+constinit locale::id codecvt<char32_t, char8_t, mbstate_t>::id;
+
+codecvt<char32_t, char8_t, mbstate_t>::~codecvt() {}
+
+codecvt<char32_t, char8_t, mbstate_t>::result codecvt<char32_t, char8_t, mbstate_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
+  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+  const uint32_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+codecvt<char32_t, char8_t, mbstate_t>::result codecvt<char32_t, char8_t, mbstate_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
+  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
+  uint32_t* _to_nxt       = _to;
+  result r                = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+codecvt<char32_t, char8_t, mbstate_t>::result codecvt<char32_t, char8_t, mbstate_t>::do_unshift(
+    state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int codecvt<char32_t, char8_t, mbstate_t>::do_encoding() const noexcept { return 0; }
+
+bool codecvt<char32_t, char8_t, mbstate_t>::do_always_noconv() const noexcept { return false; }
+
+int codecvt<char32_t, char8_t, mbstate_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf8_to_ucs4_length(_frm, _frm_end, mx);
+}
+
+int codecvt<char32_t, char8_t, mbstate_t>::do_max_length() const noexcept { return 4; }
+
+#endif
+
+// __codecvt_utf8<wchar_t>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+__codecvt_utf8<wchar_t>::result __codecvt_utf8<wchar_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
+  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+  const uint16_t* _frm_nxt = _frm;
+#  else
+  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
+  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+  const uint32_t* _frm_nxt = _frm;
+#  endif
+  uint8_t* _to     = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt = _to;
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  else
+  result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  endif
+  frm_nxt = frm + (_frm_nxt - _frm);
+  to_nxt  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8<wchar_t>::result __codecvt_utf8<wchar_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  uint16_t* _to     = reinterpret_cast<uint16_t*>(to);
+  uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
+  uint16_t* _to_nxt = _to;
+  result r          = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  else
+  uint32_t* _to     = reinterpret_cast<uint32_t*>(to);
+  uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
+  uint32_t* _to_nxt = _to;
+  result r          = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  endif
+  frm_nxt = frm + (_frm_nxt - _frm);
+  to_nxt  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8<wchar_t>::result
+__codecvt_utf8<wchar_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf8<wchar_t>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf8<wchar_t>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf8<wchar_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  return utf8_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+#  else
+  return utf8_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+#  endif
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+int __codecvt_utf8<wchar_t>::do_max_length() const noexcept {
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  if (__mode_ & consume_header)
+    return 6;
+  return 3;
+#  else
+  if (__mode_ & consume_header)
+    return 7;
+  return 4;
+#  endif
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// __codecvt_utf8<char16_t>
+
+__codecvt_utf8<char16_t>::result __codecvt_utf8<char16_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
+  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+  const uint16_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8<char16_t>::result __codecvt_utf8<char16_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
+  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
+  uint16_t* _to_nxt       = _to;
+  result r                = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8<char16_t>::result
+__codecvt_utf8<char16_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf8<char16_t>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf8<char16_t>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf8<char16_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf8_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+int __codecvt_utf8<char16_t>::do_max_length() const noexcept {
+  if (__mode_ & consume_header)
+    return 6;
+  return 3;
+}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
+// __codecvt_utf8<char32_t>
+
+__codecvt_utf8<char32_t>::result __codecvt_utf8<char32_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
+  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+  const uint32_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8<char32_t>::result __codecvt_utf8<char32_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
+  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
+  uint32_t* _to_nxt       = _to;
+  result r                = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8<char32_t>::result
+__codecvt_utf8<char32_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf8<char32_t>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf8<char32_t>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf8<char32_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf8_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+int __codecvt_utf8<char32_t>::do_max_length() const noexcept {
+  if (__mode_ & consume_header)
+    return 7;
+  return 4;
+}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
+// __codecvt_utf16<wchar_t, false>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+__codecvt_utf16<wchar_t, false>::result __codecvt_utf16<wchar_t, false>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
+  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+  const uint16_t* _frm_nxt = _frm;
+#  else
+  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
+  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+  const uint32_t* _frm_nxt = _frm;
+#  endif
+  uint8_t* _to     = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt = _to;
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  result r = ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  else
+  result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  endif
+  frm_nxt = frm + (_frm_nxt - _frm);
+  to_nxt  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<wchar_t, false>::result __codecvt_utf16<wchar_t, false>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  uint16_t* _to     = reinterpret_cast<uint16_t*>(to);
+  uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
+  uint16_t* _to_nxt = _to;
+  result r          = utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  else
+  uint32_t* _to     = reinterpret_cast<uint32_t*>(to);
+  uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
+  uint32_t* _to_nxt = _to;
+  result r          = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  endif
+  frm_nxt = frm + (_frm_nxt - _frm);
+  to_nxt  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<wchar_t, false>::result
+__codecvt_utf16<wchar_t, false>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf16<wchar_t, false>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf16<wchar_t, false>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf16<wchar_t, false>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  return utf16be_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+#  else
+  return utf16be_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+#  endif
+}
+
+int __codecvt_utf16<wchar_t, false>::do_max_length() const noexcept {
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  if (__mode_ & consume_header)
+    return 4;
+  return 2;
+#  else
+  if (__mode_ & consume_header)
+    return 6;
+  return 4;
+#  endif
+}
+
+// __codecvt_utf16<wchar_t, true>
+
+__codecvt_utf16<wchar_t, true>::result __codecvt_utf16<wchar_t, true>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
+  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+  const uint16_t* _frm_nxt = _frm;
+#  else
+  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
+  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+  const uint32_t* _frm_nxt = _frm;
+#  endif
+  uint8_t* _to     = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt = _to;
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  result r = ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  else
+  result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  endif
+  frm_nxt = frm + (_frm_nxt - _frm);
+  to_nxt  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<wchar_t, true>::result __codecvt_utf16<wchar_t, true>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  uint16_t* _to     = reinterpret_cast<uint16_t*>(to);
+  uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
+  uint16_t* _to_nxt = _to;
+  result r          = utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  else
+  uint32_t* _to     = reinterpret_cast<uint32_t*>(to);
+  uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
+  uint32_t* _to_nxt = _to;
+  result r          = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+#  endif
+  frm_nxt = frm + (_frm_nxt - _frm);
+  to_nxt  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<wchar_t, true>::result
+__codecvt_utf16<wchar_t, true>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf16<wchar_t, true>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf16<wchar_t, true>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf16<wchar_t, true>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  return utf16le_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+#  else
+  return utf16le_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+#  endif
+}
+
+int __codecvt_utf16<wchar_t, true>::do_max_length() const noexcept {
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  if (__mode_ & consume_header)
+    return 4;
+  return 2;
+#  else
+  if (__mode_ & consume_header)
+    return 6;
+  return 4;
+#  endif
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// __codecvt_utf16<char16_t, false>
+
+__codecvt_utf16<char16_t, false>::result __codecvt_utf16<char16_t, false>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
+  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+  const uint16_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<char16_t, false>::result __codecvt_utf16<char16_t, false>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
+  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
+  uint16_t* _to_nxt       = _to;
+  result r                = utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<char16_t, false>::result
+__codecvt_utf16<char16_t, false>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf16<char16_t, false>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf16<char16_t, false>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf16<char16_t, false>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf16be_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+int __codecvt_utf16<char16_t, false>::do_max_length() const noexcept {
+  if (__mode_ & consume_header)
+    return 4;
+  return 2;
+}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
+// __codecvt_utf16<char16_t, true>
+
+__codecvt_utf16<char16_t, true>::result __codecvt_utf16<char16_t, true>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
+  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+  const uint16_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<char16_t, true>::result __codecvt_utf16<char16_t, true>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
+  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
+  uint16_t* _to_nxt       = _to;
+  result r                = utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<char16_t, true>::result
+__codecvt_utf16<char16_t, true>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf16<char16_t, true>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf16<char16_t, true>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf16<char16_t, true>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf16le_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+int __codecvt_utf16<char16_t, true>::do_max_length() const noexcept {
+  if (__mode_ & consume_header)
+    return 4;
+  return 2;
+}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
+// __codecvt_utf16<char32_t, false>
+
+__codecvt_utf16<char32_t, false>::result __codecvt_utf16<char32_t, false>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
+  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+  const uint32_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<char32_t, false>::result __codecvt_utf16<char32_t, false>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
+  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
+  uint32_t* _to_nxt       = _to;
+  result r                = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<char32_t, false>::result
+__codecvt_utf16<char32_t, false>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf16<char32_t, false>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf16<char32_t, false>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf16<char32_t, false>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf16be_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+int __codecvt_utf16<char32_t, false>::do_max_length() const noexcept {
+  if (__mode_ & consume_header)
+    return 6;
+  return 4;
+}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
+// __codecvt_utf16<char32_t, true>
+
+__codecvt_utf16<char32_t, true>::result __codecvt_utf16<char32_t, true>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
+  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+  const uint32_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<char32_t, true>::result __codecvt_utf16<char32_t, true>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
+  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
+  uint32_t* _to_nxt       = _to;
+  result r                = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf16<char32_t, true>::result
+__codecvt_utf16<char32_t, true>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf16<char32_t, true>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf16<char32_t, true>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf16<char32_t, true>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf16le_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+int __codecvt_utf16<char32_t, true>::do_max_length() const noexcept {
+  if (__mode_ & consume_header)
+    return 6;
+  return 4;
+}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
+// __codecvt_utf8_utf16<wchar_t>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+__codecvt_utf8_utf16<wchar_t>::result __codecvt_utf8_utf16<wchar_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
+  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+  const uint16_t* _frm_nxt = _frm;
+#  else
+  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
+  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+  const uint32_t* _frm_nxt = _frm;
+#  endif
+  uint8_t* _to     = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt = _to;
+  result r         = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt          = frm + (_frm_nxt - _frm);
+  to_nxt           = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8_utf16<wchar_t>::result __codecvt_utf8_utf16<wchar_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+#  if defined(_LIBCPP_SHORT_WCHAR)
+  uint16_t* _to     = reinterpret_cast<uint16_t*>(to);
+  uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
+  uint16_t* _to_nxt = _to;
+#  else
+  uint32_t* _to     = reinterpret_cast<uint32_t*>(to);
+  uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
+  uint32_t* _to_nxt = _to;
+#  endif
+  result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt  = frm + (_frm_nxt - _frm);
+  to_nxt   = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8_utf16<wchar_t>::result
+__codecvt_utf8_utf16<wchar_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf8_utf16<wchar_t>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf8_utf16<wchar_t>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf8_utf16<wchar_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf8_to_utf16_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+}
+
+int __codecvt_utf8_utf16<wchar_t>::do_max_length() const noexcept {
+  if (__mode_ & consume_header)
+    return 7;
+  return 4;
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// __codecvt_utf8_utf16<char16_t>
+
+__codecvt_utf8_utf16<char16_t>::result __codecvt_utf8_utf16<char16_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint16_t* _frm     = reinterpret_cast<const uint16_t*>(frm);
+  const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+  const uint16_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8_utf16<char16_t>::result __codecvt_utf8_utf16<char16_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint16_t* _to           = reinterpret_cast<uint16_t*>(to);
+  uint16_t* _to_end       = reinterpret_cast<uint16_t*>(to_end);
+  uint16_t* _to_nxt       = _to;
+  result r                = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8_utf16<char16_t>::result
+__codecvt_utf8_utf16<char16_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf8_utf16<char16_t>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf8_utf16<char16_t>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf8_utf16<char16_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf8_to_utf16_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+int __codecvt_utf8_utf16<char16_t>::do_max_length() const noexcept {
+  if (__mode_ & consume_header)
+    return 7;
+  return 4;
+}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
+// __codecvt_utf8_utf16<char32_t>
+
+__codecvt_utf8_utf16<char32_t>::result __codecvt_utf8_utf16<char32_t>::do_out(
+    state_type&,
+    const intern_type* frm,
+    const intern_type* frm_end,
+    const intern_type*& frm_nxt,
+    extern_type* to,
+    extern_type* to_end,
+    extern_type*& to_nxt) const {
+  const uint32_t* _frm     = reinterpret_cast<const uint32_t*>(frm);
+  const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+  const uint32_t* _frm_nxt = _frm;
+  uint8_t* _to             = reinterpret_cast<uint8_t*>(to);
+  uint8_t* _to_end         = reinterpret_cast<uint8_t*>(to_end);
+  uint8_t* _to_nxt         = _to;
+  result r                 = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                  = frm + (_frm_nxt - _frm);
+  to_nxt                   = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8_utf16<char32_t>::result __codecvt_utf8_utf16<char32_t>::do_in(
+    state_type&,
+    const extern_type* frm,
+    const extern_type* frm_end,
+    const extern_type*& frm_nxt,
+    intern_type* to,
+    intern_type* to_end,
+    intern_type*& to_nxt) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  const uint8_t* _frm_nxt = _frm;
+  uint32_t* _to           = reinterpret_cast<uint32_t*>(to);
+  uint32_t* _to_end       = reinterpret_cast<uint32_t*>(to_end);
+  uint32_t* _to_nxt       = _to;
+  result r                = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt, __maxcode_, __mode_);
+  frm_nxt                 = frm + (_frm_nxt - _frm);
+  to_nxt                  = to + (_to_nxt - _to);
+  return r;
+}
+
+__codecvt_utf8_utf16<char32_t>::result
+__codecvt_utf8_utf16<char32_t>::do_unshift(state_type&, extern_type* to, extern_type*, extern_type*& to_nxt) const {
+  to_nxt = to;
+  return noconv;
+}
+
+int __codecvt_utf8_utf16<char32_t>::do_encoding() const noexcept { return 0; }
+
+bool __codecvt_utf8_utf16<char32_t>::do_always_noconv() const noexcept { return false; }
+
+int __codecvt_utf8_utf16<char32_t>::do_length(
+    state_type&, const extern_type* frm, const extern_type* frm_end, size_t mx) const {
+  const uint8_t* _frm     = reinterpret_cast<const uint8_t*>(frm);
+  const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+  return utf8_to_utf16_length(_frm, _frm_end, mx, __maxcode_, __mode_);
+}
+
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+int __codecvt_utf8_utf16<char32_t>::do_max_length() const noexcept {
+  if (__mode_ & consume_header)
+    return 7;
+  return 4;
+}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
+// __narrow_to_utf8<16>
+
+__narrow_to_utf8<16>::~__narrow_to_utf8() {}
+
+// __narrow_to_utf8<32>
+
+__narrow_to_utf8<32>::~__narrow_to_utf8() {}
+
+// __widen_from_utf8<16>
+
+__widen_from_utf8<16>::~__widen_from_utf8() {}
+
+// __widen_from_utf8<32>
+
+__widen_from_utf8<32>::~__widen_from_utf8() {}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+static bool checked_string_to_wchar_convert(wchar_t& dest, const char* ptr, locale_t loc) {
+  if (*ptr == '\0')
+    return false;
+  mbstate_t mb = {};
+  wchar_t out;
+  size_t ret = __libcpp_mbrtowc_l(&out, ptr, strlen(ptr), &mb, loc);
+  if (ret == static_cast<size_t>(-1) || ret == static_cast<size_t>(-2)) {
+    return false;
+  }
+  dest = out;
+  return true;
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+#ifdef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+static bool is_narrow_non_breaking_space(const char* ptr) {
+  // https://www.fileformat.info/info/unicode/char/202f/index.htm
+  return ptr[0] == '\xe2' && ptr[1] == '\x80' && ptr[2] == '\xaf';
+}
+
+static bool is_non_breaking_space(const char* ptr) {
+  // https://www.fileformat.info/info/unicode/char/0a/index.htm
+  return ptr[0] == '\xc2' && ptr[1] == '\xa0';
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+static bool checked_string_to_char_convert(char& dest, const char* ptr, locale_t __loc) {
+  if (*ptr == '\0')
+    return false;
+  if (!ptr[1]) {
+    dest = *ptr;
+    return true;
+  }
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  // First convert the MBS into a wide char then attempt to narrow it using
+  // wctob_l.
+  wchar_t wout;
+  if (!checked_string_to_wchar_convert(wout, ptr, __loc))
+    return false;
+  int res;
+  if ((res = __libcpp_wctob_l(wout, __loc)) != char_traits<char>::eof()) {
+    dest = res;
+    return true;
+  }
+  // FIXME: Work around specific multibyte sequences that we can reasonably
+  // translate into a different single byte.
+  switch (wout) {
+  case L'\u202F': // narrow non-breaking space
+  case L'\u00A0': // non-breaking space
+    dest = ' ';
+    return true;
+  default:
+    return false;
+  }
+#else  // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  // FIXME: Work around specific multibyte sequences that we can reasonably
+  // translate into a different single byte.
+  if (is_narrow_non_breaking_space(ptr) || is_non_breaking_space(ptr)) {
+    dest = ' ';
+    return true;
+  }
+
+  return false;
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+  __libcpp_unreachable();
+}
+
+// numpunct<char> && numpunct<wchar_t>
+
+constinit locale::id numpunct<char>::id;
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+constinit locale::id numpunct<wchar_t>::id;
+#endif
+
+numpunct<char>::numpunct(size_t refs) : locale::facet(refs), __decimal_point_('.'), __thousands_sep_(',') {}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+numpunct<wchar_t>::numpunct(size_t refs) : locale::facet(refs), __decimal_point_(L'.'), __thousands_sep_(L',') {}
+#endif
+
+numpunct<char>::~numpunct() {}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+numpunct<wchar_t>::~numpunct() {}
+#endif
+
+char numpunct< char >::do_decimal_point() const { return __decimal_point_; }
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+wchar_t numpunct<wchar_t>::do_decimal_point() const { return __decimal_point_; }
+#endif
+
+char numpunct< char >::do_thousands_sep() const { return __thousands_sep_; }
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+wchar_t numpunct<wchar_t>::do_thousands_sep() const { return __thousands_sep_; }
+#endif
+
+string numpunct< char >::do_grouping() const { return __grouping_; }
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+string numpunct<wchar_t>::do_grouping() const { return __grouping_; }
+#endif
+
+string numpunct< char >::do_truename() const { return "true"; }
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+wstring numpunct<wchar_t>::do_truename() const { return L"true"; }
+#endif
+
+string numpunct< char >::do_falsename() const { return "false"; }
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+wstring numpunct<wchar_t>::do_falsename() const { return L"false"; }
+#endif
+
+// numpunct_byname<char>
+
+numpunct_byname<char>::numpunct_byname(const char* nm, size_t refs) : numpunct<char>(refs) { __init(nm); }
+
+numpunct_byname<char>::numpunct_byname(const string& nm, size_t refs) : numpunct<char>(refs) { __init(nm.c_str()); }
+
+numpunct_byname<char>::~numpunct_byname() {}
+
+void numpunct_byname<char>::__init(const char* nm) {
+  typedef numpunct<char> base;
+  if (strcmp(nm, "C") != 0) {
+    __libcpp_unique_locale loc(nm);
+    if (!loc)
+      __throw_runtime_error(
+          ("numpunct_byname<char>::numpunct_byname"
+           " failed to construct for " +
+           string(nm))
+              .c_str());
+
+    lconv* lc = __libcpp_localeconv_l(loc.get());
+    if (!checked_string_to_char_convert(__decimal_point_, lc->decimal_point, loc.get()))
+      __decimal_point_ = base::do_decimal_point();
+    if (!checked_string_to_char_convert(__thousands_sep_, lc->thousands_sep, loc.get()))
+      __thousands_sep_ = base::do_thousands_sep();
+    __grouping_ = lc->grouping;
+    // localization for truename and falsename is not available
+  }
+}
+
+// numpunct_byname<wchar_t>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+numpunct_byname<wchar_t>::numpunct_byname(const char* nm, size_t refs) : numpunct<wchar_t>(refs) { __init(nm); }
+
+numpunct_byname<wchar_t>::numpunct_byname(const string& nm, size_t refs) : numpunct<wchar_t>(refs) {
+  __init(nm.c_str());
+}
+
+numpunct_byname<wchar_t>::~numpunct_byname() {}
+
+void numpunct_byname<wchar_t>::__init(const char* nm) {
+  if (strcmp(nm, "C") != 0) {
+    __libcpp_unique_locale loc(nm);
+    if (!loc)
+      __throw_runtime_error(
+          ("numpunct_byname<wchar_t>::numpunct_byname"
+           " failed to construct for " +
+           string(nm))
+              .c_str());
+
+    lconv* lc = __libcpp_localeconv_l(loc.get());
+    checked_string_to_wchar_convert(__decimal_point_, lc->decimal_point, loc.get());
+    checked_string_to_wchar_convert(__thousands_sep_, lc->thousands_sep, loc.get());
+    __grouping_ = lc->grouping;
+    // localization for truename and falsename is not available
+  }
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// num_get helpers
+
+int __num_get_base::__get_base(ios_base& iob) {
+  ios_base::fmtflags __basefield = iob.flags() & ios_base::basefield;
+  if (__basefield == ios_base::oct)
+    return 8;
+  else if (__basefield == ios_base::hex)
+    return 16;
+  else if (__basefield == 0)
+    return 0;
+  return 10;
+}
+
+const char __num_get_base::__src[33] = "0123456789abcdefABCDEFxX+-pPiInN";
+
+void __check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end, ios_base::iostate& __err) {
+  //  if the grouping pattern is empty _or_ there are no grouping bits, then do nothing
+  //  we always have at least a single entry in [__g, __g_end); the end of the input sequence
+  if (__grouping.size() != 0 && __g_end - __g > 1) {
+    reverse(__g, __g_end);
+    const char* __ig = __grouping.data();
+    const char* __eg = __ig + __grouping.size();
+    for (unsigned* __r = __g; __r < __g_end - 1; ++__r) {
+      if (0 < *__ig && *__ig < numeric_limits<char>::max()) {
+        if (static_cast<unsigned>(*__ig) != *__r) {
+          __err = ios_base::failbit;
+          return;
+        }
+      }
+      if (__eg - __ig > 1)
+        ++__ig;
+    }
+    if (0 < *__ig && *__ig < numeric_limits<char>::max()) {
+      if (static_cast<unsigned>(*__ig) < __g_end[-1] || __g_end[-1] == 0)
+        __err = ios_base::failbit;
+    }
+  }
+}
+
+void __num_put_base::__format_int(char* __fmtp, const char* __len, bool __signd, ios_base::fmtflags __flags) {
+  if ((__flags & ios_base::showpos) && (__flags & ios_base::basefield) != ios_base::oct &&
+      (__flags & ios_base::basefield) != ios_base::hex && __signd)
+    *__fmtp++ = '+';
+  if (__flags & ios_base::showbase)
+    *__fmtp++ = '#';
+  while (*__len)
+    *__fmtp++ = *__len++;
+  if ((__flags & ios_base::basefield) == ios_base::oct)
+    *__fmtp = 'o';
+  else if ((__flags & ios_base::basefield) == ios_base::hex) {
+    if (__flags & ios_base::uppercase)
+      *__fmtp = 'X';
+    else
+      *__fmtp = 'x';
+  } else if (__signd)
+    *__fmtp = 'd';
+  else
+    *__fmtp = 'u';
+}
+
+bool __num_put_base::__format_float(char* __fmtp, const char* __len, ios_base::fmtflags __flags) {
+  bool specify_precision = true;
+  if (__flags & ios_base::showpos)
+    *__fmtp++ = '+';
+  if (__flags & ios_base::showpoint)
+    *__fmtp++ = '#';
+  ios_base::fmtflags floatfield = __flags & ios_base::floatfield;
+  bool uppercase                = (__flags & ios_base::uppercase) != 0;
+  if (floatfield == (ios_base::fixed | ios_base::scientific))
+    specify_precision = false;
+  else {
+    *__fmtp++ = '.';
+    *__fmtp++ = '*';
+  }
+  while (*__len)
+    *__fmtp++ = *__len++;
+  if (floatfield == ios_base::fixed) {
+    if (uppercase)
+      *__fmtp = 'F';
+    else
+      *__fmtp = 'f';
+  } else if (floatfield == ios_base::scientific) {
+    if (uppercase)
+      *__fmtp = 'E';
+    else
+      *__fmtp = 'e';
+  } else if (floatfield == (ios_base::fixed | ios_base::scientific)) {
+    if (uppercase)
+      *__fmtp = 'A';
+    else
+      *__fmtp = 'a';
+  } else {
+    if (uppercase)
+      *__fmtp = 'G';
+    else
+      *__fmtp = 'g';
+  }
+  return specify_precision;
+}
+
+char* __num_put_base::__identify_padding(char* __nb, char* __ne, const ios_base& __iob) {
+  switch (__iob.flags() & ios_base::adjustfield) {
+  case ios_base::internal:
+    if (__nb[0] == '-' || __nb[0] == '+')
+      return __nb + 1;
+    if (__ne - __nb >= 2 && __nb[0] == '0' && (__nb[1] == 'x' || __nb[1] == 'X'))
+      return __nb + 2;
+    break;
+  case ios_base::left:
+    return __ne;
+  case ios_base::right:
+  default:
+    break;
+  }
+  return __nb;
+}
+
+// time_get
+
+static string* init_weeks() {
+  static string weeks[14];
+  weeks[0]  = "Sunday";
+  weeks[1]  = "Monday";
+  weeks[2]  = "Tuesday";
+  weeks[3]  = "Wednesday";
+  weeks[4]  = "Thursday";
+  weeks[5]  = "Friday";
+  weeks[6]  = "Saturday";
+  weeks[7]  = "Sun";
+  weeks[8]  = "Mon";
+  weeks[9]  = "Tue";
+  weeks[10] = "Wed";
+  weeks[11] = "Thu";
+  weeks[12] = "Fri";
+  weeks[13] = "Sat";
+  return weeks;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+static wstring* init_wweeks() {
+  static wstring weeks[14];
+  weeks[0]  = L"Sunday";
+  weeks[1]  = L"Monday";
+  weeks[2]  = L"Tuesday";
+  weeks[3]  = L"Wednesday";
+  weeks[4]  = L"Thursday";
+  weeks[5]  = L"Friday";
+  weeks[6]  = L"Saturday";
+  weeks[7]  = L"Sun";
+  weeks[8]  = L"Mon";
+  weeks[9]  = L"Tue";
+  weeks[10] = L"Wed";
+  weeks[11] = L"Thu";
+  weeks[12] = L"Fri";
+  weeks[13] = L"Sat";
+  return weeks;
+}
+#endif
+
+template <>
+const string* __time_get_c_storage<char>::__weeks() const {
+  static const string* weeks = init_weeks();
+  return weeks;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+const wstring* __time_get_c_storage<wchar_t>::__weeks() const {
+  static const wstring* weeks = init_wweeks();
+  return weeks;
+}
+#endif
+
+static string* init_months() {
+  static string months[24];
+  months[0]  = "January";
+  months[1]  = "February";
+  months[2]  = "March";
+  months[3]  = "April";
+  months[4]  = "May";
+  months[5]  = "June";
+  months[6]  = "July";
+  months[7]  = "August";
+  months[8]  = "September";
+  months[9]  = "October";
+  months[10] = "November";
+  months[11] = "December";
+  months[12] = "Jan";
+  months[13] = "Feb";
+  months[14] = "Mar";
+  months[15] = "Apr";
+  months[16] = "May";
+  months[17] = "Jun";
+  months[18] = "Jul";
+  months[19] = "Aug";
+  months[20] = "Sep";
+  months[21] = "Oct";
+  months[22] = "Nov";
+  months[23] = "Dec";
+  return months;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+static wstring* init_wmonths() {
+  static wstring months[24];
+  months[0]  = L"January";
+  months[1]  = L"February";
+  months[2]  = L"March";
+  months[3]  = L"April";
+  months[4]  = L"May";
+  months[5]  = L"June";
+  months[6]  = L"July";
+  months[7]  = L"August";
+  months[8]  = L"September";
+  months[9]  = L"October";
+  months[10] = L"November";
+  months[11] = L"December";
+  months[12] = L"Jan";
+  months[13] = L"Feb";
+  months[14] = L"Mar";
+  months[15] = L"Apr";
+  months[16] = L"May";
+  months[17] = L"Jun";
+  months[18] = L"Jul";
+  months[19] = L"Aug";
+  months[20] = L"Sep";
+  months[21] = L"Oct";
+  months[22] = L"Nov";
+  months[23] = L"Dec";
+  return months;
+}
+#endif
+
+template <>
+const string* __time_get_c_storage<char>::__months() const {
+  static const string* months = init_months();
+  return months;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+const wstring* __time_get_c_storage<wchar_t>::__months() const {
+  static const wstring* months = init_wmonths();
+  return months;
+}
+#endif
+
+static string* init_am_pm() {
+  static string am_pm[2];
+  am_pm[0] = "AM";
+  am_pm[1] = "PM";
+  return am_pm;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+static wstring* init_wam_pm() {
+  static wstring am_pm[2];
+  am_pm[0] = L"AM";
+  am_pm[1] = L"PM";
+  return am_pm;
+}
+#endif
+
+template <>
+const string* __time_get_c_storage<char>::__am_pm() const {
+  static const string* am_pm = init_am_pm();
+  return am_pm;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+const wstring* __time_get_c_storage<wchar_t>::__am_pm() const {
+  static const wstring* am_pm = init_wam_pm();
+  return am_pm;
+}
+#endif
+
+template <>
+const string& __time_get_c_storage<char>::__x() const {
+  static string s("%m/%d/%y");
+  return s;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+const wstring& __time_get_c_storage<wchar_t>::__x() const {
+  static wstring s(L"%m/%d/%y");
+  return s;
+}
+#endif
+
+template <>
+const string& __time_get_c_storage<char>::__X() const {
+  static string s("%H:%M:%S");
+  return s;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+const wstring& __time_get_c_storage<wchar_t>::__X() const {
+  static wstring s(L"%H:%M:%S");
+  return s;
+}
+#endif
+
+template <>
+const string& __time_get_c_storage<char>::__c() const {
+  static string s("%a %b %d %H:%M:%S %Y");
+  return s;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+const wstring& __time_get_c_storage<wchar_t>::__c() const {
+  static wstring s(L"%a %b %d %H:%M:%S %Y");
+  return s;
+}
+#endif
+
+template <>
+const string& __time_get_c_storage<char>::__r() const {
+  static string s("%I:%M:%S %p");
+  return s;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+const wstring& __time_get_c_storage<wchar_t>::__r() const {
+  static wstring s(L"%I:%M:%S %p");
+  return s;
+}
+#endif
+
+// time_get_byname
+
+__time_get::__time_get(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {
+  if (__loc_ == 0)
+    __throw_runtime_error(("time_get_byname failed to construct for " + string(nm)).c_str());
+}
+
+__time_get::__time_get(const string& nm) : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0)) {
+  if (__loc_ == 0)
+    __throw_runtime_error(("time_get_byname failed to construct for " + nm).c_str());
+}
+
+__time_get::~__time_get() { freelocale(__loc_); }
+
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-field-initializers")
+
+template <>
+string __time_get_storage<char>::__analyze(char fmt, const ctype<char>& ct) {
+  tm t       = {0};
+  t.tm_sec   = 59;
+  t.tm_min   = 55;
+  t.tm_hour  = 23;
+  t.tm_mday  = 31;
+  t.tm_mon   = 11;
+  t.tm_year  = 161;
+  t.tm_wday  = 6;
+  t.tm_yday  = 364;
+  t.tm_isdst = -1;
+  char buf[100];
+  char f[3] = {0};
+  f[0]      = '%';
+  f[1]      = fmt;
+  size_t n  = strftime_l(buf, countof(buf), f, &t, __loc_);
+  char* bb  = buf;
+  char* be  = buf + n;
+  string result;
+  while (bb != be) {
+    if (ct.is(ctype_base::space, *bb)) {
+      result.push_back(' ');
+      for (++bb; bb != be && ct.is(ctype_base::space, *bb); ++bb)
+        ;
+      continue;
+    }
+    char* w               = bb;
+    ios_base::iostate err = ios_base::goodbit;
+    ptrdiff_t i           = __scan_keyword(w, be, this->__weeks_, this->__weeks_ + 14, ct, err, false) - this->__weeks_;
+    if (i < 14) {
+      result.push_back('%');
+      if (i < 7)
+        result.push_back('A');
+      else
+        result.push_back('a');
+      bb = w;
+      continue;
+    }
+    w = bb;
+    i = __scan_keyword(w, be, this->__months_, this->__months_ + 24, ct, err, false) - this->__months_;
+    if (i < 24) {
+      result.push_back('%');
+      if (i < 12)
+        result.push_back('B');
+      else
+        result.push_back('b');
+      if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
+        result.back() = 'm';
+      bb = w;
+      continue;
+    }
+    if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0) {
+      w = bb;
+      i = __scan_keyword(w, be, this->__am_pm_, this->__am_pm_ + 2, ct, err, false) - this->__am_pm_;
+      if (i < 2) {
+        result.push_back('%');
+        result.push_back('p');
+        bb = w;
+        continue;
+      }
+    }
+    w = bb;
+    if (ct.is(ctype_base::digit, *bb)) {
+      switch (__get_up_to_n_digits(bb, be, err, ct, 4)) {
+      case 6:
+        result.push_back('%');
+        result.push_back('w');
+        break;
+      case 7:
+        result.push_back('%');
+        result.push_back('u');
+        break;
+      case 11:
+        result.push_back('%');
+        result.push_back('I');
+        break;
+      case 12:
+        result.push_back('%');
+        result.push_back('m');
+        break;
+      case 23:
+        result.push_back('%');
+        result.push_back('H');
+        break;
+      case 31:
+        result.push_back('%');
+        result.push_back('d');
+        break;
+      case 55:
+        result.push_back('%');
+        result.push_back('M');
+        break;
+      case 59:
+        result.push_back('%');
+        result.push_back('S');
+        break;
+      case 61:
+        result.push_back('%');
+        result.push_back('y');
+        break;
+      case 364:
+        result.push_back('%');
+        result.push_back('j');
+        break;
+      case 2061:
+        result.push_back('%');
+        result.push_back('Y');
+        break;
+      default:
+        for (; w != bb; ++w)
+          result.push_back(*w);
+        break;
+      }
+      continue;
+    }
+    if (*bb == '%') {
+      result.push_back('%');
+      result.push_back('%');
+      ++bb;
+      continue;
+    }
+    result.push_back(*bb);
+    ++bb;
+  }
+  return result;
+}
+
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-braces")
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+wstring __time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct) {
+  tm t       = {0};
+  t.tm_sec   = 59;
+  t.tm_min   = 55;
+  t.tm_hour  = 23;
+  t.tm_mday  = 31;
+  t.tm_mon   = 11;
+  t.tm_year  = 161;
+  t.tm_wday  = 6;
+  t.tm_yday  = 364;
+  t.tm_isdst = -1;
+  char buf[100];
+  char f[3] = {0};
+  f[0]      = '%';
+  f[1]      = fmt;
+  strftime_l(buf, countof(buf), f, &t, __loc_);
+  wchar_t wbuf[100];
+  wchar_t* wbb   = wbuf;
+  mbstate_t mb   = {0};
+  const char* bb = buf;
+  size_t j       = __libcpp_mbsrtowcs_l(wbb, &bb, countof(wbuf), &mb, __loc_);
+  if (j == size_t(-1))
+    __throw_runtime_error("locale not supported");
+  wchar_t* wbe = wbb + j;
+  wstring result;
+  while (wbb != wbe) {
+    if (ct.is(ctype_base::space, *wbb)) {
+      result.push_back(L' ');
+      for (++wbb; wbb != wbe && ct.is(ctype_base::space, *wbb); ++wbb)
+        ;
+      continue;
+    }
+    wchar_t* w            = wbb;
+    ios_base::iostate err = ios_base::goodbit;
+    ptrdiff_t i = __scan_keyword(w, wbe, this->__weeks_, this->__weeks_ + 14, ct, err, false) - this->__weeks_;
+    if (i < 14) {
+      result.push_back(L'%');
+      if (i < 7)
+        result.push_back(L'A');
+      else
+        result.push_back(L'a');
+      wbb = w;
+      continue;
+    }
+    w = wbb;
+    i = __scan_keyword(w, wbe, this->__months_, this->__months_ + 24, ct, err, false) - this->__months_;
+    if (i < 24) {
+      result.push_back(L'%');
+      if (i < 12)
+        result.push_back(L'B');
+      else
+        result.push_back(L'b');
+      if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
+        result.back() = L'm';
+      wbb = w;
+      continue;
+    }
+    if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0) {
+      w = wbb;
+      i = __scan_keyword(w, wbe, this->__am_pm_, this->__am_pm_ + 2, ct, err, false) - this->__am_pm_;
+      if (i < 2) {
+        result.push_back(L'%');
+        result.push_back(L'p');
+        wbb = w;
+        continue;
+      }
+    }
+    w = wbb;
+    if (ct.is(ctype_base::digit, *wbb)) {
+      switch (__get_up_to_n_digits(wbb, wbe, err, ct, 4)) {
+      case 6:
+        result.push_back(L'%');
+        result.push_back(L'w');
+        break;
+      case 7:
+        result.push_back(L'%');
+        result.push_back(L'u');
+        break;
+      case 11:
+        result.push_back(L'%');
+        result.push_back(L'I');
+        break;
+      case 12:
+        result.push_back(L'%');
+        result.push_back(L'm');
+        break;
+      case 23:
+        result.push_back(L'%');
+        result.push_back(L'H');
+        break;
+      case 31:
+        result.push_back(L'%');
+        result.push_back(L'd');
+        break;
+      case 55:
+        result.push_back(L'%');
+        result.push_back(L'M');
+        break;
+      case 59:
+        result.push_back(L'%');
+        result.push_back(L'S');
+        break;
+      case 61:
+        result.push_back(L'%');
+        result.push_back(L'y');
+        break;
+      case 364:
+        result.push_back(L'%');
+        result.push_back(L'j');
+        break;
+      case 2061:
+        result.push_back(L'%');
+        result.push_back(L'Y');
+        break;
+      default:
+        for (; w != wbb; ++w)
+          result.push_back(*w);
+        break;
+      }
+      continue;
+    }
+    if (ct.narrow(*wbb, 0) == '%') {
+      result.push_back(L'%');
+      result.push_back(L'%');
+      ++wbb;
+      continue;
+    }
+    result.push_back(*wbb);
+    ++wbb;
+  }
+  return result;
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+template <>
+void __time_get_storage<char>::init(const ctype<char>& ct) {
+  tm t = {0};
+  char buf[100];
+  // __weeks_
+  for (int i = 0; i < 7; ++i) {
+    t.tm_wday = i;
+    strftime_l(buf, countof(buf), "%A", &t, __loc_);
+    __weeks_[i] = buf;
+    strftime_l(buf, countof(buf), "%a", &t, __loc_);
+    __weeks_[i + 7] = buf;
+  }
+  // __months_
+  for (int i = 0; i < 12; ++i) {
+    t.tm_mon = i;
+    strftime_l(buf, countof(buf), "%B", &t, __loc_);
+    __months_[i] = buf;
+    strftime_l(buf, countof(buf), "%b", &t, __loc_);
+    __months_[i + 12] = buf;
+  }
+  // __am_pm_
+  t.tm_hour = 1;
+  strftime_l(buf, countof(buf), "%p", &t, __loc_);
+  __am_pm_[0] = buf;
+  t.tm_hour   = 13;
+  strftime_l(buf, countof(buf), "%p", &t, __loc_);
+  __am_pm_[1] = buf;
+  __c_        = __analyze('c', ct);
+  __r_        = __analyze('r', ct);
+  __x_        = __analyze('x', ct);
+  __X_        = __analyze('X', ct);
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
+  tm t = {0};
+  char buf[100];
+  wchar_t wbuf[100];
+  wchar_t* wbe;
+  mbstate_t mb = {0};
+  // __weeks_
+  for (int i = 0; i < 7; ++i) {
+    t.tm_wday = i;
+    strftime_l(buf, countof(buf), "%A", &t, __loc_);
+    mb             = mbstate_t();
+    const char* bb = buf;
+    size_t j       = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
+    if (j == size_t(-1) || j == 0)
+      __throw_runtime_error("locale not supported");
+    wbe = wbuf + j;
+    __weeks_[i].assign(wbuf, wbe);
+    strftime_l(buf, countof(buf), "%a", &t, __loc_);
+    mb = mbstate_t();
+    bb = buf;
+    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
+    if (j == size_t(-1) || j == 0)
+      __throw_runtime_error("locale not supported");
+    wbe = wbuf + j;
+    __weeks_[i + 7].assign(wbuf, wbe);
+  }
+  // __months_
+  for (int i = 0; i < 12; ++i) {
+    t.tm_mon = i;
+    strftime_l(buf, countof(buf), "%B", &t, __loc_);
+    mb             = mbstate_t();
+    const char* bb = buf;
+    size_t j       = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
+    if (j == size_t(-1) || j == 0)
+      __throw_runtime_error("locale not supported");
+    wbe = wbuf + j;
+    __months_[i].assign(wbuf, wbe);
+    strftime_l(buf, countof(buf), "%b", &t, __loc_);
+    mb = mbstate_t();
+    bb = buf;
+    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
+    if (j == size_t(-1) || j == 0)
+      __throw_runtime_error("locale not supported");
+    wbe = wbuf + j;
+    __months_[i + 12].assign(wbuf, wbe);
+  }
+  // __am_pm_
+  t.tm_hour = 1;
+  strftime_l(buf, countof(buf), "%p", &t, __loc_);
+  mb             = mbstate_t();
+  const char* bb = buf;
+  size_t j       = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
+  if (j == size_t(-1))
+    __throw_runtime_error("locale not supported");
+  wbe = wbuf + j;
+  __am_pm_[0].assign(wbuf, wbe);
+  t.tm_hour = 13;
+  strftime_l(buf, countof(buf), "%p", &t, __loc_);
+  mb = mbstate_t();
+  bb = buf;
+  j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
+  if (j == size_t(-1))
+    __throw_runtime_error("locale not supported");
+  wbe = wbuf + j;
+  __am_pm_[1].assign(wbuf, wbe);
+  __c_ = __analyze('c', ct);
+  __r_ = __analyze('r', ct);
+  __x_ = __analyze('x', ct);
+  __X_ = __analyze('X', ct);
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+template <class CharT>
+struct _LIBCPP_HIDDEN __time_get_temp : public ctype_byname<CharT> {
+  explicit __time_get_temp(const char* nm) : ctype_byname<CharT>(nm, 1) {}
+  explicit __time_get_temp(const string& nm) : ctype_byname<CharT>(nm, 1) {}
+};
+
+template <>
+__time_get_storage<char>::__time_get_storage(const char* __nm) : __time_get(__nm) {
+  const __time_get_temp<char> ct(__nm);
+  init(ct);
+}
+
+template <>
+__time_get_storage<char>::__time_get_storage(const string& __nm) : __time_get(__nm) {
+  const __time_get_temp<char> ct(__nm);
+  init(ct);
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+__time_get_storage<wchar_t>::__time_get_storage(const char* __nm) : __time_get(__nm) {
+  const __time_get_temp<wchar_t> ct(__nm);
+  init(ct);
+}
+
+template <>
+__time_get_storage<wchar_t>::__time_get_storage(const string& __nm) : __time_get(__nm) {
+  const __time_get_temp<wchar_t> ct(__nm);
+  init(ct);
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+template <>
+time_base::dateorder __time_get_storage<char>::__do_date_order() const {
+  unsigned i;
+  for (i = 0; i < __x_.size(); ++i)
+    if (__x_[i] == '%')
+      break;
+  ++i;
+  switch (__x_[i]) {
+  case 'y':
+  case 'Y':
+    for (++i; i < __x_.size(); ++i)
+      if (__x_[i] == '%')
+        break;
+    if (i == __x_.size())
+      break;
+    ++i;
+    switch (__x_[i]) {
+    case 'm':
+      for (++i; i < __x_.size(); ++i)
+        if (__x_[i] == '%')
+          break;
+      if (i == __x_.size())
+        break;
+      ++i;
+      if (__x_[i] == 'd')
+        return time_base::ymd;
+      break;
+    case 'd':
+      for (++i; i < __x_.size(); ++i)
+        if (__x_[i] == '%')
+          break;
+      if (i == __x_.size())
+        break;
+      ++i;
+      if (__x_[i] == 'm')
+        return time_base::ydm;
+      break;
+    }
+    break;
+  case 'm':
+    for (++i; i < __x_.size(); ++i)
+      if (__x_[i] == '%')
+        break;
+    if (i == __x_.size())
+      break;
+    ++i;
+    if (__x_[i] == 'd') {
+      for (++i; i < __x_.size(); ++i)
+        if (__x_[i] == '%')
+          break;
+      if (i == __x_.size())
+        break;
+      ++i;
+      if (__x_[i] == 'y' || __x_[i] == 'Y')
+        return time_base::mdy;
+      break;
+    }
+    break;
+  case 'd':
+    for (++i; i < __x_.size(); ++i)
+      if (__x_[i] == '%')
+        break;
+    if (i == __x_.size())
+      break;
+    ++i;
+    if (__x_[i] == 'm') {
+      for (++i; i < __x_.size(); ++i)
+        if (__x_[i] == '%')
+          break;
+      if (i == __x_.size())
+        break;
+      ++i;
+      if (__x_[i] == 'y' || __x_[i] == 'Y')
+        return time_base::dmy;
+      break;
+    }
+    break;
+  }
+  return time_base::no_order;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+time_base::dateorder __time_get_storage<wchar_t>::__do_date_order() const {
+  unsigned i;
+  for (i = 0; i < __x_.size(); ++i)
+    if (__x_[i] == L'%')
+      break;
+  ++i;
+  switch (__x_[i]) {
+  case L'y':
+  case L'Y':
+    for (++i; i < __x_.size(); ++i)
+      if (__x_[i] == L'%')
+        break;
+    if (i == __x_.size())
+      break;
+    ++i;
+    switch (__x_[i]) {
+    case L'm':
+      for (++i; i < __x_.size(); ++i)
+        if (__x_[i] == L'%')
+          break;
+      if (i == __x_.size())
+        break;
+      ++i;
+      if (__x_[i] == L'd')
+        return time_base::ymd;
+      break;
+    case L'd':
+      for (++i; i < __x_.size(); ++i)
+        if (__x_[i] == L'%')
+          break;
+      if (i == __x_.size())
+        break;
+      ++i;
+      if (__x_[i] == L'm')
+        return time_base::ydm;
+      break;
+    }
+    break;
+  case L'm':
+    for (++i; i < __x_.size(); ++i)
+      if (__x_[i] == L'%')
+        break;
+    if (i == __x_.size())
+      break;
+    ++i;
+    if (__x_[i] == L'd') {
+      for (++i; i < __x_.size(); ++i)
+        if (__x_[i] == L'%')
+          break;
+      if (i == __x_.size())
+        break;
+      ++i;
+      if (__x_[i] == L'y' || __x_[i] == L'Y')
+        return time_base::mdy;
+      break;
+    }
+    break;
+  case L'd':
+    for (++i; i < __x_.size(); ++i)
+      if (__x_[i] == L'%')
+        break;
+    if (i == __x_.size())
+      break;
+    ++i;
+    if (__x_[i] == L'm') {
+      for (++i; i < __x_.size(); ++i)
+        if (__x_[i] == L'%')
+          break;
+      if (i == __x_.size())
+        break;
+      ++i;
+      if (__x_[i] == L'y' || __x_[i] == L'Y')
+        return time_base::dmy;
+      break;
+    }
+    break;
+  }
+  return time_base::no_order;
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// time_put
+
+__time_put::__time_put(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {
+  if (__loc_ == 0)
+    __throw_runtime_error(("time_put_byname failed to construct for " + string(nm)).c_str());
+}
+
+__time_put::__time_put(const string& nm) : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0)) {
+  if (__loc_ == 0)
+    __throw_runtime_error(("time_put_byname failed to construct for " + nm).c_str());
+}
+
+__time_put::~__time_put() {
+  if (__loc_ != _LIBCPP_GET_C_LOCALE)
+    freelocale(__loc_);
+}
+
+void __time_put::__do_put(char* __nb, char*& __ne, const tm* __tm, char __fmt, char __mod) const {
+  char fmt[] = {'%', __fmt, __mod, 0};
+  if (__mod != 0)
+    swap(fmt[1], fmt[2]);
+  size_t n = strftime_l(__nb, countof(__nb, __ne), fmt, __tm, __loc_);
+  __ne     = __nb + n;
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+void __time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm, char __fmt, char __mod) const {
+  char __nar[100];
+  char* __ne = __nar + 100;
+  __do_put(__nar, __ne, __tm, __fmt, __mod);
+  mbstate_t mb     = {0};
+  const char* __nb = __nar;
+  size_t j         = __libcpp_mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
+  if (j == size_t(-1))
+    __throw_runtime_error("locale not supported");
+  __we = __wb + j;
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// moneypunct_byname
+
+template <class charT>
+static void __init_pat(
+    money_base::pattern& pat,
+    basic_string<charT>& __curr_symbol_,
+    bool intl,
+    char cs_precedes,
+    char sep_by_space,
+    char sign_posn,
+    charT space_char) {
+  const char sign                = static_cast<char>(money_base::sign);
+  const char space               = static_cast<char>(money_base::space);
+  const char none                = static_cast<char>(money_base::none);
+  const char symbol              = static_cast<char>(money_base::symbol);
+  const char value               = static_cast<char>(money_base::value);
+  const bool symbol_contains_sep = intl && __curr_symbol_.size() == 4;
+
+  // Comments on case branches reflect 'C11 7.11.2.1 The localeconv
+  // function'. "Space between sign and symbol or value" means that
+  // if the sign is adjacent to the symbol, there's a space between
+  // them, and otherwise there's a space between the sign and value.
+  //
+  // C11's localeconv specifies that the fourth character of an
+  // international curr_symbol is used to separate the sign and
+  // value when sep_by_space says to do so. C++ can't represent
+  // that, so we just use a space.  When sep_by_space says to
+  // separate the symbol and value-or-sign with a space, we rearrange the
+  // curr_symbol to put its spacing character on the correct side of
+  // the symbol.
+  //
+  // We also need to avoid adding an extra space between the sign
+  // and value when the currency symbol is suppressed (by not
+  // setting showbase).  We match glibc's strfmon by interpreting
+  // sep_by_space==1 as "omit the space when the currency symbol is
+  // absent".
+  //
+  // Users who want to get this right should use ICU instead.
+
+  switch (cs_precedes) {
+  case 0: // value before curr_symbol
+    if (symbol_contains_sep) {
+      // Move the separator to before the symbol, to place it
+      // between the value and symbol.
+      rotate(__curr_symbol_.begin(), __curr_symbol_.begin() + 3, __curr_symbol_.end());
+    }
+    switch (sign_posn) {
+    case 0: // Parentheses surround the quantity and currency symbol.
+      pat.field[0] = sign;
+      pat.field[1] = value;
+      pat.field[2] = none; // Any space appears in the symbol.
+      pat.field[3] = symbol;
+      switch (sep_by_space) {
+      case 0: // No space separates the currency symbol and value.
+              // This case may have changed between C99 and C11;
+              // assume the currency symbol matches the intention.
+      case 2: // Space between sign and currency or value.
+        // The "sign" is two parentheses, so no space here either.
+        return;
+      case 1: // Space between currency-and-sign or currency and value.
+        if (!symbol_contains_sep) {
+          // We insert the space into the symbol instead of
+          // setting pat.field[2]=space so that when
+          // showbase is not set, the space goes away too.
+          __curr_symbol_.insert(0, 1, space_char);
+        }
+        return;
+      default:
+        break;
+      }
+      break;
+    case 1: // The sign string precedes the quantity and currency symbol.
+      pat.field[0] = sign;
+      pat.field[3] = symbol;
+      switch (sep_by_space) {
+      case 0: // No space separates the currency symbol and value.
+        pat.field[1] = value;
+        pat.field[2] = none;
+        return;
+      case 1: // Space between currency-and-sign or currency and value.
+        pat.field[1] = value;
+        pat.field[2] = none;
+        if (!symbol_contains_sep) {
+          // We insert the space into the symbol instead of
+          // setting pat.field[2]=space so that when
+          // showbase is not set, the space goes away too.
+          __curr_symbol_.insert(0, 1, space_char);
+        }
+        return;
+      case 2: // Space between sign and currency or value.
+        pat.field[1] = space;
+        pat.field[2] = value;
+        if (symbol_contains_sep) {
+          // Remove the separator from the symbol, since it
+          // has already appeared after the sign.
+          __curr_symbol_.erase(__curr_symbol_.begin());
+        }
+        return;
+      default:
+        break;
+      }
+      break;
+    case 2: // The sign string succeeds the quantity and currency symbol.
+      pat.field[0] = value;
+      pat.field[3] = sign;
+      switch (sep_by_space) {
+      case 0: // No space separates the currency symbol and value.
+        pat.field[1] = none;
+        pat.field[2] = symbol;
+        return;
+      case 1: // Space between currency-and-sign or currency and value.
+        if (!symbol_contains_sep) {
+          // We insert the space into the symbol instead of
+          // setting pat.field[1]=space so that when
+          // showbase is not set, the space goes away too.
+          __curr_symbol_.insert(0, 1, space_char);
+        }
+        pat.field[1] = none;
+        pat.field[2] = symbol;
+        return;
+      case 2: // Space between sign and currency or value.
+        pat.field[1] = symbol;
+        pat.field[2] = space;
+        if (symbol_contains_sep) {
+          // Remove the separator from the symbol, since it
+          // should not be removed if showbase is absent.
+          __curr_symbol_.erase(__curr_symbol_.begin());
+        }
+        return;
+      default:
+        break;
+      }
+      break;
+    case 3: // The sign string immediately precedes the currency symbol.
+      pat.field[0] = value;
+      pat.field[3] = symbol;
+      switch (sep_by_space) {
+      case 0: // No space separates the currency symbol and value.
+        pat.field[1] = none;
+        pat.field[2] = sign;
+        return;
+      case 1: // Space between currency-and-sign or currency and value.
+        pat.field[1] = space;
+        pat.field[2] = sign;
+        if (symbol_contains_sep) {
+          // Remove the separator from the symbol, since it
+          // has already appeared before the sign.
+          __curr_symbol_.erase(__curr_symbol_.begin());
+        }
+        return;
+      case 2: // Space between sign and currency or value.
+        pat.field[1] = sign;
+        pat.field[2] = none;
+        if (!symbol_contains_sep) {
+          // We insert the space into the symbol instead of
+          // setting pat.field[2]=space so that when
+          // showbase is not set, the space goes away too.
+          __curr_symbol_.insert(0, 1, space_char);
+        }
+        return;
+      default:
+        break;
+      }
+      break;
+    case 4: // The sign string immediately succeeds the currency symbol.
+      pat.field[0] = value;
+      pat.field[3] = sign;
+      switch (sep_by_space) {
+      case 0: // No space separates the currency symbol and value.
+        pat.field[1] = none;
+        pat.field[2] = symbol;
+        return;
+      case 1: // Space between currency-and-sign or currency and value.
+        pat.field[1] = none;
+        pat.field[2] = symbol;
+        if (!symbol_contains_sep) {
+          // We insert the space into the symbol instead of
+          // setting pat.field[1]=space so that when
+          // showbase is not set, the space goes away too.
+          __curr_symbol_.insert(0, 1, space_char);
+        }
+        return;
+      case 2: // Space between sign and currency or value.
+        pat.field[1] = symbol;
+        pat.field[2] = space;
+        if (symbol_contains_sep) {
+          // Remove the separator from the symbol, since it
+          // should not disappear when showbase is absent.
+          __curr_symbol_.erase(__curr_symbol_.begin());
+        }
+        return;
+      default:
+        break;
+      }
+      break;
+    default:
+      break;
+    }
+    break;
+  case 1: // curr_symbol before value
+    switch (sign_posn) {
+    case 0: // Parentheses surround the quantity and currency symbol.
+      pat.field[0] = sign;
+      pat.field[1] = symbol;
+      pat.field[2] = none; // Any space appears in the symbol.
+      pat.field[3] = value;
+      switch (sep_by_space) {
+      case 0: // No space separates the currency symbol and value.
+              // This case may have changed between C99 and C11;
+              // assume the currency symbol matches the intention.
+      case 2: // Space between sign and currency or value.
+        // The "sign" is two parentheses, so no space here either.
+        return;
+      case 1: // Space between currency-and-sign or currency and value.
+        if (!symbol_contains_sep) {
+          // We insert the space into the symbol instead of
+          // setting pat.field[2]=space so that when
+          // showbase is not set, the space goes away too.
+          __curr_symbol_.insert(0, 1, space_char);
+        }
+        return;
+      default:
+        break;
+      }
+      break;
+    case 1: // The sign string precedes the quantity and currency symbol.
+      pat.field[0] = sign;
+      pat.field[3] = value;
+      switch (sep_by_space) {
+      case 0: // No space separates the currency symbol and value.
+        pat.field[1] = symbol;
+        pat.field[2] = none;
+        return;
+      case 1: // Space between currency-and-sign or currency and value.
+        pat.field[1] = symbol;
+        pat.field[2] = none;
+        if (!symbol_contains_sep) {
+          // We insert the space into the symbol instead of
+          // setting pat.field[2]=space so that when
+          // showbase is not set, the space goes away too.
+          __curr_symbol_.push_back(space_char);
+        }
+        return;
+      case 2: // Space between sign and currency or value.
+        pat.field[1] = space;
+        pat.field[2] = symbol;
+        if (symbol_contains_sep) {
+          // Remove the separator from the symbol, since it
+          // has already appeared after the sign.
+          __curr_symbol_.pop_back();
+        }
+        return;
+      default:
+        break;
+      }
+      break;
+    case 2: // The sign string succeeds the quantity and currency symbol.
+      pat.field[0] = symbol;
+      pat.field[3] = sign;
+      switch (sep_by_space) {
+      case 0: // No space separates the currency symbol and value.
+        pat.field[1] = none;
+        pat.field[2] = value;
+        return;
+      case 1: // Space between currency-and-sign or currency and value.
+        pat.field[1] = none;
+        pat.field[2] = value;
+        if (!symbol_contains_sep) {
+          // We insert the space into the symbol instead of
+          // setting pat.field[1]=space so that when
+          // showbase is not set, the space goes away too.
+          __curr_symbol_.push_back(space_char);
+        }
+        return;
+      case 2: // Space between sign and currency or value.
+        pat.field[1] = value;
+        pat.field[2] = space;
+        if (symbol_contains_sep) {
+          // Remove the separator from the symbol, since it
+          // will appear before the sign.
+          __curr_symbol_.pop_back();
+        }
+        return;
+      default:
+        break;
+      }
+      break;
+    case 3: // The sign string immediately precedes the currency symbol.
+      pat.field[0] = sign;
+      pat.field[3] = value;
+      switch (sep_by_space) {
+      case 0: // No space separates the currency symbol and value.
+        pat.field[1] = symbol;
+        pat.field[2] = none;
+        return;
+      case 1: // Space between currency-and-sign or currency and value.
+        pat.field[1] = symbol;
+        pat.field[2] = none;
+        if (!symbol_contains_sep) {
+          // We insert the space into the symbol instead of
+          // setting pat.field[2]=space so that when
+          // showbase is not set, the space goes away too.
+          __curr_symbol_.push_back(space_char);
+        }
+        return;
+      case 2: // Space between sign and currency or value.
+        pat.field[1] = space;
+        pat.field[2] = symbol;
+        if (symbol_contains_sep) {
+          // Remove the separator from the symbol, since it
+          // has already appeared after the sign.
+          __curr_symbol_.pop_back();
+        }
+        return;
+      default:
+        break;
+      }
+      break;
+    case 4: // The sign string immediately succeeds the currency symbol.
+      pat.field[0] = symbol;
+      pat.field[3] = value;
+      switch (sep_by_space) {
+      case 0: // No space separates the currency symbol and value.
+        pat.field[1] = sign;
+        pat.field[2] = none;
+        return;
+      case 1: // Space between currency-and-sign or currency and value.
+        pat.field[1] = sign;
+        pat.field[2] = space;
+        if (symbol_contains_sep) {
+          // Remove the separator from the symbol, since it
+          // should not disappear when showbase is absent.
+          __curr_symbol_.pop_back();
+        }
+        return;
+      case 2: // Space between sign and currency or value.
+        pat.field[1] = none;
+        pat.field[2] = sign;
+        if (!symbol_contains_sep) {
+          // We insert the space into the symbol instead of
+          // setting pat.field[1]=space so that when
+          // showbase is not set, the space goes away too.
+          __curr_symbol_.push_back(space_char);
+        }
+        return;
+      default:
+        break;
+      }
+      break;
+    default:
+      break;
+    }
+    break;
+  default:
+    break;
+  }
+  pat.field[0] = symbol;
+  pat.field[1] = sign;
+  pat.field[2] = none;
+  pat.field[3] = value;
+}
+
+template <>
+void moneypunct_byname<char, false>::init(const char* nm) {
+  typedef moneypunct<char, false> base;
+  __libcpp_unique_locale loc(nm);
+  if (!loc)
+    __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
+
+  lconv* lc = __libcpp_localeconv_l(loc.get());
+  if (!checked_string_to_char_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
+    __decimal_point_ = base::do_decimal_point();
+  if (!checked_string_to_char_convert(__thousands_sep_, lc->mon_thousands_sep, loc.get()))
+    __thousands_sep_ = base::do_thousands_sep();
+
+  __grouping_    = lc->mon_grouping;
+  __curr_symbol_ = lc->currency_symbol;
+  if (lc->frac_digits != CHAR_MAX)
+    __frac_digits_ = lc->frac_digits;
+  else
+    __frac_digits_ = base::do_frac_digits();
+  if (lc->p_sign_posn == 0)
+    __positive_sign_ = "()";
+  else
+    __positive_sign_ = lc->positive_sign;
+  if (lc->n_sign_posn == 0)
+    __negative_sign_ = "()";
+  else
+    __negative_sign_ = lc->negative_sign;
+  // Assume the positive and negative formats will want spaces in
+  // the same places in curr_symbol since there's no way to
+  // represent anything else.
+  string_type __dummy_curr_symbol = __curr_symbol_;
+  __init_pat(__pos_format_, __dummy_curr_symbol, false, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
+  __init_pat(__neg_format_, __curr_symbol_, false, lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
+}
+
+template <>
+void moneypunct_byname<char, true>::init(const char* nm) {
+  typedef moneypunct<char, true> base;
+  __libcpp_unique_locale loc(nm);
+  if (!loc)
+    __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
+
+  lconv* lc = __libcpp_localeconv_l(loc.get());
+  if (!checked_string_to_char_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
+    __decimal_point_ = base::do_decimal_point();
+  if (!checked_string_to_char_convert(__thousands_sep_, lc->mon_thousands_sep, loc.get()))
+    __thousands_sep_ = base::do_thousands_sep();
+  __grouping_    = lc->mon_grouping;
+  __curr_symbol_ = lc->int_curr_symbol;
+  if (lc->int_frac_digits != CHAR_MAX)
+    __frac_digits_ = lc->int_frac_digits;
+  else
+    __frac_digits_ = base::do_frac_digits();
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
+  if (lc->p_sign_posn == 0)
+#else  // _LIBCPP_MSVCRT
+  if (lc->int_p_sign_posn == 0)
+#endif // !_LIBCPP_MSVCRT
+    __positive_sign_ = "()";
+  else
+    __positive_sign_ = lc->positive_sign;
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
+  if (lc->n_sign_posn == 0)
+#else  // _LIBCPP_MSVCRT
+  if (lc->int_n_sign_posn == 0)
+#endif // !_LIBCPP_MSVCRT
+    __negative_sign_ = "()";
+  else
+    __negative_sign_ = lc->negative_sign;
+  // Assume the positive and negative formats will want spaces in
+  // the same places in curr_symbol since there's no way to
+  // represent anything else.
+  string_type __dummy_curr_symbol = __curr_symbol_;
+#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
+  __init_pat(__pos_format_, __dummy_curr_symbol, true, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
+  __init_pat(__neg_format_, __curr_symbol_, true, lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
+#else  // _LIBCPP_MSVCRT
+  __init_pat(
+      __pos_format_,
+      __dummy_curr_symbol,
+      true,
+      lc->int_p_cs_precedes,
+      lc->int_p_sep_by_space,
+      lc->int_p_sign_posn,
+      ' ');
+  __init_pat(
+      __neg_format_, __curr_symbol_, true, lc->int_n_cs_precedes, lc->int_n_sep_by_space, lc->int_n_sign_posn, ' ');
+#endif // !_LIBCPP_MSVCRT
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+void moneypunct_byname<wchar_t, false>::init(const char* nm) {
+  typedef moneypunct<wchar_t, false> base;
+  __libcpp_unique_locale loc(nm);
+  if (!loc)
+    __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
+  lconv* lc = __libcpp_localeconv_l(loc.get());
+  if (!checked_string_to_wchar_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
+    __decimal_point_ = base::do_decimal_point();
+  if (!checked_string_to_wchar_convert(__thousands_sep_, lc->mon_thousands_sep, loc.get()))
+    __thousands_sep_ = base::do_thousands_sep();
+  __grouping_ = lc->mon_grouping;
+  wchar_t wbuf[100];
+  mbstate_t mb   = {0};
+  const char* bb = lc->currency_symbol;
+  size_t j       = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
+  if (j == size_t(-1))
+    __throw_runtime_error("locale not supported");
+  wchar_t* wbe = wbuf + j;
+  __curr_symbol_.assign(wbuf, wbe);
+  if (lc->frac_digits != CHAR_MAX)
+    __frac_digits_ = lc->frac_digits;
+  else
+    __frac_digits_ = base::do_frac_digits();
+  if (lc->p_sign_posn == 0)
+    __positive_sign_ = L"()";
+  else {
+    mb = mbstate_t();
+    bb = lc->positive_sign;
+    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
+    if (j == size_t(-1))
+      __throw_runtime_error("locale not supported");
+    wbe = wbuf + j;
+    __positive_sign_.assign(wbuf, wbe);
+  }
+  if (lc->n_sign_posn == 0)
+    __negative_sign_ = L"()";
+  else {
+    mb = mbstate_t();
+    bb = lc->negative_sign;
+    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
+    if (j == size_t(-1))
+      __throw_runtime_error("locale not supported");
+    wbe = wbuf + j;
+    __negative_sign_.assign(wbuf, wbe);
+  }
+  // Assume the positive and negative formats will want spaces in
+  // the same places in curr_symbol since there's no way to
+  // represent anything else.
+  string_type __dummy_curr_symbol = __curr_symbol_;
+  __init_pat(__pos_format_, __dummy_curr_symbol, false, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
+  __init_pat(__neg_format_, __curr_symbol_, false, lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
+}
+
+template <>
+void moneypunct_byname<wchar_t, true>::init(const char* nm) {
+  typedef moneypunct<wchar_t, true> base;
+  __libcpp_unique_locale loc(nm);
+  if (!loc)
+    __throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
+
+  lconv* lc = __libcpp_localeconv_l(loc.get());
+  if (!checked_string_to_wchar_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
+    __decimal_point_ = base::do_decimal_point();
+  if (!checked_string_to_wchar_convert(__thousands_sep_, lc->mon_thousands_sep, loc.get()))
+    __thousands_sep_ = base::do_thousands_sep();
+  __grouping_ = lc->mon_grouping;
+  wchar_t wbuf[100];
+  mbstate_t mb   = {0};
+  const char* bb = lc->int_curr_symbol;
+  size_t j       = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
+  if (j == size_t(-1))
+    __throw_runtime_error("locale not supported");
+  wchar_t* wbe = wbuf + j;
+  __curr_symbol_.assign(wbuf, wbe);
+  if (lc->int_frac_digits != CHAR_MAX)
+    __frac_digits_ = lc->int_frac_digits;
+  else
+    __frac_digits_ = base::do_frac_digits();
+#  if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
+  if (lc->p_sign_posn == 0)
+#  else  // _LIBCPP_MSVCRT
+  if (lc->int_p_sign_posn == 0)
+#  endif // !_LIBCPP_MSVCRT
+    __positive_sign_ = L"()";
+  else {
+    mb = mbstate_t();
+    bb = lc->positive_sign;
+    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
+    if (j == size_t(-1))
+      __throw_runtime_error("locale not supported");
+    wbe = wbuf + j;
+    __positive_sign_.assign(wbuf, wbe);
+  }
+#  if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
+  if (lc->n_sign_posn == 0)
+#  else  // _LIBCPP_MSVCRT
+  if (lc->int_n_sign_posn == 0)
+#  endif // !_LIBCPP_MSVCRT
+    __negative_sign_ = L"()";
+  else {
+    mb = mbstate_t();
+    bb = lc->negative_sign;
+    j  = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
+    if (j == size_t(-1))
+      __throw_runtime_error("locale not supported");
+    wbe = wbuf + j;
+    __negative_sign_.assign(wbuf, wbe);
+  }
+  // Assume the positive and negative formats will want spaces in
+  // the same places in curr_symbol since there's no way to
+  // represent anything else.
+  string_type __dummy_curr_symbol = __curr_symbol_;
+#  if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
+  __init_pat(__pos_format_, __dummy_curr_symbol, true, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
+  __init_pat(__neg_format_, __curr_symbol_, true, lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
+#  else  // _LIBCPP_MSVCRT
+  __init_pat(
+      __pos_format_,
+      __dummy_curr_symbol,
+      true,
+      lc->int_p_cs_precedes,
+      lc->int_p_sep_by_space,
+      lc->int_p_sign_posn,
+      L' ');
+  __init_pat(
+      __neg_format_, __curr_symbol_, true, lc->int_n_cs_precedes, lc->int_n_sep_by_space, lc->int_n_sign_posn, L' ');
+#  endif // !_LIBCPP_MSVCRT
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/locale.h b/third_party/libcxx/locale.h
index 3fb812035..425bf47d4 100644
--- a/third_party/libcxx/locale.h
+++ b/third_party/libcxx/locale.h
@@ -35,10 +35,6 @@ Functions:
 
 #include <__config>
 
-#if defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   error "<locale.h> is not supported since libc++ has been configured without support for localization."
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
diff --git a/third_party/libcxx/locale2.cpp b/third_party/libcxx/locale2.cpp
new file mode 100644
index 000000000..0e9778f1d
--- /dev/null
+++ b/third_party/libcxx/locale2.cpp
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__utility/no_destroy.h>
+#include <algorithm>
+#include <clocale>
+#include <codecvt>
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <locale>
+#include <new>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <vector>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  include <cwctype>
+#endif
+
+#if defined(_AIX)
+#  include <sys/localedef.h> // for __lc_ctype_ptr
+#endif
+
+#if defined(_LIBCPP_MSVCRT)
+#  define _CTYPE_DISABLE_MACROS
+#endif
+
+#if !defined(_LIBCPP_MSVCRT) && !defined(__MINGW32__) && !defined(__BIONIC__) && !defined(__NuttX__)
+#  include <langinfo.h>
+#endif
+
+#include "atomic_support.h"
+#include "sso_allocator.h"
+
+// On Linux, wint_t and wchar_t have different signed-ness, and this causes
+// lots of noise in the build log, but no bugs that I know of.
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wsign-conversion")
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+void __do_nothing(void*) {}
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<wchar_t>;)
+
+template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<wchar_t>;)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/locale3.cpp b/third_party/libcxx/locale3.cpp
new file mode 100644
index 000000000..c185d1e44
--- /dev/null
+++ b/third_party/libcxx/locale3.cpp
@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__utility/no_destroy.h>
+#include <algorithm>
+#include <clocale>
+#include <codecvt>
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <locale>
+#include <new>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <vector>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  include <cwctype>
+#endif
+
+#if defined(_AIX)
+#  include <sys/localedef.h> // for __lc_ctype_ptr
+#endif
+
+#if defined(_LIBCPP_MSVCRT)
+#  define _CTYPE_DISABLE_MACROS
+#endif
+
+#if !defined(_LIBCPP_MSVCRT) && !defined(__MINGW32__) && !defined(__BIONIC__) && !defined(__NuttX__)
+#  include <langinfo.h>
+#endif
+
+#include "atomic_support.h"
+#include "sso_allocator.h"
+
+// On Linux, wint_t and wchar_t have different signed-ness, and this causes
+// lots of noise in the build log, but no bugs that I know of.
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wsign-conversion")
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, false>;
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, true>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, false>;)
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, true>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, false>;
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, true>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, false>;)
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, true>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char, char, mbstate_t>;
+_LIBCPP_IF_WIDE_CHARACTERS(
+    template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<wchar_t, char, mbstate_t>;)
+template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
+    codecvt_byname<char16_t, char, mbstate_t>;
+template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS
+    codecvt_byname<char32_t, char, mbstate_t>;
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char8_t, mbstate_t>;
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char8_t, mbstate_t>;
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/locale4.cpp b/third_party/libcxx/locale4.cpp
new file mode 100644
index 000000000..3e6d757e2
--- /dev/null
+++ b/third_party/libcxx/locale4.cpp
@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__utility/no_destroy.h>
+#include <algorithm>
+#include <clocale>
+#include <codecvt>
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <locale>
+#include <new>
+#include <string>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+#include <vector>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  include <cwctype>
+#endif
+
+#if defined(_AIX)
+#  include <sys/localedef.h> // for __lc_ctype_ptr
+#endif
+
+#if defined(_LIBCPP_MSVCRT)
+#  define _CTYPE_DISABLE_MACROS
+#endif
+
+#if !defined(_LIBCPP_MSVCRT) && !defined(__MINGW32__) && !defined(__BIONIC__) && !defined(__NuttX__)
+#  include <langinfo.h>
+#endif
+
+#include "atomic_support.h"
+#include "sso_allocator.h"
+
+// On Linux, wint_t and wchar_t have different signed-ness, and this causes
+// lots of noise in the build log, but no bugs that I know of.
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wsign-conversion")
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<wchar_t>;)
+
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<char>;
+_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<wchar_t>;)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/map b/third_party/libcxx/map
index eb7c204ac..02bd17ccb 100644
--- a/third_party/libcxx/map
+++ b/third_party/libcxx/map
@@ -70,6 +70,8 @@ public:
     template <class InputIterator>
         map(InputIterator first, InputIterator last,
             const key_compare& comp, const allocator_type& a);
+    template<container-compatible-range<value_type> R>
+      map(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
     map(const map& m);
     map(map&& m)
         noexcept(
@@ -83,6 +85,9 @@ public:
     template <class InputIterator>
         map(InputIterator first, InputIterator last, const allocator_type& a)
             : map(first, last, Compare(), a) {}  // C++14
+    template<container-compatible-range<value_type> R>
+      map(from_range_t, R&& rg, const Allocator& a))
+        : map(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
     map(initializer_list<value_type> il, const allocator_type& a)
         : map(il, Compare(), a) {}  // C++14
    ~map();
@@ -138,6 +143,8 @@ public:
         iterator insert(const_iterator position, P&& p);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                                      // C++23
     void insert(initializer_list<value_type> il);
 
     node_type extract(const_iterator position);                                       // C++17
@@ -229,6 +236,11 @@ template <class InputIterator,
 map(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
   -> map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Compare, Allocator>; // C++17
 
+template<ranges::input_range R, class Compare = less<range-key-type<R>,
+         class Allocator = allocator<range-to-alloc-type<R>>>
+  map(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+    -> map<range-key-type<R>, range-mapped-type<R>, Compare, Allocator>; // C++23
+
 template<class Key, class T, class Compare = less<Key>,
     class Allocator = allocator<pair<const Key, T>>>
 map(initializer_list<pair<const Key, T>>, Compare = Compare(), Allocator = Allocator())
@@ -239,6 +251,10 @@ map(InputIterator, InputIterator, Allocator)
   -> map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, less<iter_key_t<InputIterator>>,
     Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  map(from_range_t, R&&, Allocator)
+    -> map<range-key-type<R>, range-mapped-type<R>, less<range-key-type<R>>, Allocator>; // C++23
+
 template<class Key, class T, class Allocator>
 map(initializer_list<pair<const Key, T>>, Allocator) -> map<Key, T, less<Key>, Allocator>; // C++17
 
@@ -338,6 +354,9 @@ public:
     template <class InputIterator>
         multimap(InputIterator first, InputIterator last, const key_compare& comp,
                  const allocator_type& a);
+    template<container-compatible-range<value_type> R>
+      multimap(from_range_t, R&& rg,
+               const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
     multimap(const multimap& m);
     multimap(multimap&& m)
         noexcept(
@@ -352,6 +371,9 @@ public:
     template <class InputIterator>
         multimap(InputIterator first, InputIterator last, const allocator_type& a)
             : multimap(first, last, Compare(), a) {} // C++14
+    template<container-compatible-range<value_type> R>
+      multimap(from_range_t, R&& rg, const Allocator& a))
+        : multimap(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
     multimap(initializer_list<value_type> il, const allocator_type& a)
         : multimap(il, Compare(), a) {} // C++14
     ~multimap();
@@ -400,6 +422,8 @@ public:
         iterator insert(const_iterator position, P&& p);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                                      // C++23
     void insert(initializer_list<value_type> il);
 
     node_type extract(const_iterator position);                                       // C++17
@@ -474,6 +498,11 @@ template <class InputIterator,
 multimap(InputIterator, InputIterator, Compare = Compare(), Allocator = Allocator())
   -> multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Compare, Allocator>; // C++17
 
+template<ranges::input_range R, class Compare = less<range-key-type<R>>,
+          class Allocator = allocator<range-to-alloc-type<R>>>
+  multimap(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+    -> multimap<range-key-type<R>, range-mapped-type<R>, Compare, Allocator>; // C++23
+
 template<class Key, class T, class Compare = less<Key>,
     class Allocator = allocator<pair<const Key, T>>>
 multimap(initializer_list<pair<const Key, T>>, Compare = Compare(), Allocator = Allocator())
@@ -484,6 +513,10 @@ multimap(InputIterator, InputIterator, Allocator)
   -> multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>,
     less<iter_key_t<InputIterator>>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  multimap(from_range_t, R&&, Allocator)
+    -> multimap<range-key-type<R>, range-mapped-type<R>, less<range-key-type<R>>, Allocator>; // C++23
+
 template<class Key, class T, class Allocator>
 multimap(initializer_list<pair<const Key, T>>, Allocator)
   -> multimap<Key, T, less<Key>, Allocator>; // C++17
@@ -541,23 +574,28 @@ erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/ranges_iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__tree>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
+#include <stdexcept>
 #include <tuple>
 #include <version>
 
@@ -578,268 +616,223 @@ erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);  // C++20
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Key, class _CP, class _Compare,
+template <class _Key,
+          class _CP,
+          class _Compare,
           bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value>
-class __map_value_compare
-    : private _Compare
-{
+class __map_value_compare : private _Compare {
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __map_value_compare()
-        _NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
-        : _Compare() {}
-    _LIBCPP_INLINE_VISIBILITY
-    __map_value_compare(_Compare __c)
-        _NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
-        : _Compare(__c) {}
-    _LIBCPP_INLINE_VISIBILITY
-    const _Compare& key_comp() const _NOEXCEPT {return *this;}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _CP& __x, const _CP& __y) const
-        {return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y.__get_value().first);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _CP& __x, const _Key& __y) const
-        {return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Key& __x, const _CP& __y) const
-        {return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);}
-    _LIBCPP_HIDE_FROM_ABI void swap(__map_value_compare& __y)
-        _NOEXCEPT_(__is_nothrow_swappable<_Compare>::value)
-    {
-      using _VSTD::swap;
-      swap(static_cast<_Compare&>(*this), static_cast<_Compare&>(__y));
-    }
+  _LIBCPP_HIDE_FROM_ABI __map_value_compare() _NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
+      : _Compare() {}
+  _LIBCPP_HIDE_FROM_ABI __map_value_compare(_Compare __c) _NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
+      : _Compare(__c) {}
+  _LIBCPP_HIDE_FROM_ABI const _Compare& key_comp() const _NOEXCEPT { return *this; }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _CP& __y) const {
+    return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y.__get_value().first);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _Key& __y) const {
+    return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _CP& __y) const {
+    return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);
+  }
+  _LIBCPP_HIDE_FROM_ABI void swap(__map_value_compare& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Compare>) {
+    using std::swap;
+    swap(static_cast<_Compare&>(*this), static_cast<_Compare&>(__y));
+  }
 
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _K2& __x, const _CP& __y) const
-        {return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);}
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _K2& __x, const _CP& __y) const {
+    return static_cast<const _Compare&>(*this)(__x, __y.__get_value().first);
+  }
 
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _CP& __x, const _K2& __y) const
-        {return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y);}
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _K2& __y) const {
+    return static_cast<const _Compare&>(*this)(__x.__get_value().first, __y);
+  }
 #endif
 };
 
 template <class _Key, class _CP, class _Compare>
-class __map_value_compare<_Key, _CP, _Compare, false>
-{
-    _Compare __comp_;
+class __map_value_compare<_Key, _CP, _Compare, false> {
+  _Compare __comp_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __map_value_compare()
-        _NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
-        : __comp_() {}
-    _LIBCPP_INLINE_VISIBILITY
-    __map_value_compare(_Compare __c)
-        _NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
-        : __comp_(__c) {}
-    _LIBCPP_INLINE_VISIBILITY
-    const _Compare& key_comp() const _NOEXCEPT {return __comp_;}
+  _LIBCPP_HIDE_FROM_ABI __map_value_compare() _NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
+      : __comp_() {}
+  _LIBCPP_HIDE_FROM_ABI __map_value_compare(_Compare __c) _NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
+      : __comp_(__c) {}
+  _LIBCPP_HIDE_FROM_ABI const _Compare& key_comp() const _NOEXCEPT { return __comp_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _CP& __x, const _CP& __y) const
-        {return __comp_(__x.__get_value().first, __y.__get_value().first);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _CP& __x, const _Key& __y) const
-        {return __comp_(__x.__get_value().first, __y);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Key& __x, const _CP& __y) const
-        {return __comp_(__x, __y.__get_value().first);}
-    void swap(__map_value_compare& __y)
-        _NOEXCEPT_(__is_nothrow_swappable<_Compare>::value)
-    {
-        using _VSTD::swap;
-        swap(__comp_, __y.__comp_);
-    }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _CP& __y) const {
+    return __comp_(__x.__get_value().first, __y.__get_value().first);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _Key& __y) const {
+    return __comp_(__x.__get_value().first, __y);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _CP& __y) const {
+    return __comp_(__x, __y.__get_value().first);
+  }
+  void swap(__map_value_compare& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Compare>) {
+    using std::swap;
+    swap(__comp_, __y.__comp_);
+  }
 
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _K2& __x, const _CP& __y) const
-        {return __comp_(__x, __y.__get_value().first);}
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _K2& __x, const _CP& __y) const {
+    return __comp_(__x, __y.__get_value().first);
+  }
 
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _CP& __x, const _K2& __y) const
-        {return __comp_(__x.__get_value().first, __y);}
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _K2& __y) const {
+    return __comp_(__x.__get_value().first, __y);
+  }
 #endif
 };
 
 template <class _Key, class _CP, class _Compare, bool __b>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(__map_value_compare<_Key, _CP, _Compare, __b>& __x,
-     __map_value_compare<_Key, _CP, _Compare, __b>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(__map_value_compare<_Key, _CP, _Compare, __b>& __x, __map_value_compare<_Key, _CP, _Compare, __b>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 template <class _Allocator>
-class __map_node_destructor
-{
-    typedef _Allocator                          allocator_type;
-    typedef allocator_traits<allocator_type>    __alloc_traits;
+class __map_node_destructor {
+  typedef _Allocator allocator_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
 
 public:
-    typedef typename __alloc_traits::pointer    pointer;
+  typedef typename __alloc_traits::pointer pointer;
 
 private:
-    allocator_type& __na_;
-
-    __map_node_destructor& operator=(const __map_node_destructor&);
+  allocator_type& __na_;
 
 public:
-    bool __first_constructed;
-    bool __second_constructed;
+  bool __first_constructed;
+  bool __second_constructed;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __map_node_destructor(allocator_type& __na) _NOEXCEPT
-        : __na_(__na),
-          __first_constructed(false),
-          __second_constructed(false)
-        {}
+  _LIBCPP_HIDE_FROM_ABI explicit __map_node_destructor(allocator_type& __na) _NOEXCEPT
+      : __na_(__na),
+        __first_constructed(false),
+        __second_constructed(false) {}
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __map_node_destructor(__tree_node_destructor<allocator_type>&& __x) _NOEXCEPT
-        : __na_(__x.__na_),
-          __first_constructed(__x.__value_constructed),
-          __second_constructed(__x.__value_constructed)
-        {
-            __x.__value_constructed = false;
-        }
+  _LIBCPP_HIDE_FROM_ABI __map_node_destructor(__tree_node_destructor<allocator_type>&& __x) _NOEXCEPT
+      : __na_(__x.__na_),
+        __first_constructed(__x.__value_constructed),
+        __second_constructed(__x.__value_constructed) {
+    __x.__value_constructed = false;
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
-    {
-        if (__second_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second));
-        if (__first_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first));
-        if (__p)
-            __alloc_traits::deallocate(__na_, __p, 1);
-    }
+  __map_node_destructor& operator=(const __map_node_destructor&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {
+    if (__second_constructed)
+      __alloc_traits::destroy(__na_, std::addressof(__p->__value_.__get_value().second));
+    if (__first_constructed)
+      __alloc_traits::destroy(__na_, std::addressof(__p->__value_.__get_value().first));
+    if (__p)
+      __alloc_traits::deallocate(__na_, __p, 1);
+  }
 };
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-    class map;
+class map;
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-    class multimap;
-template <class _TreeIterator> class __map_const_iterator;
+class multimap;
+template <class _TreeIterator>
+class __map_const_iterator;
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp>
-struct _LIBCPP_STANDALONE_DEBUG __value_type
-{
-    typedef _Key                                     key_type;
-    typedef _Tp                                      mapped_type;
-    typedef pair<const key_type, mapped_type>        value_type;
-    typedef pair<key_type&, mapped_type&>            __nc_ref_pair_type;
-    typedef pair<key_type&&, mapped_type&&>          __nc_rref_pair_type;
+struct _LIBCPP_STANDALONE_DEBUG __value_type {
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef pair<const key_type, mapped_type> value_type;
+  typedef pair<key_type&, mapped_type&> __nc_ref_pair_type;
+  typedef pair<key_type&&, mapped_type&&> __nc_rref_pair_type;
 
 private:
-    value_type __cc_;
+  value_type __cc_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    value_type& __get_value()
-    {
-#if _LIBCPP_STD_VER >= 17
-        return *_VSTD::launder(_VSTD::addressof(__cc_));
-#else
-        return __cc_;
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI value_type& __get_value() {
+#  if _LIBCPP_STD_VER >= 17
+    return *std::launder(std::addressof(__cc_));
+#  else
+    return __cc_;
+#  endif
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type& __get_value() const
-    {
-#if _LIBCPP_STD_VER >= 17
-        return *_VSTD::launder(_VSTD::addressof(__cc_));
-#else
-        return __cc_;
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI const value_type& __get_value() const {
+#  if _LIBCPP_STD_VER >= 17
+    return *std::launder(std::addressof(__cc_));
+#  else
+    return __cc_;
+#  endif
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __nc_ref_pair_type __ref()
-    {
-        value_type& __v = __get_value();
-        return __nc_ref_pair_type(const_cast<key_type&>(__v.first), __v.second);
-    }
+  _LIBCPP_HIDE_FROM_ABI __nc_ref_pair_type __ref() {
+    value_type& __v = __get_value();
+    return __nc_ref_pair_type(const_cast<key_type&>(__v.first), __v.second);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __nc_rref_pair_type __move()
-    {
-        value_type& __v = __get_value();
-        return __nc_rref_pair_type(
-            _VSTD::move(const_cast<key_type&>(__v.first)),
-            _VSTD::move(__v.second));
-    }
+  _LIBCPP_HIDE_FROM_ABI __nc_rref_pair_type __move() {
+    value_type& __v = __get_value();
+    return __nc_rref_pair_type(std::move(const_cast<key_type&>(__v.first)), std::move(__v.second));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __value_type& operator=(const __value_type& __v)
-    {
-        __ref() = __v.__get_value();
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI __value_type& operator=(const __value_type& __v) {
+    __ref() = __v.__get_value();
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __value_type& operator=(__value_type&& __v)
-    {
-        __ref() = __v.__move();
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI __value_type& operator=(__value_type&& __v) {
+    __ref() = __v.__move();
+    return *this;
+  }
 
-    template <class _ValueTp,
-              class = __enable_if_t<__is_same_uncvref<_ValueTp, value_type>::value>
-             >
-    _LIBCPP_INLINE_VISIBILITY
-    __value_type& operator=(_ValueTp&& __v)
-    {
-        __ref() = _VSTD::forward<_ValueTp>(__v);
-        return *this;
-    }
+  template <class _ValueTp, __enable_if_t<__is_same_uncvref<_ValueTp, value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI __value_type& operator=(_ValueTp&& __v) {
+    __ref() = std::forward<_ValueTp>(__v);
+    return *this;
+  }
 
-private:
-    __value_type() = delete;
-    ~__value_type() = delete;
-    __value_type(const __value_type&) = delete;
-    __value_type(__value_type&&) = delete;
+  __value_type()                    = delete;
+  ~__value_type()                   = delete;
+  __value_type(const __value_type&) = delete;
+  __value_type(__value_type&&)      = delete;
 };
 
 #else
 
 template <class _Key, class _Tp>
-struct __value_type
-{
-    typedef _Key                                     key_type;
-    typedef _Tp                                      mapped_type;
-    typedef pair<const key_type, mapped_type>        value_type;
+struct __value_type {
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef pair<const key_type, mapped_type> value_type;
 
 private:
-    value_type __cc_;
+  value_type __cc_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    value_type& __get_value() { return __cc_; }
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type& __get_value() const { return __cc_; }
+  _LIBCPP_HIDE_FROM_ABI value_type& __get_value() { return __cc_; }
+  _LIBCPP_HIDE_FROM_ABI const value_type& __get_value() const { return __cc_; }
 
-private:
-   __value_type();
-   __value_type(__value_type const&);
-   __value_type& operator=(__value_type const&);
-   ~__value_type();
+  __value_type()                               = delete;
+  __value_type(__value_type const&)            = delete;
+  __value_type& operator=(__value_type const&) = delete;
+  ~__value_type()                              = delete;
 };
 
 #endif // _LIBCPP_CXX03_LANG
@@ -848,891 +841,775 @@ template <class _Tp>
 struct __extract_key_value_types;
 
 template <class _Key, class _Tp>
-struct __extract_key_value_types<__value_type<_Key, _Tp> >
-{
+struct __extract_key_value_types<__value_type<_Key, _Tp> > {
   typedef _Key const __key_type;
-  typedef _Tp        __mapped_type;
+  typedef _Tp __mapped_type;
 };
 
 template <class _TreeIterator>
-class _LIBCPP_TEMPLATE_VIS __map_iterator
-{
-    typedef typename _TreeIterator::_NodeTypes                   _NodeTypes;
-    typedef typename _TreeIterator::__pointer_traits             __pointer_traits;
+class _LIBCPP_TEMPLATE_VIS __map_iterator {
+  typedef typename _TreeIterator::_NodeTypes _NodeTypes;
+  typedef typename _TreeIterator::__pointer_traits __pointer_traits;
 
-    _TreeIterator __i_;
+  _TreeIterator __i_;
 
 public:
-    typedef bidirectional_iterator_tag                           iterator_category;
-    typedef typename _NodeTypes::__map_value_type                value_type;
-    typedef typename _TreeIterator::difference_type              difference_type;
-    typedef value_type&                                          reference;
-    typedef typename _NodeTypes::__map_value_type_pointer        pointer;
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef typename _NodeTypes::__map_value_type value_type;
+  typedef typename _TreeIterator::difference_type difference_type;
+  typedef value_type& reference;
+  typedef typename _NodeTypes::__map_value_type_pointer pointer;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __map_iterator() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI __map_iterator() _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __map_iterator(_TreeIterator __i) _NOEXCEPT : __i_(__i) {}
+  _LIBCPP_HIDE_FROM_ABI __map_iterator(_TreeIterator __i) _NOEXCEPT : __i_(__i) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return __i_->__get_value();}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __i_->__get_value(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__i_->__get_value()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __map_iterator& operator++() {++__i_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY
-    __map_iterator operator++(int)
-    {
-        __map_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI __map_iterator& operator++() {
+    ++__i_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __map_iterator operator++(int) {
+    __map_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __map_iterator& operator--() {--__i_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY
-    __map_iterator operator--(int)
-    {
-        __map_iterator __t(*this);
-        --(*this);
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI __map_iterator& operator--() {
+    --__i_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __map_iterator operator--(int) {
+    __map_iterator __t(*this);
+    --(*this);
+    return __t;
+  }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __map_iterator& __x, const __map_iterator& __y)
-        {return __x.__i_ == __y.__i_;}
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __map_iterator& __x, const __map_iterator& __y)
-        {return __x.__i_ != __y.__i_;}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __map_iterator& __x, const __map_iterator& __y) {
+    return __x.__i_ == __y.__i_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __map_iterator& __x, const __map_iterator& __y) {
+    return __x.__i_ != __y.__i_;
+  }
 
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
+  template <class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS map;
+  template <class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS multimap;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __map_const_iterator;
 };
 
 template <class _TreeIterator>
-class _LIBCPP_TEMPLATE_VIS __map_const_iterator
-{
-    typedef typename _TreeIterator::_NodeTypes                   _NodeTypes;
-    typedef typename _TreeIterator::__pointer_traits             __pointer_traits;
+class _LIBCPP_TEMPLATE_VIS __map_const_iterator {
+  typedef typename _TreeIterator::_NodeTypes _NodeTypes;
+  typedef typename _TreeIterator::__pointer_traits __pointer_traits;
 
-    _TreeIterator __i_;
+  _TreeIterator __i_;
 
 public:
-    typedef bidirectional_iterator_tag                           iterator_category;
-    typedef typename _NodeTypes::__map_value_type                value_type;
-    typedef typename _TreeIterator::difference_type              difference_type;
-    typedef const value_type&                                    reference;
-    typedef typename _NodeTypes::__const_map_value_type_pointer  pointer;
+  typedef bidirectional_iterator_tag iterator_category;
+  typedef typename _NodeTypes::__map_value_type value_type;
+  typedef typename _TreeIterator::difference_type difference_type;
+  typedef const value_type& reference;
+  typedef typename _NodeTypes::__const_map_value_type_pointer pointer;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __map_const_iterator() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI __map_const_iterator() _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __map_const_iterator(_TreeIterator __i) _NOEXCEPT : __i_(__i) {}
-    _LIBCPP_INLINE_VISIBILITY
-    __map_const_iterator(__map_iterator<
-        typename _TreeIterator::__non_const_iterator> __i) _NOEXCEPT
-        : __i_(__i.__i_) {}
+  _LIBCPP_HIDE_FROM_ABI __map_const_iterator(_TreeIterator __i) _NOEXCEPT : __i_(__i) {}
+  _LIBCPP_HIDE_FROM_ABI
+  __map_const_iterator(__map_iterator< typename _TreeIterator::__non_const_iterator> __i) _NOEXCEPT : __i_(__i.__i_) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return __i_->__get_value();}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __i_->__get_value(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__i_->__get_value()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __map_const_iterator& operator++() {++__i_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY
-    __map_const_iterator operator++(int)
-    {
-        __map_const_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI __map_const_iterator& operator++() {
+    ++__i_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __map_const_iterator operator++(int) {
+    __map_const_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __map_const_iterator& operator--() {--__i_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY
-    __map_const_iterator operator--(int)
-    {
-        __map_const_iterator __t(*this);
-        --(*this);
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI __map_const_iterator& operator--() {
+    --__i_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __map_const_iterator operator--(int) {
+    __map_const_iterator __t(*this);
+    --(*this);
+    return __t;
+  }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __map_const_iterator& __x, const __map_const_iterator& __y)
-        {return __x.__i_ == __y.__i_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __map_const_iterator& __x, const __map_const_iterator& __y)
-        {return __x.__i_ != __y.__i_;}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __map_const_iterator& __x, const __map_const_iterator& __y) {
+    return __x.__i_ == __y.__i_;
+  }
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __map_const_iterator& __x, const __map_const_iterator& __y) {
+    return __x.__i_ != __y.__i_;
+  }
 
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS multimap;
-    template <class, class, class> friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
+  template <class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS map;
+  template <class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS multimap;
+  template <class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS __tree_const_iterator;
 };
 
-template <class _Key, class _Tp, class _Compare = less<_Key>,
-          class _Allocator = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TEMPLATE_VIS map
-{
+template <class _Key, class _Tp, class _Compare = less<_Key>, class _Allocator = allocator<pair<const _Key, _Tp> > >
+class _LIBCPP_TEMPLATE_VIS map {
 public:
-    // types:
-    typedef _Key                                     key_type;
-    typedef _Tp                                      mapped_type;
-    typedef pair<const key_type, mapped_type>        value_type;
-    typedef __type_identity_t<_Compare>              key_compare;
-    typedef __type_identity_t<_Allocator>            allocator_type;
-    typedef value_type&                              reference;
-    typedef const value_type&                        const_reference;
+  // types:
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef pair<const key_type, mapped_type> value_type;
+  typedef __type_identity_t<_Compare> key_compare;
+  typedef __type_identity_t<_Allocator> allocator_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
 
-    static_assert((is_same<typename allocator_type::value_type, value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
+  static_assert(is_same<typename allocator_type::value_type, value_type>::value,
+                "Allocator::value_type must be same type as value_type");
 
-    class _LIBCPP_TEMPLATE_VIS value_compare
-        : public __binary_function<value_type, value_type, bool>
-    {
-        friend class map;
-    protected:
-        key_compare comp;
+  class _LIBCPP_TEMPLATE_VIS value_compare : public __binary_function<value_type, value_type, bool> {
+    friend class map;
 
-        _LIBCPP_INLINE_VISIBILITY value_compare(key_compare __c) : comp(__c) {}
-    public:
-        _LIBCPP_INLINE_VISIBILITY
-        bool operator()(const value_type& __x, const value_type& __y) const
-            {return comp(__x.first, __y.first);}
-    };
+  protected:
+    key_compare comp;
+
+    _LIBCPP_HIDE_FROM_ABI value_compare(key_compare __c) : comp(__c) {}
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI bool operator()(const value_type& __x, const value_type& __y) const {
+      return comp(__x.first, __y.first);
+    }
+  };
 
 private:
+  typedef std::__value_type<key_type, mapped_type> __value_type;
+  typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
+  typedef __rebind_alloc<allocator_traits<allocator_type>, __value_type> __allocator_type;
+  typedef __tree<__value_type, __vc, __allocator_type> __base;
+  typedef typename __base::__node_traits __node_traits;
+  typedef allocator_traits<allocator_type> __alloc_traits;
 
-    typedef _VSTD::__value_type<key_type, mapped_type>             __value_type;
-    typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
-    typedef __rebind_alloc<allocator_traits<allocator_type>, __value_type> __allocator_type;
-    typedef __tree<__value_type, __vc, __allocator_type>   __base;
-    typedef typename __base::__node_traits                 __node_traits;
-    typedef allocator_traits<allocator_type>               __alloc_traits;
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
 
-    static_assert(is_same<allocator_type, __rebind_alloc<__alloc_traits, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
-
-    __base __tree_;
+  __base __tree_;
 
 public:
-    typedef typename __alloc_traits::pointer               pointer;
-    typedef typename __alloc_traits::const_pointer         const_pointer;
-    typedef typename __alloc_traits::size_type             size_type;
-    typedef typename __alloc_traits::difference_type       difference_type;
-    typedef __map_iterator<typename __base::iterator>             iterator;
-    typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
-    typedef _VSTD::reverse_iterator<iterator>               reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator>         const_reverse_iterator;
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
+  typedef typename __alloc_traits::size_type size_type;
+  typedef typename __alloc_traits::difference_type difference_type;
+  typedef __map_iterator<typename __base::iterator> iterator;
+  typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
 #if _LIBCPP_STD_VER >= 17
-    typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
-    typedef __insert_return_type<iterator, node_type> insert_return_type;
+  typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
+  typedef __insert_return_type<iterator, node_type> insert_return_type;
 #endif
 
-    template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS multimap;
+  template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS map;
+  template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS multimap;
 
-    _LIBCPP_INLINE_VISIBILITY
-    map()
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
-        : __tree_(__vc(key_compare())) {}
+  _LIBCPP_HIDE_FROM_ABI map() _NOEXCEPT_(
+      is_nothrow_default_constructible<allocator_type>::value&& is_nothrow_default_constructible<key_compare>::value&&
+          is_nothrow_copy_constructible<key_compare>::value)
+      : __tree_(__vc(key_compare())) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit map(const key_compare& __comp)
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
-        : __tree_(__vc(__comp)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit map(const key_compare& __comp) _NOEXCEPT_(
+      is_nothrow_default_constructible<allocator_type>::value&& is_nothrow_copy_constructible<key_compare>::value)
+      : __tree_(__vc(__comp)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit map(const key_compare& __comp, const allocator_type& __a)
-        : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit map(const key_compare& __comp, const allocator_type& __a)
+      : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {}
 
-    template <class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-        map(_InputIterator __f, _InputIterator __l,
-            const key_compare& __comp = key_compare())
-        : __tree_(__vc(__comp))
-        {
-            insert(__f, __l);
-        }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI map(_InputIterator __f, _InputIterator __l, const key_compare& __comp = key_compare())
+      : __tree_(__vc(__comp)) {
+    insert(__f, __l);
+  }
 
-    template <class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-        map(_InputIterator __f, _InputIterator __l,
-            const key_compare& __comp, const allocator_type& __a)
-        : __tree_(__vc(__comp), typename __base::allocator_type(__a))
-        {
-            insert(__f, __l);
-        }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  map(_InputIterator __f, _InputIterator __l, const key_compare& __comp, const allocator_type& __a)
+      : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {
+    insert(__f, __l);
+  }
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI
+  map(from_range_t,
+      _Range&& __range,
+      const key_compare& __comp = key_compare(),
+      const allocator_type& __a = allocator_type())
+      : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {
+    insert_range(std::forward<_Range>(__range));
+  }
+#endif
 
 #if _LIBCPP_STD_VER >= 14
-    template <class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-    map(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
-        : map(__f, __l, key_compare(), __a) {}
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI map(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
+      : map(__f, __l, key_compare(), __a) {}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    map(const map& __m)
-        : __tree_(__m.__tree_)
-        {
-            insert(__m.begin(), __m.end());
-        }
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI map(from_range_t, _Range&& __range, const allocator_type& __a)
+      : map(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    map& operator=(const map& __m)
-        {
+  _LIBCPP_HIDE_FROM_ABI map(const map& __m) : __tree_(__m.__tree_) { insert(__m.begin(), __m.end()); }
+
+  _LIBCPP_HIDE_FROM_ABI map& operator=(const map& __m) {
 #ifndef _LIBCPP_CXX03_LANG
-            __tree_ = __m.__tree_;
+    __tree_ = __m.__tree_;
 #else
-            if (this != _VSTD::addressof(__m)) {
-                __tree_.clear();
-                __tree_.value_comp() = __m.__tree_.value_comp();
-                __tree_.__copy_assign_alloc(__m.__tree_);
-                insert(__m.begin(), __m.end());
-            }
+    if (this != std::addressof(__m)) {
+      __tree_.clear();
+      __tree_.value_comp() = __m.__tree_.value_comp();
+      __tree_.__copy_assign_alloc(__m.__tree_);
+      insert(__m.begin(), __m.end());
+    }
 #endif
-            return *this;
-        }
+    return *this;
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    map(map&& __m)
-        _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
-        : __tree_(_VSTD::move(__m.__tree_))
-        {
-        }
+  _LIBCPP_HIDE_FROM_ABI map(map&& __m) noexcept(is_nothrow_move_constructible<__base>::value)
+      : __tree_(std::move(__m.__tree_)) {}
 
-    _LIBCPP_HIDE_FROM_ABI map(map&& __m, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI map(map&& __m, const allocator_type& __a);
 
-    _LIBCPP_INLINE_VISIBILITY
-    map& operator=(map&& __m)
-        _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
-        {
-            __tree_ = _VSTD::move(__m.__tree_);
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI map& operator=(map&& __m) noexcept(is_nothrow_move_assignable<__base>::value) {
+    __tree_ = std::move(__m.__tree_);
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    map(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
-        : __tree_(__vc(__comp))
-        {
-            insert(__il.begin(), __il.end());
-        }
+  _LIBCPP_HIDE_FROM_ABI map(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
+      : __tree_(__vc(__comp)) {
+    insert(__il.begin(), __il.end());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    map(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
-        : __tree_(__vc(__comp), typename __base::allocator_type(__a))
-        {
-            insert(__il.begin(), __il.end());
-        }
+  _LIBCPP_HIDE_FROM_ABI map(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
+      : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {
+    insert(__il.begin(), __il.end());
+  }
 
-#if _LIBCPP_STD_VER >= 14
-    _LIBCPP_INLINE_VISIBILITY
-    map(initializer_list<value_type> __il, const allocator_type& __a)
-        : map(__il, key_compare(), __a) {}
-#endif
+#  if _LIBCPP_STD_VER >= 14
+  _LIBCPP_HIDE_FROM_ABI map(initializer_list<value_type> __il, const allocator_type& __a)
+      : map(__il, key_compare(), __a) {}
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    map& operator=(initializer_list<value_type> __il)
-        {
-            __tree_.__assign_unique(__il.begin(), __il.end());
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI map& operator=(initializer_list<value_type> __il) {
+    __tree_.__assign_unique(__il.begin(), __il.end());
+    return *this;
+  }
 
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit map(const allocator_type& __a)
-        : __tree_(typename __base::allocator_type(__a))
-        {
-        }
+  _LIBCPP_HIDE_FROM_ABI explicit map(const allocator_type& __a) : __tree_(typename __base::allocator_type(__a)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    map(const map& __m, const allocator_type& __a)
-        : __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a))
-        {
-            insert(__m.begin(), __m.end());
-        }
+  _LIBCPP_HIDE_FROM_ABI map(const map& __m, const allocator_type& __a)
+      : __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a)) {
+    insert(__m.begin(), __m.end());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~map() {
-        static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
-    }
+  _LIBCPP_HIDE_FROM_ABI ~map() { static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
 
-    _LIBCPP_INLINE_VISIBILITY
-          iterator begin() _NOEXCEPT {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT {return __tree_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT {return __tree_.end();}
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rend() _NOEXCEPT
-            {return       reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend() const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const _NOEXCEPT {return __tree_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT {return __tree_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __tree_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }
 
-    _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](const key_type& __k);
+  _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](const key_type& __k);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __k);
+  _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __k);
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI mapped_type& at(const key_type& __k);
-    _LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __k) const;
+  _LIBCPP_HIDE_FROM_ABI mapped_type& at(const key_type& __k);
+  _LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __k) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__tree_.__alloc());}
-    _LIBCPP_INLINE_VISIBILITY
-    key_compare    key_comp()      const {return __tree_.value_comp().key_comp();}
-    _LIBCPP_INLINE_VISIBILITY
-    value_compare  value_comp()    const {return value_compare(__tree_.value_comp().key_comp());}
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return allocator_type(__tree_.__alloc()); }
+  _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp().key_comp(); }
+  _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return value_compare(__tree_.value_comp().key_comp()); }
 
 #ifndef _LIBCPP_CXX03_LANG
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> emplace(_Args&& ...__args) {
-        return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
+    return __tree_.__emplace_unique(std::forward<_Args>(__args)...);
+  }
 
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator emplace_hint(const_iterator __p, _Args&& ...__args) {
-        return __tree_.__emplace_hint_unique(__p.__i_, _VSTD::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {
+    return __tree_.__emplace_hint_unique(__p.__i_, std::forward<_Args>(__args)...);
+  }
 
-    template <class _Pp,
-              class = __enable_if_t<is_constructible<value_type, _Pp>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> insert(_Pp&& __p)
-            {return __tree_.__insert_unique(_VSTD::forward<_Pp>(__p));}
+  template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(_Pp&& __p) {
+    return __tree_.__insert_unique(std::forward<_Pp>(__p));
+  }
 
-    template <class _Pp,
-              class = __enable_if_t<is_constructible<value_type, _Pp>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        iterator insert(const_iterator __pos, _Pp&& __p)
-            {return __tree_.__insert_unique(__pos.__i_, _VSTD::forward<_Pp>(__p));}
+  template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __pos, _Pp&& __p) {
+    return __tree_.__insert_unique(__pos.__i_, std::forward<_Pp>(__p));
+  }
 
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool>
-        insert(const value_type& __v) {return __tree_.__insert_unique(__v);}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __v) { return __tree_.__insert_unique(__v); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator
-        insert(const_iterator __p, const value_type& __v)
-            {return __tree_.__insert_unique(__p.__i_, __v);}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v) {
+    return __tree_.__insert_unique(__p.__i_, __v);
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool>
-    insert(value_type&& __v) {return __tree_.__insert_unique(_VSTD::move(__v));}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(value_type&& __v) {
+    return __tree_.__insert_unique(std::move(__v));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p,  value_type&& __v)
-    {return __tree_.__insert_unique(__p.__i_, _VSTD::move(__v));}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v) {
+    return __tree_.__insert_unique(__p.__i_, std::move(__v));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void insert(initializer_list<value_type> __il)
-        {insert(__il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
 #endif
 
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        void insert(_InputIterator __f, _InputIterator __l)
-        {
-            for (const_iterator __e = cend(); __f != __l; ++__f)
-                insert(__e.__i_, *__f);
-        }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __f, _InputIterator __l) {
+    for (const_iterator __e = cend(); __f != __l; ++__f)
+      insert(__e.__i_, *__f);
+  }
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+    const_iterator __end = cend();
+    for (auto&& __element : __range) {
+      insert(__end.__i_, std::forward<decltype(__element)>(__element));
+    }
+  }
+#endif
 
 #if _LIBCPP_STD_VER >= 17
 
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
-    {
-        return __tree_.__emplace_unique_key_args(__k,
-            _VSTD::piecewise_construct,
-            _VSTD::forward_as_tuple(__k),
-            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args) {
+    return __tree_.__emplace_unique_key_args(
+        __k,
+        std::piecewise_construct,
+        std::forward_as_tuple(__k),
+        std::forward_as_tuple(std::forward<_Args>(__args)...));
+  }
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args) {
+    return __tree_.__emplace_unique_key_args(
+        __k,
+        std::piecewise_construct,
+        std::forward_as_tuple(std::move(__k)),
+        std::forward_as_tuple(std::forward<_Args>(__args)...));
+  }
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args) {
+    return __tree_
+        .__emplace_hint_unique_key_args(
+            __h.__i_,
+            __k,
+            std::piecewise_construct,
+            std::forward_as_tuple(__k),
+            std::forward_as_tuple(std::forward<_Args>(__args)...))
+        .first;
+  }
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args) {
+    return __tree_
+        .__emplace_hint_unique_key_args(
+            __h.__i_,
+            __k,
+            std::piecewise_construct,
+            std::forward_as_tuple(std::move(__k)),
+            std::forward_as_tuple(std::forward<_Args>(__args)...))
+        .first;
+  }
+
+  template <class _Vp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v) {
+    iterator __p = lower_bound(__k);
+    if (__p != end() && !key_comp()(__k, __p->first)) {
+      __p->second = std::forward<_Vp>(__v);
+      return std::make_pair(__p, false);
     }
+    return std::make_pair(emplace_hint(__p, __k, std::forward<_Vp>(__v)), true);
+  }
 
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args)
-    {
-        return __tree_.__emplace_unique_key_args(__k,
-            _VSTD::piecewise_construct,
-            _VSTD::forward_as_tuple(_VSTD::move(__k)),
-            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
+  template <class _Vp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v) {
+    iterator __p = lower_bound(__k);
+    if (__p != end() && !key_comp()(__k, __p->first)) {
+      __p->second = std::forward<_Vp>(__v);
+      return std::make_pair(__p, false);
     }
+    return std::make_pair(emplace_hint(__p, std::move(__k), std::forward<_Vp>(__v)), true);
+  }
 
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args)
-    {
-        return __tree_.__emplace_hint_unique_key_args(__h.__i_, __k,
-            _VSTD::piecewise_construct,
-            _VSTD::forward_as_tuple(__k),
-            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)).first;
-    }
+  template <class _Vp>
+  _LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __h, const key_type& __k, _Vp&& __v) {
+    auto [__r, __inserted] = __tree_.__emplace_hint_unique_key_args(__h.__i_, __k, __k, std::forward<_Vp>(__v));
 
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args)
-    {
-        return __tree_.__emplace_hint_unique_key_args(__h.__i_, __k,
-            _VSTD::piecewise_construct,
-            _VSTD::forward_as_tuple(_VSTD::move(__k)),
-            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...)).first;
-    }
+    if (!__inserted)
+      __r->__get_value().second = std::forward<_Vp>(__v);
 
-    template <class _Vp>
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v)
-    {
-        iterator __p = lower_bound(__k);
-        if ( __p != end() && !key_comp()(__k, __p->first))
-        {
-            __p->second = _VSTD::forward<_Vp>(__v);
-            return _VSTD::make_pair(__p, false);
-        }
-        return _VSTD::make_pair(emplace_hint(__p, __k, _VSTD::forward<_Vp>(__v)), true);
-    }
+    return __r;
+  }
 
-    template <class _Vp>
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v)
-    {
-        iterator __p = lower_bound(__k);
-        if ( __p != end() && !key_comp()(__k, __p->first))
-        {
-            __p->second = _VSTD::forward<_Vp>(__v);
-            return _VSTD::make_pair(__p, false);
-        }
-        return _VSTD::make_pair(emplace_hint(__p, _VSTD::move(__k), _VSTD::forward<_Vp>(__v)), true);
-    }
+  template <class _Vp>
+  _LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __h, key_type&& __k, _Vp&& __v) {
+    auto [__r, __inserted] =
+        __tree_.__emplace_hint_unique_key_args(__h.__i_, __k, std::move(__k), std::forward<_Vp>(__v));
 
-    template <class _Vp>
-    _LIBCPP_INLINE_VISIBILITY iterator insert_or_assign(const_iterator __h,
-                                                        const key_type& __k,
-                                                        _Vp&& __v) {
-      auto [__r, __inserted] = __tree_.__emplace_hint_unique_key_args(
-          __h.__i_, __k, __k, _VSTD::forward<_Vp>(__v));
+    if (!__inserted)
+      __r->__get_value().second = std::forward<_Vp>(__v);
 
-      if (!__inserted)
-        __r->__get_value().second = _VSTD::forward<_Vp>(__v);
-
-      return __r;
-    }
-
-    template <class _Vp>
-    _LIBCPP_INLINE_VISIBILITY iterator insert_or_assign(const_iterator __h,
-                                                        key_type&& __k,
-                                                        _Vp&& __v) {
-      auto [__r, __inserted] = __tree_.__emplace_hint_unique_key_args(
-          __h.__i_, __k, _VSTD::move(__k), _VSTD::forward<_Vp>(__v));
-
-      if (!__inserted)
-        __r->__get_value().second = _VSTD::forward<_Vp>(__v);
-
-      return __r;
-    }
+    return __r;
+  }
 
 #endif // _LIBCPP_STD_VER >= 17
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(iterator __p)       {return __tree_.erase(__p.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type erase(const key_type& __k)
-        {return __tree_.__erase_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator  erase(const_iterator __f, const_iterator __l)
-        {return __tree_.erase(__f.__i_, __l.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__tree_.clear();}
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p) { return __tree_.erase(__p.__i_); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(iterator __p) { return __tree_.erase(__p.__i_); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __tree_.__erase_unique(__k); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l) {
+    return __tree_.erase(__f.__i_, __l.__i_);
+  }
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __tree_.clear(); }
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
-    insert_return_type insert(node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to map::insert()");
-        return __tree_.template __node_handle_insert_unique<
-            node_type, insert_return_type>(_VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __hint, node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to map::insert()");
-        return __tree_.template __node_handle_insert_unique<node_type>(
-            __hint.__i_, _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(key_type const& __key)
-    {
-        return __tree_.template __node_handle_extract<node_type>(__key);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(const_iterator __it)
-    {
-        return __tree_.template __node_handle_extract<node_type>(__it.__i_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(map<key_type, mapped_type, _Compare2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_unique(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(map<key_type, mapped_type, _Compare2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_unique(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_unique(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_unique(__source.__tree_);
-    }
+  _LIBCPP_HIDE_FROM_ABI insert_return_type insert(node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to map::insert()");
+    return __tree_.template __node_handle_insert_unique< node_type, insert_return_type>(std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to map::insert()");
+    return __tree_.template __node_handle_insert_unique<node_type>(__hint.__i_, std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+    return __tree_.template __node_handle_extract<node_type>(__key);
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+    return __tree_.template __node_handle_extract<node_type>(__it.__i_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(map<key_type, mapped_type, _Compare2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_unique(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(map<key_type, mapped_type, _Compare2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_unique(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_unique(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_unique(__source.__tree_);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(map& __m)
-        _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
-        {__tree_.swap(__m.__tree_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(map& __m) _NOEXCEPT_(__is_nothrow_swappable_v<__base>) { __tree_.swap(__m.__tree_); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator find(const key_type& __k)             {return __tree_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
-    find(const _K2& __k)                           {return __tree_.find(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
-    find(const _K2& __k) const                     {return __tree_.find(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+    return __tree_.find(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+    return __tree_.find(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type      count(const key_type& __k) const
-        {return __tree_.__count_unique(__k);}
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __tree_.__count_unique(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, size_type>
-    count(const _K2& __k) const {return __tree_.__count_multi(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+    return __tree_.__count_multi(__k);
+  }
 #endif
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const key_type& __k) const {return find(__k) != end();}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, bool>
-    contains(const _K2& __k) const { return find(__k) != end(); }
+  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+    return find(__k) != end();
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator lower_bound(const key_type& __k)
-        {return __tree_.lower_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator lower_bound(const key_type& __k) const
-        {return __tree_.lower_bound(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) { return __tree_.lower_bound(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const { return __tree_.lower_bound(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
-    lower_bound(const _K2& __k)       {return __tree_.lower_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {
+    return __tree_.lower_bound(__k);
+  }
 
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
-    lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {
+    return __tree_.lower_bound(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator upper_bound(const key_type& __k)
-        {return __tree_.upper_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator upper_bound(const key_type& __k) const
-        {return __tree_.upper_bound(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) { return __tree_.upper_bound(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const { return __tree_.upper_bound(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
-    upper_bound(const _K2& __k)       {return __tree_.upper_bound(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
-    upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
+    return __tree_.upper_bound(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {
+    return __tree_.upper_bound(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator,iterator> equal_range(const key_type& __k)
-        {return __tree_.__equal_range_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
-        {return __tree_.__equal_range_unique(__k);}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __tree_.__equal_range_unique(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __tree_.__equal_range_unique(__k);
+  }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, pair<iterator,iterator>>
-    equal_range(const _K2& __k)       {return __tree_.__equal_range_multi(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, pair<const_iterator,const_iterator>>
-    equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+    return __tree_.__equal_range_multi(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+    return __tree_.__equal_range_multi(__k);
+  }
 #endif
 
 private:
-    typedef typename __base::__node                    __node;
-    typedef typename __base::__node_allocator          __node_allocator;
-    typedef typename __base::__node_pointer            __node_pointer;
-    typedef typename __base::__node_base_pointer       __node_base_pointer;
-    typedef typename __base::__parent_pointer          __parent_pointer;
+  typedef typename __base::__node __node;
+  typedef typename __base::__node_allocator __node_allocator;
+  typedef typename __base::__node_pointer __node_pointer;
+  typedef typename __base::__node_base_pointer __node_base_pointer;
+  typedef typename __base::__parent_pointer __parent_pointer;
 
-    typedef __map_node_destructor<__node_allocator> _Dp;
-    typedef unique_ptr<__node, _Dp> __node_holder;
+  typedef __map_node_destructor<__node_allocator> _Dp;
+  typedef unique_ptr<__node, _Dp> __node_holder;
 
 #ifdef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node_with_key(const key_type& __k);
+  _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node_with_key(const key_type& __k);
 #endif
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>,
-         class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-         class = enable_if_t<!__is_allocator<_Compare>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+template <class _InputIterator,
+          class _Compare   = less<__iter_key_type<_InputIterator>>,
+          class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
+          class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>>
 map(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
-  -> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
+    -> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
 
-template<class _Key, class _Tp, class _Compare = less<remove_const_t<_Key>>,
-         class _Allocator = allocator<pair<const _Key, _Tp>>,
-         class = enable_if_t<!__is_allocator<_Compare>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
-map(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare(), _Allocator = _Allocator())
-  -> map<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Compare   = less<__range_key_type<_Range>>,
+          class _Allocator = allocator<__range_to_alloc_type<_Range>>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>>
+map(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
+    -> map<__range_key_type<_Range>, __range_mapped_type<_Range>, _Compare, _Allocator>;
+#  endif
 
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+template <class _Key,
+          class _Tp,
+          class _Compare   = less<remove_const_t<_Key>>,
+          class _Allocator = allocator<pair<const _Key, _Tp>>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>>
+map(initializer_list<pair<_Key, _Tp>>,
+    _Compare   = _Compare(),
+    _Allocator = _Allocator()) -> map<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
+
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
 map(_InputIterator, _InputIterator, _Allocator)
-  -> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
-         less<__iter_key_type<_InputIterator>>, _Allocator>;
+    -> map<__iter_key_type<_InputIterator>,
+           __iter_mapped_type<_InputIterator>,
+           less<__iter_key_type<_InputIterator>>,
+           _Allocator>;
 
-template<class _Key, class _Tp, class _Allocator,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
-map(initializer_list<pair<_Key, _Tp>>, _Allocator)
-  -> map<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+map(from_range_t, _Range&&, _Allocator)
+    -> map<__range_key_type<_Range>, __range_mapped_type<_Range>, less<__range_key_type<_Range>>, _Allocator>;
+#  endif
+
+template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+map(initializer_list<pair<_Key, _Tp>>,
+    _Allocator) -> map<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 map<_Key, _Tp, _Compare, _Allocator>::map(map&& __m, const allocator_type& __a)
-    : __tree_(_VSTD::move(__m.__tree_), typename __base::allocator_type(__a))
-{
-    if (__a != __m.get_allocator())
-    {
-        const_iterator __e = cend();
-        while (!__m.empty())
-            __tree_.__insert_unique(__e.__i_,
-                    __m.__tree_.remove(__m.begin().__i_)->__value_.__move());
-    }
+    : __tree_(std::move(__m.__tree_), typename __base::allocator_type(__a)) {
+  if (__a != __m.get_allocator()) {
+    const_iterator __e = cend();
+    while (!__m.empty())
+      __tree_.__insert_unique(__e.__i_, __m.__tree_.remove(__m.begin().__i_)->__value_.__move());
+  }
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-_Tp&
-map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k)
-{
-    return __tree_.__emplace_unique_key_args(__k,
-        _VSTD::piecewise_construct,
-        _VSTD::forward_as_tuple(__k),
-        _VSTD::forward_as_tuple()).first->__get_value().second;
+_Tp& map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k) {
+  return __tree_
+      .__emplace_unique_key_args(__k, std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple())
+      .first->__get_value()
+      .second;
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-_Tp&
-map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k)
-{
-    return __tree_.__emplace_unique_key_args(__k,
-        _VSTD::piecewise_construct,
-        _VSTD::forward_as_tuple(_VSTD::move(__k)),
-        _VSTD::forward_as_tuple()).first->__get_value().second;
+_Tp& map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k) {
+  // TODO investigate this clang-tidy warning.
+  // NOLINTBEGIN(bugprone-use-after-move)
+  return __tree_
+      .__emplace_unique_key_args(
+          __k, std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple())
+      .first->__get_value()
+      .second;
+  // NOLINTEND(bugprone-use-after-move)
 }
 
 #else // _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
-map<_Key, _Tp, _Compare, _Allocator>::__construct_node_with_key(const key_type& __k)
-{
-    __node_allocator& __na = __tree_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().first), __k);
-    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().second));
-    __h.get_deleter().__second_constructed = true;
-    return __h;
+map<_Key, _Tp, _Compare, _Allocator>::__construct_node_with_key(const key_type& __k) {
+  __node_allocator& __na = __tree_.__node_alloc();
+  __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
+  __node_traits::construct(__na, std::addressof(__h->__value_.__get_value().first), __k);
+  __h.get_deleter().__first_constructed = true;
+  __node_traits::construct(__na, std::addressof(__h->__value_.__get_value().second));
+  __h.get_deleter().__second_constructed = true;
+  return __h;
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-_Tp&
-map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k)
-{
-    __parent_pointer __parent;
-    __node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
-    __node_pointer __r = static_cast<__node_pointer>(__child);
-    if (__child == nullptr)
-    {
-        __node_holder __h = __construct_node_with_key(__k);
-        __tree_.__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
-        __r = __h.release();
-    }
-    return __r->__value_.__get_value().second;
+_Tp& map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k) {
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
+  __node_pointer __r           = static_cast<__node_pointer>(__child);
+  if (__child == nullptr) {
+    __node_holder __h = __construct_node_with_key(__k);
+    __tree_.__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
+    __r = __h.release();
+  }
+  return __r->__value_.__get_value().second;
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-_Tp&
-map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k)
-{
-    __parent_pointer __parent;
-    __node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
-    if (__child == nullptr)
-        __throw_out_of_range("map::at:  key not found");
-    return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
+_Tp& map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) {
+  __parent_pointer __parent;
+  __node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
+  if (__child == nullptr)
+    __throw_out_of_range("map::at:  key not found");
+  return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-const _Tp&
-map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const
-{
-    __parent_pointer __parent;
-    __node_base_pointer __child = __tree_.__find_equal(__parent, __k);
-    if (__child == nullptr)
-        __throw_out_of_range("map::at:  key not found");
-    return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
+const _Tp& map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const {
+  __parent_pointer __parent;
+  __node_base_pointer __child = __tree_.__find_equal(__parent, __k);
+  if (__child == nullptr)
+    __throw_out_of_range("map::at:  key not found");
+  return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
 }
 
-
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const map<_Key, _Tp, _Compare, _Allocator>& __x,
-           const map<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const map<_Key, _Tp, _Compare, _Allocator>& __x, const map<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 #if _LIBCPP_STD_VER <= 17
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const map<_Key, _Tp, _Compare, _Allocator>& __x,
-           const map<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(const map<_Key, _Tp, _Compare, _Allocator>& __x, const map<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
-           const map<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const map<_Key, _Tp, _Compare, _Allocator>& __x, const map<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return !(__x == __y);
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator> (const map<_Key, _Tp, _Compare, _Allocator>& __x,
-           const map<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(const map<_Key, _Tp, _Compare, _Allocator>& __x, const map<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return __y < __x;
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
-           const map<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(const map<_Key, _Tp, _Compare, _Allocator>& __x, const map<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return !(__x < __y);
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
-           const map<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __x, const map<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return !(__y < __x);
 }
 
 #else // #if _LIBCPP_STD_VER <= 17
@@ -1740,610 +1617,512 @@ operator<=(const map<_Key, _Tp, _Compare, _Allocator>& __x,
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI __synth_three_way_result<pair<const _Key, _Tp>>
 operator<=>(const map<_Key, _Tp, _Compare, _Allocator>& __x, const map<_Key, _Tp, _Compare, _Allocator>& __y) {
-    return std::lexicographical_compare_three_way(
-        __x.begin(),
-        __x.end(),
-        __y.begin(),
-        __y.end(),
-        std::__synth_three_way<pair<const _Key, _Tp>, pair<const _Key, _Tp>>);
+  return std::lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
 }
 
 #endif // #if _LIBCPP_STD_VER <= 17
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(map<_Key, _Tp, _Compare, _Allocator>& __x,
-     map<_Key, _Tp, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(map<_Key, _Tp, _Compare, _Allocator>& __x, map<_Key, _Tp, _Compare, _Allocator>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
-template <class _Key, class _Tp, class _Compare, class _Allocator,
-          class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-    typename map<_Key, _Tp, _Compare, _Allocator>::size_type
-    erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) {
-  return _VSTD::__libcpp_erase_if_container(__c, __pred);
+template <class _Key, class _Tp, class _Compare, class _Allocator, class _Predicate>
+inline _LIBCPP_HIDE_FROM_ABI typename map<_Key, _Tp, _Compare, _Allocator>::size_type
+erase_if(map<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) {
+  return std::__libcpp_erase_if_container(__c, __pred);
 }
 #endif
 
-
-template <class _Key, class _Tp, class _Compare = less<_Key>,
-          class _Allocator = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TEMPLATE_VIS multimap
-{
+template <class _Key, class _Tp, class _Compare = less<_Key>, class _Allocator = allocator<pair<const _Key, _Tp> > >
+class _LIBCPP_TEMPLATE_VIS multimap {
 public:
-    // types:
-    typedef _Key                                     key_type;
-    typedef _Tp                                      mapped_type;
-    typedef pair<const key_type, mapped_type>        value_type;
-    typedef __type_identity_t<_Compare>              key_compare;
-    typedef __type_identity_t<_Allocator>            allocator_type;
-    typedef value_type&                              reference;
-    typedef const value_type&                        const_reference;
+  // types:
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef pair<const key_type, mapped_type> value_type;
+  typedef __type_identity_t<_Compare> key_compare;
+  typedef __type_identity_t<_Allocator> allocator_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
 
-    static_assert((is_same<typename allocator_type::value_type, value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
+  static_assert(is_same<typename allocator_type::value_type, value_type>::value,
+                "Allocator::value_type must be same type as value_type");
 
-    class _LIBCPP_TEMPLATE_VIS value_compare
-        : public __binary_function<value_type, value_type, bool>
-    {
-        friend class multimap;
-    protected:
-        key_compare comp;
+  class _LIBCPP_TEMPLATE_VIS value_compare : public __binary_function<value_type, value_type, bool> {
+    friend class multimap;
 
-        _LIBCPP_INLINE_VISIBILITY
-        value_compare(key_compare __c) : comp(__c) {}
-    public:
-        _LIBCPP_INLINE_VISIBILITY
-        bool operator()(const value_type& __x, const value_type& __y) const
-            {return comp(__x.first, __y.first);}
-    };
+  protected:
+    key_compare comp;
+
+    _LIBCPP_HIDE_FROM_ABI value_compare(key_compare __c) : comp(__c) {}
+
+  public:
+    _LIBCPP_HIDE_FROM_ABI bool operator()(const value_type& __x, const value_type& __y) const {
+      return comp(__x.first, __y.first);
+    }
+  };
 
 private:
+  typedef std::__value_type<key_type, mapped_type> __value_type;
+  typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
+  typedef __rebind_alloc<allocator_traits<allocator_type>, __value_type> __allocator_type;
+  typedef __tree<__value_type, __vc, __allocator_type> __base;
+  typedef typename __base::__node_traits __node_traits;
+  typedef allocator_traits<allocator_type> __alloc_traits;
 
-    typedef _VSTD::__value_type<key_type, mapped_type>             __value_type;
-    typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
-    typedef __rebind_alloc<allocator_traits<allocator_type>, __value_type> __allocator_type;
-    typedef __tree<__value_type, __vc, __allocator_type>            __base;
-    typedef typename __base::__node_traits                          __node_traits;
-    typedef allocator_traits<allocator_type>                        __alloc_traits;
-
-    static_assert(is_same<allocator_type, __rebind_alloc<__alloc_traits, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
-
-    __base __tree_;
+  __base __tree_;
 
 public:
-    typedef typename __alloc_traits::pointer               pointer;
-    typedef typename __alloc_traits::const_pointer         const_pointer;
-    typedef typename __alloc_traits::size_type             size_type;
-    typedef typename __alloc_traits::difference_type       difference_type;
-    typedef __map_iterator<typename __base::iterator>      iterator;
-    typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
-    typedef _VSTD::reverse_iterator<iterator>               reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator>         const_reverse_iterator;
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
+  typedef typename __alloc_traits::size_type size_type;
+  typedef typename __alloc_traits::difference_type difference_type;
+  typedef __map_iterator<typename __base::iterator> iterator;
+  typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
 #if _LIBCPP_STD_VER >= 17
-    typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
+  typedef __map_node_handle<typename __base::__node, allocator_type> node_type;
 #endif
 
-    template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS map;
-    template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS multimap;
+  template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS map;
+  template <class _Key2, class _Value2, class _Comp2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS multimap;
 
-    _LIBCPP_INLINE_VISIBILITY
-    multimap()
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
-        : __tree_(__vc(key_compare())) {}
+  _LIBCPP_HIDE_FROM_ABI multimap() _NOEXCEPT_(
+      is_nothrow_default_constructible<allocator_type>::value&& is_nothrow_default_constructible<key_compare>::value&&
+          is_nothrow_copy_constructible<key_compare>::value)
+      : __tree_(__vc(key_compare())) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit multimap(const key_compare& __comp)
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
-        : __tree_(__vc(__comp)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit multimap(const key_compare& __comp) _NOEXCEPT_(
+      is_nothrow_default_constructible<allocator_type>::value&& is_nothrow_copy_constructible<key_compare>::value)
+      : __tree_(__vc(__comp)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit multimap(const key_compare& __comp, const allocator_type& __a)
-        : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit multimap(const key_compare& __comp, const allocator_type& __a)
+      : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {}
 
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        multimap(_InputIterator __f, _InputIterator __l,
-            const key_compare& __comp = key_compare())
-        : __tree_(__vc(__comp))
-        {
-            insert(__f, __l);
-        }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI multimap(_InputIterator __f, _InputIterator __l, const key_compare& __comp = key_compare())
+      : __tree_(__vc(__comp)) {
+    insert(__f, __l);
+  }
 
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        multimap(_InputIterator __f, _InputIterator __l,
-            const key_compare& __comp, const allocator_type& __a)
-        : __tree_(__vc(__comp), typename __base::allocator_type(__a))
-        {
-            insert(__f, __l);
-        }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  multimap(_InputIterator __f, _InputIterator __l, const key_compare& __comp, const allocator_type& __a)
+      : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {
+    insert(__f, __l);
+  }
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI
+  multimap(from_range_t,
+           _Range&& __range,
+           const key_compare& __comp = key_compare(),
+           const allocator_type& __a = allocator_type())
+      : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {
+    insert_range(std::forward<_Range>(__range));
+  }
+#endif
 
 #if _LIBCPP_STD_VER >= 14
-    template <class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-    multimap(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
-        : multimap(__f, __l, key_compare(), __a) {}
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI multimap(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
+      : multimap(__f, __l, key_compare(), __a) {}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    multimap(const multimap& __m)
-        : __tree_(__m.__tree_.value_comp(),
-          __alloc_traits::select_on_container_copy_construction(__m.__tree_.__alloc()))
-        {
-            insert(__m.begin(), __m.end());
-        }
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI multimap(from_range_t, _Range&& __range, const allocator_type& __a)
+      : multimap(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    multimap& operator=(const multimap& __m)
-        {
+  _LIBCPP_HIDE_FROM_ABI multimap(const multimap& __m)
+      : __tree_(__m.__tree_.value_comp(),
+                __alloc_traits::select_on_container_copy_construction(__m.__tree_.__alloc())) {
+    insert(__m.begin(), __m.end());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI multimap& operator=(const multimap& __m) {
 #ifndef _LIBCPP_CXX03_LANG
-            __tree_ = __m.__tree_;
+    __tree_ = __m.__tree_;
 #else
-            if (this != _VSTD::addressof(__m)) {
-                __tree_.clear();
-                __tree_.value_comp() = __m.__tree_.value_comp();
-                __tree_.__copy_assign_alloc(__m.__tree_);
-                insert(__m.begin(), __m.end());
-            }
+    if (this != std::addressof(__m)) {
+      __tree_.clear();
+      __tree_.value_comp() = __m.__tree_.value_comp();
+      __tree_.__copy_assign_alloc(__m.__tree_);
+      insert(__m.begin(), __m.end());
+    }
 #endif
-            return *this;
-        }
+    return *this;
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    multimap(multimap&& __m)
-        _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
-        : __tree_(_VSTD::move(__m.__tree_))
-        {
-        }
+  _LIBCPP_HIDE_FROM_ABI multimap(multimap&& __m) noexcept(is_nothrow_move_constructible<__base>::value)
+      : __tree_(std::move(__m.__tree_)) {}
 
-    _LIBCPP_HIDE_FROM_ABI multimap(multimap&& __m, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI multimap(multimap&& __m, const allocator_type& __a);
 
-    _LIBCPP_INLINE_VISIBILITY
-    multimap& operator=(multimap&& __m)
-        _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
-        {
-            __tree_ = _VSTD::move(__m.__tree_);
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI multimap& operator=(multimap&& __m) noexcept(is_nothrow_move_assignable<__base>::value) {
+    __tree_ = std::move(__m.__tree_);
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    multimap(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
-        : __tree_(__vc(__comp))
-        {
-            insert(__il.begin(), __il.end());
-        }
+  _LIBCPP_HIDE_FROM_ABI multimap(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
+      : __tree_(__vc(__comp)) {
+    insert(__il.begin(), __il.end());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    multimap(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
-        : __tree_(__vc(__comp), typename __base::allocator_type(__a))
-        {
-            insert(__il.begin(), __il.end());
-        }
+  _LIBCPP_HIDE_FROM_ABI
+  multimap(initializer_list<value_type> __il, const key_compare& __comp, const allocator_type& __a)
+      : __tree_(__vc(__comp), typename __base::allocator_type(__a)) {
+    insert(__il.begin(), __il.end());
+  }
 
-#if _LIBCPP_STD_VER >= 14
-    _LIBCPP_INLINE_VISIBILITY
-    multimap(initializer_list<value_type> __il, const allocator_type& __a)
-        : multimap(__il, key_compare(), __a) {}
-#endif
+#  if _LIBCPP_STD_VER >= 14
+  _LIBCPP_HIDE_FROM_ABI multimap(initializer_list<value_type> __il, const allocator_type& __a)
+      : multimap(__il, key_compare(), __a) {}
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    multimap& operator=(initializer_list<value_type> __il)
-        {
-            __tree_.__assign_multi(__il.begin(), __il.end());
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI multimap& operator=(initializer_list<value_type> __il) {
+    __tree_.__assign_multi(__il.begin(), __il.end());
+    return *this;
+  }
 
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit multimap(const allocator_type& __a)
-        : __tree_(typename __base::allocator_type(__a))
-        {
-        }
+  _LIBCPP_HIDE_FROM_ABI explicit multimap(const allocator_type& __a) : __tree_(typename __base::allocator_type(__a)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    multimap(const multimap& __m, const allocator_type& __a)
-        : __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a))
-        {
-            insert(__m.begin(), __m.end());
-        }
+  _LIBCPP_HIDE_FROM_ABI multimap(const multimap& __m, const allocator_type& __a)
+      : __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a)) {
+    insert(__m.begin(), __m.end());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~multimap() {
-        static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
-    }
+  _LIBCPP_HIDE_FROM_ABI ~multimap() { static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
 
-    _LIBCPP_INLINE_VISIBILITY
-          iterator begin() _NOEXCEPT {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT {return __tree_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT {return __tree_.end();}
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend() const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin()  const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT {return __tree_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __tree_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__tree_.__alloc());}
-    _LIBCPP_INLINE_VISIBILITY
-    key_compare    key_comp() const {return __tree_.value_comp().key_comp();}
-    _LIBCPP_INLINE_VISIBILITY
-    value_compare  value_comp() const
-        {return value_compare(__tree_.value_comp().key_comp());}
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return allocator_type(__tree_.__alloc()); }
+  _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp().key_comp(); }
+  _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return value_compare(__tree_.value_comp().key_comp()); }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator emplace(_Args&& ...__args) {
-        return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) {
+    return __tree_.__emplace_multi(std::forward<_Args>(__args)...);
+  }
 
-    template <class ..._Args>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator emplace_hint(const_iterator __p, _Args&& ...__args) {
-        return __tree_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {
+    return __tree_.__emplace_hint_multi(__p.__i_, std::forward<_Args>(__args)...);
+  }
 
-    template <class _Pp,
-              class = __enable_if_t<is_constructible<value_type, _Pp>::value>>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator insert(_Pp&& __p)
-            {return __tree_.__insert_multi(_VSTD::forward<_Pp>(__p));}
+  template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert(_Pp&& __p) {
+    return __tree_.__insert_multi(std::forward<_Pp>(__p));
+  }
 
-    template <class _Pp,
-              class = __enable_if_t<is_constructible<value_type, _Pp>::value>>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator insert(const_iterator __pos, _Pp&& __p)
-            {return __tree_.__insert_multi(__pos.__i_, _VSTD::forward<_Pp>(__p));}
+  template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __pos, _Pp&& __p) {
+    return __tree_.__insert_multi(__pos.__i_, std::forward<_Pp>(__p));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(value_type&& __v)
-        {return __tree_.__insert_multi(_VSTD::move(__v));}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(value_type&& __v) { return __tree_.__insert_multi(std::move(__v)); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, value_type&& __v)
-        {return __tree_.__insert_multi(__p.__i_, _VSTD::move(__v));}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v) {
+    return __tree_.__insert_multi(__p.__i_, std::move(__v));
+  }
 
-
-    _LIBCPP_INLINE_VISIBILITY
-    void insert(initializer_list<value_type> __il)
-        {insert(__il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
 
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const value_type& __v) {return __tree_.__insert_multi(__v);}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __v) { return __tree_.__insert_multi(__v); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, const value_type& __v)
-            {return __tree_.__insert_multi(__p.__i_, __v);}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v) {
+    return __tree_.__insert_multi(__p.__i_, __v);
+  }
 
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        void insert(_InputIterator __f, _InputIterator __l)
-        {
-            for (const_iterator __e = cend(); __f != __l; ++__f)
-                __tree_.__insert_multi(__e.__i_, *__f);
-        }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __f, _InputIterator __l) {
+    for (const_iterator __e = cend(); __f != __l; ++__f)
+      __tree_.__insert_multi(__e.__i_, *__f);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __p) {return __tree_.erase(__p.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(iterator __p)       {return __tree_.erase(__p.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator  erase(const_iterator __f, const_iterator __l)
-        {return __tree_.erase(__f.__i_, __l.__i_);}
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+    const_iterator __end = cend();
+    for (auto&& __element : __range) {
+      __tree_.__insert_multi(__end.__i_, std::forward<decltype(__element)>(__element));
+    }
+  }
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p) { return __tree_.erase(__p.__i_); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(iterator __p) { return __tree_.erase(__p.__i_); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __tree_.__erase_multi(__k); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l) {
+    return __tree_.erase(__f.__i_, __l.__i_);
+  }
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to multimap::insert()");
-        return __tree_.template __node_handle_insert_multi<node_type>(
-            _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __hint, node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to multimap::insert()");
-        return __tree_.template __node_handle_insert_multi<node_type>(
-            __hint.__i_, _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(key_type const& __key)
-    {
-        return __tree_.template __node_handle_extract<node_type>(__key);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(const_iterator __it)
-    {
-        return __tree_.template __node_handle_extract<node_type>(
-            __it.__i_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __tree_.__node_handle_merge_multi(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __tree_.__node_handle_merge_multi(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(map<key_type, mapped_type, _Compare2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __tree_.__node_handle_merge_multi(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(map<key_type, mapped_type, _Compare2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __tree_.__node_handle_merge_multi(__source.__tree_);
-    }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to multimap::insert()");
+    return __tree_.template __node_handle_insert_multi<node_type>(std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to multimap::insert()");
+    return __tree_.template __node_handle_insert_multi<node_type>(__hint.__i_, std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+    return __tree_.template __node_handle_extract<node_type>(__key);
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+    return __tree_.template __node_handle_extract<node_type>(__it.__i_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __tree_.__node_handle_merge_multi(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(multimap<key_type, mapped_type, _Compare2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __tree_.__node_handle_merge_multi(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(map<key_type, mapped_type, _Compare2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __tree_.__node_handle_merge_multi(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(map<key_type, mapped_type, _Compare2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __tree_.__node_handle_merge_multi(__source.__tree_);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__tree_.clear();}
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __tree_.clear(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(multimap& __m)
-        _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
-        {__tree_.swap(__m.__tree_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(multimap& __m) _NOEXCEPT_(__is_nothrow_swappable_v<__base>) {
+    __tree_.swap(__m.__tree_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator find(const key_type& __k)             {return __tree_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
-    find(const _K2& __k)                           {return __tree_.find(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
-    find(const _K2& __k) const                     {return __tree_.find(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+    return __tree_.find(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+    return __tree_.find(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type      count(const key_type& __k) const
-        {return __tree_.__count_multi(__k);}
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __tree_.__count_multi(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, size_type>
-    count(const _K2& __k) const {return __tree_.__count_multi(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+    return __tree_.__count_multi(__k);
+  }
 #endif
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const key_type& __k) const {return find(__k) != end();}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, bool>
-    contains(const _K2& __k) const { return find(__k) != end(); }
+  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+    return find(__k) != end();
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator lower_bound(const key_type& __k)
-        {return __tree_.lower_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator lower_bound(const key_type& __k) const
-            {return __tree_.lower_bound(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) { return __tree_.lower_bound(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const { return __tree_.lower_bound(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
-    lower_bound(const _K2& __k)       {return __tree_.lower_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {
+    return __tree_.lower_bound(__k);
+  }
 
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
-    lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {
+    return __tree_.lower_bound(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator upper_bound(const key_type& __k)
-            {return __tree_.upper_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator upper_bound(const key_type& __k) const
-            {return __tree_.upper_bound(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) { return __tree_.upper_bound(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const { return __tree_.upper_bound(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, iterator>
-    upper_bound(const _K2& __k)       {return __tree_.upper_bound(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, const_iterator>
-    upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
+    return __tree_.upper_bound(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {
+    return __tree_.upper_bound(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator,iterator>             equal_range(const key_type& __k)
-            {return __tree_.__equal_range_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
-            {return __tree_.__equal_range_multi(__k);}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __tree_.__equal_range_multi(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __tree_.__equal_range_multi(__k);
+  }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, pair<iterator,iterator>>
-    equal_range(const _K2& __k)       {return __tree_.__equal_range_multi(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    __enable_if_t<__is_transparent<_Compare, _K2>::value, pair<const_iterator,const_iterator>>
-    equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+    return __tree_.__equal_range_multi(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+    return __tree_.__equal_range_multi(__k);
+  }
 #endif
 
 private:
-    typedef typename __base::__node                    __node;
-    typedef typename __base::__node_allocator          __node_allocator;
-    typedef typename __base::__node_pointer            __node_pointer;
+  typedef typename __base::__node __node;
+  typedef typename __base::__node_allocator __node_allocator;
+  typedef typename __base::__node_pointer __node_pointer;
 
-    typedef __map_node_destructor<__node_allocator> _Dp;
-    typedef unique_ptr<__node, _Dp> __node_holder;
+  typedef __map_node_destructor<__node_allocator> _Dp;
+  typedef unique_ptr<__node, _Dp> __node_holder;
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>,
-         class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-         class = enable_if_t<!__is_allocator<_Compare>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+template <class _InputIterator,
+          class _Compare   = less<__iter_key_type<_InputIterator>>,
+          class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
+          class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>>
 multimap(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
-  -> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
+    -> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
 
-template<class _Key, class _Tp, class _Compare = less<remove_const_t<_Key>>,
-         class _Allocator = allocator<pair<const _Key, _Tp>>,
-         class = enable_if_t<!__is_allocator<_Compare>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
-multimap(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare(), _Allocator = _Allocator())
-  -> multimap<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Compare   = less<__range_key_type<_Range>>,
+          class _Allocator = allocator<__range_to_alloc_type<_Range>>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>>
+multimap(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
+    -> multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, _Compare, _Allocator>;
+#  endif
 
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+template <class _Key,
+          class _Tp,
+          class _Compare   = less<remove_const_t<_Key>>,
+          class _Allocator = allocator<pair<const _Key, _Tp>>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>>
+multimap(initializer_list<pair<_Key, _Tp>>,
+         _Compare   = _Compare(),
+         _Allocator = _Allocator()) -> multimap<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
+
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
 multimap(_InputIterator, _InputIterator, _Allocator)
-  -> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
-         less<__iter_key_type<_InputIterator>>, _Allocator>;
+    -> multimap<__iter_key_type<_InputIterator>,
+                __iter_mapped_type<_InputIterator>,
+                less<__iter_key_type<_InputIterator>>,
+                _Allocator>;
 
-template<class _Key, class _Tp, class _Allocator,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
-multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
-  -> multimap<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+multimap(from_range_t, _Range&&, _Allocator)
+    -> multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, less<__range_key_type<_Range>>, _Allocator>;
+#  endif
+
+template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+multimap(initializer_list<pair<_Key, _Tp>>,
+         _Allocator) -> multimap<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 multimap<_Key, _Tp, _Compare, _Allocator>::multimap(multimap&& __m, const allocator_type& __a)
-    : __tree_(_VSTD::move(__m.__tree_), typename __base::allocator_type(__a))
-{
-    if (__a != __m.get_allocator())
-    {
-        const_iterator __e = cend();
-        while (!__m.empty())
-            __tree_.__insert_multi(__e.__i_,
-                    _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_.__move()));
-    }
+    : __tree_(std::move(__m.__tree_), typename __base::allocator_type(__a)) {
+  if (__a != __m.get_allocator()) {
+    const_iterator __e = cend();
+    while (!__m.empty())
+      __tree_.__insert_multi(__e.__i_, std::move(__m.__tree_.remove(__m.begin().__i_)->__value_.__move()));
+  }
 }
 #endif
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
-           const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __x, const multimap<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 #if _LIBCPP_STD_VER <= 17
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
-           const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(const multimap<_Key, _Tp, _Compare, _Allocator>& __x, const multimap<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
-           const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x, const multimap<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return !(__x == __y);
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator> (const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
-           const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(const multimap<_Key, _Tp, _Compare, _Allocator>& __x, const multimap<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return __y < __x;
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
-           const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x, const multimap<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return !(__x < __y);
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
-           const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __x, const multimap<_Key, _Tp, _Compare, _Allocator>& __y) {
+  return !(__y < __x);
 }
 
 #else // #if _LIBCPP_STD_VER <= 17
@@ -2352,34 +2131,23 @@ template <class _Key, class _Tp, class _Compare, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI __synth_three_way_result<pair<const _Key, _Tp>>
 operator<=>(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
             const multimap<_Key, _Tp, _Compare, _Allocator>& __y) {
-    return std::lexicographical_compare_three_way(
-        __x.begin(),
-        __x.end(),
-        __y.begin(),
-        __y.end(),
-        std::__synth_three_way<pair<const _Key, _Tp>, pair<const _Key, _Tp>>);
+  return std::lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), __synth_three_way);
 }
 
 #endif // #if _LIBCPP_STD_VER <= 17
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(multimap<_Key, _Tp, _Compare, _Allocator>& __x,
-     multimap<_Key, _Tp, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(multimap<_Key, _Tp, _Compare, _Allocator>& __x, multimap<_Key, _Tp, _Compare, _Allocator>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
-template <class _Key, class _Tp, class _Compare, class _Allocator,
-          class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-    typename multimap<_Key, _Tp, _Compare, _Allocator>::size_type
-    erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c,
-             _Predicate __pred) {
-  return _VSTD::__libcpp_erase_if_container(__c, __pred);
+template <class _Key, class _Tp, class _Compare, class _Allocator, class _Predicate>
+inline _LIBCPP_HIDE_FROM_ABI typename multimap<_Key, _Tp, _Compare, _Allocator>::size_type
+erase_if(multimap<_Key, _Tp, _Compare, _Allocator>& __c, _Predicate __pred) {
+  return std::__libcpp_erase_if_container(__c, __pred);
 }
 #endif
 
@@ -2389,14 +2157,18 @@ _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>>
-using map = std::map<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
+using map _LIBCPP_AVAILABILITY_PMR =
+    std::map<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 
 template <class _KeyT, class _ValueT, class _CompareT = std::less<_KeyT>>
-using multimap = std::multimap<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
+using multimap _LIBCPP_AVAILABILITY_PMR =
+    std::multimap<_KeyT, _ValueT, _CompareT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstdlib>
diff --git a/third_party/libcxx/math.h b/third_party/libcxx/math.h
index 5820151c4..4e6304a75 100644
--- a/third_party/libcxx/math.h
+++ b/third_party/libcxx/math.h
@@ -8,7 +8,7 @@
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP_MATH_H
-#define _LIBCPP_MATH_H
+#  define _LIBCPP_MATH_H
 
 /*
     math.h synopsis
@@ -291,31 +291,22 @@ long double    truncl(long double x);
 
 */
 
-#include <__config>
+#  include <__config>
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 #  if __has_include_next(<math.h>)
 #    include_next <math.h>
 #  endif
 
-#ifdef __cplusplus
+#  ifdef __cplusplus
 
 // We support including .h headers inside 'extern "C"' contexts, so switch
 // back to C++ linkage before including these C++ headers.
 extern "C++" {
 
-#include <__type_traits/enable_if.h>
-#include <__type_traits/is_floating_point.h>
-#include <__type_traits/is_integral.h>
-#include <__type_traits/is_same.h>
-#include <__type_traits/promote.h>
-#include <limits>
-#include <stdlib.h>
-
-
 #    ifdef fpclassify
 #      undef fpclassify
 #    endif
@@ -364,180 +355,78 @@ extern "C++" {
 #      undef isunordered
 #    endif
 
-// signbit
+#    include <__math/abs.h>
+#    include <__math/copysign.h>
+#    include <__math/error_functions.h>
+#    include <__math/exponential_functions.h>
+#    include <__math/fdim.h>
+#    include <__math/fma.h>
+#    include <__math/gamma.h>
+#    include <__math/hyperbolic_functions.h>
+#    include <__math/hypot.h>
+#    include <__math/inverse_hyperbolic_functions.h>
+#    include <__math/inverse_trigonometric_functions.h>
+#    include <__math/logarithms.h>
+#    include <__math/min_max.h>
+#    include <__math/modulo.h>
+#    include <__math/remainder.h>
+#    include <__math/roots.h>
+#    include <__math/rounding_functions.h>
+#    include <__math/traits.h>
+#    include <__math/trigonometric_functions.h>
+#    include <__type_traits/enable_if.h>
+#    include <__type_traits/is_floating_point.h>
+#    include <__type_traits/is_integral.h>
+#    include <stdlib.h>
 
-template <class _A1, std::__enable_if_t<std::is_floating_point<_A1>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool signbit(_A1 __x) _NOEXCEPT {
-  return __builtin_signbit(__x);
-}
+// fpclassify relies on implementation-defined constants, so we can't move it to a detail header
+_LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _A1, std::__enable_if_t<std::is_integral<_A1>::value && std::is_signed<_A1>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool signbit(_A1 __x) _NOEXCEPT {
-  return __x < 0;
-}
-
-template <class _A1, std::__enable_if_t<std::is_integral<_A1>::value && !std::is_signed<_A1>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool signbit(_A1) _NOEXCEPT {
-  return false;
-}
+namespace __math {
 
 // fpclassify
 
-template <class _A1, std::__enable_if_t<std::is_floating_point<_A1>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI int fpclassify(_A1 __x) _NOEXCEPT {
+// template on non-double overloads to make them weaker than same overloads from MSVC runtime
+template <class = int>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI int fpclassify(float __x) _NOEXCEPT {
+  return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x);
+}
+
+template <class = int>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI int fpclassify(double __x) _NOEXCEPT {
+  return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x);
+}
+
+template <class = int>
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI int fpclassify(long double __x) _NOEXCEPT {
   return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x);
 }
 
 template <class _A1, std::__enable_if_t<std::is_integral<_A1>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI int fpclassify(_A1 __x) _NOEXCEPT {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI int fpclassify(_A1 __x) _NOEXCEPT {
   return __x == 0 ? FP_ZERO : FP_NORMAL;
 }
 
+} // namespace __math
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::__math::fpclassify;
+using std::__math::signbit;
+
 // The MSVC runtime already provides these functions as templates
-#ifndef _LIBCPP_MSVCRT
-
-// isfinite
-
-template <class _A1,
-          std::__enable_if_t<std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, int> = 0>
-_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(_A1 __x) _NOEXCEPT {
-  return __builtin_isfinite((typename std::__promote<_A1>::type)__x);
-}
-
-template <class _A1,
-          std::__enable_if_t<std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, int> = 0>
-_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(_A1) _NOEXCEPT {
-  return true;
-}
-
-// isinf
-
-template <class _A1,
-          std::__enable_if_t<std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, int> = 0>
-_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(_A1 __x) _NOEXCEPT {
-  return __builtin_isinf((typename std::__promote<_A1>::type)__x);
-}
-
-template <class _A1>
-_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI
-    typename std::enable_if< std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, bool>::type
-    isinf(_A1) _NOEXCEPT {
-  return false;
-}
-
-#      ifdef _LIBCPP_PREFERRED_OVERLOAD
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(float __x) _NOEXCEPT {
-  return __builtin_isinf(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool isinf(double __x) _NOEXCEPT {
-  return __builtin_isinf(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(long double __x) _NOEXCEPT {
-  return __builtin_isinf(__x);
-}
-#      endif
-
-// isnan
-
-template <class _A1, std::__enable_if_t<std::is_floating_point<_A1>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(_A1 __x) _NOEXCEPT {
-  return __builtin_isnan(__x);
-}
-
-template <class _A1, std::__enable_if_t<std::is_integral<_A1>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(_A1) _NOEXCEPT {
-  return false;
-}
-
-#      ifdef _LIBCPP_PREFERRED_OVERLOAD
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(float __x) _NOEXCEPT {
-  return __builtin_isnan(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool isnan(double __x) _NOEXCEPT {
-  return __builtin_isnan(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(long double __x) _NOEXCEPT {
-  return __builtin_isnan(__x);
-}
-#      endif
-
-// isnormal
-
-template <class _A1, std::__enable_if_t<std::is_floating_point<_A1>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnormal(_A1 __x) _NOEXCEPT {
-  return __builtin_isnormal(__x);
-}
-
-template <class _A1, std::__enable_if_t<std::is_integral<_A1>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnormal(_A1 __x) _NOEXCEPT {
-  return __x != 0;
-}
-
-// isgreater
-
-template <class _A1,
-          class _A2,
-          std::__enable_if_t<std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isgreater(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename std::__promote<_A1, _A2>::type type;
-  return __builtin_isgreater((type)__x, (type)__y);
-}
-
-// isgreaterequal
-
-template <class _A1,
-          class _A2,
-          std::__enable_if_t<std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename std::__promote<_A1, _A2>::type type;
-  return __builtin_isgreaterequal((type)__x, (type)__y);
-}
-
-// isless
-
-template <class _A1,
-          class _A2,
-          std::__enable_if_t<std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isless(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename std::__promote<_A1, _A2>::type type;
-  return __builtin_isless((type)__x, (type)__y);
-}
-
-// islessequal
-
-template <class _A1,
-          class _A2,
-          std::__enable_if_t<std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool islessequal(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename std::__promote<_A1, _A2>::type type;
-  return __builtin_islessequal((type)__x, (type)__y);
-}
-
-// islessgreater
-
-template <class _A1,
-          class _A2,
-          std::__enable_if_t<std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool islessgreater(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename std::__promote<_A1, _A2>::type type;
-  return __builtin_islessgreater((type)__x, (type)__y);
-}
-
-// isunordered
-
-template <class _A1,
-          class _A2,
-          std::__enable_if_t<std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, int> = 0>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isunordered(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename std::__promote<_A1, _A2>::type type;
-  return __builtin_isunordered((type)__x, (type)__y);
-}
-
-#endif // _LIBCPP_MSVCRT
+#    ifndef _LIBCPP_MSVCRT
+using std::__math::isfinite;
+using std::__math::isgreater;
+using std::__math::isgreaterequal;
+using std::__math::isinf;
+using std::__math::isless;
+using std::__math::islessequal;
+using std::__math::islessgreater;
+using std::__math::isnan;
+using std::__math::isnormal;
+using std::__math::isunordered;
+#    endif // _LIBCPP_MSVCRT
 
 // abs
 //
@@ -552,1102 +441,67 @@ _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isunordered(_A1 __x, _A2
 // templates. Functions are preferred over function templates during overload resolution, which means that our overload
 // will only be selected when the C library doesn't provide one.
 
-// acos
-
-inline _LIBCPP_HIDE_FROM_ABI float       acos(float __x) _NOEXCEPT       {return __builtin_acosf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double acos(double __x) _NOEXCEPT {
-  return __builtin_acos(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double acos(long double __x) _NOEXCEPT {return __builtin_acosl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-acos(_A1 __x) _NOEXCEPT {return __builtin_acos((double)__x);}
-
-// asin
-
-inline _LIBCPP_HIDE_FROM_ABI float       asin(float __x) _NOEXCEPT       {return __builtin_asinf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double asin(double __x) _NOEXCEPT {
-  return __builtin_asin(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double asin(long double __x) _NOEXCEPT {return __builtin_asinl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-asin(_A1 __x) _NOEXCEPT {return __builtin_asin((double)__x);}
-
-// atan
-
-inline _LIBCPP_HIDE_FROM_ABI float       atan(float __x) _NOEXCEPT       {return __builtin_atanf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double atan(double __x) _NOEXCEPT {
-  return __builtin_atan(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double atan(long double __x) _NOEXCEPT {return __builtin_atanl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-atan(_A1 __x) _NOEXCEPT {return __builtin_atan((double)__x);}
-
-// atan2
-
-inline _LIBCPP_HIDE_FROM_ABI float       atan2(float __y, float __x) _NOEXCEPT             {return __builtin_atan2f(__y, __x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double atan2(double __x, double __y) _NOEXCEPT {
-  return __builtin_atan2(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double atan2(long double __y, long double __x) _NOEXCEPT {return __builtin_atan2l(__y, __x);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-atan2(_A1 __y, _A2 __x) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return ::atan2((__result_type)__y, (__result_type)__x);
-}
-
-// ceil
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float       ceil(float __x) _NOEXCEPT       {return __builtin_ceilf(__x);}
-
-template <class = int>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double ceil(double __x) _NOEXCEPT {
-  return __builtin_ceil(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double ceil(long double __x) _NOEXCEPT {return __builtin_ceill(__x);}
-
-template <class _A1>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-ceil(_A1 __x) _NOEXCEPT {return __builtin_ceil((double)__x);}
-
-// cos
-
-inline _LIBCPP_HIDE_FROM_ABI float       cos(float __x) _NOEXCEPT       {return __builtin_cosf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double cos(double __x) _NOEXCEPT {
-  return __builtin_cos(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double cos(long double __x) _NOEXCEPT {return __builtin_cosl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-cos(_A1 __x) _NOEXCEPT {return __builtin_cos((double)__x);}
-
-// cosh
-
-inline _LIBCPP_HIDE_FROM_ABI float       cosh(float __x) _NOEXCEPT       {return __builtin_coshf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double cosh(double __x) _NOEXCEPT {
-  return __builtin_cosh(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double cosh(long double __x) _NOEXCEPT {return __builtin_coshl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-cosh(_A1 __x) _NOEXCEPT {return __builtin_cosh((double)__x);}
-
-// exp
-
-inline _LIBCPP_HIDE_FROM_ABI float       exp(float __x) _NOEXCEPT       {return __builtin_expf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double exp(double __x) _NOEXCEPT {
-  return __builtin_exp(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double exp(long double __x) _NOEXCEPT {return __builtin_expl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-exp(_A1 __x) _NOEXCEPT {return __builtin_exp((double)__x);}
-
-// fabs
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float       fabs(float __x) _NOEXCEPT       {return __builtin_fabsf(__x);}
-
-template <class = int>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double fabs(double __x) _NOEXCEPT {
-  return __builtin_fabs(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fabs(long double __x) _NOEXCEPT {return __builtin_fabsl(__x);}
-
-template <class _A1>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-fabs(_A1 __x) _NOEXCEPT {return __builtin_fabs((double)__x);}
-
-// floor
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float       floor(float __x) _NOEXCEPT       {return __builtin_floorf(__x);}
-
-template <class = int>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double floor(double __x) _NOEXCEPT {
-  return __builtin_floor(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double floor(long double __x) _NOEXCEPT {return __builtin_floorl(__x);}
-
-template <class _A1>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-floor(_A1 __x) _NOEXCEPT {return __builtin_floor((double)__x);}
-
-// fmod
-
-inline _LIBCPP_HIDE_FROM_ABI float       fmod(float __x, float __y) _NOEXCEPT             {return __builtin_fmodf(__x, __y);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double fmod(double __x, double __y) _NOEXCEPT {
-  return __builtin_fmod(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double fmod(long double __x, long double __y) _NOEXCEPT {return __builtin_fmodl(__x, __y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-fmod(_A1 __x, _A2 __y) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return ::fmod((__result_type)__x, (__result_type)__y);
-}
-
-// frexp
-
-inline _LIBCPP_HIDE_FROM_ABI float       frexp(float __x, int* __e) _NOEXCEPT       {return __builtin_frexpf(__x, __e);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double frexp(double __x, int* __e) _NOEXCEPT {
-  return __builtin_frexp(__x, __e);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double frexp(long double __x, int* __e) _NOEXCEPT {return __builtin_frexpl(__x, __e);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-frexp(_A1 __x, int* __e) _NOEXCEPT {return __builtin_frexp((double)__x, __e);}
-
-// ldexp
-
-inline _LIBCPP_HIDE_FROM_ABI float       ldexp(float __x, int __e) _NOEXCEPT       {return __builtin_ldexpf(__x, __e);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double ldexp(double __x, int __e) _NOEXCEPT {
-  return __builtin_ldexp(__x, __e);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double ldexp(long double __x, int __e) _NOEXCEPT {return __builtin_ldexpl(__x, __e);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-ldexp(_A1 __x, int __e) _NOEXCEPT {return __builtin_ldexp((double)__x, __e);}
-
-// log
-
-inline _LIBCPP_HIDE_FROM_ABI float       log(float __x) _NOEXCEPT       {return __builtin_logf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double log(double __x) _NOEXCEPT {
-  return __builtin_log(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double log(long double __x) _NOEXCEPT {return __builtin_logl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-log(_A1 __x) _NOEXCEPT {return __builtin_log((double)__x);}
-
-// log10
-
-inline _LIBCPP_HIDE_FROM_ABI float       log10(float __x) _NOEXCEPT       {return __builtin_log10f(__x);}
-
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double log10(double __x) _NOEXCEPT {
-  return __builtin_log10(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double log10(long double __x) _NOEXCEPT {return __builtin_log10l(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-log10(_A1 __x) _NOEXCEPT {return __builtin_log10((double)__x);}
-
-// modf
-
-inline _LIBCPP_HIDE_FROM_ABI float       modf(float __x, float* __y) _NOEXCEPT             {return __builtin_modff(__x, __y);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double modf(double __x, double* __y) _NOEXCEPT {
-  return __builtin_modf(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double modf(long double __x, long double* __y) _NOEXCEPT {return __builtin_modfl(__x, __y);}
-
-// pow
-
-inline _LIBCPP_HIDE_FROM_ABI float       pow(float __x, float __y) _NOEXCEPT             {return __builtin_powf(__x, __y);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double pow(double __x, double __y) _NOEXCEPT {
-  return __builtin_pow(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double pow(long double __x, long double __y) _NOEXCEPT {return __builtin_powl(__x, __y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-pow(_A1 __x, _A2 __y) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return ::pow((__result_type)__x, (__result_type)__y);
-}
-
-// sin
-
-inline _LIBCPP_HIDE_FROM_ABI float       sin(float __x) _NOEXCEPT       {return __builtin_sinf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double sin(double __x) _NOEXCEPT {
-  return __builtin_sin(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double sin(long double __x) _NOEXCEPT {return __builtin_sinl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-sin(_A1 __x) _NOEXCEPT {return __builtin_sin((double)__x);}
-
-// sinh
-
-inline _LIBCPP_HIDE_FROM_ABI float       sinh(float __x) _NOEXCEPT       {return __builtin_sinhf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double sinh(double __x) _NOEXCEPT {
-  return __builtin_sinh(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double sinh(long double __x) _NOEXCEPT {return __builtin_sinhl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-sinh(_A1 __x) _NOEXCEPT {return __builtin_sinh((double)__x);}
-
-// sqrt
-
-inline _LIBCPP_HIDE_FROM_ABI float       sqrt(float __x) _NOEXCEPT       {return __builtin_sqrtf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double sqrt(double __x) _NOEXCEPT {
-  return __builtin_sqrt(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double sqrt(long double __x) _NOEXCEPT {return __builtin_sqrtl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-sqrt(_A1 __x) _NOEXCEPT {return __builtin_sqrt((double)__x);}
-
-// tan
-
-inline _LIBCPP_HIDE_FROM_ABI float       tan(float __x) _NOEXCEPT       {return __builtin_tanf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double tan(double __x) _NOEXCEPT {
-  return __builtin_tan(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double tan(long double __x) _NOEXCEPT {return __builtin_tanl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-tan(_A1 __x) _NOEXCEPT {return __builtin_tan((double)__x);}
-
-// tanh
-
-inline _LIBCPP_HIDE_FROM_ABI float       tanh(float __x) _NOEXCEPT       {return __builtin_tanhf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double tanh(double __x) _NOEXCEPT {
-  return __builtin_tanh(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double tanh(long double __x) _NOEXCEPT {return __builtin_tanhl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-tanh(_A1 __x) _NOEXCEPT {return __builtin_tanh((double)__x);}
-
-// acosh
-
-inline _LIBCPP_HIDE_FROM_ABI float       acosh(float __x) _NOEXCEPT       {return __builtin_acoshf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double acosh(double __x) _NOEXCEPT {
-  return __builtin_acosh(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double acosh(long double __x) _NOEXCEPT {return __builtin_acoshl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-acosh(_A1 __x) _NOEXCEPT {return __builtin_acosh((double)__x);}
-
-// asinh
-
-inline _LIBCPP_HIDE_FROM_ABI float       asinh(float __x) _NOEXCEPT       {return __builtin_asinhf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double asinh(double __x) _NOEXCEPT {
-  return __builtin_asinh(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double asinh(long double __x) _NOEXCEPT {return __builtin_asinhl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-asinh(_A1 __x) _NOEXCEPT {return __builtin_asinh((double)__x);}
-
-// atanh
-
-inline _LIBCPP_HIDE_FROM_ABI float       atanh(float __x) _NOEXCEPT       {return __builtin_atanhf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double atanh(double __x) _NOEXCEPT {
-  return __builtin_atanh(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double atanh(long double __x) _NOEXCEPT {return __builtin_atanhl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-atanh(_A1 __x) _NOEXCEPT {return __builtin_atanh((double)__x);}
-
-// cbrt
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float       cbrt(float __x) _NOEXCEPT       {return __builtin_cbrtf(__x);}
-
-template <class = int>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double cbrt(double __x) _NOEXCEPT {
-  return __builtin_cbrt(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double cbrt(long double __x) _NOEXCEPT {return __builtin_cbrtl(__x);}
-
-template <class _A1>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-cbrt(_A1 __x) _NOEXCEPT {return __builtin_cbrt((double)__x);}
-
-// copysign
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float copysign(float __x, float __y) _NOEXCEPT {
-  return ::__builtin_copysignf(__x, __y);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double copysign(long double __x, long double __y) _NOEXCEPT {
-  return ::__builtin_copysignl(__x, __y);
-}
-
-template <class _A1, class _A2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-    copysign(_A1 __x, _A2 __y) _NOEXCEPT {
-  return ::__builtin_copysign(__x, __y);
-}
-
-// erf
-
-inline _LIBCPP_HIDE_FROM_ABI float       erf(float __x) _NOEXCEPT       {return __builtin_erff(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double erf(double __x) _NOEXCEPT {
-  return __builtin_erf(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double erf(long double __x) _NOEXCEPT {return __builtin_erfl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-erf(_A1 __x) _NOEXCEPT {return __builtin_erf((double)__x);}
-
-// erfc
-
-inline _LIBCPP_HIDE_FROM_ABI float       erfc(float __x) _NOEXCEPT       {return __builtin_erfcf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double erfc(double __x) _NOEXCEPT {
-  return __builtin_erfc(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double erfc(long double __x) _NOEXCEPT {return __builtin_erfcl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-erfc(_A1 __x) _NOEXCEPT {return __builtin_erfc((double)__x);}
-
-// exp2
-
-inline _LIBCPP_HIDE_FROM_ABI float       exp2(float __x) _NOEXCEPT       {return __builtin_exp2f(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double exp2(double __x) _NOEXCEPT {
-  return __builtin_exp2(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double exp2(long double __x) _NOEXCEPT {return __builtin_exp2l(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-exp2(_A1 __x) _NOEXCEPT {return __builtin_exp2((double)__x);}
-
-// expm1
-
-inline _LIBCPP_HIDE_FROM_ABI float       expm1(float __x) _NOEXCEPT       {return __builtin_expm1f(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double expm1(double __x) _NOEXCEPT {
-  return __builtin_expm1(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double expm1(long double __x) _NOEXCEPT {return __builtin_expm1l(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-expm1(_A1 __x) _NOEXCEPT {return __builtin_expm1((double)__x);}
-
-// fdim
-
-inline _LIBCPP_HIDE_FROM_ABI float       fdim(float __x, float __y) _NOEXCEPT             {return __builtin_fdimf(__x, __y);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double fdim(double __x, double __y) _NOEXCEPT {
-  return __builtin_fdim(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double fdim(long double __x, long double __y) _NOEXCEPT {return __builtin_fdiml(__x, __y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-fdim(_A1 __x, _A2 __y) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return ::fdim((__result_type)__x, (__result_type)__y);
-}
-
-// fma
-
-inline _LIBCPP_HIDE_FROM_ABI float       fma(float __x, float __y, float __z) _NOEXCEPT
-{
-    return __builtin_fmaf(__x, __y, __z);
-}
-
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double fma(double __x, double __y, double __z) _NOEXCEPT {
-  return __builtin_fma(__x, __y, __z);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double fma(long double __x, long double __y, long double __z) _NOEXCEPT
-{
-    return __builtin_fmal(__x, __y, __z);
-}
-
-template <class _A1, class _A2, class _A3>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value &&
-    std::is_arithmetic<_A3>::value,
-    std::__promote<_A1, _A2, _A3>
->::type
-fma(_A1 __x, _A2 __y, _A3 __z) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2, _A3>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value &&
-                     std::_IsSame<_A3, __result_type>::value)), "");
-    return __builtin_fma((__result_type)__x, (__result_type)__y, (__result_type)__z);
-}
-
-// fmax
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float       fmax(float __x, float __y) _NOEXCEPT             {return __builtin_fmaxf(__x, __y);}
-
-template <class = int>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double fmax(double __x, double __y) _NOEXCEPT {
-  return __builtin_fmax(__x, __y);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fmax(long double __x, long double __y) _NOEXCEPT {return __builtin_fmaxl(__x, __y);}
-
-template <class _A1, class _A2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-fmax(_A1 __x, _A2 __y) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return ::fmax((__result_type)__x, (__result_type)__y);
-}
-
-// fmin
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float       fmin(float __x, float __y) _NOEXCEPT             {return __builtin_fminf(__x, __y);}
-
-template <class = int>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double fmin(double __x, double __y) _NOEXCEPT {
-  return __builtin_fmin(__x, __y);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fmin(long double __x, long double __y) _NOEXCEPT {return __builtin_fminl(__x, __y);}
-
-template <class _A1, class _A2>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-fmin(_A1 __x, _A2 __y) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return ::fmin((__result_type)__x, (__result_type)__y);
-}
-
-// hypot
-
-inline _LIBCPP_HIDE_FROM_ABI float       hypot(float __x, float __y) _NOEXCEPT             {return __builtin_hypotf(__x, __y);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double hypot(double __x, double __y) _NOEXCEPT {
-  return __builtin_hypot(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double hypot(long double __x, long double __y) _NOEXCEPT {return __builtin_hypotl(__x, __y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-hypot(_A1 __x, _A2 __y) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return ::hypot((__result_type)__x, (__result_type)__y);
-}
-
-// ilogb
-
-inline _LIBCPP_HIDE_FROM_ABI int ilogb(float __x) _NOEXCEPT       {return __builtin_ilogbf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double ilogb(double __x) _NOEXCEPT {
-  return __builtin_ilogb(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI int ilogb(long double __x) _NOEXCEPT {return __builtin_ilogbl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, int>::type
-ilogb(_A1 __x) _NOEXCEPT {return __builtin_ilogb((double)__x);}
-
-// lgamma
-
-inline _LIBCPP_HIDE_FROM_ABI float       lgamma(float __x) _NOEXCEPT       {return __builtin_lgammaf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double lgamma(double __x) _NOEXCEPT {
-  return __builtin_lgamma(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double lgamma(long double __x) _NOEXCEPT {return __builtin_lgammal(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-lgamma(_A1 __x) _NOEXCEPT {return __builtin_lgamma((double)__x);}
-
-// llrint
-
-inline _LIBCPP_HIDE_FROM_ABI long long llrint(float __x) _NOEXCEPT
-{
-    return __builtin_llrintf(__x);
-}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI long long llrint(double __x) _NOEXCEPT {
-  return __builtin_llrint(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long long llrint(long double __x) _NOEXCEPT
-{
-    return __builtin_llrintl(__x);
-}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, long long>::type
-llrint(_A1 __x) _NOEXCEPT
-{
-    return __builtin_llrint((double)__x);
-}
-
-// llround
-
-inline _LIBCPP_HIDE_FROM_ABI long long llround(float __x) _NOEXCEPT
-{
-    return __builtin_llroundf(__x);
-}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI long long llround(double __x) _NOEXCEPT {
-  return __builtin_llround(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long long llround(long double __x) _NOEXCEPT
-{
-    return __builtin_llroundl(__x);
-}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, long long>::type
-llround(_A1 __x) _NOEXCEPT
-{
-    return __builtin_llround((double)__x);
-}
-
-// log1p
-
-inline _LIBCPP_HIDE_FROM_ABI float       log1p(float __x) _NOEXCEPT       {return __builtin_log1pf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double log1p(double __x) _NOEXCEPT {
-  return __builtin_log1p(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double log1p(long double __x) _NOEXCEPT {return __builtin_log1pl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-log1p(_A1 __x) _NOEXCEPT {return __builtin_log1p((double)__x);}
-
-// log2
-
-inline _LIBCPP_HIDE_FROM_ABI float       log2(float __x) _NOEXCEPT       {return __builtin_log2f(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double log2(double __x) _NOEXCEPT {
-  return __builtin_log2(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double log2(long double __x) _NOEXCEPT {return __builtin_log2l(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-log2(_A1 __x) _NOEXCEPT {return __builtin_log2((double)__x);}
-
-// logb
-
-inline _LIBCPP_HIDE_FROM_ABI float       logb(float __x) _NOEXCEPT       {return __builtin_logbf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double logb(double __x) _NOEXCEPT {
-  return __builtin_logb(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double logb(long double __x) _NOEXCEPT {return __builtin_logbl(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-logb(_A1 __x) _NOEXCEPT {return __builtin_logb((double)__x);}
-
-// lrint
-
-inline _LIBCPP_HIDE_FROM_ABI long lrint(float __x) _NOEXCEPT
-{
-    return __builtin_lrintf(__x);
-}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI long lrint(double __x) _NOEXCEPT {
-  return __builtin_lrint(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long lrint(long double __x) _NOEXCEPT
-{
-    return __builtin_lrintl(__x);
-}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, long>::type
-lrint(_A1 __x) _NOEXCEPT
-{
-    return __builtin_lrint((double)__x);
-}
-
-// lround
-
-inline _LIBCPP_HIDE_FROM_ABI long lround(float __x) _NOEXCEPT
-{
-    return __builtin_lroundf(__x);
-}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI long lround(double __x) _NOEXCEPT {
-  return __builtin_lround(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long lround(long double __x) _NOEXCEPT
-{
-    return __builtin_lroundl(__x);
-}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, long>::type
-lround(_A1 __x) _NOEXCEPT
-{
-    return __builtin_lround((double)__x);
-}
-
-// nan
-
-// nearbyint
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float       nearbyint(float __x) _NOEXCEPT       {return __builtin_nearbyintf(__x);}
-
-template <class = int>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double nearbyint(double __x) _NOEXCEPT {
-  return __builtin_nearbyint(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double nearbyint(long double __x) _NOEXCEPT {return __builtin_nearbyintl(__x);}
-
-template <class _A1>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-nearbyint(_A1 __x) _NOEXCEPT {return __builtin_nearbyint((double)__x);}
-
-// nextafter
-
-inline _LIBCPP_HIDE_FROM_ABI float       nextafter(float __x, float __y) _NOEXCEPT             {return __builtin_nextafterf(__x, __y);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double nextafter(double __x, double __y) _NOEXCEPT {
-  return __builtin_nextafter(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double nextafter(long double __x, long double __y) _NOEXCEPT {return __builtin_nextafterl(__x, __y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-nextafter(_A1 __x, _A2 __y) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return ::nextafter((__result_type)__x, (__result_type)__y);
-}
-
-// nexttoward
-
-inline _LIBCPP_HIDE_FROM_ABI float       nexttoward(float __x, long double __y) _NOEXCEPT       {return __builtin_nexttowardf(__x, __y);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double nexttoward(double __x, long double __y) _NOEXCEPT {
-  return __builtin_nexttoward(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double nexttoward(long double __x, long double __y) _NOEXCEPT {return __builtin_nexttowardl(__x, __y);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-nexttoward(_A1 __x, long double __y) _NOEXCEPT {return __builtin_nexttoward((double)__x, __y);}
-
-// remainder
-
-inline _LIBCPP_HIDE_FROM_ABI float       remainder(float __x, float __y) _NOEXCEPT             {return __builtin_remainderf(__x, __y);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double remainder(double __x, double __y) _NOEXCEPT {
-  return __builtin_remainder(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double remainder(long double __x, long double __y) _NOEXCEPT {return __builtin_remainderl(__x, __y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-remainder(_A1 __x, _A2 __y) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return ::remainder((__result_type)__x, (__result_type)__y);
-}
-
-// remquo
-
-inline _LIBCPP_HIDE_FROM_ABI float       remquo(float __x, float __y, int* __z) _NOEXCEPT             {return __builtin_remquof(__x, __y, __z);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double remquo(double __x, double __y, int* __z) _NOEXCEPT {
-  return __builtin_remquo(__x, __y, __z);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double remquo(long double __x, long double __y, int* __z) _NOEXCEPT {return __builtin_remquol(__x, __y, __z);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::__enable_if_t
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    std::__promote<_A1, _A2>
->::type
-remquo(_A1 __x, _A2 __y, int* __z) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type __result_type;
-    static_assert((!(std::_IsSame<_A1, __result_type>::value &&
-                     std::_IsSame<_A2, __result_type>::value)), "");
-    return ::remquo((__result_type)__x, (__result_type)__y, __z);
-}
-
-// rint
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float       rint(float __x) _NOEXCEPT
-{
-    return __builtin_rintf(__x);
-}
-
-template <class = int>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double rint(double __x) _NOEXCEPT {
-  return __builtin_rint(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double rint(long double __x) _NOEXCEPT
-{
-    return __builtin_rintl(__x);
-}
-
-template <class _A1>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-rint(_A1 __x) _NOEXCEPT
-{
-    return __builtin_rint((double)__x);
-}
-
-// round
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float       round(float __x) _NOEXCEPT
-{
-    return __builtin_round(__x);
-}
-
-template <class = int>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double round(double __x) _NOEXCEPT {
-  return __builtin_round(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double round(long double __x) _NOEXCEPT
-{
-    return __builtin_roundl(__x);
-}
-
-template <class _A1>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-round(_A1 __x) _NOEXCEPT
-{
-    return __builtin_round((double)__x);
-}
-
-// scalbln
-
-inline _LIBCPP_HIDE_FROM_ABI float       scalbln(float __x, long __y) _NOEXCEPT       {return __builtin_scalblnf(__x, __y);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double scalbln(double __x, long __y) _NOEXCEPT {
-  return __builtin_scalbln(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double scalbln(long double __x, long __y) _NOEXCEPT {return __builtin_scalblnl(__x, __y);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-scalbln(_A1 __x, long __y) _NOEXCEPT {return __builtin_scalbln((double)__x, __y);}
-
-// scalbn
-
-inline _LIBCPP_HIDE_FROM_ABI float       scalbn(float __x, int __y) _NOEXCEPT       {return __builtin_scalbnf(__x, __y);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double scalbn(double __x, int __y) _NOEXCEPT {
-  return __builtin_scalbn(__x, __y);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double scalbn(long double __x, int __y) _NOEXCEPT {return __builtin_scalbnl(__x, __y);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-scalbn(_A1 __x, int __y) _NOEXCEPT {return __builtin_scalbn((double)__x, __y);}
-
-// tgamma
-
-inline _LIBCPP_HIDE_FROM_ABI float       tgamma(float __x) _NOEXCEPT       {return __builtin_tgammaf(__x);}
-
-template <class = int>
-_LIBCPP_HIDE_FROM_ABI double tgamma(double __x) _NOEXCEPT {
-  return __builtin_tgamma(__x);
-}
-
-inline _LIBCPP_HIDE_FROM_ABI long double tgamma(long double __x) _NOEXCEPT {return __builtin_tgammal(__x);}
-
-template <class _A1>
-inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-tgamma(_A1 __x) _NOEXCEPT {return __builtin_tgamma((double)__x);}
-
-// trunc
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float       trunc(float __x) _NOEXCEPT
-{
-    return __builtin_trunc(__x);
-}
-
-template <class = int>
-_LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double trunc(double __x) _NOEXCEPT {
-  return __builtin_trunc(__x);
-}
-
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double trunc(long double __x) _NOEXCEPT
-{
-    return __builtin_truncl(__x);
-}
-
-template <class _A1>
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI
-typename std::enable_if<std::is_integral<_A1>::value, double>::type
-trunc(_A1 __x) _NOEXCEPT
-{
-    return __builtin_trunc((double)__x);
-}
+using std::__math::acos;
+using std::__math::acosh;
+using std::__math::asin;
+using std::__math::asinh;
+using std::__math::atan;
+using std::__math::atan2;
+using std::__math::atanh;
+using std::__math::cbrt;
+using std::__math::ceil;
+using std::__math::copysign;
+using std::__math::cos;
+using std::__math::cosh;
+using std::__math::erf;
+using std::__math::erfc;
+using std::__math::exp;
+using std::__math::exp2;
+using std::__math::expm1;
+using std::__math::fabs;
+using std::__math::fdim;
+using std::__math::floor;
+using std::__math::fma;
+using std::__math::fmax;
+using std::__math::fmin;
+using std::__math::fmod;
+using std::__math::frexp;
+using std::__math::hypot;
+using std::__math::ilogb;
+using std::__math::ldexp;
+using std::__math::lgamma;
+using std::__math::llrint;
+using std::__math::llround;
+using std::__math::log;
+using std::__math::log10;
+using std::__math::log1p;
+using std::__math::log2;
+using std::__math::logb;
+using std::__math::lrint;
+using std::__math::lround;
+using std::__math::modf;
+using std::__math::nearbyint;
+using std::__math::nextafter;
+using std::__math::nexttoward;
+using std::__math::pow;
+using std::__math::remainder;
+using std::__math::remquo;
+using std::__math::rint;
+using std::__math::round;
+using std::__math::scalbln;
+using std::__math::scalbn;
+using std::__math::signbit;
+using std::__math::sin;
+using std::__math::sinh;
+using std::__math::sqrt;
+using std::__math::tan;
+using std::__math::tanh;
+using std::__math::tgamma;
+using std::__math::trunc;
 
 } // extern "C++"
 
-#endif // __cplusplus
+#  endif // __cplusplus
 
 #else // _LIBCPP_MATH_H
 
@@ -1659,8 +513,8 @@ trunc(_A1 __x) _NOEXCEPT
 //
 // and receive the definitions of mathematical constants, even if <math.h>
 // has previously been included.
-#if defined(_LIBCPP_MSVCRT) && defined(_USE_MATH_DEFINES)
-#include_next <math.h>
-#endif
+#  if defined(_LIBCPP_MSVCRT) && defined(_USE_MATH_DEFINES)
+#    include_next <math.h>
+#  endif
 
 #endif // _LIBCPP_MATH_H
diff --git a/third_party/libcxx/mdspan b/third_party/libcxx/mdspan
index 16b4e3e16..29190e4a9 100644
--- a/third_party/libcxx/mdspan
+++ b/third_party/libcxx/mdspan
@@ -1,4 +1,4 @@
-// -*-C++ - *-
+// -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
@@ -8,7 +8,38 @@
 //===---------------------------------------------------------------------===//
 
 /*
-    extents synopsis
+
+// Overall mdspan synopsis
+
+namespace std {
+  // [mdspan.extents], class template extents
+  template<class IndexType, size_t... Extents>
+    class extents;
+
+  // [mdspan.extents.dextents], alias template dextents
+  template<class IndexType, size_t Rank>
+    using dextents = see below;
+
+  // [mdspan.extents.dims], alias template dims
+  template<size_t Rank, class IndexType = size_t>
+    using dims = see below; // since C++26
+
+  // [mdspan.layout], layout mapping
+  struct layout_left;
+  struct layout_right;
+  struct layout_stride;
+
+  // [mdspan.accessor.default], class template default_accessor
+  template<class ElementType>
+    class default_accessor;
+
+  // [mdspan.mdspan], class template mdspan
+  template<class ElementType, class Extents, class LayoutPolicy = layout_right,
+           class AccessorPolicy = default_accessor<ElementType>>
+    class mdspan; // not implemented yet
+}
+
+// extents synopsis
 
 namespace std {
   template<class _IndexType, size_t... _Extents>
@@ -54,16 +85,354 @@ namespace std {
     explicit extents(Integrals...)
       -> see below;
 }
+
+// layout_left synopsis
+
+namespace std {
+  template<class Extents>
+  class layout_left::mapping {
+  public:
+    using extents_type = Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_left;
+
+    // [mdspan.layout.right.cons], constructors
+    constexpr mapping() noexcept = default;
+    constexpr mapping(const mapping&) noexcept = default;
+    constexpr mapping(const extents_type&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const layout_right::mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(extents_type::rank() > 0)
+        mapping(const layout_stride::mapping<OtherExtents>&) noexcept;
+
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+
+    // [mdspan.layout.right.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+
+    constexpr index_type required_span_size() const noexcept;
+
+    template<class... Indices>
+      constexpr index_type operator()(Indices...) const noexcept;
+
+    static constexpr bool is_always_unique() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept { return true; }
+    static constexpr bool is_always_strided() noexcept { return true; }
+
+    static constexpr bool is_unique() noexcept { return true; }
+    static constexpr bool is_exhaustive() noexcept { return true; }
+    static constexpr bool is_strided() noexcept { return true; }
+
+    constexpr index_type stride(rank_type) const noexcept;
+
+    template<class OtherExtents>
+      friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
+
+  private:
+    extents_type extents_{};    // exposition only
+  };
+}
+
+// layout_right synopsis
+
+namespace std {
+  template<class Extents>
+  class layout_right::mapping {
+  public:
+    using extents_type = Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_right;
+
+    // [mdspan.layout.right.cons], constructors
+    constexpr mapping() noexcept = default;
+    constexpr mapping(const mapping&) noexcept = default;
+    constexpr mapping(const extents_type&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const layout_left::mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(extents_type::rank() > 0)
+        mapping(const layout_stride::mapping<OtherExtents>&) noexcept;
+
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+
+    // [mdspan.layout.right.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+
+    constexpr index_type required_span_size() const noexcept;
+
+    template<class... Indices>
+      constexpr index_type operator()(Indices...) const noexcept;
+
+    static constexpr bool is_always_unique() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept { return true; }
+    static constexpr bool is_always_strided() noexcept { return true; }
+
+    static constexpr bool is_unique() noexcept { return true; }
+    static constexpr bool is_exhaustive() noexcept { return true; }
+    static constexpr bool is_strided() noexcept { return true; }
+
+    constexpr index_type stride(rank_type) const noexcept;
+
+    template<class OtherExtents>
+      friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
+
+  private:
+    extents_type extents_{};    // exposition only
+  };
+}
+
+// layout_stride synopsis
+
+namespace std {
+  template<class Extents>
+  class layout_stride::mapping {
+  public:
+    using extents_type = Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_stride;
+
+  private:
+    static constexpr rank_type rank_ = extents_type::rank();    // exposition only
+
+  public:
+    // [mdspan.layout.stride.cons], constructors
+    constexpr mapping() noexcept;
+    constexpr mapping(const mapping&) noexcept = default;
+    template<class OtherIndexType>
+      constexpr mapping(const extents_type&, span<OtherIndexType, rank_>) noexcept;
+    template<class OtherIndexType>
+      constexpr mapping(const extents_type&, const array<OtherIndexType, rank_>&) noexcept;
+
+    template<class StridedLayoutMapping>
+      constexpr explicit(see below) mapping(const StridedLayoutMapping&) noexcept;
+
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+
+    // [mdspan.layout.stride.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+    constexpr array<index_type, rank_> strides() const noexcept { return strides_; }
+
+    constexpr index_type required_span_size() const noexcept;
+
+    template<class... Indices>
+      constexpr index_type operator()(Indices...) const noexcept;
+
+    static constexpr bool is_always_unique() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept { return false; }
+    static constexpr bool is_always_strided() noexcept { return true; }
+
+    static constexpr bool is_unique() noexcept { return true; }
+    constexpr bool is_exhaustive() const noexcept;
+    static constexpr bool is_strided() noexcept { return true; }
+
+    constexpr index_type stride(rank_type i) const noexcept { return strides_[i]; }
+
+    template<class OtherMapping>
+      friend constexpr bool operator==(const mapping&, const OtherMapping&) noexcept;
+
+  private:
+    extents_type extents_{};                    // exposition only
+    array<index_type, rank_> strides_{};        // exposition only
+  };
+}
+
+// default_accessor synopsis
+
+namespace std {
+  template<class ElementType>
+  struct default_accessor {
+    using offset_policy = default_accessor;
+    using element_type = ElementType;
+    using reference = ElementType&;
+    using data_handle_type = ElementType*;
+
+    constexpr default_accessor() noexcept = default;
+    template<class OtherElementType>
+      constexpr default_accessor(default_accessor<OtherElementType>) noexcept;
+    constexpr reference access(data_handle_type p, size_t i) const noexcept;
+    constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept;
+  };
+}
+
+// mdspan synopsis
+
+namespace std {
+  template<class ElementType, class Extents, class LayoutPolicy = layout_right,
+           class AccessorPolicy = default_accessor<ElementType>>
+  class mdspan {
+  public:
+    using extents_type = Extents;
+    using layout_type = LayoutPolicy;
+    using accessor_type = AccessorPolicy;
+    using mapping_type = typename layout_type::template mapping<extents_type>;
+    using element_type = ElementType;
+    using value_type = remove_cv_t<element_type>;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using data_handle_type = typename accessor_type::data_handle_type;
+    using reference = typename accessor_type::reference;
+
+    static constexpr rank_type rank() noexcept { return extents_type::rank(); }
+    static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
+    static constexpr size_t static_extent(rank_type r) noexcept
+      { return extents_type::static_extent(r); }
+    constexpr index_type extent(rank_type r) const noexcept { return extents().extent(r); }
+
+    // [mdspan.mdspan.cons], constructors
+    constexpr mdspan();
+    constexpr mdspan(const mdspan& rhs) = default;
+    constexpr mdspan(mdspan&& rhs) = default;
+
+    template<class... OtherIndexTypes>
+      constexpr explicit mdspan(data_handle_type ptr, OtherIndexTypes... exts);
+    template<class OtherIndexType, size_t N>
+      constexpr explicit(N != rank_dynamic())
+        mdspan(data_handle_type p, span<OtherIndexType, N> exts);
+    template<class OtherIndexType, size_t N>
+      constexpr explicit(N != rank_dynamic())
+        mdspan(data_handle_type p, const array<OtherIndexType, N>& exts);
+    constexpr mdspan(data_handle_type p, const extents_type& ext);
+    constexpr mdspan(data_handle_type p, const mapping_type& m);
+    constexpr mdspan(data_handle_type p, const mapping_type& m, const accessor_type& a);
+
+    template<class OtherElementType, class OtherExtents,
+             class OtherLayoutPolicy, class OtherAccessorPolicy>
+      constexpr explicit(see below)
+        mdspan(const mdspan<OtherElementType, OtherExtents,
+                            OtherLayoutPolicy, OtherAccessorPolicy>& other);
+
+    constexpr mdspan& operator=(const mdspan& rhs) = default;
+    constexpr mdspan& operator=(mdspan&& rhs) = default;
+
+    // [mdspan.mdspan.members], members
+    template<class... OtherIndexTypes>
+      constexpr reference operator[](OtherIndexTypes... indices) const;
+    template<class OtherIndexType>
+      constexpr reference operator[](span<OtherIndexType, rank()> indices) const;
+    template<class OtherIndexType>
+      constexpr reference operator[](const array<OtherIndexType, rank()>& indices) const;
+
+    constexpr size_type size() const noexcept;
+    [[nodiscard]] constexpr bool empty() const noexcept;
+
+    friend constexpr void swap(mdspan& x, mdspan& y) noexcept;
+
+    constexpr const extents_type& extents() const noexcept { return map_.extents(); }
+    constexpr const data_handle_type& data_handle() const noexcept { return ptr_; }
+    constexpr const mapping_type& mapping() const noexcept { return map_; }
+    constexpr const accessor_type& accessor() const noexcept { return acc_; }
+
+    // per LWG-4021 "mdspan::is_always_meow() should be noexcept"
+    static constexpr bool is_always_unique() noexcept
+      { return mapping_type::is_always_unique(); }
+    static constexpr bool is_always_exhaustive() noexcept
+      { return mapping_type::is_always_exhaustive(); }
+    static constexpr bool is_always_strided() noexcept
+      { return mapping_type::is_always_strided(); }
+
+    constexpr bool is_unique() const
+      { return map_.is_unique(); }
+    constexpr bool is_exhaustive() const
+      { return map_.is_exhaustive(); }
+    constexpr bool is_strided() const
+      { return map_.is_strided(); }
+    constexpr index_type stride(rank_type r) const
+      { return map_.stride(r); }
+
+  private:
+    accessor_type acc_;         // exposition only
+    mapping_type map_;          // exposition only
+    data_handle_type ptr_;      // exposition only
+  };
+
+  template<class CArray>
+    requires(is_array_v<CArray> && rank_v<CArray> == 1)
+    mdspan(CArray&)
+      -> mdspan<remove_all_extents_t<CArray>, extents<size_t, extent_v<CArray, 0>>>;
+
+  template<class Pointer>
+    requires(is_pointer_v<remove_reference_t<Pointer>>)
+    mdspan(Pointer&&)
+      -> mdspan<remove_pointer_t<remove_reference_t<Pointer>>, extents<size_t>>;
+
+  template<class ElementType, class... Integrals>
+    requires((is_convertible_v<Integrals, size_t> && ...) && sizeof...(Integrals) > 0)
+    explicit mdspan(ElementType*, Integrals...)
+      -> mdspan<ElementType, dextents<size_t, sizeof...(Integrals)>>;            // until C++26
+  template<class ElementType, class... Integrals>
+    requires((is_convertible_v<Integrals, size_t> && ...) && sizeof...(Integrals) > 0)
+    explicit mdspan(ElementType*, Integrals...)
+      -> mdspan<ElementType, extents<size_t, maybe-static-ext<Integrals>...>>;  // since C++26
+
+  template<class ElementType, class OtherIndexType, size_t N>
+    mdspan(ElementType*, span<OtherIndexType, N>)
+      -> mdspan<ElementType, dextents<size_t, N>>;
+
+  template<class ElementType, class OtherIndexType, size_t N>
+    mdspan(ElementType*, const array<OtherIndexType, N>&)
+      -> mdspan<ElementType, dextents<size_t, N>>;
+
+  template<class ElementType, class IndexType, size_t... ExtentsPack>
+    mdspan(ElementType*, const extents<IndexType, ExtentsPack...>&)
+      -> mdspan<ElementType, extents<IndexType, ExtentsPack...>>;
+
+  template<class ElementType, class MappingType>
+    mdspan(ElementType*, const MappingType&)
+      -> mdspan<ElementType, typename MappingType::extents_type,
+                typename MappingType::layout_type>;
+
+  template<class MappingType, class AccessorType>
+    mdspan(const typename AccessorType::data_handle_type&, const MappingType&,
+           const AccessorType&)
+      -> mdspan<typename AccessorType::element_type, typename MappingType::extents_type,
+                typename MappingType::layout_type, AccessorType>;
+}
 */
 
 #ifndef _LIBCPP_MDSPAN
 #define _LIBCPP_MDSPAN
 
 #include <__config>
-#include <__mdspan/extents.h>
+
+#if _LIBCPP_STD_VER >= 23
+#  include <__fwd/mdspan.h>
+#  include <__mdspan/default_accessor.h>
+#  include <__mdspan/extents.h>
+#  include <__mdspan/layout_left.h>
+#  include <__mdspan/layout_right.h>
+#  include <__mdspan/layout_stride.h>
+#  include <__mdspan/mdspan.h>
+#endif
+
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <array>
+#  include <cinttypes>
+#  include <concepts>
+#  include <cstddef>
+#  include <limits>
+#  include <span>
+#endif
+
 #endif // _LIBCPP_MDSPAN
diff --git a/third_party/libcxx/memory b/third_party/libcxx/memory
index 394688479..b940a32c3 100644
--- a/third_party/libcxx/memory
+++ b/third_party/libcxx/memory
@@ -10,6 +10,8 @@
 #ifndef _LIBCPP_MEMORY
 #define _LIBCPP_MEMORY
 
+// clang-format off
+
 /*
     memory synopsis
 
@@ -86,6 +88,9 @@ struct allocator_traits
     static pointer allocate(allocator_type& a, size_type n);                          // constexpr and [[nodiscard]] in C++20
     static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint); // constexpr and [[nodiscard]] in C++20
 
+    [[nodiscard]] static constexpr allocation_result<pointer, size_type>
+      allocate_at_least(Alloc& a, size_type n);                                 // Since C++23
+
     static void deallocate(allocator_type& a, pointer p, size_type n) noexcept; // constexpr in C++20
 
     template <class T, class... Args>
@@ -98,15 +103,11 @@ struct allocator_traits
     static allocator_type select_on_container_copy_construction(const allocator_type& a); // constexpr in C++20
 };
 
-template<class Pointer>
+template<class Pointer, class SizeType = size_t>
 struct allocation_result {
     Pointer ptr;
-    size_t count;
-}; // since C++23
-
-template<class Allocator>
-[[nodiscard]] constexpr allocation_result<typename allocator_traits<Allocator>::pointer>
-    allocate_at_least(Allocator& a, size_t n); // since C++23
+    SizeType count;
+}; // Since C++23
 
 template <>
 class allocator<void> // removed in C++20
@@ -137,7 +138,7 @@ public:
     template <class U> struct rebind {typedef allocator<U> other;}; // deprecated in C++17, removed in C++20
 
     typedef true_type propagate_on_container_move_assignment;
-    typedef true_type is_always_equal;
+    typedef true_type is_always_equal;                   // Deprecated in C++23, removed in C++26
 
     constexpr allocator() noexcept;                      // constexpr in C++20
     constexpr allocator(const allocator&) noexcept;      // constexpr in C++20
@@ -160,7 +161,7 @@ template <class T, class U>
 bool operator==(const allocator<T>&, const allocator<U>&) noexcept; // constexpr in C++20
 
 template <class T, class U>
-bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; // constexpr in C++20
+bool operator!=(const allocator<T>&, const allocator<U>&) noexcept; // removed in C++20
 
 template <class OutputIterator, class T>
 class raw_storage_iterator // deprecated in C++17, removed in C++20
@@ -450,7 +451,8 @@ public:
     constexpr unique_ptr& operator=(nullptr_t) noexcept;                              // constexpr since C++23
 
     // observers
-    typename constexpr add_lvalue_reference<T>::type operator*() const;               // constexpr since C++23
+    constexpr
+    add_lvalue_reference<T>::type operator*() const noexcept(see below);              // constexpr since C++23
     constexpr pointer operator->() const noexcept;                                    // constexpr since C++23
     constexpr pointer get() const noexcept;                                           // constexpr since C++23
     constexpr deleter_type& get_deleter() noexcept;                                   // constexpr since C++23
@@ -627,7 +629,7 @@ public:
     T& operator*() const noexcept;
     T* operator->() const noexcept;
     long use_count() const noexcept;
-    bool unique() const noexcept;
+    bool unique() const noexcept;  // deprected in C++17, removed in C++20
     explicit operator bool() const noexcept;
     template<class U> bool owner_before(shared_ptr<U> const& b) const noexcept;
     template<class U> bool owner_before(weak_ptr<U> const& b) const noexcept;
@@ -867,44 +869,108 @@ template <class T> struct hash<shared_ptr<T> >;
 template <class T, class Alloc>
   inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
 
+// [allocator.uses.construction], uses-allocator construction
+template<class T, class Alloc, class... Args>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // since C++20
+                                                  Args&&... args) noexcept;
+template<class T, class Alloc, class Tuple1, class Tuple2>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // since C++20
+                                                  piecewise_construct_t,
+                                                  Tuple1&& x, Tuple2&& y) noexcept;
+template<class T, class Alloc>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc) noexcept;   // since C++20
+template<class T, class Alloc, class U, class V>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // since C++20
+                                                  U&& u, V&& v) noexcept;
+template<class T, class Alloc, class U, class V>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // since C++23
+                                                  pair<U, V>& pr) noexcept;
+template<class T, class Alloc, class U, class V>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // since C++20
+                                                  const pair<U, V>& pr) noexcept;
+template<class T, class Alloc, class U, class V>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // since C++20
+                                                  pair<U, V>&& pr) noexcept;
+template<class T, class Alloc, class U, class V>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // since C++23
+                                                  const pair<U, V>&& pr) noexcept;
+template<class T, class Alloc, pair-like P>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // since C++20
+                                                  P&& p) noexcept;
+template<class T, class Alloc, class U>
+  constexpr auto uses_allocator_construction_args(const Alloc& alloc,             // since C++20
+                                                  U&& u) noexcept;
+template<class T, class Alloc, class... Args>
+  constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args);       // since C++20
+template<class T, class Alloc, class... Args>
+  constexpr T* uninitialized_construct_using_allocator(T* p,                      // since C++20
+                                                         const Alloc& alloc, Args&&... args);
+
 // [ptr.align]
 void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
 
 template<size_t N, class T>
 [[nodiscard]] constexpr T* assume_aligned(T* ptr); // since C++20
 
+// [out.ptr.t], class template out_ptr_t
+template<class Smart, class Pointer, class... Args>
+  class out_ptr_t;                                          // since c++23
+
+// [out.ptr], function template out_ptr
+template<class Pointer = void, class Smart, class... Args>
+  auto out_ptr(Smart& s, Args&&... args);                   // since c++23
+
+// [inout.ptr.t], class template inout_ptr_t
+template<class Smart, class Pointer, class... Args>
+  class inout_ptr_t;                                        // since c++23
+
+// [inout.ptr], function template inout_ptr
+template<class Pointer = void, class Smart, class... Args>
+  auto inout_ptr(Smart& s, Args&&... args);                 // since c++23
+
 }  // std
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
+// clang-format on
+
 #include <__config>
 #include <__memory/addressof.h>
 #include <__memory/align.h>
-#include <__memory/allocate_at_least.h>
-#include <__memory/allocation_guard.h>
 #include <__memory/allocator.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/allocator_traits.h>
-#include <__memory/assume_aligned.h>
 #include <__memory/auto_ptr.h>
-#include <__memory/compressed_pair.h>
-#include <__memory/concepts.h>
-#include <__memory/construct_at.h>
+#include <__memory/inout_ptr.h>
+#include <__memory/out_ptr.h>
 #include <__memory/pointer_traits.h>
-#include <__memory/ranges_construct_at.h>
-#include <__memory/ranges_uninitialized_algorithms.h>
 #include <__memory/raw_storage_iterator.h>
 #include <__memory/shared_ptr.h>
 #include <__memory/temporary_buffer.h>
 #include <__memory/uninitialized_algorithms.h>
 #include <__memory/unique_ptr.h>
 #include <__memory/uses_allocator.h>
-#include <__memory/uses_allocator_construction.h>
-#include <version>
 
 // standard-mandated includes
 
+#if _LIBCPP_STD_VER >= 17
+#  include <__memory/construct_at.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__memory/assume_aligned.h>
+#  include <__memory/concepts.h>
+#  include <__memory/ranges_construct_at.h>
+#  include <__memory/ranges_uninitialized_algorithms.h>
+#  include <__memory/uses_allocator_construction.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+#  include <__memory/allocate_at_least.h>
+#endif
+
+#include <version>
+
 // [memory.syn]
 #include <compare>
 
diff --git a/third_party/libcxx/memory.cpp b/third_party/libcxx/memory.cpp
new file mode 100644
index 000000000..a0e7d2678
--- /dev/null
+++ b/third_party/libcxx/memory.cpp
@@ -0,0 +1,148 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+#ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
+#  define _LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS
+#endif
+
+#include <memory>
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+#  include <mutex>
+#  include <thread>
+#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#    pragma comment(lib, "pthread")
+#  endif
+#endif
+
+#include "atomic_support.h"
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+bad_weak_ptr::~bad_weak_ptr() noexcept {}
+
+const char* bad_weak_ptr::what() const noexcept { return "bad_weak_ptr"; }
+
+__shared_count::~__shared_count() {}
+
+__shared_weak_count::~__shared_weak_count() {}
+
+#if defined(_LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS)
+void __shared_count::__add_shared() noexcept { __libcpp_atomic_refcount_increment(__shared_owners_); }
+
+bool __shared_count::__release_shared() noexcept {
+  if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) {
+    __on_zero_shared();
+    return true;
+  }
+  return false;
+}
+
+void __shared_weak_count::__add_shared() noexcept { __shared_count::__add_shared(); }
+
+void __shared_weak_count::__add_weak() noexcept { __libcpp_atomic_refcount_increment(__shared_weak_owners_); }
+
+void __shared_weak_count::__release_shared() noexcept {
+  if (__shared_count::__release_shared())
+    __release_weak();
+}
+#endif // _LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS
+
+void __shared_weak_count::__release_weak() noexcept {
+  // NOTE: The acquire load here is an optimization of the very
+  // common case where a shared pointer is being destructed while
+  // having no other contended references.
+  //
+  // BENEFIT: We avoid expensive atomic stores like XADD and STREX
+  // in a common case.  Those instructions are slow and do nasty
+  // things to caches.
+  //
+  // IS THIS SAFE?  Yes.  During weak destruction, if we see that we
+  // are the last reference, we know that no-one else is accessing
+  // us. If someone were accessing us, then they would be doing so
+  // while the last shared / weak_ptr was being destructed, and
+  // that's undefined anyway.
+  //
+  // If we see anything other than a 0, then we have possible
+  // contention, and need to use an atomicrmw primitive.
+  // The same arguments don't apply for increment, where it is legal
+  // (though inadvisable) to share shared_ptr references between
+  // threads, and have them all get copied at once.  The argument
+  // also doesn't apply for __release_shared, because an outstanding
+  // weak_ptr::lock() could read / modify the shared count.
+  if (__libcpp_atomic_load(&__shared_weak_owners_, _AO_Acquire) == 0) {
+    // no need to do this store, because we are about
+    // to destroy everything.
+    //__libcpp_atomic_store(&__shared_weak_owners_, -1, _AO_Release);
+    __on_zero_shared_weak();
+  } else if (__libcpp_atomic_refcount_decrement(__shared_weak_owners_) == -1)
+    __on_zero_shared_weak();
+}
+
+__shared_weak_count* __shared_weak_count::lock() noexcept {
+  long object_owners = __libcpp_atomic_load(&__shared_owners_);
+  while (object_owners != -1) {
+    if (__libcpp_atomic_compare_exchange(&__shared_owners_, &object_owners, object_owners + 1))
+      return this;
+  }
+  return nullptr;
+}
+
+const void* __shared_weak_count::__get_deleter(const type_info&) const noexcept { return nullptr; }
+
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+
+static constexpr std::size_t __sp_mut_count                = 32;
+static constinit __libcpp_mutex_t mut_back[__sp_mut_count] = {
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
+    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER};
+
+constexpr __sp_mut::__sp_mut(void* p) noexcept : __lx_(p) {}
+
+void __sp_mut::lock() noexcept {
+  auto m = static_cast<__libcpp_mutex_t*>(__lx_);
+  __libcpp_mutex_lock(m);
+}
+
+void __sp_mut::unlock() noexcept { __libcpp_mutex_unlock(static_cast<__libcpp_mutex_t*>(__lx_)); }
+
+__sp_mut& __get_sp_mut(const void* p) {
+  static constinit __sp_mut muts[__sp_mut_count] = {
+      &mut_back[0],  &mut_back[1],  &mut_back[2],  &mut_back[3],  &mut_back[4],  &mut_back[5],  &mut_back[6],
+      &mut_back[7],  &mut_back[8],  &mut_back[9],  &mut_back[10], &mut_back[11], &mut_back[12], &mut_back[13],
+      &mut_back[14], &mut_back[15], &mut_back[16], &mut_back[17], &mut_back[18], &mut_back[19], &mut_back[20],
+      &mut_back[21], &mut_back[22], &mut_back[23], &mut_back[24], &mut_back[25], &mut_back[26], &mut_back[27],
+      &mut_back[28], &mut_back[29], &mut_back[30], &mut_back[31]};
+  return muts[hash<const void*>()(p) & (__sp_mut_count - 1)];
+}
+
+#endif // !defined(_LIBCPP_HAS_NO_THREADS)
+
+void* align(size_t alignment, size_t size, void*& ptr, size_t& space) {
+  void* r = nullptr;
+  if (size <= space) {
+    char* p1 = static_cast<char*>(ptr);
+    char* p2 = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(p1 + (alignment - 1)) & -alignment);
+    size_t d = static_cast<size_t>(p2 - p1);
+    if (d <= space - size) {
+      r   = p2;
+      ptr = r;
+      space -= d;
+    }
+  }
+  return r;
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/memory_resource b/third_party/libcxx/memory_resource
index 4b3934336..674110548 100644
--- a/third_party/libcxx/memory_resource
+++ b/third_party/libcxx/memory_resource
@@ -22,7 +22,7 @@ namespace std::pmr {
   bool operator==(const memory_resource& a,
                   const memory_resource& b) noexcept;
   bool operator!=(const memory_resource& a,
-                  const memory_resource& b) noexcept;
+                  const memory_resource& b) noexcept;           // removed in C++20
 
   template <class Tp> class polymorphic_allocator;
 
@@ -31,7 +31,7 @@ namespace std::pmr {
                   const polymorphic_allocator<T2>& b) noexcept;
   template <class T1, class T2>
   bool operator!=(const polymorphic_allocator<T1>& a,
-                  const polymorphic_allocator<T2>& b) noexcept;
+                  const polymorphic_allocator<T2>& b) noexcept; // removed in C++20
 
   // Global memory resources
   memory_resource* set_default_resource(memory_resource* r) noexcept;
@@ -50,16 +50,34 @@ namespace std::pmr {
  */
 
 #include <__config>
-#include <__memory_resource/memory_resource.h>
-#include <__memory_resource/monotonic_buffer_resource.h>
-#include <__memory_resource/polymorphic_allocator.h>
-#include <__memory_resource/pool_options.h>
-#include <__memory_resource/synchronized_pool_resource.h>
-#include <__memory_resource/unsynchronized_pool_resource.h>
+
+#if _LIBCPP_STD_VER >= 17
+#  include <__memory_resource/memory_resource.h>
+#  include <__memory_resource/monotonic_buffer_resource.h>
+#  include <__memory_resource/polymorphic_allocator.h>
+#  include <__memory_resource/pool_options.h>
+#  include <__memory_resource/synchronized_pool_resource.h>
+#  include <__memory_resource/unsynchronized_pool_resource.h>
+#endif
+
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 14
+#  include <cstddef>
+#  include <cstdint>
+#  include <limits>
+#  include <mutex>
+#  include <new>
+#  include <stdexcept>
+#  include <tuple>
+#endif
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <stdexcept>
+#endif
+
 #endif /* _LIBCPP_MEMORY_RESOURCE */
diff --git a/third_party/libcxx/memory_resource.cpp b/third_party/libcxx/memory_resource.cpp
new file mode 100644
index 000000000..2117238e6
--- /dev/null
+++ b/third_party/libcxx/memory_resource.cpp
@@ -0,0 +1,498 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <memory>
+#include <memory_resource>
+
+#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
+#  include <atomic>
+#elif !defined(_LIBCPP_HAS_NO_THREADS)
+#  include <mutex>
+#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#    pragma comment(lib, "pthread")
+#  endif
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+
+// memory_resource
+
+memory_resource::~memory_resource() = default;
+
+// new_delete_resource()
+
+#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
+static bool is_aligned_to(void* ptr, size_t align) {
+  void* p2     = ptr;
+  size_t space = 1;
+  void* result = std::align(align, 1, p2, space);
+  return (result == ptr);
+}
+#endif
+
+class _LIBCPP_EXPORTED_FROM_ABI __new_delete_memory_resource_imp : public memory_resource {
+  void* do_allocate(size_t bytes, size_t align) override {
+#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
+    return std::__libcpp_allocate(bytes, align);
+#else
+    if (bytes == 0)
+      bytes = 1;
+    void* result = std::__libcpp_allocate(bytes, align);
+    if (!is_aligned_to(result, align)) {
+      std::__libcpp_deallocate(result, bytes, align);
+      __throw_bad_alloc();
+    }
+    return result;
+#endif
+  }
+
+  void do_deallocate(void* p, size_t bytes, size_t align) override { std::__libcpp_deallocate(p, bytes, align); }
+
+  bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
+};
+
+// null_memory_resource()
+
+class _LIBCPP_EXPORTED_FROM_ABI __null_memory_resource_imp : public memory_resource {
+  void* do_allocate(size_t, size_t) override { __throw_bad_alloc(); }
+  void do_deallocate(void*, size_t, size_t) override {}
+  bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
+};
+
+namespace {
+
+union ResourceInitHelper {
+  struct {
+    __new_delete_memory_resource_imp new_delete_res;
+    __null_memory_resource_imp null_res;
+  } resources;
+  char dummy;
+  constexpr ResourceInitHelper() : resources() {}
+  ~ResourceInitHelper() {}
+};
+
+// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
+// attribute with a value that's reserved for the implementation (we're the implementation).
+#include "memory_resource_init_helper.h"
+
+} // end namespace
+
+memory_resource* new_delete_resource() noexcept { return &res_init.resources.new_delete_res; }
+
+memory_resource* null_memory_resource() noexcept { return &res_init.resources.null_res; }
+
+// default_memory_resource()
+
+static memory_resource* __default_memory_resource(bool set = false, memory_resource* new_res = nullptr) noexcept {
+#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
+  static constinit atomic<memory_resource*> __res{&res_init.resources.new_delete_res};
+  if (set) {
+    new_res = new_res ? new_res : new_delete_resource();
+    // TODO: Can a weaker ordering be used?
+    return std::atomic_exchange_explicit(&__res, new_res, memory_order_acq_rel);
+  } else {
+    return std::atomic_load_explicit(&__res, memory_order_acquire);
+  }
+#elif !defined(_LIBCPP_HAS_NO_THREADS)
+  static constinit memory_resource* res = &res_init.resources.new_delete_res;
+  static mutex res_lock;
+  if (set) {
+    new_res = new_res ? new_res : new_delete_resource();
+    lock_guard<mutex> guard(res_lock);
+    memory_resource* old_res = res;
+    res                      = new_res;
+    return old_res;
+  } else {
+    lock_guard<mutex> guard(res_lock);
+    return res;
+  }
+#else
+  static constinit memory_resource* res = &res_init.resources.new_delete_res;
+  if (set) {
+    new_res                  = new_res ? new_res : new_delete_resource();
+    memory_resource* old_res = res;
+    res                      = new_res;
+    return old_res;
+  } else {
+    return res;
+  }
+#endif
+}
+
+memory_resource* get_default_resource() noexcept { return __default_memory_resource(); }
+
+memory_resource* set_default_resource(memory_resource* __new_res) noexcept {
+  return __default_memory_resource(true, __new_res);
+}
+
+// 23.12.5, mem.res.pool
+
+static size_t roundup(size_t count, size_t alignment) {
+  size_t mask = alignment - 1;
+  return (count + mask) & ~mask;
+}
+
+struct unsynchronized_pool_resource::__adhoc_pool::__chunk_footer {
+  __chunk_footer* __next_;
+  char* __start_;
+  size_t __align_;
+  size_t __allocation_size() { return (reinterpret_cast<char*>(this) - __start_) + sizeof(*this); }
+};
+
+void unsynchronized_pool_resource::__adhoc_pool::__release_ptr(memory_resource* upstream) {
+  while (__first_ != nullptr) {
+    __chunk_footer* next = __first_->__next_;
+    upstream->deallocate(__first_->__start_, __first_->__allocation_size(), __first_->__align_);
+    __first_ = next;
+  }
+}
+
+void* unsynchronized_pool_resource::__adhoc_pool::__do_allocate(memory_resource* upstream, size_t bytes, size_t align) {
+  const size_t footer_size  = sizeof(__chunk_footer);
+  const size_t footer_align = alignof(__chunk_footer);
+
+  if (align < footer_align)
+    align = footer_align;
+
+  size_t aligned_capacity = roundup(bytes, footer_align) + footer_size;
+
+  void* result = upstream->allocate(aligned_capacity, align);
+
+  __chunk_footer* h = (__chunk_footer*)((char*)result + aligned_capacity - footer_size);
+  h->__next_        = __first_;
+  h->__start_       = (char*)result;
+  h->__align_       = align;
+  __first_          = h;
+  return result;
+}
+
+void unsynchronized_pool_resource::__adhoc_pool::__do_deallocate(
+    memory_resource* upstream, void* p, size_t bytes, size_t align) {
+  _LIBCPP_ASSERT_NON_NULL(__first_ != nullptr, "deallocating a block that was not allocated with this allocator");
+  if (__first_->__start_ == p) {
+    __chunk_footer* next = __first_->__next_;
+    upstream->deallocate(p, __first_->__allocation_size(), __first_->__align_);
+    __first_ = next;
+  } else {
+    for (__chunk_footer* h = __first_; h->__next_ != nullptr; h = h->__next_) {
+      if (h->__next_->__start_ == p) {
+        __chunk_footer* next = h->__next_->__next_;
+        upstream->deallocate(p, h->__next_->__allocation_size(), h->__next_->__align_);
+        h->__next_ = next;
+        return;
+      }
+    }
+    // The request to deallocate memory ends up being a no-op, likely resulting in a memory leak.
+    _LIBCPP_ASSERT_VALID_DEALLOCATION(false, "deallocating a block that was not allocated with this allocator");
+  }
+}
+
+class unsynchronized_pool_resource::__fixed_pool {
+  struct __chunk_footer {
+    __chunk_footer* __next_;
+    char* __start_;
+    size_t __align_;
+    size_t __allocation_size() { return (reinterpret_cast<char*>(this) - __start_) + sizeof(*this); }
+  };
+
+  struct __vacancy_header {
+    __vacancy_header* __next_vacancy_;
+  };
+
+  __chunk_footer* __first_chunk_     = nullptr;
+  __vacancy_header* __first_vacancy_ = nullptr;
+
+public:
+  explicit __fixed_pool() = default;
+
+  void __release_ptr(memory_resource* upstream) {
+    __first_vacancy_ = nullptr;
+    while (__first_chunk_ != nullptr) {
+      __chunk_footer* next = __first_chunk_->__next_;
+      upstream->deallocate(__first_chunk_->__start_, __first_chunk_->__allocation_size(), __first_chunk_->__align_);
+      __first_chunk_ = next;
+    }
+  }
+
+  void* __try_allocate_from_vacancies() {
+    if (__first_vacancy_ != nullptr) {
+      void* result     = __first_vacancy_;
+      __first_vacancy_ = __first_vacancy_->__next_vacancy_;
+      return result;
+    }
+    return nullptr;
+  }
+
+  void* __allocate_in_new_chunk(memory_resource* upstream, size_t block_size, size_t chunk_size) {
+    _LIBCPP_ASSERT_INTERNAL(chunk_size % block_size == 0, "");
+    static_assert(__default_alignment >= alignof(std::max_align_t), "");
+    static_assert(__default_alignment >= alignof(__chunk_footer), "");
+    static_assert(__default_alignment >= alignof(__vacancy_header), "");
+
+    const size_t footer_size  = sizeof(__chunk_footer);
+    const size_t footer_align = alignof(__chunk_footer);
+
+    size_t aligned_capacity = roundup(chunk_size, footer_align) + footer_size;
+
+    void* result = upstream->allocate(aligned_capacity, __default_alignment);
+
+    __chunk_footer* h = (__chunk_footer*)((char*)result + aligned_capacity - footer_size);
+    h->__next_        = __first_chunk_;
+    h->__start_       = (char*)result;
+    h->__align_       = __default_alignment;
+    __first_chunk_    = h;
+
+    if (chunk_size > block_size) {
+      __vacancy_header* last_vh = this->__first_vacancy_;
+      for (size_t i = block_size; i != chunk_size; i += block_size) {
+        __vacancy_header* vh = (__vacancy_header*)((char*)result + i);
+        vh->__next_vacancy_  = last_vh;
+        last_vh              = vh;
+      }
+      this->__first_vacancy_ = last_vh;
+    }
+    return result;
+  }
+
+  void __evacuate(void* p) {
+    __vacancy_header* vh = (__vacancy_header*)(p);
+    vh->__next_vacancy_  = __first_vacancy_;
+    __first_vacancy_     = vh;
+  }
+
+  size_t __previous_chunk_size_in_bytes() const { return __first_chunk_ ? __first_chunk_->__allocation_size() : 0; }
+
+  static const size_t __default_alignment = alignof(max_align_t);
+};
+
+size_t unsynchronized_pool_resource::__pool_block_size(int i) const { return size_t(1) << __log2_pool_block_size(i); }
+
+int unsynchronized_pool_resource::__log2_pool_block_size(int i) const { return (i + __log2_smallest_block_size); }
+
+int unsynchronized_pool_resource::__pool_index(size_t bytes, size_t align) const {
+  if (align > alignof(std::max_align_t) || bytes > (size_t(1) << __num_fixed_pools_))
+    return __num_fixed_pools_;
+  else {
+    int i = 0;
+    bytes = (bytes > align) ? bytes : align;
+    bytes -= 1;
+    bytes >>= __log2_smallest_block_size;
+    while (bytes != 0) {
+      bytes >>= 1;
+      i += 1;
+    }
+    return i;
+  }
+}
+
+unsynchronized_pool_resource::unsynchronized_pool_resource(const pool_options& opts, memory_resource* upstream)
+    : __res_(upstream), __fixed_pools_(nullptr) {
+  size_t largest_block_size;
+  if (opts.largest_required_pool_block == 0)
+    largest_block_size = __default_largest_block_size;
+  else if (opts.largest_required_pool_block < __smallest_block_size)
+    largest_block_size = __smallest_block_size;
+  else if (opts.largest_required_pool_block > __max_largest_block_size)
+    largest_block_size = __max_largest_block_size;
+  else
+    largest_block_size = opts.largest_required_pool_block;
+
+  if (opts.max_blocks_per_chunk == 0)
+    __options_max_blocks_per_chunk_ = __max_blocks_per_chunk;
+  else if (opts.max_blocks_per_chunk < __min_blocks_per_chunk)
+    __options_max_blocks_per_chunk_ = __min_blocks_per_chunk;
+  else if (opts.max_blocks_per_chunk > __max_blocks_per_chunk)
+    __options_max_blocks_per_chunk_ = __max_blocks_per_chunk;
+  else
+    __options_max_blocks_per_chunk_ = opts.max_blocks_per_chunk;
+
+  __num_fixed_pools_ = 1;
+  size_t capacity    = __smallest_block_size;
+  while (capacity < largest_block_size) {
+    capacity <<= 1;
+    __num_fixed_pools_ += 1;
+  }
+}
+
+pool_options unsynchronized_pool_resource::options() const {
+  pool_options p;
+  p.max_blocks_per_chunk        = __options_max_blocks_per_chunk_;
+  p.largest_required_pool_block = __pool_block_size(__num_fixed_pools_ - 1);
+  return p;
+}
+
+void unsynchronized_pool_resource::release() {
+  __adhoc_pool_.__release_ptr(__res_);
+  if (__fixed_pools_ != nullptr) {
+    const int n = __num_fixed_pools_;
+    for (int i = 0; i < n; ++i)
+      __fixed_pools_[i].__release_ptr(__res_);
+    __res_->deallocate(__fixed_pools_, __num_fixed_pools_ * sizeof(__fixed_pool), alignof(__fixed_pool));
+    __fixed_pools_ = nullptr;
+  }
+}
+
+void* unsynchronized_pool_resource::do_allocate(size_t bytes, size_t align) {
+  // A pointer to allocated storage (6.6.4.4.1) with a size of at least bytes.
+  // The size and alignment of the allocated memory shall meet the requirements for
+  // a class derived from memory_resource (23.12).
+  // If the pool selected for a block of size bytes is unable to satisfy the memory request
+  // from its own internal data structures, it will call upstream_resource()->allocate()
+  // to obtain more memory. If bytes is larger than that which the largest pool can handle,
+  // then memory will be allocated using upstream_resource()->allocate().
+
+  int i = __pool_index(bytes, align);
+  if (i == __num_fixed_pools_)
+    return __adhoc_pool_.__do_allocate(__res_, bytes, align);
+  else {
+    if (__fixed_pools_ == nullptr) {
+      __fixed_pools_ =
+          (__fixed_pool*)__res_->allocate(__num_fixed_pools_ * sizeof(__fixed_pool), alignof(__fixed_pool));
+      __fixed_pool* first = __fixed_pools_;
+      __fixed_pool* last  = __fixed_pools_ + __num_fixed_pools_;
+      for (__fixed_pool* pool = first; pool != last; ++pool)
+        ::new ((void*)pool) __fixed_pool;
+    }
+    void* result = __fixed_pools_[i].__try_allocate_from_vacancies();
+    if (result == nullptr) {
+      auto min = [](size_t a, size_t b) { return a < b ? a : b; };
+      auto max = [](size_t a, size_t b) { return a < b ? b : a; };
+
+      size_t prev_chunk_size_in_bytes  = __fixed_pools_[i].__previous_chunk_size_in_bytes();
+      size_t prev_chunk_size_in_blocks = prev_chunk_size_in_bytes >> __log2_pool_block_size(i);
+
+      size_t chunk_size_in_blocks;
+
+      if (prev_chunk_size_in_blocks == 0) {
+        size_t min_blocks_per_chunk = max(__min_bytes_per_chunk >> __log2_pool_block_size(i), __min_blocks_per_chunk);
+        chunk_size_in_blocks        = min_blocks_per_chunk;
+      } else {
+        static_assert(__max_bytes_per_chunk <= SIZE_MAX - (__max_bytes_per_chunk / 4), "unsigned overflow is possible");
+        chunk_size_in_blocks = prev_chunk_size_in_blocks + (prev_chunk_size_in_blocks / 4);
+      }
+
+      size_t max_blocks_per_chunk =
+          min((__max_bytes_per_chunk >> __log2_pool_block_size(i)),
+              min(__max_blocks_per_chunk, __options_max_blocks_per_chunk_));
+      if (chunk_size_in_blocks > max_blocks_per_chunk)
+        chunk_size_in_blocks = max_blocks_per_chunk;
+
+      size_t block_size = __pool_block_size(i);
+
+      size_t chunk_size_in_bytes = (chunk_size_in_blocks << __log2_pool_block_size(i));
+      result                     = __fixed_pools_[i].__allocate_in_new_chunk(__res_, block_size, chunk_size_in_bytes);
+    }
+    return result;
+  }
+}
+
+void unsynchronized_pool_resource::do_deallocate(void* p, size_t bytes, size_t align) {
+  // Returns the memory at p to the pool. It is unspecified if,
+  // or under what circumstances, this operation will result in
+  // a call to upstream_resource()->deallocate().
+
+  int i = __pool_index(bytes, align);
+  if (i == __num_fixed_pools_)
+    return __adhoc_pool_.__do_deallocate(__res_, p, bytes, align);
+  else {
+    _LIBCPP_ASSERT_NON_NULL(
+        __fixed_pools_ != nullptr, "deallocating a block that was not allocated with this allocator");
+    __fixed_pools_[i].__evacuate(p);
+  }
+}
+
+bool synchronized_pool_resource::do_is_equal(const memory_resource& other) const noexcept { return &other == this; }
+
+// 23.12.6, mem.res.monotonic.buffer
+
+static void* align_down(size_t align, size_t size, void*& ptr, size_t& space) {
+  if (size > space)
+    return nullptr;
+
+  char* p1      = static_cast<char*>(ptr);
+  char* new_ptr = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(p1 - size) & ~(align - 1));
+
+  if (new_ptr < (p1 - space))
+    return nullptr;
+
+  ptr = new_ptr;
+  space -= p1 - new_ptr;
+
+  return ptr;
+}
+
+void* monotonic_buffer_resource::__initial_descriptor::__try_allocate_from_chunk(size_t bytes, size_t align) {
+  if (!__cur_)
+    return nullptr;
+  void* new_ptr       = static_cast<void*>(__cur_);
+  size_t new_capacity = (__cur_ - __start_);
+  void* aligned_ptr   = align_down(align, bytes, new_ptr, new_capacity);
+  if (aligned_ptr != nullptr)
+    __cur_ = static_cast<char*>(new_ptr);
+  return aligned_ptr;
+}
+
+void* monotonic_buffer_resource::__chunk_footer::__try_allocate_from_chunk(size_t bytes, size_t align) {
+  void* new_ptr       = static_cast<void*>(__cur_);
+  size_t new_capacity = (__cur_ - __start_);
+  void* aligned_ptr   = align_down(align, bytes, new_ptr, new_capacity);
+  if (aligned_ptr != nullptr)
+    __cur_ = static_cast<char*>(new_ptr);
+  return aligned_ptr;
+}
+
+void* monotonic_buffer_resource::do_allocate(size_t bytes, size_t align) {
+  const size_t footer_size  = sizeof(__chunk_footer);
+  const size_t footer_align = alignof(__chunk_footer);
+
+  auto previous_allocation_size = [&]() {
+    if (__chunks_ != nullptr)
+      return __chunks_->__allocation_size();
+
+    size_t newsize = (__initial_.__start_ != nullptr) ? (__initial_.__end_ - __initial_.__start_) : __initial_.__size_;
+
+    return roundup(newsize, footer_align) + footer_size;
+  };
+
+  if (void* result = __initial_.__try_allocate_from_chunk(bytes, align))
+    return result;
+  if (__chunks_ != nullptr) {
+    if (void* result = __chunks_->__try_allocate_from_chunk(bytes, align))
+      return result;
+  }
+
+  // Allocate a brand-new chunk.
+
+  if (align < footer_align)
+    align = footer_align;
+
+  size_t aligned_capacity  = roundup(bytes, footer_align) + footer_size;
+  size_t previous_capacity = previous_allocation_size();
+
+  if (aligned_capacity <= previous_capacity) {
+    size_t newsize   = 2 * (previous_capacity - footer_size);
+    aligned_capacity = roundup(newsize, footer_align) + footer_size;
+  }
+
+  char* start            = (char*)__res_->allocate(aligned_capacity, align);
+  auto end               = start + aligned_capacity - footer_size;
+  __chunk_footer* footer = (__chunk_footer*)(end);
+  footer->__next_        = __chunks_;
+  footer->__start_       = start;
+  footer->__cur_         = end;
+  footer->__align_       = align;
+  __chunks_              = footer;
+
+  return __chunks_->__try_allocate_from_chunk(bytes, align);
+}
+
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/experimental/memory_resource_init_helper.h b/third_party/libcxx/memory_resource_init_helper.h
similarity index 100%
rename from third_party/libcxx/src/experimental/memory_resource_init_helper.h
rename to third_party/libcxx/memory_resource_init_helper.h
diff --git a/third_party/libcxx/module.modulemap b/third_party/libcxx/module.modulemap
deleted file mode 100644
index 9ace2d0a5..000000000
--- a/third_party/libcxx/module.modulemap
+++ /dev/null
@@ -1,1856 +0,0 @@
-// define the module for __config outside of the top level 'std' module
-// since __config may be included from C headers which may create an
-// include cycle.
-module std_config [system] [extern_c] {
-  textual header "__config"
-  export *
-}
-
-module std [system] {
-  // FIXME: The standard does not require that each of these submodules
-  // re-exports its imported modules. We should provide an alternative form of
-  // export that issues a warning if a name from the submodule is used, and
-  // use that to provide a 'strict mode' for libc++.
-
-  // Deprecated C-compatibility headers. These can all be included from within
-  // an 'extern "C"' context.
-  module depr [extern_c] {
-    // <assert.h> provided by C library.
-    module ctype_h {
-      header "ctype.h"
-      export *
-    }
-    module errno_h {
-      header "errno.h"
-      export *
-    }
-    module fenv_h {
-      header "fenv.h"
-      export *
-    }
-    // <float.h> provided by compiler or C library.
-    module inttypes_h {
-      header "inttypes.h"
-      export stdint_h
-      export *
-    }
-    // <iso646.h> provided by compiler.
-    // <limits.h> provided by compiler or C library.
-    module locale_h {
-      header "locale.h"
-      export *
-    }
-    module math_h {
-      header "math.h"
-      export *
-    }
-    module setjmp_h {
-      header "setjmp.h"
-      export *
-    }
-    module stdatomic_h {
-      requires cplusplus23
-      header "stdatomic.h"
-      export *
-    }
-    // FIXME: <stdalign.h> is missing.
-    // <signal.h> provided by C library.
-    // <stdarg.h> provided by compiler.
-    module stdbool_h {
-      // <stdbool.h>'s __bool_true_false_are_defined macro requires textual inclusion.
-      textual header "stdbool.h"
-      export *
-    }
-    module stddef_h {
-      // <stddef.h>'s __need_* macros require textual inclusion.
-      textual header "stddef.h"
-      export *
-    }
-    module stdint_h {
-      header "stdint.h"
-      export *
-      // FIXME: This module only exists on OS X and for some reason the
-      // wildcard above doesn't export it. Removing this breaks the tests
-      // for C compatibility headers in C++17 mode with modules enabled.
-      export Darwin.C.stdint
-    }
-    module stdio_h {
-      // <stdio.h>'s __need_* macros require textual inclusion.
-      textual header "stdio.h"
-      export *
-    }
-    module stdlib_h {
-      // <stdlib.h>'s __need_* macros require textual inclusion.
-      textual header "stdlib.h"
-      export *
-    }
-    module string_h {
-      header "string.h"
-      export *
-    }
-    module uchar_h {
-      header "uchar.h"
-      export *
-    }
-    // <time.h> provided by C library.
-    module wchar_h {
-      // <wchar.h>'s __need_* macros require textual inclusion.
-      textual header "wchar.h"
-      export *
-    }
-    module wctype_h {
-      header "wctype.h"
-      export *
-    }
-  }
-
-  // <complex.h> and <tgmath.h> are not C headers in any real sense, do not
-  // allow their use in extern "C" contexts.
-  module complex_h {
-    header "complex.h"
-    export ccomplex
-    export *
-  }
-  module tgmath_h {
-    header "tgmath.h"
-    export ccomplex
-    export cmath
-    export *
-  }
-
-  // C compatibility headers.
-  module compat {
-    module cassert {
-      // <cassert>'s use of NDEBUG requires textual inclusion.
-      textual header "cassert"
-    }
-    module ccomplex {
-      header "ccomplex"
-      export complex
-      export *
-    }
-    module cctype {
-      header "cctype"
-      export *
-    }
-    module cerrno {
-      header "cerrno"
-      export *
-    }
-    module cfenv {
-      header "cfenv"
-      export *
-    }
-    module cfloat {
-      header "cfloat"
-      export *
-    }
-    module cinttypes {
-      header "cinttypes"
-      export cstdint
-      export *
-    }
-    module ciso646 {
-      header "ciso646"
-      export *
-    }
-    module climits {
-      header "climits"
-      export *
-    }
-    module clocale {
-      header "clocale"
-      export *
-    }
-    module cmath {
-      header "cmath"
-      export *
-    }
-    module csetjmp {
-      header "csetjmp"
-      export *
-    }
-    module csignal {
-      header "csignal"
-      export *
-    }
-    // FIXME: <cstdalign> is missing.
-    module cstdarg {
-      header "cstdarg"
-      export *
-    }
-    module cstdbool {
-      header "cstdbool"
-      export *
-    }
-    module cstddef {
-      header "cstddef"
-      export *
-    }
-    module cstdint {
-      header "cstdint"
-      export depr.stdint_h
-      export *
-    }
-    module cstdio {
-      header "cstdio"
-      export *
-    }
-    module cstdlib {
-      header "cstdlib"
-      export *
-    }
-    module cstring {
-      header "cstring"
-      export *
-    }
-    module ctgmath {
-      header "ctgmath"
-      export ccomplex
-      export cmath
-      export *
-    }
-    module ctime {
-      header "ctime"
-      export *
-    }
-    module cuchar {
-      header "cuchar"
-      export *
-    }
-    module cwchar {
-      header "cwchar"
-      export depr.stdio_h
-      export *
-    }
-    module cwctype {
-      header "cwctype"
-      export *
-    }
-  }
-
-  module algorithm {
-    header "algorithm"
-    export initializer_list
-    export *
-
-    module __algorithm {
-      module adjacent_find                   { private header "__algorithm/adjacent_find.h" }
-      module all_of                          { private header "__algorithm/all_of.h" }
-      module any_of                          { private header "__algorithm/any_of.h" }
-      module binary_search                   { private header "__algorithm/binary_search.h" }
-      module clamp                           { private header "__algorithm/clamp.h" }
-      module comp                            { private header "__algorithm/comp.h" }
-      module comp_ref_type                   { private header "__algorithm/comp_ref_type.h" }
-      module copy                            { private header "__algorithm/copy.h" }
-      module copy_backward                   { private header "__algorithm/copy_backward.h" }
-      module copy_if                         { private header "__algorithm/copy_if.h" }
-      module copy_move_common                { private header "__algorithm/copy_move_common.h" }
-      module copy_n                          { private header "__algorithm/copy_n.h" }
-      module count                           { private header "__algorithm/count.h" }
-      module count_if                        { private header "__algorithm/count_if.h" }
-      module equal                           { private header "__algorithm/equal.h" }
-      module equal_range                     { private header "__algorithm/equal_range.h" }
-      module fill                            { private header "__algorithm/fill.h" }
-      module fill_n                          { private header "__algorithm/fill_n.h" }
-      module find                            { private header "__algorithm/find.h" }
-      module find_end                        { private header "__algorithm/find_end.h" }
-      module find_first_of                   { private header "__algorithm/find_first_of.h" }
-      module find_if                         { private header "__algorithm/find_if.h" }
-      module find_if_not                     { private header "__algorithm/find_if_not.h" }
-      module for_each                        { private header "__algorithm/for_each.h" }
-      module for_each_n                      { private header "__algorithm/for_each_n.h" }
-      module for_each_segment                { private header "__algorithm/for_each_segment.h" }
-      module generate                        { private header "__algorithm/generate.h" }
-      module generate_n                      { private header "__algorithm/generate_n.h" }
-      module half_positive                   { private header "__algorithm/half_positive.h" }
-      module in_found_result                 { private header "__algorithm/in_found_result.h" }
-      module in_fun_result                   { private header "__algorithm/in_fun_result.h" }
-      module in_in_out_result                { private header "__algorithm/in_in_out_result.h" }
-      module in_in_result                    { private header "__algorithm/in_in_result.h" }
-      module in_out_out_result               { private header "__algorithm/in_out_out_result.h" }
-      module in_out_result                   { private header "__algorithm/in_out_result.h" }
-      module includes                        { private header "__algorithm/includes.h" }
-      module inplace_merge                   { private header "__algorithm/inplace_merge.h" }
-      module is_heap                         { private header "__algorithm/is_heap.h" }
-      module is_heap_until                   { private header "__algorithm/is_heap_until.h" }
-      module is_partitioned                  { private header "__algorithm/is_partitioned.h" }
-      module is_permutation                  { private header "__algorithm/is_permutation.h" }
-      module is_sorted                       { private header "__algorithm/is_sorted.h" }
-      module is_sorted_until                 { private header "__algorithm/is_sorted_until.h" }
-      module iter_swap                       { private header "__algorithm/iter_swap.h" }
-      module iterator_operations             {
-        private header "__algorithm/iterator_operations.h"
-        export *
-      }
-      module lexicographical_compare         { private header "__algorithm/lexicographical_compare.h" }
-      module lexicographical_compare_three_way {
-        private header "__algorithm/lexicographical_compare_three_way.h"
-      }
-      module lower_bound                     { private header "__algorithm/lower_bound.h" }
-      module make_heap                       { private header "__algorithm/make_heap.h" }
-      module make_projected                  { private header "__algorithm/make_projected.h" }
-      module max                             { private header "__algorithm/max.h" }
-      module max_element                     { private header "__algorithm/max_element.h" }
-      module merge                           { private header "__algorithm/merge.h" }
-      module min                             { private header "__algorithm/min.h" }
-      module min_element                     { private header "__algorithm/min_element.h" }
-      module min_max_result                  { private header "__algorithm/min_max_result.h" }
-      module minmax                          {
-        private header "__algorithm/minmax.h"
-        export *
-      }
-      module minmax_element                  { private header "__algorithm/minmax_element.h" }
-      module mismatch                        { private header "__algorithm/mismatch.h" }
-      module move                            { private header "__algorithm/move.h" }
-      module move_backward                   { private header "__algorithm/move_backward.h" }
-      module next_permutation                { private header "__algorithm/next_permutation.h" }
-      module none_of                         { private header "__algorithm/none_of.h" }
-      module nth_element                     { private header "__algorithm/nth_element.h" }
-      module partial_sort                    { private header "__algorithm/partial_sort.h" }
-      module partial_sort_copy               { private header "__algorithm/partial_sort_copy.h" }
-      module partition                       { private header "__algorithm/partition.h" }
-      module partition_copy                  { private header "__algorithm/partition_copy.h" }
-      module partition_point                 { private header "__algorithm/partition_point.h" }
-      module pop_heap                        { private header "__algorithm/pop_heap.h" }
-      module prev_permutation                { private header "__algorithm/prev_permutation.h" }
-      module pstl_backends_cpu_backend       {
-        private header "__algorithm/pstl_backends/cpu_backend.h"
-        export *
-      }
-      module pstl_backends_cpu_backends_any_of {
-        private header "__algorithm/pstl_backends/cpu_backends/any_of.h"
-      }
-      module pstl_backends_cpu_backends_backend {
-        private header "__algorithm/pstl_backends/cpu_backends/backend.h"
-        export *
-      }
-      module pstl_backends_cpu_backends_fill { private header "__algorithm/pstl_backends/cpu_backends/fill.h" }
-      module pstl_backends_cpu_backends_find_if {
-        private header "__algorithm/pstl_backends/cpu_backends/find_if.h"
-      }
-      module pstl_backends_cpu_backends_for_each {
-        private header "__algorithm/pstl_backends/cpu_backends/for_each.h"
-      }
-      module pstl_backends_cpu_backends_merge {
-        private header "__algorithm/pstl_backends/cpu_backends/merge.h"
-      }
-      module pstl_backends_cpu_backends_serial {
-        private header "__algorithm/pstl_backends/cpu_backends/serial.h"
-      }
-      module pstl_backends_cpu_backends_thread {
-        private header "__algorithm/pstl_backends/cpu_backends/thread.h"
-      }
-      module pstl_backends_cpu_backends_transform {
-        private header "__algorithm/pstl_backends/cpu_backends/transform.h"
-      }
-      module push_heap                       { private header "__algorithm/push_heap.h" }
-      module ranges_adjacent_find            { private header "__algorithm/ranges_adjacent_find.h" }
-      module ranges_all_of                   { private header "__algorithm/ranges_all_of.h" }
-      module ranges_any_of                   { private header "__algorithm/ranges_any_of.h" }
-      module ranges_binary_search {
-        private header "__algorithm/ranges_binary_search.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_clamp {
-        private header "__algorithm/ranges_clamp.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_copy {
-        private header "__algorithm/ranges_copy.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_copy_backward {
-        private header "__algorithm/ranges_copy_backward.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_copy_if {
-        private header "__algorithm/ranges_copy_if.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_copy_n {
-        private header "__algorithm/ranges_copy_n.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_count                    { private header "__algorithm/ranges_count.h" }
-      module ranges_count_if                 { private header "__algorithm/ranges_count_if.h" }
-      module ranges_equal                    { private header "__algorithm/ranges_equal.h" }
-      module ranges_equal_range {
-        private header "__algorithm/ranges_equal_range.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_fill                     { private header "__algorithm/ranges_fill.h" }
-      module ranges_fill_n                   { private header "__algorithm/ranges_fill_n.h" }
-      module ranges_find                     { private header "__algorithm/ranges_find.h" }
-      module ranges_find_end                 { private header "__algorithm/ranges_find_end.h" }
-      module ranges_find_first_of            { private header "__algorithm/ranges_find_first_of.h" }
-      module ranges_find_if                  { private header "__algorithm/ranges_find_if.h" }
-      module ranges_find_if_not              { private header "__algorithm/ranges_find_if_not.h" }
-      module ranges_for_each {
-        private header "__algorithm/ranges_for_each.h"
-        export algorithm.__algorithm.in_fun_result
-      }
-      module ranges_for_each_n {
-        private header "__algorithm/ranges_for_each_n.h"
-        export algorithm.__algorithm.in_fun_result
-      }
-      module ranges_generate                 { private header "__algorithm/ranges_generate.h" }
-      module ranges_generate_n               { private header "__algorithm/ranges_generate_n.h" }
-      module ranges_includes {
-        private header "__algorithm/ranges_includes.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_inplace_merge {
-        private header "__algorithm/ranges_inplace_merge.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_is_heap {
-        private header "__algorithm/ranges_is_heap.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_is_heap_until {
-        private header "__algorithm/ranges_is_heap_until.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_is_partitioned           { private header "__algorithm/ranges_is_partitioned.h" }
-      module ranges_is_permutation           { private header "__algorithm/ranges_is_permutation.h" }
-      module ranges_is_sorted {
-        private header "__algorithm/ranges_is_sorted.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_is_sorted_until {
-        private header "__algorithm/ranges_is_sorted_until.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_iterator_concept         { private header "__algorithm/ranges_iterator_concept.h" }
-      module ranges_lexicographical_compare {
-        private header "__algorithm/ranges_lexicographical_compare.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_lower_bound {
-        private header "__algorithm/ranges_lower_bound.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_make_heap {
-        private header "__algorithm/ranges_make_heap.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_max {
-        private header "__algorithm/ranges_max.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_max_element {
-        private header "__algorithm/ranges_max_element.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_merge {
-        private header "__algorithm/ranges_merge.h"
-        export algorithm.__algorithm.in_in_out_result
-      }
-      module ranges_min {
-        private header "__algorithm/ranges_min.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_min_element {
-        private header "__algorithm/ranges_min_element.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_minmax {
-        private header "__algorithm/ranges_minmax.h"
-        export functional.__functional.ranges_operations
-        export algorithm.__algorithm.min_max_result
-      }
-      module ranges_minmax_element {
-        private header "__algorithm/ranges_minmax_element.h"
-        export functional.__functional.ranges_operations
-        export algorithm.__algorithm.min_max_result
-      }
-      module ranges_mismatch {
-        private header "__algorithm/ranges_mismatch.h"
-        export algorithm.__algorithm.in_in_result
-      }
-      module ranges_move {
-        private header "__algorithm/ranges_move.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_move_backward {
-        private header "__algorithm/ranges_move_backward.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_next_permutation {
-        private header "__algorithm/ranges_next_permutation.h"
-        export algorithm.__algorithm.in_found_result
-        export functional.__functional.ranges_operations
-      }
-      module ranges_none_of                  { private header "__algorithm/ranges_none_of.h" }
-      module ranges_nth_element {
-        private header "__algorithm/ranges_nth_element.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_partial_sort {
-        private header "__algorithm/ranges_partial_sort.h"
-        export algorithm.__algorithm.in_out_result
-        export functional.__functional.ranges_operations
-      }
-      module ranges_partial_sort_copy {
-        private header "__algorithm/ranges_partial_sort_copy.h"
-        export algorithm.__algorithm.in_out_out_result
-        export functional.__functional.ranges_operations
-      }
-      module ranges_partition                { private header "__algorithm/ranges_partition.h" }
-      module ranges_partition_copy           { private header "__algorithm/ranges_partition_copy.h" }
-      module ranges_partition_point          { private header "__algorithm/ranges_partition_point.h" }
-      module ranges_pop_heap {
-        private header "__algorithm/ranges_pop_heap.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_prev_permutation {
-        private header "__algorithm/ranges_prev_permutation.h"
-        export algorithm.__algorithm.in_found_result
-        export functional.__functional.ranges_operations
-      }
-      module ranges_push_heap {
-        private header "__algorithm/ranges_push_heap.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_remove                   { private header "__algorithm/ranges_remove.h" }
-      module ranges_remove_copy {
-        private header "__algorithm/ranges_remove_copy.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_remove_copy_if {
-        private header "__algorithm/ranges_remove_copy_if.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_remove_if                { private header "__algorithm/ranges_remove_if.h" }
-      module ranges_replace                  { private header "__algorithm/ranges_replace.h" }
-      module ranges_replace_copy {
-        private header "__algorithm/ranges_replace_copy.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_replace_copy_if {
-        private header "__algorithm/ranges_replace_copy_if.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_replace_if               { private header "__algorithm/ranges_replace_if.h" }
-      module ranges_reverse                  { private header "__algorithm/ranges_reverse.h" }
-      module ranges_reverse_copy {
-        private header "__algorithm/ranges_reverse_copy.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_rotate                   { private header "__algorithm/ranges_rotate.h" }
-      module ranges_rotate_copy {
-        private header "__algorithm/ranges_rotate_copy.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_sample                   { private header "__algorithm/ranges_sample.h" }
-      module ranges_search                   { private header "__algorithm/ranges_search.h" }
-      module ranges_search_n                 { private header "__algorithm/ranges_search_n.h" }
-      module ranges_set_difference {
-        private header "__algorithm/ranges_set_difference.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_set_intersection {
-        private header "__algorithm/ranges_set_intersection.h"
-        export algorithm.__algorithm.in_in_out_result
-      }
-      module ranges_set_symmetric_difference {
-        private header "__algorithm/ranges_set_symmetric_difference.h"
-        export algorithm.__algorithm.in_in_out_result
-        export functional.__functional.ranges_operations
-      }
-      module ranges_set_union {
-        private header "__algorithm/ranges_set_union.h"
-        export algorithm.__algorithm.in_in_out_result
-        export functional.__functional.ranges_operations
-      }
-      module ranges_shuffle                  { private header "__algorithm/ranges_shuffle.h" }
-      module ranges_sort {
-        private header "__algorithm/ranges_sort.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_sort_heap {
-        private header "__algorithm/ranges_sort_heap.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_stable_partition         { private header "__algorithm/ranges_stable_partition.h" }
-      module ranges_stable_sort {
-        private header "__algorithm/ranges_stable_sort.h"
-        export functional.__functional.ranges_operations
-      }
-      module ranges_starts_with         { private header "__algorithm/ranges_starts_with.h" }
-      module ranges_swap_ranges {
-        private header "__algorithm/ranges_swap_ranges.h"
-        export algorithm.__algorithm.in_in_result
-      }
-      module ranges_transform {
-        private header "__algorithm/ranges_transform.h"
-        export algorithm.__algorithm.in_in_out_result
-        export algorithm.__algorithm.in_out_result
-      }
-      module uniform_random_bit_generator_adaptor {
-        private header "__algorithm/uniform_random_bit_generator_adaptor.h"
-      }
-      module ranges_unique                   { private header "__algorithm/ranges_unique.h" }
-      module ranges_unique_copy {
-        private header "__algorithm/ranges_unique_copy.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module ranges_upper_bound {
-        private header "__algorithm/ranges_upper_bound.h"
-        export functional.__functional.ranges_operations
-      }
-      module remove                          { private header "__algorithm/remove.h" }
-      module remove_copy                     { private header "__algorithm/remove_copy.h" }
-      module remove_copy_if                  { private header "__algorithm/remove_copy_if.h" }
-      module remove_if                       { private header "__algorithm/remove_if.h" }
-      module replace                         { private header "__algorithm/replace.h" }
-      module replace_copy                    { private header "__algorithm/replace_copy.h" }
-      module replace_copy_if                 { private header "__algorithm/replace_copy_if.h" }
-      module replace_if                      { private header "__algorithm/replace_if.h" }
-      module reverse                         { private header "__algorithm/reverse.h" }
-      module reverse_copy                    { private header "__algorithm/reverse_copy.h" }
-      module rotate                          { private header "__algorithm/rotate.h" }
-      module rotate_copy                     { private header "__algorithm/rotate_copy.h" }
-      module sample                          { private header "__algorithm/sample.h" }
-      module search                          { private header "__algorithm/search.h" }
-      module search_n                        { private header "__algorithm/search_n.h" }
-      module set_difference                  { private header "__algorithm/set_difference.h" }
-      module set_intersection                { private header "__algorithm/set_intersection.h" }
-      module set_symmetric_difference        { private header "__algorithm/set_symmetric_difference.h" }
-      module set_union                       { private header "__algorithm/set_union.h" }
-      module shift_left                      { private header "__algorithm/shift_left.h" }
-      module shift_right                     { private header "__algorithm/shift_right.h" }
-      module shuffle                         { private header "__algorithm/shuffle.h" }
-      module sift_down                       { private header "__algorithm/sift_down.h" }
-      module sort                            { private header "__algorithm/sort.h" }
-      module sort_heap                       { private header "__algorithm/sort_heap.h" }
-      module stable_partition                { private header "__algorithm/stable_partition.h" }
-      module stable_sort                     { private header "__algorithm/stable_sort.h" }
-      module swap_ranges                     { private header "__algorithm/swap_ranges.h" }
-      module three_way_comp_ref_type         { private header "__algorithm/three_way_comp_ref_type.h" }
-      module transform                       { private header "__algorithm/transform.h" }
-      module unique                          { private header "__algorithm/unique.h" }
-      module unique_copy                     { private header "__algorithm/unique_copy.h" }
-      module unwrap_iter                     { private header "__algorithm/unwrap_iter.h" }
-      module unwrap_range {
-        private header "__algorithm/unwrap_range.h"
-        export utility.__utility.pair
-      }
-      module upper_bound                     { private header "__algorithm/upper_bound.h" }
-    }
-  }
-  module any {
-    header "any"
-    export *
-  }
-  module array {
-    header "array"
-    export initializer_list
-    export *
-
-    module array_fwd { private header "__fwd/array.h" }
-  }
-  module atomic {
-    header "atomic"
-    export *
-
-    module __atomic {
-      module aliases             {
-        private header "__atomic/aliases.h"
-        export atomic
-      }
-      module atomic              {
-        private header "__atomic/atomic.h"
-
-        export atomic_base
-      }
-      module atomic_base         { private header "__atomic/atomic_base.h" }
-      module atomic_flag         { private header "__atomic/atomic_flag.h" }
-      module atomic_init         { private header "__atomic/atomic_init.h" }
-      module atomic_lock_free    { private header "__atomic/atomic_lock_free.h" }
-      module atomic_sync         { private header "__atomic/atomic_sync.h" }
-      module check_memory_order  { private header "__atomic/check_memory_order.h" }
-      module contention_t        { private header "__atomic/contention_t.h" }
-      module cxx_atomic_impl     { private header "__atomic/cxx_atomic_impl.h" }
-      module fence               { private header "__atomic/fence.h" }
-      module is_always_lock_free { private header "__atomic/is_always_lock_free.h" }
-      module kill_dependency     { private header "__atomic/kill_dependency.h" }
-      module memory_order        { private header "__atomic/memory_order.h" }
-    }
-  }
-  module barrier {
-    header "barrier"
-    export *
-  }
-  module bit {
-    header "bit"
-    export *
-
-    module __bit {
-      module bit_cast       { private header "__bit/bit_cast.h" }
-      module bit_ceil       { private header "__bit/bit_ceil.h" }
-      module bit_floor      { private header "__bit/bit_floor.h" }
-      module bit_log2       { private header "__bit/bit_log2.h" }
-      module bit_width      { private header "__bit/bit_width.h" }
-      module blsr           { private header "__bit/blsr.h" }
-      module byteswap       { private header "__bit/byteswap.h" }
-      module countl         { private header "__bit/countl.h" }
-      module countr         { private header "__bit/countr.h" }
-      module endian         { private header "__bit/endian.h" }
-      module has_single_bit { private header "__bit/has_single_bit.h" }
-      module popcount       { private header "__bit/popcount.h" }
-      module rotate         { private header "__bit/rotate.h" }
-    }
-  }
-  module bitset {
-    header "bitset"
-    export string
-    export iosfwd
-    export *
-  }
-  // No submodule for cassert. It fundamentally needs repeated, textual inclusion.
-  module charconv {
-    header "charconv"
-    export *
-
-    module __charconv {
-      module chars_format            { private header "__charconv/chars_format.h" }
-      module from_chars_integral     { private header "__charconv/from_chars_integral.h" }
-      module from_chars_result       { private header "__charconv/from_chars_result.h" }
-      module tables                  { private header "__charconv/tables.h" }
-      module to_chars                { private header "__charconv/to_chars.h" }
-      module to_chars_base_10        { private header "__charconv/to_chars_base_10.h" }
-      module to_chars_floating_point { private header "__charconv/to_chars_floating_point.h" }
-      module to_chars_integral       { private header "__charconv/to_chars_integral.h" }
-      module to_chars_result         { private header "__charconv/to_chars_result.h" }
-      module traits                  { private header "__charconv/traits.h" }
-    }
-
-  }
-  module chrono {
-    header "chrono"
-    export *
-
-    module __chrono {
-      module calendar               { private header "__chrono/calendar.h" }
-      module concepts               { private header "__chrono/concepts.h" }
-      module convert_to_timespec    { private header "__chrono/convert_to_timespec.h" }
-      module convert_to_tm          { private header "__chrono/convert_to_tm.h" }
-      module day                    { private header "__chrono/day.h" }
-      module duration               { private header "__chrono/duration.h" }
-      module file_clock             { private header "__chrono/file_clock.h" }
-      module formatter              {
-          private header "__chrono/formatter.h"
-      }
-      module hh_mm_ss               { private header "__chrono/hh_mm_ss.h" }
-      module high_resolution_clock  {
-        private header "__chrono/high_resolution_clock.h"
-        export steady_clock
-        export system_clock
-        export time_point
-      }
-      module literals               { private header "__chrono/literals.h" }
-      module month                  { private header "__chrono/month.h" }
-      module month_weekday          { private header "__chrono/month_weekday.h" }
-      module monthday               { private header "__chrono/monthday.h" }
-      module ostream                {
-          private header "__chrono/ostream.h"
-      }
-      module parser_std_format_spec {
-          private header "__chrono/parser_std_format_spec.h"
-      }
-      module statically_widen       { private header "__chrono/statically_widen.h" }
-      module steady_clock           { private header "__chrono/steady_clock.h" }
-      module system_clock           { private header "__chrono/system_clock.h" }
-      module time_point             { private header "__chrono/time_point.h" }
-      module weekday                { private header "__chrono/weekday.h" }
-      module year                   { private header "__chrono/year.h" }
-      module year_month             { private header "__chrono/year_month.h" }
-      module year_month_day         { private header "__chrono/year_month_day.h" }
-      module year_month_weekday     { private header "__chrono/year_month_weekday.h" }
-    }
-  }
-  module codecvt {
-    header "codecvt"
-    export *
-  }
-  module compare {
-    header "compare"
-    export *
-
-    module __compare {
-      module common_comparison_category     { private header "__compare/common_comparison_category.h" }
-      module compare_partial_order_fallback { private header "__compare/compare_partial_order_fallback.h" }
-      module compare_strong_order_fallback  { private header "__compare/compare_strong_order_fallback.h" }
-      module compare_three_way              { private header "__compare/compare_three_way.h" }
-      module compare_three_way_result       { private header "__compare/compare_three_way_result.h" }
-      module compare_weak_order_fallback    { private header "__compare/compare_weak_order_fallback.h" }
-      module is_eq                          { private header "__compare/is_eq.h" }
-      module ordering                       { private header "__compare/ordering.h" }
-      module partial_order                  { private header "__compare/partial_order.h" }
-      module strong_order                   { private header "__compare/strong_order.h" }
-      module synth_three_way                { private header "__compare/synth_three_way.h" }
-      module three_way_comparable           { private header "__compare/three_way_comparable.h" }
-      module weak_order                     { private header "__compare/weak_order.h" }
-    }
-  }
-  module complex {
-    header "complex"
-    export *
-  }
-  module concepts {
-    header "concepts"
-    export *
-
-    module __concepts {
-      module arithmetic                 { private header "__concepts/arithmetic.h" }
-      module assignable                 { private header "__concepts/assignable.h" }
-      module boolean_testable           { private header "__concepts/boolean_testable.h" }
-      module class_or_enum              { private header "__concepts/class_or_enum.h" }
-      module common_reference_with      { private header "__concepts/common_reference_with.h" }
-      module common_with                { private header "__concepts/common_with.h" }
-      module constructible              { private header "__concepts/constructible.h" }
-      module convertible_to             { private header "__concepts/convertible_to.h" }
-      module copyable                   { private header "__concepts/copyable.h" }
-      module derived_from               { private header "__concepts/derived_from.h" }
-      module destructible               { private header "__concepts/destructible.h" }
-      module different_from             { private header "__concepts/different_from.h" }
-      module equality_comparable {
-        private header "__concepts/equality_comparable.h"
-        export type_traits.common_reference
-      }
-      module invocable                  { private header "__concepts/invocable.h" }
-      module movable                    { private header "__concepts/movable.h" }
-      module predicate                  { private header "__concepts/predicate.h" }
-      module regular                    { private header "__concepts/regular.h" }
-      module relation                   { private header "__concepts/relation.h" }
-      module same_as {
-        private header "__concepts/same_as.h"
-        export type_traits.is_same
-      }
-      module semiregular                { private header "__concepts/semiregular.h" }
-      module swappable                  { private header "__concepts/swappable.h" }
-      module totally_ordered            { private header "__concepts/totally_ordered.h" }
-    }
-  }
-  module condition_variable {
-    header "condition_variable"
-    export *
-
-    module __condition_variable {
-      module condition_variable { private header "__condition_variable/condition_variable.h" }
-    }
-  }
-  module deque {
-    header "deque"
-    export initializer_list
-    export *
-  }
-  module exception {
-    header "exception"
-    export *
-
-    module __exception {
-      module exception        { private header "__exception/exception.h" }
-      module exception_ptr    { private header "__exception/exception_ptr.h" }
-      module nested_exception { private header "__exception/nested_exception.h" }
-      module operations       { private header "__exception/operations.h" }
-      module terminate        { private header "__exception/terminate.h" }
-    }
-  }
-  module execution {
-    header "execution"
-    export *
-  }
-  module expected {
-    header "expected"
-    export *
-
-    module __expected {
-      module bad_expected_access          { private header "__expected/bad_expected_access.h" }
-      module expected                     { private header "__expected/expected.h" }
-      module unexpect                     { private header "__expected/unexpect.h" }
-      module unexpected                   { private header "__expected/unexpected.h" }
-    }
-  }
-  module filesystem {
-    header "filesystem"
-    export *
-
-    module __filesystem {
-      module copy_options                 { private header "__filesystem/copy_options.h" }
-      module directory_entry              { private header "__filesystem/directory_entry.h" }
-      module directory_iterator           { private header "__filesystem/directory_iterator.h" }
-      module directory_options            { private header "__filesystem/directory_options.h" }
-      module file_status                  { private header "__filesystem/file_status.h" }
-      module file_time_type               { private header "__filesystem/file_time_type.h" }
-      module file_type                    { private header "__filesystem/file_type.h" }
-      module filesystem_error             { private header "__filesystem/filesystem_error.h" }
-      module operations                   { private header "__filesystem/operations.h" }
-      module path                         {
-        private header "__filesystem/path.h"
-        export functional.__functional.hash
-        export functional.__functional.unary_function
-      }
-      module path_iterator                { private header "__filesystem/path_iterator.h" }
-      module perm_options                 { private header "__filesystem/perm_options.h" }
-      module perms                        { private header "__filesystem/perms.h" }
-      module recursive_directory_iterator { private header "__filesystem/recursive_directory_iterator.h" }
-      module space_info                   { private header "__filesystem/space_info.h" }
-      module u8path                       { private header "__filesystem/u8path.h" }
-    }
-  }
-  module format {
-    header "format"
-    export *
-
-    module __format {
-      module buffer                          { private header "__format/buffer.h" }
-      module concepts                        { private header "__format/concepts.h" }
-      module container_adaptor               { private header "__format/container_adaptor.h" }
-      module enable_insertable               { private header "__format/enable_insertable.h" }
-      module escaped_output_table            { private header "__format/escaped_output_table.h" }
-      module extended_grapheme_cluster_table { private header "__format/extended_grapheme_cluster_table.h" }
-      module format_arg                      { private header "__format/format_arg.h" }
-      module format_arg_store                { private header "__format/format_arg_store.h" }
-      module format_args                     { private header "__format/format_args.h" }
-      module format_context {
-        private header "__format/format_context.h"
-        export optional
-        export locale
-        export __locale
-      }
-      module format_error                    { private header "__format/format_error.h" }
-      module format_functions                {
-        private header "__format/format_functions.h"
-        export string
-      }
-      module format_fwd                      { private header "__format/format_fwd.h" }
-      module format_parse_context            { private header "__format/format_parse_context.h" }
-      module format_string                   { private header "__format/format_string.h" }
-      module format_to_n_result {
-        private header "__format/format_to_n_result.h"
-        export iterator.__iterator.incrementable_traits
-      }
-      module formatter                       { private header "__format/formatter.h" }
-      module formatter_bool                  { private header "__format/formatter_bool.h" }
-      module formatter_char                  { private header "__format/formatter_char.h" }
-      module formatter_floating_point        { private header "__format/formatter_floating_point.h" }
-      module formatter_integer               { private header "__format/formatter_integer.h" }
-      module formatter_integral              { private header "__format/formatter_integral.h" }
-      module formatter_output                { private header "__format/formatter_output.h" }
-      module formatter_pointer               { private header "__format/formatter_pointer.h" }
-      module formatter_string                { private header "__format/formatter_string.h" }
-      module formatter_tuple                 { private header "__format/formatter_tuple.h" }
-      module parser_std_format_spec          { private header "__format/parser_std_format_spec.h" }
-      module range_default_formatter         { private header "__format/range_default_formatter.h" }
-      module range_formatter                 { private header "__format/range_formatter.h" }
-      module unicode                         { private header "__format/unicode.h" }
-      module width_estimation_table          { private header "__format/width_estimation_table.h" }
-    }
-  }
-  module forward_list {
-    header "forward_list"
-    export initializer_list
-    export *
-  }
-  module fstream {
-    header "fstream"
-    export *
-  }
-  module functional {
-    header "functional"
-    // the contents of __type_traits/unwrap_ref.h should be available from functional too.
-    export type_traits.unwrap_ref
-    export *
-
-    module __functional {
-      module binary_function            { private header "__functional/binary_function.h" }
-      module binary_negate              { private header "__functional/binary_negate.h" }
-      module bind                       { private header "__functional/bind.h" }
-      module bind_back                  { private header "__functional/bind_back.h" }
-      module bind_front                 { private header "__functional/bind_front.h" }
-      module binder1st                  { private header "__functional/binder1st.h" }
-      module binder2nd                  { private header "__functional/binder2nd.h" }
-      module boyer_moore_searcher       { private header "__functional/boyer_moore_searcher.h" }
-      module compose                    { private header "__functional/compose.h" }
-      module default_searcher           { private header "__functional/default_searcher.h" }
-      module function                   { private header "__functional/function.h" }
-      module hash                       { private header "__functional/hash.h" }
-      module hash_fwd                   { private header "__fwd/hash.h" }
-      module identity                   { private header "__functional/identity.h" }
-      module invoke                     {
-        private header "__functional/invoke.h"
-        export type_traits
-      }
-      module is_transparent             { private header "__functional/is_transparent.h" }
-      module mem_fn                     { private header "__functional/mem_fn.h" }
-      module mem_fun_ref                { private header "__functional/mem_fun_ref.h" }
-      module not_fn                     { private header "__functional/not_fn.h" }
-      module operations                 { private header "__functional/operations.h" }
-      module perfect_forward            { private header "__functional/perfect_forward.h" }
-      module pointer_to_binary_function { private header "__functional/pointer_to_binary_function.h" }
-      module pointer_to_unary_function  { private header "__functional/pointer_to_unary_function.h" }
-      module ranges_operations          { private header "__functional/ranges_operations.h" }
-      module reference_wrapper          { private header "__functional/reference_wrapper.h" }
-      module unary_function             { private header "__functional/unary_function.h" }
-      module unary_negate               { private header "__functional/unary_negate.h" }
-      module weak_result_type           { private header "__functional/weak_result_type.h" }
-    }
-  }
-  module future {
-    header "future"
-    export *
-  }
-  module initializer_list {
-    header "initializer_list"
-    export *
-  }
-  module iomanip {
-    header "iomanip"
-    export *
-  }
-  module ios {
-    header "ios"
-    export iosfwd
-    export *
-
-    module __ios {
-      module fpos { private header "__ios/fpos.h" }
-    }
-  }
-  module iosfwd {
-    header "iosfwd"
-    export *
-    module __iosfwd {
-      module fstream_fwd   { private header "__fwd/fstream.h" }
-      module ios_fwd       { private header "__fwd/ios.h" }
-      module istream_fwd   { private header "__fwd/istream.h" }
-      module ostream_fwd   { private header "__fwd/ostream.h" }
-      module sstream_fwd   { private header "__fwd/sstream.h" }
-      module streambuf_fwd { private header "__fwd/streambuf.h" }
-    }
-  }
-  module iostream {
-    header "iostream"
-    export ios
-    export streambuf
-    export istream
-    export ostream
-    export *
-  }
-  module istream {
-    header "istream"
-    // FIXME: should re-export ios, streambuf?
-    export *
-  }
-  module iterator {
-    header "iterator"
-    export *
-
-    module __iterator {
-      module access                { private header "__iterator/access.h" }
-      module advance               { private header "__iterator/advance.h" }
-      module back_insert_iterator  { private header "__iterator/back_insert_iterator.h" }
-      module bounded_iter          { private header "__iterator/bounded_iter.h" }
-      module common_iterator       { private header "__iterator/common_iterator.h" }
-      module concepts {
-        private header "__iterator/concepts.h"
-        export concepts.equality_comparable
-        export type_traits.common_reference
-      }
-      module counted_iterator      { private header "__iterator/counted_iterator.h" }
-      module data                  { private header "__iterator/data.h" }
-      module default_sentinel      { private header "__iterator/default_sentinel.h" }
-      module distance              { private header "__iterator/distance.h" }
-      module empty                 { private header "__iterator/empty.h" }
-      module erase_if_container    { private header "__iterator/erase_if_container.h" }
-      module front_insert_iterator { private header "__iterator/front_insert_iterator.h" }
-      module incrementable_traits  { private header "__iterator/incrementable_traits.h" }
-      module indirectly_comparable { private header "__iterator/indirectly_comparable.h" }
-      module insert_iterator       { private header "__iterator/insert_iterator.h" }
-      module istream_iterator      { private header "__iterator/istream_iterator.h" }
-      module istreambuf_iterator   { private header "__iterator/istreambuf_iterator.h" }
-      module iter_move             { private header "__iterator/iter_move.h" }
-      module iter_swap             { private header "__iterator/iter_swap.h" }
-      module iterator              { private header "__iterator/iterator.h" }
-      module iterator_traits       { private header "__iterator/iterator_traits.h" }
-      module iterator_with_data    { private header "__iterator/iterator_with_data.h" }
-      module mergeable {
-        private header "__iterator/mergeable.h"
-        export functional.__functional.ranges_operations
-      }
-      module move_iterator         { private header "__iterator/move_iterator.h" }
-      module move_sentinel         { private header "__iterator/move_sentinel.h" }
-      module next                  { private header "__iterator/next.h" }
-      module ostream_iterator      { private header "__iterator/ostream_iterator.h" }
-      module ostreambuf_iterator   {
-        private header "__iterator/ostreambuf_iterator.h"
-        export iosfwd
-      }
-      module permutable            { private header "__iterator/permutable.h" }
-      module prev                  { private header "__iterator/prev.h" }
-      module projected             { private header "__iterator/projected.h" }
-      module readable_traits       {
-        private header "__iterator/readable_traits.h"
-        export __iterator.iterator_traits
-      }
-      module reverse_access        { private header "__iterator/reverse_access.h" }
-      module reverse_iterator      { private header "__iterator/reverse_iterator.h" }
-      module segmented_iterator    { private header "__iterator/segmented_iterator.h" }
-      module size                  { private header "__iterator/size.h" }
-      module sortable {
-        private header "__iterator/sortable.h"
-        export functional.__functional.ranges_operations
-      }
-      module unreachable_sentinel  { private header "__iterator/unreachable_sentinel.h" }
-      module wrap_iter             { private header "__iterator/wrap_iter.h" }
-    }
-  }
-  module latch {
-    header "latch"
-    export *
-  }
-
-  module __debug_utils {
-    module randomize_range { private header "__debug_utils/randomize_range.h" }
-  }
-
-  module limits {
-    header "limits"
-    export *
-  }
-  module list {
-    header "list"
-    export initializer_list
-    export *
-  }
-  module locale {
-    header "locale"
-    export *
-  }
-  module map {
-    header "map"
-    export initializer_list
-    export *
-  }
-  module mdspan {
-    header "mdspan"
-    export array
-    export span
-    export *
-
-    module __mdspan {
-      module extents                         { private header "__mdspan/extents.h" }
-    }
-  }
-  module memory {
-    header "memory"
-    export *
-
-    module __memory {
-      module addressof                       { private header "__memory/addressof.h" }
-      module align                           { private header "__memory/align.h" }
-      module aligned_alloc                   { private header "__memory/aligned_alloc.h" }
-      module allocate_at_least               { private header "__memory/allocate_at_least.h" }
-      module allocation_guard                { private header "__memory/allocation_guard.h" }
-      module allocator                       { private header "__memory/allocator.h" }
-      module allocator_arg_t                 { private header "__memory/allocator_arg_t.h" }
-      module allocator_destructor            { private header "__memory/allocator_destructor.h" }
-      module allocator_traits                { private header "__memory/allocator_traits.h" }
-      module assume_aligned                  { private header "__memory/assume_aligned.h" }
-      module auto_ptr                        { private header "__memory/auto_ptr.h" }
-      module builtin_new_allocator           { private header "__memory/builtin_new_allocator.h" }
-      module compressed_pair                 { private header "__memory/compressed_pair.h" }
-      module concepts                        {
-        private header "__memory/concepts.h"
-        export type_traits.remove_reference
-      }
-      module construct_at                    { private header "__memory/construct_at.h" }
-      module destruct_n                      { private header "__memory/destruct_n.h" }
-      module pointer_traits                  { private header "__memory/pointer_traits.h" }
-      module ranges_construct_at             { private header "__memory/ranges_construct_at.h" }
-      module ranges_uninitialized_algorithms {
-        private header "__memory/ranges_uninitialized_algorithms.h"
-        export algorithm.__algorithm.in_out_result
-      }
-      module raw_storage_iterator            { private header "__memory/raw_storage_iterator.h" }
-      module shared_ptr                      { private header "__memory/shared_ptr.h" }
-      module swap_allocator                  { private header "__memory/swap_allocator.h" }
-      module temp_value                      { private header "__memory/temp_value.h" }
-      module temporary_buffer                { private header "__memory/temporary_buffer.h" }
-      module uninitialized_algorithms        { private header "__memory/uninitialized_algorithms.h" }
-      module unique_ptr                      { private header "__memory/unique_ptr.h" }
-      module uses_allocator                  { private header "__memory/uses_allocator.h" }
-      module uses_allocator_construction     { private header "__memory/uses_allocator_construction.h" }
-      module voidify                         { private header "__memory/voidify.h" }
-    }
-  }
-  module memory_resource {
-    header "memory_resource"
-    export *
-
-    module __memory_resource {
-      module memory_resource              { private header "__memory_resource/memory_resource.h" }
-      module memory_resource_fwd          { private header "__fwd/memory_resource.h" }
-      module monotonic_buffer_resource    { private header "__memory_resource/monotonic_buffer_resource.h" }
-      module polymorphic_allocator        { private header "__memory_resource/polymorphic_allocator.h" }
-      module pool_options                 { private header "__memory_resource/pool_options.h" }
-      module synchronized_pool_resource   { private header "__memory_resource/synchronized_pool_resource.h" }
-      module unsynchronized_pool_resource { private header "__memory_resource/unsynchronized_pool_resource.h" }
-    }
-  }
-  module mutex {
-    header "mutex"
-    export *
-
-    module __mutex {
-      module lock_guard  { private header "__mutex/lock_guard.h" }
-      module mutex       { private header "__mutex/mutex.h" }
-      module tag_types   { private header "__mutex/tag_types.h" }
-      module unique_lock { private header "__mutex/unique_lock.h" }
-    }
-  }
-  module new {
-    header "new"
-    export *
-  }
-  module numbers {
-    header "numbers"
-    export *
-  }
-  module numeric {
-    header "numeric"
-    export *
-
-    module __numeric {
-      module accumulate               { private header "__numeric/accumulate.h" }
-      module adjacent_difference      { private header "__numeric/adjacent_difference.h" }
-      module exclusive_scan           { private header "__numeric/exclusive_scan.h" }
-      module gcd_lcm                  { private header "__numeric/gcd_lcm.h" }
-      module inclusive_scan           { private header "__numeric/inclusive_scan.h" }
-      module inner_product            { private header "__numeric/inner_product.h" }
-      module iota                     { private header "__numeric/iota.h" }
-      module midpoint                 { private header "__numeric/midpoint.h" }
-      module partial_sum              { private header "__numeric/partial_sum.h" }
-      module reduce                   { private header "__numeric/reduce.h" }
-      module transform_exclusive_scan { private header "__numeric/transform_exclusive_scan.h" }
-      module transform_inclusive_scan { private header "__numeric/transform_inclusive_scan.h" }
-      module transform_reduce         { private header "__numeric/transform_reduce.h" }
-    }
-  }
-  module optional {
-    header "optional"
-    export *
-  }
-  module ostream {
-    header "ostream"
-    // FIXME: should re-export ios, streambuf?
-    export *
-  }
-  module queue {
-    header "queue"
-    export initializer_list
-    export *
-  }
-  module random {
-    header "random"
-    export initializer_list
-    export *
-
-    module __random {
-      module bernoulli_distribution          { private header "__random/bernoulli_distribution.h" }
-      module binomial_distribution           { private header "__random/binomial_distribution.h" }
-      module cauchy_distribution             { private header "__random/cauchy_distribution.h" }
-      module chi_squared_distribution        { private header "__random/chi_squared_distribution.h" }
-      module clamp_to_integral               { private header "__random/clamp_to_integral.h" }
-      module default_random_engine           { private header "__random/default_random_engine.h" }
-      module discard_block_engine            { private header "__random/discard_block_engine.h" }
-      module discrete_distribution {
-        private header "__random/discrete_distribution.h"
-        export vector
-      }
-      module exponential_distribution        { private header "__random/exponential_distribution.h" }
-      module extreme_value_distribution      { private header "__random/extreme_value_distribution.h" }
-      module fisher_f_distribution           { private header "__random/fisher_f_distribution.h" }
-      module gamma_distribution              { private header "__random/gamma_distribution.h" }
-      module generate_canonical              { private header "__random/generate_canonical.h" }
-      module geometric_distribution          { private header "__random/geometric_distribution.h" }
-      module independent_bits_engine         { private header "__random/independent_bits_engine.h" }
-      module is_seed_sequence                { private header "__random/is_seed_sequence.h" }
-      module is_valid                        { private header "__random/is_valid.h" }
-      module knuth_b                         { private header "__random/knuth_b.h" }
-      module linear_congruential_engine      { private header "__random/linear_congruential_engine.h" }
-      module log2                            { private header "__random/log2.h" }
-      module lognormal_distribution          { private header "__random/lognormal_distribution.h" }
-      module mersenne_twister_engine         { private header "__random/mersenne_twister_engine.h" }
-      module negative_binomial_distribution  { private header "__random/negative_binomial_distribution.h" }
-      module normal_distribution             { private header "__random/normal_distribution.h" }
-      module piecewise_constant_distribution {
-        private header "__random/piecewise_constant_distribution.h"
-        export vector
-      }
-      module piecewise_linear_distribution {
-        private header "__random/piecewise_linear_distribution.h"
-        export vector
-      }
-      module poisson_distribution            { private header "__random/poisson_distribution.h" }
-      module random_device                   { private header "__random/random_device.h" }
-      module ranlux                          { private header "__random/ranlux.h" }
-      module seed_seq                        { private header "__random/seed_seq.h" }
-      module shuffle_order_engine            { private header "__random/shuffle_order_engine.h" }
-      module student_t_distribution          { private header "__random/student_t_distribution.h" }
-      module subtract_with_carry_engine      { private header "__random/subtract_with_carry_engine.h" }
-      module uniform_int_distribution        { private header "__random/uniform_int_distribution.h" }
-      module uniform_random_bit_generator    { private header "__random/uniform_random_bit_generator.h" }
-      module uniform_real_distribution       { private header "__random/uniform_real_distribution.h" }
-      module weibull_distribution            { private header "__random/weibull_distribution.h" }
-    }
-  }
-  module ranges {
-    header "ranges"
-    export compare
-    export initializer_list
-    export iterator
-    export *
-
-    module __ranges {
-      module access                     { private header "__ranges/access.h" }
-      module all                        {
-        private header "__ranges/all.h"
-        export functional.__functional.compose
-        export functional.__functional.perfect_forward
-      }
-      module as_rvalue_view             { private header "__ranges/as_rvalue_view.h" }
-      module common_view                { private header "__ranges/common_view.h" }
-      module concepts                   { private header "__ranges/concepts.h" }
-      module container_compatible_range { private header "__ranges/container_compatible_range.h" }
-      module copyable_box               { private header "__ranges/copyable_box.h" }
-      module counted                    {
-        private header "__ranges/counted.h"
-        export span
-      }
-      module dangling                   { private header "__ranges/dangling.h" }
-      module data                       { private header "__ranges/data.h" }
-      module drop_view                  { private header "__ranges/drop_view.h" }
-      module drop_while_view            { private header "__ranges/drop_while_view.h" }
-      module elements_view              { private header "__ranges/elements_view.h" }
-      module empty                      { private header "__ranges/empty.h" }
-      module empty_view                 { private header "__ranges/empty_view.h" }
-      module enable_borrowed_range      { private header "__ranges/enable_borrowed_range.h" }
-      module enable_view                { private header "__ranges/enable_view.h" }
-      module filter_view                { private header "__ranges/filter_view.h" }
-      module from_range                 { private header "__ranges/from_range.h" }
-      module iota_view                  { private header "__ranges/iota_view.h" }
-      module istream_view               {
-          private header "__ranges/istream_view.h"
-      }
-      module join_view                  { private header "__ranges/join_view.h" }
-      module lazy_split_view            { private header "__ranges/lazy_split_view.h" }
-      module non_propagating_cache      { private header "__ranges/non_propagating_cache.h" }
-      module owning_view                { private header "__ranges/owning_view.h" }
-      module range_adaptor              { private header "__ranges/range_adaptor.h" }
-      module rbegin                     { private header "__ranges/rbegin.h" }
-      module ref_view                   { private header "__ranges/ref_view.h" }
-      module rend                       { private header "__ranges/rend.h" }
-      module reverse_view               { private header "__ranges/reverse_view.h" }
-      module single_view                { private header "__ranges/single_view.h" }
-      module size                       { private header "__ranges/size.h" }
-      module split_view                 { private header "__ranges/split_view.h" }
-      module subrange                   {
-        private header "__ranges/subrange.h"
-        export subrange_fwd
-      }
-      module subrange_fwd               { private header "__fwd/subrange.h" }
-      module take_view                  { private header "__ranges/take_view.h" }
-      module take_while_view            { private header "__ranges/take_while_view.h" }
-      module transform_view             {
-        private header "__ranges/transform_view.h"
-        export functional.__functional.bind_back
-        export functional.__functional.perfect_forward
-      }
-      module view_interface             { private header "__ranges/view_interface.h" }
-      module views                      { private header "__ranges/views.h" }
-      module zip_view                   { private header "__ranges/zip_view.h" }
-    }
-  }
-  module ratio {
-    header "ratio"
-    export *
-  }
-  module regex {
-    header "regex"
-    export initializer_list
-    export *
-  }
-  module scoped_allocator {
-    header "scoped_allocator"
-    export *
-  }
-  module semaphore {
-    header "semaphore"
-    export *
-  }
-  module set {
-    header "set"
-    export initializer_list
-    export *
-  }
-  module shared_mutex {
-    header "shared_mutex"
-    export version
-  }
-  module source_location {
-    header "source_location"
-    export *
-  }
-  module span {
-    header "span"
-    export ranges.__ranges.enable_borrowed_range
-    export version
-    module span_fwd { private header "__fwd/span.h" }
-  }
-  module sstream {
-    header "sstream"
-    // FIXME: should re-export istream, ostream, ios, streambuf, string?
-    export *
-  }
-  module stack {
-    header "stack"
-    export initializer_list
-    export *
-  }
-  module stdexcept {
-    header "stdexcept"
-    export *
-  }
-  module stop_token {
-    export *
-    module __stop_token {
-      module atomic_unique_lock   { private header "__stop_token/atomic_unique_lock.h" }
-      module intrusive_list_view  { private header "__stop_token/intrusive_list_view.h" }
-      module intrusive_shared_ptr { private header "__stop_token/intrusive_shared_ptr.h" }
-    }
-  }
-  module streambuf {
-    header "streambuf"
-    export *
-  }
-  module string {
-    header "string"
-    export initializer_list
-    export string_view
-    module __string {
-      module char_traits           { private header "__string/char_traits.h" }
-      module constexpr_c_functions { private header "__string/constexpr_c_functions.h" }
-      module extern_template_lists { private header "__string/extern_template_lists.h" }
-      module string_fwd            { private header "__fwd/string.h" }
-    }
-    export *
-  }
-  module string_view {
-    header "string_view"
-    export initializer_list
-    export *
-    module string_view_fwd { private header "__fwd/string_view.h" }
-  }
-  module strstream {
-    header "strstream"
-    export *
-  }
-  module system_error {
-    header "system_error"
-    export __errc
-    export *
-    module __system_error {
-      module errc           { private header "__system_error/errc.h" }
-      module error_category { private header "__system_error/error_category.h" }
-      module error_code {
-        private header "__system_error/error_code.h"
-        export functional.__functional.hash
-        export functional.__functional.unary_function
-      }
-      module error_condition {
-        private header "__system_error/error_condition.h"
-        export functional.__functional.hash
-        export functional.__functional.unary_function
-      }
-      module system_error { private header "__system_error/system_error.h" }
-
-    }
-  }
-  module thread {
-    header "thread"
-    export *
-
-    module __thread {
-      module poll_with_backoff    { private header "__thread/poll_with_backoff.h" }
-      module timed_backoff_policy { private header "__thread/timed_backoff_policy.h" }
-    }
-  }
-  module tuple {
-    header "tuple"
-    export *
-
-    module get_fwd          { private header "__fwd/get.h" }
-    module make_tuple_types { private header "__tuple/make_tuple_types.h" }
-    module pair_like        { private header "__tuple/pair_like.h" }
-    module sfinae_helpers   { private header "__tuple/sfinae_helpers.h" }
-    module tuple_element    { private header "__tuple/tuple_element.h" }
-    module tuple_fwd        { private header "__fwd/tuple.h" }
-    module tuple_indices    { private header "__tuple/tuple_indices.h" }
-    module tuple_like       { private header "__tuple/tuple_like.h" }
-    module tuple_like_ext   { private header "__tuple/tuple_like_ext.h" }
-    module tuple_size       { private header "__tuple/tuple_size.h" }
-    module tuple_types      { private header "__tuple/tuple_types.h" }
-  }
-  module type_traits {
-    header "type_traits"
-    export *
-
-    module add_const                                 { private header "__type_traits/add_const.h" }
-    module add_cv                                    { private header "__type_traits/add_cv.h" }
-    module add_lvalue_reference                      { private header "__type_traits/add_lvalue_reference.h" }
-    module add_pointer                               { private header "__type_traits/add_pointer.h" }
-    module add_rvalue_reference                      { private header "__type_traits/add_rvalue_reference.h" }
-    module add_volatile                              { private header "__type_traits/add_volatile.h" }
-    module aligned_storage                           { private header "__type_traits/aligned_storage.h" }
-    module aligned_union                             { private header "__type_traits/aligned_union.h" }
-    module alignment_of                              { private header "__type_traits/alignment_of.h" }
-    module apply_cv                                  { private header "__type_traits/apply_cv.h" }
-    module can_extract_key                           { private header "__type_traits/can_extract_key.h" }
-    module common_reference                          { private header "__type_traits/common_reference.h" }
-    module common_type                               { private header "__type_traits/common_type.h" }
-    module conditional                               { private header "__type_traits/conditional.h" }
-    module conjunction                               { private header "__type_traits/conjunction.h" }
-    module copy_cv                                   { private header "__type_traits/copy_cv.h" }
-    module copy_cvref                                { private header "__type_traits/copy_cvref.h" }
-    module decay                                     { private header "__type_traits/decay.h" }
-    module dependent_type                            { private header "__type_traits/dependent_type.h" }
-    module disjunction                               { private header "__type_traits/disjunction.h" }
-    module enable_if                                 { private header "__type_traits/enable_if.h" }
-    module extent                                    { private header "__type_traits/extent.h" }
-    module has_unique_object_representation          { private header "__type_traits/has_unique_object_representation.h" }
-    module has_virtual_destructor                    { private header "__type_traits/has_virtual_destructor.h" }
-    module integral_constant                         { private header "__type_traits/integral_constant.h" }
-    module invoke                                    { private header "__type_traits/invoke.h" }
-    module is_abstract                               { private header "__type_traits/is_abstract.h" }
-    module is_aggregate                              { private header "__type_traits/is_aggregate.h" }
-    module is_allocator                              { private header "__type_traits/is_allocator.h" }
-    module is_always_bitcastable                     { private header "__type_traits/is_always_bitcastable.h" }
-    module is_arithmetic {
-      private header "__type_traits/is_arithmetic.h"
-      export integral_constant
-    }
-    module is_array                                  {
-      private header "__type_traits/is_array.h"
-      export integral_constant
-    }
-    module is_assignable                             { private header "__type_traits/is_assignable.h" }
-    module is_base_of                                { private header "__type_traits/is_base_of.h" }
-    module is_bounded_array                          { private header "__type_traits/is_bounded_array.h" }
-    module is_callable                               { private header "__type_traits/is_callable.h" }
-    module is_char_like_type                         { private header "__type_traits/is_char_like_type.h" }
-    module is_class                                  { private header "__type_traits/is_class.h" }
-    module is_compound                               { private header "__type_traits/is_compound.h" }
-    module is_const                                  { private header "__type_traits/is_const.h" }
-    module is_constant_evaluated                     { private header "__type_traits/is_constant_evaluated.h" }
-    module is_constructible                          { private header "__type_traits/is_constructible.h" }
-    module is_convertible                            { private header "__type_traits/is_convertible.h" }
-    module is_copy_assignable                        { private header "__type_traits/is_copy_assignable.h" }
-    module is_copy_constructible                     { private header "__type_traits/is_copy_constructible.h" }
-    module is_core_convertible                       {
-      private header "__type_traits/is_core_convertible.h"
-      export integral_constant
-    }
-    module is_default_constructible                  { private header "__type_traits/is_default_constructible.h" }
-    module is_destructible                           { private header "__type_traits/is_destructible.h" }
-    module is_empty                                  { private header "__type_traits/is_empty.h" }
-    module is_enum                                   {
-      private header "__type_traits/is_enum.h"
-      export integral_constant
-    }
-    module is_equality_comparable                    {
-      private header "__type_traits/is_equality_comparable.h"
-      export integral_constant
-    }
-    module is_execution_policy                       { private header "__type_traits/is_execution_policy.h" }
-    module is_final                                  { private header "__type_traits/is_final.h" }
-    module is_floating_point                         { private header "__type_traits/is_floating_point.h" }
-    module is_function                               { private header "__type_traits/is_function.h" }
-    module is_fundamental                            { private header "__type_traits/is_fundamental.h" }
-    module is_implicitly_default_constructible       { private header "__type_traits/is_implicitly_default_constructible.h" }
-    module is_integral                               { private header "__type_traits/is_integral.h" }
-    module is_literal_type                           { private header "__type_traits/is_literal_type.h" }
-    module is_member_function_pointer                { private header "__type_traits/is_member_function_pointer.h" }
-    module is_member_object_pointer                  { private header "__type_traits/is_member_object_pointer.h" }
-    module is_member_pointer                         { private header "__type_traits/is_member_pointer.h" }
-    module is_move_assignable                        { private header "__type_traits/is_move_assignable.h" }
-    module is_move_constructible                     { private header "__type_traits/is_move_constructible.h" }
-    module is_nothrow_assignable                     { private header "__type_traits/is_nothrow_assignable.h" }
-    module is_nothrow_constructible                  { private header "__type_traits/is_nothrow_constructible.h" }
-    module is_nothrow_convertible                    { private header "__type_traits/is_nothrow_convertible.h" }
-    module is_nothrow_copy_assignable                { private header "__type_traits/is_nothrow_copy_assignable.h" }
-    module is_nothrow_copy_constructible             { private header "__type_traits/is_nothrow_copy_constructible.h" }
-    module is_nothrow_default_constructible          { private header "__type_traits/is_nothrow_default_constructible.h" }
-    module is_nothrow_destructible                   { private header "__type_traits/is_nothrow_destructible.h" }
-    module is_nothrow_move_assignable                { private header "__type_traits/is_nothrow_move_assignable.h" }
-    module is_nothrow_move_constructible             { private header "__type_traits/is_nothrow_move_constructible.h" }
-    module is_null_pointer                           { private header "__type_traits/is_null_pointer.h" }
-    module is_object                                 { private header "__type_traits/is_object.h" }
-    module is_pod                                    { private header "__type_traits/is_pod.h" }
-    module is_pointer                                { private header "__type_traits/is_pointer.h" }
-    module is_polymorphic                            { private header "__type_traits/is_polymorphic.h" }
-    module is_primary_template                       { private header "__type_traits/is_primary_template.h" }
-    module is_reference                              { private header "__type_traits/is_reference.h" }
-    module is_reference_wrapper                      { private header "__type_traits/is_reference_wrapper.h" }
-    module is_referenceable                          { private header "__type_traits/is_referenceable.h" }
-    module is_same                                   {
-      private header "__type_traits/is_same.h"
-      export type_traits.integral_constant
-    }
-    module is_scalar                                 { private header "__type_traits/is_scalar.h" }
-    module is_scoped_enum                            { private header "__type_traits/is_scoped_enum.h" }
-    module is_signed                                 { private header "__type_traits/is_signed.h" }
-    module is_signed_integer                         { private header "__type_traits/is_signed_integer.h" }
-    module is_specialization                         { private header "__type_traits/is_specialization.h" }
-    module is_standard_layout                        { private header "__type_traits/is_standard_layout.h" }
-    module is_swappable                              { private header "__type_traits/is_swappable.h" }
-    module is_trivial                                { private header "__type_traits/is_trivial.h" }
-    module is_trivially_assignable                   { private header "__type_traits/is_trivially_assignable.h" }
-    module is_trivially_constructible                { private header "__type_traits/is_trivially_constructible.h" }
-    module is_trivially_copy_assignable              { private header "__type_traits/is_trivially_copy_assignable.h" }
-    module is_trivially_copy_constructible           { private header "__type_traits/is_trivially_copy_constructible.h" }
-    module is_trivially_copyable                     { private header "__type_traits/is_trivially_copyable.h" }
-    module is_trivially_default_constructible        { private header "__type_traits/is_trivially_default_constructible.h" }
-    module is_trivially_destructible                 { private header "__type_traits/is_trivially_destructible.h" }
-    module is_trivially_lexicographically_comparable { private header "__type_traits/is_trivially_lexicographically_comparable.h" }
-    module is_trivially_move_assignable              { private header "__type_traits/is_trivially_move_assignable.h" }
-    module is_trivially_move_constructible           { private header "__type_traits/is_trivially_move_constructible.h" }
-    module is_unbounded_array                        { private header "__type_traits/is_unbounded_array.h" }
-    module is_union                                  { private header "__type_traits/is_union.h" }
-    module is_unsigned                               { private header "__type_traits/is_unsigned.h" }
-    module is_unsigned_integer                       { private header "__type_traits/is_unsigned_integer.h" }
-    module is_valid_expansion                        { private header "__type_traits/is_valid_expansion.h" }
-    module is_void                                   {
-      private header "__type_traits/is_void.h"
-      export integral_constant
-    }
-    module is_volatile                               { private header "__type_traits/is_volatile.h" }
-    module lazy                                      { private header "__type_traits/lazy.h" }
-    module make_32_64_or_128_bit                     { private header "__type_traits/make_32_64_or_128_bit.h" }
-    module make_const_lvalue_ref                     { private header "__type_traits/make_const_lvalue_ref.h" }
-    module make_signed                               { private header "__type_traits/make_signed.h" }
-    module make_unsigned                             { private header "__type_traits/make_unsigned.h" }
-    module maybe_const                               { private header "__type_traits/maybe_const.h" }
-    module nat                                       { private header "__type_traits/nat.h" }
-    module negation                                  { private header "__type_traits/negation.h" }
-    module noexcept_move_assign_container            { private header "__type_traits/noexcept_move_assign_container.h" }
-    module predicate_traits                          { private header "__type_traits/predicate_traits.h" }
-    module promote                                   { private header "__type_traits/promote.h" }
-    module rank                                      { private header "__type_traits/rank.h" }
-    module remove_all_extents                        { private header "__type_traits/remove_all_extents.h" }
-    module remove_const                              { private header "__type_traits/remove_const.h" }
-    module remove_const_ref                          { private header "__type_traits/remove_const_ref.h" }
-    module remove_cv                                 { private header "__type_traits/remove_cv.h" }
-    module remove_cvref                              { private header "__type_traits/remove_cvref.h" }
-    module remove_extent                             { private header "__type_traits/remove_extent.h" }
-    module remove_pointer                            { private header "__type_traits/remove_pointer.h" }
-    module remove_reference                          { private header "__type_traits/remove_reference.h" }
-    module remove_volatile                           { private header "__type_traits/remove_volatile.h" }
-    module result_of                                 { private header "__type_traits/result_of.h" }
-    module strip_signature                           { private header "__type_traits/strip_signature.h" }
-    module type_identity                             { private header "__type_traits/type_identity.h" }
-    module type_list                                 { private header "__type_traits/type_list.h" }
-    module underlying_type                           {
-      private header "__type_traits/underlying_type.h"
-
-      export type_traits
-    }
-    module unwrap_ref                                { private header "__type_traits/unwrap_ref.h" }
-    module void_t                                    { private header "__type_traits/void_t.h" }
-  }
-  module typeindex {
-    header "typeindex"
-    export *
-  }
-  module typeinfo {
-    header "typeinfo"
-    export *
-  }
-  module unordered_map {
-    header "unordered_map"
-    export initializer_list
-    export *
-  }
-  module unordered_set {
-    header "unordered_set"
-    export initializer_list
-    export *
-  }
-  module utility {
-    header "utility"
-    export initializer_list
-    export *
-
-    module __utility {
-      module as_const               { private header "__utility/as_const.h" }
-      module auto_cast              {
-        private header "__utility/auto_cast.h"
-        export type_traits.decay
-      }
-      module cmp                    { private header "__utility/cmp.h" }
-      module convert_to_integral    { private header "__utility/convert_to_integral.h" }
-      module declval                { private header "__utility/declval.h" }
-      module exception_guard        { private header "__utility/exception_guard.h" }
-      module exchange               { private header "__utility/exchange.h" }
-      module forward                { private header "__utility/forward.h" }
-      module forward_like           { private header "__utility/forward_like.h" }
-      module in_place               { private header "__utility/in_place.h" }
-      module integer_sequence       { private header "__utility/integer_sequence.h" }
-      module move                   { private header "__utility/move.h" }
-      module pair                   { private header "__utility/pair.h" }
-      module pair_fwd               { private header "__fwd/pair.h" }
-      module piecewise_construct    { private header "__utility/piecewise_construct.h" }
-      module priority_tag           { private header "__utility/priority_tag.h" }
-      module rel_ops                { private header "__utility/rel_ops.h" }
-      module swap                   { private header "__utility/swap.h" }
-      module terminate_on_exception { private header "__utility/terminate_on_exception.h" }
-      module to_underlying          { private header "__utility/to_underlying.h" }
-      module unreachable            { private header "__utility/unreachable.h" }
-    }
-  }
-  module valarray {
-    header "valarray"
-    export initializer_list
-    export *
-  }
-  module variant {
-    header "variant"
-    export *
-
-    module __variant {
-      module monostate { private header "__variant/monostate.h" }
-    }
-  }
-  module vector {
-    header "vector"
-    export initializer_list
-    export *
-  }
-  module version {
-    header "version"
-    export *
-  }
-
-  // FIXME: These should be private.
-  module __assert            {         header "__assert"            export * }
-  module __availability      { private header "__availability"      export * }
-  module __bit_reference     { private header "__bit_reference"     export * }
-  module __debug             {         header "__debug"             export * }
-  module __hash_table        {         header "__hash_table"        export * }
-  module __locale            {
-    private header "__locale" export *
-  }
-  module __mbstate_t         { private header "__mbstate_t.h"       export * }
-  module __node_handle       { private header "__node_handle"       export * }
-  module __split_buffer      { private header "__split_buffer"      export * }
-  module __std_mbstate_t     { private header "__std_mbstate_t.h"   export * }
-  module __threading_support {         header "__threading_support" export * }
-  module __tree              {         header "__tree"              export * }
-  module __undef_macros      {         header "__undef_macros"      export * }
-  module __verbose_abort     {         header "__verbose_abort"     export * }
-
-  // This one needs to appear after __tree to work around issues with modules in Objective-C++ mode.
-  module coroutine {
-    header "coroutine"
-    export compare
-    export *
-
-    module __coroutine {
-      module coroutine_handle           { private header "__coroutine/coroutine_handle.h" }
-      module coroutine_traits           { private header "__coroutine/coroutine_traits.h" }
-      module noop_coroutine_handle      { private header "__coroutine/noop_coroutine_handle.h" }
-      module trivial_awaitables         { private header "__coroutine/trivial_awaitables.h" }
-    }
-  }
-
-  module experimental {
-    requires cplusplus11
-
-    module deque {
-      header "experimental/deque"
-      export *
-    }
-    module forward_list {
-      header "experimental/forward_list"
-      export *
-    }
-    module iterator {
-      header "experimental/iterator"
-      export *
-    }
-    module list {
-      header "experimental/list"
-      export *
-    }
-    module map {
-      header "experimental/map"
-      export *
-    }
-    module memory_resource {
-      header "experimental/memory_resource"
-      export *
-    }
-    module propagate_const {
-      header "experimental/propagate_const"
-      export *
-    }
-    module regex {
-      header "experimental/regex"
-      export *
-    }
-    module simd {
-      header "experimental/simd"
-      export *
-    }
-    module set {
-      header "experimental/set"
-      export *
-    }
-    module span {
-      header "span"
-      export *
-    }
-    module string {
-      header "experimental/string"
-      export *
-    }
-    module type_traits {
-      header "experimental/type_traits"
-      export *
-    }
-    module unordered_map {
-      header "experimental/unordered_map"
-      export *
-    }
-    module unordered_set {
-      header "experimental/unordered_set"
-      export *
-    }
-    module utility {
-      header "experimental/utility"
-      export *
-    }
-    module vector {
-      header "experimental/vector"
-      export *
-    }
-    // FIXME these should be private
-    module __memory {
-      header "experimental/__memory"
-      export *
-    }
-  } // end experimental
-}
diff --git a/third_party/libcxx/mutex b/third_party/libcxx/mutex
index 74945b975..02c52dd72 100644
--- a/third_party/libcxx/mutex
+++ b/third_party/libcxx/mutex
@@ -186,7 +186,6 @@ template<class Callable, class ...Args>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__chrono/steady_clock.h>
 #include <__chrono/time_point.h>
 #include <__condition_variable/condition_variable.h>
@@ -194,13 +193,16 @@ template<class Callable, class ...Args>
 #include <__memory/shared_ptr.h>
 #include <__mutex/lock_guard.h>
 #include <__mutex/mutex.h>
+#include <__mutex/once_flag.h>
 #include <__mutex/tag_types.h>
 #include <__mutex/unique_lock.h>
-#include <__threading_support>
+#include <__thread/id.h>
+#include <__thread/support.h>
 #include <__utility/forward.h>
-#include <cstdint>
+#include <cstddef>
+#include <limits>
 #ifndef _LIBCPP_CXX03_LANG
-# include <tuple>
+#  include <tuple>
 #endif
 #include <version>
 
@@ -211,499 +213,286 @@ template<class Callable, class ...Args>
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
-class _LIBCPP_TYPE_VIS recursive_mutex
-{
-    __libcpp_recursive_mutex_t __m_;
+class _LIBCPP_EXPORTED_FROM_ABI recursive_mutex {
+  __libcpp_recursive_mutex_t __m_;
 
 public:
-    recursive_mutex();
-    ~recursive_mutex();
+  recursive_mutex();
+  ~recursive_mutex();
 
-    recursive_mutex(const recursive_mutex&) = delete;
-    recursive_mutex& operator=(const recursive_mutex&) = delete;
+  recursive_mutex(const recursive_mutex&)            = delete;
+  recursive_mutex& operator=(const recursive_mutex&) = delete;
 
-    void lock();
-    bool try_lock() _NOEXCEPT;
-    void unlock()  _NOEXCEPT;
+  void lock();
+  bool try_lock() _NOEXCEPT;
+  void unlock() _NOEXCEPT;
 
-    typedef __libcpp_recursive_mutex_t* native_handle_type;
+  typedef __libcpp_recursive_mutex_t* native_handle_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    native_handle_type native_handle() {return &__m_;}
+  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__m_; }
 };
 
-class _LIBCPP_TYPE_VIS timed_mutex
-{
-    mutex              __m_;
-    condition_variable __cv_;
-    bool               __locked_;
-public:
-     timed_mutex();
-     ~timed_mutex();
-
-    timed_mutex(const timed_mutex&) = delete;
-    timed_mutex& operator=(const timed_mutex&) = delete;
+class _LIBCPP_EXPORTED_FROM_ABI timed_mutex {
+  mutex __m_;
+  condition_variable __cv_;
+  bool __locked_;
 
 public:
-    void lock();
-    bool try_lock() _NOEXCEPT;
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
-            {return try_lock_until(chrono::steady_clock::now() + __d);}
-    template <class _Clock, class _Duration>
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-        bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
-    void unlock() _NOEXCEPT;
+  timed_mutex();
+  ~timed_mutex();
+
+  timed_mutex(const timed_mutex&)            = delete;
+  timed_mutex& operator=(const timed_mutex&) = delete;
+
+public:
+  void lock();
+  bool try_lock() _NOEXCEPT;
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
+    return try_lock_until(chrono::steady_clock::now() + __d);
+  }
+  template <class _Clock, class _Duration>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool
+  try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
+  void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
-bool
-timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
-{
-    using namespace chrono;
-    unique_lock<mutex> __lk(__m_);
-    bool __no_timeout = _Clock::now() < __t;
-    while (__no_timeout && __locked_)
-        __no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
-    if (!__locked_)
-    {
-        __locked_ = true;
-        return true;
-    }
-    return false;
+bool timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
+  using namespace chrono;
+  unique_lock<mutex> __lk(__m_);
+  bool __no_timeout = _Clock::now() < __t;
+  while (__no_timeout && __locked_)
+    __no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
+  if (!__locked_) {
+    __locked_ = true;
+    return true;
+  }
+  return false;
 }
 
-class _LIBCPP_TYPE_VIS recursive_timed_mutex
-{
-    mutex              __m_;
-    condition_variable __cv_;
-    size_t             __count_;
-    __thread_id        __id_;
+class _LIBCPP_EXPORTED_FROM_ABI recursive_timed_mutex {
+  mutex __m_;
+  condition_variable __cv_;
+  size_t __count_;
+  __thread_id __id_;
+
 public:
-    recursive_timed_mutex();
-    ~recursive_timed_mutex();
+  recursive_timed_mutex();
+  ~recursive_timed_mutex();
 
-    recursive_timed_mutex(const recursive_timed_mutex&) = delete;
-    recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
+  recursive_timed_mutex(const recursive_timed_mutex&)            = delete;
+  recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
 
-    void lock();
-    bool try_lock() _NOEXCEPT;
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
-            {return try_lock_until(chrono::steady_clock::now() + __d);}
-    template <class _Clock, class _Duration>
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-        bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
-    void unlock() _NOEXCEPT;
+  void lock();
+  bool try_lock() _NOEXCEPT;
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
+    return try_lock_until(chrono::steady_clock::now() + __d);
+  }
+  template <class _Clock, class _Duration>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool
+  try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
+  void unlock() _NOEXCEPT;
 };
 
 template <class _Clock, class _Duration>
-bool
-recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
-{
-    using namespace chrono;
-    __thread_id __id = this_thread::get_id();
-    unique_lock<mutex> __lk(__m_);
-    if (__id == __id_)
-    {
-        if (__count_ == numeric_limits<size_t>::max())
-            return false;
-        ++__count_;
-        return true;
-    }
-    bool __no_timeout = _Clock::now() < __t;
-    while (__no_timeout && __count_ != 0)
-        __no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
-    if (__count_ == 0)
-    {
-        __count_ = 1;
-        __id_ = __id;
-        return true;
-    }
-    return false;
+bool recursive_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
+  using namespace chrono;
+  __thread_id __id = this_thread::get_id();
+  unique_lock<mutex> __lk(__m_);
+  if (__id == __id_) {
+    if (__count_ == numeric_limits<size_t>::max())
+      return false;
+    ++__count_;
+    return true;
+  }
+  bool __no_timeout = _Clock::now() < __t;
+  while (__no_timeout && __count_ != 0)
+    __no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
+  if (__count_ == 0) {
+    __count_ = 1;
+    __id_    = __id;
+    return true;
+  }
+  return false;
 }
 
 template <class _L0, class _L1>
-_LIBCPP_HIDE_FROM_ABI int
-try_lock(_L0& __l0, _L1& __l1)
-{
-    unique_lock<_L0> __u0(__l0, try_to_lock_t());
-    if (__u0.owns_lock())
-    {
-        if (__l1.try_lock())
-        {
-            __u0.release();
-            return -1;
-        }
-        else
-            return 1;
-    }
-    return 0;
+_LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1) {
+  unique_lock<_L0> __u0(__l0, try_to_lock_t());
+  if (__u0.owns_lock()) {
+    if (__l1.try_lock()) {
+      __u0.release();
+      return -1;
+    } else
+      return 1;
+  }
+  return 0;
 }
 
-#ifndef _LIBCPP_CXX03_LANG
+#  ifndef _LIBCPP_CXX03_LANG
 
 template <class _L0, class _L1, class _L2, class... _L3>
-_LIBCPP_HIDE_FROM_ABI int
-try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3)
-{
-    int __r = 0;
-    unique_lock<_L0> __u0(__l0, try_to_lock);
-    if (__u0.owns_lock())
-    {
-        __r = std::try_lock(__l1, __l2, __l3...);
-        if (__r == -1)
-            __u0.release();
-        else
-            ++__r;
-    }
-    return __r;
+_LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
+  int __r = 0;
+  unique_lock<_L0> __u0(__l0, try_to_lock);
+  if (__u0.owns_lock()) {
+    __r = std::try_lock(__l1, __l2, __l3...);
+    if (__r == -1)
+      __u0.release();
+    else
+      ++__r;
+  }
+  return __r;
 }
 
-#endif // _LIBCPP_CXX03_LANG
+#  endif // _LIBCPP_CXX03_LANG
 
 template <class _L0, class _L1>
-_LIBCPP_HIDE_FROM_ABI void
-lock(_L0& __l0, _L1& __l1)
-{
-    while (true)
+_LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1) {
+  while (true) {
     {
-        {
-            unique_lock<_L0> __u0(__l0);
-            if (__l1.try_lock())
-            {
-                __u0.release();
-                break;
-            }
-        }
-        __libcpp_thread_yield();
-        {
-            unique_lock<_L1> __u1(__l1);
-            if (__l0.try_lock())
-            {
-                __u1.release();
-                break;
-            }
-        }
-        __libcpp_thread_yield();
+      unique_lock<_L0> __u0(__l0);
+      if (__l1.try_lock()) {
+        __u0.release();
+        break;
+      }
     }
-}
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _L0, class _L1, class _L2, class ..._L3>
-void
-__lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
-{
-    while (true)
+    __libcpp_thread_yield();
     {
-        switch (__i)
-        {
-        case 0:
-            {
-                unique_lock<_L0> __u0(__l0);
-                __i = std::try_lock(__l1, __l2, __l3...);
-                if (__i == -1)
-                {
-                    __u0.release();
-                    return;
-                }
-            }
-            ++__i;
-            __libcpp_thread_yield();
-            break;
-        case 1:
-            {
-                unique_lock<_L1> __u1(__l1);
-                __i = std::try_lock(__l2, __l3..., __l0);
-                if (__i == -1)
-                {
-                    __u1.release();
-                    return;
-                }
-            }
-            if (__i == sizeof...(_L3) + 1)
-                __i = 0;
-            else
-                __i += 2;
-            __libcpp_thread_yield();
-            break;
-        default:
-            std::__lock_first(__i - 2, __l2, __l3..., __l0, __l1);
-            return;
-        }
+      unique_lock<_L1> __u1(__l1);
+      if (__l0.try_lock()) {
+        __u1.release();
+        break;
+      }
     }
+    __libcpp_thread_yield();
+  }
 }
 
-template <class _L0, class _L1, class _L2, class ..._L3>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
-{
-    std::__lock_first(0, __l0, __l1, __l2, __l3...);
+#  ifndef _LIBCPP_CXX03_LANG
+
+template <class _L0, class _L1, class _L2, class... _L3>
+void __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
+  while (true) {
+    switch (__i) {
+    case 0: {
+      unique_lock<_L0> __u0(__l0);
+      __i = std::try_lock(__l1, __l2, __l3...);
+      if (__i == -1) {
+        __u0.release();
+        return;
+      }
+    }
+      ++__i;
+      __libcpp_thread_yield();
+      break;
+    case 1: {
+      unique_lock<_L1> __u1(__l1);
+      __i = std::try_lock(__l2, __l3..., __l0);
+      if (__i == -1) {
+        __u1.release();
+        return;
+      }
+    }
+      if (__i == sizeof...(_L3) + 1)
+        __i = 0;
+      else
+        __i += 2;
+      __libcpp_thread_yield();
+      break;
+    default:
+      std::__lock_first(__i - 2, __l2, __l3..., __l0, __l1);
+      return;
+    }
+  }
 }
 
-template <class _L0>
-inline _LIBCPP_INLINE_VISIBILITY
-void __unlock(_L0& __l0) {
-    __l0.unlock();
+template <class _L0, class _L1, class _L2, class... _L3>
+inline _LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
+  std::__lock_first(0, __l0, __l1, __l2, __l3...);
 }
 
-template <class _L0, class _L1>
-inline _LIBCPP_INLINE_VISIBILITY
-void __unlock(_L0& __l0, _L1& __l1) {
-    __l0.unlock();
-    __l1.unlock();
-}
+#  endif // _LIBCPP_CXX03_LANG
 
-template <class _L0, class _L1, class _L2, class ..._L3>
-inline _LIBCPP_INLINE_VISIBILITY
-void __unlock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
-    __l0.unlock();
-    __l1.unlock();
-    _VSTD::__unlock(__l2, __l3...);
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
-#if _LIBCPP_STD_VER >= 17
-template <class ..._Mutexes>
+#  if _LIBCPP_STD_VER >= 17
+template <class... _Mutexes>
 class _LIBCPP_TEMPLATE_VIS scoped_lock;
 
 template <>
 class _LIBCPP_TEMPLATE_VIS scoped_lock<> {
 public:
-    explicit scoped_lock() {}
-    ~scoped_lock() = default;
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock() {}
+  ~scoped_lock() = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit scoped_lock(adopt_lock_t) {}
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(adopt_lock_t) {}
 
-    scoped_lock(scoped_lock const&) = delete;
-    scoped_lock& operator=(scoped_lock const&) = delete;
+  scoped_lock(scoped_lock const&)            = delete;
+  scoped_lock& operator=(scoped_lock const&) = delete;
 };
 
 template <class _Mutex>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_THREAD_SAFETY_ANNOTATION(scoped_lockable) scoped_lock<_Mutex> {
 public:
-    typedef _Mutex  mutex_type;
+  typedef _Mutex mutex_type;
+
 private:
-    mutex_type& __m_;
+  mutex_type& __m_;
+
 public:
-    explicit scoped_lock(mutex_type & __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
-        : __m_(__m) {__m_.lock();}
+  [[nodiscard]]
+  _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability(__m))
+      : __m_(__m) {
+    __m_.lock();
+  }
 
-    ~scoped_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) {__m_.unlock();}
+  ~scoped_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability()) { __m_.unlock(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit scoped_lock(adopt_lock_t, mutex_type& __m) _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
-        : __m_(__m) {}
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(adopt_lock_t, mutex_type& __m)
+      _LIBCPP_THREAD_SAFETY_ANNOTATION(requires_capability(__m))
+      : __m_(__m) {}
 
-    scoped_lock(scoped_lock const&) = delete;
-    scoped_lock& operator=(scoped_lock const&) = delete;
+  scoped_lock(scoped_lock const&)            = delete;
+  scoped_lock& operator=(scoped_lock const&) = delete;
 };
 
-template <class ..._MArgs>
-class _LIBCPP_TEMPLATE_VIS scoped_lock
-{
-    static_assert(sizeof...(_MArgs) > 1, "At least 2 lock types required");
-    typedef tuple<_MArgs&...> _MutexTuple;
+template <class... _MArgs>
+class _LIBCPP_TEMPLATE_VIS scoped_lock {
+  static_assert(sizeof...(_MArgs) > 1, "At least 2 lock types required");
+  typedef tuple<_MArgs&...> _MutexTuple;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit scoped_lock(_MArgs&... __margs)
-      : __t_(__margs...)
-    {
-        _VSTD::lock(__margs...);
-    }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(_MArgs&... __margs) : __t_(__margs...) {
+    std::lock(__margs...);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    scoped_lock(adopt_lock_t, _MArgs&... __margs)
-        : __t_(__margs...)
-    {
-    }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI scoped_lock(adopt_lock_t, _MArgs&... __margs) : __t_(__margs...) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~scoped_lock() {
-        typedef typename __make_tuple_indices<sizeof...(_MArgs)>::type _Indices;
-        __unlock_unpack(_Indices{}, __t_);
-    }
+  _LIBCPP_HIDE_FROM_ABI ~scoped_lock() {
+    typedef typename __make_tuple_indices<sizeof...(_MArgs)>::type _Indices;
+    __unlock_unpack(_Indices{}, __t_);
+  }
 
-    scoped_lock(scoped_lock const&) = delete;
-    scoped_lock& operator=(scoped_lock const&) = delete;
+  scoped_lock(scoped_lock const&)            = delete;
+  scoped_lock& operator=(scoped_lock const&) = delete;
 
 private:
-    template <size_t ..._Indx>
-    _LIBCPP_INLINE_VISIBILITY
-    static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) {
-        _VSTD::__unlock(_VSTD::get<_Indx>(__mt)...);
-    }
+  template <size_t... _Indx>
+  _LIBCPP_HIDE_FROM_ABI static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) {
+    (std::get<_Indx>(__mt).unlock(), ...);
+  }
 
-    _MutexTuple __t_;
+  _MutexTuple __t_;
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scoped_lock);
 
-#endif // _LIBCPP_STD_VER >= 17
-#endif // !_LIBCPP_HAS_NO_THREADS
-
-struct _LIBCPP_TEMPLATE_VIS once_flag;
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template<class _Callable, class... _Args>
-_LIBCPP_INLINE_VISIBILITY
-void call_once(once_flag&, _Callable&&, _Args&&...);
-
-#else  // _LIBCPP_CXX03_LANG
-
-template<class _Callable>
-_LIBCPP_INLINE_VISIBILITY
-void call_once(once_flag&, _Callable&);
-
-template<class _Callable>
-_LIBCPP_INLINE_VISIBILITY
-void call_once(once_flag&, const _Callable&);
-
-#endif // _LIBCPP_CXX03_LANG
-
-struct _LIBCPP_TEMPLATE_VIS once_flag
-{
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR
-        once_flag() _NOEXCEPT : __state_(0) {}
-    once_flag(const once_flag&) = delete;
-    once_flag& operator=(const once_flag&) = delete;
-
-#if defined(_LIBCPP_ABI_MICROSOFT)
-   typedef uintptr_t _State_type;
-#else
-   typedef unsigned long _State_type;
-#endif
-
-private:
-    _State_type __state_;
-
-#ifndef _LIBCPP_CXX03_LANG
-    template<class _Callable, class... _Args>
-    friend
-    void call_once(once_flag&, _Callable&&, _Args&&...);
-#else  // _LIBCPP_CXX03_LANG
-    template<class _Callable>
-    friend
-    void call_once(once_flag&, _Callable&);
-
-    template<class _Callable>
-    friend
-    void call_once(once_flag&, const _Callable&);
-#endif // _LIBCPP_CXX03_LANG
-};
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Fp>
-class __call_once_param
-{
-    _Fp& __f_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __call_once_param(_Fp& __f) : __f_(__f) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()()
-    {
-        typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
-        __execute(_Index());
-    }
-
-private:
-    template <size_t ..._Indices>
-    _LIBCPP_INLINE_VISIBILITY
-    void __execute(__tuple_indices<_Indices...>)
-    {
-        _VSTD::__invoke(_VSTD::get<0>(_VSTD::move(__f_)), _VSTD::get<_Indices>(_VSTD::move(__f_))...);
-    }
-};
-
-#else
-
-template <class _Fp>
-class __call_once_param
-{
-    _Fp& __f_;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __call_once_param(_Fp& __f) : __f_(__f) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()()
-    {
-        __f_();
-    }
-};
-
-#endif
-
-template <class _Fp>
-void _LIBCPP_INLINE_VISIBILITY
-__call_once_proxy(void* __vp)
-{
-    __call_once_param<_Fp>* __p = static_cast<__call_once_param<_Fp>*>(__vp);
-    (*__p)();
-}
-
-_LIBCPP_FUNC_VIS void __call_once(volatile once_flag::_State_type&, void*,
-                                  void (*)(void*));
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template<class _Callable, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
-{
-    if (__libcpp_acquire_load(&__flag.__state_) != ~once_flag::_State_type(0))
-    {
-        typedef tuple<_Callable&&, _Args&&...> _Gp;
-        _Gp __f(_VSTD::forward<_Callable>(__func), _VSTD::forward<_Args>(__args)...);
-        __call_once_param<_Gp> __p(__f);
-        std::__call_once(__flag.__state_, &__p, &__call_once_proxy<_Gp>);
-    }
-}
-
-#else  // _LIBCPP_CXX03_LANG
-
-template<class _Callable>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-call_once(once_flag& __flag, _Callable& __func)
-{
-    if (__libcpp_acquire_load(&__flag.__state_) != ~once_flag::_State_type(0))
-    {
-        __call_once_param<_Callable> __p(__func);
-        std::__call_once(__flag.__state_, &__p, &__call_once_proxy<_Callable>);
-    }
-}
-
-template<class _Callable>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-call_once(once_flag& __flag, const _Callable& __func)
-{
-    if (__libcpp_acquire_load(&__flag.__state_) != ~once_flag::_State_type(0))
-    {
-        __call_once_param<const _Callable> __p(__func);
-        std::__call_once(__flag.__state_, &__p, &__call_once_proxy<const _Callable>);
-    }
-}
-
-#endif // _LIBCPP_CXX03_LANG
+#  endif // _LIBCPP_STD_VER >= 17
+#endif   // !_LIBCPP_HAS_NO_THREADS
 
 _LIBCPP_END_NAMESPACE_STD
 
@@ -716,6 +505,7 @@ _LIBCPP_POP_MACROS
 #  include <cstring>
 #  include <ctime>
 #  include <initializer_list>
+#  include <iosfwd>
 #  include <new>
 #  include <stdexcept>
 #  include <system_error>
diff --git a/third_party/libcxx/mutex.cpp b/third_party/libcxx/mutex.cpp
new file mode 100644
index 000000000..9f003addd
--- /dev/null
+++ b/third_party/libcxx/mutex.cpp
@@ -0,0 +1,145 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__assert>
+#include <__thread/id.h>
+#include <__utility/exception_guard.h>
+#include <limits>
+#include <mutex>
+
+#include "atomic_support.h"
+
+#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#  pragma comment(lib, "pthread")
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// ~mutex is defined elsewhere
+
+void mutex::lock() {
+  int ec = __libcpp_mutex_lock(&__m_);
+  if (ec)
+    __throw_system_error(ec, "mutex lock failed");
+}
+
+bool mutex::try_lock() noexcept { return __libcpp_mutex_trylock(&__m_); }
+
+void mutex::unlock() noexcept {
+  int ec = __libcpp_mutex_unlock(&__m_);
+  (void)ec;
+  _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(
+      ec == 0, "call to mutex::unlock failed. A possible reason is that the mutex wasn't locked");
+}
+
+// recursive_mutex
+
+recursive_mutex::recursive_mutex() {
+  int ec = __libcpp_recursive_mutex_init(&__m_);
+  if (ec)
+    __throw_system_error(ec, "recursive_mutex constructor failed");
+}
+
+recursive_mutex::~recursive_mutex() {
+  int e = __libcpp_recursive_mutex_destroy(&__m_);
+  (void)e;
+  _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(e == 0, "call to ~recursive_mutex() failed");
+}
+
+void recursive_mutex::lock() {
+  int ec = __libcpp_recursive_mutex_lock(&__m_);
+  if (ec)
+    __throw_system_error(ec, "recursive_mutex lock failed");
+}
+
+void recursive_mutex::unlock() noexcept {
+  int e = __libcpp_recursive_mutex_unlock(&__m_);
+  (void)e;
+  _LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(
+      e == 0, "call to recursive_mutex::unlock() failed. A possible reason is that the mutex wasn't locked");
+}
+
+bool recursive_mutex::try_lock() noexcept { return __libcpp_recursive_mutex_trylock(&__m_); }
+
+// timed_mutex
+
+timed_mutex::timed_mutex() : __locked_(false) {}
+
+timed_mutex::~timed_mutex() { lock_guard<mutex> _(__m_); }
+
+void timed_mutex::lock() {
+  unique_lock<mutex> lk(__m_);
+  while (__locked_)
+    __cv_.wait(lk);
+  __locked_ = true;
+}
+
+bool timed_mutex::try_lock() noexcept {
+  unique_lock<mutex> lk(__m_, try_to_lock);
+  if (lk.owns_lock() && !__locked_) {
+    __locked_ = true;
+    return true;
+  }
+  return false;
+}
+
+void timed_mutex::unlock() noexcept {
+  lock_guard<mutex> _(__m_);
+  __locked_ = false;
+  __cv_.notify_one();
+}
+
+// recursive_timed_mutex
+
+recursive_timed_mutex::recursive_timed_mutex() : __count_(0), __id_{} {}
+
+recursive_timed_mutex::~recursive_timed_mutex() { lock_guard<mutex> _(__m_); }
+
+void recursive_timed_mutex::lock() {
+  __thread_id id = this_thread::get_id();
+  unique_lock<mutex> lk(__m_);
+  if (id == __id_) {
+    if (__count_ == numeric_limits<size_t>::max())
+      __throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
+    ++__count_;
+    return;
+  }
+  while (__count_ != 0)
+    __cv_.wait(lk);
+  __count_ = 1;
+  __id_    = id;
+}
+
+bool recursive_timed_mutex::try_lock() noexcept {
+  __thread_id id = this_thread::get_id();
+  unique_lock<mutex> lk(__m_, try_to_lock);
+  if (lk.owns_lock() && (__count_ == 0 || id == __id_)) {
+    if (__count_ == numeric_limits<size_t>::max())
+      return false;
+    ++__count_;
+    __id_ = id;
+    return true;
+  }
+  return false;
+}
+
+void recursive_timed_mutex::unlock() noexcept {
+  unique_lock<mutex> lk(__m_);
+  if (--__count_ == 0) {
+    __id_.__reset();
+    lk.unlock();
+    __cv_.notify_one();
+  }
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/mutex_destructor.cpp b/third_party/libcxx/mutex_destructor.cpp
new file mode 100644
index 000000000..a6ceaaaf2
--- /dev/null
+++ b/third_party/libcxx/mutex_destructor.cpp
@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Define ~mutex.
+//
+// On some platforms ~mutex has been made trivial and the definition is only
+// provided for ABI compatibility.
+//
+// In order to avoid ODR violations within libc++ itself, we need to ensure
+// that *nothing* sees the non-trivial mutex declaration. For this reason
+// we re-declare the entire class in this file instead of using
+// _LIBCPP_BUILDING_LIBRARY to change the definition in the headers.
+
+#include <__config>
+#include <__thread/support.h>
+
+#if _LIBCPP_ABI_VERSION == 1 || !defined(_LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION)
+#  define NEEDS_MUTEX_DESTRUCTOR
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifdef NEEDS_MUTEX_DESTRUCTOR
+class _LIBCPP_EXPORTED_FROM_ABI mutex {
+  __libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
+
+public:
+  _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI constexpr mutex() = default;
+  mutex(const mutex&)                                           = delete;
+  mutex& operator=(const mutex&)                                = delete;
+  ~mutex() noexcept;
+};
+
+mutex::~mutex() noexcept { __libcpp_mutex_destroy(&__m_); }
+#endif // !NEEDS_MUTEX_DESTRUCTOR
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/new b/third_party/libcxx/new
index af396cd4b..c32e7a5a4 100644
--- a/third_party/libcxx/new
+++ b/third_party/libcxx/new
@@ -10,6 +10,8 @@
 #ifndef _LIBCPP_NEW
 #define _LIBCPP_NEW
 
+#pragma GCC diagnostic ignored "-Walloc-size-larger-than="
+
 /*
     new synopsis
 
@@ -46,7 +48,7 @@ new_handler set_new_handler(new_handler new_p) noexcept;
 new_handler get_new_handler() noexcept;
 
 // 21.6.4, pointer optimization barrier
-template <class T> constexpr T* launder(T* p) noexcept; // C++17
+template <class T> [[nodiscard]] constexpr T* launder(T* p) noexcept;   // C++17, nodiscard since C++20
 }  // std
 
 void* operator new(std::size_t size);                                   // replaceable, nodiscard in C++20
@@ -86,69 +88,65 @@ void  operator delete[](void* ptr, void*) noexcept;
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__availability>
 #include <__config>
 #include <__exception/exception.h>
-#include <__type_traits/alignment_of.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cv.h>
 #include <__verbose_abort>
 #include <cstddef>
-#include <cstdlib>
 #include <version>
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
-#include <new.h>
+#  include <new.h>
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-#if !defined(__cpp_sized_deallocation) || __cpp_sized_deallocation  < 201309L
-#define _LIBCPP_HAS_NO_LANGUAGE_SIZED_DEALLOCATION
+#if !defined(__cpp_sized_deallocation) || __cpp_sized_deallocation < 201309L
+#  define _LIBCPP_HAS_NO_LANGUAGE_SIZED_DEALLOCATION
 #endif
 
-#if !defined(_LIBCPP_BUILDING_LIBRARY) && _LIBCPP_STD_VER < 14 && \
-    defined(_LIBCPP_HAS_NO_LANGUAGE_SIZED_DEALLOCATION)
-# define _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
+#if !defined(_LIBCPP_BUILDING_LIBRARY) && _LIBCPP_STD_VER < 14 && defined(_LIBCPP_HAS_NO_LANGUAGE_SIZED_DEALLOCATION)
+#  define _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
 #endif
 
-#if defined(_LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION) || \
-    defined(_LIBCPP_HAS_NO_LANGUAGE_SIZED_DEALLOCATION)
-# define _LIBCPP_HAS_NO_SIZED_DEALLOCATION
+#if defined(_LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION) || defined(_LIBCPP_HAS_NO_LANGUAGE_SIZED_DEALLOCATION)
+#  define _LIBCPP_HAS_NO_SIZED_DEALLOCATION
 #endif
 
-namespace std  // purposefully not using versioning namespace
+namespace std // purposefully not using versioning namespace
 {
 
 #if !defined(_LIBCPP_ABI_VCRUNTIME)
-struct _LIBCPP_TYPE_VIS nothrow_t { explicit nothrow_t() = default; };
-extern _LIBCPP_FUNC_VIS const nothrow_t nothrow;
+struct _LIBCPP_EXPORTED_FROM_ABI nothrow_t {
+  explicit nothrow_t() = default;
+};
+extern _LIBCPP_EXPORTED_FROM_ABI const nothrow_t nothrow;
 
-class _LIBCPP_EXCEPTION_ABI bad_alloc
-    : public exception
-{
+class _LIBCPP_EXPORTED_FROM_ABI bad_alloc : public exception {
 public:
-    bad_alloc() _NOEXCEPT;
-    ~bad_alloc() _NOEXCEPT override;
-    const char* what() const _NOEXCEPT override;
+  bad_alloc() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI bad_alloc(const bad_alloc&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_alloc& operator=(const bad_alloc&) _NOEXCEPT = default;
+  ~bad_alloc() _NOEXCEPT override;
+  const char* what() const _NOEXCEPT override;
 };
 
-class _LIBCPP_EXCEPTION_ABI bad_array_new_length
-    : public bad_alloc
-{
+class _LIBCPP_EXPORTED_FROM_ABI bad_array_new_length : public bad_alloc {
 public:
-    bad_array_new_length() _NOEXCEPT;
-    ~bad_array_new_length() _NOEXCEPT override;
-    const char* what() const _NOEXCEPT override;
+  bad_array_new_length() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI bad_array_new_length(const bad_array_new_length&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_array_new_length& operator=(const bad_array_new_length&) _NOEXCEPT = default;
+  ~bad_array_new_length() _NOEXCEPT override;
+  const char* what() const _NOEXCEPT override;
 };
 
 typedef void (*new_handler)();
-_LIBCPP_FUNC_VIS new_handler set_new_handler(new_handler) _NOEXCEPT;
-_LIBCPP_FUNC_VIS new_handler get_new_handler() _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI new_handler set_new_handler(new_handler) _NOEXCEPT;
+_LIBCPP_EXPORTED_FROM_ABI new_handler get_new_handler() _NOEXCEPT;
 
 #elif defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS == 0 // !_LIBCPP_ABI_VCRUNTIME
 
@@ -170,25 +168,22 @@ public:
 };
 #endif // defined(_LIBCPP_ABI_VCRUNTIME) && defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS == 0
 
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_bad_alloc();  // not in C++ spec
+_LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_bad_alloc(); // not in C++ spec
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_bad_array_new_length()
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_bad_array_new_length() {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw bad_array_new_length();
+  throw bad_array_new_length();
 #else
-    _LIBCPP_VERBOSE_ABORT("bad_array_new_length was thrown in -fno-exceptions mode");
+  _LIBCPP_VERBOSE_ABORT("bad_array_new_length was thrown in -fno-exceptions mode");
 #endif
 }
 
-#if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) && \
-    !defined(_LIBCPP_ABI_VCRUNTIME)
-#ifndef _LIBCPP_CXX03_LANG
-enum class _LIBCPP_ENUM_VIS align_val_t : size_t { };
-#else
+#if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION) && !defined(_LIBCPP_ABI_VCRUNTIME)
+#  ifndef _LIBCPP_CXX03_LANG
+enum class align_val_t : size_t {};
+#  else
 enum align_val_t { __zero = 0, __max = (size_t)-1 };
-#endif
+#  endif
 #endif
 
 #if _LIBCPP_STD_VER >= 20
@@ -203,77 +198,81 @@ inline constexpr destroying_delete_t destroying_delete{};
 } // namespace std
 
 #if defined(_LIBCPP_CXX03_LANG)
-#define _THROW_BAD_ALLOC throw(std::bad_alloc)
+#  define _THROW_BAD_ALLOC throw(std::bad_alloc)
 #else
-#define _THROW_BAD_ALLOC
+#  define _THROW_BAD_ALLOC
 #endif
 
 #if !defined(_LIBCPP_ABI_VCRUNTIME)
 
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz) _THROW_BAD_ALLOC;
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _LIBCPP_NOALIAS;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p) _NOEXCEPT;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT;
-#ifndef _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
-_LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE void  operator delete(void* __p, std::size_t __sz) _NOEXCEPT;
-#endif
+_LIBCPP_NODISCARD _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz) _THROW_BAD_ALLOC;
+_LIBCPP_NODISCARD _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT
+    _LIBCPP_NOALIAS;
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p) _NOEXCEPT;
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT;
+#  ifndef _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::size_t __sz) _NOEXCEPT;
+#  endif
 
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz) _THROW_BAD_ALLOC;
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT _LIBCPP_NOALIAS;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete[](void* __p) _NOEXCEPT;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT;
-#ifndef _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
-_LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE void  operator delete[](void* __p, std::size_t __sz) _NOEXCEPT;
-#endif
+_LIBCPP_NODISCARD _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz) _THROW_BAD_ALLOC;
+_LIBCPP_NODISCARD _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT
+    _LIBCPP_NOALIAS;
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p) _NOEXCEPT;
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT;
+#  ifndef _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::size_t __sz) _NOEXCEPT;
+#  endif
 
-#ifndef _LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, std::align_val_t) _THROW_BAD_ALLOC;
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _LIBCPP_NOALIAS;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p, std::align_val_t) _NOEXCEPT;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete(void* __p, std::align_val_t, const std::nothrow_t&) _NOEXCEPT;
-#ifndef _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
-_LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE void  operator delete(void* __p, std::size_t __sz, std::align_val_t) _NOEXCEPT;
-#endif
+#  ifndef _LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
+_LIBCPP_NODISCARD _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new(std::size_t __sz, std::align_val_t) _THROW_BAD_ALLOC;
+_LIBCPP_NODISCARD _LIBCPP_OVERRIDABLE_FUNC_VIS void*
+operator new(std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _LIBCPP_NOALIAS;
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::align_val_t) _NOEXCEPT;
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::align_val_t, const std::nothrow_t&) _NOEXCEPT;
+#    ifndef _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::size_t __sz, std::align_val_t) _NOEXCEPT;
+#    endif
 
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz, std::align_val_t) _THROW_BAD_ALLOC;
-_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_OVERRIDABLE_FUNC_VIS void* operator new[](std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _LIBCPP_NOALIAS;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete[](void* __p, std::align_val_t) _NOEXCEPT;
-_LIBCPP_OVERRIDABLE_FUNC_VIS void  operator delete[](void* __p, std::align_val_t, const std::nothrow_t&) _NOEXCEPT;
-#ifndef _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
-_LIBCPP_OVERRIDABLE_FUNC_VIS _LIBCPP_AVAILABILITY_SIZED_NEW_DELETE void  operator delete[](void* __p, std::size_t __sz, std::align_val_t) _NOEXCEPT;
-#endif
-#endif
+_LIBCPP_NODISCARD _LIBCPP_OVERRIDABLE_FUNC_VIS void*
+operator new[](std::size_t __sz, std::align_val_t) _THROW_BAD_ALLOC;
+_LIBCPP_NODISCARD _LIBCPP_OVERRIDABLE_FUNC_VIS void*
+operator new[](std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _LIBCPP_NOALIAS;
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::align_val_t) _NOEXCEPT;
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::align_val_t, const std::nothrow_t&) _NOEXCEPT;
+#    ifndef _LIBCPP_HAS_NO_LIBRARY_SIZED_DEALLOCATION
+_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::size_t __sz, std::align_val_t) _NOEXCEPT;
+#    endif
+#  endif
 
-_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY void* operator new  (std::size_t, void* __p) _NOEXCEPT {return __p;}
-_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;}
-inline _LIBCPP_INLINE_VISIBILITY void  operator delete  (void*, void*) _NOEXCEPT {}
-inline _LIBCPP_INLINE_VISIBILITY void  operator delete[](void*, void*) _NOEXCEPT {}
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI void* operator new(std::size_t, void* __p) _NOEXCEPT { return __p; }
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI void* operator new[](std::size_t, void* __p) _NOEXCEPT { return __p; }
+inline _LIBCPP_HIDE_FROM_ABI void operator delete(void*, void*) _NOEXCEPT {}
+inline _LIBCPP_HIDE_FROM_ABI void operator delete[](void*, void*) _NOEXCEPT {}
 
 #endif // !_LIBCPP_ABI_VCRUNTIME
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-_LIBCPP_CONSTEXPR inline _LIBCPP_INLINE_VISIBILITY bool __is_overaligned_for_new(size_t __align) _NOEXCEPT {
+_LIBCPP_CONSTEXPR inline _LIBCPP_HIDE_FROM_ABI bool __is_overaligned_for_new(size_t __align) _NOEXCEPT {
 #ifdef __STDCPP_DEFAULT_NEW_ALIGNMENT__
   return __align > __STDCPP_DEFAULT_NEW_ALIGNMENT__;
 #else
-  return __align > alignment_of<max_align_t>::value;
+  return __align > _LIBCPP_ALIGNOF(max_align_t);
 #endif
 }
 
-template <class ..._Args>
-_LIBCPP_INLINE_VISIBILITY
-void* __libcpp_operator_new(_Args ...__args) {
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void* __libcpp_operator_new(_Args... __args) {
 #if __has_builtin(__builtin_operator_new) && __has_builtin(__builtin_operator_delete)
   return __builtin_operator_new(__args...);
 #else
+
   return ::operator new(__args...);
 #endif
 }
 
-template <class ..._Args>
-_LIBCPP_INLINE_VISIBILITY
-void __libcpp_operator_delete(_Args ...__args) {
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void __libcpp_operator_delete(_Args... __args) {
 #if __has_builtin(__builtin_operator_new) && __has_builtin(__builtin_operator_delete)
   __builtin_operator_delete(__args...);
 #else
@@ -281,8 +280,7 @@ void __libcpp_operator_delete(_Args ...__args) {
 #endif
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-void *__libcpp_allocate(size_t __size, size_t __align) {
+inline _LIBCPP_HIDE_FROM_ABI void* __libcpp_allocate(size_t __size, size_t __align) {
 #ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
   if (__is_overaligned_for_new(__align)) {
     const align_val_t __align_val = static_cast<align_val_t>(__align);
@@ -294,9 +292,8 @@ void *__libcpp_allocate(size_t __size, size_t __align) {
   return __libcpp_operator_new(__size);
 }
 
-template <class ..._Args>
-_LIBCPP_INLINE_VISIBILITY
-void __do_deallocate_handle_size(void *__ptr, size_t __size, _Args ...__args) {
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void __do_deallocate_handle_size(void* __ptr, size_t __size, _Args... __args) {
 #ifdef _LIBCPP_HAS_NO_SIZED_DEALLOCATION
   (void)__size;
   return std::__libcpp_operator_delete(__ptr, __args...);
@@ -305,68 +302,63 @@ void __do_deallocate_handle_size(void *__ptr, size_t __size, _Args ...__args) {
 #endif
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-void __libcpp_deallocate(void* __ptr, size_t __size, size_t __align) {
+inline _LIBCPP_HIDE_FROM_ABI void __libcpp_deallocate(void* __ptr, size_t __size, size_t __align) {
 #if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
-    (void)__align;
+  (void)__align;
+  return __do_deallocate_handle_size(__ptr, __size);
+#else
+  if (__is_overaligned_for_new(__align)) {
+    const align_val_t __align_val = static_cast<align_val_t>(__align);
+    return __do_deallocate_handle_size(__ptr, __size, __align_val);
+  } else {
     return __do_deallocate_handle_size(__ptr, __size);
-#else
-    if (__is_overaligned_for_new(__align)) {
-      const align_val_t __align_val = static_cast<align_val_t>(__align);
-      return __do_deallocate_handle_size(__ptr, __size, __align_val);
-    } else {
-      return __do_deallocate_handle_size(__ptr, __size);
-    }
+  }
 #endif
 }
 
-inline _LIBCPP_INLINE_VISIBILITY void __libcpp_deallocate_unsized(void* __ptr, size_t __align) {
+inline _LIBCPP_HIDE_FROM_ABI void __libcpp_deallocate_unsized(void* __ptr, size_t __align) {
 #if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION)
-    (void)__align;
-    return __libcpp_operator_delete(__ptr);
+  (void)__align;
+  return __libcpp_operator_delete(__ptr);
 #else
-    if (__is_overaligned_for_new(__align)) {
-      const align_val_t __align_val = static_cast<align_val_t>(__align);
-      return __libcpp_operator_delete(__ptr, __align_val);
-    } else {
-      return __libcpp_operator_delete(__ptr);
-    }
+  if (__is_overaligned_for_new(__align)) {
+    const align_val_t __align_val = static_cast<align_val_t>(__align);
+    return __libcpp_operator_delete(__ptr, __align_val);
+  } else {
+    return __libcpp_operator_delete(__ptr);
+  }
 #endif
 }
 
 template <class _Tp>
-_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI
-_LIBCPP_CONSTEXPR _Tp* __launder(_Tp* __p) _NOEXCEPT
-{
-    static_assert (!(is_function<_Tp>::value), "can't launder functions" );
-    static_assert (!(is_same<void, __remove_cv_t<_Tp> >::value), "can't launder cv-void" );
-    return __builtin_launder(__p);
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* __launder(_Tp* __p) _NOEXCEPT {
+  static_assert(!(is_function<_Tp>::value), "can't launder functions");
+  static_assert(!(is_same<void, __remove_cv_t<_Tp> >::value), "can't launder cv-void");
+  return __builtin_launder(__p);
 }
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
-_LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_HIDE_FROM_ABI
-constexpr _Tp* launder(_Tp* __p) noexcept
-{
-    return _VSTD::__launder(__p);
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp* launder(_Tp* __p) noexcept {
+  return std::__launder(__p);
 }
 #endif
 
 #if _LIBCPP_STD_VER >= 17
 
-#if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
+#  if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
 
-inline constexpr size_t hardware_destructive_interference_size = __GCC_DESTRUCTIVE_SIZE;
+inline constexpr size_t hardware_destructive_interference_size  = __GCC_DESTRUCTIVE_SIZE;
 inline constexpr size_t hardware_constructive_interference_size = __GCC_CONSTRUCTIVE_SIZE;
 
-#endif // defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
+#  endif // defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-#  include <exception>
+#  include <cstdlib>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/new.cpp b/third_party/libcxx/new.cpp
new file mode 100644
index 000000000..f97f459fe
--- /dev/null
+++ b/third_party/libcxx/new.cpp
@@ -0,0 +1,226 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "overridable_function.h"
+#include <__assert>
+#include <__memory/aligned_alloc.h>
+#include <cstddef>
+#include <cstdlib>
+#include <new>
+
+#if !defined(__GLIBCXX__) && !defined(_LIBCPP_ABI_VCRUNTIME)
+
+// The code below is copied as-is into libc++abi's libcxxabi/src/stdlib_new_delete.cpp
+// file. The version in this file is the canonical one.
+
+inline void __throw_bad_alloc_shim() { std::__throw_bad_alloc(); }
+
+#  define _LIBCPP_ASSERT_SHIM(expr, str) _LIBCPP_ASSERT(expr, str)
+
+// ------------------ BEGIN COPY ------------------
+// Implement all new and delete operators as weak definitions
+// in this shared library, so that they can be overridden by programs
+// that define non-weak copies of the functions.
+
+static void* operator_new_impl(std::size_t size) {
+  if (size == 0)
+    size = 1;
+  void* p;
+  while ((p = std::malloc(size)) == nullptr) {
+    // If malloc fails and there is a new_handler,
+    // call it to try free up memory.
+    std::new_handler nh = std::get_new_handler();
+    if (nh)
+      nh();
+    else
+      break;
+  }
+  return p;
+}
+
+_LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE _LIBCPP_WEAK void* operator new(std::size_t size) _THROW_BAD_ALLOC {
+  void* p = operator_new_impl(size);
+  if (p == nullptr)
+    __throw_bad_alloc_shim();
+  return p;
+}
+
+_LIBCPP_WEAK void* operator new(size_t size, const std::nothrow_t&) noexcept {
+#  ifdef _LIBCPP_HAS_NO_EXCEPTIONS
+#    if _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION
+  _LIBCPP_ASSERT_SHIM(
+      !std::__is_function_overridden(static_cast<void* (*)(std::size_t)>(&operator new)),
+      "libc++ was configured with exceptions disabled and `operator new(size_t)` has been overridden, "
+      "but `operator new(size_t, nothrow_t)` has not been overridden. This is problematic because "
+      "`operator new(size_t, nothrow_t)` must call `operator new(size_t)`, which will terminate in case "
+      "it fails to allocate, making it impossible for `operator new(size_t, nothrow_t)` to fulfill its "
+      "contract (since it should return nullptr upon failure). Please make sure you override "
+      "`operator new(size_t, nothrow_t)` as well.");
+#    endif
+
+  return operator_new_impl(size);
+#  else
+  void* p = nullptr;
+  try {
+    p = ::operator new(size);
+  } catch (...) {
+  }
+  return p;
+#  endif
+}
+
+_LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE _LIBCPP_WEAK void* operator new[](size_t size) _THROW_BAD_ALLOC {
+  return ::operator new(size);
+}
+
+_LIBCPP_WEAK void* operator new[](size_t size, const std::nothrow_t&) noexcept {
+#  ifdef _LIBCPP_HAS_NO_EXCEPTIONS
+#    if _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION
+  _LIBCPP_ASSERT_SHIM(
+      !std::__is_function_overridden(static_cast<void* (*)(std::size_t)>(&operator new[])),
+      "libc++ was configured with exceptions disabled and `operator new[](size_t)` has been overridden, "
+      "but `operator new[](size_t, nothrow_t)` has not been overridden. This is problematic because "
+      "`operator new[](size_t, nothrow_t)` must call `operator new[](size_t)`, which will terminate in case "
+      "it fails to allocate, making it impossible for `operator new[](size_t, nothrow_t)` to fulfill its "
+      "contract (since it should return nullptr upon failure). Please make sure you override "
+      "`operator new[](size_t, nothrow_t)` as well.");
+#    endif
+
+  return operator_new_impl(size);
+#  else
+  void* p = nullptr;
+  try {
+    p = ::operator new[](size);
+  } catch (...) {
+  }
+  return p;
+#  endif
+}
+
+_LIBCPP_WEAK void operator delete(void* ptr) noexcept { std::free(ptr); }
+
+_LIBCPP_WEAK void operator delete(void* ptr, const std::nothrow_t&) noexcept { ::operator delete(ptr); }
+
+_LIBCPP_WEAK void operator delete(void* ptr, size_t) noexcept { ::operator delete(ptr); }
+
+_LIBCPP_WEAK void operator delete[](void* ptr) noexcept { ::operator delete(ptr); }
+
+_LIBCPP_WEAK void operator delete[](void* ptr, const std::nothrow_t&) noexcept { ::operator delete[](ptr); }
+
+_LIBCPP_WEAK void operator delete[](void* ptr, size_t) noexcept { ::operator delete[](ptr); }
+
+#  if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
+
+static void* operator_new_aligned_impl(std::size_t size, std::align_val_t alignment) {
+  if (size == 0)
+    size = 1;
+  if (static_cast<size_t>(alignment) < sizeof(void*))
+    alignment = std::align_val_t(sizeof(void*));
+
+  // Try allocating memory. If allocation fails and there is a new_handler,
+  // call it to try free up memory, and try again until it succeeds, or until
+  // the new_handler decides to terminate.
+  void* p;
+  while ((p = std::__libcpp_aligned_alloc(static_cast<std::size_t>(alignment), size)) == nullptr) {
+    std::new_handler nh = std::get_new_handler();
+    if (nh)
+      nh();
+    else
+      break;
+  }
+  return p;
+}
+
+_LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE _LIBCPP_WEAK void*
+operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC {
+  void* p = operator_new_aligned_impl(size, alignment);
+  if (p == nullptr)
+    __throw_bad_alloc_shim();
+  return p;
+}
+
+_LIBCPP_WEAK void* operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept {
+#    ifdef _LIBCPP_HAS_NO_EXCEPTIONS
+#      if _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION
+  _LIBCPP_ASSERT_SHIM(
+      !std::__is_function_overridden(static_cast<void* (*)(std::size_t, std::align_val_t)>(&operator new)),
+      "libc++ was configured with exceptions disabled and `operator new(size_t, align_val_t)` has been overridden, "
+      "but `operator new(size_t, align_val_t, nothrow_t)` has not been overridden. This is problematic because "
+      "`operator new(size_t, align_val_t, nothrow_t)` must call `operator new(size_t, align_val_t)`, which will "
+      "terminate in case it fails to allocate, making it impossible for `operator new(size_t, align_val_t, nothrow_t)` "
+      "to fulfill its contract (since it should return nullptr upon failure). Please make sure you override "
+      "`operator new(size_t, align_val_t, nothrow_t)` as well.");
+#      endif
+
+  return operator_new_aligned_impl(size, alignment);
+#    else
+  void* p = nullptr;
+  try {
+    p = ::operator new(size, alignment);
+  } catch (...) {
+  }
+  return p;
+#    endif
+}
+
+_LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE _LIBCPP_WEAK void*
+operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC {
+  return ::operator new(size, alignment);
+}
+
+_LIBCPP_WEAK void* operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept {
+#    ifdef _LIBCPP_HAS_NO_EXCEPTIONS
+#      if _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION
+  _LIBCPP_ASSERT_SHIM(
+      !std::__is_function_overridden(static_cast<void* (*)(std::size_t, std::align_val_t)>(&operator new[])),
+      "libc++ was configured with exceptions disabled and `operator new[](size_t, align_val_t)` has been overridden, "
+      "but `operator new[](size_t, align_val_t, nothrow_t)` has not been overridden. This is problematic because "
+      "`operator new[](size_t, align_val_t, nothrow_t)` must call `operator new[](size_t, align_val_t)`, which will "
+      "terminate in case it fails to allocate, making it impossible for `operator new[](size_t, align_val_t, "
+      "nothrow_t)` to fulfill its contract (since it should return nullptr upon failure). Please make sure you "
+      "override "
+      "`operator new[](size_t, align_val_t, nothrow_t)` as well.");
+#      endif
+
+  return operator_new_aligned_impl(size, alignment);
+#    else
+  void* p = nullptr;
+  try {
+    p = ::operator new[](size, alignment);
+  } catch (...) {
+  }
+  return p;
+#    endif
+}
+
+_LIBCPP_WEAK void operator delete(void* ptr, std::align_val_t) noexcept { std::__libcpp_aligned_free(ptr); }
+
+_LIBCPP_WEAK void operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept {
+  ::operator delete(ptr, alignment);
+}
+
+_LIBCPP_WEAK void operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept {
+  ::operator delete(ptr, alignment);
+}
+
+_LIBCPP_WEAK void operator delete[](void* ptr, std::align_val_t alignment) noexcept {
+  ::operator delete(ptr, alignment);
+}
+
+_LIBCPP_WEAK void operator delete[](void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept {
+  ::operator delete[](ptr, alignment);
+}
+
+_LIBCPP_WEAK void operator delete[](void* ptr, size_t, std::align_val_t alignment) noexcept {
+  ::operator delete[](ptr, alignment);
+}
+
+#  endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
+// ------------------ END COPY ------------------
+
+#endif // !__GLIBCXX__ && !_LIBCPP_ABI_VCRUNTIME
diff --git a/third_party/libcxx/new_handler.cpp b/third_party/libcxx/new_handler.cpp
new file mode 100644
index 000000000..62d8f66ba
--- /dev/null
+++ b/third_party/libcxx/new_handler.cpp
@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <new>
+
+#include "atomic_support.h"
+
+#if defined(_LIBCPP_ABI_MICROSOFT)
+#  if !defined(_LIBCPP_ABI_VCRUNTIME)
+#    define _LIBPCPP_DEFINE_NEW_HANDLER
+#  endif
+#elif defined(LIBCXX_BUILDING_LIBCXXABI)
+// nothing to do, we use the one from libc++abi
+#elif defined(LIBCXXRT)
+#  define _LIBPCPP_DEFINE_NEW_HANDLER
+#elif defined(__GLIBCXX__)
+// nothing to do, we use the one from libstdc++/libsupc++
+#else
+#  define _LIBPCPP_DEFINE_NEW_HANDLER
+#endif
+
+#if defined(_LIBPCPP_DEFINE_NEW_HANDLER)
+
+namespace std { // purposefully not versioned
+
+static constinit std::new_handler __new_handler = nullptr;
+
+new_handler set_new_handler(new_handler handler) noexcept { return __libcpp_atomic_exchange(&__new_handler, handler); }
+
+new_handler get_new_handler() noexcept { return __libcpp_atomic_load(&__new_handler); }
+
+} // namespace std
+
+#endif // _LIBPCPP_DEFINE_NEW_HANDLER
diff --git a/third_party/libcxx/new_helpers.cpp b/third_party/libcxx/new_helpers.cpp
new file mode 100644
index 000000000..6560d0188
--- /dev/null
+++ b/third_party/libcxx/new_helpers.cpp
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__verbose_abort>
+#include <new>
+
+namespace std { // purposefully not versioned
+
+#ifndef __GLIBCXX__
+const nothrow_t nothrow{};
+#endif
+
+#ifndef LIBSTDCXX
+
+void __throw_bad_alloc() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw bad_alloc();
+#  else
+  _LIBCPP_VERBOSE_ABORT("bad_alloc was thrown in -fno-exceptions mode");
+#  endif
+}
+
+#endif // !LIBSTDCXX
+
+} // namespace std
diff --git a/third_party/libcxx/numbers b/third_party/libcxx/numbers
index ec9eea5df..f48ba4baf 100644
--- a/third_party/libcxx/numbers
+++ b/third_party/libcxx/numbers
@@ -58,16 +58,15 @@ namespace std::numbers {
 }
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__concepts/arithmetic.h>
 #include <__config>
 #include <version>
 
 #if _LIBCPP_STD_VER >= 20
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -77,38 +76,65 @@ template <class _Tp>
 inline constexpr bool __false = false;
 
 template <class _Tp>
-struct __illformed
-{
-  static_assert(__false<_Tp>, "A program that instantiates a primary template of a mathematical constant variable template is ill-formed.");
+struct __illformed {
+  static_assert(
+      __false<_Tp>,
+      "A program that instantiates a primary template of a mathematical constant variable template is ill-formed.");
 };
 
-template <class _Tp> inline constexpr _Tp e_v =          __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp log2e_v =      __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp log10e_v =     __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp pi_v =         __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp inv_pi_v =     __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp inv_sqrtpi_v = __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp ln2_v =        __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp ln10_v =       __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp sqrt2_v =      __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp sqrt3_v =      __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp inv_sqrt3_v =  __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp egamma_v =     __illformed<_Tp>{};
-template <class _Tp> inline constexpr _Tp phi_v =        __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp e_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp log2e_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp log10e_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp pi_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp inv_pi_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp inv_sqrtpi_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp ln2_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp ln10_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp sqrt2_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp sqrt3_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp inv_sqrt3_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp egamma_v = __illformed<_Tp>{};
+template <class _Tp>
+inline constexpr _Tp phi_v = __illformed<_Tp>{};
 
-template <floating_point _Tp> inline constexpr _Tp e_v<_Tp>          = 2.718281828459045235360287471352662;
-template <floating_point _Tp> inline constexpr _Tp log2e_v<_Tp>      = 1.442695040888963407359924681001892;
-template <floating_point _Tp> inline constexpr _Tp log10e_v<_Tp>     = 0.434294481903251827651128918916605;
-template <floating_point _Tp> inline constexpr _Tp pi_v<_Tp>         = 3.141592653589793238462643383279502;
-template <floating_point _Tp> inline constexpr _Tp inv_pi_v<_Tp>     = 0.318309886183790671537767526745028;
-template <floating_point _Tp> inline constexpr _Tp inv_sqrtpi_v<_Tp> = 0.564189583547756286948079451560772;
-template <floating_point _Tp> inline constexpr _Tp ln2_v<_Tp>        = 0.693147180559945309417232121458176;
-template <floating_point _Tp> inline constexpr _Tp ln10_v<_Tp>       = 2.302585092994045684017991454684364;
-template <floating_point _Tp> inline constexpr _Tp sqrt2_v<_Tp>      = 1.414213562373095048801688724209698;
-template <floating_point _Tp> inline constexpr _Tp sqrt3_v<_Tp>      = 1.732050807568877293527446341505872;
-template <floating_point _Tp> inline constexpr _Tp inv_sqrt3_v<_Tp>  = 0.577350269189625764509148780501957;
-template <floating_point _Tp> inline constexpr _Tp egamma_v<_Tp>     = 0.577215664901532860606512090082402;
-template <floating_point _Tp> inline constexpr _Tp phi_v<_Tp>        = 1.618033988749894848204586834365638;
+template <floating_point _Tp>
+inline constexpr _Tp e_v<_Tp> = 2.718281828459045235360287471352662;
+template <floating_point _Tp>
+inline constexpr _Tp log2e_v<_Tp> = 1.442695040888963407359924681001892;
+template <floating_point _Tp>
+inline constexpr _Tp log10e_v<_Tp> = 0.434294481903251827651128918916605;
+template <floating_point _Tp>
+inline constexpr _Tp pi_v<_Tp> = 3.141592653589793238462643383279502;
+template <floating_point _Tp>
+inline constexpr _Tp inv_pi_v<_Tp> = 0.318309886183790671537767526745028;
+template <floating_point _Tp>
+inline constexpr _Tp inv_sqrtpi_v<_Tp> = 0.564189583547756286948079451560772;
+template <floating_point _Tp>
+inline constexpr _Tp ln2_v<_Tp> = 0.693147180559945309417232121458176;
+template <floating_point _Tp>
+inline constexpr _Tp ln10_v<_Tp> = 2.302585092994045684017991454684364;
+template <floating_point _Tp>
+inline constexpr _Tp sqrt2_v<_Tp> = 1.414213562373095048801688724209698;
+template <floating_point _Tp>
+inline constexpr _Tp sqrt3_v<_Tp> = 1.732050807568877293527446341505872;
+template <floating_point _Tp>
+inline constexpr _Tp inv_sqrt3_v<_Tp> = 0.577350269189625764509148780501957;
+template <floating_point _Tp>
+inline constexpr _Tp egamma_v<_Tp> = 0.577215664901532860606512090082402;
+template <floating_point _Tp>
+inline constexpr _Tp phi_v<_Tp> = 1.618033988749894848204586834365638;
 
 inline constexpr double e          = e_v<double>;
 inline constexpr double log2e      = log2e_v<double>;
diff --git a/third_party/libcxx/numeric b/third_party/libcxx/numeric
index 5d7f25c2e..6b92ce3a0 100644
--- a/third_party/libcxx/numeric
+++ b/third_party/libcxx/numeric
@@ -140,37 +140,67 @@ template<class T>
 template<class T>
     constexpr T* midpoint(T* a, T* b);        // C++20
 
+// [numeric.sat], saturation arithmetic
+template<class T>
+constexpr T add_sat(T x, T y) noexcept;                     // freestanding, Since C++26
+template<class T>
+constexpr T sub_sat(T x, T y) noexcept;                     // freestanding, Since C++26
+template<class T>
+constexpr T mul_sat(T x, T y) noexcept;                     // freestanding, Since C++26
+template<class T>
+constexpr T div_sat(T x, T y) noexcept;                     // freestanding, Since C++26
+template<class T, class U>
+constexpr T saturate_cast(U x) noexcept;                    // freestanding, Since C++26
+
 }  // std
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <cmath> // for isnormal
-#include <version>
 
 #include <__numeric/accumulate.h>
 #include <__numeric/adjacent_difference.h>
-#include <__numeric/exclusive_scan.h>
-#include <__numeric/gcd_lcm.h>
-#include <__numeric/inclusive_scan.h>
 #include <__numeric/inner_product.h>
 #include <__numeric/iota.h>
-#include <__numeric/midpoint.h>
 #include <__numeric/partial_sum.h>
-#include <__numeric/reduce.h>
-#include <__numeric/transform_exclusive_scan.h>
-#include <__numeric/transform_inclusive_scan.h>
-#include <__numeric/transform_reduce.h>
+
+#if _LIBCPP_STD_VER >= 17
+#  include <__numeric/exclusive_scan.h>
+#  include <__numeric/gcd_lcm.h>
+#  include <__numeric/inclusive_scan.h>
+#  include <__numeric/pstl.h>
+#  include <__numeric/reduce.h>
+#  include <__numeric/transform_exclusive_scan.h>
+#  include <__numeric/transform_inclusive_scan.h>
+#  include <__numeric/transform_reduce.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__numeric/midpoint.h>
+#  include <__numeric/saturation_arithmetic.h>
+#endif
+
+#include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 14
+#  include <initializer_list>
+#  include <limits>
+#endif
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <climits>
+#  include <cmath>
 #  include <concepts>
+#  include <cstdint>
+#  include <execution>
 #  include <functional>
 #  include <iterator>
+#  include <new>
+#  include <optional>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/optional b/third_party/libcxx/optional
index 68fb4c914..f9cbcbfa5 100644
--- a/third_party/libcxx/optional
+++ b/third_party/libcxx/optional
@@ -136,12 +136,12 @@ namespace std {
     void swap(optional &) noexcept(see below ); // constexpr in C++20
 
     // [optional.observe], observers
-    constexpr T const *operator->() const;
-    constexpr T *operator->();
-    constexpr T const &operator*() const &;
-    constexpr T &operator*() &;
-    constexpr T &&operator*() &&;
-    constexpr const T &&operator*() const &&;
+    constexpr T const *operator->() const noexcept;
+    constexpr T *operator->() noexcept;
+    constexpr T const &operator*() const & noexcept;
+    constexpr T &operator*() & noexcept;
+    constexpr T &&operator*() && noexcept;
+    constexpr const T &&operator*() const && noexcept;
     constexpr explicit operator bool() const noexcept;
     constexpr bool has_value() const noexcept;
     constexpr T const &value() const &;
@@ -177,16 +177,16 @@ namespace std {
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__availability>
+#include <__assert>
 #include <__compare/compare_three_way_result.h>
 #include <__compare/three_way_comparable.h>
 #include <__concepts/invocable.h>
 #include <__config>
+#include <__exception/exception.h>
 #include <__functional/hash.h>
 #include <__functional/invoke.h>
-#include <__functional/reference_wrapper.h>
 #include <__functional/unary_function.h>
+#include <__fwd/functional.h>
 #include <__memory/addressof.h>
 #include <__memory/construct_at.h>
 #include <__tuple/sfinae_helpers.h>
@@ -199,22 +199,17 @@ namespace std {
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
-#include <__type_traits/is_copy_assignable.h>
-#include <__type_traits/is_copy_constructible.h>
 #include <__type_traits/is_destructible.h>
-#include <__type_traits/is_move_assignable.h>
-#include <__type_traits/is_move_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_object.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_scalar.h>
 #include <__type_traits/is_swappable.h>
-#include <__type_traits/is_trivially_copy_assignable.h>
-#include <__type_traits/is_trivially_copy_constructible.h>
+#include <__type_traits/is_trivially_assignable.h>
+#include <__type_traits/is_trivially_constructible.h>
 #include <__type_traits/is_trivially_destructible.h>
-#include <__type_traits/is_trivially_move_assignable.h>
-#include <__type_traits/is_trivially_move_constructible.h>
+#include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/negation.h>
 #include <__type_traits/remove_const.h>
 #include <__type_traits/remove_cvref.h>
@@ -227,7 +222,6 @@ namespace std {
 #include <__verbose_abort>
 #include <initializer_list>
 #include <new>
-#include <stdexcept>
 #include <version>
 
 // standard-mandated includes
@@ -239,16 +233,20 @@ namespace std {
 #  pragma GCC system_header
 #endif
 
-namespace std  // purposefully not using versioning namespace
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+namespace std // purposefully not using versioning namespace
 {
 
-class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
-    : public exception
-{
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access : public exception {
 public:
-    // Get the key function ~bad_optional_access() into the dylib
-    ~bad_optional_access() _NOEXCEPT override;
-    const char* what() const _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI bad_optional_access() _NOEXCEPT                                      = default;
+  _LIBCPP_HIDE_FROM_ABI bad_optional_access(const bad_optional_access&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_optional_access& operator=(const bad_optional_access&) _NOEXCEPT = default;
+  // Get the key function ~bad_optional_access() into the dylib
+  ~bad_optional_access() _NOEXCEPT override;
+  const char* what() const _NOEXCEPT override;
 };
 
 } // namespace std
@@ -257,21 +255,20 @@ public:
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-_LIBCPP_NORETURN
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-void __throw_bad_optional_access() {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        throw bad_optional_access();
-#else
-    _LIBCPP_VERBOSE_ABORT("bad_optional_access was thrown in -fno-exceptions mode");
-#endif
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS void
+__throw_bad_optional_access() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw bad_optional_access();
+#  else
+  _LIBCPP_VERBOSE_ABORT("bad_optional_access was thrown in -fno-exceptions mode");
+#  endif
 }
 
-struct nullopt_t
-{
-    struct __secret_tag { explicit __secret_tag() = default; };
-    _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {}
+struct nullopt_t {
+  struct __secret_tag {
+    explicit __secret_tag() = default;
+  };
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {}
 };
 
 inline constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}};
@@ -282,1401 +279,1018 @@ template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
 struct __optional_destruct_base;
 
 template <class _Tp>
-struct __optional_destruct_base<_Tp, false>
-{
-    typedef _Tp value_type;
-    static_assert(is_object_v<value_type>,
-        "instantiation of optional with a non-object type is undefined behavior");
-    union
-    {
-        char __null_state_;
-        value_type __val_;
-    };
-    bool __engaged_;
+struct __optional_destruct_base<_Tp, false> {
+  typedef _Tp value_type;
+  static_assert(is_object_v<value_type>, "instantiation of optional with a non-object type is undefined behavior");
+  union {
+    char __null_state_;
+    value_type __val_;
+  };
+  bool __engaged_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__optional_destruct_base()
-    {
-        if (__engaged_)
-            __val_.~value_type();
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__optional_destruct_base() {
+    if (__engaged_)
+      __val_.~value_type();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr __optional_destruct_base() noexcept
-        :  __null_state_(),
-           __engaged_(false) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base() noexcept : __null_state_(), __engaged_(false) {}
 
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
-        :  __val_(_VSTD::forward<_Args>(__args)...),
-           __engaged_(true) {}
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
+      : __val_(std::forward<_Args>(__args)...), __engaged_(true) {}
 
-#if _LIBCPP_STD_VER >= 23
+#  if _LIBCPP_STD_VER >= 23
   template <class _Fp, class... _Args>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
-      : __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {}
-#endif
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base(
+      __optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
+      : __val_(std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...)), __engaged_(true) {}
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept
-    {
-        if (__engaged_)
-        {
-            __val_.~value_type();
-            __engaged_ = false;
-        }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept {
+    if (__engaged_) {
+      __val_.~value_type();
+      __engaged_ = false;
     }
+  }
 };
 
 template <class _Tp>
-struct __optional_destruct_base<_Tp, true>
-{
-    typedef _Tp value_type;
-    static_assert(is_object_v<value_type>,
-        "instantiation of optional with a non-object type is undefined behavior");
-    union
-    {
-        char __null_state_;
-        value_type __val_;
-    };
-    bool __engaged_;
+struct __optional_destruct_base<_Tp, true> {
+  typedef _Tp value_type;
+  static_assert(is_object_v<value_type>, "instantiation of optional with a non-object type is undefined behavior");
+  union {
+    char __null_state_;
+    value_type __val_;
+  };
+  bool __engaged_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr __optional_destruct_base() noexcept
-        :  __null_state_(),
-           __engaged_(false) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base() noexcept : __null_state_(), __engaged_(false) {}
 
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
-        :  __val_(_VSTD::forward<_Args>(__args)...),
-           __engaged_(true) {}
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
+      : __val_(std::forward<_Args>(__args)...), __engaged_(true) {}
 
-#if _LIBCPP_STD_VER >= 23
+#  if _LIBCPP_STD_VER >= 23
   template <class _Fp, class... _Args>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr __optional_destruct_base(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
-      : __val_(_VSTD::invoke(_VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...)), __engaged_(true) {}
-#endif
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_destruct_base(
+      __optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
+      : __val_(std::invoke(std::forward<_Fp>(__f), std::forward<_Args>(__args)...)), __engaged_(true) {}
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept
-    {
-        if (__engaged_)
-        {
-            __engaged_ = false;
-        }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept {
+    if (__engaged_) {
+      __engaged_ = false;
     }
+  }
 };
 
 template <class _Tp, bool = is_reference<_Tp>::value>
-struct __optional_storage_base : __optional_destruct_base<_Tp>
-{
-    using __base = __optional_destruct_base<_Tp>;
-    using value_type = _Tp;
-    using __base::__base;
+struct __optional_storage_base : __optional_destruct_base<_Tp> {
+  using __base     = __optional_destruct_base<_Tp>;
+  using value_type = _Tp;
+  using __base::__base;
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr bool has_value() const noexcept
-    {
-        return this->__engaged_;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return this->__engaged_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type& __get() & noexcept
-    {
-        return this->__val_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr const value_type& __get() const& noexcept
-    {
-        return this->__val_;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type&& __get() && noexcept
-    {
-        return _VSTD::move(this->__val_);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr const value_type&& __get() const&& noexcept
-    {
-        return _VSTD::move(this->__val_);
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type& __get() & noexcept { return this->__val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr const value_type& __get() const& noexcept { return this->__val_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type&& __get() && noexcept { return std::move(this->__val_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr const value_type&& __get() const&& noexcept { return std::move(this->__val_); }
 
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_Args&&... __args)
-    {
-        _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
-#if _LIBCPP_STD_VER >= 20
-        _VSTD::construct_at(_VSTD::addressof(this->__val_), _VSTD::forward<_Args>(__args)...);
-#else
-        ::new ((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
-#endif
-        this->__engaged_ = true;
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_Args&&... __args) {
+    _LIBCPP_ASSERT_INTERNAL(!has_value(), "__construct called for engaged __optional_storage");
+    std::__construct_at(std::addressof(this->__val_), std::forward<_Args>(__args)...);
+    this->__engaged_ = true;
+  }
 
-    template <class _That>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_from(_That&& __opt)
-    {
-        if (__opt.has_value())
-            __construct(_VSTD::forward<_That>(__opt).__get());
-    }
+  template <class _That>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_from(_That&& __opt) {
+    if (__opt.has_value())
+      __construct(std::forward<_That>(__opt).__get());
+  }
 
-    template <class _That>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_from(_That&& __opt)
-    {
-        if (this->__engaged_ == __opt.has_value())
-        {
-            if (this->__engaged_)
-                this->__val_ = _VSTD::forward<_That>(__opt).__get();
-        }
-        else
-        {
-            if (this->__engaged_)
-                this->reset();
-            else
-                __construct(_VSTD::forward<_That>(__opt).__get());
-        }
+  template <class _That>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_from(_That&& __opt) {
+    if (this->__engaged_ == __opt.has_value()) {
+      if (this->__engaged_)
+        this->__val_ = std::forward<_That>(__opt).__get();
+    } else {
+      if (this->__engaged_)
+        this->reset();
+      else
+        __construct(std::forward<_That>(__opt).__get());
     }
+  }
 };
 
 // optional<T&> is currently required to be ill-formed. However, it may
 // be allowed in the future. For this reason, it has already been implemented
 // to ensure we can make the change in an ABI-compatible manner.
 template <class _Tp>
-struct __optional_storage_base<_Tp, true>
-{
-    using value_type = _Tp;
-    using __raw_type = remove_reference_t<_Tp>;
-    __raw_type* __value_;
+struct __optional_storage_base<_Tp, true> {
+  using value_type = _Tp;
+  using __raw_type = remove_reference_t<_Tp>;
+  __raw_type* __value_;
 
-    template <class _Up>
-    static _LIBCPP_HIDE_FROM_ABI constexpr bool __can_bind_reference() {
-        using _RawUp = __libcpp_remove_reference_t<_Up>;
-        using _UpPtr = _RawUp*;
-        using _RawTp = __libcpp_remove_reference_t<_Tp>;
-        using _TpPtr = _RawTp*;
-        using _CheckLValueArg = integral_constant<bool,
-            (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value)
-        ||  is_same<_RawUp, reference_wrapper<_RawTp>>::value
-        ||  is_same<_RawUp, reference_wrapper<__remove_const_t<_RawTp>>>::value
-        >;
-        return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value)
-            || (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value &&
-                is_convertible<_UpPtr, _TpPtr>::value);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr __optional_storage_base() noexcept
-        :  __value_(nullptr) {}
-
-    template <class _UArg>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg)
-        :  __value_(_VSTD::addressof(__uarg))
-    {
-      static_assert(__can_bind_reference<_UArg>(),
-        "Attempted to construct a reference element in tuple from a "
-        "possible temporary");
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept { __value_ = nullptr; }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr bool has_value() const noexcept
-      { return __value_ != nullptr; }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type& __get() const& noexcept
-      { return *__value_; }
-
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type&& __get() const&& noexcept
-      { return _VSTD::forward<value_type>(*__value_); }
-
-    template <class _UArg>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_UArg&& __val)
-    {
-        _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
-        static_assert(__can_bind_reference<_UArg>(),
-            "Attempted to construct a reference element in tuple from a "
-            "possible temporary");
-        __value_ = _VSTD::addressof(__val);
-    }
-
-    template <class _That>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_from(_That&& __opt)
-    {
-        if (__opt.has_value())
-            __construct(_VSTD::forward<_That>(__opt).__get());
-    }
-
-    template <class _That>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_from(_That&& __opt)
-    {
-        if (has_value() == __opt.has_value())
-        {
-            if (has_value())
-                *__value_ = _VSTD::forward<_That>(__opt).__get();
-        }
-        else
-        {
-            if (has_value())
-                reset();
-            else
-                __construct(_VSTD::forward<_That>(__opt).__get());
-        }
+  template <class _Up>
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __can_bind_reference() {
+    using _RawUp = __libcpp_remove_reference_t<_Up>;
+    using _UpPtr = _RawUp*;
+    using _RawTp = __libcpp_remove_reference_t<_Tp>;
+    using _TpPtr = _RawTp*;
+    using _CheckLValueArg =
+        integral_constant<bool,
+                          (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value) ||
+                              is_same<_RawUp, reference_wrapper<_RawTp>>::value ||
+                              is_same<_RawUp, reference_wrapper<__remove_const_t<_RawTp>>>::value >;
+    return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value) ||
+           (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value &&
+            is_convertible<_UpPtr, _TpPtr>::value);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_storage_base() noexcept : __value_(nullptr) {}
+
+  template <class _UArg>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg)
+      : __value_(std::addressof(__uarg)) {
+    static_assert(__can_bind_reference<_UArg>(),
+                  "Attempted to construct a reference element in tuple from a "
+                  "possible temporary");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept { __value_ = nullptr; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __value_ != nullptr; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type& __get() const& noexcept { return *__value_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type&& __get() const&& noexcept { return std::forward<value_type>(*__value_); }
+
+  template <class _UArg>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_UArg&& __val) {
+    _LIBCPP_ASSERT_INTERNAL(!has_value(), "__construct called for engaged __optional_storage");
+    static_assert(__can_bind_reference<_UArg>(),
+                  "Attempted to construct a reference element in tuple from a "
+                  "possible temporary");
+    __value_ = std::addressof(__val);
+  }
+
+  template <class _That>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_from(_That&& __opt) {
+    if (__opt.has_value())
+      __construct(std::forward<_That>(__opt).__get());
+  }
+
+  template <class _That>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_from(_That&& __opt) {
+    if (has_value() == __opt.has_value()) {
+      if (has_value())
+        *__value_ = std::forward<_That>(__opt).__get();
+    } else {
+      if (has_value())
+        reset();
+      else
+        __construct(std::forward<_That>(__opt).__get());
     }
+  }
 };
 
 template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value>
-struct __optional_copy_base : __optional_storage_base<_Tp>
-{
-    using __optional_storage_base<_Tp>::__optional_storage_base;
+struct __optional_copy_base : __optional_storage_base<_Tp> {
+  using __optional_storage_base<_Tp>::__optional_storage_base;
 };
 
 template <class _Tp>
-struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp>
-{
-    using __optional_storage_base<_Tp>::__optional_storage_base;
+struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp> {
+  using __optional_storage_base<_Tp>::__optional_storage_base;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_base() = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_copy_base() = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_copy_base(const __optional_copy_base& __opt)
-    {
-        this->__construct_from(__opt);
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_copy_base(const __optional_copy_base& __opt) {
+    this->__construct_from(__opt);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_base(__optional_copy_base&&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_base& operator=(const __optional_copy_base&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_base& operator=(__optional_copy_base&&) = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_copy_base(__optional_copy_base&&)                 = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_copy_base& operator=(const __optional_copy_base&) = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_copy_base& operator=(__optional_copy_base&&)      = default;
 };
 
 template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value>
-struct __optional_move_base : __optional_copy_base<_Tp>
-{
-    using __optional_copy_base<_Tp>::__optional_copy_base;
+struct __optional_move_base : __optional_copy_base<_Tp> {
+  using __optional_copy_base<_Tp>::__optional_copy_base;
 };
 
 template <class _Tp>
-struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp>
-{
-    using value_type = _Tp;
-    using __optional_copy_base<_Tp>::__optional_copy_base;
+struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp> {
+  using value_type = _Tp;
+  using __optional_copy_base<_Tp>::__optional_copy_base;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_base() = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_base(const __optional_move_base&) = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_move_base()                            = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_move_base(const __optional_move_base&) = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_move_base(__optional_move_base&& __opt)
-        noexcept(is_nothrow_move_constructible_v<value_type>)
-    {
-        this->__construct_from(_VSTD::move(__opt));
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  __optional_move_base(__optional_move_base&& __opt) noexcept(is_nothrow_move_constructible_v<value_type>) {
+    this->__construct_from(std::move(__opt));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_base& operator=(const __optional_move_base&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_base& operator=(__optional_move_base&&) = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_move_base& operator=(const __optional_move_base&) = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_move_base& operator=(__optional_move_base&&)      = default;
 };
 
-template <class _Tp, bool =
-    is_trivially_destructible<_Tp>::value &&
-    is_trivially_copy_constructible<_Tp>::value &&
-    is_trivially_copy_assignable<_Tp>::value>
-struct __optional_copy_assign_base : __optional_move_base<_Tp>
-{
-    using __optional_move_base<_Tp>::__optional_move_base;
+template <class _Tp,
+          bool = is_trivially_destructible<_Tp>::value && is_trivially_copy_constructible<_Tp>::value &&
+                 is_trivially_copy_assignable<_Tp>::value>
+struct __optional_copy_assign_base : __optional_move_base<_Tp> {
+  using __optional_move_base<_Tp>::__optional_move_base;
 };
 
 template <class _Tp>
-struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp>
-{
-    using __optional_move_base<_Tp>::__optional_move_base;
+struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp> {
+  using __optional_move_base<_Tp>::__optional_move_base;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_assign_base() = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base()                                   = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base(__optional_copy_assign_base&&)      = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt)
-    {
-        this->__assign_from(__opt);
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_copy_assign_base&
+  operator=(const __optional_copy_assign_base& __opt) {
+    this->__assign_from(__opt);
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
 };
 
-template <class _Tp, bool =
-    is_trivially_destructible<_Tp>::value &&
-    is_trivially_move_constructible<_Tp>::value &&
-    is_trivially_move_assignable<_Tp>::value>
-struct __optional_move_assign_base : __optional_copy_assign_base<_Tp>
-{
-    using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
+template <class _Tp,
+          bool = is_trivially_destructible<_Tp>::value && is_trivially_move_constructible<_Tp>::value &&
+                 is_trivially_move_assignable<_Tp>::value>
+struct __optional_move_assign_base : __optional_copy_assign_base<_Tp> {
+  using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
 };
 
 template <class _Tp>
-struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp>
-{
-    using value_type = _Tp;
-    using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
+struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp> {
+  using value_type = _Tp;
+  using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_assign_base() = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_assign_base(__optional_move_assign_base&&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base()                                              = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base(const __optional_move_assign_base& __opt)      = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base(__optional_move_assign_base&&)                 = default;
+  _LIBCPP_HIDE_FROM_ABI __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt)
-        noexcept(is_nothrow_move_assignable_v<value_type> &&
-                 is_nothrow_move_constructible_v<value_type>)
-    {
-        this->__assign_from(_VSTD::move(__opt));
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __optional_move_assign_base&
+  operator=(__optional_move_assign_base&& __opt) noexcept(
+      is_nothrow_move_assignable_v<value_type> && is_nothrow_move_constructible_v<value_type>) {
+    this->__assign_from(std::move(__opt));
+    return *this;
+  }
 };
 
 template <class _Tp>
-using __optional_sfinae_ctor_base_t = __sfinae_ctor_base<
-    is_copy_constructible<_Tp>::value,
-    is_move_constructible<_Tp>::value
->;
+using __optional_sfinae_ctor_base_t =
+    __sfinae_ctor_base< is_copy_constructible<_Tp>::value, is_move_constructible<_Tp>::value >;
 
 template <class _Tp>
-using __optional_sfinae_assign_base_t = __sfinae_assign_base<
-    (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value),
-    (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value)
->;
+using __optional_sfinae_assign_base_t =
+    __sfinae_assign_base< (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value),
+                          (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value) >;
 
-template<class _Tp>
+template <class _Tp>
 class optional;
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
 
 template <class _Tp>
-concept __is_derived_from_optional = requires(const _Tp& __t) { []<class __Up>(const optional<__Up>&) {}(__t); };
+concept __is_derived_from_optional = requires(const _Tp& __t) { []<class _Up>(const optional<_Up>&) {}(__t); };
 
 #  endif // _LIBCPP_STD_VER >= 20
 
 template <class _Tp>
 struct __is_std_optional : false_type {};
-template <class _Tp> struct __is_std_optional<optional<_Tp>> : true_type {};
+template <class _Tp>
+struct __is_std_optional<optional<_Tp>> : true_type {};
 
 template <class _Tp>
 class _LIBCPP_DECLSPEC_EMPTY_BASES optional
-    : private __optional_move_assign_base<_Tp>
-    , private __optional_sfinae_ctor_base_t<_Tp>
-    , private __optional_sfinae_assign_base_t<_Tp>
-{
-    using __base = __optional_move_assign_base<_Tp>;
+    : private __optional_move_assign_base<_Tp>,
+      private __optional_sfinae_ctor_base_t<_Tp>,
+      private __optional_sfinae_assign_base_t<_Tp> {
+  using __base = __optional_move_assign_base<_Tp>;
+
 public:
-    using value_type = _Tp;
+  using value_type = _Tp;
+
+  using __trivially_relocatable = conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, optional, void>;
 
 private:
-     // Disable the reference extension using this static assert.
-    static_assert(!is_same_v<__remove_cvref_t<value_type>, in_place_t>,
-        "instantiation of optional with in_place_t is ill-formed");
-    static_assert(!is_same_v<__remove_cvref_t<value_type>, nullopt_t>,
-        "instantiation of optional with nullopt_t is ill-formed");
-    static_assert(!is_reference_v<value_type>,
-        "instantiation of optional with a reference type is ill-formed");
-    static_assert(is_destructible_v<value_type>,
-        "instantiation of optional with a non-destructible type is ill-formed");
-    static_assert(!is_array_v<value_type>,
-        "instantiation of optional with an array type is ill-formed");
+  // Disable the reference extension using this static assert.
+  static_assert(!is_same_v<__remove_cvref_t<value_type>, in_place_t>,
+                "instantiation of optional with in_place_t is ill-formed");
+  static_assert(!is_same_v<__remove_cvref_t<value_type>, nullopt_t>,
+                "instantiation of optional with nullopt_t is ill-formed");
+  static_assert(!is_reference_v<value_type>, "instantiation of optional with a reference type is ill-formed");
+  static_assert(is_destructible_v<value_type>, "instantiation of optional with a non-destructible type is ill-formed");
+  static_assert(!is_array_v<value_type>, "instantiation of optional with an array type is ill-formed");
 
-    // LWG2756: conditionally explicit conversion from _Up
-    struct _CheckOptionalArgsConstructor {
-      template <class _Up>
-      _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_implicit() {
-          return is_constructible_v<_Tp, _Up&&> &&
-                 is_convertible_v<_Up&&, _Tp>;
-      }
-
-      template <class _Up>
-      _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_explicit() {
-          return is_constructible_v<_Tp, _Up&&> &&
-                 !is_convertible_v<_Up&&, _Tp>;
-      }
-    };
+  // LWG2756: conditionally explicit conversion from _Up
+  struct _CheckOptionalArgsConstructor {
     template <class _Up>
-    using _CheckOptionalArgsCtor = _If<
-        _IsNotSame<__remove_cvref_t<_Up>, in_place_t>::value &&
-        _IsNotSame<__remove_cvref_t<_Up>, optional>::value,
-        _CheckOptionalArgsConstructor,
-        __check_tuple_constructor_fail
-    >;
-    template <class _QualUp>
-    struct _CheckOptionalLikeConstructor {
-      template <class _Up, class _Opt = optional<_Up>>
-      using __check_constructible_from_opt = _Or<
-          is_constructible<_Tp, _Opt&>,
-          is_constructible<_Tp, _Opt const&>,
-          is_constructible<_Tp, _Opt&&>,
-          is_constructible<_Tp, _Opt const&&>,
-          is_convertible<_Opt&, _Tp>,
-          is_convertible<_Opt const&, _Tp>,
-          is_convertible<_Opt&&, _Tp>,
-          is_convertible<_Opt const&&, _Tp>
-      >;
-      template <class _Up, class _Opt = optional<_Up>>
-      using __check_assignable_from_opt = _Or<
-          is_assignable<_Tp&, _Opt&>,
-          is_assignable<_Tp&, _Opt const&>,
-          is_assignable<_Tp&, _Opt&&>,
-          is_assignable<_Tp&, _Opt const&&>
-      >;
-      template <class _Up, class _QUp = _QualUp>
-      _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_implicit() {
-          return is_convertible<_QUp, _Tp>::value &&
-              !__check_constructible_from_opt<_Up>::value;
-      }
-      template <class _Up, class _QUp = _QualUp>
-      _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_explicit() {
-          return !is_convertible<_QUp, _Tp>::value &&
-              !__check_constructible_from_opt<_Up>::value;
-      }
-      template <class _Up, class _QUp = _QualUp>
-      _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_assign() {
-          // Construction and assignability of _QUp to _Tp has already been
-          // checked.
-          return !__check_constructible_from_opt<_Up>::value &&
-              !__check_assignable_from_opt<_Up>::value;
-      }
-    };
+    _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_implicit() {
+      return is_constructible_v<_Tp, _Up&&> && is_convertible_v<_Up&&, _Tp>;
+    }
 
-    template <class _Up, class _QualUp>
-    using _CheckOptionalLikeCtor = _If<
-      _And<
-         _IsNotSame<_Up, _Tp>,
-          is_constructible<_Tp, _QualUp>
-      >::value,
-      _CheckOptionalLikeConstructor<_QualUp>,
-      __check_tuple_constructor_fail
-    >;
-    template <class _Up, class _QualUp>
-    using _CheckOptionalLikeAssign = _If<
-      _And<
-          _IsNotSame<_Up, _Tp>,
-          is_constructible<_Tp, _QualUp>,
-          is_assignable<_Tp&, _QualUp>
-      >::value,
-      _CheckOptionalLikeConstructor<_QualUp>,
-      __check_tuple_constructor_fail
-    >;
+    template <class _Up>
+    _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_explicit() {
+      return is_constructible_v<_Tp, _Up&&> && !is_convertible_v<_Up&&, _Tp>;
+    }
+  };
+  template <class _Up>
+  using _CheckOptionalArgsCtor =
+      _If< _IsNotSame<__remove_cvref_t<_Up>, in_place_t>::value && _IsNotSame<__remove_cvref_t<_Up>, optional>::value &&
+               (!is_same_v<remove_cv_t<_Tp>, bool> || !__is_std_optional<__remove_cvref_t<_Up>>::value),
+           _CheckOptionalArgsConstructor,
+           __check_tuple_constructor_fail >;
+  template <class _QualUp>
+  struct _CheckOptionalLikeConstructor {
+    template <class _Up, class _Opt = optional<_Up>>
+    using __check_constructible_from_opt =
+        _Or< is_constructible<_Tp, _Opt&>,
+             is_constructible<_Tp, _Opt const&>,
+             is_constructible<_Tp, _Opt&&>,
+             is_constructible<_Tp, _Opt const&&>,
+             is_convertible<_Opt&, _Tp>,
+             is_convertible<_Opt const&, _Tp>,
+             is_convertible<_Opt&&, _Tp>,
+             is_convertible<_Opt const&&, _Tp> >;
+    template <class _Up, class _Opt = optional<_Up>>
+    using __check_assignable_from_opt =
+        _Or< is_assignable<_Tp&, _Opt&>,
+             is_assignable<_Tp&, _Opt const&>,
+             is_assignable<_Tp&, _Opt&&>,
+             is_assignable<_Tp&, _Opt const&&> >;
+    template <class _Up, class _QUp = _QualUp>
+    _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_implicit() {
+      return is_convertible<_QUp, _Tp>::value &&
+             (is_same_v<remove_cv_t<_Tp>, bool> || !__check_constructible_from_opt<_Up>::value);
+    }
+    template <class _Up, class _QUp = _QualUp>
+    _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_explicit() {
+      return !is_convertible<_QUp, _Tp>::value &&
+             (is_same_v<remove_cv_t<_Tp>, bool> || !__check_constructible_from_opt<_Up>::value);
+    }
+    template <class _Up, class _QUp = _QualUp>
+    _LIBCPP_HIDE_FROM_ABI static constexpr bool __enable_assign() {
+      // Construction and assignability of _QUp to _Tp has already been
+      // checked.
+      return !__check_constructible_from_opt<_Up>::value && !__check_assignable_from_opt<_Up>::value;
+    }
+  };
+
+  template <class _Up, class _QualUp>
+  using _CheckOptionalLikeCtor =
+      _If< _And< _IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp> >::value,
+           _CheckOptionalLikeConstructor<_QualUp>,
+           __check_tuple_constructor_fail >;
+  template <class _Up, class _QualUp>
+  using _CheckOptionalLikeAssign =
+      _If< _And< _IsNotSame<_Up, _Tp>, is_constructible<_Tp, _QualUp>, is_assignable<_Tp&, _QualUp> >::value,
+           _CheckOptionalLikeConstructor<_QualUp>,
+           __check_tuple_constructor_fail >;
 
 public:
+  _LIBCPP_HIDE_FROM_ABI constexpr optional() noexcept {}
+  _LIBCPP_HIDE_FROM_ABI constexpr optional(const optional&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr optional(optional&&)      = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr optional(nullopt_t) noexcept {}
 
-    _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
-    _LIBCPP_INLINE_VISIBILITY constexpr optional(const optional&) = default;
-    _LIBCPP_INLINE_VISIBILITY constexpr optional(optional&&) = default;
-    _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}
+  template <
+      class _InPlaceT,
+      class... _Args,
+      class = enable_if_t< _And< _IsSame<_InPlaceT, in_place_t>, is_constructible<value_type, _Args...> >::value > >
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_InPlaceT, _Args&&... __args)
+      : __base(in_place, std::forward<_Args>(__args)...) {}
 
-    template <class _InPlaceT, class... _Args, class = enable_if_t<
-          _And<
-              _IsSame<_InPlaceT, in_place_t>,
-              is_constructible<value_type, _Args...>
-            >::value
-        >
-    >
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit optional(_InPlaceT, _Args&&... __args)
-        : __base(in_place, _VSTD::forward<_Args>(__args)...) {}
+  template <class _Up,
+            class... _Args,
+            class = enable_if_t< is_constructible_v<value_type, initializer_list<_Up>&, _Args...>> >
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
+      : __base(in_place, __il, std::forward<_Args>(__args)...) {}
 
-    template <class _Up, class... _Args, class = enable_if_t<
-        is_constructible_v<value_type, initializer_list<_Up>&, _Args...>>
-    >
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
-        : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}
+  template <class _Up                                                                         = value_type,
+            enable_if_t< _CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI constexpr optional(_Up&& __v) : __base(in_place, std::forward<_Up>(__v)) {}
 
-    template <class _Up = value_type, enable_if_t<
-        _CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>()
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr optional(_Up&& __v)
-        : __base(in_place, _VSTD::forward<_Up>(__v)) {}
+  template <class _Up, enable_if_t< _CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Up&& __v) : __base(in_place, std::forward<_Up>(__v)) {}
 
-    template <class _Up, enable_if_t<
-        _CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>()
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit optional(_Up&& __v)
-        : __base(in_place, _VSTD::forward<_Up>(__v)) {}
-
-    // LWG2756: conditionally explicit conversion from const optional<_Up>&
-    template <class _Up, enable_if_t<
-        _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>()
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>& __v)
-    {
-        this->__construct_from(__v);
-    }
-    template <class _Up, enable_if_t<
-        _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>()
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(const optional<_Up>& __v)
-    {
-        this->__construct_from(__v);
-    }
-
-    // LWG2756: conditionally explicit conversion from optional<_Up>&&
-    template <class _Up, enable_if_t<
-        _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_implicit<_Up>()
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(optional<_Up>&& __v)
-    {
-        this->__construct_from(_VSTD::move(__v));
-    }
-    template <class _Up, enable_if_t<
-        _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>()
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v)
-    {
-        this->__construct_from(_VSTD::move(__v));
-    }
-
-#if _LIBCPP_STD_VER >= 23
-  template<class _Fp, class... _Args>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr explicit optional(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
-      : __base(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Fp>(__f), _VSTD::forward<_Args>(__args)...) {
+  // LWG2756: conditionally explicit conversion from const optional<_Up>&
+  template <class _Up,
+            enable_if_t< _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>& __v) {
+    this->__construct_from(__v);
+  }
+  template <class _Up,
+            enable_if_t< _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(const optional<_Up>& __v) {
+    this->__construct_from(__v);
   }
-#endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(nullopt_t) noexcept
-    {
+  // LWG2756: conditionally explicit conversion from optional<_Up>&&
+  template <class _Up, enable_if_t< _CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_implicit<_Up>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(optional<_Up>&& __v) {
+    this->__construct_from(std::move(__v));
+  }
+  template <class _Up, enable_if_t< _CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_explicit<_Up>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v) {
+    this->__construct_from(std::move(__v));
+  }
+
+#  if _LIBCPP_STD_VER >= 23
+  template <class _Fp, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(__optional_construct_from_invoke_tag, _Fp&& __f, _Args&&... __args)
+      : __base(__optional_construct_from_invoke_tag{}, std::forward<_Fp>(__f), std::forward<_Args>(__args)...) {}
+#  endif
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(nullopt_t) noexcept {
+    reset();
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(const optional&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(optional&&)      = default;
+
+  // LWG2756
+  template <
+      class _Up = value_type,
+      class     = enable_if_t< _And< _IsNotSame<__remove_cvref_t<_Up>, optional>,
+                                     _Or< _IsNotSame<__remove_cvref_t<_Up>, value_type>, _Not<is_scalar<value_type>> >,
+                                     is_constructible<value_type, _Up>,
+                                     is_assignable<value_type&, _Up> >::value> >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(_Up&& __v) {
+    if (this->has_value())
+      this->__get() = std::forward<_Up>(__v);
+    else
+      this->__construct(std::forward<_Up>(__v));
+    return *this;
+  }
+
+  // LWG2756
+  template <class _Up,
+            enable_if_t< _CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(const optional<_Up>& __v) {
+    this->__assign_from(__v);
+    return *this;
+  }
+
+  // LWG2756
+  template <class _Up, enable_if_t< _CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_assign<_Up>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(optional<_Up>&& __v) {
+    this->__assign_from(std::move(__v));
+    return *this;
+  }
+
+  template <class... _Args, class = enable_if_t< is_constructible_v<value_type, _Args...> > >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args) {
+    reset();
+    this->__construct(std::forward<_Args>(__args)...);
+    return this->__get();
+  }
+
+  template <class _Up,
+            class... _Args,
+            class = enable_if_t< is_constructible_v<value_type, initializer_list<_Up>&, _Args...> > >
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
+    reset();
+    this->__construct(__il, std::forward<_Args>(__args)...);
+    return this->__get();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  swap(optional& __opt) noexcept(is_nothrow_move_constructible_v<value_type> && is_nothrow_swappable_v<value_type>) {
+    if (this->has_value() == __opt.has_value()) {
+      using std::swap;
+      if (this->has_value())
+        swap(this->__get(), __opt.__get());
+    } else {
+      if (this->has_value()) {
+        __opt.__construct(std::move(this->__get()));
         reset();
-        return *this;
+      } else {
+        this->__construct(std::move(__opt.__get()));
+        __opt.reset();
+      }
     }
+  }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(const optional&) = default;
-    _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(optional&&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<value_type const> operator->() const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
+    return std::addressof(this->__get());
+  }
 
-    // LWG2756
-    template <class _Up = value_type,
-              class = enable_if_t<
-                      _And<
-                          _IsNotSame<__remove_cvref_t<_Up>, optional>,
-                          _Or<
-                              _IsNotSame<__remove_cvref_t<_Up>, value_type>,
-                              _Not<is_scalar<value_type>>
-                          >,
-                          is_constructible<value_type, _Up>,
-                          is_assignable<value_type&, _Up>
-                      >::value>
-             >
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 optional&
-    operator=(_Up&& __v)
-    {
-        if (this->has_value())
-            this->__get() = _VSTD::forward<_Up>(__v);
-        else
-            this->__construct(_VSTD::forward<_Up>(__v));
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<value_type> operator->() noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
+    return std::addressof(this->__get());
+  }
 
-    // LWG2756
-    template <class _Up, enable_if_t<
-        _CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>()
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 optional&
-    operator=(const optional<_Up>& __v)
-    {
-        this->__assign_from(__v);
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr const value_type& operator*() const& noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
+    return this->__get();
+  }
 
-    // LWG2756
-    template <class _Up, enable_if_t<
-        _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_assign<_Up>()
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 optional&
-    operator=(optional<_Up>&& __v)
-    {
-        this->__assign_from(_VSTD::move(__v));
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type& operator*() & noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
+    return this->__get();
+  }
 
-    template <class... _Args,
-              class = enable_if_t
-                      <
-                          is_constructible_v<value_type, _Args...>
-                      >
-             >
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp &
-    emplace(_Args&&... __args)
-    {
-        reset();
-        this->__construct(_VSTD::forward<_Args>(__args)...);
-        return this->__get();
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type&& operator*() && noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
+    return std::move(this->__get());
+  }
 
-    template <class _Up, class... _Args,
-              class = enable_if_t
-                      <
-                          is_constructible_v<value_type, initializer_list<_Up>&, _Args...>
-                      >
-             >
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp &
-    emplace(initializer_list<_Up> __il, _Args&&... __args)
-    {
-        reset();
-        this->__construct(__il, _VSTD::forward<_Args>(__args)...);
-        return this->__get();
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr const value_type&& operator*() const&& noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
+    return std::move(this->__get());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(optional& __opt)
-        noexcept(is_nothrow_move_constructible_v<value_type> &&
-                 is_nothrow_swappable_v<value_type>)
-    {
-        if (this->has_value() == __opt.has_value())
-        {
-            using _VSTD::swap;
-            if (this->has_value())
-                swap(this->__get(), __opt.__get());
-        }
-        else
-        {
-            if (this->has_value())
-            {
-                __opt.__construct(_VSTD::move(this->__get()));
-                reset();
-            }
-            else
-            {
-                this->__construct(_VSTD::move(__opt.__get()));
-                __opt.reset();
-            }
-        }
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return has_value(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    add_pointer_t<value_type const>
-    operator->() const
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator-> called on a disengaged value");
-        return _VSTD::addressof(this->__get());
-    }
+  using __base::__get;
+  using __base::has_value;
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    add_pointer_t<value_type>
-    operator->()
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator-> called on a disengaged value");
-        return _VSTD::addressof(this->__get());
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type const& value() const& {
+    if (!this->has_value())
+      __throw_bad_optional_access();
+    return this->__get();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    const value_type&
-    operator*() const& noexcept
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
-        return this->__get();
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type& value() & {
+    if (!this->has_value())
+      __throw_bad_optional_access();
+    return this->__get();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    value_type&
-    operator*() & noexcept
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
-        return this->__get();
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type&& value() && {
+    if (!this->has_value())
+      __throw_bad_optional_access();
+    return std::move(this->__get());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    value_type&&
-    operator*() && noexcept
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
-        return _VSTD::move(this->__get());
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type const&& value() const&& {
+    if (!this->has_value())
+      __throw_bad_optional_access();
+    return std::move(this->__get());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr
-    const value_type&&
-    operator*() const&& noexcept
-    {
-        _LIBCPP_ASSERT(this->has_value(), "optional operator* called on a disengaged value");
-        return _VSTD::move(this->__get());
-    }
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type value_or(_Up&& __v) const& {
+    static_assert(is_copy_constructible_v<value_type>, "optional<T>::value_or: T must be copy constructible");
+    static_assert(is_convertible_v<_Up, value_type>, "optional<T>::value_or: U must be convertible to T");
+    return this->has_value() ? this->__get() : static_cast<value_type>(std::forward<_Up>(__v));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit operator bool() const noexcept { return has_value(); }
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type value_or(_Up&& __v) && {
+    static_assert(is_move_constructible_v<value_type>, "optional<T>::value_or: T must be move constructible");
+    static_assert(is_convertible_v<_Up, value_type>, "optional<T>::value_or: U must be convertible to T");
+    return this->has_value() ? std::move(this->__get()) : static_cast<value_type>(std::forward<_Up>(__v));
+  }
 
-    using __base::has_value;
-    using __base::__get;
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-    constexpr value_type const& value() const&
-    {
-        if (!this->has_value())
-            __throw_bad_optional_access();
-        return this->__get();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-    constexpr value_type& value() &
-    {
-        if (!this->has_value())
-            __throw_bad_optional_access();
-        return this->__get();
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-    constexpr value_type&& value() &&
-    {
-        if (!this->has_value())
-            __throw_bad_optional_access();
-        return _VSTD::move(this->__get());
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-    constexpr value_type const&& value() const&&
-    {
-        if (!this->has_value())
-            __throw_bad_optional_access();
-        return _VSTD::move(this->__get());
-    }
-
-    template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type value_or(_Up&& __v) const&
-    {
-        static_assert(is_copy_constructible_v<value_type>,
-                      "optional<T>::value_or: T must be copy constructible");
-        static_assert(is_convertible_v<_Up, value_type>,
-                      "optional<T>::value_or: U must be convertible to T");
-        return this->has_value() ? this->__get() :
-                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
-    }
-
-    template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr value_type value_or(_Up&& __v) &&
-    {
-        static_assert(is_move_constructible_v<value_type>,
-                      "optional<T>::value_or: T must be move constructible");
-        static_assert(is_convertible_v<_Up, value_type>,
-                      "optional<T>::value_or: U must be convertible to T");
-        return this->has_value() ? _VSTD::move(this->__get()) :
-                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
-    }
-
-#if _LIBCPP_STD_VER >= 23
-  template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-  constexpr auto and_then(_Func&& __f) & {
+#  if _LIBCPP_STD_VER >= 23
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto and_then(_Func&& __f) & {
     using _Up = invoke_result_t<_Func, value_type&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(value()) must be a specialization of std::optional");
     if (*this)
-      return _VSTD::invoke(_VSTD::forward<_Func>(__f), value());
+      return std::invoke(std::forward<_Func>(__f), value());
     return remove_cvref_t<_Up>();
   }
 
-  template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-  constexpr auto and_then(_Func&& __f) const& {
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto and_then(_Func&& __f) const& {
     using _Up = invoke_result_t<_Func, const value_type&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(value()) must be a specialization of std::optional");
     if (*this)
-      return _VSTD::invoke(_VSTD::forward<_Func>(__f), value());
+      return std::invoke(std::forward<_Func>(__f), value());
     return remove_cvref_t<_Up>();
   }
 
-  template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-  constexpr auto and_then(_Func&& __f) && {
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto and_then(_Func&& __f) && {
     using _Up = invoke_result_t<_Func, value_type&&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(std::move(value())) must be a specialization of std::optional");
     if (*this)
-      return _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(value()));
+      return std::invoke(std::forward<_Func>(__f), std::move(value()));
     return remove_cvref_t<_Up>();
   }
 
-  template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto and_then(_Func&& __f) const&& {
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
     using _Up = invoke_result_t<_Func, const value_type&&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(std::move(value())) must be a specialization of std::optional");
     if (*this)
-      return _VSTD::invoke(_VSTD::forward<_Func>(__f), _VSTD::move(value()));
+      return std::invoke(std::forward<_Func>(__f), std::move(value()));
     return remove_cvref_t<_Up>();
   }
 
-  template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-  constexpr auto transform(_Func&& __f) & {
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto transform(_Func&& __f) & {
     using _Up = remove_cv_t<invoke_result_t<_Func, value_type&>>;
     static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
-    static_assert(!is_same_v<_Up, in_place_t>,
-                  "Result of f(value()) should not be std::in_place_t");
-    static_assert(!is_same_v<_Up, nullopt_t>,
-                  "Result of f(value()) should not be std::nullopt_t");
+    static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
+    static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
     static_assert(is_object_v<_Up>, "Result of f(value()) should be an object type");
     if (*this)
-      return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), value());
+      return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
     return optional<_Up>();
   }
 
-  template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-  constexpr auto transform(_Func&& __f) const& {
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto transform(_Func&& __f) const& {
     using _Up = remove_cv_t<invoke_result_t<_Func, const value_type&>>;
     static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
-    static_assert(!is_same_v<_Up, in_place_t>,
-                  "Result of f(value()) should not be std::in_place_t");
-    static_assert(!is_same_v<_Up, nullopt_t>,
-                  "Result of f(value()) should not be std::nullopt_t");
+    static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
+    static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
     static_assert(is_object_v<_Up>, "Result of f(value()) should be an object type");
     if (*this)
-      return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), value());
+      return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
     return optional<_Up>();
   }
 
-  template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-  constexpr auto transform(_Func&& __f) && {
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto transform(_Func&& __f) && {
     using _Up = remove_cv_t<invoke_result_t<_Func, value_type&&>>;
     static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
-    static_assert(!is_same_v<_Up, in_place_t>,
-                  "Result of f(std::move(value())) should not be std::in_place_t");
-    static_assert(!is_same_v<_Up, nullopt_t>,
-                  "Result of f(std::move(value())) should not be std::nullopt_t");
+    static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
+    static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
     static_assert(is_object_v<_Up>, "Result of f(std::move(value())) should be an object type");
     if (*this)
-      return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), _VSTD::move(value()));
+      return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
     return optional<_Up>();
   }
 
-  template<class _Func>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
-  constexpr auto transform(_Func&& __f) const&& {
+  template <class _Func>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr auto transform(_Func&& __f) const&& {
     using _Up = remove_cvref_t<invoke_result_t<_Func, const value_type&&>>;
     static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
-    static_assert(!is_same_v<_Up, in_place_t>,
-                  "Result of f(std::move(value())) should not be std::in_place_t");
-    static_assert(!is_same_v<_Up, nullopt_t>,
-                  "Result of f(std::move(value())) should not be std::nullopt_t");
+    static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
+    static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
     static_assert(is_object_v<_Up>, "Result of f(std::move(value())) should be an object type");
     if (*this)
-      return optional<_Up>(__optional_construct_from_invoke_tag{}, _VSTD::forward<_Func>(__f), _VSTD::move(value()));
+      return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), std::move(value()));
     return optional<_Up>();
   }
 
-  template<invocable _Func>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr optional or_else(_Func&& __f) const& requires is_copy_constructible_v<value_type> {
+  template <invocable _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) const&
+    requires is_copy_constructible_v<value_type>
+  {
     static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
                   "Result of f() should be the same type as this optional");
     if (*this)
       return *this;
-    return _VSTD::forward<_Func>(__f)();
+    return std::forward<_Func>(__f)();
   }
 
-  template<invocable _Func>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr optional or_else(_Func&& __f) && requires is_move_constructible_v<value_type> {
+  template <invocable _Func>
+  _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) &&
+    requires is_move_constructible_v<value_type>
+  {
     static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
                   "Result of f() should be the same type as this optional");
     if (*this)
-      return _VSTD::move(*this);
-    return _VSTD::forward<_Func>(__f)();
+      return std::move(*this);
+    return std::forward<_Func>(__f)();
   }
-#endif // _LIBCPP_STD_VER >= 23
+#  endif // _LIBCPP_STD_VER >= 23
 
-    using __base::reset;
+  using __base::reset;
 };
 
-#if _LIBCPP_STD_VER >= 17
-template<class _Tp>
-    optional(_Tp) -> optional<_Tp>;
-#endif
+#  if _LIBCPP_STD_VER >= 17
+template <class _Tp>
+optional(_Tp) -> optional<_Tp>;
+#  endif
 
 // Comparisons between optionals
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() ==
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator==(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (static_cast<bool>(__x) != static_cast<bool>(__y))
-        return false;
-    if (!static_cast<bool>(__x))
-        return true;
-    return *__x == *__y;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
+    bool >
+operator==(const optional<_Tp>& __x, const optional<_Up>& __y) {
+  if (static_cast<bool>(__x) != static_cast<bool>(__y))
+    return false;
+  if (!static_cast<bool>(__x))
+    return true;
+  return *__x == *__y;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() !=
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator!=(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (static_cast<bool>(__x) != static_cast<bool>(__y))
-        return true;
-    if (!static_cast<bool>(__x))
-        return false;
-    return *__x != *__y;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
+    bool >
+operator!=(const optional<_Tp>& __x, const optional<_Up>& __y) {
+  if (static_cast<bool>(__x) != static_cast<bool>(__y))
+    return true;
+  if (!static_cast<bool>(__x))
+    return false;
+  return *__x != *__y;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() <
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator<(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (!static_cast<bool>(__y))
-        return false;
-    if (!static_cast<bool>(__x))
-        return true;
-    return *__x < *__y;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
+    bool >
+operator<(const optional<_Tp>& __x, const optional<_Up>& __y) {
+  if (!static_cast<bool>(__y))
+    return false;
+  if (!static_cast<bool>(__x))
+    return true;
+  return *__x < *__y;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() >
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator>(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (!static_cast<bool>(__x))
-        return false;
-    if (!static_cast<bool>(__y))
-        return true;
-    return *__x > *__y;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
+    bool >
+operator>(const optional<_Tp>& __x, const optional<_Up>& __y) {
+  if (!static_cast<bool>(__x))
+    return false;
+  if (!static_cast<bool>(__y))
+    return true;
+  return *__x > *__y;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() <=
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator<=(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (!static_cast<bool>(__x))
-        return true;
-    if (!static_cast<bool>(__y))
-        return false;
-    return *__x <= *__y;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
+    bool >
+operator<=(const optional<_Tp>& __x, const optional<_Up>& __y) {
+  if (!static_cast<bool>(__x))
+    return true;
+  if (!static_cast<bool>(__y))
+    return false;
+  return *__x <= *__y;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() >=
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator>=(const optional<_Tp>& __x, const optional<_Up>& __y)
-{
-    if (!static_cast<bool>(__y))
-        return true;
-    if (!static_cast<bool>(__x))
-        return false;
-    return *__x >= *__y;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
+    bool >
+operator>=(const optional<_Tp>& __x, const optional<_Up>& __y) {
+  if (!static_cast<bool>(__y))
+    return true;
+  if (!static_cast<bool>(__x))
+    return false;
+  return *__x >= *__y;
 }
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
 
 template <class _Tp, three_way_comparable_with<_Tp> _Up>
 _LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up>
 operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y) {
-    if (__x && __y)
-        return *__x <=> *__y;
-    return __x.has_value() <=> __y.has_value();
+  if (__x && __y)
+    return *__x <=> *__y;
+  return __x.has_value() <=> __y.has_value();
 }
 
-#endif // _LIBCPP_STD_VER >= 20
+#  endif // _LIBCPP_STD_VER >= 20
 
 // Comparisons with nullopt
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator==(const optional<_Tp>& __x, nullopt_t) noexcept
-{
-    return !static_cast<bool>(__x);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, nullopt_t) noexcept {
+  return !static_cast<bool>(__x);
 }
 
-#if _LIBCPP_STD_VER <= 17
+#  if _LIBCPP_STD_VER <= 17
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator==(nullopt_t, const optional<_Tp>& __x) noexcept
-{
-    return !static_cast<bool>(__x);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(nullopt_t, const optional<_Tp>& __x) noexcept {
+  return !static_cast<bool>(__x);
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
-{
-    return static_cast<bool>(__x);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, nullopt_t) noexcept {
+  return static_cast<bool>(__x);
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
-{
-    return static_cast<bool>(__x);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(nullopt_t, const optional<_Tp>& __x) noexcept {
+  return static_cast<bool>(__x);
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<(const optional<_Tp>&, nullopt_t) noexcept
-{
-    return false;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>&, nullopt_t) noexcept {
+  return false;
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<(nullopt_t, const optional<_Tp>& __x) noexcept
-{
-    return static_cast<bool>(__x);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(nullopt_t, const optional<_Tp>& __x) noexcept {
+  return static_cast<bool>(__x);
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
-{
-    return !static_cast<bool>(__x);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, nullopt_t) noexcept {
+  return !static_cast<bool>(__x);
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator<=(nullopt_t, const optional<_Tp>&) noexcept
-{
-    return true;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(nullopt_t, const optional<_Tp>&) noexcept {
+  return true;
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>(const optional<_Tp>& __x, nullopt_t) noexcept
-{
-    return static_cast<bool>(__x);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, nullopt_t) noexcept {
+  return static_cast<bool>(__x);
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>(nullopt_t, const optional<_Tp>&) noexcept
-{
-    return false;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(nullopt_t, const optional<_Tp>&) noexcept {
+  return false;
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>=(const optional<_Tp>&, nullopt_t) noexcept
-{
-    return true;
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>&, nullopt_t) noexcept {
+  return true;
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-bool
-operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
-{
-    return !static_cast<bool>(__x);
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(nullopt_t, const optional<_Tp>& __x) noexcept {
+  return !static_cast<bool>(__x);
 }
 
-#else // _LIBCPP_STD_VER <= 17
+#  else // _LIBCPP_STD_VER <= 17
 
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI constexpr strong_ordering operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept {
-    return __x.has_value() <=> false;
+  return __x.has_value() <=> false;
 }
 
-#endif // _LIBCPP_STD_VER <= 17
+#  endif // _LIBCPP_STD_VER <= 17
 
 // Comparisons with T
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() ==
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator==(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x == __v : false;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
+    bool >
+operator==(const optional<_Tp>& __x, const _Up& __v) {
+  return static_cast<bool>(__x) ? *__x == __v : false;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() ==
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator==(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v == *__x : false;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
+    bool >
+operator==(const _Tp& __v, const optional<_Up>& __x) {
+  return static_cast<bool>(__x) ? __v == *__x : false;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() !=
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator!=(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x != __v : true;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
+    bool >
+operator!=(const optional<_Tp>& __x, const _Up& __v) {
+  return static_cast<bool>(__x) ? *__x != __v : true;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() !=
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator!=(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v != *__x : true;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
+    bool >
+operator!=(const _Tp& __v, const optional<_Up>& __x) {
+  return static_cast<bool>(__x) ? __v != *__x : true;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() <
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator<(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x < __v : true;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
+    bool >
+operator<(const optional<_Tp>& __x, const _Up& __v) {
+  return static_cast<bool>(__x) ? *__x < __v : true;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() <
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator<(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v < *__x : false;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
+    bool >
+operator<(const _Tp& __v, const optional<_Up>& __x) {
+  return static_cast<bool>(__x) ? __v < *__x : false;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() <=
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator<=(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x <= __v : true;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
+    bool >
+operator<=(const optional<_Tp>& __x, const _Up& __v) {
+  return static_cast<bool>(__x) ? *__x <= __v : true;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() <=
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator<=(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v <= *__x : false;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
+    bool >
+operator<=(const _Tp& __v, const optional<_Up>& __x) {
+  return static_cast<bool>(__x) ? __v <= *__x : false;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() >
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator>(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x > __v : false;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
+    bool >
+operator>(const optional<_Tp>& __x, const _Up& __v) {
+  return static_cast<bool>(__x) ? *__x > __v : false;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() >
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator>(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v > *__x : true;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
+    bool >
+operator>(const _Tp& __v, const optional<_Up>& __x) {
+  return static_cast<bool>(__x) ? __v > *__x : true;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() >=
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator>=(const optional<_Tp>& __x, const _Up& __v)
-{
-    return static_cast<bool>(__x) ? *__x >= __v : false;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
+    bool >
+operator>=(const optional<_Tp>& __x, const _Up& __v) {
+  return static_cast<bool>(__x) ? *__x >= __v : false;
 }
 
 template <class _Tp, class _Up>
-_LIBCPP_INLINE_VISIBILITY constexpr
-enable_if_t<
-    is_convertible_v<decltype(std::declval<const _Tp&>() >=
-        std::declval<const _Up&>()), bool>,
-    bool
->
-operator>=(const _Tp& __v, const optional<_Up>& __x)
-{
-    return static_cast<bool>(__x) ? __v >= *__x : true;
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<
+    is_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
+    bool >
+operator>=(const _Tp& __v, const optional<_Up>& __x) {
+  return static_cast<bool>(__x) ? __v >= *__x : true;
 }
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
 
 template <class _Tp, class _Up>
   requires(!__is_derived_from_optional<_Up>) && three_way_comparable_with<_Tp, _Up>
 _LIBCPP_HIDE_FROM_ABI constexpr compare_three_way_result_t<_Tp, _Up>
 operator<=>(const optional<_Tp>& __x, const _Up& __v) {
-    return __x.has_value() ? *__x <=> __v : strong_ordering::less;
+  return __x.has_value() ? *__x <=> __v : strong_ordering::less;
 }
 
-#endif // _LIBCPP_STD_VER >= 20
-
+#  endif // _LIBCPP_STD_VER >= 20
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-enable_if_t<
-    is_move_constructible_v<_Tp> && is_swappable_v<_Tp>,
-    void
->
-swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 enable_if_t< is_move_constructible_v<_Tp> && is_swappable_v<_Tp>, void >
+swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY constexpr
-optional<decay_t<_Tp>> make_optional(_Tp&& __v)
-{
-    return optional<decay_t<_Tp>>(_VSTD::forward<_Tp>(__v));
+_LIBCPP_HIDE_FROM_ABI constexpr optional<decay_t<_Tp>> make_optional(_Tp&& __v) {
+  return optional<decay_t<_Tp>>(std::forward<_Tp>(__v));
 }
 
 template <class _Tp, class... _Args>
-_LIBCPP_INLINE_VISIBILITY constexpr
-optional<_Tp> make_optional(_Args&&... __args)
-{
-    return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...);
+_LIBCPP_HIDE_FROM_ABI constexpr optional<_Tp> make_optional(_Args&&... __args) {
+  return optional<_Tp>(in_place, std::forward<_Args>(__args)...);
 }
 
 template <class _Tp, class _Up, class... _Args>
-_LIBCPP_INLINE_VISIBILITY constexpr
-optional<_Tp> make_optional(initializer_list<_Up> __il,  _Args&&... __args)
-{
-    return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...);
+_LIBCPP_HIDE_FROM_ABI constexpr optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) {
+  return optional<_Tp>(in_place, __il, std::forward<_Args>(__args)...);
 }
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS hash<
-    __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>>
->
-{
-#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef optional<_Tp> argument_type;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t        result_type;
-#endif
+struct _LIBCPP_TEMPLATE_VIS hash< __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>> > {
+#  if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef optional<_Tp> argument_type;
+  _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const optional<_Tp>& __opt) const
-    {
-        return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0;
-    }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const optional<_Tp>& __opt) const {
+    return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0;
+  }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 17
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <climits>
 #  include <concepts>
 #  include <ctime>
 #  include <iterator>
+#  include <limits>
 #  include <memory>
 #  include <ratio>
+#  include <stdexcept>
 #  include <tuple>
 #  include <type_traits>
 #  include <typeinfo>
diff --git a/third_party/libcxx/src/optional.cpp b/third_party/libcxx/optional.cpp
similarity index 78%
rename from third_party/libcxx/src/optional.cpp
rename to third_party/libcxx/optional.cpp
index e2b5ccef9..62b474a31 100644
--- a/third_party/libcxx/src/optional.cpp
+++ b/third_party/libcxx/optional.cpp
@@ -6,20 +6,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <__availability>
 #include <optional>
+#include <stdexcept>
 
-namespace std
-{
+namespace std {
 
 bad_optional_access::~bad_optional_access() noexcept = default;
 
-const char* bad_optional_access::what() const noexcept {
-  return "bad_optional_access";
-}
-
-} // std
+const char* bad_optional_access::what() const noexcept { return "bad_optional_access"; }
 
+} // namespace std
 
 #include <experimental/__config>
 
@@ -27,9 +23,7 @@ const char* bad_optional_access::what() const noexcept {
 //  Even though it no longer exists in a header file
 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
 
-class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
-  : public std::logic_error
-{
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access : public std::logic_error {
 public:
   bad_optional_access() : std::logic_error("Bad optional Access") {}
 
diff --git a/third_party/libcxx/ostream b/third_party/libcxx/ostream
index 168a75376..359d3c0e1 100644
--- a/third_party/libcxx/ostream
+++ b/third_party/libcxx/ostream
@@ -159,1048 +159,43 @@ basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, cons
 template<class traits>
 basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete; // since C++20
 
+// [ostream.formatted.print], print functions
+template<class... Args>                                                                                // since C++23
+  void print(ostream& os, format_string<Args...> fmt, Args&&... args);
+template<class... Args>                                                                                // since C++23
+  void println(ostream& os, format_string<Args...> fmt, Args&&... args);
+void println(ostream& os);                                                                             // since C++26
+
+void vprint_unicode(ostream& os, string_view fmt, format_args args);                                   // since C++23
+void vprint_nonunicode(ostream& os, string_view fmt, format_args args);                                // since C++23
 }  // std
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__exception/operations.h>
-#include <__fwd/ostream.h>
-#include <__memory/shared_ptr.h>
-#include <__memory/unique_ptr.h>
-#include <__system_error/error_code.h>
-#include <__type_traits/conjunction.h>
-#include <__type_traits/enable_if.h>
-#include <__type_traits/is_base_of.h>
-#include <__type_traits/void_t.h>
-#include <__utility/declval.h>
-#include <bitset>
-#include <ios>
-#include <locale>
-#include <new>
-#include <streambuf>
+
+#include <__ostream/basic_ostream.h>
+
+#if _LIBCPP_STD_VER >= 23
+#  include <__ostream/print.h>
+#endif
+
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _CharT, class _Traits>
-class _LIBCPP_TEMPLATE_VIS basic_ostream
-    : virtual public basic_ios<_CharT, _Traits>
-{
-public:
-    // types (inherited from basic_ios (27.5.4)):
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
-
-    // 27.7.2.2 Constructor/destructor:
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb)
-    { this->init(__sb); }
-    ~basic_ostream() override;
-protected:
-    inline _LIBCPP_INLINE_VISIBILITY
-    basic_ostream(basic_ostream&& __rhs);
-
-    // 27.7.2.3 Assign/swap
-    inline _LIBCPP_INLINE_VISIBILITY
-    basic_ostream& operator=(basic_ostream&& __rhs);
-
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    void swap(basic_ostream& __rhs)
-    { basic_ios<char_type, traits_type>::swap(__rhs); }
-
-    basic_ostream           (const basic_ostream& __rhs) = delete;
-    basic_ostream& operator=(const basic_ostream& __rhs) = delete;
-
-public:
-    // 27.7.2.4 Prefix/suffix:
-    class _LIBCPP_TEMPLATE_VIS sentry;
-
-    // 27.7.2.6 Formatted output:
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&))
-    { return __pf(*this); }
-
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_ostream& operator<<(basic_ios<char_type, traits_type>&
-                              (*__pf)(basic_ios<char_type,traits_type>&))
-    { __pf(*this); return *this; }
-
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_ostream& operator<<(ios_base& (*__pf)(ios_base&))
-    { __pf(*this); return *this; }
-
-    basic_ostream& operator<<(bool __n);
-    basic_ostream& operator<<(short __n);
-    basic_ostream& operator<<(unsigned short __n);
-    basic_ostream& operator<<(int __n);
-    basic_ostream& operator<<(unsigned int __n);
-    basic_ostream& operator<<(long __n);
-    basic_ostream& operator<<(unsigned long __n);
-    basic_ostream& operator<<(long long __n);
-    basic_ostream& operator<<(unsigned long long __n);
-    basic_ostream& operator<<(float __f);
-    basic_ostream& operator<<(double __f);
-    basic_ostream& operator<<(long double __f);
-    basic_ostream& operator<<(const void* __p);
-
-#if _LIBCPP_STD_VER >= 23
-    _LIBCPP_HIDE_FROM_ABI
-    basic_ostream& operator<<(const volatile void* __p) {
-        return operator<<(const_cast<const void*>(__p));
-    }
-#endif
-
-    basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
-
-#if _LIBCPP_STD_VER >= 17
-// LWG 2221 - nullptr. This is not backported to older standards modes.
-// See https://reviews.llvm.org/D127033 for more info on the rationale.
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream& operator<<(nullptr_t)
-    { return *this << "nullptr"; }
-#endif
-
-    // 27.7.2.7 Unformatted output:
-    basic_ostream& put(char_type __c);
-    basic_ostream& write(const char_type* __s, streamsize __n);
-    basic_ostream& flush();
-
-    // 27.7.2.5 seeks:
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    pos_type tellp();
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_ostream& seekp(pos_type __pos);
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
-
-protected:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostream() {}  // extension, intentially does not initialize
-};
-
-template <class _CharT, class _Traits>
-class _LIBCPP_TEMPLATE_VIS basic_ostream<_CharT, _Traits>::sentry
-{
-    bool __ok_;
-    basic_ostream<_CharT, _Traits>& __os_;
-
-public:
-    explicit sentry(basic_ostream<_CharT, _Traits>& __os);
-    ~sentry();
-    sentry(const sentry&) = delete;
-    sentry& operator=(const sentry&) = delete;
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool() const {return __ok_;}
-};
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>::sentry::sentry(basic_ostream<_CharT, _Traits>& __os)
-    : __ok_(false),
-      __os_(__os)
-{
-    if (__os.good())
-    {
-        if (__os.tie())
-            __os.tie()->flush();
-        __ok_ = true;
-    }
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>::sentry::~sentry()
-{
-    if (__os_.rdbuf() && __os_.good() && (__os_.flags() & ios_base::unitbuf)
-                      && !uncaught_exception())
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            if (__os_.rdbuf()->pubsync() == -1)
-                __os_.setstate(ios_base::badbit);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>::basic_ostream(basic_ostream&& __rhs)
-{
-    this->move(__rhs);
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator=(basic_ostream&& __rhs)
-{
-    swap(__rhs);
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>::~basic_ostream()
-{
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(basic_streambuf<char_type, traits_type>* __sb)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            if (__sb)
-            {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-                try
-                {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-                    typedef istreambuf_iterator<_CharT, _Traits> _Ip;
-                    typedef ostreambuf_iterator<_CharT, _Traits> _Op;
-                    _Ip __i(__sb);
-                    _Ip __eof;
-                    _Op __o(*this);
-                    size_t __c = 0;
-                    for (; __i != __eof; ++__i, ++__o, ++__c)
-                    {
-                        *__o = *__i;
-                        if (__o.failed())
-                            break;
-                    }
-                    if (__c == 0)
-                        this->setstate(ios_base::failbit);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-                }
-                catch (...)
-                {
-                    this->__set_failbit_and_consider_rethrow();
-                }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            }
-            else
-                this->setstate(ios_base::badbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(bool __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), __n).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(short __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(),
-                        __flags == ios_base::oct || __flags == ios_base::hex ?
-                        static_cast<long>(static_cast<unsigned short>(__n))  :
-                        static_cast<long>(__n)).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(unsigned short __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(int __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            ios_base::fmtflags __flags = ios_base::flags() & ios_base::basefield;
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(),
-                        __flags == ios_base::oct || __flags == ios_base::hex ?
-                        static_cast<long>(static_cast<unsigned int>(__n))  :
-                        static_cast<long>(__n)).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(unsigned int __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), static_cast<unsigned long>(__n)).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(long __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), __n).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(unsigned long __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), __n).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(long long __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), __n).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(unsigned long long __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), __n).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(float __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), static_cast<double>(__n)).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(double __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), __n).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(long double __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), __n).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::operator<<(const void* __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef num_put<char_type, ostreambuf_iterator<char_type, traits_type> > _Fp;
-            const _Fp& __f = std::use_facet<_Fp>(this->getloc());
-            if (__f.put(*this, *this, this->fill(), __n).failed())
-                this->setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template<class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-__put_character_sequence(basic_ostream<_CharT, _Traits>& __os,
-                          const _CharT* __str, size_t __len)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
-        if (__s)
-        {
-            typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
-            if (std::__pad_and_output(_Ip(__os),
-                                      __str,
-                                      (__os.flags() & ios_base::adjustfield) == ios_base::left ?
-                                          __str + __len :
-                                          __str,
-                                      __str + __len,
-                                      __os,
-                                      __os.fill()).failed())
-                __os.setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __os.__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return __os;
-}
-
-
-template<class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, _CharT __c)
-{
-    return _VSTD::__put_character_sequence(__os, &__c, 1);
-}
-
-template<class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, char __cn)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
-        if (__s)
-        {
-            _CharT __c = __os.widen(__cn);
-            typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
-            if (std::__pad_and_output(_Ip(__os),
-                                      &__c,
-                                      (__os.flags() & ios_base::adjustfield) == ios_base::left ?
-                                          &__c + 1 :
-                                          &__c,
-                                      &__c + 1,
-                                      __os,
-                                      __os.fill()).failed())
-                __os.setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __os.__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return __os;
-}
-
-template<class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
-operator<<(basic_ostream<char, _Traits>& __os, char __c)
-{
-    return _VSTD::__put_character_sequence(__os, &__c, 1);
-}
-
-template<class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
-operator<<(basic_ostream<char, _Traits>& __os, signed char __c)
-{
-    return _VSTD::__put_character_sequence(__os, (char *) &__c, 1);
-}
-
-template<class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
-operator<<(basic_ostream<char, _Traits>& __os, unsigned char __c)
-{
-    return _VSTD::__put_character_sequence(__os, (char *) &__c, 1);
-}
-
-template<class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const _CharT* __str)
-{
-    return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str));
-}
-
-template<class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        typename basic_ostream<_CharT, _Traits>::sentry __s(__os);
-        if (__s)
-        {
-            typedef ostreambuf_iterator<_CharT, _Traits> _Ip;
-            size_t __len = char_traits<char>::length(__strn);
-            const int __bs = 100;
-            _CharT __wbb[__bs];
-            _CharT* __wb = __wbb;
-            unique_ptr<_CharT, void(*)(void*)> __h(0, free);
-            if (__len > __bs)
-            {
-                __wb = (_CharT*)malloc(__len*sizeof(_CharT));
-                if (__wb == 0)
-                    __throw_bad_alloc();
-                __h.reset(__wb);
-            }
-            for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)
-                *__p = __os.widen(*__strn);
-            if (std::__pad_and_output(_Ip(__os),
-                                      __wb,
-                                      (__os.flags() & ios_base::adjustfield) == ios_base::left ?
-                                          __wb + __len :
-                                          __wb,
-                                      __wb + __len,
-                                      __os,
-                                      __os.fill()).failed())
-                __os.setstate(ios_base::badbit | ios_base::failbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        __os.__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return __os;
-}
-
-template<class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
-operator<<(basic_ostream<char, _Traits>& __os, const char* __str)
-{
-    return _VSTD::__put_character_sequence(__os, __str, _Traits::length(__str));
-}
-
-template<class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
-operator<<(basic_ostream<char, _Traits>& __os, const signed char* __str)
-{
-    const char *__s = (const char *) __str;
-    return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s));
-}
-
-template<class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<char, _Traits>&
-operator<<(basic_ostream<char, _Traits>& __os, const unsigned char* __str)
-{
-    const char *__s = (const char *) __str;
-    return _VSTD::__put_character_sequence(__os, __s, _Traits::length(__s));
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::put(char_type __c)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __s(*this);
-        if (__s)
-        {
-            typedef ostreambuf_iterator<_CharT, _Traits> _Op;
-            _Op __o(*this);
-            *__o = __c;
-            if (__o.failed())
-                this->setstate(ios_base::badbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::write(const char_type* __s, streamsize __n)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        sentry __sen(*this);
-        if (__sen && __n)
-        {
-            if (this->rdbuf()->sputn(__s, __n) != __n)
-                this->setstate(ios_base::badbit);
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::flush()
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        if (this->rdbuf())
-        {
-            sentry __s(*this);
-            if (__s)
-            {
-                if (this->rdbuf()->pubsync() == -1)
-                    this->setstate(ios_base::badbit);
-            }
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        this->__set_badbit_and_consider_rethrow();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-typename basic_ostream<_CharT, _Traits>::pos_type
-basic_ostream<_CharT, _Traits>::tellp()
-{
-    if (this->fail())
-        return pos_type(-1);
-    return this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::seekp(pos_type __pos)
-{
-    sentry __s(*this);
-    if (!this->fail())
-    {
-        if (this->rdbuf()->pubseekpos(__pos, ios_base::out) == pos_type(-1))
-            this->setstate(ios_base::failbit);
-    }
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-basic_ostream<_CharT, _Traits>&
-basic_ostream<_CharT, _Traits>::seekp(off_type __off, ios_base::seekdir __dir)
-{
-    sentry __s(*this);
-    if (!this->fail())
-    {
-        if (this->rdbuf()->pubseekoff(__off, __dir, ios_base::out) == pos_type(-1))
-            this->setstate(ios_base::failbit);
-    }
-    return *this;
-}
-
-template <class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI inline
-basic_ostream<_CharT, _Traits>&
-endl(basic_ostream<_CharT, _Traits>& __os)
-{
-    __os.put(__os.widen('\n'));
-    __os.flush();
-    return __os;
-}
-
-template <class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI inline
-basic_ostream<_CharT, _Traits>&
-ends(basic_ostream<_CharT, _Traits>& __os)
-{
-    __os.put(_CharT());
-    return __os;
-}
-
-template <class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI inline
-basic_ostream<_CharT, _Traits>&
-flush(basic_ostream<_CharT, _Traits>& __os)
-{
-    __os.flush();
-    return __os;
-}
-
-template <class _Stream, class _Tp, class = void>
-struct __is_ostreamable : false_type { };
-
-template <class _Stream, class _Tp>
-struct __is_ostreamable<_Stream, _Tp, decltype(
-    std::declval<_Stream>() << std::declval<_Tp>(), void()
-)> : true_type { };
-
-template <class _Stream, class _Tp, class = typename enable_if<
-    _And<is_base_of<ios_base, _Stream>,
-         __is_ostreamable<_Stream&, const _Tp&> >::value
->::type>
-_LIBCPP_INLINE_VISIBILITY
-_Stream&& operator<<(_Stream&& __os, const _Tp& __x)
-{
-    __os << __x;
-    return _VSTD::move(__os);
-}
-
-template<class _CharT, class _Traits, class _Allocator>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const basic_string<_CharT, _Traits, _Allocator>& __str)
-{
-    return _VSTD::__put_character_sequence(__os, __str.data(), __str.size());
-}
-
-template<class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           basic_string_view<_CharT, _Traits> __sv)
-{
-    return _VSTD::__put_character_sequence(__os, __sv.data(), __sv.size());
-}
-
-template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __ec)
-{
-    return __os << __ec.category().name() << ':' << __ec.value();
-}
-
-template<class _CharT, class _Traits, class _Yp>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p)
-{
-    return __os << __p.get();
-}
-
-template<class _CharT, class _Traits, class _Yp, class _Dp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    is_same<void, __void_t<decltype((std::declval<basic_ostream<_CharT, _Traits>&>() << std::declval<typename unique_ptr<_Yp, _Dp>::pointer>()))> >::value,
-    basic_ostream<_CharT, _Traits>&
->::type
-operator<<(basic_ostream<_CharT, _Traits>& __os, unique_ptr<_Yp, _Dp> const& __p)
-{
-    return __os << __p.get();
-}
-
-template <class _CharT, class _Traits, size_t _Size>
-_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
-{
-    return __os << __x.template to_string<_CharT, _Traits>
-                        (std::use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
-                         std::use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
-}
-
-#if _LIBCPP_STD_VER >= 20
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <class _Traits>
-basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
-
-template <class _Traits>
-basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
-
-template <class _Traits>
-basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;
-
-template <class _Traits>
-basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
-
-template <class _Traits>
-basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;
-
-template <class _Traits>
-basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
-
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-template <class _Traits>
-basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;
-
-template <class _Traits>
-basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;
-
-template <class _Traits>
-basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;
-
-template <class _Traits>
-basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;
-#endif
-
-template <class _Traits>
-basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;
-
-template <class _Traits>
-basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;
-
-template <class _Traits>
-basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
-
-template <class _Traits>
-basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;
-
-#endif // _LIBCPP_STD_VER >= 20
-
-extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <concepts>
+#  include <cstdio>
 #  include <cstdlib>
+#  include <format>
+#  include <iosfwd>
 #  include <iterator>
+#  include <print>
+#  include <stdexcept>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/ostream.cpp b/third_party/libcxx/ostream.cpp
new file mode 100644
index 000000000..e1a9a4bc1
--- /dev/null
+++ b/third_party/libcxx/ostream.cpp
@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM
+#  include <fstream>
+#endif
+#include <ostream>
+
+#include "std_stream.h"
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_LIBCPP_EXPORTED_FROM_ABI FILE* __get_ostream_file(ostream& __os) {
+  // dynamic_cast requires RTTI, this only affects users whose vendor builds
+  // the dylib with RTTI disabled. It does not affect users who build with RTTI
+  // disabled but use a dylib where the RTTI is enabled.
+  //
+  // Returning a nullptr means the stream is not considered a terminal and the
+  // special terminal handling is not done. The terminal handling is mainly of
+  // importance on Windows.
+#ifndef _LIBCPP_HAS_NO_RTTI
+  auto* __rdbuf = __os.rdbuf();
+#  ifndef _LIBCPP_HAS_NO_FILESYSTEM
+  if (auto* __buffer = dynamic_cast<filebuf*>(__rdbuf))
+    return __buffer->__file_;
+#  endif
+
+  if (auto* __buffer = dynamic_cast<__stdoutbuf<char>*>(__rdbuf))
+    return __buffer->__file_;
+#endif // _LIBCPP_HAS_NO_RTTI
+
+  return nullptr;
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/overridable_function.h b/third_party/libcxx/overridable_function.h
new file mode 100644
index 000000000..e71e4f104
--- /dev/null
+++ b/third_party/libcxx/overridable_function.h
@@ -0,0 +1,129 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SRC_INCLUDE_OVERRIDABLE_FUNCTION_H
+#define _LIBCPP_SRC_INCLUDE_OVERRIDABLE_FUNCTION_H
+
+#include <__config>
+#include <cstdint>
+
+#if defined(__arm64e__) && __has_feature(ptrauth_calls)
+#  include <ptrauth.h>
+#endif
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+//
+// This file provides the std::__is_function_overridden utility, which allows checking
+// whether an overridable function (typically a weak symbol) like `operator new`
+// has been overridden by a user or not.
+//
+// This is a low-level utility which does not work on all platforms, since it needs
+// to make assumptions about the object file format in use. Furthermore, it requires
+// the "base definition" of the function (the one we want to check whether it has been
+// overridden) to be annotated with the _LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE macro.
+//
+// This currently works with Mach-O files (used on Darwin) and with ELF files (used on Linux
+// and others). On platforms where we know how to implement this detection, the macro
+// _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION is defined to 1, and it is defined to 0 on
+// other platforms. The _LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE macro is defined to
+// nothing on unsupported platforms so that it can be used to decorate functions regardless
+// of whether detection is actually supported.
+//
+// How does this work?
+// -------------------
+//
+// Let's say we want to check whether a weak function `f` has been overridden by the user.
+// The general mechanism works by placing `f`'s definition (in the libc++ built library)
+// inside a special section, which we do using the `__section__` attribute via the
+// _LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE macro.
+//
+// Then, when comes the time to check whether the function has been overridden, we take
+// the address of the function and we check whether it falls inside the special function
+// we created. This can be done by finding pointers to the start and the end of the section
+// (which is done differently for ELF and Mach-O), and then checking whether `f` falls
+// within those bounds. If it falls within those bounds, then `f` is still inside the
+// special section and so it is the version we defined in the libc++ built library, i.e.
+// it was not overridden. Otherwise, it was overridden by the user because it falls
+// outside of the section.
+//
+// Important note
+// --------------
+//
+// This mechanism should never be used outside of the libc++ built library. In particular,
+// attempting to use this within the libc++ headers will not work at all because we don't
+// want to be defining special sections inside user's executables which use our headers.
+//
+
+#if defined(_LIBCPP_OBJECT_FORMAT_MACHO)
+
+#  define _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION 1
+#  define _LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE                                                                 \
+    __attribute__((__section__("__TEXT,__lcxx_override,regular,pure_instructions")))
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+template <class _Ret, class... _Args>
+_LIBCPP_HIDE_FROM_ABI bool __is_function_overridden(_Ret (*__fptr)(_Args...)) noexcept {
+  // Declare two dummy bytes and give them these special `__asm` values. These values are
+  // defined by the linker, which means that referring to `&__lcxx_override_start` will
+  // effectively refer to the address where the section starts (and same for the end).
+  extern char __lcxx_override_start __asm("section$start$__TEXT$__lcxx_override");
+  extern char __lcxx_override_end __asm("section$end$__TEXT$__lcxx_override");
+
+  // Now get a uintptr_t out of these locations, and out of the function pointer.
+  uintptr_t __start = reinterpret_cast<uintptr_t>(&__lcxx_override_start);
+  uintptr_t __end   = reinterpret_cast<uintptr_t>(&__lcxx_override_end);
+  uintptr_t __ptr   = reinterpret_cast<uintptr_t>(__fptr);
+
+#if defined(__arm64e__) && __has_feature(ptrauth_calls)
+  // We must pass a void* to ptrauth_strip since it only accepts a pointer type. Also, in particular,
+  // we must NOT pass a function pointer, otherwise we will strip the function pointer, and then attempt
+  // to authenticate and re-sign it when casting it to a uintptr_t again, which will fail because we just
+  // stripped the function pointer. See rdar://122927845.
+  __ptr = reinterpret_cast<uintptr_t>(ptrauth_strip(reinterpret_cast<void*>(__ptr), ptrauth_key_function_pointer));
+#endif
+
+  // Finally, the function was overridden if it falls outside of the section's bounds.
+  return __ptr < __start || __ptr > __end;
+}
+_LIBCPP_END_NAMESPACE_STD
+
+#elif defined(_LIBCPP_OBJECT_FORMAT_ELF)
+
+#  define _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION 1
+#  define _LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE __attribute__((__section__("__lcxx_override")))
+
+// This is very similar to what we do for Mach-O above. The ELF linker will implicitly define
+// variables with those names corresponding to the start and the end of the section.
+//
+// See https://stackoverflow.com/questions/16552710/how-do-you-get-the-start-and-end-addresses-of-a-custom-elf-section
+extern char __start___lcxx_override;
+extern char __stop___lcxx_override;
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+template <class _Ret, class... _Args>
+_LIBCPP_HIDE_FROM_ABI bool __is_function_overridden(_Ret (*__fptr)(_Args...)) noexcept {
+  uintptr_t __start = reinterpret_cast<uintptr_t>(&__start___lcxx_override);
+  uintptr_t __end   = reinterpret_cast<uintptr_t>(&__stop___lcxx_override);
+  uintptr_t __ptr   = reinterpret_cast<uintptr_t>(__fptr);
+
+  return __ptr < __start || __ptr > __end;
+}
+_LIBCPP_END_NAMESPACE_STD
+
+#else
+
+#  define _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION 0
+#  define _LIBCPP_MAKE_OVERRIDABLE_FUNCTION_DETECTABLE /* nothing */
+
+#endif
+
+#endif // _LIBCPP_SRC_INCLUDE_OVERRIDABLE_FUNCTION_H
diff --git a/third_party/libcxx/print b/third_party/libcxx/print
new file mode 100644
index 000000000..1a579daff
--- /dev/null
+++ b/third_party/libcxx/print
@@ -0,0 +1,402 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_PRINT
+#define _LIBCPP_PRINT
+
+/*
+namespace std {
+  // [print.fun], print functions
+  template<class... Args>
+    void print(format_string<Args...> fmt, Args&&... args);
+  void println();                                                          // Since C++26
+  template<class... Args>
+    void print(FILE* stream, format_string<Args...> fmt, Args&&... args);
+  void println(FILE* stream);                                              // Since C++26
+
+  template<class... Args>
+    void println(format_string<Args...> fmt, Args&&... args);
+  template<class... Args>
+    void println(FILE* stream, format_string<Args...> fmt, Args&&... args);
+
+  void vprint_unicode(string_view fmt, format_args args);
+  void vprint_unicode(FILE* stream, string_view fmt, format_args args);
+
+  void vprint_nonunicode(string_view fmt, format_args args);
+  void vprint_nonunicode(FILE* stream, string_view fmt, format_args args);
+}
+*/
+
+#include <__assert>
+#include <__concepts/same_as.h>
+#include <__config>
+#include <__system_error/system_error.h>
+#include <__utility/forward.h>
+#include <cerrno>
+#include <cstdio>
+#include <format>
+#include <string>
+#include <string_view>
+#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifdef _LIBCPP_WIN32API
+_LIBCPP_EXPORTED_FROM_ABI bool __is_windows_terminal(FILE* __stream);
+
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+// A wrapper for WriteConsoleW which is used to write to the Windows
+// console. This function is in the dylib to avoid pulling in windows.h
+// in the library headers. The function itself uses some private parts
+// of the dylib too.
+//
+// The function does not depend on the language standard used. Guarding
+// it with C++23 would fail since the dylib is currently built using C++20.
+//
+// Note the function is only implemented on the Windows platform.
+_LIBCPP_EXPORTED_FROM_ABI void __write_to_windows_console(FILE* __stream, wstring_view __view);
+#  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#elif __has_include(<unistd.h>)
+_LIBCPP_EXPORTED_FROM_ABI bool __is_posix_terminal(FILE* __stream);
+#endif // _LIBCPP_WIN32API
+
+#if _LIBCPP_STD_VER >= 23
+
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+// This is the code to transcode UTF-8 to UTF-16. This is used on
+// Windows for the native Unicode API. The code is modeled to make it
+// easier to extend to
+//
+//  P2728R0 Unicode in the Library, Part 1: UTF Transcoding
+//
+// This paper is still under heavy development so it makes no sense yet
+// to strictly follow the paper.
+namespace __unicode {
+
+// The names of these concepts are modelled after P2728R0, but the
+// implementation is not. char16_t may contain 32-bits so depending on the
+// number of bits is an issue.
+#    ifdef _LIBCPP_SHORT_WCHAR
+template <class _Tp>
+concept __utf16_code_unit =
+    same_as<_Tp, char16_t>
+#      ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    || same_as<_Tp, wchar_t>
+#      endif
+    ;
+template <class _Tp>
+concept __utf32_code_unit = same_as<_Tp, char32_t>;
+#    else // _LIBCPP_SHORT_WCHAR
+template <class _Tp>
+concept __utf16_code_unit = same_as<_Tp, char16_t>;
+template <class _Tp>
+concept __utf32_code_unit =
+    same_as<_Tp, char32_t>
+#      ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+    || same_as<_Tp, wchar_t>
+#      endif
+    ;
+#    endif // _LIBCPP_SHORT_WCHAR
+
+// Pass by reference since an output_iterator may not be copyable.
+template <class _OutIt>
+_LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt&, char32_t) = delete;
+
+template <class _OutIt>
+  requires __utf16_code_unit<iter_value_t<_OutIt>>
+_LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt& __out_it, char32_t __value) {
+  // [print.fun]/7 : "if `out` contains invalid code units, the behavior is undefined and implementations are encouraged
+  // to diagnose it".
+  _LIBCPP_ASSERT_UNCATEGORIZED(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-16");
+
+  if (__value < 0x10000) {
+    *__out_it++ = __value;
+    return;
+  }
+
+  __value -= 0x10000;
+  *__out_it++ = 0xd800 + (__value >> 10);
+  *__out_it++ = 0xdc00 + (__value & 0x3FF);
+}
+
+template <class _OutIt>
+  requires __utf32_code_unit<iter_value_t<_OutIt>>
+_LIBCPP_HIDE_FROM_ABI constexpr void __encode(_OutIt& __out_it, char32_t __value) {
+  // [print.fun]/7 : "if `out` contains invalid code units, the behavior is undefined and implementations are encouraged
+  // to diagnose it".
+  _LIBCPP_ASSERT_UNCATEGORIZED(__is_scalar_value(__value), "an invalid unicode scalar value results in invalid UTF-32");
+  *__out_it++ = __value;
+}
+
+template <class _OutIt, input_iterator _InIt>
+  requires output_iterator<_OutIt, const iter_value_t<_OutIt>&> && (!same_as<iter_value_t<_OutIt>, iter_value_t<_InIt>>)
+_LIBCPP_HIDE_FROM_ABI constexpr _OutIt __transcode(_InIt __first, _InIt __last, _OutIt __out_it) {
+  // The __code_point_view has a basic_string_view interface.
+  // When transcoding becomes part of the standard we probably want to
+  // look at smarter algorithms.
+  // For example, when processing a code point that is encoded in
+  // 1 to 3 code units in UTF-8, the result will always be encoded
+  // in 1 code unit in UTF-16 (code points that require 4 code
+  // units in UTF-8 will require 2 code units in UTF-16).
+  //
+  // Note if P2728 is accepted types like int may become valid. In that case
+  // the __code_point_view should use a span. Libc++ will remove support for
+  // char_traits<int>.
+
+  // TODO PRINT Validate with clang-tidy
+  // NOLINTNEXTLINE(bugprone-dangling-handle)
+  basic_string_view<iter_value_t<_InIt>> __data{__first, __last};
+  __code_point_view<iter_value_t<_InIt>> __view{__data.begin(), __data.end()};
+  while (!__view.__at_end())
+    __unicode::__encode(__out_it, __view.__consume().__code_point);
+  return __out_it;
+}
+
+} // namespace __unicode
+
+#  endif //  _LIBCPP_HAS_NO_UNICODE
+
+namespace __print {
+
+// [print.fun]/2
+//   Effects: If the ordinary literal encoding ([lex.charset]) is UTF-8, equivalent to:
+//     vprint_unicode(stream, fmt.str, make_format_args(args...));
+//   Otherwise, equivalent to:
+//     vprint_nonunicode(stream, fmt.str, make_format_args(args...));
+//
+// Based on the compiler and its compilation flags this value is or is
+// not true. As mentioned in P2093R14 this only affects Windows. The
+// test below could also be done for
+// - GCC using __GNUC_EXECUTION_CHARSET_NAME
+//   https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+// - Clang using __clang_literal_encoding__
+//   https://clang.llvm.org/docs/LanguageExtensions.html#builtin-macros
+//   (note at the time of writing Clang is hard-coded to UTF-8.)
+//
+
+#  ifdef _LIBCPP_HAS_NO_UNICODE
+inline constexpr bool __use_unicode_execution_charset = false;
+#  elif defined(_MSVC_EXECUTION_CHARACTER_SET)
+// This is the same test MSVC STL uses in their implementation of <print>
+// See: https://learn.microsoft.com/en-us/windows/win32/intl/code-page-identifiers
+inline constexpr bool __use_unicode_execution_charset = _MSVC_EXECUTION_CHARACTER_SET == 65001;
+#  else
+inline constexpr bool __use_unicode_execution_charset = true;
+#  endif
+
+_LIBCPP_HIDE_FROM_ABI inline bool __is_terminal([[maybe_unused]] FILE* __stream) {
+  // The macro _LIBCPP_TESTING_PRINT_IS_TERMINAL is used to change
+  // the behavior in the test. This is not part of the public API.
+#  ifdef _LIBCPP_TESTING_PRINT_IS_TERMINAL
+  return _LIBCPP_TESTING_PRINT_IS_TERMINAL(__stream);
+#  elif _LIBCPP_AVAILABILITY_HAS_PRINT == 0
+  return false;
+#  elif defined(_LIBCPP_WIN32API)
+  return std::__is_windows_terminal(__stream);
+#  elif __has_include(<unistd.h>)
+  return std::__is_posix_terminal(__stream);
+#  else
+#    error "Provide a way to determine whether a FILE* is a terminal"
+#  endif
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void
+__vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl) {
+  _LIBCPP_ASSERT_NON_NULL(__stream, "__stream must be a valid pointer to an output C stream");
+  string __str = std::vformat(__fmt, __args);
+  if (__write_nl)
+    __str.push_back('\n');
+
+  size_t __size = fwrite(__str.data(), 1, __str.size(), __stream);
+  if (__size < __str.size()) {
+    if (std::feof(__stream))
+      std::__throw_system_error(EIO, "EOF while writing the formatted output");
+    std::__throw_system_error(std::ferror(__stream), "failed to write formatted output");
+  }
+}
+
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+
+// Note these helper functions are mainly used to aid testing.
+// On POSIX systems and Windows the output is no longer considered a
+// terminal when the output is redirected. Typically during testing the
+// output is redirected to be able to capture it. This makes it hard to
+// test this code path.
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void
+__vprint_unicode_posix(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl, bool __is_terminal) {
+  // TODO PRINT Should flush errors throw too?
+  if (__is_terminal)
+    std::fflush(__stream);
+
+  __print::__vprint_nonunicode(__stream, __fmt, __args, __write_nl);
+}
+
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void
+__vprint_unicode_windows(FILE* __stream, string_view __fmt, format_args __args, bool __write_nl, bool __is_terminal) {
+  if (!__is_terminal)
+    return __print::__vprint_nonunicode(__stream, __fmt, __args, __write_nl);
+
+  // TODO PRINT Should flush errors throw too?
+  std::fflush(__stream);
+
+  string __str = std::vformat(__fmt, __args);
+  // UTF-16 uses the same number or less code units than UTF-8.
+  // However the size of the code unit is 16 bits instead of 8 bits.
+  //
+  // The buffer uses the worst-case estimate and should never resize.
+  // However when the string is large this could lead to OOM. Using a
+  // smaller size might work, but since the buffer uses a grow factor
+  // the final size might be larger when the estimate is wrong.
+  //
+  // TODO PRINT profile and improve the speed of this code.
+  __format::__retarget_buffer<wchar_t> __buffer{__str.size()};
+  __unicode::__transcode(__str.begin(), __str.end(), __buffer.__make_output_iterator());
+  if (__write_nl)
+    __buffer.push_back(L'\n');
+
+  [[maybe_unused]] wstring_view __view = __buffer.__view();
+
+  // The macro _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION is used to change
+  // the behavior in the test. This is not part of the public API.
+#      ifdef _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION
+  _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION(__stream, __view);
+#      elif defined(_LIBCPP_WIN32API)
+  std::__write_to_windows_console(__stream, __view);
+#      else
+  std::__throw_runtime_error("No defintion of _LIBCPP_TESTING_PRINT_WRITE_TO_WINDOWS_CONSOLE_FUNCTION and "
+                             "__write_to_windows_console is not available.");
+#      endif
+}
+#    endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void
+__vprint_unicode([[maybe_unused]] FILE* __stream,
+                 [[maybe_unused]] string_view __fmt,
+                 [[maybe_unused]] format_args __args,
+                 [[maybe_unused]] bool __write_nl) {
+  _LIBCPP_ASSERT_NON_NULL(__stream, "__stream must be a valid pointer to an output C stream");
+
+  // [print.fun]
+  //   7 - Effects: If stream refers to a terminal capable of displaying
+  //       Unicode, writes out to the terminal using the native Unicode
+  //       API; if out contains invalid code units, the behavior is
+  //       undefined and implementations are encouraged to diagnose it.
+  //       Otherwise writes out to stream unchanged. If the native
+  //       Unicode API is used, the function flushes stream before
+  //       writing out.
+  //   8 - Throws: Any exception thrown by the call to vformat
+  //       ([format.err.report]). system_error if writing to the terminal
+  //       or stream fails. May throw bad_alloc.
+  //   9 - Recommended practice: If invoking the native Unicode API
+  //       requires transcoding, implementations should substitute
+  //       invalid code units with U+FFFD replacement character per the
+  //       Unicode Standard, Chapter 3.9 U+FFFD Substitution in
+  //       Conversion.
+
+  // On non-Windows platforms the Unicode API is the normal file I/O API
+  // so there the call can be forwarded to the non_unicode API. On
+  // Windows there is a different API. This API requires transcoding.
+
+#    ifndef _LIBCPP_WIN32API
+  __print::__vprint_unicode_posix(__stream, __fmt, __args, __write_nl, __print::__is_terminal(__stream));
+#    elif !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+  __print::__vprint_unicode_windows(__stream, __fmt, __args, __write_nl, __print::__is_terminal(__stream));
+#    else
+#      error "Windows builds with wchar_t disabled are not supported."
+#    endif
+}
+
+#  endif // _LIBCPP_HAS_NO_UNICODE
+
+} // namespace __print
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void print(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args) {
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+  if constexpr (__print::__use_unicode_execution_charset)
+    __print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), false);
+  else
+    __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), false);
+#  else  // _LIBCPP_HAS_NO_UNICODE
+  __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), false);
+#  endif // _LIBCPP_HAS_NO_UNICODE
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void print(format_string<_Args...> __fmt, _Args&&... __args) {
+  std::print(stdout, __fmt, std::forward<_Args>(__args)...);
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void println(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args) {
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+  // Note the wording in the Standard is inefficient. The output of
+  // std::format is a std::string which is then copied. This solution
+  // just appends a newline at the end of the output.
+  if constexpr (__print::__use_unicode_execution_charset)
+    __print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
+  else
+    __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
+#  else  // _LIBCPP_HAS_NO_UNICODE
+  __print::__vprint_nonunicode(__stream, __fmt.get(), std::make_format_args(__args...), true);
+#  endif // _LIBCPP_HAS_NO_UNICODE
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void println(FILE* __stream) {
+  std::print(__stream, "\n");
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void println() {
+  println(stdout);
+}
+
+template <class... _Args>
+_LIBCPP_HIDE_FROM_ABI void println(format_string<_Args...> __fmt, _Args&&... __args) {
+  std::println(stdout, __fmt, std::forward<_Args>(__args)...);
+}
+
+#  ifndef _LIBCPP_HAS_NO_UNICODE
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(FILE* __stream, string_view __fmt, format_args __args) {
+  __print::__vprint_unicode(__stream, __fmt, __args, false);
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(string_view __fmt, format_args __args) {
+  std::vprint_unicode(stdout, __fmt, __args);
+}
+
+#  endif // _LIBCPP_HAS_NO_UNICODE
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args) {
+  __print::__vprint_nonunicode(__stream, __fmt, __args, false);
+}
+
+template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
+_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(string_view __fmt, format_args __args) {
+  std::vprint_nonunicode(stdout, __fmt, __args);
+}
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_PRINT
diff --git a/third_party/libcxx/print.cpp b/third_party/libcxx/print.cpp
new file mode 100644
index 000000000..a24a98538
--- /dev/null
+++ b/third_party/libcxx/print.cpp
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+
+#include <cstdlib>
+#include <print>
+
+#include <__system_error/system_error.h>
+
+#include "third_party/libcxx/fs/error.h"
+
+#if defined(_LIBCPP_WIN32API)
+#  define WIN32_LEAN_AND_MEAN
+#  define NOMINMAX
+#  include <io.h>
+#  include <windows.h>
+#elif __has_include(<unistd.h>)
+#  include <unistd.h>
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCPP_WIN32API)
+
+_LIBCPP_EXPORTED_FROM_ABI bool __is_windows_terminal(FILE* __stream) {
+  // Note the Standard does this in one call, but it's unclear whether
+  // an invalid handle is allowed when calling GetConsoleMode.
+  //
+  // https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/get-osfhandle?view=msvc-170
+  // https://learn.microsoft.com/en-us/windows/console/getconsolemode
+  intptr_t __handle = _get_osfhandle(fileno(__stream));
+  if (__handle == -1)
+    return false;
+
+  unsigned long __mode;
+  return GetConsoleMode(reinterpret_cast<void*>(__handle), &__mode);
+}
+
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+_LIBCPP_EXPORTED_FROM_ABI void
+__write_to_windows_console([[maybe_unused]] FILE* __stream, [[maybe_unused]] wstring_view __view) {
+  // https://learn.microsoft.com/en-us/windows/console/writeconsole
+  if (WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fileno(__stream))), // clang-format aid
+                    __view.data(),
+                    __view.size(),
+                    nullptr,
+                    nullptr) == 0) {
+    __throw_system_error(filesystem::detail::make_windows_error(GetLastError()), "failed to write formatted output");
+  }
+}
+#  endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+#elif __has_include(<unistd.h>) // !_LIBCPP_WIN32API
+
+_LIBCPP_EXPORTED_FROM_ABI bool __is_posix_terminal(FILE* __stream) { return isatty(fileno(__stream)); }
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/queue b/third_party/libcxx/queue
index 4e8398cf0..9508de9f9 100644
--- a/third_party/libcxx/queue
+++ b/third_party/libcxx/queue
@@ -43,6 +43,7 @@ public:
     explicit queue(container_type&& c)
     template<class InputIterator>
         queue(InputIterator first, InputIterator last); // since C++23
+    template<container-compatible-range<T> R> queue(from_range_t, R&& rg); // since C++23
     template <class Alloc>
         explicit queue(const Alloc& a);
     template <class Alloc>
@@ -55,6 +56,8 @@ public:
         queue(queue&& q, const Alloc& a);
     template <class InputIterator, class Alloc>
         queue(InputIterator first, InputIterator last, const Alloc&); // since C++23
+    template<container-compatible-range<T> R, class Alloc>
+        queue(from_range_t, R&& rg, const Alloc&); // since C++23
 
     bool      empty() const;
     size_type size() const;
@@ -66,6 +69,8 @@ public:
 
     void push(const value_type& v);
     void push(value_type&& v);
+    template<container-compatible-range<T> R>
+      void push_range(R&& rg); // C++23
     template <class... Args> reference emplace(Args&&... args); // reference in C++17
     void pop();
 
@@ -78,6 +83,9 @@ template<class Container>
 template<class InputIterator>
   queue(InputIterator, InputIterator) -> queue<iter-value-type<InputIterator>>; // since C++23
 
+template<ranges::input_range R>
+  queue(from_range_t, R&&) -> queue<ranges::range_value_t<R>>; // since C++23
+
 template<class Container, class Allocator>
   queue(Container, Allocator) -> queue<typename Container::value_type, Container>; // C++17
 
@@ -86,6 +94,10 @@ template<class InputIterator, class Allocator>
   -> queue<iter-value-type<InputIterator>,
            deque<iter-value-type<InputIterator>, Allocator>>; // since C++23
 
+template<ranges::input_range R, class Allocator>
+    queue(from_range_t, R&&, Allocator)
+      -> queue<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
+
 template <class T, class Container>
   bool operator==(const queue<T, Container>& x,const queue<T, Container>& y);
 
@@ -104,6 +116,10 @@ template <class T, class Container>
 template <class T, class Container>
   bool operator<=(const queue<T, Container>& x,const queue<T, Container>& y);
 
+template<class T, three_way_comparable Container>
+  compare_three_way_result_t<Container>
+    operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);  // since C++20
+
 template <class T, class Container>
   void swap(queue<T, Container>& x, queue<T, Container>& y)
   noexcept(noexcept(x.swap(y)));
@@ -138,6 +154,8 @@ public:
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, Container&& c);
+    template <container-compatible-range<T> R>
+        priority_queue(from_range_t, R&& rg, const Compare& x = Compare()); // since C++23
     template <class Alloc>
         explicit priority_queue(const Alloc& a);
     template <class Alloc>
@@ -160,6 +178,10 @@ public:
     template <class InputIterator>
         priority_queue(InputIterator first, InputIterator last,
                        const Compare& comp, Container&& c, const Alloc& a);
+    template <container-compatible-range<T> R, class Alloc>
+      priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&); // since C++23
+    template <container-compatible-range<T> R, class Alloc>
+      priority_queue(from_range_t, R&& rg, const Alloc&); // since C++23
     template <class Alloc>
         priority_queue(const priority_queue& q, const Alloc& a);
     template <class Alloc>
@@ -171,6 +193,8 @@ public:
 
     void push(const value_type& v);
     void push(value_type&& v);
+    template<container-compatible-range<T> R>
+      void push_range(R&& rg); // C++23
     template <class... Args> void emplace(Args&&... args);
     void pop();
 
@@ -189,6 +213,10 @@ template<class InputIterator,
 priority_queue(InputIterator, InputIterator, Compare = Compare(), Container = Container())
     -> priority_queue<iter-value-type<InputIterator>, Container, Compare>; // C++17
 
+template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>>
+  priority_queue(from_range_t, R&&, Compare = Compare())
+    -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>>, Compare>; // C++23
+
 template<class Compare, class Container, class Allocator>
 priority_queue(Compare, Container, Allocator)
     -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
@@ -208,6 +236,15 @@ template<class InputIterator, class Compare, class Container, class Allocator>
 priority_queue(InputIterator, InputIterator, Compare, Container, Allocator)
     -> priority_queue<typename Container::value_type, Container, Compare>; // C++17
 
+template<ranges::input_range R, class Compare, class Allocator>
+  priority_queue(from_range_t, R&&, Compare, Allocator)
+    -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>,
+                        Compare>; // C++23
+
+template<ranges::input_range R, class Allocator>
+  priority_queue(from_range_t, R&&, Allocator)
+    -> priority_queue<ranges::range_value_t<R>, vector<ranges::range_value_t<R>, Allocator>>; // C++23
+
 template <class T, class Container, class Compare>
   void swap(priority_queue<T, Container, Compare>& x,
             priority_queue<T, Container, Compare>& y)
@@ -220,11 +257,18 @@ template <class T, class Container, class Compare>
 #include <__algorithm/make_heap.h>
 #include <__algorithm/pop_heap.h>
 #include <__algorithm/push_heap.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__algorithm/ranges_copy.h>
 #include <__config>
 #include <__functional/operations.h>
+#include <__fwd/deque.h>
+#include <__fwd/queue.h>
+#include <__iterator/back_insert_iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__utility/forward.h>
 #include <deque>
 #include <vector>
@@ -240,727 +284,668 @@ template <class T, class Container, class Compare>
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TEMPLATE_VIS queue;
+template <class _Tp, class _Container>
+_LIBCPP_HIDE_FROM_ABI bool operator==(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
-
-template <class _Tp, class _Container>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y);
+_LIBCPP_HIDE_FROM_ABI bool operator<(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container /*= deque<_Tp>*/>
-class _LIBCPP_TEMPLATE_VIS queue
-{
+class _LIBCPP_TEMPLATE_VIS queue {
 public:
-    typedef _Container                               container_type;
-    typedef typename container_type::value_type      value_type;
-    typedef typename container_type::reference       reference;
-    typedef typename container_type::const_reference const_reference;
-    typedef typename container_type::size_type       size_type;
-    static_assert((is_same<_Tp, value_type>::value), "" );
+  typedef _Container container_type;
+  typedef typename container_type::value_type value_type;
+  typedef typename container_type::reference reference;
+  typedef typename container_type::const_reference const_reference;
+  typedef typename container_type::size_type size_type;
+  static_assert(is_same<_Tp, value_type>::value, "");
 
 protected:
-    container_type c;
+  container_type c;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    queue()
-        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
-        : c() {}
+  _LIBCPP_HIDE_FROM_ABI queue() _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value) : c() {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    queue(const queue& __q) : c(__q.c) {}
+  _LIBCPP_HIDE_FROM_ABI queue(const queue& __q) : c(__q.c) {}
 
 #if _LIBCPP_STD_VER >= 23
-    template <class _InputIterator,
-              class = __enable_if_t<__has_input_iterator_category<_InputIterator>::value>>
-    _LIBCPP_HIDE_FROM_ABI
-    queue(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
+  template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI queue(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
+
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI queue(from_range_t, _Range&& __range) : c(from_range, std::forward<_Range>(__range)) {}
+
+  template <class _InputIterator,
+            class _Alloc,
+            __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0,
+            __enable_if_t<uses_allocator<container_type, _Alloc>::value, int>        = 0>
+  _LIBCPP_HIDE_FROM_ABI queue(_InputIterator __first, _InputIterator __second, const _Alloc& __alloc)
+      : c(__first, __second, __alloc) {}
+
+  template <_ContainerCompatibleRange<_Tp> _Range,
+            class _Alloc,
+            __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI queue(from_range_t, _Range&& __range, const _Alloc& __alloc)
+      : c(from_range, std::forward<_Range>(__range), __alloc) {}
 
-    template <class _InputIterator,
-              class _Alloc,
-              class = __enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-              class = __enable_if_t<uses_allocator<container_type, _Alloc>::value>>
-    _LIBCPP_HIDE_FROM_ABI
-    queue(_InputIterator __first, _InputIterator __second, const _Alloc& __alloc) : c(__first, __second, __alloc) {}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    queue& operator=(const queue& __q) {c = __q.c; return *this;}
+  _LIBCPP_HIDE_FROM_ABI queue& operator=(const queue& __q) {
+    c = __q.c;
+    return *this;
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    queue(queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
-        : c(_VSTD::move(__q.c)) {}
+  _LIBCPP_HIDE_FROM_ABI queue(queue&& __q) noexcept(is_nothrow_move_constructible<container_type>::value)
+      : c(std::move(__q.c)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    queue& operator=(queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
-        {c = _VSTD::move(__q.c); return *this;}
+  _LIBCPP_HIDE_FROM_ABI queue& operator=(queue&& __q) noexcept(is_nothrow_move_assignable<container_type>::value) {
+    c = std::move(__q.c);
+    return *this;
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit queue(const container_type& __c)  : c(__c) {}
+  _LIBCPP_HIDE_FROM_ABI explicit queue(const container_type& __c) : c(__c) {}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit queue(container_type&& __c) : c(_VSTD::move(__c)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit queue(container_type&& __c) : c(std::move(__c)) {}
 #endif // _LIBCPP_CXX03_LANG
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit queue(const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
-            : c(__a) {}
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        queue(const queue& __q, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
-            : c(__q.c, __a) {}
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        queue(const container_type& __c, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
-            : c(__c, __a) {}
+
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit queue(const _Alloc& __a) : c(__a) {}
+
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI queue(const queue& __q, const _Alloc& __a) : c(__q.c, __a) {}
+
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI queue(const container_type& __c, const _Alloc& __a) : c(__c, __a) {}
+
 #ifndef _LIBCPP_CXX03_LANG
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        queue(container_type&& __c, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
-            : c(_VSTD::move(__c), __a) {}
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        queue(queue&& __q, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
-            : c(_VSTD::move(__q.c), __a) {}
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI queue(container_type&& __c, const _Alloc& __a) : c(std::move(__c), __a) {}
 
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI queue(queue&& __q, const _Alloc& __a) : c(std::move(__q.c), __a) {}
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const {return c.empty();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const  {return c.size();}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference       front()       {return c.front();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference front() const {return c.front();}
-    _LIBCPP_INLINE_VISIBILITY
-    reference       back()        {return c.back();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference back() const  {return c.back();}
+  _LIBCPP_HIDE_FROM_ABI reference front() { return c.front(); }
+  _LIBCPP_HIDE_FROM_ABI const_reference front() const { return c.front(); }
+  _LIBCPP_HIDE_FROM_ABI reference back() { return c.back(); }
+  _LIBCPP_HIDE_FROM_ABI const_reference back() const { return c.back(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void push(const value_type& __v) {c.push_back(__v);}
+  _LIBCPP_HIDE_FROM_ABI void push(const value_type& __v) { c.push_back(__v); }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void push(value_type&& __v)      {c.push_back(_VSTD::move(__v));}
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-#if _LIBCPP_STD_VER >= 17
-        decltype(auto) emplace(_Args&&... __args)
-            { return c.emplace_back(_VSTD::forward<_Args>(__args)...);}
-#else
-        void     emplace(_Args&&... __args)
-            {        c.emplace_back(_VSTD::forward<_Args>(__args)...);}
-#endif
-#endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void pop() {c.pop_front();}
+  _LIBCPP_HIDE_FROM_ABI void push(value_type&& __v) { c.push_back(std::move(__v)); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(queue& __q)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
-    {
-        using _VSTD::swap;
-        swap(c, __q.c);
+#  if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void push_range(_Range&& __range) {
+    if constexpr (requires(container_type& __c) { __c.append_range(std::forward<_Range>(__range)); }) {
+      c.append_range(std::forward<_Range>(__range));
+    } else {
+      ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
     }
+  }
+#  endif
 
-    _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI
+#  if _LIBCPP_STD_VER >= 17
+  decltype(auto)
+  emplace(_Args&&... __args) {
+    return c.emplace_back(std::forward<_Args>(__args)...);
+  }
+#  else
+  void
+  emplace(_Args&&... __args) {
+    c.emplace_back(std::forward<_Args>(__args)...);
+  }
+#  endif
+#endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI void pop() { c.pop_front(); }
 
-    template <class _T1, class _C1>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    bool
-    operator==(const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
+  _LIBCPP_HIDE_FROM_ABI void swap(queue& __q) _NOEXCEPT_(__is_nothrow_swappable_v<container_type>) {
+    using std::swap;
+    swap(c, __q.c);
+  }
 
-    template <class _T1, class _C1>
-    friend
-    _LIBCPP_INLINE_VISIBILITY
-    bool
-    operator< (const queue<_T1, _C1>& __x,const queue<_T1, _C1>& __y);
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; }
+
+  template <class _T1, class _OtherContainer>
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const queue<_T1, _OtherContainer>& __x, const queue<_T1, _OtherContainer>& __y);
+
+  template <class _T1, class _OtherContainer>
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator<(const queue<_T1, _OtherContainer>& __x, const queue<_T1, _OtherContainer>& __y);
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _Container,
-         class = enable_if_t<!__is_allocator<_Container>::value>
->
-queue(_Container)
-    -> queue<typename _Container::value_type, _Container>;
+template <class _Container, class = enable_if_t<!__is_allocator<_Container>::value> >
+queue(_Container) -> queue<typename _Container::value_type, _Container>;
 
-template<class _Container,
-         class _Alloc,
-         class = enable_if_t<!__is_allocator<_Container>::value>,
-         class = enable_if_t<uses_allocator<_Container, _Alloc>::value>
->
-queue(_Container, _Alloc)
-    -> queue<typename _Container::value_type, _Container>;
+template <class _Container,
+          class _Alloc,
+          class = enable_if_t<!__is_allocator<_Container>::value>,
+          class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
+queue(_Container, _Alloc) -> queue<typename _Container::value_type, _Container>;
 #endif
 
 #if _LIBCPP_STD_VER >= 23
-template <class _InputIterator,
-          class = __enable_if_t<__has_input_iterator_category<_InputIterator>::value>>
-queue(_InputIterator, _InputIterator)
-    -> queue<__iter_value_type<_InputIterator>>;
+template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
+queue(_InputIterator, _InputIterator) -> queue<__iter_value_type<_InputIterator>>;
+
+template <ranges::input_range _Range>
+queue(from_range_t, _Range&&) -> queue<ranges::range_value_t<_Range>>;
 
 template <class _InputIterator,
           class _Alloc,
-          class = __enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = __enable_if_t<__is_allocator<_Alloc>::value>>
-queue(_InputIterator, _InputIterator, _Alloc)
-    -> queue<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;
+          __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0,
+          __enable_if_t<__is_allocator<_Alloc>::value, int>                        = 0>
+queue(_InputIterator,
+      _InputIterator,
+      _Alloc) -> queue<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;
+
+template <ranges::input_range _Range, class _Alloc, __enable_if_t<__is_allocator<_Alloc>::value, int> = 0>
+queue(from_range_t,
+      _Range&&,
+      _Alloc) -> queue<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
 #endif
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
-{
-    return __x.c == __y.c;
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
+  return __x.c == __y.c;
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
-{
-    return __x.c < __y.c;
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
+  return __x.c < __y.c;
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
+  return !(__x == __y);
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator> (const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
+  return __y < __x;
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
+  return !(__x < __y);
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const queue<_Tp, _Container>& __x,const queue<_Tp, _Container>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
+  return !(__y < __x);
 }
 
-template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-__enable_if_t<__is_swappable<_Container>::value, void>
-swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp, three_way_comparable _Container>
+_LIBCPP_HIDE_FROM_ABI compare_three_way_result_t<_Container>
+operator<=>(const queue<_Tp, _Container>& __x, const queue<_Tp, _Container>& __y) {
+  // clang 16 bug: declaring `friend operator<=>` causes "use of overloaded operator '*' is ambiguous" errors
+  return __x.__get_container() <=> __y.__get_container();
+}
+
+#endif
+
+template <class _Tp, class _Container, __enable_if_t<__is_swappable_v<_Container>, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 template <class _Tp, class _Container, class _Alloc>
-struct _LIBCPP_TEMPLATE_VIS uses_allocator<queue<_Tp, _Container>, _Alloc>
-    : public uses_allocator<_Container, _Alloc>
-{
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<queue<_Tp, _Container>, _Alloc> : public uses_allocator<_Container, _Alloc> {
 };
 
-template <class _Tp, class _Container = vector<_Tp>,
-          class _Compare = less<typename _Container::value_type> >
-class _LIBCPP_TEMPLATE_VIS priority_queue
-{
+template <class _Tp, class _Container, class _Compare>
+class _LIBCPP_TEMPLATE_VIS priority_queue {
 public:
-    typedef _Container                               container_type;
-    typedef _Compare                                 value_compare;
-    typedef typename container_type::value_type      value_type;
-    typedef typename container_type::reference       reference;
-    typedef typename container_type::const_reference const_reference;
-    typedef typename container_type::size_type       size_type;
-    static_assert((is_same<_Tp, value_type>::value), "" );
+  typedef _Container container_type;
+  typedef _Compare value_compare;
+  typedef typename container_type::value_type value_type;
+  typedef typename container_type::reference reference;
+  typedef typename container_type::const_reference const_reference;
+  typedef typename container_type::size_type size_type;
+  static_assert(is_same<_Tp, value_type>::value, "");
 
 protected:
-    container_type c;
-    value_compare comp;
+  container_type c;
+  value_compare comp;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue()
-        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value &&
-                   is_nothrow_default_constructible<value_compare>::value)
-        : c(), comp() {}
+  _LIBCPP_HIDE_FROM_ABI priority_queue() _NOEXCEPT_(
+      is_nothrow_default_constructible<container_type>::value&& is_nothrow_default_constructible<value_compare>::value)
+      : c(), comp() {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue(const priority_queue& __q) : c(__q.c), comp(__q.comp) {}
+  _LIBCPP_HIDE_FROM_ABI priority_queue(const priority_queue& __q) : c(__q.c), comp(__q.comp) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue& operator=(const priority_queue& __q)
-        {c = __q.c; comp = __q.comp; return *this;}
+  _LIBCPP_HIDE_FROM_ABI priority_queue& operator=(const priority_queue& __q) {
+    c    = __q.c;
+    comp = __q.comp;
+    return *this;
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue(priority_queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value &&
-                   is_nothrow_move_constructible<value_compare>::value)
-        : c(_VSTD::move(__q.c)), comp(_VSTD::move(__q.comp)) {}
+  _LIBCPP_HIDE_FROM_ABI priority_queue(priority_queue&& __q) noexcept(
+      is_nothrow_move_constructible<container_type>::value && is_nothrow_move_constructible<value_compare>::value)
+      : c(std::move(__q.c)), comp(std::move(__q.comp)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue& operator=(priority_queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value &&
-                   is_nothrow_move_assignable<value_compare>::value)
-        {c = _VSTD::move(__q.c); comp = _VSTD::move(__q.comp); return *this;}
+  _LIBCPP_HIDE_FROM_ABI priority_queue& operator=(priority_queue&& __q) noexcept(
+      is_nothrow_move_assignable<container_type>::value && is_nothrow_move_assignable<value_compare>::value) {
+    c    = std::move(__q.c);
+    comp = std::move(__q.comp);
+    return *this;
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit priority_queue(const value_compare& __comp)
-        : c(), comp(__comp) {}
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue(const value_compare& __comp, const container_type& __c);
+  _LIBCPP_HIDE_FROM_ABI explicit priority_queue(const value_compare& __comp) : c(), comp(__comp) {}
+  _LIBCPP_HIDE_FROM_ABI priority_queue(const value_compare& __comp, const container_type& __c);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue(const value_compare& __comp, container_type&& __c);
+  _LIBCPP_HIDE_FROM_ABI priority_queue(const value_compare& __comp, container_type&& __c);
 #endif
-    template <class _InputIter, class = __enable_if_t<__has_input_iterator_category<_InputIter>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(_InputIter __f, _InputIter __l,
-                       const value_compare& __comp = value_compare());
-    template <class _InputIter, class = __enable_if_t<__has_input_iterator_category<_InputIter>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(_InputIter __f, _InputIter __l,
-                       const value_compare& __comp, const container_type& __c);
+  template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp = value_compare());
+
+  template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c);
+
 #ifndef _LIBCPP_CXX03_LANG
-    template <class _InputIter, class = __enable_if_t<__has_input_iterator_category<_InputIter>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(_InputIter __f, _InputIter __l,
-                       const value_compare& __comp, container_type&& __c);
-#endif // _LIBCPP_CXX03_LANG
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit priority_queue(const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(const value_compare& __comp, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(const value_compare& __comp, const container_type& __c,
-                       const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(const priority_queue& __q, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
-#ifndef _LIBCPP_CXX03_LANG
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(const value_compare& __comp, container_type&& __c,
-                       const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(priority_queue&& __q, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
+  template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, container_type&& __c);
 #endif // _LIBCPP_CXX03_LANG
 
-    template <class _InputIter, class _Alloc, class = __enable_if_t<__has_input_iterator_category<_InputIter>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(_InputIter __f, _InputIter __l, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(from_range_t, _Range&& __range, const value_compare& __comp = value_compare())
+      : c(from_range, std::forward<_Range>(__range)), comp(__comp) {
+    std::make_heap(c.begin(), c.end(), comp);
+  }
+#endif
 
-    template <class _InputIter, class _Alloc, class = __enable_if_t<__has_input_iterator_category<_InputIter>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(_InputIter __f, _InputIter __l,
-                       const value_compare& __comp, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit priority_queue(const _Alloc& __a);
 
-    template <class _InputIter, class _Alloc, class = __enable_if_t<__has_input_iterator_category<_InputIter>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(_InputIter __f, _InputIter __l,
-                       const value_compare& __comp, const container_type& __c, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(const value_compare& __comp, const _Alloc& __a);
+
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(const value_compare& __comp, const container_type& __c, const _Alloc& __a);
+
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(const priority_queue& __q, const _Alloc& __a);
 
 #ifndef _LIBCPP_CXX03_LANG
-    template <class _InputIter, class _Alloc, class = __enable_if_t<__has_input_iterator_category<_InputIter>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        priority_queue(_InputIter __f, _InputIter __l,
-                       const value_compare& __comp, container_type&& __c, const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0);
-#endif  // _LIBCPP_CXX03_LANG
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(const value_compare& __comp, container_type&& __c, const _Alloc& __a);
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool            empty() const {return c.empty();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type       size() const  {return c.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference top() const   {return c.front();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void push(const value_type& __v);
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void push(value_type&& __v);
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    void emplace(_Args&&... __args);
+  template <class _Alloc, __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(priority_queue&& __q, const _Alloc& __a);
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void pop();
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(priority_queue& __q)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
-                   __is_nothrow_swappable<value_compare>::value);
+  template <
+      class _InputIter,
+      class _Alloc,
+      __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(_InputIter __f, _InputIter __l, const _Alloc& __a);
 
-    _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; }
+  template <
+      class _InputIter,
+      class _Alloc,
+      __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, const _Alloc& __a);
+
+  template <
+      class _InputIter,
+      class _Alloc,
+      __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(
+      _InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c, const _Alloc& __a);
+
+#ifndef _LIBCPP_CXX03_LANG
+  template <
+      class _InputIter,
+      class _Alloc,
+      __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<container_type, _Alloc>::value,
+                    int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  priority_queue(_InputIter __f, _InputIter __l, const value_compare& __comp, container_type&& __c, const _Alloc& __a);
+#endif // _LIBCPP_CXX03_LANG
+
+#if _LIBCPP_STD_VER >= 23
+
+  template <_ContainerCompatibleRange<_Tp> _Range,
+            class _Alloc,
+            class = enable_if_t<uses_allocator<_Container, _Alloc>::value>>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(from_range_t, _Range&& __range, const value_compare& __comp, const _Alloc& __a)
+      : c(from_range, std::forward<_Range>(__range), __a), comp(__comp) {
+    std::make_heap(c.begin(), c.end(), comp);
+  }
+
+  template <_ContainerCompatibleRange<_Tp> _Range,
+            class _Alloc,
+            class = enable_if_t<uses_allocator<_Container, _Alloc>::value>>
+  _LIBCPP_HIDE_FROM_ABI priority_queue(from_range_t, _Range&& __range, const _Alloc& __a)
+      : c(from_range, std::forward<_Range>(__range), __a), comp() {
+    std::make_heap(c.begin(), c.end(), comp);
+  }
+
+#endif
+
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }
+  _LIBCPP_HIDE_FROM_ABI const_reference top() const { return c.front(); }
+
+  _LIBCPP_HIDE_FROM_ABI void push(const value_type& __v);
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI void push(value_type&& __v);
+
+#  if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void push_range(_Range&& __range) {
+    if constexpr (requires(container_type& __c) { __c.append_range(std::forward<_Range>(__range)); }) {
+      c.append_range(std::forward<_Range>(__range));
+    } else {
+      ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
+    }
+
+    std::make_heap(c.begin(), c.end(), comp);
+  }
+#  endif
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void emplace(_Args&&... __args);
+#endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI void pop();
+
+  _LIBCPP_HIDE_FROM_ABI void swap(priority_queue& __q)
+      _NOEXCEPT_(__is_nothrow_swappable_v<container_type>&& __is_nothrow_swappable_v<value_compare>);
+
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; }
 };
 
 #if _LIBCPP_STD_VER >= 17
 template <class _Compare,
           class _Container,
           class = enable_if_t<!__is_allocator<_Compare>::value>,
-          class = enable_if_t<!__is_allocator<_Container>::value>
->
-priority_queue(_Compare, _Container)
-    -> priority_queue<typename _Container::value_type, _Container, _Compare>;
+          class = enable_if_t<!__is_allocator<_Container>::value> >
+priority_queue(_Compare, _Container) -> priority_queue<typename _Container::value_type, _Container, _Compare>;
 
-template<class _InputIterator,
-         class _Compare = less<__iter_value_type<_InputIterator>>,
-         class _Container = vector<__iter_value_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Compare>::value>,
-         class = enable_if_t<!__is_allocator<_Container>::value>
->
+template <class _InputIterator,
+          class _Compare   = less<__iter_value_type<_InputIterator>>,
+          class _Container = vector<__iter_value_type<_InputIterator>>,
+          class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value>,
+          class            = enable_if_t<!__is_allocator<_Container>::value> >
 priority_queue(_InputIterator, _InputIterator, _Compare = _Compare(), _Container = _Container())
     -> priority_queue<__iter_value_type<_InputIterator>, _Container, _Compare>;
 
-template<class _Compare,
-         class _Container,
-         class _Alloc,
-         class = enable_if_t<!__is_allocator<_Compare>::value>,
-         class = enable_if_t<!__is_allocator<_Container>::value>,
-         class = enable_if_t<uses_allocator<_Container, _Alloc>::value>
->
-priority_queue(_Compare, _Container, _Alloc)
-    -> priority_queue<typename _Container::value_type, _Container, _Compare>;
+template <class _Compare,
+          class _Container,
+          class _Alloc,
+          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<!__is_allocator<_Container>::value>,
+          class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
+priority_queue(_Compare, _Container, _Alloc) -> priority_queue<typename _Container::value_type, _Container, _Compare>;
 
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>
->
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value> >
 priority_queue(_InputIterator, _InputIterator, _Allocator)
     -> priority_queue<__iter_value_type<_InputIterator>,
                       vector<__iter_value_type<_InputIterator>, _Allocator>,
                       less<__iter_value_type<_InputIterator>>>;
 
-template<class _InputIterator, class _Compare, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Compare>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>
->
+template <class _InputIterator,
+          class _Compare,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value> >
 priority_queue(_InputIterator, _InputIterator, _Compare, _Allocator)
     -> priority_queue<__iter_value_type<_InputIterator>,
-                      vector<__iter_value_type<_InputIterator>, _Allocator>, _Compare>;
+                      vector<__iter_value_type<_InputIterator>, _Allocator>,
+                      _Compare>;
 
-template<class _InputIterator, class _Compare, class _Container, class _Alloc,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Compare>::value>,
-         class = enable_if_t<!__is_allocator<_Container>::value>,
-         class = enable_if_t<uses_allocator<_Container, _Alloc>::value>
->
+template <class _InputIterator,
+          class _Compare,
+          class _Container,
+          class _Alloc,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<!__is_allocator<_Container>::value>,
+          class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
 priority_queue(_InputIterator, _InputIterator, _Compare, _Container, _Alloc)
     -> priority_queue<typename _Container::value_type, _Container, _Compare>;
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range,
+          class _Compare = less<ranges::range_value_t<_Range>>,
+          class          = enable_if_t<!__is_allocator<_Compare>::value>>
+priority_queue(from_range_t, _Range&&, _Compare = _Compare())
+    -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>>, _Compare>;
+
+template <ranges::input_range _Range,
+          class _Compare,
+          class _Alloc,
+          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<__is_allocator<_Alloc>::value>>
+priority_queue(from_range_t, _Range&&, _Compare, _Alloc)
+    -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>, _Compare>;
+
+template <ranges::input_range _Range, class _Alloc, class = enable_if_t<__is_allocator<_Alloc>::value>>
+priority_queue(from_range_t, _Range&&, _Alloc)
+    -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>>;
+
+#endif
+
 template <class _Tp, class _Container, class _Compare>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp,
-                                                          const container_type& __c)
-    : c(__c),
-      comp(__comp)
-{
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp, const container_type& __c)
+    : c(__c), comp(__comp) {
+  std::make_heap(c.begin(), c.end(), comp);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Container, class _Compare>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
-                                                          container_type&& __c)
-    : c(_VSTD::move(__c)),
-      comp(__comp)
-{
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp, container_type&& __c)
+    : c(std::move(__c)), comp(__comp) {
+  std::make_heap(c.begin(), c.end(), comp);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Container, class _Compare>
-template <class _InputIter, class>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
-                                                          const value_compare& __comp)
-    : c(__f, __l),
-      comp(__comp)
-{
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
+    _InputIter __f, _InputIter __l, const value_compare& __comp)
+    : c(__f, __l), comp(__comp) {
+  std::make_heap(c.begin(), c.end(), comp);
 }
 
 template <class _Tp, class _Container, class _Compare>
-template <class _InputIter, class>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
-                                                          const value_compare& __comp,
-                                                          const container_type& __c)
-    : c(__c),
-      comp(__comp)
-{
-    c.insert(c.end(), __f, __l);
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
+    _InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c)
+    : c(__c), comp(__comp) {
+  c.insert(c.end(), __f, __l);
+  std::make_heap(c.begin(), c.end(), comp);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Container, class _Compare>
-template <class _InputIter, class>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
-                                                          const value_compare& __comp,
-                                                          container_type&& __c)
-    : c(_VSTD::move(__c)),
-      comp(__comp)
-{
-    c.insert(c.end(), __f, __l);
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+template <class _InputIter, __enable_if_t<__has_input_iterator_category<_InputIter>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
+    _InputIter __f, _InputIter __l, const value_compare& __comp, container_type&& __c)
+    : c(std::move(__c)), comp(__comp) {
+  c.insert(c.end(), __f, __l);
+  std::make_heap(c.begin(), c.end(), comp);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Container, class _Compare>
-template <class _Alloc>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>*)
-    : c(__a)
-{
+template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Alloc& __a) : c(__a) {}
+
+template <class _Tp, class _Container, class _Compare>
+template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp, const _Alloc& __a)
+    : c(__a), comp(__comp) {}
+
+template <class _Tp, class _Container, class _Compare>
+template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
+    const value_compare& __comp, const container_type& __c, const _Alloc& __a)
+    : c(__c, __a), comp(__comp) {
+  std::make_heap(c.begin(), c.end(), comp);
 }
 
 template <class _Tp, class _Container, class _Compare>
-template <class _Alloc>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
-                                                          const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>*)
-    : c(__a),
-      comp(__comp)
-{
+template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue& __q, const _Alloc& __a)
+    : c(__q.c, __a), comp(__q.comp) {}
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Tp, class _Container, class _Compare>
+template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
+    const value_compare& __comp, container_type&& __c, const _Alloc& __a)
+    : c(std::move(__c), __a), comp(__comp) {
+  std::make_heap(c.begin(), c.end(), comp);
 }
 
 template <class _Tp, class _Container, class _Compare>
-template <class _Alloc>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
-                                                          const container_type& __c,
-                                                          const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>*)
-    : c(__c, __a),
-      comp(__comp)
-{
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+template <class _Alloc, __enable_if_t<uses_allocator<_Container, _Alloc>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q, const _Alloc& __a)
+    : c(std::move(__q.c), __a), comp(std::move(__q.comp)) {}
+
+#endif // _LIBCPP_CXX03_LANG
+
+template <class _Tp, class _Container, class _Compare>
+template <
+    class _InputIter,
+    class _Alloc,
+    __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l, const _Alloc& __a)
+    : c(__f, __l, __a), comp() {
+  std::make_heap(c.begin(), c.end(), comp);
 }
 
 template <class _Tp, class _Container, class _Compare>
-template <class _Alloc>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue& __q,
-                                                          const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>*)
-    : c(__q.c, __a),
-      comp(__q.comp)
-{
+template <
+    class _InputIter,
+    class _Alloc,
+    __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
+    _InputIter __f, _InputIter __l, const value_compare& __comp, const _Alloc& __a)
+    : c(__f, __l, __a), comp(__comp) {
+  std::make_heap(c.begin(), c.end(), comp);
+}
+
+template <class _Tp, class _Container, class _Compare>
+template <
+    class _InputIter,
+    class _Alloc,
+    __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
+    _InputIter __f, _InputIter __l, const value_compare& __comp, const container_type& __c, const _Alloc& __a)
+    : c(__c, __a), comp(__comp) {
+  c.insert(c.end(), __f, __l);
+  std::make_heap(c.begin(), c.end(), comp);
+}
+
+#ifndef _LIBCPP_CXX03_LANG
+template <class _Tp, class _Container, class _Compare>
+template <
+    class _InputIter,
+    class _Alloc,
+    __enable_if_t<__has_input_iterator_category<_InputIter>::value && uses_allocator<_Container, _Alloc>::value, int> >
+inline priority_queue<_Tp, _Container, _Compare>::priority_queue(
+    _InputIter __f, _InputIter __l, const value_compare& __comp, container_type&& __c, const _Alloc& __a)
+    : c(std::move(__c), __a), comp(__comp) {
+  c.insert(c.end(), __f, __l);
+  std::make_heap(c.begin(), c.end(), comp);
+}
+#endif // _LIBCPP_CXX03_LANG
+
+template <class _Tp, class _Container, class _Compare>
+inline void priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v) {
+  c.push_back(__v);
+  std::push_heap(c.begin(), c.end(), comp);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Container, class _Compare>
-template <class _Alloc>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
-                                                          container_type&& __c,
-                                                          const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>*)
-    : c(_VSTD::move(__c), __a),
-      comp(__comp)
-{
-    _VSTD::make_heap(c.begin(), c.end(), comp);
-}
-
-template <class _Tp, class _Container, class _Compare>
-template <class _Alloc>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
-                                                          const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>*)
-    : c(_VSTD::move(__q.c), __a),
-      comp(_VSTD::move(__q.comp))
-{
-}
-
-#endif  // _LIBCPP_CXX03_LANG
-
-template <class _Tp, class _Container, class _Compare>
-template <class _InputIter, class _Alloc, class>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(
-        _InputIter __f, _InputIter __l, const _Alloc& __a,
-        __enable_if_t<uses_allocator<container_type, _Alloc>::value>*)
-    : c(__f, __l, __a),
-      comp()
-{
-    _VSTD::make_heap(c.begin(), c.end(), comp);
-}
-
-template <class _Tp, class _Container, class _Compare>
-template <class _InputIter, class _Alloc, class>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(
-        _InputIter __f, _InputIter __l,
-        const value_compare& __comp, const _Alloc& __a,
-        __enable_if_t<uses_allocator<container_type, _Alloc>::value>*)
-    : c(__f, __l, __a),
-      comp(__comp)
-{
-    _VSTD::make_heap(c.begin(), c.end(), comp);
-}
-
-template <class _Tp, class _Container, class _Compare>
-template <class _InputIter, class _Alloc, class>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(
-        _InputIter __f, _InputIter __l,
-        const value_compare& __comp, const container_type& __c, const _Alloc& __a,
-        __enable_if_t<uses_allocator<container_type, _Alloc>::value>*)
-    : c(__c, __a),
-      comp(__comp)
-{
-    c.insert(c.end(), __f, __l);
-    _VSTD::make_heap(c.begin(), c.end(), comp);
-}
-
-#ifndef _LIBCPP_CXX03_LANG
-template <class _Tp, class _Container, class _Compare>
-template <class _InputIter, class _Alloc, class>
-inline
-priority_queue<_Tp, _Container, _Compare>::priority_queue(
-        _InputIter __f, _InputIter __l, const value_compare& __comp,
-        container_type&& __c, const _Alloc& __a,
-        __enable_if_t<uses_allocator<container_type, _Alloc>::value>*)
-    : c(_VSTD::move(__c), __a),
-      comp(__comp)
-{
-    c.insert(c.end(), __f, __l);
-    _VSTD::make_heap(c.begin(), c.end(), comp);
-}
-#endif  // _LIBCPP_CXX03_LANG
-
-template <class _Tp, class _Container, class _Compare>
-inline
-void
-priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
-{
-    c.push_back(__v);
-    _VSTD::push_heap(c.begin(), c.end(), comp);
-}
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Tp, class _Container, class _Compare>
-inline
-void
-priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
-{
-    c.push_back(_VSTD::move(__v));
-    _VSTD::push_heap(c.begin(), c.end(), comp);
+inline void priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v) {
+  c.push_back(std::move(__v));
+  std::push_heap(c.begin(), c.end(), comp);
 }
 
 template <class _Tp, class _Container, class _Compare>
 template <class... _Args>
-inline
-void
-priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
-{
-    c.emplace_back(_VSTD::forward<_Args>(__args)...);
-    _VSTD::push_heap(c.begin(), c.end(), comp);
+inline void priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args) {
+  c.emplace_back(std::forward<_Args>(__args)...);
+  std::push_heap(c.begin(), c.end(), comp);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Container, class _Compare>
-inline
-void
-priority_queue<_Tp, _Container, _Compare>::pop()
-{
-    _VSTD::pop_heap(c.begin(), c.end(), comp);
-    c.pop_back();
+inline void priority_queue<_Tp, _Container, _Compare>::pop() {
+  std::pop_heap(c.begin(), c.end(), comp);
+  c.pop_back();
 }
 
 template <class _Tp, class _Container, class _Compare>
-inline
-void
-priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
-                   __is_nothrow_swappable<value_compare>::value)
-{
-    using _VSTD::swap;
-    swap(c, __q.c);
-    swap(comp, __q.comp);
+inline void priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
+    _NOEXCEPT_(__is_nothrow_swappable_v<container_type>&& __is_nothrow_swappable_v<value_compare>) {
+  using std::swap;
+  swap(c, __q.c);
+  swap(comp, __q.comp);
 }
 
-template <class _Tp, class _Container, class _Compare>
-inline _LIBCPP_INLINE_VISIBILITY
-__enable_if_t<
-    __is_swappable<_Container>::value && __is_swappable<_Compare>::value,
-    void
->
-swap(priority_queue<_Tp, _Container, _Compare>& __x,
-     priority_queue<_Tp, _Container, _Compare>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+template <class _Tp,
+          class _Container,
+          class _Compare,
+          __enable_if_t<__is_swappable_v<_Container> && __is_swappable_v<_Compare>, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(priority_queue<_Tp, _Container, _Compare>& __x, priority_queue<_Tp, _Container, _Compare>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 template <class _Tp, class _Container, class _Compare, class _Alloc>
 struct _LIBCPP_TEMPLATE_VIS uses_allocator<priority_queue<_Tp, _Container, _Compare>, _Alloc>
-    : public uses_allocator<_Container, _Alloc>
-{
-};
+    : public uses_allocator<_Container, _Alloc> {};
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstdlib>
diff --git a/third_party/libcxx/random b/third_party/libcxx/random
index 02d71ad6d..6cc3760c2 100644
--- a/third_party/libcxx/random
+++ b/third_party/libcxx/random
@@ -1677,13 +1677,11 @@ class piecewise_linear_distribution
 } // std
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__random/bernoulli_distribution.h>
 #include <__random/binomial_distribution.h>
 #include <__random/cauchy_distribution.h>
 #include <__random/chi_squared_distribution.h>
-#include <__random/clamp_to_integral.h>
 #include <__random/default_random_engine.h>
 #include <__random/discard_block_engine.h>
 #include <__random/discrete_distribution.h>
@@ -1695,10 +1693,8 @@ class piecewise_linear_distribution
 #include <__random/geometric_distribution.h>
 #include <__random/independent_bits_engine.h>
 #include <__random/is_seed_sequence.h>
-#include <__random/is_valid.h>
 #include <__random/knuth_b.h>
 #include <__random/linear_congruential_engine.h>
-#include <__random/log2.h>
 #include <__random/lognormal_distribution.h>
 #include <__random/mersenne_twister_engine.h>
 #include <__random/negative_binomial_distribution.h>
diff --git a/third_party/libcxx/random.cpp b/third_party/libcxx/random.cpp
new file mode 100644
index 000000000..14c6f4473
--- /dev/null
+++ b/third_party/libcxx/random.cpp
@@ -0,0 +1,181 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__config>
+
+#if defined(_LIBCPP_USING_WIN32_RANDOM)
+// Must be defined before including stdlib.h to enable rand_s().
+#  define _CRT_RAND_S
+#endif // defined(_LIBCPP_USING_WIN32_RANDOM)
+
+#include <__system_error/system_error.h>
+#include <limits>
+#include <random>
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(_LIBCPP_USING_GETENTROPY)
+#  include <sys/random.h>
+#elif defined(_LIBCPP_USING_DEV_RANDOM)
+#  include <fcntl.h>
+#  include <unistd.h>
+#  if __has_include(<sys/ioctl.h>) && __has_include(<linux/random.h>)
+#    include <linux/random.h>
+#    include <sys/ioctl.h>
+#  endif
+#elif defined(_LIBCPP_USING_NACL_RANDOM)
+#  include <nacl/nacl_random.h>
+#elif defined(_LIBCPP_USING_FUCHSIA_CPRNG)
+#  include <zircon/syscalls.h>
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if defined(_LIBCPP_USING_GETENTROPY)
+
+random_device::random_device(const string& __token) {
+  if (__token != "/dev/urandom")
+    __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
+}
+
+random_device::~random_device() {}
+
+unsigned random_device::operator()() {
+  unsigned r;
+  size_t n = sizeof(r);
+  int err  = getentropy(&r, n);
+  if (err)
+    __throw_system_error(errno, "random_device getentropy failed");
+  return r;
+}
+
+#elif defined(_LIBCPP_USING_ARC4_RANDOM)
+
+random_device::random_device(const string&) {}
+
+random_device::~random_device() {}
+
+unsigned random_device::operator()() { return arc4random(); }
+
+#elif defined(_LIBCPP_USING_DEV_RANDOM)
+
+random_device::random_device(const string& __token) : __f_(open(__token.c_str(), O_RDONLY)) {
+  if (__f_ < 0)
+    __throw_system_error(errno, ("random_device failed to open " + __token).c_str());
+}
+
+random_device::~random_device() { close(__f_); }
+
+unsigned random_device::operator()() {
+  unsigned r;
+  size_t n = sizeof(r);
+  char* p  = reinterpret_cast<char*>(&r);
+  while (n > 0) {
+    ssize_t s = read(__f_, p, n);
+    if (s == 0)
+      __throw_system_error(ENOMSG, "random_device got EOF");
+    if (s == -1) {
+      if (errno != EINTR)
+        __throw_system_error(errno, "random_device got an unexpected error");
+      continue;
+    }
+    n -= static_cast<size_t>(s);
+    p += static_cast<size_t>(s);
+  }
+  return r;
+}
+
+#elif defined(_LIBCPP_USING_NACL_RANDOM)
+
+random_device::random_device(const string& __token) {
+  if (__token != "/dev/urandom")
+    __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
+  int error = nacl_secure_random_init();
+  if (error)
+    __throw_system_error(error, ("random device failed to open " + __token).c_str());
+}
+
+random_device::~random_device() {}
+
+unsigned random_device::operator()() {
+  unsigned r;
+  size_t n = sizeof(r);
+  size_t bytes_written;
+  int error = nacl_secure_random(&r, n, &bytes_written);
+  if (error != 0)
+    __throw_system_error(error, "random_device failed getting bytes");
+  else if (bytes_written != n)
+    __throw_runtime_error("random_device failed to obtain enough bytes");
+  return r;
+}
+
+#elif defined(_LIBCPP_USING_WIN32_RANDOM)
+
+random_device::random_device(const string& __token) {
+  if (__token != "/dev/urandom")
+    __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
+}
+
+random_device::~random_device() {}
+
+unsigned random_device::operator()() {
+  unsigned r;
+  errno_t err = rand_s(&r);
+  if (err)
+    __throw_system_error(err, "random_device rand_s failed.");
+  return r;
+}
+
+#elif defined(_LIBCPP_USING_FUCHSIA_CPRNG)
+
+random_device::random_device(const string& __token) {
+  if (__token != "/dev/urandom")
+    __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
+}
+
+random_device::~random_device() {}
+
+unsigned random_device::operator()() {
+  // Implicitly link against the vDSO system call ABI without
+  // requiring the final link to specify -lzircon explicitly when
+  // statically linking libc++.
+#  pragma comment(lib, "zircon")
+
+  // The system call cannot fail.  It returns only when the bits are ready.
+  unsigned r;
+  _zx_cprng_draw(&r, sizeof(r));
+  return r;
+}
+
+#else
+#  error "Random device not implemented for this architecture"
+#endif
+
+double random_device::entropy() const noexcept {
+#if defined(_LIBCPP_USING_DEV_RANDOM) && defined(RNDGETENTCNT)
+  int ent;
+  if (::ioctl(__f_, RNDGETENTCNT, &ent) < 0)
+    return 0;
+
+  if (ent < 0)
+    return 0;
+
+  if (ent > std::numeric_limits<result_type>::digits)
+    return std::numeric_limits<result_type>::digits;
+
+  return ent;
+#elif defined(_LIBCPP_USING_ARC4_RANDOM) || defined(_LIBCPP_USING_FUCHSIA_CPRNG)
+  return std::numeric_limits<result_type>::digits;
+#else
+  return 0;
+#endif
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/random_shuffle.cpp b/third_party/libcxx/random_shuffle.cpp
new file mode 100644
index 000000000..3aaf71d84
--- /dev/null
+++ b/third_party/libcxx/random_shuffle.cpp
@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <algorithm>
+#include <random>
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+#  include <mutex>
+#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#    pragma comment(lib, "pthread")
+#  endif
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+static constinit __libcpp_mutex_t __rs_mut = _LIBCPP_MUTEX_INITIALIZER;
+#endif
+unsigned __rs_default::__c_ = 0;
+
+__rs_default::__rs_default() {
+#ifndef _LIBCPP_HAS_NO_THREADS
+  __libcpp_mutex_lock(&__rs_mut);
+#endif
+  __c_ = 1;
+}
+
+__rs_default::__rs_default(const __rs_default&) { ++__c_; }
+
+__rs_default::~__rs_default() {
+#ifndef _LIBCPP_HAS_NO_THREADS
+  if (--__c_ == 0)
+    __libcpp_mutex_unlock(&__rs_mut);
+#else
+  --__c_;
+#endif
+}
+
+__rs_default::result_type __rs_default::operator()() {
+  static mt19937 __rs_g;
+  return __rs_g();
+}
+
+__rs_default __rs_get() { return __rs_default(); }
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/ranges b/third_party/libcxx/ranges
index bcf05f55f..fa3587426 100644
--- a/third_party/libcxx/ranges
+++ b/third_party/libcxx/ranges
@@ -93,6 +93,11 @@ namespace std::ranges {
   template<class T>
   concept viewable_range = see below;
 
+  // [range.adaptor.object], range adaptor objects
+  template<class D>
+    requires is_class_v<D> && same_as<D, remove_cv_t<D>>
+  class range_adaptor_closure { };  // Since c++23
+
   // [view.interface], class template view_interface
   template<class D>
     requires is_class_v<D> && same_as<D, remove_cv_t<D>>
@@ -138,6 +143,16 @@ namespace std::ranges {
     inline constexpr auto values = elements<1>;
   }
 
+  // [range.utility.conv], range conversions
+  template<class C, input_range R, class... Args> requires (!view<C>)
+    constexpr C to(R&& r, Args&&... args);     // Since C++23
+  template<template<class...> class C, input_range R, class... Args>
+    constexpr auto to(R&& r, Args&&... args);  // Since C++23
+  template<class C, class... Args> requires (!view<C>)
+    constexpr auto to(Args&&... args);         // Since C++23
+  template<template<class...> class C, class... Args>
+    constexpr auto to(Args&&... args);         // Since C++23
+
   // [range.empty], empty view
   template<class T>
     requires is_object_v<T>
@@ -252,6 +267,19 @@ namespace std::ranges {
   template<class W, class Bound>
     inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
 
+  // [range.repeat], repeat view
+  template<class T>
+    concept integer-like-with-usable-difference-type =  // exposition only
+      is-signed-integer-like<T> || (is-integer-like<T> && weakly_incrementable<T>);
+
+  template<move_constructible T, semiregular Bound = unreachable_sentinel_t>
+    requires (is_object_v<T> && same_as<T, remove_cv_t<T>> &&
+              (integer-like-with-usable-difference-type<Bound> ||
+               same_as<Bound, unreachable_sentinel_t>))
+  class repeat_view;
+
+  namespace views { inline constexpr unspecified repeat = unspecified; }
+
   // [range.join], join view
   template<input_range V>
     requires view<V> && input_range<range_reference_t<V>>
@@ -297,17 +325,24 @@ namespace std::ranges {
   class zip_view;        // C++23
 
   template<class... Views>
-    inline constexpr bool enable_borrowed_range<zip_view<Views...>> =    // C++23
+    inline constexpr bool enable_borrowed_range<zip_view<Views...>> =       // C++23
       (enable_borrowed_range<Views> && ...);
 
-  namespace views { inline constexpr unspecified zip = unspecified; }    // C++23
+  namespace views { inline constexpr unspecified zip = unspecified; }       // C++23
 
   // [range.as.rvalue]
   template <view V>
     requires input_range<V>
-  class as_rvalue_view; // since C++23
+  class as_rvalue_view;                                                     // C++23
 
-  namespace views { inline constexpr unspecified as_rvalue ) unspecified; } // since C++23
+  namespace views { inline constexpr unspecified as_rvalue ) unspecified; } // C++23
+
+  [range.chunk.by]
+  template<forward_range V, indirect_binary_predicate<iterator_t<V>, iterator_t<V>> Pred>
+    requires view<V> && is_object_v<Pred>
+  class chunk_by_view;                                                      // C++23
+
+  namespace views { inline constexpr unspecified chunk_by = unspecified; }  // C++23
 }
 
 namespace std {
@@ -345,48 +380,57 @@ namespace std {
 }
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__ranges/access.h>
-#include <__ranges/all.h>
-#include <__ranges/as_rvalue_view.h>
-#include <__ranges/common_view.h>
-#include <__ranges/concepts.h>
-#include <__ranges/counted.h>
-#include <__ranges/dangling.h>
-#include <__ranges/data.h>
-#include <__ranges/drop_view.h>
-#include <__ranges/drop_while_view.h>
-#include <__ranges/elements_view.h>
-#include <__ranges/empty.h>
-#include <__ranges/empty_view.h>
-#include <__ranges/enable_borrowed_range.h>
-#include <__ranges/enable_view.h>
-#include <__ranges/filter_view.h>
-#include <__ranges/from_range.h>
-#include <__ranges/iota_view.h>
-#include <__ranges/join_view.h>
-#include <__ranges/lazy_split_view.h>
-#include <__ranges/rbegin.h>
-#include <__ranges/ref_view.h>
-#include <__ranges/rend.h>
-#include <__ranges/reverse_view.h>
-#include <__ranges/single_view.h>
-#include <__ranges/size.h>
-#include <__ranges/split_view.h>
-#include <__ranges/subrange.h>
-#include <__ranges/take_view.h>
-#include <__ranges/take_while_view.h>
-#include <__ranges/transform_view.h>
-#include <__ranges/view_interface.h>
-#include <__ranges/views.h>
-#include <__ranges/zip_view.h>
-#include <version>
 
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#include <__ranges/istream_view.h>
+#if _LIBCPP_STD_VER >= 20
+#  include <__ranges/access.h>
+#  include <__ranges/all.h>
+#  include <__ranges/common_view.h>
+#  include <__ranges/concepts.h>
+#  include <__ranges/counted.h>
+#  include <__ranges/dangling.h>
+#  include <__ranges/data.h>
+#  include <__ranges/drop_view.h>
+#  include <__ranges/drop_while_view.h>
+#  include <__ranges/elements_view.h>
+#  include <__ranges/empty.h>
+#  include <__ranges/empty_view.h>
+#  include <__ranges/enable_borrowed_range.h>
+#  include <__ranges/enable_view.h>
+#  include <__ranges/filter_view.h>
+#  include <__ranges/iota_view.h>
+#  include <__ranges/join_view.h>
+#  include <__ranges/lazy_split_view.h>
+#  include <__ranges/rbegin.h>
+#  include <__ranges/ref_view.h>
+#  include <__ranges/rend.h>
+#  include <__ranges/reverse_view.h>
+#  include <__ranges/single_view.h>
+#  include <__ranges/size.h>
+#  include <__ranges/split_view.h>
+#  include <__ranges/subrange.h>
+#  include <__ranges/take_view.h>
+#  include <__ranges/take_while_view.h>
+#  include <__ranges/transform_view.h>
+#  include <__ranges/view_interface.h>
+#  include <__ranges/views.h>
+
+#  if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#    include <__ranges/istream_view.h>
+#  endif
 #endif
 
+#if _LIBCPP_STD_VER >= 23
+#  include <__ranges/as_rvalue_view.h>
+#  include <__ranges/chunk_by_view.h>
+#  include <__ranges/from_range.h>
+#  include <__ranges/repeat_view.h>
+#  include <__ranges/to.h>
+#  include <__ranges/zip_view.h>
+#endif
+
+#include <version>
+
 // standard-mandated includes
 
 // [ranges.syn]
@@ -402,8 +446,17 @@ namespace std {
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
+#  include <cstddef>
+#  include <limits>
+#  include <optional>
+#  include <span>
+#  include <tuple>
+#endif
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <cstdlib>
+#  include <iosfwd>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/ratio b/third_party/libcxx/ratio
index 327e08cf1..b989c272a 100644
--- a/third_party/libcxx/ratio
+++ b/third_party/libcxx/ratio
@@ -40,6 +40,8 @@ template <class R1, class R2> struct ratio_greater;
 template <class R1, class R2> struct ratio_greater_equal;
 
 // convenience SI typedefs
+using quecto = ratio <1, 1'000'000'000'000'000'000'000'000'000'000>; // Since C++26; not supported
+using ronto = ratio <1, 1'000'000'000'000'000'000'000'000'000>;      // Since C++26; not supported
 typedef ratio<1, 1000000000000000000000000> yocto;  // not supported
 typedef ratio<1,    1000000000000000000000> zepto;  // not supported
 typedef ratio<1,       1000000000000000000> atto;
@@ -60,6 +62,8 @@ typedef ratio<         1000000000000000, 1> peta;
 typedef ratio<      1000000000000000000, 1> exa;
 typedef ratio<   1000000000000000000000, 1> zetta;  // not supported
 typedef ratio<1000000000000000000000000, 1> yotta;  // not supported
+using ronna = ratio <1'000'000'000'000'000'000'000'000'000, 1>;      // Since C++26; not supported
+using quetta = ratio <1'000'000'000'000'000'000'000'000'000'000, 1>; // Since C++26; not supported
 
   // 20.11.5, ratio comparison
   template <class R1, class R2> inline constexpr bool ratio_equal_v
@@ -77,7 +81,6 @@ typedef ratio<1000000000000000000000000, 1> yotta;  // not supported
 }
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__type_traits/integral_constant.h>
 #include <climits>
@@ -91,176 +94,164 @@ typedef ratio<1000000000000000000000000, 1> yotta;  // not supported
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // __static_gcd
 
 template <intmax_t _Xp, intmax_t _Yp>
-struct __static_gcd
-{
-    static const intmax_t value = __static_gcd<_Yp, _Xp % _Yp>::value;
+struct __static_gcd {
+  static const intmax_t value = __static_gcd<_Yp, _Xp % _Yp>::value;
 };
 
 template <intmax_t _Xp>
-struct __static_gcd<_Xp, 0>
-{
-    static const intmax_t value = _Xp;
+struct __static_gcd<_Xp, 0> {
+  static const intmax_t value = _Xp;
 };
 
 template <>
-struct __static_gcd<0, 0>
-{
-    static const intmax_t value = 1;
+struct __static_gcd<0, 0> {
+  static const intmax_t value = 1;
 };
 
 // __static_lcm
 
 template <intmax_t _Xp, intmax_t _Yp>
-struct __static_lcm
-{
-    static const intmax_t value = _Xp / __static_gcd<_Xp, _Yp>::value * _Yp;
+struct __static_lcm {
+  static const intmax_t value = _Xp / __static_gcd<_Xp, _Yp>::value * _Yp;
 };
 
 template <intmax_t _Xp>
-struct __static_abs
-{
-    static const intmax_t value = _Xp < 0 ? -_Xp : _Xp;
+struct __static_abs {
+  static const intmax_t value = _Xp < 0 ? -_Xp : _Xp;
 };
 
 template <intmax_t _Xp>
-struct __static_sign
-{
-    static const intmax_t value = _Xp == 0 ? 0 : (_Xp < 0 ? -1 : 1);
+struct __static_sign {
+  static const intmax_t value = _Xp == 0 ? 0 : (_Xp < 0 ? -1 : 1);
 };
 
 template <intmax_t _Xp, intmax_t _Yp, intmax_t = __static_sign<_Yp>::value>
 class __ll_add;
 
 template <intmax_t _Xp, intmax_t _Yp>
-class __ll_add<_Xp, _Yp, 1>
-{
-    static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
-    static const intmax_t max = -min;
+class __ll_add<_Xp, _Yp, 1> {
+  static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
+  static const intmax_t max = -min;
+
+  static_assert(_Xp <= max - _Yp, "overflow in __ll_add");
 
-    static_assert(_Xp <= max - _Yp, "overflow in __ll_add");
 public:
-    static const intmax_t value = _Xp + _Yp;
+  static const intmax_t value = _Xp + _Yp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp>
-class __ll_add<_Xp, _Yp, 0>
-{
+class __ll_add<_Xp, _Yp, 0> {
 public:
-    static const intmax_t value = _Xp;
+  static const intmax_t value = _Xp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp>
-class __ll_add<_Xp, _Yp, -1>
-{
-    static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
-    static const intmax_t max = -min;
+class __ll_add<_Xp, _Yp, -1> {
+  static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
+  static const intmax_t max = -min;
+
+  static_assert(min - _Yp <= _Xp, "overflow in __ll_add");
 
-    static_assert(min - _Yp <= _Xp, "overflow in __ll_add");
 public:
-    static const intmax_t value = _Xp + _Yp;
+  static const intmax_t value = _Xp + _Yp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp, intmax_t = __static_sign<_Yp>::value>
 class __ll_sub;
 
 template <intmax_t _Xp, intmax_t _Yp>
-class __ll_sub<_Xp, _Yp, 1>
-{
-    static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
-    static const intmax_t max = -min;
+class __ll_sub<_Xp, _Yp, 1> {
+  static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
+  static const intmax_t max = -min;
+
+  static_assert(min + _Yp <= _Xp, "overflow in __ll_sub");
 
-    static_assert(min + _Yp <= _Xp, "overflow in __ll_sub");
 public:
-    static const intmax_t value = _Xp - _Yp;
+  static const intmax_t value = _Xp - _Yp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp>
-class __ll_sub<_Xp, _Yp, 0>
-{
+class __ll_sub<_Xp, _Yp, 0> {
 public:
-    static const intmax_t value = _Xp;
+  static const intmax_t value = _Xp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp>
-class __ll_sub<_Xp, _Yp, -1>
-{
-    static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
-    static const intmax_t max = -min;
+class __ll_sub<_Xp, _Yp, -1> {
+  static const intmax_t min = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1;
+  static const intmax_t max = -min;
+
+  static_assert(_Xp <= max + _Yp, "overflow in __ll_sub");
 
-    static_assert(_Xp <= max + _Yp, "overflow in __ll_sub");
 public:
-    static const intmax_t value = _Xp - _Yp;
+  static const intmax_t value = _Xp - _Yp;
 };
 
 template <intmax_t _Xp, intmax_t _Yp>
-class __ll_mul
-{
-    static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
-    static const intmax_t min = nan + 1;
-    static const intmax_t max = -min;
-    static const intmax_t __a_x = __static_abs<_Xp>::value;
-    static const intmax_t __a_y = __static_abs<_Yp>::value;
+class __ll_mul {
+  static const intmax_t nan   = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
+  static const intmax_t min   = nan + 1;
+  static const intmax_t max   = -min;
+  static const intmax_t __a_x = __static_abs<_Xp>::value;
+  static const intmax_t __a_y = __static_abs<_Yp>::value;
+
+  static_assert(_Xp != nan && _Yp != nan && __a_x <= max / __a_y, "overflow in __ll_mul");
 
-    static_assert(_Xp != nan && _Yp != nan && __a_x <= max / __a_y, "overflow in __ll_mul");
 public:
-    static const intmax_t value = _Xp * _Yp;
+  static const intmax_t value = _Xp * _Yp;
 };
 
 template <intmax_t _Yp>
-class __ll_mul<0, _Yp>
-{
+class __ll_mul<0, _Yp> {
 public:
-    static const intmax_t value = 0;
+  static const intmax_t value = 0;
 };
 
 template <intmax_t _Xp>
-class __ll_mul<_Xp, 0>
-{
+class __ll_mul<_Xp, 0> {
 public:
-    static const intmax_t value = 0;
+  static const intmax_t value = 0;
 };
 
 template <>
-class __ll_mul<0, 0>
-{
+class __ll_mul<0, 0> {
 public:
-    static const intmax_t value = 0;
+  static const intmax_t value = 0;
 };
 
 // Not actually used but left here in case needed in future maintenance
 template <intmax_t _Xp, intmax_t _Yp>
-class __ll_div
-{
-    static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
-    static const intmax_t min = nan + 1;
-    static const intmax_t max = -min;
+class __ll_div {
+  static const intmax_t nan = (1LL << (sizeof(intmax_t) * CHAR_BIT - 1));
+  static const intmax_t min = nan + 1;
+  static const intmax_t max = -min;
+
+  static_assert(_Xp != nan && _Yp != nan && _Yp != 0, "overflow in __ll_div");
 
-    static_assert(_Xp != nan && _Yp != nan && _Yp != 0, "overflow in __ll_div");
 public:
-    static const intmax_t value = _Xp / _Yp;
+  static const intmax_t value = _Xp / _Yp;
 };
 
 template <intmax_t _Num, intmax_t _Den = 1>
-class _LIBCPP_TEMPLATE_VIS ratio
-{
-    static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range");
-    static_assert(_Den != 0, "ratio divide by 0");
-    static_assert(__static_abs<_Den>::value >  0, "ratio denominator is out of range");
-    static _LIBCPP_CONSTEXPR const intmax_t __na = __static_abs<_Num>::value;
-    static _LIBCPP_CONSTEXPR const intmax_t __da = __static_abs<_Den>::value;
-    static _LIBCPP_CONSTEXPR const intmax_t __s = __static_sign<_Num>::value * __static_sign<_Den>::value;
-    static _LIBCPP_CONSTEXPR const intmax_t __gcd = __static_gcd<__na, __da>::value;
-public:
-    static _LIBCPP_CONSTEXPR const intmax_t num = __s * __na / __gcd;
-    static _LIBCPP_CONSTEXPR const intmax_t den = __da / __gcd;
+class _LIBCPP_TEMPLATE_VIS ratio {
+  static_assert(__static_abs<_Num>::value >= 0, "ratio numerator is out of range");
+  static_assert(_Den != 0, "ratio divide by 0");
+  static_assert(__static_abs<_Den>::value > 0, "ratio denominator is out of range");
+  static _LIBCPP_CONSTEXPR const intmax_t __na  = __static_abs<_Num>::value;
+  static _LIBCPP_CONSTEXPR const intmax_t __da  = __static_abs<_Den>::value;
+  static _LIBCPP_CONSTEXPR const intmax_t __s   = __static_sign<_Num>::value * __static_sign<_Den>::value;
+  static _LIBCPP_CONSTEXPR const intmax_t __gcd = __static_gcd<__na, __da>::value;
 
-    typedef ratio<num, den> type;
+public:
+  static _LIBCPP_CONSTEXPR const intmax_t num = __s * __na / __gcd;
+  static _LIBCPP_CONSTEXPR const intmax_t den = __da / __gcd;
+
+  typedef ratio<num, den> type;
 };
 
 template <intmax_t _Num, intmax_t _Den>
@@ -269,236 +260,230 @@ _LIBCPP_CONSTEXPR const intmax_t ratio<_Num, _Den>::num;
 template <intmax_t _Num, intmax_t _Den>
 _LIBCPP_CONSTEXPR const intmax_t ratio<_Num, _Den>::den;
 
-template <class _Tp>                    struct __is_ratio                     : false_type {};
-template <intmax_t _Num, intmax_t _Den> struct __is_ratio<ratio<_Num, _Den> > : true_type  {};
+template <class _Tp>
+struct __is_ratio : false_type {};
+template <intmax_t _Num, intmax_t _Den>
+struct __is_ratio<ratio<_Num, _Den> > : true_type {};
 
 typedef ratio<1LL, 1000000000000000000LL> atto;
-typedef ratio<1LL,    1000000000000000LL> femto;
-typedef ratio<1LL,       1000000000000LL> pico;
-typedef ratio<1LL,          1000000000LL> nano;
-typedef ratio<1LL,             1000000LL> micro;
-typedef ratio<1LL,                1000LL> milli;
-typedef ratio<1LL,                 100LL> centi;
-typedef ratio<1LL,                  10LL> deci;
-typedef ratio<                 10LL, 1LL> deca;
-typedef ratio<                100LL, 1LL> hecto;
-typedef ratio<               1000LL, 1LL> kilo;
-typedef ratio<            1000000LL, 1LL> mega;
-typedef ratio<         1000000000LL, 1LL> giga;
-typedef ratio<      1000000000000LL, 1LL> tera;
-typedef ratio<   1000000000000000LL, 1LL> peta;
+typedef ratio<1LL, 1000000000000000LL> femto;
+typedef ratio<1LL, 1000000000000LL> pico;
+typedef ratio<1LL, 1000000000LL> nano;
+typedef ratio<1LL, 1000000LL> micro;
+typedef ratio<1LL, 1000LL> milli;
+typedef ratio<1LL, 100LL> centi;
+typedef ratio<1LL, 10LL> deci;
+typedef ratio< 10LL, 1LL> deca;
+typedef ratio< 100LL, 1LL> hecto;
+typedef ratio< 1000LL, 1LL> kilo;
+typedef ratio< 1000000LL, 1LL> mega;
+typedef ratio< 1000000000LL, 1LL> giga;
+typedef ratio< 1000000000000LL, 1LL> tera;
+typedef ratio< 1000000000000000LL, 1LL> peta;
 typedef ratio<1000000000000000000LL, 1LL> exa;
 
 template <class _R1, class _R2>
-struct __ratio_multiply
-{
+struct __ratio_multiply {
 private:
-    static const intmax_t __gcd_n1_d2 = __static_gcd<_R1::num, _R2::den>::value;
-    static const intmax_t __gcd_d1_n2 = __static_gcd<_R1::den, _R2::num>::value;
+  static const intmax_t __gcd_n1_d2 = __static_gcd<_R1::num, _R2::den>::value;
+  static const intmax_t __gcd_d1_n2 = __static_gcd<_R1::den, _R2::num>::value;
+
+  static_assert(__is_ratio<_R1>::value, "[ratio.general]/2 requires R1 to be a specialisation of the ratio template");
+  static_assert(__is_ratio<_R2>::value, "[ratio.general]/2 requires R2 to be a specialisation of the ratio template");
+
 public:
-    typedef typename ratio
-        <
-            __ll_mul<_R1::num / __gcd_n1_d2, _R2::num / __gcd_d1_n2>::value,
-            __ll_mul<_R2::den / __gcd_n1_d2, _R1::den / __gcd_d1_n2>::value
-        >::type type;
+  typedef typename ratio< __ll_mul<_R1::num / __gcd_n1_d2, _R2::num / __gcd_d1_n2>::value,
+                          __ll_mul<_R2::den / __gcd_n1_d2, _R1::den / __gcd_d1_n2>::value >::type type;
 };
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template <class _R1, class _R2> using ratio_multiply
-                                    = typename __ratio_multiply<_R1, _R2>::type;
+template <class _R1, class _R2>
+using ratio_multiply = typename __ratio_multiply<_R1, _R2>::type;
 
-#else  // _LIBCPP_CXX03_LANG
+#else // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
-struct _LIBCPP_TEMPLATE_VIS ratio_multiply
-    : public __ratio_multiply<_R1, _R2>::type {};
+struct _LIBCPP_TEMPLATE_VIS ratio_multiply : public __ratio_multiply<_R1, _R2>::type {};
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
-struct __ratio_divide
-{
+struct __ratio_divide {
 private:
-    static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
-    static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
+  static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
+  static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
+
+  static_assert(__is_ratio<_R1>::value, "[ratio.general]/2 requires R1 to be a specialisation of the ratio template");
+  static_assert(__is_ratio<_R2>::value, "[ratio.general]/2 requires R2 to be a specialisation of the ratio template");
+
 public:
-    typedef typename ratio
-        <
-            __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
-            __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
-        >::type type;
+  typedef typename ratio< __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
+                          __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value >::type type;
 };
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template <class _R1, class _R2> using ratio_divide
-                                      = typename __ratio_divide<_R1, _R2>::type;
+template <class _R1, class _R2>
+using ratio_divide = typename __ratio_divide<_R1, _R2>::type;
 
-#else  // _LIBCPP_CXX03_LANG
+#else // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
-struct _LIBCPP_TEMPLATE_VIS ratio_divide
-    : public __ratio_divide<_R1, _R2>::type {};
+struct _LIBCPP_TEMPLATE_VIS ratio_divide : public __ratio_divide<_R1, _R2>::type {};
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
-struct __ratio_add
-{
+struct __ratio_add {
 private:
-    static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
-    static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
+  static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
+  static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
+
+  static_assert(__is_ratio<_R1>::value, "[ratio.general]/2 requires R1 to be a specialisation of the ratio template");
+  static_assert(__is_ratio<_R2>::value, "[ratio.general]/2 requires R2 to be a specialisation of the ratio template");
+
 public:
-    typedef typename ratio_multiply
-        <
-            ratio<__gcd_n1_n2, _R1::den / __gcd_d1_d2>,
-            ratio
-            <
-                __ll_add
-                <
-                    __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
-                    __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
-                >::value,
-                _R2::den
-            >
-        >::type type;
+  typedef typename ratio_multiply<
+      ratio<__gcd_n1_n2, _R1::den / __gcd_d1_d2>,
+      ratio< __ll_add< __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
+                       __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value >::value,
+             _R2::den > >::type type;
 };
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template <class _R1, class _R2> using ratio_add
-                                         = typename __ratio_add<_R1, _R2>::type;
+template <class _R1, class _R2>
+using ratio_add = typename __ratio_add<_R1, _R2>::type;
 
-#else  // _LIBCPP_CXX03_LANG
+#else // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
-struct _LIBCPP_TEMPLATE_VIS ratio_add
-    : public __ratio_add<_R1, _R2>::type {};
+struct _LIBCPP_TEMPLATE_VIS ratio_add : public __ratio_add<_R1, _R2>::type {};
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
-struct __ratio_subtract
-{
+struct __ratio_subtract {
 private:
-    static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
-    static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
+  static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
+  static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
+
+  static_assert(__is_ratio<_R1>::value, "[ratio.general]/2 requires R1 to be a specialisation of the ratio template");
+  static_assert(__is_ratio<_R2>::value, "[ratio.general]/2 requires R2 to be a specialisation of the ratio template");
+
 public:
-    typedef typename ratio_multiply
-        <
-            ratio<__gcd_n1_n2, _R1::den / __gcd_d1_d2>,
-            ratio
-            <
-                __ll_sub
-                <
-                    __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
-                    __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value
-                >::value,
-                _R2::den
-            >
-        >::type type;
+  typedef typename ratio_multiply<
+      ratio<__gcd_n1_n2, _R1::den / __gcd_d1_d2>,
+      ratio< __ll_sub< __ll_mul<_R1::num / __gcd_n1_n2, _R2::den / __gcd_d1_d2>::value,
+                       __ll_mul<_R2::num / __gcd_n1_n2, _R1::den / __gcd_d1_d2>::value >::value,
+             _R2::den > >::type type;
 };
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template <class _R1, class _R2> using ratio_subtract
-                                    = typename __ratio_subtract<_R1, _R2>::type;
+template <class _R1, class _R2>
+using ratio_subtract = typename __ratio_subtract<_R1, _R2>::type;
 
-#else  // _LIBCPP_CXX03_LANG
+#else // _LIBCPP_CXX03_LANG
 
 template <class _R1, class _R2>
-struct _LIBCPP_TEMPLATE_VIS ratio_subtract
-    : public __ratio_subtract<_R1, _R2>::type {};
+struct _LIBCPP_TEMPLATE_VIS ratio_subtract : public __ratio_subtract<_R1, _R2>::type {};
 
 #endif // _LIBCPP_CXX03_LANG
 
 // ratio_equal
 
 template <class _R1, class _R2>
-struct _LIBCPP_TEMPLATE_VIS ratio_equal
-    : _BoolConstant<(_R1::num == _R2::num && _R1::den == _R2::den)> {};
+struct _LIBCPP_TEMPLATE_VIS ratio_equal : _BoolConstant<(_R1::num == _R2::num && _R1::den == _R2::den)> {
+  static_assert(__is_ratio<_R1>::value, "[ratio.general]/2 requires R1 to be a specialisation of the ratio template");
+  static_assert(__is_ratio<_R2>::value, "[ratio.general]/2 requires R2 to be a specialisation of the ratio template");
+};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TEMPLATE_VIS ratio_not_equal
-    : _BoolConstant<!ratio_equal<_R1, _R2>::value> {};
+struct _LIBCPP_TEMPLATE_VIS ratio_not_equal : _BoolConstant<!ratio_equal<_R1, _R2>::value> {
+  static_assert(__is_ratio<_R1>::value, "[ratio.general]/2 requires R1 to be a specialisation of the ratio template");
+  static_assert(__is_ratio<_R2>::value, "[ratio.general]/2 requires R2 to be a specialisation of the ratio template");
+};
 
 // ratio_less
 
-template <class _R1, class _R2, bool _Odd = false,
-          intmax_t _Q1 = _R1::num / _R1::den, intmax_t _M1 = _R1::num % _R1::den,
-          intmax_t _Q2 = _R2::num / _R2::den, intmax_t _M2 = _R2::num % _R2::den>
-struct __ratio_less1
-{
-    static const bool value = _Odd ? _Q2 < _Q1 : _Q1 < _Q2;
+template <class _R1,
+          class _R2,
+          bool _Odd    = false,
+          intmax_t _Q1 = _R1::num / _R1::den,
+          intmax_t _M1 = _R1::num % _R1::den,
+          intmax_t _Q2 = _R2::num / _R2::den,
+          intmax_t _M2 = _R2::num % _R2::den>
+struct __ratio_less1 {
+  static const bool value = _Odd ? _Q2 < _Q1 : _Q1 < _Q2;
 };
 
 template <class _R1, class _R2, bool _Odd, intmax_t _Qp>
-struct __ratio_less1<_R1, _R2, _Odd, _Qp, 0, _Qp, 0>
-{
-    static const bool value = false;
+struct __ratio_less1<_R1, _R2, _Odd, _Qp, 0, _Qp, 0> {
+  static const bool value = false;
 };
 
 template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M2>
-struct __ratio_less1<_R1, _R2, _Odd, _Qp, 0, _Qp, _M2>
-{
-    static const bool value = !_Odd;
+struct __ratio_less1<_R1, _R2, _Odd, _Qp, 0, _Qp, _M2> {
+  static const bool value = !_Odd;
 };
 
 template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M1>
-struct __ratio_less1<_R1, _R2, _Odd, _Qp, _M1, _Qp, 0>
-{
-    static const bool value = _Odd;
+struct __ratio_less1<_R1, _R2, _Odd, _Qp, _M1, _Qp, 0> {
+  static const bool value = _Odd;
 };
 
-template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M1,
-                                                        intmax_t _M2>
-struct __ratio_less1<_R1, _R2, _Odd, _Qp, _M1, _Qp, _M2>
-{
-    static const bool value = __ratio_less1<ratio<_R1::den, _M1>,
-                                            ratio<_R2::den, _M2>, !_Odd>::value;
+template <class _R1, class _R2, bool _Odd, intmax_t _Qp, intmax_t _M1, intmax_t _M2>
+struct __ratio_less1<_R1, _R2, _Odd, _Qp, _M1, _Qp, _M2> {
+  static const bool value = __ratio_less1<ratio<_R1::den, _M1>, ratio<_R2::den, _M2>, !_Odd>::value;
 };
 
-template <class _R1, class _R2, intmax_t _S1 = __static_sign<_R1::num>::value,
-                                intmax_t _S2 = __static_sign<_R2::num>::value>
-struct __ratio_less
-{
-    static const bool value = _S1 < _S2;
+template <class _R1,
+          class _R2,
+          intmax_t _S1 = __static_sign<_R1::num>::value,
+          intmax_t _S2 = __static_sign<_R2::num>::value>
+struct __ratio_less {
+  static const bool value = _S1 < _S2;
 };
 
 template <class _R1, class _R2>
-struct __ratio_less<_R1, _R2, 1LL, 1LL>
-{
-    static const bool value = __ratio_less1<_R1, _R2>::value;
+struct __ratio_less<_R1, _R2, 1LL, 1LL> {
+  static const bool value = __ratio_less1<_R1, _R2>::value;
 };
 
 template <class _R1, class _R2>
-struct __ratio_less<_R1, _R2, -1LL, -1LL>
-{
-    static const bool value = __ratio_less1<ratio<-_R2::num, _R2::den>, ratio<-_R1::num, _R1::den> >::value;
+struct __ratio_less<_R1, _R2, -1LL, -1LL> {
+  static const bool value = __ratio_less1<ratio<-_R2::num, _R2::den>, ratio<-_R1::num, _R1::den> >::value;
 };
 
 template <class _R1, class _R2>
-struct _LIBCPP_TEMPLATE_VIS ratio_less
-    : _BoolConstant<__ratio_less<_R1, _R2>::value> {};
+struct _LIBCPP_TEMPLATE_VIS ratio_less : _BoolConstant<__ratio_less<_R1, _R2>::value> {
+  static_assert(__is_ratio<_R1>::value, "[ratio.general]/2 requires R1 to be a specialisation of the ratio template");
+  static_assert(__is_ratio<_R2>::value, "[ratio.general]/2 requires R2 to be a specialisation of the ratio template");
+};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TEMPLATE_VIS ratio_less_equal
-    : _BoolConstant<!ratio_less<_R2, _R1>::value> {};
+struct _LIBCPP_TEMPLATE_VIS ratio_less_equal : _BoolConstant<!ratio_less<_R2, _R1>::value> {
+  static_assert(__is_ratio<_R1>::value, "[ratio.general]/2 requires R1 to be a specialisation of the ratio template");
+  static_assert(__is_ratio<_R2>::value, "[ratio.general]/2 requires R2 to be a specialisation of the ratio template");
+};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TEMPLATE_VIS ratio_greater
-    : _BoolConstant<ratio_less<_R2, _R1>::value> {};
+struct _LIBCPP_TEMPLATE_VIS ratio_greater : _BoolConstant<ratio_less<_R2, _R1>::value> {
+  static_assert(__is_ratio<_R1>::value, "[ratio.general]/2 requires R1 to be a specialisation of the ratio template");
+  static_assert(__is_ratio<_R2>::value, "[ratio.general]/2 requires R2 to be a specialisation of the ratio template");
+};
 
 template <class _R1, class _R2>
-struct _LIBCPP_TEMPLATE_VIS ratio_greater_equal
-    : _BoolConstant<!ratio_less<_R1, _R2>::value> {};
+struct _LIBCPP_TEMPLATE_VIS ratio_greater_equal : _BoolConstant<!ratio_less<_R1, _R2>::value> {
+  static_assert(__is_ratio<_R1>::value, "[ratio.general]/2 requires R1 to be a specialisation of the ratio template");
+  static_assert(__is_ratio<_R2>::value, "[ratio.general]/2 requires R2 to be a specialisation of the ratio template");
+};
 
 template <class _R1, class _R2>
-struct __ratio_gcd
-{
-    typedef ratio<__static_gcd<_R1::num, _R2::num>::value,
-                  __static_lcm<_R1::den, _R2::den>::value> type;
+struct __ratio_gcd {
+  typedef ratio<__static_gcd<_R1::num, _R2::num>::value, __static_lcm<_R1::den, _R2::den>::value> type;
 };
 
 #if _LIBCPP_STD_VER >= 17
diff --git a/third_party/libcxx/refstring.h b/third_party/libcxx/refstring.h
new file mode 100644
index 000000000..78452249f
--- /dev/null
+++ b/third_party/libcxx/refstring.h
@@ -0,0 +1,127 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_REFSTRING_H
+#define _LIBCPP_REFSTRING_H
+
+#include "atomic_support.h"
+#include <__config>
+#include <cstddef>
+#include <cstring>
+#include <stdexcept>
+
+// MacOS and iOS used to ship with libstdc++, and still support old applications
+// linking against libstdc++. The libc++ and libstdc++ exceptions are supposed
+// to be ABI compatible, such that they can be thrown from one library and caught
+// in the other.
+//
+// For that reason, we must look for libstdc++ in the same process and if found,
+// check the string stored in the exception object to see if it is the GCC empty
+// string singleton before manipulating the reference count. This is done so that
+// if an exception is created with a zero-length string in libstdc++, libc++abi
+// won't try to delete the memory.
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) || defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
+#  define _LIBCPP_CHECK_FOR_GCC_EMPTY_STRING_STORAGE
+#  include <dlfcn.h>
+#  include <mach-o/dyld.h>
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __refstring_imp {
+namespace {
+typedef int count_t;
+
+struct _Rep_base {
+  std::size_t len;
+  std::size_t cap;
+  count_t count;
+};
+
+inline _Rep_base* rep_from_data(const char* data_) noexcept {
+  char* data = const_cast<char*>(data_);
+  return reinterpret_cast<_Rep_base*>(data - sizeof(_Rep_base));
+}
+
+inline char* data_from_rep(_Rep_base* rep) noexcept {
+  char* data = reinterpret_cast<char*>(rep);
+  return data + sizeof(*rep);
+}
+
+#if defined(_LIBCPP_CHECK_FOR_GCC_EMPTY_STRING_STORAGE)
+inline const char* compute_gcc_empty_string_storage() noexcept {
+  void* handle = dlopen("/usr/lib/libstdc++.6.dylib", RTLD_NOLOAD);
+  if (handle == nullptr)
+    return nullptr;
+  void* sym = dlsym(handle, "_ZNSs4_Rep20_S_empty_rep_storageE");
+  if (sym == nullptr)
+    return nullptr;
+  return data_from_rep(reinterpret_cast<_Rep_base*>(sym));
+}
+
+inline const char* get_gcc_empty_string_storage() noexcept {
+  static const char* p = compute_gcc_empty_string_storage();
+  return p;
+}
+#endif
+
+} // namespace
+} // namespace __refstring_imp
+
+using namespace __refstring_imp;
+
+inline __libcpp_refstring::__libcpp_refstring(const char* msg) {
+  std::size_t len = strlen(msg);
+  _Rep_base* rep  = static_cast<_Rep_base*>(::operator new(sizeof(*rep) + len + 1));
+  rep->len        = len;
+  rep->cap        = len;
+  rep->count      = 0;
+  char* data      = data_from_rep(rep);
+  std::memcpy(data, msg, len + 1);
+  __imp_ = data;
+}
+
+inline __libcpp_refstring::__libcpp_refstring(const __libcpp_refstring& s) noexcept : __imp_(s.__imp_) {
+  if (__uses_refcount())
+    __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
+}
+
+inline __libcpp_refstring& __libcpp_refstring::operator=(__libcpp_refstring const& s) noexcept {
+  bool adjust_old_count     = __uses_refcount();
+  struct _Rep_base* old_rep = rep_from_data(__imp_);
+  __imp_                    = s.__imp_;
+  if (__uses_refcount())
+    __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
+  if (adjust_old_count) {
+    if (__libcpp_atomic_add(&old_rep->count, count_t(-1)) < 0) {
+      ::operator delete(old_rep);
+    }
+  }
+  return *this;
+}
+
+inline __libcpp_refstring::~__libcpp_refstring() {
+  if (__uses_refcount()) {
+    _Rep_base* rep = rep_from_data(__imp_);
+    if (__libcpp_atomic_add(&rep->count, count_t(-1)) < 0) {
+      ::operator delete(rep);
+    }
+  }
+}
+
+inline bool __libcpp_refstring::__uses_refcount() const {
+#if defined(_LIBCPP_CHECK_FOR_GCC_EMPTY_STRING_STORAGE)
+  return __imp_ != get_gcc_empty_string_storage();
+#else
+  return true;
+#endif
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif //_LIBCPP_REFSTRING_H
diff --git a/third_party/libcxx/regex b/third_party/libcxx/regex
index 7b31bf4f9..b81413512 100644
--- a/third_party/libcxx/regex
+++ b/third_party/libcxx/regex
@@ -543,7 +543,7 @@ template <class BidirectionalIterator, class Allocator>
     operator==(const match_results<BidirectionalIterator, Allocator>& m1,
                const match_results<BidirectionalIterator, Allocator>& m2);
 
-template <class BidirectionalIterator, class Allocator>
+template <class BidirectionalIterator, class Allocator>                    // Removed in C++20
     bool
     operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
                const match_results<BidirectionalIterator, Allocator>& m2);
@@ -697,6 +697,7 @@ public:
     typedef const value_type*                    pointer;
     typedef const value_type&                    reference;
     typedef forward_iterator_tag                 iterator_category;
+    typedef input_iterator_tag                   iterator_concept; // since C++20
 
     regex_iterator();
     regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
@@ -710,7 +711,8 @@ public:
     regex_iterator& operator=(const regex_iterator&);
 
     bool operator==(const regex_iterator&) const;
-    bool operator!=(const regex_iterator&) const;
+    bool operator==(default_sentinel_t) const { return *this == regex_iterator(); } // since C++20
+    bool operator!=(const regex_iterator&) const;                                   // Removed in C++20
 
     const value_type& operator*() const;
     const value_type* operator->() const;
@@ -736,6 +738,7 @@ public:
     typedef const value_type*                pointer;
     typedef const value_type&                reference;
     typedef forward_iterator_tag             iterator_category;
+    typedef input_iterator_tag               iterator_concept; // since C++20
 
     regex_token_iterator();
     regex_token_iterator(BidirectionalIterator a, BidirectionalIterator b,
@@ -768,7 +771,8 @@ public:
     regex_token_iterator& operator=(const regex_token_iterator&);
 
     bool operator==(const regex_token_iterator&) const;
-    bool operator!=(const regex_token_iterator&) const;
+    bool operator==(default_sentinel_t) const { return *this == regex_token_iterator(); } // since C++20
+    bool operator!=(const regex_token_iterator&) const;                                   // Removed in C++20
 
     const value_type& operator*() const;
     const value_type* operator->() const;
@@ -787,11 +791,13 @@ typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 
 #include <__algorithm/find.h>
 #include <__algorithm/search.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
 #include <__iterator/back_insert_iterator.h>
+#include <__iterator/default_sentinel.h>
 #include <__iterator/wrap_iter.h>
 #include <__locale>
+#include <__memory/shared_ptr.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__type_traits/is_swappable.h>
 #include <__utility/move.h>
@@ -824,375 +830,289 @@ typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 #define _LIBCPP_REGEX_COMPLEXITY_FACTOR 4096
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-namespace regex_constants
-{
+namespace regex_constants {
 
 // syntax_option_type
 
-enum syntax_option_type
-{
-    icase      = 1 << 0,
-    nosubs     = 1 << 1,
-    optimize   = 1 << 2,
-    collate    = 1 << 3,
+enum syntax_option_type {
+  icase    = 1 << 0,
+  nosubs   = 1 << 1,
+  optimize = 1 << 2,
+  collate  = 1 << 3,
 #ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
-    ECMAScript = 1 << 9,
+  ECMAScript = 1 << 9,
 #else
-    ECMAScript = 0,
+  ECMAScript = 0,
 #endif
-    basic      = 1 << 4,
-    extended   = 1 << 5,
-    awk        = 1 << 6,
-    grep       = 1 << 7,
-    egrep      = 1 << 8,
-    // 1 << 9 may be used by ECMAScript
-    multiline  = 1 << 10
+  basic    = 1 << 4,
+  extended = 1 << 5,
+  awk      = 1 << 6,
+  grep     = 1 << 7,
+  egrep    = 1 << 8,
+  // 1 << 9 may be used by ECMAScript
+  multiline = 1 << 10
 };
 
-_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR
-syntax_option_type __get_grammar(syntax_option_type __g)
-{
+_LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR syntax_option_type __get_grammar(syntax_option_type __g) {
 #ifdef _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
-    return static_cast<syntax_option_type>(__g & 0x3F0);
+  return static_cast<syntax_option_type>(__g & 0x3F0);
 #else
-    return static_cast<syntax_option_type>(__g & 0x1F0);
+  return static_cast<syntax_option_type>(__g & 0x1F0);
 #endif
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-syntax_option_type
-operator~(syntax_option_type __x)
-{
-    return syntax_option_type(~int(__x) & 0x1FF);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR syntax_option_type operator~(syntax_option_type __x) {
+  return syntax_option_type(~int(__x) & 0x1FF);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-syntax_option_type
-operator&(syntax_option_type __x, syntax_option_type __y)
-{
-    return syntax_option_type(int(__x) & int(__y));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR syntax_option_type
+operator&(syntax_option_type __x, syntax_option_type __y) {
+  return syntax_option_type(int(__x) & int(__y));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-syntax_option_type
-operator|(syntax_option_type __x, syntax_option_type __y)
-{
-    return syntax_option_type(int(__x) | int(__y));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR syntax_option_type
+operator|(syntax_option_type __x, syntax_option_type __y) {
+  return syntax_option_type(int(__x) | int(__y));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-syntax_option_type
-operator^(syntax_option_type __x, syntax_option_type __y)
-{
-    return syntax_option_type(int(__x) ^ int(__y));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR syntax_option_type
+operator^(syntax_option_type __x, syntax_option_type __y) {
+  return syntax_option_type(int(__x) ^ int(__y));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-syntax_option_type&
-operator&=(syntax_option_type& __x, syntax_option_type __y)
-{
-    __x = __x & __y;
-    return __x;
+inline _LIBCPP_HIDE_FROM_ABI syntax_option_type& operator&=(syntax_option_type& __x, syntax_option_type __y) {
+  __x = __x & __y;
+  return __x;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-syntax_option_type&
-operator|=(syntax_option_type& __x, syntax_option_type __y)
-{
-    __x = __x | __y;
-    return __x;
+inline _LIBCPP_HIDE_FROM_ABI syntax_option_type& operator|=(syntax_option_type& __x, syntax_option_type __y) {
+  __x = __x | __y;
+  return __x;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-syntax_option_type&
-operator^=(syntax_option_type& __x, syntax_option_type __y)
-{
-    __x = __x ^ __y;
-    return __x;
+inline _LIBCPP_HIDE_FROM_ABI syntax_option_type& operator^=(syntax_option_type& __x, syntax_option_type __y) {
+  __x = __x ^ __y;
+  return __x;
 }
 
 // match_flag_type
 
-enum match_flag_type
-{
-    match_default     = 0,
-    match_not_bol     = 1 << 0,
-    match_not_eol     = 1 << 1,
-    match_not_bow     = 1 << 2,
-    match_not_eow     = 1 << 3,
-    match_any         = 1 << 4,
-    match_not_null    = 1 << 5,
-    match_continuous  = 1 << 6,
-    match_prev_avail  = 1 << 7,
-    format_default    = 0,
-    format_sed        = 1 << 8,
-    format_no_copy    = 1 << 9,
-    format_first_only = 1 << 10,
-    __no_update_pos   = 1 << 11,
-    __full_match      = 1 << 12
+enum match_flag_type {
+  match_default     = 0,
+  match_not_bol     = 1 << 0,
+  match_not_eol     = 1 << 1,
+  match_not_bow     = 1 << 2,
+  match_not_eow     = 1 << 3,
+  match_any         = 1 << 4,
+  match_not_null    = 1 << 5,
+  match_continuous  = 1 << 6,
+  match_prev_avail  = 1 << 7,
+  format_default    = 0,
+  format_sed        = 1 << 8,
+  format_no_copy    = 1 << 9,
+  format_first_only = 1 << 10,
+  __no_update_pos   = 1 << 11,
+  __full_match      = 1 << 12
 };
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-match_flag_type
-operator~(match_flag_type __x)
-{
-    return match_flag_type(~int(__x) & 0x0FFF);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR match_flag_type operator~(match_flag_type __x) {
+  return match_flag_type(~int(__x) & 0x0FFF);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-match_flag_type
-operator&(match_flag_type __x, match_flag_type __y)
-{
-    return match_flag_type(int(__x) & int(__y));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR match_flag_type operator&(match_flag_type __x, match_flag_type __y) {
+  return match_flag_type(int(__x) & int(__y));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-match_flag_type
-operator|(match_flag_type __x, match_flag_type __y)
-{
-    return match_flag_type(int(__x) | int(__y));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR match_flag_type operator|(match_flag_type __x, match_flag_type __y) {
+  return match_flag_type(int(__x) | int(__y));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-_LIBCPP_CONSTEXPR
-match_flag_type
-operator^(match_flag_type __x, match_flag_type __y)
-{
-    return match_flag_type(int(__x) ^ int(__y));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR match_flag_type operator^(match_flag_type __x, match_flag_type __y) {
+  return match_flag_type(int(__x) ^ int(__y));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-match_flag_type&
-operator&=(match_flag_type& __x, match_flag_type __y)
-{
-    __x = __x & __y;
-    return __x;
+inline _LIBCPP_HIDE_FROM_ABI match_flag_type& operator&=(match_flag_type& __x, match_flag_type __y) {
+  __x = __x & __y;
+  return __x;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-match_flag_type&
-operator|=(match_flag_type& __x, match_flag_type __y)
-{
-    __x = __x | __y;
-    return __x;
+inline _LIBCPP_HIDE_FROM_ABI match_flag_type& operator|=(match_flag_type& __x, match_flag_type __y) {
+  __x = __x | __y;
+  return __x;
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-match_flag_type&
-operator^=(match_flag_type& __x, match_flag_type __y)
-{
-    __x = __x ^ __y;
-    return __x;
+inline _LIBCPP_HIDE_FROM_ABI match_flag_type& operator^=(match_flag_type& __x, match_flag_type __y) {
+  __x = __x ^ __y;
+  return __x;
 }
 
-enum error_type
-{
-    error_collate = 1,
-    error_ctype,
-    error_escape,
-    error_backref,
-    error_brack,
-    error_paren,
-    error_brace,
-    error_badbrace,
-    error_range,
-    error_space,
-    error_badrepeat,
-    error_complexity,
-    error_stack,
-    __re_err_grammar,
-    __re_err_empty,
-    __re_err_unknown,
-    __re_err_parse
+enum error_type {
+  error_collate = 1,
+  error_ctype,
+  error_escape,
+  error_backref,
+  error_brack,
+  error_paren,
+  error_brace,
+  error_badbrace,
+  error_range,
+  error_space,
+  error_badrepeat,
+  error_complexity,
+  error_stack,
+  __re_err_grammar,
+  __re_err_empty,
+  __re_err_unknown,
+  __re_err_parse
 };
 
 } // namespace regex_constants
 
-class _LIBCPP_EXCEPTION_ABI regex_error
-    : public runtime_error
-{
-    regex_constants::error_type __code_;
+class _LIBCPP_EXPORTED_FROM_ABI regex_error : public runtime_error {
+  regex_constants::error_type __code_;
+
 public:
-    explicit regex_error(regex_constants::error_type __ecode);
-    _LIBCPP_HIDE_FROM_ABI regex_error(const regex_error&) _NOEXCEPT = default;
-    ~regex_error() _NOEXCEPT override;
-    _LIBCPP_INLINE_VISIBILITY
-    regex_constants::error_type code() const {return __code_;}
+  explicit regex_error(regex_constants::error_type __ecode);
+  _LIBCPP_HIDE_FROM_ABI regex_error(const regex_error&) _NOEXCEPT = default;
+  ~regex_error() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI regex_constants::error_type code() const { return __code_; }
 };
 
 template <regex_constants::error_type _Ev>
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_regex_error()
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_regex_error() {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw regex_error(_Ev);
+  throw regex_error(_Ev);
 #else
-    _LIBCPP_VERBOSE_ABORT("regex_error was thrown in -fno-exceptions mode");
+  _LIBCPP_VERBOSE_ABORT("regex_error was thrown in -fno-exceptions mode");
 #endif
 }
 
 template <class _CharT>
-struct _LIBCPP_TEMPLATE_VIS regex_traits
-{
+struct _LIBCPP_TEMPLATE_VIS regex_traits {
 public:
-    typedef _CharT                  char_type;
-    typedef basic_string<char_type> string_type;
-    typedef locale                  locale_type;
+  typedef _CharT char_type;
+  typedef basic_string<char_type> string_type;
+  typedef locale locale_type;
 #if defined(__BIONIC__) || defined(_NEWLIB_VERSION)
-    // Originally bionic's ctype_base used its own ctype masks because the
-    // builtin ctype implementation wasn't in libc++ yet. Bionic's ctype mask
-    // was only 8 bits wide and already saturated, so it used a wider type here
-    // to make room for __regex_word (then a part of this class rather than
-    // ctype_base). Bionic has since moved to the builtin ctype_base
-    // implementation, but this was not updated to match. Since then Android has
-    // needed to maintain a stable libc++ ABI, and this can't be changed without
-    // an ABI break.
-    // We also need this workaround for newlib since _NEWLIB_VERSION is not
-    // defined yet inside __config, so we can't set the
-    // _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE macro. Additionally, newlib is
-    // often used for space constrained environments, so it makes sense not to
-    // duplicate the ctype table.
-    typedef uint16_t char_class_type;
+  // Originally bionic's ctype_base used its own ctype masks because the
+  // builtin ctype implementation wasn't in libc++ yet. Bionic's ctype mask
+  // was only 8 bits wide and already saturated, so it used a wider type here
+  // to make room for __regex_word (then a part of this class rather than
+  // ctype_base). Bionic has since moved to the builtin ctype_base
+  // implementation, but this was not updated to match. Since then Android has
+  // needed to maintain a stable libc++ ABI, and this can't be changed without
+  // an ABI break.
+  // We also need this workaround for newlib since _NEWLIB_VERSION is not
+  // defined yet inside __config, so we can't set the
+  // _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE macro. Additionally, newlib is
+  // often used for space constrained environments, so it makes sense not to
+  // duplicate the ctype table.
+  typedef uint16_t char_class_type;
 #else
-    typedef ctype_base::mask        char_class_type;
+  typedef ctype_base::mask char_class_type;
 #endif
 
-    static const char_class_type __regex_word = ctype_base::__regex_word;
+  static const char_class_type __regex_word = ctype_base::__regex_word;
+
 private:
-    locale __loc_;
-    const ctype<char_type>* __ct_;
-    const collate<char_type>* __col_;
+  locale __loc_;
+  const ctype<char_type>* __ct_;
+  const collate<char_type>* __col_;
 
 public:
-    regex_traits();
+  regex_traits();
 
-    _LIBCPP_INLINE_VISIBILITY
-    static size_t length(const char_type* __p)
-        {return char_traits<char_type>::length(__p);}
-    _LIBCPP_INLINE_VISIBILITY
-    char_type translate(char_type __c) const {return __c;}
-    char_type translate_nocase(char_type __c) const;
-    template <class _ForwardIterator>
-        string_type
-        transform(_ForwardIterator __f, _ForwardIterator __l) const;
-    template <class _ForwardIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        string_type
-        transform_primary( _ForwardIterator __f, _ForwardIterator __l) const
-            {return __transform_primary(__f, __l, char_type());}
-    template <class _ForwardIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        string_type
-        lookup_collatename(_ForwardIterator __f, _ForwardIterator __l) const
-            {return __lookup_collatename(__f, __l, char_type());}
-    template <class _ForwardIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        char_class_type
-        lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
-                         bool __icase = false) const
-            {return __lookup_classname(__f, __l, __icase, char_type());}
-    bool isctype(char_type __c, char_class_type __m) const;
-    _LIBCPP_INLINE_VISIBILITY
-    int value(char_type __ch, int __radix) const
-        {return __regex_traits_value(__ch, __radix);}
-    locale_type imbue(locale_type __l);
-    _LIBCPP_INLINE_VISIBILITY
-    locale_type getloc()const {return __loc_;}
+  _LIBCPP_HIDE_FROM_ABI static size_t length(const char_type* __p) { return char_traits<char_type>::length(__p); }
+  _LIBCPP_HIDE_FROM_ABI char_type translate(char_type __c) const { return __c; }
+  char_type translate_nocase(char_type __c) const;
+  template <class _ForwardIterator>
+  string_type transform(_ForwardIterator __f, _ForwardIterator __l) const;
+  template <class _ForwardIterator>
+  _LIBCPP_HIDE_FROM_ABI string_type transform_primary(_ForwardIterator __f, _ForwardIterator __l) const {
+    return __transform_primary(__f, __l, char_type());
+  }
+  template <class _ForwardIterator>
+  _LIBCPP_HIDE_FROM_ABI string_type lookup_collatename(_ForwardIterator __f, _ForwardIterator __l) const {
+    return __lookup_collatename(__f, __l, char_type());
+  }
+  template <class _ForwardIterator>
+  _LIBCPP_HIDE_FROM_ABI char_class_type
+  lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase = false) const {
+    return __lookup_classname(__f, __l, __icase, char_type());
+  }
+  bool isctype(char_type __c, char_class_type __m) const;
+  _LIBCPP_HIDE_FROM_ABI int value(char_type __ch, int __radix) const { return __regex_traits_value(__ch, __radix); }
+  locale_type imbue(locale_type __l);
+  _LIBCPP_HIDE_FROM_ABI locale_type getloc() const { return __loc_; }
 
 private:
-    void __init();
+  void __init();
 
-    template <class _ForwardIterator>
-        string_type
-        __transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const;
+  template <class _ForwardIterator>
+  string_type __transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    template <class _ForwardIterator>
-        string_type
-        __transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
+  template <class _ForwardIterator>
+  string_type __transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
 #endif
-    template <class _ForwardIterator>
-        string_type
-        __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const;
+  template <class _ForwardIterator>
+  string_type __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    template <class _ForwardIterator>
-        string_type
-        __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
+  template <class _ForwardIterator>
+  string_type __lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const;
 #endif
-    template <class _ForwardIterator>
-        char_class_type
-        __lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
-                           bool __icase, char) const;
+  template <class _ForwardIterator>
+  char_class_type __lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, char) const;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    template <class _ForwardIterator>
-        char_class_type
-        __lookup_classname(_ForwardIterator __f, _ForwardIterator __l,
-                           bool __icase, wchar_t) const;
+  template <class _ForwardIterator>
+  char_class_type __lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, wchar_t) const;
 #endif
 
-    static int __regex_traits_value(unsigned char __ch, int __radix);
-    _LIBCPP_INLINE_VISIBILITY
-    int __regex_traits_value(char __ch, int __radix) const
-        {return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);}
+  static int __regex_traits_value(unsigned char __ch, int __radix);
+  _LIBCPP_HIDE_FROM_ABI int __regex_traits_value(char __ch, int __radix) const {
+    return __regex_traits_value(static_cast<unsigned char>(__ch), __radix);
+  }
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    _LIBCPP_INLINE_VISIBILITY
-    int __regex_traits_value(wchar_t __ch, int __radix) const;
+  _LIBCPP_HIDE_FROM_ABI int __regex_traits_value(wchar_t __ch, int __radix) const;
 #endif
 };
 
 template <class _CharT>
-const typename regex_traits<_CharT>::char_class_type
-regex_traits<_CharT>::__regex_word;
+const typename regex_traits<_CharT>::char_class_type regex_traits<_CharT>::__regex_word;
 
 template <class _CharT>
-regex_traits<_CharT>::regex_traits()
-{
-    __init();
+regex_traits<_CharT>::regex_traits() {
+  __init();
 }
 
 template <class _CharT>
-typename regex_traits<_CharT>::char_type
-regex_traits<_CharT>::translate_nocase(char_type __c) const
-{
-    return __ct_->tolower(__c);
+typename regex_traits<_CharT>::char_type regex_traits<_CharT>::translate_nocase(char_type __c) const {
+  return __ct_->tolower(__c);
 }
 
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::string_type
-regex_traits<_CharT>::transform(_ForwardIterator __f, _ForwardIterator __l) const
-{
-    string_type __s(__f, __l);
-    return __col_->transform(__s.data(), __s.data() + __s.size());
+regex_traits<_CharT>::transform(_ForwardIterator __f, _ForwardIterator __l) const {
+  string_type __s(__f, __l);
+  return __col_->transform(__s.data(), __s.data() + __s.size());
 }
 
 template <class _CharT>
-void
-regex_traits<_CharT>::__init()
-{
-    __ct_ = &std::use_facet<ctype<char_type> >(__loc_);
-    __col_ = &std::use_facet<collate<char_type> >(__loc_);
+void regex_traits<_CharT>::__init() {
+  __ct_  = &std::use_facet<ctype<char_type> >(__loc_);
+  __col_ = &std::use_facet<collate<char_type> >(__loc_);
 }
 
 template <class _CharT>
-typename regex_traits<_CharT>::locale_type
-regex_traits<_CharT>::imbue(locale_type __l)
-{
-    locale __r = __loc_;
-    __loc_ = __l;
-    __init();
-    return __r;
+typename regex_traits<_CharT>::locale_type regex_traits<_CharT>::imbue(locale_type __l) {
+  locale __r = __loc_;
+  __loc_     = __l;
+  __init();
+  return __r;
 }
 
 // transform_primary is very FreeBSD-specific
@@ -1200,5157 +1120,4176 @@ regex_traits<_CharT>::imbue(locale_type __l)
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::string_type
-regex_traits<_CharT>::__transform_primary(_ForwardIterator __f,
-                                          _ForwardIterator __l, char) const
-{
-    const string_type __s(__f, __l);
-    string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
-    switch (__d.size())
-    {
-    case 1:
-        break;
-    case 12:
-        __d[11] = __d[3];
-        break;
-    default:
-        __d.clear();
-        break;
-    }
-    return __d;
+regex_traits<_CharT>::__transform_primary(_ForwardIterator __f, _ForwardIterator __l, char) const {
+  const string_type __s(__f, __l);
+  string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
+  switch (__d.size()) {
+  case 1:
+    break;
+  case 12:
+    __d[11] = __d[3];
+    break;
+  default:
+    __d.clear();
+    break;
+  }
+  return __d;
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::string_type
-regex_traits<_CharT>::__transform_primary(_ForwardIterator __f,
-                                          _ForwardIterator __l, wchar_t) const
-{
-    const string_type __s(__f, __l);
-    string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
-    switch (__d.size())
-    {
-    case 1:
-        break;
-    case 3:
-        __d[2] = __d[0];
-        break;
-    default:
-        __d.clear();
-        break;
-    }
-    return __d;
+regex_traits<_CharT>::__transform_primary(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const {
+  const string_type __s(__f, __l);
+  string_type __d = __col_->transform(__s.data(), __s.data() + __s.size());
+  switch (__d.size()) {
+  case 1:
+    break;
+  case 3:
+    __d[2] = __d[0];
+    break;
+  default:
+    __d.clear();
+    break;
+  }
+  return __d;
 }
 #endif
 
 // lookup_collatename is very FreeBSD-specific
 
-_LIBCPP_FUNC_VIS string __get_collation_name(const char* __s);
+_LIBCPP_EXPORTED_FROM_ABI string __get_collation_name(const char* __s);
 
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::string_type
-regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
-                                           _ForwardIterator __l, char) const
-{
-    string_type __s(__f, __l);
-    string_type __r;
-    if (!__s.empty())
-    {
-        __r = std::__get_collation_name(__s.c_str());
-        if (__r.empty() && __s.size() <= 2)
-        {
-            __r = __col_->transform(__s.data(), __s.data() + __s.size());
-            if (__r.size() == 1 || __r.size() == 12)
-                __r = __s;
-            else
-                __r.clear();
-        }
+regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, char) const {
+  string_type __s(__f, __l);
+  string_type __r;
+  if (!__s.empty()) {
+    __r = std::__get_collation_name(__s.c_str());
+    if (__r.empty() && __s.size() <= 2) {
+      __r = __col_->transform(__s.data(), __s.data() + __s.size());
+      if (__r.size() == 1 || __r.size() == 12)
+        __r = __s;
+      else
+        __r.clear();
     }
-    return __r;
+  }
+  return __r;
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::string_type
-regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f,
-                                           _ForwardIterator __l, wchar_t) const
-{
-    string_type __s(__f, __l);
-    string __n;
-    __n.reserve(__s.size());
-    for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end();
-                                                              __i != __e; ++__i)
-    {
-        if (static_cast<unsigned>(*__i) >= 127)
-            return string_type();
-        __n.push_back(char(*__i));
+regex_traits<_CharT>::__lookup_collatename(_ForwardIterator __f, _ForwardIterator __l, wchar_t) const {
+  string_type __s(__f, __l);
+  string __n;
+  __n.reserve(__s.size());
+  for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); __i != __e; ++__i) {
+    if (static_cast<unsigned>(*__i) >= 127)
+      return string_type();
+    __n.push_back(char(*__i));
+  }
+  string_type __r;
+  if (!__s.empty()) {
+    __n = __get_collation_name(__n.c_str());
+    if (!__n.empty())
+      __r.assign(__n.begin(), __n.end());
+    else if (__s.size() <= 2) {
+      __r = __col_->transform(__s.data(), __s.data() + __s.size());
+      if (__r.size() == 1 || __r.size() == 3)
+        __r = __s;
+      else
+        __r.clear();
     }
-    string_type __r;
-    if (!__s.empty())
-    {
-        __n = __get_collation_name(__n.c_str());
-        if (!__n.empty())
-            __r.assign(__n.begin(), __n.end());
-        else if (__s.size() <= 2)
-        {
-            __r = __col_->transform(__s.data(), __s.data() + __s.size());
-            if (__r.size() == 1 || __r.size() == 3)
-                __r = __s;
-            else
-                __r.clear();
-        }
-    }
-    return __r;
+  }
+  return __r;
 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 // lookup_classname
 
-regex_traits<char>::char_class_type _LIBCPP_FUNC_VIS
-__get_classname(const char* __s, bool __icase);
+regex_traits<char>::char_class_type _LIBCPP_EXPORTED_FROM_ABI __get_classname(const char* __s, bool __icase);
 
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::char_class_type
-regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
-                                         _ForwardIterator __l,
-                                         bool __icase, char) const
-{
-    string_type __s(__f, __l);
-    __ct_->tolower(&__s[0], &__s[0] + __s.size());
-    return std::__get_classname(__s.c_str(), __icase);
+regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, char) const {
+  string_type __s(__f, __l);
+  __ct_->tolower(&__s[0], &__s[0] + __s.size());
+  return std::__get_classname(__s.c_str(), __icase);
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class _CharT>
 template <class _ForwardIterator>
 typename regex_traits<_CharT>::char_class_type
-regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f,
-                                         _ForwardIterator __l,
-                                         bool __icase, wchar_t) const
-{
-    string_type __s(__f, __l);
-    __ct_->tolower(&__s[0], &__s[0] + __s.size());
-    string __n;
-    __n.reserve(__s.size());
-    for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end();
-                                                              __i != __e; ++__i)
-    {
-        if (static_cast<unsigned>(*__i) >= 127)
-            return char_class_type();
-        __n.push_back(char(*__i));
-    }
-    return __get_classname(__n.c_str(), __icase);
+regex_traits<_CharT>::__lookup_classname(_ForwardIterator __f, _ForwardIterator __l, bool __icase, wchar_t) const {
+  string_type __s(__f, __l);
+  __ct_->tolower(&__s[0], &__s[0] + __s.size());
+  string __n;
+  __n.reserve(__s.size());
+  for (typename string_type::const_iterator __i = __s.begin(), __e = __s.end(); __i != __e; ++__i) {
+    if (static_cast<unsigned>(*__i) >= 127)
+      return char_class_type();
+    __n.push_back(char(*__i));
+  }
+  return __get_classname(__n.c_str(), __icase);
 }
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
 template <class _CharT>
-bool
-regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const
-{
-    if (__ct_->is(__m, __c))
-        return true;
-    return (__c == '_' && (__m & __regex_word));
+bool regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const {
+  if (__ct_->is(__m, __c))
+    return true;
+  return (__c == '_' && (__m & __regex_word));
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-bool __is_07(unsigned char __c)
-{
-    return (__c & 0xF8u) ==
+inline _LIBCPP_HIDE_FROM_ABI bool __is_07(unsigned char __c) {
+  return (__c & 0xF8u) ==
 #if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
-        0xF0;
+         0xF0;
 #else
-        0x30;
+         0x30;
 #endif
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-bool __is_89(unsigned char __c)
-{
-    return (__c & 0xFEu) ==
+inline _LIBCPP_HIDE_FROM_ABI bool __is_89(unsigned char __c) {
+  return (__c & 0xFEu) ==
 #if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
-        0xF8;
+         0xF8;
 #else
-        0x38;
+         0x38;
 #endif
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-unsigned char __to_lower(unsigned char __c)
-{
+inline _LIBCPP_HIDE_FROM_ABI unsigned char __to_lower(unsigned char __c) {
 #if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
-    return __c & 0xBF;
+  return __c & 0xBF;
 #else
-    return __c | 0x20;
+  return __c | 0x20;
 #endif
 }
 
 template <class _CharT>
-int
-regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix)
-{
-    if (__is_07(__ch))  // '0' <= __ch && __ch <= '7'
-        return __ch - '0';
-    if (__radix != 8)
-    {
-        if (__is_89(__ch))  // '8' <= __ch && __ch <= '9'
-            return __ch - '0';
-        if (__radix == 16)
-        {
-            __ch = __to_lower(__ch);  // tolower
-            if ('a' <= __ch && __ch <= 'f')
-                return __ch - ('a' - 10);
-        }
+int regex_traits<_CharT>::__regex_traits_value(unsigned char __ch, int __radix) {
+  if (__is_07(__ch)) // '0' <= __ch && __ch <= '7'
+    return __ch - '0';
+  if (__radix != 8) {
+    if (__is_89(__ch)) // '8' <= __ch && __ch <= '9'
+      return __ch - '0';
+    if (__radix == 16) {
+      __ch = __to_lower(__ch); // tolower
+      if ('a' <= __ch && __ch <= 'f')
+        return __ch - ('a' - 10);
     }
-    return -1;
+  }
+  return -1;
 }
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <class _CharT>
-inline
-int
-regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const
-{
-    return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
+inline int regex_traits<_CharT>::__regex_traits_value(wchar_t __ch, int __radix) const {
+  return __regex_traits_value(static_cast<unsigned char>(__ct_->narrow(__ch, char_type())), __radix);
 }
 #endif
 
-template <class _CharT> class __node;
+template <class _CharT>
+class __node;
 
-template <class _BidirectionalIterator> class _LIBCPP_TEMPLATE_VIS sub_match;
+template <class _BidirectionalIterator>
+class _LIBCPP_TEMPLATE_VIS sub_match;
 
-template <class _BidirectionalIterator,
-          class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
+template <class _BidirectionalIterator, class _Allocator = allocator<sub_match<_BidirectionalIterator> > >
 class _LIBCPP_TEMPLATE_VIS match_results;
 
 template <class _CharT>
-struct __state
-{
-    enum
-    {
-        __end_state = -1000,
-        __consume_input,  // -999
-        __begin_marked_expr, // -998
-        __end_marked_expr,   // -997
-        __pop_state,           // -996
-        __accept_and_consume,  // -995
-        __accept_but_not_consume,  // -994
-        __reject,                  // -993
-        __split,
-        __repeat
-    };
+struct __state {
+  enum {
+    __end_state = -1000,
+    __consume_input,          // -999
+    __begin_marked_expr,      // -998
+    __end_marked_expr,        // -997
+    __pop_state,              // -996
+    __accept_and_consume,     // -995
+    __accept_but_not_consume, // -994
+    __reject,                 // -993
+    __split,
+    __repeat
+  };
 
-    int __do_;
-    const _CharT* __first_;
-    const _CharT* __current_;
-    const _CharT* __last_;
-    vector<sub_match<const _CharT*> > __sub_matches_;
-    vector<pair<size_t, const _CharT*> > __loop_data_;
-    const __node<_CharT>* __node_;
-    regex_constants::match_flag_type __flags_;
-    bool __at_first_;
+  int __do_;
+  const _CharT* __first_;
+  const _CharT* __current_;
+  const _CharT* __last_;
+  vector<sub_match<const _CharT*> > __sub_matches_;
+  vector<pair<size_t, const _CharT*> > __loop_data_;
+  const __node<_CharT>* __node_;
+  regex_constants::match_flag_type __flags_;
+  bool __at_first_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __state()
-        : __do_(0), __first_(nullptr), __current_(nullptr), __last_(nullptr),
-          __node_(nullptr), __flags_() {}
+  _LIBCPP_HIDE_FROM_ABI __state()
+      : __do_(0),
+        __first_(nullptr),
+        __current_(nullptr),
+        __last_(nullptr),
+        __node_(nullptr),
+        __flags_(),
+        __at_first_(false) {}
 };
 
 // __node
 
 template <class _CharT>
-class __node
-{
-    __node(const __node&);
-    __node& operator=(const __node&);
+class __node {
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __node() {}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL
-    virtual ~__node() {}
+  _LIBCPP_HIDE_FROM_ABI __node() {}
+  __node(const __node&)            = delete;
+  __node& operator=(const __node&) = delete;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  virtual ~__node() {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL
-    virtual void __exec(__state&) const {}
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL
-    virtual void __exec_split(bool, __state&) const {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  virtual void __exec(__state&) const {}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  virtual void __exec_split(bool, __state&) const {}
 };
 
 // __end_state
 
 template <class _CharT>
-class __end_state
-    : public __node<_CharT>
-{
+class __end_state : public __node<_CharT> {
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __end_state() {}
+  _LIBCPP_HIDE_FROM_ABI __end_state() {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__end_state<_CharT>::__exec(__state& __s) const
-{
-    __s.__do_ = __state::__end_state;
+void __end_state<_CharT>::__exec(__state& __s) const {
+  __s.__do_ = __state::__end_state;
 }
 
 // __has_one_state
 
 template <class _CharT>
-class __has_one_state
-    : public __node<_CharT>
-{
-    __node<_CharT>* __first_;
+class __has_one_state : public __node<_CharT> {
+  __node<_CharT>* __first_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __has_one_state(__node<_CharT>* __s)
-        : __first_(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __has_one_state(__node<_CharT>* __s) : __first_(__s) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __node<_CharT>*  first() const {return __first_;}
-    _LIBCPP_INLINE_VISIBILITY
-    __node<_CharT>*& first()       {return __first_;}
+  _LIBCPP_HIDE_FROM_ABI __node<_CharT>* first() const { return __first_; }
+  _LIBCPP_HIDE_FROM_ABI __node<_CharT>*& first() { return __first_; }
 };
 
 // __owns_one_state
 
 template <class _CharT>
-class __owns_one_state
-    : public __has_one_state<_CharT>
-{
-    typedef __has_one_state<_CharT> base;
+class __owns_one_state : public __has_one_state<_CharT> {
+  typedef __has_one_state<_CharT> base;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __owns_one_state(__node<_CharT>* __s)
-        : base(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __owns_one_state(__node<_CharT>* __s) : base(__s) {}
 
-    ~__owns_one_state() override;
+  ~__owns_one_state() override;
 };
 
 template <class _CharT>
-__owns_one_state<_CharT>::~__owns_one_state()
-{
-    delete this->first();
+__owns_one_state<_CharT>::~__owns_one_state() {
+  delete this->first();
 }
 
 // __empty_state
 
 template <class _CharT>
-class __empty_state
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __empty_state : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
 
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __empty_state(__node<_CharT>* __s)
-        : base(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __empty_state(__node<_CharT>* __s) : base(__s) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__empty_state<_CharT>::__exec(__state& __s) const
-{
-    __s.__do_ = __state::__accept_but_not_consume;
-    __s.__node_ = this->first();
+void __empty_state<_CharT>::__exec(__state& __s) const {
+  __s.__do_   = __state::__accept_but_not_consume;
+  __s.__node_ = this->first();
 }
 
 // __empty_non_own_state
 
 template <class _CharT>
-class __empty_non_own_state
-    : public __has_one_state<_CharT>
-{
-    typedef __has_one_state<_CharT> base;
+class __empty_non_own_state : public __has_one_state<_CharT> {
+  typedef __has_one_state<_CharT> base;
 
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __empty_non_own_state(__node<_CharT>* __s)
-        : base(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __empty_non_own_state(__node<_CharT>* __s) : base(__s) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__empty_non_own_state<_CharT>::__exec(__state& __s) const
-{
-    __s.__do_ = __state::__accept_but_not_consume;
-    __s.__node_ = this->first();
+void __empty_non_own_state<_CharT>::__exec(__state& __s) const {
+  __s.__do_   = __state::__accept_but_not_consume;
+  __s.__node_ = this->first();
 }
 
 // __repeat_one_loop
 
 template <class _CharT>
-class __repeat_one_loop
-    : public __has_one_state<_CharT>
-{
-    typedef __has_one_state<_CharT> base;
+class __repeat_one_loop : public __has_one_state<_CharT> {
+  typedef __has_one_state<_CharT> base;
 
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __repeat_one_loop(__node<_CharT>* __s)
-        : base(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __repeat_one_loop(__node<_CharT>* __s) : base(__s) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__repeat_one_loop<_CharT>::__exec(__state& __s) const
-{
-    __s.__do_ = __state::__repeat;
-    __s.__node_ = this->first();
+void __repeat_one_loop<_CharT>::__exec(__state& __s) const {
+  __s.__do_   = __state::__repeat;
+  __s.__node_ = this->first();
 }
 
 // __owns_two_states
 
 template <class _CharT>
-class __owns_two_states
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __owns_two_states : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
 
-    base* __second_;
+  base* __second_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __owns_two_states(__node<_CharT>* __s1, base* __s2)
-        : base(__s1), __second_(__s2) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __owns_two_states(__node<_CharT>* __s1, base* __s2) : base(__s1), __second_(__s2) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual ~__owns_two_states();
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual ~__owns_two_states();
 
-    _LIBCPP_INLINE_VISIBILITY
-    base*  second() const {return __second_;}
-    _LIBCPP_INLINE_VISIBILITY
-    base*& second()       {return __second_;}
+  _LIBCPP_HIDE_FROM_ABI base* second() const { return __second_; }
+  _LIBCPP_HIDE_FROM_ABI base*& second() { return __second_; }
 };
 
 template <class _CharT>
-__owns_two_states<_CharT>::~__owns_two_states()
-{
-    delete __second_;
+__owns_two_states<_CharT>::~__owns_two_states() {
+  delete __second_;
 }
 
 // __loop
 
 template <class _CharT>
-class __loop
-    : public __owns_two_states<_CharT>
-{
-    typedef __owns_two_states<_CharT> base;
+class __loop : public __owns_two_states<_CharT> {
+  typedef __owns_two_states<_CharT> base;
 
-    size_t __min_;
-    size_t __max_;
-    unsigned __loop_id_;
-    unsigned __mexp_begin_;
-    unsigned __mexp_end_;
-    bool __greedy_;
+  size_t __min_;
+  size_t __max_;
+  unsigned __loop_id_;
+  unsigned __mexp_begin_;
+  unsigned __mexp_end_;
+  bool __greedy_;
 
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __loop(unsigned __loop_id,
-                          __node<_CharT>* __s1, __owns_one_state<_CharT>* __s2,
-                          unsigned __mexp_begin, unsigned __mexp_end,
-                          bool __greedy = true,
-                          size_t __min = 0,
-                          size_t __max = numeric_limits<size_t>::max())
-        : base(__s1, __s2), __min_(__min), __max_(__max), __loop_id_(__loop_id),
-          __mexp_begin_(__mexp_begin), __mexp_end_(__mexp_end),
-          __greedy_(__greedy) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __loop(
+      unsigned __loop_id,
+      __node<_CharT>* __s1,
+      __owns_one_state<_CharT>* __s2,
+      unsigned __mexp_begin,
+      unsigned __mexp_end,
+      bool __greedy = true,
+      size_t __min  = 0,
+      size_t __max  = numeric_limits<size_t>::max())
+      : base(__s1, __s2),
+        __min_(__min),
+        __max_(__max),
+        __loop_id_(__loop_id),
+        __mexp_begin_(__mexp_begin),
+        __mexp_end_(__mexp_end),
+        __greedy_(__greedy) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state& __s) const;
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec_split(bool __second, __state& __s) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state& __s) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec_split(bool __second, __state& __s) const;
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    void __init_repeat(__state& __s) const
-    {
-        __s.__loop_data_[__loop_id_].second = __s.__current_;
-        for (size_t __i = __mexp_begin_-1; __i != __mexp_end_-1; ++__i)
-        {
-            __s.__sub_matches_[__i].first = __s.__last_;
-            __s.__sub_matches_[__i].second = __s.__last_;
-            __s.__sub_matches_[__i].matched = false;
-        }
+  _LIBCPP_HIDE_FROM_ABI void __init_repeat(__state& __s) const {
+    __s.__loop_data_[__loop_id_].second = __s.__current_;
+    for (size_t __i = __mexp_begin_ - 1; __i != __mexp_end_ - 1; ++__i) {
+      __s.__sub_matches_[__i].first   = __s.__last_;
+      __s.__sub_matches_[__i].second  = __s.__last_;
+      __s.__sub_matches_[__i].matched = false;
     }
+  }
 };
 
 template <class _CharT>
-void
-__loop<_CharT>::__exec(__state& __s) const
-{
-    if (__s.__do_ == __state::__repeat)
-    {
-        bool __do_repeat = ++__s.__loop_data_[__loop_id_].first < __max_;
-        bool __do_alt = __s.__loop_data_[__loop_id_].first >= __min_;
-        if (__do_repeat && __do_alt &&
-                               __s.__loop_data_[__loop_id_].second == __s.__current_)
-            __do_repeat = false;
-        if (__do_repeat && __do_alt)
-            __s.__do_ = __state::__split;
-        else if (__do_repeat)
-        {
-            __s.__do_ = __state::__accept_but_not_consume;
-            __s.__node_ = this->first();
-            __init_repeat(__s);
-        }
-        else
-        {
-            __s.__do_ = __state::__accept_but_not_consume;
-            __s.__node_ = this->second();
-        }
+void __loop<_CharT>::__exec(__state& __s) const {
+  if (__s.__do_ == __state::__repeat) {
+    bool __do_repeat = ++__s.__loop_data_[__loop_id_].first < __max_;
+    bool __do_alt    = __s.__loop_data_[__loop_id_].first >= __min_;
+    if (__do_repeat && __do_alt && __s.__loop_data_[__loop_id_].second == __s.__current_)
+      __do_repeat = false;
+    if (__do_repeat && __do_alt)
+      __s.__do_ = __state::__split;
+    else if (__do_repeat) {
+      __s.__do_   = __state::__accept_but_not_consume;
+      __s.__node_ = this->first();
+      __init_repeat(__s);
+    } else {
+      __s.__do_   = __state::__accept_but_not_consume;
+      __s.__node_ = this->second();
     }
-    else
-    {
-        __s.__loop_data_[__loop_id_].first = 0;
-        bool __do_repeat = 0 < __max_;
-        bool __do_alt = 0 >= __min_;
-        if (__do_repeat && __do_alt)
-            __s.__do_ = __state::__split;
-        else if (__do_repeat)
-        {
-            __s.__do_ = __state::__accept_but_not_consume;
-            __s.__node_ = this->first();
-            __init_repeat(__s);
-        }
-        else
-        {
-            __s.__do_ = __state::__accept_but_not_consume;
-            __s.__node_ = this->second();
-        }
+  } else {
+    __s.__loop_data_[__loop_id_].first = 0;
+    bool __do_repeat                   = 0 < __max_;
+    bool __do_alt                      = 0 >= __min_;
+    if (__do_repeat && __do_alt)
+      __s.__do_ = __state::__split;
+    else if (__do_repeat) {
+      __s.__do_   = __state::__accept_but_not_consume;
+      __s.__node_ = this->first();
+      __init_repeat(__s);
+    } else {
+      __s.__do_   = __state::__accept_but_not_consume;
+      __s.__node_ = this->second();
     }
+  }
 }
 
 template <class _CharT>
-void
-__loop<_CharT>::__exec_split(bool __second, __state& __s) const
-{
-    __s.__do_ = __state::__accept_but_not_consume;
-    if (__greedy_ != __second)
-    {
-        __s.__node_ = this->first();
-        __init_repeat(__s);
-    }
-    else
-        __s.__node_ = this->second();
+void __loop<_CharT>::__exec_split(bool __second, __state& __s) const {
+  __s.__do_ = __state::__accept_but_not_consume;
+  if (__greedy_ != __second) {
+    __s.__node_ = this->first();
+    __init_repeat(__s);
+  } else
+    __s.__node_ = this->second();
 }
 
 // __alternate
 
 template <class _CharT>
-class __alternate
-    : public __owns_two_states<_CharT>
-{
-    typedef __owns_two_states<_CharT> base;
+class __alternate : public __owns_two_states<_CharT> {
+  typedef __owns_two_states<_CharT> base;
 
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __alternate(__owns_one_state<_CharT>* __s1,
-                         __owns_one_state<_CharT>* __s2)
-        : base(__s1, __s2) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __alternate(__owns_one_state<_CharT>* __s1, __owns_one_state<_CharT>* __s2)
+      : base(__s1, __s2) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state& __s) const;
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec_split(bool __second, __state& __s) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state& __s) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec_split(bool __second, __state& __s) const;
 };
 
 template <class _CharT>
-void
-__alternate<_CharT>::__exec(__state& __s) const
-{
-    __s.__do_ = __state::__split;
+void __alternate<_CharT>::__exec(__state& __s) const {
+  __s.__do_ = __state::__split;
 }
 
 template <class _CharT>
-void
-__alternate<_CharT>::__exec_split(bool __second, __state& __s) const
-{
-    __s.__do_ = __state::__accept_but_not_consume;
-    if (__second)
-        __s.__node_ = this->second();
-    else
-        __s.__node_ = this->first();
+void __alternate<_CharT>::__exec_split(bool __second, __state& __s) const {
+  __s.__do_ = __state::__accept_but_not_consume;
+  if (__second)
+    __s.__node_ = this->second();
+  else
+    __s.__node_ = this->first();
 }
 
 // __begin_marked_subexpression
 
 template <class _CharT>
-class __begin_marked_subexpression
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __begin_marked_subexpression : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
+
+  unsigned __mexp_;
 
-    unsigned __mexp_;
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
-        : base(__s), __mexp_(__mexp) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
+      : base(__s), __mexp_(__mexp) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__begin_marked_subexpression<_CharT>::__exec(__state& __s) const
-{
-    __s.__do_ = __state::__accept_but_not_consume;
-    __s.__sub_matches_[__mexp_-1].first = __s.__current_;
-    __s.__node_ = this->first();
+void __begin_marked_subexpression<_CharT>::__exec(__state& __s) const {
+  __s.__do_                             = __state::__accept_but_not_consume;
+  __s.__sub_matches_[__mexp_ - 1].first = __s.__current_;
+  __s.__node_                           = this->first();
 }
 
 // __end_marked_subexpression
 
 template <class _CharT>
-class __end_marked_subexpression
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __end_marked_subexpression : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
+
+  unsigned __mexp_;
 
-    unsigned __mexp_;
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
-        : base(__s), __mexp_(__mexp) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
+      : base(__s), __mexp_(__mexp) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__end_marked_subexpression<_CharT>::__exec(__state& __s) const
-{
-    __s.__do_ = __state::__accept_but_not_consume;
-    __s.__sub_matches_[__mexp_-1].second = __s.__current_;
-    __s.__sub_matches_[__mexp_-1].matched = true;
-    __s.__node_ = this->first();
+void __end_marked_subexpression<_CharT>::__exec(__state& __s) const {
+  __s.__do_                               = __state::__accept_but_not_consume;
+  __s.__sub_matches_[__mexp_ - 1].second  = __s.__current_;
+  __s.__sub_matches_[__mexp_ - 1].matched = true;
+  __s.__node_                             = this->first();
 }
 
 // __back_ref
 
 template <class _CharT>
-class __back_ref
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __back_ref : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
+
+  unsigned __mexp_;
 
-    unsigned __mexp_;
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __back_ref(unsigned __mexp, __node<_CharT>* __s)
-        : base(__s), __mexp_(__mexp) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __back_ref(unsigned __mexp, __node<_CharT>* __s) : base(__s), __mexp_(__mexp) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__back_ref<_CharT>::__exec(__state& __s) const
-{
-    if (__mexp_ > __s.__sub_matches_.size())
-        __throw_regex_error<regex_constants::error_backref>();
-    sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
-    if (__sm.matched)
-    {
-        ptrdiff_t __len = __sm.second - __sm.first;
-        if (__s.__last_ - __s.__current_ >= __len &&
-            _VSTD::equal(__sm.first, __sm.second, __s.__current_))
-        {
-            __s.__do_ = __state::__accept_but_not_consume;
-            __s.__current_ += __len;
-            __s.__node_ = this->first();
-        }
-        else
-        {
-            __s.__do_ = __state::__reject;
-            __s.__node_ = nullptr;
-        }
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
+void __back_ref<_CharT>::__exec(__state& __s) const {
+  if (__mexp_ > __s.__sub_matches_.size())
+    __throw_regex_error<regex_constants::error_backref>();
+  sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_ - 1];
+  if (__sm.matched) {
+    ptrdiff_t __len = __sm.second - __sm.first;
+    if (__s.__last_ - __s.__current_ >= __len && std::equal(__sm.first, __sm.second, __s.__current_)) {
+      __s.__do_ = __state::__accept_but_not_consume;
+      __s.__current_ += __len;
+      __s.__node_ = this->first();
+    } else {
+      __s.__do_   = __state::__reject;
+      __s.__node_ = nullptr;
     }
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
 // __back_ref_icase
 
 template <class _CharT, class _Traits>
-class __back_ref_icase
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __back_ref_icase : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
+
+  _Traits __traits_;
+  unsigned __mexp_;
 
-    _Traits __traits_;
-    unsigned __mexp_;
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp,
-                              __node<_CharT>* __s)
-        : base(__s), __traits_(__traits), __mexp_(__mexp) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp, __node<_CharT>* __s)
+      : base(__s), __traits_(__traits), __mexp_(__mexp) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
-void
-__back_ref_icase<_CharT, _Traits>::__exec(__state& __s) const
-{
-    sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
-    if (__sm.matched)
-    {
-        ptrdiff_t __len = __sm.second - __sm.first;
-        if (__s.__last_ - __s.__current_ >= __len)
-        {
-            for (ptrdiff_t __i = 0; __i < __len; ++__i)
-            {
-                if (__traits_.translate_nocase(__sm.first[__i]) !=
-                                __traits_.translate_nocase(__s.__current_[__i]))
-                    goto __not_equal;
-            }
-            __s.__do_ = __state::__accept_but_not_consume;
-            __s.__current_ += __len;
-            __s.__node_ = this->first();
-        }
-        else
-        {
-            __s.__do_ = __state::__reject;
-            __s.__node_ = nullptr;
-        }
-    }
-    else
-    {
-__not_equal:
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
+void __back_ref_icase<_CharT, _Traits>::__exec(__state& __s) const {
+  sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_ - 1];
+  if (__sm.matched) {
+    ptrdiff_t __len = __sm.second - __sm.first;
+    if (__s.__last_ - __s.__current_ >= __len) {
+      for (ptrdiff_t __i = 0; __i < __len; ++__i) {
+        if (__traits_.translate_nocase(__sm.first[__i]) != __traits_.translate_nocase(__s.__current_[__i]))
+          goto __not_equal;
+      }
+      __s.__do_ = __state::__accept_but_not_consume;
+      __s.__current_ += __len;
+      __s.__node_ = this->first();
+    } else {
+      __s.__do_   = __state::__reject;
+      __s.__node_ = nullptr;
     }
+  } else {
+  __not_equal:
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
 // __back_ref_collate
 
 template <class _CharT, class _Traits>
-class __back_ref_collate
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __back_ref_collate : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
+
+  _Traits __traits_;
+  unsigned __mexp_;
 
-    _Traits __traits_;
-    unsigned __mexp_;
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp,
-                              __node<_CharT>* __s)
-        : base(__s), __traits_(__traits), __mexp_(__mexp) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp, __node<_CharT>* __s)
+      : base(__s), __traits_(__traits), __mexp_(__mexp) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
-void
-__back_ref_collate<_CharT, _Traits>::__exec(__state& __s) const
-{
-    sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_-1];
-    if (__sm.matched)
-    {
-        ptrdiff_t __len = __sm.second - __sm.first;
-        if (__s.__last_ - __s.__current_ >= __len)
-        {
-            for (ptrdiff_t __i = 0; __i < __len; ++__i)
-            {
-                if (__traits_.translate(__sm.first[__i]) !=
-                                       __traits_.translate(__s.__current_[__i]))
-                    goto __not_equal;
-            }
-            __s.__do_ = __state::__accept_but_not_consume;
-            __s.__current_ += __len;
-            __s.__node_ = this->first();
-        }
-        else
-        {
-            __s.__do_ = __state::__reject;
-            __s.__node_ = nullptr;
-        }
-    }
-    else
-    {
-__not_equal:
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
+void __back_ref_collate<_CharT, _Traits>::__exec(__state& __s) const {
+  sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_ - 1];
+  if (__sm.matched) {
+    ptrdiff_t __len = __sm.second - __sm.first;
+    if (__s.__last_ - __s.__current_ >= __len) {
+      for (ptrdiff_t __i = 0; __i < __len; ++__i) {
+        if (__traits_.translate(__sm.first[__i]) != __traits_.translate(__s.__current_[__i]))
+          goto __not_equal;
+      }
+      __s.__do_ = __state::__accept_but_not_consume;
+      __s.__current_ += __len;
+      __s.__node_ = this->first();
+    } else {
+      __s.__do_   = __state::__reject;
+      __s.__node_ = nullptr;
     }
+  } else {
+  __not_equal:
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
 // __word_boundary
 
 template <class _CharT, class _Traits>
-class __word_boundary
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __word_boundary : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
+
+  _Traits __traits_;
+  bool __invert_;
 
-    _Traits __traits_;
-    bool __invert_;
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __word_boundary(const _Traits& __traits, bool __invert,
-                             __node<_CharT>* __s)
-        : base(__s), __traits_(__traits), __invert_(__invert) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __word_boundary(const _Traits& __traits, bool __invert, __node<_CharT>* __s)
+      : base(__s), __traits_(__traits), __invert_(__invert) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
-void
-__word_boundary<_CharT, _Traits>::__exec(__state& __s) const
-{
-    bool __is_word_b = false;
-    if (__s.__first_ != __s.__last_)
-    {
-        if (__s.__current_ == __s.__last_)
-        {
-            if (!(__s.__flags_ & regex_constants::match_not_eow))
-            {
-                _CharT __c = __s.__current_[-1];
-                __is_word_b = __c == '_' ||
-                              __traits_.isctype(__c, ctype_base::alnum);
-            }
-        }
-        else if (__s.__current_ == __s.__first_ &&
-                !(__s.__flags_ & regex_constants::match_prev_avail))
-        {
-            if (!(__s.__flags_ & regex_constants::match_not_bow))
-            {
-                _CharT __c = *__s.__current_;
-                __is_word_b = __c == '_' ||
-                              __traits_.isctype(__c, ctype_base::alnum);
-            }
-        }
-        else
-        {
-            _CharT __c1 = __s.__current_[-1];
-            _CharT __c2 = *__s.__current_;
-            bool __is_c1_b = __c1 == '_' ||
-                             __traits_.isctype(__c1, ctype_base::alnum);
-            bool __is_c2_b = __c2 == '_' ||
-                             __traits_.isctype(__c2, ctype_base::alnum);
-            __is_word_b = __is_c1_b != __is_c2_b;
-        }
-    }
-    if (__is_word_b != __invert_)
-    {
-        __s.__do_ = __state::__accept_but_not_consume;
-        __s.__node_ = this->first();
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
+void __word_boundary<_CharT, _Traits>::__exec(__state& __s) const {
+  bool __is_word_b = false;
+  if (__s.__first_ != __s.__last_) {
+    if (__s.__current_ == __s.__last_) {
+      if (!(__s.__flags_ & regex_constants::match_not_eow)) {
+        _CharT __c  = __s.__current_[-1];
+        __is_word_b = __c == '_' || __traits_.isctype(__c, ctype_base::alnum);
+      }
+    } else if (__s.__current_ == __s.__first_ && !(__s.__flags_ & regex_constants::match_prev_avail)) {
+      if (!(__s.__flags_ & regex_constants::match_not_bow)) {
+        _CharT __c  = *__s.__current_;
+        __is_word_b = __c == '_' || __traits_.isctype(__c, ctype_base::alnum);
+      }
+    } else {
+      _CharT __c1    = __s.__current_[-1];
+      _CharT __c2    = *__s.__current_;
+      bool __is_c1_b = __c1 == '_' || __traits_.isctype(__c1, ctype_base::alnum);
+      bool __is_c2_b = __c2 == '_' || __traits_.isctype(__c2, ctype_base::alnum);
+      __is_word_b    = __is_c1_b != __is_c2_b;
     }
+  }
+  if (__is_word_b != __invert_) {
+    __s.__do_   = __state::__accept_but_not_consume;
+    __s.__node_ = this->first();
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
 // __l_anchor
 
 template <class _CharT>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-bool __is_eol(_CharT __c)
-{
-    return __c == '\r' || __c == '\n';
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool __is_eol(_CharT __c) {
+  return __c == '\r' || __c == '\n';
 }
 
 template <class _CharT>
-class __l_anchor_multiline
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __l_anchor_multiline : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
 
-    bool __multiline_;
+  bool __multiline_;
 
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __l_anchor_multiline(bool __multiline, __node<_CharT>* __s)
-        : base(__s), __multiline_(__multiline) {}
+  _LIBCPP_HIDE_FROM_ABI __l_anchor_multiline(bool __multiline, __node<_CharT>* __s)
+      : base(__s), __multiline_(__multiline) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__l_anchor_multiline<_CharT>::__exec(__state& __s) const
-{
-    if (__s.__at_first_ && __s.__current_ == __s.__first_ &&
-        !(__s.__flags_ & regex_constants::match_not_bol))
-    {
-        __s.__do_ = __state::__accept_but_not_consume;
-        __s.__node_ = this->first();
-    }
-    else if (__multiline_ &&
-             !__s.__at_first_ &&
-             std::__is_eol(*_VSTD::prev(__s.__current_)))
-    {
-        __s.__do_ = __state::__accept_but_not_consume;
-        __s.__node_ = this->first();
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
+void __l_anchor_multiline<_CharT>::__exec(__state& __s) const {
+  if (__s.__at_first_ && __s.__current_ == __s.__first_ && !(__s.__flags_ & regex_constants::match_not_bol)) {
+    __s.__do_   = __state::__accept_but_not_consume;
+    __s.__node_ = this->first();
+  } else if (__multiline_ && !__s.__at_first_ && std::__is_eol(*std::prev(__s.__current_))) {
+    __s.__do_   = __state::__accept_but_not_consume;
+    __s.__node_ = this->first();
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
 // __r_anchor
 
 template <class _CharT>
-class __r_anchor_multiline
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __r_anchor_multiline : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
 
-    bool __multiline_;
+  bool __multiline_;
 
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __r_anchor_multiline(bool __multiline, __node<_CharT>* __s)
-        : base(__s), __multiline_(__multiline) {}
+  _LIBCPP_HIDE_FROM_ABI __r_anchor_multiline(bool __multiline, __node<_CharT>* __s)
+      : base(__s), __multiline_(__multiline) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__r_anchor_multiline<_CharT>::__exec(__state& __s) const
-{
-    if (__s.__current_ == __s.__last_ &&
-        !(__s.__flags_ & regex_constants::match_not_eol))
-    {
-        __s.__do_ = __state::__accept_but_not_consume;
-        __s.__node_ = this->first();
-    }
-    else if (__multiline_ && std::__is_eol(*__s.__current_))
-    {
-        __s.__do_ = __state::__accept_but_not_consume;
-        __s.__node_ = this->first();
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
+void __r_anchor_multiline<_CharT>::__exec(__state& __s) const {
+  if (__s.__current_ == __s.__last_ && !(__s.__flags_ & regex_constants::match_not_eol)) {
+    __s.__do_   = __state::__accept_but_not_consume;
+    __s.__node_ = this->first();
+  } else if (__multiline_ && std::__is_eol(*__s.__current_)) {
+    __s.__do_   = __state::__accept_but_not_consume;
+    __s.__node_ = this->first();
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
 // __match_any
 
 template <class _CharT>
-class __match_any
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __match_any : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
 
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __match_any(__node<_CharT>* __s)
-        : base(__s) {}
+  _LIBCPP_HIDE_FROM_ABI __match_any(__node<_CharT>* __s) : base(__s) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__match_any<_CharT>::__exec(__state& __s) const
-{
-    if (__s.__current_ != __s.__last_ && *__s.__current_ != 0)
-    {
-        __s.__do_ = __state::__accept_and_consume;
-        ++__s.__current_;
-        __s.__node_ = this->first();
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
+void __match_any<_CharT>::__exec(__state& __s) const {
+  if (__s.__current_ != __s.__last_ && *__s.__current_ != 0) {
+    __s.__do_ = __state::__accept_and_consume;
+    ++__s.__current_;
+    __s.__node_ = this->first();
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
 // __match_any_but_newline
 
 template <class _CharT>
-class __match_any_but_newline
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __match_any_but_newline : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
 
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __match_any_but_newline(__node<_CharT>* __s)
-        : base(__s) {}
+  _LIBCPP_HIDE_FROM_ABI __match_any_but_newline(__node<_CharT>* __s) : base(__s) {}
 
-    void __exec(__state&) const override;
+  void __exec(__state&) const override;
 };
 
-template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<char>::__exec(__state&) const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI void __match_any_but_newline<char>::__exec(__state&) const;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <> _LIBCPP_FUNC_VIS void __match_any_but_newline<wchar_t>::__exec(__state&) const;
+template <>
+_LIBCPP_EXPORTED_FROM_ABI void __match_any_but_newline<wchar_t>::__exec(__state&) const;
 #endif
 
 // __match_char
 
 template <class _CharT>
-class __match_char
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __match_char : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
 
-    _CharT __c_;
+  _CharT __c_;
 
-    __match_char(const __match_char&);
-    __match_char& operator=(const __match_char&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __match_char(_CharT __c, __node<_CharT>* __s)
-        : base(__s), __c_(__c) {}
+  _LIBCPP_HIDE_FROM_ABI __match_char(_CharT __c, __node<_CharT>* __s) : base(__s), __c_(__c) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  __match_char(const __match_char&)            = delete;
+  __match_char& operator=(const __match_char&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
-void
-__match_char<_CharT>::__exec(__state& __s) const
-{
-    if (__s.__current_ != __s.__last_ && *__s.__current_ == __c_)
-    {
-        __s.__do_ = __state::__accept_and_consume;
-        ++__s.__current_;
-        __s.__node_ = this->first();
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
+void __match_char<_CharT>::__exec(__state& __s) const {
+  if (__s.__current_ != __s.__last_ && *__s.__current_ == __c_) {
+    __s.__do_ = __state::__accept_and_consume;
+    ++__s.__current_;
+    __s.__node_ = this->first();
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
 // __match_char_icase
 
 template <class _CharT, class _Traits>
-class __match_char_icase
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __match_char_icase : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
 
-    _Traits __traits_;
-    _CharT __c_;
+  _Traits __traits_;
+  _CharT __c_;
 
-    __match_char_icase(const __match_char_icase&);
-    __match_char_icase& operator=(const __match_char_icase&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
-        : base(__s), __traits_(__traits), __c_(__traits.translate_nocase(__c)) {}
+  _LIBCPP_HIDE_FROM_ABI __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
+      : base(__s), __traits_(__traits), __c_(__traits.translate_nocase(__c)) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  __match_char_icase(const __match_char_icase&)            = delete;
+  __match_char_icase& operator=(const __match_char_icase&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
-void
-__match_char_icase<_CharT, _Traits>::__exec(__state& __s) const
-{
-    if (__s.__current_ != __s.__last_ &&
-        __traits_.translate_nocase(*__s.__current_) == __c_)
-    {
-        __s.__do_ = __state::__accept_and_consume;
-        ++__s.__current_;
-        __s.__node_ = this->first();
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
+void __match_char_icase<_CharT, _Traits>::__exec(__state& __s) const {
+  if (__s.__current_ != __s.__last_ && __traits_.translate_nocase(*__s.__current_) == __c_) {
+    __s.__do_ = __state::__accept_and_consume;
+    ++__s.__current_;
+    __s.__node_ = this->first();
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
 // __match_char_collate
 
 template <class _CharT, class _Traits>
-class __match_char_collate
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __match_char_collate : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
 
-    _Traits __traits_;
-    _CharT __c_;
+  _Traits __traits_;
+  _CharT __c_;
 
-    __match_char_collate(const __match_char_collate&);
-    __match_char_collate& operator=(const __match_char_collate&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
-        : base(__s), __traits_(__traits), __c_(__traits.translate(__c)) {}
+  _LIBCPP_HIDE_FROM_ABI __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
+      : base(__s), __traits_(__traits), __c_(__traits.translate(__c)) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  __match_char_collate(const __match_char_collate&)            = delete;
+  __match_char_collate& operator=(const __match_char_collate&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
-void
-__match_char_collate<_CharT, _Traits>::__exec(__state& __s) const
-{
-    if (__s.__current_ != __s.__last_ &&
-        __traits_.translate(*__s.__current_) == __c_)
-    {
-        __s.__do_ = __state::__accept_and_consume;
-        ++__s.__current_;
-        __s.__node_ = this->first();
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
+void __match_char_collate<_CharT, _Traits>::__exec(__state& __s) const {
+  if (__s.__current_ != __s.__last_ && __traits_.translate(*__s.__current_) == __c_) {
+    __s.__do_ = __state::__accept_and_consume;
+    ++__s.__current_;
+    __s.__node_ = this->first();
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
 // __bracket_expression
 
 template <class _CharT, class _Traits>
-class __bracket_expression
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
-    typedef typename _Traits::string_type string_type;
+class __bracket_expression : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
+  typedef typename _Traits::string_type string_type;
 
-    _Traits __traits_;
-    vector<_CharT> __chars_;
-    vector<_CharT> __neg_chars_;
-    vector<pair<string_type, string_type> > __ranges_;
-    vector<pair<_CharT, _CharT> > __digraphs_;
-    vector<string_type> __equivalences_;
-    typename regex_traits<_CharT>::char_class_type __mask_;
-    typename regex_traits<_CharT>::char_class_type __neg_mask_;
-    bool __negate_;
-    bool __icase_;
-    bool __collate_;
-    bool __might_have_digraph_;
+  _Traits __traits_;
+  vector<_CharT> __chars_;
+  vector<_CharT> __neg_chars_;
+  vector<pair<string_type, string_type> > __ranges_;
+  vector<pair<_CharT, _CharT> > __digraphs_;
+  vector<string_type> __equivalences_;
+  typename regex_traits<_CharT>::char_class_type __mask_;
+  typename regex_traits<_CharT>::char_class_type __neg_mask_;
+  bool __negate_;
+  bool __icase_;
+  bool __collate_;
+  bool __might_have_digraph_;
 
-    __bracket_expression(const __bracket_expression&);
-    __bracket_expression& operator=(const __bracket_expression&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __bracket_expression(const _Traits& __traits, __node<_CharT>* __s,
-                                 bool __negate, bool __icase, bool __collate)
-        : base(__s), __traits_(__traits), __mask_(), __neg_mask_(),
-          __negate_(__negate), __icase_(__icase), __collate_(__collate),
-          __might_have_digraph_(__traits_.getloc().name() != "C") {}
+  _LIBCPP_HIDE_FROM_ABI
+  __bracket_expression(const _Traits& __traits, __node<_CharT>* __s, bool __negate, bool __icase, bool __collate)
+      : base(__s),
+        __traits_(__traits),
+        __mask_(),
+        __neg_mask_(),
+        __negate_(__negate),
+        __icase_(__icase),
+        __collate_(__collate),
+        __might_have_digraph_(__traits_.getloc().name() != "C") {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  __bracket_expression(const __bracket_expression&)            = delete;
+  __bracket_expression& operator=(const __bracket_expression&) = delete;
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool __negated() const {return __negate_;}
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __add_char(_CharT __c)
-        {
-            if (__icase_)
-                __chars_.push_back(__traits_.translate_nocase(__c));
-            else if (__collate_)
-                __chars_.push_back(__traits_.translate(__c));
-            else
-                __chars_.push_back(__c);
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    void __add_neg_char(_CharT __c)
-        {
-            if (__icase_)
-                __neg_chars_.push_back(__traits_.translate_nocase(__c));
-            else if (__collate_)
-                __neg_chars_.push_back(__traits_.translate(__c));
-            else
-                __neg_chars_.push_back(__c);
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    void __add_range(string_type __b, string_type __e)
-        {
-            if (__collate_)
-            {
-                if (__icase_)
-                {
-                    for (size_t __i = 0; __i < __b.size(); ++__i)
-                        __b[__i] = __traits_.translate_nocase(__b[__i]);
-                    for (size_t __i = 0; __i < __e.size(); ++__i)
-                        __e[__i] = __traits_.translate_nocase(__e[__i]);
-                }
-                else
-                {
-                    for (size_t __i = 0; __i < __b.size(); ++__i)
-                        __b[__i] = __traits_.translate(__b[__i]);
-                    for (size_t __i = 0; __i < __e.size(); ++__i)
-                        __e[__i] = __traits_.translate(__e[__i]);
-                }
-                __ranges_.push_back(std::make_pair(
-                                  __traits_.transform(__b.begin(), __b.end()),
-                                  __traits_.transform(__e.begin(), __e.end())));
-            }
-            else
-            {
-                if (__b.size() != 1 || __e.size() != 1)
-                    __throw_regex_error<regex_constants::error_range>();
-                if (__icase_)
-                {
-                    __b[0] = __traits_.translate_nocase(__b[0]);
-                    __e[0] = __traits_.translate_nocase(__e[0]);
-                }
-                __ranges_.push_back(std::make_pair(_VSTD::move(__b), _VSTD::move(__e)));
-            }
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    void __add_digraph(_CharT __c1, _CharT __c2)
-        {
-            if (__icase_)
-                __digraphs_.push_back(std::make_pair(__traits_.translate_nocase(__c1),
-                                                     __traits_.translate_nocase(__c2)));
-            else if (__collate_)
-                __digraphs_.push_back(std::make_pair(__traits_.translate(__c1),
-                                                     __traits_.translate(__c2)));
-            else
-                __digraphs_.push_back(std::make_pair(__c1, __c2));
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    void __add_equivalence(const string_type& __s)
-        {__equivalences_.push_back(__s);}
-    _LIBCPP_INLINE_VISIBILITY
-    void __add_class(typename regex_traits<_CharT>::char_class_type __mask)
-        {__mask_ |= __mask;}
-    _LIBCPP_INLINE_VISIBILITY
-    void __add_neg_class(typename regex_traits<_CharT>::char_class_type __mask)
-        {__neg_mask_ |= __mask;}
+  _LIBCPP_HIDE_FROM_ABI bool __negated() const { return __negate_; }
+
+  _LIBCPP_HIDE_FROM_ABI void __add_char(_CharT __c) {
+    if (__icase_)
+      __chars_.push_back(__traits_.translate_nocase(__c));
+    else if (__collate_)
+      __chars_.push_back(__traits_.translate(__c));
+    else
+      __chars_.push_back(__c);
+  }
+  _LIBCPP_HIDE_FROM_ABI void __add_neg_char(_CharT __c) {
+    if (__icase_)
+      __neg_chars_.push_back(__traits_.translate_nocase(__c));
+    else if (__collate_)
+      __neg_chars_.push_back(__traits_.translate(__c));
+    else
+      __neg_chars_.push_back(__c);
+  }
+  _LIBCPP_HIDE_FROM_ABI void __add_range(string_type __b, string_type __e) {
+    if (__collate_) {
+      if (__icase_) {
+        for (size_t __i = 0; __i < __b.size(); ++__i)
+          __b[__i] = __traits_.translate_nocase(__b[__i]);
+        for (size_t __i = 0; __i < __e.size(); ++__i)
+          __e[__i] = __traits_.translate_nocase(__e[__i]);
+      } else {
+        for (size_t __i = 0; __i < __b.size(); ++__i)
+          __b[__i] = __traits_.translate(__b[__i]);
+        for (size_t __i = 0; __i < __e.size(); ++__i)
+          __e[__i] = __traits_.translate(__e[__i]);
+      }
+      __ranges_.push_back(
+          std::make_pair(__traits_.transform(__b.begin(), __b.end()), __traits_.transform(__e.begin(), __e.end())));
+    } else {
+      if (__b.size() != 1 || __e.size() != 1)
+        __throw_regex_error<regex_constants::error_range>();
+      if (__icase_) {
+        __b[0] = __traits_.translate_nocase(__b[0]);
+        __e[0] = __traits_.translate_nocase(__e[0]);
+      }
+      __ranges_.push_back(std::make_pair(std::move(__b), std::move(__e)));
+    }
+  }
+  _LIBCPP_HIDE_FROM_ABI void __add_digraph(_CharT __c1, _CharT __c2) {
+    if (__icase_)
+      __digraphs_.push_back(std::make_pair(__traits_.translate_nocase(__c1), __traits_.translate_nocase(__c2)));
+    else if (__collate_)
+      __digraphs_.push_back(std::make_pair(__traits_.translate(__c1), __traits_.translate(__c2)));
+    else
+      __digraphs_.push_back(std::make_pair(__c1, __c2));
+  }
+  _LIBCPP_HIDE_FROM_ABI void __add_equivalence(const string_type& __s) { __equivalences_.push_back(__s); }
+  _LIBCPP_HIDE_FROM_ABI void __add_class(typename regex_traits<_CharT>::char_class_type __mask) { __mask_ |= __mask; }
+  _LIBCPP_HIDE_FROM_ABI void __add_neg_class(typename regex_traits<_CharT>::char_class_type __mask) {
+    __neg_mask_ |= __mask;
+  }
 };
 
 template <class _CharT, class _Traits>
-void
-__bracket_expression<_CharT, _Traits>::__exec(__state& __s) const
-{
-    bool __found = false;
-    unsigned __consumed = 0;
-    if (__s.__current_ != __s.__last_)
-    {
-        ++__consumed;
-        if (__might_have_digraph_)
-        {
-            const _CharT* __next = _VSTD::next(__s.__current_);
-            if (__next != __s.__last_)
-            {
-                pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
-                if (__icase_)
-                {
-                    __ch2.first = __traits_.translate_nocase(__ch2.first);
-                    __ch2.second = __traits_.translate_nocase(__ch2.second);
-                }
-                else if (__collate_)
-                {
-                    __ch2.first = __traits_.translate(__ch2.first);
-                    __ch2.second = __traits_.translate(__ch2.second);
-                }
-                if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first+2).empty())
-                {
-                    // __ch2 is a digraph in this locale
-                    ++__consumed;
-                    for (size_t __i = 0; __i < __digraphs_.size(); ++__i)
-                    {
-                        if (__ch2 == __digraphs_[__i])
-                        {
-                            __found = true;
-                            goto __exit;
-                        }
-                    }
-                    if (__collate_ && !__ranges_.empty())
-                    {
-                        string_type __s2 = __traits_.transform(&__ch2.first,
-                                                               &__ch2.first + 2);
-                        for (size_t __i = 0; __i < __ranges_.size(); ++__i)
-                        {
-                            if (__ranges_[__i].first <= __s2 &&
-                                __s2 <= __ranges_[__i].second)
-                            {
-                                __found = true;
-                                goto __exit;
-                            }
-                        }
-                    }
-                    if (!__equivalences_.empty())
-                    {
-                        string_type __s2 = __traits_.transform_primary(&__ch2.first,
-                                                                       &__ch2.first + 2);
-                        for (size_t __i = 0; __i < __equivalences_.size(); ++__i)
-                        {
-                            if (__s2 == __equivalences_[__i])
-                            {
-                                __found = true;
-                                goto __exit;
-                            }
-                        }
-                    }
-                    if (__traits_.isctype(__ch2.first, __mask_) &&
-                        __traits_.isctype(__ch2.second, __mask_))
-                    {
-                        __found = true;
-                        goto __exit;
-                    }
-                    if (!__traits_.isctype(__ch2.first, __neg_mask_) &&
-                        !__traits_.isctype(__ch2.second, __neg_mask_))
-                    {
-                        __found = true;
-                        goto __exit;
-                    }
-                    goto __exit;
-                }
-            }
+void __bracket_expression<_CharT, _Traits>::__exec(__state& __s) const {
+  bool __found        = false;
+  unsigned __consumed = 0;
+  if (__s.__current_ != __s.__last_) {
+    ++__consumed;
+    if (__might_have_digraph_) {
+      const _CharT* __next = std::next(__s.__current_);
+      if (__next != __s.__last_) {
+        pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
+        if (__icase_) {
+          __ch2.first  = __traits_.translate_nocase(__ch2.first);
+          __ch2.second = __traits_.translate_nocase(__ch2.second);
+        } else if (__collate_) {
+          __ch2.first  = __traits_.translate(__ch2.first);
+          __ch2.second = __traits_.translate(__ch2.second);
         }
-        // test *__s.__current_ as not a digraph
-        _CharT __ch = *__s.__current_;
-        if (__icase_)
-            __ch = __traits_.translate_nocase(__ch);
-        else if (__collate_)
-            __ch = __traits_.translate(__ch);
-        for (size_t __i = 0; __i < __chars_.size(); ++__i)
-        {
-            if (__ch == __chars_[__i])
-            {
+        if (!__traits_.lookup_collatename(&__ch2.first, &__ch2.first + 2).empty()) {
+          // __ch2 is a digraph in this locale
+          ++__consumed;
+          for (size_t __i = 0; __i < __digraphs_.size(); ++__i) {
+            if (__ch2 == __digraphs_[__i]) {
+              __found = true;
+              goto __exit;
+            }
+          }
+          if (__collate_ && !__ranges_.empty()) {
+            string_type __s2 = __traits_.transform(&__ch2.first, &__ch2.first + 2);
+            for (size_t __i = 0; __i < __ranges_.size(); ++__i) {
+              if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second) {
                 __found = true;
                 goto __exit;
+              }
             }
-        }
-        // When there's at least one of __neg_chars_ and __neg_mask_, the set
-        // of "__found" chars is
-        //   union(complement(union(__neg_chars_, __neg_mask_)),
-        //         other cases...)
-        //
-        // It doesn't make sense to check this when there are no __neg_chars_
-        // and no __neg_mask_.
-        if (!(__neg_mask_ == 0 && __neg_chars_.empty()))
-        {
-            const bool __in_neg_mask = __traits_.isctype(__ch, __neg_mask_);
-          const bool __in_neg_chars =
-              _VSTD::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) !=
-              __neg_chars_.end();
-          if (!(__in_neg_mask || __in_neg_chars))
-          {
+          }
+          if (!__equivalences_.empty()) {
+            string_type __s2 = __traits_.transform_primary(&__ch2.first, &__ch2.first + 2);
+            for (size_t __i = 0; __i < __equivalences_.size(); ++__i) {
+              if (__s2 == __equivalences_[__i]) {
+                __found = true;
+                goto __exit;
+              }
+            }
+          }
+          if (__traits_.isctype(__ch2.first, __mask_) && __traits_.isctype(__ch2.second, __mask_)) {
             __found = true;
             goto __exit;
           }
-        }
-        if (!__ranges_.empty())
-        {
-            string_type __s2 = __collate_ ?
-                                   __traits_.transform(&__ch, &__ch + 1) :
-                                   string_type(1, __ch);
-            for (size_t __i = 0; __i < __ranges_.size(); ++__i)
-            {
-                if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second)
-                {
-                    __found = true;
-                    goto __exit;
-                }
-            }
-        }
-        if (!__equivalences_.empty())
-        {
-            string_type __s2 = __traits_.transform_primary(&__ch, &__ch + 1);
-            for (size_t __i = 0; __i < __equivalences_.size(); ++__i)
-            {
-                if (__s2 == __equivalences_[__i])
-                {
-                    __found = true;
-                    goto __exit;
-                }
-            }
-        }
-        if (__traits_.isctype(__ch, __mask_))
-        {
+          if (!__traits_.isctype(__ch2.first, __neg_mask_) && !__traits_.isctype(__ch2.second, __neg_mask_)) {
             __found = true;
             goto __exit;
+          }
+          goto __exit;
         }
+      }
     }
-    else
-        __found = __negate_;  // force reject
+    // test *__s.__current_ as not a digraph
+    _CharT __ch = *__s.__current_;
+    if (__icase_)
+      __ch = __traits_.translate_nocase(__ch);
+    else if (__collate_)
+      __ch = __traits_.translate(__ch);
+    for (size_t __i = 0; __i < __chars_.size(); ++__i) {
+      if (__ch == __chars_[__i]) {
+        __found = true;
+        goto __exit;
+      }
+    }
+    // When there's at least one of __neg_chars_ and __neg_mask_, the set
+    // of "__found" chars is
+    //   union(complement(union(__neg_chars_, __neg_mask_)),
+    //         other cases...)
+    //
+    // It doesn't make sense to check this when there are no __neg_chars_
+    // and no __neg_mask_.
+    if (!(__neg_mask_ == 0 && __neg_chars_.empty())) {
+      const bool __in_neg_mask  = __traits_.isctype(__ch, __neg_mask_);
+      const bool __in_neg_chars = std::find(__neg_chars_.begin(), __neg_chars_.end(), __ch) != __neg_chars_.end();
+      if (!(__in_neg_mask || __in_neg_chars)) {
+        __found = true;
+        goto __exit;
+      }
+    }
+    if (!__ranges_.empty()) {
+      string_type __s2 = __collate_ ? __traits_.transform(&__ch, &__ch + 1) : string_type(1, __ch);
+      for (size_t __i = 0; __i < __ranges_.size(); ++__i) {
+        if (__ranges_[__i].first <= __s2 && __s2 <= __ranges_[__i].second) {
+          __found = true;
+          goto __exit;
+        }
+      }
+    }
+    if (!__equivalences_.empty()) {
+      string_type __s2 = __traits_.transform_primary(&__ch, &__ch + 1);
+      for (size_t __i = 0; __i < __equivalences_.size(); ++__i) {
+        if (__s2 == __equivalences_[__i]) {
+          __found = true;
+          goto __exit;
+        }
+      }
+    }
+    if (__traits_.isctype(__ch, __mask_)) {
+      __found = true;
+      goto __exit;
+    }
+  } else
+    __found = __negate_; // force reject
 __exit:
-    if (__found != __negate_)
-    {
-        __s.__do_ = __state::__accept_and_consume;
-        __s.__current_ += __consumed;
-        __s.__node_ = this->first();
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
+  if (__found != __negate_) {
+    __s.__do_ = __state::__accept_and_consume;
+    __s.__current_ += __consumed;
+    __s.__node_ = this->first();
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
 }
 
-template <class _CharT, class _Traits> class __lookahead;
+template <class _CharT, class _Traits>
+class __lookahead;
 
 template <class _CharT, class _Traits = regex_traits<_CharT> >
-    class _LIBCPP_TEMPLATE_VIS basic_regex;
+class _LIBCPP_TEMPLATE_VIS basic_regex;
 
-typedef basic_regex<char>    regex;
+typedef basic_regex<char> regex;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 typedef basic_regex<wchar_t> wregex;
 #endif
 
 template <class _CharT, class _Traits>
-class
-    _LIBCPP_TEMPLATE_VIS
-    _LIBCPP_PREFERRED_NAME(regex)
-    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wregex))
-    basic_regex
-{
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_PREFERRED_NAME(regex)
+    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wregex)) basic_regex {
 public:
-    // types:
-    typedef _CharT                              value_type;
-    typedef _Traits                             traits_type;
-    typedef typename _Traits::string_type       string_type;
-    typedef regex_constants::syntax_option_type flag_type;
-    typedef typename _Traits::locale_type       locale_type;
+  // types:
+  typedef _CharT value_type;
+  typedef _Traits traits_type;
+  typedef typename _Traits::string_type string_type;
+  typedef regex_constants::syntax_option_type flag_type;
+  typedef typename _Traits::locale_type locale_type;
 
 private:
-    _Traits   __traits_;
-    flag_type __flags_;
-    unsigned __marked_count_;
-    unsigned __loop_count_;
-    int __open_count_;
-    shared_ptr<__empty_state<_CharT> > __start_;
-    __owns_one_state<_CharT>* __end_;
+  _Traits __traits_;
+  flag_type __flags_;
+  unsigned __marked_count_;
+  unsigned __loop_count_;
+  int __open_count_;
+  shared_ptr<__empty_state<_CharT> > __start_;
+  __owns_one_state<_CharT>* __end_;
 
-    typedef _VSTD::__state<_CharT> __state;
-    typedef _VSTD::__node<_CharT> __node;
+  typedef std::__state<_CharT> __state;
+  typedef std::__node<_CharT> __node;
 
 public:
-    // constants:
-    static const regex_constants::syntax_option_type icase = regex_constants::icase;
-    static const regex_constants::syntax_option_type nosubs = regex_constants::nosubs;
-    static const regex_constants::syntax_option_type optimize = regex_constants::optimize;
-    static const regex_constants::syntax_option_type collate = regex_constants::collate;
-    static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
-    static const regex_constants::syntax_option_type basic = regex_constants::basic;
-    static const regex_constants::syntax_option_type extended = regex_constants::extended;
-    static const regex_constants::syntax_option_type awk = regex_constants::awk;
-    static const regex_constants::syntax_option_type grep = regex_constants::grep;
-    static const regex_constants::syntax_option_type egrep = regex_constants::egrep;
-    static const regex_constants::syntax_option_type multiline = regex_constants::multiline;
+  // constants:
+  static const regex_constants::syntax_option_type icase      = regex_constants::icase;
+  static const regex_constants::syntax_option_type nosubs     = regex_constants::nosubs;
+  static const regex_constants::syntax_option_type optimize   = regex_constants::optimize;
+  static const regex_constants::syntax_option_type collate    = regex_constants::collate;
+  static const regex_constants::syntax_option_type ECMAScript = regex_constants::ECMAScript;
+  static const regex_constants::syntax_option_type basic      = regex_constants::basic;
+  static const regex_constants::syntax_option_type extended   = regex_constants::extended;
+  static const regex_constants::syntax_option_type awk        = regex_constants::awk;
+  static const regex_constants::syntax_option_type grep       = regex_constants::grep;
+  static const regex_constants::syntax_option_type egrep      = regex_constants::egrep;
+  static const regex_constants::syntax_option_type multiline  = regex_constants::multiline;
 
-    // construct/copy/destroy:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_regex()
-        : __flags_(regex_constants::ECMAScript), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(nullptr)
-        {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
-        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(nullptr)
-        {
-        __init(__p, __p + __traits_.length(__p));
-        }
+  // construct/copy/destroy:
+  _LIBCPP_HIDE_FROM_ABI basic_regex()
+      : __flags_(regex_constants::ECMAScript),
+        __marked_count_(0),
+        __loop_count_(0),
+        __open_count_(0),
+        __end_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
+      : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), __end_(nullptr) {
+    __init(__p, __p + __traits_.length(__p));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_regex(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
-        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(nullptr)
-        {
-        __init(__p, __p + __len);
-        }
+  _LIBCPP_HIDE_FROM_ABI basic_regex(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
+      : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), __end_(nullptr) {
+    __init(__p, __p + __len);
+  }
 
-//     basic_regex(const basic_regex&) = default;
-//     basic_regex(basic_regex&&) = default;
-    template <class _ST, class _SA>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p,
-                             flag_type __f = regex_constants::ECMAScript)
-        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(nullptr)
-        {
-        __init(__p.begin(), __p.end());
-        }
+  //     basic_regex(const basic_regex&) = default;
+  //     basic_regex(basic_regex&&) = default;
+  template <class _ST, class _SA>
+  _LIBCPP_HIDE_FROM_ABI explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p,
+                                             flag_type __f = regex_constants::ECMAScript)
+      : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), __end_(nullptr) {
+    __init(__p.begin(), __p.end());
+  }
 
-    template <class _ForwardIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        basic_regex(_ForwardIterator __first, _ForwardIterator __last,
-                    flag_type __f = regex_constants::ECMAScript)
-        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(nullptr)
-        {
-        __init(__first, __last);
-        }
+  template <class _ForwardIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  basic_regex(_ForwardIterator __first, _ForwardIterator __last, flag_type __f = regex_constants::ECMAScript)
+      : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), __end_(nullptr) {
+    __init(__first, __last);
+  }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    basic_regex(initializer_list<value_type> __il,
-                flag_type __f = regex_constants::ECMAScript)
-        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(nullptr)
-        {
-        __init(__il.begin(), __il.end());
-        }
+  _LIBCPP_HIDE_FROM_ABI basic_regex(initializer_list<value_type> __il, flag_type __f = regex_constants::ECMAScript)
+      : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0), __end_(nullptr) {
+    __init(__il.begin(), __il.end());
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-//    ~basic_regex() = default;
+  //    ~basic_regex() = default;
 
-//     basic_regex& operator=(const basic_regex&) = default;
-//     basic_regex& operator=(basic_regex&&) = default;
-    _LIBCPP_INLINE_VISIBILITY
-    basic_regex& operator=(const value_type* __p)
-        {return assign(__p);}
+  //     basic_regex& operator=(const basic_regex&) = default;
+  //     basic_regex& operator=(basic_regex&&) = default;
+  _LIBCPP_HIDE_FROM_ABI basic_regex& operator=(const value_type* __p) { return assign(__p); }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    basic_regex& operator=(initializer_list<value_type> __il)
-        {return assign(__il);}
+  _LIBCPP_HIDE_FROM_ABI basic_regex& operator=(initializer_list<value_type> __il) { return assign(__il); }
 #endif // _LIBCPP_CXX03_LANG
-    template <class _ST, class _SA>
-        _LIBCPP_INLINE_VISIBILITY
-        basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p)
-        {return assign(__p);}
+  template <class _ST, class _SA>
+  _LIBCPP_HIDE_FROM_ABI basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p) {
+    return assign(__p);
+  }
 
-    // assign:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_regex& assign(const basic_regex& __that)
-        {return *this = __that;}
+  // assign:
+  _LIBCPP_HIDE_FROM_ABI basic_regex& assign(const basic_regex& __that) { return *this = __that; }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    basic_regex& assign(basic_regex&& __that) _NOEXCEPT
-        {return *this = _VSTD::move(__that);}
+  _LIBCPP_HIDE_FROM_ABI basic_regex& assign(basic_regex&& __that) _NOEXCEPT { return *this = std::move(__that); }
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
-        {return assign(__p, __p + __traits_.length(__p), __f);}
-    _LIBCPP_INLINE_VISIBILITY
-    basic_regex& assign(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript)
-        {return assign(__p, __p + __len, __f);}
-    template <class _ST, class _SA>
-        _LIBCPP_INLINE_VISIBILITY
-        basic_regex& assign(const basic_string<value_type, _ST, _SA>& __s,
-                            flag_type __f = regex_constants::ECMAScript)
-            {return assign(__s.begin(), __s.end(), __f);}
+  _LIBCPP_HIDE_FROM_ABI basic_regex& assign(const value_type* __p, flag_type __f = regex_constants::ECMAScript) {
+    return assign(__p, __p + __traits_.length(__p), __f);
+  }
+  _LIBCPP_HIDE_FROM_ABI basic_regex&
+  assign(const value_type* __p, size_t __len, flag_type __f = regex_constants::ECMAScript) {
+    return assign(__p, __p + __len, __f);
+  }
+  template <class _ST, class _SA>
+  _LIBCPP_HIDE_FROM_ABI basic_regex&
+  assign(const basic_string<value_type, _ST, _SA>& __s, flag_type __f = regex_constants::ECMAScript) {
+    return assign(__s.begin(), __s.end(), __f);
+  }
 
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if<__has_exactly_input_iterator_category<_InputIterator>::value, basic_regex&>::type
-        assign(_InputIterator __first, _InputIterator __last,
-                            flag_type __f = regex_constants::ECMAScript)
-        {
-            basic_string<_CharT> __t(__first, __last);
-            return assign(__t.begin(), __t.end(), __f);
-        }
+  template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI basic_regex&
+  assign(_InputIterator __first, _InputIterator __last, flag_type __f = regex_constants::ECMAScript) {
+    basic_string<_CharT> __t(__first, __last);
+    return assign(__t.begin(), __t.end(), __f);
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    void __member_init(flag_type __f)
-    {
-        __flags_ = __f;
-        __marked_count_ = 0;
-        __loop_count_ = 0;
-        __open_count_ = 0;
-        __end_ = nullptr;
-    }
-public:
+  _LIBCPP_HIDE_FROM_ABI void __member_init(flag_type __f) {
+    __flags_        = __f;
+    __marked_count_ = 0;
+    __loop_count_   = 0;
+    __open_count_   = 0;
+    __end_          = nullptr;
+  }
 
-    template <class _ForwardIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        typename enable_if
-        <
-            __has_forward_iterator_category<_ForwardIterator>::value,
-            basic_regex&
-        >::type
-        assign(_ForwardIterator __first, _ForwardIterator __last,
-                            flag_type __f = regex_constants::ECMAScript)
-        {
-            return assign(basic_regex(__first, __last, __f));
-        }
+public:
+  template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI basic_regex&
+  assign(_ForwardIterator __first, _ForwardIterator __last, flag_type __f = regex_constants::ECMAScript) {
+    return assign(basic_regex(__first, __last, __f));
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_regex& assign(initializer_list<value_type> __il,
-                        flag_type __f = regex_constants::ECMAScript)
-        {return assign(__il.begin(), __il.end(), __f);}
+  _LIBCPP_HIDE_FROM_ABI basic_regex&
+  assign(initializer_list<value_type> __il, flag_type __f = regex_constants::ECMAScript) {
+    return assign(__il.begin(), __il.end(), __f);
+  }
 
 #endif // _LIBCPP_CXX03_LANG
 
-    // const operations:
-    _LIBCPP_INLINE_VISIBILITY
-    unsigned mark_count() const {return __marked_count_;}
-    _LIBCPP_INLINE_VISIBILITY
-    flag_type flags() const {return __flags_;}
+  // const operations:
+  _LIBCPP_HIDE_FROM_ABI unsigned mark_count() const { return __marked_count_; }
+  _LIBCPP_HIDE_FROM_ABI flag_type flags() const { return __flags_; }
 
-    // locale:
-    _LIBCPP_INLINE_VISIBILITY
-    locale_type imbue(locale_type __loc)
-    {
-        __member_init(ECMAScript);
-        __start_.reset();
-        return __traits_.imbue(__loc);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    locale_type getloc() const {return __traits_.getloc();}
+  // locale:
+  _LIBCPP_HIDE_FROM_ABI locale_type imbue(locale_type __loc) {
+    __member_init(ECMAScript);
+    __start_.reset();
+    return __traits_.imbue(__loc);
+  }
+  _LIBCPP_HIDE_FROM_ABI locale_type getloc() const { return __traits_.getloc(); }
 
-    // swap:
-    void swap(basic_regex& __r);
+  // swap:
+  void swap(basic_regex& __r);
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    unsigned __loop_count() const {return __loop_count_;}
+  _LIBCPP_HIDE_FROM_ABI unsigned __loop_count() const { return __loop_count_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool __use_multiline() const
-    {
-        return __get_grammar(__flags_) == ECMAScript && (__flags_ & multiline);
-    }
+  _LIBCPP_HIDE_FROM_ABI bool __use_multiline() const {
+    return __get_grammar(__flags_) == ECMAScript && (__flags_ & multiline);
+  }
 
-    template <class _ForwardIterator>
-        void
-        __init(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_RE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
-                               __owns_one_state<_CharT>* __s,
-                               unsigned __mexp_begin, unsigned __mexp_end);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_ERE_dupl_symbol(_ForwardIterator __first, _ForwardIterator __last,
-                                __owns_one_state<_CharT>* __s,
-                                unsigned __mexp_begin, unsigned __mexp_end);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_follow_list(_ForwardIterator __first, _ForwardIterator __last,
-                            __bracket_expression<_CharT, _Traits>* __ml);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_expression_term(_ForwardIterator __first, _ForwardIterator __last,
-                                __bracket_expression<_CharT, _Traits>* __ml);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_equivalence_class(_ForwardIterator __first, _ForwardIterator __last,
-                                  __bracket_expression<_CharT, _Traits>* __ml);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_character_class(_ForwardIterator __first, _ForwardIterator __last,
-                                __bracket_expression<_CharT, _Traits>* __ml);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last,
-                                 basic_string<_CharT>& __col_sym);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_alternative(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_term(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_assertion(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_atom(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_character_escape(_ForwardIterator __first, _ForwardIterator __last,
-                                 basic_string<_CharT>* __str = nullptr);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_grep(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_egrep(_ForwardIterator __first, _ForwardIterator __last);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_class_escape(_ForwardIterator __first, _ForwardIterator __last,
-                          basic_string<_CharT>& __str,
-                          __bracket_expression<_CharT, _Traits>* __ml);
-    template <class _ForwardIterator>
-        _ForwardIterator
-        __parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last,
-                          basic_string<_CharT>* __str = nullptr);
+  template <class _ForwardIterator>
+  void __init(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_RE_dupl_symbol(
+      _ForwardIterator __first,
+      _ForwardIterator __last,
+      __owns_one_state<_CharT>* __s,
+      unsigned __mexp_begin,
+      unsigned __mexp_end);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_ERE_dupl_symbol(
+      _ForwardIterator __first,
+      _ForwardIterator __last,
+      __owns_one_state<_CharT>* __s,
+      unsigned __mexp_begin,
+      unsigned __mexp_end);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator
+  __parse_follow_list(_ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_expression_term(
+      _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_equivalence_class(
+      _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_character_class(
+      _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml);
+  template <class _ForwardIterator>
+  _ForwardIterator
+  __parse_collating_symbol(_ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>& __col_sym);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_alternative(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_term(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_assertion(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_atom(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator
+  __parse_character_escape(_ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>* __str = nullptr);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_grep(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_egrep(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator>
+  _ForwardIterator __parse_class_escape(
+      _ForwardIterator __first,
+      _ForwardIterator __last,
+      basic_string<_CharT>& __str,
+      __bracket_expression<_CharT, _Traits>* __ml);
+  template <class _ForwardIterator>
+  _ForwardIterator
+  __parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>* __str = nullptr);
 
-    bool __test_back_ref(_CharT);
+  bool __test_back_ref(_CharT);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __push_l_anchor();
-    void __push_r_anchor();
-    void __push_match_any();
-    void __push_match_any_but_newline();
-    _LIBCPP_INLINE_VISIBILITY
-    void __push_greedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
-                                  unsigned __mexp_begin = 0, unsigned __mexp_end = 0)
-        {__push_loop(__min, numeric_limits<size_t>::max(), __s,
-                     __mexp_begin, __mexp_end);}
-    _LIBCPP_INLINE_VISIBILITY
-    void __push_nongreedy_inf_repeat(size_t __min, __owns_one_state<_CharT>* __s,
-                                  unsigned __mexp_begin = 0, unsigned __mexp_end = 0)
-        {__push_loop(__min, numeric_limits<size_t>::max(), __s,
-                     __mexp_begin, __mexp_end, false);}
-    void __push_loop(size_t __min, size_t __max, __owns_one_state<_CharT>* __s,
-                     size_t __mexp_begin = 0, size_t __mexp_end = 0,
-                     bool __greedy = true);
-    __bracket_expression<_CharT, _Traits>* __start_matching_list(bool __negate);
-    void __push_char(value_type __c);
-    void __push_back_ref(int __i);
-    void __push_alternation(__owns_one_state<_CharT>* __sa,
-                            __owns_one_state<_CharT>* __sb);
-    void __push_begin_marked_subexpression();
-    void __push_end_marked_subexpression(unsigned);
-    void __push_empty();
-    void __push_word_boundary(bool);
-    void __push_lookahead(const basic_regex&, bool, unsigned);
+  _LIBCPP_HIDE_FROM_ABI void __push_l_anchor();
+  void __push_r_anchor();
+  void __push_match_any();
+  void __push_match_any_but_newline();
+  _LIBCPP_HIDE_FROM_ABI void __push_greedy_inf_repeat(
+      size_t __min, __owns_one_state<_CharT>* __s, unsigned __mexp_begin = 0, unsigned __mexp_end = 0) {
+    __push_loop(__min, numeric_limits<size_t>::max(), __s, __mexp_begin, __mexp_end);
+  }
+  _LIBCPP_HIDE_FROM_ABI void __push_nongreedy_inf_repeat(
+      size_t __min, __owns_one_state<_CharT>* __s, unsigned __mexp_begin = 0, unsigned __mexp_end = 0) {
+    __push_loop(__min, numeric_limits<size_t>::max(), __s, __mexp_begin, __mexp_end, false);
+  }
+  void __push_loop(size_t __min,
+                   size_t __max,
+                   __owns_one_state<_CharT>* __s,
+                   size_t __mexp_begin = 0,
+                   size_t __mexp_end   = 0,
+                   bool __greedy       = true);
+  __bracket_expression<_CharT, _Traits>* __start_matching_list(bool __negate);
+  void __push_char(value_type __c);
+  void __push_back_ref(int __i);
+  void __push_alternation(__owns_one_state<_CharT>* __sa, __owns_one_state<_CharT>* __sb);
+  void __push_begin_marked_subexpression();
+  void __push_end_marked_subexpression(unsigned);
+  void __push_empty();
+  void __push_word_boundary(bool);
+  void __push_lookahead(const basic_regex&, bool, unsigned);
 
-    template <class _Allocator>
-        bool
-        __search(const _CharT* __first, const _CharT* __last,
-                 match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags) const;
+  template <class _Allocator>
+  bool __search(const _CharT* __first,
+                const _CharT* __last,
+                match_results<const _CharT*, _Allocator>& __m,
+                regex_constants::match_flag_type __flags) const;
 
-    template <class _Allocator>
-        bool
-        __match_at_start(const _CharT* __first, const _CharT* __last,
-                 match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
-    template <class _Allocator>
-        bool
-        __match_at_start_ecma(const _CharT* __first, const _CharT* __last,
-                 match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
-    template <class _Allocator>
-        bool
-        __match_at_start_posix_nosubs(const _CharT* __first, const _CharT* __last,
-                 match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
-    template <class _Allocator>
-        bool
-        __match_at_start_posix_subs(const _CharT* __first, const _CharT* __last,
-                 match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
+  template <class _Allocator>
+  bool __match_at_start(const _CharT* __first,
+                        const _CharT* __last,
+                        match_results<const _CharT*, _Allocator>& __m,
+                        regex_constants::match_flag_type __flags,
+                        bool) const;
+  template <class _Allocator>
+  bool __match_at_start_ecma(
+      const _CharT* __first,
+      const _CharT* __last,
+      match_results<const _CharT*, _Allocator>& __m,
+      regex_constants::match_flag_type __flags,
+      bool) const;
+  template <class _Allocator>
+  bool __match_at_start_posix_nosubs(
+      const _CharT* __first,
+      const _CharT* __last,
+      match_results<const _CharT*, _Allocator>& __m,
+      regex_constants::match_flag_type __flags,
+      bool) const;
+  template <class _Allocator>
+  bool __match_at_start_posix_subs(
+      const _CharT* __first,
+      const _CharT* __last,
+      match_results<const _CharT*, _Allocator>& __m,
+      regex_constants::match_flag_type __flags,
+      bool) const;
 
-    template <class _Bp, class _Ap, class _Cp, class _Tp>
-    friend
-    bool
-    regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
-                 regex_constants::match_flag_type);
+  template <class _Bp, class _Ap, class _Cp, class _Tp>
+  friend bool
+  regex_search(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
 
-    template <class _Ap, class _Cp, class _Tp>
-    friend
-    bool
-    regex_search(const _Cp*, const _Cp*, match_results<const _Cp*, _Ap>&,
-                 const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
+  template <class _Ap, class _Cp, class _Tp>
+  friend bool
+  regex_search(const _Cp*,
+               const _Cp*,
+               match_results<const _Cp*, _Ap>&,
+               const basic_regex<_Cp, _Tp>&,
+               regex_constants::match_flag_type);
 
-    template <class _Bp, class _Cp, class _Tp>
-    friend
-    bool
-    regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&,
-                 regex_constants::match_flag_type);
+  template <class _Bp, class _Cp, class _Tp>
+  friend bool regex_search(_Bp, _Bp, const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
 
-    template <class _Cp, class _Tp>
-    friend
-    bool
-    regex_search(const _Cp*, const _Cp*,
-                 const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
+  template <class _Cp, class _Tp>
+  friend bool regex_search(const _Cp*, const _Cp*, const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
 
-    template <class _Cp, class _Ap, class _Tp>
-    friend
-    bool
-    regex_search(const _Cp*, match_results<const _Cp*, _Ap>&, const basic_regex<_Cp, _Tp>&,
-                 regex_constants::match_flag_type);
+  template <class _Cp, class _Ap, class _Tp>
+  friend bool regex_search(
+      const _Cp*, match_results<const _Cp*, _Ap>&, const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
 
-    template <class _ST, class _SA, class _Cp, class _Tp>
-    friend
-    bool
-    regex_search(const basic_string<_Cp, _ST, _SA>& __s,
-                 const basic_regex<_Cp, _Tp>& __e,
-                 regex_constants::match_flag_type __flags);
+  template <class _ST, class _SA, class _Cp, class _Tp>
+  friend bool regex_search(const basic_string<_Cp, _ST, _SA>& __s,
+                           const basic_regex<_Cp, _Tp>& __e,
+                           regex_constants::match_flag_type __flags);
 
-    template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
-    friend
-    bool
-    regex_search(const basic_string<_Cp, _ST, _SA>& __s,
-                 match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
-                 const basic_regex<_Cp, _Tp>& __e,
-                 regex_constants::match_flag_type __flags);
+  template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
+  friend bool regex_search(const basic_string<_Cp, _ST, _SA>& __s,
+                           match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
+                           const basic_regex<_Cp, _Tp>& __e,
+                           regex_constants::match_flag_type __flags);
 
-    template <class _Iter, class _Ap, class _Cp, class _Tp>
-    friend
-    bool
-    regex_search(__wrap_iter<_Iter> __first,
-                 __wrap_iter<_Iter> __last,
-                 match_results<__wrap_iter<_Iter>, _Ap>& __m,
-                 const basic_regex<_Cp, _Tp>& __e,
-                 regex_constants::match_flag_type __flags);
+  template <class _Iter, class _Ap, class _Cp, class _Tp>
+  friend bool
+  regex_search(__wrap_iter<_Iter> __first,
+               __wrap_iter<_Iter> __last,
+               match_results<__wrap_iter<_Iter>, _Ap>& __m,
+               const basic_regex<_Cp, _Tp>& __e,
+               regex_constants::match_flag_type __flags);
 
-    template <class, class> friend class __lookahead;
+  template <class, class>
+  friend class __lookahead;
 };
 
 #if _LIBCPP_STD_VER >= 17
-template <class _ForwardIterator,
-          class = typename enable_if<__has_forward_iterator_category<_ForwardIterator>::value, nullptr_t>::type
->
-basic_regex(_ForwardIterator, _ForwardIterator,
-            regex_constants::syntax_option_type = regex_constants::ECMAScript)
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+basic_regex(_ForwardIterator, _ForwardIterator, regex_constants::syntax_option_type = regex_constants::ECMAScript)
     -> basic_regex<typename iterator_traits<_ForwardIterator>::value_type>;
 #endif
 
 template <class _CharT, class _Traits>
-    const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::icase;
+const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::icase;
 template <class _CharT, class _Traits>
-    const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::nosubs;
+const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::nosubs;
 template <class _CharT, class _Traits>
-    const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::optimize;
+const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::optimize;
 template <class _CharT, class _Traits>
-    const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::collate;
+const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::collate;
 template <class _CharT, class _Traits>
-    const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::ECMAScript;
+const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::ECMAScript;
 template <class _CharT, class _Traits>
-    const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::basic;
+const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::basic;
 template <class _CharT, class _Traits>
-    const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::extended;
+const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::extended;
 template <class _CharT, class _Traits>
-    const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::awk;
+const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::awk;
 template <class _CharT, class _Traits>
-    const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::grep;
+const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::grep;
 template <class _CharT, class _Traits>
-    const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::egrep;
+const regex_constants::syntax_option_type basic_regex<_CharT, _Traits>::egrep;
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
-{
-    using _VSTD::swap;
-    swap(__traits_, __r.__traits_);
-    swap(__flags_, __r.__flags_);
-    swap(__marked_count_, __r.__marked_count_);
-    swap(__loop_count_, __r.__loop_count_);
-    swap(__open_count_, __r.__open_count_);
-    swap(__start_, __r.__start_);
-    swap(__end_, __r.__end_);
+void basic_regex<_CharT, _Traits>::swap(basic_regex& __r) {
+  using std::swap;
+  swap(__traits_, __r.__traits_);
+  swap(__flags_, __r.__flags_);
+  swap(__marked_count_, __r.__marked_count_);
+  swap(__loop_count_, __r.__loop_count_);
+  swap(__open_count_, __r.__open_count_);
+  swap(__start_, __r.__start_);
+  swap(__end_, __r.__end_);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(basic_regex<_CharT, _Traits>& __x, basic_regex<_CharT, _Traits>& __y)
-{
-    return __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void swap(basic_regex<_CharT, _Traits>& __x, basic_regex<_CharT, _Traits>& __y) {
+  return __x.swap(__y);
 }
 
 // __lookahead
 
 template <class _CharT, class _Traits>
-class __lookahead
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
+class __lookahead : public __owns_one_state<_CharT> {
+  typedef __owns_one_state<_CharT> base;
 
-    basic_regex<_CharT, _Traits> __exp_;
-    unsigned __mexp_;
-    bool __invert_;
+  basic_regex<_CharT, _Traits> __exp_;
+  unsigned __mexp_;
+  bool __invert_;
 
-    __lookahead(const __lookahead&);
-    __lookahead& operator=(const __lookahead&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+  typedef std::__state<_CharT> __state;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp)
-        : base(__s), __exp_(__exp), __mexp_(__mexp), __invert_(__invert) {}
+  _LIBCPP_HIDE_FROM_ABI
+  __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s, unsigned __mexp)
+      : base(__s), __exp_(__exp), __mexp_(__mexp), __invert_(__invert) {}
 
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
+  __lookahead(const __lookahead&)            = delete;
+  __lookahead& operator=(const __lookahead&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __exec(__state&) const;
 };
 
 template <class _CharT, class _Traits>
-void
-__lookahead<_CharT, _Traits>::__exec(__state& __s) const
-{
-    match_results<const _CharT*> __m;
-    __m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_);
-    bool __matched = __exp_.__match_at_start_ecma(
-        __s.__current_, __s.__last_,
-        __m,
-        (__s.__flags_ | regex_constants::match_continuous) &
-        ~regex_constants::__full_match,
-        __s.__at_first_ && __s.__current_ == __s.__first_);
-    if (__matched != __invert_)
-    {
-        __s.__do_ = __state::__accept_but_not_consume;
-        __s.__node_ = this->first();
-        for (unsigned __i = 1; __i < __m.size(); ++__i) {
-            __s.__sub_matches_[__mexp_ + __i - 1] = __m.__matches_[__i];
+void __lookahead<_CharT, _Traits>::__exec(__state& __s) const {
+  match_results<const _CharT*> __m;
+  __m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_);
+  bool __matched = __exp_.__match_at_start_ecma(
+      __s.__current_,
+      __s.__last_,
+      __m,
+      (__s.__flags_ | regex_constants::match_continuous) & ~regex_constants::__full_match,
+      __s.__at_first_ && __s.__current_ == __s.__first_);
+  if (__matched != __invert_) {
+    __s.__do_   = __state::__accept_but_not_consume;
+    __s.__node_ = this->first();
+    for (unsigned __i = 1; __i < __m.size(); ++__i) {
+      __s.__sub_matches_[__mexp_ + __i - 1] = __m.__matches_[__i];
+    }
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+void basic_regex<_CharT, _Traits>::__init(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__get_grammar(__flags_) == 0)
+    __flags_ |= regex_constants::ECMAScript;
+  _ForwardIterator __temp = __parse(__first, __last);
+  if (__temp != __last)
+    __throw_regex_error<regex_constants::__re_err_parse>();
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first, _ForwardIterator __last) {
+  {
+    unique_ptr<__node> __h(new __end_state<_CharT>);
+    __start_.reset(new __empty_state<_CharT>(__h.get()));
+    __h.release();
+    __end_ = __start_.get();
+  }
+  switch (__get_grammar(__flags_)) {
+  case ECMAScript:
+    __first = __parse_ecma_exp(__first, __last);
+    break;
+  case basic:
+    __first = __parse_basic_reg_exp(__first, __last);
+    break;
+  case extended:
+  case awk:
+    __first = __parse_extended_reg_exp(__first, __last);
+    break;
+  case grep:
+    __first = __parse_grep(__first, __last);
+    break;
+  case egrep:
+    __first = __parse_egrep(__first, __last);
+    break;
+  default:
+    __throw_regex_error<regex_constants::__re_err_grammar>();
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator
+basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    if (*__first == '^') {
+      __push_l_anchor();
+      ++__first;
+    }
+    if (__first != __last) {
+      __first = __parse_RE_expression(__first, __last);
+      if (__first != __last) {
+        _ForwardIterator __temp = std::next(__first);
+        if (__temp == __last && *__first == '$') {
+          __push_r_anchor();
+          ++__first;
         }
+      }
     }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-void
-basic_regex<_CharT, _Traits>::__init(_ForwardIterator __first, _ForwardIterator __last)
-{
-    if (__get_grammar(__flags_) == 0) __flags_ |= regex_constants::ECMAScript;
-    _ForwardIterator __temp = __parse(__first, __last);
-    if ( __temp != __last)
-        __throw_regex_error<regex_constants::__re_err_parse>();
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first,
-                                      _ForwardIterator __last)
-{
-    {
-        unique_ptr<__node> __h(new __end_state<_CharT>);
-        __start_.reset(new __empty_state<_CharT>(__h.get()));
-        __h.release();
-        __end_ = __start_.get();
-    }
-    switch (__get_grammar(__flags_))
-    {
-    case ECMAScript:
-        __first = __parse_ecma_exp(__first, __last);
-        break;
-    case basic:
-        __first = __parse_basic_reg_exp(__first, __last);
-        break;
-    case extended:
-    case awk:
-        __first = __parse_extended_reg_exp(__first, __last);
-        break;
-    case grep:
-        __first = __parse_grep(__first, __last);
-        break;
-    case egrep:
-        __first = __parse_egrep(__first, __last);
-        break;
-    default:
-        __throw_regex_error<regex_constants::__re_err_grammar>();
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
-                                                    _ForwardIterator __last)
-{
     if (__first != __last)
-    {
-        if (*__first == '^')
-        {
-            __push_l_anchor();
-            ++__first;
-        }
-        if (__first != __last)
-        {
-            __first = __parse_RE_expression(__first, __last);
-            if (__first != __last)
-            {
-                _ForwardIterator __temp = _VSTD::next(__first);
-                if (__temp == __last && *__first == '$')
-                {
-                    __push_r_anchor();
-                    ++__first;
-                }
-            }
-        }
-        if (__first != __last)
-            __throw_regex_error<regex_constants::__re_err_empty>();
-    }
-    return __first;
+      __throw_regex_error<regex_constants::__re_err_empty>();
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first,
-                                                       _ForwardIterator __last)
-{
-    __owns_one_state<_CharT>* __sa = __end_;
-    _ForwardIterator __temp = __parse_ERE_branch(__first, __last);
+basic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first, _ForwardIterator __last) {
+  __owns_one_state<_CharT>* __sa = __end_;
+  _ForwardIterator __temp        = __parse_ERE_branch(__first, __last);
+  if (__temp == __first)
+    __throw_regex_error<regex_constants::__re_err_empty>();
+  __first = __temp;
+  while (__first != __last && *__first == '|') {
+    __owns_one_state<_CharT>* __sb = __end_;
+    __temp                         = __parse_ERE_branch(++__first, __last);
     if (__temp == __first)
-        __throw_regex_error<regex_constants::__re_err_empty>();
+      __throw_regex_error<regex_constants::__re_err_empty>();
+    __push_alternation(__sa, __sb);
     __first = __temp;
-    while (__first != __last && *__first == '|')
-    {
-        __owns_one_state<_CharT>* __sb = __end_;
-        __temp = __parse_ERE_branch(++__first, __last);
-        if (__temp == __first)
-            __throw_regex_error<regex_constants::__re_err_empty>();
-        __push_alternation(__sa, __sb);
-        __first = __temp;
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last) {
+  _ForwardIterator __temp = __parse_ERE_expression(__first, __last);
+  if (__temp == __first)
+    __throw_regex_error<regex_constants::__re_err_empty>();
+  do {
+    __first = __temp;
+    __temp  = __parse_ERE_expression(__first, __last);
+  } while (__temp != __first);
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator
+basic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first, _ForwardIterator __last) {
+  __owns_one_state<_CharT>* __e = __end_;
+  unsigned __mexp_begin         = __marked_count_;
+  _ForwardIterator __temp       = __parse_one_char_or_coll_elem_ERE(__first, __last);
+  if (__temp == __first && __temp != __last) {
+    switch (*__temp) {
+    case '^':
+      __push_l_anchor();
+      ++__temp;
+      break;
+    case '$':
+      __push_r_anchor();
+      ++__temp;
+      break;
+    case '(':
+      __push_begin_marked_subexpression();
+      unsigned __temp_count = __marked_count_;
+      ++__open_count_;
+      __temp = __parse_extended_reg_exp(++__temp, __last);
+      if (__temp == __last || *__temp != ')')
+        __throw_regex_error<regex_constants::error_paren>();
+      __push_end_marked_subexpression(__temp_count);
+      --__open_count_;
+      ++__temp;
+      break;
     }
-    return __first;
+  }
+  if (__temp != __first)
+    __temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin + 1, __marked_count_ + 1);
+  __first = __temp;
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first,
-                                                 _ForwardIterator __last)
-{
-    _ForwardIterator __temp = __parse_ERE_expression(__first, __last);
+basic_regex<_CharT, _Traits>::__parse_RE_expression(_ForwardIterator __first, _ForwardIterator __last) {
+  while (true) {
+    _ForwardIterator __temp = __parse_simple_RE(__first, __last);
     if (__temp == __first)
-        __throw_regex_error<regex_constants::__re_err_empty>();
-    do
-    {
-        __first = __temp;
-        __temp = __parse_ERE_expression(__first, __last);
-    } while (__temp != __first);
-    return __first;
+      break;
+    __first = __temp;
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first,
-                                                     _ForwardIterator __last)
-{
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_simple_RE(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
     __owns_one_state<_CharT>* __e = __end_;
-    unsigned __mexp_begin = __marked_count_;
-    _ForwardIterator __temp = __parse_one_char_or_coll_elem_ERE(__first, __last);
-    if (__temp == __first && __temp != __last)
-    {
-        switch (*__temp)
-        {
-        case '^':
-            __push_l_anchor();
-            ++__temp;
-            break;
-        case '$':
-            __push_r_anchor();
-            ++__temp;
-            break;
-        case '(':
-            __push_begin_marked_subexpression();
-            unsigned __temp_count = __marked_count_;
-            ++__open_count_;
-            __temp = __parse_extended_reg_exp(++__temp, __last);
-            if (__temp == __last || *__temp != ')')
-                __throw_regex_error<regex_constants::error_paren>();
-            __push_end_marked_subexpression(__temp_count);
-            --__open_count_;
-            ++__temp;
-            break;
-        }
-    }
+    unsigned __mexp_begin         = __marked_count_;
+    _ForwardIterator __temp       = __parse_nondupl_RE(__first, __last);
     if (__temp != __first)
-        __temp = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin+1,
-                                         __marked_count_+1);
-    __first = __temp;
-    return __first;
+      __first = __parse_RE_dupl_symbol(__temp, __last, __e, __mexp_begin + 1, __marked_count_ + 1);
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterator __first, _ForwardIterator __last) {
+  _ForwardIterator __temp = __first;
+  __first                 = __parse_one_char_or_coll_elem_RE(__first, __last);
+  if (__temp == __first) {
+    __temp = __parse_Back_open_paren(__first, __last);
+    if (__temp != __first) {
+      __push_begin_marked_subexpression();
+      unsigned __temp_count = __marked_count_;
+      __first               = __parse_RE_expression(__temp, __last);
+      __temp                = __parse_Back_close_paren(__first, __last);
+      if (__temp == __first)
+        __throw_regex_error<regex_constants::error_paren>();
+      __push_end_marked_subexpression(__temp_count);
+      __first = __temp;
+    } else
+      __first = __parse_BACKREF(__first, __last);
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_RE_expression(_ForwardIterator __first,
-                                                    _ForwardIterator __last)
-{
-    while (true)
-    {
-        _ForwardIterator __temp = __parse_simple_RE(__first, __last);
-        if (__temp == __first)
-            break;
-        __first = __temp;
+basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_RE(_ForwardIterator __first, _ForwardIterator __last) {
+  _ForwardIterator __temp = __parse_ORD_CHAR(__first, __last);
+  if (__temp == __first) {
+    __temp = __parse_QUOTED_CHAR(__first, __last);
+    if (__temp == __first) {
+      if (__temp != __last && *__temp == '.') {
+        __push_match_any();
+        ++__temp;
+      } else
+        __temp = __parse_bracket_expression(__first, __last);
     }
-    return __first;
+  }
+  __first = __temp;
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_simple_RE(_ForwardIterator __first,
-                                                _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        __owns_one_state<_CharT>* __e = __end_;
-        unsigned __mexp_begin = __marked_count_;
-        _ForwardIterator __temp = __parse_nondupl_RE(__first, __last);
-        if (__temp != __first)
-            __first = __parse_RE_dupl_symbol(__temp, __last, __e,
-                                             __mexp_begin+1, __marked_count_+1);
+basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ERE(_ForwardIterator __first, _ForwardIterator __last) {
+  _ForwardIterator __temp = __parse_ORD_CHAR_ERE(__first, __last);
+  if (__temp == __first) {
+    __temp = __parse_QUOTED_CHAR_ERE(__first, __last);
+    if (__temp == __first) {
+      if (__temp != __last && *__temp == '.') {
+        __push_match_any();
+        ++__temp;
+      } else
+        __temp = __parse_bracket_expression(__first, __last);
     }
-    return __first;
+  }
+  __first = __temp;
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterator __first,
-                                                 _ForwardIterator __last)
-{
-    _ForwardIterator __temp = __first;
-    __first = __parse_one_char_or_coll_elem_RE(__first, __last);
-    if (__temp == __first)
-    {
-        __temp = __parse_Back_open_paren(__first, __last);
-        if (__temp != __first)
-        {
-            __push_begin_marked_subexpression();
-            unsigned __temp_count = __marked_count_;
-            __first = __parse_RE_expression(__temp, __last);
-            __temp = __parse_Back_close_paren(__first, __last);
-            if (__temp == __first)
-                __throw_regex_error<regex_constants::error_paren>();
-            __push_end_marked_subexpression(__temp_count);
-            __first = __temp;
-        }
-        else
-            __first = __parse_BACKREF(__first, __last);
+basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    _ForwardIterator __temp = std::next(__first);
+    if (__temp != __last) {
+      if (*__first == '\\' && *__temp == '(')
+        __first = ++__temp;
     }
-    return __first;
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_RE(
-                                                       _ForwardIterator __first,
-                                                       _ForwardIterator __last)
-{
-    _ForwardIterator __temp = __parse_ORD_CHAR(__first, __last);
-    if (__temp == __first)
-    {
-        __temp = __parse_QUOTED_CHAR(__first, __last);
-        if (__temp == __first)
-        {
-            if (__temp != __last && *__temp == '.')
-            {
-                __push_match_any();
-                ++__temp;
-            }
-            else
-                __temp = __parse_bracket_expression(__first, __last);
-        }
+basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    _ForwardIterator __temp = std::next(__first);
+    if (__temp != __last) {
+      if (*__first == '\\' && *__temp == ')')
+        __first = ++__temp;
     }
-    __first = __temp;
-    return __first;
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_one_char_or_coll_elem_ERE(
-                                                       _ForwardIterator __first,
-                                                       _ForwardIterator __last)
-{
-    _ForwardIterator __temp = __parse_ORD_CHAR_ERE(__first, __last);
-    if (__temp == __first)
-    {
-        __temp = __parse_QUOTED_CHAR_ERE(__first, __last);
-        if (__temp == __first)
-        {
-            if (__temp != __last && *__temp == '.')
-            {
-                __push_match_any();
-                ++__temp;
-            }
-            else
-                __temp = __parse_bracket_expression(__first, __last);
-        }
+basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    _ForwardIterator __temp = std::next(__first);
+    if (__temp != __last) {
+      if (*__first == '\\' && *__temp == '{')
+        __first = ++__temp;
     }
-    __first = __temp;
-    return __first;
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
-                                                      _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp != __last)
-        {
-            if (*__first == '\\' && *__temp == '(')
-                __first = ++__temp;
-        }
+basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    _ForwardIterator __temp = std::next(__first);
+    if (__temp != __last) {
+      if (*__first == '\\' && *__temp == '}')
+        __first = ++__temp;
     }
-    return __first;
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
-                                                       _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp != __last)
-        {
-            if (*__first == '\\' && *__temp == ')')
-                __first = ++__temp;
-        }
-    }
-    return __first;
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    _ForwardIterator __temp = std::next(__first);
+    if (__temp != __last && *__first == '\\' && __test_back_ref(*__temp))
+      __first = ++__temp;
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
-                                                      _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp != __last)
-        {
-            if (*__first == '\\' && *__temp == '{')
-                __first = ++__temp;
-        }
-    }
-    return __first;
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    _ForwardIterator __temp = std::next(__first);
+    if (__temp == __last && *__first == '$')
+      return __first;
+    // Not called inside a bracket
+    if (*__first == '.' || *__first == '\\' || *__first == '[')
+      return __first;
+    __push_char(*__first);
+    ++__first;
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
-                                                       _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp != __last)
-        {
-            if (*__first == '\\' && *__temp == '}')
-                __first = ++__temp;
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
-                                              _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp != __last && *__first == '\\' && __test_back_ref(*__temp))
-            __first = ++__temp;
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
-                                               _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp == __last && *__first == '$')
-            return __first;
-        // Not called inside a bracket
-        if (*__first == '.' || *__first == '\\' || *__first == '[')
-            return __first;
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ORD_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    switch (*__first) {
+    case '^':
+    case '.':
+    case '[':
+    case '$':
+    case '(':
+    case '|':
+    case '*':
+    case '+':
+    case '?':
+    case '{':
+    case '\\':
+      break;
+    case ')':
+      if (__open_count_ == 0) {
         __push_char(*__first);
         ++__first;
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ORD_CHAR_ERE(_ForwardIterator __first,
-                                                   _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        switch (*__first)
-        {
-        case '^':
-        case '.':
-        case '[':
-        case '$':
-        case '(':
-        case '|':
-        case '*':
-        case '+':
-        case '?':
-        case '{':
-        case '\\':
-            break;
-        case ')':
-            if (__open_count_ == 0)
-            {
-                __push_char(*__first);
-                ++__first;
-            }
-            break;
-        default:
-            __push_char(*__first);
-            ++__first;
-            break;
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
-                                                  _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp != __last)
-        {
-            if (*__first == '\\')
-            {
-                switch (*__temp)
-                {
-                case '^':
-                case '.':
-                case '*':
-                case '[':
-                case '$':
-                case '\\':
-                    __push_char(*__temp);
-                    __first = ++__temp;
-                    break;
-                }
-            }
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
-                                                      _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        if (__temp != __last)
-        {
-            if (*__first == '\\')
-            {
-                switch (*__temp)
-                {
-                case '^':
-                case '.':
-                case '*':
-                case '[':
-                case '$':
-                case '\\':
-                case '(':
-                case ')':
-                case '|':
-                case '+':
-                case '?':
-                case '{':
-                case '}':
-                    __push_char(*__temp);
-                    __first = ++__temp;
-                    break;
-                default:
-                    if (__get_grammar(__flags_) == awk)
-                        __first = __parse_awk_escape(++__first, __last);
-                    else if(__test_back_ref(*__temp))
-                        __first = ++__temp;
-                    break;
-                }
-            }
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(_ForwardIterator __first,
-                                                     _ForwardIterator __last,
-                                                     __owns_one_state<_CharT>* __s,
-                                                     unsigned __mexp_begin,
-                                                     unsigned __mexp_end)
-{
-    if (__first != __last)
-    {
-        if (*__first == '*')
-        {
-            __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
-            ++__first;
-        }
-        else
-        {
-            _ForwardIterator __temp = __parse_Back_open_brace(__first, __last);
-            if (__temp != __first)
-            {
-                int __min = 0;
-                __first = __temp;
-                __temp = __parse_DUP_COUNT(__first, __last, __min);
-                if (__temp == __first)
-                    __throw_regex_error<regex_constants::error_badbrace>();
-                __first = __temp;
-                if (__first == __last)
-                    __throw_regex_error<regex_constants::error_brace>();
-                if (*__first != ',')
-                {
-                    __temp = __parse_Back_close_brace(__first, __last);
-                    if (__temp == __first)
-                        __throw_regex_error<regex_constants::error_brace>();
-                    __push_loop(__min, __min, __s, __mexp_begin, __mexp_end,
-                                    true);
-                    __first = __temp;
-                }
-                else
-                {
-                    ++__first;  // consume ','
-                    int __max = -1;
-                    __first = __parse_DUP_COUNT(__first, __last, __max);
-                    __temp = __parse_Back_close_brace(__first, __last);
-                    if (__temp == __first)
-                        __throw_regex_error<regex_constants::error_brace>();
-                    if (__max == -1)
-                        __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
-                    else
-                    {
-                        if (__max < __min)
-                            __throw_regex_error<regex_constants::error_badbrace>();
-                        __push_loop(__min, __max, __s, __mexp_begin, __mexp_end,
-                                    true);
-                    }
-                    __first = __temp;
-                }
-            }
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(_ForwardIterator __first,
-                                                      _ForwardIterator __last,
-                                                      __owns_one_state<_CharT>* __s,
-                                                      unsigned __mexp_begin,
-                                                      unsigned __mexp_end)
-{
-    if (__first != __last)
-    {
-        unsigned __grammar = __get_grammar(__flags_);
-        switch (*__first)
-        {
-        case '*':
-            ++__first;
-            if (__grammar == ECMAScript && __first != __last && *__first == '?')
-            {
-                ++__first;
-                __push_nongreedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
-            }
-            else
-                __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
-            break;
-        case '+':
-            ++__first;
-            if (__grammar == ECMAScript && __first != __last && *__first == '?')
-            {
-                ++__first;
-                __push_nongreedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
-            }
-            else
-                __push_greedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
-            break;
-        case '?':
-            ++__first;
-            if (__grammar == ECMAScript && __first != __last && *__first == '?')
-            {
-                ++__first;
-                __push_loop(0, 1, __s, __mexp_begin, __mexp_end, false);
-            }
-            else
-                __push_loop(0, 1, __s, __mexp_begin, __mexp_end);
-            break;
-        case '{':
-            {
-                int __min;
-                _ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min);
-                if (__temp == __first)
-                    __throw_regex_error<regex_constants::error_badbrace>();
-                __first = __temp;
-                if (__first == __last)
-                    __throw_regex_error<regex_constants::error_brace>();
-                switch (*__first)
-                {
-                case '}':
-                    ++__first;
-                    if (__grammar == ECMAScript && __first != __last && *__first == '?')
-                    {
-                        ++__first;
-                        __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, false);
-                    }
-                    else
-                        __push_loop(__min, __min, __s, __mexp_begin, __mexp_end);
-                    break;
-                case ',':
-                    ++__first;
-                    if (__first == __last)
-                        __throw_regex_error<regex_constants::error_badbrace>();
-                    if (*__first == '}')
-                    {
-                        ++__first;
-                        if (__grammar == ECMAScript && __first != __last && *__first == '?')
-                        {
-                            ++__first;
-                            __push_nongreedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
-                        }
-                        else
-                            __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
-                    }
-                    else
-                    {
-                        int __max = -1;
-                        __temp = __parse_DUP_COUNT(__first, __last, __max);
-                        if (__temp == __first)
-                            __throw_regex_error<regex_constants::error_brace>();
-                        __first = __temp;
-                        if (__first == __last || *__first != '}')
-                            __throw_regex_error<regex_constants::error_brace>();
-                        ++__first;
-                        if (__max < __min)
-                            __throw_regex_error<regex_constants::error_badbrace>();
-                        if (__grammar == ECMAScript && __first != __last && *__first == '?')
-                        {
-                            ++__first;
-                            __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, false);
-                        }
-                        else
-                            __push_loop(__min, __max, __s, __mexp_begin, __mexp_end);
-                    }
-                    break;
-                default:
-                    __throw_regex_error<regex_constants::error_badbrace>();
-                }
-            }
-            break;
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __first,
-                                                         _ForwardIterator __last)
-{
-    if (__first != __last && *__first == '[')
-    {
-        ++__first;
-        if (__first == __last)
-            __throw_regex_error<regex_constants::error_brack>();
-        bool __negate = false;
-        if (*__first == '^')
-        {
-            ++__first;
-            __negate = true;
-        }
-        __bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate);
-        // __ml owned by *this
-        if (__first == __last)
-            __throw_regex_error<regex_constants::error_brack>();
-        if (__get_grammar(__flags_) != ECMAScript && *__first == ']')
-        {
-            __ml->__add_char(']');
-            ++__first;
-        }
-        __first = __parse_follow_list(__first, __last, __ml);
-        if (__first == __last)
-            __throw_regex_error<regex_constants::error_brack>();
-        if (*__first == '-')
-        {
-            __ml->__add_char('-');
-            ++__first;
-        }
-        if (__first == __last || *__first != ']')
-            __throw_regex_error<regex_constants::error_brack>();
-        ++__first;
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_follow_list(_ForwardIterator __first,
-                                    _ForwardIterator __last,
-                                    __bracket_expression<_CharT, _Traits>* __ml)
-{
-    if (__first != __last)
-    {
-        while (true)
-        {
-            _ForwardIterator __temp = __parse_expression_term(__first, __last,
-                                                              __ml);
-            if (__temp == __first)
-                break;
-            __first = __temp;
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
-                                    _ForwardIterator __last,
-                                    __bracket_expression<_CharT, _Traits>* __ml)
-{
-    if (__first != __last && *__first != ']')
-    {
-        _ForwardIterator __temp = _VSTD::next(__first);
-        basic_string<_CharT> __start_range;
-        if (__temp != __last && *__first == '[')
-        {
-            if (*__temp == '=')
-                return __parse_equivalence_class(++__temp, __last, __ml);
-            else if (*__temp == ':')
-                return __parse_character_class(++__temp, __last, __ml);
-            else if (*__temp == '.')
-                __first = __parse_collating_symbol(++__temp, __last, __start_range);
-        }
-        unsigned __grammar = __get_grammar(__flags_);
-        if (__start_range.empty())
-        {
-            if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\')
-            {
-                if (__grammar == ECMAScript)
-                    __first = __parse_class_escape(++__first, __last, __start_range, __ml);
-                else
-                    __first = __parse_awk_escape(++__first, __last, &__start_range);
-            }
-            else
-            {
-                __start_range = *__first;
-                ++__first;
-            }
-        }
-        if (__first != __last && *__first != ']')
-        {
-            __temp = _VSTD::next(__first);
-            if (__temp != __last && *__first == '-' && *__temp != ']')
-            {
-                // parse a range
-                basic_string<_CharT> __end_range;
-                __first = __temp;
-                ++__temp;
-                if (__temp != __last && *__first == '[' && *__temp == '.')
-                    __first = __parse_collating_symbol(++__temp, __last, __end_range);
-                else
-                {
-                    if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\')
-                    {
-                        if (__grammar == ECMAScript)
-                            __first = __parse_class_escape(++__first, __last,
-                                                           __end_range, __ml);
-                        else
-                            __first = __parse_awk_escape(++__first, __last,
-                                                         &__end_range);
-                    }
-                    else
-                    {
-                        __end_range = *__first;
-                        ++__first;
-                    }
-                }
-                __ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range));
-            }
-            else if (!__start_range.empty())
-            {
-                if (__start_range.size() == 1)
-                    __ml->__add_char(__start_range[0]);
-                else
-                    __ml->__add_digraph(__start_range[0], __start_range[1]);
-            }
-        }
-        else if (!__start_range.empty())
-        {
-            if (__start_range.size() == 1)
-                __ml->__add_char(__start_range[0]);
-            else
-                __ml->__add_digraph(__start_range[0], __start_range[1]);
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_class_escape(_ForwardIterator __first,
-                          _ForwardIterator __last,
-                          basic_string<_CharT>& __str,
-                          __bracket_expression<_CharT, _Traits>* __ml)
-{
-    if (__first == __last)
-        __throw_regex_error<regex_constants::error_escape>();
-    switch (*__first)
-    {
-    case 0:
-        __str = *__first;
-        return ++__first;
-    case 'b':
-        __str = _CharT(8);
-        return ++__first;
-    case 'd':
-        __ml->__add_class(ctype_base::digit);
-        return ++__first;
-    case 'D':
-        __ml->__add_neg_class(ctype_base::digit);
-        return ++__first;
-    case 's':
-        __ml->__add_class(ctype_base::space);
-        return ++__first;
-    case 'S':
-        __ml->__add_neg_class(ctype_base::space);
-        return ++__first;
-    case 'w':
-        __ml->__add_class(ctype_base::alnum);
-        __ml->__add_char('_');
-        return ++__first;
-    case 'W':
-        __ml->__add_neg_class(ctype_base::alnum);
-        __ml->__add_neg_char('_');
-        return ++__first;
-    }
-    __first = __parse_character_escape(__first, __last, &__str);
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_awk_escape(_ForwardIterator __first,
-                          _ForwardIterator __last,
-                          basic_string<_CharT>* __str)
-{
-    if (__first == __last)
-        __throw_regex_error<regex_constants::error_escape>();
-    switch (*__first)
-    {
-    case '\\':
-    case '"':
-    case '/':
-        if (__str)
-            *__str = *__first;
-        else
-            __push_char(*__first);
-        return ++__first;
-    case 'a':
-        if (__str)
-            *__str = _CharT(7);
-        else
-            __push_char(_CharT(7));
-        return ++__first;
-    case 'b':
-        if (__str)
-            *__str = _CharT(8);
-        else
-            __push_char(_CharT(8));
-        return ++__first;
-    case 'f':
-        if (__str)
-            *__str = _CharT(0xC);
-        else
-            __push_char(_CharT(0xC));
-        return ++__first;
-    case 'n':
-        if (__str)
-            *__str = _CharT(0xA);
-        else
-            __push_char(_CharT(0xA));
-        return ++__first;
-    case 'r':
-        if (__str)
-            *__str = _CharT(0xD);
-        else
-            __push_char(_CharT(0xD));
-        return ++__first;
-    case 't':
-        if (__str)
-            *__str = _CharT(0x9);
-        else
-            __push_char(_CharT(0x9));
-        return ++__first;
-    case 'v':
-        if (__str)
-            *__str = _CharT(0xB);
-        else
-            __push_char(_CharT(0xB));
-        return ++__first;
-    }
-    if ('0' <= *__first && *__first <= '7')
-    {
-        unsigned __val = *__first - '0';
-        if (++__first != __last && ('0' <= *__first && *__first <= '7'))
-        {
-            __val = 8 * __val + *__first - '0';
-            if (++__first != __last && ('0' <= *__first && *__first <= '7'))
-                __val = 8 * __val + *__first++ - '0';
-        }
-        if (__str)
-            *__str = _CharT(__val);
-        else
-            __push_char(_CharT(__val));
-    }
-    else
-        __throw_regex_error<regex_constants::error_escape>();
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first,
-                                    _ForwardIterator __last,
-                                    __bracket_expression<_CharT, _Traits>* __ml)
-{
-    // Found [=
-    //   This means =] must exist
-    value_type __equal_close[2] = {'=', ']'};
-    _ForwardIterator __temp = _VSTD::search(__first, __last, __equal_close,
-                                                            __equal_close+2);
-    if (__temp == __last)
-        __throw_regex_error<regex_constants::error_brack>();
-    // [__first, __temp) contains all text in [= ... =]
-    string_type __collate_name =
-        __traits_.lookup_collatename(__first, __temp);
-    if (__collate_name.empty())
-        __throw_regex_error<regex_constants::error_collate>();
-    string_type __equiv_name =
-        __traits_.transform_primary(__collate_name.begin(),
-                                    __collate_name.end());
-    if (!__equiv_name.empty())
-        __ml->__add_equivalence(__equiv_name);
-    else
-    {
-        switch (__collate_name.size())
-        {
-        case 1:
-            __ml->__add_char(__collate_name[0]);
-            break;
-        case 2:
-            __ml->__add_digraph(__collate_name[0], __collate_name[1]);
-            break;
-        default:
-            __throw_regex_error<regex_constants::error_collate>();
-        }
-    }
-    __first = _VSTD::next(__temp, 2);
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
-                                    _ForwardIterator __last,
-                                    __bracket_expression<_CharT, _Traits>* __ml)
-{
-    // Found [:
-    //   This means :] must exist
-    value_type __colon_close[2] = {':', ']'};
-    _ForwardIterator __temp = _VSTD::search(__first, __last, __colon_close,
-                                                            __colon_close+2);
-    if (__temp == __last)
-        __throw_regex_error<regex_constants::error_brack>();
-    // [__first, __temp) contains all text in [: ... :]
-    typedef typename _Traits::char_class_type char_class_type;
-    char_class_type __class_type =
-        __traits_.lookup_classname(__first, __temp, __flags_ & icase);
-    if (__class_type == 0)
-        __throw_regex_error<regex_constants::error_ctype>();
-    __ml->__add_class(__class_type);
-    __first = _VSTD::next(__temp, 2);
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
-                                                _ForwardIterator __last,
-                                                basic_string<_CharT>& __col_sym)
-{
-    // Found [.
-    //   This means .] must exist
-    value_type __dot_close[2] = {'.', ']'};
-    _ForwardIterator __temp = _VSTD::search(__first, __last, __dot_close,
-                                                            __dot_close+2);
-    if (__temp == __last)
-        __throw_regex_error<regex_constants::error_brack>();
-    // [__first, __temp) contains all text in [. ... .]
-    __col_sym = __traits_.lookup_collatename(__first, __temp);
-    switch (__col_sym.size())
-    {
-    case 1:
-    case 2:
-        break;
+      }
+      break;
     default:
-        __throw_regex_error<regex_constants::error_collate>();
+      __push_char(*__first);
+      ++__first;
+      break;
     }
-    __first = _VSTD::next(__temp, 2);
-    return __first;
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first,
-                                                _ForwardIterator __last,
-                                                int& __c)
-{
-    if (__first != __last )
-    {
-        int __val = __traits_.value(*__first, 10);
-        if ( __val != -1 )
-        {
-            __c = __val;
-            for (++__first;
-                 __first != __last && ( __val = __traits_.value(*__first, 10)) != -1;
-                 ++__first)
-            {
-                if (__c >= numeric_limits<int>::max() / 10)
-                    __throw_regex_error<regex_constants::error_badbrace>();
-                __c *= 10;
-                __c += __val;
-            }
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_ecma_exp(_ForwardIterator __first,
-                                               _ForwardIterator __last)
-{
-    __owns_one_state<_CharT>* __sa = __end_;
-    _ForwardIterator __temp = __parse_alternative(__first, __last);
-    if (__temp == __first)
-        __push_empty();
-    __first = __temp;
-    while (__first != __last && *__first == '|')
-    {
-        __owns_one_state<_CharT>* __sb = __end_;
-        __temp = __parse_alternative(++__first, __last);
-        if (__temp == __first)
-            __push_empty();
-        __push_alternation(__sa, __sb);
-        __first = __temp;
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_alternative(_ForwardIterator __first,
-                                                  _ForwardIterator __last)
-{
-    while (true)
-    {
-        _ForwardIterator __temp = __parse_term(__first, __last);
-        if (__temp == __first)
-            break;
-        __first = __temp;
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_term(_ForwardIterator __first,
-                                           _ForwardIterator __last)
-{
-    _ForwardIterator __temp = __parse_assertion(__first, __last);
-    if (__temp == __first)
-    {
-        __owns_one_state<_CharT>* __e = __end_;
-        unsigned __mexp_begin = __marked_count_;
-        __temp = __parse_atom(__first, __last);
-        if (__temp != __first)
-            __first = __parse_ERE_dupl_symbol(__temp, __last, __e,
-                                              __mexp_begin+1, __marked_count_+1);
-    }
-    else
-        __first = __temp;
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
-                                                _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        switch (*__first)
-        {
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    _ForwardIterator __temp = std::next(__first);
+    if (__temp != __last) {
+      if (*__first == '\\') {
+        switch (*__temp) {
         case '^':
-            __push_l_anchor();
-            ++__first;
-            break;
-        case '$':
-            __push_r_anchor();
-            ++__first;
-            break;
-        case '\\':
-            {
-                _ForwardIterator __temp = _VSTD::next(__first);
-                if (__temp != __last)
-                {
-                    if (*__temp == 'b')
-                    {
-                        __push_word_boundary(false);
-                        __first = ++__temp;
-                    }
-                    else if (*__temp == 'B')
-                    {
-                        __push_word_boundary(true);
-                        __first = ++__temp;
-                    }
-                }
-            }
-            break;
-        case '(':
-            {
-                _ForwardIterator __temp = _VSTD::next(__first);
-                if (__temp != __last && *__temp == '?')
-                {
-                    if (++__temp != __last)
-                    {
-                        switch (*__temp)
-                        {
-                        case '=':
-                            {
-                                basic_regex __exp;
-                                __exp.__flags_ = __flags_;
-                                __temp = __exp.__parse(++__temp, __last);
-                                unsigned __mexp = __exp.__marked_count_;
-                                __push_lookahead(_VSTD::move(__exp), false, __marked_count_);
-                                __marked_count_ += __mexp;
-                                if (__temp == __last || *__temp != ')')
-                                    __throw_regex_error<regex_constants::error_paren>();
-                                __first = ++__temp;
-                            }
-                            break;
-                        case '!':
-                            {
-                                basic_regex __exp;
-                                __exp.__flags_ = __flags_;
-                                __temp = __exp.__parse(++__temp, __last);
-                                unsigned __mexp = __exp.__marked_count_;
-                                __push_lookahead(_VSTD::move(__exp), true, __marked_count_);
-                                __marked_count_ += __mexp;
-                                if (__temp == __last || *__temp != ')')
-                                    __throw_regex_error<regex_constants::error_paren>();
-                                __first = ++__temp;
-                            }
-                            break;
-                        }
-                    }
-                }
-            }
-            break;
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first,
-                                           _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        switch (*__first)
-        {
         case '.':
-            __push_match_any_but_newline();
-            ++__first;
-            break;
-        case '\\':
-            __first = __parse_atom_escape(__first, __last);
-            break;
+        case '*':
         case '[':
-            __first = __parse_bracket_expression(__first, __last);
-            break;
-        case '(':
-            {
-                ++__first;
-                if (__first == __last)
-                    __throw_regex_error<regex_constants::error_paren>();
-                _ForwardIterator __temp = _VSTD::next(__first);
-                if (__temp != __last && *__first == '?' && *__temp == ':')
-                {
-                    ++__open_count_;
-                    __first = __parse_ecma_exp(++__temp, __last);
-                    if (__first == __last || *__first != ')')
-                        __throw_regex_error<regex_constants::error_paren>();
-                    --__open_count_;
-                    ++__first;
-                }
-                else
-                {
-                    __push_begin_marked_subexpression();
-                    unsigned __temp_count = __marked_count_;
-                    ++__open_count_;
-                    __first = __parse_ecma_exp(__first, __last);
-                    if (__first == __last || *__first != ')')
-                        __throw_regex_error<regex_constants::error_paren>();
-                    __push_end_marked_subexpression(__temp_count);
-                    --__open_count_;
-                    ++__first;
-                }
-            }
-            break;
-        case '*':
-        case '+':
-        case '?':
-        case '{':
-            __throw_regex_error<regex_constants::error_badrepeat>();
-            break;
-        default:
-            __first = __parse_pattern_character(__first, __last);
-            break;
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first,
-                                                  _ForwardIterator __last)
-{
-    if (__first != __last && *__first == '\\')
-    {
-        _ForwardIterator __t1 = _VSTD::next(__first);
-        if (__t1 == __last)
-            __throw_regex_error<regex_constants::error_escape>();
-
-        _ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
-        if (__t2 != __t1)
-            __first = __t2;
-        else
-        {
-            __t2 = __parse_character_class_escape(__t1, __last);
-            if (__t2 != __t1)
-                __first = __t2;
-            else
-            {
-                __t2 = __parse_character_escape(__t1, __last);
-                if (__t2 != __t1)
-                    __first = __t2;
-            }
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first,
-                                                     _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        if (*__first == '0')
-        {
-            __push_char(_CharT());
-            ++__first;
-        }
-        else if ('1' <= *__first && *__first <= '9')
-        {
-            unsigned __v = *__first - '0';
-            for (++__first;
-                    __first != __last && '0' <= *__first && *__first <= '9'; ++__first)
-                {
-                if (__v >= numeric_limits<unsigned>::max() / 10)
-                    __throw_regex_error<regex_constants::error_backref>();
-                __v = 10 * __v + *__first - '0';
-                }
-            if (__v == 0 || __v > mark_count())
-                __throw_regex_error<regex_constants::error_backref>();
-            __push_back_ref(__v);
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_character_class_escape(_ForwardIterator __first,
-                                                             _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        __bracket_expression<_CharT, _Traits>* __ml;
-        switch (*__first)
-        {
-        case 'd':
-            __ml = __start_matching_list(false);
-            __ml->__add_class(ctype_base::digit);
-            ++__first;
-            break;
-        case 'D':
-            __ml = __start_matching_list(true);
-            __ml->__add_class(ctype_base::digit);
-            ++__first;
-            break;
-        case 's':
-            __ml = __start_matching_list(false);
-            __ml->__add_class(ctype_base::space);
-            ++__first;
-            break;
-        case 'S':
-            __ml = __start_matching_list(true);
-            __ml->__add_class(ctype_base::space);
-            ++__first;
-            break;
-        case 'w':
-            __ml = __start_matching_list(false);
-            __ml->__add_class(ctype_base::alnum);
-            __ml->__add_char('_');
-            ++__first;
-            break;
-        case 'W':
-            __ml = __start_matching_list(true);
-            __ml->__add_class(ctype_base::alnum);
-            __ml->__add_char('_');
-            ++__first;
-            break;
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
-                                                    _ForwardIterator __last,
-                                                    basic_string<_CharT>* __str)
-{
-    if (__first != __last)
-    {
-        _ForwardIterator __t;
-        unsigned __sum = 0;
-        int __hd;
-        switch (*__first)
-        {
-        case 'f':
-            if (__str)
-                *__str = _CharT(0xC);
-            else
-                __push_char(_CharT(0xC));
-            ++__first;
-            break;
-        case 'n':
-            if (__str)
-                *__str = _CharT(0xA);
-            else
-                __push_char(_CharT(0xA));
-            ++__first;
-            break;
-        case 'r':
-            if (__str)
-                *__str = _CharT(0xD);
-            else
-                __push_char(_CharT(0xD));
-            ++__first;
-            break;
-        case 't':
-            if (__str)
-                *__str = _CharT(0x9);
-            else
-                __push_char(_CharT(0x9));
-            ++__first;
-            break;
-        case 'v':
-            if (__str)
-                *__str = _CharT(0xB);
-            else
-                __push_char(_CharT(0xB));
-            ++__first;
-            break;
-        case 'c':
-            if ((__t = _VSTD::next(__first)) != __last)
-            {
-                if (('A' <= *__t && *__t <= 'Z') ||
-                    ('a' <= *__t && *__t <= 'z'))
-                {
-                    if (__str)
-                        *__str = _CharT(*__t % 32);
-                    else
-                        __push_char(_CharT(*__t % 32));
-                    __first = ++__t;
-                }
-                else
-                    __throw_regex_error<regex_constants::error_escape>();
-            }
-            else
-                __throw_regex_error<regex_constants::error_escape>();
-            break;
-        case 'u':
-            ++__first;
-            if (__first == __last)
-                __throw_regex_error<regex_constants::error_escape>();
-            __hd = __traits_.value(*__first, 16);
-            if (__hd == -1)
-                __throw_regex_error<regex_constants::error_escape>();
-            __sum = 16 * __sum + static_cast<unsigned>(__hd);
-            ++__first;
-            if (__first == __last)
-                __throw_regex_error<regex_constants::error_escape>();
-            __hd = __traits_.value(*__first, 16);
-            if (__hd == -1)
-                __throw_regex_error<regex_constants::error_escape>();
-            __sum = 16 * __sum + static_cast<unsigned>(__hd);
-            // fallthrough
-        case 'x':
-            ++__first;
-            if (__first == __last)
-                __throw_regex_error<regex_constants::error_escape>();
-            __hd = __traits_.value(*__first, 16);
-            if (__hd == -1)
-                __throw_regex_error<regex_constants::error_escape>();
-            __sum = 16 * __sum + static_cast<unsigned>(__hd);
-            ++__first;
-            if (__first == __last)
-                __throw_regex_error<regex_constants::error_escape>();
-            __hd = __traits_.value(*__first, 16);
-            if (__hd == -1)
-                __throw_regex_error<regex_constants::error_escape>();
-            __sum = 16 * __sum + static_cast<unsigned>(__hd);
-            if (__str)
-                *__str = _CharT(__sum);
-            else
-                __push_char(_CharT(__sum));
-            ++__first;
-            break;
-        case '0':
-            if (__str)
-                *__str = _CharT(0);
-            else
-                __push_char(_CharT(0));
-            ++__first;
-            break;
-        default:
-            if (*__first != '_' && !__traits_.isctype(*__first, ctype_base::alnum))
-            {
-                if (__str)
-                    *__str = *__first;
-                else
-                    __push_char(*__first);
-                ++__first;
-            }
-            else
-                __throw_regex_error<regex_constants::error_escape>();
-            break;
-        }
-    }
-    return __first;
-}
-
-template <class _CharT, class _Traits>
-template <class _ForwardIterator>
-_ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_pattern_character(_ForwardIterator __first,
-                                                        _ForwardIterator __last)
-{
-    if (__first != __last)
-    {
-        switch (*__first)
-        {
-        case '^':
         case '$':
         case '\\':
+          __push_char(*__temp);
+          __first = ++__temp;
+          break;
+        }
+      }
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator
+basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    _ForwardIterator __temp = std::next(__first);
+    if (__temp != __last) {
+      if (*__first == '\\') {
+        switch (*__temp) {
+        case '^':
         case '.':
         case '*':
-        case '+':
-        case '?':
+        case '[':
+        case '$':
+        case '\\':
         case '(':
         case ')':
-        case '[':
-        case ']':
+        case '|':
+        case '+':
+        case '?':
         case '{':
         case '}':
-        case '|':
-            break;
+          __push_char(*__temp);
+          __first = ++__temp;
+          break;
         default:
-            __push_char(*__first);
-            ++__first;
-            break;
+          if (__get_grammar(__flags_) == awk)
+            __first = __parse_awk_escape(++__first, __last);
+          else if (__test_back_ref(*__temp))
+            __first = ++__temp;
+          break;
         }
+      }
     }
-    return __first;
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(
+    _ForwardIterator __first,
+    _ForwardIterator __last,
+    __owns_one_state<_CharT>* __s,
+    unsigned __mexp_begin,
+    unsigned __mexp_end) {
+  if (__first != __last) {
+    if (*__first == '*') {
+      __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
+      ++__first;
+    } else {
+      _ForwardIterator __temp = __parse_Back_open_brace(__first, __last);
+      if (__temp != __first) {
+        int __min = 0;
+        __first   = __temp;
+        __temp    = __parse_DUP_COUNT(__first, __last, __min);
+        if (__temp == __first)
+          __throw_regex_error<regex_constants::error_badbrace>();
+        __first = __temp;
+        if (__first == __last)
+          __throw_regex_error<regex_constants::error_brace>();
+        if (*__first != ',') {
+          __temp = __parse_Back_close_brace(__first, __last);
+          if (__temp == __first)
+            __throw_regex_error<regex_constants::error_brace>();
+          __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, true);
+          __first = __temp;
+        } else {
+          ++__first; // consume ','
+          int __max = -1;
+          __first   = __parse_DUP_COUNT(__first, __last, __max);
+          __temp    = __parse_Back_close_brace(__first, __last);
+          if (__temp == __first)
+            __throw_regex_error<regex_constants::error_brace>();
+          if (__max == -1)
+            __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
+          else {
+            if (__max < __min)
+              __throw_regex_error<regex_constants::error_badbrace>();
+            __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, true);
+          }
+          __first = __temp;
+        }
+      }
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(
+    _ForwardIterator __first,
+    _ForwardIterator __last,
+    __owns_one_state<_CharT>* __s,
+    unsigned __mexp_begin,
+    unsigned __mexp_end) {
+  if (__first != __last) {
+    unsigned __grammar = __get_grammar(__flags_);
+    switch (*__first) {
+    case '*':
+      ++__first;
+      if (__grammar == ECMAScript && __first != __last && *__first == '?') {
+        ++__first;
+        __push_nongreedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
+      } else
+        __push_greedy_inf_repeat(0, __s, __mexp_begin, __mexp_end);
+      break;
+    case '+':
+      ++__first;
+      if (__grammar == ECMAScript && __first != __last && *__first == '?') {
+        ++__first;
+        __push_nongreedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
+      } else
+        __push_greedy_inf_repeat(1, __s, __mexp_begin, __mexp_end);
+      break;
+    case '?':
+      ++__first;
+      if (__grammar == ECMAScript && __first != __last && *__first == '?') {
+        ++__first;
+        __push_loop(0, 1, __s, __mexp_begin, __mexp_end, false);
+      } else
+        __push_loop(0, 1, __s, __mexp_begin, __mexp_end);
+      break;
+    case '{': {
+      int __min;
+      _ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min);
+      if (__temp == __first)
+        __throw_regex_error<regex_constants::error_badbrace>();
+      __first = __temp;
+      if (__first == __last)
+        __throw_regex_error<regex_constants::error_brace>();
+      switch (*__first) {
+      case '}':
+        ++__first;
+        if (__grammar == ECMAScript && __first != __last && *__first == '?') {
+          ++__first;
+          __push_loop(__min, __min, __s, __mexp_begin, __mexp_end, false);
+        } else
+          __push_loop(__min, __min, __s, __mexp_begin, __mexp_end);
+        break;
+      case ',':
+        ++__first;
+        if (__first == __last)
+          __throw_regex_error<regex_constants::error_badbrace>();
+        if (*__first == '}') {
+          ++__first;
+          if (__grammar == ECMAScript && __first != __last && *__first == '?') {
+            ++__first;
+            __push_nongreedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
+          } else
+            __push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
+        } else {
+          int __max = -1;
+          __temp    = __parse_DUP_COUNT(__first, __last, __max);
+          if (__temp == __first)
+            __throw_regex_error<regex_constants::error_brace>();
+          __first = __temp;
+          if (__first == __last || *__first != '}')
+            __throw_regex_error<regex_constants::error_brace>();
+          ++__first;
+          if (__max < __min)
+            __throw_regex_error<regex_constants::error_badbrace>();
+          if (__grammar == ECMAScript && __first != __last && *__first == '?') {
+            ++__first;
+            __push_loop(__min, __max, __s, __mexp_begin, __mexp_end, false);
+          } else
+            __push_loop(__min, __max, __s, __mexp_begin, __mexp_end);
+        }
+        break;
+      default:
+        __throw_regex_error<regex_constants::error_badbrace>();
+      }
+    } break;
+    }
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
-                                           _ForwardIterator __last)
-{
-    __owns_one_state<_CharT>* __sa = __end_;
-    _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
-    if (__t1 != __first)
-        __parse_basic_reg_exp(__first, __t1);
-    else
-        __push_empty();
-    __first = __t1;
-    if (__first != __last)
-        ++__first;
-    while (__first != __last)
-    {
-        __t1 = _VSTD::find(__first, __last, _CharT('\n'));
-        __owns_one_state<_CharT>* __sb = __end_;
-        if (__t1 != __first)
-            __parse_basic_reg_exp(__first, __t1);
-        else
-            __push_empty();
-        __push_alternation(__sa, __sb);
-        __first = __t1;
-        if (__first != __last)
-            ++__first;
+basic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last && *__first == '[') {
+    ++__first;
+    if (__first == __last)
+      __throw_regex_error<regex_constants::error_brack>();
+    bool __negate = false;
+    if (*__first == '^') {
+      ++__first;
+      __negate = true;
     }
-    return __first;
+    __bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate);
+    // __ml owned by *this
+    if (__first == __last)
+      __throw_regex_error<regex_constants::error_brack>();
+    if (__get_grammar(__flags_) != ECMAScript && *__first == ']') {
+      __ml->__add_char(']');
+      ++__first;
+    }
+    __first = __parse_follow_list(__first, __last, __ml);
+    if (__first == __last)
+      __throw_regex_error<regex_constants::error_brack>();
+    if (*__first == '-') {
+      __ml->__add_char('-');
+      ++__first;
+    }
+    if (__first == __last || *__first != ']')
+      __throw_regex_error<regex_constants::error_brack>();
+    ++__first;
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_follow_list(
+    _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml) {
+  if (__first != __last) {
+    while (true) {
+      _ForwardIterator __temp = __parse_expression_term(__first, __last, __ml);
+      if (__temp == __first)
+        break;
+      __first = __temp;
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_expression_term(
+    _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml) {
+  if (__first != __last && *__first != ']') {
+    _ForwardIterator __temp = std::next(__first);
+    basic_string<_CharT> __start_range;
+    if (__temp != __last && *__first == '[') {
+      if (*__temp == '=')
+        return __parse_equivalence_class(++__temp, __last, __ml);
+      else if (*__temp == ':')
+        return __parse_character_class(++__temp, __last, __ml);
+      else if (*__temp == '.')
+        __first = __parse_collating_symbol(++__temp, __last, __start_range);
+    }
+    unsigned __grammar = __get_grammar(__flags_);
+    if (__start_range.empty()) {
+      if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\') {
+        if (__grammar == ECMAScript)
+          __first = __parse_class_escape(++__first, __last, __start_range, __ml);
+        else
+          __first = __parse_awk_escape(++__first, __last, &__start_range);
+      } else {
+        __start_range = *__first;
+        ++__first;
+      }
+    }
+    if (__first != __last && *__first != ']') {
+      __temp = std::next(__first);
+      if (__temp != __last && *__first == '-' && *__temp != ']') {
+        // parse a range
+        basic_string<_CharT> __end_range;
+        __first = __temp;
+        ++__temp;
+        if (__temp != __last && *__first == '[' && *__temp == '.')
+          __first = __parse_collating_symbol(++__temp, __last, __end_range);
+        else {
+          if ((__grammar == ECMAScript || __grammar == awk) && *__first == '\\') {
+            if (__grammar == ECMAScript)
+              __first = __parse_class_escape(++__first, __last, __end_range, __ml);
+            else
+              __first = __parse_awk_escape(++__first, __last, &__end_range);
+          } else {
+            __end_range = *__first;
+            ++__first;
+          }
+        }
+        __ml->__add_range(std::move(__start_range), std::move(__end_range));
+      } else if (!__start_range.empty()) {
+        if (__start_range.size() == 1)
+          __ml->__add_char(__start_range[0]);
+        else
+          __ml->__add_digraph(__start_range[0], __start_range[1]);
+      }
+    } else if (!__start_range.empty()) {
+      if (__start_range.size() == 1)
+        __ml->__add_char(__start_range[0]);
+      else
+        __ml->__add_digraph(__start_range[0], __start_range[1]);
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_class_escape(
+    _ForwardIterator __first,
+    _ForwardIterator __last,
+    basic_string<_CharT>& __str,
+    __bracket_expression<_CharT, _Traits>* __ml) {
+  if (__first == __last)
+    __throw_regex_error<regex_constants::error_escape>();
+  switch (*__first) {
+  case 0:
+    __str = *__first;
+    return ++__first;
+  case 'b':
+    __str = _CharT(8);
+    return ++__first;
+  case 'd':
+    __ml->__add_class(ctype_base::digit);
+    return ++__first;
+  case 'D':
+    __ml->__add_neg_class(ctype_base::digit);
+    return ++__first;
+  case 's':
+    __ml->__add_class(ctype_base::space);
+    return ++__first;
+  case 'S':
+    __ml->__add_neg_class(ctype_base::space);
+    return ++__first;
+  case 'w':
+    __ml->__add_class(ctype_base::alnum);
+    __ml->__add_char('_');
+    return ++__first;
+  case 'W':
+    __ml->__add_neg_class(ctype_base::alnum);
+    __ml->__add_neg_char('_');
+    return ++__first;
+  }
+  __first = __parse_character_escape(__first, __last, &__str);
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_awk_escape(
+    _ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>* __str) {
+  if (__first == __last)
+    __throw_regex_error<regex_constants::error_escape>();
+  switch (*__first) {
+  case '\\':
+  case '"':
+  case '/':
+    if (__str)
+      *__str = *__first;
+    else
+      __push_char(*__first);
+    return ++__first;
+  case 'a':
+    if (__str)
+      *__str = _CharT(7);
+    else
+      __push_char(_CharT(7));
+    return ++__first;
+  case 'b':
+    if (__str)
+      *__str = _CharT(8);
+    else
+      __push_char(_CharT(8));
+    return ++__first;
+  case 'f':
+    if (__str)
+      *__str = _CharT(0xC);
+    else
+      __push_char(_CharT(0xC));
+    return ++__first;
+  case 'n':
+    if (__str)
+      *__str = _CharT(0xA);
+    else
+      __push_char(_CharT(0xA));
+    return ++__first;
+  case 'r':
+    if (__str)
+      *__str = _CharT(0xD);
+    else
+      __push_char(_CharT(0xD));
+    return ++__first;
+  case 't':
+    if (__str)
+      *__str = _CharT(0x9);
+    else
+      __push_char(_CharT(0x9));
+    return ++__first;
+  case 'v':
+    if (__str)
+      *__str = _CharT(0xB);
+    else
+      __push_char(_CharT(0xB));
+    return ++__first;
+  }
+  if ('0' <= *__first && *__first <= '7') {
+    unsigned __val = *__first - '0';
+    if (++__first != __last && ('0' <= *__first && *__first <= '7')) {
+      __val = 8 * __val + *__first - '0';
+      if (++__first != __last && ('0' <= *__first && *__first <= '7'))
+        __val = 8 * __val + *__first++ - '0';
+    }
+    if (__str)
+      *__str = _CharT(__val);
+    else
+      __push_char(_CharT(__val));
+  } else
+    __throw_regex_error<regex_constants::error_escape>();
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_equivalence_class(
+    _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml) {
+  // Found [=
+  //   This means =] must exist
+  value_type __equal_close[2] = {'=', ']'};
+  _ForwardIterator __temp     = std::search(__first, __last, __equal_close, __equal_close + 2);
+  if (__temp == __last)
+    __throw_regex_error<regex_constants::error_brack>();
+  // [__first, __temp) contains all text in [= ... =]
+  string_type __collate_name = __traits_.lookup_collatename(__first, __temp);
+  if (__collate_name.empty())
+    __throw_regex_error<regex_constants::error_collate>();
+  string_type __equiv_name = __traits_.transform_primary(__collate_name.begin(), __collate_name.end());
+  if (!__equiv_name.empty())
+    __ml->__add_equivalence(__equiv_name);
+  else {
+    switch (__collate_name.size()) {
+    case 1:
+      __ml->__add_char(__collate_name[0]);
+      break;
+    case 2:
+      __ml->__add_digraph(__collate_name[0], __collate_name[1]);
+      break;
+    default:
+      __throw_regex_error<regex_constants::error_collate>();
+    }
+  }
+  __first = std::next(__temp, 2);
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_character_class(
+    _ForwardIterator __first, _ForwardIterator __last, __bracket_expression<_CharT, _Traits>* __ml) {
+  // Found [:
+  //   This means :] must exist
+  value_type __colon_close[2] = {':', ']'};
+  _ForwardIterator __temp     = std::search(__first, __last, __colon_close, __colon_close + 2);
+  if (__temp == __last)
+    __throw_regex_error<regex_constants::error_brack>();
+  // [__first, __temp) contains all text in [: ... :]
+  typedef typename _Traits::char_class_type char_class_type;
+  char_class_type __class_type = __traits_.lookup_classname(__first, __temp, __flags_ & icase);
+  if (__class_type == 0)
+    __throw_regex_error<regex_constants::error_ctype>();
+  __ml->__add_class(__class_type);
+  __first = std::next(__temp, 2);
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_collating_symbol(
+    _ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>& __col_sym) {
+  // Found [.
+  //   This means .] must exist
+  value_type __dot_close[2] = {'.', ']'};
+  _ForwardIterator __temp   = std::search(__first, __last, __dot_close, __dot_close + 2);
+  if (__temp == __last)
+    __throw_regex_error<regex_constants::error_brack>();
+  // [__first, __temp) contains all text in [. ... .]
+  __col_sym = __traits_.lookup_collatename(__first, __temp);
+  switch (__col_sym.size()) {
+  case 1:
+  case 2:
+    break;
+  default:
+    __throw_regex_error<regex_constants::error_collate>();
+  }
+  __first = std::next(__temp, 2);
+  return __first;
 }
 
 template <class _CharT, class _Traits>
 template <class _ForwardIterator>
 _ForwardIterator
-basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
-                                            _ForwardIterator __last)
-{
-    __owns_one_state<_CharT>* __sa = __end_;
-    _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
+basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first, _ForwardIterator __last, int& __c) {
+  if (__first != __last) {
+    int __val = __traits_.value(*__first, 10);
+    if (__val != -1) {
+      __c = __val;
+      for (++__first; __first != __last && (__val = __traits_.value(*__first, 10)) != -1; ++__first) {
+        if (__c >= numeric_limits<int>::max() / 10)
+          __throw_regex_error<regex_constants::error_badbrace>();
+        __c *= 10;
+        __c += __val;
+      }
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ecma_exp(_ForwardIterator __first, _ForwardIterator __last) {
+  __owns_one_state<_CharT>* __sa = __end_;
+  _ForwardIterator __temp        = __parse_alternative(__first, __last);
+  if (__temp == __first)
+    __push_empty();
+  __first = __temp;
+  while (__first != __last && *__first == '|') {
+    __owns_one_state<_CharT>* __sb = __end_;
+    __temp                         = __parse_alternative(++__first, __last);
+    if (__temp == __first)
+      __push_empty();
+    __push_alternation(__sa, __sb);
+    __first = __temp;
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_alternative(_ForwardIterator __first, _ForwardIterator __last) {
+  while (true) {
+    _ForwardIterator __temp = __parse_term(__first, __last);
+    if (__temp == __first)
+      break;
+    __first = __temp;
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_term(_ForwardIterator __first, _ForwardIterator __last) {
+  _ForwardIterator __temp = __parse_assertion(__first, __last);
+  if (__temp == __first) {
+    __owns_one_state<_CharT>* __e = __end_;
+    unsigned __mexp_begin         = __marked_count_;
+    __temp                        = __parse_atom(__first, __last);
+    if (__temp != __first)
+      __first = __parse_ERE_dupl_symbol(__temp, __last, __e, __mexp_begin + 1, __marked_count_ + 1);
+  } else
+    __first = __temp;
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    switch (*__first) {
+    case '^':
+      __push_l_anchor();
+      ++__first;
+      break;
+    case '$':
+      __push_r_anchor();
+      ++__first;
+      break;
+    case '\\': {
+      _ForwardIterator __temp = std::next(__first);
+      if (__temp != __last) {
+        if (*__temp == 'b') {
+          __push_word_boundary(false);
+          __first = ++__temp;
+        } else if (*__temp == 'B') {
+          __push_word_boundary(true);
+          __first = ++__temp;
+        }
+      }
+    } break;
+    case '(': {
+      _ForwardIterator __temp = std::next(__first);
+      if (__temp != __last && *__temp == '?') {
+        if (++__temp != __last) {
+          switch (*__temp) {
+          case '=': {
+            basic_regex __exp;
+            __exp.__flags_  = __flags_;
+            __temp          = __exp.__parse(++__temp, __last);
+            unsigned __mexp = __exp.__marked_count_;
+            __push_lookahead(std::move(__exp), false, __marked_count_);
+            __marked_count_ += __mexp;
+            if (__temp == __last || *__temp != ')')
+              __throw_regex_error<regex_constants::error_paren>();
+            __first = ++__temp;
+          } break;
+          case '!': {
+            basic_regex __exp;
+            __exp.__flags_  = __flags_;
+            __temp          = __exp.__parse(++__temp, __last);
+            unsigned __mexp = __exp.__marked_count_;
+            __push_lookahead(std::move(__exp), true, __marked_count_);
+            __marked_count_ += __mexp;
+            if (__temp == __last || *__temp != ')')
+              __throw_regex_error<regex_constants::error_paren>();
+            __first = ++__temp;
+          } break;
+          }
+        }
+      }
+    } break;
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    switch (*__first) {
+    case '.':
+      __push_match_any_but_newline();
+      ++__first;
+      break;
+    case '\\':
+      __first = __parse_atom_escape(__first, __last);
+      break;
+    case '[':
+      __first = __parse_bracket_expression(__first, __last);
+      break;
+    case '(': {
+      ++__first;
+      if (__first == __last)
+        __throw_regex_error<regex_constants::error_paren>();
+      _ForwardIterator __temp = std::next(__first);
+      if (__temp != __last && *__first == '?' && *__temp == ':') {
+        ++__open_count_;
+        __first = __parse_ecma_exp(++__temp, __last);
+        if (__first == __last || *__first != ')')
+          __throw_regex_error<regex_constants::error_paren>();
+        --__open_count_;
+        ++__first;
+      } else {
+        __push_begin_marked_subexpression();
+        unsigned __temp_count = __marked_count_;
+        ++__open_count_;
+        __first = __parse_ecma_exp(__first, __last);
+        if (__first == __last || *__first != ')')
+          __throw_regex_error<regex_constants::error_paren>();
+        __push_end_marked_subexpression(__temp_count);
+        --__open_count_;
+        ++__first;
+      }
+    } break;
+    case '*':
+    case '+':
+    case '?':
+    case '{':
+      __throw_regex_error<regex_constants::error_badrepeat>();
+      break;
+    default:
+      __first = __parse_pattern_character(__first, __last);
+      break;
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last && *__first == '\\') {
+    _ForwardIterator __t1 = std::next(__first);
+    if (__t1 == __last)
+      __throw_regex_error<regex_constants::error_escape>();
+
+    _ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
+    if (__t2 != __t1)
+      __first = __t2;
+    else {
+      __t2 = __parse_character_class_escape(__t1, __last);
+      if (__t2 != __t1)
+        __first = __t2;
+      else {
+        __t2 = __parse_character_escape(__t1, __last);
+        if (__t2 != __t1)
+          __first = __t2;
+      }
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator
+basic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    if (*__first == '0') {
+      __push_char(_CharT());
+      ++__first;
+    } else if ('1' <= *__first && *__first <= '9') {
+      unsigned __v = *__first - '0';
+      for (++__first; __first != __last && '0' <= *__first && *__first <= '9'; ++__first) {
+        if (__v >= numeric_limits<unsigned>::max() / 10)
+          __throw_regex_error<regex_constants::error_backref>();
+        __v = 10 * __v + *__first - '0';
+      }
+      if (__v == 0 || __v > mark_count())
+        __throw_regex_error<regex_constants::error_backref>();
+      __push_back_ref(__v);
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator
+basic_regex<_CharT, _Traits>::__parse_character_class_escape(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    __bracket_expression<_CharT, _Traits>* __ml;
+    switch (*__first) {
+    case 'd':
+      __ml = __start_matching_list(false);
+      __ml->__add_class(ctype_base::digit);
+      ++__first;
+      break;
+    case 'D':
+      __ml = __start_matching_list(true);
+      __ml->__add_class(ctype_base::digit);
+      ++__first;
+      break;
+    case 's':
+      __ml = __start_matching_list(false);
+      __ml->__add_class(ctype_base::space);
+      ++__first;
+      break;
+    case 'S':
+      __ml = __start_matching_list(true);
+      __ml->__add_class(ctype_base::space);
+      ++__first;
+      break;
+    case 'w':
+      __ml = __start_matching_list(false);
+      __ml->__add_class(ctype_base::alnum);
+      __ml->__add_char('_');
+      ++__first;
+      break;
+    case 'W':
+      __ml = __start_matching_list(true);
+      __ml->__add_class(ctype_base::alnum);
+      __ml->__add_char('_');
+      ++__first;
+      break;
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_character_escape(
+    _ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>* __str) {
+  if (__first != __last) {
+    _ForwardIterator __t;
+    unsigned __sum = 0;
+    int __hd;
+    switch (*__first) {
+    case 'f':
+      if (__str)
+        *__str = _CharT(0xC);
+      else
+        __push_char(_CharT(0xC));
+      ++__first;
+      break;
+    case 'n':
+      if (__str)
+        *__str = _CharT(0xA);
+      else
+        __push_char(_CharT(0xA));
+      ++__first;
+      break;
+    case 'r':
+      if (__str)
+        *__str = _CharT(0xD);
+      else
+        __push_char(_CharT(0xD));
+      ++__first;
+      break;
+    case 't':
+      if (__str)
+        *__str = _CharT(0x9);
+      else
+        __push_char(_CharT(0x9));
+      ++__first;
+      break;
+    case 'v':
+      if (__str)
+        *__str = _CharT(0xB);
+      else
+        __push_char(_CharT(0xB));
+      ++__first;
+      break;
+    case 'c':
+      if ((__t = std::next(__first)) != __last) {
+        if (('A' <= *__t && *__t <= 'Z') || ('a' <= *__t && *__t <= 'z')) {
+          if (__str)
+            *__str = _CharT(*__t % 32);
+          else
+            __push_char(_CharT(*__t % 32));
+          __first = ++__t;
+        } else
+          __throw_regex_error<regex_constants::error_escape>();
+      } else
+        __throw_regex_error<regex_constants::error_escape>();
+      break;
+    case 'u':
+      ++__first;
+      if (__first == __last)
+        __throw_regex_error<regex_constants::error_escape>();
+      __hd = __traits_.value(*__first, 16);
+      if (__hd == -1)
+        __throw_regex_error<regex_constants::error_escape>();
+      __sum = 16 * __sum + static_cast<unsigned>(__hd);
+      ++__first;
+      if (__first == __last)
+        __throw_regex_error<regex_constants::error_escape>();
+      __hd = __traits_.value(*__first, 16);
+      if (__hd == -1)
+        __throw_regex_error<regex_constants::error_escape>();
+      __sum = 16 * __sum + static_cast<unsigned>(__hd);
+      // fallthrough
+    case 'x':
+      ++__first;
+      if (__first == __last)
+        __throw_regex_error<regex_constants::error_escape>();
+      __hd = __traits_.value(*__first, 16);
+      if (__hd == -1)
+        __throw_regex_error<regex_constants::error_escape>();
+      __sum = 16 * __sum + static_cast<unsigned>(__hd);
+      ++__first;
+      if (__first == __last)
+        __throw_regex_error<regex_constants::error_escape>();
+      __hd = __traits_.value(*__first, 16);
+      if (__hd == -1)
+        __throw_regex_error<regex_constants::error_escape>();
+      __sum = 16 * __sum + static_cast<unsigned>(__hd);
+      if (__str)
+        *__str = _CharT(__sum);
+      else
+        __push_char(_CharT(__sum));
+      ++__first;
+      break;
+    case '0':
+      if (__str)
+        *__str = _CharT(0);
+      else
+        __push_char(_CharT(0));
+      ++__first;
+      break;
+    default:
+      if (*__first != '_' && !__traits_.isctype(*__first, ctype_base::alnum)) {
+        if (__str)
+          *__str = *__first;
+        else
+          __push_char(*__first);
+        ++__first;
+      } else
+        __throw_regex_error<regex_constants::error_escape>();
+      break;
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator
+basic_regex<_CharT, _Traits>::__parse_pattern_character(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__first != __last) {
+    switch (*__first) {
+    case '^':
+    case '$':
+    case '\\':
+    case '.':
+    case '*':
+    case '+':
+    case '?':
+    case '(':
+    case ')':
+    case '[':
+    case ']':
+    case '{':
+    case '}':
+    case '|':
+      break;
+    default:
+      __push_char(*__first);
+      ++__first;
+      break;
+    }
+  }
+  return __first;
+}
+
+template <class _CharT, class _Traits>
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first, _ForwardIterator __last) {
+  __owns_one_state<_CharT>* __sa = __end_;
+  _ForwardIterator __t1          = std::find(__first, __last, _CharT('\n'));
+  if (__t1 != __first)
+    __parse_basic_reg_exp(__first, __t1);
+  else
+    __push_empty();
+  __first = __t1;
+  if (__first != __last)
+    ++__first;
+  while (__first != __last) {
+    __t1                           = std::find(__first, __last, _CharT('\n'));
+    __owns_one_state<_CharT>* __sb = __end_;
     if (__t1 != __first)
-        __parse_extended_reg_exp(__first, __t1);
+      __parse_basic_reg_exp(__first, __t1);
     else
-        __push_empty();
+      __push_empty();
+    __push_alternation(__sa, __sb);
     __first = __t1;
     if (__first != __last)
-        ++__first;
-    while (__first != __last)
-    {
-        __t1 = _VSTD::find(__first, __last, _CharT('\n'));
-        __owns_one_state<_CharT>* __sb = __end_;
-        if (__t1 != __first)
-            __parse_extended_reg_exp(__first, __t1);
-        else
-            __push_empty();
-        __push_alternation(__sa, __sb);
-        __first = __t1;
-        if (__first != __last)
-            ++__first;
-    }
-    return __first;
+      ++__first;
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
-bool
-basic_regex<_CharT, _Traits>::__test_back_ref(_CharT __c)
-{
-    unsigned __val = __traits_.value(__c, 10);
-    if (__val >= 1 && __val <= 9)
-    {
-        if (__val > mark_count())
-            __throw_regex_error<regex_constants::error_backref>();
-        __push_back_ref(__val);
-        return true;
-    }
-
-    return false;
-}
-
-template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_loop(size_t __min, size_t __max,
-        __owns_one_state<_CharT>* __s, size_t __mexp_begin, size_t __mexp_end,
-        bool __greedy)
-{
-    unique_ptr<__empty_state<_CharT> > __e1(new __empty_state<_CharT>(__end_->first()));
-    __end_->first() = nullptr;
-    unique_ptr<__loop<_CharT> > __e2(new __loop<_CharT>(__loop_count_,
-                __s->first(), __e1.get(), __mexp_begin, __mexp_end, __greedy,
-                __min, __max));
-    __s->first() = nullptr;
-    __e1.release();
-    __end_->first() = new __repeat_one_loop<_CharT>(__e2.get());
-    __end_ = __e2->second();
-    __s->first() = __e2.release();
-    ++__loop_count_;
-}
-
-template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_char(value_type __c)
-{
-    if (flags() & icase)
-        __end_->first() = new __match_char_icase<_CharT, _Traits>
-                                              (__traits_, __c, __end_->first());
-    else if (flags() & collate)
-        __end_->first() = new __match_char_collate<_CharT, _Traits>
-                                              (__traits_, __c, __end_->first());
+template <class _ForwardIterator>
+_ForwardIterator basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first, _ForwardIterator __last) {
+  __owns_one_state<_CharT>* __sa = __end_;
+  _ForwardIterator __t1          = std::find(__first, __last, _CharT('\n'));
+  if (__t1 != __first)
+    __parse_extended_reg_exp(__first, __t1);
+  else
+    __push_empty();
+  __first = __t1;
+  if (__first != __last)
+    ++__first;
+  while (__first != __last) {
+    __t1                           = std::find(__first, __last, _CharT('\n'));
+    __owns_one_state<_CharT>* __sb = __end_;
+    if (__t1 != __first)
+      __parse_extended_reg_exp(__first, __t1);
     else
-        __end_->first() = new __match_char<_CharT>(__c, __end_->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+      __push_empty();
+    __push_alternation(__sa, __sb);
+    __first = __t1;
+    if (__first != __last)
+      ++__first;
+  }
+  return __first;
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_begin_marked_subexpression()
-{
-    if (!(__flags_ & nosubs))
-    {
-        __end_->first() =
-                new __begin_marked_subexpression<_CharT>(++__marked_count_,
-                                                         __end_->first());
-        __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
-    }
+bool basic_regex<_CharT, _Traits>::__test_back_ref(_CharT __c) {
+  unsigned __val = __traits_.value(__c, 10);
+  if (__val >= 1 && __val <= 9) {
+    if (__val > mark_count())
+      __throw_regex_error<regex_constants::error_backref>();
+    __push_back_ref(__val);
+    return true;
+  }
+
+  return false;
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub)
-{
-    if (!(__flags_ & nosubs))
-    {
-        __end_->first() =
-                new __end_marked_subexpression<_CharT>(__sub, __end_->first());
-        __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
-    }
+void basic_regex<_CharT, _Traits>::__push_loop(
+    size_t __min, size_t __max, __owns_one_state<_CharT>* __s, size_t __mexp_begin, size_t __mexp_end, bool __greedy) {
+  unique_ptr<__empty_state<_CharT> > __e1(new __empty_state<_CharT>(__end_->first()));
+  __end_->first() = nullptr;
+  unique_ptr<__loop<_CharT> > __e2(
+      new __loop<_CharT>(__loop_count_, __s->first(), __e1.get(), __mexp_begin, __mexp_end, __greedy, __min, __max));
+  __s->first() = nullptr;
+  __e1.release();
+  __end_->first() = new __repeat_one_loop<_CharT>(__e2.get());
+  __end_          = __e2->second();
+  __s->first()    = __e2.release();
+  ++__loop_count_;
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_l_anchor()
-{
-    __end_->first() = new __l_anchor_multiline<_CharT>(__use_multiline(), __end_->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+void basic_regex<_CharT, _Traits>::__push_char(value_type __c) {
+  if (flags() & icase)
+    __end_->first() = new __match_char_icase<_CharT, _Traits>(__traits_, __c, __end_->first());
+  else if (flags() & collate)
+    __end_->first() = new __match_char_collate<_CharT, _Traits>(__traits_, __c, __end_->first());
+  else
+    __end_->first() = new __match_char<_CharT>(__c, __end_->first());
+  __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_r_anchor()
-{
-    __end_->first() = new __r_anchor_multiline<_CharT>(__use_multiline(), __end_->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+void basic_regex<_CharT, _Traits>::__push_begin_marked_subexpression() {
+  if (!(__flags_ & nosubs)) {
+    __end_->first() = new __begin_marked_subexpression<_CharT>(++__marked_count_, __end_->first());
+    __end_          = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+  }
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_match_any()
-{
-    __end_->first() = new __match_any<_CharT>(__end_->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+void basic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub) {
+  if (!(__flags_ & nosubs)) {
+    __end_->first() = new __end_marked_subexpression<_CharT>(__sub, __end_->first());
+    __end_          = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+  }
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_match_any_but_newline()
-{
-    __end_->first() = new __match_any_but_newline<_CharT>(__end_->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+void basic_regex<_CharT, _Traits>::__push_l_anchor() {
+  __end_->first() = new __l_anchor_multiline<_CharT>(__use_multiline(), __end_->first());
+  __end_          = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_empty()
-{
-    __end_->first() = new __empty_state<_CharT>(__end_->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+void basic_regex<_CharT, _Traits>::__push_r_anchor() {
+  __end_->first() = new __r_anchor_multiline<_CharT>(__use_multiline(), __end_->first());
+  __end_          = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_word_boundary(bool __invert)
-{
-    __end_->first() = new __word_boundary<_CharT, _Traits>(__traits_, __invert,
-                                                           __end_->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+void basic_regex<_CharT, _Traits>::__push_match_any() {
+  __end_->first() = new __match_any<_CharT>(__end_->first());
+  __end_          = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_back_ref(int __i)
-{
-    if (flags() & icase)
-        __end_->first() = new __back_ref_icase<_CharT, _Traits>
-                                              (__traits_, __i, __end_->first());
-    else if (flags() & collate)
-        __end_->first() = new __back_ref_collate<_CharT, _Traits>
-                                              (__traits_, __i, __end_->first());
-    else
-        __end_->first() = new __back_ref<_CharT>(__i, __end_->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+void basic_regex<_CharT, _Traits>::__push_match_any_but_newline() {
+  __end_->first() = new __match_any_but_newline<_CharT>(__end_->first());
+  __end_          = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_alternation(__owns_one_state<_CharT>* __sa,
-                                                 __owns_one_state<_CharT>* __ea)
-{
-    __sa->first() = new __alternate<_CharT>(
-                         static_cast<__owns_one_state<_CharT>*>(__sa->first()),
-                         static_cast<__owns_one_state<_CharT>*>(__ea->first()));
-    __ea->first() = nullptr;
-    __ea->first() = new __empty_state<_CharT>(__end_->first());
-    __end_->first() = nullptr;
-    __end_->first() = new __empty_non_own_state<_CharT>(__ea->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__ea->first());
+void basic_regex<_CharT, _Traits>::__push_empty() {
+  __end_->first() = new __empty_state<_CharT>(__end_->first());
+  __end_          = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
-__bracket_expression<_CharT, _Traits>*
-basic_regex<_CharT, _Traits>::__start_matching_list(bool __negate)
-{
-    __bracket_expression<_CharT, _Traits>* __r =
-        new __bracket_expression<_CharT, _Traits>(__traits_, __end_->first(),
-                                                  __negate, __flags_ & icase,
-                                                  __flags_ & collate);
-    __end_->first() = __r;
-    __end_ = __r;
-    return __r;
+void basic_regex<_CharT, _Traits>::__push_word_boundary(bool __invert) {
+  __end_->first() = new __word_boundary<_CharT, _Traits>(__traits_, __invert, __end_->first());
+  __end_          = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_lookahead(const basic_regex& __exp,
-                                               bool __invert,
-                                               unsigned __mexp)
-{
-    __end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert,
-                                                           __end_->first(), __mexp);
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+void basic_regex<_CharT, _Traits>::__push_back_ref(int __i) {
+  if (flags() & icase)
+    __end_->first() = new __back_ref_icase<_CharT, _Traits>(__traits_, __i, __end_->first());
+  else if (flags() & collate)
+    __end_->first() = new __back_ref_collate<_CharT, _Traits>(__traits_, __i, __end_->first());
+  else
+    __end_->first() = new __back_ref<_CharT>(__i, __end_->first());
+  __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
+}
+
+template <class _CharT, class _Traits>
+void basic_regex<_CharT, _Traits>::__push_alternation(__owns_one_state<_CharT>* __sa, __owns_one_state<_CharT>* __ea) {
+  __sa->first() = new __alternate<_CharT>(
+      static_cast<__owns_one_state<_CharT>*>(__sa->first()), static_cast<__owns_one_state<_CharT>*>(__ea->first()));
+  __ea->first()   = nullptr;
+  __ea->first()   = new __empty_state<_CharT>(__end_->first());
+  __end_->first() = nullptr;
+  __end_->first() = new __empty_non_own_state<_CharT>(__ea->first());
+  __end_          = static_cast<__owns_one_state<_CharT>*>(__ea->first());
+}
+
+template <class _CharT, class _Traits>
+__bracket_expression<_CharT, _Traits>* basic_regex<_CharT, _Traits>::__start_matching_list(bool __negate) {
+  __bracket_expression<_CharT, _Traits>* __r = new __bracket_expression<_CharT, _Traits>(
+      __traits_, __end_->first(), __negate, __flags_ & icase, __flags_ & collate);
+  __end_->first() = __r;
+  __end_          = __r;
+  return __r;
+}
+
+template <class _CharT, class _Traits>
+void basic_regex<_CharT, _Traits>::__push_lookahead(const basic_regex& __exp, bool __invert, unsigned __mexp) {
+  __end_->first() = new __lookahead<_CharT, _Traits>(__exp, __invert, __end_->first(), __mexp);
+  __end_          = static_cast<__owns_one_state<_CharT>*>(__end_->first());
 }
 
 // sub_match
 
-typedef sub_match<const char*>             csub_match;
-typedef sub_match<string::const_iterator>  ssub_match;
+typedef sub_match<const char*> csub_match;
+typedef sub_match<string::const_iterator> ssub_match;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-typedef sub_match<const wchar_t*>          wcsub_match;
+typedef sub_match<const wchar_t*> wcsub_match;
 typedef sub_match<wstring::const_iterator> wssub_match;
 #endif
 
 template <class _BidirectionalIterator>
-class
-    _LIBCPP_TEMPLATE_VIS
-    _LIBCPP_PREFERRED_NAME(csub_match)
-    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcsub_match))
-    _LIBCPP_PREFERRED_NAME(ssub_match)
-    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wssub_match))
-    sub_match
-    : public pair<_BidirectionalIterator, _BidirectionalIterator>
-{
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_PREFERRED_NAME(csub_match)
+    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcsub_match)) _LIBCPP_PREFERRED_NAME(ssub_match)
+        _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wssub_match)) sub_match
+    : public pair<_BidirectionalIterator, _BidirectionalIterator> {
 public:
-    typedef _BidirectionalIterator                              iterator;
-    typedef typename iterator_traits<iterator>::value_type      value_type;
-    typedef typename iterator_traits<iterator>::difference_type difference_type;
-    typedef basic_string<value_type>                            string_type;
+  typedef _BidirectionalIterator iterator;
+  typedef typename iterator_traits<iterator>::value_type value_type;
+  typedef typename iterator_traits<iterator>::difference_type difference_type;
+  typedef basic_string<value_type> string_type;
 
-    bool matched;
+  bool matched;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR sub_match() : matched() {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR sub_match() : matched() {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    difference_type length() const
-        {return matched ? _VSTD::distance(this->first, this->second) : 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    string_type str() const
-        {return matched ? string_type(this->first, this->second) : string_type();}
-    _LIBCPP_INLINE_VISIBILITY
-    operator string_type() const
-        {return str();}
+  _LIBCPP_HIDE_FROM_ABI difference_type length() const {
+    return matched ? std::distance(this->first, this->second) : 0;
+  }
+  _LIBCPP_HIDE_FROM_ABI string_type str() const {
+    return matched ? string_type(this->first, this->second) : string_type();
+  }
+  _LIBCPP_HIDE_FROM_ABI operator string_type() const { return str(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    int compare(const sub_match& __s) const
-        {return str().compare(__s.str());}
-    _LIBCPP_INLINE_VISIBILITY
-    int compare(const string_type& __s) const
-        {return str().compare(__s);}
-    _LIBCPP_INLINE_VISIBILITY
-    int compare(const value_type* __s) const
-        {return str().compare(__s);}
+  _LIBCPP_HIDE_FROM_ABI int compare(const sub_match& __s) const { return str().compare(__s.str()); }
+  _LIBCPP_HIDE_FROM_ABI int compare(const string_type& __s) const { return str().compare(__s); }
+  _LIBCPP_HIDE_FROM_ABI int compare(const value_type* __s) const { return str().compare(__s); }
 
-    _LIBCPP_HIDE_FROM_ABI
-    void swap(sub_match& __s)
-#ifndef _LIBCPP_CXX03_LANG
-    _NOEXCEPT(__is_nothrow_swappable<_BidirectionalIterator>::value)
-#endif // _LIBCPP_CXX03_LANG
-    {
-        this->pair<_BidirectionalIterator, _BidirectionalIterator>::swap(__s);
-        std::swap(matched, __s.matched);
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(sub_match& __s) _NOEXCEPT_(__is_nothrow_swappable_v<_BidirectionalIterator>) {
+    this->pair<_BidirectionalIterator, _BidirectionalIterator>::swap(__s);
+    std::swap(matched, __s.matched);
+  }
 };
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
-{
-    return __x.compare(__y) == 0;
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
+  return __x.compare(__y) == 0;
 }
 
 #if _LIBCPP_STD_VER >= 20
-template<class _BiIter>
+template <class _BiIter>
 using __sub_match_cat = compare_three_way_result_t<basic_string<typename iterator_traits<_BiIter>::value_type>>;
 
 template <class _BiIter>
 _LIBCPP_HIDE_FROM_ABI auto operator<=>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
-    return static_cast<__sub_match_cat<_BiIter>>(__x.compare(__y) <=> 0);
+  return static_cast<__sub_match_cat<_BiIter>>(__x.compare(__y) <=> 0);
 }
-#else // _LIBCPP_STD_VER >= 20
+#else  // _LIBCPP_STD_VER >= 20
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
+  return !(__x == __y);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
-{
-    return __x.compare(__y) < 0;
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
+  return __x.compare(__y) < 0;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
+  return !(__y < __x);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
+  return !(__x < __y);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const sub_match<_BiIter>& __x, const sub_match<_BiIter>& __y) {
+  return __y < __x;
 }
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator==(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
-           const sub_match<_BiIter>& __y)
-{
-    return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) == 0;
+           const sub_match<_BiIter>& __y) {
+  return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) == 0;
 }
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator!=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
-           const sub_match<_BiIter>& __y)
-{
-    return !(__x == __y);
+           const sub_match<_BiIter>& __y) {
+  return !(__x == __y);
 }
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator<(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
-          const sub_match<_BiIter>& __y)
-{
-    return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) > 0;
+          const sub_match<_BiIter>& __y) {
+  return __y.compare(typename sub_match<_BiIter>::string_type(__x.data(), __x.size())) > 0;
 }
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator>(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
-          const sub_match<_BiIter>& __y)
-{
-    return __y < __x;
+          const sub_match<_BiIter>& __y) {
+  return __y < __x;
 }
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator>=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
-                const sub_match<_BiIter>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
+           const sub_match<_BiIter>& __y) {
+  return !(__x < __y);
 }
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator<=(const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __x,
-           const sub_match<_BiIter>& __y)
-{
-    return !(__y < __x);
+           const sub_match<_BiIter>& __y) {
+  return !(__y < __x);
 }
 #endif // _LIBCPP_STD_VER >= 20
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator==(const sub_match<_BiIter>& __x,
-           const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
-{
-    return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0;
+           const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
+  return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) == 0;
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _BiIter, class _ST, class _SA>
-_LIBCPP_HIDE_FROM_ABI auto operator<=>(
-    const sub_match<_BiIter>& __x, const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
-    return static_cast<__sub_match_cat<_BiIter>>(
-        __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) <=> 0);
+_LIBCPP_HIDE_FROM_ABI auto
+operator<=>(const sub_match<_BiIter>& __x,
+            const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
+  return static_cast<__sub_match_cat<_BiIter>>(
+      __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) <=> 0);
 }
-#else // _LIBCPP_STD_VER >= 20
+#else  // _LIBCPP_STD_VER >= 20
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator!=(const sub_match<_BiIter>& __x,
-           const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
-{
-    return !(__x == __y);
+           const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
+  return !(__x == __y);
 }
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator<(const sub_match<_BiIter>& __x,
-          const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
-{
-    return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) < 0;
+          const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
+  return __x.compare(typename sub_match<_BiIter>::string_type(__y.data(), __y.size())) < 0;
 }
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator>(const sub_match<_BiIter>& __x,
-               const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(const sub_match<_BiIter>& __x,
+          const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
+  return __y < __x;
 }
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator>=(const sub_match<_BiIter>& __x,
-           const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
-{
-    return !(__x < __y);
+           const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
+  return !(__x < __y);
 }
 
 template <class _BiIter, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator<=(const sub_match<_BiIter>& __x,
-           const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y)
-{
-    return !(__y < __x);
+           const basic_string<typename iterator_traits<_BiIter>::value_type, _ST, _SA>& __y) {
+  return !(__y < __x);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(typename iterator_traits<_BiIter>::value_type const* __x,
-           const sub_match<_BiIter>& __y)
-{
-    return __y.compare(__x) == 0;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
+  return __y.compare(__x) == 0;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(typename iterator_traits<_BiIter>::value_type const* __x,
-           const sub_match<_BiIter>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
+  return !(__x == __y);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(typename iterator_traits<_BiIter>::value_type const* __x,
-          const sub_match<_BiIter>& __y)
-{
-    return __y.compare(__x) > 0;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
+  return __y.compare(__x) > 0;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(typename iterator_traits<_BiIter>::value_type const* __x,
-          const sub_match<_BiIter>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
+  return __y < __x;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(typename iterator_traits<_BiIter>::value_type const* __x,
-           const sub_match<_BiIter>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
+  return !(__x < __y);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(typename iterator_traits<_BiIter>::value_type const* __x,
-           const sub_match<_BiIter>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(typename iterator_traits<_BiIter>::value_type const* __x, const sub_match<_BiIter>& __y) {
+  return !(__y < __x);
 }
 #endif // _LIBCPP_STD_VER >= 20
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const sub_match<_BiIter>& __x,
-           typename iterator_traits<_BiIter>::value_type const* __y)
-{
-    return __x.compare(__y) == 0;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
+  return __x.compare(__y) == 0;
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _BiIter>
 _LIBCPP_HIDE_FROM_ABI auto
 operator<=>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
-    return static_cast<__sub_match_cat<_BiIter>>(__x.compare(__y) <=> 0);
+  return static_cast<__sub_match_cat<_BiIter>>(__x.compare(__y) <=> 0);
 }
-#else // _LIBCPP_STD_VER >= 20
+#else  // _LIBCPP_STD_VER >= 20
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const sub_match<_BiIter>& __x,
-           typename iterator_traits<_BiIter>::value_type const* __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
+  return !(__x == __y);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const sub_match<_BiIter>& __x,
-          typename iterator_traits<_BiIter>::value_type const* __y)
-{
-    return __x.compare(__y) < 0;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
+  return __x.compare(__y) < 0;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(const sub_match<_BiIter>& __x,
-          typename iterator_traits<_BiIter>::value_type const* __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
+  return __y < __x;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const sub_match<_BiIter>& __x,
-           typename iterator_traits<_BiIter>::value_type const* __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
+  return !(__x < __y);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const sub_match<_BiIter>& __x,
-           typename iterator_traits<_BiIter>::value_type const* __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const* __y) {
+  return !(__y < __x);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(typename iterator_traits<_BiIter>::value_type const& __x,
-           const sub_match<_BiIter>& __y)
-{
-    typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
-    return __y.compare(string_type(1, __x)) == 0;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
+  typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
+  return __y.compare(string_type(1, __x)) == 0;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(typename iterator_traits<_BiIter>::value_type const& __x,
-           const sub_match<_BiIter>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
+  return !(__x == __y);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(typename iterator_traits<_BiIter>::value_type const& __x,
-          const sub_match<_BiIter>& __y)
-{
-    typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
-    return __y.compare(string_type(1, __x)) > 0;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
+  typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
+  return __y.compare(string_type(1, __x)) > 0;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(typename iterator_traits<_BiIter>::value_type const& __x,
-          const sub_match<_BiIter>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
+  return __y < __x;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(typename iterator_traits<_BiIter>::value_type const& __x,
-           const sub_match<_BiIter>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
+  return !(__x < __y);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(typename iterator_traits<_BiIter>::value_type const& __x,
-           const sub_match<_BiIter>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(typename iterator_traits<_BiIter>::value_type const& __x, const sub_match<_BiIter>& __y) {
+  return !(__y < __x);
 }
 #endif // _LIBCPP_STD_VER >= 20
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const sub_match<_BiIter>& __x,
-           typename iterator_traits<_BiIter>::value_type const& __y)
-{
-    typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
-    return __x.compare(string_type(1, __y)) == 0;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
+  typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
+  return __x.compare(string_type(1, __y)) == 0;
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _BiIter>
 _LIBCPP_HIDE_FROM_ABI auto
 operator<=>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
-    using string_type = basic_string<typename iterator_traits<_BiIter>::value_type>;
-    return static_cast<__sub_match_cat<_BiIter>>(__x.compare(string_type(1, __y)) <=> 0);
+  using string_type = basic_string<typename iterator_traits<_BiIter>::value_type>;
+  return static_cast<__sub_match_cat<_BiIter>>(__x.compare(string_type(1, __y)) <=> 0);
 }
-#else // _LIBCPP_STD_VER >= 20
+#else  // _LIBCPP_STD_VER >= 20
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const sub_match<_BiIter>& __x,
-           typename iterator_traits<_BiIter>::value_type const& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
+  return !(__x == __y);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<(const sub_match<_BiIter>& __x,
-          typename iterator_traits<_BiIter>::value_type const& __y)
-{
-    typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
-    return __x.compare(string_type(1, __y)) < 0;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
+  typedef basic_string<typename iterator_traits<_BiIter>::value_type> string_type;
+  return __x.compare(string_type(1, __y)) < 0;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>(const sub_match<_BiIter>& __x,
-          typename iterator_traits<_BiIter>::value_type const& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
+  return __y < __x;
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const sub_match<_BiIter>& __x,
-           typename iterator_traits<_BiIter>::value_type const& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
+  return !(__x < __y);
 }
 
 template <class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const sub_match<_BiIter>& __x,
-           typename iterator_traits<_BiIter>::value_type const& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(const sub_match<_BiIter>& __x, typename iterator_traits<_BiIter>::value_type const& __y) {
+  return !(__y < __x);
 }
 #endif // _LIBCPP_STD_VER >= 20
 
 template <class _CharT, class _ST, class _BiIter>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _ST>&
-operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m)
-{
-    return __os << __m.str();
+inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _ST>&
+operator<<(basic_ostream<_CharT, _ST>& __os, const sub_match<_BiIter>& __m) {
+  return __os << __m.str();
 }
 
-typedef match_results<const char*>             cmatch;
-typedef match_results<string::const_iterator>  smatch;
+typedef match_results<const char*> cmatch;
+typedef match_results<string::const_iterator> smatch;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-typedef match_results<const wchar_t*>          wcmatch;
+typedef match_results<const wchar_t*> wcmatch;
 typedef match_results<wstring::const_iterator> wsmatch;
 #endif
 
 template <class _BidirectionalIterator, class _Allocator>
-class
-    _LIBCPP_TEMPLATE_VIS
-    _LIBCPP_PREFERRED_NAME(cmatch)
-    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcmatch))
-    _LIBCPP_PREFERRED_NAME(smatch)
-    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsmatch))
-    match_results
-{
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_PREFERRED_NAME(cmatch) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcmatch))
+    _LIBCPP_PREFERRED_NAME(smatch) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsmatch)) match_results {
 public:
-    typedef _Allocator                                        allocator_type;
-    typedef sub_match<_BidirectionalIterator>                 value_type;
+  typedef _Allocator allocator_type;
+  typedef sub_match<_BidirectionalIterator> value_type;
+
 private:
-    typedef vector<value_type, allocator_type>                __container_type;
+  typedef vector<value_type, allocator_type> __container_type;
+
+  __container_type __matches_;
+  value_type __unmatched_;
+  value_type __prefix_;
+  value_type __suffix_;
+  bool __ready_;
 
-    __container_type  __matches_;
-    value_type __unmatched_;
-    value_type __prefix_;
-    value_type __suffix_;
-    bool       __ready_;
 public:
-    _BidirectionalIterator __position_start_;
-    typedef const value_type&                                 const_reference;
-    typedef value_type&                                       reference;
-    typedef typename __container_type::const_iterator         const_iterator;
-    typedef const_iterator                                    iterator;
-    typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
-    typedef typename allocator_traits<allocator_type>::size_type size_type;
-    typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type;
-    typedef basic_string<char_type>                           string_type;
+  _BidirectionalIterator __position_start_;
+  typedef const value_type& const_reference;
+  typedef value_type& reference;
+  typedef typename __container_type::const_iterator const_iterator;
+  typedef const_iterator iterator;
+  typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
+  typedef typename allocator_traits<allocator_type>::size_type size_type;
+  typedef typename iterator_traits<_BidirectionalIterator>::value_type char_type;
+  typedef basic_string<char_type> string_type;
 
-    // construct/copy/destroy:
+  // construct/copy/destroy:
 #ifndef _LIBCPP_CXX03_LANG
-    match_results() : match_results(allocator_type()) {}
-    explicit match_results(const allocator_type& __a);
+  match_results() : match_results(allocator_type()) {}
+  explicit match_results(const allocator_type& __a);
 #else
-    explicit match_results(const allocator_type& __a = allocator_type());
+  explicit match_results(const allocator_type& __a = allocator_type());
 #endif
 
-//    match_results(const match_results&) = default;
-//    match_results& operator=(const match_results&) = default;
-//    match_results(match_results&& __m) = default;
-//    match_results& operator=(match_results&& __m) = default;
-//    ~match_results() = default;
+  //    match_results(const match_results&) = default;
+  //    match_results& operator=(const match_results&) = default;
+  //    match_results(match_results&& __m) = default;
+  //    match_results& operator=(match_results&& __m) = default;
+  //    ~match_results() = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool ready() const {return __ready_;}
+  _LIBCPP_HIDE_FROM_ABI bool ready() const { return __ready_; }
 
-    // size:
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT {return __matches_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __matches_.max_size();}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return size() == 0;}
+  // size:
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __matches_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __matches_.max_size(); }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return size() == 0; }
 
-    // element access:
-    _LIBCPP_INLINE_VISIBILITY
-    difference_type length(size_type __sub = 0) const
-        {
-        _LIBCPP_ASSERT(ready(), "match_results::length() called when not ready");
-        return (*this)[__sub].length();
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    difference_type position(size_type __sub = 0) const
-        {
-        _LIBCPP_ASSERT(ready(), "match_results::position() called when not ready");
-        return _VSTD::distance(__position_start_, (*this)[__sub].first);
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    string_type str(size_type __sub = 0) const
-        {
-        _LIBCPP_ASSERT(ready(), "match_results::str() called when not ready");
-        return (*this)[__sub].str();
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference operator[](size_type __n) const
-        {
-        _LIBCPP_ASSERT(ready(), "match_results::operator[]() called when not ready");
-        return __n < __matches_.size() ? __matches_[__n] : __unmatched_;
-        }
+  // element access:
+  _LIBCPP_HIDE_FROM_ABI difference_type length(size_type __sub = 0) const {
+    // If the match results are not ready, this will return `0`.
+    _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::length() called when not ready");
+    return (*this)[__sub].length();
+  }
+  _LIBCPP_HIDE_FROM_ABI difference_type position(size_type __sub = 0) const {
+    // If the match results are not ready, this will return the result of subtracting two default-constructed iterators
+    // (which is typically a well-defined operation).
+    _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::position() called when not ready");
+    return std::distance(__position_start_, (*this)[__sub].first);
+  }
+  _LIBCPP_HIDE_FROM_ABI string_type str(size_type __sub = 0) const {
+    // If the match results are not ready, this will return an empty string.
+    _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::str() called when not ready");
+    return (*this)[__sub].str();
+  }
+  _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __n) const {
+    // If the match results are not ready, this call will be equivalent to calling this function with `__n >= size()`,
+    // returning an empty subrange.
+    _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::operator[]() called when not ready");
+    return __n < __matches_.size() ? __matches_[__n] : __unmatched_;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference prefix() const
-        {
-        _LIBCPP_ASSERT(ready(), "match_results::prefix() called when not ready");
-        return __prefix_;
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference suffix() const
-        {
-        _LIBCPP_ASSERT(ready(), "match_results::suffix() called when not ready");
-        return __suffix_;
-        }
+  _LIBCPP_HIDE_FROM_ABI const_reference prefix() const {
+    // If the match results are not ready, this will return a default-constructed empty `__suffix_`.
+    _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::prefix() called when not ready");
+    return __prefix_;
+  }
+  _LIBCPP_HIDE_FROM_ABI const_reference suffix() const {
+    // If the match results are not ready, this will return a default-constructed empty `__suffix_`.
+    _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::suffix() called when not ready");
+    return __suffix_;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const {return __matches_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const {return __matches_.end();}
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const { return empty() ? __matches_.end() : __matches_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const { return __matches_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const { return empty() ? __matches_.end() : __matches_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const { return __matches_.end(); }
 
-    // format:
-    template <class _OutputIter>
-        _OutputIter
-        format(_OutputIter __output_iter, const char_type* __fmt_first,
-               const char_type* __fmt_last,
-               regex_constants::match_flag_type __flags = regex_constants::format_default) const;
-    template <class _OutputIter, class _ST, class _SA>
-        _LIBCPP_INLINE_VISIBILITY
-        _OutputIter
-        format(_OutputIter __output_iter, const basic_string<char_type, _ST, _SA>& __fmt,
-               regex_constants::match_flag_type __flags = regex_constants::format_default) const
-            {return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);}
-    template <class _ST, class _SA>
-        _LIBCPP_INLINE_VISIBILITY
-        basic_string<char_type, _ST, _SA>
-        format(const basic_string<char_type, _ST, _SA>& __fmt,
-               regex_constants::match_flag_type __flags = regex_constants::format_default) const
-        {
-            basic_string<char_type, _ST, _SA> __r;
-            format(std::back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(),
-                   __flags);
-            return __r;
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    string_type
-        format(const char_type* __fmt,
-               regex_constants::match_flag_type __flags = regex_constants::format_default) const
-        {
-            string_type __r;
-            format(std::back_inserter(__r), __fmt,
-                   __fmt + char_traits<char_type>::length(__fmt), __flags);
-            return __r;
-        }
+  // format:
+  template <class _OutputIter>
+  _OutputIter format(_OutputIter __output_iter,
+                     const char_type* __fmt_first,
+                     const char_type* __fmt_last,
+                     regex_constants::match_flag_type __flags = regex_constants::format_default) const;
+  template <class _OutputIter, class _ST, class _SA>
+  _LIBCPP_HIDE_FROM_ABI _OutputIter
+  format(_OutputIter __output_iter,
+         const basic_string<char_type, _ST, _SA>& __fmt,
+         regex_constants::match_flag_type __flags = regex_constants::format_default) const {
+    return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);
+  }
+  template <class _ST, class _SA>
+  _LIBCPP_HIDE_FROM_ABI basic_string<char_type, _ST, _SA>
+  format(const basic_string<char_type, _ST, _SA>& __fmt,
+         regex_constants::match_flag_type __flags = regex_constants::format_default) const {
+    basic_string<char_type, _ST, _SA> __r;
+    format(std::back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(), __flags);
+    return __r;
+  }
+  _LIBCPP_HIDE_FROM_ABI string_type
+  format(const char_type* __fmt, regex_constants::match_flag_type __flags = regex_constants::format_default) const {
+    string_type __r;
+    format(std::back_inserter(__r), __fmt, __fmt + char_traits<char_type>::length(__fmt), __flags);
+    return __r;
+  }
 
-    // allocator:
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const {return __matches_.get_allocator();}
+  // allocator:
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const { return __matches_.get_allocator(); }
 
-    // swap:
-    void swap(match_results& __m);
+  // swap:
+  void swap(match_results& __m);
 
-    template <class _Bp, class _Ap>
-        _LIBCPP_INLINE_VISIBILITY
-        void __assign(_BidirectionalIterator __f, _BidirectionalIterator __l,
-                      const match_results<_Bp, _Ap>& __m, bool __no_update_pos)
-    {
-        _Bp __mf = __m.prefix().first;
-        __matches_.resize(__m.size());
-        for (size_type __i = 0; __i < __matches_.size(); ++__i)
-        {
-            __matches_[__i].first = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].first));
-            __matches_[__i].second = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].second));
-            __matches_[__i].matched = __m[__i].matched;
-        }
-        __unmatched_.first   = __l;
-        __unmatched_.second  = __l;
-        __unmatched_.matched = false;
-        __prefix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().first));
-        __prefix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().second));
-        __prefix_.matched = __m.prefix().matched;
-        __suffix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().first));
-        __suffix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().second));
-        __suffix_.matched = __m.suffix().matched;
-        if (!__no_update_pos)
-            __position_start_ = __prefix_.first;
-        __ready_ = __m.ready();
+  template <class _Bp, class _Ap>
+  _LIBCPP_HIDE_FROM_ABI void
+  __assign(_BidirectionalIterator __f,
+           _BidirectionalIterator __l,
+           const match_results<_Bp, _Ap>& __m,
+           bool __no_update_pos) {
+    _Bp __mf = __m.prefix().first;
+    __matches_.resize(__m.size());
+    for (size_type __i = 0; __i < __matches_.size(); ++__i) {
+      __matches_[__i].first   = std::next(__f, std::distance(__mf, __m[__i].first));
+      __matches_[__i].second  = std::next(__f, std::distance(__mf, __m[__i].second));
+      __matches_[__i].matched = __m[__i].matched;
     }
-
-private:
-    void __init(unsigned __s,
-                _BidirectionalIterator __f, _BidirectionalIterator __l,
-                bool __no_update_pos = false);
-
-    template <class, class> friend class basic_regex;
-
-    template <class _Bp, class _Ap, class _Cp, class _Tp>
-    friend
-    bool
-    regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&,
-                regex_constants::match_flag_type);
-
-    template <class _Bp, class _Ap>
-    friend
-    bool
-    operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&);
-
-    template <class, class> friend class __lookahead;
-};
-
-template <class _BidirectionalIterator, class _Allocator>
-match_results<_BidirectionalIterator, _Allocator>::match_results(
-        const allocator_type& __a)
-    : __matches_(__a),
-      __unmatched_(),
-      __prefix_(),
-      __suffix_(),
-      __ready_(false),
-      __position_start_()
-{
-}
-
-template <class _BidirectionalIterator, class _Allocator>
-void
-match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s,
-                         _BidirectionalIterator __f, _BidirectionalIterator __l,
-                         bool __no_update_pos)
-{
     __unmatched_.first   = __l;
     __unmatched_.second  = __l;
     __unmatched_.matched = false;
-    __matches_.assign(__s, __unmatched_);
-    __prefix_.first      = __f;
-    __prefix_.second     = __f;
-    __prefix_.matched    = false;
-    __suffix_ = __unmatched_;
+    __prefix_.first      = std::next(__f, std::distance(__mf, __m.prefix().first));
+    __prefix_.second     = std::next(__f, std::distance(__mf, __m.prefix().second));
+    __prefix_.matched    = __m.prefix().matched;
+    __suffix_.first      = std::next(__f, std::distance(__mf, __m.suffix().first));
+    __suffix_.second     = std::next(__f, std::distance(__mf, __m.suffix().second));
+    __suffix_.matched    = __m.suffix().matched;
     if (!__no_update_pos)
-        __position_start_ = __prefix_.first;
-    __ready_ = true;
+      __position_start_ = __prefix_.first;
+    __ready_ = __m.ready();
+  }
+
+private:
+  void __init(unsigned __s, _BidirectionalIterator __f, _BidirectionalIterator __l, bool __no_update_pos = false);
+
+  template <class, class>
+  friend class basic_regex;
+
+  template <class _Bp, class _Ap, class _Cp, class _Tp>
+  friend bool
+  regex_match(_Bp, _Bp, match_results<_Bp, _Ap>&, const basic_regex<_Cp, _Tp>&, regex_constants::match_flag_type);
+
+  template <class _Bp, class _Ap>
+  friend bool operator==(const match_results<_Bp, _Ap>&, const match_results<_Bp, _Ap>&);
+
+  template <class, class>
+  friend class __lookahead;
+
+  template <class, class, class>
+  friend class regex_iterator;
+};
+
+template <class _BidirectionalIterator, class _Allocator>
+match_results<_BidirectionalIterator, _Allocator>::match_results(const allocator_type& __a)
+    : __matches_(__a), __unmatched_(), __prefix_(), __suffix_(), __ready_(false), __position_start_() {}
+
+template <class _BidirectionalIterator, class _Allocator>
+void match_results<_BidirectionalIterator, _Allocator>::__init(
+    unsigned __s, _BidirectionalIterator __f, _BidirectionalIterator __l, bool __no_update_pos) {
+  __unmatched_.first   = __l;
+  __unmatched_.second  = __l;
+  __unmatched_.matched = false;
+  __matches_.assign(__s, __unmatched_);
+  __prefix_.first   = __f;
+  __prefix_.second  = __f;
+  __prefix_.matched = false;
+  __suffix_         = __unmatched_;
+  if (!__no_update_pos)
+    __position_start_ = __prefix_.first;
+  __ready_ = true;
 }
 
 template <class _BidirectionalIterator, class _Allocator>
 template <class _OutputIter>
-_OutputIter
-match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __output_iter,
-        const char_type* __fmt_first, const char_type* __fmt_last,
-        regex_constants::match_flag_type __flags) const
-{
-    _LIBCPP_ASSERT(ready(), "match_results::format() called when not ready");
-    if (__flags & regex_constants::format_sed)
-    {
-        for (; __fmt_first != __fmt_last; ++__fmt_first)
-        {
-            if (*__fmt_first == '&')
-                __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
-                                   __output_iter);
-            else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last)
-            {
-                ++__fmt_first;
-                if ('0' <= *__fmt_first && *__fmt_first <= '9')
-                {
-                    size_t __i = *__fmt_first - '0';
-                    __output_iter = _VSTD::copy((*this)[__i].first,
-                                        (*this)[__i].second, __output_iter);
-                }
-                else
-                {
-                    *__output_iter = *__fmt_first;
-                    ++__output_iter;
-                }
-            }
-            else
-            {
-                *__output_iter = *__fmt_first;
-                ++__output_iter;
-            }
+_OutputIter match_results<_BidirectionalIterator, _Allocator>::format(
+    _OutputIter __output_iter,
+    const char_type* __fmt_first,
+    const char_type* __fmt_last,
+    regex_constants::match_flag_type __flags) const {
+  // Note: this duplicates a check in `vector::operator[]` but provides a better error message.
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(ready(), "match_results::format() called when not ready");
+  if (__flags & regex_constants::format_sed) {
+    for (; __fmt_first != __fmt_last; ++__fmt_first) {
+      if (*__fmt_first == '&')
+        __output_iter = std::copy(__matches_[0].first, __matches_[0].second, __output_iter);
+      else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last) {
+        ++__fmt_first;
+        if ('0' <= *__fmt_first && *__fmt_first <= '9') {
+          size_t __i    = *__fmt_first - '0';
+          __output_iter = std::copy((*this)[__i].first, (*this)[__i].second, __output_iter);
+        } else {
+          *__output_iter = *__fmt_first;
+          ++__output_iter;
         }
+      } else {
+        *__output_iter = *__fmt_first;
+        ++__output_iter;
+      }
     }
-    else
-    {
-        for (; __fmt_first != __fmt_last; ++__fmt_first)
-        {
-            if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last)
-            {
-                switch (__fmt_first[1])
-                {
-                case '$':
-                    *__output_iter = *++__fmt_first;
-                    ++__output_iter;
-                    break;
-                case '&':
-                    ++__fmt_first;
-                    __output_iter = _VSTD::copy(__matches_[0].first, __matches_[0].second,
-                                       __output_iter);
-                    break;
-                case '`':
-                    ++__fmt_first;
-                    __output_iter = _VSTD::copy(__prefix_.first, __prefix_.second, __output_iter);
-                    break;
-                case '\'':
-                    ++__fmt_first;
-                    __output_iter = _VSTD::copy(__suffix_.first, __suffix_.second, __output_iter);
-                    break;
-                default:
-                    if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
-                    {
-                        ++__fmt_first;
-                        size_t __idx = *__fmt_first - '0';
-                        if (__fmt_first + 1 != __fmt_last &&
-                            '0' <= __fmt_first[1] && __fmt_first[1] <= '9')
-                        {
-                            ++__fmt_first;
-                            if (__idx >= numeric_limits<size_t>::max() / 10)
-                                __throw_regex_error<regex_constants::error_escape>();
-                            __idx = 10 * __idx + *__fmt_first - '0';
-                        }
-                        __output_iter = _VSTD::copy((*this)[__idx].first,
-                                            (*this)[__idx].second, __output_iter);
-                    }
-                    else
-                    {
-                        *__output_iter = *__fmt_first;
-                        ++__output_iter;
-                    }
-                    break;
-                }
-            }
-            else
-            {
-                *__output_iter = *__fmt_first;
-                ++__output_iter;
+  } else {
+    for (; __fmt_first != __fmt_last; ++__fmt_first) {
+      if (*__fmt_first == '$' && __fmt_first + 1 != __fmt_last) {
+        switch (__fmt_first[1]) {
+        case '$':
+          *__output_iter = *++__fmt_first;
+          ++__output_iter;
+          break;
+        case '&':
+          ++__fmt_first;
+          __output_iter = std::copy(__matches_[0].first, __matches_[0].second, __output_iter);
+          break;
+        case '`':
+          ++__fmt_first;
+          __output_iter = std::copy(__prefix_.first, __prefix_.second, __output_iter);
+          break;
+        case '\'':
+          ++__fmt_first;
+          __output_iter = std::copy(__suffix_.first, __suffix_.second, __output_iter);
+          break;
+        default:
+          if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9') {
+            ++__fmt_first;
+            size_t __idx = *__fmt_first - '0';
+            if (__fmt_first + 1 != __fmt_last && '0' <= __fmt_first[1] && __fmt_first[1] <= '9') {
+              ++__fmt_first;
+              if (__idx >= numeric_limits<size_t>::max() / 10)
+                __throw_regex_error<regex_constants::error_escape>();
+              __idx = 10 * __idx + *__fmt_first - '0';
             }
+            __output_iter = std::copy((*this)[__idx].first, (*this)[__idx].second, __output_iter);
+          } else {
+            *__output_iter = *__fmt_first;
+            ++__output_iter;
+          }
+          break;
         }
+      } else {
+        *__output_iter = *__fmt_first;
+        ++__output_iter;
+      }
     }
-    return __output_iter;
+  }
+  return __output_iter;
 }
 
 template <class _BidirectionalIterator, class _Allocator>
-void
-match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m)
-{
-    using _VSTD::swap;
-    swap(__matches_, __m.__matches_);
-    swap(__unmatched_, __m.__unmatched_);
-    swap(__prefix_, __m.__prefix_);
-    swap(__suffix_, __m.__suffix_);
-    swap(__position_start_, __m.__position_start_);
-    swap(__ready_, __m.__ready_);
+void match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m) {
+  using std::swap;
+  swap(__matches_, __m.__matches_);
+  swap(__unmatched_, __m.__unmatched_);
+  swap(__prefix_, __m.__prefix_);
+  swap(__suffix_, __m.__suffix_);
+  swap(__position_start_, __m.__position_start_);
+  swap(__ready_, __m.__ready_);
 }
 
 template <class _BidirectionalIterator, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI bool
-operator==(const match_results<_BidirectionalIterator, _Allocator>& __x,
-           const match_results<_BidirectionalIterator, _Allocator>& __y)
-{
-    if (__x.__ready_ != __y.__ready_)
-        return false;
-    if (!__x.__ready_)
-        return true;
-    return __x.__matches_ == __y.__matches_ &&
-           __x.__prefix_ == __y.__prefix_ &&
-           __x.__suffix_ == __y.__suffix_;
+_LIBCPP_HIDE_FROM_ABI bool operator==(const match_results<_BidirectionalIterator, _Allocator>& __x,
+                                      const match_results<_BidirectionalIterator, _Allocator>& __y) {
+  if (__x.__ready_ != __y.__ready_)
+    return false;
+  if (!__x.__ready_)
+    return true;
+  return __x.__matches_ == __y.__matches_ && __x.__prefix_ == __y.__prefix_ && __x.__suffix_ == __y.__suffix_;
 }
 
+#if _LIBCPP_STD_VER < 20
 template <class _BidirectionalIterator, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const match_results<_BidirectionalIterator, _Allocator>& __x,
-           const match_results<_BidirectionalIterator, _Allocator>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const match_results<_BidirectionalIterator, _Allocator>& __x,
+                                             const match_results<_BidirectionalIterator, _Allocator>& __y) {
+  return !(__x == __y);
 }
+#endif
 
 template <class _BidirectionalIterator, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(match_results<_BidirectionalIterator, _Allocator>& __x,
-     match_results<_BidirectionalIterator, _Allocator>& __y)
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(match_results<_BidirectionalIterator, _Allocator>& __x, match_results<_BidirectionalIterator, _Allocator>& __y) {
+  __x.swap(__y);
 }
 
 // regex_search
 
 template <class _CharT, class _Traits>
 template <class _Allocator>
-bool
-basic_regex<_CharT, _Traits>::__match_at_start_ecma(
-        const _CharT* __first, const _CharT* __last,
-        match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
-{
-    vector<__state> __states;
-    __node* __st = __start_.get();
-    if (__st)
-    {
-        sub_match<const _CharT*> __unmatched;
-        __unmatched.first   = __last;
-        __unmatched.second  = __last;
-        __unmatched.matched = false;
+bool basic_regex<_CharT, _Traits>::__match_at_start_ecma(
+    const _CharT* __first,
+    const _CharT* __last,
+    match_results<const _CharT*, _Allocator>& __m,
+    regex_constants::match_flag_type __flags,
+    bool __at_first) const {
+  vector<__state> __states;
+  __node* __st = __start_.get();
+  if (__st) {
+    sub_match<const _CharT*> __unmatched;
+    __unmatched.first   = __last;
+    __unmatched.second  = __last;
+    __unmatched.matched = false;
 
-        __states.push_back(__state());
-        __states.back().__do_ = 0;
-        __states.back().__first_ = __first;
-        __states.back().__current_ = __first;
-        __states.back().__last_ = __last;
-        __states.back().__sub_matches_.resize(mark_count(), __unmatched);
-        __states.back().__loop_data_.resize(__loop_count());
-        __states.back().__node_ = __st;
-        __states.back().__flags_ = __flags;
-        __states.back().__at_first_ = __at_first;
-        int __counter = 0;
-        int __length = __last - __first;
-        do
-        {
-            ++__counter;
-            if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
-                __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
-              __throw_regex_error<regex_constants::error_complexity>();
-            __state& __s = __states.back();
-            if (__s.__node_)
-                __s.__node_->__exec(__s);
-            switch (__s.__do_)
-            {
-            case __state::__end_state:
-                if ((__flags & regex_constants::match_not_null) &&
-                    __s.__current_ == __first)
-                {
-                  __states.pop_back();
-                  break;
-                }
-                if ((__flags & regex_constants::__full_match) &&
-                    __s.__current_ != __last)
-                {
-                  __states.pop_back();
-                  break;
-                }
-                __m.__matches_[0].first = __first;
-                __m.__matches_[0].second = _VSTD::next(__first, __s.__current_ - __first);
-                __m.__matches_[0].matched = true;
-                for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i)
-                    __m.__matches_[__i+1] = __s.__sub_matches_[__i];
-                return true;
-            case __state::__accept_and_consume:
-            case __state::__repeat:
-            case __state::__accept_but_not_consume:
-                break;
-            case __state::__split:
-                {
-                __state __snext = __s;
-                __s.__node_->__exec_split(true, __s);
-                __snext.__node_->__exec_split(false, __snext);
-                __states.push_back(_VSTD::move(__snext));
-                }
-                break;
-            case __state::__reject:
-                __states.pop_back();
-                break;
-            default:
-                __throw_regex_error<regex_constants::__re_err_unknown>();
-                break;
-
-            }
-        } while (!__states.empty());
-    }
-    return false;
-}
-
-template <class _CharT, class _Traits>
-template <class _Allocator>
-bool
-basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
-        const _CharT* __first, const _CharT* __last,
-        match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
-{
-    deque<__state> __states;
-    ptrdiff_t __highest_j = 0;
-    ptrdiff_t __np = _VSTD::distance(__first, __last);
-    __node* __st = __start_.get();
-    if (__st)
-    {
-        __states.push_back(__state());
-        __states.back().__do_ = 0;
-        __states.back().__first_ = __first;
-        __states.back().__current_ = __first;
-        __states.back().__last_ = __last;
-        __states.back().__loop_data_.resize(__loop_count());
-        __states.back().__node_ = __st;
-        __states.back().__flags_ = __flags;
-        __states.back().__at_first_ = __at_first;
-        bool __matched = false;
-        int __counter = 0;
-        int __length = __last - __first;
-        do
-        {
-            ++__counter;
-            if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
-                __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
-              __throw_regex_error<regex_constants::error_complexity>();
-            __state& __s = __states.back();
-            if (__s.__node_)
-                __s.__node_->__exec(__s);
-            switch (__s.__do_)
-            {
-            case __state::__end_state:
-                if ((__flags & regex_constants::match_not_null) &&
-                    __s.__current_ == __first)
-                {
-                  __states.pop_back();
-                  break;
-                }
-                if ((__flags & regex_constants::__full_match) &&
-                    __s.__current_ != __last)
-                {
-                  __states.pop_back();
-                  break;
-                }
-                if (!__matched || __highest_j < __s.__current_ - __s.__first_)
-                    __highest_j = __s.__current_ - __s.__first_;
-                __matched = true;
-                if (__highest_j == __np)
-                    __states.clear();
-                else
-                    __states.pop_back();
-                break;
-            case __state::__consume_input:
-                break;
-            case __state::__accept_and_consume:
-                __states.push_front(_VSTD::move(__s));
-                __states.pop_back();
-                break;
-            case __state::__repeat:
-            case __state::__accept_but_not_consume:
-                break;
-            case __state::__split:
-                {
-                __state __snext = __s;
-                __s.__node_->__exec_split(true, __s);
-                __snext.__node_->__exec_split(false, __snext);
-                __states.push_back(_VSTD::move(__snext));
-                }
-                break;
-            case __state::__reject:
-                __states.pop_back();
-                break;
-            default:
-                __throw_regex_error<regex_constants::__re_err_unknown>();
-                break;
-            }
-        } while (!__states.empty());
-        if (__matched)
-        {
-            __m.__matches_[0].first = __first;
-            __m.__matches_[0].second = _VSTD::next(__first, __highest_j);
-            __m.__matches_[0].matched = true;
-            return true;
+    __states.push_back(__state());
+    __states.back().__do_      = 0;
+    __states.back().__first_   = __first;
+    __states.back().__current_ = __first;
+    __states.back().__last_    = __last;
+    __states.back().__sub_matches_.resize(mark_count(), __unmatched);
+    __states.back().__loop_data_.resize(__loop_count());
+    __states.back().__node_     = __st;
+    __states.back().__flags_    = __flags;
+    __states.back().__at_first_ = __at_first;
+    int __counter               = 0;
+    int __length                = __last - __first;
+    do {
+      ++__counter;
+      if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
+        __throw_regex_error<regex_constants::error_complexity>();
+      __state& __s = __states.back();
+      if (__s.__node_)
+        __s.__node_->__exec(__s);
+      switch (__s.__do_) {
+      case __state::__end_state:
+        if ((__flags & regex_constants::match_not_null) && __s.__current_ == __first) {
+          __states.pop_back();
+          break;
         }
-    }
-    return false;
-}
-
-template <class _CharT, class _Traits>
-template <class _Allocator>
-bool
-basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
-        const _CharT* __first, const _CharT* __last,
-        match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
-{
-    vector<__state> __states;
-    __state __best_state;
-    ptrdiff_t __highest_j = 0;
-    ptrdiff_t __np = _VSTD::distance(__first, __last);
-    __node* __st = __start_.get();
-    if (__st)
-    {
-        sub_match<const _CharT*> __unmatched;
-        __unmatched.first   = __last;
-        __unmatched.second  = __last;
-        __unmatched.matched = false;
-
-        __states.push_back(__state());
-        __states.back().__do_ = 0;
-        __states.back().__first_ = __first;
-        __states.back().__current_ = __first;
-        __states.back().__last_ = __last;
-        __states.back().__sub_matches_.resize(mark_count(), __unmatched);
-        __states.back().__loop_data_.resize(__loop_count());
-        __states.back().__node_ = __st;
-        __states.back().__flags_ = __flags;
-        __states.back().__at_first_ = __at_first;
-        bool __matched = false;
-        int __counter = 0;
-        int __length = __last - __first;
-        do
-        {
-            ++__counter;
-            if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 &&
-                __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
-              __throw_regex_error<regex_constants::error_complexity>();
-            __state& __s = __states.back();
-            if (__s.__node_)
-                __s.__node_->__exec(__s);
-            switch (__s.__do_)
-            {
-            case __state::__end_state:
-                if ((__flags & regex_constants::match_not_null) &&
-                    __s.__current_ == __first)
-                {
-                  __states.pop_back();
-                  break;
-                }
-                if ((__flags & regex_constants::__full_match) &&
-                    __s.__current_ != __last)
-                {
-                  __states.pop_back();
-                  break;
-                }
-                if (!__matched || __highest_j < __s.__current_ - __s.__first_)
-                {
-                    __highest_j = __s.__current_ - __s.__first_;
-                    __best_state = __s;
-                }
-                __matched = true;
-                if (__highest_j == __np)
-                    __states.clear();
-                else
-                    __states.pop_back();
-                break;
-            case __state::__accept_and_consume:
-            case __state::__repeat:
-            case __state::__accept_but_not_consume:
-                break;
-            case __state::__split:
-                {
-                __state __snext = __s;
-                __s.__node_->__exec_split(true, __s);
-                __snext.__node_->__exec_split(false, __snext);
-                __states.push_back(_VSTD::move(__snext));
-                }
-                break;
-            case __state::__reject:
-                __states.pop_back();
-                break;
-            default:
-                __throw_regex_error<regex_constants::__re_err_unknown>();
-                break;
-            }
-        } while (!__states.empty());
-        if (__matched)
-        {
-            __m.__matches_[0].first = __first;
-            __m.__matches_[0].second = _VSTD::next(__first, __highest_j);
-            __m.__matches_[0].matched = true;
-            for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i)
-                __m.__matches_[__i+1] = __best_state.__sub_matches_[__i];
-            return true;
+        if ((__flags & regex_constants::__full_match) && __s.__current_ != __last) {
+          __states.pop_back();
+          break;
         }
+        __m.__matches_[0].first   = __first;
+        __m.__matches_[0].second  = std::next(__first, __s.__current_ - __first);
+        __m.__matches_[0].matched = true;
+        for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i)
+          __m.__matches_[__i + 1] = __s.__sub_matches_[__i];
+        return true;
+      case __state::__accept_and_consume:
+      case __state::__repeat:
+      case __state::__accept_but_not_consume:
+        break;
+      case __state::__split: {
+        __state __snext = __s;
+        __s.__node_->__exec_split(true, __s);
+        __snext.__node_->__exec_split(false, __snext);
+        __states.push_back(std::move(__snext));
+      } break;
+      case __state::__reject:
+        __states.pop_back();
+        break;
+      default:
+        __throw_regex_error<regex_constants::__re_err_unknown>();
+        break;
+      }
+    } while (!__states.empty());
+  }
+  return false;
+}
+
+template <class _CharT, class _Traits>
+template <class _Allocator>
+bool basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
+    const _CharT* __first,
+    const _CharT* __last,
+    match_results<const _CharT*, _Allocator>& __m,
+    regex_constants::match_flag_type __flags,
+    bool __at_first) const {
+  deque<__state> __states;
+  ptrdiff_t __highest_j = 0;
+  ptrdiff_t __np        = std::distance(__first, __last);
+  __node* __st          = __start_.get();
+  if (__st) {
+    __states.push_back(__state());
+    __states.back().__do_      = 0;
+    __states.back().__first_   = __first;
+    __states.back().__current_ = __first;
+    __states.back().__last_    = __last;
+    __states.back().__loop_data_.resize(__loop_count());
+    __states.back().__node_     = __st;
+    __states.back().__flags_    = __flags;
+    __states.back().__at_first_ = __at_first;
+    bool __matched              = false;
+    int __counter               = 0;
+    int __length                = __last - __first;
+    do {
+      ++__counter;
+      if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
+        __throw_regex_error<regex_constants::error_complexity>();
+      __state& __s = __states.back();
+      if (__s.__node_)
+        __s.__node_->__exec(__s);
+      switch (__s.__do_) {
+      case __state::__end_state:
+        if ((__flags & regex_constants::match_not_null) && __s.__current_ == __first) {
+          __states.pop_back();
+          break;
+        }
+        if ((__flags & regex_constants::__full_match) && __s.__current_ != __last) {
+          __states.pop_back();
+          break;
+        }
+        if (!__matched || __highest_j < __s.__current_ - __s.__first_)
+          __highest_j = __s.__current_ - __s.__first_;
+        __matched = true;
+        if (__highest_j == __np)
+          __states.clear();
+        else
+          __states.pop_back();
+        break;
+      case __state::__consume_input:
+        break;
+      case __state::__accept_and_consume:
+        __states.push_front(std::move(__s));
+        __states.pop_back();
+        break;
+      case __state::__repeat:
+      case __state::__accept_but_not_consume:
+        break;
+      case __state::__split: {
+        __state __snext = __s;
+        __s.__node_->__exec_split(true, __s);
+        __snext.__node_->__exec_split(false, __snext);
+        __states.push_back(std::move(__snext));
+      } break;
+      case __state::__reject:
+        __states.pop_back();
+        break;
+      default:
+        __throw_regex_error<regex_constants::__re_err_unknown>();
+        break;
+      }
+    } while (!__states.empty());
+    if (__matched) {
+      __m.__matches_[0].first   = __first;
+      __m.__matches_[0].second  = std::next(__first, __highest_j);
+      __m.__matches_[0].matched = true;
+      return true;
     }
-    return false;
+  }
+  return false;
 }
 
 template <class _CharT, class _Traits>
 template <class _Allocator>
-bool
-basic_regex<_CharT, _Traits>::__match_at_start(
-        const _CharT* __first, const _CharT* __last,
-        match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
-{
-    if (__get_grammar(__flags_) == ECMAScript)
-        return __match_at_start_ecma(__first, __last, __m, __flags, __at_first);
-    if (mark_count() == 0)
-        return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first);
-    return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first);
+bool basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
+    const _CharT* __first,
+    const _CharT* __last,
+    match_results<const _CharT*, _Allocator>& __m,
+    regex_constants::match_flag_type __flags,
+    bool __at_first) const {
+  vector<__state> __states;
+  __state __best_state;
+  ptrdiff_t __highest_j = 0;
+  ptrdiff_t __np        = std::distance(__first, __last);
+  __node* __st          = __start_.get();
+  if (__st) {
+    sub_match<const _CharT*> __unmatched;
+    __unmatched.first   = __last;
+    __unmatched.second  = __last;
+    __unmatched.matched = false;
+
+    __states.push_back(__state());
+    __states.back().__do_      = 0;
+    __states.back().__first_   = __first;
+    __states.back().__current_ = __first;
+    __states.back().__last_    = __last;
+    __states.back().__sub_matches_.resize(mark_count(), __unmatched);
+    __states.back().__loop_data_.resize(__loop_count());
+    __states.back().__node_     = __st;
+    __states.back().__flags_    = __flags;
+    __states.back().__at_first_ = __at_first;
+    bool __matched              = false;
+    int __counter               = 0;
+    int __length                = __last - __first;
+    do {
+      ++__counter;
+      if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
+        __throw_regex_error<regex_constants::error_complexity>();
+      __state& __s = __states.back();
+      if (__s.__node_)
+        __s.__node_->__exec(__s);
+      switch (__s.__do_) {
+      case __state::__end_state:
+        if ((__flags & regex_constants::match_not_null) && __s.__current_ == __first) {
+          __states.pop_back();
+          break;
+        }
+        if ((__flags & regex_constants::__full_match) && __s.__current_ != __last) {
+          __states.pop_back();
+          break;
+        }
+        if (!__matched || __highest_j < __s.__current_ - __s.__first_) {
+          __highest_j  = __s.__current_ - __s.__first_;
+          __best_state = __s;
+        }
+        __matched = true;
+        if (__highest_j == __np)
+          __states.clear();
+        else
+          __states.pop_back();
+        break;
+      case __state::__accept_and_consume:
+      case __state::__repeat:
+      case __state::__accept_but_not_consume:
+        break;
+      case __state::__split: {
+        __state __snext = __s;
+        __s.__node_->__exec_split(true, __s);
+        __snext.__node_->__exec_split(false, __snext);
+        __states.push_back(std::move(__snext));
+      } break;
+      case __state::__reject:
+        __states.pop_back();
+        break;
+      default:
+        __throw_regex_error<regex_constants::__re_err_unknown>();
+        break;
+      }
+    } while (!__states.empty());
+    if (__matched) {
+      __m.__matches_[0].first   = __first;
+      __m.__matches_[0].second  = std::next(__first, __highest_j);
+      __m.__matches_[0].matched = true;
+      for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i)
+        __m.__matches_[__i + 1] = __best_state.__sub_matches_[__i];
+      return true;
+    }
+  }
+  return false;
 }
 
 template <class _CharT, class _Traits>
 template <class _Allocator>
-bool
-basic_regex<_CharT, _Traits>::__search(
-        const _CharT* __first, const _CharT* __last,
-        match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags) const
-{
-    if (__flags & regex_constants::match_prev_avail)
-        __flags &= ~(regex_constants::match_not_bol | regex_constants::match_not_bow);
+bool basic_regex<_CharT, _Traits>::__match_at_start(
+    const _CharT* __first,
+    const _CharT* __last,
+    match_results<const _CharT*, _Allocator>& __m,
+    regex_constants::match_flag_type __flags,
+    bool __at_first) const {
+  if (__get_grammar(__flags_) == ECMAScript)
+    return __match_at_start_ecma(__first, __last, __m, __flags, __at_first);
+  if (mark_count() == 0)
+    return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first);
+  return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first);
+}
 
-    __m.__init(1 + mark_count(), __first, __last,
-                                    __flags & regex_constants::__no_update_pos);
-    if (__match_at_start(__first, __last, __m, __flags,
-                                    !(__flags & regex_constants::__no_update_pos)))
-    {
-        __m.__prefix_.second = __m[0].first;
+template <class _CharT, class _Traits>
+template <class _Allocator>
+bool basic_regex<_CharT, _Traits>::__search(
+    const _CharT* __first,
+    const _CharT* __last,
+    match_results<const _CharT*, _Allocator>& __m,
+    regex_constants::match_flag_type __flags) const {
+  if (__flags & regex_constants::match_prev_avail)
+    __flags &= ~(regex_constants::match_not_bol | regex_constants::match_not_bow);
+
+  __m.__init(1 + mark_count(), __first, __last, __flags & regex_constants::__no_update_pos);
+  if (__match_at_start(__first, __last, __m, __flags, !(__flags & regex_constants::__no_update_pos))) {
+    __m.__prefix_.second  = __m[0].first;
+    __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
+    __m.__suffix_.first   = __m[0].second;
+    __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
+    return true;
+  }
+  if (__first != __last && !(__flags & regex_constants::match_continuous)) {
+    __flags |= regex_constants::match_prev_avail;
+    for (++__first; __first != __last; ++__first) {
+      __m.__matches_.assign(__m.size(), __m.__unmatched_);
+      if (__match_at_start(__first, __last, __m, __flags, false)) {
+        __m.__prefix_.second  = __m[0].first;
         __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
-        __m.__suffix_.first = __m[0].second;
+        __m.__suffix_.first   = __m[0].second;
         __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
         return true;
+      }
+      __m.__matches_.assign(__m.size(), __m.__unmatched_);
     }
-    if (__first != __last && !(__flags & regex_constants::match_continuous))
-    {
-        __flags |= regex_constants::match_prev_avail;
-        for (++__first; __first != __last; ++__first)
-        {
-            __m.__matches_.assign(__m.size(), __m.__unmatched_);
-            if (__match_at_start(__first, __last, __m, __flags, false))
-            {
-                __m.__prefix_.second = __m[0].first;
-                __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
-                __m.__suffix_.first = __m[0].second;
-                __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
-                return true;
-            }
-            __m.__matches_.assign(__m.size(), __m.__unmatched_);
-        }
+    __m.__matches_.assign(__m.size(), __m.__unmatched_);
+    if (__match_at_start(__first, __last, __m, __flags, false)) {
+      __m.__prefix_.second  = __m[0].first;
+      __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
+      __m.__suffix_.first   = __m[0].second;
+      __m.__suffix_.matched = __m.__suffix_.first != __m.__suffix_.second;
+      return true;
     }
-    __m.__matches_.clear();
-    return false;
+  }
+  __m.__matches_.clear();
+  return false;
 }
 
 template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last,
+inline _LIBCPP_HIDE_FROM_ABI bool
+regex_search(_BidirectionalIterator __first,
+             _BidirectionalIterator __last,
              match_results<_BidirectionalIterator, _Allocator>& __m,
              const basic_regex<_CharT, _Traits>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    int __offset = (__flags & regex_constants::match_prev_avail) ? 1 : 0;
-    basic_string<_CharT> __s(_VSTD::prev(__first, __offset), __last);
-    match_results<const _CharT*> __mc;
-    bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags);
-    __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
-    return __r;
+             regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  int __offset = (__flags & regex_constants::match_prev_avail) ? 1 : 0;
+  basic_string<_CharT> __s(std::prev(__first, __offset), __last);
+  match_results<const _CharT*> __mc;
+  bool __r = __e.__search(__s.data() + __offset, __s.data() + __s.size(), __mc, __flags);
+  __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
+  return __r;
 }
 
 template <class _Iter, class _Allocator, class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 regex_search(__wrap_iter<_Iter> __first,
              __wrap_iter<_Iter> __last,
              match_results<__wrap_iter<_Iter>, _Allocator>& __m,
              const basic_regex<_CharT, _Traits>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    match_results<const _CharT*> __mc;
-    bool __r = __e.__search(__first.base(), __last.base(), __mc, __flags);
-    __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
-    return __r;
+             regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  match_results<const _CharT*> __mc;
+  bool __r = __e.__search(__first.base(), __last.base(), __mc, __flags);
+  __m.__assign(__first, __last, __mc, __flags & regex_constants::__no_update_pos);
+  return __r;
 }
 
 template <class _Allocator, class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-regex_search(const _CharT* __first, const _CharT* __last,
+inline _LIBCPP_HIDE_FROM_ABI bool
+regex_search(const _CharT* __first,
+             const _CharT* __last,
              match_results<const _CharT*, _Allocator>& __m,
              const basic_regex<_CharT, _Traits>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    return __e.__search(__first, __last, __m, __flags);
+             regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  return __e.__search(__first, __last, __m, __flags);
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-regex_search(_BidirectionalIterator __first, _BidirectionalIterator __last,
+inline _LIBCPP_HIDE_FROM_ABI bool
+regex_search(_BidirectionalIterator __first,
+             _BidirectionalIterator __last,
              const basic_regex<_CharT, _Traits>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    basic_string<_CharT> __s(__first, __last);
-    match_results<const _CharT*> __mc;
-    return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
+             regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  basic_string<_CharT> __s(__first, __last);
+  match_results<const _CharT*> __mc;
+  return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-regex_search(const _CharT* __first, const _CharT* __last,
+inline _LIBCPP_HIDE_FROM_ABI bool
+regex_search(const _CharT* __first,
+             const _CharT* __last,
              const basic_regex<_CharT, _Traits>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    match_results<const _CharT*> __mc;
-    return __e.__search(__first, __last, __mc, __flags);
+             regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  match_results<const _CharT*> __mc;
+  return __e.__search(__first, __last, __mc, __flags);
 }
 
 template <class _CharT, class _Allocator, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-regex_search(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
+inline _LIBCPP_HIDE_FROM_ABI bool
+regex_search(const _CharT* __str,
+             match_results<const _CharT*, _Allocator>& __m,
              const basic_regex<_CharT, _Traits>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    return __e.__search(__str, __str + _Traits::length(__str), __m, __flags);
+             regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  return __e.__search(__str, __str + _Traits::length(__str), __m, __flags);
 }
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-regex_search(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    match_results<const _CharT*> __m;
-    return _VSTD::regex_search(__str, __m, __e, __flags);
+inline _LIBCPP_HIDE_FROM_ABI bool
+regex_search(const _CharT* __str,
+             const basic_regex<_CharT, _Traits>& __e,
+             regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  match_results<const _CharT*> __m;
+  return std::regex_search(__str, __m, __e, __flags);
 }
 
 template <class _ST, class _SA, class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 regex_search(const basic_string<_CharT, _ST, _SA>& __s,
              const basic_regex<_CharT, _Traits>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    match_results<const _CharT*> __mc;
-    return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
+             regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  match_results<const _CharT*> __mc;
+  return __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
 }
 
 template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 regex_search(const basic_string<_CharT, _ST, _SA>& __s,
              match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
              const basic_regex<_CharT, _Traits>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    match_results<const _CharT*> __mc;
-    bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
-    __m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos);
-    return __r;
+             regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  match_results<const _CharT*> __mc;
+  bool __r = __e.__search(__s.data(), __s.data() + __s.size(), __mc, __flags);
+  __m.__assign(__s.begin(), __s.end(), __mc, __flags & regex_constants::__no_update_pos);
+  return __r;
 }
 
 #if _LIBCPP_STD_VER >= 14
 template <class _ST, class _SA, class _Ap, class _Cp, class _Tp>
-bool
-regex_search(const basic_string<_Cp, _ST, _SA>&& __s,
-             match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
-             const basic_regex<_Cp, _Tp>& __e,
-             regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
+bool regex_search(const basic_string<_Cp, _ST, _SA>&& __s,
+                  match_results<typename basic_string<_Cp, _ST, _SA>::const_iterator, _Ap>&,
+                  const basic_regex<_Cp, _Tp>& __e,
+                  regex_constants::match_flag_type __flags = regex_constants::match_default) = delete;
 #endif
 
 // regex_match
 
 template <class _BidirectionalIterator, class _Allocator, class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI bool
-regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
+regex_match(_BidirectionalIterator __first,
+            _BidirectionalIterator __last,
             match_results<_BidirectionalIterator, _Allocator>& __m,
             const basic_regex<_CharT, _Traits>& __e,
-            regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    bool __r = _VSTD::regex_search(
-        __first, __last, __m, __e,
-        __flags | regex_constants::match_continuous |
-        regex_constants::__full_match);
-    if (__r)
-    {
-        __r = !__m.suffix().matched;
-        if (!__r)
-            __m.__matches_.clear();
-    }
-    return __r;
+            regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  bool __r = std::regex_search(
+      __first, __last, __m, __e, __flags | regex_constants::match_continuous | regex_constants::__full_match);
+  if (__r) {
+    __r = !__m.suffix().matched;
+    if (!__r)
+      __m.__matches_.clear();
+  }
+  return __r;
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
+inline _LIBCPP_HIDE_FROM_ABI bool
+regex_match(_BidirectionalIterator __first,
+            _BidirectionalIterator __last,
             const basic_regex<_CharT, _Traits>& __e,
-            regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    match_results<_BidirectionalIterator> __m;
-    return _VSTD::regex_match(__first, __last, __m, __e, __flags);
+            regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  match_results<_BidirectionalIterator> __m;
+  return std::regex_match(__first, __last, __m, __e, __flags);
 }
 
 template <class _CharT, class _Allocator, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-regex_match(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
+inline _LIBCPP_HIDE_FROM_ABI bool
+regex_match(const _CharT* __str,
+            match_results<const _CharT*, _Allocator>& __m,
             const basic_regex<_CharT, _Traits>& __e,
-            regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    return _VSTD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
+            regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  return std::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
 }
 
 template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 regex_match(const basic_string<_CharT, _ST, _SA>& __s,
             match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
             const basic_regex<_CharT, _Traits>& __e,
-            regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
+            regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  return std::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
 }
 
 #if _LIBCPP_STD_VER >= 14
 template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 regex_match(const basic_string<_CharT, _ST, _SA>&& __s,
             match_results<typename basic_string<_CharT, _ST, _SA>::const_iterator, _Allocator>& __m,
             const basic_regex<_CharT, _Traits>& __e,
@@ -6358,558 +5297,505 @@ regex_match(const basic_string<_CharT, _ST, _SA>&& __s,
 #endif
 
 template <class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-regex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
-            regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    return _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
+inline _LIBCPP_HIDE_FROM_ABI bool
+regex_match(const _CharT* __str,
+            const basic_regex<_CharT, _Traits>& __e,
+            regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  return std::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
 }
 
 template <class _ST, class _SA, class _CharT, class _Traits>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 regex_match(const basic_string<_CharT, _ST, _SA>& __s,
             const basic_regex<_CharT, _Traits>& __e,
-            regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags);
+            regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  return std::regex_match(__s.begin(), __s.end(), __e, __flags);
 }
 
 // regex_iterator
 
 template <class _BidirectionalIterator,
-          class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
+          class _CharT  = typename iterator_traits<_BidirectionalIterator>::value_type,
           class _Traits = regex_traits<_CharT> >
-    class _LIBCPP_TEMPLATE_VIS regex_iterator;
+class _LIBCPP_TEMPLATE_VIS regex_iterator;
 
-typedef regex_iterator<const char*>             cregex_iterator;
-typedef regex_iterator<string::const_iterator>  sregex_iterator;
+typedef regex_iterator<const char*> cregex_iterator;
+typedef regex_iterator<string::const_iterator> sregex_iterator;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-typedef regex_iterator<const wchar_t*>          wcregex_iterator;
+typedef regex_iterator<const wchar_t*> wcregex_iterator;
 typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
 #endif
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
-class
-    _LIBCPP_TEMPLATE_VIS
-    _LIBCPP_PREFERRED_NAME(cregex_iterator)
-    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_iterator))
-    _LIBCPP_PREFERRED_NAME(sregex_iterator)
-    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_iterator))
-    regex_iterator
-{
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_PREFERRED_NAME(cregex_iterator)
+    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_iterator)) _LIBCPP_PREFERRED_NAME(sregex_iterator)
+        _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_iterator)) regex_iterator {
 public:
-    typedef basic_regex<_CharT, _Traits>          regex_type;
-    typedef match_results<_BidirectionalIterator> value_type;
-    typedef ptrdiff_t                             difference_type;
-    typedef const value_type*                     pointer;
-    typedef const value_type&                     reference;
-    typedef forward_iterator_tag                  iterator_category;
-
-private:
-    _BidirectionalIterator           __begin_;
-    _BidirectionalIterator           __end_;
-    const regex_type*                __pregex_;
-    regex_constants::match_flag_type __flags_;
-    value_type                       __match_;
-
-public:
-    regex_iterator();
-    regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                   const regex_type& __re,
-                   regex_constants::match_flag_type __m
-                                              = regex_constants::match_default);
-#if _LIBCPP_STD_VER >= 14
-    regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                   const regex_type&& __re,
-                   regex_constants::match_flag_type __m
-                                     = regex_constants::match_default) = delete;
+  typedef basic_regex<_CharT, _Traits> regex_type;
+  typedef match_results<_BidirectionalIterator> value_type;
+  typedef ptrdiff_t difference_type;
+  typedef const value_type* pointer;
+  typedef const value_type& reference;
+  typedef forward_iterator_tag iterator_category;
+#if _LIBCPP_STD_VER >= 20
+  typedef input_iterator_tag iterator_concept;
 #endif
 
-    bool operator==(const regex_iterator& __x) const;
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const regex_iterator& __x) const {return !(*this == __x);}
+private:
+  _BidirectionalIterator __begin_;
+  _BidirectionalIterator __end_;
+  const regex_type* __pregex_;
+  regex_constants::match_flag_type __flags_;
+  value_type __match_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return  __match_;}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const  {return _VSTD::addressof(__match_);}
+public:
+  regex_iterator();
+  regex_iterator(_BidirectionalIterator __a,
+                 _BidirectionalIterator __b,
+                 const regex_type& __re,
+                 regex_constants::match_flag_type __m = regex_constants::match_default);
+#if _LIBCPP_STD_VER >= 14
+  regex_iterator(_BidirectionalIterator __a,
+                 _BidirectionalIterator __b,
+                 const regex_type&& __re,
+                 regex_constants::match_flag_type __m = regex_constants::match_default) = delete;
+#endif
 
-    regex_iterator& operator++();
-    _LIBCPP_INLINE_VISIBILITY
-    regex_iterator operator++(int)
-    {
-        regex_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI bool operator==(const regex_iterator& __x) const;
+#if _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI bool operator==(default_sentinel_t) const { return *this == regex_iterator(); }
+#endif
+#if _LIBCPP_STD_VER < 20
+  _LIBCPP_HIDE_FROM_ABI bool operator!=(const regex_iterator& __x) const { return !(*this == __x); }
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __match_; }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return std::addressof(__match_); }
+
+  regex_iterator& operator++();
+  _LIBCPP_HIDE_FROM_ABI regex_iterator operator++(int) {
+    regex_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 };
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_iterator()
-    : __begin_(), __end_(), __pregex_(nullptr), __flags_(), __match_()
-{
+    : __begin_(), __end_(), __pregex_(nullptr), __flags_(), __match_() {}
+
+template <class _BidirectionalIterator, class _CharT, class _Traits>
+regex_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_iterator(
+    _BidirectionalIterator __a,
+    _BidirectionalIterator __b,
+    const regex_type& __re,
+    regex_constants::match_flag_type __m)
+    : __begin_(__a), __end_(__b), __pregex_(std::addressof(__re)), __flags_(__m) {
+  std::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
-regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    regex_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                   const regex_type& __re, regex_constants::match_flag_type __m)
-    : __begin_(__a),
-      __end_(__b),
-      __pregex_(_VSTD::addressof(__re)),
-      __flags_(__m)
-{
-    _VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
-}
-
-template <class _BidirectionalIterator, class _CharT, class _Traits>
-bool
-regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    operator==(const regex_iterator& __x) const
-{
-    if (__match_.empty() && __x.__match_.empty())
-        return true;
-    if (__match_.empty() || __x.__match_.empty())
-        return false;
-    return __begin_ == __x.__begin_       &&
-           __end_ == __x.__end_           &&
-           __pregex_ == __x.__pregex_     &&
-           __flags_ == __x.__flags_       &&
-           __match_[0] == __x.__match_[0];
+bool regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator==(const regex_iterator& __x) const {
+  if (__match_.empty() && __x.__match_.empty())
+    return true;
+  if (__match_.empty() || __x.__match_.empty())
+    return false;
+  return __begin_ == __x.__begin_ && __end_ == __x.__end_ && __pregex_ == __x.__pregex_ && __flags_ == __x.__flags_ &&
+         __match_[0] == __x.__match_[0];
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_iterator<_BidirectionalIterator, _CharT, _Traits>&
-regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
-{
-    __flags_ |= regex_constants::__no_update_pos;
-    _BidirectionalIterator __start = __match_[0].second;
-    if (__match_[0].first == __match_[0].second)
-    {
-        if (__start == __end_)
-        {
-            __match_ = value_type();
-            return *this;
-        }
-        else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
-                                    __flags_ | regex_constants::match_not_null |
-                                    regex_constants::match_continuous))
-            return *this;
-        else
-            ++__start;
-    }
-    __flags_ |= regex_constants::match_prev_avail;
-    if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
-        __match_ = value_type();
-    return *this;
+regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++() {
+  __flags_ |= regex_constants::__no_update_pos;
+  _BidirectionalIterator __start        = __match_[0].second;
+  _BidirectionalIterator __prefix_start = __start;
+
+  if (__match_[0].first == __match_[0].second) {
+    if (__start == __end_) {
+      __match_ = value_type();
+      return *this;
+    } else if (std::regex_search(__start,
+                                 __end_,
+                                 __match_,
+                                 *__pregex_,
+                                 __flags_ | regex_constants::match_not_null | regex_constants::match_continuous))
+      return *this;
+    else
+      ++__start;
+  }
+
+  __flags_ |= regex_constants::match_prev_avail;
+  if (!std::regex_search(__start, __end_, __match_, *__pregex_, __flags_)) {
+    __match_ = value_type();
+
+  } else {
+    // The Standard mandates that if `regex_search` returns true ([re.regiter.incr]), "`match.prefix().first` shall be
+    // equal to the previous value of `match[0].second`... It is unspecified how the implementation makes these
+    // adjustments." The adjustment is necessary if we incremented `__start` above (the branch that deals with
+    // zero-length matches).
+    auto& __prefix   = __match_.__prefix_;
+    __prefix.first   = __prefix_start;
+    __prefix.matched = __prefix.first != __prefix.second;
+  }
+
+  return *this;
 }
 
 // regex_token_iterator
 
 template <class _BidirectionalIterator,
-          class _CharT = typename iterator_traits<_BidirectionalIterator>::value_type,
+          class _CharT  = typename iterator_traits<_BidirectionalIterator>::value_type,
           class _Traits = regex_traits<_CharT> >
-    class _LIBCPP_TEMPLATE_VIS regex_token_iterator;
+class _LIBCPP_TEMPLATE_VIS regex_token_iterator;
 
-typedef regex_token_iterator<const char*>             cregex_token_iterator;
-typedef regex_token_iterator<string::const_iterator>  sregex_token_iterator;
+typedef regex_token_iterator<const char*> cregex_token_iterator;
+typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-typedef regex_token_iterator<const wchar_t*>          wcregex_token_iterator;
+typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
 typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
 #endif
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
-class
-    _LIBCPP_TEMPLATE_VIS
-    _LIBCPP_PREFERRED_NAME(cregex_token_iterator)
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_PREFERRED_NAME(cregex_token_iterator)
     _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wcregex_token_iterator))
-    _LIBCPP_PREFERRED_NAME(sregex_token_iterator)
-    _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_token_iterator))
-    regex_token_iterator
-{
+        _LIBCPP_PREFERRED_NAME(sregex_token_iterator)
+            _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wsregex_token_iterator)) regex_token_iterator {
 public:
-    typedef basic_regex<_CharT, _Traits>      regex_type;
-    typedef sub_match<_BidirectionalIterator> value_type;
-    typedef ptrdiff_t                         difference_type;
-    typedef const value_type*                 pointer;
-    typedef const value_type&                 reference;
-    typedef forward_iterator_tag              iterator_category;
-
-private:
-    typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Position;
-
-    _Position         __position_;
-    const value_type* __result_;
-    value_type        __suffix_;
-    ptrdiff_t         __n_;
-    vector<int>       __subs_;
-
-public:
-    regex_token_iterator();
-    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                         const regex_type& __re, int __submatch = 0,
-                         regex_constants::match_flag_type __m =
-                                                regex_constants::match_default);
-#if _LIBCPP_STD_VER >= 14
-    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                         const regex_type&& __re, int __submatch = 0,
-                         regex_constants::match_flag_type __m =
-                                       regex_constants::match_default) = delete;
+  typedef basic_regex<_CharT, _Traits> regex_type;
+  typedef sub_match<_BidirectionalIterator> value_type;
+  typedef ptrdiff_t difference_type;
+  typedef const value_type* pointer;
+  typedef const value_type& reference;
+  typedef forward_iterator_tag iterator_category;
+#if _LIBCPP_STD_VER >= 20
+  typedef input_iterator_tag iterator_concept;
 #endif
 
-    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                         const regex_type& __re, const vector<int>& __submatches,
-                         regex_constants::match_flag_type __m =
-                                                regex_constants::match_default);
+private:
+  typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Position;
+
+  _Position __position_;
+  const value_type* __result_;
+  value_type __suffix_;
+  ptrdiff_t __n_;
+  vector<int> __subs_;
+
+public:
+  regex_token_iterator();
+  regex_token_iterator(_BidirectionalIterator __a,
+                       _BidirectionalIterator __b,
+                       const regex_type& __re,
+                       int __submatch                       = 0,
+                       regex_constants::match_flag_type __m = regex_constants::match_default);
 #if _LIBCPP_STD_VER >= 14
-    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                         const regex_type&& __re, const vector<int>& __submatches,
-                         regex_constants::match_flag_type __m =
-                                     regex_constants::match_default) = delete;
+  regex_token_iterator(_BidirectionalIterator __a,
+                       _BidirectionalIterator __b,
+                       const regex_type&& __re,
+                       int __submatch                       = 0,
+                       regex_constants::match_flag_type __m = regex_constants::match_default) = delete;
+#endif
+
+  regex_token_iterator(_BidirectionalIterator __a,
+                       _BidirectionalIterator __b,
+                       const regex_type& __re,
+                       const vector<int>& __submatches,
+                       regex_constants::match_flag_type __m = regex_constants::match_default);
+#if _LIBCPP_STD_VER >= 14
+  regex_token_iterator(_BidirectionalIterator __a,
+                       _BidirectionalIterator __b,
+                       const regex_type&& __re,
+                       const vector<int>& __submatches,
+                       regex_constants::match_flag_type __m = regex_constants::match_default) = delete;
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
-    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                         const regex_type& __re,
-                         initializer_list<int> __submatches,
-                         regex_constants::match_flag_type __m =
-                                                regex_constants::match_default);
+  regex_token_iterator(_BidirectionalIterator __a,
+                       _BidirectionalIterator __b,
+                       const regex_type& __re,
+                       initializer_list<int> __submatches,
+                       regex_constants::match_flag_type __m = regex_constants::match_default);
 
-#if _LIBCPP_STD_VER >= 14
-    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                         const regex_type&& __re,
-                         initializer_list<int> __submatches,
-                         regex_constants::match_flag_type __m =
-                                       regex_constants::match_default) = delete;
-#endif
+#  if _LIBCPP_STD_VER >= 14
+  regex_token_iterator(_BidirectionalIterator __a,
+                       _BidirectionalIterator __b,
+                       const regex_type&& __re,
+                       initializer_list<int> __submatches,
+                       regex_constants::match_flag_type __m = regex_constants::match_default) = delete;
+#  endif
 #endif // _LIBCPP_CXX03_LANG
-    template <size_t _Np>
-        regex_token_iterator(_BidirectionalIterator __a,
-                             _BidirectionalIterator __b,
-                             const regex_type& __re,
-                             const int (&__submatches)[_Np],
-                             regex_constants::match_flag_type __m =
-                                                regex_constants::match_default);
+  template <size_t _Np>
+  regex_token_iterator(_BidirectionalIterator __a,
+                       _BidirectionalIterator __b,
+                       const regex_type& __re,
+                       const int (&__submatches)[_Np],
+                       regex_constants::match_flag_type __m = regex_constants::match_default);
 #if _LIBCPP_STD_VER >= 14
-    template <size_t _Np>
-        regex_token_iterator(_BidirectionalIterator __a,
-                             _BidirectionalIterator __b,
-                             const regex_type&& __re,
-                             const int (&__submatches)[_Np],
-                             regex_constants::match_flag_type __m =
-                                      regex_constants::match_default) = delete;
+  template <size_t _Np>
+  regex_token_iterator(_BidirectionalIterator __a,
+                       _BidirectionalIterator __b,
+                       const regex_type&& __re,
+                       const int (&__submatches)[_Np],
+                       regex_constants::match_flag_type __m = regex_constants::match_default) = delete;
 #endif
 
-    regex_token_iterator(const regex_token_iterator&);
-    regex_token_iterator& operator=(const regex_token_iterator&);
+  regex_token_iterator(const regex_token_iterator&);
+  regex_token_iterator& operator=(const regex_token_iterator&);
 
-    bool operator==(const regex_token_iterator& __x) const;
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const regex_token_iterator& __x) const {return !(*this == __x);}
+  _LIBCPP_HIDE_FROM_ABI bool operator==(const regex_token_iterator& __x) const;
+#if _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI bool operator==(default_sentinel_t) const {
+    return *this == regex_token_iterator();
+  }
+#endif
+#if _LIBCPP_STD_VER < 20
+  _LIBCPP_HIDE_FROM_ABI bool operator!=(const regex_token_iterator& __x) const { return !(*this == __x); }
+#endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type& operator*() const {return *__result_;}
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type* operator->() const {return __result_;}
+  _LIBCPP_HIDE_FROM_ABI const value_type& operator*() const { return *__result_; }
+  _LIBCPP_HIDE_FROM_ABI const value_type* operator->() const { return __result_; }
 
-    regex_token_iterator& operator++();
-    _LIBCPP_INLINE_VISIBILITY
-    regex_token_iterator operator++(int)
-    {
-        regex_token_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
+  regex_token_iterator& operator++();
+  _LIBCPP_HIDE_FROM_ABI regex_token_iterator operator++(int) {
+    regex_token_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
 private:
-    void __init(_BidirectionalIterator __a, _BidirectionalIterator __b);
-    void __establish_result () {
-        if (__subs_[__n_] == -1)
-            __result_ = &__position_->prefix();
-        else
-            __result_ = &(*__position_)[__subs_[__n_]];
-        }
+  void __init(_BidirectionalIterator __a, _BidirectionalIterator __b);
+  void __establish_result() {
+    if (__subs_[__n_] == -1)
+      __result_ = &__position_->prefix();
+    else
+      __result_ = &(*__position_)[__subs_[__n_]];
+  }
 };
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    regex_token_iterator()
-    : __result_(nullptr),
-      __suffix_(),
-      __n_(0)
-{
+regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator()
+    : __result_(nullptr), __suffix_(), __n_(0) {}
+
+template <class _BidirectionalIterator, class _CharT, class _Traits>
+void regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::__init(
+    _BidirectionalIterator __a, _BidirectionalIterator __b) {
+  if (__position_ != _Position())
+    __establish_result();
+  else if (__subs_[__n_] == -1) {
+    __suffix_.matched = true;
+    __suffix_.first   = __a;
+    __suffix_.second  = __b;
+    __result_         = &__suffix_;
+  } else
+    __result_ = nullptr;
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
-void
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    __init(_BidirectionalIterator __a, _BidirectionalIterator __b)
-{
-    if (__position_ != _Position())
-        __establish_result ();
-    else if (__subs_[__n_] == -1)
-    {
-        __suffix_.matched = true;
-        __suffix_.first = __a;
-        __suffix_.second = __b;
-        __result_ = &__suffix_;
-    }
-    else
-        __result_ = nullptr;
+regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator(
+    _BidirectionalIterator __a,
+    _BidirectionalIterator __b,
+    const regex_type& __re,
+    int __submatch,
+    regex_constants::match_flag_type __m)
+    : __position_(__a, __b, __re, __m), __n_(0), __subs_(1, __submatch) {
+  __init(__a, __b);
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                         const regex_type& __re, int __submatch,
-                         regex_constants::match_flag_type __m)
-    : __position_(__a, __b, __re, __m),
-      __n_(0),
-      __subs_(1, __submatch)
-{
-    __init(__a, __b);
-}
-
-template <class _BidirectionalIterator, class _CharT, class _Traits>
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                         const regex_type& __re, const vector<int>& __submatches,
-                         regex_constants::match_flag_type __m)
-    : __position_(__a, __b, __re, __m),
-      __n_(0),
-      __subs_(__submatches)
-{
-    __init(__a, __b);
+regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator(
+    _BidirectionalIterator __a,
+    _BidirectionalIterator __b,
+    const regex_type& __re,
+    const vector<int>& __submatches,
+    regex_constants::match_flag_type __m)
+    : __position_(__a, __b, __re, __m), __n_(0), __subs_(__submatches) {
+  __init(__a, __b);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                         const regex_type& __re,
-                         initializer_list<int> __submatches,
-                         regex_constants::match_flag_type __m)
-    : __position_(__a, __b, __re, __m),
-      __n_(0),
-      __subs_(__submatches)
-{
-    __init(__a, __b);
+regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator(
+    _BidirectionalIterator __a,
+    _BidirectionalIterator __b,
+    const regex_type& __re,
+    initializer_list<int> __submatches,
+    regex_constants::match_flag_type __m)
+    : __position_(__a, __b, __re, __m), __n_(0), __subs_(__submatches) {
+  __init(__a, __b);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 template <size_t _Np>
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
-                             const regex_type& __re,
-                             const int (&__submatches)[_Np],
-                             regex_constants::match_flag_type __m)
-    : __position_(__a, __b, __re, __m),
-      __n_(0),
-      __subs_(begin(__submatches), end(__submatches))
-{
-    __init(__a, __b);
+regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator(
+    _BidirectionalIterator __a,
+    _BidirectionalIterator __b,
+    const regex_type& __re,
+    const int (&__submatches)[_Np],
+    regex_constants::match_flag_type __m)
+    : __position_(__a, __b, __re, __m), __n_(0), __subs_(begin(__submatches), end(__submatches)) {
+  __init(__a, __b);
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    regex_token_iterator(const regex_token_iterator& __x)
+regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::regex_token_iterator(const regex_token_iterator& __x)
     : __position_(__x.__position_),
       __result_(__x.__result_),
       __suffix_(__x.__suffix_),
       __n_(__x.__n_),
-      __subs_(__x.__subs_)
-{
+      __subs_(__x.__subs_) {
+  if (__x.__result_ == &__x.__suffix_)
+    __result_ = &__suffix_;
+  else if (__result_ != nullptr)
+    __establish_result();
+}
+
+template <class _BidirectionalIterator, class _CharT, class _Traits>
+regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
+regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator=(const regex_token_iterator& __x) {
+  if (this != &__x) {
+    __position_ = __x.__position_;
     if (__x.__result_ == &__x.__suffix_)
-        __result_ = &__suffix_;
-    else if ( __result_ != nullptr )
-        __establish_result ();
-}
-
-template <class _BidirectionalIterator, class _CharT, class _Traits>
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    operator=(const regex_token_iterator& __x)
-{
-    if (this != &__x)
-    {
-        __position_ = __x.__position_;
-        if (__x.__result_ == &__x.__suffix_)
-            __result_ = &__suffix_;
-        else
-            __result_ = __x.__result_;
-        __suffix_ = __x.__suffix_;
-        __n_ = __x.__n_;
-        __subs_ = __x.__subs_;
-
-        if ( __result_ != nullptr && __result_ != &__suffix_ )
-            __establish_result();
-    }
-    return *this;
-}
-
-template <class _BidirectionalIterator, class _CharT, class _Traits>
-bool
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
-    operator==(const regex_token_iterator& __x) const
-{
-    if (__result_ == nullptr && __x.__result_ == nullptr)
-        return true;
-    if (__result_ == &__suffix_ && __x.__result_ == &__x.__suffix_ &&
-            __suffix_ == __x.__suffix_)
-        return true;
-    if (__result_ == nullptr || __x.__result_ == nullptr)
-        return false;
-    if (__result_ == &__suffix_ || __x.__result_ == &__x.__suffix_)
-        return false;
-    return __position_ == __x.__position_ && __n_ == __x.__n_ &&
-           __subs_ == __x.__subs_;
-}
-
-template <class _BidirectionalIterator, class _CharT, class _Traits>
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
-regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
-{
-    _Position __prev = __position_;
-    if (__result_ == &__suffix_)
-        __result_ = nullptr;
-    else if (static_cast<size_t>(__n_ + 1) < __subs_.size())
-    {
-        ++__n_;
-        __establish_result();
-    }
+      __result_ = &__suffix_;
     else
-    {
-        __n_ = 0;
-        ++__position_;
-        if (__position_ != _Position())
-            __establish_result();
-        else
-        {
-            if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
-                && __prev->suffix().length() != 0)
-            {
-                __suffix_.matched = true;
-                __suffix_.first = __prev->suffix().first;
-                __suffix_.second = __prev->suffix().second;
-                __result_ = &__suffix_;
-            }
-            else
-                __result_ = nullptr;
-        }
+      __result_ = __x.__result_;
+    __suffix_ = __x.__suffix_;
+    __n_      = __x.__n_;
+    __subs_   = __x.__subs_;
+
+    if (__result_ != nullptr && __result_ != &__suffix_)
+      __establish_result();
+  }
+  return *this;
+}
+
+template <class _BidirectionalIterator, class _CharT, class _Traits>
+bool regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator==(const regex_token_iterator& __x) const {
+  if (__result_ == nullptr && __x.__result_ == nullptr)
+    return true;
+  if (__result_ == &__suffix_ && __x.__result_ == &__x.__suffix_ && __suffix_ == __x.__suffix_)
+    return true;
+  if (__result_ == nullptr || __x.__result_ == nullptr)
+    return false;
+  if (__result_ == &__suffix_ || __x.__result_ == &__x.__suffix_)
+    return false;
+  return __position_ == __x.__position_ && __n_ == __x.__n_ && __subs_ == __x.__subs_;
+}
+
+template <class _BidirectionalIterator, class _CharT, class _Traits>
+regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>&
+regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++() {
+  _Position __prev = __position_;
+  if (__result_ == &__suffix_)
+    __result_ = nullptr;
+  else if (static_cast<size_t>(__n_ + 1) < __subs_.size()) {
+    ++__n_;
+    __establish_result();
+  } else {
+    __n_ = 0;
+    ++__position_;
+    if (__position_ != _Position())
+      __establish_result();
+    else {
+      if (std::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end() && __prev->suffix().length() != 0) {
+        __suffix_.matched = true;
+        __suffix_.first   = __prev->suffix().first;
+        __suffix_.second  = __prev->suffix().second;
+        __result_         = &__suffix_;
+      } else
+        __result_ = nullptr;
     }
-    return *this;
+  }
+  return *this;
 }
 
 // regex_replace
 
-template <class _OutputIterator, class _BidirectionalIterator,
-          class _Traits, class _CharT>
-_LIBCPP_HIDE_FROM_ABI _OutputIterator
-regex_replace(_OutputIterator __output_iter,
-              _BidirectionalIterator __first, _BidirectionalIterator __last,
-              const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
-              regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Iter;
-    _Iter __i(__first, __last, __e, __flags);
-    _Iter __eof;
-    if (__i == __eof)
-    {
-        if (!(__flags & regex_constants::format_no_copy))
-            __output_iter = _VSTD::copy(__first, __last, __output_iter);
+template <class _OutputIterator, class _BidirectionalIterator, class _Traits, class _CharT>
+_LIBCPP_HIDE_FROM_ABI _OutputIterator regex_replace(
+    _OutputIterator __output_iter,
+    _BidirectionalIterator __first,
+    _BidirectionalIterator __last,
+    const basic_regex<_CharT, _Traits>& __e,
+    const _CharT* __fmt,
+    regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  typedef regex_iterator<_BidirectionalIterator, _CharT, _Traits> _Iter;
+  _Iter __i(__first, __last, __e, __flags);
+  _Iter __eof;
+  if (__i == __eof) {
+    if (!(__flags & regex_constants::format_no_copy))
+      __output_iter = std::copy(__first, __last, __output_iter);
+  } else {
+    sub_match<_BidirectionalIterator> __lm;
+    for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i) {
+      if (!(__flags & regex_constants::format_no_copy))
+        __output_iter = std::copy(__i->prefix().first, __i->prefix().second, __output_iter);
+      __output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags);
+      __lm          = __i->suffix();
+      if (__flags & regex_constants::format_first_only)
+        break;
     }
-    else
-    {
-        sub_match<_BidirectionalIterator> __lm;
-        for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i)
-        {
-            if (!(__flags & regex_constants::format_no_copy))
-                __output_iter = _VSTD::copy(__i->prefix().first, __i->prefix().second, __output_iter);
-            __output_iter = __i->format(__output_iter, __fmt, __fmt + __len, __flags);
-            __lm = __i->suffix();
-            if (__flags & regex_constants::format_first_only)
-                break;
-        }
-        if (!(__flags & regex_constants::format_no_copy))
-            __output_iter = _VSTD::copy(__lm.first, __lm.second, __output_iter);
-    }
-    return __output_iter;
+    if (!(__flags & regex_constants::format_no_copy))
+      __output_iter = std::copy(__lm.first, __lm.second, __output_iter);
+  }
+  return __output_iter;
 }
 
-template <class _OutputIterator, class _BidirectionalIterator,
-          class _Traits, class _CharT, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-_OutputIterator
-regex_replace(_OutputIterator __output_iter,
-              _BidirectionalIterator __first, _BidirectionalIterator __last,
-              const basic_regex<_CharT, _Traits>& __e,
-              const basic_string<_CharT, _ST, _SA>& __fmt,
-              regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    return _VSTD::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags);
+template <class _OutputIterator, class _BidirectionalIterator, class _Traits, class _CharT, class _ST, class _SA>
+inline _LIBCPP_HIDE_FROM_ABI _OutputIterator regex_replace(
+    _OutputIterator __output_iter,
+    _BidirectionalIterator __first,
+    _BidirectionalIterator __last,
+    const basic_regex<_CharT, _Traits>& __e,
+    const basic_string<_CharT, _ST, _SA>& __fmt,
+    regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  return std::regex_replace(__output_iter, __first, __last, __e, __fmt.c_str(), __flags);
 }
 
-template <class _Traits, class _CharT, class _ST, class _SA, class _FST,
-          class _FSA>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _ST, _SA>
+template <class _Traits, class _CharT, class _ST, class _SA, class _FST, class _FSA>
+inline _LIBCPP_HIDE_FROM_ABI basic_string<_CharT, _ST, _SA>
 regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
               const basic_regex<_CharT, _Traits>& __e,
               const basic_string<_CharT, _FST, _FSA>& __fmt,
-              regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    basic_string<_CharT, _ST, _SA> __r;
-    _VSTD::regex_replace(std::back_inserter(__r), __s.begin(), __s.end(), __e,
-                        __fmt.c_str(), __flags);
-    return __r;
+              regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  basic_string<_CharT, _ST, _SA> __r;
+  std::regex_replace(std::back_inserter(__r), __s.begin(), __s.end(), __e, __fmt.c_str(), __flags);
+  return __r;
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT, _ST, _SA>
+inline _LIBCPP_HIDE_FROM_ABI basic_string<_CharT, _ST, _SA>
 regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
-              const basic_regex<_CharT, _Traits>& __e, const _CharT* __fmt,
-              regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    basic_string<_CharT, _ST, _SA> __r;
-    _VSTD::regex_replace(std::back_inserter(__r), __s.begin(), __s.end(), __e,
-                        __fmt, __flags);
-    return __r;
+              const basic_regex<_CharT, _Traits>& __e,
+              const _CharT* __fmt,
+              regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  basic_string<_CharT, _ST, _SA> __r;
+  std::regex_replace(std::back_inserter(__r), __s.begin(), __s.end(), __e, __fmt, __flags);
+  return __r;
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT>
+inline _LIBCPP_HIDE_FROM_ABI basic_string<_CharT>
 regex_replace(const _CharT* __s,
               const basic_regex<_CharT, _Traits>& __e,
               const basic_string<_CharT, _ST, _SA>& __fmt,
-              regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    basic_string<_CharT> __r;
-    _VSTD::regex_replace(std::back_inserter(__r), __s,
-                        __s + char_traits<_CharT>::length(__s), __e,
-                        __fmt.c_str(), __flags);
-    return __r;
+              regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  basic_string<_CharT> __r;
+  std::regex_replace(std::back_inserter(__r), __s, __s + char_traits<_CharT>::length(__s), __e, __fmt.c_str(), __flags);
+  return __r;
 }
 
 template <class _Traits, class _CharT>
-inline _LIBCPP_INLINE_VISIBILITY
-basic_string<_CharT>
+inline _LIBCPP_HIDE_FROM_ABI basic_string<_CharT>
 regex_replace(const _CharT* __s,
               const basic_regex<_CharT, _Traits>& __e,
               const _CharT* __fmt,
-              regex_constants::match_flag_type __flags = regex_constants::match_default)
-{
-    basic_string<_CharT> __r;
-    _VSTD::regex_replace(std::back_inserter(__r), __s,
-                        __s + char_traits<_CharT>::length(__s), __e,
-                        __fmt, __flags);
-    return __r;
+              regex_constants::match_flag_type __flags = regex_constants::match_default) {
+  basic_string<_CharT> __r;
+  std::regex_replace(std::back_inserter(__r), __s, __s + char_traits<_CharT>::length(__s), __e, __fmt, __flags);
+  return __r;
 }
 
 _LIBCPP_END_NAMESPACE_STD
@@ -6918,15 +5804,16 @@ _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _BidirT>
-using match_results = std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>;
+using match_results _LIBCPP_AVAILABILITY_PMR =
+    std::match_results<_BidirT, polymorphic_allocator<std::sub_match<_BidirT>>>;
 
-using cmatch  = match_results<const char*>;
-using smatch  = match_results<std::pmr::string::const_iterator>;
+using cmatch _LIBCPP_AVAILABILITY_PMR = match_results<const char*>;
+using smatch _LIBCPP_AVAILABILITY_PMR = match_results<std::pmr::string::const_iterator>;
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-using wcmatch = match_results<const wchar_t*>;
-using wsmatch = match_results<std::pmr::wstring::const_iterator>;
-#endif
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using wcmatch _LIBCPP_AVAILABILITY_PMR = match_results<const wchar_t*>;
+using wsmatch _LIBCPP_AVAILABILITY_PMR = match_results<std::pmr::wstring::const_iterator>;
+#  endif
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
@@ -6939,6 +5826,7 @@ _LIBCPP_POP_MACROS
 #  include <cstdlib>
 #  include <iosfwd>
 #  include <iterator>
+#  include <mutex>
 #  include <new>
 #  include <type_traits>
 #  include <typeinfo>
diff --git a/third_party/libcxx/regex.cpp b/third_party/libcxx/regex.cpp
new file mode 100644
index 000000000..9dc0c6985
--- /dev/null
+++ b/third_party/libcxx/regex.cpp
@@ -0,0 +1,399 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <algorithm>
+#include <iterator>
+#include <regex>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+static const char* make_error_type_string(regex_constants::error_type ecode) {
+  switch (ecode) {
+  case regex_constants::error_collate:
+    return "The expression contained an invalid collating element name.";
+  case regex_constants::error_ctype:
+    return "The expression contained an invalid character class name.";
+  case regex_constants::error_escape:
+    return "The expression contained an invalid escaped character, or a "
+           "trailing escape.";
+  case regex_constants::error_backref:
+    return "The expression contained an invalid back reference.";
+  case regex_constants::error_brack:
+    return "The expression contained mismatched [ and ].";
+  case regex_constants::error_paren:
+    return "The expression contained mismatched ( and ).";
+  case regex_constants::error_brace:
+    return "The expression contained mismatched { and }.";
+  case regex_constants::error_badbrace:
+    return "The expression contained an invalid range in a {} expression.";
+  case regex_constants::error_range:
+    return "The expression contained an invalid character range, "
+           "such as [b-a] in most encodings.";
+  case regex_constants::error_space:
+    return "There was insufficient memory to convert the expression into "
+           "a finite state machine.";
+  case regex_constants::error_badrepeat:
+    return "One of *?+{ was not preceded by a valid regular expression.";
+  case regex_constants::error_complexity:
+    return "The complexity of an attempted match against a regular "
+           "expression exceeded a pre-set level.";
+  case regex_constants::error_stack:
+    return "There was insufficient memory to determine whether the regular "
+           "expression could match the specified character sequence.";
+  case regex_constants::__re_err_grammar:
+    return "An invalid regex grammar has been requested.";
+  case regex_constants::__re_err_empty:
+    return "An empty regex is not allowed in the POSIX grammar.";
+  case regex_constants::__re_err_parse:
+    return "The parser did not consume the entire regular expression.";
+  default:
+    break;
+  }
+  return "Unknown error type";
+}
+
+regex_error::regex_error(regex_constants::error_type ecode)
+    : runtime_error(make_error_type_string(ecode)), __code_(ecode) {}
+
+regex_error::~regex_error() throw() {}
+
+namespace {
+
+struct collationnames {
+  const char* elem_;
+  char char_;
+};
+
+#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
+// EBCDIC IBM-1047
+// Sorted via the EBCDIC collating sequence
+const collationnames collatenames[] = {
+    {"a", 0x81},
+    {"alert", 0x2f},
+    {"ampersand", 0x50},
+    {"apostrophe", 0x7d},
+    {"asterisk", 0x5c},
+    {"b", 0x82},
+    {"backslash", 0xe0},
+    {"backspace", 0x16},
+    {"c", 0x83},
+    {"carriage-return", 0xd},
+    {"circumflex", 0x5f},
+    {"circumflex-accent", 0x5f},
+    {"colon", 0x7a},
+    {"comma", 0x6b},
+    {"commercial-at", 0x7c},
+    {"d", 0x84},
+    {"dollar-sign", 0x5b},
+    {"e", 0x85},
+    {"eight", 0xf8},
+    {"equals-sign", 0x7e},
+    {"exclamation-mark", 0x5a},
+    {"f", 0x86},
+    {"five", 0xf5},
+    {"form-feed", 0xc},
+    {"four", 0xf4},
+    {"full-stop", 0x4b},
+    {"g", 0x87},
+    {"grave-accent", 0x79},
+    {"greater-than-sign", 0x6e},
+    {"h", 0x88},
+    {"hyphen", 0x60},
+    {"hyphen-minus", 0x60},
+    {"i", 0x89},
+    {"j", 0x91},
+    {"k", 0x92},
+    {"l", 0x93},
+    {"left-brace", 0xc0},
+    {"left-curly-bracket", 0xc0},
+    {"left-parenthesis", 0x4d},
+    {"left-square-bracket", 0xad},
+    {"less-than-sign", 0x4c},
+    {"low-line", 0x6d},
+    {"m", 0x94},
+    {"n", 0x95},
+    {"newline", 0x15},
+    {"nine", 0xf9},
+    {"number-sign", 0x7b},
+    {"o", 0x96},
+    {"one", 0xf1},
+    {"p", 0x97},
+    {"percent-sign", 0x6c},
+    {"period", 0x4b},
+    {"plus-sign", 0x4e},
+    {"q", 0x98},
+    {"question-mark", 0x6f},
+    {"quotation-mark", 0x7f},
+    {"r", 0x99},
+    {"reverse-solidus", 0xe0},
+    {"right-brace", 0xd0},
+    {"right-curly-bracket", 0xd0},
+    {"right-parenthesis", 0x5d},
+    {"right-square-bracket", 0xbd},
+    {"s", 0xa2},
+    {"semicolon", 0x5e},
+    {"seven", 0xf7},
+    {"six", 0xf6},
+    {"slash", 0x61},
+    {"solidus", 0x61},
+    {"space", 0x40},
+    {"t", 0xa3},
+    {"tab", 0x5},
+    {"three", 0xf3},
+    {"tilde", 0xa1},
+    {"two", 0xf2},
+    {"u", 0xa4},
+    {"underscore", 0x6d},
+    {"v", 0xa5},
+    {"vertical-line", 0x4f},
+    {"vertical-tab", 0xb},
+    {"w", 0xa6},
+    {"x", 0xa7},
+    {"y", 0xa8},
+    {"z", 0xa9},
+    {"zero", 0xf0},
+    {"A", 0xc1},
+    {"B", 0xc2},
+    {"C", 0xc3},
+    {"D", 0xc4},
+    {"E", 0xc5},
+    {"F", 0xc6},
+    {"G", 0xc7},
+    {"H", 0xc8},
+    {"I", 0xc9},
+    {"J", 0xd1},
+    {"K", 0xd2},
+    {"L", 0xd3},
+    {"M", 0xd4},
+    {"N", 0xd5},
+    {"NUL", 0},
+    {"O", 0xd6},
+    {"P", 0xd7},
+    {"Q", 0xd8},
+    {"R", 0xd9},
+    {"S", 0xe2},
+    {"T", 0xe3},
+    {"U", 0xe4},
+    {"V", 0xe5},
+    {"W", 0xe6},
+    {"X", 0xe7},
+    {"Y", 0xe8},
+    {"Z", 0xe9}};
+#else
+// ASCII
+const collationnames collatenames[] = {
+    {"A", 0x41},
+    {"B", 0x42},
+    {"C", 0x43},
+    {"D", 0x44},
+    {"E", 0x45},
+    {"F", 0x46},
+    {"G", 0x47},
+    {"H", 0x48},
+    {"I", 0x49},
+    {"J", 0x4a},
+    {"K", 0x4b},
+    {"L", 0x4c},
+    {"M", 0x4d},
+    {"N", 0x4e},
+    {"NUL", 0x00},
+    {"O", 0x4f},
+    {"P", 0x50},
+    {"Q", 0x51},
+    {"R", 0x52},
+    {"S", 0x53},
+    {"T", 0x54},
+    {"U", 0x55},
+    {"V", 0x56},
+    {"W", 0x57},
+    {"X", 0x58},
+    {"Y", 0x59},
+    {"Z", 0x5a},
+    {"a", 0x61},
+    {"alert", 0x07},
+    {"ampersand", 0x26},
+    {"apostrophe", 0x27},
+    {"asterisk", 0x2a},
+    {"b", 0x62},
+    {"backslash", 0x5c},
+    {"backspace", 0x08},
+    {"c", 0x63},
+    {"carriage-return", 0x0d},
+    {"circumflex", 0x5e},
+    {"circumflex-accent", 0x5e},
+    {"colon", 0x3a},
+    {"comma", 0x2c},
+    {"commercial-at", 0x40},
+    {"d", 0x64},
+    {"dollar-sign", 0x24},
+    {"e", 0x65},
+    {"eight", 0x38},
+    {"equals-sign", 0x3d},
+    {"exclamation-mark", 0x21},
+    {"f", 0x66},
+    {"five", 0x35},
+    {"form-feed", 0x0c},
+    {"four", 0x34},
+    {"full-stop", 0x2e},
+    {"g", 0x67},
+    {"grave-accent", 0x60},
+    {"greater-than-sign", 0x3e},
+    {"h", 0x68},
+    {"hyphen", 0x2d},
+    {"hyphen-minus", 0x2d},
+    {"i", 0x69},
+    {"j", 0x6a},
+    {"k", 0x6b},
+    {"l", 0x6c},
+    {"left-brace", 0x7b},
+    {"left-curly-bracket", 0x7b},
+    {"left-parenthesis", 0x28},
+    {"left-square-bracket", 0x5b},
+    {"less-than-sign", 0x3c},
+    {"low-line", 0x5f},
+    {"m", 0x6d},
+    {"n", 0x6e},
+    {"newline", 0x0a},
+    {"nine", 0x39},
+    {"number-sign", 0x23},
+    {"o", 0x6f},
+    {"one", 0x31},
+    {"p", 0x70},
+    {"percent-sign", 0x25},
+    {"period", 0x2e},
+    {"plus-sign", 0x2b},
+    {"q", 0x71},
+    {"question-mark", 0x3f},
+    {"quotation-mark", 0x22},
+    {"r", 0x72},
+    {"reverse-solidus", 0x5c},
+    {"right-brace", 0x7d},
+    {"right-curly-bracket", 0x7d},
+    {"right-parenthesis", 0x29},
+    {"right-square-bracket", 0x5d},
+    {"s", 0x73},
+    {"semicolon", 0x3b},
+    {"seven", 0x37},
+    {"six", 0x36},
+    {"slash", 0x2f},
+    {"solidus", 0x2f},
+    {"space", 0x20},
+    {"t", 0x74},
+    {"tab", 0x09},
+    {"three", 0x33},
+    {"tilde", 0x7e},
+    {"two", 0x32},
+    {"u", 0x75},
+    {"underscore", 0x5f},
+    {"v", 0x76},
+    {"vertical-line", 0x7c},
+    {"vertical-tab", 0x0b},
+    {"w", 0x77},
+    {"x", 0x78},
+    {"y", 0x79},
+    {"z", 0x7a},
+    {"zero", 0x30}};
+#endif
+
+struct classnames {
+  const char* elem_;
+  regex_traits<char>::char_class_type mask_;
+};
+
+const classnames ClassNames[] = {
+    {"alnum", ctype_base::alnum},
+    {"alpha", ctype_base::alpha},
+    {"blank", ctype_base::blank},
+    {"cntrl", ctype_base::cntrl},
+    {"d", ctype_base::digit},
+    {"digit", ctype_base::digit},
+    {"graph", ctype_base::graph},
+    {"lower", ctype_base::lower},
+    {"print", ctype_base::print},
+    {"punct", ctype_base::punct},
+    {"s", ctype_base::space},
+    {"space", ctype_base::space},
+    {"upper", ctype_base::upper},
+    {"w", regex_traits<char>::__regex_word},
+    {"xdigit", ctype_base::xdigit}};
+
+struct use_strcmp {
+  bool operator()(const collationnames& x, const char* y) { return strcmp(x.elem_, y) < 0; }
+  bool operator()(const classnames& x, const char* y) { return strcmp(x.elem_, y) < 0; }
+};
+
+} // namespace
+
+string __get_collation_name(const char* s) {
+  const collationnames* i = std::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
+  string r;
+  if (i != end(collatenames) && strcmp(s, i->elem_) == 0)
+    r = char(i->char_);
+  return r;
+}
+
+regex_traits<char>::char_class_type __get_classname(const char* s, bool __icase) {
+  const classnames* i                   = std::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
+  regex_traits<char>::char_class_type r = 0;
+  if (i != end(ClassNames) && strcmp(s, i->elem_) == 0) {
+    r = i->mask_;
+    if (r == regex_traits<char>::__regex_word)
+      r |= ctype_base::alnum | ctype_base::upper | ctype_base::lower;
+    else if (__icase) {
+      if (r & (ctype_base::lower | ctype_base::upper))
+        r |= ctype_base::alpha;
+    }
+  }
+  return r;
+}
+
+template <>
+void __match_any_but_newline<char>::__exec(__state& __s) const {
+  if (__s.__current_ != __s.__last_) {
+    switch (*__s.__current_) {
+    case '\r':
+    case '\n':
+      __s.__do_   = __state::__reject;
+      __s.__node_ = nullptr;
+      break;
+    default:
+      __s.__do_ = __state::__accept_and_consume;
+      ++__s.__current_;
+      __s.__node_ = this->first();
+      break;
+    }
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
+}
+
+template <>
+void __match_any_but_newline<wchar_t>::__exec(__state& __s) const {
+  if (__s.__current_ != __s.__last_) {
+    switch (*__s.__current_) {
+    case '\r':
+    case '\n':
+    case 0x2028:
+    case 0x2029:
+      __s.__do_   = __state::__reject;
+      __s.__node_ = nullptr;
+      break;
+    default:
+      __s.__do_ = __state::__accept_and_consume;
+      ++__s.__current_;
+      __s.__node_ = this->first();
+      break;
+    }
+  } else {
+    __s.__do_   = __state::__reject;
+    __s.__node_ = nullptr;
+  }
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/ryu/common.h b/third_party/libcxx/ryu/common.h
new file mode 100644
index 000000000..d5168d871
--- /dev/null
+++ b/third_party/libcxx/ryu/common.h
@@ -0,0 +1,109 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// Copyright 2018 Ulf Adams
+// Copyright (c) Microsoft Corporation. All rights reserved.
+
+// Boost Software License - Version 1.0 - August 17th, 2003
+
+// Permission is hereby granted, free of charge, to any person or organization
+// obtaining a copy of the software and accompanying documentation covered by
+// this license (the "Software") to use, reproduce, display, distribute,
+// execute, and transmit the Software, and to prepare derivative works of the
+// Software, and to permit third-parties to whom the Software is furnished to
+// do so, all subject to the following:
+
+// The copyright notices in the Software and this entire statement, including
+// the above license grant, this restriction and the following disclaimer,
+// must be included in all copies of the Software, in whole or in part, and
+// all derivative works of the Software, unless such copies or derivative
+// works are solely in the form of machine-executable object code generated by
+// a source language processor.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+#ifndef _LIBCPP_SRC_INCLUDE_RYU_COMMON_H
+#define _LIBCPP_SRC_INCLUDE_RYU_COMMON_H
+
+// Avoid formatting to keep the changes with the original code minimal.
+// clang-format off
+
+#include <__assert>
+#include <__config>
+#include <cstring>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __decimalLength9(const uint32_t __v) {
+  // Function precondition: __v is not a 10-digit number.
+  // (f2s: 9 digits are sufficient for round-tripping.)
+  // (d2fixed: We print 9-digit blocks.)
+  _LIBCPP_ASSERT_INTERNAL(__v < 1000000000, "");
+  if (__v >= 100000000) { return 9; }
+  if (__v >= 10000000) { return 8; }
+  if (__v >= 1000000) { return 7; }
+  if (__v >= 100000) { return 6; }
+  if (__v >= 10000) { return 5; }
+  if (__v >= 1000) { return 4; }
+  if (__v >= 100) { return 3; }
+  if (__v >= 10) { return 2; }
+  return 1;
+}
+
+// Returns __e == 0 ? 1 : ceil(log_2(5^__e)).
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI  inline int32_t __pow5bits(const int32_t __e) {
+  // This approximation works up to the point that the multiplication overflows at __e = 3529.
+  // If the multiplication were done in 64 bits, it would fail at 5^4004 which is just greater
+  // than 2^9297.
+  _LIBCPP_ASSERT_INTERNAL(__e >= 0, "");
+  _LIBCPP_ASSERT_INTERNAL(__e <= 3528, "");
+  return static_cast<int32_t>(((static_cast<uint32_t>(__e) * 1217359) >> 19) + 1);
+}
+
+// Returns floor(log_10(2^__e)).
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI  inline uint32_t __log10Pow2(const int32_t __e) {
+  // The first value this approximation fails for is 2^1651 which is just greater than 10^297.
+  _LIBCPP_ASSERT_INTERNAL(__e >= 0, "");
+  _LIBCPP_ASSERT_INTERNAL(__e <= 1650, "");
+  return (static_cast<uint32_t>(__e) * 78913) >> 18;
+}
+
+// Returns floor(log_10(5^__e)).
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __log10Pow5(const int32_t __e) {
+  // The first value this approximation fails for is 5^2621 which is just greater than 10^1832.
+  _LIBCPP_ASSERT_INTERNAL(__e >= 0, "");
+  _LIBCPP_ASSERT_INTERNAL(__e <= 2620, "");
+  return (static_cast<uint32_t>(__e) * 732923) >> 20;
+}
+
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __float_to_bits(const float __f) {
+  uint32_t __bits = 0;
+  std::memcpy(&__bits, &__f, sizeof(float));
+  return __bits;
+}
+
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint64_t __double_to_bits(const double __d) {
+  uint64_t __bits = 0;
+  std::memcpy(&__bits, &__d, sizeof(double));
+  return __bits;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+// clang-format on
+
+#endif // _LIBCPP_SRC_INCLUDE_RYU_COMMON_H
diff --git a/third_party/libcxx/src/ryu/d2fixed.cpp b/third_party/libcxx/ryu/d2fixed.cpp
similarity index 98%
rename from third_party/libcxx/src/ryu/d2fixed.cpp
rename to third_party/libcxx/ryu/d2fixed.cpp
index 428d0a5ed..d63649f0f 100644
--- a/third_party/libcxx/src/ryu/d2fixed.cpp
+++ b/third_party/libcxx/ryu/d2fixed.cpp
@@ -44,12 +44,12 @@
 #include <charconv>
 #include <cstring>
 
-#include "third_party/libcxx/src/include/ryu/common.h"
-#include "third_party/libcxx/src/include/ryu/d2fixed.h"
-#include "third_party/libcxx/src/include/ryu/d2fixed_full_table.h"
-#include "third_party/libcxx/src/include/ryu/d2s.h"
-#include "third_party/libcxx/src/include/ryu/d2s_intrinsics.h"
-#include "third_party/libcxx/src/include/ryu/digit_table.h"
+#include "third_party/libcxx/ryu/common.h"
+#include "third_party/libcxx/ryu/d2fixed.h"
+#include "third_party/libcxx/ryu/d2fixed_full_table.h"
+#include "third_party/libcxx/ryu/d2s.h"
+#include "third_party/libcxx/ryu/d2s_intrinsics.h"
+#include "third_party/libcxx/ryu/digit_table.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -102,8 +102,8 @@ inline constexpr int __POW10_ADDITIONAL_BITS = 120;
   const uint64_t __s1low = __low2 + __high1 + __c1; // 128
   const uint32_t __c2 = __s1low < __low2; // __high1 + __c1 can't overflow, so compare against __low2
   const uint64_t __s1high = __high2 + __c2;         // 192
-  _LIBCPP_ASSERT(__j >= 128, "");
-  _LIBCPP_ASSERT(__j <= 180, "");
+  _LIBCPP_ASSERT_INTERNAL(__j >= 128, "");
+  _LIBCPP_ASSERT_INTERNAL(__j <= 180, "");
 #ifdef _LIBCPP_INTRINSIC128
   const uint32_t __dist = static_cast<uint32_t>(__j - 128); // __dist: [0, 52]
   const uint64_t __shiftedhigh = __s1high >> __dist;
diff --git a/third_party/libcxx/src/include/ryu/d2fixed.h b/third_party/libcxx/ryu/d2fixed.h
similarity index 100%
rename from third_party/libcxx/src/include/ryu/d2fixed.h
rename to third_party/libcxx/ryu/d2fixed.h
diff --git a/third_party/libcxx/src/include/ryu/d2fixed_full_table.h b/third_party/libcxx/ryu/d2fixed_full_table.h
similarity index 100%
rename from third_party/libcxx/src/include/ryu/d2fixed_full_table.h
rename to third_party/libcxx/ryu/d2fixed_full_table.h
diff --git a/third_party/libcxx/src/ryu/d2s.cpp b/third_party/libcxx/ryu/d2s.cpp
similarity index 98%
rename from third_party/libcxx/src/ryu/d2s.cpp
rename to third_party/libcxx/ryu/d2s.cpp
index c6322736a..1ba7af563 100644
--- a/third_party/libcxx/src/ryu/d2s.cpp
+++ b/third_party/libcxx/ryu/d2s.cpp
@@ -43,13 +43,13 @@
 #include <__config>
 #include <charconv>
 
-#include "third_party/libcxx/src/include/ryu/common.h"
-#include "third_party/libcxx/src/include/ryu/d2fixed.h"
-#include "third_party/libcxx/src/include/ryu/d2s.h"
-#include "third_party/libcxx/src/include/ryu/d2s_full_table.h"
-#include "third_party/libcxx/src/include/ryu/d2s_intrinsics.h"
-#include "third_party/libcxx/src/include/ryu/digit_table.h"
-#include "third_party/libcxx/src/include/ryu/ryu.h"
+#include "third_party/libcxx/ryu/common.h"
+#include "third_party/libcxx/ryu/d2fixed.h"
+#include "third_party/libcxx/ryu/d2s.h"
+#include "third_party/libcxx/ryu/d2s_full_table.h"
+#include "third_party/libcxx/ryu/d2s_intrinsics.h"
+#include "third_party/libcxx/ryu/digit_table.h"
+#include "third_party/libcxx/ryu/ryu.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -154,7 +154,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
   // The average output length is 16.38 digits, so we check high-to-low.
   // Function precondition: __v is not an 18, 19, or 20-digit number.
   // (17 digits are sufficient for round-tripping.)
-  _LIBCPP_ASSERT(__v < 100000000000000000u, "");
+  _LIBCPP_ASSERT_INTERNAL(__v < 100000000000000000u, "");
   if (__v >= 10000000000000000u) { return 17; }
   if (__v >= 1000000000000000u) { return 16; }
   if (__v >= 100000000000000u) { return 15; }
diff --git a/third_party/libcxx/src/include/ryu/d2s.h b/third_party/libcxx/ryu/d2s.h
similarity index 100%
rename from third_party/libcxx/src/include/ryu/d2s.h
rename to third_party/libcxx/ryu/d2s.h
diff --git a/third_party/libcxx/src/include/ryu/d2s_full_table.h b/third_party/libcxx/ryu/d2s_full_table.h
similarity index 100%
rename from third_party/libcxx/src/include/ryu/d2s_full_table.h
rename to third_party/libcxx/ryu/d2s_full_table.h
diff --git a/third_party/libcxx/src/include/ryu/d2s_intrinsics.h b/third_party/libcxx/ryu/d2s_intrinsics.h
similarity index 96%
rename from third_party/libcxx/src/include/ryu/d2s_intrinsics.h
rename to third_party/libcxx/ryu/d2s_intrinsics.h
index 8790f74c0..a6712bb74 100644
--- a/third_party/libcxx/src/include/ryu/d2s_intrinsics.h
+++ b/third_party/libcxx/ryu/d2s_intrinsics.h
@@ -45,7 +45,7 @@
 #include <__assert>
 #include <__config>
 
-#include "third_party/libcxx/src/include/ryu/ryu.h"
+#include "third_party/libcxx/ryu/ryu.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -63,7 +63,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
   // (The shift value is in the range [49, 58].)
   // Check this here in case a future change requires larger shift
   // values. In this case this function needs to be adjusted.
-  _LIBCPP_ASSERT(__dist < 64, "");
+  _LIBCPP_ASSERT_INTERNAL(__dist < 64, "");
   return __shiftright128(__lo, __hi, static_cast<unsigned char>(__dist));
 }
 
@@ -85,7 +85,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
   // (The shift value is in the range [49, 58].)
   // Check this here in case a future change requires larger shift
   // values. In this case this function needs to be adjusted.
-  _LIBCPP_ASSERT(__dist < 64, "");
+  _LIBCPP_ASSERT_INTERNAL(__dist < 64, "");
   auto __temp = __lo | ((unsigned __int128)__hi << 64);
   // For x64 128-bit shfits using the `shrd` instruction and two 64-bit
   // registers, the shift value is modulo 64.  Thus the `& 63` is free.
@@ -126,13 +126,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint64_t __ryu_shiftright128(const uint64_t __lo, const uint64_t __hi, const uint32_t __dist) {
   // We don't need to handle the case __dist >= 64 here (see above).
-  _LIBCPP_ASSERT(__dist < 64, "");
+  _LIBCPP_ASSERT_INTERNAL(__dist < 64, "");
 #ifdef _LIBCPP_64_BIT
-  _LIBCPP_ASSERT(__dist > 0, "");
+  _LIBCPP_ASSERT_INTERNAL(__dist > 0, "");
   return (__hi << (64 - __dist)) | (__lo >> __dist);
 #else // ^^^ 64-bit ^^^ / vvv 32-bit vvv
   // Avoid a 64-bit shift by taking advantage of the range of shift values.
-  _LIBCPP_ASSERT(__dist >= 32, "");
+  _LIBCPP_ASSERT_INTERNAL(__dist >= 32, "");
   return (__hi << (64 - __dist)) | (static_cast<uint32_t>(__lo >> 32) >> (__dist - 32));
 #endif // ^^^ 32-bit ^^^
 }
@@ -227,7 +227,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __pow5Factor(uint64_t __value) {
   uint32_t __count = 0;
   for (;;) {
-    _LIBCPP_ASSERT(__value != 0, "");
+    _LIBCPP_ASSERT_INTERNAL(__value != 0, "");
     const uint64_t __q = __div5(__value);
     const uint32_t __r = static_cast<uint32_t>(__value) - 5 * static_cast<uint32_t>(__q);
     if (__r != 0) {
@@ -247,8 +247,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Returns true if __value is divisible by 2^__p.
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline bool __multipleOfPowerOf2(const uint64_t __value, const uint32_t __p) {
-  _LIBCPP_ASSERT(__value != 0, "");
-  _LIBCPP_ASSERT(__p < 64, "");
+  _LIBCPP_ASSERT_INTERNAL(__value != 0, "");
+  _LIBCPP_ASSERT_INTERNAL(__p < 64, "");
   // __builtin_ctzll doesn't appear to be faster here.
   return (__value & ((1ull << __p) - 1)) == 0;
 }
diff --git a/third_party/libcxx/src/include/ryu/digit_table.h b/third_party/libcxx/ryu/digit_table.h
similarity index 100%
rename from third_party/libcxx/src/include/ryu/digit_table.h
rename to third_party/libcxx/ryu/digit_table.h
diff --git a/third_party/libcxx/src/ryu/f2s.cpp b/third_party/libcxx/ryu/f2s.cpp
similarity index 97%
rename from third_party/libcxx/src/ryu/f2s.cpp
rename to third_party/libcxx/ryu/f2s.cpp
index 3ef5f2e15..52b7464d3 100644
--- a/third_party/libcxx/src/ryu/f2s.cpp
+++ b/third_party/libcxx/ryu/f2s.cpp
@@ -43,12 +43,12 @@
 #include <__config>
 #include <charconv>
 
-#include "third_party/libcxx/src/include/ryu/common.h"
-#include "third_party/libcxx/src/include/ryu/d2fixed.h"
-#include "third_party/libcxx/src/include/ryu/d2s_intrinsics.h"
-#include "third_party/libcxx/src/include/ryu/digit_table.h"
-#include "third_party/libcxx/src/include/ryu/f2s.h"
-#include "third_party/libcxx/src/include/ryu/ryu.h"
+#include "third_party/libcxx/ryu/common.h"
+#include "third_party/libcxx/ryu/d2fixed.h"
+#include "third_party/libcxx/ryu/d2s_intrinsics.h"
+#include "third_party/libcxx/ryu/digit_table.h"
+#include "third_party/libcxx/ryu/f2s.h"
+#include "third_party/libcxx/ryu/ryu.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -86,7 +86,7 @@ inline constexpr uint64_t __FLOAT_POW5_SPLIT[47] = {
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __pow5Factor(uint32_t __value) {
   uint32_t __count = 0;
   for (;;) {
-    _LIBCPP_ASSERT(__value != 0, "");
+    _LIBCPP_ASSERT_INTERNAL(__value != 0, "");
     const uint32_t __q = __value / 5;
     const uint32_t __r = __value % 5;
     if (__r != 0) {
@@ -105,14 +105,14 @@ inline constexpr uint64_t __FLOAT_POW5_SPLIT[47] = {
 
 // Returns true if __value is divisible by 2^__p.
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline bool __multipleOfPowerOf2(const uint32_t __value, const uint32_t __p) {
-  _LIBCPP_ASSERT(__value != 0, "");
-  _LIBCPP_ASSERT(__p < 32, "");
+  _LIBCPP_ASSERT_INTERNAL(__value != 0, "");
+  _LIBCPP_ASSERT_INTERNAL(__p < 32, "");
   // __builtin_ctz doesn't appear to be faster here.
   return (__value & ((1u << __p) - 1)) == 0;
 }
 
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __mulShift(const uint32_t __m, const uint64_t __factor, const int32_t __shift) {
-  _LIBCPP_ASSERT(__shift > 32, "");
+  _LIBCPP_ASSERT_INTERNAL(__shift > 32, "");
 
   // The casts here help MSVC to avoid calls to the __allmul library
   // function.
@@ -134,7 +134,7 @@ inline constexpr uint64_t __FLOAT_POW5_SPLIT[47] = {
 #else // ^^^ 32-bit ^^^ / vvv 64-bit vvv
   const uint64_t __sum = (__bits0 >> 32) + __bits1;
   const uint64_t __shiftedSum = __sum >> (__shift - 32);
-  _LIBCPP_ASSERT(__shiftedSum <= UINT32_MAX, "");
+  _LIBCPP_ASSERT_INTERNAL(__shiftedSum <= UINT32_MAX, "");
   return static_cast<uint32_t>(__shiftedSum);
 #endif // ^^^ 64-bit ^^^
 }
@@ -309,8 +309,8 @@ struct __floating_decimal_32 {
   // Performance note: Long division appears to be faster than losslessly widening float to double and calling
   // __d2fixed_buffered_n(). If __f2fixed_buffered_n() is implemented, it might be faster than long division.
 
-  _LIBCPP_ASSERT(_Exponent2 > 0, "");
-  _LIBCPP_ASSERT(_Exponent2 <= 104, ""); // because __ieeeExponent <= 254
+  _LIBCPP_ASSERT_INTERNAL(_Exponent2 > 0, "");
+  _LIBCPP_ASSERT_INTERNAL(_Exponent2 <= 104, ""); // because __ieeeExponent <= 254
 
   // Manually represent _Mantissa2 * 2^_Exponent2 as a large integer. _Mantissa2 is always 24 bits
   // (due to the implicit bit), while _Exponent2 indicates a shift of at most 104 bits.
@@ -328,7 +328,7 @@ struct __floating_decimal_32 {
 
   // _Maxidx is the index of the most significant nonzero element.
   uint32_t _Maxidx = ((24 + static_cast<uint32_t>(_Exponent2) + 31) / 32) - 1;
-  _LIBCPP_ASSERT(_Maxidx < _Data_size, "");
+  _LIBCPP_ASSERT_INTERNAL(_Maxidx < _Data_size, "");
 
   const uint32_t _Bit_shift = static_cast<uint32_t>(_Exponent2) % 32;
   if (_Bit_shift <= 8) { // _Mantissa2's 24 bits don't cross an element boundary
@@ -388,9 +388,9 @@ struct __floating_decimal_32 {
     }
   }
 
-  _LIBCPP_ASSERT(_Data[0] != 0, "");
+  _LIBCPP_ASSERT_INTERNAL(_Data[0] != 0, "");
   for (uint32_t _Idx = 1; _Idx < _Data_size; ++_Idx) {
-    _LIBCPP_ASSERT(_Data[_Idx] == 0, "");
+    _LIBCPP_ASSERT_INTERNAL(_Data[_Idx] == 0, "");
   }
 
   const uint32_t _Data_olength = _Data[0] >= 1000000000 ? 10 : __decimalLength9(_Data[0]);
diff --git a/third_party/libcxx/src/include/ryu/f2s.h b/third_party/libcxx/ryu/f2s.h
similarity index 100%
rename from third_party/libcxx/src/include/ryu/f2s.h
rename to third_party/libcxx/ryu/f2s.h
diff --git a/third_party/libcxx/src/include/ryu/ryu.h b/third_party/libcxx/ryu/ryu.h
similarity index 96%
rename from third_party/libcxx/src/include/ryu/ryu.h
rename to third_party/libcxx/ryu/ryu.h
index c694da4cd..ce6fb6aec 100644
--- a/third_party/libcxx/src/include/ryu/ryu.h
+++ b/third_party/libcxx/ryu/ryu.h
@@ -10,7 +10,6 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-
 // Copyright 2018 Ulf Adams
 // Copyright (c) Microsoft Corporation. All rights reserved.
 
@@ -47,15 +46,14 @@
 #include <__charconv/chars_format.h>
 #include <__charconv/to_chars_result.h>
 #include <__config>
-#include <__debug>
 #include <__system_error/errc.h>
 #include <cstdint>
 #include <cstring>
 #include <type_traits>
 
-#include "third_party/libcxx/src/include/ryu/f2s.h"
-#include "third_party/libcxx/src/include/ryu/d2s.h"
-#include "third_party/libcxx/src/include/ryu/d2fixed.h"
+#include "third_party/libcxx/ryu/f2s.h"
+#include "third_party/libcxx/ryu/d2s.h"
+#include "third_party/libcxx/ryu/d2fixed.h"
 
 #if defined(_MSC_VER)
 #include <intrin.h> // for _umul128(), __shiftright128(), _BitScanForward{,64}
diff --git a/third_party/libcxx/scoped_allocator b/third_party/libcxx/scoped_allocator
index bb61a7cd1..a49ff465b 100644
--- a/third_party/libcxx/scoped_allocator
+++ b/third_party/libcxx/scoped_allocator
@@ -103,13 +103,12 @@ template <class OuterA1, class OuterA2, class... InnerAllocs>
 template <class OuterA1, class OuterA2, class... InnerAllocs>
     bool
     operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
-               const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
+               const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept; // removed in C++20
 
 }  // std
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__memory/allocator_traits.h>
 #include <__memory/uses_allocator_construction.h>
@@ -130,592 +129,433 @@ template <class OuterA1, class OuterA2, class... InnerAllocs>
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if !defined(_LIBCPP_CXX03_LANG)
 
 // scoped_allocator_adaptor
 
-template <class ..._Allocs>
+template <class... _Allocs>
 class scoped_allocator_adaptor;
 
-template <class ..._Allocs> struct __get_poc_copy_assignment;
+template <class... _Allocs>
+struct __get_poc_copy_assignment;
 
 template <class _A0>
-struct __get_poc_copy_assignment<_A0>
-{
-    static const bool value = allocator_traits<_A0>::
-                              propagate_on_container_copy_assignment::value;
+struct __get_poc_copy_assignment<_A0> {
+  static const bool value = allocator_traits<_A0>::propagate_on_container_copy_assignment::value;
 };
 
-template <class _A0, class ..._Allocs>
-struct __get_poc_copy_assignment<_A0, _Allocs...>
-{
-    static const bool value =
-        allocator_traits<_A0>::propagate_on_container_copy_assignment::value ||
-        __get_poc_copy_assignment<_Allocs...>::value;
+template <class _A0, class... _Allocs>
+struct __get_poc_copy_assignment<_A0, _Allocs...> {
+  static const bool value = allocator_traits<_A0>::propagate_on_container_copy_assignment::value ||
+                            __get_poc_copy_assignment<_Allocs...>::value;
 };
 
-template <class ..._Allocs> struct __get_poc_move_assignment;
+template <class... _Allocs>
+struct __get_poc_move_assignment;
 
 template <class _A0>
-struct __get_poc_move_assignment<_A0>
-{
-    static const bool value = allocator_traits<_A0>::
-                              propagate_on_container_move_assignment::value;
+struct __get_poc_move_assignment<_A0> {
+  static const bool value = allocator_traits<_A0>::propagate_on_container_move_assignment::value;
 };
 
-template <class _A0, class ..._Allocs>
-struct __get_poc_move_assignment<_A0, _Allocs...>
-{
-    static const bool value =
-        allocator_traits<_A0>::propagate_on_container_move_assignment::value ||
-        __get_poc_move_assignment<_Allocs...>::value;
+template <class _A0, class... _Allocs>
+struct __get_poc_move_assignment<_A0, _Allocs...> {
+  static const bool value = allocator_traits<_A0>::propagate_on_container_move_assignment::value ||
+                            __get_poc_move_assignment<_Allocs...>::value;
 };
 
-template <class ..._Allocs> struct __get_poc_swap;
+template <class... _Allocs>
+struct __get_poc_swap;
 
 template <class _A0>
-struct __get_poc_swap<_A0>
-{
-    static const bool value = allocator_traits<_A0>::
-                              propagate_on_container_swap::value;
+struct __get_poc_swap<_A0> {
+  static const bool value = allocator_traits<_A0>::propagate_on_container_swap::value;
 };
 
-template <class _A0, class ..._Allocs>
-struct __get_poc_swap<_A0, _Allocs...>
-{
-    static const bool value =
-        allocator_traits<_A0>::propagate_on_container_swap::value ||
-        __get_poc_swap<_Allocs...>::value;
+template <class _A0, class... _Allocs>
+struct __get_poc_swap<_A0, _Allocs...> {
+  static const bool value =
+      allocator_traits<_A0>::propagate_on_container_swap::value || __get_poc_swap<_Allocs...>::value;
 };
 
-template <class ..._Allocs> struct __get_is_always_equal;
+template <class... _Allocs>
+struct __get_is_always_equal;
 
 template <class _A0>
-struct __get_is_always_equal<_A0>
-{
-    static const bool value = allocator_traits<_A0>::is_always_equal::value;
+struct __get_is_always_equal<_A0> {
+  static const bool value = allocator_traits<_A0>::is_always_equal::value;
 };
 
-template <class _A0, class ..._Allocs>
-struct __get_is_always_equal<_A0, _Allocs...>
-{
-    static const bool value =
-        allocator_traits<_A0>::is_always_equal::value &&
-        __get_is_always_equal<_Allocs...>::value;
+template <class _A0, class... _Allocs>
+struct __get_is_always_equal<_A0, _Allocs...> {
+  static const bool value = allocator_traits<_A0>::is_always_equal::value && __get_is_always_equal<_Allocs...>::value;
 };
 
-template <class ..._Allocs>
+template <class... _Allocs>
 class __scoped_allocator_storage;
 
 template <class _OuterAlloc, class... _InnerAllocs>
-class __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
-    : public _OuterAlloc
-{
-    typedef _OuterAlloc outer_allocator_type;
+class __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> : public _OuterAlloc {
+  typedef _OuterAlloc outer_allocator_type;
+
 protected:
-    typedef scoped_allocator_adaptor<_InnerAllocs...> inner_allocator_type;
+  typedef scoped_allocator_adaptor<_InnerAllocs...> inner_allocator_type;
 
 private:
-    inner_allocator_type __inner_;
+  inner_allocator_type __inner_;
 
 protected:
+  _LIBCPP_HIDE_FROM_ABI __scoped_allocator_storage() _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __scoped_allocator_storage() _NOEXCEPT {}
+  template <class _OuterA2, __enable_if_t<is_constructible<outer_allocator_type, _OuterA2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  __scoped_allocator_storage(_OuterA2&& __outer_alloc, const _InnerAllocs&... __inner_allocs) _NOEXCEPT
+      : outer_allocator_type(std::forward<_OuterA2>(__outer_alloc)),
+        __inner_(__inner_allocs...) {}
 
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(_OuterA2&& __outer_alloc,
-                                   const _InnerAllocs& ...__inner_allocs) _NOEXCEPT
-            : outer_allocator_type(_VSTD::forward<_OuterA2>(__outer_alloc)),
-              __inner_(__inner_allocs...) {}
+  template <class _OuterA2, __enable_if_t<is_constructible<outer_allocator_type, const _OuterA2&>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  __scoped_allocator_storage(const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
+      : outer_allocator_type(__other.outer_allocator()),
+        __inner_(__other.inner_allocator()) {}
 
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, const _OuterA2&>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(
-            const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
-            : outer_allocator_type(__other.outer_allocator()),
-              __inner_(__other.inner_allocator()) {}
+  template <class _OuterA2, __enable_if_t<is_constructible<outer_allocator_type, _OuterA2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  __scoped_allocator_storage(__scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
+      : outer_allocator_type(std::move(__other.outer_allocator())),
+        __inner_(std::move(__other.inner_allocator())) {}
 
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(
-            __scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
-            : outer_allocator_type(_VSTD::move(__other.outer_allocator())),
-              __inner_(_VSTD::move(__other.inner_allocator())) {}
+  template <class _OuterA2, __enable_if_t<is_constructible<outer_allocator_type, _OuterA2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI __scoped_allocator_storage(_OuterA2&& __o, const inner_allocator_type& __i) _NOEXCEPT
+      : outer_allocator_type(std::forward<_OuterA2>(__o)),
+        __inner_(__i) {}
 
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(_OuterA2&& __o,
-                                   const inner_allocator_type& __i) _NOEXCEPT
-            : outer_allocator_type(_VSTD::forward<_OuterA2>(__o)),
-              __inner_(__i)
-        {
-        }
+  _LIBCPP_HIDE_FROM_ABI inner_allocator_type& inner_allocator() _NOEXCEPT { return __inner_; }
+  _LIBCPP_HIDE_FROM_ABI const inner_allocator_type& inner_allocator() const _NOEXCEPT { return __inner_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    inner_allocator_type& inner_allocator() _NOEXCEPT             {return __inner_;}
-    _LIBCPP_INLINE_VISIBILITY
-    const inner_allocator_type& inner_allocator() const _NOEXCEPT {return __inner_;}
+  _LIBCPP_HIDE_FROM_ABI outer_allocator_type& outer_allocator() _NOEXCEPT {
+    return static_cast<outer_allocator_type&>(*this);
+  }
+  _LIBCPP_HIDE_FROM_ABI const outer_allocator_type& outer_allocator() const _NOEXCEPT {
+    return static_cast<const outer_allocator_type&>(*this);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    outer_allocator_type& outer_allocator() _NOEXCEPT
-        {return static_cast<outer_allocator_type&>(*this);}
-    _LIBCPP_INLINE_VISIBILITY
-    const outer_allocator_type& outer_allocator() const _NOEXCEPT
-        {return static_cast<const outer_allocator_type&>(*this);}
+  scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...> _LIBCPP_HIDE_FROM_ABI
+  select_on_container_copy_construction() const _NOEXCEPT {
+    return scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>(
+        allocator_traits<outer_allocator_type>::select_on_container_copy_construction(outer_allocator()),
+        allocator_traits<inner_allocator_type>::select_on_container_copy_construction(inner_allocator()));
+  }
 
-    scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
-    _LIBCPP_INLINE_VISIBILITY
-    select_on_container_copy_construction() const _NOEXCEPT
-        {
-            return scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
-            (
-                allocator_traits<outer_allocator_type>::
-                    select_on_container_copy_construction(outer_allocator()),
-                allocator_traits<inner_allocator_type>::
-                    select_on_container_copy_construction(inner_allocator())
-            );
-        }
-
-    template <class...> friend class __scoped_allocator_storage;
+  template <class...>
+  friend class __scoped_allocator_storage;
 };
 
 template <class _OuterAlloc>
-class __scoped_allocator_storage<_OuterAlloc>
-    : public _OuterAlloc
-{
-    typedef _OuterAlloc outer_allocator_type;
+class __scoped_allocator_storage<_OuterAlloc> : public _OuterAlloc {
+  typedef _OuterAlloc outer_allocator_type;
+
 protected:
-    typedef scoped_allocator_adaptor<_OuterAlloc> inner_allocator_type;
+  typedef scoped_allocator_adaptor<_OuterAlloc> inner_allocator_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __scoped_allocator_storage() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI __scoped_allocator_storage() _NOEXCEPT {}
 
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(_OuterA2&& __outer_alloc) _NOEXCEPT
-            : outer_allocator_type(_VSTD::forward<_OuterA2>(__outer_alloc)) {}
+  template <class _OuterA2, __enable_if_t<is_constructible<outer_allocator_type, _OuterA2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI __scoped_allocator_storage(_OuterA2&& __outer_alloc) _NOEXCEPT
+      : outer_allocator_type(std::forward<_OuterA2>(__outer_alloc)) {}
 
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, const _OuterA2&>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(
-            const __scoped_allocator_storage<_OuterA2>& __other) _NOEXCEPT
-            : outer_allocator_type(__other.outer_allocator()) {}
+  template <class _OuterA2, __enable_if_t<is_constructible<outer_allocator_type, const _OuterA2&>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI __scoped_allocator_storage(const __scoped_allocator_storage<_OuterA2>& __other) _NOEXCEPT
+      : outer_allocator_type(__other.outer_allocator()) {}
 
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(
-            __scoped_allocator_storage<_OuterA2>&& __other) _NOEXCEPT
-            : outer_allocator_type(_VSTD::move(__other.outer_allocator())) {}
+  template <class _OuterA2, __enable_if_t<is_constructible<outer_allocator_type, _OuterA2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI __scoped_allocator_storage(__scoped_allocator_storage<_OuterA2>&& __other) _NOEXCEPT
+      : outer_allocator_type(std::move(__other.outer_allocator())) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    inner_allocator_type& inner_allocator() _NOEXCEPT
-        {return static_cast<inner_allocator_type&>(*this);}
-    _LIBCPP_INLINE_VISIBILITY
-    const inner_allocator_type& inner_allocator() const _NOEXCEPT
-        {return static_cast<const inner_allocator_type&>(*this);}
+  _LIBCPP_HIDE_FROM_ABI inner_allocator_type& inner_allocator() _NOEXCEPT {
+    return static_cast<inner_allocator_type&>(*this);
+  }
+  _LIBCPP_HIDE_FROM_ABI const inner_allocator_type& inner_allocator() const _NOEXCEPT {
+    return static_cast<const inner_allocator_type&>(*this);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    outer_allocator_type& outer_allocator() _NOEXCEPT
-        {return static_cast<outer_allocator_type&>(*this);}
-    _LIBCPP_INLINE_VISIBILITY
-    const outer_allocator_type& outer_allocator() const _NOEXCEPT
-        {return static_cast<const outer_allocator_type&>(*this);}
+  _LIBCPP_HIDE_FROM_ABI outer_allocator_type& outer_allocator() _NOEXCEPT {
+    return static_cast<outer_allocator_type&>(*this);
+  }
+  _LIBCPP_HIDE_FROM_ABI const outer_allocator_type& outer_allocator() const _NOEXCEPT {
+    return static_cast<const outer_allocator_type&>(*this);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    scoped_allocator_adaptor<outer_allocator_type>
-    select_on_container_copy_construction() const _NOEXCEPT
-        {return scoped_allocator_adaptor<outer_allocator_type>(
-            allocator_traits<outer_allocator_type>::
-                select_on_container_copy_construction(outer_allocator())
-        );}
+  _LIBCPP_HIDE_FROM_ABI scoped_allocator_adaptor<outer_allocator_type>
+  select_on_container_copy_construction() const _NOEXCEPT {
+    return scoped_allocator_adaptor<outer_allocator_type>(
+        allocator_traits<outer_allocator_type>::select_on_container_copy_construction(outer_allocator()));
+  }
 
-    __scoped_allocator_storage(const outer_allocator_type& __o,
-                               const inner_allocator_type& __i) _NOEXCEPT;
+  __scoped_allocator_storage(const outer_allocator_type& __o, const inner_allocator_type& __i) _NOEXCEPT;
 
-    template <class...> friend class __scoped_allocator_storage;
+  template <class...>
+  friend class __scoped_allocator_storage;
 };
 
 // __outermost
 
 template <class _Alloc>
-decltype(std::declval<_Alloc>().outer_allocator(), true_type())
-__has_outer_allocator_test(_Alloc&& __a);
+decltype(std::declval<_Alloc>().outer_allocator(), true_type()) __has_outer_allocator_test(_Alloc&& __a);
 
 template <class _Alloc>
-false_type
-__has_outer_allocator_test(const volatile _Alloc& __a);
+false_type __has_outer_allocator_test(const volatile _Alloc& __a);
 
 template <class _Alloc>
 struct __has_outer_allocator
-    : public common_type
-             <
-                 decltype(std::__has_outer_allocator_test(std::declval<_Alloc&>()))
-             >::type
-{
-};
+    : public common_type< decltype(std::__has_outer_allocator_test(std::declval<_Alloc&>()))>::type {};
 
 template <class _Alloc, bool = __has_outer_allocator<_Alloc>::value>
-struct __outermost
-{
-    typedef _Alloc type;
-    _LIBCPP_INLINE_VISIBILITY
-    type& operator()(type& __a) const _NOEXCEPT {return __a;}
+struct __outermost {
+  typedef _Alloc type;
+  _LIBCPP_HIDE_FROM_ABI type& operator()(type& __a) const _NOEXCEPT { return __a; }
 };
 
 template <class _Alloc>
-struct __outermost<_Alloc, true>
-{
-    typedef __libcpp_remove_reference_t
-                     <
-                        decltype(std::declval<_Alloc>().outer_allocator())
-                     >                                    _OuterAlloc;
-    typedef typename __outermost<_OuterAlloc>::type             type;
-    _LIBCPP_INLINE_VISIBILITY
-    type& operator()(_Alloc& __a) const _NOEXCEPT
-        {return __outermost<_OuterAlloc>()(__a.outer_allocator());}
+struct __outermost<_Alloc, true> {
+  typedef __libcpp_remove_reference_t< decltype(std::declval<_Alloc>().outer_allocator()) > _OuterAlloc;
+  typedef typename __outermost<_OuterAlloc>::type type;
+  _LIBCPP_HIDE_FROM_ABI type& operator()(_Alloc& __a) const _NOEXCEPT {
+    return __outermost<_OuterAlloc>()(__a.outer_allocator());
+  }
 };
 
 template <class _OuterAlloc, class... _InnerAllocs>
 class _LIBCPP_TEMPLATE_VIS scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>
-    : public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...>
-{
-    typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> base;
-    typedef allocator_traits<_OuterAlloc>             _OuterTraits;
+    : public __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> {
+  typedef __scoped_allocator_storage<_OuterAlloc, _InnerAllocs...> _Base;
+  typedef allocator_traits<_OuterAlloc> _OuterTraits;
+
 public:
-    typedef _OuterAlloc                               outer_allocator_type;
-    typedef typename base::inner_allocator_type       inner_allocator_type;
-    typedef typename _OuterTraits::size_type          size_type;
-    typedef typename _OuterTraits::difference_type    difference_type;
-    typedef typename _OuterTraits::pointer            pointer;
-    typedef typename _OuterTraits::const_pointer      const_pointer;
-    typedef typename _OuterTraits::void_pointer       void_pointer;
-    typedef typename _OuterTraits::const_void_pointer const_void_pointer;
+  typedef _OuterAlloc outer_allocator_type;
+  typedef typename _Base::inner_allocator_type inner_allocator_type;
+  typedef typename _OuterTraits::size_type size_type;
+  typedef typename _OuterTraits::difference_type difference_type;
+  typedef typename _OuterTraits::pointer pointer;
+  typedef typename _OuterTraits::const_pointer const_pointer;
+  typedef typename _OuterTraits::void_pointer void_pointer;
+  typedef typename _OuterTraits::const_void_pointer const_void_pointer;
 
-    typedef integral_constant
-            <
-                bool,
-                __get_poc_copy_assignment<outer_allocator_type,
-                                          _InnerAllocs...>::value
-            > propagate_on_container_copy_assignment;
-    typedef integral_constant
-            <
-                bool,
-                __get_poc_move_assignment<outer_allocator_type,
-                                          _InnerAllocs...>::value
-            > propagate_on_container_move_assignment;
-    typedef integral_constant
-            <
-                bool,
-                __get_poc_swap<outer_allocator_type, _InnerAllocs...>::value
-            > propagate_on_container_swap;
-    typedef integral_constant
-            <
-                bool,
-                __get_is_always_equal<outer_allocator_type, _InnerAllocs...>::value
-            > is_always_equal;
+  typedef integral_constant< bool, __get_poc_copy_assignment<outer_allocator_type, _InnerAllocs...>::value >
+      propagate_on_container_copy_assignment;
+  typedef integral_constant< bool, __get_poc_move_assignment<outer_allocator_type, _InnerAllocs...>::value >
+      propagate_on_container_move_assignment;
+  typedef integral_constant< bool, __get_poc_swap<outer_allocator_type, _InnerAllocs...>::value >
+      propagate_on_container_swap;
+  typedef integral_constant< bool, __get_is_always_equal<outer_allocator_type, _InnerAllocs...>::value >
+      is_always_equal;
 
-    template <class _Tp>
-    struct rebind
-    {
-        typedef scoped_allocator_adaptor
-        <
-            typename _OuterTraits::template rebind_alloc<_Tp>, _InnerAllocs...
-        > other;
-    };
+  template <class _Tp>
+  struct rebind {
+    typedef scoped_allocator_adaptor< typename _OuterTraits::template rebind_alloc<_Tp>, _InnerAllocs... > other;
+  };
 
-    _LIBCPP_INLINE_VISIBILITY
-    scoped_allocator_adaptor() _NOEXCEPT {}
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        scoped_allocator_adaptor(_OuterA2&& __outer_alloc,
-                                 const _InnerAllocs& ...__inner_allocs) _NOEXCEPT
-            : base(_VSTD::forward<_OuterA2>(__outer_alloc), __inner_allocs...) {}
-    // scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, const _OuterA2&>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        scoped_allocator_adaptor(
-            const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
-                : base(__other) {}
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-        _LIBCPP_INLINE_VISIBILITY
-        scoped_allocator_adaptor(
-            scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
-                : base(_VSTD::move(__other)) {}
+  _LIBCPP_HIDE_FROM_ABI scoped_allocator_adaptor() _NOEXCEPT {}
+  template <class _OuterA2, __enable_if_t<is_constructible<outer_allocator_type, _OuterA2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  scoped_allocator_adaptor(_OuterA2&& __outer_alloc, const _InnerAllocs&... __inner_allocs) _NOEXCEPT
+      : _Base(std::forward<_OuterA2>(__outer_alloc), __inner_allocs...) {}
+  // scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
+  template <class _OuterA2, __enable_if_t<is_constructible<outer_allocator_type, const _OuterA2&>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  scoped_allocator_adaptor(const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
+      : _Base(__other) {}
+  template <class _OuterA2, __enable_if_t<is_constructible<outer_allocator_type, _OuterA2>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  scoped_allocator_adaptor(scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
+      : _Base(std::move(__other)) {}
 
-    // scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default;
-    // scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default;
-    // ~scoped_allocator_adaptor() = default;
+  // scoped_allocator_adaptor& operator=(const scoped_allocator_adaptor&) = default;
+  // scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default;
+  // ~scoped_allocator_adaptor() = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    inner_allocator_type& inner_allocator() _NOEXCEPT
-        {return base::inner_allocator();}
-    _LIBCPP_INLINE_VISIBILITY
-    const inner_allocator_type& inner_allocator() const _NOEXCEPT
-        {return base::inner_allocator();}
+  _LIBCPP_HIDE_FROM_ABI inner_allocator_type& inner_allocator() _NOEXCEPT { return _Base::inner_allocator(); }
+  _LIBCPP_HIDE_FROM_ABI const inner_allocator_type& inner_allocator() const _NOEXCEPT {
+    return _Base::inner_allocator();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    outer_allocator_type& outer_allocator() _NOEXCEPT
-        {return base::outer_allocator();}
-    _LIBCPP_INLINE_VISIBILITY
-    const outer_allocator_type& outer_allocator() const _NOEXCEPT
-        {return base::outer_allocator();}
+  _LIBCPP_HIDE_FROM_ABI outer_allocator_type& outer_allocator() _NOEXCEPT { return _Base::outer_allocator(); }
+  _LIBCPP_HIDE_FROM_ABI const outer_allocator_type& outer_allocator() const _NOEXCEPT {
+    return _Base::outer_allocator();
+  }
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    pointer allocate(size_type __n)
-        {return allocator_traits<outer_allocator_type>::
-            allocate(outer_allocator(), __n);}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    pointer allocate(size_type __n, const_void_pointer __hint)
-        {return allocator_traits<outer_allocator_type>::
-            allocate(outer_allocator(), __n, __hint);}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI pointer allocate(size_type __n) {
+    return allocator_traits<outer_allocator_type>::allocate(outer_allocator(), __n);
+  }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI pointer allocate(size_type __n, const_void_pointer __hint) {
+    return allocator_traits<outer_allocator_type>::allocate(outer_allocator(), __n, __hint);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void deallocate(pointer __p, size_type __n) _NOEXCEPT
-        {allocator_traits<outer_allocator_type>::
-            deallocate(outer_allocator(), __p, __n);}
+  _LIBCPP_HIDE_FROM_ABI void deallocate(pointer __p, size_type __n) _NOEXCEPT {
+    allocator_traits<outer_allocator_type>::deallocate(outer_allocator(), __p, __n);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const
-        {return allocator_traits<outer_allocator_type>::max_size(outer_allocator());}
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const {
+    return allocator_traits<outer_allocator_type>::max_size(outer_allocator());
+  }
 
-#if _LIBCPP_STD_VER >= 20
-    template <class _Type, class... _Args>
-    _LIBCPP_HIDE_FROM_ABI void construct(_Type* __ptr, _Args&&... __args) {
-      using _OM = __outermost<outer_allocator_type>;
-      std::apply(
-          [__ptr, this](auto&&... __newargs) {
-            allocator_traits<typename _OM::type>::construct(
-                _OM()(outer_allocator()), __ptr, std::forward<decltype(__newargs)>(__newargs)...);
-          },
-          std::uses_allocator_construction_args<_Type>(inner_allocator(), std::forward<_Args>(__args)...));
-    }
-#else
-    template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        void construct(_Tp* __p, _Args&& ...__args)
-            {__construct(__uses_alloc_ctor<_Tp, inner_allocator_type&, _Args...>(),
-                         __p, _VSTD::forward<_Args>(__args)...);}
+#  if _LIBCPP_STD_VER >= 20
+  template <class _Type, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void construct(_Type* __ptr, _Args&&... __args) {
+    using _OM = __outermost<outer_allocator_type>;
+    std::apply(
+        [__ptr, this](auto&&... __newargs) {
+          allocator_traits<typename _OM::type>::construct(
+              _OM()(outer_allocator()), __ptr, std::forward<decltype(__newargs)>(__newargs)...);
+        },
+        std::uses_allocator_construction_args<_Type>(inner_allocator(), std::forward<_Args>(__args)...));
+  }
+#  else
+  template <class _Tp, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void construct(_Tp* __p, _Args&&... __args) {
+    __construct(__uses_alloc_ctor<_Tp, inner_allocator_type&, _Args...>(), __p, std::forward<_Args>(__args)...);
+  }
 
-    template <class _T1, class _T2, class... _Args1, class... _Args2>
-    _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
-                       tuple<_Args1...> __x, tuple<_Args2...> __y)
-    {
-        typedef __outermost<outer_allocator_type> _OM;
-        allocator_traits<typename _OM::type>::construct(
-            _OM()(outer_allocator()), __p, piecewise_construct
-          , __transform_tuple(
-              typename __uses_alloc_ctor<
-                  _T1, inner_allocator_type&, _Args1...
-              >::type()
-            , _VSTD::move(__x)
-            , typename __make_tuple_indices<sizeof...(_Args1)>::type{}
-          )
-          , __transform_tuple(
-              typename __uses_alloc_ctor<
-                  _T2, inner_allocator_type&, _Args2...
-              >::type()
-            , _VSTD::move(__y)
-            , typename __make_tuple_indices<sizeof...(_Args2)>::type{}
-          )
-        );
-    }
+  template <class _T1, class _T2, class... _Args1, class... _Args2>
+  _LIBCPP_HIDE_FROM_ABI void
+  construct(pair<_T1, _T2>* __p, piecewise_construct_t, tuple<_Args1...> __x, tuple<_Args2...> __y) {
+    typedef __outermost<outer_allocator_type> _OM;
+    allocator_traits<typename _OM::type>::construct(
+        _OM()(outer_allocator()),
+        __p,
+        piecewise_construct,
+        __transform_tuple(typename __uses_alloc_ctor< _T1, inner_allocator_type&, _Args1... >::type(),
+                          std::move(__x),
+                          typename __make_tuple_indices<sizeof...(_Args1)>::type{}),
+        __transform_tuple(typename __uses_alloc_ctor< _T2, inner_allocator_type&, _Args2... >::type(),
+                          std::move(__y),
+                          typename __make_tuple_indices<sizeof...(_Args2)>::type{}));
+  }
 
-    template <class _T1, class _T2>
-    _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p)
-    { construct(__p, piecewise_construct, tuple<>{}, tuple<>{}); }
+  template <class _T1, class _T2>
+  _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p) {
+    construct(__p, piecewise_construct, tuple<>{}, tuple<>{});
+  }
 
-    template <class _T1, class _T2, class _Up, class _Vp>
-    _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p, _Up&& __x, _Vp&& __y) {
-        construct(__p, piecewise_construct,
-                  _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__x)),
-                  _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__y)));
-    }
+  template <class _T1, class _T2, class _Up, class _Vp>
+  _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p, _Up&& __x, _Vp&& __y) {
+    construct(__p,
+              piecewise_construct,
+              std::forward_as_tuple(std::forward<_Up>(__x)),
+              std::forward_as_tuple(std::forward<_Vp>(__y)));
+  }
 
-    template <class _T1, class _T2, class _Up, class _Vp>
-    _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p, const pair<_Up, _Vp>& __x) {
-        construct(__p, piecewise_construct,
-                  _VSTD::forward_as_tuple(__x.first),
-                  _VSTD::forward_as_tuple(__x.second));
-    }
+  template <class _T1, class _T2, class _Up, class _Vp>
+  _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p, const pair<_Up, _Vp>& __x) {
+    construct(__p, piecewise_construct, std::forward_as_tuple(__x.first), std::forward_as_tuple(__x.second));
+  }
 
-    template <class _T1, class _T2, class _Up, class _Vp>
-    _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p, pair<_Up, _Vp>&& __x) {
-        construct(__p, piecewise_construct,
-                  _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__x.first)),
-                  _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__x.second)));
-    }
-#endif
+  template <class _T1, class _T2, class _Up, class _Vp>
+  _LIBCPP_HIDE_FROM_ABI void construct(pair<_T1, _T2>* __p, pair<_Up, _Vp>&& __x) {
+    construct(__p,
+              piecewise_construct,
+              std::forward_as_tuple(std::forward<_Up>(__x.first)),
+              std::forward_as_tuple(std::forward<_Vp>(__x.second)));
+  }
+#  endif
 
-    template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
-        void destroy(_Tp* __p)
-            {
-                typedef __outermost<outer_allocator_type> _OM;
-                allocator_traits<typename _OM::type>::
-                                         destroy(_OM()(outer_allocator()), __p);
-            }
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI void destroy(_Tp* __p) {
+    typedef __outermost<outer_allocator_type> _OM;
+    allocator_traits<typename _OM::type>::destroy(_OM()(outer_allocator()), __p);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    scoped_allocator_adaptor select_on_container_copy_construction() const _NOEXCEPT
-        {return base::select_on_container_copy_construction();}
+  _LIBCPP_HIDE_FROM_ABI scoped_allocator_adaptor select_on_container_copy_construction() const _NOEXCEPT {
+    return _Base::select_on_container_copy_construction();
+  }
 
 private:
+  _LIBCPP_HIDE_FROM_ABI explicit scoped_allocator_adaptor(
+      outer_allocator_type&& __o, inner_allocator_type&& __i) _NOEXCEPT : _Base(std::move(__o), std::move(__i)) {}
 
+  template <class _Tp, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void __construct(integral_constant<int, 0>, _Tp* __p, _Args&&... __args) {
+    typedef __outermost<outer_allocator_type> _OM;
+    allocator_traits<typename _OM::type>::construct(_OM()(outer_allocator()), __p, std::forward<_Args>(__args)...);
+  }
 
-    template <class _OuterA2,
-              class = typename enable_if<
-                        is_constructible<outer_allocator_type, _OuterA2>::value
-                      >::type>
-    _LIBCPP_INLINE_VISIBILITY
-    scoped_allocator_adaptor(_OuterA2&& __o,
-                             const inner_allocator_type& __i) _NOEXCEPT
-        : base(_VSTD::forward<_OuterA2>(__o), __i) {}
+  template <class _Tp, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void __construct(integral_constant<int, 1>, _Tp* __p, _Args&&... __args) {
+    typedef __outermost<outer_allocator_type> _OM;
+    allocator_traits<typename _OM::type>::construct(
+        _OM()(outer_allocator()), __p, allocator_arg, inner_allocator(), std::forward<_Args>(__args)...);
+  }
 
-    template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        void __construct(integral_constant<int, 0>, _Tp* __p, _Args&& ...__args)
-            {
-                typedef __outermost<outer_allocator_type> _OM;
-                allocator_traits<typename _OM::type>::construct
-                (
-                    _OM()(outer_allocator()),
-                    __p,
-                    _VSTD::forward<_Args>(__args)...
-                );
-            }
+  template <class _Tp, class... _Args>
+  _LIBCPP_HIDE_FROM_ABI void __construct(integral_constant<int, 2>, _Tp* __p, _Args&&... __args) {
+    typedef __outermost<outer_allocator_type> _OM;
+    allocator_traits<typename _OM::type>::construct(
+        _OM()(outer_allocator()), __p, std::forward<_Args>(__args)..., inner_allocator());
+  }
 
-    template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        void __construct(integral_constant<int, 1>, _Tp* __p, _Args&& ...__args)
-            {
-                typedef __outermost<outer_allocator_type> _OM;
-                allocator_traits<typename _OM::type>::construct
-                (
-                    _OM()(outer_allocator()),
-                    __p, allocator_arg, inner_allocator(),
-                    _VSTD::forward<_Args>(__args)...
-                );
-            }
+  template <class... _Args, size_t... _Idx>
+  _LIBCPP_HIDE_FROM_ABI tuple<_Args&&...>
+  __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t, __tuple_indices<_Idx...>) {
+    return std::forward_as_tuple(std::get<_Idx>(std::move(__t))...);
+  }
 
-    template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        void __construct(integral_constant<int, 2>, _Tp* __p, _Args&& ...__args)
-            {
-                typedef __outermost<outer_allocator_type> _OM;
-                allocator_traits<typename _OM::type>::construct
-                (
-                    _OM()(outer_allocator()),
-                    __p,
-                    _VSTD::forward<_Args>(__args)...,
-                    inner_allocator()
-                );
-            }
+  template <class... _Args, size_t... _Idx>
+  _LIBCPP_HIDE_FROM_ABI tuple<allocator_arg_t, inner_allocator_type&, _Args&&...>
+  __transform_tuple(integral_constant<int, 1>, tuple<_Args...>&& __t, __tuple_indices<_Idx...>) {
+    using _Tup = tuple<allocator_arg_t, inner_allocator_type&, _Args&&...>;
+    return _Tup(allocator_arg, inner_allocator(), std::get<_Idx>(std::move(__t))...);
+  }
 
-    template <class ..._Args, size_t ..._Idx>
-    _LIBCPP_INLINE_VISIBILITY
-    tuple<_Args&&...>
-    __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
-                      __tuple_indices<_Idx...>)
-    {
-        return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...);
-    }
+  template <class... _Args, size_t... _Idx>
+  _LIBCPP_HIDE_FROM_ABI tuple<_Args&&..., inner_allocator_type&>
+  __transform_tuple(integral_constant<int, 2>, tuple<_Args...>&& __t, __tuple_indices<_Idx...>) {
+    using _Tup = tuple<_Args&&..., inner_allocator_type&>;
+    return _Tup(std::get<_Idx>(std::move(__t))..., inner_allocator());
+  }
 
-    template <class ..._Args, size_t ..._Idx>
-    _LIBCPP_INLINE_VISIBILITY
-    tuple<allocator_arg_t, inner_allocator_type&, _Args&&...>
-    __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
-                      __tuple_indices<_Idx...>)
-    {
-        using _Tup = tuple<allocator_arg_t, inner_allocator_type&, _Args&&...>;
-        return _Tup(allocator_arg, inner_allocator(),
-                    _VSTD::get<_Idx>(_VSTD::move(__t))...);
-    }
-
-    template <class ..._Args, size_t ..._Idx>
-    _LIBCPP_INLINE_VISIBILITY
-    tuple<_Args&&..., inner_allocator_type&>
-    __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
-                      __tuple_indices<_Idx...>)
-    {
-        using _Tup = tuple<_Args&&..., inner_allocator_type&>;
-        return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., inner_allocator());
-    }
-
-    template <class...> friend class __scoped_allocator_storage;
+  template <class...>
+  friend class __scoped_allocator_storage;
 };
 
-#if _LIBCPP_STD_VER >= 17
-template<class _OuterAlloc, class... _InnerAllocs>
-    scoped_allocator_adaptor(_OuterAlloc, _InnerAllocs...)
-        -> scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>;
-#endif
+#  if _LIBCPP_STD_VER >= 17
+template <class _OuterAlloc, class... _InnerAllocs>
+scoped_allocator_adaptor(_OuterAlloc, _InnerAllocs...) -> scoped_allocator_adaptor<_OuterAlloc, _InnerAllocs...>;
+#  endif
 
 template <class _OuterA1, class _OuterA2>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const scoped_allocator_adaptor<_OuterA1>& __a,
-           const scoped_allocator_adaptor<_OuterA2>& __b) _NOEXCEPT
-{
-    return __a.outer_allocator() == __b.outer_allocator();
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const scoped_allocator_adaptor<_OuterA1>& __a, const scoped_allocator_adaptor<_OuterA2>& __b) _NOEXCEPT {
+  return __a.outer_allocator() == __b.outer_allocator();
 }
 
 template <class _OuterA1, class _OuterA2, class _InnerA0, class... _InnerAllocs>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
+inline _LIBCPP_HIDE_FROM_ABI bool
 operator==(const scoped_allocator_adaptor<_OuterA1, _InnerA0, _InnerAllocs...>& __a,
-           const scoped_allocator_adaptor<_OuterA2, _InnerA0, _InnerAllocs...>& __b) _NOEXCEPT
-{
-    return __a.outer_allocator() == __b.outer_allocator() &&
-           __a.inner_allocator() == __b.inner_allocator();
+           const scoped_allocator_adaptor<_OuterA2, _InnerA0, _InnerAllocs...>& __b) _NOEXCEPT {
+  return __a.outer_allocator() == __b.outer_allocator() && __a.inner_allocator() == __b.inner_allocator();
 }
 
+#  if _LIBCPP_STD_VER <= 17
+
 template <class _OuterA1, class _OuterA2, class... _InnerAllocs>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
-           const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b) _NOEXCEPT
-{
-    return !(__a == __b);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
+                                             const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b) _NOEXCEPT {
+  return !(__a == __b);
 }
 
+#  endif // _LIBCPP_STD_VER <= 17
+
 #endif // !defined(_LIBCPP_CXX03_LANG)
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <climits>
diff --git a/third_party/libcxx/semaphore b/third_party/libcxx/semaphore
index cfbc2477a..95a4375f2 100644
--- a/third_party/libcxx/semaphore
+++ b/third_party/libcxx/semaphore
@@ -45,31 +45,30 @@ using binary_semaphore = counting_semaphore<1>;
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__atomic/atomic_base.h>
-#include <__atomic/atomic_sync.h>
-#include <__atomic/memory_order.h>
-#include <__availability>
-#include <__chrono/time_point.h>
 #include <__config>
-#include <__thread/timed_backoff_policy.h>
-#include <__threading_support>
-#include <cstddef>
-#include <limits>
-#include <version>
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#if !defined(_LIBCPP_HAS_NO_THREADS)
 
-#ifdef _LIBCPP_HAS_NO_THREADS
-# error "<semaphore> is not supported since libc++ has been configured without support for threads."
-#endif
+#  include <__assert>
+#  include <__atomic/atomic_base.h>
+#  include <__atomic/atomic_sync.h>
+#  include <__atomic/memory_order.h>
+#  include <__chrono/time_point.h>
+#  include <__thread/poll_with_backoff.h>
+#  include <__thread/support.h>
+#  include <__thread/timed_backoff_policy.h>
+#  include <cstddef>
+#  include <limits>
+#  include <version>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 _LIBCPP_PUSH_MACROS
-#include <__undef_macros>
+#  include <__undef_macros>
 
-#if _LIBCPP_STD_VER >= 14
+#  if _LIBCPP_STD_VER >= 14
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
@@ -81,116 +80,107 @@ functions. It avoids contention against users' own use of those facilities.
 
 */
 
-class __atomic_semaphore_base
-{
-    __atomic_base<ptrdiff_t> __a_;
+#    define _LIBCPP_SEMAPHORE_MAX (numeric_limits<ptrdiff_t>::max())
+
+class __atomic_semaphore_base {
+  __atomic_base<ptrdiff_t> __a_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit __atomic_semaphore_base(ptrdiff_t __count) : __a_(__count)
-    {
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __atomic_semaphore_base(ptrdiff_t __count) : __a_(__count) {}
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void release(ptrdiff_t __update = 1) {
+    auto __old = __a_.fetch_add(__update, memory_order_release);
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __update <= _LIBCPP_SEMAPHORE_MAX - __old, "update is greater than the expected value");
+    if (__old == 0) {
+      __a_.notify_all();
     }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void release(ptrdiff_t __update = 1)
-    {
-        if(0 < __a_.fetch_add(__update, memory_order_release))
-            ;
-        else if(__update > 1)
-            __a_.notify_all();
-        else
-            __a_.notify_one();
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void acquire()
-    {
-        auto const __test_fn = [this]() -> bool {
-            auto __old = __a_.load(memory_order_relaxed);
-            return (__old != 0) && __a_.compare_exchange_strong(__old, __old - 1, memory_order_acquire, memory_order_relaxed);
-        };
-        __cxx_atomic_wait(&__a_.__a_, __test_fn);
-    }
-    template <class Rep, class Period>
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    bool try_acquire_for(chrono::duration<Rep, Period> const& __rel_time)
-    {
-        if (__rel_time == chrono::duration<Rep, Period>::zero())
-            return try_acquire();
-        auto const __test_fn = [this]() { return try_acquire(); };
-        return std::__libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy(), __rel_time);
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    bool try_acquire()
-    {
-        auto __old = __a_.load(memory_order_acquire);
-        while (true) {
-            if (__old == 0)
-                return false;
-            if (__a_.compare_exchange_strong(__old, __old - 1, memory_order_acquire, memory_order_relaxed))
-                return true;
-        }
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void acquire() {
+    std::__atomic_wait_unless(
+        __a_, [this](ptrdiff_t& __old) { return __try_acquire_impl(__old); }, memory_order_relaxed);
+  }
+  template <class _Rep, class _Period>
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool
+  try_acquire_for(chrono::duration<_Rep, _Period> const& __rel_time) {
+    if (__rel_time == chrono::duration<_Rep, _Period>::zero())
+      return try_acquire();
+    auto const __poll_fn = [this]() { return try_acquire(); };
+    return std::__libcpp_thread_poll_with_backoff(__poll_fn, __libcpp_timed_backoff_policy(), __rel_time);
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool try_acquire() {
+    auto __old = __a_.load(memory_order_relaxed);
+    return __try_acquire_impl(__old);
+  }
+
+private:
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool __try_acquire_impl(ptrdiff_t& __old) {
+    while (true) {
+      if (__old == 0)
+        return false;
+      if (__a_.compare_exchange_weak(__old, __old - 1, memory_order_acquire, memory_order_relaxed))
+        return true;
     }
+  }
 };
 
-#define _LIBCPP_SEMAPHORE_MAX (numeric_limits<ptrdiff_t>::max())
-
-template<ptrdiff_t __least_max_value = _LIBCPP_SEMAPHORE_MAX>
-class counting_semaphore
-{
-    __atomic_semaphore_base __semaphore_;
+template <ptrdiff_t __least_max_value = _LIBCPP_SEMAPHORE_MAX>
+class _LIBCPP_DEPRECATED_ATOMIC_SYNC counting_semaphore {
+  __atomic_semaphore_base __semaphore_;
 
 public:
-    static constexpr ptrdiff_t max() noexcept {
-        return __least_max_value;
-    }
+  static_assert(__least_max_value >= 0, "The least maximum value must be a positive number");
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit counting_semaphore(ptrdiff_t __count) : __semaphore_(__count) { }
-    ~counting_semaphore() = default;
+  static constexpr ptrdiff_t max() noexcept { return __least_max_value; }
 
-    counting_semaphore(const counting_semaphore&) = delete;
-    counting_semaphore& operator=(const counting_semaphore&) = delete;
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit counting_semaphore(ptrdiff_t __count) : __semaphore_(__count) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __count >= 0,
+        "counting_semaphore::counting_semaphore(ptrdiff_t): counting_semaphore cannot be "
+        "initialized with a negative value");
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
+        __count <= max(),
+        "counting_semaphore::counting_semaphore(ptrdiff_t): counting_semaphore cannot be "
+        "initialized with a value greater than max()");
+  }
+  ~counting_semaphore() = default;
 
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void release(ptrdiff_t __update = 1)
-    {
-        __semaphore_.release(__update);
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    void acquire()
-    {
-        __semaphore_.acquire();
-    }
-    template<class Rep, class Period>
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    bool try_acquire_for(chrono::duration<Rep, Period> const& __rel_time)
-    {
-        return __semaphore_.try_acquire_for(chrono::duration_cast<chrono::nanoseconds>(__rel_time));
-    }
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    bool try_acquire()
-    {
-        return __semaphore_.try_acquire();
-    }
-    template <class Clock, class Duration>
-    _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
-    bool try_acquire_until(chrono::time_point<Clock, Duration> const& __abs_time)
-    {
-        auto const __current = Clock::now();
-        if (__current >= __abs_time)
-            return try_acquire();
-        else
-            return try_acquire_for(__abs_time - __current);
-    }
+  counting_semaphore(const counting_semaphore&)            = delete;
+  counting_semaphore& operator=(const counting_semaphore&) = delete;
+
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void release(ptrdiff_t __update = 1) {
+    _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update >= 0, "counting_semaphore:release called with a negative value");
+    __semaphore_.release(__update);
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void acquire() { __semaphore_.acquire(); }
+  template <class _Rep, class _Period>
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool
+  try_acquire_for(chrono::duration<_Rep, _Period> const& __rel_time) {
+    return __semaphore_.try_acquire_for(chrono::duration_cast<chrono::nanoseconds>(__rel_time));
+  }
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool try_acquire() { return __semaphore_.try_acquire(); }
+  template <class _Clock, class _Duration>
+  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool
+  try_acquire_until(chrono::time_point<_Clock, _Duration> const& __abs_time) {
+    auto const __current = _Clock::now();
+    if (__current >= __abs_time)
+      return try_acquire();
+    else
+      return try_acquire_for(__abs_time - __current);
+  }
 };
 
-using binary_semaphore = counting_semaphore<1>;
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+using binary_semaphore _LIBCPP_DEPRECATED_ATOMIC_SYNC = counting_semaphore<1>;
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_STD_VER >= 14
+#  endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
+#endif // !defined(_LIBCPP_HAS_NO_THREADS)
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #endif
diff --git a/third_party/libcxx/set b/third_party/libcxx/set
index 7d54c9022..945335837 100644
--- a/third_party/libcxx/set
+++ b/third_party/libcxx/set
@@ -56,6 +56,8 @@ public:
     template <class InputIterator>
         set(InputIterator first, InputIterator last, const value_compare& comp,
             const allocator_type& a);
+    template<container-compatible-range<value_type> R>
+      set(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
     set(const set& s);
     set(set&& s)
         noexcept(
@@ -70,6 +72,9 @@ public:
     template <class InputIterator>
         set(InputIterator first, InputIterator last, const allocator_type& a)
             : set(first, last, Compare(), a) {}  // C++14
+    template<container-compatible-range<value_type> R>
+      set(from_range_t, R&& rg, const Allocator& a))
+        : set(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
     set(initializer_list<value_type> il, const allocator_type& a)
         : set(il, Compare(), a) {}  // C++14
     ~set();
@@ -114,6 +119,8 @@ public:
     iterator insert(const_iterator position, value_type&& v);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                                      // C++23
     void insert(initializer_list<value_type> il);
 
     node_type extract(const_iterator position);                                       // C++17
@@ -190,6 +197,11 @@ set(InputIterator, InputIterator,
     Compare = Compare(), Allocator = Allocator())
   -> set<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; // C++17
 
+template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
+         class Allocator = allocator<ranges::range_value_t<R>>>
+  set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+    -> set<ranges::range_value_t<R>, Compare, Allocator>; // C++23
+
 template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
 set(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
   -> set<Key, Compare, Allocator>; // C++17
@@ -199,6 +211,10 @@ set(InputIterator, InputIterator, Allocator)
   -> set<typename iterator_traits<InputIterator>::value_type,
           less<typename iterator_traits<InputIterator>::value_type>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  set(from_range_t, R&&, Allocator)
+    -> set<ranges::range_value_t<R>, less<ranges::range_value_t<R>>, Allocator>; // C++23
+
 template<class Key, class Allocator>
 set(initializer_list<Key>, Allocator) -> set<Key, less<Key>, Allocator>; // C++17
 
@@ -284,6 +300,9 @@ public:
     template <class InputIterator>
         multiset(InputIterator first, InputIterator last,
                  const value_compare& comp, const allocator_type& a);
+    template<container-compatible-range<value_type> R>
+      multiset(from_range_t, R&& rg,
+               const Compare& comp = Compare(), const Allocator& = Allocator()); // C++23
     multiset(const multiset& s);
     multiset(multiset&& s)
         noexcept(
@@ -298,6 +317,9 @@ public:
     template <class InputIterator>
         multiset(InputIterator first, InputIterator last, const allocator_type& a)
             : set(first, last, Compare(), a) {}  // C++14
+    template<container-compatible-range<value_type> R>
+      multiset(from_range_t, R&& rg, const Allocator& a))
+        : multiset(from_range, std::forward<R>(rg), Compare(), a) { } // C++23
     multiset(initializer_list<value_type> il, const allocator_type& a)
         : set(il, Compare(), a) {}  // C++14
     ~multiset();
@@ -342,6 +364,8 @@ public:
     iterator insert(const_iterator position, value_type&& v);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                                      // C++23
     void insert(initializer_list<value_type> il);
 
     node_type extract(const_iterator position);                                       // C++17
@@ -419,6 +443,11 @@ multiset(InputIterator, InputIterator,
     Compare = Compare(), Allocator = Allocator())
   -> multiset<typename iterator_traits<InputIterator>::value_type, Compare, Allocator>; // C++17
 
+template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
+          class Allocator = allocator<ranges::range_value_t<R>>>
+  multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
+    -> multiset<ranges::range_value_t<R>, Compare, Allocator>;
+
 template<class Key, class Compare = less<Key>, class Allocator = allocator<Key>>
 multiset(initializer_list<Key>, Compare = Compare(), Allocator = Allocator())
   -> multiset<Key, Compare, Allocator>; // C++17
@@ -428,6 +457,10 @@ multiset(InputIterator, InputIterator, Allocator)
   -> multiset<typename iterator_traits<InputIterator>::value_type,
           less<typename iterator_traits<InputIterator>::value_type>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  multiset(from_range_t, R&&, Allocator)
+    -> multiset<ranges::range_value_t<R>, less<ranges::range_value_t<R>>, Allocator>;
+
 template<class Key, class Allocator>
 multiset(initializer_list<Key>, Allocator) -> multiset<Key, less<Key>, Allocator>; // C++17
 
@@ -482,16 +515,20 @@ erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 #include <__algorithm/equal.h>
 #include <__algorithm/lexicographical_compare.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/ranges_iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__tree>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
@@ -514,528 +551,441 @@ erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Key, class _Compare, class _Allocator>
 class multiset;
 
-template <class _Key, class _Compare = less<_Key>,
-          class _Allocator = allocator<_Key> >
-class _LIBCPP_TEMPLATE_VIS set
-{
+template <class _Key, class _Compare = less<_Key>, class _Allocator = allocator<_Key> >
+class _LIBCPP_TEMPLATE_VIS set {
 public:
-    // types:
-    typedef _Key                                     key_type;
-    typedef key_type                                 value_type;
-    typedef __type_identity_t<_Compare>              key_compare;
-    typedef key_compare                              value_compare;
-    typedef __type_identity_t<_Allocator>            allocator_type;
-    typedef value_type&                              reference;
-    typedef const value_type&                        const_reference;
+  // types:
+  typedef _Key key_type;
+  typedef key_type value_type;
+  typedef __type_identity_t<_Compare> key_compare;
+  typedef key_compare value_compare;
+  typedef __type_identity_t<_Allocator> allocator_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
 
-    static_assert((is_same<typename allocator_type::value_type, value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
+  static_assert(is_same<typename allocator_type::value_type, value_type>::value,
+                "Allocator::value_type must be same type as value_type");
 
 private:
-    typedef __tree<value_type, value_compare, allocator_type> __base;
-    typedef allocator_traits<allocator_type>                  __alloc_traits;
+  typedef __tree<value_type, value_compare, allocator_type> __base;
+  typedef allocator_traits<allocator_type> __alloc_traits;
 
-    static_assert(is_same<allocator_type, __rebind_alloc<__alloc_traits, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
 
-    __base __tree_;
+  __base __tree_;
 
 public:
-    typedef typename __base::pointer               pointer;
-    typedef typename __base::const_pointer         const_pointer;
-    typedef typename __base::size_type             size_type;
-    typedef typename __base::difference_type       difference_type;
-    typedef typename __base::const_iterator        iterator;
-    typedef typename __base::const_iterator        const_iterator;
-    typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef typename __base::pointer pointer;
+  typedef typename __base::const_pointer const_pointer;
+  typedef typename __base::size_type size_type;
+  typedef typename __base::difference_type difference_type;
+  typedef typename __base::const_iterator iterator;
+  typedef typename __base::const_iterator const_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
 #if _LIBCPP_STD_VER >= 17
-    typedef __set_node_handle<typename __base::__node, allocator_type> node_type;
-    typedef __insert_return_type<iterator, node_type> insert_return_type;
+  typedef __set_node_handle<typename __base::__node, allocator_type> node_type;
+  typedef __insert_return_type<iterator, node_type> insert_return_type;
 #endif
 
-    template <class _Key2, class _Compare2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS set;
-    template <class _Key2, class _Compare2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS multiset;
+  template <class _Key2, class _Compare2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS set;
+  template <class _Key2, class _Compare2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS multiset;
 
-    _LIBCPP_INLINE_VISIBILITY
-    set()
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
-        : __tree_(value_compare()) {}
+  _LIBCPP_HIDE_FROM_ABI set() _NOEXCEPT_(
+      is_nothrow_default_constructible<allocator_type>::value&& is_nothrow_default_constructible<key_compare>::value&&
+          is_nothrow_copy_constructible<key_compare>::value)
+      : __tree_(value_compare()) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit set(const value_compare& __comp)
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
-        : __tree_(__comp) {}
+  _LIBCPP_HIDE_FROM_ABI explicit set(const value_compare& __comp) _NOEXCEPT_(
+      is_nothrow_default_constructible<allocator_type>::value&& is_nothrow_copy_constructible<key_compare>::value)
+      : __tree_(__comp) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit set(const value_compare& __comp, const allocator_type& __a)
-        : __tree_(__comp, __a) {}
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        set(_InputIterator __f, _InputIterator __l,
-            const value_compare& __comp = value_compare())
-        : __tree_(__comp)
-        {
-            insert(__f, __l);
-        }
+  _LIBCPP_HIDE_FROM_ABI explicit set(const value_compare& __comp, const allocator_type& __a) : __tree_(__comp, __a) {}
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI set(_InputIterator __f, _InputIterator __l, const value_compare& __comp = value_compare())
+      : __tree_(__comp) {
+    insert(__f, __l);
+  }
 
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        set(_InputIterator __f, _InputIterator __l, const value_compare& __comp,
-            const allocator_type& __a)
-        : __tree_(__comp, __a)
-        {
-            insert(__f, __l);
-        }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  set(_InputIterator __f, _InputIterator __l, const value_compare& __comp, const allocator_type& __a)
+      : __tree_(__comp, __a) {
+    insert(__f, __l);
+  }
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI
+  set(from_range_t,
+      _Range&& __range,
+      const key_compare& __comp = key_compare(),
+      const allocator_type& __a = allocator_type())
+      : __tree_(__comp, __a) {
+    insert_range(std::forward<_Range>(__range));
+  }
+#endif
 
 #if _LIBCPP_STD_VER >= 14
-        template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        set(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
-            : set(__f, __l, key_compare(), __a) {}
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI set(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
+      : set(__f, __l, key_compare(), __a) {}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    set(const set& __s)
-        : __tree_(__s.__tree_)
-        {
-            insert(__s.begin(), __s.end());
-        }
-
-    _LIBCPP_INLINE_VISIBILITY
-    set& operator=(const set& __s)
-        {
-            __tree_ = __s.__tree_;
-            return *this;
-        }
-
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    set(set&& __s)
-        _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
-        : __tree_(_VSTD::move(__s.__tree_)) {}
-#endif // _LIBCPP_CXX03_LANG
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit set(const allocator_type& __a)
-        : __tree_(__a) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    set(const set& __s, const allocator_type& __a)
-        : __tree_(__s.__tree_.value_comp(), __a)
-        {
-            insert(__s.begin(), __s.end());
-        }
-
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI set(set&& __s, const allocator_type& __a);
-
-    _LIBCPP_INLINE_VISIBILITY
-    set(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
-        : __tree_(__comp)
-        {
-            insert(__il.begin(), __il.end());
-        }
-
-    _LIBCPP_INLINE_VISIBILITY
-    set(initializer_list<value_type> __il, const value_compare& __comp,
-        const allocator_type& __a)
-        : __tree_(__comp, __a)
-        {
-            insert(__il.begin(), __il.end());
-        }
-
-#if _LIBCPP_STD_VER >= 14
-    _LIBCPP_INLINE_VISIBILITY
-    set(initializer_list<value_type> __il, const allocator_type& __a)
-        : set(__il, key_compare(), __a) {}
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI set(from_range_t, _Range&& __range, const allocator_type& __a)
+      : set(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    set& operator=(initializer_list<value_type> __il)
-        {
-            __tree_.__assign_unique(__il.begin(), __il.end());
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI set(const set& __s) : __tree_(__s.__tree_) { insert(__s.begin(), __s.end()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    set& operator=(set&& __s)
-        _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
-        {
-            __tree_ = _VSTD::move(__s.__tree_);
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI set& operator=(const set& __s) {
+    __tree_ = __s.__tree_;
+    return *this;
+  }
+
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI set(set&& __s) noexcept(is_nothrow_move_constructible<__base>::value)
+      : __tree_(std::move(__s.__tree_)) {}
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~set() {
-        static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
+  _LIBCPP_HIDE_FROM_ABI explicit set(const allocator_type& __a) : __tree_(__a) {}
+
+  _LIBCPP_HIDE_FROM_ABI set(const set& __s, const allocator_type& __a) : __tree_(__s.__tree_.value_comp(), __a) {
+    insert(__s.begin(), __s.end());
+  }
+
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI set(set&& __s, const allocator_type& __a);
+
+  _LIBCPP_HIDE_FROM_ABI set(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
+      : __tree_(__comp) {
+    insert(__il.begin(), __il.end());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI set(initializer_list<value_type> __il, const value_compare& __comp, const allocator_type& __a)
+      : __tree_(__comp, __a) {
+    insert(__il.begin(), __il.end());
+  }
+
+#  if _LIBCPP_STD_VER >= 14
+  _LIBCPP_HIDE_FROM_ABI set(initializer_list<value_type> __il, const allocator_type& __a)
+      : set(__il, key_compare(), __a) {}
+#  endif
+
+  _LIBCPP_HIDE_FROM_ABI set& operator=(initializer_list<value_type> __il) {
+    __tree_.__assign_unique(__il.begin(), __il.end());
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI set& operator=(set&& __s) noexcept(is_nothrow_move_assignable<__base>::value) {
+    __tree_ = std::move(__s.__tree_);
+    return *this;
+  }
+#endif // _LIBCPP_CXX03_LANG
+
+  _LIBCPP_HIDE_FROM_ABI ~set() { static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }
+
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }
+
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
+
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __tree_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }
+
+  // modifiers:
+#ifndef _LIBCPP_CXX03_LANG
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
+    return __tree_.__emplace_unique(std::forward<_Args>(__args)...);
+  }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {
+    return __tree_.__emplace_hint_unique(__p, std::forward<_Args>(__args)...);
+  }
+#endif // _LIBCPP_CXX03_LANG
+
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __v) { return __tree_.__insert_unique(__v); }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v) {
+    return __tree_.__insert_unique(__p, __v);
+  }
+
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __f, _InputIterator __l) {
+    for (const_iterator __e = cend(); __f != __l; ++__f)
+      __tree_.__insert_unique(__e, *__f);
+  }
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+    const_iterator __end = cend();
+    for (auto&& __element : __range) {
+      __tree_.__insert_unique(__end, std::forward<decltype(__element)>(__element));
     }
-
-    _LIBCPP_INLINE_VISIBILITY
-          iterator begin() _NOEXCEPT       {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT         {return __tree_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()   const _NOEXCEPT {return __tree_.end();}
-
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rbegin() _NOEXCEPT
-            {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rend() _NOEXCEPT
-            {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend() const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
-
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin()  const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
-
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT {return __tree_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
-
-    // modifiers:
-#ifndef _LIBCPP_CXX03_LANG
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> emplace(_Args&&... __args)
-            {return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator emplace_hint(const_iterator __p, _Args&&... __args)
-            {return __tree_.__emplace_hint_unique(__p, _VSTD::forward<_Args>(__args)...);}
-#endif // _LIBCPP_CXX03_LANG
-
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator,bool> insert(const value_type& __v)
-        {return __tree_.__insert_unique(__v);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, const value_type& __v)
-        {return __tree_.__insert_unique(__p, __v);}
-
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        void insert(_InputIterator __f, _InputIterator __l)
-        {
-            for (const_iterator __e = cend(); __f != __l; ++__f)
-                __tree_.__insert_unique(__e, *__f);
-        }
+  }
+#endif
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator,bool> insert(value_type&& __v)
-        {return __tree_.__insert_unique(_VSTD::move(__v));}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(value_type&& __v) {
+    return __tree_.__insert_unique(std::move(__v));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, value_type&& __v)
-        {return __tree_.__insert_unique(__p, _VSTD::move(__v));}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v) {
+    return __tree_.__insert_unique(__p, std::move(__v));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void insert(initializer_list<value_type> __il)
-        {insert(__il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator  erase(const_iterator __p) {return __tree_.erase(__p);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type erase(const key_type& __k)
-        {return __tree_.__erase_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator  erase(const_iterator __f, const_iterator __l)
-        {return __tree_.erase(__f, __l);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__tree_.clear();}
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p) { return __tree_.erase(__p); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __tree_.__erase_unique(__k); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l) { return __tree_.erase(__f, __l); }
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __tree_.clear(); }
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
-    insert_return_type insert(node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to set::insert()");
-        return __tree_.template __node_handle_insert_unique<
-            node_type, insert_return_type>(_VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __hint, node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to set::insert()");
-        return __tree_.template __node_handle_insert_unique<node_type>(
-            __hint, _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(key_type const& __key)
-    {
-        return __tree_.template __node_handle_extract<node_type>(__key);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(const_iterator __it)
-    {
-        return __tree_.template __node_handle_extract<node_type>(__it);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(set<key_type, _Compare2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_unique(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(set<key_type, _Compare2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_unique(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(multiset<key_type, _Compare2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_unique(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(multiset<key_type, _Compare2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_unique(__source.__tree_);
-    }
+  _LIBCPP_HIDE_FROM_ABI insert_return_type insert(node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to set::insert()");
+    return __tree_.template __node_handle_insert_unique< node_type, insert_return_type>(std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to set::insert()");
+    return __tree_.template __node_handle_insert_unique<node_type>(__hint, std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+    return __tree_.template __node_handle_extract<node_type>(__key);
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+    return __tree_.template __node_handle_extract<node_type>(__it);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(set<key_type, _Compare2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_unique(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(set<key_type, _Compare2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_unique(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(multiset<key_type, _Compare2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_unique(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(multiset<key_type, _Compare2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_unique(__source.__tree_);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(set& __s) _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
-        {__tree_.swap(__s.__tree_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(set& __s) _NOEXCEPT_(__is_nothrow_swappable_v<__base>) { __tree_.swap(__s.__tree_); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT {return __tree_.__alloc();}
-    _LIBCPP_INLINE_VISIBILITY
-    key_compare    key_comp()      const {return __tree_.value_comp();}
-    _LIBCPP_INLINE_VISIBILITY
-    value_compare  value_comp()    const {return __tree_.value_comp();}
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return __tree_.__alloc(); }
+  _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp(); }
+  _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return __tree_.value_comp(); }
 
-    // set operations:
-    _LIBCPP_INLINE_VISIBILITY
-    iterator find(const key_type& __k)             {return __tree_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
+  // set operations:
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
-    find(const _K2& __k)                           {return __tree_.find(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
-    find(const _K2& __k) const                     {return __tree_.find(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+    return __tree_.find(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+    return __tree_.find(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type      count(const key_type& __k) const
-        {return __tree_.__count_unique(__k);}
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __tree_.__count_unique(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
-    count(const _K2& __k) const                    {return __tree_.__count_multi(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+    return __tree_.__count_multi(__k);
+  }
 #endif
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const key_type& __k) const {return find(__k) != end();}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
-    contains(const _K2& __k) const { return find(__k) != end(); }
+  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+    return find(__k) != end();
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator lower_bound(const key_type& __k)
-        {return __tree_.lower_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator lower_bound(const key_type& __k) const
-        {return __tree_.lower_bound(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) { return __tree_.lower_bound(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const { return __tree_.lower_bound(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
-    lower_bound(const _K2& __k)       {return __tree_.lower_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {
+    return __tree_.lower_bound(__k);
+  }
 
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
-    lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {
+    return __tree_.lower_bound(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator upper_bound(const key_type& __k)
-        {return __tree_.upper_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator upper_bound(const key_type& __k) const
-        {return __tree_.upper_bound(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) { return __tree_.upper_bound(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const { return __tree_.upper_bound(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
-    upper_bound(const _K2& __k)       {return __tree_.upper_bound(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
-    upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
+    return __tree_.upper_bound(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {
+    return __tree_.upper_bound(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator,iterator> equal_range(const key_type& __k)
-        {return __tree_.__equal_range_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
-        {return __tree_.__equal_range_unique(__k);}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __tree_.__equal_range_unique(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __tree_.__equal_range_unique(__k);
+  }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
-    equal_range(const _K2& __k)       {return __tree_.__equal_range_multi(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
-    equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+    return __tree_.__equal_range_multi(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+    return __tree_.__equal_range_multi(__k);
+  }
 #endif
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Compare = less<__iter_value_type<_InputIterator>>,
-         class _Allocator = allocator<__iter_value_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>,
-         class = enable_if_t<!__is_allocator<_Compare>::value, void>>
+template <class _InputIterator,
+          class _Compare   = less<__iter_value_type<_InputIterator>>,
+          class _Allocator = allocator<__iter_value_type<_InputIterator>>,
+          class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>>
 set(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
-  -> set<__iter_value_type<_InputIterator>, _Compare, _Allocator>;
+    -> set<__iter_value_type<_InputIterator>, _Compare, _Allocator>;
 
-template<class _Key, class _Compare = less<_Key>,
-         class _Allocator = allocator<_Key>,
-         class = enable_if_t<!__is_allocator<_Compare>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
-set(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator())
-  -> set<_Key, _Compare, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Compare   = less<ranges::range_value_t<_Range>>,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>>
+set(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
+    -> set<ranges::range_value_t<_Range>, _Compare, _Allocator>;
+#  endif
 
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
-set(_InputIterator, _InputIterator, _Allocator)
-  -> set<__iter_value_type<_InputIterator>,
-         less<__iter_value_type<_InputIterator>>, _Allocator>;
+template <class _Key,
+          class _Compare   = less<_Key>,
+          class _Allocator = allocator<_Key>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>>
+set(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator()) -> set<_Key, _Compare, _Allocator>;
 
-template<class _Key, class _Allocator,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
-set(initializer_list<_Key>, _Allocator)
-  -> set<_Key, less<_Key>, _Allocator>;
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+set(_InputIterator,
+    _InputIterator,
+    _Allocator) -> set<__iter_value_type<_InputIterator>, less<__iter_value_type<_InputIterator>>, _Allocator>;
+
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+set(from_range_t,
+    _Range&&,
+    _Allocator) -> set<ranges::range_value_t<_Range>, less<ranges::range_value_t<_Range>>, _Allocator>;
+#  endif
+
+template <class _Key, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+set(initializer_list<_Key>, _Allocator) -> set<_Key, less<_Key>, _Allocator>;
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Compare, class _Allocator>
-set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a)
-    : __tree_(_VSTD::move(__s.__tree_), __a)
-{
-    if (__a != __s.get_allocator())
-    {
-        const_iterator __e = cend();
-        while (!__s.empty())
-            insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_));
-    }
+set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a) : __tree_(std::move(__s.__tree_), __a) {
+  if (__a != __s.get_allocator()) {
+    const_iterator __e = cend();
+    while (!__s.empty())
+      insert(__e, std::move(__s.__tree_.remove(__s.begin())->__value_));
+  }
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const set<_Key, _Compare, _Allocator>& __x,
-           const set<_Key, _Compare, _Allocator>& __y)
-{
-    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const set<_Key, _Compare, _Allocator>& __x, const set<_Key, _Compare, _Allocator>& __y) {
+  return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 #if _LIBCPP_STD_VER <= 17
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const set<_Key, _Compare, _Allocator>& __x,
-           const set<_Key, _Compare, _Allocator>& __y)
-{
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(const set<_Key, _Compare, _Allocator>& __x, const set<_Key, _Compare, _Allocator>& __y) {
+  return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const set<_Key, _Compare, _Allocator>& __x,
-           const set<_Key, _Compare, _Allocator>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const set<_Key, _Compare, _Allocator>& __x, const set<_Key, _Compare, _Allocator>& __y) {
+  return !(__x == __y);
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator> (const set<_Key, _Compare, _Allocator>& __x,
-           const set<_Key, _Compare, _Allocator>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(const set<_Key, _Compare, _Allocator>& __x, const set<_Key, _Compare, _Allocator>& __y) {
+  return __y < __x;
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const set<_Key, _Compare, _Allocator>& __x,
-           const set<_Key, _Compare, _Allocator>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(const set<_Key, _Compare, _Allocator>& __x, const set<_Key, _Compare, _Allocator>& __y) {
+  return !(__x < __y);
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const set<_Key, _Compare, _Allocator>& __x,
-           const set<_Key, _Compare, _Allocator>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(const set<_Key, _Compare, _Allocator>& __x, const set<_Key, _Compare, _Allocator>& __y) {
+  return !(__y < __x);
 }
 
 #else // _LIBCPP_STD_VER <= 17
@@ -1043,548 +993,458 @@ operator<=(const set<_Key, _Compare, _Allocator>& __x,
 template <class _Key, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI __synth_three_way_result<_Key>
 operator<=>(const set<_Key, _Allocator>& __x, const set<_Key, _Allocator>& __y) {
-    return std::lexicographical_compare_three_way(
-        __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way<_Key, _Key>);
+  return std::lexicographical_compare_three_way(__x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
 }
 
 #endif // _LIBCPP_STD_VER <= 17
 
 // specialized algorithms:
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(set<_Key, _Compare, _Allocator>& __x,
-     set<_Key, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void swap(set<_Key, _Compare, _Allocator>& __x, set<_Key, _Compare, _Allocator>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Key, class _Compare, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-    typename set<_Key, _Compare, _Allocator>::size_type
-    erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
-  return _VSTD::__libcpp_erase_if_container(__c, __pred);
+inline _LIBCPP_HIDE_FROM_ABI typename set<_Key, _Compare, _Allocator>::size_type
+erase_if(set<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
+  return std::__libcpp_erase_if_container(__c, __pred);
 }
 #endif
 
-template <class _Key, class _Compare = less<_Key>,
-          class _Allocator = allocator<_Key> >
-class _LIBCPP_TEMPLATE_VIS multiset
-{
+template <class _Key, class _Compare = less<_Key>, class _Allocator = allocator<_Key> >
+class _LIBCPP_TEMPLATE_VIS multiset {
 public:
-    // types:
-    typedef _Key                                     key_type;
-    typedef key_type                                 value_type;
-    typedef __type_identity_t<_Compare>              key_compare;
-    typedef key_compare                              value_compare;
-    typedef __type_identity_t<_Allocator>            allocator_type;
-    typedef value_type&                              reference;
-    typedef const value_type&                        const_reference;
+  // types:
+  typedef _Key key_type;
+  typedef key_type value_type;
+  typedef __type_identity_t<_Compare> key_compare;
+  typedef key_compare value_compare;
+  typedef __type_identity_t<_Allocator> allocator_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
 
-    static_assert((is_same<typename allocator_type::value_type, value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
+  static_assert(is_same<typename allocator_type::value_type, value_type>::value,
+                "Allocator::value_type must be same type as value_type");
 
 private:
-    typedef __tree<value_type, value_compare, allocator_type> __base;
-    typedef allocator_traits<allocator_type>                  __alloc_traits;
+  typedef __tree<value_type, value_compare, allocator_type> __base;
+  typedef allocator_traits<allocator_type> __alloc_traits;
 
-    static_assert(is_same<allocator_type, __rebind_alloc<__alloc_traits, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
 
-    __base __tree_;
+  __base __tree_;
 
 public:
-    typedef typename __base::pointer               pointer;
-    typedef typename __base::const_pointer         const_pointer;
-    typedef typename __base::size_type             size_type;
-    typedef typename __base::difference_type       difference_type;
-    typedef typename __base::const_iterator        iterator;
-    typedef typename __base::const_iterator        const_iterator;
-    typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef typename __base::pointer pointer;
+  typedef typename __base::const_pointer const_pointer;
+  typedef typename __base::size_type size_type;
+  typedef typename __base::difference_type difference_type;
+  typedef typename __base::const_iterator iterator;
+  typedef typename __base::const_iterator const_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
 #if _LIBCPP_STD_VER >= 17
-    typedef __set_node_handle<typename __base::__node, allocator_type> node_type;
+  typedef __set_node_handle<typename __base::__node, allocator_type> node_type;
 #endif
 
-    template <class _Key2, class _Compare2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS set;
-    template <class _Key2, class _Compare2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS multiset;
+  template <class _Key2, class _Compare2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS set;
+  template <class _Key2, class _Compare2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS multiset;
 
-    // construct/copy/destroy:
-    _LIBCPP_INLINE_VISIBILITY
-    multiset()
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
-        : __tree_(value_compare()) {}
+  // construct/copy/destroy:
+  _LIBCPP_HIDE_FROM_ABI multiset() _NOEXCEPT_(
+      is_nothrow_default_constructible<allocator_type>::value&& is_nothrow_default_constructible<key_compare>::value&&
+          is_nothrow_copy_constructible<key_compare>::value)
+      : __tree_(value_compare()) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit multiset(const value_compare& __comp)
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
-        : __tree_(__comp) {}
+  _LIBCPP_HIDE_FROM_ABI explicit multiset(const value_compare& __comp) _NOEXCEPT_(
+      is_nothrow_default_constructible<allocator_type>::value&& is_nothrow_copy_constructible<key_compare>::value)
+      : __tree_(__comp) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit multiset(const value_compare& __comp, const allocator_type& __a)
-        : __tree_(__comp, __a) {}
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        multiset(_InputIterator __f, _InputIterator __l,
-                 const value_compare& __comp = value_compare())
-        : __tree_(__comp)
-        {
-            insert(__f, __l);
-        }
+  _LIBCPP_HIDE_FROM_ABI explicit multiset(const value_compare& __comp, const allocator_type& __a)
+      : __tree_(__comp, __a) {}
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI multiset(_InputIterator __f, _InputIterator __l, const value_compare& __comp = value_compare())
+      : __tree_(__comp) {
+    insert(__f, __l);
+  }
 
 #if _LIBCPP_STD_VER >= 14
-        template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        multiset(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
-            : multiset(__f, __l, key_compare(), __a) {}
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI multiset(_InputIterator __f, _InputIterator __l, const allocator_type& __a)
+      : multiset(__f, __l, key_compare(), __a) {}
 #endif
 
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        multiset(_InputIterator __f, _InputIterator __l,
-                 const value_compare& __comp, const allocator_type& __a)
-        : __tree_(__comp, __a)
-        {
-            insert(__f, __l);
-        }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  multiset(_InputIterator __f, _InputIterator __l, const value_compare& __comp, const allocator_type& __a)
+      : __tree_(__comp, __a) {
+    insert(__f, __l);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    multiset(const multiset& __s)
-        : __tree_(__s.__tree_.value_comp(),
-          __alloc_traits::select_on_container_copy_construction(__s.__tree_.__alloc()))
-        {
-            insert(__s.begin(), __s.end());
-        }
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI
+  multiset(from_range_t,
+           _Range&& __range,
+           const key_compare& __comp = key_compare(),
+           const allocator_type& __a = allocator_type())
+      : __tree_(__comp, __a) {
+    insert_range(std::forward<_Range>(__range));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    multiset& operator=(const multiset& __s)
-        {
-            __tree_ = __s.__tree_;
-            return *this;
-        }
-
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    multiset(multiset&& __s)
-        _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
-        : __tree_(_VSTD::move(__s.__tree_)) {}
-
-    _LIBCPP_HIDE_FROM_ABI multiset(multiset&& __s, const allocator_type& __a);
-#endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    explicit multiset(const allocator_type& __a)
-        : __tree_(__a) {}
-    _LIBCPP_INLINE_VISIBILITY
-    multiset(const multiset& __s, const allocator_type& __a)
-        : __tree_(__s.__tree_.value_comp(), __a)
-        {
-            insert(__s.begin(), __s.end());
-        }
-
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    multiset(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
-        : __tree_(__comp)
-        {
-            insert(__il.begin(), __il.end());
-        }
-
-    _LIBCPP_INLINE_VISIBILITY
-    multiset(initializer_list<value_type> __il, const value_compare& __comp,
-        const allocator_type& __a)
-        : __tree_(__comp, __a)
-        {
-            insert(__il.begin(), __il.end());
-        }
-
-#if _LIBCPP_STD_VER >= 14
-    _LIBCPP_INLINE_VISIBILITY
-    multiset(initializer_list<value_type> __il, const allocator_type& __a)
-        : multiset(__il, key_compare(), __a) {}
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI multiset(from_range_t, _Range&& __range, const allocator_type& __a)
+      : multiset(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    multiset& operator=(initializer_list<value_type> __il)
-        {
-            __tree_.__assign_multi(__il.begin(), __il.end());
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI multiset(const multiset& __s)
+      : __tree_(__s.__tree_.value_comp(),
+                __alloc_traits::select_on_container_copy_construction(__s.__tree_.__alloc())) {
+    insert(__s.begin(), __s.end());
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    multiset& operator=(multiset&& __s)
-        _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
-        {
-            __tree_ = _VSTD::move(__s.__tree_);
-            return *this;
-        }
+  _LIBCPP_HIDE_FROM_ABI multiset& operator=(const multiset& __s) {
+    __tree_ = __s.__tree_;
+    return *this;
+  }
+
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI multiset(multiset&& __s) noexcept(is_nothrow_move_constructible<__base>::value)
+      : __tree_(std::move(__s.__tree_)) {}
+
+  _LIBCPP_HIDE_FROM_ABI multiset(multiset&& __s, const allocator_type& __a);
+#endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI explicit multiset(const allocator_type& __a) : __tree_(__a) {}
+  _LIBCPP_HIDE_FROM_ABI multiset(const multiset& __s, const allocator_type& __a)
+      : __tree_(__s.__tree_.value_comp(), __a) {
+    insert(__s.begin(), __s.end());
+  }
+
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI multiset(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
+      : __tree_(__comp) {
+    insert(__il.begin(), __il.end());
+  }
+
+  _LIBCPP_HIDE_FROM_ABI
+  multiset(initializer_list<value_type> __il, const value_compare& __comp, const allocator_type& __a)
+      : __tree_(__comp, __a) {
+    insert(__il.begin(), __il.end());
+  }
+
+#  if _LIBCPP_STD_VER >= 14
+  _LIBCPP_HIDE_FROM_ABI multiset(initializer_list<value_type> __il, const allocator_type& __a)
+      : multiset(__il, key_compare(), __a) {}
+#  endif
+
+  _LIBCPP_HIDE_FROM_ABI multiset& operator=(initializer_list<value_type> __il) {
+    __tree_.__assign_multi(__il.begin(), __il.end());
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI multiset& operator=(multiset&& __s) _NOEXCEPT_(is_nothrow_move_assignable<__base>::value) {
+    __tree_ = std::move(__s.__tree_);
+    return *this;
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~multiset() {
-        static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), "");
+  _LIBCPP_HIDE_FROM_ABI ~multiset() { static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }
+
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }
+
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }
+  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
+
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __tree_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }
+
+  // modifiers:
+#ifndef _LIBCPP_CXX03_LANG
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) {
+    return __tree_.__emplace_multi(std::forward<_Args>(__args)...);
+  }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {
+    return __tree_.__emplace_hint_multi(__p, std::forward<_Args>(__args)...);
+  }
+#endif // _LIBCPP_CXX03_LANG
+
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __v) { return __tree_.__insert_multi(__v); }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v) {
+    return __tree_.__insert_multi(__p, __v);
+  }
+
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __f, _InputIterator __l) {
+    for (const_iterator __e = cend(); __f != __l; ++__f)
+      __tree_.__insert_multi(__e, *__f);
+  }
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+    const_iterator __end = cend();
+    for (auto&& __element : __range) {
+      __tree_.__insert_multi(__end, std::forward<decltype(__element)>(__element));
     }
-
-    _LIBCPP_INLINE_VISIBILITY
-          iterator begin() _NOEXCEPT       {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT         {return __tree_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()   const _NOEXCEPT {return __tree_.end();}
-
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rbegin() _NOEXCEPT
-            {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rend() _NOEXCEPT
-            {return       reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend() const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
-
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin()  const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
-
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT {return __tree_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
-
-    // modifiers:
-#ifndef _LIBCPP_CXX03_LANG
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator emplace(_Args&&... __args)
-            {return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator emplace_hint(const_iterator __p, _Args&&... __args)
-            {return __tree_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
-#endif // _LIBCPP_CXX03_LANG
-
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const value_type& __v)
-        {return __tree_.__insert_multi(__v);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, const value_type& __v)
-        {return __tree_.__insert_multi(__p, __v);}
-
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        void insert(_InputIterator __f, _InputIterator __l)
-        {
-            for (const_iterator __e = cend(); __f != __l; ++__f)
-                __tree_.__insert_multi(__e, *__f);
-        }
+  }
+#endif
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(value_type&& __v)
-        {return __tree_.__insert_multi(_VSTD::move(__v));}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(value_type&& __v) { return __tree_.__insert_multi(std::move(__v)); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, value_type&& __v)
-        {return __tree_.__insert_multi(__p, _VSTD::move(__v));}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v) {
+    return __tree_.__insert_multi(__p, std::move(__v));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void insert(initializer_list<value_type> __il)
-        {insert(__il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator  erase(const_iterator __p) {return __tree_.erase(__p);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type erase(const key_type& __k) {return __tree_.__erase_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator  erase(const_iterator __f, const_iterator __l)
-        {return __tree_.erase(__f, __l);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__tree_.clear();}
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p) { return __tree_.erase(__p); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __tree_.__erase_multi(__k); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __f, const_iterator __l) { return __tree_.erase(__f, __l); }
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __tree_.clear(); }
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to multiset::insert()");
-        return __tree_.template __node_handle_insert_multi<node_type>(
-            _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __hint, node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to multiset::insert()");
-        return __tree_.template __node_handle_insert_multi<node_type>(
-            __hint, _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(key_type const& __key)
-    {
-        return __tree_.template __node_handle_extract<node_type>(__key);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(const_iterator __it)
-    {
-        return __tree_.template __node_handle_extract<node_type>(__it);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(multiset<key_type, _Compare2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_multi(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(multiset<key_type, _Compare2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_multi(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(set<key_type, _Compare2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_multi(__source.__tree_);
-    }
-    template <class _Compare2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(set<key_type, _Compare2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __tree_.__node_handle_merge_multi(__source.__tree_);
-    }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to multiset::insert()");
+    return __tree_.template __node_handle_insert_multi<node_type>(std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to multiset::insert()");
+    return __tree_.template __node_handle_insert_multi<node_type>(__hint, std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+    return __tree_.template __node_handle_extract<node_type>(__key);
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+    return __tree_.template __node_handle_extract<node_type>(__it);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(multiset<key_type, _Compare2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_multi(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(multiset<key_type, _Compare2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_multi(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(set<key_type, _Compare2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_multi(__source.__tree_);
+  }
+  template <class _Compare2>
+  _LIBCPP_HIDE_FROM_ABI void merge(set<key_type, _Compare2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __tree_.__node_handle_merge_multi(__source.__tree_);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(multiset& __s)
-        _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
-        {__tree_.swap(__s.__tree_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(multiset& __s) _NOEXCEPT_(__is_nothrow_swappable_v<__base>) {
+    __tree_.swap(__s.__tree_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT {return __tree_.__alloc();}
-    _LIBCPP_INLINE_VISIBILITY
-    key_compare    key_comp()      const {return __tree_.value_comp();}
-    _LIBCPP_INLINE_VISIBILITY
-    value_compare  value_comp()    const {return __tree_.value_comp();}
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return __tree_.__alloc(); }
+  _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp(); }
+  _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return __tree_.value_comp(); }
 
-    // set operations:
-    _LIBCPP_INLINE_VISIBILITY
-    iterator find(const key_type& __k)             {return __tree_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const key_type& __k) const {return __tree_.find(__k);}
+  // set operations:
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
-    find(const _K2& __k)                           {return __tree_.find(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
-    find(const _K2& __k) const                     {return __tree_.find(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+    return __tree_.find(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+    return __tree_.find(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type      count(const key_type& __k) const
-        {return __tree_.__count_multi(__k);}
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __tree_.__count_multi(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,size_type>::type
-    count(const _K2& __k) const            {return __tree_.__count_multi(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+    return __tree_.__count_multi(__k);
+  }
 #endif
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const key_type& __k) const {return find(__k) != end();}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value, bool>::type
-    contains(const _K2& __k) const { return find(__k) != end(); }
+  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+    return find(__k) != end();
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator lower_bound(const key_type& __k)
-        {return __tree_.lower_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator lower_bound(const key_type& __k) const
-            {return __tree_.lower_bound(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) { return __tree_.lower_bound(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const { return __tree_.lower_bound(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
-    lower_bound(const _K2& __k)       {return __tree_.lower_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {
+    return __tree_.lower_bound(__k);
+  }
 
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
-    lower_bound(const _K2& __k) const {return __tree_.lower_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {
+    return __tree_.lower_bound(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator upper_bound(const key_type& __k)
-            {return __tree_.upper_bound(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator upper_bound(const key_type& __k) const
-            {return __tree_.upper_bound(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) { return __tree_.upper_bound(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const { return __tree_.upper_bound(__k); }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,iterator>::type
-    upper_bound(const _K2& __k)       {return __tree_.upper_bound(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,const_iterator>::type
-    upper_bound(const _K2& __k) const {return __tree_.upper_bound(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
+    return __tree_.upper_bound(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {
+    return __tree_.upper_bound(__k);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator,iterator>             equal_range(const key_type& __k)
-            {return __tree_.__equal_range_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator,const_iterator> equal_range(const key_type& __k) const
-            {return __tree_.__equal_range_multi(__k);}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __tree_.__equal_range_multi(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __tree_.__equal_range_multi(__k);
+  }
 #if _LIBCPP_STD_VER >= 14
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<iterator,iterator>>::type
-    equal_range(const _K2& __k)       {return __tree_.__equal_range_multi(__k);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    typename enable_if<__is_transparent<_Compare, _K2>::value,pair<const_iterator,const_iterator>>::type
-    equal_range(const _K2& __k) const {return __tree_.__equal_range_multi(__k);}
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+    return __tree_.__equal_range_multi(__k);
+  }
+  template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+    return __tree_.__equal_range_multi(__k);
+  }
 #endif
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Compare = less<__iter_value_type<_InputIterator>>,
-         class _Allocator = allocator<__iter_value_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>,
-         class = enable_if_t<!__is_allocator<_Compare>::value, void>>
+template <class _InputIterator,
+          class _Compare   = less<__iter_value_type<_InputIterator>>,
+          class _Allocator = allocator<__iter_value_type<_InputIterator>>,
+          class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>>
 multiset(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
-  -> multiset<__iter_value_type<_InputIterator>, _Compare, _Allocator>;
+    -> multiset<__iter_value_type<_InputIterator>, _Compare, _Allocator>;
 
-template<class _Key, class _Compare = less<_Key>,
-         class _Allocator = allocator<_Key>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>,
-         class = enable_if_t<!__is_allocator<_Compare>::value, void>>
-multiset(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator())
-  -> multiset<_Key, _Compare, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Compare   = less<ranges::range_value_t<_Range>>,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>>
+multiset(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
+    -> multiset<ranges::range_value_t<_Range>, _Compare, _Allocator>;
+#  endif
 
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+template <class _Key,
+          class _Compare   = less<_Key>,
+          class _Allocator = allocator<_Key>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class            = enable_if_t<!__is_allocator<_Compare>::value, void>>
+multiset(initializer_list<_Key>,
+         _Compare   = _Compare(),
+         _Allocator = _Allocator()) -> multiset<_Key, _Compare, _Allocator>;
+
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
+          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
 multiset(_InputIterator, _InputIterator, _Allocator)
-  -> multiset<__iter_value_type<_InputIterator>,
-         less<__iter_value_type<_InputIterator>>, _Allocator>;
+    -> multiset<__iter_value_type<_InputIterator>, less<__iter_value_type<_InputIterator>>, _Allocator>;
 
-template<class _Key, class _Allocator,
-         class = enable_if_t<__is_allocator<_Allocator>::value, void>>
-multiset(initializer_list<_Key>, _Allocator)
-  -> multiset<_Key, less<_Key>, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+multiset(from_range_t,
+         _Range&&,
+         _Allocator) -> multiset<ranges::range_value_t<_Range>, less<ranges::range_value_t<_Range>>, _Allocator>;
+#  endif
+
+template <class _Key, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+multiset(initializer_list<_Key>, _Allocator) -> multiset<_Key, less<_Key>, _Allocator>;
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Compare, class _Allocator>
 multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_type& __a)
-    : __tree_(_VSTD::move(__s.__tree_), __a)
-{
-    if (__a != __s.get_allocator())
-    {
-        const_iterator __e = cend();
-        while (!__s.empty())
-            insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_));
-    }
+    : __tree_(std::move(__s.__tree_), __a) {
+  if (__a != __s.get_allocator()) {
+    const_iterator __e = cend();
+    while (!__s.empty())
+      insert(__e, std::move(__s.__tree_.remove(__s.begin())->__value_));
+  }
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const multiset<_Key, _Compare, _Allocator>& __x,
-           const multiset<_Key, _Compare, _Allocator>& __y)
-{
-    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const multiset<_Key, _Compare, _Allocator>& __x, const multiset<_Key, _Compare, _Allocator>& __y) {
+  return __x.size() == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 #if _LIBCPP_STD_VER <= 17
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const multiset<_Key, _Compare, _Allocator>& __x,
-           const multiset<_Key, _Compare, _Allocator>& __y)
-{
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(const multiset<_Key, _Compare, _Allocator>& __x, const multiset<_Key, _Compare, _Allocator>& __y) {
+  return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const multiset<_Key, _Compare, _Allocator>& __x,
-           const multiset<_Key, _Compare, _Allocator>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const multiset<_Key, _Compare, _Allocator>& __x, const multiset<_Key, _Compare, _Allocator>& __y) {
+  return !(__x == __y);
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator> (const multiset<_Key, _Compare, _Allocator>& __x,
-           const multiset<_Key, _Compare, _Allocator>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(const multiset<_Key, _Compare, _Allocator>& __x, const multiset<_Key, _Compare, _Allocator>& __y) {
+  return __y < __x;
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const multiset<_Key, _Compare, _Allocator>& __x,
-           const multiset<_Key, _Compare, _Allocator>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(const multiset<_Key, _Compare, _Allocator>& __x, const multiset<_Key, _Compare, _Allocator>& __y) {
+  return !(__x < __y);
 }
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const multiset<_Key, _Compare, _Allocator>& __x,
-           const multiset<_Key, _Compare, _Allocator>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(const multiset<_Key, _Compare, _Allocator>& __x, const multiset<_Key, _Compare, _Allocator>& __y) {
+  return !(__y < __x);
 }
 
 #else // _LIBCPP_STD_VER <= 17
@@ -1592,28 +1452,24 @@ operator<=(const multiset<_Key, _Compare, _Allocator>& __x,
 template <class _Key, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI __synth_three_way_result<_Key>
 operator<=>(const multiset<_Key, _Allocator>& __x, const multiset<_Key, _Allocator>& __y) {
-    return std::lexicographical_compare_three_way(
-        __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way<_Key, _Key>);
+  return std::lexicographical_compare_three_way(
+      __x.begin(), __x.end(), __y.begin(), __y.end(), __synth_three_way);
 }
 
 #endif // _LIBCPP_STD_VER <= 17
 
 template <class _Key, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(multiset<_Key, _Compare, _Allocator>& __x,
-     multiset<_Key, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(multiset<_Key, _Compare, _Allocator>& __x, multiset<_Key, _Compare, _Allocator>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Key, class _Compare, class _Allocator, class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-    typename multiset<_Key, _Compare, _Allocator>::size_type
-    erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
-  return _VSTD::__libcpp_erase_if_container(__c, __pred);
+inline _LIBCPP_HIDE_FROM_ABI typename multiset<_Key, _Compare, _Allocator>::size_type
+erase_if(multiset<_Key, _Compare, _Allocator>& __c, _Predicate __pred) {
+  return std::__libcpp_erase_if_container(__c, __pred);
 }
 #endif
 
@@ -1623,19 +1479,22 @@ _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _KeyT, class _CompareT = std::less<_KeyT>>
-using set = std::set<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
+using set _LIBCPP_AVAILABILITY_PMR = std::set<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
 
 template <class _KeyT, class _CompareT = std::less<_KeyT>>
-using multiset = std::multiset<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
+using multiset _LIBCPP_AVAILABILITY_PMR = std::multiset<_KeyT, _CompareT, polymorphic_allocator<_KeyT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstdlib>
 #  include <functional>
 #  include <iterator>
+#  include <stdexcept>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/setjmp.h b/third_party/libcxx/setjmp.h
deleted file mode 100644
index f4a2bbcb0..000000000
--- a/third_party/libcxx/setjmp.h
+++ /dev/null
@@ -1,46 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_SETJMP_H
-#define _LIBCPP_SETJMP_H
-
-/*
-    setjmp.h synopsis
-
-Macros:
-
-    setjmp
-
-Types:
-
-    jmp_buf
-
-void longjmp(jmp_buf env, int val);
-
-*/
-
-#include <__config>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#if __has_include_next(<setjmp.h>)
-#  include_next <setjmp.h>
-#endif
-
-#ifdef __cplusplus
-
-#ifndef setjmp
-#define setjmp(env) setjmp(env)
-#endif
-
-#endif // __cplusplus
-
-#endif // _LIBCPP_SETJMP_H
diff --git a/third_party/libcxx/shared_mutex b/third_party/libcxx/shared_mutex
index f84a7d9da..f63bd2549 100644
--- a/third_party/libcxx/shared_mutex
+++ b/third_party/libcxx/shared_mutex
@@ -122,399 +122,341 @@ template <class Mutex>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__availability>
-#include <__chrono/duration.h>
-#include <__chrono/steady_clock.h>
-#include <__chrono/time_point.h>
-#include <__condition_variable/condition_variable.h>
 #include <__config>
-#include <__memory/addressof.h>
-#include <__mutex/mutex.h>
-#include <__mutex/tag_types.h>
-#include <__mutex/unique_lock.h>
-#include <__system_error/system_error.h>
-#include <__utility/swap.h>
-#include <cerrno>
-#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+
+#  include <__chrono/duration.h>
+#  include <__chrono/steady_clock.h>
+#  include <__chrono/time_point.h>
+#  include <__condition_variable/condition_variable.h>
+#  include <__memory/addressof.h>
+#  include <__mutex/mutex.h>
+#  include <__mutex/tag_types.h>
+#  include <__mutex/unique_lock.h>
+#  include <__system_error/system_error.h>
+#  include <__utility/swap.h>
+#  include <cerrno>
+#  include <version>
 
 _LIBCPP_PUSH_MACROS
-#include <__undef_macros>
+#  include <__undef_macros>
 
+#  if _LIBCPP_STD_VER >= 14
 
-#if _LIBCPP_STD_VER >= 14 || defined(_LIBCPP_BUILDING_LIBRARY)
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#ifdef _LIBCPP_HAS_NO_THREADS
-# error "<shared_mutex> is not supported since libc++ has been configured without support for threads."
-#endif
+#    if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#      pragma GCC system_header
+#    endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX _LIBCPP_THREAD_SAFETY_ANNOTATION(capability("shared_mutex"))
-__shared_mutex_base
-{
-    mutex               __mut_;
-    condition_variable  __gate1_;
-    condition_variable  __gate2_;
-    unsigned            __state_;
+struct _LIBCPP_EXPORTED_FROM_ABI __shared_mutex_base {
+  mutex __mut_;
+  condition_variable __gate1_;
+  condition_variable __gate2_;
+  unsigned __state_;
 
-    static const unsigned __write_entered_ = 1U << (sizeof(unsigned)*__CHAR_BIT__ - 1);
-    static const unsigned __n_readers_ = ~__write_entered_;
+  static const unsigned __write_entered_ = 1U << (sizeof(unsigned) * __CHAR_BIT__ - 1);
+  static const unsigned __n_readers_     = ~__write_entered_;
 
-    __shared_mutex_base();
-    _LIBCPP_INLINE_VISIBILITY ~__shared_mutex_base() = default;
+  __shared_mutex_base();
+  _LIBCPP_HIDE_FROM_ABI ~__shared_mutex_base() = default;
 
-    __shared_mutex_base(const __shared_mutex_base&) = delete;
-    __shared_mutex_base& operator=(const __shared_mutex_base&) = delete;
+  __shared_mutex_base(const __shared_mutex_base&)            = delete;
+  __shared_mutex_base& operator=(const __shared_mutex_base&) = delete;
 
-    // Exclusive ownership
-    void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_capability()); // blocking
-    bool try_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_capability(true));
-    void unlock() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_capability());
+  // Exclusive ownership
+  void lock(); // blocking
+  bool try_lock();
+  void unlock();
 
-    // Shared ownership
-    void lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(acquire_shared_capability()); // blocking
-    bool try_lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(try_acquire_shared_capability(true));
-    void unlock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(release_shared_capability());
+  // Shared ownership
+  void lock_shared(); // blocking
+  bool try_lock_shared();
+  void unlock_shared();
 
-//     typedef implementation-defined native_handle_type; // See 30.2.3
-//     native_handle_type native_handle(); // See 30.2.3
+  //     typedef implementation-defined native_handle_type; // See 30.2.3
+  //     native_handle_type native_handle(); // See 30.2.3
 };
 
+#    if _LIBCPP_STD_VER >= 17
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_THREAD_SAFETY_ANNOTATION(__capability__("shared_mutex")) shared_mutex {
+  __shared_mutex_base __base_;
 
-#if _LIBCPP_STD_VER >= 17
-class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX shared_mutex
-{
-    __shared_mutex_base __base_;
 public:
-    _LIBCPP_INLINE_VISIBILITY shared_mutex() : __base_() {}
-    _LIBCPP_INLINE_VISIBILITY ~shared_mutex() = default;
+  _LIBCPP_HIDE_FROM_ABI shared_mutex() : __base_() {}
+  _LIBCPP_HIDE_FROM_ABI ~shared_mutex() = default;
 
-    shared_mutex(const shared_mutex&) = delete;
-    shared_mutex& operator=(const shared_mutex&) = delete;
+  shared_mutex(const shared_mutex&)            = delete;
+  shared_mutex& operator=(const shared_mutex&) = delete;
 
-    // Exclusive ownership
-    _LIBCPP_INLINE_VISIBILITY void lock()     { return __base_.lock(); }
-    _LIBCPP_INLINE_VISIBILITY bool try_lock() { return __base_.try_lock(); }
-    _LIBCPP_INLINE_VISIBILITY void unlock()   { return __base_.unlock(); }
+  // Exclusive ownership
+  _LIBCPP_HIDE_FROM_ABI void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__acquire_capability__()) {
+    return __base_.lock();
+  }
+  _LIBCPP_HIDE_FROM_ABI bool try_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_capability__(true)) {
+    return __base_.try_lock();
+  }
+  _LIBCPP_HIDE_FROM_ABI void unlock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__release_capability__()) {
+    return __base_.unlock();
+  }
 
-    // Shared ownership
-    _LIBCPP_INLINE_VISIBILITY void lock_shared()     { return __base_.lock_shared(); }
-    _LIBCPP_INLINE_VISIBILITY bool try_lock_shared() { return __base_.try_lock_shared(); }
-    _LIBCPP_INLINE_VISIBILITY void unlock_shared()   { return __base_.unlock_shared(); }
+  // Shared ownership
+  _LIBCPP_HIDE_FROM_ABI void lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(__acquire_shared_capability__()) {
+    return __base_.lock_shared();
+  }
+  _LIBCPP_HIDE_FROM_ABI bool try_lock_shared()
+      _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_shared_capability__(true)) {
+    return __base_.try_lock_shared();
+  }
+  _LIBCPP_HIDE_FROM_ABI void unlock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(__release_shared_capability__()) {
+    return __base_.unlock_shared();
+  }
 
-//     typedef __shared_mutex_base::native_handle_type native_handle_type;
-//     _LIBCPP_INLINE_VISIBILITY native_handle_type native_handle() { return __base::unlock_shared(); }
+  //     typedef __shared_mutex_base::native_handle_type native_handle_type;
+  //     _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return __base::unlock_shared(); }
 };
-#endif
+#    endif
 
+class _LIBCPP_EXPORTED_FROM_ABI
+_LIBCPP_THREAD_SAFETY_ANNOTATION(__capability__("shared_timed_mutex")) shared_timed_mutex {
+  __shared_mutex_base __base_;
 
-class _LIBCPP_TYPE_VIS _LIBCPP_AVAILABILITY_SHARED_MUTEX shared_timed_mutex
-{
-    __shared_mutex_base __base_;
 public:
-    shared_timed_mutex();
-    _LIBCPP_INLINE_VISIBILITY ~shared_timed_mutex() = default;
+  shared_timed_mutex();
+  _LIBCPP_HIDE_FROM_ABI ~shared_timed_mutex() = default;
 
-    shared_timed_mutex(const shared_timed_mutex&) = delete;
-    shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
+  shared_timed_mutex(const shared_timed_mutex&)            = delete;
+  shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
 
-    // Exclusive ownership
-    void lock();
-    bool try_lock();
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        bool
-        try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
-        {
-            return try_lock_until(chrono::steady_clock::now() + __rel_time);
-        }
-    template <class _Clock, class _Duration>
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-        bool
-        try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
-    void unlock();
+  // Exclusive ownership
+  void lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__acquire_capability__());
+  bool try_lock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_capability__(true));
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time)
+      _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_capability__(true)) {
+    return try_lock_until(chrono::steady_clock::now() + __rel_time);
+  }
+  template <class _Clock, class _Duration>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool
+  try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time)
+      _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_capability__(true));
+  void unlock() _LIBCPP_THREAD_SAFETY_ANNOTATION(__release_capability__());
 
-    // Shared ownership
-    void lock_shared();
-    bool try_lock_shared();
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        bool
-        try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time)
-        {
-            return try_lock_shared_until(chrono::steady_clock::now() + __rel_time);
-        }
-    template <class _Clock, class _Duration>
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-        bool
-        try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
-    void unlock_shared();
+  // Shared ownership
+  void lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(__acquire_shared_capability__());
+  bool try_lock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_shared_capability__(true));
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI bool try_lock_shared_for(const chrono::duration<_Rep, _Period>& __rel_time)
+      _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_shared_capability__(true)) {
+    return try_lock_shared_until(chrono::steady_clock::now() + __rel_time);
+  }
+  template <class _Clock, class _Duration>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS bool
+  try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time)
+      _LIBCPP_THREAD_SAFETY_ANNOTATION(__try_acquire_shared_capability__(true));
+  void unlock_shared() _LIBCPP_THREAD_SAFETY_ANNOTATION(__release_shared_capability__());
 };
 
 template <class _Clock, class _Duration>
-bool
-shared_timed_mutex::try_lock_until(
-                        const chrono::time_point<_Clock, _Duration>& __abs_time)
-{
-    unique_lock<mutex> __lk(__base_.__mut_);
-    if (__base_.__state_ & __base_.__write_entered_)
-    {
-        while (true)
-        {
-            cv_status __status = __base_.__gate1_.wait_until(__lk, __abs_time);
-            if ((__base_.__state_ & __base_.__write_entered_) == 0)
-                break;
-            if (__status == cv_status::timeout)
-                return false;
-        }
+bool shared_timed_mutex::try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time) {
+  unique_lock<mutex> __lk(__base_.__mut_);
+  if (__base_.__state_ & __base_.__write_entered_) {
+    while (true) {
+      cv_status __status = __base_.__gate1_.wait_until(__lk, __abs_time);
+      if ((__base_.__state_ & __base_.__write_entered_) == 0)
+        break;
+      if (__status == cv_status::timeout)
+        return false;
     }
-    __base_.__state_ |= __base_.__write_entered_;
-    if (__base_.__state_ & __base_.__n_readers_)
-    {
-        while (true)
-        {
-            cv_status __status = __base_.__gate2_.wait_until(__lk, __abs_time);
-            if ((__base_.__state_ & __base_.__n_readers_) == 0)
-                break;
-            if (__status == cv_status::timeout)
-            {
-                __base_.__state_ &= ~__base_.__write_entered_;
-                __base_.__gate1_.notify_all();
-                return false;
-            }
-        }
+  }
+  __base_.__state_ |= __base_.__write_entered_;
+  if (__base_.__state_ & __base_.__n_readers_) {
+    while (true) {
+      cv_status __status = __base_.__gate2_.wait_until(__lk, __abs_time);
+      if ((__base_.__state_ & __base_.__n_readers_) == 0)
+        break;
+      if (__status == cv_status::timeout) {
+        __base_.__state_ &= ~__base_.__write_entered_;
+        __base_.__gate1_.notify_all();
+        return false;
+      }
     }
-    return true;
+  }
+  return true;
 }
 
 template <class _Clock, class _Duration>
-bool
-shared_timed_mutex::try_lock_shared_until(
-                        const chrono::time_point<_Clock, _Duration>& __abs_time)
-{
-    unique_lock<mutex> __lk(__base_.__mut_);
-    if ((__base_.__state_ & __base_.__write_entered_) || (__base_.__state_ & __base_.__n_readers_) == __base_.__n_readers_)
-    {
-        while (true)
-        {
-            cv_status __status = __base_.__gate1_.wait_until(__lk, __abs_time);
-            if ((__base_.__state_ & __base_.__write_entered_) == 0 &&
-                                       (__base_.__state_ & __base_.__n_readers_) < __base_.__n_readers_)
-                break;
-            if (__status == cv_status::timeout)
-                return false;
-        }
+bool shared_timed_mutex::try_lock_shared_until(const chrono::time_point<_Clock, _Duration>& __abs_time) {
+  unique_lock<mutex> __lk(__base_.__mut_);
+  if ((__base_.__state_ & __base_.__write_entered_) ||
+      (__base_.__state_ & __base_.__n_readers_) == __base_.__n_readers_) {
+    while (true) {
+      cv_status __status = __base_.__gate1_.wait_until(__lk, __abs_time);
+      if ((__base_.__state_ & __base_.__write_entered_) == 0 &&
+          (__base_.__state_ & __base_.__n_readers_) < __base_.__n_readers_)
+        break;
+      if (__status == cv_status::timeout)
+        return false;
     }
-    unsigned __num_readers = (__base_.__state_ & __base_.__n_readers_) + 1;
-    __base_.__state_ &= ~__base_.__n_readers_;
-    __base_.__state_ |= __num_readers;
-    return true;
+  }
+  unsigned __num_readers = (__base_.__state_ & __base_.__n_readers_) + 1;
+  __base_.__state_ &= ~__base_.__n_readers_;
+  __base_.__state_ |= __num_readers;
+  return true;
 }
 
 template <class _Mutex>
-class shared_lock
-{
+class shared_lock {
 public:
-    typedef _Mutex mutex_type;
+  typedef _Mutex mutex_type;
 
 private:
-    mutex_type* __m_;
-    bool __owns_;
+  mutex_type* __m_;
+  bool __owns_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    shared_lock() _NOEXCEPT
-        : __m_(nullptr),
-          __owns_(false)
-        {}
+  _LIBCPP_HIDE_FROM_ABI shared_lock() _NOEXCEPT : __m_(nullptr), __owns_(false) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit shared_lock(mutex_type& __m)
-        : __m_(_VSTD::addressof(__m)),
-          __owns_(true)
-        {__m_->lock_shared();}
+  _LIBCPP_HIDE_FROM_ABI explicit shared_lock(mutex_type& __m) : __m_(std::addressof(__m)), __owns_(true) {
+    __m_->lock_shared();
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    shared_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
-        : __m_(_VSTD::addressof(__m)),
-          __owns_(false)
-        {}
+  _LIBCPP_HIDE_FROM_ABI shared_lock(mutex_type& __m, defer_lock_t) _NOEXCEPT
+      : __m_(std::addressof(__m)),
+        __owns_(false) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    shared_lock(mutex_type& __m, try_to_lock_t)
-        : __m_(_VSTD::addressof(__m)),
-          __owns_(__m.try_lock_shared())
-        {}
+  _LIBCPP_HIDE_FROM_ABI shared_lock(mutex_type& __m, try_to_lock_t)
+      : __m_(std::addressof(__m)), __owns_(__m.try_lock_shared()) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    shared_lock(mutex_type& __m, adopt_lock_t)
-        : __m_(_VSTD::addressof(__m)),
-          __owns_(true)
-        {}
+  _LIBCPP_HIDE_FROM_ABI shared_lock(mutex_type& __m, adopt_lock_t) : __m_(std::addressof(__m)), __owns_(true) {}
 
-    template <class _Clock, class _Duration>
-        _LIBCPP_INLINE_VISIBILITY
-        shared_lock(mutex_type& __m,
-                    const chrono::time_point<_Clock, _Duration>& __abs_time)
-            : __m_(_VSTD::addressof(__m)),
-              __owns_(__m.try_lock_shared_until(__abs_time))
-            {}
+  template <class _Clock, class _Duration>
+  _LIBCPP_HIDE_FROM_ABI shared_lock(mutex_type& __m, const chrono::time_point<_Clock, _Duration>& __abs_time)
+      : __m_(std::addressof(__m)), __owns_(__m.try_lock_shared_until(__abs_time)) {}
 
-    template <class _Rep, class _Period>
-        _LIBCPP_INLINE_VISIBILITY
-        shared_lock(mutex_type& __m,
-                    const chrono::duration<_Rep, _Period>& __rel_time)
-            : __m_(_VSTD::addressof(__m)),
-              __owns_(__m.try_lock_shared_for(__rel_time))
-            {}
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI shared_lock(mutex_type& __m, const chrono::duration<_Rep, _Period>& __rel_time)
+      : __m_(std::addressof(__m)), __owns_(__m.try_lock_shared_for(__rel_time)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    ~shared_lock()
-    {
-        if (__owns_)
-            __m_->unlock_shared();
-    }
+  _LIBCPP_HIDE_FROM_ABI ~shared_lock() {
+    if (__owns_)
+      __m_->unlock_shared();
+  }
 
-    shared_lock(shared_lock const&) = delete;
-    shared_lock& operator=(shared_lock const&) = delete;
+  shared_lock(shared_lock const&)            = delete;
+  shared_lock& operator=(shared_lock const&) = delete;
 
-    _LIBCPP_INLINE_VISIBILITY
-    shared_lock(shared_lock&& __u) _NOEXCEPT
-        : __m_(__u.__m_),
-          __owns_(__u.__owns_)
-        {
-            __u.__m_ = nullptr;
-            __u.__owns_ = false;
-        }
+  _LIBCPP_HIDE_FROM_ABI shared_lock(shared_lock&& __u) _NOEXCEPT : __m_(__u.__m_), __owns_(__u.__owns_) {
+    __u.__m_    = nullptr;
+    __u.__owns_ = false;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    shared_lock& operator=(shared_lock&& __u) _NOEXCEPT
-    {
-        if (__owns_)
-            __m_->unlock_shared();
-        __m_ = nullptr;
-        __owns_ = false;
-        __m_ = __u.__m_;
-        __owns_ = __u.__owns_;
-        __u.__m_ = nullptr;
-        __u.__owns_ = false;
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI shared_lock& operator=(shared_lock&& __u) _NOEXCEPT {
+    if (__owns_)
+      __m_->unlock_shared();
+    __m_        = nullptr;
+    __owns_     = false;
+    __m_        = __u.__m_;
+    __owns_     = __u.__owns_;
+    __u.__m_    = nullptr;
+    __u.__owns_ = false;
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI void lock();
-    _LIBCPP_HIDE_FROM_ABI bool try_lock();
-    template <class Rep, class Period>
-    _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<Rep, Period>& __rel_time);
-    template <class Clock, class Duration>
-    _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<Clock, Duration>& __abs_time);
-    _LIBCPP_HIDE_FROM_ABI void unlock();
+  _LIBCPP_HIDE_FROM_ABI void lock();
+  _LIBCPP_HIDE_FROM_ABI bool try_lock();
+  template <class _Rep, class _Period>
+  _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __rel_time);
+  template <class _Clock, class _Duration>
+  _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __abs_time);
+  _LIBCPP_HIDE_FROM_ABI void unlock();
 
-    // Setters
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_lock& __u) _NOEXCEPT
-    {
-        _VSTD::swap(__m_, __u.__m_);
-        _VSTD::swap(__owns_, __u.__owns_);
-    }
+  // Setters
+  _LIBCPP_HIDE_FROM_ABI void swap(shared_lock& __u) _NOEXCEPT {
+    std::swap(__m_, __u.__m_);
+    std::swap(__owns_, __u.__owns_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    mutex_type* release() _NOEXCEPT
-    {
-        mutex_type* __m = __m_;
-        __m_ = nullptr;
-        __owns_ = false;
-        return __m;
-    }
+  _LIBCPP_HIDE_FROM_ABI mutex_type* release() _NOEXCEPT {
+    mutex_type* __m = __m_;
+    __m_            = nullptr;
+    __owns_         = false;
+    return __m;
+  }
 
-    // Getters
-    _LIBCPP_INLINE_VISIBILITY
-    bool owns_lock() const _NOEXCEPT {return __owns_;}
+  // Getters
+  _LIBCPP_HIDE_FROM_ABI bool owns_lock() const _NOEXCEPT { return __owns_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit operator bool () const _NOEXCEPT {return __owns_;}
+  _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __owns_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    mutex_type* mutex() const _NOEXCEPT {return __m_;}
+  _LIBCPP_HIDE_FROM_ABI mutex_type* mutex() const _NOEXCEPT { return __m_; }
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(shared_lock);
 
 template <class _Mutex>
-void
-shared_lock<_Mutex>::lock()
-{
-    if (__m_ == nullptr)
-        __throw_system_error(EPERM, "shared_lock::lock: references null mutex");
-    if (__owns_)
-        __throw_system_error(EDEADLK, "shared_lock::lock: already locked");
-    __m_->lock_shared();
-    __owns_ = true;
+void shared_lock<_Mutex>::lock() {
+  if (__m_ == nullptr)
+    __throw_system_error(EPERM, "shared_lock::lock: references null mutex");
+  if (__owns_)
+    __throw_system_error(EDEADLK, "shared_lock::lock: already locked");
+  __m_->lock_shared();
+  __owns_ = true;
 }
 
 template <class _Mutex>
-bool
-shared_lock<_Mutex>::try_lock()
-{
-    if (__m_ == nullptr)
-        __throw_system_error(EPERM, "shared_lock::try_lock: references null mutex");
-    if (__owns_)
-        __throw_system_error(EDEADLK, "shared_lock::try_lock: already locked");
-    __owns_ = __m_->try_lock_shared();
-    return __owns_;
+bool shared_lock<_Mutex>::try_lock() {
+  if (__m_ == nullptr)
+    __throw_system_error(EPERM, "shared_lock::try_lock: references null mutex");
+  if (__owns_)
+    __throw_system_error(EDEADLK, "shared_lock::try_lock: already locked");
+  __owns_ = __m_->try_lock_shared();
+  return __owns_;
 }
 
 template <class _Mutex>
 template <class _Rep, class _Period>
-bool
-shared_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d)
-{
-    if (__m_ == nullptr)
-        __throw_system_error(EPERM, "shared_lock::try_lock_for: references null mutex");
-    if (__owns_)
-        __throw_system_error(EDEADLK, "shared_lock::try_lock_for: already locked");
-    __owns_ = __m_->try_lock_shared_for(__d);
-    return __owns_;
+bool shared_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
+  if (__m_ == nullptr)
+    __throw_system_error(EPERM, "shared_lock::try_lock_for: references null mutex");
+  if (__owns_)
+    __throw_system_error(EDEADLK, "shared_lock::try_lock_for: already locked");
+  __owns_ = __m_->try_lock_shared_for(__d);
+  return __owns_;
 }
 
 template <class _Mutex>
 template <class _Clock, class _Duration>
-bool
-shared_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t)
-{
-    if (__m_ == nullptr)
-        __throw_system_error(EPERM, "shared_lock::try_lock_until: references null mutex");
-    if (__owns_)
-        __throw_system_error(EDEADLK, "shared_lock::try_lock_until: already locked");
-    __owns_ = __m_->try_lock_shared_until(__t);
-    return __owns_;
+bool shared_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
+  if (__m_ == nullptr)
+    __throw_system_error(EPERM, "shared_lock::try_lock_until: references null mutex");
+  if (__owns_)
+    __throw_system_error(EDEADLK, "shared_lock::try_lock_until: already locked");
+  __owns_ = __m_->try_lock_shared_until(__t);
+  return __owns_;
 }
 
 template <class _Mutex>
-void
-shared_lock<_Mutex>::unlock()
-{
-    if (!__owns_)
-        __throw_system_error(EPERM, "shared_lock::unlock: not locked");
-    __m_->unlock_shared();
-    __owns_ = false;
+void shared_lock<_Mutex>::unlock() {
+  if (!__owns_)
+    __throw_system_error(EPERM, "shared_lock::unlock: not locked");
+  __m_->unlock_shared();
+  __owns_ = false;
 }
 
 template <class _Mutex>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) _NOEXCEPT
-    {__x.swap(__y);}
+inline _LIBCPP_HIDE_FROM_ABI void swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) _NOEXCEPT {
+  __x.swap(__y);
+}
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP_STD_VER >= 14
+#  endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
+#endif // !defined(_LIBCPP_HAS_NO_THREADS)
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <system_error>
 #endif
diff --git a/third_party/libcxx/shared_mutex.cpp b/third_party/libcxx/shared_mutex.cpp
new file mode 100644
index 000000000..1a346dda0
--- /dev/null
+++ b/third_party/libcxx/shared_mutex.cpp
@@ -0,0 +1,93 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <mutex>
+#include <shared_mutex>
+#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#  pragma comment(lib, "pthread")
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// Shared Mutex Base
+__shared_mutex_base::__shared_mutex_base() : __state_(0) {}
+
+// Exclusive ownership
+
+void __shared_mutex_base::lock() {
+  unique_lock<mutex> lk(__mut_);
+  while (__state_ & __write_entered_)
+    __gate1_.wait(lk);
+  __state_ |= __write_entered_;
+  while (__state_ & __n_readers_)
+    __gate2_.wait(lk);
+}
+
+bool __shared_mutex_base::try_lock() {
+  unique_lock<mutex> lk(__mut_);
+  if (__state_ == 0) {
+    __state_ = __write_entered_;
+    return true;
+  }
+  return false;
+}
+
+void __shared_mutex_base::unlock() {
+  lock_guard<mutex> _(__mut_);
+  __state_ = 0;
+  __gate1_.notify_all();
+}
+
+// Shared ownership
+
+void __shared_mutex_base::lock_shared() {
+  unique_lock<mutex> lk(__mut_);
+  while ((__state_ & __write_entered_) || (__state_ & __n_readers_) == __n_readers_)
+    __gate1_.wait(lk);
+  unsigned num_readers = (__state_ & __n_readers_) + 1;
+  __state_ &= ~__n_readers_;
+  __state_ |= num_readers;
+}
+
+bool __shared_mutex_base::try_lock_shared() {
+  unique_lock<mutex> lk(__mut_);
+  unsigned num_readers = __state_ & __n_readers_;
+  if (!(__state_ & __write_entered_) && num_readers != __n_readers_) {
+    ++num_readers;
+    __state_ &= ~__n_readers_;
+    __state_ |= num_readers;
+    return true;
+  }
+  return false;
+}
+
+void __shared_mutex_base::unlock_shared() {
+  lock_guard<mutex> _(__mut_);
+  unsigned num_readers = (__state_ & __n_readers_) - 1;
+  __state_ &= ~__n_readers_;
+  __state_ |= num_readers;
+  if (__state_ & __write_entered_) {
+    if (num_readers == 0)
+      __gate2_.notify_one();
+  } else {
+    if (num_readers == __n_readers_ - 1)
+      __gate1_.notify_one();
+  }
+}
+
+// Shared Timed Mutex
+// These routines are here for ABI stability
+shared_timed_mutex::shared_timed_mutex() : __base_() {}
+void shared_timed_mutex::lock() { return __base_.lock(); }
+bool shared_timed_mutex::try_lock() { return __base_.try_lock(); }
+void shared_timed_mutex::unlock() { return __base_.unlock(); }
+void shared_timed_mutex::lock_shared() { return __base_.lock_shared(); }
+bool shared_timed_mutex::try_lock_shared() { return __base_.try_lock_shared(); }
+void shared_timed_mutex::unlock_shared() { return __base_.unlock_shared(); }
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/source_location b/third_party/libcxx/source_location
index e9e852a6e..d16e3c46f 100644
--- a/third_party/libcxx/source_location
+++ b/third_party/libcxx/source_location
@@ -35,8 +35,7 @@ namespace std {
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if _LIBCPP_STD_VER >= 20 && __has_builtin(__builtin_source_location) &&                                               \
-    !(defined(_LIBCPP_APPLE_CLANG_VER) && _LIBCPP_APPLE_CLANG_VER <= 1403)
+#if _LIBCPP_STD_VER >= 20
 
 class source_location {
   // The names source_location::__impl, _M_file_name, _M_function_name, _M_line, and _M_column
@@ -79,8 +78,7 @@ public:
   }
 };
 
-#endif // _LIBCPP_STD_VER >= 20 && __has_builtin(__builtin_source_location) && !(defined(_LIBCPP_APPLE_CLANG_VER) &&
-       // _LIBCPP_APPLE_CLANG_VER <= 1403)
+#endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/third_party/libcxx/span b/third_party/libcxx/span
index 0464c94fa..60d76d830 100644
--- a/third_party/libcxx/span
+++ b/third_party/libcxx/span
@@ -18,6 +18,20 @@ namespace std {
 // constants
 inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max();
 
+template<class T>
+  concept integral-constant-like =                           // exposition only, since C++26
+    is_integral_v<decltype(T::value)> &&
+    !is_same_v<bool, remove_const_t<decltype(T::value)>> &&
+    convertible_to<T, decltype(T::value)> &&
+    equality_comparable_with<T, decltype(T::value)> &&
+    bool_constant<T() == T::value>::value &&
+    bool_constant<static_cast<decltype(T::value)>(T()) == T::value>::value;
+
+template<class T>
+  constexpr size_t maybe-static-ext = dynamic_extent;        // exposition only, since C++26
+template<integral-constant-like T>
+  constexpr size_t maybe-static-ext<T> = {T::value};
+
 // [views.span], class template span
 template <class ElementType, size_t Extent = dynamic_extent>
     class span;
@@ -68,10 +82,10 @@ public:
         constexpr span(const array<value_type, N>& arr) noexcept;
     template<class R>
       constexpr explicit(Extent != dynamic_extent) span(R&& r);
+    constexpr explicit(extent != dynamic_extent) span(std::initializer_list<value_type> il); // Since C++26
     constexpr span(const span& other) noexcept = default;
     template <class OtherElementType, size_t OtherExtent>
         constexpr explicit(Extent != dynamic_extent) span(const span<OtherElementType, OtherExtent>& s) noexcept;
-    ~span() noexcept = default;
     constexpr span& operator=(const span& other) noexcept = default;
 
     // [span.sub], span subviews
@@ -93,6 +107,7 @@ public:
 
     // [span.elem], span element access
     constexpr reference operator[](size_type idx) const;
+    constexpr reference at(size_type idx) const; // since C++26
     constexpr reference front() const;
     constexpr reference back() const;
     constexpr pointer data() const noexcept;
@@ -109,7 +124,9 @@ private:
 };
 
 template<class It, class EndOrSize>
-    span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;
+    span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;                             // until C++26
+template<class It, class EndOrSize>
+    span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>, maybe-static-ext<EndOrSize>>; // since C++26
 
 template<class T, size_t N>
     span(T (&)[N]) -> span<T, N>;
@@ -127,13 +144,16 @@ template<class R>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
+#include <__concepts/convertible_to.h>
+#include <__concepts/equality_comparable.h>
 #include <__config>
-#include <__debug>
+#include <__fwd/array.h>
 #include <__fwd/span.h>
 #include <__iterator/bounded_iter.h>
 #include <__iterator/concepts.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/reverse_iterator.h>
 #include <__iterator/wrap_iter.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/concepts.h>
@@ -141,14 +161,21 @@ template<class R>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__ranges/size.h>
+#include <__type_traits/integral_constant.h>
+#include <__type_traits/is_array.h>
+#include <__type_traits/is_const.h>
 #include <__type_traits/is_convertible.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_same.h>
+#include <__type_traits/remove_const.h>
+#include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_cvref.h>
 #include <__type_traits/remove_reference.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
-#include <array>        // for array
-#include <cstddef>      // for byte
-#include <limits>
+#include <cstddef> // for byte
+#include <initializer_list>
+#include <stdexcept>
 #include <version>
 
 // standard-mandated includes
@@ -171,12 +198,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 20
 
-template <class _Tp>
-struct __is_std_array : false_type {};
-
-template <class _Tp, size_t _Sz>
-struct __is_std_array<array<_Tp, _Sz>> : true_type {};
-
 template <class _Tp>
 struct __is_std_span : false_type {};
 
@@ -185,19 +206,20 @@ struct __is_std_span<span<_Tp, _Sz>> : true_type {};
 
 template <class _Range, class _ElementType>
 concept __span_compatible_range =
-  ranges::contiguous_range<_Range> &&
-  ranges::sized_range<_Range> &&
-  (ranges::borrowed_range<_Range> || is_const_v<_ElementType>) &&
-  !__is_std_span<remove_cvref_t<_Range>>::value  &&
-  !__is_std_array<remove_cvref_t<_Range>>::value &&
-  !is_array_v<remove_cvref_t<_Range>> &&
-  is_convertible_v<remove_reference_t<ranges::range_reference_t<_Range>>(*)[], _ElementType(*)[]>;
+    ranges::contiguous_range<_Range> &&                             //
+    ranges::sized_range<_Range> &&                                  //
+    (ranges::borrowed_range<_Range> || is_const_v<_ElementType>) && //
+    !__is_std_span<remove_cvref_t<_Range>>::value &&                //
+    !__is_std_array<remove_cvref_t<_Range>>::value &&               //
+    !is_array_v<remove_cvref_t<_Range>> &&                          //
+    is_convertible_v<remove_reference_t<ranges::range_reference_t<_Range>> (*)[], _ElementType (*)[]>;
 
 template <class _From, class _To>
-concept __span_array_convertible = is_convertible_v<_From(*)[], _To(*)[]>;
+concept __span_array_convertible = is_convertible_v<_From (*)[], _To (*)[]>;
 
 template <class _It, class _Tp>
-concept __span_compatible_iterator = contiguous_iterator<_It> && __span_array_convertible<remove_reference_t<iter_reference_t<_It>>, _Tp>;
+concept __span_compatible_iterator =
+    contiguous_iterator<_It> && __span_array_convertible<remove_reference_t<iter_reference_t<_It>>, _Tp>;
 
 template <class _Sentinel, class _It>
 concept __span_compatible_sentinel_for = sized_sentinel_for<_Sentinel, _It> && !is_convertible_v<_Sentinel, size_t>;
@@ -205,351 +227,345 @@ concept __span_compatible_sentinel_for = sized_sentinel_for<_Sentinel, _It> && !
 template <typename _Tp, size_t _Extent>
 class _LIBCPP_TEMPLATE_VIS span {
 public:
-//  constants and types
-    using element_type           = _Tp;
-    using value_type             = remove_cv_t<_Tp>;
-    using size_type              = size_t;
-    using difference_type        = ptrdiff_t;
-    using pointer                = _Tp *;
-    using const_pointer          = const _Tp *;
-    using reference              = _Tp &;
-    using const_reference        = const _Tp &;
-#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
-    using iterator               = __bounded_iter<pointer>;
-#else
-    using iterator               = __wrap_iter<pointer>;
-#endif
-    using reverse_iterator       = _VSTD::reverse_iterator<iterator>;
+  //  constants and types
+  using element_type    = _Tp;
+  using value_type      = remove_cv_t<_Tp>;
+  using size_type       = size_t;
+  using difference_type = ptrdiff_t;
+  using pointer         = _Tp*;
+  using const_pointer   = const _Tp*;
+  using reference       = _Tp&;
+  using const_reference = const _Tp&;
+#  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
+  using iterator = __bounded_iter<pointer>;
+#  else
+  using iterator = __wrap_iter<pointer>;
+#  endif
+  using reverse_iterator = std::reverse_iterator<iterator>;
 
-    static constexpr size_type extent = _Extent;
+  static constexpr size_type extent = _Extent;
 
-// [span.cons], span constructors, copy, assignment, and destructor
-    template <size_t _Sz = _Extent> requires(_Sz == 0)
-    _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data_{nullptr} {}
+  // [span.cons], span constructors, copy, assignment, and destructor
+  template <size_t _Sz = _Extent>
+    requires(_Sz == 0)
+  _LIBCPP_HIDE_FROM_ABI constexpr span() noexcept : __data_{nullptr} {}
 
-    constexpr span           (const span&) noexcept = default;
-    constexpr span& operator=(const span&) noexcept = default;
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit span(std::initializer_list<value_type> __il)
+    requires is_const_v<element_type>
+      : __data_{__il.begin()} {
+    _LIBCPP_ASSERT_VALID_INPUT_RANGE(
+        _Extent == __il.size(), "Size mismatch in span's constructor _Extent != __il.size().");
+  }
+#  endif
 
-    template <__span_compatible_iterator<element_type> _It>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit span(_It __first, size_type __count)
-        : __data_{_VSTD::to_address(__first)} {
-      (void)__count;
-      _LIBCPP_ASSERT(_Extent == __count, "size mismatch in span's constructor (iterator, len)");
-    }
+  constexpr span(const span&) noexcept            = default;
+  constexpr span& operator=(const span&) noexcept = default;
 
-    template <__span_compatible_iterator<element_type> _It, __span_compatible_sentinel_for<_It> _End>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit span(_It __first, _End __last) : __data_{_VSTD::to_address(__first)} {
-      // [span.cons]/10
-      // Throws: When and what last - first throws.
-      [[maybe_unused]] auto __dist = __last - __first;
-      _LIBCPP_ASSERT(__dist >= 0, "invalid range in span's constructor (iterator, sentinel)");
-      _LIBCPP_ASSERT(
-          __dist == _Extent, "invalid range in span's constructor (iterator, sentinel): last - first != extent");
-    }
+  template <__span_compatible_iterator<element_type> _It>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit span(_It __first, size_type __count) : __data_{std::to_address(__first)} {
+    (void)__count;
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Extent == __count, "size mismatch in span's constructor (iterator, len)");
+  }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr span(type_identity_t<element_type> (&__arr)[_Extent]) noexcept : __data_{__arr} {}
+  template <__span_compatible_iterator<element_type> _It, __span_compatible_sentinel_for<_It> _End>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit span(_It __first, _End __last) : __data_{std::to_address(__first)} {
+    // [span.cons]/10
+    // Throws: When and what last - first throws.
+    [[maybe_unused]] auto __dist = __last - __first;
+    _LIBCPP_ASSERT_VALID_INPUT_RANGE(__dist >= 0, "invalid range in span's constructor (iterator, sentinel)");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __dist == _Extent, "invalid range in span's constructor (iterator, sentinel): last - first != extent");
+  }
 
-    template <__span_array_convertible<element_type> _OtherElementType>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span(array<_OtherElementType, _Extent>& __arr) noexcept : __data_{__arr.data()} {}
+  _LIBCPP_HIDE_FROM_ABI constexpr span(type_identity_t<element_type> (&__arr)[_Extent]) noexcept : __data_{__arr} {}
 
-    template <class _OtherElementType>
-        requires __span_array_convertible<const _OtherElementType, element_type>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span(const array<_OtherElementType, _Extent>& __arr) noexcept : __data_{__arr.data()} {}
+  template <__span_array_convertible<element_type> _OtherElementType>
+  _LIBCPP_HIDE_FROM_ABI constexpr span(array<_OtherElementType, _Extent>& __arr) noexcept : __data_{__arr.data()} {}
 
-    template <__span_compatible_range<element_type> _Range>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr explicit span(_Range&& __r) : __data_{ranges::data(__r)} {
-      _LIBCPP_ASSERT(ranges::size(__r) == _Extent, "size mismatch in span's constructor (range)");
-    }
+  template <class _OtherElementType>
+    requires __span_array_convertible<const _OtherElementType, element_type>
+  _LIBCPP_HIDE_FROM_ABI constexpr span(const array<_OtherElementType, _Extent>& __arr) noexcept
+      : __data_{__arr.data()} {}
 
-    template <__span_array_convertible<element_type> _OtherElementType>
-    _LIBCPP_INLINE_VISIBILITY
-        constexpr span(const span<_OtherElementType, _Extent>& __other)
-        : __data_{__other.data()} {}
+  template <__span_compatible_range<element_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit span(_Range&& __r) : __data_{ranges::data(__r)} {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(ranges::size(__r) == _Extent, "size mismatch in span's constructor (range)");
+  }
 
-    template <__span_array_convertible<element_type> _OtherElementType>
-    _LIBCPP_INLINE_VISIBILITY
-        constexpr explicit span(const span<_OtherElementType, dynamic_extent>& __other) noexcept
-        : __data_{__other.data()} { _LIBCPP_ASSERT(_Extent == __other.size(), "size mismatch in span's constructor (other span)"); }
+  template <__span_array_convertible<element_type> _OtherElementType>
+  _LIBCPP_HIDE_FROM_ABI constexpr span(const span<_OtherElementType, _Extent>& __other) noexcept
+      : __data_{__other.data()} {}
 
+  template <__span_array_convertible<element_type> _OtherElementType>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit span(const span<_OtherElementType, dynamic_extent>& __other) noexcept
+      : __data_{__other.data()} {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Extent == __other.size(), "size mismatch in span's constructor (other span)");
+  }
 
-//  ~span() noexcept = default;
+  template <size_t _Count>
+  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> first() const noexcept {
+    static_assert(_Count <= _Extent, "span<T, N>::first<Count>(): Count out of range");
+    return span<element_type, _Count>{data(), _Count};
+  }
 
-    template <size_t _Count>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, _Count> first() const noexcept
-    {
-        static_assert(_Count <= _Extent, "span<T, N>::first<Count>(): Count out of range");
-        return span<element_type, _Count>{data(), _Count};
-    }
+  template <size_t _Count>
+  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> last() const noexcept {
+    static_assert(_Count <= _Extent, "span<T, N>::last<Count>(): Count out of range");
+    return span<element_type, _Count>{data() + size() - _Count, _Count};
+  }
 
-    template <size_t _Count>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, _Count> last() const noexcept
-    {
-        static_assert(_Count <= _Extent, "span<T, N>::last<Count>(): Count out of range");
-        return span<element_type, _Count>{data() + size() - _Count, _Count};
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T, N>::first(count): count out of range");
+    return {data(), __count};
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept
-    {
-        _LIBCPP_ASSERT(__count <= size(), "span<T, N>::first(count): count out of range");
-        return {data(), __count};
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> last(size_type __count) const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T, N>::last(count): count out of range");
+    return {data() + size() - __count, __count};
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, dynamic_extent> last(size_type __count) const noexcept
-    {
-        _LIBCPP_ASSERT(__count <= size(), "span<T, N>::last(count): count out of range");
-        return {data() + size() - __count, __count};
-    }
+  template <size_t _Offset, size_t _Count = dynamic_extent>
+  _LIBCPP_HIDE_FROM_ABI constexpr auto
+  subspan() const noexcept -> span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset> {
+    static_assert(_Offset <= _Extent, "span<T, N>::subspan<Offset, Count>(): Offset out of range");
+    static_assert(_Count == dynamic_extent || _Count <= _Extent - _Offset,
+                  "span<T, N>::subspan<Offset, Count>(): Offset + Count out of range");
 
-    template <size_t _Offset, size_t _Count = dynamic_extent>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr auto subspan() const noexcept
-        -> span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>
-    {
-        static_assert(_Offset <= _Extent, "span<T, N>::subspan<Offset, Count>(): Offset out of range");
-        static_assert(_Count == dynamic_extent || _Count <= _Extent - _Offset, "span<T, N>::subspan<Offset, Count>(): Offset + Count out of range");
+    using _ReturnType = span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>;
+    return _ReturnType{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
+  }
 
-        using _ReturnType = span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset>;
-        return _ReturnType{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent>
+  subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__offset <= size(), "span<T, N>::subspan(offset, count): offset out of range");
+    if (__count == dynamic_extent)
+      return {data() + __offset, size() - __offset};
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __count <= size() - __offset, "span<T, N>::subspan(offset, count): offset + count out of range");
+    return {data() + __offset, __count};
+  }
 
+  _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept { return _Extent; }
+  _LIBCPP_HIDE_FROM_ABI constexpr size_type size_bytes() const noexcept { return _Extent * sizeof(element_type); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const noexcept { return _Extent == 0; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, dynamic_extent>
-       subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept
-    {
-        _LIBCPP_ASSERT(__offset <= size(), "span<T, N>::subspan(offset, count): offset out of range");
-        if (__count == dynamic_extent)
-            return {data() + __offset, size() - __offset};
-        _LIBCPP_ASSERT(__count <= size() - __offset, "span<T, N>::subspan(offset, count): offset + count out of range");
-        return {data() + __offset, __count};
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](size_type __idx) const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__idx < size(), "span<T, N>::operator[](index): index out of range");
+    return __data_[__idx];
+  }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr size_type size()           const noexcept { return _Extent; }
-    _LIBCPP_INLINE_VISIBILITY constexpr size_type size_bytes()     const noexcept { return _Extent * sizeof(element_type); }
-    [[nodiscard]] _LIBCPP_INLINE_VISIBILITY constexpr bool empty() const noexcept { return _Extent == 0; }
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI constexpr reference at(size_type __index) const {
+    if (__index >= size())
+      std::__throw_out_of_range("span");
+    return __data_[__index];
+  }
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
-    {
-        _LIBCPP_ASSERT(__idx < size(), "span<T, N>::operator[](index): index out of range");
-        return __data_[__idx];
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr reference front() const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T, N>::front() on empty span");
+    return __data_[0];
+  }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr reference front() const noexcept
-    {
-        _LIBCPP_ASSERT(!empty(), "span<T, N>::front() on empty span");
-        return __data_[0];
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr reference back() const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T, N>::back() on empty span");
+    return __data_[size() - 1];
+  }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept
-    {
-        _LIBCPP_ASSERT(!empty(), "span<T, N>::back() on empty span");
-        return __data_[size()-1];
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr pointer data() const noexcept { return __data_; }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr pointer data()                         const noexcept { return __data_; }
+  // [span.iter], span iterator support
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() const noexcept {
+#  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
+    return std::__make_bounded_iter(data(), data(), data() + size());
+#  else
+    return iterator(data());
+#  endif
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator end() const noexcept {
+#  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
+    return std::__make_bounded_iter(data() + size(), data(), data() + size());
+#  else
+    return iterator(data() + size());
+#  endif
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
 
-// [span.iter], span iterator support
-    _LIBCPP_INLINE_VISIBILITY constexpr iterator begin() const noexcept {
-#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
-        return std::__make_bounded_iter(data(), data(), data() + size());
-#else
-        return iterator(this, data());
-#endif
-    }
-    _LIBCPP_INLINE_VISIBILITY constexpr iterator end() const noexcept {
-#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
-        return std::__make_bounded_iter(data() + size(), data(), data() + size());
-#else
-        return iterator(this, data() + size());
-#endif
-    }
-    _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator        rbegin() const noexcept { return reverse_iterator(end()); }
-    _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator          rend() const noexcept { return reverse_iterator(begin()); }
+  _LIBCPP_HIDE_FROM_ABI span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept {
+    return span<const byte, _Extent * sizeof(element_type)>{reinterpret_cast<const byte*>(data()), size_bytes()};
+  }
 
-    _LIBCPP_INLINE_VISIBILITY span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept
-    { return span<const byte, _Extent * sizeof(element_type)>{reinterpret_cast<const byte *>(data()), size_bytes()}; }
-
-    _LIBCPP_INLINE_VISIBILITY span<byte, _Extent * sizeof(element_type)> __as_writable_bytes() const noexcept
-    { return span<byte, _Extent * sizeof(element_type)>{reinterpret_cast<byte *>(data()), size_bytes()}; }
+  _LIBCPP_HIDE_FROM_ABI span<byte, _Extent * sizeof(element_type)> __as_writable_bytes() const noexcept {
+    return span<byte, _Extent * sizeof(element_type)>{reinterpret_cast<byte*>(data()), size_bytes()};
+  }
 
 private:
-    pointer    __data_;
+  pointer __data_;
 };
 
-
 template <typename _Tp>
 class _LIBCPP_TEMPLATE_VIS span<_Tp, dynamic_extent> {
 public:
-//  constants and types
-    using element_type           = _Tp;
-    using value_type             = remove_cv_t<_Tp>;
-    using size_type              = size_t;
-    using difference_type        = ptrdiff_t;
-    using pointer                = _Tp *;
-    using const_pointer          = const _Tp *;
-    using reference              = _Tp &;
-    using const_reference        = const _Tp &;
-#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
-    using iterator               = __bounded_iter<pointer>;
-#else
-    using iterator               = __wrap_iter<pointer>;
-#endif
-    using reverse_iterator       = _VSTD::reverse_iterator<iterator>;
+  //  constants and types
+  using element_type    = _Tp;
+  using value_type      = remove_cv_t<_Tp>;
+  using size_type       = size_t;
+  using difference_type = ptrdiff_t;
+  using pointer         = _Tp*;
+  using const_pointer   = const _Tp*;
+  using reference       = _Tp&;
+  using const_reference = const _Tp&;
+#  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
+  using iterator = __bounded_iter<pointer>;
+#  else
+  using iterator = __wrap_iter<pointer>;
+#  endif
+  using reverse_iterator = std::reverse_iterator<iterator>;
 
-    static constexpr size_type extent = dynamic_extent;
+  static constexpr size_type extent = dynamic_extent;
 
-// [span.cons], span constructors, copy, assignment, and destructor
-    _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data_{nullptr}, __size_{0} {}
+  // [span.cons], span constructors, copy, assignment, and destructor
+  _LIBCPP_HIDE_FROM_ABI constexpr span() noexcept : __data_{nullptr}, __size_{0} {}
 
-    constexpr span           (const span&) noexcept = default;
-    constexpr span& operator=(const span&) noexcept = default;
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI constexpr span(std::initializer_list<value_type> __il)
+    requires is_const_v<element_type>
+      : __data_{__il.begin()}, __size_{__il.size()} {}
+#  endif
 
-    template <__span_compatible_iterator<element_type> _It>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span(_It __first, size_type __count)
-        : __data_{_VSTD::to_address(__first)}, __size_{__count} {}
+  constexpr span(const span&) noexcept            = default;
+  constexpr span& operator=(const span&) noexcept = default;
 
-    template <__span_compatible_iterator<element_type> _It, __span_compatible_sentinel_for<_It> _End>
-    _LIBCPP_INLINE_VISIBILITY constexpr span(_It __first, _End __last)
-        : __data_(_VSTD::to_address(__first)), __size_(__last - __first) {
-      _LIBCPP_ASSERT(__last - __first >= 0, "invalid range in span's constructor (iterator, sentinel)");
-    }
+  template <__span_compatible_iterator<element_type> _It>
+  _LIBCPP_HIDE_FROM_ABI constexpr span(_It __first, size_type __count)
+      : __data_{std::to_address(__first)}, __size_{__count} {}
 
-    template <size_t _Sz>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span(type_identity_t<element_type> (&__arr)[_Sz]) noexcept : __data_{__arr}, __size_{_Sz} {}
+  template <__span_compatible_iterator<element_type> _It, __span_compatible_sentinel_for<_It> _End>
+  _LIBCPP_HIDE_FROM_ABI constexpr span(_It __first, _End __last)
+      : __data_(std::to_address(__first)), __size_(__last - __first) {
+    _LIBCPP_ASSERT_VALID_INPUT_RANGE(__last - __first >= 0, "invalid range in span's constructor (iterator, sentinel)");
+  }
 
-    template <__span_array_convertible<element_type> _OtherElementType, size_t _Sz>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span(array<_OtherElementType, _Sz>& __arr) noexcept : __data_{__arr.data()}, __size_{_Sz} {}
+  template <size_t _Sz>
+  _LIBCPP_HIDE_FROM_ABI constexpr span(type_identity_t<element_type> (&__arr)[_Sz]) noexcept
+      : __data_{__arr}, __size_{_Sz} {}
 
-    template <class _OtherElementType, size_t _Sz>
-        requires __span_array_convertible<const _OtherElementType, element_type>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span(const array<_OtherElementType, _Sz>& __arr) noexcept : __data_{__arr.data()}, __size_{_Sz} {}
+  template <__span_array_convertible<element_type> _OtherElementType, size_t _Sz>
+  _LIBCPP_HIDE_FROM_ABI constexpr span(array<_OtherElementType, _Sz>& __arr) noexcept
+      : __data_{__arr.data()}, __size_{_Sz} {}
 
-    template <__span_compatible_range<element_type> _Range>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span(_Range&& __r) : __data_(ranges::data(__r)), __size_{ranges::size(__r)} {}
+  template <class _OtherElementType, size_t _Sz>
+    requires __span_array_convertible<const _OtherElementType, element_type>
+  _LIBCPP_HIDE_FROM_ABI constexpr span(const array<_OtherElementType, _Sz>& __arr) noexcept
+      : __data_{__arr.data()}, __size_{_Sz} {}
 
-    template <__span_array_convertible<element_type> _OtherElementType, size_t _OtherExtent>
-    _LIBCPP_INLINE_VISIBILITY
-        constexpr span(const span<_OtherElementType, _OtherExtent>& __other)  noexcept
-        : __data_{__other.data()}, __size_{__other.size()} {}
+  template <__span_compatible_range<element_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr span(_Range&& __r) : __data_(ranges::data(__r)), __size_{ranges::size(__r)} {}
 
-//    ~span() noexcept = default;
+  template <__span_array_convertible<element_type> _OtherElementType, size_t _OtherExtent>
+  _LIBCPP_HIDE_FROM_ABI constexpr span(const span<_OtherElementType, _OtherExtent>& __other) noexcept
+      : __data_{__other.data()}, __size_{__other.size()} {}
 
-    template <size_t _Count>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, _Count> first() const noexcept
-    {
-        _LIBCPP_ASSERT(_Count <= size(), "span<T>::first<Count>(): Count out of range");
-        return span<element_type, _Count>{data(), _Count};
-    }
+  template <size_t _Count>
+  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> first() const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Count <= size(), "span<T>::first<Count>(): Count out of range");
+    return span<element_type, _Count>{data(), _Count};
+  }
 
-    template <size_t _Count>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, _Count> last() const noexcept
-    {
-        _LIBCPP_ASSERT(_Count <= size(), "span<T>::last<Count>(): Count out of range");
-        return span<element_type, _Count>{data() + size() - _Count, _Count};
-    }
+  template <size_t _Count>
+  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> last() const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Count <= size(), "span<T>::last<Count>(): Count out of range");
+    return span<element_type, _Count>{data() + size() - _Count, _Count};
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept
-    {
-        _LIBCPP_ASSERT(__count <= size(), "span<T>::first(count): count out of range");
-        return {data(), __count};
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T>::first(count): count out of range");
+    return {data(), __count};
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, dynamic_extent> last (size_type __count) const noexcept
-    {
-        _LIBCPP_ASSERT(__count <= size(), "span<T>::last(count): count out of range");
-        return {data() + size() - __count, __count};
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> last(size_type __count) const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T>::last(count): count out of range");
+    return {data() + size() - __count, __count};
+  }
 
-    template <size_t _Offset, size_t _Count = dynamic_extent>
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr span<element_type, _Count> subspan() const noexcept
-    {
-        _LIBCPP_ASSERT(_Offset <= size(), "span<T>::subspan<Offset, Count>(): Offset out of range");
-        _LIBCPP_ASSERT(_Count == dynamic_extent || _Count <= size() - _Offset, "span<T>::subspan<Offset, Count>(): Offset + Count out of range");
-        return span<element_type, _Count>{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
-    }
+  template <size_t _Offset, size_t _Count = dynamic_extent>
+  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> subspan() const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Offset <= size(), "span<T>::subspan<Offset, Count>(): Offset out of range");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Count == dynamic_extent || _Count <= size() - _Offset,
+                                        "span<T>::subspan<Offset, Count>(): Offset + Count out of range");
+    return span<element_type, _Count>{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
+  }
 
-    constexpr span<element_type, dynamic_extent>
-    _LIBCPP_INLINE_VISIBILITY
-    subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept
-    {
-        _LIBCPP_ASSERT(__offset <= size(), "span<T>::subspan(offset, count): offset out of range");
-        if (__count == dynamic_extent)
-            return {data() + __offset, size() - __offset};
-        _LIBCPP_ASSERT(__count <= size() - __offset, "span<T>::subspan(offset, count): offset + count out of range");
-        return {data() + __offset, __count};
-    }
+  constexpr span<element_type, dynamic_extent> _LIBCPP_HIDE_FROM_ABI
+  subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__offset <= size(), "span<T>::subspan(offset, count): offset out of range");
+    if (__count == dynamic_extent)
+      return {data() + __offset, size() - __offset};
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+        __count <= size() - __offset, "span<T>::subspan(offset, count): offset + count out of range");
+    return {data() + __offset, __count};
+  }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr size_type size()           const noexcept { return __size_; }
-    _LIBCPP_INLINE_VISIBILITY constexpr size_type size_bytes()     const noexcept { return __size_ * sizeof(element_type); }
-    [[nodiscard]] _LIBCPP_INLINE_VISIBILITY constexpr bool empty() const noexcept { return __size_ == 0; }
+  _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept { return __size_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr size_type size_bytes() const noexcept { return __size_ * sizeof(element_type); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const noexcept { return __size_ == 0; }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr reference operator[](size_type __idx) const noexcept
-    {
-        _LIBCPP_ASSERT(__idx < size(), "span<T>::operator[](index): index out of range");
-        return __data_[__idx];
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](size_type __idx) const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__idx < size(), "span<T>::operator[](index): index out of range");
+    return __data_[__idx];
+  }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr reference front() const noexcept
-    {
-        _LIBCPP_ASSERT(!empty(), "span<T>::front() on empty span");
-        return __data_[0];
-    }
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI constexpr reference at(size_type __index) const {
+    if (__index >= size())
+      std::__throw_out_of_range("span");
+    return __data_[__index];
+  }
+#  endif
 
-    _LIBCPP_INLINE_VISIBILITY constexpr reference back() const noexcept
-    {
-        _LIBCPP_ASSERT(!empty(), "span<T>::back() on empty span");
-        return __data_[size()-1];
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr reference front() const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T>::front() on empty span");
+    return __data_[0];
+  }
 
+  _LIBCPP_HIDE_FROM_ABI constexpr reference back() const noexcept {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T>::back() on empty span");
+    return __data_[size() - 1];
+  }
 
-    _LIBCPP_INLINE_VISIBILITY constexpr pointer data()                         const noexcept { return __data_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr pointer data() const noexcept { return __data_; }
 
-// [span.iter], span iterator support
-    _LIBCPP_INLINE_VISIBILITY constexpr iterator begin() const noexcept {
-#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
-        return std::__make_bounded_iter(data(), data(), data() + size());
-#else
-        return iterator(this, data());
-#endif
-    }
-    _LIBCPP_INLINE_VISIBILITY constexpr iterator end() const noexcept {
-#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
-        return std::__make_bounded_iter(data() + size(), data(), data() + size());
-#else
-        return iterator(this, data() + size());
-#endif
-    }
-    _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator        rbegin() const noexcept { return reverse_iterator(end()); }
-    _LIBCPP_INLINE_VISIBILITY constexpr reverse_iterator          rend() const noexcept { return reverse_iterator(begin()); }
+  // [span.iter], span iterator support
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() const noexcept {
+#  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
+    return std::__make_bounded_iter(data(), data(), data() + size());
+#  else
+    return iterator(data());
+#  endif
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator end() const noexcept {
+#  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
+    return std::__make_bounded_iter(data() + size(), data(), data() + size());
+#  else
+    return iterator(data() + size());
+#  endif
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
+  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
 
-    _LIBCPP_INLINE_VISIBILITY span<const byte, dynamic_extent> __as_bytes() const noexcept
-    { return {reinterpret_cast<const byte *>(data()), size_bytes()}; }
+  _LIBCPP_HIDE_FROM_ABI span<const byte, dynamic_extent> __as_bytes() const noexcept {
+    return {reinterpret_cast<const byte*>(data()), size_bytes()};
+  }
 
-    _LIBCPP_INLINE_VISIBILITY span<byte, dynamic_extent> __as_writable_bytes() const noexcept
-    { return {reinterpret_cast<byte *>(data()), size_bytes()}; }
+  _LIBCPP_HIDE_FROM_ABI span<byte, dynamic_extent> __as_writable_bytes() const noexcept {
+    return {reinterpret_cast<byte*>(data()), size_bytes()};
+  }
 
 private:
-    pointer   __data_;
-    size_type __size_;
+  pointer __data_;
+  size_type __size_;
 };
 
 template <class _Tp, size_t _Extent>
@@ -560,31 +576,48 @@ inline constexpr bool ranges::enable_view<span<_ElementType, _Extent>> = true;
 
 //  as_bytes & as_writable_bytes
 template <class _Tp, size_t _Extent>
-_LIBCPP_INLINE_VISIBILITY
-auto as_bytes(span<_Tp, _Extent> __s) noexcept
-{ return __s.__as_bytes(); }
+_LIBCPP_HIDE_FROM_ABI auto as_bytes(span<_Tp, _Extent> __s) noexcept {
+  return __s.__as_bytes();
+}
 
-template <class _Tp, size_t _Extent> requires(!is_const_v<_Tp>)
-_LIBCPP_INLINE_VISIBILITY
-auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept
-{ return __s.__as_writable_bytes(); }
+template <class _Tp, size_t _Extent>
+  requires(!is_const_v<_Tp>)
+_LIBCPP_HIDE_FROM_ABI auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept {
+  return __s.__as_writable_bytes();
+}
 
-#if _LIBCPP_STD_VER >= 20
-template<contiguous_iterator _It, class _EndOrSize>
-    span(_It, _EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;
-#endif // _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 26
+template <class _Tp>
+concept __integral_constant_like =
+    is_integral_v<decltype(_Tp::value)> && !is_same_v<bool, remove_const_t<decltype(_Tp::value)>> &&
+    convertible_to<_Tp, decltype(_Tp::value)> && equality_comparable_with<_Tp, decltype(_Tp::value)> &&
+    bool_constant<_Tp() == _Tp::value>::value &&
+    bool_constant<static_cast<decltype(_Tp::value)>(_Tp()) == _Tp::value>::value;
 
-template<class _Tp, size_t _Sz>
-    span(_Tp (&)[_Sz]) -> span<_Tp, _Sz>;
+template <class _Tp>
+inline constexpr size_t __maybe_static_ext = dynamic_extent;
 
-template<class _Tp, size_t _Sz>
-    span(array<_Tp, _Sz>&) -> span<_Tp, _Sz>;
+template <__integral_constant_like _Tp>
+inline constexpr size_t __maybe_static_ext<_Tp> = {_Tp::value};
 
-template<class _Tp, size_t _Sz>
-    span(const array<_Tp, _Sz>&) -> span<const _Tp, _Sz>;
+template <contiguous_iterator _It, class _EndOrSize>
+span(_It, _EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>, __maybe_static_ext<_EndOrSize>>;
+#  else
+template <contiguous_iterator _It, class _EndOrSize>
+span(_It, _EndOrSize) -> span<remove_reference_t<iter_reference_t<_It>>>;
+#  endif
 
-template<ranges::contiguous_range _Range>
-    span(_Range&&) -> span<remove_reference_t<ranges::range_reference_t<_Range>>>;
+template <class _Tp, size_t _Sz>
+span(_Tp (&)[_Sz]) -> span<_Tp, _Sz>;
+
+template <class _Tp, size_t _Sz>
+span(array<_Tp, _Sz>&) -> span<_Tp, _Sz>;
+
+template <class _Tp, size_t _Sz>
+span(const array<_Tp, _Sz>&) -> span<const _Tp, _Sz>;
+
+template <ranges::contiguous_range _Range>
+span(_Range&&) -> span<remove_reference_t<ranges::range_reference_t<_Range>>>;
 
 #endif // _LIBCPP_STD_VER >= 20
 
@@ -593,6 +626,7 @@ _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <array>
 #  include <concepts>
 #  include <functional>
 #  include <iterator>
diff --git a/third_party/libcxx/src/any.cpp b/third_party/libcxx/src/any.cpp
deleted file mode 100644
index 9a101b44a..000000000
--- a/third_party/libcxx/src/any.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <any>
-
-namespace std {
-const char* bad_any_cast::what() const noexcept {
-    return "bad any cast";
-}
-}
-
-
-#include <experimental/__config>
-
-//  Preserve std::experimental::any_bad_cast for ABI compatibility
-//  Even though it no longer exists in a header file
-_LIBCPP_BEGIN_NAMESPACE_LFTS
-
-class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
-{
-public:
-    virtual const char* what() const noexcept;
-};
-
-const char* bad_any_cast::what() const noexcept {
-    return "bad any cast";
-}
-
-_LIBCPP_END_NAMESPACE_LFTS
diff --git a/third_party/libcxx/src/atomic.cpp b/third_party/libcxx/src/atomic.cpp
deleted file mode 100644
index 9a34210b6..000000000
--- a/third_party/libcxx/src/atomic.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-#ifndef _LIBCPP_HAS_NO_THREADS
-
-#include <atomic>
-#include <climits>
-#include <functional>
-#include <thread>
-
-#ifdef __linux__
-
-#include <unistd.h>
-#include <linux/futex.h>
-#include <sys/syscall.h>
-
-// libc++ uses SYS_futex as a universal syscall name. However, on 32 bit architectures
-// with a 64 bit time_t, we need to specify SYS_futex_time64.
-#if !defined(SYS_futex) && defined(SYS_futex_time64)
-# define SYS_futex SYS_futex_time64
-#endif
-
-#elif defined(__FreeBSD__)
-
-#include <sys/types.h>
-#include <sys/umtx.h>
-
-#else // <- Add other operating systems here
-
-// Baseline needs no new headers
-
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#ifdef __linux__
-
-static void __libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr,
-                                              __cxx_contention_t __val)
-{
-    static constexpr timespec __timeout = { 2, 0 };
-    syscall(SYS_futex, __ptr, FUTEX_WAIT_PRIVATE, __val, &__timeout, 0, 0);
-}
-
-static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr,
-                                              bool __notify_one)
-{
-    syscall(SYS_futex, __ptr, FUTEX_WAKE_PRIVATE, __notify_one ? 1 : INT_MAX, 0, 0, 0);
-}
-
-#elif defined(__APPLE__) && defined(_LIBCPP_USE_ULOCK)
-
-extern "C" int __ulock_wait(uint32_t operation, void *addr, uint64_t value,
-                            uint32_t timeout); /* timeout is specified in microseconds */
-extern "C" int __ulock_wake(uint32_t operation, void *addr, uint64_t wake_value);
-
-#define UL_COMPARE_AND_WAIT 1
-#define ULF_WAKE_ALL        0x00000100
-
-static void __libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr,
-                                              __cxx_contention_t __val)
-{
-    __ulock_wait(UL_COMPARE_AND_WAIT,
-                 const_cast<__cxx_atomic_contention_t*>(__ptr), __val, 0);
-}
-
-static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr,
-                                              bool __notify_one)
-{
-    __ulock_wake(UL_COMPARE_AND_WAIT | (__notify_one ? 0 : ULF_WAKE_ALL),
-                 const_cast<__cxx_atomic_contention_t*>(__ptr), 0);
-}
-
-#elif defined(__FreeBSD__) && __SIZEOF_LONG__ == 8
-/*
- * Since __cxx_contention_t is int64_t even on 32bit FreeBSD
- * platforms, we have to use umtx ops that work on the long type, and
- * limit its use to architectures where long and int64_t are synonyms.
- */
-
-static void __libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr,
-                                              __cxx_contention_t __val)
-{
-    _umtx_op(const_cast<__cxx_atomic_contention_t*>(__ptr),
-             UMTX_OP_WAIT, __val, NULL, NULL);
-}
-
-static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr,
-                                              bool __notify_one)
-{
-    _umtx_op(const_cast<__cxx_atomic_contention_t*>(__ptr),
-             UMTX_OP_WAKE, __notify_one ? 1 : INT_MAX, NULL, NULL);
-}
-
-#else // <- Add other operating systems here
-
-// Baseline is just a timed backoff
-
-static void __libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr,
-                                              __cxx_contention_t __val)
-{
-    __libcpp_thread_poll_with_backoff([=]() -> bool {
-        return !__cxx_nonatomic_compare_equal(__cxx_atomic_load(__ptr, memory_order_relaxed), __val);
-    }, __libcpp_timed_backoff_policy());
-}
-
-static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile*, bool) { }
-
-#endif // __linux__
-
-static constexpr size_t __libcpp_contention_table_size = (1 << 8);  /* < there's no magic in this number */
-
-struct alignas(64) /*  aim to avoid false sharing */ __libcpp_contention_table_entry
-{
-    __cxx_atomic_contention_t __contention_state;
-    __cxx_atomic_contention_t __platform_state;
-    inline constexpr __libcpp_contention_table_entry() :
-        __contention_state(0), __platform_state(0) { }
-};
-
-static __libcpp_contention_table_entry __libcpp_contention_table[ __libcpp_contention_table_size ];
-
-static hash<void const volatile*> __libcpp_contention_hasher;
-
-static __libcpp_contention_table_entry* __libcpp_contention_state(void const volatile * p)
-{
-    return &__libcpp_contention_table[__libcpp_contention_hasher(p) & (__libcpp_contention_table_size - 1)];
-}
-
-/* Given an atomic to track contention and an atomic to actually wait on, which may be
-   the same atomic, we try to detect contention to avoid spuriously calling the platform. */
-
-static void __libcpp_contention_notify(__cxx_atomic_contention_t volatile* __contention_state,
-                                       __cxx_atomic_contention_t const volatile* __platform_state,
-                                       bool __notify_one)
-{
-    if(0 != __cxx_atomic_load(__contention_state, memory_order_seq_cst))
-        // We only call 'wake' if we consumed a contention bit here.
-        __libcpp_platform_wake_by_address(__platform_state, __notify_one);
-}
-static __cxx_contention_t __libcpp_contention_monitor_for_wait(__cxx_atomic_contention_t volatile* __contention_state,
-                                                               __cxx_atomic_contention_t const volatile* __platform_state)
-{
-    // We will monitor this value.
-    return __cxx_atomic_load(__platform_state, memory_order_acquire);
-}
-static void __libcpp_contention_wait(__cxx_atomic_contention_t volatile* __contention_state,
-                                     __cxx_atomic_contention_t const volatile* __platform_state,
-                                     __cxx_contention_t __old_value)
-{
-    __cxx_atomic_fetch_add(__contention_state, __cxx_contention_t(1), memory_order_seq_cst);
-    // We sleep as long as the monitored value hasn't changed.
-    __libcpp_platform_wait_on_address(__platform_state, __old_value);
-    __cxx_atomic_fetch_sub(__contention_state, __cxx_contention_t(1), memory_order_release);
-}
-
-/* When the incoming atomic is the wrong size for the platform wait size, need to
-   launder the value sequence through an atomic from our table. */
-
-static void __libcpp_atomic_notify(void const volatile* __location)
-{
-    auto const __entry = __libcpp_contention_state(__location);
-    // The value sequence laundering happens on the next line below.
-    __cxx_atomic_fetch_add(&__entry->__platform_state, __cxx_contention_t(1), memory_order_release);
-    __libcpp_contention_notify(&__entry->__contention_state,
-                               &__entry->__platform_state,
-                               false /* when laundering, we can't handle notify_one */);
-}
-_LIBCPP_EXPORTED_FROM_ABI
-void __cxx_atomic_notify_one(void const volatile* __location)
-    { __libcpp_atomic_notify(__location); }
-_LIBCPP_EXPORTED_FROM_ABI
-void __cxx_atomic_notify_all(void const volatile* __location)
-    { __libcpp_atomic_notify(__location); }
-_LIBCPP_EXPORTED_FROM_ABI
-__cxx_contention_t __libcpp_atomic_monitor(void const volatile* __location)
-{
-    auto const __entry = __libcpp_contention_state(__location);
-    return __libcpp_contention_monitor_for_wait(&__entry->__contention_state, &__entry->__platform_state);
-}
-_LIBCPP_EXPORTED_FROM_ABI
-void __libcpp_atomic_wait(void const volatile* __location, __cxx_contention_t __old_value)
-{
-    auto const __entry = __libcpp_contention_state(__location);
-    __libcpp_contention_wait(&__entry->__contention_state, &__entry->__platform_state, __old_value);
-}
-
-/* When the incoming atomic happens to be the platform wait size, we still need to use the
-   table for the contention detection, but we can use the atomic directly for the wait. */
-
-_LIBCPP_EXPORTED_FROM_ABI
-void __cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile* __location)
-{
-    __libcpp_contention_notify(&__libcpp_contention_state(__location)->__contention_state, __location, true);
-}
-_LIBCPP_EXPORTED_FROM_ABI
-void __cxx_atomic_notify_all(__cxx_atomic_contention_t const volatile* __location)
-{
-    __libcpp_contention_notify(&__libcpp_contention_state(__location)->__contention_state, __location, false);
-}
-_LIBCPP_EXPORTED_FROM_ABI
-__cxx_contention_t __libcpp_atomic_monitor(__cxx_atomic_contention_t const volatile* __location)
-{
-    return __libcpp_contention_monitor_for_wait(&__libcpp_contention_state(__location)->__contention_state, __location);
-}
-_LIBCPP_EXPORTED_FROM_ABI
-void __libcpp_atomic_wait(__cxx_atomic_contention_t const volatile* __location, __cxx_contention_t __old_value)
-{
-    __libcpp_contention_wait(&__libcpp_contention_state(__location)->__contention_state, __location, __old_value);
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif //_LIBCPP_HAS_NO_THREADS
diff --git a/third_party/libcxx/src/barrier.cpp b/third_party/libcxx/src/barrier.cpp
deleted file mode 100644
index 8ce2c043c..000000000
--- a/third_party/libcxx/src/barrier.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-
-#include <barrier>
-#include <thread>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if !defined(_LIBCPP_HAS_NO_TREE_BARRIER)
-
-class __barrier_algorithm_base {
-public:
-    struct alignas(64) /* naturally-align the heap state */ __state_t
-    {
-        struct {
-          __atomic_base<__barrier_phase_t> __phase{0};
-        } __tickets[64];
-    };
-
-    ptrdiff_t&              __expected;
-    unique_ptr<__state_t[]> __state;
-
-    _LIBCPP_HIDDEN
-    __barrier_algorithm_base(ptrdiff_t& __expected)
-        : __expected(__expected)
-    {
-        size_t const __count = (__expected + 1) >> 1;
-        __state = unique_ptr<__state_t[]>(new __state_t[__count]);
-    }
-    _LIBCPP_HIDDEN
-    bool __arrive(__barrier_phase_t __old_phase)
-    {
-        __barrier_phase_t const __half_step = __old_phase + 1,
-                                __full_step = __old_phase + 2;
-        size_t __current_expected = __expected,
-            __current = hash<thread::id>()(this_thread::get_id()) % ((__expected + 1) >> 1);
-        for(int __round = 0;; ++__round) {
-            if(__current_expected <= 1)
-                return true;
-            size_t const __end_node = ((__current_expected + 1) >> 1),
-                         __last_node = __end_node - 1;
-            for(;;++__current) {
-                if(__current == __end_node)
-                __current = 0;
-                __barrier_phase_t expect = __old_phase;
-                if(__current == __last_node && (__current_expected & 1))
-                {
-                    if(__state[__current].__tickets[__round].__phase.compare_exchange_strong(expect, __full_step, memory_order_acq_rel))
-                        break;    // I'm 1 in 1, go to next __round
-                }
-                else if(__state[__current].__tickets[__round].__phase.compare_exchange_strong(expect, __half_step, memory_order_acq_rel))
-                {
-                    return false; // I'm 1 in 2, done with arrival
-                }
-                else if(expect == __half_step)
-                {
-                    if(__state[__current].__tickets[__round].__phase.compare_exchange_strong(expect, __full_step, memory_order_acq_rel))
-                        break;    // I'm 2 in 2, go to next __round
-                }
-            }
-            __current_expected = __last_node + 1;
-            __current >>= 1;
-        }
-    }
-};
-
-_LIBCPP_EXPORTED_FROM_ABI
-__barrier_algorithm_base * __construct_barrier_algorithm_base(ptrdiff_t& __expected)
-{
-    return new __barrier_algorithm_base(__expected);
-}
-_LIBCPP_EXPORTED_FROM_ABI
-bool __arrive_barrier_algorithm_base(__barrier_algorithm_base* __barrier,
-                                     __barrier_phase_t __old_phase)
-{
-    return __barrier->__arrive(__old_phase);
-}
-_LIBCPP_EXPORTED_FROM_ABI
-void __destroy_barrier_algorithm_base(__barrier_algorithm_base* __barrier)
-{
-    delete __barrier;
-}
-
-#endif // !defined(_LIBCPP_HAS_NO_TREE_BARRIER)
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif //_LIBCPP_HAS_NO_THREADS
diff --git a/third_party/libcxx/src/bind.cpp b/third_party/libcxx/src/bind.cpp
deleted file mode 100644
index 0e217e5fc..000000000
--- a/third_party/libcxx/src/bind.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <functional>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace placeholders
-{
-
-const __ph<1>   _1{};
-const __ph<2>   _2{};
-const __ph<3>   _3{};
-const __ph<4>   _4{};
-const __ph<5>   _5{};
-const __ph<6>   _6{};
-const __ph<7>   _7{};
-const __ph<8>   _8{};
-const __ph<9>   _9{};
-const __ph<10> _10{};
-
-}  // placeholders
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/charconv.cpp b/third_party/libcxx/src/charconv.cpp
deleted file mode 100644
index 3e0fe4d31..000000000
--- a/third_party/libcxx/src/charconv.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <charconv>
-#include <string.h>
-
-#include "third_party/libcxx/src/include/to_chars_floating_point.h"
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#ifndef _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
-
-namespace __itoa
-{
-
-_LIBCPP_FUNC_VIS char*
-__u32toa(uint32_t value, char* buffer) noexcept
-{
-  return __base_10_u32(buffer, value);
-}
-
-_LIBCPP_FUNC_VIS char*
-__u64toa(uint64_t value, char* buffer) noexcept
-{
-  return __base_10_u64(buffer, value);
-}
-
-}  // namespace __itoa
-
-#endif // _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
-
-// The original version of floating-point to_chars was written by Microsoft and
-// contributed with the following license.
-
-// Copyright (c) Microsoft Corporation.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-// This implementation is dedicated to the memory of Mary and Thavatchai.
-
-to_chars_result to_chars(char* __first, char* __last, float __value) {
-  return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(__first, __last, __value, chars_format{}, 0);
-}
-
-to_chars_result to_chars(char* __first, char* __last, double __value) {
-  return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(__first, __last, __value, chars_format{}, 0);
-}
-
-to_chars_result to_chars(char* __first, char* __last, long double __value) {
-  return _Floating_to_chars<_Floating_to_chars_overload::_Plain>(__first, __last, static_cast<double>(__value),
-                                                                 chars_format{}, 0);
-}
-
-to_chars_result to_chars(char* __first, char* __last, float __value, chars_format __fmt) {
-  return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(__first, __last, __value, __fmt, 0);
-}
-
-to_chars_result to_chars(char* __first, char* __last, double __value, chars_format __fmt) {
-  return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(__first, __last, __value, __fmt, 0);
-}
-
-to_chars_result to_chars(char* __first, char* __last, long double __value, chars_format __fmt) {
-  return _Floating_to_chars<_Floating_to_chars_overload::_Format_only>(__first, __last, static_cast<double>(__value),
-                                                                       __fmt, 0);
-}
-
-to_chars_result to_chars(char* __first, char* __last, float __value, chars_format __fmt, int __precision) {
-  return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(__first, __last, __value, __fmt,
-                                                                            __precision);
-}
-
-to_chars_result to_chars(char* __first, char* __last, double __value, chars_format __fmt, int __precision) {
-  return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(__first, __last, __value, __fmt,
-                                                                            __precision);
-}
-
-to_chars_result to_chars(char* __first, char* __last, long double __value, chars_format __fmt, int __precision) {
-  return _Floating_to_chars<_Floating_to_chars_overload::_Format_precision>(
-      __first, __last, static_cast<double>(__value), __fmt, __precision);
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/chrono.cpp b/third_party/libcxx/src/chrono.cpp
deleted file mode 100644
index ffeb48508..000000000
--- a/third_party/libcxx/src/chrono.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#if defined(__MVS__)
-// As part of monotonic clock support on z/OS we need macro _LARGE_TIME_API
-// to be defined before any system header to include definition of struct timespec64.
-#define _LARGE_TIME_API
-#endif
-
-#include <__system_error/system_error.h>
-#include <cerrno> // errno
-#include <chrono>
-
-#if defined(__MVS__)
-#include <__support/ibm/gettod_zos.h> // gettimeofdayMonotonic
-#endif
-
-#include <time.h>        // clock_gettime and CLOCK_{MONOTONIC,REALTIME,MONOTONIC_RAW}
-#include "third_party/libcxx/src/include/apple_availability.h"
-
-#if __has_include(<unistd.h>)
-# include <unistd.h>
-#endif
-
-#if __has_include(<sys/time.h>)
-# include <sys/time.h> // for gettimeofday and timeval
-#endif
-
-#if !defined(__APPLE__) && defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0
-# define _LIBCPP_USE_CLOCK_GETTIME
-#endif
-
-#if defined(_LIBCPP_WIN32API)
-#  define WIN32_LEAN_AND_MEAN
-#  define VC_EXTRA_LEAN
-#  include <windows.h>
-#  if _WIN32_WINNT >= _WIN32_WINNT_WIN8
-#    include <winapifamily.h>
-#  endif
-#endif // defined(_LIBCPP_WIN32API)
-
-#if defined(__Fuchsia__)
-#  include <zircon/syscalls.h>
-#endif
-
-#if __has_include(<mach/mach_time.h>)
-# include <mach/mach_time.h>
-#endif
-
-#if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
-#  pragma comment(lib, "rt")
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace chrono
-{
-
-//
-// system_clock
-//
-
-#if defined(_LIBCPP_WIN32API)
-
-#if _WIN32_WINNT < _WIN32_WINNT_WIN8
-
-namespace {
-
-typedef void(WINAPI *GetSystemTimeAsFileTimePtr)(LPFILETIME);
-
-class GetSystemTimeInit {
-public:
-  GetSystemTimeInit() {
-    fp = (GetSystemTimeAsFileTimePtr)GetProcAddress(
-        GetModuleHandleW(L"kernel32.dll"), "GetSystemTimePreciseAsFileTime");
-    if (fp == nullptr)
-      fp = GetSystemTimeAsFileTime;
-  }
-  GetSystemTimeAsFileTimePtr fp;
-};
-
-// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
-// attribute with a value that's reserved for the implementation (we're the implementation).
-#include "chrono_system_time_init.h"
-} // namespace
-
-#endif
-
-static system_clock::time_point __libcpp_system_clock_now() {
-  // FILETIME is in 100ns units
-  using filetime_duration =
-      _VSTD::chrono::duration<__int64,
-                              _VSTD::ratio_multiply<_VSTD::ratio<100, 1>,
-                                                    nanoseconds::period>>;
-
-  // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970.
-  static _LIBCPP_CONSTEXPR const seconds nt_to_unix_epoch{11644473600};
-
-  FILETIME ft;
-#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8 && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)) || \
-    (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
-  GetSystemTimePreciseAsFileTime(&ft);
-#elif !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-  GetSystemTimeAsFileTime(&ft);
-#else
-  GetSystemTimeAsFileTimeFunc.fp(&ft);
-#endif
-
-  filetime_duration d{(static_cast<__int64>(ft.dwHighDateTime) << 32) |
-                       static_cast<__int64>(ft.dwLowDateTime)};
-  return system_clock::time_point(duration_cast<system_clock::duration>(d - nt_to_unix_epoch));
-}
-
-#elif defined(CLOCK_REALTIME) && defined(_LIBCPP_USE_CLOCK_GETTIME)
-
-static system_clock::time_point __libcpp_system_clock_now() {
-  struct timespec tp;
-  if (0 != clock_gettime(CLOCK_REALTIME, &tp))
-    __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
-  return system_clock::time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000));
-}
-
-#else
-
-static system_clock::time_point __libcpp_system_clock_now() {
-    timeval tv;
-    gettimeofday(&tv, 0);
-    return system_clock::time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
-}
-
-#endif
-
-const bool system_clock::is_steady;
-
-system_clock::time_point
-system_clock::now() noexcept
-{
-    return __libcpp_system_clock_now();
-}
-
-time_t
-system_clock::to_time_t(const time_point& t) noexcept
-{
-    return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
-}
-
-system_clock::time_point
-system_clock::from_time_t(time_t t) noexcept
-{
-    return system_clock::time_point(seconds(t));
-}
-
-//
-// steady_clock
-//
-// Warning:  If this is not truly steady, then it is non-conforming.  It is
-//  better for it to not exist and have the rest of libc++ use system_clock
-//  instead.
-//
-
-#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
-
-#if defined(__APPLE__)
-
-// On Apple platforms, only CLOCK_UPTIME_RAW, CLOCK_MONOTONIC_RAW or
-// mach_absolute_time are able to time functions in the nanosecond range.
-// Furthermore, only CLOCK_MONOTONIC_RAW is truly monotonic, because it
-// also counts cycles when the system is asleep. Thus, it is the only
-// acceptable implementation of steady_clock.
-static steady_clock::time_point __libcpp_steady_clock_now() {
-    struct timespec tp;
-    if (0 != clock_gettime(CLOCK_MONOTONIC_RAW, &tp))
-        __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC_RAW) failed");
-    return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
-}
-
-#elif defined(_LIBCPP_WIN32API)
-
-// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx says:
-//    If the function fails, the return value is zero. <snip>
-//    On systems that run Windows XP or later, the function will always succeed
-//      and will thus never return zero.
-
-static LARGE_INTEGER
-__QueryPerformanceFrequency()
-{
-    LARGE_INTEGER val;
-    (void) QueryPerformanceFrequency(&val);
-    return val;
-}
-
-static steady_clock::time_point __libcpp_steady_clock_now() {
-  static const LARGE_INTEGER freq = __QueryPerformanceFrequency();
-
-  LARGE_INTEGER counter;
-  (void) QueryPerformanceCounter(&counter);
-  auto seconds = counter.QuadPart / freq.QuadPart;
-  auto fractions = counter.QuadPart % freq.QuadPart;
-  auto dur = seconds * nano::den + fractions * nano::den / freq.QuadPart;
-  return steady_clock::time_point(steady_clock::duration(dur));
-}
-
-#elif defined(__MVS__)
-
-static steady_clock::time_point __libcpp_steady_clock_now() {
-  struct timespec64 ts;
-  if (0 != gettimeofdayMonotonic(&ts))
-    __throw_system_error(errno, "failed to obtain time of day");
-
-  return steady_clock::time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
-}
-
-#  elif defined(__Fuchsia__)
-
-static steady_clock::time_point __libcpp_steady_clock_now() noexcept {
-  // Implicitly link against the vDSO system call ABI without
-  // requiring the final link to specify -lzircon explicitly when
-  // statically linking libc++.
-#    pragma comment(lib, "zircon")
-
-  return steady_clock::time_point(nanoseconds(_zx_clock_get_monotonic()));
-}
-
-#  elif defined(CLOCK_MONOTONIC)
-
-static steady_clock::time_point __libcpp_steady_clock_now() {
-    struct timespec tp;
-    if (0 != clock_gettime(CLOCK_MONOTONIC, &tp))
-        __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed");
-    return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
-}
-
-#  else
-#    error "Monotonic clock not implemented on this platform"
-#  endif
-
-const bool steady_clock::is_steady;
-
-steady_clock::time_point
-steady_clock::now() noexcept
-{
-    return __libcpp_steady_clock_now();
-}
-
-#endif // !_LIBCPP_HAS_NO_MONOTONIC_CLOCK
-
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/condition_variable.cpp b/third_party/libcxx/src/condition_variable.cpp
deleted file mode 100644
index 85f334e02..000000000
--- a/third_party/libcxx/src/condition_variable.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-
-#include <condition_variable>
-#include <thread>
-
-#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#  pragma comment(lib, "pthread")
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// ~condition_variable is defined elsewhere.
-
-void
-condition_variable::notify_one() noexcept
-{
-    __libcpp_condvar_signal(&__cv_);
-}
-
-void
-condition_variable::notify_all() noexcept
-{
-    __libcpp_condvar_broadcast(&__cv_);
-}
-
-void
-condition_variable::wait(unique_lock<mutex>& lk) noexcept
-{
-    if (!lk.owns_lock())
-        __throw_system_error(EPERM,
-                                  "condition_variable::wait: mutex not locked");
-    int ec = __libcpp_condvar_wait(&__cv_, lk.mutex()->native_handle());
-    if (ec)
-        __throw_system_error(ec, "condition_variable wait failed");
-}
-
-void
-condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
-     chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp) noexcept
-{
-    using namespace chrono;
-    if (!lk.owns_lock())
-        __throw_system_error(EPERM,
-                            "condition_variable::timed wait: mutex not locked");
-    nanoseconds d = tp.time_since_epoch();
-    if (d > nanoseconds(0x59682F000000E941))
-        d = nanoseconds(0x59682F000000E941);
-    __libcpp_timespec_t ts;
-    seconds s = duration_cast<seconds>(d);
-    typedef decltype(ts.tv_sec) ts_sec;
-    _LIBCPP_CONSTEXPR ts_sec ts_sec_max = numeric_limits<ts_sec>::max();
-    if (s.count() < ts_sec_max)
-    {
-        ts.tv_sec = static_cast<ts_sec>(s.count());
-        ts.tv_nsec = static_cast<decltype(ts.tv_nsec)>((d - s).count());
-    }
-    else
-    {
-        ts.tv_sec = ts_sec_max;
-        ts.tv_nsec = giga::num - 1;
-    }
-    int ec = __libcpp_condvar_timedwait(&__cv_, lk.mutex()->native_handle(), &ts);
-    if (ec != 0 && ec != ETIMEDOUT)
-        __throw_system_error(ec, "condition_variable timed_wait failed");
-}
-
-void
-notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk)
-{
-    auto& tl_ptr = __thread_local_data();
-    // If this thread was not created using std::thread then it will not have
-    // previously allocated.
-    if (tl_ptr.get() == nullptr) {
-        tl_ptr.set_pointer(new __thread_struct);
-    }
-    __thread_local_data()->notify_all_at_thread_exit(&cond, lk.release());
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-#endif // !_LIBCPP_HAS_NO_THREADS
diff --git a/third_party/libcxx/src/condition_variable_destructor.cpp b/third_party/libcxx/src/condition_variable_destructor.cpp
deleted file mode 100644
index c217a0939..000000000
--- a/third_party/libcxx/src/condition_variable_destructor.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// Define ~condition_variable.
-//
-// On some platforms ~condition_variable has been made trivial and the
-// definition is only provided for ABI compatibility.
-
-#include <__config>
-#include <__threading_support>
-
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-# if _LIBCPP_ABI_VERSION == 1 || !defined(_LIBCPP_HAS_TRIVIAL_CONDVAR_DESTRUCTION)
-#   define NEEDS_CONDVAR_DESTRUCTOR
-# endif
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#ifdef NEEDS_CONDVAR_DESTRUCTOR
-
-class _LIBCPP_TYPE_VIS condition_variable
-{
-    __libcpp_condvar_t __cv_ = _LIBCPP_CONDVAR_INITIALIZER;
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr condition_variable() noexcept = default;
-
-    ~condition_variable();
-
-    condition_variable(const condition_variable&) = delete;
-    condition_variable& operator=(const condition_variable&)  = delete;
-};
-
-condition_variable::~condition_variable()
-{
-    __libcpp_condvar_destroy(&__cv_);
-}
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/debug.cpp b/third_party/libcxx/src/debug.cpp
deleted file mode 100644
index 8f1d328f0..000000000
--- a/third_party/libcxx/src/debug.cpp
+++ /dev/null
@@ -1,559 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__assert>
-#include <__config>
-#include <__debug>
-#include <__hash_table>
-#include <algorithm>
-#include <cstdio>
-#include <functional>
-#include <string>
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-#  include <mutex>
-#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#    pragma comment(lib, "pthread")
-#  endif
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-_LIBCPP_FUNC_VIS
-__libcpp_db*
-__get_db()
-{
-    static _LIBCPP_NO_DESTROY __libcpp_db db;
-    return &db;
-}
-
-_LIBCPP_FUNC_VIS
-const __libcpp_db*
-__get_const_db()
-{
-    return __get_db();
-}
-
-namespace
-{
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-typedef mutex mutex_type;
-typedef lock_guard<mutex_type> WLock;
-typedef lock_guard<mutex_type> RLock;
-
-mutex_type&
-mut()
-{
-    static _LIBCPP_NO_DESTROY mutex_type m;
-    return m;
-}
-#endif // !_LIBCPP_HAS_NO_THREADS
-
-}  // unnamed namespace
-
-__i_node::~__i_node()
-{
-    if (__next_)
-    {
-        __next_->~__i_node();
-        free(__next_);
-    }
-}
-
-__c_node::~__c_node()
-{
-    free(beg_);
-    if (__next_)
-    {
-        __next_->~__c_node();
-        free(__next_);
-    }
-}
-
-__libcpp_db::__libcpp_db()
-    : __cbeg_(nullptr),
-      __cend_(nullptr),
-      __csz_(0),
-      __ibeg_(nullptr),
-      __iend_(nullptr),
-      __isz_(0)
-{
-}
-
-__libcpp_db::~__libcpp_db()
-{
-    if (__cbeg_)
-    {
-        for (__c_node** p = __cbeg_; p != __cend_; ++p)
-        {
-            if (*p != nullptr)
-            {
-                (*p)->~__c_node();
-                free(*p);
-            }
-        }
-        free(__cbeg_);
-    }
-    if (__ibeg_)
-    {
-        for (__i_node** p = __ibeg_; p != __iend_; ++p)
-        {
-            if (*p != nullptr)
-            {
-                (*p)->~__i_node();
-                free(*p);
-            }
-        }
-        free(__ibeg_);
-    }
-}
-
-void*
-__libcpp_db::__find_c_from_i(void* __i) const
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    RLock _(mut());
-#endif
-    __i_node* i = __find_iterator(__i);
-    _LIBCPP_ASSERT(i != nullptr, "iterator not found in debug database.");
-    return i->__c_ != nullptr ? i->__c_->__c_ : nullptr;
-}
-
-void
-__libcpp_db::__insert_ic(void* __i, const void* __c)
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    WLock _(mut());
-#endif
-    if (__cbeg_ == __cend_)
-        return;
-    size_t hc = hash<const void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
-    __c_node* c = __cbeg_[hc];
-    if (c == nullptr)
-        return;
-    while (c->__c_ != __c)
-    {
-        c = c->__next_;
-        if (c == nullptr)
-            return;
-    }
-    __i_node* i = __insert_iterator(__i);
-    c->__add(i);
-    i->__c_ = c;
-}
-
-void
-__libcpp_db::__insert_c(void* __c, __libcpp_db::_InsertConstruct *__fn)
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    WLock _(mut());
-#endif
-    if (__csz_ + 1 > static_cast<size_t>(__cend_ - __cbeg_))
-    {
-        size_t nc = __next_prime(2*static_cast<size_t>(__cend_ - __cbeg_) + 1);
-        __c_node** cbeg = static_cast<__c_node**>(calloc(nc, sizeof(__c_node*)));
-        if (cbeg == nullptr)
-            __throw_bad_alloc();
-
-        for (__c_node** p = __cbeg_; p != __cend_; ++p)
-        {
-            __c_node* q = *p;
-            while (q != nullptr)
-            {
-                size_t h = hash<void*>()(q->__c_) % nc;
-                __c_node* r = q->__next_;
-                q->__next_ = cbeg[h];
-                cbeg[h] = q;
-                q = r;
-            }
-        }
-        free(__cbeg_);
-        __cbeg_ = cbeg;
-        __cend_ = __cbeg_ + nc;
-    }
-    size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
-    __c_node* p = __cbeg_[hc];
-    void *buf = malloc(sizeof(__c_node));
-    if (buf == nullptr)
-      __throw_bad_alloc();
-    __cbeg_[hc] = __fn(buf, __c, p);
-
-    ++__csz_;
-}
-
-void
-__libcpp_db::__erase_i(void* __i)
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    WLock _(mut());
-#endif
-    if (__ibeg_ != __iend_)
-    {
-        size_t hi = hash<void*>()(__i) % static_cast<size_t>(__iend_ - __ibeg_);
-        __i_node* p = __ibeg_[hi];
-        if (p != nullptr)
-        {
-            __i_node* q = nullptr;
-            while (p->__i_ != __i)
-            {
-                q = p;
-                p = p->__next_;
-                if (p == nullptr)
-                    return;
-            }
-            if (q == nullptr)
-                __ibeg_[hi] = p->__next_;
-            else
-                q->__next_ = p->__next_;
-            __c_node* c = p->__c_;
-            --__isz_;
-            if (c != nullptr)
-                c->__remove(p);
-            free(p);
-        }
-    }
-}
-
-void
-__libcpp_db::__invalidate_all(void* __c)
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    WLock _(mut());
-#endif
-    if (__cend_ != __cbeg_)
-    {
-        size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
-        __c_node* p = __cbeg_[hc];
-        if (p == nullptr)
-            return;
-        while (p->__c_ != __c)
-        {
-            p = p->__next_;
-            if (p == nullptr)
-                return;
-        }
-        while (p->end_ != p->beg_)
-        {
-            --p->end_;
-            (*p->end_)->__c_ = nullptr;
-        }
-    }
-}
-
-__c_node*
-__libcpp_db::__find_c_and_lock(void* __c) const
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    mut().lock();
-#endif
-    if (__cend_ == __cbeg_)
-    {
-#ifndef _LIBCPP_HAS_NO_THREADS
-        mut().unlock();
-#endif
-        return nullptr;
-    }
-    size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
-    __c_node* p = __cbeg_[hc];
-    if (p == nullptr)
-    {
-#ifndef _LIBCPP_HAS_NO_THREADS
-        mut().unlock();
-#endif
-        return nullptr;
-    }
-    while (p->__c_ != __c)
-    {
-        p = p->__next_;
-        if (p == nullptr)
-        {
-#ifndef _LIBCPP_HAS_NO_THREADS
-            mut().unlock();
-#endif
-            return nullptr;
-        }
-    }
-    return p;
-}
-
-__c_node*
-__libcpp_db::__find_c(void* __c) const
-{
-    size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
-    __c_node* p = __cbeg_[hc];
-    _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c A");
-    while (p->__c_ != __c)
-    {
-        p = p->__next_;
-        _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c B");
-    }
-    return p;
-}
-
-void
-__libcpp_db::unlock() const
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    mut().unlock();
-#endif
-}
-
-void
-__libcpp_db::__erase_c(void* __c)
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    WLock _(mut());
-#endif
-    if (__cend_ != __cbeg_)
-    {
-        size_t hc = hash<void*>()(__c) % static_cast<size_t>(__cend_ - __cbeg_);
-        __c_node* p = __cbeg_[hc];
-        if (p == nullptr)
-            return;
-        __c_node* q = nullptr;
-        _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c A");
-        while (p->__c_ != __c)
-        {
-            q = p;
-            p = p->__next_;
-            if (p == nullptr)
-                return;
-            _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c B");
-        }
-        if (q == nullptr)
-            __cbeg_[hc] = p->__next_;
-        else
-            q->__next_ = p->__next_;
-        while (p->end_ != p->beg_)
-        {
-            --p->end_;
-            (*p->end_)->__c_ = nullptr;
-        }
-        free(p->beg_);
-        free(p);
-        --__csz_;
-    }
-}
-
-void
-__libcpp_db::__iterator_copy(void* __i, const void* __i0)
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    WLock _(mut());
-#endif
-    __i_node* i = __find_iterator(__i);
-    __i_node* i0 = __find_iterator(__i0);
-    __c_node* c0 = i0 != nullptr ? i0->__c_ : nullptr;
-    if (i == nullptr && i0 != nullptr)
-        i = __insert_iterator(__i);
-    __c_node* c = i != nullptr ? i->__c_ : nullptr;
-    if (c != c0)
-    {
-        if (c != nullptr)
-            c->__remove(i);
-        if (i != nullptr)
-        {
-            i->__c_ = nullptr;
-            if (c0 != nullptr)
-            {
-                i->__c_ = c0;
-                i->__c_->__add(i);
-            }
-        }
-    }
-}
-
-bool
-__libcpp_db::__dereferenceable(const void* __i) const
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    RLock _(mut());
-#endif
-    __i_node* i = __find_iterator(__i);
-    return i != nullptr && i->__c_ != nullptr && i->__c_->__dereferenceable(__i);
-}
-
-bool
-__libcpp_db::__decrementable(const void* __i) const
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    RLock _(mut());
-#endif
-    __i_node* i = __find_iterator(__i);
-    return i != nullptr && i->__c_ != nullptr && i->__c_->__decrementable(__i);
-}
-
-bool
-__libcpp_db::__addable(const void* __i, ptrdiff_t __n) const
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    RLock _(mut());
-#endif
-    __i_node* i = __find_iterator(__i);
-    return i != nullptr && i->__c_ != nullptr && i->__c_->__addable(__i, __n);
-}
-
-bool
-__libcpp_db::__subscriptable(const void* __i, ptrdiff_t __n) const
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    RLock _(mut());
-#endif
-    __i_node* i = __find_iterator(__i);
-    return i != nullptr && i->__c_ != nullptr && i->__c_->__subscriptable(__i, __n);
-}
-
-bool
-__libcpp_db::__less_than_comparable(const void* __i, const void* __j) const
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    RLock _(mut());
-#endif
-    __i_node* i = __find_iterator(__i);
-    __i_node* j = __find_iterator(__j);
-    __c_node* ci = i != nullptr ? i->__c_ : nullptr;
-    __c_node* cj = j != nullptr ? j->__c_ : nullptr;
-    return ci == cj;
-}
-
-void
-__libcpp_db::swap(void* c1, void* c2)
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    WLock _(mut());
-#endif
-    size_t hc = hash<void*>()(c1) % static_cast<size_t>(__cend_ - __cbeg_);
-    __c_node* p1 = __cbeg_[hc];
-    _LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap A");
-    while (p1->__c_ != c1)
-    {
-        p1 = p1->__next_;
-        _LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap B");
-    }
-    hc = hash<void*>()(c2) % static_cast<size_t>(__cend_ - __cbeg_);
-    __c_node* p2 = __cbeg_[hc];
-    _LIBCPP_ASSERT(p2 != nullptr, "debug mode internal logic error swap C");
-    while (p2->__c_ != c2)
-    {
-        p2 = p2->__next_;
-        _LIBCPP_ASSERT(p2 != nullptr, "debug mode internal logic error swap D");
-    }
-    std::swap(p1->beg_, p2->beg_);
-    std::swap(p1->end_, p2->end_);
-    std::swap(p1->cap_, p2->cap_);
-    for (__i_node** p = p1->beg_; p != p1->end_; ++p)
-        (*p)->__c_ = p1;
-    for (__i_node** p = p2->beg_; p != p2->end_; ++p)
-        (*p)->__c_ = p2;
-}
-
-void
-__libcpp_db::__insert_i(void* __i)
-{
-#ifndef _LIBCPP_HAS_NO_THREADS
-    WLock _(mut());
-#endif
-    __insert_iterator(__i);
-}
-
-void
-__c_node::__add(__i_node* i)
-{
-    if (end_ == cap_)
-    {
-        size_t nc = 2*static_cast<size_t>(cap_ - beg_);
-        if (nc == 0)
-            nc = 1;
-        __i_node** beg =
-           static_cast<__i_node**>(malloc(nc * sizeof(__i_node*)));
-        if (beg == nullptr)
-            __throw_bad_alloc();
-
-        if (nc > 1)
-            memcpy(beg, beg_, nc/2*sizeof(__i_node*));
-        free(beg_);
-        beg_ = beg;
-        end_ = beg_ + nc/2;
-        cap_ = beg_ + nc;
-    }
-    *end_++ = i;
-}
-
-// private api
-
-_LIBCPP_HIDDEN
-__i_node*
-__libcpp_db::__insert_iterator(void* __i)
-{
-    if (__isz_ + 1 > static_cast<size_t>(__iend_ - __ibeg_))
-    {
-        size_t nc = __next_prime(2*static_cast<size_t>(__iend_ - __ibeg_) + 1);
-        __i_node** ibeg = static_cast<__i_node**>(calloc(nc, sizeof(__i_node*)));
-        if (ibeg == nullptr)
-            __throw_bad_alloc();
-
-        for (__i_node** p = __ibeg_; p != __iend_; ++p)
-        {
-            __i_node* q = *p;
-            while (q != nullptr)
-            {
-                size_t h = hash<void*>()(q->__i_) % nc;
-                __i_node* r = q->__next_;
-                q->__next_ = ibeg[h];
-                ibeg[h] = q;
-                q = r;
-            }
-        }
-        free(__ibeg_);
-        __ibeg_ = ibeg;
-        __iend_ = __ibeg_ + nc;
-    }
-    size_t hi = hash<void*>()(__i) % static_cast<size_t>(__iend_ - __ibeg_);
-    __i_node* p = __ibeg_[hi];
-    __i_node* r = __ibeg_[hi] =
-      static_cast<__i_node*>(malloc(sizeof(__i_node)));
-    if (r == nullptr)
-        __throw_bad_alloc();
-
-    ::new(r) __i_node(__i, p, nullptr);
-    ++__isz_;
-    return r;
-}
-
-_LIBCPP_HIDDEN
-__i_node*
-__libcpp_db::__find_iterator(const void* __i) const
-{
-    __i_node* r = nullptr;
-    if (__ibeg_ != __iend_)
-    {
-        size_t h = hash<const void*>()(__i) % static_cast<size_t>(__iend_ - __ibeg_);
-        for (__i_node* nd = __ibeg_[h]; nd != nullptr; nd = nd->__next_)
-        {
-            if (nd->__i_ == __i)
-            {
-                r = nd;
-                break;
-            }
-        }
-    }
-    return r;
-}
-
-_LIBCPP_HIDDEN
-void
-__c_node::__remove(__i_node* p)
-{
-    __i_node** r = find(beg_, end_, p);
-    _LIBCPP_ASSERT(r != end_, "debug mode internal logic error __c_node::__remove");
-    if (--end_ != r)
-        memmove(r, r+1, static_cast<size_t>(end_ - r)*sizeof(__i_node*));
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/exception.cpp b/third_party/libcxx/src/exception.cpp
deleted file mode 100644
index 6c307fcbb..000000000
--- a/third_party/libcxx/src/exception.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <exception>
-#include <new>
-#include <typeinfo>
-
-#if defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI)
-  #include <cxxabi.h>
-  using namespace __cxxabiv1;
-  #define HAVE_DEPENDENT_EH_ABI 1
-#endif
-
-#if defined(_LIBCPP_ABI_MICROSOFT)
-#include "third_party/libcxx/src/support/runtime/exception_msvc.ipp"
-#include "third_party/libcxx/src/support/runtime/exception_pointer_msvc.ipp"
-#elif defined(_LIBCPPABI_VERSION)
-#include "third_party/libcxx/src/support/runtime/exception_libcxxabi.ipp"
-#include "third_party/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp"
-#elif defined(LIBCXXRT)
-#include "third_party/libcxx/src/support/runtime/exception_libcxxrt.ipp"
-#include "third_party/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp"
-#elif defined(__GLIBCXX__)
-#include "third_party/libcxx/src/support/runtime/exception_glibcxx.ipp"
-#include "third_party/libcxx/src/support/runtime/exception_pointer_glibcxx.ipp"
-#else
-#include "third_party/libcxx/src/include/atomic_support.h"
-#include "third_party/libcxx/src/support/runtime/exception_fallback.ipp"
-#include "third_party/libcxx/src/support/runtime/exception_pointer_unimplemented.ipp"
-#endif
diff --git a/third_party/libcxx/src/experimental/memory_resource.cpp b/third_party/libcxx/src/experimental/memory_resource.cpp
deleted file mode 100644
index d6bb52ec1..000000000
--- a/third_party/libcxx/src/experimental/memory_resource.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <experimental/memory_resource>
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-
-#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
-#  include <atomic>
-#elif !defined(_LIBCPP_HAS_NO_THREADS)
-#  include <mutex>
-#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#    pragma comment(lib, "pthread")
-#  endif
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-// memory_resource
-
-//memory_resource::~memory_resource() {}
-
-// new_delete_resource()
-
-class _LIBCPP_TYPE_VIS __new_delete_memory_resource_imp
-    : public memory_resource
-{
-    void *do_allocate(size_t size, size_t align) override {
-#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-        if (__is_overaligned_for_new(align))
-            __throw_bad_alloc();
-#endif
-        return _VSTD::__libcpp_allocate(size, align);
-    }
-
-    void do_deallocate(void *p, size_t n, size_t align) override {
-      _VSTD::__libcpp_deallocate(p, n, align);
-    }
-
-    bool do_is_equal(memory_resource const & other) const noexcept override
-        { return &other == this; }
-
-public:
-    ~__new_delete_memory_resource_imp() override = default;
-};
-
-// null_memory_resource()
-
-class _LIBCPP_TYPE_VIS __null_memory_resource_imp
-    : public memory_resource
-{
-public:
-    ~__null_memory_resource_imp() = default;
-
-protected:
-    virtual void* do_allocate(size_t, size_t) {
-        __throw_bad_alloc();
-    }
-    virtual void do_deallocate(void *, size_t, size_t) {}
-    virtual bool do_is_equal(memory_resource const & __other) const noexcept
-    { return &__other == this; }
-};
-
-namespace {
-
-union ResourceInitHelper {
-  struct {
-    __new_delete_memory_resource_imp new_delete_res;
-    __null_memory_resource_imp       null_res;
-  } resources;
-  char dummy;
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 ResourceInitHelper() : resources() {}
-  ~ResourceInitHelper() {}
-};
-
-// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
-// attribute with a value that's reserved for the implementation (we're the implementation).
-#include "memory_resource_init_helper.h"
-
-} // end namespace
-
-
-memory_resource * new_delete_resource() noexcept {
-    return &res_init.resources.new_delete_res;
-}
-
-memory_resource * null_memory_resource() noexcept {
-    return &res_init.resources.null_res;
-}
-
-// default_memory_resource()
-
-static memory_resource *
-__default_memory_resource(bool set = false, memory_resource * new_res = nullptr) noexcept
-{
-#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
-    static constinit atomic<memory_resource*> __res{&res_init.resources.new_delete_res};
-    if (set) {
-        new_res = new_res ? new_res : new_delete_resource();
-        // TODO: Can a weaker ordering be used?
-        return _VSTD::atomic_exchange_explicit(
-            &__res, new_res, memory_order_acq_rel);
-    }
-    else {
-        return _VSTD::atomic_load_explicit(
-            &__res, memory_order_acquire);
-    }
-#elif !defined(_LIBCPP_HAS_NO_THREADS)
-    static constinit memory_resource *res = &res_init.resources.new_delete_res;
-    static mutex res_lock;
-    if (set) {
-        new_res = new_res ? new_res : new_delete_resource();
-        lock_guard<mutex> guard(res_lock);
-        memory_resource * old_res = res;
-        res = new_res;
-        return old_res;
-    } else {
-        lock_guard<mutex> guard(res_lock);
-        return res;
-    }
-#else
-    static constinit memory_resource *res = &res_init.resources.new_delete_res;
-    if (set) {
-        new_res = new_res ? new_res : new_delete_resource();
-        memory_resource * old_res = res;
-        res = new_res;
-        return old_res;
-    } else {
-        return res;
-    }
-#endif
-}
-
-memory_resource * get_default_resource() noexcept
-{
-    return __default_memory_resource();
-}
-
-memory_resource * set_default_resource(memory_resource * __new_res) noexcept
-{
-    return __default_memory_resource(true, __new_res);
-}
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
diff --git a/third_party/libcxx/src/filesystem/directory_iterator.cpp b/third_party/libcxx/src/filesystem/directory_iterator.cpp
deleted file mode 100644
index 8d069cc08..000000000
--- a/third_party/libcxx/src/filesystem/directory_iterator.cpp
+++ /dev/null
@@ -1,332 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__assert>
-#include <__config>
-#include <errno.h>
-#include <filesystem>
-#include <stack>
-
-#include "filesystem_common.h"
-
-_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
-
-using detail::ErrorHandler;
-
-#if defined(_LIBCPP_WIN32API)
-class __dir_stream {
-public:
-  __dir_stream() = delete;
-  __dir_stream& operator=(const __dir_stream&) = delete;
-
-  __dir_stream(__dir_stream&& __ds) noexcept : __stream_(__ds.__stream_),
-                                               __root_(std::move(__ds.__root_)),
-                                               __entry_(std::move(__ds.__entry_)) {
-    __ds.__stream_ = INVALID_HANDLE_VALUE;
-  }
-
-  __dir_stream(const path& root, directory_options opts, error_code& ec)
-      : __stream_(INVALID_HANDLE_VALUE), __root_(root) {
-    if (root.native().empty()) {
-      ec = make_error_code(errc::no_such_file_or_directory);
-      return;
-    }
-    __stream_ = ::FindFirstFileW((root / "*").c_str(), &__data_);
-    if (__stream_ == INVALID_HANDLE_VALUE) {
-      ec = detail::make_windows_error(GetLastError());
-      const bool ignore_permission_denied =
-          bool(opts & directory_options::skip_permission_denied);
-      if (ignore_permission_denied &&
-          ec.value() == static_cast<int>(errc::permission_denied))
-        ec.clear();
-      return;
-    }
-    if (!assign())
-      advance(ec);
-  }
-
-  ~__dir_stream() noexcept {
-    if (__stream_ == INVALID_HANDLE_VALUE)
-      return;
-    close();
-  }
-
-  bool good() const noexcept { return __stream_ != INVALID_HANDLE_VALUE; }
-
-  bool advance(error_code& ec) {
-    while (::FindNextFileW(__stream_, &__data_)) {
-      if (assign())
-        return true;
-    }
-    close();
-    return false;
-  }
-
-  bool assign() {
-    if (!wcscmp(__data_.cFileName, L".") || !wcscmp(__data_.cFileName, L".."))
-      return false;
-    // FIXME: Cache more of this
-    //directory_entry::__cached_data cdata;
-    //cdata.__type_ = get_file_type(__data_);
-    //cdata.__size_ = get_file_size(__data_);
-    //cdata.__write_time_ = get_write_time(__data_);
-    __entry_.__assign_iter_entry(
-        __root_ / __data_.cFileName,
-        directory_entry::__create_iter_result(detail::get_file_type(__data_)));
-    return true;
-  }
-
-private:
-  error_code close() noexcept {
-    error_code ec;
-    if (!::FindClose(__stream_))
-      ec = detail::make_windows_error(GetLastError());
-    __stream_ = INVALID_HANDLE_VALUE;
-    return ec;
-  }
-
-  HANDLE __stream_{INVALID_HANDLE_VALUE};
-  WIN32_FIND_DATAW __data_;
-
-public:
-  path __root_;
-  directory_entry __entry_;
-};
-#else
-class __dir_stream {
-public:
-  __dir_stream() = delete;
-  __dir_stream& operator=(const __dir_stream&) = delete;
-
-  __dir_stream(__dir_stream&& other) noexcept : __stream_(other.__stream_),
-                                                __root_(std::move(other.__root_)),
-                                                __entry_(std::move(other.__entry_)) {
-    other.__stream_ = nullptr;
-  }
-
-  __dir_stream(const path& root, directory_options opts, error_code& ec)
-      : __stream_(nullptr), __root_(root) {
-    if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
-      ec = detail::capture_errno();
-      const bool allow_eacces =
-          bool(opts & directory_options::skip_permission_denied);
-      if (allow_eacces && ec.value() == EACCES)
-        ec.clear();
-      return;
-    }
-    advance(ec);
-  }
-
-  ~__dir_stream() noexcept {
-    if (__stream_)
-      close();
-  }
-
-  bool good() const noexcept { return __stream_ != nullptr; }
-
-  bool advance(error_code& ec) {
-    while (true) {
-      auto str_type_pair = detail::posix_readdir(__stream_, ec);
-      auto& str = str_type_pair.first;
-      if (str == "." || str == "..") {
-        continue;
-      } else if (ec || str.empty()) {
-        close();
-        return false;
-      } else {
-        __entry_.__assign_iter_entry(
-            __root_ / str,
-            directory_entry::__create_iter_result(str_type_pair.second));
-        return true;
-      }
-    }
-  }
-
-private:
-  error_code close() noexcept {
-    error_code m_ec;
-    if (::closedir(__stream_) == -1)
-      m_ec = detail::capture_errno();
-    __stream_ = nullptr;
-    return m_ec;
-  }
-
-  DIR* __stream_{nullptr};
-
-public:
-  path __root_;
-  directory_entry __entry_;
-};
-#endif
-
-// directory_iterator
-
-directory_iterator::directory_iterator(const path& p, error_code* ec,
-                                       directory_options opts) {
-  ErrorHandler<void> err("directory_iterator::directory_iterator(...)", ec, &p);
-
-  error_code m_ec;
-  __imp_ = make_shared<__dir_stream>(p, opts, m_ec);
-  if (ec)
-    *ec = m_ec;
-  if (!__imp_->good()) {
-    __imp_.reset();
-    if (m_ec)
-      err.report(m_ec);
-  }
-}
-
-directory_iterator& directory_iterator::__increment(error_code* ec) {
-  _LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator");
-  ErrorHandler<void> err("directory_iterator::operator++()", ec);
-
-  error_code m_ec;
-  if (!__imp_->advance(m_ec)) {
-    path root = std::move(__imp_->__root_);
-    __imp_.reset();
-    if (m_ec)
-      err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str());
-  }
-  return *this;
-}
-
-directory_entry const& directory_iterator::__dereference() const {
-  _LIBCPP_ASSERT(__imp_, "Attempting to dereference an invalid iterator");
-  return __imp_->__entry_;
-}
-
-// recursive_directory_iterator
-
-struct recursive_directory_iterator::__shared_imp {
-  stack<__dir_stream> __stack_;
-  directory_options __options_;
-};
-
-recursive_directory_iterator::recursive_directory_iterator(
-    const path& p, directory_options opt, error_code* ec)
-    : __imp_(nullptr), __rec_(true) {
-  ErrorHandler<void> err("recursive_directory_iterator", ec, &p);
-
-  error_code m_ec;
-  __dir_stream new_s(p, opt, m_ec);
-  if (m_ec)
-    err.report(m_ec);
-  if (m_ec || !new_s.good())
-    return;
-
-  __imp_ = make_shared<__shared_imp>();
-  __imp_->__options_ = opt;
-  __imp_->__stack_.push(std::move(new_s));
-}
-
-void recursive_directory_iterator::__pop(error_code* ec) {
-  _LIBCPP_ASSERT(__imp_, "Popping the end iterator");
-  if (ec)
-    ec->clear();
-  __imp_->__stack_.pop();
-  if (__imp_->__stack_.size() == 0)
-    __imp_.reset();
-  else
-    __advance(ec);
-}
-
-directory_options recursive_directory_iterator::options() const {
-  return __imp_->__options_;
-}
-
-int recursive_directory_iterator::depth() const {
-  return __imp_->__stack_.size() - 1;
-}
-
-const directory_entry& recursive_directory_iterator::__dereference() const {
-  return __imp_->__stack_.top().__entry_;
-}
-
-recursive_directory_iterator&
-recursive_directory_iterator::__increment(error_code* ec) {
-  if (ec)
-    ec->clear();
-  if (recursion_pending()) {
-    if (__try_recursion(ec) || (ec && *ec))
-      return *this;
-  }
-  __rec_ = true;
-  __advance(ec);
-  return *this;
-}
-
-void recursive_directory_iterator::__advance(error_code* ec) {
-  ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec);
-
-  const directory_iterator end_it;
-  auto& stack = __imp_->__stack_;
-  error_code m_ec;
-  while (stack.size() > 0) {
-    if (stack.top().advance(m_ec))
-      return;
-    if (m_ec)
-      break;
-    stack.pop();
-  }
-
-  if (m_ec) {
-    path root = std::move(stack.top().__root_);
-    __imp_.reset();
-    err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str());
-  } else {
-    __imp_.reset();
-  }
-}
-
-bool recursive_directory_iterator::__try_recursion(error_code* ec) {
-  ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec);
-
-  bool rec_sym = bool(options() & directory_options::follow_directory_symlink);
-
-  auto& curr_it = __imp_->__stack_.top();
-
-  bool skip_rec = false;
-  error_code m_ec;
-  if (!rec_sym) {
-    file_status st(curr_it.__entry_.__get_sym_ft(&m_ec));
-    if (m_ec && status_known(st))
-      m_ec.clear();
-    if (m_ec || is_symlink(st) || !is_directory(st))
-      skip_rec = true;
-  } else {
-    file_status st(curr_it.__entry_.__get_ft(&m_ec));
-    if (m_ec && status_known(st))
-      m_ec.clear();
-    if (m_ec || !is_directory(st))
-      skip_rec = true;
-  }
-
-  if (!skip_rec) {
-    __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
-    if (new_it.good()) {
-      __imp_->__stack_.push(std::move(new_it));
-      return true;
-    }
-  }
-  if (m_ec) {
-    const bool allow_eacess =
-        bool(__imp_->__options_ & directory_options::skip_permission_denied);
-    if (m_ec.value() == EACCES && allow_eacess) {
-      if (ec)
-        ec->clear();
-    } else {
-      path at_ent = std::move(curr_it.__entry_.__p_);
-      __imp_.reset();
-      err.report(m_ec, "attempting recursion into " PATH_CSTR_FMT,
-                 at_ent.c_str());
-    }
-  }
-  return false;
-}
-
-_LIBCPP_END_NAMESPACE_FILESYSTEM
diff --git a/third_party/libcxx/src/filesystem/filesystem_common.h b/third_party/libcxx/src/filesystem/filesystem_common.h
deleted file mode 100644
index a1756cf5e..000000000
--- a/third_party/libcxx/src/filesystem/filesystem_common.h
+++ /dev/null
@@ -1,611 +0,0 @@
-//===----------------------------------------------------------------------===////
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===////
-
-#ifndef FILESYSTEM_COMMON_H
-#define FILESYSTEM_COMMON_H
-
-#include <__assert>
-#include <__config>
-#include <array>
-#include <cerrno>
-#include <chrono>
-#include <climits>
-#include <cstdarg>
-#include <ctime>
-#include <filesystem>
-#include <ratio>
-#include <utility>
-#include <system_error>
-
-#if defined(_LIBCPP_WIN32API)
-# define WIN32_LEAN_AND_MEAN
-# define NOMINMAX
-# include <windows.h>
-#else
-# include <dirent.h>   // for DIR & friends
-# include <fcntl.h>    /* values for fchmodat */
-# include <sys/stat.h>
-# include <sys/statvfs.h>
-# include <sys/time.h> // for ::utimes as used in __last_write_time
-# include <unistd.h>
-#endif // defined(_LIBCPP_WIN32API)
-
-// We can use the presence of UTIME_OMIT to detect platforms that provide utimensat.
-#if defined(UTIME_OMIT)
-# define _LIBCPP_USE_UTIMENSAT
-#endif
-
-// TODO: Check whether these functions actually need internal linkage, or if they can be made normal header functions
-_LIBCPP_DIAGNOSTIC_PUSH
-_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wunused-function")
-_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wunused-function")
-_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wunused-template")
-
-#if defined(_LIBCPP_WIN32API)
-#  define PATHSTR(x) (L##x)
-#  define PATH_CSTR_FMT "\"%ls\""
-#else
-#  define PATHSTR(x) (x)
-#  define PATH_CSTR_FMT "\"%s\""
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
-
-namespace detail {
-
-#if defined(_LIBCPP_WIN32API)
-// Non anonymous, to allow access from two translation units.
-errc __win_err_to_errc(int err);
-#endif
-
-namespace {
-
-static _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 0) string
-format_string_impl(const char* msg, va_list ap) {
-  array<char, 256> buf;
-
-  va_list apcopy;
-  va_copy(apcopy, ap);
-  int ret = ::vsnprintf(buf.data(), buf.size(), msg, apcopy);
-  va_end(apcopy);
-
-  string result;
-  if (static_cast<size_t>(ret) < buf.size()) {
-    result.assign(buf.data(), static_cast<size_t>(ret));
-  } else {
-    // we did not provide a long enough buffer on our first attempt. The
-    // return value is the number of bytes (excluding the null byte) that are
-    // needed for formatting.
-    size_t size_with_null = static_cast<size_t>(ret) + 1;
-    result.__resize_default_init(size_with_null - 1);
-    ret = ::vsnprintf(&result[0], size_with_null, msg, ap);
-    _LIBCPP_ASSERT(static_cast<size_t>(ret) == (size_with_null - 1), "TODO");
-  }
-  return result;
-}
-
-static _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 2) string
-format_string(const char* msg, ...) {
-  string ret;
-  va_list ap;
-  va_start(ap, msg);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-  try {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    ret = format_string_impl(msg, ap);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-  } catch (...) {
-    va_end(ap);
-    throw;
-  }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-  va_end(ap);
-  return ret;
-}
-
-error_code capture_errno() {
-  _LIBCPP_ASSERT(errno != 0, "Expected errno to be non-zero");
-  return error_code(errno, generic_category());
-}
-
-#if defined(_LIBCPP_WIN32API)
-error_code make_windows_error(int err) {
-  return make_error_code(__win_err_to_errc(err));
-}
-#endif
-
-template <class T>
-T error_value();
-template <>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 void error_value<void>() {}
-template <>
-bool error_value<bool>() {
-  return false;
-}
-#if __SIZEOF_SIZE_T__ != __SIZEOF_LONG_LONG__
-template <>
-size_t error_value<size_t>() {
-  return size_t(-1);
-}
-#endif
-template <>
-uintmax_t error_value<uintmax_t>() {
-  return uintmax_t(-1);
-}
-template <>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 file_time_type error_value<file_time_type>() {
-  return file_time_type::min();
-}
-template <>
-path error_value<path>() {
-  return {};
-}
-
-template <class T>
-struct ErrorHandler {
-  const char* func_name_;
-  error_code* ec_ = nullptr;
-  const path* p1_ = nullptr;
-  const path* p2_ = nullptr;
-
-  ErrorHandler(const char* fname, error_code* ec, const path* p1 = nullptr,
-               const path* p2 = nullptr)
-      : func_name_(fname), ec_(ec), p1_(p1), p2_(p2) {
-    if (ec_)
-      ec_->clear();
-  }
-
-  T report(const error_code& ec) const {
-    if (ec_) {
-      *ec_ = ec;
-      return error_value<T>();
-    }
-    string what = string("in ") + func_name_;
-    switch (bool(p1_) + bool(p2_)) {
-    case 0:
-      __throw_filesystem_error(what, ec);
-    case 1:
-      __throw_filesystem_error(what, *p1_, ec);
-    case 2:
-      __throw_filesystem_error(what, *p1_, *p2_, ec);
-    }
-    __libcpp_unreachable();
-  }
-
-  _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 0)
-  void report_impl(const error_code& ec, const char* msg, va_list ap) const {
-    if (ec_) {
-      *ec_ = ec;
-      return;
-    }
-    string what =
-        string("in ") + func_name_ + ": " + format_string_impl(msg, ap);
-    switch (bool(p1_) + bool(p2_)) {
-    case 0:
-      __throw_filesystem_error(what, ec);
-    case 1:
-      __throw_filesystem_error(what, *p1_, ec);
-    case 2:
-      __throw_filesystem_error(what, *p1_, *p2_, ec);
-    }
-    __libcpp_unreachable();
-  }
-
-  _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4)
-  T report(const error_code& ec, const char* msg, ...) const {
-    va_list ap;
-    va_start(ap, msg);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-      report_impl(ec, msg, ap);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    } catch (...) {
-      va_end(ap);
-      throw;
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    va_end(ap);
-    return error_value<T>();
-  }
-
-  T report(errc const& err) const {
-    return report(make_error_code(err));
-  }
-
-  _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4)
-  T report(errc const& err, const char* msg, ...) const {
-    va_list ap;
-    va_start(ap, msg);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-      report_impl(make_error_code(err), msg, ap);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    } catch (...) {
-      va_end(ap);
-      throw;
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    va_end(ap);
-    return error_value<T>();
-  }
-
-private:
-  ErrorHandler(ErrorHandler const&) = delete;
-  ErrorHandler& operator=(ErrorHandler const&) = delete;
-};
-
-using chrono::duration;
-using chrono::duration_cast;
-
-#if defined(_LIBCPP_WIN32API)
-// Various C runtime versions (UCRT, or the legacy msvcrt.dll used by
-// some mingw toolchains) provide different stat function implementations,
-// with a number of limitations with respect to what we want from the
-// stat function. Instead provide our own (in the anonymous detail namespace
-// in posix_compat.h) which does exactly what we want, along with our own
-// stat structure and flag macros.
-
-struct TimeSpec {
-  int64_t tv_sec;
-  int64_t tv_nsec;
-};
-struct StatT {
-  unsigned st_mode;
-  TimeSpec st_atim;
-  TimeSpec st_mtim;
-  uint64_t st_dev; // FILE_ID_INFO::VolumeSerialNumber
-  struct FileIdStruct {
-    unsigned char id[16]; // FILE_ID_INFO::FileId
-    bool operator==(const FileIdStruct &other) const {
-      for (int i = 0; i < 16; i++)
-        if (id[i] != other.id[i])
-          return false;
-      return true;
-    }
-  } st_ino;
-  uint32_t st_nlink;
-  uintmax_t st_size;
-};
-
-#else
-using TimeSpec = struct timespec;
-using TimeVal = struct timeval;
-using StatT = struct stat;
-#endif
-
-template <class FileTimeT, class TimeT,
-          bool IsFloat = is_floating_point<typename FileTimeT::rep>::value>
-struct time_util_base {
-  using rep = typename FileTimeT::rep;
-  using fs_duration = typename FileTimeT::duration;
-  using fs_seconds = duration<rep>;
-  using fs_nanoseconds = duration<rep, nano>;
-  using fs_microseconds = duration<rep, micro>;
-
-  static constexpr rep max_seconds =
-      duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
-
-  static constexpr rep max_nsec =
-      duration_cast<fs_nanoseconds>(FileTimeT::duration::max() -
-                                    fs_seconds(max_seconds))
-          .count();
-
-  static constexpr rep min_seconds =
-      duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
-
-  static constexpr rep min_nsec_timespec =
-      duration_cast<fs_nanoseconds>(
-          (FileTimeT::duration::min() - fs_seconds(min_seconds)) +
-          fs_seconds(1))
-          .count();
-
-private:
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 fs_duration get_min_nsecs() {
-    return duration_cast<fs_duration>(
-        fs_nanoseconds(min_nsec_timespec) -
-        duration_cast<fs_nanoseconds>(fs_seconds(1)));
-  }
-  // Static assert that these values properly round trip.
-  static_assert(fs_seconds(min_seconds) + get_min_nsecs() ==
-                    FileTimeT::duration::min(),
-                "value doesn't roundtrip");
-
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool check_range() {
-    // This kinda sucks, but it's what happens when we don't have __int128_t.
-    if (sizeof(TimeT) == sizeof(rep)) {
-      typedef duration<long long, ratio<3600 * 24 * 365> > Years;
-      return duration_cast<Years>(fs_seconds(max_seconds)) > Years(250) &&
-             duration_cast<Years>(fs_seconds(min_seconds)) < Years(-250);
-    }
-    return max_seconds >= numeric_limits<TimeT>::max() &&
-           min_seconds <= numeric_limits<TimeT>::min();
-  }
-  static_assert(check_range(), "the representable range is unacceptable small");
-};
-
-template <class FileTimeT, class TimeT>
-struct time_util_base<FileTimeT, TimeT, true> {
-  using rep = typename FileTimeT::rep;
-  using fs_duration = typename FileTimeT::duration;
-  using fs_seconds = duration<rep>;
-  using fs_nanoseconds = duration<rep, nano>;
-  using fs_microseconds = duration<rep, micro>;
-
-  static const rep max_seconds;
-  static const rep max_nsec;
-  static const rep min_seconds;
-  static const rep min_nsec_timespec;
-};
-
-template <class FileTimeT, class TimeT>
-const typename FileTimeT::rep
-    time_util_base<FileTimeT, TimeT, true>::max_seconds =
-        duration_cast<fs_seconds>(FileTimeT::duration::max()).count();
-
-template <class FileTimeT, class TimeT>
-const typename FileTimeT::rep time_util_base<FileTimeT, TimeT, true>::max_nsec =
-    duration_cast<fs_nanoseconds>(FileTimeT::duration::max() -
-                                  fs_seconds(max_seconds))
-        .count();
-
-template <class FileTimeT, class TimeT>
-const typename FileTimeT::rep
-    time_util_base<FileTimeT, TimeT, true>::min_seconds =
-        duration_cast<fs_seconds>(FileTimeT::duration::min()).count();
-
-template <class FileTimeT, class TimeT>
-const typename FileTimeT::rep
-    time_util_base<FileTimeT, TimeT, true>::min_nsec_timespec =
-        duration_cast<fs_nanoseconds>((FileTimeT::duration::min() -
-                                       fs_seconds(min_seconds)) +
-                                      fs_seconds(1))
-            .count();
-
-template <class FileTimeT, class TimeT, class TimeSpecT>
-struct time_util : time_util_base<FileTimeT, TimeT> {
-  using Base = time_util_base<FileTimeT, TimeT>;
-  using Base::max_nsec;
-  using Base::max_seconds;
-  using Base::min_nsec_timespec;
-  using Base::min_seconds;
-
-  using typename Base::fs_duration;
-  using typename Base::fs_microseconds;
-  using typename Base::fs_nanoseconds;
-  using typename Base::fs_seconds;
-
-public:
-  template <class CType, class ChronoType>
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool checked_set(CType* out,
-                                                        ChronoType time) {
-    using Lim = numeric_limits<CType>;
-    if (time > Lim::max() || time < Lim::min())
-      return false;
-    *out = static_cast<CType>(time);
-    return true;
-  }
-
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool is_representable(TimeSpecT tm) {
-    if (tm.tv_sec >= 0) {
-      return tm.tv_sec < max_seconds ||
-             (tm.tv_sec == max_seconds && tm.tv_nsec <= max_nsec);
-    } else if (tm.tv_sec == (min_seconds - 1)) {
-      return tm.tv_nsec >= min_nsec_timespec;
-    } else {
-      return tm.tv_sec >= min_seconds;
-    }
-  }
-
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool is_representable(FileTimeT tm) {
-    auto secs = duration_cast<fs_seconds>(tm.time_since_epoch());
-    auto nsecs = duration_cast<fs_nanoseconds>(tm.time_since_epoch() - secs);
-    if (nsecs.count() < 0) {
-      secs = secs + fs_seconds(1);
-      nsecs = nsecs + fs_seconds(1);
-    }
-    using TLim = numeric_limits<TimeT>;
-    if (secs.count() >= 0)
-      return secs.count() <= TLim::max();
-    return secs.count() >= TLim::min();
-  }
-
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 FileTimeT
-  convert_from_timespec(TimeSpecT tm) {
-    if (tm.tv_sec >= 0 || tm.tv_nsec == 0) {
-      return FileTimeT(fs_seconds(tm.tv_sec) +
-                       duration_cast<fs_duration>(fs_nanoseconds(tm.tv_nsec)));
-    } else { // tm.tv_sec < 0
-      auto adj_subsec = duration_cast<fs_duration>(fs_seconds(1) -
-                                                   fs_nanoseconds(tm.tv_nsec));
-      auto Dur = fs_seconds(tm.tv_sec + 1) - adj_subsec;
-      return FileTimeT(Dur);
-    }
-  }
-
-  template <class SubSecT>
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
-  set_times_checked(TimeT* sec_out, SubSecT* subsec_out, FileTimeT tp) {
-    auto dur = tp.time_since_epoch();
-    auto sec_dur = duration_cast<fs_seconds>(dur);
-    auto subsec_dur = duration_cast<fs_nanoseconds>(dur - sec_dur);
-    // The tv_nsec and tv_usec fields must not be negative so adjust accordingly
-    if (subsec_dur.count() < 0) {
-      if (sec_dur.count() > min_seconds) {
-        sec_dur = sec_dur - fs_seconds(1);
-        subsec_dur = subsec_dur + fs_seconds(1);
-      } else {
-        subsec_dur = fs_nanoseconds::zero();
-      }
-    }
-    return checked_set(sec_out, sec_dur.count()) &&
-           checked_set(subsec_out, subsec_dur.count());
-  }
-  static _LIBCPP_CONSTEXPR_SINCE_CXX14 bool convert_to_timespec(TimeSpecT& dest,
-                                                                FileTimeT tp) {
-    if (!is_representable(tp))
-      return false;
-    return set_times_checked(&dest.tv_sec, &dest.tv_nsec, tp);
-  }
-};
-
-#if defined(_LIBCPP_WIN32API)
-using fs_time = time_util<file_time_type, int64_t, TimeSpec>;
-#else
-using fs_time = time_util<file_time_type, time_t, TimeSpec>;
-#endif
-
-#if defined(__APPLE__)
-inline TimeSpec extract_mtime(StatT const& st) { return st.st_mtimespec; }
-inline TimeSpec extract_atime(StatT const& st) { return st.st_atimespec; }
-#elif defined(__MVS__)
-inline TimeSpec extract_mtime(StatT const& st) {
-  TimeSpec TS = {st.st_mtime, 0};
-  return TS;
-}
-inline TimeSpec extract_atime(StatT const& st) {
-  TimeSpec TS = {st.st_atime, 0};
-  return TS;
-}
-#elif defined(_AIX)
-inline TimeSpec extract_mtime(StatT const& st) {
-  TimeSpec TS = {st.st_mtime, st.st_mtime_n};
-  return TS;
-}
-inline TimeSpec extract_atime(StatT const& st) {
-  TimeSpec TS = {st.st_atime, st.st_atime_n};
-  return TS;
-}
-#else
-inline TimeSpec extract_mtime(StatT const& st) { return st.st_mtim; }
-inline TimeSpec extract_atime(StatT const& st) { return st.st_atim; }
-#endif
-
-#if !defined(_LIBCPP_WIN32API)
-inline TimeVal make_timeval(TimeSpec const& ts) {
-  using namespace chrono;
-  auto Convert = [](long nsec) {
-    using int_type = decltype(std::declval<TimeVal>().tv_usec);
-    auto dur = duration_cast<microseconds>(nanoseconds(nsec)).count();
-    return static_cast<int_type>(dur);
-  };
-  TimeVal TV = {};
-  TV.tv_sec = ts.tv_sec;
-  TV.tv_usec = Convert(ts.tv_nsec);
-  return TV;
-}
-
-inline bool posix_utimes(const path& p, std::array<TimeSpec, 2> const& TS,
-                  error_code& ec) {
-  TimeVal ConvertedTS[2] = {make_timeval(TS[0]), make_timeval(TS[1])};
-  if (::utimes(p.c_str(), ConvertedTS) == -1) {
-    ec = capture_errno();
-    return true;
-  }
-  return false;
-}
-
-#if defined(_LIBCPP_USE_UTIMENSAT)
-bool posix_utimensat(const path& p, std::array<TimeSpec, 2> const& TS,
-                     error_code& ec) {
-  if (::utimensat(AT_FDCWD, p.c_str(), TS.data(), 0) == -1) {
-    ec = capture_errno();
-    return true;
-  }
-  return false;
-}
-#endif
-
-bool set_file_times(const path& p, std::array<TimeSpec, 2> const& TS,
-                    error_code& ec) {
-#if !defined(_LIBCPP_USE_UTIMENSAT)
-  return posix_utimes(p, TS, ec);
-#else
-  return posix_utimensat(p, TS, ec);
-#endif
-}
-
-#if defined(DT_BLK)
-template <class DirEntT, class = decltype(DirEntT::d_type)>
-static file_type get_file_type(DirEntT* ent, int) {
-  switch (ent->d_type) {
-  case DT_BLK:
-    return file_type::block;
-  case DT_CHR:
-    return file_type::character;
-  case DT_DIR:
-    return file_type::directory;
-  case DT_FIFO:
-    return file_type::fifo;
-  case DT_LNK:
-    return file_type::symlink;
-  case DT_REG:
-    return file_type::regular;
-  case DT_SOCK:
-    return file_type::socket;
-  // Unlike in lstat, hitting "unknown" here simply means that the underlying
-  // filesystem doesn't support d_type. Report is as 'none' so we correctly
-  // set the cache to empty.
-  case DT_UNKNOWN:
-    break;
-  }
-  return file_type::none;
-}
-#endif // defined(DT_BLK)
-
-template <class DirEntT>
-static file_type get_file_type(DirEntT*, long) {
-  return file_type::none;
-}
-
-static pair<string_view, file_type> posix_readdir(DIR* dir_stream,
-                                                  error_code& ec) {
-  struct dirent* dir_entry_ptr = nullptr;
-  errno = 0; // zero errno in order to detect errors
-  ec.clear();
-  if ((dir_entry_ptr = ::readdir(dir_stream)) == nullptr) {
-    if (errno)
-      ec = capture_errno();
-    return {};
-  } else {
-    return {dir_entry_ptr->d_name, get_file_type(dir_entry_ptr, 0)};
-  }
-}
-
-#else // _LIBCPP_WIN32API
-
-static file_type get_file_type(const WIN32_FIND_DATAW& data) {
-  if (data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT &&
-      data.dwReserved0 == IO_REPARSE_TAG_SYMLINK)
-    return file_type::symlink;
-  if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-    return file_type::directory;
-  return file_type::regular;
-}
-static uintmax_t get_file_size(const WIN32_FIND_DATAW& data) {
-  return (static_cast<uint64_t>(data.nFileSizeHigh) << 32) + data.nFileSizeLow;
-}
-static file_time_type get_write_time(const WIN32_FIND_DATAW& data) {
-  ULARGE_INTEGER tmp;
-  const FILETIME& time = data.ftLastWriteTime;
-  tmp.u.LowPart = time.dwLowDateTime;
-  tmp.u.HighPart = time.dwHighDateTime;
-  return file_time_type(file_time_type::duration(tmp.QuadPart));
-}
-
-#endif // !_LIBCPP_WIN32API
-
-} // namespace
-} // end namespace detail
-
-_LIBCPP_END_NAMESPACE_FILESYSTEM
-
-_LIBCPP_DIAGNOSTIC_POP
-
-#endif // FILESYSTEM_COMMON_H
diff --git a/third_party/libcxx/src/filesystem/operations.cpp b/third_party/libcxx/src/filesystem/operations.cpp
deleted file mode 100644
index fc14778f3..000000000
--- a/third_party/libcxx/src/filesystem/operations.cpp
+++ /dev/null
@@ -1,2103 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__assert>
-#include <__utility/unreachable.h>
-#include <array>
-#include <climits>
-#include <cstdlib>
-#include <filesystem>
-#include <iterator>
-#include <string_view>
-#include <type_traits>
-#include <vector>
-
-#include "filesystem_common.h"
-
-#include "posix_compat.h"
-
-#if defined(_LIBCPP_WIN32API)
-# define WIN32_LEAN_AND_MEAN
-# define NOMINMAX
-# include <windows.h>
-#else
-# include <dirent.h>
-# include <sys/stat.h>
-# include <sys/statvfs.h>
-# include <unistd.h>
-#endif
-#include <time.h>
-#include <fcntl.h> /* values for fchmodat */
-
-#if __has_include(<sys/sendfile.h>)
-# include <sys/sendfile.h>
-# define _LIBCPP_FILESYSTEM_USE_SENDFILE
-#elif defined(__APPLE__) || __has_include(<copyfile.h>)
-# include <copyfile.h>
-# define _LIBCPP_FILESYSTEM_USE_COPYFILE
-#else
-# include <fstream>
-# define _LIBCPP_FILESYSTEM_USE_FSTREAM
-#endif
-
-#if !defined(CLOCK_REALTIME) && !defined(_LIBCPP_WIN32API)
-# include <sys/time.h> // for gettimeofday and timeval
-#endif
-
-#if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
-# pragma comment(lib, "rt")
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
-
-namespace {
-
-bool isSeparator(path::value_type C) {
-  if (C == '/')
-    return true;
-#if defined(_LIBCPP_WIN32API)
-  if (C == '\\')
-    return true;
-#endif
-  return false;
-}
-
-bool isDriveLetter(path::value_type C) {
-  return (C >= 'a' && C <= 'z') || (C >= 'A' && C <= 'Z');
-}
-
-namespace parser {
-
-using string_view_t = path::__string_view;
-using string_view_pair = pair<string_view_t, string_view_t>;
-using PosPtr = path::value_type const*;
-
-struct PathParser {
-  enum ParserState : unsigned char {
-    // Zero is a special sentinel value used by default constructed iterators.
-    PS_BeforeBegin = path::iterator::_BeforeBegin,
-    PS_InRootName = path::iterator::_InRootName,
-    PS_InRootDir = path::iterator::_InRootDir,
-    PS_InFilenames = path::iterator::_InFilenames,
-    PS_InTrailingSep = path::iterator::_InTrailingSep,
-    PS_AtEnd = path::iterator::_AtEnd
-  };
-
-  const string_view_t Path;
-  string_view_t RawEntry;
-  ParserState State;
-
-private:
-  PathParser(string_view_t P, ParserState State) noexcept : Path(P),
-                                                            State(State) {}
-
-public:
-  PathParser(string_view_t P, string_view_t E, unsigned char S)
-      : Path(P), RawEntry(E), State(static_cast<ParserState>(S)) {
-    // S cannot be '0' or PS_BeforeBegin.
-  }
-
-  static PathParser CreateBegin(string_view_t P) noexcept {
-    PathParser PP(P, PS_BeforeBegin);
-    PP.increment();
-    return PP;
-  }
-
-  static PathParser CreateEnd(string_view_t P) noexcept {
-    PathParser PP(P, PS_AtEnd);
-    return PP;
-  }
-
-  PosPtr peek() const noexcept {
-    auto TkEnd = getNextTokenStartPos();
-    auto End = getAfterBack();
-    return TkEnd == End ? nullptr : TkEnd;
-  }
-
-  void increment() noexcept {
-    const PosPtr End = getAfterBack();
-    const PosPtr Start = getNextTokenStartPos();
-    if (Start == End)
-      return makeState(PS_AtEnd);
-
-    switch (State) {
-    case PS_BeforeBegin: {
-      PosPtr TkEnd = consumeRootName(Start, End);
-      if (TkEnd)
-        return makeState(PS_InRootName, Start, TkEnd);
-    }
-      _LIBCPP_FALLTHROUGH();
-    case PS_InRootName: {
-      PosPtr TkEnd = consumeAllSeparators(Start, End);
-      if (TkEnd)
-        return makeState(PS_InRootDir, Start, TkEnd);
-      else
-        return makeState(PS_InFilenames, Start, consumeName(Start, End));
-    }
-    case PS_InRootDir:
-      return makeState(PS_InFilenames, Start, consumeName(Start, End));
-
-    case PS_InFilenames: {
-      PosPtr SepEnd = consumeAllSeparators(Start, End);
-      if (SepEnd != End) {
-        PosPtr TkEnd = consumeName(SepEnd, End);
-        if (TkEnd)
-          return makeState(PS_InFilenames, SepEnd, TkEnd);
-      }
-      return makeState(PS_InTrailingSep, Start, SepEnd);
-    }
-
-    case PS_InTrailingSep:
-      return makeState(PS_AtEnd);
-
-    case PS_AtEnd:
-      __libcpp_unreachable();
-    }
-  }
-
-  void decrement() noexcept {
-    const PosPtr REnd = getBeforeFront();
-    const PosPtr RStart = getCurrentTokenStartPos() - 1;
-    if (RStart == REnd) // we're decrementing the begin
-      return makeState(PS_BeforeBegin);
-
-    switch (State) {
-    case PS_AtEnd: {
-      // Try to consume a trailing separator or root directory first.
-      if (PosPtr SepEnd = consumeAllSeparators(RStart, REnd)) {
-        if (SepEnd == REnd)
-          return makeState(PS_InRootDir, Path.data(), RStart + 1);
-        PosPtr TkStart = consumeRootName(SepEnd, REnd);
-        if (TkStart == REnd)
-          return makeState(PS_InRootDir, RStart, RStart + 1);
-        return makeState(PS_InTrailingSep, SepEnd + 1, RStart + 1);
-      } else {
-        PosPtr TkStart = consumeRootName(RStart, REnd);
-        if (TkStart == REnd)
-          return makeState(PS_InRootName, TkStart + 1, RStart + 1);
-        TkStart = consumeName(RStart, REnd);
-        return makeState(PS_InFilenames, TkStart + 1, RStart + 1);
-      }
-    }
-    case PS_InTrailingSep:
-      return makeState(PS_InFilenames, consumeName(RStart, REnd) + 1,
-                       RStart + 1);
-    case PS_InFilenames: {
-      PosPtr SepEnd = consumeAllSeparators(RStart, REnd);
-      if (SepEnd == REnd)
-        return makeState(PS_InRootDir, Path.data(), RStart + 1);
-      PosPtr TkStart = consumeRootName(SepEnd ? SepEnd : RStart, REnd);
-      if (TkStart == REnd) {
-        if (SepEnd)
-          return makeState(PS_InRootDir, SepEnd + 1, RStart + 1);
-        return makeState(PS_InRootName, TkStart + 1, RStart + 1);
-      }
-      TkStart = consumeName(SepEnd, REnd);
-      return makeState(PS_InFilenames, TkStart + 1, SepEnd + 1);
-    }
-    case PS_InRootDir:
-      return makeState(PS_InRootName, Path.data(), RStart + 1);
-    case PS_InRootName:
-    case PS_BeforeBegin:
-      __libcpp_unreachable();
-    }
-  }
-
-  /// \brief Return a view with the "preferred representation" of the current
-  ///   element. For example trailing separators are represented as a '.'
-  string_view_t operator*() const noexcept {
-    switch (State) {
-    case PS_BeforeBegin:
-    case PS_AtEnd:
-      return PATHSTR("");
-    case PS_InRootDir:
-      if (RawEntry[0] == '\\')
-        return PATHSTR("\\");
-      else
-        return PATHSTR("/");
-    case PS_InTrailingSep:
-      return PATHSTR("");
-    case PS_InRootName:
-    case PS_InFilenames:
-      return RawEntry;
-    }
-    __libcpp_unreachable();
-  }
-
-  explicit operator bool() const noexcept {
-    return State != PS_BeforeBegin && State != PS_AtEnd;
-  }
-
-  PathParser& operator++() noexcept {
-    increment();
-    return *this;
-  }
-
-  PathParser& operator--() noexcept {
-    decrement();
-    return *this;
-  }
-
-  bool atEnd() const noexcept {
-    return State == PS_AtEnd;
-  }
-
-  bool inRootDir() const noexcept {
-    return State == PS_InRootDir;
-  }
-
-  bool inRootName() const noexcept {
-    return State == PS_InRootName;
-  }
-
-  bool inRootPath() const noexcept {
-    return inRootName() || inRootDir();
-  }
-
-private:
-  void makeState(ParserState NewState, PosPtr Start, PosPtr End) noexcept {
-    State = NewState;
-    RawEntry = string_view_t(Start, End - Start);
-  }
-  void makeState(ParserState NewState) noexcept {
-    State = NewState;
-    RawEntry = {};
-  }
-
-  PosPtr getAfterBack() const noexcept { return Path.data() + Path.size(); }
-
-  PosPtr getBeforeFront() const noexcept { return Path.data() - 1; }
-
-  /// \brief Return a pointer to the first character after the currently
-  ///   lexed element.
-  PosPtr getNextTokenStartPos() const noexcept {
-    switch (State) {
-    case PS_BeforeBegin:
-      return Path.data();
-    case PS_InRootName:
-    case PS_InRootDir:
-    case PS_InFilenames:
-      return &RawEntry.back() + 1;
-    case PS_InTrailingSep:
-    case PS_AtEnd:
-      return getAfterBack();
-    }
-    __libcpp_unreachable();
-  }
-
-  /// \brief Return a pointer to the first character in the currently lexed
-  ///   element.
-  PosPtr getCurrentTokenStartPos() const noexcept {
-    switch (State) {
-    case PS_BeforeBegin:
-    case PS_InRootName:
-      return &Path.front();
-    case PS_InRootDir:
-    case PS_InFilenames:
-    case PS_InTrailingSep:
-      return &RawEntry.front();
-    case PS_AtEnd:
-      return &Path.back() + 1;
-    }
-    __libcpp_unreachable();
-  }
-
-  // Consume all consecutive separators.
-  PosPtr consumeAllSeparators(PosPtr P, PosPtr End) const noexcept {
-    if (P == nullptr || P == End || !isSeparator(*P))
-      return nullptr;
-    const int Inc = P < End ? 1 : -1;
-    P += Inc;
-    while (P != End && isSeparator(*P))
-      P += Inc;
-    return P;
-  }
-
-  // Consume exactly N separators, or return nullptr.
-  PosPtr consumeNSeparators(PosPtr P, PosPtr End, int N) const noexcept {
-    PosPtr Ret = consumeAllSeparators(P, End);
-    if (Ret == nullptr)
-      return nullptr;
-    if (P < End) {
-      if (Ret == P + N)
-        return Ret;
-    } else {
-      if (Ret == P - N)
-        return Ret;
-    }
-    return nullptr;
-  }
-
-  PosPtr consumeName(PosPtr P, PosPtr End) const noexcept {
-    PosPtr Start = P;
-    if (P == nullptr || P == End || isSeparator(*P))
-      return nullptr;
-    const int Inc = P < End ? 1 : -1;
-    P += Inc;
-    while (P != End && !isSeparator(*P))
-      P += Inc;
-    if (P == End && Inc < 0) {
-      // Iterating backwards and consumed all the rest of the input.
-      // Check if the start of the string would have been considered
-      // a root name.
-      PosPtr RootEnd = consumeRootName(End + 1, Start);
-      if (RootEnd)
-        return RootEnd - 1;
-    }
-    return P;
-  }
-
-  PosPtr consumeDriveLetter(PosPtr P, PosPtr End) const noexcept {
-    if (P == End)
-      return nullptr;
-    if (P < End) {
-      if (P + 1 == End || !isDriveLetter(P[0]) || P[1] != ':')
-        return nullptr;
-      return P + 2;
-    } else {
-      if (P - 1 == End || !isDriveLetter(P[-1]) || P[0] != ':')
-        return nullptr;
-      return P - 2;
-    }
-  }
-
-  PosPtr consumeNetworkRoot(PosPtr P, PosPtr End) const noexcept {
-    if (P == End)
-      return nullptr;
-    if (P < End)
-      return consumeName(consumeNSeparators(P, End, 2), End);
-    else
-      return consumeNSeparators(consumeName(P, End), End, 2);
-  }
-
-  PosPtr consumeRootName(PosPtr P, PosPtr End) const noexcept {
-#if defined(_LIBCPP_WIN32API)
-    if (PosPtr Ret = consumeDriveLetter(P, End))
-      return Ret;
-    if (PosPtr Ret = consumeNetworkRoot(P, End))
-      return Ret;
-#endif
-    return nullptr;
-  }
-};
-
-string_view_pair separate_filename(string_view_t const& s) {
-  if (s == PATHSTR(".") || s == PATHSTR("..") || s.empty())
-    return string_view_pair{s, PATHSTR("")};
-  auto pos = s.find_last_of('.');
-  if (pos == string_view_t::npos || pos == 0)
-    return string_view_pair{s, string_view_t{}};
-  return string_view_pair{s.substr(0, pos), s.substr(pos)};
-}
-
-string_view_t createView(PosPtr S, PosPtr E) noexcept {
-  return {S, static_cast<size_t>(E - S) + 1};
-}
-
-} // namespace parser
-} // namespace
-
-//                       POSIX HELPERS
-
-#if defined(_LIBCPP_WIN32API)
-namespace detail {
-
-errc __win_err_to_errc(int err) {
-  constexpr struct {
-    DWORD win;
-    errc errc;
-  } win_error_mapping[] = {
-      {ERROR_ACCESS_DENIED, errc::permission_denied},
-      {ERROR_ALREADY_EXISTS, errc::file_exists},
-      {ERROR_BAD_NETPATH, errc::no_such_file_or_directory},
-      {ERROR_BAD_PATHNAME, errc::no_such_file_or_directory},
-      {ERROR_BAD_UNIT, errc::no_such_device},
-      {ERROR_BROKEN_PIPE, errc::broken_pipe},
-      {ERROR_BUFFER_OVERFLOW, errc::filename_too_long},
-      {ERROR_BUSY, errc::device_or_resource_busy},
-      {ERROR_BUSY_DRIVE, errc::device_or_resource_busy},
-      {ERROR_CANNOT_MAKE, errc::permission_denied},
-      {ERROR_CANTOPEN, errc::io_error},
-      {ERROR_CANTREAD, errc::io_error},
-      {ERROR_CANTWRITE, errc::io_error},
-      {ERROR_CURRENT_DIRECTORY, errc::permission_denied},
-      {ERROR_DEV_NOT_EXIST, errc::no_such_device},
-      {ERROR_DEVICE_IN_USE, errc::device_or_resource_busy},
-      {ERROR_DIR_NOT_EMPTY, errc::directory_not_empty},
-      {ERROR_DIRECTORY, errc::invalid_argument},
-      {ERROR_DISK_FULL, errc::no_space_on_device},
-      {ERROR_FILE_EXISTS, errc::file_exists},
-      {ERROR_FILE_NOT_FOUND, errc::no_such_file_or_directory},
-      {ERROR_HANDLE_DISK_FULL, errc::no_space_on_device},
-      {ERROR_INVALID_ACCESS, errc::permission_denied},
-      {ERROR_INVALID_DRIVE, errc::no_such_device},
-      {ERROR_INVALID_FUNCTION, errc::function_not_supported},
-      {ERROR_INVALID_HANDLE, errc::invalid_argument},
-      {ERROR_INVALID_NAME, errc::no_such_file_or_directory},
-      {ERROR_INVALID_PARAMETER, errc::invalid_argument},
-      {ERROR_LOCK_VIOLATION, errc::no_lock_available},
-      {ERROR_LOCKED, errc::no_lock_available},
-      {ERROR_NEGATIVE_SEEK, errc::invalid_argument},
-      {ERROR_NOACCESS, errc::permission_denied},
-      {ERROR_NOT_ENOUGH_MEMORY, errc::not_enough_memory},
-      {ERROR_NOT_READY, errc::resource_unavailable_try_again},
-      {ERROR_NOT_SAME_DEVICE, errc::cross_device_link},
-      {ERROR_NOT_SUPPORTED, errc::not_supported},
-      {ERROR_OPEN_FAILED, errc::io_error},
-      {ERROR_OPEN_FILES, errc::device_or_resource_busy},
-      {ERROR_OPERATION_ABORTED, errc::operation_canceled},
-      {ERROR_OUTOFMEMORY, errc::not_enough_memory},
-      {ERROR_PATH_NOT_FOUND, errc::no_such_file_or_directory},
-      {ERROR_READ_FAULT, errc::io_error},
-      {ERROR_REPARSE_TAG_INVALID, errc::invalid_argument},
-      {ERROR_RETRY, errc::resource_unavailable_try_again},
-      {ERROR_SEEK, errc::io_error},
-      {ERROR_SHARING_VIOLATION, errc::permission_denied},
-      {ERROR_TOO_MANY_OPEN_FILES, errc::too_many_files_open},
-      {ERROR_WRITE_FAULT, errc::io_error},
-      {ERROR_WRITE_PROTECT, errc::permission_denied},
-  };
-
-  for (const auto &pair : win_error_mapping)
-    if (pair.win == static_cast<DWORD>(err))
-      return pair.errc;
-  return errc::invalid_argument;
-}
-
-} // namespace detail
-#endif
-
-namespace detail {
-namespace {
-
-using value_type = path::value_type;
-using string_type = path::string_type;
-
-struct FileDescriptor {
-  const path& name;
-  int fd = -1;
-  StatT m_stat;
-  file_status m_status;
-
-  template <class... Args>
-  static FileDescriptor create(const path* p, error_code& ec, Args... args) {
-    ec.clear();
-    int fd;
-    if ((fd = detail::open(p->c_str(), args...)) == -1) {
-      ec = capture_errno();
-      return FileDescriptor{p};
-    }
-    return FileDescriptor(p, fd);
-  }
-
-  template <class... Args>
-  static FileDescriptor create_with_status(const path* p, error_code& ec,
-                                           Args... args) {
-    FileDescriptor fd = create(p, ec, args...);
-    if (!ec)
-      fd.refresh_status(ec);
-
-    return fd;
-  }
-
-  file_status get_status() const { return m_status; }
-  StatT const& get_stat() const { return m_stat; }
-
-  bool status_known() const { return _VSTD_FS::status_known(m_status); }
-
-  file_status refresh_status(error_code& ec);
-
-  void close() noexcept {
-    if (fd != -1)
-      detail::close(fd);
-    fd = -1;
-  }
-
-  FileDescriptor(FileDescriptor&& other)
-      : name(other.name), fd(other.fd), m_stat(other.m_stat),
-        m_status(other.m_status) {
-    other.fd = -1;
-    other.m_status = file_status{};
-  }
-
-  ~FileDescriptor() { close(); }
-
-  FileDescriptor(FileDescriptor const&) = delete;
-  FileDescriptor& operator=(FileDescriptor const&) = delete;
-
-private:
-  explicit FileDescriptor(const path* p, int fd = -1) : name(*p), fd(fd) {}
-};
-
-perms posix_get_perms(const StatT& st) noexcept {
-  return static_cast<perms>(st.st_mode) & perms::mask;
-}
-
-file_status create_file_status(error_code& m_ec, path const& p,
-                               const StatT& path_stat, error_code* ec) {
-  if (ec)
-    *ec = m_ec;
-  if (m_ec && (m_ec.value() == ENOENT || m_ec.value() == ENOTDIR)) {
-    return file_status(file_type::not_found);
-  } else if (m_ec) {
-    ErrorHandler<void> err("posix_stat", ec, &p);
-    err.report(m_ec, "failed to determine attributes for the specified path");
-    return file_status(file_type::none);
-  }
-  // else
-
-  file_status fs_tmp;
-  auto const mode = path_stat.st_mode;
-  if (S_ISLNK(mode))
-    fs_tmp.type(file_type::symlink);
-  else if (S_ISREG(mode))
-    fs_tmp.type(file_type::regular);
-  else if (S_ISDIR(mode))
-    fs_tmp.type(file_type::directory);
-  else if (S_ISBLK(mode))
-    fs_tmp.type(file_type::block);
-  else if (S_ISCHR(mode))
-    fs_tmp.type(file_type::character);
-  else if (S_ISFIFO(mode))
-    fs_tmp.type(file_type::fifo);
-  else if (S_ISSOCK(mode))
-    fs_tmp.type(file_type::socket);
-  else
-    fs_tmp.type(file_type::unknown);
-
-  fs_tmp.permissions(detail::posix_get_perms(path_stat));
-  return fs_tmp;
-}
-
-file_status posix_stat(path const& p, StatT& path_stat, error_code* ec) {
-  error_code m_ec;
-  if (detail::stat(p.c_str(), &path_stat) == -1)
-    m_ec = detail::capture_errno();
-  return create_file_status(m_ec, p, path_stat, ec);
-}
-
-file_status posix_stat(path const& p, error_code* ec) {
-  StatT path_stat;
-  return posix_stat(p, path_stat, ec);
-}
-
-file_status posix_lstat(path const& p, StatT& path_stat, error_code* ec) {
-  error_code m_ec;
-  if (detail::lstat(p.c_str(), &path_stat) == -1)
-    m_ec = detail::capture_errno();
-  return create_file_status(m_ec, p, path_stat, ec);
-}
-
-file_status posix_lstat(path const& p, error_code* ec) {
-  StatT path_stat;
-  return posix_lstat(p, path_stat, ec);
-}
-
-// http://pubs.opengroup.org/onlinepubs/9699919799/functions/ftruncate.html
-bool posix_ftruncate(const FileDescriptor& fd, off_t to_size, error_code& ec) {
-  if (detail::ftruncate(fd.fd, to_size) == -1) {
-    ec = capture_errno();
-    return true;
-  }
-  ec.clear();
-  return false;
-}
-
-bool posix_fchmod(const FileDescriptor& fd, const StatT& st, error_code& ec) {
-  if (detail::fchmod(fd.fd, st.st_mode) == -1) {
-    ec = capture_errno();
-    return true;
-  }
-  ec.clear();
-  return false;
-}
-
-bool stat_equivalent(const StatT& st1, const StatT& st2) {
-  return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
-}
-
-file_status FileDescriptor::refresh_status(error_code& ec) {
-  // FD must be open and good.
-  m_status = file_status{};
-  m_stat = {};
-  error_code m_ec;
-  if (detail::fstat(fd, &m_stat) == -1)
-    m_ec = capture_errno();
-  m_status = create_file_status(m_ec, name, m_stat, &ec);
-  return m_status;
-}
-} // namespace
-} // end namespace detail
-
-using detail::capture_errno;
-using detail::ErrorHandler;
-using detail::StatT;
-using detail::TimeSpec;
-using parser::createView;
-using parser::PathParser;
-using parser::string_view_t;
-
-const bool _FilesystemClock::is_steady;
-
-_FilesystemClock::time_point _FilesystemClock::now() noexcept {
-  typedef chrono::duration<rep> __secs;
-#if defined(_LIBCPP_WIN32API)
-  typedef chrono::duration<rep, nano> __nsecs;
-  FILETIME time;
-  GetSystemTimeAsFileTime(&time);
-  TimeSpec tp = detail::filetime_to_timespec(time);
-  return time_point(__secs(tp.tv_sec) +
-                    chrono::duration_cast<duration>(__nsecs(tp.tv_nsec)));
-#elif defined(CLOCK_REALTIME)
-  typedef chrono::duration<rep, nano> __nsecs;
-  struct timespec tp;
-  if (0 != clock_gettime(CLOCK_REALTIME, &tp))
-    __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
-  return time_point(__secs(tp.tv_sec) +
-                    chrono::duration_cast<duration>(__nsecs(tp.tv_nsec)));
-#else
-  typedef chrono::duration<rep, micro> __microsecs;
-  timeval tv;
-  gettimeofday(&tv, 0);
-  return time_point(__secs(tv.tv_sec) + __microsecs(tv.tv_usec));
-#endif // CLOCK_REALTIME
-}
-
-filesystem_error::~filesystem_error() {}
-
-void filesystem_error::__create_what(int __num_paths) {
-  const char* derived_what = system_error::what();
-  __storage_->__what_ = [&]() -> string {
-    switch (__num_paths) {
-    case 0:
-      return detail::format_string("filesystem error: %s", derived_what);
-    case 1:
-      return detail::format_string("filesystem error: %s [" PATH_CSTR_FMT "]",
-                                   derived_what, path1().c_str());
-    case 2:
-      return detail::format_string("filesystem error: %s [" PATH_CSTR_FMT "] [" PATH_CSTR_FMT "]",
-                                   derived_what, path1().c_str(), path2().c_str());
-    }
-    __libcpp_unreachable();
-  }();
-}
-
-static path __do_absolute(const path& p, path* cwd, error_code* ec) {
-  if (ec)
-    ec->clear();
-  if (p.is_absolute())
-    return p;
-  *cwd = __current_path(ec);
-  if (ec && *ec)
-    return {};
-  return (*cwd) / p;
-}
-
-path __absolute(const path& p, error_code* ec) {
-  path cwd;
-  return __do_absolute(p, &cwd, ec);
-}
-
-path __canonical(path const& orig_p, error_code* ec) {
-  path cwd;
-  ErrorHandler<path> err("canonical", ec, &orig_p, &cwd);
-
-  path p = __do_absolute(orig_p, &cwd, ec);
-#if (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112) || defined(_LIBCPP_WIN32API)
-  std::unique_ptr<path::value_type, decltype(&::free)>
-    hold(detail::realpath(p.c_str(), nullptr), &::free);
-  if (hold.get() == nullptr)
-    return err.report(capture_errno());
-  return {hold.get()};
-#else
-  #if defined(__MVS__) && !defined(PATH_MAX)
-    path::value_type buff[ _XOPEN_PATH_MAX + 1 ];
-  #else
-    path::value_type buff[PATH_MAX + 1];
-  #endif
-  path::value_type* ret;
-  if ((ret = detail::realpath(p.c_str(), buff)) == nullptr)
-    return err.report(capture_errno());
-  return {ret};
-#endif
-}
-
-void __copy(const path& from, const path& to, copy_options options,
-            error_code* ec) {
-  ErrorHandler<void> err("copy", ec, &from, &to);
-
-  const bool sym_status = bool(
-      options & (copy_options::create_symlinks | copy_options::skip_symlinks));
-
-  const bool sym_status2 = bool(options & copy_options::copy_symlinks);
-
-  error_code m_ec1;
-  StatT f_st = {};
-  const file_status f = sym_status || sym_status2
-                            ? detail::posix_lstat(from, f_st, &m_ec1)
-                            : detail::posix_stat(from, f_st, &m_ec1);
-  if (m_ec1)
-    return err.report(m_ec1);
-
-  StatT t_st = {};
-  const file_status t = sym_status ? detail::posix_lstat(to, t_st, &m_ec1)
-                                   : detail::posix_stat(to, t_st, &m_ec1);
-
-  if (not status_known(t))
-    return err.report(m_ec1);
-
-  if (!exists(f) || is_other(f) || is_other(t) ||
-      (is_directory(f) && is_regular_file(t)) ||
-      detail::stat_equivalent(f_st, t_st)) {
-    return err.report(errc::function_not_supported);
-  }
-
-  if (ec)
-    ec->clear();
-
-  if (is_symlink(f)) {
-    if (bool(copy_options::skip_symlinks & options)) {
-      // do nothing
-    } else if (not exists(t)) {
-      __copy_symlink(from, to, ec);
-    } else {
-      return err.report(errc::file_exists);
-    }
-    return;
-  } else if (is_regular_file(f)) {
-    if (bool(copy_options::directories_only & options)) {
-      // do nothing
-    } else if (bool(copy_options::create_symlinks & options)) {
-      __create_symlink(from, to, ec);
-    } else if (bool(copy_options::create_hard_links & options)) {
-      __create_hard_link(from, to, ec);
-    } else if (is_directory(t)) {
-      __copy_file(from, to / from.filename(), options, ec);
-    } else {
-      __copy_file(from, to, options, ec);
-    }
-    return;
-  } else if (is_directory(f) && bool(copy_options::create_symlinks & options)) {
-    return err.report(errc::is_a_directory);
-  } else if (is_directory(f) && (bool(copy_options::recursive & options) ||
-                                 copy_options::none == options)) {
-
-    if (!exists(t)) {
-      // create directory to with attributes from 'from'.
-      __create_directory(to, from, ec);
-      if (ec && *ec) {
-        return;
-      }
-    }
-    directory_iterator it =
-        ec ? directory_iterator(from, *ec) : directory_iterator(from);
-    if (ec && *ec) {
-      return;
-    }
-    error_code m_ec2;
-    for (; it != directory_iterator(); it.increment(m_ec2)) {
-      if (m_ec2) {
-        return err.report(m_ec2);
-      }
-      __copy(it->path(), to / it->path().filename(),
-             options | copy_options::__in_recursive_copy, ec);
-      if (ec && *ec) {
-        return;
-      }
-    }
-  }
-}
-
-namespace detail {
-namespace {
-
-#if defined(_LIBCPP_FILESYSTEM_USE_SENDFILE)
-  bool copy_file_impl(FileDescriptor& read_fd, FileDescriptor& write_fd, error_code& ec) {
-    size_t count = read_fd.get_stat().st_size;
-    do {
-      ssize_t res;
-      if ((res = ::sendfile(write_fd.fd, read_fd.fd, nullptr, count)) == -1) {
-        ec = capture_errno();
-        return false;
-      }
-      count -= res;
-    } while (count > 0);
-
-    ec.clear();
-
-    return true;
-  }
-#elif defined(_LIBCPP_FILESYSTEM_USE_COPYFILE)
-  bool copy_file_impl(FileDescriptor& read_fd, FileDescriptor& write_fd, error_code& ec) {
-    struct CopyFileState {
-      copyfile_state_t state;
-      CopyFileState() { state = copyfile_state_alloc(); }
-      ~CopyFileState() { copyfile_state_free(state); }
-
-    private:
-      CopyFileState(CopyFileState const&) = delete;
-      CopyFileState& operator=(CopyFileState const&) = delete;
-    };
-
-    CopyFileState cfs;
-    if (fcopyfile(read_fd.fd, write_fd.fd, cfs.state, COPYFILE_DATA) < 0) {
-      ec = capture_errno();
-      return false;
-    }
-
-    ec.clear();
-    return true;
-  }
-#elif defined(_LIBCPP_FILESYSTEM_USE_FSTREAM)
-  bool copy_file_impl(FileDescriptor& read_fd, FileDescriptor& write_fd, error_code& ec) {
-    ifstream in;
-    in.__open(read_fd.fd, ios::binary);
-    if (!in.is_open()) {
-      // This assumes that __open didn't reset the error code.
-      ec = capture_errno();
-      return false;
-    }
-    read_fd.fd = -1;
-    ofstream out;
-    out.__open(write_fd.fd, ios::binary);
-    if (!out.is_open()) {
-      ec = capture_errno();
-      return false;
-    }
-    write_fd.fd = -1;
-
-    if (in.good() && out.good()) {
-      using InIt = istreambuf_iterator<char>;
-      using OutIt = ostreambuf_iterator<char>;
-      InIt bin(in);
-      InIt ein;
-      OutIt bout(out);
-      copy(bin, ein, bout);
-    }
-    if (out.fail() || in.fail()) {
-      ec = make_error_code(errc::io_error);
-      return false;
-    }
-
-    ec.clear();
-    return true;
-  }
-#else
-# error "Unknown implementation for copy_file_impl"
-#endif // copy_file_impl implementation
-
-} // end anonymous namespace
-} // end namespace detail
-
-bool __copy_file(const path& from, const path& to, copy_options options,
-                 error_code* ec) {
-  using detail::FileDescriptor;
-  ErrorHandler<bool> err("copy_file", ec, &to, &from);
-
-  error_code m_ec;
-  FileDescriptor from_fd = FileDescriptor::create_with_status(
-      &from, m_ec, O_RDONLY | O_NONBLOCK | O_BINARY);
-  if (m_ec)
-    return err.report(m_ec);
-
-  auto from_st = from_fd.get_status();
-  StatT const& from_stat = from_fd.get_stat();
-  if (!is_regular_file(from_st)) {
-    if (not m_ec)
-      m_ec = make_error_code(errc::not_supported);
-    return err.report(m_ec);
-  }
-
-  const bool skip_existing = bool(copy_options::skip_existing & options);
-  const bool update_existing = bool(copy_options::update_existing & options);
-  const bool overwrite_existing =
-      bool(copy_options::overwrite_existing & options);
-
-  StatT to_stat_path;
-  file_status to_st = detail::posix_stat(to, to_stat_path, &m_ec);
-  if (!status_known(to_st))
-    return err.report(m_ec);
-
-  const bool to_exists = exists(to_st);
-  if (to_exists && !is_regular_file(to_st))
-    return err.report(errc::not_supported);
-
-  if (to_exists && detail::stat_equivalent(from_stat, to_stat_path))
-    return err.report(errc::file_exists);
-
-  if (to_exists && skip_existing)
-    return false;
-
-  bool ShouldCopy = [&]() {
-    if (to_exists && update_existing) {
-      auto from_time = detail::extract_mtime(from_stat);
-      auto to_time = detail::extract_mtime(to_stat_path);
-      if (from_time.tv_sec < to_time.tv_sec)
-        return false;
-      if (from_time.tv_sec == to_time.tv_sec &&
-          from_time.tv_nsec <= to_time.tv_nsec)
-        return false;
-      return true;
-    }
-    if (!to_exists || overwrite_existing)
-      return true;
-    return err.report(errc::file_exists);
-  }();
-  if (!ShouldCopy)
-    return false;
-
-  // Don't truncate right away. We may not be opening the file we originally
-  // looked at; we'll check this later.
-  int to_open_flags = O_WRONLY | O_BINARY;
-  if (!to_exists)
-    to_open_flags |= O_CREAT;
-  FileDescriptor to_fd = FileDescriptor::create_with_status(
-      &to, m_ec, to_open_flags, from_stat.st_mode);
-  if (m_ec)
-    return err.report(m_ec);
-
-  if (to_exists) {
-    // Check that the file we initially stat'ed is equivalent to the one
-    // we opened.
-    // FIXME: report this better.
-    if (!detail::stat_equivalent(to_stat_path, to_fd.get_stat()))
-      return err.report(errc::bad_file_descriptor);
-
-    // Set the permissions and truncate the file we opened.
-    if (detail::posix_fchmod(to_fd, from_stat, m_ec))
-      return err.report(m_ec);
-    if (detail::posix_ftruncate(to_fd, 0, m_ec))
-      return err.report(m_ec);
-  }
-
-  if (!copy_file_impl(from_fd, to_fd, m_ec)) {
-    // FIXME: Remove the dest file if we failed, and it didn't exist previously.
-    return err.report(m_ec);
-  }
-
-  return true;
-}
-
-void __copy_symlink(const path& existing_symlink, const path& new_symlink,
-                    error_code* ec) {
-  const path real_path(__read_symlink(existing_symlink, ec));
-  if (ec && *ec) {
-    return;
-  }
-#if defined(_LIBCPP_WIN32API)
-  error_code local_ec;
-  if (is_directory(real_path, local_ec))
-    __create_directory_symlink(real_path, new_symlink, ec);
-  else
-#endif
-    __create_symlink(real_path, new_symlink, ec);
-}
-
-bool __create_directories(const path& p, error_code* ec) {
-  ErrorHandler<bool> err("create_directories", ec, &p);
-
-  error_code m_ec;
-  auto const st = detail::posix_stat(p, &m_ec);
-  if (!status_known(st))
-    return err.report(m_ec);
-  else if (is_directory(st))
-    return false;
-  else if (exists(st))
-    return err.report(errc::file_exists);
-
-  const path parent = p.parent_path();
-  if (!parent.empty()) {
-    const file_status parent_st = status(parent, m_ec);
-    if (not status_known(parent_st))
-      return err.report(m_ec);
-    if (not exists(parent_st)) {
-      if (parent == p)
-        return err.report(errc::invalid_argument);
-      __create_directories(parent, ec);
-      if (ec && *ec) {
-        return false;
-      }
-    } else if (not is_directory(parent_st))
-      return err.report(errc::not_a_directory);
-  }
-  bool ret = __create_directory(p, &m_ec);
-  if (m_ec)
-    return err.report(m_ec);
-  return ret;
-}
-
-bool __create_directory(const path& p, error_code* ec) {
-  ErrorHandler<bool> err("create_directory", ec, &p);
-
-  if (detail::mkdir(p.c_str(), static_cast<int>(perms::all)) == 0)
-    return true;
-
-  if (errno != EEXIST)
-    return err.report(capture_errno());
-  error_code mec = capture_errno();
-  error_code ignored_ec;
-  const file_status st = status(p, ignored_ec);
-  if (!is_directory(st))
-    return err.report(mec);
-  return false;
-}
-
-bool __create_directory(path const& p, path const& attributes, error_code* ec) {
-  ErrorHandler<bool> err("create_directory", ec, &p, &attributes);
-
-  StatT attr_stat;
-  error_code mec;
-  file_status st = detail::posix_stat(attributes, attr_stat, &mec);
-  if (!status_known(st))
-    return err.report(mec);
-  if (!is_directory(st))
-    return err.report(errc::not_a_directory,
-                      "the specified attribute path is invalid");
-
-  if (detail::mkdir(p.c_str(), attr_stat.st_mode) == 0)
-    return true;
-
-  if (errno != EEXIST)
-    return err.report(capture_errno());
-
-  mec = capture_errno();
-  error_code ignored_ec;
-  st = status(p, ignored_ec);
-  if (!is_directory(st))
-    return err.report(mec);
-  return false;
-}
-
-void __create_directory_symlink(path const& from, path const& to,
-                                error_code* ec) {
-  ErrorHandler<void> err("create_directory_symlink", ec, &from, &to);
-  if (detail::symlink_dir(from.c_str(), to.c_str()) == -1)
-    return err.report(capture_errno());
-}
-
-void __create_hard_link(const path& from, const path& to, error_code* ec) {
-  ErrorHandler<void> err("create_hard_link", ec, &from, &to);
-  if (detail::link(from.c_str(), to.c_str()) == -1)
-    return err.report(capture_errno());
-}
-
-void __create_symlink(path const& from, path const& to, error_code* ec) {
-  ErrorHandler<void> err("create_symlink", ec, &from, &to);
-  if (detail::symlink_file(from.c_str(), to.c_str()) == -1)
-    return err.report(capture_errno());
-}
-
-path __current_path(error_code* ec) {
-  ErrorHandler<path> err("current_path", ec);
-
-#if defined(_LIBCPP_WIN32API) || defined(__GLIBC__) || defined(__APPLE__)
-  // Common extension outside of POSIX getcwd() spec, without needing to
-  // preallocate a buffer. Also supported by a number of other POSIX libcs.
-  int size = 0;
-  path::value_type* ptr = nullptr;
-  typedef decltype(&::free) Deleter;
-  Deleter deleter = &::free;
-#else
-  auto size = ::pathconf(".", _PC_PATH_MAX);
-  _LIBCPP_ASSERT(size >= 0, "pathconf returned a 0 as max size");
-
-  auto buff = unique_ptr<path::value_type[]>(new path::value_type[size + 1]);
-  path::value_type* ptr = buff.get();
-
-  // Preallocated buffer, don't free the buffer in the second unique_ptr
-  // below.
-  struct Deleter { void operator()(void*) const {} };
-  Deleter deleter;
-#endif
-
-  unique_ptr<path::value_type, Deleter> hold(detail::getcwd(ptr, size),
-                                             deleter);
-  if (hold.get() == nullptr)
-    return err.report(capture_errno(), "call to getcwd failed");
-
-  return {hold.get()};
-}
-
-void __current_path(const path& p, error_code* ec) {
-  ErrorHandler<void> err("current_path", ec, &p);
-  if (detail::chdir(p.c_str()) == -1)
-    err.report(capture_errno());
-}
-
-bool __equivalent(const path& p1, const path& p2, error_code* ec) {
-  ErrorHandler<bool> err("equivalent", ec, &p1, &p2);
-
-  error_code ec1, ec2;
-  StatT st1 = {}, st2 = {};
-  auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
-  if (!exists(s1))
-    return err.report(errc::not_supported);
-  auto s2 = detail::posix_stat(p2.native(), st2, &ec2);
-  if (!exists(s2))
-    return err.report(errc::not_supported);
-
-  return detail::stat_equivalent(st1, st2);
-}
-
-uintmax_t __file_size(const path& p, error_code* ec) {
-  ErrorHandler<uintmax_t> err("file_size", ec, &p);
-
-  error_code m_ec;
-  StatT st;
-  file_status fst = detail::posix_stat(p, st, &m_ec);
-  if (!exists(fst) || !is_regular_file(fst)) {
-    errc error_kind =
-        is_directory(fst) ? errc::is_a_directory : errc::not_supported;
-    if (!m_ec)
-      m_ec = make_error_code(error_kind);
-    return err.report(m_ec);
-  }
-  // is_regular_file(p) == true
-  return static_cast<uintmax_t>(st.st_size);
-}
-
-uintmax_t __hard_link_count(const path& p, error_code* ec) {
-  ErrorHandler<uintmax_t> err("hard_link_count", ec, &p);
-
-  error_code m_ec;
-  StatT st;
-  detail::posix_stat(p, st, &m_ec);
-  if (m_ec)
-    return err.report(m_ec);
-  return static_cast<uintmax_t>(st.st_nlink);
-}
-
-bool __fs_is_empty(const path& p, error_code* ec) {
-  ErrorHandler<bool> err("is_empty", ec, &p);
-
-  error_code m_ec;
-  StatT pst;
-  auto st = detail::posix_stat(p, pst, &m_ec);
-  if (m_ec)
-    return err.report(m_ec);
-  else if (!is_directory(st) && !is_regular_file(st))
-    return err.report(errc::not_supported);
-  else if (is_directory(st)) {
-    auto it = ec ? directory_iterator(p, *ec) : directory_iterator(p);
-    if (ec && *ec)
-      return false;
-    return it == directory_iterator{};
-  } else if (is_regular_file(st))
-    return static_cast<uintmax_t>(pst.st_size) == 0;
-
-  __libcpp_unreachable();
-}
-
-static file_time_type __extract_last_write_time(const path& p, const StatT& st,
-                                                error_code* ec) {
-  using detail::fs_time;
-  ErrorHandler<file_time_type> err("last_write_time", ec, &p);
-
-  auto ts = detail::extract_mtime(st);
-  if (!fs_time::is_representable(ts))
-    return err.report(errc::value_too_large);
-
-  return fs_time::convert_from_timespec(ts);
-}
-
-file_time_type __last_write_time(const path& p, error_code* ec) {
-  using namespace chrono;
-  ErrorHandler<file_time_type> err("last_write_time", ec, &p);
-
-  error_code m_ec;
-  StatT st;
-  detail::posix_stat(p, st, &m_ec);
-  if (m_ec)
-    return err.report(m_ec);
-  return __extract_last_write_time(p, st, ec);
-}
-
-void __last_write_time(const path& p, file_time_type new_time, error_code* ec) {
-  using detail::fs_time;
-  ErrorHandler<void> err("last_write_time", ec, &p);
-
-#if defined(_LIBCPP_WIN32API)
-  TimeSpec ts;
-  if (!fs_time::convert_to_timespec(ts, new_time))
-    return err.report(errc::value_too_large);
-  detail::WinHandle h(p.c_str(), FILE_WRITE_ATTRIBUTES, 0);
-  if (!h)
-    return err.report(detail::make_windows_error(GetLastError()));
-  FILETIME last_write = timespec_to_filetime(ts);
-  if (!SetFileTime(h, nullptr, nullptr, &last_write))
-    return err.report(detail::make_windows_error(GetLastError()));
-#else
-  error_code m_ec;
-  array<TimeSpec, 2> tbuf;
-#if !defined(_LIBCPP_USE_UTIMENSAT)
-  // This implementation has a race condition between determining the
-  // last access time and attempting to set it to the same value using
-  // ::utimes
-  StatT st;
-  file_status fst = detail::posix_stat(p, st, &m_ec);
-  if (m_ec)
-    return err.report(m_ec);
-  tbuf[0] = detail::extract_atime(st);
-#else
-  tbuf[0].tv_sec = 0;
-  tbuf[0].tv_nsec = UTIME_OMIT;
-#endif
-  if (!fs_time::convert_to_timespec(tbuf[1], new_time))
-    return err.report(errc::value_too_large);
-
-  detail::set_file_times(p, tbuf, m_ec);
-  if (m_ec)
-    return err.report(m_ec);
-#endif
-}
-
-void __permissions(const path& p, perms prms, perm_options opts,
-                   error_code* ec) {
-  ErrorHandler<void> err("permissions", ec, &p);
-
-  auto has_opt = [&](perm_options o) { return bool(o & opts); };
-  const bool resolve_symlinks = !has_opt(perm_options::nofollow);
-  const bool add_perms = has_opt(perm_options::add);
-  const bool remove_perms = has_opt(perm_options::remove);
-  _LIBCPP_ASSERT(
-      (add_perms + remove_perms + has_opt(perm_options::replace)) == 1,
-      "One and only one of the perm_options constants replace, add, or remove "
-      "is present in opts");
-
-  bool set_sym_perms = false;
-  prms &= perms::mask;
-  if (!resolve_symlinks || (add_perms || remove_perms)) {
-    error_code m_ec;
-    file_status st = resolve_symlinks ? detail::posix_stat(p, &m_ec)
-                                      : detail::posix_lstat(p, &m_ec);
-    set_sym_perms = is_symlink(st);
-    if (m_ec)
-      return err.report(m_ec);
-    _LIBCPP_ASSERT(st.permissions() != perms::unknown,
-                   "Permissions unexpectedly unknown");
-    if (add_perms)
-      prms |= st.permissions();
-    else if (remove_perms)
-      prms = st.permissions() & ~prms;
-  }
-  const auto real_perms = static_cast<detail::ModeT>(prms & perms::mask);
-
-#if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
-  const int flags = set_sym_perms ? AT_SYMLINK_NOFOLLOW : 0;
-  if (detail::fchmodat(AT_FDCWD, p.c_str(), real_perms, flags) == -1) {
-    return err.report(capture_errno());
-  }
-#else
-  if (set_sym_perms)
-    return err.report(errc::operation_not_supported);
-  if (::chmod(p.c_str(), real_perms) == -1) {
-    return err.report(capture_errno());
-  }
-#endif
-}
-
-path __read_symlink(const path& p, error_code* ec) {
-  ErrorHandler<path> err("read_symlink", ec, &p);
-
-#if defined(PATH_MAX) || defined(MAX_SYMLINK_SIZE)
-  struct NullDeleter { void operator()(void*) const {} };
-#ifdef MAX_SYMLINK_SIZE
-  const size_t size = MAX_SYMLINK_SIZE + 1;
-#else
-  const size_t size = PATH_MAX + 1;
-#endif
-  path::value_type stack_buff[size];
-  auto buff = std::unique_ptr<path::value_type[], NullDeleter>(stack_buff);
-#else
-  StatT sb;
-  if (detail::lstat(p.c_str(), &sb) == -1) {
-    return err.report(capture_errno());
-  }
-  const size_t size = sb.st_size + 1;
-  auto buff = unique_ptr<path::value_type[]>(new path::value_type[size]);
-#endif
-  detail::SSizeT ret;
-  if ((ret = detail::readlink(p.c_str(), buff.get(), size)) == -1)
-    return err.report(capture_errno());
-  _LIBCPP_ASSERT(ret > 0, "TODO");
-  if (static_cast<size_t>(ret) >= size)
-    return err.report(errc::value_too_large);
-  buff[ret] = 0;
-  return {buff.get()};
-}
-
-bool __remove(const path& p, error_code* ec) {
-  ErrorHandler<bool> err("remove", ec, &p);
-  if (detail::remove(p.c_str()) == -1) {
-    if (errno != ENOENT)
-      err.report(capture_errno());
-    return false;
-  }
-  return true;
-}
-
-// We currently have two implementations of `__remove_all`. The first one is general and
-// used on platforms where we don't have access to the `openat()` family of POSIX functions.
-// That implementation uses `directory_iterator`, however it is vulnerable to some race
-// conditions, see https://reviews.llvm.org/D118134 for details.
-//
-// The second implementation is used on platforms where `openat()` & friends are available,
-// and it threads file descriptors through recursive calls to avoid such race conditions.
-#if defined(_LIBCPP_WIN32API) || defined (__MVS__)
-# define REMOVE_ALL_USE_DIRECTORY_ITERATOR
-#endif
-
-#if defined(REMOVE_ALL_USE_DIRECTORY_ITERATOR)
-
-namespace {
-
-uintmax_t remove_all_impl(path const& p, error_code& ec) {
-  const auto npos = static_cast<uintmax_t>(-1);
-  const file_status st = __symlink_status(p, &ec);
-  if (ec)
-    return npos;
-  uintmax_t count = 1;
-  if (is_directory(st)) {
-    for (directory_iterator it(p, ec); !ec && it != directory_iterator();
-         it.increment(ec)) {
-      auto other_count = remove_all_impl(it->path(), ec);
-      if (ec)
-        return npos;
-      count += other_count;
-    }
-    if (ec)
-      return npos;
-  }
-  if (!__remove(p, &ec))
-    return npos;
-  return count;
-}
-
-} // end namespace
-
-uintmax_t __remove_all(const path& p, error_code* ec) {
-  ErrorHandler<uintmax_t> err("remove_all", ec, &p);
-
-  error_code mec;
-  auto count = remove_all_impl(p, mec);
-  if (mec) {
-    if (mec == errc::no_such_file_or_directory)
-      return 0;
-    return err.report(mec);
-  }
-  return count;
-}
-
-#else // !REMOVE_ALL_USE_DIRECTORY_ITERATOR
-
-namespace {
-
-template <class Cleanup>
-struct scope_exit {
-  explicit scope_exit(Cleanup const& cleanup)
-    : cleanup_(cleanup)
-  { }
-
-  ~scope_exit() { cleanup_(); }
-
-private:
-  Cleanup cleanup_;
-};
-_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scope_exit);
-
-uintmax_t remove_all_impl(int parent_directory, const path& p, error_code& ec) {
-  // First, try to open the path as a directory.
-  const int options = O_CLOEXEC | O_RDONLY | O_DIRECTORY | O_NOFOLLOW;
-  int fd = ::openat(parent_directory, p.c_str(), options);
-  if (fd != -1) {
-    // If that worked, iterate over the contents of the directory and
-    // remove everything in it, recursively.
-    DIR* stream = ::fdopendir(fd);
-    if (stream == nullptr) {
-      ::close(fd);
-      ec = detail::capture_errno();
-      return 0;
-    }
-    // Note: `::closedir` will also close the associated file descriptor, so
-    // there should be no call to `close(fd)`.
-    scope_exit close_stream([=] { ::closedir(stream); });
-
-    uintmax_t count = 0;
-    while (true) {
-      auto [str, type] = detail::posix_readdir(stream, ec);
-      static_assert(std::is_same_v<decltype(str), std::string_view>);
-      if (str == "." || str == "..") {
-        continue;
-      } else if (ec || str.empty()) {
-        break; // we're done iterating through the directory
-      } else {
-        count += remove_all_impl(fd, str, ec);
-      }
-    }
-
-    // Then, remove the now-empty directory itself.
-    if (::unlinkat(parent_directory, p.c_str(), AT_REMOVEDIR) == -1) {
-      ec = detail::capture_errno();
-      return count;
-    }
-
-    return count + 1; // the contents of the directory + the directory itself
-  }
-
-  ec = detail::capture_errno();
-
-  // If we failed to open `p` because it didn't exist, it's not an
-  // error -- it might have moved or have been deleted already.
-  if (ec == errc::no_such_file_or_directory) {
-    ec.clear();
-    return 0;
-  }
-
-  // If opening `p` failed because it wasn't a directory, remove it as
-  // a normal file instead. Note that `openat()` can return either ENOTDIR
-  // or ELOOP depending on the exact reason of the failure.
-  if (ec == errc::not_a_directory || ec == errc::too_many_symbolic_link_levels) {
-    ec.clear();
-    if (::unlinkat(parent_directory, p.c_str(), /* flags = */0) == -1) {
-      ec = detail::capture_errno();
-      return 0;
-    }
-    return 1;
-  }
-
-  // Otherwise, it's a real error -- we don't remove anything.
-  return 0;
-}
-
-} // end namespace
-
-uintmax_t __remove_all(const path& p, error_code* ec) {
-  ErrorHandler<uintmax_t> err("remove_all", ec, &p);
-  error_code mec;
-  uintmax_t count = remove_all_impl(AT_FDCWD, p, mec);
-  if (mec)
-    return err.report(mec);
-  return count;
-}
-
-#endif // REMOVE_ALL_USE_DIRECTORY_ITERATOR
-
-void __rename(const path& from, const path& to, error_code* ec) {
-  ErrorHandler<void> err("rename", ec, &from, &to);
-  if (detail::rename(from.c_str(), to.c_str()) == -1)
-    err.report(capture_errno());
-}
-
-void __resize_file(const path& p, uintmax_t size, error_code* ec) {
-  ErrorHandler<void> err("resize_file", ec, &p);
-  if (detail::truncate(p.c_str(), static_cast< ::off_t>(size)) == -1)
-    return err.report(capture_errno());
-}
-
-space_info __space(const path& p, error_code* ec) {
-  ErrorHandler<void> err("space", ec, &p);
-  space_info si;
-  detail::StatVFS m_svfs = {};
-  if (detail::statvfs(p.c_str(), &m_svfs) == -1) {
-    err.report(capture_errno());
-    si.capacity = si.free = si.available = static_cast<uintmax_t>(-1);
-    return si;
-  }
-  // Multiply with overflow checking.
-  auto do_mult = [&](uintmax_t& out, uintmax_t other) {
-    out = other * m_svfs.f_frsize;
-    if (other == 0 || out / other != m_svfs.f_frsize)
-      out = static_cast<uintmax_t>(-1);
-  };
-  do_mult(si.capacity, m_svfs.f_blocks);
-  do_mult(si.free, m_svfs.f_bfree);
-  do_mult(si.available, m_svfs.f_bavail);
-  return si;
-}
-
-file_status __status(const path& p, error_code* ec) {
-  return detail::posix_stat(p, ec);
-}
-
-file_status __symlink_status(const path& p, error_code* ec) {
-  return detail::posix_lstat(p, ec);
-}
-
-path __temp_directory_path(error_code* ec) {
-  ErrorHandler<path> err("temp_directory_path", ec);
-
-#if defined(_LIBCPP_WIN32API)
-  wchar_t buf[MAX_PATH];
-  DWORD retval = GetTempPathW(MAX_PATH, buf);
-  if (!retval)
-    return err.report(detail::make_windows_error(GetLastError()));
-  if (retval > MAX_PATH)
-    return err.report(errc::filename_too_long);
-  // GetTempPathW returns a path with a trailing slash, which we
-  // shouldn't include for consistency.
-  if (buf[retval-1] == L'\\')
-    buf[retval-1] = L'\0';
-  path p(buf);
-#else
-  const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
-  const char* ret = nullptr;
-
-  for (auto& ep : env_paths)
-    if ((ret = getenv(ep)))
-      break;
-  if (ret == nullptr)
-    ret = "/tmp";
-
-  path p(ret);
-#endif
-  error_code m_ec;
-  file_status st = detail::posix_stat(p, &m_ec);
-  if (!status_known(st))
-    return err.report(m_ec, "cannot access path " PATH_CSTR_FMT, p.c_str());
-
-  if (!exists(st) || !is_directory(st))
-    return err.report(errc::not_a_directory,
-                      "path " PATH_CSTR_FMT " is not a directory", p.c_str());
-
-  return p;
-}
-
-path __weakly_canonical(const path& p, error_code* ec) {
-  ErrorHandler<path> err("weakly_canonical", ec, &p);
-
-  if (p.empty())
-    return __canonical("", ec);
-
-  path result;
-  path tmp;
-  tmp.__reserve(p.native().size());
-  auto PP = PathParser::CreateEnd(p.native());
-  --PP;
-  vector<string_view_t> DNEParts;
-
-  while (PP.State != PathParser::PS_BeforeBegin) {
-    tmp.assign(createView(p.native().data(), &PP.RawEntry.back()));
-    error_code m_ec;
-    file_status st = __status(tmp, &m_ec);
-    if (!status_known(st)) {
-      return err.report(m_ec);
-    } else if (exists(st)) {
-      result = __canonical(tmp, ec);
-      break;
-    }
-    DNEParts.push_back(*PP);
-    --PP;
-  }
-  if (PP.State == PathParser::PS_BeforeBegin)
-    result = __canonical("", ec);
-  if (ec)
-    ec->clear();
-  if (DNEParts.empty())
-    return result;
-  for (auto It = DNEParts.rbegin(); It != DNEParts.rend(); ++It)
-    result /= *It;
-  return result.lexically_normal();
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//                            path definitions
-///////////////////////////////////////////////////////////////////////////////
-
-constexpr path::value_type path::preferred_separator;
-
-path& path::replace_extension(path const& replacement) {
-  path p = extension();
-  if (not p.empty()) {
-    __pn_.erase(__pn_.size() - p.native().size());
-  }
-  if (!replacement.empty()) {
-    if (replacement.native()[0] != '.') {
-      __pn_ += PATHSTR(".");
-    }
-    __pn_.append(replacement.__pn_);
-  }
-  return *this;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// path.decompose
-
-string_view_t path::__root_name() const {
-  auto PP = PathParser::CreateBegin(__pn_);
-  if (PP.State == PathParser::PS_InRootName)
-    return *PP;
-  return {};
-}
-
-string_view_t path::__root_directory() const {
-  auto PP = PathParser::CreateBegin(__pn_);
-  if (PP.State == PathParser::PS_InRootName)
-    ++PP;
-  if (PP.State == PathParser::PS_InRootDir)
-    return *PP;
-  return {};
-}
-
-string_view_t path::__root_path_raw() const {
-  auto PP = PathParser::CreateBegin(__pn_);
-  if (PP.State == PathParser::PS_InRootName) {
-    auto NextCh = PP.peek();
-    if (NextCh && isSeparator(*NextCh)) {
-      ++PP;
-      return createView(__pn_.data(), &PP.RawEntry.back());
-    }
-    return PP.RawEntry;
-  }
-  if (PP.State == PathParser::PS_InRootDir)
-    return *PP;
-  return {};
-}
-
-static bool ConsumeRootName(PathParser *PP) {
-  static_assert(PathParser::PS_BeforeBegin == 1 &&
-      PathParser::PS_InRootName == 2,
-      "Values for enums are incorrect");
-  while (PP->State <= PathParser::PS_InRootName)
-    ++(*PP);
-  return PP->State == PathParser::PS_AtEnd;
-}
-
-static bool ConsumeRootDir(PathParser* PP) {
-  static_assert(PathParser::PS_BeforeBegin == 1 &&
-                PathParser::PS_InRootName == 2 &&
-                PathParser::PS_InRootDir == 3, "Values for enums are incorrect");
-  while (PP->State <= PathParser::PS_InRootDir)
-    ++(*PP);
-  return PP->State == PathParser::PS_AtEnd;
-}
-
-string_view_t path::__relative_path() const {
-  auto PP = PathParser::CreateBegin(__pn_);
-  if (ConsumeRootDir(&PP))
-    return {};
-  return createView(PP.RawEntry.data(), &__pn_.back());
-}
-
-string_view_t path::__parent_path() const {
-  if (empty())
-    return {};
-  // Determine if we have a root path but not a relative path. In that case
-  // return *this.
-  {
-    auto PP = PathParser::CreateBegin(__pn_);
-    if (ConsumeRootDir(&PP))
-      return __pn_;
-  }
-  // Otherwise remove a single element from the end of the path, and return
-  // a string representing that path
-  {
-    auto PP = PathParser::CreateEnd(__pn_);
-    --PP;
-    if (PP.RawEntry.data() == __pn_.data())
-      return {};
-    --PP;
-    return createView(__pn_.data(), &PP.RawEntry.back());
-  }
-}
-
-string_view_t path::__filename() const {
-  if (empty())
-    return {};
-  {
-    PathParser PP = PathParser::CreateBegin(__pn_);
-    if (ConsumeRootDir(&PP))
-      return {};
-  }
-  return *(--PathParser::CreateEnd(__pn_));
-}
-
-string_view_t path::__stem() const {
-  return parser::separate_filename(__filename()).first;
-}
-
-string_view_t path::__extension() const {
-  return parser::separate_filename(__filename()).second;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// path.gen
-
-enum PathPartKind : unsigned char {
-  PK_None,
-  PK_RootSep,
-  PK_Filename,
-  PK_Dot,
-  PK_DotDot,
-  PK_TrailingSep
-};
-
-static PathPartKind ClassifyPathPart(string_view_t Part) {
-  if (Part.empty())
-    return PK_TrailingSep;
-  if (Part == PATHSTR("."))
-    return PK_Dot;
-  if (Part == PATHSTR(".."))
-    return PK_DotDot;
-  if (Part == PATHSTR("/"))
-    return PK_RootSep;
-#if defined(_LIBCPP_WIN32API)
-  if (Part == PATHSTR("\\"))
-    return PK_RootSep;
-#endif
-  return PK_Filename;
-}
-
-path path::lexically_normal() const {
-  if (__pn_.empty())
-    return *this;
-
-  using PartKindPair = pair<string_view_t, PathPartKind>;
-  vector<PartKindPair> Parts;
-  // Guess as to how many elements the path has to avoid reallocating.
-  Parts.reserve(32);
-
-  // Track the total size of the parts as we collect them. This allows the
-  // resulting path to reserve the correct amount of memory.
-  size_t NewPathSize = 0;
-  auto AddPart = [&](PathPartKind K, string_view_t P) {
-    NewPathSize += P.size();
-    Parts.emplace_back(P, K);
-  };
-  auto LastPartKind = [&]() {
-    if (Parts.empty())
-      return PK_None;
-    return Parts.back().second;
-  };
-
-  bool MaybeNeedTrailingSep = false;
-  // Build a stack containing the remaining elements of the path, popping off
-  // elements which occur before a '..' entry.
-  for (auto PP = PathParser::CreateBegin(__pn_); PP; ++PP) {
-    auto Part = *PP;
-    PathPartKind Kind = ClassifyPathPart(Part);
-    switch (Kind) {
-    case PK_Filename:
-    case PK_RootSep: {
-      // Add all non-dot and non-dot-dot elements to the stack of elements.
-      AddPart(Kind, Part);
-      MaybeNeedTrailingSep = false;
-      break;
-    }
-    case PK_DotDot: {
-      // Only push a ".." element if there are no elements preceding the "..",
-      // or if the preceding element is itself "..".
-      auto LastKind = LastPartKind();
-      if (LastKind == PK_Filename) {
-        NewPathSize -= Parts.back().first.size();
-        Parts.pop_back();
-      } else if (LastKind != PK_RootSep)
-        AddPart(PK_DotDot, PATHSTR(".."));
-      MaybeNeedTrailingSep = LastKind == PK_Filename;
-      break;
-    }
-    case PK_Dot:
-    case PK_TrailingSep: {
-      MaybeNeedTrailingSep = true;
-      break;
-    }
-    case PK_None:
-      __libcpp_unreachable();
-    }
-  }
-  // [fs.path.generic]p6.8: If the path is empty, add a dot.
-  if (Parts.empty())
-    return PATHSTR(".");
-
-  // [fs.path.generic]p6.7: If the last filename is dot-dot, remove any
-  // trailing directory-separator.
-  bool NeedTrailingSep = MaybeNeedTrailingSep && LastPartKind() == PK_Filename;
-
-  path Result;
-  Result.__pn_.reserve(Parts.size() + NewPathSize + NeedTrailingSep);
-  for (auto& PK : Parts)
-    Result /= PK.first;
-
-  if (NeedTrailingSep)
-    Result /= PATHSTR("");
-
-  Result.make_preferred();
-  return Result;
-}
-
-static int DetermineLexicalElementCount(PathParser PP) {
-  int Count = 0;
-  for (; PP; ++PP) {
-    auto Elem = *PP;
-    if (Elem == PATHSTR(".."))
-      --Count;
-    else if (Elem != PATHSTR(".") && Elem != PATHSTR(""))
-      ++Count;
-  }
-  return Count;
-}
-
-path path::lexically_relative(const path& base) const {
-  { // perform root-name/root-directory mismatch checks
-    auto PP = PathParser::CreateBegin(__pn_);
-    auto PPBase = PathParser::CreateBegin(base.__pn_);
-    auto CheckIterMismatchAtBase = [&]() {
-      return PP.State != PPBase.State &&
-             (PP.inRootPath() || PPBase.inRootPath());
-    };
-    if (PP.inRootName() && PPBase.inRootName()) {
-      if (*PP != *PPBase)
-        return {};
-    } else if (CheckIterMismatchAtBase())
-      return {};
-
-    if (PP.inRootPath())
-      ++PP;
-    if (PPBase.inRootPath())
-      ++PPBase;
-    if (CheckIterMismatchAtBase())
-      return {};
-  }
-
-  // Find the first mismatching element
-  auto PP = PathParser::CreateBegin(__pn_);
-  auto PPBase = PathParser::CreateBegin(base.__pn_);
-  while (PP && PPBase && PP.State == PPBase.State && *PP == *PPBase) {
-    ++PP;
-    ++PPBase;
-  }
-
-  // If there is no mismatch, return ".".
-  if (!PP && !PPBase)
-    return ".";
-
-  // Otherwise, determine the number of elements, 'n', which are not dot or
-  // dot-dot minus the number of dot-dot elements.
-  int ElemCount = DetermineLexicalElementCount(PPBase);
-  if (ElemCount < 0)
-    return {};
-
-  // if n == 0 and (a == end() || a->empty()), returns path("."); otherwise
-  if (ElemCount == 0 && (PP.atEnd() || *PP == PATHSTR("")))
-    return PATHSTR(".");
-
-  // return a path constructed with 'n' dot-dot elements, followed by the
-  // elements of '*this' after the mismatch.
-  path Result;
-  // FIXME: Reserve enough room in Result that it won't have to re-allocate.
-  while (ElemCount--)
-    Result /= PATHSTR("..");
-  for (; PP; ++PP)
-    Result /= *PP;
-  return Result;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// path.comparisons
-static int CompareRootName(PathParser *LHS, PathParser *RHS) {
-  if (!LHS->inRootName() && !RHS->inRootName())
-    return 0;
-
-  auto GetRootName = [](PathParser *Parser) -> string_view_t {
-    return Parser->inRootName() ? **Parser : PATHSTR("");
-  };
-  int res = GetRootName(LHS).compare(GetRootName(RHS));
-  ConsumeRootName(LHS);
-  ConsumeRootName(RHS);
-  return res;
-}
-
-static int CompareRootDir(PathParser *LHS, PathParser *RHS) {
-  if (!LHS->inRootDir() && RHS->inRootDir())
-    return -1;
-  else if (LHS->inRootDir() && !RHS->inRootDir())
-    return 1;
-  else {
-    ConsumeRootDir(LHS);
-    ConsumeRootDir(RHS);
-    return 0;
-  }
-}
-
-static int CompareRelative(PathParser *LHSPtr, PathParser *RHSPtr) {
-  auto &LHS = *LHSPtr;
-  auto &RHS = *RHSPtr;
-
-  int res;
-  while (LHS && RHS) {
-    if ((res = (*LHS).compare(*RHS)) != 0)
-      return res;
-    ++LHS;
-    ++RHS;
-  }
-  return 0;
-}
-
-static int CompareEndState(PathParser *LHS, PathParser *RHS) {
-  if (LHS->atEnd() && !RHS->atEnd())
-    return -1;
-  else if (!LHS->atEnd() && RHS->atEnd())
-    return 1;
-  return 0;
-}
-
-int path::__compare(string_view_t __s) const {
-  auto LHS = PathParser::CreateBegin(__pn_);
-  auto RHS = PathParser::CreateBegin(__s);
-  int res;
-
-  if ((res = CompareRootName(&LHS, &RHS)) != 0)
-    return res;
-
-  if ((res = CompareRootDir(&LHS, &RHS)) != 0)
-    return res;
-
-  if ((res = CompareRelative(&LHS, &RHS)) != 0)
-    return res;
-
-  return CompareEndState(&LHS, &RHS);
-}
-
-////////////////////////////////////////////////////////////////////////////
-// path.nonmembers
-size_t hash_value(const path& __p) noexcept {
-  auto PP = PathParser::CreateBegin(__p.native());
-  size_t hash_value = 0;
-  hash<string_view_t> hasher;
-  while (PP) {
-    hash_value = __hash_combine(hash_value, hasher(*PP));
-    ++PP;
-  }
-  return hash_value;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// path.itr
-path::iterator path::begin() const {
-  auto PP = PathParser::CreateBegin(__pn_);
-  iterator it;
-  it.__path_ptr_ = this;
-  it.__state_ = static_cast<path::iterator::_ParserState>(PP.State);
-  it.__entry_ = PP.RawEntry;
-  it.__stashed_elem_.__assign_view(*PP);
-  return it;
-}
-
-path::iterator path::end() const {
-  iterator it{};
-  it.__state_ = path::iterator::_AtEnd;
-  it.__path_ptr_ = this;
-  return it;
-}
-
-path::iterator& path::iterator::__increment() {
-  PathParser PP(__path_ptr_->native(), __entry_, __state_);
-  ++PP;
-  __state_ = static_cast<_ParserState>(PP.State);
-  __entry_ = PP.RawEntry;
-  __stashed_elem_.__assign_view(*PP);
-  return *this;
-}
-
-path::iterator& path::iterator::__decrement() {
-  PathParser PP(__path_ptr_->native(), __entry_, __state_);
-  --PP;
-  __state_ = static_cast<_ParserState>(PP.State);
-  __entry_ = PP.RawEntry;
-  __stashed_elem_.__assign_view(*PP);
-  return *this;
-}
-
-#if defined(_LIBCPP_WIN32API)
-////////////////////////////////////////////////////////////////////////////
-// Windows path conversions
-size_t __wide_to_char(const wstring &str, char *out, size_t outlen) {
-  if (str.empty())
-    return 0;
-  ErrorHandler<size_t> err("__wide_to_char", nullptr);
-  UINT codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
-  BOOL used_default = FALSE;
-  int ret = WideCharToMultiByte(codepage, 0, str.data(), str.size(), out,
-                                outlen, nullptr, &used_default);
-  if (ret <= 0 || used_default)
-    return err.report(errc::illegal_byte_sequence);
-  return ret;
-}
-
-size_t __char_to_wide(const string &str, wchar_t *out, size_t outlen) {
-  if (str.empty())
-    return 0;
-  ErrorHandler<size_t> err("__char_to_wide", nullptr);
-  UINT codepage = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
-  int ret = MultiByteToWideChar(codepage, MB_ERR_INVALID_CHARS, str.data(),
-                                str.size(), out, outlen);
-  if (ret <= 0)
-    return err.report(errc::illegal_byte_sequence);
-  return ret;
-}
-#endif
-
-
-///////////////////////////////////////////////////////////////////////////////
-//                           directory entry definitions
-///////////////////////////////////////////////////////////////////////////////
-
-error_code directory_entry::__do_refresh() noexcept {
-  __data_.__reset();
-  error_code failure_ec;
-
-  StatT full_st;
-  file_status st = detail::posix_lstat(__p_, full_st, &failure_ec);
-  if (!status_known(st)) {
-    __data_.__reset();
-    return failure_ec;
-  }
-
-  if (!_VSTD_FS::exists(st) || !_VSTD_FS::is_symlink(st)) {
-    __data_.__cache_type_ = directory_entry::_RefreshNonSymlink;
-    __data_.__type_ = st.type();
-    __data_.__non_sym_perms_ = st.permissions();
-  } else { // we have a symlink
-    __data_.__sym_perms_ = st.permissions();
-    // Get the information about the linked entity.
-    // Ignore errors from stat, since we don't want errors regarding symlink
-    // resolution to be reported to the user.
-    error_code ignored_ec;
-    st = detail::posix_stat(__p_, full_st, &ignored_ec);
-
-    __data_.__type_ = st.type();
-    __data_.__non_sym_perms_ = st.permissions();
-
-    // If we failed to resolve the link, then only partially populate the
-    // cache.
-    if (!status_known(st)) {
-      __data_.__cache_type_ = directory_entry::_RefreshSymlinkUnresolved;
-      return error_code{};
-    }
-    // Otherwise, we resolved the link, potentially as not existing.
-    // That's OK.
-    __data_.__cache_type_ = directory_entry::_RefreshSymlink;
-  }
-
-  if (_VSTD_FS::is_regular_file(st))
-    __data_.__size_ = static_cast<uintmax_t>(full_st.st_size);
-
-  if (_VSTD_FS::exists(st)) {
-    __data_.__nlink_ = static_cast<uintmax_t>(full_st.st_nlink);
-
-    // Attempt to extract the mtime, and fail if it's not representable using
-    // file_time_type. For now we ignore the error, as we'll report it when
-    // the value is actually used.
-    error_code ignored_ec;
-    __data_.__write_time_ =
-        __extract_last_write_time(__p_, full_st, &ignored_ec);
-  }
-
-  return failure_ec;
-}
-
-_LIBCPP_END_NAMESPACE_FILESYSTEM
diff --git a/third_party/libcxx/src/filesystem/posix_compat.h b/third_party/libcxx/src/filesystem/posix_compat.h
deleted file mode 100644
index 36116ec5a..000000000
--- a/third_party/libcxx/src/filesystem/posix_compat.h
+++ /dev/null
@@ -1,522 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-//
-// POSIX-like portability helper functions.
-//
-// These generally behave like the proper posix functions, with these
-// exceptions:
-// On Windows, they take paths in wchar_t* form, instead of char* form.
-// The symlink() function is split into two frontends, symlink_file()
-// and symlink_dir().
-//
-// These are provided within an anonymous namespace within the detail
-// namespace - callers need to include this header and call them as
-// detail::function(), regardless of platform.
-//
-
-#ifndef POSIX_COMPAT_H
-#define POSIX_COMPAT_H
-
-#include <__assert>
-#include <filesystem>
-
-#include "filesystem_common.h"
-
-#if defined(_LIBCPP_WIN32API)
-# define WIN32_LEAN_AND_MEAN
-# define NOMINMAX
-# include <windows.h>
-# include <io.h>
-# include <winioctl.h>
-#else
-# include <unistd.h>
-# include <sys/stat.h>
-# include <sys/statvfs.h>
-#endif
-#include <time.h>
-
-#if defined(_LIBCPP_WIN32API)
-// This struct isn't defined in the normal Windows SDK, but only in the
-// Windows Driver Kit.
-struct LIBCPP_REPARSE_DATA_BUFFER {
-  unsigned long  ReparseTag;
-  unsigned short ReparseDataLength;
-  unsigned short Reserved;
-  union {
-    struct {
-      unsigned short SubstituteNameOffset;
-      unsigned short SubstituteNameLength;
-      unsigned short PrintNameOffset;
-      unsigned short PrintNameLength;
-      unsigned long  Flags;
-      wchar_t        PathBuffer[1];
-    } SymbolicLinkReparseBuffer;
-    struct {
-      unsigned short SubstituteNameOffset;
-      unsigned short SubstituteNameLength;
-      unsigned short PrintNameOffset;
-      unsigned short PrintNameLength;
-      wchar_t        PathBuffer[1];
-    } MountPointReparseBuffer;
-    struct {
-      unsigned char DataBuffer[1];
-    } GenericReparseBuffer;
-  };
-};
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
-
-namespace detail {
-namespace {
-
-#if defined(_LIBCPP_WIN32API)
-
-// Various C runtime header sets provide more or less of these. As we
-// provide our own implementation, undef all potential defines from the
-// C runtime headers and provide a complete set of macros of our own.
-
-#undef _S_IFMT
-#undef _S_IFDIR
-#undef _S_IFCHR
-#undef _S_IFIFO
-#undef _S_IFREG
-#undef _S_IFBLK
-#undef _S_IFLNK
-#undef _S_IFSOCK
-
-#define _S_IFMT   0xF000
-#define _S_IFDIR  0x4000
-#define _S_IFCHR  0x2000
-#define _S_IFIFO  0x1000
-#define _S_IFREG  0x8000
-#define _S_IFBLK  0x6000
-#define _S_IFLNK  0xA000
-#define _S_IFSOCK 0xC000
-
-#undef S_ISDIR
-#undef S_ISFIFO
-#undef S_ISCHR
-#undef S_ISREG
-#undef S_ISLNK
-#undef S_ISBLK
-#undef S_ISSOCK
-
-#define S_ISDIR(m)      (((m) & _S_IFMT) == _S_IFDIR)
-#define S_ISCHR(m)      (((m) & _S_IFMT) == _S_IFCHR)
-#define S_ISFIFO(m)     (((m) & _S_IFMT) == _S_IFIFO)
-#define S_ISREG(m)      (((m) & _S_IFMT) == _S_IFREG)
-#define S_ISBLK(m)      (((m) & _S_IFMT) == _S_IFBLK)
-#define S_ISLNK(m)      (((m) & _S_IFMT) == _S_IFLNK)
-#define S_ISSOCK(m)     (((m) & _S_IFMT) == _S_IFSOCK)
-
-#define O_NONBLOCK 0
-
-
-// There were 369 years and 89 leap days from the Windows epoch
-// (1601) to the Unix epoch (1970).
-#define FILE_TIME_OFFSET_SECS (uint64_t(369 * 365 + 89) * (24 * 60 * 60))
-
-TimeSpec filetime_to_timespec(LARGE_INTEGER li) {
-  TimeSpec ret;
-  ret.tv_sec = li.QuadPart / 10000000 - FILE_TIME_OFFSET_SECS;
-  ret.tv_nsec = (li.QuadPart % 10000000) * 100;
-  return ret;
-}
-
-TimeSpec filetime_to_timespec(FILETIME ft) {
-  LARGE_INTEGER li;
-  li.LowPart = ft.dwLowDateTime;
-  li.HighPart = ft.dwHighDateTime;
-  return filetime_to_timespec(li);
-}
-
-FILETIME timespec_to_filetime(TimeSpec ts) {
-  LARGE_INTEGER li;
-  li.QuadPart =
-      ts.tv_nsec / 100 + (ts.tv_sec + FILE_TIME_OFFSET_SECS) * 10000000;
-  FILETIME ft;
-  ft.dwLowDateTime = li.LowPart;
-  ft.dwHighDateTime = li.HighPart;
-  return ft;
-}
-
-int set_errno(int e = GetLastError()) {
-  errno = static_cast<int>(__win_err_to_errc(e));
-  return -1;
-}
-
-class WinHandle {
-public:
-  WinHandle(const wchar_t *p, DWORD access, DWORD flags) {
-    h = CreateFileW(
-        p, access, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-        nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | flags, nullptr);
-  }
-  ~WinHandle() {
-    if (h != INVALID_HANDLE_VALUE)
-      CloseHandle(h);
-  }
-  operator HANDLE() const { return h; }
-  operator bool() const { return h != INVALID_HANDLE_VALUE; }
-
-private:
-  HANDLE h;
-};
-
-int stat_handle(HANDLE h, StatT *buf) {
-  FILE_BASIC_INFO basic;
-  if (!GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic)))
-    return set_errno();
-  memset(buf, 0, sizeof(*buf));
-  buf->st_mtim = filetime_to_timespec(basic.LastWriteTime);
-  buf->st_atim = filetime_to_timespec(basic.LastAccessTime);
-  buf->st_mode = 0555; // Read-only
-  if (!(basic.FileAttributes & FILE_ATTRIBUTE_READONLY))
-    buf->st_mode |= 0222; // Write
-  if (basic.FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
-    buf->st_mode |= _S_IFDIR;
-  } else {
-    buf->st_mode |= _S_IFREG;
-  }
-  if (basic.FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
-    FILE_ATTRIBUTE_TAG_INFO tag;
-    if (!GetFileInformationByHandleEx(h, FileAttributeTagInfo, &tag,
-                                      sizeof(tag)))
-      return set_errno();
-    if (tag.ReparseTag == IO_REPARSE_TAG_SYMLINK)
-      buf->st_mode = (buf->st_mode & ~_S_IFMT) | _S_IFLNK;
-  }
-  FILE_STANDARD_INFO standard;
-  if (!GetFileInformationByHandleEx(h, FileStandardInfo, &standard,
-                                    sizeof(standard)))
-    return set_errno();
-  buf->st_nlink = standard.NumberOfLinks;
-  buf->st_size = standard.EndOfFile.QuadPart;
-  BY_HANDLE_FILE_INFORMATION info;
-  if (!GetFileInformationByHandle(h, &info))
-    return set_errno();
-  buf->st_dev = info.dwVolumeSerialNumber;
-  memcpy(&buf->st_ino.id[0], &info.nFileIndexHigh, 4);
-  memcpy(&buf->st_ino.id[4], &info.nFileIndexLow, 4);
-  return 0;
-}
-
-int stat_file(const wchar_t *path, StatT *buf, DWORD flags) {
-  WinHandle h(path, FILE_READ_ATTRIBUTES, flags);
-  if (!h)
-    return set_errno();
-  int ret = stat_handle(h, buf);
-  return ret;
-}
-
-int stat(const wchar_t *path, StatT *buf) { return stat_file(path, buf, 0); }
-
-int lstat(const wchar_t *path, StatT *buf) {
-  return stat_file(path, buf, FILE_FLAG_OPEN_REPARSE_POINT);
-}
-
-int fstat(int fd, StatT *buf) {
-  HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
-  return stat_handle(h, buf);
-}
-
-int mkdir(const wchar_t *path, int permissions) {
-  (void)permissions;
-  return _wmkdir(path);
-}
-
-int symlink_file_dir(const wchar_t *oldname, const wchar_t *newname,
-                     bool is_dir) {
-  path dest(oldname);
-  dest.make_preferred();
-  oldname = dest.c_str();
-  DWORD flags = is_dir ? SYMBOLIC_LINK_FLAG_DIRECTORY : 0;
-  if (CreateSymbolicLinkW(newname, oldname,
-                          flags | SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE))
-    return 0;
-  int e = GetLastError();
-  if (e != ERROR_INVALID_PARAMETER)
-    return set_errno(e);
-  if (CreateSymbolicLinkW(newname, oldname, flags))
-    return 0;
-  return set_errno();
-}
-
-int symlink_file(const wchar_t *oldname, const wchar_t *newname) {
-  return symlink_file_dir(oldname, newname, false);
-}
-
-int symlink_dir(const wchar_t *oldname, const wchar_t *newname) {
-  return symlink_file_dir(oldname, newname, true);
-}
-
-int link(const wchar_t *oldname, const wchar_t *newname) {
-  if (CreateHardLinkW(newname, oldname, nullptr))
-    return 0;
-  return set_errno();
-}
-
-int remove(const wchar_t *path) {
-  detail::WinHandle h(path, DELETE, FILE_FLAG_OPEN_REPARSE_POINT);
-  if (!h)
-    return set_errno();
-  FILE_DISPOSITION_INFO info;
-  info.DeleteFile = TRUE;
-  if (!SetFileInformationByHandle(h, FileDispositionInfo, &info, sizeof(info)))
-    return set_errno();
-  return 0;
-}
-
-int truncate_handle(HANDLE h, off_t length) {
-  LARGE_INTEGER size_param;
-  size_param.QuadPart = length;
-  if (!SetFilePointerEx(h, size_param, 0, FILE_BEGIN))
-    return set_errno();
-  if (!SetEndOfFile(h))
-    return set_errno();
-  return 0;
-}
-
-int ftruncate(int fd, off_t length) {
-  HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
-  return truncate_handle(h, length);
-}
-
-int truncate(const wchar_t *path, off_t length) {
-  detail::WinHandle h(path, GENERIC_WRITE, 0);
-  if (!h)
-    return set_errno();
-  return truncate_handle(h, length);
-}
-
-int rename(const wchar_t *from, const wchar_t *to) {
-  if (!(MoveFileExW(from, to,
-                    MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING |
-                        MOVEFILE_WRITE_THROUGH)))
-    return set_errno();
-  return 0;
-}
-
-template <class... Args> int open(const wchar_t *filename, Args... args) {
-  return _wopen(filename, args...);
-}
-int close(int fd) { return _close(fd); }
-int chdir(const wchar_t *path) { return _wchdir(path); }
-
-struct StatVFS {
-  uint64_t f_frsize;
-  uint64_t f_blocks;
-  uint64_t f_bfree;
-  uint64_t f_bavail;
-};
-
-int statvfs(const wchar_t *p, StatVFS *buf) {
-  path dir = p;
-  while (true) {
-    error_code local_ec;
-    const file_status st = status(dir, local_ec);
-    if (!exists(st) || is_directory(st))
-      break;
-    path parent = dir.parent_path();
-    if (parent == dir) {
-      errno = ENOENT;
-      return -1;
-    }
-    dir = parent;
-  }
-  ULARGE_INTEGER free_bytes_available_to_caller, total_number_of_bytes,
-      total_number_of_free_bytes;
-  if (!GetDiskFreeSpaceExW(dir.c_str(), &free_bytes_available_to_caller,
-                           &total_number_of_bytes, &total_number_of_free_bytes))
-    return set_errno();
-  buf->f_frsize = 1;
-  buf->f_blocks = total_number_of_bytes.QuadPart;
-  buf->f_bfree = total_number_of_free_bytes.QuadPart;
-  buf->f_bavail = free_bytes_available_to_caller.QuadPart;
-  return 0;
-}
-
-wchar_t *getcwd(wchar_t *buff, size_t size) { return _wgetcwd(buff, size); }
-
-wchar_t *realpath(const wchar_t *path, wchar_t *resolved_name) {
-  // Only expected to be used with us allocating the buffer.
-  _LIBCPP_ASSERT(resolved_name == nullptr,
-                 "Windows realpath() assumes a null resolved_name");
-
-  WinHandle h(path, FILE_READ_ATTRIBUTES, 0);
-  if (!h) {
-    set_errno();
-    return nullptr;
-  }
-  size_t buff_size = MAX_PATH + 10;
-  std::unique_ptr<wchar_t, decltype(&::free)> buff(
-      static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))), &::free);
-  DWORD retval = GetFinalPathNameByHandleW(
-      h, buff.get(), buff_size, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
-  if (retval > buff_size) {
-    buff_size = retval;
-    buff.reset(static_cast<wchar_t *>(malloc(buff_size * sizeof(wchar_t))));
-    retval = GetFinalPathNameByHandleW(h, buff.get(), buff_size,
-                                       FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
-  }
-  if (!retval) {
-    set_errno();
-    return nullptr;
-  }
-  wchar_t *ptr = buff.get();
-  if (!wcsncmp(ptr, L"\\\\?\\", 4)) {
-    if (ptr[5] == ':') { // \\?\X: -> X:
-      memmove(&ptr[0], &ptr[4], (wcslen(&ptr[4]) + 1) * sizeof(wchar_t));
-    } else if (!wcsncmp(&ptr[4], L"UNC\\", 4)) { // \\?\UNC\server -> \\server
-      wcscpy(&ptr[0], L"\\\\");
-      memmove(&ptr[2], &ptr[8], (wcslen(&ptr[8]) + 1) * sizeof(wchar_t));
-    }
-  }
-  return buff.release();
-}
-
-#define AT_FDCWD -1
-#define AT_SYMLINK_NOFOLLOW 1
-using ModeT = int;
-
-int fchmod_handle(HANDLE h, int perms) {
-  FILE_BASIC_INFO basic;
-  if (!GetFileInformationByHandleEx(h, FileBasicInfo, &basic, sizeof(basic)))
-    return set_errno();
-  DWORD orig_attributes = basic.FileAttributes;
-  basic.FileAttributes &= ~FILE_ATTRIBUTE_READONLY;
-  if ((perms & 0222) == 0)
-    basic.FileAttributes |= FILE_ATTRIBUTE_READONLY;
-  if (basic.FileAttributes != orig_attributes &&
-      !SetFileInformationByHandle(h, FileBasicInfo, &basic, sizeof(basic)))
-    return set_errno();
-  return 0;
-}
-
-int fchmodat(int fd, const wchar_t *path, int perms, int flag) {
-  DWORD attributes = GetFileAttributesW(path);
-  if (attributes == INVALID_FILE_ATTRIBUTES)
-    return set_errno();
-  if (attributes & FILE_ATTRIBUTE_REPARSE_POINT &&
-      !(flag & AT_SYMLINK_NOFOLLOW)) {
-    // If the file is a symlink, and we are supposed to operate on the target
-    // of the symlink, we need to open a handle to it, without the
-    // FILE_FLAG_OPEN_REPARSE_POINT flag, to open the destination of the
-    // symlink, and operate on it via the handle.
-    detail::WinHandle h(path, FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES, 0);
-    if (!h)
-      return set_errno();
-    return fchmod_handle(h, perms);
-  } else {
-    // For a non-symlink, or if operating on the symlink itself instead of
-    // its target, we can use SetFileAttributesW, saving a few calls.
-    DWORD orig_attributes = attributes;
-    attributes &= ~FILE_ATTRIBUTE_READONLY;
-    if ((perms & 0222) == 0)
-      attributes |= FILE_ATTRIBUTE_READONLY;
-    if (attributes != orig_attributes && !SetFileAttributesW(path, attributes))
-      return set_errno();
-  }
-  return 0;
-}
-
-int fchmod(int fd, int perms) {
-  HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
-  return fchmod_handle(h, perms);
-}
-
-#define MAX_SYMLINK_SIZE MAXIMUM_REPARSE_DATA_BUFFER_SIZE
-using SSizeT = ::int64_t;
-
-SSizeT readlink(const wchar_t *path, wchar_t *ret_buf, size_t bufsize) {
-  uint8_t buf[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
-  detail::WinHandle h(path, FILE_READ_ATTRIBUTES, FILE_FLAG_OPEN_REPARSE_POINT);
-  if (!h)
-    return set_errno();
-  DWORD out;
-  if (!DeviceIoControl(h, FSCTL_GET_REPARSE_POINT, nullptr, 0, buf, sizeof(buf),
-                       &out, 0))
-    return set_errno();
-  const auto *reparse = reinterpret_cast<LIBCPP_REPARSE_DATA_BUFFER *>(buf);
-  size_t path_buf_offset = offsetof(LIBCPP_REPARSE_DATA_BUFFER,
-                                    SymbolicLinkReparseBuffer.PathBuffer[0]);
-  if (out < path_buf_offset) {
-    errno = EINVAL;
-    return -1;
-  }
-  if (reparse->ReparseTag != IO_REPARSE_TAG_SYMLINK) {
-    errno = EINVAL;
-    return -1;
-  }
-  const auto &symlink = reparse->SymbolicLinkReparseBuffer;
-  unsigned short name_offset, name_length;
-  if (symlink.PrintNameLength == 0) {
-    name_offset = symlink.SubstituteNameOffset;
-    name_length = symlink.SubstituteNameLength;
-  } else {
-    name_offset = symlink.PrintNameOffset;
-    name_length = symlink.PrintNameLength;
-  }
-  // name_offset/length are expressed in bytes, not in wchar_t
-  if (path_buf_offset + name_offset + name_length > out) {
-    errno = EINVAL;
-    return -1;
-  }
-  if (name_length / sizeof(wchar_t) > bufsize) {
-    errno = ENOMEM;
-    return -1;
-  }
-  memcpy(ret_buf, &symlink.PathBuffer[name_offset / sizeof(wchar_t)],
-         name_length);
-  return name_length / sizeof(wchar_t);
-}
-
-#else
-int symlink_file(const char *oldname, const char *newname) {
-  return ::symlink(oldname, newname);
-}
-int symlink_dir(const char *oldname, const char *newname) {
-  return ::symlink(oldname, newname);
-}
-using ::chdir;
-using ::close;
-using ::fchmod;
-#if defined(AT_SYMLINK_NOFOLLOW) && defined(AT_FDCWD)
-using ::fchmodat;
-#endif
-using ::fstat;
-using ::ftruncate;
-using ::getcwd;
-using ::link;
-using ::lstat;
-using ::mkdir;
-using ::open;
-using ::readlink;
-using ::realpath;
-using ::remove;
-using ::rename;
-using ::stat;
-using ::statvfs;
-using ::truncate;
-
-#define O_BINARY 0
-
-using StatVFS = struct statvfs;
-using ModeT = ::mode_t;
-using SSizeT = ::ssize_t;
-
-#endif
-
-} // namespace
-} // end namespace detail
-
-_LIBCPP_END_NAMESPACE_FILESYSTEM
-
-#endif // POSIX_COMPAT_H
diff --git a/third_party/libcxx/src/functional.cpp b/third_party/libcxx/src/functional.cpp
deleted file mode 100644
index ca1079cdd..000000000
--- a/third_party/libcxx/src/functional.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <functional>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
-bad_function_call::~bad_function_call() noexcept
-{
-}
-#endif
-
-#ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
-const char*
-bad_function_call::what() const noexcept
-{
-    return "std::bad_function_call";
-}
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/future.cpp b/third_party/libcxx/src/future.cpp
deleted file mode 100644
index f8f466bd5..000000000
--- a/third_party/libcxx/src/future.cpp
+++ /dev/null
@@ -1,269 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-
-#include <future>
-#include <string>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-class _LIBCPP_HIDDEN __future_error_category
-    : public __do_message
-{
-public:
-    virtual const char* name() const noexcept;
-    virtual string message(int ev) const;
-};
-
-const char*
-__future_error_category::name() const noexcept
-{
-    return "future";
-}
-
-_LIBCPP_DIAGNOSTIC_PUSH
-_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wswitch")
-_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wswitch")
-
-string
-__future_error_category::message(int ev) const
-{
-    switch (static_cast<future_errc>(ev))
-    {
-    case future_errc(0):  // For backwards compatibility with C++11 (LWG 2056)
-    case future_errc::broken_promise:
-        return string("The associated promise has been destructed prior "
-                      "to the associated state becoming ready.");
-    case future_errc::future_already_retrieved:
-        return string("The future has already been retrieved from "
-                      "the promise or packaged_task.");
-    case future_errc::promise_already_satisfied:
-        return string("The state of the promise has already been set.");
-    case future_errc::no_state:
-        return string("Operation not permitted on an object without "
-                      "an associated state.");
-    }
-    return string("unspecified future_errc value\n");
-}
-
-_LIBCPP_DIAGNOSTIC_POP
-
-const error_category&
-future_category() noexcept
-{
-    static __future_error_category __f;
-    return __f;
-}
-
-future_error::future_error(error_code __ec)
-    : logic_error(__ec.message()),
-      __ec_(__ec)
-{
-}
-
-future_error::~future_error() noexcept
-{
-}
-
-void
-__assoc_sub_state::__on_zero_shared() noexcept
-{
-    delete this;
-}
-
-void
-__assoc_sub_state::set_value()
-{
-    unique_lock<mutex> __lk(__mut_);
-    if (__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-    __state_ |= __constructed | ready;
-    __cv_.notify_all();
-}
-
-void
-__assoc_sub_state::set_value_at_thread_exit()
-{
-    unique_lock<mutex> __lk(__mut_);
-    if (__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-    __state_ |= __constructed;
-    __thread_local_data()->__make_ready_at_thread_exit(this);
-}
-
-void
-__assoc_sub_state::set_exception(exception_ptr __p)
-{
-    unique_lock<mutex> __lk(__mut_);
-    if (__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-    __exception_ = __p;
-    __state_ |= ready;
-    __cv_.notify_all();
-}
-
-void
-__assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p)
-{
-    unique_lock<mutex> __lk(__mut_);
-    if (__has_value())
-        __throw_future_error(future_errc::promise_already_satisfied);
-    __exception_ = __p;
-    __thread_local_data()->__make_ready_at_thread_exit(this);
-}
-
-void
-__assoc_sub_state::__make_ready()
-{
-    unique_lock<mutex> __lk(__mut_);
-    __state_ |= ready;
-    __cv_.notify_all();
-}
-
-void
-__assoc_sub_state::copy()
-{
-    unique_lock<mutex> __lk(__mut_);
-    __sub_wait(__lk);
-    if (__exception_ != nullptr)
-        rethrow_exception(__exception_);
-}
-
-void
-__assoc_sub_state::wait()
-{
-    unique_lock<mutex> __lk(__mut_);
-    __sub_wait(__lk);
-}
-
-void
-__assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk)
-{
-    if (!__is_ready())
-    {
-        if (__state_ & static_cast<unsigned>(deferred))
-        {
-            __state_ &= ~static_cast<unsigned>(deferred);
-            __lk.unlock();
-            __execute();
-        }
-        else
-            while (!__is_ready())
-                __cv_.wait(__lk);
-    }
-}
-
-void
-__assoc_sub_state::__execute()
-{
-    __throw_future_error(future_errc::no_state);
-}
-
-future<void>::future(__assoc_sub_state* __state)
-    : __state_(__state)
-{
-    __state_->__attach_future();
-}
-
-future<void>::~future()
-{
-    if (__state_)
-        __state_->__release_shared();
-}
-
-void
-future<void>::get()
-{
-    unique_ptr<__shared_count, __release_shared_count> __(__state_);
-    __assoc_sub_state* __s = __state_;
-    __state_ = nullptr;
-    __s->copy();
-}
-
-promise<void>::promise()
-    : __state_(new __assoc_sub_state)
-{
-}
-
-promise<void>::~promise()
-{
-    if (__state_)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        if (!__state_->__has_value() && __state_->use_count() > 1)
-            __state_->set_exception(make_exception_ptr(
-                      future_error(make_error_code(future_errc::broken_promise))
-                                                      ));
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        __state_->__release_shared();
-    }
-}
-
-future<void>
-promise<void>::get_future()
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    return future<void>(__state_);
-}
-
-void
-promise<void>::set_value()
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_value();
-}
-
-void
-promise<void>::set_exception(exception_ptr __p)
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_exception(__p);
-}
-
-void
-promise<void>::set_value_at_thread_exit()
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_value_at_thread_exit();
-}
-
-void
-promise<void>::set_exception_at_thread_exit(exception_ptr __p)
-{
-    if (__state_ == nullptr)
-        __throw_future_error(future_errc::no_state);
-    __state_->set_exception_at_thread_exit(__p);
-}
-
-shared_future<void>::~shared_future()
-{
-    if (__state_)
-        __state_->__release_shared();
-}
-
-shared_future<void>&
-shared_future<void>::operator=(const shared_future& __rhs)
-{
-    if (__rhs.__state_)
-        __rhs.__state_->__add_shared();
-    if (__state_)
-        __state_->__release_shared();
-    __state_ = __rhs.__state_;
-    return *this;
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !_LIBCPP_HAS_NO_THREADS
diff --git a/third_party/libcxx/src/hash.cpp b/third_party/libcxx/src/hash.cpp
deleted file mode 100644
index 96cbd38f4..000000000
--- a/third_party/libcxx/src/hash.cpp
+++ /dev/null
@@ -1,559 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__hash_table>
-#include <algorithm>
-#include <stdexcept>
-#include <type_traits>
-
-_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wtautological-constant-out-of-range-compare")
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace {
-
-// handle all next_prime(i) for i in [1, 210), special case 0
-const unsigned small_primes[] =
-{
-    0,
-    2,
-    3,
-    5,
-    7,
-    11,
-    13,
-    17,
-    19,
-    23,
-    29,
-    31,
-    37,
-    41,
-    43,
-    47,
-    53,
-    59,
-    61,
-    67,
-    71,
-    73,
-    79,
-    83,
-    89,
-    97,
-    101,
-    103,
-    107,
-    109,
-    113,
-    127,
-    131,
-    137,
-    139,
-    149,
-    151,
-    157,
-    163,
-    167,
-    173,
-    179,
-    181,
-    191,
-    193,
-    197,
-    199,
-    211
-};
-
-// potential primes = 210*k + indices[i], k >= 1
-//   these numbers are not divisible by 2, 3, 5 or 7
-//   (or any integer 2 <= j <= 10 for that matter).
-const unsigned indices[] =
-{
-    1,
-    11,
-    13,
-    17,
-    19,
-    23,
-    29,
-    31,
-    37,
-    41,
-    43,
-    47,
-    53,
-    59,
-    61,
-    67,
-    71,
-    73,
-    79,
-    83,
-    89,
-    97,
-    101,
-    103,
-    107,
-    109,
-    113,
-    121,
-    127,
-    131,
-    137,
-    139,
-    143,
-    149,
-    151,
-    157,
-    163,
-    167,
-    169,
-    173,
-    179,
-    181,
-    187,
-    191,
-    193,
-    197,
-    199,
-    209
-};
-
-}
-
-// Returns:  If n == 0, returns 0.  Else returns the lowest prime number that
-// is greater than or equal to n.
-//
-// The algorithm creates a list of small primes, plus an open-ended list of
-// potential primes.  All prime numbers are potential prime numbers.  However
-// some potential prime numbers are not prime.  In an ideal world, all potential
-// prime numbers would be prime.  Candidate prime numbers are chosen as the next
-// highest potential prime.  Then this number is tested for prime by dividing it
-// by all potential prime numbers less than the sqrt of the candidate.
-//
-// This implementation defines potential primes as those numbers not divisible
-// by 2, 3, 5, and 7.  Other (common) implementations define potential primes
-// as those not divisible by 2.  A few other implementations define potential
-// primes as those not divisible by 2 or 3.  By raising the number of small
-// primes which the potential prime is not divisible by, the set of potential
-// primes more closely approximates the set of prime numbers.  And thus there
-// are fewer potential primes to search, and fewer potential primes to divide
-// against.
-
-template <size_t _Sz = sizeof(size_t)>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<_Sz == 4, void>::type
-__check_for_overflow(size_t N)
-{
-    if (N > 0xFFFFFFFB)
-        __throw_overflow_error("__next_prime overflow");
-}
-
-template <size_t _Sz = sizeof(size_t)>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<_Sz == 8, void>::type
-__check_for_overflow(size_t N)
-{
-    if (N > 0xFFFFFFFFFFFFFFC5ull)
-        __throw_overflow_error("__next_prime overflow");
-}
-
-size_t
-__next_prime(size_t n)
-{
-    const size_t L = 210;
-    const size_t N = sizeof(small_primes) / sizeof(small_primes[0]);
-    // If n is small enough, search in small_primes
-    if (n <= small_primes[N-1])
-        return *std::lower_bound(small_primes, small_primes + N, n);
-    // Else n > largest small_primes
-    // Check for overflow
-    __check_for_overflow(n);
-    // Start searching list of potential primes: L * k0 + indices[in]
-    const size_t M = sizeof(indices) / sizeof(indices[0]);
-    // Select first potential prime >= n
-    //   Known a-priori n >= L
-    size_t k0 = n / L;
-    size_t in = static_cast<size_t>(std::lower_bound(indices, indices + M, n - k0 * L)
-                                    - indices);
-    n = L * k0 + indices[in];
-    while (true)
-    {
-        // Divide n by all primes or potential primes (i) until:
-        //    1.  The division is even, so try next potential prime.
-        //    2.  The i > sqrt(n), in which case n is prime.
-        // It is known a-priori that n is not divisible by 2, 3, 5 or 7,
-        //    so don't test those (j == 5 ->  divide by 11 first).  And the
-        //    potential primes start with 211, so don't test against the last
-        //    small prime.
-        for (size_t j = 5; j < N - 1; ++j)
-        {
-            const std::size_t p = small_primes[j];
-            const std::size_t q = n / p;
-            if (q < p)
-                return n;
-            if (n == q * p)
-                goto next;
-        }
-        // n wasn't divisible by small primes, try potential primes
-        {
-            size_t i = 211;
-            while (true)
-            {
-                std::size_t q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 10;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 8;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 8;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 6;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 4;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 2;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                i += 10;
-                q = n / i;
-                if (q < i)
-                    return n;
-                if (n == q * i)
-                    break;
-
-                // This will loop i to the next "plane" of potential primes
-                i += 2;
-            }
-        }
-next:
-        // n is not prime.  Increment n to next potential prime.
-        if (++in == M)
-        {
-            ++k0;
-            in = 0;
-        }
-        n = L * k0 + indices[in];
-    }
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/include/apple_availability.h b/third_party/libcxx/src/include/apple_availability.h
deleted file mode 100644
index c8d158e99..000000000
--- a/third_party/libcxx/src/include/apple_availability.h
+++ /dev/null
@@ -1,34 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
-#define _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
-
-#if defined(__APPLE__)
-
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)
-#if __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101500
-#define _LIBCPP_USE_ULOCK
-#endif
-#elif defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
-#if __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130000
-#define _LIBCPP_USE_ULOCK
-#endif
-#elif defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)
-#if __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 130000
-#define _LIBCPP_USE_ULOCK
-#endif
-#elif defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)
-#if __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 60000
-#define _LIBCPP_USE_ULOCK
-#endif
-#endif // __ENVIRONMENT_.*_VERSION_MIN_REQUIRED__
-
-#endif // __APPLE__
-
-#endif // _LIBCPP_SRC_INCLUDE_APPLE_AVAILABILITY_H
diff --git a/third_party/libcxx/src/include/atomic_support.h b/third_party/libcxx/src/include/atomic_support.h
deleted file mode 100644
index 3e73f2ce2..000000000
--- a/third_party/libcxx/src/include/atomic_support.h
+++ /dev/null
@@ -1,176 +0,0 @@
-//===----------------------------------------------------------------------===////
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===////
-
-#ifndef ATOMIC_SUPPORT_H
-#define ATOMIC_SUPPORT_H
-
-#include <__config>
-#include <memory> // for __libcpp_relaxed_load
-
-#if defined(__clang__) && __has_builtin(__atomic_load_n)             \
-                       && __has_builtin(__atomic_store_n)            \
-                       && __has_builtin(__atomic_add_fetch)          \
-                       && __has_builtin(__atomic_exchange_n)         \
-                       && __has_builtin(__atomic_compare_exchange_n) \
-                       && defined(__ATOMIC_RELAXED)                  \
-                       && defined(__ATOMIC_CONSUME)                  \
-                       && defined(__ATOMIC_ACQUIRE)                  \
-                       && defined(__ATOMIC_RELEASE)                  \
-                       && defined(__ATOMIC_ACQ_REL)                  \
-                       && defined(__ATOMIC_SEQ_CST)
-#   define _LIBCPP_HAS_ATOMIC_BUILTINS
-#elif defined(_LIBCPP_COMPILER_GCC)
-#   define _LIBCPP_HAS_ATOMIC_BUILTINS
-#endif
-
-#if !defined(_LIBCPP_HAS_ATOMIC_BUILTINS) && !defined(_LIBCPP_HAS_NO_THREADS)
-# if defined(_LIBCPP_WARNING)
-    _LIBCPP_WARNING("Building libc++ without __atomic builtins is unsupported")
-# else
-#   warning Building libc++ without __atomic builtins is unsupported
-# endif
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace {
-
-#if defined(_LIBCPP_HAS_ATOMIC_BUILTINS) && !defined(_LIBCPP_HAS_NO_THREADS)
-
-enum __libcpp_atomic_order {
-    _AO_Relaxed = __ATOMIC_RELAXED,
-    _AO_Consume = __ATOMIC_CONSUME,
-    _AO_Acquire = __ATOMIC_ACQUIRE,
-    _AO_Release = __ATOMIC_RELEASE,
-    _AO_Acq_Rel = __ATOMIC_ACQ_REL,
-    _AO_Seq     = __ATOMIC_SEQ_CST
-};
-
-template <class _ValueType, class _FromType>
-inline _LIBCPP_INLINE_VISIBILITY
-void __libcpp_atomic_store(_ValueType* __dest, _FromType __val,
-                           int __order = _AO_Seq)
-{
-    __atomic_store_n(__dest, __val, __order);
-}
-
-template <class _ValueType, class _FromType>
-inline _LIBCPP_INLINE_VISIBILITY
-void __libcpp_relaxed_store(_ValueType* __dest, _FromType __val)
-{
-    __atomic_store_n(__dest, __val, _AO_Relaxed);
-}
-
-template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-_ValueType __libcpp_atomic_load(_ValueType const* __val,
-                                int __order = _AO_Seq)
-{
-    return __atomic_load_n(__val, __order);
-}
-
-template <class _ValueType, class _AddType>
-inline _LIBCPP_INLINE_VISIBILITY
-_ValueType __libcpp_atomic_add(_ValueType* __val, _AddType __a,
-                               int __order = _AO_Seq)
-{
-    return __atomic_add_fetch(__val, __a, __order);
-}
-
-template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-_ValueType __libcpp_atomic_exchange(_ValueType* __target,
-                                    _ValueType __value, int __order = _AO_Seq)
-{
-    return __atomic_exchange_n(__target, __value, __order);
-}
-
-template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-bool __libcpp_atomic_compare_exchange(_ValueType* __val,
-    _ValueType* __expected, _ValueType __after,
-    int __success_order = _AO_Seq,
-    int __fail_order = _AO_Seq)
-{
-    return __atomic_compare_exchange_n(__val, __expected, __after, true,
-                                       __success_order, __fail_order);
-}
-
-#else // _LIBCPP_HAS_NO_THREADS
-
-enum __libcpp_atomic_order {
-    _AO_Relaxed,
-    _AO_Consume,
-    _AO_Acquire,
-    _AO_Release,
-    _AO_Acq_Rel,
-    _AO_Seq
-};
-
-template <class _ValueType, class _FromType>
-inline _LIBCPP_INLINE_VISIBILITY
-void __libcpp_atomic_store(_ValueType* __dest, _FromType __val,
-                           int = 0)
-{
-    *__dest = __val;
-}
-
-template <class _ValueType, class _FromType>
-inline _LIBCPP_INLINE_VISIBILITY
-void __libcpp_relaxed_store(_ValueType* __dest, _FromType __val)
-{
-    *__dest = __val;
-}
-
-template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-_ValueType __libcpp_atomic_load(_ValueType const* __val,
-                                int = 0)
-{
-    return *__val;
-}
-
-template <class _ValueType, class _AddType>
-inline _LIBCPP_INLINE_VISIBILITY
-_ValueType __libcpp_atomic_add(_ValueType* __val, _AddType __a,
-                               int = 0)
-{
-    return *__val += __a;
-}
-
-template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-_ValueType __libcpp_atomic_exchange(_ValueType* __target,
-                                    _ValueType __value, int = _AO_Seq)
-{
-    _ValueType old = *__target;
-    *__target = __value;
-    return old;
-}
-
-template <class _ValueType>
-inline _LIBCPP_INLINE_VISIBILITY
-bool __libcpp_atomic_compare_exchange(_ValueType* __val,
-    _ValueType* __expected, _ValueType __after,
-    int = 0, int = 0)
-{
-    if (*__val == *__expected) {
-        *__val = __after;
-        return true;
-    }
-    *__expected = *__val;
-    return false;
-}
-
-#endif // _LIBCPP_HAS_NO_THREADS
-
-} // end namespace
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // ATOMIC_SUPPORT_H
diff --git a/third_party/libcxx/src/include/refstring.h b/third_party/libcxx/src/include/refstring.h
deleted file mode 100644
index 0675b393b..000000000
--- a/third_party/libcxx/src/include/refstring.h
+++ /dev/null
@@ -1,140 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_REFSTRING_H
-#define _LIBCPP_REFSTRING_H
-
-#include <__config>
-#include <stdexcept>
-#include <cstddef>
-#include <cstring>
-#include "atomic_support.h"
-
-// MacOS and iOS used to ship with libstdc++, and still support old applications
-// linking against libstdc++. The libc++ and libstdc++ exceptions are supposed
-// to be ABI compatible, such that they can be thrown from one library and caught
-// in the other.
-//
-// For that reason, we must look for libstdc++ in the same process and if found,
-// check the string stored in the exception object to see if it is the GCC empty
-// string singleton before manipulating the reference count. This is done so that
-// if an exception is created with a zero-length string in libstdc++, libc++abi
-// won't try to delete the memory.
-#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) || \
-    defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__)
-#   define _LIBCPP_CHECK_FOR_GCC_EMPTY_STRING_STORAGE
-#   include <dlfcn.h>
-#   include <mach-o/dyld.h>
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace __refstring_imp { namespace {
-typedef int count_t;
-
-struct _Rep_base {
-    std::size_t len;
-    std::size_t cap;
-    count_t     count;
-};
-
-inline _Rep_base* rep_from_data(const char *data_) noexcept {
-    char *data = const_cast<char *>(data_);
-    return reinterpret_cast<_Rep_base *>(data - sizeof(_Rep_base));
-}
-
-inline char * data_from_rep(_Rep_base *rep) noexcept {
-    char *data = reinterpret_cast<char *>(rep);
-    return data + sizeof(*rep);
-}
-
-#if defined(_LIBCPP_CHECK_FOR_GCC_EMPTY_STRING_STORAGE)
-inline
-const char* compute_gcc_empty_string_storage() noexcept
-{
-    void* handle = dlopen("/usr/lib/libstdc++.6.dylib", RTLD_NOLOAD);
-    if (handle == nullptr)
-        return nullptr;
-    void* sym = dlsym(handle, "_ZNSs4_Rep20_S_empty_rep_storageE");
-    if (sym == nullptr)
-        return nullptr;
-    return data_from_rep(reinterpret_cast<_Rep_base *>(sym));
-}
-
-inline
-const char*
-get_gcc_empty_string_storage() noexcept
-{
-    static const char* p = compute_gcc_empty_string_storage();
-    return p;
-}
-#endif
-
-}} // namespace __refstring_imp
-
-using namespace __refstring_imp;
-
-inline
-__libcpp_refstring::__libcpp_refstring(const char* msg) {
-    std::size_t len = strlen(msg);
-    _Rep_base* rep = static_cast<_Rep_base *>(::operator new(sizeof(*rep) + len + 1));
-    rep->len = len;
-    rep->cap = len;
-    rep->count = 0;
-    char *data = data_from_rep(rep);
-    std::memcpy(data, msg, len + 1);
-    __imp_ = data;
-}
-
-inline
-__libcpp_refstring::__libcpp_refstring(const __libcpp_refstring &s) noexcept
-    : __imp_(s.__imp_)
-{
-    if (__uses_refcount())
-        __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
-}
-
-inline
-__libcpp_refstring& __libcpp_refstring::operator=(__libcpp_refstring const& s) noexcept {
-    bool adjust_old_count = __uses_refcount();
-    struct _Rep_base *old_rep = rep_from_data(__imp_);
-    __imp_ = s.__imp_;
-    if (__uses_refcount())
-        __libcpp_atomic_add(&rep_from_data(__imp_)->count, 1);
-    if (adjust_old_count)
-    {
-        if (__libcpp_atomic_add(&old_rep->count, count_t(-1)) < 0)
-        {
-            ::operator delete(old_rep);
-        }
-    }
-    return *this;
-}
-
-inline
-__libcpp_refstring::~__libcpp_refstring() {
-    if (__uses_refcount()) {
-        _Rep_base* rep = rep_from_data(__imp_);
-        if (__libcpp_atomic_add(&rep->count, count_t(-1)) < 0) {
-            ::operator delete(rep);
-        }
-    }
-}
-
-inline
-bool __libcpp_refstring::__uses_refcount() const {
-#if defined(_LIBCPP_CHECK_FOR_GCC_EMPTY_STRING_STORAGE)
-    return __imp_ != get_gcc_empty_string_storage();
-#else
-    return true;
-#endif
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif //_LIBCPP_REFSTRING_H
diff --git a/third_party/libcxx/src/include/ryu/common.h b/third_party/libcxx/src/include/ryu/common.h
deleted file mode 100644
index 4503e6d35..000000000
--- a/third_party/libcxx/src/include/ryu/common.h
+++ /dev/null
@@ -1,109 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// Copyright (c) Microsoft Corporation.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-// Copyright 2018 Ulf Adams
-// Copyright (c) Microsoft Corporation. All rights reserved.
-
-// Boost Software License - Version 1.0 - August 17th, 2003
-
-// Permission is hereby granted, free of charge, to any person or organization
-// obtaining a copy of the software and accompanying documentation covered by
-// this license (the "Software") to use, reproduce, display, distribute,
-// execute, and transmit the Software, and to prepare derivative works of the
-// Software, and to permit third-parties to whom the Software is furnished to
-// do so, all subject to the following:
-
-// The copyright notices in the Software and this entire statement, including
-// the above license grant, this restriction and the following disclaimer,
-// must be included in all copies of the Software, in whole or in part, and
-// all derivative works of the Software, unless such copies or derivative
-// works are solely in the form of machine-executable object code generated by
-// a source language processor.
-
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-// DEALINGS IN THE SOFTWARE.
-
-#ifndef _LIBCPP_SRC_INCLUDE_RYU_COMMON_H
-#define _LIBCPP_SRC_INCLUDE_RYU_COMMON_H
-
-// Avoid formatting to keep the changes with the original code minimal.
-// clang-format off
-
-#include <__assert>
-#include <__config>
-#include <cstring>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __decimalLength9(const uint32_t __v) {
-  // Function precondition: __v is not a 10-digit number.
-  // (f2s: 9 digits are sufficient for round-tripping.)
-  // (d2fixed: We print 9-digit blocks.)
-  _LIBCPP_ASSERT(__v < 1000000000, "");
-  if (__v >= 100000000) { return 9; }
-  if (__v >= 10000000) { return 8; }
-  if (__v >= 1000000) { return 7; }
-  if (__v >= 100000) { return 6; }
-  if (__v >= 10000) { return 5; }
-  if (__v >= 1000) { return 4; }
-  if (__v >= 100) { return 3; }
-  if (__v >= 10) { return 2; }
-  return 1;
-}
-
-// Returns __e == 0 ? 1 : ceil(log_2(5^__e)).
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI  inline int32_t __pow5bits(const int32_t __e) {
-  // This approximation works up to the point that the multiplication overflows at __e = 3529.
-  // If the multiplication were done in 64 bits, it would fail at 5^4004 which is just greater
-  // than 2^9297.
-  _LIBCPP_ASSERT(__e >= 0, "");
-  _LIBCPP_ASSERT(__e <= 3528, "");
-  return static_cast<int32_t>(((static_cast<uint32_t>(__e) * 1217359) >> 19) + 1);
-}
-
-// Returns floor(log_10(2^__e)).
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI  inline uint32_t __log10Pow2(const int32_t __e) {
-  // The first value this approximation fails for is 2^1651 which is just greater than 10^297.
-  _LIBCPP_ASSERT(__e >= 0, "");
-  _LIBCPP_ASSERT(__e <= 1650, "");
-  return (static_cast<uint32_t>(__e) * 78913) >> 18;
-}
-
-// Returns floor(log_10(5^__e)).
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __log10Pow5(const int32_t __e) {
-  // The first value this approximation fails for is 5^2621 which is just greater than 10^1832.
-  _LIBCPP_ASSERT(__e >= 0, "");
-  _LIBCPP_ASSERT(__e <= 2620, "");
-  return (static_cast<uint32_t>(__e) * 732923) >> 20;
-}
-
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint32_t __float_to_bits(const float __f) {
-  uint32_t __bits = 0;
-  std::memcpy(&__bits, &__f, sizeof(float));
-  return __bits;
-}
-
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline uint64_t __double_to_bits(const double __d) {
-  uint64_t __bits = 0;
-  std::memcpy(&__bits, &__d, sizeof(double));
-  return __bits;
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-// clang-format on
-
-#endif // _LIBCPP_SRC_INCLUDE_RYU_COMMON_H
diff --git a/third_party/libcxx/src/include/sso_allocator.h b/third_party/libcxx/src/include/sso_allocator.h
deleted file mode 100644
index 6a682fc43..000000000
--- a/third_party/libcxx/src/include/sso_allocator.h
+++ /dev/null
@@ -1,82 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_SSO_ALLOCATOR_H
-#define _LIBCPP_SSO_ALLOCATOR_H
-
-#include <__config>
-#include <memory>
-#include <new>
-#include <type_traits>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp, size_t _Np> class _LIBCPP_HIDDEN __sso_allocator;
-
-template <size_t _Np>
-class _LIBCPP_HIDDEN __sso_allocator<void, _Np>
-{
-public:
-    typedef const void*       const_pointer;
-    typedef void              value_type;
-};
-
-template <class _Tp, size_t _Np>
-class _LIBCPP_HIDDEN __sso_allocator
-{
-    typename aligned_storage<sizeof(_Tp) * _Np>::type buf_;
-    bool __allocated_;
-public:
-    typedef size_t            size_type;
-    typedef _Tp*              pointer;
-    typedef _Tp               value_type;
-
-    template <class U>
-    struct rebind {
-        using other = __sso_allocator<U, _Np>;
-    };
-
-    _LIBCPP_INLINE_VISIBILITY __sso_allocator() throw() : __allocated_(false) {}
-    _LIBCPP_INLINE_VISIBILITY __sso_allocator(const __sso_allocator&) throw() : __allocated_(false) {}
-    template <class _Up> _LIBCPP_INLINE_VISIBILITY __sso_allocator(const __sso_allocator<_Up, _Np>&) throw()
-         : __allocated_(false) {}
-private:
-    __sso_allocator& operator=(const __sso_allocator&);
-public:
-    _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, typename __sso_allocator<void, _Np>::const_pointer = nullptr)
-    {
-        if (!__allocated_ && __n <= _Np)
-        {
-            __allocated_ = true;
-            return (pointer)&buf_;
-        }
-        return allocator<_Tp>().allocate(__n);
-    }
-    _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n)
-    {
-        if (__p == (pointer)&buf_)
-            __allocated_ = false;
-        else
-            allocator<_Tp>().deallocate(__p, __n);
-    }
-    _LIBCPP_INLINE_VISIBILITY size_type max_size() const throw() {return size_type(~0) / sizeof(_Tp);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const __sso_allocator& __a) const {return &buf_ == &__a.buf_;}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const __sso_allocator& __a) const {return &buf_ != &__a.buf_;}
-};
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // _LIBCPP_SSO_ALLOCATOR_H
diff --git a/third_party/libcxx/src/include/to_chars_floating_point.h b/third_party/libcxx/src/include/to_chars_floating_point.h
deleted file mode 100644
index f356fae95..000000000
--- a/third_party/libcxx/src/include/to_chars_floating_point.h
+++ /dev/null
@@ -1,1085 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// Copyright (c) Microsoft Corporation.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-
-// This implementation is dedicated to the memory of Mary and Thavatchai.
-
-#ifndef _LIBCPP_SRC_INCLUDE_TO_CHARS_FLOATING_POINT_H
-#define _LIBCPP_SRC_INCLUDE_TO_CHARS_FLOATING_POINT_H
-
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wattributes"
-
-// Avoid formatting to keep the changes with the original code minimal.
-// clang-format off
-
-#include <__algorithm/find.h>
-#include <__algorithm/find_if.h>
-#include <__algorithm/lower_bound.h>
-#include <__algorithm/min.h>
-#include <__bit/bit_cast.h>
-#include <__assert>
-#include <__config>
-#include <__functional/operations.h>
-#include <__iterator/access.h>
-#include <__iterator/size.h>
-#include <bit>
-#include <cfloat>
-#include <climits>
-
-#include "third_party/libcxx/src/include/ryu/ryu.h"
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace __itoa {
-inline constexpr char _Charconv_digits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
-    'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
-static_assert(_VSTD::size(_Charconv_digits) == 36);
-} // __itoa
-
-// vvvvvvvvvv DERIVED FROM corecrt_internal_fltintrn.h vvvvvvvvvv
-
-template <class _FloatingType>
-struct _Floating_type_traits;
-
-template <>
-struct _Floating_type_traits<float> {
-    static constexpr int32_t _Mantissa_bits = FLT_MANT_DIG;
-    static constexpr int32_t _Exponent_bits = sizeof(float) * CHAR_BIT - FLT_MANT_DIG;
-
-    static constexpr int32_t _Maximum_binary_exponent = FLT_MAX_EXP - 1;
-    static constexpr int32_t _Minimum_binary_exponent = FLT_MIN_EXP - 1;
-
-    static constexpr int32_t _Exponent_bias = 127;
-
-    static constexpr int32_t _Sign_shift     = _Exponent_bits + _Mantissa_bits - 1;
-    static constexpr int32_t _Exponent_shift = _Mantissa_bits - 1;
-
-    using _Uint_type = uint32_t;
-
-    static constexpr uint32_t _Exponent_mask             = (1u << _Exponent_bits) - 1;
-    static constexpr uint32_t _Normal_mantissa_mask      = (1u << _Mantissa_bits) - 1;
-    static constexpr uint32_t _Denormal_mantissa_mask    = (1u << (_Mantissa_bits - 1)) - 1;
-    static constexpr uint32_t _Special_nan_mantissa_mask = 1u << (_Mantissa_bits - 2);
-    static constexpr uint32_t _Shifted_sign_mask         = 1u << _Sign_shift;
-    static constexpr uint32_t _Shifted_exponent_mask     = _Exponent_mask << _Exponent_shift;
-};
-
-template <>
-struct _Floating_type_traits<double> {
-    static constexpr int32_t _Mantissa_bits = DBL_MANT_DIG;
-    static constexpr int32_t _Exponent_bits = sizeof(double) * CHAR_BIT - DBL_MANT_DIG;
-
-    static constexpr int32_t _Maximum_binary_exponent = DBL_MAX_EXP - 1;
-    static constexpr int32_t _Minimum_binary_exponent = DBL_MIN_EXP - 1;
-
-    static constexpr int32_t _Exponent_bias = 1023;
-
-    static constexpr int32_t _Sign_shift     = _Exponent_bits + _Mantissa_bits - 1;
-    static constexpr int32_t _Exponent_shift = _Mantissa_bits - 1;
-
-    using _Uint_type = uint64_t;
-
-    static constexpr uint64_t _Exponent_mask             = (1ULL << _Exponent_bits) - 1;
-    static constexpr uint64_t _Normal_mantissa_mask      = (1ULL << _Mantissa_bits) - 1;
-    static constexpr uint64_t _Denormal_mantissa_mask    = (1ULL << (_Mantissa_bits - 1)) - 1;
-    static constexpr uint64_t _Special_nan_mantissa_mask = 1ULL << (_Mantissa_bits - 2);
-    static constexpr uint64_t _Shifted_sign_mask         = 1ULL << _Sign_shift;
-    static constexpr uint64_t _Shifted_exponent_mask     = _Exponent_mask << _Exponent_shift;
-};
-
-// ^^^^^^^^^^ DERIVED FROM corecrt_internal_fltintrn.h ^^^^^^^^^^
-
-// FUNCTION to_chars (FLOATING-POINT TO STRING)
-template <class _Floating>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-to_chars_result _Floating_to_chars_hex_precision(
-    char* _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {
-
-    // * Determine the effective _Precision.
-    // * Later, we'll decrement _Precision when printing each hexit after the decimal point.
-
-    // The hexits after the decimal point correspond to the explicitly stored fraction bits.
-    // float explicitly stores 23 fraction bits. 23 / 4 == 5.75, which is 6 hexits.
-    // double explicitly stores 52 fraction bits. 52 / 4 == 13, which is 13 hexits.
-    constexpr int _Full_precision         = _IsSame<_Floating, float>::value ? 6 : 13;
-    constexpr int _Adjusted_explicit_bits = _Full_precision * 4;
-
-    if (_Precision < 0) {
-        // C11 7.21.6.1 "The fprintf function"/5: "A negative precision argument is taken as if the precision were
-        // omitted." /8: "if the precision is missing and FLT_RADIX is a power of 2, then the precision is sufficient
-        // for an exact representation of the value"
-        _Precision = _Full_precision;
-    }
-
-    // * Extract the _Ieee_mantissa and _Ieee_exponent.
-    using _Traits    = _Floating_type_traits<_Floating>;
-    using _Uint_type = typename _Traits::_Uint_type;
-
-    const _Uint_type _Uint_value    = _VSTD::bit_cast<_Uint_type>(_Value);
-    const _Uint_type _Ieee_mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
-    const int32_t _Ieee_exponent    = static_cast<int32_t>(_Uint_value >> _Traits::_Exponent_shift);
-
-    // * Prepare the _Adjusted_mantissa. This is aligned to hexit boundaries,
-    // * with the implicit bit restored (0 for zero values and subnormal values, 1 for normal values).
-    // * Also calculate the _Unbiased_exponent. This unifies the processing of zero, subnormal, and normal values.
-    _Uint_type _Adjusted_mantissa;
-
-    if constexpr (_IsSame<_Floating, float>::value) {
-        _Adjusted_mantissa = _Ieee_mantissa << 1; // align to hexit boundary (23 isn't divisible by 4)
-    } else {
-        _Adjusted_mantissa = _Ieee_mantissa; // already aligned (52 is divisible by 4)
-    }
-
-    int32_t _Unbiased_exponent;
-
-    if (_Ieee_exponent == 0) { // zero or subnormal
-        // implicit bit is 0
-
-        if (_Ieee_mantissa == 0) { // zero
-            // C11 7.21.6.1 "The fprintf function"/8: "If the value is zero, the exponent is zero."
-            _Unbiased_exponent = 0;
-        } else { // subnormal
-            _Unbiased_exponent = 1 - _Traits::_Exponent_bias;
-        }
-    } else { // normal
-        _Adjusted_mantissa |= _Uint_type{1} << _Adjusted_explicit_bits; // implicit bit is 1
-        _Unbiased_exponent = _Ieee_exponent - _Traits::_Exponent_bias;
-    }
-
-    // _Unbiased_exponent is within [-126, 127] for float, [-1022, 1023] for double.
-
-    // * Decompose _Unbiased_exponent into _Sign_character and _Absolute_exponent.
-    char _Sign_character;
-    uint32_t _Absolute_exponent;
-
-    if (_Unbiased_exponent < 0) {
-        _Sign_character    = '-';
-        _Absolute_exponent = static_cast<uint32_t>(-_Unbiased_exponent);
-    } else {
-        _Sign_character    = '+';
-        _Absolute_exponent = static_cast<uint32_t>(_Unbiased_exponent);
-    }
-
-    // _Absolute_exponent is within [0, 127] for float, [0, 1023] for double.
-
-    // * Perform a single bounds check.
-    {
-        int32_t _Exponent_length;
-
-        if (_Absolute_exponent < 10) {
-            _Exponent_length = 1;
-        } else if (_Absolute_exponent < 100) {
-            _Exponent_length = 2;
-        } else if constexpr (_IsSame<_Floating, float>::value) {
-            _Exponent_length = 3;
-        } else if (_Absolute_exponent < 1000) {
-            _Exponent_length = 3;
-        } else {
-            _Exponent_length = 4;
-        }
-
-        // _Precision might be enormous; avoid integer overflow by testing it separately.
-        ptrdiff_t _Buffer_size = _Last - _First;
-
-        if (_Buffer_size < _Precision) {
-            return {_Last, errc::value_too_large};
-        }
-
-        _Buffer_size -= _Precision;
-
-        const int32_t _Length_excluding_precision = 1 // leading hexit
-                                                    + static_cast<int32_t>(_Precision > 0) // possible decimal point
-                                                    // excluding `+ _Precision`, hexits after decimal point
-                                                    + 2 // "p+" or "p-"
-                                                    + _Exponent_length; // exponent
-
-        if (_Buffer_size < _Length_excluding_precision) {
-            return {_Last, errc::value_too_large};
-        }
-    }
-
-    // * Perform rounding when we've been asked to omit hexits.
-    if (_Precision < _Full_precision) {
-        // _Precision is within [0, 5] for float, [0, 12] for double.
-
-        // _Dropped_bits is within [4, 24] for float, [4, 52] for double.
-        const int _Dropped_bits = (_Full_precision - _Precision) * 4;
-
-        // Perform rounding by adding an appropriately-shifted bit.
-
-        // This can propagate carries all the way into the leading hexit. Examples:
-        // "0.ff9" rounded to a precision of 2 is "1.00".
-        // "1.ff9" rounded to a precision of 2 is "2.00".
-
-        // Note that the leading hexit participates in the rounding decision. Examples:
-        // "0.8" rounded to a precision of 0 is "0".
-        // "1.8" rounded to a precision of 0 is "2".
-
-        // Reference implementation with suboptimal codegen:
-        // bool _Should_round_up(bool _Lsb_bit, bool _Round_bit, bool _Has_tail_bits) {
-        //    // If there are no insignificant set bits, the value is exactly-representable and should not be rounded.
-        //    //
-        //    // If there are insignificant set bits, we need to round according to round_to_nearest.
-        //    // We need to handle two cases: we round up if either [1] the value is slightly greater
-        //    // than the midpoint between two exactly-representable values or [2] the value is exactly the midpoint
-        //    // between two exactly-representable values and the greater of the two is even (this is "round-to-even").
-        //    return _Round_bit && (_Has_tail_bits || _Lsb_bit);
-        //}
-        // const bool _Lsb_bit       = (_Adjusted_mantissa & (_Uint_type{1} << _Dropped_bits)) != 0;
-        // const bool _Round_bit     = (_Adjusted_mantissa & (_Uint_type{1} << (_Dropped_bits - 1))) != 0;
-        // const bool _Has_tail_bits = (_Adjusted_mantissa & ((_Uint_type{1} << (_Dropped_bits - 1)) - 1)) != 0;
-        // const bool _Should_round = _Should_round_up(_Lsb_bit, _Round_bit, _Has_tail_bits);
-        // _Adjusted_mantissa += _Uint_type{_Should_round} << _Dropped_bits;
-
-        // Example for optimized implementation: Let _Dropped_bits be 8.
-        //          Bit index: ...[8]76543210
-        // _Adjusted_mantissa: ...[L]RTTTTTTT (not depicting known details, like hexit alignment)
-        // By focusing on the bit at index _Dropped_bits, we can avoid unnecessary branching and shifting.
-
-        // Bit index: ...[8]76543210
-        //  _Lsb_bit: ...[L]RTTTTTTT
-        const _Uint_type _Lsb_bit = _Adjusted_mantissa;
-
-        //  Bit index: ...9[8]76543210
-        // _Round_bit: ...L[R]TTTTTTT0
-        const _Uint_type _Round_bit = _Adjusted_mantissa << 1;
-
-        // We can detect (without branching) whether any of the trailing bits are set.
-        // Due to _Should_round below, this computation will be used if and only if R is 1, so we can assume that here.
-        //      Bit index: ...9[8]76543210
-        //     _Round_bit: ...L[1]TTTTTTT0
-        // _Has_tail_bits: ....[H]........
-
-        // If all of the trailing bits T are 0, then `_Round_bit - 1` will produce 0 for H (due to R being 1).
-        // If any of the trailing bits T are 1, then `_Round_bit - 1` will produce 1 for H (due to R being 1).
-        const _Uint_type _Has_tail_bits = _Round_bit - 1;
-
-        // Finally, we can use _Should_round_up() logic with bitwise-AND and bitwise-OR,
-        // selecting just the bit at index _Dropped_bits. This is the appropriately-shifted bit that we want.
-        const _Uint_type _Should_round = _Round_bit & (_Has_tail_bits | _Lsb_bit) & (_Uint_type{1} << _Dropped_bits);
-
-        // This rounding technique is dedicated to the memory of Peppermint. =^..^=
-        _Adjusted_mantissa += _Should_round;
-    }
-
-    // * Print the leading hexit, then mask it away.
-    {
-        const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Adjusted_explicit_bits);
-        _LIBCPP_ASSERT(_Nibble < 3, "");
-        const char _Leading_hexit = static_cast<char>('0' + _Nibble);
-
-        *_First++ = _Leading_hexit;
-
-        constexpr _Uint_type _Mask = (_Uint_type{1} << _Adjusted_explicit_bits) - 1;
-        _Adjusted_mantissa &= _Mask;
-    }
-
-    // * Print the decimal point and trailing hexits.
-
-    // C11 7.21.6.1 "The fprintf function"/8:
-    // "if the precision is zero and the # flag is not specified, no decimal-point character appears."
-    if (_Precision > 0) {
-        *_First++ = '.';
-
-        int32_t _Number_of_bits_remaining = _Adjusted_explicit_bits; // 24 for float, 52 for double
-
-        for (;;) {
-            _LIBCPP_ASSERT(_Number_of_bits_remaining >= 4, "");
-            _LIBCPP_ASSERT(_Number_of_bits_remaining % 4 == 0, "");
-            _Number_of_bits_remaining -= 4;
-
-            const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Number_of_bits_remaining);
-            _LIBCPP_ASSERT(_Nibble < 16, "");
-            const char _Hexit = __itoa::_Charconv_digits[_Nibble];
-
-            *_First++ = _Hexit;
-
-            // _Precision is the number of hexits that still need to be printed.
-            --_Precision;
-            if (_Precision == 0) {
-                break; // We're completely done with this phase.
-            }
-            // Otherwise, we need to keep printing hexits.
-
-            if (_Number_of_bits_remaining == 0) {
-                // We've finished printing _Adjusted_mantissa, so all remaining hexits are '0'.
-                _VSTD::memset(_First, '0', static_cast<size_t>(_Precision));
-                _First += _Precision;
-                break;
-            }
-
-            // Mask away the hexit that we just printed, then keep looping.
-            // (We skip this when breaking out of the loop above, because _Adjusted_mantissa isn't used later.)
-            const _Uint_type _Mask = (_Uint_type{1} << _Number_of_bits_remaining) - 1;
-            _Adjusted_mantissa &= _Mask;
-        }
-    }
-
-    // * Print the exponent.
-
-    // C11 7.21.6.1 "The fprintf function"/8: "The exponent always contains at least one digit, and only as many more
-    // digits as necessary to represent the decimal exponent of 2."
-
-    // Performance note: We should take advantage of the known ranges of possible exponents.
-
-    *_First++ = 'p';
-    *_First++ = _Sign_character;
-
-    // We've already printed '-' if necessary, so uint32_t _Absolute_exponent avoids testing that again.
-    return _VSTD::to_chars(_First, _Last, _Absolute_exponent);
-}
-
-template <class _Floating>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-to_chars_result _Floating_to_chars_hex_shortest(
-    char* _First, char* const _Last, const _Floating _Value) noexcept {
-
-    // This prints "1.728p+0" instead of "2.e5p-1".
-    // This prints "0.000002p-126" instead of "1p-149" for float.
-    // This prints "0.0000000000001p-1022" instead of "1p-1074" for double.
-    // This prioritizes being consistent with printf's de facto behavior (and hex-precision's behavior)
-    // over minimizing the number of characters printed.
-
-    using _Traits    = _Floating_type_traits<_Floating>;
-    using _Uint_type = typename _Traits::_Uint_type;
-
-    const _Uint_type _Uint_value = _VSTD::bit_cast<_Uint_type>(_Value);
-
-    if (_Uint_value == 0) { // zero detected; write "0p+0" and return
-        // C11 7.21.6.1 "The fprintf function"/8: "If the value is zero, the exponent is zero."
-        // Special-casing zero is necessary because of the exponent.
-        const char* const _Str = "0p+0";
-        const size_t _Len      = 4;
-
-        if (_Last - _First < static_cast<ptrdiff_t>(_Len)) {
-            return {_Last, errc::value_too_large};
-        }
-
-        _VSTD::memcpy(_First, _Str, _Len);
-
-        return {_First + _Len, errc{}};
-    }
-
-    const _Uint_type _Ieee_mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
-    const int32_t _Ieee_exponent    = static_cast<int32_t>(_Uint_value >> _Traits::_Exponent_shift);
-
-    char _Leading_hexit; // implicit bit
-    int32_t _Unbiased_exponent;
-
-    if (_Ieee_exponent == 0) { // subnormal
-        _Leading_hexit     = '0';
-        _Unbiased_exponent = 1 - _Traits::_Exponent_bias;
-    } else { // normal
-        _Leading_hexit     = '1';
-        _Unbiased_exponent = _Ieee_exponent - _Traits::_Exponent_bias;
-    }
-
-    // Performance note: Consider avoiding per-character bounds checking when there's plenty of space.
-
-    if (_First == _Last) {
-        return {_Last, errc::value_too_large};
-    }
-
-    *_First++ = _Leading_hexit;
-
-    if (_Ieee_mantissa == 0) {
-        // The fraction bits are all 0. Trim them away, including the decimal point.
-    } else {
-        if (_First == _Last) {
-            return {_Last, errc::value_too_large};
-        }
-
-        *_First++ = '.';
-
-        // The hexits after the decimal point correspond to the explicitly stored fraction bits.
-        // float explicitly stores 23 fraction bits. 23 / 4 == 5.75, so we'll print at most 6 hexits.
-        // double explicitly stores 52 fraction bits. 52 / 4 == 13, so we'll print at most 13 hexits.
-        _Uint_type _Adjusted_mantissa;
-        int32_t _Number_of_bits_remaining;
-
-        if constexpr (_IsSame<_Floating, float>::value) {
-            _Adjusted_mantissa        = _Ieee_mantissa << 1; // align to hexit boundary (23 isn't divisible by 4)
-            _Number_of_bits_remaining = 24; // 23 fraction bits + 1 alignment bit
-        } else {
-            _Adjusted_mantissa        = _Ieee_mantissa; // already aligned (52 is divisible by 4)
-            _Number_of_bits_remaining = 52; // 52 fraction bits
-        }
-
-        // do-while: The condition _Adjusted_mantissa != 0 is initially true - we have nonzero fraction bits and we've
-        // printed the decimal point. Each iteration, we print a hexit, mask it away, and keep looping if we still have
-        // nonzero fraction bits. If there would be trailing '0' hexits, this trims them. If there wouldn't be trailing
-        // '0' hexits, the same condition works (as we print the final hexit and mask it away); we don't need to test
-        // _Number_of_bits_remaining.
-        do {
-            _LIBCPP_ASSERT(_Number_of_bits_remaining >= 4, "");
-            _LIBCPP_ASSERT(_Number_of_bits_remaining % 4 == 0, "");
-            _Number_of_bits_remaining -= 4;
-
-            const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Number_of_bits_remaining);
-            _LIBCPP_ASSERT(_Nibble < 16, "");
-            const char _Hexit = __itoa::_Charconv_digits[_Nibble];
-
-            if (_First == _Last) {
-                return {_Last, errc::value_too_large};
-            }
-
-            *_First++ = _Hexit;
-
-            const _Uint_type _Mask = (_Uint_type{1} << _Number_of_bits_remaining) - 1;
-            _Adjusted_mantissa &= _Mask;
-
-        } while (_Adjusted_mantissa != 0);
-    }
-
-    // C11 7.21.6.1 "The fprintf function"/8: "The exponent always contains at least one digit, and only as many more
-    // digits as necessary to represent the decimal exponent of 2."
-
-    // Performance note: We should take advantage of the known ranges of possible exponents.
-
-    // float: _Unbiased_exponent is within [-126, 127].
-    // double: _Unbiased_exponent is within [-1022, 1023].
-
-    if (_Last - _First < 2) {
-        return {_Last, errc::value_too_large};
-    }
-
-    *_First++ = 'p';
-
-    if (_Unbiased_exponent < 0) {
-        *_First++          = '-';
-        _Unbiased_exponent = -_Unbiased_exponent;
-    } else {
-        *_First++ = '+';
-    }
-
-    // We've already printed '-' if necessary, so static_cast<uint32_t> avoids testing that again.
-    return _VSTD::to_chars(_First, _Last, static_cast<uint32_t>(_Unbiased_exponent));
-}
-
-// For general precision, we can use lookup tables to avoid performing trial formatting.
-
-// For a simple example, imagine counting the number of digits D in an integer, and needing to know
-// whether D is less than 3, equal to 3/4/5/6, or greater than 6. We could use a lookup table:
-// D | Largest integer with D digits
-// 2 |      99
-// 3 |     999
-// 4 |   9'999
-// 5 |  99'999
-// 6 | 999'999
-// 7 | table end
-// Looking up an integer in this table with lower_bound() will work:
-// * Too-small integers, like 7, 70, and 99, will cause lower_bound() to return the D == 2 row. (If all we care
-//   about is whether D is less than 3, then it's okay to smash the D == 1 and D == 2 cases together.)
-// * Integers in [100, 999] will cause lower_bound() to return the D == 3 row, and so forth.
-// * Too-large integers, like 1'000'000 and above, will cause lower_bound() to return the end of the table. If we
-//   compute D from that index, this will be considered D == 7, which will activate any "greater than 6" logic.
-
-// Floating-point is slightly more complicated.
-
-// The ordinary lookup tables are for X within [-5, 38] for float, and [-5, 308] for double.
-// (-5 absorbs too-negative exponents, outside the P > X >= -4 criterion. 38 and 308 are the maximum exponents.)
-// Due to the P > X condition, we can use a subset of the table for X within [-5, P - 1], suitably clamped.
-
-// When P is small, rounding can affect X. For example:
-// For P == 1, the largest double with X == 0 is: 9.4999999999999982236431605997495353221893310546875
-// For P == 2, the largest double with X == 0 is: 9.949999999999999289457264239899814128875732421875
-// For P == 3, the largest double with X == 0 is: 9.9949999999999992184029906638897955417633056640625
-
-// Exponent adjustment is a concern for P within [1, 7] for float, and [1, 15] for double (determined via
-// brute force). While larger values of P still perform rounding, they can't trigger exponent adjustment.
-// This is because only values with repeated '9' digits can undergo exponent adjustment during rounding,
-// and floating-point granularity limits the number of consecutive '9' digits that can appear.
-
-// So, we need special lookup tables for small values of P.
-// These tables have varying lengths due to the P > X >= -4 criterion. For example:
-// For P == 1, need table entries for X: -5, -4, -3, -2, -1, 0
-// For P == 2, need table entries for X: -5, -4, -3, -2, -1, 0, 1
-// For P == 3, need table entries for X: -5, -4, -3, -2, -1, 0, 1, 2
-// For P == 4, need table entries for X: -5, -4, -3, -2, -1, 0, 1, 2, 3
-
-// We can concatenate these tables for compact storage, using triangular numbers to access them.
-// The table for P begins at index (P - 1) * (P + 10) / 2 with length P + 5.
-
-// For both the ordinary and special lookup tables, after an index I is returned by lower_bound(), X is I - 5.
-
-// We need to special-case the floating-point value 0.0, which is considered to have X == 0.
-// Otherwise, the lookup tables would consider it to have a highly negative X.
-
-// Finally, because we're working with positive floating-point values,
-// representation comparisons behave identically to floating-point comparisons.
-
-// The following code generated the lookup tables for the scientific exponent X. Don't remove this code.
-#if 0
-// cl /EHsc /nologo /W4 /MT /O2 /std:c++17 generate_tables.cpp && generate_tables
-
-#include <algorithm>
-#include <assert.h>
-#include <charconv>
-#include <cmath>
-#include <limits>
-#include <map>
-#include <stdint.h>
-#include <stdio.h>
-#include <system_error>
-#include <type_traits>
-#include <vector>
-using namespace std;
-
-template <typename UInt, typename Pred>
-[[nodiscard]] UInt uint_partition_point(UInt first, const UInt last, Pred pred) {
-    // Find the beginning of the false partition in [first, last).
-    // [first, last) is partitioned when all of the true values occur before all of the false values.
-
-    static_assert(is_unsigned_v<UInt>);
-    assert(first <= last);
-
-    for (UInt n = last - first; n > 0;) {
-        const UInt n2  = n / 2;
-        const UInt mid = first + n2;
-
-        if (pred(mid)) {
-            first = mid + 1;
-            n     = n - n2 - 1;
-        } else {
-            n = n2;
-        }
-    }
-
-    return first;
-}
-
-template <typename Floating>
-[[nodiscard]] int scientific_exponent_X(const int P, const Floating flt) {
-    char buf[400]; // more than enough
-
-    // C11 7.21.6.1 "The fprintf function"/8 performs trial formatting with scientific precision P - 1.
-    const auto to_result = to_chars(buf, end(buf), flt, chars_format::scientific, P - 1);
-    assert(to_result.ec == errc{});
-
-    const char* exp_ptr = find(buf, to_result.ptr, 'e');
-    assert(exp_ptr != to_result.ptr);
-
-    ++exp_ptr; // advance past 'e'
-
-    if (*exp_ptr == '+') {
-        ++exp_ptr; // advance past '+' which from_chars() won't parse
-    }
-
-    int X;
-    const auto from_result = from_chars(exp_ptr, to_result.ptr, X);
-    assert(from_result.ec == errc{});
-    return X;
-}
-
-template <typename UInt>
-void print_table(const vector<UInt>& v, const char* const name) {
-    constexpr const char* UIntName = _IsSame<UInt, uint32_t>::value ? "uint32_t" : "uint64_t";
-
-    printf("static constexpr %s %s[%zu] = {\n", UIntName, name, v.size());
-
-    for (const auto& val : v) {
-        if constexpr (_IsSame<UInt, uint32_t>::value) {
-            printf("0x%08Xu,\n", val);
-        } else {
-            printf("0x%016llXu,\n", val);
-        }
-    }
-
-    printf("};\n");
-}
-
-enum class Mode { Tables, Tests };
-
-template <typename Floating>
-void generate_tables(const Mode mode) {
-    using Limits = numeric_limits<Floating>;
-    using UInt   = conditional_t<_IsSame<Floating, float>::value, uint32_t, uint64_t>;
-
-    map<int, map<int, UInt>> P_X_LargestValWithX;
-
-    constexpr int MaxP = Limits::max_exponent10 + 1; // MaxP performs no rounding during trial formatting
-
-    for (int P = 1; P <= MaxP; ++P) {
-        for (int X = -5; X < P; ++X) {
-            constexpr Floating first = static_cast<Floating>(9e-5); // well below 9.5e-5, otherwise arbitrary
-            constexpr Floating last  = Limits::infinity(); // one bit above Limits::max()
-
-            const UInt val_beyond_X = uint_partition_point(reinterpret_cast<const UInt&>(first),
-                reinterpret_cast<const UInt&>(last),
-                [P, X](const UInt u) { return scientific_exponent_X(P, reinterpret_cast<const Floating&>(u)) <= X; });
-
-            P_X_LargestValWithX[P][X] = val_beyond_X - 1;
-        }
-    }
-
-    constexpr const char* FloatingName = _IsSame<Floating, float>::value ? "float" : "double";
-
-    constexpr int MaxSpecialP = _IsSame<Floating, float>::value ? 7 : 15; // MaxSpecialP is affected by exponent adjustment
-
-    if (mode == Mode::Tables) {
-        printf("template <>\n");
-        printf("struct _General_precision_tables<%s> {\n", FloatingName);
-
-        printf("static constexpr int _Max_special_P = %d;\n", MaxSpecialP);
-
-        vector<UInt> special;
-
-        for (int P = 1; P <= MaxSpecialP; ++P) {
-            for (int X = -5; X < P; ++X) {
-                const UInt val = P_X_LargestValWithX[P][X];
-                special.push_back(val);
-            }
-        }
-
-        print_table(special, "_Special_X_table");
-
-        for (int P = MaxSpecialP + 1; P < MaxP; ++P) {
-            for (int X = -5; X < P; ++X) {
-                const UInt val = P_X_LargestValWithX[P][X];
-                assert(val == P_X_LargestValWithX[MaxP][X]);
-            }
-        }
-
-        printf("static constexpr int _Max_P = %d;\n", MaxP);
-
-        vector<UInt> ordinary;
-
-        for (int X = -5; X < MaxP; ++X) {
-            const UInt val = P_X_LargestValWithX[MaxP][X];
-            ordinary.push_back(val);
-        }
-
-        print_table(ordinary, "_Ordinary_X_table");
-
-        printf("};\n");
-    } else {
-        printf("==========\n");
-        printf("Test cases for %s:\n", FloatingName);
-
-        constexpr int Hexits         = _IsSame<Floating, float>::value ? 6 : 13;
-        constexpr const char* Suffix = _IsSame<Floating, float>::value ? "f" : "";
-
-        for (int P = 1; P <= MaxP; ++P) {
-            for (int X = -5; X < P; ++X) {
-                if (P <= MaxSpecialP || P == 25 || P == MaxP || X == P - 1) {
-                    const UInt val1   = P_X_LargestValWithX[P][X];
-                    const Floating f1 = reinterpret_cast<const Floating&>(val1);
-                    const UInt val2   = val1 + 1;
-                    const Floating f2 = reinterpret_cast<const Floating&>(val2);
-
-                    printf("{%.*a%s, chars_format::general, %d, \"%.*g\"},\n", Hexits, f1, Suffix, P, P, f1);
-                    if (isfinite(f2)) {
-                        printf("{%.*a%s, chars_format::general, %d, \"%.*g\"},\n", Hexits, f2, Suffix, P, P, f2);
-                    }
-                }
-            }
-        }
-    }
-}
-
-int main() {
-    printf("template <class _Floating>\n");
-    printf("struct _General_precision_tables;\n");
-    generate_tables<float>(Mode::Tables);
-    generate_tables<double>(Mode::Tables);
-    generate_tables<float>(Mode::Tests);
-    generate_tables<double>(Mode::Tests);
-}
-#endif // 0
-
-template <class _Floating>
-struct _General_precision_tables;
-
-template <>
-struct _General_precision_tables<float> {
-    static constexpr int _Max_special_P = 7;
-
-    static constexpr uint32_t _Special_X_table[63] = {0x38C73ABCu, 0x3A79096Bu, 0x3C1BA5E3u, 0x3DC28F5Cu, 0x3F733333u,
-        0x4117FFFFu, 0x38D0AAA7u, 0x3A826AA8u, 0x3C230553u, 0x3DCBC6A7u, 0x3F7EB851u, 0x411F3333u, 0x42C6FFFFu,
-        0x38D19C3Fu, 0x3A8301A7u, 0x3C23C211u, 0x3DCCB295u, 0x3F7FDF3Bu, 0x411FEB85u, 0x42C7E666u, 0x4479DFFFu,
-        0x38D1B468u, 0x3A8310C1u, 0x3C23D4F1u, 0x3DCCCA2Du, 0x3F7FFCB9u, 0x411FFDF3u, 0x42C7FD70u, 0x4479FCCCu,
-        0x461C3DFFu, 0x38D1B6D2u, 0x3A831243u, 0x3C23D6D4u, 0x3DCCCC89u, 0x3F7FFFACu, 0x411FFFCBu, 0x42C7FFBEu,
-        0x4479FFAEu, 0x461C3FCCu, 0x47C34FBFu, 0x38D1B710u, 0x3A83126Au, 0x3C23D704u, 0x3DCCCCC6u, 0x3F7FFFF7u,
-        0x411FFFFAu, 0x42C7FFF9u, 0x4479FFF7u, 0x461C3FFAu, 0x47C34FF9u, 0x497423F7u, 0x38D1B716u, 0x3A83126Eu,
-        0x3C23D709u, 0x3DCCCCCCu, 0x3F7FFFFFu, 0x411FFFFFu, 0x42C7FFFFu, 0x4479FFFFu, 0x461C3FFFu, 0x47C34FFFu,
-        0x497423FFu, 0x4B18967Fu};
-
-    static constexpr int _Max_P = 39;
-
-    static constexpr uint32_t _Ordinary_X_table[44] = {0x38D1B717u, 0x3A83126Eu, 0x3C23D70Au, 0x3DCCCCCCu, 0x3F7FFFFFu,
-        0x411FFFFFu, 0x42C7FFFFu, 0x4479FFFFu, 0x461C3FFFu, 0x47C34FFFu, 0x497423FFu, 0x4B18967Fu, 0x4CBEBC1Fu,
-        0x4E6E6B27u, 0x501502F8u, 0x51BA43B7u, 0x5368D4A5u, 0x551184E7u, 0x56B5E620u, 0x58635FA9u, 0x5A0E1BC9u,
-        0x5BB1A2BCu, 0x5D5E0B6Bu, 0x5F0AC723u, 0x60AD78EBu, 0x6258D726u, 0x64078678u, 0x65A96816u, 0x6753C21Bu,
-        0x69045951u, 0x6AA56FA5u, 0x6C4ECB8Fu, 0x6E013F39u, 0x6FA18F07u, 0x7149F2C9u, 0x72FC6F7Cu, 0x749DC5ADu,
-        0x76453719u, 0x77F684DFu, 0x799A130Bu, 0x7B4097CEu, 0x7CF0BDC2u, 0x7E967699u, 0x7F7FFFFFu};
-};
-
-template <>
-struct _General_precision_tables<double> {
-    static constexpr int _Max_special_P = 15;
-
-    static constexpr uint64_t _Special_X_table[195] = {0x3F18E757928E0C9Du, 0x3F4F212D77318FC5u, 0x3F8374BC6A7EF9DBu,
-        0x3FB851EB851EB851u, 0x3FEE666666666666u, 0x4022FFFFFFFFFFFFu, 0x3F1A1554FBDAD751u, 0x3F504D551D68C692u,
-        0x3F8460AA64C2F837u, 0x3FB978D4FDF3B645u, 0x3FEFD70A3D70A3D7u, 0x4023E66666666666u, 0x4058DFFFFFFFFFFFu,
-        0x3F1A3387ECC8EB96u, 0x3F506034F3FD933Eu, 0x3F84784230FCF80Du, 0x3FB99652BD3C3611u, 0x3FEFFBE76C8B4395u,
-        0x4023FD70A3D70A3Du, 0x4058FCCCCCCCCCCCu, 0x408F3BFFFFFFFFFFu, 0x3F1A368D04E0BA6Au, 0x3F506218230C7482u,
-        0x3F847A9E2BCF91A3u, 0x3FB99945B6C3760Bu, 0x3FEFFF972474538Eu, 0x4023FFBE76C8B439u, 0x4058FFAE147AE147u,
-        0x408F3F9999999999u, 0x40C387BFFFFFFFFFu, 0x3F1A36DA54164F19u, 0x3F506248748DF16Fu, 0x3F847ADA91B16DCBu,
-        0x3FB99991361DC93Eu, 0x3FEFFFF583A53B8Eu, 0x4023FFF972474538u, 0x4058FFF7CED91687u, 0x408F3FF5C28F5C28u,
-        0x40C387F999999999u, 0x40F869F7FFFFFFFFu, 0x3F1A36E20F35445Du, 0x3F50624D49814ABAu, 0x3F847AE09BE19D69u,
-        0x3FB99998C2DA04C3u, 0x3FEFFFFEF39085F4u, 0x4023FFFF583A53B8u, 0x4058FFFF2E48E8A7u, 0x408F3FFEF9DB22D0u,
-        0x40C387FF5C28F5C2u, 0x40F869FF33333333u, 0x412E847EFFFFFFFFu, 0x3F1A36E2D51EC34Bu, 0x3F50624DC5333A0Eu,
-        0x3F847AE136800892u, 0x3FB9999984200AB7u, 0x3FEFFFFFE5280D65u, 0x4023FFFFEF39085Fu, 0x4058FFFFEB074A77u,
-        0x408F3FFFE5C91D14u, 0x40C387FFEF9DB22Du, 0x40F869FFEB851EB8u, 0x412E847FE6666666u, 0x416312CFEFFFFFFFu,
-        0x3F1A36E2E8E94FFCu, 0x3F50624DD191D1FDu, 0x3F847AE145F6467Du, 0x3FB999999773D81Cu, 0x3FEFFFFFFD50CE23u,
-        0x4023FFFFFE5280D6u, 0x4058FFFFFDE7210Bu, 0x408F3FFFFD60E94Eu, 0x40C387FFFE5C91D1u, 0x40F869FFFDF3B645u,
-        0x412E847FFD70A3D7u, 0x416312CFFE666666u, 0x4197D783FDFFFFFFu, 0x3F1A36E2EAE3F7A7u, 0x3F50624DD2CE7AC8u,
-        0x3F847AE14782197Bu, 0x3FB9999999629FD9u, 0x3FEFFFFFFFBB47D0u, 0x4023FFFFFFD50CE2u, 0x4058FFFFFFCA501Au,
-        0x408F3FFFFFBCE421u, 0x40C387FFFFD60E94u, 0x40F869FFFFCB923Au, 0x412E847FFFBE76C8u, 0x416312CFFFD70A3Du,
-        0x4197D783FFCCCCCCu, 0x41CDCD64FFBFFFFFu, 0x3F1A36E2EB16A205u, 0x3F50624DD2EE2543u, 0x3F847AE147A9AE94u,
-        0x3FB9999999941A39u, 0x3FEFFFFFFFF920C8u, 0x4023FFFFFFFBB47Du, 0x4058FFFFFFFAA19Cu, 0x408F3FFFFFF94A03u,
-        0x40C387FFFFFBCE42u, 0x40F869FFFFFAC1D2u, 0x412E847FFFF97247u, 0x416312CFFFFBE76Cu, 0x4197D783FFFAE147u,
-        0x41CDCD64FFF99999u, 0x4202A05F1FFBFFFFu, 0x3F1A36E2EB1BB30Fu, 0x3F50624DD2F14FE9u, 0x3F847AE147ADA3E3u,
-        0x3FB9999999990CDCu, 0x3FEFFFFFFFFF5014u, 0x4023FFFFFFFF920Cu, 0x4058FFFFFFFF768Fu, 0x408F3FFFFFFF5433u,
-        0x40C387FFFFFF94A0u, 0x40F869FFFFFF79C8u, 0x412E847FFFFF583Au, 0x416312CFFFFF9724u, 0x4197D783FFFF7CEDu,
-        0x41CDCD64FFFF5C28u, 0x4202A05F1FFF9999u, 0x42374876E7FF7FFFu, 0x3F1A36E2EB1C34C3u, 0x3F50624DD2F1A0FAu,
-        0x3F847AE147AE0938u, 0x3FB9999999998B86u, 0x3FEFFFFFFFFFEE68u, 0x4023FFFFFFFFF501u, 0x4058FFFFFFFFF241u,
-        0x408F3FFFFFFFEED1u, 0x40C387FFFFFFF543u, 0x40F869FFFFFFF294u, 0x412E847FFFFFEF39u, 0x416312CFFFFFF583u,
-        0x4197D783FFFFF2E4u, 0x41CDCD64FFFFEF9Du, 0x4202A05F1FFFF5C2u, 0x42374876E7FFF333u, 0x426D1A94A1FFEFFFu,
-        0x3F1A36E2EB1C41BBu, 0x3F50624DD2F1A915u, 0x3F847AE147AE135Au, 0x3FB9999999999831u, 0x3FEFFFFFFFFFFE3Du,
-        0x4023FFFFFFFFFEE6u, 0x4058FFFFFFFFFEA0u, 0x408F3FFFFFFFFE48u, 0x40C387FFFFFFFEEDu, 0x40F869FFFFFFFEA8u,
-        0x412E847FFFFFFE52u, 0x416312CFFFFFFEF3u, 0x4197D783FFFFFEB0u, 0x41CDCD64FFFFFE5Cu, 0x4202A05F1FFFFEF9u,
-        0x42374876E7FFFEB8u, 0x426D1A94A1FFFE66u, 0x42A2309CE53FFEFFu, 0x3F1A36E2EB1C4307u, 0x3F50624DD2F1A9E4u,
-        0x3F847AE147AE145Eu, 0x3FB9999999999975u, 0x3FEFFFFFFFFFFFD2u, 0x4023FFFFFFFFFFE3u, 0x4058FFFFFFFFFFDCu,
-        0x408F3FFFFFFFFFD4u, 0x40C387FFFFFFFFE4u, 0x40F869FFFFFFFFDDu, 0x412E847FFFFFFFD5u, 0x416312CFFFFFFFE5u,
-        0x4197D783FFFFFFDEu, 0x41CDCD64FFFFFFD6u, 0x4202A05F1FFFFFE5u, 0x42374876E7FFFFDFu, 0x426D1A94A1FFFFD7u,
-        0x42A2309CE53FFFE6u, 0x42D6BCC41E8FFFDFu, 0x3F1A36E2EB1C4328u, 0x3F50624DD2F1A9F9u, 0x3F847AE147AE1477u,
-        0x3FB9999999999995u, 0x3FEFFFFFFFFFFFFBu, 0x4023FFFFFFFFFFFDu, 0x4058FFFFFFFFFFFCu, 0x408F3FFFFFFFFFFBu,
-        0x40C387FFFFFFFFFDu, 0x40F869FFFFFFFFFCu, 0x412E847FFFFFFFFBu, 0x416312CFFFFFFFFDu, 0x4197D783FFFFFFFCu,
-        0x41CDCD64FFFFFFFBu, 0x4202A05F1FFFFFFDu, 0x42374876E7FFFFFCu, 0x426D1A94A1FFFFFBu, 0x42A2309CE53FFFFDu,
-        0x42D6BCC41E8FFFFCu, 0x430C6BF52633FFFBu};
-
-    static constexpr int _Max_P = 309;
-
-    static constexpr uint64_t _Ordinary_X_table[314] = {0x3F1A36E2EB1C432Cu, 0x3F50624DD2F1A9FBu, 0x3F847AE147AE147Au,
-        0x3FB9999999999999u, 0x3FEFFFFFFFFFFFFFu, 0x4023FFFFFFFFFFFFu, 0x4058FFFFFFFFFFFFu, 0x408F3FFFFFFFFFFFu,
-        0x40C387FFFFFFFFFFu, 0x40F869FFFFFFFFFFu, 0x412E847FFFFFFFFFu, 0x416312CFFFFFFFFFu, 0x4197D783FFFFFFFFu,
-        0x41CDCD64FFFFFFFFu, 0x4202A05F1FFFFFFFu, 0x42374876E7FFFFFFu, 0x426D1A94A1FFFFFFu, 0x42A2309CE53FFFFFu,
-        0x42D6BCC41E8FFFFFu, 0x430C6BF52633FFFFu, 0x4341C37937E07FFFu, 0x4376345785D89FFFu, 0x43ABC16D674EC7FFu,
-        0x43E158E460913CFFu, 0x4415AF1D78B58C3Fu, 0x444B1AE4D6E2EF4Fu, 0x4480F0CF064DD591u, 0x44B52D02C7E14AF6u,
-        0x44EA784379D99DB4u, 0x45208B2A2C280290u, 0x4554ADF4B7320334u, 0x4589D971E4FE8401u, 0x45C027E72F1F1281u,
-        0x45F431E0FAE6D721u, 0x46293E5939A08CE9u, 0x465F8DEF8808B024u, 0x4693B8B5B5056E16u, 0x46C8A6E32246C99Cu,
-        0x46FED09BEAD87C03u, 0x4733426172C74D82u, 0x476812F9CF7920E2u, 0x479E17B84357691Bu, 0x47D2CED32A16A1B1u,
-        0x48078287F49C4A1Du, 0x483D6329F1C35CA4u, 0x48725DFA371A19E6u, 0x48A6F578C4E0A060u, 0x48DCB2D6F618C878u,
-        0x4911EFC659CF7D4Bu, 0x49466BB7F0435C9Eu, 0x497C06A5EC5433C6u, 0x49B18427B3B4A05Bu, 0x49E5E531A0A1C872u,
-        0x4A1B5E7E08CA3A8Fu, 0x4A511B0EC57E6499u, 0x4A8561D276DDFDC0u, 0x4ABABA4714957D30u, 0x4AF0B46C6CDD6E3Eu,
-        0x4B24E1878814C9CDu, 0x4B5A19E96A19FC40u, 0x4B905031E2503DA8u, 0x4BC4643E5AE44D12u, 0x4BF97D4DF19D6057u,
-        0x4C2FDCA16E04B86Du, 0x4C63E9E4E4C2F344u, 0x4C98E45E1DF3B015u, 0x4CCF1D75A5709C1Au, 0x4D03726987666190u,
-        0x4D384F03E93FF9F4u, 0x4D6E62C4E38FF872u, 0x4DA2FDBB0E39FB47u, 0x4DD7BD29D1C87A19u, 0x4E0DAC74463A989Fu,
-        0x4E428BC8ABE49F63u, 0x4E772EBAD6DDC73Cu, 0x4EACFA698C95390Bu, 0x4EE21C81F7DD43A7u, 0x4F16A3A275D49491u,
-        0x4F4C4C8B1349B9B5u, 0x4F81AFD6EC0E1411u, 0x4FB61BCCA7119915u, 0x4FEBA2BFD0D5FF5Bu, 0x502145B7E285BF98u,
-        0x50559725DB272F7Fu, 0x508AFCEF51F0FB5Eu, 0x50C0DE1593369D1Bu, 0x50F5159AF8044462u, 0x512A5B01B605557Au,
-        0x516078E111C3556Cu, 0x5194971956342AC7u, 0x51C9BCDFABC13579u, 0x5200160BCB58C16Cu, 0x52341B8EBE2EF1C7u,
-        0x526922726DBAAE39u, 0x529F6B0F092959C7u, 0x52D3A2E965B9D81Cu, 0x53088BA3BF284E23u, 0x533EAE8CAEF261ACu,
-        0x53732D17ED577D0Bu, 0x53A7F85DE8AD5C4Eu, 0x53DDF67562D8B362u, 0x5412BA095DC7701Du, 0x5447688BB5394C25u,
-        0x547D42AEA2879F2Eu, 0x54B249AD2594C37Cu, 0x54E6DC186EF9F45Cu, 0x551C931E8AB87173u, 0x5551DBF316B346E7u,
-        0x558652EFDC6018A1u, 0x55BBE7ABD3781ECAu, 0x55F170CB642B133Eu, 0x5625CCFE3D35D80Eu, 0x565B403DCC834E11u,
-        0x569108269FD210CBu, 0x56C54A3047C694FDu, 0x56FA9CBC59B83A3Du, 0x5730A1F5B8132466u, 0x5764CA732617ED7Fu,
-        0x5799FD0FEF9DE8DFu, 0x57D03E29F5C2B18Bu, 0x58044DB473335DEEu, 0x583961219000356Au, 0x586FB969F40042C5u,
-        0x58A3D3E2388029BBu, 0x58D8C8DAC6A0342Au, 0x590EFB1178484134u, 0x59435CEAEB2D28C0u, 0x59783425A5F872F1u,
-        0x59AE412F0F768FADu, 0x59E2E8BD69AA19CCu, 0x5A17A2ECC414A03Fu, 0x5A4D8BA7F519C84Fu, 0x5A827748F9301D31u,
-        0x5AB7151B377C247Eu, 0x5AECDA62055B2D9Du, 0x5B22087D4358FC82u, 0x5B568A9C942F3BA3u, 0x5B8C2D43B93B0A8Bu,
-        0x5BC19C4A53C4E697u, 0x5BF6035CE8B6203Du, 0x5C2B843422E3A84Cu, 0x5C6132A095CE492Fu, 0x5C957F48BB41DB7Bu,
-        0x5CCADF1AEA12525Au, 0x5D00CB70D24B7378u, 0x5D34FE4D06DE5056u, 0x5D6A3DE04895E46Cu, 0x5DA066AC2D5DAEC3u,
-        0x5DD4805738B51A74u, 0x5E09A06D06E26112u, 0x5E400444244D7CABu, 0x5E7405552D60DBD6u, 0x5EA906AA78B912CBu,
-        0x5EDF485516E7577Eu, 0x5F138D352E5096AFu, 0x5F48708279E4BC5Au, 0x5F7E8CA3185DEB71u, 0x5FB317E5EF3AB327u,
-        0x5FE7DDDF6B095FF0u, 0x601DD55745CBB7ECu, 0x6052A5568B9F52F4u, 0x60874EAC2E8727B1u, 0x60BD22573A28F19Du,
-        0x60F2357684599702u, 0x6126C2D4256FFCC2u, 0x615C73892ECBFBF3u, 0x6191C835BD3F7D78u, 0x61C63A432C8F5CD6u,
-        0x61FBC8D3F7B3340Bu, 0x62315D847AD00087u, 0x6265B4E5998400A9u, 0x629B221EFFE500D3u, 0x62D0F5535FEF2084u,
-        0x630532A837EAE8A5u, 0x633A7F5245E5A2CEu, 0x63708F936BAF85C1u, 0x63A4B378469B6731u, 0x63D9E056584240FDu,
-        0x64102C35F729689Eu, 0x6444374374F3C2C6u, 0x647945145230B377u, 0x64AF965966BCE055u, 0x64E3BDF7E0360C35u,
-        0x6518AD75D8438F43u, 0x654ED8D34E547313u, 0x6583478410F4C7ECu, 0x65B819651531F9E7u, 0x65EE1FBE5A7E7861u,
-        0x6622D3D6F88F0B3Cu, 0x665788CCB6B2CE0Cu, 0x668D6AFFE45F818Fu, 0x66C262DFEEBBB0F9u, 0x66F6FB97EA6A9D37u,
-        0x672CBA7DE5054485u, 0x6761F48EAF234AD3u, 0x679671B25AEC1D88u, 0x67CC0E1EF1A724EAu, 0x680188D357087712u,
-        0x6835EB082CCA94D7u, 0x686B65CA37FD3A0Du, 0x68A11F9E62FE4448u, 0x68D56785FBBDD55Au, 0x690AC1677AAD4AB0u,
-        0x6940B8E0ACAC4EAEu, 0x6974E718D7D7625Au, 0x69AA20DF0DCD3AF0u, 0x69E0548B68A044D6u, 0x6A1469AE42C8560Cu,
-        0x6A498419D37A6B8Fu, 0x6A7FE52048590672u, 0x6AB3EF342D37A407u, 0x6AE8EB0138858D09u, 0x6B1F25C186A6F04Cu,
-        0x6B537798F428562Fu, 0x6B88557F31326BBBu, 0x6BBE6ADEFD7F06AAu, 0x6BF302CB5E6F642Au, 0x6C27C37E360B3D35u,
-        0x6C5DB45DC38E0C82u, 0x6C9290BA9A38C7D1u, 0x6CC734E940C6F9C5u, 0x6CFD022390F8B837u, 0x6D3221563A9B7322u,
-        0x6D66A9ABC9424FEBu, 0x6D9C5416BB92E3E6u, 0x6DD1B48E353BCE6Fu, 0x6E0621B1C28AC20Bu, 0x6E3BAA1E332D728Eu,
-        0x6E714A52DFFC6799u, 0x6EA59CE797FB817Fu, 0x6EDB04217DFA61DFu, 0x6F10E294EEBC7D2Bu, 0x6F451B3A2A6B9C76u,
-        0x6F7A6208B5068394u, 0x6FB07D457124123Cu, 0x6FE49C96CD6D16CBu, 0x7019C3BC80C85C7Eu, 0x70501A55D07D39CFu,
-        0x708420EB449C8842u, 0x70B9292615C3AA53u, 0x70EF736F9B3494E8u, 0x7123A825C100DD11u, 0x7158922F31411455u,
-        0x718EB6BAFD91596Bu, 0x71C33234DE7AD7E2u, 0x71F7FEC216198DDBu, 0x722DFE729B9FF152u, 0x7262BF07A143F6D3u,
-        0x72976EC98994F488u, 0x72CD4A7BEBFA31AAu, 0x73024E8D737C5F0Au, 0x7336E230D05B76CDu, 0x736C9ABD04725480u,
-        0x73A1E0B622C774D0u, 0x73D658E3AB795204u, 0x740BEF1C9657A685u, 0x74417571DDF6C813u, 0x7475D2CE55747A18u,
-        0x74AB4781EAD1989Eu, 0x74E10CB132C2FF63u, 0x75154FDD7F73BF3Bu, 0x754AA3D4DF50AF0Au, 0x7580A6650B926D66u,
-        0x75B4CFFE4E7708C0u, 0x75EA03FDE214CAF0u, 0x7620427EAD4CFED6u, 0x7654531E58A03E8Bu, 0x768967E5EEC84E2Eu,
-        0x76BFC1DF6A7A61BAu, 0x76F3D92BA28C7D14u, 0x7728CF768B2F9C59u, 0x775F03542DFB8370u, 0x779362149CBD3226u,
-        0x77C83A99C3EC7EAFu, 0x77FE494034E79E5Bu, 0x7832EDC82110C2F9u, 0x7867A93A2954F3B7u, 0x789D9388B3AA30A5u,
-        0x78D27C35704A5E67u, 0x79071B42CC5CF601u, 0x793CE2137F743381u, 0x79720D4C2FA8A030u, 0x79A6909F3B92C83Du,
-        0x79DC34C70A777A4Cu, 0x7A11A0FC668AAC6Fu, 0x7A46093B802D578Bu, 0x7A7B8B8A6038AD6Eu, 0x7AB137367C236C65u,
-        0x7AE585041B2C477Eu, 0x7B1AE64521F7595Eu, 0x7B50CFEB353A97DAu, 0x7B8503E602893DD1u, 0x7BBA44DF832B8D45u,
-        0x7BF06B0BB1FB384Bu, 0x7C2485CE9E7A065Eu, 0x7C59A742461887F6u, 0x7C9008896BCF54F9u, 0x7CC40AABC6C32A38u,
-        0x7CF90D56B873F4C6u, 0x7D2F50AC6690F1F8u, 0x7D63926BC01A973Bu, 0x7D987706B0213D09u, 0x7DCE94C85C298C4Cu,
-        0x7E031CFD3999F7AFu, 0x7E37E43C8800759Bu, 0x7E6DDD4BAA009302u, 0x7EA2AA4F4A405BE1u, 0x7ED754E31CD072D9u,
-        0x7F0D2A1BE4048F90u, 0x7F423A516E82D9BAu, 0x7F76C8E5CA239028u, 0x7FAC7B1F3CAC7433u, 0x7FE1CCF385EBC89Fu,
-        0x7FEFFFFFFFFFFFFFu};
-};
-
-template <class _Floating>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-to_chars_result _Floating_to_chars_general_precision(
-    char* _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {
-
-    using _Traits    = _Floating_type_traits<_Floating>;
-    using _Uint_type = typename _Traits::_Uint_type;
-
-    const _Uint_type _Uint_value = _VSTD::bit_cast<_Uint_type>(_Value);
-
-    if (_Uint_value == 0) { // zero detected; write "0" and return; _Precision is irrelevant due to zero-trimming
-        if (_First == _Last) {
-            return {_Last, errc::value_too_large};
-        }
-
-        *_First++ = '0';
-
-        return {_First, errc{}};
-    }
-
-    // C11 7.21.6.1 "The fprintf function"/5:
-    // "A negative precision argument is taken as if the precision were omitted."
-    // /8: "g,G [...] Let P equal the precision if nonzero, 6 if the precision is omitted,
-    // or 1 if the precision is zero."
-
-    // Performance note: It's possible to rewrite this for branchless codegen,
-    // but profiling will be necessary to determine whether that's faster.
-    if (_Precision < 0) {
-        _Precision = 6;
-    } else if (_Precision == 0) {
-        _Precision = 1;
-    } else if (_Precision < 1'000'000) {
-        // _Precision is ok.
-    } else {
-        // Avoid integer overflow.
-        // Due to general notation's zero-trimming behavior, we can simply clamp _Precision.
-        // This is further clamped below.
-        _Precision = 1'000'000;
-    }
-
-    // _Precision is now the Standard's P.
-
-    // /8: "Then, if a conversion with style E would have an exponent of X:
-    // - if P > X >= -4, the conversion is with style f (or F) and precision P - (X + 1).
-    // - otherwise, the conversion is with style e (or E) and precision P - 1."
-
-    // /8: "Finally, [...] any trailing zeros are removed from the fractional portion of the result
-    // and the decimal-point character is removed if there is no fractional portion remaining."
-
-    using _Tables = _General_precision_tables<_Floating>;
-
-    const _Uint_type* _Table_begin;
-    const _Uint_type* _Table_end;
-
-    if (_Precision <= _Tables::_Max_special_P) {
-        _Table_begin = _Tables::_Special_X_table + (_Precision - 1) * (_Precision + 10) / 2;
-        _Table_end   = _Table_begin + _Precision + 5;
-    } else {
-        _Table_begin = _Tables::_Ordinary_X_table;
-        _Table_end   = _Table_begin + _VSTD::min(_Precision, _Tables::_Max_P) + 5;
-    }
-
-    // Profiling indicates that linear search is faster than binary search for small tables.
-    // Performance note: lambda captures may have a small performance cost.
-    const _Uint_type* const _Table_lower_bound = [=] {
-        if constexpr (!_IsSame<_Floating, float>::value) {
-            if (_Precision > 155) { // threshold determined via profiling
-                return _VSTD::lower_bound(_Table_begin, _Table_end, _Uint_value, less{});
-            }
-        }
-
-        return _VSTD::find_if(_Table_begin, _Table_end, [=](const _Uint_type _Elem) { return _Uint_value <= _Elem; });
-    }();
-
-    const ptrdiff_t _Table_index     = _Table_lower_bound - _Table_begin;
-    const int _Scientific_exponent_X = static_cast<int>(_Table_index - 5);
-    const bool _Use_fixed_notation   = _Precision > _Scientific_exponent_X && _Scientific_exponent_X >= -4;
-
-    // Performance note: it might (or might not) be faster to modify Ryu Printf to perform zero-trimming.
-    // Such modifications would involve a fairly complicated state machine (notably, both '0' and '9' digits would
-    // need to be buffered, due to rounding), and that would have performance costs due to increased branching.
-    // Here, we're using a simpler approach: writing into a local buffer, manually zero-trimming, and then copying into
-    // the output range. The necessary buffer size is reasonably small, the zero-trimming logic is simple and fast,
-    // and the final copying is also fast.
-
-    constexpr int _Max_output_length =
-        _IsSame<_Floating, float>::value ? 117 : 773; // cases: 0x1.fffffep-126f and 0x1.fffffffffffffp-1022
-    constexpr int _Max_fixed_precision =
-        _IsSame<_Floating, float>::value ? 37 : 66; // cases: 0x1.fffffep-14f and 0x1.fffffffffffffp-14
-    constexpr int _Max_scientific_precision =
-        _IsSame<_Floating, float>::value ? 111 : 766; // cases: 0x1.fffffep-126f and 0x1.fffffffffffffp-1022
-
-    // Note that _Max_output_length is determined by scientific notation and is more than enough for fixed notation.
-    // 0x1.fffffep+127f is 39 digits, plus 1 for '.', plus _Max_fixed_precision for '0' digits, equals 77.
-    // 0x1.fffffffffffffp+1023 is 309 digits, plus 1 for '.', plus _Max_fixed_precision for '0' digits, equals 376.
-
-    char _Buffer[_Max_output_length];
-    const char* const _Significand_first = _Buffer; // e.g. "1.234"
-    const char* _Significand_last        = nullptr;
-    const char* _Exponent_first          = nullptr; // e.g. "e-05"
-    const char* _Exponent_last           = nullptr;
-    int _Effective_precision; // number of digits printed after the decimal point, before trimming
-
-    // Write into the local buffer.
-    // Clamping _Effective_precision allows _Buffer to be as small as possible, and increases efficiency.
-    if (_Use_fixed_notation) {
-        _Effective_precision = _VSTD::min(_Precision - (_Scientific_exponent_X + 1), _Max_fixed_precision);
-        const to_chars_result _Buf_result =
-            _Floating_to_chars_fixed_precision(_Buffer, _VSTD::end(_Buffer), _Value, _Effective_precision);
-        _LIBCPP_ASSERT(_Buf_result.ec == errc{}, "");
-        _Significand_last = _Buf_result.ptr;
-    } else {
-        _Effective_precision = _VSTD::min(_Precision - 1, _Max_scientific_precision);
-        const to_chars_result _Buf_result =
-            _Floating_to_chars_scientific_precision(_Buffer, _VSTD::end(_Buffer), _Value, _Effective_precision);
-        _LIBCPP_ASSERT(_Buf_result.ec == errc{}, "");
-        _Significand_last = _VSTD::find(_Buffer, _Buf_result.ptr, 'e');
-        _Exponent_first   = _Significand_last;
-        _Exponent_last    = _Buf_result.ptr;
-    }
-
-    // If we printed a decimal point followed by digits, perform zero-trimming.
-    if (_Effective_precision > 0) {
-        while (_Significand_last[-1] == '0') { // will stop at '.' or a nonzero digit
-            --_Significand_last;
-        }
-
-        if (_Significand_last[-1] == '.') {
-            --_Significand_last;
-        }
-    }
-
-    // Copy the significand to the output range.
-    const ptrdiff_t _Significand_distance = _Significand_last - _Significand_first;
-    if (_Last - _First < _Significand_distance) {
-        return {_Last, errc::value_too_large};
-    }
-    _VSTD::memcpy(_First, _Significand_first, static_cast<size_t>(_Significand_distance));
-    _First += _Significand_distance;
-
-    // Copy the exponent to the output range.
-    if (!_Use_fixed_notation) {
-        const ptrdiff_t _Exponent_distance = _Exponent_last - _Exponent_first;
-        if (_Last - _First < _Exponent_distance) {
-            return {_Last, errc::value_too_large};
-        }
-        _VSTD::memcpy(_First, _Exponent_first, static_cast<size_t>(_Exponent_distance));
-        _First += _Exponent_distance;
-    }
-
-    return {_First, errc{}};
-}
-
-enum class _Floating_to_chars_overload { _Plain, _Format_only, _Format_precision };
-
-template <_Floating_to_chars_overload _Overload, class _Floating>
-[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
-to_chars_result _Floating_to_chars(
-    char* _First, char* const _Last, _Floating _Value, const chars_format _Fmt, const int _Precision) noexcept {
-
-    if constexpr (_Overload == _Floating_to_chars_overload::_Plain) {
-        _LIBCPP_ASSERT(_Fmt == chars_format{}, ""); // plain overload must pass chars_format{} internally
-    } else {
-        _LIBCPP_ASSERT(_Fmt == chars_format::general || _Fmt == chars_format::scientific || _Fmt == chars_format::fixed
-                         || _Fmt == chars_format::hex,
-            "invalid format in to_chars()");
-    }
-
-    using _Traits    = _Floating_type_traits<_Floating>;
-    using _Uint_type = typename _Traits::_Uint_type;
-
-    _Uint_type _Uint_value = _VSTD::bit_cast<_Uint_type>(_Value);
-
-    const bool _Was_negative = (_Uint_value & _Traits::_Shifted_sign_mask) != 0;
-
-    if (_Was_negative) { // sign bit detected; write minus sign and clear sign bit
-        if (_First == _Last) {
-            return {_Last, errc::value_too_large};
-        }
-
-        *_First++ = '-';
-
-        _Uint_value &= ~_Traits::_Shifted_sign_mask;
-        _Value = _VSTD::bit_cast<_Floating>(_Uint_value);
-    }
-
-    if ((_Uint_value & _Traits::_Shifted_exponent_mask) == _Traits::_Shifted_exponent_mask) {
-        // inf/nan detected; write appropriate string and return
-        const char* _Str;
-        size_t _Len;
-
-        const _Uint_type _Mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
-
-        if (_Mantissa == 0) {
-            _Str = "inf";
-            _Len = 3;
-        } else if (_Was_negative && _Mantissa == _Traits::_Special_nan_mantissa_mask) {
-            // When a NaN value has the sign bit set, the quiet bit set, and all other mantissa bits cleared,
-            // the UCRT interprets it to mean "indeterminate", and indicates this by printing "-nan(ind)".
-            _Str = "nan(ind)";
-            _Len = 8;
-        } else if ((_Mantissa & _Traits::_Special_nan_mantissa_mask) != 0) {
-            _Str = "nan";
-            _Len = 3;
-        } else {
-            _Str = "nan(snan)";
-            _Len = 9;
-        }
-
-        if (_Last - _First < static_cast<ptrdiff_t>(_Len)) {
-            return {_Last, errc::value_too_large};
-        }
-
-        _VSTD::memcpy(_First, _Str, _Len);
-
-        return {_First + _Len, errc{}};
-    }
-
-    if constexpr (_Overload == _Floating_to_chars_overload::_Plain) {
-        return _Floating_to_chars_ryu(_First, _Last, _Value, chars_format{});
-    } else if constexpr (_Overload == _Floating_to_chars_overload::_Format_only) {
-        if (_Fmt == chars_format::hex) {
-            return _Floating_to_chars_hex_shortest(_First, _Last, _Value);
-        }
-
-        return _Floating_to_chars_ryu(_First, _Last, _Value, _Fmt);
-    } else if constexpr (_Overload == _Floating_to_chars_overload::_Format_precision) {
-        switch (_Fmt) {
-        case chars_format::scientific:
-            return _Floating_to_chars_scientific_precision(_First, _Last, _Value, _Precision);
-        case chars_format::fixed:
-            return _Floating_to_chars_fixed_precision(_First, _Last, _Value, _Precision);
-        case chars_format::general:
-            return _Floating_to_chars_general_precision(_First, _Last, _Value, _Precision);
-        case chars_format::hex:
-        default: // avoid MSVC warning C4715: not all control paths return a value
-            return _Floating_to_chars_hex_precision(_First, _Last, _Value, _Precision);
-        }
-    }
-}
-
-// clang-format on
-
-_LIBCPP_END_NAMESPACE_STD
-
-#pragma GCC diagnostic pop
-
-#endif // _LIBCPP_SRC_INCLUDE_TO_CHARS_FLOATING_POINT_H
diff --git a/third_party/libcxx/src/ios.cpp b/third_party/libcxx/src/ios.cpp
deleted file mode 100644
index 64d8f773c..000000000
--- a/third_party/libcxx/src/ios.cpp
+++ /dev/null
@@ -1,443 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-#include <__locale>
-#include <algorithm>
-#include <ios>
-#include <limits>
-#include <memory>
-#include <new>
-#include <stdlib.h>
-#include <string>
-
-#include "third_party/libcxx/src/include/config_elast.h"
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-class _LIBCPP_HIDDEN __iostream_category
-    : public __do_message
-{
-public:
-    virtual const char* name() const noexcept;
-    virtual string message(int ev) const;
-};
-
-const char*
-__iostream_category::name() const noexcept
-{
-    return "iostream";
-}
-
-string
-__iostream_category::message(int ev) const
-{
-    if (ev != static_cast<int>(io_errc::stream)
-#ifdef _LIBCPP_ELAST
-        && ev <= _LIBCPP_ELAST
-#endif // _LIBCPP_ELAST
-        )
-        return __do_message::message(ev);
-    return string("unspecified iostream_category error");
-}
-
-const error_category&
-iostream_category() noexcept
-{
-    static __iostream_category s;
-    return s;
-}
-
-// ios_base::failure
-
-ios_base::failure::failure(const string& msg, const error_code& ec)
-    : system_error(ec, msg)
-{
-}
-
-ios_base::failure::failure(const char* msg, const error_code& ec)
-    : system_error(ec, msg)
-{
-}
-
-ios_base::failure::~failure() throw()
-{
-}
-
-// ios_base locale
-
-const ios_base::fmtflags ios_base::boolalpha;
-const ios_base::fmtflags ios_base::dec;
-const ios_base::fmtflags ios_base::fixed;
-const ios_base::fmtflags ios_base::hex;
-const ios_base::fmtflags ios_base::internal;
-const ios_base::fmtflags ios_base::left;
-const ios_base::fmtflags ios_base::oct;
-const ios_base::fmtflags ios_base::right;
-const ios_base::fmtflags ios_base::scientific;
-const ios_base::fmtflags ios_base::showbase;
-const ios_base::fmtflags ios_base::showpoint;
-const ios_base::fmtflags ios_base::showpos;
-const ios_base::fmtflags ios_base::skipws;
-const ios_base::fmtflags ios_base::unitbuf;
-const ios_base::fmtflags ios_base::uppercase;
-const ios_base::fmtflags ios_base::adjustfield;
-const ios_base::fmtflags ios_base::basefield;
-const ios_base::fmtflags ios_base::floatfield;
-
-const ios_base::iostate ios_base::badbit;
-const ios_base::iostate ios_base::eofbit;
-const ios_base::iostate ios_base::failbit;
-const ios_base::iostate ios_base::goodbit;
-
-const ios_base::openmode ios_base::app;
-const ios_base::openmode ios_base::ate;
-const ios_base::openmode ios_base::binary;
-const ios_base::openmode ios_base::in;
-const ios_base::openmode ios_base::out;
-const ios_base::openmode ios_base::trunc;
-
-void
-ios_base::__call_callbacks(event ev)
-{
-    for (size_t i = __event_size_; i;)
-    {
-        --i;
-        __fn_[i](ev, *this, __index_[i]);
-    }
-}
-
-// locale
-
-locale
-ios_base::imbue(const locale& newloc)
-{
-    static_assert(sizeof(locale) == sizeof(__loc_), "");
-    locale& loc_storage = *reinterpret_cast<locale*>(&__loc_);
-    locale oldloc = loc_storage;
-    loc_storage = newloc;
-    __call_callbacks(imbue_event);
-    return oldloc;
-}
-
-locale
-ios_base::getloc() const
-{
-    const locale& loc_storage = *reinterpret_cast<const locale*>(&__loc_);
-    return loc_storage;
-}
-
-// xalloc
-#if defined(_LIBCPP_HAS_C_ATOMIC_IMP) && !defined(_LIBCPP_HAS_NO_THREADS)
-atomic<int> ios_base::__xindex_{0};
-#else
-int ios_base::__xindex_ = 0;
-#endif
-
-template <typename _Tp>
-static size_t __ios_new_cap(size_t __req_size, size_t __current_cap)
-{ // Precondition: __req_size > __current_cap
-    const size_t mx = std::numeric_limits<size_t>::max() / sizeof(_Tp);
-    if (__req_size < mx/2)
-        return _VSTD::max(2 * __current_cap, __req_size);
-    else
-        return mx;
-}
-
-int
-ios_base::xalloc()
-{
-    return __xindex_++;
-}
-
-long&
-ios_base::iword(int index)
-{
-    size_t req_size = static_cast<size_t>(index)+1;
-    if (req_size > __iarray_cap_)
-    {
-        size_t newcap = __ios_new_cap<long>(req_size, __iarray_cap_);
-        long* iarray = static_cast<long*>(realloc(__iarray_, newcap * sizeof(long)));
-        if (iarray == 0)
-        {
-            setstate(badbit);
-            static long error;
-            error = 0;
-            return error;
-        }
-        __iarray_ = iarray;
-        for (long* p = __iarray_ + __iarray_size_; p < __iarray_ + newcap; ++p)
-            *p = 0;
-        __iarray_cap_ = newcap;
-    }
-    __iarray_size_ = max<size_t>(__iarray_size_, req_size);
-    return __iarray_[index];
-}
-
-void*&
-ios_base::pword(int index)
-{
-    size_t req_size = static_cast<size_t>(index)+1;
-    if (req_size > __parray_cap_)
-    {
-        size_t newcap = __ios_new_cap<void *>(req_size, __iarray_cap_);
-        void** parray = static_cast<void**>(realloc(__parray_, newcap * sizeof(void *)));
-        if (parray == 0)
-        {
-            setstate(badbit);
-            static void* error;
-            error = 0;
-            return error;
-        }
-        __parray_ = parray;
-        for (void** p = __parray_ + __parray_size_; p < __parray_ + newcap; ++p)
-            *p = 0;
-        __parray_cap_ = newcap;
-    }
-    __parray_size_ = max<size_t>(__parray_size_, req_size);
-    return __parray_[index];
-}
-
-// register_callback
-
-void
-ios_base::register_callback(event_callback fn, int index)
-{
-    size_t req_size = __event_size_ + 1;
-    if (req_size > __event_cap_)
-    {
-        size_t newcap = __ios_new_cap<event_callback>(req_size, __event_cap_);
-        event_callback* fns = static_cast<event_callback*>(realloc(__fn_, newcap * sizeof(event_callback)));
-        if (fns == 0)
-            setstate(badbit);
-        __fn_ = fns;
-        int* indxs = static_cast<int *>(realloc(__index_, newcap * sizeof(int)));
-        if (indxs == 0)
-            setstate(badbit);
-        __index_ = indxs;
-        __event_cap_ = newcap;
-    }
-    __fn_[__event_size_] = fn;
-    __index_[__event_size_] = index;
-    ++__event_size_;
-}
-
-ios_base::~ios_base()
-{
-    __call_callbacks(erase_event);
-    locale& loc_storage = *reinterpret_cast<locale*>(&__loc_);
-    loc_storage.~locale();
-    free(__fn_);
-    free(__index_);
-    free(__iarray_);
-    free(__parray_);
-}
-
-// iostate
-
-void
-ios_base::clear(iostate state)
-{
-    if (__rdbuf_)
-        __rdstate_ = state;
-    else
-        __rdstate_ = state | badbit;
-
-    if (((state | (__rdbuf_ ? goodbit : badbit)) & __exceptions_) != 0)
-        __throw_failure("ios_base::clear");
-}
-
-// init
-
-void
-ios_base::init(void* sb)
-{
-    __rdbuf_ = sb;
-    __rdstate_ = __rdbuf_ ? goodbit : badbit;
-    __exceptions_ = goodbit;
-    __fmtflags_ = skipws | dec;
-    __width_ = 0;
-    __precision_ = 6;
-    __fn_ = 0;
-    __index_ = 0;
-    __event_size_ = 0;
-    __event_cap_ = 0;
-    __iarray_ = 0;
-    __iarray_size_ = 0;
-    __iarray_cap_ = 0;
-    __parray_ = 0;
-    __parray_size_ = 0;
-    __parray_cap_ = 0;
-    ::new(&__loc_) locale;
-}
-
-void
-ios_base::copyfmt(const ios_base& rhs)
-{
-    // If we can't acquire the needed resources, throw bad_alloc (can't set badbit)
-    // Don't alter *this until all needed resources are acquired
-    unique_ptr<event_callback, void (*)(void*)> new_callbacks(0, free);
-    unique_ptr<int, void (*)(void*)> new_ints(0, free);
-    unique_ptr<long, void (*)(void*)> new_longs(0, free);
-    unique_ptr<void*, void (*)(void*)> new_pointers(0, free);
-    if (__event_cap_ < rhs.__event_size_)
-    {
-        size_t newesize = sizeof(event_callback) * rhs.__event_size_;
-        new_callbacks.reset(static_cast<event_callback*>(malloc(newesize)));
-        if (!new_callbacks)
-            __throw_bad_alloc();
-
-        size_t newisize = sizeof(int) * rhs.__event_size_;
-        new_ints.reset(static_cast<int *>(malloc(newisize)));
-        if (!new_ints)
-            __throw_bad_alloc();
-    }
-    if (__iarray_cap_ < rhs.__iarray_size_)
-    {
-        size_t newsize = sizeof(long) * rhs.__iarray_size_;
-        new_longs.reset(static_cast<long*>(malloc(newsize)));
-        if (!new_longs)
-            __throw_bad_alloc();
-    }
-    if (__parray_cap_ < rhs.__parray_size_)
-    {
-        size_t newsize = sizeof(void*) * rhs.__parray_size_;
-        new_pointers.reset(static_cast<void**>(malloc(newsize)));
-        if (!new_pointers)
-            __throw_bad_alloc();
-    }
-    // Got everything we need.  Copy everything but __rdstate_, __rdbuf_ and __exceptions_
-    __fmtflags_ = rhs.__fmtflags_;
-    __precision_ = rhs.__precision_;
-    __width_ = rhs.__width_;
-    locale& lhs_loc = *reinterpret_cast<locale*>(&__loc_);
-    const locale& rhs_loc = *reinterpret_cast<const locale*>(&rhs.__loc_);
-    lhs_loc = rhs_loc;
-    if (__event_cap_ < rhs.__event_size_)
-    {
-        free(__fn_);
-        __fn_ = new_callbacks.release();
-        free(__index_);
-        __index_ = new_ints.release();
-        __event_cap_ = rhs.__event_size_;
-    }
-    for (__event_size_ = 0; __event_size_ < rhs.__event_size_; ++__event_size_)
-    {
-        __fn_[__event_size_] = rhs.__fn_[__event_size_];
-        __index_[__event_size_] = rhs.__index_[__event_size_];
-    }
-    if (__iarray_cap_ < rhs.__iarray_size_)
-    {
-        free(__iarray_);
-        __iarray_ = new_longs.release();
-        __iarray_cap_ = rhs.__iarray_size_;
-    }
-    for (__iarray_size_ = 0; __iarray_size_ < rhs.__iarray_size_; ++__iarray_size_)
-        __iarray_[__iarray_size_] = rhs.__iarray_[__iarray_size_];
-    if (__parray_cap_ < rhs.__parray_size_)
-    {
-        free(__parray_);
-        __parray_ = new_pointers.release();
-        __parray_cap_ = rhs.__parray_size_;
-    }
-    for (__parray_size_ = 0; __parray_size_ < rhs.__parray_size_; ++__parray_size_)
-        __parray_[__parray_size_] = rhs.__parray_[__parray_size_];
-}
-
-void
-ios_base::move(ios_base& rhs)
-{
-    // *this is uninitialized
-    __fmtflags_ = rhs.__fmtflags_;
-    __precision_ = rhs.__precision_;
-    __width_ = rhs.__width_;
-    __rdstate_ = rhs.__rdstate_;
-    __exceptions_ = rhs.__exceptions_;
-    __rdbuf_ = 0;
-    locale& rhs_loc = *reinterpret_cast<locale*>(&rhs.__loc_);
-    ::new(&__loc_) locale(rhs_loc);
-    __fn_ = rhs.__fn_;
-    rhs.__fn_ = 0;
-    __index_ = rhs.__index_;
-    rhs.__index_ = 0;
-    __event_size_ = rhs.__event_size_;
-    rhs.__event_size_ = 0;
-    __event_cap_ = rhs.__event_cap_;
-    rhs.__event_cap_ = 0;
-    __iarray_ = rhs.__iarray_;
-    rhs.__iarray_ = 0;
-    __iarray_size_ = rhs.__iarray_size_;
-    rhs.__iarray_size_ = 0;
-    __iarray_cap_ = rhs.__iarray_cap_;
-    rhs.__iarray_cap_ = 0;
-    __parray_ = rhs.__parray_;
-    rhs.__parray_ = 0;
-    __parray_size_ = rhs.__parray_size_;
-    rhs.__parray_size_ = 0;
-    __parray_cap_ = rhs.__parray_cap_;
-    rhs.__parray_cap_ = 0;
-}
-
-void
-ios_base::swap(ios_base& rhs) noexcept
-{
-    _VSTD::swap(__fmtflags_, rhs.__fmtflags_);
-    _VSTD::swap(__precision_, rhs.__precision_);
-    _VSTD::swap(__width_, rhs.__width_);
-    _VSTD::swap(__rdstate_, rhs.__rdstate_);
-    _VSTD::swap(__exceptions_, rhs.__exceptions_);
-    locale& lhs_loc = *reinterpret_cast<locale*>(&__loc_);
-    locale& rhs_loc = *reinterpret_cast<locale*>(&rhs.__loc_);
-    _VSTD::swap(lhs_loc, rhs_loc);
-    _VSTD::swap(__fn_, rhs.__fn_);
-    _VSTD::swap(__index_, rhs.__index_);
-    _VSTD::swap(__event_size_, rhs.__event_size_);
-    _VSTD::swap(__event_cap_, rhs.__event_cap_);
-    _VSTD::swap(__iarray_, rhs.__iarray_);
-    _VSTD::swap(__iarray_size_, rhs.__iarray_size_);
-    _VSTD::swap(__iarray_cap_, rhs.__iarray_cap_);
-    _VSTD::swap(__parray_, rhs.__parray_);
-    _VSTD::swap(__parray_size_, rhs.__parray_size_);
-    _VSTD::swap(__parray_cap_, rhs.__parray_cap_);
-}
-
-void
-ios_base::__set_badbit_and_consider_rethrow()
-{
-    __rdstate_ |= badbit;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    if (__exceptions_ & badbit)
-        throw;
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-}
-
-void
-ios_base::__set_failbit_and_consider_rethrow()
-{
-    __rdstate_ |= failbit;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    if (__exceptions_ & failbit)
-        throw;
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-}
-
-bool
-ios_base::sync_with_stdio(bool sync)
-{
-    static bool previous_state = true;
-    bool r = previous_state;
-    previous_state = sync;
-    return r;
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/src/iostream.cpp b/third_party/libcxx/src/iostream.cpp
deleted file mode 100644
index 9b1a1a41e..000000000
--- a/third_party/libcxx/src/iostream.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__locale>
-#include "std_stream.h"
-#include <new>
-#include <string>
-
-#ifdef _LIBCPP_MSVCRT_LIKE
-#  include <__locale_dir/locale_base_api/locale_guard.h>
-#endif
-
-#define _str(s) #s
-#define str(s) _str(s)
-#define _LIBCPP_ABI_NAMESPACE_STR str(_LIBCPP_ABI_NAMESPACE)
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-_ALIGNAS_TYPE (istream) _LIBCPP_FUNC_VIS char cin[sizeof(istream)]
-#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?cin@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_istream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
-#endif
-;
-_ALIGNAS_TYPE (__stdinbuf<char> ) static char __cin[sizeof(__stdinbuf <char>)];
-static mbstate_t mb_cin;
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_ALIGNAS_TYPE (wistream) _LIBCPP_FUNC_VIS char wcin[sizeof(wistream)]
-#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wcin@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_istream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
-#endif
-;
-_ALIGNAS_TYPE (__stdinbuf<wchar_t> ) static char __wcin[sizeof(__stdinbuf <wchar_t>)];
-static mbstate_t mb_wcin;
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cout[sizeof(ostream)]
-#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?cout@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
-#endif
-;
-_ALIGNAS_TYPE (__stdoutbuf<char>) static char __cout[sizeof(__stdoutbuf<char>)];
-static mbstate_t mb_cout;
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcout[sizeof(wostream)]
-#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wcout@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
-#endif
-;
-_ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcout[sizeof(__stdoutbuf<wchar_t>)];
-static mbstate_t mb_wcout;
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char cerr[sizeof(ostream)]
-#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?cerr@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
-#endif
-;
-_ALIGNAS_TYPE (__stdoutbuf<char>) static char __cerr[sizeof(__stdoutbuf<char>)];
-static mbstate_t mb_cerr;
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wcerr[sizeof(wostream)]
-#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wcerr@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
-#endif
-;
-_ALIGNAS_TYPE (__stdoutbuf<wchar_t>) static char __wcerr[sizeof(__stdoutbuf<wchar_t>)];
-static mbstate_t mb_wcerr;
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-_ALIGNAS_TYPE (ostream) _LIBCPP_FUNC_VIS char clog[sizeof(ostream)]
-#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?clog@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@DU?$char_traits@D@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
-#endif
-;
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_ALIGNAS_TYPE (wostream) _LIBCPP_FUNC_VIS char wclog[sizeof(wostream)]
-#if defined(_LIBCPP_ABI_MICROSOFT) && defined(__clang__)
-__asm__("?wclog@" _LIBCPP_ABI_NAMESPACE_STR "@std@@3V?$basic_ostream@_WU?$char_traits@_W@" _LIBCPP_ABI_NAMESPACE_STR "@std@@@12@A")
-#endif
-;
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
-// attribute with a value that's reserved for the implementation (we're the implementation).
-#include "iostream_init.h"
-
-// On Windows the TLS storage for locales needs to be initialized before we create
-// the standard streams, otherwise it may not be alive during program termination
-// when we flush the streams.
-static void force_locale_initialization() {
-#if defined(_LIBCPP_MSVCRT_LIKE)
-  static bool once = []() {
-    auto loc = newlocale(LC_ALL_MASK, "C", 0);
-    {
-        __libcpp_locale_guard g(loc); // forces initialization of locale TLS
-        ((void)g);
-    }
-    freelocale(loc);
-    return true;
-  }();
-  ((void)once);
-#endif
-}
-
-class DoIOSInit {
-public:
-    DoIOSInit();
-    ~DoIOSInit();
-};
-
-DoIOSInit::DoIOSInit()
-{
-    force_locale_initialization();
-
-    istream* cin_ptr  = ::new(cin)  istream(::new(__cin)  __stdinbuf <char>(stdin, &mb_cin));
-    ostream* cout_ptr = ::new(cout) ostream(::new(__cout) __stdoutbuf<char>(stdout, &mb_cout));
-    ostream* cerr_ptr = ::new(cerr) ostream(::new(__cerr) __stdoutbuf<char>(stderr, &mb_cerr));
-                        ::new(clog) ostream(cerr_ptr->rdbuf());
-    cin_ptr->tie(cout_ptr);
-    _VSTD::unitbuf(*cerr_ptr);
-    cerr_ptr->tie(cout_ptr);
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    wistream* wcin_ptr  = ::new(wcin)  wistream(::new(__wcin)  __stdinbuf <wchar_t>(stdin, &mb_wcin));
-    wostream* wcout_ptr = ::new(wcout) wostream(::new(__wcout) __stdoutbuf<wchar_t>(stdout, &mb_wcout));
-    wostream* wcerr_ptr = ::new(wcerr) wostream(::new(__wcerr) __stdoutbuf<wchar_t>(stderr, &mb_wcerr));
-                          ::new(wclog) wostream(wcerr_ptr->rdbuf());
-
-    wcin_ptr->tie(wcout_ptr);
-    _VSTD::unitbuf(*wcerr_ptr);
-    wcerr_ptr->tie(wcout_ptr);
-#endif
-}
-
-DoIOSInit::~DoIOSInit()
-{
-    ostream* cout_ptr = reinterpret_cast<ostream*>(cout);
-    cout_ptr->flush();
-    ostream* clog_ptr = reinterpret_cast<ostream*>(clog);
-    clog_ptr->flush();
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    wostream* wcout_ptr = reinterpret_cast<wostream*>(wcout);
-    wcout_ptr->flush();
-    wostream* wclog_ptr = reinterpret_cast<wostream*>(wclog);
-    wclog_ptr->flush();
-#endif
-}
-
-ios_base::Init::Init()
-{
-    static DoIOSInit init_the_streams; // gets initialized once
-}
-
-ios_base::Init::~Init()
-{
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/legacy_debug_handler.cpp b/third_party/libcxx/src/legacy_debug_handler.cpp
deleted file mode 100644
index cb2025bfc..000000000
--- a/third_party/libcxx/src/legacy_debug_handler.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-#include <cstdio>
-#include <cstdlib>
-#include <string>
-
-// This file defines the legacy default debug handler and related mechanisms
-// to set it. This is for backwards ABI compatibility with code that has been
-// using this debug handler previously.
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-struct _LIBCPP_TEMPLATE_VIS __libcpp_debug_info {
-  _LIBCPP_EXPORTED_FROM_ABI string what() const;
-
-  const char* __file_;
-  int __line_;
-  const char* __pred_;
-  const char* __msg_;
-};
-
-std::string __libcpp_debug_info::what() const {
-  string msg = __file_;
-  msg += ":" + std::to_string(__line_) + ": _LIBCPP_ASSERT '";
-  msg += __pred_;
-  msg += "' failed. ";
-  msg += __msg_;
-  return msg;
-}
-
-_LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __libcpp_abort_debug_function(__libcpp_debug_info const& info) {
-  std::fprintf(stderr, "%s\n", info.what().c_str());
-  std::abort();
-}
-
-typedef void (*__libcpp_debug_function_type)(__libcpp_debug_info const&);
-
-_LIBCPP_EXPORTED_FROM_ABI
-constinit __libcpp_debug_function_type __libcpp_debug_function = __libcpp_abort_debug_function;
-
-_LIBCPP_EXPORTED_FROM_ABI
-bool __libcpp_set_debug_function(__libcpp_debug_function_type __func) {
-  __libcpp_debug_function = __func;
-  return true;
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/legacy_pointer_safety.cpp b/third_party/libcxx/src/legacy_pointer_safety.cpp
deleted file mode 100644
index 5d2b04c12..000000000
--- a/third_party/libcxx/src/legacy_pointer_safety.cpp
+++ /dev/null
@@ -1,23 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-#include <memory>
-
-// Support for garbage collection was removed in C++23 by https://wg21.link/P2186R2. Libc++ implements
-// that removal as an extension in all Standard versions. However, we still define the functions that
-// were once part of the library's ABI for backwards compatibility.
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-_LIBCPP_FUNC_VIS void declare_reachable(void*) {}
-_LIBCPP_FUNC_VIS void declare_no_pointers(char*, size_t) {}
-_LIBCPP_FUNC_VIS void undeclare_no_pointers(char*, size_t) {}
-_LIBCPP_FUNC_VIS void* __undeclare_reachable(void* p) { return p; }
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/locale.cpp b/third_party/libcxx/src/locale.cpp
deleted file mode 100644
index 1bd05db9a..000000000
--- a/third_party/libcxx/src/locale.cpp
+++ /dev/null
@@ -1,6596 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__utility/unreachable.h>
-#include <algorithm>
-#include <clocale>
-#include <codecvt>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <locale>
-#include <string>
-#include <type_traits>
-#include <typeinfo>
-#include <vector>
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-#   include <cwctype>
-#endif
-
-#if defined(_AIX)
-#   include <sys/localedef.h> // for __lc_ctype_ptr
-#endif
-
-#if defined(_LIBCPP_MSVCRT)
-#   define _CTYPE_DISABLE_MACROS
-#endif
-
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-// #   include "third_party/libcxx/__support/win32/locale_win32.h"
-#elif !defined(__BIONIC__) && !defined(__NuttX__)
-#   include <langinfo.h>
-#endif
-
-#include "third_party/libcxx/src/include/atomic_support.h"
-#include "third_party/libcxx/src/include/sso_allocator.h"
-
-// On Linux, wint_t and wchar_t have different signed-ness, and this causes
-// lots of noise in the build log, but no bugs that I know of.
-_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wsign-conversion")
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-struct __libcpp_unique_locale {
-  __libcpp_unique_locale(const char* nm) : __loc_(newlocale(LC_ALL_MASK, nm, 0)) {}
-
-  ~__libcpp_unique_locale() {
-    if (__loc_)
-      freelocale(__loc_);
-  }
-
-  explicit operator bool() const { return __loc_; }
-
-  locale_t& get() { return __loc_; }
-
-  locale_t __loc_;
-private:
-  __libcpp_unique_locale(__libcpp_unique_locale const&);
-  __libcpp_unique_locale& operator=(__libcpp_unique_locale const&);
-};
-
-#ifdef __cloc_defined
-locale_t __cloc() {
-  // In theory this could create a race condition. In practice
-  // the race condition is non-fatal since it will just create
-  // a little resource leak. Better approach would be appreciated.
-  static locale_t result = newlocale(LC_ALL_MASK, "C", 0);
-  return result;
-}
-#endif // __cloc_defined
-
-namespace {
-
-struct release
-{
-    void operator()(locale::facet* p) {p->__release_shared();}
-};
-
-template <class T, class ...Args>
-T& make(Args ...args)
-{
-    static typename aligned_storage<sizeof(T)>::type buf;
-    auto *obj = ::new (&buf) T(args...);
-    return *obj;
-}
-
-template <typename T, size_t N>
-inline
-_LIBCPP_CONSTEXPR
-size_t
-countof(const T (&)[N])
-{
-    return N;
-}
-
-template <typename T>
-inline
-_LIBCPP_CONSTEXPR
-size_t
-countof(const T * const begin, const T * const end)
-{
-    return static_cast<size_t>(end - begin);
-}
-
-_LIBCPP_NORETURN static void __throw_runtime_error(const string &msg)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw runtime_error(msg);
-#else
-    (void)msg;
-    _VSTD::abort();
-#endif
-}
-
-}
-
-const locale::category locale::none;
-const locale::category locale::collate;
-const locale::category locale::ctype;
-const locale::category locale::monetary;
-const locale::category locale::numeric;
-const locale::category locale::time;
-const locale::category locale::messages;
-const locale::category locale::all;
-
-class _LIBCPP_HIDDEN locale::__imp
-    : public facet
-{
-    enum {N = 30};
-    vector<facet*, __sso_allocator<facet*, N> > facets_;
-    string         name_;
-public:
-    explicit __imp(size_t refs = 0);
-    explicit __imp(const string& name, size_t refs = 0);
-    __imp(const __imp&);
-    __imp(const __imp&, const string&, locale::category c);
-    __imp(const __imp& other, const __imp& one, locale::category c);
-    __imp(const __imp&, facet* f, long id);
-    ~__imp();
-
-    const string& name() const {return name_;}
-    bool has_facet(long id) const
-        {return static_cast<size_t>(id) < facets_.size() && facets_[static_cast<size_t>(id)];}
-    const locale::facet* use_facet(long id) const;
-
-    static const locale& make_classic();
-    static       locale& make_global();
-private:
-    void install(facet* f, long id);
-    template <class F> void install(F* f) {install(f, f->id.__get());}
-    template <class F> void install_from(const __imp& other);
-};
-
-locale::__imp::__imp(size_t refs)
-    : facet(refs),
-      facets_(N),
-      name_("C")
-{
-    facets_.clear();
-    install(&make<_VSTD::collate<char> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<_VSTD::collate<wchar_t> >(1u));
-#endif
-    install(&make<_VSTD::ctype<char> >(nullptr, false, 1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<_VSTD::ctype<wchar_t> >(1u));
-#endif
-    install(&make<codecvt<char, char, mbstate_t> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<codecvt<wchar_t, char, mbstate_t> >(1u));
-#endif
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    install(&make<codecvt<char16_t, char, mbstate_t> >(1u));
-    install(&make<codecvt<char32_t, char, mbstate_t> >(1u));
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-    install(&make<codecvt<char16_t, char8_t, mbstate_t> >(1u));
-    install(&make<codecvt<char32_t, char8_t, mbstate_t> >(1u));
-#endif
-    install(&make<numpunct<char> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<numpunct<wchar_t> >(1u));
-#endif
-    install(&make<num_get<char> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<num_get<wchar_t> >(1u));
-#endif
-    install(&make<num_put<char> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<num_put<wchar_t> >(1u));
-#endif
-    install(&make<moneypunct<char, false> >(1u));
-    install(&make<moneypunct<char, true> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<moneypunct<wchar_t, false> >(1u));
-    install(&make<moneypunct<wchar_t, true> >(1u));
-#endif
-    install(&make<money_get<char> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<money_get<wchar_t> >(1u));
-#endif
-    install(&make<money_put<char> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<money_put<wchar_t> >(1u));
-#endif
-    install(&make<time_get<char> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<time_get<wchar_t> >(1u));
-#endif
-    install(&make<time_put<char> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<time_put<wchar_t> >(1u));
-#endif
-    install(&make<_VSTD::messages<char> >(1u));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    install(&make<_VSTD::messages<wchar_t> >(1u));
-#endif
-}
-
-locale::__imp::__imp(const string& name, size_t refs)
-    : facet(refs),
-      facets_(N),
-      name_(name)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        facets_ = locale::classic().__locale_->facets_;
-        for (unsigned i = 0; i < facets_.size(); ++i)
-            if (facets_[i])
-                facets_[i]->__add_shared();
-        install(new collate_byname<char>(name_));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        install(new collate_byname<wchar_t>(name_));
-#endif
-        install(new ctype_byname<char>(name_));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        install(new ctype_byname<wchar_t>(name_));
-#endif
-        install(new codecvt_byname<char, char, mbstate_t>(name_));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        install(new codecvt_byname<wchar_t, char, mbstate_t>(name_));
-#endif
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-        install(new codecvt_byname<char16_t, char, mbstate_t>(name_));
-        install(new codecvt_byname<char32_t, char, mbstate_t>(name_));
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-        install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name_));
-        install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name_));
-#endif
-        install(new numpunct_byname<char>(name_));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        install(new numpunct_byname<wchar_t>(name_));
-#endif
-        install(new moneypunct_byname<char, false>(name_));
-        install(new moneypunct_byname<char, true>(name_));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        install(new moneypunct_byname<wchar_t, false>(name_));
-        install(new moneypunct_byname<wchar_t, true>(name_));
-#endif
-        install(new time_get_byname<char>(name_));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        install(new time_get_byname<wchar_t>(name_));
-#endif
-        install(new time_put_byname<char>(name_));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        install(new time_put_byname<wchar_t>(name_));
-#endif
-        install(new messages_byname<char>(name_));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        install(new messages_byname<wchar_t>(name_));
-#endif
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        for (unsigned i = 0; i < facets_.size(); ++i)
-            if (facets_[i])
-                facets_[i]->__release_shared();
-        throw;
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-}
-
-locale::__imp::__imp(const __imp& other)
-    : facets_(max<size_t>(N, other.facets_.size())),
-      name_(other.name_)
-{
-    facets_ = other.facets_;
-    for (unsigned i = 0; i < facets_.size(); ++i)
-        if (facets_[i])
-            facets_[i]->__add_shared();
-}
-
-locale::__imp::__imp(const __imp& other, const string& name, locale::category c)
-    : facets_(N),
-      name_("*")
-{
-    facets_ = other.facets_;
-    for (unsigned i = 0; i < facets_.size(); ++i)
-        if (facets_[i])
-            facets_[i]->__add_shared();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        if (c & locale::collate)
-        {
-            install(new collate_byname<char>(name));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install(new collate_byname<wchar_t>(name));
-#endif
-        }
-        if (c & locale::ctype)
-        {
-            install(new ctype_byname<char>(name));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install(new ctype_byname<wchar_t>(name));
-#endif
-            install(new codecvt_byname<char, char, mbstate_t>(name));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install(new codecvt_byname<wchar_t, char, mbstate_t>(name));
-#endif
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-            install(new codecvt_byname<char16_t, char, mbstate_t>(name));
-            install(new codecvt_byname<char32_t, char, mbstate_t>(name));
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-            install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name));
-            install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name));
-#endif
-        }
-        if (c & locale::monetary)
-        {
-            install(new moneypunct_byname<char, false>(name));
-            install(new moneypunct_byname<char, true>(name));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install(new moneypunct_byname<wchar_t, false>(name));
-            install(new moneypunct_byname<wchar_t, true>(name));
-#endif
-        }
-        if (c & locale::numeric)
-        {
-            install(new numpunct_byname<char>(name));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install(new numpunct_byname<wchar_t>(name));
-#endif
-        }
-        if (c & locale::time)
-        {
-            install(new time_get_byname<char>(name));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install(new time_get_byname<wchar_t>(name));
-#endif
-            install(new time_put_byname<char>(name));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install(new time_put_byname<wchar_t>(name));
-#endif
-        }
-        if (c & locale::messages)
-        {
-            install(new messages_byname<char>(name));
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install(new messages_byname<wchar_t>(name));
-#endif
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        for (unsigned i = 0; i < facets_.size(); ++i)
-            if (facets_[i])
-                facets_[i]->__release_shared();
-        throw;
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-}
-
-template<class F>
-inline
-void
-locale::__imp::install_from(const locale::__imp& one)
-{
-    long id = F::id.__get();
-    install(const_cast<F*>(static_cast<const F*>(one.use_facet(id))), id);
-}
-
-locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
-    : facets_(N),
-      name_("*")
-{
-    facets_ = other.facets_;
-    for (unsigned i = 0; i < facets_.size(); ++i)
-        if (facets_[i])
-            facets_[i]->__add_shared();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        if (c & locale::collate)
-        {
-            install_from<_VSTD::collate<char> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<_VSTD::collate<wchar_t> >(one);
-#endif
-        }
-        if (c & locale::ctype)
-        {
-            install_from<_VSTD::ctype<char> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<_VSTD::ctype<wchar_t> >(one);
-#endif
-            install_from<_VSTD::codecvt<char, char, mbstate_t> >(one);
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-            install_from<_VSTD::codecvt<char16_t, char, mbstate_t> >(one);
-            install_from<_VSTD::codecvt<char32_t, char, mbstate_t> >(one);
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-            install_from<_VSTD::codecvt<char16_t, char8_t, mbstate_t> >(one);
-            install_from<_VSTD::codecvt<char32_t, char8_t, mbstate_t> >(one);
-#endif
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<_VSTD::codecvt<wchar_t, char, mbstate_t> >(one);
-#endif
-        }
-        if (c & locale::monetary)
-        {
-            install_from<moneypunct<char, false> >(one);
-            install_from<moneypunct<char, true> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<moneypunct<wchar_t, false> >(one);
-            install_from<moneypunct<wchar_t, true> >(one);
-#endif
-            install_from<money_get<char> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<money_get<wchar_t> >(one);
-#endif
-            install_from<money_put<char> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<money_put<wchar_t> >(one);
-#endif
-        }
-        if (c & locale::numeric)
-        {
-            install_from<numpunct<char> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<numpunct<wchar_t> >(one);
-#endif
-            install_from<num_get<char> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<num_get<wchar_t> >(one);
-#endif
-            install_from<num_put<char> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<num_put<wchar_t> >(one);
-#endif
-        }
-        if (c & locale::time)
-        {
-            install_from<time_get<char> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<time_get<wchar_t> >(one);
-#endif
-            install_from<time_put<char> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<time_put<wchar_t> >(one);
-#endif
-        }
-        if (c & locale::messages)
-        {
-            install_from<_VSTD::messages<char> >(one);
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-            install_from<_VSTD::messages<wchar_t> >(one);
-#endif
-        }
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        for (unsigned i = 0; i < facets_.size(); ++i)
-            if (facets_[i])
-                facets_[i]->__release_shared();
-        throw;
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-}
-
-locale::__imp::__imp(const __imp& other, facet* f, long id)
-    : facets_(max<size_t>(N, other.facets_.size()+1)),
-      name_("*")
-{
-    f->__add_shared();
-    unique_ptr<facet, release> hold(f);
-    facets_ = other.facets_;
-    for (unsigned i = 0; i < other.facets_.size(); ++i)
-        if (facets_[i])
-            facets_[i]->__add_shared();
-    install(hold.get(), id);
-}
-
-locale::__imp::~__imp()
-{
-    for (unsigned i = 0; i < facets_.size(); ++i)
-        if (facets_[i])
-            facets_[i]->__release_shared();
-}
-
-void
-locale::__imp::install(facet* f, long id)
-{
-    f->__add_shared();
-    unique_ptr<facet, release> hold(f);
-    if (static_cast<size_t>(id) >= facets_.size())
-        facets_.resize(static_cast<size_t>(id+1));
-    if (facets_[static_cast<size_t>(id)])
-        facets_[static_cast<size_t>(id)]->__release_shared();
-    facets_[static_cast<size_t>(id)] = hold.release();
-}
-
-const locale::facet*
-locale::__imp::use_facet(long id) const
-{
-    if (!has_facet(id))
-        __throw_bad_cast();
-    return facets_[static_cast<size_t>(id)];
-}
-
-// locale
-
-const locale&
-locale::__imp::make_classic()
-{
-    // only one thread can get in here and it only gets in once
-    static aligned_storage<sizeof(locale)>::type buf;
-    locale* c = reinterpret_cast<locale*>(&buf);
-    c->__locale_ = &make<__imp>(1u);
-    return *c;
-}
-
-const locale&
-locale::classic()
-{
-    static const locale& c = __imp::make_classic();
-    return c;
-}
-
-locale&
-locale::__imp::make_global()
-{
-    // only one thread can get in here and it only gets in once
-    static aligned_storage<sizeof(locale)>::type buf;
-    auto *obj = ::new (&buf) locale(locale::classic());
-    return *obj;
-}
-
-locale&
-locale::__global()
-{
-    static locale& g = __imp::make_global();
-    return g;
-}
-
-locale::locale() noexcept
-    : __locale_(__global().__locale_)
-{
-    __locale_->__add_shared();
-}
-
-locale::locale(const locale& l) noexcept
-    : __locale_(l.__locale_)
-{
-    __locale_->__add_shared();
-}
-
-locale::~locale()
-{
-    __locale_->__release_shared();
-}
-
-const locale&
-locale::operator=(const locale& other) noexcept
-{
-    other.__locale_->__add_shared();
-    __locale_->__release_shared();
-    __locale_ = other.__locale_;
-    return *this;
-}
-
-locale::locale(const char* name)
-    : __locale_(name ? new __imp(name)
-                     : (__throw_runtime_error("locale constructed with null"), nullptr))
-{
-    __locale_->__add_shared();
-}
-
-locale::locale(const string& name)
-    : __locale_(new __imp(name))
-{
-    __locale_->__add_shared();
-}
-
-locale::locale(const locale& other, const char* name, category c)
-    : __locale_(name ? new __imp(*other.__locale_, name, c)
-                     : (__throw_runtime_error("locale constructed with null"), nullptr))
-{
-    __locale_->__add_shared();
-}
-
-locale::locale(const locale& other, const string& name, category c)
-    : __locale_(new __imp(*other.__locale_, name, c))
-{
-    __locale_->__add_shared();
-}
-
-locale::locale(const locale& other, const locale& one, category c)
-    : __locale_(new __imp(*other.__locale_, *one.__locale_, c))
-{
-    __locale_->__add_shared();
-}
-
-string
-locale::name() const
-{
-    return __locale_->name();
-}
-
-void
-locale::__install_ctor(const locale& other, facet* f, long id)
-{
-    if (f)
-        __locale_ = new __imp(*other.__locale_, f, id);
-    else
-        __locale_ = other.__locale_;
-    __locale_->__add_shared();
-}
-
-locale
-locale::global(const locale& loc)
-{
-    locale& g = __global();
-    locale r = g;
-    g = loc;
-    if (g.name() != "*")
-        setlocale(LC_ALL, g.name().c_str());
-    return r;
-}
-
-bool
-locale::has_facet(id& x) const
-{
-    return __locale_->has_facet(x.__get());
-}
-
-const locale::facet*
-locale::use_facet(id& x) const
-{
-    return __locale_->use_facet(x.__get());
-}
-
-bool
-locale::operator==(const locale& y) const
-{
-    return (__locale_ == y.__locale_)
-        || (__locale_->name() != "*" && __locale_->name() == y.__locale_->name());
-}
-
-// locale::facet
-
-locale::facet::~facet()
-{
-}
-
-void
-locale::facet::__on_zero_shared() noexcept
-{
-    delete this;
-}
-
-// locale::id
-
-int32_t locale::id::__next_id = 0;
-
-namespace
-{
-
-class __fake_bind
-{
-    locale::id* id_;
-    void (locale::id::* pmf_)();
-public:
-    __fake_bind(void (locale::id::* pmf)(), locale::id* id)
-        : id_(id), pmf_(pmf) {}
-
-    void operator()() const
-    {
-        (id_->*pmf_)();
-    }
-};
-
-}
-
-long
-locale::id::__get()
-{
-    call_once(__flag_, __fake_bind(&locale::id::__init, this));
-    return __id_ - 1;
-}
-
-void
-locale::id::__init()
-{
-    __id_ = __libcpp_atomic_add(&__next_id, 1);
-}
-
-// template <> class collate_byname<char>
-
-collate_byname<char>::collate_byname(const char* n, size_t refs)
-    : collate<char>(refs),
-      __l_(newlocale(LC_ALL_MASK, n, 0))
-{
-    if (__l_ == 0)
-        __throw_runtime_error("collate_byname<char>::collate_byname"
-                            " failed to construct for " + string(n));
-}
-
-collate_byname<char>::collate_byname(const string& name, size_t refs)
-    : collate<char>(refs),
-      __l_(newlocale(LC_ALL_MASK, name.c_str(), 0))
-{
-    if (__l_ == 0)
-        __throw_runtime_error("collate_byname<char>::collate_byname"
-                            " failed to construct for " + name);
-}
-
-collate_byname<char>::~collate_byname()
-{
-    freelocale(__l_);
-}
-
-int
-collate_byname<char>::do_compare(const char_type* __lo1, const char_type* __hi1,
-                                 const char_type* __lo2, const char_type* __hi2) const
-{
-    string_type lhs(__lo1, __hi1);
-    string_type rhs(__lo2, __hi2);
-    int r = strcoll_l(lhs.c_str(), rhs.c_str(), __l_);
-    if (r < 0)
-        return -1;
-    if (r > 0)
-        return 1;
-    return r;
-}
-
-collate_byname<char>::string_type
-collate_byname<char>::do_transform(const char_type* lo, const char_type* hi) const
-{
-    const string_type in(lo, hi);
-    string_type out(strxfrm_l(0, in.c_str(), 0, __l_), char());
-    strxfrm_l(const_cast<char*>(out.c_str()), in.c_str(), out.size()+1, __l_);
-    return out;
-}
-
-// template <> class collate_byname<wchar_t>
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
-    : collate<wchar_t>(refs),
-      __l_(newlocale(LC_ALL_MASK, n, 0))
-{
-    if (__l_ == 0)
-        __throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
-                            " failed to construct for " + string(n));
-}
-
-collate_byname<wchar_t>::collate_byname(const string& name, size_t refs)
-    : collate<wchar_t>(refs),
-      __l_(newlocale(LC_ALL_MASK, name.c_str(), 0))
-{
-    if (__l_ == 0)
-        __throw_runtime_error("collate_byname<wchar_t>::collate_byname(size_t refs)"
-                            " failed to construct for " + name);
-}
-
-collate_byname<wchar_t>::~collate_byname()
-{
-    freelocale(__l_);
-}
-
-int
-collate_byname<wchar_t>::do_compare(const char_type* __lo1, const char_type* __hi1,
-                                 const char_type* __lo2, const char_type* __hi2) const
-{
-    string_type lhs(__lo1, __hi1);
-    string_type rhs(__lo2, __hi2);
-    int r = wcscoll_l(lhs.c_str(), rhs.c_str(), __l_);
-    if (r < 0)
-        return -1;
-    if (r > 0)
-        return 1;
-    return r;
-}
-
-collate_byname<wchar_t>::string_type
-collate_byname<wchar_t>::do_transform(const char_type* lo, const char_type* hi) const
-{
-    const string_type in(lo, hi);
-    string_type out(wcsxfrm_l(0, in.c_str(), 0, __l_), wchar_t());
-    wcsxfrm_l(const_cast<wchar_t*>(out.c_str()), in.c_str(), out.size()+1, __l_);
-    return out;
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-const ctype_base::mask ctype_base::space;
-const ctype_base::mask ctype_base::print;
-const ctype_base::mask ctype_base::cntrl;
-const ctype_base::mask ctype_base::upper;
-const ctype_base::mask ctype_base::lower;
-const ctype_base::mask ctype_base::alpha;
-const ctype_base::mask ctype_base::digit;
-const ctype_base::mask ctype_base::punct;
-const ctype_base::mask ctype_base::xdigit;
-const ctype_base::mask ctype_base::blank;
-const ctype_base::mask ctype_base::alnum;
-const ctype_base::mask ctype_base::graph;
-
-// template <> class ctype<wchar_t>;
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-locale::id ctype<wchar_t>::id;
-
-ctype<wchar_t>::~ctype()
-{
-}
-
-bool
-ctype<wchar_t>::do_is(mask m, char_type c) const
-{
-    return isascii(c) ? (ctype<char>::classic_table()[c] & m) != 0 : false;
-}
-
-const wchar_t*
-ctype<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const
-{
-    for (; low != high; ++low, ++vec)
-        *vec = static_cast<mask>(isascii(*low) ?
-                                   ctype<char>::classic_table()[*low] : 0);
-    return low;
-}
-
-const wchar_t*
-ctype<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-        if (isascii(*low) && (ctype<char>::classic_table()[*low] & m))
-            break;
-    return low;
-}
-
-const wchar_t*
-ctype<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-        if (!(isascii(*low) && (ctype<char>::classic_table()[*low] & m)))
-            break;
-    return low;
-}
-
-wchar_t
-ctype<wchar_t>::do_toupper(char_type c) const
-{
-#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
-    return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
-      defined(__NetBSD__) || defined(__MVS__)
-    return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c;
-#else
-    return (isascii(c) && iswlower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'a'+L'A' : c;
-#endif
-}
-
-const wchar_t*
-ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
-        *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
-      defined(__NetBSD__) || defined(__MVS__)
-        *low = isascii(*low) ? ctype<char>::__classic_upper_table()[*low]
-                             : *low;
-#else
-        *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? (*low-L'a'+L'A') : *low;
-#endif
-    return low;
-}
-
-wchar_t
-ctype<wchar_t>::do_tolower(char_type c) const
-{
-#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
-    return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
-      defined(__NetBSD__) || defined(__MVS__)
-    return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c;
-#else
-    return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-L'A'+'a' : c;
-#endif
-}
-
-const wchar_t*
-ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
-        *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || \
-      defined(__NetBSD__) || defined(__MVS__)
-        *low = isascii(*low) ? ctype<char>::__classic_lower_table()[*low]
-                             : *low;
-#else
-        *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-L'A'+L'a' : *low;
-#endif
-    return low;
-}
-
-wchar_t
-ctype<wchar_t>::do_widen(char c) const
-{
-    return c;
-}
-
-const char*
-ctype<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const
-{
-    for (; low != high; ++low, ++dest)
-        *dest = *low;
-    return low;
-}
-
-char
-ctype<wchar_t>::do_narrow(char_type c, char dfault) const
-{
-    if (isascii(c))
-        return static_cast<char>(c);
-    return dfault;
-}
-
-const wchar_t*
-ctype<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
-{
-    for (; low != high; ++low, ++dest)
-        if (isascii(*low))
-            *dest = static_cast<char>(*low);
-        else
-            *dest = dfault;
-    return low;
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// template <> class ctype<char>;
-
-locale::id ctype<char>::id;
-
-const size_t ctype<char>::table_size;
-
-ctype<char>::ctype(const mask* tab, bool del, size_t refs)
-    : locale::facet(refs),
-      __tab_(tab),
-      __del_(del)
-{
-  if (__tab_ == 0)
-      __tab_ = classic_table();
-}
-
-ctype<char>::~ctype()
-{
-    if (__tab_ && __del_)
-        delete [] __tab_;
-}
-
-char
-ctype<char>::do_toupper(char_type c) const
-{
-#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
-    return isascii(c) ?
-      static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(c)]) : c;
-#elif defined(__NetBSD__)
-    return static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]);
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
-    return isascii(c) ?
-      static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(c)]) : c;
-#else
-    return (isascii(c) && islower_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'a'+'A' : c;
-#endif
-}
-
-const char*
-ctype<char>::do_toupper(char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
-        *low = isascii(*low) ?
-          static_cast<char>(_DefaultRuneLocale.__mapupper[static_cast<ptrdiff_t>(*low)]) : *low;
-#elif defined(__NetBSD__)
-        *low = static_cast<char>(__classic_upper_table()[static_cast<unsigned char>(*low)]);
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
-        *low = isascii(*low) ?
-          static_cast<char>(__classic_upper_table()[static_cast<size_t>(*low)]) : *low;
-#else
-        *low = (isascii(*low) && islower_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'a'+'A' : *low;
-#endif
-    return low;
-}
-
-char
-ctype<char>::do_tolower(char_type c) const
-{
-#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
-    return isascii(c) ?
-      static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(c)]) : c;
-#elif defined(__NetBSD__)
-    return static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(c)]);
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
-    return isascii(c) ?
-      static_cast<char>(__classic_lower_table()[static_cast<size_t>(c)]) : c;
-#else
-    return (isascii(c) && isupper_l(c, _LIBCPP_GET_C_LOCALE)) ? c-'A'+'a' : c;
-#endif
-}
-
-const char*
-ctype<char>::do_tolower(char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-#ifdef _LIBCPP_HAS_DEFAULTRUNELOCALE
-        *low = isascii(*low) ? static_cast<char>(_DefaultRuneLocale.__maplower[static_cast<ptrdiff_t>(*low)]) : *low;
-#elif defined(__NetBSD__)
-        *low = static_cast<char>(__classic_lower_table()[static_cast<unsigned char>(*low)]);
-#elif defined(__GLIBC__) || defined(__EMSCRIPTEN__) || defined(__MVS__)
-        *low = isascii(*low) ? static_cast<char>(__classic_lower_table()[static_cast<size_t>(*low)]) : *low;
-#else
-        *low = (isascii(*low) && isupper_l(*low, _LIBCPP_GET_C_LOCALE)) ? *low-'A'+'a' : *low;
-#endif
-    return low;
-}
-
-char
-ctype<char>::do_widen(char c) const
-{
-    return c;
-}
-
-const char*
-ctype<char>::do_widen(const char* low, const char* high, char_type* dest) const
-{
-    for (; low != high; ++low, ++dest)
-        *dest = *low;
-    return low;
-}
-
-char
-ctype<char>::do_narrow(char_type c, char dfault) const
-{
-    if (isascii(c))
-        return static_cast<char>(c);
-    return dfault;
-}
-
-const char*
-ctype<char>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
-{
-    for (; low != high; ++low, ++dest)
-        if (isascii(*low))
-            *dest = *low;
-        else
-            *dest = dfault;
-    return low;
-}
-
-#if defined(__EMSCRIPTEN__)
-extern "C" const unsigned short ** __ctype_b_loc();
-extern "C" const int ** __ctype_tolower_loc();
-extern "C" const int ** __ctype_toupper_loc();
-#endif
-
-#ifdef _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
-const ctype<char>::mask*
-ctype<char>::classic_table() noexcept
-{
-    static _LIBCPP_CONSTEXPR const ctype<char>::mask builtin_table[table_size] = {
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl | space | blank,
-        cntrl | space,                  cntrl | space,
-        cntrl | space,                  cntrl | space,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        cntrl,                          cntrl,
-        space | blank | print,          punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  punct | print,
-        digit | print | xdigit,         digit | print | xdigit,
-        digit | print | xdigit,         digit | print | xdigit,
-        digit | print | xdigit,         digit | print | xdigit,
-        digit | print | xdigit,         digit | print | xdigit,
-        digit | print | xdigit,         digit | print | xdigit,
-        punct | print,                  punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  upper | xdigit | print | alpha,
-        upper | xdigit | print | alpha, upper | xdigit | print | alpha,
-        upper | xdigit | print | alpha, upper | xdigit | print | alpha,
-        upper | xdigit | print | alpha, upper | print | alpha,
-        upper | print | alpha,          upper | print | alpha,
-        upper | print | alpha,          upper | print | alpha,
-        upper | print | alpha,          upper | print | alpha,
-        upper | print | alpha,          upper | print | alpha,
-        upper | print | alpha,          upper | print | alpha,
-        upper | print | alpha,          upper | print | alpha,
-        upper | print | alpha,          upper | print | alpha,
-        upper | print | alpha,          upper | print | alpha,
-        upper | print | alpha,          upper | print | alpha,
-        upper | print | alpha,          punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  lower | xdigit | print | alpha,
-        lower | xdigit | print | alpha, lower | xdigit | print | alpha,
-        lower | xdigit | print | alpha, lower | xdigit | print | alpha,
-        lower | xdigit | print | alpha, lower | print | alpha,
-        lower | print | alpha,          lower | print | alpha,
-        lower | print | alpha,          lower | print | alpha,
-        lower | print | alpha,          lower | print | alpha,
-        lower | print | alpha,          lower | print | alpha,
-        lower | print | alpha,          lower | print | alpha,
-        lower | print | alpha,          lower | print | alpha,
-        lower | print | alpha,          lower | print | alpha,
-        lower | print | alpha,          lower | print | alpha,
-        lower | print | alpha,          lower | print | alpha,
-        lower | print | alpha,          punct | print,
-        punct | print,                  punct | print,
-        punct | print,                  cntrl,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    };
-    return builtin_table;
-}
-#else
-const ctype<char>::mask*
-ctype<char>::classic_table() noexcept
-{
-#if defined(__APPLE__) || defined(__FreeBSD__)
-    return _DefaultRuneLocale.__runetype;
-#elif defined(__NetBSD__)
-    return _C_ctype_tab_ + 1;
-#elif defined(__GLIBC__)
-    return _LIBCPP_GET_C_LOCALE->__ctype_b;
-#elif defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-    return __pctype_func();
-#elif defined(__EMSCRIPTEN__)
-    return *__ctype_b_loc();
-#elif defined(_NEWLIB_VERSION)
-    // Newlib has a 257-entry table in ctype_.c, where (char)0 starts at [1].
-    return _ctype_ + 1;
-#elif defined(_AIX)
-    return (const unsigned int *)__lc_ctype_ptr->obj->mask;
-#elif defined(__MVS__)
-# if defined(__NATIVE_ASCII_F)
-    return const_cast<const ctype<char>::mask*> (__OBJ_DATA(__lc_ctype_a)->mask);
-# else
-    return const_cast<const ctype<char>::mask*> (__ctypec);
-# endif
-#else
-    // Platform not supported: abort so the person doing the port knows what to
-    // fix
-# warning  ctype<char>::classic_table() is not implemented
-    printf("ctype<char>::classic_table() is not implemented\n");
-    abort();
-    return NULL;
-#endif
-}
-#endif
-
-#if defined(__GLIBC__)
-const int*
-ctype<char>::__classic_lower_table() noexcept
-{
-    return _LIBCPP_GET_C_LOCALE->__ctype_tolower;
-}
-
-const int*
-ctype<char>::__classic_upper_table() noexcept
-{
-    return _LIBCPP_GET_C_LOCALE->__ctype_toupper;
-}
-#elif defined(__NetBSD__)
-const short*
-ctype<char>::__classic_lower_table() noexcept
-{
-    return _C_tolower_tab_ + 1;
-}
-
-const short*
-ctype<char>::__classic_upper_table() noexcept
-{
-    return _C_toupper_tab_ + 1;
-}
-
-#elif defined(__EMSCRIPTEN__)
-const int*
-ctype<char>::__classic_lower_table() noexcept
-{
-    return *__ctype_tolower_loc();
-}
-
-const int*
-ctype<char>::__classic_upper_table() noexcept
-{
-    return *__ctype_toupper_loc();
-}
-#elif defined(__MVS__)
-const unsigned short*
-ctype<char>::__classic_lower_table() _NOEXCEPT
-{
-# if defined(__NATIVE_ASCII_F)
-  return const_cast<const unsigned short*>(__OBJ_DATA(__lc_ctype_a)->lower);
-# else
-  return const_cast<const unsigned short*>(__ctype + __TOLOWER_INDEX);
-# endif
-}
-const unsigned short *
-ctype<char>::__classic_upper_table() _NOEXCEPT
-{
-# if defined(__NATIVE_ASCII_F)
-  return const_cast<const unsigned short*>(__OBJ_DATA(__lc_ctype_a)->upper);
-# else
-  return const_cast<const unsigned short*>(__ctype + __TOUPPER_INDEX);
-# endif
-}
-#endif // __GLIBC__ || __NETBSD__ || __EMSCRIPTEN__ || __MVS__
-
-// template <> class ctype_byname<char>
-
-ctype_byname<char>::ctype_byname(const char* name, size_t refs)
-    : ctype<char>(0, false, refs),
-      __l_(newlocale(LC_ALL_MASK, name, 0))
-{
-    if (__l_ == 0)
-        __throw_runtime_error("ctype_byname<char>::ctype_byname"
-                            " failed to construct for " + string(name));
-}
-
-ctype_byname<char>::ctype_byname(const string& name, size_t refs)
-    : ctype<char>(0, false, refs),
-      __l_(newlocale(LC_ALL_MASK, name.c_str(), 0))
-{
-    if (__l_ == 0)
-        __throw_runtime_error("ctype_byname<char>::ctype_byname"
-                            " failed to construct for " + name);
-}
-
-ctype_byname<char>::~ctype_byname()
-{
-    freelocale(__l_);
-}
-
-char
-ctype_byname<char>::do_toupper(char_type c) const
-{
-    return static_cast<char>(toupper_l(static_cast<unsigned char>(c), __l_));
-}
-
-const char*
-ctype_byname<char>::do_toupper(char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-        *low = static_cast<char>(toupper_l(static_cast<unsigned char>(*low), __l_));
-    return low;
-}
-
-char
-ctype_byname<char>::do_tolower(char_type c) const
-{
-    return static_cast<char>(tolower_l(static_cast<unsigned char>(c), __l_));
-}
-
-const char*
-ctype_byname<char>::do_tolower(char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-        *low = static_cast<char>(tolower_l(static_cast<unsigned char>(*low), __l_));
-    return low;
-}
-
-// template <> class ctype_byname<wchar_t>
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
-    : ctype<wchar_t>(refs),
-      __l_(newlocale(LC_ALL_MASK, name, 0))
-{
-    if (__l_ == 0)
-        __throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
-                            " failed to construct for " + string(name));
-}
-
-ctype_byname<wchar_t>::ctype_byname(const string& name, size_t refs)
-    : ctype<wchar_t>(refs),
-      __l_(newlocale(LC_ALL_MASK, name.c_str(), 0))
-{
-    if (__l_ == 0)
-        __throw_runtime_error("ctype_byname<wchar_t>::ctype_byname"
-                            " failed to construct for " + name);
-}
-
-ctype_byname<wchar_t>::~ctype_byname()
-{
-    freelocale(__l_);
-}
-
-bool
-ctype_byname<wchar_t>::do_is(mask m, char_type c) const
-{
-#ifdef _LIBCPP_WCTYPE_IS_MASK
-    return static_cast<bool>(iswctype_l(c, m, __l_));
-#else
-    bool result = false;
-    wint_t ch = static_cast<wint_t>(c);
-    if ((m & space) == space) result |= (iswspace_l(ch, __l_) != 0);
-    if ((m & print) == print) result |= (iswprint_l(ch, __l_) != 0);
-    if ((m & cntrl) == cntrl) result |= (iswcntrl_l(ch, __l_) != 0);
-    if ((m & upper) == upper) result |= (iswupper_l(ch, __l_) != 0);
-    if ((m & lower) == lower) result |= (iswlower_l(ch, __l_) != 0);
-    if ((m & alpha) == alpha) result |= (iswalpha_l(ch, __l_) != 0);
-    if ((m & digit) == digit) result |= (iswdigit_l(ch, __l_) != 0);
-    if ((m & punct) == punct) result |= (iswpunct_l(ch, __l_) != 0);
-    if ((m & xdigit) == xdigit) result |= (iswxdigit_l(ch, __l_) != 0);
-    if ((m & blank) == blank) result |= (iswblank_l(ch, __l_) != 0);
-    return result;
-#endif
-}
-
-const wchar_t*
-ctype_byname<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const
-{
-    for (; low != high; ++low, ++vec)
-    {
-        if (isascii(*low))
-            *vec = static_cast<mask>(ctype<char>::classic_table()[*low]);
-        else
-        {
-            *vec = 0;
-            wint_t ch = static_cast<wint_t>(*low);
-            if (iswspace_l(ch, __l_))
-                *vec |= space;
-#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_PRINT
-            if (iswprint_l(ch, __l_))
-                *vec |= print;
-#endif
-            if (iswcntrl_l(ch, __l_))
-                *vec |= cntrl;
-            if (iswupper_l(ch, __l_))
-                *vec |= upper;
-            if (iswlower_l(ch, __l_))
-                *vec |= lower;
-#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_ALPHA
-            if (iswalpha_l(ch, __l_))
-                *vec |= alpha;
-#endif
-            if (iswdigit_l(ch, __l_))
-                *vec |= digit;
-            if (iswpunct_l(ch, __l_))
-                *vec |= punct;
-#ifndef _LIBCPP_CTYPE_MASK_IS_COMPOSITE_XDIGIT
-            if (iswxdigit_l(ch, __l_))
-                *vec |= xdigit;
-#endif
-            if (iswblank_l(ch, __l_))
-                *vec |= blank;
-        }
-    }
-    return low;
-}
-
-const wchar_t*
-ctype_byname<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-    {
-#ifdef _LIBCPP_WCTYPE_IS_MASK
-        if (iswctype_l(*low, m, __l_))
-            break;
-#else
-        wint_t ch = static_cast<wint_t>(*low);
-        if ((m & space) == space && iswspace_l(ch, __l_)) break;
-        if ((m & print) == print && iswprint_l(ch, __l_)) break;
-        if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l_)) break;
-        if ((m & upper) == upper && iswupper_l(ch, __l_)) break;
-        if ((m & lower) == lower && iswlower_l(ch, __l_)) break;
-        if ((m & alpha) == alpha && iswalpha_l(ch, __l_)) break;
-        if ((m & digit) == digit && iswdigit_l(ch, __l_)) break;
-        if ((m & punct) == punct && iswpunct_l(ch, __l_)) break;
-        if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l_)) break;
-        if ((m & blank) == blank && iswblank_l(ch, __l_)) break;
-#endif
-    }
-    return low;
-}
-
-const wchar_t*
-ctype_byname<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-    {
-#ifdef _LIBCPP_WCTYPE_IS_MASK
-        if (!iswctype_l(*low, m, __l_))
-            break;
-#else
-        wint_t ch = static_cast<wint_t>(*low);
-        if ((m & space) == space && iswspace_l(ch, __l_)) continue;
-        if ((m & print) == print && iswprint_l(ch, __l_)) continue;
-        if ((m & cntrl) == cntrl && iswcntrl_l(ch, __l_)) continue;
-        if ((m & upper) == upper && iswupper_l(ch, __l_)) continue;
-        if ((m & lower) == lower && iswlower_l(ch, __l_)) continue;
-        if ((m & alpha) == alpha && iswalpha_l(ch, __l_)) continue;
-        if ((m & digit) == digit && iswdigit_l(ch, __l_)) continue;
-        if ((m & punct) == punct && iswpunct_l(ch, __l_)) continue;
-        if ((m & xdigit) == xdigit && iswxdigit_l(ch, __l_)) continue;
-        if ((m & blank) == blank && iswblank_l(ch, __l_)) continue;
-        break;
-#endif
-    }
-    return low;
-}
-
-wchar_t
-ctype_byname<wchar_t>::do_toupper(char_type c) const
-{
-    return towupper_l(c, __l_);
-}
-
-const wchar_t*
-ctype_byname<wchar_t>::do_toupper(char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-        *low = towupper_l(*low, __l_);
-    return low;
-}
-
-wchar_t
-ctype_byname<wchar_t>::do_tolower(char_type c) const
-{
-    return towlower_l(c, __l_);
-}
-
-const wchar_t*
-ctype_byname<wchar_t>::do_tolower(char_type* low, const char_type* high) const
-{
-    for (; low != high; ++low)
-        *low = towlower_l(*low, __l_);
-    return low;
-}
-
-wchar_t
-ctype_byname<wchar_t>::do_widen(char c) const
-{
-    return __libcpp_btowc_l(c, __l_);
-}
-
-const char*
-ctype_byname<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const
-{
-    for (; low != high; ++low, ++dest)
-        *dest = __libcpp_btowc_l(*low, __l_);
-    return low;
-}
-
-char
-ctype_byname<wchar_t>::do_narrow(char_type c, char dfault) const
-{
-    int r = __libcpp_wctob_l(c, __l_);
-    return (r != EOF) ? static_cast<char>(r) : dfault;
-}
-
-const wchar_t*
-ctype_byname<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
-{
-    for (; low != high; ++low, ++dest)
-    {
-        int r = __libcpp_wctob_l(*low, __l_);
-        *dest = (r != EOF) ? static_cast<char>(r) : dfault;
-    }
-    return low;
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// template <> class codecvt<char, char, mbstate_t>
-
-locale::id codecvt<char, char, mbstate_t>::id;
-
-codecvt<char, char, mbstate_t>::~codecvt()
-{
-}
-
-codecvt<char, char, mbstate_t>::result
-codecvt<char, char, mbstate_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type*, const intern_type*& frm_nxt,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    return noconv;
-}
-
-codecvt<char, char, mbstate_t>::result
-codecvt<char, char, mbstate_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type*, const extern_type*& frm_nxt,
-    intern_type* to, intern_type*, intern_type*& to_nxt) const
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    return noconv;
-}
-
-codecvt<char, char, mbstate_t>::result
-codecvt<char, char, mbstate_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-codecvt<char, char, mbstate_t>::do_encoding() const noexcept
-{
-    return 1;
-}
-
-bool
-codecvt<char, char, mbstate_t>::do_always_noconv() const noexcept
-{
-    return true;
-}
-
-int
-codecvt<char, char, mbstate_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* end, size_t mx) const
-{
-    return static_cast<int>(min<size_t>(mx, static_cast<size_t>(end-frm)));
-}
-
-int
-codecvt<char, char, mbstate_t>::do_max_length() const noexcept
-{
-    return 1;
-}
-
-// template <> class codecvt<wchar_t, char, mbstate_t>
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-locale::id codecvt<wchar_t, char, mbstate_t>::id;
-
-codecvt<wchar_t, char, mbstate_t>::codecvt(size_t refs)
-    : locale::facet(refs),
-      __l_(_LIBCPP_GET_C_LOCALE)
-{
-}
-
-codecvt<wchar_t, char, mbstate_t>::codecvt(const char* nm, size_t refs)
-    : locale::facet(refs),
-      __l_(newlocale(LC_ALL_MASK, nm, 0))
-{
-    if (__l_ == 0)
-        __throw_runtime_error("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
-                            " failed to construct for " + string(nm));
-}
-
-codecvt<wchar_t, char, mbstate_t>::~codecvt()
-{
-    if (__l_ != _LIBCPP_GET_C_LOCALE)
-        freelocale(__l_);
-}
-
-codecvt<wchar_t, char, mbstate_t>::result
-codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    // look for first internal null in frm
-    const intern_type* fend = frm;
-    for (; fend != frm_end; ++fend)
-        if (*fend == 0)
-            break;
-    // loop over all null-terminated sequences in frm
-    to_nxt = to;
-    for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt)
-    {
-        // save state in case it is needed to recover to_nxt on error
-        mbstate_t save_state = st;
-        size_t n = __libcpp_wcsnrtombs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
-                                     static_cast<size_t>(to_end-to), &st, __l_);
-        if (n == size_t(-1))
-        {
-            // need to recover to_nxt
-            for (to_nxt = to; frm != frm_nxt; ++frm)
-            {
-                n = __libcpp_wcrtomb_l(to_nxt, *frm, &save_state, __l_);
-                if (n == size_t(-1))
-                    break;
-                to_nxt += n;
-            }
-            frm_nxt = frm;
-            return error;
-        }
-        if (n == 0)
-            return partial;
-        to_nxt += n;
-        if (to_nxt == to_end)
-            break;
-        if (fend != frm_end)  // set up next null terminated sequence
-        {
-            // Try to write the terminating null
-            extern_type tmp[MB_LEN_MAX];
-            n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l_);
-            if (n == size_t(-1))  // on error
-                return error;
-            if (n > static_cast<size_t>(to_end-to_nxt))  // is there room?
-                return partial;
-            for (extern_type* p = tmp; n; --n)  // write it
-                *to_nxt++ = *p++;
-            ++frm_nxt;
-            // look for next null in frm
-            for (fend = frm_nxt; fend != frm_end; ++fend)
-                if (*fend == 0)
-                    break;
-        }
-    }
-    return frm_nxt == frm_end ? ok : partial;
-}
-
-codecvt<wchar_t, char, mbstate_t>::result
-codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    // look for first internal null in frm
-    const extern_type* fend = frm;
-    for (; fend != frm_end; ++fend)
-        if (*fend == 0)
-            break;
-    // loop over all null-terminated sequences in frm
-    to_nxt = to;
-    for (frm_nxt = frm; frm != frm_end && to != to_end; frm = frm_nxt, to = to_nxt)
-    {
-        // save state in case it is needed to recover to_nxt on error
-        mbstate_t save_state = st;
-        size_t n = __libcpp_mbsnrtowcs_l(to, &frm_nxt, static_cast<size_t>(fend-frm),
-                                     static_cast<size_t>(to_end-to), &st, __l_);
-        if (n == size_t(-1))
-        {
-            // need to recover to_nxt
-            for (to_nxt = to; frm != frm_nxt; ++to_nxt)
-            {
-                n = __libcpp_mbrtowc_l(to_nxt, frm, static_cast<size_t>(fend-frm),
-                                   &save_state, __l_);
-                switch (n)
-                {
-                case 0:
-                    ++frm;
-                    break;
-                case size_t(-1):
-                    frm_nxt = frm;
-                    return error;
-                case size_t(-2):
-                    frm_nxt = frm;
-                    return partial;
-                default:
-                    frm += n;
-                    break;
-                }
-            }
-            frm_nxt = frm;
-            return frm_nxt == frm_end ? ok : partial;
-        }
-        if (n == size_t(-1))
-            return error;
-        to_nxt += n;
-        if (to_nxt == to_end)
-            break;
-        if (fend != frm_end)  // set up next null terminated sequence
-        {
-            // Try to write the terminating null
-            n = __libcpp_mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l_);
-            if (n != 0)  // on error
-                return error;
-            ++to_nxt;
-            ++frm_nxt;
-            // look for next null in frm
-            for (fend = frm_nxt; fend != frm_end; ++fend)
-                if (*fend == 0)
-                    break;
-        }
-    }
-    return frm_nxt == frm_end ? ok : partial;
-}
-
-codecvt<wchar_t, char, mbstate_t>::result
-codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& st,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    extern_type tmp[MB_LEN_MAX];
-    size_t n = __libcpp_wcrtomb_l(tmp, intern_type(), &st, __l_);
-    if (n == size_t(-1) || n == 0)  // on error
-        return error;
-    --n;
-    if (n > static_cast<size_t>(to_end-to_nxt))  // is there room?
-        return partial;
-    for (extern_type* p = tmp; n; --n)  // write it
-        *to_nxt++ = *p++;
-    return ok;
-}
-
-int
-codecvt<wchar_t, char, mbstate_t>::do_encoding() const noexcept
-{
-    if (__libcpp_mbtowc_l(nullptr, nullptr, MB_LEN_MAX, __l_) != 0)
-        return -1;
-
-    // stateless encoding
-    if (__l_ == 0 || __libcpp_mb_cur_max_l(__l_) == 1)  // there are no known constant length encodings
-        return 1;                // which take more than 1 char to form a wchar_t
-    return 0;
-}
-
-bool
-codecvt<wchar_t, char, mbstate_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-codecvt<wchar_t, char, mbstate_t>::do_length(state_type& st,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    int nbytes = 0;
-    for (size_t nwchar_t = 0; nwchar_t < mx && frm != frm_end; ++nwchar_t)
-    {
-        size_t n = __libcpp_mbrlen_l(frm, static_cast<size_t>(frm_end-frm), &st, __l_);
-        switch (n)
-        {
-        case 0:
-            ++nbytes;
-            ++frm;
-            break;
-        case size_t(-1):
-        case size_t(-2):
-            return nbytes;
-        default:
-            nbytes += n;
-            frm += n;
-            break;
-        }
-    }
-    return nbytes;
-}
-
-int
-codecvt<wchar_t, char, mbstate_t>::do_max_length() const noexcept
-{
-    return __l_ == 0 ? 1 : static_cast<int>(__libcpp_mb_cur_max_l(__l_));
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-//                                     Valid UTF ranges
-//     UTF-32               UTF-16                          UTF-8               # of code points
-//                     first      second       first   second    third   fourth
-// 000000 - 00007F  0000 - 007F               00 - 7F                                 127
-// 000080 - 0007FF  0080 - 07FF               C2 - DF, 80 - BF                       1920
-// 000800 - 000FFF  0800 - 0FFF               E0 - E0, A0 - BF, 80 - BF              2048
-// 001000 - 00CFFF  1000 - CFFF               E1 - EC, 80 - BF, 80 - BF             49152
-// 00D000 - 00D7FF  D000 - D7FF               ED - ED, 80 - 9F, 80 - BF              2048
-// 00D800 - 00DFFF                invalid
-// 00E000 - 00FFFF  E000 - FFFF               EE - EF, 80 - BF, 80 - BF              8192
-// 010000 - 03FFFF  D800 - D8BF, DC00 - DFFF  F0 - F0, 90 - BF, 80 - BF, 80 - BF   196608
-// 040000 - 0FFFFF  D8C0 - DBBF, DC00 - DFFF  F1 - F3, 80 - BF, 80 - BF, 80 - BF   786432
-// 100000 - 10FFFF  DBC0 - DBFF, DC00 - DFFF  F4 - F4, 80 - 8F, 80 - BF, 80 - BF    65536
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-static
-codecvt_base::result
-utf16_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
-              uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
-              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & generate_header)
-    {
-        if (to_end-to_nxt < 3)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(0xEF);
-        *to_nxt++ = static_cast<uint8_t>(0xBB);
-        *to_nxt++ = static_cast<uint8_t>(0xBF);
-    }
-    for (; frm_nxt < frm_end; ++frm_nxt)
-    {
-        uint16_t wc1 = *frm_nxt;
-        if (wc1 > Maxcode)
-            return codecvt_base::error;
-        if (wc1 < 0x0080)
-        {
-            if (to_end-to_nxt < 1)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(wc1);
-        }
-        else if (wc1 < 0x0800)
-        {
-            if (to_end-to_nxt < 2)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
-        }
-        else if (wc1 < 0xD800)
-        {
-            if (to_end-to_nxt < 3)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
-        }
-        else if (wc1 < 0xDC00)
-        {
-            if (frm_end-frm_nxt < 2)
-                return codecvt_base::partial;
-            uint16_t wc2 = frm_nxt[1];
-            if ((wc2 & 0xFC00) != 0xDC00)
-                return codecvt_base::error;
-            if (to_end-to_nxt < 4)
-                return codecvt_base::partial;
-            if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) +
-                ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
-                return codecvt_base::error;
-            ++frm_nxt;
-            uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
-            *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4)     | ((wc1 & 0x003C) >> 2));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc2 & 0x003F));
-        }
-        else if (wc1 < 0xE000)
-        {
-            return codecvt_base::error;
-        }
-        else
-        {
-            if (to_end-to_nxt < 3)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
-        }
-    }
-    return codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf16_to_utf8(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
-              uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
-              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & generate_header)
-    {
-        if (to_end-to_nxt < 3)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(0xEF);
-        *to_nxt++ = static_cast<uint8_t>(0xBB);
-        *to_nxt++ = static_cast<uint8_t>(0xBF);
-    }
-    for (; frm_nxt < frm_end; ++frm_nxt)
-    {
-        uint16_t wc1 = static_cast<uint16_t>(*frm_nxt);
-        if (wc1 > Maxcode)
-            return codecvt_base::error;
-        if (wc1 < 0x0080)
-        {
-            if (to_end-to_nxt < 1)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(wc1);
-        }
-        else if (wc1 < 0x0800)
-        {
-            if (to_end-to_nxt < 2)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc1 >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | (wc1 & 0x03F));
-        }
-        else if (wc1 < 0xD800)
-        {
-            if (to_end-to_nxt < 3)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
-        }
-        else if (wc1 < 0xDC00)
-        {
-            if (frm_end-frm_nxt < 2)
-                return codecvt_base::partial;
-            uint16_t wc2 = static_cast<uint16_t>(frm_nxt[1]);
-            if ((wc2 & 0xFC00) != 0xDC00)
-                return codecvt_base::error;
-            if (to_end-to_nxt < 4)
-                return codecvt_base::partial;
-            if (((((wc1 & 0x03C0UL) >> 6) + 1) << 16) +
-                ((wc1 & 0x003FUL) << 10) + (wc2 & 0x03FF) > Maxcode)
-                return codecvt_base::error;
-            ++frm_nxt;
-            uint8_t z = ((wc1 & 0x03C0) >> 6) + 1;
-            *to_nxt++ = static_cast<uint8_t>(0xF0 | (z >> 2));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((z & 0x03) << 4)     | ((wc1 & 0x003C) >> 2));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0003) << 4) | ((wc2 & 0x03C0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc2 & 0x003F));
-        }
-        else if (wc1 < 0xE000)
-        {
-            return codecvt_base::error;
-        }
-        else
-        {
-            if (to_end-to_nxt < 3)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc1 >> 12));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc1 & 0x0FC0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc1 & 0x003F));
-        }
-    }
-    return codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf8_to_utf16(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
-              uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
-              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
-                                                          frm_nxt[2] == 0xBF)
-            frm_nxt += 3;
-    }
-    for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
-    {
-        uint8_t c1 = *frm_nxt;
-        if (c1 > Maxcode)
-            return codecvt_base::error;
-        if (c1 < 0x80)
-        {
-            *to_nxt = static_cast<uint16_t>(c1);
-            ++frm_nxt;
-        }
-        else if (c1 < 0xC2)
-        {
-            return codecvt_base::error;
-        }
-        else if (c1 < 0xE0)
-        {
-            if (frm_end-frm_nxt < 2)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            if ((c2 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = t;
-            frm_nxt += 2;
-        }
-        else if (c1 < 0xF0)
-        {
-            if (frm_end-frm_nxt < 3)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            switch (c1)
-            {
-            case 0xE0:
-                if ((c2 & 0xE0) != 0xA0)
-                    return codecvt_base::error;
-                 break;
-            case 0xED:
-                if ((c2 & 0xE0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
-                                             | ((c2 & 0x3F) << 6)
-                                             |  (c3 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = t;
-            frm_nxt += 3;
-        }
-        else if (c1 < 0xF5)
-        {
-            if (frm_end-frm_nxt < 4)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            uint8_t c4 = frm_nxt[3];
-            switch (c1)
-            {
-            case 0xF0:
-                if (!(0x90 <= c2 && c2 <= 0xBF))
-                    return codecvt_base::error;
-                 break;
-            case 0xF4:
-                if ((c2 & 0xF0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            if (to_end-to_nxt < 2)
-                return codecvt_base::partial;
-            if ((((c1 & 7UL) << 18) +
-                ((c2 & 0x3FUL) << 12) +
-                ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint16_t>(
-                    0xD800
-                  | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6)
-                  | ((c2 & 0x0F) << 2)
-                  | ((c3 & 0x30) >> 4));
-            *++to_nxt = static_cast<uint16_t>(
-                    0xDC00
-                  | ((c3 & 0x0F) << 6)
-                  |  (c4 & 0x3F));
-            frm_nxt += 4;
-        }
-        else
-        {
-            return codecvt_base::error;
-        }
-    }
-    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf8_to_utf16(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
-              uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
-              unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
-                                                          frm_nxt[2] == 0xBF)
-            frm_nxt += 3;
-    }
-    for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
-    {
-        uint8_t c1 = *frm_nxt;
-        if (c1 > Maxcode)
-            return codecvt_base::error;
-        if (c1 < 0x80)
-        {
-            *to_nxt = static_cast<uint32_t>(c1);
-            ++frm_nxt;
-        }
-        else if (c1 < 0xC2)
-        {
-            return codecvt_base::error;
-        }
-        else if (c1 < 0xE0)
-        {
-            if (frm_end-frm_nxt < 2)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            if ((c2 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (c2 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint32_t>(t);
-            frm_nxt += 2;
-        }
-        else if (c1 < 0xF0)
-        {
-            if (frm_end-frm_nxt < 3)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            switch (c1)
-            {
-            case 0xE0:
-                if ((c2 & 0xE0) != 0xA0)
-                    return codecvt_base::error;
-                 break;
-            case 0xED:
-                if ((c2 & 0xE0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
-                                             | ((c2 & 0x3F) << 6)
-                                             |  (c3 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint32_t>(t);
-            frm_nxt += 3;
-        }
-        else if (c1 < 0xF5)
-        {
-            if (frm_end-frm_nxt < 4)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            uint8_t c4 = frm_nxt[3];
-            switch (c1)
-            {
-            case 0xF0:
-                if (!(0x90 <= c2 && c2 <= 0xBF))
-                    return codecvt_base::error;
-                 break;
-            case 0xF4:
-                if ((c2 & 0xF0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            if (to_end-to_nxt < 2)
-                return codecvt_base::partial;
-            if ((((c1 & 7UL) << 18) +
-                ((c2 & 0x3FUL) << 12) +
-                ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint32_t>(
-                    0xD800
-                  | (((((c1 & 0x07) << 2) | ((c2 & 0x30) >> 4)) - 1) << 6)
-                  | ((c2 & 0x0F) << 2)
-                  | ((c3 & 0x30) >> 4));
-            *++to_nxt = static_cast<uint32_t>(
-                    0xDC00
-                  | ((c3 & 0x0F) << 6)
-                  |  (c4 & 0x3F));
-            frm_nxt += 4;
-        }
-        else
-        {
-            return codecvt_base::error;
-        }
-    }
-    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
-}
-
-static
-int
-utf8_to_utf16_length(const uint8_t* frm, const uint8_t* frm_end,
-                     size_t mx, unsigned long Maxcode = 0x10FFFF,
-                     codecvt_mode mode = codecvt_mode(0))
-{
-    const uint8_t* frm_nxt = frm;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
-                                                          frm_nxt[2] == 0xBF)
-            frm_nxt += 3;
-    }
-    for (size_t nchar16_t = 0; frm_nxt < frm_end && nchar16_t < mx; ++nchar16_t)
-    {
-        uint8_t c1 = *frm_nxt;
-        if (c1 > Maxcode)
-            break;
-        if (c1 < 0x80)
-        {
-            ++frm_nxt;
-        }
-        else if (c1 < 0xC2)
-        {
-            break;
-        }
-        else if (c1 < 0xE0)
-        {
-            if ((frm_end-frm_nxt < 2) || (frm_nxt[1] & 0xC0) != 0x80)
-                break;
-            uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6) | (frm_nxt[1] & 0x3F));
-            if (t > Maxcode)
-                break;
-            frm_nxt += 2;
-        }
-        else if (c1 < 0xF0)
-        {
-            if (frm_end-frm_nxt < 3)
-                break;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            switch (c1)
-            {
-            case 0xE0:
-                if ((c2 & 0xE0) != 0xA0)
-                    return static_cast<int>(frm_nxt - frm);
-                break;
-            case 0xED:
-                if ((c2 & 0xE0) != 0x80)
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80)
-                break;
-            if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
-                break;
-            frm_nxt += 3;
-        }
-        else if (c1 < 0xF5)
-        {
-            if (frm_end-frm_nxt < 4 || mx-nchar16_t < 2)
-                break;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            uint8_t c4 = frm_nxt[3];
-            switch (c1)
-            {
-            case 0xF0:
-                if (!(0x90 <= c2 && c2 <= 0xBF))
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            case 0xF4:
-                if ((c2 & 0xF0) != 0x80)
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
-                break;
-            if ((((c1 & 7UL) << 18) +
-                ((c2 & 0x3FUL) << 12) +
-                ((c3 & 0x3FUL) << 6) + (c4 & 0x3F)) > Maxcode)
-                break;
-            ++nchar16_t;
-            frm_nxt += 4;
-        }
-        else
-        {
-            break;
-        }
-    }
-    return static_cast<int>(frm_nxt - frm);
-}
-
-static
-codecvt_base::result
-ucs4_to_utf8(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
-             uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
-             unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & generate_header)
-    {
-        if (to_end-to_nxt < 3)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(0xEF);
-        *to_nxt++ = static_cast<uint8_t>(0xBB);
-        *to_nxt++ = static_cast<uint8_t>(0xBF);
-    }
-    for (; frm_nxt < frm_end; ++frm_nxt)
-    {
-        uint32_t wc = *frm_nxt;
-        if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
-            return codecvt_base::error;
-        if (wc < 0x000080)
-        {
-            if (to_end-to_nxt < 1)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(wc);
-        }
-        else if (wc < 0x000800)
-        {
-            if (to_end-to_nxt < 2)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
-        }
-        else if (wc < 0x010000)
-        {
-            if (to_end-to_nxt < 3)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc >> 12));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc & 0x003F));
-        }
-        else // if (wc < 0x110000)
-        {
-            if (to_end-to_nxt < 4)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xF0 |  (wc >> 18));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x03F000) >> 12));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x000FC0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc & 0x00003F));
-        }
-    }
-    return codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf8_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
-             uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
-             unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
-                                                          frm_nxt[2] == 0xBF)
-            frm_nxt += 3;
-    }
-    for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
-    {
-        uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
-        if (c1 < 0x80)
-        {
-            if (c1 > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint32_t>(c1);
-            ++frm_nxt;
-        }
-        else if (c1 < 0xC2)
-        {
-            return codecvt_base::error;
-        }
-        else if (c1 < 0xE0)
-        {
-            if (frm_end-frm_nxt < 2)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            if ((c2 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint32_t t = static_cast<uint32_t>(((c1 & 0x1F) << 6)
-                                              | (c2 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = t;
-            frm_nxt += 2;
-        }
-        else if (c1 < 0xF0)
-        {
-            if (frm_end-frm_nxt < 3)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            switch (c1)
-            {
-            case 0xE0:
-                if ((c2 & 0xE0) != 0xA0)
-                    return codecvt_base::error;
-                 break;
-            case 0xED:
-                if ((c2 & 0xE0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint32_t t = static_cast<uint32_t>(((c1 & 0x0F) << 12)
-                                             | ((c2 & 0x3F) << 6)
-                                             |  (c3 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = t;
-            frm_nxt += 3;
-        }
-        else if (c1 < 0xF5)
-        {
-            if (frm_end-frm_nxt < 4)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            uint8_t c4 = frm_nxt[3];
-            switch (c1)
-            {
-            case 0xF0:
-                if (!(0x90 <= c2 && c2 <= 0xBF))
-                    return codecvt_base::error;
-                 break;
-            case 0xF4:
-                if ((c2 & 0xF0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint32_t t = static_cast<uint32_t>(((c1 & 0x07) << 18)
-                                             | ((c2 & 0x3F) << 12)
-                                             | ((c3 & 0x3F) << 6)
-                                             |  (c4 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = t;
-            frm_nxt += 4;
-        }
-        else
-        {
-            return codecvt_base::error;
-        }
-    }
-    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
-}
-
-static
-int
-utf8_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
-                    size_t mx, unsigned long Maxcode = 0x10FFFF,
-                    codecvt_mode mode = codecvt_mode(0))
-{
-    const uint8_t* frm_nxt = frm;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
-                                                          frm_nxt[2] == 0xBF)
-            frm_nxt += 3;
-    }
-    for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t)
-    {
-        uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
-        if (c1 < 0x80)
-        {
-            if (c1 > Maxcode)
-                break;
-            ++frm_nxt;
-        }
-        else if (c1 < 0xC2)
-        {
-            break;
-        }
-        else if (c1 < 0xE0)
-        {
-            if ((frm_end-frm_nxt < 2) || ((frm_nxt[1] & 0xC0) != 0x80))
-                break;
-            if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
-                break;
-            frm_nxt += 2;
-        }
-        else if (c1 < 0xF0)
-        {
-            if (frm_end-frm_nxt < 3)
-                break;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            switch (c1)
-            {
-            case 0xE0:
-                if ((c2 & 0xE0) != 0xA0)
-                    return static_cast<int>(frm_nxt - frm);
-                break;
-            case 0xED:
-                if ((c2 & 0xE0) != 0x80)
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80)
-                break;
-            if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
-                break;
-            frm_nxt += 3;
-        }
-        else if (c1 < 0xF5)
-        {
-            if (frm_end-frm_nxt < 4)
-                break;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            uint8_t c4 = frm_nxt[3];
-            switch (c1)
-            {
-            case 0xF0:
-                if (!(0x90 <= c2 && c2 <= 0xBF))
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            case 0xF4:
-                if ((c2 & 0xF0) != 0x80)
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80 || (c4 & 0xC0) != 0x80)
-                break;
-            if ((((c1 & 0x07u) << 18) | ((c2 & 0x3Fu) << 12) |
-                 ((c3 & 0x3Fu) << 6)  |  (c4 & 0x3Fu)) > Maxcode)
-                break;
-            frm_nxt += 4;
-        }
-        else
-        {
-            break;
-        }
-    }
-    return static_cast<int>(frm_nxt - frm);
-}
-
-static
-codecvt_base::result
-ucs2_to_utf8(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
-             uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
-             unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & generate_header)
-    {
-        if (to_end-to_nxt < 3)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(0xEF);
-        *to_nxt++ = static_cast<uint8_t>(0xBB);
-        *to_nxt++ = static_cast<uint8_t>(0xBF);
-    }
-    for (; frm_nxt < frm_end; ++frm_nxt)
-    {
-        uint16_t wc = *frm_nxt;
-        if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
-            return codecvt_base::error;
-        if (wc < 0x0080)
-        {
-            if (to_end-to_nxt < 1)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(wc);
-        }
-        else if (wc < 0x0800)
-        {
-            if (to_end-to_nxt < 2)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xC0 | (wc >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | (wc & 0x03F));
-        }
-        else // if (wc <= 0xFFFF)
-        {
-            if (to_end-to_nxt < 3)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(0xE0 |  (wc >> 12));
-            *to_nxt++ = static_cast<uint8_t>(0x80 | ((wc & 0x0FC0) >> 6));
-            *to_nxt++ = static_cast<uint8_t>(0x80 |  (wc & 0x003F));
-        }
-    }
-    return codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf8_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
-             uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
-             unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
-                                                          frm_nxt[2] == 0xBF)
-            frm_nxt += 3;
-    }
-    for (; frm_nxt < frm_end && to_nxt < to_end; ++to_nxt)
-    {
-        uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
-        if (c1 < 0x80)
-        {
-            if (c1 > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint16_t>(c1);
-            ++frm_nxt;
-        }
-        else if (c1 < 0xC2)
-        {
-            return codecvt_base::error;
-        }
-        else if (c1 < 0xE0)
-        {
-            if (frm_end-frm_nxt < 2)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            if ((c2 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint16_t t = static_cast<uint16_t>(((c1 & 0x1F) << 6)
-                                              | (c2 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = t;
-            frm_nxt += 2;
-        }
-        else if (c1 < 0xF0)
-        {
-            if (frm_end-frm_nxt < 3)
-                return codecvt_base::partial;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            switch (c1)
-            {
-            case 0xE0:
-                if ((c2 & 0xE0) != 0xA0)
-                    return codecvt_base::error;
-                 break;
-            case 0xED:
-                if ((c2 & 0xE0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return codecvt_base::error;
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80)
-                return codecvt_base::error;
-            uint16_t t = static_cast<uint16_t>(((c1 & 0x0F) << 12)
-                                             | ((c2 & 0x3F) << 6)
-                                             |  (c3 & 0x3F));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = t;
-            frm_nxt += 3;
-        }
-        else
-        {
-            return codecvt_base::error;
-        }
-    }
-    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
-}
-
-static
-int
-utf8_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
-                    size_t mx, unsigned long Maxcode = 0x10FFFF,
-                    codecvt_mode mode = codecvt_mode(0))
-{
-    const uint8_t* frm_nxt = frm;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 3 && frm_nxt[0] == 0xEF && frm_nxt[1] == 0xBB &&
-                                                          frm_nxt[2] == 0xBF)
-            frm_nxt += 3;
-    }
-    for (size_t nchar32_t = 0; frm_nxt < frm_end && nchar32_t < mx; ++nchar32_t)
-    {
-        uint8_t c1 = static_cast<uint8_t>(*frm_nxt);
-        if (c1 < 0x80)
-        {
-            if (c1 > Maxcode)
-                break;
-            ++frm_nxt;
-        }
-        else if (c1 < 0xC2)
-        {
-            break;
-        }
-        else if (c1 < 0xE0)
-        {
-            if ((frm_end-frm_nxt < 2) || ((frm_nxt[1] & 0xC0) != 0x80))
-                break;
-            if ((((c1 & 0x1Fu) << 6) | (frm_nxt[1] & 0x3Fu)) > Maxcode)
-                break;
-            frm_nxt += 2;
-        }
-        else if (c1 < 0xF0)
-        {
-            if (frm_end-frm_nxt < 3)
-                break;
-            uint8_t c2 = frm_nxt[1];
-            uint8_t c3 = frm_nxt[2];
-            switch (c1)
-            {
-            case 0xE0:
-                if ((c2 & 0xE0) != 0xA0)
-                    return static_cast<int>(frm_nxt - frm);
-                break;
-            case 0xED:
-                if ((c2 & 0xE0) != 0x80)
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            default:
-                if ((c2 & 0xC0) != 0x80)
-                    return static_cast<int>(frm_nxt - frm);
-                 break;
-            }
-            if ((c3 & 0xC0) != 0x80)
-                break;
-            if ((((c1 & 0x0Fu) << 12) | ((c2 & 0x3Fu) << 6) | (c3 & 0x3Fu)) > Maxcode)
-                break;
-            frm_nxt += 3;
-        }
-        else
-        {
-            break;
-        }
-    }
-    return static_cast<int>(frm_nxt - frm);
-}
-
-static
-codecvt_base::result
-ucs4_to_utf16be(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
-                uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
-                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & generate_header)
-    {
-        if (to_end-to_nxt < 2)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(0xFE);
-        *to_nxt++ = static_cast<uint8_t>(0xFF);
-    }
-    for (; frm_nxt < frm_end; ++frm_nxt)
-    {
-        uint32_t wc = *frm_nxt;
-        if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
-            return codecvt_base::error;
-        if (wc < 0x010000)
-        {
-            if (to_end-to_nxt < 2)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(wc >> 8);
-            *to_nxt++ = static_cast<uint8_t>(wc);
-        }
-        else
-        {
-            if (to_end-to_nxt < 4)
-                return codecvt_base::partial;
-            uint16_t t = static_cast<uint16_t>(
-                    0xD800
-                  | ((((wc & 0x1F0000) >> 16) - 1) << 6)
-                  |   ((wc & 0x00FC00) >> 10));
-            *to_nxt++ = static_cast<uint8_t>(t >> 8);
-            *to_nxt++ = static_cast<uint8_t>(t);
-            t = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
-            *to_nxt++ = static_cast<uint8_t>(t >> 8);
-            *to_nxt++ = static_cast<uint8_t>(t);
-        }
-    }
-    return codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf16be_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
-                uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
-                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
-            frm_nxt += 2;
-    }
-    for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
-    {
-        uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
-        if ((c1 & 0xFC00) == 0xDC00)
-            return codecvt_base::error;
-        if ((c1 & 0xFC00) != 0xD800)
-        {
-            if (c1 > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint32_t>(c1);
-            frm_nxt += 2;
-        }
-        else
-        {
-            if (frm_end-frm_nxt < 4)
-                return codecvt_base::partial;
-            uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 | frm_nxt[3]);
-            if ((c2 & 0xFC00) != 0xDC00)
-                return codecvt_base::error;
-            uint32_t t = static_cast<uint32_t>(
-                    ((((c1 & 0x03C0) >> 6) + 1) << 16)
-                  |   ((c1 & 0x003F) << 10)
-                  |    (c2 & 0x03FF));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = t;
-            frm_nxt += 4;
-        }
-    }
-    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
-}
-
-static
-int
-utf16be_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
-                       size_t mx, unsigned long Maxcode = 0x10FFFF,
-                       codecvt_mode mode = codecvt_mode(0))
-{
-    const uint8_t* frm_nxt = frm;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
-            frm_nxt += 2;
-    }
-    for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t)
-    {
-        uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
-        if ((c1 & 0xFC00) == 0xDC00)
-            break;
-        if ((c1 & 0xFC00) != 0xD800)
-        {
-            if (c1 > Maxcode)
-                break;
-            frm_nxt += 2;
-        }
-        else
-        {
-            if (frm_end-frm_nxt < 4)
-                break;
-            uint16_t c2 = static_cast<uint16_t>(frm_nxt[2] << 8 | frm_nxt[3]);
-            if ((c2 & 0xFC00) != 0xDC00)
-                break;
-            uint32_t t = static_cast<uint32_t>(
-                    ((((c1 & 0x03C0) >> 6) + 1) << 16)
-                  |   ((c1 & 0x003F) << 10)
-                  |    (c2 & 0x03FF));
-            if (t > Maxcode)
-                break;
-            frm_nxt += 4;
-        }
-    }
-    return static_cast<int>(frm_nxt - frm);
-}
-
-static
-codecvt_base::result
-ucs4_to_utf16le(const uint32_t* frm, const uint32_t* frm_end, const uint32_t*& frm_nxt,
-                uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
-                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & generate_header)
-    {
-        if (to_end - to_nxt < 2)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(0xFF);
-        *to_nxt++ = static_cast<uint8_t>(0xFE);
-    }
-    for (; frm_nxt < frm_end; ++frm_nxt)
-    {
-        uint32_t wc = *frm_nxt;
-        if ((wc & 0xFFFFF800) == 0x00D800 || wc > Maxcode)
-            return codecvt_base::error;
-        if (wc < 0x010000)
-        {
-            if (to_end-to_nxt < 2)
-                return codecvt_base::partial;
-            *to_nxt++ = static_cast<uint8_t>(wc);
-            *to_nxt++ = static_cast<uint8_t>(wc >> 8);
-        }
-        else
-        {
-            if (to_end-to_nxt < 4)
-                return codecvt_base::partial;
-            uint16_t t = static_cast<uint16_t>(
-                    0xD800
-                  | ((((wc & 0x1F0000) >> 16) - 1) << 6)
-                  |   ((wc & 0x00FC00) >> 10));
-            *to_nxt++ = static_cast<uint8_t>(t);
-            *to_nxt++ = static_cast<uint8_t>(t >> 8);
-            t = static_cast<uint16_t>(0xDC00 | (wc & 0x03FF));
-            *to_nxt++ = static_cast<uint8_t>(t);
-            *to_nxt++ = static_cast<uint8_t>(t >> 8);
-        }
-    }
-    return codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf16le_to_ucs4(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
-                uint32_t* to, uint32_t* to_end, uint32_t*& to_nxt,
-                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
-            frm_nxt += 2;
-    }
-    for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
-    {
-        uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
-        if ((c1 & 0xFC00) == 0xDC00)
-            return codecvt_base::error;
-        if ((c1 & 0xFC00) != 0xD800)
-        {
-            if (c1 > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = static_cast<uint32_t>(c1);
-            frm_nxt += 2;
-        }
-        else
-        {
-            if (frm_end-frm_nxt < 4)
-                return codecvt_base::partial;
-            uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 | frm_nxt[2]);
-            if ((c2 & 0xFC00) != 0xDC00)
-                return codecvt_base::error;
-            uint32_t t = static_cast<uint32_t>(
-                    ((((c1 & 0x03C0) >> 6) + 1) << 16)
-                  |   ((c1 & 0x003F) << 10)
-                  |    (c2 & 0x03FF));
-            if (t > Maxcode)
-                return codecvt_base::error;
-            *to_nxt = t;
-            frm_nxt += 4;
-        }
-    }
-    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
-}
-
-static
-int
-utf16le_to_ucs4_length(const uint8_t* frm, const uint8_t* frm_end,
-                       size_t mx, unsigned long Maxcode = 0x10FFFF,
-                       codecvt_mode mode = codecvt_mode(0))
-{
-    const uint8_t* frm_nxt = frm;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
-            frm_nxt += 2;
-    }
-    for (size_t nchar32_t = 0; frm_nxt < frm_end - 1 && nchar32_t < mx; ++nchar32_t)
-    {
-        uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
-        if ((c1 & 0xFC00) == 0xDC00)
-            break;
-        if ((c1 & 0xFC00) != 0xD800)
-        {
-            if (c1 > Maxcode)
-                break;
-            frm_nxt += 2;
-        }
-        else
-        {
-            if (frm_end-frm_nxt < 4)
-                break;
-            uint16_t c2 = static_cast<uint16_t>(frm_nxt[3] << 8 | frm_nxt[2]);
-            if ((c2 & 0xFC00) != 0xDC00)
-                break;
-            uint32_t t = static_cast<uint32_t>(
-                    ((((c1 & 0x03C0) >> 6) + 1) << 16)
-                  |   ((c1 & 0x003F) << 10)
-                  |    (c2 & 0x03FF));
-            if (t > Maxcode)
-                break;
-            frm_nxt += 4;
-        }
-    }
-    return static_cast<int>(frm_nxt - frm);
-}
-
-static
-codecvt_base::result
-ucs2_to_utf16be(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
-                uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
-                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & generate_header)
-    {
-        if (to_end-to_nxt < 2)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(0xFE);
-        *to_nxt++ = static_cast<uint8_t>(0xFF);
-    }
-    for (; frm_nxt < frm_end; ++frm_nxt)
-    {
-        uint16_t wc = *frm_nxt;
-        if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
-            return codecvt_base::error;
-        if (to_end-to_nxt < 2)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(wc >> 8);
-        *to_nxt++ = static_cast<uint8_t>(wc);
-    }
-    return codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf16be_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
-                uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
-                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
-            frm_nxt += 2;
-    }
-    for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
-    {
-        uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
-        if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
-            return codecvt_base::error;
-        *to_nxt = c1;
-        frm_nxt += 2;
-    }
-    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
-}
-
-static
-int
-utf16be_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
-                       size_t mx, unsigned long Maxcode = 0x10FFFF,
-                       codecvt_mode mode = codecvt_mode(0))
-{
-    const uint8_t* frm_nxt = frm;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFE && frm_nxt[1] == 0xFF)
-            frm_nxt += 2;
-    }
-    for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
-    {
-        uint16_t c1 = static_cast<uint16_t>(frm_nxt[0] << 8 | frm_nxt[1]);
-        if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
-            break;
-        frm_nxt += 2;
-    }
-    return static_cast<int>(frm_nxt - frm);
-}
-
-static
-codecvt_base::result
-ucs2_to_utf16le(const uint16_t* frm, const uint16_t* frm_end, const uint16_t*& frm_nxt,
-                uint8_t* to, uint8_t* to_end, uint8_t*& to_nxt,
-                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & generate_header)
-    {
-        if (to_end-to_nxt < 2)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(0xFF);
-        *to_nxt++ = static_cast<uint8_t>(0xFE);
-    }
-    for (; frm_nxt < frm_end; ++frm_nxt)
-    {
-        uint16_t wc = *frm_nxt;
-        if ((wc & 0xF800) == 0xD800 || wc > Maxcode)
-            return codecvt_base::error;
-        if (to_end-to_nxt < 2)
-            return codecvt_base::partial;
-        *to_nxt++ = static_cast<uint8_t>(wc);
-        *to_nxt++ = static_cast<uint8_t>(wc >> 8);
-    }
-    return codecvt_base::ok;
-}
-
-static
-codecvt_base::result
-utf16le_to_ucs2(const uint8_t* frm, const uint8_t* frm_end, const uint8_t*& frm_nxt,
-                uint16_t* to, uint16_t* to_end, uint16_t*& to_nxt,
-                unsigned long Maxcode = 0x10FFFF, codecvt_mode mode = codecvt_mode(0))
-{
-    frm_nxt = frm;
-    to_nxt = to;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
-            frm_nxt += 2;
-    }
-    for (; frm_nxt < frm_end - 1 && to_nxt < to_end; ++to_nxt)
-    {
-        uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
-        if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
-            return codecvt_base::error;
-        *to_nxt = c1;
-        frm_nxt += 2;
-    }
-    return frm_nxt < frm_end ? codecvt_base::partial : codecvt_base::ok;
-}
-
-static
-int
-utf16le_to_ucs2_length(const uint8_t* frm, const uint8_t* frm_end,
-                       size_t mx, unsigned long Maxcode = 0x10FFFF,
-                       codecvt_mode mode = codecvt_mode(0))
-{
-    const uint8_t* frm_nxt = frm;
-    frm_nxt = frm;
-    if (mode & consume_header)
-    {
-        if (frm_end-frm_nxt >= 2 && frm_nxt[0] == 0xFF && frm_nxt[1] == 0xFE)
-            frm_nxt += 2;
-    }
-    for (size_t nchar16_t = 0; frm_nxt < frm_end - 1 && nchar16_t < mx; ++nchar16_t)
-    {
-        uint16_t c1 = static_cast<uint16_t>(frm_nxt[1] << 8 | frm_nxt[0]);
-        if ((c1 & 0xF800) == 0xD800 || c1 > Maxcode)
-            break;
-        frm_nxt += 2;
-    }
-    return static_cast<int>(frm_nxt - frm);
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-// template <> class codecvt<char16_t, char, mbstate_t>
-
-locale::id codecvt<char16_t, char, mbstate_t>::id;
-
-codecvt<char16_t, char, mbstate_t>::~codecvt()
-{
-}
-
-codecvt<char16_t, char, mbstate_t>::result
-codecvt<char16_t, char, mbstate_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-codecvt<char16_t, char, mbstate_t>::result
-codecvt<char16_t, char, mbstate_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
-    result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-codecvt<char16_t, char, mbstate_t>::result
-codecvt<char16_t, char, mbstate_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-codecvt<char16_t, char, mbstate_t>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-codecvt<char16_t, char, mbstate_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-codecvt<char16_t, char, mbstate_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf8_to_utf16_length(_frm, _frm_end, mx);
-}
-
-int
-codecvt<char16_t, char, mbstate_t>::do_max_length() const noexcept
-{
-    return 4;
-}
-
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-
-// template <> class codecvt<char16_t, char8_t, mbstate_t>
-
-locale::id codecvt<char16_t, char8_t, mbstate_t>::id;
-
-codecvt<char16_t, char8_t, mbstate_t>::~codecvt()
-{
-}
-
-codecvt<char16_t, char8_t, mbstate_t>::result
-codecvt<char16_t, char8_t, mbstate_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-codecvt<char16_t, char8_t, mbstate_t>::result
-codecvt<char16_t, char8_t, mbstate_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
-    result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-codecvt<char16_t, char8_t, mbstate_t>::result
-codecvt<char16_t, char8_t, mbstate_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-codecvt<char16_t, char8_t, mbstate_t>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-codecvt<char16_t, char8_t, mbstate_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-codecvt<char16_t, char8_t, mbstate_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf8_to_utf16_length(_frm, _frm_end, mx);
-}
-
-int
-codecvt<char16_t, char8_t, mbstate_t>::do_max_length() const noexcept
-{
-    return 4;
-}
-
-#endif
-
-// template <> class codecvt<char32_t, char, mbstate_t>
-
-locale::id codecvt<char32_t, char, mbstate_t>::id;
-
-codecvt<char32_t, char, mbstate_t>::~codecvt()
-{
-}
-
-codecvt<char32_t, char, mbstate_t>::result
-codecvt<char32_t, char, mbstate_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-codecvt<char32_t, char, mbstate_t>::result
-codecvt<char32_t, char, mbstate_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
-    result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-codecvt<char32_t, char, mbstate_t>::result
-codecvt<char32_t, char, mbstate_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-codecvt<char32_t, char, mbstate_t>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-codecvt<char32_t, char, mbstate_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-codecvt<char32_t, char, mbstate_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf8_to_ucs4_length(_frm, _frm_end, mx);
-}
-
-int
-codecvt<char32_t, char, mbstate_t>::do_max_length() const noexcept
-{
-    return 4;
-}
-
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-
-// template <> class codecvt<char32_t, char8_t, mbstate_t>
-
-locale::id codecvt<char32_t, char8_t, mbstate_t>::id;
-
-codecvt<char32_t, char8_t, mbstate_t>::~codecvt()
-{
-}
-
-codecvt<char32_t, char8_t, mbstate_t>::result
-codecvt<char32_t, char8_t, mbstate_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-codecvt<char32_t, char8_t, mbstate_t>::result
-codecvt<char32_t, char8_t, mbstate_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
-    result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-codecvt<char32_t, char8_t, mbstate_t>::result
-codecvt<char32_t, char8_t, mbstate_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-codecvt<char32_t, char8_t, mbstate_t>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-codecvt<char32_t, char8_t, mbstate_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-codecvt<char32_t, char8_t, mbstate_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf8_to_ucs4_length(_frm, _frm_end, mx);
-}
-
-int
-codecvt<char32_t, char8_t, mbstate_t>::do_max_length() const noexcept
-{
-    return 4;
-}
-
-#endif
-
-// __codecvt_utf8<wchar_t>
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-__codecvt_utf8<wchar_t>::result
-__codecvt_utf8<wchar_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-#if defined(_LIBCPP_SHORT_WCHAR)
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-#else
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-#endif
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-#if defined(_LIBCPP_SHORT_WCHAR)
-    result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                            __maxcode_, __mode_);
-#else
-    result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                            __maxcode_, __mode_);
-#endif
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8<wchar_t>::result
-__codecvt_utf8<wchar_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-#if defined(_LIBCPP_SHORT_WCHAR)
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
-    result r = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                            __maxcode_, __mode_);
-#else
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
-    result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                            __maxcode_, __mode_);
-#endif
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8<wchar_t>::result
-__codecvt_utf8<wchar_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf8<wchar_t>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf8<wchar_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf8<wchar_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-#if defined(_LIBCPP_SHORT_WCHAR)
-    return utf8_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-#else
-    return utf8_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-#endif
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-int
-__codecvt_utf8<wchar_t>::do_max_length() const noexcept
-{
-#if defined(_LIBCPP_SHORT_WCHAR)
-    if (__mode_ & consume_header)
-        return 6;
-    return 3;
-#else
-    if (__mode_ & consume_header)
-        return 7;
-    return 4;
-#endif
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// __codecvt_utf8<char16_t>
-
-__codecvt_utf8<char16_t>::result
-__codecvt_utf8<char16_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = ucs2_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                            __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8<char16_t>::result
-__codecvt_utf8<char16_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
-    result r = utf8_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                            __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8<char16_t>::result
-__codecvt_utf8<char16_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf8<char16_t>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf8<char16_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf8<char16_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf8_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-int
-__codecvt_utf8<char16_t>::do_max_length() const noexcept
-{
-    if (__mode_ & consume_header)
-        return 6;
-    return 3;
-}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-// __codecvt_utf8<char32_t>
-
-__codecvt_utf8<char32_t>::result
-__codecvt_utf8<char32_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                            __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8<char32_t>::result
-__codecvt_utf8<char32_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
-    result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                            __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8<char32_t>::result
-__codecvt_utf8<char32_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf8<char32_t>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf8<char32_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf8<char32_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf8_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-int
-__codecvt_utf8<char32_t>::do_max_length() const noexcept
-{
-    if (__mode_ & consume_header)
-        return 7;
-    return 4;
-}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-// __codecvt_utf16<wchar_t, false>
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-__codecvt_utf16<wchar_t, false>::result
-__codecvt_utf16<wchar_t, false>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-#if defined(_LIBCPP_SHORT_WCHAR)
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-#else
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-#endif
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-#if defined(_LIBCPP_SHORT_WCHAR)
-    result r = ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-#else
-    result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-#endif
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<wchar_t, false>::result
-__codecvt_utf16<wchar_t, false>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-#if defined(_LIBCPP_SHORT_WCHAR)
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
-    result r = utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-#else
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
-    result r = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-#endif
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<wchar_t, false>::result
-__codecvt_utf16<wchar_t, false>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf16<wchar_t, false>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf16<wchar_t, false>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf16<wchar_t, false>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-#if defined(_LIBCPP_SHORT_WCHAR)
-    return utf16be_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-#else
-    return utf16be_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-#endif
-}
-
-int
-__codecvt_utf16<wchar_t, false>::do_max_length() const noexcept
-{
-#if defined(_LIBCPP_SHORT_WCHAR)
-    if (__mode_ & consume_header)
-        return 4;
-    return 2;
-#else
-    if (__mode_ & consume_header)
-        return 6;
-    return 4;
-#endif
-}
-
-// __codecvt_utf16<wchar_t, true>
-
-__codecvt_utf16<wchar_t, true>::result
-__codecvt_utf16<wchar_t, true>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-#if defined(_LIBCPP_SHORT_WCHAR)
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-#else
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-#endif
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-#if defined(_LIBCPP_SHORT_WCHAR)
-    result r = ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-#else
-    result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-#endif
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<wchar_t, true>::result
-__codecvt_utf16<wchar_t, true>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-#if defined(_LIBCPP_SHORT_WCHAR)
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
-    result r = utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-#else
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
-    result r = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-#endif
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<wchar_t, true>::result
-__codecvt_utf16<wchar_t, true>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf16<wchar_t, true>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf16<wchar_t, true>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf16<wchar_t, true>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-#if defined(_LIBCPP_SHORT_WCHAR)
-    return utf16le_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-#else
-    return utf16le_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-#endif
-}
-
-int
-__codecvt_utf16<wchar_t, true>::do_max_length() const noexcept
-{
-#if defined(_LIBCPP_SHORT_WCHAR)
-    if (__mode_ & consume_header)
-        return 4;
-    return 2;
-#else
-    if (__mode_ & consume_header)
-        return 6;
-    return 4;
-#endif
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// __codecvt_utf16<char16_t, false>
-
-__codecvt_utf16<char16_t, false>::result
-__codecvt_utf16<char16_t, false>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = ucs2_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<char16_t, false>::result
-__codecvt_utf16<char16_t, false>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
-    result r = utf16be_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<char16_t, false>::result
-__codecvt_utf16<char16_t, false>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf16<char16_t, false>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf16<char16_t, false>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf16<char16_t, false>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf16be_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-int
-__codecvt_utf16<char16_t, false>::do_max_length() const noexcept
-{
-    if (__mode_ & consume_header)
-        return 4;
-    return 2;
-}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-// __codecvt_utf16<char16_t, true>
-
-__codecvt_utf16<char16_t, true>::result
-__codecvt_utf16<char16_t, true>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = ucs2_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<char16_t, true>::result
-__codecvt_utf16<char16_t, true>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
-    result r = utf16le_to_ucs2(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<char16_t, true>::result
-__codecvt_utf16<char16_t, true>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf16<char16_t, true>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf16<char16_t, true>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf16<char16_t, true>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf16le_to_ucs2_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-int
-__codecvt_utf16<char16_t, true>::do_max_length() const noexcept
-{
-    if (__mode_ & consume_header)
-        return 4;
-    return 2;
-}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-// __codecvt_utf16<char32_t, false>
-
-__codecvt_utf16<char32_t, false>::result
-__codecvt_utf16<char32_t, false>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = ucs4_to_utf16be(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<char32_t, false>::result
-__codecvt_utf16<char32_t, false>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
-    result r = utf16be_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<char32_t, false>::result
-__codecvt_utf16<char32_t, false>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf16<char32_t, false>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf16<char32_t, false>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf16<char32_t, false>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf16be_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-int
-__codecvt_utf16<char32_t, false>::do_max_length() const noexcept
-{
-    if (__mode_ & consume_header)
-        return 6;
-    return 4;
-}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-// __codecvt_utf16<char32_t, true>
-
-__codecvt_utf16<char32_t, true>::result
-__codecvt_utf16<char32_t, true>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = ucs4_to_utf16le(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<char32_t, true>::result
-__codecvt_utf16<char32_t, true>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
-    result r = utf16le_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                               __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf16<char32_t, true>::result
-__codecvt_utf16<char32_t, true>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf16<char32_t, true>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf16<char32_t, true>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf16<char32_t, true>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf16le_to_ucs4_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-int
-__codecvt_utf16<char32_t, true>::do_max_length() const noexcept
-{
-    if (__mode_ & consume_header)
-        return 6;
-    return 4;
-}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-// __codecvt_utf8_utf16<wchar_t>
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-__codecvt_utf8_utf16<wchar_t>::result
-__codecvt_utf8_utf16<wchar_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-#if defined(_LIBCPP_SHORT_WCHAR)
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-#else
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-#endif
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                             __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8_utf16<wchar_t>::result
-__codecvt_utf8_utf16<wchar_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-#if defined(_LIBCPP_SHORT_WCHAR)
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
-#else
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
-#endif
-    result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                             __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8_utf16<wchar_t>::result
-__codecvt_utf8_utf16<wchar_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf8_utf16<wchar_t>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf8_utf16<wchar_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf8_utf16<wchar_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf8_to_utf16_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-}
-
-int
-__codecvt_utf8_utf16<wchar_t>::do_max_length() const noexcept
-{
-    if (__mode_ & consume_header)
-        return 7;
-    return 4;
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// __codecvt_utf8_utf16<char16_t>
-
-__codecvt_utf8_utf16<char16_t>::result
-__codecvt_utf8_utf16<char16_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
-    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
-    const uint16_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                             __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8_utf16<char16_t>::result
-__codecvt_utf8_utf16<char16_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
-    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
-    uint16_t* _to_nxt = _to;
-    result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                             __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8_utf16<char16_t>::result
-__codecvt_utf8_utf16<char16_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf8_utf16<char16_t>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf8_utf16<char16_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf8_utf16<char16_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf8_to_utf16_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-int
-__codecvt_utf8_utf16<char16_t>::do_max_length() const noexcept
-{
-    if (__mode_ & consume_header)
-        return 7;
-    return 4;
-}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-// __codecvt_utf8_utf16<char32_t>
-
-__codecvt_utf8_utf16<char32_t>::result
-__codecvt_utf8_utf16<char32_t>::do_out(state_type&,
-    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
-    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
-{
-    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
-    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
-    const uint32_t* _frm_nxt = _frm;
-    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
-    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
-    uint8_t* _to_nxt = _to;
-    result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                             __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8_utf16<char32_t>::result
-__codecvt_utf8_utf16<char32_t>::do_in(state_type&,
-    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
-    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    const uint8_t* _frm_nxt = _frm;
-    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
-    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
-    uint32_t* _to_nxt = _to;
-    result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt,
-                             __maxcode_, __mode_);
-    frm_nxt = frm + (_frm_nxt - _frm);
-    to_nxt = to + (_to_nxt - _to);
-    return r;
-}
-
-__codecvt_utf8_utf16<char32_t>::result
-__codecvt_utf8_utf16<char32_t>::do_unshift(state_type&,
-    extern_type* to, extern_type*, extern_type*& to_nxt) const
-{
-    to_nxt = to;
-    return noconv;
-}
-
-int
-__codecvt_utf8_utf16<char32_t>::do_encoding() const noexcept
-{
-    return 0;
-}
-
-bool
-__codecvt_utf8_utf16<char32_t>::do_always_noconv() const noexcept
-{
-    return false;
-}
-
-int
-__codecvt_utf8_utf16<char32_t>::do_length(state_type&,
-    const extern_type* frm, const extern_type* frm_end, size_t mx) const
-{
-    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
-    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
-    return utf8_to_utf16_length(_frm, _frm_end, mx, __maxcode_, __mode_);
-}
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-int
-__codecvt_utf8_utf16<char32_t>::do_max_length() const noexcept
-{
-    if (__mode_ & consume_header)
-        return 7;
-    return 4;
-}
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-// __narrow_to_utf8<16>
-
-__narrow_to_utf8<16>::~__narrow_to_utf8()
-{
-}
-
-// __narrow_to_utf8<32>
-
-__narrow_to_utf8<32>::~__narrow_to_utf8()
-{
-}
-
-// __widen_from_utf8<16>
-
-__widen_from_utf8<16>::~__widen_from_utf8()
-{
-}
-
-// __widen_from_utf8<32>
-
-__widen_from_utf8<32>::~__widen_from_utf8()
-{
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-static bool checked_string_to_wchar_convert(wchar_t& dest,
-                                            const char* ptr,
-                                            locale_t loc) {
-  if (*ptr == '\0')
-    return false;
-  mbstate_t mb = {};
-  wchar_t out;
-  size_t ret = __libcpp_mbrtowc_l(&out, ptr, strlen(ptr), &mb, loc);
-  if (ret == static_cast<size_t>(-1) || ret == static_cast<size_t>(-2)) {
-    return false;
-  }
-  dest = out;
-  return true;
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-#ifdef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-static bool is_narrow_non_breaking_space(const char* ptr) {
-  // https://www.fileformat.info/info/unicode/char/202f/index.htm
-  return ptr[0] == '\xe2' && ptr[1] == '\x80' && ptr[2] == '\xaf';
-}
-
-static bool is_non_breaking_space(const char* ptr) {
-  // https://www.fileformat.info/info/unicode/char/0a/index.htm
-  return ptr[0] == '\xc2' && ptr[1] == '\xa0';
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-static bool checked_string_to_char_convert(char& dest,
-                                           const char* ptr,
-                                           locale_t __loc) {
-  if (*ptr == '\0')
-    return false;
-  if (!ptr[1]) {
-    dest = *ptr;
-    return true;
-  }
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-  // First convert the MBS into a wide char then attempt to narrow it using
-  // wctob_l.
-  wchar_t wout;
-  if (!checked_string_to_wchar_convert(wout, ptr, __loc))
-    return false;
-  int res;
-  if ((res = __libcpp_wctob_l(wout, __loc)) != char_traits<char>::eof()) {
-    dest = res;
-    return true;
-  }
-  // FIXME: Work around specific multibyte sequences that we can reasonably
-  // translate into a different single byte.
-  switch (wout) {
-  case L'\u202F': // narrow non-breaking space
-  case L'\u00A0': // non-breaking space
-    dest = ' ';
-    return true;
-  default:
-    return false;
-  }
-#else // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-  // FIXME: Work around specific multibyte sequences that we can reasonably
-  // translate into a different single byte.
-  if (is_narrow_non_breaking_space(ptr) || is_non_breaking_space(ptr)) {
-    dest = ' ';
-    return true;
-  }
-
-  return false;
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-  __libcpp_unreachable();
-}
-
-
-// numpunct<char> && numpunct<wchar_t>
-
-locale::id numpunct< char  >::id;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-locale::id numpunct<wchar_t>::id;
-#endif
-
-numpunct<char>::numpunct(size_t refs)
-    : locale::facet(refs),
-      __decimal_point_('.'),
-      __thousands_sep_(',')
-{
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-numpunct<wchar_t>::numpunct(size_t refs)
-    : locale::facet(refs),
-      __decimal_point_(L'.'),
-      __thousands_sep_(L',')
-{
-}
-#endif
-
-numpunct<char>::~numpunct()
-{
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-numpunct<wchar_t>::~numpunct()
-{
-}
-#endif
-
- char   numpunct< char  >::do_decimal_point() const {return __decimal_point_;}
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-wchar_t numpunct<wchar_t>::do_decimal_point() const {return __decimal_point_;}
-#endif
-
- char   numpunct< char  >::do_thousands_sep() const {return __thousands_sep_;}
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-wchar_t numpunct<wchar_t>::do_thousands_sep() const {return __thousands_sep_;}
-#endif
-
-string numpunct< char  >::do_grouping() const {return __grouping_;}
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-string numpunct<wchar_t>::do_grouping() const {return __grouping_;}
-#endif
-
- string numpunct< char  >::do_truename() const {return "true";}
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-wstring numpunct<wchar_t>::do_truename() const {return L"true";}
-#endif
-
- string numpunct< char  >::do_falsename() const {return "false";}
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-wstring numpunct<wchar_t>::do_falsename() const {return L"false";}
-#endif
-
-// numpunct_byname<char>
-
-numpunct_byname<char>::numpunct_byname(const char* nm, size_t refs)
-    : numpunct<char>(refs)
-{
-    __init(nm);
-}
-
-numpunct_byname<char>::numpunct_byname(const string& nm, size_t refs)
-    : numpunct<char>(refs)
-{
-    __init(nm.c_str());
-}
-
-numpunct_byname<char>::~numpunct_byname()
-{
-}
-
-void
-numpunct_byname<char>::__init(const char* nm)
-{
-    typedef numpunct<char> base;
-    if (strcmp(nm, "C") != 0)
-    {
-        __libcpp_unique_locale loc(nm);
-        if (!loc)
-            __throw_runtime_error("numpunct_byname<char>::numpunct_byname"
-                                " failed to construct for " + string(nm));
-
-        lconv* lc = __libcpp_localeconv_l(loc.get());
-        if (!checked_string_to_char_convert(__decimal_point_, lc->decimal_point,
-                                            loc.get()))
-            __decimal_point_ = base::do_decimal_point();
-        if (!checked_string_to_char_convert(__thousands_sep_, lc->thousands_sep,
-                                            loc.get()))
-            __thousands_sep_ = base::do_thousands_sep();
-        __grouping_ = lc->grouping;
-        // localization for truename and falsename is not available
-    }
-}
-
-// numpunct_byname<wchar_t>
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-numpunct_byname<wchar_t>::numpunct_byname(const char* nm, size_t refs)
-    : numpunct<wchar_t>(refs)
-{
-    __init(nm);
-}
-
-numpunct_byname<wchar_t>::numpunct_byname(const string& nm, size_t refs)
-    : numpunct<wchar_t>(refs)
-{
-    __init(nm.c_str());
-}
-
-numpunct_byname<wchar_t>::~numpunct_byname()
-{
-}
-
-void
-numpunct_byname<wchar_t>::__init(const char* nm)
-{
-    if (strcmp(nm, "C") != 0)
-    {
-        __libcpp_unique_locale loc(nm);
-        if (!loc)
-            __throw_runtime_error("numpunct_byname<wchar_t>::numpunct_byname"
-                                " failed to construct for " + string(nm));
-
-        lconv* lc = __libcpp_localeconv_l(loc.get());
-        checked_string_to_wchar_convert(__decimal_point_, lc->decimal_point,
-                                        loc.get());
-        checked_string_to_wchar_convert(__thousands_sep_, lc->thousands_sep,
-                                        loc.get());
-        __grouping_ = lc->grouping;
-        // localization for truename and falsename is not available
-    }
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// num_get helpers
-
-int
-__num_get_base::__get_base(ios_base& iob)
-{
-    ios_base::fmtflags __basefield = iob.flags() & ios_base::basefield;
-    if (__basefield == ios_base::oct)
-        return 8;
-    else if (__basefield == ios_base::hex)
-        return 16;
-    else if (__basefield == 0)
-        return 0;
-    return 10;
-}
-
-const char __num_get_base::__src[33] = "0123456789abcdefABCDEFxX+-pPiInN";
-
-void
-__check_grouping(const string& __grouping, unsigned* __g, unsigned* __g_end,
-                 ios_base::iostate& __err)
-{
-//  if the grouping pattern is empty _or_ there are no grouping bits, then do nothing
-//  we always have at least a single entry in [__g, __g_end); the end of the input sequence
-    if (__grouping.size() != 0 && __g_end - __g > 1)
-    {
-        reverse(__g, __g_end);
-        const char* __ig = __grouping.data();
-        const char* __eg = __ig + __grouping.size();
-        for (unsigned* __r = __g; __r < __g_end-1; ++__r)
-        {
-            if (0 < *__ig && *__ig < numeric_limits<char>::max())
-            {
-                if (static_cast<unsigned>(*__ig) != *__r)
-                {
-                    __err = ios_base::failbit;
-                    return;
-                }
-            }
-            if (__eg - __ig > 1)
-                ++__ig;
-        }
-        if (0 < *__ig && *__ig < numeric_limits<char>::max())
-        {
-            if (static_cast<unsigned>(*__ig) < __g_end[-1] || __g_end[-1] == 0)
-                __err = ios_base::failbit;
-        }
-    }
-}
-
-void
-__num_put_base::__format_int(char* __fmtp, const char* __len, bool __signd,
-                             ios_base::fmtflags __flags)
-{
-    if ((__flags & ios_base::showpos) &&
-        (__flags & ios_base::basefield) != ios_base::oct &&
-        (__flags & ios_base::basefield) != ios_base::hex &&
-        __signd)
-        *__fmtp++ = '+';
-    if (__flags & ios_base::showbase)
-        *__fmtp++ = '#';
-    while(*__len)
-        *__fmtp++ = *__len++;
-    if ((__flags & ios_base::basefield) == ios_base::oct)
-        *__fmtp = 'o';
-    else if ((__flags & ios_base::basefield) == ios_base::hex)
-    {
-        if (__flags & ios_base::uppercase)
-            *__fmtp = 'X';
-        else
-            *__fmtp = 'x';
-    }
-    else if (__signd)
-        *__fmtp = 'd';
-    else
-        *__fmtp = 'u';
-}
-
-bool
-__num_put_base::__format_float(char* __fmtp, const char* __len,
-                               ios_base::fmtflags __flags)
-{
-    bool specify_precision = true;
-    if (__flags & ios_base::showpos)
-        *__fmtp++ = '+';
-    if (__flags & ios_base::showpoint)
-        *__fmtp++ = '#';
-    ios_base::fmtflags floatfield = __flags & ios_base::floatfield;
-    bool uppercase = (__flags & ios_base::uppercase) != 0;
-    if (floatfield == (ios_base::fixed | ios_base::scientific))
-        specify_precision = false;
-    else
-    {
-        *__fmtp++ = '.';
-        *__fmtp++ = '*';
-    }
-    while(*__len)
-        *__fmtp++ = *__len++;
-    if (floatfield == ios_base::fixed)
-    {
-        if (uppercase)
-            *__fmtp = 'F';
-        else
-            *__fmtp = 'f';
-    }
-    else if (floatfield == ios_base::scientific)
-    {
-        if (uppercase)
-            *__fmtp = 'E';
-        else
-            *__fmtp = 'e';
-    }
-    else if (floatfield == (ios_base::fixed | ios_base::scientific))
-    {
-        if (uppercase)
-            *__fmtp = 'A';
-        else
-            *__fmtp = 'a';
-    }
-    else
-    {
-        if (uppercase)
-            *__fmtp = 'G';
-        else
-            *__fmtp = 'g';
-    }
-    return specify_precision;
-}
-
-char*
-__num_put_base::__identify_padding(char* __nb, char* __ne,
-                                   const ios_base& __iob)
-{
-    switch (__iob.flags() & ios_base::adjustfield)
-    {
-    case ios_base::internal:
-        if (__nb[0] == '-' || __nb[0] == '+')
-            return __nb+1;
-        if (__ne - __nb >= 2 && __nb[0] == '0'
-                            && (__nb[1] == 'x' || __nb[1] == 'X'))
-            return __nb+2;
-        break;
-    case ios_base::left:
-        return __ne;
-    case ios_base::right:
-    default:
-        break;
-    }
-    return __nb;
-}
-
-// time_get
-
-static
-string*
-init_weeks()
-{
-    static string weeks[14];
-    weeks[0]  = "Sunday";
-    weeks[1]  = "Monday";
-    weeks[2]  = "Tuesday";
-    weeks[3]  = "Wednesday";
-    weeks[4]  = "Thursday";
-    weeks[5]  = "Friday";
-    weeks[6]  = "Saturday";
-    weeks[7]  = "Sun";
-    weeks[8]  = "Mon";
-    weeks[9]  = "Tue";
-    weeks[10] = "Wed";
-    weeks[11] = "Thu";
-    weeks[12] = "Fri";
-    weeks[13] = "Sat";
-    return weeks;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-static
-wstring*
-init_wweeks()
-{
-    static wstring weeks[14];
-    weeks[0]  = L"Sunday";
-    weeks[1]  = L"Monday";
-    weeks[2]  = L"Tuesday";
-    weeks[3]  = L"Wednesday";
-    weeks[4]  = L"Thursday";
-    weeks[5]  = L"Friday";
-    weeks[6]  = L"Saturday";
-    weeks[7]  = L"Sun";
-    weeks[8]  = L"Mon";
-    weeks[9]  = L"Tue";
-    weeks[10] = L"Wed";
-    weeks[11] = L"Thu";
-    weeks[12] = L"Fri";
-    weeks[13] = L"Sat";
-    return weeks;
-}
-#endif
-
-template <>
-const string*
-__time_get_c_storage<char>::__weeks() const
-{
-    static const string* weeks = init_weeks();
-    return weeks;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-const wstring*
-__time_get_c_storage<wchar_t>::__weeks() const
-{
-    static const wstring* weeks = init_wweeks();
-    return weeks;
-}
-#endif
-
-static
-string*
-init_months()
-{
-    static string months[24];
-    months[0]  = "January";
-    months[1]  = "February";
-    months[2]  = "March";
-    months[3]  = "April";
-    months[4]  = "May";
-    months[5]  = "June";
-    months[6]  = "July";
-    months[7]  = "August";
-    months[8]  = "September";
-    months[9]  = "October";
-    months[10] = "November";
-    months[11] = "December";
-    months[12] = "Jan";
-    months[13] = "Feb";
-    months[14] = "Mar";
-    months[15] = "Apr";
-    months[16] = "May";
-    months[17] = "Jun";
-    months[18] = "Jul";
-    months[19] = "Aug";
-    months[20] = "Sep";
-    months[21] = "Oct";
-    months[22] = "Nov";
-    months[23] = "Dec";
-    return months;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-static
-wstring*
-init_wmonths()
-{
-    static wstring months[24];
-    months[0]  = L"January";
-    months[1]  = L"February";
-    months[2]  = L"March";
-    months[3]  = L"April";
-    months[4]  = L"May";
-    months[5]  = L"June";
-    months[6]  = L"July";
-    months[7]  = L"August";
-    months[8]  = L"September";
-    months[9]  = L"October";
-    months[10] = L"November";
-    months[11] = L"December";
-    months[12] = L"Jan";
-    months[13] = L"Feb";
-    months[14] = L"Mar";
-    months[15] = L"Apr";
-    months[16] = L"May";
-    months[17] = L"Jun";
-    months[18] = L"Jul";
-    months[19] = L"Aug";
-    months[20] = L"Sep";
-    months[21] = L"Oct";
-    months[22] = L"Nov";
-    months[23] = L"Dec";
-    return months;
-}
-#endif
-
-template <>
-const string*
-__time_get_c_storage<char>::__months() const
-{
-    static const string* months = init_months();
-    return months;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-const wstring*
-__time_get_c_storage<wchar_t>::__months() const
-{
-    static const wstring* months = init_wmonths();
-    return months;
-}
-#endif
-
-static
-string*
-init_am_pm()
-{
-    static string am_pm[2];
-    am_pm[0]  = "AM";
-    am_pm[1]  = "PM";
-    return am_pm;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-static
-wstring*
-init_wam_pm()
-{
-    static wstring am_pm[2];
-    am_pm[0]  = L"AM";
-    am_pm[1]  = L"PM";
-    return am_pm;
-}
-#endif
-
-template <>
-const string*
-__time_get_c_storage<char>::__am_pm() const
-{
-    static const string* am_pm = init_am_pm();
-    return am_pm;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-const wstring*
-__time_get_c_storage<wchar_t>::__am_pm() const
-{
-    static const wstring* am_pm = init_wam_pm();
-    return am_pm;
-}
-#endif
-
-template <>
-const string&
-__time_get_c_storage<char>::__x() const
-{
-    static string s("%m/%d/%y");
-    return s;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-const wstring&
-__time_get_c_storage<wchar_t>::__x() const
-{
-    static wstring s(L"%m/%d/%y");
-    return s;
-}
-#endif
-
-template <>
-const string&
-__time_get_c_storage<char>::__X() const
-{
-    static string s("%H:%M:%S");
-    return s;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-const wstring&
-__time_get_c_storage<wchar_t>::__X() const
-{
-    static wstring s(L"%H:%M:%S");
-    return s;
-}
-#endif
-
-template <>
-const string&
-__time_get_c_storage<char>::__c() const
-{
-    static string s("%a %b %d %H:%M:%S %Y");
-    return s;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-const wstring&
-__time_get_c_storage<wchar_t>::__c() const
-{
-    static wstring s(L"%a %b %d %H:%M:%S %Y");
-    return s;
-}
-#endif
-
-template <>
-const string&
-__time_get_c_storage<char>::__r() const
-{
-    static string s("%I:%M:%S %p");
-    return s;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-const wstring&
-__time_get_c_storage<wchar_t>::__r() const
-{
-    static wstring s(L"%I:%M:%S %p");
-    return s;
-}
-#endif
-
-// time_get_byname
-
-__time_get::__time_get(const char* nm)
-    : __loc_(newlocale(LC_ALL_MASK, nm, 0))
-{
-    if (__loc_ == 0)
-        __throw_runtime_error("time_get_byname"
-                            " failed to construct for " + string(nm));
-}
-
-__time_get::__time_get(const string& nm)
-    : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
-{
-    if (__loc_ == 0)
-        __throw_runtime_error("time_get_byname"
-                            " failed to construct for " + nm);
-}
-
-__time_get::~__time_get()
-{
-    freelocale(__loc_);
-}
-
-_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-field-initializers")
-
-template <>
-string
-__time_get_storage<char>::__analyze(char fmt, const ctype<char>& ct)
-{
-    tm t = {0};
-    t.tm_sec = 59;
-    t.tm_min = 55;
-    t.tm_hour = 23;
-    t.tm_mday = 31;
-    t.tm_mon = 11;
-    t.tm_year = 161;
-    t.tm_wday = 6;
-    t.tm_yday = 364;
-    t.tm_isdst = -1;
-    char buf[100];
-    char f[3] = {0};
-    f[0] = '%';
-    f[1] = fmt;
-    size_t n = strftime_l(buf, countof(buf), f, &t, __loc_);
-    char* bb = buf;
-    char* be = buf + n;
-    string result;
-    while (bb != be)
-    {
-        if (ct.is(ctype_base::space, *bb))
-        {
-            result.push_back(' ');
-            for (++bb; bb != be && ct.is(ctype_base::space, *bb); ++bb)
-                ;
-            continue;
-        }
-        char* w = bb;
-        ios_base::iostate err = ios_base::goodbit;
-        ptrdiff_t i = __scan_keyword(w, be, this->__weeks_, this->__weeks_+14,
-                               ct, err, false)
-                               - this->__weeks_;
-        if (i < 14)
-        {
-            result.push_back('%');
-            if (i < 7)
-                result.push_back('A');
-            else
-                result.push_back('a');
-            bb = w;
-            continue;
-        }
-        w = bb;
-        i = __scan_keyword(w, be, this->__months_, this->__months_+24,
-                           ct, err, false)
-                           - this->__months_;
-        if (i < 24)
-        {
-            result.push_back('%');
-            if (i < 12)
-                result.push_back('B');
-            else
-                result.push_back('b');
-            if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
-                result.back() = 'm';
-            bb = w;
-            continue;
-        }
-        if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0)
-        {
-            w = bb;
-            i = __scan_keyword(w, be, this->__am_pm_, this->__am_pm_+2,
-                               ct, err, false) - this->__am_pm_;
-            if (i < 2)
-            {
-                result.push_back('%');
-                result.push_back('p');
-                bb = w;
-                continue;
-            }
-        }
-        w = bb;
-        if (ct.is(ctype_base::digit, *bb))
-        {
-            switch(__get_up_to_n_digits(bb, be, err, ct, 4))
-            {
-            case 6:
-                result.push_back('%');
-                result.push_back('w');
-                break;
-            case 7:
-                result.push_back('%');
-                result.push_back('u');
-                break;
-            case 11:
-                result.push_back('%');
-                result.push_back('I');
-                break;
-            case 12:
-                result.push_back('%');
-                result.push_back('m');
-                break;
-            case 23:
-                result.push_back('%');
-                result.push_back('H');
-                break;
-            case 31:
-                result.push_back('%');
-                result.push_back('d');
-                break;
-            case 55:
-                result.push_back('%');
-                result.push_back('M');
-                break;
-            case 59:
-                result.push_back('%');
-                result.push_back('S');
-                break;
-            case 61:
-                result.push_back('%');
-                result.push_back('y');
-                break;
-            case 364:
-                result.push_back('%');
-                result.push_back('j');
-                break;
-            case 2061:
-                result.push_back('%');
-                result.push_back('Y');
-                break;
-            default:
-                for (; w != bb; ++w)
-                    result.push_back(*w);
-                break;
-            }
-            continue;
-        }
-        if (*bb == '%')
-        {
-            result.push_back('%');
-            result.push_back('%');
-            ++bb;
-            continue;
-        }
-        result.push_back(*bb);
-        ++bb;
-    }
-    return result;
-}
-
-_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-braces")
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-wstring
-__time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct)
-{
-    tm t = {0};
-    t.tm_sec = 59;
-    t.tm_min = 55;
-    t.tm_hour = 23;
-    t.tm_mday = 31;
-    t.tm_mon = 11;
-    t.tm_year = 161;
-    t.tm_wday = 6;
-    t.tm_yday = 364;
-    t.tm_isdst = -1;
-    char buf[100];
-    char f[3] = {0};
-    f[0] = '%';
-    f[1] = fmt;
-    strftime_l(buf, countof(buf), f, &t, __loc_);
-    wchar_t wbuf[100];
-    wchar_t* wbb = wbuf;
-    mbstate_t mb = {0};
-    const char* bb = buf;
-    size_t j = __libcpp_mbsrtowcs_l( wbb, &bb, countof(wbuf), &mb, __loc_);
-    if (j == size_t(-1))
-        __throw_runtime_error("locale not supported");
-    wchar_t* wbe = wbb + j;
-    wstring result;
-    while (wbb != wbe)
-    {
-        if (ct.is(ctype_base::space, *wbb))
-        {
-            result.push_back(L' ');
-            for (++wbb; wbb != wbe && ct.is(ctype_base::space, *wbb); ++wbb)
-                ;
-            continue;
-        }
-        wchar_t* w = wbb;
-        ios_base::iostate err = ios_base::goodbit;
-        ptrdiff_t i = __scan_keyword(w, wbe, this->__weeks_, this->__weeks_+14,
-                               ct, err, false)
-                               - this->__weeks_;
-        if (i < 14)
-        {
-            result.push_back(L'%');
-            if (i < 7)
-                result.push_back(L'A');
-            else
-                result.push_back(L'a');
-            wbb = w;
-            continue;
-        }
-        w = wbb;
-        i = __scan_keyword(w, wbe, this->__months_, this->__months_+24,
-                           ct, err, false)
-                           - this->__months_;
-        if (i < 24)
-        {
-            result.push_back(L'%');
-            if (i < 12)
-                result.push_back(L'B');
-            else
-                result.push_back(L'b');
-            if (fmt == 'x' && ct.is(ctype_base::digit, this->__months_[i][0]))
-                result.back() = L'm';
-            wbb = w;
-            continue;
-        }
-        if (this->__am_pm_[0].size() + this->__am_pm_[1].size() > 0)
-        {
-            w = wbb;
-            i = __scan_keyword(w, wbe, this->__am_pm_, this->__am_pm_+2,
-                               ct, err, false) - this->__am_pm_;
-            if (i < 2)
-            {
-                result.push_back(L'%');
-                result.push_back(L'p');
-                wbb = w;
-                continue;
-            }
-        }
-        w = wbb;
-        if (ct.is(ctype_base::digit, *wbb))
-        {
-            switch(__get_up_to_n_digits(wbb, wbe, err, ct, 4))
-            {
-            case 6:
-                result.push_back(L'%');
-                result.push_back(L'w');
-                break;
-            case 7:
-                result.push_back(L'%');
-                result.push_back(L'u');
-                break;
-            case 11:
-                result.push_back(L'%');
-                result.push_back(L'I');
-                break;
-            case 12:
-                result.push_back(L'%');
-                result.push_back(L'm');
-                break;
-            case 23:
-                result.push_back(L'%');
-                result.push_back(L'H');
-                break;
-            case 31:
-                result.push_back(L'%');
-                result.push_back(L'd');
-                break;
-            case 55:
-                result.push_back(L'%');
-                result.push_back(L'M');
-                break;
-            case 59:
-                result.push_back(L'%');
-                result.push_back(L'S');
-                break;
-            case 61:
-                result.push_back(L'%');
-                result.push_back(L'y');
-                break;
-            case 364:
-                result.push_back(L'%');
-                result.push_back(L'j');
-                break;
-            case 2061:
-                result.push_back(L'%');
-                result.push_back(L'Y');
-                break;
-            default:
-                for (; w != wbb; ++w)
-                    result.push_back(*w);
-                break;
-            }
-            continue;
-        }
-        if (ct.narrow(*wbb, 0) == '%')
-        {
-            result.push_back(L'%');
-            result.push_back(L'%');
-            ++wbb;
-            continue;
-        }
-        result.push_back(*wbb);
-        ++wbb;
-    }
-    return result;
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-template <>
-void
-__time_get_storage<char>::init(const ctype<char>& ct)
-{
-    tm t = {0};
-    char buf[100];
-    // __weeks_
-    for (int i = 0; i < 7; ++i)
-    {
-        t.tm_wday = i;
-        strftime_l(buf, countof(buf), "%A", &t, __loc_);
-        __weeks_[i] = buf;
-        strftime_l(buf, countof(buf), "%a", &t, __loc_);
-        __weeks_[i+7] = buf;
-    }
-    // __months_
-    for (int i = 0; i < 12; ++i)
-    {
-        t.tm_mon = i;
-        strftime_l(buf, countof(buf), "%B", &t, __loc_);
-        __months_[i] = buf;
-        strftime_l(buf, countof(buf), "%b", &t, __loc_);
-        __months_[i+12] = buf;
-    }
-    // __am_pm_
-    t.tm_hour = 1;
-    strftime_l(buf, countof(buf), "%p", &t, __loc_);
-    __am_pm_[0] = buf;
-    t.tm_hour = 13;
-    strftime_l(buf, countof(buf), "%p", &t, __loc_);
-    __am_pm_[1] = buf;
-    __c_ = __analyze('c', ct);
-    __r_ = __analyze('r', ct);
-    __x_ = __analyze('x', ct);
-    __X_ = __analyze('X', ct);
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-void
-__time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
-{
-    tm t = {0};
-    char buf[100];
-    wchar_t wbuf[100];
-    wchar_t* wbe;
-    mbstate_t mb = {0};
-    // __weeks_
-    for (int i = 0; i < 7; ++i)
-    {
-        t.tm_wday = i;
-        strftime_l(buf, countof(buf), "%A", &t, __loc_);
-        mb = mbstate_t();
-        const char* bb = buf;
-        size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-        if (j == size_t(-1) || j == 0)
-            __throw_runtime_error("locale not supported");
-        wbe = wbuf + j;
-        __weeks_[i].assign(wbuf, wbe);
-        strftime_l(buf, countof(buf), "%a", &t, __loc_);
-        mb = mbstate_t();
-        bb = buf;
-        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-        if (j == size_t(-1) || j == 0)
-            __throw_runtime_error("locale not supported");
-        wbe = wbuf + j;
-        __weeks_[i+7].assign(wbuf, wbe);
-    }
-    // __months_
-    for (int i = 0; i < 12; ++i)
-    {
-        t.tm_mon = i;
-        strftime_l(buf, countof(buf), "%B", &t, __loc_);
-        mb = mbstate_t();
-        const char* bb = buf;
-        size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-        if (j == size_t(-1) || j == 0)
-            __throw_runtime_error("locale not supported");
-        wbe = wbuf + j;
-        __months_[i].assign(wbuf, wbe);
-        strftime_l(buf, countof(buf), "%b", &t, __loc_);
-        mb = mbstate_t();
-        bb = buf;
-        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-        if (j == size_t(-1) || j == 0)
-            __throw_runtime_error("locale not supported");
-        wbe = wbuf + j;
-        __months_[i+12].assign(wbuf, wbe);
-    }
-    // __am_pm_
-    t.tm_hour = 1;
-    strftime_l(buf, countof(buf), "%p", &t, __loc_);
-    mb = mbstate_t();
-    const char* bb = buf;
-    size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-    if (j == size_t(-1))
-        __throw_runtime_error("locale not supported");
-    wbe = wbuf + j;
-    __am_pm_[0].assign(wbuf, wbe);
-    t.tm_hour = 13;
-    strftime_l(buf, countof(buf), "%p", &t, __loc_);
-    mb = mbstate_t();
-    bb = buf;
-    j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, __loc_);
-    if (j == size_t(-1))
-        __throw_runtime_error("locale not supported");
-    wbe = wbuf + j;
-    __am_pm_[1].assign(wbuf, wbe);
-    __c_ = __analyze('c', ct);
-    __r_ = __analyze('r', ct);
-    __x_ = __analyze('x', ct);
-    __X_ = __analyze('X', ct);
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-template <class CharT>
-struct _LIBCPP_HIDDEN __time_get_temp
-    : public ctype_byname<CharT>
-{
-    explicit __time_get_temp(const char* nm)
-        : ctype_byname<CharT>(nm, 1) {}
-    explicit __time_get_temp(const string& nm)
-        : ctype_byname<CharT>(nm, 1) {}
-};
-
-template <>
-__time_get_storage<char>::__time_get_storage(const char* __nm)
-    : __time_get(__nm)
-{
-    const __time_get_temp<char> ct(__nm);
-    init(ct);
-}
-
-template <>
-__time_get_storage<char>::__time_get_storage(const string& __nm)
-    : __time_get(__nm)
-{
-    const __time_get_temp<char> ct(__nm);
-    init(ct);
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-__time_get_storage<wchar_t>::__time_get_storage(const char* __nm)
-    : __time_get(__nm)
-{
-    const __time_get_temp<wchar_t> ct(__nm);
-    init(ct);
-}
-
-template <>
-__time_get_storage<wchar_t>::__time_get_storage(const string& __nm)
-    : __time_get(__nm)
-{
-    const __time_get_temp<wchar_t> ct(__nm);
-    init(ct);
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-template <>
-time_base::dateorder
-__time_get_storage<char>::__do_date_order() const
-{
-    unsigned i;
-    for (i = 0; i < __x_.size(); ++i)
-        if (__x_[i] == '%')
-            break;
-    ++i;
-    switch (__x_[i])
-    {
-    case 'y':
-    case 'Y':
-        for (++i; i < __x_.size(); ++i)
-            if (__x_[i] == '%')
-                break;
-        if (i == __x_.size())
-            break;
-        ++i;
-        switch (__x_[i])
-        {
-        case 'm':
-            for (++i; i < __x_.size(); ++i)
-                if (__x_[i] == '%')
-                    break;
-            if (i == __x_.size())
-                break;
-            ++i;
-            if (__x_[i] == 'd')
-                return time_base::ymd;
-            break;
-        case 'd':
-            for (++i; i < __x_.size(); ++i)
-                if (__x_[i] == '%')
-                    break;
-            if (i == __x_.size())
-                break;
-            ++i;
-            if (__x_[i] == 'm')
-                return time_base::ydm;
-            break;
-        }
-        break;
-    case 'm':
-        for (++i; i < __x_.size(); ++i)
-            if (__x_[i] == '%')
-                break;
-        if (i == __x_.size())
-            break;
-        ++i;
-        if (__x_[i] == 'd')
-        {
-            for (++i; i < __x_.size(); ++i)
-                if (__x_[i] == '%')
-                    break;
-            if (i == __x_.size())
-                break;
-            ++i;
-            if (__x_[i] == 'y' || __x_[i] == 'Y')
-                return time_base::mdy;
-            break;
-        }
-        break;
-    case 'd':
-        for (++i; i < __x_.size(); ++i)
-            if (__x_[i] == '%')
-                break;
-        if (i == __x_.size())
-            break;
-        ++i;
-        if (__x_[i] == 'm')
-        {
-            for (++i; i < __x_.size(); ++i)
-                if (__x_[i] == '%')
-                    break;
-            if (i == __x_.size())
-                break;
-            ++i;
-            if (__x_[i] == 'y' || __x_[i] == 'Y')
-                return time_base::dmy;
-            break;
-        }
-        break;
-    }
-    return time_base::no_order;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-time_base::dateorder
-__time_get_storage<wchar_t>::__do_date_order() const
-{
-    unsigned i;
-    for (i = 0; i < __x_.size(); ++i)
-        if (__x_[i] == L'%')
-            break;
-    ++i;
-    switch (__x_[i])
-    {
-    case L'y':
-    case L'Y':
-        for (++i; i < __x_.size(); ++i)
-            if (__x_[i] == L'%')
-                break;
-        if (i == __x_.size())
-            break;
-        ++i;
-        switch (__x_[i])
-        {
-        case L'm':
-            for (++i; i < __x_.size(); ++i)
-                if (__x_[i] == L'%')
-                    break;
-            if (i == __x_.size())
-                break;
-            ++i;
-            if (__x_[i] == L'd')
-                return time_base::ymd;
-            break;
-        case L'd':
-            for (++i; i < __x_.size(); ++i)
-                if (__x_[i] == L'%')
-                    break;
-            if (i == __x_.size())
-                break;
-            ++i;
-            if (__x_[i] == L'm')
-                return time_base::ydm;
-            break;
-        }
-        break;
-    case L'm':
-        for (++i; i < __x_.size(); ++i)
-            if (__x_[i] == L'%')
-                break;
-        if (i == __x_.size())
-            break;
-        ++i;
-        if (__x_[i] == L'd')
-        {
-            for (++i; i < __x_.size(); ++i)
-                if (__x_[i] == L'%')
-                    break;
-            if (i == __x_.size())
-                break;
-            ++i;
-            if (__x_[i] == L'y' || __x_[i] == L'Y')
-                return time_base::mdy;
-            break;
-        }
-        break;
-    case L'd':
-        for (++i; i < __x_.size(); ++i)
-            if (__x_[i] == L'%')
-                break;
-        if (i == __x_.size())
-            break;
-        ++i;
-        if (__x_[i] == L'm')
-        {
-            for (++i; i < __x_.size(); ++i)
-                if (__x_[i] == L'%')
-                    break;
-            if (i == __x_.size())
-                break;
-            ++i;
-            if (__x_[i] == L'y' || __x_[i] == L'Y')
-                return time_base::dmy;
-            break;
-        }
-        break;
-    }
-    return time_base::no_order;
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// time_put
-
-__time_put::__time_put(const char* nm)
-    : __loc_(newlocale(LC_ALL_MASK, nm, 0))
-{
-    if (__loc_ == 0)
-        __throw_runtime_error("time_put_byname"
-                            " failed to construct for " + string(nm));
-}
-
-__time_put::__time_put(const string& nm)
-    : __loc_(newlocale(LC_ALL_MASK, nm.c_str(), 0))
-{
-    if (__loc_ == 0)
-        __throw_runtime_error("time_put_byname"
-                            " failed to construct for " + nm);
-}
-
-__time_put::~__time_put()
-{
-    if (__loc_ != _LIBCPP_GET_C_LOCALE)
-        freelocale(__loc_);
-}
-
-void
-__time_put::__do_put(char* __nb, char*& __ne, const tm* __tm,
-                     char __fmt, char __mod) const
-{
-    char fmt[] = {'%', __fmt, __mod, 0};
-    if (__mod != 0)
-        swap(fmt[1], fmt[2]);
-    size_t n = strftime_l(__nb, countof(__nb, __ne), fmt, __tm, __loc_);
-    __ne = __nb + n;
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-void
-__time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm,
-                     char __fmt, char __mod) const
-{
-    char __nar[100];
-    char* __ne = __nar + 100;
-    __do_put(__nar, __ne, __tm, __fmt, __mod);
-    mbstate_t mb = {0};
-    const char* __nb = __nar;
-    size_t j = __libcpp_mbsrtowcs_l(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
-    if (j == size_t(-1))
-        __throw_runtime_error("locale not supported");
-    __we = __wb + j;
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// moneypunct_byname
-
-template <class charT>
-static
-void
-__init_pat(money_base::pattern& pat, basic_string<charT>& __curr_symbol_,
-           bool intl, char cs_precedes, char sep_by_space, char sign_posn,
-           charT space_char)
-{
-    const char sign = static_cast<char>(money_base::sign);
-    const char space = static_cast<char>(money_base::space);
-    const char none = static_cast<char>(money_base::none);
-    const char symbol = static_cast<char>(money_base::symbol);
-    const char value = static_cast<char>(money_base::value);
-    const bool symbol_contains_sep = intl && __curr_symbol_.size() == 4;
-
-    // Comments on case branches reflect 'C11 7.11.2.1 The localeconv
-    // function'. "Space between sign and symbol or value" means that
-    // if the sign is adjacent to the symbol, there's a space between
-    // them, and otherwise there's a space between the sign and value.
-    //
-    // C11's localeconv specifies that the fourth character of an
-    // international curr_symbol is used to separate the sign and
-    // value when sep_by_space says to do so. C++ can't represent
-    // that, so we just use a space.  When sep_by_space says to
-    // separate the symbol and value-or-sign with a space, we rearrange the
-    // curr_symbol to put its spacing character on the correct side of
-    // the symbol.
-    //
-    // We also need to avoid adding an extra space between the sign
-    // and value when the currency symbol is suppressed (by not
-    // setting showbase).  We match glibc's strfmon by interpreting
-    // sep_by_space==1 as "omit the space when the currency symbol is
-    // absent".
-    //
-    // Users who want to get this right should use ICU instead.
-
-    switch (cs_precedes)
-    {
-    case 0:  // value before curr_symbol
-        if (symbol_contains_sep) {
-            // Move the separator to before the symbol, to place it
-            // between the value and symbol.
-            rotate(__curr_symbol_.begin(), __curr_symbol_.begin() + 3,
-                   __curr_symbol_.end());
-        }
-        switch (sign_posn)
-        {
-        case 0:  // Parentheses surround the quantity and currency symbol.
-            pat.field[0] = sign;
-            pat.field[1] = value;
-            pat.field[2] = none;  // Any space appears in the symbol.
-            pat.field[3] = symbol;
-            switch (sep_by_space)
-            {
-            case 0:  // No space separates the currency symbol and value.
-                // This case may have changed between C99 and C11;
-                // assume the currency symbol matches the intention.
-            case 2:  // Space between sign and currency or value.
-                // The "sign" is two parentheses, so no space here either.
-                return;
-            case 1:  // Space between currency-and-sign or currency and value.
-                if (!symbol_contains_sep) {
-                    // We insert the space into the symbol instead of
-                    // setting pat.field[2]=space so that when
-                    // showbase is not set, the space goes away too.
-                    __curr_symbol_.insert(0, 1, space_char);
-                }
-                return;
-            default:
-                break;
-            }
-            break;
-        case 1:  // The sign string precedes the quantity and currency symbol.
-            pat.field[0] = sign;
-            pat.field[3] = symbol;
-            switch (sep_by_space)
-            {
-            case 0:  // No space separates the currency symbol and value.
-                pat.field[1] = value;
-                pat.field[2] = none;
-                return;
-            case 1:  // Space between currency-and-sign or currency and value.
-                pat.field[1] = value;
-                pat.field[2] = none;
-                if (!symbol_contains_sep) {
-                    // We insert the space into the symbol instead of
-                    // setting pat.field[2]=space so that when
-                    // showbase is not set, the space goes away too.
-                    __curr_symbol_.insert(0, 1, space_char);
-                }
-                return;
-            case 2:  // Space between sign and currency or value.
-                pat.field[1] = space;
-                pat.field[2] = value;
-                if (symbol_contains_sep) {
-                    // Remove the separator from the symbol, since it
-                    // has already appeared after the sign.
-                    __curr_symbol_.erase(__curr_symbol_.begin());
-                }
-                return;
-            default:
-                break;
-            }
-            break;
-        case 2:  // The sign string succeeds the quantity and currency symbol.
-            pat.field[0] = value;
-            pat.field[3] = sign;
-            switch (sep_by_space)
-            {
-            case 0:  // No space separates the currency symbol and value.
-                pat.field[1] = none;
-                pat.field[2] = symbol;
-                return;
-            case 1:  // Space between currency-and-sign or currency and value.
-                if (!symbol_contains_sep) {
-                    // We insert the space into the symbol instead of
-                    // setting pat.field[1]=space so that when
-                    // showbase is not set, the space goes away too.
-                    __curr_symbol_.insert(0, 1, space_char);
-                }
-                pat.field[1] = none;
-                pat.field[2] = symbol;
-                return;
-            case 2:  // Space between sign and currency or value.
-                pat.field[1] = symbol;
-                pat.field[2] = space;
-                if (symbol_contains_sep) {
-                    // Remove the separator from the symbol, since it
-                    // should not be removed if showbase is absent.
-                    __curr_symbol_.erase(__curr_symbol_.begin());
-                }
-                return;
-            default:
-                break;
-            }
-            break;
-        case 3:  // The sign string immediately precedes the currency symbol.
-            pat.field[0] = value;
-            pat.field[3] = symbol;
-            switch (sep_by_space)
-            {
-            case 0:  // No space separates the currency symbol and value.
-                pat.field[1] = none;
-                pat.field[2] = sign;
-                return;
-            case 1:  // Space between currency-and-sign or currency and value.
-                pat.field[1] = space;
-                pat.field[2] = sign;
-                if (symbol_contains_sep) {
-                    // Remove the separator from the symbol, since it
-                    // has already appeared before the sign.
-                    __curr_symbol_.erase(__curr_symbol_.begin());
-                }
-                return;
-            case 2:  // Space between sign and currency or value.
-                pat.field[1] = sign;
-                pat.field[2] = none;
-                if (!symbol_contains_sep) {
-                    // We insert the space into the symbol instead of
-                    // setting pat.field[2]=space so that when
-                    // showbase is not set, the space goes away too.
-                    __curr_symbol_.insert(0, 1, space_char);
-                }
-                return;
-            default:
-                break;
-            }
-            break;
-        case 4:  // The sign string immediately succeeds the currency symbol.
-            pat.field[0] = value;
-            pat.field[3] = sign;
-            switch (sep_by_space)
-            {
-            case 0:  // No space separates the currency symbol and value.
-                pat.field[1] = none;
-                pat.field[2] = symbol;
-                return;
-            case 1:  // Space between currency-and-sign or currency and value.
-                pat.field[1] = none;
-                pat.field[2] = symbol;
-                if (!symbol_contains_sep) {
-                    // We insert the space into the symbol instead of
-                    // setting pat.field[1]=space so that when
-                    // showbase is not set, the space goes away too.
-                    __curr_symbol_.insert(0, 1, space_char);
-                }
-                return;
-            case 2:  // Space between sign and currency or value.
-                pat.field[1] = symbol;
-                pat.field[2] = space;
-                if (symbol_contains_sep) {
-                    // Remove the separator from the symbol, since it
-                    // should not disappear when showbase is absent.
-                    __curr_symbol_.erase(__curr_symbol_.begin());
-                }
-                return;
-            default:
-                break;
-            }
-            break;
-        default:
-            break;
-        }
-        break;
-    case 1:  // curr_symbol before value
-        switch (sign_posn)
-        {
-        case 0:  // Parentheses surround the quantity and currency symbol.
-            pat.field[0] = sign;
-            pat.field[1] = symbol;
-            pat.field[2] = none;  // Any space appears in the symbol.
-            pat.field[3] = value;
-            switch (sep_by_space)
-            {
-            case 0:  // No space separates the currency symbol and value.
-                // This case may have changed between C99 and C11;
-                // assume the currency symbol matches the intention.
-            case 2:  // Space between sign and currency or value.
-                // The "sign" is two parentheses, so no space here either.
-                return;
-            case 1:  // Space between currency-and-sign or currency and value.
-                if (!symbol_contains_sep) {
-                    // We insert the space into the symbol instead of
-                    // setting pat.field[2]=space so that when
-                    // showbase is not set, the space goes away too.
-                    __curr_symbol_.insert(0, 1, space_char);
-                }
-                return;
-            default:
-                break;
-            }
-            break;
-        case 1:  // The sign string precedes the quantity and currency symbol.
-            pat.field[0] = sign;
-            pat.field[3] = value;
-            switch (sep_by_space)
-            {
-            case 0:  // No space separates the currency symbol and value.
-                pat.field[1] = symbol;
-                pat.field[2] = none;
-                return;
-            case 1:  // Space between currency-and-sign or currency and value.
-                pat.field[1] = symbol;
-                pat.field[2] = none;
-                if (!symbol_contains_sep) {
-                    // We insert the space into the symbol instead of
-                    // setting pat.field[2]=space so that when
-                    // showbase is not set, the space goes away too.
-                    __curr_symbol_.push_back(space_char);
-                }
-                return;
-            case 2:  // Space between sign and currency or value.
-                pat.field[1] = space;
-                pat.field[2] = symbol;
-                if (symbol_contains_sep) {
-                    // Remove the separator from the symbol, since it
-                    // has already appeared after the sign.
-                    __curr_symbol_.pop_back();
-                }
-                return;
-            default:
-                break;
-            }
-            break;
-        case 2:  // The sign string succeeds the quantity and currency symbol.
-            pat.field[0] = symbol;
-            pat.field[3] = sign;
-            switch (sep_by_space)
-            {
-            case 0:  // No space separates the currency symbol and value.
-                pat.field[1] = none;
-                pat.field[2] = value;
-                return;
-            case 1:  // Space between currency-and-sign or currency and value.
-                pat.field[1] = none;
-                pat.field[2] = value;
-                if (!symbol_contains_sep) {
-                    // We insert the space into the symbol instead of
-                    // setting pat.field[1]=space so that when
-                    // showbase is not set, the space goes away too.
-                    __curr_symbol_.push_back(space_char);
-                }
-                return;
-            case 2:  // Space between sign and currency or value.
-                pat.field[1] = value;
-                pat.field[2] = space;
-                if (symbol_contains_sep) {
-                    // Remove the separator from the symbol, since it
-                    // will appear before the sign.
-                    __curr_symbol_.pop_back();
-                }
-                return;
-            default:
-                break;
-            }
-            break;
-        case 3:  // The sign string immediately precedes the currency symbol.
-            pat.field[0] = sign;
-            pat.field[3] = value;
-            switch (sep_by_space)
-            {
-            case 0:  // No space separates the currency symbol and value.
-                pat.field[1] = symbol;
-                pat.field[2] = none;
-                return;
-            case 1:  // Space between currency-and-sign or currency and value.
-                pat.field[1] = symbol;
-                pat.field[2] = none;
-                if (!symbol_contains_sep) {
-                    // We insert the space into the symbol instead of
-                    // setting pat.field[2]=space so that when
-                    // showbase is not set, the space goes away too.
-                    __curr_symbol_.push_back(space_char);
-                }
-                return;
-            case 2:  // Space between sign and currency or value.
-                pat.field[1] = space;
-                pat.field[2] = symbol;
-                if (symbol_contains_sep) {
-                    // Remove the separator from the symbol, since it
-                    // has already appeared after the sign.
-                    __curr_symbol_.pop_back();
-                }
-                return;
-            default:
-                break;
-            }
-            break;
-        case 4:  // The sign string immediately succeeds the currency symbol.
-            pat.field[0] = symbol;
-            pat.field[3] = value;
-            switch (sep_by_space)
-            {
-            case 0:  // No space separates the currency symbol and value.
-                pat.field[1] = sign;
-                pat.field[2] = none;
-                return;
-            case 1:  // Space between currency-and-sign or currency and value.
-                pat.field[1] = sign;
-                pat.field[2] = space;
-                if (symbol_contains_sep) {
-                    // Remove the separator from the symbol, since it
-                    // should not disappear when showbase is absent.
-                    __curr_symbol_.pop_back();
-                }
-                return;
-            case 2:  // Space between sign and currency or value.
-                pat.field[1] = none;
-                pat.field[2] = sign;
-                if (!symbol_contains_sep) {
-                    // We insert the space into the symbol instead of
-                    // setting pat.field[1]=space so that when
-                    // showbase is not set, the space goes away too.
-                    __curr_symbol_.push_back(space_char);
-                }
-                return;
-           default:
-                break;
-            }
-            break;
-        default:
-            break;
-        }
-        break;
-    default:
-        break;
-    }
-    pat.field[0] = symbol;
-    pat.field[1] = sign;
-    pat.field[2] = none;
-    pat.field[3] = value;
-}
-
-template<>
-void
-moneypunct_byname<char, false>::init(const char* nm)
-{
-    typedef moneypunct<char, false> base;
-    __libcpp_unique_locale loc(nm);
-    if (!loc)
-        __throw_runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
-
-    lconv* lc = __libcpp_localeconv_l(loc.get());
-    if (!checked_string_to_char_convert(__decimal_point_,
-                                        lc->mon_decimal_point,
-                                        loc.get()))
-      __decimal_point_ = base::do_decimal_point();
-    if (!checked_string_to_char_convert(__thousands_sep_,
-                                        lc->mon_thousands_sep,
-                                        loc.get()))
-      __thousands_sep_ = base::do_thousands_sep();
-
-    __grouping_ = lc->mon_grouping;
-    __curr_symbol_ = lc->currency_symbol;
-    if (lc->frac_digits != CHAR_MAX)
-        __frac_digits_ = lc->frac_digits;
-    else
-        __frac_digits_ = base::do_frac_digits();
-    if (lc->p_sign_posn == 0)
-        __positive_sign_ = "()";
-    else
-        __positive_sign_ = lc->positive_sign;
-    if (lc->n_sign_posn == 0)
-        __negative_sign_ = "()";
-    else
-        __negative_sign_ = lc->negative_sign;
-    // Assume the positive and negative formats will want spaces in
-    // the same places in curr_symbol since there's no way to
-    // represent anything else.
-    string_type __dummy_curr_symbol = __curr_symbol_;
-    __init_pat(__pos_format_, __dummy_curr_symbol, false,
-               lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
-    __init_pat(__neg_format_, __curr_symbol_, false,
-               lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
-}
-
-template<>
-void
-moneypunct_byname<char, true>::init(const char* nm)
-{
-    typedef moneypunct<char, true> base;
-    __libcpp_unique_locale loc(nm);
-    if (!loc)
-        __throw_runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
-
-    lconv* lc = __libcpp_localeconv_l(loc.get());
-    if (!checked_string_to_char_convert(__decimal_point_,
-                                        lc->mon_decimal_point,
-                                        loc.get()))
-      __decimal_point_ = base::do_decimal_point();
-    if (!checked_string_to_char_convert(__thousands_sep_,
-                                        lc->mon_thousands_sep,
-                                        loc.get()))
-      __thousands_sep_ = base::do_thousands_sep();
-    __grouping_ = lc->mon_grouping;
-    __curr_symbol_ = lc->int_curr_symbol;
-    if (lc->int_frac_digits != CHAR_MAX)
-        __frac_digits_ = lc->int_frac_digits;
-    else
-        __frac_digits_ = base::do_frac_digits();
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-    if (lc->p_sign_posn == 0)
-#else // _LIBCPP_MSVCRT
-    if (lc->int_p_sign_posn == 0)
-#endif // !_LIBCPP_MSVCRT
-        __positive_sign_ = "()";
-    else
-        __positive_sign_ = lc->positive_sign;
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-    if(lc->n_sign_posn == 0)
-#else // _LIBCPP_MSVCRT
-    if (lc->int_n_sign_posn == 0)
-#endif // !_LIBCPP_MSVCRT
-        __negative_sign_ = "()";
-    else
-        __negative_sign_ = lc->negative_sign;
-    // Assume the positive and negative formats will want spaces in
-    // the same places in curr_symbol since there's no way to
-    // represent anything else.
-    string_type __dummy_curr_symbol = __curr_symbol_;
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-    __init_pat(__pos_format_, __dummy_curr_symbol, true,
-               lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, ' ');
-    __init_pat(__neg_format_, __curr_symbol_, true,
-               lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, ' ');
-#else // _LIBCPP_MSVCRT
-    __init_pat(__pos_format_, __dummy_curr_symbol, true,
-               lc->int_p_cs_precedes, lc->int_p_sep_by_space,
-               lc->int_p_sign_posn, ' ');
-    __init_pat(__neg_format_, __curr_symbol_, true,
-               lc->int_n_cs_precedes, lc->int_n_sep_by_space,
-               lc->int_n_sign_posn, ' ');
-#endif // !_LIBCPP_MSVCRT
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template<>
-void
-moneypunct_byname<wchar_t, false>::init(const char* nm)
-{
-    typedef moneypunct<wchar_t, false> base;
-    __libcpp_unique_locale loc(nm);
-    if (!loc)
-        __throw_runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
-    lconv* lc = __libcpp_localeconv_l(loc.get());
-    if (!checked_string_to_wchar_convert(__decimal_point_,
-                                         lc->mon_decimal_point,
-                                         loc.get()))
-      __decimal_point_ = base::do_decimal_point();
-    if (!checked_string_to_wchar_convert(__thousands_sep_,
-                                         lc->mon_thousands_sep,
-                                         loc.get()))
-      __thousands_sep_ = base::do_thousands_sep();
-    __grouping_ = lc->mon_grouping;
-    wchar_t wbuf[100];
-    mbstate_t mb = {0};
-    const char* bb = lc->currency_symbol;
-    size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-    if (j == size_t(-1))
-        __throw_runtime_error("locale not supported");
-    wchar_t* wbe = wbuf + j;
-    __curr_symbol_.assign(wbuf, wbe);
-    if (lc->frac_digits != CHAR_MAX)
-        __frac_digits_ = lc->frac_digits;
-    else
-        __frac_digits_ = base::do_frac_digits();
-    if (lc->p_sign_posn == 0)
-        __positive_sign_ = L"()";
-    else
-    {
-        mb = mbstate_t();
-        bb = lc->positive_sign;
-        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-        if (j == size_t(-1))
-            __throw_runtime_error("locale not supported");
-        wbe = wbuf + j;
-        __positive_sign_.assign(wbuf, wbe);
-    }
-    if (lc->n_sign_posn == 0)
-        __negative_sign_ = L"()";
-    else
-    {
-        mb = mbstate_t();
-        bb = lc->negative_sign;
-        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-        if (j == size_t(-1))
-            __throw_runtime_error("locale not supported");
-        wbe = wbuf + j;
-        __negative_sign_.assign(wbuf, wbe);
-    }
-    // Assume the positive and negative formats will want spaces in
-    // the same places in curr_symbol since there's no way to
-    // represent anything else.
-    string_type __dummy_curr_symbol = __curr_symbol_;
-    __init_pat(__pos_format_, __dummy_curr_symbol, false,
-               lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
-    __init_pat(__neg_format_, __curr_symbol_, false,
-               lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
-}
-
-template<>
-void
-moneypunct_byname<wchar_t, true>::init(const char* nm)
-{
-    typedef moneypunct<wchar_t, true> base;
-    __libcpp_unique_locale loc(nm);
-    if (!loc)
-        __throw_runtime_error("moneypunct_byname"
-                            " failed to construct for " + string(nm));
-
-    lconv* lc = __libcpp_localeconv_l(loc.get());
-    if (!checked_string_to_wchar_convert(__decimal_point_,
-                                         lc->mon_decimal_point,
-                                         loc.get()))
-      __decimal_point_ = base::do_decimal_point();
-    if (!checked_string_to_wchar_convert(__thousands_sep_,
-                                         lc->mon_thousands_sep,
-                                         loc.get()))
-      __thousands_sep_ = base::do_thousands_sep();
-    __grouping_ = lc->mon_grouping;
-    wchar_t wbuf[100];
-    mbstate_t mb = {0};
-    const char* bb = lc->int_curr_symbol;
-    size_t j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-    if (j == size_t(-1))
-        __throw_runtime_error("locale not supported");
-    wchar_t* wbe = wbuf + j;
-    __curr_symbol_.assign(wbuf, wbe);
-    if (lc->int_frac_digits != CHAR_MAX)
-        __frac_digits_ = lc->int_frac_digits;
-    else
-        __frac_digits_ = base::do_frac_digits();
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-    if (lc->p_sign_posn == 0)
-#else // _LIBCPP_MSVCRT
-    if (lc->int_p_sign_posn == 0)
-#endif // !_LIBCPP_MSVCRT
-        __positive_sign_ = L"()";
-    else
-    {
-        mb = mbstate_t();
-        bb = lc->positive_sign;
-        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-        if (j == size_t(-1))
-            __throw_runtime_error("locale not supported");
-        wbe = wbuf + j;
-        __positive_sign_.assign(wbuf, wbe);
-    }
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-    if (lc->n_sign_posn == 0)
-#else // _LIBCPP_MSVCRT
-    if (lc->int_n_sign_posn == 0)
-#endif // !_LIBCPP_MSVCRT
-        __negative_sign_ = L"()";
-    else
-    {
-        mb = mbstate_t();
-        bb = lc->negative_sign;
-        j = __libcpp_mbsrtowcs_l(wbuf, &bb, countof(wbuf), &mb, loc.get());
-        if (j == size_t(-1))
-            __throw_runtime_error("locale not supported");
-        wbe = wbuf + j;
-        __negative_sign_.assign(wbuf, wbe);
-    }
-    // Assume the positive and negative formats will want spaces in
-    // the same places in curr_symbol since there's no way to
-    // represent anything else.
-    string_type __dummy_curr_symbol = __curr_symbol_;
-#if defined(_LIBCPP_MSVCRT) || defined(__MINGW32__)
-    __init_pat(__pos_format_, __dummy_curr_symbol, true,
-               lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn, L' ');
-    __init_pat(__neg_format_, __curr_symbol_, true,
-               lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn, L' ');
-#else // _LIBCPP_MSVCRT
-    __init_pat(__pos_format_, __dummy_curr_symbol, true,
-               lc->int_p_cs_precedes, lc->int_p_sep_by_space,
-               lc->int_p_sign_posn, L' ');
-    __init_pat(__neg_format_, __curr_symbol_, true,
-               lc->int_n_cs_precedes, lc->int_n_sep_by_space,
-               lc->int_n_sign_posn, L' ');
-#endif // !_LIBCPP_MSVCRT
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-void __do_nothing(void*) {}
-
-void __throw_runtime_error(const char* msg)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw runtime_error(msg);
-#else
-    (void)msg;
-    _VSTD::abort();
-#endif
-}
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_get<wchar_t>;)
-
-                           template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_get<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS num_put<wchar_t>;)
-
-                           template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template struct _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __num_put<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_get_byname<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS time_put_byname<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, false>;
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<char, true>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, false>;)
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct<wchar_t, true>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, false>;
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<char, true>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, false>;)
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS moneypunct_byname<wchar_t, true>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_get<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_get<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS money_put<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS __money_put<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<char>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<wchar_t>;)
-
-                           template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char, char, mbstate_t>;
-_LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<wchar_t, char, mbstate_t>;)
-template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char, mbstate_t>;
-template class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char, mbstate_t>;
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char8_t, mbstate_t>;
-template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char8_t, mbstate_t>;
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/src/memory.cpp b/third_party/libcxx/src/memory.cpp
deleted file mode 100644
index c6638d942..000000000
--- a/third_party/libcxx/src/memory.cpp
+++ /dev/null
@@ -1,207 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-#ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
-#   define _LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS
-#endif
-
-#include <memory>
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-#  include <mutex>
-#  include <thread>
-#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#    pragma comment(lib, "pthread")
-#  endif
-#endif
-
-#include "third_party/libcxx/src/include/atomic_support.h"
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-bad_weak_ptr::~bad_weak_ptr() noexcept {}
-
-const char*
-bad_weak_ptr::what() const noexcept
-{
-    return "bad_weak_ptr";
-}
-
-__shared_count::~__shared_count()
-{
-}
-
-__shared_weak_count::~__shared_weak_count()
-{
-}
-
-#if defined(_LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS)
-void
-__shared_count::__add_shared() noexcept
-{
-    __libcpp_atomic_refcount_increment(__shared_owners_);
-}
-
-bool
-__shared_count::__release_shared() noexcept
-{
-    if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1)
-    {
-        __on_zero_shared();
-        return true;
-    }
-    return false;
-}
-
-void
-__shared_weak_count::__add_shared() noexcept
-{
-    __shared_count::__add_shared();
-}
-
-void
-__shared_weak_count::__add_weak() noexcept
-{
-    __libcpp_atomic_refcount_increment(__shared_weak_owners_);
-}
-
-void
-__shared_weak_count::__release_shared() noexcept
-{
-    if (__shared_count::__release_shared())
-        __release_weak();
-}
-#endif // _LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS
-
-void
-__shared_weak_count::__release_weak() noexcept
-{
-    // NOTE: The acquire load here is an optimization of the very
-    // common case where a shared pointer is being destructed while
-    // having no other contended references.
-    //
-    // BENEFIT: We avoid expensive atomic stores like XADD and STREX
-    // in a common case.  Those instructions are slow and do nasty
-    // things to caches.
-    //
-    // IS THIS SAFE?  Yes.  During weak destruction, if we see that we
-    // are the last reference, we know that no-one else is accessing
-    // us. If someone were accessing us, then they would be doing so
-    // while the last shared / weak_ptr was being destructed, and
-    // that's undefined anyway.
-    //
-    // If we see anything other than a 0, then we have possible
-    // contention, and need to use an atomicrmw primitive.
-    // The same arguments don't apply for increment, where it is legal
-    // (though inadvisable) to share shared_ptr references between
-    // threads, and have them all get copied at once.  The argument
-    // also doesn't apply for __release_shared, because an outstanding
-    // weak_ptr::lock() could read / modify the shared count.
-    if (__libcpp_atomic_load(&__shared_weak_owners_, _AO_Acquire) == 0)
-    {
-        // no need to do this store, because we are about
-        // to destroy everything.
-        //__libcpp_atomic_store(&__shared_weak_owners_, -1, _AO_Release);
-        __on_zero_shared_weak();
-    }
-    else if (__libcpp_atomic_refcount_decrement(__shared_weak_owners_) == -1)
-        __on_zero_shared_weak();
-}
-
-__shared_weak_count*
-__shared_weak_count::lock() noexcept
-{
-    long object_owners = __libcpp_atomic_load(&__shared_owners_);
-    while (object_owners != -1)
-    {
-        if (__libcpp_atomic_compare_exchange(&__shared_owners_,
-                                             &object_owners,
-                                             object_owners+1))
-            return this;
-    }
-    return nullptr;
-}
-
-const void*
-__shared_weak_count::__get_deleter(const type_info&) const noexcept
-{
-    return nullptr;
-}
-
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-
-static constexpr std::size_t __sp_mut_count = 32;
-static constinit __libcpp_mutex_t mut_back[__sp_mut_count] =
-{
-    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
-    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
-    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
-    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
-    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
-    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
-    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER,
-    _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER, _LIBCPP_MUTEX_INITIALIZER
-};
-
-_LIBCPP_CONSTEXPR __sp_mut::__sp_mut(void* p) noexcept
-   : __lx_(p)
-{
-}
-
-void
-__sp_mut::lock() noexcept
-{
-    auto m = static_cast<__libcpp_mutex_t*>(__lx_);
-    __libcpp_mutex_lock(m);
-}
-
-void
-__sp_mut::unlock() noexcept
-{
-    __libcpp_mutex_unlock(static_cast<__libcpp_mutex_t*>(__lx_));
-}
-
-__sp_mut&
-__get_sp_mut(const void* p)
-{
-    static constinit __sp_mut muts[__sp_mut_count] = {
-        &mut_back[ 0], &mut_back[ 1], &mut_back[ 2], &mut_back[ 3],
-        &mut_back[ 4], &mut_back[ 5], &mut_back[ 6], &mut_back[ 7],
-        &mut_back[ 8], &mut_back[ 9], &mut_back[10], &mut_back[11],
-        &mut_back[12], &mut_back[13], &mut_back[14], &mut_back[15],
-        &mut_back[16], &mut_back[17], &mut_back[18], &mut_back[19],
-        &mut_back[20], &mut_back[21], &mut_back[22], &mut_back[23],
-        &mut_back[24], &mut_back[25], &mut_back[26], &mut_back[27],
-        &mut_back[28], &mut_back[29], &mut_back[30], &mut_back[31]
-    };
-    return muts[hash<const void*>()(p) & (__sp_mut_count-1)];
-}
-
-#endif // !defined(_LIBCPP_HAS_NO_THREADS)
-
-void*
-align(size_t alignment, size_t size, void*& ptr, size_t& space)
-{
-    void* r = nullptr;
-    if (size <= space)
-    {
-        char* p1 = static_cast<char*>(ptr);
-        char* p2 = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(p1 + (alignment - 1)) & -alignment);
-        size_t d = static_cast<size_t>(p2 - p1);
-        if (d <= space - size)
-        {
-            r = p2;
-            ptr = r;
-            space -= d;
-        }
-    }
-    return r;
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/memory_resource.cpp b/third_party/libcxx/src/memory_resource.cpp
deleted file mode 100644
index ca1d6406a..000000000
--- a/third_party/libcxx/src/memory_resource.cpp
+++ /dev/null
@@ -1,496 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <memory>
-#include <memory_resource>
-
-#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
-#  include <atomic>
-#elif !defined(_LIBCPP_HAS_NO_THREADS)
-#  include <mutex>
-#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#    pragma comment(lib, "pthread")
-#  endif
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-namespace pmr {
-
-// memory_resource
-
-memory_resource::~memory_resource() = default;
-
-// new_delete_resource()
-
-#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-static bool is_aligned_to(void* ptr, size_t align) {
-  void* p2     = ptr;
-  size_t space = 1;
-  void* result = std::align(align, 1, p2, space);
-  return (result == ptr);
-}
-#endif
-
-class _LIBCPP_TYPE_VIS __new_delete_memory_resource_imp : public memory_resource {
-  void* do_allocate(size_t bytes, size_t align) override {
-#ifndef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-    return std::__libcpp_allocate(bytes, align);
-#else
-    if (bytes == 0)
-      bytes = 1;
-    void* result = std::__libcpp_allocate(bytes, align);
-    if (!is_aligned_to(result, align)) {
-      std::__libcpp_deallocate(result, bytes, align);
-      __throw_bad_alloc();
-    }
-    return result;
-#endif
-  }
-
-  void do_deallocate(void* p, size_t bytes, size_t align) override { std::__libcpp_deallocate(p, bytes, align); }
-
-  bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
-};
-
-// null_memory_resource()
-
-class _LIBCPP_TYPE_VIS __null_memory_resource_imp : public memory_resource {
-  void* do_allocate(size_t, size_t) override { __throw_bad_alloc(); }
-  void do_deallocate(void*, size_t, size_t) override {}
-  bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
-};
-
-namespace {
-
-union ResourceInitHelper {
-  struct {
-    __new_delete_memory_resource_imp new_delete_res;
-    __null_memory_resource_imp null_res;
-  } resources;
-  char dummy;
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 ResourceInitHelper() : resources() {}
-  ~ResourceInitHelper() {}
-};
-
-// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
-// attribute with a value that's reserved for the implementation (we're the implementation).
-#include "memory_resource_init_helper.h"
-
-} // end namespace
-
-memory_resource* new_delete_resource() noexcept { return &res_init.resources.new_delete_res; }
-
-memory_resource* null_memory_resource() noexcept { return &res_init.resources.null_res; }
-
-// default_memory_resource()
-
-static memory_resource* __default_memory_resource(bool set = false, memory_resource* new_res = nullptr) noexcept {
-#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
-  static constinit atomic<memory_resource*> __res{&res_init.resources.new_delete_res};
-  if (set) {
-    new_res = new_res ? new_res : new_delete_resource();
-    // TODO: Can a weaker ordering be used?
-    return std::atomic_exchange_explicit(&__res, new_res, memory_order_acq_rel);
-  } else {
-    return std::atomic_load_explicit(&__res, memory_order_acquire);
-  }
-#elif !defined(_LIBCPP_HAS_NO_THREADS)
-  static constinit memory_resource* res = &res_init.resources.new_delete_res;
-  static mutex res_lock;
-  if (set) {
-    new_res = new_res ? new_res : new_delete_resource();
-    lock_guard<mutex> guard(res_lock);
-    memory_resource* old_res = res;
-    res                      = new_res;
-    return old_res;
-  } else {
-    lock_guard<mutex> guard(res_lock);
-    return res;
-  }
-#else
-  static constinit memory_resource* res = &res_init.resources.new_delete_res;
-  if (set) {
-    new_res                  = new_res ? new_res : new_delete_resource();
-    memory_resource* old_res = res;
-    res                      = new_res;
-    return old_res;
-  } else {
-    return res;
-  }
-#endif
-}
-
-memory_resource* get_default_resource() noexcept { return __default_memory_resource(); }
-
-memory_resource* set_default_resource(memory_resource* __new_res) noexcept {
-  return __default_memory_resource(true, __new_res);
-}
-
-// 23.12.5, mem.res.pool
-
-static size_t roundup(size_t count, size_t alignment) {
-  size_t mask = alignment - 1;
-  return (count + mask) & ~mask;
-}
-
-struct unsynchronized_pool_resource::__adhoc_pool::__chunk_footer {
-  __chunk_footer* __next_;
-  char* __start_;
-  size_t __align_;
-  size_t __allocation_size() { return (reinterpret_cast<char*>(this) - __start_) + sizeof(*this); }
-};
-
-void unsynchronized_pool_resource::__adhoc_pool::__release_ptr(memory_resource* upstream) {
-  while (__first_ != nullptr) {
-    __chunk_footer* next = __first_->__next_;
-    upstream->deallocate(__first_->__start_, __first_->__allocation_size(), __first_->__align_);
-    __first_ = next;
-  }
-}
-
-void* unsynchronized_pool_resource::__adhoc_pool::__do_allocate(memory_resource* upstream, size_t bytes, size_t align) {
-  const size_t footer_size  = sizeof(__chunk_footer);
-  const size_t footer_align = alignof(__chunk_footer);
-
-  if (align < footer_align)
-    align = footer_align;
-
-  size_t aligned_capacity = roundup(bytes, footer_align) + footer_size;
-
-  void* result = upstream->allocate(aligned_capacity, align);
-
-  __chunk_footer* h = (__chunk_footer*)((char*)result + aligned_capacity - footer_size);
-  h->__next_        = __first_;
-  h->__start_       = (char*)result;
-  h->__align_       = align;
-  __first_          = h;
-  return result;
-}
-
-void unsynchronized_pool_resource::__adhoc_pool::__do_deallocate(
-    memory_resource* upstream, void* p, size_t bytes, size_t align) {
-  _LIBCPP_ASSERT(__first_ != nullptr, "deallocating a block that was not allocated with this allocator");
-  if (__first_->__start_ == p) {
-    __chunk_footer* next = __first_->__next_;
-    upstream->deallocate(p, __first_->__allocation_size(), __first_->__align_);
-    __first_ = next;
-  } else {
-    for (__chunk_footer* h = __first_; h->__next_ != nullptr; h = h->__next_) {
-      if (h->__next_->__start_ == p) {
-        __chunk_footer* next = h->__next_->__next_;
-        upstream->deallocate(p, h->__next_->__allocation_size(), h->__next_->__align_);
-        h->__next_ = next;
-        return;
-      }
-    }
-    _LIBCPP_ASSERT(false, "deallocating a block that was not allocated with this allocator");
-  }
-}
-
-class unsynchronized_pool_resource::__fixed_pool {
-  struct __chunk_footer {
-    __chunk_footer* __next_;
-    char* __start_;
-    size_t __align_;
-    size_t __allocation_size() { return (reinterpret_cast<char*>(this) - __start_) + sizeof(*this); }
-  };
-
-  struct __vacancy_header {
-    __vacancy_header* __next_vacancy_;
-  };
-
-  __chunk_footer* __first_chunk_     = nullptr;
-  __vacancy_header* __first_vacancy_ = nullptr;
-
-public:
-  explicit __fixed_pool() = default;
-
-  void __release_ptr(memory_resource* upstream) {
-    __first_vacancy_ = nullptr;
-    while (__first_chunk_ != nullptr) {
-      __chunk_footer* next = __first_chunk_->__next_;
-      upstream->deallocate(__first_chunk_->__start_, __first_chunk_->__allocation_size(), __first_chunk_->__align_);
-      __first_chunk_ = next;
-    }
-  }
-
-  void* __try_allocate_from_vacancies() {
-    if (__first_vacancy_ != nullptr) {
-      void* result     = __first_vacancy_;
-      __first_vacancy_ = __first_vacancy_->__next_vacancy_;
-      return result;
-    }
-    return nullptr;
-  }
-
-  void* __allocate_in_new_chunk(memory_resource* upstream, size_t block_size, size_t chunk_size) {
-    _LIBCPP_ASSERT(chunk_size % block_size == 0, "");
-    static_assert(__default_alignment >= alignof(std::max_align_t), "");
-    static_assert(__default_alignment >= alignof(__chunk_footer), "");
-    static_assert(__default_alignment >= alignof(__vacancy_header), "");
-
-    const size_t footer_size  = sizeof(__chunk_footer);
-    const size_t footer_align = alignof(__chunk_footer);
-
-    size_t aligned_capacity = roundup(chunk_size, footer_align) + footer_size;
-
-    void* result = upstream->allocate(aligned_capacity, __default_alignment);
-
-    __chunk_footer* h = (__chunk_footer*)((char*)result + aligned_capacity - footer_size);
-    h->__next_        = __first_chunk_;
-    h->__start_       = (char*)result;
-    h->__align_       = __default_alignment;
-    __first_chunk_    = h;
-
-    if (chunk_size > block_size) {
-      __vacancy_header* last_vh = this->__first_vacancy_;
-      for (size_t i = block_size; i != chunk_size; i += block_size) {
-        __vacancy_header* vh = (__vacancy_header*)((char*)result + i);
-        vh->__next_vacancy_  = last_vh;
-        last_vh              = vh;
-      }
-      this->__first_vacancy_ = last_vh;
-    }
-    return result;
-  }
-
-  void __evacuate(void* p) {
-    __vacancy_header* vh = (__vacancy_header*)(p);
-    vh->__next_vacancy_  = __first_vacancy_;
-    __first_vacancy_     = vh;
-  }
-
-  size_t __previous_chunk_size_in_bytes() const { return __first_chunk_ ? __first_chunk_->__allocation_size() : 0; }
-
-  static const size_t __default_alignment = alignof(max_align_t);
-};
-
-size_t unsynchronized_pool_resource::__pool_block_size(int i) const { return size_t(1) << __log2_pool_block_size(i); }
-
-int unsynchronized_pool_resource::__log2_pool_block_size(int i) const { return (i + __log2_smallest_block_size); }
-
-int unsynchronized_pool_resource::__pool_index(size_t bytes, size_t align) const {
-  if (align > alignof(std::max_align_t) || bytes > (size_t(1) << __num_fixed_pools_))
-    return __num_fixed_pools_;
-  else {
-    int i = 0;
-    bytes = (bytes > align) ? bytes : align;
-    bytes -= 1;
-    bytes >>= __log2_smallest_block_size;
-    while (bytes != 0) {
-      bytes >>= 1;
-      i += 1;
-    }
-    return i;
-  }
-}
-
-unsynchronized_pool_resource::unsynchronized_pool_resource(const pool_options& opts, memory_resource* upstream)
-    : __res_(upstream), __fixed_pools_(nullptr) {
-  size_t largest_block_size;
-  if (opts.largest_required_pool_block == 0)
-    largest_block_size = __default_largest_block_size;
-  else if (opts.largest_required_pool_block < __smallest_block_size)
-    largest_block_size = __smallest_block_size;
-  else if (opts.largest_required_pool_block > __max_largest_block_size)
-    largest_block_size = __max_largest_block_size;
-  else
-    largest_block_size = opts.largest_required_pool_block;
-
-  if (opts.max_blocks_per_chunk == 0)
-    __options_max_blocks_per_chunk_ = __max_blocks_per_chunk;
-  else if (opts.max_blocks_per_chunk < __min_blocks_per_chunk)
-    __options_max_blocks_per_chunk_ = __min_blocks_per_chunk;
-  else if (opts.max_blocks_per_chunk > __max_blocks_per_chunk)
-    __options_max_blocks_per_chunk_ = __max_blocks_per_chunk;
-  else
-    __options_max_blocks_per_chunk_ = opts.max_blocks_per_chunk;
-
-  __num_fixed_pools_ = 1;
-  size_t capacity    = __smallest_block_size;
-  while (capacity < largest_block_size) {
-    capacity <<= 1;
-    __num_fixed_pools_ += 1;
-  }
-}
-
-pool_options unsynchronized_pool_resource::options() const {
-  pool_options p;
-  p.max_blocks_per_chunk        = __options_max_blocks_per_chunk_;
-  p.largest_required_pool_block = __pool_block_size(__num_fixed_pools_ - 1);
-  return p;
-}
-
-void unsynchronized_pool_resource::release() {
-  __adhoc_pool_.__release_ptr(__res_);
-  if (__fixed_pools_ != nullptr) {
-    const int n = __num_fixed_pools_;
-    for (int i = 0; i < n; ++i)
-      __fixed_pools_[i].__release_ptr(__res_);
-    __res_->deallocate(__fixed_pools_, __num_fixed_pools_ * sizeof(__fixed_pool), alignof(__fixed_pool));
-    __fixed_pools_ = nullptr;
-  }
-}
-
-void* unsynchronized_pool_resource::do_allocate(size_t bytes, size_t align) {
-  // A pointer to allocated storage (6.6.4.4.1) with a size of at least bytes.
-  // The size and alignment of the allocated memory shall meet the requirements for
-  // a class derived from memory_resource (23.12).
-  // If the pool selected for a block of size bytes is unable to satisfy the memory request
-  // from its own internal data structures, it will call upstream_resource()->allocate()
-  // to obtain more memory. If bytes is larger than that which the largest pool can handle,
-  // then memory will be allocated using upstream_resource()->allocate().
-
-  int i = __pool_index(bytes, align);
-  if (i == __num_fixed_pools_)
-    return __adhoc_pool_.__do_allocate(__res_, bytes, align);
-  else {
-    if (__fixed_pools_ == nullptr) {
-      __fixed_pools_ =
-          (__fixed_pool*)__res_->allocate(__num_fixed_pools_ * sizeof(__fixed_pool), alignof(__fixed_pool));
-      __fixed_pool* first = __fixed_pools_;
-      __fixed_pool* last  = __fixed_pools_ + __num_fixed_pools_;
-      for (__fixed_pool* pool = first; pool != last; ++pool)
-        ::new ((void*)pool) __fixed_pool;
-    }
-    void* result = __fixed_pools_[i].__try_allocate_from_vacancies();
-    if (result == nullptr) {
-      auto min = [](size_t a, size_t b) { return a < b ? a : b; };
-      auto max = [](size_t a, size_t b) { return a < b ? b : a; };
-
-      size_t prev_chunk_size_in_bytes  = __fixed_pools_[i].__previous_chunk_size_in_bytes();
-      size_t prev_chunk_size_in_blocks = prev_chunk_size_in_bytes >> __log2_pool_block_size(i);
-
-      size_t chunk_size_in_blocks;
-
-      if (prev_chunk_size_in_blocks == 0) {
-        size_t min_blocks_per_chunk = max(__min_bytes_per_chunk >> __log2_pool_block_size(i), __min_blocks_per_chunk);
-        chunk_size_in_blocks        = min_blocks_per_chunk;
-      } else {
-        static_assert(__max_bytes_per_chunk <= SIZE_MAX - (__max_bytes_per_chunk / 4), "unsigned overflow is possible");
-        chunk_size_in_blocks = prev_chunk_size_in_blocks + (prev_chunk_size_in_blocks / 4);
-      }
-
-      size_t max_blocks_per_chunk =
-          min((__max_bytes_per_chunk >> __log2_pool_block_size(i)),
-              min(__max_blocks_per_chunk, __options_max_blocks_per_chunk_));
-      if (chunk_size_in_blocks > max_blocks_per_chunk)
-        chunk_size_in_blocks = max_blocks_per_chunk;
-
-      size_t block_size = __pool_block_size(i);
-
-      size_t chunk_size_in_bytes = (chunk_size_in_blocks << __log2_pool_block_size(i));
-      result                     = __fixed_pools_[i].__allocate_in_new_chunk(__res_, block_size, chunk_size_in_bytes);
-    }
-    return result;
-  }
-}
-
-void unsynchronized_pool_resource::do_deallocate(void* p, size_t bytes, size_t align) {
-  // Returns the memory at p to the pool. It is unspecified if,
-  // or under what circumstances, this operation will result in
-  // a call to upstream_resource()->deallocate().
-
-  int i = __pool_index(bytes, align);
-  if (i == __num_fixed_pools_)
-    return __adhoc_pool_.__do_deallocate(__res_, p, bytes, align);
-  else {
-    _LIBCPP_ASSERT(__fixed_pools_ != nullptr, "deallocating a block that was not allocated with this allocator");
-    __fixed_pools_[i].__evacuate(p);
-  }
-}
-
-bool synchronized_pool_resource::do_is_equal(const memory_resource& other) const noexcept { return &other == this; }
-
-// 23.12.6, mem.res.monotonic.buffer
-
-static void* align_down(size_t align, size_t size, void*& ptr, size_t& space) {
-  if (size > space)
-    return nullptr;
-
-  char* p1      = static_cast<char*>(ptr);
-  char* new_ptr = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(p1 - size) & ~(align - 1));
-
-  if (new_ptr < (p1 - space))
-    return nullptr;
-
-  ptr = new_ptr;
-  space -= p1 - new_ptr;
-
-  return ptr;
-}
-
-void* monotonic_buffer_resource::__initial_descriptor::__try_allocate_from_chunk(size_t bytes, size_t align) {
-  if (!__cur_)
-    return nullptr;
-  void* new_ptr       = static_cast<void*>(__cur_);
-  size_t new_capacity = (__cur_ - __start_);
-  void* aligned_ptr   = align_down(align, bytes, new_ptr, new_capacity);
-  if (aligned_ptr != nullptr)
-    __cur_ = static_cast<char*>(new_ptr);
-  return aligned_ptr;
-}
-
-void* monotonic_buffer_resource::__chunk_footer::__try_allocate_from_chunk(size_t bytes, size_t align) {
-  void* new_ptr       = static_cast<void*>(__cur_);
-  size_t new_capacity = (__cur_ - __start_);
-  void* aligned_ptr   = align_down(align, bytes, new_ptr, new_capacity);
-  if (aligned_ptr != nullptr)
-    __cur_ = static_cast<char*>(new_ptr);
-  return aligned_ptr;
-}
-
-void* monotonic_buffer_resource::do_allocate(size_t bytes, size_t align) {
-  const size_t footer_size  = sizeof(__chunk_footer);
-  const size_t footer_align = alignof(__chunk_footer);
-
-  auto previous_allocation_size = [&]() {
-    if (__chunks_ != nullptr)
-      return __chunks_->__allocation_size();
-
-    size_t newsize = (__initial_.__start_ != nullptr) ? (__initial_.__end_ - __initial_.__start_) : __initial_.__size_;
-
-    return roundup(newsize, footer_align) + footer_size;
-  };
-
-  if (void* result = __initial_.__try_allocate_from_chunk(bytes, align))
-    return result;
-  if (__chunks_ != nullptr) {
-    if (void* result = __chunks_->__try_allocate_from_chunk(bytes, align))
-      return result;
-  }
-
-  // Allocate a brand-new chunk.
-
-  if (align < footer_align)
-    align = footer_align;
-
-  size_t aligned_capacity  = roundup(bytes, footer_align) + footer_size;
-  size_t previous_capacity = previous_allocation_size();
-
-  if (aligned_capacity <= previous_capacity) {
-    size_t newsize   = 2 * (previous_capacity - footer_size);
-    aligned_capacity = roundup(newsize, footer_align) + footer_size;
-  }
-
-  char* start            = (char*)__res_->allocate(aligned_capacity, align);
-  auto end               = start + aligned_capacity - footer_size;
-  __chunk_footer* footer = (__chunk_footer*)(end);
-  footer->__next_        = __chunks_;
-  footer->__start_       = start;
-  footer->__cur_         = end;
-  footer->__align_       = align;
-  __chunks_              = footer;
-
-  return __chunks_->__try_allocate_from_chunk(bytes, align);
-}
-
-} // namespace pmr
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/memory_resource_init_helper.h b/third_party/libcxx/src/memory_resource_init_helper.h
deleted file mode 100644
index 032edc12f..000000000
--- a/third_party/libcxx/src/memory_resource_init_helper.h
+++ /dev/null
@@ -1,2 +0,0 @@
-#pragma GCC system_header
-static constinit ResourceInitHelper res_init _LIBCPP_INIT_PRIORITY_MAX;
diff --git a/third_party/libcxx/src/mutex.cpp b/third_party/libcxx/src/mutex.cpp
deleted file mode 100644
index f55ba8d82..000000000
--- a/third_party/libcxx/src/mutex.cpp
+++ /dev/null
@@ -1,262 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__assert>
-#include <limits>
-#include <mutex>
-
-#include "third_party/libcxx/src/include/atomic_support.h"
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#    pragma comment(lib, "pthread")
-#  endif
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-
-// ~mutex is defined elsewhere
-
-void
-mutex::lock()
-{
-    int ec = __libcpp_mutex_lock(&__m_);
-    if (ec)
-        __throw_system_error(ec, "mutex lock failed");
-}
-
-bool
-mutex::try_lock() noexcept
-{
-    return __libcpp_mutex_trylock(&__m_);
-}
-
-void
-mutex::unlock() noexcept
-{
-    int ec = __libcpp_mutex_unlock(&__m_);
-    (void)ec;
-    _LIBCPP_ASSERT(ec == 0, "call to mutex::unlock failed");
-}
-
-// recursive_mutex
-
-recursive_mutex::recursive_mutex()
-{
-    int ec = __libcpp_recursive_mutex_init(&__m_);
-    if (ec)
-        __throw_system_error(ec, "recursive_mutex constructor failed");
-}
-
-recursive_mutex::~recursive_mutex()
-{
-    int e = __libcpp_recursive_mutex_destroy(&__m_);
-    (void)e;
-    _LIBCPP_ASSERT(e == 0, "call to ~recursive_mutex() failed");
-}
-
-void
-recursive_mutex::lock()
-{
-    int ec = __libcpp_recursive_mutex_lock(&__m_);
-    if (ec)
-        __throw_system_error(ec, "recursive_mutex lock failed");
-}
-
-void
-recursive_mutex::unlock() noexcept
-{
-    int e = __libcpp_recursive_mutex_unlock(&__m_);
-    (void)e;
-    _LIBCPP_ASSERT(e == 0, "call to recursive_mutex::unlock() failed");
-}
-
-bool
-recursive_mutex::try_lock() noexcept
-{
-    return __libcpp_recursive_mutex_trylock(&__m_);
-}
-
-// timed_mutex
-
-timed_mutex::timed_mutex()
-    : __locked_(false)
-{
-}
-
-timed_mutex::~timed_mutex()
-{
-    lock_guard<mutex> _(__m_);
-}
-
-void
-timed_mutex::lock()
-{
-    unique_lock<mutex> lk(__m_);
-    while (__locked_)
-        __cv_.wait(lk);
-    __locked_ = true;
-}
-
-bool
-timed_mutex::try_lock() noexcept
-{
-    unique_lock<mutex> lk(__m_, try_to_lock);
-    if (lk.owns_lock() && !__locked_)
-    {
-        __locked_ = true;
-        return true;
-    }
-    return false;
-}
-
-void
-timed_mutex::unlock() noexcept
-{
-    lock_guard<mutex> _(__m_);
-    __locked_ = false;
-    __cv_.notify_one();
-}
-
-// recursive_timed_mutex
-
-recursive_timed_mutex::recursive_timed_mutex()
-    : __count_(0),
-      __id_{}
-{
-}
-
-recursive_timed_mutex::~recursive_timed_mutex()
-{
-    lock_guard<mutex> _(__m_);
-}
-
-void
-recursive_timed_mutex::lock()
-{
-    __thread_id id = this_thread::get_id();
-    unique_lock<mutex> lk(__m_);
-    if (id ==__id_)
-    {
-        if (__count_ == numeric_limits<size_t>::max())
-            __throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
-        ++__count_;
-        return;
-    }
-    while (__count_ != 0)
-        __cv_.wait(lk);
-    __count_ = 1;
-    __id_ = id;
-}
-
-bool
-recursive_timed_mutex::try_lock() noexcept
-{
-    __thread_id id = this_thread::get_id();
-    unique_lock<mutex> lk(__m_, try_to_lock);
-    if (lk.owns_lock() && (__count_ == 0 || id == __id_))
-    {
-        if (__count_ == numeric_limits<size_t>::max())
-            return false;
-        ++__count_;
-        __id_ = id;
-        return true;
-    }
-    return false;
-}
-
-void
-recursive_timed_mutex::unlock() noexcept
-{
-    unique_lock<mutex> lk(__m_);
-    if (--__count_ == 0)
-    {
-        __id_.__reset();
-        lk.unlock();
-        __cv_.notify_one();
-    }
-}
-
-#endif // !_LIBCPP_HAS_NO_THREADS
-
-// If dispatch_once_f ever handles C++ exceptions, and if one can get to it
-// without illegal macros (unexpected macros not beginning with _UpperCase or
-// __lowercase), and if it stops spinning waiting threads, then call_once should
-// call into dispatch_once_f instead of here. Relevant radar this code needs to
-// keep in sync with:  7741191.
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-static constinit __libcpp_mutex_t mut = _LIBCPP_MUTEX_INITIALIZER;
-static constinit __libcpp_condvar_t cv = _LIBCPP_CONDVAR_INITIALIZER;
-#endif
-
-void __call_once(volatile once_flag::_State_type& flag, void* arg,
-                 void (*func)(void*))
-{
-#if defined(_LIBCPP_HAS_NO_THREADS)
-    if (flag == 0)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            flag = 1;
-            func(arg);
-            flag = ~once_flag::_State_type(0);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            flag = 0;
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-#else // !_LIBCPP_HAS_NO_THREADS
-    __libcpp_mutex_lock(&mut);
-    while (flag == 1)
-        __libcpp_condvar_wait(&cv, &mut);
-    if (flag == 0)
-    {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            __libcpp_relaxed_store(&flag, once_flag::_State_type(1));
-            __libcpp_mutex_unlock(&mut);
-            func(arg);
-            __libcpp_mutex_lock(&mut);
-            __libcpp_atomic_store(&flag, ~once_flag::_State_type(0),
-                                  _AO_Release);
-            __libcpp_mutex_unlock(&mut);
-            __libcpp_condvar_broadcast(&cv);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __libcpp_mutex_lock(&mut);
-            __libcpp_relaxed_store(&flag, once_flag::_State_type(0));
-            __libcpp_mutex_unlock(&mut);
-            __libcpp_condvar_broadcast(&cv);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    else
-        __libcpp_mutex_unlock(&mut);
-#endif // !_LIBCPP_HAS_NO_THREADS
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/src/mutex_destructor.cpp b/third_party/libcxx/src/mutex_destructor.cpp
deleted file mode 100644
index 6850b6e6f..000000000
--- a/third_party/libcxx/src/mutex_destructor.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// Define ~mutex.
-//
-// On some platforms ~mutex has been made trivial and the definition is only
-// provided for ABI compatibility.
-//
-// In order to avoid ODR violations within libc++ itself, we need to ensure
-// that *nothing* sees the non-trivial mutex declaration. For this reason
-// we re-declare the entire class in this file instead of using
-// _LIBCPP_BUILDING_LIBRARY to change the definition in the headers.
-
-#include <__config>
-#include <__threading_support>
-
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-#  if _LIBCPP_ABI_VERSION == 1 || !defined(_LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION)
-#    define NEEDS_MUTEX_DESTRUCTOR
-#  endif
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#ifdef NEEDS_MUTEX_DESTRUCTOR
-class _LIBCPP_TYPE_VIS mutex
-{
-    __libcpp_mutex_t __m_ = _LIBCPP_MUTEX_INITIALIZER;
-
-public:
-    _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY
-    constexpr mutex() = default;
-    mutex(const mutex&) = delete;
-    mutex& operator=(const mutex&) = delete;
-    ~mutex() noexcept;
-};
-
-
-mutex::~mutex() noexcept
-{
-    __libcpp_mutex_destroy(&__m_);
-}
-
-#endif // !_LIBCPP_HAS_NO_THREADS
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/new.cpp b/third_party/libcxx/src/new.cpp
deleted file mode 100644
index 998eb4456..000000000
--- a/third_party/libcxx/src/new.cpp
+++ /dev/null
@@ -1,294 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__memory/aligned_alloc.h>
-#include <new>
-#include <stdlib.h>
-
-#include "third_party/libcxx/src/include/atomic_support.h"
-
-#if defined(_LIBCPP_ABI_MICROSOFT)
-#   if !defined(_LIBCPP_ABI_VCRUNTIME)
-#       include "third_party/libcxx/src/support/runtime/new_handler_fallback.ipp"
-#   endif
-#elif defined(LIBCXX_BUILDING_LIBCXXABI)
-#   include <cxxabi.h>
-#elif defined(LIBCXXRT)
-#   include <cxxabi.h>
-#   include "third_party/libcxx/src/support/runtime/new_handler_fallback.ipp"
-#elif defined(__GLIBCXX__)
-    // nothing to do
-#else
-#   include "third_party/libcxx/src/support/runtime/new_handler_fallback.ipp"
-#endif
-
-namespace std
-{
-
-#ifndef __GLIBCXX__
-const nothrow_t nothrow{};
-#endif
-
-#ifndef LIBSTDCXX
-
-void
-__throw_bad_alloc()
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw bad_alloc();
-#else
-    _VSTD::abort();
-#endif
-}
-
-#endif // !LIBSTDCXX
-
-}  // std
-
-#if !defined(__GLIBCXX__) &&                                                   \
-    !defined(_LIBCPP_ABI_VCRUNTIME) &&      \
-    !defined(_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS)
-
-// Implement all new and delete operators as weak definitions
-// in this shared library, so that they can be overridden by programs
-// that define non-weak copies of the functions.
-
-_LIBCPP_WEAK
-void *
-operator new(std::size_t size) _THROW_BAD_ALLOC
-{
-    if (size == 0)
-        size = 1;
-    void* p;
-    while ((p = ::malloc(size)) == nullptr)
-    {
-        // If malloc fails and there is a new_handler,
-        // call it to try free up memory.
-        std::new_handler nh = std::get_new_handler();
-        if (nh)
-            nh();
-        else
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            throw std::bad_alloc();
-#else
-            break;
-#endif
-    }
-    return p;
-}
-
-_LIBCPP_WEAK
-void*
-operator new(size_t size, const std::nothrow_t&) noexcept
-{
-    void* p = nullptr;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        p = ::operator new(size);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return p;
-}
-
-_LIBCPP_WEAK
-void*
-operator new[](size_t size) _THROW_BAD_ALLOC
-{
-    return ::operator new(size);
-}
-
-_LIBCPP_WEAK
-void*
-operator new[](size_t size, const std::nothrow_t&) noexcept
-{
-    void* p = nullptr;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        p = ::operator new[](size);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return p;
-}
-
-_LIBCPP_WEAK
-void
-operator delete(void* ptr) noexcept
-{
-    ::free(ptr);
-}
-
-_LIBCPP_WEAK
-void
-operator delete(void* ptr, const std::nothrow_t&) noexcept
-{
-    ::operator delete(ptr);
-}
-
-_LIBCPP_WEAK
-void
-operator delete(void* ptr, size_t) noexcept
-{
-    ::operator delete(ptr);
-}
-
-_LIBCPP_WEAK
-void
-operator delete[] (void* ptr) noexcept
-{
-    ::operator delete(ptr);
-}
-
-_LIBCPP_WEAK
-void
-operator delete[] (void* ptr, const std::nothrow_t&) noexcept
-{
-    ::operator delete[](ptr);
-}
-
-_LIBCPP_WEAK
-void
-operator delete[] (void* ptr, size_t) noexcept
-{
-    ::operator delete[](ptr);
-}
-
-#if !defined(_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION)
-
-_LIBCPP_WEAK
-void *
-operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
-{
-    if (size == 0)
-        size = 1;
-    if (static_cast<size_t>(alignment) < sizeof(void*))
-      alignment = std::align_val_t(sizeof(void*));
-
-    // Try allocating memory. If allocation fails and there is a new_handler,
-    // call it to try free up memory, and try again until it succeeds, or until
-    // the new_handler decides to terminate.
-    //
-    // If allocation fails and there is no new_handler, we throw bad_alloc
-    // (or return nullptr if exceptions are disabled).
-    void* p;
-    while ((p = std::__libcpp_aligned_alloc(static_cast<std::size_t>(alignment), size)) == nullptr)
-    {
-        std::new_handler nh = std::get_new_handler();
-        if (nh)
-            nh();
-        else {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            throw std::bad_alloc();
-#else
-            break;
-#endif
-        }
-    }
-    return p;
-}
-
-_LIBCPP_WEAK
-void*
-operator new(size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
-{
-    void* p = nullptr;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        p = ::operator new(size, alignment);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return p;
-}
-
-_LIBCPP_WEAK
-void*
-operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC
-{
-    return ::operator new(size, alignment);
-}
-
-_LIBCPP_WEAK
-void*
-operator new[](size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept
-{
-    void* p = nullptr;
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        p = ::operator new[](size, alignment);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    return p;
-}
-
-_LIBCPP_WEAK
-void
-operator delete(void* ptr, std::align_val_t) noexcept
-{
-    std::__libcpp_aligned_free(ptr);
-}
-
-_LIBCPP_WEAK
-void
-operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
-{
-    ::operator delete(ptr, alignment);
-}
-
-_LIBCPP_WEAK
-void
-operator delete(void* ptr, size_t, std::align_val_t alignment) noexcept
-{
-    ::operator delete(ptr, alignment);
-}
-
-_LIBCPP_WEAK
-void
-operator delete[] (void* ptr, std::align_val_t alignment) noexcept
-{
-    ::operator delete(ptr, alignment);
-}
-
-_LIBCPP_WEAK
-void
-operator delete[] (void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept
-{
-    ::operator delete[](ptr, alignment);
-}
-
-_LIBCPP_WEAK
-void
-operator delete[] (void* ptr, size_t, std::align_val_t alignment) noexcept
-{
-    ::operator delete[](ptr, alignment);
-}
-
-#endif // !_LIBCPP_HAS_NO_LIBRARY_ALIGNED_ALLOCATION
-#endif // !__GLIBCXX__ && !_LIBCPP_ABI_VCRUNTIME && !_LIBCPP_DISABLE_NEW_DELETE_DEFINITIONS
diff --git a/third_party/libcxx/src/random.cpp b/third_party/libcxx/src/random.cpp
deleted file mode 100644
index dfac89f75..000000000
--- a/third_party/libcxx/src/random.cpp
+++ /dev/null
@@ -1,216 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-
-#if defined(_LIBCPP_USING_WIN32_RANDOM)
-    // Must be defined before including stdlib.h to enable rand_s().
-#   define _CRT_RAND_S
-#endif // defined(_LIBCPP_USING_WIN32_RANDOM)
-
-#include <__system_error/system_error.h>
-#include <limits>
-#include <random>
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#if defined(_LIBCPP_USING_GETENTROPY)
-#   include <sys/random.h>
-#elif defined(_LIBCPP_USING_DEV_RANDOM)
-#   include <fcntl.h>
-#   include <unistd.h>
-#   if __has_include(<sys/ioctl.h>) && __has_include(<linux/random.h>)
-#       include <sys/ioctl.h>
-#       include <linux/random.h>
-#   endif
-#elif defined(_LIBCPP_USING_NACL_RANDOM)
-#   include <nacl/nacl_random.h>
-#elif defined(_LIBCPP_USING_FUCHSIA_CPRNG)
-#  include <zircon/syscalls.h>
-#endif
-
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#if defined(_LIBCPP_USING_GETENTROPY)
-
-random_device::random_device(const string& __token)
-{
-    if (__token != "/dev/urandom")
-        __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
-}
-
-random_device::~random_device()
-{
-}
-
-unsigned
-random_device::operator()()
-{
-    unsigned r;
-    size_t n = sizeof(r);
-    int err = getentropy(&r, n);
-    if (err)
-        __throw_system_error(errno, "random_device getentropy failed");
-    return r;
-}
-
-#elif defined(_LIBCPP_USING_ARC4_RANDOM)
-
-random_device::random_device(const string&)
-{
-}
-
-random_device::~random_device()
-{
-}
-
-unsigned
-random_device::operator()()
-{
-    return arc4random();
-}
-
-#elif defined(_LIBCPP_USING_DEV_RANDOM)
-
-random_device::random_device(const string& __token)
-    : __f_(open(__token.c_str(), O_RDONLY))
-{
-    if (__f_ < 0)
-        __throw_system_error(errno, ("random_device failed to open " + __token).c_str());
-}
-
-random_device::~random_device()
-{
-    close(__f_);
-}
-
-unsigned
-random_device::operator()()
-{
-    unsigned r;
-    size_t n = sizeof(r);
-    char* p = reinterpret_cast<char*>(&r);
-    while (n > 0)
-    {
-        ssize_t s = read(__f_, p, n);
-        if (s == 0)
-            __throw_system_error(ENODATA, "random_device got EOF");
-        if (s == -1)
-        {
-            if (errno != EINTR)
-                __throw_system_error(errno, "random_device got an unexpected error");
-            continue;
-        }
-        n -= static_cast<size_t>(s);
-        p += static_cast<size_t>(s);
-    }
-    return r;
-}
-
-#elif defined(_LIBCPP_USING_NACL_RANDOM)
-
-random_device::random_device(const string& __token)
-{
-    if (__token != "/dev/urandom")
-        __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
-    int error = nacl_secure_random_init();
-    if (error)
-        __throw_system_error(error, ("random device failed to open " + __token).c_str());
-}
-
-random_device::~random_device()
-{
-}
-
-unsigned
-random_device::operator()()
-{
-    unsigned r;
-    size_t n = sizeof(r);
-    size_t bytes_written;
-    int error = nacl_secure_random(&r, n, &bytes_written);
-    if (error != 0)
-        __throw_system_error(error, "random_device failed getting bytes");
-    else if (bytes_written != n)
-        __throw_runtime_error("random_device failed to obtain enough bytes");
-    return r;
-}
-
-#elif defined(_LIBCPP_USING_WIN32_RANDOM)
-
-random_device::random_device(const string& __token)
-{
-    if (__token != "/dev/urandom")
-        __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
-}
-
-random_device::~random_device()
-{
-}
-
-unsigned
-random_device::operator()()
-{
-    unsigned r;
-    errno_t err = rand_s(&r);
-    if (err)
-        __throw_system_error(err, "random_device rand_s failed.");
-    return r;
-}
-
-#elif defined(_LIBCPP_USING_FUCHSIA_CPRNG)
-
-random_device::random_device(const string& __token) {
-  if (__token != "/dev/urandom")
-    __throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
-}
-
-random_device::~random_device() {}
-
-unsigned random_device::operator()() {
-  // Implicitly link against the vDSO system call ABI without
-  // requiring the final link to specify -lzircon explicitly when
-  // statically linking libc++.
-#  pragma comment(lib, "zircon")
-
-  // The system call cannot fail.  It returns only when the bits are ready.
-  unsigned r;
-  _zx_cprng_draw(&r, sizeof(r));
-  return r;
-}
-
-#else
-#error "Random device not implemented for this architecture"
-#endif
-
-double
-random_device::entropy() const noexcept
-{
-#if defined(_LIBCPP_USING_DEV_RANDOM) && defined(RNDGETENTCNT)
-  int ent;
-  if (::ioctl(__f_, RNDGETENTCNT, &ent) < 0)
-    return 0;
-
-  if (ent < 0)
-    return 0;
-
-  if (ent > std::numeric_limits<result_type>::digits)
-    return std::numeric_limits<result_type>::digits;
-
-  return ent;
-#elif defined(_LIBCPP_USING_ARC4_RANDOM) || defined(_LIBCPP_USING_FUCHSIA_CPRNG)
-  return std::numeric_limits<result_type>::digits;
-#else
-  return 0;
-#endif
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/regex.cpp b/third_party/libcxx/src/regex.cpp
deleted file mode 100644
index e53d32418..000000000
--- a/third_party/libcxx/src/regex.cpp
+++ /dev/null
@@ -1,436 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <algorithm>
-#include <iterator>
-#include <regex>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-static
-const char*
-make_error_type_string(regex_constants::error_type ecode)
-{
-    switch (ecode)
-    {
-    case regex_constants::error_collate:
-        return "The expression contained an invalid collating element name.";
-    case regex_constants::error_ctype:
-        return "The expression contained an invalid character class name.";
-    case regex_constants::error_escape:
-        return "The expression contained an invalid escaped character, or a "
-               "trailing escape.";
-    case regex_constants::error_backref:
-        return "The expression contained an invalid back reference.";
-    case regex_constants::error_brack:
-        return "The expression contained mismatched [ and ].";
-    case regex_constants::error_paren:
-        return "The expression contained mismatched ( and ).";
-    case regex_constants::error_brace:
-        return "The expression contained mismatched { and }.";
-    case regex_constants::error_badbrace:
-        return "The expression contained an invalid range in a {} expression.";
-    case regex_constants::error_range:
-        return "The expression contained an invalid character range, "
-               "such as [b-a] in most encodings.";
-    case regex_constants::error_space:
-        return "There was insufficient memory to convert the expression into "
-               "a finite state machine.";
-    case regex_constants::error_badrepeat:
-        return "One of *?+{ was not preceded by a valid regular expression.";
-    case regex_constants::error_complexity:
-        return "The complexity of an attempted match against a regular "
-               "expression exceeded a pre-set level.";
-    case regex_constants::error_stack:
-        return "There was insufficient memory to determine whether the regular "
-               "expression could match the specified character sequence.";
-    case regex_constants::__re_err_grammar:
-        return "An invalid regex grammar has been requested.";
-    case regex_constants::__re_err_empty:
-        return "An empty regex is not allowed in the POSIX grammar.";
-    case regex_constants::__re_err_parse:
-        return "The parser did not consume the entire regular expression.";
-    default:
-        break;
-    }
-    return "Unknown error type";
-}
-
-regex_error::regex_error(regex_constants::error_type ecode)
-    : runtime_error(make_error_type_string(ecode)),
-      __code_(ecode)
-{}
-
-regex_error::~regex_error() throw() {}
-
-namespace {
-
-struct collationnames
-{
-    const char* elem_;
-    char char_;
-};
-
-#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
-// EBCDIC IBM-1047
-// Sorted via the EBCDIC collating sequence
-const collationnames collatenames[] =
-{
-    {"a", 0x81},
-    {"alert", 0x2f},
-    {"ampersand", 0x50},
-    {"apostrophe", 0x7d},
-    {"asterisk", 0x5c},
-    {"b", 0x82},
-    {"backslash", 0xe0},
-    {"backspace", 0x16},
-    {"c", 0x83},
-    {"carriage-return", 0xd},
-    {"circumflex", 0x5f},
-    {"circumflex-accent", 0x5f},
-    {"colon", 0x7a},
-    {"comma", 0x6b},
-    {"commercial-at", 0x7c},
-    {"d", 0x84},
-    {"dollar-sign", 0x5b},
-    {"e", 0x85},
-    {"eight", 0xf8},
-    {"equals-sign", 0x7e},
-    {"exclamation-mark", 0x5a},
-    {"f", 0x86},
-    {"five", 0xf5},
-    {"form-feed", 0xc},
-    {"four", 0xf4},
-    {"full-stop", 0x4b},
-    {"g", 0x87},
-    {"grave-accent", 0x79},
-    {"greater-than-sign", 0x6e},
-    {"h", 0x88},
-    {"hyphen", 0x60},
-    {"hyphen-minus", 0x60},
-    {"i", 0x89},
-    {"j", 0x91},
-    {"k", 0x92},
-    {"l", 0x93},
-    {"left-brace", 0xc0},
-    {"left-curly-bracket", 0xc0},
-    {"left-parenthesis", 0x4d},
-    {"left-square-bracket", 0xad},
-    {"less-than-sign", 0x4c},
-    {"low-line", 0x6d},
-    {"m", 0x94},
-    {"n", 0x95},
-    {"newline", 0x15},
-    {"nine", 0xf9},
-    {"number-sign", 0x7b},
-    {"o", 0x96},
-    {"one", 0xf1},
-    {"p", 0x97},
-    {"percent-sign", 0x6c},
-    {"period", 0x4b},
-    {"plus-sign", 0x4e},
-    {"q", 0x98},
-    {"question-mark", 0x6f},
-    {"quotation-mark", 0x7f},
-    {"r", 0x99},
-    {"reverse-solidus", 0xe0},
-    {"right-brace", 0xd0},
-    {"right-curly-bracket", 0xd0},
-    {"right-parenthesis", 0x5d},
-    {"right-square-bracket", 0xbd},
-    {"s", 0xa2},
-    {"semicolon", 0x5e},
-    {"seven", 0xf7},
-    {"six", 0xf6},
-    {"slash", 0x61},
-    {"solidus", 0x61},
-    {"space", 0x40},
-    {"t", 0xa3},
-    {"tab", 0x5},
-    {"three", 0xf3},
-    {"tilde", 0xa1},
-    {"two", 0xf2},
-    {"u", 0xa4},
-    {"underscore", 0x6d},
-    {"v", 0xa5},
-    {"vertical-line", 0x4f},
-    {"vertical-tab", 0xb},
-    {"w", 0xa6},
-    {"x", 0xa7},
-    {"y", 0xa8},
-    {"z", 0xa9},
-    {"zero", 0xf0},
-    {"A", 0xc1},
-    {"B", 0xc2},
-    {"C", 0xc3},
-    {"D", 0xc4},
-    {"E", 0xc5},
-    {"F", 0xc6},
-    {"G", 0xc7},
-    {"H", 0xc8},
-    {"I", 0xc9},
-    {"J", 0xd1},
-    {"K", 0xd2},
-    {"L", 0xd3},
-    {"M", 0xd4},
-    {"N", 0xd5},
-    {"NUL", 0},
-    {"O", 0xd6},
-    {"P", 0xd7},
-    {"Q", 0xd8},
-    {"R", 0xd9},
-    {"S", 0xe2},
-    {"T", 0xe3},
-    {"U", 0xe4},
-    {"V", 0xe5},
-    {"W", 0xe6},
-    {"X", 0xe7},
-    {"Y", 0xe8},
-    {"Z", 0xe9}
-};
-#else
-// ASCII
-const collationnames collatenames[] =
-{
-    {"A", 0x41},
-    {"B", 0x42},
-    {"C", 0x43},
-    {"D", 0x44},
-    {"E", 0x45},
-    {"F", 0x46},
-    {"G", 0x47},
-    {"H", 0x48},
-    {"I", 0x49},
-    {"J", 0x4a},
-    {"K", 0x4b},
-    {"L", 0x4c},
-    {"M", 0x4d},
-    {"N", 0x4e},
-    {"NUL", 0x00},
-    {"O", 0x4f},
-    {"P", 0x50},
-    {"Q", 0x51},
-    {"R", 0x52},
-    {"S", 0x53},
-    {"T", 0x54},
-    {"U", 0x55},
-    {"V", 0x56},
-    {"W", 0x57},
-    {"X", 0x58},
-    {"Y", 0x59},
-    {"Z", 0x5a},
-    {"a", 0x61},
-    {"alert", 0x07},
-    {"ampersand", 0x26},
-    {"apostrophe", 0x27},
-    {"asterisk", 0x2a},
-    {"b", 0x62},
-    {"backslash", 0x5c},
-    {"backspace", 0x08},
-    {"c", 0x63},
-    {"carriage-return", 0x0d},
-    {"circumflex", 0x5e},
-    {"circumflex-accent", 0x5e},
-    {"colon", 0x3a},
-    {"comma", 0x2c},
-    {"commercial-at", 0x40},
-    {"d", 0x64},
-    {"dollar-sign", 0x24},
-    {"e", 0x65},
-    {"eight", 0x38},
-    {"equals-sign", 0x3d},
-    {"exclamation-mark", 0x21},
-    {"f", 0x66},
-    {"five", 0x35},
-    {"form-feed", 0x0c},
-    {"four", 0x34},
-    {"full-stop", 0x2e},
-    {"g", 0x67},
-    {"grave-accent", 0x60},
-    {"greater-than-sign", 0x3e},
-    {"h", 0x68},
-    {"hyphen", 0x2d},
-    {"hyphen-minus", 0x2d},
-    {"i", 0x69},
-    {"j", 0x6a},
-    {"k", 0x6b},
-    {"l", 0x6c},
-    {"left-brace", 0x7b},
-    {"left-curly-bracket", 0x7b},
-    {"left-parenthesis", 0x28},
-    {"left-square-bracket", 0x5b},
-    {"less-than-sign", 0x3c},
-    {"low-line", 0x5f},
-    {"m", 0x6d},
-    {"n", 0x6e},
-    {"newline", 0x0a},
-    {"nine", 0x39},
-    {"number-sign", 0x23},
-    {"o", 0x6f},
-    {"one", 0x31},
-    {"p", 0x70},
-    {"percent-sign", 0x25},
-    {"period", 0x2e},
-    {"plus-sign", 0x2b},
-    {"q", 0x71},
-    {"question-mark", 0x3f},
-    {"quotation-mark", 0x22},
-    {"r", 0x72},
-    {"reverse-solidus", 0x5c},
-    {"right-brace", 0x7d},
-    {"right-curly-bracket", 0x7d},
-    {"right-parenthesis", 0x29},
-    {"right-square-bracket", 0x5d},
-    {"s", 0x73},
-    {"semicolon", 0x3b},
-    {"seven", 0x37},
-    {"six", 0x36},
-    {"slash", 0x2f},
-    {"solidus", 0x2f},
-    {"space", 0x20},
-    {"t", 0x74},
-    {"tab", 0x09},
-    {"three", 0x33},
-    {"tilde", 0x7e},
-    {"two", 0x32},
-    {"u", 0x75},
-    {"underscore", 0x5f},
-    {"v", 0x76},
-    {"vertical-line", 0x7c},
-    {"vertical-tab", 0x0b},
-    {"w", 0x77},
-    {"x", 0x78},
-    {"y", 0x79},
-    {"z", 0x7a},
-    {"zero", 0x30}
-};
-#endif
-
-struct classnames
-{
-    const char* elem_;
-    regex_traits<char>::char_class_type mask_;
-};
-
-const classnames ClassNames[] =
-{
-    {"alnum",  ctype_base::alnum},
-    {"alpha",  ctype_base::alpha},
-    {"blank",  ctype_base::blank},
-    {"cntrl",  ctype_base::cntrl},
-    {"d",      ctype_base::digit},
-    {"digit",  ctype_base::digit},
-    {"graph",  ctype_base::graph},
-    {"lower",  ctype_base::lower},
-    {"print",  ctype_base::print},
-    {"punct",  ctype_base::punct},
-    {"s",      ctype_base::space},
-    {"space",  ctype_base::space},
-    {"upper",  ctype_base::upper},
-    {"w",      regex_traits<char>::__regex_word},
-    {"xdigit", ctype_base::xdigit}
-};
-
-struct use_strcmp
-{
-    bool operator()(const collationnames& x, const char* y)
-        {return strcmp(x.elem_, y) < 0;}
-    bool operator()(const classnames& x, const char* y)
-        {return strcmp(x.elem_, y) < 0;}
-};
-
-}
-
-string
-__get_collation_name(const char* s)
-{
-    const collationnames* i =
-            _VSTD::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
-    string r;
-    if (i != end(collatenames) && strcmp(s, i->elem_) == 0)
-        r = char(i->char_);
-    return r;
-}
-
-regex_traits<char>::char_class_type
-__get_classname(const char* s, bool __icase)
-{
-    const classnames* i =
-            _VSTD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
-    regex_traits<char>::char_class_type r = 0;
-    if (i != end(ClassNames) && strcmp(s, i->elem_) == 0)
-    {
-        r = i->mask_;
-        if (r == regex_traits<char>::__regex_word)
-            r |= ctype_base::alnum | ctype_base::upper | ctype_base::lower;
-        else if (__icase)
-        {
-            if (r & (ctype_base::lower | ctype_base::upper))
-                r |= ctype_base::alpha;
-        }
-    }
-    return r;
-}
-
-template <>
-void
-__match_any_but_newline<char>::__exec(__state& __s) const
-{
-    if (__s.__current_ != __s.__last_)
-    {
-        switch (*__s.__current_)
-        {
-        case '\r':
-        case '\n':
-            __s.__do_ = __state::__reject;
-            __s.__node_ = nullptr;
-            break;
-        default:
-            __s.__do_ = __state::__accept_and_consume;
-            ++__s.__current_;
-            __s.__node_ = this->first();
-            break;
-        }
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
-}
-
-template <>
-void
-__match_any_but_newline<wchar_t>::__exec(__state& __s) const
-{
-    if (__s.__current_ != __s.__last_)
-    {
-        switch (*__s.__current_)
-        {
-        case '\r':
-        case '\n':
-        case 0x2028:
-        case 0x2029:
-            __s.__do_ = __state::__reject;
-            __s.__node_ = nullptr;
-            break;
-        default:
-            __s.__do_ = __state::__accept_and_consume;
-            ++__s.__current_;
-            __s.__node_ = this->first();
-            break;
-        }
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/ryu/README.txt b/third_party/libcxx/src/ryu/README.txt
deleted file mode 100644
index e3d17469d..000000000
--- a/third_party/libcxx/src/ryu/README.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-The code in this directory is based on Ulf Adams's work. The upstream for the
-code is:
-
-https://github.com/ulfjack/ryu/tree/59661c3/ryu
-
-The code has been adapted by Stephan T. Lavavej of Microsoft for usage in
-std::to_chars. This code has been contributed by Microsoft for inclusion in
-libc++.
-
-The code in this directory has a different coding style than other parts to
-minimize the number of changes by both upstream sources.
diff --git a/third_party/libcxx/src/shared_mutex.cpp b/third_party/libcxx/src/shared_mutex.cpp
deleted file mode 100644
index b1976c11d..000000000
--- a/third_party/libcxx/src/shared_mutex.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-
-#include <mutex>
-#include <shared_mutex>
-#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#  pragma comment(lib, "pthread")
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// Shared Mutex Base
-__shared_mutex_base::__shared_mutex_base()
-    : __state_(0)
-{
-}
-
-// Exclusive ownership
-
-void
-__shared_mutex_base::lock()
-{
-    unique_lock<mutex> lk(__mut_);
-    while (__state_ & __write_entered_)
-        __gate1_.wait(lk);
-    __state_ |= __write_entered_;
-    while (__state_ & __n_readers_)
-        __gate2_.wait(lk);
-}
-
-bool
-__shared_mutex_base::try_lock()
-{
-    unique_lock<mutex> lk(__mut_);
-    if (__state_ == 0)
-    {
-        __state_ = __write_entered_;
-        return true;
-    }
-    return false;
-}
-
-void
-__shared_mutex_base::unlock()
-{
-    lock_guard<mutex> _(__mut_);
-    __state_ = 0;
-    __gate1_.notify_all();
-}
-
-// Shared ownership
-
-void
-__shared_mutex_base::lock_shared()
-{
-    unique_lock<mutex> lk(__mut_);
-    while ((__state_ & __write_entered_) || (__state_ & __n_readers_) == __n_readers_)
-        __gate1_.wait(lk);
-    unsigned num_readers = (__state_ & __n_readers_) + 1;
-    __state_ &= ~__n_readers_;
-    __state_ |= num_readers;
-}
-
-bool
-__shared_mutex_base::try_lock_shared()
-{
-    unique_lock<mutex> lk(__mut_);
-    unsigned num_readers = __state_ & __n_readers_;
-    if (!(__state_ & __write_entered_) && num_readers != __n_readers_)
-    {
-        ++num_readers;
-        __state_ &= ~__n_readers_;
-        __state_ |= num_readers;
-        return true;
-    }
-    return false;
-}
-
-void
-__shared_mutex_base::unlock_shared()
-{
-    lock_guard<mutex> _(__mut_);
-    unsigned num_readers = (__state_ & __n_readers_) - 1;
-    __state_ &= ~__n_readers_;
-    __state_ |= num_readers;
-    if (__state_ & __write_entered_)
-    {
-        if (num_readers == 0)
-            __gate2_.notify_one();
-    }
-    else
-    {
-        if (num_readers == __n_readers_ - 1)
-            __gate1_.notify_one();
-    }
-}
-
-
-// Shared Timed Mutex
-// These routines are here for ABI stability
-shared_timed_mutex::shared_timed_mutex() : __base_() {}
-void shared_timed_mutex::lock()     { return __base_.lock(); }
-bool shared_timed_mutex::try_lock() { return __base_.try_lock(); }
-void shared_timed_mutex::unlock()   { return __base_.unlock(); }
-void shared_timed_mutex::lock_shared() { return __base_.lock_shared(); }
-bool shared_timed_mutex::try_lock_shared() { return __base_.try_lock_shared(); }
-void shared_timed_mutex::unlock_shared() { return __base_.unlock_shared(); }
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !_LIBCPP_HAS_NO_THREADS
diff --git a/third_party/libcxx/src/std_stream.h b/third_party/libcxx/src/std_stream.h
deleted file mode 100644
index 9c15d7d40..000000000
--- a/third_party/libcxx/src/std_stream.h
+++ /dev/null
@@ -1,361 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_STD_STREAM_H
-#define _LIBCPP_STD_STREAM_H
-
-#include <__config>
-#include <__locale>
-#include <cstdio>
-#include <istream>
-#include <ostream>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-static const int __limit = 8;
-
-// __stdinbuf
-
-template <class _CharT>
-class _LIBCPP_HIDDEN __stdinbuf
-    : public basic_streambuf<_CharT, char_traits<_CharT> >
-{
-public:
-    typedef _CharT                           char_type;
-    typedef char_traits<char_type>           traits_type;
-    typedef typename traits_type::int_type   int_type;
-    typedef typename traits_type::pos_type   pos_type;
-    typedef typename traits_type::off_type   off_type;
-    typedef typename traits_type::state_type state_type;
-
-    __stdinbuf(FILE* __fp, state_type* __st);
-
-protected:
-    virtual int_type underflow();
-    virtual int_type uflow();
-    virtual int_type pbackfail(int_type __c = traits_type::eof());
-    virtual void imbue(const locale& __loc);
-
-private:
-
-    FILE* __file_;
-    const codecvt<char_type, char, state_type>* __cv_;
-    state_type* __st_;
-    int __encoding_;
-    int_type __last_consumed_;
-    bool __last_consumed_is_next_;
-    bool __always_noconv_;
-
-    __stdinbuf(const __stdinbuf&);
-    __stdinbuf& operator=(const __stdinbuf&);
-
-    int_type __getchar(bool __consume);
-};
-
-template <class _CharT>
-__stdinbuf<_CharT>::__stdinbuf(FILE* __fp, state_type* __st)
-    : __file_(__fp),
-      __st_(__st),
-      __last_consumed_(traits_type::eof()),
-      __last_consumed_is_next_(false)
-{
-    imbue(this->getloc());
-}
-
-template <class _CharT>
-void
-__stdinbuf<_CharT>::imbue(const locale& __loc)
-{
-    __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
-    __encoding_ = __cv_->encoding();
-    __always_noconv_ = __cv_->always_noconv();
-    if (__encoding_ > __limit)
-        __throw_runtime_error("unsupported locale for standard input");
-}
-
-template <class _CharT>
-typename __stdinbuf<_CharT>::int_type
-__stdinbuf<_CharT>::underflow()
-{
-    return __getchar(false);
-}
-
-template <class _CharT>
-typename __stdinbuf<_CharT>::int_type
-__stdinbuf<_CharT>::uflow()
-{
-    return __getchar(true);
-}
-
-template <class _CharT>
-typename __stdinbuf<_CharT>::int_type
-__stdinbuf<_CharT>::__getchar(bool __consume)
-{
-    if (__last_consumed_is_next_)
-    {
-        int_type __result = __last_consumed_;
-        if (__consume)
-        {
-            __last_consumed_ = traits_type::eof();
-            __last_consumed_is_next_ = false;
-        }
-        return __result;
-    }
-    char __extbuf[__limit];
-    int __nread = _VSTD::max(1, __encoding_);
-    for (int __i = 0; __i < __nread; ++__i)
-    {
-        int __c = getc(__file_);
-        if (__c == EOF)
-            return traits_type::eof();
-        __extbuf[__i] = static_cast<char>(__c);
-    }
-    char_type __1buf;
-    if (__always_noconv_)
-        __1buf = static_cast<char_type>(__extbuf[0]);
-    else
-    {
-        const char* __enxt;
-        char_type* __inxt;
-        codecvt_base::result __r;
-        do
-        {
-            state_type __sv_st = *__st_;
-            __r = __cv_->in(*__st_, __extbuf, __extbuf + __nread, __enxt,
-                                   &__1buf, &__1buf + 1, __inxt);
-            switch (__r)
-            {
-            case _VSTD::codecvt_base::ok:
-                break;
-            case codecvt_base::partial:
-                *__st_ = __sv_st;
-                if (__nread == sizeof(__extbuf))
-                    return traits_type::eof();
-                {
-                    int __c = getc(__file_);
-                    if (__c == EOF)
-                        return traits_type::eof();
-                    __extbuf[__nread] = static_cast<char>(__c);
-                }
-                ++__nread;
-                break;
-            case codecvt_base::error:
-                return traits_type::eof();
-            case _VSTD::codecvt_base::noconv:
-                __1buf = static_cast<char_type>(__extbuf[0]);
-                break;
-            }
-        } while (__r == _VSTD::codecvt_base::partial);
-    }
-    if (!__consume)
-    {
-        for (int __i = __nread; __i > 0;)
-        {
-            if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF)
-                return traits_type::eof();
-        }
-    }
-    else
-        __last_consumed_ = traits_type::to_int_type(__1buf);
-    return traits_type::to_int_type(__1buf);
-}
-
-template <class _CharT>
-typename __stdinbuf<_CharT>::int_type
-__stdinbuf<_CharT>::pbackfail(int_type __c)
-{
-    if (traits_type::eq_int_type(__c, traits_type::eof()))
-    {
-        if (!__last_consumed_is_next_)
-        {
-            __c = __last_consumed_;
-            __last_consumed_is_next_ = !traits_type::eq_int_type(__last_consumed_,
-                                                                 traits_type::eof());
-        }
-        return __c;
-    }
-    if (__last_consumed_is_next_)
-    {
-        char __extbuf[__limit];
-        char* __enxt;
-        const char_type __ci = traits_type::to_char_type(__last_consumed_);
-        const char_type* __inxt;
-        switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt,
-                                  __extbuf, __extbuf + sizeof(__extbuf), __enxt))
-        {
-        case _VSTD::codecvt_base::ok:
-            break;
-        case _VSTD::codecvt_base::noconv:
-            __extbuf[0] = static_cast<char>(__last_consumed_);
-            __enxt = __extbuf + 1;
-            break;
-        case codecvt_base::partial:
-        case codecvt_base::error:
-            return traits_type::eof();
-        }
-        while (__enxt > __extbuf)
-            if (ungetc(*--__enxt, __file_) == EOF)
-                return traits_type::eof();
-    }
-    __last_consumed_ = __c;
-    __last_consumed_is_next_ = true;
-    return __c;
-}
-
-// __stdoutbuf
-
-template <class _CharT>
-class _LIBCPP_HIDDEN __stdoutbuf
-    : public basic_streambuf<_CharT, char_traits<_CharT> >
-{
-public:
-    typedef _CharT                           char_type;
-    typedef char_traits<char_type>           traits_type;
-    typedef typename traits_type::int_type   int_type;
-    typedef typename traits_type::pos_type   pos_type;
-    typedef typename traits_type::off_type   off_type;
-    typedef typename traits_type::state_type state_type;
-
-    __stdoutbuf(FILE* __fp, state_type* __st);
-
-protected:
-    virtual int_type overflow (int_type __c = traits_type::eof());
-    virtual streamsize xsputn(const char_type* __s, streamsize __n);
-    virtual int sync();
-    virtual void imbue(const locale& __loc);
-
-private:
-    FILE* __file_;
-    const codecvt<char_type, char, state_type>* __cv_;
-    state_type* __st_;
-    bool __always_noconv_;
-
-    __stdoutbuf(const __stdoutbuf&);
-    __stdoutbuf& operator=(const __stdoutbuf&);
-};
-
-template <class _CharT>
-__stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st)
-    : __file_(__fp),
-      __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),
-      __st_(__st),
-      __always_noconv_(__cv_->always_noconv())
-{
-}
-
-template <class _CharT>
-typename __stdoutbuf<_CharT>::int_type
-__stdoutbuf<_CharT>::overflow(int_type __c)
-{
-    char __extbuf[__limit];
-    char_type __1buf;
-    if (!traits_type::eq_int_type(__c, traits_type::eof()))
-    {
-        __1buf = traits_type::to_char_type(__c);
-        if (__always_noconv_)
-        {
-            if (fwrite(&__1buf, sizeof(char_type), 1, __file_) != 1)
-                return traits_type::eof();
-        }
-        else
-        {
-            char* __extbe = __extbuf;
-            codecvt_base::result __r;
-            char_type* pbase = &__1buf;
-            char_type* pptr = pbase + 1;
-            do
-            {
-                const char_type* __e;
-                __r = __cv_->out(*__st_, pbase, pptr, __e,
-                                        __extbuf,
-                                        __extbuf + sizeof(__extbuf),
-                                        __extbe);
-                if (__e == pbase)
-                    return traits_type::eof();
-                if (__r == codecvt_base::noconv)
-                {
-                    if (fwrite(pbase, 1, 1, __file_) != 1)
-                        return traits_type::eof();
-                }
-                else if (__r == codecvt_base::ok || __r == codecvt_base::partial)
-                {
-                    size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
-                    if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
-                        return traits_type::eof();
-                    if (__r == codecvt_base::partial)
-                    {
-                        pbase = const_cast<char_type*>(__e);
-                    }
-                }
-                else
-                    return traits_type::eof();
-            } while (__r == codecvt_base::partial);
-        }
-    }
-    return traits_type::not_eof(__c);
-}
-
-template <class _CharT>
-streamsize
-__stdoutbuf<_CharT>::xsputn(const char_type* __s, streamsize __n)
-{
-    if (__always_noconv_)
-        return fwrite(__s, sizeof(char_type), __n, __file_);
-    streamsize __i = 0;
-    for (; __i < __n; ++__i, ++__s)
-        if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof())
-            break;
-    return __i;
-}
-
-template <class _CharT>
-int
-__stdoutbuf<_CharT>::sync()
-{
-    char __extbuf[__limit];
-    codecvt_base::result __r;
-    do
-    {
-        char* __extbe;
-        __r = __cv_->unshift(*__st_, __extbuf,
-                                    __extbuf + sizeof(__extbuf),
-                                    __extbe);
-        size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
-        if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
-            return -1;
-    } while (__r == codecvt_base::partial);
-    if (__r == codecvt_base::error)
-        return -1;
-    if (fflush(__file_))
-        return -1;
-    return 0;
-}
-
-template <class _CharT>
-void
-__stdoutbuf<_CharT>::imbue(const locale& __loc)
-{
-    sync();
-    __cv_ = &use_facet<codecvt<char_type, char, state_type> >(__loc);
-    __always_noconv_ = __cv_->always_noconv();
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
-#endif // _LIBCPP_STD_STREAM_H
diff --git a/third_party/libcxx/src/stdexcept.cpp b/third_party/libcxx/src/stdexcept.cpp
deleted file mode 100644
index 10231b979..000000000
--- a/third_party/libcxx/src/stdexcept.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <new>
-#include <stdexcept>
-#include <string>
-
-#ifdef _LIBCPP_ABI_VCRUNTIME
-#include "third_party/libcxx/src/support/runtime/stdexcept_vcruntime.ipp"
-#else
-#include "third_party/libcxx/src/support/runtime/stdexcept_default.ipp"
-#endif
diff --git a/third_party/libcxx/src/string.cpp b/third_party/libcxx/src/string.cpp
deleted file mode 100644
index b18dcceb3..000000000
--- a/third_party/libcxx/src/string.cpp
+++ /dev/null
@@ -1,392 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__assert>
-#include <cerrno>
-#include <charconv>
-#include <cstdlib>
-#include <limits>
-#include <stdexcept>
-#include <stdio.h>
-#include <string>
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-#  include <cwchar>
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-#ifndef _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
-
-template <bool>
-struct __basic_string_common;
-
-// The struct isn't declared anymore in the headers. It's only here for ABI compatibility.
-template <>
-struct __basic_string_common<true> {
-    _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_length_error() const;
-    _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_out_of_range() const;
-};
-
-void __basic_string_common<true>::__throw_length_error() const {
-    std::__throw_length_error("basic_string");
-}
-void __basic_string_common<true>::__throw_out_of_range() const {
-    std::__throw_out_of_range("basic_string");
-}
-
-#endif // _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
-
-#define _LIBCPP_EXTERN_TEMPLATE_DEFINE(...) template __VA_ARGS__;
-#ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
-    _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, char)
-#   ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, wchar_t)
-#   endif
-#else
-    _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, char)
-#   ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, wchar_t)
-#   endif
-#endif
-#undef _LIBCPP_EXTERN_TEMPLATE_DEFINE
-
-template string operator+<char, char_traits<char>, allocator<char>>(char const*, string const&);
-
-namespace
-{
-
-template<typename T>
-inline void throw_helper(const string& msg) {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw T(msg);
-#else
-    fprintf(stderr, "%s\n", msg.c_str());
-    _VSTD::abort();
-#endif
-}
-
-inline void throw_from_string_out_of_range(const string& func) {
-    throw_helper<out_of_range>(func + ": out of range");
-}
-
-inline void throw_from_string_invalid_arg(const string& func) {
-    throw_helper<invalid_argument>(func + ": no conversion");
-}
-
-// as_integer
-
-template<typename V, typename S, typename F>
-inline V as_integer_helper(const string& func, const S& str, size_t* idx, int base, F f) {
-    typename S::value_type* ptr = nullptr;
-    const typename S::value_type* const p = str.c_str();
-    __libcpp_remove_reference_t<decltype(errno)> errno_save = errno;
-    errno = 0;
-    V r = f(p, &ptr, base);
-    swap(errno, errno_save);
-    if (errno_save == ERANGE)
-        throw_from_string_out_of_range(func);
-    if (ptr == p)
-        throw_from_string_invalid_arg(func);
-    if (idx)
-        *idx = static_cast<size_t>(ptr - p);
-    return r;
-}
-
-template<typename V, typename S>
-inline V as_integer(const string& func, const S& s, size_t* idx, int base);
-
-// string
-template<>
-inline int as_integer(const string& func, const string& s, size_t* idx, int base) {
-    // Use long as no Standard string to integer exists.
-    long r = as_integer_helper<long>(func, s, idx, base, strtol);
-    if (r < numeric_limits<int>::min() || numeric_limits<int>::max() < r)
-        throw_from_string_out_of_range(func);
-    return static_cast<int>(r);
-}
-
-template<>
-inline long as_integer(const string& func, const string& s, size_t* idx, int base) {
-    return as_integer_helper<long>(func, s, idx, base, strtol);
-}
-
-template<>
-inline unsigned long as_integer(const string& func, const string& s, size_t* idx, int base) {
-    return as_integer_helper<unsigned long>(func, s, idx, base, strtoul);
-}
-
-template<>
-inline long long as_integer(const string& func, const string& s, size_t* idx, int base) {
-    return as_integer_helper<long long>(func, s, idx, base, strtoll);
-}
-
-template<>
-inline unsigned long long as_integer(const string& func, const string& s, size_t* idx, int base) {
-    return as_integer_helper<unsigned long long>(func, s, idx, base, strtoull);
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-// wstring
-template<>
-inline int as_integer(const string& func, const wstring& s, size_t* idx, int base) {
-    // Use long as no Stantard string to integer exists.
-    long r = as_integer_helper<long>(func, s, idx, base, wcstol);
-    if (r < numeric_limits<int>::min() || numeric_limits<int>::max() < r)
-        throw_from_string_out_of_range(func);
-    return static_cast<int>(r);
-}
-
-template<>
-inline long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
-    return as_integer_helper<long>(func, s, idx, base, wcstol);
-}
-
-template<>
-inline
-unsigned long
-as_integer(const string& func, const wstring& s, size_t* idx, int base)
-{
-    return as_integer_helper<unsigned long>(func, s, idx, base, wcstoul);
-}
-
-template<>
-inline long long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
-    return as_integer_helper<long long>(func, s, idx, base, wcstoll);
-}
-
-template<>
-inline unsigned long long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
-    return as_integer_helper<unsigned long long>(func, s, idx, base, wcstoull);
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// as_float
-
-template<typename V, typename S, typename F>
-inline V as_float_helper(const string& func, const S& str, size_t* idx, F f) {
-    typename S::value_type* ptr = nullptr;
-    const typename S::value_type* const p = str.c_str();
-    __libcpp_remove_reference_t<decltype(errno)> errno_save = errno;
-    errno = 0;
-    V r = f(p, &ptr);
-    swap(errno, errno_save);
-    if (errno_save == ERANGE)
-        throw_from_string_out_of_range(func);
-    if (ptr == p)
-        throw_from_string_invalid_arg(func);
-    if (idx)
-        *idx = static_cast<size_t>(ptr - p);
-    return r;
-}
-
-template<typename V, typename S>
-inline V as_float(const string& func, const S& s, size_t* idx = nullptr);
-
-template<>
-inline float as_float(const string& func, const string& s, size_t* idx) {
-    return as_float_helper<float>(func, s, idx, strtof);
-}
-
-template<>
-inline double as_float(const string& func, const string& s, size_t* idx) {
-    return as_float_helper<double>(func, s, idx, strtod);
-}
-
-template<>
-inline long double as_float(const string& func, const string& s, size_t* idx) {
-    return as_float_helper<long double>(func, s, idx, strtold);
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template<>
-inline float as_float(const string& func, const wstring& s, size_t* idx) {
-    return as_float_helper<float>(func, s, idx, wcstof);
-}
-
-template<>
-inline double as_float(const string& func, const wstring& s, size_t* idx) {
-    return as_float_helper<double>(func, s, idx, wcstod);
-}
-
-template<>
-inline long double as_float(const string& func, const wstring& s, size_t* idx) {
-    return as_float_helper<long double>(func, s, idx, wcstold);
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-}  // unnamed namespace
-
-int stoi(const string& str, size_t* idx, int base) {
-    return as_integer<int>("stoi", str, idx, base);
-}
-
-long stol(const string& str, size_t* idx, int base) {
-    return as_integer<long>("stol", str, idx, base);
-}
-
-unsigned long stoul(const string& str, size_t* idx, int base) {
-    return as_integer<unsigned long>("stoul", str, idx, base);
-}
-
-long long stoll(const string& str, size_t* idx, int base) {
-    return as_integer<long long>("stoll", str, idx, base);
-}
-
-unsigned long long stoull(const string& str, size_t* idx, int base) {
-    return as_integer<unsigned long long>("stoull", str, idx, base);
-}
-
-float stof(const string& str, size_t* idx) {
-    return as_float<float>("stof", str, idx);
-}
-
-double stod(const string& str, size_t* idx) {
-    return as_float<double>("stod", str, idx);
-}
-
-long double stold(const string& str, size_t* idx) {
-    return as_float<long double>("stold", str, idx);
-}
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-int stoi(const wstring& str, size_t* idx, int base) {
-    return as_integer<int>("stoi", str, idx, base);
-}
-
-long stol(const wstring& str, size_t* idx, int base) {
-    return as_integer<long>("stol", str, idx, base);
-}
-
-unsigned long stoul(const wstring& str, size_t* idx, int base) {
-    return as_integer<unsigned long>("stoul", str, idx, base);
-}
-
-long long stoll(const wstring& str, size_t* idx, int base) {
-    return as_integer<long long>("stoll", str, idx, base);
-}
-
-unsigned long long stoull(const wstring& str, size_t* idx, int base) {
-    return as_integer<unsigned long long>("stoull", str, idx, base);
-}
-
-float stof(const wstring& str, size_t* idx) {
-    return as_float<float>("stof", str, idx);
-}
-
-double stod(const wstring& str, size_t* idx) {
-    return as_float<double>("stod", str, idx);
-}
-
-long double stold(const wstring& str, size_t* idx) {
-    return as_float<long double>("stold", str, idx);
-}
-#endif // !_LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-// to_string
-
-namespace
-{
-
-// as_string
-
-template<typename S, typename P, typename V >
-inline S as_string(P sprintf_like, S s, const typename S::value_type* fmt, V a) {
-    typedef typename S::size_type size_type;
-    size_type available = s.size();
-    while (true) {
-        int status = sprintf_like(&s[0], available + 1, fmt, a);
-        if (status >= 0) {
-            size_type used = static_cast<size_type>(status);
-            if (used <= available) {
-                s.resize(used);
-                break;
-            }
-            available = used; // Assume this is advice of how much space we need.
-        }
-        else
-            available = available * 2 + 1;
-        s.resize(available);
-    }
-    return s;
-}
-
-template <class S>
-struct initial_string;
-
-template <>
-struct initial_string<string> {
-    string operator()() const {
-        string s;
-        s.resize(s.capacity());
-        return s;
-    }
-};
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-template <>
-struct initial_string<wstring> {
-    wstring operator()() const {
-        wstring s(20, wchar_t());
-        s.resize(s.capacity());
-        return s;
-    }
-};
-
-typedef int (*wide_printf)(wchar_t* __restrict, size_t, const wchar_t*__restrict, ...);
-
-inline wide_printf get_swprintf() {
-#ifndef _LIBCPP_MSVCRT
-    return swprintf;
-#else
-    return static_cast<int (__cdecl*)(wchar_t* __restrict, size_t, const wchar_t*__restrict, ...)>(_snwprintf);
-#endif
-}
-#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
-
-template <typename S, typename V>
-S i_to_string(V v) {
-//  numeric_limits::digits10 returns value less on 1 than desired for unsigned numbers.
-//  For example, for 1-byte unsigned value digits10 is 2 (999 can not be represented),
-//  so we need +1 here.
-    constexpr size_t bufsize = numeric_limits<V>::digits10 + 2;  // +1 for minus, +1 for digits10
-    char buf[bufsize];
-    const auto res = to_chars(buf, buf + bufsize, v);
-    _LIBCPP_ASSERT(res.ec == errc(), "bufsize must be large enough to accomodate the value");
-    return S(buf, res.ptr);
-}
-
-}  // unnamed namespace
-
-string  to_string (int val)                { return i_to_string< string>(val); }
-string  to_string (long val)               { return i_to_string< string>(val); }
-string  to_string (long long val)          { return i_to_string< string>(val); }
-string  to_string (unsigned val)           { return i_to_string< string>(val); }
-string  to_string (unsigned long val)      { return i_to_string< string>(val); }
-string  to_string (unsigned long long val) { return i_to_string< string>(val); }
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-wstring to_wstring(int val)                { return i_to_string<wstring>(val); }
-wstring to_wstring(long val)               { return i_to_string<wstring>(val); }
-wstring to_wstring(long long val)          { return i_to_string<wstring>(val); }
-wstring to_wstring(unsigned val)           { return i_to_string<wstring>(val); }
-wstring to_wstring(unsigned long val)      { return i_to_string<wstring>(val); }
-wstring to_wstring(unsigned long long val) { return i_to_string<wstring>(val); }
-#endif
-
-string  to_string (float val)       { return as_string(snprintf,       initial_string< string>()(),   "%f", val); }
-string  to_string (double val)      { return as_string(snprintf,       initial_string< string>()(),   "%f", val); }
-string  to_string (long double val) { return as_string(snprintf,       initial_string< string>()(),  "%Lf", val); }
-
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-wstring to_wstring(float val)       { return as_string(get_swprintf(), initial_string<wstring>()(),  L"%f", val); }
-wstring to_wstring(double val)      { return as_string(get_swprintf(), initial_string<wstring>()(),  L"%f", val); }
-wstring to_wstring(long double val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%Lf", val); }
-#endif
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/strstream.cpp b/third_party/libcxx/src/strstream.cpp
deleted file mode 100644
index 87c235a97..000000000
--- a/third_party/libcxx/src/strstream.cpp
+++ /dev/null
@@ -1,340 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__assert>
-#include <__utility/unreachable.h>
-#include <algorithm>
-#include <climits>
-#include <cstdlib>
-#include <cstring>
-#include <strstream>
-
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-strstreambuf::strstreambuf(streamsize __alsize)
-    : __strmode_(__dynamic),
-      __alsize_(__alsize),
-      __palloc_(nullptr),
-      __pfree_(nullptr)
-{
-}
-
-strstreambuf::strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*))
-    : __strmode_(__dynamic),
-      __alsize_(__default_alsize),
-      __palloc_(__palloc),
-      __pfree_(__pfree)
-{
-}
-
-void
-strstreambuf::__init(char* __gnext, streamsize __n, char* __pbeg)
-{
-    if (__n == 0)
-        __n = static_cast<streamsize>(strlen(__gnext));
-    else if (__n < 0)
-        __n = INT_MAX;
-    if (__pbeg == nullptr)
-        setg(__gnext, __gnext, __gnext + __n);
-    else
-    {
-        setg(__gnext, __gnext, __pbeg);
-        setp(__pbeg, __pbeg + __n);
-    }
-}
-
-strstreambuf::strstreambuf(char* __gnext, streamsize __n, char* __pbeg)
-    : __strmode_(),
-      __alsize_(__default_alsize),
-      __palloc_(nullptr),
-      __pfree_(nullptr)
-{
-    __init(__gnext, __n, __pbeg);
-}
-
-strstreambuf::strstreambuf(const char* __gnext, streamsize __n)
-    : __strmode_(__constant),
-      __alsize_(__default_alsize),
-      __palloc_(nullptr),
-      __pfree_(nullptr)
-{
-    __init(const_cast<char *>(__gnext), __n, nullptr);
-}
-
-strstreambuf::strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg)
-    : __strmode_(),
-      __alsize_(__default_alsize),
-      __palloc_(nullptr),
-      __pfree_(nullptr)
-{
-    __init(const_cast<char *>(reinterpret_cast<const char*>(__gnext)), __n, reinterpret_cast<char*>(__pbeg));
-}
-
-strstreambuf::strstreambuf(const signed char* __gnext, streamsize __n)
-    : __strmode_(__constant),
-      __alsize_(__default_alsize),
-      __palloc_(nullptr),
-      __pfree_(nullptr)
-{
-    __init(const_cast<char *>(reinterpret_cast<const char*>(__gnext)), __n, nullptr);
-}
-
-strstreambuf::strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg)
-    : __strmode_(),
-      __alsize_(__default_alsize),
-      __palloc_(nullptr),
-      __pfree_(nullptr)
-{
-    __init(const_cast<char *>(reinterpret_cast<const char*>(__gnext)), __n, reinterpret_cast<char*>(__pbeg));
-}
-
-strstreambuf::strstreambuf(const unsigned char* __gnext, streamsize __n)
-    : __strmode_(__constant),
-      __alsize_(__default_alsize),
-      __palloc_(nullptr),
-      __pfree_(nullptr)
-{
-    __init(const_cast<char *>(reinterpret_cast<const char*>(__gnext)), __n, nullptr);
-}
-
-strstreambuf::~strstreambuf()
-{
-    if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
-    {
-        if (__pfree_)
-            __pfree_(eback());
-        else
-            delete [] eback();
-    }
-}
-
-void
-strstreambuf::swap(strstreambuf& __rhs)
-{
-    streambuf::swap(__rhs);
-    _VSTD::swap(__strmode_, __rhs.__strmode_);
-    _VSTD::swap(__alsize_, __rhs.__alsize_);
-    _VSTD::swap(__palloc_, __rhs.__palloc_);
-    _VSTD::swap(__pfree_, __rhs.__pfree_);
-}
-
-void
-strstreambuf::freeze(bool __freezefl)
-{
-    if (__strmode_ & __dynamic)
-    {
-        if (__freezefl)
-            __strmode_ |= __frozen;
-        else
-            __strmode_ &= ~__frozen;
-    }
-}
-
-char*
-strstreambuf::str()
-{
-    if (__strmode_ & __dynamic)
-        __strmode_ |= __frozen;
-    return eback();
-}
-
-int
-strstreambuf::pcount() const
-{
-    return static_cast<int>(pptr() - pbase());
-}
-
-strstreambuf::int_type
-strstreambuf::overflow(int_type __c)
-{
-    if (__c == EOF)
-        return int_type(0);
-    if (pptr() == epptr())
-    {
-        if ((__strmode_ & __dynamic) == 0 || (__strmode_ & __frozen) != 0)
-            return int_type(EOF);
-        size_t old_size = static_cast<size_t> ((epptr() ? epptr() : egptr()) - eback());
-        size_t new_size = max<size_t>(static_cast<size_t>(__alsize_), 2*old_size);
-        if (new_size == 0)
-            new_size = __default_alsize;
-        char* buf = nullptr;
-        if (__palloc_)
-            buf = static_cast<char*>(__palloc_(new_size));
-        else
-            buf = new char[new_size];
-        if (buf == nullptr)
-            return int_type(EOF);
-        if (old_size != 0) {
-            _LIBCPP_ASSERT(eback(), "overflow copying from NULL");
-            memcpy(buf, eback(), static_cast<size_t>(old_size));
-        }
-        ptrdiff_t ninp = gptr()  - eback();
-        ptrdiff_t einp = egptr() - eback();
-        ptrdiff_t nout = pptr()  - pbase();
-        if (__strmode_ & __allocated)
-        {
-            if (__pfree_)
-                __pfree_(eback());
-            else
-                delete [] eback();
-        }
-        setg(buf, buf + ninp, buf + einp);
-        setp(buf + einp, buf + new_size);
-        __pbump(nout);
-        __strmode_ |= __allocated;
-    }
-    *pptr() = static_cast<char>(__c);
-    pbump(1);
-    return int_type(static_cast<unsigned char>(__c));
-}
-
-strstreambuf::int_type
-strstreambuf::pbackfail(int_type __c)
-{
-    if (eback() == gptr())
-        return EOF;
-    if (__c == EOF)
-    {
-        gbump(-1);
-        return int_type(0);
-    }
-    if (__strmode_ & __constant)
-    {
-        if (gptr()[-1] == static_cast<char>(__c))
-        {
-            gbump(-1);
-            return __c;
-        }
-        return EOF;
-    }
-    gbump(-1);
-    *gptr() = static_cast<char>(__c);
-    return __c;
-}
-
-strstreambuf::int_type
-strstreambuf::underflow()
-{
-    if (gptr() == egptr())
-    {
-        if (egptr() >= pptr())
-            return EOF;
-        setg(eback(), gptr(), pptr());
-    }
-    return int_type(static_cast<unsigned char>(*gptr()));
-}
-
-strstreambuf::pos_type
-strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which)
-{
-    off_type __p(-1);
-    bool pos_in = (__which & ios::in) != 0;
-    bool pos_out = (__which & ios::out) != 0;
-    bool legal = false;
-    switch (__way)
-    {
-    case ios::beg:
-    case ios::end:
-        if (pos_in || pos_out)
-            legal = true;
-        break;
-    case ios::cur:
-        if (pos_in != pos_out)
-            legal = true;
-        break;
-    }
-    if (pos_in && gptr() == nullptr)
-        legal = false;
-    if (pos_out && pptr() == nullptr)
-        legal = false;
-    if (legal)
-    {
-        off_type newoff;
-        char* seekhigh = epptr() ? epptr() : egptr();
-        switch (__way)
-        {
-        case ios::beg:
-            newoff = 0;
-            break;
-        case ios::cur:
-            newoff = (pos_in ? gptr() : pptr()) - eback();
-            break;
-        case ios::end:
-            newoff = seekhigh - eback();
-            break;
-        default:
-            __libcpp_unreachable();
-        }
-        newoff += __off;
-        if (0 <= newoff && newoff <= seekhigh - eback())
-        {
-            char* newpos = eback() + newoff;
-            if (pos_in)
-                setg(eback(), newpos, _VSTD::max(newpos, egptr()));
-            if (pos_out)
-            {
-                // min(pbase, newpos), newpos, epptr()
-                __off = epptr() - newpos;
-                setp(min(pbase(), newpos), epptr());
-                __pbump((epptr() - pbase()) - __off);
-            }
-            __p = newoff;
-        }
-    }
-    return pos_type(__p);
-}
-
-strstreambuf::pos_type
-strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which)
-{
-    off_type __p(-1);
-    bool pos_in = (__which & ios::in) != 0;
-    bool pos_out = (__which & ios::out) != 0;
-    if (pos_in || pos_out)
-    {
-        if (!((pos_in && gptr() == nullptr) || (pos_out && pptr() == nullptr)))
-        {
-            off_type newoff = __sp;
-            char* seekhigh = epptr() ? epptr() : egptr();
-            if (0 <= newoff && newoff <= seekhigh - eback())
-            {
-                char* newpos = eback() + newoff;
-                if (pos_in)
-                    setg(eback(), newpos, _VSTD::max(newpos, egptr()));
-                if (pos_out)
-                {
-                    // min(pbase, newpos), newpos, epptr()
-                    off_type temp = epptr() - newpos;
-                    setp(min(pbase(), newpos), epptr());
-                    __pbump((epptr() - pbase()) - temp);
-                }
-                __p = newoff;
-            }
-        }
-    }
-    return pos_type(__p);
-}
-
-istrstream::~istrstream()
-{
-}
-
-ostrstream::~ostrstream()
-{
-}
-
-strstream::~strstream()
-{
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/src/support/ibm/mbsnrtowcs.cpp b/third_party/libcxx/src/support/ibm/mbsnrtowcs.cpp
deleted file mode 100644
index d7220fb46..000000000
--- a/third_party/libcxx/src/support/ibm/mbsnrtowcs.cpp
+++ /dev/null
@@ -1,95 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <cstddef> // size_t
-#include <cwchar>  // mbstate_t
-#include <limits.h> // MB_LEN_MAX
-#include <string.h> // wmemcpy
-
-// Returns the number of wide characters found in the multi byte sequence `src`
-// (of `src_size_bytes`), that fit in the buffer `dst` (of `max_dest_chars`
-// elements size). The count returned excludes the null terminator.
-// When `dst` is NULL, no characters are copied to `dst`.
-// Returns (size_t) -1 when an invalid sequence is encountered.
-// Leaves *`src` pointing to the next character to convert or NULL
-// if a null character was converted from *`src`.
-_LIBCPP_FUNC_VIS
-size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
-                   size_t src_size_bytes, size_t max_dest_chars,
-                   mbstate_t *__restrict ps) {
-  const size_t terminated_sequence = static_cast<size_t>(0);
-  const size_t invalid_sequence = static_cast<size_t>(-1);
-  const size_t incomplete_sequence = static_cast<size_t>(-2);
-
-  size_t source_converted;
-  size_t dest_converted;
-  size_t result = 0;
-
-  // If `dst` is null then `max_dest_chars` should be ignored according to the
-  // standard. Setting `max_dest_chars` to a large value has this effect.
-  if (dst == nullptr)
-    max_dest_chars = static_cast<size_t>(-1);
-
-  for (dest_converted = source_converted = 0;
-       source_converted < src_size_bytes && (!dst || dest_converted < max_dest_chars);
-       ++dest_converted, source_converted += result) {
-    // Converts one multi byte character.
-    // If result (char_size) is greater than 0, it's the size in bytes of that character.
-    // If result (char_size) is zero, it indicates that the null character has been found.
-    // Otherwise, it's an error and errno may be set.
-    size_t source_remaining = src_size_bytes - source_converted;
-    size_t dest_remaining = max_dest_chars - dest_converted;
-
-    if (dst == nullptr) {
-      result = mbrtowc(NULL, *src + source_converted, source_remaining, ps);
-    } else if (dest_remaining >= source_remaining) {
-      // dst has enough space to translate in-place.
-      result = mbrtowc(dst + dest_converted, *src + source_converted, source_remaining, ps);
-    } else {
-      /*
-      * dst may not have enough space, so use a temporary buffer.
-      *
-      * We need to save a copy of the conversion state
-      * here so we can restore it if the multibyte
-      * character is too long for the buffer.
-      */
-      wchar_t buff[MB_LEN_MAX];
-      mbstate_t mbstate_tmp;
-
-      if (ps != nullptr)
-        mbstate_tmp = *ps;
-      result = mbrtowc(buff, *src + source_converted, source_remaining, ps);
-
-      if (result > dest_remaining) {
-        // Multi-byte sequence for character won't fit.
-        if (ps != nullptr)
-          *ps = mbstate_tmp;
-        break;
-      } else {
-        // The buffer was used, so we need copy the translation to dst.
-        wmemcpy(dst, buff, result);
-      }
-    }
-
-    // Don't do anything to change errno from here on.
-    if (result == invalid_sequence || result == terminated_sequence || result == incomplete_sequence) {
-      break;
-    }
-  }
-
-  if (dst) {
-    if (result == terminated_sequence)
-      *src = NULL;
-    else
-      *src += source_converted;
-  }
-  if (result == invalid_sequence)
-    return invalid_sequence;
-
-  return dest_converted;
-}
diff --git a/third_party/libcxx/src/support/ibm/wcsnrtombs.cpp b/third_party/libcxx/src/support/ibm/wcsnrtombs.cpp
deleted file mode 100644
index 66395bfdc..000000000
--- a/third_party/libcxx/src/support/ibm/wcsnrtombs.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <cwchar>  // mbstate_t
-#include <limits.h> // MB_LEN_MAX
-#include <stdlib.h> // MB_CUR_MAX, size_t
-#include <string.h> // memcpy
-
-// Converts `max_source_chars` from the wide character buffer pointer to by *`src`,
-// into the multi byte character sequence buffer stored at `dst`, which must be
-// `dst_size_bytes` bytes in size. Returns the number of bytes in the sequence
-// converted from *src, excluding the null terminator.
-// Returns (size_t) -1 if an error occurs and sets errno.
-// If `dst` is NULL, `dst_size_bytes` is ignored and no bytes are copied to `dst`.
-_LIBCPP_FUNC_VIS
-size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
-                   size_t max_source_chars, size_t dst_size_bytes,
-                   mbstate_t *__restrict ps) {
-
-  const size_t invalid_wchar = static_cast<size_t>(-1);
-
-  size_t source_converted;
-  size_t dest_converted;
-  size_t result = 0;
-
-  // If `dst` is null then `dst_size_bytes` should be ignored according to the
-  // standard. Setting dst_size_bytes to a large value has this effect.
-  if (dst == nullptr)
-    dst_size_bytes = static_cast<size_t>(-1);
-
-  for (dest_converted = source_converted = 0;
-       source_converted < max_source_chars && (!dst || dest_converted < dst_size_bytes);
-       ++source_converted, dest_converted += result) {
-    wchar_t c = (*src)[source_converted];
-    size_t dest_remaining = dst_size_bytes - dest_converted;
-
-    if (dst == nullptr) {
-      result = wcrtomb(NULL, c, ps);
-    } else if (dest_remaining >= static_cast<size_t>(MB_CUR_MAX)) {
-      // dst has enough space to translate in-place.
-      result = wcrtomb(dst + dest_converted, c, ps);
-    } else {
-      /*
-      * dst may not have enough space, so use a temporary buffer.
-      *
-      * We need to save a copy of the conversion state
-      * here so we can restore it if the multibyte
-      * character is too long for the buffer.
-      */
-      char buff[MB_LEN_MAX];
-      mbstate_t mbstate_tmp;
-
-      if (ps != nullptr)
-        mbstate_tmp = *ps;
-      result = wcrtomb(buff, c, ps);
-
-      if (result > dest_remaining) {
-        // Multi-byte sequence for character won't fit.
-        if (ps != nullptr)
-          *ps = mbstate_tmp;
-        if (result != invalid_wchar)
-          break;
-      } else {
-        // The buffer was used, so we need copy the translation to dst.
-        memcpy(dst, buff, result);
-      }
-    }
-
-    // result (char_size) contains the size of the multi-byte-sequence converted.
-    // Otherwise, result (char_size) is (size_t) -1 and wcrtomb() sets the errno.
-    if (result == invalid_wchar) {
-      if (dst)
-        *src = *src + source_converted;
-      return invalid_wchar;
-    }
-
-    if (c == L'\0') {
-      if (dst)
-        *src = NULL;
-      return dest_converted;
-    }
-  }
-
-  if (dst)
-    *src = *src + source_converted;
-
-  return dest_converted;
-}
diff --git a/third_party/libcxx/src/support/ibm/xlocale_zos.cpp b/third_party/libcxx/src/support/ibm/xlocale_zos.cpp
deleted file mode 100644
index a3f9558a0..000000000
--- a/third_party/libcxx/src/support/ibm/xlocale_zos.cpp
+++ /dev/null
@@ -1,138 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__assert>
-#include <__support/ibm/xlocale.h>
-#include <sstream>
-#include <vector>
-
-#ifdef __cplusplus
-extern "C" {
-#endif // __cplusplus
-
-locale_t newlocale(int category_mask, const char* locale, locale_t base) {
-  // Maintain current locale name(s) to restore later.
-  std::string current_loc_name(setlocale(LC_ALL, 0));
-
-  // Check for errors.
-  if (category_mask == LC_ALL_MASK && setlocale(LC_ALL, locale) == NULL) {
-    errno = EINVAL;
-    return (locale_t)0;
-  } else {
-    for (int _Cat = 0; _Cat <= _LC_MAX; ++_Cat) {
-      if ((_CATMASK(_Cat) & category_mask) != 0 && setlocale(_Cat, locale) == NULL) {
-        setlocale(LC_ALL, current_loc_name.c_str());
-        errno = EINVAL;
-        return (locale_t)0;
-      }
-    }
-  }
-
-  // Create new locale.
-  locale_t newloc = new locale_struct();
-
-  if (base) {
-    if (category_mask != LC_ALL_MASK) {
-      // Copy base when it will not be overwritten.
-      memcpy(newloc, base, sizeof (locale_struct));
-      newloc->category_mask = category_mask | base->category_mask;
-    }
-    delete base;
-  } else {
-    newloc->category_mask = category_mask;
-  }
-
-  if (category_mask & LC_COLLATE_MASK)
-    newloc->lc_collate = locale;
-  if (category_mask & LC_CTYPE_MASK)
-    newloc->lc_ctype = locale;
-  if (category_mask & LC_MONETARY_MASK)
-    newloc->lc_monetary = locale;
-  if (category_mask & LC_NUMERIC_MASK)
-    newloc->lc_numeric = locale;
-  if (category_mask & LC_TIME_MASK)
-    newloc->lc_time = locale;
-  if (category_mask & LC_MESSAGES_MASK)
-    newloc->lc_messages = locale;
-
-  // Restore current locale.
-  setlocale(LC_ALL, current_loc_name.c_str());
-  return (locale_t)newloc;
-}
-
-void freelocale(locale_t locobj) {
-  delete locobj;
-}
-
-locale_t uselocale(locale_t newloc) {
-  // Maintain current locale name(s).
-  std::string current_loc_name(setlocale(LC_ALL, 0));
-
-  if (newloc) {
-    // Set locales and check for errors.
-    bool is_error =
-      (newloc->category_mask & LC_COLLATE_MASK &&
-        setlocale(LC_COLLATE, newloc->lc_collate.c_str()) == NULL) ||
-      (newloc->category_mask & LC_CTYPE_MASK &&
-        setlocale(LC_CTYPE, newloc->lc_ctype.c_str()) == NULL) ||
-      (newloc->category_mask & LC_MONETARY_MASK &&
-        setlocale(LC_MONETARY, newloc->lc_monetary.c_str()) == NULL) ||
-      (newloc->category_mask & LC_NUMERIC_MASK &&
-        setlocale(LC_NUMERIC, newloc->lc_numeric.c_str()) == NULL) ||
-      (newloc->category_mask & LC_TIME_MASK &&
-        setlocale(LC_TIME, newloc->lc_time.c_str()) == NULL) ||
-      (newloc->category_mask & LC_MESSAGES_MASK &&
-        setlocale(LC_MESSAGES, newloc->lc_messages.c_str()) == NULL);
-
-    if (is_error) {
-      setlocale(LC_ALL, current_loc_name.c_str());
-      errno = EINVAL;
-      return (locale_t)0;
-    }
-  }
-
-  // Construct and return previous locale.
-  locale_t previous_loc = new locale_struct();
-
-  // current_loc_name might be a comma-separated locale name list.
-  if (current_loc_name.find(',') != std::string::npos) {
-    // Tokenize locale name list.
-    const char delimiter = ',';
-    std::vector<std::string> tokenized;
-    std::stringstream ss(current_loc_name);
-    std::string s;
-
-    while (std::getline(ss, s, delimiter)) {
-        tokenized.push_back(s);
-    }
-
-    _LIBCPP_ASSERT(tokenized.size() >= _NCAT, "locale-name list is too short");
-
-    previous_loc->lc_collate = tokenized[LC_COLLATE];
-    previous_loc->lc_ctype = tokenized[LC_CTYPE];
-    previous_loc->lc_monetary = tokenized[LC_MONETARY];
-    previous_loc->lc_numeric = tokenized[LC_NUMERIC];
-    previous_loc->lc_time = tokenized[LC_TIME];
-    // Skip LC_TOD.
-    previous_loc->lc_messages = tokenized[LC_MESSAGES];
-  } else {
-    previous_loc->lc_collate = current_loc_name;
-    previous_loc->lc_ctype = current_loc_name;
-    previous_loc->lc_monetary = current_loc_name;
-    previous_loc->lc_numeric = current_loc_name;
-    previous_loc->lc_time = current_loc_name;
-    previous_loc->lc_messages = current_loc_name;
-  }
-
-  previous_loc->category_mask = LC_ALL_MASK;
-  return previous_loc;
-}
-
-#ifdef __cplusplus
-}
-#endif // __cplusplus
diff --git a/third_party/libcxx/src/support/runtime/exception_fallback.ipp b/third_party/libcxx/src/support/runtime/exception_fallback.ipp
deleted file mode 100644
index 3b2716d36..000000000
--- a/third_party/libcxx/src/support/runtime/exception_fallback.ipp
+++ /dev/null
@@ -1,158 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <cstdio>
-
-namespace std {
-
-static constinit std::terminate_handler  __terminate_handler = nullptr;
-static constinit std::unexpected_handler __unexpected_handler = nullptr;
-
-// libcxxrt provides implementations of these functions itself.
-unexpected_handler
-set_unexpected(unexpected_handler func) noexcept
-{
-  return __libcpp_atomic_exchange(&__unexpected_handler, func);
-}
-
-unexpected_handler
-get_unexpected() noexcept
-{
-  return __libcpp_atomic_load(&__unexpected_handler);
-}
-
-_LIBCPP_NORETURN
-void unexpected()
-{
-    (*get_unexpected())();
-    // unexpected handler should not return
-    terminate();
-}
-
-terminate_handler
-set_terminate(terminate_handler func) noexcept
-{
-  return __libcpp_atomic_exchange(&__terminate_handler, func);
-}
-
-terminate_handler
-get_terminate() noexcept
-{
-  return __libcpp_atomic_load(&__terminate_handler);
-}
-
-_LIBCPP_NORETURN
-void
-terminate() noexcept
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        (*get_terminate())();
-        // handler should not return
-        fprintf(stderr, "terminate_handler unexpectedly returned\n");
-        ::abort();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        // handler should not throw exception
-        fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
-        ::abort();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-}
-
-bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
-
-int uncaught_exceptions() noexcept
-{
-#warning uncaught_exception not yet implemented
-  fprintf(stderr, "uncaught_exceptions not yet implemented\n");
-  ::abort();
-}
-
-
-exception::~exception() noexcept
-{
-}
-
-const char* exception::what() const noexcept
-{
-  return "std::exception";
-}
-
-bad_exception::~bad_exception() noexcept
-{
-}
-
-const char* bad_exception::what() const noexcept
-{
-  return "std::bad_exception";
-}
-
-
-bad_alloc::bad_alloc() noexcept
-{
-}
-
-bad_alloc::~bad_alloc() noexcept
-{
-}
-
-const char*
-bad_alloc::what() const noexcept
-{
-    return "std::bad_alloc";
-}
-
-bad_array_new_length::bad_array_new_length() noexcept
-{
-}
-
-bad_array_new_length::~bad_array_new_length() noexcept
-{
-}
-
-const char*
-bad_array_new_length::what() const noexcept
-{
-    return "bad_array_new_length";
-}
-
-bad_cast::bad_cast() noexcept
-{
-}
-
-bad_typeid::bad_typeid() noexcept
-{
-}
-
-bad_cast::~bad_cast() noexcept
-{
-}
-
-const char*
-bad_cast::what() const noexcept
-{
-  return "std::bad_cast";
-}
-
-bad_typeid::~bad_typeid() noexcept
-{
-}
-
-const char*
-bad_typeid::what() const noexcept
-{
-  return "std::bad_typeid";
-}
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/exception_glibcxx.ipp b/third_party/libcxx/src/support/runtime/exception_glibcxx.ipp
deleted file mode 100644
index e478ccbb6..000000000
--- a/third_party/libcxx/src/support/runtime/exception_glibcxx.ipp
+++ /dev/null
@@ -1,32 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef __GLIBCXX__
-#error header can only be used when targeting libstdc++ or libsupc++
-#endif
-
-namespace std {
-
-bad_alloc::bad_alloc() noexcept
-{
-}
-
-bad_array_new_length::bad_array_new_length() noexcept
-{
-}
-
-bad_cast::bad_cast() noexcept
-{
-}
-
-bad_typeid::bad_typeid() noexcept
-{
-}
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/exception_libcxxabi.ipp b/third_party/libcxx/src/support/runtime/exception_libcxxabi.ipp
deleted file mode 100644
index ee15e437e..000000000
--- a/third_party/libcxx/src/support/runtime/exception_libcxxabi.ipp
+++ /dev/null
@@ -1,27 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPPABI_VERSION
-#error this header can only be used with libc++abi
-#endif
-
-namespace std {
-
-bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
-
-int uncaught_exceptions() noexcept
-{
-# if _LIBCPPABI_VERSION > 1001
-    return __cxa_uncaught_exceptions();
-# else
-    return __cxa_uncaught_exception() ? 1 : 0;
-# endif
-}
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/exception_libcxxrt.ipp b/third_party/libcxx/src/support/runtime/exception_libcxxrt.ipp
deleted file mode 100644
index 62aa3229e..000000000
--- a/third_party/libcxx/src/support/runtime/exception_libcxxrt.ipp
+++ /dev/null
@@ -1,25 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LIBCXXRT
-#error this header may only be used when targeting libcxxrt
-#endif
-
-namespace std {
-
-bad_exception::~bad_exception() noexcept
-{
-}
-
-const char* bad_exception::what() const noexcept
-{
-  return "std::bad_exception";
-}
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/exception_msvc.ipp b/third_party/libcxx/src/support/runtime/exception_msvc.ipp
deleted file mode 100644
index 0114d5ade..000000000
--- a/third_party/libcxx/src/support/runtime/exception_msvc.ipp
+++ /dev/null
@@ -1,163 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_ABI_MICROSOFT
-#error this header can only be used when targeting the MSVC ABI
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-
-extern "C" {
-typedef void (__cdecl* terminate_handler)();
-_LIBCPP_CRT_FUNC terminate_handler __cdecl set_terminate(
-    terminate_handler _NewTerminateHandler) throw();
-_LIBCPP_CRT_FUNC terminate_handler __cdecl _get_terminate();
-
-typedef void (__cdecl* unexpected_handler)();
-unexpected_handler __cdecl set_unexpected(
-    unexpected_handler _NewUnexpectedHandler) throw();
-unexpected_handler __cdecl _get_unexpected();
-
-int __cdecl __uncaught_exceptions();
-}
-
-namespace std {
-
-unexpected_handler
-set_unexpected(unexpected_handler func) noexcept {
-  return ::set_unexpected(func);
-}
-
-unexpected_handler get_unexpected() noexcept {
-  return ::_get_unexpected();
-}
-
-_LIBCPP_NORETURN
-void unexpected() {
-    (*get_unexpected())();
-    // unexpected handler should not return
-    terminate();
-}
-
-terminate_handler set_terminate(terminate_handler func) noexcept {
-  return ::set_terminate(func);
-}
-
-terminate_handler get_terminate() noexcept {
-  return ::_get_terminate();
-}
-
-_LIBCPP_NORETURN
-void terminate() noexcept
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        (*get_terminate())();
-        // handler should not return
-        fprintf(stderr, "terminate_handler unexpectedly returned\n");
-        ::abort();
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        // handler should not throw exception
-        fprintf(stderr, "terminate_handler unexpectedly threw an exception\n");
-        ::abort();
-    }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-}
-
-bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
-
-int uncaught_exceptions() noexcept {
-    return __uncaught_exceptions();
-}
-
-#if !defined(_LIBCPP_ABI_VCRUNTIME)
-bad_cast::bad_cast() noexcept
-{
-}
-
-bad_cast::~bad_cast() noexcept
-{
-}
-
-const char *
-bad_cast::what() const noexcept
-{
-  return "std::bad_cast";
-}
-
-bad_typeid::bad_typeid() noexcept
-{
-}
-
-bad_typeid::~bad_typeid() noexcept
-{
-}
-
-const char *
-bad_typeid::what() const noexcept
-{
-  return "std::bad_typeid";
-}
-
-exception::~exception() noexcept
-{
-}
-
-const char* exception::what() const noexcept
-{
-  return "std::exception";
-}
-
-
-bad_exception::~bad_exception() noexcept
-{
-}
-
-const char* bad_exception::what() const noexcept
-{
-  return "std::bad_exception";
-}
-
-
-bad_alloc::bad_alloc() noexcept
-{
-}
-
-bad_alloc::~bad_alloc() noexcept
-{
-}
-
-const char*
-bad_alloc::what() const noexcept
-{
-    return "std::bad_alloc";
-}
-
-bad_array_new_length::bad_array_new_length() noexcept
-{
-}
-
-bad_array_new_length::~bad_array_new_length() noexcept
-{
-}
-
-const char*
-bad_array_new_length::what() const noexcept
-{
-    return "bad_array_new_length";
-}
-#endif // !_LIBCPP_ABI_VCRUNTIME
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp b/third_party/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp
deleted file mode 100644
index 33aa94502..000000000
--- a/third_party/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp
+++ /dev/null
@@ -1,73 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef HAVE_DEPENDENT_EH_ABI
-#error this header may only be used with libc++abi or libcxxrt
-#endif
-
-namespace std {
-
-exception_ptr::~exception_ptr() noexcept {
-  __cxa_decrement_exception_refcount(__ptr_);
-}
-
-exception_ptr::exception_ptr(const exception_ptr& other) noexcept
-    : __ptr_(other.__ptr_)
-{
-    __cxa_increment_exception_refcount(__ptr_);
-}
-
-exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept
-{
-    if (__ptr_ != other.__ptr_)
-    {
-        __cxa_increment_exception_refcount(other.__ptr_);
-        __cxa_decrement_exception_refcount(__ptr_);
-        __ptr_ = other.__ptr_;
-    }
-    return *this;
-}
-
-nested_exception::nested_exception() noexcept
-    : __ptr_(current_exception())
-{
-}
-
-nested_exception::~nested_exception() noexcept
-{
-}
-
-_LIBCPP_NORETURN
-void
-nested_exception::rethrow_nested() const
-{
-    if (__ptr_ == nullptr)
-        terminate();
-    rethrow_exception(__ptr_);
-}
-
-exception_ptr current_exception() noexcept
-{
-    // be nicer if there was a constructor that took a ptr, then
-    // this whole function would be just:
-    //    return exception_ptr(__cxa_current_primary_exception());
-    exception_ptr ptr;
-    ptr.__ptr_ = __cxa_current_primary_exception();
-    return ptr;
-}
-
-_LIBCPP_NORETURN
-void rethrow_exception(exception_ptr p)
-{
-    __cxa_rethrow_primary_exception(p.__ptr_);
-    // if p.__ptr_ is NULL, above returns so we terminate
-    terminate();
-}
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/exception_pointer_glibcxx.ipp b/third_party/libcxx/src/support/runtime/exception_pointer_glibcxx.ipp
deleted file mode 100644
index 983a08808..000000000
--- a/third_party/libcxx/src/support/runtime/exception_pointer_glibcxx.ipp
+++ /dev/null
@@ -1,77 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// libsupc++ does not implement the dependent EH ABI and the functionality
-// it uses to implement std::exception_ptr (which it declares as an alias of
-// std::__exception_ptr::exception_ptr) is not directly exported to clients. So
-// we have little choice but to hijack std::__exception_ptr::exception_ptr's
-// (which fortunately has the same layout as our std::exception_ptr) copy
-// constructor, assignment operator and destructor (which are part of its
-// stable ABI), and its rethrow_exception(std::__exception_ptr::exception_ptr)
-// function.
-
-namespace std {
-
-namespace __exception_ptr
-{
-
-struct exception_ptr
-{
-    void* __ptr_;
-
-    exception_ptr(const exception_ptr&) noexcept;
-    exception_ptr& operator=(const exception_ptr&) noexcept;
-    ~exception_ptr() noexcept;
-};
-
-}
-
-_LIBCPP_NORETURN void rethrow_exception(__exception_ptr::exception_ptr);
-
-exception_ptr::~exception_ptr() noexcept
-{
-    reinterpret_cast<__exception_ptr::exception_ptr*>(this)->~exception_ptr();
-}
-
-exception_ptr::exception_ptr(const exception_ptr& other) noexcept
-    : __ptr_(other.__ptr_)
-{
-    new (reinterpret_cast<void*>(this)) __exception_ptr::exception_ptr(
-        reinterpret_cast<const __exception_ptr::exception_ptr&>(other));
-}
-
-exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept
-{
-    *reinterpret_cast<__exception_ptr::exception_ptr*>(this) =
-        reinterpret_cast<const __exception_ptr::exception_ptr&>(other);
-    return *this;
-}
-
-nested_exception::nested_exception() noexcept
-    : __ptr_(current_exception())
-{
-}
-
-
-_LIBCPP_NORETURN
-void
-nested_exception::rethrow_nested() const
-{
-    if (__ptr_ == nullptr)
-        terminate();
-    rethrow_exception(__ptr_);
-}
-
-_LIBCPP_NORETURN
-void rethrow_exception(exception_ptr p)
-{
-    rethrow_exception(reinterpret_cast<__exception_ptr::exception_ptr&>(p));
-}
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/exception_pointer_msvc.ipp b/third_party/libcxx/src/support/runtime/exception_pointer_msvc.ipp
deleted file mode 100644
index 9e7f392e7..000000000
--- a/third_party/libcxx/src/support/runtime/exception_pointer_msvc.ipp
+++ /dev/null
@@ -1,86 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <stdio.h>
-#include <stdlib.h>
-
-_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrCreate(void*);
-_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrDestroy(void*);
-_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrCopy(void*, const void*);
-_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrAssign(void*, const void*);
-_LIBCPP_CRT_FUNC bool __cdecl __ExceptionPtrCompare(const void*, const void*);
-_LIBCPP_CRT_FUNC bool __cdecl __ExceptionPtrToBool(const void*);
-_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrSwap(void*, void*);
-_LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrCurrentException(void*);
-[[noreturn]] _LIBCPP_CRT_FUNC void __cdecl __ExceptionPtrRethrow(const void*);
-_LIBCPP_CRT_FUNC void __cdecl
-__ExceptionPtrCopyException(void*, const void*, const void*);
-
-namespace std {
-
-exception_ptr::exception_ptr() noexcept { __ExceptionPtrCreate(this); }
-exception_ptr::exception_ptr(nullptr_t) noexcept { __ExceptionPtrCreate(this); }
-
-exception_ptr::exception_ptr(const exception_ptr& __other) noexcept {
-  __ExceptionPtrCopy(this, &__other);
-}
-exception_ptr& exception_ptr::operator=(const exception_ptr& __other) noexcept {
-  __ExceptionPtrAssign(this, &__other);
-  return *this;
-}
-
-exception_ptr& exception_ptr::operator=(nullptr_t) noexcept {
-  exception_ptr dummy;
-  __ExceptionPtrAssign(this, &dummy);
-  return *this;
-}
-
-exception_ptr::~exception_ptr() noexcept { __ExceptionPtrDestroy(this); }
-
-exception_ptr::operator bool() const noexcept {
-  return __ExceptionPtrToBool(this);
-}
-
-bool operator==(const exception_ptr& __x, const exception_ptr& __y) noexcept {
-  return __ExceptionPtrCompare(&__x, &__y);
-}
-
-
-void swap(exception_ptr& lhs, exception_ptr& rhs) noexcept {
-  __ExceptionPtrSwap(&rhs, &lhs);
-}
-
-exception_ptr __copy_exception_ptr(void* __except, const void* __ptr) {
-  exception_ptr __ret = nullptr;
-  if (__ptr)
-    __ExceptionPtrCopyException(&__ret, __except, __ptr);
-  return __ret;
-}
-
-exception_ptr current_exception() noexcept {
-  exception_ptr __ret;
-  __ExceptionPtrCurrentException(&__ret);
-  return __ret;
-}
-
-_LIBCPP_NORETURN
-void rethrow_exception(exception_ptr p) { __ExceptionPtrRethrow(&p); }
-
-nested_exception::nested_exception() noexcept : __ptr_(current_exception()) {}
-
-nested_exception::~nested_exception() noexcept {}
-
-_LIBCPP_NORETURN
-void nested_exception::rethrow_nested() const {
-  if (__ptr_ == nullptr)
-    terminate();
-  rethrow_exception(__ptr_);
-}
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/exception_pointer_unimplemented.ipp b/third_party/libcxx/src/support/runtime/exception_pointer_unimplemented.ipp
deleted file mode 100644
index 9e8ec04e1..000000000
--- a/third_party/libcxx/src/support/runtime/exception_pointer_unimplemented.ipp
+++ /dev/null
@@ -1,79 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <stdio.h>
-#include <stdlib.h>
-
-namespace std {
-
-exception_ptr::~exception_ptr() noexcept
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-}
-
-exception_ptr::exception_ptr(const exception_ptr& other) noexcept
-    : __ptr_(other.__ptr_)
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-}
-
-exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-}
-
-nested_exception::nested_exception() noexcept
-    : __ptr_(current_exception())
-{
-}
-
-#if !defined(__GLIBCXX__)
-
-nested_exception::~nested_exception() noexcept
-{
-}
-
-#endif
-
-_LIBCPP_NORETURN
-void
-nested_exception::rethrow_nested() const
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-#if 0
-  if (__ptr_ == nullptr)
-      terminate();
-  rethrow_exception(__ptr_);
-#endif // FIXME
-}
-
-exception_ptr current_exception() noexcept
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-}
-
-_LIBCPP_NORETURN
-void rethrow_exception(exception_ptr p)
-{
-#  warning exception_ptr not yet implemented
-  fprintf(stderr, "exception_ptr not yet implemented\n");
-  ::abort();
-}
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/new_handler_fallback.ipp b/third_party/libcxx/src/support/runtime/new_handler_fallback.ipp
deleted file mode 100644
index 2ec408327..000000000
--- a/third_party/libcxx/src/support/runtime/new_handler_fallback.ipp
+++ /dev/null
@@ -1,26 +0,0 @@
-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-namespace std {
-
-static constinit std::new_handler __new_handler = nullptr;
-
-new_handler
-set_new_handler(new_handler handler) noexcept
-{
-    return __libcpp_atomic_exchange(&__new_handler, handler);
-}
-
-new_handler
-get_new_handler() noexcept
-{
-    return __libcpp_atomic_load(&__new_handler);
-}
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/stdexcept_default.ipp b/third_party/libcxx/src/support/runtime/stdexcept_default.ipp
deleted file mode 100644
index 027dded4d..000000000
--- a/third_party/libcxx/src/support/runtime/stdexcept_default.ipp
+++ /dev/null
@@ -1,64 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "third_party/libcxx/src/include/refstring.h"
-
-/* For _LIBCPPABI_VERSION */
-#if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) &&                           \
-    (defined(LIBCXX_BUILDING_LIBCXXABI) || defined(LIBCXXRT))
-#include <cxxabi.h>
-#endif
-
-static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char*), "");
-
-namespace std // purposefully not using versioning namespace
-{
-
-logic_error::logic_error(const string& msg) : __imp_(msg.c_str()) {}
-
-logic_error::logic_error(const char* msg) : __imp_(msg) {}
-
-logic_error::logic_error(const logic_error& le) noexcept : __imp_(le.__imp_) {}
-
-logic_error& logic_error::operator=(const logic_error& le) noexcept {
-  __imp_ = le.__imp_;
-  return *this;
-}
-
-runtime_error::runtime_error(const string& msg) : __imp_(msg.c_str()) {}
-
-runtime_error::runtime_error(const char* msg) : __imp_(msg) {}
-
-runtime_error::runtime_error(const runtime_error& re) noexcept
-    : __imp_(re.__imp_) {}
-
-runtime_error& runtime_error::operator=(const runtime_error& re) noexcept {
-  __imp_ = re.__imp_;
-  return *this;
-}
-
-#if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
-
-const char* logic_error::what() const noexcept { return __imp_.c_str(); }
-
-const char* runtime_error::what() const noexcept { return __imp_.c_str(); }
-
-logic_error::~logic_error() noexcept {}
-domain_error::~domain_error() noexcept {}
-invalid_argument::~invalid_argument() noexcept {}
-length_error::~length_error() noexcept {}
-out_of_range::~out_of_range() noexcept {}
-
-runtime_error::~runtime_error() noexcept {}
-range_error::~range_error() noexcept {}
-overflow_error::~overflow_error() noexcept {}
-underflow_error::~underflow_error() noexcept {}
-
-#endif
-
-} // namespace std
diff --git a/third_party/libcxx/src/support/runtime/stdexcept_vcruntime.ipp b/third_party/libcxx/src/support/runtime/stdexcept_vcruntime.ipp
deleted file mode 100644
index db9097d09..000000000
--- a/third_party/libcxx/src/support/runtime/stdexcept_vcruntime.ipp
+++ /dev/null
@@ -1,16 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_ABI_VCRUNTIME
-#error This file may only be used when deferring to vcruntime
-#endif
-
-namespace std {
-logic_error::logic_error(std::string const& s) : exception(s.c_str()) {}
-runtime_error::runtime_error(std::string const& s) : exception(s.c_str()) {}
-} // namespace std
diff --git a/third_party/libcxx/src/support/win32/locale_win32.cpp b/third_party/libcxx/src/support/win32/locale_win32.cpp
deleted file mode 100644
index 2543686c9..000000000
--- a/third_party/libcxx/src/support/win32/locale_win32.cpp
+++ /dev/null
@@ -1,143 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <locale>
-#include <cstdarg> // va_start, va_end
-#include <memory>
-#include <type_traits>
-
-#include <__locale_dir/locale_base_api/locale_guard.h>
-
-int __libcpp_vasprintf(char **sptr, const char *__restrict fmt, va_list ap);
-
-using std::__libcpp_locale_guard;
-
-// FIXME: base currently unused. Needs manual work to construct the new locale
-locale_t newlocale( int mask, const char * locale, locale_t /*base*/ )
-{
-    return {_create_locale( LC_ALL, locale ), locale};
-}
-
-decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l )
-{
-#if defined(_LIBCPP_MSVCRT)
-  return ___mb_cur_max_l_func(__l);
-#else
-  __libcpp_locale_guard __current(__l);
-  return MB_CUR_MAX;
-#endif
-}
-
-lconv *localeconv_l( locale_t &loc )
-{
-    __libcpp_locale_guard __current(loc);
-    lconv *lc = localeconv();
-    if (!lc)
-        return lc;
-    return loc.__store_lconv(lc);
-}
-size_t mbrlen_l( const char *__restrict s, size_t n,
-                 mbstate_t *__restrict ps, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return mbrlen( s, n, ps );
-}
-size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
-                    size_t len, mbstate_t *__restrict ps, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return mbsrtowcs( dst, src, len, ps );
-}
-size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps,
-                  locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return wcrtomb( s, wc, ps );
-}
-size_t mbrtowc_l( wchar_t *__restrict pwc, const char *__restrict s,
-                  size_t n, mbstate_t *__restrict ps, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return mbrtowc( pwc, s, n, ps );
-}
-size_t mbsnrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
-                     size_t nms, size_t len, mbstate_t *__restrict ps, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return mbsnrtowcs( dst, src, nms, len, ps );
-}
-size_t wcsnrtombs_l( char *__restrict dst, const wchar_t **__restrict src,
-                     size_t nwc, size_t len, mbstate_t *__restrict ps, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return wcsnrtombs( dst, src, nwc, len, ps );
-}
-wint_t btowc_l( int c, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return btowc( c );
-}
-int wctob_l( wint_t c, locale_t loc )
-{
-    __libcpp_locale_guard __current(loc);
-    return wctob( c );
-}
-
-int snprintf_l(char *ret, size_t n, locale_t loc, const char *format, ...)
-{
-    va_list ap;
-    va_start( ap, format );
-#if defined(_LIBCPP_MSVCRT)
-    // FIXME: Remove usage of internal CRT function and globals.
-    int result = __stdio_common_vsprintf(
-        _CRT_INTERNAL_LOCAL_PRINTF_OPTIONS | _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR,
-        ret, n, format, loc, ap);
-#else
-    __libcpp_locale_guard __current(loc);
-    _LIBCPP_DIAGNOSTIC_PUSH
-    _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
-    int result = vsnprintf( ret, n, format, ap );
-    _LIBCPP_DIAGNOSTIC_POP
-#endif
-    va_end(ap);
-    return result;
-}
-
-int asprintf_l( char **ret, locale_t loc, const char *format, ... )
-{
-    va_list ap;
-    va_start( ap, format );
-    int result = vasprintf_l( ret, loc, format, ap );
-    va_end(ap);
-    return result;
-}
-int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap )
-{
-    __libcpp_locale_guard __current(loc);
-    return __libcpp_vasprintf( ret, format, ap );
-}
-
-#if !defined(_LIBCPP_MSVCRT)
-float strtof_l(const char* nptr, char** endptr, locale_t loc) {
-  __libcpp_locale_guard __current(loc);
-  return strtof(nptr, endptr);
-}
-
-long double strtold_l(const char* nptr, char** endptr, locale_t loc) {
-  __libcpp_locale_guard __current(loc);
-  return strtold(nptr, endptr);
-}
-#endif
-
-#if defined(__MINGW32__) && __MSVCRT_VERSION__ < 0x0800
-size_t strftime_l(char *ret, size_t n, const char *format, const struct tm *tm,
-                  locale_t loc) {
-  __libcpp_locale_guard __current(loc);
-  return strftime(ret, n, format, tm);
-}
-#endif
diff --git a/third_party/libcxx/src/support/win32/support.cpp b/third_party/libcxx/src/support/win32/support.cpp
deleted file mode 100644
index dbec4083c..000000000
--- a/third_party/libcxx/src/support/win32/support.cpp
+++ /dev/null
@@ -1,172 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <cstdarg> // va_start, va_end
-#include <cstddef> // size_t
-#include <cstdlib> // malloc
-#include <cstdio>  // vsprintf, vsnprintf
-#include <cstring> // strcpy, wcsncpy
-#include <cwchar>  // mbstate_t
-
-
-// Like sprintf, but when return value >= 0 it returns
-// a pointer to a malloc'd string in *sptr.
-// If return >= 0, use free to delete *sptr.
-int __libcpp_vasprintf( char **sptr, const char *__restrict format, va_list ap )
-{
-    *sptr = NULL;
-    // Query the count required.
-    va_list ap_copy;
-    va_copy(ap_copy, ap);
-    _LIBCPP_DIAGNOSTIC_PUSH
-    _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
-    int count = vsnprintf( NULL, 0, format, ap_copy );
-    _LIBCPP_DIAGNOSTIC_POP
-    va_end(ap_copy);
-    if (count < 0)
-        return count;
-    size_t buffer_size = static_cast<size_t>(count) + 1;
-    char* p = static_cast<char*>(malloc(buffer_size));
-    if ( ! p )
-        return -1;
-    // If we haven't used exactly what was required, something is wrong.
-    // Maybe bug in vsnprintf. Report the error and return.
-    _LIBCPP_DIAGNOSTIC_PUSH
-    _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wformat-nonliteral")
-    if (vsnprintf(p, buffer_size, format, ap) != count) {
-    _LIBCPP_DIAGNOSTIC_POP
-        free(p);
-        return -1;
-    }
-    // All good. This is returning memory to the caller not freeing it.
-    *sptr = p;
-    return count;
-}
-
-// Returns >= 0: the number of wide characters found in the
-// multi byte sequence src (of src_size_bytes), that fit in the buffer dst
-// (of max_dest_chars elements size). The count returned excludes the
-// null terminator. When dst is NULL, no characters are copied
-// and no "out" parameters are updated.
-// Returns (size_t) -1: an incomplete sequence encountered.
-// Leaves *src pointing the next character to convert or NULL
-// if a null character was converted from *src.
-size_t mbsnrtowcs( wchar_t *__restrict dst, const char **__restrict src,
-                   size_t src_size_bytes, size_t max_dest_chars, mbstate_t *__restrict ps )
-{
-    const size_t terminated_sequence = static_cast<size_t>(0);
-    //const size_t invalid_sequence = static_cast<size_t>(-1);
-    const size_t incomplete_sequence = static_cast< size_t>(-2);
-
-    size_t dest_converted = 0;
-    size_t source_converted = 0;
-    size_t source_remaining = src_size_bytes;
-    size_t result = 0;
-    bool have_result = false;
-
-    // If dst is null then max_dest_chars should be ignored according to the
-    // standard.  Setting max_dest_chars to a large value has this effect.
-    if (!dst)
-        max_dest_chars = static_cast<size_t>(-1);
-
-    while ( source_remaining ) {
-        if ( dst && dest_converted >= max_dest_chars )
-            break;
-        // Converts one multi byte character.
-        // if result > 0, it's the size in bytes of that character.
-        // othewise if result is zero it indicates the null character has been found.
-        // otherwise it's an error and errno may be set.
-        size_t char_size = mbrtowc( dst ? dst + dest_converted : NULL, *src + source_converted, source_remaining, ps );
-        // Don't do anything to change errno from here on.
-        if ( char_size > 0 ) {
-            source_remaining -= char_size;
-            source_converted += char_size;
-            ++dest_converted;
-            continue;
-        }
-        result = char_size;
-        have_result = true;
-        break;
-    }
-    if ( dst ) {
-        if ( have_result && result == terminated_sequence )
-            *src = NULL;
-        else
-            *src += source_converted;
-    }
-    if ( have_result && result != terminated_sequence && result != incomplete_sequence )
-        return static_cast<size_t>(-1);
-
-    return dest_converted;
-}
-
-// Converts max_source_chars from the wide character buffer pointer to by *src,
-// into the multi byte character sequence buffer stored at dst which must be
-// dst_size_bytes bytes in size.
-// Returns >= 0: the number of bytes in the sequence
-// converted from *src, excluding the null terminator.
-// Returns size_t(-1) if an error occurs, also sets errno.
-// If dst is NULL dst_size_bytes is ignored and no bytes are copied to dst
-// and no "out" parameters are updated.
-size_t wcsnrtombs( char *__restrict dst, const wchar_t **__restrict src,
-                   size_t max_source_chars, size_t dst_size_bytes, mbstate_t *__restrict ps )
-{
-    //const size_t invalid_sequence = static_cast<size_t>(-1);
-
-    size_t source_converted = 0;
-    size_t dest_converted = 0;
-    size_t dest_remaining = dst_size_bytes;
-    size_t char_size = 0;
-    const errno_t no_error = ( errno_t) 0;
-    errno_t result = ( errno_t ) 0;
-    bool have_result = false;
-    bool terminator_found = false;
-
-    // If dst is null then dst_size_bytes should be ignored according to the
-    // standard.  Setting dest_remaining to a large value has this effect.
-    if (!dst)
-        dest_remaining = static_cast<size_t>(-1);
-
-    while ( source_converted != max_source_chars ) {
-        if ( ! dest_remaining )
-            break;
-        wchar_t c = (*src)[source_converted];
-        if ( dst )
-            result = wcrtomb_s( &char_size, dst + dest_converted, dest_remaining, c, ps);
-        else
-            result = wcrtomb_s( &char_size, NULL, 0, c, ps);
-        // If result is zero there is no error and char_size contains the
-        // size of the multi-byte-sequence converted.
-        // Otherwise result indicates an errno type error.
-        if ( result == no_error ) {
-            if ( c == L'\0' ) {
-                terminator_found = true;
-                break;
-            }
-            ++source_converted;
-            if ( dst )
-                dest_remaining -= char_size;
-            dest_converted += char_size;
-            continue;
-        }
-        have_result = true;
-        break;
-    }
-    if ( dst ) {
-        if ( terminator_found )
-            *src = NULL;
-        else
-            *src = *src + source_converted;
-    }
-    if ( have_result && result != no_error ) {
-        errno = result;
-        return static_cast<size_t>(-1);
-    }
-
-    return dest_converted;
-}
diff --git a/third_party/libcxx/src/support/win32/thread_win32.cpp b/third_party/libcxx/src/support/win32/thread_win32.cpp
deleted file mode 100644
index f2072b143..000000000
--- a/third_party/libcxx/src/support/win32/thread_win32.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__threading_support>
-#define NOMINMAX
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include <process.h>
-#include <fibersapi.h>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-static_assert(sizeof(__libcpp_mutex_t) == sizeof(SRWLOCK), "");
-static_assert(alignof(__libcpp_mutex_t) == alignof(SRWLOCK), "");
-
-static_assert(sizeof(__libcpp_recursive_mutex_t) == sizeof(CRITICAL_SECTION),
-              "");
-static_assert(alignof(__libcpp_recursive_mutex_t) == alignof(CRITICAL_SECTION),
-              "");
-
-static_assert(sizeof(__libcpp_condvar_t) == sizeof(CONDITION_VARIABLE), "");
-static_assert(alignof(__libcpp_condvar_t) == alignof(CONDITION_VARIABLE), "");
-
-static_assert(sizeof(__libcpp_exec_once_flag) == sizeof(INIT_ONCE), "");
-static_assert(alignof(__libcpp_exec_once_flag) == alignof(INIT_ONCE), "");
-
-static_assert(sizeof(__libcpp_thread_id) == sizeof(DWORD), "");
-static_assert(alignof(__libcpp_thread_id) == alignof(DWORD), "");
-
-static_assert(sizeof(__libcpp_thread_t) == sizeof(HANDLE), "");
-static_assert(alignof(__libcpp_thread_t) == alignof(HANDLE), "");
-
-static_assert(sizeof(__libcpp_tls_key) == sizeof(DWORD), "");
-static_assert(alignof(__libcpp_tls_key) == alignof(DWORD), "");
-
-// Mutex
-int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t *__m)
-{
-  InitializeCriticalSection((LPCRITICAL_SECTION)__m);
-  return 0;
-}
-
-int __libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t *__m)
-{
-  EnterCriticalSection((LPCRITICAL_SECTION)__m);
-  return 0;
-}
-
-bool __libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t *__m)
-{
-  return TryEnterCriticalSection((LPCRITICAL_SECTION)__m) != 0;
-}
-
-int __libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t *__m)
-{
-  LeaveCriticalSection((LPCRITICAL_SECTION)__m);
-  return 0;
-}
-
-int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t *__m)
-{
-  DeleteCriticalSection((LPCRITICAL_SECTION)__m);
-  return 0;
-}
-
-int __libcpp_mutex_lock(__libcpp_mutex_t *__m)
-{
-  AcquireSRWLockExclusive((PSRWLOCK)__m);
-  return 0;
-}
-
-bool __libcpp_mutex_trylock(__libcpp_mutex_t *__m)
-{
-  return TryAcquireSRWLockExclusive((PSRWLOCK)__m) != 0;
-}
-
-int __libcpp_mutex_unlock(__libcpp_mutex_t *__m)
-{
-  ReleaseSRWLockExclusive((PSRWLOCK)__m);
-  return 0;
-}
-
-int __libcpp_mutex_destroy(__libcpp_mutex_t *__m)
-{
-  static_cast<void>(__m);
-  return 0;
-}
-
-// Condition Variable
-int __libcpp_condvar_signal(__libcpp_condvar_t *__cv)
-{
-  WakeConditionVariable((PCONDITION_VARIABLE)__cv);
-  return 0;
-}
-
-int __libcpp_condvar_broadcast(__libcpp_condvar_t *__cv)
-{
-  WakeAllConditionVariable((PCONDITION_VARIABLE)__cv);
-  return 0;
-}
-
-int __libcpp_condvar_wait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m)
-{
-  SleepConditionVariableSRW((PCONDITION_VARIABLE)__cv, (PSRWLOCK)__m, INFINITE, 0);
-  return 0;
-}
-
-int __libcpp_condvar_timedwait(__libcpp_condvar_t *__cv, __libcpp_mutex_t *__m,
-                               __libcpp_timespec_t *__ts)
-{
-  using namespace _VSTD::chrono;
-
-  auto duration = seconds(__ts->tv_sec) + nanoseconds(__ts->tv_nsec);
-  auto abstime =
-      system_clock::time_point(duration_cast<system_clock::duration>(duration));
-  auto timeout_ms = duration_cast<milliseconds>(abstime - system_clock::now());
-
-  if (!SleepConditionVariableSRW((PCONDITION_VARIABLE)__cv, (PSRWLOCK)__m,
-                                 timeout_ms.count() > 0 ? timeout_ms.count()
-                                                        : 0,
-                                 0))
-    {
-      auto __ec = GetLastError();
-      return __ec == ERROR_TIMEOUT ? ETIMEDOUT : __ec;
-    }
-  return 0;
-}
-
-int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
-{
-  static_cast<void>(__cv);
-  return 0;
-}
-
-// Execute Once
-static inline _LIBCPP_INLINE_VISIBILITY BOOL CALLBACK
-__libcpp_init_once_execute_once_thunk(PINIT_ONCE __init_once, PVOID __parameter,
-                                      PVOID *__context)
-{
-  static_cast<void>(__init_once);
-  static_cast<void>(__context);
-
-  void (*init_routine)(void) = reinterpret_cast<void (*)(void)>(__parameter);
-  init_routine();
-  return TRUE;
-}
-
-int __libcpp_execute_once(__libcpp_exec_once_flag *__flag,
-                          void (*__init_routine)(void))
-{
-  if (!InitOnceExecuteOnce((PINIT_ONCE)__flag, __libcpp_init_once_execute_once_thunk,
-                           reinterpret_cast<void *>(__init_routine), NULL))
-    return GetLastError();
-  return 0;
-}
-
-// Thread ID
-bool __libcpp_thread_id_equal(__libcpp_thread_id __lhs,
-                              __libcpp_thread_id __rhs)
-{
-  return __lhs == __rhs;
-}
-
-bool __libcpp_thread_id_less(__libcpp_thread_id __lhs, __libcpp_thread_id __rhs)
-{
-  return __lhs < __rhs;
-}
-
-// Thread
-struct __libcpp_beginthreadex_thunk_data
-{
-  void *(*__func)(void *);
-  void *__arg;
-};
-
-static inline _LIBCPP_INLINE_VISIBILITY unsigned WINAPI
-__libcpp_beginthreadex_thunk(void *__raw_data)
-{
-  auto *__data =
-      static_cast<__libcpp_beginthreadex_thunk_data *>(__raw_data);
-  auto *__func = __data->__func;
-  void *__arg = __data->__arg;
-  delete __data;
-  return static_cast<unsigned>(reinterpret_cast<uintptr_t>(__func(__arg)));
-}
-
-bool __libcpp_thread_isnull(const __libcpp_thread_t *__t) {
-  return *__t == 0;
-}
-
-int __libcpp_thread_create(__libcpp_thread_t *__t, void *(*__func)(void *),
-                           void *__arg)
-{
-  auto *__data = new __libcpp_beginthreadex_thunk_data;
-  __data->__func = __func;
-  __data->__arg = __arg;
-
-  *__t = reinterpret_cast<HANDLE>(_beginthreadex(nullptr, 0,
-                                                 __libcpp_beginthreadex_thunk,
-                                                 __data, 0, nullptr));
-
-  if (*__t)
-    return 0;
-  return GetLastError();
-}
-
-__libcpp_thread_id __libcpp_thread_get_current_id()
-{
-  return GetCurrentThreadId();
-}
-
-__libcpp_thread_id __libcpp_thread_get_id(const __libcpp_thread_t *__t)
-{
-  return GetThreadId(*__t);
-}
-
-int __libcpp_thread_join(__libcpp_thread_t *__t)
-{
-  if (WaitForSingleObjectEx(*__t, INFINITE, FALSE) == WAIT_FAILED)
-    return GetLastError();
-  if (!CloseHandle(*__t))
-    return GetLastError();
-  return 0;
-}
-
-int __libcpp_thread_detach(__libcpp_thread_t *__t)
-{
-  if (!CloseHandle(*__t))
-    return GetLastError();
-  return 0;
-}
-
-void __libcpp_thread_yield()
-{
-  SwitchToThread();
-}
-
-void __libcpp_thread_sleep_for(const chrono::nanoseconds& __ns)
-{
-  // round-up to the nearest millisecond
-  chrono::milliseconds __ms = chrono::ceil<chrono::milliseconds>(__ns);
-  // FIXME(compnerd) this should be an alertable sleep (WFSO or SleepEx)
-  Sleep(__ms.count());
-}
-
-// Thread Local Storage
-int __libcpp_tls_create(__libcpp_tls_key* __key,
-                        void(_LIBCPP_TLS_DESTRUCTOR_CC* __at_exit)(void*))
-{
-  DWORD index = FlsAlloc(__at_exit);
-  if (index == FLS_OUT_OF_INDEXES)
-    return GetLastError();
-  *__key = index;
-  return 0;
-}
-
-void *__libcpp_tls_get(__libcpp_tls_key __key)
-{
-  return FlsGetValue(__key);
-}
-
-int __libcpp_tls_set(__libcpp_tls_key __key, void *__p)
-{
-  if (!FlsSetValue(__key, __p))
-    return GetLastError();
-  return 0;
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/system_error.cpp b/third_party/libcxx/src/system_error.cpp
deleted file mode 100644
index 812da2e25..000000000
--- a/third_party/libcxx/src/system_error.cpp
+++ /dev/null
@@ -1,298 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-#ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
-#   define _LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS
-#endif
-
-#include <__assert>
-#include <cerrno>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <string>
-#include <string.h>
-#include <system_error>
-
-#include "third_party/libcxx/src/include/config_elast.h"
-
-#if defined(__ANDROID__)
-#include <android/api-level.h>
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// class error_category
-
-#if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
-error_category::error_category() noexcept
-{
-}
-#endif
-
-error_category::~error_category() noexcept
-{
-}
-
-error_condition
-error_category::default_error_condition(int ev) const noexcept
-{
-    return error_condition(ev, *this);
-}
-
-bool
-error_category::equivalent(int code, const error_condition& condition) const noexcept
-{
-    return default_error_condition(code) == condition;
-}
-
-bool
-error_category::equivalent(const error_code& code, int condition) const noexcept
-{
-    return *this == code.category() && code.value() == condition;
-}
-
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-namespace {
-
-//  GLIBC also uses 1024 as the maximum buffer size internally.
-constexpr size_t strerror_buff_size = 1024;
-
-string do_strerror_r(int ev);
-
-#if defined(_LIBCPP_MSVCRT_LIKE)
-string do_strerror_r(int ev) {
-  char buffer[strerror_buff_size];
-  if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
-    return string(buffer);
-  std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
-  return string(buffer);
-}
-#else
-
-// Only one of the two following functions will be used, depending on
-// the return type of strerror_r:
-
-// For the GNU variant, a char* return value:
-__attribute__((unused)) const char *
-handle_strerror_r_return(char *strerror_return, char *buffer) {
-  // GNU always returns a string pointer in its return value. The
-  // string might point to either the input buffer, or a static
-  // buffer, but we don't care which.
-  return strerror_return;
-}
-
-// For the POSIX variant: an int return value.
-__attribute__((unused)) const char *
-handle_strerror_r_return(int strerror_return, char *buffer) {
-  // The POSIX variant either:
-  // - fills in the provided buffer and returns 0
-  // - returns a positive error value, or
-  // - returns -1 and fills in errno with an error value.
-  if (strerror_return == 0)
-    return buffer;
-
-  // Only handle EINVAL. Other errors abort.
-  int new_errno = strerror_return == -1 ? errno : strerror_return;
-  if (new_errno == EINVAL)
-    return "";
-
-  _LIBCPP_ASSERT(new_errno == ERANGE, "unexpected error from ::strerror_r");
-  // FIXME maybe? 'strerror_buff_size' is likely to exceed the
-  // maximum error size so ERANGE shouldn't be returned.
-  std::abort();
-}
-
-// This function handles both GNU and POSIX variants, dispatching to
-// one of the two above functions.
-string do_strerror_r(int ev) {
-    char buffer[strerror_buff_size];
-    // Preserve errno around the call. (The C++ standard requires that
-    // system_error functions not modify errno).
-    const int old_errno = errno;
-    const char *error_message = handle_strerror_r_return(
-        ::strerror_r(ev, buffer, strerror_buff_size), buffer);
-    // If we didn't get any message, print one now.
-    if (!error_message[0]) {
-      std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
-      error_message = buffer;
-    }
-    errno = old_errno;
-    return string(error_message);
-}
-#endif
-} // end namespace
-#endif
-
-string
-__do_message::message(int ev) const
-{
-#if defined(_LIBCPP_HAS_NO_THREADS)
-    return string(::strerror(ev));
-#else
-    return do_strerror_r(ev);
-#endif
-}
-
-class _LIBCPP_HIDDEN __generic_error_category
-    : public __do_message
-{
-public:
-    virtual const char* name() const noexcept;
-    virtual string message(int ev) const;
-};
-
-const char*
-__generic_error_category::name() const noexcept
-{
-    return "generic";
-}
-
-string
-__generic_error_category::message(int ev) const
-{
-#ifdef _LIBCPP_ELAST
-    if (ev > _LIBCPP_ELAST)
-      return string("unspecified generic_category error");
-#endif // _LIBCPP_ELAST
-    return __do_message::message(ev);
-}
-
-const error_category&
-generic_category() noexcept
-{
-    static __generic_error_category s;
-    return s;
-}
-
-class _LIBCPP_HIDDEN __system_error_category
-    : public __do_message
-{
-public:
-    virtual const char* name() const noexcept;
-    virtual string message(int ev) const;
-    virtual error_condition default_error_condition(int ev) const noexcept;
-};
-
-const char*
-__system_error_category::name() const noexcept
-{
-    return "system";
-}
-
-string
-__system_error_category::message(int ev) const
-{
-#ifdef _LIBCPP_ELAST
-    if (ev > _LIBCPP_ELAST)
-      return string("unspecified system_category error");
-#endif // _LIBCPP_ELAST
-    return __do_message::message(ev);
-}
-
-error_condition
-__system_error_category::default_error_condition(int ev) const noexcept
-{
-#ifdef _LIBCPP_ELAST
-    if (ev > _LIBCPP_ELAST)
-      return error_condition(ev, system_category());
-#endif // _LIBCPP_ELAST
-    return error_condition(ev, generic_category());
-}
-
-const error_category&
-system_category() noexcept
-{
-    static __system_error_category s;
-    return s;
-}
-
-// error_condition
-
-string
-error_condition::message() const
-{
-    return __cat_->message(__val_);
-}
-
-// error_code
-
-string
-error_code::message() const
-{
-    return __cat_->message(__val_);
-}
-
-// system_error
-
-string
-system_error::__init(const error_code& ec, string what_arg)
-{
-    if (ec)
-    {
-        if (!what_arg.empty())
-            what_arg += ": ";
-        what_arg += ec.message();
-    }
-    return what_arg;
-}
-
-system_error::system_error(error_code ec, const string& what_arg)
-    : runtime_error(__init(ec, what_arg)),
-      __ec_(ec)
-{
-}
-
-system_error::system_error(error_code ec, const char* what_arg)
-    : runtime_error(__init(ec, what_arg)),
-      __ec_(ec)
-{
-}
-
-system_error::system_error(error_code ec)
-    : runtime_error(__init(ec, "")),
-      __ec_(ec)
-{
-}
-
-system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
-    : runtime_error(__init(error_code(ev, ecat), what_arg)),
-      __ec_(error_code(ev, ecat))
-{
-}
-
-system_error::system_error(int ev, const error_category& ecat, const char* what_arg)
-    : runtime_error(__init(error_code(ev, ecat), what_arg)),
-      __ec_(error_code(ev, ecat))
-{
-}
-
-system_error::system_error(int ev, const error_category& ecat)
-    : runtime_error(__init(error_code(ev, ecat), "")),
-      __ec_(error_code(ev, ecat))
-{
-}
-
-system_error::~system_error() noexcept
-{
-}
-
-void
-__throw_system_error(int ev, const char* what_arg)
-{
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw system_error(error_code(ev, system_category()), what_arg);
-#else
-    (void)ev;
-    (void)what_arg;
-    _VSTD::abort();
-#endif
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/src/thread.cpp b/third_party/libcxx/src/thread.cpp
deleted file mode 100644
index 97c92d5a5..000000000
--- a/third_party/libcxx/src/thread.cpp
+++ /dev/null
@@ -1,217 +0,0 @@
-//===------------------------- thread.cpp----------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <__config>
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-
-#include <exception>
-#include <future>
-#include <limits>
-#include <thread>
-#include <vector>
-
-#if __has_include(<unistd.h>)
-# include <unistd.h> // for sysconf
-#endif
-
-#if defined(__NetBSD__)
-//#pragma weak pthread_create // Do not create libpthread dependency
-#endif
-
-#if defined(_LIBCPP_WIN32API)
-#include <windows.h>
-#endif
-
-#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#pragma comment(lib, "pthread")
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-thread::~thread()
-{
-    if (!__libcpp_thread_isnull(&__t_))
-        terminate();
-}
-
-void
-thread::join()
-{
-    int ec = EINVAL;
-    if (!__libcpp_thread_isnull(&__t_))
-    {
-        ec = __libcpp_thread_join(&__t_);
-        if (ec == 0)
-            __t_ = _LIBCPP_NULL_THREAD;
-    }
-
-    if (ec)
-        __throw_system_error(ec, "thread::join failed");
-}
-
-void
-thread::detach()
-{
-    int ec = EINVAL;
-    if (!__libcpp_thread_isnull(&__t_))
-    {
-        ec = __libcpp_thread_detach(&__t_);
-        if (ec == 0)
-            __t_ = _LIBCPP_NULL_THREAD;
-    }
-
-    if (ec)
-        __throw_system_error(ec, "thread::detach failed");
-}
-
-unsigned
-thread::hardware_concurrency() noexcept
-{
-#if defined(_SC_NPROCESSORS_ONLN)
-    long result = sysconf(_SC_NPROCESSORS_ONLN);
-    // sysconf returns -1 if the name is invalid, the option does not exist or
-    // does not have a definite limit.
-    // if sysconf returns some other negative number, we have no idea
-    // what is going on. Default to something safe.
-    if (result < 0)
-        return 0;
-    return static_cast<unsigned>(result);
-#elif defined(_LIBCPP_WIN32API)
-    SYSTEM_INFO info;
-    GetSystemInfo(&info);
-    return info.dwNumberOfProcessors;
-#else  // defined(CTL_HW) && defined(HW_NCPU)
-    // TODO: grovel through /proc or check cpuid on x86 and similar
-    // instructions on other architectures.
-#   if defined(_LIBCPP_WARNING)
-        _LIBCPP_WARNING("hardware_concurrency not yet implemented")
-#   else
-#       warning hardware_concurrency not yet implemented
-#   endif
-    return 0;  // Means not computable [thread.thread.static]
-#endif // defined(CTL_HW) && defined(HW_NCPU)
-}
-
-namespace this_thread
-{
-
-void
-sleep_for(const chrono::nanoseconds& ns)
-{
-    if (ns > chrono::nanoseconds::zero())
-    {
-        __libcpp_thread_sleep_for(ns);
-    }
-}
-
-}  // this_thread
-
-__thread_specific_ptr<__thread_struct>&
-__thread_local_data()
-{
-  // Even though __thread_specific_ptr's destructor doesn't actually destroy
-  // anything (see comments there), we can't call it at all because threads may
-  // outlive the static variable and calling its destructor means accessing an
-  // object outside of its lifetime, which is UB.
-  alignas(__thread_specific_ptr<__thread_struct>) static char __b[sizeof(__thread_specific_ptr<__thread_struct>)];
-  static __thread_specific_ptr<__thread_struct>* __p = new (__b) __thread_specific_ptr<__thread_struct>();
-  return *__p;
-}
-
-// __thread_struct_imp
-
-template <class T>
-class _LIBCPP_HIDDEN __hidden_allocator
-{
-public:
-    typedef T  value_type;
-
-    T* allocate(size_t __n)
-        {return static_cast<T*>(::operator new(__n * sizeof(T)));}
-    void deallocate(T* __p, size_t) {::operator delete(static_cast<void*>(__p));}
-
-    size_t max_size() const {return size_t(~0) / sizeof(T);}
-};
-
-class _LIBCPP_HIDDEN __thread_struct_imp
-{
-    typedef vector<__assoc_sub_state*,
-                          __hidden_allocator<__assoc_sub_state*> > _AsyncStates;
-    typedef vector<pair<condition_variable*, mutex*>,
-               __hidden_allocator<pair<condition_variable*, mutex*> > > _Notify;
-
-    _AsyncStates async_states_;
-    _Notify notify_;
-
-    __thread_struct_imp(const __thread_struct_imp&);
-    __thread_struct_imp& operator=(const __thread_struct_imp&);
-public:
-    __thread_struct_imp() {}
-    ~__thread_struct_imp();
-
-    void notify_all_at_thread_exit(condition_variable* cv, mutex* m);
-    void __make_ready_at_thread_exit(__assoc_sub_state* __s);
-};
-
-__thread_struct_imp::~__thread_struct_imp()
-{
-    for (_Notify::iterator i = notify_.begin(), e = notify_.end();
-            i != e; ++i)
-    {
-        i->first->notify_all();
-        i->second->unlock();
-    }
-    for (_AsyncStates::iterator i = async_states_.begin(), e = async_states_.end();
-            i != e; ++i)
-    {
-        (*i)->__make_ready();
-        (*i)->__release_shared();
-    }
-}
-
-void
-__thread_struct_imp::notify_all_at_thread_exit(condition_variable* cv, mutex* m)
-{
-    notify_.push_back(pair<condition_variable*, mutex*>(cv, m));
-}
-
-void
-__thread_struct_imp::__make_ready_at_thread_exit(__assoc_sub_state* __s)
-{
-    async_states_.push_back(__s);
-    __s->__add_shared();
-}
-
-// __thread_struct
-
-__thread_struct::__thread_struct()
-    : __p_(new __thread_struct_imp)
-{
-}
-
-__thread_struct::~__thread_struct()
-{
-    delete __p_;
-}
-
-void
-__thread_struct::notify_all_at_thread_exit(condition_variable* cv, mutex* m)
-{
-    __p_->notify_all_at_thread_exit(cv, m);
-}
-
-void
-__thread_struct::__make_ready_at_thread_exit(__assoc_sub_state* __s)
-{
-    __p_->__make_ready_at_thread_exit(__s);
-}
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif // !_LIBCPP_HAS_NO_THREADS
diff --git a/third_party/libcxx/src/typeinfo.cpp b/third_party/libcxx/src/typeinfo.cpp
deleted file mode 100644
index c7f0a70f8..000000000
--- a/third_party/libcxx/src/typeinfo.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <typeinfo>
-
-#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_ABI_VCRUNTIME)
-
-#include <string.h>
-
-int std::type_info::__compare(const type_info &__rhs) const noexcept {
-  if (&__data == &__rhs.__data)
-    return 0;
-  return strcmp(&__data.__decorated_name[1], &__rhs.__data.__decorated_name[1]);
-}
-
-const char *std::type_info::name() const noexcept {
-  // TODO(compnerd) cache demangled &__data.__decorated_name[1]
-  return &__data.__decorated_name[1];
-}
-
-size_t std::type_info::hash_code() const noexcept {
-#if defined(_WIN64)
-  constexpr size_t fnv_offset_basis = 14695981039346656037ull;
-  constexpr size_t fnv_prime = 10995116282110ull;
-#else
-  constexpr size_t fnv_offset_basis = 2166136261ull;
-  constexpr size_t fnv_prime = 16777619ull;
-#endif
-
-  size_t value = fnv_offset_basis;
-  for (const char* c = &__data.__decorated_name[1]; *c; ++c) {
-    value ^= static_cast<size_t>(static_cast<unsigned char>(*c));
-    value *= fnv_prime;
-  }
-
-#if defined(_WIN64)
-  value ^= value >> 32;
-#endif
-
-  return value;
-}
-#endif // _LIBCPP_ABI_MICROSOFT
-
-// FIXME: Remove the _LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY configuration.
-#if (!defined(LIBCXX_BUILDING_LIBCXXABI) &&               \
-     !defined(LIBCXXRT) &&                                \
-     !defined(__GLIBCXX__) &&                             \
-     !defined(_LIBCPP_ABI_VCRUNTIME)) ||                  \
-    defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
-std::type_info::~type_info()
-{
-}
-#endif
diff --git a/third_party/libcxx/src/valarray.cpp b/third_party/libcxx/src/valarray.cpp
deleted file mode 100644
index 5d63bc118..000000000
--- a/third_party/libcxx/src/valarray.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <valarray>
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-// These two symbols are part of the v1 ABI but not part of the >=v2 ABI.
-#if _LIBCPP_ABI_VERSION == 1
-template _LIBCPP_FUNC_VIS valarray<size_t>::valarray(size_t);
-template _LIBCPP_FUNC_VIS valarray<size_t>::~valarray();
-#endif
-
-template void valarray<size_t>::resize(size_t, size_t);
-
-void
-gslice::__init(size_t __start)
-{
-    valarray<size_t> __indices(__size_.size());
-    size_t __k = __size_.size() != 0;
-    for (size_t __i = 0; __i < __size_.size(); ++__i)
-        __k *= __size_[__i];
-    __1d_.resize(__k);
-    if (__1d_.size())
-    {
-        __k = 0;
-        __1d_[__k] = __start;
-        while (true)
-        {
-            size_t __i = __indices.size() - 1;
-            while (true)
-            {
-                if (++__indices[__i] < __size_[__i])
-                {
-                    ++__k;
-                    __1d_[__k] = __1d_[__k-1] + __stride_[__i];
-                    for (size_t __j = __i + 1; __j != __indices.size(); ++__j)
-                        __1d_[__k] -= __stride_[__j] * (__size_[__j] - 1);
-                    break;
-                }
-                else
-                {
-                    if (__i == 0)
-                        return;
-                    __indices[__i--] = 0;
-                }
-            }
-        }
-    }
-}
-
-_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/sso_allocator.h b/third_party/libcxx/sso_allocator.h
new file mode 100644
index 000000000..4e6761c58
--- /dev/null
+++ b/third_party/libcxx/sso_allocator.h
@@ -0,0 +1,80 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SSO_ALLOCATOR_H
+#define _LIBCPP_SSO_ALLOCATOR_H
+
+#include <__config>
+#include <cstddef>
+#include <memory>
+#include <new>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, size_t _Np>
+class _LIBCPP_HIDDEN __sso_allocator;
+
+template <size_t _Np>
+class _LIBCPP_HIDDEN __sso_allocator<void, _Np> {
+public:
+  typedef const void* const_pointer;
+  typedef void value_type;
+};
+
+template <class _Tp, size_t _Np>
+class _LIBCPP_HIDDEN __sso_allocator {
+  alignas(_Tp) std::byte buf_[sizeof(_Tp) * _Np];
+  bool __allocated_;
+
+public:
+  typedef size_t size_type;
+  typedef _Tp* pointer;
+  typedef _Tp value_type;
+
+  template <class U>
+  struct rebind {
+    using other = __sso_allocator<U, _Np>;
+  };
+
+  _LIBCPP_HIDE_FROM_ABI __sso_allocator() throw() : __allocated_(false) {}
+  _LIBCPP_HIDE_FROM_ABI __sso_allocator(const __sso_allocator&) throw() : __allocated_(false) {}
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI __sso_allocator(const __sso_allocator<_Up, _Np>&) throw() : __allocated_(false) {}
+
+private:
+  __sso_allocator& operator=(const __sso_allocator&);
+
+public:
+  _LIBCPP_HIDE_FROM_ABI pointer allocate(size_type __n, typename __sso_allocator<void, _Np>::const_pointer = nullptr) {
+    if (!__allocated_ && __n <= _Np) {
+      __allocated_ = true;
+      return (pointer)&buf_;
+    }
+    return allocator<_Tp>().allocate(__n);
+  }
+  _LIBCPP_HIDE_FROM_ABI void deallocate(pointer __p, size_type __n) {
+    if (__p == (pointer)&buf_)
+      __allocated_ = false;
+    else
+      allocator<_Tp>().deallocate(__p, __n);
+  }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const throw() { return size_type(~0) / sizeof(_Tp); }
+
+  _LIBCPP_HIDE_FROM_ABI bool operator==(const __sso_allocator& __a) const { return &buf_ == &__a.buf_; }
+  _LIBCPP_HIDE_FROM_ABI bool operator!=(const __sso_allocator& __a) const { return &buf_ != &__a.buf_; }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SSO_ALLOCATOR_H
diff --git a/third_party/libcxx/sstream b/third_party/libcxx/sstream
index 26c899215..9ba43ffeb 100644
--- a/third_party/libcxx/sstream
+++ b/third_party/libcxx/sstream
@@ -10,6 +10,8 @@
 #ifndef _LIBCPP_SSTREAM
 #define _LIBCPP_SSTREAM
 
+// clang-format off
+
 /*
     sstream synopsis [sstream.syn]
 
@@ -30,18 +32,52 @@ public:
     explicit basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out); // before C++20
     basic_stringbuf() : basic_stringbuf(ios_base::in | ios_base::out) {}               // C++20
     explicit basic_stringbuf(ios_base::openmode which);                                // C++20
-    explicit basic_stringbuf(const basic_string<char_type, traits_type, allocator_type>& str,
+    explicit basic_stringbuf(const basic_string<char_type, traits_type, allocator_type>& s,
                              ios_base::openmode which = ios_base::in | ios_base::out);
+    explicit basic_stringbuf(const allocator_type& a)
+        : basic_stringbuf(ios_base::in | ios_base::out, a) {}                          // C++20
+    basic_stringbuf(ios_base::openmode which, const allocator_type& a);                // C++20
+    explicit basic_stringbuf(basic_string<char_type, traits_type, allocator_type>&& s,
+                             ios_base::openmode which = ios_base::in | ios_base::out); // C++20
+    template <class SAlloc>
+    basic_stringbuf(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a)
+        : basic_stringbuf(s, ios_base::in | ios_base::out, a) {}                       // C++20
+    template <class SAlloc>
+    basic_stringbuf(const basic_string<char_type, traits_type, SAlloc>& s,
+                    ios_base::openmode which, const allocator_type& a);                // C++20
+    template <class SAlloc>
+    explicit basic_stringbuf(const basic_string<char_type, traits_type, SAlloc>& s,
+                             ios_base::openmode which = ios_base::in | ios_base::out); // C++20
+    template<class T>
+      explicit basic_stringbuf(const T& t,
+                               ios_base::openmode which = ios_base::in | ios_base::out); // Since C++26
+    template<class T>
+      basic_stringbuf(const T& t, const Allocator& a);                                   // Since C++26
+    template<class T>
+      basic_stringbuf(const T& t, ios_base::openmode which, const Allocator& a);         // Since C++26
+    basic_stringbuf(const basic_stringbuf&) = delete;
     basic_stringbuf(basic_stringbuf&& rhs);
+    basic_stringbuf(basic_stringbuf&& rhs, const allocator_type& a);                   // C++20
 
     // [stringbuf.assign] Assign and swap:
+    basic_stringbuf& operator=(const basic_stringbuf&) = delete;
     basic_stringbuf& operator=(basic_stringbuf&& rhs);
-    void swap(basic_stringbuf& rhs);
+    void swap(basic_stringbuf& rhs) noexcept(see below);                               // conditionally noexcept since C++20
 
     // [stringbuf.members] Member functions:
-    basic_string<char_type, traits_type, allocator_type> str() const;
+    allocator_type get_allocator() const noexcept;                                     // C++20
+    basic_string<char_type, traits_type, allocator_type> str() const;                  // before C++20
+    basic_string<char_type, traits_type, allocator_type> str() const &;                // C++20
+    template <class SAlloc>
+    basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const;          // C++20
+    basic_string<char_type, traits_type, allocator_type> str() &&;                     // C++20
+    basic_string_view<char_type, traits_type> view() const noexcept;                   // C++20
     void str(const basic_string<char_type, traits_type, allocator_type>& s);
-    basic_string_view<char_type, traits_type> view() const noexcept; // C++20
+    template <class SAlloc>
+    void str(const basic_string<char_type, traits_type, SAlloc>& s);                   // C++20
+    void str(basic_string<char_type, traits_type, allocator_type>&& s);                // C++20
+    template<class T>
+      void str(const T& t);                                                            // Since C++26
 
 protected:
     // [stringbuf.virtuals] Overridden virtual functions:
@@ -57,8 +93,8 @@ protected:
 
 // [stringbuf.assign] non member swap
 template <class charT, class traits, class Allocator>
-  void swap(basic_stringbuf<charT, traits, Allocator>& x,
-            basic_stringbuf<charT, traits, Allocator>& y);
+void swap(basic_stringbuf<charT, traits, Allocator>& x,
+          basic_stringbuf<charT, traits, Allocator>& y); // conditionally noexcept since C++20
 
 typedef basic_stringbuf<char>    stringbuf;
 typedef basic_stringbuf<wchar_t> wstringbuf;
@@ -77,28 +113,56 @@ public:
     typedef Allocator                      allocator_type;
 
     // [istringstream.cons] Constructors:
-    explicit basic_istringstream(ios_base::openmode which = ios_base::in); // before C++20
-    basic_istringstream() : basic_istringstream(ios_base::in) {}           // C++20
-    explicit basic_istringstream(ios_base::openmode which);                // C++20
-
-    explicit basic_istringstream(const basic_string<char_type, traits_type,allocator_type>& str,
+    explicit basic_istringstream(ios_base::openmode which = ios_base::in);             // before C++20
+    basic_istringstream() : basic_istringstream(ios_base::in) {}                       // C++20
+    explicit basic_istringstream(ios_base::openmode which);                            // C++20
+    explicit basic_istringstream(const basic_string<char_type, traits_type, allocator_type>& s,
                                  ios_base::openmode which = ios_base::in);
+    basic_istringstream(ios_base::openmode which, const allocator_type& a);            // C++20
+    explicit basic_istringstream(basic_string<char_type, traits_type, allocator_type>&& s,
+                                 ios_base::openmode which = ios_base::in);             // C++20
+    template <class SAlloc>
+    basic_istringstream(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a)
+        : basic_istringstream(s, ios_base::in, a) {}                                   // C++20
+    template <class SAlloc>
+    basic_istringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                        ios_base::openmode which, const allocator_type& a);            // C++20
+    template <class SAlloc>
+    explicit basic_istringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                                 ios_base::openmode which = ios_base::in);             // C++20
+    template<class T>
+      explicit basic_istringstream(const T& t, ios_base::openmode which = ios_base::in); // Since C++26
+    template<class T>
+      basic_istringstream(const T& t, const Allocator& a);                               // Since C++26
+    template<class T>
+      basic_istringstream(const T& t, ios_base::openmode which, const Allocator& a);     // Since C++26
+    basic_istringstream(const basic_istringstream&) = delete;
     basic_istringstream(basic_istringstream&& rhs);
 
     // [istringstream.assign] Assign and swap:
+    basic_istringstream& operator=(const basic_istringstream&) = delete;
     basic_istringstream& operator=(basic_istringstream&& rhs);
     void swap(basic_istringstream& rhs);
 
     // [istringstream.members] Member functions:
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
-    basic_string<char_type, traits_type, allocator_type> str() const;
+    basic_string<char_type, traits_type, allocator_type> str() const;                  // before C++20
+    basic_string<char_type, traits_type, allocator_type> str() const &;                // C++20
+    template <class SAlloc>
+    basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const;          // C++20
+    basic_string<char_type, traits_type, allocator_type> str() &&;                     // C++20
+    basic_string_view<char_type, traits_type> view() const noexcept;                   // C++20
     void str(const basic_string<char_type, traits_type, allocator_type>& s);
-    basic_string_view<char_type, traits_type> view() const noexcept; // C++20
+    template <class SAlloc>
+    void str(const basic_string<char_type, traits_type, SAlloc>& s);                   // C++20
+    void str(basic_string<char_type, traits_type, allocator_type>&& s);                // C++20
+    template<class T>
+      void str(const T& t);                                                            // Since C++26
 };
 
 template <class charT, class traits, class Allocator>
-  void swap(basic_istringstream<charT, traits, Allocator>& x,
-            basic_istringstream<charT, traits, Allocator>& y);
+void swap(basic_istringstream<charT, traits, Allocator>& x,
+          basic_istringstream<charT, traits, Allocator>& y);
 
 typedef basic_istringstream<char>    istringstream;
 typedef basic_istringstream<wchar_t> wistringstream;
@@ -118,28 +182,56 @@ public:
     typedef Allocator                      allocator_type;
 
     // [ostringstream.cons] Constructors:
-    explicit basic_ostringstream(ios_base::openmode which = ios_base::out); // before C++20
-    basic_ostringstream() : basic_ostringstream(ios_base::out) {}           // C++20
-    explicit basic_ostringstream(ios_base::openmode which);                 // C++20
-
-    explicit basic_ostringstream(const basic_string<char_type, traits_type, allocator_type>& str,
+    explicit basic_ostringstream(ios_base::openmode which = ios_base::out);            // before C++20
+    basic_ostringstream() : basic_ostringstream(ios_base::out) {}                      // C++20
+    explicit basic_ostringstream(ios_base::openmode which);                            // C++20
+    explicit basic_ostringstream(const basic_string<char_type, traits_type, allocator_type>& s,
                                  ios_base::openmode which = ios_base::out);
+    basic_ostringstream(ios_base::openmode which, const allocator_type& a);            // C++20
+    explicit basic_ostringstream(basic_string<char_type, traits_type, allocator_type>&& s,
+                                 ios_base::openmode which = ios_base::out);            // C++20
+    template <class SAlloc>
+    basic_ostringstream(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a)
+        : basic_ostringstream(s, ios_base::out, a) {}                                  // C++20
+    template <class SAlloc>
+    basic_ostringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                        ios_base::openmode which, const allocator_type& a);            // C++20
+    template <class SAlloc>
+    explicit basic_ostringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                                 ios_base::openmode which = ios_base::out);            // C++20
+    template<class T>
+      explicit basic_ostringstream(const T& t, ios_base::openmode which = ios_base::out); // Since C++26
+    template<class T>
+      basic_ostringstream(const T& t, const Allocator& a);                                // Since C++26
+    template<class T>
+      basic_ostringstream(const T& t, ios_base::openmode which, const Allocator& a);      // Since C++26
+    basic_ostringstream(const basic_ostringstream&) = delete;
     basic_ostringstream(basic_ostringstream&& rhs);
 
     // [ostringstream.assign] Assign and swap:
+    basic_ostringstream& operator=(const basic_ostringstream&) = delete;
     basic_ostringstream& operator=(basic_ostringstream&& rhs);
     void swap(basic_ostringstream& rhs);
 
     // [ostringstream.members] Member functions:
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
-    basic_string<char_type, traits_type, allocator_type> str() const;
+    basic_string<char_type, traits_type, allocator_type> str() const;                  // before C++20
+    basic_string<char_type, traits_type, allocator_type> str() const &;                // C++20
+    template <class SAlloc>
+    basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const;          // C++20
+    basic_string<char_type, traits_type, allocator_type> str() &&;                     // C++20
+    basic_string_view<char_type, traits_type> view() const noexcept;                   // C++20
     void str(const basic_string<char_type, traits_type, allocator_type>& s);
-    basic_string_view<char_type, traits_type> view() const noexcept; // C++20
+    template <class SAlloc>
+    void str(const basic_string<char_type, traits_type, SAlloc>& s);                   // C++20
+    void str(basic_string<char_type, traits_type, allocator_type>&& s);                // C++20
+    template<class T>
+      void str(const T& t);                                                            // Since C++26
 };
 
 template <class charT, class traits, class Allocator>
-  void swap(basic_ostringstream<charT, traits, Allocator>& x,
-            basic_ostringstream<charT, traits, Allocator>& y);
+void swap(basic_ostringstream<charT, traits, Allocator>& x,
+          basic_ostringstream<charT, traits, Allocator>& y);
 
 typedef basic_ostringstream<char>    ostringstream;
 typedef basic_ostringstream<wchar_t> wostringstream;
@@ -162,25 +254,54 @@ public:
     explicit basic_stringstream(ios_base::openmode which = ios_base::out | ios_base::in); // before C++20
     basic_stringstream() : basic_stringstream(ios_base::out | ios_base::in) {}            // C++20
     explicit basic_stringstream(ios_base::openmode which);                                // C++20
-
-    explicit basic_stringstream(const basic_string<char_type, traits_type, allocator_type>& str,
-                                ios_base::openmode which = ios_base::out|ios_base::in);
+    explicit basic_stringstream(const basic_string<char_type, traits_type, allocator_type>& s,
+                                ios_base::openmode which = ios_base::out | ios_base::in);
+    basic_stringstream(ios_base::openmode which, const allocator_type& a);                // C++20
+    explicit basic_stringstream(basic_string<char_type, traits_type, allocator_type>&& s,
+                                ios_base::openmode which = ios_base::out | ios_base::in); // C++20
+    template <class SAlloc>
+    basic_stringstream(const basic_string<char_type, traits_type, SAlloc>& s, const allocator_type& a)
+        : basic_stringstream(s, ios_base::out | ios_base::in, a) {}                       // C++20
+    template <class SAlloc>
+    basic_stringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                       ios_base::openmode which, const allocator_type& a);                // C++20
+    template <class SAlloc>
+    explicit basic_stringstream(const basic_string<char_type, traits_type, SAlloc>& s,
+                                ios_base::openmode which = ios_base::out | ios_base::in); // C++20
+    template<class T>
+      explicit basic_stringstream(const T& t,
+                                  ios_base::openmode which = ios_base::out | ios_base::in); // Since C++26
+    template<class T>
+      basic_stringstream(const T& t, const Allocator& a);                                   // Since C++26
+    template<class T>
+      basic_stringstream(const T& t, ios_base::openmode which, const Allocator& a);         // Since C++26
+    basic_stringstream(const basic_stringstream&) = delete;
     basic_stringstream(basic_stringstream&& rhs);
 
     // [stringstream.assign] Assign and swap:
+    basic_stringstream& operator=(const basic_stringstream&) = delete;
     basic_stringstream& operator=(basic_stringstream&& rhs);
     void swap(basic_stringstream& rhs);
 
     // [stringstream.members] Member functions:
     basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const;
-    basic_string<char_type, traits_type, allocator_type> str() const;
-    void str(const basic_string<char_type, traits_type, allocator_type>& str);
-    basic_string_view<char_type, traits_type> view() const noexcept; // C++20
+    basic_string<char_type, traits_type, allocator_type> str() const;                     // before C++20
+    basic_string<char_type, traits_type, allocator_type> str() const &;                   // C++20
+    template <class SAlloc>
+    basic_string<char_type, traits_type, SAlloc> str(const SAlloc& sa) const;             // C++20
+    basic_string<char_type, traits_type, allocator_type> str() &&;                        // C++20
+    basic_string_view<char_type, traits_type> view() const noexcept;                      // C++20
+    void str(const basic_string<char_type, traits_type, allocator_type>& s);
+    template <class SAlloc>
+    void str(const basic_string<char_type, traits_type, SAlloc>& s);                      // C++20
+    void str(basic_string<char_type, traits_type, allocator_type>&& s);                   // C++20
+    template<class T>
+      void str(const T& t);                                                               // Since C++26
 };
 
 template <class charT, class traits, class Allocator>
-  void swap(basic_stringstream<charT, traits, Allocator>& x,
-            basic_stringstream<charT, traits, Allocator>& y);
+void swap(basic_stringstream<charT, traits, Allocator>& x,
+          basic_stringstream<charT, traits, Allocator>& y);
 
 typedef basic_stringstream<char>    stringstream;
 typedef basic_stringstream<wchar_t> wstringstream;
@@ -189,13 +310,16 @@ typedef basic_stringstream<wchar_t> wstringstream;
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
+// clang-format on
+
 #include <__config>
 #include <__fwd/sstream.h>
+#include <__ostream/basic_ostream.h>
+#include <__type_traits/is_convertible.h>
 #include <__utility/swap.h>
 #include <istream>
-#include <ostream>
 #include <string>
+#include <string_view>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -205,712 +329,935 @@ typedef basic_stringstream<wchar_t> wstringstream;
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Class template basic_stringbuf [stringbuf]
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TEMPLATE_VIS basic_stringbuf
-    : public basic_streambuf<_CharT, _Traits>
-{
+class _LIBCPP_TEMPLATE_VIS basic_stringbuf : public basic_streambuf<_CharT, _Traits> {
 public:
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
-    typedef _Allocator                     allocator_type;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+  typedef _Allocator allocator_type;
 
-    typedef basic_string<char_type, traits_type, allocator_type> string_type;
+  typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
-
-    string_type __str_;
-    mutable char_type* __hm_;
-    ios_base::openmode __mode_;
+  string_type __str_;
+  mutable char_type* __hm_;
+  ios_base::openmode __mode_;
+  _LIBCPP_HIDE_FROM_ABI void __init_buf_ptrs();
+  _LIBCPP_HIDE_FROM_ABI void __move_init(basic_stringbuf&& __rhs);
 
 public:
-    // [stringbuf.cons] constructors:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_stringbuf()
-        : __hm_(nullptr), __mode_(ios_base::in | ios_base::out) {}
+  // [stringbuf.cons] constructors:
+  _LIBCPP_HIDE_FROM_ABI basic_stringbuf() : __hm_(nullptr), __mode_(ios_base::in | ios_base::out) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_stringbuf(ios_base::openmode __wch)
-        : __hm_(nullptr), __mode_(__wch) {}
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringbuf(ios_base::openmode __wch) : __hm_(nullptr), __mode_(__wch) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_stringbuf(const string_type& __s,
-                             ios_base::openmode __wch = ios_base::in | ios_base::out)
-        : __str_(__s.get_allocator()), __hm_(nullptr), __mode_(__wch)
-    {
-        str(__s);
-    }
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringbuf(const string_type& __s,
+                                                 ios_base::openmode __wch = ios_base::in | ios_base::out)
+      : __str_(__s.get_allocator()), __hm_(nullptr), __mode_(__wch) {
+    str(__s);
+  }
 
-    basic_stringbuf(basic_stringbuf&& __rhs);
-
-    // [stringbuf.assign] Assign and swap:
-    basic_stringbuf& operator=(basic_stringbuf&& __rhs);
-    void swap(basic_stringbuf& __rhs);
-
-    // [stringbuf.members] Member functions:
-    string_type str() const;
-    void str(const string_type& __s);
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    basic_string_view<char_type, traits_type> view() const noexcept;
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringbuf(const allocator_type& __a)
+      : basic_stringbuf(ios_base::in | ios_base::out, __a) {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_stringbuf(ios_base::openmode __wch, const allocator_type& __a)
+      : __str_(__a), __hm_(nullptr), __mode_(__wch) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringbuf(string_type&& __s,
+                                                 ios_base::openmode __wch = ios_base::in | ios_base::out)
+      : __str_(std::move(__s)), __hm_(nullptr), __mode_(__wch) {
+    __init_buf_ptrs();
+  }
+
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI
+  basic_stringbuf(const basic_string<char_type, traits_type, _SAlloc>& __s, const allocator_type& __a)
+      : basic_stringbuf(__s, ios_base::in | ios_base::out, __a) {}
+
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI basic_stringbuf(
+      const basic_string<char_type, traits_type, _SAlloc>& __s, ios_base::openmode __wch, const allocator_type& __a)
+      : __str_(__s, __a), __hm_(nullptr), __mode_(__wch) {
+    __init_buf_ptrs();
+  }
+
+  template <class _SAlloc>
+    requires(!is_same_v<_SAlloc, allocator_type>)
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringbuf(const basic_string<char_type, traits_type, _SAlloc>& __s,
+                                                 ios_base::openmode __wch = ios_base::in | ios_base::out)
+      : __str_(__s), __hm_(nullptr), __mode_(__wch) {
+    __init_buf_ptrs();
+  }
+#endif // _LIBCPP_STD_VER >= 20
+
+#if _LIBCPP_STD_VER >= 26
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringbuf(const _Tp& __t,
+                                                 ios_base::openmode __which = ios_base::in | ios_base::out)
+      : basic_stringbuf(__t, __which, _Allocator()) {}
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI basic_stringbuf(const _Tp& __t, const _Allocator& __a)
+      : basic_stringbuf(__t, ios_base::in | ios_base::out, __a) {}
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI basic_stringbuf(const _Tp& __t, ios_base::openmode __which, const _Allocator& __a)
+      : __hm_(nullptr), __mode_(__which) {
+    basic_string_view<_CharT, _Traits> __sv = __t;
+    __str_                                  = string_type(__sv, __a);
+    __init_buf_ptrs();
+  }
+
+#endif //  _LIBCPP_STD_VER >= 26
+
+  basic_stringbuf(const basic_stringbuf&) = delete;
+  basic_stringbuf(basic_stringbuf&& __rhs) : __mode_(__rhs.__mode_) { __move_init(std::move(__rhs)); }
+
+#if _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI basic_stringbuf(basic_stringbuf&& __rhs, const allocator_type& __a)
+      : basic_stringbuf(__rhs.__mode_, __a) {
+    __move_init(std::move(__rhs));
+  }
 #endif
 
+  // [stringbuf.assign] Assign and swap:
+  basic_stringbuf& operator=(const basic_stringbuf&) = delete;
+  basic_stringbuf& operator=(basic_stringbuf&& __rhs);
+  void swap(basic_stringbuf& __rhs)
+#if _LIBCPP_STD_VER >= 20
+      noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value ||
+               allocator_traits<allocator_type>::is_always_equal::value)
+#endif
+          ;
+
+  // [stringbuf.members] Member functions:
+
+#if _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __str_.get_allocator(); }
+#endif
+
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
+  string_type str() const;
+#else
+  _LIBCPP_HIDE_FROM_ABI string_type str() const& { return str(__str_.get_allocator()); }
+
+  _LIBCPP_HIDE_FROM_ABI string_type str() && {
+    const basic_string_view<_CharT, _Traits> __view = view();
+    typename string_type::size_type __pos           = __view.empty() ? 0 : __view.data() - __str_.data();
+    // In C++23, this is just string_type(std::move(__str_), __pos, __view.size(), __str_.get_allocator());
+    // But we need something that works in C++20 also.
+    string_type __result(std::move(__str_), __str_.get_allocator());
+    __result.resize(__pos + __view.size());
+    __result.erase(0, __pos);
+    __init_buf_ptrs();
+    return __result;
+  }
+#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
+
+#if _LIBCPP_STD_VER >= 20
+  template <class _SAlloc>
+    requires __is_allocator<_SAlloc>::value
+  _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+    return basic_string<_CharT, _Traits, _SAlloc>(view(), __sa);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept;
+#endif // _LIBCPP_STD_VER >= 20
+
+  void str(const string_type& __s) {
+    __str_ = __s;
+    __init_buf_ptrs();
+  }
+
+#if _LIBCPP_STD_VER >= 20
+  template <class _SAlloc>
+    requires(!is_same_v<_SAlloc, allocator_type>)
+  _LIBCPP_HIDE_FROM_ABI void str(const basic_string<char_type, traits_type, _SAlloc>& __s) {
+    __str_ = __s;
+    __init_buf_ptrs();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void str(string_type&& __s) {
+    __str_ = std::move(__s);
+    __init_buf_ptrs();
+  }
+#endif // _LIBCPP_STD_VER >= 20
+
+#if _LIBCPP_STD_VER >= 26
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI void str(const _Tp& __t) {
+    basic_string_view<_CharT, _Traits> __sv = __t;
+    __str_                                  = __sv;
+    __init_buf_ptrs();
+  }
+
+#endif //  _LIBCPP_STD_VER >= 26
+
 protected:
-    // [stringbuf.virtuals] Overridden virtual functions:
-    int_type underflow() override;
-    int_type pbackfail(int_type __c = traits_type::eof()) override;
-    int_type overflow (int_type __c = traits_type::eof()) override;
-    pos_type seekoff(off_type __off, ios_base::seekdir __way,
-                     ios_base::openmode __wch = ios_base::in | ios_base::out) override;
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL
-    pos_type seekpos(pos_type __sp,
-                     ios_base::openmode __wch = ios_base::in | ios_base::out) override {
-        return seekoff(__sp, ios_base::beg, __wch);
-    }
+  // [stringbuf.virtuals] Overridden virtual functions:
+  int_type underflow() override;
+  int_type pbackfail(int_type __c = traits_type::eof()) override;
+  int_type overflow(int_type __c = traits_type::eof()) override;
+  pos_type
+  seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __wch = ios_base::in | ios_base::out) override;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  pos_type seekpos(pos_type __sp, ios_base::openmode __wch = ios_base::in | ios_base::out) override {
+    return seekoff(__sp, ios_base::beg, __wch);
+  }
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(basic_stringbuf&& __rhs)
-    : __mode_(__rhs.__mode_)
-{
-    char_type* __p = const_cast<char_type*>(__rhs.__str_.data());
-    ptrdiff_t __binp = -1;
-    ptrdiff_t __ninp = -1;
-    ptrdiff_t __einp = -1;
-    if (__rhs.eback() != nullptr)
-    {
-        __binp = __rhs.eback() - __p;
-        __ninp = __rhs.gptr() - __p;
-        __einp = __rhs.egptr() - __p;
-    }
-    ptrdiff_t __bout = -1;
-    ptrdiff_t __nout = -1;
-    ptrdiff_t __eout = -1;
-    if (__rhs.pbase() != nullptr)
-    {
-        __bout = __rhs.pbase() - __p;
-        __nout = __rhs.pptr() - __p;
-        __eout = __rhs.epptr() - __p;
-    }
-    ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p;
-    __str_ = _VSTD::move(__rhs.__str_);
-    __p = const_cast<char_type*>(__str_.data());
-    if (__binp != -1)
-        this->setg(__p + __binp, __p + __ninp, __p + __einp);
-    if (__bout != -1)
-    {
-        this->setp(__p + __bout, __p + __eout);
-        this->__pbump(__nout);
-    }
-    __hm_ = __hm == -1 ? nullptr : __p + __hm;
-    __p = const_cast<char_type*>(__rhs.__str_.data());
-    __rhs.setg(__p, __p, __p);
-    __rhs.setp(__p, __p);
-    __rhs.__hm_ = __p;
-    this->pubimbue(__rhs.getloc());
+_LIBCPP_HIDE_FROM_ABI void basic_stringbuf<_CharT, _Traits, _Allocator>::__move_init(basic_stringbuf&& __rhs) {
+  char_type* __p   = const_cast<char_type*>(__rhs.__str_.data());
+  ptrdiff_t __binp = -1;
+  ptrdiff_t __ninp = -1;
+  ptrdiff_t __einp = -1;
+  if (__rhs.eback() != nullptr) {
+    __binp = __rhs.eback() - __p;
+    __ninp = __rhs.gptr() - __p;
+    __einp = __rhs.egptr() - __p;
+  }
+  ptrdiff_t __bout = -1;
+  ptrdiff_t __nout = -1;
+  ptrdiff_t __eout = -1;
+  if (__rhs.pbase() != nullptr) {
+    __bout = __rhs.pbase() - __p;
+    __nout = __rhs.pptr() - __p;
+    __eout = __rhs.epptr() - __p;
+  }
+  ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p;
+  __str_         = std::move(__rhs.__str_);
+  __p            = const_cast<char_type*>(__str_.data());
+  if (__binp != -1)
+    this->setg(__p + __binp, __p + __ninp, __p + __einp);
+  if (__bout != -1) {
+    this->setp(__p + __bout, __p + __eout);
+    this->__pbump(__nout);
+  }
+  __hm_ = __hm == -1 ? nullptr : __p + __hm;
+  __p   = const_cast<char_type*>(__rhs.__str_.data());
+  __rhs.setg(__p, __p, __p);
+  __rhs.setp(__p, __p);
+  __rhs.__hm_ = __p;
+  this->pubimbue(__rhs.getloc());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_stringbuf<_CharT, _Traits, _Allocator>&
-basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs)
-{
-    char_type* __p = const_cast<char_type*>(__rhs.__str_.data());
-    ptrdiff_t __binp = -1;
-    ptrdiff_t __ninp = -1;
-    ptrdiff_t __einp = -1;
-    if (__rhs.eback() != nullptr)
-    {
-        __binp = __rhs.eback() - __p;
-        __ninp = __rhs.gptr() - __p;
-        __einp = __rhs.egptr() - __p;
-    }
-    ptrdiff_t __bout = -1;
-    ptrdiff_t __nout = -1;
-    ptrdiff_t __eout = -1;
-    if (__rhs.pbase() != nullptr)
-    {
-        __bout = __rhs.pbase() - __p;
-        __nout = __rhs.pptr() - __p;
-        __eout = __rhs.epptr() - __p;
-    }
-    ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p;
-    __str_ = _VSTD::move(__rhs.__str_);
-    __p = const_cast<char_type*>(__str_.data());
-    if (__binp != -1)
-        this->setg(__p + __binp, __p + __ninp, __p + __einp);
-    else
-        this->setg(nullptr, nullptr, nullptr);
-    if (__bout != -1)
-    {
-        this->setp(__p + __bout, __p + __eout);
-        this->__pbump(__nout);
-    }
-    else
-        this->setp(nullptr, nullptr);
+basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs) {
+  char_type* __p   = const_cast<char_type*>(__rhs.__str_.data());
+  ptrdiff_t __binp = -1;
+  ptrdiff_t __ninp = -1;
+  ptrdiff_t __einp = -1;
+  if (__rhs.eback() != nullptr) {
+    __binp = __rhs.eback() - __p;
+    __ninp = __rhs.gptr() - __p;
+    __einp = __rhs.egptr() - __p;
+  }
+  ptrdiff_t __bout = -1;
+  ptrdiff_t __nout = -1;
+  ptrdiff_t __eout = -1;
+  if (__rhs.pbase() != nullptr) {
+    __bout = __rhs.pbase() - __p;
+    __nout = __rhs.pptr() - __p;
+    __eout = __rhs.epptr() - __p;
+  }
+  ptrdiff_t __hm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p;
+  __str_         = std::move(__rhs.__str_);
+  __p            = const_cast<char_type*>(__str_.data());
+  if (__binp != -1)
+    this->setg(__p + __binp, __p + __ninp, __p + __einp);
+  else
+    this->setg(nullptr, nullptr, nullptr);
+  if (__bout != -1) {
+    this->setp(__p + __bout, __p + __eout);
+    this->__pbump(__nout);
+  } else
+    this->setp(nullptr, nullptr);
 
-    __hm_ = __hm == -1 ? nullptr : __p + __hm;
-    __mode_ = __rhs.__mode_;
-    __p = const_cast<char_type*>(__rhs.__str_.data());
-    __rhs.setg(__p, __p, __p);
-    __rhs.setp(__p, __p);
-    __rhs.__hm_ = __p;
-    this->pubimbue(__rhs.getloc());
-    return *this;
+  __hm_   = __hm == -1 ? nullptr : __p + __hm;
+  __mode_ = __rhs.__mode_;
+  __p     = const_cast<char_type*>(__rhs.__str_.data());
+  __rhs.setg(__p, __p, __p);
+  __rhs.setp(__p, __p);
+  __rhs.__hm_ = __p;
+  this->pubimbue(__rhs.getloc());
+  return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-void
-basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs)
-{
-    char_type* __p = const_cast<char_type*>(__rhs.__str_.data());
-    ptrdiff_t __rbinp = -1;
-    ptrdiff_t __rninp = -1;
-    ptrdiff_t __reinp = -1;
-    if (__rhs.eback() != nullptr)
-    {
-        __rbinp = __rhs.eback() - __p;
-        __rninp = __rhs.gptr() - __p;
-        __reinp = __rhs.egptr() - __p;
-    }
-    ptrdiff_t __rbout = -1;
-    ptrdiff_t __rnout = -1;
-    ptrdiff_t __reout = -1;
-    if (__rhs.pbase() != nullptr)
-    {
-        __rbout = __rhs.pbase() - __p;
-        __rnout = __rhs.pptr() - __p;
-        __reout = __rhs.epptr() - __p;
-    }
-    ptrdiff_t __rhm = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p;
-    __p = const_cast<char_type*>(__str_.data());
-    ptrdiff_t __lbinp = -1;
-    ptrdiff_t __lninp = -1;
-    ptrdiff_t __leinp = -1;
-    if (this->eback() != nullptr)
-    {
-        __lbinp = this->eback() - __p;
-        __lninp = this->gptr() - __p;
-        __leinp = this->egptr() - __p;
-    }
-    ptrdiff_t __lbout = -1;
-    ptrdiff_t __lnout = -1;
-    ptrdiff_t __leout = -1;
-    if (this->pbase() != nullptr)
-    {
-        __lbout = this->pbase() - __p;
-        __lnout = this->pptr() - __p;
-        __leout = this->epptr() - __p;
-    }
-    ptrdiff_t __lhm = __hm_ == nullptr ? -1 : __hm_ - __p;
-    _VSTD::swap(__mode_, __rhs.__mode_);
-    __str_.swap(__rhs.__str_);
-    __p = const_cast<char_type*>(__str_.data());
-    if (__rbinp != -1)
-        this->setg(__p + __rbinp, __p + __rninp, __p + __reinp);
-    else
-        this->setg(nullptr, nullptr, nullptr);
-    if (__rbout != -1)
-    {
-        this->setp(__p + __rbout, __p + __reout);
-        this->__pbump(__rnout);
-    }
-    else
-        this->setp(nullptr, nullptr);
-    __hm_ = __rhm == -1 ? nullptr : __p + __rhm;
-    __p = const_cast<char_type*>(__rhs.__str_.data());
-    if (__lbinp != -1)
-        __rhs.setg(__p + __lbinp, __p + __lninp, __p + __leinp);
-    else
-        __rhs.setg(nullptr, nullptr, nullptr);
-    if (__lbout != -1)
-    {
-        __rhs.setp(__p + __lbout, __p + __leout);
-        __rhs.__pbump(__lnout);
-    }
-    else
-        __rhs.setp(nullptr, nullptr);
-    __rhs.__hm_ = __lhm == -1 ? nullptr : __p + __lhm;
-    locale __tl = __rhs.getloc();
-    __rhs.pubimbue(this->getloc());
-    this->pubimbue(__tl);
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
-     basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
-{
-    __x.swap(__y);
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-basic_string<_CharT, _Traits, _Allocator>
-basic_stringbuf<_CharT, _Traits, _Allocator>::str() const
-{
+void basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs)
 #if _LIBCPP_STD_VER >= 20
-    return string_type(view(), __str_.get_allocator());
-#else // _LIBCPP_STD_VER >= 20
-    if (__mode_ & ios_base::out)
-    {
-        if (__hm_ < this->pptr())
-            __hm_ = this->pptr();
-        return string_type(this->pbase(), __hm_, __str_.get_allocator());
-    }
-    else if (__mode_ & ios_base::in)
-        return string_type(this->eback(), this->egptr(), __str_.get_allocator());
-    return string_type(__str_.get_allocator());
-#endif // _LIBCPP_STD_VER >= 20
+    noexcept(allocator_traits<_Allocator>::propagate_on_container_swap::value ||
+             allocator_traits<_Allocator>::is_always_equal::value)
+#endif
+{
+  char_type* __p    = const_cast<char_type*>(__rhs.__str_.data());
+  ptrdiff_t __rbinp = -1;
+  ptrdiff_t __rninp = -1;
+  ptrdiff_t __reinp = -1;
+  if (__rhs.eback() != nullptr) {
+    __rbinp = __rhs.eback() - __p;
+    __rninp = __rhs.gptr() - __p;
+    __reinp = __rhs.egptr() - __p;
+  }
+  ptrdiff_t __rbout = -1;
+  ptrdiff_t __rnout = -1;
+  ptrdiff_t __reout = -1;
+  if (__rhs.pbase() != nullptr) {
+    __rbout = __rhs.pbase() - __p;
+    __rnout = __rhs.pptr() - __p;
+    __reout = __rhs.epptr() - __p;
+  }
+  ptrdiff_t __rhm   = __rhs.__hm_ == nullptr ? -1 : __rhs.__hm_ - __p;
+  __p               = const_cast<char_type*>(__str_.data());
+  ptrdiff_t __lbinp = -1;
+  ptrdiff_t __lninp = -1;
+  ptrdiff_t __leinp = -1;
+  if (this->eback() != nullptr) {
+    __lbinp = this->eback() - __p;
+    __lninp = this->gptr() - __p;
+    __leinp = this->egptr() - __p;
+  }
+  ptrdiff_t __lbout = -1;
+  ptrdiff_t __lnout = -1;
+  ptrdiff_t __leout = -1;
+  if (this->pbase() != nullptr) {
+    __lbout = this->pbase() - __p;
+    __lnout = this->pptr() - __p;
+    __leout = this->epptr() - __p;
+  }
+  ptrdiff_t __lhm = __hm_ == nullptr ? -1 : __hm_ - __p;
+  std::swap(__mode_, __rhs.__mode_);
+  __str_.swap(__rhs.__str_);
+  __p = const_cast<char_type*>(__str_.data());
+  if (__rbinp != -1)
+    this->setg(__p + __rbinp, __p + __rninp, __p + __reinp);
+  else
+    this->setg(nullptr, nullptr, nullptr);
+  if (__rbout != -1) {
+    this->setp(__p + __rbout, __p + __reout);
+    this->__pbump(__rnout);
+  } else
+    this->setp(nullptr, nullptr);
+  __hm_ = __rhm == -1 ? nullptr : __p + __rhm;
+  __p   = const_cast<char_type*>(__rhs.__str_.data());
+  if (__lbinp != -1)
+    __rhs.setg(__p + __lbinp, __p + __lninp, __p + __leinp);
+  else
+    __rhs.setg(nullptr, nullptr, nullptr);
+  if (__lbout != -1) {
+    __rhs.setp(__p + __lbout, __p + __leout);
+    __rhs.__pbump(__lnout);
+  } else
+    __rhs.setp(nullptr, nullptr);
+  __rhs.__hm_ = __lhm == -1 ? nullptr : __p + __lhm;
+  locale __tl = __rhs.getloc();
+  __rhs.pubimbue(this->getloc());
+  this->pubimbue(__tl);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-void
-basic_stringbuf<_CharT, _Traits, _Allocator>::str(const string_type& __s)
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x, basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
+#if _LIBCPP_STD_VER >= 20
+    noexcept(noexcept(__x.swap(__y)))
+#endif
 {
-    __str_ = __s;
-    __hm_ = nullptr;
-    if (__mode_ & ios_base::in)
-    {
-        __hm_ = const_cast<char_type*>(__str_.data()) + __str_.size();
-        this->setg(const_cast<char_type*>(__str_.data()),
-                   const_cast<char_type*>(__str_.data()),
-                   __hm_);
-    }
-    if (__mode_ & ios_base::out)
-    {
-        typename string_type::size_type __sz = __str_.size();
-        __hm_ = const_cast<char_type*>(__str_.data()) + __sz;
-        __str_.resize(__str_.capacity());
-        this->setp(const_cast<char_type*>(__str_.data()),
-                   const_cast<char_type*>(__str_.data()) + __str_.size());
-        if (__mode_ & (ios_base::app | ios_base::ate))
-        {
-            while (__sz > INT_MAX)
-            {
-                this->pbump(INT_MAX);
-                __sz -= INT_MAX;
-            }
-            if (__sz > 0)
-                this->pbump(__sz);
-        }
+  __x.swap(__y);
+}
+
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
+template <class _CharT, class _Traits, class _Allocator>
+basic_string<_CharT, _Traits, _Allocator> basic_stringbuf<_CharT, _Traits, _Allocator>::str() const {
+  if (__mode_ & ios_base::out) {
+    if (__hm_ < this->pptr())
+      __hm_ = this->pptr();
+    return string_type(this->pbase(), __hm_, __str_.get_allocator());
+  } else if (__mode_ & ios_base::in)
+    return string_type(this->eback(), this->egptr(), __str_.get_allocator());
+  return string_type(__str_.get_allocator());
+}
+#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI void basic_stringbuf<_CharT, _Traits, _Allocator>::__init_buf_ptrs() {
+  __hm_                                = nullptr;
+  char_type* __data                    = const_cast<char_type*>(__str_.data());
+  typename string_type::size_type __sz = __str_.size();
+  if (__mode_ & ios_base::in) {
+    __hm_ = __data + __sz;
+    this->setg(__data, __data, __hm_);
+  }
+  if (__mode_ & ios_base::out) {
+    __hm_ = __data + __sz;
+    __str_.resize(__str_.capacity());
+    this->setp(__data, __data + __str_.size());
+    if (__mode_ & (ios_base::app | ios_base::ate)) {
+      while (__sz > INT_MAX) {
+        this->pbump(INT_MAX);
+        __sz -= INT_MAX;
+      }
+      if (__sz > 0)
+        this->pbump(__sz);
     }
+  }
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI basic_string_view<_CharT, _Traits>
 basic_stringbuf<_CharT, _Traits, _Allocator>::view() const noexcept {
-    if (__mode_ & ios_base::out) {
-        if (__hm_ < this->pptr())
-            __hm_ = this->pptr();
-        return basic_string_view<_CharT, _Traits>(this->pbase(), __hm_);
-    } else if (__mode_ & ios_base::in)
-        return basic_string_view<_CharT, _Traits>(this->eback(), this->egptr());
-    return basic_string_view<_CharT, _Traits>();
+  if (__mode_ & ios_base::out) {
+    if (__hm_ < this->pptr())
+      __hm_ = this->pptr();
+    return basic_string_view<_CharT, _Traits>(this->pbase(), __hm_);
+  } else if (__mode_ & ios_base::in)
+    return basic_string_view<_CharT, _Traits>(this->eback(), this->egptr());
+  return basic_string_view<_CharT, _Traits>();
 }
 #endif // _LIBCPP_STD_VER >= 20
 
 template <class _CharT, class _Traits, class _Allocator>
 typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type
-basic_stringbuf<_CharT, _Traits, _Allocator>::underflow()
-{
-    if (__hm_ < this->pptr())
-        __hm_ = this->pptr();
-    if (__mode_ & ios_base::in)
-    {
-        if (this->egptr() < __hm_)
-            this->setg(this->eback(), this->gptr(), __hm_);
-        if (this->gptr() < this->egptr())
-            return traits_type::to_int_type(*this->gptr());
-    }
-    return traits_type::eof();
+basic_stringbuf<_CharT, _Traits, _Allocator>::underflow() {
+  if (__hm_ < this->pptr())
+    __hm_ = this->pptr();
+  if (__mode_ & ios_base::in) {
+    if (this->egptr() < __hm_)
+      this->setg(this->eback(), this->gptr(), __hm_);
+    if (this->gptr() < this->egptr())
+      return traits_type::to_int_type(*this->gptr());
+  }
+  return traits_type::eof();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type
-basic_stringbuf<_CharT, _Traits, _Allocator>::pbackfail(int_type __c)
-{
-    if (__hm_ < this->pptr())
-        __hm_ = this->pptr();
-    if (this->eback() < this->gptr())
-    {
-        if (traits_type::eq_int_type(__c, traits_type::eof()))
-        {
-            this->setg(this->eback(), this->gptr()-1, __hm_);
-            return traits_type::not_eof(__c);
-        }
-        if ((__mode_ & ios_base::out) ||
-            traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1]))
-        {
-            this->setg(this->eback(), this->gptr()-1, __hm_);
-            *this->gptr() = traits_type::to_char_type(__c);
-            return __c;
-        }
+basic_stringbuf<_CharT, _Traits, _Allocator>::pbackfail(int_type __c) {
+  if (__hm_ < this->pptr())
+    __hm_ = this->pptr();
+  if (this->eback() < this->gptr()) {
+    if (traits_type::eq_int_type(__c, traits_type::eof())) {
+      this->setg(this->eback(), this->gptr() - 1, __hm_);
+      return traits_type::not_eof(__c);
     }
-    return traits_type::eof();
+    if ((__mode_ & ios_base::out) || traits_type::eq(traits_type::to_char_type(__c), this->gptr()[-1])) {
+      this->setg(this->eback(), this->gptr() - 1, __hm_);
+      *this->gptr() = traits_type::to_char_type(__c);
+      return __c;
+    }
+  }
+  return traits_type::eof();
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 typename basic_stringbuf<_CharT, _Traits, _Allocator>::int_type
-basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
-{
-    if (!traits_type::eq_int_type(__c, traits_type::eof()))
-    {
-        ptrdiff_t __ninp = this->gptr()  - this->eback();
-        if (this->pptr() == this->epptr())
-        {
-            if (!(__mode_ & ios_base::out))
-                return traits_type::eof();
+basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c) {
+  if (!traits_type::eq_int_type(__c, traits_type::eof())) {
+    ptrdiff_t __ninp = this->gptr() - this->eback();
+    if (this->pptr() == this->epptr()) {
+      if (!(__mode_ & ios_base::out))
+        return traits_type::eof();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            try
-            {
+      try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-                ptrdiff_t __nout = this->pptr()  - this->pbase();
-                ptrdiff_t __hm = __hm_ - this->pbase();
-                __str_.push_back(char_type());
-                __str_.resize(__str_.capacity());
-                char_type* __p = const_cast<char_type*>(__str_.data());
-                this->setp(__p, __p + __str_.size());
-                this->__pbump(__nout);
-                __hm_ = this->pbase() + __hm;
+        ptrdiff_t __nout = this->pptr() - this->pbase();
+        ptrdiff_t __hm   = __hm_ - this->pbase();
+        __str_.push_back(char_type());
+        __str_.resize(__str_.capacity());
+        char_type* __p = const_cast<char_type*>(__str_.data());
+        this->setp(__p, __p + __str_.size());
+        this->__pbump(__nout);
+        __hm_ = this->pbase() + __hm;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            }
-            catch (...)
-            {
-                return traits_type::eof();
-            }
+      } catch (...) {
+        return traits_type::eof();
+      }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        __hm_ = _VSTD::max(this->pptr() + 1, __hm_);
-        if (__mode_ & ios_base::in)
-        {
-            char_type* __p = const_cast<char_type*>(__str_.data());
-            this->setg(__p, __p + __ninp, __hm_);
-        }
-        return this->sputc(traits_type::to_char_type(__c));
     }
-    return traits_type::not_eof(__c);
+    __hm_ = std::max(this->pptr() + 1, __hm_);
+    if (__mode_ & ios_base::in) {
+      char_type* __p = const_cast<char_type*>(__str_.data());
+      this->setg(__p, __p + __ninp, __hm_);
+    }
+    return this->sputc(traits_type::to_char_type(__c));
+  }
+  return traits_type::not_eof(__c);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-typename basic_stringbuf<_CharT, _Traits, _Allocator>::pos_type
-basic_stringbuf<_CharT, _Traits, _Allocator>::seekoff(off_type __off,
-                                                      ios_base::seekdir __way,
-                                                      ios_base::openmode __wch)
-{
-    if (__hm_ < this->pptr())
-        __hm_ = this->pptr();
-    if ((__wch & (ios_base::in | ios_base::out)) == 0)
-        return pos_type(-1);
-    if ((__wch & (ios_base::in | ios_base::out)) == (ios_base::in | ios_base::out)
-        && __way == ios_base::cur)
-        return pos_type(-1);
-    const ptrdiff_t __hm = __hm_ == nullptr ? 0 : __hm_ - __str_.data();
-    off_type __noff;
-    switch (__way)
-    {
-    case ios_base::beg:
-        __noff = 0;
-        break;
-    case ios_base::cur:
-        if (__wch & ios_base::in)
-            __noff = this->gptr() - this->eback();
-        else
-            __noff = this->pptr() - this->pbase();
-        break;
-    case ios_base::end:
-        __noff = __hm;
-        break;
-    default:
-        return pos_type(-1);
-    }
-    __noff += __off;
-    if (__noff < 0 || __hm < __noff)
-        return pos_type(-1);
-    if (__noff != 0)
-    {
-        if ((__wch & ios_base::in) && this->gptr() == nullptr)
-            return pos_type(-1);
-        if ((__wch & ios_base::out) && this->pptr() == nullptr)
-            return pos_type(-1);
-    }
+typename basic_stringbuf<_CharT, _Traits, _Allocator>::pos_type basic_stringbuf<_CharT, _Traits, _Allocator>::seekoff(
+    off_type __off, ios_base::seekdir __way, ios_base::openmode __wch) {
+  if (__hm_ < this->pptr())
+    __hm_ = this->pptr();
+  if ((__wch & (ios_base::in | ios_base::out)) == 0)
+    return pos_type(-1);
+  if ((__wch & (ios_base::in | ios_base::out)) == (ios_base::in | ios_base::out) && __way == ios_base::cur)
+    return pos_type(-1);
+  const ptrdiff_t __hm = __hm_ == nullptr ? 0 : __hm_ - __str_.data();
+  off_type __noff;
+  switch (__way) {
+  case ios_base::beg:
+    __noff = 0;
+    break;
+  case ios_base::cur:
     if (__wch & ios_base::in)
-        this->setg(this->eback(), this->eback() + __noff, __hm_);
-    if (__wch & ios_base::out)
-    {
-        this->setp(this->pbase(), this->epptr());
-        this->__pbump(__noff);
-    }
-    return pos_type(__noff);
+      __noff = this->gptr() - this->eback();
+    else
+      __noff = this->pptr() - this->pbase();
+    break;
+  case ios_base::end:
+    __noff = __hm;
+    break;
+  default:
+    return pos_type(-1);
+  }
+  __noff += __off;
+  if (__noff < 0 || __hm < __noff)
+    return pos_type(-1);
+  if (__noff != 0) {
+    if ((__wch & ios_base::in) && this->gptr() == nullptr)
+      return pos_type(-1);
+    if ((__wch & ios_base::out) && this->pptr() == nullptr)
+      return pos_type(-1);
+  }
+  if (__wch & ios_base::in)
+    this->setg(this->eback(), this->eback() + __noff, __hm_);
+  if (__wch & ios_base::out) {
+    this->setp(this->pbase(), this->epptr());
+    this->__pbump(__noff);
+  }
+  return pos_type(__noff);
 }
 
 // Class template basic_istringstream [istringstream]
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TEMPLATE_VIS basic_istringstream
-    : public basic_istream<_CharT, _Traits>
-{
+class _LIBCPP_TEMPLATE_VIS basic_istringstream : public basic_istream<_CharT, _Traits> {
 public:
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
-    typedef _Allocator                     allocator_type;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+  typedef _Allocator allocator_type;
 
-    typedef basic_string<char_type, traits_type, allocator_type> string_type;
+  typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
-    basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
+  basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
-    // [istringstream.cons] Constructors:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_istringstream()
-        : basic_istream<_CharT, _Traits>(&__sb_), __sb_(ios_base::in) {}
+  // [istringstream.cons] Constructors:
+  _LIBCPP_HIDE_FROM_ABI basic_istringstream() : basic_istream<_CharT, _Traits>(&__sb_), __sb_(ios_base::in) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_istringstream(ios_base::openmode __wch)
-        : basic_istream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::in) {}
+  _LIBCPP_HIDE_FROM_ABI explicit basic_istringstream(ios_base::openmode __wch)
+      : basic_istream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::in) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_istringstream(const string_type& __s,
-                                 ios_base::openmode __wch = ios_base::in)
-        : basic_istream<_CharT, _Traits>(&__sb_)
-        , __sb_(__s, __wch | ios_base::in)
-    { }
+  _LIBCPP_HIDE_FROM_ABI explicit basic_istringstream(const string_type& __s, ios_base::openmode __wch = ios_base::in)
+      : basic_istream<_CharT, _Traits>(&__sb_), __sb_(__s, __wch | ios_base::in) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_istringstream(basic_istringstream&& __rhs)
-        : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
-        , __sb_(_VSTD::move(__rhs.__sb_))
-    {
-        basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
-    }
-
-    // [istringstream.assign] Assign and swap:
-    basic_istringstream& operator=(basic_istringstream&& __rhs) {
-        basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
-        __sb_ = _VSTD::move(__rhs.__sb_);
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(basic_istringstream& __rhs) {
-        basic_istream<char_type, traits_type>::swap(__rhs);
-        __sb_.swap(__rhs.__sb_);
-    }
-
-    // [istringstream.members] Member functions:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
-        return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    string_type str() const {
-        return __sb_.str();
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    void str(const string_type& __s) {
-        __sb_.str(__s);
-    }
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    basic_string_view<char_type, traits_type> view() const noexcept {
-        return __sb_.view();
-    }
+  _LIBCPP_HIDE_FROM_ABI basic_istringstream(ios_base::openmode __wch, const _Allocator& __a)
+      : basic_istream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__wch | ios_base::in, __a) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_istringstream(string_type&& __s, ios_base::openmode __wch = ios_base::in)
+      : basic_istream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(std::move(__s), __wch | ios_base::in) {}
+
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s, const _Allocator& __a)
+      : basic_istringstream(__s, ios_base::in, __a) {}
+
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI basic_istringstream(
+      const basic_string<_CharT, _Traits, _SAlloc>& __s, ios_base::openmode __wch, const _Allocator& __a)
+      : basic_istream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__s, __wch | ios_base::in, __a) {}
+
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI explicit basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s,
+                                                     ios_base::openmode __wch = ios_base::in)
+      : basic_istream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__s, __wch | ios_base::in) {}
+#endif // _LIBCPP_STD_VER >= 20
+
+#if _LIBCPP_STD_VER >= 26
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI explicit basic_istringstream(const _Tp& __t, ios_base::openmode __which = ios_base::in)
+      : basic_istringstream(__t, __which, _Allocator()) {}
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI basic_istringstream(const _Tp& __t, const _Allocator& __a)
+      : basic_istringstream(__t, ios_base::in, __a) {}
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI basic_istringstream(const _Tp& __t, ios_base::openmode __which, const _Allocator& __a)
+      : basic_istream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__t, __which | ios_base::in, __a) {}
+
+#endif //  _LIBCPP_STD_VER >= 26
+
+  basic_istringstream(const basic_istringstream&) = delete;
+  _LIBCPP_HIDE_FROM_ABI basic_istringstream(basic_istringstream&& __rhs)
+      : basic_istream<_CharT, _Traits>(std::move(__rhs)), __sb_(std::move(__rhs.__sb_)) {
+    basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
+  }
+
+  // [istringstream.assign] Assign and swap:
+  basic_istringstream& operator=(const basic_istringstream&) = delete;
+  basic_istringstream& operator=(basic_istringstream&& __rhs) {
+    basic_istream<char_type, traits_type>::operator=(std::move(__rhs));
+    __sb_ = std::move(__rhs.__sb_);
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI void swap(basic_istringstream& __rhs) {
+    basic_istream<char_type, traits_type>::swap(__rhs);
+    __sb_.swap(__rhs.__sb_);
+  }
+
+  // [istringstream.members] Member functions:
+  _LIBCPP_HIDE_FROM_ABI basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
+    return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
+  }
+
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
+  _LIBCPP_HIDE_FROM_ABI string_type str() const { return __sb_.str(); }
+#else
+  _LIBCPP_HIDE_FROM_ABI string_type str() const& { return __sb_.str(); }
+
+  _LIBCPP_HIDE_FROM_ABI string_type str() && { return std::move(__sb_).str(); }
 #endif
+
+#if _LIBCPP_STD_VER >= 20
+  template <class _SAlloc>
+    requires __is_allocator<_SAlloc>::value
+  _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+    return __sb_.str(__sa);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept { return __sb_.view(); }
+#endif // _LIBCPP_STD_VER >= 20
+
+  _LIBCPP_HIDE_FROM_ABI void str(const string_type& __s) { __sb_.str(__s); }
+
+#if _LIBCPP_STD_VER >= 20
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI void str(const basic_string<char_type, traits_type, _SAlloc>& __s) {
+    __sb_.str(__s);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void str(string_type&& __s) { __sb_.str(std::move(__s)); }
+#endif // _LIBCPP_STD_VER >= 20
+
+#if _LIBCPP_STD_VER >= 26
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI void str(const _Tp& __t) {
+    rdbuf()->str(__t);
+  }
+#endif //  _LIBCPP_STD_VER >= 26
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
-     basic_istringstream<_CharT, _Traits, _Allocator>& __y)
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x, basic_istringstream<_CharT, _Traits, _Allocator>& __y) {
+  __x.swap(__y);
 }
 
 // Class template basic_ostringstream [ostringstream]
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TEMPLATE_VIS basic_ostringstream
-    : public basic_ostream<_CharT, _Traits>
-{
+class _LIBCPP_TEMPLATE_VIS basic_ostringstream : public basic_ostream<_CharT, _Traits> {
 public:
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
-    typedef _Allocator                     allocator_type;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+  typedef _Allocator allocator_type;
 
-    typedef basic_string<char_type, traits_type, allocator_type> string_type;
+  typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
-    basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
+  basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
-    // [ostringstream.cons] Constructors:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostringstream()
-        : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(ios_base::out) {}
+  // [ostringstream.cons] Constructors:
+  _LIBCPP_HIDE_FROM_ABI basic_ostringstream() : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(ios_base::out) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ostringstream(ios_base::openmode __wch)
-        : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::out) {}
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ostringstream(ios_base::openmode __wch)
+      : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(__wch | ios_base::out) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_ostringstream(const string_type& __s,
-                                 ios_base::openmode __wch = ios_base::out)
-        : basic_ostream<_CharT, _Traits>(&__sb_)
-        , __sb_(__s, __wch | ios_base::out)
-    { }
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ostringstream(const string_type& __s, ios_base::openmode __wch = ios_base::out)
+      : basic_ostream<_CharT, _Traits>(&__sb_), __sb_(__s, __wch | ios_base::out) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_ostringstream(basic_ostringstream&& __rhs)
-        : basic_ostream<_CharT, _Traits>(_VSTD::move(__rhs))
-        , __sb_(_VSTD::move(__rhs.__sb_))
-    {
-        basic_ostream<_CharT, _Traits>::set_rdbuf(&__sb_);
-    }
-
-    // [ostringstream.assign] Assign and swap:
-    basic_ostringstream& operator=(basic_ostringstream&& __rhs) {
-        basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
-        __sb_ = _VSTD::move(__rhs.__sb_);
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(basic_ostringstream& __rhs) {
-        basic_ostream<char_type, traits_type>::swap(__rhs);
-        __sb_.swap(__rhs.__sb_);
-    }
-
-    // [ostringstream.members] Member functions:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
-        return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    string_type str() const {
-        return __sb_.str();
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    void str(const string_type& __s) {
-        __sb_.str(__s);
-    }
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    basic_string_view<char_type, traits_type> view() const noexcept {
-        return __sb_.view();
-    }
+  _LIBCPP_HIDE_FROM_ABI basic_ostringstream(ios_base::openmode __wch, const _Allocator& __a)
+      : basic_ostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__wch | ios_base::out, __a) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ostringstream(string_type&& __s, ios_base::openmode __wch = ios_base::out)
+      : basic_ostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(std::move(__s), __wch | ios_base::out) {}
+
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s, const _Allocator& __a)
+      : basic_ostringstream(__s, ios_base::out, __a) {}
+
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI basic_ostringstream(
+      const basic_string<_CharT, _Traits, _SAlloc>& __s, ios_base::openmode __wch, const _Allocator& __a)
+      : basic_ostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__s, __wch | ios_base::out, __a) {}
+
+  template <class _SAlloc>
+    requires(!is_same_v<_SAlloc, allocator_type>)
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s,
+                                                     ios_base::openmode __wch = ios_base::out)
+      : basic_ostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__s, __wch | ios_base::out) {}
+#endif // _LIBCPP_STD_VER >= 20
+
+#if _LIBCPP_STD_VER >= 26
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ostringstream(const _Tp& __t, ios_base::openmode __which = ios_base::out)
+      : basic_ostringstream(__t, __which | ios_base::out, _Allocator()) {}
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI basic_ostringstream(const _Tp& __t, const _Allocator& __a)
+      : basic_ostringstream(__t, ios_base::out, __a) {}
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI basic_ostringstream(const _Tp& __t, ios_base::openmode __which, const _Allocator& __a)
+      : basic_ostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__t, __which | ios_base::out, __a) {}
+
+#endif //  _LIBCPP_STD_VER >= 26
+
+  basic_ostringstream(const basic_ostringstream&) = delete;
+  _LIBCPP_HIDE_FROM_ABI basic_ostringstream(basic_ostringstream&& __rhs)
+      : basic_ostream<_CharT, _Traits>(std::move(__rhs)), __sb_(std::move(__rhs.__sb_)) {
+    basic_ostream<_CharT, _Traits>::set_rdbuf(&__sb_);
+  }
+
+  // [ostringstream.assign] Assign and swap:
+  basic_ostringstream& operator=(const basic_ostringstream&) = delete;
+  basic_ostringstream& operator=(basic_ostringstream&& __rhs) {
+    basic_ostream<char_type, traits_type>::operator=(std::move(__rhs));
+    __sb_ = std::move(__rhs.__sb_);
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(basic_ostringstream& __rhs) {
+    basic_ostream<char_type, traits_type>::swap(__rhs);
+    __sb_.swap(__rhs.__sb_);
+  }
+
+  // [ostringstream.members] Member functions:
+  _LIBCPP_HIDE_FROM_ABI basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
+    return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
+  }
+
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
+  _LIBCPP_HIDE_FROM_ABI string_type str() const { return __sb_.str(); }
+#else
+  _LIBCPP_HIDE_FROM_ABI string_type str() const& { return __sb_.str(); }
+
+  _LIBCPP_HIDE_FROM_ABI string_type str() && { return std::move(__sb_).str(); }
 #endif
+
+#if _LIBCPP_STD_VER >= 20
+  template <class _SAlloc>
+    requires __is_allocator<_SAlloc>::value
+  _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+    return __sb_.str(__sa);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept { return __sb_.view(); }
+#endif // _LIBCPP_STD_VER >= 20
+
+  _LIBCPP_HIDE_FROM_ABI void str(const string_type& __s) { __sb_.str(__s); }
+
+#if _LIBCPP_STD_VER >= 20
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI void str(const basic_string<char_type, traits_type, _SAlloc>& __s) {
+    __sb_.str(__s);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void str(string_type&& __s) { __sb_.str(std::move(__s)); }
+#endif // _LIBCPP_STD_VER >= 20
+
+#if _LIBCPP_STD_VER >= 26
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI void str(const _Tp& __t) {
+    rdbuf()->str(__t);
+  }
+#endif //  _LIBCPP_STD_VER >= 26
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
-     basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x, basic_ostringstream<_CharT, _Traits, _Allocator>& __y) {
+  __x.swap(__y);
 }
 
 // Class template basic_stringstream [stringstream]
 
 template <class _CharT, class _Traits, class _Allocator>
-class _LIBCPP_TEMPLATE_VIS basic_stringstream
-    : public basic_iostream<_CharT, _Traits>
-{
+class _LIBCPP_TEMPLATE_VIS basic_stringstream : public basic_iostream<_CharT, _Traits> {
 public:
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
-    typedef _Allocator                     allocator_type;
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+  typedef _Allocator allocator_type;
 
-    typedef basic_string<char_type, traits_type, allocator_type> string_type;
+  typedef basic_string<char_type, traits_type, allocator_type> string_type;
 
 private:
-    basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
+  basic_stringbuf<char_type, traits_type, allocator_type> __sb_;
 
 public:
-    // [stringstream.cons] constructors
-    _LIBCPP_INLINE_VISIBILITY
-    basic_stringstream()
-        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(ios_base::in | ios_base::out) {}
+  // [stringstream.cons] constructors
+  _LIBCPP_HIDE_FROM_ABI basic_stringstream()
+      : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(ios_base::in | ios_base::out) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_stringstream(ios_base::openmode __wch)
-        : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__wch) {}
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringstream(ios_base::openmode __wch)
+      : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__wch) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit basic_stringstream(const string_type& __s,
-                                ios_base::openmode __wch = ios_base::in | ios_base::out)
-        : basic_iostream<_CharT, _Traits>(&__sb_)
-        , __sb_(__s, __wch)
-    { }
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringstream(const string_type& __s,
+                                                    ios_base::openmode __wch = ios_base::in | ios_base::out)
+      : basic_iostream<_CharT, _Traits>(&__sb_), __sb_(__s, __wch) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_stringstream(basic_stringstream&& __rhs)
-        : basic_iostream<_CharT, _Traits>(_VSTD::move(__rhs))
-        , __sb_(_VSTD::move(__rhs.__sb_))
-    {
-        basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
-    }
-
-    // [stringstream.assign] Assign and swap:
-    basic_stringstream& operator=(basic_stringstream&& __rhs) {
-        basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
-        __sb_ = _VSTD::move(__rhs.__sb_);
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(basic_stringstream& __rhs) {
-        basic_iostream<char_type, traits_type>::swap(__rhs);
-        __sb_.swap(__rhs.__sb_);
-    }
-
-    // [stringstream.members] Member functions:
-    _LIBCPP_INLINE_VISIBILITY
-    basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
-        return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    string_type str() const {
-        return __sb_.str();
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    void str(const string_type& __s) {
-        __sb_.str(__s);
-    }
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    basic_string_view<char_type, traits_type> view() const noexcept {
-        return __sb_.view();
-    }
+  _LIBCPP_HIDE_FROM_ABI basic_stringstream(ios_base::openmode __wch, const _Allocator& __a)
+      : basic_iostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__wch, __a) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringstream(string_type&& __s,
+                                                    ios_base::openmode __wch = ios_base::out | ios_base::in)
+      : basic_iostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(std::move(__s), __wch) {}
+
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s, const _Allocator& __a)
+      : basic_stringstream(__s, ios_base::out | ios_base::in, __a) {}
+
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI
+  basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s, ios_base::openmode __wch, const _Allocator& __a)
+      : basic_iostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__s, __wch, __a) {}
+
+  template <class _SAlloc>
+    requires(!is_same_v<_SAlloc, allocator_type>)
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __s,
+                                                    ios_base::openmode __wch = ios_base::out | ios_base::in)
+      : basic_iostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__s, __wch) {}
+#endif // _LIBCPP_STD_VER >= 20
+
+#if _LIBCPP_STD_VER >= 26
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI explicit basic_stringstream(const _Tp& __t,
+                                                    ios_base::openmode __which = ios_base::out | ios_base::in)
+      : basic_stringstream(__t, __which, _Allocator()) {}
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI basic_stringstream(const _Tp& __t, const _Allocator& __a)
+      : basic_stringstream(__t, ios_base::out | ios_base::in, __a) {}
+
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI basic_stringstream(const _Tp& __t, ios_base::openmode __which, const _Allocator& __a)
+      : basic_iostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__t, __which, __a) {}
+
+#endif //  _LIBCPP_STD_VER >= 26
+
+  basic_stringstream(const basic_stringstream&) = delete;
+  _LIBCPP_HIDE_FROM_ABI basic_stringstream(basic_stringstream&& __rhs)
+      : basic_iostream<_CharT, _Traits>(std::move(__rhs)), __sb_(std::move(__rhs.__sb_)) {
+    basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
+  }
+
+  // [stringstream.assign] Assign and swap:
+  basic_stringstream& operator=(const basic_stringstream&) = delete;
+  basic_stringstream& operator=(basic_stringstream&& __rhs) {
+    basic_iostream<char_type, traits_type>::operator=(std::move(__rhs));
+    __sb_ = std::move(__rhs.__sb_);
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI void swap(basic_stringstream& __rhs) {
+    basic_iostream<char_type, traits_type>::swap(__rhs);
+    __sb_.swap(__rhs.__sb_);
+  }
+
+  // [stringstream.members] Member functions:
+  _LIBCPP_HIDE_FROM_ABI basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
+    return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(&__sb_);
+  }
+
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
+  _LIBCPP_HIDE_FROM_ABI string_type str() const { return __sb_.str(); }
+#else
+  _LIBCPP_HIDE_FROM_ABI string_type str() const& { return __sb_.str(); }
+
+  _LIBCPP_HIDE_FROM_ABI string_type str() && { return std::move(__sb_).str(); }
 #endif
+
+#if _LIBCPP_STD_VER >= 20
+  template <class _SAlloc>
+    requires __is_allocator<_SAlloc>::value
+  _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+    return __sb_.str(__sa);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept { return __sb_.view(); }
+#endif // _LIBCPP_STD_VER >= 20
+
+  _LIBCPP_HIDE_FROM_ABI void str(const string_type& __s) { __sb_.str(__s); }
+
+#if _LIBCPP_STD_VER >= 20
+  template <class _SAlloc>
+  _LIBCPP_HIDE_FROM_ABI void str(const basic_string<char_type, traits_type, _SAlloc>& __s) {
+    __sb_.str(__s);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void str(string_type&& __s) { __sb_.str(std::move(__s)); }
+#endif // _LIBCPP_STD_VER >= 20
+
+#if _LIBCPP_STD_VER >= 26
+  template <class _Tp>
+    requires is_convertible_v<const _Tp&, basic_string_view<_CharT, _Traits>>
+  _LIBCPP_HIDE_FROM_ABI void str(const _Tp& __t) {
+    rdbuf()->str(__t);
+  }
+#endif //  _LIBCPP_STD_VER >= 26
 };
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
-     basic_stringstream<_CharT, _Traits, _Allocator>& __y)
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x, basic_stringstream<_CharT, _Traits, _Allocator>& __y) {
+  __x.swap(__y);
 }
 
-#if defined(_LIBCPP_ABI_ENABLE_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1)
+#if _LIBCPP_AVAILABILITY_HAS_ADDITIONAL_IOSTREAM_EXPLICIT_INSTANTIATIONS_1
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_stringbuf<char>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_stringstream<char>;
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostringstream<char>;
@@ -921,7 +1268,8 @@ _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
-#if _LIBCPP_STD_VER <= 20 && !defined(_LIPCPP_REMOVE_TRANSITIVE_INCLUDES)
+#if _LIBCPP_STD_VER <= 20 && !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES)
+#  include <ostream>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/stack b/third_party/libcxx/stack
index 93bed1555..90f8933cc 100644
--- a/third_party/libcxx/stack
+++ b/third_party/libcxx/stack
@@ -42,6 +42,7 @@ public:
     explicit stack(const container_type& c);
     explicit stack(container_type&& c);
     template <class InputIterator> stack(InputIterator first, InputIterator last); // since C++23
+    template<container-compatible-range<T> R> stack(from_range_t, R&& rg); // since C++23
     template <class Alloc> explicit stack(const Alloc& a);
     template <class Alloc> stack(const container_type& c, const Alloc& a);
     template <class Alloc> stack(container_type&& c, const Alloc& a);
@@ -49,6 +50,8 @@ public:
     template <class Alloc> stack(stack&& c, const Alloc& a);
     template<class InputIterator, class Alloc>
     stack(InputIterator first, InputIterator last, const Alloc&); // since C++23
+    template<container-compatible-range<T> R, class Alloc>
+      stack(from_range_t, R&& rg, const Alloc&); // since C++23
 
     bool empty() const;
     size_type size() const;
@@ -57,6 +60,8 @@ public:
 
     void push(const value_type& x);
     void push(value_type&& x);
+    template<container-compatible-range<T> R>
+      void push_range(R&& rg); // C++23
     template <class... Args> reference emplace(Args&&... args); // reference in C++17
     void pop();
 
@@ -69,6 +74,9 @@ template<class Container>
 template<class InputIterator>
   stack(InputIterator, InputIterator) -> stack<iter-value-type<InputIterator>>; // since C++23
 
+template<ranges::input_range R>
+  stack(from_range_t, R&&) -> stack<ranges::range_value_t<R>>; // since C++23
+
 template<class Container, class Allocator>
   stack(Container, Allocator) -> stack<typename Container::value_type, Container>; // C++17
 
@@ -77,6 +85,10 @@ template<class InputIterator, class Allocator>
     -> stack<iter-value-type<InputIterator>,
              deque<iter-value-type<InputIterator>, Allocator>>; // since C++23
 
+template<ranges::input_range R, class Allocator>
+  stack(from_range_t, R&&, Allocator)
+    -> stack<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>; // since C++23
+
 template <class T, class Container>
   bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
 template <class T, class Container>
@@ -89,6 +101,9 @@ template <class T, class Container>
   bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
 template <class T, class Container>
   bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
+template<class T, three_way_comparable Container>
+  compare_three_way_result_t<Container>
+    operator<=>(const stack<T, Container>& x, const stack<T, Container>& y); // since C++20
 
 template <class T, class Container>
   void swap(stack<T, Container>& x, stack<T, Container>& y)
@@ -98,10 +113,16 @@ template <class T, class Container>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__algorithm/ranges_copy.h>
 #include <__config>
+#include <__fwd/stack.h>
+#include <__iterator/back_insert_iterator.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/uses_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/is_same.h>
 #include <__utility/forward.h>
 #include <deque>
@@ -117,252 +138,238 @@ template <class T, class Container>
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, class _Container = deque<_Tp> > class _LIBCPP_TEMPLATE_VIS stack;
+template <class _Tp, class _Container>
+_LIBCPP_HIDE_FROM_ABI bool operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
-
-template <class _Tp, class _Container>
-_LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
+_LIBCPP_HIDE_FROM_ABI bool operator<(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y);
 
 template <class _Tp, class _Container /*= deque<_Tp>*/>
-class _LIBCPP_TEMPLATE_VIS stack
-{
+class _LIBCPP_TEMPLATE_VIS stack {
 public:
-    typedef _Container                               container_type;
-    typedef typename container_type::value_type      value_type;
-    typedef typename container_type::reference       reference;
-    typedef typename container_type::const_reference const_reference;
-    typedef typename container_type::size_type       size_type;
-    static_assert((is_same<_Tp, value_type>::value), "" );
+  typedef _Container container_type;
+  typedef typename container_type::value_type value_type;
+  typedef typename container_type::reference reference;
+  typedef typename container_type::const_reference const_reference;
+  typedef typename container_type::size_type size_type;
+  static_assert(is_same<_Tp, value_type>::value, "");
 
 protected:
-    container_type c;
+  container_type c;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    stack()
-        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
-        : c() {}
+  _LIBCPP_HIDE_FROM_ABI stack() _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value) : c() {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    stack(const stack& __q) : c(__q.c) {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    stack& operator=(const stack& __q) {c = __q.c; return *this;}
+  _LIBCPP_HIDE_FROM_ABI stack(const stack& __q) : c(__q.c) {}
 
+  _LIBCPP_HIDE_FROM_ABI stack& operator=(const stack& __q) {
+    c = __q.c;
+    return *this;
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    stack(stack&& __q)
-        _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
-        : c(_VSTD::move(__q.c)) {}
+  _LIBCPP_HIDE_FROM_ABI stack(stack&& __q) noexcept(is_nothrow_move_constructible<container_type>::value)
+      : c(std::move(__q.c)) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    stack& operator=(stack&& __q)
-        _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
-        {c = _VSTD::move(__q.c); return *this;}
+  _LIBCPP_HIDE_FROM_ABI stack& operator=(stack&& __q) noexcept(is_nothrow_move_assignable<container_type>::value) {
+    c = std::move(__q.c);
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit stack(container_type&& __c) : c(_VSTD::move(__c)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit stack(container_type&& __c) : c(std::move(__c)) {}
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit stack(const container_type& __c) : c(__c) {}
+  _LIBCPP_HIDE_FROM_ABI explicit stack(const container_type& __c) : c(__c) {}
 
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        explicit stack(const _Alloc& __a,
-                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
-            : c(__a) {}
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        stack(const container_type& __c, const _Alloc& __a,
-              __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
-            : c(__c, __a) {}
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        stack(const stack& __s, const _Alloc& __a,
-              __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
-            : c(__s.c, __a) {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI explicit stack(const _Alloc& __a,
+                                       __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
+      : c(__a) {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI
+  stack(const container_type& __c, const _Alloc& __a, __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
+      : c(__c, __a) {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI
+  stack(const stack& __s, const _Alloc& __a, __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
+      : c(__s.c, __a) {}
 #ifndef _LIBCPP_CXX03_LANG
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        stack(container_type&& __c, const _Alloc& __a,
-              __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
-            : c(_VSTD::move(__c), __a) {}
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
-        stack(stack&& __s, const _Alloc& __a,
-              __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
-            : c(_VSTD::move(__s.c), __a) {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI
+  stack(container_type&& __c, const _Alloc& __a, __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
+      : c(std::move(__c), __a) {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI
+  stack(stack&& __s, const _Alloc& __a, __enable_if_t<uses_allocator<container_type, _Alloc>::value>* = 0)
+      : c(std::move(__s.c), __a) {}
 #endif // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER >= 23
-    template <class _InputIterator,
-              class = __enable_if_t<__has_input_iterator_category<_InputIterator>::value>>
-    _LIBCPP_HIDE_FROM_ABI
-    stack(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
+  template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI stack(_InputIterator __first, _InputIterator __last) : c(__first, __last) {}
+
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI stack(from_range_t, _Range&& __range) : c(from_range, std::forward<_Range>(__range)) {}
+
+  template <class _InputIterator,
+            class _Alloc,
+            __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0,
+            __enable_if_t<uses_allocator<container_type, _Alloc>::value, int>        = 0>
+  _LIBCPP_HIDE_FROM_ABI stack(_InputIterator __first, _InputIterator __last, const _Alloc& __alloc)
+      : c(__first, __last, __alloc) {}
+
+  template <_ContainerCompatibleRange<_Tp> _Range,
+            class _Alloc,
+            __enable_if_t<uses_allocator<container_type, _Alloc>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI stack(from_range_t, _Range&& __range, const _Alloc& __alloc)
+      : c(from_range, std::forward<_Range>(__range), __alloc) {}
 
-    template <class _InputIterator,
-              class _Alloc,
-              class = __enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-              class = __enable_if_t<uses_allocator<container_type, _Alloc>::value>>
-    _LIBCPP_HIDE_FROM_ABI
-    stack(_InputIterator __first, _InputIterator __last, const _Alloc& __alloc) : c(__first, __last, __alloc) {}
 #endif
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool empty()     const      {return c.empty();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const      {return c.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    reference top()             {return c.back();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reference top() const {return c.back();}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }
+  _LIBCPP_HIDE_FROM_ABI reference top() { return c.back(); }
+  _LIBCPP_HIDE_FROM_ABI const_reference top() const { return c.back(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void push(const value_type& __v) {c.push_back(__v);}
+  _LIBCPP_HIDE_FROM_ABI void push(const value_type& __v) { c.push_back(__v); }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
+  _LIBCPP_HIDE_FROM_ABI void push(value_type&& __v) { c.push_back(std::move(__v)); }
 
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-#if _LIBCPP_STD_VER >= 17
-        decltype(auto) emplace(_Args&&... __args)
-        { return c.emplace_back(_VSTD::forward<_Args>(__args)...);}
-#else
-        void      emplace(_Args&&... __args)
-        {        c.emplace_back(_VSTD::forward<_Args>(__args)...);}
-#endif
+#  if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI void push_range(_Range&& __range) {
+    if constexpr (requires(container_type& __c) { __c.append_range(std::forward<_Range>(__range)); }) {
+      c.append_range(std::forward<_Range>(__range));
+    } else {
+      ranges::copy(std::forward<_Range>(__range), std::back_inserter(c));
+    }
+  }
+#  endif
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI
+#  if _LIBCPP_STD_VER >= 17
+  decltype(auto)
+  emplace(_Args&&... __args) {
+    return c.emplace_back(std::forward<_Args>(__args)...);
+  }
+#  else
+  void
+  emplace(_Args&&... __args) {
+    c.emplace_back(std::forward<_Args>(__args)...);
+  }
+#  endif
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    void pop() {c.pop_back();}
+  _LIBCPP_HIDE_FROM_ABI void pop() { c.pop_back(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(stack& __s)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
-    {
-        using _VSTD::swap;
-        swap(c, __s.c);
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(stack& __s) _NOEXCEPT_(__is_nothrow_swappable_v<container_type>) {
+    using std::swap;
+    swap(c, __s.c);
+  }
 
-    _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI const _Container& __get_container() const { return c; }
 
-    template <class T1, class _C1>
-    friend
-    bool
-    operator==(const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
+  template <class _T1, class _OtherContainer>
+  friend bool operator==(const stack<_T1, _OtherContainer>& __x, const stack<_T1, _OtherContainer>& __y);
 
-    template <class T1, class _C1>
-    friend
-    bool
-    operator< (const stack<T1, _C1>& __x, const stack<T1, _C1>& __y);
+  template <class _T1, class _OtherContainer>
+  friend bool operator<(const stack<_T1, _OtherContainer>& __x, const stack<_T1, _OtherContainer>& __y);
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _Container,
-         class = enable_if_t<!__is_allocator<_Container>::value>
->
-stack(_Container)
-    -> stack<typename _Container::value_type, _Container>;
+template <class _Container, class = enable_if_t<!__is_allocator<_Container>::value> >
+stack(_Container) -> stack<typename _Container::value_type, _Container>;
 
-template<class _Container,
-         class _Alloc,
-         class = enable_if_t<!__is_allocator<_Container>::value>,
-         class = enable_if_t<uses_allocator<_Container, _Alloc>::value>
-         >
-stack(_Container, _Alloc)
-    -> stack<typename _Container::value_type, _Container>;
+template <class _Container,
+          class _Alloc,
+          class = enable_if_t<!__is_allocator<_Container>::value>,
+          class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
+stack(_Container, _Alloc) -> stack<typename _Container::value_type, _Container>;
 #endif
 
 #if _LIBCPP_STD_VER >= 23
-template<class _InputIterator,
-         class = __enable_if_t<__has_input_iterator_category<_InputIterator>::value>>
-stack(_InputIterator, _InputIterator)
-    -> stack<__iter_value_type<_InputIterator>>;
+template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
+stack(_InputIterator, _InputIterator) -> stack<__iter_value_type<_InputIterator>>;
+
+template <ranges::input_range _Range>
+stack(from_range_t, _Range&&) -> stack<ranges::range_value_t<_Range>>;
+
+template <class _InputIterator,
+          class _Alloc,
+          __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0,
+          __enable_if_t<__is_allocator<_Alloc>::value, int>                        = 0>
+stack(_InputIterator,
+      _InputIterator,
+      _Alloc) -> stack<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;
+
+template <ranges::input_range _Range, class _Alloc, __enable_if_t<__is_allocator<_Alloc>::value, int> = 0>
+stack(from_range_t,
+      _Range&&,
+      _Alloc) -> stack<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
 
-template<class _InputIterator,
-         class _Alloc,
-         class = __enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = __enable_if_t<__is_allocator<_Alloc>::value>>
-stack(_InputIterator, _InputIterator, _Alloc)
-    -> stack<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;
 #endif
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
-{
-    return __x.c == __y.c;
+inline _LIBCPP_HIDE_FROM_ABI bool operator==(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) {
+  return __x.c == __y.c;
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator< (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
-{
-    return __x.c < __y.c;
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) {
+  return __x.c < __y.c;
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) {
+  return !(__x == __y);
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator> (const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) {
+  return __y < __x;
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator>=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) {
+  return !(__x < __y);
 }
 
 template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y)
-{
-    return !(__y < __x);
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) {
+  return !(__y < __x);
 }
 
-template <class _Tp, class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
-__enable_if_t<__is_swappable<_Container>::value, void>
-swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Tp, three_way_comparable _Container>
+_LIBCPP_HIDE_FROM_ABI compare_three_way_result_t<_Container>
+operator<=>(const stack<_Tp, _Container>& __x, const stack<_Tp, _Container>& __y) {
+  // clang 16 bug: declaring `friend operator<=>` causes "use of overloaded operator '*' is ambiguous" errors
+  return __x.__get_container() <=> __y.__get_container();
+}
+
+#endif
+
+template <class _Tp, class _Container, __enable_if_t<__is_swappable_v<_Container>, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI void swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 template <class _Tp, class _Container, class _Alloc>
-struct _LIBCPP_TEMPLATE_VIS uses_allocator<stack<_Tp, _Container>, _Alloc>
-    : public uses_allocator<_Container, _Alloc>
-{
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<stack<_Tp, _Container>, _Alloc> : public uses_allocator<_Container, _Alloc> {
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <functional>
diff --git a/third_party/libcxx/std_stream.h b/third_party/libcxx/std_stream.h
new file mode 100644
index 000000000..e55cd0b6b
--- /dev/null
+++ b/third_party/libcxx/std_stream.h
@@ -0,0 +1,387 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_STD_STREAM_H
+#define _LIBCPP_STD_STREAM_H
+
+#include <__config>
+#include <__locale>
+#include <cstdio>
+#include <istream>
+#include <ostream>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+static const int __limit = 8;
+
+// __stdinbuf
+
+template <class _CharT>
+class _LIBCPP_HIDDEN __stdinbuf : public basic_streambuf<_CharT, char_traits<_CharT> > {
+public:
+  typedef _CharT char_type;
+  typedef char_traits<char_type> traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+  typedef typename traits_type::state_type state_type;
+
+  __stdinbuf(FILE* __fp, state_type* __st);
+
+protected:
+  virtual int_type underflow();
+  virtual int_type uflow();
+  virtual int_type pbackfail(int_type __c = traits_type::eof());
+  virtual void imbue(const locale& __loc);
+
+private:
+  FILE* __file_;
+  const codecvt<char_type, char, state_type>* __cv_;
+  state_type* __st_;
+  int __encoding_;
+  int_type __last_consumed_;
+  bool __last_consumed_is_next_;
+  bool __always_noconv_;
+
+#if defined(_LIBCPP_WIN32API)
+  static constexpr bool __is_win32api_wide_char = !is_same_v<_CharT, char>;
+#else
+  static constexpr bool __is_win32api_wide_char = false;
+#endif
+
+  __stdinbuf(const __stdinbuf&);
+  __stdinbuf& operator=(const __stdinbuf&);
+
+  int_type __getchar(bool __consume);
+};
+
+template <class _CharT>
+__stdinbuf<_CharT>::__stdinbuf(FILE* __fp, state_type* __st)
+    : __file_(__fp), __st_(__st), __last_consumed_(traits_type::eof()), __last_consumed_is_next_(false) {
+  imbue(this->getloc());
+  // On Windows, in wchar_t mode, ignore the codecvt from the locale by
+  // default and assume noconv; this passes wchar_t through unmodified from
+  // getwc. If the user sets a custom locale with imbue(), that gets honored,
+  // the IO is done with getc() and converted with the provided codecvt.
+  if constexpr (__is_win32api_wide_char)
+    __always_noconv_ = true;
+}
+
+template <class _CharT>
+void __stdinbuf<_CharT>::imbue(const locale& __loc) {
+  __cv_            = &use_facet<codecvt<char_type, char, state_type> >(__loc);
+  __encoding_      = __cv_->encoding();
+  __always_noconv_ = __cv_->always_noconv();
+  if (__encoding_ > __limit)
+    __throw_runtime_error("unsupported locale for standard input");
+}
+
+template <class _CharT>
+typename __stdinbuf<_CharT>::int_type __stdinbuf<_CharT>::underflow() {
+  return __getchar(false);
+}
+
+template <class _CharT>
+typename __stdinbuf<_CharT>::int_type __stdinbuf<_CharT>::uflow() {
+  return __getchar(true);
+}
+
+inline bool __do_getc(FILE* __fp, char* __pbuf) {
+  int __c = getc(__fp);
+  if (__c == EOF)
+    return false;
+  *__pbuf = static_cast<char>(__c);
+  return true;
+}
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+inline bool __do_getc(FILE* __fp, wchar_t* __pbuf) {
+  wint_t __c = getwc(__fp);
+  if (__c == WEOF)
+    return false;
+  *__pbuf = static_cast<wchar_t>(__c);
+  return true;
+}
+#endif
+
+inline bool __do_ungetc(int __c, FILE* __fp, char __dummy) {
+  if (ungetc(__c, __fp) == EOF)
+    return false;
+  return true;
+}
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+inline bool __do_ungetc(std::wint_t __c, FILE* __fp, wchar_t __dummy) {
+  if (ungetwc(__c, __fp) == WEOF)
+    return false;
+  return true;
+}
+#endif
+
+template <class _CharT>
+typename __stdinbuf<_CharT>::int_type __stdinbuf<_CharT>::__getchar(bool __consume) {
+  if (__last_consumed_is_next_) {
+    int_type __result = __last_consumed_;
+    if (__consume) {
+      __last_consumed_         = traits_type::eof();
+      __last_consumed_is_next_ = false;
+    }
+    return __result;
+  }
+  if (__always_noconv_) {
+    char_type __1buf;
+    if (!__do_getc(__file_, &__1buf))
+      return traits_type::eof();
+    if (!__consume) {
+      if (!__do_ungetc(traits_type::to_int_type(__1buf), __file_, __1buf))
+        return traits_type::eof();
+    } else
+      __last_consumed_ = traits_type::to_int_type(__1buf);
+    return traits_type::to_int_type(__1buf);
+  }
+
+  char __extbuf[__limit];
+  int __nread = std::max(1, __encoding_);
+  for (int __i = 0; __i < __nread; ++__i) {
+    int __c = getc(__file_);
+    if (__c == EOF)
+      return traits_type::eof();
+    __extbuf[__i] = static_cast<char>(__c);
+  }
+  char_type __1buf;
+  const char* __enxt;
+  char_type* __inxt;
+  codecvt_base::result __r;
+  do {
+    state_type __sv_st = *__st_;
+    __r                = __cv_->in(*__st_, __extbuf, __extbuf + __nread, __enxt, &__1buf, &__1buf + 1, __inxt);
+    switch (__r) {
+    case std::codecvt_base::ok:
+      break;
+    case codecvt_base::partial:
+      *__st_ = __sv_st;
+      if (__nread == sizeof(__extbuf))
+        return traits_type::eof();
+      {
+        int __c = getc(__file_);
+        if (__c == EOF)
+          return traits_type::eof();
+        __extbuf[__nread] = static_cast<char>(__c);
+      }
+      ++__nread;
+      break;
+    case codecvt_base::error:
+      return traits_type::eof();
+    case std::codecvt_base::noconv:
+      __1buf = static_cast<char_type>(__extbuf[0]);
+      break;
+    }
+  } while (__r == std::codecvt_base::partial);
+  if (!__consume) {
+    for (int __i = __nread; __i > 0;) {
+      if (ungetc(traits_type::to_int_type(__extbuf[--__i]), __file_) == EOF)
+        return traits_type::eof();
+    }
+  } else
+    __last_consumed_ = traits_type::to_int_type(__1buf);
+  return traits_type::to_int_type(__1buf);
+}
+
+template <class _CharT>
+typename __stdinbuf<_CharT>::int_type __stdinbuf<_CharT>::pbackfail(int_type __c) {
+  if (traits_type::eq_int_type(__c, traits_type::eof())) {
+    if (!__last_consumed_is_next_) {
+      __c                      = __last_consumed_;
+      __last_consumed_is_next_ = !traits_type::eq_int_type(__last_consumed_, traits_type::eof());
+    }
+    return __c;
+  }
+  if (__always_noconv_ && __last_consumed_is_next_) {
+    if (!__do_ungetc(__last_consumed_, __file_, traits_type::to_char_type(__last_consumed_)))
+      return traits_type::eof();
+  } else if (__last_consumed_is_next_) {
+    char __extbuf[__limit];
+    char* __enxt;
+    const char_type __ci = traits_type::to_char_type(__last_consumed_);
+    const char_type* __inxt;
+    switch (__cv_->out(*__st_, &__ci, &__ci + 1, __inxt, __extbuf, __extbuf + sizeof(__extbuf), __enxt)) {
+    case std::codecvt_base::ok:
+      break;
+    case std::codecvt_base::noconv:
+      __extbuf[0] = static_cast<char>(__last_consumed_);
+      __enxt      = __extbuf + 1;
+      break;
+    case codecvt_base::partial:
+    case codecvt_base::error:
+      return traits_type::eof();
+    }
+    while (__enxt > __extbuf)
+      if (ungetc(*--__enxt, __file_) == EOF)
+        return traits_type::eof();
+  }
+  __last_consumed_         = __c;
+  __last_consumed_is_next_ = true;
+  return __c;
+}
+
+// __stdoutbuf
+
+template <class _CharT>
+class _LIBCPP_HIDDEN __stdoutbuf : public basic_streambuf<_CharT, char_traits<_CharT> > {
+public:
+  typedef _CharT char_type;
+  typedef char_traits<char_type> traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
+  typedef typename traits_type::state_type state_type;
+
+  __stdoutbuf(FILE* __fp, state_type* __st);
+
+protected:
+  virtual int_type overflow(int_type __c = traits_type::eof());
+  virtual streamsize xsputn(const char_type* __s, streamsize __n);
+  virtual int sync();
+  virtual void imbue(const locale& __loc);
+
+private:
+  FILE* __file_;
+  const codecvt<char_type, char, state_type>* __cv_;
+  state_type* __st_;
+  bool __always_noconv_;
+
+#if defined(_LIBCPP_WIN32API)
+  static constexpr bool __is_win32api_wide_char = !is_same_v<_CharT, char>;
+#else
+  static constexpr bool __is_win32api_wide_char = false;
+#endif
+
+  __stdoutbuf(const __stdoutbuf&);
+  __stdoutbuf& operator=(const __stdoutbuf&);
+
+  _LIBCPP_EXPORTED_FROM_ABI friend FILE* __get_ostream_file(ostream&);
+};
+
+template <class _CharT>
+__stdoutbuf<_CharT>::__stdoutbuf(FILE* __fp, state_type* __st)
+    : __file_(__fp),
+      __cv_(&use_facet<codecvt<char_type, char, state_type> >(this->getloc())),
+      __st_(__st),
+      __always_noconv_(__cv_->always_noconv()) {
+  // On Windows, in wchar_t mode, ignore the codecvt from the locale by
+  // default and assume noconv; this passes wchar_t through unmodified to
+  // fputwc, which handles it correctly depending on the actual mode of the
+  // output stream. If the user sets a custom locale with imbue(), that
+  // gets honored.
+  if constexpr (__is_win32api_wide_char)
+    __always_noconv_ = true;
+}
+
+inline bool __do_fputc(char __c, FILE* __fp) {
+  if (fwrite(&__c, sizeof(__c), 1, __fp) != 1)
+    return false;
+  return true;
+}
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+inline bool __do_fputc(wchar_t __c, FILE* __fp) {
+  // fputwc works regardless of wide/narrow mode of stdout, while
+  // fwrite of wchar_t only works if the stream actually has been set
+  // into wide mode.
+  if (fputwc(__c, __fp) == WEOF)
+    return false;
+  return true;
+}
+#endif
+
+template <class _CharT>
+typename __stdoutbuf<_CharT>::int_type __stdoutbuf<_CharT>::overflow(int_type __c) {
+  char __extbuf[__limit];
+  char_type __1buf;
+  if (!traits_type::eq_int_type(__c, traits_type::eof())) {
+    __1buf = traits_type::to_char_type(__c);
+    if (__always_noconv_) {
+      if (!__do_fputc(__1buf, __file_))
+        return traits_type::eof();
+    } else {
+      char* __extbe = __extbuf;
+      codecvt_base::result __r;
+      char_type* pbase = &__1buf;
+      char_type* pptr  = pbase + 1;
+      do {
+        const char_type* __e;
+        __r = __cv_->out(*__st_, pbase, pptr, __e, __extbuf, __extbuf + sizeof(__extbuf), __extbe);
+        if (__e == pbase)
+          return traits_type::eof();
+        if (__r == codecvt_base::noconv) {
+          if (fwrite(pbase, 1, 1, __file_) != 1)
+            return traits_type::eof();
+        } else if (__r == codecvt_base::ok || __r == codecvt_base::partial) {
+          size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
+          if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
+            return traits_type::eof();
+          if (__r == codecvt_base::partial) {
+            pbase = const_cast<char_type*>(__e);
+          }
+        } else
+          return traits_type::eof();
+      } while (__r == codecvt_base::partial);
+    }
+  }
+  return traits_type::not_eof(__c);
+}
+
+template <class _CharT>
+streamsize __stdoutbuf<_CharT>::xsputn(const char_type* __s, streamsize __n) {
+  // For wchar_t on Windows, don't call fwrite(), but write characters one
+  // at a time with fputwc(); that works both when stdout is in the default
+  // mode and when it is set to Unicode mode.
+  if (__always_noconv_ && !__is_win32api_wide_char)
+    return fwrite(__s, sizeof(char_type), __n, __file_);
+  streamsize __i = 0;
+  for (; __i < __n; ++__i, ++__s)
+    if (overflow(traits_type::to_int_type(*__s)) == traits_type::eof())
+      break;
+  return __i;
+}
+
+template <class _CharT>
+int __stdoutbuf<_CharT>::sync() {
+  char __extbuf[__limit];
+  codecvt_base::result __r;
+  do {
+    char* __extbe;
+    __r            = __cv_->unshift(*__st_, __extbuf, __extbuf + sizeof(__extbuf), __extbe);
+    size_t __nmemb = static_cast<size_t>(__extbe - __extbuf);
+    if (fwrite(__extbuf, 1, __nmemb, __file_) != __nmemb)
+      return -1;
+  } while (__r == codecvt_base::partial);
+  if (__r == codecvt_base::error)
+    return -1;
+  if (fflush(__file_))
+    return -1;
+  return 0;
+}
+
+template <class _CharT>
+void __stdoutbuf<_CharT>::imbue(const locale& __loc) {
+  sync();
+  __cv_            = &use_facet<codecvt<char_type, char, state_type> >(__loc);
+  __always_noconv_ = __cv_->always_noconv();
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_STD_STREAM_H
diff --git a/third_party/libcxx/stdatomic.h b/third_party/libcxx/stdatomic.h
index 4909e214e..79772eb7f 100644
--- a/third_party/libcxx/stdatomic.h
+++ b/third_party/libcxx/stdatomic.h
@@ -9,7 +9,6 @@
 
 #ifndef _LIBCPP_STDATOMIC_H
 #define _LIBCPP_STDATOMIC_H
-#ifndef __ASSEMBLER__
 
 /*
     stdatomic.h synopsis
@@ -122,16 +121,16 @@ using std::atomic_signal_fence                         // see below
 #  pragma GCC system_header
 #endif
 
-#if defined(__cplusplus) //&& _LIBCPP_STD_VER >= 23 // [jart]
+#if defined(__cplusplus) && _LIBCPP_STD_VER >= 23
 
-#include <atomic>
-#include <version>
+#  include <atomic>
+#  include <version>
 
-#ifdef _Atomic
-# undef _Atomic
-#endif
+#  ifdef _Atomic
+#    undef _Atomic
+#  endif
 
-#define _Atomic(_Tp) ::std::atomic<_Tp>
+#  define _Atomic(_Tp) ::std::atomic<_Tp>
 
 using std::memory_order _LIBCPP_USING_IF_EXISTS;
 using std::memory_order_relaxed _LIBCPP_USING_IF_EXISTS;
@@ -155,7 +154,7 @@ using std::atomic_long _LIBCPP_USING_IF_EXISTS;
 using std::atomic_ulong _LIBCPP_USING_IF_EXISTS;
 using std::atomic_llong _LIBCPP_USING_IF_EXISTS;
 using std::atomic_ullong _LIBCPP_USING_IF_EXISTS;
-// using std::atomic_char8_t _LIBCPP_USING_IF_EXISTS;
+using std::atomic_char8_t _LIBCPP_USING_IF_EXISTS;
 using std::atomic_char16_t _LIBCPP_USING_IF_EXISTS;
 using std::atomic_char32_t _LIBCPP_USING_IF_EXISTS;
 using std::atomic_wchar_t _LIBCPP_USING_IF_EXISTS;
@@ -227,11 +226,10 @@ using std::atomic_thread_fence _LIBCPP_USING_IF_EXISTS;
 // the header. We do this because Clang has historically shipped a <stdatomic.h>
 // header that would be available in all Standard modes, and we don't want to
 // break that use case.
-# if __has_include_next(<stdatomic.h>)
-#   include_next <stdatomic.h>
-# endif
+#  if __has_include_next(<stdatomic.h>)
+#    include_next <stdatomic.h>
+#  endif
 
 #endif // defined(__cplusplus) && _LIBCPP_STD_VER >= 23
 
-#endif // __ASSEMBLER__
 #endif // _LIBCPP_STDATOMIC_H
diff --git a/third_party/libcxx/stdbool.h b/third_party/libcxx/stdbool.h
index 74869b46d..e74d91f45 100644
--- a/third_party/libcxx/stdbool.h
+++ b/third_party/libcxx/stdbool.h
@@ -30,11 +30,11 @@ Macros:
 #endif
 
 #ifdef __cplusplus
-#undef bool
-#undef true
-#undef false
-#undef __bool_true_false_are_defined
-#define __bool_true_false_are_defined 1
+#  undef bool
+#  undef true
+#  undef false
+#  undef __bool_true_false_are_defined
+#  define __bool_true_false_are_defined 1
 #endif
 
 #endif // _LIBCPP_STDBOOL_H
diff --git a/third_party/libcxx/stddef.h b/third_party/libcxx/stddef.h
index f1725db06..1583e78e3 100644
--- a/third_party/libcxx/stddef.h
+++ b/third_party/libcxx/stddef.h
@@ -7,18 +7,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#if defined(__need_ptrdiff_t) || defined(__need_size_t) || \
-    defined(__need_wchar_t) || defined(__need_NULL) || defined(__need_wint_t)
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-#include_next <stddef.h>
-
-#elif !defined(_LIBCPP_STDDEF_H)
-#define _LIBCPP_STDDEF_H
-
 /*
     stddef.h synopsis
 
@@ -42,12 +30,15 @@ Types:
 #  pragma GCC system_header
 #endif
 
-#  if __has_include_next(<stddef.h>)
-#    include_next <stddef.h>
+// Note: This include is outside of header guards because we sometimes get included multiple times
+//       with different defines and the underlying <stddef.h> will know how to deal with that.
+#include_next <stddef.h>
+
+#ifndef _LIBCPP_STDDEF_H
+#  define _LIBCPP_STDDEF_H
+
+#  ifdef __cplusplus
+typedef decltype(nullptr) nullptr_t;
 #  endif
 
-#ifdef __cplusplus
-    typedef decltype(nullptr) nullptr_t;
-#endif
-
 #endif // _LIBCPP_STDDEF_H
diff --git a/third_party/libcxx/stdexcept b/third_party/libcxx/stdexcept
index 54be71938..853c18518 100644
--- a/third_party/libcxx/stdexcept
+++ b/third_party/libcxx/stdexcept
@@ -17,14 +17,14 @@ namespace std
 {
 
 class logic_error;
-    class domain_error;
-    class invalid_argument;
-    class length_error;
-    class out_of_range;
+class domain_error;
+class invalid_argument;
+class length_error;
+class out_of_range;
 class runtime_error;
-    class range_error;
-    class overflow_error;
-    class underflow_error;
+class range_error;
+class overflow_error;
+class underflow_error;
 
 for each class xxx_error:
 
@@ -41,11 +41,10 @@ public:
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__exception/exception.h>
+#include <__fwd/string.h>
 #include <__verbose_abort>
-#include <iosfwd>  // for string forward decl
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
@@ -54,159 +53,154 @@ public:
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
-class _LIBCPP_HIDDEN __libcpp_refstring
-{
-    const char* __imp_;
+class _LIBCPP_HIDDEN __libcpp_refstring {
+  const char* __imp_;
+
+  bool __uses_refcount() const;
 
-    bool __uses_refcount() const;
 public:
-    explicit __libcpp_refstring(const char* __msg);
-    __libcpp_refstring(const __libcpp_refstring& __s) _NOEXCEPT;
-    __libcpp_refstring& operator=(const __libcpp_refstring& __s) _NOEXCEPT;
-    ~__libcpp_refstring();
+  explicit __libcpp_refstring(const char* __msg);
+  __libcpp_refstring(const __libcpp_refstring& __s) _NOEXCEPT;
+  __libcpp_refstring& operator=(const __libcpp_refstring& __s) _NOEXCEPT;
+  ~__libcpp_refstring();
 
-    _LIBCPP_HIDE_FROM_ABI const char* c_str() const _NOEXCEPT {return __imp_;}
+  _LIBCPP_HIDE_FROM_ABI const char* c_str() const _NOEXCEPT { return __imp_; }
 };
 #endif // !_LIBCPP_ABI_VCRUNTIME
 
 _LIBCPP_END_NAMESPACE_STD
 
-namespace std  // purposefully not using versioning namespace
+namespace std // purposefully not using versioning namespace
 {
 
-class _LIBCPP_EXCEPTION_ABI logic_error
-    : public exception
-{
+class _LIBCPP_EXPORTED_FROM_ABI logic_error : public exception {
 #ifndef _LIBCPP_ABI_VCRUNTIME
+
 private:
-    _VSTD::__libcpp_refstring __imp_;
+  std::__libcpp_refstring __imp_;
+
 public:
-    explicit logic_error(const string&);
-    explicit logic_error(const char*);
+  explicit logic_error(const string&);
+  explicit logic_error(const char*);
 
-    logic_error(const logic_error&) _NOEXCEPT;
-    logic_error& operator=(const logic_error&) _NOEXCEPT;
+  logic_error(const logic_error&) _NOEXCEPT;
+  logic_error& operator=(const logic_error&) _NOEXCEPT;
 
-    ~logic_error() _NOEXCEPT override;
+  ~logic_error() _NOEXCEPT override;
 
-    const char* what() const _NOEXCEPT override;
+  const char* what() const _NOEXCEPT override;
 #else
+
 public:
-    explicit logic_error(const _VSTD::string&); // Symbol uses versioned std::string
-    _LIBCPP_INLINE_VISIBILITY explicit logic_error(const char* __s) : exception(__s) {}
+  explicit logic_error(const std::string&); // Symbol uses versioned std::string
+  _LIBCPP_HIDE_FROM_ABI explicit logic_error(const char* __s) : exception(__s) {}
 #endif
 };
 
-class _LIBCPP_EXCEPTION_ABI runtime_error
-    : public exception
-{
+class _LIBCPP_EXPORTED_FROM_ABI runtime_error : public exception {
 #ifndef _LIBCPP_ABI_VCRUNTIME
+
 private:
-    _VSTD::__libcpp_refstring __imp_;
+  std::__libcpp_refstring __imp_;
+
 public:
-    explicit runtime_error(const string&);
-    explicit runtime_error(const char*);
+  explicit runtime_error(const string&);
+  explicit runtime_error(const char*);
 
-    runtime_error(const runtime_error&) _NOEXCEPT;
-    runtime_error& operator=(const runtime_error&) _NOEXCEPT;
+  runtime_error(const runtime_error&) _NOEXCEPT;
+  runtime_error& operator=(const runtime_error&) _NOEXCEPT;
 
-    ~runtime_error() _NOEXCEPT override;
+  ~runtime_error() _NOEXCEPT override;
 
-    const char* what() const _NOEXCEPT override;
+  const char* what() const _NOEXCEPT override;
 #else
+
 public:
-   explicit runtime_error(const _VSTD::string&); // Symbol uses versioned std::string
-   _LIBCPP_INLINE_VISIBILITY explicit runtime_error(const char* __s) : exception(__s) {}
+  explicit runtime_error(const std::string&); // Symbol uses versioned std::string
+  _LIBCPP_HIDE_FROM_ABI explicit runtime_error(const char* __s) : exception(__s) {}
 #endif // _LIBCPP_ABI_VCRUNTIME
 };
 
-class _LIBCPP_EXCEPTION_ABI domain_error
-    : public logic_error
-{
+class _LIBCPP_EXPORTED_FROM_ABI domain_error : public logic_error {
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
-    _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s)   : logic_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit domain_error(const string& __s) : logic_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit domain_error(const char* __s) : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
-    _LIBCPP_HIDE_FROM_ABI domain_error(const domain_error&) _NOEXCEPT = default;
-    ~domain_error() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI domain_error(const domain_error&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI domain_error& operator=(const domain_error&) _NOEXCEPT = default;
+  ~domain_error() _NOEXCEPT override;
 #endif
 };
 
-class _LIBCPP_EXCEPTION_ABI invalid_argument
-    : public logic_error
-{
+class _LIBCPP_EXPORTED_FROM_ABI invalid_argument : public logic_error {
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
-    _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s)   : logic_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit invalid_argument(const string& __s) : logic_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit invalid_argument(const char* __s) : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
-    _LIBCPP_HIDE_FROM_ABI invalid_argument(const invalid_argument&) _NOEXCEPT = default;
-    ~invalid_argument() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI invalid_argument(const invalid_argument&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI invalid_argument& operator=(const invalid_argument&) _NOEXCEPT = default;
+  ~invalid_argument() _NOEXCEPT override;
 #endif
 };
 
-class _LIBCPP_EXCEPTION_ABI length_error
-    : public logic_error
-{
+class _LIBCPP_EXPORTED_FROM_ABI length_error : public logic_error {
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
-    _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s)   : logic_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit length_error(const string& __s) : logic_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit length_error(const char* __s) : logic_error(__s) {}
 #ifndef _LIBCPP_ABI_VCRUNTIME
-    _LIBCPP_HIDE_FROM_ABI length_error(const length_error&) _NOEXCEPT = default;
-    ~length_error() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI length_error(const length_error&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI length_error& operator=(const length_error&) _NOEXCEPT = default;
+  ~length_error() _NOEXCEPT override;
 #endif
 };
 
-class _LIBCPP_EXCEPTION_ABI out_of_range
-    : public logic_error
-{
+class _LIBCPP_EXPORTED_FROM_ABI out_of_range : public logic_error {
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
-    _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s)   : logic_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit out_of_range(const string& __s) : logic_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit out_of_range(const char* __s) : logic_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
-    _LIBCPP_HIDE_FROM_ABI out_of_range(const out_of_range&) _NOEXCEPT = default;
-    ~out_of_range() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI out_of_range(const out_of_range&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI out_of_range& operator=(const out_of_range&) _NOEXCEPT = default;
+  ~out_of_range() _NOEXCEPT override;
 #endif
 };
 
-class _LIBCPP_EXCEPTION_ABI range_error
-    : public runtime_error
-{
+class _LIBCPP_EXPORTED_FROM_ABI range_error : public runtime_error {
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
-    _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s)   : runtime_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit range_error(const string& __s) : runtime_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit range_error(const char* __s) : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
-    _LIBCPP_HIDE_FROM_ABI range_error(const range_error&) _NOEXCEPT = default;
-    ~range_error() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI range_error(const range_error&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI range_error& operator=(const range_error&) _NOEXCEPT = default;
+  ~range_error() _NOEXCEPT override;
 #endif
 };
 
-class _LIBCPP_EXCEPTION_ABI overflow_error
-    : public runtime_error
-{
+class _LIBCPP_EXPORTED_FROM_ABI overflow_error : public runtime_error {
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
-    _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s)   : runtime_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit overflow_error(const string& __s) : runtime_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit overflow_error(const char* __s) : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
-    _LIBCPP_HIDE_FROM_ABI overflow_error(const overflow_error&) _NOEXCEPT = default;
-    ~overflow_error() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI overflow_error(const overflow_error&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI overflow_error& operator=(const overflow_error&) _NOEXCEPT = default;
+  ~overflow_error() _NOEXCEPT override;
 #endif
 };
 
-class _LIBCPP_EXCEPTION_ABI underflow_error
-    : public runtime_error
-{
+class _LIBCPP_EXPORTED_FROM_ABI underflow_error : public runtime_error {
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
-    _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s)   : runtime_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit underflow_error(const string& __s) : runtime_error(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit underflow_error(const char* __s) : runtime_error(__s) {}
 
 #ifndef _LIBCPP_ABI_VCRUNTIME
-    _LIBCPP_HIDE_FROM_ABI underflow_error(const underflow_error&) _NOEXCEPT = default;
-    ~underflow_error() _NOEXCEPT override;
+  _LIBCPP_HIDE_FROM_ABI underflow_error(const underflow_error&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI underflow_error& operator=(const underflow_error&) _NOEXCEPT = default;
+  ~underflow_error() _NOEXCEPT override;
 #endif
 };
 
@@ -215,85 +209,69 @@ public:
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // in the dylib
-_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_runtime_error(const char*);
+_LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_runtime_error(const char*);
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_logic_error(const char*__msg)
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_logic_error(const char* __msg) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw logic_error(__msg);
+  throw logic_error(__msg);
 #else
-    _LIBCPP_VERBOSE_ABORT("logic_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
+  _LIBCPP_VERBOSE_ABORT("logic_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_domain_error(const char*__msg)
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_domain_error(const char* __msg) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw domain_error(__msg);
+  throw domain_error(__msg);
 #else
-    _LIBCPP_VERBOSE_ABORT("domain_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
+  _LIBCPP_VERBOSE_ABORT("domain_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_invalid_argument(const char*__msg)
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_invalid_argument(const char* __msg) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw invalid_argument(__msg);
+  throw invalid_argument(__msg);
 #else
-    _LIBCPP_VERBOSE_ABORT("invalid_argument was thrown in -fno-exceptions mode with message \"%s\"", __msg);
+  _LIBCPP_VERBOSE_ABORT("invalid_argument was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_length_error(const char*__msg)
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_length_error(const char* __msg) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw length_error(__msg);
+  throw length_error(__msg);
 #else
-    _LIBCPP_VERBOSE_ABORT("length_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
+  _LIBCPP_VERBOSE_ABORT("length_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_out_of_range(const char*__msg)
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_out_of_range(const char* __msg) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw out_of_range(__msg);
+  throw out_of_range(__msg);
 #else
-    _LIBCPP_VERBOSE_ABORT("out_of_range was thrown in -fno-exceptions mode with message \"%s\"", __msg);
+  _LIBCPP_VERBOSE_ABORT("out_of_range was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_range_error(const char*__msg)
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_range_error(const char* __msg) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw range_error(__msg);
+  throw range_error(__msg);
 #else
-    _LIBCPP_VERBOSE_ABORT("range_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
+  _LIBCPP_VERBOSE_ABORT("range_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_overflow_error(const char*__msg)
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_overflow_error(const char* __msg) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw overflow_error(__msg);
+  throw overflow_error(__msg);
 #else
-    _LIBCPP_VERBOSE_ABORT("overflow_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
+  _LIBCPP_VERBOSE_ABORT("overflow_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_underflow_error(const char*__msg)
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_underflow_error(const char* __msg) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw underflow_error(__msg);
+  throw underflow_error(__msg);
 #else
-    _LIBCPP_VERBOSE_ABORT("underflow_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
+  _LIBCPP_VERBOSE_ABORT("underflow_error was thrown in -fno-exceptions mode with message \"%s\"", __msg);
 #endif
 }
 
@@ -302,6 +280,7 @@ _LIBCPP_END_NAMESPACE_STD
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <cstdlib>
 #  include <exception>
+#  include <iosfwd>
 #endif
 
 #endif // _LIBCPP_STDEXCEPT
diff --git a/third_party/libcxx/stdexcept.cpp b/third_party/libcxx/stdexcept.cpp
new file mode 100644
index 000000000..c8668254f
--- /dev/null
+++ b/third_party/libcxx/stdexcept.cpp
@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__verbose_abort>
+#include <new>
+#include <stdexcept>
+#include <string>
+
+#include "stdexcept_default.h"
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+_LIBCPP_NORETURN void __throw_runtime_error(const char* msg) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw runtime_error(msg);
+#else
+  _LIBCPP_VERBOSE_ABORT("runtime_error was thrown in -fno-exceptions mode with message \"%s\"", msg);
+#endif
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/stdexcept_default.h b/third_party/libcxx/stdexcept_default.h
new file mode 100644
index 000000000..7b442f63d
--- /dev/null
+++ b/third_party/libcxx/stdexcept_default.h
@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "refstring.h"
+
+#include <string>
+
+/* For _LIBCPPABI_VERSION */
+#if !defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY) && (defined(LIBCXX_BUILDING_LIBCXXABI) || defined(LIBCXXRT))
+#  include <cxxabi.h>
+#endif
+
+static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char*), "");
+
+namespace std // purposefully not using versioning namespace
+{
+
+logic_error::logic_error(const string& msg) : __imp_(msg.c_str()) {}
+
+logic_error::logic_error(const char* msg) : __imp_(msg) {}
+
+logic_error::logic_error(const logic_error& le) noexcept : __imp_(le.__imp_) {}
+
+logic_error& logic_error::operator=(const logic_error& le) noexcept {
+  __imp_ = le.__imp_;
+  return *this;
+}
+
+runtime_error::runtime_error(const string& msg) : __imp_(msg.c_str()) {}
+
+runtime_error::runtime_error(const char* msg) : __imp_(msg) {}
+
+runtime_error::runtime_error(const runtime_error& re) noexcept : __imp_(re.__imp_) {}
+
+runtime_error& runtime_error::operator=(const runtime_error& re) noexcept {
+  __imp_ = re.__imp_;
+  return *this;
+}
+
+#if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
+
+const char* logic_error::what() const noexcept { return __imp_.c_str(); }
+
+const char* runtime_error::what() const noexcept { return __imp_.c_str(); }
+
+logic_error::~logic_error() noexcept {}
+domain_error::~domain_error() noexcept {}
+invalid_argument::~invalid_argument() noexcept {}
+length_error::~length_error() noexcept {}
+out_of_range::~out_of_range() noexcept {}
+
+runtime_error::~runtime_error() noexcept {}
+range_error::~range_error() noexcept {}
+overflow_error::~overflow_error() noexcept {}
+underflow_error::~underflow_error() noexcept {}
+
+#endif
+
+} // namespace std
diff --git a/third_party/libcxx/stdfloat b/third_party/libcxx/stdfloat
new file mode 100644
index 000000000..a3a27dcb5
--- /dev/null
+++ b/third_party/libcxx/stdfloat
@@ -0,0 +1,26 @@
+// -*- C++ -*-
+#pragma once
+
+export namespace std {
+
+#if defined(__STDCPP_FLOAT16_T__)
+  using float16_t = _Float16;
+#endif
+
+#if defined(__STDCPP_FLOAT32_T__)
+  using float32_t = float;
+#endif
+
+#if defined(__STDCPP_FLOAT64_T__)
+  using float64_t = double;
+#endif
+
+#if defined(__STDCPP_FLOAT128_T__)
+  using float128_t = long double;
+#endif
+
+#if defined(__STDCPP_BFLOAT16_T__)
+  using bfloat16_t = __bf16;
+#endif
+
+} // namespace std
diff --git a/third_party/libcxx/stdint.h b/third_party/libcxx/stdint.h
index fa7b011c7..35e5b8cbd 100644
--- a/third_party/libcxx/stdint.h
+++ b/third_party/libcxx/stdint.h
@@ -12,7 +12,7 @@
 // is defined until an inclusion of it without _STD_TYPES_T occurs, in which
 // case the header guard macro is defined.
 #if !defined(_AIX) || !defined(_STD_TYPES_T)
-#define _LIBCPP_STDINT_H
+#  define _LIBCPP_STDINT_H
 #endif // _STD_TYPES_T
 
 /*
@@ -114,10 +114,10 @@ Macros:
    are defined
 */
 #if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS)
-#   define __STDC_LIMIT_MACROS
+#  define __STDC_LIMIT_MACROS
 #endif
 #if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS)
-#   define __STDC_CONSTANT_MACROS
+#  define __STDC_CONSTANT_MACROS
 #endif
 
 #if __has_include_next(<stdint.h>)
diff --git a/third_party/libcxx/stdio.h b/third_party/libcxx/stdio.h
index cea43aa76..3aa559393 100644
--- a/third_party/libcxx/stdio.h
+++ b/third_party/libcxx/stdio.h
@@ -9,14 +9,14 @@
 
 #if defined(__need_FILE) || defined(__need___FILE)
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
-#include_next <stdio.h>
+#  include_next <stdio.h>
 
 #elif !defined(_LIBCPP_STDIO_H)
-#define _LIBCPP_STDIO_H
+#  define _LIBCPP_STDIO_H
 
 /*
     stdio.h synopsis
@@ -98,24 +98,26 @@ int ferror(FILE* stream);
 void perror(const char* s);
 */
 
-#include <__config>
+#  include <__config>
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 #  if __has_include_next(<stdio.h>)
 #    include_next <stdio.h>
 #  endif
 
-#ifdef __cplusplus
+#  ifdef __cplusplus
 
-#undef getc
-#undef putc
-#undef clearerr
-#undef feof
-#undef ferror
+#    undef getc
+#    undef putc
+#    undef clearerr
+#    undef feof
+#    undef ferror
+#    undef putchar
+#    undef getchar
 
-#endif
+#  endif
 
 #endif // _LIBCPP_STDIO_H
diff --git a/third_party/libcxx/stdlib.h b/third_party/libcxx/stdlib.h
index 614e3730c..a74344d49 100644
--- a/third_party/libcxx/stdlib.h
+++ b/third_party/libcxx/stdlib.h
@@ -9,14 +9,14 @@
 
 #if defined(__need_malloc_and_calloc)
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
-#include_next <stdlib.h>
+#  include_next <stdlib.h>
 
 #elif !defined(_LIBCPP_STDLIB_H)
-#define _LIBCPP_STDLIB_H
+#  define _LIBCPP_STDLIB_H
 
 /*
     stdlib.h synopsis
@@ -84,78 +84,68 @@ void *aligned_alloc(size_t alignment, size_t size);                       // C11
 
 */
 
-#include <__config>
+#  include <__config>
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 #  if __has_include_next(<stdlib.h>)
 #    include_next <stdlib.h>
 #  endif
 
-#ifdef __cplusplus
+#  ifdef __cplusplus
 extern "C++" {
 // abs
 
-#ifdef abs
-# undef abs
-#endif
-#ifdef labs
-# undef labs
-#endif
-#ifdef llabs
-# undef llabs
-#endif
+#    ifdef abs
+#      undef abs
+#    endif
+#    ifdef labs
+#      undef labs
+#    endif
+#    ifdef llabs
+#      undef llabs
+#    endif
 
 // MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
-#if !defined(_LIBCPP_MSVCRT)
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY long abs(long __x) _NOEXCEPT {
-  return __builtin_labs(__x);
-}
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY long long abs(long long __x) _NOEXCEPT {
-  return __builtin_llabs(__x);
-}
-#endif // !defined(_LIBCPP_MSVCRT)
+#    if !defined(_LIBCPP_MSVCRT)
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long abs(long __x) _NOEXCEPT { return __builtin_labs(__x); }
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long long abs(long long __x) _NOEXCEPT { return __builtin_llabs(__x); }
+#    endif // !defined(_LIBCPP_MSVCRT)
 
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY float abs(float __lcpp_x) _NOEXCEPT {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI float abs(float __lcpp_x) _NOEXCEPT {
   return __builtin_fabsf(__lcpp_x); // Use builtins to prevent needing math.h
 }
 
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY double abs(double __lcpp_x) _NOEXCEPT {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI double abs(double __lcpp_x) _NOEXCEPT {
   return __builtin_fabs(__lcpp_x);
 }
 
-_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY long double
-abs(long double __lcpp_x) _NOEXCEPT {
+_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI long double abs(long double __lcpp_x) _NOEXCEPT {
   return __builtin_fabsl(__lcpp_x);
 }
 
 // div
 
-#ifdef div
-# undef div
-#endif
-#ifdef ldiv
-# undef ldiv
-#endif
-#ifdef lldiv
-# undef lldiv
-#endif
+#    ifdef div
+#      undef div
+#    endif
+#    ifdef ldiv
+#      undef ldiv
+#    endif
+#    ifdef lldiv
+#      undef lldiv
+#    endif
 
 // MSVCRT already has the correct prototype in <stdlib.h> if __cplusplus is defined
-#if !defined(_LIBCPP_MSVCRT)
-inline _LIBCPP_INLINE_VISIBILITY ldiv_t div(long __x, long __y) _NOEXCEPT {
-  return ::ldiv(__x, __y);
-}
-#if !(defined(__FreeBSD__) && !defined(__LONG_LONG_SUPPORTED))
-inline _LIBCPP_INLINE_VISIBILITY lldiv_t div(long long __x,
-                                             long long __y) _NOEXCEPT {
-  return ::lldiv(__x, __y);
-}
-#endif
-#endif // _LIBCPP_MSVCRT
+#    if !defined(_LIBCPP_MSVCRT)
+inline _LIBCPP_HIDE_FROM_ABI ldiv_t div(long __x, long __y) _NOEXCEPT { return ::ldiv(__x, __y); }
+#      if !(defined(__FreeBSD__) && !defined(__LONG_LONG_SUPPORTED))
+inline _LIBCPP_HIDE_FROM_ABI lldiv_t div(long long __x, long long __y) _NOEXCEPT { return ::lldiv(__x, __y); }
+#      endif
+#    endif // _LIBCPP_MSVCRT
 } // extern "C++"
-#endif // __cplusplus
+#  endif   // __cplusplus
 
 #endif // _LIBCPP_STDLIB_H
diff --git a/third_party/libcxx/stop_token b/third_party/libcxx/stop_token
new file mode 100644
index 000000000..d4e651d95
--- /dev/null
+++ b/third_party/libcxx/stop_token
@@ -0,0 +1,56 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_STOP_TOKEN
+#define _LIBCPP_STOP_TOKEN
+
+/*
+
+namespace std {
+  // [stoptoken], class stop_token
+  class stop_token;
+
+  // [stopsource], class stop_source
+  class stop_source;
+
+  // no-shared-stop-state indicator
+  struct nostopstate_t {
+    explicit nostopstate_t() = default;
+  };
+  inline constexpr nostopstate_t nostopstate{};
+
+  // [stopcallback], class template stop_callback
+  template<class Callback>
+    class stop_callback;
+
+*/
+
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+
+#  if _LIBCPP_STD_VER >= 20
+#    include <__stop_token/stop_callback.h>
+#    include <__stop_token/stop_source.h>
+#    include <__stop_token/stop_token.h>
+#  endif
+
+#  include <version>
+
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+#endif // !defined(_LIBCPP_HAS_NO_THREADS)
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <iosfwd>
+#endif
+
+#endif // _LIBCPP_STOP_TOKEN
diff --git a/third_party/libcxx/streambuf b/third_party/libcxx/streambuf
index 095ac7d3a..5a3c17ef7 100644
--- a/third_party/libcxx/streambuf
+++ b/third_party/libcxx/streambuf
@@ -107,10 +107,13 @@ protected:
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
 #include <__fwd/streambuf.h>
-#include <cstdint>
+#include <__locale>
+#include <__type_traits/is_same.h>
+#include <__utility/is_valid_range.h>
+#include <climits>
 #include <ios>
 #include <iosfwd>
 #include <version>
@@ -125,201 +128,177 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _CharT, class _Traits>
-class _LIBCPP_TEMPLATE_VIS basic_streambuf
-{
+class _LIBCPP_TEMPLATE_VIS basic_streambuf {
 public:
-    // types:
-    typedef _CharT                         char_type;
-    typedef _Traits                        traits_type;
-    typedef typename traits_type::int_type int_type;
-    typedef typename traits_type::pos_type pos_type;
-    typedef typename traits_type::off_type off_type;
+  // types:
+  typedef _CharT char_type;
+  typedef _Traits traits_type;
+  typedef typename traits_type::int_type int_type;
+  typedef typename traits_type::pos_type pos_type;
+  typedef typename traits_type::off_type off_type;
 
-    static_assert((is_same<_CharT, typename traits_type::char_type>::value),
-                  "traits_type::char_type must be the same type as CharT");
+  static_assert(is_same<_CharT, typename traits_type::char_type>::value,
+                "traits_type::char_type must be the same type as CharT");
 
-    virtual ~basic_streambuf();
+  virtual ~basic_streambuf();
 
-    // 27.6.2.2.1 locales:
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    locale pubimbue(const locale& __loc) {
-        imbue(__loc);
-        locale __r = __loc_;
-        __loc_ = __loc;
-        return __r;
-    }
+  // 27.6.2.2.1 locales:
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 locale pubimbue(const locale& __loc) {
+    imbue(__loc);
+    locale __r = __loc_;
+    __loc_     = __loc;
+    return __r;
+  }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    locale getloc() const { return __loc_; }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 locale getloc() const { return __loc_; }
 
-    // 27.6.2.2.2 buffer and positioning:
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    basic_streambuf* pubsetbuf(char_type* __s, streamsize __n)
-    { return setbuf(__s, __n); }
+  // 27.6.2.2.2 buffer and positioning:
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_streambuf* pubsetbuf(char_type* __s, streamsize __n) {
+    return setbuf(__s, __n);
+  }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    pos_type pubseekoff(off_type __off, ios_base::seekdir __way,
-                        ios_base::openmode __which = ios_base::in | ios_base::out)
-    { return seekoff(__off, __way, __which); }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type
+  pubseekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) {
+    return seekoff(__off, __way, __which);
+  }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    pos_type pubseekpos(pos_type __sp,
-                        ios_base::openmode __which = ios_base::in | ios_base::out)
-    { return seekpos(__sp, __which); }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type
+  pubseekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) {
+    return seekpos(__sp, __which);
+  }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    int pubsync() { return sync(); }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int pubsync() { return sync(); }
 
-    // Get and put areas:
-    // 27.6.2.2.3 Get area:
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    streamsize in_avail() {
-        if (__ninp_ < __einp_)
-            return static_cast<streamsize>(__einp_ - __ninp_);
-        return showmanyc();
-    }
+  // Get and put areas:
+  // 27.6.2.2.3 Get area:
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 streamsize in_avail() {
+    if (__ninp_ < __einp_)
+      return static_cast<streamsize>(__einp_ - __ninp_);
+    return showmanyc();
+  }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    int_type snextc() {
-        if (sbumpc() == traits_type::eof())
-            return traits_type::eof();
-        return sgetc();
-    }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type snextc() {
+    if (sbumpc() == traits_type::eof())
+      return traits_type::eof();
+    return sgetc();
+  }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    int_type sbumpc() {
-        if (__ninp_ == __einp_)
-            return uflow();
-        return traits_type::to_int_type(*__ninp_++);
-    }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sbumpc() {
+    if (__ninp_ == __einp_)
+      return uflow();
+    return traits_type::to_int_type(*__ninp_++);
+  }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    int_type sgetc() {
-        if (__ninp_ == __einp_)
-            return underflow();
-        return traits_type::to_int_type(*__ninp_);
-    }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sgetc() {
+    if (__ninp_ == __einp_)
+      return underflow();
+    return traits_type::to_int_type(*__ninp_);
+  }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    streamsize sgetn(char_type* __s, streamsize __n)
-    { return xsgetn(__s, __n); }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 streamsize sgetn(char_type* __s, streamsize __n) { return xsgetn(__s, __n); }
 
-    // 27.6.2.2.4 Putback:
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    int_type sputbackc(char_type __c) {
-        if (__binp_ == __ninp_ || !traits_type::eq(__c, __ninp_[-1]))
-            return pbackfail(traits_type::to_int_type(__c));
-        return traits_type::to_int_type(*--__ninp_);
-    }
+  // 27.6.2.2.4 Putback:
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sputbackc(char_type __c) {
+    if (__binp_ == __ninp_ || !traits_type::eq(__c, __ninp_[-1]))
+      return pbackfail(traits_type::to_int_type(__c));
+    return traits_type::to_int_type(*--__ninp_);
+  }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    int_type sungetc() {
-        if (__binp_ == __ninp_)
-          return pbackfail();
-        return traits_type::to_int_type(*--__ninp_);
-    }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sungetc() {
+    if (__binp_ == __ninp_)
+      return pbackfail();
+    return traits_type::to_int_type(*--__ninp_);
+  }
 
-    // 27.6.2.2.5 Put area:
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    int_type sputc(char_type __c) {
-        if (__nout_ == __eout_)
-            return overflow(traits_type::to_int_type(__c));
-        *__nout_++ = __c;
-        return traits_type::to_int_type(__c);
-    }
+  // 27.6.2.2.5 Put area:
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sputc(char_type __c) {
+    if (__nout_ == __eout_)
+      return overflow(traits_type::to_int_type(__c));
+    *__nout_++ = __c;
+    return traits_type::to_int_type(__c);
+  }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    streamsize sputn(const char_type* __s, streamsize __n)
-    { return xsputn(__s, __n); }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 streamsize sputn(const char_type* __s, streamsize __n) {
+    return xsputn(__s, __n);
+  }
 
 protected:
-    basic_streambuf();
-    basic_streambuf(const basic_streambuf& __rhs);
-    basic_streambuf& operator=(const basic_streambuf& __rhs);
-    void swap(basic_streambuf& __rhs);
+  basic_streambuf();
+  basic_streambuf(const basic_streambuf& __rhs);
+  basic_streambuf& operator=(const basic_streambuf& __rhs);
+  void swap(basic_streambuf& __rhs);
 
-    // 27.6.2.3.2 Get area:
-    _LIBCPP_INLINE_VISIBILITY char_type* eback() const {return __binp_;}
-    _LIBCPP_INLINE_VISIBILITY char_type* gptr()  const {return __ninp_;}
-    _LIBCPP_INLINE_VISIBILITY char_type* egptr() const {return __einp_;}
+  // 27.6.2.3.2 Get area:
+  _LIBCPP_HIDE_FROM_ABI char_type* eback() const { return __binp_; }
+  _LIBCPP_HIDE_FROM_ABI char_type* gptr() const { return __ninp_; }
+  _LIBCPP_HIDE_FROM_ABI char_type* egptr() const { return __einp_; }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    void gbump(int __n) { __ninp_ += __n; }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void gbump(int __n) { __ninp_ += __n; }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) {
-        __binp_ = __gbeg;
-        __ninp_ = __gnext;
-        __einp_ = __gend;
-    }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) {
+    _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gbeg, __gnext), "[gbeg, gnext) must be a valid range");
+    _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gbeg, __gend), "[gbeg, gend) must be a valid range");
+    _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gnext, __gend), "[gnext, gend) must be a valid range");
+    __binp_ = __gbeg;
+    __ninp_ = __gnext;
+    __einp_ = __gend;
+  }
 
-    // 27.6.2.3.3 Put area:
-    _LIBCPP_INLINE_VISIBILITY char_type* pbase() const {return __bout_;}
-    _LIBCPP_INLINE_VISIBILITY char_type* pptr()  const {return __nout_;}
-    _LIBCPP_INLINE_VISIBILITY char_type* epptr() const {return __eout_;}
+  // 27.6.2.3.3 Put area:
+  _LIBCPP_HIDE_FROM_ABI char_type* pbase() const { return __bout_; }
+  _LIBCPP_HIDE_FROM_ABI char_type* pptr() const { return __nout_; }
+  _LIBCPP_HIDE_FROM_ABI char_type* epptr() const { return __eout_; }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    void pbump(int __n) { __nout_ += __n; }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void pbump(int __n) { __nout_ += __n; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __pbump(streamsize __n) { __nout_ += __n; }
+  _LIBCPP_HIDE_FROM_ABI void __pbump(streamsize __n) { __nout_ += __n; }
 
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    void setp(char_type* __pbeg, char_type* __pend) {
-        __bout_ = __nout_ = __pbeg;
-        __eout_ = __pend;
-    }
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void setp(char_type* __pbeg, char_type* __pend) {
+    _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__pbeg, __pend), "[pbeg, pend) must be a valid range");
+    __bout_ = __nout_ = __pbeg;
+    __eout_           = __pend;
+  }
 
-    // 27.6.2.4 virtual functions:
-    // 27.6.2.4.1 Locales:
-    virtual void imbue(const locale& __loc);
+  // 27.6.2.4 virtual functions:
+  // 27.6.2.4.1 Locales:
+  virtual void imbue(const locale& __loc);
 
-    // 27.6.2.4.2 Buffer management and positioning:
-    virtual basic_streambuf* setbuf(char_type* __s, streamsize __n);
-    virtual pos_type seekoff(off_type __off, ios_base::seekdir __way,
-                             ios_base::openmode __which = ios_base::in | ios_base::out);
-    virtual pos_type seekpos(pos_type __sp,
-                             ios_base::openmode __which = ios_base::in | ios_base::out);
-    virtual int sync();
+  // 27.6.2.4.2 Buffer management and positioning:
+  virtual basic_streambuf* setbuf(char_type* __s, streamsize __n);
+  virtual pos_type
+  seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out);
+  virtual pos_type seekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out);
+  virtual int sync();
 
-    // 27.6.2.4.3 Get area:
-    virtual streamsize showmanyc();
-    virtual streamsize xsgetn(char_type* __s, streamsize __n);
-    virtual int_type underflow();
-    virtual int_type uflow();
+  // 27.6.2.4.3 Get area:
+  virtual streamsize showmanyc();
+  virtual streamsize xsgetn(char_type* __s, streamsize __n);
+  virtual int_type underflow();
+  virtual int_type uflow();
 
-    // 27.6.2.4.4 Putback:
-    virtual int_type pbackfail(int_type __c = traits_type::eof());
+  // 27.6.2.4.4 Putback:
+  virtual int_type pbackfail(int_type __c = traits_type::eof());
 
-    // 27.6.2.4.5 Put area:
-    virtual streamsize xsputn(const char_type* __s, streamsize __n);
-    virtual int_type overflow(int_type __c = traits_type::eof());
+  // 27.6.2.4.5 Put area:
+  virtual streamsize xsputn(const char_type* __s, streamsize __n);
+  virtual int_type overflow(int_type __c = traits_type::eof());
 
 private:
-    locale __loc_;
-    char_type* __binp_;
-    char_type* __ninp_;
-    char_type* __einp_;
-    char_type* __bout_;
-    char_type* __nout_;
-    char_type* __eout_;
+  locale __loc_;
+  char_type* __binp_;
+  char_type* __ninp_;
+  char_type* __einp_;
+  char_type* __bout_;
+  char_type* __nout_;
+  char_type* __eout_;
 };
 
 template <class _CharT, class _Traits>
-basic_streambuf<_CharT, _Traits>::~basic_streambuf()
-{
-}
+basic_streambuf<_CharT, _Traits>::~basic_streambuf() {}
 
 template <class _CharT, class _Traits>
 basic_streambuf<_CharT, _Traits>::basic_streambuf()
-    : __binp_(nullptr),
-      __ninp_(nullptr),
-      __einp_(nullptr),
-      __bout_(nullptr),
-      __nout_(nullptr),
-      __eout_(nullptr)
-{
-}
+    : __binp_(nullptr), __ninp_(nullptr), __einp_(nullptr), __bout_(nullptr), __nout_(nullptr), __eout_(nullptr) {}
 
 template <class _CharT, class _Traits>
 basic_streambuf<_CharT, _Traits>::basic_streambuf(const basic_streambuf& __sb)
@@ -329,164 +308,124 @@ basic_streambuf<_CharT, _Traits>::basic_streambuf(const basic_streambuf& __sb)
       __einp_(__sb.__einp_),
       __bout_(__sb.__bout_),
       __nout_(__sb.__nout_),
-      __eout_(__sb.__eout_)
-{
+      __eout_(__sb.__eout_) {}
+
+template <class _CharT, class _Traits>
+basic_streambuf<_CharT, _Traits>& basic_streambuf<_CharT, _Traits>::operator=(const basic_streambuf& __sb) {
+  __loc_  = __sb.__loc_;
+  __binp_ = __sb.__binp_;
+  __ninp_ = __sb.__ninp_;
+  __einp_ = __sb.__einp_;
+  __bout_ = __sb.__bout_;
+  __nout_ = __sb.__nout_;
+  __eout_ = __sb.__eout_;
+  return *this;
 }
 
 template <class _CharT, class _Traits>
-basic_streambuf<_CharT, _Traits>&
-basic_streambuf<_CharT, _Traits>::operator=(const basic_streambuf& __sb)
-{
-    __loc_ = __sb.__loc_;
-    __binp_ = __sb.__binp_;
-    __ninp_ = __sb.__ninp_;
-    __einp_ = __sb.__einp_;
-    __bout_ = __sb.__bout_;
-    __nout_ = __sb.__nout_;
-    __eout_ = __sb.__eout_;
-    return *this;
+void basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb) {
+  std::swap(__loc_, __sb.__loc_);
+  std::swap(__binp_, __sb.__binp_);
+  std::swap(__ninp_, __sb.__ninp_);
+  std::swap(__einp_, __sb.__einp_);
+  std::swap(__bout_, __sb.__bout_);
+  std::swap(__nout_, __sb.__nout_);
+  std::swap(__eout_, __sb.__eout_);
 }
 
 template <class _CharT, class _Traits>
-void
-basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb)
-{
-    _VSTD::swap(__loc_, __sb.__loc_);
-    _VSTD::swap(__binp_, __sb.__binp_);
-    _VSTD::swap(__ninp_, __sb.__ninp_);
-    _VSTD::swap(__einp_, __sb.__einp_);
-    _VSTD::swap(__bout_, __sb.__bout_);
-    _VSTD::swap(__nout_, __sb.__nout_);
-    _VSTD::swap(__eout_, __sb.__eout_);
-}
+void basic_streambuf<_CharT, _Traits>::imbue(const locale&) {}
 
 template <class _CharT, class _Traits>
-void
-basic_streambuf<_CharT, _Traits>::imbue(const locale&)
-{
-}
-
-template <class _CharT, class _Traits>
-basic_streambuf<_CharT, _Traits>*
-basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize)
-{
-    return this;
+basic_streambuf<_CharT, _Traits>* basic_streambuf<_CharT, _Traits>::setbuf(char_type*, streamsize) {
+  return this;
 }
 
 template <class _CharT, class _Traits>
 typename basic_streambuf<_CharT, _Traits>::pos_type
-basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir,
-                                          ios_base::openmode)
-{
-    return pos_type(off_type(-1));
+basic_streambuf<_CharT, _Traits>::seekoff(off_type, ios_base::seekdir, ios_base::openmode) {
+  return pos_type(off_type(-1));
 }
 
 template <class _CharT, class _Traits>
 typename basic_streambuf<_CharT, _Traits>::pos_type
-basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode)
-{
-    return pos_type(off_type(-1));
+basic_streambuf<_CharT, _Traits>::seekpos(pos_type, ios_base::openmode) {
+  return pos_type(off_type(-1));
 }
 
 template <class _CharT, class _Traits>
-int
-basic_streambuf<_CharT, _Traits>::sync()
-{
-    return 0;
+int basic_streambuf<_CharT, _Traits>::sync() {
+  return 0;
 }
 
 template <class _CharT, class _Traits>
-streamsize
-basic_streambuf<_CharT, _Traits>::showmanyc()
-{
-    return 0;
+streamsize basic_streambuf<_CharT, _Traits>::showmanyc() {
+  return 0;
 }
 
 template <class _CharT, class _Traits>
-streamsize
-basic_streambuf<_CharT, _Traits>::xsgetn(char_type* __s, streamsize __n)
-{
-    const int_type __eof = traits_type::eof();
-    int_type __c;
-    streamsize __i = 0;
-    while(__i < __n)
-    {
-        if (__ninp_ < __einp_)
-        {
-            const streamsize __len = _VSTD::min(static_cast<streamsize>(INT_MAX),
-                                _VSTD::min(__einp_ - __ninp_, __n - __i));
-            traits_type::copy(__s, __ninp_, __len);
-            __s +=  __len;
-            __i +=  __len;
-            this->gbump(__len);
-        }
-        else if ((__c = uflow()) != __eof)
-        {
-            *__s = traits_type::to_char_type(__c);
-            ++__s;
-            ++__i;
-        }
-        else
-            break;
+streamsize basic_streambuf<_CharT, _Traits>::xsgetn(char_type* __s, streamsize __n) {
+  const int_type __eof = traits_type::eof();
+  int_type __c;
+  streamsize __i = 0;
+  while (__i < __n) {
+    if (__ninp_ < __einp_) {
+      const streamsize __len = std::min(static_cast<streamsize>(INT_MAX), std::min(__einp_ - __ninp_, __n - __i));
+      traits_type::copy(__s, __ninp_, __len);
+      __s += __len;
+      __i += __len;
+      this->gbump(__len);
+    } else if ((__c = uflow()) != __eof) {
+      *__s = traits_type::to_char_type(__c);
+      ++__s;
+      ++__i;
+    } else
+      break;
+  }
+  return __i;
+}
+
+template <class _CharT, class _Traits>
+typename basic_streambuf<_CharT, _Traits>::int_type basic_streambuf<_CharT, _Traits>::underflow() {
+  return traits_type::eof();
+}
+
+template <class _CharT, class _Traits>
+typename basic_streambuf<_CharT, _Traits>::int_type basic_streambuf<_CharT, _Traits>::uflow() {
+  if (underflow() == traits_type::eof())
+    return traits_type::eof();
+  return traits_type::to_int_type(*__ninp_++);
+}
+
+template <class _CharT, class _Traits>
+typename basic_streambuf<_CharT, _Traits>::int_type basic_streambuf<_CharT, _Traits>::pbackfail(int_type) {
+  return traits_type::eof();
+}
+
+template <class _CharT, class _Traits>
+streamsize basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n) {
+  streamsize __i = 0;
+  int_type __eof = traits_type::eof();
+  while (__i < __n) {
+    if (__nout_ >= __eout_) {
+      if (overflow(traits_type::to_int_type(*__s)) == __eof)
+        break;
+      ++__s;
+      ++__i;
+    } else {
+      streamsize __chunk_size = std::min(__eout_ - __nout_, __n - __i);
+      traits_type::copy(__nout_, __s, __chunk_size);
+      __nout_ += __chunk_size;
+      __s += __chunk_size;
+      __i += __chunk_size;
     }
-    return __i;
+  }
+  return __i;
 }
 
 template <class _CharT, class _Traits>
-typename basic_streambuf<_CharT, _Traits>::int_type
-basic_streambuf<_CharT, _Traits>::underflow()
-{
-    return traits_type::eof();
-}
-
-template <class _CharT, class _Traits>
-typename basic_streambuf<_CharT, _Traits>::int_type
-basic_streambuf<_CharT, _Traits>::uflow()
-{
-    if (underflow() == traits_type::eof())
-        return traits_type::eof();
-    return traits_type::to_int_type(*__ninp_++);
-}
-
-template <class _CharT, class _Traits>
-typename basic_streambuf<_CharT, _Traits>::int_type
-basic_streambuf<_CharT, _Traits>::pbackfail(int_type)
-{
-    return traits_type::eof();
-}
-
-template <class _CharT, class _Traits>
-streamsize
-basic_streambuf<_CharT, _Traits>::xsputn(const char_type* __s, streamsize __n)
-{
-    streamsize __i = 0;
-    int_type __eof = traits_type::eof();
-    while( __i < __n)
-    {
-        if (__nout_ >= __eout_)
-        {
-            if (overflow(traits_type::to_int_type(*__s)) == __eof)
-                break;
-            ++__s;
-            ++__i;
-        }
-        else
-        {
-            streamsize __chunk_size = _VSTD::min(__eout_ - __nout_, __n - __i);
-            traits_type::copy(__nout_, __s, __chunk_size);
-            __nout_ += __chunk_size;
-            __s     += __chunk_size;
-            __i     += __chunk_size;
-        }
-    }
-    return __i;
-}
-
-template <class _CharT, class _Traits>
-typename basic_streambuf<_CharT, _Traits>::int_type
-basic_streambuf<_CharT, _Traits>::overflow(int_type)
-{
-    return traits_type::eof();
+typename basic_streambuf<_CharT, _Traits>::int_type basic_streambuf<_CharT, _Traits>::overflow(int_type) {
+  return traits_type::eof();
 }
 
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_streambuf<char>;
@@ -499,4 +438,8 @@ _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cstdint>
+#endif
+
 #endif // _LIBCPP_STREAMBUF
diff --git a/third_party/libcxx/string b/third_party/libcxx/string
index ef6957200..b1756794b 100644
--- a/third_party/libcxx/string
+++ b/third_party/libcxx/string
@@ -10,8 +10,9 @@
 #ifndef _LIBCPP_STRING
 #define _LIBCPP_STRING
 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // [jart]
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+
+// clang-format off
 
 /*
     string synopsis
@@ -127,6 +128,8 @@ public:
     template<class InputIterator>
         basic_string(InputIterator begin, InputIterator end,
                      const allocator_type& a = allocator_type());                               // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string(from_range_t, R&& rg, const Allocator& a = Allocator());           // since C++23
     basic_string(initializer_list<value_type>, const Allocator& = Allocator());                 // constexpr since C++20
     basic_string(const basic_string&, const Allocator&);                                        // constexpr since C++20
     basic_string(basic_string&&, const Allocator&);                                             // constexpr since C++20
@@ -174,7 +177,7 @@ public:
     constexpr void resize_and_overwrite(size_type n, Operation op); // since C++23
 
     void reserve(size_type res_arg);                                                            // constexpr since C++20
-    void reserve(); // deprecated in C++20
+    void reserve();                                                                             // deprecated in C++20, removed in C++26
     void shrink_to_fit();                                                                       // constexpr since C++20
     void clear() noexcept;                                                                      // constexpr since C++20
     bool empty() const noexcept;                                                                // constexpr since C++20
@@ -203,6 +206,8 @@ public:
     basic_string& append(size_type n, value_type c);                                            // constexpr since C++20
     template<class InputIterator>
         basic_string& append(InputIterator first, InputIterator last);                          // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& append_range(R&& rg);                                             // C++23
     basic_string& append(initializer_list<value_type>);                                         // constexpr since C++20
 
     void push_back(value_type c);                                                               // constexpr since C++20
@@ -224,6 +229,8 @@ public:
     basic_string& assign(size_type n, value_type c);                                            // constexpr since C++20
     template<class InputIterator>
         basic_string& assign(InputIterator first, InputIterator last);                          // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& assign_range(R&& rg);                                             // C++23
     basic_string& assign(initializer_list<value_type>);                                         // constexpr since C++20
 
     basic_string& insert(size_type pos1, const basic_string& str);                              // constexpr since C++20
@@ -240,6 +247,8 @@ public:
     iterator      insert(const_iterator p, size_type n, value_type c);                          // constexpr since C++20
     template<class InputIterator>
         iterator insert(const_iterator p, InputIterator first, InputIterator last);             // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr iterator insert_range(const_iterator p, R&& rg);                                // C++23
     iterator      insert(const_iterator p, initializer_list<value_type>);                       // constexpr since C++20
 
     basic_string& erase(size_type pos = 0, size_type n = npos);                                 // constexpr since C++20
@@ -265,6 +274,8 @@ public:
     basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c);     // constexpr since C++20
     template<class InputIterator>
         basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2); // constexpr since C++20
+    template<container-compatible-range<charT> R>
+      constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg); // C++23
     basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>);  // constexpr since C++20
 
     size_type copy(value_type* s, size_type n, size_type pos = 0) const;                        // constexpr since C++20
@@ -357,6 +368,26 @@ basic_string(InputIterator, InputIterator, Allocator = Allocator())
                   char_traits<typename iterator_traits<InputIterator>::value_type>,
                   Allocator>;   // C++17
 
+template<ranges::input_range R,
+         class Allocator = allocator<ranges::range_value_t<R>>>
+  basic_string(from_range_t, R&&, Allocator = Allocator())
+    -> basic_string<ranges::range_value_t<R>, char_traits<ranges::range_value_t<R>>,
+                    Allocator>; // C++23
+
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>; // C++17
+
+template<class charT,
+         class traits,
+         class Allocator = allocator<charT>>
+  basic_string(basic_string_view<charT, traits>,
+                typename see below::size_type, typename see below::size_type,
+                const Allocator& = Allocator())
+    -> basic_string<charT, traits, Allocator>; // C++17
+
 template<class charT, class traits, class Allocator>
 basic_string<charT, traits, Allocator>
 operator+(const basic_string<charT, traits, Allocator>& lhs,
@@ -378,6 +409,24 @@ template<class charT, class traits, class Allocator>
 basic_string<charT, traits, Allocator>
 operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);                        // constexpr since C++20
 
+template<class charT, class traits, class Allocator>
+  constexpr basic_string<charT, traits, Allocator>
+    operator+(const basic_string<charT, traits, Allocator>& lhs,
+              type_identity_t<basic_string_view<charT, traits>> rhs);                           // Since C++26
+template<class charT, class traits, class Allocator>
+  constexpr basic_string<charT, traits, Allocator>
+    operator+(basic_string<charT, traits, Allocator>&& lhs,
+              type_identity_t<basic_string_view<charT, traits>> rhs);                           // Since C++26
+template<class charT, class traits, class Allocator>
+  constexpr basic_string<charT, traits, Allocator>
+    operator+(type_identity_t<basic_string_view<charT, traits>> lhs,
+              const basic_string<charT, traits, Allocator>& rhs);                               // Since C++26
+template<class charT, class traits, class Allocator>
+  constexpr basic_string<charT, traits, Allocator>
+    operator+(type_identity_t<basic_string_view<charT, traits>> lhs,
+              basic_string<charT, traits, Allocator>&& rhs);                                    // Since C++26
+
+
 template<class charT, class traits, class Allocator>
 bool operator==(const basic_string<charT, traits, Allocator>& lhs,
                 const basic_string<charT, traits, Allocator>& rhs) noexcept;                    // constexpr since C++20
@@ -527,23 +576,25 @@ template <> struct hash<u16string>;
 template <> struct hash<u32string>;
 template <> struct hash<wstring>;
 
-basic_string<char>     operator "" s( const char *str,     size_t len );           // C++14, constexpr since C++20
-basic_string<wchar_t>  operator "" s( const wchar_t *str,  size_t len );           // C++14, constexpr since C++20
-constexpr basic_string<char8_t>  operator "" s( const char8_t *str,  size_t len ); // C++20
-basic_string<char16_t> operator "" s( const char16_t *str, size_t len );           // C++14, constexpr since C++20
-basic_string<char32_t> operator "" s( const char32_t *str, size_t len );           // C++14, constexpr since C++20
+basic_string<char>     operator""s( const char *str,     size_t len );           // C++14, constexpr since C++20
+basic_string<wchar_t>  operator""s( const wchar_t *str,  size_t len );           // C++14, constexpr since C++20
+constexpr basic_string<char8_t>  operator""s( const char8_t *str,  size_t len ); // C++20
+basic_string<char16_t> operator""s( const char16_t *str, size_t len );           // C++14, constexpr since C++20
+basic_string<char32_t> operator""s( const char32_t *str, size_t len );           // C++14, constexpr since C++20
 
 }  // std
 
 */
 
+// clang-format on
+
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
-#include <__debug>
+#include <__debug_utils/sanitizers.h>
 #include <__format/enable_insertable.h>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
@@ -562,25 +613,35 @@ basic_string<char32_t> operator "" s( const char32_t *str, size_t len );
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
+#include <__ranges/size.h>
 #include <__string/char_traits.h>
 #include <__string/extern_template_lists.h>
+#include <__type_traits/conditional.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_convertible.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_standard_layout.h>
 #include <__type_traits/is_trivial.h>
+#include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/noexcept_move_assign_container.h>
 #include <__type_traits/remove_cvref.h>
+#include <__type_traits/void_t.h>
 #include <__utility/auto_cast.h>
+#include <__utility/declval.h>
+#include <__utility/forward.h>
+#include <__utility/is_pointer_in_range.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__utility/unreachable.h>
 #include <climits>
-#include <cstdint>
-#include <cstdio>  // EOF
+#include <cstdio> // EOF
 #include <cstring>
 #include <limits>
 #include <stdexcept>
@@ -611,234 +672,289 @@ basic_string<char32_t> operator "" s( const char32_t *str, size_t len );
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
+#if !defined(_LIBCPP_HAS_NO_ASAN) && defined(_LIBCPP_INSTRUMENTED_WITH_ASAN)
+#  define _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS __attribute__((__no_sanitize__("address")))
+// This macro disables AddressSanitizer (ASan) instrumentation for a specific function,
+// allowing memory accesses that would normally trigger ASan errors to proceed without crashing.
+// This is useful for accessing parts of objects memory, which should not be accessed,
+// such as unused bytes in short strings, that should never be accessed
+// by other parts of the program.
+#else
+#  define _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
+#endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // basic_string
 
-template<class _CharT, class _Traits, class _Allocator>
-basic_string<_CharT, _Traits, _Allocator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-operator+(const basic_string<_CharT, _Traits, _Allocator>& __x,
-          const basic_string<_CharT, _Traits, _Allocator>& __y);
+template <class _CharT, class _Traits, class _Allocator>
+basic_string<_CharT, _Traits, _Allocator> _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const basic_string<_CharT, _Traits, _Allocator>& __y);
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDDEN _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDDEN _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(const _CharT* __x, const basic_string<_CharT, _Traits, _Allocator>& __y);
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(_CharT __x, const basic_string<_CharT, _Traits, _Allocator>& __y);
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y);
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
 
-extern template _LIBCPP_FUNC_VIS string operator+<char, char_traits<char>, allocator<char> >(char const*, string const&);
+#if _LIBCPP_STD_VER >= 26
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI constexpr basic_string<_CharT, _Traits, _Allocator>
+operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+          type_identity_t<basic_string_view<_CharT, _Traits>> __rhs);
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI constexpr basic_string<_CharT, _Traits, _Allocator>
+operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, type_identity_t<basic_string_view<_CharT, _Traits>> __rhs);
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI constexpr basic_string<_CharT, _Traits, _Allocator>
+operator+(type_identity_t<basic_string_view<_CharT, _Traits>> __lhs,
+          const basic_string<_CharT, _Traits, _Allocator>& __rhs);
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI constexpr basic_string<_CharT, _Traits, _Allocator>
+operator+(type_identity_t<basic_string_view<_CharT, _Traits>> __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs);
+
+#endif
+
+extern template _LIBCPP_EXPORTED_FROM_ABI string operator+
+    <char, char_traits<char>, allocator<char> >(char const*, string const&);
 
 template <class _Iter>
 struct __string_is_trivial_iterator : public false_type {};
 
 template <class _Tp>
-struct __string_is_trivial_iterator<_Tp*>
-    : public is_arithmetic<_Tp> {};
+struct __string_is_trivial_iterator<_Tp*> : public is_arithmetic<_Tp> {};
 
 template <class _Iter>
-struct __string_is_trivial_iterator<__wrap_iter<_Iter> >
-    : public __string_is_trivial_iterator<_Iter> {};
+struct __string_is_trivial_iterator<__wrap_iter<_Iter> > : public __string_is_trivial_iterator<_Iter> {};
 
 template <class _CharT, class _Traits, class _Tp>
-struct __can_be_converted_to_string_view : public _BoolConstant<
-      is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
-     !is_convertible<const _Tp&, const _CharT*>::value
-    > {};
+struct __can_be_converted_to_string_view
+    : public _BoolConstant< is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
+                            !is_convertible<const _Tp&, const _CharT*>::value > {};
 
 struct __uninitialized_size_tag {};
+struct __init_with_sentinel_tag {};
+
+template <class _CharT, class _Traits, class _Allocator>
+class basic_string {
+private:
+  using __default_allocator_type = allocator<_CharT>;
 
-template<class _CharT, class _Traits, class _Allocator>
-class basic_string
-{
 public:
-    typedef basic_string                                 __self;
-    typedef basic_string_view<_CharT, _Traits>           __self_view;
-    typedef _Traits                                      traits_type;
-    typedef _CharT                                       value_type;
-    typedef _Allocator                                   allocator_type;
-    typedef allocator_traits<allocator_type>             __alloc_traits;
-    typedef typename __alloc_traits::size_type           size_type;
-    typedef typename __alloc_traits::difference_type     difference_type;
-    typedef value_type&                                  reference;
-    typedef const value_type&                            const_reference;
-    typedef typename __alloc_traits::pointer             pointer;
-    typedef typename __alloc_traits::const_pointer       const_pointer;
+  typedef basic_string __self;
+  typedef basic_string_view<_CharT, _Traits> __self_view;
+  typedef _Traits traits_type;
+  typedef _CharT value_type;
+  typedef _Allocator allocator_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
+  typedef typename __alloc_traits::size_type size_type;
+  typedef typename __alloc_traits::difference_type difference_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
 
-    static_assert((!is_array<value_type>::value), "Character type of basic_string must not be an array");
-    static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string must be standard-layout");
-    static_assert(( is_trivial<value_type>::value), "Character type of basic_string must be trivial");
-    static_assert(( is_same<_CharT, typename traits_type::char_type>::value),
-                  "traits_type::char_type must be the same type as CharT");
-    static_assert(( is_same<typename allocator_type::value_type, value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
+  // A basic_string contains the following members which may be trivially relocatable:
+  // - pointer: is currently assumed to be trivially relocatable, but is still checked in case that changes
+  // - size_type: is always trivially relocatable, since it has to be an integral type
+  // - value_type: is always trivially relocatable, since it has to be trivial
+  // - unsigned char: is a fundamental type, so it's trivially relocatable
+  // - allocator_type: may or may not be trivially relocatable, so it's checked
+  //
+  // This string implementation doesn't contain any references into itself. It only contains a bit that says whether
+  // it is in small or large string mode, so the entire structure is trivially relocatable if its members are.
+#if !defined(_LIBCPP_HAS_NO_ASAN) && defined(_LIBCPP_INSTRUMENTED_WITH_ASAN)
+  // When compiling with AddressSanitizer (ASan), basic_string cannot be trivially
+  // relocatable. Because the object's memory might be poisoned when its content
+  // is kept inside objects memory (short string optimization), instead of in allocated
+  // external memory. In such cases, the destructor is responsible for unpoisoning
+  // the memory to avoid triggering false positives.
+  // Therefore it's crucial to ensure the destructor is called.
+  using __trivially_relocatable = void;
+#else
+  using __trivially_relocatable = __conditional_t<
+      __libcpp_is_trivially_relocatable<allocator_type>::value && __libcpp_is_trivially_relocatable<pointer>::value,
+      basic_string,
+      void>;
+#endif
+#if !defined(_LIBCPP_HAS_NO_ASAN) && defined(_LIBCPP_INSTRUMENTED_WITH_ASAN)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pointer __asan_volatile_wrapper(pointer const& __ptr) const {
+    if (__libcpp_is_constant_evaluated())
+      return __ptr;
 
-    static_assert(is_same<allocator_type, __rebind_alloc<__alloc_traits, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
+    pointer volatile __copy_ptr = __ptr;
 
-    // TODO: Implement iterator bounds checking without requiring the global database.
-    typedef __wrap_iter<pointer>                         iterator;
-    typedef __wrap_iter<const_pointer>                   const_iterator;
-    typedef std::reverse_iterator<iterator>              reverse_iterator;
-    typedef std::reverse_iterator<const_iterator>        const_reverse_iterator;
+    return const_cast<pointer&>(__copy_ptr);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_pointer
+  __asan_volatile_wrapper(const_pointer const& __ptr) const {
+    if (__libcpp_is_constant_evaluated())
+      return __ptr;
+
+    const_pointer volatile __copy_ptr = __ptr;
+
+    return const_cast<const_pointer&>(__copy_ptr);
+  }
+#  define _LIBCPP_ASAN_VOLATILE_WRAPPER(PTR) __asan_volatile_wrapper(PTR)
+#else
+#  define _LIBCPP_ASAN_VOLATILE_WRAPPER(PTR) PTR
+#endif
+
+  static_assert(!is_array<value_type>::value, "Character type of basic_string must not be an array");
+  static_assert(is_standard_layout<value_type>::value, "Character type of basic_string must be standard-layout");
+  static_assert(is_trivial<value_type>::value, "Character type of basic_string must be trivial");
+  static_assert(is_same<_CharT, typename traits_type::char_type>::value,
+                "traits_type::char_type must be the same type as CharT");
+  static_assert(is_same<typename allocator_type::value_type, value_type>::value,
+                "Allocator::value_type must be same type as value_type");
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
+
+  // TODO: Implement iterator bounds checking without requiring the global database.
+  typedef __wrap_iter<pointer> iterator;
+  typedef __wrap_iter<const_pointer> const_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
 private:
-    static_assert(CHAR_BIT == 8, "This implementation assumes that one byte contains 8 bits");
+  static_assert(CHAR_BIT == 8, "This implementation assumes that one byte contains 8 bits");
 
 #ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
-    struct __long
-    {
-        pointer   __data_;
-        size_type __size_;
-        size_type __cap_ : sizeof(size_type) * CHAR_BIT - 1;
-        size_type __is_long_ : 1;
-    };
+  struct __long {
+    pointer __data_;
+    size_type __size_;
+    size_type __cap_ : sizeof(size_type) * CHAR_BIT - 1;
+    size_type __is_long_ : 1;
+  };
 
-    enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
-                      (sizeof(__long) - 1)/sizeof(value_type) : 2};
+  enum { __min_cap = (sizeof(__long) - 1) / sizeof(value_type) > 2 ? (sizeof(__long) - 1) / sizeof(value_type) : 2 };
 
-    struct __short
-    {
-        value_type __data_[__min_cap];
-        unsigned char __padding_[sizeof(value_type) - 1];
-        unsigned char __size_ : 7;
-        unsigned char __is_long_ : 1;
-    };
+  struct __short {
+    value_type __data_[__min_cap];
+    unsigned char __padding_[sizeof(value_type) - 1];
+    unsigned char __size_    : 7;
+    unsigned char __is_long_ : 1;
+  };
 
-// The __endian_factor is required because the field we use to store the size
-// has one fewer bit than it would if it were not a bitfield.
-//
-// If the LSB is used to store the short-flag in the short string representation,
-// we have to multiply the size by two when it is stored and divide it by two when
-// it is loaded to make sure that we always store an even number. In the long string
-// representation, we can ignore this because we can assume that we always allocate
-// an even amount of value_types.
-//
-// If the MSB is used for the short-flag, the max_size() is numeric_limits<size_type>::max() / 2.
-// This does not impact the short string representation, since we never need the MSB
-// for representing the size of a short string anyway.
+  // The __endian_factor is required because the field we use to store the size
+  // has one fewer bit than it would if it were not a bitfield.
+  //
+  // If the LSB is used to store the short-flag in the short string representation,
+  // we have to multiply the size by two when it is stored and divide it by two when
+  // it is loaded to make sure that we always store an even number. In the long string
+  // representation, we can ignore this because we can assume that we always allocate
+  // an even amount of value_types.
+  //
+  // If the MSB is used for the short-flag, the max_size() is numeric_limits<size_type>::max() / 2.
+  // This does not impact the short string representation, since we never need the MSB
+  // for representing the size of a short string anyway.
 
-#ifdef _LIBCPP_BIG_ENDIAN
-    static const size_type __endian_factor = 2;
-#else
-    static const size_type __endian_factor = 1;
-#endif
+#  ifdef _LIBCPP_BIG_ENDIAN
+  static const size_type __endian_factor = 2;
+#  else
+  static const size_type __endian_factor = 1;
+#  endif
 
 #else // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
-#ifdef _LIBCPP_BIG_ENDIAN
-    static const size_type __endian_factor = 1;
-#else
-    static const size_type __endian_factor = 2;
-#endif
+#  ifdef _LIBCPP_BIG_ENDIAN
+  static const size_type __endian_factor = 1;
+#  else
+  static const size_type __endian_factor = 2;
+#  endif
 
-    // Attribute 'packed' is used to keep the layout compatible with the
-    // previous definition that did not use bit fields. This is because on
-    // some platforms bit fields have a default size rather than the actual
-    // size used, e.g., it is 4 bytes on AIX. See D128285 for details.
-    struct __long
-    {
-        struct _LIBCPP_PACKED {
-            size_type __is_long_ : 1;
-            size_type __cap_ : sizeof(size_type) * CHAR_BIT - 1;
-        };
-        size_type __size_;
-        pointer   __data_;
+  // Attribute 'packed' is used to keep the layout compatible with the
+  // previous definition that did not use bit fields. This is because on
+  // some platforms bit fields have a default size rather than the actual
+  // size used, e.g., it is 4 bytes on AIX. See D128285 for details.
+  struct __long {
+    struct _LIBCPP_PACKED {
+      size_type __is_long_ : 1;
+      size_type __cap_ : sizeof(size_type) * CHAR_BIT - 1;
     };
+    size_type __size_;
+    pointer __data_;
+  };
 
-    enum {__min_cap = (sizeof(__long) - 1)/sizeof(value_type) > 2 ?
-                      (sizeof(__long) - 1)/sizeof(value_type) : 2};
+  enum { __min_cap = (sizeof(__long) - 1) / sizeof(value_type) > 2 ? (sizeof(__long) - 1) / sizeof(value_type) : 2 };
 
-    struct __short
-    {
-        struct _LIBCPP_PACKED {
-            unsigned char __is_long_ : 1;
-            unsigned char __size_ : 7;
-        };
-        char __padding_[sizeof(value_type) - 1];
-        value_type __data_[__min_cap];
+  struct __short {
+    struct _LIBCPP_PACKED {
+      unsigned char __is_long_ : 1;
+      unsigned char __size_    : 7;
     };
+    char __padding_[sizeof(value_type) - 1];
+    value_type __data_[__min_cap];
+  };
 
 #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
-    static_assert(sizeof(__short) == (sizeof(value_type) * (__min_cap + 1)), "__short has an unexpected size.");
+  static_assert(sizeof(__short) == (sizeof(value_type) * (__min_cap + 1)), "__short has an unexpected size.");
 
-    union __ulx{__long __lx; __short __lxx;};
+  union __rep {
+    __short __s;
+    __long __l;
+  };
 
-    enum {__n_words = sizeof(__ulx) / sizeof(size_type)};
+  __compressed_pair<__rep, allocator_type> __r_;
 
-    struct __raw
-    {
-        size_type __words[__n_words];
-    };
-
-    struct __rep
-    {
-        union
-        {
-            __long  __l;
-            __short __s;
-            __raw   __r;
-        };
-    };
-
-    __compressed_pair<__rep, allocator_type> __r_;
-
-    // Construct a string with the given allocator and enough storage to hold `__size` characters, but
-    // don't initialize the characters. The contents of the string, including the null terminator, must be
-    // initialized separately.
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    explicit basic_string(__uninitialized_size_tag, size_type __size, const allocator_type& __a)
-            : __r_(__default_init_tag(), __a) {
-        if (__size > max_size())
-            __throw_length_error();
-        if (__fits_in_sso(__size)) {
-            __r_.first() = __rep();
-            __set_short_size(__size);
-        } else {
-            auto __capacity = __recommend(__size) + 1;
-            auto __allocation = __alloc_traits::allocate(__alloc(), __capacity);
-            __begin_lifetime(__allocation, __capacity);
-            __set_long_cap(__capacity);
-            __set_long_pointer(__allocation);
-            __set_long_size(__size);
-        }
-        std::__debug_db_insert_c(this);
+  // Construct a string with the given allocator and enough storage to hold `__size` characters, but
+  // don't initialize the characters. The contents of the string, including the null terminator, must be
+  // initialized separately.
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit basic_string(
+      __uninitialized_size_tag, size_type __size, const allocator_type& __a)
+      : __r_(__default_init_tag(), __a) {
+    if (__size > max_size())
+      __throw_length_error();
+    if (__fits_in_sso(__size)) {
+      __r_.first() = __rep();
+      __set_short_size(__size);
+    } else {
+      auto __capacity   = __recommend(__size) + 1;
+      auto __allocation = __alloc_traits::allocate(__alloc(), __capacity);
+      __begin_lifetime(__allocation, __capacity);
+      __set_long_cap(__capacity);
+      __set_long_pointer(__allocation);
+      __set_long_size(__size);
     }
+    __annotate_new(__size);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator __make_iterator(pointer __p) {
-        return iterator(this, __p);
-    }
+  template <class _Iter, class _Sent>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  basic_string(__init_with_sentinel_tag, _Iter __first, _Sent __last, const allocator_type& __a)
+      : __r_(__default_init_tag(), __a) {
+    __init_with_sentinel(std::move(__first), std::move(__last));
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator __make_const_iterator(const_pointer __p) const {
-        return const_iterator(this, __p);
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator __make_iterator(pointer __p) { return iterator(__p); }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator __make_const_iterator(const_pointer __p) const {
+    return const_iterator(__p);
+  }
 
 public:
   _LIBCPP_TEMPLATE_DATA_VIS static const size_type npos = -1;
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string()
       _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
-      : __r_(__default_init_tag(), __default_init_tag()) {
-    std::__debug_db_insert_c(this);
-    __default_init();
+      : __r_(__value_init_tag(), __default_init_tag()) {
+    __annotate_new(0);
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit basic_string(const allocator_type& __a)
@@ -847,27 +963,27 @@ public:
 #else
       _NOEXCEPT
 #endif
-      : __r_(__default_init_tag(), __a) {
-    std::__debug_db_insert_c(this);
-    __default_init();
+      : __r_(__value_init_tag(), __a) {
+    __annotate_new(0);
   }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const basic_string& __str)
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS basic_string(const basic_string& __str)
       : __r_(__default_init_tag(), __alloc_traits::select_on_container_copy_construction(__str.__alloc())) {
-    if (!__str.__is_long())
+    if (!__str.__is_long()) {
       __r_.first() = __str.__r_.first();
-    else
+      __annotate_new(__get_short_size());
+    } else
       __init_copy_ctor_external(std::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
-    std::__debug_db_insert_c(this);
   }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const basic_string& __str, const allocator_type& __a)
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
+  basic_string(const basic_string& __str, const allocator_type& __a)
       : __r_(__default_init_tag(), __a) {
-    if (!__str.__is_long())
+    if (!__str.__is_long()) {
       __r_.first() = __str.__r_.first();
-    else
+      __annotate_new(__get_short_size());
+    } else
       __init_copy_ctor_external(std::__to_address(__str.__get_long_pointer()), __str.__get_long_size());
-    std::__debug_db_insert_c(this);
   }
 
 #ifndef _LIBCPP_CXX03_LANG
@@ -877,11 +993,18 @@ public:
 #  else
       _NOEXCEPT
 #  endif
-      : __r_(std::move(__str.__r_)) {
-    __str.__default_init();
-    std::__debug_db_insert_c(this);
-    if (__is_long())
-      std::__debug_db_swap(this, &__str);
+      // Turning off ASan instrumentation for variable initialization with _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS
+      // does not work consistently during initialization of __r_, so we instead unpoison __str's memory manually first.
+      // __str's memory needs to be unpoisoned only in the case where it's a short string.
+      : __r_([](basic_string& __s) -> decltype(__s.__r_)&& {
+          if (!__s.__is_long())
+            __s.__annotate_delete();
+          return std::move(__s.__r_);
+        }(__str)) {
+    __str.__r_.first() = __rep();
+    __str.__annotate_new(0);
+    if (!__is_long())
+      __annotate_new(size());
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(basic_string&& __str, const allocator_type& __a)
@@ -891,29 +1014,29 @@ public:
     else {
       if (__libcpp_is_constant_evaluated())
         __r_.first() = __rep();
-      __r_.first() = __str.__r_.first();
-      __str.__default_init();
+      if (!__str.__is_long())
+        __str.__annotate_delete();
+      __r_.first()       = __str.__r_.first();
+      __str.__r_.first() = __rep();
+      __str.__annotate_new(0);
+      if (!__is_long() && this != &__str)
+        __annotate_new(size());
     }
-    std::__debug_db_insert_c(this);
-    if (__is_long())
-      std::__debug_db_swap(this, &__str);
   }
 #endif // _LIBCPP_CXX03_LANG
 
   template <__enable_if_t<__is_allocator<_Allocator>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* __s)
       : __r_(__default_init_tag(), __default_init_tag()) {
-    _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*) detected nullptr");
+    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "basic_string(const char*) detected nullptr");
     __init(__s, traits_type::length(__s));
-    std::__debug_db_insert_c(this);
   }
 
   template <__enable_if_t<__is_allocator<_Allocator>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* __s, const _Allocator& __a)
       : __r_(__default_init_tag(), __a) {
-    _LIBCPP_ASSERT(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
+    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "basic_string(const char*, allocator) detected nullptr");
     __init(__s, traits_type::length(__s));
-    std::__debug_db_insert_c(this);
   }
 
 #if _LIBCPP_STD_VER >= 23
@@ -922,52 +1045,40 @@ public:
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* __s, size_type __n)
       : __r_(__default_init_tag(), __default_init_tag()) {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
+    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "basic_string(const char*, n) detected nullptr");
     __init(__s, __n);
-    std::__debug_db_insert_c(this);
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
   basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
       : __r_(__default_init_tag(), __a) {
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
+    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
     __init(__s, __n);
-    std::__debug_db_insert_c(this);
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(size_type __n, _CharT __c)
       : __r_(__default_init_tag(), __default_init_tag()) {
     __init(__n, __c);
-    std::__debug_db_insert_c(this);
   }
 
 #if _LIBCPP_STD_VER >= 23
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  basic_string(basic_string&& __str, size_type __pos, const _Allocator& __alloc = _Allocator())
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_string(
+      basic_string&& __str, size_type __pos, const _Allocator& __alloc = _Allocator())
       : basic_string(std::move(__str), __pos, npos, __alloc) {}
 
-  _LIBCPP_HIDE_FROM_ABI constexpr
-  basic_string(basic_string&& __str, size_type __pos, size_type __n, const _Allocator& __alloc = _Allocator())
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_string(
+      basic_string&& __str, size_type __pos, size_type __n, const _Allocator& __alloc = _Allocator())
       : __r_(__default_init_tag(), __alloc) {
     if (__pos > __str.size())
       __throw_out_of_range();
 
     auto __len = std::min<size_type>(__n, __str.size() - __pos);
     if (__alloc_traits::is_always_equal::value || __alloc == __str.__alloc()) {
-      __r_.first() = __str.__r_.first();
-      __str.__default_init();
-
-      _Traits::move(data(), data() + __pos, __len);
-      __set_size(__len);
-      _Traits::assign(data()[__len], value_type());
+      __move_assign(std::move(__str), __pos, __len);
     } else {
       // Perform a copy because the allocators are not compatible.
       __init(__str.data() + __pos, __len);
     }
-
-    std::__debug_db_insert_c(this);
-    if (__is_long())
-      std::__debug_db_swap(this, &__str);
   }
 #endif
 
@@ -975,7 +1086,6 @@ public:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(size_type __n, _CharT __c, const _Allocator& __a)
       : __r_(__default_init_tag(), __a) {
     __init(__n, __c);
-    std::__debug_db_insert_c(this);
   }
 
   _LIBCPP_CONSTEXPR_SINCE_CXX20
@@ -985,7 +1095,6 @@ public:
     if (__pos > __str_sz)
       __throw_out_of_range();
     __init(__str.data() + __pos, std::min(__n, __str_sz - __pos));
-    std::__debug_db_insert_c(this);
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
@@ -995,7 +1104,6 @@ public:
     if (__pos > __str_sz)
       __throw_out_of_range();
     __init(__str.data() + __pos, __str_sz - __pos);
-    std::__debug_db_insert_c(this);
   }
 
   template <class _Tp,
@@ -1008,7 +1116,6 @@ public:
     __self_view __sv0 = __t;
     __self_view __sv  = __sv0.substr(__pos, __n);
     __init(__sv.data(), __sv.size());
-    std::__debug_db_insert_c(this);
   }
 
   template <class _Tp,
@@ -1019,26 +1126,23 @@ public:
       : __r_(__default_init_tag(), __default_init_tag()) {
     __self_view __sv = __t;
     __init(__sv.data(), __sv.size());
-    std::__debug_db_insert_c(this);
   }
 
   template <class _Tp,
             __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
                               !__is_same_uncvref<_Tp, basic_string>::value,
                           int> = 0>
-  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit basic_string(
-      const _Tp& __t, const allocator_type& __a)
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit basic_string(const _Tp& __t, const allocator_type& __a)
       : __r_(__default_init_tag(), __a) {
     __self_view __sv = __t;
     __init(__sv.data(), __sv.size());
-    std::__debug_db_insert_c(this);
   }
 
   template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(_InputIterator __first, _InputIterator __last)
       : __r_(__default_init_tag(), __default_init_tag()) {
     __init(__first, __last);
-    std::__debug_db_insert_c(this);
   }
 
   template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
@@ -1046,180 +1150,201 @@ public:
   basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a)
       : __r_(__default_init_tag(), __a) {
     __init(__first, __last);
-    std::__debug_db_insert_c(this);
   }
 
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_CharT> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_string(
+      from_range_t, _Range&& __range, const allocator_type& __a = allocator_type())
+      : __r_(__default_init_tag(), __a) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      __init_with_size(ranges::begin(__range), ranges::end(__range), ranges::distance(__range));
+    } else {
+      __init_with_sentinel(ranges::begin(__range), ranges::end(__range));
+    }
+  }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(initializer_list<_CharT> __il)
       : __r_(__default_init_tag(), __default_init_tag()) {
     __init(__il.begin(), __il.end());
-    std::__debug_db_insert_c(this);
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(initializer_list<_CharT> __il, const _Allocator& __a)
       : __r_(__default_init_tag(), __a) {
     __init(__il.begin(), __il.end());
-    std::__debug_db_insert_c(this);
   }
 #endif // _LIBCPP_CXX03_LANG
 
   inline _LIBCPP_CONSTEXPR_SINCE_CXX20 ~basic_string() {
-    std::__debug_db_erase_c(this);
+    __annotate_delete();
     if (__is_long())
       __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
   }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    operator __self_view() const _NOEXCEPT { return __self_view(data(), size()); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 operator __self_view() const _NOEXCEPT {
+    return __self_view(data(), size());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(const basic_string& __str);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS basic_string&
+  operator=(const basic_string& __str);
 
-    template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
-                                           !__is_same_uncvref<_Tp, basic_string>::value, int> = 0>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(const _Tp& __t) {
-      __self_view __sv = __t;
-      return assign(__sv);
-    }
+  template <class _Tp,
+            __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
+                              !__is_same_uncvref<_Tp, basic_string>::value,
+                          int> = 0>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(const _Tp& __t) {
+    __self_view __sv = __t;
+    return assign(__sv);
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(basic_string&& __str)
-      _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value)) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
+  operator=(basic_string&& __str) noexcept(__noexcept_move_assign_container<_Allocator, __alloc_traits>::value) {
     __move_assign(__str, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
     return *this;
   }
 
-     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string& operator=(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(initializer_list<value_type> __il) {
+    return assign(__il.begin(), __il.size());
+  }
 #endif
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string& operator=(const value_type* __s) {return assign(__s);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(const value_type* __s) {
+    return assign(__s);
+  }
 #if _LIBCPP_STD_VER >= 23
-    basic_string& operator=(nullptr_t) = delete;
+  basic_string& operator=(nullptr_t) = delete;
 #endif
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(value_type __c);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(value_type __c);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    iterator begin() _NOEXCEPT
-        {return __make_iterator(__get_pointer());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_iterator begin() const _NOEXCEPT
-        {return __make_const_iterator(__get_pointer());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    iterator end() _NOEXCEPT
-        {return __make_iterator(__get_pointer() + size());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_iterator end() const _NOEXCEPT
-        {return __make_const_iterator(__get_pointer() + size());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator begin() _NOEXCEPT {
+    return __make_iterator(__get_pointer());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator begin() const _NOEXCEPT {
+    return __make_const_iterator(__get_pointer());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator end() _NOEXCEPT {
+    return __make_iterator(__get_pointer() + size());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator end() const _NOEXCEPT {
+    return __make_const_iterator(__get_pointer() + size());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    reverse_iterator rbegin() _NOEXCEPT
-        {return reverse_iterator(end());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    reverse_iterator rend() _NOEXCEPT
-        {return reverse_iterator(begin());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_reverse_iterator rend() const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rbegin() _NOEXCEPT {
+    return reverse_iterator(end());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator rbegin() const _NOEXCEPT {
+    return const_reverse_iterator(end());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rend() _NOEXCEPT {
+    return reverse_iterator(begin());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator rend() const _NOEXCEPT {
+    return const_reverse_iterator(begin());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_iterator cbegin() const _NOEXCEPT
-        {return begin();}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_iterator cend() const _NOEXCEPT
-        {return end();}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_reverse_iterator crbegin() const _NOEXCEPT
-        {return rbegin();}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_reverse_iterator crend() const _NOEXCEPT
-        {return rend();}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cend() const _NOEXCEPT { return end(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator crbegin() const _NOEXCEPT {
+    return rbegin();
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type size() const _NOEXCEPT
-        {return __is_long() ? __get_long_size() : __get_short_size();}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type length() const _NOEXCEPT {return size();}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type size() const _NOEXCEPT {
+    return __is_long() ? __get_long_size() : __get_short_size();
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type length() const _NOEXCEPT { return size(); }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type max_size() const _NOEXCEPT {
     size_type __m = __alloc_traits::max_size(__alloc());
     if (__m <= std::numeric_limits<size_type>::max() / 2) {
       return __m - __alignment;
     } else {
-    bool __uses_lsb = __endian_factor == 2;
+      bool __uses_lsb = __endian_factor == 2;
       return __uses_lsb ? __m - __alignment : (__m / 2) - __alignment;
     }
   }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type capacity() const _NOEXCEPT {
-        return (__is_long() ? __get_long_cap() : static_cast<size_type>(__min_cap)) - 1;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type capacity() const _NOEXCEPT {
+    return (__is_long() ? __get_long_cap() : static_cast<size_type>(__min_cap)) - 1;
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void resize(size_type __n, value_type __c);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void resize(size_type __n) { resize(__n, value_type()); }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 void resize(size_type __n, value_type __c);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void resize(size_type __n) { resize(__n, value_type()); }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void reserve(size_type __requested_capacity);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 void reserve(size_type __requested_capacity);
 
 #if _LIBCPP_STD_VER >= 23
-    template <class _Op>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    void resize_and_overwrite(size_type __n, _Op __op) {
-      __resize_default_init(__n);
-      __erase_to_end(std::move(__op)(data(), _LIBCPP_AUTO_CAST(__n)));
-    }
+  template <class _Op>
+  _LIBCPP_HIDE_FROM_ABI constexpr void resize_and_overwrite(size_type __n, _Op __op) {
+    __resize_default_init(__n);
+    __erase_to_end(std::move(__op)(data(), _LIBCPP_AUTO_CAST(__n)));
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __resize_default_init(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __resize_default_init(size_type __n);
 
-    _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI void reserve() _NOEXCEPT { shrink_to_fit(); }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void shrink_to_fit() _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void clear() _NOEXCEPT;
+#if _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRING_RESERVE)
+  _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI void reserve() _NOEXCEPT { shrink_to_fit(); }
+#endif
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void shrink_to_fit() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void clear() _NOEXCEPT;
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    bool empty() const _NOEXCEPT {return size() == 0;}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool empty() const _NOEXCEPT {
+    return size() == 0;
+  }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference operator[](size_type __pos) const _NOEXCEPT {
-    _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__pos <= size(), "string index out of bounds");
+    if (__builtin_constant_p(__pos) && !__fits_in_sso(__pos)) {
+      return *(__get_long_pointer() + __pos);
+    }
     return *(data() + __pos);
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator[](size_type __pos) _NOEXCEPT {
-    _LIBCPP_ASSERT(__pos <= size(), "string index out of bounds");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__pos <= size(), "string index out of bounds");
+    if (__builtin_constant_p(__pos) && !__fits_in_sso(__pos)) {
+      return *(__get_long_pointer() + __pos);
+    }
     return *(__get_pointer() + __pos);
   }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference at(size_type __n) const;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 reference       at(size_type __n);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference at(size_type __n) const;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 reference at(size_type __n);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(const basic_string& __str) {
-        return append(__str);
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(const basic_string& __str) {
+    return append(__str);
+  }
 
-    template <class _Tp,
-              __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
-                                !__is_same_uncvref<_Tp, basic_string >::value,
-                            int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
-    operator+=(const _Tp& __t) {
-        __self_view __sv = __t; return append(__sv);
-    }
+  template <class _Tp,
+            __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
+                              !__is_same_uncvref<_Tp, basic_string >::value,
+                          int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
+  operator+=(const _Tp& __t) {
+    __self_view __sv = __t;
+    return append(__sv);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(const value_type* __s) {
-        return append(__s);
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(const value_type* __s) {
+    return append(__s);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(value_type __c) {
-        push_back(__c);
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(value_type __c) {
+    push_back(__c);
+    return *this;
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string& operator+=(initializer_list<value_type> __il) { return append(__il); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(initializer_list<value_type> __il) {
+    return append(__il);
+  }
 #endif // _LIBCPP_CXX03_LANG
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const basic_string& __str) {
-        return append(__str.data(), __str.size());
+    return append(__str.data(), __str.size());
   }
 
   template <class _Tp,
@@ -1228,65 +1353,73 @@ public:
                           int> = 0>
   _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
   append(const _Tp& __t) {
-        __self_view __sv = __t;
-        return append(__sv.data(), __sv.size());
+    __self_view __sv = __t;
+    return append(__sv.data(), __sv.size());
   }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const basic_string& __str, size_type __pos, size_type __n=npos);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const basic_string& __str, size_type __pos, size_type __n = npos);
 
-    template <class _Tp,
-              __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
-                                !__is_same_uncvref<_Tp, basic_string>::value,
-                            int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20
+  template <class _Tp,
+            __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
+                              !__is_same_uncvref<_Tp, basic_string>::value,
+                          int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20
 
-        basic_string&
-        append(const _Tp& __t, size_type __pos, size_type __n = npos);
+  basic_string&
+  append(const _Tp& __t, size_type __pos, size_type __n = npos);
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const value_type* __s, size_type __n);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const value_type* __s);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(size_type __n, value_type __c);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const value_type* __s, size_type __n);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const value_type* __s);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(size_type __n, value_type __c);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __append_default_init(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __append_default_init(size_type __n);
 
-    template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
-    append(_InputIterator __first, _InputIterator __last) {
-        const basic_string __temp(__first, __last, __alloc());
-        append(__temp.data(), __temp.size());
-        return *this;
-    }
+  template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
+  append(_InputIterator __first, _InputIterator __last) {
+    const basic_string __temp(__first, __last, __alloc());
+    append(__temp.data(), __temp.size());
+    return *this;
+  }
 
-    template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
-    append(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
+  append(_ForwardIterator __first, _ForwardIterator __last);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_CharT> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_string& append_range(_Range&& __range) {
+    insert_range(end(), std::forward<_Range>(__range));
+    return *this;
+  }
+#endif
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(initializer_list<value_type> __il) {
+    return append(__il.begin(), __il.size());
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void push_back(value_type __c);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void pop_back();
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 void push_back(value_type __c);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void pop_back();
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference front() _NOEXCEPT {
-    _LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::front(): string is empty");
     return *__get_pointer();
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference front() const _NOEXCEPT {
-    _LIBCPP_ASSERT(!empty(), "string::front(): string is empty");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::front(): string is empty");
     return *data();
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference back() _NOEXCEPT {
-    _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::back(): string is empty");
     return *(__get_pointer() + size() - 1);
   }
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference back() const _NOEXCEPT {
-    _LIBCPP_ASSERT(!empty(), "string::back(): string is empty");
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::back(): string is empty");
     return *(data() + size() - 1);
   }
 
@@ -1297,37 +1430,79 @@ public:
     return assign(__sv.data(), __sv.size());
   }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string& assign(const basic_string& __str) { return *this = __str; }
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string& assign(basic_string&& __str)
-        _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
-        {*this = std::move(__str); return *this;}
+#if _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI constexpr void __move_assign(basic_string&& __str, size_type __pos, size_type __len) {
+    // Pilfer the allocation from __str.
+    _LIBCPP_ASSERT_INTERNAL(__alloc() == __str.__alloc(), "__move_assign called with wrong allocator");
+    size_type __old_sz = __str.size();
+    if (!__str.__is_long())
+      __str.__annotate_delete();
+    __r_.first()       = __str.__r_.first();
+    __str.__r_.first() = __rep();
+    __str.__annotate_new(0);
+
+    _Traits::move(data(), data() + __pos, __len);
+    __set_size(__len);
+    _Traits::assign(data()[__len], value_type());
+
+    if (!__is_long()) {
+      __annotate_new(__len);
+    } else if (__old_sz > __len) {
+      __annotate_shrink(__old_sz);
+    }
+  }
 #endif
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n=npos);
 
-    template <class _Tp,
-              __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
-                                !__is_same_uncvref<_Tp, basic_string>::value,
-                            int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
-    assign(const _Tp& __t, size_type __pos, size_type __n = npos);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const basic_string& __str) {
+    return *this = __str;
+  }
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
+  assign(basic_string&& __str) noexcept(__noexcept_move_assign_container<_Allocator, __alloc_traits>::value) {
+    *this = std::move(__str);
+    return *this;
+  }
+#endif
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n = npos);
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const value_type* __s, size_type __n);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const value_type* __s);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(size_type __n, value_type __c);
-    template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
-    assign(_InputIterator __first, _InputIterator __last);
+  template <class _Tp,
+            __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
+                              !__is_same_uncvref<_Tp, basic_string>::value,
+                          int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
+  assign(const _Tp& __t, size_type __pos, size_type __n = npos);
 
-    template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
-    assign(_ForwardIterator __first, _ForwardIterator __last);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const value_type* __s, size_type __n);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const value_type* __s);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(size_type __n, value_type __c);
+  template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
+  assign(_InputIterator __first, _InputIterator __last);
+
+  template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
+  assign(_ForwardIterator __first, _ForwardIterator __last);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_CharT> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_string& assign_range(_Range&& __range) {
+    if constexpr (__string_is_trivial_iterator<ranges::iterator_t<_Range>>::value &&
+                  (ranges::forward_range<_Range> || ranges::sized_range<_Range>)) {
+      size_type __n = static_cast<size_type>(ranges::distance(__range));
+      __assign_trivial(ranges::begin(__range), ranges::end(__range), __n);
+
+    } else {
+      __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
+    }
+
+    return *this;
+  }
+#endif
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(initializer_list<value_type> __il) {
+    return assign(__il.begin(), __il.size());
+  }
 #endif // _LIBCPP_CXX03_LANG
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
@@ -1356,10 +1531,22 @@ public:
   _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, size_type __n, value_type __c);
   _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __pos, value_type __c);
 
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_CharT> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);
+
+    } else {
+      basic_string __temp(from_range, std::forward<_Range>(__range), __alloc());
+      return insert(__position, __temp.data(), __temp.data() + __temp.size());
+    }
+  }
+#endif
+
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator
   insert(const_iterator __pos, size_type __n, value_type __c) {
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
-                         "string::insert(iterator, n, value) called with an iterator not referring to this string");
     difference_type __p = __pos - begin();
     insert(static_cast<size_type>(__p), __n, __c);
     return begin() + __p;
@@ -1374,16 +1561,15 @@ public:
   insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    iterator insert(const_iterator __pos, initializer_list<value_type> __il)
-                    {return insert(__pos, __il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator
+  insert(const_iterator __pos, initializer_list<value_type> __il) {
+    return insert(__pos, __il.begin(), __il.end());
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& erase(size_type __pos = 0, size_type __n = npos);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    iterator      erase(const_iterator __pos);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    iterator      erase(const_iterator __first, const_iterator __last);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& erase(size_type __pos = 0, size_type __n = npos);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator erase(const_iterator __pos);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator erase(const_iterator __first, const_iterator __last);
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
   replace(size_type __pos1, size_type __n1, const basic_string& __str) {
@@ -1444,670 +1630,698 @@ public:
   _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
   replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
 
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<_CharT> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_string&
+  replace_with_range(const_iterator __i1, const_iterator __i2, _Range&& __range) {
+    basic_string __temp(from_range, std::forward<_Range>(__range), __alloc());
+    return replace(__i1, __i2, __temp);
+  }
+#endif
+
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
-        {return replace(__i1, __i2, __il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
+  replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il) {
+    return replace(__i1, __i2, __il.begin(), __il.end());
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
 
 #if _LIBCPP_STD_VER <= 20
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string substr(size_type __pos = 0, size_type __n = npos) const {
-      return basic_string(*this, __pos, __n);
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string
+  substr(size_type __pos = 0, size_type __n = npos) const {
+    return basic_string(*this, __pos, __n);
+  }
 #else
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    basic_string substr(size_type __pos = 0, size_type __n = npos) const& {
-      return basic_string(*this, __pos, __n);
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_string substr(size_type __pos = 0, size_type __n = npos) const& {
+    return basic_string(*this, __pos, __n);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    basic_string substr(size_type __pos = 0, size_type __n = npos) && {
-      return basic_string(std::move(*this), __pos, __n);
-    }
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_string substr(size_type __pos = 0, size_type __n = npos) && {
+    return basic_string(std::move(*this), __pos, __n);
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void swap(basic_string& __str)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(basic_string& __str)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT;
+      _NOEXCEPT;
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<allocator_type>::value);
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>);
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const value_type* c_str() const _NOEXCEPT {return data();}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const value_type* data() const _NOEXCEPT  {return std::__to_address(__get_pointer());}
-#if _LIBCPP_STD_VER >= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    value_type* data()             _NOEXCEPT  {return std::__to_address(__get_pointer());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const value_type* c_str() const _NOEXCEPT { return data(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const value_type* data() const _NOEXCEPT {
+    return std::__to_address(__get_pointer());
+  }
+#if _LIBCPP_STD_VER >= 17
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 value_type* data() _NOEXCEPT {
+    return std::__to_address(__get_pointer());
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    allocator_type get_allocator() const _NOEXCEPT {return __alloc();}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator_type get_allocator() const _NOEXCEPT {
+    return __alloc();
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
 
-    template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
-    find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
+  template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
 
-    template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
-    rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
+  template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  rfind(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
 
-    template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
-    find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
+  template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_first_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
 
-    template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
-    find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
+  template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_last_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT;
 
-    template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
-    find_first_not_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
+  template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_first_not_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_first_not_of(const value_type* __s, size_type __pos = 0) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT;
 
-    template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
-    find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
+  template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_last_not_of(const value_type* __s, size_type __pos = npos) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    int compare(const basic_string& __str) const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(const basic_string& __str) const _NOEXCEPT;
 
-    template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 int
-    compare(const _Tp& __t) const _NOEXCEPT;
+  template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 int
+  compare(const _Tp& __t) const _NOEXCEPT;
 
-    template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 int
-    compare(size_type __pos1, size_type __n1, const _Tp& __t) const;
+  template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>
+  _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS _LIBCPP_CONSTEXPR_SINCE_CXX20 int
+  compare(size_type __pos1, size_type __n1, const _Tp& __t) const;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    int compare(size_type __pos1, size_type __n1, const basic_string& __str) const;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2,
-                size_type __n2 = npos) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int
+  compare(size_type __pos1, size_type __n1, const basic_string& __str) const;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 int
+  compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2 = npos) const;
 
-    template <class _Tp,
-              __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
-                                !__is_same_uncvref<_Tp, basic_string>::value,
-                            int> = 0>
-    inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int
-    compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2 = npos) const;
+  template <class _Tp,
+            __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&
+                              !__is_same_uncvref<_Tp, basic_string>::value,
+                          int> = 0>
+  inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int
+  compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2 = npos) const;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(const value_type* __s) const _NOEXCEPT;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    int compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(const value_type* __s) const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(size_type __pos1, size_type __n1, const value_type* __s) const;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 int
+  compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;
 
 #if _LIBCPP_STD_VER >= 20
-    constexpr _LIBCPP_HIDE_FROM_ABI
-    bool starts_with(__self_view __sv) const noexcept
-    { return __self_view(data(), size()).starts_with(__sv); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(__self_view __sv) const noexcept {
+    return __self_view(data(), size()).starts_with(__sv);
+  }
 
-    constexpr _LIBCPP_HIDE_FROM_ABI
-    bool starts_with(value_type __c) const noexcept
-    { return !empty() && _Traits::eq(front(), __c); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(value_type __c) const noexcept {
+    return !empty() && _Traits::eq(front(), __c);
+  }
 
-    constexpr _LIBCPP_HIDE_FROM_ABI
-    bool starts_with(const value_type* __s) const noexcept
-    { return starts_with(__self_view(__s)); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(const value_type* __s) const noexcept {
+    return starts_with(__self_view(__s));
+  }
 
-    constexpr _LIBCPP_HIDE_FROM_ABI
-    bool ends_with(__self_view __sv) const noexcept
-    { return __self_view(data(), size()).ends_with( __sv); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(__self_view __sv) const noexcept {
+    return __self_view(data(), size()).ends_with(__sv);
+  }
 
-    constexpr _LIBCPP_HIDE_FROM_ABI
-    bool ends_with(value_type __c) const noexcept
-    { return !empty() && _Traits::eq(back(), __c); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(value_type __c) const noexcept {
+    return !empty() && _Traits::eq(back(), __c);
+  }
 
-    constexpr _LIBCPP_HIDE_FROM_ABI
-    bool ends_with(const value_type* __s) const noexcept
-    { return ends_with(__self_view(__s)); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(const value_type* __s) const noexcept {
+    return ends_with(__self_view(__s));
+  }
 #endif
 
 #if _LIBCPP_STD_VER >= 23
-    constexpr _LIBCPP_HIDE_FROM_ABI
-    bool contains(__self_view __sv) const noexcept
-    { return __self_view(data(), size()).contains(__sv); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(__self_view __sv) const noexcept {
+    return __self_view(data(), size()).contains(__sv);
+  }
 
-    constexpr _LIBCPP_HIDE_FROM_ABI
-    bool contains(value_type __c) const noexcept
-    { return __self_view(data(), size()).contains(__c); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(value_type __c) const noexcept {
+    return __self_view(data(), size()).contains(__c);
+  }
 
-    constexpr _LIBCPP_HIDE_FROM_ABI
-    bool contains(const value_type* __s) const
-    { return __self_view(data(), size()).contains(__s); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(const value_type* __s) const {
+    return __self_view(data(), size()).contains(__s);
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __invariants() const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __invariants() const;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __clear_and_shrink() _NOEXCEPT;
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-    bool __dereferenceable(const const_iterator* __i) const;
-    bool __decrementable(const const_iterator* __i) const;
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __clear_and_shrink() _NOEXCEPT;
 
 private:
-    template<class _Alloc>
-    inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    bool friend operator==(const basic_string<char, char_traits<char>, _Alloc>& __lhs,
-                           const basic_string<char, char_traits<char>, _Alloc>& __rhs) _NOEXCEPT;
+  template <class _Alloc>
+  inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool friend
+  operator==(const basic_string<char, char_traits<char>, _Alloc>& __lhs,
+             const basic_string<char, char_traits<char>, _Alloc>& __rhs) _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __shrink_or_extend(size_type __target_capacity);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __shrink_or_extend(size_type __target_capacity);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    bool __is_long() const _NOEXCEPT {
-        if (__libcpp_is_constant_evaluated())
-            return true;
-        return __r_.first().__s.__is_long_;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS bool
+  __is_long() const _NOEXCEPT {
+    if (__libcpp_is_constant_evaluated() && __builtin_constant_p(__r_.first().__l.__is_long_)) {
+      return __r_.first().__l.__is_long_;
     }
+    return __r_.first().__s.__is_long_;
+  }
 
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __begin_lifetime(pointer __begin, size_type __n) {
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __begin_lifetime(pointer __begin, size_type __n) {
 #if _LIBCPP_STD_VER >= 20
-        if (__libcpp_is_constant_evaluated()) {
-            for (size_type __i = 0; __i != __n; ++__i)
-                std::construct_at(std::addressof(__begin[__i]));
-        }
+    if (__libcpp_is_constant_evaluated()) {
+      for (size_type __i = 0; __i != __n; ++__i)
+        std::construct_at(std::addressof(__begin[__i]));
+    }
 #else
-        (void)__begin;
-        (void)__n;
+    (void)__begin;
+    (void)__n;
 #endif // _LIBCPP_STD_VER >= 20
+  }
+
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI static bool __fits_in_sso(size_type __sz) { return __sz < __min_cap; }
+
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __assign_trivial(_Iterator __first, _Sentinel __last, size_type __n);
+
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
+
+  // Copy [__first, __last) into [__dest, __dest + (__last - __first)). Assumes that the ranges don't overlap.
+  template <class _ForwardIter, class _Sent>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static value_type*
+  __copy_non_overlapping_range(_ForwardIter __first, _Sent __last, value_type* __dest) {
+#ifndef _LIBCPP_CXX03_LANG
+    if constexpr (__libcpp_is_contiguous_iterator<_ForwardIter>::value &&
+                  is_same<value_type, __iter_value_type<_ForwardIter>>::value && is_same<_ForwardIter, _Sent>::value) {
+      traits_type::copy(__dest, std::__to_address(__first), __last - __first);
+      return __dest + (__last - __first);
     }
+#endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __default_init() {
-        __r_.first() = __rep();
-        if (__libcpp_is_constant_evaluated()) {
-            size_type __sz = __recommend(0) + 1;
-            pointer __ptr = __alloc_traits::allocate(__alloc(), __sz);
-            __begin_lifetime(__ptr, __sz);
-            __set_long_pointer(__ptr);
-            __set_long_cap(__sz);
-            __set_long_size(0);
-        }
+    for (; __first != __last; ++__first)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+      traits_type::assign(*__dest++, *__first);
+#pragma GCC diagnostic pop
+    return __dest;
+  }
+
+  template <class _ForwardIterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 iterator
+  __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _Sentinel __last) {
+    size_type __sz  = size();
+    size_type __cap = capacity();
+    value_type* __p;
+    if (__cap - __sz >= __n) {
+      __annotate_increase(__n);
+      __p                = std::__to_address(__get_pointer());
+      size_type __n_move = __sz - __ip;
+      if (__n_move != 0)
+        traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
+    } else {
+      __grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
+      __p = std::__to_address(__get_long_pointer());
     }
+    __sz += __n;
+    __set_size(__sz);
+    traits_type::assign(__p[__sz], value_type());
+    __copy_non_overlapping_range(__first, __last, __p + __ip);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __deallocate_constexpr() {
-        if (__libcpp_is_constant_evaluated() && __get_pointer() != nullptr)
-            __alloc_traits::deallocate(__alloc(), __get_pointer(), __get_long_cap());
+    return begin() + __ip;
+  }
+
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator
+  __insert_with_size(const_iterator __pos, _Iterator __first, _Sentinel __last, size_type __n);
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 allocator_type& __alloc() _NOEXCEPT { return __r_.second(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const allocator_type& __alloc() const _NOEXCEPT { return __r_.second(); }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS void
+  __set_short_size(size_type __s) _NOEXCEPT {
+    _LIBCPP_ASSERT_INTERNAL(__s < __min_cap, "__s should never be greater than or equal to the short string capacity");
+    __r_.first().__s.__size_    = __s;
+    __r_.first().__s.__is_long_ = false;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS size_type
+  __get_short_size() const _NOEXCEPT {
+    _LIBCPP_ASSERT_INTERNAL(!__r_.first().__s.__is_long_, "String has to be short when trying to get the short size");
+    return __r_.first().__s.__size_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __set_long_size(size_type __s) _NOEXCEPT {
+    __r_.first().__l.__size_ = __s;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type __get_long_size() const _NOEXCEPT {
+    return __r_.first().__l.__size_;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __set_size(size_type __s) _NOEXCEPT {
+    if (__is_long())
+      __set_long_size(__s);
+    else
+      __set_short_size(__s);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __set_long_cap(size_type __s) _NOEXCEPT {
+    __r_.first().__l.__cap_     = __s / __endian_factor;
+    __r_.first().__l.__is_long_ = true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type __get_long_cap() const _NOEXCEPT {
+    return __r_.first().__l.__cap_ * __endian_factor;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __set_long_pointer(pointer __p) _NOEXCEPT {
+    __r_.first().__l.__data_ = __p;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pointer __get_long_pointer() _NOEXCEPT {
+    return _LIBCPP_ASAN_VOLATILE_WRAPPER(__r_.first().__l.__data_);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_pointer __get_long_pointer() const _NOEXCEPT {
+    return _LIBCPP_ASAN_VOLATILE_WRAPPER(__r_.first().__l.__data_);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS pointer
+  __get_short_pointer() _NOEXCEPT {
+    return _LIBCPP_ASAN_VOLATILE_WRAPPER(pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]));
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS const_pointer
+  __get_short_pointer() const _NOEXCEPT {
+    return _LIBCPP_ASAN_VOLATILE_WRAPPER(pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]));
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pointer __get_pointer() _NOEXCEPT {
+    return __is_long() ? __get_long_pointer() : __get_short_pointer();
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_pointer __get_pointer() const _NOEXCEPT {
+    return __is_long() ? __get_long_pointer() : __get_short_pointer();
+  }
+
+  // The following functions are no-ops outside of AddressSanitizer mode.
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  __annotate_contiguous_container(const void* __old_mid, const void* __new_mid) const {
+    (void)__old_mid;
+    (void)__new_mid;
+#if !defined(_LIBCPP_HAS_NO_ASAN) && defined(_LIBCPP_INSTRUMENTED_WITH_ASAN)
+  #if defined(__APPLE__)
+    // TODO: remove after addressing issue #96099 (https://github.com/llvm/llvm-project/issues/96099)
+    if(!__is_long())
+      return;
+  #endif
+    std::__annotate_contiguous_container<_Allocator>(data(), data() + capacity() + 1, __old_mid, __new_mid);
+#endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __annotate_new(size_type __current_size) const _NOEXCEPT {
+    (void)__current_size;
+#if !defined(_LIBCPP_HAS_NO_ASAN) && defined(_LIBCPP_INSTRUMENTED_WITH_ASAN)
+    if (!__libcpp_is_constant_evaluated())
+      __annotate_contiguous_container(data() + capacity() + 1, data() + __current_size + 1);
+#endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __annotate_delete() const _NOEXCEPT {
+#if !defined(_LIBCPP_HAS_NO_ASAN) && defined(_LIBCPP_INSTRUMENTED_WITH_ASAN)
+    if (!__libcpp_is_constant_evaluated())
+      __annotate_contiguous_container(data() + size() + 1, data() + capacity() + 1);
+#endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __annotate_increase(size_type __n) const _NOEXCEPT {
+    (void)__n;
+#if !defined(_LIBCPP_HAS_NO_ASAN) && defined(_LIBCPP_INSTRUMENTED_WITH_ASAN)
+    if (!__libcpp_is_constant_evaluated())
+      __annotate_contiguous_container(data() + size() + 1, data() + size() + 1 + __n);
+#endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __annotate_shrink(size_type __old_size) const _NOEXCEPT {
+    (void)__old_size;
+#if !defined(_LIBCPP_HAS_NO_ASAN) && defined(_LIBCPP_INSTRUMENTED_WITH_ASAN)
+    if (!__libcpp_is_constant_evaluated())
+      __annotate_contiguous_container(data() + __old_size + 1, data() + size() + 1);
+#endif
+  }
+
+  template <size_type __a>
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type __align_it(size_type __s) _NOEXCEPT {
+    return (__s + (__a - 1)) & ~(__a - 1);
+  }
+  enum { __alignment = 8 };
+  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type __recommend(size_type __s) _NOEXCEPT {
+    if (__s < __min_cap) {
+      return static_cast<size_type>(__min_cap) - 1;
     }
+    const size_type __boundary = sizeof(value_type) < __alignment ? __alignment / sizeof(value_type) : __endian_factor;
+    size_type __guess          = __align_it<__boundary>(__s + 1) - 1;
+    if (__guess == __min_cap)
+      __guess += __endian_factor;
+    return __guess;
+  }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI static bool __fits_in_sso(size_type __sz) {
-        // SSO is disabled during constant evaluation because `__is_long` isn't constexpr friendly
-        return !__libcpp_is_constant_evaluated() && (__sz < __min_cap);
-    }
+  inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(const value_type* __s, size_type __sz, size_type __reserve);
+  inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(const value_type* __s, size_type __sz);
+  inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(size_type __n, value_type __c);
 
-    template <class _ForwardIterator>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-    iterator __insert_from_safe_copy(size_type __n, size_type __ip, _ForwardIterator __first, _ForwardIterator __last) {
-        size_type __sz = size();
-        size_type __cap = capacity();
-        value_type* __p;
-        if (__cap - __sz >= __n)
-        {
-            __p = std::__to_address(__get_pointer());
-            size_type __n_move = __sz - __ip;
-            if (__n_move != 0)
-                traits_type::move(__p + __ip + __n, __p + __ip, __n_move);
-        }
-        else
-        {
-            __grow_by(__cap, __sz + __n - __cap, __sz, __ip, 0, __n);
-            __p = std::__to_address(__get_long_pointer());
-        }
-        __sz += __n;
-        __set_size(__sz);
-        traits_type::assign(__p[__sz], value_type());
-        for (__p += __ip; __first != __last; ++__p, ++__first)
-            traits_type::assign(*__p, *__first);
+  // Slow path for the (inlined) copy constructor for 'long' strings.
+  // Always externally instantiated and not inlined.
+  // Requires that __s is zero terminated.
+  // The main reason for this function to exist is because for unstable, we
+  // want to allow inlining of the copy constructor. However, we don't want
+  // to call the __init() functions as those are marked as inline which may
+  // result in over-aggressive inlining by the compiler, where our aim is
+  // to only inline the fast path code directly in the ctor.
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE void __init_copy_ctor_external(const value_type* __s, size_type __sz);
 
-        return begin() + __ip;
-    }
+  template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
+  inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(_InputIterator __first, _InputIterator __last);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 allocator_type& __alloc() _NOEXCEPT { return __r_.second(); }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR const allocator_type& __alloc() const _NOEXCEPT { return __r_.second(); }
+  template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+  inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(_ForwardIterator __first, _ForwardIterator __last);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __set_short_size(size_type __s) _NOEXCEPT {
-        _LIBCPP_ASSERT(__s < __min_cap, "__s should never be greater than or equal to the short string capacity");
-        __r_.first().__s.__size_ = __s;
-        __r_.first().__s.__is_long_ = false;
-    }
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  __init_with_sentinel(_InputIterator __first, _Sentinel __last);
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  __init_with_size(_InputIterator __first, _Sentinel __last, size_type __sz);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type __get_short_size() const _NOEXCEPT {
-        _LIBCPP_ASSERT(!__r_.first().__s.__is_long_, "String has to be short when trying to get the short size");
-        return __r_.first().__s.__size_;
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20
+#if _LIBCPP_ABI_VERSION >= 2 //  We want to use the function in the dylib in ABIv1
+  _LIBCPP_HIDE_FROM_ABI
+#endif
+  _LIBCPP_DEPRECATED_("use __grow_by_without_replace") void __grow_by(
+      size_type __old_cap,
+      size_type __delta_cap,
+      size_type __old_sz,
+      size_type __n_copy,
+      size_type __n_del,
+      size_type __n_add = 0);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __grow_by_without_replace(
+      size_type __old_cap,
+      size_type __delta_cap,
+      size_type __old_sz,
+      size_type __n_copy,
+      size_type __n_del,
+      size_type __n_add = 0);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 void __grow_by_and_replace(
+      size_type __old_cap,
+      size_type __delta_cap,
+      size_type __old_sz,
+      size_type __n_copy,
+      size_type __n_del,
+      size_type __n_add,
+      const value_type* __p_new_stuff);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __set_long_size(size_type __s) _NOEXCEPT
-        {__r_.first().__l.__size_ = __s;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type __get_long_size() const _NOEXCEPT
-        {return __r_.first().__l.__size_;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __set_size(size_type __s) _NOEXCEPT
-        {if (__is_long()) __set_long_size(__s); else __set_short_size(__s);}
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __set_long_cap(size_type __s) _NOEXCEPT {
-        __r_.first().__l.__cap_ = __s / __endian_factor;
-        __r_.first().__l.__is_long_ = true;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type __get_long_cap() const _NOEXCEPT {
-        return __r_.first().__l.__cap_ * __endian_factor;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __set_long_pointer(pointer __p) _NOEXCEPT
-        {__r_.first().__l.__data_ = __p;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    pointer __get_long_pointer() _NOEXCEPT
-        {return __r_.first().__l.__data_;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_pointer __get_long_pointer() const _NOEXCEPT
-        {return __r_.first().__l.__data_;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    pointer __get_short_pointer() _NOEXCEPT
-        {return pointer_traits<pointer>::pointer_to(__r_.first().__s.__data_[0]);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_pointer __get_short_pointer() const _NOEXCEPT
-        {return pointer_traits<const_pointer>::pointer_to(__r_.first().__s.__data_[0]);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    pointer __get_pointer() _NOEXCEPT
-        {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_pointer __get_pointer() const _NOEXCEPT
-        {return __is_long() ? __get_long_pointer() : __get_short_pointer();}
-
-    template <size_type __a> static
-        _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-        size_type __align_it(size_type __s) _NOEXCEPT
-            {return (__s + (__a-1)) & ~(__a-1);}
-    enum {__alignment = 16};
-    static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type __recommend(size_type __s) _NOEXCEPT
-    {
-        if (__s < __min_cap) {
-            if (__libcpp_is_constant_evaluated())
-                return static_cast<size_type>(__min_cap);
-            else
-                return static_cast<size_type>(__min_cap) - 1;
-        }
-        size_type __guess = __align_it<sizeof(value_type) < __alignment ?
-                     __alignment/sizeof(value_type) : 1 > (__s+1) - 1;
-        if (__guess == __min_cap) ++__guess;
-        return __guess;
-    }
-
-    inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __init(const value_type* __s, size_type __sz, size_type __reserve);
-    inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __init(const value_type* __s, size_type __sz);
-    inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __init(size_type __n, value_type __c);
-
-    // Slow path for the (inlined) copy constructor for 'long' strings.
-    // Always externally instantiated and not inlined.
-    // Requires that __s is zero terminated.
-    // The main reason for this function to exist is because for unstable, we
-    // want to allow inlining of the copy constructor. However, we don't want
-    // to call the __init() functions as those are marked as inline which may
-    // result in over-aggressive inlining by the compiler, where our aim is
-    // to only inline the fast path code directly in the ctor.
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init_copy_ctor_external(const value_type* __s, size_type __sz);
-
-    template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
-    inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(_InputIterator __first, _InputIterator __last);
-
-    template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
-    inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(_ForwardIterator __first, _ForwardIterator __last);
-
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
-                   size_type __n_copy,  size_type __n_del,     size_type __n_add = 0);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __grow_by_and_replace(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
-                               size_type __n_copy,  size_type __n_del,
-                               size_type __n_add, const value_type* __p_new_stuff);
-
-    // __assign_no_alias is invoked for assignment operations where we
-    // have proof that the input does not alias the current instance.
-    // For example, operator=(basic_string) performs a 'self' check.
-    template <bool __is_short>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& __assign_no_alias(const value_type* __s, size_type __n);
+  // __assign_no_alias is invoked for assignment operations where we
+  // have proof that the input does not alias the current instance.
+  // For example, operator=(basic_string) performs a 'self' check.
+  template <bool __is_short>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE basic_string& __assign_no_alias(const value_type* __s, size_type __n);
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __erase_to_end(size_type __pos) {
     __null_terminate_at(std::__to_address(__get_pointer()), __pos);
   }
 
-    // __erase_external_with_move is invoked for erase() invocations where
-    // `n ~= npos`, likely requiring memory moves on the string data.
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 void __erase_external_with_move(size_type __pos, size_type __n);
+  // __erase_external_with_move is invoked for erase() invocations where
+  // `n ~= npos`, likely requiring memory moves on the string data.
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE void __erase_external_with_move(size_type __pos, size_type __n);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __copy_assign_alloc(const basic_string& __str)
-        {__copy_assign_alloc(__str, integral_constant<bool,
-                      __alloc_traits::propagate_on_container_copy_assignment::value>());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __copy_assign_alloc(const basic_string& __str) {
+    __copy_assign_alloc(
+        __str, integral_constant<bool, __alloc_traits::propagate_on_container_copy_assignment::value>());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __copy_assign_alloc(const basic_string& __str, true_type)
-        {
-            if (__alloc() == __str.__alloc())
-                __alloc() = __str.__alloc();
-            else
-            {
-                if (!__str.__is_long())
-                {
-                    __clear_and_shrink();
-                    __alloc() = __str.__alloc();
-                }
-                else
-                {
-                    allocator_type __a = __str.__alloc();
-                    auto __allocation = std::__allocate_at_least(__a, __str.__get_long_cap());
-                    __begin_lifetime(__allocation.ptr, __allocation.count);
-                    __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
-                    __alloc() = std::move(__a);
-                    __set_long_pointer(__allocation.ptr);
-                    __set_long_cap(__allocation.count);
-                    __set_long_size(__str.size());
-                }
-            }
-        }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __copy_assign_alloc(const basic_string& __str, true_type) {
+    if (__alloc() == __str.__alloc())
+      __alloc() = __str.__alloc();
+    else {
+      if (!__str.__is_long()) {
+        __clear_and_shrink();
+        __alloc() = __str.__alloc();
+      } else {
+        __annotate_delete();
+        allocator_type __a = __str.__alloc();
+        auto __allocation  = std::__allocate_at_least(__a, __str.__get_long_cap());
+        __begin_lifetime(__allocation.ptr, __allocation.count);
+        if (__is_long())
+          __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+        __alloc() = std::move(__a);
+        __set_long_pointer(__allocation.ptr);
+        __set_long_cap(__allocation.count);
+        __set_long_size(__str.size());
+        __annotate_new(__get_long_size());
+      }
+    }
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT
-        {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  __copy_assign_alloc(const basic_string&, false_type) _NOEXCEPT {}
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __move_assign(basic_string& __str, false_type)
-        _NOEXCEPT_(__alloc_traits::is_always_equal::value);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __move_assign(basic_string& __str, true_type)
-#if _LIBCPP_STD_VER >= 17
-        _NOEXCEPT;
-#else
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
-#endif
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  __move_assign(basic_string& __str, false_type) noexcept(__alloc_traits::is_always_equal::value);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS void
+  __move_assign(basic_string& __str, true_type)
+#  if _LIBCPP_STD_VER >= 17
+      noexcept;
+#  else
+      noexcept(is_nothrow_move_assignable<allocator_type>::value);
+#  endif
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void
-    __move_assign_alloc(basic_string& __str)
-        _NOEXCEPT_(
-            !__alloc_traits::propagate_on_container_move_assignment::value ||
-            is_nothrow_move_assignable<allocator_type>::value)
-    {__move_assign_alloc(__str, integral_constant<bool,
-                      __alloc_traits::propagate_on_container_move_assignment::value>());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign_alloc(basic_string& __str)
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_move_assignment::value ||
+                 is_nothrow_move_assignable<allocator_type>::value) {
+    __move_assign_alloc(
+        __str, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __move_assign_alloc(basic_string& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-        {
-            __alloc() = std::move(__c.__alloc());
-        }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign_alloc(basic_string& __c, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
+    __alloc() = std::move(__c.__alloc());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __move_assign_alloc(basic_string&, false_type)
-        _NOEXCEPT
-        {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign_alloc(basic_string&, false_type) _NOEXCEPT {}
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& __assign_external(const value_type* __s);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& __assign_external(const value_type* __s, size_type __n);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE basic_string& __assign_external(const value_type* __s);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE basic_string& __assign_external(const value_type* __s, size_type __n);
 
-    // Assigns the value in __s, guaranteed to be __n < __min_cap in length.
-    inline basic_string& __assign_short(const value_type* __s, size_type __n) {
-      pointer __p = __is_long()
-                        ? (__set_long_size(__n), __get_long_pointer())
-                        : (__set_short_size(__n), __get_short_pointer());
-      traits_type::move(std::__to_address(__p), __s, __n);
-      traits_type::assign(__p[__n], value_type());
-      return *this;
-    }
+  // Assigns the value in __s, guaranteed to be __n < __min_cap in length.
+  inline _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& __assign_short(const value_type* __s, size_type __n) {
+    size_type __old_size = size();
+    if (__n > __old_size)
+      __annotate_increase(__n - __old_size);
+    pointer __p =
+        __is_long() ? (__set_long_size(__n), __get_long_pointer()) : (__set_short_size(__n), __get_short_pointer());
+    traits_type::move(std::__to_address(__p), __s, __n);
+    traits_type::assign(__p[__n], value_type());
+    if (__old_size > __n)
+      __annotate_shrink(__old_size);
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string& __null_terminate_at(value_type* __p, size_type __newsz) {
-      __set_size(__newsz);
-      __invalidate_iterators_past(__newsz);
-      traits_type::assign(__p[__newsz], value_type());
-      return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
+  __null_terminate_at(value_type* __p, size_type __newsz) {
+    size_type __old_size = size();
+    if (__newsz > __old_size)
+      __annotate_increase(__newsz - __old_size);
+    __set_size(__newsz);
+    traits_type::assign(__p[__newsz], value_type());
+    if (__old_size > __newsz)
+      __annotate_shrink(__old_size);
+    return *this;
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __invalidate_iterators_past(size_type);
+  template <class _Tp>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __addr_in_range(const _Tp& __v) const {
+    return std::__is_pointer_in_range(data(), data() + size() + 1, std::addressof(__v));
+  }
 
-    template<class _Tp>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    bool __addr_in_range(_Tp&& __t) const {
-        // assume that the ranges overlap, because we can't check during constant evaluation
-        if (__libcpp_is_constant_evaluated())
-          return true;
-        const volatile void *__p = std::addressof(__t);
-        return data() <= __p && __p <= data() + size();
-    }
+  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void __throw_length_error() const {
+    std::__throw_length_error("basic_string");
+  }
 
-    _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
-    void __throw_length_error() const {
-        std::__throw_length_error("basic_string");
-    }
+  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void __throw_out_of_range() const {
+    std::__throw_out_of_range("basic_string");
+  }
 
-    _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
-    void __throw_out_of_range() const {
-        std::__throw_out_of_range("basic_string");
-    }
-
-    friend _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string operator+<>(const basic_string&, const basic_string&);
-    friend _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string operator+<>(const value_type*, const basic_string&);
-    friend _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string operator+<>(value_type, const basic_string&);
-    friend _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string operator+<>(const basic_string&, const value_type*);
-    friend _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string operator+<>(const basic_string&, value_type);
+  friend _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string operator+ <>(const basic_string&, const basic_string&);
+  friend _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string operator+ <>(const value_type*, const basic_string&);
+  friend _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string operator+ <>(value_type, const basic_string&);
+  friend _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string operator+ <>(const basic_string&, const value_type*);
+  friend _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string operator+ <>(const basic_string&, value_type);
+#if _LIBCPP_STD_VER >= 26
+  friend constexpr basic_string operator+ <>(const basic_string&, type_identity_t<__self_view>);
+  friend constexpr basic_string operator+ <>(type_identity_t<__self_view>, const basic_string&);
+#endif
 };
 
 // These declarations must appear before any functions are implicitly used
 // so that they have the correct visibility specifier.
 #define _LIBCPP_DECLARE(...) extern template __VA_ARGS__;
 #ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
-    _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, char)
-#   ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        _LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, wchar_t)
-#   endif
+_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, char)
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, wchar_t)
+#  endif
 #else
-    _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, char)
-#   ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-        _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, wchar_t)
-#   endif
+_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, char)
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, wchar_t)
+#  endif
 #endif
 #undef _LIBCPP_DECLARE
 
-
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _CharT = __iter_value_type<_InputIterator>,
-         class _Allocator = allocator<_CharT>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>
-         >
+template <class _InputIterator,
+          class _CharT     = __iter_value_type<_InputIterator>,
+          class _Allocator = allocator<_CharT>,
+          class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value> >
 basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
-  -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
+    -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
 
-template<class _CharT,
-         class _Traits,
-         class _Allocator = allocator<_CharT>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>
-         >
-explicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
-  -> basic_string<_CharT, _Traits, _Allocator>;
+template <class _CharT,
+          class _Traits,
+          class _Allocator = allocator<_CharT>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value> >
+explicit basic_string(basic_string_view<_CharT, _Traits>,
+                      const _Allocator& = _Allocator()) -> basic_string<_CharT, _Traits, _Allocator>;
 
-template<class _CharT,
-         class _Traits,
-         class _Allocator = allocator<_CharT>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>,
-         class _Sz = typename allocator_traits<_Allocator>::size_type
-         >
+template <class _CharT,
+          class _Traits,
+          class _Allocator = allocator<_CharT>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>,
+          class _Sz        = typename allocator_traits<_Allocator>::size_type >
 basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())
-  -> basic_string<_CharT, _Traits, _Allocator>;
+    -> basic_string<_CharT, _Traits, _Allocator>;
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value> >
+basic_string(from_range_t, _Range&&, _Allocator = _Allocator())
+    -> basic_string<ranges::range_value_t<_Range>, char_traits<ranges::range_value_t<_Range>>, _Allocator>;
 #endif
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::__invalidate_iterators_past(size_type __pos)
-{
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-    if (!__libcpp_is_constant_evaluated()) {
-        __c_node* __c = __get_db()->__find_c_and_lock(this);
-        if (__c)
-        {
-            const_pointer __new_last = __get_pointer() + __pos;
-            for (__i_node** __p = __c->end_; __p != __c->beg_; )
-            {
-                --__p;
-                const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
-                if (__i->base() > __new_last)
-                {
-                    (*__p)->__c_ = nullptr;
-                    if (--__c->end_ != __p)
-                        std::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
-                }
-            }
-            __get_db()->unlock();
-        }
-    }
-#else
-    (void)__pos;
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz, size_type __reserve) {
+  if (__libcpp_is_constant_evaluated())
+    __r_.first() = __rep();
+  if (__reserve > max_size())
+    __throw_length_error();
+  pointer __p;
+  if (__fits_in_sso(__reserve)) {
+    __set_short_size(__sz);
+    __p = __get_short_pointer();
+  } else {
+    auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__reserve) + 1);
+    __p               = __allocation.ptr;
+    __begin_lifetime(__p, __allocation.count);
+    __set_long_pointer(__p);
+    __set_long_cap(__allocation.count);
+    __set_long_size(__sz);
+  }
+  traits_type::copy(std::__to_address(__p), __s, __sz);
+  traits_type::assign(__p[__sz], value_type());
+  __annotate_new(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s,
-                                                       size_type __sz,
-                                                       size_type __reserve)
-{
-    if (__libcpp_is_constant_evaluated())
-        __r_.first() = __rep();
-    if (__reserve > max_size())
-        __throw_length_error();
-    pointer __p;
-    if (__fits_in_sso(__reserve))
-    {
-        __set_short_size(__sz);
-        __p = __get_short_pointer();
-    }
-    else
-    {
-        auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__reserve) + 1);
-        __p = __allocation.ptr;
-        __begin_lifetime(__p, __allocation.count);
-        __set_long_pointer(__p);
-        __set_long_cap(__allocation.count);
-        __set_long_size(__sz);
-    }
-    traits_type::copy(std::__to_address(__p), __s, __sz);
-    traits_type::assign(__p[__sz], value_type());
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz) {
+  if (__libcpp_is_constant_evaluated())
+    __r_.first() = __rep();
+  if (__sz > max_size())
+    __throw_length_error();
+  pointer __p;
+  if (__fits_in_sso(__sz)) {
+    __set_short_size(__sz);
+    __p = __get_short_pointer();
+  } else {
+    auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1);
+    __p               = __allocation.ptr;
+    __begin_lifetime(__p, __allocation.count);
+    __set_long_pointer(__p);
+    __set_long_cap(__allocation.count);
+    __set_long_size(__sz);
+  }
+  traits_type::copy(std::__to_address(__p), __s, __sz);
+  traits_type::assign(__p[__sz], value_type());
+  __annotate_new(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz)
-{
-    if (__libcpp_is_constant_evaluated())
-        __r_.first() = __rep();
-    if (__sz > max_size())
-        __throw_length_error();
-    pointer __p;
-    if (__fits_in_sso(__sz))
-    {
-        __set_short_size(__sz);
-        __p = __get_short_pointer();
-    }
-    else
-    {
-        auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1);
-        __p = __allocation.ptr;
-        __begin_lifetime(__p, __allocation.count);
-        __set_long_pointer(__p);
-        __set_long_cap(__allocation.count);
-        __set_long_size(__sz);
-    }
-    traits_type::copy(std::__to_address(__p), __s, __sz);
-    traits_type::assign(__p[__sz], value_type());
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(
-    const value_type* __s, size_type __sz) {
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE void
+basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(const value_type* __s, size_type __sz) {
   if (__libcpp_is_constant_evaluated())
     __r_.first() = __rep();
 
@@ -2119,193 +2333,223 @@ void basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(
     if (__sz > max_size())
       __throw_length_error();
     auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1);
-    __p = __allocation.ptr;
+    __p               = __allocation.ptr;
     __begin_lifetime(__p, __allocation.count);
     __set_long_pointer(__p);
     __set_long_cap(__allocation.count);
     __set_long_size(__sz);
   }
   traits_type::copy(std::__to_address(__p), __s, __sz + 1);
+  __annotate_new(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
-{
-    if (__libcpp_is_constant_evaluated())
-        __r_.first() = __rep();
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c) {
+  if (__libcpp_is_constant_evaluated())
+    __r_.first() = __rep();
 
-    if (__n > max_size())
-        __throw_length_error();
-    pointer __p;
-    if (__fits_in_sso(__n))
-    {
-        __set_short_size(__n);
-        __p = __get_short_pointer();
-    }
-    else
-    {
-        auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__n) + 1);
-        __p = __allocation.ptr;
-        __begin_lifetime(__p, __allocation.count);
-        __set_long_pointer(__p);
-        __set_long_cap(__allocation.count);
-        __set_long_size(__n);
-    }
-    traits_type::assign(std::__to_address(__p), __n, __c);
-    traits_type::assign(__p[__n], value_type());
+  if (__n > max_size())
+    __throw_length_error();
+  pointer __p;
+  if (__fits_in_sso(__n)) {
+    __set_short_size(__n);
+    __p = __get_short_pointer();
+  } else {
+    auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__n) + 1);
+    __p               = __allocation.ptr;
+    __begin_lifetime(__p, __allocation.count);
+    __set_long_pointer(__p);
+    __set_long_cap(__allocation.count);
+    __set_long_size(__n);
+  }
+  traits_type::assign(std::__to_address(__p), __n, __c);
+  traits_type::assign(__p[__n], value_type());
+  __annotate_new(__n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last)
-{
-    __default_init();
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _InputIterator __last) {
+  __init_with_sentinel(std::move(__first), std::move(__last));
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+basic_string<_CharT, _Traits, _Allocator>::__init_with_sentinel(_InputIterator __first, _Sentinel __last) {
+  __r_.first() = __rep();
+  __annotate_new(0);
+
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
+  try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
     for (; __first != __last; ++__first)
-        push_back(*__first);
+      push_back(*__first);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        if (__is_long())
-            __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
-        throw;
-    }
+  } catch (...) {
+    __annotate_delete();
+    if (__is_long())
+      __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+    throw;
+  }
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 void
-basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
-{
-    if (__libcpp_is_constant_evaluated())
-        __r_.first() = __rep();
-    size_type __sz = static_cast<size_type>(std::distance(__first, __last));
-    if (__sz > max_size())
-        __throw_length_error();
-    pointer __p;
-    if (__fits_in_sso(__sz))
-    {
-        __set_short_size(__sz);
-        __p = __get_short_pointer();
-    }
-    else
-    {
-        auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1);
-        __p = __allocation.ptr;
-        __begin_lifetime(__p, __allocation.count);
-        __set_long_pointer(__p);
-        __set_long_cap(__allocation.count);
-        __set_long_size(__sz);
-    }
-
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    try
-    {
-#endif  // _LIBCPP_HAS_NO_EXCEPTIONS
-    for (; __first != __last; ++__first, (void) ++__p)
-        traits_type::assign(*__p, *__first);
-    traits_type::assign(*__p, value_type());
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-    catch (...)
-    {
-        if (__is_long())
-            __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
-        throw;
-    }
-#endif  // _LIBCPP_HAS_NO_EXCEPTIONS
+basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last) {
+  size_type __sz = static_cast<size_type>(std::distance(__first, __last));
+  __init_with_size(__first, __last, __sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
-    (size_type __old_cap, size_type __delta_cap, size_type __old_sz,
-     size_type __n_copy,  size_type __n_del,     size_type __n_add, const value_type* __p_new_stuff)
-{
-    size_type __ms = max_size();
-    if (__delta_cap > __ms - __old_cap - 1)
-        __throw_length_error();
-    pointer __old_p = __get_pointer();
-    size_type __cap = __old_cap < __ms / 2 - __alignment ?
-                          __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) :
-                          __ms - 1;
-    auto __allocation = std::__allocate_at_least(__alloc(), __cap + 1);
-    pointer __p = __allocation.ptr;
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+basic_string<_CharT, _Traits, _Allocator>::__init_with_size(_InputIterator __first, _Sentinel __last, size_type __sz) {
+  if (__libcpp_is_constant_evaluated())
+    __r_.first() = __rep();
+
+  if (__sz > max_size())
+    __throw_length_error();
+
+  pointer __p;
+  if (__fits_in_sso(__sz)) {
+    __set_short_size(__sz);
+    __p = __get_short_pointer();
+
+  } else {
+    auto __allocation = std::__allocate_at_least(__alloc(), __recommend(__sz) + 1);
+    __p               = __allocation.ptr;
     __begin_lifetime(__p, __allocation.count);
-    std::__debug_db_invalidate_all(this);
-    if (__n_copy != 0)
-        traits_type::copy(std::__to_address(__p),
-                          std::__to_address(__old_p), __n_copy);
-    if (__n_add != 0)
-        traits_type::copy(std::__to_address(__p) + __n_copy, __p_new_stuff, __n_add);
-    size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
-    if (__sec_cp_sz != 0)
-        traits_type::copy(std::__to_address(__p) + __n_copy + __n_add,
-                          std::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);
-    if (__old_cap+1 != __min_cap || __libcpp_is_constant_evaluated())
-        __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
     __set_long_pointer(__p);
     __set_long_cap(__allocation.count);
-    __old_sz = __n_copy + __n_add + __sec_cp_sz;
-    __set_long_size(__old_sz);
-    traits_type::assign(__p[__old_sz], value_type());
+    __set_long_size(__sz);
+  }
+
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    auto __end = __copy_non_overlapping_range(__first, __last, std::__to_address(__p));
+    traits_type::assign(*__end, value_type());
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  } catch (...) {
+    if (__is_long())
+      __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+    throw;
+  }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  __annotate_new(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-void
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_type __delta_cap, size_type __old_sz,
-                                                     size_type __n_copy,  size_type __n_del,     size_type __n_add)
-{
-    size_type __ms = max_size();
-    if (__delta_cap > __ms - __old_cap)
-        __throw_length_error();
-    pointer __old_p = __get_pointer();
-    size_type __cap = __old_cap < __ms / 2 - __alignment ?
-                          __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) :
-                          __ms - 1;
-    auto __allocation = std::__allocate_at_least(__alloc(), __cap + 1);
-    pointer __p = __allocation.ptr;
-    __begin_lifetime(__p, __allocation.count);
-    std::__debug_db_invalidate_all(this);
-    if (__n_copy != 0)
-        traits_type::copy(std::__to_address(__p),
-                          std::__to_address(__old_p), __n_copy);
-    size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
-    if (__sec_cp_sz != 0)
-        traits_type::copy(std::__to_address(__p) + __n_copy + __n_add,
-                          std::__to_address(__old_p) + __n_copy + __n_del,
-                          __sec_cp_sz);
-    if (__libcpp_is_constant_evaluated() || __old_cap + 1 != __min_cap)
-        __alloc_traits::deallocate(__alloc(), __old_p, __old_cap + 1);
-    __set_long_pointer(__p);
-    __set_long_cap(__allocation.count);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace(
+    size_type __old_cap,
+    size_type __delta_cap,
+    size_type __old_sz,
+    size_type __n_copy,
+    size_type __n_del,
+    size_type __n_add,
+    const value_type* __p_new_stuff) {
+  size_type __ms = max_size();
+  if (__delta_cap > __ms - __old_cap - 1)
+    __throw_length_error();
+  pointer __old_p = __get_pointer();
+  size_type __cap =
+      __old_cap < __ms / 2 - __alignment ? __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms - 1;
+  __annotate_delete();
+  auto __allocation = std::__allocate_at_least(__alloc(), __cap + 1);
+  pointer __p       = __allocation.ptr;
+  __begin_lifetime(__p, __allocation.count);
+  if (__n_copy != 0)
+    traits_type::copy(std::__to_address(__p), std::__to_address(__old_p), __n_copy);
+  if (__n_add != 0)
+    traits_type::copy(std::__to_address(__p) + __n_copy, __p_new_stuff, __n_add);
+  size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
+  if (__sec_cp_sz != 0)
+    traits_type::copy(
+        std::__to_address(__p) + __n_copy + __n_add, std::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);
+  if (__old_cap + 1 != __min_cap)
+    __alloc_traits::deallocate(__alloc(), __old_p, __old_cap + 1);
+  __set_long_pointer(__p);
+  __set_long_cap(__allocation.count);
+  __old_sz = __n_copy + __n_add + __sec_cp_sz;
+  __set_long_size(__old_sz);
+  traits_type::assign(__p[__old_sz], value_type());
+  __annotate_new(__old_sz);
+}
+
+// __grow_by is deprecated because it does not set the size. It may not update the size when the size is changed, and it
+// may also not set the size at all when the string was short initially. This leads to unpredictable size value. It is
+// not removed or changed to avoid breaking the ABI.
+template <class _CharT, class _Traits, class _Allocator>
+void _LIBCPP_CONSTEXPR_SINCE_CXX20
+#if _LIBCPP_ABI_VERSION >= 2 // We want to use the function in the dylib in ABIv1
+_LIBCPP_HIDE_FROM_ABI
+#endif
+_LIBCPP_DEPRECATED_("use __grow_by_without_replace") basic_string<_CharT, _Traits, _Allocator>::__grow_by(
+    size_type __old_cap,
+    size_type __delta_cap,
+    size_type __old_sz,
+    size_type __n_copy,
+    size_type __n_del,
+    size_type __n_add) {
+  size_type __ms = max_size();
+  if (__delta_cap > __ms - __old_cap)
+    __throw_length_error();
+  pointer __old_p = __get_pointer();
+  size_type __cap =
+      __old_cap < __ms / 2 - __alignment ? __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms - 1;
+  __annotate_delete();
+  auto __allocation = std::__allocate_at_least(__alloc(), __cap + 1);
+  pointer __p       = __allocation.ptr;
+  __begin_lifetime(__p, __allocation.count);
+  if (__n_copy != 0)
+    traits_type::copy(std::__to_address(__p), std::__to_address(__old_p), __n_copy);
+  size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
+  if (__sec_cp_sz != 0)
+    traits_type::copy(
+        std::__to_address(__p) + __n_copy + __n_add, std::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);
+  if (__old_cap + 1 != __min_cap)
+    __alloc_traits::deallocate(__alloc(), __old_p, __old_cap + 1);
+  __set_long_pointer(__p);
+  __set_long_cap(__allocation.count);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+void _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+basic_string<_CharT, _Traits, _Allocator>::__grow_by_without_replace(
+    size_type __old_cap,
+    size_type __delta_cap,
+    size_type __old_sz,
+    size_type __n_copy,
+    size_type __n_del,
+    size_type __n_add) {
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  __grow_by(__old_cap, __delta_cap, __old_sz, __n_copy, __n_del, __n_add);
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+  __set_long_size(__old_sz - __n_del + __n_add);
+  __annotate_new(__old_sz - __n_del + __n_add);
 }
 
 // assign
 
 template <class _CharT, class _Traits, class _Allocator>
 template <bool __is_short>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(
-    const value_type* __s, size_type __n) {
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(const value_type* __s, size_type __n) {
   size_type __cap = __is_short ? static_cast<size_type>(__min_cap) : __get_long_cap();
   if (__n < __cap) {
+    size_type __old_size = __is_short ? __get_short_size() : __get_long_size();
+    if (__n > __old_size)
+      __annotate_increase(__n - __old_size);
     pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer();
     __is_short ? __set_short_size(__n) : __set_long_size(__n);
     traits_type::copy(std::__to_address(__p), __s, __n);
     traits_type::assign(__p[__n], value_type());
-    __invalidate_iterators_past(__n);
+    if (__old_size > __n)
+      __annotate_shrink(__old_size);
   } else {
     size_type __sz = __is_short ? __get_short_size() : __get_long_size();
     __grow_by_and_replace(__cap - 1, __n - __cap + 1, __sz, 0, __sz, __n, __s);
@@ -2314,12 +2558,13 @@ basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::__assign_external(
-    const value_type* __s, size_type __n) {
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __s, size_type __n) {
   size_type __cap = capacity();
   if (__cap >= __n) {
+    size_type __old_size = size();
+    if (__n > __old_size)
+      __annotate_increase(__n - __old_size);
     value_type* __p = std::__to_address(__get_pointer());
     traits_type::move(__p, __s, __n);
     return __null_terminate_at(__p, __n);
@@ -2331,64 +2576,62 @@ basic_string<_CharT, _Traits, _Allocator>::__assign_external(
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n)
-{
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::assign received nullptr");
-    return (__builtin_constant_p(__n) && __fits_in_sso(__n))
-               ? __assign_short(__s, __n)
-               : __assign_external(__s, __n);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s, size_type __n) {
+  _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string::assign received nullptr");
+  return (__builtin_constant_p(__n) && __fits_in_sso(__n)) ? __assign_short(__s, __n) : __assign_external(__s, __n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c)
-{
-    size_type __cap = capacity();
-    if (__cap < __n)
-    {
-        size_type __sz = size();
-        __grow_by(__cap, __n - __cap, __sz, 0, __sz);
-    }
-    value_type* __p = std::__to_address(__get_pointer());
-    traits_type::assign(__p, __n, __c);
-    return __null_terminate_at(__p, __n);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::assign(size_type __n, value_type __c) {
+  size_type __cap      = capacity();
+  size_type __old_size = size();
+  if (__cap < __n) {
+    size_type __sz = size();
+    __grow_by_without_replace(__cap, __n - __cap, __sz, 0, __sz);
+    __annotate_increase(__n);
+  } else if (__n > __old_size)
+    __annotate_increase(__n - __old_size);
+  value_type* __p = std::__to_address(__get_pointer());
+  traits_type::assign(__p, __n, __c);
+  return __null_terminate_at(__p, __n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
-{
-    pointer __p;
-    if (__is_long())
-    {
-        __p = __get_long_pointer();
-        __set_long_size(1);
-    }
-    else
-    {
-        __p = __get_short_pointer();
-        __set_short_size(1);
-    }
-    traits_type::assign(*__p, __c);
-    traits_type::assign(*++__p, value_type());
-    __invalidate_iterators_past(1);
-    return *this;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c) {
+  pointer __p;
+  size_type __old_size = size();
+  if (__old_size == 0)
+    __annotate_increase(1);
+  if (__is_long()) {
+    __p = __get_long_pointer();
+    __set_long_size(1);
+  } else {
+    __p = __get_short_pointer();
+    __set_short_size(1);
+  }
+  traits_type::assign(*__p, __c);
+  traits_type::assign(*++__p, value_type());
+  if (__old_size > 1)
+    __annotate_shrink(__old_size);
+  return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
-{
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str) {
   if (this != std::addressof(__str)) {
     __copy_assign_alloc(__str);
     if (!__is_long()) {
       if (!__str.__is_long()) {
+        size_type __old_size = __get_short_size();
+        if (__get_short_size() < __str.__get_short_size())
+          __annotate_increase(__str.__get_short_size() - __get_short_size());
         __r_.first() = __str.__r_.first();
+        if (__old_size > __get_short_size())
+          __annotate_shrink(__old_size);
       } else {
         return __assign_no_alias<true>(__str.data(), __str.size());
       }
@@ -2402,100 +2645,130 @@ basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
-    _NOEXCEPT_(__alloc_traits::is_always_equal::value)
-{
-    if (__alloc() != __str.__alloc())
-        assign(__str);
-    else
-        __move_assign(__str, true_type());
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__move_assign(
+    basic_string& __str, false_type) noexcept(__alloc_traits::is_always_equal::value) {
+  if (__alloc() != __str.__alloc())
+    assign(__str);
+  else
+    __move_assign(__str, true_type());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS void
 basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
-#if _LIBCPP_STD_VER >= 17
-    _NOEXCEPT
-#else
-    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-#endif
+#  if _LIBCPP_STD_VER >= 17
+    noexcept
+#  else
+    noexcept(is_nothrow_move_assignable<allocator_type>::value)
+#  endif
 {
+  __annotate_delete();
   if (__is_long()) {
-    __alloc_traits::deallocate(__alloc(), __get_long_pointer(),
-                               __get_long_cap());
-#if _LIBCPP_STD_VER <= 14
+    __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+#  if _LIBCPP_STD_VER <= 14
     if (!is_nothrow_move_assignable<allocator_type>::value) {
       __set_short_size(0);
       traits_type::assign(__get_short_pointer()[0], value_type());
+      __annotate_new(0);
     }
-#endif
+#  endif
   }
+  size_type __str_old_size = __str.size();
+  bool __str_was_short     = !__str.__is_long();
+
   __move_assign_alloc(__str);
   __r_.first() = __str.__r_.first();
-  if (__libcpp_is_constant_evaluated()) {
-    __str.__default_init();
-  } else {
-    __str.__set_short_size(0);
-    traits_type::assign(__str.__get_short_pointer()[0], value_type());
-  }
+  __str.__set_short_size(0);
+  traits_type::assign(__str.__get_short_pointer()[0], value_type());
+
+  if (__str_was_short && this != &__str)
+    __str.__annotate_shrink(__str_old_size);
+  else
+    // ASan annotations: was long, so object memory is unpoisoned as new.
+    // Or is same as *this, and __annotate_delete() was called.
+    __str.__annotate_new(0);
+
+  // ASan annotations: Guard against `std::string s; s = std::move(s);`
+  // You can find more here: https://en.cppreference.com/w/cpp/utility/move
+  // Quote: "Unless otherwise specified, all standard library objects that have been moved
+  // from are placed in a "valid but unspecified state", meaning the object's class
+  // invariants hold (so functions without preconditions, such as the assignment operator,
+  // can be safely used on the object after it was moved from):"
+  // Quote: "v = std::move(v); // the value of v is unspecified"
+  if (!__is_long() && &__str != this)
+    // If it is long string, delete was never called on original __str's buffer.
+    __annotate_new(__get_short_size());
 }
 
 #endif
 
 template <class _CharT, class _Traits, class _Allocator>
-template<class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
+template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
-{
-    const basic_string __temp(__first, __last, __alloc());
-    assign(__temp.data(), __temp.size());
-    return *this;
+basic_string<_CharT, _Traits, _Allocator>::assign(_InputIterator __first, _InputIterator __last) {
+  __assign_with_sentinel(__first, __last);
+  return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-template<class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
-_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
-{
-    size_type __cap = capacity();
-    size_type __n = __string_is_trivial_iterator<_ForwardIterator>::value ?
-        static_cast<size_type>(std::distance(__first, __last)) : 0;
-
-    if (__string_is_trivial_iterator<_ForwardIterator>::value &&
-        (__cap >= __n || !__addr_in_range(*__first)))
-    {
-        if (__cap < __n)
-        {
-            size_type __sz = size();
-            __grow_by(__cap, __n - __cap, __sz, 0, __sz);
-        }
-        pointer __p = __get_pointer();
-        for (; __first != __last; ++__p, (void) ++__first)
-            traits_type::assign(*__p, *__first);
-        traits_type::assign(*__p, value_type());
-        __set_size(__n);
-        __invalidate_iterators_past(__n);
-    }
-    else
-    {
-        const basic_string __temp(__first, __last, __alloc());
-        assign(__temp.data(), __temp.size());
-    }
-    return *this;
+template <class _InputIterator, class _Sentinel>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+basic_string<_CharT, _Traits, _Allocator>::__assign_with_sentinel(_InputIterator __first, _Sentinel __last) {
+  const basic_string __temp(__init_with_sentinel_tag(), std::move(__first), std::move(__last), __alloc());
+  assign(__temp.data(), __temp.size());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
-{
-    size_type __sz = __str.size();
-    if (__pos > __sz)
-        __throw_out_of_range();
-    return assign(__str.data() + __pos, std::min(__n, __sz - __pos));
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) {
+  if (__string_is_trivial_iterator<_ForwardIterator>::value) {
+    size_type __n = static_cast<size_type>(std::distance(__first, __last));
+    __assign_trivial(__first, __last, __n);
+  } else {
+    __assign_with_sentinel(__first, __last);
+  }
+
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+basic_string<_CharT, _Traits, _Allocator>::__assign_trivial(_Iterator __first, _Sentinel __last, size_type __n) {
+  _LIBCPP_ASSERT_INTERNAL(
+      __string_is_trivial_iterator<_Iterator>::value, "The iterator type given to `__assign_trivial` must be trivial");
+
+  size_type __old_size = size();
+  size_type __cap      = capacity();
+  if (__cap < __n) {
+    // Unlike `append` functions, if the input range points into the string itself, there is no case that the input
+    // range could get invalidated by reallocation:
+    // 1. If the input range is a subset of the string itself, its size cannot exceed the capacity of the string,
+    //    thus no reallocation would happen.
+    // 2. In the exotic case where the input range is the byte representation of the string itself, the string
+    //    object itself stays valid even if reallocation happens.
+    size_type __sz = size();
+    __grow_by_without_replace(__cap, __n - __cap, __sz, 0, __sz);
+    __annotate_increase(__n);
+  } else if (__n > __old_size)
+    __annotate_increase(__n - __old_size);
+  pointer __p = __get_pointer();
+  for (; __first != __last; ++__p, (void)++__first)
+    traits_type::assign(*__p, *__first);
+  traits_type::assign(*__p, value_type());
+  __set_size(__n);
+  if (__n < __old_size)
+    __annotate_shrink(__old_size);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n) {
+  size_type __sz = __str.size();
+  if (__pos > __sz)
+    __throw_out_of_range();
+  return assign(__str.data() + __pos, std::min(__n, __sz - __pos));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2505,173 +2778,144 @@ template <class _Tp,
                         int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp& __t, size_type __pos, size_type __n) {
-    __self_view __sv = __t;
-    size_type __sz = __sv.size();
-    if (__pos > __sz)
-        __throw_out_of_range();
-    return assign(__sv.data() + __pos, std::min(__n, __sz - __pos));
+  __self_view __sv = __t;
+  size_type __sz   = __sv.size();
+  if (__pos > __sz)
+    __throw_out_of_range();
+  return assign(__sv.data() + __pos, std::min(__n, __sz - __pos));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::__assign_external(const value_type* __s) {
   return __assign_external(__s, traits_type::length(__s));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s)
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::assign received nullptr");
-    return __builtin_constant_p(*__s)
-               ? (__fits_in_sso(traits_type::length(__s))
-                      ? __assign_short(__s, traits_type::length(__s))
-                      : __assign_external(__s, traits_type::length(__s)))
-               : __assign_external(__s);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::assign(const value_type* __s) {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::assign received nullptr");
+  return __builtin_constant_p(*__s)
+           ? (__fits_in_sso(traits_type::length(__s)) ? __assign_short(__s, traits_type::length(__s))
+                                                      : __assign_external(__s, traits_type::length(__s)))
+           : __assign_external(__s);
 }
 // append
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n)
-{
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::append received nullptr");
-    size_type __cap = capacity();
-    size_type __sz = size();
-    if (__cap - __sz >= __n)
-    {
-        if (__n)
-        {
-            value_type* __p = std::__to_address(__get_pointer());
-            traits_type::copy(__p + __sz, __s, __n);
-            __sz += __n;
-            __set_size(__sz);
-            traits_type::assign(__p[__sz], value_type());
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_type __n) {
+  _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string::append received nullptr");
+  size_type __cap = capacity();
+  size_type __sz  = size();
+  if (__cap - __sz >= __n) {
+    if (__n) {
+      __annotate_increase(__n);
+      value_type* __p = std::__to_address(__get_pointer());
+      traits_type::copy(__p + __sz, __s, __n);
+      __sz += __n;
+      __set_size(__sz);
+      traits_type::assign(__p[__sz], value_type());
     }
-    else
-        __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);
-    return *this;
+  } else
+    __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);
+  return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c)
-{
-    if (__n)
-    {
-        size_type __cap = capacity();
-        size_type __sz = size();
-        if (__cap - __sz < __n)
-            __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
-        pointer __p = __get_pointer();
-        traits_type::assign(std::__to_address(__p) + __sz, __n, __c);
-        __sz += __n;
-        __set_size(__sz);
-        traits_type::assign(__p[__sz], value_type());
-    }
-    return *this;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c) {
+  if (__n) {
+    size_type __cap = capacity();
+    size_type __sz  = size();
+    if (__cap - __sz < __n)
+      __grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);
+    __annotate_increase(__n);
+    pointer __p = __get_pointer();
+    traits_type::assign(std::__to_address(__p) + __sz, __n, __c);
+    __sz += __n;
+    __set_size(__sz);
+    traits_type::assign(__p[__sz], value_type());
+  }
+  return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 inline void
-basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n)
-{
-    if (__n)
-    {
-        size_type __cap = capacity();
-        size_type __sz = size();
-        if (__cap - __sz < __n)
-            __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
-        pointer __p = __get_pointer();
-        __sz += __n;
-        __set_size(__sz);
-        traits_type::assign(__p[__sz], value_type());
-    }
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c)
-{
-    bool __is_short = !__is_long();
-    size_type __cap;
-    size_type __sz;
-    if (__is_short)
-    {
-        __cap = __min_cap - 1;
-        __sz = __get_short_size();
-    }
-    else
-    {
-        __cap = __get_long_cap() - 1;
-        __sz = __get_long_size();
-    }
-    if (__sz == __cap)
-    {
-        __grow_by(__cap, 1, __sz, __sz, 0);
-        __is_short = false; // the string is always long after __grow_by
-    }
-    pointer __p = __get_pointer();
-    if (__is_short)
-    {
-        __p = __get_short_pointer() + __sz;
-        __set_short_size(__sz+1);
-    }
-    else
-    {
-        __p = __get_long_pointer() + __sz;
-        __set_long_size(__sz+1);
-    }
-    traits_type::assign(*__p, __c);
-    traits_type::assign(*++__p, value_type());
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-template<class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
-_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::append(
-    _ForwardIterator __first, _ForwardIterator __last)
-{
-    size_type __sz = size();
+basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n) {
+  if (__n) {
     size_type __cap = capacity();
-    size_type __n = static_cast<size_type>(std::distance(__first, __last));
-    if (__n)
-    {
-        if (__string_is_trivial_iterator<_ForwardIterator>::value &&
-            !__addr_in_range(*__first))
-        {
-            if (__cap - __sz < __n)
-                __grow_by(__cap, __sz + __n - __cap, __sz, __sz, 0);
-            pointer __p = __get_pointer() + __sz;
-            for (; __first != __last; ++__p, (void) ++__first)
-                traits_type::assign(*__p, *__first);
-            traits_type::assign(*__p, value_type());
-            __set_size(__sz + __n);
-        }
-        else
-        {
-            const basic_string __temp(__first, __last, __alloc());
-            append(__temp.data(), __temp.size());
-        }
-    }
-    return *this;
+    size_type __sz  = size();
+    if (__cap - __sz < __n)
+      __grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);
+    __annotate_increase(__n);
+    pointer __p = __get_pointer();
+    __sz += __n;
+    __set_size(__sz);
+    traits_type::assign(__p[__sz], value_type());
+  }
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n)
-{
-    size_type __sz = __str.size();
-    if (__pos > __sz)
-        __throw_out_of_range();
-    return append(__str.data() + __pos, std::min(__n, __sz - __pos));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::push_back(value_type __c) {
+  bool __is_short = !__is_long();
+  size_type __cap;
+  size_type __sz;
+  if (__is_short) {
+    __cap = __min_cap - 1;
+    __sz  = __get_short_size();
+  } else {
+    __cap = __get_long_cap() - 1;
+    __sz  = __get_long_size();
+  }
+  if (__sz == __cap) {
+    __grow_by_without_replace(__cap, 1, __sz, __sz, 0);
+    __annotate_increase(1);
+    __is_short = false; // the string is always long after __grow_by
+  } else
+    __annotate_increase(1);
+  pointer __p = __get_pointer();
+  if (__is_short) {
+    __p = __get_short_pointer() + __sz;
+    __set_short_size(__sz + 1);
+  } else {
+    __p = __get_long_pointer() + __sz;
+    __set_long_size(__sz + 1);
+  }
+  traits_type::assign(*__p, __c);
+  traits_type::assign(*++__p, value_type());
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::append(_ForwardIterator __first, _ForwardIterator __last) {
+  size_type __sz  = size();
+  size_type __cap = capacity();
+  size_type __n   = static_cast<size_type>(std::distance(__first, __last));
+  if (__n) {
+    if (__string_is_trivial_iterator<_ForwardIterator>::value && !__addr_in_range(*__first)) {
+      if (__cap - __sz < __n)
+        __grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);
+      __annotate_increase(__n);
+      auto __end = __copy_non_overlapping_range(__first, __last, std::__to_address(__get_pointer() + __sz));
+      traits_type::assign(*__end, value_type());
+      __set_size(__sz + __n);
+    } else {
+      const basic_string __temp(__first, __last, __alloc());
+      append(__temp.data(), __temp.size());
+    }
+  }
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n) {
+  size_type __sz = __str.size();
+  if (__pos > __sz)
+    __throw_out_of_range();
+  return append(__str.data() + __pos, std::min(__n, __sz - __pos));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2681,142 +2925,119 @@ template <class _Tp,
                         int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::append(const _Tp& __t, size_type __pos, size_type __n) {
-    __self_view __sv = __t;
-    size_type __sz = __sv.size();
-    if (__pos > __sz)
-        __throw_out_of_range();
-    return append(__sv.data() + __pos, std::min(__n, __sz - __pos));
+  __self_view __sv = __t;
+  size_type __sz   = __sv.size();
+  if (__pos > __sz)
+    __throw_out_of_range();
+  return append(__sv.data() + __pos, std::min(__n, __sz - __pos));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s)
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::append received nullptr");
-    return append(__s, traits_type::length(__s));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s) {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::append received nullptr");
+  return append(__s, traits_type::length(__s));
 }
 
 // insert
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n)
-{
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::insert received nullptr");
-    size_type __sz = size();
-    if (__pos > __sz)
-        __throw_out_of_range();
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s, size_type __n) {
+  _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string::insert received nullptr");
+  size_type __sz = size();
+  if (__pos > __sz)
+    __throw_out_of_range();
+  size_type __cap = capacity();
+  if (__cap - __sz >= __n) {
+    if (__n) {
+      __annotate_increase(__n);
+      value_type* __p    = std::__to_address(__get_pointer());
+      size_type __n_move = __sz - __pos;
+      if (__n_move != 0) {
+        if (std::__is_pointer_in_range(__p + __pos, __p + __sz, __s))
+          __s += __n;
+        traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
+      }
+      traits_type::move(__p + __pos, __s, __n);
+      __sz += __n;
+      __set_size(__sz);
+      traits_type::assign(__p[__sz], value_type());
+    }
+  } else
+    __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
+  return *this;
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c) {
+  size_type __sz = size();
+  if (__pos > __sz)
+    __throw_out_of_range();
+  if (__n) {
     size_type __cap = capacity();
-    if (__libcpp_is_constant_evaluated()) {
-        if (__cap - __sz >= __n)
-            __grow_by_and_replace(__cap, 0, __sz, __pos, 0, __n, __s);
-        else
-            __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
-        return *this;
+    value_type* __p;
+    if (__cap - __sz >= __n) {
+      __annotate_increase(__n);
+      __p                = std::__to_address(__get_pointer());
+      size_type __n_move = __sz - __pos;
+      if (__n_move != 0)
+        traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
+    } else {
+      __grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);
+      __p = std::__to_address(__get_long_pointer());
     }
-    if (__cap - __sz >= __n)
-    {
-        if (__n)
-        {
-            value_type* __p = std::__to_address(__get_pointer());
-            size_type __n_move = __sz - __pos;
-            if (__n_move != 0)
-            {
-                if (__p + __pos <= __s && __s < __p + __sz)
-                    __s += __n;
-                traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
-            }
-            traits_type::move(__p + __pos, __s, __n);
-            __sz += __n;
-            __set_size(__sz);
-            traits_type::assign(__p[__sz], value_type());
-        }
-    }
-    else
-        __grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
-    return *this;
+    traits_type::assign(__p + __pos, __n, __c);
+    __sz += __n;
+    __set_size(__sz);
+    traits_type::assign(__p[__sz], value_type());
+  }
+  return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c)
-{
-    size_type __sz = size();
-    if (__pos > __sz)
-        __throw_out_of_range();
-    if (__n)
-    {
-        size_type __cap = capacity();
-        value_type* __p;
-        if (__cap - __sz >= __n)
-        {
-            __p = std::__to_address(__get_pointer());
-            size_type __n_move = __sz - __pos;
-            if (__n_move != 0)
-                traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
-        }
-        else
-        {
-            __grow_by(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);
-            __p = std::__to_address(__get_long_pointer());
-        }
-        traits_type::assign(__p + __pos, __n, __c);
-        __sz += __n;
-        __set_size(__sz);
-        traits_type::assign(__p[__sz], value_type());
-    }
-    return *this;
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-template<class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
+template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::iterator
-basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last)
-{
-  _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
-                       "string::insert(iterator, range) called with an iterator not"
-                       " referring to this string");
+basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIterator __first, _InputIterator __last) {
   const basic_string __temp(__first, __last, __alloc());
   return insert(__pos, __temp.data(), __temp.data() + __temp.size());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-template<class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::iterator
-basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
-                         "string::insert(iterator, range) called with an iterator not referring to this string");
-
-    size_type __ip = static_cast<size_type>(__pos - begin());
-    size_type __n = static_cast<size_type>(std::distance(__first, __last));
-    if (__n == 0)
-        return begin() + __ip;
-
-    if (__string_is_trivial_iterator<_ForwardIterator>::value && !__addr_in_range(*__first))
-    {
-        return __insert_from_safe_copy(__n, __ip, __first, __last);
-    }
-    else
-    {
-        const basic_string __temp(__first, __last, __alloc());
-        return __insert_from_safe_copy(__n, __ip, __temp.begin(), __temp.end());
-    }
+basic_string<_CharT, _Traits, _Allocator>::insert(
+    const_iterator __pos, _ForwardIterator __first, _ForwardIterator __last) {
+  auto __n = static_cast<size_type>(std::distance(__first, __last));
+  return __insert_with_size(__pos, __first, __last, __n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_string& __str,
-                                                  size_type __pos2, size_type __n)
-{
-    size_type __str_sz = __str.size();
-    if (__pos2 > __str_sz)
-        __throw_out_of_range();
-    return insert(__pos1, __str.data() + __pos2, std::min(__n, __str_sz - __pos2));
+template <class _Iterator, class _Sentinel>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::iterator
+basic_string<_CharT, _Traits, _Allocator>::__insert_with_size(
+    const_iterator __pos, _Iterator __first, _Sentinel __last, size_type __n) {
+  size_type __ip = static_cast<size_type>(__pos - begin());
+  if (__n == 0)
+    return begin() + __ip;
+
+  if (__string_is_trivial_iterator<_Iterator>::value && !__addr_in_range(*__first)) {
+    return __insert_from_safe_copy(__n, __ip, __first, __last);
+  } else {
+    const basic_string __temp(__init_with_sentinel_tag(), __first, __last, __alloc());
+    return __insert_from_safe_copy(__n, __ip, __temp.begin(), __temp.end());
+  }
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::insert(
+    size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n) {
+  size_type __str_sz = __str.size();
+  if (__pos2 > __str_sz)
+    __throw_out_of_range();
+  return insert(__pos1, __str.data() + __pos2, std::min(__n, __str_sz - __pos2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2826,159 +3047,133 @@ template <class _Tp,
                         int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& __t, size_type __pos2, size_type __n) {
-    __self_view __sv = __t;
-    size_type __str_sz = __sv.size();
-    if (__pos2 > __str_sz)
-        __throw_out_of_range();
-    return insert(__pos1, __sv.data() + __pos2, std::min(__n, __str_sz - __pos2));
+  __self_view __sv   = __t;
+  size_type __str_sz = __sv.size();
+  if (__pos2 > __str_sz)
+    __throw_out_of_range();
+  return insert(__pos1, __sv.data() + __pos2, std::min(__n, __str_sz - __pos2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s)
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::insert received nullptr");
-    return insert(__pos, __s, traits_type::length(__s));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_type* __s) {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::insert received nullptr");
+  return insert(__pos, __s, traits_type::length(__s));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::iterator
-basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
-                         "string::insert(iterator, character) called with an iterator not"
-                         " referring to this string");
-
-    size_type __ip = static_cast<size_type>(__pos - begin());
-    size_type __sz = size();
-    size_type __cap = capacity();
-    value_type* __p;
-    if (__cap == __sz)
-    {
-        __grow_by(__cap, 1, __sz, __ip, 0, 1);
-        __p = std::__to_address(__get_long_pointer());
-    }
-    else
-    {
-        __p = std::__to_address(__get_pointer());
-        size_type __n_move = __sz - __ip;
-        if (__n_move != 0)
-            traits_type::move(__p + __ip + 1, __p + __ip, __n_move);
-    }
-    traits_type::assign(__p[__ip], __c);
-    traits_type::assign(__p[++__sz], value_type());
-    __set_size(__sz);
-    return begin() + static_cast<difference_type>(__ip);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::iterator
+basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, value_type __c) {
+  size_type __ip  = static_cast<size_type>(__pos - begin());
+  size_type __sz  = size();
+  size_type __cap = capacity();
+  value_type* __p;
+  if (__cap == __sz) {
+    __grow_by_without_replace(__cap, 1, __sz, __ip, 0, 1);
+    __p = std::__to_address(__get_long_pointer());
+  } else {
+    __annotate_increase(1);
+    __p                = std::__to_address(__get_pointer());
+    size_type __n_move = __sz - __ip;
+    if (__n_move != 0)
+      traits_type::move(__p + __ip + 1, __p + __ip, __n_move);
+  }
+  traits_type::assign(__p[__ip], __c);
+  traits_type::assign(__p[++__sz], value_type());
+  __set_size(__sz);
+  return begin() + static_cast<difference_type>(__ip);
 }
 
 // replace
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
-    _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
-{
-    _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
-    size_type __sz = size();
-    if (__pos > __sz)
-        __throw_out_of_range();
-    __n1 = std::min(__n1, __sz - __pos);
-    size_type __cap = capacity();
-    if (__cap - __sz + __n1 >= __n2)
-    {
-        if (__libcpp_is_constant_evaluated()) {
-            __grow_by_and_replace(__cap, 0, __sz, __pos, __n1, __n2, __s);
-            return *this;
-        }
-        value_type* __p = std::__to_address(__get_pointer());
-        if (__n1 != __n2)
-        {
-            size_type __n_move = __sz - __pos - __n1;
-            if (__n_move != 0)
-            {
-                if (__n1 > __n2)
-                {
-                    traits_type::move(__p + __pos, __s, __n2);
-                    traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
-                    return __null_terminate_at(__p, __sz + (__n2 - __n1));
-                }
-                if (__p + __pos < __s && __s < __p + __sz)
-                {
-                    if (__p + __pos + __n1 <= __s)
-                        __s += __n2 - __n1;
-                    else // __p + __pos < __s < __p + __pos + __n1
-                    {
-                        traits_type::move(__p + __pos, __s, __n1);
-                        __pos += __n1;
-                        __s += __n2;
-                        __n2 -= __n1;
-                        __n1 = 0;
-                    }
-                }
-                traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
-            }
-        }
-        traits_type::move(__p + __pos, __s, __n2);
-        return __null_terminate_at(__p, __sz + (__n2 - __n1));
-    }
-    else
-        __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
-    return *this;
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c)
-{
-    size_type __sz = size();
-    if (__pos > __sz)
-        __throw_out_of_range();
-    __n1 = std::min(__n1, __sz - __pos);
-    size_type __cap = capacity();
-    value_type* __p;
-    if (__cap - __sz + __n1 >= __n2)
-    {
-        __p = std::__to_address(__get_pointer());
-        if (__n1 != __n2)
-        {
-            size_type __n_move = __sz - __pos - __n1;
-            if (__n_move != 0)
-                traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
-        }
-    }
-    else
-    {
-        __grow_by(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2);
-        __p = std::__to_address(__get_long_pointer());
-    }
-    traits_type::assign(__p + __pos, __n2, __c);
-    return __null_terminate_at(__p, __sz - (__n1 - __n2));
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-template<class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,
-                                                   _InputIterator __j1, _InputIterator __j2)
-{
-    const basic_string __temp(__j1, __j2, __alloc());
-    return replace(__i1, __i2, __temp);
+basic_string<_CharT, _Traits, _Allocator>::replace(
+    size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
+    _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK {
+  _LIBCPP_ASSERT_NON_NULL(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
+  size_type __sz = size();
+  if (__pos > __sz)
+    __throw_out_of_range();
+  __n1            = std::min(__n1, __sz - __pos);
+  size_type __cap = capacity();
+  if (__cap - __sz + __n1 >= __n2) {
+    value_type* __p = std::__to_address(__get_pointer());
+    if (__n1 != __n2) {
+      if (__n2 > __n1)
+        __annotate_increase(__n2 - __n1);
+      size_type __n_move = __sz - __pos - __n1;
+      if (__n_move != 0) {
+        if (__n1 > __n2) {
+          traits_type::move(__p + __pos, __s, __n2);
+          traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
+          return __null_terminate_at(__p, __sz + (__n2 - __n1));
+        }
+        if (std::__is_pointer_in_range(__p + __pos + 1, __p + __sz, __s)) {
+          if (__p + __pos + __n1 <= __s)
+            __s += __n2 - __n1;
+          else // __p + __pos < __s < __p + __pos + __n1
+          {
+            traits_type::move(__p + __pos, __s, __n1);
+            __pos += __n1;
+            __s += __n2;
+            __n2 -= __n1;
+            __n1 = 0;
+          }
+        }
+        traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
+      }
+    }
+    traits_type::move(__p + __pos, __s, __n2);
+    return __null_terminate_at(__p, __sz + (__n2 - __n1));
+  } else
+    __grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
+  return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type __n1, const basic_string& __str,
-                                                   size_type __pos2, size_type __n2)
-{
-    size_type __str_sz = __str.size();
-    if (__pos2 > __str_sz)
-        __throw_out_of_range();
-    return replace(__pos1, __n1, __str.data() + __pos2, std::min(__n2, __str_sz - __pos2));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c) {
+  size_type __sz = size();
+  if (__pos > __sz)
+    __throw_out_of_range();
+  __n1            = std::min(__n1, __sz - __pos);
+  size_type __cap = capacity();
+  value_type* __p;
+  if (__cap - __sz + __n1 >= __n2) {
+    __p = std::__to_address(__get_pointer());
+    if (__n1 != __n2) {
+      if (__n2 > __n1)
+        __annotate_increase(__n2 - __n1);
+      size_type __n_move = __sz - __pos - __n1;
+      if (__n_move != 0)
+        traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
+    }
+  } else {
+    __grow_by_without_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2);
+    __p = std::__to_address(__get_long_pointer());
+  }
+  traits_type::assign(__p + __pos, __n2, __c);
+  return __null_terminate_at(__p, __sz - (__n1 - __n2));
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::replace(
+    const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2) {
+  const basic_string __temp(__j1, __j2, __alloc());
+  return replace(__i1, __i2, __temp);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::replace(
+    size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) {
+  size_type __str_sz = __str.size();
+  if (__pos2 > __str_sz)
+    __throw_out_of_range();
+  return replace(__pos1, __n1, __str.data() + __pos2, std::min(__n2, __str_sz - __pos2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2989,20 +3184,18 @@ template <class _Tp,
 _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::replace(
     size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2) {
-    __self_view __sv = __t;
-    size_type __str_sz = __sv.size();
-    if (__pos2 > __str_sz)
-        __throw_out_of_range();
-    return replace(__pos1, __n1, __sv.data() + __pos2, std::min(__n2, __str_sz - __pos2));
+  __self_view __sv   = __t;
+  size_type __str_sz = __sv.size();
+  if (__pos2 > __str_sz)
+    __throw_out_of_range();
+  return replace(__pos1, __n1, __sv.data() + __pos2, std::min(__n2, __str_sz - __pos2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s)
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::replace received nullptr");
-    return replace(__pos, __n1, __s, traits_type::length(__s));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, const value_type* __s) {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::replace received nullptr");
+  return replace(__pos, __n1, __s, traits_type::length(__s));
 }
 
 // erase
@@ -3010,28 +3203,22 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
 // 'externally instantiated' erase() implementation, called when __n != npos.
 // Does not check __pos against size()
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move(
-    size_type __pos, size_type __n)
-{
-    if (__n)
-    {
-        size_type __sz = size();
-        value_type* __p = std::__to_address(__get_pointer());
-        __n = std::min(__n, __sz - __pos);
-        size_type __n_move = __sz - __pos - __n;
-        if (__n_move != 0)
-            traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
-        __null_terminate_at(__p, __sz - __n);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE void
+basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move(size_type __pos, size_type __n) {
+  if (__n) {
+    size_type __sz     = size();
+    value_type* __p    = std::__to_address(__get_pointer());
+    __n                = std::min(__n, __sz - __pos);
+    size_type __n_move = __sz - __pos - __n;
+    if (__n_move != 0)
+      traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
+    __null_terminate_at(__p, __sz - __n);
+  }
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos,
-                                                 size_type __n) {
+_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
+basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n) {
   if (__pos > size())
     __throw_out_of_range();
   if (__n == npos) {
@@ -3043,656 +3230,494 @@ basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos,
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::iterator
-basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos)
-{
-  _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__pos) == this,
-                       "string::erase(iterator) called with an iterator not"
-                       " referring to this string");
-
-  _LIBCPP_ASSERT(__pos != end(), "string::erase(iterator) called with a non-dereferenceable iterator");
-  iterator __b = begin();
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::iterator
+basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __pos) {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+      __pos != end(), "string::erase(iterator) called with a non-dereferenceable iterator");
+  iterator __b  = begin();
   size_type __r = static_cast<size_type>(__pos - __b);
   erase(__r, 1);
   return __b + static_cast<difference_type>(__r);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::iterator
-basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last)
-{
-  _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(&__first) == this,
-                       "string::erase(iterator,  iterator) called with an iterator not"
-                       " referring to this string");
-
-  _LIBCPP_ASSERT(__first <= __last, "string::erase(first, last) called with invalid range");
-  iterator __b = begin();
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::iterator
+basic_string<_CharT, _Traits, _Allocator>::erase(const_iterator __first, const_iterator __last) {
+  _LIBCPP_ASSERT_VALID_INPUT_RANGE(__first <= __last, "string::erase(first, last) called with invalid range");
+  iterator __b  = begin();
   size_type __r = static_cast<size_type>(__first - __b);
   erase(__r, static_cast<size_type>(__last - __first));
   return __b + static_cast<difference_type>(__r);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::pop_back()
-{
-    _LIBCPP_ASSERT(!empty(), "string::pop_back(): string is already empty");
-    __erase_to_end(size() - 1);
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::pop_back() {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::pop_back(): string is already empty");
+  __erase_to_end(size() - 1);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT
-{
-    std::__debug_db_invalidate_all(this);
-    if (__is_long())
-    {
-        traits_type::assign(*__get_long_pointer(), value_type());
-        __set_long_size(0);
-    }
-    else
-    {
-        traits_type::assign(*__get_short_pointer(), value_type());
-        __set_short_size(0);
-    }
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::clear() _NOEXCEPT {
+  size_type __old_size = size();
+  if (__is_long()) {
+    traits_type::assign(*__get_long_pointer(), value_type());
+    __set_long_size(0);
+  } else {
+    traits_type::assign(*__get_short_pointer(), value_type());
+    __set_short_size(0);
+  }
+  __annotate_shrink(__old_size);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c)
-{
-    size_type __sz = size();
-    if (__n > __sz)
-        append(__n - __sz, __c);
-    else
-        __erase_to_end(__n);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::resize(size_type __n, value_type __c) {
+  size_type __sz = size();
+  if (__n > __sz)
+    append(__n - __sz, __c);
+  else
+    __erase_to_end(__n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 inline void
-basic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n)
-{
-    size_type __sz = size();
-    if (__n > __sz) {
-       __append_default_init(__n - __sz);
-    } else
-        __erase_to_end(__n);
+basic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n) {
+  size_type __sz = size();
+  if (__n > __sz) {
+    __append_default_init(__n - __sz);
+  } else
+    __erase_to_end(__n);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity)
-{
-    if (__requested_capacity > max_size())
-        __throw_length_error();
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity) {
+  if (__requested_capacity > max_size())
+    __throw_length_error();
 
-    // Make sure reserve(n) never shrinks. This is technically only required in C++20
-    // and later (since P0966R1), however we provide consistent behavior in all Standard
-    // modes because this function is instantiated in the shared library.
-    if (__requested_capacity <= capacity())
+  // Make sure reserve(n) never shrinks. This is technically only required in C++20
+  // and later (since P0966R1), however we provide consistent behavior in all Standard
+  // modes because this function is instantiated in the shared library.
+  if (__requested_capacity <= capacity())
+    return;
+
+  size_type __target_capacity = std::max(__requested_capacity, size());
+  __target_capacity           = __recommend(__target_capacity);
+  if (__target_capacity == capacity())
+    return;
+
+  __shrink_or_extend(__target_capacity);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT {
+  size_type __target_capacity = __recommend(size());
+  if (__target_capacity == capacity())
+    return;
+
+  __shrink_or_extend(__target_capacity);
+}
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity) {
+  __annotate_delete();
+  size_type __cap = capacity();
+  size_type __sz  = size();
+
+  pointer __new_data, __p;
+  bool __was_long, __now_long;
+  if (__fits_in_sso(__target_capacity)) {
+    __was_long = true;
+    __now_long = false;
+    __new_data = __get_short_pointer();
+    __p        = __get_long_pointer();
+  } else {
+    if (__target_capacity > __cap) {
+      auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1);
+      __new_data        = __allocation.ptr;
+      __target_capacity = __allocation.count - 1;
+    } else {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+        auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1);
+        __new_data        = __allocation.ptr;
+        __target_capacity = __allocation.count - 1;
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      } catch (...) {
         return;
-
-    size_type __target_capacity = std::max(__requested_capacity, size());
-    __target_capacity = __recommend(__target_capacity);
-    if (__target_capacity == capacity()) return;
-
-    __shrink_or_extend(__target_capacity);
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT
-{
-    size_type __target_capacity = __recommend(size());
-    if (__target_capacity == capacity()) return;
-
-    __shrink_or_extend(__target_capacity);
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::__shrink_or_extend(size_type __target_capacity)
-{
-    size_type __cap = capacity();
-    size_type __sz = size();
-
-    pointer __new_data, __p;
-    bool __was_long, __now_long;
-    if (__fits_in_sso(__target_capacity))
-    {
-        __was_long = true;
-        __now_long = false;
-        __new_data = __get_short_pointer();
-        __p = __get_long_pointer();
+      }
+#else  // _LIBCPP_HAS_NO_EXCEPTIONS
+      if (__new_data == nullptr)
+        return;
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
     }
-    else
-    {
-        if (__target_capacity > __cap) {
-            auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1);
-            __new_data = __allocation.ptr;
-            __target_capacity = __allocation.count - 1;
-        }
-        else
-        {
-        #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            try
-            {
-        #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-                auto __allocation = std::__allocate_at_least(__alloc(), __target_capacity + 1);
-                __new_data = __allocation.ptr;
-                __target_capacity = __allocation.count - 1;
-        #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-            }
-            catch (...)
-            {
-                return;
-            }
-        #else  // _LIBCPP_HAS_NO_EXCEPTIONS
-            if (__new_data == nullptr)
-                return;
-        #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        __begin_lifetime(__new_data, __target_capacity + 1);
-        __now_long = true;
-        __was_long = __is_long();
-        __p = __get_pointer();
-    }
-    traits_type::copy(std::__to_address(__new_data),
-                      std::__to_address(__p), size()+1);
-    if (__was_long)
-        __alloc_traits::deallocate(__alloc(), __p, __cap+1);
-    if (__now_long)
-    {
-        __set_long_cap(__target_capacity+1);
-        __set_long_size(__sz);
-        __set_long_pointer(__new_data);
-    }
-    else
-        __set_short_size(__sz);
-    std::__debug_db_invalidate_all(this);
+    __begin_lifetime(__new_data, __target_capacity + 1);
+    __now_long = true;
+    __was_long = __is_long();
+    __p        = __get_pointer();
+  }
+  traits_type::copy(std::__to_address(__new_data), std::__to_address(__p), size() + 1);
+  if (__was_long)
+    __alloc_traits::deallocate(__alloc(), __p, __cap + 1);
+  if (__now_long) {
+    __set_long_cap(__target_capacity + 1);
+    __set_long_size(__sz);
+    __set_long_pointer(__new_data);
+  } else
+    __set_short_size(__sz);
+  __annotate_new(__sz);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::const_reference
-basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const
-{
-    if (__n >= size())
-        __throw_out_of_range();
-    return (*this)[__n];
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
+basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const {
+  if (__n >= size())
+    __throw_out_of_range();
+  return (*this)[__n];
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::reference
-basic_string<_CharT, _Traits, _Allocator>::at(size_type __n)
-{
-    if (__n >= size())
-        __throw_out_of_range();
-    return (*this)[__n];
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::reference
+basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) {
+  if (__n >= size())
+    __throw_out_of_range();
+  return (*this)[__n];
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const
-{
-    size_type __sz = size();
-    if (__pos > __sz)
-        __throw_out_of_range();
-    size_type __rlen = std::min(__n, __sz - __pos);
-    traits_type::copy(__s, data() + __pos, __rlen);
-    return __rlen;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const {
+  size_type __sz = size();
+  if (__pos > __sz)
+    __throw_out_of_range();
+  size_type __rlen = std::min(__n, __sz - __pos);
+  traits_type::copy(__s, data() + __pos, __rlen);
+  return __rlen;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT
+    _NOEXCEPT
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<allocator_type>::value)
+    _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>)
 #endif
 {
-    if (!__is_long())
-        std::__debug_db_invalidate_all(this);
-    if (!__str.__is_long())
-        std::__debug_db_invalidate_all(&__str);
-    std::__debug_db_swap(this, &__str);
-
-    _LIBCPP_ASSERT(
-        __alloc_traits::propagate_on_container_swap::value ||
-        __alloc_traits::is_always_equal::value ||
-        __alloc() == __str.__alloc(), "swapping non-equal allocators");
-    std::swap(__r_.first(), __str.__r_.first());
-    std::__swap_allocator(__alloc(), __str.__alloc());
+  _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+      __alloc_traits::propagate_on_container_swap::value || __alloc_traits::is_always_equal::value ||
+          __alloc() == __str.__alloc(),
+      "swapping non-equal allocators");
+  if (!__is_long())
+    __annotate_delete();
+  if (this != &__str && !__str.__is_long())
+    __str.__annotate_delete();
+  std::swap(__r_.first(), __str.__r_.first());
+  std::__swap_allocator(__alloc(), __str.__alloc());
+  if (!__is_long())
+    __annotate_new(__get_short_size());
+  if (this != &__str && !__str.__is_long())
+    __str.__annotate_new(__str.__get_short_size());
 }
 
 // find
 
 template <class _Traits>
-struct _LIBCPP_HIDDEN __traits_eq
-{
-    typedef typename _Traits::char_type char_type;
-    _LIBCPP_HIDE_FROM_ABI
-    bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT
-        {return _Traits::eq(__x, __y);}
+struct _LIBCPP_HIDDEN __traits_eq {
+  typedef typename _Traits::char_type char_type;
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const char_type& __x, const char_type& __y) _NOEXCEPT {
+    return _Traits::eq(__x, __y);
+  }
 };
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
-                                                size_type __pos,
-                                                size_type __n) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find(): received nullptr");
-    return std::__str_find<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string::find(): received nullptr");
+  return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str,
-                                                size_type __pos) const _NOEXCEPT
-{
-    return std::__str_find<value_type, size_type, traits_type, npos>
-        (data(), size(), __str.data(), __pos, __str.size());
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find(const basic_string& __str, size_type __pos) const _NOEXCEPT {
+  return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __str.data(), __pos, __str.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find(const _Tp &__t,
-                                                size_type __pos) const _NOEXCEPT
-{
-    __self_view __sv = __t;
-    return std::__str_find<value_type, size_type, traits_type, npos>
-        (data(), size(), __sv.data(), __pos, __sv.size());
+basic_string<_CharT, _Traits, _Allocator>::find(const _Tp& __t, size_type __pos) const _NOEXCEPT {
+  __self_view __sv = __t;
+  return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __sv.data(), __pos, __sv.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s,
-                                                size_type __pos) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::find(): received nullptr");
-    return std::__str_find<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find(const value_type* __s, size_type __pos) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find(): received nullptr");
+  return std::__str_find<value_type, size_type, traits_type, npos>(
+      data(), size(), __s, __pos, traits_type::length(__s));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find(value_type __c,
-                                                size_type __pos) const _NOEXCEPT
-{
-    return std::__str_find<value_type, size_type, traits_type, npos>
-        (data(), size(), __c, __pos);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find(value_type __c, size_type __pos) const _NOEXCEPT {
+  return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
 }
 
 // rfind
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
-                                                 size_type __pos,
-                                                 size_type __n) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::rfind(): received nullptr");
-    return std::__str_rfind<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::rfind(
+    const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string::rfind(): received nullptr");
+  return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str,
-                                                 size_type __pos) const _NOEXCEPT
-{
-    return std::__str_rfind<value_type, size_type, traits_type, npos>
-        (data(), size(), __str.data(), __pos, __str.size());
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::rfind(const basic_string& __str, size_type __pos) const _NOEXCEPT {
+  return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __str.data(), __pos, __str.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t,
-                                                size_type __pos) const _NOEXCEPT
-{
-    __self_view __sv = __t;
-    return std::__str_rfind<value_type, size_type, traits_type, npos>
-        (data(), size(), __sv.data(), __pos, __sv.size());
+basic_string<_CharT, _Traits, _Allocator>::rfind(const _Tp& __t, size_type __pos) const _NOEXCEPT {
+  __self_view __sv = __t;
+  return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __sv.data(), __pos, __sv.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s,
-                                                 size_type __pos) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::rfind(): received nullptr");
-    return std::__str_rfind<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::rfind(const value_type* __s, size_type __pos) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::rfind(): received nullptr");
+  return std::__str_rfind<value_type, size_type, traits_type, npos>(
+      data(), size(), __s, __pos, traits_type::length(__s));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c,
-                                                 size_type __pos) const _NOEXCEPT
-{
-    return std::__str_rfind<value_type, size_type, traits_type, npos>
-        (data(), size(), __c, __pos);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::rfind(value_type __c, size_type __pos) const _NOEXCEPT {
+  return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
 }
 
 // find_first_of
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
-                                                         size_type __pos,
-                                                         size_type __n) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr");
-    return std::__str_find_first_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_first_of(
+    const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string::find_first_of(): received nullptr");
+  return std::__str_find_first_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str,
-                                                         size_type __pos) const _NOEXCEPT
-{
-    return std::__str_find_first_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __str.data(), __pos, __str.size());
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_first_of(const basic_string& __str, size_type __pos) const _NOEXCEPT {
+  return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __str.data(), __pos, __str.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t,
-                                                size_type __pos) const _NOEXCEPT
-{
-    __self_view __sv = __t;
-    return std::__str_find_first_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __sv.data(), __pos, __sv.size());
+basic_string<_CharT, _Traits, _Allocator>::find_first_of(const _Tp& __t, size_type __pos) const _NOEXCEPT {
+  __self_view __sv = __t;
+  return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __sv.data(), __pos, __sv.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s,
-                                                         size_type __pos) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::find_first_of(): received nullptr");
-    return std::__str_find_first_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_first_of(const value_type* __s, size_type __pos) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_first_of(): received nullptr");
+  return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __s, __pos, traits_type::length(__s));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c,
-                                                         size_type __pos) const _NOEXCEPT
-{
-    return find(__c, __pos);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_first_of(value_type __c, size_type __pos) const _NOEXCEPT {
+  return find(__c, __pos);
 }
 
 // find_last_of
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
-                                                        size_type __pos,
-                                                        size_type __n) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr");
-    return std::__str_find_last_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_last_of(
+    const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string::find_last_of(): received nullptr");
+  return std::__str_find_last_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str,
-                                                        size_type __pos) const _NOEXCEPT
-{
-    return std::__str_find_last_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __str.data(), __pos, __str.size());
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_last_of(const basic_string& __str, size_type __pos) const _NOEXCEPT {
+  return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __str.data(), __pos, __str.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t,
-                                                size_type __pos) const _NOEXCEPT
-{
-    __self_view __sv = __t;
-    return std::__str_find_last_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __sv.data(), __pos, __sv.size());
+basic_string<_CharT, _Traits, _Allocator>::find_last_of(const _Tp& __t, size_type __pos) const _NOEXCEPT {
+  __self_view __sv = __t;
+  return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __sv.data(), __pos, __sv.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s,
-                                                        size_type __pos) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::find_last_of(): received nullptr");
-    return std::__str_find_last_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_last_of(const value_type* __s, size_type __pos) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_last_of(): received nullptr");
+  return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __s, __pos, traits_type::length(__s));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c,
-                                                        size_type __pos) const _NOEXCEPT
-{
-    return rfind(__c, __pos);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_last_of(value_type __c, size_type __pos) const _NOEXCEPT {
+  return rfind(__c, __pos);
 }
 
 // find_first_not_of
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
-                                                             size_type __pos,
-                                                             size_type __n) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr");
-    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(
+    const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string::find_first_not_of(): received nullptr");
+  return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const basic_string& __str,
-                                                             size_type __pos) const _NOEXCEPT
-{
-    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __str.data(), __pos, __str.size());
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(
+    const basic_string& __str, size_type __pos) const _NOEXCEPT {
+  return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __str.data(), __pos, __str.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t,
-                                                size_type __pos) const _NOEXCEPT
-{
-    __self_view __sv = __t;
-    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __sv.data(), __pos, __sv.size());
+basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const _Tp& __t, size_type __pos) const _NOEXCEPT {
+  __self_view __sv = __t;
+  return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __sv.data(), __pos, __sv.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s,
-                                                             size_type __pos) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::find_first_not_of(): received nullptr");
-    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(const value_type* __s, size_type __pos) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_first_not_of(): received nullptr");
+  return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __s, __pos, traits_type::length(__s));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c,
-                                                             size_type __pos) const _NOEXCEPT
-{
-    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __c, __pos);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_first_not_of(value_type __c, size_type __pos) const _NOEXCEPT {
+  return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
 }
 
 // find_last_not_of
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
-                                                            size_type __pos,
-                                                            size_type __n) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr");
-    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, __n);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(
+    const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string::find_last_not_of(): received nullptr");
+  return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const basic_string& __str,
-                                                            size_type __pos) const _NOEXCEPT
-{
-    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __str.data(), __pos, __str.size());
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(
+    const basic_string& __str, size_type __pos) const _NOEXCEPT {
+  return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __str.data(), __pos, __str.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t,
-                                                size_type __pos) const _NOEXCEPT
-{
-    __self_view __sv = __t;
-    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __sv.data(), __pos, __sv.size());
+basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const _Tp& __t, size_type __pos) const _NOEXCEPT {
+  __self_view __sv = __t;
+  return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __sv.data(), __pos, __sv.size());
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s,
-                                                            size_type __pos) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::find_last_not_of(): received nullptr");
-    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __s, __pos, traits_type::length(__s));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(const value_type* __s, size_type __pos) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_last_not_of(): received nullptr");
+  return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
+      data(), size(), __s, __pos, traits_type::length(__s));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename basic_string<_CharT, _Traits, _Allocator>::size_type
-basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c,
-                                                            size_type __pos) const _NOEXCEPT
-{
-    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
-        (data(), size(), __c, __pos);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::size_type
+basic_string<_CharT, _Traits, _Allocator>::find_last_not_of(value_type __c, size_type __pos) const _NOEXCEPT {
+  return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
 }
 
 // compare
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> >
-_LIBCPP_CONSTEXPR_SINCE_CXX20 int
-basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const _NOEXCEPT
-{
-    __self_view __sv = __t;
-    size_t __lhs_sz = size();
-    size_t __rhs_sz = __sv.size();
-    int __result = traits_type::compare(data(), __sv.data(),
-                                        std::min(__lhs_sz, __rhs_sz));
-    if (__result != 0)
-        return __result;
-    if (__lhs_sz < __rhs_sz)
-        return -1;
-    if (__lhs_sz > __rhs_sz)
-        return 1;
-    return 0;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 int basic_string<_CharT, _Traits, _Allocator>::compare(const _Tp& __t) const _NOEXCEPT {
+  __self_view __sv = __t;
+  size_t __lhs_sz  = size();
+  size_t __rhs_sz  = __sv.size();
+  int __result     = traits_type::compare(data(), __sv.data(), std::min(__lhs_sz, __rhs_sz));
+  if (__result != 0)
+    return __result;
+  if (__lhs_sz < __rhs_sz)
+    return -1;
+  if (__lhs_sz > __rhs_sz)
+    return 1;
+  return 0;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-int
-basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT
-{
-    return compare(__self_view(__str));
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 int
+basic_string<_CharT, _Traits, _Allocator>::compare(const basic_string& __str) const _NOEXCEPT {
+  return compare(__self_view(__str));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-int
-basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
-                                                   size_type __n1,
-                                                   const value_type* __s,
-                                                   size_type __n2) const
-{
-    _LIBCPP_ASSERT(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr");
-    size_type __sz = size();
-    if (__pos1 > __sz || __n2 == npos)
-        __throw_out_of_range();
-    size_type __rlen = std::min(__n1, __sz - __pos1);
-    int __r = traits_type::compare(data() + __pos1, __s, std::min(__rlen, __n2));
-    if (__r == 0)
-    {
-        if (__rlen < __n2)
-            __r = -1;
-        else if (__rlen > __n2)
-            __r = 1;
-    }
-    return __r;
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 int basic_string<_CharT, _Traits, _Allocator>::compare(
+    size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const {
+  _LIBCPP_ASSERT_NON_NULL(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr");
+  size_type __sz = size();
+  if (__pos1 > __sz || __n2 == npos)
+    __throw_out_of_range();
+  size_type __rlen = std::min(__n1, __sz - __pos1);
+  int __r          = traits_type::compare(data() + __pos1, __s, std::min(__rlen, __n2));
+  if (__r == 0) {
+    if (__rlen < __n2)
+      __r = -1;
+    else if (__rlen > __n2)
+      __r = 1;
+  }
+  return __r;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 int
-basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
-                                                   size_type __n1,
-                                                   const _Tp& __t) const
-{
-    __self_view __sv = __t;
-    return compare(__pos1, __n1, __sv.data(), __sv.size());
+basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, size_type __n1, const _Tp& __t) const {
+  __self_view __sv = __t;
+  return compare(__pos1, __n1, __sv.data(), __sv.size());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-int
-basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
-                                                   size_type __n1,
-                                                   const basic_string& __str) const
-{
-    return compare(__pos1, __n1, __str.data(), __str.size());
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 int
+basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, size_type __n1, const basic_string& __str) const {
+  return compare(__pos1, __n1, __str.data(), __str.size());
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -3702,523 +3727,468 @@ template <class _Tp,
                         int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 int basic_string<_CharT, _Traits, _Allocator>::compare(
     size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2) const {
-    __self_view __sv = __t;
-    return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
+  __self_view __sv = __t;
+  return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-int
-basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
-                                                   size_type __n1,
-                                                   const basic_string& __str,
-                                                   size_type __pos2,
-                                                   size_type __n2) const
-{
-    return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 int basic_string<_CharT, _Traits, _Allocator>::compare(
+    size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) const {
+  return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-int
-basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
-    return compare(0, npos, __s, traits_type::length(__s));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 int
+basic_string<_CharT, _Traits, _Allocator>::compare(const value_type* __s) const _NOEXCEPT {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::compare(): received nullptr");
+  return compare(0, npos, __s, traits_type::length(__s));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-int
-basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
-                                                   size_type __n1,
-                                                   const value_type* __s) const
-{
-    _LIBCPP_ASSERT(__s != nullptr, "string::compare(): received nullptr");
-    return compare(__pos1, __n1, __s, traits_type::length(__s));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 int
+basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, size_type __n1, const value_type* __s) const {
+  _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::compare(): received nullptr");
+  return compare(__pos1, __n1, __s, traits_type::length(__s));
 }
 
 // __invariants
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-basic_string<_CharT, _Traits, _Allocator>::__invariants() const
-{
-    if (size() > capacity())
-        return false;
-    if (capacity() < __min_cap - 1)
-        return false;
-    if (data() == nullptr)
-        return false;
-    if (!_Traits::eq(data()[size()], value_type()))
-        return false;
-    return true;
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 bool basic_string<_CharT, _Traits, _Allocator>::__invariants() const {
+  if (size() > capacity())
+    return false;
+  if (capacity() < __min_cap - 1)
+    return false;
+  if (data() == nullptr)
+    return false;
+  if (!_Traits::eq(data()[size()], value_type()))
+    return false;
+  return true;
 }
 
 // __clear_and_shrink
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT
-{
-    clear();
-    if(__is_long())
-    {
-        __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
-        __default_init();
-    }
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__clear_and_shrink() _NOEXCEPT {
+  clear();
+  if (__is_long()) {
+    __annotate_delete();
+    __alloc_traits::deallocate(__alloc(), __get_long_pointer(), capacity() + 1);
+    __r_.first() = __rep();
+  }
 }
 
 // operator==
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-bool
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool
 operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
+           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
 #if _LIBCPP_STD_VER >= 20
-    return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs);
+  return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs);
 #else
-    size_t __lhs_sz = __lhs.size();
-    return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(),
-                                                        __rhs.data(),
-                                                        __lhs_sz) == 0;
+  size_t __lhs_sz = __lhs.size();
+  return __lhs_sz == __rhs.size() && _Traits::compare(__lhs.data(), __rhs.data(), __lhs_sz) == 0;
 #endif
 }
 
-template<class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-bool
+template <class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool
 operator==(const basic_string<char, char_traits<char>, _Allocator>& __lhs,
-           const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT
-{
-    size_t __lhs_sz = __lhs.size();
-    if (__lhs_sz != __rhs.size())
-        return false;
-    const char* __lp = __lhs.data();
-    const char* __rp = __rhs.data();
-    if (__lhs.__is_long())
-        return char_traits<char>::compare(__lp, __rp, __lhs_sz) == 0;
-    for (; __lhs_sz != 0; --__lhs_sz, ++__lp, ++__rp)
-        if (*__lp != *__rp)
-            return false;
-    return true;
+           const basic_string<char, char_traits<char>, _Allocator>& __rhs) _NOEXCEPT {
+  size_t __sz = __lhs.size();
+  if (__sz != __rhs.size())
+    return false;
+  return char_traits<char>::compare(__lhs.data(), __rhs.data(), __sz) == 0;
 }
 
 #if _LIBCPP_STD_VER <= 17
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator==(const _CharT* __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    typedef basic_string<_CharT, _Traits, _Allocator> _String;
-    _LIBCPP_ASSERT(__lhs != nullptr, "operator==(char*, basic_string): received nullptr");
-    size_t __lhs_len = _Traits::length(__lhs);
-    if (__lhs_len != __rhs.size()) return false;
-    return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0;
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  typedef basic_string<_CharT, _Traits, _Allocator> _String;
+  _LIBCPP_ASSERT_NON_NULL(__lhs != nullptr, "operator==(char*, basic_string): received nullptr");
+  size_t __lhs_len = _Traits::length(__lhs);
+  if (__lhs_len != __rhs.size())
+    return false;
+  return __rhs.compare(0, _String::npos, __lhs, __lhs_len) == 0;
 }
 #endif // _LIBCPP_STD_VER <= 17
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-bool
-operator==(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
-           const _CharT* __rhs) _NOEXCEPT
-{
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool
+operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) _NOEXCEPT {
 #if _LIBCPP_STD_VER >= 20
-    return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs);
+  return basic_string_view<_CharT, _Traits>(__lhs) == basic_string_view<_CharT, _Traits>(__rhs);
 #else
-    typedef basic_string<_CharT, _Traits, _Allocator> _String;
-    _LIBCPP_ASSERT(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
-    size_t __rhs_len = _Traits::length(__rhs);
-    if (__rhs_len != __lhs.size()) return false;
-    return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0;
+  typedef basic_string<_CharT, _Traits, _Allocator> _String;
+  _LIBCPP_ASSERT_NON_NULL(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
+  size_t __rhs_len = _Traits::length(__rhs);
+  if (__rhs_len != __lhs.size())
+    return false;
+  return __lhs.compare(0, _String::npos, __rhs, __rhs_len) == 0;
 #endif
 }
 
 #if _LIBCPP_STD_VER >= 20
 
 template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(
-    const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-    const basic_string<_CharT, _Traits, _Allocator>& __rhs) noexcept {
-    return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs);
+_LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+                                                 const basic_string<_CharT, _Traits, _Allocator>& __rhs) noexcept {
+  return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs);
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI constexpr auto
 operator<=>(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) {
-    return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs);
+  return basic_string_view<_CharT, _Traits>(__lhs) <=> basic_string_view<_CharT, _Traits>(__rhs);
 }
 
-#else // _LIBCPP_STD_VER >= 20
+#else  // _LIBCPP_STD_VER >= 20
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator!=(const basic_string<_CharT,_Traits,_Allocator>& __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    return !(__lhs == __rhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+                                             const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  return !(__lhs == __rhs);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator!=(const _CharT* __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    return !(__lhs == __rhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  return !(__lhs == __rhs);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const _CharT* __rhs) _NOEXCEPT
-{
-    return !(__lhs == __rhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator!=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) _NOEXCEPT {
+  return !(__lhs == __rhs);
 }
 
 // operator<
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) < 0;
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+                                            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) < 0;
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator< (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const _CharT* __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) < 0;
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) < 0;
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator< (const _CharT* __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    return __rhs.compare(__lhs) > 0;
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  return __rhs.compare(__lhs) > 0;
 }
 
 // operator>
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    return __rhs < __lhs;
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+                                            const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  return __rhs < __lhs;
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator> (const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const _CharT* __rhs) _NOEXCEPT
-{
-    return __rhs < __lhs;
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) _NOEXCEPT {
+  return __rhs < __lhs;
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator> (const _CharT* __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    return __rhs < __lhs;
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  return __rhs < __lhs;
 }
 
 // operator<=
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    return !(__rhs < __lhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+                                             const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  return !(__rhs < __lhs);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const _CharT* __rhs) _NOEXCEPT
-{
-    return !(__rhs < __lhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) _NOEXCEPT {
+  return !(__rhs < __lhs);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator<=(const _CharT* __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    return !(__rhs < __lhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator<=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  return !(__rhs < __lhs);
 }
 
 // operator>=
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    return !(__lhs < __rhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+                                             const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  return !(__lhs < __rhs);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-           const _CharT* __rhs) _NOEXCEPT
-{
-    return !(__lhs < __rhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) _NOEXCEPT {
+  return !(__lhs < __rhs);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator>=(const _CharT* __lhs,
-           const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT
-{
-    return !(__lhs < __rhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool
+operator>=(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) _NOEXCEPT {
+  return !(__lhs < __rhs);
 }
 #endif // _LIBCPP_STD_VER >= 20
 
 // operator +
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
-          const basic_string<_CharT, _Traits, _Allocator>& __rhs)
-{
-    using _String = basic_string<_CharT, _Traits, _Allocator>;
-    auto __lhs_sz = __lhs.size();
-    auto __rhs_sz = __rhs.size();
-    _String __r(__uninitialized_size_tag(),
-                __lhs_sz + __rhs_sz,
-                _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
-    auto __ptr = std::__to_address(__r.__get_pointer());
-    _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
-    _Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz);
-    _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
-    return __r;
+          const basic_string<_CharT, _Traits, _Allocator>& __rhs) {
+  using _String = basic_string<_CharT, _Traits, _Allocator>;
+  auto __lhs_sz = __lhs.size();
+  auto __rhs_sz = __rhs.size();
+  _String __r(__uninitialized_size_tag(),
+              __lhs_sz + __rhs_sz,
+              _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
+  auto __ptr = std::__to_address(__r.__get_pointer());
+  _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
+  _Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz);
+  _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
+  return __r;
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDDEN _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(const _CharT* __lhs , const basic_string<_CharT,_Traits,_Allocator>& __rhs)
-{
-    using _String = basic_string<_CharT, _Traits, _Allocator>;
-    auto __lhs_sz = _Traits::length(__lhs);
-    auto __rhs_sz = __rhs.size();
-    _String __r(__uninitialized_size_tag(),
-                __lhs_sz + __rhs_sz,
-                _String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator()));
-    auto __ptr = std::__to_address(__r.__get_pointer());
-    _Traits::copy(__ptr, __lhs, __lhs_sz);
-    _Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz);
-    _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
-    return __r;
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDDEN _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(const _CharT* __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) {
+  using _String = basic_string<_CharT, _Traits, _Allocator>;
+  auto __lhs_sz = _Traits::length(__lhs);
+  auto __rhs_sz = __rhs.size();
+  _String __r(__uninitialized_size_tag(),
+              __lhs_sz + __rhs_sz,
+              _String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator()));
+  auto __ptr = std::__to_address(__r.__get_pointer());
+  _Traits::copy(__ptr, __lhs, __lhs_sz);
+  _Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz);
+  _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
+  return __r;
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Allocator>& __rhs)
-{
-    using _String = basic_string<_CharT, _Traits, _Allocator>;
-    typename _String::size_type __rhs_sz = __rhs.size();
-    _String __r(__uninitialized_size_tag(),
-                __rhs_sz + 1,
-                _String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator()));
-    auto __ptr = std::__to_address(__r.__get_pointer());
-    _Traits::assign(__ptr, 1, __lhs);
-    _Traits::copy(__ptr + 1, __rhs.data(), __rhs_sz);
-    _Traits::assign(__ptr + 1 + __rhs_sz, 1, _CharT());
-    return __r;
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) {
+  using _String                        = basic_string<_CharT, _Traits, _Allocator>;
+  typename _String::size_type __rhs_sz = __rhs.size();
+  _String __r(__uninitialized_size_tag(),
+              __rhs_sz + 1,
+              _String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator()));
+  auto __ptr = std::__to_address(__r.__get_pointer());
+  _Traits::assign(__ptr, 1, __lhs);
+  _Traits::copy(__ptr + 1, __rhs.data(), __rhs_sz);
+  _Traits::assign(__ptr + 1 + __rhs_sz, 1, _CharT());
+  return __r;
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs)
-{
-    using _String = basic_string<_CharT, _Traits, _Allocator>;
-    typename _String::size_type __lhs_sz = __lhs.size();
-    typename _String::size_type __rhs_sz = _Traits::length(__rhs);
-    _String __r(__uninitialized_size_tag(),
-                __lhs_sz + __rhs_sz,
-                _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
-    auto __ptr = std::__to_address(__r.__get_pointer());
-    _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
-    _Traits::copy(__ptr + __lhs_sz, __rhs, __rhs_sz);
-    _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
-    return __r;
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) {
+  using _String                        = basic_string<_CharT, _Traits, _Allocator>;
+  typename _String::size_type __lhs_sz = __lhs.size();
+  typename _String::size_type __rhs_sz = _Traits::length(__rhs);
+  _String __r(__uninitialized_size_tag(),
+              __lhs_sz + __rhs_sz,
+              _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
+  auto __ptr = std::__to_address(__r.__get_pointer());
+  _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
+  _Traits::copy(__ptr + __lhs_sz, __rhs, __rhs_sz);
+  _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
+  return __r;
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs)
-{
-    using _String = basic_string<_CharT, _Traits, _Allocator>;
-    typename _String::size_type __lhs_sz = __lhs.size();
-    _String __r(__uninitialized_size_tag(),
-                __lhs_sz + 1,
-                _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
-    auto __ptr = std::__to_address(__r.__get_pointer());
-    _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
-    _Traits::assign(__ptr + __lhs_sz, 1, __rhs);
-    _Traits::assign(__ptr + 1 + __lhs_sz, 1, _CharT());
-    return __r;
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, _CharT __rhs) {
+  using _String                        = basic_string<_CharT, _Traits, _Allocator>;
+  typename _String::size_type __lhs_sz = __lhs.size();
+  _String __r(__uninitialized_size_tag(),
+              __lhs_sz + 1,
+              _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
+  auto __ptr = std::__to_address(__r.__get_pointer());
+  _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
+  _Traits::assign(__ptr + __lhs_sz, 1, __rhs);
+  _Traits::assign(__ptr + 1 + __lhs_sz, 1, _CharT());
+  return __r;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs)
-{
-    return std::move(__lhs.append(__rhs));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs) {
+  return std::move(__lhs.append(__rhs));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
-{
-    return std::move(__rhs.insert(0, __lhs));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) {
+  return std::move(__rhs.insert(0, __lhs));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
-{
-    return std::move(__lhs.append(__rhs));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) {
+  return std::move(__lhs.append(__rhs));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
-{
-    return std::move(__rhs.insert(0, __lhs));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(const _CharT* __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) {
+  return std::move(__rhs.insert(0, __lhs));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
-{
-    __rhs.insert(__rhs.begin(), __lhs);
-    return std::move(__rhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(_CharT __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs) {
+  __rhs.insert(__rhs.begin(), __lhs);
+  return std::move(__rhs);
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs)
-{
-    return std::move(__lhs.append(__rhs));
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs) {
+  return std::move(__lhs.append(__rhs));
 }
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-basic_string<_CharT, _Traits, _Allocator>
-operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
-{
-    __lhs.push_back(__rhs);
-    return std::move(__lhs);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>
+operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs) {
+  __lhs.push_back(__rhs);
+  return std::move(__lhs);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
-// swap
+#if _LIBCPP_STD_VER >= 26
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-swap(basic_string<_CharT, _Traits, _Allocator>& __lhs,
-     basic_string<_CharT, _Traits, _Allocator>& __rhs)
-     _NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs)))
-{
-    __lhs.swap(__rhs);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI constexpr basic_string<_CharT, _Traits, _Allocator>
+operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
+          type_identity_t<basic_string_view<_CharT, _Traits>> __rhs) {
+  using _String                        = basic_string<_CharT, _Traits, _Allocator>;
+  typename _String::size_type __lhs_sz = __lhs.size();
+  typename _String::size_type __rhs_sz = __rhs.size();
+  _String __r(__uninitialized_size_tag(),
+              __lhs_sz + __rhs_sz,
+              _String::__alloc_traits::select_on_container_copy_construction(__lhs.get_allocator()));
+  auto __ptr = std::__to_address(__r.__get_pointer());
+  _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
+  _Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz);
+  _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
+  return __r;
 }
 
-_LIBCPP_FUNC_VIS int                stoi  (const string& __str, size_t* __idx = nullptr, int __base = 10);
-_LIBCPP_FUNC_VIS long               stol  (const string& __str, size_t* __idx = nullptr, int __base = 10);
-_LIBCPP_FUNC_VIS unsigned long      stoul (const string& __str, size_t* __idx = nullptr, int __base = 10);
-_LIBCPP_FUNC_VIS long long          stoll (const string& __str, size_t* __idx = nullptr, int __base = 10);
-_LIBCPP_FUNC_VIS unsigned long long stoull(const string& __str, size_t* __idx = nullptr, int __base = 10);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI constexpr basic_string<_CharT, _Traits, _Allocator>
+operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs,
+          type_identity_t<basic_string_view<_CharT, _Traits>> __rhs) {
+  __lhs.append(__rhs);
+  return std::move(__lhs);
+}
 
-_LIBCPP_FUNC_VIS float       stof (const string& __str, size_t* __idx = nullptr);
-_LIBCPP_FUNC_VIS double      stod (const string& __str, size_t* __idx = nullptr);
-_LIBCPP_FUNC_VIS long double stold(const string& __str, size_t* __idx = nullptr);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI constexpr basic_string<_CharT, _Traits, _Allocator>
+operator+(type_identity_t<basic_string_view<_CharT, _Traits>> __lhs,
+          const basic_string<_CharT, _Traits, _Allocator>& __rhs) {
+  using _String                        = basic_string<_CharT, _Traits, _Allocator>;
+  typename _String::size_type __lhs_sz = __lhs.size();
+  typename _String::size_type __rhs_sz = __rhs.size();
+  _String __r(__uninitialized_size_tag(),
+              __lhs_sz + __rhs_sz,
+              _String::__alloc_traits::select_on_container_copy_construction(__rhs.get_allocator()));
+  auto __ptr = std::__to_address(__r.__get_pointer());
+  _Traits::copy(__ptr, __lhs.data(), __lhs_sz);
+  _Traits::copy(__ptr + __lhs_sz, __rhs.data(), __rhs_sz);
+  _Traits::assign(__ptr + __lhs_sz + __rhs_sz, 1, _CharT());
+  return __r;
+}
 
-_LIBCPP_FUNC_VIS string to_string(int __val);
-_LIBCPP_FUNC_VIS string to_string(unsigned __val);
-_LIBCPP_FUNC_VIS string to_string(long __val);
-_LIBCPP_FUNC_VIS string to_string(unsigned long __val);
-_LIBCPP_FUNC_VIS string to_string(long long __val);
-_LIBCPP_FUNC_VIS string to_string(unsigned long long __val);
-_LIBCPP_FUNC_VIS string to_string(float __val);
-_LIBCPP_FUNC_VIS string to_string(double __val);
-_LIBCPP_FUNC_VIS string to_string(long double __val);
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI constexpr basic_string<_CharT, _Traits, _Allocator>
+operator+(type_identity_t<basic_string_view<_CharT, _Traits>> __lhs,
+          basic_string<_CharT, _Traits, _Allocator>&& __rhs) {
+  __rhs.insert(0, __lhs);
+  return std::move(__rhs);
+}
+
+#endif // _LIBCPP_STD_VER >= 26
+
+// swap
+
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+swap(basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>& __rhs)
+    _NOEXCEPT_(_NOEXCEPT_(__lhs.swap(__rhs))) {
+  __lhs.swap(__rhs);
+}
+
+_LIBCPP_EXPORTED_FROM_ABI int stoi(const string& __str, size_t* __idx = nullptr, int __base = 10);
+_LIBCPP_EXPORTED_FROM_ABI long stol(const string& __str, size_t* __idx = nullptr, int __base = 10);
+_LIBCPP_EXPORTED_FROM_ABI unsigned long stoul(const string& __str, size_t* __idx = nullptr, int __base = 10);
+_LIBCPP_EXPORTED_FROM_ABI long long stoll(const string& __str, size_t* __idx = nullptr, int __base = 10);
+_LIBCPP_EXPORTED_FROM_ABI unsigned long long stoull(const string& __str, size_t* __idx = nullptr, int __base = 10);
+
+_LIBCPP_EXPORTED_FROM_ABI float stof(const string& __str, size_t* __idx = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI double stod(const string& __str, size_t* __idx = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI long double stold(const string& __str, size_t* __idx = nullptr);
+
+_LIBCPP_EXPORTED_FROM_ABI string to_string(int __val);
+_LIBCPP_EXPORTED_FROM_ABI string to_string(unsigned __val);
+_LIBCPP_EXPORTED_FROM_ABI string to_string(long __val);
+_LIBCPP_EXPORTED_FROM_ABI string to_string(unsigned long __val);
+_LIBCPP_EXPORTED_FROM_ABI string to_string(long long __val);
+_LIBCPP_EXPORTED_FROM_ABI string to_string(unsigned long long __val);
+_LIBCPP_EXPORTED_FROM_ABI string to_string(float __val);
+_LIBCPP_EXPORTED_FROM_ABI string to_string(double __val);
+_LIBCPP_EXPORTED_FROM_ABI string to_string(long double __val);
 
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_LIBCPP_FUNC_VIS int                stoi  (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
-_LIBCPP_FUNC_VIS long               stol  (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
-_LIBCPP_FUNC_VIS unsigned long      stoul (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
-_LIBCPP_FUNC_VIS long long          stoll (const wstring& __str, size_t* __idx = nullptr, int __base = 10);
-_LIBCPP_FUNC_VIS unsigned long long stoull(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
+_LIBCPP_EXPORTED_FROM_ABI int stoi(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
+_LIBCPP_EXPORTED_FROM_ABI long stol(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
+_LIBCPP_EXPORTED_FROM_ABI unsigned long stoul(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
+_LIBCPP_EXPORTED_FROM_ABI long long stoll(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
+_LIBCPP_EXPORTED_FROM_ABI unsigned long long stoull(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
 
-_LIBCPP_FUNC_VIS float       stof (const wstring& __str, size_t* __idx = nullptr);
-_LIBCPP_FUNC_VIS double      stod (const wstring& __str, size_t* __idx = nullptr);
-_LIBCPP_FUNC_VIS long double stold(const wstring& __str, size_t* __idx = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI float stof(const wstring& __str, size_t* __idx = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI double stod(const wstring& __str, size_t* __idx = nullptr);
+_LIBCPP_EXPORTED_FROM_ABI long double stold(const wstring& __str, size_t* __idx = nullptr);
 
-_LIBCPP_FUNC_VIS wstring to_wstring(int __val);
-_LIBCPP_FUNC_VIS wstring to_wstring(unsigned __val);
-_LIBCPP_FUNC_VIS wstring to_wstring(long __val);
-_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long __val);
-_LIBCPP_FUNC_VIS wstring to_wstring(long long __val);
-_LIBCPP_FUNC_VIS wstring to_wstring(unsigned long long __val);
-_LIBCPP_FUNC_VIS wstring to_wstring(float __val);
-_LIBCPP_FUNC_VIS wstring to_wstring(double __val);
-_LIBCPP_FUNC_VIS wstring to_wstring(long double __val);
+_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(int __val);
+_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(unsigned __val);
+_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(long __val);
+_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(unsigned long __val);
+_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(long long __val);
+_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(unsigned long long __val);
+_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(float __val);
+_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(double __val);
+_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(long double __val);
 #endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
 
-template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_TEMPLATE_DATA_VIS
-const typename basic_string<_CharT, _Traits, _Allocator>::size_type
-               basic_string<_CharT, _Traits, _Allocator>::npos;
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_TEMPLATE_DATA_VIS const typename basic_string<_CharT, _Traits, _Allocator>::size_type
+    basic_string<_CharT, _Traits, _Allocator>::npos;
 
 template <class _CharT, class _Allocator>
 struct __string_hash : public __unary_function<basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t> {
-    _LIBCPP_HIDE_FROM_ABI size_t
-    operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT {
-        return std::__do_string_hash(__val.data(), __val.data() + __val.size());
-    }
+  _LIBCPP_HIDE_FROM_ABI size_t
+  operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT {
+    return std::__do_string_hash(__val.data(), __val.data() + __val.size());
+  }
 };
 
 template <class _Allocator>
@@ -4240,147 +4210,90 @@ template <class _Allocator>
 struct hash<basic_string<wchar_t, char_traits<wchar_t>, _Allocator> > : __string_hash<wchar_t, _Allocator> {};
 #endif
 
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           const basic_string<_CharT, _Traits, _Allocator>& __str);
+operator<<(basic_ostream<_CharT, _Traits>& __os, const basic_string<_CharT, _Traits, _Allocator>& __str);
 
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is,
-           basic_string<_CharT, _Traits, _Allocator>& __str);
+operator>>(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Allocator>& __str);
 
-template<class _CharT, class _Traits, class _Allocator>
+template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
-getline(basic_istream<_CharT, _Traits>& __is,
-        basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
+getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-basic_istream<_CharT, _Traits>&
-getline(basic_istream<_CharT, _Traits>& __is,
-        basic_string<_CharT, _Traits, _Allocator>& __str);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+getline(basic_istream<_CharT, _Traits>& __is, basic_string<_CharT, _Traits, _Allocator>& __str);
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-basic_istream<_CharT, _Traits>&
-getline(basic_istream<_CharT, _Traits>&& __is,
-        basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+getline(basic_istream<_CharT, _Traits>&& __is, basic_string<_CharT, _Traits, _Allocator>& __str, _CharT __dlm);
 
-template<class _CharT, class _Traits, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-basic_istream<_CharT, _Traits>&
-getline(basic_istream<_CharT, _Traits>&& __is,
-        basic_string<_CharT, _Traits, _Allocator>& __str);
+template <class _CharT, class _Traits, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
+getline(basic_istream<_CharT, _Traits>&& __is, basic_string<_CharT, _Traits, _Allocator>& __str);
 
 #if _LIBCPP_STD_VER >= 20
 template <class _CharT, class _Traits, class _Allocator, class _Up>
-inline _LIBCPP_HIDE_FROM_ABI
-    typename basic_string<_CharT, _Traits, _Allocator>::size_type
-    erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) {
+inline _LIBCPP_HIDE_FROM_ABI typename basic_string<_CharT, _Traits, _Allocator>::size_type
+erase(basic_string<_CharT, _Traits, _Allocator>& __str, const _Up& __v) {
   auto __old_size = __str.size();
   __str.erase(std::remove(__str.begin(), __str.end(), __v), __str.end());
   return __old_size - __str.size();
 }
 
 template <class _CharT, class _Traits, class _Allocator, class _Predicate>
-inline _LIBCPP_HIDE_FROM_ABI
-    typename basic_string<_CharT, _Traits, _Allocator>::size_type
-    erase_if(basic_string<_CharT, _Traits, _Allocator>& __str,
-             _Predicate __pred) {
+inline _LIBCPP_HIDE_FROM_ABI typename basic_string<_CharT, _Traits, _Allocator>::size_type
+erase_if(basic_string<_CharT, _Traits, _Allocator>& __str, _Predicate __pred) {
   auto __old_size = __str.size();
-  __str.erase(std::remove_if(__str.begin(), __str.end(), __pred),
-              __str.end());
+  __str.erase(std::remove_if(__str.begin(), __str.end(), __pred), __str.end());
   return __old_size - __str.size();
 }
 #endif
 
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-template<class _CharT, class _Traits, class _Allocator>
-bool
-basic_string<_CharT, _Traits, _Allocator>::__dereferenceable(const const_iterator* __i) const
-{
-    return data() <= std::__to_address(__i->base()) &&
-           std::__to_address(__i->base()) < data() + size();
-}
-
-template<class _CharT, class _Traits, class _Allocator>
-bool
-basic_string<_CharT, _Traits, _Allocator>::__decrementable(const const_iterator* __i) const
-{
-    return data() < std::__to_address(__i->base()) &&
-           std::__to_address(__i->base()) <= data() + size();
-}
-
-template<class _CharT, class _Traits, class _Allocator>
-bool
-basic_string<_CharT, _Traits, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
-{
-    const value_type* __p = std::__to_address(__i->base()) + __n;
-    return data() <= __p && __p <= data() + size();
-}
-
-template<class _CharT, class _Traits, class _Allocator>
-bool
-basic_string<_CharT, _Traits, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
-{
-    const value_type* __p = std::__to_address(__i->base()) + __n;
-    return data() <= __p && __p < data() + size();
-}
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
-
 #if _LIBCPP_STD_VER >= 14
 // Literal suffixes for basic_string [basic.string.literals]
-inline namespace literals
-{
-  inline namespace string_literals
-  {
-    inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string<char> operator "" s( const char *__str, size_t __len )
-    {
-        return basic_string<char> (__str, __len);
-    }
+inline namespace literals {
+inline namespace string_literals {
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<char>
+operator""s(const char* __str, size_t __len) {
+  return basic_string<char>(__str, __len);
+}
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len )
-    {
-        return basic_string<wchar_t> (__str, __len);
-    }
-#endif
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<wchar_t>
+operator""s(const wchar_t* __str, size_t __len) {
+  return basic_string<wchar_t>(__str, __len);
+}
+#  endif
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-    inline _LIBCPP_HIDE_FROM_ABI constexpr
-    basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len)
-    {
-        return basic_string<char8_t> (__str, __len);
-    }
-#endif
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
+inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string<char8_t> operator""s(const char8_t* __str, size_t __len) {
+  return basic_string<char8_t>(__str, __len);
+}
+#  endif
 
-    inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string<char16_t> operator "" s( const char16_t *__str, size_t __len )
-    {
-        return basic_string<char16_t> (__str, __len);
-    }
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<char16_t>
+operator""s(const char16_t* __str, size_t __len) {
+  return basic_string<char16_t>(__str, __len);
+}
 
-    inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    basic_string<char32_t> operator "" s( const char32_t *__str, size_t __len )
-    {
-        return basic_string<char32_t> (__str, __len);
-    }
-  } // namespace string_literals
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<char32_t>
+operator""s(const char32_t* __str, size_t __len) {
+  return basic_string<char32_t>(__str, __len);
+}
+} // namespace string_literals
 } // namespace literals
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
 template <>
 inline constexpr bool __format::__enable_insertable<std::basic_string<char>> = true;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#    ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
 inline constexpr bool __format::__enable_insertable<std::basic_string<wchar_t>> = true;
-#endif
-#endif
+#    endif
+#  endif
 
 #endif
 
@@ -4399,6 +4312,4 @@ _LIBCPP_POP_MACROS
 #  include <utility>
 #endif
 
-#pragma GCC diagnostic pop // [jart]
-
 #endif // _LIBCPP_STRING
diff --git a/third_party/libcxx/string.cpp b/third_party/libcxx/string.cpp
new file mode 100644
index 000000000..cf07b3ef1
--- /dev/null
+++ b/third_party/libcxx/string.cpp
@@ -0,0 +1,347 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__assert>
+#include <cerrno>
+#include <charconv>
+#include <cstdlib>
+#include <limits>
+#include <stdexcept>
+#include <string>
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  include <cwchar>
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#ifndef _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
+
+template <bool>
+struct __basic_string_common;
+
+// The struct isn't declared anymore in the headers. It's only here for ABI compatibility.
+template <>
+struct __basic_string_common<true> {
+  _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_length_error() const;
+  _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_out_of_range() const;
+};
+
+void __basic_string_common<true>::__throw_length_error() const { std::__throw_length_error("basic_string"); }
+void __basic_string_common<true>::__throw_out_of_range() const { std::__throw_out_of_range("basic_string"); }
+
+#endif // _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
+
+#define _LIBCPP_EXTERN_TEMPLATE_DEFINE(...) template __VA_ARGS__;
+#ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
+_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, char)
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+_LIBCPP_STRING_UNSTABLE_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, wchar_t)
+#  endif
+#else
+_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, char)
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+_LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_EXTERN_TEMPLATE_DEFINE, wchar_t)
+#  endif
+#endif
+#undef _LIBCPP_EXTERN_TEMPLATE_DEFINE
+
+template string operator+ <char, char_traits<char>, allocator<char>>(char const*, string const&);
+
+namespace {
+
+inline void throw_from_string_out_of_range(const string& func) {
+  std::__throw_out_of_range((func + ": out of range").c_str());
+}
+
+inline void throw_from_string_invalid_arg(const string& func) {
+  std::__throw_invalid_argument((func + ": no conversion").c_str());
+}
+
+// as_integer
+
+template <typename V, typename S, typename F>
+inline V as_integer_helper(const string& func, const S& str, size_t* idx, int base, F f) {
+  typename S::value_type* ptr                             = nullptr;
+  const typename S::value_type* const p                   = str.c_str();
+  __libcpp_remove_reference_t<decltype(errno)> errno_save = errno;
+  errno                                                   = 0;
+  V r                                                     = f(p, &ptr, base);
+  swap(errno, errno_save);
+  if (errno_save == ERANGE)
+    throw_from_string_out_of_range(func);
+  if (ptr == p)
+    throw_from_string_invalid_arg(func);
+  if (idx)
+    *idx = static_cast<size_t>(ptr - p);
+  return r;
+}
+
+template <typename V, typename S>
+inline V as_integer(const string& func, const S& s, size_t* idx, int base);
+
+// string
+template <>
+inline int as_integer(const string& func, const string& s, size_t* idx, int base) {
+  // Use long as no Standard string to integer exists.
+  long r = as_integer_helper<long>(func, s, idx, base, strtol);
+  if (r < numeric_limits<int>::min() || numeric_limits<int>::max() < r)
+    throw_from_string_out_of_range(func);
+  return static_cast<int>(r);
+}
+
+template <>
+inline long as_integer(const string& func, const string& s, size_t* idx, int base) {
+  return as_integer_helper<long>(func, s, idx, base, strtol);
+}
+
+template <>
+inline unsigned long as_integer(const string& func, const string& s, size_t* idx, int base) {
+  return as_integer_helper<unsigned long>(func, s, idx, base, strtoul);
+}
+
+template <>
+inline long long as_integer(const string& func, const string& s, size_t* idx, int base) {
+  return as_integer_helper<long long>(func, s, idx, base, strtoll);
+}
+
+template <>
+inline unsigned long long as_integer(const string& func, const string& s, size_t* idx, int base) {
+  return as_integer_helper<unsigned long long>(func, s, idx, base, strtoull);
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+// wstring
+template <>
+inline int as_integer(const string& func, const wstring& s, size_t* idx, int base) {
+  // Use long as no Stantard string to integer exists.
+  long r = as_integer_helper<long>(func, s, idx, base, wcstol);
+  if (r < numeric_limits<int>::min() || numeric_limits<int>::max() < r)
+    throw_from_string_out_of_range(func);
+  return static_cast<int>(r);
+}
+
+template <>
+inline long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
+  return as_integer_helper<long>(func, s, idx, base, wcstol);
+}
+
+template <>
+inline unsigned long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
+  return as_integer_helper<unsigned long>(func, s, idx, base, wcstoul);
+}
+
+template <>
+inline long long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
+  return as_integer_helper<long long>(func, s, idx, base, wcstoll);
+}
+
+template <>
+inline unsigned long long as_integer(const string& func, const wstring& s, size_t* idx, int base) {
+  return as_integer_helper<unsigned long long>(func, s, idx, base, wcstoull);
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// as_float
+
+template <typename V, typename S, typename F>
+inline V as_float_helper(const string& func, const S& str, size_t* idx, F f) {
+  typename S::value_type* ptr                             = nullptr;
+  const typename S::value_type* const p                   = str.c_str();
+  __libcpp_remove_reference_t<decltype(errno)> errno_save = errno;
+  errno                                                   = 0;
+  V r                                                     = f(p, &ptr);
+  swap(errno, errno_save);
+  if (errno_save == ERANGE)
+    throw_from_string_out_of_range(func);
+  if (ptr == p)
+    throw_from_string_invalid_arg(func);
+  if (idx)
+    *idx = static_cast<size_t>(ptr - p);
+  return r;
+}
+
+template <typename V, typename S>
+inline V as_float(const string& func, const S& s, size_t* idx = nullptr);
+
+template <>
+inline float as_float(const string& func, const string& s, size_t* idx) {
+  return as_float_helper<float>(func, s, idx, strtof);
+}
+
+template <>
+inline double as_float(const string& func, const string& s, size_t* idx) {
+  return as_float_helper<double>(func, s, idx, strtod);
+}
+
+template <>
+inline long double as_float(const string& func, const string& s, size_t* idx) {
+  return as_float_helper<long double>(func, s, idx, strtold);
+}
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+inline float as_float(const string& func, const wstring& s, size_t* idx) {
+  return as_float_helper<float>(func, s, idx, wcstof);
+}
+
+template <>
+inline double as_float(const string& func, const wstring& s, size_t* idx) {
+  return as_float_helper<double>(func, s, idx, wcstod);
+}
+
+template <>
+inline long double as_float(const string& func, const wstring& s, size_t* idx) {
+  return as_float_helper<long double>(func, s, idx, wcstold);
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+} // unnamed namespace
+
+int stoi(const string& str, size_t* idx, int base) { return as_integer<int>("stoi", str, idx, base); }
+
+long stol(const string& str, size_t* idx, int base) { return as_integer<long>("stol", str, idx, base); }
+
+unsigned long stoul(const string& str, size_t* idx, int base) {
+  return as_integer<unsigned long>("stoul", str, idx, base);
+}
+
+long long stoll(const string& str, size_t* idx, int base) { return as_integer<long long>("stoll", str, idx, base); }
+
+unsigned long long stoull(const string& str, size_t* idx, int base) {
+  return as_integer<unsigned long long>("stoull", str, idx, base);
+}
+
+float stof(const string& str, size_t* idx) { return as_float<float>("stof", str, idx); }
+
+double stod(const string& str, size_t* idx) { return as_float<double>("stod", str, idx); }
+
+long double stold(const string& str, size_t* idx) { return as_float<long double>("stold", str, idx); }
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+int stoi(const wstring& str, size_t* idx, int base) { return as_integer<int>("stoi", str, idx, base); }
+
+long stol(const wstring& str, size_t* idx, int base) { return as_integer<long>("stol", str, idx, base); }
+
+unsigned long stoul(const wstring& str, size_t* idx, int base) {
+  return as_integer<unsigned long>("stoul", str, idx, base);
+}
+
+long long stoll(const wstring& str, size_t* idx, int base) { return as_integer<long long>("stoll", str, idx, base); }
+
+unsigned long long stoull(const wstring& str, size_t* idx, int base) {
+  return as_integer<unsigned long long>("stoull", str, idx, base);
+}
+
+float stof(const wstring& str, size_t* idx) { return as_float<float>("stof", str, idx); }
+
+double stod(const wstring& str, size_t* idx) { return as_float<double>("stod", str, idx); }
+
+long double stold(const wstring& str, size_t* idx) { return as_float<long double>("stold", str, idx); }
+#endif // !_LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+// to_string
+
+namespace {
+
+// as_string
+
+template <typename S, typename P, typename V >
+inline S as_string(P sprintf_like, S s, const typename S::value_type* fmt, V a) {
+  typedef typename S::size_type size_type;
+  size_type available = s.size();
+  while (true) {
+    int status = sprintf_like(&s[0], available + 1, fmt, a);
+    if (status >= 0) {
+      size_type used = static_cast<size_type>(status);
+      if (used <= available) {
+        s.resize(used);
+        break;
+      }
+      available = used; // Assume this is advice of how much space we need.
+    } else
+      available = available * 2 + 1;
+    s.resize(available);
+  }
+  return s;
+}
+
+template <class S>
+struct initial_string;
+
+template <>
+struct initial_string<string> {
+  string operator()() const {
+    string s;
+    s.resize(s.capacity());
+    return s;
+  }
+};
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <>
+struct initial_string<wstring> {
+  wstring operator()() const {
+    wstring s(20, wchar_t());
+    s.resize(s.capacity());
+    return s;
+  }
+};
+
+typedef int (*wide_printf)(wchar_t* __restrict, size_t, const wchar_t* __restrict, ...);
+
+inline wide_printf get_swprintf() {
+#  ifndef _LIBCPP_MSVCRT
+  return swprintf;
+#  else
+  return static_cast<int(__cdecl*)(wchar_t* __restrict, size_t, const wchar_t* __restrict, ...)>(_snwprintf);
+#  endif
+}
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+template <typename S, typename V>
+S i_to_string(V v) {
+  //  numeric_limits::digits10 returns value less on 1 than desired for unsigned numbers.
+  //  For example, for 1-byte unsigned value digits10 is 2 (999 can not be represented),
+  //  so we need +1 here.
+  constexpr size_t bufsize = numeric_limits<V>::digits10 + 2; // +1 for minus, +1 for digits10
+  char buf[bufsize];
+  const auto res = to_chars(buf, buf + bufsize, v);
+  _LIBCPP_ASSERT_INTERNAL(res.ec == errc(), "bufsize must be large enough to accomodate the value");
+  return S(buf, res.ptr);
+}
+
+} // unnamed namespace
+
+string to_string(int val) { return i_to_string< string>(val); }
+string to_string(long val) { return i_to_string< string>(val); }
+string to_string(long long val) { return i_to_string< string>(val); }
+string to_string(unsigned val) { return i_to_string< string>(val); }
+string to_string(unsigned long val) { return i_to_string< string>(val); }
+string to_string(unsigned long long val) { return i_to_string< string>(val); }
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+wstring to_wstring(int val) { return i_to_string<wstring>(val); }
+wstring to_wstring(long val) { return i_to_string<wstring>(val); }
+wstring to_wstring(long long val) { return i_to_string<wstring>(val); }
+wstring to_wstring(unsigned val) { return i_to_string<wstring>(val); }
+wstring to_wstring(unsigned long val) { return i_to_string<wstring>(val); }
+wstring to_wstring(unsigned long long val) { return i_to_string<wstring>(val); }
+#endif
+
+string to_string(float val) { return as_string(snprintf, initial_string< string>()(), "%f", val); }
+string to_string(double val) { return as_string(snprintf, initial_string< string>()(), "%f", val); }
+string to_string(long double val) { return as_string(snprintf, initial_string< string>()(), "%Lf", val); }
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+wstring to_wstring(float val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%f", val); }
+wstring to_wstring(double val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%f", val); }
+wstring to_wstring(long double val) { return as_string(get_swprintf(), initial_string<wstring>()(), L"%Lf", val); }
+#endif
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/string.h b/third_party/libcxx/string.h
index 673d90316..ae10d5ad2 100644
--- a/third_party/libcxx/string.h
+++ b/third_party/libcxx/string.h
@@ -65,7 +65,7 @@ size_t strlen(const char* s);
 // <string.h>. This macro can be defined by users if their C library provides
 // the right signature.
 #if defined(__CORRECT_ISO_CPP_STRING_H_PROTO) || defined(_LIBCPP_MSVCRT) || defined(_STRING_H_CPLUSPLUS_98_CONFORMANCE_)
-#define _LIBCPP_STRING_H_HAS_CONST_OVERLOADS
+#  define _LIBCPP_STRING_H_HAS_CONST_OVERLOADS
 #endif
 
 #if defined(__cplusplus) && !defined(_LIBCPP_STRING_H_HAS_CONST_OVERLOADS) && defined(_LIBCPP_PREFERRED_OVERLOAD)
diff --git a/third_party/libcxx/string_view b/third_party/libcxx/string_view
index 2cdad4441..72dbf0bfa 100644
--- a/third_party/libcxx/string_view
+++ b/third_party/libcxx/string_view
@@ -10,6 +10,8 @@
 #ifndef _LIBCPP_STRING_VIEW
 #define _LIBCPP_STRING_VIEW
 
+// clang-format off
+
 /*
 
     string_view synopsis
@@ -191,27 +193,30 @@ namespace std {
   template <> struct hash<u32string_view>;
   template <> struct hash<wstring_view>;
 
-  constexpr basic_string_view<char>     operator "" sv(const char *str,     size_t len) noexcept;
-  constexpr basic_string_view<wchar_t>  operator "" sv(const wchar_t *str,  size_t len) noexcept;
-  constexpr basic_string_view<char8_t>  operator "" sv(const char8_t *str,  size_t len) noexcept; // C++20
-  constexpr basic_string_view<char16_t> operator "" sv(const char16_t *str, size_t len) noexcept;
-  constexpr basic_string_view<char32_t> operator "" sv(const char32_t *str, size_t len) noexcept;
+  constexpr basic_string_view<char>     operator""sv(const char *str,     size_t len) noexcept;
+  constexpr basic_string_view<wchar_t>  operator""sv(const wchar_t *str,  size_t len) noexcept;
+  constexpr basic_string_view<char8_t>  operator""sv(const char8_t *str,  size_t len) noexcept; // C++20
+  constexpr basic_string_view<char16_t> operator""sv(const char16_t *str, size_t len) noexcept;
+  constexpr basic_string_view<char32_t> operator""sv(const char32_t *str, size_t len) noexcept;
 
 }  // namespace std
 
-
 */
 
+// clang-format on
+
 #include <__algorithm/min.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
+#include <__fwd/ostream.h>
 #include <__fwd/string_view.h>
 #include <__iterator/bounded_iter.h>
 #include <__iterator/concepts.h>
-#include <__iterator/readable_traits.h>
+#include <__iterator/iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
+#include <__iterator/wrap_iter.h>
 #include <__memory/pointer_traits.h>
 #include <__ranges/concepts.h>
 #include <__ranges/data.h>
@@ -252,494 +257,425 @@ namespace std {
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // TODO: This is a workaround for some vendors to carry a downstream diff to accept `nullptr` in
 //       string_view constructors. This can be refactored when this exact form isn't needed anymore.
 template <class _Traits>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
-inline size_t __char_traits_length_checked(const typename _Traits::char_type* __s) _NOEXCEPT {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR inline size_t
+__char_traits_length_checked(const typename _Traits::char_type* __s) _NOEXCEPT {
   // This needs to be a single statement for C++11 constexpr
-  return _LIBCPP_ASSERT(__s != nullptr, "null pointer passed to non-null argument of char_traits<...>::length"), _Traits::length(__s);
+  return _LIBCPP_ASSERT_NON_NULL(
+             __s != nullptr, "null pointer passed to non-null argument of char_traits<...>::length"),
+         _Traits::length(__s);
 }
 
-template<class _CharT, class _Traits>
+template <class _CharT, class _Traits>
 class basic_string_view {
 public:
-    // types
-    using traits_type            = _Traits;
-    using value_type             = _CharT;
-    using pointer                = _CharT*;
-    using const_pointer          = const _CharT*;
-    using reference              = _CharT&;
-    using const_reference        = const _CharT&;
-#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
-    using const_iterator         = __bounded_iter<const_pointer>;
+  // types
+  using traits_type     = _Traits;
+  using value_type      = _CharT;
+  using pointer         = _CharT*;
+  using const_pointer   = const _CharT*;
+  using reference       = _CharT&;
+  using const_reference = const _CharT&;
+#if defined(_LIBCPP_ABI_BOUNDED_ITERATORS)
+  using const_iterator = __bounded_iter<const_pointer>;
+#elif defined(_LIBCPP_ABI_USE_WRAP_ITER_IN_STD_STRING_VIEW)
+  using const_iterator = __wrap_iter<const_pointer>;
 #else
-    using const_iterator         = const_pointer; // See [string.view.iterators]
+  using const_iterator = const_pointer;
 #endif
-    using iterator               = const_iterator;
-    using const_reverse_iterator = _VSTD::reverse_iterator<const_iterator>;
-    using reverse_iterator       = const_reverse_iterator;
-    using size_type              = size_t;
-    using difference_type        = ptrdiff_t;
-    static _LIBCPP_CONSTEXPR const size_type npos = -1; // size_type(-1);
+  using iterator                                = const_iterator;
+  using const_reverse_iterator                  = std::reverse_iterator<const_iterator>;
+  using reverse_iterator                        = const_reverse_iterator;
+  using size_type                               = size_t;
+  using difference_type                         = ptrdiff_t;
+  static _LIBCPP_CONSTEXPR const size_type npos = -1; // size_type(-1);
 
-    static_assert((!is_array<value_type>::value), "Character type of basic_string_view must not be an array");
-    static_assert(( is_standard_layout<value_type>::value), "Character type of basic_string_view must be standard-layout");
-    static_assert(( is_trivial<value_type>::value), "Character type of basic_string_view must be trivial");
-    static_assert((is_same<_CharT, typename traits_type::char_type>::value),
-                  "traits_type::char_type must be the same type as CharT");
+  static_assert(!is_array<value_type>::value, "Character type of basic_string_view must not be an array");
+  static_assert(is_standard_layout<value_type>::value, "Character type of basic_string_view must be standard-layout");
+  static_assert(is_trivial<value_type>::value, "Character type of basic_string_view must be trivial");
+  static_assert(is_same<_CharT, typename traits_type::char_type>::value,
+                "traits_type::char_type must be the same type as CharT");
 
-    // [string.view.cons], construct/copy
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    basic_string_view() _NOEXCEPT : __data_(nullptr), __size_(0) {}
+  // [string.view.cons], construct/copy
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view() _NOEXCEPT : __data_(nullptr), __size_(0) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_string_view(const basic_string_view&) _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI basic_string_view(const basic_string_view&) _NOEXCEPT = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    basic_string_view(const _CharT* __s, size_type __len) _NOEXCEPT
-        : __data_(__s), __size_(__len)
-    {
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view(const _CharT* __s, size_type __len) _NOEXCEPT
+      : __data_(__s),
+        __size_(__len) {
 #if _LIBCPP_STD_VER >= 14
-    _LIBCPP_ASSERT(__len <= static_cast<size_type>(numeric_limits<difference_type>::max()), "string_view::string_view(_CharT *, size_t): length does not fit in difference_type");
-    _LIBCPP_ASSERT(__len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): received nullptr");
+    // Allocations must fit in `ptrdiff_t` for pointer arithmetic to work. If `__len` exceeds it, the input
+    // range could not have been valid. Most likely the caller underflowed some arithmetic and inadvertently
+    // passed in a negative length.
+    _LIBCPP_ASSERT_VALID_INPUT_RANGE(
+        __len <= static_cast<size_type>(numeric_limits<difference_type>::max()),
+        "string_view::string_view(_CharT *, size_t): length does not fit in difference_type");
+    _LIBCPP_ASSERT_NON_NULL(
+        __len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): received nullptr");
 #endif
-    }
+  }
 
 #if _LIBCPP_STD_VER >= 20
-    template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
-      requires (is_same_v<iter_value_t<_It>, _CharT> && !is_convertible_v<_End, size_type>)
-    constexpr _LIBCPP_HIDE_FROM_ABI basic_string_view(_It __begin, _End __end)
-       : __data_(_VSTD::to_address(__begin)), __size_(__end - __begin)
-    {
-      _LIBCPP_ASSERT((__end - __begin) >= 0, "std::string_view::string_view(iterator, sentinel) received invalid range");
-    }
+  template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
+    requires(is_same_v<iter_value_t<_It>, _CharT> && !is_convertible_v<_End, size_type>)
+  constexpr _LIBCPP_HIDE_FROM_ABI basic_string_view(_It __begin, _End __end)
+      : __data_(std::to_address(__begin)), __size_(__end - __begin) {
+    _LIBCPP_ASSERT_VALID_INPUT_RANGE(
+        (__end - __begin) >= 0, "std::string_view::string_view(iterator, sentinel) received invalid range");
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
 #if _LIBCPP_STD_VER >= 23
-    template <class _Range>
-      requires (
-        !is_same_v<remove_cvref_t<_Range>, basic_string_view> &&
-        ranges::contiguous_range<_Range> &&
-        ranges::sized_range<_Range> &&
-        is_same_v<ranges::range_value_t<_Range>, _CharT> &&
-        !is_convertible_v<_Range, const _CharT*> &&
-        (!requires(remove_cvref_t<_Range>& __d) {
-          __d.operator _VSTD::basic_string_view<_CharT, _Traits>();
-        })
-      )
-    constexpr explicit _LIBCPP_HIDE_FROM_ABI
-    basic_string_view(_Range&& __r) : __data_(ranges::data(__r)), __size_(ranges::size(__r)) {}
+  template <class _Range>
+    requires(!is_same_v<remove_cvref_t<_Range>, basic_string_view> && ranges::contiguous_range<_Range> &&
+             ranges::sized_range<_Range> && is_same_v<ranges::range_value_t<_Range>, _CharT> &&
+             !is_convertible_v<_Range, const _CharT*> &&
+             (!requires(remove_cvref_t<_Range>& __d) { __d.operator std::basic_string_view<_CharT, _Traits>(); }))
+  constexpr explicit _LIBCPP_HIDE_FROM_ABI basic_string_view(_Range&& __r)
+      : __data_(ranges::data(__r)), __size_(ranges::size(__r)) {}
 #endif // _LIBCPP_STD_VER >= 23
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    basic_string_view(const _CharT* __s)
-        : __data_(__s), __size_(_VSTD::__char_traits_length_checked<_Traits>(__s)) {}
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view(const _CharT* __s)
+      : __data_(__s), __size_(std::__char_traits_length_checked<_Traits>(__s)) {}
 
 #if _LIBCPP_STD_VER >= 23
-    basic_string_view(nullptr_t) = delete;
+  basic_string_view(nullptr_t) = delete;
 #endif
 
-    // [string.view.iterators], iterators
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT { return cbegin(); }
+  // [string.view.iterators], iterators
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return cbegin(); }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT { return cend(); }
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return cend(); }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {
-#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
-        return std::__make_bounded_iter(data(), data(), data() + size());
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
+#ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
+    return std::__make_bounded_iter(data(), data(), data() + size());
 #else
-        return __data_;
+    return const_iterator(__data_);
 #endif
-    }
+  }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {
-#ifdef _LIBCPP_DEBUG_ITERATOR_BOUNDS_CHECKING
-        return std::__make_bounded_iter(data() + size(), data(), data() + size());
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT {
+#ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
+    return std::__make_bounded_iter(data() + size(), data(), data() + size());
 #else
-        return __data_ + __size_;
+    return const_iterator(__data_ + __size_);
 #endif
-    }
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin()   const _NOEXCEPT { return const_reverse_iterator(cend()); }
+  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {
+    return const_reverse_iterator(cend());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend()     const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
+  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
+    return const_reverse_iterator(cbegin());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin()  const _NOEXCEPT { return const_reverse_iterator(cend()); }
+  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT {
+    return const_reverse_iterator(cend());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend()    const _NOEXCEPT { return const_reverse_iterator(cbegin()); }
+  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT {
+    return const_reverse_iterator(cbegin());
+  }
 
-    // [string.view.capacity], capacity
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    size_type size()     const _NOEXCEPT { return __size_; }
+  // [string.view.capacity], capacity
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size_; }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    size_type length()   const _NOEXCEPT { return __size_; }
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type length() const _NOEXCEPT { return __size_; }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT { return numeric_limits<size_type>::max() / sizeof(value_type); }
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+    return numeric_limits<size_type>::max() / sizeof(value_type);
+  }
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    bool empty()         const _NOEXCEPT { return __size_ == 0; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT { return __size_ == 0; }
 
-    // [string.view.access], element access
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_reference operator[](size_type __pos) const _NOEXCEPT {
-      return _LIBCPP_ASSERT(__pos < size(), "string_view[] index out of bounds"), __data_[__pos];
-    }
+  // [string.view.access], element access
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __pos) const _NOEXCEPT {
+    return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__pos < size(), "string_view[] index out of bounds"), __data_[__pos];
+  }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_reference at(size_type __pos) const
-    {
-        return __pos >= size()
-            ? (__throw_out_of_range("string_view::at"), __data_[0])
-            : __data_[__pos];
-    }
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __pos) const {
+    return __pos >= size() ? (__throw_out_of_range("string_view::at"), __data_[0]) : __data_[__pos];
+  }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_reference front() const _NOEXCEPT
-    {
-        return _LIBCPP_ASSERT(!empty(), "string_view::front(): string is empty"), __data_[0];
-    }
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT {
+    return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string_view::front(): string is empty"), __data_[0];
+  }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_reference back() const _NOEXCEPT
-    {
-        return _LIBCPP_ASSERT(!empty(), "string_view::back(): string is empty"), __data_[__size_-1];
-    }
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT {
+    return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string_view::back(): string is empty"), __data_[__size_ - 1];
+  }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    const_pointer data() const _NOEXCEPT { return __data_; }
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_pointer data() const _NOEXCEPT { return __data_; }
 
-    // [string.view.modifiers], modifiers:
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    void remove_prefix(size_type __n) _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__n <= size(), "remove_prefix() can't remove more than size()");
-        __data_ += __n;
-        __size_ -= __n;
-    }
+  // [string.view.modifiers], modifiers:
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI void remove_prefix(size_type __n) _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n <= size(), "remove_prefix() can't remove more than size()");
+    __data_ += __n;
+    __size_ -= __n;
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    void remove_suffix(size_type __n) _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__n <= size(), "remove_suffix() can't remove more than size()");
-        __size_ -= __n;
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI void remove_suffix(size_type __n) _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n <= size(), "remove_suffix() can't remove more than size()");
+    __size_ -= __n;
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    void swap(basic_string_view& __other) _NOEXCEPT
-    {
-        const value_type *__p = __data_;
-        __data_ = __other.__data_;
-        __other.__data_ = __p;
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI void swap(basic_string_view& __other) _NOEXCEPT {
+    const value_type* __p = __data_;
+    __data_               = __other.__data_;
+    __other.__data_       = __p;
 
-        size_type __sz = __size_;
-        __size_ = __other.__size_;
-        __other.__size_ = __sz;
-    }
+    size_type __sz  = __size_;
+    __size_         = __other.__size_;
+    __other.__size_ = __sz;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
-    {
-        if (__pos > size())
-            __throw_out_of_range("string_view::copy");
-        size_type __rlen = _VSTD::min(__n, size() - __pos);
-        _Traits::copy(__s, data() + __pos, __rlen);
-        return __rlen;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
+  copy(_CharT* __s, size_type __n, size_type __pos = 0) const {
+    if (__pos > size())
+      __throw_out_of_range("string_view::copy");
+    size_type __rlen = std::min(__n, size() - __pos);
+    _Traits::copy(__s, data() + __pos, __rlen);
+    return __rlen;
+  }
 
-    _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
-    basic_string_view substr(size_type __pos = 0, size_type __n = npos) const
-    {
-        return __pos > size()
-            ? (__throw_out_of_range("string_view::substr"), basic_string_view())
-            : basic_string_view(data() + __pos, _VSTD::min(__n, size() - __pos));
-    }
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view substr(size_type __pos = 0, size_type __n = npos) const {
+    return __pos > size() ? (__throw_out_of_range("string_view::substr"), basic_string_view())
+                          : basic_string_view(data() + __pos, std::min(__n, size() - __pos));
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 int compare(basic_string_view __sv) const _NOEXCEPT
-    {
-        size_type __rlen = _VSTD::min(size(), __sv.size());
-        int __retval = _Traits::compare(data(), __sv.data(), __rlen);
-        if (__retval == 0) // first __rlen chars matched
-            __retval = size() == __sv.size() ? 0 : (size() < __sv.size() ? -1 : 1);
-        return __retval;
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 int compare(basic_string_view __sv) const _NOEXCEPT {
+    size_type __rlen = std::min(size(), __sv.size());
+    int __retval     = _Traits::compare(data(), __sv.data(), __rlen);
+    if (__retval == 0) // first __rlen chars matched
+      __retval = size() == __sv.size() ? 0 : (size() < __sv.size() ? -1 : 1);
+    return __retval;
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    int compare(size_type __pos1, size_type __n1, basic_string_view __sv) const
-    {
-        return substr(__pos1, __n1).compare(__sv);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
+  compare(size_type __pos1, size_type __n1, basic_string_view __sv) const {
+    return substr(__pos1, __n1).compare(__sv);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    int compare(                       size_type __pos1, size_type __n1,
-                basic_string_view __sv, size_type __pos2, size_type __n2) const
-    {
-        return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
+  compare(size_type __pos1, size_type __n1, basic_string_view __sv, size_type __pos2, size_type __n2) const {
+    return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    int compare(const _CharT* __s) const _NOEXCEPT
-    {
-        return compare(basic_string_view(__s));
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int compare(const _CharT* __s) const _NOEXCEPT {
+    return compare(basic_string_view(__s));
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    int compare(size_type __pos1, size_type __n1, const _CharT* __s) const
-    {
-        return substr(__pos1, __n1).compare(basic_string_view(__s));
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
+  compare(size_type __pos1, size_type __n1, const _CharT* __s) const {
+    return substr(__pos1, __n1).compare(basic_string_view(__s));
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    int compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const
-    {
-        return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
+  compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const {
+    return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
+  }
 
-    // find
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
-        return std::__str_find<value_type, size_type, traits_type, npos>
-            (data(), size(), __s.data(), __pos, __s.size());
-    }
+  // find
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
+    return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s.data(), __pos, __s.size());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT
-    {
-        return std::__str_find<value_type, size_type, traits_type, npos>
-            (data(), size(), __c, __pos);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
+    return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
-        return std::__str_find<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, __n);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
+    return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s != nullptr, "string_view::find(): received nullptr");
-        return std::__str_find<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, traits_type::length(__s));
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find(): received nullptr");
+    return std::__str_find<value_type, size_type, traits_type, npos>(
+        data(), size(), __s, __pos, traits_type::length(__s));
+  }
 
-    // rfind
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
-        return std::__str_rfind<value_type, size_type, traits_type, npos>
-            (data(), size(), __s.data(), __pos, __s.size());
-    }
+  // rfind
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
+    return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s.data(), __pos, __s.size());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT
-    {
-        return std::__str_rfind<value_type, size_type, traits_type, npos>
-            (data(), size(), __c, __pos);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
+    return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
-        return std::__str_rfind<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, __n);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
+    return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type rfind(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s != nullptr, "string_view::rfind(): received nullptr");
-        return std::__str_rfind<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, traits_type::length(__s));
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  rfind(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::rfind(): received nullptr");
+    return std::__str_rfind<value_type, size_type, traits_type, npos>(
+        data(), size(), __s, __pos, traits_type::length(__s));
+  }
 
-    // find_first_of
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
-        return std::__str_find_first_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s.data(), __pos, __s.size());
-    }
+  // find_first_of
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
+    return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
+        data(), size(), __s.data(), __pos, __s.size());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT
-    { return find(__c, __pos); }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
+    return find(__c, __pos);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
-        return std::__str_find_first_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, __n);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
+    return std::__str_find_first_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_first_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_of(): received nullptr");
-        return std::__str_find_first_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, traits_type::length(__s));
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_first_of(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_first_of(): received nullptr");
+    return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
+        data(), size(), __s, __pos, traits_type::length(__s));
+  }
 
-    // find_last_of
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_last_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
-        return std::__str_find_last_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s.data(), __pos, __s.size());
-    }
+  // find_last_of
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_last_of(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
+    return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
+        data(), size(), __s.data(), __pos, __s.size());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT
-    { return rfind(__c, __pos); }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
+    return rfind(__c, __pos);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
-        return std::__str_find_last_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, __n);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
+    return std::__str_find_last_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_last_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_of(): received nullptr");
-        return std::__str_find_last_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, traits_type::length(__s));
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_last_of(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_last_of(): received nullptr");
+    return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
+        data(), size(), __s, __pos, traits_type::length(__s));
+  }
 
-    // find_first_not_of
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_first_not_of(basic_string_view __s, size_type __pos=0) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
-        return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s.data(), __pos, __s.size());
-    }
+  // find_first_not_of
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_first_not_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(
+        __s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
+    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
+        data(), size(), __s.data(), __pos, __s.size());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_first_not_of(_CharT __c, size_type __pos=0) const _NOEXCEPT
-    {
-        return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __c, __pos);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_first_not_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
+    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
-        return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, __n);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
+    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_first_not_of(const _CharT* __s, size_type __pos=0) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
-        return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, traits_type::length(__s));
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_first_not_of(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
+    return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
+        data(), size(), __s, __pos, traits_type::length(__s));
+  }
 
-    // find_last_not_of
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_last_not_of(basic_string_view __s, size_type __pos=npos) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
-        return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s.data(), __pos, __s.size());
-    }
+  // find_last_not_of
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_last_not_of(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(
+        __s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
+    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
+        data(), size(), __s.data(), __pos, __s.size());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_last_not_of(_CharT __c, size_type __pos=npos) const _NOEXCEPT
-    {
-        return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __c, __pos);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_last_not_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
+    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
-        return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, __n);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
+    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-    size_type find_last_not_of(const _CharT* __s, size_type __pos=npos) const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
-        return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>
-            (data(), size(), __s, __pos, traits_type::length(__s));
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find_last_not_of(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
+    _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
+    return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
+        data(), size(), __s, __pos, traits_type::length(__s));
+  }
 
 #if _LIBCPP_STD_VER >= 20
-    constexpr _LIBCPP_INLINE_VISIBILITY
-    bool starts_with(basic_string_view __s) const noexcept
-    { return size() >= __s.size() && compare(0, __s.size(), __s) == 0; }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(basic_string_view __s) const noexcept {
+    return size() >= __s.size() && compare(0, __s.size(), __s) == 0;
+  }
 
-    constexpr _LIBCPP_INLINE_VISIBILITY
-    bool starts_with(value_type __c) const noexcept
-    { return !empty() && _Traits::eq(front(), __c); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(value_type __c) const noexcept {
+    return !empty() && _Traits::eq(front(), __c);
+  }
 
-    constexpr _LIBCPP_INLINE_VISIBILITY
-    bool starts_with(const value_type* __s) const noexcept
-    { return starts_with(basic_string_view(__s)); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(const value_type* __s) const noexcept {
+    return starts_with(basic_string_view(__s));
+  }
 
-    constexpr _LIBCPP_INLINE_VISIBILITY
-    bool ends_with(basic_string_view __s) const noexcept
-    { return size() >= __s.size() && compare(size() - __s.size(), npos, __s) == 0; }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(basic_string_view __s) const noexcept {
+    return size() >= __s.size() && compare(size() - __s.size(), npos, __s) == 0;
+  }
 
-    constexpr _LIBCPP_INLINE_VISIBILITY
-    bool ends_with(value_type __c) const noexcept
-    { return !empty() && _Traits::eq(back(), __c); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(value_type __c) const noexcept {
+    return !empty() && _Traits::eq(back(), __c);
+  }
 
-    constexpr _LIBCPP_INLINE_VISIBILITY
-    bool ends_with(const value_type* __s) const noexcept
-    { return ends_with(basic_string_view(__s)); }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(const value_type* __s) const noexcept {
+    return ends_with(basic_string_view(__s));
+  }
 #endif
 
 #if _LIBCPP_STD_VER >= 23
-    constexpr _LIBCPP_INLINE_VISIBILITY
-    bool contains(basic_string_view __sv) const noexcept
-    { return find(__sv) != npos; }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(basic_string_view __sv) const noexcept { return find(__sv) != npos; }
 
-    constexpr _LIBCPP_INLINE_VISIBILITY
-    bool contains(value_type __c) const noexcept
-    { return find(__c) != npos; }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(value_type __c) const noexcept { return find(__c) != npos; }
 
-    constexpr _LIBCPP_INLINE_VISIBILITY
-    bool contains(const value_type* __s) const
-    { return find(__s) != npos; }
+  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(const value_type* __s) const { return find(__s) != npos; }
 #endif
 
 private:
-    const   value_type* __data_;
-    size_type           __size_;
+  const value_type* __data_;
+  size_type __size_;
 };
 _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(basic_string_view);
 
@@ -755,229 +691,194 @@ inline constexpr bool ranges::enable_borrowed_range<basic_string_view<_CharT, _T
 
 #if _LIBCPP_STD_VER >= 20
 template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
-  basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;
+basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;
 #endif // _LIBCPP_STD_VER >= 20
 
-
 #if _LIBCPP_STD_VER >= 23
 template <ranges::contiguous_range _Range>
-  basic_string_view(_Range) -> basic_string_view<ranges::range_value_t<_Range>>;
+basic_string_view(_Range) -> basic_string_view<ranges::range_value_t<_Range>>;
 #endif
 
 // [string.view.comparison]
-// operator ==
-template<class _CharT, class _Traits>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator==(basic_string_view<_CharT, _Traits> __lhs,
-                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    if (__lhs.size() != __rhs.size()) return false;
-    return __lhs.compare(__rhs) == 0;
-}
-
-// The dummy default template parameters are used to work around a MSVC issue with mangling, see VSO-409326 for details.
-// This applies to the other sufficient overloads below for the other comparison operators.
-template<class _CharT, class _Traits, int = 1>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator==(basic_string_view<_CharT, _Traits> __lhs,
-                __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT
-{
-    if (__lhs.size() != __rhs.size()) return false;
-    return __lhs.compare(__rhs) == 0;
-}
-
-#if _LIBCPP_STD_VER < 20
-// This overload is automatically generated in C++20.
-template<class _CharT, class _Traits, int = 2>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator==(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
-                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    if (__lhs.size() != __rhs.size()) return false;
-    return __lhs.compare(__rhs) == 0;
-}
-#endif // _LIBCPP_STD_VER >= 20
-
-// operator <=>
 
 #if _LIBCPP_STD_VER >= 20
 
 template <class _CharT, class _Traits>
-_LIBCPP_HIDE_FROM_ABI constexpr auto
-operator<=>(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) noexcept {
-    if constexpr (requires { typename _Traits::comparison_category; }) {
-        // [string.view]/4
-        static_assert(
-            __comparison_category<typename _Traits::comparison_category>,
-            "return type is not a comparison category type");
-        return static_cast<typename _Traits::comparison_category>(__lhs.compare(__rhs) <=> 0);
-    } else {
-        return static_cast<weak_ordering>(__lhs.compare(__rhs) <=> 0);
-    }
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(basic_string_view<_CharT, _Traits> __lhs,
+                                                type_identity_t<basic_string_view<_CharT, _Traits>> __rhs) noexcept {
+  if (__lhs.size() != __rhs.size())
+    return false;
+  return __lhs.compare(__rhs) == 0;
+}
+
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(basic_string_view<_CharT, _Traits> __lhs,
+                                                 type_identity_t<basic_string_view<_CharT, _Traits>> __rhs) noexcept {
+  if constexpr (requires { typename _Traits::comparison_category; }) {
+    // [string.view]/4
+    static_assert(
+        __comparison_category<typename _Traits::comparison_category>, "return type is not a comparison category type");
+    return static_cast<typename _Traits::comparison_category>(__lhs.compare(__rhs) <=> 0);
+  } else {
+    return static_cast<weak_ordering>(__lhs.compare(__rhs) <=> 0);
+  }
+}
+
+#else
+
+// operator ==
+
+template <class _CharT, class _Traits>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator==(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  if (__lhs.size() != __rhs.size())
+    return false;
+  return __lhs.compare(__rhs) == 0;
+}
+
+// The dummy default template parameters are used to work around a MSVC issue with mangling, see VSO-409326 for details.
+// This applies to the other sufficient overloads below for the other comparison operators.
+template <class _CharT, class _Traits, int = 1>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator==(basic_string_view<_CharT, _Traits> __lhs,
+           __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
+  if (__lhs.size() != __rhs.size())
+    return false;
+  return __lhs.compare(__rhs) == 0;
+}
+
+template <class _CharT, class _Traits, int = 2>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator==(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
+           basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  if (__lhs.size() != __rhs.size())
+    return false;
+  return __lhs.compare(__rhs) == 0;
+}
+
+// operator !=
+template <class _CharT, class _Traits>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  if (__lhs.size() != __rhs.size())
+    return true;
+  return __lhs.compare(__rhs) != 0;
 }
 
 template <class _CharT, class _Traits, int = 1>
-_LIBCPP_HIDE_FROM_ABI constexpr auto operator<=>(
-    basic_string_view<_CharT, _Traits> __lhs, type_identity_t<basic_string_view<_CharT, _Traits>> __rhs) noexcept {
-    if constexpr (requires { typename _Traits::comparison_category; }) {
-        // [string.view]/4
-        static_assert(
-            __comparison_category<typename _Traits::comparison_category>,
-            "return type is not a comparison category type");
-        return static_cast<typename _Traits::comparison_category>(__lhs.compare(__rhs) <=> 0);
-    } else {
-        return static_cast<weak_ordering>(__lhs.compare(__rhs) <=> 0);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator!=(basic_string_view<_CharT, _Traits> __lhs,
+           __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
+  if (__lhs.size() != __rhs.size())
+    return true;
+  return __lhs.compare(__rhs) != 0;
 }
 
-#else //  _LIBCPP_STD_VER >= 20
-
-// operator !=
-template<class _CharT, class _Traits>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator!=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    if (__lhs.size() != __rhs.size())
-        return true;
-    return __lhs.compare(__rhs) != 0;
+template <class _CharT, class _Traits, int = 2>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator!=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
+           basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  if (__lhs.size() != __rhs.size())
+    return true;
+  return __lhs.compare(__rhs) != 0;
 }
 
-template<class _CharT, class _Traits, int = 1>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator!=(basic_string_view<_CharT, _Traits> __lhs,
-                __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT
-{
-    if (__lhs.size() != __rhs.size())
-        return true;
-    return __lhs.compare(__rhs) != 0;
-}
-
-template<class _CharT, class _Traits, int = 2>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator!=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
-                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    if (__lhs.size() != __rhs.size())
-        return true;
-    return __lhs.compare(__rhs) != 0;
-}
-
-
 // operator <
-template<class _CharT, class _Traits>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator<(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) < 0;
+template <class _CharT, class _Traits>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator<(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) < 0;
 }
 
-template<class _CharT, class _Traits, int = 1>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator<(basic_string_view<_CharT, _Traits> __lhs,
-                __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) < 0;
+template <class _CharT, class _Traits, int = 1>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator<(basic_string_view<_CharT, _Traits> __lhs,
+          __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) < 0;
 }
 
-template<class _CharT, class _Traits, int = 2>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator<(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
-                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) < 0;
+template <class _CharT, class _Traits, int = 2>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator<(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
+          basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) < 0;
 }
 
-
 // operator >
-template<class _CharT, class _Traits>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator> (basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) > 0;
+template <class _CharT, class _Traits>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator>(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) > 0;
 }
 
-template<class _CharT, class _Traits, int = 1>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator>(basic_string_view<_CharT, _Traits> __lhs,
-                __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) > 0;
+template <class _CharT, class _Traits, int = 1>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator>(basic_string_view<_CharT, _Traits> __lhs,
+          __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) > 0;
 }
 
-template<class _CharT, class _Traits, int = 2>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator>(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
-                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) > 0;
+template <class _CharT, class _Traits, int = 2>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator>(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
+          basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) > 0;
 }
 
-
 // operator <=
-template<class _CharT, class _Traits>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator<=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) <= 0;
+template <class _CharT, class _Traits>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator<=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) <= 0;
 }
 
-template<class _CharT, class _Traits, int = 1>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator<=(basic_string_view<_CharT, _Traits> __lhs,
-                __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) <= 0;
+template <class _CharT, class _Traits, int = 1>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator<=(basic_string_view<_CharT, _Traits> __lhs,
+           __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) <= 0;
 }
 
-template<class _CharT, class _Traits, int = 2>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator<=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
-                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) <= 0;
+template <class _CharT, class _Traits, int = 2>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator<=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
+           basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) <= 0;
 }
 
-
 // operator >=
-template<class _CharT, class _Traits>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator>=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) >= 0;
+template <class _CharT, class _Traits>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator>=(basic_string_view<_CharT, _Traits> __lhs, basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) >= 0;
 }
 
-
-template<class _CharT, class _Traits, int = 1>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator>=(basic_string_view<_CharT, _Traits> __lhs,
-                __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) >= 0;
+template <class _CharT, class _Traits, int = 1>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator>=(basic_string_view<_CharT, _Traits> __lhs,
+           __type_identity_t<basic_string_view<_CharT, _Traits> > __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) >= 0;
 }
 
-template<class _CharT, class _Traits, int = 2>
-_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_INLINE_VISIBILITY
-bool operator>=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
-                basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
-{
-    return __lhs.compare(__rhs) >= 0;
+template <class _CharT, class _Traits, int = 2>
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI bool
+operator>=(__type_identity_t<basic_string_view<_CharT, _Traits> > __lhs,
+           basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT {
+  return __lhs.compare(__rhs) >= 0;
 }
 
 #endif //  _LIBCPP_STD_VER >= 20
 
-template<class _CharT, class _Traits>
+template <class _CharT, class _Traits>
 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os,
-           basic_string_view<_CharT, _Traits> __str);
+operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Traits> __str);
 
 // [string.view.hash]
-template<class _CharT>
-struct __string_view_hash : public __unary_function<basic_string_view<_CharT, char_traits<_CharT> >, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const basic_string_view<_CharT, char_traits<_CharT> > __val) const _NOEXCEPT {
-        return std::__do_string_hash(__val.data(), __val.data() + __val.size());
-    }
+template <class _CharT>
+struct __string_view_hash : public __unary_function<basic_string_view<_CharT, char_traits<_CharT> >, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const basic_string_view<_CharT, char_traits<_CharT> > __val) const _NOEXCEPT {
+    return std::__do_string_hash(__val.data(), __val.data() + __val.size());
+  }
 };
 
 template <>
@@ -1000,44 +901,36 @@ struct hash<basic_string_view<wchar_t, char_traits<wchar_t> > > : __string_view_
 #endif
 
 #if _LIBCPP_STD_VER >= 14
-inline namespace literals
-{
-  inline namespace string_view_literals
-  {
-    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    basic_string_view<char> operator "" sv(const char *__str, size_t __len) _NOEXCEPT
-    {
-        return basic_string_view<char> (__str, __len);
-    }
+inline namespace literals {
+inline namespace string_view_literals {
+inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char> operator""sv(const char* __str, size_t __len) noexcept {
+  return basic_string_view<char>(__str, __len);
+}
 
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    basic_string_view<wchar_t> operator "" sv(const wchar_t *__str, size_t __len) _NOEXCEPT
-    {
-        return basic_string_view<wchar_t> (__str, __len);
-    }
-#endif
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<wchar_t>
+operator""sv(const wchar_t* __str, size_t __len) noexcept {
+  return basic_string_view<wchar_t>(__str, __len);
+}
+#  endif
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    basic_string_view<char8_t> operator "" sv(const char8_t *__str, size_t __len) _NOEXCEPT
-    {
-        return basic_string_view<char8_t> (__str, __len);
-    }
-#endif
+#  ifndef _LIBCPP_HAS_NO_CHAR8_T
+inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char8_t>
+operator""sv(const char8_t* __str, size_t __len) noexcept {
+  return basic_string_view<char8_t>(__str, __len);
+}
+#  endif
 
-    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    basic_string_view<char16_t> operator "" sv(const char16_t *__str, size_t __len) _NOEXCEPT
-    {
-        return basic_string_view<char16_t> (__str, __len);
-    }
+inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char16_t>
+operator""sv(const char16_t* __str, size_t __len) noexcept {
+  return basic_string_view<char16_t>(__str, __len);
+}
 
-    inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    basic_string_view<char32_t> operator "" sv(const char32_t *__str, size_t __len) _NOEXCEPT
-    {
-        return basic_string_view<char32_t> (__str, __len);
-    }
-  } // namespace string_view_literals
+inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char32_t>
+operator""sv(const char32_t* __str, size_t __len) noexcept {
+  return basic_string_view<char32_t>(__str, __len);
+}
+} // namespace string_view_literals
 } // namespace literals
 #endif
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/strstream b/third_party/libcxx/strstream
index 594353bac..9ff4024a7 100644
--- a/third_party/libcxx/strstream
+++ b/third_party/libcxx/strstream
@@ -13,7 +13,7 @@
 /*
     strstream synopsis
 
-class strstreambuf
+class strstreambuf                                    // Removed in C++26
     : public basic_streambuf<char>
 {
 public:
@@ -63,7 +63,7 @@ private:
     void (*pfree)(void*);               // exposition only
 };
 
-class istrstream
+class istrstream                                      // Removed in C++26
     : public basic_istream<char>
 {
 public:
@@ -81,7 +81,7 @@ private:
     strstreambuf sb; // exposition only
 };
 
-class ostrstream
+class ostrstream                                      // Removed in C++26
     : public basic_ostream<char>
 {
 public:
@@ -99,7 +99,7 @@ private:
     strstreambuf sb; // exposition only
 };
 
-class strstream
+class strstream                                       // Removed in C++26
     : public basic_iostream<char>
 {
 public:
@@ -129,7 +129,6 @@ private:
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <istream>
 #include <ostream>
@@ -139,271 +138,214 @@ private:
 #  pragma GCC system_header
 #endif
 
+#if _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) || defined(_LIBCPP_BUILDING_LIBRARY)
+
+_LIBCPP_PUSH_MACROS
+#  include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_DEPRECATED _LIBCPP_TYPE_VIS strstreambuf
-    : public streambuf
-{
+class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstreambuf : public streambuf {
 public:
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI strstreambuf() : strstreambuf(0) {}
-    explicit strstreambuf(streamsize __alsize);
-#else
-    explicit strstreambuf(streamsize __alsize = 0);
-#endif
-    strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
-    strstreambuf(char* __gnext, streamsize __n, char* __pbeg = nullptr);
-    strstreambuf(const char* __gnext, streamsize __n);
+#  ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI strstreambuf() : strstreambuf(0) {}
+  explicit strstreambuf(streamsize __alsize);
+#  else
+  explicit strstreambuf(streamsize __alsize = 0);
+#  endif
+  strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*));
+  strstreambuf(char* __gnext, streamsize __n, char* __pbeg = nullptr);
+  strstreambuf(const char* __gnext, streamsize __n);
 
-    strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = nullptr);
-    strstreambuf(const signed char* __gnext, streamsize __n);
-    strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = nullptr);
-    strstreambuf(const unsigned char* __gnext, streamsize __n);
+  strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg = nullptr);
+  strstreambuf(const signed char* __gnext, streamsize __n);
+  strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg = nullptr);
+  strstreambuf(const unsigned char* __gnext, streamsize __n);
 
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    strstreambuf(strstreambuf&& __rhs);
-    _LIBCPP_INLINE_VISIBILITY
-    strstreambuf& operator=(strstreambuf&& __rhs);
-#endif // _LIBCPP_CXX03_LANG
+#  ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI strstreambuf(strstreambuf&& __rhs);
+  _LIBCPP_HIDE_FROM_ABI strstreambuf& operator=(strstreambuf&& __rhs);
+#  endif // _LIBCPP_CXX03_LANG
 
-    ~strstreambuf() override;
+  ~strstreambuf() override;
 
-    void swap(strstreambuf& __rhs);
+  void swap(strstreambuf& __rhs);
 
-    void freeze(bool __freezefl = true);
-    char* str();
-    int pcount() const;
+  void freeze(bool __freezefl = true);
+  char* str();
+  int pcount() const;
 
 protected:
-    int_type overflow (int_type __c = EOF) override;
-    int_type pbackfail(int_type __c = EOF) override;
-    int_type underflow() override;
-    pos_type seekoff(off_type __off, ios_base::seekdir __way,
-                     ios_base::openmode __which = ios_base::in | ios_base::out) override;
-    pos_type seekpos(pos_type __sp,
-                     ios_base::openmode __which = ios_base::in | ios_base::out) override;
+  int_type overflow(int_type __c = EOF) override;
+  int_type pbackfail(int_type __c = EOF) override;
+  int_type underflow() override;
+  pos_type
+  seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) override;
+  pos_type seekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) override;
 
 private:
-    typedef unsigned __mode_type;
-    static const __mode_type __allocated = 0x01;
-    static const __mode_type __constant  = 0x02;
-    static const __mode_type __dynamic   = 0x04;
-    static const __mode_type __frozen    = 0x08;
-    static const streamsize    __default_alsize = 4096;
+  typedef unsigned __mode_type;
+  static const __mode_type __allocated     = 0x01;
+  static const __mode_type __constant      = 0x02;
+  static const __mode_type __dynamic       = 0x04;
+  static const __mode_type __frozen        = 0x08;
+  static const streamsize __default_alsize = 4096;
 
-    __mode_type __strmode_;
-    streamsize __alsize_;
-    void* (*__palloc_)(size_t);
-    void (*__pfree_)(void*);
+  __mode_type __strmode_;
+  streamsize __alsize_;
+  void* (*__palloc_)(size_t);
+  void (*__pfree_)(void*);
 
-    void __init(char* __gnext, streamsize __n, char* __pbeg);
+  void __init(char* __gnext, streamsize __n, char* __pbeg);
 };
 
-#ifndef _LIBCPP_CXX03_LANG
+#  ifndef _LIBCPP_CXX03_LANG
 
-inline _LIBCPP_INLINE_VISIBILITY
-strstreambuf::strstreambuf(strstreambuf&& __rhs)
+inline _LIBCPP_HIDE_FROM_ABI strstreambuf::strstreambuf(strstreambuf&& __rhs)
     : streambuf(__rhs),
       __strmode_(__rhs.__strmode_),
       __alsize_(__rhs.__alsize_),
       __palloc_(__rhs.__palloc_),
-      __pfree_(__rhs.__pfree_)
-{
-    __rhs.setg(nullptr, nullptr, nullptr);
-    __rhs.setp(nullptr, nullptr);
+      __pfree_(__rhs.__pfree_) {
+  __rhs.setg(nullptr, nullptr, nullptr);
+  __rhs.setp(nullptr, nullptr);
 }
 
-inline _LIBCPP_INLINE_VISIBILITY
-strstreambuf&
-strstreambuf::operator=(strstreambuf&& __rhs)
-{
-    if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
-    {
-        if (__pfree_)
-            __pfree_(eback());
-        else
-            delete [] eback();
-    }
-    streambuf::operator=(__rhs);
-    __strmode_ = __rhs.__strmode_;
-    __alsize_ = __rhs.__alsize_;
-    __palloc_ = __rhs.__palloc_;
-    __pfree_ = __rhs.__pfree_;
-    __rhs.setg(nullptr, nullptr, nullptr);
-    __rhs.setp(nullptr, nullptr);
+inline _LIBCPP_HIDE_FROM_ABI strstreambuf& strstreambuf::operator=(strstreambuf&& __rhs) {
+  if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) {
+    if (__pfree_)
+      __pfree_(eback());
+    else
+      delete[] eback();
+  }
+  streambuf::operator=(__rhs);
+  __strmode_ = __rhs.__strmode_;
+  __alsize_  = __rhs.__alsize_;
+  __palloc_  = __rhs.__palloc_;
+  __pfree_   = __rhs.__pfree_;
+  __rhs.setg(nullptr, nullptr, nullptr);
+  __rhs.setp(nullptr, nullptr);
+  return *this;
+}
+
+#  endif // _LIBCPP_CXX03_LANG
+
+class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI istrstream : public istream {
+public:
+  _LIBCPP_HIDE_FROM_ABI explicit istrstream(const char* __s) : istream(&__sb_), __sb_(__s, 0) {}
+  _LIBCPP_HIDE_FROM_ABI explicit istrstream(char* __s) : istream(&__sb_), __sb_(__s, 0) {}
+  _LIBCPP_HIDE_FROM_ABI istrstream(const char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}
+  _LIBCPP_HIDE_FROM_ABI istrstream(char* __s, streamsize __n) : istream(&__sb_), __sb_(__s, __n) {}
+
+#  ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI istrstream(istrstream&& __rhs) // extension
+      : istream(std::move(static_cast<istream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
+    istream::set_rdbuf(&__sb_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI istrstream& operator=(istrstream&& __rhs) {
+    __sb_ = std::move(__rhs.__sb_);
+    istream::operator=(std::move(__rhs));
     return *this;
-}
+  }
+#  endif // _LIBCPP_CXX03_LANG
 
-#endif // _LIBCPP_CXX03_LANG
+  ~istrstream() override;
 
-class _LIBCPP_DEPRECATED _LIBCPP_TYPE_VIS istrstream
-    : public istream
-{
-public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit istrstream(const char* __s)
-        : istream(&__sb_), __sb_(__s, 0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    explicit istrstream(char* __s)
-        : istream(&__sb_), __sb_(__s, 0) {}
-    _LIBCPP_INLINE_VISIBILITY
-    istrstream(const char* __s, streamsize __n)
-        : istream(&__sb_), __sb_(__s, __n) {}
-    _LIBCPP_INLINE_VISIBILITY
-    istrstream(char* __s, streamsize __n)
-        : istream(&__sb_), __sb_(__s, __n) {}
+  _LIBCPP_HIDE_FROM_ABI void swap(istrstream& __rhs) {
+    istream::swap(__rhs);
+    __sb_.swap(__rhs.__sb_);
+  }
 
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    istrstream(istrstream&& __rhs)  // extension
-        : istream(_VSTD::move(static_cast<istream&>(__rhs))),
-          __sb_(_VSTD::move(__rhs.__sb_))
-    {
-        istream::set_rdbuf(&__sb_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    istrstream& operator=(istrstream&& __rhs)
-    {
-        __sb_ = _VSTD::move(__rhs.__sb_);
-        istream::operator=(_VSTD::move(__rhs));
-        return *this;
-    }
-#endif // _LIBCPP_CXX03_LANG
-
-    ~istrstream() override;
-
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(istrstream& __rhs)
-    {
-        istream::swap(__rhs);
-        __sb_.swap(__rhs.__sb_);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
-    _LIBCPP_INLINE_VISIBILITY
-    char *str() {return __sb_.str();}
+  _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
+  _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
 
 private:
-    strstreambuf __sb_;
+  strstreambuf __sb_;
 };
 
-class _LIBCPP_DEPRECATED _LIBCPP_TYPE_VIS ostrstream
-    : public ostream
-{
+class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI ostrstream : public ostream {
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    ostrstream()
-        : ostream(&__sb_) {}
-    _LIBCPP_INLINE_VISIBILITY
-    ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
-        : ostream(&__sb_),
-          __sb_(__s, __n, __s + (__mode & ios::app ? _VSTD::strlen(__s) : 0))
-        {}
+  _LIBCPP_HIDE_FROM_ABI ostrstream() : ostream(&__sb_) {}
+  _LIBCPP_HIDE_FROM_ABI ostrstream(char* __s, int __n, ios_base::openmode __mode = ios_base::out)
+      : ostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}
 
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    ostrstream(ostrstream&& __rhs)  // extension
-        : ostream(_VSTD::move(static_cast<ostream&>(__rhs))),
-          __sb_(_VSTD::move(__rhs.__sb_))
-    {
-        ostream::set_rdbuf(&__sb_);
-    }
+#  ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI ostrstream(ostrstream&& __rhs) // extension
+      : ostream(std::move(static_cast<ostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
+    ostream::set_rdbuf(&__sb_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    ostrstream& operator=(ostrstream&& __rhs)
-    {
-        __sb_ = _VSTD::move(__rhs.__sb_);
-        ostream::operator=(_VSTD::move(__rhs));
-        return *this;
-    }
-#endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI ostrstream& operator=(ostrstream&& __rhs) {
+    __sb_ = std::move(__rhs.__sb_);
+    ostream::operator=(std::move(__rhs));
+    return *this;
+  }
+#  endif // _LIBCPP_CXX03_LANG
 
-    ~ostrstream() override;
+  ~ostrstream() override;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(ostrstream& __rhs)
-    {
-        ostream::swap(__rhs);
-        __sb_.swap(__rhs.__sb_);
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(ostrstream& __rhs) {
+    ostream::swap(__rhs);
+    __sb_.swap(__rhs.__sb_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
-    _LIBCPP_INLINE_VISIBILITY
-    void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
-    _LIBCPP_INLINE_VISIBILITY
-    char* str()         {return __sb_.str();}
-    _LIBCPP_INLINE_VISIBILITY
-    int pcount() const  {return __sb_.pcount();}
+  _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
+  _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
+  _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
+  _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
 
 private:
-    strstreambuf __sb_; // exposition only
+  strstreambuf __sb_; // exposition only
 };
 
-class _LIBCPP_DEPRECATED _LIBCPP_TYPE_VIS strstream
-    : public iostream
-{
+class _LIBCPP_DEPRECATED _LIBCPP_EXPORTED_FROM_ABI strstream : public iostream {
 public:
-    // Types
-    typedef char                        char_type;
-    typedef char_traits<char>::int_type int_type;
-    typedef char_traits<char>::pos_type pos_type;
-    typedef char_traits<char>::off_type off_type;
+  // Types
+  typedef char char_type;
+  typedef char_traits<char>::int_type int_type;
+  typedef char_traits<char>::pos_type pos_type;
+  typedef char_traits<char>::off_type off_type;
 
-    // constructors/destructor
-    _LIBCPP_INLINE_VISIBILITY
-    strstream()
-        : iostream(&__sb_) {}
-    _LIBCPP_INLINE_VISIBILITY
-    strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
-        : iostream(&__sb_),
-          __sb_(__s, __n, __s + (__mode & ios::app ? _VSTD::strlen(__s) : 0))
-        {}
+  // constructors/destructor
+  _LIBCPP_HIDE_FROM_ABI strstream() : iostream(&__sb_) {}
+  _LIBCPP_HIDE_FROM_ABI strstream(char* __s, int __n, ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : iostream(&__sb_), __sb_(__s, __n, __s + (__mode & ios::app ? std::strlen(__s) : 0)) {}
 
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    strstream(strstream&& __rhs)  // extension
-        : iostream(_VSTD::move(static_cast<iostream&>(__rhs))),
-          __sb_(_VSTD::move(__rhs.__sb_))
-    {
-        iostream::set_rdbuf(&__sb_);
-    }
+#  ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI strstream(strstream&& __rhs) // extension
+      : iostream(std::move(static_cast<iostream&>(__rhs))), __sb_(std::move(__rhs.__sb_)) {
+    iostream::set_rdbuf(&__sb_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    strstream& operator=(strstream&& __rhs)
-    {
-        __sb_ = _VSTD::move(__rhs.__sb_);
-        iostream::operator=(_VSTD::move(__rhs));
-        return *this;
-    }
-#endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI strstream& operator=(strstream&& __rhs) {
+    __sb_ = std::move(__rhs.__sb_);
+    iostream::operator=(std::move(__rhs));
+    return *this;
+  }
+#  endif // _LIBCPP_CXX03_LANG
 
-    ~strstream() override;
+  ~strstream() override;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(strstream& __rhs)
-    {
-        iostream::swap(__rhs);
-        __sb_.swap(__rhs.__sb_);
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(strstream& __rhs) {
+    iostream::swap(__rhs);
+    __sb_.swap(__rhs.__sb_);
+  }
 
-    // Members:
-    _LIBCPP_INLINE_VISIBILITY
-    strstreambuf* rdbuf() const {return const_cast<strstreambuf*>(&__sb_);}
-    _LIBCPP_INLINE_VISIBILITY
-    void freeze(bool __freezefl = true) {__sb_.freeze(__freezefl);}
-    _LIBCPP_INLINE_VISIBILITY
-    int pcount() const {return __sb_.pcount();}
-    _LIBCPP_INLINE_VISIBILITY
-    char* str()        {return __sb_.str();}
+  // Members:
+  _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
+  _LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
+  _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
+  _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
 
 private:
-    strstreambuf __sb_; // exposition only
+  strstreambuf __sb_; // exposition only
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_STD_VER < 26 || defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRSTREAM) || defined(_LIBCPP_BUILDING_LIBRARY)
+
 #endif // _LIBCPP_STRSTREAM
diff --git a/third_party/libcxx/strstream.cpp b/third_party/libcxx/strstream.cpp
new file mode 100644
index 000000000..70374191c
--- /dev/null
+++ b/third_party/libcxx/strstream.cpp
@@ -0,0 +1,258 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__assert>
+#include <__utility/unreachable.h>
+#include <algorithm>
+#include <climits>
+#include <cstdlib>
+#include <cstring>
+#include <strstream>
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+strstreambuf::strstreambuf(streamsize __alsize)
+    : __strmode_(__dynamic), __alsize_(__alsize), __palloc_(nullptr), __pfree_(nullptr) {}
+
+strstreambuf::strstreambuf(void* (*__palloc)(size_t), void (*__pfree)(void*))
+    : __strmode_(__dynamic), __alsize_(__default_alsize), __palloc_(__palloc), __pfree_(__pfree) {}
+
+void strstreambuf::__init(char* __gnext, streamsize __n, char* __pbeg) {
+  if (__n == 0)
+    __n = static_cast<streamsize>(strlen(__gnext));
+  else if (__n < 0)
+    __n = INT_MAX;
+  if (__pbeg == nullptr)
+    setg(__gnext, __gnext, __gnext + __n);
+  else {
+    setg(__gnext, __gnext, __pbeg);
+    setp(__pbeg, __pbeg + __n);
+  }
+}
+
+strstreambuf::strstreambuf(char* __gnext, streamsize __n, char* __pbeg)
+    : __strmode_(), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
+  __init(__gnext, __n, __pbeg);
+}
+
+strstreambuf::strstreambuf(const char* __gnext, streamsize __n)
+    : __strmode_(__constant), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
+  __init(const_cast<char*>(__gnext), __n, nullptr);
+}
+
+strstreambuf::strstreambuf(signed char* __gnext, streamsize __n, signed char* __pbeg)
+    : __strmode_(), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
+  __init(const_cast<char*>(reinterpret_cast<const char*>(__gnext)), __n, reinterpret_cast<char*>(__pbeg));
+}
+
+strstreambuf::strstreambuf(const signed char* __gnext, streamsize __n)
+    : __strmode_(__constant), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
+  __init(const_cast<char*>(reinterpret_cast<const char*>(__gnext)), __n, nullptr);
+}
+
+strstreambuf::strstreambuf(unsigned char* __gnext, streamsize __n, unsigned char* __pbeg)
+    : __strmode_(), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
+  __init(const_cast<char*>(reinterpret_cast<const char*>(__gnext)), __n, reinterpret_cast<char*>(__pbeg));
+}
+
+strstreambuf::strstreambuf(const unsigned char* __gnext, streamsize __n)
+    : __strmode_(__constant), __alsize_(__default_alsize), __palloc_(nullptr), __pfree_(nullptr) {
+  __init(const_cast<char*>(reinterpret_cast<const char*>(__gnext)), __n, nullptr);
+}
+
+strstreambuf::~strstreambuf() {
+  if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0) {
+    if (__pfree_)
+      __pfree_(eback());
+    else
+      delete[] eback();
+  }
+}
+
+void strstreambuf::swap(strstreambuf& __rhs) {
+  streambuf::swap(__rhs);
+  std::swap(__strmode_, __rhs.__strmode_);
+  std::swap(__alsize_, __rhs.__alsize_);
+  std::swap(__palloc_, __rhs.__palloc_);
+  std::swap(__pfree_, __rhs.__pfree_);
+}
+
+void strstreambuf::freeze(bool __freezefl) {
+  if (__strmode_ & __dynamic) {
+    if (__freezefl)
+      __strmode_ |= __frozen;
+    else
+      __strmode_ &= ~__frozen;
+  }
+}
+
+char* strstreambuf::str() {
+  if (__strmode_ & __dynamic)
+    __strmode_ |= __frozen;
+  return eback();
+}
+
+int strstreambuf::pcount() const { return static_cast<int>(pptr() - pbase()); }
+
+strstreambuf::int_type strstreambuf::overflow(int_type __c) {
+  if (__c == EOF)
+    return int_type(0);
+  if (pptr() == epptr()) {
+    if ((__strmode_ & __dynamic) == 0 || (__strmode_ & __frozen) != 0)
+      return int_type(EOF);
+    size_t old_size = static_cast<size_t>((epptr() ? epptr() : egptr()) - eback());
+    size_t new_size = max<size_t>(static_cast<size_t>(__alsize_), 2 * old_size);
+    if (new_size == 0)
+      new_size = __default_alsize;
+    char* buf = nullptr;
+    if (__palloc_)
+      buf = static_cast<char*>(__palloc_(new_size));
+    else
+      buf = new char[new_size];
+    if (buf == nullptr)
+      return int_type(EOF);
+    if (old_size != 0) {
+      _LIBCPP_ASSERT_INTERNAL(eback(), "strstreambuf::overflow reallocating but the get area is a null pointer");
+      memcpy(buf, eback(), static_cast<size_t>(old_size));
+    }
+    ptrdiff_t ninp = gptr() - eback();
+    ptrdiff_t einp = egptr() - eback();
+    ptrdiff_t nout = pptr() - pbase();
+    if (__strmode_ & __allocated) {
+      if (__pfree_)
+        __pfree_(eback());
+      else
+        delete[] eback();
+    }
+    setg(buf, buf + ninp, buf + einp);
+    setp(buf + einp, buf + new_size);
+    __pbump(nout);
+    __strmode_ |= __allocated;
+  }
+  *pptr() = static_cast<char>(__c);
+  pbump(1);
+  return int_type(static_cast<unsigned char>(__c));
+}
+
+strstreambuf::int_type strstreambuf::pbackfail(int_type __c) {
+  if (eback() == gptr())
+    return EOF;
+  if (__c == EOF) {
+    gbump(-1);
+    return int_type(0);
+  }
+  if (__strmode_ & __constant) {
+    if (gptr()[-1] == static_cast<char>(__c)) {
+      gbump(-1);
+      return __c;
+    }
+    return EOF;
+  }
+  gbump(-1);
+  *gptr() = static_cast<char>(__c);
+  return __c;
+}
+
+strstreambuf::int_type strstreambuf::underflow() {
+  if (gptr() == egptr()) {
+    if (egptr() >= pptr())
+      return EOF;
+    setg(eback(), gptr(), pptr());
+  }
+  return int_type(static_cast<unsigned char>(*gptr()));
+}
+
+strstreambuf::pos_type strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which) {
+  bool pos_in  = (__which & ios::in) != 0;
+  bool pos_out = (__which & ios::out) != 0;
+  switch (__way) {
+  case ios::beg:
+  case ios::end:
+    if (!pos_in && !pos_out)
+      return pos_type(off_type(-1));
+    break;
+  case ios::cur:
+    if (pos_in == pos_out)
+      return pos_type(off_type(-1));
+    break;
+  }
+
+  if (pos_in && gptr() == nullptr)
+    return pos_type(off_type(-1));
+  if (pos_out && pptr() == nullptr)
+    return pos_type(off_type(-1));
+
+  off_type newoff;
+  char* seekhigh = epptr() ? epptr() : egptr();
+  switch (__way) {
+  case ios::beg:
+    newoff = 0;
+    break;
+  case ios::cur:
+    newoff = (pos_in ? gptr() : pptr()) - eback();
+    break;
+  case ios::end:
+    newoff = seekhigh - eback();
+    break;
+  default:
+    __libcpp_unreachable();
+  }
+  newoff += __off;
+  if (newoff < 0 || newoff > seekhigh - eback())
+    return pos_type(off_type(-1));
+
+  char* newpos = eback() + newoff;
+  if (pos_in)
+    setg(eback(), newpos, std::max(newpos, egptr()));
+  if (pos_out) {
+    // min(pbase, newpos), newpos, epptr()
+    __off = epptr() - newpos;
+    setp(min(pbase(), newpos), epptr());
+    __pbump((epptr() - pbase()) - __off);
+  }
+  return pos_type(newoff);
+}
+
+strstreambuf::pos_type strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which) {
+  bool pos_in  = (__which & ios::in) != 0;
+  bool pos_out = (__which & ios::out) != 0;
+  if (!pos_in && !pos_out)
+    return pos_type(off_type(-1));
+
+  if ((pos_in && gptr() == nullptr) || (pos_out && pptr() == nullptr))
+    return pos_type(off_type(-1));
+
+  off_type newoff = __sp;
+  char* seekhigh  = epptr() ? epptr() : egptr();
+  if (newoff < 0 || newoff > seekhigh - eback())
+    return pos_type(off_type(-1));
+
+  char* newpos = eback() + newoff;
+  if (pos_in)
+    setg(eback(), newpos, std::max(newpos, egptr()));
+  if (pos_out) {
+    // min(pbase, newpos), newpos, epptr()
+    off_type temp = epptr() - newpos;
+    setp(min(pbase(), newpos), epptr());
+    __pbump((epptr() - pbase()) - temp);
+  }
+  return pos_type(newoff);
+}
+
+istrstream::~istrstream() {}
+
+ostrstream::~ostrstream() {}
+
+strstream::~strstream() {}
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
diff --git a/third_party/libcxx/syncstream b/third_party/libcxx/syncstream
new file mode 100644
index 000000000..e6f35b6f4
--- /dev/null
+++ b/third_party/libcxx/syncstream
@@ -0,0 +1,512 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_SYNCSTREAM
+#define _LIBCPP_SYNCSTREAM
+
+/*
+    syncstream synopsis
+
+#include <ostream>  // see [ostream.syn]
+
+namespace std {
+    template<class charT, class traits, class Allocator>
+    class basic_syncbuf;
+
+    // [syncstream.syncbuf.special], specialized algorithms
+    template<class charT, class traits, class Allocator>
+      void swap(basic_syncbuf<charT, traits, Allocator>&,
+                basic_syncbuf<charT, traits, Allocator>&);
+
+    using syncbuf = basic_syncbuf<char>;
+    using wsyncbuf = basic_syncbuf<wchar_t>;
+
+    template<class charT, class traits, class Allocator>
+    class basic_osyncstream;
+
+    using osyncstream = basic_osyncstream<char>;
+    using wosyncstream = basic_osyncstream<wchar_t>;
+
+    template<class charT, class traits, class Allocator>
+    class basic_syncbuf : public basic_streambuf<charT, traits> {
+    public:
+        using char_type      = charT;
+        using int_type       = typename traits::int_type;
+        using pos_type       = typename traits::pos_type;
+        using off_type       = typename traits::off_type;
+        using traits_type    = traits;
+        using allocator_type = Allocator;
+
+        using streambuf_type = basic_streambuf<charT, traits>;
+
+        // [syncstream.syncbuf.cons], construction and destruction
+        explicit basic_syncbuf(streambuf_type* obuf = nullptr)
+          : basic_syncbuf(obuf, Allocator()) {}
+        basic_syncbuf(streambuf_type*, const Allocator&);
+        basic_syncbuf(basic_syncbuf&&);
+        ~basic_syncbuf();
+
+        // [syncstream.syncbuf.assign], assignment and swap
+        basic_syncbuf& operator=(basic_syncbuf&&);
+        void swap(basic_syncbuf&);
+
+        // [syncstream.syncbuf.members], member functions
+        bool emit();
+        streambuf_type* get_wrapped() const noexcept;
+        allocator_type get_allocator() const noexcept;
+        void set_emit_on_sync(bool) noexcept;
+
+    protected:
+        // [syncstream.syncbuf.virtuals], overridden virtual functions
+        int sync() override;
+
+    private:
+        streambuf_type* wrapped;    // exposition only
+        bool emit_on_sync{};        // exposition only
+    };
+
+    // [syncstream.syncbuf.special], specialized algorithms
+    template<class charT, class traits, class Allocator>
+    void swap(basic_syncbuf<charT, traits, Allocator>&,
+              basic_syncbuf<charT, traits, Allocator>&);
+
+    template<class charT, class traits, class Allocator>
+    class basic_osyncstream : public basic_ostream<charT, traits> {
+    public:
+        using char_type   = charT;
+        using int_type    = typename traits::int_type;
+        using pos_type    = typename traits::pos_type;
+        using off_type    = typename traits::off_type;
+        using traits_type = traits;
+
+        using allocator_type = Allocator;
+        using streambuf_type = basic_streambuf<charT, traits>;
+        using syncbuf_type   = basic_syncbuf<charT, traits, Allocator>;
+
+        // [syncstream.osyncstream.cons], construction and destruction
+        basic_osyncstream(streambuf_type*, const Allocator&);
+        explicit basic_osyncstream(streambuf_type* obuf)
+          : basic_osyncstream(obuf, Allocator()) {}
+        basic_osyncstream(basic_ostream<charT, traits>& os, const Allocator& allocator)
+          : basic_osyncstream(os.rdbuf(), allocator) {}
+        explicit basic_osyncstream(basic_ostream<charT, traits>& os)
+          : basic_osyncstream(os, Allocator()) {}
+        basic_osyncstream(basic_osyncstream&&) noexcept;
+        ~basic_osyncstream();
+
+        // [syncstream.osyncstream.assign], assignment
+        basic_osyncstream& operator=(basic_osyncstream&&);
+
+        // [syncstream.osyncstream.members], member functions
+        void emit();
+        streambuf_type* get_wrapped() const noexcept;
+        syncbuf_type* rdbuf() const noexcept { return const_cast<syncbuf_type*>(addressof(sb)); }
+
+    private:
+        syncbuf_type sb;    // exposition only
+    };
+}
+
+*/
+
+#include <__config>
+#include <__utility/move.h>
+#include <ios>
+#include <iosfwd> // required for declaration of default arguments
+#include <streambuf>
+#include <string>
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+#  include <map>
+#  include <mutex>
+#  include <shared_mutex>
+#endif
+
+// standard-mandated includes
+
+// [syncstream.syn]
+#include <ostream>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_SYNCSTREAM)
+
+// [syncstream.syncbuf.overview]/1
+//   Class template basic_syncbuf stores character data written to it,
+//   known as the associated output, into internal buffers allocated
+//   using the object's allocator. The associated output is transferred
+//   to the wrapped stream buffer object *wrapped when emit() is called
+//   or when the basic_syncbuf object is destroyed. Such transfers are
+//   atomic with respect to transfers by other basic_syncbuf objects
+//   with the same wrapped stream buffer object.
+//
+// This helper singleton is used to implement the required
+// synchronisation guarantees.
+#  ifndef _LIBCPP_HAS_NO_THREADS
+class __wrapped_streambuf_mutex {
+  _LIBCPP_HIDE_FROM_ABI __wrapped_streambuf_mutex() = default;
+
+public:
+  __wrapped_streambuf_mutex(const __wrapped_streambuf_mutex&)            = delete;
+  __wrapped_streambuf_mutex& operator=(const __wrapped_streambuf_mutex&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI void __inc_reference([[maybe_unused]] void* __ptr) {
+    _LIBCPP_ASSERT_INTERNAL(__ptr != nullptr, "non-wrapped streambufs are never written to");
+    unique_lock __lock{__mutex_};
+    ++__lut_[reinterpret_cast<uintptr_t>(__ptr)].__count;
+  }
+
+  // pre: __ptr is in __lut_
+  _LIBCPP_HIDE_FROM_ABI void __dec_reference([[maybe_unused]] void* __ptr) noexcept {
+    unique_lock __lock{__mutex_};
+
+    auto __it = __get_it(__ptr);
+    if (__it->second.__count == 1)
+      __lut_.erase(__it);
+    else
+      --__it->second.__count;
+  }
+
+  // TODO
+  // This function causes emit() aquire two mutexes:
+  // - __mutex_ shared
+  // _ __get_it(__ptr)->second.__mutex exclusive
+  //
+  // Instead store a pointer to __get_it(__ptr)->second.__mutex when
+  // calling __inc_reference.
+  //
+  // pre: __ptr is in __lut_
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI lock_guard<mutex> __get_lock([[maybe_unused]] void* __ptr) noexcept {
+    shared_lock __lock{__mutex_};
+    return lock_guard{__get_it(__ptr)->second.__mutex};
+  }
+
+  // This function is used for testing.
+  //
+  // It is allowed to call this function with a non-registered pointer.
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI size_t __get_count([[maybe_unused]] void* __ptr) noexcept {
+    _LIBCPP_ASSERT_INTERNAL(__ptr != nullptr, "non-wrapped streambufs are never written to");
+    shared_lock __lock{__mutex_};
+
+    auto __it = __lut_.find(reinterpret_cast<uintptr_t>(__ptr));
+    return __it != __lut_.end() ? __it->second.__count : 0;
+  }
+
+  [[nodiscard]] static _LIBCPP_HIDE_FROM_ABI __wrapped_streambuf_mutex& __instance() noexcept {
+    static __wrapped_streambuf_mutex __result;
+    return __result;
+  }
+
+private:
+  struct __value {
+    mutex __mutex;
+    size_t __count{0};
+  };
+
+  shared_mutex __mutex_;
+  map<uintptr_t, __value> __lut_;
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI map<uintptr_t, __value>::iterator __get_it(void* __ptr) noexcept {
+    _LIBCPP_ASSERT_INTERNAL(__ptr != nullptr, "non-wrapped streambufs are never written to");
+
+    auto __it = __lut_.find(reinterpret_cast<uintptr_t>(__ptr));
+    _LIBCPP_ASSERT_INTERNAL(__it != __lut_.end(), "using a wrapped streambuf that has not been registered");
+    _LIBCPP_ASSERT_INTERNAL(__it->second.__count >= 1, "found an inactive streambuf wrapper");
+    return __it;
+  }
+};
+#  endif // _LIBCPP_HAS_NO_THREADS
+
+// basic_syncbuf
+
+// The class uses a basic_string<_CharT, _Traits, _Allocator> as
+// internal buffer. Per [syncstream.syncbuf.cons]/4
+//   Remarks: A copy of allocator is used to allocate memory for
+//   internal buffers holding the associated output.
+//
+// Therefore the allocator used in the constructor is passed to the
+// basic_string. The class does not keep a copy of this allocator.
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCPP_TEMPLATE_VIS basic_syncbuf : public basic_streambuf<_CharT, _Traits> {
+public:
+  using char_type      = _CharT;
+  using traits_type    = _Traits;
+  using int_type       = typename traits_type::int_type;
+  using pos_type       = typename traits_type::pos_type;
+  using off_type       = typename traits_type::off_type;
+  using allocator_type = _Allocator;
+
+  using streambuf_type = basic_streambuf<_CharT, _Traits>;
+
+  // [syncstream.syncbuf.cons], construction and destruction
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_syncbuf(streambuf_type* __obuf = nullptr)
+      : basic_syncbuf(__obuf, _Allocator()) {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_syncbuf(streambuf_type* __obuf, _Allocator const& __alloc)
+      : __wrapped_(__obuf), __str_(__alloc) {
+    __inc_reference();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI basic_syncbuf(basic_syncbuf&& __other)
+      : __wrapped_(__other.get_wrapped()), __str_(std::move(__other.__str_)), __emit_on_sync_(__other.__emit_on_sync_) {
+    __move_common(__other);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI ~basic_syncbuf() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      emit();
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+    }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    __dec_reference();
+  }
+
+  // [syncstream.syncbuf.assign], assignment and swap
+
+  _LIBCPP_HIDE_FROM_ABI basic_syncbuf& operator=(basic_syncbuf&& __other) {
+    // The function is specified to call emit. This call should
+    // propagate the exception thrown.
+    emit();
+    __dec_reference();
+
+    __wrapped_      = __other.get_wrapped();
+    __str_          = std::move(__other.__str_);
+    __emit_on_sync_ = __other.__emit_on_sync_;
+
+    __move_common(__other);
+
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(basic_syncbuf& __other) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        allocator_traits<_Allocator>::propagate_on_container_swap::value || get_allocator() == __other.get_allocator(),
+        "violates the mandated swap precondition");
+
+    basic_syncbuf __tmp(std::move(__other));
+    __other = std::move(*this);
+    *this   = std::move(__tmp);
+  }
+
+  // [syncstream.syncbuf.members], member functions
+
+  _LIBCPP_HIDE_FROM_ABI bool emit() { return emit(false); }
+
+  _LIBCPP_HIDE_FROM_ABI streambuf_type* get_wrapped() const noexcept { return __wrapped_; }
+
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __str_.get_allocator(); }
+
+  _LIBCPP_HIDE_FROM_ABI void set_emit_on_sync(bool __b) noexcept { __emit_on_sync_ = __b; }
+
+protected:
+  // [syncstream.syncbuf.virtuals], overridden virtual functions
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  int sync() override {
+    if (__emit_on_sync_ && !emit(true))
+      return -1;
+    return 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  int_type overflow(int_type __c = traits_type::eof()) override {
+    if (traits_type::eq_int_type(__c, traits_type::eof()))
+      return traits_type::not_eof(__c);
+
+    if (this->pptr() == this->epptr()) {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      try {
+#  endif
+        size_t __size = __str_.size();
+        __str_.resize(__str_.capacity() + 1);
+        _LIBCPP_ASSERT_INTERNAL(__str_.size() > __size, "the buffer hasn't grown");
+
+        char_type* __p = static_cast<char_type*>(__str_.data());
+        this->setp(__p, __p + __str_.size());
+        this->pbump(__size);
+
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      } catch (...) {
+        return traits_type::eof();
+      }
+#  endif
+    }
+
+    return this->sputc(traits_type::to_char_type(__c));
+  }
+
+private:
+  streambuf_type* __wrapped_;
+
+  // TODO Use a more generic buffer.
+  // That buffer should be light with almost no additional headers. Then
+  // it can be use here, the __retarget_buffer, and place that use
+  // the now deprecated get_temporary_buffer
+
+  basic_string<_CharT, _Traits, _Allocator> __str_;
+  bool __emit_on_sync_{false};
+
+  _LIBCPP_HIDE_FROM_ABI bool emit(bool __flush) {
+    if (!__wrapped_)
+      return false;
+
+#  ifndef _LIBCPP_HAS_NO_THREADS
+    lock_guard<mutex> __lock = __wrapped_streambuf_mutex::__instance().__get_lock(__wrapped_);
+#  endif
+
+    bool __result = true;
+    if (this->pptr() != this->pbase()) {
+      _LIBCPP_ASSERT_INTERNAL(this->pbase() && this->pptr() && this->epptr(), "all put area pointers shold be valid");
+
+      // The __str_ does not know how much of its buffer is used. This
+      // information is extracted from the information of the base class.
+      __result &= (__wrapped_->sputn(this->pbase(), this->pptr() - this->pbase()) != -1);
+      // Clears the buffer, but keeps the contents (and) size of the
+      // internal buffer.
+      this->setp(this->pbase(), this->epptr());
+    }
+
+    if (__flush)
+      __result &= (__wrapped_->pubsync() != -1);
+
+    return __result;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __move_common(basic_syncbuf& __other) {
+    // Adjust the put area pointers to our buffer.
+    char_type* __p = static_cast<char_type*>(__str_.data());
+    this->setp(__p, __p + __str_.size());
+    this->pbump(__other.pptr() - __other.pbase());
+
+    // Clear __other_ so the destructor will act as a NOP.
+    __other.setp(nullptr, nullptr);
+    __other.__wrapped_ = nullptr;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __inc_reference() {
+#  ifndef _LIBCPP_HAS_NO_THREADS
+    if (__wrapped_)
+      __wrapped_streambuf_mutex::__instance().__inc_reference(__wrapped_);
+#  endif
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void __dec_reference() noexcept {
+#  ifndef _LIBCPP_HAS_NO_THREADS
+    if (__wrapped_)
+      __wrapped_streambuf_mutex::__instance().__dec_reference(__wrapped_);
+#  endif
+  }
+};
+
+using std::syncbuf;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using std::wsyncbuf;
+#  endif
+
+// [syncstream.syncbuf.special], specialized algorithms
+template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_HIDE_FROM_ABI void
+swap(basic_syncbuf<_CharT, _Traits, _Allocator>& __lhs, basic_syncbuf<_CharT, _Traits, _Allocator>& __rhs) {
+  __lhs.swap(__rhs);
+}
+
+// basic_osyncstream
+
+template <class _CharT, class _Traits, class _Allocator>
+class _LIBCPP_TEMPLATE_VIS basic_osyncstream : public basic_ostream<_CharT, _Traits> {
+public:
+  using char_type   = _CharT;
+  using traits_type = _Traits;
+  using int_type    = typename traits_type::int_type;
+  using pos_type    = typename traits_type::pos_type;
+  using off_type    = typename traits_type::off_type;
+
+  using allocator_type = _Allocator;
+  using streambuf_type = basic_streambuf<char_type, traits_type>;
+  using syncbuf_type   = basic_syncbuf<char_type, traits_type, allocator_type>;
+
+  // [syncstream.osyncstream.cons], construction and destruction
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream(streambuf_type* __obuf, allocator_type const& __alloc)
+      : basic_ostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(__obuf, __alloc) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_osyncstream(streambuf_type* __obuf)
+      : basic_osyncstream(__obuf, allocator_type()) {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream(basic_ostream<char_type, traits_type>& __os, allocator_type const& __alloc)
+      : basic_osyncstream(__os.rdbuf(), __alloc) {}
+
+  _LIBCPP_HIDE_FROM_ABI explicit basic_osyncstream(basic_ostream<char_type, traits_type>& __os)
+      : basic_osyncstream(__os, allocator_type()) {}
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream(basic_osyncstream&& __other) noexcept
+      : basic_ostream<_CharT, _Traits>(std::addressof(__sb_)), __sb_(std::move(__other.__sb_)) {
+    this->set_rdbuf(std::addressof(__sb_));
+  }
+
+  // [syncstream.osyncstream.assign], assignment
+
+  _LIBCPP_HIDE_FROM_ABI basic_osyncstream& operator=(basic_osyncstream&& __other) = default;
+
+  // [syncstream.osyncstream.members], member functions
+
+  _LIBCPP_HIDE_FROM_ABI void emit() {
+    // The basic_ostream::put places the sentry in a try
+    // catch, this does not match the wording of the standard
+    // [ostream.unformatted]
+    // TODO validate other unformatted output functions.
+    typename basic_ostream<char_type, traits_type>::sentry __s(*this);
+    if (__s) {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      try {
+#  endif
+
+        if (__sb_.emit() == false)
+          this->setstate(ios::badbit);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      } catch (...) {
+        this->__set_badbit_and_consider_rethrow();
+      }
+#  endif
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI streambuf_type* get_wrapped() const noexcept { return __sb_.get_wrapped(); }
+
+  _LIBCPP_HIDE_FROM_ABI syncbuf_type* rdbuf() const noexcept {
+    return const_cast<syncbuf_type*>(std::addressof(__sb_));
+  }
+
+private:
+  syncbuf_type __sb_;
+};
+
+using std::osyncstream;
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+using std::wosyncstream;
+#  endif
+
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_SYNCSTREAM)
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP_SYNCSTREAM
diff --git a/third_party/libcxx/system_error b/third_party/libcxx/system_error
index a60c98492..2d3af910d 100644
--- a/third_party/libcxx/system_error
+++ b/third_party/libcxx/system_error
@@ -144,11 +144,10 @@ template <> struct hash<std::error_condition>;
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__system_error/errc.h>
-#include <__system_error/error_category.h>
 #include <__system_error/error_code.h>
+#include <__system_error/error_category.h>
 #include <__system_error/error_condition.h>
 #include <__system_error/system_error.h>
 #include <version>
diff --git a/third_party/libcxx/system_error.cpp b/third_party/libcxx/system_error.cpp
new file mode 100644
index 000000000..0e5bf2d4f
--- /dev/null
+++ b/third_party/libcxx/system_error.cpp
@@ -0,0 +1,229 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__assert>
+#include <__config>
+#include <__verbose_abort>
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string.h>
+#include <string>
+#include <system_error>
+#include <__system_error/errc.h>
+
+#include "config_elast.h"
+
+#if defined(__ANDROID__)
+#  include <android/api-level.h>
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace {
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+
+//  GLIBC also uses 1024 as the maximum buffer size internally.
+constexpr size_t strerror_buff_size = 1024;
+
+string do_strerror_r(int ev);
+
+#  if defined(_LIBCPP_MSVCRT_LIKE)
+string do_strerror_r(int ev) {
+  ev = __errc_to_err(ev);
+  char buffer[strerror_buff_size];
+  if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
+    return string(buffer);
+  std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
+  return string(buffer);
+}
+#  else
+
+// Only one of the two following functions will be used, depending on
+// the return type of strerror_r:
+
+// For the GNU variant, a char* return value:
+__attribute__((unused)) const char* handle_strerror_r_return(char* strerror_return, char* buffer) {
+  // GNU always returns a string pointer in its return value. The
+  // string might point to either the input buffer, or a static
+  // buffer, but we don't care which.
+  return strerror_return;
+}
+
+// For the POSIX variant: an int return value.
+__attribute__((unused)) const char* handle_strerror_r_return(int strerror_return, char* buffer) {
+  // The POSIX variant either:
+  // - fills in the provided buffer and returns 0
+  // - returns a positive error value, or
+  // - returns -1 and fills in errno with an error value.
+  if (strerror_return == 0)
+    return buffer;
+
+  // Only handle EINVAL. Other errors abort.
+  int new_errno = strerror_return == -1 ? errno : strerror_return;
+  if (new_errno == EINVAL)
+    return "";
+
+  _LIBCPP_ASSERT_INTERNAL(new_errno == ERANGE, "unexpected error from ::strerror_r");
+  // FIXME maybe? 'strerror_buff_size' is likely to exceed the
+  // maximum error size so ERANGE shouldn't be returned.
+  std::abort();
+}
+
+// This function handles both GNU and POSIX variants, dispatching to
+// one of the two above functions.
+string do_strerror_r(int ev) {
+  char buffer[strerror_buff_size];
+  // Preserve errno around the call. (The C++ standard requires that
+  // system_error functions not modify errno).
+  const int old_errno       = errno;
+  ev = __errc_to_err((errc)ev);
+  const char* error_message = handle_strerror_r_return(::strerror_r(ev, buffer, strerror_buff_size), buffer);
+  // If we didn't get any message, print one now.
+  if (!error_message[0]) {
+    std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
+    error_message = buffer;
+  }
+  errno = old_errno;
+  return string(error_message);
+}
+#  endif
+
+#endif // !defined(_LIBCPP_HAS_NO_THREADS)
+
+string make_error_str(const error_code& ec, string what_arg) {
+  if (ec) {
+    if (!what_arg.empty()) {
+      what_arg += ": ";
+    }
+    what_arg += ec.message();
+  }
+  return what_arg;
+}
+
+string make_error_str(const error_code& ec) {
+  if (ec) {
+    return ec.message();
+  }
+  return string();
+}
+} // end namespace
+
+string __do_message::message(int ev) const {
+#if defined(_LIBCPP_HAS_NO_THREADS)
+  return string(::strerror(ev));
+#else
+  return do_strerror_r(ev);
+#endif
+}
+
+class _LIBCPP_HIDDEN __generic_error_category : public __do_message {
+public:
+  virtual const char* name() const noexcept;
+  virtual string message(int ev) const;
+};
+
+const char* __generic_error_category::name() const noexcept { return "generic"; }
+
+string __generic_error_category::message(int ev) const {
+  ev = __errc_to_err((errc)ev);
+#ifdef _LIBCPP_ELAST
+  if (ev > _LIBCPP_ELAST)
+    return string("unspecified generic_category error");
+#endif // _LIBCPP_ELAST
+  return __do_message::message(ev);
+}
+
+const error_category& generic_category() noexcept {
+  union AvoidDestroyingGenericCategory {
+    __generic_error_category generic_error_category;
+    constexpr explicit AvoidDestroyingGenericCategory() : generic_error_category() {}
+    ~AvoidDestroyingGenericCategory() {}
+  };
+  constinit static AvoidDestroyingGenericCategory helper;
+  return helper.generic_error_category;
+}
+
+class _LIBCPP_HIDDEN __system_error_category : public __do_message {
+public:
+  virtual const char* name() const noexcept;
+  virtual string message(int ev) const;
+  virtual error_condition default_error_condition(int ev) const noexcept;
+};
+
+const char* __system_error_category::name() const noexcept { return "system"; }
+
+string __system_error_category::message(int ev) const {
+  ev = __errc_to_err((errc)ev);
+#ifdef _LIBCPP_ELAST
+  if (ev > _LIBCPP_ELAST)
+    return string("unspecified system_category error");
+#endif // _LIBCPP_ELAST
+  return __do_message::message(ev);
+}
+
+error_condition __system_error_category::default_error_condition(int ev) const noexcept {
+  ev = __errc_to_err((errc)ev);
+#ifdef _LIBCPP_ELAST
+  if (ev > _LIBCPP_ELAST)
+    return error_condition(ev, system_category());
+#endif // _LIBCPP_ELAST
+  return error_condition(ev, generic_category());
+}
+
+const error_category& system_category() noexcept {
+  union AvoidDestroyingSystemCategory {
+    __system_error_category system_error_category;
+    constexpr explicit AvoidDestroyingSystemCategory() : system_error_category() {}
+    ~AvoidDestroyingSystemCategory() {}
+  };
+  constinit static AvoidDestroyingSystemCategory helper;
+  return helper.system_error_category;
+}
+
+// error_condition
+
+string error_condition::message() const { return __cat_->message(__val_); }
+
+// error_code
+
+string error_code::message() const { return __cat_->message(__val_); }
+
+// system_error
+
+system_error::system_error(error_code ec, const string& what_arg)
+    : runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
+
+system_error::system_error(error_code ec, const char* what_arg)
+    : runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
+
+system_error::system_error(error_code ec) : runtime_error(make_error_str(ec)), __ec_(ec) {}
+
+system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
+    : runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
+
+system_error::system_error(int ev, const error_category& ecat, const char* what_arg)
+    : runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
+
+system_error::system_error(int ev, const error_category& ecat)
+    : runtime_error(make_error_str(error_code(ev, ecat))), __ec_(error_code(ev, ecat)) {}
+
+system_error::~system_error() noexcept {}
+
+void __throw_system_error(int ev, const char* what_arg) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  std::__throw_system_error(error_code(__errc_to_err((errc)ev), system_category()), what_arg);
+#else
+  // The above could also handle the no-exception case, but for size, avoid referencing system_category() unnecessarily.
+  _LIBCPP_VERBOSE_ABORT(
+      "system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", ev, what_arg);
+#endif
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/thread b/third_party/libcxx/thread
index 33227ff9a..25cb7ce6d 100644
--- a/third_party/libcxx/thread
+++ b/third_party/libcxx/thread
@@ -86,387 +86,35 @@ void sleep_for(const chrono::duration<Rep, Period>& rel_time);
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__availability>
-#include <__chrono/steady_clock.h>
-#include <__chrono/time_point.h>
-#include <__concepts/arithmetic.h>
-#include <__condition_variable/condition_variable.h>
 #include <__config>
-#include <__exception/terminate.h>
-#include <__format/concepts.h>
-#include <__format/format_parse_context.h>
-#include <__format/formatter.h>
-#include <__format/formatter_integral.h>
-#include <__format/parser_std_format_spec.h>
-#include <__functional/hash.h>
-#include <__functional/unary_function.h>
-#include <__memory/addressof.h>
-#include <__memory/unique_ptr.h>
-#include <__mutex/mutex.h>
-#include <__mutex/unique_lock.h>
-#include <__system_error/system_error.h>
-#include <__thread/poll_with_backoff.h>
-#include <__thread/timed_backoff_policy.h>
-#include <__threading_support>
-#include <__utility/forward.h>
-#include <cstddef>
-#include <cstdint>
-#include <iosfwd>
-#include <tuple>
-#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+
+#  include <__thread/formatter.h>
+#  include <__thread/jthread.h>
+#  include <__thread/support.h>
+#  include <__thread/this_thread.h>
+#  include <__thread/thread.h>
+#  include <version>
 
 // standard-mandated includes
 
 // [thread.syn]
-#include <compare>
+#  include <compare>
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
+
+#endif // !defined(_LIBCPP_HAS_NO_THREADS)
+
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES)
+#  include <cstddef>
+#  include <ctime>
+#  include <iosfwd>
+#  include <ratio>
 #endif
 
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
-
-#ifdef _LIBCPP_HAS_NO_THREADS
-# error "<thread> is not supported since libc++ has been configured without support for threads."
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-template <class _Tp> class __thread_specific_ptr;
-class _LIBCPP_TYPE_VIS __thread_struct;
-class _LIBCPP_HIDDEN __thread_struct_imp;
-class __assoc_sub_state;
-
-_LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();
-
-class _LIBCPP_TYPE_VIS __thread_struct
-{
-    __thread_struct_imp* __p_;
-
-    __thread_struct(const __thread_struct&);
-    __thread_struct& operator=(const __thread_struct&);
-public:
-    __thread_struct();
-    ~__thread_struct();
-
-    void notify_all_at_thread_exit(condition_variable*, mutex*);
-    void __make_ready_at_thread_exit(__assoc_sub_state*);
-};
-
-template <class _Tp>
-class __thread_specific_ptr
-{
-    __libcpp_tls_key __key_;
-
-     // Only __thread_local_data() may construct a __thread_specific_ptr
-     // and only with _Tp == __thread_struct.
-    static_assert((is_same<_Tp, __thread_struct>::value), "");
-    __thread_specific_ptr();
-    friend _LIBCPP_FUNC_VIS __thread_specific_ptr<__thread_struct>& __thread_local_data();
-
-    __thread_specific_ptr(const __thread_specific_ptr&);
-    __thread_specific_ptr& operator=(const __thread_specific_ptr&);
-
-    _LIBCPP_HIDDEN static void _LIBCPP_TLS_DESTRUCTOR_CC __at_thread_exit(void*);
-
-public:
-    typedef _Tp* pointer;
-
-    ~__thread_specific_ptr();
-
-    _LIBCPP_INLINE_VISIBILITY
-    pointer get() const {return static_cast<_Tp*>(__libcpp_tls_get(__key_));}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator*() const {return *get();}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return get();}
-    void set_pointer(pointer __p);
-};
-
-template <class _Tp>
-void _LIBCPP_TLS_DESTRUCTOR_CC
-__thread_specific_ptr<_Tp>::__at_thread_exit(void* __p)
-{
-    delete static_cast<pointer>(__p);
-}
-
-template <class _Tp>
-__thread_specific_ptr<_Tp>::__thread_specific_ptr()
-{
-  int __ec =
-      __libcpp_tls_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
-  if (__ec)
-    __throw_system_error(__ec, "__thread_specific_ptr construction failed");
-}
-
-template <class _Tp>
-__thread_specific_ptr<_Tp>::~__thread_specific_ptr()
-{
-    // __thread_specific_ptr is only created with a static storage duration
-    // so this destructor is only invoked during program termination. Invoking
-    // pthread_key_delete(__key_) may prevent other threads from deleting their
-    // thread local data. For this reason we leak the key.
-}
-
-template <class _Tp>
-void
-__thread_specific_ptr<_Tp>::set_pointer(pointer __p)
-{
-    _LIBCPP_ASSERT(get() == nullptr,
-                   "Attempting to overwrite thread local data");
-    std::__libcpp_tls_set(__key_, __p);
-}
-
-template<>
-struct _LIBCPP_TEMPLATE_VIS hash<__thread_id>
-    : public __unary_function<__thread_id, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(__thread_id __v) const _NOEXCEPT
-    {
-        return hash<__libcpp_thread_id>()(__v.__id_);
-    }
-};
-
-template<class _CharT, class _Traits>
-_LIBCPP_INLINE_VISIBILITY
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id)
-{return __os << __id.__id_;}
-
-#if _LIBCPP_STD_VER >= 23
-template <__fmt_char_type _CharT>
-struct _LIBCPP_TEMPLATE_VIS formatter<__thread_id, _CharT> {
-  public:
-    template <class _ParseContext>
-    _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
-        return __parser_.__parse(__ctx, __format_spec::__fields_fill_align_width);
-    }
-
-    template <class _FormatContext>
-    _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(__thread_id __id, _FormatContext& __ctx) const {
-        // In __threading_support __libcpp_thread_id is either a
-        // unsigned long long or a pthread_t.
-        //
-        // The type of pthread_t is left unspecified in POSIX so it can be any
-        // type. The most logical types are an integral or pointer.
-        // On Linux systems pthread_t is an unsigned long long.
-        // On Apple systems pthread_t is a pointer type.
-        //
-        // Note the output should match what the stream operator does. Since
-        // the ostream operator has been shipped years before this formatter
-        // was added to the Standard, this formatter does what the stream
-        // operator does. This may require platform specific changes.
-
-        using _Tp = decltype(__get_underlying_id(__id));
-        using _Cp = conditional_t<integral<_Tp>, _Tp, conditional_t<is_pointer_v<_Tp>, uintptr_t, void>>;
-        static_assert(!is_same_v<_Cp, void>, "unsupported thread::id type, please file a bug report");
-
-        __format_spec::__parsed_specifications<_CharT> __specs = __parser_.__get_parsed_std_specifications(__ctx);
-        if constexpr (is_pointer_v<_Tp>) {
-          __specs.__std_.__alternate_form_ = true;
-          __specs.__std_.__type_           = __format_spec::__type::__hexadecimal_lower_case;
-        }
-        return __formatter::__format_integer(reinterpret_cast<_Cp>(__get_underlying_id(__id)), __ctx, __specs);
-    }
-
-    __format_spec::__parser<_CharT> __parser_{.__alignment_ = __format_spec::__alignment::__right};
-};
-#endif // _LIBCPP_STD_VER >= 23
-
-class _LIBCPP_TYPE_VIS thread
-{
-    __libcpp_thread_t __t_;
-
-    thread(const thread&);
-    thread& operator=(const thread&);
-public:
-    typedef __thread_id id;
-    typedef __libcpp_thread_t native_handle_type;
-
-    _LIBCPP_INLINE_VISIBILITY
-    thread() _NOEXCEPT : __t_(_LIBCPP_NULL_THREAD) {}
-#ifndef _LIBCPP_CXX03_LANG
-    template <class _Fp, class ..._Args,
-              class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, thread>::value> >
-        _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-        explicit thread(_Fp&& __f, _Args&&... __args);
-#else  // _LIBCPP_CXX03_LANG
-    template <class _Fp>
-    _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
-    explicit thread(_Fp __f);
-#endif
-    ~thread();
-
-    _LIBCPP_INLINE_VISIBILITY
-    thread(thread&& __t) _NOEXCEPT : __t_(__t.__t_) {
-        __t.__t_ = _LIBCPP_NULL_THREAD;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    thread& operator=(thread&& __t) _NOEXCEPT {
-        if (!__libcpp_thread_isnull(&__t_))
-            terminate();
-        __t_ = __t.__t_;
-        __t.__t_ = _LIBCPP_NULL_THREAD;
-        return *this;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(thread& __t) _NOEXCEPT {_VSTD::swap(__t_, __t.__t_);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool joinable() const _NOEXCEPT {return !__libcpp_thread_isnull(&__t_);}
-    void join();
-    void detach();
-    _LIBCPP_INLINE_VISIBILITY
-    id get_id() const _NOEXCEPT {return __libcpp_thread_get_id(&__t_);}
-    _LIBCPP_INLINE_VISIBILITY
-    native_handle_type native_handle() _NOEXCEPT {return __t_;}
-
-    static unsigned hardware_concurrency() _NOEXCEPT;
-};
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _TSp, class _Fp, class ..._Args, size_t ..._Indices>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-__thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __tuple_indices<_Indices...>)
-{
-    _VSTD::__invoke(_VSTD::move(_VSTD::get<1>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
-}
-
-template <class _Fp>
-_LIBCPP_INLINE_VISIBILITY
-void* __thread_proxy(void* __vp)
-{
-    // _Fp = tuple< unique_ptr<__thread_struct>, Functor, Args...>
-    unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
-    __thread_local_data().set_pointer(_VSTD::get<0>(*__p.get()).release());
-    typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 2>::type _Index;
-    _VSTD::__thread_execute(*__p.get(), _Index());
-    return nullptr;
-}
-
-template <class _Fp, class ..._Args,
-          class
-         >
-thread::thread(_Fp&& __f, _Args&&... __args)
-{
-    typedef unique_ptr<__thread_struct> _TSPtr;
-    _TSPtr __tsp(new __thread_struct);
-    typedef tuple<_TSPtr, __decay_t<_Fp>, __decay_t<_Args>...> _Gp;
-    unique_ptr<_Gp> __p(
-            new _Gp(_VSTD::move(__tsp),
-                    _VSTD::forward<_Fp>(__f),
-                    _VSTD::forward<_Args>(__args)...));
-    int __ec = _VSTD::__libcpp_thread_create(&__t_, &__thread_proxy<_Gp>, __p.get());
-    if (__ec == 0)
-        __p.release();
-    else
-        __throw_system_error(__ec, "thread constructor failed");
-}
-
-#else  // _LIBCPP_CXX03_LANG
-
-template <class _Fp>
-struct __thread_invoke_pair {
-    // This type is used to pass memory for thread local storage and a functor
-    // to a newly created thread because std::pair doesn't work with
-    // std::unique_ptr in C++03.
-    _LIBCPP_HIDE_FROM_ABI __thread_invoke_pair(_Fp& __f) : __tsp_(new __thread_struct), __fn_(__f) {}
-    unique_ptr<__thread_struct> __tsp_;
-    _Fp __fn_;
-};
-
-template <class _Fp>
-_LIBCPP_HIDE_FROM_ABI void* __thread_proxy_cxx03(void* __vp)
-{
-    unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
-    __thread_local_data().set_pointer(__p->__tsp_.release());
-    (__p->__fn_)();
-    return nullptr;
-}
-
-template <class _Fp>
-thread::thread(_Fp __f)
-{
-
-    typedef __thread_invoke_pair<_Fp> _InvokePair;
-    typedef unique_ptr<_InvokePair> _PairPtr;
-    _PairPtr __pp(new _InvokePair(__f));
-    int __ec = _VSTD::__libcpp_thread_create(&__t_, &__thread_proxy_cxx03<_InvokePair>, __pp.get());
-    if (__ec == 0)
-        __pp.release();
-    else
-        __throw_system_error(__ec, "thread constructor failed");
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
-inline _LIBCPP_INLINE_VISIBILITY
-void swap(thread& __x, thread& __y) _NOEXCEPT {__x.swap(__y);}
-
-namespace this_thread
-{
-
-_LIBCPP_FUNC_VIS void sleep_for(const chrono::nanoseconds& __ns);
-
-template <class _Rep, class _Period>
-_LIBCPP_HIDE_FROM_ABI void
-sleep_for(const chrono::duration<_Rep, _Period>& __d)
-{
-    if (__d > chrono::duration<_Rep, _Period>::zero())
-    {
-        // The standard guarantees a 64bit signed integer resolution for nanoseconds,
-        // so use INT64_MAX / 1e9 as cut-off point. Use a constant to avoid <climits>
-        // and issues with long double folding on PowerPC with GCC.
-        _LIBCPP_CONSTEXPR chrono::duration<long double> __max =
-            chrono::duration<long double>(9223372036.0L);
-        chrono::nanoseconds __ns;
-        if (__d < __max)
-        {
-            __ns = chrono::duration_cast<chrono::nanoseconds>(__d);
-            if (__ns < __d)
-                ++__ns;
-        }
-        else
-            __ns = chrono::nanoseconds::max();
-        this_thread::sleep_for(__ns);
-    }
-}
-
-template <class _Clock, class _Duration>
-_LIBCPP_HIDE_FROM_ABI void
-sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
-{
-    mutex __mut;
-    condition_variable __cv;
-    unique_lock<mutex> __lk(__mut);
-    while (_Clock::now() < __t)
-        __cv.wait_until(__lk, __t);
-}
-
-template <class _Duration>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
-{
-    this_thread::sleep_for(__t - chrono::steady_clock::now());
-}
-
-inline _LIBCPP_INLINE_VISIBILITY
-void yield() _NOEXCEPT {__libcpp_thread_yield();}
-
-} // namespace this_thread
-
-_LIBCPP_END_NAMESPACE_STD
-
-_LIBCPP_POP_MACROS
-
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
 #  include <chrono>
 #endif
@@ -476,6 +124,7 @@ _LIBCPP_POP_MACROS
 #  include <functional>
 #  include <new>
 #  include <system_error>
+#  include <type_traits>
 #endif
 
 #endif // _LIBCPP_THREAD
diff --git a/third_party/libcxx/thread.cpp b/third_party/libcxx/thread.cpp
new file mode 100644
index 000000000..73f22f12d
--- /dev/null
+++ b/third_party/libcxx/thread.cpp
@@ -0,0 +1,173 @@
+//===------------------------- thread.cpp----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <__thread/poll_with_backoff.h>
+#include <__thread/timed_backoff_policy.h>
+#include <exception>
+#include <future>
+#include <limits>
+#include <thread>
+#include <vector>
+
+#if __has_include(<unistd.h>)
+#  include <unistd.h> // for sysconf
+#endif
+
+#if defined(__NetBSD__)
+#  pragma weak pthread_create // Do not create libpthread dependency
+#endif
+
+#if defined(_LIBCPP_WIN32API)
+#  include <windows.h>
+#endif
+
+#if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
+#  pragma comment(lib, "pthread")
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+thread::~thread() {
+  if (!__libcpp_thread_isnull(&__t_))
+    terminate();
+}
+
+void thread::join() {
+  int ec = EINVAL;
+  if (!__libcpp_thread_isnull(&__t_)) {
+    ec = __libcpp_thread_join(&__t_);
+    if (ec == 0)
+      __t_ = _LIBCPP_NULL_THREAD;
+  }
+
+  if (ec)
+    __throw_system_error(ec, "thread::join failed");
+}
+
+void thread::detach() {
+  int ec = EINVAL;
+  if (!__libcpp_thread_isnull(&__t_)) {
+    ec = __libcpp_thread_detach(&__t_);
+    if (ec == 0)
+      __t_ = _LIBCPP_NULL_THREAD;
+  }
+
+  if (ec)
+    __throw_system_error(ec, "thread::detach failed");
+}
+
+unsigned thread::hardware_concurrency() noexcept {
+#if defined(_SC_NPROCESSORS_ONLN)
+  long result = sysconf(_SC_NPROCESSORS_ONLN);
+  // sysconf returns -1 if the name is invalid, the option does not exist or
+  // does not have a definite limit.
+  // if sysconf returns some other negative number, we have no idea
+  // what is going on. Default to something safe.
+  if (result < 0)
+    return 0;
+  return static_cast<unsigned>(result);
+#elif defined(_LIBCPP_WIN32API)
+  SYSTEM_INFO info;
+  GetSystemInfo(&info);
+  return info.dwNumberOfProcessors;
+#else // defined(CTL_HW) && defined(HW_NCPU)
+  // TODO: grovel through /proc or check cpuid on x86 and similar
+  // instructions on other architectures.
+#  if defined(_LIBCPP_WARNING)
+  _LIBCPP_WARNING("hardware_concurrency not yet implemented")
+#  else
+#    warning hardware_concurrency not yet implemented
+#  endif
+  return 0; // Means not computable [thread.thread.static]
+#endif // defined(CTL_HW) && defined(HW_NCPU)
+}
+
+namespace this_thread {
+
+void sleep_for(const chrono::nanoseconds& ns) {
+  if (ns > chrono::nanoseconds::zero()) {
+    __libcpp_thread_sleep_for(ns);
+  }
+}
+
+} // namespace this_thread
+
+__thread_specific_ptr<__thread_struct>& __thread_local_data() {
+  // Even though __thread_specific_ptr's destructor doesn't actually destroy
+  // anything (see comments there), we can't call it at all because threads may
+  // outlive the static variable and calling its destructor means accessing an
+  // object outside of its lifetime, which is UB.
+  alignas(__thread_specific_ptr<__thread_struct>) static char __b[sizeof(__thread_specific_ptr<__thread_struct>)];
+  static __thread_specific_ptr<__thread_struct>* __p = new (__b) __thread_specific_ptr<__thread_struct>();
+  return *__p;
+}
+
+// __thread_struct_imp
+
+template <class T>
+class _LIBCPP_HIDDEN __hidden_allocator {
+public:
+  typedef T value_type;
+
+  T* allocate(size_t __n) { return static_cast<T*>(::operator new(__n * sizeof(T))); }
+  void deallocate(T* __p, size_t) { ::operator delete(static_cast<void*>(__p)); }
+
+  size_t max_size() const { return size_t(~0) / sizeof(T); }
+};
+
+class _LIBCPP_HIDDEN __thread_struct_imp {
+  typedef vector<__assoc_sub_state*, __hidden_allocator<__assoc_sub_state*> > _AsyncStates;
+  typedef vector<pair<condition_variable*, mutex*>, __hidden_allocator<pair<condition_variable*, mutex*> > > _Notify;
+
+  _AsyncStates async_states_;
+  _Notify notify_;
+
+  __thread_struct_imp(const __thread_struct_imp&);
+  __thread_struct_imp& operator=(const __thread_struct_imp&);
+
+public:
+  __thread_struct_imp() {}
+  ~__thread_struct_imp();
+
+  void notify_all_at_thread_exit(condition_variable* cv, mutex* m);
+  void __make_ready_at_thread_exit(__assoc_sub_state* __s);
+};
+
+__thread_struct_imp::~__thread_struct_imp() {
+  for (_Notify::iterator i = notify_.begin(), e = notify_.end(); i != e; ++i) {
+    i->first->notify_all();
+    i->second->unlock();
+  }
+  for (_AsyncStates::iterator i = async_states_.begin(), e = async_states_.end(); i != e; ++i) {
+    (*i)->__make_ready();
+    (*i)->__release_shared();
+  }
+}
+
+void __thread_struct_imp::notify_all_at_thread_exit(condition_variable* cv, mutex* m) {
+  notify_.push_back(pair<condition_variable*, mutex*>(cv, m));
+}
+
+void __thread_struct_imp::__make_ready_at_thread_exit(__assoc_sub_state* __s) {
+  async_states_.push_back(__s);
+  __s->__add_shared();
+}
+
+// __thread_struct
+
+__thread_struct::__thread_struct() : __p_(new __thread_struct_imp) {}
+
+__thread_struct::~__thread_struct() { delete __p_; }
+
+void __thread_struct::notify_all_at_thread_exit(condition_variable* cv, mutex* m) {
+  __p_->notify_all_at_thread_exit(cv, m);
+}
+
+void __thread_struct::__make_ready_at_thread_exit(__assoc_sub_state* __s) { __p_->__make_ready_at_thread_exit(__s); }
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/to_chars_floating_point.h b/third_party/libcxx/to_chars_floating_point.h
new file mode 100644
index 000000000..b0d385b7d
--- /dev/null
+++ b/third_party/libcxx/to_chars_floating_point.h
@@ -0,0 +1,1079 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// This implementation is dedicated to the memory of Mary and Thavatchai.
+
+#ifndef _LIBCPP_SRC_INCLUDE_TO_CHARS_FLOATING_POINT_H
+#define _LIBCPP_SRC_INCLUDE_TO_CHARS_FLOATING_POINT_H
+
+// Avoid formatting to keep the changes with the original code minimal.
+// clang-format off
+
+#include <__algorithm/find.h>
+#include <__algorithm/find_if.h>
+#include <__algorithm/lower_bound.h>
+#include <__algorithm/min.h>
+#include <__assert>
+#include <__config>
+#include <__functional/operations.h>
+#include <__iterator/access.h>
+#include <__iterator/size.h>
+#include <bit>
+#include <cfloat>
+#include <climits>
+
+#include "third_party/libcxx/ryu/ryu.h"
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace __itoa {
+inline constexpr char _Charconv_digits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e',
+    'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
+static_assert(std::size(_Charconv_digits) == 36);
+} // __itoa
+
+// vvvvvvvvvv DERIVED FROM corecrt_internal_fltintrn.h vvvvvvvvvv
+
+template <class _FloatingType>
+struct _Floating_type_traits;
+
+template <>
+struct _Floating_type_traits<float> {
+    static constexpr int32_t _Mantissa_bits = FLT_MANT_DIG;
+    static constexpr int32_t _Exponent_bits = sizeof(float) * CHAR_BIT - FLT_MANT_DIG;
+
+    static constexpr int32_t _Maximum_binary_exponent = FLT_MAX_EXP - 1;
+    static constexpr int32_t _Minimum_binary_exponent = FLT_MIN_EXP - 1;
+
+    static constexpr int32_t _Exponent_bias = 127;
+
+    static constexpr int32_t _Sign_shift     = _Exponent_bits + _Mantissa_bits - 1;
+    static constexpr int32_t _Exponent_shift = _Mantissa_bits - 1;
+
+    using _Uint_type = uint32_t;
+
+    static constexpr uint32_t _Exponent_mask             = (1u << _Exponent_bits) - 1;
+    static constexpr uint32_t _Normal_mantissa_mask      = (1u << _Mantissa_bits) - 1;
+    static constexpr uint32_t _Denormal_mantissa_mask    = (1u << (_Mantissa_bits - 1)) - 1;
+    static constexpr uint32_t _Special_nan_mantissa_mask = 1u << (_Mantissa_bits - 2);
+    static constexpr uint32_t _Shifted_sign_mask         = 1u << _Sign_shift;
+    static constexpr uint32_t _Shifted_exponent_mask     = _Exponent_mask << _Exponent_shift;
+};
+
+template <>
+struct _Floating_type_traits<double> {
+    static constexpr int32_t _Mantissa_bits = DBL_MANT_DIG;
+    static constexpr int32_t _Exponent_bits = sizeof(double) * CHAR_BIT - DBL_MANT_DIG;
+
+    static constexpr int32_t _Maximum_binary_exponent = DBL_MAX_EXP - 1;
+    static constexpr int32_t _Minimum_binary_exponent = DBL_MIN_EXP - 1;
+
+    static constexpr int32_t _Exponent_bias = 1023;
+
+    static constexpr int32_t _Sign_shift     = _Exponent_bits + _Mantissa_bits - 1;
+    static constexpr int32_t _Exponent_shift = _Mantissa_bits - 1;
+
+    using _Uint_type = uint64_t;
+
+    static constexpr uint64_t _Exponent_mask             = (1ULL << _Exponent_bits) - 1;
+    static constexpr uint64_t _Normal_mantissa_mask      = (1ULL << _Mantissa_bits) - 1;
+    static constexpr uint64_t _Denormal_mantissa_mask    = (1ULL << (_Mantissa_bits - 1)) - 1;
+    static constexpr uint64_t _Special_nan_mantissa_mask = 1ULL << (_Mantissa_bits - 2);
+    static constexpr uint64_t _Shifted_sign_mask         = 1ULL << _Sign_shift;
+    static constexpr uint64_t _Shifted_exponent_mask     = _Exponent_mask << _Exponent_shift;
+};
+
+// ^^^^^^^^^^ DERIVED FROM corecrt_internal_fltintrn.h ^^^^^^^^^^
+
+// FUNCTION to_chars (FLOATING-POINT TO STRING)
+template <class _Floating>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+to_chars_result _Floating_to_chars_hex_precision(
+    char* _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {
+
+    // * Determine the effective _Precision.
+    // * Later, we'll decrement _Precision when printing each hexit after the decimal point.
+
+    // The hexits after the decimal point correspond to the explicitly stored fraction bits.
+    // float explicitly stores 23 fraction bits. 23 / 4 == 5.75, which is 6 hexits.
+    // double explicitly stores 52 fraction bits. 52 / 4 == 13, which is 13 hexits.
+    constexpr int _Full_precision         = _IsSame<_Floating, float>::value ? 6 : 13;
+    constexpr int _Adjusted_explicit_bits = _Full_precision * 4;
+
+    if (_Precision < 0) {
+        // C11 7.21.6.1 "The fprintf function"/5: "A negative precision argument is taken as if the precision were
+        // omitted." /8: "if the precision is missing and FLT_RADIX is a power of 2, then the precision is sufficient
+        // for an exact representation of the value"
+        _Precision = _Full_precision;
+    }
+
+    // * Extract the _Ieee_mantissa and _Ieee_exponent.
+    using _Traits    = _Floating_type_traits<_Floating>;
+    using _Uint_type = typename _Traits::_Uint_type;
+
+    const _Uint_type _Uint_value    = std::bit_cast<_Uint_type>(_Value);
+    const _Uint_type _Ieee_mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
+    const int32_t _Ieee_exponent    = static_cast<int32_t>(_Uint_value >> _Traits::_Exponent_shift);
+
+    // * Prepare the _Adjusted_mantissa. This is aligned to hexit boundaries,
+    // * with the implicit bit restored (0 for zero values and subnormal values, 1 for normal values).
+    // * Also calculate the _Unbiased_exponent. This unifies the processing of zero, subnormal, and normal values.
+    _Uint_type _Adjusted_mantissa;
+
+    if constexpr (_IsSame<_Floating, float>::value) {
+        _Adjusted_mantissa = _Ieee_mantissa << 1; // align to hexit boundary (23 isn't divisible by 4)
+    } else {
+        _Adjusted_mantissa = _Ieee_mantissa; // already aligned (52 is divisible by 4)
+    }
+
+    int32_t _Unbiased_exponent;
+
+    if (_Ieee_exponent == 0) { // zero or subnormal
+        // implicit bit is 0
+
+        if (_Ieee_mantissa == 0) { // zero
+            // C11 7.21.6.1 "The fprintf function"/8: "If the value is zero, the exponent is zero."
+            _Unbiased_exponent = 0;
+        } else { // subnormal
+            _Unbiased_exponent = 1 - _Traits::_Exponent_bias;
+        }
+    } else { // normal
+        _Adjusted_mantissa |= _Uint_type{1} << _Adjusted_explicit_bits; // implicit bit is 1
+        _Unbiased_exponent = _Ieee_exponent - _Traits::_Exponent_bias;
+    }
+
+    // _Unbiased_exponent is within [-126, 127] for float, [-1022, 1023] for double.
+
+    // * Decompose _Unbiased_exponent into _Sign_character and _Absolute_exponent.
+    char _Sign_character;
+    uint32_t _Absolute_exponent;
+
+    if (_Unbiased_exponent < 0) {
+        _Sign_character    = '-';
+        _Absolute_exponent = static_cast<uint32_t>(-_Unbiased_exponent);
+    } else {
+        _Sign_character    = '+';
+        _Absolute_exponent = static_cast<uint32_t>(_Unbiased_exponent);
+    }
+
+    // _Absolute_exponent is within [0, 127] for float, [0, 1023] for double.
+
+    // * Perform a single bounds check.
+    {
+        int32_t _Exponent_length;
+
+        if (_Absolute_exponent < 10) {
+            _Exponent_length = 1;
+        } else if (_Absolute_exponent < 100) {
+            _Exponent_length = 2;
+        } else if constexpr (_IsSame<_Floating, float>::value) {
+            _Exponent_length = 3;
+        } else if (_Absolute_exponent < 1000) {
+            _Exponent_length = 3;
+        } else {
+            _Exponent_length = 4;
+        }
+
+        // _Precision might be enormous; avoid integer overflow by testing it separately.
+        ptrdiff_t _Buffer_size = _Last - _First;
+
+        if (_Buffer_size < _Precision) {
+            return {_Last, errc::value_too_large};
+        }
+
+        _Buffer_size -= _Precision;
+
+        const int32_t _Length_excluding_precision = 1 // leading hexit
+                                                    + static_cast<int32_t>(_Precision > 0) // possible decimal point
+                                                    // excluding `+ _Precision`, hexits after decimal point
+                                                    + 2 // "p+" or "p-"
+                                                    + _Exponent_length; // exponent
+
+        if (_Buffer_size < _Length_excluding_precision) {
+            return {_Last, errc::value_too_large};
+        }
+    }
+
+    // * Perform rounding when we've been asked to omit hexits.
+    if (_Precision < _Full_precision) {
+        // _Precision is within [0, 5] for float, [0, 12] for double.
+
+        // _Dropped_bits is within [4, 24] for float, [4, 52] for double.
+        const int _Dropped_bits = (_Full_precision - _Precision) * 4;
+
+        // Perform rounding by adding an appropriately-shifted bit.
+
+        // This can propagate carries all the way into the leading hexit. Examples:
+        // "0.ff9" rounded to a precision of 2 is "1.00".
+        // "1.ff9" rounded to a precision of 2 is "2.00".
+
+        // Note that the leading hexit participates in the rounding decision. Examples:
+        // "0.8" rounded to a precision of 0 is "0".
+        // "1.8" rounded to a precision of 0 is "2".
+
+        // Reference implementation with suboptimal codegen:
+        // bool _Should_round_up(bool _Lsb_bit, bool _Round_bit, bool _Has_tail_bits) {
+        //    // If there are no insignificant set bits, the value is exactly-representable and should not be rounded.
+        //    //
+        //    // If there are insignificant set bits, we need to round according to round_to_nearest.
+        //    // We need to handle two cases: we round up if either [1] the value is slightly greater
+        //    // than the midpoint between two exactly-representable values or [2] the value is exactly the midpoint
+        //    // between two exactly-representable values and the greater of the two is even (this is "round-to-even").
+        //    return _Round_bit && (_Has_tail_bits || _Lsb_bit);
+        //}
+        // const bool _Lsb_bit       = (_Adjusted_mantissa & (_Uint_type{1} << _Dropped_bits)) != 0;
+        // const bool _Round_bit     = (_Adjusted_mantissa & (_Uint_type{1} << (_Dropped_bits - 1))) != 0;
+        // const bool _Has_tail_bits = (_Adjusted_mantissa & ((_Uint_type{1} << (_Dropped_bits - 1)) - 1)) != 0;
+        // const bool _Should_round = _Should_round_up(_Lsb_bit, _Round_bit, _Has_tail_bits);
+        // _Adjusted_mantissa += _Uint_type{_Should_round} << _Dropped_bits;
+
+        // Example for optimized implementation: Let _Dropped_bits be 8.
+        //          Bit index: ...[8]76543210
+        // _Adjusted_mantissa: ...[L]RTTTTTTT (not depicting known details, like hexit alignment)
+        // By focusing on the bit at index _Dropped_bits, we can avoid unnecessary branching and shifting.
+
+        // Bit index: ...[8]76543210
+        //  _Lsb_bit: ...[L]RTTTTTTT
+        const _Uint_type _Lsb_bit = _Adjusted_mantissa;
+
+        //  Bit index: ...9[8]76543210
+        // _Round_bit: ...L[R]TTTTTTT0
+        const _Uint_type _Round_bit = _Adjusted_mantissa << 1;
+
+        // We can detect (without branching) whether any of the trailing bits are set.
+        // Due to _Should_round below, this computation will be used if and only if R is 1, so we can assume that here.
+        //      Bit index: ...9[8]76543210
+        //     _Round_bit: ...L[1]TTTTTTT0
+        // _Has_tail_bits: ....[H]........
+
+        // If all of the trailing bits T are 0, then `_Round_bit - 1` will produce 0 for H (due to R being 1).
+        // If any of the trailing bits T are 1, then `_Round_bit - 1` will produce 1 for H (due to R being 1).
+        const _Uint_type _Has_tail_bits = _Round_bit - 1;
+
+        // Finally, we can use _Should_round_up() logic with bitwise-AND and bitwise-OR,
+        // selecting just the bit at index _Dropped_bits. This is the appropriately-shifted bit that we want.
+        const _Uint_type _Should_round = _Round_bit & (_Has_tail_bits | _Lsb_bit) & (_Uint_type{1} << _Dropped_bits);
+
+        // This rounding technique is dedicated to the memory of Peppermint. =^..^=
+        _Adjusted_mantissa += _Should_round;
+    }
+
+    // * Print the leading hexit, then mask it away.
+    {
+        const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Adjusted_explicit_bits);
+        _LIBCPP_ASSERT_INTERNAL(_Nibble < 3, "");
+        const char _Leading_hexit = static_cast<char>('0' + _Nibble);
+
+        *_First++ = _Leading_hexit;
+
+        constexpr _Uint_type _Mask = (_Uint_type{1} << _Adjusted_explicit_bits) - 1;
+        _Adjusted_mantissa &= _Mask;
+    }
+
+    // * Print the decimal point and trailing hexits.
+
+    // C11 7.21.6.1 "The fprintf function"/8:
+    // "if the precision is zero and the # flag is not specified, no decimal-point character appears."
+    if (_Precision > 0) {
+        *_First++ = '.';
+
+        int32_t _Number_of_bits_remaining = _Adjusted_explicit_bits; // 24 for float, 52 for double
+
+        for (;;) {
+            _LIBCPP_ASSERT_INTERNAL(_Number_of_bits_remaining >= 4, "");
+            _LIBCPP_ASSERT_INTERNAL(_Number_of_bits_remaining % 4 == 0, "");
+            _Number_of_bits_remaining -= 4;
+
+            const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Number_of_bits_remaining);
+            _LIBCPP_ASSERT_INTERNAL(_Nibble < 16, "");
+            const char _Hexit = __itoa::_Charconv_digits[_Nibble];
+
+            *_First++ = _Hexit;
+
+            // _Precision is the number of hexits that still need to be printed.
+            --_Precision;
+            if (_Precision == 0) {
+                break; // We're completely done with this phase.
+            }
+            // Otherwise, we need to keep printing hexits.
+
+            if (_Number_of_bits_remaining == 0) {
+                // We've finished printing _Adjusted_mantissa, so all remaining hexits are '0'.
+                std::memset(_First, '0', static_cast<size_t>(_Precision));
+                _First += _Precision;
+                break;
+            }
+
+            // Mask away the hexit that we just printed, then keep looping.
+            // (We skip this when breaking out of the loop above, because _Adjusted_mantissa isn't used later.)
+            const _Uint_type _Mask = (_Uint_type{1} << _Number_of_bits_remaining) - 1;
+            _Adjusted_mantissa &= _Mask;
+        }
+    }
+
+    // * Print the exponent.
+
+    // C11 7.21.6.1 "The fprintf function"/8: "The exponent always contains at least one digit, and only as many more
+    // digits as necessary to represent the decimal exponent of 2."
+
+    // Performance note: We should take advantage of the known ranges of possible exponents.
+
+    *_First++ = 'p';
+    *_First++ = _Sign_character;
+
+    // We've already printed '-' if necessary, so uint32_t _Absolute_exponent avoids testing that again.
+    return std::to_chars(_First, _Last, _Absolute_exponent);
+}
+
+template <class _Floating>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+to_chars_result _Floating_to_chars_hex_shortest(
+    char* _First, char* const _Last, const _Floating _Value) noexcept {
+
+    // This prints "1.728p+0" instead of "2.e5p-1".
+    // This prints "0.000002p-126" instead of "1p-149" for float.
+    // This prints "0.0000000000001p-1022" instead of "1p-1074" for double.
+    // This prioritizes being consistent with printf's de facto behavior (and hex-precision's behavior)
+    // over minimizing the number of characters printed.
+
+    using _Traits    = _Floating_type_traits<_Floating>;
+    using _Uint_type = typename _Traits::_Uint_type;
+
+    const _Uint_type _Uint_value = std::bit_cast<_Uint_type>(_Value);
+
+    if (_Uint_value == 0) { // zero detected; write "0p+0" and return
+        // C11 7.21.6.1 "The fprintf function"/8: "If the value is zero, the exponent is zero."
+        // Special-casing zero is necessary because of the exponent.
+        const char* const _Str = "0p+0";
+        const size_t _Len      = 4;
+
+        if (_Last - _First < static_cast<ptrdiff_t>(_Len)) {
+            return {_Last, errc::value_too_large};
+        }
+
+        std::memcpy(_First, _Str, _Len);
+
+        return {_First + _Len, errc{}};
+    }
+
+    const _Uint_type _Ieee_mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
+    const int32_t _Ieee_exponent    = static_cast<int32_t>(_Uint_value >> _Traits::_Exponent_shift);
+
+    char _Leading_hexit; // implicit bit
+    int32_t _Unbiased_exponent;
+
+    if (_Ieee_exponent == 0) { // subnormal
+        _Leading_hexit     = '0';
+        _Unbiased_exponent = 1 - _Traits::_Exponent_bias;
+    } else { // normal
+        _Leading_hexit     = '1';
+        _Unbiased_exponent = _Ieee_exponent - _Traits::_Exponent_bias;
+    }
+
+    // Performance note: Consider avoiding per-character bounds checking when there's plenty of space.
+
+    if (_First == _Last) {
+        return {_Last, errc::value_too_large};
+    }
+
+    *_First++ = _Leading_hexit;
+
+    if (_Ieee_mantissa == 0) {
+        // The fraction bits are all 0. Trim them away, including the decimal point.
+    } else {
+        if (_First == _Last) {
+            return {_Last, errc::value_too_large};
+        }
+
+        *_First++ = '.';
+
+        // The hexits after the decimal point correspond to the explicitly stored fraction bits.
+        // float explicitly stores 23 fraction bits. 23 / 4 == 5.75, so we'll print at most 6 hexits.
+        // double explicitly stores 52 fraction bits. 52 / 4 == 13, so we'll print at most 13 hexits.
+        _Uint_type _Adjusted_mantissa;
+        int32_t _Number_of_bits_remaining;
+
+        if constexpr (_IsSame<_Floating, float>::value) {
+            _Adjusted_mantissa        = _Ieee_mantissa << 1; // align to hexit boundary (23 isn't divisible by 4)
+            _Number_of_bits_remaining = 24; // 23 fraction bits + 1 alignment bit
+        } else {
+            _Adjusted_mantissa        = _Ieee_mantissa; // already aligned (52 is divisible by 4)
+            _Number_of_bits_remaining = 52; // 52 fraction bits
+        }
+
+        // do-while: The condition _Adjusted_mantissa != 0 is initially true - we have nonzero fraction bits and we've
+        // printed the decimal point. Each iteration, we print a hexit, mask it away, and keep looping if we still have
+        // nonzero fraction bits. If there would be trailing '0' hexits, this trims them. If there wouldn't be trailing
+        // '0' hexits, the same condition works (as we print the final hexit and mask it away); we don't need to test
+        // _Number_of_bits_remaining.
+        do {
+            _LIBCPP_ASSERT_INTERNAL(_Number_of_bits_remaining >= 4, "");
+            _LIBCPP_ASSERT_INTERNAL(_Number_of_bits_remaining % 4 == 0, "");
+            _Number_of_bits_remaining -= 4;
+
+            const uint32_t _Nibble = static_cast<uint32_t>(_Adjusted_mantissa >> _Number_of_bits_remaining);
+            _LIBCPP_ASSERT_INTERNAL(_Nibble < 16, "");
+            const char _Hexit = __itoa::_Charconv_digits[_Nibble];
+
+            if (_First == _Last) {
+                return {_Last, errc::value_too_large};
+            }
+
+            *_First++ = _Hexit;
+
+            const _Uint_type _Mask = (_Uint_type{1} << _Number_of_bits_remaining) - 1;
+            _Adjusted_mantissa &= _Mask;
+
+        } while (_Adjusted_mantissa != 0);
+    }
+
+    // C11 7.21.6.1 "The fprintf function"/8: "The exponent always contains at least one digit, and only as many more
+    // digits as necessary to represent the decimal exponent of 2."
+
+    // Performance note: We should take advantage of the known ranges of possible exponents.
+
+    // float: _Unbiased_exponent is within [-126, 127].
+    // double: _Unbiased_exponent is within [-1022, 1023].
+
+    if (_Last - _First < 2) {
+        return {_Last, errc::value_too_large};
+    }
+
+    *_First++ = 'p';
+
+    if (_Unbiased_exponent < 0) {
+        *_First++          = '-';
+        _Unbiased_exponent = -_Unbiased_exponent;
+    } else {
+        *_First++ = '+';
+    }
+
+    // We've already printed '-' if necessary, so static_cast<uint32_t> avoids testing that again.
+    return std::to_chars(_First, _Last, static_cast<uint32_t>(_Unbiased_exponent));
+}
+
+// For general precision, we can use lookup tables to avoid performing trial formatting.
+
+// For a simple example, imagine counting the number of digits D in an integer, and needing to know
+// whether D is less than 3, equal to 3/4/5/6, or greater than 6. We could use a lookup table:
+// D | Largest integer with D digits
+// 2 |      99
+// 3 |     999
+// 4 |   9'999
+// 5 |  99'999
+// 6 | 999'999
+// 7 | table end
+// Looking up an integer in this table with lower_bound() will work:
+// * Too-small integers, like 7, 70, and 99, will cause lower_bound() to return the D == 2 row. (If all we care
+//   about is whether D is less than 3, then it's okay to smash the D == 1 and D == 2 cases together.)
+// * Integers in [100, 999] will cause lower_bound() to return the D == 3 row, and so forth.
+// * Too-large integers, like 1'000'000 and above, will cause lower_bound() to return the end of the table. If we
+//   compute D from that index, this will be considered D == 7, which will activate any "greater than 6" logic.
+
+// Floating-point is slightly more complicated.
+
+// The ordinary lookup tables are for X within [-5, 38] for float, and [-5, 308] for double.
+// (-5 absorbs too-negative exponents, outside the P > X >= -4 criterion. 38 and 308 are the maximum exponents.)
+// Due to the P > X condition, we can use a subset of the table for X within [-5, P - 1], suitably clamped.
+
+// When P is small, rounding can affect X. For example:
+// For P == 1, the largest double with X == 0 is: 9.4999999999999982236431605997495353221893310546875
+// For P == 2, the largest double with X == 0 is: 9.949999999999999289457264239899814128875732421875
+// For P == 3, the largest double with X == 0 is: 9.9949999999999992184029906638897955417633056640625
+
+// Exponent adjustment is a concern for P within [1, 7] for float, and [1, 15] for double (determined via
+// brute force). While larger values of P still perform rounding, they can't trigger exponent adjustment.
+// This is because only values with repeated '9' digits can undergo exponent adjustment during rounding,
+// and floating-point granularity limits the number of consecutive '9' digits that can appear.
+
+// So, we need special lookup tables for small values of P.
+// These tables have varying lengths due to the P > X >= -4 criterion. For example:
+// For P == 1, need table entries for X: -5, -4, -3, -2, -1, 0
+// For P == 2, need table entries for X: -5, -4, -3, -2, -1, 0, 1
+// For P == 3, need table entries for X: -5, -4, -3, -2, -1, 0, 1, 2
+// For P == 4, need table entries for X: -5, -4, -3, -2, -1, 0, 1, 2, 3
+
+// We can concatenate these tables for compact storage, using triangular numbers to access them.
+// The table for P begins at index (P - 1) * (P + 10) / 2 with length P + 5.
+
+// For both the ordinary and special lookup tables, after an index I is returned by lower_bound(), X is I - 5.
+
+// We need to special-case the floating-point value 0.0, which is considered to have X == 0.
+// Otherwise, the lookup tables would consider it to have a highly negative X.
+
+// Finally, because we're working with positive floating-point values,
+// representation comparisons behave identically to floating-point comparisons.
+
+// The following code generated the lookup tables for the scientific exponent X. Don't remove this code.
+#if 0
+// cl /EHsc /nologo /W4 /MT /O2 /std:c++17 generate_tables.cpp && generate_tables
+
+#include <algorithm>
+#include <assert.h>
+#include <charconv>
+#include <cmath>
+#include <limits>
+#include <map>
+#include <stdint.h>
+#include <stdio.h>
+#include <system_error>
+#include <type_traits>
+#include <vector>
+using namespace std;
+
+template <typename UInt, typename Pred>
+[[nodiscard]] UInt uint_partition_point(UInt first, const UInt last, Pred pred) {
+    // Find the beginning of the false partition in [first, last).
+    // [first, last) is partitioned when all of the true values occur before all of the false values.
+
+    static_assert(is_unsigned_v<UInt>);
+    assert(first <= last);
+
+    for (UInt n = last - first; n > 0;) {
+        const UInt n2  = n / 2;
+        const UInt mid = first + n2;
+
+        if (pred(mid)) {
+            first = mid + 1;
+            n     = n - n2 - 1;
+        } else {
+            n = n2;
+        }
+    }
+
+    return first;
+}
+
+template <typename Floating>
+[[nodiscard]] int scientific_exponent_X(const int P, const Floating flt) {
+    char buf[400]; // more than enough
+
+    // C11 7.21.6.1 "The fprintf function"/8 performs trial formatting with scientific precision P - 1.
+    const auto to_result = to_chars(buf, end(buf), flt, chars_format::scientific, P - 1);
+    assert(to_result.ec == errc{});
+
+    const char* exp_ptr = find(buf, to_result.ptr, 'e');
+    assert(exp_ptr != to_result.ptr);
+
+    ++exp_ptr; // advance past 'e'
+
+    if (*exp_ptr == '+') {
+        ++exp_ptr; // advance past '+' which from_chars() won't parse
+    }
+
+    int X;
+    const auto from_result = from_chars(exp_ptr, to_result.ptr, X);
+    assert(from_result.ec == errc{});
+    return X;
+}
+
+template <typename UInt>
+void print_table(const vector<UInt>& v, const char* const name) {
+    constexpr const char* UIntName = _IsSame<UInt, uint32_t>::value ? "uint32_t" : "uint64_t";
+
+    printf("static constexpr %s %s[%zu] = {\n", UIntName, name, v.size());
+
+    for (const auto& val : v) {
+        if constexpr (_IsSame<UInt, uint32_t>::value) {
+            printf("0x%08Xu,\n", val);
+        } else {
+            printf("0x%016llXu,\n", val);
+        }
+    }
+
+    printf("};\n");
+}
+
+enum class Mode { Tables, Tests };
+
+template <typename Floating>
+void generate_tables(const Mode mode) {
+    using Limits = numeric_limits<Floating>;
+    using UInt   = conditional_t<_IsSame<Floating, float>::value, uint32_t, uint64_t>;
+
+    map<int, map<int, UInt>> P_X_LargestValWithX;
+
+    constexpr int MaxP = Limits::max_exponent10 + 1; // MaxP performs no rounding during trial formatting
+
+    for (int P = 1; P <= MaxP; ++P) {
+        for (int X = -5; X < P; ++X) {
+            constexpr Floating first = static_cast<Floating>(9e-5); // well below 9.5e-5, otherwise arbitrary
+            constexpr Floating last  = Limits::infinity(); // one bit above Limits::max()
+
+            const UInt val_beyond_X = uint_partition_point(reinterpret_cast<const UInt&>(first),
+                reinterpret_cast<const UInt&>(last),
+                [P, X](const UInt u) { return scientific_exponent_X(P, reinterpret_cast<const Floating&>(u)) <= X; });
+
+            P_X_LargestValWithX[P][X] = val_beyond_X - 1;
+        }
+    }
+
+    constexpr const char* FloatingName = _IsSame<Floating, float>::value ? "float" : "double";
+
+    constexpr int MaxSpecialP = _IsSame<Floating, float>::value ? 7 : 15; // MaxSpecialP is affected by exponent adjustment
+
+    if (mode == Mode::Tables) {
+        printf("template <>\n");
+        printf("struct _General_precision_tables<%s> {\n", FloatingName);
+
+        printf("static constexpr int _Max_special_P = %d;\n", MaxSpecialP);
+
+        vector<UInt> special;
+
+        for (int P = 1; P <= MaxSpecialP; ++P) {
+            for (int X = -5; X < P; ++X) {
+                const UInt val = P_X_LargestValWithX[P][X];
+                special.push_back(val);
+            }
+        }
+
+        print_table(special, "_Special_X_table");
+
+        for (int P = MaxSpecialP + 1; P < MaxP; ++P) {
+            for (int X = -5; X < P; ++X) {
+                const UInt val = P_X_LargestValWithX[P][X];
+                assert(val == P_X_LargestValWithX[MaxP][X]);
+            }
+        }
+
+        printf("static constexpr int _Max_P = %d;\n", MaxP);
+
+        vector<UInt> ordinary;
+
+        for (int X = -5; X < MaxP; ++X) {
+            const UInt val = P_X_LargestValWithX[MaxP][X];
+            ordinary.push_back(val);
+        }
+
+        print_table(ordinary, "_Ordinary_X_table");
+
+        printf("};\n");
+    } else {
+        printf("==========\n");
+        printf("Test cases for %s:\n", FloatingName);
+
+        constexpr int Hexits         = _IsSame<Floating, float>::value ? 6 : 13;
+        constexpr const char* Suffix = _IsSame<Floating, float>::value ? "f" : "";
+
+        for (int P = 1; P <= MaxP; ++P) {
+            for (int X = -5; X < P; ++X) {
+                if (P <= MaxSpecialP || P == 25 || P == MaxP || X == P - 1) {
+                    const UInt val1   = P_X_LargestValWithX[P][X];
+                    const Floating f1 = reinterpret_cast<const Floating&>(val1);
+                    const UInt val2   = val1 + 1;
+                    const Floating f2 = reinterpret_cast<const Floating&>(val2);
+
+                    printf("{%.*a%s, chars_format::general, %d, \"%.*g\"},\n", Hexits, f1, Suffix, P, P, f1);
+                    if (isfinite(f2)) {
+                        printf("{%.*a%s, chars_format::general, %d, \"%.*g\"},\n", Hexits, f2, Suffix, P, P, f2);
+                    }
+                }
+            }
+        }
+    }
+}
+
+int main() {
+    printf("template <class _Floating>\n");
+    printf("struct _General_precision_tables;\n");
+    generate_tables<float>(Mode::Tables);
+    generate_tables<double>(Mode::Tables);
+    generate_tables<float>(Mode::Tests);
+    generate_tables<double>(Mode::Tests);
+}
+#endif // 0
+
+template <class _Floating>
+struct _General_precision_tables;
+
+template <>
+struct _General_precision_tables<float> {
+    static constexpr int _Max_special_P = 7;
+
+    static constexpr uint32_t _Special_X_table[63] = {0x38C73ABCu, 0x3A79096Bu, 0x3C1BA5E3u, 0x3DC28F5Cu, 0x3F733333u,
+        0x4117FFFFu, 0x38D0AAA7u, 0x3A826AA8u, 0x3C230553u, 0x3DCBC6A7u, 0x3F7EB851u, 0x411F3333u, 0x42C6FFFFu,
+        0x38D19C3Fu, 0x3A8301A7u, 0x3C23C211u, 0x3DCCB295u, 0x3F7FDF3Bu, 0x411FEB85u, 0x42C7E666u, 0x4479DFFFu,
+        0x38D1B468u, 0x3A8310C1u, 0x3C23D4F1u, 0x3DCCCA2Du, 0x3F7FFCB9u, 0x411FFDF3u, 0x42C7FD70u, 0x4479FCCCu,
+        0x461C3DFFu, 0x38D1B6D2u, 0x3A831243u, 0x3C23D6D4u, 0x3DCCCC89u, 0x3F7FFFACu, 0x411FFFCBu, 0x42C7FFBEu,
+        0x4479FFAEu, 0x461C3FCCu, 0x47C34FBFu, 0x38D1B710u, 0x3A83126Au, 0x3C23D704u, 0x3DCCCCC6u, 0x3F7FFFF7u,
+        0x411FFFFAu, 0x42C7FFF9u, 0x4479FFF7u, 0x461C3FFAu, 0x47C34FF9u, 0x497423F7u, 0x38D1B716u, 0x3A83126Eu,
+        0x3C23D709u, 0x3DCCCCCCu, 0x3F7FFFFFu, 0x411FFFFFu, 0x42C7FFFFu, 0x4479FFFFu, 0x461C3FFFu, 0x47C34FFFu,
+        0x497423FFu, 0x4B18967Fu};
+
+    static constexpr int _Max_P = 39;
+
+    static constexpr uint32_t _Ordinary_X_table[44] = {0x38D1B717u, 0x3A83126Eu, 0x3C23D70Au, 0x3DCCCCCCu, 0x3F7FFFFFu,
+        0x411FFFFFu, 0x42C7FFFFu, 0x4479FFFFu, 0x461C3FFFu, 0x47C34FFFu, 0x497423FFu, 0x4B18967Fu, 0x4CBEBC1Fu,
+        0x4E6E6B27u, 0x501502F8u, 0x51BA43B7u, 0x5368D4A5u, 0x551184E7u, 0x56B5E620u, 0x58635FA9u, 0x5A0E1BC9u,
+        0x5BB1A2BCu, 0x5D5E0B6Bu, 0x5F0AC723u, 0x60AD78EBu, 0x6258D726u, 0x64078678u, 0x65A96816u, 0x6753C21Bu,
+        0x69045951u, 0x6AA56FA5u, 0x6C4ECB8Fu, 0x6E013F39u, 0x6FA18F07u, 0x7149F2C9u, 0x72FC6F7Cu, 0x749DC5ADu,
+        0x76453719u, 0x77F684DFu, 0x799A130Bu, 0x7B4097CEu, 0x7CF0BDC2u, 0x7E967699u, 0x7F7FFFFFu};
+};
+
+template <>
+struct _General_precision_tables<double> {
+    static constexpr int _Max_special_P = 15;
+
+    static constexpr uint64_t _Special_X_table[195] = {0x3F18E757928E0C9Du, 0x3F4F212D77318FC5u, 0x3F8374BC6A7EF9DBu,
+        0x3FB851EB851EB851u, 0x3FEE666666666666u, 0x4022FFFFFFFFFFFFu, 0x3F1A1554FBDAD751u, 0x3F504D551D68C692u,
+        0x3F8460AA64C2F837u, 0x3FB978D4FDF3B645u, 0x3FEFD70A3D70A3D7u, 0x4023E66666666666u, 0x4058DFFFFFFFFFFFu,
+        0x3F1A3387ECC8EB96u, 0x3F506034F3FD933Eu, 0x3F84784230FCF80Du, 0x3FB99652BD3C3611u, 0x3FEFFBE76C8B4395u,
+        0x4023FD70A3D70A3Du, 0x4058FCCCCCCCCCCCu, 0x408F3BFFFFFFFFFFu, 0x3F1A368D04E0BA6Au, 0x3F506218230C7482u,
+        0x3F847A9E2BCF91A3u, 0x3FB99945B6C3760Bu, 0x3FEFFF972474538Eu, 0x4023FFBE76C8B439u, 0x4058FFAE147AE147u,
+        0x408F3F9999999999u, 0x40C387BFFFFFFFFFu, 0x3F1A36DA54164F19u, 0x3F506248748DF16Fu, 0x3F847ADA91B16DCBu,
+        0x3FB99991361DC93Eu, 0x3FEFFFF583A53B8Eu, 0x4023FFF972474538u, 0x4058FFF7CED91687u, 0x408F3FF5C28F5C28u,
+        0x40C387F999999999u, 0x40F869F7FFFFFFFFu, 0x3F1A36E20F35445Du, 0x3F50624D49814ABAu, 0x3F847AE09BE19D69u,
+        0x3FB99998C2DA04C3u, 0x3FEFFFFEF39085F4u, 0x4023FFFF583A53B8u, 0x4058FFFF2E48E8A7u, 0x408F3FFEF9DB22D0u,
+        0x40C387FF5C28F5C2u, 0x40F869FF33333333u, 0x412E847EFFFFFFFFu, 0x3F1A36E2D51EC34Bu, 0x3F50624DC5333A0Eu,
+        0x3F847AE136800892u, 0x3FB9999984200AB7u, 0x3FEFFFFFE5280D65u, 0x4023FFFFEF39085Fu, 0x4058FFFFEB074A77u,
+        0x408F3FFFE5C91D14u, 0x40C387FFEF9DB22Du, 0x40F869FFEB851EB8u, 0x412E847FE6666666u, 0x416312CFEFFFFFFFu,
+        0x3F1A36E2E8E94FFCu, 0x3F50624DD191D1FDu, 0x3F847AE145F6467Du, 0x3FB999999773D81Cu, 0x3FEFFFFFFD50CE23u,
+        0x4023FFFFFE5280D6u, 0x4058FFFFFDE7210Bu, 0x408F3FFFFD60E94Eu, 0x40C387FFFE5C91D1u, 0x40F869FFFDF3B645u,
+        0x412E847FFD70A3D7u, 0x416312CFFE666666u, 0x4197D783FDFFFFFFu, 0x3F1A36E2EAE3F7A7u, 0x3F50624DD2CE7AC8u,
+        0x3F847AE14782197Bu, 0x3FB9999999629FD9u, 0x3FEFFFFFFFBB47D0u, 0x4023FFFFFFD50CE2u, 0x4058FFFFFFCA501Au,
+        0x408F3FFFFFBCE421u, 0x40C387FFFFD60E94u, 0x40F869FFFFCB923Au, 0x412E847FFFBE76C8u, 0x416312CFFFD70A3Du,
+        0x4197D783FFCCCCCCu, 0x41CDCD64FFBFFFFFu, 0x3F1A36E2EB16A205u, 0x3F50624DD2EE2543u, 0x3F847AE147A9AE94u,
+        0x3FB9999999941A39u, 0x3FEFFFFFFFF920C8u, 0x4023FFFFFFFBB47Du, 0x4058FFFFFFFAA19Cu, 0x408F3FFFFFF94A03u,
+        0x40C387FFFFFBCE42u, 0x40F869FFFFFAC1D2u, 0x412E847FFFF97247u, 0x416312CFFFFBE76Cu, 0x4197D783FFFAE147u,
+        0x41CDCD64FFF99999u, 0x4202A05F1FFBFFFFu, 0x3F1A36E2EB1BB30Fu, 0x3F50624DD2F14FE9u, 0x3F847AE147ADA3E3u,
+        0x3FB9999999990CDCu, 0x3FEFFFFFFFFF5014u, 0x4023FFFFFFFF920Cu, 0x4058FFFFFFFF768Fu, 0x408F3FFFFFFF5433u,
+        0x40C387FFFFFF94A0u, 0x40F869FFFFFF79C8u, 0x412E847FFFFF583Au, 0x416312CFFFFF9724u, 0x4197D783FFFF7CEDu,
+        0x41CDCD64FFFF5C28u, 0x4202A05F1FFF9999u, 0x42374876E7FF7FFFu, 0x3F1A36E2EB1C34C3u, 0x3F50624DD2F1A0FAu,
+        0x3F847AE147AE0938u, 0x3FB9999999998B86u, 0x3FEFFFFFFFFFEE68u, 0x4023FFFFFFFFF501u, 0x4058FFFFFFFFF241u,
+        0x408F3FFFFFFFEED1u, 0x40C387FFFFFFF543u, 0x40F869FFFFFFF294u, 0x412E847FFFFFEF39u, 0x416312CFFFFFF583u,
+        0x4197D783FFFFF2E4u, 0x41CDCD64FFFFEF9Du, 0x4202A05F1FFFF5C2u, 0x42374876E7FFF333u, 0x426D1A94A1FFEFFFu,
+        0x3F1A36E2EB1C41BBu, 0x3F50624DD2F1A915u, 0x3F847AE147AE135Au, 0x3FB9999999999831u, 0x3FEFFFFFFFFFFE3Du,
+        0x4023FFFFFFFFFEE6u, 0x4058FFFFFFFFFEA0u, 0x408F3FFFFFFFFE48u, 0x40C387FFFFFFFEEDu, 0x40F869FFFFFFFEA8u,
+        0x412E847FFFFFFE52u, 0x416312CFFFFFFEF3u, 0x4197D783FFFFFEB0u, 0x41CDCD64FFFFFE5Cu, 0x4202A05F1FFFFEF9u,
+        0x42374876E7FFFEB8u, 0x426D1A94A1FFFE66u, 0x42A2309CE53FFEFFu, 0x3F1A36E2EB1C4307u, 0x3F50624DD2F1A9E4u,
+        0x3F847AE147AE145Eu, 0x3FB9999999999975u, 0x3FEFFFFFFFFFFFD2u, 0x4023FFFFFFFFFFE3u, 0x4058FFFFFFFFFFDCu,
+        0x408F3FFFFFFFFFD4u, 0x40C387FFFFFFFFE4u, 0x40F869FFFFFFFFDDu, 0x412E847FFFFFFFD5u, 0x416312CFFFFFFFE5u,
+        0x4197D783FFFFFFDEu, 0x41CDCD64FFFFFFD6u, 0x4202A05F1FFFFFE5u, 0x42374876E7FFFFDFu, 0x426D1A94A1FFFFD7u,
+        0x42A2309CE53FFFE6u, 0x42D6BCC41E8FFFDFu, 0x3F1A36E2EB1C4328u, 0x3F50624DD2F1A9F9u, 0x3F847AE147AE1477u,
+        0x3FB9999999999995u, 0x3FEFFFFFFFFFFFFBu, 0x4023FFFFFFFFFFFDu, 0x4058FFFFFFFFFFFCu, 0x408F3FFFFFFFFFFBu,
+        0x40C387FFFFFFFFFDu, 0x40F869FFFFFFFFFCu, 0x412E847FFFFFFFFBu, 0x416312CFFFFFFFFDu, 0x4197D783FFFFFFFCu,
+        0x41CDCD64FFFFFFFBu, 0x4202A05F1FFFFFFDu, 0x42374876E7FFFFFCu, 0x426D1A94A1FFFFFBu, 0x42A2309CE53FFFFDu,
+        0x42D6BCC41E8FFFFCu, 0x430C6BF52633FFFBu};
+
+    static constexpr int _Max_P = 309;
+
+    static constexpr uint64_t _Ordinary_X_table[314] = {0x3F1A36E2EB1C432Cu, 0x3F50624DD2F1A9FBu, 0x3F847AE147AE147Au,
+        0x3FB9999999999999u, 0x3FEFFFFFFFFFFFFFu, 0x4023FFFFFFFFFFFFu, 0x4058FFFFFFFFFFFFu, 0x408F3FFFFFFFFFFFu,
+        0x40C387FFFFFFFFFFu, 0x40F869FFFFFFFFFFu, 0x412E847FFFFFFFFFu, 0x416312CFFFFFFFFFu, 0x4197D783FFFFFFFFu,
+        0x41CDCD64FFFFFFFFu, 0x4202A05F1FFFFFFFu, 0x42374876E7FFFFFFu, 0x426D1A94A1FFFFFFu, 0x42A2309CE53FFFFFu,
+        0x42D6BCC41E8FFFFFu, 0x430C6BF52633FFFFu, 0x4341C37937E07FFFu, 0x4376345785D89FFFu, 0x43ABC16D674EC7FFu,
+        0x43E158E460913CFFu, 0x4415AF1D78B58C3Fu, 0x444B1AE4D6E2EF4Fu, 0x4480F0CF064DD591u, 0x44B52D02C7E14AF6u,
+        0x44EA784379D99DB4u, 0x45208B2A2C280290u, 0x4554ADF4B7320334u, 0x4589D971E4FE8401u, 0x45C027E72F1F1281u,
+        0x45F431E0FAE6D721u, 0x46293E5939A08CE9u, 0x465F8DEF8808B024u, 0x4693B8B5B5056E16u, 0x46C8A6E32246C99Cu,
+        0x46FED09BEAD87C03u, 0x4733426172C74D82u, 0x476812F9CF7920E2u, 0x479E17B84357691Bu, 0x47D2CED32A16A1B1u,
+        0x48078287F49C4A1Du, 0x483D6329F1C35CA4u, 0x48725DFA371A19E6u, 0x48A6F578C4E0A060u, 0x48DCB2D6F618C878u,
+        0x4911EFC659CF7D4Bu, 0x49466BB7F0435C9Eu, 0x497C06A5EC5433C6u, 0x49B18427B3B4A05Bu, 0x49E5E531A0A1C872u,
+        0x4A1B5E7E08CA3A8Fu, 0x4A511B0EC57E6499u, 0x4A8561D276DDFDC0u, 0x4ABABA4714957D30u, 0x4AF0B46C6CDD6E3Eu,
+        0x4B24E1878814C9CDu, 0x4B5A19E96A19FC40u, 0x4B905031E2503DA8u, 0x4BC4643E5AE44D12u, 0x4BF97D4DF19D6057u,
+        0x4C2FDCA16E04B86Du, 0x4C63E9E4E4C2F344u, 0x4C98E45E1DF3B015u, 0x4CCF1D75A5709C1Au, 0x4D03726987666190u,
+        0x4D384F03E93FF9F4u, 0x4D6E62C4E38FF872u, 0x4DA2FDBB0E39FB47u, 0x4DD7BD29D1C87A19u, 0x4E0DAC74463A989Fu,
+        0x4E428BC8ABE49F63u, 0x4E772EBAD6DDC73Cu, 0x4EACFA698C95390Bu, 0x4EE21C81F7DD43A7u, 0x4F16A3A275D49491u,
+        0x4F4C4C8B1349B9B5u, 0x4F81AFD6EC0E1411u, 0x4FB61BCCA7119915u, 0x4FEBA2BFD0D5FF5Bu, 0x502145B7E285BF98u,
+        0x50559725DB272F7Fu, 0x508AFCEF51F0FB5Eu, 0x50C0DE1593369D1Bu, 0x50F5159AF8044462u, 0x512A5B01B605557Au,
+        0x516078E111C3556Cu, 0x5194971956342AC7u, 0x51C9BCDFABC13579u, 0x5200160BCB58C16Cu, 0x52341B8EBE2EF1C7u,
+        0x526922726DBAAE39u, 0x529F6B0F092959C7u, 0x52D3A2E965B9D81Cu, 0x53088BA3BF284E23u, 0x533EAE8CAEF261ACu,
+        0x53732D17ED577D0Bu, 0x53A7F85DE8AD5C4Eu, 0x53DDF67562D8B362u, 0x5412BA095DC7701Du, 0x5447688BB5394C25u,
+        0x547D42AEA2879F2Eu, 0x54B249AD2594C37Cu, 0x54E6DC186EF9F45Cu, 0x551C931E8AB87173u, 0x5551DBF316B346E7u,
+        0x558652EFDC6018A1u, 0x55BBE7ABD3781ECAu, 0x55F170CB642B133Eu, 0x5625CCFE3D35D80Eu, 0x565B403DCC834E11u,
+        0x569108269FD210CBu, 0x56C54A3047C694FDu, 0x56FA9CBC59B83A3Du, 0x5730A1F5B8132466u, 0x5764CA732617ED7Fu,
+        0x5799FD0FEF9DE8DFu, 0x57D03E29F5C2B18Bu, 0x58044DB473335DEEu, 0x583961219000356Au, 0x586FB969F40042C5u,
+        0x58A3D3E2388029BBu, 0x58D8C8DAC6A0342Au, 0x590EFB1178484134u, 0x59435CEAEB2D28C0u, 0x59783425A5F872F1u,
+        0x59AE412F0F768FADu, 0x59E2E8BD69AA19CCu, 0x5A17A2ECC414A03Fu, 0x5A4D8BA7F519C84Fu, 0x5A827748F9301D31u,
+        0x5AB7151B377C247Eu, 0x5AECDA62055B2D9Du, 0x5B22087D4358FC82u, 0x5B568A9C942F3BA3u, 0x5B8C2D43B93B0A8Bu,
+        0x5BC19C4A53C4E697u, 0x5BF6035CE8B6203Du, 0x5C2B843422E3A84Cu, 0x5C6132A095CE492Fu, 0x5C957F48BB41DB7Bu,
+        0x5CCADF1AEA12525Au, 0x5D00CB70D24B7378u, 0x5D34FE4D06DE5056u, 0x5D6A3DE04895E46Cu, 0x5DA066AC2D5DAEC3u,
+        0x5DD4805738B51A74u, 0x5E09A06D06E26112u, 0x5E400444244D7CABu, 0x5E7405552D60DBD6u, 0x5EA906AA78B912CBu,
+        0x5EDF485516E7577Eu, 0x5F138D352E5096AFu, 0x5F48708279E4BC5Au, 0x5F7E8CA3185DEB71u, 0x5FB317E5EF3AB327u,
+        0x5FE7DDDF6B095FF0u, 0x601DD55745CBB7ECu, 0x6052A5568B9F52F4u, 0x60874EAC2E8727B1u, 0x60BD22573A28F19Du,
+        0x60F2357684599702u, 0x6126C2D4256FFCC2u, 0x615C73892ECBFBF3u, 0x6191C835BD3F7D78u, 0x61C63A432C8F5CD6u,
+        0x61FBC8D3F7B3340Bu, 0x62315D847AD00087u, 0x6265B4E5998400A9u, 0x629B221EFFE500D3u, 0x62D0F5535FEF2084u,
+        0x630532A837EAE8A5u, 0x633A7F5245E5A2CEu, 0x63708F936BAF85C1u, 0x63A4B378469B6731u, 0x63D9E056584240FDu,
+        0x64102C35F729689Eu, 0x6444374374F3C2C6u, 0x647945145230B377u, 0x64AF965966BCE055u, 0x64E3BDF7E0360C35u,
+        0x6518AD75D8438F43u, 0x654ED8D34E547313u, 0x6583478410F4C7ECu, 0x65B819651531F9E7u, 0x65EE1FBE5A7E7861u,
+        0x6622D3D6F88F0B3Cu, 0x665788CCB6B2CE0Cu, 0x668D6AFFE45F818Fu, 0x66C262DFEEBBB0F9u, 0x66F6FB97EA6A9D37u,
+        0x672CBA7DE5054485u, 0x6761F48EAF234AD3u, 0x679671B25AEC1D88u, 0x67CC0E1EF1A724EAu, 0x680188D357087712u,
+        0x6835EB082CCA94D7u, 0x686B65CA37FD3A0Du, 0x68A11F9E62FE4448u, 0x68D56785FBBDD55Au, 0x690AC1677AAD4AB0u,
+        0x6940B8E0ACAC4EAEu, 0x6974E718D7D7625Au, 0x69AA20DF0DCD3AF0u, 0x69E0548B68A044D6u, 0x6A1469AE42C8560Cu,
+        0x6A498419D37A6B8Fu, 0x6A7FE52048590672u, 0x6AB3EF342D37A407u, 0x6AE8EB0138858D09u, 0x6B1F25C186A6F04Cu,
+        0x6B537798F428562Fu, 0x6B88557F31326BBBu, 0x6BBE6ADEFD7F06AAu, 0x6BF302CB5E6F642Au, 0x6C27C37E360B3D35u,
+        0x6C5DB45DC38E0C82u, 0x6C9290BA9A38C7D1u, 0x6CC734E940C6F9C5u, 0x6CFD022390F8B837u, 0x6D3221563A9B7322u,
+        0x6D66A9ABC9424FEBu, 0x6D9C5416BB92E3E6u, 0x6DD1B48E353BCE6Fu, 0x6E0621B1C28AC20Bu, 0x6E3BAA1E332D728Eu,
+        0x6E714A52DFFC6799u, 0x6EA59CE797FB817Fu, 0x6EDB04217DFA61DFu, 0x6F10E294EEBC7D2Bu, 0x6F451B3A2A6B9C76u,
+        0x6F7A6208B5068394u, 0x6FB07D457124123Cu, 0x6FE49C96CD6D16CBu, 0x7019C3BC80C85C7Eu, 0x70501A55D07D39CFu,
+        0x708420EB449C8842u, 0x70B9292615C3AA53u, 0x70EF736F9B3494E8u, 0x7123A825C100DD11u, 0x7158922F31411455u,
+        0x718EB6BAFD91596Bu, 0x71C33234DE7AD7E2u, 0x71F7FEC216198DDBu, 0x722DFE729B9FF152u, 0x7262BF07A143F6D3u,
+        0x72976EC98994F488u, 0x72CD4A7BEBFA31AAu, 0x73024E8D737C5F0Au, 0x7336E230D05B76CDu, 0x736C9ABD04725480u,
+        0x73A1E0B622C774D0u, 0x73D658E3AB795204u, 0x740BEF1C9657A685u, 0x74417571DDF6C813u, 0x7475D2CE55747A18u,
+        0x74AB4781EAD1989Eu, 0x74E10CB132C2FF63u, 0x75154FDD7F73BF3Bu, 0x754AA3D4DF50AF0Au, 0x7580A6650B926D66u,
+        0x75B4CFFE4E7708C0u, 0x75EA03FDE214CAF0u, 0x7620427EAD4CFED6u, 0x7654531E58A03E8Bu, 0x768967E5EEC84E2Eu,
+        0x76BFC1DF6A7A61BAu, 0x76F3D92BA28C7D14u, 0x7728CF768B2F9C59u, 0x775F03542DFB8370u, 0x779362149CBD3226u,
+        0x77C83A99C3EC7EAFu, 0x77FE494034E79E5Bu, 0x7832EDC82110C2F9u, 0x7867A93A2954F3B7u, 0x789D9388B3AA30A5u,
+        0x78D27C35704A5E67u, 0x79071B42CC5CF601u, 0x793CE2137F743381u, 0x79720D4C2FA8A030u, 0x79A6909F3B92C83Du,
+        0x79DC34C70A777A4Cu, 0x7A11A0FC668AAC6Fu, 0x7A46093B802D578Bu, 0x7A7B8B8A6038AD6Eu, 0x7AB137367C236C65u,
+        0x7AE585041B2C477Eu, 0x7B1AE64521F7595Eu, 0x7B50CFEB353A97DAu, 0x7B8503E602893DD1u, 0x7BBA44DF832B8D45u,
+        0x7BF06B0BB1FB384Bu, 0x7C2485CE9E7A065Eu, 0x7C59A742461887F6u, 0x7C9008896BCF54F9u, 0x7CC40AABC6C32A38u,
+        0x7CF90D56B873F4C6u, 0x7D2F50AC6690F1F8u, 0x7D63926BC01A973Bu, 0x7D987706B0213D09u, 0x7DCE94C85C298C4Cu,
+        0x7E031CFD3999F7AFu, 0x7E37E43C8800759Bu, 0x7E6DDD4BAA009302u, 0x7EA2AA4F4A405BE1u, 0x7ED754E31CD072D9u,
+        0x7F0D2A1BE4048F90u, 0x7F423A516E82D9BAu, 0x7F76C8E5CA239028u, 0x7FAC7B1F3CAC7433u, 0x7FE1CCF385EBC89Fu,
+        0x7FEFFFFFFFFFFFFFu};
+};
+
+template <class _Floating>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+to_chars_result _Floating_to_chars_general_precision(
+    char* _First, char* const _Last, const _Floating _Value, int _Precision) noexcept {
+
+    using _Traits    = _Floating_type_traits<_Floating>;
+    using _Uint_type = typename _Traits::_Uint_type;
+
+    const _Uint_type _Uint_value = std::bit_cast<_Uint_type>(_Value);
+
+    if (_Uint_value == 0) { // zero detected; write "0" and return; _Precision is irrelevant due to zero-trimming
+        if (_First == _Last) {
+            return {_Last, errc::value_too_large};
+        }
+
+        *_First++ = '0';
+
+        return {_First, errc{}};
+    }
+
+    // C11 7.21.6.1 "The fprintf function"/5:
+    // "A negative precision argument is taken as if the precision were omitted."
+    // /8: "g,G [...] Let P equal the precision if nonzero, 6 if the precision is omitted,
+    // or 1 if the precision is zero."
+
+    // Performance note: It's possible to rewrite this for branchless codegen,
+    // but profiling will be necessary to determine whether that's faster.
+    if (_Precision < 0) {
+        _Precision = 6;
+    } else if (_Precision == 0) {
+        _Precision = 1;
+    } else if (_Precision < 1'000'000) {
+        // _Precision is ok.
+    } else {
+        // Avoid integer overflow.
+        // Due to general notation's zero-trimming behavior, we can simply clamp _Precision.
+        // This is further clamped below.
+        _Precision = 1'000'000;
+    }
+
+    // _Precision is now the Standard's P.
+
+    // /8: "Then, if a conversion with style E would have an exponent of X:
+    // - if P > X >= -4, the conversion is with style f (or F) and precision P - (X + 1).
+    // - otherwise, the conversion is with style e (or E) and precision P - 1."
+
+    // /8: "Finally, [...] any trailing zeros are removed from the fractional portion of the result
+    // and the decimal-point character is removed if there is no fractional portion remaining."
+
+    using _Tables = _General_precision_tables<_Floating>;
+
+    const _Uint_type* _Table_begin;
+    const _Uint_type* _Table_end;
+
+    if (_Precision <= _Tables::_Max_special_P) {
+        _Table_begin = _Tables::_Special_X_table + (_Precision - 1) * (_Precision + 10) / 2;
+        _Table_end   = _Table_begin + _Precision + 5;
+    } else {
+        _Table_begin = _Tables::_Ordinary_X_table;
+        _Table_end   = _Table_begin + std::min(_Precision, _Tables::_Max_P) + 5;
+    }
+
+    // Profiling indicates that linear search is faster than binary search for small tables.
+    // Performance note: lambda captures may have a small performance cost.
+    const _Uint_type* const _Table_lower_bound = [=] {
+        if constexpr (!_IsSame<_Floating, float>::value) {
+            if (_Precision > 155) { // threshold determined via profiling
+                return std::lower_bound(_Table_begin, _Table_end, _Uint_value, less{});
+            }
+        }
+
+        return std::find_if(_Table_begin, _Table_end, [=](const _Uint_type _Elem) { return _Uint_value <= _Elem; });
+    }();
+
+    const ptrdiff_t _Table_index     = _Table_lower_bound - _Table_begin;
+    const int _Scientific_exponent_X = static_cast<int>(_Table_index - 5);
+    const bool _Use_fixed_notation   = _Precision > _Scientific_exponent_X && _Scientific_exponent_X >= -4;
+
+    // Performance note: it might (or might not) be faster to modify Ryu Printf to perform zero-trimming.
+    // Such modifications would involve a fairly complicated state machine (notably, both '0' and '9' digits would
+    // need to be buffered, due to rounding), and that would have performance costs due to increased branching.
+    // Here, we're using a simpler approach: writing into a local buffer, manually zero-trimming, and then copying into
+    // the output range. The necessary buffer size is reasonably small, the zero-trimming logic is simple and fast,
+    // and the final copying is also fast.
+
+    constexpr int _Max_output_length =
+        _IsSame<_Floating, float>::value ? 117 : 773; // cases: 0x1.fffffep-126f and 0x1.fffffffffffffp-1022
+    constexpr int _Max_fixed_precision =
+        _IsSame<_Floating, float>::value ? 37 : 66; // cases: 0x1.fffffep-14f and 0x1.fffffffffffffp-14
+    constexpr int _Max_scientific_precision =
+        _IsSame<_Floating, float>::value ? 111 : 766; // cases: 0x1.fffffep-126f and 0x1.fffffffffffffp-1022
+
+    // Note that _Max_output_length is determined by scientific notation and is more than enough for fixed notation.
+    // 0x1.fffffep+127f is 39 digits, plus 1 for '.', plus _Max_fixed_precision for '0' digits, equals 77.
+    // 0x1.fffffffffffffp+1023 is 309 digits, plus 1 for '.', plus _Max_fixed_precision for '0' digits, equals 376.
+
+    char _Buffer[_Max_output_length];
+    const char* const _Significand_first = _Buffer; // e.g. "1.234"
+    const char* _Significand_last        = nullptr;
+    const char* _Exponent_first          = nullptr; // e.g. "e-05"
+    const char* _Exponent_last           = nullptr;
+    int _Effective_precision; // number of digits printed after the decimal point, before trimming
+
+    // Write into the local buffer.
+    // Clamping _Effective_precision allows _Buffer to be as small as possible, and increases efficiency.
+    if (_Use_fixed_notation) {
+        _Effective_precision = std::min(_Precision - (_Scientific_exponent_X + 1), _Max_fixed_precision);
+        const to_chars_result _Buf_result =
+            _Floating_to_chars_fixed_precision(_Buffer, std::end(_Buffer), _Value, _Effective_precision);
+        _LIBCPP_ASSERT_INTERNAL(_Buf_result.ec == errc{}, "");
+        _Significand_last = _Buf_result.ptr;
+    } else {
+        _Effective_precision = std::min(_Precision - 1, _Max_scientific_precision);
+        const to_chars_result _Buf_result =
+            _Floating_to_chars_scientific_precision(_Buffer, std::end(_Buffer), _Value, _Effective_precision);
+        _LIBCPP_ASSERT_INTERNAL(_Buf_result.ec == errc{}, "");
+        _Significand_last = std::find(_Buffer, _Buf_result.ptr, 'e');
+        _Exponent_first   = _Significand_last;
+        _Exponent_last    = _Buf_result.ptr;
+    }
+
+    // If we printed a decimal point followed by digits, perform zero-trimming.
+    if (_Effective_precision > 0) {
+        while (_Significand_last[-1] == '0') { // will stop at '.' or a nonzero digit
+            --_Significand_last;
+        }
+
+        if (_Significand_last[-1] == '.') {
+            --_Significand_last;
+        }
+    }
+
+    // Copy the significand to the output range.
+    const ptrdiff_t _Significand_distance = _Significand_last - _Significand_first;
+    if (_Last - _First < _Significand_distance) {
+        return {_Last, errc::value_too_large};
+    }
+    std::memcpy(_First, _Significand_first, static_cast<size_t>(_Significand_distance));
+    _First += _Significand_distance;
+
+    // Copy the exponent to the output range.
+    if (!_Use_fixed_notation) {
+        const ptrdiff_t _Exponent_distance = _Exponent_last - _Exponent_first;
+        if (_Last - _First < _Exponent_distance) {
+            return {_Last, errc::value_too_large};
+        }
+        std::memcpy(_First, _Exponent_first, static_cast<size_t>(_Exponent_distance));
+        _First += _Exponent_distance;
+    }
+
+    return {_First, errc{}};
+}
+
+enum class _Floating_to_chars_overload { _Plain, _Format_only, _Format_precision };
+
+template <_Floating_to_chars_overload _Overload, class _Floating>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI
+to_chars_result _Floating_to_chars(
+    char* _First, char* const _Last, _Floating _Value, const chars_format _Fmt, const int _Precision) noexcept {
+
+    if constexpr (_Overload == _Floating_to_chars_overload::_Plain) {
+        _LIBCPP_ASSERT_INTERNAL(_Fmt == chars_format{}, ""); // plain overload must pass chars_format{} internally
+    } else {
+        _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(_Fmt == chars_format::general || _Fmt == chars_format::scientific
+                         || _Fmt == chars_format::fixed || _Fmt == chars_format::hex,
+            "invalid format in to_chars()");
+    }
+
+    using _Traits    = _Floating_type_traits<_Floating>;
+    using _Uint_type = typename _Traits::_Uint_type;
+
+    _Uint_type _Uint_value = std::bit_cast<_Uint_type>(_Value);
+
+    const bool _Was_negative = (_Uint_value & _Traits::_Shifted_sign_mask) != 0;
+
+    if (_Was_negative) { // sign bit detected; write minus sign and clear sign bit
+        if (_First == _Last) {
+            return {_Last, errc::value_too_large};
+        }
+
+        *_First++ = '-';
+
+        _Uint_value &= ~_Traits::_Shifted_sign_mask;
+        _Value = std::bit_cast<_Floating>(_Uint_value);
+    }
+
+    if ((_Uint_value & _Traits::_Shifted_exponent_mask) == _Traits::_Shifted_exponent_mask) {
+        // inf/nan detected; write appropriate string and return
+        const char* _Str;
+        size_t _Len;
+
+        const _Uint_type _Mantissa = _Uint_value & _Traits::_Denormal_mantissa_mask;
+
+        if (_Mantissa == 0) {
+            _Str = "inf";
+            _Len = 3;
+        } else if (_Was_negative && _Mantissa == _Traits::_Special_nan_mantissa_mask) {
+            // When a NaN value has the sign bit set, the quiet bit set, and all other mantissa bits cleared,
+            // the UCRT interprets it to mean "indeterminate", and indicates this by printing "-nan(ind)".
+            _Str = "nan(ind)";
+            _Len = 8;
+        } else if ((_Mantissa & _Traits::_Special_nan_mantissa_mask) != 0) {
+            _Str = "nan";
+            _Len = 3;
+        } else {
+            _Str = "nan(snan)";
+            _Len = 9;
+        }
+
+        if (_Last - _First < static_cast<ptrdiff_t>(_Len)) {
+            return {_Last, errc::value_too_large};
+        }
+
+        std::memcpy(_First, _Str, _Len);
+
+        return {_First + _Len, errc{}};
+    }
+
+    if constexpr (_Overload == _Floating_to_chars_overload::_Plain) {
+        return _Floating_to_chars_ryu(_First, _Last, _Value, chars_format{});
+    } else if constexpr (_Overload == _Floating_to_chars_overload::_Format_only) {
+        if (_Fmt == chars_format::hex) {
+            return _Floating_to_chars_hex_shortest(_First, _Last, _Value);
+        }
+
+        return _Floating_to_chars_ryu(_First, _Last, _Value, _Fmt);
+    } else if constexpr (_Overload == _Floating_to_chars_overload::_Format_precision) {
+        switch (_Fmt) {
+        case chars_format::scientific:
+            return _Floating_to_chars_scientific_precision(_First, _Last, _Value, _Precision);
+        case chars_format::fixed:
+            return _Floating_to_chars_fixed_precision(_First, _Last, _Value, _Precision);
+        case chars_format::general:
+            return _Floating_to_chars_general_precision(_First, _Last, _Value, _Precision);
+        case chars_format::hex:
+        default: // avoid MSVC warning C4715: not all control paths return a value
+            return _Floating_to_chars_hex_precision(_First, _Last, _Value, _Precision);
+        }
+    }
+}
+
+// clang-format on
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_SRC_INCLUDE_TO_CHARS_FLOATING_POINT_H
diff --git a/third_party/libcxx/tuple b/third_party/libcxx/tuple
index e4119cf2e..081b90c7b 100644
--- a/third_party/libcxx/tuple
+++ b/third_party/libcxx/tuple
@@ -10,6 +10,8 @@
 #ifndef _LIBCPP_TUPLE
 #define _LIBCPP_TUPLE
 
+// clang-format off
+
 /*
     tuple synopsis
 
@@ -130,7 +132,12 @@ tuple(allocator_arg_t, Alloc, pair<T1, T2>) -> tuple<T1, T2>;       // since C++
 template <class Alloc, class ...T>
 tuple(allocator_arg_t, Alloc, tuple<T...>) -> tuple<T...>;          // since C++17
 
-inline constexpr unspecified ignore;
+struct ignore-type { // exposition only                             // Since C++26
+  constexpr const ignore-type&
+    operator=(const auto &) const noexcept
+      { return *this; }
+};
+inline constexpr ignore-type ignore;
 
 template <class... T> tuple<V...>  make_tuple(T&&...); // constexpr in C++14
 template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept; // constexpr in C++14
@@ -139,7 +146,7 @@ template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls); // cons
 
 // [tuple.apply], calling a function with a tuple of arguments:
 template <class F, class Tuple>
-  constexpr decltype(auto) apply(F&& f, Tuple&& t); // C++17
+  constexpr decltype(auto) apply(F&& f, Tuple&& t) noexcept(see below);  // C++17 noexcept since C++23
 template <class T, class Tuple>
   constexpr T make_from_tuple(Tuple&& t); // C++17
 
@@ -201,15 +208,19 @@ template <class... Types>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
+// clang-format on
+
 #include <__compare/common_comparison_category.h>
 #include <__compare/synth_three_way.h>
 #include <__config>
 #include <__functional/invoke.h>
 #include <__fwd/array.h>
+#include <__fwd/pair.h>
 #include <__fwd/tuple.h>
 #include <__memory/allocator_arg_t.h>
 #include <__memory/uses_allocator.h>
+#include <__tuple/find_index.h>
+#include <__tuple/ignore.h>
 #include <__tuple/make_tuple_types.h>
 #include <__tuple/sfinae_helpers.h>
 #include <__tuple/tuple_element.h>
@@ -217,7 +228,6 @@ template <class... Types>
 #include <__tuple/tuple_like_ext.h>
 #include <__tuple/tuple_size.h>
 #include <__tuple/tuple_types.h>
-#include <__type_traits/apply_cv.h>
 #include <__type_traits/common_reference.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/conditional.h>
@@ -228,23 +238,15 @@ template <class... Types>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
-#include <__type_traits/is_copy_assignable.h>
-#include <__type_traits/is_copy_constructible.h>
-#include <__type_traits/is_default_constructible.h>
 #include <__type_traits/is_empty.h>
 #include <__type_traits/is_final.h>
 #include <__type_traits/is_implicitly_default_constructible.h>
-#include <__type_traits/is_move_assignable.h>
-#include <__type_traits/is_move_constructible.h>
 #include <__type_traits/is_nothrow_assignable.h>
 #include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_nothrow_copy_assignable.h>
-#include <__type_traits/is_nothrow_copy_constructible.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
+#include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/lazy.h>
 #include <__type_traits/maybe_const.h>
 #include <__type_traits/nat.h>
@@ -255,7 +257,6 @@ template <class... Types>
 #include <__utility/forward.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/move.h>
-#include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
 #include <__utility/swap.h>
 #include <cstddef>
@@ -270,1592 +271,1142 @@ template <class... Types>
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifndef _LIBCPP_CXX03_LANG
 
-
 // __tuple_leaf
 
-template <size_t _Ip, class _Hp,
-          bool=is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value
-         >
+template <size_t _Ip, class _Hp, bool = is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value >
 class __tuple_leaf;
 
 template <size_t _Ip, class _Hp, bool _Ep>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
-    _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
-{
-    swap(__x.get(), __y.get());
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y) noexcept(__is_nothrow_swappable_v<_Hp>) {
+  swap(__x.get(), __y.get());
 }
 
 template <size_t _Ip, class _Hp, bool _Ep>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-void swap(const __tuple_leaf<_Ip, _Hp, _Ep>& __x, const __tuple_leaf<_Ip, _Hp, _Ep>& __y)
-     _NOEXCEPT_(__is_nothrow_swappable<const _Hp>::value) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+swap(const __tuple_leaf<_Ip, _Hp, _Ep>& __x,
+     const __tuple_leaf<_Ip, _Hp, _Ep>& __y) noexcept(__is_nothrow_swappable_v<const _Hp>) {
   swap(__x.get(), __y.get());
 }
 
 template <size_t _Ip, class _Hp, bool>
-class __tuple_leaf
-{
-    _Hp __value_;
+class __tuple_leaf {
+  _Hp __value_;
 
-    template <class _Tp>
-    static _LIBCPP_HIDE_FROM_ABI constexpr bool __can_bind_reference() {
-#if __has_keyword(__reference_binds_to_temporary)
-      return !__reference_binds_to_temporary(_Hp, _Tp);
-#else
-      return true;
-#endif
-    }
+  template <class _Tp>
+  static _LIBCPP_HIDE_FROM_ABI constexpr bool __can_bind_reference() {
+#  if __has_keyword(__reference_binds_to_temporary)
+    return !__reference_binds_to_temporary(_Hp, _Tp);
+#  else
+    return true;
+#  endif
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX14
-    __tuple_leaf& operator=(const __tuple_leaf&);
 public:
-    _LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
-             _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_()
-       {static_assert(!is_reference<_Hp>::value,
-              "Attempted to default construct a reference element in a tuple");}
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 __tuple_leaf& operator=(const __tuple_leaf&) = delete;
 
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY constexpr
-        __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
-            : __value_()
-        {static_assert(!is_reference<_Hp>::value,
-              "Attempted to default construct a reference element in a tuple");}
+  _LIBCPP_HIDE_FROM_ABI constexpr __tuple_leaf() noexcept(is_nothrow_default_constructible<_Hp>::value) : __value_() {
+    static_assert(!is_reference<_Hp>::value, "Attempted to default construct a reference element in a tuple");
+  }
 
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY constexpr
-        __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
-            : __value_(allocator_arg_t(), __a)
-        {static_assert(!is_reference<_Hp>::value,
-              "Attempted to default construct a reference element in a tuple");}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI constexpr __tuple_leaf(integral_constant<int, 0>, const _Alloc&) : __value_() {
+    static_assert(!is_reference<_Hp>::value, "Attempted to default construct a reference element in a tuple");
+  }
 
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY constexpr
-        __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
-            : __value_(__a)
-        {static_assert(!is_reference<_Hp>::value,
-              "Attempted to default construct a reference element in a tuple");}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI constexpr __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
+      : __value_(allocator_arg_t(), __a) {
+    static_assert(!is_reference<_Hp>::value, "Attempted to default construct a reference element in a tuple");
+  }
 
-    template <class _Tp,
-              class = __enable_if_t<
-                  _And<
-                      _IsNotSame<__remove_cvref_t<_Tp>, __tuple_leaf>,
-                      is_constructible<_Hp, _Tp>
-                    >::value
-                >
-            >
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-        explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
-            : __value_(_VSTD::forward<_Tp>(__t))
-        {static_assert(__can_bind_reference<_Tp&&>(),
-       "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI constexpr __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a) : __value_(__a) {
+    static_assert(!is_reference<_Hp>::value, "Attempted to default construct a reference element in a tuple");
+  }
 
-    template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-        explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
-            : __value_(_VSTD::forward<_Tp>(__t))
-        {static_assert(__can_bind_reference<_Tp&&>(),
-       "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
+  template <
+      class _Tp,
+      __enable_if_t<_And<_IsNotSame<__remove_cvref_t<_Tp>, __tuple_leaf>, is_constructible<_Hp, _Tp> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_leaf(_Tp&& __t) noexcept(is_nothrow_constructible<_Hp, _Tp>::value)
+      : __value_(std::forward<_Tp>(__t)) {
+    static_assert(__can_bind_reference<_Tp&&>(),
+                  "Attempted construction of reference element binds to a temporary whose lifetime has ended");
+  }
 
-    template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-        explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
-            : __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
-        {static_assert(!is_reference<_Hp>::value,
-            "Attempted to uses-allocator construct a reference element in a tuple");}
+  template <class _Tp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
+      : __value_(std::forward<_Tp>(__t)) {
+    static_assert(__can_bind_reference<_Tp&&>(),
+                  "Attempted construction of reference element binds to a temporary whose lifetime has ended");
+  }
 
-    template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-        explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
-            : __value_(_VSTD::forward<_Tp>(__t), __a)
-        {static_assert(!is_reference<_Hp>::value,
-           "Attempted to uses-allocator construct a reference element in a tuple");}
+  template <class _Tp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
+      : __value_(allocator_arg_t(), __a, std::forward<_Tp>(__t)) {
+    static_assert(!is_reference<_Hp>::value, "Attempted to uses-allocator construct a reference element in a tuple");
+  }
 
-    _LIBCPP_HIDE_FROM_ABI __tuple_leaf(const __tuple_leaf& __t) = default;
-    _LIBCPP_HIDE_FROM_ABI __tuple_leaf(__tuple_leaf&& __t) = default;
+  template <class _Tp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
+      : __value_(std::forward<_Tp>(__t), __a) {
+    static_assert(!is_reference<_Hp>::value, "Attempted to uses-allocator construct a reference element in a tuple");
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
-    {
-        _VSTD::swap(*this, __t);
-        return 0;
-    }
+  _LIBCPP_HIDE_FROM_ABI __tuple_leaf(const __tuple_leaf& __t) = default;
+  _LIBCPP_HIDE_FROM_ABI __tuple_leaf(__tuple_leaf&& __t)      = default;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    int swap(const __tuple_leaf& __t) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) {
-        _VSTD::swap(*this, __t);
-        return 0;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int
+  swap(__tuple_leaf& __t) noexcept(__is_nothrow_swappable_v<__tuple_leaf>) {
+    std::swap(*this, __t);
+    return 0;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14       _Hp& get()       _NOEXCEPT {return __value_;}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Hp& get() const _NOEXCEPT {return __value_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int swap(const __tuple_leaf& __t) const
+      noexcept(__is_nothrow_swappable_v<const __tuple_leaf>) {
+    std::swap(*this, __t);
+    return 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Hp& get() _NOEXCEPT { return __value_; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Hp& get() const _NOEXCEPT { return __value_; }
 };
 
 template <size_t _Ip, class _Hp>
-class __tuple_leaf<_Ip, _Hp, true>
-    : private _Hp
-{
-    _LIBCPP_CONSTEXPR_SINCE_CXX14
-    __tuple_leaf& operator=(const __tuple_leaf&);
+class __tuple_leaf<_Ip, _Hp, true> : private _Hp {
 public:
-    _LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
-             _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 __tuple_leaf& operator=(const __tuple_leaf&) = delete;
 
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY constexpr
-        __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr __tuple_leaf() noexcept(is_nothrow_default_constructible<_Hp>::value) {}
 
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY constexpr
-        __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
-            : _Hp(allocator_arg_t(), __a) {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI constexpr __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
 
-    template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY constexpr
-        __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
-            : _Hp(__a) {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI constexpr __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
+      : _Hp(allocator_arg_t(), __a) {}
 
-    template <class _Tp,
-              class = __enable_if_t<
-                  _And<
-                    _IsNotSame<__remove_cvref_t<_Tp>, __tuple_leaf>,
-                    is_constructible<_Hp, _Tp>
-                  >::value
-                >
-            >
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-        explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
-            : _Hp(_VSTD::forward<_Tp>(__t)) {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI constexpr __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a) : _Hp(__a) {}
 
-    template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY constexpr
-        explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
-            : _Hp(_VSTD::forward<_Tp>(__t)) {}
+  template <class _Tp,
+            __enable_if_t< _And< _IsNotSame<__remove_cvref_t<_Tp>, __tuple_leaf>, is_constructible<_Hp, _Tp> >::value,
+                           int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_leaf(_Tp&& __t) noexcept(is_nothrow_constructible<_Hp, _Tp>::value)
+      : _Hp(std::forward<_Tp>(__t)) {}
 
-    template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY constexpr
-        explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
-            : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
+  template <class _Tp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
+      : _Hp(std::forward<_Tp>(__t)) {}
 
-    template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY constexpr
-        explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
-            : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
+  template <class _Tp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
+      : _Hp(allocator_arg_t(), __a, std::forward<_Tp>(__t)) {}
 
-    __tuple_leaf(__tuple_leaf const &) = default;
-    __tuple_leaf(__tuple_leaf &&) = default;
+  template <class _Tp, class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
+      : _Hp(std::forward<_Tp>(__t), __a) {}
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    int
-    swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
-    {
-        _VSTD::swap(*this, __t);
-        return 0;
-    }
+  __tuple_leaf(__tuple_leaf const&) = default;
+  __tuple_leaf(__tuple_leaf&&)      = default;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    int swap(const __tuple_leaf& __rhs) const _NOEXCEPT_(__is_nothrow_swappable<const __tuple_leaf>::value) {
-        _VSTD::swap(*this, __rhs);
-        return 0;
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int
+  swap(__tuple_leaf& __t) noexcept(__is_nothrow_swappable_v<__tuple_leaf>) {
+    std::swap(*this, __t);
+    return 0;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14       _Hp& get()       _NOEXCEPT {return static_cast<_Hp&>(*this);}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int swap(const __tuple_leaf& __rhs) const
+      noexcept(__is_nothrow_swappable_v<const __tuple_leaf>) {
+    std::swap(*this, __rhs);
+    return 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Hp& get() _NOEXCEPT { return static_cast<_Hp&>(*this); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Hp& get() const _NOEXCEPT {
+    return static_cast<const _Hp&>(*this);
+  }
 };
 
-template <class ..._Tp>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-void __swallow(_Tp&&...) _NOEXCEPT {}
+template <class... _Tp>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __swallow(_Tp&&...) _NOEXCEPT {}
 
 template <class _Tp>
 struct __all_default_constructible;
 
-template <class ..._Tp>
-struct __all_default_constructible<__tuple_types<_Tp...>>
-    : __all<is_default_constructible<_Tp>::value...>
-{ };
+template <class... _Tp>
+struct __all_default_constructible<__tuple_types<_Tp...>> : __all<is_default_constructible<_Tp>::value...> {};
 
 // __tuple_impl
 
-template<class _Indx, class ..._Tp> struct __tuple_impl;
+template <class _Indx, class... _Tp>
+struct __tuple_impl;
 
-template<size_t ..._Indx, class ..._Tp>
+template <size_t... _Indx, class... _Tp>
 struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
-    : public __tuple_leaf<_Indx, _Tp>...
-{
-    _LIBCPP_INLINE_VISIBILITY
-    constexpr __tuple_impl()
-        _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
+    : public __tuple_leaf<_Indx, _Tp>... {
+  _LIBCPP_HIDE_FROM_ABI constexpr __tuple_impl() noexcept(
+      __all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 
-    template <size_t ..._Uf, class ..._Tf,
-              size_t ..._Ul, class ..._Tl, class ..._Up>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-        explicit
-        __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
-                     __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
-                     _Up&&... __u)
-                     _NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
-                                 __all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
-            __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
-            __tuple_leaf<_Ul, _Tl>()...
-            {}
+  template <size_t... _Uf, class... _Tf, size_t... _Ul, class... _Tl, class... _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_impl(
+      __tuple_indices<_Uf...>,
+      __tuple_types<_Tf...>,
+      __tuple_indices<_Ul...>,
+      __tuple_types<_Tl...>,
+      _Up&&... __u) noexcept(__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
+                             __all<is_nothrow_default_constructible<_Tl>::value...>::value)
+      : __tuple_leaf<_Uf, _Tf>(std::forward<_Up>(__u))..., __tuple_leaf<_Ul, _Tl>()... {}
 
-    template <class _Alloc, size_t ..._Uf, class ..._Tf,
-              size_t ..._Ul, class ..._Tl, class ..._Up>
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-        explicit
-        __tuple_impl(allocator_arg_t, const _Alloc& __a,
-                     __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
-                     __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
-                     _Up&&... __u) :
-            __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
-            _VSTD::forward<_Up>(__u))...,
-            __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
-            {}
+  template <class _Alloc, size_t... _Uf, class... _Tf, size_t... _Ul, class... _Tl, class... _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_impl(
+      allocator_arg_t,
+      const _Alloc& __a,
+      __tuple_indices<_Uf...>,
+      __tuple_types<_Tf...>,
+      __tuple_indices<_Ul...>,
+      __tuple_types<_Tl...>,
+      _Up&&... __u)
+      : __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a, std::forward<_Up>(__u))...,
+        __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)... {}
 
-    template <class _Tuple,
-              class = __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value>
-             >
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-        __tuple_impl(_Tuple&& __t) _NOEXCEPT_((__all<is_nothrow_constructible<_Tp, typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
-            : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
-            {}
+  template <class _Tuple, __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __tuple_impl(_Tuple&& __t) noexcept(
+      (__all<is_nothrow_constructible<
+           _Tp,
+           typename tuple_element<_Indx, typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
+      : __tuple_leaf<_Indx, _Tp>(
+            std::forward<typename tuple_element<_Indx, typename __make_tuple_types<_Tuple>::type>::type>(
+                std::get<_Indx>(__t)))... {}
 
-    template <class _Alloc, class _Tuple,
-              class = __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value>
-             >
-        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-        __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
-            : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(), __a,
-                                       _VSTD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
-            {}
+  template <class _Alloc, class _Tuple, __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
+      : __tuple_leaf<_Indx, _Tp>(
+            __uses_alloc_ctor<_Tp,
+                              _Alloc,
+                              typename tuple_element<_Indx, typename __make_tuple_types<_Tuple>::type>::type>(),
+            __a,
+            std::forward<typename tuple_element<_Indx, typename __make_tuple_types<_Tuple>::type>::type>(
+                std::get<_Indx>(__t)))... {}
 
-    __tuple_impl(const __tuple_impl&) = default;
-    __tuple_impl(__tuple_impl&&) = default;
+  __tuple_impl(const __tuple_impl&) = default;
+  __tuple_impl(__tuple_impl&&)      = default;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    void swap(__tuple_impl& __t)
-        _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
-    {
-        _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+  swap(__tuple_impl& __t) noexcept(__all<__is_nothrow_swappable_v<_Tp>...>::value) {
+    std::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    void swap(const __tuple_impl& __t) const
-        _NOEXCEPT_(__all<__is_nothrow_swappable<const _Tp>::value...>::value)
-    {
-        _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t))...);
-    }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void swap(const __tuple_impl& __t) const
+      noexcept(__all<__is_nothrow_swappable_v<const _Tp>...>::value) {
+    std::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<const __tuple_leaf<_Indx, _Tp>&>(__t))...);
+  }
 };
 
-template<class _Dest, class _Source, size_t ..._Np>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
-    _VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...);
+template <class _Dest, class _Source, size_t... _Np>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+__memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
+  std::__swallow(((std::get<_Np>(__dest) = std::get<_Np>(__source)), void(), 0)...);
 }
 
-template<class _Dest, class _Source, class ..._Up, size_t ..._Np>
-_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-void __memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) {
-    _VSTD::__swallow(((
-        _VSTD::get<_Np>(__dest) = _VSTD::forward<_Up>(_VSTD::get<_Np>(__source))
-    ), void(), 0)...);
+template <class _Dest, class _Source, class... _Up, size_t... _Np>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
+__memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) {
+  std::__swallow(((std::get<_Np>(__dest) = std::forward<_Up>(std::get<_Np>(__source))), void(), 0)...);
 }
 
-template <class ..._Tp>
-class _LIBCPP_TEMPLATE_VIS tuple
-{
-    typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
+template <class... _Tp>
+class _LIBCPP_TEMPLATE_VIS tuple {
+  typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;
 
-    _BaseT __base_;
+  _BaseT __base_;
+
+  template <size_t _Jp, class... _Up>
+  friend _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
+  template <size_t _Jp, class... _Up>
+  friend _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Jp, tuple<_Up...> >::type&
+  get(const tuple<_Up...>&) _NOEXCEPT;
+  template <size_t _Jp, class... _Up>
+  friend _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Jp, tuple<_Up...> >::type&&
+  get(tuple<_Up...>&&) _NOEXCEPT;
+  template <size_t _Jp, class... _Up>
+  friend _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Jp, tuple<_Up...> >::type&&
+  get(const tuple<_Up...>&&) _NOEXCEPT;
 
-    template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_SINCE_CXX14
-        typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&) _NOEXCEPT;
-    template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_SINCE_CXX14
-        const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&) _NOEXCEPT;
-    template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_SINCE_CXX14
-        typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
-    template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_SINCE_CXX14
-        const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
 public:
-    // [tuple.cnstr]
+  using __trivially_relocatable = __conditional_t<_And<__libcpp_is_trivially_relocatable<_Tp>...>::value, tuple, void>;
 
-    // tuple() constructors (including allocator_arg_t variants)
-    template <template<class...> class _IsImpDefault = __is_implicitly_default_constructible, __enable_if_t<
-        _And<
-            _IsImpDefault<_Tp>... // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    tuple()
-        _NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value)
-    { }
+  // [tuple.cnstr]
 
-    template <template<class...> class _IsImpDefault = __is_implicitly_default_constructible,
-              template<class...> class _IsDefault = is_default_constructible, __enable_if_t<
-        _And<
-            _IsDefault<_Tp>...,
-            _Not<_Lazy<_And, _IsImpDefault<_Tp>...> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
-    explicit tuple()
-        _NOEXCEPT_(_And<is_nothrow_default_constructible<_Tp>...>::value)
-    { }
+  // tuple() constructors (including allocator_arg_t variants)
+  template <template <class...> class _IsImpDefault                = __is_implicitly_default_constructible,
+            template <class...> class _IsDefault                   = is_default_constructible,
+            __enable_if_t< _And< _IsDefault<_Tp>... >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(_Not<_Lazy<_And, _IsImpDefault<_Tp>...> >::value)
+      tuple() noexcept(_And<is_nothrow_default_constructible<_Tp>...>::value) {}
 
-    template <class _Alloc, template<class...> class _IsImpDefault = __is_implicitly_default_constructible, __enable_if_t<
-        _And<
-            _IsImpDefault<_Tp>... // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple(allocator_arg_t, _Alloc const& __a)
-      : __base_(allocator_arg_t(), __a,
-                    __tuple_indices<>(), __tuple_types<>(),
-                    typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
-                    __tuple_types<_Tp...>()) {}
+  template <class _Alloc,
+            template <class...> class _IsImpDefault                = __is_implicitly_default_constructible,
+            template <class...> class _IsDefault                   = is_default_constructible,
+            __enable_if_t< _And< _IsDefault<_Tp>... >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, _IsImpDefault<_Tp>...> >::value)
+      tuple(allocator_arg_t, _Alloc const& __a)
+      : __base_(allocator_arg_t(),
+                __a,
+                __tuple_indices<>(),
+                __tuple_types<>(),
+                typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
+                __tuple_types<_Tp...>()) {}
 
-    template <class _Alloc,
-              template<class...> class _IsImpDefault = __is_implicitly_default_constructible,
-              template<class...> class _IsDefault = is_default_constructible, __enable_if_t<
-        _And<
-            _IsDefault<_Tp>...,
-            _Not<_Lazy<_And, _IsImpDefault<_Tp>...> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    explicit tuple(allocator_arg_t, _Alloc const& __a)
-      : __base_(allocator_arg_t(), __a,
-                    __tuple_indices<>(), __tuple_types<>(),
-                    typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
-                    __tuple_types<_Tp...>()) {}
-
-    // tuple(const T&...) constructors (including allocator_arg_t variants)
-    template <template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _BoolConstant<sizeof...(_Tp) >= 1>,
-            is_copy_constructible<_Tp>...,
-            is_convertible<const _Tp&, _Tp>... // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    tuple(const _Tp& ... __t)
-        _NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value)
-        : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+  // tuple(const T&...) constructors (including allocator_arg_t variants)
+  template <template <class...> class _And = _And,
+            __enable_if_t< _And< _BoolConstant<sizeof...(_Tp) >= 1>, is_copy_constructible<_Tp>... >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> >::value)
+      tuple(const _Tp&... __t) noexcept(_And<is_nothrow_copy_constructible<_Tp>...>::value)
+      : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
-                __t...
-               ) {}
+                __t...) {}
 
-    template <template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _BoolConstant<sizeof...(_Tp) >= 1>,
-            is_copy_constructible<_Tp>...,
-            _Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit tuple(const _Tp& ... __t)
-        _NOEXCEPT_(_And<is_nothrow_copy_constructible<_Tp>...>::value)
-        : __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),
-                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
-                typename __make_tuple_indices<0>::type(),
-                typename __make_tuple_types<tuple, 0>::type(),
-                __t...
-               ) {}
-
-    template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _BoolConstant<sizeof...(_Tp) >= 1>,
-            is_copy_constructible<_Tp>...,
-            is_convertible<const _Tp&, _Tp>... // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
-        : __base_(allocator_arg_t(), __a,
+  template <class _Alloc,
+            template <class...> class _And = _And,
+            __enable_if_t< _And< _BoolConstant<sizeof...(_Tp) >= 1>, is_copy_constructible<_Tp>... >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> >::value)
+      tuple(allocator_arg_t, const _Alloc& __a, const _Tp&... __t)
+      : __base_(allocator_arg_t(),
+                __a,
                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
-                __t...
-               ) {}
+                __t...) {}
 
-    template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _BoolConstant<sizeof...(_Tp) >= 1>,
-            is_copy_constructible<_Tp>...,
-            _Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    explicit tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
-        : __base_(allocator_arg_t(), __a,
-                typename __make_tuple_indices<sizeof...(_Tp)>::type(),
-                typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
-                typename __make_tuple_indices<0>::type(),
-                typename __make_tuple_types<tuple, 0>::type(),
-                __t...
-               ) {}
+  // tuple(U&& ...) constructors (including allocator_arg_t variants)
+  template <class... _Up>
+  struct _IsThisTuple : false_type {};
+  template <class _Up>
+  struct _IsThisTuple<_Up> : is_same<__remove_cvref_t<_Up>, tuple> {};
 
-    // tuple(U&& ...) constructors (including allocator_arg_t variants)
-    template <class ..._Up> struct _IsThisTuple : false_type { };
-    template <class _Up> struct _IsThisTuple<_Up> : is_same<__remove_cvref_t<_Up>, tuple> { };
+  template <class... _Up>
+  struct _EnableUTypesCtor
+      : _And< _BoolConstant<sizeof...(_Tp) >= 1>,
+              _Not<_IsThisTuple<_Up...> >, // extension to allow mis-behaved user constructors
+              is_constructible<_Tp, _Up>... > {};
 
-    template <class ..._Up>
-    struct _EnableUTypesCtor : _And<
-        _BoolConstant<sizeof...(_Tp) >= 1>,
-        _Not<_IsThisTuple<_Up...> >, // extension to allow mis-behaved user constructors
-        is_constructible<_Tp, _Up>...
-    > { };
+  template <class... _Up,
+            __enable_if_t< _And< _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _EnableUTypesCtor<_Up...> >::value,
+                           int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)
+      tuple(_Up&&... __u) noexcept(_And<is_nothrow_constructible<_Tp, _Up>...>::value)
+      : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
+                typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
+                typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
+                typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
+                std::forward<_Up>(__u)...) {}
 
-    template <class ..._Up, __enable_if_t<
-        _And<
-            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableUTypesCtor<_Up...>,
-            is_convertible<_Up, _Tp>... // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    tuple(_Up&&... __u)
-        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
-        : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
-                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
-                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
-                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
-                    _VSTD::forward<_Up>(__u)...) {}
+  template <class _Alloc,
+            class... _Up,
+            __enable_if_t< _And< _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>, _EnableUTypesCtor<_Up...> >::value,
+                           int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)
+      tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
+      : __base_(allocator_arg_t(),
+                __a,
+                typename __make_tuple_indices<sizeof...(_Up)>::type(),
+                typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
+                typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
+                typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
+                std::forward<_Up>(__u)...) {}
 
-    template <class ..._Up, __enable_if_t<
-        _And<
-            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableUTypesCtor<_Up...>,
-            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit tuple(_Up&&... __u)
-        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
-        : __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
-                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
-                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
-                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
-                    _VSTD::forward<_Up>(__u)...) {}
+  // Copy and move constructors (including the allocator_arg_t variants)
+  tuple(const tuple&) = default;
+  tuple(tuple&&)      = default;
 
-    template <class _Alloc, class ..._Up, __enable_if_t<
-        _And<
-            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableUTypesCtor<_Up...>,
-            is_convertible<_Up, _Tp>... // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
-        : __base_(allocator_arg_t(), __a,
-                    typename __make_tuple_indices<sizeof...(_Up)>::type(),
-                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
-                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
-                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
-                    _VSTD::forward<_Up>(__u)...) {}
+  template <class _Alloc,
+            template <class...> class _And                                  = _And,
+            __enable_if_t< _And<is_copy_constructible<_Tp>...>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t)
+      : __base_(allocator_arg_t(), __alloc, __t) {}
 
-    template <class _Alloc, class ..._Up, __enable_if_t<
-        _And<
-            _BoolConstant<sizeof...(_Up) == sizeof...(_Tp)>,
-            _EnableUTypesCtor<_Up...>,
-            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    explicit tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
-        : __base_(allocator_arg_t(), __a,
-                    typename __make_tuple_indices<sizeof...(_Up)>::type(),
-                    typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
-                    typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
-                    typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
-                    _VSTD::forward<_Up>(__u)...) {}
+  template <class _Alloc,
+            template <class...> class _And                                  = _And,
+            __enable_if_t< _And<is_move_constructible<_Tp>...>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t)
+      : __base_(allocator_arg_t(), __alloc, std::move(__t)) {}
 
-    // Copy and move constructors (including the allocator_arg_t variants)
-    tuple(const tuple&) = default;
-    tuple(tuple&&) = default;
+  // tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
 
-    template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
-        _And<is_copy_constructible<_Tp>...>::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t)
-        : __base_(allocator_arg_t(), __alloc, __t)
-    { }
+  template <class _OtherTuple, class _DecayedOtherTuple = __remove_cvref_t<_OtherTuple>, class = void>
+  struct _EnableCtorFromUTypesTuple : false_type {};
 
-    template <class _Alloc, template<class...> class _And = _And, __enable_if_t<
-        _And<is_move_constructible<_Tp>...>::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t)
-        : __base_(allocator_arg_t(), __alloc, _VSTD::move(__t))
-    { }
+  template <class _OtherTuple, class... _Up>
+  struct _EnableCtorFromUTypesTuple<
+      _OtherTuple,
+      tuple<_Up...>,
+      // the length of the packs needs to checked first otherwise the 2 packs cannot be expanded simultaneously below
+      __enable_if_t<sizeof...(_Up) == sizeof...(_Tp)>>
+      : _And<
+            // the two conditions below are not in spec. The purpose is to disable the UTypes Ctor when copy/move Ctor
+            // can work. Otherwise, is_constructible can trigger hard error in those cases
+            // https://godbolt.org/z/M94cGdKcE
+            _Not<is_same<_OtherTuple, const tuple&> >,
+            _Not<is_same<_OtherTuple, tuple&&> >,
+            is_constructible<_Tp, __copy_cvref_t<_OtherTuple, _Up> >...,
+            _Lazy<_Or,
+                  _BoolConstant<sizeof...(_Tp) != 1>,
+                  // _Tp and _Up are 1-element packs - the pack expansions look
+                  // weird to avoid tripping up the type traits in degenerate cases
+                  _Lazy<_And,
+                        _Not<is_same<_Tp, _Up> >...,
+                        _Not<is_convertible<_OtherTuple, _Tp> >...,
+                        _Not<is_constructible<_Tp, _OtherTuple> >... > > > {};
 
-    // tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
+  template <class... _Up, __enable_if_t< _And< _EnableCtorFromUTypesTuple<const tuple<_Up...>&> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> >::value)
+      tuple(const tuple<_Up...>& __t) noexcept(_And<is_nothrow_constructible<_Tp, const _Up&>...>::value)
+      : __base_(__t) {}
 
-    template <class _OtherTuple, class _DecayedOtherTuple = __remove_cvref_t<_OtherTuple>, class = void>
-    struct _EnableCtorFromUTypesTuple : false_type {};
+  template <class... _Up,
+            class _Alloc,
+            __enable_if_t< _And< _EnableCtorFromUTypesTuple<const tuple<_Up...>&> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> >::value)
+      tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
+      : __base_(allocator_arg_t(), __a, __t) {}
 
-    template <class _OtherTuple, class... _Up>
-    struct _EnableCtorFromUTypesTuple<_OtherTuple, tuple<_Up...>,
-              // the length of the packs needs to checked first otherwise the 2 packs cannot be expanded simultaneously below
-               __enable_if_t<sizeof...(_Up) == sizeof...(_Tp)>> : _And<
-        // the two conditions below are not in spec. The purpose is to disable the UTypes Ctor when copy/move Ctor can work.
-        // Otherwise, is_constructible can trigger hard error in those cases https://godbolt.org/z/M94cGdKcE
-        _Not<is_same<_OtherTuple, const tuple&> >,
-        _Not<is_same<_OtherTuple, tuple&&> >,
-        is_constructible<_Tp, __copy_cvref_t<_OtherTuple, _Up> >...,
-        _Lazy<_Or, _BoolConstant<sizeof...(_Tp) != 1>,
-            // _Tp and _Up are 1-element packs - the pack expansions look
-            // weird to avoid tripping up the type traits in degenerate cases
-            _Lazy<_And,
-                _Not<is_same<_Tp, _Up> >...,
-                _Not<is_convertible<_OtherTuple, _Tp> >...,
-                _Not<is_constructible<_Tp, _OtherTuple> >...
-            >
-        >
-    > {};
+#  if _LIBCPP_STD_VER >= 23
+  // tuple(tuple<U...>&) constructors (including allocator_arg_t variants)
 
-    template <class ..._Up, __enable_if_t<
-        _And<
-            _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
-            is_convertible<const _Up&, _Tp>... // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    tuple(const tuple<_Up...>& __t)
-        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
-        : __base_(__t)
-    { }
+  template <class... _Up, enable_if_t< _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<_Up&, _Tp>...>::value) tuple(tuple<_Up...>& __t)
+      : __base_(__t) {}
 
-    template <class ..._Up, __enable_if_t<
-        _And<
-            _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
-            _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit tuple(const tuple<_Up...>& __t)
-        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, const _Up&>...>::value))
-        : __base_(__t)
-    { }
+  template <class _Alloc, class... _Up, enable_if_t< _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<_Up&, _Tp>...>::value)
+      tuple(allocator_arg_t, const _Alloc& __alloc, tuple<_Up...>& __t)
+      : __base_(allocator_arg_t(), __alloc, __t) {}
+#  endif // _LIBCPP_STD_VER >= 23
 
-    template <class ..._Up, class _Alloc, __enable_if_t<
-        _And<
-            _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
-            is_convertible<const _Up&, _Tp>... // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
-        : __base_(allocator_arg_t(), __a, __t)
-    { }
+  // tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
+  template <class... _Up, __enable_if_t< _And< _EnableCtorFromUTypesTuple<tuple<_Up...>&&> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)
+      tuple(tuple<_Up...>&& __t) noexcept(_And<is_nothrow_constructible<_Tp, _Up>...>::value)
+      : __base_(std::move(__t)) {}
 
-    template <class ..._Up, class _Alloc, __enable_if_t<
-        _And<
-            _EnableCtorFromUTypesTuple<const tuple<_Up...>&>,
-            _Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    explicit tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
-        : __base_(allocator_arg_t(), __a, __t)
-    { }
+  template <class _Alloc,
+            class... _Up,
+            __enable_if_t< _And< _EnableCtorFromUTypesTuple<tuple<_Up...>&&> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)
+      tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
+      : __base_(allocator_arg_t(), __a, std::move(__t)) {}
 
-#if _LIBCPP_STD_VER >= 23
-    // tuple(tuple<U...>&) constructors (including allocator_arg_t variants)
+#  if _LIBCPP_STD_VER >= 23
+  // tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)
 
-    template <class... _Up, enable_if_t<
-        _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<_Up&, _Tp> && ...))
-    tuple(tuple<_Up...>& __t) : __base_(__t) {}
+  template <class... _Up, enable_if_t< _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<const _Up&&, _Tp>...>::value)
+      tuple(const tuple<_Up...>&& __t)
+      : __base_(std::move(__t)) {}
 
-    template <class _Alloc, class... _Up, enable_if_t<
-        _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<_Up&, _Tp> && ...))
-    tuple(allocator_arg_t, const _Alloc& __alloc, tuple<_Up...>& __t) : __base_(allocator_arg_t(), __alloc, __t) {}
-#endif // _LIBCPP_STD_VER >= 23
+  template <class _Alloc,
+            class... _Up,
+            enable_if_t< _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<const _Up&&, _Tp>...>::value)
+      tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)
+      : __base_(allocator_arg_t(), __alloc, std::move(__t)) {}
+#  endif // _LIBCPP_STD_VER >= 23
 
-    // tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
+  // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
 
-    template <class ..._Up, __enable_if_t<
-        _And<
-            _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
-            is_convertible<_Up, _Tp>... // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    tuple(tuple<_Up...>&& __t)
-        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
-        : __base_(_VSTD::move(__t))
-    { }
+  template <template <class...> class _Pred,
+            class _Pair,
+            class _DecayedPair = __remove_cvref_t<_Pair>,
+            class _Tuple       = tuple>
+  struct _CtorPredicateFromPair : false_type {};
 
-    template <class ..._Up, __enable_if_t<
-        _And<
-            _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
-            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit tuple(tuple<_Up...>&& __t)
-        _NOEXCEPT_((_And<is_nothrow_constructible<_Tp, _Up>...>::value))
-        : __base_(_VSTD::move(__t))
-    { }
+  template <template <class...> class _Pred, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
+  struct _CtorPredicateFromPair<_Pred, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> >
+      : _And< _Pred<_Tp1, __copy_cvref_t<_Pair, _Up1> >, _Pred<_Tp2, __copy_cvref_t<_Pair, _Up2> > > {};
 
-    template <class _Alloc, class ..._Up, __enable_if_t<
-        _And<
-            _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
-            is_convertible<_Up, _Tp>... // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
-        : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
-    { }
+  template <class _Pair>
+  struct _EnableCtorFromPair : _CtorPredicateFromPair<is_constructible, _Pair> {};
 
-    template <class _Alloc, class ..._Up, __enable_if_t<
-        _And<
-            _EnableCtorFromUTypesTuple<tuple<_Up...>&&>,
-            _Not<_Lazy<_And, is_convertible<_Up, _Tp>...> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    explicit tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
-        : __base_(allocator_arg_t(), __a, _VSTD::move(__t))
-    { }
+  template <class _Pair>
+  struct _NothrowConstructibleFromPair : _CtorPredicateFromPair<is_nothrow_constructible, _Pair> {};
 
-#if _LIBCPP_STD_VER >= 23
-    // tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)
+  template <class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
+  struct _BothImplicitlyConvertible : false_type {};
 
-    template <class... _Up, enable_if_t<
-        _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
-    tuple(const tuple<_Up...>&& __t) : __base_(std::move(__t)) {}
+  template <class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
+  struct _BothImplicitlyConvertible<_Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> >
+      : _And< is_convertible<__copy_cvref_t<_Pair, _Up1>, _Tp1>, is_convertible<__copy_cvref_t<_Pair, _Up2>, _Tp2> > {};
 
-    template <class _Alloc, class... _Up, enable_if_t<
-        _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!(is_convertible_v<const _Up&&, _Tp> && ...))
-    tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)
-        : __base_(allocator_arg_t(), __alloc, std::move(__t)) {}
-#endif // _LIBCPP_STD_VER >= 23
+  template <class _Up1,
+            class _Up2,
+            template <class...> class _And                                                   = _And,
+            __enable_if_t< _And< _EnableCtorFromPair<const pair<_Up1, _Up2>&> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> >::value)
+      tuple(const pair<_Up1, _Up2>& __p) noexcept(_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value)
+      : __base_(__p) {}
 
-    // tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
+  template <class _Alloc,
+            class _Up1,
+            class _Up2,
+            template <class...> class _And                                                   = _And,
+            __enable_if_t< _And< _EnableCtorFromPair<const pair<_Up1, _Up2>&> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> >::value)
+      tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
+      : __base_(allocator_arg_t(), __a, __p) {}
 
-    template <template <class...> class Pred, class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
-    struct _CtorPredicateFromPair : false_type{};
+#  if _LIBCPP_STD_VER >= 23
+  // tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants)
 
-    template <template <class...> class Pred, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
-    struct _CtorPredicateFromPair<Pred, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
-        Pred<_Tp1, __copy_cvref_t<_Pair, _Up1> >,
-        Pred<_Tp2, __copy_cvref_t<_Pair, _Up2> >
-    > {};
+  template <class _U1, class _U2, enable_if_t< _EnableCtorFromPair<pair<_U1, _U2>&>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
+      tuple(pair<_U1, _U2>& __p)
+      : __base_(__p) {}
 
-    template <class _Pair>
-    struct _EnableCtorFromPair : _CtorPredicateFromPair<is_constructible, _Pair>{};
+  template <class _Alloc,
+            class _U1,
+            class _U2,
+            enable_if_t< _EnableCtorFromPair<std::pair<_U1, _U2>&>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
+      tuple(allocator_arg_t, const _Alloc& __alloc, pair<_U1, _U2>& __p)
+      : __base_(allocator_arg_t(), __alloc, __p) {}
+#  endif
 
-    template <class _Pair>
-    struct _NothrowConstructibleFromPair : _CtorPredicateFromPair<is_nothrow_constructible, _Pair>{};
+  // tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
 
-    template <class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
-    struct _BothImplicitlyConvertible : false_type{};
+  template <class _Up1,
+            class _Up2,
+            template <class...> class _And                                              = _And,
+            __enable_if_t< _And< _EnableCtorFromPair<pair<_Up1, _Up2>&&> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> >::value)
+      tuple(pair<_Up1, _Up2>&& __p) noexcept(_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value)
+      : __base_(std::move(__p)) {}
 
-    template <class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
-    struct _BothImplicitlyConvertible<_Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > : _And<
-        is_convertible<__copy_cvref_t<_Pair, _Up1>, _Tp1>,
-        is_convertible<__copy_cvref_t<_Pair, _Up2>, _Tp2>
-    > {};
+  template <class _Alloc,
+            class _Up1,
+            class _Up2,
+            template <class...> class _And                                              = _And,
+            __enable_if_t< _And< _EnableCtorFromPair<pair<_Up1, _Up2>&&> >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> >::value)
+      tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
+      : __base_(allocator_arg_t(), __a, std::move(__p)) {}
 
-    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
-            _BothImplicitlyConvertible<const pair<_Up1, _Up2>&> // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    tuple(const pair<_Up1, _Up2>& __p)
-        _NOEXCEPT_((_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value))
-        : __base_(__p)
-    { }
+#  if _LIBCPP_STD_VER >= 23
+  // tuple(const pair<U1, U2>&&) constructors (including allocator_arg_t variants)
 
-    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
-            _Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit tuple(const pair<_Up1, _Up2>& __p)
-        _NOEXCEPT_((_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value))
-        : __base_(__p)
-    { }
+  template <class _U1, class _U2, enable_if_t< _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
+      tuple(const pair<_U1, _U2>&& __p)
+      : __base_(std::move(__p)) {}
 
-    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
-            _BothImplicitlyConvertible<const pair<_Up1, _Up2>&> // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
-        : __base_(allocator_arg_t(), __a, __p)
-    { }
+  template <class _Alloc,
+            class _U1,
+            class _U2,
+            enable_if_t< _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
+      tuple(allocator_arg_t, const _Alloc& __alloc, const pair<_U1, _U2>&& __p)
+      : __base_(allocator_arg_t(), __alloc, std::move(__p)) {}
+#  endif // _LIBCPP_STD_VER >= 23
 
-    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _EnableCtorFromPair<const pair<_Up1, _Up2>&>,
-            _Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    explicit tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
-        : __base_(allocator_arg_t(), __a, __p)
-    { }
+  // [tuple.assign]
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&
+  operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
+      noexcept(_And<is_nothrow_copy_assignable<_Tp>...>::value) {
+    std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());
+    return *this;
+  }
 
-#if _LIBCPP_STD_VER >= 23
-    // tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants)
+#  if _LIBCPP_STD_VER >= 23
+  _LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(tuple const& __tuple) const
+    requires(_And<is_copy_assignable<const _Tp>...>::value)
+  {
+    std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());
+    return *this;
+  }
 
-    template <class _U1, class _U2, enable_if_t<
-        _EnableCtorFromPair<pair<_U1, _U2>&>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
-    tuple(pair<_U1, _U2>& __p) : __base_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(tuple&& __tuple) const
+    requires(_And<is_assignable<const _Tp&, _Tp>...>::value)
+  {
+    std::__memberwise_forward_assign(
+        *this, std::move(__tuple), __tuple_types<_Tp...>(), typename __make_tuple_indices<sizeof...(_Tp)>::type());
+    return *this;
+  }
+#  endif // _LIBCPP_STD_VER >= 23
 
-    template <class _Alloc, class _U1, class _U2, enable_if_t<
-        _EnableCtorFromPair<std::pair<_U1, _U2>&>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
-    tuple(allocator_arg_t, const _Alloc& __alloc, pair<_U1, _U2>& __p) : __base_(allocator_arg_t(), __alloc, __p) {}
-#endif
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&
+  operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple)
+      noexcept(_And<is_nothrow_move_assignable<_Tp>...>::value) {
+    std::__memberwise_forward_assign(
+        *this, std::move(__tuple), __tuple_types<_Tp...>(), typename __make_tuple_indices<sizeof...(_Tp)>::type());
+    return *this;
+  }
 
-    // tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
+  template <
+      class... _Up,
+      __enable_if_t< _And< _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>, is_assignable<_Tp&, _Up const&>... >::value,
+                     int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple& operator=(tuple<_Up...> const& __tuple)
+      noexcept(_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value) {
+    std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());
+    return *this;
+  }
 
-    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
-            _BothImplicitlyConvertible<pair<_Up1, _Up2>&&> // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    tuple(pair<_Up1, _Up2>&& __p)
-        _NOEXCEPT_((_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value))
-        : __base_(_VSTD::move(__p))
-    { }
+  template <class... _Up,
+            __enable_if_t< _And< _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>, is_assignable<_Tp&, _Up>... >::value,
+                           int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple& operator=(tuple<_Up...>&& __tuple)
+      noexcept(_And<is_nothrow_assignable<_Tp&, _Up>...>::value) {
+    std::__memberwise_forward_assign(
+        *this, std::move(__tuple), __tuple_types<_Up...>(), typename __make_tuple_indices<sizeof...(_Tp)>::type());
+    return *this;
+  }
 
-    template <class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
-            _Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    explicit tuple(pair<_Up1, _Up2>&& __p)
-        _NOEXCEPT_((_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value))
-        : __base_(_VSTD::move(__p))
-    { }
+#  if _LIBCPP_STD_VER >= 23
+  template <class... _UTypes,
+            enable_if_t< _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
+                              is_assignable<const _Tp&, const _UTypes&>...>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(const tuple<_UTypes...>& __u) const {
+    std::__memberwise_copy_assign(*this, __u, typename __make_tuple_indices<sizeof...(_Tp)>::type());
+    return *this;
+  }
 
-    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
-            _BothImplicitlyConvertible<pair<_Up1, _Up2>&&> // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
-        : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
-    { }
+  template <class... _UTypes,
+            enable_if_t< _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
+                              is_assignable<const _Tp&, _UTypes>...>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(tuple<_UTypes...>&& __u) const {
+    std::__memberwise_forward_assign(
+        *this, __u, __tuple_types<_UTypes...>(), typename __make_tuple_indices<sizeof...(_Tp)>::type());
+    return *this;
+  }
+#  endif // _LIBCPP_STD_VER >= 23
 
-    template <class _Alloc, class _Up1, class _Up2, template<class...> class _And = _And, __enable_if_t<
-        _And<
-            _EnableCtorFromPair<pair<_Up1, _Up2>&&>,
-            _Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> > // explicit check
-        >::value
-    , int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    explicit tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
-        : __base_(allocator_arg_t(), __a, _VSTD::move(__p))
-    { }
+  template <template <class...> class _Pred,
+            bool _Const,
+            class _Pair,
+            class _DecayedPair = __remove_cvref_t<_Pair>,
+            class _Tuple       = tuple>
+  struct _AssignPredicateFromPair : false_type {};
 
-#if _LIBCPP_STD_VER >= 23
-    // tuple(const pair<U1, U2>&&) constructors (including allocator_arg_t variants)
+  template <template <class...> class _Pred, bool _Const, class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
+  struct _AssignPredicateFromPair<_Pred, _Const, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> >
+      : _And<_Pred<__maybe_const<_Const, _Tp1>&, __copy_cvref_t<_Pair, _Up1> >,
+             _Pred<__maybe_const<_Const, _Tp2>&, __copy_cvref_t<_Pair, _Up2> > > {};
 
-    template <class _U1, class _U2, enable_if_t<
-        _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
-    tuple(const pair<_U1, _U2>&& __p) : __base_(std::move(__p)) {}
+  template <bool _Const, class _Pair>
+  struct _EnableAssignFromPair : _AssignPredicateFromPair<is_assignable, _Const, _Pair> {};
 
-    template <class _Alloc, class _U1, class _U2, enable_if_t<
-        _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-        explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
-    tuple(allocator_arg_t, const _Alloc& __alloc, const pair<_U1, _U2>&& __p)
-        : __base_(allocator_arg_t(), __alloc, std::move(__p)) {}
-#endif // _LIBCPP_STD_VER >= 23
+  template <bool _Const, class _Pair>
+  struct _NothrowAssignFromPair : _AssignPredicateFromPair<is_nothrow_assignable, _Const, _Pair> {};
 
-    // [tuple.assign]
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
-        _NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value))
-    {
-        _VSTD::__memberwise_copy_assign(*this, __tuple,
-            typename __make_tuple_indices<sizeof...(_Tp)>::type());
-        return *this;
-    }
-
-#if _LIBCPP_STD_VER >= 23
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    const tuple& operator=(tuple const& __tuple) const
-      requires (_And<is_copy_assignable<const _Tp>...>::value) {
-        std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());
-        return *this;
-    }
-
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    const tuple& operator=(tuple&& __tuple) const
-      requires (_And<is_assignable<const _Tp&, _Tp>...>::value) {
-        std::__memberwise_forward_assign(*this,
-                                         std::move(__tuple),
-                                         __tuple_types<_Tp...>(),
-                                         typename __make_tuple_indices<sizeof...(_Tp)>::type());
-        return *this;
-    }
-#endif // _LIBCPP_STD_VER >= 23
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple& operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple)
-        _NOEXCEPT_((_And<is_nothrow_move_assignable<_Tp>...>::value))
-    {
-        _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
-            __tuple_types<_Tp...>(),
-            typename __make_tuple_indices<sizeof...(_Tp)>::type());
-        return *this;
-    }
-
-    template<class... _Up, __enable_if_t<
-        _And<
-            _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
-            is_assignable<_Tp&, _Up const&>...
-        >::value
-    ,int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple& operator=(tuple<_Up...> const& __tuple)
-        _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
-    {
-        _VSTD::__memberwise_copy_assign(*this, __tuple,
-            typename __make_tuple_indices<sizeof...(_Tp)>::type());
-        return *this;
-    }
-
-    template<class... _Up, __enable_if_t<
-        _And<
-            _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
-            is_assignable<_Tp&, _Up>...
-        >::value
-    ,int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple& operator=(tuple<_Up...>&& __tuple)
-        _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
-    {
-        _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
-            __tuple_types<_Up...>(),
-            typename __make_tuple_indices<sizeof...(_Tp)>::type());
-        return *this;
-    }
-
-
-#if _LIBCPP_STD_VER >= 23
-    template <class... _UTypes, enable_if_t<
-        _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
-             is_assignable<const _Tp&, const _UTypes&>...>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    const tuple& operator=(const tuple<_UTypes...>& __u) const {
-        std::__memberwise_copy_assign(*this,
-                                      __u,
-                                      typename __make_tuple_indices<sizeof...(_Tp)>::type());
-        return *this;
-    }
-
-    template <class... _UTypes, enable_if_t<
-        _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
-             is_assignable<const _Tp&, _UTypes>...>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    const tuple& operator=(tuple<_UTypes...>&& __u) const {
-        std::__memberwise_forward_assign(*this,
-                                         __u,
-                                         __tuple_types<_UTypes...>(),
-                                         typename __make_tuple_indices<sizeof...(_Tp)>::type());
-        return *this;
-    }
-#endif // _LIBCPP_STD_VER >= 23
-
-    template <template<class...> class Pred, bool _Const,
-              class _Pair, class _DecayedPair = __remove_cvref_t<_Pair>, class _Tuple = tuple>
-    struct _AssignPredicateFromPair : false_type {};
-
-    template <template<class...> class Pred, bool _Const,
-              class _Pair, class _Up1, class _Up2, class _Tp1, class _Tp2>
-    struct _AssignPredicateFromPair<Pred, _Const, _Pair, pair<_Up1, _Up2>, tuple<_Tp1, _Tp2> > :
-        _And<Pred<__maybe_const<_Const, _Tp1>&, __copy_cvref_t<_Pair, _Up1> >,
-             Pred<__maybe_const<_Const, _Tp2>&, __copy_cvref_t<_Pair, _Up2> >
-            > {};
-
-    template <bool _Const, class _Pair>
-    struct _EnableAssignFromPair : _AssignPredicateFromPair<is_assignable, _Const, _Pair> {};
-
-    template <bool _Const, class _Pair>
-    struct _NothrowAssignFromPair : _AssignPredicateFromPair<is_nothrow_assignable, _Const, _Pair> {};
-
-#if _LIBCPP_STD_VER >= 23
-    template <class _U1, class _U2, enable_if_t<
-        _EnableAssignFromPair<true, const pair<_U1, _U2>&>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    const tuple& operator=(const pair<_U1, _U2>& __pair) const
+#  if _LIBCPP_STD_VER >= 23
+  template <class _U1, class _U2, enable_if_t< _EnableAssignFromPair<true, const pair<_U1, _U2>&>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(const pair<_U1, _U2>& __pair) const
       noexcept(_NothrowAssignFromPair<true, const pair<_U1, _U2>&>::value) {
-        std::get<0>(*this) = __pair.first;
-        std::get<1>(*this) = __pair.second;
-        return *this;
-    }
+    std::get<0>(*this) = __pair.first;
+    std::get<1>(*this) = __pair.second;
+    return *this;
+  }
 
-    template <class _U1, class _U2, enable_if_t<
-        _EnableAssignFromPair<true, pair<_U1, _U2>&&>::value>* = nullptr>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    const tuple& operator=(pair<_U1, _U2>&& __pair) const
+  template <class _U1, class _U2, enable_if_t< _EnableAssignFromPair<true, pair<_U1, _U2>&&>::value>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(pair<_U1, _U2>&& __pair) const
       noexcept(_NothrowAssignFromPair<true, pair<_U1, _U2>&&>::value) {
-        std::get<0>(*this) = std::move(__pair.first);
-        std::get<1>(*this) = std::move(__pair.second);
-        return *this;
-    }
-#endif // _LIBCPP_STD_VER >= 23
+    std::get<0>(*this) = std::move(__pair.first);
+    std::get<1>(*this) = std::move(__pair.second);
+    return *this;
+  }
+#  endif // _LIBCPP_STD_VER >= 23
 
-    template<class _Up1, class _Up2, __enable_if_t<
-        _EnableAssignFromPair<false, pair<_Up1, _Up2> const&>::value
-    ,int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple& operator=(pair<_Up1, _Up2> const& __pair)
-        _NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2> const&>::value))
-    {
-        _VSTD::get<0>(*this) = __pair.first;
-        _VSTD::get<1>(*this) = __pair.second;
-        return *this;
-    }
+  template <class _Up1,
+            class _Up2,
+            __enable_if_t< _EnableAssignFromPair<false, pair<_Up1, _Up2> const&>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple& operator=(pair<_Up1, _Up2> const& __pair)
+      noexcept(_NothrowAssignFromPair<false, pair<_Up1, _Up2> const&>::value) {
+    std::get<0>(*this) = __pair.first;
+    std::get<1>(*this) = __pair.second;
+    return *this;
+  }
 
-    template<class _Up1, class _Up2, __enable_if_t<
-        _EnableAssignFromPair<false, pair<_Up1, _Up2>&&>::value
-    ,int> = 0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple& operator=(pair<_Up1, _Up2>&& __pair)
-        _NOEXCEPT_((_NothrowAssignFromPair<false, pair<_Up1, _Up2>&&>::value))
-    {
-        _VSTD::get<0>(*this) = _VSTD::forward<_Up1>(__pair.first);
-        _VSTD::get<1>(*this) = _VSTD::forward<_Up2>(__pair.second);
-        return *this;
-    }
+  template <class _Up1, class _Up2, __enable_if_t< _EnableAssignFromPair<false, pair<_Up1, _Up2>&&>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple& operator=(pair<_Up1, _Up2>&& __pair)
+      noexcept(_NothrowAssignFromPair<false, pair<_Up1, _Up2>&&>::value) {
+    std::get<0>(*this) = std::forward<_Up1>(__pair.first);
+    std::get<1>(*this) = std::forward<_Up2>(__pair.second);
+    return *this;
+  }
 
-    // EXTENSION
-    template<class _Up, size_t _Np, class = __enable_if_t<
-        _And<
-            _BoolConstant<_Np == sizeof...(_Tp)>,
-            is_assignable<_Tp&, _Up const&>...
-        >::value
-    > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple& operator=(array<_Up, _Np> const& __array)
-        _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
-    {
-        _VSTD::__memberwise_copy_assign(*this, __array,
-            typename __make_tuple_indices<sizeof...(_Tp)>::type());
-        return *this;
-    }
+  // EXTENSION
+  template <
+      class _Up,
+      size_t _Np,
+      __enable_if_t< _And< _BoolConstant<_Np == sizeof...(_Tp)>, is_assignable<_Tp&, _Up const&>... >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple& operator=(array<_Up, _Np> const& __array)
+      noexcept(_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value) {
+    std::__memberwise_copy_assign(*this, __array, typename __make_tuple_indices<sizeof...(_Tp)>::type());
+    return *this;
+  }
 
-    // EXTENSION
-    template<class _Up, size_t _Np, class = void, class = __enable_if_t<
-        _And<
-            _BoolConstant<_Np == sizeof...(_Tp)>,
-            is_assignable<_Tp&, _Up>...
-        >::value
-    > >
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    tuple& operator=(array<_Up, _Np>&& __array)
-        _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
-    {
-        _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__array),
-            __tuple_types<_If<true, _Up, _Tp>...>(),
-            typename __make_tuple_indices<sizeof...(_Tp)>::type());
-        return *this;
-    }
+  // EXTENSION
+  template <class _Up,
+            size_t _Np,
+            class = void,
+            __enable_if_t< _And< _BoolConstant<_Np == sizeof...(_Tp)>, is_assignable<_Tp&, _Up>... >::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple& operator=(array<_Up, _Np>&& __array)
+      noexcept(_And<is_nothrow_assignable<_Tp&, _Up>...>::value) {
+    std::__memberwise_forward_assign(
+        *this,
+        std::move(__array),
+        __tuple_types<_If<true, _Up, _Tp>...>(),
+        typename __make_tuple_indices<sizeof...(_Tp)>::type());
+    return *this;
+  }
 
-    // [tuple.swap]
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
-        {__base_.swap(__t.__base_);}
+  // [tuple.swap]
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(tuple& __t)
+      noexcept(__all<__is_nothrow_swappable_v<_Tp>...>::value) {
+    __base_.swap(__t.__base_);
+  }
 
-#if _LIBCPP_STD_VER >= 23
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    void swap(const tuple& __t) const noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {
-        __base_.swap(__t.__base_);
-    }
-#endif // _LIBCPP_STD_VER >= 23
+#  if _LIBCPP_STD_VER >= 23
+  _LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple& __t) const
+      noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {
+    __base_.swap(__t.__base_);
+  }
+#  endif // _LIBCPP_STD_VER >= 23
 };
 
 template <>
-class _LIBCPP_TEMPLATE_VIS tuple<>
-{
+class _LIBCPP_TEMPLATE_VIS tuple<> {
 public:
-    constexpr tuple() _NOEXCEPT = default;
-    template <class _Alloc>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-        tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
-    template <class _Alloc>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-        tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
-    template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-        tuple(array<_Up, 0>) _NOEXCEPT {}
-    template <class _Alloc, class _Up>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-        tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void swap(tuple&) _NOEXCEPT {}
-#if _LIBCPP_STD_VER >= 23
-    _LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {}
-#endif
+  constexpr tuple() _NOEXCEPT = default;
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
+  template <class _Alloc>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
+  template <class _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple(array<_Up, 0>) _NOEXCEPT {}
+  template <class _Alloc, class _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(tuple&) _NOEXCEPT {}
+#  if _LIBCPP_STD_VER >= 23
+  _LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {}
+#  endif
 };
 
-#if _LIBCPP_STD_VER >= 23
-template <class... _TTypes, class... _UTypes, template<class> class _TQual, template<class> class _UQual>
-    requires requires { typename tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; }
+#  if _LIBCPP_STD_VER >= 23
+template <class... _TTypes, class... _UTypes, template <class> class _TQual, template <class> class _UQual>
+  requires requires { typename tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>; }
 struct basic_common_reference<tuple<_TTypes...>, tuple<_UTypes...>, _TQual, _UQual> {
-    using type = tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>;
+  using type = tuple<common_reference_t<_TQual<_TTypes>, _UQual<_UTypes>>...>;
 };
 
 template <class... _TTypes, class... _UTypes>
-    requires requires { typename tuple<common_type_t<_TTypes, _UTypes>...>; }
+  requires requires { typename tuple<common_type_t<_TTypes, _UTypes>...>; }
 struct common_type<tuple<_TTypes...>, tuple<_UTypes...>> {
-    using type = tuple<common_type_t<_TTypes, _UTypes>...>;
+  using type = tuple<common_type_t<_TTypes, _UTypes>...>;
 };
-#endif // _LIBCPP_STD_VER >= 23
+#  endif // _LIBCPP_STD_VER >= 23
 
-#if _LIBCPP_STD_VER >= 17
-template <class ..._Tp>
+#  if _LIBCPP_STD_VER >= 17
+template <class... _Tp>
 tuple(_Tp...) -> tuple<_Tp...>;
 template <class _Tp1, class _Tp2>
 tuple(pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
-template <class _Alloc, class ..._Tp>
+template <class _Alloc, class... _Tp>
 tuple(allocator_arg_t, _Alloc, _Tp...) -> tuple<_Tp...>;
 template <class _Alloc, class _Tp1, class _Tp2>
 tuple(allocator_arg_t, _Alloc, pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
-template <class _Alloc, class ..._Tp>
+template <class _Alloc, class... _Tp>
 tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>;
-#endif
+#  endif
 
-template <class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-__enable_if_t<__all<__is_swappable<_Tp>::value...>::value, void>
-swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
-                 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
-    {__t.swap(__u);}
-
-#if _LIBCPP_STD_VER >= 23
-template <class... _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr
-enable_if_t<__all<is_swappable_v<const _Tp>...>::value, void>
-swap(const tuple<_Tp...>& __lhs, const tuple<_Tp...>& __rhs)
-        noexcept(__all<is_nothrow_swappable_v<const _Tp>...>::value) {
-    __lhs.swap(__rhs);
+template <class... _Tp, __enable_if_t<__all<__is_swappable_v<_Tp>...>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
+    noexcept(__all<__is_nothrow_swappable_v<_Tp>...>::value) {
+  __t.swap(__u);
 }
-#endif
+
+#  if _LIBCPP_STD_VER >= 23
+template <class... _Tp>
+_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<__all<is_swappable_v<const _Tp>...>::value, void>
+swap(const tuple<_Tp...>& __lhs,
+     const tuple<_Tp...>& __rhs) noexcept(__all<is_nothrow_swappable_v<const _Tp>...>::value) {
+  __lhs.swap(__rhs);
+}
+#  endif
 
 // get
 
-template <size_t _Ip, class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename tuple_element<_Ip, tuple<_Tp...> >::type&
-get(tuple<_Tp...>& __t) _NOEXCEPT
-{
-    typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
-    return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();
+template <size_t _Ip, class... _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, tuple<_Tp...> >::type&
+get(tuple<_Tp...>& __t) _NOEXCEPT {
+  typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
+  return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();
 }
 
-template <size_t _Ip, class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const typename tuple_element<_Ip, tuple<_Tp...> >::type&
-get(const tuple<_Tp...>& __t) _NOEXCEPT
-{
-    typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
-    return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();
+template <size_t _Ip, class... _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, tuple<_Tp...> >::type&
+get(const tuple<_Tp...>& __t) _NOEXCEPT {
+  typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
+  return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();
 }
 
-template <size_t _Ip, class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename tuple_element<_Ip, tuple<_Tp...> >::type&&
-get(tuple<_Tp...>&& __t) _NOEXCEPT
-{
-    typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
-    return static_cast<type&&>(
-             static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());
+template <size_t _Ip, class... _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, tuple<_Tp...> >::type&&
+get(tuple<_Tp...>&& __t) _NOEXCEPT {
+  typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
+  return static_cast<type&&>(static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());
 }
 
-template <size_t _Ip, class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
-get(const tuple<_Tp...>&& __t) _NOEXCEPT
-{
-    typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
-    return static_cast<const type&&>(
-             static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
+template <size_t _Ip, class... _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
+get(const tuple<_Tp...>&& __t) _NOEXCEPT {
+  typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, tuple<_Tp...> >::type type;
+  return static_cast<const type&&>(static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
 }
 
-#if _LIBCPP_STD_VER >= 14
-
-namespace __find_detail {
-
-static constexpr size_t __not_found = static_cast<size_t>(-1);
-static constexpr size_t __ambiguous = __not_found - 1;
-
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr size_t __find_idx_return(size_t __curr_i, size_t __res, bool __matches) {
-    return !__matches ? __res :
-        (__res == __not_found ? __curr_i : __ambiguous);
-}
-
-template <size_t _Nx>
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr size_t __find_idx(size_t __i, const bool (&__matches)[_Nx]) {
-  return __i == _Nx ? __not_found :
-      __find_detail::__find_idx_return(__i, __find_detail::__find_idx(__i + 1, __matches), __matches[__i]);
-}
-
-template <class _T1, class ..._Args>
-struct __find_exactly_one_checked {
-    static constexpr bool __matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...};
-    static constexpr size_t value = __find_detail::__find_idx(0, __matches);
-    static_assert(value != __not_found, "type not found in type list" );
-    static_assert(value != __ambiguous, "type occurs more than once in type list");
-};
-
-template <class _T1>
-struct __find_exactly_one_checked<_T1> {
-    static_assert(!is_same<_T1, _T1>::value, "type not in empty type list");
-};
-
-} // namespace __find_detail
-
-template <typename _T1, typename... _Args>
-struct __find_exactly_one_t
-    : public __find_detail::__find_exactly_one_checked<_T1, _Args...> {
-};
+#  if _LIBCPP_STD_VER >= 14
 
 template <class _T1, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr _T1& get(tuple<_Args...>& __tup) noexcept
-{
-    return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(tuple<_Args...>& __tup) noexcept {
+  return std::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
 }
 
 template <class _T1, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept
-{
-    return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept {
+  return std::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
 }
 
 template <class _T1, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept
-{
-    return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept {
+  return std::get<__find_exactly_one_t<_T1, _Args...>::value>(std::move(__tup));
 }
 
 template <class _T1, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept
-{
-    return _VSTD::get<__find_exactly_one_t<_T1, _Args...>::value>(_VSTD::move(__tup));
+inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept {
+  return std::get<__find_exactly_one_t<_T1, _Args...>::value>(std::move(__tup));
 }
 
-#endif
+#  endif
 
 // tie
 
-template <class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-tuple<_Tp&...>
-tie(_Tp&... __t) _NOEXCEPT
-{
-    return tuple<_Tp&...>(__t...);
-}
-
-template <class _Up>
-struct __ignore_t
-{
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    const __ignore_t& operator=(_Tp&&) const {return *this;}
-};
-
-#  if _LIBCPP_STD_VER >= 17
-inline constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
-#  else
-namespace {
-  constexpr __ignore_t<unsigned char> ignore = __ignore_t<unsigned char>();
-} // namespace
-#  endif
-
 template <class... _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-tuple<typename __unwrap_ref_decay<_Tp>::type...>
-make_tuple(_Tp&&... __t)
-{
-    return tuple<typename __unwrap_ref_decay<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<_Tp&...> tie(_Tp&... __t) _NOEXCEPT {
+  return tuple<_Tp&...>(__t...);
 }
 
 template <class... _Tp>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-tuple<_Tp&&...>
-forward_as_tuple(_Tp&&... __t) _NOEXCEPT
-{
-    return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<typename __unwrap_ref_decay<_Tp>::type...>
+make_tuple(_Tp&&... __t) {
+  return tuple<typename __unwrap_ref_decay<_Tp>::type...>(std::forward<_Tp>(__t)...);
+}
+
+template <class... _Tp>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<_Tp&&...> forward_as_tuple(_Tp&&... __t) _NOEXCEPT {
+  return tuple<_Tp&&...>(std::forward<_Tp>(__t)...);
 }
 
 template <size_t _Ip>
-struct __tuple_equal
-{
-    template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _Tp& __x, const _Up& __y)
-    {
-        return __tuple_equal<_Ip - 1>()(__x, __y) && _VSTD::get<_Ip-1>(__x) == _VSTD::get<_Ip-1>(__y);
-    }
+struct __tuple_equal {
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp& __x, const _Up& __y) {
+    return __tuple_equal<_Ip - 1>()(__x, __y) && std::get<_Ip - 1>(__x) == std::get<_Ip - 1>(__y);
+  }
 };
 
 template <>
-struct __tuple_equal<0>
-{
-    template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _Tp&, const _Up&)
-    {
-        return true;
-    }
+struct __tuple_equal<0> {
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp&, const _Up&) {
+    return true;
+  }
 };
 
-template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
-{
-    static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
-    return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
+template <class... _Tp, class... _Up>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
+  static_assert(sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
+  return __tuple_equal<sizeof...(_Tp)>()(__x, __y);
 }
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
 
 // operator<=>
 
-template <class ..._Tp, class ..._Up, size_t ..._Is>
-_LIBCPP_HIDE_FROM_ABI constexpr
-auto
+template <class... _Tp, class... _Up, size_t... _Is>
+_LIBCPP_HIDE_FROM_ABI constexpr auto
 __tuple_compare_three_way(const tuple<_Tp...>& __x, const tuple<_Up...>& __y, index_sequence<_Is...>) {
-    common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> __result = strong_ordering::equal;
-    static_cast<void>(((__result = _VSTD::__synth_three_way(_VSTD::get<_Is>(__x), _VSTD::get<_Is>(__y)), __result != 0) || ...));
-    return __result;
+  common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> __result = strong_ordering::equal;
+  static_cast<void>(
+      ((__result = std::__synth_three_way(std::get<_Is>(__x), std::get<_Is>(__y)), __result != 0) || ...));
+  return __result;
 }
 
-template <class ..._Tp, class ..._Up>
-requires (sizeof...(_Tp) == sizeof...(_Up))
-_LIBCPP_HIDE_FROM_ABI constexpr
-common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>
-operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
-{
-    return _VSTD::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{});
+template <class... _Tp, class... _Up>
+  requires(sizeof...(_Tp) == sizeof...(_Up))
+_LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>
+operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
+  return std::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{});
 }
 
-#else // _LIBCPP_STD_VER >= 20
+#  else // _LIBCPP_STD_VER >= 20
 
-template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
-{
-    return !(__x == __y);
+template <class... _Tp, class... _Up>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator!=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
+  return !(__x == __y);
 }
 
 template <size_t _Ip>
-struct __tuple_less
-{
-    template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _Tp& __x, const _Up& __y)
-    {
-        const size_t __idx = tuple_size<_Tp>::value - _Ip;
-        if (_VSTD::get<__idx>(__x) < _VSTD::get<__idx>(__y))
-            return true;
-        if (_VSTD::get<__idx>(__y) < _VSTD::get<__idx>(__x))
-            return false;
-        return __tuple_less<_Ip-1>()(__x, __y);
-    }
+struct __tuple_less {
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp& __x, const _Up& __y) {
+    const size_t __idx = tuple_size<_Tp>::value - _Ip;
+    if (std::get<__idx>(__x) < std::get<__idx>(__y))
+      return true;
+    if (std::get<__idx>(__y) < std::get<__idx>(__x))
+      return false;
+    return __tuple_less<_Ip - 1>()(__x, __y);
+  }
 };
 
 template <>
-struct __tuple_less<0>
-{
-    template <class _Tp, class _Up>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    bool operator()(const _Tp&, const _Up&)
-    {
-        return false;
-    }
+struct __tuple_less<0> {
+  template <class _Tp, class _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp&, const _Up&) {
+    return false;
+  }
 };
 
-template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
-{
-    static_assert (sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
-    return __tuple_less<sizeof...(_Tp)>()(__x, __y);
+template <class... _Tp, class... _Up>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator<(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
+  static_assert(sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
+  return __tuple_less<sizeof...(_Tp)>()(__x, __y);
 }
 
-template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
-{
-    return __y < __x;
+template <class... _Tp, class... _Up>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
+  return __y < __x;
 }
 
-template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
-{
-    return !(__x < __y);
+template <class... _Tp, class... _Up>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator>=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
+  return !(__x < __y);
 }
 
-template <class ..._Tp, class ..._Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-bool
-operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
-{
-    return !(__y < __x);
+template <class... _Tp, class... _Up>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
+operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
+  return !(__y < __x);
 }
 
-#endif // _LIBCPP_STD_VER >= 20
+#  endif // _LIBCPP_STD_VER >= 20
 
 // tuple_cat
 
-template <class _Tp, class _Up> struct __tuple_cat_type;
+template <class _Tp, class _Up>
+struct __tuple_cat_type;
 
-template <class ..._Ttypes, class ..._Utypes>
-struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
-{
-    typedef _LIBCPP_NODEBUG tuple<_Ttypes..., _Utypes...> type;
+template <class... _Ttypes, class... _Utypes>
+struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> > {
+  typedef _LIBCPP_NODEBUG tuple<_Ttypes..., _Utypes...> type;
 };
 
-template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
-struct __tuple_cat_return_1
-{
+template <class _ResultTuple, bool _Is_Tuple0TupleLike, class... _Tuples>
+struct __tuple_cat_return_1 {};
+
+template <class... _Types, class _Tuple0>
+struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0> {
+  using type _LIBCPP_NODEBUG =
+      typename __tuple_cat_type< tuple<_Types...>,
+                                 typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type >::type;
 };
 
-template <class ..._Types, class _Tuple0>
-struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
-{
-  using type _LIBCPP_NODEBUG = typename __tuple_cat_type<
-      tuple<_Types...>,
-      typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type
-    >::type;
-};
-
-template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
+template <class... _Types, class _Tuple0, class _Tuple1, class... _Tuples>
 struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
     : public __tuple_cat_return_1<
-                 typename __tuple_cat_type<
-                     tuple<_Types...>,
-                     typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type
-                 >::type,
-                 __tuple_like_ext<__libcpp_remove_reference_t<_Tuple1> >::value,
-                 _Tuple1, _Tuples...>
-{
-};
+          typename __tuple_cat_type< tuple<_Types...>,
+                                     typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type >::type,
+          __tuple_like_ext<__libcpp_remove_reference_t<_Tuple1> >::value,
+          _Tuple1,
+          _Tuples...> {};
 
-template <class ..._Tuples> struct __tuple_cat_return;
+template <class... _Tuples>
+struct __tuple_cat_return;
 
-template <class _Tuple0, class ..._Tuples>
+template <class _Tuple0, class... _Tuples>
 struct __tuple_cat_return<_Tuple0, _Tuples...>
     : public __tuple_cat_return_1<tuple<>,
-         __tuple_like_ext<__libcpp_remove_reference_t<_Tuple0> >::value, _Tuple0,
-                                                                     _Tuples...>
-{
-};
+                                  __tuple_like_ext<__libcpp_remove_reference_t<_Tuple0> >::value,
+                                  _Tuple0,
+                                  _Tuples...> {};
 
 template <>
-struct __tuple_cat_return<>
-{
-    typedef _LIBCPP_NODEBUG tuple<> type;
+struct __tuple_cat_return<> {
+  typedef _LIBCPP_NODEBUG tuple<> type;
 };
 
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-tuple<>
-tuple_cat()
-{
-    return tuple<>();
-}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<> tuple_cat() { return tuple<>(); }
 
-template <class _Rp, class _Indices, class _Tuple0, class ..._Tuples>
+template <class _Rp, class _Indices, class _Tuple0, class... _Tuples>
 struct __tuple_cat_return_ref_imp;
 
-template <class ..._Types, size_t ..._I0, class _Tuple0>
-struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
-{
-    typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
-    typedef tuple<_Types..., __apply_cv_t<_Tuple0, typename tuple_element<_I0, _T0>::type>&&...> type;
+template <class... _Types, size_t... _I0, class _Tuple0>
+struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0> {
+  typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
+  typedef tuple<_Types..., __copy_cvref_t<_Tuple0, typename tuple_element<_I0, _T0>::type>&&...> type;
 };
 
-template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
-struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
-                                  _Tuple0, _Tuple1, _Tuples...>
+template <class... _Types, size_t... _I0, class _Tuple0, class _Tuple1, class... _Tuples>
+struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0, _Tuple1, _Tuples...>
     : public __tuple_cat_return_ref_imp<
-         tuple<_Types..., __apply_cv_t<_Tuple0,
-                                       typename tuple_element<_I0, __libcpp_remove_reference_t<_Tuple0>>::type>&&...>,
-         typename __make_tuple_indices<tuple_size<__libcpp_remove_reference_t<_Tuple1> >::value>::type,
-         _Tuple1, _Tuples...>
-{
-};
+          tuple<_Types...,
+                __copy_cvref_t<_Tuple0, typename tuple_element<_I0, __libcpp_remove_reference_t<_Tuple0>>::type>&&...>,
+          typename __make_tuple_indices<tuple_size<__libcpp_remove_reference_t<_Tuple1> >::value>::type,
+          _Tuple1,
+          _Tuples...> {};
 
-template <class _Tuple0, class ..._Tuples>
+template <class _Tuple0, class... _Tuples>
 struct __tuple_cat_return_ref
-    : public __tuple_cat_return_ref_imp<tuple<>,
-               typename __make_tuple_indices<
-                        tuple_size<__libcpp_remove_reference_t<_Tuple0> >::value
-               >::type, _Tuple0, _Tuples...>
-{
-};
+    : public __tuple_cat_return_ref_imp<
+          tuple<>,
+          typename __make_tuple_indices< tuple_size<__libcpp_remove_reference_t<_Tuple0> >::value >::type,
+          _Tuple0,
+          _Tuples...> {};
 
 template <class _Types, class _I0, class _J0>
 struct __tuple_cat;
 
-template <class ..._Types, size_t ..._I0, size_t ..._J0>
-struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
-{
-    template <class _Tuple0>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
-    operator()(tuple<_Types...> __t, _Tuple0&& __t0)
-    {
-        (void)__t; // avoid unused parameter warning on GCC when _I0 is empty
-        return _VSTD::forward_as_tuple(
-            _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
-            _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
-    }
+template <class... _Types, size_t... _I0, size_t... _J0>
+struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> > {
+  template <class _Tuple0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
+  typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
+  operator()(tuple<_Types...> __t, _Tuple0&& __t0) {
+    (void)__t; // avoid unused parameter warning on GCC when _I0 is empty
+    return std::forward_as_tuple(
+        std::forward<_Types>(std::get<_I0>(__t))..., std::get<_J0>(std::forward<_Tuple0>(__t0))...);
+  }
 
-    template <class _Tuple0, class _Tuple1, class ..._Tuples>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
-    operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
-    {
-        (void)__t; // avoid unused parameter warning on GCC when _I0 is empty
-        typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
-        typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple1> _T1;
-        return __tuple_cat<tuple<_Types..., __apply_cv_t<_Tuple0, typename tuple_element<_J0, _T0>::type>&&...>,
-                           typename __make_tuple_indices<sizeof...(_Types) + tuple_size<_T0>::value>::type,
-                           typename __make_tuple_indices<tuple_size<_T1>::value>::type>()(
-            _VSTD::forward_as_tuple(
-                _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
-                _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...),
-            _VSTD::forward<_Tuple1>(__t1), _VSTD::forward<_Tuples>(__tpls)...);
-    }
+  template <class _Tuple0, class _Tuple1, class... _Tuples>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
+  typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
+  operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&&... __tpls) {
+    (void)__t; // avoid unused parameter warning on GCC when _I0 is empty
+    typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
+    typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple1> _T1;
+    return __tuple_cat<tuple<_Types..., __copy_cvref_t<_Tuple0, typename tuple_element<_J0, _T0>::type>&&...>,
+                       typename __make_tuple_indices<sizeof...(_Types) + tuple_size<_T0>::value>::type,
+                       typename __make_tuple_indices<tuple_size<_T1>::value>::type>()(
+        std::forward_as_tuple(
+            std::forward<_Types>(std::get<_I0>(__t))..., std::get<_J0>(std::forward<_Tuple0>(__t0))...),
+        std::forward<_Tuple1>(__t1),
+        std::forward<_Tuples>(__tpls)...);
+  }
 };
 
 template <class _Tuple0, class... _Tuples>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14
-typename __tuple_cat_return<_Tuple0, _Tuples...>::type
-tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
-{
-    typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
-    return __tuple_cat<tuple<>, __tuple_indices<>,
-                  typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
-                  (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
-                                            _VSTD::forward<_Tuples>(__tpls)...);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename __tuple_cat_return<_Tuple0, _Tuples...>::type
+tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls) {
+  typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tuple0> _T0;
+  return __tuple_cat<tuple<>, __tuple_indices<>, typename __make_tuple_indices<tuple_size<_T0>::value>::type>()(
+      tuple<>(), std::forward<_Tuple0>(__t0), std::forward<_Tuples>(__tpls)...);
 }
 
-template <class ..._Tp, class _Alloc>
-struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc>
-    : true_type {};
+template <class... _Tp, class _Alloc>
+struct _LIBCPP_TEMPLATE_VIS uses_allocator<tuple<_Tp...>, _Alloc> : true_type {};
 
-template <class _T1, class _T2>
-template <class... _Args1, class... _Args2, size_t ..._I1, size_t ..._I2>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
-pair<_T1, _T2>::pair(piecewise_construct_t,
-                     tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
-                     __tuple_indices<_I1...>, __tuple_indices<_I2...>)
-    :  first(_VSTD::forward<_Args1>(_VSTD::get<_I1>( __first_args))...),
-      second(_VSTD::forward<_Args2>(_VSTD::get<_I2>(__second_args))...)
-{
-}
+#  if _LIBCPP_STD_VER >= 17
+#    define _LIBCPP_NOEXCEPT_RETURN(...)                                                                               \
+      noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
 
-#if _LIBCPP_STD_VER >= 17
-template <class _Tp>
-inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
-
-#define _LIBCPP_NOEXCEPT_RETURN(...) noexcept(noexcept(__VA_ARGS__)) { return __VA_ARGS__; }
-
-template <class _Fn, class _Tuple, size_t ..._Id>
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr decltype(auto) __apply_tuple_impl(_Fn && __f, _Tuple && __t,
-                                            __tuple_indices<_Id...>)
-_LIBCPP_NOEXCEPT_RETURN(
-    _VSTD::__invoke(
-        _VSTD::forward<_Fn>(__f),
-        _VSTD::get<_Id>(_VSTD::forward<_Tuple>(__t))...)
-)
+// The _LIBCPP_NOEXCEPT_RETURN macro breaks formatting.
+// clang-format off
+template <class _Fn, class _Tuple, size_t... _Id>
+inline _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto)
+__apply_tuple_impl(_Fn&& __f, _Tuple&& __t, __tuple_indices<_Id...>)
+    _LIBCPP_NOEXCEPT_RETURN(std::__invoke(std::forward<_Fn>(__f), std::get<_Id>(std::forward<_Tuple>(__t))...))
 
 template <class _Fn, class _Tuple>
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr decltype(auto) apply(_Fn && __f, _Tuple && __t)
-_LIBCPP_NOEXCEPT_RETURN(
-    _VSTD::__apply_tuple_impl(
-        _VSTD::forward<_Fn>(__f), _VSTD::forward<_Tuple>(__t),
-        typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
-)
+inline _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) apply(_Fn&& __f, _Tuple&& __t)
+    _LIBCPP_NOEXCEPT_RETURN(std::__apply_tuple_impl(
+        std::forward<_Fn>(__f),
+        std::forward<_Tuple>(__t),
+        typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{}))
+
+#if _LIBCPP_STD_VER >= 20
+template <class _Tp, class _Tuple, size_t... _Idx>
+inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
+  noexcept(noexcept(_Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...)))
+  requires is_constructible_v<_Tp, decltype(std::get<_Idx>(std::forward<_Tuple>(__t)))...> {
+  return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...);
+}
+#else
+template <class _Tp, class _Tuple, size_t... _Idx>
+inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>,
+    enable_if_t<is_constructible_v<_Tp, decltype(std::get<_Idx>(std::forward<_Tuple>(__t)))...>> * = nullptr)
+    _LIBCPP_NOEXCEPT_RETURN(_Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...))
+#endif // _LIBCPP_STD_VER >= 20
+
+template <class _Tp, class _Tuple,
+          class _Seq = typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type, class = void>
+inline constexpr bool __can_make_from_tuple = false;
 
 template <class _Tp, class _Tuple, size_t... _Idx>
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)
-_LIBCPP_NOEXCEPT_RETURN(
-    _Tp(_VSTD::get<_Idx>(_VSTD::forward<_Tuple>(__t))...)
-)
+inline constexpr bool __can_make_from_tuple<_Tp, _Tuple, __tuple_indices<_Idx...>,
+    enable_if_t<is_constructible_v<_Tp, decltype(std::get<_Idx>(std::declval<_Tuple>()))...>>> = true;
 
+// Based on LWG3528(https://wg21.link/LWG3528) and http://eel.is/c++draft/description#structure.requirements-9,
+// the standard allows to impose requirements, we constraint std::make_from_tuple to make std::make_from_tuple
+// SFINAE friendly and also avoid worse diagnostic messages. We still keep the constraints of std::__make_from_tuple_impl
+// so that std::__make_from_tuple_impl will have the same advantages when used alone.
+#if _LIBCPP_STD_VER >= 20
 template <class _Tp, class _Tuple>
-inline _LIBCPP_INLINE_VISIBILITY
-constexpr _Tp make_from_tuple(_Tuple&& __t)
-_LIBCPP_NOEXCEPT_RETURN(
-    _VSTD::__make_from_tuple_impl<_Tp>(_VSTD::forward<_Tuple>(__t),
-        typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{})
-)
+  requires __can_make_from_tuple<_Tp, _Tuple> // strengthen
+#else
+template <class _Tp, class _Tuple, class = enable_if_t<__can_make_from_tuple<_Tp, _Tuple>>> // strengthen
+#endif // _LIBCPP_STD_VER >= 20
+inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp make_from_tuple(_Tuple&& __t)
+    _LIBCPP_NOEXCEPT_RETURN(std::__make_from_tuple_impl<_Tp>(
+        std::forward<_Tuple>(__t), typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{}))
+#    undef _LIBCPP_NOEXCEPT_RETURN
 
-#undef _LIBCPP_NOEXCEPT_RETURN
-
-#endif // _LIBCPP_STD_VER >= 17
+#  endif // _LIBCPP_STD_VER >= 17
 
 #endif // !defined(_LIBCPP_CXX03_LANG)
 
 _LIBCPP_END_NAMESPACE_STD
 
+_LIBCPP_POP_MACROS
+
+// clang-format on
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <exception>
 #  include <iosfwd>
diff --git a/third_party/libcxx/type_traits b/third_party/libcxx/type_traits
index 466aeb6e0..7f231cd09 100644
--- a/third_party/libcxx/type_traits
+++ b/third_party/libcxx/type_traits
@@ -416,9 +416,9 @@ namespace std
 }
 
 */
-#include <__assert> // all public C++ headers provide the assertion handler
+
 #include <__config>
-#include <__fwd/hash.h> // This is https://llvm.org/PR56938
+#include <__fwd/functional.h> // This is https://llvm.org/PR56938
 #include <__type_traits/add_const.h>
 #include <__type_traits/add_cv.h>
 #include <__type_traits/add_lvalue_reference.h>
@@ -428,115 +428,92 @@ namespace std
 #include <__type_traits/aligned_storage.h>
 #include <__type_traits/aligned_union.h>
 #include <__type_traits/alignment_of.h>
-#include <__type_traits/apply_cv.h>
-#include <__type_traits/can_extract_key.h>
-#include <__type_traits/common_reference.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/conditional.h>
-#include <__type_traits/conjunction.h>
 #include <__type_traits/decay.h>
-#include <__type_traits/dependent_type.h>
-#include <__type_traits/disjunction.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/extent.h>
-#include <__type_traits/has_unique_object_representation.h>
 #include <__type_traits/has_virtual_destructor.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/invoke.h>
 #include <__type_traits/is_abstract.h>
-#include <__type_traits/is_aggregate.h>
 #include <__type_traits/is_arithmetic.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_assignable.h>
 #include <__type_traits/is_base_of.h>
-#include <__type_traits/is_bounded_array.h>
-#include <__type_traits/is_callable.h>
-#include <__type_traits/is_char_like_type.h>
 #include <__type_traits/is_class.h>
 #include <__type_traits/is_compound.h>
 #include <__type_traits/is_const.h>
-#include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
-#include <__type_traits/is_copy_assignable.h>
-#include <__type_traits/is_copy_constructible.h>
-#include <__type_traits/is_default_constructible.h>
 #include <__type_traits/is_destructible.h>
 #include <__type_traits/is_empty.h>
 #include <__type_traits/is_enum.h>
-#include <__type_traits/is_final.h>
 #include <__type_traits/is_floating_point.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_fundamental.h>
-#include <__type_traits/is_implicitly_default_constructible.h>
 #include <__type_traits/is_integral.h>
 #include <__type_traits/is_literal_type.h>
-#include <__type_traits/is_member_function_pointer.h>
-#include <__type_traits/is_member_object_pointer.h>
 #include <__type_traits/is_member_pointer.h>
-#include <__type_traits/is_move_assignable.h>
-#include <__type_traits/is_move_constructible.h>
 #include <__type_traits/is_nothrow_assignable.h>
 #include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_nothrow_convertible.h>
-#include <__type_traits/is_nothrow_copy_assignable.h>
-#include <__type_traits/is_nothrow_copy_constructible.h>
-#include <__type_traits/is_nothrow_default_constructible.h>
 #include <__type_traits/is_nothrow_destructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
-#include <__type_traits/is_null_pointer.h>
 #include <__type_traits/is_object.h>
 #include <__type_traits/is_pod.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_polymorphic.h>
 #include <__type_traits/is_reference.h>
-#include <__type_traits/is_reference_wrapper.h>
-#include <__type_traits/is_referenceable.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_scalar.h>
-#include <__type_traits/is_scoped_enum.h>
 #include <__type_traits/is_signed.h>
-#include <__type_traits/is_specialization.h>
 #include <__type_traits/is_standard_layout.h>
-#include <__type_traits/is_swappable.h>
 #include <__type_traits/is_trivial.h>
 #include <__type_traits/is_trivially_assignable.h>
 #include <__type_traits/is_trivially_constructible.h>
-#include <__type_traits/is_trivially_copy_assignable.h>
-#include <__type_traits/is_trivially_copy_constructible.h>
 #include <__type_traits/is_trivially_copyable.h>
-#include <__type_traits/is_trivially_default_constructible.h>
 #include <__type_traits/is_trivially_destructible.h>
-#include <__type_traits/is_trivially_move_assignable.h>
-#include <__type_traits/is_trivially_move_constructible.h>
-#include <__type_traits/is_unbounded_array.h>
 #include <__type_traits/is_union.h>
 #include <__type_traits/is_unsigned.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/is_volatile.h>
-#include <__type_traits/make_const_lvalue_ref.h>
 #include <__type_traits/make_signed.h>
 #include <__type_traits/make_unsigned.h>
-#include <__type_traits/maybe_const.h>
-#include <__type_traits/negation.h>
 #include <__type_traits/rank.h>
 #include <__type_traits/remove_all_extents.h>
 #include <__type_traits/remove_const.h>
-#include <__type_traits/remove_const_ref.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_extent.h>
 #include <__type_traits/remove_pointer.h>
 #include <__type_traits/remove_reference.h>
 #include <__type_traits/remove_volatile.h>
 #include <__type_traits/result_of.h>
-#include <__type_traits/type_identity.h>
 #include <__type_traits/underlying_type.h>
-#include <__type_traits/unwrap_ref.h>
-#include <__type_traits/void_t.h>
-#include <__utility/declval.h>
-#include <cstddef>
-#include <cstdint>
+
+#if _LIBCPP_STD_VER >= 14
+#  include <__type_traits/is_final.h>
+#  include <__type_traits/is_null_pointer.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 17
+#  include <__type_traits/conjunction.h>
+#  include <__type_traits/disjunction.h>
+#  include <__type_traits/has_unique_object_representation.h>
+#  include <__type_traits/invoke.h>
+#  include <__type_traits/is_aggregate.h>
+#  include <__type_traits/is_swappable.h>
+#  include <__type_traits/negation.h>
+#  include <__type_traits/void_t.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__type_traits/common_reference.h>
+#  include <__type_traits/is_bounded_array.h>
+#  include <__type_traits/is_constant_evaluated.h>
+#  include <__type_traits/is_nothrow_convertible.h>
+#  include <__type_traits/is_unbounded_array.h>
+#  include <__type_traits/type_identity.h>
+#  include <__type_traits/unwrap_ref.h>
+#endif
+
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
diff --git a/third_party/libcxx/typeindex b/third_party/libcxx/typeindex
index 251aa4306..6398aa40d 100644
--- a/third_party/libcxx/typeindex
+++ b/third_party/libcxx/typeindex
@@ -45,7 +45,6 @@ struct hash<type_index>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <__functional/unary_function.h>
 #include <typeinfo>
@@ -60,59 +59,40 @@ struct hash<type_index>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-class _LIBCPP_TEMPLATE_VIS type_index
-{
-    const type_info* __t_;
+class _LIBCPP_TEMPLATE_VIS type_index {
+  const type_info* __t_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    type_index(const type_info& __y) _NOEXCEPT : __t_(&__y) {}
+  _LIBCPP_HIDE_FROM_ABI type_index(const type_info& __y) _NOEXCEPT : __t_(&__y) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const type_index& __y) const _NOEXCEPT
-        {return *__t_ == *__y.__t_;}
-    _LIBCPP_INLINE_VISIBILITY
+  _LIBCPP_HIDE_FROM_ABI bool operator==(const type_index& __y) const _NOEXCEPT { return *__t_ == *__y.__t_; }
 #if _LIBCPP_STD_VER <= 17
-    bool operator!=(const type_index& __y) const _NOEXCEPT
-        {return *__t_ != *__y.__t_;}
+  _LIBCPP_HIDE_FROM_ABI bool operator!=(const type_index& __y) const _NOEXCEPT { return *__t_ != *__y.__t_; }
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator< (const type_index& __y) const _NOEXCEPT
-        {return  __t_->before(*__y.__t_);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator<=(const type_index& __y) const _NOEXCEPT
-        {return !__y.__t_->before(*__t_);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator> (const type_index& __y) const _NOEXCEPT
-        {return  __y.__t_->before(*__t_);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator>=(const type_index& __y) const _NOEXCEPT
-        {return !__t_->before(*__y.__t_);}
+  _LIBCPP_HIDE_FROM_ABI bool operator<(const type_index& __y) const _NOEXCEPT { return __t_->before(*__y.__t_); }
+  _LIBCPP_HIDE_FROM_ABI bool operator<=(const type_index& __y) const _NOEXCEPT { return !__y.__t_->before(*__t_); }
+  _LIBCPP_HIDE_FROM_ABI bool operator>(const type_index& __y) const _NOEXCEPT { return __y.__t_->before(*__t_); }
+  _LIBCPP_HIDE_FROM_ABI bool operator>=(const type_index& __y) const _NOEXCEPT { return !__t_->before(*__y.__t_); }
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_HIDE_FROM_ABI
-    strong_ordering operator<=>(const type_index& __y) const noexcept {
-      if (*__t_ == *__y.__t_)
-        return strong_ordering::equal;
-      if (__t_->before(*__y.__t_))
-        return strong_ordering::less;
-      return strong_ordering::greater;
-    }
+  _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(const type_index& __y) const noexcept {
+    if (*__t_ == *__y.__t_)
+      return strong_ordering::equal;
+    if (__t_->before(*__y.__t_))
+      return strong_ordering::less;
+    return strong_ordering::greater;
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t hash_code() const _NOEXCEPT {return __t_->hash_code();}
-    _LIBCPP_INLINE_VISIBILITY
-    const char* name() const _NOEXCEPT {return __t_->name();}
+  _LIBCPP_HIDE_FROM_ABI size_t hash_code() const _NOEXCEPT { return __t_->hash_code(); }
+  _LIBCPP_HIDE_FROM_ABI const char* name() const _NOEXCEPT { return __t_->name(); }
 };
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash;
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS hash;
 
 template <>
-struct _LIBCPP_TEMPLATE_VIS hash<type_index>
-    : public __unary_function<type_index, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(type_index __index) const _NOEXCEPT
-        {return __index.hash_code();}
+struct _LIBCPP_TEMPLATE_VIS hash<type_index> : public __unary_function<type_index, size_t> {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(type_index __index) const _NOEXCEPT { return __index.hash_code(); }
 };
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/typeinfo b/third_party/libcxx/typeinfo
index 3392cb45c..d1c0de3c1 100644
--- a/third_party/libcxx/typeinfo
+++ b/third_party/libcxx/typeinfo
@@ -7,8 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef __LIBCPP_TYPEINFO
-#define __LIBCPP_TYPEINFO
+#ifndef _LIBCPP_TYPEINFO
+#define _LIBCPP_TYPEINFO
 
 /*
 
@@ -56,8 +56,6 @@ public:
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__availability>
 #include <__config>
 #include <__exception/exception.h>
 #include <__type_traits/is_constant_evaluated.h>
@@ -70,58 +68,49 @@ public:
 #endif
 
 #if defined(_LIBCPP_ABI_VCRUNTIME)
-#include <vcruntime_typeinfo.h>
+#  include <vcruntime_typeinfo.h>
 #else
 
-namespace std  // purposefully not using versioning namespace
+namespace std // purposefully not using versioning namespace
 {
 
+#  if defined(_LIBCPP_ABI_MICROSOFT)
 
-#if defined(_LIBCPP_ABI_MICROSOFT)
+class _LIBCPP_EXPORTED_FROM_ABI type_info {
+  type_info& operator=(const type_info&);
+  type_info(const type_info&);
 
-class _LIBCPP_EXCEPTION_ABI type_info
-{
-    type_info& operator=(const type_info&);
-    type_info(const type_info&);
+  mutable struct {
+    const char* __undecorated_name;
+    const char __decorated_name[1];
+  } __data;
 
-    mutable struct {
-      const char *__undecorated_name;
-      const char __decorated_name[1];
-    } __data;
-
-    int __compare(const type_info &__rhs) const _NOEXCEPT;
+  int __compare(const type_info& __rhs) const _NOEXCEPT;
 
 public:
-    _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
-    virtual ~type_info();
+  virtual ~type_info();
 
-    const char *name() const _NOEXCEPT;
+  const char* name() const _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool before(const type_info& __arg) const _NOEXCEPT {
-      return __compare(__arg) < 0;
+  _LIBCPP_HIDE_FROM_ABI bool before(const type_info& __arg) const _NOEXCEPT { return __compare(__arg) < 0; }
+
+  size_t hash_code() const _NOEXCEPT;
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator==(const type_info& __arg) const _NOEXCEPT {
+    // When evaluated in a constant expression, both type infos simply can't come
+    // from different translation units, so it is sufficient to compare their addresses.
+    if (__libcpp_is_constant_evaluated()) {
+      return this == &__arg;
     }
+    return __compare(__arg) == 0;
+  }
 
-    size_t hash_code() const _NOEXCEPT;
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bool operator==(const type_info& __arg) const _NOEXCEPT {
-      // When evaluated in a constant expression, both type infos simply can't come
-      // from different translation units, so it is sufficient to compare their addresses.
-      if (__libcpp_is_constant_evaluated()) {
-        return this == &__arg;
-      }
-      return __compare(__arg) == 0;
-    }
-
-#if _LIBCPP_STD_VER <= 17
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const type_info& __arg) const _NOEXCEPT
-    { return !operator==(__arg); }
-#endif
+#    if _LIBCPP_STD_VER <= 17
+  _LIBCPP_HIDE_FROM_ABI bool operator!=(const type_info& __arg) const _NOEXCEPT { return !operator==(__arg); }
+#    endif
 };
 
-#else // !defined(_LIBCPP_ABI_MICROSOFT)
+#  else // !defined(_LIBCPP_ABI_MICROSOFT)
 
 // ========================================================================== //
 //                           Implementations
@@ -176,64 +165,58 @@ public:
 
 // This value can be overriden in the __config_site. When it's not overriden,
 // we pick a default implementation based on the platform here.
-#ifndef _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION
+#    ifndef _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION
 
-  // Windows and AIX binaries can't merge typeinfos, so use the NonUnique implementation.
-# if defined(_LIBCPP_OBJECT_FORMAT_COFF) || defined(_LIBCPP_OBJECT_FORMAT_XCOFF)
-#   define _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION 2
+// Windows and AIX binaries can't merge typeinfos, so use the NonUnique implementation.
+#      if defined(_LIBCPP_OBJECT_FORMAT_COFF) || defined(_LIBCPP_OBJECT_FORMAT_XCOFF)
+#        define _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION 2
 
-  // On arm64 on Apple platforms, use the special NonUniqueARMRTTIBit implementation.
-# elif defined(__APPLE__) && defined(__LP64__) && !defined(__x86_64__)
-#   define _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION 3
+// On arm64 on Apple platforms, use the special NonUniqueARMRTTIBit implementation.
+#      elif defined(__APPLE__) && defined(__LP64__) && !defined(__x86_64__)
+#        define _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION 3
 
-  // On all other platforms, assume the Itanium C++ ABI and use the Unique implementation.
-# else
-#   define _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION 1
-# endif
-#endif
+// On all other platforms, assume the Itanium C++ ABI and use the Unique implementation.
+#      else
+#        define _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION 1
+#      endif
+#    endif
 
 struct __type_info_implementations {
   struct __string_impl_base {
     typedef const char* __type_name_t;
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    _LIBCPP_CONSTEXPR static const char* __type_name_to_string(__type_name_t __v) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR static const char*
+    __type_name_to_string(__type_name_t __v) _NOEXCEPT {
       return __v;
     }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    _LIBCPP_CONSTEXPR static __type_name_t __string_to_type_name(const char* __v) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR static __type_name_t
+    __string_to_type_name(const char* __v) _NOEXCEPT {
       return __v;
     }
   };
 
   struct __unique_impl : __string_impl_base {
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static size_t __hash(__type_name_t __v) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static size_t __hash(__type_name_t __v) _NOEXCEPT {
       return reinterpret_cast<size_t>(__v);
     }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       return __lhs == __rhs;
     }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       return __lhs < __rhs;
     }
   };
 
   struct __non_unique_impl : __string_impl_base {
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static size_t __hash(__type_name_t __ptr) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static size_t __hash(__type_name_t __ptr) _NOEXCEPT {
       size_t __hash = 5381;
       while (unsigned char __c = static_cast<unsigned char>(*__ptr++))
         __hash = (__hash * 33) ^ __c;
       return __hash;
     }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       return __lhs == __rhs || __builtin_strcmp(__lhs, __rhs) == 0;
     }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       return __builtin_strcmp(__lhs, __rhs) < 0;
     }
   };
@@ -241,24 +224,19 @@ struct __type_info_implementations {
   struct __non_unique_arm_rtti_bit_impl {
     typedef uintptr_t __type_name_t;
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static const char* __type_name_to_string(__type_name_t __v) _NOEXCEPT {
-      return reinterpret_cast<const char*>(__v &
-          ~__non_unique_rtti_bit::value);
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static const char* __type_name_to_string(__type_name_t __v) _NOEXCEPT {
+      return reinterpret_cast<const char*>(__v & ~__non_unique_rtti_bit::value);
     }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static __type_name_t __string_to_type_name(const char* __v) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static __type_name_t __string_to_type_name(const char* __v) _NOEXCEPT {
       return reinterpret_cast<__type_name_t>(__v);
     }
 
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static size_t __hash(__type_name_t __v) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static size_t __hash(__type_name_t __v) _NOEXCEPT {
       if (__is_type_name_unique(__v))
         return __v;
       return __non_unique_impl::__hash(__type_name_to_string(__v));
     }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       if (__lhs == __rhs)
         return true;
       if (__is_type_name_unique(__lhs) || __is_type_name_unique(__rhs))
@@ -267,108 +245,99 @@ struct __type_info_implementations {
         return false;
       return __builtin_strcmp(__type_name_to_string(__lhs), __type_name_to_string(__rhs)) == 0;
     }
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_ALWAYS_INLINE
-    static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
       if (__is_type_name_unique(__lhs) || __is_type_name_unique(__rhs))
         return __lhs < __rhs;
       return __builtin_strcmp(__type_name_to_string(__lhs), __type_name_to_string(__rhs)) < 0;
     }
 
-   private:
+  private:
     // The unique bit is the top bit. It is expected that __type_name_t is 64 bits when
     // this implementation is actually used.
-    typedef integral_constant<__type_name_t,
-      (1ULL << ((__CHAR_BIT__ * sizeof(__type_name_t)) - 1))> __non_unique_rtti_bit;
+    typedef integral_constant<__type_name_t, (1ULL << ((__CHAR_BIT__ * sizeof(__type_name_t)) - 1))>
+        __non_unique_rtti_bit;
 
-    _LIBCPP_INLINE_VISIBILITY
-    static bool __is_type_name_unique(__type_name_t __lhs) _NOEXCEPT {
+    _LIBCPP_HIDE_FROM_ABI static bool __is_type_name_unique(__type_name_t __lhs) _NOEXCEPT {
       return !(__lhs & __non_unique_rtti_bit::value);
     }
   };
 
   typedef
-#if _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 1
-    __unique_impl
-#elif _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 2
-    __non_unique_impl
-#elif _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 3
-    __non_unique_arm_rtti_bit_impl
-#else
-#   error invalid configuration for _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION
-#endif
-     __impl;
+#    if _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 1
+      __unique_impl
+#    elif _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 2
+      __non_unique_impl
+#    elif _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 3
+      __non_unique_arm_rtti_bit_impl
+#    else
+#      error invalid configuration for _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION
+#    endif
+          __impl;
 };
 
-class _LIBCPP_EXCEPTION_ABI type_info
-{
+#    if defined(__arm64__) && __has_cpp_attribute(clang::ptrauth_vtable_pointer)
+#      if __has_feature(ptrauth_type_info_discriminated_vtable_pointer)
+#        define _LIBCPP_TYPE_INFO_VTABLE_POINTER_AUTH                                                                  \
+          [[clang::ptrauth_vtable_pointer(process_independent, address_discrimination, type_discrimination)]]
+#      else
+#        define _LIBCPP_TYPE_INFO_VTABLE_POINTER_AUTH                                                                  \
+          [[clang::ptrauth_vtable_pointer(process_independent, no_address_discrimination, no_extra_discrimination)]]
+#      endif
+#    else
+#      define _LIBCPP_TYPE_INFO_VTABLE_POINTER_AUTH
+#    endif
+
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_TYPE_INFO_VTABLE_POINTER_AUTH type_info {
   type_info& operator=(const type_info&);
   type_info(const type_info&);
 
- protected:
-    typedef __type_info_implementations::__impl __impl;
+protected:
+  typedef __type_info_implementations::__impl __impl;
 
-    __impl::__type_name_t __type_name;
+  __impl::__type_name_t __type_name;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit type_info(const char* __n)
-      : __type_name(__impl::__string_to_type_name(__n)) {}
+  _LIBCPP_HIDE_FROM_ABI explicit type_info(const char* __n) : __type_name(__impl::__string_to_type_name(__n)) {}
 
 public:
-    _LIBCPP_AVAILABILITY_TYPEINFO_VTABLE
-    virtual ~type_info();
+  virtual ~type_info();
 
-    _LIBCPP_INLINE_VISIBILITY
-    const char* name() const _NOEXCEPT
-    {
-      return __impl::__type_name_to_string(__type_name);
+  _LIBCPP_HIDE_FROM_ABI const char* name() const _NOEXCEPT { return __impl::__type_name_to_string(__type_name); }
+
+  _LIBCPP_HIDE_FROM_ABI bool before(const type_info& __arg) const _NOEXCEPT {
+    return __impl::__lt(__type_name, __arg.__type_name);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI size_t hash_code() const _NOEXCEPT { return __impl::__hash(__type_name); }
+
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator==(const type_info& __arg) const _NOEXCEPT {
+    // When evaluated in a constant expression, both type infos simply can't come
+    // from different translation units, so it is sufficient to compare their addresses.
+    if (__libcpp_is_constant_evaluated()) {
+      return this == &__arg;
     }
+    return __impl::__eq(__type_name, __arg.__type_name);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    bool before(const type_info& __arg) const _NOEXCEPT
-    {
-      return __impl::__lt(__type_name, __arg.__type_name);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    size_t hash_code() const _NOEXCEPT
-    {
-      return __impl::__hash(__type_name);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX23
-    bool operator==(const type_info& __arg) const _NOEXCEPT
-    {
-      // When evaluated in a constant expression, both type infos simply can't come
-      // from different translation units, so it is sufficient to compare their addresses.
-      if (__libcpp_is_constant_evaluated()) {
-        return this == &__arg;
-      }
-      return __impl::__eq(__type_name, __arg.__type_name);
-    }
-
-#if _LIBCPP_STD_VER <= 17
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const type_info& __arg) const _NOEXCEPT
-    { return !operator==(__arg); }
-#endif
+#    if _LIBCPP_STD_VER <= 17
+  _LIBCPP_HIDE_FROM_ABI bool operator!=(const type_info& __arg) const _NOEXCEPT { return !operator==(__arg); }
+#    endif
 };
-#endif // defined(_LIBCPP_ABI_MICROSOFT)
+#  endif // defined(_LIBCPP_ABI_MICROSOFT)
 
-class _LIBCPP_EXCEPTION_ABI bad_cast
-    : public exception
-{
- public:
+class _LIBCPP_EXPORTED_FROM_ABI bad_cast : public exception {
+public:
   bad_cast() _NOEXCEPT;
-  _LIBCPP_HIDE_FROM_ABI bad_cast(const bad_cast&) _NOEXCEPT = default;
+  _LIBCPP_HIDE_FROM_ABI bad_cast(const bad_cast&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_cast& operator=(const bad_cast&) _NOEXCEPT = default;
   ~bad_cast() _NOEXCEPT override;
   const char* what() const _NOEXCEPT override;
 };
 
-class _LIBCPP_EXCEPTION_ABI bad_typeid
-    : public exception
-{
- public:
+class _LIBCPP_EXPORTED_FROM_ABI bad_typeid : public exception {
+public:
   bad_typeid() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI bad_typeid(const bad_typeid&) _NOEXCEPT            = default;
+  _LIBCPP_HIDE_FROM_ABI bad_typeid& operator=(const bad_typeid&) _NOEXCEPT = default;
   ~bad_typeid() _NOEXCEPT override;
   const char* what() const _NOEXCEPT override;
 };
@@ -402,21 +371,18 @@ private:
 #endif // defined(_LIBCPP_ABI_VCRUNTIME) && _HAS_EXCEPTIONS == 0
 
 _LIBCPP_BEGIN_NAMESPACE_STD
-_LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
-void __throw_bad_cast()
-{
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_bad_cast() {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-    throw bad_cast();
+  throw bad_cast();
 #else
-    _LIBCPP_VERBOSE_ABORT("bad_cast was thrown in -fno-exceptions mode");
+  _LIBCPP_VERBOSE_ABORT("bad_cast was thrown in -fno-exceptions mode");
 #endif
 }
 _LIBCPP_END_NAMESPACE_STD
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <cstdlib>
-#  include <exception>
 #  include <type_traits>
 #endif
 
-#endif // __LIBCPP_TYPEINFO
+#endif // _LIBCPP_TYPEINFO
diff --git a/third_party/libcxx/typeinfo.cpp b/third_party/libcxx/typeinfo.cpp
new file mode 100644
index 000000000..e5f59da31
--- /dev/null
+++ b/third_party/libcxx/typeinfo.cpp
@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <typeinfo>
+
+#if defined(_LIBCPP_ABI_MICROSOFT) && !defined(_LIBCPP_ABI_VCRUNTIME)
+
+#  include <string.h>
+
+int std::type_info::__compare(const type_info& __rhs) const noexcept {
+  if (&__data == &__rhs.__data)
+    return 0;
+  return strcmp(&__data.__decorated_name[1], &__rhs.__data.__decorated_name[1]);
+}
+
+const char* std::type_info::name() const noexcept {
+  // TODO(compnerd) cache demangled &__data.__decorated_name[1]
+  return &__data.__decorated_name[1];
+}
+
+size_t std::type_info::hash_code() const noexcept {
+#  if defined(_WIN64)
+  constexpr size_t fnv_offset_basis = 14695981039346656037ull;
+  constexpr size_t fnv_prime        = 10995116282110ull;
+#  else
+  constexpr size_t fnv_offset_basis = 2166136261ull;
+  constexpr size_t fnv_prime        = 16777619ull;
+#  endif
+
+  size_t value = fnv_offset_basis;
+  for (const char* c = &__data.__decorated_name[1]; *c; ++c) {
+    value ^= static_cast<size_t>(static_cast<unsigned char>(*c));
+    value *= fnv_prime;
+  }
+
+#  if defined(_WIN64)
+  value ^= value >> 32;
+#  endif
+
+  return value;
+}
+#endif // _LIBCPP_ABI_MICROSOFT
+
+// FIXME: Remove the _LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY configuration.
+#if (!defined(LIBCXX_BUILDING_LIBCXXABI) && !defined(LIBCXXRT) && !defined(__GLIBCXX__) &&                             \
+     !defined(_LIBCPP_ABI_VCRUNTIME)) ||                                                                               \
+    defined(_LIBCPP_BUILDING_HAS_NO_ABI_LIBRARY)
+std::type_info::~type_info() {}
+#endif
diff --git a/third_party/libcxx/uchar.h b/third_party/libcxx/uchar.h
index 546113f7e..07b786114 100644
--- a/third_party/libcxx/uchar.h
+++ b/third_party/libcxx/uchar.h
@@ -44,12 +44,12 @@ size_t c32rtomb(char* s, char32_t c32, mbstate_t* ps);
 // error on those platforms. When the platform doesn't provide <uchar.h>, at
 // least include <stddef.h> so we get the declaration for size_t, and try to
 // get the declaration of mbstate_t too.
-#if __has_include_next(<uchar.h>)
-# include_next <uchar.h>
-#else
-# include <__mbstate_t.h>
-# include <stddef.h>
-#endif
+#  if __has_include_next(<uchar.h>)
+#    include_next <uchar.h>
+#  else
+#    include <__mbstate_t.h>
+#    include <stddef.h>
+#  endif
 
 #endif // _LIBCPP_CXX03_LANG
 
diff --git a/third_party/libcxx/unordered_map b/third_party/libcxx/unordered_map
index 414b7fdc2..7c31c4fce 100644
--- a/third_party/libcxx/unordered_map
+++ b/third_party/libcxx/unordered_map
@@ -59,6 +59,11 @@ public:
                       size_type n = 0, const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
+    template<container-compatible-range<value_type> R>
+      unordered_map(from_range_t, R&& rg, size_type n = see below,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type()); // C++23
+
     explicit unordered_map(const allocator_type&);
     unordered_map(const unordered_map&);
     unordered_map(const unordered_map&, const Allocator&);
@@ -82,6 +87,12 @@ public:
       unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
         const allocator_type& a)
       : unordered_map(f, l, n, hf, key_equal(), a) {}  // C++14
+    template<container-compatible-range<value_type> R>
+      unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
+        : unordered_map(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+    template<container-compatible-range<value_type> R>
+      unordered_map(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+        : unordered_map(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
     unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
       : unordered_map(il, n, hasher(), key_equal(), a) {}  // C++14
     unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
@@ -122,6 +133,8 @@ public:
         iterator insert(const_iterator hint, P&& obj);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                                      // C++23
     void insert(initializer_list<value_type>);
 
     node_type extract(const_iterator position);                                       // C++17
@@ -224,6 +237,13 @@ unordered_map(InputIterator, InputIterator, typename see below::size_type = see
   -> unordered_map<iter_key_t<InputIterator>, iter_value_t<InputIterator>, Hash, Pred,
     Allocator>; // C++17
 
+template<ranges::input_range R, class Hash = hash<range-key-type<R>>,
+         class Pred = equal_to<range-key-type<R>>,
+         class Allocator = allocator<range-to-alloc-type<R>>>
+  unordered_map(from_range_t, R&&, typename see below::size_type = see below,
+                Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+    -> unordered_map<range-key-type<R>, range-mapped-type<R>, Hash, Pred, Allocator>; // C++23
+
 template<class Key, class T, class Hash = hash<Key>,
     class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
 unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type = see below,
@@ -245,6 +265,21 @@ unordered_map(InputIterator, InputIterator, typename see below::size_type, Hash,
   -> unordered_map<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Hash,
           equal_to<iter_key_t<InputIterator>>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  unordered_map(from_range_t, R&&, typename see below::size_type, Allocator)
+    -> unordered_map<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
+template<ranges::input_range R, class Allocator>
+  unordered_map(from_range_t, R&&, Allocator)
+    -> unordered_map<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
+template<ranges::input_range R, class Hash, class Allocator>
+  unordered_map(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+    -> unordered_map<range-key-type<R>, range-mapped-type<R>, Hash,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
 template<class Key, class T, typename Allocator>
 unordered_map(initializer_list<pair<const Key, T>>, typename see below::size_type, Allocator)
   -> unordered_map<Key, T, hash<Key>, equal_to<Key>, Allocator>; // C++17
@@ -270,7 +305,7 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
 template <class Key, class T, class Hash, class Pred, class Alloc>
     bool
     operator!=(const unordered_map<Key, T, Hash, Pred, Alloc>& x,
-               const unordered_map<Key, T, Hash, Pred, Alloc>& y);
+               const unordered_map<Key, T, Hash, Pred, Alloc>& y); // Removed in C++20
 
 template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
           class Alloc = allocator<pair<const Key, T>>>
@@ -311,6 +346,10 @@ public:
                       size_type n = 0, const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
+    template<container-compatible-range<value_type> R>
+      unordered_multimap(from_range_t, R&& rg, size_type n = see below,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type()); // C++23
     explicit unordered_multimap(const allocator_type&);
     unordered_multimap(const unordered_multimap&);
     unordered_multimap(const unordered_multimap&, const Allocator&);
@@ -334,6 +373,12 @@ public:
       unordered_multimap(InputIterator f, InputIterator l, size_type n, const hasher& hf,
         const allocator_type& a)
       : unordered_multimap(f, l, n, hf, key_equal(), a) {}  // C++14
+    template<container-compatible-range<value_type> R>
+      unordered_multimap(from_range_t, R&& rg, size_type n, const allocator_type& a)
+        : unordered_multimap(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+    template<container-compatible-range<value_type> R>
+      unordered_multimap(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+        : unordered_multimap(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
     unordered_multimap(initializer_list<value_type> il, size_type n, const allocator_type& a)
       : unordered_multimap(il, n, hasher(), key_equal(), a) {}  // C++14
     unordered_multimap(initializer_list<value_type> il, size_type n, const hasher& hf,
@@ -374,6 +419,8 @@ public:
         iterator insert(const_iterator hint, P&& obj);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                               // C++23
     void insert(initializer_list<value_type>);
 
     node_type extract(const_iterator position);                // C++17
@@ -453,6 +500,13 @@ unordered_multimap(InputIterator, InputIterator, typename see below::size_type =
   -> unordered_multimap<iter_key_t<InputIterator>, iter_value_t<InputIterator>, Hash, Pred,
     Allocator>; // C++17
 
+template<ranges::input_range R, class Hash = hash<range-key-type<R>>,
+         class Pred = equal_to<range-key-type<R>>,
+         class Allocator = allocator<range-to-alloc-type<R>>>
+  unordered_multimap(from_range_t, R&&, typename see below::size_type = see below,
+                Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+    -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, Hash, Pred, Allocator>; // C++23
+
 template<class Key, class T, class Hash = hash<Key>,
     class Pred = equal_to<Key>, class Allocator = allocator<pair<const Key, T>>>
 unordered_multimap(initializer_list<pair<const Key, T>>, typename see below::size_type = see below,
@@ -474,6 +528,21 @@ unordered_multimap(InputIterator, InputIterator, typename see below::size_type,
   -> unordered_multimap<iter_key_t<InputIterator>, iter_val_t<InputIterator>, Hash,
           equal_to<iter_key_t<InputIterator>>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  unordered_multimap(from_range_t, R&&, typename see below::size_type, Allocator)
+    -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
+template<ranges::input_range R, class Allocator>
+  unordered_multimap(from_range_t, R&&, Allocator)
+    -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, hash<range-key-type<R>>,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
+template<ranges::input_range R, class Hash, class Allocator>
+  unordered_multimap(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+    -> unordered_multimap<range-key-type<R>, range-mapped-type<R>, Hash,
+                      equal_to<range-key-type<R>>, Allocator>;   // C++23
+
 template<class Key, class T, typename Allocator>
 unordered_multimap(initializer_list<pair<const Key, T>>, typename see below::size_type, Allocator)
   -> unordered_multimap<Key, T, hash<Key>, equal_to<Key>, Allocator>; // C++17
@@ -508,26 +577,29 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
 template <class Key, class T, class Hash, class Pred, class Alloc>
     bool
     operator!=(const unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
-               const unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
+               const unordered_multimap<Key, T, Hash, Pred, Alloc>& y); // Removed in C++20
 
 }  // std
 
 */
 
 #include <__algorithm/is_permutation.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__hash_table>
 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/ranges_iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/forward.h>
@@ -552,2098 +624,1911 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Key, class _Cp, class _Hash, class _Pred,
+template <class _Key,
+          class _Cp,
+          class _Hash,
+          class _Pred,
           bool = is_empty<_Hash>::value && !__libcpp_is_final<_Hash>::value>
-class __unordered_map_hasher
-    : private _Hash
-{
+class __unordered_map_hasher : private _Hash {
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __unordered_map_hasher()
-        _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value)
-        : _Hash() {}
-    _LIBCPP_INLINE_VISIBILITY
-    __unordered_map_hasher(const _Hash& __h)
-        _NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value)
-        : _Hash(__h) {}
-    _LIBCPP_INLINE_VISIBILITY
-    const _Hash& hash_function() const _NOEXCEPT {return *this;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const _Cp& __x) const
-        {return static_cast<const _Hash&>(*this)(__x.__get_value().first);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const _Key& __x) const
-        {return static_cast<const _Hash&>(*this)(__x);}
+  _LIBCPP_HIDE_FROM_ABI __unordered_map_hasher() _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value) : _Hash() {}
+  _LIBCPP_HIDE_FROM_ABI __unordered_map_hasher(const _Hash& __h) _NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value)
+      : _Hash(__h) {}
+  _LIBCPP_HIDE_FROM_ABI const _Hash& hash_function() const _NOEXCEPT { return *this; }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _Cp& __x) const {
+    return static_cast<const _Hash&>(*this)(__x.__get_value().first);
+  }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _Key& __x) const { return static_cast<const _Hash&>(*this)(__x); }
 #if _LIBCPP_STD_VER >= 20
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const _K2& __x) const
-        {return static_cast<const _Hash&>(*this)(__x);}
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _K2& __x) const {
+    return static_cast<const _Hash&>(*this)(__x);
+  }
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(__unordered_map_hasher& __y)
-        _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value)
-    {
-        using _VSTD::swap;
-        swap(static_cast<_Hash&>(*this), static_cast<_Hash&>(__y));
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(__unordered_map_hasher& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Hash>) {
+    using std::swap;
+    swap(static_cast<_Hash&>(*this), static_cast<_Hash&>(__y));
+  }
 };
 
 template <class _Key, class _Cp, class _Hash, class _Pred>
-class __unordered_map_hasher<_Key, _Cp, _Hash, _Pred, false>
-{
-    _Hash __hash_;
+class __unordered_map_hasher<_Key, _Cp, _Hash, _Pred, false> {
+  _Hash __hash_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __unordered_map_hasher()
-        _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value)
-        : __hash_() {}
-    _LIBCPP_INLINE_VISIBILITY
-    __unordered_map_hasher(const _Hash& __h)
-        _NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value)
-        : __hash_(__h) {}
-    _LIBCPP_INLINE_VISIBILITY
-    const _Hash& hash_function() const _NOEXCEPT {return __hash_;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const _Cp& __x) const
-        {return __hash_(__x.__get_value().first);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const _Key& __x) const
-        {return __hash_(__x);}
+  _LIBCPP_HIDE_FROM_ABI __unordered_map_hasher() _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value)
+      : __hash_() {}
+  _LIBCPP_HIDE_FROM_ABI __unordered_map_hasher(const _Hash& __h) _NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value)
+      : __hash_(__h) {}
+  _LIBCPP_HIDE_FROM_ABI const _Hash& hash_function() const _NOEXCEPT { return __hash_; }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _Cp& __x) const { return __hash_(__x.__get_value().first); }
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _Key& __x) const { return __hash_(__x); }
 #if _LIBCPP_STD_VER >= 20
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const _K2& __x) const
-        {return __hash_(__x);}
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _K2& __x) const {
+    return __hash_(__x);
+  }
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(__unordered_map_hasher& __y)
-        _NOEXCEPT_(__is_nothrow_swappable<_Hash>::value)
-    {
-        using _VSTD::swap;
-        swap(__hash_, __y.__hash_);
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(__unordered_map_hasher& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Hash>) {
+    using std::swap;
+    swap(__hash_, __y.__hash_);
+  }
 };
 
 template <class _Key, class _Cp, class _Hash, class _Pred, bool __b>
-inline _LIBCPP_INLINE_VISIBILITY
-void
+inline _LIBCPP_HIDE_FROM_ABI void
 swap(__unordered_map_hasher<_Key, _Cp, _Hash, _Pred, __b>& __x,
-     __unordered_map_hasher<_Key, _Cp, _Hash, _Pred, __b>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+     __unordered_map_hasher<_Key, _Cp, _Hash, _Pred, __b>& __y) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
-template <class _Key, class _Cp, class _Pred, class _Hash,
+template <class _Key,
+          class _Cp,
+          class _Pred,
+          class _Hash,
           bool = is_empty<_Pred>::value && !__libcpp_is_final<_Pred>::value>
-class __unordered_map_equal
-    : private _Pred
-{
+class __unordered_map_equal : private _Pred {
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __unordered_map_equal()
-        _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value)
-        : _Pred() {}
-    _LIBCPP_INLINE_VISIBILITY
-    __unordered_map_equal(const _Pred& __p)
-        _NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value)
-        : _Pred(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    const _Pred& key_eq() const _NOEXCEPT {return *this;}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Cp& __x, const _Cp& __y) const
-        {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y.__get_value().first);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Cp& __x, const _Key& __y) const
-        {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Key& __x, const _Cp& __y) const
-        {return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
+  _LIBCPP_HIDE_FROM_ABI __unordered_map_equal() _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value) : _Pred() {}
+  _LIBCPP_HIDE_FROM_ABI __unordered_map_equal(const _Pred& __p) _NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value)
+      : _Pred(__p) {}
+  _LIBCPP_HIDE_FROM_ABI const _Pred& key_eq() const _NOEXCEPT { return *this; }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Cp& __x, const _Cp& __y) const {
+    return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y.__get_value().first);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Cp& __x, const _Key& __y) const {
+    return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _Cp& __y) const {
+    return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);
+  }
 #if _LIBCPP_STD_VER >= 20
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Cp& __x, const _K2& __y) const
-        {return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _K2& __x, const _Cp& __y) const
-        {return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Key& __x, const _K2& __y) const
-        {return static_cast<const _Pred&>(*this)(__x, __y);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _K2& __x, const _Key& __y) const
-        {return static_cast<const _Pred&>(*this)(__x, __y);}
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Cp& __x, const _K2& __y) const {
+    return static_cast<const _Pred&>(*this)(__x.__get_value().first, __y);
+  }
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _K2& __x, const _Cp& __y) const {
+    return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);
+  }
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _K2& __y) const {
+    return static_cast<const _Pred&>(*this)(__x, __y);
+  }
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _K2& __x, const _Key& __y) const {
+    return static_cast<const _Pred&>(*this)(__x, __y);
+  }
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(__unordered_map_equal& __y)
-        _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value)
-    {
-        using _VSTD::swap;
-        swap(static_cast<_Pred&>(*this), static_cast<_Pred&>(__y));
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(__unordered_map_equal& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Pred>) {
+    using std::swap;
+    swap(static_cast<_Pred&>(*this), static_cast<_Pred&>(__y));
+  }
 };
 
 template <class _Key, class _Cp, class _Pred, class _Hash>
-class __unordered_map_equal<_Key, _Cp, _Pred, _Hash, false>
-{
-    _Pred __pred_;
+class __unordered_map_equal<_Key, _Cp, _Pred, _Hash, false> {
+  _Pred __pred_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __unordered_map_equal()
-        _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value)
-        : __pred_() {}
-    _LIBCPP_INLINE_VISIBILITY
-    __unordered_map_equal(const _Pred& __p)
-        _NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value)
-        : __pred_(__p) {}
-    _LIBCPP_INLINE_VISIBILITY
-    const _Pred& key_eq() const _NOEXCEPT {return __pred_;}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Cp& __x, const _Cp& __y) const
-        {return __pred_(__x.__get_value().first, __y.__get_value().first);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Cp& __x, const _Key& __y) const
-        {return __pred_(__x.__get_value().first, __y);}
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Key& __x, const _Cp& __y) const
-        {return __pred_(__x, __y.__get_value().first);}
+  _LIBCPP_HIDE_FROM_ABI __unordered_map_equal() _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value)
+      : __pred_() {}
+  _LIBCPP_HIDE_FROM_ABI __unordered_map_equal(const _Pred& __p) _NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value)
+      : __pred_(__p) {}
+  _LIBCPP_HIDE_FROM_ABI const _Pred& key_eq() const _NOEXCEPT { return __pred_; }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Cp& __x, const _Cp& __y) const {
+    return __pred_(__x.__get_value().first, __y.__get_value().first);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Cp& __x, const _Key& __y) const {
+    return __pred_(__x.__get_value().first, __y);
+  }
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _Cp& __y) const {
+    return __pred_(__x, __y.__get_value().first);
+  }
 #if _LIBCPP_STD_VER >= 20
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Cp& __x, const _K2& __y) const
-        {return __pred_(__x.__get_value().first, __y);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _K2& __x, const _Cp& __y) const
-        {return __pred_(__x, __y.__get_value().first);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _Key& __x, const _K2& __y) const
-        {return __pred_(__x, __y);}
-    template <typename _K2>
-    _LIBCPP_INLINE_VISIBILITY
-    bool operator()(const _K2& __x, const _Key& __y) const
-        {return __pred_(__x, __y);}
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Cp& __x, const _K2& __y) const {
+    return __pred_(__x.__get_value().first, __y);
+  }
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _K2& __x, const _Cp& __y) const {
+    return __pred_(__x, __y.__get_value().first);
+  }
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _K2& __y) const {
+    return __pred_(__x, __y);
+  }
+  template <typename _K2>
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const _K2& __x, const _Key& __y) const {
+    return __pred_(__x, __y);
+  }
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(__unordered_map_equal& __y)
-        _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value)
-    {
-        using _VSTD::swap;
-        swap(__pred_, __y.__pred_);
-    }
+  _LIBCPP_HIDE_FROM_ABI void swap(__unordered_map_equal& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Pred>) {
+    using std::swap;
+    swap(__pred_, __y.__pred_);
+  }
 };
 
 template <class _Key, class _Cp, class _Pred, class _Hash, bool __b>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(__unordered_map_equal<_Key, _Cp, _Pred, _Hash, __b>& __x,
-     __unordered_map_equal<_Key, _Cp, _Pred, _Hash, __b>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(__unordered_map_equal<_Key, _Cp, _Pred, _Hash, __b>& __x, __unordered_map_equal<_Key, _Cp, _Pred, _Hash, __b>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 template <class _Alloc>
-class __hash_map_node_destructor
-{
-    typedef _Alloc                              allocator_type;
-    typedef allocator_traits<allocator_type>    __alloc_traits;
+class __hash_map_node_destructor {
+  typedef _Alloc allocator_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
 
 public:
+  typedef typename __alloc_traits::pointer pointer;
 
-    typedef typename __alloc_traits::pointer       pointer;
 private:
-
-    allocator_type& __na_;
-
-    __hash_map_node_destructor& operator=(const __hash_map_node_destructor&);
+  allocator_type& __na_;
 
 public:
-    bool __first_constructed;
-    bool __second_constructed;
+  bool __first_constructed;
+  bool __second_constructed;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __hash_map_node_destructor(allocator_type& __na) _NOEXCEPT
-        : __na_(__na),
-          __first_constructed(false),
-          __second_constructed(false)
-        {}
+  __hash_map_node_destructor& operator=(const __hash_map_node_destructor&) = delete;
+
+  _LIBCPP_HIDE_FROM_ABI explicit __hash_map_node_destructor(allocator_type& __na) _NOEXCEPT
+      : __na_(__na),
+        __first_constructed(false),
+        __second_constructed(false) {}
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_node_destructor(__hash_node_destructor<allocator_type>&& __x)
-        _NOEXCEPT
-        : __na_(__x.__na_),
-          __first_constructed(__x.__value_constructed),
-          __second_constructed(__x.__value_constructed)
-        {
-            __x.__value_constructed = false;
-        }
+  _LIBCPP_HIDE_FROM_ABI __hash_map_node_destructor(__hash_node_destructor<allocator_type>&& __x) _NOEXCEPT
+      : __na_(__x.__na_),
+        __first_constructed(__x.__value_constructed),
+        __second_constructed(__x.__value_constructed) {
+    __x.__value_constructed = false;
+  }
 #else  // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
-        : __na_(__x.__na_),
-          __first_constructed(__x.__value_constructed),
-          __second_constructed(__x.__value_constructed)
-        {
-            const_cast<bool&>(__x.__value_constructed) = false;
-        }
+  _LIBCPP_HIDE_FROM_ABI __hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
+      : __na_(__x.__na_), __first_constructed(__x.__value_constructed), __second_constructed(__x.__value_constructed) {
+    const_cast<bool&>(__x.__value_constructed) = false;
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
-    {
-        if (__second_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().second));
-        if (__first_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.__get_value().first));
-        if (__p)
-            __alloc_traits::deallocate(__na_, __p, 1);
-    }
+  _LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {
+    if (__second_constructed)
+      __alloc_traits::destroy(__na_, std::addressof(__p->__get_value().__get_value().second));
+    if (__first_constructed)
+      __alloc_traits::destroy(__na_, std::addressof(__p->__get_value().__get_value().first));
+    if (__p)
+      __alloc_traits::deallocate(__na_, __p, 1);
+  }
 };
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Key, class _Tp>
-struct _LIBCPP_STANDALONE_DEBUG __hash_value_type
-{
-    typedef _Key                                     key_type;
-    typedef _Tp                                      mapped_type;
-    typedef pair<const key_type, mapped_type>        value_type;
-    typedef pair<key_type&, mapped_type&>            __nc_ref_pair_type;
-    typedef pair<key_type&&, mapped_type&&>          __nc_rref_pair_type;
+struct _LIBCPP_STANDALONE_DEBUG __hash_value_type {
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef pair<const key_type, mapped_type> value_type;
+  typedef pair<key_type&, mapped_type&> __nc_ref_pair_type;
+  typedef pair<key_type&&, mapped_type&&> __nc_rref_pair_type;
 
 private:
-    value_type __cc_;
+  value_type __cc_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    value_type& __get_value()
-    {
-#if _LIBCPP_STD_VER >= 17
-        return *_VSTD::launder(_VSTD::addressof(__cc_));
-#else
-        return __cc_;
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI value_type& __get_value() {
+#  if _LIBCPP_STD_VER >= 17
+    return *std::launder(std::addressof(__cc_));
+#  else
+    return __cc_;
+#  endif
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type& __get_value() const
-    {
-#if _LIBCPP_STD_VER >= 17
-        return *_VSTD::launder(_VSTD::addressof(__cc_));
-#else
-        return __cc_;
-#endif
-    }
+  _LIBCPP_HIDE_FROM_ABI const value_type& __get_value() const {
+#  if _LIBCPP_STD_VER >= 17
+    return *std::launder(std::addressof(__cc_));
+#  else
+    return __cc_;
+#  endif
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __nc_ref_pair_type __ref()
-    {
-        value_type& __v = __get_value();
-        return __nc_ref_pair_type(const_cast<key_type&>(__v.first), __v.second);
-    }
+  _LIBCPP_HIDE_FROM_ABI __nc_ref_pair_type __ref() {
+    value_type& __v = __get_value();
+    return __nc_ref_pair_type(const_cast<key_type&>(__v.first), __v.second);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __nc_rref_pair_type __move()
-    {
-        value_type& __v = __get_value();
-        return __nc_rref_pair_type(
-            _VSTD::move(const_cast<key_type&>(__v.first)),
-            _VSTD::move(__v.second));
-    }
+  _LIBCPP_HIDE_FROM_ABI __nc_rref_pair_type __move() {
+    value_type& __v = __get_value();
+    return __nc_rref_pair_type(std::move(const_cast<key_type&>(__v.first)), std::move(__v.second));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_value_type& operator=(const __hash_value_type& __v)
-    {
-        __ref() = __v.__get_value();
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_value_type& operator=(const __hash_value_type& __v) {
+    __ref() = __v.__get_value();
+    return *this;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_value_type& operator=(__hash_value_type&& __v)
-    {
-        __ref() = __v.__move();
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_value_type& operator=(__hash_value_type&& __v) {
+    __ref() = __v.__move();
+    return *this;
+  }
 
-    template <class _ValueTp,
-              class = __enable_if_t<__is_same_uncvref<_ValueTp, value_type>::value>
-             >
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_value_type& operator=(_ValueTp&& __v)
-    {
-        __ref() = _VSTD::forward<_ValueTp>(__v);
-        return *this;
-    }
+  template <class _ValueTp, __enable_if_t<__is_same_uncvref<_ValueTp, value_type>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI __hash_value_type& operator=(_ValueTp&& __v) {
+    __ref() = std::forward<_ValueTp>(__v);
+    return *this;
+  }
 
-private:
-    __hash_value_type(const __hash_value_type& __v) = delete;
-    __hash_value_type(__hash_value_type&& __v) = delete;
-    template <class ..._Args>
-    explicit __hash_value_type(_Args&& ...__args) = delete;
+  __hash_value_type(const __hash_value_type& __v) = delete;
+  __hash_value_type(__hash_value_type&& __v)      = delete;
+  template <class... _Args>
+  explicit __hash_value_type(_Args&&... __args) = delete;
 
-    ~__hash_value_type() = delete;
+  ~__hash_value_type() = delete;
 };
 
 #else
 
 template <class _Key, class _Tp>
-struct __hash_value_type
-{
-    typedef _Key                                     key_type;
-    typedef _Tp                                      mapped_type;
-    typedef pair<const key_type, mapped_type>        value_type;
+struct __hash_value_type {
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef pair<const key_type, mapped_type> value_type;
 
 private:
-    value_type __cc_;
+  value_type __cc_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    value_type& __get_value() { return __cc_; }
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type& __get_value() const { return __cc_; }
+  _LIBCPP_HIDE_FROM_ABI value_type& __get_value() { return __cc_; }
+  _LIBCPP_HIDE_FROM_ABI const value_type& __get_value() const { return __cc_; }
 
-private:
-   ~__hash_value_type();
+  ~__hash_value_type() = delete;
 };
 
 #endif
 
 template <class _HashIterator>
-class _LIBCPP_TEMPLATE_VIS __hash_map_iterator
-{
-    _HashIterator __i_;
+class _LIBCPP_TEMPLATE_VIS __hash_map_iterator {
+  _HashIterator __i_;
 
-    typedef  __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
+  typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
 
 public:
-    typedef forward_iterator_tag                                 iterator_category;
-    typedef typename _NodeTypes::__map_value_type                value_type;
-    typedef typename _NodeTypes::difference_type                 difference_type;
-    typedef value_type&                                          reference;
-    typedef typename _NodeTypes::__map_value_type_pointer       pointer;
+  typedef forward_iterator_tag iterator_category;
+  typedef typename _NodeTypes::__map_value_type value_type;
+  typedef typename _NodeTypes::difference_type difference_type;
+  typedef value_type& reference;
+  typedef typename _NodeTypes::__map_value_type_pointer pointer;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_iterator() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI __hash_map_iterator() _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {}
+  _LIBCPP_HIDE_FROM_ABI __hash_map_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return __i_->__get_value();}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __i_->__get_value(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__i_->__get_value()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_iterator& operator++() {++__i_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_iterator operator++(int)
-    {
-        __hash_map_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_map_iterator& operator++() {
+    ++__i_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __hash_map_iterator operator++(int) {
+    __hash_map_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
-        {return __x.__i_ == __y.__i_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y)
-        {return __x.__i_ != __y.__i_;}
+  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const __hash_map_iterator& __x, const __hash_map_iterator& __y) {
+    return __x.__i_ == __y.__i_;
+  }
+#if _LIBCPP_STD_VER <= 17
+  friend _LIBCPP_HIDE_FROM_ABI bool operator!=(const __hash_map_iterator& __x, const __hash_map_iterator& __y) {
+    return __x.__i_ != __y.__i_;
+  }
+#endif
 
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator;
 };
 
 template <class _HashIterator>
-class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator
-{
-    _HashIterator __i_;
+class _LIBCPP_TEMPLATE_VIS __hash_map_const_iterator {
+  _HashIterator __i_;
 
-    typedef  __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
+  typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes;
 
 public:
-    typedef forward_iterator_tag                                 iterator_category;
-    typedef typename _NodeTypes::__map_value_type                value_type;
-    typedef typename _NodeTypes::difference_type                 difference_type;
-    typedef const value_type&                                    reference;
-    typedef typename _NodeTypes::__const_map_value_type_pointer  pointer;
+  typedef forward_iterator_tag iterator_category;
+  typedef typename _NodeTypes::__map_value_type value_type;
+  typedef typename _NodeTypes::difference_type difference_type;
+  typedef const value_type& reference;
+  typedef typename _NodeTypes::__const_map_value_type_pointer pointer;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_const_iterator() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI __hash_map_const_iterator() _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_const_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {}
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_const_iterator(
-            __hash_map_iterator<typename _HashIterator::__non_const_iterator> __i)
-                 _NOEXCEPT
-                : __i_(__i.__i_) {}
+  _LIBCPP_HIDE_FROM_ABI __hash_map_const_iterator(_HashIterator __i) _NOEXCEPT : __i_(__i) {}
+  _LIBCPP_HIDE_FROM_ABI
+  __hash_map_const_iterator(__hash_map_iterator<typename _HashIterator::__non_const_iterator> __i) _NOEXCEPT
+      : __i_(__i.__i_) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    reference operator*() const {return __i_->__get_value();}
-    _LIBCPP_INLINE_VISIBILITY
-    pointer operator->() const {return pointer_traits<pointer>::pointer_to(__i_->__get_value());}
+  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __i_->__get_value(); }
+  _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__i_->__get_value()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_const_iterator& operator++() {++__i_; return *this;}
-    _LIBCPP_INLINE_VISIBILITY
-    __hash_map_const_iterator operator++(int)
-    {
-        __hash_map_const_iterator __t(*this);
-        ++(*this);
-        return __t;
-    }
+  _LIBCPP_HIDE_FROM_ABI __hash_map_const_iterator& operator++() {
+    ++__i_;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI __hash_map_const_iterator operator++(int) {
+    __hash_map_const_iterator __t(*this);
+    ++(*this);
+    return __t;
+  }
 
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
-        {return __x.__i_ == __y.__i_;}
-    friend _LIBCPP_INLINE_VISIBILITY
-        bool operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y)
-        {return __x.__i_ != __y.__i_;}
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator==(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) {
+    return __x.__i_ == __y.__i_;
+  }
+#if _LIBCPP_STD_VER <= 17
+  friend _LIBCPP_HIDE_FROM_ABI bool
+  operator!=(const __hash_map_const_iterator& __x, const __hash_map_const_iterator& __y) {
+    return __x.__i_ != __y.__i_;
+  }
+#endif
 
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class, class, class, class, class> friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+  template <class, class, class, class, class>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_const_iterator;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS __hash_const_local_iterator;
 };
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 class unordered_multimap;
 
-template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
+template <class _Key,
+          class _Tp,
+          class _Hash  = hash<_Key>,
+          class _Pred  = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TEMPLATE_VIS unordered_map
-{
+class _LIBCPP_TEMPLATE_VIS unordered_map {
 public:
-    // types
-    typedef _Key                                           key_type;
-    typedef _Tp                                            mapped_type;
-    typedef __type_identity_t<_Hash>                       hasher;
-    typedef __type_identity_t<_Pred>                       key_equal;
-    typedef __type_identity_t<_Alloc>                      allocator_type;
-    typedef pair<const key_type, mapped_type>              value_type;
-    typedef value_type&                                    reference;
-    typedef const value_type&                              const_reference;
-    static_assert((is_same<value_type, typename allocator_type::value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
+  // types
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef __type_identity_t<_Hash> hasher;
+  typedef __type_identity_t<_Pred> key_equal;
+  typedef __type_identity_t<_Alloc> allocator_type;
+  typedef pair<const key_type, mapped_type> value_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  static_assert(is_same<value_type, typename allocator_type::value_type>::value,
+                "Allocator::value_type must be same type as value_type");
 
 private:
-    typedef __hash_value_type<key_type, mapped_type>                          __value_type;
-    typedef __unordered_map_hasher<key_type, __value_type, hasher, key_equal> __hasher;
-    typedef __unordered_map_equal<key_type, __value_type, key_equal, hasher>  __key_equal;
-    typedef __rebind_alloc<allocator_traits<allocator_type>, __value_type>    __allocator_type;
+  typedef __hash_value_type<key_type, mapped_type> __value_type;
+  typedef __unordered_map_hasher<key_type, __value_type, hasher, key_equal> __hasher;
+  typedef __unordered_map_equal<key_type, __value_type, key_equal, hasher> __key_equal;
+  typedef __rebind_alloc<allocator_traits<allocator_type>, __value_type> __allocator_type;
 
-    typedef __hash_table<__value_type, __hasher,
-                         __key_equal,  __allocator_type>   __table;
+  typedef __hash_table<__value_type, __hasher, __key_equal, __allocator_type> __table;
 
-    __table __table_;
+  __table __table_;
 
-    typedef typename __table::_NodeTypes                   _NodeTypes;
-    typedef typename __table::__node_pointer               __node_pointer;
-    typedef typename __table::__node_const_pointer         __node_const_pointer;
-    typedef typename __table::__node_traits                __node_traits;
-    typedef typename __table::__node_allocator             __node_allocator;
-    typedef typename __table::__node                       __node;
-    typedef __hash_map_node_destructor<__node_allocator>   _Dp;
-    typedef unique_ptr<__node, _Dp>                         __node_holder;
-    typedef allocator_traits<allocator_type>               __alloc_traits;
+  typedef typename __table::_NodeTypes _NodeTypes;
+  typedef typename __table::__node_pointer __node_pointer;
+  typedef typename __table::__node_const_pointer __node_const_pointer;
+  typedef typename __table::__node_traits __node_traits;
+  typedef typename __table::__node_allocator __node_allocator;
+  typedef typename __table::__node __node;
+  typedef __hash_map_node_destructor<__node_allocator> _Dp;
+  typedef unique_ptr<__node, _Dp> __node_holder;
+  typedef allocator_traits<allocator_type> __alloc_traits;
 
-    static_assert(is_same<allocator_type, __rebind_alloc<__alloc_traits, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
+
+  static_assert(is_same<typename __table::__container_value_type, value_type>::value, "");
+  static_assert(is_same<typename __table::__node_value_type, __value_type>::value, "");
 
-    static_assert((is_same<typename __table::__container_value_type, value_type>::value), "");
-    static_assert((is_same<typename __table::__node_value_type, __value_type>::value), "");
 public:
-    typedef typename __alloc_traits::pointer         pointer;
-    typedef typename __alloc_traits::const_pointer   const_pointer;
-    typedef typename __table::size_type              size_type;
-    typedef typename __table::difference_type        difference_type;
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
+  typedef typename __table::size_type size_type;
+  typedef typename __table::difference_type difference_type;
 
-    typedef __hash_map_iterator<typename __table::iterator>       iterator;
-    typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
-    typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
-    typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
+  typedef __hash_map_iterator<typename __table::iterator> iterator;
+  typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
+  typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
+  typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
 
 #if _LIBCPP_STD_VER >= 17
-    typedef __map_node_handle<__node, allocator_type> node_type;
-    typedef __insert_return_type<iterator, node_type> insert_return_type;
+  typedef __map_node_handle<__node, allocator_type> node_type;
+  typedef __insert_return_type<iterator, node_type> insert_return_type;
 #endif
 
-    template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+  template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+  template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
 
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_map()
-        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
-    {
-        _VSTD::__debug_db_insert_c(this);
+  _LIBCPP_HIDE_FROM_ABI unordered_map() _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) {}
+  explicit _LIBCPP_HIDE_FROM_ABI
+  unordered_map(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_map(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_map(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_map(_InputIterator __first,
+                _InputIterator __last,
+                size_type __n,
+                const hasher& __hf     = hasher(),
+                const key_equal& __eql = key_equal());
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_map(
+      _InputIterator __first,
+      _InputIterator __last,
+      size_type __n,
+      const hasher& __hf,
+      const key_equal& __eql,
+      const allocator_type& __a);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI unordered_map(
+      from_range_t,
+      _Range&& __range,
+      size_type __n             = /*implementation-defined*/ 0,
+      const hasher& __hf        = hasher(),
+      const key_equal& __eql    = key_equal(),
+      const allocator_type& __a = allocator_type())
+      : __table_(__hf, __eql, typename __table::allocator_type(__a)) {
+    if (__n > 0) {
+      __table_.__rehash_unique(__n);
     }
-    explicit _LIBCPP_HIDE_FROM_ABI unordered_map(size_type __n, const hasher& __hf = hasher(),
-                           const key_equal& __eql = key_equal());
-    _LIBCPP_HIDE_FROM_ABI unordered_map(size_type __n, const hasher& __hf,
-                  const key_equal& __eql,
-                  const allocator_type& __a);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_map(_InputIterator __first, _InputIterator __last);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_map(_InputIterator __first, _InputIterator __last,
-                      size_type __n, const hasher& __hf = hasher(),
-                      const key_equal& __eql = key_equal());
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_map(_InputIterator __first, _InputIterator __last,
-                      size_type __n, const hasher& __hf,
-                      const key_equal& __eql,
-                      const allocator_type& __a);
-    _LIBCPP_INLINE_VISIBILITY
-    explicit unordered_map(const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI unordered_map(const unordered_map& __u);
-    _LIBCPP_HIDE_FROM_ABI unordered_map(const unordered_map& __u, const allocator_type& __a);
+    insert_range(std::forward<_Range>(__range));
+  }
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI explicit unordered_map(const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI unordered_map(const unordered_map& __u);
+  _LIBCPP_HIDE_FROM_ABI unordered_map(const unordered_map& __u, const allocator_type& __a);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_map(unordered_map&& __u)
-        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
-    _LIBCPP_HIDE_FROM_ABI unordered_map(unordered_map&& __u, const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI unordered_map(initializer_list<value_type> __il);
-    _LIBCPP_HIDE_FROM_ABI unordered_map(initializer_list<value_type> __il, size_type __n,
-                  const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
-    _LIBCPP_HIDE_FROM_ABI unordered_map(initializer_list<value_type> __il, size_type __n,
-                  const hasher& __hf, const key_equal& __eql,
-                  const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI unordered_map(unordered_map&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+  _LIBCPP_HIDE_FROM_ABI unordered_map(unordered_map&& __u, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI unordered_map(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_map(initializer_list<value_type> __il,
+                size_type __n,
+                const hasher& __hf     = hasher(),
+                const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI unordered_map(
+      initializer_list<value_type> __il,
+      size_type __n,
+      const hasher& __hf,
+      const key_equal& __eql,
+      const allocator_type& __a);
 #endif // _LIBCPP_CXX03_LANG
 #if _LIBCPP_STD_VER >= 14
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_map(size_type __n, const allocator_type& __a)
+  _LIBCPP_HIDE_FROM_ABI unordered_map(size_type __n, const allocator_type& __a)
       : unordered_map(__n, hasher(), key_equal(), __a) {}
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a)
+  _LIBCPP_HIDE_FROM_ABI unordered_map(size_type __n, const hasher& __hf, const allocator_type& __a)
       : unordered_map(__n, __hf, key_equal(), __a) {}
-    template <class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-      unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
       : unordered_map(__first, __last, __n, hasher(), key_equal(), __a) {}
-    template <class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-      unordered_map(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf,
-        const allocator_type& __a)
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_map(
+      _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a)
       : unordered_map(__first, __last, __n, __hf, key_equal(), __a) {}
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_map(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
+
+#  if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI unordered_map(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a)
+      : unordered_map(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {}
+
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_map(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_map(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {}
+#  endif
+
+  _LIBCPP_HIDE_FROM_ABI unordered_map(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
       : unordered_map(__il, __n, hasher(), key_equal(), __a) {}
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_map(initializer_list<value_type> __il, size_type __n, const hasher& __hf,
-      const allocator_type& __a)
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_map(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
       : unordered_map(__il, __n, __hf, key_equal(), __a) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    ~unordered_map() {
-        static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
-    }
+  _LIBCPP_HIDE_FROM_ABI ~unordered_map() {
+    static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_map& operator=(const unordered_map& __u)
-    {
+  _LIBCPP_HIDE_FROM_ABI unordered_map& operator=(const unordered_map& __u) {
 #ifndef _LIBCPP_CXX03_LANG
-        __table_ = __u.__table_;
+    __table_ = __u.__table_;
 #else
-        if (this != _VSTD::addressof(__u)) {
-            __table_.clear();
-            __table_.hash_function() = __u.__table_.hash_function();
-            __table_.key_eq() = __u.__table_.key_eq();
-            __table_.max_load_factor() = __u.__table_.max_load_factor();
-            __table_.__copy_assign_alloc(__u.__table_);
-            insert(__u.begin(), __u.end());
-        }
-#endif
-        return *this;
+    if (this != std::addressof(__u)) {
+      __table_.clear();
+      __table_.hash_function()   = __u.__table_.hash_function();
+      __table_.key_eq()          = __u.__table_.key_eq();
+      __table_.max_load_factor() = __u.__table_.max_load_factor();
+      __table_.__copy_assign_alloc(__u.__table_);
+      insert(__u.begin(), __u.end());
     }
+#endif
+    return *this;
+  }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_map& operator=(unordered_map&& __u)
-        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_map& operator=(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI unordered_map& operator=(unordered_map&& __u)
+      _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
+  _LIBCPP_HIDE_FROM_ABI unordered_map& operator=(initializer_list<value_type> __il);
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT
-        {return allocator_type(__table_.__node_alloc());}
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
+    return allocator_type(__table_.__node_alloc());
+  }
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __table_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT        {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT          {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> insert(const value_type& __x)
-        {return __table_.__insert_unique(__x);}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __x) { return __table_.__insert_unique(__x); }
 
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __x) {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                             "unordered_map::insert(const_iterator, const value_type&) called with an iterator not "
-                             "referring to this unordered_map");
-        ((void)__p);
-        return insert(__x).first;
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, const value_type& __x) { return insert(__x).first; }
+
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+    for (auto&& __element : __range) {
+      __table_.__insert_unique(std::forward<decltype(__element)>(__element));
     }
-
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        void insert(_InputIterator __first, _InputIterator __last);
+  }
+#endif
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void insert(initializer_list<value_type> __il)
-        {insert(__il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> insert(value_type&& __x)
-        {return __table_.__insert_unique(_VSTD::move(__x));}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(value_type&& __x) {
+    return __table_.__insert_unique(std::move(__x));
+  }
 
-    _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __x) {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                             "unordered_map::insert(const_iterator, const value_type&) called with an iterator not"
-                             " referring to this unordered_map");
-        ((void)__p);
-        return __table_.__insert_unique(_VSTD::move(__x)).first;
-    }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, value_type&& __x) {
+    return __table_.__insert_unique(std::move(__x)).first;
+  }
 
-    template <class _Pp,
-              class = __enable_if_t<is_constructible<value_type, _Pp>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> insert(_Pp&& __x)
-            {return __table_.__insert_unique(_VSTD::forward<_Pp>(__x));}
+  template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(_Pp&& __x) {
+    return __table_.__insert_unique(std::forward<_Pp>(__x));
+  }
 
-    template <class _Pp,
-              class = __enable_if_t<is_constructible<value_type, _Pp>::value> >
-        _LIBCPP_INLINE_VISIBILITY
-        iterator insert(const_iterator __p, _Pp&& __x)
-        {
-            _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                                 "unordered_map::insert(const_iterator, value_type&&) called with an iterator not"
-                                 " referring to this unordered_map");
-          ((void)__p);
-            return insert(_VSTD::forward<_Pp>(__x)).first;
-        }
+  template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, _Pp&& __x) {
+    return insert(std::forward<_Pp>(__x)).first;
+  }
 
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> emplace(_Args&&... __args) {
-        return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
+    return __table_.__emplace_unique(std::forward<_Args>(__args)...);
+  }
 
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator emplace_hint(const_iterator __p, _Args&&... __args) {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__p)) == this,
-                             "unordered_map::emplace_hint(const_iterator, args...) called with an iterator not"
-                             " referring to this unordered_map");
-          ((void)__p);
-        return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator, _Args&&... __args) {
+    return __table_.__emplace_unique(std::forward<_Args>(__args)...).first;
+  }
 
 #endif // _LIBCPP_CXX03_LANG
 
 #if _LIBCPP_STD_VER >= 17
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args)
-    {
-        return __table_.__emplace_unique_key_args(__k, piecewise_construct,
-            _VSTD::forward_as_tuple(__k),
-            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args) {
+    return __table_.__emplace_unique_key_args(
+        __k, piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple(std::forward<_Args>(__args)...));
+  }
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args) {
+    return __table_.__emplace_unique_key_args(
+        __k,
+        piecewise_construct,
+        std::forward_as_tuple(std::move(__k)),
+        std::forward_as_tuple(std::forward<_Args>(__args)...));
+  }
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator, const key_type& __k, _Args&&... __args) {
+    return try_emplace(__k, std::forward<_Args>(__args)...).first;
+  }
+
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator, key_type&& __k, _Args&&... __args) {
+    return try_emplace(std::move(__k), std::forward<_Args>(__args)...).first;
+  }
+
+  template <class _Vp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v) {
+    pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k, __k, std::forward<_Vp>(__v));
+    if (!__res.second) {
+      __res.first->second = std::forward<_Vp>(__v);
     }
+    return __res;
+  }
 
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args)
-    {
-        return __table_.__emplace_unique_key_args(__k, piecewise_construct,
-            _VSTD::forward_as_tuple(_VSTD::move(__k)),
-            _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...));
+  template <class _Vp>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v) {
+    pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k, std::move(__k), std::forward<_Vp>(__v));
+    if (!__res.second) {
+      __res.first->second = std::forward<_Vp>(__v);
     }
+    return __res;
+  }
 
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args)
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__h)) == this,
-                             "unordered_map::try_emplace(const_iterator, key, args...) called with an iterator not"
-                             " referring to this unordered_map");
-        ((void)__h);
-        return try_emplace(__k, _VSTD::forward<_Args>(__args)...).first;
-    }
+  template <class _Vp>
+  _LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator, const key_type& __k, _Vp&& __v) {
+    return insert_or_assign(__k, std::forward<_Vp>(__v)).first;
+  }
 
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args)
-    {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(_VSTD::addressof(__h)) == this,
-                             "unordered_map::try_emplace(const_iterator, key, args...) called with an iterator not"
-                             " referring to this unordered_map");
-        ((void)__h);
-        return try_emplace(_VSTD::move(__k), _VSTD::forward<_Args>(__args)...).first;
-    }
-
-    template <class _Vp>
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v)
-    {
-        pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k,
-            __k, _VSTD::forward<_Vp>(__v));
-        if (!__res.second) {
-            __res.first->second = _VSTD::forward<_Vp>(__v);
-        }
-        return __res;
-    }
-
-    template <class _Vp>
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v)
-    {
-        pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k,
-            _VSTD::move(__k), _VSTD::forward<_Vp>(__v));
-        if (!__res.second) {
-            __res.first->second = _VSTD::forward<_Vp>(__v);
-        }
-        return __res;
-    }
-
-    template <class _Vp>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator insert_or_assign(const_iterator, const key_type& __k, _Vp&& __v)
-     {
-          // FIXME: Add debug mode checking for the iterator input
-          return insert_or_assign(__k, _VSTD::forward<_Vp>(__v)).first;
-     }
-
-    template <class _Vp>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator insert_or_assign(const_iterator, key_type&& __k, _Vp&& __v)
-     {
-        // FIXME: Add debug mode checking for the iterator input
-        return insert_or_assign(_VSTD::move(__k), _VSTD::forward<_Vp>(__v)).first;
-     }
+  template <class _Vp>
+  _LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator, key_type&& __k, _Vp&& __v) {
+    return insert_or_assign(std::move(__k), std::forward<_Vp>(__v)).first;
+  }
 #endif // _LIBCPP_STD_VER >= 17
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(iterator __p)       {return __table_.erase(__p.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __first, const_iterator __last)
-        {return __table_.erase(__first.__i_, __last.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-        void clear() _NOEXCEPT {__table_.clear();}
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p) { return __table_.erase(__p.__i_); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(iterator __p) { return __table_.erase(__p.__i_); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __table_.__erase_unique(__k); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
+    return __table_.erase(__first.__i_, __last.__i_);
+  }
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __table_.clear(); }
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
-    insert_return_type insert(node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to unordered_map::insert()");
-        return __table_.template __node_handle_insert_unique<
-            node_type, insert_return_type>(_VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __hint, node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to unordered_map::insert()");
-        return __table_.template __node_handle_insert_unique<node_type>(
-            __hint.__i_, _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(key_type const& __key)
-    {
-        return __table_.template __node_handle_extract<node_type>(__key);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(const_iterator __it)
-    {
-        return __table_.template __node_handle_extract<node_type>(
-            __it.__i_);
-    }
+  _LIBCPP_HIDE_FROM_ABI insert_return_type insert(node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to unordered_map::insert()");
+    return __table_.template __node_handle_insert_unique< node_type, insert_return_type>(std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to unordered_map::insert()");
+    return __table_.template __node_handle_insert_unique<node_type>(__hint.__i_, std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+    return __table_.template __node_handle_extract<node_type>(__key);
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+    return __table_.template __node_handle_extract<node_type>(__it.__i_);
+  }
 
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_unique(__source.__table_);
-    }
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_unique(__source.__table_);
-    }
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_unique(__source.__table_);
-    }
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_unique(__source.__table_);
-    }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_unique(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_unique(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_unique(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_unique(__source.__table_);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_map& __u)
-        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
-        { __table_.swap(__u.__table_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(unordered_map& __u) _NOEXCEPT_(__is_nothrow_swappable_v<__table>) {
+    __table_.swap(__u.__table_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    hasher hash_function() const
-        {return __table_.hash_function().hash_function();}
-    _LIBCPP_INLINE_VISIBILITY
-    key_equal key_eq() const
-        {return __table_.key_eq().key_eq();}
+  _LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function().hash_function(); }
+  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq().key_eq(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       find(const key_type& __k)       {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const key_type& __k) const {return __table_.find(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
 #if _LIBCPP_STD_VER >= 20
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       find(const _K2& __k)            {return __table_.find(__k);}
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const _K2& __k) const      {return __table_.find(__k);}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+    return __table_.find(__k);
+  }
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+    return __table_.find(__k);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_unique(__k); }
 #if _LIBCPP_STD_VER >= 20
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    size_type count(const _K2& __k) const      {return __table_.__count_unique(__k);}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+    return __table_.__count_unique(__k);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const key_type& __k) const {return find(__k) != end();}
+  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
 
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const _K2& __k) const      {return find(__k) != end();}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+    return find(__k) != end();
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, iterator>             equal_range(const key_type& __k)
-        {return __table_.__equal_range_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
-        {return __table_.__equal_range_unique(__k);}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __table_.__equal_range_unique(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __table_.__equal_range_unique(__k);
+  }
 #if _LIBCPP_STD_VER >= 20
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, iterator>             equal_range(const _K2& __k)
-        {return __table_.__equal_range_unique(__k);}
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
-        {return __table_.__equal_range_unique(__k);}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+    return __table_.__equal_range_unique(__k);
+  }
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+    return __table_.__equal_range_unique(__k);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](const key_type& __k);
+  _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](const key_type& __k);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __k);
+  _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __k);
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI mapped_type&       at(const key_type& __k);
-    _LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __k) const;
+  _LIBCPP_HIDE_FROM_ABI mapped_type& at(const key_type& __k);
+  _LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __k) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return __table_.max_bucket_count(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_size(size_type __n) const
-        {return __table_.bucket_size(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const { return __table_.bucket_size(__n); }
+  _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    local_iterator       begin(size_type __n)        {return __table_.begin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    local_iterator       end(size_type __n)          {return __table_.end(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator begin(size_type __n) const  {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator end(size_type __n) const    {return __table_.cend(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}
+  _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
+  _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const { return __table_.cbegin(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const { return __table_.cbegin(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
-    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
-    void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
-    _LIBCPP_INLINE_VISIBILITY
-    void rehash(size_type __n) {__table_.__rehash_unique(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    void reserve(size_type __n) {__table_.__reserve_unique(__n);}
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-    _LIBCPP_HIDE_FROM_ABI bool __dereferenceable(const const_iterator* __i) const
-        {return __table_.__dereferenceable(_VSTD::addressof(__i->__i_));}
-    _LIBCPP_HIDE_FROM_ABI bool __decrementable(const const_iterator* __i) const
-        {return __table_.__decrementable(_VSTD::addressof(__i->__i_));}
-    _LIBCPP_HIDE_FROM_ABI bool __addable(const const_iterator* __i, ptrdiff_t __n) const
-        {return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
-    _LIBCPP_HIDE_FROM_ABI bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
-        {return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
+  _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
+  _LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) { __table_.max_load_factor(__mlf); }
+  _LIBCPP_HIDE_FROM_ABI void rehash(size_type __n) { __table_.__rehash_unique(__n); }
+  _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n) { __table_.__reserve_unique(__n); }
 
 private:
-
 #ifdef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node_with_key(const key_type& __k);
+  _LIBCPP_HIDE_FROM_ABI __node_holder __construct_node_with_key(const key_type& __k);
 #endif
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Hash = hash<__iter_key_type<_InputIterator>>,
-         class _Pred = equal_to<__iter_key_type<_InputIterator>>,
-         class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<!__is_allocator<_Pred>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0,
-              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
-  -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Hash, _Pred, _Allocator>;
+template <class _InputIterator,
+          class _Hash      = hash<__iter_key_type<_InputIterator>>,
+          class _Pred      = equal_to<__iter_key_type<_InputIterator>>,
+          class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
+          class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_map(_InputIterator,
+              _InputIterator,
+              typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash                                            = _Hash(),
+              _Pred                                            = _Pred(),
+              _Allocator                                       = _Allocator())
+    -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Hash, _Pred, _Allocator>;
 
-template<class _Key, class _Tp, class _Hash = hash<remove_const_t<_Key>>,
-         class _Pred = equal_to<remove_const_t<_Key>>,
-         class _Allocator = allocator<pair<const _Key, _Tp>>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<!__is_allocator<_Pred>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type = 0,
-              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
-  -> unordered_map<remove_const_t<_Key>, _Tp, _Hash, _Pred, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Hash      = hash<__range_key_type<_Range>>,
+          class _Pred      = equal_to<__range_key_type<_Range>>,
+          class _Allocator = allocator<__range_to_alloc_type<_Range>>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_map(from_range_t,
+              _Range&&,
+              typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash                                            = _Hash(),
+              _Pred                                            = _Pred(),
+              _Allocator                                       = _Allocator())
+    -> unordered_map<__range_key_type<_Range>, __range_mapped_type<_Range>, _Hash, _Pred, _Allocator>; // C++23
+#  endif
 
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Key,
+          class _Tp,
+          class _Hash      = hash<remove_const_t<_Key>>,
+          class _Pred      = equal_to<remove_const_t<_Key>>,
+          class _Allocator = allocator<pair<const _Key, _Tp>>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_map(initializer_list<pair<_Key, _Tp>>,
+              typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash                                            = _Hash(),
+              _Pred                                            = _Pred(),
+              _Allocator = _Allocator()) -> unordered_map<remove_const_t<_Key>, _Tp, _Hash, _Pred, _Allocator>;
+
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
-  -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
-                   hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+    -> unordered_map<__iter_key_type<_InputIterator>,
+                     __iter_mapped_type<_InputIterator>,
+                     hash<__iter_key_type<_InputIterator>>,
+                     equal_to<__iter_key_type<_InputIterator>>,
+                     _Allocator>;
 
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_map(_InputIterator, _InputIterator, _Allocator)
-  -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
-                   hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+    -> unordered_map<__iter_key_type<_InputIterator>,
+                     __iter_mapped_type<_InputIterator>,
+                     hash<__iter_key_type<_InputIterator>>,
+                     equal_to<__iter_key_type<_InputIterator>>,
+                     _Allocator>;
 
-template<class _InputIterator, class _Hash, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _InputIterator,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
-  -> unordered_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
-                   _Hash, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+    -> unordered_map<__iter_key_type<_InputIterator>,
+                     __iter_mapped_type<_InputIterator>,
+                     _Hash,
+                     equal_to<__iter_key_type<_InputIterator>>,
+                     _Allocator>;
 
-template<class _Key, class _Tp, class _Allocator,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+#  if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_map(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
+    -> unordered_map<__range_key_type<_Range>,
+                     __range_mapped_type<_Range>,
+                     hash<__range_key_type<_Range>>,
+                     equal_to<__range_key_type<_Range>>,
+                     _Allocator>;
+
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_map(from_range_t, _Range&&, _Allocator)
+    -> unordered_map<__range_key_type<_Range>,
+                     __range_mapped_type<_Range>,
+                     hash<__range_key_type<_Range>>,
+                     equal_to<__range_key_type<_Range>>,
+                     _Allocator>;
+
+template <ranges::input_range _Range,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_map(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+    -> unordered_map<__range_key_type<_Range>,
+                     __range_mapped_type<_Range>,
+                     _Hash,
+                     equal_to<__range_key_type<_Range>>,
+                     _Allocator>;
+
+#  endif
+
+template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
-  -> unordered_map<remove_const_t<_Key>, _Tp,
-                   hash<remove_const_t<_Key>>,
-                   equal_to<remove_const_t<_Key>>, _Allocator>;
+    -> unordered_map<remove_const_t<_Key>, _Tp, hash<remove_const_t<_Key>>, equal_to<remove_const_t<_Key>>, _Allocator>;
 
-template<class _Key, class _Tp, class _Allocator,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_map(initializer_list<pair<_Key, _Tp>>, _Allocator)
-  -> unordered_map<remove_const_t<_Key>, _Tp,
-                   hash<remove_const_t<_Key>>,
-                   equal_to<remove_const_t<_Key>>, _Allocator>;
+    -> unordered_map<remove_const_t<_Key>, _Tp, hash<remove_const_t<_Key>>, equal_to<remove_const_t<_Key>>, _Allocator>;
 
-template<class _Key, class _Tp, class _Hash, class _Allocator,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Key,
+          class _Tp,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
-  -> unordered_map<remove_const_t<_Key>, _Tp, _Hash,
-                   equal_to<remove_const_t<_Key>>, _Allocator>;
+    -> unordered_map<remove_const_t<_Key>, _Tp, _Hash, equal_to<remove_const_t<_Key>>, _Allocator>;
 #endif
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        size_type __n, const hasher& __hf, const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
+unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_unique(__n);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        size_type __n, const hasher& __hf, const key_equal& __eql,
-        const allocator_type& __a)
-    : __table_(__hf, __eql, typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
+    size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, typename __table::allocator_type(__a)) {
+  __table_.__rehash_unique(__n);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        const allocator_type& __a)
-    : __table_(typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
+inline unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(const allocator_type& __a)
+    : __table_(typename __table::allocator_type(__a)) {}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(_InputIterator __first, _InputIterator __last) {
+  insert(__first, __last);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        _InputIterator __first, _InputIterator __last)
-{
-    _VSTD::__debug_db_insert_c(this);
-    insert(__first, __last);
+    _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_unique(__n);
+  insert(__first, __last);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        _InputIterator __first, _InputIterator __last, size_type __n,
-        const hasher& __hf, const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
-    insert(__first, __last);
+    _InputIterator __first,
+    _InputIterator __last,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, typename __table::allocator_type(__a)) {
+  __table_.__rehash_unique(__n);
+  insert(__first, __last);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-template <class _InputIterator>
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        _InputIterator __first, _InputIterator __last, size_type __n,
-        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
-    : __table_(__hf, __eql, typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
-    insert(__first, __last);
+unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(const unordered_map& __u) : __table_(__u.__table_) {
+  __table_.__rehash_unique(__u.bucket_count());
+  insert(__u.begin(), __u.end());
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        const unordered_map& __u)
-    : __table_(__u.__table_)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__u.bucket_count());
-    insert(__u.begin(), __u.end());
-}
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        const unordered_map& __u, const allocator_type& __a)
-    : __table_(__u.__table_, typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__u.bucket_count());
-    insert(__u.begin(), __u.end());
+unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(const unordered_map& __u, const allocator_type& __a)
+    : __table_(__u.__table_, typename __table::allocator_type(__a)) {
+  __table_.__rehash_unique(__u.bucket_count());
+  insert(__u.begin(), __u.end());
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        unordered_map&& __u)
+inline unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(unordered_map&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(_VSTD::move(__u.__table_))
-{
-    _VSTD::__debug_db_insert_c(this);
-    std::__debug_db_swap(this, std::addressof(__u));
-}
+    : __table_(std::move(__u.__table_)) {}
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        unordered_map&& __u, const allocator_type& __a)
-    : __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
-    if (__a != __u.get_allocator())
-    {
-        iterator __i = __u.begin();
-        while (__u.size() != 0) {
-            __table_.__emplace_unique(
-                __u.__table_.remove((__i++).__i_)->__value_.__move());
-        }
+unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(unordered_map&& __u, const allocator_type& __a)
+    : __table_(std::move(__u.__table_), typename __table::allocator_type(__a)) {
+  if (__a != __u.get_allocator()) {
+    iterator __i = __u.begin();
+    while (__u.size() != 0) {
+      __table_.__emplace_unique(__u.__table_.remove((__i++).__i_)->__get_value().__move());
     }
-    else
-        std::__debug_db_swap(this, std::addressof(__u));
+  }
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(initializer_list<value_type> __il) {
+  insert(__il.begin(), __il.end());
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        initializer_list<value_type> __il)
-{
-    _VSTD::__debug_db_insert_c(this);
-    insert(__il.begin(), __il.end());
+    initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_unique(__n);
+  insert(__il.begin(), __il.end());
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
-        const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
-    insert(__il.begin(), __il.end());
+    initializer_list<value_type> __il,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, typename __table::allocator_type(__a)) {
+  __table_.__rehash_unique(__n);
+  insert(__il.begin(), __il.end());
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
-        const key_equal& __eql, const allocator_type& __a)
-    : __table_(__hf, __eql, typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
-    insert(__il.begin(), __il.end());
-}
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
+inline unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
-{
-    __table_ = _VSTD::move(__u.__table_);
-    return *this;
+    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) {
+  __table_ = std::move(__u.__table_);
+  return *this;
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
-        initializer_list<value_type> __il)
-{
-    __table_.__assign_unique(__il.begin(), __il.end());
-    return *this;
+inline unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
+unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(initializer_list<value_type> __il) {
+  __table_.__assign_unique(__il.begin(), __il.end());
+  return *this;
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline
-void
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
-                                                       _InputIterator __last)
-{
-    for (; __first != __last; ++__first)
-        __table_.__insert_unique(*__first);
+inline void unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last) {
+  for (; __first != __last; ++__first)
+    __table_.__insert_unique(*__first);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-_Tp&
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
-{
-    return __table_.__emplace_unique_key_args(__k,
-        piecewise_construct, _VSTD::forward_as_tuple(__k),
-                             _VSTD::forward_as_tuple()).first->__get_value().second;
+_Tp& unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k) {
+  return __table_
+      .__emplace_unique_key_args(__k, piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple())
+      .first->__get_value()
+      .second;
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-_Tp&
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k)
-{
-    return __table_.__emplace_unique_key_args(__k,
-        piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__k)),
-                             _VSTD::forward_as_tuple()).first->__get_value().second;
+_Tp& unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k) {
+  return __table_
+      .__emplace_unique_key_args(
+          __k, piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple())
+      .first->__get_value()
+      .second;
 }
 #else // _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const key_type& __k)
-{
-    __node_allocator& __na = __table_.__node_alloc();
-    __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().first), __k);
-    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.__get_value().second));
-    __h.get_deleter().__second_constructed = true;
-    return __h;
+unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const key_type& __k) {
+  __node_allocator& __na = __table_.__node_alloc();
+  __node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
+  __node_traits::construct(__na, std::addressof(__h->__get_value().__get_value().first), __k);
+  __h.get_deleter().__first_constructed = true;
+  __node_traits::construct(__na, std::addressof(__h->__get_value().__get_value().second));
+  __h.get_deleter().__second_constructed = true;
+  return __h;
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-_Tp&
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
-{
-    iterator __i = find(__k);
-    if (__i != end())
-        return __i->second;
-    __node_holder __h = __construct_node_with_key(__k);
-    pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
-    __h.release();
-    return __r.first->second;
+_Tp& unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k) {
+  iterator __i = find(__k);
+  if (__i != end())
+    return __i->second;
+  __node_holder __h        = __construct_node_with_key(__k);
+  pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
+  __h.release();
+  return __r.first->second;
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-_Tp&
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k)
-{
-    iterator __i = find(__k);
-    if (__i == end())
-        __throw_out_of_range("unordered_map::at: key not found");
-    return __i->second;
+_Tp& unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) {
+  iterator __i = find(__k);
+  if (__i == end())
+    __throw_out_of_range("unordered_map::at: key not found");
+  return __i->second;
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-const _Tp&
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) const
-{
-    const_iterator __i = find(__k);
-    if (__i == end())
-        __throw_out_of_range("unordered_map::at: key not found");
-    return __i->second;
+const _Tp& unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) const {
+  const_iterator __i = find(__k);
+  if (__i == end())
+    __throw_out_of_range("unordered_map::at: key not found");
+  return __i->second;
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
-     unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
-          class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-    typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
-    erase_if(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __c,
-             _Predicate __pred) {
-  return _VSTD::__libcpp_erase_if_container(__c, __pred);
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc, class _Predicate>
+inline _LIBCPP_HIDE_FROM_ABI typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
+erase_if(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __c, _Predicate __pred) {
+  return std::__libcpp_erase_if_container(__c, __pred);
 }
 #endif
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-_LIBCPP_HIDE_FROM_ABI bool
-operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
-           const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
-{
-    if (__x.size() != __y.size())
-        return false;
-    typedef typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator
-                                                                 const_iterator;
-    for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end();
-            __i != __ex; ++__i)
-    {
-        const_iterator __j = __y.find(__i->first);
-        if (__j == __ey || !(*__i == *__j))
-            return false;
-    }
-    return true;
+_LIBCPP_HIDE_FROM_ABI bool operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+                                      const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) {
+  if (__x.size() != __y.size())
+    return false;
+  typedef typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator const_iterator;
+  for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end(); __i != __ex; ++__i) {
+    const_iterator __j = __y.find(__i->first);
+    if (__j == __ey || !(*__i == *__j))
+      return false;
+  }
+  return true;
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
-           const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+                                             const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) {
+  return !(__x == __y);
 }
 
-template <class _Key, class _Tp, class _Hash = hash<_Key>, class _Pred = equal_to<_Key>,
+#endif
+
+template <class _Key,
+          class _Tp,
+          class _Hash  = hash<_Key>,
+          class _Pred  = equal_to<_Key>,
           class _Alloc = allocator<pair<const _Key, _Tp> > >
-class _LIBCPP_TEMPLATE_VIS unordered_multimap
-{
+class _LIBCPP_TEMPLATE_VIS unordered_multimap {
 public:
-    // types
-    typedef _Key                                           key_type;
-    typedef _Tp                                            mapped_type;
-    typedef __type_identity_t<_Hash>                       hasher;
-    typedef __type_identity_t<_Pred>                       key_equal;
-    typedef __type_identity_t<_Alloc>                      allocator_type;
-    typedef pair<const key_type, mapped_type>              value_type;
-    typedef value_type&                                    reference;
-    typedef const value_type&                              const_reference;
-    static_assert((is_same<value_type, typename allocator_type::value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
+  // types
+  typedef _Key key_type;
+  typedef _Tp mapped_type;
+  typedef __type_identity_t<_Hash> hasher;
+  typedef __type_identity_t<_Pred> key_equal;
+  typedef __type_identity_t<_Alloc> allocator_type;
+  typedef pair<const key_type, mapped_type> value_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
+  static_assert(is_same<value_type, typename allocator_type::value_type>::value,
+                "Allocator::value_type must be same type as value_type");
 
 private:
-    typedef __hash_value_type<key_type, mapped_type>                          __value_type;
-    typedef __unordered_map_hasher<key_type, __value_type, hasher, key_equal> __hasher;
-    typedef __unordered_map_equal<key_type, __value_type, key_equal, hasher>  __key_equal;
-    typedef __rebind_alloc<allocator_traits<allocator_type>, __value_type>    __allocator_type;
+  typedef __hash_value_type<key_type, mapped_type> __value_type;
+  typedef __unordered_map_hasher<key_type, __value_type, hasher, key_equal> __hasher;
+  typedef __unordered_map_equal<key_type, __value_type, key_equal, hasher> __key_equal;
+  typedef __rebind_alloc<allocator_traits<allocator_type>, __value_type> __allocator_type;
 
-    typedef __hash_table<__value_type, __hasher,
-                         __key_equal,  __allocator_type>   __table;
+  typedef __hash_table<__value_type, __hasher, __key_equal, __allocator_type> __table;
 
-    __table __table_;
+  __table __table_;
 
-    typedef typename __table::_NodeTypes                   _NodeTypes;
-    typedef typename __table::__node_traits                __node_traits;
-    typedef typename __table::__node_allocator             __node_allocator;
-    typedef typename __table::__node                       __node;
-    typedef __hash_map_node_destructor<__node_allocator>   _Dp;
-    typedef unique_ptr<__node, _Dp>                         __node_holder;
-    typedef allocator_traits<allocator_type>               __alloc_traits;
-    static_assert((is_same<typename __node_traits::size_type,
-                          typename __alloc_traits::size_type>::value),
-                 "Allocator uses different size_type for different types");
+  typedef typename __table::_NodeTypes _NodeTypes;
+  typedef typename __table::__node_traits __node_traits;
+  typedef typename __table::__node_allocator __node_allocator;
+  typedef typename __table::__node __node;
+  typedef __hash_map_node_destructor<__node_allocator> _Dp;
+  typedef unique_ptr<__node, _Dp> __node_holder;
+  typedef allocator_traits<allocator_type> __alloc_traits;
+  static_assert(is_same<typename __node_traits::size_type, typename __alloc_traits::size_type>::value,
+                "Allocator uses different size_type for different types");
 
-    static_assert(is_same<allocator_type, __rebind_alloc<__alloc_traits, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
+public:
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
+  typedef typename __table::size_type size_type;
+  typedef typename __table::difference_type difference_type;
 
-  public:
-    typedef typename __alloc_traits::pointer         pointer;
-    typedef typename __alloc_traits::const_pointer   const_pointer;
-    typedef typename __table::size_type              size_type;
-    typedef typename __table::difference_type        difference_type;
-
-    typedef __hash_map_iterator<typename __table::iterator>       iterator;
-    typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
-    typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
-    typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
+  typedef __hash_map_iterator<typename __table::iterator> iterator;
+  typedef __hash_map_const_iterator<typename __table::const_iterator> const_iterator;
+  typedef __hash_map_iterator<typename __table::local_iterator> local_iterator;
+  typedef __hash_map_const_iterator<typename __table::const_local_iterator> const_local_iterator;
 
 #if _LIBCPP_STD_VER >= 17
-    typedef __map_node_handle<__node, allocator_type> node_type;
+  typedef __map_node_handle<__node, allocator_type> node_type;
 #endif
 
-    template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_map;
-    template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
+  template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_map;
+  template <class _Key2, class _Tp2, class _Hash2, class _Pred2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_multimap;
 
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multimap()
-        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
-    {
-        _VSTD::__debug_db_insert_c(this);
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap() _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) {}
+  explicit _LIBCPP_HIDE_FROM_ABI
+  unordered_multimap(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_multimap(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(
+      _InputIterator __first,
+      _InputIterator __last,
+      size_type __n,
+      const hasher& __hf     = hasher(),
+      const key_equal& __eql = key_equal());
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(
+      _InputIterator __first,
+      _InputIterator __last,
+      size_type __n,
+      const hasher& __hf,
+      const key_equal& __eql,
+      const allocator_type& __a);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(
+      from_range_t,
+      _Range&& __range,
+      size_type __n             = /*implementation-defined*/ 0,
+      const hasher& __hf        = hasher(),
+      const key_equal& __eql    = key_equal(),
+      const allocator_type& __a = allocator_type())
+      : __table_(__hf, __eql, typename __table::allocator_type(__a)) {
+    if (__n > 0) {
+      __table_.__rehash_multi(__n);
     }
-    explicit _LIBCPP_HIDE_FROM_ABI unordered_multimap(size_type __n, const hasher& __hf = hasher(),
-                                const key_equal& __eql = key_equal());
-    _LIBCPP_HIDE_FROM_ABI unordered_multimap(size_type __n, const hasher& __hf,
-                                const key_equal& __eql,
-                                const allocator_type& __a);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_multimap(_InputIterator __first, _InputIterator __last);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_multimap(_InputIterator __first, _InputIterator __last,
-                      size_type __n, const hasher& __hf = hasher(),
-                      const key_equal& __eql = key_equal());
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_multimap(_InputIterator __first, _InputIterator __last,
-                      size_type __n, const hasher& __hf,
-                      const key_equal& __eql,
-                      const allocator_type& __a);
-    _LIBCPP_INLINE_VISIBILITY
-    explicit unordered_multimap(const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI unordered_multimap(const unordered_multimap& __u);
-    _LIBCPP_HIDE_FROM_ABI unordered_multimap(const unordered_multimap& __u, const allocator_type& __a);
+    insert_range(std::forward<_Range>(__range));
+  }
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI explicit unordered_multimap(const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(const unordered_multimap& __u);
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(const unordered_multimap& __u, const allocator_type& __a);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multimap(unordered_multimap&& __u)
-        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
-    _LIBCPP_HIDE_FROM_ABI unordered_multimap(unordered_multimap&& __u, const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI unordered_multimap(initializer_list<value_type> __il);
-    _LIBCPP_HIDE_FROM_ABI unordered_multimap(initializer_list<value_type> __il, size_type __n,
-                       const hasher& __hf = hasher(),
-                       const key_equal& __eql = key_equal());
-    _LIBCPP_HIDE_FROM_ABI unordered_multimap(initializer_list<value_type> __il, size_type __n,
-                       const hasher& __hf, const key_equal& __eql,
-                       const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(unordered_multimap&& __u)
+      _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(unordered_multimap&& __u, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(
+      initializer_list<value_type> __il,
+      size_type __n,
+      const hasher& __hf     = hasher(),
+      const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(
+      initializer_list<value_type> __il,
+      size_type __n,
+      const hasher& __hf,
+      const key_equal& __eql,
+      const allocator_type& __a);
 #endif // _LIBCPP_CXX03_LANG
 #if _LIBCPP_STD_VER >= 14
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multimap(size_type __n, const allocator_type& __a)
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(size_type __n, const allocator_type& __a)
       : unordered_multimap(__n, hasher(), key_equal(), __a) {}
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a)
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(size_type __n, const hasher& __hf, const allocator_type& __a)
       : unordered_multimap(__n, __hf, key_equal(), __a) {}
-    template <class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-      unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
       : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a) {}
-    template <class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-      unordered_multimap(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf,
-        const allocator_type& __a)
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(
+      _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a)
       : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) {}
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multimap(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
+
+#  if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a)
+      : unordered_multimap(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {}
+
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_multimap(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_multimap(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {}
+#  endif
+
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
       : unordered_multimap(__il, __n, hasher(), key_equal(), __a) {}
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multimap(initializer_list<value_type> __il, size_type __n, const hasher& __hf,
-      const allocator_type& __a)
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_multimap(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
       : unordered_multimap(__il, __n, __hf, key_equal(), __a) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    ~unordered_multimap() {
-        static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
-    }
+  _LIBCPP_HIDE_FROM_ABI ~unordered_multimap() {
+    static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multimap& operator=(const unordered_multimap& __u)
-    {
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap& operator=(const unordered_multimap& __u) {
 #ifndef _LIBCPP_CXX03_LANG
-        __table_ = __u.__table_;
+    __table_ = __u.__table_;
 #else
-        if (this != _VSTD::addressof(__u)) {
-            __table_.clear();
-            __table_.hash_function() = __u.__table_.hash_function();
-            __table_.key_eq() = __u.__table_.key_eq();
-            __table_.max_load_factor() = __u.__table_.max_load_factor();
-            __table_.__copy_assign_alloc(__u.__table_);
-            insert(__u.begin(), __u.end());
-        }
+    if (this != std::addressof(__u)) {
+      __table_.clear();
+      __table_.hash_function()   = __u.__table_.hash_function();
+      __table_.key_eq()          = __u.__table_.key_eq();
+      __table_.max_load_factor() = __u.__table_.max_load_factor();
+      __table_.__copy_assign_alloc(__u.__table_);
+      insert(__u.begin(), __u.end());
+    }
 #endif
-        return *this;
-    }
+    return *this;
+  }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multimap& operator=(unordered_multimap&& __u)
-        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multimap& operator=(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap& operator=(unordered_multimap&& __u)
+      _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap& operator=(initializer_list<value_type> __il);
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT
-        {return allocator_type(__table_.__node_alloc());}
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
+    return allocator_type(__table_.__node_alloc());
+  }
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __table_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT        {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT          {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return __table_.__insert_multi(__x); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, const value_type& __x)
-        {return __table_.__insert_multi(__p.__i_, __x);}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __x) {
+    return __table_.__insert_multi(__p.__i_, __x);
+  }
 
-    template <class _InputIterator>
-    _LIBCPP_INLINE_VISIBILITY
-    void insert(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+    for (auto&& __element : __range) {
+      __table_.__insert_multi(std::forward<decltype(__element)>(__element));
+    }
+  }
+#endif
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    void insert(initializer_list<value_type> __il)
-        {insert(__il.begin(), __il.end());}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));}
+  _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(value_type&& __x) { return __table_.__insert_multi(std::move(__x)); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, value_type&& __x)
-        {return __table_.__insert_multi(__p.__i_, _VSTD::move(__x));}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __x) {
+    return __table_.__insert_multi(__p.__i_, std::move(__x));
+  }
 
-    template <class _Pp,
-              class = __enable_if_t<is_constructible<value_type, _Pp>::value> >
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(_Pp&& __x)
-        {return __table_.__insert_multi(_VSTD::forward<_Pp>(__x));}
+  template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert(_Pp&& __x) {
+    return __table_.__insert_multi(std::forward<_Pp>(__x));
+  }
 
-    template <class _Pp,
-              class = __enable_if_t<is_constructible<value_type, _Pp>::value> >
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, _Pp&& __x)
-        {return __table_.__insert_multi(__p.__i_, _VSTD::forward<_Pp>(__x));}
+  template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _Pp&& __x) {
+    return __table_.__insert_multi(__p.__i_, std::forward<_Pp>(__x));
+  }
 
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) {
-        return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) {
+    return __table_.__emplace_multi(std::forward<_Args>(__args)...);
+  }
 
-    template <class... _Args>
-    _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {
-        return __table_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_Args>(__args)...);
-    }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {
+    return __table_.__emplace_hint_multi(__p.__i_, std::forward<_Args>(__args)...);
+  }
 #endif // _LIBCPP_CXX03_LANG
 
-
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(iterator __p)       {return __table_.erase(__p.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __first, const_iterator __last)
-        {return __table_.erase(__first.__i_, __last.__i_);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__table_.clear();}
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p) { return __table_.erase(__p.__i_); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(iterator __p) { return __table_.erase(__p.__i_); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __table_.__erase_multi(__k); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
+    return __table_.erase(__first.__i_, __last.__i_);
+  }
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __table_.clear(); }
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to unordered_multimap::insert()");
-        return __table_.template __node_handle_insert_multi<node_type>(
-            _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __hint, node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to unordered_multimap::insert()");
-        return __table_.template __node_handle_insert_multi<node_type>(
-            __hint.__i_, _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(key_type const& __key)
-    {
-        return __table_.template __node_handle_extract<node_type>(__key);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(const_iterator __it)
-    {
-        return __table_.template __node_handle_extract<node_type>(
-            __it.__i_);
-    }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to unordered_multimap::insert()");
+    return __table_.template __node_handle_insert_multi<node_type>(std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to unordered_multimap::insert()");
+    return __table_.template __node_handle_insert_multi<node_type>(__hint.__i_, std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+    return __table_.template __node_handle_extract<node_type>(__key);
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+    return __table_.template __node_handle_extract<node_type>(__it.__i_);
+  }
 
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_multi(__source.__table_);
-    }
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_multi(__source.__table_);
-    }
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_multi(__source.__table_);
-    }
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_multi(__source.__table_);
-    }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_multi(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_multimap<key_type, mapped_type, _H2, _P2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_multi(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_multi(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_map<key_type, mapped_type, _H2, _P2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_multi(__source.__table_);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_multimap& __u)
-        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
-        {__table_.swap(__u.__table_);}
+  _LIBCPP_HIDE_FROM_ABI void swap(unordered_multimap& __u) _NOEXCEPT_(__is_nothrow_swappable_v<__table>) {
+    __table_.swap(__u.__table_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    hasher hash_function() const
-        {return __table_.hash_function().hash_function();}
-    _LIBCPP_INLINE_VISIBILITY
-    key_equal key_eq() const
-        {return __table_.key_eq().key_eq();}
+  _LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function().hash_function(); }
+  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq().key_eq(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       find(const key_type& __k)       {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const key_type& __k) const {return __table_.find(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
 #if _LIBCPP_STD_VER >= 20
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       find(const _K2& __k)            {return __table_.find(__k);}
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const _K2& __k) const      {return __table_.find(__k);}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+    return __table_.find(__k);
+  }
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+    return __table_.find(__k);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_multi(__k); }
 #if _LIBCPP_STD_VER >= 20
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    size_type count(const _K2& __k) const      {return __table_.__count_multi(__k);}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+    return __table_.__count_multi(__k);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const key_type& __k) const {return find(__k) != end();}
+  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
 
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const _K2& __k) const      {return find(__k) != end();}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+    return find(__k) != end();
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, iterator>             equal_range(const key_type& __k)
-        {return __table_.__equal_range_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
-        {return __table_.__equal_range_multi(__k);}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __table_.__equal_range_multi(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __table_.__equal_range_multi(__k);
+  }
 #if _LIBCPP_STD_VER >= 20
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, iterator>             equal_range(const _K2& __k)
-        {return __table_.__equal_range_multi(__k);}
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
-        {return __table_.__equal_range_multi(__k);}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+    return __table_.__equal_range_multi(__k);
+  }
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+    return __table_.__equal_range_multi(__k);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const _NOEXCEPT
-        {return __table_.max_bucket_count();}
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return __table_.max_bucket_count(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_size(size_type __n) const
-        {return __table_.bucket_size(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    local_iterator       begin(size_type __n)        {return __table_.begin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    local_iterator       end(size_type __n)          {return __table_.end(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator begin(size_type __n) const  {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator end(size_type __n) const    {return __table_.cend(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
-    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
-    void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
-    _LIBCPP_INLINE_VISIBILITY
-    void rehash(size_type __n) {__table_.__rehash_multi(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    void reserve(size_type __n) {__table_.__reserve_multi(__n);}
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-    _LIBCPP_HIDE_FROM_ABI bool __dereferenceable(const const_iterator* __i) const
-        {return __table_.__dereferenceable(_VSTD::addressof(__i->__i_));}
-    _LIBCPP_HIDE_FROM_ABI bool __decrementable(const const_iterator* __i) const
-        {return __table_.__decrementable(_VSTD::addressof(__i->__i_));}
-    _LIBCPP_HIDE_FROM_ABI bool __addable(const const_iterator* __i, ptrdiff_t __n) const
-        {return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
-    _LIBCPP_HIDE_FROM_ABI bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
-        {return __table_.__addable(_VSTD::addressof(__i->__i_), __n);}
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const { return __table_.bucket_size(__n); }
+  _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
 
+  _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
+  _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const { return __table_.cbegin(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const { return __table_.cbegin(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
 
+  _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
+  _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
+  _LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) { __table_.max_load_factor(__mlf); }
+  _LIBCPP_HIDE_FROM_ABI void rehash(size_type __n) { __table_.__rehash_multi(__n); }
+  _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n) { __table_.__reserve_multi(__n); }
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Hash = hash<__iter_key_type<_InputIterator>>,
-         class _Pred = equal_to<__iter_key_type<_InputIterator>>,
-         class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<!__is_allocator<_Pred>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0,
-                   _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
-  -> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Hash, _Pred, _Allocator>;
+template <class _InputIterator,
+          class _Hash      = hash<__iter_key_type<_InputIterator>>,
+          class _Pred      = equal_to<__iter_key_type<_InputIterator>>,
+          class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
+          class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(_InputIterator,
+                   _InputIterator,
+                   typename allocator_traits<_Allocator>::size_type = 0,
+                   _Hash                                            = _Hash(),
+                   _Pred                                            = _Pred(),
+                   _Allocator                                       = _Allocator())
+    -> unordered_multimap<__iter_key_type<_InputIterator>,
+                          __iter_mapped_type<_InputIterator>,
+                          _Hash,
+                          _Pred,
+                          _Allocator>;
 
-template<class _Key, class _Tp, class _Hash = hash<remove_const_t<_Key>>,
-         class _Pred = equal_to<remove_const_t<_Key>>,
-         class _Allocator = allocator<pair<const _Key, _Tp>>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<!__is_allocator<_Pred>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type = 0,
-                   _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
-  -> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash, _Pred, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Hash      = hash<__range_key_type<_Range>>,
+          class _Pred      = equal_to<__range_key_type<_Range>>,
+          class _Allocator = allocator<__range_to_alloc_type<_Range>>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(from_range_t,
+                   _Range&&,
+                   typename allocator_traits<_Allocator>::size_type = 0,
+                   _Hash                                            = _Hash(),
+                   _Pred                                            = _Pred(),
+                   _Allocator                                       = _Allocator())
+    -> unordered_multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, _Hash, _Pred, _Allocator>;
+#  endif
 
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Key,
+          class _Tp,
+          class _Hash      = hash<remove_const_t<_Key>>,
+          class _Pred      = equal_to<remove_const_t<_Key>>,
+          class _Allocator = allocator<pair<const _Key, _Tp>>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(
+    initializer_list<pair<_Key, _Tp>>,
+    typename allocator_traits<_Allocator>::size_type = 0,
+    _Hash                                            = _Hash(),
+    _Pred                                            = _Pred(),
+    _Allocator = _Allocator()) -> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash, _Pred, _Allocator>;
+
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
-  -> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
-                        hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+    -> unordered_multimap<__iter_key_type<_InputIterator>,
+                          __iter_mapped_type<_InputIterator>,
+                          hash<__iter_key_type<_InputIterator>>,
+                          equal_to<__iter_key_type<_InputIterator>>,
+                          _Allocator>;
 
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_multimap(_InputIterator, _InputIterator, _Allocator)
-  -> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
-                        hash<__iter_key_type<_InputIterator>>, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+    -> unordered_multimap<__iter_key_type<_InputIterator>,
+                          __iter_mapped_type<_InputIterator>,
+                          hash<__iter_key_type<_InputIterator>>,
+                          equal_to<__iter_key_type<_InputIterator>>,
+                          _Allocator>;
 
-template<class _InputIterator, class _Hash, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _InputIterator,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
-  -> unordered_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>,
-                        _Hash, equal_to<__iter_key_type<_InputIterator>>, _Allocator>;
+    -> unordered_multimap<__iter_key_type<_InputIterator>,
+                          __iter_mapped_type<_InputIterator>,
+                          _Hash,
+                          equal_to<__iter_key_type<_InputIterator>>,
+                          _Allocator>;
 
-template<class _Key, class _Tp, class _Allocator,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+#  if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
+    -> unordered_multimap<__range_key_type<_Range>,
+                          __range_mapped_type<_Range>,
+                          hash<__range_key_type<_Range>>,
+                          equal_to<__range_key_type<_Range>>,
+                          _Allocator>;
+
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(from_range_t, _Range&&, _Allocator)
+    -> unordered_multimap<__range_key_type<_Range>,
+                          __range_mapped_type<_Range>,
+                          hash<__range_key_type<_Range>>,
+                          equal_to<__range_key_type<_Range>>,
+                          _Allocator>;
+
+template <ranges::input_range _Range,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+    -> unordered_multimap<__range_key_type<_Range>,
+                          __range_mapped_type<_Range>,
+                          _Hash,
+                          equal_to<__range_key_type<_Range>>,
+                          _Allocator>;
+
+#  endif
+
+template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
-  -> unordered_multimap<remove_const_t<_Key>, _Tp,
-                        hash<remove_const_t<_Key>>,
-                        equal_to<remove_const_t<_Key>>, _Allocator>;
+    -> unordered_multimap<remove_const_t<_Key>,
+                          _Tp,
+                          hash<remove_const_t<_Key>>,
+                          equal_to<remove_const_t<_Key>>,
+                          _Allocator>;
 
-template<class _Key, class _Tp, class _Allocator,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
 unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
-  -> unordered_multimap<remove_const_t<_Key>, _Tp,
-                        hash<remove_const_t<_Key>>,
-                        equal_to<remove_const_t<_Key>>, _Allocator>;
+    -> unordered_multimap<remove_const_t<_Key>,
+                          _Tp,
+                          hash<remove_const_t<_Key>>,
+                          equal_to<remove_const_t<_Key>>,
+                          _Allocator>;
 
-template<class _Key, class _Tp, class _Hash, class _Allocator,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
-  -> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash,
-                        equal_to<remove_const_t<_Key>>, _Allocator>;
+template <class _Key,
+          class _Tp,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multimap(
+    initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+    -> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash, equal_to<remove_const_t<_Key>>, _Allocator>;
 #endif
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        size_type __n, const hasher& __hf, const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
+    size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_multi(__n);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        size_type __n, const hasher& __hf, const key_equal& __eql,
-        const allocator_type& __a)
-    : __table_(__hf, __eql, typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
+    size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, typename __table::allocator_type(__a)) {
+  __table_.__rehash_multi(__n);
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(_InputIterator __first, _InputIterator __last) {
+  insert(__first, __last);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        _InputIterator __first, _InputIterator __last)
-{
-    _VSTD::__debug_db_insert_c(this);
-    insert(__first, __last);
+    _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_multi(__n);
+  insert(__first, __last);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        _InputIterator __first, _InputIterator __last, size_type __n,
-        const hasher& __hf, const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
-    insert(__first, __last);
+    _InputIterator __first,
+    _InputIterator __last,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, typename __table::allocator_type(__a)) {
+  __table_.__rehash_multi(__n);
+  insert(__first, __last);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-template <class _InputIterator>
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        _InputIterator __first, _InputIterator __last, size_type __n,
-        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
-    : __table_(__hf, __eql, typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
-    insert(__first, __last);
-}
+inline unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(const allocator_type& __a)
+    : __table_(typename __table::allocator_type(__a)) {}
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        const allocator_type& __a)
-    : __table_(typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
+unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(const unordered_multimap& __u)
+    : __table_(__u.__table_) {
+  __table_.__rehash_multi(__u.bucket_count());
+  insert(__u.begin(), __u.end());
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        const unordered_multimap& __u)
-    : __table_(__u.__table_)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__u.bucket_count());
-    insert(__u.begin(), __u.end());
-}
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        const unordered_multimap& __u, const allocator_type& __a)
-    : __table_(__u.__table_, typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__u.bucket_count());
-    insert(__u.begin(), __u.end());
+    const unordered_multimap& __u, const allocator_type& __a)
+    : __table_(__u.__table_, typename __table::allocator_type(__a)) {
+  __table_.__rehash_multi(__u.bucket_count());
+  insert(__u.begin(), __u.end());
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        unordered_multimap&& __u)
+inline unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(unordered_multimap&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(_VSTD::move(__u.__table_))
-{
-    _VSTD::__debug_db_insert_c(this);
-    std::__debug_db_swap(this, std::addressof(__u));
-}
+    : __table_(std::move(__u.__table_)) {}
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        unordered_multimap&& __u, const allocator_type& __a)
-    : __table_(_VSTD::move(__u.__table_), typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
-    if (__a != __u.get_allocator())
-    {
-        iterator __i = __u.begin();
-        while (__u.size() != 0)
-        {
-            __table_.__insert_multi(
-                __u.__table_.remove((__i++).__i_)->__value_.__move());
-        }
+    unordered_multimap&& __u, const allocator_type& __a)
+    : __table_(std::move(__u.__table_), typename __table::allocator_type(__a)) {
+  if (__a != __u.get_allocator()) {
+    iterator __i = __u.begin();
+    while (__u.size() != 0) {
+      __table_.__insert_multi(__u.__table_.remove((__i++).__i_)->__get_value().__move());
     }
-    else
-        std::__debug_db_swap(this, std::addressof(__u));
+  }
+}
+
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(initializer_list<value_type> __il) {
+  insert(__il.begin(), __il.end());
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        initializer_list<value_type> __il)
-{
-    _VSTD::__debug_db_insert_c(this);
-    insert(__il.begin(), __il.end());
+    initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_multi(__n);
+  insert(__il.begin(), __il.end());
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
-        const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
-    insert(__il.begin(), __il.end());
+    initializer_list<value_type> __il,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, typename __table::allocator_type(__a)) {
+  __table_.__rehash_multi(__n);
+  insert(__il.begin(), __il.end());
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
-        const key_equal& __eql, const allocator_type& __a)
-    : __table_(__hf, __eql, typename __table::allocator_type(__a))
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
-    insert(__il.begin(), __il.end());
-}
-
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
+inline unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multimap&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
-{
-    __table_ = _VSTD::move(__u.__table_);
-    return *this;
+    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) {
+  __table_ = std::move(__u.__table_);
+  return *this;
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
-        initializer_list<value_type> __il)
-{
-    __table_.__assign_multi(__il.begin(), __il.end());
-    return *this;
+inline unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
+unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(initializer_list<value_type> __il) {
+  __table_.__assign_multi(__il.begin(), __il.end());
+  return *this;
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
-
-
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline
-void
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
-                                                            _InputIterator __last)
-{
-    for (; __first != __last; ++__first)
-        __table_.__insert_multi(*__first);
+inline void unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last) {
+  for (; __first != __last; ++__first)
+    __table_.__insert_multi(*__first);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
-     unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
-          class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-    typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
-    erase_if(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __c,
-             _Predicate __pred) {
-  return _VSTD::__libcpp_erase_if_container(__c, __pred);
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc, class _Predicate>
+inline _LIBCPP_HIDE_FROM_ABI typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::size_type
+erase_if(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __c, _Predicate __pred) {
+  return std::__libcpp_erase_if_container(__c, __pred);
 }
 #endif
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-_LIBCPP_HIDE_FROM_ABI bool
-operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
-           const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
-{
-    if (__x.size() != __y.size())
-        return false;
-    typedef typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator
-                                                                 const_iterator;
-    typedef pair<const_iterator, const_iterator> _EqRng;
-    for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;)
-    {
-        _EqRng __xeq = __x.equal_range(__i->first);
-        _EqRng __yeq = __y.equal_range(__i->first);
-        if (_VSTD::distance(__xeq.first, __xeq.second) !=
-            _VSTD::distance(__yeq.first, __yeq.second) ||
-                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
-            return false;
-        __i = __xeq.second;
-    }
-    return true;
+_LIBCPP_HIDE_FROM_ABI bool operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+                                      const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) {
+  if (__x.size() != __y.size())
+    return false;
+  typedef typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::const_iterator const_iterator;
+  typedef pair<const_iterator, const_iterator> _EqRng;
+  for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;) {
+    _EqRng __xeq = __x.equal_range(__i->first);
+    _EqRng __yeq = __y.equal_range(__i->first);
+    if (std::distance(__xeq.first, __xeq.second) != std::distance(__yeq.first, __yeq.second) ||
+        !std::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+      return false;
+    __i = __xeq.second;
+  }
+  return true;
 }
 
+#if _LIBCPP_STD_VER <= 17
+
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
-           const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
+                                             const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) {
+  return !(__x == __y);
 }
 
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _KeyT, class _ValueT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
-using unordered_map =
+using unordered_map _LIBCPP_AVAILABILITY_PMR =
     std::unordered_map<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 
 template <class _KeyT, class _ValueT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
-using unordered_multimap =
+using unordered_multimap _LIBCPP_AVAILABILITY_PMR =
     std::unordered_multimap<_KeyT, _ValueT, _HashT, _PredT, polymorphic_allocator<std::pair<const _KeyT, _ValueT>>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <algorithm>
 #  include <bit>
diff --git a/third_party/libcxx/unordered_set b/third_party/libcxx/unordered_set
index 413fb0934..3297294a8 100644
--- a/third_party/libcxx/unordered_set
+++ b/third_party/libcxx/unordered_set
@@ -10,6 +10,8 @@
 #ifndef _LIBCPP_UNORDERED_SET
 #define _LIBCPP_UNORDERED_SET
 
+// clang-format off
+
 /*
 
     unordered_set synopsis
@@ -58,6 +60,10 @@ public:
                       size_type n = 0, const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
+    template<container-compatible-range<value_type> R>
+      unordered_set(from_range_t, R&& rg, size_type n = see below,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type()); // C++23
     explicit unordered_set(const allocator_type&);
     unordered_set(const unordered_set&);
     unordered_set(const unordered_set&, const Allocator&);
@@ -77,6 +83,12 @@ public:
     template <class InputIterator>
       unordered_set(InputIterator f, InputIterator l, size_type n,
                     const hasher& hf,  const allocator_type& a); // C++14
+    template<container-compatible-range<value_type> R>
+      unordered_set(from_range_t, R&& rg, size_type n, const allocator_type& a)
+        : unordered_set(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+    template<container-compatible-range<value_type> R>
+      unordered_set(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+        : unordered_set(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
     unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
     unordered_set(initializer_list<value_type> il, size_type n,
                   const hasher& hf,  const allocator_type& a); // C++14
@@ -113,6 +125,8 @@ public:
     iterator insert(const_iterator hint, value_type&& obj);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                                      // C++23
     void insert(initializer_list<value_type>);
 
     node_type extract(const_iterator position);                       // C++17
@@ -191,6 +205,13 @@ unordered_set(InputIterator, InputIterator, typename see below::size_type = see
   -> unordered_set<typename iterator_traits<InputIterator>::value_type,
         Hash, Pred, Allocator>; // C++17
 
+template<ranges::input_range R,
+         class Hash = hash<ranges::range_value_t<R>>,
+         class Pred = equal_to<ranges::range_value_t<R>>,
+         class Allocator = allocator<ranges::range_value_t<R>>>
+  unordered_set(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+    -> unordered_set<ranges::range_value_t<R>, Hash, Pred, Allocator>; // C++23
+
 template<class T, class Hash = hash<T>,
           class Pred = equal_to<T>, class Allocator = allocator<T>>
 unordered_set(initializer_list<T>, typename see below::size_type = see below,
@@ -211,6 +232,21 @@ unordered_set(InputIterator, InputIterator, typename see below::size_type,
         equal_to<typename iterator_traits<InputIterator>::value_type>,
         Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  unordered_set(from_range_t, R&&, typename see below::size_type, Allocator)
+    -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
+template<ranges::input_range R, class Allocator>
+  unordered_set(from_range_t, R&&, Allocator)
+    -> unordered_set<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
+template<ranges::input_range R, class Hash, class Allocator>
+  unordered_set(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+    -> unordered_set<ranges::range_value_t<R>, Hash,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
 template<class T, class Allocator>
 unordered_set(initializer_list<T>, typename see below::size_type, Allocator)
   -> unordered_set<T, hash<T>, equal_to<T>, Allocator>; // C++17
@@ -232,7 +268,7 @@ template <class Value, class Hash, class Pred, class Alloc>
 template <class Value, class Hash, class Pred, class Alloc>
     bool
     operator!=(const unordered_set<Value, Hash, Pred, Alloc>& x,
-               const unordered_set<Value, Hash, Pred, Alloc>& y);
+               const unordered_set<Value, Hash, Pred, Alloc>& y); // removed in C++20
 
 template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
           class Alloc = allocator<Value>>
@@ -272,6 +308,10 @@ public:
                       size_type n = 0, const hasher& hf = hasher(),
                       const key_equal& eql = key_equal(),
                       const allocator_type& a = allocator_type());
+    template<container-compatible-range<value_type> R>
+      unordered_multiset(from_range_t, R&& rg, size_type n = see below,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type()); // C++23
     explicit unordered_multiset(const allocator_type&);
     unordered_multiset(const unordered_multiset&);
     unordered_multiset(const unordered_multiset&, const Allocator&);
@@ -291,6 +331,12 @@ public:
     template <class InputIterator>
       unordered_multiset(InputIterator f, InputIterator l, size_type n,
                          const hasher& hf, const allocator_type& a); // C++14
+    template<container-compatible-range<value_type> R>
+      unordered_multiset(from_range_t, R&& rg, size_type n, const allocator_type& a)
+        : unordered_multiset(from_range, std::forward<R>(rg), n, hasher(), key_equal(), a) { } // C++23
+    template<container-compatible-range<value_type> R>
+      unordered_multiset(from_range_t, R&& rg, size_type n, const hasher& hf, const allocator_type& a)
+        : unordered_multiset(from_range, std::forward<R>(rg), n, hf, key_equal(), a) { }       // C++23
     unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
     unordered_multiset(initializer_list<value_type> il, size_type n,
                        const hasher& hf,  const allocator_type& a); // C++14
@@ -327,6 +373,8 @@ public:
     iterator insert(const_iterator hint, value_type&& obj);
     template <class InputIterator>
         void insert(InputIterator first, InputIterator last);
+    template<container-compatible-range<value_type> R>
+      void insert_range(R&& rg);                            // C++23
     void insert(initializer_list<value_type>);
 
     node_type extract(const_iterator position);             // C++17
@@ -405,6 +453,13 @@ unordered_multiset(InputIterator, InputIterator, see below::size_type = see belo
   -> unordered_multiset<typename iterator_traits<InputIterator>::value_type,
         Hash, Pred, Allocator>; // C++17
 
+template<ranges::input_range R,
+         class Hash = hash<ranges::range_value_t<R>>,
+         class Pred = equal_to<ranges::range_value_t<R>>,
+         class Allocator = allocator<ranges::range_value_t<R>>>
+  unordered_multiset(from_range_t, R&&, typename see below::size_type = see below, Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+    -> unordered_multiset<ranges::range_value_t<R>, Hash, Pred, Allocator>; // C++23
+
 template<class T, class Hash = hash<T>,
           class Pred = equal_to<T>, class Allocator = allocator<T>>
 unordered_multiset(initializer_list<T>, typename see below::size_type = see below,
@@ -424,6 +479,21 @@ unordered_multiset(InputIterator, InputIterator, typename see below::size_type,
   -> unordered_multiset<typename iterator_traits<InputIterator>::value_type, Hash,
         equal_to<typename iterator_traits<InputIterator>::value_type>, Allocator>; // C++17
 
+template<ranges::input_range R, class Allocator>
+  unordered_multiset(from_range_t, R&&, typename see below::size_type, Allocator)
+    -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
+template<ranges::input_range R, class Allocator>
+  unordered_multiset(from_range_t, R&&, Allocator)
+    -> unordered_multiset<ranges::range_value_t<R>, hash<ranges::range_value_t<R>>,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
+template<ranges::input_range R, class Hash, class Allocator>
+  unordered_multiset(from_range_t, R&&, typename see below::size_type, Hash, Allocator)
+    -> unordered_multiset<ranges::range_value_t<R>, Hash,
+                      equal_to<ranges::range_value_t<R>>, Allocator>; // C++23
+
 template<class T, class Allocator>
 unordered_multiset(initializer_list<T>, typename see below::size_type, Allocator)
   -> unordered_multiset<T, hash<T>, equal_to<T>, Allocator>; // C++17
@@ -454,25 +524,30 @@ template <class Value, class Hash, class Pred, class Alloc>
 template <class Value, class Hash, class Pred, class Alloc>
     bool
     operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x,
-               const unordered_multiset<Value, Hash, Pred, Alloc>& y);
+               const unordered_multiset<Value, Hash, Pred, Alloc>& y); // removed in C++20
 }  // std
 
 */
 
+// clang-format on
+
 #include <__algorithm/is_permutation.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
-#include <__debug>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__hash_table>
 #include <__iterator/distance.h>
 #include <__iterator/erase_if_container.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/ranges_iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator.h>
 #include <__memory_resource/polymorphic_allocator.h>
 #include <__node_handle>
+#include <__ranges/concepts.h>
+#include <__ranges/container_compatible_range.h>
+#include <__ranges/from_range.h>
 #include <__type_traits/is_allocator.h>
 #include <__utility/forward.h>
 #include <version>
@@ -494,1332 +569,1242 @@ template <class Value, class Hash, class Pred, class Alloc>
 #  pragma GCC system_header
 #endif
 
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 class unordered_multiset;
 
-template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
-          class _Alloc = allocator<_Value> >
-class _LIBCPP_TEMPLATE_VIS unordered_set
-{
+template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> >
+class _LIBCPP_TEMPLATE_VIS unordered_set {
 public:
-    // types
-    typedef _Value                                                     key_type;
-    typedef key_type                                                   value_type;
-    typedef __type_identity_t<_Hash>                                   hasher;
-    typedef __type_identity_t<_Pred>                                   key_equal;
-    typedef __type_identity_t<_Alloc>                                  allocator_type;
-    typedef value_type&                                                reference;
-    typedef const value_type&                                          const_reference;
-    static_assert((is_same<value_type, typename allocator_type::value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
-
-    static_assert(is_same<allocator_type, __rebind_alloc<allocator_traits<allocator_type>, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
-
-  private:
-    typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
-
-    __table __table_;
-
-public:
-    typedef typename __table::pointer         pointer;
-    typedef typename __table::const_pointer   const_pointer;
-    typedef typename __table::size_type       size_type;
-    typedef typename __table::difference_type difference_type;
-
-    typedef typename __table::const_iterator       iterator;
-    typedef typename __table::const_iterator       const_iterator;
-    typedef typename __table::const_local_iterator local_iterator;
-    typedef typename __table::const_local_iterator const_local_iterator;
-
-#if _LIBCPP_STD_VER >= 17
-    typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
-    typedef __insert_return_type<iterator, node_type> insert_return_type;
-#endif
-
-    template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_set;
-    template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_multiset;
-
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_set()
-        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
-    {
-        _VSTD::__debug_db_insert_c(this);
-    }
-    explicit _LIBCPP_HIDE_FROM_ABI unordered_set(size_type __n, const hasher& __hf = hasher(),
-                           const key_equal& __eql = key_equal());
-#if _LIBCPP_STD_VER >= 14
-    inline _LIBCPP_INLINE_VISIBILITY
-    unordered_set(size_type __n, const allocator_type& __a)
-        : unordered_set(__n, hasher(), key_equal(), __a) {}
-    inline _LIBCPP_INLINE_VISIBILITY
-    unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a)
-        : unordered_set(__n, __hf, key_equal(), __a) {}
-#endif
-    _LIBCPP_HIDE_FROM_ABI unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql,
-                  const allocator_type& __a);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_set(_InputIterator __first, _InputIterator __last);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_set(_InputIterator __first, _InputIterator __last,
-                      size_type __n, const hasher& __hf = hasher(),
-                      const key_equal& __eql = key_equal());
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_set(_InputIterator __first, _InputIterator __last,
-                      size_type __n, const hasher& __hf, const key_equal& __eql,
-                      const allocator_type& __a);
-#if _LIBCPP_STD_VER >= 14
-    template <class _InputIterator>
-    inline _LIBCPP_INLINE_VISIBILITY
-        unordered_set(_InputIterator __first, _InputIterator __last,
-                    size_type __n, const allocator_type& __a)
-            : unordered_set(__first, __last, __n, hasher(), key_equal(), __a) {}
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_set(_InputIterator __first, _InputIterator __last,
-                      size_type __n, const hasher& __hf, const allocator_type& __a)
-            : unordered_set(__first, __last, __n, __hf, key_equal(), __a) {}
-#endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit unordered_set(const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI unordered_set(const unordered_set& __u);
-    _LIBCPP_HIDE_FROM_ABI unordered_set(const unordered_set& __u, const allocator_type& __a);
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_set(unordered_set&& __u)
-        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
-    _LIBCPP_HIDE_FROM_ABI unordered_set(unordered_set&& __u, const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI unordered_set(initializer_list<value_type> __il);
-    _LIBCPP_HIDE_FROM_ABI unordered_set(initializer_list<value_type> __il, size_type __n,
-                  const hasher& __hf = hasher(),
-                  const key_equal& __eql = key_equal());
-    _LIBCPP_HIDE_FROM_ABI unordered_set(initializer_list<value_type> __il, size_type __n,
-                  const hasher& __hf, const key_equal& __eql,
-                  const allocator_type& __a);
-#if _LIBCPP_STD_VER >= 14
-    inline _LIBCPP_INLINE_VISIBILITY
-    unordered_set(initializer_list<value_type> __il, size_type __n,
-                                                      const allocator_type& __a)
-        : unordered_set(__il, __n, hasher(), key_equal(), __a) {}
-    inline _LIBCPP_INLINE_VISIBILITY
-    unordered_set(initializer_list<value_type> __il, size_type __n,
-                                  const hasher& __hf, const allocator_type& __a)
-        : unordered_set(__il, __n, __hf, key_equal(), __a) {}
-#endif
-#endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    ~unordered_set() {
-        static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_set& operator=(const unordered_set& __u)
-    {
-        __table_ = __u.__table_;
-        return *this;
-    }
-#ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_set& operator=(unordered_set&& __u)
-        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_set& operator=(initializer_list<value_type> __il);
-#endif // _LIBCPP_CXX03_LANG
-
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT
-        {return allocator_type(__table_.__node_alloc());}
-
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT        {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT          {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
-
-#ifndef _LIBCPP_CXX03_LANG
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        pair<iterator, bool> emplace(_Args&&... __args)
-            {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
-    template <class... _Args>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator emplace_hint(const_iterator __p, _Args&&... __args) {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__p)) == this,
-            "unordered_set::emplace_hint(const_iterator, args...) called with an iterator not"
-            " referring to this unordered_set");
-        (void)__p;
-        return __table_.__emplace_unique(std::forward<_Args>(__args)...).first;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> insert(value_type&& __x)
-        {return __table_.__insert_unique(_VSTD::move(__x));}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, value_type&& __x) {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__p)) == this,
-            "unordered_set::insert(const_iterator, value_type&&) called with an iterator not"
-            " referring to this unordered_set");
-        (void)__p;
-        return insert(std::move(__x)).first;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void insert(initializer_list<value_type> __il)
-        {insert(__il.begin(), __il.end());}
-#endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, bool> insert(const value_type& __x)
-        {return __table_.__insert_unique(__x);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, const value_type& __x) {
-        _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__p)) == this,
-            "unordered_set::insert(const_iterator, const value_type&) called with an iterator not"
-            " referring to this unordered_set");
-        (void)__p;
-        return insert(__x).first;
-    }
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        void insert(_InputIterator __first, _InputIterator __last);
-
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __p) {return __table_.erase(__p);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __first, const_iterator __last)
-        {return __table_.erase(__first, __last);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__table_.clear();}
-
-#if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
-    insert_return_type insert(node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to unordered_set::insert()");
-        return __table_.template __node_handle_insert_unique<
-            node_type, insert_return_type>(_VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __h, node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to unordered_set::insert()");
-        return __table_.template __node_handle_insert_unique<node_type>(
-            __h, _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(key_type const& __key)
-    {
-        return __table_.template __node_handle_extract<node_type>(__key);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(const_iterator __it)
-    {
-        return __table_.template __node_handle_extract<node_type>(__it);
-    }
-
-    template<class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_set<key_type, _H2, _P2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __table_.__node_handle_merge_unique(__source.__table_);
-    }
-    template<class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_set<key_type, _H2, _P2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __table_.__node_handle_merge_unique(__source.__table_);
-    }
-    template<class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __table_.__node_handle_merge_unique(__source.__table_);
-    }
-    template<class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        __table_.__node_handle_merge_unique(__source.__table_);
-    }
-#endif
-
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_set& __u)
-        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
-        {__table_.swap(__u.__table_);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    hasher hash_function() const {return __table_.hash_function();}
-    _LIBCPP_INLINE_VISIBILITY
-    key_equal key_eq() const {return __table_.key_eq();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       find(const key_type& __k)       {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const key_type& __k) const {return __table_.find(__k);}
-#if _LIBCPP_STD_VER >= 20
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       find(const _K2& __k)            {return __table_.find(__k);}
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const _K2& __k) const      {return __table_.find(__k);}
-#endif // _LIBCPP_STD_VER >= 20
-
-    _LIBCPP_INLINE_VISIBILITY
-    size_type count(const key_type& __k) const {return __table_.__count_unique(__k);}
-#if _LIBCPP_STD_VER >= 20
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    size_type count(const _K2& __k) const      {return __table_.__count_unique(__k);}
-#endif // _LIBCPP_STD_VER >= 20
-
-#if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const key_type& __k) const {return find(__k) != end();}
-
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const _K2& __k) const      {return find(__k) != end();}
-#endif // _LIBCPP_STD_VER >= 20
-
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, iterator>             equal_range(const key_type& __k)
-        {return __table_.__equal_range_unique(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
-        {return __table_.__equal_range_unique(__k);}
-#if _LIBCPP_STD_VER >= 20
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, iterator>             equal_range(const _K2& __k)
-        {return __table_.__equal_range_unique(__k);}
-    template <class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
-        {return __table_.__equal_range_unique(__k);}
-#endif // _LIBCPP_STD_VER >= 20
-
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    local_iterator       begin(size_type __n)        {return __table_.begin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    local_iterator       end(size_type __n)          {return __table_.end(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator begin(size_type __n) const  {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator end(size_type __n) const    {return __table_.cend(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
-    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
-    void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
-    _LIBCPP_INLINE_VISIBILITY
-    void rehash(size_type __n) {__table_.__rehash_unique(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    void reserve(size_type __n) {__table_.__reserve_unique(__n);}
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-    _LIBCPP_HIDE_FROM_ABI bool __dereferenceable(const const_iterator* __i) const
-        {return __table_.__dereferenceable(__i);}
-    _LIBCPP_HIDE_FROM_ABI bool __decrementable(const const_iterator* __i) const
-        {return __table_.__decrementable(__i);}
-    _LIBCPP_HIDE_FROM_ABI bool __addable(const const_iterator* __i, ptrdiff_t __n) const
-        {return __table_.__addable(__i, __n);}
-    _LIBCPP_HIDE_FROM_ABI bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
-        {return __table_.__addable(__i, __n);}
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
-
-};
-
-#if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Hash = hash<__iter_value_type<_InputIterator>>,
-         class _Pred = equal_to<__iter_value_type<_InputIterator>>,
-         class _Allocator = allocator<__iter_value_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<!__is_allocator<_Pred>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_set(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0,
-              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
-  -> unordered_set<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
-
-template<class _Tp, class _Hash = hash<_Tp>,
-         class _Pred = equal_to<_Tp>,
-         class _Allocator = allocator<_Tp>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<!__is_allocator<_Pred>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type = 0,
-              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
-  -> unordered_set<_Tp, _Hash, _Pred, _Allocator>;
-
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_set(_InputIterator, _InputIterator,
-              typename allocator_traits<_Allocator>::size_type, _Allocator)
-  -> unordered_set<__iter_value_type<_InputIterator>,
-                   hash<__iter_value_type<_InputIterator>>,
-                   equal_to<__iter_value_type<_InputIterator>>,
-                   _Allocator>;
-
-template<class _InputIterator, class _Hash, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_set(_InputIterator, _InputIterator,
-              typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
-  -> unordered_set<__iter_value_type<_InputIterator>, _Hash,
-                   equal_to<__iter_value_type<_InputIterator>>,
-                   _Allocator>;
-
-template<class _Tp, class _Allocator,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
-  -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
-
-template<class _Tp, class _Hash, class _Allocator,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
-  -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
-#endif
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n,
-        const hasher& __hf, const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n,
-        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
-    : __table_(__hf, __eql, __a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-template <class _InputIterator>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        _InputIterator __first, _InputIterator __last)
-{
-    _VSTD::__debug_db_insert_c(this);
-    insert(__first, __last);
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-template <class _InputIterator>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        _InputIterator __first, _InputIterator __last, size_type __n,
-        const hasher& __hf, const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
-    insert(__first, __last);
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-template <class _InputIterator>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        _InputIterator __first, _InputIterator __last, size_type __n,
-        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
-    : __table_(__hf, __eql, __a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
-    insert(__first, __last);
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        const allocator_type& __a)
-    : __table_(__a)
-{
-    _VSTD::__debug_db_insert_c(this);
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        const unordered_set& __u)
-    : __table_(__u.__table_)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__u.bucket_count());
-    insert(__u.begin(), __u.end());
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        const unordered_set& __u, const allocator_type& __a)
-    : __table_(__u.__table_, __a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__u.bucket_count());
-    insert(__u.begin(), __u.end());
-}
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        unordered_set&& __u)
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(_VSTD::move(__u.__table_))
-{
-    _VSTD::__debug_db_insert_c(this);
-    std::__debug_db_swap(this, std::addressof(__u));
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        unordered_set&& __u, const allocator_type& __a)
-    : __table_(_VSTD::move(__u.__table_), __a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    if (__a != __u.get_allocator())
-    {
-        iterator __i = __u.begin();
-        while (__u.size() != 0)
-            __table_.__insert_unique(_VSTD::move(__u.__table_.remove(__i++)->__value_));
-    }
-    else
-        std::__debug_db_swap(this, std::addressof(__u));
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        initializer_list<value_type> __il)
-{
-    _VSTD::__debug_db_insert_c(this);
-    insert(__il.begin(), __il.end());
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
-        const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
-    insert(__il.begin(), __il.end());
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
-        const key_equal& __eql, const allocator_type& __a)
-    : __table_(__hf, __eql, __a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_unique(__n);
-    insert(__il.begin(), __il.end());
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_set<_Value, _Hash, _Pred, _Alloc>&
-unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
-{
-    __table_ = _VSTD::move(__u.__table_);
-    return *this;
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_set<_Value, _Hash, _Pred, _Alloc>&
-unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(
-        initializer_list<value_type> __il)
-{
-    __table_.__assign_unique(__il.begin(), __il.end());
-    return *this;
-}
-
-#endif // _LIBCPP_CXX03_LANG
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-template <class _InputIterator>
-inline
-void
-unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
-                                                    _InputIterator __last)
-{
-    for (; __first != __last; ++__first)
-        __table_.__insert_unique(*__first);
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
-     unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
-}
-
-#if _LIBCPP_STD_VER >= 20
-template <class _Value, class _Hash, class _Pred, class _Alloc,
-          class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-    typename unordered_set<_Value, _Hash, _Pred, _Alloc>::size_type
-    erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c,
-             _Predicate __pred) {
-  return _VSTD::__libcpp_erase_if_container(__c, __pred);
-}
-#endif
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-_LIBCPP_HIDE_FROM_ABI bool
-operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
-           const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
-{
-    if (__x.size() != __y.size())
-        return false;
-    typedef typename unordered_set<_Value, _Hash, _Pred, _Alloc>::const_iterator
-                                                                 const_iterator;
-    for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end();
-            __i != __ex; ++__i)
-    {
-        const_iterator __j = __y.find(*__i);
-        if (__j == __ey || !(*__i == *__j))
-            return false;
-    }
-    return true;
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
-           const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
-{
-    return !(__x == __y);
-}
-
-template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
-          class _Alloc = allocator<_Value> >
-class _LIBCPP_TEMPLATE_VIS unordered_multiset
-{
-public:
-    // types
-    typedef _Value                                                     key_type;
-    typedef key_type                                                   value_type;
-    typedef __type_identity_t<_Hash>                                   hasher;
-    typedef __type_identity_t<_Pred>                                   key_equal;
-    typedef __type_identity_t<_Alloc>                                  allocator_type;
-    typedef value_type&                                                reference;
-    typedef const value_type&                                          const_reference;
-    static_assert((is_same<value_type, typename allocator_type::value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
+  // types
+  typedef _Value key_type;
+  typedef key_type value_type;
+  typedef __type_identity_t<_Hash> hasher;
+  typedef __type_identity_t<_Pred> key_equal;
+  typedef __type_identity_t<_Alloc> allocator_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
+  static_assert(is_same<value_type, typename allocator_type::value_type>::value,
+                "Allocator::value_type must be same type as value_type");
 
 private:
-    typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
+  typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
 
-    __table __table_;
+  __table __table_;
 
 public:
-    typedef typename __table::pointer         pointer;
-    typedef typename __table::const_pointer   const_pointer;
-    typedef typename __table::size_type       size_type;
-    typedef typename __table::difference_type difference_type;
+  typedef typename __table::pointer pointer;
+  typedef typename __table::const_pointer const_pointer;
+  typedef typename __table::size_type size_type;
+  typedef typename __table::difference_type difference_type;
 
-    typedef typename __table::const_iterator       iterator;
-    typedef typename __table::const_iterator       const_iterator;
-    typedef typename __table::const_local_iterator local_iterator;
-    typedef typename __table::const_local_iterator const_local_iterator;
+  typedef typename __table::const_iterator iterator;
+  typedef typename __table::const_iterator const_iterator;
+  typedef typename __table::const_local_iterator local_iterator;
+  typedef typename __table::const_local_iterator const_local_iterator;
 
 #if _LIBCPP_STD_VER >= 17
-    typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
+  typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
+  typedef __insert_return_type<iterator, node_type> insert_return_type;
 #endif
 
-    template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_set;
-    template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
-        friend class _LIBCPP_TEMPLATE_VIS unordered_multiset;
+  template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_set;
+  template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_multiset;
 
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset()
-        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
-    {
-        _VSTD::__debug_db_insert_c(this);
+  _LIBCPP_HIDE_FROM_ABI unordered_set() _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) {}
+  explicit _LIBCPP_HIDE_FROM_ABI
+  unordered_set(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
+#if _LIBCPP_STD_VER >= 14
+  inline _LIBCPP_HIDE_FROM_ABI unordered_set(size_type __n, const allocator_type& __a)
+      : unordered_set(__n, hasher(), key_equal(), __a) {}
+  inline _LIBCPP_HIDE_FROM_ABI unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_set(__n, __hf, key_equal(), __a) {}
+#endif
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_set(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_set(_InputIterator __first,
+                _InputIterator __last,
+                size_type __n,
+                const hasher& __hf     = hasher(),
+                const key_equal& __eql = key_equal());
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_set(
+      _InputIterator __first,
+      _InputIterator __last,
+      size_type __n,
+      const hasher& __hf,
+      const key_equal& __eql,
+      const allocator_type& __a);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI unordered_set(
+      from_range_t,
+      _Range&& __range,
+      size_type __n             = /*implementation-defined*/ 0,
+      const hasher& __hf        = hasher(),
+      const key_equal& __eql    = key_equal(),
+      const allocator_type& __a = allocator_type())
+      : __table_(__hf, __eql, __a) {
+    if (__n > 0) {
+      __table_.__rehash_unique(__n);
     }
-    explicit _LIBCPP_HIDE_FROM_ABI unordered_multiset(size_type __n, const hasher& __hf = hasher(),
-                                const key_equal& __eql = key_equal());
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset(size_type __n, const hasher& __hf,
-                       const key_equal& __eql, const allocator_type& __a);
-#if _LIBCPP_STD_VER >= 14
-    inline _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset(size_type __n, const allocator_type& __a)
-        : unordered_multiset(__n, hasher(), key_equal(), __a) {}
-    inline _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a)
-        : unordered_multiset(__n, __hf, key_equal(), __a) {}
+    insert_range(std::forward<_Range>(__range));
+  }
 #endif
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset(_InputIterator __first, _InputIterator __last);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset(_InputIterator __first, _InputIterator __last,
-                      size_type __n, const hasher& __hf = hasher(),
-                      const key_equal& __eql = key_equal());
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset(_InputIterator __first, _InputIterator __last,
-                      size_type __n , const hasher& __hf,
-                      const key_equal& __eql, const allocator_type& __a);
+
 #if _LIBCPP_STD_VER >= 14
-    template <class _InputIterator>
-    inline _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset(_InputIterator __first, _InputIterator __last,
-                       size_type __n, const allocator_type& __a)
-        : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) {}
-    template <class _InputIterator>
-    inline _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset(_InputIterator __first, _InputIterator __last,
-                       size_type __n, const hasher& __hf, const allocator_type& __a)
-        : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) {}
+  template <class _InputIterator>
+  inline _LIBCPP_HIDE_FROM_ABI
+  unordered_set(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
+      : unordered_set(__first, __last, __n, hasher(), key_equal(), __a) {}
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_set(
+      _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_set(__first, __last, __n, __hf, key_equal(), __a) {}
 #endif
-    _LIBCPP_INLINE_VISIBILITY
-    explicit unordered_multiset(const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset(const unordered_multiset& __u);
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI unordered_set(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a)
+      : unordered_set(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {}
+
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_set(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_set(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {}
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI explicit unordered_set(const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI unordered_set(const unordered_set& __u);
+  _LIBCPP_HIDE_FROM_ABI unordered_set(const unordered_set& __u, const allocator_type& __a);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset(unordered_multiset&& __u)
-        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset(initializer_list<value_type> __il);
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset(initializer_list<value_type> __il, size_type __n,
-                       const hasher& __hf = hasher(),
-                       const key_equal& __eql = key_equal());
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset(initializer_list<value_type> __il, size_type __n,
-                       const hasher& __hf, const key_equal& __eql,
-                       const allocator_type& __a);
-#if _LIBCPP_STD_VER >= 14
-    inline _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
-      : unordered_multiset(__il, __n, hasher(), key_equal(), __a) {}
-    inline _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
-      : unordered_multiset(__il, __n, __hf, key_equal(), __a) {}
-#endif
+  _LIBCPP_HIDE_FROM_ABI unordered_set(unordered_set&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+  _LIBCPP_HIDE_FROM_ABI unordered_set(unordered_set&& __u, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI unordered_set(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_set(initializer_list<value_type> __il,
+                size_type __n,
+                const hasher& __hf     = hasher(),
+                const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI unordered_set(
+      initializer_list<value_type> __il,
+      size_type __n,
+      const hasher& __hf,
+      const key_equal& __eql,
+      const allocator_type& __a);
+#  if _LIBCPP_STD_VER >= 14
+  inline _LIBCPP_HIDE_FROM_ABI
+  unordered_set(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
+      : unordered_set(__il, __n, hasher(), key_equal(), __a) {}
+  inline _LIBCPP_HIDE_FROM_ABI
+  unordered_set(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_set(__il, __n, __hf, key_equal(), __a) {}
+#  endif
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    ~unordered_multiset() {
-        static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
-    }
+  _LIBCPP_HIDE_FROM_ABI ~unordered_set() {
+    static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset& operator=(const unordered_multiset& __u)
-    {
-        __table_ = __u.__table_;
-        return *this;
-    }
+  _LIBCPP_HIDE_FROM_ABI unordered_set& operator=(const unordered_set& __u) {
+    __table_ = __u.__table_;
+    return *this;
+  }
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset& operator=(unordered_multiset&& __u)
-        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
-    _LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI unordered_set& operator=(unordered_set&& __u)
+      _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
+  _LIBCPP_HIDE_FROM_ABI unordered_set& operator=(initializer_list<value_type> __il);
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT
-        {return allocator_type(__table_.__node_alloc());}
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
+    return allocator_type(__table_.__node_alloc());
+  }
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT  {return __table_.size();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __table_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT        {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT          {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT {return __table_.end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
 
 #ifndef _LIBCPP_CXX03_LANG
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator emplace(_Args&&... __args)
-            {return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
-    template <class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        iterator emplace_hint(const_iterator __p, _Args&&... __args)
-            {return __table_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> emplace(_Args&&... __args) {
+    return __table_.__emplace_unique(std::forward<_Args>(__args)...);
+  }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator, _Args&&... __args) {
+    return __table_.__emplace_unique(std::forward<_Args>(__args)...).first;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, value_type&& __x)
-        {return __table_.__insert_multi(__p, _VSTD::move(__x));}
-    _LIBCPP_INLINE_VISIBILITY
-    void insert(initializer_list<value_type> __il)
-        {insert(__il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(value_type&& __x) {
+    return __table_.__insert_unique(std::move(__x));
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, value_type&& __x) { return insert(std::move(__x)).first; }
+
+  _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
 #endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __x) { return __table_.__insert_unique(__x); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator, const value_type& __x) { return insert(__x).first; }
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last);
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __p, const value_type& __x)
-        {return __table_.__insert_multi(__p, __x);}
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+    for (auto&& __element : __range) {
+      __table_.__insert_unique(std::forward<decltype(__element)>(__element));
+    }
+  }
+#endif
 
-    template <class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
-        void insert(_InputIterator __first, _InputIterator __last);
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p) { return __table_.erase(__p); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __table_.__erase_unique(__k); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
+    return __table_.erase(__first, __last);
+  }
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __table_.clear(); }
 
 #if _LIBCPP_STD_VER >= 17
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to unordered_multiset::insert()");
-        return __table_.template __node_handle_insert_multi<node_type>(
-            _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator __hint, node_type&& __nh)
-    {
-        _LIBCPP_ASSERT(__nh.empty() || __nh.get_allocator() == get_allocator(),
-            "node_type with incompatible allocator passed to unordered_multiset::insert()");
-        return __table_.template __node_handle_insert_multi<node_type>(
-            __hint, _VSTD::move(__nh));
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(const_iterator __position)
-    {
-        return __table_.template __node_handle_extract<node_type>(
-            __position);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    node_type extract(key_type const& __key)
-    {
-        return __table_.template __node_handle_extract<node_type>(__key);
-    }
+  _LIBCPP_HIDE_FROM_ABI insert_return_type insert(node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to unordered_set::insert()");
+    return __table_.template __node_handle_insert_unique< node_type, insert_return_type>(std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __h, node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to unordered_set::insert()");
+    return __table_.template __node_handle_insert_unique<node_type>(__h, std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+    return __table_.template __node_handle_extract<node_type>(__key);
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+    return __table_.template __node_handle_extract<node_type>(__it);
+  }
 
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_multi(__source.__table_);
-    }
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_multi(__source.__table_);
-    }
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_set<key_type, _H2, _P2, allocator_type>& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_multi(__source.__table_);
-    }
-    template <class _H2, class _P2>
-    _LIBCPP_INLINE_VISIBILITY
-    void merge(unordered_set<key_type, _H2, _P2, allocator_type>&& __source)
-    {
-        _LIBCPP_ASSERT(__source.get_allocator() == get_allocator(),
-                       "merging container with incompatible allocator");
-        return __table_.__node_handle_merge_multi(__source.__table_);
-    }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_set<key_type, _H2, _P2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __table_.__node_handle_merge_unique(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_set<key_type, _H2, _P2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __table_.__node_handle_merge_unique(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __table_.__node_handle_merge_unique(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    __table_.__node_handle_merge_unique(__source.__table_);
+  }
 #endif
 
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __p) {return __table_.erase(__p);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator erase(const_iterator __first, const_iterator __last)
-        {return __table_.erase(__first, __last);}
-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__table_.clear();}
+  _LIBCPP_HIDE_FROM_ABI void swap(unordered_set& __u) _NOEXCEPT_(__is_nothrow_swappable_v<__table>) {
+    __table_.swap(__u.__table_);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_multiset& __u)
-        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
-        {__table_.swap(__u.__table_);}
+  _LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function(); }
+  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    hasher hash_function() const {return __table_.hash_function();}
-    _LIBCPP_INLINE_VISIBILITY
-    key_equal key_eq() const {return __table_.key_eq();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       find(const key_type& __k)       {return __table_.find(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const key_type& __k) const {return __table_.find(__k);}
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
 #if _LIBCPP_STD_VER >= 20
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    iterator       find(const _K2& __k)            {return __table_.find(__k);}
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator find(const _K2& __k) const      {return __table_.find(__k);}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+    return __table_.find(__k);
+  }
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+    return __table_.find(__k);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type count(const key_type& __k) const {return __table_.__count_multi(__k);}
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_unique(__k); }
 #if _LIBCPP_STD_VER >= 20
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    size_type count(const _K2& __k) const      {return __table_.__count_multi(__k);}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+    return __table_.__count_unique(__k);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
 #if _LIBCPP_STD_VER >= 20
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const key_type& __k) const {return find(__k) != end();}
+  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
 
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    bool contains(const _K2& __k) const      {return find(__k) != end();}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+    return find(__k) != end();
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, iterator>             equal_range(const key_type& __k)
-        {return __table_.__equal_range_multi(__k);}
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator, const_iterator> equal_range(const key_type& __k) const
-        {return __table_.__equal_range_multi(__k);}
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __table_.__equal_range_unique(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __table_.__equal_range_unique(__k);
+  }
 #if _LIBCPP_STD_VER >= 20
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<iterator, iterator>             equal_range(const _K2& __k)
-        {return __table_.__equal_range_multi(__k);}
-    template<class _K2, enable_if_t<__is_transparent<hasher, _K2>::value && __is_transparent<key_equal, _K2>::value>* = nullptr>
-    _LIBCPP_INLINE_VISIBILITY
-    pair<const_iterator, const_iterator> equal_range(const _K2& __k) const
-        {return __table_.__equal_range_multi(__k);}
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+    return __table_.__equal_range_unique(__k);
+  }
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+    return __table_.__equal_range_unique(__k);
+  }
 #endif // _LIBCPP_STD_VER >= 20
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return __table_.max_bucket_count(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket(const key_type& __k) const {return __table_.bucket(__k);}
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const { return __table_.bucket_size(__n); }
+  _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    local_iterator       begin(size_type __n)        {return __table_.begin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    local_iterator       end(size_type __n)          {return __table_.end(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator begin(size_type __n) const  {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator end(size_type __n) const    {return __table_.cend(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}
-
-    _LIBCPP_INLINE_VISIBILITY
-    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
-    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
-    _LIBCPP_INLINE_VISIBILITY
-    void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
-    _LIBCPP_INLINE_VISIBILITY
-    void rehash(size_type __n) {__table_.__rehash_multi(__n);}
-    _LIBCPP_INLINE_VISIBILITY
-    void reserve(size_type __n) {__table_.__reserve_multi(__n);}
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-    _LIBCPP_HIDE_FROM_ABI bool __dereferenceable(const const_iterator* __i) const
-        {return __table_.__dereferenceable(__i);}
-    _LIBCPP_HIDE_FROM_ABI bool __decrementable(const const_iterator* __i) const
-        {return __table_.__decrementable(__i);}
-    _LIBCPP_HIDE_FROM_ABI bool __addable(const const_iterator* __i, ptrdiff_t __n) const
-        {return __table_.__addable(__i, __n);}
-    _LIBCPP_HIDE_FROM_ABI bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const
-        {return __table_.__addable(__i, __n);}
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
+  _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const { return __table_.cbegin(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const { return __table_.cbegin(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
 
+  _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
+  _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
+  _LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) { __table_.max_load_factor(__mlf); }
+  _LIBCPP_HIDE_FROM_ABI void rehash(size_type __n) { __table_.__rehash_unique(__n); }
+  _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n) { __table_.__reserve_unique(__n); }
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Hash = hash<__iter_value_type<_InputIterator>>,
-         class _Pred = equal_to<__iter_value_type<_InputIterator>>,
-         class _Allocator = allocator<__iter_value_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<!__is_allocator<_Pred>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type = 0,
-              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
-  -> unordered_multiset<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
+template <class _InputIterator,
+          class _Hash      = hash<__iter_value_type<_InputIterator>>,
+          class _Pred      = equal_to<__iter_value_type<_InputIterator>>,
+          class _Allocator = allocator<__iter_value_type<_InputIterator>>,
+          class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(_InputIterator,
+              _InputIterator,
+              typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash                                            = _Hash(),
+              _Pred                                            = _Pred(),
+              _Allocator = _Allocator()) -> unordered_set<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
 
-template<class _Tp, class _Hash = hash<_Tp>,
-         class _Pred = equal_to<_Tp>, class _Allocator = allocator<_Tp>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<!__is_allocator<_Pred>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type = 0,
-              _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
-  -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Hash      = hash<ranges::range_value_t<_Range>>,
+          class _Pred      = equal_to<ranges::range_value_t<_Range>>,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(
+    from_range_t,
+    _Range&&,
+    typename allocator_traits<_Allocator>::size_type = 0,
+    _Hash                                            = _Hash(),
+    _Pred                                            = _Pred(),
+    _Allocator = _Allocator()) -> unordered_set<ranges::range_value_t<_Range>, _Hash, _Pred, _Allocator>; // C++23
+#  endif
 
-template<class _InputIterator, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
-  -> unordered_multiset<__iter_value_type<_InputIterator>,
-                   hash<__iter_value_type<_InputIterator>>,
-                   equal_to<__iter_value_type<_InputIterator>>,
-                   _Allocator>;
+template <class _Tp,
+          class _Hash      = hash<_Tp>,
+          class _Pred      = equal_to<_Tp>,
+          class _Allocator = allocator<_Tp>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(initializer_list<_Tp>,
+              typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash                                            = _Hash(),
+              _Pred                                            = _Pred(),
+              _Allocator = _Allocator()) -> unordered_set<_Tp, _Hash, _Pred, _Allocator>;
 
-template<class _InputIterator, class _Hash, class _Allocator,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type,
-              _Hash, _Allocator)
-  -> unordered_multiset<__iter_value_type<_InputIterator>, _Hash,
-                   equal_to<__iter_value_type<_InputIterator>>,
-                   _Allocator>;
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
+    -> unordered_set<__iter_value_type<_InputIterator>,
+                     hash<__iter_value_type<_InputIterator>>,
+                     equal_to<__iter_value_type<_InputIterator>>,
+                     _Allocator>;
 
-template<class _Tp, class _Allocator,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
-  -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+template <class _InputIterator,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+    -> unordered_set<__iter_value_type<_InputIterator>, _Hash, equal_to<__iter_value_type<_InputIterator>>, _Allocator>;
 
-template<class _Tp, class _Hash, class _Allocator,
-         class = enable_if_t<!__is_allocator<_Hash>::value>,
-         class = enable_if_t<!is_integral<_Hash>::value>,
-         class = enable_if_t<__is_allocator<_Allocator>::value>>
-unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
-  -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
+#  if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
+    -> unordered_set<ranges::range_value_t<_Range>,
+                     hash<ranges::range_value_t<_Range>>,
+                     equal_to<ranges::range_value_t<_Range>>,
+                     _Allocator>;
+
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(from_range_t, _Range&&, _Allocator)
+    -> unordered_set<ranges::range_value_t<_Range>,
+                     hash<ranges::range_value_t<_Range>>,
+                     equal_to<ranges::range_value_t<_Range>>,
+                     _Allocator>;
+
+template <ranges::input_range _Range,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+    -> unordered_set<ranges::range_value_t<_Range>, _Hash, equal_to<ranges::range_value_t<_Range>>, _Allocator>;
+
+#  endif
+
+template <class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
+    -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
+template <class _Tp,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+    -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
 #endif
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        size_type __n, const hasher& __hf, const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_unique(__n);
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        size_type __n, const hasher& __hf, const key_equal& __eql,
-        const allocator_type& __a)
-    : __table_(__hf, __eql, __a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+    size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_unique(__n);
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        _InputIterator __first, _InputIterator __last)
-{
-    _VSTD::__debug_db_insert_c(this);
-    insert(__first, __last);
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(_InputIterator __first, _InputIterator __last) {
+  insert(__first, __last);
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        _InputIterator __first, _InputIterator __last, size_type __n,
-        const hasher& __hf, const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
-    insert(__first, __last);
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+    _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_unique(__n);
+  insert(__first, __last);
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        _InputIterator __first, _InputIterator __last, size_type __n,
-        const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
-    : __table_(__hf, __eql, __a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
-    insert(__first, __last);
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+    _InputIterator __first,
+    _InputIterator __last,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_unique(__n);
+  insert(__first, __last);
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        const allocator_type& __a)
-    : __table_(__a)
-{
-    _VSTD::__debug_db_insert_c(this);
+inline unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(const allocator_type& __a) : __table_(__a) {}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(const unordered_set& __u) : __table_(__u.__table_) {
+  __table_.__rehash_unique(__u.bucket_count());
+  insert(__u.begin(), __u.end());
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        const unordered_multiset& __u)
-    : __table_(__u.__table_)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__u.bucket_count());
-    insert(__u.begin(), __u.end());
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        const unordered_multiset& __u, const allocator_type& __a)
-    : __table_(__u.__table_, __a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__u.bucket_count());
-    insert(__u.begin(), __u.end());
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(const unordered_set& __u, const allocator_type& __a)
+    : __table_(__u.__table_, __a) {
+  __table_.__rehash_unique(__u.bucket_count());
+  insert(__u.begin(), __u.end());
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        unordered_multiset&& __u)
+inline unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(unordered_set&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(_VSTD::move(__u.__table_))
-{
-    _VSTD::__debug_db_insert_c(this);
-    std::__debug_db_swap(this, std::addressof(__u));
+    : __table_(std::move(__u.__table_)) {}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(unordered_set&& __u, const allocator_type& __a)
+    : __table_(std::move(__u.__table_), __a) {
+  if (__a != __u.get_allocator()) {
+    iterator __i = __u.begin();
+    while (__u.size() != 0)
+      __table_.__insert_unique(std::move(__u.__table_.remove(__i++)->__get_value()));
+  }
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        unordered_multiset&& __u, const allocator_type& __a)
-    : __table_(_VSTD::move(__u.__table_), __a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    if (__a != __u.get_allocator())
-    {
-        iterator __i = __u.begin();
-        while (__u.size() != 0)
-            __table_.__insert_multi(_VSTD::move(__u.__table_.remove(__i++)->__value_));
-    }
-    else
-        std::__debug_db_swap(this, std::addressof(__u));
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(initializer_list<value_type> __il) {
+  insert(__il.begin(), __il.end());
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        initializer_list<value_type> __il)
-{
-    _VSTD::__debug_db_insert_c(this);
-    insert(__il.begin(), __il.end());
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+    initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_unique(__n);
+  insert(__il.begin(), __il.end());
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
-        const key_equal& __eql)
-    : __table_(__hf, __eql)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
-    insert(__il.begin(), __il.end());
+unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
+    initializer_list<value_type> __il,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_unique(__n);
+  insert(__il.begin(), __il.end());
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
-        initializer_list<value_type> __il, size_type __n, const hasher& __hf,
-        const key_equal& __eql, const allocator_type& __a)
-    : __table_(__hf, __eql, __a)
-{
-    _VSTD::__debug_db_insert_c(this);
-    __table_.__rehash_multi(__n);
-    insert(__il.begin(), __il.end());
+inline unordered_set<_Value, _Hash, _Pred, _Alloc>&
+unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
+    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) {
+  __table_ = std::move(__u.__table_);
+  return *this;
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
-        unordered_multiset&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
-{
-    __table_ = _VSTD::move(__u.__table_);
-    return *this;
-}
-
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
-        initializer_list<value_type> __il)
-{
-    __table_.__assign_multi(__il.begin(), __il.end());
-    return *this;
+inline unordered_set<_Value, _Hash, _Pred, _Alloc>&
+unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(initializer_list<value_type> __il) {
+  __table_.__assign_unique(__il.begin(), __il.end());
+  return *this;
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
-inline
-void
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
-                                                         _InputIterator __last)
-{
-    for (; __first != __last; ++__first)
-        __table_.__insert_multi(*__first);
+inline void unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last) {
+  for (; __first != __last; ++__first)
+    __table_.__insert_unique(*__first);
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
-     unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
-template <class _Value, class _Hash, class _Pred, class _Alloc,
-          class _Predicate>
-inline _LIBCPP_INLINE_VISIBILITY
-    typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::size_type
-    erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c,
-             _Predicate __pred) {
-  return _VSTD::__libcpp_erase_if_container(__c, __pred);
+template <class _Value, class _Hash, class _Pred, class _Alloc, class _Predicate>
+inline _LIBCPP_HIDE_FROM_ABI typename unordered_set<_Value, _Hash, _Pred, _Alloc>::size_type
+erase_if(unordered_set<_Value, _Hash, _Pred, _Alloc>& __c, _Predicate __pred) {
+  return std::__libcpp_erase_if_container(__c, __pred);
 }
 #endif
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-_LIBCPP_HIDE_FROM_ABI bool
-operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
-           const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
-{
-    if (__x.size() != __y.size())
-        return false;
-    typedef typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::const_iterator
-                                                                 const_iterator;
-    typedef pair<const_iterator, const_iterator> _EqRng;
-    for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;)
-    {
-        _EqRng __xeq = __x.equal_range(*__i);
-        _EqRng __yeq = __y.equal_range(*__i);
-        if (_VSTD::distance(__xeq.first, __xeq.second) !=
-            _VSTD::distance(__yeq.first, __yeq.second) ||
-                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
-            return false;
-        __i = __xeq.second;
+_LIBCPP_HIDE_FROM_ABI bool operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+                                      const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) {
+  if (__x.size() != __y.size())
+    return false;
+  typedef typename unordered_set<_Value, _Hash, _Pred, _Alloc>::const_iterator const_iterator;
+  for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end(); __i != __ex; ++__i) {
+    const_iterator __j = __y.find(*__i);
+    if (__j == __ey || !(*__i == *__j))
+      return false;
+  }
+  return true;
+}
+
+#if _LIBCPP_STD_VER <= 17
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
+                                             const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) {
+  return !(__x == __y);
+}
+
+#endif
+
+template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> >
+class _LIBCPP_TEMPLATE_VIS unordered_multiset {
+public:
+  // types
+  typedef _Value key_type;
+  typedef key_type value_type;
+  typedef __type_identity_t<_Hash> hasher;
+  typedef __type_identity_t<_Pred> key_equal;
+  typedef __type_identity_t<_Alloc> allocator_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  static_assert(is_same<value_type, typename allocator_type::value_type>::value,
+                "Allocator::value_type must be same type as value_type");
+
+private:
+  typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table;
+
+  __table __table_;
+
+public:
+  typedef typename __table::pointer pointer;
+  typedef typename __table::const_pointer const_pointer;
+  typedef typename __table::size_type size_type;
+  typedef typename __table::difference_type difference_type;
+
+  typedef typename __table::const_iterator iterator;
+  typedef typename __table::const_iterator const_iterator;
+  typedef typename __table::const_local_iterator local_iterator;
+  typedef typename __table::const_local_iterator const_local_iterator;
+
+#if _LIBCPP_STD_VER >= 17
+  typedef __set_node_handle<typename __table::__node, allocator_type> node_type;
+#endif
+
+  template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_set;
+  template <class _Value2, class _Hash2, class _Pred2, class _Alloc2>
+  friend class _LIBCPP_TEMPLATE_VIS unordered_multiset;
+
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset() _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) {}
+  explicit _LIBCPP_HIDE_FROM_ABI
+  unordered_multiset(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_multiset(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);
+#if _LIBCPP_STD_VER >= 14
+  inline _LIBCPP_HIDE_FROM_ABI unordered_multiset(size_type __n, const allocator_type& __a)
+      : unordered_multiset(__n, hasher(), key_equal(), __a) {}
+  inline _LIBCPP_HIDE_FROM_ABI unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_multiset(__n, __hf, key_equal(), __a) {}
+#endif
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(
+      _InputIterator __first,
+      _InputIterator __last,
+      size_type __n,
+      const hasher& __hf     = hasher(),
+      const key_equal& __eql = key_equal());
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(
+      _InputIterator __first,
+      _InputIterator __last,
+      size_type __n,
+      const hasher& __hf,
+      const key_equal& __eql,
+      const allocator_type& __a);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(
+      from_range_t,
+      _Range&& __range,
+      size_type __n             = /*implementation-defined*/ 0,
+      const hasher& __hf        = hasher(),
+      const key_equal& __eql    = key_equal(),
+      const allocator_type& __a = allocator_type())
+      : __table_(__hf, __eql, __a) {
+    if (__n > 0) {
+      __table_.__rehash_multi(__n);
     }
-    return true;
+    insert_range(std::forward<_Range>(__range));
+  }
+#endif
+
+#if _LIBCPP_STD_VER >= 14
+  template <class _InputIterator>
+  inline _LIBCPP_HIDE_FROM_ABI
+  unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a)
+      : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) {}
+  template <class _InputIterator>
+  inline _LIBCPP_HIDE_FROM_ABI unordered_multiset(
+      _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) {}
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(from_range_t, _Range&& __range, size_type __n, const allocator_type& __a)
+      : unordered_multiset(from_range, std::forward<_Range>(__range), __n, hasher(), key_equal(), __a) {}
+
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI
+  unordered_multiset(from_range_t, _Range&& __range, size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_multiset(from_range, std::forward<_Range>(__range), __n, __hf, key_equal(), __a) {}
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI explicit unordered_multiset(const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(const unordered_multiset& __u);
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(unordered_multiset&& __u)
+      _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(
+      initializer_list<value_type> __il,
+      size_type __n,
+      const hasher& __hf     = hasher(),
+      const key_equal& __eql = key_equal());
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(
+      initializer_list<value_type> __il,
+      size_type __n,
+      const hasher& __hf,
+      const key_equal& __eql,
+      const allocator_type& __a);
+#  if _LIBCPP_STD_VER >= 14
+  inline _LIBCPP_HIDE_FROM_ABI
+  unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
+      : unordered_multiset(__il, __n, hasher(), key_equal(), __a) {}
+  inline _LIBCPP_HIDE_FROM_ABI
+  unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
+      : unordered_multiset(__il, __n, __hf, key_equal(), __a) {}
+#  endif
+#endif // _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI ~unordered_multiset() {
+    static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
+  }
+
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(const unordered_multiset& __u) {
+    __table_ = __u.__table_;
+    return *this;
+  }
+#ifndef _LIBCPP_CXX03_LANG
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(unordered_multiset&& __u)
+      _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(initializer_list<value_type> __il);
+#endif // _LIBCPP_CXX03_LANG
+
+  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
+    return allocator_type(__table_.__node_alloc());
+  }
+
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __table_.size() == 0; }
+  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
+
+#ifndef _LIBCPP_CXX03_LANG
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) {
+    return __table_.__emplace_multi(std::forward<_Args>(__args)...);
+  }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {
+    return __table_.__emplace_hint_multi(__p, std::forward<_Args>(__args)...);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI iterator insert(value_type&& __x) { return __table_.__insert_multi(std::move(__x)); }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __x) {
+    return __table_.__insert_multi(__p, std::move(__x));
+  }
+  _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
+#endif // _LIBCPP_CXX03_LANG
+
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return __table_.__insert_multi(__x); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __x) {
+    return __table_.__insert_multi(__p, __x);
+  }
+
+  template <class _InputIterator>
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last);
+
+#if _LIBCPP_STD_VER >= 23
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+    for (auto&& __element : __range) {
+      __table_.__insert_multi(std::forward<decltype(__element)>(__element));
+    }
+  }
+#endif
+
+#if _LIBCPP_STD_VER >= 17
+  _LIBCPP_HIDE_FROM_ABI iterator insert(node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to unordered_multiset::insert()");
+    return __table_.template __node_handle_insert_multi<node_type>(std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, node_type&& __nh) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(__nh.empty() || __nh.get_allocator() == get_allocator(),
+                                        "node_type with incompatible allocator passed to unordered_multiset::insert()");
+    return __table_.template __node_handle_insert_multi<node_type>(__hint, std::move(__nh));
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __position) {
+    return __table_.template __node_handle_extract<node_type>(__position);
+  }
+  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+    return __table_.template __node_handle_extract<node_type>(__key);
+  }
+
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_multi(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_multiset<key_type, _H2, _P2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_multi(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_set<key_type, _H2, _P2, allocator_type>& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_multi(__source.__table_);
+  }
+  template <class _H2, class _P2>
+  _LIBCPP_HIDE_FROM_ABI void merge(unordered_set<key_type, _H2, _P2, allocator_type>&& __source) {
+    _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+        __source.get_allocator() == get_allocator(), "merging container with incompatible allocator");
+    return __table_.__node_handle_merge_multi(__source.__table_);
+  }
+#endif
+
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __p) { return __table_.erase(__p); }
+  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __k) { return __table_.__erase_multi(__k); }
+  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
+    return __table_.erase(__first, __last);
+  }
+  _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __table_.clear(); }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(unordered_multiset& __u) _NOEXCEPT_(__is_nothrow_swappable_v<__table>) {
+    __table_.swap(__u.__table_);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function(); }
+  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq(); }
+
+  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
+#if _LIBCPP_STD_VER >= 20
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+    return __table_.find(__k);
+  }
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+    return __table_.find(__k);
+  }
+#endif // _LIBCPP_STD_VER >= 20
+
+  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_multi(__k); }
+#if _LIBCPP_STD_VER >= 20
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+    return __table_.__count_multi(__k);
+  }
+#endif // _LIBCPP_STD_VER >= 20
+
+#if _LIBCPP_STD_VER >= 20
+  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+    return find(__k) != end();
+  }
+#endif // _LIBCPP_STD_VER >= 20
+
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+    return __table_.__equal_range_multi(__k);
+  }
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+    return __table_.__equal_range_multi(__k);
+  }
+#if _LIBCPP_STD_VER >= 20
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+    return __table_.__equal_range_multi(__k);
+  }
+  template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
+  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+    return __table_.__equal_range_multi(__k);
+  }
+#endif // _LIBCPP_STD_VER >= 20
+
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
+  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return __table_.max_bucket_count(); }
+
+  _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const { return __table_.bucket_size(__n); }
+  _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
+
+  _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
+  _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const { return __table_.cbegin(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const { return __table_.cbegin(__n); }
+  _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
+
+  _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
+  _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
+  _LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) { __table_.max_load_factor(__mlf); }
+  _LIBCPP_HIDE_FROM_ABI void rehash(size_type __n) { __table_.__rehash_multi(__n); }
+  _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n) { __table_.__reserve_multi(__n); }
+};
+
+#if _LIBCPP_STD_VER >= 17
+template <class _InputIterator,
+          class _Hash      = hash<__iter_value_type<_InputIterator>>,
+          class _Pred      = equal_to<__iter_value_type<_InputIterator>>,
+          class _Allocator = allocator<__iter_value_type<_InputIterator>>,
+          class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(
+    _InputIterator,
+    _InputIterator,
+    typename allocator_traits<_Allocator>::size_type = 0,
+    _Hash                                            = _Hash(),
+    _Pred                                            = _Pred(),
+    _Allocator = _Allocator()) -> unordered_multiset<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
+
+#  if _LIBCPP_STD_VER >= 23
+template <ranges::input_range _Range,
+          class _Hash      = hash<ranges::range_value_t<_Range>>,
+          class _Pred      = equal_to<ranges::range_value_t<_Range>>,
+          class _Allocator = allocator<ranges::range_value_t<_Range>>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(
+    from_range_t,
+    _Range&&,
+    typename allocator_traits<_Allocator>::size_type = 0,
+    _Hash                                            = _Hash(),
+    _Pred                                            = _Pred(),
+    _Allocator = _Allocator()) -> unordered_multiset<ranges::range_value_t<_Range>, _Hash, _Pred, _Allocator>; // C++23
+#  endif
+
+template <class _Tp,
+          class _Hash      = hash<_Tp>,
+          class _Pred      = equal_to<_Tp>,
+          class _Allocator = allocator<_Tp>,
+          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!is_integral<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(initializer_list<_Tp>,
+                   typename allocator_traits<_Allocator>::size_type = 0,
+                   _Hash                                            = _Hash(),
+                   _Pred                                            = _Pred(),
+                   _Allocator = _Allocator()) -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>;
+
+template <class _InputIterator,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
+    -> unordered_multiset<__iter_value_type<_InputIterator>,
+                          hash<__iter_value_type<_InputIterator>>,
+                          equal_to<__iter_value_type<_InputIterator>>,
+                          _Allocator>;
+
+template <class _InputIterator,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+    -> unordered_multiset<__iter_value_type<_InputIterator>,
+                          _Hash,
+                          equal_to<__iter_value_type<_InputIterator>>,
+                          _Allocator>;
+
+#  if _LIBCPP_STD_VER >= 23
+
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
+    -> unordered_multiset<ranges::range_value_t<_Range>,
+                          hash<ranges::range_value_t<_Range>>,
+                          equal_to<ranges::range_value_t<_Range>>,
+                          _Allocator>;
+
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(from_range_t, _Range&&, _Allocator)
+    -> unordered_multiset<ranges::range_value_t<_Range>,
+                          hash<ranges::range_value_t<_Range>>,
+                          equal_to<ranges::range_value_t<_Range>>,
+                          _Allocator>;
+
+template <ranges::input_range _Range,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+    -> unordered_multiset<ranges::range_value_t<_Range>, _Hash, equal_to<ranges::range_value_t<_Range>>, _Allocator>;
+
+#  endif
+
+template <class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
+    -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
+
+template <class _Tp,
+          class _Hash,
+          class _Allocator,
+          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!is_integral<_Hash>::value>,
+          class = enable_if_t<__is_allocator<_Allocator>::value>>
+unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
+    -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
+#endif
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+    size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_multi(__n);
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
-           const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
-{
-    return !(__x == __y);
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+    size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_multi(__n);
 }
 
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(_InputIterator __first, _InputIterator __last) {
+  insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+    _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_multi(__n);
+  insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+    _InputIterator __first,
+    _InputIterator __last,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_multi(__n);
+  insert(__first, __last);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(const allocator_type& __a)
+    : __table_(__a) {}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(const unordered_multiset& __u)
+    : __table_(__u.__table_) {
+  __table_.__rehash_multi(__u.bucket_count());
+  insert(__u.begin(), __u.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+    const unordered_multiset& __u, const allocator_type& __a)
+    : __table_(__u.__table_, __a) {
+  __table_.__rehash_multi(__u.bucket_count());
+  insert(__u.begin(), __u.end());
+}
+
+#ifndef _LIBCPP_CXX03_LANG
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(unordered_multiset&& __u)
+    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
+    : __table_(std::move(__u.__table_)) {}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+    unordered_multiset&& __u, const allocator_type& __a)
+    : __table_(std::move(__u.__table_), __a) {
+  if (__a != __u.get_allocator()) {
+    iterator __i = __u.begin();
+    while (__u.size() != 0)
+      __table_.__insert_multi(std::move(__u.__table_.remove(__i++)->__get_value()));
+  }
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(initializer_list<value_type> __il) {
+  insert(__il.begin(), __il.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+    initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql)
+    : __table_(__hf, __eql) {
+  __table_.__rehash_multi(__n);
+  insert(__il.begin(), __il.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
+    initializer_list<value_type> __il,
+    size_type __n,
+    const hasher& __hf,
+    const key_equal& __eql,
+    const allocator_type& __a)
+    : __table_(__hf, __eql, __a) {
+  __table_.__rehash_multi(__n);
+  insert(__il.begin(), __il.end());
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_multiset&& __u)
+    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) {
+  __table_ = std::move(__u.__table_);
+  return *this;
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
+unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(initializer_list<value_type> __il) {
+  __table_.__assign_multi(__il.begin(), __il.end());
+  return *this;
+}
+
+#endif // _LIBCPP_CXX03_LANG
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+template <class _InputIterator>
+inline void unordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last) {
+  for (; __first != __last; ++__first)
+    __table_.__insert_multi(*__first);
+}
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI void
+swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
+}
+
+#if _LIBCPP_STD_VER >= 20
+template <class _Value, class _Hash, class _Pred, class _Alloc, class _Predicate>
+inline _LIBCPP_HIDE_FROM_ABI typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::size_type
+erase_if(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __c, _Predicate __pred) {
+  return std::__libcpp_erase_if_container(__c, __pred);
+}
+#endif
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+_LIBCPP_HIDE_FROM_ABI bool operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+                                      const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) {
+  if (__x.size() != __y.size())
+    return false;
+  typedef typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::const_iterator const_iterator;
+  typedef pair<const_iterator, const_iterator> _EqRng;
+  for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;) {
+    _EqRng __xeq = __x.equal_range(*__i);
+    _EqRng __yeq = __y.equal_range(*__i);
+    if (std::distance(__xeq.first, __xeq.second) != std::distance(__yeq.first, __yeq.second) ||
+        !std::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+      return false;
+    __i = __xeq.second;
+  }
+  return true;
+}
+
+#if _LIBCPP_STD_VER <= 17
+
+template <class _Value, class _Hash, class _Pred, class _Alloc>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
+                                             const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) {
+  return !(__x == __y);
+}
+
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER >= 17
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
-using unordered_set = std::unordered_set<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
+using unordered_set _LIBCPP_AVAILABILITY_PMR = std::unordered_set<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
 
 template <class _KeyT, class _HashT = std::hash<_KeyT>, class _PredT = std::equal_to<_KeyT>>
-using unordered_multiset = std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
+using unordered_multiset _LIBCPP_AVAILABILITY_PMR =
+    std::unordered_multiset<_KeyT, _HashT, _PredT, polymorphic_allocator<_KeyT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
 
+_LIBCPP_POP_MACROS
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <concepts>
 #  include <cstdlib>
 #  include <functional>
 #  include <iterator>
+#  include <stdexcept>
 #  include <type_traits>
 #endif
 
diff --git a/third_party/libcxx/utility b/third_party/libcxx/utility
index c5581d55e..f97907fbf 100644
--- a/third_party/libcxx/utility
+++ b/third_party/libcxx/utility
@@ -246,26 +246,36 @@ template <class T>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <__utility/as_const.h>
-#include <__utility/auto_cast.h>
-#include <__utility/cmp.h>
+
 #include <__utility/declval.h>
-#include <__utility/exception_guard.h>
-#include <__utility/exchange.h>
 #include <__utility/forward.h>
-#include <__utility/forward_like.h>
-#include <__utility/in_place.h>
-#include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/piecewise_construct.h>
-#include <__utility/priority_tag.h>
 #include <__utility/rel_ops.h>
 #include <__utility/swap.h>
-#include <__utility/to_underlying.h>
-#include <__utility/unreachable.h>
+
+#if _LIBCPP_STD_VER >= 14
+#  include <__utility/exchange.h>
+#  include <__utility/integer_sequence.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 17
+#  include <__utility/as_const.h>
+#  include <__utility/in_place.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 20
+#  include <__utility/cmp.h>
+#endif
+
+#if _LIBCPP_STD_VER >= 23
+#  include <__utility/forward_like.h>
+#  include <__utility/to_underlying.h>
+#  include <__utility/unreachable.h>
+#endif
+
 #include <version>
 
 // standard-mandated includes
@@ -274,6 +284,10 @@ template <class T>
 #include <compare>
 #include <initializer_list>
 
+// [tuple.creation]
+
+#include <__tuple/ignore.h>
+
 // [tuple.helper]
 #include <__tuple/tuple_element.h>
 #include <__tuple/tuple_size.h>
@@ -282,6 +296,10 @@ template <class T>
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <limits>
+#endif
+
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <cstdlib>
 #  include <iosfwd>
diff --git a/third_party/libcxx/valarray b/third_party/libcxx/valarray
index 001e111a0..44341eb2b 100644
--- a/third_party/libcxx/valarray
+++ b/third_party/libcxx/valarray
@@ -116,6 +116,8 @@ public:
     size_t start()  const;
     size_t size()   const;
     size_t stride() const;
+
+    friend bool operator==(const slice& x, const slice& y); // since C++20
 };
 
 template <class T>
@@ -348,7 +350,7 @@ template <class T> unspecified2 end(const valarray<T>& v);
 #include <__algorithm/min.h>
 #include <__algorithm/min_element.h>
 #include <__algorithm/unwrap_iter.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__config>
 #include <__functional/operations.h>
 #include <__memory/addressof.h>
@@ -377,347 +379,264 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<class _Tp> class _LIBCPP_TEMPLATE_VIS valarray;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS valarray;
+
+class _LIBCPP_TEMPLATE_VIS slice {
+  size_t __start_;
+  size_t __size_;
+  size_t __stride_;
 
-class _LIBCPP_TEMPLATE_VIS slice
-{
-    size_t __start_;
-    size_t __size_;
-    size_t __stride_;
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    slice()
-        : __start_(0),
-          __size_(0),
-          __stride_(0)
-          {}
+  _LIBCPP_HIDE_FROM_ABI slice() : __start_(0), __size_(0), __stride_(0) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    slice(size_t __start, size_t __size, size_t __stride)
-        : __start_(__start),
-          __size_(__size),
-          __stride_(__stride)
-          {}
+  _LIBCPP_HIDE_FROM_ABI slice(size_t __start, size_t __size, size_t __stride)
+      : __start_(__start), __size_(__size), __stride_(__stride) {}
 
-    _LIBCPP_INLINE_VISIBILITY size_t start()  const {return __start_;}
-    _LIBCPP_INLINE_VISIBILITY size_t size()   const {return __size_;}
-    _LIBCPP_INLINE_VISIBILITY size_t stride() const {return __stride_;}
+  _LIBCPP_HIDE_FROM_ABI size_t start() const { return __start_; }
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
+  _LIBCPP_HIDE_FROM_ABI size_t stride() const { return __stride_; }
+
+#if _LIBCPP_STD_VER >= 20
+
+  _LIBCPP_HIDE_FROM_ABI friend bool operator==(const slice& __x, const slice& __y) {
+    return __x.start() == __y.start() && __x.size() == __y.size() && __x.stride() == __y.stride();
+  }
+
+#endif
 };
 
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS slice_array;
-class _LIBCPP_TYPE_VIS gslice;
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS gslice_array;
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS mask_array;
-template <class _Tp> class _LIBCPP_TEMPLATE_VIS indirect_array;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS slice_array;
+class _LIBCPP_EXPORTED_FROM_ABI gslice;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS gslice_array;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS mask_array;
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS indirect_array;
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-begin(valarray<_Tp>& __v);
+_LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v);
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-const _Tp*
-begin(const valarray<_Tp>& __v);
+_LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v);
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-_Tp*
-end(valarray<_Tp>& __v);
+_LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v);
 
 template <class _Tp>
-_LIBCPP_INLINE_VISIBILITY
-const _Tp*
-end(const valarray<_Tp>& __v);
+_LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v);
 
 template <class _Op, class _A0>
-struct _UnaryOp
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _UnaryOp {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    _A0 __a0_;
+  _Op __op_;
+  _A0 __a0_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}
+  _LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const _A0& __a0) : __op_(__op), __a0_(__a0) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 template <class _Op, class _A0, class _A1>
-struct _BinaryOp
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _BinaryOp {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    _A0 __a0_;
-    _A1 __a1_;
+  _Op __op_;
+  _A0 __a0_;
+  _A1 __a1_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)
-        : __op_(__op), __a0_(__a0), __a1_(__a1) {}
+  _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const _A1& __a1)
+      : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 template <class _Tp>
-class __scalar_expr
-{
+class __scalar_expr {
 public:
-    typedef _Tp        value_type;
-    typedef const _Tp& __result_type;
+  typedef _Tp value_type;
+  typedef const _Tp& __result_type;
+
 private:
-    const value_type& __t_;
-    size_t __s_;
+  const value_type& __t_;
+  size_t __s_;
+
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __scalar_expr(const value_type& __t, size_t __s) : __t_(__t), __s_(__s) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t) const {return __t_;}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t) const { return __t_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __s_;}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __s_; }
 };
 
 template <class _Tp>
-struct __unary_plus
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return +__x;}
+struct __unary_plus {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return +__x; }
 };
 
 template <class _Tp>
-struct __bit_not
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return ~__x;}
+struct __bit_not {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return ~__x; }
 };
 
 template <class _Tp>
-struct __bit_shift_left
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x << __y;}
+struct __bit_shift_left {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x << __y; }
 };
 
 template <class _Tp>
-struct __bit_shift_right
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return __x >> __y;}
+struct __bit_shift_right {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x >> __y; }
 };
 
 template <class _Tp, class _Fp>
-struct __apply_expr
-{
+struct __apply_expr {
 private:
-    _Fp __f_;
+  _Fp __f_;
+
 public:
-    typedef _Tp __result_type;
+  typedef _Tp __result_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __apply_expr(_Fp __f) : __f_(__f) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __apply_expr(_Fp __f) : __f_(__f) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return __f_(__x);}
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return __f_(__x); }
 };
 
 template <class _Tp>
-struct __abs_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::abs(__x);}
+struct __abs_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::abs(__x); }
 };
 
 template <class _Tp>
-struct __acos_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::acos(__x);}
+struct __acos_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::acos(__x); }
 };
 
 template <class _Tp>
-struct __asin_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::asin(__x);}
+struct __asin_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::asin(__x); }
 };
 
 template <class _Tp>
-struct __atan_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::atan(__x);}
+struct __atan_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::atan(__x); }
 };
 
 template <class _Tp>
-struct __atan2_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return std::atan2(__x, __y);}
+struct __atan2_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return std::atan2(__x, __y); }
 };
 
 template <class _Tp>
-struct __cos_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::cos(__x);}
+struct __cos_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::cos(__x); }
 };
 
 template <class _Tp>
-struct __cosh_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::cosh(__x);}
+struct __cosh_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::cosh(__x); }
 };
 
 template <class _Tp>
-struct __exp_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::exp(__x);}
+struct __exp_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::exp(__x); }
 };
 
 template <class _Tp>
-struct __log_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::log(__x);}
+struct __log_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::log(__x); }
 };
 
 template <class _Tp>
-struct __log10_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::log10(__x);}
+struct __log10_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::log10(__x); }
 };
 
 template <class _Tp>
-struct __pow_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x, const _Tp& __y) const
-        {return std::pow(__x, __y);}
+struct __pow_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x, const _Tp& __y) const { return std::pow(__x, __y); }
 };
 
 template <class _Tp>
-struct __sin_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::sin(__x);}
+struct __sin_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sin(__x); }
 };
 
 template <class _Tp>
-struct __sinh_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::sinh(__x);}
+struct __sinh_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sinh(__x); }
 };
 
 template <class _Tp>
-struct __sqrt_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::sqrt(__x);}
+struct __sqrt_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::sqrt(__x); }
 };
 
 template <class _Tp>
-struct __tan_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::tan(__x);}
+struct __tan_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::tan(__x); }
 };
 
 template <class _Tp>
-struct __tanh_expr
-{
-    typedef _Tp __result_type;
-    _LIBCPP_INLINE_VISIBILITY
-    _Tp operator()(const _Tp& __x) const
-        {return std::tanh(__x);}
+struct __tanh_expr {
+  typedef _Tp __result_type;
+  _LIBCPP_HIDE_FROM_ABI _Tp operator()(const _Tp& __x) const { return std::tanh(__x); }
 };
 
 template <class _ValExpr>
-class __slice_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+class __slice_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef value_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef value_type __result_type;
 
 private:
-    _ValExpr __expr_;
-    size_t __start_;
-    size_t __size_;
-    size_t __stride_;
+  _ValExpr __expr_;
+  size_t __start_;
+  size_t __size_;
+  size_t __stride_;
+
+  _LIBCPP_HIDE_FROM_ABI __slice_expr(const slice& __sl, const _RmExpr& __e)
+      : __expr_(__e), __start_(__sl.start()), __size_(__sl.size()), __stride_(__sl.stride()) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __slice_expr(const slice& __sl, const _RmExpr& __e)
-        : __expr_(__e),
-          __start_(__sl.start()),
-          __size_(__sl.size()),
-          __stride_(__sl.stride())
-        {}
 public:
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__start_ + __i * __stride_]; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const
-        {return __expr_[__start_ + __i * __stride_];}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __size_;}
-
-    template <class> friend class __val_expr;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
+  template <class>
+  friend class __val_expr;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS valarray;
 };
 
 template <class _ValExpr>
@@ -727,3018 +646,1984 @@ template <class _ValExpr>
 class __indirect_expr;
 
 template <class _ValExpr>
-class __shift_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+class __shift_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef value_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef value_type __result_type;
 
 private:
-    _ValExpr __expr_;
-    size_t __size_;
-    ptrdiff_t __ul_;
-    ptrdiff_t __sn_;
-    ptrdiff_t __n_;
-    static const ptrdiff_t _Np = static_cast<ptrdiff_t>(
-                                    sizeof(ptrdiff_t) * __CHAR_BIT__ - 1);
+  _ValExpr __expr_;
+  size_t __size_;
+  ptrdiff_t __ul_;
+  ptrdiff_t __sn_;
+  ptrdiff_t __n_;
+  static const ptrdiff_t _Np = static_cast<ptrdiff_t>(sizeof(ptrdiff_t) * __CHAR_BIT__ - 1);
+
+  _LIBCPP_HIDE_FROM_ABI __shift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()), __n_(__n) {
+    ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np);
+    __sn_             = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np);
+    __ul_             = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __shift_expr(int __n, const _RmExpr& __e)
-        : __expr_(__e),
-          __size_(__e.size()),
-          __n_(__n)
-        {
-            ptrdiff_t __neg_n = static_cast<ptrdiff_t>(__n_ >> _Np);
-            __sn_ = __neg_n | static_cast<ptrdiff_t>(static_cast<size_t>(-__n_) >> _Np);
-            __ul_ = ((__size_ - __n_) & ~__neg_n) | ((__n_ + 1) & __neg_n);
-        }
 public:
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __j) const {
+    ptrdiff_t __i = static_cast<ptrdiff_t>(__j);
+    ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np;
+    return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __j) const
-        {
-            ptrdiff_t __i = static_cast<ptrdiff_t>(__j);
-            ptrdiff_t __m = (__sn_ * __i - __ul_) >> _Np;
-            return (__expr_[(__i + __n_) & __m] & __m) | (value_type() & ~__m);
-        }
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __size_;}
-
-    template <class> friend class __val_expr;
+  template <class>
+  friend class __val_expr;
 };
 
 template <class _ValExpr>
-class __cshift_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+class __cshift_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef value_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef value_type __result_type;
 
 private:
-    _ValExpr __expr_;
-    size_t __size_;
-    size_t __m_;
-    size_t __o1_;
-    size_t __o2_;
+  _ValExpr __expr_;
+  size_t __size_;
+  size_t __m_;
+  size_t __o1_;
+  size_t __o2_;
+
+  _LIBCPP_HIDE_FROM_ABI __cshift_expr(int __n, const _RmExpr& __e) : __expr_(__e), __size_(__e.size()) {
+    __n %= static_cast<int>(__size_);
+    if (__n >= 0) {
+      __m_  = __size_ - __n;
+      __o1_ = __n;
+      __o2_ = __n - __size_;
+    } else {
+      __m_  = -__n;
+      __o1_ = __n + __size_;
+      __o2_ = __n;
+    }
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __cshift_expr(int __n, const _RmExpr& __e)
-        : __expr_(__e),
-          __size_(__e.size())
-        {
-            __n %= static_cast<int>(__size_);
-            if (__n >= 0)
-            {
-                __m_ = __size_ - __n;
-                __o1_ = __n;
-                __o2_ = __n - __size_;
-            }
-            else
-            {
-                __m_ = -__n;
-                __o1_ = __n + __size_;
-                __o2_ = __n;
-            }
-        }
 public:
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const {
+    if (__i < __m_)
+      return __expr_[__i + __o1_];
+    return __expr_[__i + __o2_];
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const
-        {
-            if (__i < __m_)
-                return __expr_[__i + __o1_];
-            return __expr_[__i + __o2_];
-        }
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __size_;}
-
-    template <class> friend class __val_expr;
+  template <class>
+  friend class __val_expr;
 };
 
-template<class _ValExpr>
+template <class _ValExpr>
 class __val_expr;
 
-template<class _ValExpr>
+template <class _ValExpr>
 struct __is_val_expr : false_type {};
 
-template<class _ValExpr>
+template <class _ValExpr>
 struct __is_val_expr<__val_expr<_ValExpr> > : true_type {};
 
-template<class _Tp>
+template <class _Tp>
 struct __is_val_expr<valarray<_Tp> > : true_type {};
 
-template<class _Tp>
-class _LIBCPP_TEMPLATE_VIS valarray
-{
+template <class _Tp>
+struct __is_val_expr<slice_array<_Tp> > : true_type {};
+
+template <class _Tp>
+struct __is_val_expr<gslice_array<_Tp> > : true_type {};
+
+template <class _Tp>
+struct __is_val_expr<mask_array<_Tp> > : true_type {};
+
+template <class _Tp>
+struct __is_val_expr<indirect_array<_Tp> > : true_type {};
+
+// The functions using a __val_expr access the elements by their index.
+// valarray and the libc++ lazy proxies have an operator[]. The
+// Standard proxy array's don't have this operator, instead they have a
+// implementation specific accessor
+//   __get(size_t)
+//
+// The functions use the non-member function
+//   __get(__val_expr, size_t)
+//
+// If the __val_expr is a specialization of __val_expr_use_member_functions it
+// uses the __val_expr's member function
+//   __get(size_t)
+// else it uses the __val_expr's member function
+//   operator[](size_t)
+template <class _ValExpr>
+struct __val_expr_use_member_functions;
+
+template <class>
+struct __val_expr_use_member_functions : false_type {};
+
+template <class _Tp>
+struct __val_expr_use_member_functions<slice_array<_Tp> > : true_type {};
+
+template <class _Tp>
+struct __val_expr_use_member_functions<gslice_array<_Tp> > : true_type {};
+
+template <class _Tp>
+struct __val_expr_use_member_functions<mask_array<_Tp> > : true_type {};
+
+template <class _Tp>
+struct __val_expr_use_member_functions<indirect_array<_Tp> > : true_type {};
+
+template <class _Tp>
+class _LIBCPP_TEMPLATE_VIS valarray {
 public:
-    typedef _Tp value_type;
-    typedef _Tp __result_type;
+  typedef _Tp value_type;
+  typedef _Tp __result_type;
 
 private:
-    value_type* __begin_;
-    value_type* __end_;
+  value_type* __begin_;
+  value_type* __end_;
 
 public:
-    // construct/destroy:
-    _LIBCPP_INLINE_VISIBILITY
-    valarray() : __begin_(nullptr), __end_(nullptr) {}
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    explicit valarray(size_t __n);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray(const value_type& __x, size_t __n);
-    valarray(const value_type* __p, size_t __n);
-    valarray(const valarray& __v);
+  // construct/destroy:
+  _LIBCPP_HIDE_FROM_ABI valarray() : __begin_(nullptr), __end_(nullptr) {}
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit valarray(size_t __n);
+  _LIBCPP_HIDE_FROM_ABI valarray(const value_type& __x, size_t __n);
+  valarray(const value_type* __p, size_t __n);
+  valarray(const valarray& __v);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    valarray(valarray&& __v) _NOEXCEPT;
-    valarray(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI valarray(valarray&& __v) _NOEXCEPT;
+  valarray(initializer_list<value_type> __il);
 #endif // _LIBCPP_CXX03_LANG
-    valarray(const slice_array<value_type>& __sa);
-    valarray(const gslice_array<value_type>& __ga);
-    valarray(const mask_array<value_type>& __ma);
-    valarray(const indirect_array<value_type>& __ia);
-    inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1
-    ~valarray();
+  valarray(const slice_array<value_type>& __sa);
+  valarray(const gslice_array<value_type>& __ga);
+  valarray(const mask_array<value_type>& __ma);
+  valarray(const indirect_array<value_type>& __ia);
+  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 ~valarray();
 
-    // assignment:
-    valarray& operator=(const valarray& __v);
+  // assignment:
+  valarray& operator=(const valarray& __v);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(valarray&& __v) _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(initializer_list<value_type>);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(valarray&& __v) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(initializer_list<value_type>);
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(const slice_array<value_type>& __sa);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(const gslice_array<value_type>& __ga);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(const mask_array<value_type>& __ma);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator=(const indirect_array<value_type>& __ia);
-    template <class _ValExpr>
-        _LIBCPP_INLINE_VISIBILITY
-        valarray& operator=(const __val_expr<_ValExpr>& __v);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const slice_array<value_type>& __sa);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const gslice_array<value_type>& __ga);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const mask_array<value_type>& __ma);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const indirect_array<value_type>& __ia);
+  template <class _ValExpr>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator=(const __val_expr<_ValExpr>& __v);
 
-    // element access:
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type& operator[](size_t __i) const {return __begin_[__i];}
+  // element access:
+  _LIBCPP_HIDE_FROM_ABI const value_type& operator[](size_t __i) const { return __begin_[__i]; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    value_type&       operator[](size_t __i)       {return __begin_[__i];}
+  _LIBCPP_HIDE_FROM_ABI value_type& operator[](size_t __i) { return __begin_[__i]; }
 
-    // subset operations:
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__slice_expr<const valarray&> >    operator[](slice __s) const;
-    _LIBCPP_INLINE_VISIBILITY
-    slice_array<value_type>                       operator[](slice __s);
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;
-    _LIBCPP_INLINE_VISIBILITY
-    gslice_array<value_type>   operator[](const gslice& __gs);
+  // subset operations:
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const;
+  _LIBCPP_HIDE_FROM_ABI slice_array<value_type> operator[](slice __s);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;
+  _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](const gslice& __gs);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
-    _LIBCPP_INLINE_VISIBILITY
-    gslice_array<value_type>                      operator[](gslice&& __gs);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
+  _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](gslice&& __gs);
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__mask_expr<const valarray&> >     operator[](const valarray<bool>& __vb) const;
-    _LIBCPP_INLINE_VISIBILITY
-    mask_array<value_type>                        operator[](const valarray<bool>& __vb);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const;
+  _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](const valarray<bool>& __vb);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__mask_expr<const valarray&> >     operator[](valarray<bool>&& __vb) const;
-    _LIBCPP_INLINE_VISIBILITY
-    mask_array<value_type>                        operator[](valarray<bool>&& __vb);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const;
+  _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](valarray<bool>&& __vb);
 #endif // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;
-    _LIBCPP_INLINE_VISIBILITY
-    indirect_array<value_type>                    operator[](const valarray<size_t>& __vs);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;
+  _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](const valarray<size_t>& __vs);
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;
-    _LIBCPP_INLINE_VISIBILITY
-    indirect_array<value_type>                    operator[](valarray<size_t>&& __vs);
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;
+  _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](valarray<size_t>&& __vs);
 #endif // _LIBCPP_CXX03_LANG
 
-    // unary operators:
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> >   operator+() const;
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<negate<_Tp>, const valarray&> >         operator-() const;
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> >      operator~() const;
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<logical_not<_Tp>, const valarray&> >    operator!() const;
+  // unary operators:
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray&> > operator+() const;
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<negate<_Tp>, const valarray&> > operator-() const;
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray&> > operator~() const;
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<logical_not<_Tp>, const valarray&> > operator!() const;
 
-    // computed assignment:
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator*= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator/= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator%= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator+= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator-= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator^= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator&= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator|= (const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator<<=(const value_type& __x);
-    _LIBCPP_INLINE_VISIBILITY
-    valarray& operator>>=(const value_type& __x);
+  // computed assignment:
+  _LIBCPP_HIDE_FROM_ABI valarray& operator*=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator/=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator%=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator+=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator-=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator^=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator&=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator|=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const value_type& __x);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator*= (const _Expr& __v);
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator*=(const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator/= (const _Expr& __v);
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator/=(const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator%= (const _Expr& __v);
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator%=(const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator+= (const _Expr& __v);
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator+=(const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator-= (const _Expr& __v);
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator-=(const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator^= (const _Expr& __v);
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator^=(const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator|= (const _Expr& __v);
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator|=(const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator&= (const _Expr& __v);
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator&=(const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator<<= (const _Expr& __v);
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator<<=(const _Expr& __v);
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        valarray&
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator>>= (const _Expr& __v);
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI valarray& operator>>=(const _Expr& __v);
 
-    // member functions:
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(valarray& __v) _NOEXCEPT;
+  // member functions:
+  _LIBCPP_HIDE_FROM_ABI void swap(valarray& __v) _NOEXCEPT;
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return static_cast<size_t>(__end_ - __begin_);}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return static_cast<size_t>(__end_ - __begin_); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    value_type sum() const;
-    _LIBCPP_INLINE_VISIBILITY
-    value_type min() const;
-    _LIBCPP_INLINE_VISIBILITY
-    value_type max() const;
+  _LIBCPP_HIDE_FROM_ABI value_type sum() const;
+  _LIBCPP_HIDE_FROM_ABI value_type min() const;
+  _LIBCPP_HIDE_FROM_ABI value_type max() const;
 
-    valarray shift (int __i) const;
-    valarray cshift(int __i) const;
-    valarray apply(value_type __f(value_type)) const;
-    valarray apply(value_type __f(const value_type&)) const;
-    void     resize(size_t __n, value_type __x = value_type());
+  valarray shift(int __i) const;
+  valarray cshift(int __i) const;
+  valarray apply(value_type __f(value_type)) const;
+  valarray apply(value_type __f(const value_type&)) const;
+  void resize(size_t __n, value_type __x = value_type());
 
 private:
-    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS slice_array;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS gslice_array;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS mask_array;
-    template <class> friend class __mask_expr;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS indirect_array;
-    template <class> friend class __indirect_expr;
-    template <class> friend class __val_expr;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS valarray;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS slice_array;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS gslice_array;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS mask_array;
+  template <class>
+  friend class __mask_expr;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS indirect_array;
+  template <class>
+  friend class __indirect_expr;
+  template <class>
+  friend class __val_expr;
 
-    template <class _Up>
-    friend
-    _Up*
-    begin(valarray<_Up>& __v);
+  template <class _Up>
+  friend _Up* begin(valarray<_Up>& __v);
 
-    template <class _Up>
-    friend
-    const _Up*
-    begin(const valarray<_Up>& __v);
+  template <class _Up>
+  friend const _Up* begin(const valarray<_Up>& __v);
 
-    template <class _Up>
-    friend
-    _Up*
-    end(valarray<_Up>& __v);
+  template <class _Up>
+  friend _Up* end(valarray<_Up>& __v);
 
-    template <class _Up>
-    friend
-    const _Up*
-    end(const valarray<_Up>& __v);
+  template <class _Up>
+  friend const _Up* end(const valarray<_Up>& __v);
 
-    _LIBCPP_INLINE_VISIBILITY
-    void __clear(size_t __capacity);
-    valarray& __assign_range(const value_type* __f, const value_type* __l);
+  _LIBCPP_HIDE_FROM_ABI void __clear(size_t __capacity);
+  valarray& __assign_range(const value_type* __f, const value_type* __l);
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _Tp, size_t _Size>
-valarray(const _Tp(&)[_Size], size_t) -> valarray<_Tp>;
+template <class _Tp, size_t _Size>
+valarray(const _Tp (&)[_Size], size_t) -> valarray<_Tp>;
 #endif
 
-extern template _LIBCPP_FUNC_VIS void valarray<size_t>::resize(size_t, size_t);
+template <class _Expr,
+          __enable_if_t<__is_val_expr<_Expr>::value && __val_expr_use_member_functions<_Expr>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename _Expr::value_type __get(const _Expr& __v, size_t __i) {
+  return __v.__get(__i);
+}
+
+template <class _Expr,
+          __enable_if_t<__is_val_expr<_Expr>::value && !__val_expr_use_member_functions<_Expr>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename _Expr::value_type __get(const _Expr& __v, size_t __i) {
+  return __v[__i];
+}
+
+extern template _LIBCPP_EXPORTED_FROM_ABI void valarray<size_t>::resize(size_t, size_t);
 
 template <class _Op, class _Tp>
-struct _UnaryOp<_Op, valarray<_Tp> >
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _UnaryOp<_Op, valarray<_Tp> > {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    const valarray<_Tp>& __a0_;
+  _Op __op_;
+  const valarray<_Tp>& __a0_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}
+  _LIBCPP_HIDE_FROM_ABI _UnaryOp(const _Op& __op, const valarray<_Tp>& __a0) : __op_(__op), __a0_(__a0) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 template <class _Op, class _Tp, class _A1>
-struct _BinaryOp<_Op, valarray<_Tp>, _A1>
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _BinaryOp<_Op, valarray<_Tp>, _A1> {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    const valarray<_Tp>& __a0_;
-    _A1 __a1_;
+  _Op __op_;
+  const valarray<_Tp>& __a0_;
+  _A1 __a1_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)
-        : __op_(__op), __a0_(__a0), __a1_(__a1) {}
+  _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const _A1& __a1)
+      : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 template <class _Op, class _A0, class _Tp>
-struct _BinaryOp<_Op, _A0, valarray<_Tp> >
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _BinaryOp<_Op, _A0, valarray<_Tp> > {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    _A0 __a0_;
-    const valarray<_Tp>& __a1_;
+  _Op __op_;
+  _A0 __a0_;
+  const valarray<_Tp>& __a1_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)
-        : __op_(__op), __a0_(__a0), __a1_(__a1) {}
+  _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const _A0& __a0, const valarray<_Tp>& __a1)
+      : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 template <class _Op, class _Tp>
-struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> >
-{
-    typedef typename _Op::__result_type __result_type;
-    using value_type = __decay_t<__result_type>;
+struct _BinaryOp<_Op, valarray<_Tp>, valarray<_Tp> > {
+  typedef typename _Op::__result_type __result_type;
+  using value_type = __decay_t<__result_type>;
 
-    _Op __op_;
-    const valarray<_Tp>& __a0_;
-    const valarray<_Tp>& __a1_;
+  _Op __op_;
+  const valarray<_Tp>& __a0_;
+  const valarray<_Tp>& __a1_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)
-        : __op_(__op), __a0_(__a0), __a1_(__a1) {}
+  _LIBCPP_HIDE_FROM_ABI _BinaryOp(const _Op& __op, const valarray<_Tp>& __a0, const valarray<_Tp>& __a1)
+      : __op_(__op), __a0_(__a0), __a1_(__a1) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const {return __op_(__a0_[__i], __a1_[__i]);}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __op_(__a0_[__i], __a1_[__i]); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __a0_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __a0_.size(); }
 };
 
 // slice_array
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS slice_array
-{
+class _LIBCPP_TEMPLATE_VIS slice_array {
 public:
-    typedef _Tp value_type;
+  typedef _Tp value_type;
 
 private:
-    value_type* __vp_;
-    size_t __size_;
-    size_t __stride_;
+  value_type* __vp_;
+  size_t __size_;
+  size_t __stride_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator*=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator/=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator%=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator+=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator-=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator^=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator&=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator|=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator<<=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator>>=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
 
-    slice_array(slice_array const&) = default;
+  slice_array(slice_array const&) = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    const slice_array& operator=(const slice_array& __sa) const;
+  _LIBCPP_HIDE_FROM_ABI const slice_array& operator=(const slice_array& __sa) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator=(const value_type& __x) const;
+  _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator=(const valarray<value_type>& __va) const;
+  _LIBCPP_HIDE_FROM_ABI void operator=(const valarray<value_type>& __va) const;
+
+  // Behaves like __val_expr::operator[], which returns by value.
+  _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __size_, "slice_array.__get() index out of bounds");
+    return __vp_[__i * __stride_];
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    slice_array(const slice& __sl, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())),
-          __size_(__sl.size()),
-          __stride_(__sl.stride())
-        {}
+  _LIBCPP_HIDE_FROM_ABI slice_array(const slice& __sl, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_ + __sl.start())), __size_(__sl.size()), __stride_(__sl.stride()) {}
 
-    template <class> friend class valarray;
+  template <class>
+  friend class valarray;
 };
 
 template <class _Tp>
-inline
-const slice_array<_Tp>&
-slice_array<_Tp>::operator=(const slice_array& __sa) const
-{
-    value_type* __t = __vp_;
-    const value_type* __s = __sa.__vp_;
-    for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_)
-        *__t = *__s;
-    return *this;
+inline const slice_array<_Tp>& slice_array<_Tp>::operator=(const slice_array& __sa) const {
+  value_type* __t       = __vp_;
+  const value_type* __s = __sa.__vp_;
+  for (size_t __n = __size_; __n; --__n, __t += __stride_, __s += __sa.__stride_)
+    *__t = *__s;
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t = __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t = __v[__i];
 }
 
 template <class _Tp>
-inline void
-slice_array<_Tp>::operator=(const valarray<value_type>& __va) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_)
-        *__t = __va[__i];
+inline void slice_array<_Tp>::operator=(const valarray<value_type>& __va) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __va.size(); ++__i, __t += __stride_)
+    *__t = __va[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator*=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t *= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator*=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t *= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator/=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t /= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator/=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t /= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator%=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t %= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator%=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t %= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator+=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t += __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator+=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t += __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator-=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t -= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator-=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t -= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator^=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t ^= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator^=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t ^= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator&=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t &= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator&=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t &= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator|=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t |= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator|=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t |= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator<<=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t <<= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator<<=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t <<= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-slice_array<_Tp>::operator>>=(const _Expr& __v) const
-{
-    value_type* __t = __vp_;
-    for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
-        *__t >>= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void slice_array<_Tp>::operator>>=(const _Expr& __v) const {
+  value_type* __t = __vp_;
+  for (size_t __i = 0; __i < __size_; ++__i, __t += __stride_)
+    *__t >>= __v[__i];
 }
 
 template <class _Tp>
-inline
-void
-slice_array<_Tp>::operator=(const value_type& __x) const
-{
-    value_type* __t = __vp_;
-    for (size_t __n = __size_; __n; --__n, __t += __stride_)
-        *__t = __x;
+inline void slice_array<_Tp>::operator=(const value_type& __x) const {
+  value_type* __t = __vp_;
+  for (size_t __n = __size_; __n; --__n, __t += __stride_)
+    *__t = __x;
 }
 
 // gslice
 
-class _LIBCPP_TYPE_VIS gslice
-{
-    valarray<size_t> __size_;
-    valarray<size_t> __stride_;
-    valarray<size_t> __1d_;
+class _LIBCPP_EXPORTED_FROM_ABI gslice {
+  valarray<size_t> __size_;
+  valarray<size_t> __stride_;
+  valarray<size_t> __1d_;
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    gslice() {}
+  _LIBCPP_HIDE_FROM_ABI gslice() {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    gslice(size_t __start, const valarray<size_t>& __size,
-                           const valarray<size_t>& __stride)
-        : __size_(__size),
-          __stride_(__stride)
-        {__init(__start);}
+  _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray<size_t>& __size, const valarray<size_t>& __stride)
+      : __size_(__size), __stride_(__stride) {
+    __init(__start);
+  }
 
 #ifndef _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    gslice(size_t __start, const valarray<size_t>&  __size,
-                                 valarray<size_t>&& __stride)
-        : __size_(__size),
-          __stride_(std::move(__stride))
-        {__init(__start);}
+  _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, const valarray<size_t>& __size, valarray<size_t>&& __stride)
+      : __size_(__size), __stride_(std::move(__stride)) {
+    __init(__start);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    gslice(size_t __start,       valarray<size_t>&& __size,
-                           const valarray<size_t>&  __stride)
-        : __size_(std::move(__size)),
-          __stride_(__stride)
-        {__init(__start);}
+  _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray<size_t>&& __size, const valarray<size_t>& __stride)
+      : __size_(std::move(__size)), __stride_(__stride) {
+    __init(__start);
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    gslice(size_t __start,       valarray<size_t>&& __size,
-                                 valarray<size_t>&& __stride)
-        : __size_(std::move(__size)),
-          __stride_(std::move(__stride))
-        {__init(__start);}
+  _LIBCPP_HIDE_FROM_ABI gslice(size_t __start, valarray<size_t>&& __size, valarray<size_t>&& __stride)
+      : __size_(std::move(__size)), __stride_(std::move(__stride)) {
+    __init(__start);
+  }
 
 #endif // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t           start()  const {return __1d_.size() ? __1d_[0] : 0;}
+  _LIBCPP_HIDE_FROM_ABI size_t start() const { return __1d_.size() ? __1d_[0] : 0; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    valarray<size_t> size()   const {return __size_;}
+  _LIBCPP_HIDE_FROM_ABI valarray<size_t> size() const { return __size_; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    valarray<size_t> stride() const {return __stride_;}
+  _LIBCPP_HIDE_FROM_ABI valarray<size_t> stride() const { return __stride_; }
 
 private:
-    void __init(size_t __start);
+  void __init(size_t __start);
 
-    template <class> friend class gslice_array;
-    template <class> friend class valarray;
-    template <class> friend class __val_expr;
+  template <class>
+  friend class gslice_array;
+  template <class>
+  friend class valarray;
+  template <class>
+  friend class __val_expr;
 };
 
 // gslice_array
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS gslice_array
-{
+class _LIBCPP_TEMPLATE_VIS gslice_array {
 public:
-    typedef _Tp value_type;
+  typedef _Tp value_type;
 
 private:
-    value_type*      __vp_;
-    valarray<size_t> __1d_;
+  value_type* __vp_;
+  valarray<size_t> __1d_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator*=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator/=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator%=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator+=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator-=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator^=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator&=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator|=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator<<=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator>>=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    const gslice_array& operator=(const gslice_array& __ga) const;
+  _LIBCPP_HIDE_FROM_ABI const gslice_array& operator=(const gslice_array& __ga) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator=(const value_type& __x) const;
+  _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
 
-    gslice_array(const gslice_array&)            = default;
+  gslice_array(const gslice_array&) = default;
+
+  // Behaves like __val_expr::operator[], which returns by value.
+  _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "gslice_array.__get() index out of bounds");
+    return __vp_[__1d_[__i]];
+  }
 
 private:
-    gslice_array(const gslice& __gs, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(__gs.__1d_)
-        {}
+  gslice_array(const gslice& __gs, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__gs.__1d_) {}
 
 #ifndef _LIBCPP_CXX03_LANG
-    gslice_array(gslice&& __gs, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(std::move(__gs.__1d_))
-        {}
+  gslice_array(gslice&& __gs, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(std::move(__gs.__1d_)) {}
 #endif // _LIBCPP_CXX03_LANG
 
-    template <class> friend class valarray;
+  template <class>
+  friend class valarray;
 };
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] = __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] = __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator*=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] *= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator*=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] *= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator/=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] /= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator/=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] /= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator%=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] %= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator%=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] %= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator+=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] += __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator+=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] += __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator-=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] -= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator-=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] -= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator^=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] ^= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator^=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] ^= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator&=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] &= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator&=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] &= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator|=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] |= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator|=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] |= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator<<=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] <<= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator<<=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] <<= __v[__j];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-gslice_array<_Tp>::operator>>=(const _Expr& __v) const
-{
-    typedef const size_t* _Ip;
-    size_t __j = 0;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
-        __vp_[*__i] >>= __v[__j];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void gslice_array<_Tp>::operator>>=(const _Expr& __v) const {
+  typedef const size_t* _Ip;
+  size_t __j = 0;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] >>= __v[__j];
 }
 
 template <class _Tp>
-inline
-const gslice_array<_Tp>&
-gslice_array<_Tp>::operator=(const gslice_array& __ga) const
-{
-    typedef const size_t* _Ip;
-    const value_type* __s = __ga.__vp_;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_;
-            __i != __e; ++__i, ++__j)
-        __vp_[*__i] = __s[*__j];
-    return *this;
+inline const gslice_array<_Tp>& gslice_array<_Tp>::operator=(const gslice_array& __ga) const {
+  typedef const size_t* _Ip;
+  const value_type* __s = __ga.__vp_;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ga.__1d_.__begin_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] = __s[*__j];
+  return *this;
 }
 
 template <class _Tp>
-inline
-void
-gslice_array<_Tp>::operator=(const value_type& __x) const
-{
-    typedef const size_t* _Ip;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
-        __vp_[*__i] = __x;
+inline void gslice_array<_Tp>::operator=(const value_type& __x) const {
+  typedef const size_t* _Ip;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
+    __vp_[*__i] = __x;
 }
 
 // mask_array
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS mask_array
-{
+class _LIBCPP_TEMPLATE_VIS mask_array {
 public:
-    typedef _Tp value_type;
+  typedef _Tp value_type;
 
 private:
-    value_type*      __vp_;
-    valarray<size_t> __1d_;
+  value_type* __vp_;
+  valarray<size_t> __1d_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator*=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator/=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator%=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator+=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator-=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator^=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator&=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator|=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator<<=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator>>=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
 
-    mask_array(const mask_array&) = default;
+  mask_array(const mask_array&) = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    const mask_array& operator=(const mask_array& __ma) const;
+  _LIBCPP_HIDE_FROM_ABI const mask_array& operator=(const mask_array& __ma) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator=(const value_type& __x) const;
+  _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
+
+  // Behaves like __val_expr::operator[], which returns by value.
+  _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "mask_array.__get() index out of bounds");
+    return __vp_[__1d_[__i]];
+  }
 
 private:
-    _LIBCPP_INLINE_VISIBILITY
-    mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
-          {
-              size_t __j = 0;
-              for (size_t __i = 0; __i < __vb.size(); ++__i)
-                  if (__vb[__i])
-                      __1d_[__j++] = __i;
-          }
+  _LIBCPP_HIDE_FROM_ABI mask_array(const valarray<bool>& __vb, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_)),
+        __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) {
+    size_t __j = 0;
+    for (size_t __i = 0; __i < __vb.size(); ++__i)
+      if (__vb[__i])
+        __1d_[__j++] = __i;
+  }
 
-    template <class> friend class valarray;
+  template <class>
+  friend class valarray;
 };
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] = __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] = __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator*=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] *= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator*=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] *= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator/=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] /= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator/=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] /= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator%=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] %= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator%=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] %= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator+=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] += __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator+=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] += __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator-=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] -= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator-=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] -= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator^=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] ^= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator^=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] ^= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator&=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] &= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator&=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] &= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator|=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] |= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator|=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] |= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator<<=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] <<= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator<<=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] <<= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-mask_array<_Tp>::operator>>=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] >>= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void mask_array<_Tp>::operator>>=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] >>= __v[__i];
 }
 
 template <class _Tp>
-inline
-const mask_array<_Tp>&
-mask_array<_Tp>::operator=(const mask_array& __ma) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]];
-    return *this;
+inline const mask_array<_Tp>& mask_array<_Tp>::operator=(const mask_array& __ma) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] = __ma.__vp_[__1d_[__i]];
+  return *this;
 }
 
 template <class _Tp>
-inline
-void
-mask_array<_Tp>::operator=(const value_type& __x) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] = __x;
+inline void mask_array<_Tp>::operator=(const value_type& __x) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] = __x;
 }
 
 template <class _ValExpr>
-class __mask_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+class __mask_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef value_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef value_type __result_type;
 
 private:
-    _ValExpr __expr_;
-    valarray<size_t> __1d_;
+  _ValExpr __expr_;
+  valarray<size_t> __1d_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e)
-        : __expr_(__e),
-          __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true)))
-          {
-              size_t __j = 0;
-              for (size_t __i = 0; __i < __vb.size(); ++__i)
-                  if (__vb[__i])
-                      __1d_[__j++] = __i;
-          }
+  _LIBCPP_HIDE_FROM_ABI __mask_expr(const valarray<bool>& __vb, const _RmExpr& __e)
+      : __expr_(__e), __1d_(static_cast<size_t>(count(__vb.__begin_, __vb.__end_, true))) {
+    size_t __j = 0;
+    for (size_t __i = 0; __i < __vb.size(); ++__i)
+      if (__vb[__i])
+        __1d_[__j++] = __i;
+  }
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const
-        {return __expr_[__1d_[__i]];}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __1d_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); }
 
-    template <class> friend class __val_expr;
-    template <class> friend class valarray;
+  template <class>
+  friend class __val_expr;
+  template <class>
+  friend class valarray;
 };
 
 // indirect_array
 
 template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS indirect_array
-{
+class _LIBCPP_TEMPLATE_VIS indirect_array {
 public:
-    typedef _Tp value_type;
+  typedef _Tp value_type;
 
 private:
-    value_type*      __vp_;
-    valarray<size_t> __1d_;
+  value_type* __vp_;
+  valarray<size_t> __1d_;
 
 public:
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator*=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator*=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator/=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator/=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator%=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator%=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator+=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator+=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator-=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator-=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator^=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator^=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator&=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator&=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator|=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator|=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator<<=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator<<=(const _Expr& __v) const;
 
-    template <class _Expr>
-    typename enable_if
-    <
-        __is_val_expr<_Expr>::value,
-        void
-    >::type
-    _LIBCPP_INLINE_VISIBILITY
-    operator>>=(const _Expr& __v) const;
+  template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI operator>>=(const _Expr& __v) const;
 
-    indirect_array(const indirect_array&) = default;
+  indirect_array(const indirect_array&) = default;
 
-    _LIBCPP_INLINE_VISIBILITY
-    const indirect_array& operator=(const indirect_array& __ia) const;
+  _LIBCPP_HIDE_FROM_ABI const indirect_array& operator=(const indirect_array& __ia) const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    void operator=(const value_type& __x) const;
+  _LIBCPP_HIDE_FROM_ABI void operator=(const value_type& __x) const;
+
+  // Behaves like __val_expr::operator[], which returns by value.
+  _LIBCPP_HIDE_FROM_ABI value_type __get(size_t __i) const {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < __1d_.size(), "indirect_array.__get() index out of bounds");
+    return __vp_[__1d_[__i]];
+  }
 
 private:
-     _LIBCPP_INLINE_VISIBILITY
-   indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(__ia)
-        {}
+  _LIBCPP_HIDE_FROM_ABI indirect_array(const valarray<size_t>& __ia, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(__ia) {}
 
 #ifndef _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
-        : __vp_(const_cast<value_type*>(__v.__begin_)),
-          __1d_(std::move(__ia))
-        {}
+  _LIBCPP_HIDE_FROM_ABI indirect_array(valarray<size_t>&& __ia, const valarray<value_type>& __v)
+      : __vp_(const_cast<value_type*>(__v.__begin_)), __1d_(std::move(__ia)) {}
 
 #endif // _LIBCPP_CXX03_LANG
 
-    template <class> friend class valarray;
+  template <class>
+  friend class valarray;
 };
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] = __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] = __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator*=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] *= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator*=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] *= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator/=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] /= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator/=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] /= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator%=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] %= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator%=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] %= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator+=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] += __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator+=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] += __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator-=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] -= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator-=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] -= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator^=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] ^= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator^=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] ^= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator&=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] &= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator&=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] &= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator|=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] |= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator|=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] |= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator<<=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] <<= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator<<=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] <<= __v[__i];
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    void
->::type
-indirect_array<_Tp>::operator>>=(const _Expr& __v) const
-{
-    size_t __n = __1d_.size();
-    for (size_t __i = 0; __i < __n; ++__i)
-        __vp_[__1d_[__i]] >>= __v[__i];
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline void indirect_array<_Tp>::operator>>=(const _Expr& __v) const {
+  size_t __n = __1d_.size();
+  for (size_t __i = 0; __i < __n; ++__i)
+    __vp_[__1d_[__i]] >>= __v[__i];
 }
 
 template <class _Tp>
-inline
-const indirect_array<_Tp>&
-indirect_array<_Tp>::operator=(const indirect_array& __ia) const
-{
-    typedef const size_t* _Ip;
-    const value_type* __s = __ia.__vp_;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_;
-            __i != __e; ++__i, ++__j)
-        __vp_[*__i] = __s[*__j];
-    return *this;
+inline const indirect_array<_Tp>& indirect_array<_Tp>::operator=(const indirect_array& __ia) const {
+  typedef const size_t* _Ip;
+  const value_type* __s = __ia.__vp_;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_, __j = __ia.__1d_.__begin_; __i != __e; ++__i, ++__j)
+    __vp_[*__i] = __s[*__j];
+  return *this;
 }
 
 template <class _Tp>
-inline
-void
-indirect_array<_Tp>::operator=(const value_type& __x) const
-{
-    typedef const size_t* _Ip;
-    for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
-        __vp_[*__i] = __x;
+inline void indirect_array<_Tp>::operator=(const value_type& __x) const {
+  typedef const size_t* _Ip;
+  for (_Ip __i = __1d_.__begin_, __e = __1d_.__end_; __i != __e; ++__i)
+    __vp_[*__i] = __x;
 }
 
 template <class _ValExpr>
-class __indirect_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+class __indirect_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef value_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef value_type __result_type;
 
 private:
-    _ValExpr __expr_;
-    valarray<size_t> __1d_;
+  _ValExpr __expr_;
+  valarray<size_t> __1d_;
 
-    _LIBCPP_INLINE_VISIBILITY
-    __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e)
-        : __expr_(__e),
-          __1d_(__ia)
-          {}
+  _LIBCPP_HIDE_FROM_ABI __indirect_expr(const valarray<size_t>& __ia, const _RmExpr& __e) : __expr_(__e), __1d_(__ia) {}
 
 #ifndef _LIBCPP_CXX03_LANG
 
-    _LIBCPP_INLINE_VISIBILITY
-    __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
-        : __expr_(__e),
-          __1d_(std::move(__ia))
-          {}
+  _LIBCPP_HIDE_FROM_ABI __indirect_expr(valarray<size_t>&& __ia, const _RmExpr& __e)
+      : __expr_(__e), __1d_(std::move(__ia)) {}
 
 #endif // _LIBCPP_CXX03_LANG
 
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const
-        {return __expr_[__1d_[__i]];}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__1d_[__i]]; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __1d_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __1d_.size(); }
 
-    template <class> friend class __val_expr;
-    template <class> friend class _LIBCPP_TEMPLATE_VIS valarray;
+  template <class>
+  friend class __val_expr;
+  template <class>
+  friend class _LIBCPP_TEMPLATE_VIS valarray;
 };
 
-template<class _ValExpr>
-class __val_expr
-{
-    typedef __libcpp_remove_reference_t<_ValExpr>  _RmExpr;
+template <class _ValExpr>
+class __val_expr {
+  typedef __libcpp_remove_reference_t<_ValExpr> _RmExpr;
+
+  _ValExpr __expr_;
 
-    _ValExpr __expr_;
 public:
-    typedef typename _RmExpr::value_type value_type;
-    typedef typename _RmExpr::__result_type __result_type;
+  typedef typename _RmExpr::value_type value_type;
+  typedef typename _RmExpr::__result_type __result_type;
 
-    _LIBCPP_INLINE_VISIBILITY
-    explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __val_expr(const _RmExpr& __e) : __expr_(__e) {}
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type operator[](size_t __i) const
-        {return __expr_[__i];}
+  _LIBCPP_HIDE_FROM_ABI __result_type operator[](size_t __i) const { return __expr_[__i]; }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const
-    {
-        typedef __slice_expr<_ValExpr> _NewExpr;
-        return __val_expr< _NewExpr >(_NewExpr(__s, __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<_ValExpr> > operator[](slice __s) const {
+    typedef __slice_expr<_ValExpr> _NewExpr;
+    return __val_expr< _NewExpr >(_NewExpr(__s, __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const
-    {
-        typedef __indirect_expr<_ValExpr> _NewExpr;
-        return __val_expr<_NewExpr >(_NewExpr(__gs.__1d_, __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const gslice& __gs) const {
+    typedef __indirect_expr<_ValExpr> _NewExpr;
+    return __val_expr<_NewExpr >(_NewExpr(__gs.__1d_, __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const
-    {
-        typedef __mask_expr<_ValExpr> _NewExpr;
-        return __val_expr< _NewExpr >( _NewExpr(__vb, __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<_ValExpr> > operator[](const valarray<bool>& __vb) const {
+    typedef __mask_expr<_ValExpr> _NewExpr;
+    return __val_expr< _NewExpr >(_NewExpr(__vb, __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const
-    {
-        typedef __indirect_expr<_ValExpr> _NewExpr;
-        return __val_expr< _NewExpr >(_NewExpr(__vs, __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<_ValExpr> > operator[](const valarray<size_t>& __vs) const {
+    typedef __indirect_expr<_ValExpr> _NewExpr;
+    return __val_expr< _NewExpr >(_NewExpr(__vs, __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> >
-    operator+() const
-    {
-        typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__unary_plus<value_type>, _ValExpr> > operator+() const {
+    typedef _UnaryOp<__unary_plus<value_type>, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(__unary_plus<value_type>(), __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<negate<value_type>, _ValExpr> >
-    operator-() const
-    {
-        typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<negate<value_type>, _ValExpr> > operator-() const {
+    typedef _UnaryOp<negate<value_type>, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(negate<value_type>(), __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> >
-    operator~() const
-    {
-        typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__bit_not<value_type>, _ValExpr> > operator~() const {
+    typedef _UnaryOp<__bit_not<value_type>, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(__bit_not<value_type>(), __expr_));
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> >
-    operator!() const
-    {
-        typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_));
-    }
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<logical_not<value_type>, _ValExpr> > operator!() const {
+    typedef _UnaryOp<logical_not<value_type>, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(logical_not<value_type>(), __expr_));
+  }
 
-    operator valarray<__result_type>() const;
+  operator valarray<__result_type>() const;
 
-    _LIBCPP_INLINE_VISIBILITY
-    size_t size() const {return __expr_.size();}
+  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __expr_.size(); }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type sum() const
-    {
-        size_t __n = __expr_.size();
-        __result_type __r = __n ? __expr_[0] : __result_type();
-        for (size_t __i = 1; __i < __n; ++__i)
-            __r += __expr_[__i];
-        return __r;
-    }
+  _LIBCPP_HIDE_FROM_ABI __result_type sum() const {
+    size_t __n        = __expr_.size();
+    __result_type __r = __n ? __expr_[0] : __result_type();
+    for (size_t __i = 1; __i < __n; ++__i)
+      __r += __expr_[__i];
+    return __r;
+  }
 
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type min() const
-    {
-        size_t __n = size();
-        __result_type __r = __n ? (*this)[0] : __result_type();
-        for (size_t __i = 1; __i < __n; ++__i)
-        {
-            __result_type __x = __expr_[__i];
-            if (__x < __r)
-                __r = __x;
-        }
-        return __r;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __result_type max() const
-    {
-        size_t __n = size();
-        __result_type __r = __n ? (*this)[0] : __result_type();
-        for (size_t __i = 1; __i < __n; ++__i)
-        {
-            __result_type __x = __expr_[__i];
-            if (__r < __x)
-                __r = __x;
-        }
-        return __r;
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__shift_expr<_ValExpr> > shift (int __i) const
-        {return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const
-        {return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));}
-
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(value_type)>, _ValExpr> >
-    apply(value_type __f(value_type)) const
-    {
-        typedef __apply_expr<value_type, value_type(*)(value_type)> _Op;
-        typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    __val_expr<_UnaryOp<__apply_expr<value_type, value_type(*)(const value_type&)>, _ValExpr> >
-    apply(value_type __f(const value_type&)) const
-    {
-        typedef __apply_expr<value_type, value_type(*)(const value_type&)> _Op;
-        typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
-        return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
-    }
-};
-
-template<class _ValExpr>
-__val_expr<_ValExpr>::operator valarray<__val_expr::__result_type>() const
-{
-    valarray<__result_type> __r;
-    size_t __n = __expr_.size();
-    if (__n)
-    {
-        __r.__begin_ =
-            __r.__end_ = allocator<__result_type>().allocate(__n);
-        for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
-            ::new ((void*)__r.__end_) __result_type(__expr_[__i]);
+  _LIBCPP_HIDE_FROM_ABI __result_type min() const {
+    size_t __n        = size();
+    __result_type __r = __n ? (*this)[0] : __result_type();
+    for (size_t __i = 1; __i < __n; ++__i) {
+      __result_type __x = __expr_[__i];
+      if (__x < __r)
+        __r = __x;
     }
     return __r;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __result_type max() const {
+    size_t __n        = size();
+    __result_type __r = __n ? (*this)[0] : __result_type();
+    for (size_t __i = 1; __i < __n; ++__i) {
+      __result_type __x = __expr_[__i];
+      if (__r < __x)
+        __r = __x;
+    }
+    return __r;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__shift_expr<_ValExpr> > shift(int __i) const {
+    return __val_expr<__shift_expr<_ValExpr> >(__shift_expr<_ValExpr>(__i, __expr_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __val_expr<__cshift_expr<_ValExpr> > cshift(int __i) const {
+    return __val_expr<__cshift_expr<_ValExpr> >(__cshift_expr<_ValExpr>(__i, __expr_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr<value_type, value_type (*)(value_type)>, _ValExpr> >
+  apply(value_type __f(value_type)) const {
+    typedef __apply_expr<value_type, value_type (*)(value_type)> _Op;
+    typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__apply_expr<value_type, value_type (*)(const value_type&)>, _ValExpr> >
+  apply(value_type __f(const value_type&)) const {
+    typedef __apply_expr<value_type, value_type (*)(const value_type&)> _Op;
+    typedef _UnaryOp<_Op, _ValExpr> _NewExpr;
+    return __val_expr<_NewExpr>(_NewExpr(_Op(__f), __expr_));
+  }
+};
+
+template <class _ValExpr>
+__val_expr<_ValExpr>::operator valarray<__val_expr::__result_type>() const {
+  valarray<__result_type> __r;
+  size_t __n = __expr_.size();
+  if (__n) {
+    __r.__begin_ = __r.__end_ = allocator<__result_type>().allocate(__n);
+    for (size_t __i = 0; __i != __n; ++__r.__end_, ++__i)
+      ::new ((void*)__r.__end_) __result_type(__expr_[__i]);
+  }
+  return __r;
 }
 
 // valarray
 
 template <class _Tp>
-inline
-valarray<_Tp>::valarray(size_t __n)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+inline valarray<_Tp>::valarray(size_t __n) : __begin_(nullptr), __end_(nullptr) {
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
-                ::new ((void*)__end_) value_type();
+      for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
+        ::new ((void*)__end_) value_type();
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>::valarray(const value_type& __x, size_t __n)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    resize(__n, __x);
+inline valarray<_Tp>::valarray(const value_type& __x, size_t __n) : __begin_(nullptr), __end_(nullptr) {
+  resize(__n, __x);
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(const value_type* __p, size_t __n)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+valarray<_Tp>::valarray(const value_type* __p, size_t __n) : __begin_(nullptr), __end_(nullptr) {
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left)
-                ::new ((void*)__end_) value_type(*__p);
+      for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left)
+        ::new ((void*)__end_) value_type(*__p);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(const valarray& __v)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    if (__v.size())
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__v.size());
+valarray<_Tp>::valarray(const valarray& __v) : __begin_(nullptr), __end_(nullptr) {
+  if (__v.size()) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__v.size());
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
-                ::new ((void*)__end_) value_type(*__p);
+      for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
+        ::new ((void*)__end_) value_type(*__p);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__v.size());
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__v.size());
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT
-    : __begin_(__v.__begin_),
-      __end_(__v.__end_)
-{
-    __v.__begin_ = __v.__end_ = nullptr;
+inline valarray<_Tp>::valarray(valarray&& __v) _NOEXCEPT : __begin_(__v.__begin_), __end_(__v.__end_) {
+  __v.__begin_ = __v.__end_ = nullptr;
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(initializer_list<value_type> __il)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    const size_t __n = __il.size();
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            size_t __n_left = __n;
-            for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left)
-                ::new ((void*)__end_) value_type(*__p);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+valarray<_Tp>::valarray(initializer_list<value_type> __il) : __begin_(nullptr), __end_(nullptr) {
+  const size_t __n = __il.size();
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      size_t __n_left = __n;
+      for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left)
+        ::new ((void*)__end_) value_type(*__p);
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#  endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-valarray<_Tp>::valarray(const slice_array<value_type>& __sa)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    const size_t __n = __sa.__size_;
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+valarray<_Tp>::valarray(const slice_array<value_type>& __sa) : __begin_(nullptr), __end_(nullptr) {
+  const size_t __n = __sa.__size_;
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            size_t __n_left = __n;
-            for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left)
-                ::new ((void*)__end_) value_type(*__p);
+      size_t __n_left = __n;
+      for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left)
+        ::new ((void*)__end_) value_type(*__p);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(const gslice_array<value_type>& __ga)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    const size_t __n = __ga.__1d_.size();
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+valarray<_Tp>::valarray(const gslice_array<value_type>& __ga) : __begin_(nullptr), __end_(nullptr) {
+  const size_t __n = __ga.__1d_.size();
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef const size_t* _Ip;
-            const value_type* __s = __ga.__vp_;
-            for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
-                    __i != __e; ++__i, ++__end_)
-                ::new ((void*)__end_) value_type(__s[*__i]);
+      typedef const size_t* _Ip;
+      const value_type* __s = __ga.__vp_;
+      for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__end_)
+        ::new ((void*)__end_) value_type(__s[*__i]);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(const mask_array<value_type>& __ma)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    const size_t __n = __ma.__1d_.size();
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+valarray<_Tp>::valarray(const mask_array<value_type>& __ma) : __begin_(nullptr), __end_(nullptr) {
+  const size_t __n = __ma.__1d_.size();
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef const size_t* _Ip;
-            const value_type* __s = __ma.__vp_;
-            for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
-                    __i != __e; ++__i, ++__end_)
-                ::new ((void*)__end_) value_type(__s[*__i]);
+      typedef const size_t* _Ip;
+      const value_type* __s = __ma.__vp_;
+      for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__end_)
+        ::new ((void*)__end_) value_type(__s[*__i]);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-valarray<_Tp>::valarray(const indirect_array<value_type>& __ia)
-    : __begin_(nullptr),
-      __end_(nullptr)
-{
-    const size_t __n = __ia.__1d_.size();
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+valarray<_Tp>::valarray(const indirect_array<value_type>& __ia) : __begin_(nullptr), __end_(nullptr) {
+  const size_t __n = __ia.__1d_.size();
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            typedef const size_t* _Ip;
-            const value_type* __s = __ia.__vp_;
-            for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
-                    __i != __e; ++__i, ++__end_)
-                ::new ((void*)__end_) value_type(__s[*__i]);
+      typedef const size_t* _Ip;
+      const value_type* __s = __ia.__vp_;
+      for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__end_)
+        ::new ((void*)__end_) value_type(__s[*__i]);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>::~valarray()
-{
+inline valarray<_Tp>::~valarray() {
+  __clear(size());
+}
+
+template <class _Tp>
+valarray<_Tp>& valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l) {
+  size_t __n = __l - __f;
+  if (size() != __n) {
     __clear(size());
+    __begin_ = allocator<value_type>().allocate(__n);
+    __end_   = __begin_ + __n;
+    std::uninitialized_copy(__f, __l, __begin_);
+  } else {
+    std::copy(__f, __l, __begin_);
+  }
+  return *this;
 }
 
 template <class _Tp>
-valarray<_Tp>&
-valarray<_Tp>::__assign_range(const value_type* __f, const value_type* __l)
-{
-    size_t __n = __l - __f;
-    if (size() != __n)
-    {
-        __clear(size());
-        __begin_ = allocator<value_type>().allocate(__n);
-        __end_ = __begin_ + __n;
-        _VSTD::uninitialized_copy(__f, __l, __begin_);
-    } else {
-        _VSTD::copy(__f, __l, __begin_);
-    }
-    return *this;
-}
-
-template <class _Tp>
-valarray<_Tp>&
-valarray<_Tp>::operator=(const valarray& __v)
-{
-    if (this != _VSTD::addressof(__v))
-        return __assign_range(__v.__begin_, __v.__end_);
-    return *this;
+valarray<_Tp>& valarray<_Tp>::operator=(const valarray& __v) {
+  if (this != std::addressof(__v))
+    return __assign_range(__v.__begin_, __v.__end_);
+  return *this;
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT
-{
-    __clear(size());
-    __begin_ = __v.__begin_;
-    __end_ = __v.__end_;
-    __v.__begin_ = nullptr;
-    __v.__end_ = nullptr;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(valarray&& __v) _NOEXCEPT {
+  __clear(size());
+  __begin_     = __v.__begin_;
+  __end_       = __v.__end_;
+  __v.__begin_ = nullptr;
+  __v.__end_   = nullptr;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(initializer_list<value_type> __il)
-{
-    return __assign_range(__il.begin(), __il.end());
+inline valarray<_Tp>& valarray<_Tp>::operator=(initializer_list<value_type> __il) {
+  return __assign_range(__il.begin(), __il.end());
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const value_type& __x)
-{
-    _VSTD::fill(__begin_, __end_, __x);
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const value_type& __x) {
+  std::fill(__begin_, __end_, __x);
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const slice_array<value_type>& __sa)
-{
-    value_type* __t = __begin_;
-    const value_type* __s = __sa.__vp_;
-    for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t)
-        *__t = *__s;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const slice_array<value_type>& __sa) {
+  value_type* __t       = __begin_;
+  const value_type* __s = __sa.__vp_;
+  for (size_t __n = __sa.__size_; __n; --__n, __s += __sa.__stride_, ++__t)
+    *__t = *__s;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const gslice_array<value_type>& __ga)
-{
-    typedef const size_t* _Ip;
-    value_type* __t = __begin_;
-    const value_type* __s = __ga.__vp_;
-    for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_;
-                    __i != __e; ++__i, ++__t)
-        *__t = __s[*__i];
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const gslice_array<value_type>& __ga) {
+  typedef const size_t* _Ip;
+  value_type* __t       = __begin_;
+  const value_type* __s = __ga.__vp_;
+  for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__t)
+    *__t = __s[*__i];
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const mask_array<value_type>& __ma)
-{
-    typedef const size_t* _Ip;
-    value_type* __t = __begin_;
-    const value_type* __s = __ma.__vp_;
-    for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_;
-                    __i != __e; ++__i, ++__t)
-        *__t = __s[*__i];
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const mask_array<value_type>& __ma) {
+  typedef const size_t* _Ip;
+  value_type* __t       = __begin_;
+  const value_type* __s = __ma.__vp_;
+  for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__t)
+    *__t = __s[*__i];
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const indirect_array<value_type>& __ia)
-{
-    typedef const size_t* _Ip;
-    value_type* __t = __begin_;
-    const value_type* __s = __ia.__vp_;
-    for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_;
-                    __i != __e; ++__i, ++__t)
-        *__t = __s[*__i];
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const indirect_array<value_type>& __ia) {
+  typedef const size_t* _Ip;
+  value_type* __t       = __begin_;
+  const value_type* __s = __ia.__vp_;
+  for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__t)
+    *__t = __s[*__i];
+  return *this;
 }
 
 template <class _Tp>
 template <class _ValExpr>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v)
-{
-    size_t __n = __v.size();
-    if (size() != __n)
-        resize(__n);
-    value_type* __t = __begin_;
-    for (size_t __i = 0; __i != __n; ++__t, ++__i)
-        *__t = __result_type(__v[__i]);
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v) {
+  size_t __n = __v.size();
+  if (size() != __n)
+    resize(__n);
+  value_type* __t = __begin_;
+  for (size_t __i = 0; __i != __n; ++__t, ++__i)
+    *__t = __result_type(__v[__i]);
+  return *this;
 }
 
 template <class _Tp>
-inline
-__val_expr<__slice_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](slice __s) const
-{
-    return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this));
+inline __val_expr<__slice_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](slice __s) const {
+  return __val_expr<__slice_expr<const valarray&> >(__slice_expr<const valarray&>(__s, *this));
 }
 
 template <class _Tp>
-inline
-slice_array<_Tp>
-valarray<_Tp>::operator[](slice __s)
-{
-    return slice_array<value_type>(__s, *this);
+inline slice_array<_Tp> valarray<_Tp>::operator[](slice __s) {
+  return slice_array<value_type>(__s, *this);
 }
 
 template <class _Tp>
-inline
-__val_expr<__indirect_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](const gslice& __gs) const
-{
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this));
+inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](const gslice& __gs) const {
+  return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__gs.__1d_, *this));
 }
 
 template <class _Tp>
-inline
-gslice_array<_Tp>
-valarray<_Tp>::operator[](const gslice& __gs)
-{
-    return gslice_array<value_type>(__gs, *this);
+inline gslice_array<_Tp> valarray<_Tp>::operator[](const gslice& __gs) {
+  return gslice_array<value_type>(__gs, *this);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<__indirect_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](gslice&& __gs) const
-{
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__gs.__1d_), *this));
+inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](gslice&& __gs) const {
+  return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__gs.__1d_), *this));
 }
 
 template <class _Tp>
-inline
-gslice_array<_Tp>
-valarray<_Tp>::operator[](gslice&& __gs)
-{
-    return gslice_array<value_type>(std::move(__gs), *this);
+inline gslice_array<_Tp> valarray<_Tp>::operator[](gslice&& __gs) {
+  return gslice_array<value_type>(std::move(__gs), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<__mask_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](const valarray<bool>& __vb) const
-{
-    return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this));
+inline __val_expr<__mask_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](const valarray<bool>& __vb) const {
+  return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(__vb, *this));
 }
 
 template <class _Tp>
-inline
-mask_array<_Tp>
-valarray<_Tp>::operator[](const valarray<bool>& __vb)
-{
-    return mask_array<value_type>(__vb, *this);
+inline mask_array<_Tp> valarray<_Tp>::operator[](const valarray<bool>& __vb) {
+  return mask_array<value_type>(__vb, *this);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<__mask_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](valarray<bool>&& __vb) const
-{
-    return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(std::move(__vb), *this));
+inline __val_expr<__mask_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](valarray<bool>&& __vb) const {
+  return __val_expr<__mask_expr<const valarray&> >(__mask_expr<const valarray&>(std::move(__vb), *this));
 }
 
 template <class _Tp>
-inline
-mask_array<_Tp>
-valarray<_Tp>::operator[](valarray<bool>&& __vb)
-{
-    return mask_array<value_type>(std::move(__vb), *this);
+inline mask_array<_Tp> valarray<_Tp>::operator[](valarray<bool>&& __vb) {
+  return mask_array<value_type>(std::move(__vb), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<__indirect_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](const valarray<size_t>& __vs) const
-{
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this));
+inline __val_expr<__indirect_expr<const valarray<_Tp>&> >
+valarray<_Tp>::operator[](const valarray<size_t>& __vs) const {
+  return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(__vs, *this));
 }
 
 template <class _Tp>
-inline
-indirect_array<_Tp>
-valarray<_Tp>::operator[](const valarray<size_t>& __vs)
-{
-    return indirect_array<value_type>(__vs, *this);
+inline indirect_array<_Tp> valarray<_Tp>::operator[](const valarray<size_t>& __vs) {
+  return indirect_array<value_type>(__vs, *this);
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<__indirect_expr<const valarray<_Tp>&> >
-valarray<_Tp>::operator[](valarray<size_t>&& __vs) const
-{
-    return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__vs), *this));
+inline __val_expr<__indirect_expr<const valarray<_Tp>&> > valarray<_Tp>::operator[](valarray<size_t>&& __vs) const {
+  return __val_expr<__indirect_expr<const valarray&> >(__indirect_expr<const valarray&>(std::move(__vs), *this));
 }
 
 template <class _Tp>
-inline
-indirect_array<_Tp>
-valarray<_Tp>::operator[](valarray<size_t>&& __vs)
-{
-    return indirect_array<value_type>(std::move(__vs), *this);
+inline indirect_array<_Tp> valarray<_Tp>::operator[](valarray<size_t>&& __vs) {
+  return indirect_array<value_type>(std::move(__vs), *this);
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp>
-inline
-__val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&> >
-valarray<_Tp>::operator+() const
-{
-    using _Op = _UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&>;
-    return __val_expr<_Op>(_Op(__unary_plus<_Tp>(), *this));
+inline __val_expr<_UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator+() const {
+  using _Op = _UnaryOp<__unary_plus<_Tp>, const valarray<_Tp>&>;
+  return __val_expr<_Op>(_Op(__unary_plus<_Tp>(), *this));
 }
 
 template <class _Tp>
-inline
-__val_expr<_UnaryOp<negate<_Tp>, const valarray<_Tp>&> >
-valarray<_Tp>::operator-() const
-{
-    using _Op = _UnaryOp<negate<_Tp>, const valarray<_Tp>&>;
-    return __val_expr<_Op>(_Op(negate<_Tp>(), *this));
+inline __val_expr<_UnaryOp<negate<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator-() const {
+  using _Op = _UnaryOp<negate<_Tp>, const valarray<_Tp>&>;
+  return __val_expr<_Op>(_Op(negate<_Tp>(), *this));
 }
 
 template <class _Tp>
-inline
-__val_expr<_UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&> >
-valarray<_Tp>::operator~() const
-{
-    using _Op = _UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&>;
-    return __val_expr<_Op>(_Op(__bit_not<_Tp>(), *this));
+inline __val_expr<_UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator~() const {
+  using _Op = _UnaryOp<__bit_not<_Tp>, const valarray<_Tp>&>;
+  return __val_expr<_Op>(_Op(__bit_not<_Tp>(), *this));
 }
 
 template <class _Tp>
-inline
-__val_expr<_UnaryOp<logical_not<_Tp>, const valarray<_Tp>&> >
-valarray<_Tp>::operator!() const
-{
-    using _Op = _UnaryOp<logical_not<_Tp>, const valarray<_Tp>&>;
-    return __val_expr<_Op>(_Op(logical_not<_Tp>(), *this));
+inline __val_expr<_UnaryOp<logical_not<_Tp>, const valarray<_Tp>&> > valarray<_Tp>::operator!() const {
+  using _Op = _UnaryOp<logical_not<_Tp>, const valarray<_Tp>&>;
+  return __val_expr<_Op>(_Op(logical_not<_Tp>(), *this));
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator*=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p *= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator*=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p *= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator/=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p /= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator/=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p /= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator%=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p %= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator%=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p %= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator+=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p += __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator+=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p += __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator-=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p -= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator-=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p -= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator^=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p ^= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator^=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p ^= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator&=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p &= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator&=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p &= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator|=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p |= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator|=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p |= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator<<=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p <<= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator<<=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p <<= __x;
+  return *this;
 }
 
 template <class _Tp>
-inline
-valarray<_Tp>&
-valarray<_Tp>::operator>>=(const value_type& __x)
-{
-    for (value_type* __p = __begin_; __p != __end_; ++__p)
-        *__p >>= __x;
-    return *this;
+inline valarray<_Tp>& valarray<_Tp>::operator>>=(const value_type& __x) {
+  for (value_type* __p = __begin_; __p != __end_; ++__p)
+    *__p >>= __x;
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator*=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t *= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator*=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t *= std::__get(__v, __i);
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator/=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t /= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator/=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t /= std::__get(__v, __i);
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator%=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t %= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator%=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t %= std::__get(__v, __i);
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator+=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t += __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator+=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t += std::__get(__v, __i);
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator-=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t -= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator-=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t -= std::__get(__v, __i);
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator^=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t ^= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator^=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t ^= std::__get(__v, __i);
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator|=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t |= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator|=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t |= std::__get(__v, __i);
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator&=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t &= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator&=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t &= std::__get(__v, __i);
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator<<=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t <<= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator<<=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t <<= std::__get(__v, __i);
+  return *this;
 }
 
 template <class _Tp>
-template <class _Expr>
-inline
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    valarray<_Tp>&
->::type
-valarray<_Tp>::operator>>=(const _Expr& __v)
-{
-    size_t __i = 0;
-    for (value_type* __t = __begin_; __t != __end_ ; ++__t, ++__i)
-        *__t >>= __v[__i];
-    return *this;
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> >
+inline valarray<_Tp>& valarray<_Tp>::operator>>=(const _Expr& __v) {
+  size_t __i = 0;
+  for (value_type* __t = __begin_; __t != __end_; ++__t, ++__i)
+    *__t >>= std::__get(__v, __i);
+  return *this;
 }
 
 template <class _Tp>
-inline
-void
-valarray<_Tp>::swap(valarray& __v) _NOEXCEPT
-{
-    _VSTD::swap(__begin_, __v.__begin_);
-    _VSTD::swap(__end_, __v.__end_);
+inline void valarray<_Tp>::swap(valarray& __v) _NOEXCEPT {
+  std::swap(__begin_, __v.__begin_);
+  std::swap(__end_, __v.__end_);
 }
 
 template <class _Tp>
-inline
-_Tp
-valarray<_Tp>::sum() const
-{
-    if (__begin_ == __end_)
-        return value_type();
-    const value_type* __p = __begin_;
-    _Tp __r = *__p;
-    for (++__p; __p != __end_; ++__p)
-        __r += *__p;
-    return __r;
+inline _Tp valarray<_Tp>::sum() const {
+  if (__begin_ == __end_)
+    return value_type();
+  const value_type* __p = __begin_;
+  _Tp __r               = *__p;
+  for (++__p; __p != __end_; ++__p)
+    __r += *__p;
+  return __r;
 }
 
 template <class _Tp>
-inline
-_Tp
-valarray<_Tp>::min() const
-{
-    if (__begin_ == __end_)
-        return value_type();
-    return *_VSTD::min_element(__begin_, __end_);
+inline _Tp valarray<_Tp>::min() const {
+  if (__begin_ == __end_)
+    return value_type();
+  return *std::min_element(__begin_, __end_);
 }
 
 template <class _Tp>
-inline
-_Tp
-valarray<_Tp>::max() const
-{
-    if (__begin_ == __end_)
-        return value_type();
-    return *_VSTD::max_element(__begin_, __end_);
+inline _Tp valarray<_Tp>::max() const {
+  if (__begin_ == __end_)
+    return value_type();
+  return *std::max_element(__begin_, __end_);
 }
 
 template <class _Tp>
-valarray<_Tp>
-valarray<_Tp>::shift(int __i) const
-{
-    valarray<value_type> __r;
-    size_t __n = size();
-    if (__n)
-    {
-        __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
-        const value_type* __sb;
-        value_type* __tb;
-        value_type* __te;
-        if (__i >= 0)
-        {
-            __i = _VSTD::min(__i, static_cast<int>(__n));
-            __sb = __begin_ + __i;
-            __tb = __r.__begin_;
-            __te = __r.__begin_ + (__n - __i);
-        }
-        else
-        {
-            __i = _VSTD::min(-__i, static_cast<int>(__n));
-            __sb = __begin_;
-            __tb = __r.__begin_ + __i;
-            __te = __r.__begin_ + __n;
-        }
-        for (; __r.__end_ != __tb; ++__r.__end_)
-            ::new ((void*)__r.__end_) value_type();
-        for (; __r.__end_ != __te; ++__r.__end_, ++__sb)
-            ::new ((void*)__r.__end_) value_type(*__sb);
-        for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_)
-            ::new ((void*)__r.__end_) value_type();
+valarray<_Tp> valarray<_Tp>::shift(int __i) const {
+  valarray<value_type> __r;
+  size_t __n = size();
+  if (__n) {
+    __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
+    const value_type* __sb;
+    value_type* __tb;
+    value_type* __te;
+    if (__i >= 0) {
+      __i  = std::min(__i, static_cast<int>(__n));
+      __sb = __begin_ + __i;
+      __tb = __r.__begin_;
+      __te = __r.__begin_ + (__n - __i);
+    } else {
+      __i  = std::min(-__i, static_cast<int>(__n));
+      __sb = __begin_;
+      __tb = __r.__begin_ + __i;
+      __te = __r.__begin_ + __n;
     }
-    return __r;
+    for (; __r.__end_ != __tb; ++__r.__end_)
+      ::new ((void*)__r.__end_) value_type();
+    for (; __r.__end_ != __te; ++__r.__end_, ++__sb)
+      ::new ((void*)__r.__end_) value_type(*__sb);
+    for (__te = __r.__begin_ + __n; __r.__end_ != __te; ++__r.__end_)
+      ::new ((void*)__r.__end_) value_type();
+  }
+  return __r;
 }
 
 template <class _Tp>
-valarray<_Tp>
-valarray<_Tp>::cshift(int __i) const
-{
-    valarray<value_type> __r;
-    size_t __n = size();
-    if (__n)
-    {
-        __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
-        __i %= static_cast<int>(__n);
-        const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i;
-        for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s)
-            ::new ((void*)__r.__end_) value_type(*__s);
-        for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s)
-            ::new ((void*)__r.__end_) value_type(*__s);
-    }
-    return __r;
+valarray<_Tp> valarray<_Tp>::cshift(int __i) const {
+  valarray<value_type> __r;
+  size_t __n = size();
+  if (__n) {
+    __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
+    __i %= static_cast<int>(__n);
+    const value_type* __m = __i >= 0 ? __begin_ + __i : __end_ + __i;
+    for (const value_type* __s = __m; __s != __end_; ++__r.__end_, ++__s)
+      ::new ((void*)__r.__end_) value_type(*__s);
+    for (const value_type* __s = __begin_; __s != __m; ++__r.__end_, ++__s)
+      ::new ((void*)__r.__end_) value_type(*__s);
+  }
+  return __r;
 }
 
 template <class _Tp>
-valarray<_Tp>
-valarray<_Tp>::apply(value_type __f(value_type)) const
-{
-    valarray<value_type> __r;
-    size_t __n = size();
-    if (__n)
-    {
-        __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
-        for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
-            ::new ((void*)__r.__end_) value_type(__f(*__p));
-    }
-    return __r;
+valarray<_Tp> valarray<_Tp>::apply(value_type __f(value_type)) const {
+  valarray<value_type> __r;
+  size_t __n = size();
+  if (__n) {
+    __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
+    for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
+      ::new ((void*)__r.__end_) value_type(__f(*__p));
+  }
+  return __r;
 }
 
 template <class _Tp>
-valarray<_Tp>
-valarray<_Tp>::apply(value_type __f(const value_type&)) const
-{
-    valarray<value_type> __r;
-    size_t __n = size();
-    if (__n)
-    {
-        __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
-        for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
-            ::new ((void*)__r.__end_) value_type(__f(*__p));
-    }
-    return __r;
+valarray<_Tp> valarray<_Tp>::apply(value_type __f(const value_type&)) const {
+  valarray<value_type> __r;
+  size_t __n = size();
+  if (__n) {
+    __r.__begin_ = __r.__end_ = allocator<value_type>().allocate(__n);
+    for (const value_type* __p = __begin_; __n; ++__r.__end_, ++__p, --__n)
+      ::new ((void*)__r.__end_) value_type(__f(*__p));
+  }
+  return __r;
 }
 
 template <class _Tp>
-inline
-void valarray<_Tp>::__clear(size_t __capacity)
-{
-  if (__begin_ != nullptr)
-  {
+inline void valarray<_Tp>::__clear(size_t __capacity) {
+  if (__begin_ != nullptr) {
     while (__end_ != __begin_)
       (--__end_)->~value_type();
     allocator<value_type>().deallocate(__begin_, __capacity);
@@ -3747,1184 +2632,719 @@ void valarray<_Tp>::__clear(size_t __capacity)
 }
 
 template <class _Tp>
-void
-valarray<_Tp>::resize(size_t __n, value_type __x)
-{
-    __clear(size());
-    if (__n)
-    {
-        __begin_ = __end_ = allocator<value_type>().allocate(__n);
+void valarray<_Tp>::resize(size_t __n, value_type __x) {
+  __clear(size());
+  if (__n) {
+    __begin_ = __end_ = allocator<value_type>().allocate(__n);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
-                ::new ((void*)__end_) value_type(__x);
+      for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
+        ::new ((void*)__end_) value_type(__x);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            __clear(__n);
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      __clear(__n);
+      throw;
     }
-}
-
-template<class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT
-{
-    __x.swap(__y);
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator*(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator*(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(multiplies<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<multiplies<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator*(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(multiplies<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator/(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<divides<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator/(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(divides<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<divides<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator/(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(divides<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator%(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator%(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(modulus<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<modulus<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator%(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(modulus<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator+(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<plus<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator+(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(plus<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<plus<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator+(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(plus<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator-(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<minus<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator-(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(minus<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<minus<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator-(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(minus<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator^(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator^(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(bit_xor<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator^(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(bit_xor<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator&(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator&(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(bit_and<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_and<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator&(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(bit_and<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator|(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator|(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(bit_or<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<bit_or<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator|(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(bit_or<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator<<(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator<<(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_left<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator<<(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator>>(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator>>(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__bit_shift_right<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator>>(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator&&(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator&&(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(logical_and<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_and<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator&&(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(logical_and<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator||(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator||(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(logical_or<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<logical_or<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator||(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(logical_or<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator==(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator==(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(equal_to<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<equal_to<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator==(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(equal_to<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator!=(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator!=(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(not_equal_to<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator!=(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(not_equal_to<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator<(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(less<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator<(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(less<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator<(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(less<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator>(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator>(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(greater<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator>(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(greater<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator<=(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator<=(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(less_equal<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<less_equal<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator<=(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(less_equal<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-operator>=(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-operator>=(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(greater_equal<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-operator>=(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(greater_equal<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
->::type
-abs(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
->::type
-acos(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
->::type
-asin(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
->::type
-atan(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-atan2(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-atan2(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-atan2(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__atan2_expr<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
->::type
-cos(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
->::type
-cosh(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
->::type
-exp(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
->::type
-log(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
->::type
-log10(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x));
-}
-
-template<class _Expr1, class _Expr2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value,
-    __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
->::type
-pow(const _Expr1& __x, const _Expr2& __y)
-{
-    typedef typename _Expr1::value_type value_type;
-    typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op;
-    return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
-               _Expr, __scalar_expr<typename _Expr::value_type> > >
->::type
-pow(const _Expr& __x, const typename _Expr::value_type& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
-    return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
-                           __x, __scalar_expr<value_type>(__y, __x.size())));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>,
-               __scalar_expr<typename _Expr::value_type>, _Expr> >
->::type
-pow(const typename _Expr::value_type& __x, const _Expr& __y)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__pow_expr<value_type>(),
-                           __scalar_expr<value_type>(__x, __y.size()), __y));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
->::type
-sin(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
->::type
-sinh(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
->::type
-sqrt(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
->::type
-tan(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x));
-}
-
-template<class _Expr>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_val_expr<_Expr>::value,
-    __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
->::type
-tanh(const _Expr& __x)
-{
-    typedef typename _Expr::value_type value_type;
-    typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op;
-    return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp*
-begin(valarray<_Tp>& __v)
-{
-    return __v.__begin_;
+inline _LIBCPP_HIDE_FROM_ABI void swap(valarray<_Tp>& __x, valarray<_Tp>& __y) _NOEXCEPT {
+  __x.swap(__y);
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<multiplies<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator*(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<multiplies<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator*(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<multiplies<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(multiplies<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<multiplies<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator*(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<multiplies<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(multiplies<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<divides<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator/(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<divides<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(divides<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<divides<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator/(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<divides<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(divides<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<divides<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator/(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<divides<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(divides<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<modulus<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator%(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<modulus<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<modulus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator%(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<modulus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(modulus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<modulus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator%(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<modulus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(modulus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<plus<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator+(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<plus<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(plus<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<plus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator+(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<plus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(plus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<plus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator+(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<plus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(plus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<minus<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator-(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<minus<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(minus<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<minus<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator-(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<minus<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(minus<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<minus<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator-(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<minus<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(minus<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_xor<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator^(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<bit_xor<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator^(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_xor<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(bit_xor<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<bit_xor<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator^(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_xor<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(bit_xor<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator&(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<bit_and<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator&(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(bit_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<bit_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator&(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(bit_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<bit_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator|(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<bit_or<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator|(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(bit_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<bit_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator|(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<bit_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(bit_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_left<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator<<(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<__bit_shift_left<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr< _BinaryOp<__bit_shift_left<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator<<(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__bit_shift_left<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr< _BinaryOp<__bit_shift_left<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator<<(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__bit_shift_left<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_left<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__bit_shift_right<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator>>(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<__bit_shift_right<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<
+    _BinaryOp<__bit_shift_right<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator>>(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__bit_shift_right<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr< _BinaryOp<__bit_shift_right<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator>>(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__bit_shift_right<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__bit_shift_right<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<logical_and<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator&&(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<logical_and<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator&&(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<logical_and<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(logical_and<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<logical_and<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator&&(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<logical_and<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(logical_and<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<logical_or<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator||(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<logical_or<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator||(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<logical_or<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(logical_or<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<logical_or<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator||(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<logical_or<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(logical_or<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator==(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<equal_to<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator==(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator==(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<not_equal_to<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator!=(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<not_equal_to<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator!=(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<not_equal_to<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<not_equal_to<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator!=(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<not_equal_to<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(not_equal_to<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<less<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator<(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<less<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(less<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<less<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator<(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<less<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(less<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<less<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator<(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<less<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(less<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<greater<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator>(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<greater<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(greater<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<greater<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator>(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<greater<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(greater<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<greater<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator>(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<greater<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(greater<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<less_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator<=(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<less_equal<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator<=(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<less_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(less_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<less_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator<=(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<less_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(less_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<greater_equal<typename _Expr1::value_type>, _Expr1, _Expr2> >
+operator>=(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<greater_equal<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+operator>=(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<greater_equal<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(greater_equal<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<greater_equal<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+operator>=(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<greater_equal<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(greater_equal<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
+abs(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__abs_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
+acos(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__acos_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
+asin(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__asin_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
+atan(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__atan_expr<value_type>(), __x));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
+atan2(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+atan2(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__atan2_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+atan2(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__atan2_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
+cos(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__cos_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
+cosh(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__cosh_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
+exp(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__exp_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
+log(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__log_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
+log10(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__log10_expr<value_type>(), __x));
+}
+
+template <class _Expr1,
+          class _Expr2,
+          __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
+pow(const _Expr1& __x, const _Expr2& __y) {
+  typedef typename _Expr1::value_type value_type;
+  typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op;
+  return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
+pow(const _Expr& __x, const typename _Expr::value_type& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__pow_expr<value_type>, _Expr, __scalar_expr<value_type> > _Op;
+  return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __scalar_expr<value_type>(__y, __x.size())));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI
+__val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
+pow(const typename _Expr::value_type& __x, const _Expr& __y) {
+  typedef typename _Expr::value_type value_type;
+  typedef _BinaryOp<__pow_expr<value_type>, __scalar_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __scalar_expr<value_type>(__x, __y.size()), __y));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
+sin(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__sin_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
+sinh(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__sinh_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
+sqrt(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__sqrt_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
+tan(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__tan_expr<value_type>(), __x));
+}
+
+template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
+tanh(const _Expr& __x) {
+  typedef typename _Expr::value_type value_type;
+  typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op;
+  return __val_expr<_Op>(_Op(__tanh_expr<value_type>(), __x));
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-const _Tp*
-begin(const valarray<_Tp>& __v)
-{
-    return __v.__begin_;
+inline _LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v) {
+  return __v.__begin_;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-_Tp*
-end(valarray<_Tp>& __v)
-{
-    return __v.__end_;
+inline _LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v) {
+  return __v.__begin_;
 }
 
 template <class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-const _Tp*
-end(const valarray<_Tp>& __v)
-{
-    return __v.__end_;
+inline _LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v) {
+  return __v.__end_;
+}
+
+template <class _Tp>
+inline _LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v) {
+  return __v.__end_;
 }
 
 _LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/valarray.cpp b/third_party/libcxx/valarray.cpp
new file mode 100644
index 000000000..6ef1f1caf
--- /dev/null
+++ b/third_party/libcxx/valarray.cpp
@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <valarray>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// These two symbols are part of the v1 ABI but not part of the >=v2 ABI.
+#if _LIBCPP_ABI_VERSION == 1
+template _LIBCPP_EXPORTED_FROM_ABI valarray<size_t>::valarray(size_t);
+template _LIBCPP_EXPORTED_FROM_ABI valarray<size_t>::~valarray();
+#endif
+
+template void valarray<size_t>::resize(size_t, size_t);
+
+void gslice::__init(size_t __start) {
+  valarray<size_t> __indices(__size_.size());
+  size_t __k = __size_.size() != 0;
+  for (size_t __i = 0; __i < __size_.size(); ++__i)
+    __k *= __size_[__i];
+  __1d_.resize(__k);
+  if (__1d_.size()) {
+    __k        = 0;
+    __1d_[__k] = __start;
+    while (true) {
+      size_t __i = __indices.size() - 1;
+      while (true) {
+        if (++__indices[__i] < __size_[__i]) {
+          ++__k;
+          __1d_[__k] = __1d_[__k - 1] + __stride_[__i];
+          for (size_t __j = __i + 1; __j != __indices.size(); ++__j)
+            __1d_[__k] -= __stride_[__j] * (__size_[__j] - 1);
+          break;
+        } else {
+          if (__i == 0)
+            return;
+          __indices[__i--] = 0;
+        }
+      }
+    }
+  }
+}
+
+_LIBCPP_END_NAMESPACE_STD
diff --git a/third_party/libcxx/variant b/third_party/libcxx/variant
index 2ee7f4891..5f2d03b72 100644
--- a/third_party/libcxx/variant
+++ b/third_party/libcxx/variant
@@ -42,26 +42,28 @@ namespace std {
         in_place_index_t<I>, initializer_list<U>, Args&&...);
 
     // 20.7.2.2, destructor
-    ~variant();
+    constexpr ~variant();                                             // constexpr since c++20
 
     // 20.7.2.3, assignment
     constexpr variant& operator=(const variant&);
     constexpr variant& operator=(variant&&) noexcept(see below);
 
-    template <class T> variant& operator=(T&&) noexcept(see below);
+    template <class T>
+    constexpr variant& operator=(T&&) noexcept(see below);            // constexpr since c++20
 
     // 20.7.2.4, modifiers
     template <class T, class... Args>
-    T& emplace(Args&&...);
+    constexpr T& emplace(Args&&...);                                  // constexpr since c++20
 
     template <class T, class U, class... Args>
-    T& emplace(initializer_list<U>, Args&&...);
+    constexpr T& emplace(initializer_list<U>, Args&&...);             // constexpr since c++20
 
     template <size_t I, class... Args>
-    variant_alternative_t<I, variant>& emplace(Args&&...);
+    constexpr variant_alternative_t<I, variant>& emplace(Args&&...);  // constexpr since c++20
 
     template <size_t I, class U, class...  Args>
-    variant_alternative_t<I, variant>& emplace(initializer_list<U>, Args&&...);
+    constexpr variant_alternative_t<I, variant>&
+        emplace(initializer_list<U>, Args&&...);                      // constexpr since c++20
 
     // 20.7.2.5, value status
     constexpr bool valueless_by_exception() const noexcept;
@@ -69,6 +71,12 @@ namespace std {
 
     // 20.7.2.6, swap
     void swap(variant&) noexcept(see below);
+
+    // [variant.visit], visitation
+    template<class Self, class Visitor>
+      constexpr decltype(auto) visit(this Self&&, Visitor&&); // Since C++26
+    template<class R, class Self, class Visitor>
+      constexpr R visit(this Self&&, Visitor&&);              // Since C++26
   };
 
   // 20.7.3, variant helper classes
@@ -204,8 +212,6 @@ namespace std {
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <__availability>
 #include <__compare/common_comparison_category.h>
 #include <__compare/compare_three_way_result.h>
 #include <__compare/three_way_comparable.h>
@@ -216,26 +222,36 @@ namespace std {
 #include <__functional/operations.h>
 #include <__functional/unary_function.h>
 #include <__memory/addressof.h>
+#include <__memory/construct_at.h>
+#include <__tuple/find_index.h>
+#include <__tuple/sfinae_helpers.h>
 #include <__type_traits/add_const.h>
 #include <__type_traits/add_cv.h>
 #include <__type_traits/add_pointer.h>
 #include <__type_traits/add_volatile.h>
+#include <__type_traits/common_type.h>
+#include <__type_traits/conjunction.h>
 #include <__type_traits/dependent_type.h>
 #include <__type_traits/is_array.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/is_destructible.h>
-#include <__type_traits/is_nothrow_move_constructible.h>
-#include <__type_traits/is_trivially_copy_assignable.h>
-#include <__type_traits/is_trivially_copy_constructible.h>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_reference.h>
+#include <__type_traits/is_trivially_assignable.h>
+#include <__type_traits/is_trivially_constructible.h>
 #include <__type_traits/is_trivially_destructible.h>
-#include <__type_traits/is_trivially_move_assignable.h>
-#include <__type_traits/is_trivially_move_constructible.h>
+#include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/remove_const.h>
+#include <__type_traits/remove_cvref.h>
 #include <__type_traits/type_identity.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/forward_like.h>
 #include <__utility/in_place.h>
+#include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 #include <__variant/monostate.h>
@@ -243,7 +259,6 @@ namespace std {
 #include <initializer_list>
 #include <limits>
 #include <new>
-#include <tuple>
 #include <version>
 
 // standard-mandated includes
@@ -260,9 +275,9 @@ _LIBCPP_PUSH_MACROS
 
 namespace std { // explicitly not using versioning namespace
 
-class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS bad_variant_access : public exception {
+class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_BAD_VARIANT_ACCESS bad_variant_access : public exception {
 public:
-   const char* what() const _NOEXCEPT override;
+  const char* what() const _NOEXCEPT override;
 };
 
 } // namespace std
@@ -273,26 +288,21 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 // Light N-dimensional array of function pointers. Used in place of std::array to avoid
 // adding a dependency.
-template<class _Tp, size_t _Size>
+template <class _Tp, size_t _Size>
 struct __farray {
   static_assert(_Size > 0, "N-dimensional array should never be empty in std::visit");
   _Tp __buf_[_Size] = {};
 
-  _LIBCPP_INLINE_VISIBILITY constexpr
-  const _Tp &operator[](size_t __n) const noexcept {
-      return __buf_[__n];
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator[](size_t __n) const noexcept { return __buf_[__n]; }
 };
 
-_LIBCPP_NORETURN
-inline _LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-void __throw_bad_variant_access() {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        throw bad_variant_access();
-#else
-    _LIBCPP_VERBOSE_ABORT("bad_variant_access was thrown in -fno-exceptions mode");
-#endif
+_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS void
+__throw_bad_variant_access() {
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+  throw bad_variant_access();
+#  else
+  _LIBCPP_VERBOSE_ABORT("bad_variant_access was thrown in -fno-exceptions mode");
+#  endif
 }
 
 template <class... _Types>
@@ -311,12 +321,10 @@ template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS variant_size<volatile _Tp> : variant_size<_Tp> {};
 
 template <class _Tp>
-struct _LIBCPP_TEMPLATE_VIS variant_size<const volatile _Tp>
-    : variant_size<_Tp> {};
+struct _LIBCPP_TEMPLATE_VIS variant_size<const volatile _Tp> : variant_size<_Tp> {};
 
 template <class... _Types>
-struct _LIBCPP_TEMPLATE_VIS variant_size<variant<_Types...>>
-    : integral_constant<size_t, sizeof...(_Types)> {};
+struct _LIBCPP_TEMPLATE_VIS variant_size<variant<_Types...>> : integral_constant<size_t, sizeof...(_Types)> {};
 
 template <size_t _Ip, class _Tp>
 struct _LIBCPP_TEMPLATE_VIS variant_alternative;
@@ -325,16 +333,13 @@ template <size_t _Ip, class _Tp>
 using variant_alternative_t = typename variant_alternative<_Ip, _Tp>::type;
 
 template <size_t _Ip, class _Tp>
-struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const _Tp>
-    : add_const<variant_alternative_t<_Ip, _Tp>> {};
+struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const _Tp> : add_const<variant_alternative_t<_Ip, _Tp>> {};
 
 template <size_t _Ip, class _Tp>
-struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, volatile _Tp>
-    : add_volatile<variant_alternative_t<_Ip, _Tp>> {};
+struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, volatile _Tp> : add_volatile<variant_alternative_t<_Ip, _Tp>> {};
 
 template <size_t _Ip, class _Tp>
-struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const volatile _Tp>
-    : add_cv<variant_alternative_t<_Ip, _Tp>> {};
+struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, const volatile _Tp> : add_cv<variant_alternative_t<_Ip, _Tp>> {};
 
 template <size_t _Ip, class... _Types>
 struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, variant<_Types...>> {
@@ -344,24 +349,20 @@ struct _LIBCPP_TEMPLATE_VIS variant_alternative<_Ip, variant<_Types...>> {
 
 inline constexpr size_t variant_npos = static_cast<size_t>(-1);
 
-_LIBCPP_HIDE_FROM_ABI constexpr int __choose_index_type(unsigned int __num_elem) {
-  if (__num_elem < numeric_limits<unsigned char>::max())
-    return 0;
-  if (__num_elem < numeric_limits<unsigned short>::max())
-    return 1;
-  return 2;
+template <size_t _NumAlternatives>
+_LIBCPP_HIDE_FROM_ABI constexpr auto __choose_index_type() {
+#  ifdef _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
+  if constexpr (_NumAlternatives < numeric_limits<unsigned char>::max())
+    return static_cast<unsigned char>(0);
+  else if constexpr (_NumAlternatives < numeric_limits<unsigned short>::max())
+    return static_cast<unsigned short>(0);
+  else
+#  endif // _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
+    return static_cast<unsigned int>(0);
 }
 
 template <size_t _NumAlts>
-using __variant_index_t =
-#ifndef _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
-  unsigned int;
-#else
-  std::tuple_element_t<
-      __choose_index_type(_NumAlts),
-      std::tuple<unsigned char, unsigned short, unsigned int>
-  >;
-#endif
+using __variant_index_t = decltype(std::__choose_index_type<_NumAlts>());
 
 template <class _IndexType>
 constexpr _IndexType __variant_npos = static_cast<_IndexType>(-1);
@@ -370,36 +371,31 @@ template <class... _Types>
 class _LIBCPP_TEMPLATE_VIS variant;
 
 template <class... _Types>
-_LIBCPP_INLINE_VISIBILITY constexpr variant<_Types...>&
-__as_variant(variant<_Types...>& __vs) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr variant<_Types...>& __as_variant(variant<_Types...>& __vs) noexcept {
   return __vs;
 }
 
 template <class... _Types>
-_LIBCPP_INLINE_VISIBILITY constexpr const variant<_Types...>&
-__as_variant(const variant<_Types...>& __vs) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr const variant<_Types...>& __as_variant(const variant<_Types...>& __vs) noexcept {
   return __vs;
 }
 
 template <class... _Types>
-_LIBCPP_INLINE_VISIBILITY constexpr variant<_Types...>&&
-__as_variant(variant<_Types...>&& __vs) noexcept {
-  return _VSTD::move(__vs);
+_LIBCPP_HIDE_FROM_ABI constexpr variant<_Types...>&& __as_variant(variant<_Types...>&& __vs) noexcept {
+  return std::move(__vs);
 }
 
 template <class... _Types>
-_LIBCPP_INLINE_VISIBILITY constexpr const variant<_Types...>&&
-__as_variant(const variant<_Types...>&& __vs) noexcept {
-  return _VSTD::move(__vs);
+_LIBCPP_HIDE_FROM_ABI constexpr const variant<_Types...>&& __as_variant(const variant<_Types...>&& __vs) noexcept {
+  return std::move(__vs);
 }
 
 namespace __find_detail {
 
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr size_t __find_index() {
+_LIBCPP_HIDE_FROM_ABI constexpr size_t __find_index() {
   constexpr bool __matches[] = {is_same_v<_Tp, _Types>...};
-  size_t __result = __not_found;
+  size_t __result            = __not_found;
   for (size_t __i = 0; __i < sizeof...(_Types); ++__i) {
     if (__matches[__i]) {
       if (__result != __not_found) {
@@ -412,8 +408,7 @@ constexpr size_t __find_index() {
 }
 
 template <size_t _Index>
-struct __find_unambiguous_index_sfinae_impl
-    : integral_constant<size_t, _Index> {};
+struct __find_unambiguous_index_sfinae_impl : integral_constant<size_t, _Index> {};
 
 template <>
 struct __find_unambiguous_index_sfinae_impl<__not_found> {};
@@ -422,8 +417,7 @@ template <>
 struct __find_unambiguous_index_sfinae_impl<__ambiguous> {};
 
 template <class _Tp, class... _Types>
-struct __find_unambiguous_index_sfinae
-    : __find_unambiguous_index_sfinae_impl<__find_index<_Tp, _Types...>()> {};
+struct __find_unambiguous_index_sfinae : __find_unambiguous_index_sfinae_impl<__find_index<_Tp, _Types...>()> {};
 
 } // namespace __find_detail
 
@@ -433,16 +427,14 @@ struct __valueless_t {};
 
 enum class _Trait { _TriviallyAvailable, _Available, _Unavailable };
 
-template <typename _Tp,
-          template <typename> class _IsTriviallyAvailable,
-          template <typename> class _IsAvailable>
+template <typename _Tp, template <typename> class _IsTriviallyAvailable, template <typename> class _IsAvailable>
 constexpr _Trait __trait =
-    _IsTriviallyAvailable<_Tp>::value
-        ? _Trait::_TriviallyAvailable
-        : _IsAvailable<_Tp>::value ? _Trait::_Available : _Trait::_Unavailable;
+    _IsTriviallyAvailable<_Tp>::value ? _Trait::_TriviallyAvailable
+    : _IsAvailable<_Tp>::value
+        ? _Trait::_Available
+        : _Trait::_Unavailable;
 
-_LIBCPP_HIDE_FROM_ABI
-constexpr _Trait __common_trait(initializer_list<_Trait> __traits) {
+_LIBCPP_HIDE_FROM_ABI constexpr _Trait __common_trait(initializer_list<_Trait> __traits) {
   _Trait __result = _Trait::_TriviallyAvailable;
   for (_Trait __t : __traits) {
     if (static_cast<int>(__t) > static_cast<int>(__result)) {
@@ -455,57 +447,46 @@ constexpr _Trait __common_trait(initializer_list<_Trait> __traits) {
 template <typename... _Types>
 struct __traits {
   static constexpr _Trait __copy_constructible_trait =
-      __variant_detail::__common_trait({__trait<_Types,
-                              is_trivially_copy_constructible,
-                              is_copy_constructible>...});
+      __variant_detail::__common_trait({__trait<_Types, is_trivially_copy_constructible, is_copy_constructible>...});
 
   static constexpr _Trait __move_constructible_trait =
-      __variant_detail::__common_trait({__trait<_Types,
-                              is_trivially_move_constructible,
-                              is_move_constructible>...});
+      __variant_detail::__common_trait({__trait<_Types, is_trivially_move_constructible, is_move_constructible>...});
 
   static constexpr _Trait __copy_assignable_trait = __variant_detail::__common_trait(
-      {__copy_constructible_trait,
-       __trait<_Types, is_trivially_copy_assignable, is_copy_assignable>...});
+      {__copy_constructible_trait, __trait<_Types, is_trivially_copy_assignable, is_copy_assignable>...});
 
   static constexpr _Trait __move_assignable_trait = __variant_detail::__common_trait(
-      {__move_constructible_trait,
-       __trait<_Types, is_trivially_move_assignable, is_move_assignable>...});
+      {__move_constructible_trait, __trait<_Types, is_trivially_move_assignable, is_move_assignable>...});
 
-  static constexpr _Trait __destructible_trait = __variant_detail::__common_trait(
-      {__trait<_Types, is_trivially_destructible, is_destructible>...});
+  static constexpr _Trait __destructible_trait =
+      __variant_detail::__common_trait({__trait<_Types, is_trivially_destructible, is_destructible>...});
 };
 
 namespace __access {
 
 struct __union {
   template <class _Vp>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) {
-    return _VSTD::forward<_Vp>(__v).__head;
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) {
+    return std::forward<_Vp>(__v).__head;
   }
 
   template <class _Vp, size_t _Ip>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) {
-    return __get_alt(_VSTD::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>);
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) {
+    return __get_alt(std::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>);
   }
 };
 
 struct __base {
   template <size_t _Ip, class _Vp>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto&& __get_alt(_Vp&& __v) {
-    return __union::__get_alt(_VSTD::forward<_Vp>(__v).__data,
-                              in_place_index<_Ip>);
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto&& __get_alt(_Vp&& __v) {
+    return __union::__get_alt(std::forward<_Vp>(__v).__data, in_place_index<_Ip>);
   }
 };
 
 struct __variant {
   template <size_t _Ip, class _Vp>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto&& __get_alt(_Vp&& __v) {
-    return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl_);
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto&& __get_alt(_Vp&& __v) {
+    return __base::__get_alt<_Ip>(std::forward<_Vp>(__v).__impl_);
   }
 };
 
@@ -515,111 +496,86 @@ namespace __visitation {
 
 struct __base {
   template <class _Visitor, class... _Vs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr decltype(auto)
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto)
   __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
-    constexpr auto __fdiagonal =
-        __make_fdiagonal<_Visitor&&,
-                         decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
-    return __fdiagonal[__index](_VSTD::forward<_Visitor>(__visitor),
-                                _VSTD::forward<_Vs>(__vs).__as_base()...);
+    constexpr auto __fdiagonal = __make_fdiagonal<_Visitor&&, decltype(std::forward<_Vs>(__vs).__as_base())...>();
+    return __fdiagonal[__index](std::forward<_Visitor>(__visitor), std::forward<_Vs>(__vs).__as_base()...);
   }
 
   template <class _Visitor, class... _Vs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
-                                              _Vs&&... __vs) {
-    constexpr auto __fmatrix =
-        __make_fmatrix<_Visitor&&,
-                       decltype(_VSTD::forward<_Vs>(__vs).__as_base())...>();
-    return __at(__fmatrix, __vs.index()...)(
-        _VSTD::forward<_Visitor>(__visitor),
-        _VSTD::forward<_Vs>(__vs).__as_base()...);
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor, _Vs&&... __vs) {
+    constexpr auto __fmatrix = __make_fmatrix<_Visitor&&, decltype(std::forward<_Vs>(__vs).__as_base())...>();
+    return __at(__fmatrix, __vs.index()...)(std::forward<_Visitor>(__visitor), std::forward<_Vs>(__vs).__as_base()...);
   }
 
 private:
   template <class _Tp>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr const _Tp& __at(const _Tp& __elem) { return __elem; }
+  _LIBCPP_HIDE_FROM_ABI static constexpr const _Tp& __at(const _Tp& __elem) {
+    return __elem;
+  }
 
   template <class _Tp, size_t _Np, typename... _Indices>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto&& __at(const __farray<_Tp, _Np>& __elems,
-                               size_t __index, _Indices... __indices) {
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto&&
+  __at(const __farray<_Tp, _Np>& __elems, size_t __index, _Indices... __indices) {
     return __at(__elems[__index], __indices...);
   }
 
   template <class _Fp, class... _Fs>
   static _LIBCPP_HIDE_FROM_ABI constexpr void __std_visit_visitor_return_type_check() {
     static_assert(
-        __all<is_same_v<_Fp, _Fs>...>::value,
-        "`std::visit` requires the visitor to have a single return type.");
+        __all<is_same_v<_Fp, _Fs>...>::value, "`std::visit` requires the visitor to have a single return type.");
   }
 
   template <class... _Fs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto __make_farray(_Fs&&... __fs) {
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __make_farray(_Fs&&... __fs) {
     __std_visit_visitor_return_type_check<__remove_cvref_t<_Fs>...>();
     using __result = __farray<common_type_t<__remove_cvref_t<_Fs>...>, sizeof...(_Fs)>;
-    return __result{{_VSTD::forward<_Fs>(__fs)...}};
+    return __result{{std::forward<_Fs>(__fs)...}};
   }
 
   template <size_t... _Is>
   struct __dispatcher {
     template <class _Fp, class... _Vs>
-    _LIBCPP_HIDE_FROM_ABI
-    static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
-        return _VSTD::__invoke(
-            static_cast<_Fp>(__f),
-            __access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...);
+    _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto) __dispatch(_Fp __f, _Vs... __vs) {
+      return std::__invoke(static_cast<_Fp>(__f), __access::__base::__get_alt<_Is>(static_cast<_Vs>(__vs))...);
     }
   };
 
   template <class _Fp, class... _Vs, size_t... _Is>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto __make_dispatch(index_sequence<_Is...>) {
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __make_dispatch(index_sequence<_Is...>) {
     return __dispatcher<_Is...>::template __dispatch<_Fp, _Vs...>;
   }
 
   template <size_t _Ip, class _Fp, class... _Vs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto __make_fdiagonal_impl() {
-    return __make_dispatch<_Fp, _Vs...>(
-        index_sequence<((void)__type_identity<_Vs>{}, _Ip)...>{});
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __make_fdiagonal_impl() {
+    return __make_dispatch<_Fp, _Vs...>(index_sequence<((void)__type_identity<_Vs>{}, _Ip)...>{});
   }
 
   template <class _Fp, class... _Vs, size_t... _Is>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) {
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __make_fdiagonal_impl(index_sequence<_Is...>) {
     return __base::__make_farray(__make_fdiagonal_impl<_Is, _Fp, _Vs...>()...);
   }
 
   template <class _Fp, class _Vp, class... _Vs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto __make_fdiagonal() {
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __make_fdiagonal() {
     constexpr size_t __np = __remove_cvref_t<_Vp>::__size();
     static_assert(__all<(__np == __remove_cvref_t<_Vs>::__size())...>::value);
     return __make_fdiagonal_impl<_Fp, _Vp, _Vs...>(make_index_sequence<__np>{});
   }
 
   template <class _Fp, class... _Vs, size_t... _Is>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) {
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __make_fmatrix_impl(index_sequence<_Is...> __is) {
     return __make_dispatch<_Fp, _Vs...>(__is);
   }
 
   template <class _Fp, class... _Vs, size_t... _Is, size_t... _Js, class... _Ls>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto __make_fmatrix_impl(index_sequence<_Is...>,
-                                            index_sequence<_Js...>,
-                                            _Ls... __ls) {
-    return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(
-        index_sequence<_Is..., _Js>{}, __ls...)...);
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto
+  __make_fmatrix_impl(index_sequence<_Is...>, index_sequence<_Js...>, _Ls... __ls) {
+    return __base::__make_farray(__make_fmatrix_impl<_Fp, _Vs...>(index_sequence<_Is..., _Js>{}, __ls...)...);
   }
 
   template <class _Fp, class... _Vs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto __make_fmatrix() {
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __make_fmatrix() {
     return __make_fmatrix_impl<_Fp, _Vs...>(
         index_sequence<>{}, make_index_sequence<__remove_cvref_t<_Vs>::__size()>{}...);
   }
@@ -627,122 +583,95 @@ private:
 
 struct __variant {
   template <class _Visitor, class... _Vs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr decltype(auto)
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto)
   __visit_alt_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
-    return __base::__visit_alt_at(__index,
-                                  _VSTD::forward<_Visitor>(__visitor),
-                                  _VSTD::forward<_Vs>(__vs).__impl_...);
+    return __base::__visit_alt_at(__index, std::forward<_Visitor>(__visitor), std::forward<_Vs>(__vs).__impl_...);
   }
 
   template <class _Visitor, class... _Vs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor,
-                                              _Vs&&... __vs) {
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto) __visit_alt(_Visitor&& __visitor, _Vs&&... __vs) {
     return __base::__visit_alt(
-        _VSTD::forward<_Visitor>(__visitor),
-        _VSTD::__as_variant(_VSTD::forward<_Vs>(__vs)).__impl_...);
+        std::forward<_Visitor>(__visitor), std::__as_variant(std::forward<_Vs>(__vs)).__impl_...);
   }
 
   template <class _Visitor, class... _Vs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr decltype(auto)
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto)
   __visit_value_at(size_t __index, _Visitor&& __visitor, _Vs&&... __vs) {
-    return __visit_alt_at(
-        __index,
-        __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
-        _VSTD::forward<_Vs>(__vs)...);
+    return __visit_alt_at(__index, __make_value_visitor(std::forward<_Visitor>(__visitor)), std::forward<_Vs>(__vs)...);
   }
 
   template <class _Visitor, class... _Vs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr decltype(auto) __visit_value(_Visitor&& __visitor,
-                                                _Vs&&... __vs) {
-    return __visit_alt(
-        __make_value_visitor(_VSTD::forward<_Visitor>(__visitor)),
-        _VSTD::forward<_Vs>(__vs)...);
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto) __visit_value(_Visitor&& __visitor, _Vs&&... __vs) {
+    return __visit_alt(__make_value_visitor(std::forward<_Visitor>(__visitor)), std::forward<_Vs>(__vs)...);
   }
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
   template <class _Rp, class _Visitor, class... _Vs>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr _Rp __visit_value(_Visitor&& __visitor,
-                                     _Vs&&... __vs) {
-    return __visit_alt(
-        __make_value_visitor<_Rp>(_VSTD::forward<_Visitor>(__visitor)),
-        _VSTD::forward<_Vs>(__vs)...);
+  _LIBCPP_HIDE_FROM_ABI static constexpr _Rp __visit_value(_Visitor&& __visitor, _Vs&&... __vs) {
+    return __visit_alt(__make_value_visitor<_Rp>(std::forward<_Visitor>(__visitor)), std::forward<_Vs>(__vs)...);
   }
-#endif
+#  endif
 
 private:
   template <class _Visitor, class... _Values>
   static _LIBCPP_HIDE_FROM_ABI constexpr void __std_visit_exhaustive_visitor_check() {
-    static_assert(is_invocable_v<_Visitor, _Values...>,
-                  "`std::visit` requires the visitor to be exhaustive.");
+    static_assert(is_invocable_v<_Visitor, _Values...>, "`std::visit` requires the visitor to be exhaustive.");
   }
 
   template <class _Visitor>
   struct __value_visitor {
     template <class... _Alts>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr decltype(auto) operator()(_Alts&&... __alts) const {
-      __std_visit_exhaustive_visitor_check<
-          _Visitor,
-          decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
-      return _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
-                             _VSTD::forward<_Alts>(__alts).__value...);
+    _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator()(_Alts&&... __alts) const {
+      __std_visit_exhaustive_visitor_check< _Visitor, decltype((std::forward<_Alts>(__alts).__value))...>();
+      return std::__invoke(std::forward<_Visitor>(__visitor), std::forward<_Alts>(__alts).__value...);
     }
     _Visitor&& __visitor;
   };
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
   template <class _Rp, class _Visitor>
   struct __value_visitor_return_type {
     template <class... _Alts>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr _Rp operator()(_Alts&&... __alts) const {
-      __std_visit_exhaustive_visitor_check<
-          _Visitor,
-          decltype((_VSTD::forward<_Alts>(__alts).__value))...>();
+    _LIBCPP_HIDE_FROM_ABI constexpr _Rp operator()(_Alts&&... __alts) const {
+      __std_visit_exhaustive_visitor_check< _Visitor, decltype((std::forward<_Alts>(__alts).__value))...>();
       if constexpr (is_void_v<_Rp>) {
-        _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
-                        _VSTD::forward<_Alts>(__alts).__value...);
-      }
-      else {
-        return _VSTD::__invoke(_VSTD::forward<_Visitor>(__visitor),
-                               _VSTD::forward<_Alts>(__alts).__value...);
+        std::__invoke(std::forward<_Visitor>(__visitor), std::forward<_Alts>(__alts).__value...);
+      } else {
+        return std::__invoke(std::forward<_Visitor>(__visitor), std::forward<_Alts>(__alts).__value...);
       }
     }
 
     _Visitor&& __visitor;
   };
-#endif
+#  endif
 
   template <class _Visitor>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
-    return __value_visitor<_Visitor>{_VSTD::forward<_Visitor>(__visitor)};
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
+    return __value_visitor<_Visitor>{std::forward<_Visitor>(__visitor)};
   }
 
-#if _LIBCPP_STD_VER >= 20
+#  if _LIBCPP_STD_VER >= 20
   template <class _Rp, class _Visitor>
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
-    return __value_visitor_return_type<_Rp, _Visitor>{_VSTD::forward<_Visitor>(__visitor)};
+  _LIBCPP_HIDE_FROM_ABI static constexpr auto __make_value_visitor(_Visitor&& __visitor) {
+    return __value_visitor_return_type<_Rp, _Visitor>{std::forward<_Visitor>(__visitor)};
   }
-#endif
+#  endif
 };
 
 } // namespace __visitation
 
+// Adding semi-colons in macro expansions helps clang-format to do a better job.
+// This macro is used to avoid compilation errors due to "stray" semi-colons.
+#  define _LIBCPP_EAT_SEMICOLON static_assert(true, "")
+
 template <size_t _Index, class _Tp>
 struct _LIBCPP_TEMPLATE_VIS __alt {
-  using __value_type = _Tp;
+  using __value_type              = _Tp;
+  static constexpr size_t __index = _Index;
 
   template <class... _Args>
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr __alt(in_place_t, _Args&&... __args)
-      : __value(_VSTD::forward<_Args>(__args)...) {}
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr __alt(in_place_t, _Args&&... __args)
+      : __value(std::forward<_Args>(__args)...) {}
 
   __value_type __value;
 };
@@ -753,89 +682,70 @@ union _LIBCPP_TEMPLATE_VIS __union;
 template <_Trait _DestructibleTrait, size_t _Index>
 union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
 
-#define _LIBCPP_VARIANT_UNION(destructible_trait, destructor)                  \
-  template <size_t _Index, class _Tp, class... _Types>                         \
-  union _LIBCPP_TEMPLATE_VIS __union<destructible_trait,                       \
-                                      _Index,                                  \
-                                      _Tp,                                     \
-                                      _Types...> {                             \
-  public:                                                                      \
-    _LIBCPP_HIDE_FROM_ABI                                                      \
-    explicit constexpr __union(__valueless_t) noexcept : __dummy{} {}          \
-                                                                               \
-    template <class... _Args>                                                  \
-    _LIBCPP_HIDE_FROM_ABI                                                      \
-    explicit constexpr __union(in_place_index_t<0>, _Args&&... __args)         \
-        : __head(in_place, _VSTD::forward<_Args>(__args)...) {}                \
-                                                                               \
-    template <size_t _Ip, class... _Args>                                      \
-    _LIBCPP_HIDE_FROM_ABI                                                      \
-    explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args)       \
-        : __tail(in_place_index<_Ip - 1>, _VSTD::forward<_Args>(__args)...) {} \
-                                                                               \
-    __union(const __union&) = default;                                         \
-    __union(__union&&) = default;                                              \
-                                                                               \
-    destructor                                                                 \
-                                                                               \
-    __union& operator=(const __union&) = default;                              \
-    __union& operator=(__union&&) = default;                                   \
-                                                                               \
-  private:                                                                     \
-    char __dummy;                                                              \
-    __alt<_Index, _Tp> __head;                                                 \
-    __union<destructible_trait, _Index + 1, _Types...> __tail;                 \
-                                                                               \
-    friend struct __access::__union;                                           \
-  }
+#  define _LIBCPP_VARIANT_UNION(destructible_trait, destructor_definition)                                             \
+    template <size_t _Index, class _Tp, class... _Types>                                                               \
+    union _LIBCPP_TEMPLATE_VIS __union<destructible_trait, _Index, _Tp, _Types...> {                                   \
+    public:                                                                                                            \
+      _LIBCPP_HIDE_FROM_ABI explicit constexpr __union(__valueless_t) noexcept : __dummy{} {}                          \
+                                                                                                                       \
+      template <class... _Args>                                                                                        \
+      _LIBCPP_HIDE_FROM_ABI explicit constexpr __union(in_place_index_t<0>, _Args&&... __args)                         \
+          : __head(in_place, std::forward<_Args>(__args)...) {}                                                        \
+                                                                                                                       \
+      template <size_t _Ip, class... _Args>                                                                            \
+      _LIBCPP_HIDE_FROM_ABI explicit constexpr __union(in_place_index_t<_Ip>, _Args&&... __args)                       \
+          : __tail(in_place_index<_Ip - 1>, std::forward<_Args>(__args)...) {}                                         \
+                                                                                                                       \
+      _LIBCPP_HIDE_FROM_ABI __union(const __union&)            = default;                                              \
+      _LIBCPP_HIDE_FROM_ABI __union(__union&&)                 = default;                                              \
+      _LIBCPP_HIDE_FROM_ABI __union& operator=(const __union&) = default;                                              \
+      _LIBCPP_HIDE_FROM_ABI __union& operator=(__union&&)      = default;                                              \
+      destructor_definition;                                                                                           \
+                                                                                                                       \
+    private:                                                                                                           \
+      char __dummy;                                                                                                    \
+      __alt<_Index, _Tp> __head;                                                                                       \
+      __union<destructible_trait, _Index + 1, _Types...> __tail;                                                       \
+                                                                                                                       \
+      friend struct __access::__union;                                                                                 \
+    }
 
-_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable, ~__union() = default;);
-_LIBCPP_VARIANT_UNION(_Trait::_Available, ~__union() {});
-_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, ~__union() = delete;);
+_LIBCPP_VARIANT_UNION(_Trait::_TriviallyAvailable,
+                      _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union() = default);
+_LIBCPP_VARIANT_UNION(
+    _Trait::_Available, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union() {} _LIBCPP_EAT_SEMICOLON);
+_LIBCPP_VARIANT_UNION(_Trait::_Unavailable, _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__union() = delete);
 
-#undef _LIBCPP_VARIANT_UNION
+#  undef _LIBCPP_VARIANT_UNION
 
 template <_Trait _DestructibleTrait, class... _Types>
 class _LIBCPP_TEMPLATE_VIS __base {
 public:
   using __index_t = __variant_index_t<sizeof...(_Types)>;
 
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr __base(__valueless_t __tag) noexcept
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr __base(__valueless_t __tag) noexcept
       : __data(__tag), __index(__variant_npos<__index_t>) {}
 
   template <size_t _Ip, class... _Args>
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args)
-      :
-        __data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...),
-        __index(_Ip) {}
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args)
+      : __data(in_place_index<_Ip>, std::forward<_Args>(__args)...), __index(_Ip) {}
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr bool valueless_by_exception() const noexcept {
-    return index() == variant_npos;
-  }
+  _LIBCPP_HIDE_FROM_ABI constexpr bool valueless_by_exception() const noexcept { return index() == variant_npos; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr size_t index() const noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr size_t index() const noexcept {
     return __index == __variant_npos<__index_t> ? variant_npos : __index;
   }
 
 protected:
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto&& __as_base() & { return *this; }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto&& __as_base() & { return *this; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto&& __as_base() && { return _VSTD::move(*this); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto&& __as_base() && { return std::move(*this); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto&& __as_base() const & { return *this; }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto&& __as_base() const& { return *this; }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr auto&& __as_base() const && { return _VSTD::move(*this); }
+  _LIBCPP_HIDE_FROM_ABI constexpr auto&& __as_base() const&& { return std::move(*this); }
 
-  _LIBCPP_HIDE_FROM_ABI
-  static constexpr size_t __size() { return sizeof...(_Types); }
+  _LIBCPP_HIDE_FROM_ABI static constexpr size_t __size() { return sizeof...(_Types); }
 
   __union<_DestructibleTrait, 0, _Types...> __data;
   __index_t __index;
@@ -847,38 +757,37 @@ protected:
 template <class _Traits, _Trait = _Traits::__destructible_trait>
 class _LIBCPP_TEMPLATE_VIS __dtor;
 
-#define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor, destroy)    \
-  template <class... _Types>                                                   \
-  class _LIBCPP_TEMPLATE_VIS __dtor<__traits<_Types...>,                       \
-                                    destructible_trait>                        \
-      : public __base<destructible_trait, _Types...> {                         \
-    using __base_type = __base<destructible_trait, _Types...>;                 \
-    using __index_t = typename __base_type::__index_t;                         \
-                                                                               \
-  public:                                                                      \
-    using __base_type::__base_type;                                            \
-    using __base_type::operator=;                                              \
-                                                                               \
-    __dtor(const __dtor&) = default;                                           \
-    __dtor(__dtor&&) = default;                                                \
-    destructor                                                                 \
-    __dtor& operator=(const __dtor&) = default;                                \
-    __dtor& operator=(__dtor&&) = default;                                     \
-                                                                               \
-  protected:                                                                   \
-    inline _LIBCPP_HIDE_FROM_ABI                                               \
-    destroy                                                                    \
-  }
+#  define _LIBCPP_VARIANT_DESTRUCTOR(destructible_trait, destructor_definition, destroy)                               \
+    template <class... _Types>                                                                                         \
+    class _LIBCPP_TEMPLATE_VIS __dtor<__traits<_Types...>, destructible_trait>                                         \
+        : public __base<destructible_trait, _Types...> {                                                               \
+      using __base_type = __base<destructible_trait, _Types...>;                                                       \
+      using __index_t   = typename __base_type::__index_t;                                                             \
+                                                                                                                       \
+    public:                                                                                                            \
+      using __base_type::__base_type;                                                                                  \
+      using __base_type::operator=;                                                                                    \
+      _LIBCPP_HIDE_FROM_ABI __dtor(const __dtor&)            = default;                                                \
+      _LIBCPP_HIDE_FROM_ABI __dtor(__dtor&&)                 = default;                                                \
+      _LIBCPP_HIDE_FROM_ABI __dtor& operator=(const __dtor&) = default;                                                \
+      _LIBCPP_HIDE_FROM_ABI __dtor& operator=(__dtor&&)      = default;                                                \
+      destructor_definition;                                                                                           \
+                                                                                                                       \
+    protected:                                                                                                         \
+      destroy;                                                                                                         \
+    }
 
 _LIBCPP_VARIANT_DESTRUCTOR(
     _Trait::_TriviallyAvailable,
-    ~__dtor() = default;,
-    void __destroy() noexcept { this->__index = __variant_npos<__index_t>; });
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() = default,
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept {
+      this->__index = __variant_npos<__index_t>;
+    } _LIBCPP_EAT_SEMICOLON);
 
 _LIBCPP_VARIANT_DESTRUCTOR(
     _Trait::_Available,
-    ~__dtor() { __destroy(); },
-    void __destroy() noexcept {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor() { __destroy(); } _LIBCPP_EAT_SEMICOLON,
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept {
       if (!this->valueless_by_exception()) {
         __visitation::__base::__visit_alt(
             [](auto& __alt) noexcept {
@@ -888,14 +797,13 @@ _LIBCPP_VARIANT_DESTRUCTOR(
             *this);
       }
       this->__index = __variant_npos<__index_t>;
-    });
+    } _LIBCPP_EAT_SEMICOLON);
 
-_LIBCPP_VARIANT_DESTRUCTOR(
-    _Trait::_Unavailable,
-    ~__dtor() = delete;,
-    void __destroy() noexcept = delete;);
+_LIBCPP_VARIANT_DESTRUCTOR(_Trait::_Unavailable,
+                           _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~__dtor()                 = delete,
+                           _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy() noexcept = delete);
 
-#undef _LIBCPP_VARIANT_DESTRUCTOR
+#  undef _LIBCPP_VARIANT_DESTRUCTOR
 
 template <class _Traits>
 class _LIBCPP_TEMPLATE_VIS __ctor : public __dtor<_Traits> {
@@ -906,28 +814,20 @@ public:
   using __base_type::operator=;
 
 protected:
-  template <size_t _Ip, class _Tp, class... _Args>
-  _LIBCPP_HIDE_FROM_ABI
-  static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) {
-    ::new ((void*)_VSTD::addressof(__a))
-        __alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...);
-    return __a.__value;
-  }
-
   template <class _Rhs>
-  _LIBCPP_HIDE_FROM_ABI
-  static void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) {
+  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX20 void __generic_construct(__ctor& __lhs, _Rhs&& __rhs) {
     __lhs.__destroy();
     if (!__rhs.valueless_by_exception()) {
+      auto __rhs_index = __rhs.index();
       __visitation::__base::__visit_alt_at(
-          __rhs.index(),
-          [](auto& __lhs_alt, auto&& __rhs_alt) {
-            __construct_alt(
-                __lhs_alt,
-                _VSTD::forward<decltype(__rhs_alt)>(__rhs_alt).__value);
+          __rhs_index,
+          [&__lhs](auto&& __rhs_alt) {
+            std::__construct_at(std::addressof(__lhs.__data),
+                                in_place_index<__decay_t<decltype(__rhs_alt)>::__index>,
+                                std::forward<decltype(__rhs_alt)>(__rhs_alt).__value);
           },
-          __lhs, _VSTD::forward<_Rhs>(__rhs));
-      __lhs.__index = __rhs.index();
+          std::forward<_Rhs>(__rhs));
+      __lhs.__index = __rhs_index;
     }
   }
 };
@@ -935,81 +835,75 @@ protected:
 template <class _Traits, _Trait = _Traits::__move_constructible_trait>
 class _LIBCPP_TEMPLATE_VIS __move_constructor;
 
-#define _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait,             \
-                                         move_constructor)                     \
-  template <class... _Types>                                                   \
-  class _LIBCPP_TEMPLATE_VIS __move_constructor<__traits<_Types...>,           \
-                                                move_constructible_trait>      \
-      : public __ctor<__traits<_Types...>> {                                   \
-    using __base_type = __ctor<__traits<_Types...>>;                           \
-                                                                               \
-  public:                                                                      \
-    using __base_type::__base_type;                                            \
-    using __base_type::operator=;                                              \
-                                                                               \
-    __move_constructor(const __move_constructor&) = default;                   \
-    move_constructor                                                           \
-    ~__move_constructor() = default;                                           \
-    __move_constructor& operator=(const __move_constructor&) = default;        \
-    __move_constructor& operator=(__move_constructor&&) = default;             \
-  }
+#  define _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, move_constructor_definition)                      \
+    template <class... _Types>                                                                                         \
+    class _LIBCPP_TEMPLATE_VIS __move_constructor<__traits<_Types...>, move_constructible_trait>                       \
+        : public __ctor<__traits<_Types...>> {                                                                         \
+      using __base_type = __ctor<__traits<_Types...>>;                                                                 \
+                                                                                                                       \
+    public:                                                                                                            \
+      using __base_type::__base_type;                                                                                  \
+      using __base_type::operator=;                                                                                    \
+                                                                                                                       \
+      _LIBCPP_HIDE_FROM_ABI __move_constructor(const __move_constructor&)            = default;                        \
+      _LIBCPP_HIDE_FROM_ABI ~__move_constructor()                                    = default;                        \
+      _LIBCPP_HIDE_FROM_ABI __move_constructor& operator=(const __move_constructor&) = default;                        \
+      _LIBCPP_HIDE_FROM_ABI __move_constructor& operator=(__move_constructor&&)      = default;                        \
+      move_constructor_definition;                                                                                     \
+    }
 
 _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
     _Trait::_TriviallyAvailable,
-    __move_constructor(__move_constructor&& __that) = default;);
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&& __that) = default);
 
 _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
     _Trait::_Available,
-    __move_constructor(__move_constructor&& __that) noexcept(
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&& __that) noexcept(
         __all<is_nothrow_move_constructible_v<_Types>...>::value)
-        : __move_constructor(__valueless_t{}) {
-      this->__generic_construct(*this, _VSTD::move(__that));
-    });
+    : __move_constructor(__valueless_t{}) {
+      this->__generic_construct(*this, std::move(__that));
+    } _LIBCPP_EAT_SEMICOLON);
 
 _LIBCPP_VARIANT_MOVE_CONSTRUCTOR(
     _Trait::_Unavailable,
-    __move_constructor(__move_constructor&&) = delete;);
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_constructor(__move_constructor&&) = delete);
 
-#undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR
+#  undef _LIBCPP_VARIANT_MOVE_CONSTRUCTOR
 
 template <class _Traits, _Trait = _Traits::__copy_constructible_trait>
 class _LIBCPP_TEMPLATE_VIS __copy_constructor;
 
-#define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait,             \
-                                         copy_constructor)                     \
-  template <class... _Types>                                                   \
-  class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>,           \
-                                                 copy_constructible_trait>     \
-      : public __move_constructor<__traits<_Types...>> {                       \
-    using __base_type = __move_constructor<__traits<_Types...>>;               \
-                                                                               \
-  public:                                                                      \
-    using __base_type::__base_type;                                            \
-    using __base_type::operator=;                                              \
-                                                                               \
-    copy_constructor                                                           \
-    __copy_constructor(__copy_constructor&&) = default;                        \
-    ~__copy_constructor() = default;                                           \
-    __copy_constructor& operator=(const __copy_constructor&) = default;        \
-    __copy_constructor& operator=(__copy_constructor&&) = default;             \
-  }
+#  define _LIBCPP_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, copy_constructor_definition)                      \
+    template <class... _Types>                                                                                         \
+    class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>, copy_constructible_trait>                       \
+        : public __move_constructor<__traits<_Types...>> {                                                             \
+      using __base_type = __move_constructor<__traits<_Types...>>;                                                     \
+                                                                                                                       \
+    public:                                                                                                            \
+      using __base_type::__base_type;                                                                                  \
+      using __base_type::operator=;                                                                                    \
+                                                                                                                       \
+      _LIBCPP_HIDE_FROM_ABI __copy_constructor(__copy_constructor&&)                 = default;                        \
+      _LIBCPP_HIDE_FROM_ABI ~__copy_constructor()                                    = default;                        \
+      _LIBCPP_HIDE_FROM_ABI __copy_constructor& operator=(const __copy_constructor&) = default;                        \
+      _LIBCPP_HIDE_FROM_ABI __copy_constructor& operator=(__copy_constructor&&)      = default;                        \
+      copy_constructor_definition;                                                                                     \
+    }
 
 _LIBCPP_VARIANT_COPY_CONSTRUCTOR(
     _Trait::_TriviallyAvailable,
-    __copy_constructor(const __copy_constructor& __that) = default;);
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor& __that) = default);
 
 _LIBCPP_VARIANT_COPY_CONSTRUCTOR(
     _Trait::_Available,
-    __copy_constructor(const __copy_constructor& __that)
-        : __copy_constructor(__valueless_t{}) {
-      this->__generic_construct(*this, __that);
-    });
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor& __that)
+    : __copy_constructor(__valueless_t{}) { this->__generic_construct(*this, __that); } _LIBCPP_EAT_SEMICOLON);
 
 _LIBCPP_VARIANT_COPY_CONSTRUCTOR(
     _Trait::_Unavailable,
-    __copy_constructor(const __copy_constructor&) = delete;);
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_constructor(const __copy_constructor&) = delete);
 
-#undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR
+#  undef _LIBCPP_VARIANT_COPY_CONSTRUCTOR
 
 template <class _Traits>
 class _LIBCPP_TEMPLATE_VIS __assignment : public __copy_constructor<_Traits> {
@@ -1020,40 +914,35 @@ public:
   using __base_type::operator=;
 
   template <size_t _Ip, class... _Args>
-  _LIBCPP_HIDE_FROM_ABI
-  auto& __emplace(_Args&&... __args) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 auto& __emplace(_Args&&... __args) {
     this->__destroy();
-    auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this),
-                          _VSTD::forward<_Args>(__args)...);
+    std::__construct_at(std::addressof(this->__data), in_place_index<_Ip>, std::forward<_Args>(__args)...);
     this->__index = _Ip;
-    return __res;
+    return __access::__base::__get_alt<_Ip>(*this).__value;
   }
 
 protected:
   template <size_t _Ip, class _Tp, class _Arg>
-  _LIBCPP_HIDE_FROM_ABI
-  void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
     if (this->index() == _Ip) {
-      __a.__value = _VSTD::forward<_Arg>(__arg);
+      __a.__value = std::forward<_Arg>(__arg);
     } else {
       struct {
-        _LIBCPP_HIDE_FROM_ABI void operator()(true_type) const {
-          __this->__emplace<_Ip>(_VSTD::forward<_Arg>(__arg));
+        _LIBCPP_HIDDEN _LIBCPP_CONSTEXPR_SINCE_CXX20 void operator()(true_type) const {
+          __this->__emplace<_Ip>(std::forward<_Arg>(__arg));
         }
-        _LIBCPP_HIDE_FROM_ABI void operator()(false_type) const {
-          __this->__emplace<_Ip>(_Tp(_VSTD::forward<_Arg>(__arg)));
+        _LIBCPP_HIDDEN _LIBCPP_CONSTEXPR_SINCE_CXX20 void operator()(false_type) const {
+          __this->__emplace<_Ip>(_Tp(std::forward<_Arg>(__arg)));
         }
         __assignment* __this;
         _Arg&& __arg;
-      } __impl{this, _VSTD::forward<_Arg>(__arg)};
-      __impl(bool_constant<is_nothrow_constructible_v<_Tp, _Arg> ||
-                           !is_nothrow_move_constructible_v<_Tp>>{});
+      } __impl{this, std::forward<_Arg>(__arg)};
+      __impl(bool_constant < is_nothrow_constructible_v<_Tp, _Arg> || !is_nothrow_move_constructible_v < _Tp >> {});
     }
   }
 
   template <class _That>
-  _LIBCPP_HIDE_FROM_ABI
-  void __generic_assign(_That&& __that) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __generic_assign(_That&& __that) {
     if (this->valueless_by_exception() && __that.valueless_by_exception()) {
       // do nothing.
     } else if (__that.valueless_by_exception()) {
@@ -1062,11 +951,10 @@ protected:
       __visitation::__base::__visit_alt_at(
           __that.index(),
           [this](auto& __this_alt, auto&& __that_alt) {
-            this->__assign_alt(
-                __this_alt,
-                _VSTD::forward<decltype(__that_alt)>(__that_alt).__value);
+            this->__assign_alt(__this_alt, std::forward<decltype(__that_alt)>(__that_alt).__value);
           },
-          *this, _VSTD::forward<_That>(__that));
+          *this,
+          std::forward<_That>(__that));
     }
   }
 };
@@ -1074,150 +962,142 @@ protected:
 template <class _Traits, _Trait = _Traits::__move_assignable_trait>
 class _LIBCPP_TEMPLATE_VIS __move_assignment;
 
-#define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait,                 \
-                                        move_assignment)                       \
-  template <class... _Types>                                                   \
-  class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>,            \
-                                                move_assignable_trait>         \
-      : public __assignment<__traits<_Types...>> {                             \
-    using __base_type = __assignment<__traits<_Types...>>;                     \
-                                                                               \
-  public:                                                                      \
-    using __base_type::__base_type;                                            \
-    using __base_type::operator=;                                              \
-                                                                               \
-    __move_assignment(const __move_assignment&) = default;                     \
-    __move_assignment(__move_assignment&&) = default;                          \
-    ~__move_assignment() = default;                                            \
-    __move_assignment& operator=(const __move_assignment&) = default;          \
-    move_assignment                                                            \
-  }
+#  define _LIBCPP_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, move_assignment_definition)                           \
+    template <class... _Types>                                                                                         \
+    class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>, move_assignable_trait>                           \
+        : public __assignment<__traits<_Types...>> {                                                                   \
+      using __base_type = __assignment<__traits<_Types...>>;                                                           \
+                                                                                                                       \
+    public:                                                                                                            \
+      using __base_type::__base_type;                                                                                  \
+      using __base_type::operator=;                                                                                    \
+                                                                                                                       \
+      _LIBCPP_HIDE_FROM_ABI __move_assignment(const __move_assignment&)            = default;                          \
+      _LIBCPP_HIDE_FROM_ABI __move_assignment(__move_assignment&&)                 = default;                          \
+      _LIBCPP_HIDE_FROM_ABI ~__move_assignment()                                   = default;                          \
+      _LIBCPP_HIDE_FROM_ABI __move_assignment& operator=(const __move_assignment&) = default;                          \
+      move_assignment_definition;                                                                                      \
+    }
 
-_LIBCPP_VARIANT_MOVE_ASSIGNMENT(
-    _Trait::_TriviallyAvailable,
-    __move_assignment& operator=(__move_assignment&& __that) = default;);
+_LIBCPP_VARIANT_MOVE_ASSIGNMENT(_Trait::_TriviallyAvailable,
+                                _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment& operator=(
+                                    __move_assignment&& __that) = default);
 
 _LIBCPP_VARIANT_MOVE_ASSIGNMENT(
     _Trait::_Available,
-    __move_assignment& operator=(__move_assignment&& __that) noexcept(
-        __all<(is_nothrow_move_constructible_v<_Types> &&
-               is_nothrow_move_assignable_v<_Types>)...>::value) {
-      this->__generic_assign(_VSTD::move(__that));
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment&
+    operator=(__move_assignment&& __that) noexcept(
+        __all<(is_nothrow_move_constructible_v<_Types> && is_nothrow_move_assignable_v<_Types>)...>::value) {
+      this->__generic_assign(std::move(__that));
       return *this;
-    });
+    } _LIBCPP_EAT_SEMICOLON);
 
 _LIBCPP_VARIANT_MOVE_ASSIGNMENT(
     _Trait::_Unavailable,
-    __move_assignment& operator=(__move_assignment&&) = delete;);
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __move_assignment& operator=(__move_assignment&&) = delete);
 
-#undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT
+#  undef _LIBCPP_VARIANT_MOVE_ASSIGNMENT
 
 template <class _Traits, _Trait = _Traits::__copy_assignable_trait>
 class _LIBCPP_TEMPLATE_VIS __copy_assignment;
 
-#define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait,                 \
-                                        copy_assignment)                       \
-  template <class... _Types>                                                   \
-  class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>,            \
-                                                copy_assignable_trait>         \
-      : public __move_assignment<__traits<_Types...>> {                        \
-    using __base_type = __move_assignment<__traits<_Types...>>;                \
-                                                                               \
-  public:                                                                      \
-    using __base_type::__base_type;                                            \
-    using __base_type::operator=;                                              \
-                                                                               \
-    __copy_assignment(const __copy_assignment&) = default;                     \
-    __copy_assignment(__copy_assignment&&) = default;                          \
-    ~__copy_assignment() = default;                                            \
-    copy_assignment                                                            \
-    __copy_assignment& operator=(__copy_assignment&&) = default;               \
-  }
+#  define _LIBCPP_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, copy_assignment_definition)                           \
+    template <class... _Types>                                                                                         \
+    class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>, copy_assignable_trait>                           \
+        : public __move_assignment<__traits<_Types...>> {                                                              \
+      using __base_type = __move_assignment<__traits<_Types...>>;                                                      \
+                                                                                                                       \
+    public:                                                                                                            \
+      using __base_type::__base_type;                                                                                  \
+      using __base_type::operator=;                                                                                    \
+                                                                                                                       \
+      _LIBCPP_HIDE_FROM_ABI __copy_assignment(const __copy_assignment&)       = default;                               \
+      _LIBCPP_HIDE_FROM_ABI __copy_assignment(__copy_assignment&&)            = default;                               \
+      _LIBCPP_HIDE_FROM_ABI ~__copy_assignment()                              = default;                               \
+      _LIBCPP_HIDE_FROM_ABI __copy_assignment& operator=(__copy_assignment&&) = default;                               \
+      copy_assignment_definition;                                                                                      \
+    }
 
-_LIBCPP_VARIANT_COPY_ASSIGNMENT(
-    _Trait::_TriviallyAvailable,
-    __copy_assignment& operator=(const __copy_assignment& __that) = default;);
+_LIBCPP_VARIANT_COPY_ASSIGNMENT(_Trait::_TriviallyAvailable,
+                                _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment& operator=(
+                                    const __copy_assignment& __that) = default);
 
 _LIBCPP_VARIANT_COPY_ASSIGNMENT(
     _Trait::_Available,
-    __copy_assignment& operator=(const __copy_assignment& __that) {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment&
+    operator=(const __copy_assignment& __that) {
       this->__generic_assign(__that);
       return *this;
-    });
+    } _LIBCPP_EAT_SEMICOLON);
 
-_LIBCPP_VARIANT_COPY_ASSIGNMENT(
-    _Trait::_Unavailable,
-    __copy_assignment& operator=(const __copy_assignment&) = delete;);
+_LIBCPP_VARIANT_COPY_ASSIGNMENT(_Trait::_Unavailable,
+                                _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __copy_assignment& operator=(
+                                    const __copy_assignment&) = delete);
 
-#undef _LIBCPP_VARIANT_COPY_ASSIGNMENT
+#  undef _LIBCPP_VARIANT_COPY_ASSIGNMENT
 
 template <class... _Types>
-class _LIBCPP_TEMPLATE_VIS __impl
-    : public __copy_assignment<__traits<_Types...>> {
+class _LIBCPP_TEMPLATE_VIS __impl : public __copy_assignment<__traits<_Types...>> {
   using __base_type = __copy_assignment<__traits<_Types...>>;
 
 public:
   using __base_type::__base_type; // get in_place_index_t constructor & friends
-  _LIBCPP_HIDE_FROM_ABI __impl(__impl const&) = default;
-  _LIBCPP_HIDE_FROM_ABI __impl(__impl&&) = default;
+  _LIBCPP_HIDE_FROM_ABI __impl(__impl const&)            = default;
+  _LIBCPP_HIDE_FROM_ABI __impl(__impl&&)                 = default;
   _LIBCPP_HIDE_FROM_ABI __impl& operator=(__impl const&) = default;
-  _LIBCPP_HIDE_FROM_ABI __impl& operator=(__impl&&) = default;
+  _LIBCPP_HIDE_FROM_ABI __impl& operator=(__impl&&)      = default;
 
   template <size_t _Ip, class _Arg>
-  _LIBCPP_HIDE_FROM_ABI
-  void __assign(_Arg&& __arg) {
-    this->__assign_alt(__access::__base::__get_alt<_Ip>(*this),
-                       _VSTD::forward<_Arg>(__arg));
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign(_Arg&& __arg) {
+    this->__assign_alt(__access::__base::__get_alt<_Ip>(*this), std::forward<_Arg>(__arg));
   }
 
-  inline _LIBCPP_HIDE_FROM_ABI
-  void __swap(__impl& __that)  {
+  inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __swap(__impl& __that) {
     if (this->valueless_by_exception() && __that.valueless_by_exception()) {
       // do nothing.
     } else if (this->index() == __that.index()) {
       __visitation::__base::__visit_alt_at(
           this->index(),
           [](auto& __this_alt, auto& __that_alt) {
-            using _VSTD::swap;
+            using std::swap;
             swap(__this_alt.__value, __that_alt.__value);
           },
           *this,
           __that);
     } else {
       __impl* __lhs = this;
-      __impl* __rhs = _VSTD::addressof(__that);
+      __impl* __rhs = std::addressof(__that);
       if (__lhs->__move_nothrow() && !__rhs->__move_nothrow()) {
-        _VSTD::swap(__lhs, __rhs);
+        std::swap(__lhs, __rhs);
       }
-      __impl __tmp(_VSTD::move(*__rhs));
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+      __impl __tmp(std::move(*__rhs));
+#  ifndef _LIBCPP_HAS_NO_EXCEPTIONS
       if constexpr (__all<is_nothrow_move_constructible_v<_Types>...>::value) {
-        this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
+        this->__generic_construct(*__rhs, std::move(*__lhs));
       } else {
         // EXTENSION: When the move construction of `__lhs` into `__rhs` throws
         // and `__tmp` is nothrow move constructible then we move `__tmp` back
         // into `__rhs` and provide the strong exception safety guarantee.
         try {
-          this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
+          this->__generic_construct(*__rhs, std::move(*__lhs));
         } catch (...) {
           if (__tmp.__move_nothrow()) {
-            this->__generic_construct(*__rhs, _VSTD::move(__tmp));
+            this->__generic_construct(*__rhs, std::move(__tmp));
           }
           throw;
         }
       }
-#else
+#  else
       // this isn't consolidated with the `if constexpr` branch above due to
       // `throw` being ill-formed with exceptions disabled even when discarded.
-      this->__generic_construct(*__rhs, _VSTD::move(*__lhs));
-#endif
-      this->__generic_construct(*__lhs, _VSTD::move(__tmp));
+      this->__generic_construct(*__rhs, std::move(*__lhs));
+#  endif
+      this->__generic_construct(*__lhs, std::move(__tmp));
     }
   }
 
 private:
-  inline _LIBCPP_HIDE_FROM_ABI
-  bool __move_nothrow() const {
+  constexpr inline _LIBCPP_HIDE_FROM_ABI bool __move_nothrow() const {
     constexpr bool __results[] = {is_nothrow_move_constructible_v<_Types>...};
     return this->valueless_by_exception() || __results[this->index()];
   }
@@ -1237,14 +1117,8 @@ struct __narrowing_check {
 
 template <class _Dest, class _Source>
 using __check_for_narrowing _LIBCPP_NODEBUG =
-  typename _If<
-#ifdef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
-    false &&
-#endif
-    is_arithmetic<_Dest>::value,
-    __narrowing_check,
-    __no_narrowing_check
-  >::template _Apply<_Dest, _Source>;
+    typename _If< is_arithmetic<_Dest>::value, __narrowing_check, __no_narrowing_check >::template _Apply<_Dest,
+                                                                                                          _Source>;
 
 template <class _Tp, size_t _Idx>
 struct __overload {
@@ -1252,241 +1126,210 @@ struct __overload {
   auto operator()(_Tp, _Up&&) const -> __check_for_narrowing<_Tp, _Up>;
 };
 
-template <class _Tp, size_t>
-struct __overload_bool  {
-  template <class _Up, class _Ap = __remove_cvref_t<_Up>>
-  auto operator()(bool, _Up&&) const
-      -> enable_if_t<is_same_v<_Ap, bool>, __type_identity<_Tp>>;
-};
-
-template <size_t _Idx>
-struct __overload<bool, _Idx> : __overload_bool<bool, _Idx> {};
-template <size_t _Idx>
-struct __overload<bool const, _Idx> : __overload_bool<bool const, _Idx> {};
-template <size_t _Idx>
-struct __overload<bool volatile, _Idx> : __overload_bool<bool volatile, _Idx> {};
-template <size_t _Idx>
-struct __overload<bool const volatile, _Idx> : __overload_bool<bool const volatile, _Idx> {};
-
-template <class ..._Bases>
+template <class... _Bases>
 struct __all_overloads : _Bases... {
   void operator()() const;
   using _Bases::operator()...;
 };
 
-template <class IdxSeq>
+template <class _IdxSeq>
 struct __make_overloads_imp;
 
-template <size_t ..._Idx>
+template <size_t... _Idx>
 struct __make_overloads_imp<__tuple_indices<_Idx...> > {
-  template <class ..._Types>
+  template <class... _Types>
   using _Apply _LIBCPP_NODEBUG = __all_overloads<__overload<_Types, _Idx>...>;
 };
 
-template <class ..._Types>
-using _MakeOverloads _LIBCPP_NODEBUG = typename __make_overloads_imp<
-    __make_indices_imp<sizeof...(_Types), 0> >::template _Apply<_Types...>;
+template <class... _Types>
+using _MakeOverloads _LIBCPP_NODEBUG =
+    typename __make_overloads_imp< __make_indices_imp<sizeof...(_Types), 0> >::template _Apply<_Types...>;
 
 template <class _Tp, class... _Types>
-using __best_match_t =
-    typename invoke_result_t<_MakeOverloads<_Types...>, _Tp, _Tp>::type;
+using __best_match_t = typename invoke_result_t<_MakeOverloads<_Types...>, _Tp, _Tp>::type;
 
 } // namespace __variant_detail
 
+template <class _Visitor, class... _Vs, typename = void_t<decltype(std::__as_variant(std::declval<_Vs>()))...>>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr decltype(auto)
+visit(_Visitor&& __visitor, _Vs&&... __vs);
+
+#  if _LIBCPP_STD_VER >= 20
+template <class _Rp,
+          class _Visitor,
+          class... _Vs,
+          typename = void_t<decltype(std::__as_variant(std::declval<_Vs>()))...>>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr _Rp
+visit(_Visitor&& __visitor, _Vs&&... __vs);
+#  endif
+
 template <class... _Types>
 class _LIBCPP_TEMPLATE_VIS _LIBCPP_DECLSPEC_EMPTY_BASES variant
-    : private __sfinae_ctor_base<
-          __all<is_copy_constructible_v<_Types>...>::value,
-          __all<is_move_constructible_v<_Types>...>::value>,
+    : private __sfinae_ctor_base< __all<is_copy_constructible_v<_Types>...>::value,
+                                  __all<is_move_constructible_v<_Types>...>::value>,
       private __sfinae_assign_base<
-          __all<(is_copy_constructible_v<_Types> &&
-                 is_copy_assignable_v<_Types>)...>::value,
-          __all<(is_move_constructible_v<_Types> &&
-                 is_move_assignable_v<_Types>)...>::value> {
-  static_assert(0 < sizeof...(_Types),
-                "variant must consist of at least one alternative.");
+          __all<(is_copy_constructible_v<_Types> && is_copy_assignable_v<_Types>)...>::value,
+          __all<(is_move_constructible_v<_Types> && is_move_assignable_v<_Types>)...>::value> {
+  static_assert(0 < sizeof...(_Types), "variant must consist of at least one alternative.");
 
-  static_assert(__all<!is_array_v<_Types>...>::value,
-                "variant can not have an array type as an alternative.");
+  static_assert(__all<!is_array_v<_Types>...>::value, "variant can not have an array type as an alternative.");
 
-  static_assert(__all<!is_reference_v<_Types>...>::value,
-                "variant can not have a reference type as an alternative.");
+  static_assert(__all<!is_reference_v<_Types>...>::value, "variant can not have a reference type as an alternative.");
 
-  static_assert(__all<!is_void_v<_Types>...>::value,
-                "variant can not have a void type as an alternative.");
+  static_assert(__all<!is_void_v<_Types>...>::value, "variant can not have a void type as an alternative.");
 
   using __first_type = variant_alternative_t<0, variant>;
 
 public:
-  template <bool _Dummy = true,
-            enable_if_t<__dependent_type<is_default_constructible<__first_type>,
-                                         _Dummy>::value,
-                        int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>)
+  using __trivially_relocatable =
+      conditional_t<_And<__libcpp_is_trivially_relocatable<_Types>...>::value, variant, void>;
+
+  template <bool _Dummy                                                                               = true,
+            enable_if_t<__dependent_type<is_default_constructible<__first_type>, _Dummy>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI constexpr variant() noexcept(is_nothrow_default_constructible_v<__first_type>)
       : __impl_(in_place_index<0>) {}
 
   _LIBCPP_HIDE_FROM_ABI constexpr variant(const variant&) = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr variant(variant&&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr variant(variant&&)      = default;
 
-  template <
-      class _Arg,
-      enable_if_t<!is_same_v<__remove_cvref_t<_Arg>, variant>, int> = 0,
-      enable_if_t<!__is_inplace_type<__remove_cvref_t<_Arg>>::value, int> = 0,
-      enable_if_t<!__is_inplace_index<__remove_cvref_t<_Arg>>::value, int> = 0,
-      class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
-      size_t _Ip =
-          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
-      enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr variant(_Arg&& __arg) noexcept(
-      is_nothrow_constructible_v<_Tp, _Arg>)
-      : __impl_(in_place_index<_Ip>, _VSTD::forward<_Arg>(__arg)) {}
+  template < class _Arg,
+             enable_if_t<!is_same_v<__remove_cvref_t<_Arg>, variant>, int>        = 0,
+             enable_if_t<!__is_inplace_type<__remove_cvref_t<_Arg>>::value, int>  = 0,
+             enable_if_t<!__is_inplace_index<__remove_cvref_t<_Arg>>::value, int> = 0,
+             class _Tp  = __variant_detail::__best_match_t<_Arg, _Types...>,
+             size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+             enable_if_t<is_constructible_v<_Tp, _Arg>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI constexpr variant(_Arg&& __arg) noexcept(is_nothrow_constructible_v<_Tp, _Arg>)
+      : __impl_(in_place_index<_Ip>, std::forward<_Arg>(__arg)) {}
 
-  template <size_t _Ip, class... _Args,
-            class = enable_if_t<(_Ip < sizeof...(_Types)), int>,
-            class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
+  template <size_t _Ip,
+            class... _Args,
+            class                                               = enable_if_t<(_Ip < sizeof...(_Types)), int>,
+            class _Tp                                           = variant_alternative_t<_Ip, variant<_Types...>>,
             enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr variant(
-      in_place_index_t<_Ip>,
-      _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
-      : __impl_(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr variant(in_place_index_t<_Ip>, _Args&&... __args) noexcept(
+      is_nothrow_constructible_v<_Tp, _Args...>)
+      : __impl_(in_place_index<_Ip>, std::forward<_Args>(__args)...) {}
 
-  template <
-      size_t _Ip,
-      class _Up,
-      class... _Args,
-      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
-      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
-      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
-                  int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr variant(
+  template < size_t _Ip,
+             class _Up,
+             class... _Args,
+             enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
+             class _Tp                                   = variant_alternative_t<_Ip, variant<_Types...>>,
+             enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr variant(
       in_place_index_t<_Ip>,
       initializer_list<_Up> __il,
-      _Args&&... __args) noexcept(
-      is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
-      : __impl_(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
+      _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
+      : __impl_(in_place_index<_Ip>, __il, std::forward<_Args>(__args)...) {}
 
-  template <
-      class _Tp,
-      class... _Args,
-      size_t _Ip =
-          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
-      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr variant(in_place_type_t<_Tp>, _Args&&... __args) noexcept(
+  template < class _Tp,
+             class... _Args,
+             size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+             enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr variant(in_place_type_t<_Tp>, _Args&&... __args) noexcept(
       is_nothrow_constructible_v<_Tp, _Args...>)
-      : __impl_(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...) {}
+      : __impl_(in_place_index<_Ip>, std::forward<_Args>(__args)...) {}
 
-  template <
-      class _Tp,
-      class _Up,
-      class... _Args,
-      size_t _Ip =
-          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
-      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
-                  int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  explicit constexpr variant(
+  template < class _Tp,
+             class _Up,
+             class... _Args,
+             size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+             enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI explicit constexpr variant(
       in_place_type_t<_Tp>,
       initializer_list<_Up> __il,
-      _Args&&... __args) noexcept(
-      is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>)
-      : __impl_(in_place_index<_Ip>, __il, _VSTD::forward<_Args>(__args)...) {}
+      _Args&&... __args) noexcept(is_nothrow_constructible_v<_Tp, initializer_list< _Up>&, _Args...>)
+      : __impl_(in_place_index<_Ip>, __il, std::forward<_Args>(__args)...) {}
 
-  _LIBCPP_HIDE_FROM_ABI ~variant() = default;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~variant() = default;
 
   _LIBCPP_HIDE_FROM_ABI constexpr variant& operator=(const variant&) = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr variant& operator=(variant&&) = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr variant& operator=(variant&&)      = default;
 
-  template <
-      class _Arg,
-      enable_if_t<!is_same_v<__remove_cvref_t<_Arg>, variant>, int> = 0,
-      class _Tp = __variant_detail::__best_match_t<_Arg, _Types...>,
-      size_t _Ip =
-          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
-      enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>,
-                  int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  variant& operator=(_Arg&& __arg) noexcept(
-      is_nothrow_assignable_v<_Tp&, _Arg> &&
-      is_nothrow_constructible_v<_Tp, _Arg>) {
-    __impl_.template __assign<_Ip>(_VSTD::forward<_Arg>(__arg));
+  template < class _Arg,
+             enable_if_t<!is_same_v<__remove_cvref_t<_Arg>, variant>, int> = 0,
+             class _Tp  = __variant_detail::__best_match_t<_Arg, _Types...>,
+             size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+             enable_if_t<is_assignable_v<_Tp&, _Arg> && is_constructible_v<_Tp, _Arg>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 variant&
+  operator=(_Arg&& __arg) noexcept(is_nothrow_assignable_v<_Tp&, _Arg> && is_nothrow_constructible_v<_Tp, _Arg>) {
+    __impl_.template __assign<_Ip>(std::forward<_Arg>(__arg));
     return *this;
   }
 
-  template <
-      size_t _Ip,
-      class... _Args,
-      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
-      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
-      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  _Tp& emplace(_Args&&... __args) {
-    return __impl_.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
+  template < size_t _Ip,
+             class... _Args,
+             enable_if_t<(_Ip < sizeof...(_Types)), int>         = 0,
+             class _Tp                                           = variant_alternative_t<_Ip, variant<_Types...>>,
+             enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args) {
+    return __impl_.template __emplace<_Ip>(std::forward<_Args>(__args)...);
   }
 
-  template <
-      size_t _Ip,
-      class _Up,
-      class... _Args,
-      enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
-      class _Tp = variant_alternative_t<_Ip, variant<_Types...>>,
-      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
-                  int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
-    return __impl_.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
+  template < size_t _Ip,
+             class _Up,
+             class... _Args,
+             enable_if_t<(_Ip < sizeof...(_Types)), int> = 0,
+             class _Tp                                   = variant_alternative_t<_Ip, variant<_Types...>>,
+             enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
+    return __impl_.template __emplace<_Ip>(__il, std::forward<_Args>(__args)...);
   }
 
-  template <
-      class _Tp,
-      class... _Args,
-      size_t _Ip =
-          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
-      enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  _Tp& emplace(_Args&&... __args) {
-    return __impl_.template __emplace<_Ip>(_VSTD::forward<_Args>(__args)...);
+  template < class _Tp,
+             class... _Args,
+             size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+             enable_if_t<is_constructible_v<_Tp, _Args...>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args) {
+    return __impl_.template __emplace<_Ip>(std::forward<_Args>(__args)...);
   }
 
-  template <
-      class _Tp,
-      class _Up,
-      class... _Args,
-      size_t _Ip =
-          __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
-      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
-                  int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
-    return __impl_.template __emplace<_Ip>(__il, _VSTD::forward<_Args>(__args)...);
+  template < class _Tp,
+             class _Up,
+             class... _Args,
+             size_t _Ip = __find_detail::__find_unambiguous_index_sfinae<_Tp, _Types...>::value,
+             enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
+    return __impl_.template __emplace<_Ip>(__il, std::forward<_Args>(__args)...);
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr bool valueless_by_exception() const noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr bool valueless_by_exception() const noexcept {
     return __impl_.valueless_by_exception();
   }
 
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr size_t index() const noexcept { return __impl_.index(); }
+  _LIBCPP_HIDE_FROM_ABI constexpr size_t index() const noexcept { return __impl_.index(); }
 
-  template <
-      bool _Dummy = true,
-      enable_if_t<
-          __all<(
-              __dependent_type<is_move_constructible<_Types>, _Dummy>::value &&
-              __dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value,
-          int> = 0>
-  _LIBCPP_HIDE_FROM_ABI
-  void swap(variant& __that) noexcept(
-      __all<(is_nothrow_move_constructible_v<_Types> &&
-             is_nothrow_swappable_v<_Types>)...>::value) {
+  template < bool _Dummy       = true,
+             enable_if_t< __all<(__dependent_type<is_move_constructible<_Types>, _Dummy>::value &&
+                                 __dependent_type<is_swappable<_Types>, _Dummy>::value)...>::value,
+                          int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(variant& __that) noexcept(
+      __all<(is_nothrow_move_constructible_v<_Types> && is_nothrow_swappable_v<_Types>)...>::value) {
     __impl_.__swap(__that.__impl_);
   }
 
+#  if _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_HAS_EXPLICIT_THIS_PARAMETER)
+  // Helper class to implement [variant.visit]/10
+  //   Constraints: The call to visit does not use an explicit template-argument-list
+  //   that begins with a type template-argument.
+  struct __variant_visit_barrier_tag {
+    _LIBCPP_HIDE_FROM_ABI explicit __variant_visit_barrier_tag() = default;
+  };
+
+  template <__variant_visit_barrier_tag = __variant_visit_barrier_tag{}, class _Self, class _Visitor>
+  _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) visit(this _Self&& __self, _Visitor&& __visitor) {
+    using _VariantT = _OverrideRef<_Self&&, _CopyConst<remove_reference_t<_Self>, variant>>;
+    return std::visit(std::forward<_Visitor>(__visitor), (_VariantT)__self);
+  }
+
+  template <class _Rp, class _Self, class _Visitor>
+  _LIBCPP_HIDE_FROM_ABI constexpr _Rp visit(this _Self&& __self, _Visitor&& __visitor) {
+    using _VariantT = _OverrideRef<_Self&&, _CopyConst<remove_reference_t<_Self>, variant>>;
+    return std::visit<_Rp>(std::forward<_Visitor>(__visitor), (_VariantT)__self);
+  }
+#  endif
+
 private:
   __variant_detail::__impl<_Types...> __impl_;
 
@@ -1495,33 +1338,28 @@ private:
 };
 
 template <size_t _Ip, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept {
   return __v.index() == _Ip;
 }
 
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept {
   return std::__holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <size_t _Ip, class _Vp>
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr auto&& __generic_get(_Vp&& __v) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr auto&& __generic_get(_Vp&& __v) {
   using __variant_detail::__access::__variant;
   if (!std::__holds_alternative<_Ip>(__v)) {
     __throw_bad_variant_access();
   }
-  return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
+  return __variant::__get_alt<_Ip>(std::forward<_Vp>(__v)).__value;
 }
 
 template <size_t _Ip, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(
-    variant<_Types...>& __v) {
+_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr variant_alternative_t<_Ip, variant<_Types...>>&
+get(variant<_Types...>& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
   return std::__generic_get<_Ip>(__v);
@@ -1529,19 +1367,17 @@ constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(
 
 template <size_t _Ip, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get(
-    variant<_Types...>&& __v) {
+_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr variant_alternative_t<_Ip, variant<_Types...>>&&
+get(variant<_Types...>&& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
-  return std::__generic_get<_Ip>(_VSTD::move(__v));
+  return std::__generic_get<_Ip>(std::move(__v));
 }
 
 template <size_t _Ip, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr const variant_alternative_t<_Ip, variant<_Types...>>& get(
-    const variant<_Types...>& __v) {
+_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr const variant_alternative_t<_Ip, variant<_Types...>>&
+get(const variant<_Types...>& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
   return std::__generic_get<_Ip>(__v);
@@ -1549,60 +1385,47 @@ constexpr const variant_alternative_t<_Ip, variant<_Types...>>& get(
 
 template <size_t _Ip, class... _Types>
 _LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr const variant_alternative_t<_Ip, variant<_Types...>>&& get(
-    const variant<_Types...>&& __v) {
+_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr const variant_alternative_t<_Ip, variant<_Types...>>&&
+get(const variant<_Types...>&& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
-  return std::__generic_get<_Ip>(_VSTD::move(__v));
+  return std::__generic_get<_Ip>(std::move(__v));
 }
 
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr _Tp& get(variant<_Types...>& __v) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr _Tp& get(variant<_Types...>& __v) {
   static_assert(!is_void_v<_Tp>);
-  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+  return std::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr _Tp&& get(variant<_Types...>&& __v) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr _Tp&& get(variant<_Types...>&& __v) {
   static_assert(!is_void_v<_Tp>);
-  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
-      _VSTD::move(__v));
+  return std::get<__find_exactly_one_t<_Tp, _Types...>::value>(std::move(__v));
 }
 
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr const _Tp& get(const variant<_Types...>& __v) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr const _Tp&
+get(const variant<_Types...>& __v) {
   static_assert(!is_void_v<_Tp>);
-  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+  return std::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr const _Tp&& get(const variant<_Types...>&& __v) {
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr const _Tp&&
+get(const variant<_Types...>&& __v) {
   static_assert(!is_void_v<_Tp>);
-  return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(
-      _VSTD::move(__v));
+  return std::get<__find_exactly_one_t<_Tp, _Types...>::value>(std::move(__v));
 }
 
 template <size_t _Ip, class _Vp>
-_LIBCPP_HIDE_FROM_ABI
-constexpr auto* __generic_get_if(_Vp* __v) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr auto* __generic_get_if(_Vp* __v) noexcept {
   using __variant_detail::__access::__variant;
-  return __v && std::__holds_alternative<_Ip>(*__v)
-             ? _VSTD::addressof(__variant::__get_alt<_Ip>(*__v).__value)
-             : nullptr;
+  return __v && std::__holds_alternative<_Ip>(*__v) ? std::addressof(__variant::__get_alt<_Ip>(*__v).__value) : nullptr;
 }
 
 template <size_t _Ip, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
+_LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
 get_if(variant<_Types...>* __v) noexcept {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
@@ -1610,8 +1433,7 @@ get_if(variant<_Types...>* __v) noexcept {
 }
 
 template <size_t _Ip, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
+_LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
 get_if(const variant<_Types...>* __v) noexcept {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
@@ -1619,45 +1441,41 @@ get_if(const variant<_Types...>* __v) noexcept {
 }
 
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr add_pointer_t<_Tp>
-get_if(variant<_Types...>* __v) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp> get_if(variant<_Types...>* __v) noexcept {
   static_assert(!is_void_v<_Tp>);
-  return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+  return std::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr add_pointer_t<const _Tp>
-get_if(const variant<_Types...>* __v) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<const _Tp> get_if(const variant<_Types...>* __v) noexcept {
   static_assert(!is_void_v<_Tp>);
-  return _VSTD::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
+  return std::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Operator>
 struct __convert_to_bool {
   template <class _T1, class _T2>
-  _LIBCPP_HIDE_FROM_ABI
-  constexpr bool operator()(_T1 && __t1, _T2&& __t2) const {
-    static_assert(is_convertible<decltype(_Operator{}(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2))), bool>::value,
-        "the relational operator does not return a type which is implicitly convertible to bool");
-    return _Operator{}(_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
+  _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(_T1&& __t1, _T2&& __t2) const {
+    static_assert(is_convertible<decltype(_Operator{}(std::forward<_T1>(__t1), std::forward<_T2>(__t2))), bool>::value,
+                  "the relational operator does not return a type which is implicitly convertible to bool");
+    return _Operator{}(std::forward<_T1>(__t1), std::forward<_T2>(__t2));
   }
 };
 
 template <class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr bool operator==(const variant<_Types...>& __lhs,
-                          const variant<_Types...>& __rhs) {
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
-  if (__lhs.index() != __rhs.index()) return false;
-  if (__lhs.valueless_by_exception()) return true;
+  if (__lhs.index() != __rhs.index())
+    return false;
+  if (__lhs.valueless_by_exception())
+    return true;
   return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<equal_to<>>{}, __lhs, __rhs);
 }
 
 #  if _LIBCPP_STD_VER >= 20
 
-template <class... _Types> requires (three_way_comparable<_Types> && ...)
+template <class... _Types>
+  requires(three_way_comparable<_Types> && ...)
 _LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t<compare_three_way_result_t<_Types>...>
 operator<=>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
@@ -1677,130 +1495,121 @@ operator<=>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
 #  endif // _LIBCPP_STD_VER >= 20
 
 template <class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr bool operator!=(const variant<_Types...>& __lhs,
-                          const variant<_Types...>& __rhs) {
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
-  if (__lhs.index() != __rhs.index()) return true;
-  if (__lhs.valueless_by_exception()) return false;
-  return __variant::__visit_value_at(
-      __lhs.index(), __convert_to_bool<not_equal_to<>>{}, __lhs, __rhs);
+  if (__lhs.index() != __rhs.index())
+    return true;
+  if (__lhs.valueless_by_exception())
+    return false;
+  return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<not_equal_to<>>{}, __lhs, __rhs);
 }
 
 template <class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr bool operator<(const variant<_Types...>& __lhs,
-                         const variant<_Types...>& __rhs) {
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
-  if (__rhs.valueless_by_exception()) return false;
-  if (__lhs.valueless_by_exception()) return true;
-  if (__lhs.index() < __rhs.index()) return true;
-  if (__lhs.index() > __rhs.index()) return false;
+  if (__rhs.valueless_by_exception())
+    return false;
+  if (__lhs.valueless_by_exception())
+    return true;
+  if (__lhs.index() < __rhs.index())
+    return true;
+  if (__lhs.index() > __rhs.index())
+    return false;
   return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<less<>>{}, __lhs, __rhs);
 }
 
 template <class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr bool operator>(const variant<_Types...>& __lhs,
-                         const variant<_Types...>& __rhs) {
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
-  if (__lhs.valueless_by_exception()) return false;
-  if (__rhs.valueless_by_exception()) return true;
-  if (__lhs.index() > __rhs.index()) return true;
-  if (__lhs.index() < __rhs.index()) return false;
+  if (__lhs.valueless_by_exception())
+    return false;
+  if (__rhs.valueless_by_exception())
+    return true;
+  if (__lhs.index() > __rhs.index())
+    return true;
+  if (__lhs.index() < __rhs.index())
+    return false;
   return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<greater<>>{}, __lhs, __rhs);
 }
 
 template <class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr bool operator<=(const variant<_Types...>& __lhs,
-                          const variant<_Types...>& __rhs) {
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
-  if (__lhs.valueless_by_exception()) return true;
-  if (__rhs.valueless_by_exception()) return false;
-  if (__lhs.index() < __rhs.index()) return true;
-  if (__lhs.index() > __rhs.index()) return false;
-  return __variant::__visit_value_at(
-      __lhs.index(), __convert_to_bool<less_equal<>>{}, __lhs, __rhs);
+  if (__lhs.valueless_by_exception())
+    return true;
+  if (__rhs.valueless_by_exception())
+    return false;
+  if (__lhs.index() < __rhs.index())
+    return true;
+  if (__lhs.index() > __rhs.index())
+    return false;
+  return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<less_equal<>>{}, __lhs, __rhs);
 }
 
 template <class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr bool operator>=(const variant<_Types...>& __lhs,
-                          const variant<_Types...>& __rhs) {
+_LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) {
   using __variant_detail::__visitation::__variant;
-  if (__rhs.valueless_by_exception()) return true;
-  if (__lhs.valueless_by_exception()) return false;
-  if (__lhs.index() > __rhs.index()) return true;
-  if (__lhs.index() < __rhs.index()) return false;
-  return __variant::__visit_value_at(
-      __lhs.index(), __convert_to_bool<greater_equal<>>{}, __lhs, __rhs);
+  if (__rhs.valueless_by_exception())
+    return true;
+  if (__lhs.valueless_by_exception())
+    return false;
+  if (__lhs.index() > __rhs.index())
+    return true;
+  if (__lhs.index() < __rhs.index())
+    return false;
+  return __variant::__visit_value_at(__lhs.index(), __convert_to_bool<greater_equal<>>{}, __lhs, __rhs);
 }
 
 template <class... _Vs>
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr void __throw_if_valueless(_Vs&&... __vs) {
-  const bool __valueless =
-      (... || _VSTD::__as_variant(__vs).valueless_by_exception());
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr void __throw_if_valueless(_Vs&&... __vs) {
+  const bool __valueless = (... || std::__as_variant(__vs).valueless_by_exception());
   if (__valueless) {
     __throw_bad_variant_access();
   }
 }
 
-template <
-    class _Visitor, class... _Vs,
-    typename = void_t<decltype(_VSTD::__as_variant(std::declval<_Vs>()))...> >
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr decltype(auto) visit(_Visitor&& __visitor, _Vs&&... __vs) {
+template < class _Visitor, class... _Vs, typename>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr decltype(auto)
+visit(_Visitor&& __visitor, _Vs&&... __vs) {
   using __variant_detail::__visitation::__variant;
-  _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...);
-  return __variant::__visit_value(_VSTD::forward<_Visitor>(__visitor),
-                                  _VSTD::forward<_Vs>(__vs)...);
+  std::__throw_if_valueless(std::forward<_Vs>(__vs)...);
+  return __variant::__visit_value(std::forward<_Visitor>(__visitor), std::forward<_Vs>(__vs)...);
 }
 
-#if _LIBCPP_STD_VER >= 20
-template <
-    class _Rp, class _Visitor, class... _Vs,
-    typename = void_t<decltype(_VSTD::__as_variant(std::declval<_Vs>()))...> >
-_LIBCPP_HIDE_FROM_ABI
-_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
-constexpr _Rp visit(_Visitor&& __visitor, _Vs&&... __vs) {
+#  if _LIBCPP_STD_VER >= 20
+template < class _Rp, class _Visitor, class... _Vs, typename>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr _Rp
+visit(_Visitor&& __visitor, _Vs&&... __vs) {
   using __variant_detail::__visitation::__variant;
-  _VSTD::__throw_if_valueless(_VSTD::forward<_Vs>(__vs)...);
-  return __variant::__visit_value<_Rp>(_VSTD::forward<_Visitor>(__visitor),
-                                       _VSTD::forward<_Vs>(__vs)...);
+  std::__throw_if_valueless(std::forward<_Vs>(__vs)...);
+  return __variant::__visit_value<_Rp>(std::forward<_Visitor>(__visitor), std::forward<_Vs>(__vs)...);
 }
-#endif
+#  endif
 
 template <class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-auto swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
-  noexcept(noexcept(__lhs.swap(__rhs)))
-  -> decltype(      __lhs.swap(__rhs))
-  { return          __lhs.swap(__rhs); }
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 auto
+swap(variant<_Types...>& __lhs,
+     variant<_Types...>& __rhs) noexcept(noexcept(__lhs.swap(__rhs))) -> decltype(__lhs.swap(__rhs)) {
+  return __lhs.swap(__rhs);
+}
 
 template <class... _Types>
-struct _LIBCPP_TEMPLATE_VIS hash<
-    __enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>> {
+struct _LIBCPP_TEMPLATE_VIS hash< __enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>> {
   using argument_type = variant<_Types...>;
-  using result_type = size_t;
+  using result_type   = size_t;
 
-  _LIBCPP_HIDE_FROM_ABI
-  result_type operator()(const argument_type& __v) const {
+  _LIBCPP_HIDE_FROM_ABI result_type operator()(const argument_type& __v) const {
     using __variant_detail::__visitation::__variant;
     size_t __res =
         __v.valueless_by_exception()
-               ? 299792458 // Random value chosen by the universe upon creation
-               : __variant::__visit_alt(
-                     [](const auto& __alt) {
-                       using __alt_type = __remove_cvref_t<decltype(__alt)>;
-                       using __value_type = remove_const_t<
-                         typename __alt_type::__value_type>;
-                       return hash<__value_type>{}(__alt.__value);
-                     },
-                     __v);
+            ? 299792458 // Random value chosen by the universe upon creation
+            : __variant::__visit_alt(
+                  [](const auto& __alt) {
+                    using __alt_type   = __remove_cvref_t<decltype(__alt)>;
+                    using __value_type = remove_const_t< typename __alt_type::__value_type>;
+                    return hash<__value_type>{}(__alt.__value);
+                  },
+                  __v);
     return std::__hash_combine(__res, hash<size_t>{}(__v.index()));
   }
 };
@@ -1809,21 +1618,18 @@ struct _LIBCPP_TEMPLATE_VIS hash<
 // type whereas std::get will throw or returning nullptr. This makes it faster than
 // std::get.
 template <size_t _Ip, class _Vp>
-_LIBCPP_HIDE_FROM_ABI
-constexpr auto&& __unchecked_get(_Vp&& __v) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr auto&& __unchecked_get(_Vp&& __v) noexcept {
   using __variant_detail::__access::__variant;
-  return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
+  return __variant::__get_alt<_Ip>(std::forward<_Vp>(__v)).__value;
 }
 
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr auto&& __unchecked_get(const variant<_Types...>& __v) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr auto&& __unchecked_get(const variant<_Types...>& __v) noexcept {
   return std::__unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI
-constexpr auto&& __unchecked_get(variant<_Types...>& __v) noexcept {
+_LIBCPP_HIDE_FROM_ABI constexpr auto&& __unchecked_get(variant<_Types...>& __v) noexcept {
   return std::__unchecked_get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 
@@ -1835,6 +1641,7 @@ _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <exception>
+#  include <tuple>
 #  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
diff --git a/third_party/libcxx/src/variant.cpp b/third_party/libcxx/variant.cpp
similarity index 78%
rename from third_party/libcxx/src/variant.cpp
rename to third_party/libcxx/variant.cpp
index b6ec44808..b5462d64f 100644
--- a/third_party/libcxx/src/variant.cpp
+++ b/third_party/libcxx/variant.cpp
@@ -10,8 +10,6 @@
 
 namespace std {
 
-const char* bad_variant_access::what() const noexcept {
-  return "bad_variant_access";
-}
+const char* bad_variant_access::what() const noexcept { return "bad_variant_access"; }
 
-}  // namespace std
+} // namespace std
diff --git a/third_party/libcxx/vector b/third_party/libcxx/vector
index 82078fbb2..45980043a 100644
--- a/third_party/libcxx/vector
+++ b/third_party/libcxx/vector
@@ -10,6 +10,8 @@
 #ifndef _LIBCPP_VECTOR
 #define _LIBCPP_VECTOR
 
+// clang-format off
+
 /*
     vector synopsis
 
@@ -269,12 +271,15 @@ template<ranges::input_range R, class Allocator = allocator<ranges::range_value_
 
 template <class Allocator> struct hash<std::vector<bool, Allocator>>;
 
-template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
+template <class T, class Allocator> bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // constexpr since C++20
+template <class T, class Allocator> bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // removed in C++20
+template <class T, class Allocator> bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // removed in C++20
+template <class T, class Allocator> bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // removed in C++20
+template <class T, class Allocator> bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // removed in C++20
+template <class T, class Allocator> bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);   // removed in C++20
+template <class T, class Allocator> constexpr
+  constexpr synth-three-way-result<T> operator<=>(const vector<T, Allocator>& x,
+                                                  const vector<T, Allocator>& y);                                  // since C++20
 
 template <class T, class Allocator>
 void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
@@ -282,10 +287,10 @@ void swap(vector<T,Allocator>& x, vector<T,Allocator>& y)
 
 template <class T, class Allocator, class U>
 typename vector<T, Allocator>::size_type
-erase(vector<T, Allocator>& c, const U& value);       // C++20
+erase(vector<T, Allocator>& c, const U& value);       // since C++20
 template <class T, class Allocator, class Predicate>
 typename vector<T, Allocator>::size_type
-erase_if(vector<T, Allocator>& c, Predicate pred);    // C++20
+erase_if(vector<T, Allocator>& c, Predicate pred);    // since C++20
 
 
 template<class T>
@@ -298,25 +303,29 @@ template<class T, class charT> requires is-vector-bool-reference<T> // Since C++
 
 */
 
+// clang-format on
+
 #include <__algorithm/copy.h>
 #include <__algorithm/equal.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/lexicographical_compare.h>
+#include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/remove.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/unwrap_iter.h>
-#include <__assert> // all public C++ headers provide the assertion handler
+#include <__assert>
 #include <__bit_reference>
 #include <__concepts/same_as.h>
 #include <__config>
-#include <__debug>
+#include <__debug_utils/sanitizers.h>
 #include <__format/enable_insertable.h>
 #include <__format/formatter.h>
 #include <__format/formatter_bool.h>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
+#include <__fwd/vector.h>
 #include <__iterator/advance.h>
 #include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
@@ -338,17 +347,17 @@ template<class T, class charT> requires is-vector-bool-reference<T> // Since C++
 #include <__split_buffer>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_constructible.h>
-#include <__type_traits/is_nothrow_move_assignable.h>
+#include <__type_traits/is_nothrow_assignable.h>
 #include <__type_traits/noexcept_move_assign_container.h>
 #include <__type_traits/type_identity.h>
 #include <__utility/exception_guard.h>
 #include <__utility/forward.h>
+#include <__utility/is_pointer_in_range.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
 #include <climits>
 #include <cstring>
-#include <iosfwd> // for forward declaration of vector
 #include <limits>
 #include <stdexcept>
 #include <version>
@@ -376,67 +385,90 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp, class _Allocator /* = allocator<_Tp> */>
-class _LIBCPP_TEMPLATE_VIS vector
-{
+class _LIBCPP_TEMPLATE_VIS vector {
 private:
-    typedef allocator<_Tp>                                  __default_allocator_type;
+  typedef allocator<_Tp> __default_allocator_type;
+
 public:
-    typedef vector                                          __self;
-    typedef _Tp                                             value_type;
-    typedef _Allocator                                      allocator_type;
-    typedef allocator_traits<allocator_type>                __alloc_traits;
-    typedef value_type&                                     reference;
-    typedef const value_type&                               const_reference;
-    typedef typename __alloc_traits::size_type              size_type;
-    typedef typename __alloc_traits::difference_type        difference_type;
-    typedef typename __alloc_traits::pointer                pointer;
-    typedef typename __alloc_traits::const_pointer          const_pointer;
-    // TODO: Implement iterator bounds checking without requiring the global database.
-    typedef __wrap_iter<pointer>                            iterator;
-    typedef __wrap_iter<const_pointer>                      const_iterator;
-    typedef std::reverse_iterator<iterator>               reverse_iterator;
-    typedef std::reverse_iterator<const_iterator>         const_reverse_iterator;
+  typedef vector __self;
+  typedef _Tp value_type;
+  typedef _Allocator allocator_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef typename __alloc_traits::size_type size_type;
+  typedef typename __alloc_traits::difference_type difference_type;
+  typedef typename __alloc_traits::pointer pointer;
+  typedef typename __alloc_traits::const_pointer const_pointer;
+  // TODO: Implement iterator bounds checking without requiring the global database.
+  typedef __wrap_iter<pointer> iterator;
+  typedef __wrap_iter<const_pointer> const_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
-    static_assert((is_same<typename allocator_type::value_type, value_type>::value),
-                  "Allocator::value_type must be same type as value_type");
+  // A vector containers the following members which may be trivially relocatable:
+  // - pointer: may be trivially relocatable, so it's checked
+  // - allocator_type: may be trivially relocatable, so it's checked
+  // vector doesn't contain any self-references, so it's trivially relocatable if its members are.
+  using __trivially_relocatable = __conditional_t<
+      __libcpp_is_trivially_relocatable<pointer>::value && __libcpp_is_trivially_relocatable<allocator_type>::value,
+      vector,
+      void>;
 
-    static_assert(is_same<allocator_type, __rebind_alloc<__alloc_traits, value_type> >::value,
-                  "[allocator.requirements] states that rebinding an allocator to the same type should result in the "
-                  "original allocator");
+  static_assert(__check_valid_allocator<allocator_type>::value, "");
+  static_assert(is_same<typename allocator_type::value_type, value_type>::value,
+                "Allocator::value_type must be same type as value_type");
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
-    {
-        std::__debug_db_insert_c(this);
-    }
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit vector(const allocator_type& __a)
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector()
+      _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value) {}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit vector(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
-        _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
+      _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
 #else
-        _NOEXCEPT
+      _NOEXCEPT
 #endif
-        : __end_cap_(nullptr, __a)
-    {
-        std::__debug_db_insert_c(this);
-    }
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit vector(size_type __n);
-#if _LIBCPP_STD_VER >= 14
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit vector(size_type __n, const allocator_type& __a);
-#endif
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(size_type __n, const value_type& __x);
+      : __end_cap_(nullptr, __a) {
+  }
 
-    template <class = __enable_if_t<__is_allocator<_Allocator>::value> >
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    vector(size_type __n, const value_type& __x, const allocator_type& __a)
-        : __end_cap_(nullptr, __a)
-    {
-      std::__debug_db_insert_c(this);
-      if (__n > 0)
-      {
-          __vallocate(__n);
-          __construct_at_end(__n, __x);
-      }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit vector(size_type __n) {
+    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+    if (__n > 0) {
+      __vallocate(__n);
+      __construct_at_end(__n);
     }
+    __guard.__complete();
+  }
+
+#if _LIBCPP_STD_VER >= 14
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit vector(size_type __n, const allocator_type& __a)
+      : __end_cap_(nullptr, __a) {
+    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+    if (__n > 0) {
+      __vallocate(__n);
+      __construct_at_end(__n);
+    }
+    __guard.__complete();
+  }
+#endif
+
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(size_type __n, const value_type& __x) {
+    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+    if (__n > 0) {
+      __vallocate(__n);
+      __construct_at_end(__n, __x);
+    }
+    __guard.__complete();
+  }
+
+  template <__enable_if_t<__is_allocator<_Allocator>::value, int> = 0>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  vector(size_type __n, const value_type& __x, const allocator_type& __a)
+      : __end_cap_(nullptr, __a) {
+    if (__n > 0) {
+      __vallocate(__n);
+      __construct_at_end(__n, __x);
+    }
+  }
 
   template <class _InputIterator,
             __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
@@ -457,7 +489,8 @@ public:
                     int> = 0>
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(_ForwardIterator __first, _ForwardIterator __last);
 
-  template <class _ForwardIterator,
+  template <
+      class _ForwardIterator,
       __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value &&
                         is_constructible<value_type, typename iterator_traits<_ForwardIterator>::reference>::value,
                     int> = 0>
@@ -466,8 +499,9 @@ public:
 
 #if _LIBCPP_STD_VER >= 23
   template <_ContainerCompatibleRange<_Tp> _Range>
-  _LIBCPP_HIDE_FROM_ABI constexpr vector(from_range_t, _Range&& __range,
-      const allocator_type& __alloc = allocator_type()) : __end_cap_(nullptr, __alloc) {
+  _LIBCPP_HIDE_FROM_ABI constexpr vector(
+      from_range_t, _Range&& __range, const allocator_type& __alloc = allocator_type())
+      : __end_cap_(nullptr, __alloc) {
     if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
       auto __n = static_cast<size_type>(ranges::distance(__range));
       __init_with_size(ranges::begin(__range), ranges::end(__range), __n);
@@ -480,56 +514,52 @@ public:
 
 private:
   class __destroy_vector {
-    public:
-      _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI __destroy_vector(vector& __vec) : __vec_(__vec) {}
+  public:
+    _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI __destroy_vector(vector& __vec) : __vec_(__vec) {}
 
-      _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void operator()() {
-          std::__debug_db_erase_c(std::addressof(__vec_));
-
-          if (__vec_.__begin_ != nullptr) {
-            __vec_.__clear();
-            __vec_.__annotate_delete();
-            __alloc_traits::deallocate(__vec_.__alloc(), __vec_.__begin_, __vec_.capacity());
-          }
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void operator()() {
+      if (__vec_.__begin_ != nullptr) {
+        __vec_.__clear();
+        __vec_.__annotate_delete();
+        __alloc_traits::deallocate(__vec_.__alloc(), __vec_.__begin_, __vec_.capacity());
       }
+    }
 
-    private:
-      vector& __vec_;
+  private:
+    vector& __vec_;
   };
 
 public:
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI ~vector() { __destroy_vector(*this)(); }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI ~vector() { __destroy_vector (*this)(); }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(const vector& __x);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(const vector& __x, const __type_identity_t<allocator_type>& __a);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    vector& operator=(const vector& __x);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(const vector& __x);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  vector(const vector& __x, const __type_identity_t<allocator_type>& __a);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector& operator=(const vector& __x);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    vector(initializer_list<value_type> __il);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(initializer_list<value_type> __il);
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    vector(initializer_list<value_type> __il, const allocator_type& __a);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  vector(initializer_list<value_type> __il, const allocator_type& __a);
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    vector& operator=(initializer_list<value_type> __il)
-        {assign(__il.begin(), __il.end()); return *this;}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector& operator=(initializer_list<value_type> __il) {
+    assign(__il.begin(), __il.end());
+    return *this;
+  }
 #endif // !_LIBCPP_CXX03_LANG
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    vector(vector&& __x)
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector(vector&& __x)
 #if _LIBCPP_STD_VER >= 17
-        noexcept;
+      noexcept;
 #else
-        _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
+      _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
 #endif
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    vector(vector&& __x, const __type_identity_t<allocator_type>& __a);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    vector& operator=(vector&& __x)
-        _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  vector(vector&& __x, const __type_identity_t<allocator_type>& __a);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI vector& operator=(vector&& __x)
+      _NOEXCEPT_(__noexcept_move_assign_container<_Allocator, __alloc_traits>::value);
 
   template <class _InputIterator,
             __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
@@ -544,140 +574,129 @@ public:
   _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void assign(_ForwardIterator __first, _ForwardIterator __last);
 
 #if _LIBCPP_STD_VER >= 23
-    template <_ContainerCompatibleRange<_Tp> _Range>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void assign_range(_Range&& __range) {
-      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
-        auto __n = static_cast<size_type>(ranges::distance(__range));
-        __assign_with_size(ranges::begin(__range), ranges::end(__range), __n);
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr void assign_range(_Range&& __range) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      __assign_with_size(ranges::begin(__range), ranges::end(__range), __n);
 
-      } else {
-        __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
-      }
+    } else {
+      __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
     }
+  }
 #endif
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const_reference __u);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const_reference __u);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void assign(initializer_list<value_type> __il)
-        {assign(__il.begin(), __il.end());}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void assign(initializer_list<value_type> __il) {
+    assign(__il.begin(), __il.end());
+  }
 #endif
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    allocator_type get_allocator() const _NOEXCEPT
-        {return this->__alloc();}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
+    return this->__alloc();
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator               begin() _NOEXCEPT;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator         begin()   const _NOEXCEPT;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator               end() _NOEXCEPT;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator         end()     const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    reverse_iterator       rbegin() _NOEXCEPT
-        {return       reverse_iterator(end());}
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    const_reverse_iterator rbegin()  const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    reverse_iterator       rend() _NOEXCEPT
-        {return       reverse_iterator(begin());}
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    const_reverse_iterator rend()    const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT {
+    return reverse_iterator(end());
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {
+    return const_reverse_iterator(end());
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT {
+    return reverse_iterator(begin());
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
+    return const_reverse_iterator(begin());
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    const_iterator         cbegin()  const _NOEXCEPT
-        {return begin();}
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    const_iterator         cend()    const _NOEXCEPT
-        {return end();}
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    const_reverse_iterator crbegin() const _NOEXCEPT
-        {return rbegin();}
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    const_reverse_iterator crend()   const _NOEXCEPT
-        {return rend();}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT {
+    return rbegin();
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    size_type size() const _NOEXCEPT
-        {return static_cast<size_type>(this->__end_ - this->__begin_);}
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    size_type capacity() const _NOEXCEPT
-        {return static_cast<size_type>(__end_cap() - this->__begin_);}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    bool empty() const _NOEXCEPT
-        {return this->__begin_ == this->__end_;}
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void shrink_to_fit() _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT {
+    return static_cast<size_type>(this->__end_ - this->__begin_);
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type capacity() const _NOEXCEPT {
+    return static_cast<size_type>(__end_cap() - this->__begin_);
+  }
+  _LIBCPP_NODISCARD _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT {
+    return this->__begin_ == this->__end_;
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void shrink_to_fit() _NOEXCEPT;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference       operator[](size_type __n) _NOEXCEPT;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __n) const _NOEXCEPT;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference       at(size_type __n);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __n) const;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference operator[](size_type __n) _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __n) const _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference at(size_type __n);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __n) const;
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference       front() _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(!empty(), "front() called on an empty vector");
-        return *this->__begin_;
-    }
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(!empty(), "front() called on an empty vector");
-        return *this->__begin_;
-    }
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference       back() _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(!empty(), "back() called on an empty vector");
-        return *(this->__end_ - 1);
-    }
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference back()  const _NOEXCEPT
-    {
-        _LIBCPP_ASSERT(!empty(), "back() called on an empty vector");
-        return *(this->__end_ - 1);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference front() _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "front() called on an empty vector");
+    return *this->__begin_;
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "front() called on an empty vector");
+    return *this->__begin_;
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference back() _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "back() called on an empty vector");
+    return *(this->__end_ - 1);
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "back() called on an empty vector");
+    return *(this->__end_ - 1);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    value_type*       data() _NOEXCEPT
-        {return std::__to_address(this->__begin_);}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI value_type* data() _NOEXCEPT {
+    return std::__to_address(this->__begin_);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    const value_type* data() const _NOEXCEPT
-        {return std::__to_address(this->__begin_);}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const value_type* data() const _NOEXCEPT {
+    return std::__to_address(this->__begin_);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void push_back(const_reference __x);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void push_back(const_reference __x);
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __x);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __x);
 
-    template <class... _Args>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
+  template <class... _Args>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
 #if _LIBCPP_STD_VER >= 17
-        reference emplace_back(_Args&&... __args);
+  reference
+  emplace_back(_Args&&... __args);
 #else
-        void      emplace_back(_Args&&... __args);
+  void
+  emplace_back(_Args&&... __args);
 #endif
 
 #if _LIBCPP_STD_VER >= 23
-    template <_ContainerCompatibleRange<_Tp> _Range>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void append_range(_Range&& __range) {
-      insert_range(end(), std::forward<_Range>(__range));
-    }
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr void append_range(_Range&& __range) {
+    insert_range(end(), std::forward<_Range>(__range));
+  }
 #endif
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void pop_back();
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void pop_back();
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __position, const_reference __x);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __position, const_reference __x);
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __position, value_type&& __x);
-    template <class... _Args>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __position, _Args&&... __args);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __position, value_type&& __x);
+  template <class... _Args>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __position, _Args&&... __args);
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    iterator insert(const_iterator __position, size_type __n, const_reference __x);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator
+  insert(const_iterator __position, size_type __n, const_reference __x);
 
   template <class _InputIterator,
             __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
@@ -687,17 +706,16 @@ public:
   insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
 
 #if _LIBCPP_STD_VER >= 23
-    template <_ContainerCompatibleRange<_Tp> _Range>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
-      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
-        auto __n = static_cast<size_type>(ranges::distance(__range));
-        return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);
+  template <_ContainerCompatibleRange<_Tp> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);
 
-      } else {
-        return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
-      }
+    } else {
+      return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
     }
+  }
 #endif
 
   template <
@@ -709,205 +727,182 @@ public:
   insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    iterator insert(const_iterator __position, initializer_list<value_type> __il)
-        {return insert(__position, __il.begin(), __il.end());}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator
+  insert(const_iterator __position, initializer_list<value_type> __il) {
+    return insert(__position, __il.begin(), __il.end());
+  }
 #endif
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __position);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __position);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last);
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void clear() _NOEXCEPT
-    {
-        size_type __old_size = size();
-        __clear();
-        __annotate_shrink(__old_size);
-        std::__debug_db_invalidate_all(this);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT {
+    size_type __old_size = size();
+    __clear();
+    __annotate_shrink(__old_size);
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void resize(size_type __sz);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void resize(size_type __sz, const_reference __x);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void resize(size_type __sz);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void resize(size_type __sz, const_reference __x);
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void swap(vector&)
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void swap(vector&)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT;
+      _NOEXCEPT;
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<allocator_type>::value);
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>);
 #endif
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool __invariants() const;
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-    bool __dereferenceable(const const_iterator* __i) const;
-    bool __decrementable(const const_iterator* __i) const;
-    bool __addable(const const_iterator* __i, ptrdiff_t __n) const;
-    bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const;
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool __invariants() const;
 
 private:
-    pointer __begin_ = nullptr;
-    pointer __end_ = nullptr;
-    __compressed_pair<pointer, allocator_type> __end_cap_ =
-        __compressed_pair<pointer, allocator_type>(nullptr, __default_init_tag());
+  pointer __begin_ = nullptr;
+  pointer __end_   = nullptr;
+  __compressed_pair<pointer, allocator_type> __end_cap_ =
+      __compressed_pair<pointer, allocator_type>(nullptr, __default_init_tag());
 
-    _LIBCPP_HIDE_FROM_ABI void __invalidate_iterators_past(pointer __new_last);
+  //  Allocate space for __n objects
+  //  throws length_error if __n > max_size()
+  //  throws (probably bad_alloc) if memory run out
+  //  Precondition:  __begin_ == __end_ == __end_cap() == 0
+  //  Precondition:  __n > 0
+  //  Postcondition:  capacity() >= __n
+  //  Postcondition:  size() == 0
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __vallocate(size_type __n) {
+    if (__n > max_size())
+      __throw_length_error();
+    auto __allocation = std::__allocate_at_least(__alloc(), __n);
+    __begin_          = __allocation.ptr;
+    __end_            = __allocation.ptr;
+    __end_cap()       = __begin_ + __allocation.count;
+    __annotate_new(0);
+  }
 
-    //  Allocate space for __n objects
-    //  throws length_error if __n > max_size()
-    //  throws (probably bad_alloc) if memory run out
-    //  Precondition:  __begin_ == __end_ == __end_cap() == 0
-    //  Precondition:  __n > 0
-    //  Postcondition:  capacity() >= __n
-    //  Postcondition:  size() == 0
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __vallocate(size_type __n) {
-        if (__n > max_size())
-            __throw_length_error();
-        auto __allocation = std::__allocate_at_least(__alloc(), __n);
-        __begin_ = __allocation.ptr;
-        __end_ = __allocation.ptr;
-        __end_cap() = __begin_ + __allocation.count;
-        __annotate_new(0);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __vdeallocate() _NOEXCEPT;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type __recommend(size_type __new_size) const;
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_at_end(size_type __n);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_at_end(size_type __n, const_reference __x);
+
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __init_with_size(_InputIterator __first, _Sentinel __last, size_type __n) {
+    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+
+    if (__n > 0) {
+      __vallocate(__n);
+      __construct_at_end(__first, __last, __n);
     }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __vdeallocate() _NOEXCEPT;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type __recommend(size_type __new_size) const;
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_at_end(size_type __n);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __construct_at_end(size_type __n, const_reference __x);
+    __guard.__complete();
+  }
 
-    template <class _InputIterator, class _Sentinel>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __init_with_size(_InputIterator __first, _Sentinel __last, size_type __n) {
-      auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-      std::__debug_db_insert_c(this);
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __init_with_sentinel(_InputIterator __first, _Sentinel __last) {
+    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
 
-      if (__n > 0) {
-        __vallocate(__n);
-        __construct_at_end(__first, __last, __n);
-      }
+    for (; __first != __last; ++__first)
+      emplace_back(*__first);
 
-      __guard.__complete();
-    }
+    __guard.__complete();
+  }
 
-    template <class _InputIterator, class _Sentinel>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __init_with_sentinel(_InputIterator __first, _Sentinel __last) {
-      auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-      std::__debug_db_insert_c(this);
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
 
-      for (; __first != __last; ++__first)
-        emplace_back(*__first);
+  template <class _ForwardIterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __n);
 
-      __guard.__complete();
-    }
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator
+  __insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last);
 
-    template <class _Iterator, class _Sentinel>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator
+  __insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n);
 
-    template <class _ForwardIterator, class _Sentinel>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __n);
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __construct_at_end(_InputIterator __first, _Sentinel __last, size_type __n);
 
-    template <class _InputIterator, class _Sentinel>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    iterator __insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __append(size_type __n);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const_reference __x);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator __make_iter(pointer __p) _NOEXCEPT {
+    return iterator(__p);
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator __make_iter(const_pointer __p) const _NOEXCEPT {
+    return const_iterator(__p);
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer
+  __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __move_range(pointer __from_s, pointer __from_e, pointer __to);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign(vector& __c, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign(vector& __c, false_type)
+      _NOEXCEPT_(__alloc_traits::is_always_equal::value);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __destruct_at_end(pointer __new_last) _NOEXCEPT {
+    size_type __old_size = size();
+    __base_destruct_at_end(__new_last);
+    __annotate_shrink(__old_size);
+  }
 
-    template <class _Iterator, class _Sentinel>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    iterator __insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n);
+  template <class _Up>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI inline pointer __push_back_slow_path(_Up&& __x);
 
-    template <class _InputIterator, class _Sentinel>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __construct_at_end(_InputIterator __first, _Sentinel __last, size_type __n);
+  template <class... _Args>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI inline pointer __emplace_back_slow_path(_Args&&... __args);
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __append(size_type __n);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const_reference __x);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    iterator       __make_iter(pointer __p) _NOEXCEPT { return iterator(this, __p); }
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    const_iterator __make_iter(const_pointer __p) const _NOEXCEPT { return const_iterator(this, __p); }
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_range(pointer __from_s, pointer __from_e, pointer __to);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign(vector& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign(vector& __c, false_type)
-        _NOEXCEPT_(__alloc_traits::is_always_equal::value);
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __destruct_at_end(pointer __new_last) _NOEXCEPT
-    {
-        if (!__libcpp_is_constant_evaluated())
-            __invalidate_iterators_past(__new_last);
-        size_type __old_size = size();
-        __base_destruct_at_end(__new_last);
-        __annotate_shrink(__old_size);
-    }
+  // The following functions are no-ops outside of AddressSanitizer mode.
+  // We call annotations for every allocator, unless explicitly disabled.
+  //
+  // To disable annotations for a particular allocator, change value of
+  // __asan_annotate_container_with_allocator to false.
+  // For more details, see the "Using libc++" documentation page or
+  // the documentation for __sanitizer_annotate_contiguous_container.
 
-    template <class _Up>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    inline void __push_back_slow_path(_Up&& __x);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __annotate_contiguous_container(const void* __old_mid, const void* __new_mid) const {
+    std::__annotate_contiguous_container<_Allocator>(data(), data() + capacity(), __old_mid, __new_mid);
+  }
 
-    template <class... _Args>
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    inline void __emplace_back_slow_path(_Args&&... __args);
-
-    // The following functions are no-ops outside of AddressSanitizer mode.
-    // We call annotatations only for the default Allocator because other allocators
-    // may not meet the AddressSanitizer alignment constraints.
-    // See the documentation for __sanitizer_annotate_contiguous_container for more details.
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __annotate_new(size_type __current_size) const _NOEXCEPT {
+    (void)__current_size;
 #ifndef _LIBCPP_HAS_NO_ASAN
-    _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __annotate_contiguous_container(const void *__beg, const void *__end,
-                                         const void *__old_mid,
-                                         const void *__new_mid) const
-    {
-      if (!__libcpp_is_constant_evaluated() && __beg != nullptr && __asan_annotate_container_with_allocator<_Allocator>::value)
-        __sanitizer_annotate_contiguous_container(__beg, __end, __old_mid, __new_mid);
-    }
-#else
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __annotate_contiguous_container(const void*, const void*, const void*,
-                                         const void*) const _NOEXCEPT {}
+    __annotate_contiguous_container(data() + capacity(), data() + __current_size);
 #endif
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __annotate_new(size_type __current_size) const _NOEXCEPT {
-      __annotate_contiguous_container(data(), data() + capacity(),
-                                      data() + capacity(), data() + __current_size);
-    }
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __annotate_delete() const _NOEXCEPT {
-      __annotate_contiguous_container(data(), data() + capacity(),
-                                      data() + size(), data() + capacity());
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __annotate_delete() const _NOEXCEPT {
+#ifndef _LIBCPP_HAS_NO_ASAN
+    __annotate_contiguous_container(data() + size(), data() + capacity());
+#endif
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __annotate_increase(size_type __n) const _NOEXCEPT
-    {
-      __annotate_contiguous_container(data(), data() + capacity(),
-                                      data() + size(), data() + size() + __n);
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __annotate_increase(size_type __n) const _NOEXCEPT {
+    (void)__n;
+#ifndef _LIBCPP_HAS_NO_ASAN
+    __annotate_contiguous_container(data() + size(), data() + size() + __n);
+#endif
+  }
 
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    void __annotate_shrink(size_type __old_size) const _NOEXCEPT
-    {
-      __annotate_contiguous_container(data(), data() + capacity(),
-                                      data() + __old_size, data() + size());
-    }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __annotate_shrink(size_type __old_size) const _NOEXCEPT {
+    (void)__old_size;
+#ifndef _LIBCPP_HAS_NO_ASAN
+    __annotate_contiguous_container(data() + __old_size, data() + size());
+#endif
+  }
 
   struct _ConstructTransaction {
-    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-    explicit _ConstructTransaction(vector &__v, size_type __n)
-      : __v_(__v), __pos_(__v.__end_), __new_end_(__v.__end_ + __n) {
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit _ConstructTransaction(vector& __v, size_type __n)
+        : __v_(__v), __pos_(__v.__end_), __new_end_(__v.__end_ + __n) {
 #ifndef _LIBCPP_HAS_NO_ASAN
       __v_.__annotate_increase(__n);
 #endif
     }
+
     _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI ~_ConstructTransaction() {
       __v_.__end_ = __pos_;
 #ifndef _LIBCPP_HAS_NO_ASAN
@@ -917,76 +912,61 @@ private:
 #endif
     }
 
-    vector &__v_;
+    vector& __v_;
     pointer __pos_;
     const_pointer const __new_end_;
 
-  private:
-    _ConstructTransaction(_ConstructTransaction const&) = delete;
+    _ConstructTransaction(_ConstructTransaction const&)            = delete;
     _ConstructTransaction& operator=(_ConstructTransaction const&) = delete;
   };
 
-  template <class ..._Args>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __construct_one_at_end(_Args&& ...__args) {
+  template <class... _Args>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_one_at_end(_Args&&... __args) {
     _ConstructTransaction __tx(*this, 1);
-    __alloc_traits::construct(this->__alloc(), std::__to_address(__tx.__pos_),
-        std::forward<_Args>(__args)...);
+    __alloc_traits::construct(this->__alloc(), std::__to_address(__tx.__pos_), std::forward<_Args>(__args)...);
     ++__tx.__pos_;
   }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  allocator_type& __alloc() _NOEXCEPT
-      {return this->__end_cap_.second();}
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  const allocator_type& __alloc() const _NOEXCEPT
-      {return this->__end_cap_.second();}
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  pointer& __end_cap() _NOEXCEPT
-      {return this->__end_cap_.first();}
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  const pointer& __end_cap() const _NOEXCEPT
-      {return this->__end_cap_.first();}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI allocator_type& __alloc() _NOEXCEPT {
+    return this->__end_cap_.second();
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const allocator_type& __alloc() const _NOEXCEPT {
+    return this->__end_cap_.second();
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer& __end_cap() _NOEXCEPT {
+    return this->__end_cap_.first();
+  }
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const pointer& __end_cap() const _NOEXCEPT {
+    return this->__end_cap_.first();
+  }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __clear() _NOEXCEPT {__base_destruct_at_end(this->__begin_);}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __clear() _NOEXCEPT {
+    __base_destruct_at_end(this->__begin_);
+  }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __base_destruct_at_end(pointer __new_last) _NOEXCEPT {
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __base_destruct_at_end(pointer __new_last) _NOEXCEPT {
     pointer __soon_to_be_end = this->__end_;
     while (__new_last != __soon_to_be_end)
-        __alloc_traits::destroy(__alloc(), std::__to_address(--__soon_to_be_end));
+      __alloc_traits::destroy(__alloc(), std::__to_address(--__soon_to_be_end));
     this->__end_ = __new_last;
   }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __copy_assign_alloc(const vector& __c)
-      {__copy_assign_alloc(__c, integral_constant<bool,
-                    __alloc_traits::propagate_on_container_copy_assignment::value>());}
-
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __move_assign_alloc(vector& __c)
-      _NOEXCEPT_(
-          !__alloc_traits::propagate_on_container_move_assignment::value ||
-          is_nothrow_move_assignable<allocator_type>::value)
-      {__move_assign_alloc(__c, integral_constant<bool,
-                    __alloc_traits::propagate_on_container_move_assignment::value>());}
-
-  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
-  void __throw_length_error() const {
-      std::__throw_length_error("vector");
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const vector& __c) {
+    __copy_assign_alloc(__c, integral_constant<bool, __alloc_traits::propagate_on_container_copy_assignment::value>());
   }
 
-  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
-  void __throw_out_of_range() const {
-      std::__throw_out_of_range("vector");
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(vector& __c)
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_move_assignment::value ||
+                 is_nothrow_move_assignable<allocator_type>::value) {
+    __move_assign_alloc(__c, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
   }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __copy_assign_alloc(const vector& __c, true_type)
-  {
-    if (__alloc() != __c.__alloc())
-    {
+  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void __throw_length_error() const { std::__throw_length_error("vector"); }
+
+  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void __throw_out_of_range() const { std::__throw_out_of_range("vector"); }
+
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const vector& __c, true_type) {
+    if (__alloc() != __c.__alloc()) {
       __clear();
       __annotate_delete();
       __alloc_traits::deallocate(__alloc(), this->__begin_, capacity());
@@ -995,126 +975,114 @@ private:
     __alloc() = __c.__alloc();
   }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __copy_assign_alloc(const vector&, false_type)
-  {}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const vector&, false_type) {}
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __move_assign_alloc(vector& __c, true_type)
-      _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-  {
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(vector& __c, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
     __alloc() = std::move(__c.__alloc());
   }
 
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __move_assign_alloc(vector&, false_type)
-      _NOEXCEPT
-  {}
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(vector&, false_type) _NOEXCEPT {}
 };
 
 #if _LIBCPP_STD_VER >= 17
-template<class _InputIterator,
-         class _Alloc = allocator<__iter_value_type<_InputIterator>>,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Alloc>::value>
-         >
-vector(_InputIterator, _InputIterator)
-  -> vector<__iter_value_type<_InputIterator>, _Alloc>;
+template <class _InputIterator,
+          class _Alloc = allocator<__iter_value_type<_InputIterator>>,
+          class        = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+vector(_InputIterator, _InputIterator) -> vector<__iter_value_type<_InputIterator>, _Alloc>;
 
-template<class _InputIterator,
-         class _Alloc,
-         class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-         class = enable_if_t<__is_allocator<_Alloc>::value>
-         >
-vector(_InputIterator, _InputIterator, _Alloc)
-  -> vector<__iter_value_type<_InputIterator>, _Alloc>;
+template <class _InputIterator,
+          class _Alloc,
+          class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
+          class = enable_if_t<__is_allocator<_Alloc>::value> >
+vector(_InputIterator, _InputIterator, _Alloc) -> vector<__iter_value_type<_InputIterator>, _Alloc>;
 #endif
 
 #if _LIBCPP_STD_VER >= 23
 template <ranges::input_range _Range,
           class _Alloc = allocator<ranges::range_value_t<_Range>>,
-          class = enable_if_t<__is_allocator<_Alloc>::value>
-          >
-vector(from_range_t, _Range&&, _Alloc = _Alloc())
-  -> vector<ranges::range_value_t<_Range>, _Alloc>;
+          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+vector(from_range_t, _Range&&, _Alloc = _Alloc()) -> vector<ranges::range_value_t<_Range>, _Alloc>;
 #endif
 
+// __swap_out_circular_buffer relocates the objects in [__begin_, __end_) into the front of __v and swaps the buffers of
+// *this and __v. It is assumed that __v provides space for exactly (__end_ - __begin_) objects in the front. This
+// function has a strong exception guarantee.
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v)
-{
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v) {
+  __annotate_delete();
+  auto __new_begin = __v.__begin_ - (__end_ - __begin_);
+  std::__uninitialized_allocator_relocate(
+      __alloc(), std::__to_address(__begin_), std::__to_address(__end_), std::__to_address(__new_begin));
+  __v.__begin_ = __new_begin;
+  __end_       = __begin_; // All the objects have been destroyed by relocating them.
+  std::swap(this->__begin_, __v.__begin_);
+  std::swap(this->__end_, __v.__end_);
+  std::swap(this->__end_cap(), __v.__end_cap());
+  __v.__first_ = __v.__begin_;
+  __annotate_new(size());
+}
+
+// __swap_out_circular_buffer relocates the objects in [__begin_, __p) into the front of __v, the objects in
+// [__p, __end_) into the back of __v and swaps the buffers of *this and __v. It is assumed that __v provides space for
+// exactly (__p - __begin_) objects in the front and space for at least (__end_ - __p) objects in the back. This
+// function has a strong exception guarantee if __begin_ == __p || __end_ == __p.
+template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::pointer
+vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p) {
+  __annotate_delete();
+  pointer __ret = __v.__begin_;
+
+  // Relocate [__p, __end_) first to avoid having a hole in [__begin_, __end_)
+  // in case something in [__begin_, __p) throws.
+  std::__uninitialized_allocator_relocate(
+      __alloc(), std::__to_address(__p), std::__to_address(__end_), std::__to_address(__v.__end_));
+  __v.__end_ += (__end_ - __p);
+  __end_           = __p; // The objects in [__p, __end_) have been destroyed by relocating them.
+  auto __new_begin = __v.__begin_ - (__p - __begin_);
+
+  std::__uninitialized_allocator_relocate(
+      __alloc(), std::__to_address(__begin_), std::__to_address(__p), std::__to_address(__new_begin));
+  __v.__begin_ = __new_begin;
+  __end_       = __begin_; // All the objects have been destroyed by relocating them.
+
+  std::swap(this->__begin_, __v.__begin_);
+  std::swap(this->__end_, __v.__end_);
+  std::swap(this->__end_cap(), __v.__end_cap());
+  __v.__first_ = __v.__begin_;
+  __annotate_new(size());
+  return __ret;
+}
+
+template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::__vdeallocate() _NOEXCEPT {
+  if (this->__begin_ != nullptr) {
+    clear();
     __annotate_delete();
-    using _RevIter = std::reverse_iterator<pointer>;
-    __v.__begin_   = std::__uninitialized_allocator_move_if_noexcept(
-                       __alloc(), _RevIter(__end_), _RevIter(__begin_), _RevIter(__v.__begin_))
-                       .base();
-    std::swap(this->__begin_, __v.__begin_);
-    std::swap(this->__end_, __v.__end_);
-    std::swap(this->__end_cap(), __v.__end_cap());
-    __v.__first_ = __v.__begin_;
-    __annotate_new(size());
-    std::__debug_db_invalidate_all(this);
+    __alloc_traits::deallocate(this->__alloc(), this->__begin_, capacity());
+    this->__begin_ = this->__end_ = this->__end_cap() = nullptr;
+  }
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<_Tp, _Allocator>::pointer
-vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p)
-{
-    __annotate_delete();
-    pointer __r = __v.__begin_;
-    using _RevIter = std::reverse_iterator<pointer>;
-    __v.__begin_   = std::__uninitialized_allocator_move_if_noexcept(
-                       __alloc(), _RevIter(__p), _RevIter(__begin_), _RevIter(__v.__begin_))
-                       .base();
-    __v.__end_ = std::__uninitialized_allocator_move_if_noexcept(__alloc(), __p, __end_, __v.__end_);
-    std::swap(this->__begin_, __v.__begin_);
-    std::swap(this->__end_, __v.__end_);
-    std::swap(this->__end_cap(), __v.__end_cap());
-    __v.__first_ = __v.__begin_;
-    __annotate_new(size());
-    std::__debug_db_invalidate_all(this);
-    return __r;
-}
-
-template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::__vdeallocate() _NOEXCEPT
-{
-    if (this->__begin_ != nullptr)
-    {
-        clear();
-        __annotate_delete();
-        __alloc_traits::deallocate(this->__alloc(), this->__begin_, capacity());
-        this->__begin_ = this->__end_ = this->__end_cap() = nullptr;
-    }
-}
-
-template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<_Tp, _Allocator>::size_type
-vector<_Tp, _Allocator>::max_size() const _NOEXCEPT
-{
-    return std::min<size_type>(__alloc_traits::max_size(this->__alloc()),
-                                 numeric_limits<difference_type>::max());
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::size_type
+vector<_Tp, _Allocator>::max_size() const _NOEXCEPT {
+  return std::min<size_type>(__alloc_traits::max_size(this->__alloc()), numeric_limits<difference_type>::max());
 }
 
 //  Precondition:  __new_size > capacity()
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-typename vector<_Tp, _Allocator>::size_type
-vector<_Tp, _Allocator>::__recommend(size_type __new_size) const
-{
-    const size_type __ms = max_size();
-    if (__new_size > __ms)
-        this->__throw_length_error();
-    const size_type __cap = capacity();
-    if (__cap >= __ms / 2)
-        return __ms;
-    return std::max<size_type>(2 * __cap, __new_size);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::size_type
+vector<_Tp, _Allocator>::__recommend(size_type __new_size) const {
+  const size_type __ms = max_size();
+  if (__new_size > __ms)
+    this->__throw_length_error();
+  const size_type __cap = capacity();
+  if (__cap >= __ms / 2)
+    return __ms;
+  return std::max<size_type>(2 * __cap, __new_size);
 }
 
 //  Default constructs __n objects starting at __end_
@@ -1123,15 +1091,12 @@ vector<_Tp, _Allocator>::__recommend(size_type __new_size) const
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
-{
-    _ConstructTransaction __tx(*this, __n);
-    const_pointer __new_end = __tx.__new_end_;
-    for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
-        __alloc_traits::construct(this->__alloc(), std::__to_address(__pos));
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::__construct_at_end(size_type __n) {
+  _ConstructTransaction __tx(*this, __n);
+  const_pointer __new_end = __tx.__new_end_;
+  for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
+    __alloc_traits::construct(this->__alloc(), std::__to_address(__pos));
+  }
 }
 
 //  Copy constructs __n objects starting at __end_ from __x
@@ -1141,16 +1106,13 @@ vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
 //  Postcondition:  size() == old size() + __n
 //  Postcondition:  [i] == __x for all i in [size() - __n, __n)
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline
-void
-vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
-{
-    _ConstructTransaction __tx(*this, __n);
-    const_pointer __new_end = __tx.__new_end_;
-    for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
-        __alloc_traits::construct(this->__alloc(), std::__to_address(__pos), __x);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline void
+vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x) {
+  _ConstructTransaction __tx(*this, __n);
+  const_pointer __new_end = __tx.__new_end_;
+  for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) {
+    __alloc_traits::construct(this->__alloc(), std::__to_address(__pos), __x);
+  }
 }
 
 template <class _Tp, class _Allocator>
@@ -1166,19 +1128,15 @@ vector<_Tp, _Allocator>::__construct_at_end(_InputIterator __first, _Sentinel __
 //  Postcondition:  size() == size() + __n
 //  Exception safety: strong.
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::__append(size_type __n)
-{
-    if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
-        this->__construct_at_end(__n);
-    else
-    {
-        allocator_type& __a = this->__alloc();
-        __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
-        __v.__construct_at_end(__n);
-        __swap_out_circular_buffer(__v);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::__append(size_type __n) {
+  if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
+    this->__construct_at_end(__n);
+  else {
+    allocator_type& __a = this->__alloc();
+    __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
+    __v.__construct_at_end(__n);
+    __swap_out_circular_buffer(__v);
+  }
 }
 
 //  Default constructs __n objects starting at __end_
@@ -1186,1507 +1144,1156 @@ vector<_Tp, _Allocator>::__append(size_type __n)
 //  Postcondition:  size() == size() + __n
 //  Exception safety: strong.
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::__append(size_type __n, const_reference __x)
-{
-    if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
-        this->__construct_at_end(__n, __x);
-    else
-    {
-        allocator_type& __a = this->__alloc();
-        __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
-        __v.__construct_at_end(__n, __x);
-        __swap_out_circular_buffer(__v);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::__append(size_type __n, const_reference __x) {
+  if (static_cast<size_type>(this->__end_cap() - this->__end_) >= __n)
+    this->__construct_at_end(__n, __x);
+  else {
+    allocator_type& __a = this->__alloc();
+    __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), __a);
+    __v.__construct_at_end(__n, __x);
+    __swap_out_circular_buffer(__v);
+  }
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<_Tp, _Allocator>::vector(size_type __n)
-{
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__n);
-    }
-    __guard.__complete();
-}
-
-#if _LIBCPP_STD_VER >= 14
-template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<_Tp, _Allocator>::vector(size_type __n, const allocator_type& __a)
-    : __end_cap_(nullptr, __a)
-{
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__n);
-    }
-    __guard.__complete();
-}
-#endif
-
-template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<_Tp, _Allocator>::vector(size_type __n, const value_type& __x)
-{
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__n, __x);
-    }
-    __guard.__complete();
-}
-
-template <class _Tp, class _Allocator>
-template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
-                              is_constructible<_Tp, typename iterator_traits<_InputIterator>::reference>::value,
-                          int> >
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last)
-{
+template <class _InputIterator,
+          __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
+                            is_constructible<_Tp, typename iterator_traits<_InputIterator>::reference>::value,
+                        int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last) {
   __init_with_sentinel(__first, __last);
 }
 
 template <class _Tp, class _Allocator>
-template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
-                              is_constructible<_Tp, typename iterator_traits<_InputIterator>::reference>::value,
-                          int> >
+template <class _InputIterator,
+          __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
+                            is_constructible<_Tp, typename iterator_traits<_InputIterator>::reference>::value,
+                        int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<_Tp, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a)
-    : __end_cap_(nullptr, __a)
-{
+    : __end_cap_(nullptr, __a) {
   __init_with_sentinel(__first, __last);
 }
 
 template <class _Tp, class _Allocator>
-template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value &&
-                        is_constructible<_Tp, typename iterator_traits<_ForwardIterator>::reference>::value,
-                    int> >
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last)
-{
+template <class _ForwardIterator,
+          __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value &&
+                            is_constructible<_Tp, typename iterator_traits<_ForwardIterator>::reference>::value,
+                        int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last) {
   size_type __n = static_cast<size_type>(std::distance(__first, __last));
   __init_with_size(__first, __last, __n);
 }
 
 template <class _Tp, class _Allocator>
-template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value &&
-                        is_constructible<_Tp, typename iterator_traits<_ForwardIterator>::reference>::value,
-                    int> >
+template <class _ForwardIterator,
+          __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value &&
+                            is_constructible<_Tp, typename iterator_traits<_ForwardIterator>::reference>::value,
+                        int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a)
-    : __end_cap_(nullptr, __a)
-{
+    : __end_cap_(nullptr, __a) {
   size_type __n = static_cast<size_type>(std::distance(__first, __last));
   __init_with_size(__first, __last, __n);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<_Tp, _Allocator>::vector(const vector& __x)
-    : __end_cap_(nullptr, __alloc_traits::select_on_container_copy_construction(__x.__alloc()))
-{
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<_Tp, _Allocator>::vector(const vector& __x)
+    : __end_cap_(nullptr, __alloc_traits::select_on_container_copy_construction(__x.__alloc())) {
   __init_with_size(__x.__begin_, __x.__end_, __x.size());
 }
 
 template <class _Tp, class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<_Tp, _Allocator>::vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
-    : __end_cap_(nullptr, __a)
-{
+    : __end_cap_(nullptr, __a) {
   __init_with_size(__x.__begin_, __x.__end_, __x.size());
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-vector<_Tp, _Allocator>::vector(vector&& __x)
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI vector<_Tp, _Allocator>::vector(vector&& __x)
 #if _LIBCPP_STD_VER >= 17
-        noexcept
+    noexcept
 #else
-        _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
+    _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
 #endif
-    : __end_cap_(nullptr, std::move(__x.__alloc()))
-{
-    std::__debug_db_insert_c(this);
-    std::__debug_db_swap(this, std::addressof(__x));
-    this->__begin_ = __x.__begin_;
-    this->__end_ = __x.__end_;
-    this->__end_cap() = __x.__end_cap();
-    __x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
+    : __end_cap_(nullptr, std::move(__x.__alloc())) {
+  this->__begin_    = __x.__begin_;
+  this->__end_      = __x.__end_;
+  this->__end_cap() = __x.__end_cap();
+  __x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI
 vector<_Tp, _Allocator>::vector(vector&& __x, const __type_identity_t<allocator_type>& __a)
-    : __end_cap_(nullptr, __a)
-{
-    std::__debug_db_insert_c(this);
-    if (__a == __x.__alloc())
-    {
-        this->__begin_ = __x.__begin_;
-        this->__end_ = __x.__end_;
-        this->__end_cap() = __x.__end_cap();
-        __x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
-        std::__debug_db_swap(this, std::addressof(__x));
-    }
-    else
-    {
-        typedef move_iterator<iterator> _Ip;
-        auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-        assign(_Ip(__x.begin()), _Ip(__x.end()));
-        __guard.__complete();
-    }
+    : __end_cap_(nullptr, __a) {
+  if (__a == __x.__alloc()) {
+    this->__begin_    = __x.__begin_;
+    this->__end_      = __x.__end_;
+    this->__end_cap() = __x.__end_cap();
+    __x.__begin_ = __x.__end_ = __x.__end_cap() = nullptr;
+  } else {
+    typedef move_iterator<iterator> _Ip;
+    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+    assign(_Ip(__x.begin()), _Ip(__x.end()));
+    __guard.__complete();
+  }
 }
 
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il)
-{
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    if (__il.size() > 0)
-    {
-        __vallocate(__il.size());
-        __construct_at_end(__il.begin(), __il.end(), __il.size());
-    }
-    __guard.__complete();
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI
+vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il) {
+  auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+  if (__il.size() > 0) {
+    __vallocate(__il.size());
+    __construct_at_end(__il.begin(), __il.end(), __il.size());
+  }
+  __guard.__complete();
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI
 vector<_Tp, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
-    : __end_cap_(nullptr, __a)
-{
-    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-    std::__debug_db_insert_c(this);
-    if (__il.size() > 0)
-    {
-        __vallocate(__il.size());
-        __construct_at_end(__il.begin(), __il.end(), __il.size());
-    }
-    __guard.__complete();
+    : __end_cap_(nullptr, __a) {
+  auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+  if (__il.size() > 0) {
+    __vallocate(__il.size());
+    __construct_at_end(__il.begin(), __il.end(), __il.size());
+  }
+  __guard.__complete();
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-vector<_Tp, _Allocator>&
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI vector<_Tp, _Allocator>&
 vector<_Tp, _Allocator>::operator=(vector&& __x)
-    _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
-{
-    __move_assign(__x, integral_constant<bool,
-          __alloc_traits::propagate_on_container_move_assignment::value>());
-    return *this;
+    _NOEXCEPT_(__noexcept_move_assign_container<_Allocator, __alloc_traits>::value) {
+  __move_assign(__x, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
+  return *this;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::__move_assign(vector& __c, false_type)
-    _NOEXCEPT_(__alloc_traits::is_always_equal::value)
-{
-    if (__alloc() != __c.__alloc())
-    {
-        typedef move_iterator<iterator> _Ip;
-        assign(_Ip(__c.begin()), _Ip(__c.end()));
-    }
-    else
-        __move_assign(__c, true_type());
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::__move_assign(vector& __c, false_type)
+    _NOEXCEPT_(__alloc_traits::is_always_equal::value) {
+  if (__alloc() != __c.__alloc()) {
+    typedef move_iterator<iterator> _Ip;
+    assign(_Ip(__c.begin()), _Ip(__c.end()));
+  } else
+    __move_assign(__c, true_type());
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::__move_assign(vector& __c, true_type)
-    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-{
-    __vdeallocate();
-    __move_assign_alloc(__c); // this can throw
-    this->__begin_ = __c.__begin_;
-    this->__end_ = __c.__end_;
-    this->__end_cap() = __c.__end_cap();
-    __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
-    std::__debug_db_swap(this, std::addressof(__c));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::__move_assign(vector& __c, true_type)
+    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
+  __vdeallocate();
+  __move_assign_alloc(__c); // this can throw
+  this->__begin_    = __c.__begin_;
+  this->__end_      = __c.__end_;
+  this->__end_cap() = __c.__end_cap();
+  __c.__begin_ = __c.__end_ = __c.__end_cap() = nullptr;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-vector<_Tp, _Allocator>&
-vector<_Tp, _Allocator>::operator=(const vector& __x)
-{
-    if (this != std::addressof(__x))
-    {
-        __copy_assign_alloc(__x);
-        assign(__x.__begin_, __x.__end_);
-    }
-    return *this;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI vector<_Tp, _Allocator>&
+vector<_Tp, _Allocator>::operator=(const vector& __x) {
+  if (this != std::addressof(__x)) {
+    __copy_assign_alloc(__x);
+    assign(__x.__begin_, __x.__end_);
+  }
+  return *this;
 }
 
 template <class _Tp, class _Allocator>
-template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
-                              is_constructible<_Tp, typename iterator_traits<_InputIterator>::reference>::value,
-                          int> >
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<_Tp, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
-{
+template <class _InputIterator,
+          __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
+                            is_constructible<_Tp, typename iterator_traits<_InputIterator>::reference>::value,
+                        int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::assign(_InputIterator __first, _InputIterator __last) {
   __assign_with_sentinel(__first, __last);
 }
 
 template <class _Tp, class _Allocator>
 template <class _Iterator, class _Sentinel>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-void vector<_Tp, _Allocator>::__assign_with_sentinel(_Iterator __first, _Sentinel __last) {
-    clear();
-    for (; __first != __last; ++__first)
-        emplace_back(*__first);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+vector<_Tp, _Allocator>::__assign_with_sentinel(_Iterator __first, _Sentinel __last) {
+  clear();
+  for (; __first != __last; ++__first)
+    emplace_back(*__first);
 }
 
 template <class _Tp, class _Allocator>
-template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value &&
-                        is_constructible<_Tp, typename iterator_traits<_ForwardIterator>::reference>::value,
-                    int> >
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
-{
+template <class _ForwardIterator,
+          __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value &&
+                            is_constructible<_Tp, typename iterator_traits<_ForwardIterator>::reference>::value,
+                        int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) {
   __assign_with_size(__first, __last, std::distance(__first, __last));
 }
 
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator, class _Sentinel>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-void vector<_Tp, _Allocator>::__assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __n) {
-    size_type __new_size = static_cast<size_type>(__n);
-    if (__new_size <= capacity())
-    {
-        if (__new_size > size())
-        {
-            _ForwardIterator __mid = std::next(__first, size());
-            std::copy(__first, __mid, this->__begin_);
-            __construct_at_end(__mid, __last, __new_size - size());
-        }
-        else
-        {
-            pointer __m = std::__copy<_ClassicAlgPolicy>(__first, __last, this->__begin_).second;
-            this->__destruct_at_end(__m);
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+vector<_Tp, _Allocator>::__assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __n) {
+  size_type __new_size = static_cast<size_type>(__n);
+  if (__new_size <= capacity()) {
+    if (__new_size > size()) {
+      _ForwardIterator __mid = std::next(__first, size());
+      std::copy(__first, __mid, this->__begin_);
+      __construct_at_end(__mid, __last, __new_size - size());
+    } else {
+      pointer __m = std::__copy<_ClassicAlgPolicy>(__first, __last, this->__begin_).second;
+      this->__destruct_at_end(__m);
     }
+  } else {
+    __vdeallocate();
+    __vallocate(__recommend(__new_size));
+    __construct_at_end(__first, __last, __new_size);
+  }
+}
+
+template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u) {
+  if (__n <= capacity()) {
+    size_type __s = size();
+    std::fill_n(this->__begin_, std::min(__n, __s), __u);
+    if (__n > __s)
+      __construct_at_end(__n - __s, __u);
     else
-    {
-        __vdeallocate();
-        __vallocate(__recommend(__new_size));
-        __construct_at_end(__first, __last, __new_size);
-    }
-    std::__debug_db_invalidate_all(this);
+      this->__destruct_at_end(this->__begin_ + __n);
+  } else {
+    __vdeallocate();
+    __vallocate(__recommend(static_cast<size_type>(__n)));
+    __construct_at_end(__n, __u);
+  }
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u)
-{
-    if (__n <= capacity())
-    {
-        size_type __s = size();
-        std::fill_n(this->__begin_, std::min(__n, __s), __u);
-        if (__n > __s)
-            __construct_at_end(__n - __s, __u);
-        else
-            this->__destruct_at_end(this->__begin_ + __n);
-    }
-    else
-    {
-        __vdeallocate();
-        __vallocate(__recommend(static_cast<size_type>(__n)));
-        __construct_at_end(__n, __u);
-    }
-    std::__debug_db_invalidate_all(this);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::begin() _NOEXCEPT {
+  return __make_iter(this->__begin_);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::begin() _NOEXCEPT
-{
-    return __make_iter(this->__begin_);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::const_iterator
+vector<_Tp, _Allocator>::begin() const _NOEXCEPT {
+  return __make_iter(this->__begin_);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-typename vector<_Tp, _Allocator>::const_iterator
-vector<_Tp, _Allocator>::begin() const _NOEXCEPT
-{
-    return __make_iter(this->__begin_);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::end() _NOEXCEPT {
+  return __make_iter(this->__end_);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::end() _NOEXCEPT
-{
-    return __make_iter(this->__end_);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::const_iterator
+vector<_Tp, _Allocator>::end() const _NOEXCEPT {
+  return __make_iter(this->__end_);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-typename vector<_Tp, _Allocator>::const_iterator
-vector<_Tp, _Allocator>::end() const _NOEXCEPT
-{
-    return __make_iter(this->__end_);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::reference
+vector<_Tp, _Allocator>::operator[](size_type __n) _NOEXCEPT {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < size(), "vector[] index out of bounds");
+  return this->__begin_[__n];
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-typename vector<_Tp, _Allocator>::reference
-vector<_Tp, _Allocator>::operator[](size_type __n) _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds");
-    return this->__begin_[__n];
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::const_reference
+vector<_Tp, _Allocator>::operator[](size_type __n) const _NOEXCEPT {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < size(), "vector[] index out of bounds");
+  return this->__begin_[__n];
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-typename vector<_Tp, _Allocator>::const_reference
-vector<_Tp, _Allocator>::operator[](size_type __n) const _NOEXCEPT
-{
-    _LIBCPP_ASSERT(__n < size(), "vector[] index out of bounds");
-    return this->__begin_[__n];
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::reference vector<_Tp, _Allocator>::at(size_type __n) {
+  if (__n >= size())
+    this->__throw_out_of_range();
+  return this->__begin_[__n];
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<_Tp, _Allocator>::reference
-vector<_Tp, _Allocator>::at(size_type __n)
-{
-    if (__n >= size())
-        this->__throw_out_of_range();
-    return this->__begin_[__n];
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::const_reference
+vector<_Tp, _Allocator>::at(size_type __n) const {
+  if (__n >= size())
+    this->__throw_out_of_range();
+  return this->__begin_[__n];
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<_Tp, _Allocator>::const_reference
-vector<_Tp, _Allocator>::at(size_type __n) const
-{
-    if (__n >= size())
-        this->__throw_out_of_range();
-    return this->__begin_[__n];
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::reserve(size_type __n) {
+  if (__n > capacity()) {
+    if (__n > max_size())
+      this->__throw_length_error();
+    allocator_type& __a = this->__alloc();
+    __split_buffer<value_type, allocator_type&> __v(__n, size(), __a);
+    __swap_out_circular_buffer(__v);
+  }
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::reserve(size_type __n)
-{
-    if (__n > capacity())
-    {
-        if (__n > max_size())
-            this->__throw_length_error();
-        allocator_type& __a = this->__alloc();
-        __split_buffer<value_type, allocator_type&> __v(__n, size(), __a);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT {
+  if (capacity() > size()) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      allocator_type& __a = this->__alloc();
+      __split_buffer<value_type, allocator_type&> __v(size(), size(), __a);
+      // The Standard mandates shrink_to_fit() does not increase the capacity.
+      // With equal capacity keep the existing buffer. This avoids extra work
+      // due to swapping the elements.
+      if (__v.capacity() < capacity())
         __swap_out_circular_buffer(__v);
-    }
-}
-
-template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
-{
-    if (capacity() > size())
-    {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            allocator_type& __a = this->__alloc();
-            __split_buffer<value_type, allocator_type&> __v(size(), size(), __a);
-            __swap_out_circular_buffer(__v);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Tp, class _Allocator>
 template <class _Up>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x)
-{
-    allocator_type& __a = this->__alloc();
-    __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
-    // __v.push_back(std::forward<_Up>(__x));
-    __alloc_traits::construct(__a, std::__to_address(__v.__end_), std::forward<_Up>(__x));
-    __v.__end_++;
-    __swap_out_circular_buffer(__v);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::pointer
+vector<_Tp, _Allocator>::__push_back_slow_path(_Up&& __x) {
+  allocator_type& __a = this->__alloc();
+  __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
+  // __v.push_back(std::forward<_Up>(__x));
+  __alloc_traits::construct(__a, std::__to_address(__v.__end_), std::forward<_Up>(__x));
+  __v.__end_++;
+  __swap_out_circular_buffer(__v);
+  return this->__end_;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-void
-vector<_Tp, _Allocator>::push_back(const_reference __x)
-{
-    if (this->__end_ != this->__end_cap())
-    {
-        __construct_one_at_end(__x);
-    }
-    else
-        __push_back_slow_path(__x);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void
+vector<_Tp, _Allocator>::push_back(const_reference __x) {
+  pointer __end = this->__end_;
+  if (__end < this->__end_cap()) {
+    __construct_one_at_end(__x);
+    ++__end;
+  } else {
+    __end = __push_back_slow_path(__x);
+  }
+  this->__end_ = __end;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-void
-vector<_Tp, _Allocator>::push_back(value_type&& __x)
-{
-    if (this->__end_ < this->__end_cap())
-    {
-        __construct_one_at_end(std::move(__x));
-    }
-    else
-        __push_back_slow_path(std::move(__x));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void vector<_Tp, _Allocator>::push_back(value_type&& __x) {
+  pointer __end = this->__end_;
+  if (__end < this->__end_cap()) {
+    __construct_one_at_end(std::move(__x));
+    ++__end;
+  } else {
+    __end = __push_back_slow_path(std::move(__x));
+  }
+  this->__end_ = __end;
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args)
-{
-    allocator_type& __a = this->__alloc();
-    __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
-//    __v.emplace_back(std::forward<_Args>(__args)...);
-    __alloc_traits::construct(__a, std::__to_address(__v.__end_), std::forward<_Args>(__args)...);
-    __v.__end_++;
-    __swap_out_circular_buffer(__v);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::pointer
+vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args) {
+  allocator_type& __a = this->__alloc();
+  __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
+  //    __v.emplace_back(std::forward<_Args>(__args)...);
+  __alloc_traits::construct(__a, std::__to_address(__v.__end_), std::forward<_Args>(__args)...);
+  __v.__end_++;
+  __swap_out_circular_buffer(__v);
+  return this->__end_;
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline
 #if _LIBCPP_STD_VER >= 17
-typename vector<_Tp, _Allocator>::reference
+    typename vector<_Tp, _Allocator>::reference
 #else
-void
+    void
 #endif
-vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
-{
-    if (this->__end_ < this->__end_cap())
-    {
-        __construct_one_at_end(std::forward<_Args>(__args)...);
-    }
-    else
-        __emplace_back_slow_path(std::forward<_Args>(__args)...);
+    vector<_Tp, _Allocator>::emplace_back(_Args&&... __args) {
+  pointer __end = this->__end_;
+  if (__end < this->__end_cap()) {
+    __construct_one_at_end(std::forward<_Args>(__args)...);
+    ++__end;
+  } else {
+    __end = __emplace_back_slow_path(std::forward<_Args>(__args)...);
+  }
+  this->__end_ = __end;
 #if _LIBCPP_STD_VER >= 17
-    return this->back();
+  return *(__end - 1);
 #endif
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline
-void
-vector<_Tp, _Allocator>::pop_back()
-{
-    _LIBCPP_ASSERT(!empty(), "vector::pop_back called on an empty vector");
-    this->__destruct_at_end(this->__end_ - 1);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline void vector<_Tp, _Allocator>::pop_back() {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "vector::pop_back called on an empty vector");
+  this->__destruct_at_end(this->__end_ - 1);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::erase(const_iterator __position)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__position)) == this,
-                         "vector::erase(iterator) called with an iterator not referring to this vector");
-    _LIBCPP_ASSERT(__position != end(),
-        "vector::erase(iterator) called with a non-dereferenceable iterator");
-    difference_type __ps = __position - cbegin();
-    pointer __p = this->__begin_ + __ps;
-    this->__destruct_at_end(std::move(__p + 1, this->__end_, __p));
-    if (!__libcpp_is_constant_evaluated())
-        this->__invalidate_iterators_past(__p - 1);
-    return __make_iter(__p);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::erase(const_iterator __position) {
+  _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
+      __position != end(), "vector::erase(iterator) called with a non-dereferenceable iterator");
+  difference_type __ps = __position - cbegin();
+  pointer __p          = this->__begin_ + __ps;
+  this->__destruct_at_end(std::move(__p + 1, this->__end_, __p));
+  return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::erase(const_iterator __first, const_iterator __last)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__first)) == this,
-                         "vector::erase(iterator, iterator) called with an iterator not referring to this vector");
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__last)) == this,
-                         "vector::erase(iterator, iterator) called with an iterator not referring to this vector");
-
-    _LIBCPP_ASSERT(__first <= __last, "vector::erase(first, last) called with invalid range");
-    pointer __p = this->__begin_ + (__first - begin());
-    if (__first != __last) {
-        this->__destruct_at_end(std::move(__p + (__last - __first), this->__end_, __p));
-        if (!__libcpp_is_constant_evaluated())
-            this->__invalidate_iterators_past(__p - 1);
-    }
-    return __make_iter(__p);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::erase(const_iterator __first, const_iterator __last) {
+  _LIBCPP_ASSERT_VALID_INPUT_RANGE(__first <= __last, "vector::erase(first, last) called with invalid range");
+  pointer __p = this->__begin_ + (__first - begin());
+  if (__first != __last) {
+    this->__destruct_at_end(std::move(__p + (__last - __first), this->__end_, __p));
+  }
+  return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointer __to)
-{
-    pointer __old_last = this->__end_;
-    difference_type __n = __old_last - __to;
-    {
-      pointer __i = __from_s + __n;
-      _ConstructTransaction __tx(*this, __from_e - __i);
-      for (pointer __pos = __tx.__pos_; __i < __from_e;
-           ++__i, (void) ++__pos, __tx.__pos_ = __pos) {
-          __alloc_traits::construct(this->__alloc(),
-                                    std::__to_address(__pos),
-                                    std::move(*__i));
-      }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointer __to) {
+  pointer __old_last  = this->__end_;
+  difference_type __n = __old_last - __to;
+  {
+    pointer __i = __from_s + __n;
+    _ConstructTransaction __tx(*this, __from_e - __i);
+    for (pointer __pos = __tx.__pos_; __i < __from_e; ++__i, (void)++__pos, __tx.__pos_ = __pos) {
+      __alloc_traits::construct(this->__alloc(), std::__to_address(__pos), std::move(*__i));
     }
-    std::move_backward(__from_s, __from_s + __n, __old_last);
+  }
+  std::move_backward(__from_s, __from_s + __n, __old_last);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__position)) == this,
-                         "vector::insert(iterator, x) called with an iterator not referring to this vector");
-    pointer __p = this->__begin_ + (__position - begin());
-    // We can't compare unrelated pointers inside constant expressions
-    if (!__libcpp_is_constant_evaluated() && this->__end_ < this->__end_cap())
-    {
-        if (__p == this->__end_)
-        {
-            __construct_one_at_end(__x);
-        }
-        else
-        {
-            __move_range(__p, this->__end_, __p + 1);
-            const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x);
-            if (__p <= __xr && __xr < this->__end_)
-                ++__xr;
-            *__p = *__xr;
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x) {
+  pointer __p = this->__begin_ + (__position - begin());
+  if (this->__end_ < this->__end_cap()) {
+    if (__p == this->__end_) {
+      __construct_one_at_end(__x);
+    } else {
+      __move_range(__p, this->__end_, __p + 1);
+      const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x);
+      if (std::__is_pointer_in_range(std::__to_address(__p), std::__to_address(__end_), std::addressof(__x)))
+        ++__xr;
+      *__p = *__xr;
     }
-    else
-    {
-        allocator_type& __a = this->__alloc();
-        __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
-        __v.push_back(__x);
-        __p = __swap_out_circular_buffer(__v, __p);
-    }
-    return __make_iter(__p);
+  } else {
+    allocator_type& __a = this->__alloc();
+    __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
+    __v.push_back(__x);
+    __p = __swap_out_circular_buffer(__v, __p);
+  }
+  return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__position)) == this,
-                         "vector::insert(iterator, x) called with an iterator not referring to this vector");
-    pointer __p = this->__begin_ + (__position - begin());
-    if (this->__end_ < this->__end_cap())
-    {
-        if (__p == this->__end_)
-        {
-            __construct_one_at_end(std::move(__x));
-        }
-        else
-        {
-            __move_range(__p, this->__end_, __p + 1);
-            *__p = std::move(__x);
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x) {
+  pointer __p = this->__begin_ + (__position - begin());
+  if (this->__end_ < this->__end_cap()) {
+    if (__p == this->__end_) {
+      __construct_one_at_end(std::move(__x));
+    } else {
+      __move_range(__p, this->__end_, __p + 1);
+      *__p = std::move(__x);
     }
-    else
-    {
-        allocator_type& __a = this->__alloc();
-        __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
-        __v.push_back(std::move(__x));
-        __p = __swap_out_circular_buffer(__v, __p);
-    }
-    return __make_iter(__p);
+  } else {
+    allocator_type& __a = this->__alloc();
+    __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
+    __v.push_back(std::move(__x));
+    __p = __swap_out_circular_buffer(__v, __p);
+  }
+  return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
 template <class... _Args>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__position)) == this,
-                         "vector::emplace(iterator, x) called with an iterator not referring to this vector");
-    pointer __p = this->__begin_ + (__position - begin());
-    if (this->__end_ < this->__end_cap())
-    {
-        if (__p == this->__end_)
-        {
-            __construct_one_at_end(std::forward<_Args>(__args)...);
-        }
-        else
-        {
-            __temp_value<value_type, _Allocator> __tmp(this->__alloc(), std::forward<_Args>(__args)...);
-            __move_range(__p, this->__end_, __p + 1);
-            *__p = std::move(__tmp.get());
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args) {
+  pointer __p = this->__begin_ + (__position - begin());
+  if (this->__end_ < this->__end_cap()) {
+    if (__p == this->__end_) {
+      __construct_one_at_end(std::forward<_Args>(__args)...);
+    } else {
+      __temp_value<value_type, _Allocator> __tmp(this->__alloc(), std::forward<_Args>(__args)...);
+      __move_range(__p, this->__end_, __p + 1);
+      *__p = std::move(__tmp.get());
     }
-    else
-    {
-        allocator_type& __a = this->__alloc();
-        __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
-        __v.emplace_back(std::forward<_Args>(__args)...);
-        __p = __swap_out_circular_buffer(__v, __p);
-    }
-    return __make_iter(__p);
+  } else {
+    allocator_type& __a = this->__alloc();
+    __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
+    __v.emplace_back(std::forward<_Args>(__args)...);
+    __p = __swap_out_circular_buffer(__v, __p);
+  }
+  return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_reference __x)
-{
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__position)) == this,
-                         "vector::insert(iterator, n, x) called with an iterator not referring to this vector");
-    pointer __p = this->__begin_ + (__position - begin());
-    if (__n > 0)
-    {
-        // We can't compare unrelated pointers inside constant expressions
-        if (!__libcpp_is_constant_evaluated() && __n <= static_cast<size_type>(this->__end_cap() - this->__end_))
-        {
-            size_type __old_n = __n;
-            pointer __old_last = this->__end_;
-            if (__n > static_cast<size_type>(this->__end_ - __p))
-            {
-                size_type __cx = __n - (this->__end_ - __p);
-                __construct_at_end(__cx, __x);
-                __n -= __cx;
-            }
-            if (__n > 0)
-            {
-                __move_range(__p, __old_last, __p + __old_n);
-                const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x);
-                if (__p <= __xr && __xr < this->__end_)
-                    __xr += __old_n;
-                std::fill_n(__p, __n, *__xr);
-            }
-        }
-        else
-        {
-            allocator_type& __a = this->__alloc();
-            __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a);
-            __v.__construct_at_end(__n, __x);
-            __p = __swap_out_circular_buffer(__v, __p);
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_reference __x) {
+  pointer __p = this->__begin_ + (__position - begin());
+  if (__n > 0) {
+    // We can't compare unrelated pointers inside constant expressions
+    if (!__libcpp_is_constant_evaluated() && __n <= static_cast<size_type>(this->__end_cap() - this->__end_)) {
+      size_type __old_n  = __n;
+      pointer __old_last = this->__end_;
+      if (__n > static_cast<size_type>(this->__end_ - __p)) {
+        size_type __cx = __n - (this->__end_ - __p);
+        __construct_at_end(__cx, __x);
+        __n -= __cx;
+      }
+      if (__n > 0) {
+        __move_range(__p, __old_last, __p + __old_n);
+        const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x);
+        if (__p <= __xr && __xr < this->__end_)
+          __xr += __old_n;
+        std::fill_n(__p, __n, *__xr);
+      }
+    } else {
+      allocator_type& __a = this->__alloc();
+      __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a);
+      __v.__construct_at_end(__n, __x);
+      __p = __swap_out_circular_buffer(__v, __p);
     }
-    return __make_iter(__p);
+  }
+  return __make_iter(__p);
 }
 template <class _Tp, class _Allocator>
-template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
-                              is_constructible<_Tp, typename iterator_traits<_InputIterator>::reference>::value,
-                          int> >
+template <class _InputIterator,
+          __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value &&
+                            is_constructible<_Tp, typename iterator_traits<_InputIterator>::reference>::value,
+                        int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
-{
+vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last) {
   return __insert_with_sentinel(__position, __first, __last);
 }
 
 template <class _Tp, class _Allocator>
 template <class _InputIterator, class _Sentinel>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-typename vector<_Tp, _Allocator>::iterator
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::iterator
 vector<_Tp, _Allocator>::__insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last) {
-  _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__position)) == this,
-                        "vector::insert called with an iterator not referring to this vector");
-
-    difference_type __off = __position - begin();
-    pointer __p = this->__begin_ + __off;
-    allocator_type& __a = this->__alloc();
-    pointer __old_last = this->__end_;
-    for (; this->__end_ != this->__end_cap() && __first != __last; ++__first)
-    {
-        __construct_one_at_end(*__first);
-    }
-    __split_buffer<value_type, allocator_type&> __v(__a);
-    if (__first != __last)
-    {
+  difference_type __off = __position - begin();
+  pointer __p           = this->__begin_ + __off;
+  allocator_type& __a   = this->__alloc();
+  pointer __old_last    = this->__end_;
+  for (; this->__end_ != this->__end_cap() && __first != __last; ++__first) {
+    __construct_one_at_end(*__first);
+  }
+  __split_buffer<value_type, allocator_type&> __v(__a);
+  if (__first != __last) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            __v.__construct_at_end_with_sentinel(std::move(__first), std::move(__last));
-            difference_type __old_size = __old_last - this->__begin_;
-            difference_type __old_p = __p - this->__begin_;
-            reserve(__recommend(size() + __v.size()));
-            __p = this->__begin_ + __old_p;
-            __old_last = this->__begin_ + __old_size;
+      __v.__construct_at_end_with_sentinel(std::move(__first), std::move(__last));
+      difference_type __old_size = __old_last - this->__begin_;
+      difference_type __old_p    = __p - this->__begin_;
+      reserve(__recommend(size() + __v.size()));
+      __p        = this->__begin_ + __old_p;
+      __old_last = this->__begin_ + __old_size;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            erase(__make_iter(__old_last), end());
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      erase(__make_iter(__old_last), end());
+      throw;
     }
-    __p = std::rotate(__p, __old_last, this->__end_);
-    insert(__make_iter(__p), std::make_move_iterator(__v.begin()),
-                             std::make_move_iterator(__v.end()));
-    return begin() + __off;
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
+  __p = std::rotate(__p, __old_last, this->__end_);
+  insert(__make_iter(__p), std::make_move_iterator(__v.begin()), std::make_move_iterator(__v.end()));
+  return begin() + __off;
 }
 
 template <class _Tp, class _Allocator>
-template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value &&
-                        is_constructible<_Tp, typename iterator_traits<_ForwardIterator>::reference>::value,
-                    int> >
+template <class _ForwardIterator,
+          __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value &&
+                            is_constructible<_Tp, typename iterator_traits<_ForwardIterator>::reference>::value,
+                        int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
-{
+vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last) {
   return __insert_with_size(__position, __first, __last, std::distance(__first, __last));
 }
 
 template <class _Tp, class _Allocator>
 template <class _Iterator, class _Sentinel>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-typename vector<_Tp, _Allocator>::iterator
-vector<_Tp, _Allocator>::__insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last,
-                                            difference_type __n) {
-    _LIBCPP_DEBUG_ASSERT(__get_const_db()->__find_c_from_i(std::addressof(__position)) == this,
-                        "vector::insert called with an iterator not referring to this vector");
-
-    auto __insertion_size = __n;
-    pointer __p = this->__begin_ + (__position - begin());
-    if (__n > 0)
-    {
-        if (__n <= this->__end_cap() - this->__end_)
-        {
-            size_type __old_n = __n;
-            pointer __old_last = this->__end_;
-            _Iterator __m = std::next(__first, __n);
-            difference_type __dx = this->__end_ - __p;
-            if (__n > __dx)
-            {
-                __m = __first;
-                difference_type __diff = this->__end_ - __p;
-                std::advance(__m, __diff);
-                __construct_at_end(__m, __last, __n - __diff);
-                __n = __dx;
-            }
-            if (__n > 0)
-            {
-                __move_range(__p, __old_last, __p + __old_n);
-                std::copy(__first, __m, __p);
-            }
-        }
-        else
-        {
-            allocator_type& __a = this->__alloc();
-            __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a);
-            __v.__construct_at_end_with_size(__first, __insertion_size);
-            __p = __swap_out_circular_buffer(__v, __p);
-        }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::iterator
+vector<_Tp, _Allocator>::__insert_with_size(
+    const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n) {
+  auto __insertion_size = __n;
+  pointer __p           = this->__begin_ + (__position - begin());
+  if (__n > 0) {
+    if (__n <= this->__end_cap() - this->__end_) {
+      size_type __old_n    = __n;
+      pointer __old_last   = this->__end_;
+      _Iterator __m        = std::next(__first, __n);
+      difference_type __dx = this->__end_ - __p;
+      if (__n > __dx) {
+        __m                    = __first;
+        difference_type __diff = this->__end_ - __p;
+        std::advance(__m, __diff);
+        __construct_at_end(__m, __last, __n - __diff);
+        __n = __dx;
+      }
+      if (__n > 0) {
+        __move_range(__p, __old_last, __p + __old_n);
+        std::copy(__first, __m, __p);
+      }
+    } else {
+      allocator_type& __a = this->__alloc();
+      __split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, __a);
+      __v.__construct_at_end_with_size(__first, __insertion_size);
+      __p = __swap_out_circular_buffer(__v, __p);
     }
-    return __make_iter(__p);
+  }
+  return __make_iter(__p);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::resize(size_type __sz)
-{
-    size_type __cs = size();
-    if (__cs < __sz)
-        this->__append(__sz - __cs);
-    else if (__cs > __sz)
-        this->__destruct_at_end(this->__begin_ + __sz);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::resize(size_type __sz) {
+  size_type __cs = size();
+  if (__cs < __sz)
+    this->__append(__sz - __cs);
+  else if (__cs > __sz)
+    this->__destruct_at_end(this->__begin_ + __sz);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x)
-{
-    size_type __cs = size();
-    if (__cs < __sz)
-        this->__append(__sz - __cs, __x);
-    else if (__cs > __sz)
-        this->__destruct_at_end(this->__begin_ + __sz);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x) {
+  size_type __cs = size();
+  if (__cs < __sz)
+    this->__append(__sz - __cs, __x);
+  else if (__cs > __sz)
+    this->__destruct_at_end(this->__begin_ + __sz);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<_Tp, _Allocator>::swap(vector& __x)
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::swap(vector& __x)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
-    _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                __is_nothrow_swappable<allocator_type>::value)
+    _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>)
 #endif
 {
-    _LIBCPP_ASSERT(__alloc_traits::propagate_on_container_swap::value ||
-                   this->__alloc() == __x.__alloc(),
-                   "vector::swap: Either propagate_on_container_swap must be true"
-                   " or the allocators must compare equal");
-    std::swap(this->__begin_, __x.__begin_);
-    std::swap(this->__end_, __x.__end_);
-    std::swap(this->__end_cap(), __x.__end_cap());
-    std::__swap_allocator(this->__alloc(), __x.__alloc(),
-        integral_constant<bool,__alloc_traits::propagate_on_container_swap::value>());
-    std::__debug_db_swap(this, std::addressof(__x));
+  _LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR(
+      __alloc_traits::propagate_on_container_swap::value || this->__alloc() == __x.__alloc(),
+      "vector::swap: Either propagate_on_container_swap must be true"
+      " or the allocators must compare equal");
+  std::swap(this->__begin_, __x.__begin_);
+  std::swap(this->__end_, __x.__end_);
+  std::swap(this->__end_cap(), __x.__end_cap());
+  std::__swap_allocator(
+      this->__alloc(), __x.__alloc(), integral_constant<bool, __alloc_traits::propagate_on_container_swap::value>());
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-bool
-vector<_Tp, _Allocator>::__invariants() const
-{
-    if (this->__begin_ == nullptr)
-    {
-        if (this->__end_ != nullptr || this->__end_cap() != nullptr)
-            return false;
-    }
-    else
-    {
-        if (this->__begin_ > this->__end_)
-            return false;
-        if (this->__begin_ == this->__end_cap())
-            return false;
-        if (this->__end_ > this->__end_cap())
-            return false;
-    }
-    return true;
-}
-
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-
-template <class _Tp, class _Allocator>
-bool
-vector<_Tp, _Allocator>::__dereferenceable(const const_iterator* __i) const
-{
-    return this->__begin_ <= __i->base() && __i->base() < this->__end_;
-}
-
-template <class _Tp, class _Allocator>
-bool
-vector<_Tp, _Allocator>::__decrementable(const const_iterator* __i) const
-{
-    return this->__begin_ < __i->base() && __i->base() <= this->__end_;
-}
-
-template <class _Tp, class _Allocator>
-bool
-vector<_Tp, _Allocator>::__addable(const const_iterator* __i, ptrdiff_t __n) const
-{
-    const_pointer __p = __i->base() + __n;
-    return this->__begin_ <= __p && __p <= this->__end_;
-}
-
-template <class _Tp, class _Allocator>
-bool
-vector<_Tp, _Allocator>::__subscriptable(const const_iterator* __i, ptrdiff_t __n) const
-{
-    const_pointer __p = __i->base() + __n;
-    return this->__begin_ <= __p && __p < this->__end_;
-}
-
-#endif // _LIBCPP_ENABLE_DEBUG_MODE
-
-template <class _Tp, class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI
-void
-vector<_Tp, _Allocator>::__invalidate_iterators_past(pointer __new_last) {
-#ifdef _LIBCPP_ENABLE_DEBUG_MODE
-  __c_node* __c = __get_db()->__find_c_and_lock(this);
-  for (__i_node** __p = __c->end_; __p != __c->beg_; ) {
-    --__p;
-    const_iterator* __i = static_cast<const_iterator*>((*__p)->__i_);
-    if (__i->base() > __new_last) {
-      (*__p)->__c_ = nullptr;
-      if (--__c->end_ != __p)
-        std::memmove(__p, __p+1, (__c->end_ - __p)*sizeof(__i_node*));
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 bool vector<_Tp, _Allocator>::__invariants() const {
+  if (this->__begin_ == nullptr) {
+    if (this->__end_ != nullptr || this->__end_cap() != nullptr)
+      return false;
+  } else {
+    if (this->__begin_ > this->__end_)
+      return false;
+    if (this->__begin_ == this->__end_cap())
+      return false;
+    if (this->__end_ > this->__end_cap())
+      return false;
   }
-  __get_db()->unlock();
-#else
-  ((void)__new_last);
-#endif
+  return true;
 }
 
 // vector<bool>
 
-template <class _Allocator> class vector<bool, _Allocator>;
-
-template <class _Allocator> struct hash<vector<bool, _Allocator> >;
+template <class _Allocator>
+class vector<bool, _Allocator>;
 
 template <class _Allocator>
-struct __has_storage_type<vector<bool, _Allocator> >
-{
-    static const bool value = true;
+struct hash<vector<bool, _Allocator> >;
+
+template <class _Allocator>
+struct __has_storage_type<vector<bool, _Allocator> > {
+  static const bool value = true;
 };
 
 template <class _Allocator>
-class _LIBCPP_TEMPLATE_VIS vector<bool, _Allocator>
-{
+class _LIBCPP_TEMPLATE_VIS vector<bool, _Allocator> {
 public:
-    typedef vector                                   __self;
-    typedef bool                                     value_type;
-    typedef _Allocator                               allocator_type;
-    typedef allocator_traits<allocator_type>         __alloc_traits;
-    typedef typename __alloc_traits::size_type       size_type;
-    typedef typename __alloc_traits::difference_type difference_type;
-    typedef size_type __storage_type;
-    typedef __bit_iterator<vector, false>            pointer;
-    typedef __bit_iterator<vector, true>             const_pointer;
-    typedef pointer                                  iterator;
-    typedef const_pointer                            const_iterator;
-    typedef std::reverse_iterator<iterator>         reverse_iterator;
-    typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
+  typedef vector __self;
+  typedef bool value_type;
+  typedef _Allocator allocator_type;
+  typedef allocator_traits<allocator_type> __alloc_traits;
+  typedef typename __alloc_traits::size_type size_type;
+  typedef typename __alloc_traits::difference_type difference_type;
+  typedef size_type __storage_type;
+  typedef __bit_iterator<vector, false> pointer;
+  typedef __bit_iterator<vector, true> const_pointer;
+  typedef pointer iterator;
+  typedef const_pointer const_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
 private:
-    typedef __rebind_alloc<__alloc_traits, __storage_type> __storage_allocator;
-    typedef allocator_traits<__storage_allocator>    __storage_traits;
-    typedef typename __storage_traits::pointer       __storage_pointer;
-    typedef typename __storage_traits::const_pointer __const_storage_pointer;
+  typedef __rebind_alloc<__alloc_traits, __storage_type> __storage_allocator;
+  typedef allocator_traits<__storage_allocator> __storage_traits;
+  typedef typename __storage_traits::pointer __storage_pointer;
+  typedef typename __storage_traits::const_pointer __const_storage_pointer;
+
+  __storage_pointer __begin_;
+  size_type __size_;
+  __compressed_pair<size_type, __storage_allocator> __cap_alloc_;
 
-    __storage_pointer                                      __begin_;
-    size_type                                              __size_;
-    __compressed_pair<size_type, __storage_allocator> __cap_alloc_;
 public:
-    typedef __bit_reference<vector>                  reference;
+  typedef __bit_reference<vector> reference;
 #ifdef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
-    using const_reference = bool;
+  using const_reference = bool;
 #else
-    typedef __bit_const_reference<vector>            const_reference;
+  typedef __bit_const_reference<vector> const_reference;
 #endif
+
 private:
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type& __cap() _NOEXCEPT
-        {return __cap_alloc_.first();}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const size_type& __cap() const _NOEXCEPT
-        {return __cap_alloc_.first();}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    __storage_allocator& __alloc() _NOEXCEPT
-        {return __cap_alloc_.second();}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const __storage_allocator& __alloc() const _NOEXCEPT
-        {return __cap_alloc_.second();}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type& __cap() _NOEXCEPT { return __cap_alloc_.first(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const size_type& __cap() const _NOEXCEPT {
+    return __cap_alloc_.first();
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __storage_allocator& __alloc() _NOEXCEPT {
+    return __cap_alloc_.second();
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const __storage_allocator& __alloc() const _NOEXCEPT {
+    return __cap_alloc_.second();
+  }
 
-    static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
+  static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static size_type __internal_cap_to_external(size_type __n) _NOEXCEPT
-        {return __n * __bits_per_word;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static size_type __external_cap_to_internal(size_type __n) _NOEXCEPT
-        {return (__n - 1) / __bits_per_word + 1;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static size_type
+  __internal_cap_to_external(size_type __n) _NOEXCEPT {
+    return __n * __bits_per_word;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static size_type
+  __external_cap_to_internal(size_type __n) _NOEXCEPT {
+    return (__n - 1) / __bits_per_word + 1;
+  }
 
 public:
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    vector() _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector()
+      _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(const allocator_type& __a)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
-        _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
+      _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value);
 #else
-        _NOEXCEPT;
+      _NOEXCEPT;
 #endif
 
 private:
   class __destroy_vector {
-    public:
-      _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI __destroy_vector(vector& __vec) : __vec_(__vec) {}
+  public:
+    _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI __destroy_vector(vector& __vec) : __vec_(__vec) {}
 
-      _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void operator()() {
-        if (__vec_.__begin_ != nullptr)
-            __storage_traits::deallocate(__vec_.__alloc(), __vec_.__begin_, __vec_.__cap());
-        std::__debug_db_invalidate_all(this);
-      }
+    _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void operator()() {
+      if (__vec_.__begin_ != nullptr)
+        __storage_traits::deallocate(__vec_.__alloc(), __vec_.__begin_, __vec_.__cap());
+    }
 
-    private:
-      vector& __vec_;
+  private:
+    vector& __vec_;
   };
 
 public:
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~vector() { __destroy_vector(*this)(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 ~vector() { __destroy_vector (*this)(); }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n);
 #if _LIBCPP_STD_VER >= 14
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit vector(size_type __n, const allocator_type& __a);
 #endif
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v, const allocator_type& __a);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_InputIterator __first, _InputIterator __last,
-               typename enable_if<__has_exactly_input_iterator_category<_InputIterator>::value>::type* = 0);
-    template <class _InputIterator>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
-               typename enable_if<__has_exactly_input_iterator_category<_InputIterator>::value>::type* = 0);
-    template <class _ForwardIterator>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_ForwardIterator __first, _ForwardIterator __last,
-               typename enable_if<__has_forward_iterator_category<_ForwardIterator>::value>::type* = 0);
-    template <class _ForwardIterator>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
-               typename enable_if<__has_forward_iterator_category<_ForwardIterator>::value>::type* = 0);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(size_type __n, const value_type& __v);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  vector(size_type __n, const value_type& __v, const allocator_type& __a);
+  template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_InputIterator __first, _InputIterator __last);
+  template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
+  template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a);
 
 #if _LIBCPP_STD_VER >= 23
-    template <_ContainerCompatibleRange<bool> _Range>
-    _LIBCPP_HIDE_FROM_ABI constexpr
-    vector(from_range_t, _Range&& __range, const allocator_type& __a = allocator_type())
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, static_cast<__storage_allocator>(__a)) {
-      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
-        auto __n = static_cast<size_type>(ranges::distance(__range));
-        __init_with_size(ranges::begin(__range), ranges::end(__range), __n);
+  template <_ContainerCompatibleRange<bool> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr vector(from_range_t, _Range&& __range, const allocator_type& __a = allocator_type())
+      : __begin_(nullptr), __size_(0), __cap_alloc_(0, static_cast<__storage_allocator>(__a)) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      __init_with_size(ranges::begin(__range), ranges::end(__range), __n);
 
-      } else {
-        __init_with_sentinel(ranges::begin(__range), ranges::end(__range));
-      }
+    } else {
+      __init_with_sentinel(ranges::begin(__range), ranges::end(__range));
     }
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(const vector& __v);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(const vector& __v, const allocator_type& __a);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector& operator=(const vector& __v);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(const vector& __v);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(const vector& __v, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector& operator=(const vector& __v);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(initializer_list<value_type> __il);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(initializer_list<value_type> __il, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(initializer_list<value_type> __il);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  vector(initializer_list<value_type> __il, const allocator_type& __a);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    vector& operator=(initializer_list<value_type> __il)
-        {assign(__il.begin(), __il.end()); return *this;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector& operator=(initializer_list<value_type> __il) {
+    assign(__il.begin(), __il.end());
+    return *this;
+  }
 
 #endif // !_LIBCPP_CXX03_LANG
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    vector(vector&& __v)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(vector&& __v)
 #if _LIBCPP_STD_VER >= 17
-        noexcept;
+      noexcept;
 #else
-        _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
+      _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
 #endif
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector(vector&& __v, const __type_identity_t<allocator_type>& __a);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    vector& operator=(vector&& __v)
-        _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value));
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  vector(vector&& __v, const __type_identity_t<allocator_type>& __a);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector& operator=(vector&& __v)
+      _NOEXCEPT_(__noexcept_move_assign_container<_Allocator, __alloc_traits>::value);
 
-    template <class _InputIterator>
-        typename enable_if <__has_exactly_input_iterator_category<_InputIterator>::value,
-           void
-        >::type
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 assign(_InputIterator __first, _InputIterator __last);
-    template <class _ForwardIterator>
-        typename enable_if
-        <
-            __has_forward_iterator_category<_ForwardIterator>::value,
-           void
-        >::type
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 assign(_ForwardIterator __first, _ForwardIterator __last);
+  template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 assign(_InputIterator __first, _InputIterator __last);
+  template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+  void _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 assign(_ForwardIterator __first, _ForwardIterator __last);
 
 #if _LIBCPP_STD_VER >= 23
-    template <_ContainerCompatibleRange<bool> _Range>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void assign_range(_Range&& __range) {
-      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
-        auto __n = static_cast<size_type>(ranges::distance(__range));
-        __assign_with_size(ranges::begin(__range), ranges::end(__range), __n);
+  template <_ContainerCompatibleRange<bool> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr void assign_range(_Range&& __range) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      __assign_with_size(ranges::begin(__range), ranges::end(__range), __n);
 
-      } else {
-        __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
-      }
+    } else {
+      __assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
     }
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void assign(size_type __n, const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void assign(size_type __n, const value_type& __x);
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void assign(initializer_list<value_type> __il)
-        {assign(__il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void assign(initializer_list<value_type> __il) {
+    assign(__il.begin(), __il.end());
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator_type get_allocator() const _NOEXCEPT
-        {return allocator_type(this->__alloc());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator_type get_allocator() const _NOEXCEPT {
+    return allocator_type(this->__alloc());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type max_size() const _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type capacity() const _NOEXCEPT
-        {return __internal_cap_to_external(__cap());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_type size() const _NOEXCEPT
-        {return __size_;}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    bool empty() const _NOEXCEPT
-        {return __size_ == 0;}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reserve(size_type __n);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void shrink_to_fit() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type max_size() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type capacity() const _NOEXCEPT {
+    return __internal_cap_to_external(__cap());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type size() const _NOEXCEPT { return __size_; }
+  _LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool empty() const _NOEXCEPT {
+    return __size_ == 0;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reserve(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void shrink_to_fit() _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    iterator begin() _NOEXCEPT
-        {return __make_iter(0);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_iterator begin() const _NOEXCEPT
-        {return __make_iter(0);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    iterator end() _NOEXCEPT
-        {return __make_iter(__size_);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_iterator end()   const _NOEXCEPT
-        {return __make_iter(__size_);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator begin() _NOEXCEPT { return __make_iter(0); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator begin() const _NOEXCEPT { return __make_iter(0); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator end() _NOEXCEPT { return __make_iter(__size_); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator end() const _NOEXCEPT {
+    return __make_iter(__size_);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    reverse_iterator rbegin() _NOEXCEPT
-        {return       reverse_iterator(end());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    reverse_iterator rend() _NOEXCEPT
-        {return       reverse_iterator(begin());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_reverse_iterator rend()   const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rbegin() _NOEXCEPT {
+    return reverse_iterator(end());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator rbegin() const _NOEXCEPT {
+    return const_reverse_iterator(end());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rend() _NOEXCEPT {
+    return reverse_iterator(begin());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator rend() const _NOEXCEPT {
+    return const_reverse_iterator(begin());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_iterator         cbegin()  const _NOEXCEPT
-        {return __make_iter(0);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_iterator         cend()    const _NOEXCEPT
-        {return __make_iter(__size_);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_reverse_iterator crbegin() const _NOEXCEPT
-        {return rbegin();}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_reverse_iterator crend()   const _NOEXCEPT
-        {return rend();}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cbegin() const _NOEXCEPT { return __make_iter(0); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cend() const _NOEXCEPT {
+    return __make_iter(__size_);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator crbegin() const _NOEXCEPT {
+    return rbegin();
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference       operator[](size_type __n)       {return __make_ref(__n);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference operator[](size_type __n) const {return __make_ref(__n);}
-    _LIBCPP_HIDE_FROM_ABI reference       at(size_type __n);
-    _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __n) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator[](size_type __n) { return __make_ref(__n); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference operator[](size_type __n) const {
+    return __make_ref(__n);
+  }
+  _LIBCPP_HIDE_FROM_ABI reference at(size_type __n);
+  _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __n) const;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference       front()       {return __make_ref(0);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference front() const {return __make_ref(0);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference       back()        {return __make_ref(__size_ - 1);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference back()  const {return __make_ref(__size_ - 1);}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference front() { return __make_ref(0); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference front() const { return __make_ref(0); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference back() { return __make_ref(__size_ - 1); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference back() const { return __make_ref(__size_ - 1); }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void push_back(const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void push_back(const value_type& __x);
 #if _LIBCPP_STD_VER >= 14
-    template <class... _Args>
-#if _LIBCPP_STD_VER >= 17
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference emplace_back(_Args&&... __args)
-#else
-    _LIBCPP_HIDE_FROM_ABI void      emplace_back(_Args&&... __args)
-#endif
-    {
-        push_back ( value_type ( std::forward<_Args>(__args)... ));
-#if _LIBCPP_STD_VER >= 17
-        return this->back();
-#endif
-    }
+  template <class... _Args>
+#  if _LIBCPP_STD_VER >= 17
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference emplace_back(_Args&&... __args)
+#  else
+  _LIBCPP_HIDE_FROM_ABI void emplace_back(_Args&&... __args)
+#  endif
+  {
+    push_back(value_type(std::forward<_Args>(__args)...));
+#  if _LIBCPP_STD_VER >= 17
+    return this->back();
+#  endif
+  }
 #endif
 
 #if _LIBCPP_STD_VER >= 23
-    template <_ContainerCompatibleRange<bool> _Range>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr void append_range(_Range&& __range) {
-      insert_range(end(), std::forward<_Range>(__range));
-    }
+  template <_ContainerCompatibleRange<bool> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr void append_range(_Range&& __range) {
+    insert_range(end(), std::forward<_Range>(__range));
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void pop_back() {--__size_;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void pop_back() { --__size_; }
 
 #if _LIBCPP_STD_VER >= 14
-    template <class... _Args>
-   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator emplace(const_iterator __position, _Args&&... __args)
-        { return insert ( __position, value_type ( std::forward<_Args>(__args)... )); }
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator emplace(const_iterator __position, _Args&&... __args) {
+    return insert(__position, value_type(std::forward<_Args>(__args)...));
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __position, const value_type& __x);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __position, size_type __n, const value_type& __x);
-    template <class _InputIterator>
-        typename enable_if <__has_exactly_input_iterator_category<_InputIterator>::value,
-            iterator
-        >::type
-        _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
-    template <class _ForwardIterator>
-        typename enable_if
-        <
-            __has_forward_iterator_category<_ForwardIterator>::value,
-            iterator
-        >::type
-        _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __position, const value_type& __x);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator
+  insert(const_iterator __position, size_type __n, const value_type& __x);
+  template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
+  iterator _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
+  template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
+  iterator _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+  insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last);
 
 #if _LIBCPP_STD_VER >= 23
-    template <_ContainerCompatibleRange<bool> _Range>
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
-      if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
-        auto __n = static_cast<size_type>(ranges::distance(__range));
-        return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);
+  template <_ContainerCompatibleRange<bool> _Range>
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
+    if constexpr (ranges::forward_range<_Range> || ranges::sized_range<_Range>) {
+      auto __n = static_cast<size_type>(ranges::distance(__range));
+      return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);
 
-      } else {
-        return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
-      }
+    } else {
+      return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
     }
+  }
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    iterator insert(const_iterator __position, initializer_list<value_type> __il)
-        {return insert(__position, __il.begin(), __il.end());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator
+  insert(const_iterator __position, initializer_list<value_type> __il) {
+    return insert(__position, __il.begin(), __il.end());
+  }
 #endif
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator erase(const_iterator __position);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator erase(const_iterator __first, const_iterator __last);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator erase(const_iterator __position);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator erase(const_iterator __first, const_iterator __last);
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void clear() _NOEXCEPT {__size_ = 0;}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void clear() _NOEXCEPT { __size_ = 0; }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(vector&)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(vector&)
 #if _LIBCPP_STD_VER >= 14
-        _NOEXCEPT;
+      _NOEXCEPT;
 #else
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                    __is_nothrow_swappable<allocator_type>::value);
+      _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>);
 #endif
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void swap(reference __x, reference __y) _NOEXCEPT { std::swap(__x, __y); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void swap(reference __x, reference __y) _NOEXCEPT {
+    std::swap(__x, __y);
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void resize(size_type __sz, value_type __x = false);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void flip() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void resize(size_type __sz, value_type __x = false);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void flip() _NOEXCEPT;
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __invariants() const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __invariants() const;
 
 private:
-    _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
-    void __throw_length_error() const {
-        std::__throw_length_error("vector");
-    }
+  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void __throw_length_error() const { std::__throw_length_error("vector"); }
 
-    _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI
-    void __throw_out_of_range() const {
-        std::__throw_out_of_range("vector");
-    }
-
-    template <class _InputIterator, class _Sentinel>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __init_with_size(_InputIterator __first, _Sentinel __last, size_type __n) {
-      auto __guard = std::__make_exception_guard(__destroy_vector(*this));
-
-      if (__n > 0) {
-        __vallocate(__n);
-        __construct_at_end(std::move(__first), std::move(__last), __n);
-      }
-
-      __guard.__complete();
-    }
-
-    template <class _InputIterator, class _Sentinel>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __init_with_sentinel(_InputIterator __first, _Sentinel __last) {
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-      try {
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-        for (; __first != __last; ++__first)
-            push_back(*__first);
-#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-      } catch (...) {
-        if (__begin_ != nullptr)
-          __storage_traits::deallocate(__alloc(), __begin_, __cap());
-        std::__debug_db_invalidate_all(this);
-        throw;
-      }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
-    }
-
-  template <class _Iterator, class _Sentinel>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
-
-  template <class _ForwardIterator, class _Sentinel>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  void __assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __ns);
+  _LIBCPP_NORETURN _LIBCPP_HIDE_FROM_ABI void __throw_out_of_range() const { std::__throw_out_of_range("vector"); }
 
   template <class _InputIterator, class _Sentinel>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  iterator __insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  __init_with_size(_InputIterator __first, _Sentinel __last, size_type __n) {
+    auto __guard = std::__make_exception_guard(__destroy_vector(*this));
+
+    if (__n > 0) {
+      __vallocate(__n);
+      __construct_at_end(std::move(__first), std::move(__last), __n);
+    }
+
+    __guard.__complete();
+  }
+
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  __init_with_sentinel(_InputIterator __first, _Sentinel __last) {
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    try {
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+      for (; __first != __last; ++__first)
+        push_back(*__first);
+#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      if (__begin_ != nullptr)
+        __storage_traits::deallocate(__alloc(), __begin_, __cap());
+      throw;
+    }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 
   template <class _Iterator, class _Sentinel>
-  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-  iterator __insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n);
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __assign_with_sentinel(_Iterator __first, _Sentinel __last);
 
-    //  Allocate space for __n objects
-    //  throws length_error if __n > max_size()
-    //  throws (probably bad_alloc) if memory run out
-    //  Precondition:  __begin_ == __end_ == __cap() == 0
-    //  Precondition:  __n > 0
-    //  Postcondition:  capacity() >= __n
-    //  Postcondition:  size() == 0
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __vallocate(size_type __n) {
-        if (__n > max_size())
-            __throw_length_error();
-        auto __allocation = std::__allocate_at_least(__alloc(), __external_cap_to_internal(__n));
-        __begin_ = __allocation.ptr;
-        __size_ = 0;
-        __cap() = __allocation.count;
-        if (__libcpp_is_constant_evaluated()) {
-            for (size_type __i = 0; __i != __cap(); ++__i)
-                std::__construct_at(std::__to_address(__begin_) + __i);
-        }
+  template <class _ForwardIterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+  __assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __ns);
+
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator
+  __insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last);
+
+  template <class _Iterator, class _Sentinel>
+  _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator
+  __insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n);
+
+  //  Allocate space for __n objects
+  //  throws length_error if __n > max_size()
+  //  throws (probably bad_alloc) if memory run out
+  //  Precondition:  __begin_ == __end_ == __cap() == 0
+  //  Precondition:  __n > 0
+  //  Postcondition:  capacity() >= __n
+  //  Postcondition:  size() == 0
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __vallocate(size_type __n) {
+    if (__n > max_size())
+      __throw_length_error();
+    auto __allocation = std::__allocate_at_least(__alloc(), __external_cap_to_internal(__n));
+    __begin_          = __allocation.ptr;
+    __size_           = 0;
+    __cap()           = __allocation.count;
+    if (__libcpp_is_constant_evaluated()) {
+      for (size_type __i = 0; __i != __cap(); ++__i)
+        std::__construct_at(std::__to_address(__begin_) + __i);
     }
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __vdeallocate() _NOEXCEPT;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    static size_type __align_it(size_type __new_size) _NOEXCEPT
-        {return (__new_size + (__bits_per_word-1)) & ~((size_type)__bits_per_word-1);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20  size_type __recommend(size_type __new_size) const;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_at_end(size_type __n, bool __x);
-    template <class _InputIterator, class _Sentinel>
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __construct_at_end(_InputIterator __first, _Sentinel __last, size_type __n);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __append(size_type __n, const_reference __x);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    reference __make_ref(size_type __pos) _NOEXCEPT
-        {return reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_reference __make_ref(size_type __pos) const _NOEXCEPT {
-        return __bit_const_reference<vector>(__begin_ + __pos / __bits_per_word,
-                                             __storage_type(1) << __pos % __bits_per_word);
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    iterator __make_iter(size_type __pos) _NOEXCEPT
-        {return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    const_iterator __make_iter(size_type __pos) const _NOEXCEPT
-        {return const_iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    iterator __const_iterator_cast(const_iterator __p) _NOEXCEPT
-        {return begin() + (__p - cbegin());}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __vdeallocate() _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static size_type __align_it(size_type __new_size) _NOEXCEPT {
+    return (__new_size + (__bits_per_word - 1)) & ~((size_type)__bits_per_word - 1);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type __recommend(size_type __new_size) const;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_at_end(size_type __n, bool __x);
+  template <class _InputIterator, class _Sentinel>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  __construct_at_end(_InputIterator __first, _Sentinel __last, size_type __n);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __append(size_type __n, const_reference __x);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference __make_ref(size_type __pos) _NOEXCEPT {
+    return reference(__begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference __make_ref(size_type __pos) const _NOEXCEPT {
+    return __bit_const_reference<vector>(
+        __begin_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator __make_iter(size_type __pos) _NOEXCEPT {
+    return iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator __make_iter(size_type __pos) const _NOEXCEPT {
+    return const_iterator(__begin_ + __pos / __bits_per_word, static_cast<unsigned>(__pos % __bits_per_word));
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator __const_iterator_cast(const_iterator __p) _NOEXCEPT {
+    return begin() + (__p - cbegin());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __copy_assign_alloc(const vector& __v)
-        {__copy_assign_alloc(__v, integral_constant<bool,
-                      __storage_traits::propagate_on_container_copy_assignment::value>());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __copy_assign_alloc(const vector& __c, true_type)
-        {
-            if (__alloc() != __c.__alloc())
-                __vdeallocate();
-            __alloc() = __c.__alloc();
-        }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __copy_assign_alloc(const vector& __v) {
+    __copy_assign_alloc(
+        __v, integral_constant<bool, __storage_traits::propagate_on_container_copy_assignment::value>());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __copy_assign_alloc(const vector& __c, true_type) {
+    if (__alloc() != __c.__alloc())
+      __vdeallocate();
+    __alloc() = __c.__alloc();
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __copy_assign_alloc(const vector&, false_type)
-        {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __copy_assign_alloc(const vector&, false_type) {}
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign(vector& __c, false_type);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign(vector& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __move_assign_alloc(vector& __c)
-        _NOEXCEPT_(
-            !__storage_traits::propagate_on_container_move_assignment::value ||
-            is_nothrow_move_assignable<allocator_type>::value)
-        {__move_assign_alloc(__c, integral_constant<bool,
-                      __storage_traits::propagate_on_container_move_assignment::value>());}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __move_assign_alloc(vector& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-        {
-            __alloc() = std::move(__c.__alloc());
-        }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign(vector& __c, false_type);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign(vector& __c, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign_alloc(vector& __c)
+      _NOEXCEPT_(!__storage_traits::propagate_on_container_move_assignment::value ||
+                 is_nothrow_move_assignable<allocator_type>::value) {
+    __move_assign_alloc(
+        __c, integral_constant<bool, __storage_traits::propagate_on_container_move_assignment::value>());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign_alloc(vector& __c, true_type)
+      _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
+    __alloc() = std::move(__c.__alloc());
+  }
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    void __move_assign_alloc(vector&, false_type)
-        _NOEXCEPT
-        {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign_alloc(vector&, false_type) _NOEXCEPT {}
 
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_t __hash_code() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_t __hash_code() const _NOEXCEPT;
 
-    friend class __bit_reference<vector>;
-    friend class __bit_const_reference<vector>;
-    friend class __bit_iterator<vector, false>;
-    friend class __bit_iterator<vector, true>;
-    friend struct __bit_array<vector>;
-    friend struct _LIBCPP_TEMPLATE_VIS hash<vector>;
+  friend class __bit_reference<vector>;
+  friend class __bit_const_reference<vector>;
+  friend class __bit_iterator<vector, false>;
+  friend class __bit_iterator<vector, true>;
+  friend struct __bit_array<vector>;
+  friend struct _LIBCPP_TEMPLATE_VIS hash<vector>;
 };
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<bool, _Allocator>::__vdeallocate() _NOEXCEPT
-{
-    if (this->__begin_ != nullptr)
-    {
-        __storage_traits::deallocate(this->__alloc(), this->__begin_, __cap());
-        std::__debug_db_invalidate_all(this);
-        this->__begin_ = nullptr;
-        this->__size_ = this->__cap() = 0;
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::__vdeallocate() _NOEXCEPT {
+  if (this->__begin_ != nullptr) {
+    __storage_traits::deallocate(this->__alloc(), this->__begin_, __cap());
+    this->__begin_ = nullptr;
+    this->__size_ = this->__cap() = 0;
+  }
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<bool, _Allocator>::size_type
-vector<bool, _Allocator>::max_size() const _NOEXCEPT
-{
-    size_type __amax = __storage_traits::max_size(__alloc());
-    size_type __nmax = numeric_limits<size_type>::max() / 2;  // end() >= begin(), always
-    if (__nmax / __bits_per_word <= __amax)
-        return __nmax;
-    return __internal_cap_to_external(__amax);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<bool, _Allocator>::size_type
+vector<bool, _Allocator>::max_size() const _NOEXCEPT {
+  size_type __amax = __storage_traits::max_size(__alloc());
+  size_type __nmax = numeric_limits<size_type>::max() / 2; // end() >= begin(), always
+  if (__nmax / __bits_per_word <= __amax)
+    return __nmax;
+  return __internal_cap_to_external(__amax);
 }
 
 //  Precondition:  __new_size > capacity()
 template <class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<bool, _Allocator>::size_type
-vector<bool, _Allocator>::__recommend(size_type __new_size) const
-{
-    const size_type __ms = max_size();
-    if (__new_size > __ms)
-        this->__throw_length_error();
-    const size_type __cap = capacity();
-    if (__cap >= __ms / 2)
-        return __ms;
-    return std::max(2 * __cap, __align_it(__new_size));
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<bool, _Allocator>::size_type
+vector<bool, _Allocator>::__recommend(size_type __new_size) const {
+  const size_type __ms = max_size();
+  if (__new_size > __ms)
+    this->__throw_length_error();
+  const size_type __cap = capacity();
+  if (__cap >= __ms / 2)
+    return __ms;
+  return std::max(2 * __cap, __align_it(__new_size));
 }
 
 //  Default constructs __n objects starting at __end_
@@ -2694,166 +2301,116 @@ vector<bool, _Allocator>::__recommend(size_type __new_size) const
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-void
-vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x)
-{
-    size_type __old_size = this->__size_;
-    this->__size_ += __n;
-    if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word))
-    {
-        if (this->__size_ <= __bits_per_word)
-            this->__begin_[0] = __storage_type(0);
-        else
-            this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0);
-    }
-    std::fill_n(__make_iter(__old_size), __n, __x);
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x) {
+  size_type __old_size = this->__size_;
+  this->__size_ += __n;
+  if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word)) {
+    if (this->__size_ <= __bits_per_word)
+      this->__begin_[0] = __storage_type(0);
+    else
+      this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0);
+  }
+  std::fill_n(__make_iter(__old_size), __n, __x);
 }
 
 template <class _Allocator>
 template <class _InputIterator, class _Sentinel>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-void vector<bool, _Allocator>::__construct_at_end(_InputIterator __first, _Sentinel __last, size_type __n) {
-    size_type __old_size = this->__size_;
-    this->__size_ += __n;
-    if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word))
-    {
-        if (this->__size_ <= __bits_per_word)
-            this->__begin_[0] = __storage_type(0);
-        else
-            this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0);
-    }
-    std::__copy<_ClassicAlgPolicy>(__first, __last, __make_iter(__old_size));
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void
+vector<bool, _Allocator>::__construct_at_end(_InputIterator __first, _Sentinel __last, size_type __n) {
+  size_type __old_size = this->__size_;
+  this->__size_ += __n;
+  if (__old_size == 0 || ((__old_size - 1) / __bits_per_word) != ((this->__size_ - 1) / __bits_per_word)) {
+    if (this->__size_ <= __bits_per_word)
+      this->__begin_[0] = __storage_type(0);
+    else
+      this->__begin_[(this->__size_ - 1) / __bits_per_word] = __storage_type(0);
+  }
+  std::__copy<_ClassicAlgPolicy>(__first, __last, __make_iter(__old_size));
 }
 
 template <class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector()
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector()
     _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, __default_init_tag())
-{
-}
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, __default_init_tag()) {}
 
 template <class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(const allocator_type& __a)
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(const allocator_type& __a)
 #if _LIBCPP_STD_VER <= 14
-        _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
+    _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
 #else
         _NOEXCEPT
 #endif
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, static_cast<__storage_allocator>(__a))
-{
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, static_cast<__storage_allocator>(__a)) {
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(size_type __n)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, __default_init_tag())
-{
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__n, false);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(size_type __n)
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, __default_init_tag()) {
+  if (__n > 0) {
+    __vallocate(__n);
+    __construct_at_end(__n, false);
+  }
 }
 
 #if _LIBCPP_STD_VER >= 14
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, static_cast<__storage_allocator>(__a))
-{
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__n, false);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(size_type __n, const allocator_type& __a)
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, static_cast<__storage_allocator>(__a)) {
+  if (__n > 0) {
+    __vallocate(__n);
+    __construct_at_end(__n, false);
+  }
 }
 #endif
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(size_type __n, const value_type& __x)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, __default_init_tag())
-{
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__n, __x);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(size_type __n, const value_type& __x)
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, __default_init_tag()) {
+  if (__n > 0) {
+    __vallocate(__n);
+    __construct_at_end(__n, __x);
+  }
 }
 
 template <class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const allocator_type& __a)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, static_cast<__storage_allocator>(__a))
-{
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__n, __x);
-    }
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, static_cast<__storage_allocator>(__a)) {
+  if (__n > 0) {
+    __vallocate(__n);
+    __construct_at_end(__n, __x);
+  }
 }
 
 template <class _Allocator>
-template <class _InputIterator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last,
-       typename enable_if<__has_exactly_input_iterator_category<_InputIterator>::value>::type*)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, __default_init_tag())
-{
+template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last)
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, __default_init_tag()) {
   __init_with_sentinel(__first, __last);
 }
 
 template <class _Allocator>
-template <class _InputIterator>
+template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a,
-       typename enable_if<__has_exactly_input_iterator_category<_InputIterator>::value>::type*)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, static_cast<__storage_allocator>(__a))
-{
+vector<bool, _Allocator>::vector(_InputIterator __first, _InputIterator __last, const allocator_type& __a)
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, static_cast<__storage_allocator>(__a)) {
   __init_with_sentinel(__first, __last);
 }
 
 template <class _Allocator>
-template <class _ForwardIterator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last,
-                                typename enable_if<__has_forward_iterator_category<_ForwardIterator>::value>::type*)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, __default_init_tag())
-{
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last)
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, __default_init_tag()) {
   auto __n = static_cast<size_type>(std::distance(__first, __last));
   __init_with_size(__first, __last, __n);
 }
 
 template <class _Allocator>
-template <class _ForwardIterator>
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
 _LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
-                                typename enable_if<__has_forward_iterator_category<_ForwardIterator>::value>::type*)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, static_cast<__storage_allocator>(__a))
-{
+vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a)
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, static_cast<__storage_allocator>(__a)) {
   auto __n = static_cast<size_type>(std::distance(__first, __last));
   __init_with_size(__first, __last, __n);
 }
@@ -2861,85 +2418,62 @@ vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __la
 #ifndef _LIBCPP_CXX03_LANG
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(initializer_list<value_type> __il)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, __default_init_tag())
-{
-    size_type __n = static_cast<size_type>(__il.size());
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__il.begin(), __il.end(), __n);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(initializer_list<value_type> __il)
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, __default_init_tag()) {
+  size_type __n = static_cast<size_type>(__il.size());
+  if (__n > 0) {
+    __vallocate(__n);
+    __construct_at_end(__il.begin(), __il.end(), __n);
+  }
 }
 
 template <class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<bool, _Allocator>::vector(initializer_list<value_type> __il, const allocator_type& __a)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, static_cast<__storage_allocator>(__a))
-{
-    size_type __n = static_cast<size_type>(__il.size());
-    if (__n > 0)
-    {
-        __vallocate(__n);
-        __construct_at_end(__il.begin(), __il.end(), __n);
-    }
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, static_cast<__storage_allocator>(__a)) {
+  size_type __n = static_cast<size_type>(__il.size());
+  if (__n > 0) {
+    __vallocate(__n);
+    __construct_at_end(__il.begin(), __il.end(), __n);
+  }
 }
 
 #endif // _LIBCPP_CXX03_LANG
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(const vector& __v)
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(const vector& __v)
     : __begin_(nullptr),
       __size_(0),
-      __cap_alloc_(0, __storage_traits::select_on_container_copy_construction(__v.__alloc()))
-{
-    if (__v.size() > 0)
-    {
-        __vallocate(__v.size());
-        __construct_at_end(__v.begin(), __v.end(), __v.size());
-    }
+      __cap_alloc_(0, __storage_traits::select_on_container_copy_construction(__v.__alloc())) {
+  if (__v.size() > 0) {
+    __vallocate(__v.size());
+    __construct_at_end(__v.begin(), __v.end(), __v.size());
+  }
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>::vector(const vector& __v, const allocator_type& __a)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, __a)
-{
-    if (__v.size() > 0)
-    {
-        __vallocate(__v.size());
-        __construct_at_end(__v.begin(), __v.end(), __v.size());
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(const vector& __v, const allocator_type& __a)
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, __a) {
+  if (__v.size() > 0) {
+    __vallocate(__v.size());
+    __construct_at_end(__v.begin(), __v.end(), __v.size());
+  }
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>&
-vector<bool, _Allocator>::operator=(const vector& __v)
-{
-    if (this != std::addressof(__v))
-    {
-        __copy_assign_alloc(__v);
-        if (__v.__size_)
-        {
-            if (__v.__size_ > capacity())
-            {
-                __vdeallocate();
-                __vallocate(__v.__size_);
-            }
-            std::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_);
-        }
-        __size_ = __v.__size_;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>& vector<bool, _Allocator>::operator=(const vector& __v) {
+  if (this != std::addressof(__v)) {
+    __copy_assign_alloc(__v);
+    if (__v.__size_) {
+      if (__v.__size_ > capacity()) {
+        __vdeallocate();
+        __vallocate(__v.__size_);
+      }
+      std::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_);
     }
-    return *this;
+    __size_ = __v.__size_;
+  }
+  return *this;
 }
 
 template <class _Allocator>
@@ -2952,554 +2486,441 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocat
     : __begin_(__v.__begin_),
       __size_(__v.__size_),
       __cap_alloc_(std::move(__v.__cap_alloc_)) {
-    __v.__begin_ = nullptr;
-    __v.__size_ = 0;
-    __v.__cap() = 0;
+  __v.__begin_ = nullptr;
+  __v.__size_  = 0;
+  __v.__cap()  = 0;
 }
 
 template <class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20
 vector<bool, _Allocator>::vector(vector&& __v, const __type_identity_t<allocator_type>& __a)
-    : __begin_(nullptr),
-      __size_(0),
-      __cap_alloc_(0, __a)
-{
-    if (__a == allocator_type(__v.__alloc()))
-    {
-        this->__begin_ = __v.__begin_;
-        this->__size_ = __v.__size_;
-        this->__cap() = __v.__cap();
-        __v.__begin_ = nullptr;
-        __v.__cap() = __v.__size_ = 0;
-    }
-    else if (__v.size() > 0)
-    {
-        __vallocate(__v.size());
-        __construct_at_end(__v.begin(), __v.end(), __v.size());
-    }
+    : __begin_(nullptr), __size_(0), __cap_alloc_(0, __a) {
+  if (__a == allocator_type(__v.__alloc())) {
+    this->__begin_ = __v.__begin_;
+    this->__size_  = __v.__size_;
+    this->__cap()  = __v.__cap();
+    __v.__begin_   = nullptr;
+    __v.__cap() = __v.__size_ = 0;
+  } else if (__v.size() > 0) {
+    __vallocate(__v.size());
+    __construct_at_end(__v.begin(), __v.end(), __v.size());
+  }
 }
 
 template <class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-vector<bool, _Allocator>&
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>&
 vector<bool, _Allocator>::operator=(vector&& __v)
-    _NOEXCEPT_((__noexcept_move_assign_container<_Allocator, __alloc_traits>::value))
-{
-    __move_assign(__v, integral_constant<bool,
-          __storage_traits::propagate_on_container_move_assignment::value>());
-    return *this;
+    _NOEXCEPT_(__noexcept_move_assign_container<_Allocator, __alloc_traits>::value) {
+  __move_assign(__v, integral_constant<bool, __storage_traits::propagate_on_container_move_assignment::value>());
+  return *this;
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<bool, _Allocator>::__move_assign(vector& __c, false_type)
-{
-    if (__alloc() != __c.__alloc())
-        assign(__c.begin(), __c.end());
-    else
-        __move_assign(__c, true_type());
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::__move_assign(vector& __c, false_type) {
+  if (__alloc() != __c.__alloc())
+    assign(__c.begin(), __c.end());
+  else
+    __move_assign(__c, true_type());
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<bool, _Allocator>::__move_assign(vector& __c, true_type)
-    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
-{
-    __vdeallocate();
-    __move_assign_alloc(__c);
-    this->__begin_ = __c.__begin_;
-    this->__size_ = __c.__size_;
-    this->__cap() = __c.__cap();
-    __c.__begin_ = nullptr;
-    __c.__cap() = __c.__size_ = 0;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::__move_assign(vector& __c, true_type)
+    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
+  __vdeallocate();
+  __move_assign_alloc(__c);
+  this->__begin_ = __c.__begin_;
+  this->__size_  = __c.__size_;
+  this->__cap()  = __c.__cap();
+  __c.__begin_   = nullptr;
+  __c.__cap() = __c.__size_ = 0;
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<bool, _Allocator>::assign(size_type __n, const value_type& __x)
-{
-    __size_ = 0;
-    if (__n > 0)
-    {
-        size_type __c = capacity();
-        if (__n <= __c)
-            __size_ = __n;
-        else
-        {
-            vector __v(get_allocator());
-            __v.reserve(__recommend(__n));
-            __v.__size_ = __n;
-            swap(__v);
-        }
-        std::fill_n(begin(), __n, __x);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::assign(size_type __n, const value_type& __x) {
+  __size_ = 0;
+  if (__n > 0) {
+    size_type __c = capacity();
+    if (__n <= __c)
+      __size_ = __n;
+    else {
+      vector __v(get_allocator());
+      __v.reserve(__recommend(__n));
+      __v.__size_ = __n;
+      swap(__v);
     }
-    std::__debug_db_invalidate_all(this);
+    std::fill_n(begin(), __n, __x);
+  }
 }
 
 template <class _Allocator>
-template <class _InputIterator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 typename enable_if <__has_exactly_input_iterator_category<_InputIterator>::value,
-   void
->::type
-vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last)
-{
+template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::assign(_InputIterator __first, _InputIterator __last) {
   __assign_with_sentinel(__first, __last);
 }
 
 template <class _Allocator>
 template <class _Iterator, class _Sentinel>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-void vector<bool, _Allocator>::__assign_with_sentinel(_Iterator __first, _Sentinel __last) {
-    clear();
-    for (; __first != __last; ++__first)
-        push_back(*__first);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+vector<bool, _Allocator>::__assign_with_sentinel(_Iterator __first, _Sentinel __last) {
+  clear();
+  for (; __first != __last; ++__first)
+    push_back(*__first);
 }
 
 template <class _Allocator>
-template <class _ForwardIterator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __has_forward_iterator_category<_ForwardIterator>::value,
-   void
->::type
-vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
-{
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last) {
   __assign_with_size(__first, __last, std::distance(__first, __last));
 }
 
 template <class _Allocator>
 template <class _ForwardIterator, class _Sentinel>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-void vector<bool, _Allocator>::__assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __ns) {
-    _LIBCPP_ASSERT(__ns >= 0, "invalid range specified");
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
+vector<bool, _Allocator>::__assign_with_size(_ForwardIterator __first, _Sentinel __last, difference_type __ns) {
+  _LIBCPP_ASSERT_VALID_INPUT_RANGE(__ns >= 0, "invalid range specified");
 
-    clear();
+  clear();
 
-    const size_t __n = static_cast<size_type>(__ns);
-    if (__n)
-    {
-        if (__n > capacity())
-        {
-            __vdeallocate();
-            __vallocate(__n);
-        }
-        __construct_at_end(__first, __last, __n);
+  const size_t __n = static_cast<size_type>(__ns);
+  if (__n) {
+    if (__n > capacity()) {
+      __vdeallocate();
+      __vallocate(__n);
     }
+    __construct_at_end(__first, __last, __n);
+  }
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<bool, _Allocator>::reserve(size_type __n)
-{
-    if (__n > capacity())
-    {
-        if (__n > max_size())
-            this->__throw_length_error();
-        vector __v(this->get_allocator());
-        __v.__vallocate(__n);
-        __v.__construct_at_end(this->begin(), this->end(), this->size());
-        swap(__v);
-        std::__debug_db_invalidate_all(this);
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::reserve(size_type __n) {
+  if (__n > capacity()) {
+    if (__n > max_size())
+      this->__throw_length_error();
+    vector __v(this->get_allocator());
+    __v.__vallocate(__n);
+    __v.__construct_at_end(this->begin(), this->end(), this->size());
+    swap(__v);
+  }
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<bool, _Allocator>::shrink_to_fit() _NOEXCEPT
-{
-    if (__external_cap_to_internal(size()) > __cap())
-    {
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::shrink_to_fit() _NOEXCEPT {
+  if (__external_cap_to_internal(size()) > __cap()) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            vector(*this, allocator_type(__alloc())).swap(*this);
+      vector(*this, allocator_type(__alloc())).swap(*this);
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
     }
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
 }
 
 template <class _Allocator>
-typename vector<bool, _Allocator>::reference
-vector<bool, _Allocator>::at(size_type __n)
-{
-    if (__n >= size())
-        this->__throw_out_of_range();
-    return (*this)[__n];
+typename vector<bool, _Allocator>::reference vector<bool, _Allocator>::at(size_type __n) {
+  if (__n >= size())
+    this->__throw_out_of_range();
+  return (*this)[__n];
 }
 
 template <class _Allocator>
-typename vector<bool, _Allocator>::const_reference
-vector<bool, _Allocator>::at(size_type __n) const
-{
-    if (__n >= size())
-        this->__throw_out_of_range();
-    return (*this)[__n];
+typename vector<bool, _Allocator>::const_reference vector<bool, _Allocator>::at(size_type __n) const {
+  if (__n >= size())
+    this->__throw_out_of_range();
+  return (*this)[__n];
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<bool, _Allocator>::push_back(const value_type& __x)
-{
-    if (this->__size_ == this->capacity())
-        reserve(__recommend(this->__size_ + 1));
-    ++this->__size_;
-    back() = __x;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::push_back(const value_type& __x) {
+  if (this->__size_ == this->capacity())
+    reserve(__recommend(this->__size_ + 1));
+  ++this->__size_;
+  back() = __x;
 }
 
 template <class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<bool, _Allocator>::iterator
-vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __x)
-{
-    iterator __r;
-    if (size() < capacity())
-    {
-        const_iterator __old_end = end();
-        ++__size_;
-        std::copy_backward(__position, __old_end, end());
-        __r = __const_iterator_cast(__position);
-    }
-    else
-    {
-        vector __v(get_allocator());
-        __v.reserve(__recommend(__size_ + 1));
-        __v.__size_ = __size_ + 1;
-        __r = std::copy(cbegin(), __position, __v.begin());
-        std::copy_backward(__position, cend(), __v.end());
-        swap(__v);
-    }
-    *__r = __x;
-    return __r;
+vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __x) {
+  iterator __r;
+  if (size() < capacity()) {
+    const_iterator __old_end = end();
+    ++__size_;
+    std::copy_backward(__position, __old_end, end());
+    __r = __const_iterator_cast(__position);
+  } else {
+    vector __v(get_allocator());
+    __v.reserve(__recommend(__size_ + 1));
+    __v.__size_ = __size_ + 1;
+    __r         = std::copy(cbegin(), __position, __v.begin());
+    std::copy_backward(__position, cend(), __v.end());
+    swap(__v);
+  }
+  *__r = __x;
+  return __r;
 }
 
 template <class _Allocator>
 _LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<bool, _Allocator>::iterator
-vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const value_type& __x)
-{
-    iterator __r;
-    size_type __c = capacity();
-    if (__n <= __c && size() <= __c - __n)
-    {
-        const_iterator __old_end = end();
-        __size_ += __n;
-        std::copy_backward(__position, __old_end, end());
-        __r = __const_iterator_cast(__position);
-    }
-    else
-    {
-        vector __v(get_allocator());
-        __v.reserve(__recommend(__size_ + __n));
-        __v.__size_ = __size_ + __n;
-        __r = std::copy(cbegin(), __position, __v.begin());
-        std::copy_backward(__position, cend(), __v.end());
-        swap(__v);
-    }
-    std::fill_n(__r, __n, __x);
-    return __r;
+vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const value_type& __x) {
+  iterator __r;
+  size_type __c = capacity();
+  if (__n <= __c && size() <= __c - __n) {
+    const_iterator __old_end = end();
+    __size_ += __n;
+    std::copy_backward(__position, __old_end, end());
+    __r = __const_iterator_cast(__position);
+  } else {
+    vector __v(get_allocator());
+    __v.reserve(__recommend(__size_ + __n));
+    __v.__size_ = __size_ + __n;
+    __r         = std::copy(cbegin(), __position, __v.begin());
+    std::copy_backward(__position, cend(), __v.end());
+    swap(__v);
+  }
+  std::fill_n(__r, __n, __x);
+  return __r;
 }
 
 template <class _Allocator>
-template <class _InputIterator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 typename enable_if <__has_exactly_input_iterator_category<_InputIterator>::value,
-    typename vector<bool, _Allocator>::iterator
->::type
-vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last)
-{
+template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<bool, _Allocator>::iterator
+vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __first, _InputIterator __last) {
   return __insert_with_sentinel(__position, __first, __last);
 }
 
 template <class _Allocator>
 template <class _InputIterator, class _Sentinel>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-typename vector<bool, _Allocator>::iterator
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI typename vector<bool, _Allocator>::iterator
 vector<bool, _Allocator>::__insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last) {
-    difference_type __off = __position - begin();
-    iterator __p = __const_iterator_cast(__position);
-    iterator __old_end = end();
-    for (; size() != capacity() && __first != __last; ++__first)
-    {
-        ++this->__size_;
-        back() = *__first;
-    }
-    vector __v(get_allocator());
-    if (__first != __last)
-    {
+  difference_type __off = __position - begin();
+  iterator __p          = __const_iterator_cast(__position);
+  iterator __old_end    = end();
+  for (; size() != capacity() && __first != __last; ++__first) {
+    ++this->__size_;
+    back() = *__first;
+  }
+  vector __v(get_allocator());
+  if (__first != __last) {
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        try
-        {
+    try {
 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
-            __v.__assign_with_sentinel(std::move(__first), std::move(__last));
-            difference_type __old_size = static_cast<difference_type>(__old_end - begin());
-            difference_type __old_p = __p - begin();
-            reserve(__recommend(size() + __v.size()));
-            __p = begin() + __old_p;
-            __old_end = begin() + __old_size;
+      __v.__assign_with_sentinel(std::move(__first), std::move(__last));
+      difference_type __old_size = static_cast<difference_type>(__old_end - begin());
+      difference_type __old_p    = __p - begin();
+      reserve(__recommend(size() + __v.size()));
+      __p       = begin() + __old_p;
+      __old_end = begin() + __old_size;
 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
-        }
-        catch (...)
-        {
-            erase(__old_end, end());
-            throw;
-        }
-#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+    } catch (...) {
+      erase(__old_end, end());
+      throw;
     }
-    __p = std::rotate(__p, __old_end, end());
-    insert(__p, __v.begin(), __v.end());
-    return begin() + __off;
+#endif // _LIBCPP_HAS_NO_EXCEPTIONS
+  }
+  __p = std::rotate(__p, __old_end, end());
+  insert(__p, __v.begin(), __v.end());
+  return begin() + __off;
 }
 
 template <class _Allocator>
-template <class _ForwardIterator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename enable_if
-<
-    __has_forward_iterator_category<_ForwardIterator>::value,
-    typename vector<bool, _Allocator>::iterator
->::type
-vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
-{
+template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<bool, _Allocator>::iterator
+vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last) {
   return __insert_with_size(__position, __first, __last, std::distance(__first, __last));
 }
 
 template <class _Allocator>
 template <class _ForwardIterator, class _Sentinel>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
-typename vector<bool, _Allocator>::iterator
-vector<bool, _Allocator>::__insert_with_size(const_iterator __position, _ForwardIterator __first, _Sentinel __last,
-                                             difference_type __n_signed) {
-    _LIBCPP_ASSERT(__n_signed >= 0, "invalid range specified");
-    const size_type __n = static_cast<size_type>(__n_signed);
-    iterator __r;
-    size_type __c = capacity();
-    if (__n <= __c && size() <= __c - __n)
-    {
-        const_iterator __old_end = end();
-        __size_ += __n;
-        std::copy_backward(__position, __old_end, end());
-        __r = __const_iterator_cast(__position);
-    }
-    else
-    {
-        vector __v(get_allocator());
-        __v.reserve(__recommend(__size_ + __n));
-        __v.__size_ = __size_ + __n;
-        __r = std::copy(cbegin(), __position, __v.begin());
-        std::copy_backward(__position, cend(), __v.end());
-        swap(__v);
-    }
-    std::__copy<_ClassicAlgPolicy>(__first, __last, __r);
-    return __r;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI typename vector<bool, _Allocator>::iterator
+vector<bool, _Allocator>::__insert_with_size(
+    const_iterator __position, _ForwardIterator __first, _Sentinel __last, difference_type __n_signed) {
+  _LIBCPP_ASSERT_VALID_INPUT_RANGE(__n_signed >= 0, "invalid range specified");
+  const size_type __n = static_cast<size_type>(__n_signed);
+  iterator __r;
+  size_type __c = capacity();
+  if (__n <= __c && size() <= __c - __n) {
+    const_iterator __old_end = end();
+    __size_ += __n;
+    std::copy_backward(__position, __old_end, end());
+    __r = __const_iterator_cast(__position);
+  } else {
+    vector __v(get_allocator());
+    __v.reserve(__recommend(__size_ + __n));
+    __v.__size_ = __size_ + __n;
+    __r         = std::copy(cbegin(), __position, __v.begin());
+    std::copy_backward(__position, cend(), __v.end());
+    swap(__v);
+  }
+  std::__copy<_ClassicAlgPolicy>(__first, __last, __r);
+  return __r;
 }
 
 template <class _Allocator>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<bool, _Allocator>::iterator
-vector<bool, _Allocator>::erase(const_iterator __position)
-{
-    iterator __r = __const_iterator_cast(__position);
-    std::copy(__position + 1, this->cend(), __r);
-    --__size_;
-    return __r;
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<bool, _Allocator>::iterator
+vector<bool, _Allocator>::erase(const_iterator __position) {
+  iterator __r = __const_iterator_cast(__position);
+  std::copy(__position + 1, this->cend(), __r);
+  --__size_;
+  return __r;
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-typename vector<bool, _Allocator>::iterator
-vector<bool, _Allocator>::erase(const_iterator __first, const_iterator __last)
-{
-    iterator __r = __const_iterator_cast(__first);
-    difference_type __d = __last - __first;
-    std::copy(__last, this->cend(), __r);
-    __size_ -= __d;
-    return __r;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<bool, _Allocator>::iterator
+vector<bool, _Allocator>::erase(const_iterator __first, const_iterator __last) {
+  iterator __r        = __const_iterator_cast(__first);
+  difference_type __d = __last - __first;
+  std::copy(__last, this->cend(), __r);
+  __size_ -= __d;
+  return __r;
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<bool, _Allocator>::swap(vector& __x)
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::swap(vector& __x)
 #if _LIBCPP_STD_VER >= 14
     _NOEXCEPT
 #else
-    _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
-                __is_nothrow_swappable<allocator_type>::value)
+    _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value || __is_nothrow_swappable_v<allocator_type>)
 #endif
 {
-    std::swap(this->__begin_, __x.__begin_);
-    std::swap(this->__size_, __x.__size_);
-    std::swap(this->__cap(), __x.__cap());
-    std::__swap_allocator(this->__alloc(), __x.__alloc(),
-        integral_constant<bool, __alloc_traits::propagate_on_container_swap::value>());
+  std::swap(this->__begin_, __x.__begin_);
+  std::swap(this->__size_, __x.__size_);
+  std::swap(this->__cap(), __x.__cap());
+  std::__swap_allocator(
+      this->__alloc(), __x.__alloc(), integral_constant<bool, __alloc_traits::propagate_on_container_swap::value>());
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<bool, _Allocator>::resize(size_type __sz, value_type __x)
-{
-    size_type __cs = size();
-    if (__cs < __sz)
-    {
-        iterator __r;
-        size_type __c = capacity();
-        size_type __n = __sz - __cs;
-        if (__n <= __c && __cs <= __c - __n)
-        {
-            __r = end();
-            __size_ += __n;
-        }
-        else
-        {
-            vector __v(get_allocator());
-            __v.reserve(__recommend(__size_ + __n));
-            __v.__size_ = __size_ + __n;
-            __r = std::copy(cbegin(), cend(), __v.begin());
-            swap(__v);
-        }
-        std::fill_n(__r, __n, __x);
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::resize(size_type __sz, value_type __x) {
+  size_type __cs = size();
+  if (__cs < __sz) {
+    iterator __r;
+    size_type __c = capacity();
+    size_type __n = __sz - __cs;
+    if (__n <= __c && __cs <= __c - __n) {
+      __r = end();
+      __size_ += __n;
+    } else {
+      vector __v(get_allocator());
+      __v.reserve(__recommend(__size_ + __n));
+      __v.__size_ = __size_ + __n;
+      __r         = std::copy(cbegin(), cend(), __v.begin());
+      swap(__v);
     }
-    else
-        __size_ = __sz;
+    std::fill_n(__r, __n, __x);
+  } else
+    __size_ = __sz;
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 void
-vector<bool, _Allocator>::flip() _NOEXCEPT
-{
-    // do middle whole words
-    size_type __n = __size_;
-    __storage_pointer __p = __begin_;
-    for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
-        *__p = ~*__p;
-    // do last partial word
-    if (__n > 0)
-    {
-        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __storage_type __b = *__p & __m;
-        *__p &= ~__m;
-        *__p |= ~__b & __m;
-    }
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::flip() _NOEXCEPT {
+  // do middle whole words
+  size_type __n         = __size_;
+  __storage_pointer __p = __begin_;
+  for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
+    *__p = ~*__p;
+  // do last partial word
+  if (__n > 0) {
+    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+    __storage_type __b = *__p & __m;
+    *__p &= ~__m;
+    *__p |= ~__b & __m;
+  }
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-vector<bool, _Allocator>::__invariants() const
-{
-    if (this->__begin_ == nullptr)
-    {
-        if (this->__size_ != 0 || this->__cap() != 0)
-            return false;
-    }
-    else
-    {
-        if (this->__cap() == 0)
-            return false;
-        if (this->__size_ > this->capacity())
-            return false;
-    }
-    return true;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 bool vector<bool, _Allocator>::__invariants() const {
+  if (this->__begin_ == nullptr) {
+    if (this->__size_ != 0 || this->__cap() != 0)
+      return false;
+  } else {
+    if (this->__cap() == 0)
+      return false;
+    if (this->__size_ > this->capacity())
+      return false;
+  }
+  return true;
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 size_t
-vector<bool, _Allocator>::__hash_code() const _NOEXCEPT
-{
-    size_t __h = 0;
-    // do middle whole words
-    size_type __n = __size_;
-    __storage_pointer __p = __begin_;
-    for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
-        __h ^= *__p;
-    // do last partial word
-    if (__n > 0)
-    {
-        const __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __h ^= *__p & __m;
-    }
-    return __h;
+_LIBCPP_CONSTEXPR_SINCE_CXX20 size_t vector<bool, _Allocator>::__hash_code() const _NOEXCEPT {
+  size_t __h = 0;
+  // do middle whole words
+  size_type __n         = __size_;
+  __storage_pointer __p = __begin_;
+  for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
+    __h ^= *__p;
+  // do last partial word
+  if (__n > 0) {
+    const __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
+    __h ^= *__p & __m;
+  }
+  return __h;
 }
 
 template <class _Allocator>
 struct _LIBCPP_TEMPLATE_VIS hash<vector<bool, _Allocator> >
-    : public __unary_function<vector<bool, _Allocator>, size_t>
-{
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
-    size_t operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT
-        {return __vec.__hash_code();}
+    : public __unary_function<vector<bool, _Allocator>, size_t> {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_t
+  operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT {
+    return __vec.__hash_code();
+  }
 };
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
-{
-    const typename vector<_Tp, _Allocator>::size_type __sz = __x.size();
-    return __sz == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin());
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) {
+  const typename vector<_Tp, _Allocator>::size_type __sz = __x.size();
+  return __sz == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin());
+}
+
+#if _LIBCPP_STD_VER <= 17
+
+template <class _Tp, class _Allocator>
+inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) {
+  return !(__x == __y);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator!=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
-{
-    return !(__x == __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator<(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) {
+  return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
-{
-    return std::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+inline _LIBCPP_HIDE_FROM_ABI bool operator>(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) {
+  return __y < __x;
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator> (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
-{
-    return __y < __x;
+inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) {
+  return !(__x < __y);
 }
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator>=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
-{
-    return !(__x < __y);
+inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) {
+  return !(__y < __x);
 }
 
-template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-bool
-operator<=(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
-{
-    return !(__y < __x);
-}
+#else // _LIBCPP_STD_VER <= 17
 
 template <class _Tp, class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI
-void
-swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
+_LIBCPP_HIDE_FROM_ABI constexpr __synth_three_way_result<_Tp>
+operator<=>(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y) {
+  return std::lexicographical_compare_three_way(
+      __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
+}
+
+#endif // _LIBCPP_STD_VER <= 17
+
+template <class _Tp, class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void
+swap(vector<_Tp, _Allocator>& __x, vector<_Tp, _Allocator>& __y) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+  __x.swap(__y);
 }
 
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp, class _Allocator, class _Up>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::size_type
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::size_type
 erase(vector<_Tp, _Allocator>& __c, const _Up& __v) {
   auto __old_size = __c.size();
   __c.erase(std::remove(__c.begin(), __c.end(), __v), __c.end());
@@ -3507,8 +2928,7 @@ erase(vector<_Tp, _Allocator>& __c, const _Up& __v) {
 }
 
 template <class _Tp, class _Allocator, class _Predicate>
-_LIBCPP_CONSTEXPR_SINCE_CXX20
-inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::size_type
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::size_type
 erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred) {
   auto __old_size = __c.size();
   __c.erase(std::remove_if(__c.begin(), __c.end(), __pred), __c.end());
@@ -3517,30 +2937,30 @@ erase_if(vector<_Tp, _Allocator>& __c, _Predicate __pred) {
 
 template <>
 inline constexpr bool __format::__enable_insertable<vector<char>> = true;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#  ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 template <>
 inline constexpr bool __format::__enable_insertable<vector<wchar_t>> = true;
-#endif
+#  endif
 
 #endif // _LIBCPP_STD_VER >= 20
 
 #if _LIBCPP_STD_VER >= 23
-template <class _Tp, class CharT>
+template <class _Tp, class _CharT>
 // Since is-vector-bool-reference is only used once it's inlined here.
   requires same_as<typename _Tp::__container, vector<bool, typename _Tp::__container::allocator_type>>
-struct _LIBCPP_TEMPLATE_VIS formatter<_Tp, CharT> {
+struct _LIBCPP_TEMPLATE_VIS formatter<_Tp, _CharT> {
 private:
-  formatter<bool, CharT> __underlying_;
+  formatter<bool, _CharT> __underlying_;
 
 public:
   template <class _ParseContext>
   _LIBCPP_HIDE_FROM_ABI constexpr typename _ParseContext::iterator parse(_ParseContext& __ctx) {
-        return __underlying_.parse(__ctx);
+    return __underlying_.parse(__ctx);
   }
 
   template <class _FormatContext>
   _LIBCPP_HIDE_FROM_ABI typename _FormatContext::iterator format(const _Tp& __ref, _FormatContext& __ctx) const {
-        return __underlying_.format(__ref, __ctx);
+    return __underlying_.format(__ref, __ctx);
   }
 };
 #endif // _LIBCPP_STD_VER >= 23
@@ -3551,7 +2971,7 @@ _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_BEGIN_NAMESPACE_STD
 namespace pmr {
 template <class _ValueT>
-using vector = std::vector<_ValueT, polymorphic_allocator<_ValueT>>;
+using vector _LIBCPP_AVAILABILITY_PMR = std::vector<_ValueT, polymorphic_allocator<_ValueT>>;
 } // namespace pmr
 _LIBCPP_END_NAMESPACE_STD
 #endif
@@ -3563,6 +2983,11 @@ _LIBCPP_POP_MACROS
 #  include <atomic>
 #  include <concepts>
 #  include <cstdlib>
+#  include <iosfwd>
+#  if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#    include <locale>
+#  endif
+#  include <tuple>
 #  include <type_traits>
 #  include <typeinfo>
 #  include <utility>
diff --git a/third_party/libcxx/src/vector.cpp b/third_party/libcxx/vector.cpp
similarity index 79%
rename from third_party/libcxx/src/vector.cpp
rename to third_party/libcxx/vector.cpp
index fa63d5c5e..b6153b0e9 100644
--- a/third_party/libcxx/src/vector.cpp
+++ b/third_party/libcxx/vector.cpp
@@ -21,13 +21,9 @@ struct __vector_base_common<true> {
   _LIBCPP_NORETURN _LIBCPP_EXPORTED_FROM_ABI void __throw_out_of_range() const;
 };
 
-void __vector_base_common<true>::__throw_length_error() const {
-  _VSTD::__throw_length_error("vector");
-}
+void __vector_base_common<true>::__throw_length_error() const { std::__throw_length_error("vector"); }
 
-void __vector_base_common<true>::__throw_out_of_range() const {
-  _VSTD::__throw_out_of_range("vector");
-}
+void __vector_base_common<true>::__throw_out_of_range() const { std::__throw_out_of_range("vector"); }
 
 #endif // _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON
 
diff --git a/third_party/libcxx/src/verbose_abort.cpp b/third_party/libcxx/verbose_abort.cpp
similarity index 95%
rename from third_party/libcxx/src/verbose_abort.cpp
rename to third_party/libcxx/verbose_abort.cpp
index a9fba5e3c..719134e2a 100644
--- a/third_party/libcxx/src/verbose_abort.cpp
+++ b/third_party/libcxx/verbose_abort.cpp
@@ -28,8 +28,7 @@ extern "C" void android_set_abort_message(const char* msg);
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-_LIBCPP_WEAK
-void __libcpp_verbose_abort(char const* format, ...) {
+_LIBCPP_WEAK void __libcpp_verbose_abort(char const* format, ...) {
   // Write message to stderr. We do this before formatting into a
   // buffer so that we still get some information out if that fails.
   {
@@ -41,7 +40,8 @@ void __libcpp_verbose_abort(char const* format, ...) {
 
   // Format the arguments into an allocated buffer for CrashReport & friends.
   // We leak the buffer on purpose, since we're about to abort() anyway.
-  char* buffer; (void)buffer;
+  char* buffer;
+  (void)buffer;
   va_list list;
   va_start(list, format);
 
diff --git a/third_party/libcxx/version b/third_party/libcxx/version
index 0117a9282..40548098a 100644
--- a/third_party/libcxx/version
+++ b/third_party/libcxx/version
@@ -16,7 +16,7 @@
 Macro name                                              Value   Headers
 __cpp_lib_adaptor_iterator_pair_constructor             202106L <queue> <stack>
 __cpp_lib_addressof_constexpr                           201603L <memory>
-__cpp_lib_allocate_at_least                             202106L <memory>
+__cpp_lib_allocate_at_least                             202302L <memory>
 __cpp_lib_allocator_traits_is_always_equal              201411L <deque> <forward_list> <list>
                                                                 <map> <memory> <scoped_allocator>
                                                                 <set> <string> <unordered_map>
@@ -28,20 +28,25 @@ __cpp_lib_array_constexpr                               201811L <array> <iterato
 __cpp_lib_as_const                                      201510L <utility>
 __cpp_lib_associative_heterogeneous_erasure             202110L <map> <set> <unordered_map>
                                                                 <unordered_set>
+__cpp_lib_associative_heterogeneous_insertion           202306L <map> <set> <unordered_map>
+                                                                <unordered_set>
 __cpp_lib_assume_aligned                                201811L <memory>
 __cpp_lib_atomic_flag_test                              201907L <atomic>
 __cpp_lib_atomic_float                                  201711L <atomic>
 __cpp_lib_atomic_is_always_lock_free                    201603L <atomic>
 __cpp_lib_atomic_lock_free_type_aliases                 201907L <atomic>
+__cpp_lib_atomic_min_max                                202403L <atomic>
 __cpp_lib_atomic_ref                                    201806L <atomic>
 __cpp_lib_atomic_shared_ptr                             201711L <atomic>
 __cpp_lib_atomic_value_initialization                   201911L <atomic> <memory>
 __cpp_lib_atomic_wait                                   201907L <atomic>
 __cpp_lib_barrier                                       201907L <barrier>
 __cpp_lib_bind_back                                     202202L <functional>
-__cpp_lib_bind_front                                    201907L <functional>
+__cpp_lib_bind_front                                    202306L <functional>
+                                                        201907L // C++20
 __cpp_lib_bit_cast                                      201806L <bit>
 __cpp_lib_bitops                                        201907L <bit>
+__cpp_lib_bitset                                        202306L <bitset>
 __cpp_lib_bool_constant                                 201505L <type_traits>
 __cpp_lib_bounded_array_traits                          201902L <type_traits>
 __cpp_lib_boyer_moore_searcher                          201603L <functional>
@@ -65,6 +70,7 @@ __cpp_lib_constexpr_functional                          201907L <functional>
 __cpp_lib_constexpr_iterator                            201811L <iterator>
 __cpp_lib_constexpr_memory                              202202L <memory>
                                                         201811L // C++20
+__cpp_lib_constexpr_new                                 202406L <new>
 __cpp_lib_constexpr_numeric                             201911L <numeric>
 __cpp_lib_constexpr_string                              201907L <string>
 __cpp_lib_constexpr_string_view                         201811L <string_view>
@@ -72,7 +78,18 @@ __cpp_lib_constexpr_tuple                               201811L <tuple>
 __cpp_lib_constexpr_typeinfo                            202106L <typeinfo>
 __cpp_lib_constexpr_utility                             201811L <utility>
 __cpp_lib_constexpr_vector                              201907L <vector>
+__cpp_lib_constrained_equality                          202403L <optional> <tuple> <utility>
+                                                                <variant>
+__cpp_lib_containers_ranges                             202202L <deque> <forward_list> <list>
+                                                                <map> <queue> <set>
+                                                                <stack> <string> <unordered_map>
+                                                                <unordered_set> <vector>
+__cpp_lib_copyable_function                             202306L <functional>
 __cpp_lib_coroutine                                     201902L <coroutine>
+__cpp_lib_debugging                                     202311L <debugging>
+__cpp_lib_default_template_type_for_algorithm_values    202403L <algorithm> <deque> <forward_list>
+                                                                <list> <ranges> <string>
+                                                                <vector>
 __cpp_lib_destroying_delete                             201806L <new>
 __cpp_lib_enable_shared_from_this                       201603L <memory>
 __cpp_lib_endian                                        201907L <bit>
@@ -84,17 +101,32 @@ __cpp_lib_execution                                     201902L <execution>
                                                         201603L // C++17
 __cpp_lib_expected                                      202211L <expected>
 __cpp_lib_filesystem                                    201703L <filesystem>
-__cpp_lib_format                                        202106L <format>
+__cpp_lib_format                                        202110L <format>
+__cpp_lib_format_path                                   202403L <filesystem>
 __cpp_lib_format_ranges                                 202207L <format>
+__cpp_lib_format_uchar                                  202311L <format>
 __cpp_lib_formatters                                    202302L <stacktrace> <thread>
 __cpp_lib_forward_like                                  202207L <utility>
+__cpp_lib_freestanding_algorithm                        202311L <algorithm>
+__cpp_lib_freestanding_array                            202311L <array>
+__cpp_lib_freestanding_cstring                          202306L <cstring>
+__cpp_lib_freestanding_expected                         202311L <expected>
+__cpp_lib_freestanding_mdspan                           202311L <mdspan>
+__cpp_lib_freestanding_optional                         202311L <optional>
+__cpp_lib_freestanding_string_view                      202311L <string_view>
+__cpp_lib_freestanding_variant                          202311L <variant>
+__cpp_lib_fstream_native_handle                         202306L <fstream>
+__cpp_lib_function_ref                                  202306L <functional>
 __cpp_lib_gcd_lcm                                       201606L <numeric>
+__cpp_lib_generate_random                               202403L <random>
 __cpp_lib_generic_associative_lookup                    201304L <map> <set>
 __cpp_lib_generic_unordered_lookup                      201811L <unordered_map> <unordered_set>
 __cpp_lib_hardware_interference_size                    201703L <new>
 __cpp_lib_has_unique_object_representations             201606L <type_traits>
+__cpp_lib_hazard_pointer                                202306L <hazard_pointer>
 __cpp_lib_hypot                                         201603L <cmath>
 __cpp_lib_incomplete_container_elements                 201505L <forward_list> <list> <vector>
+__cpp_lib_inplace_vector                                202406L <inplace_vector>
 __cpp_lib_int_pow2                                      202002L <bit>
 __cpp_lib_integer_comparison_functions                  202002L <utility>
 __cpp_lib_integer_sequence                              201304L <utility>
@@ -102,6 +134,7 @@ __cpp_lib_integral_constant_callable                    201304L <type_traits>
 __cpp_lib_interpolate                                   201902L <cmath> <numeric>
 __cpp_lib_invoke                                        201411L <functional>
 __cpp_lib_invoke_r                                      202106L <functional>
+__cpp_lib_ios_noreplace                                 202207L <ios>
 __cpp_lib_is_aggregate                                  201703L <type_traits>
 __cpp_lib_is_constant_evaluated                         201811L <type_traits>
 __cpp_lib_is_final                                      201402L <type_traits>
@@ -112,9 +145,12 @@ __cpp_lib_is_null_pointer                               201309L <type_traits>
 __cpp_lib_is_pointer_interconvertible                   201907L <type_traits>
 __cpp_lib_is_scoped_enum                                202011L <type_traits>
 __cpp_lib_is_swappable                                  201603L <type_traits>
+__cpp_lib_is_virtual_base_of                            202406L <type_traits>
+__cpp_lib_is_within_lifetime                            202306L <type_traits>
 __cpp_lib_jthread                                       201911L <stop_token> <thread>
 __cpp_lib_latch                                         201907L <latch>
 __cpp_lib_launder                                       201606L <new>
+__cpp_lib_linalg                                        202311L <linalg>
 __cpp_lib_list_remove_return_type                       201806L <forward_list> <list>
 __cpp_lib_logical_traits                                201510L <type_traits>
 __cpp_lib_make_from_tuple                               201606L <tuple>
@@ -123,7 +159,8 @@ __cpp_lib_make_unique                                   201304L <memory>
 __cpp_lib_map_try_emplace                               201411L <map>
 __cpp_lib_math_constants                                201907L <numbers>
 __cpp_lib_math_special_functions                        201603L <cmath>
-__cpp_lib_mdspan                                        202207L <mdspan>
+__cpp_lib_mdspan                                        202406L <mdspan>
+                                                        202207L // C++23
 __cpp_lib_memory_resource                               201603L <memory_resource>
 __cpp_lib_move_iterator_concept                         202207L <iterator>
 __cpp_lib_move_only_function                            202110L <functional>
@@ -137,32 +174,43 @@ __cpp_lib_not_fn                                        201603L <functional>
 __cpp_lib_null_iterators                                201304L <iterator>
 __cpp_lib_optional                                      202110L <optional>
                                                         201606L // C++17
-__cpp_lib_out_ptr                                       202106L <memory>
+__cpp_lib_optional_range_support                        202406L <optional>
+__cpp_lib_out_ptr                                       202311L <memory>
+                                                        202106L // C++23
 __cpp_lib_parallel_algorithm                            201603L <algorithm> <numeric>
+__cpp_lib_philox_engine                                 202406L <random>
 __cpp_lib_polymorphic_allocator                         201902L <memory_resource>
+__cpp_lib_print                                         202207L <ostream> <print>
 __cpp_lib_quoted_string_io                              201304L <iomanip>
-__cpp_lib_ranges                                        202106L <algorithm> <functional> <iterator>
+__cpp_lib_ranges                                        202207L <algorithm> <functional> <iterator>
                                                                 <memory> <ranges>
+__cpp_lib_ranges_as_const                               202207L <ranges>
 __cpp_lib_ranges_as_rvalue                              202207L <ranges>
 __cpp_lib_ranges_chunk                                  202202L <ranges>
 __cpp_lib_ranges_chunk_by                               202202L <ranges>
+__cpp_lib_ranges_concat                                 202403L <ranges>
+__cpp_lib_ranges_contains                               202207L <algorithm>
+__cpp_lib_ranges_find_last                              202207L <algorithm>
 __cpp_lib_ranges_iota                                   202202L <numeric>
 __cpp_lib_ranges_join_with                              202202L <ranges>
+__cpp_lib_ranges_repeat                                 202207L <ranges>
 __cpp_lib_ranges_slide                                  202202L <ranges>
 __cpp_lib_ranges_starts_ends_with                       202106L <algorithm>
-__cpp_lib_ranges_to_container                           202202L <deque> <forward_list> <list>
-                                                                <map> <priority_queue> <queue>
-                                                                <set> <stack> <string>
-                                                                <unordered_map> <unordered_set> <vector>
+__cpp_lib_ranges_to_container                           202202L <ranges>
 __cpp_lib_ranges_zip                                    202110L <ranges> <tuple> <utility>
+__cpp_lib_ratio                                         202306L <ratio>
 __cpp_lib_raw_memory_algorithms                         201606L <memory>
+__cpp_lib_rcu                                           202306L <rcu>
 __cpp_lib_reference_from_temporary                      202202L <type_traits>
+__cpp_lib_reference_wrapper                             202403L <functional>
 __cpp_lib_remove_cvref                                  201711L <type_traits>
 __cpp_lib_result_of_sfinae                              201210L <functional> <type_traits>
 __cpp_lib_robust_nonmodifying_seq_ops                   201304L <algorithm>
 __cpp_lib_sample                                        201603L <algorithm>
+__cpp_lib_saturation_arithmetic                         202311L <numeric>
 __cpp_lib_scoped_lock                                   201703L <mutex>
 __cpp_lib_semaphore                                     201907L <semaphore>
+__cpp_lib_senders                                       202406L <execution>
 __cpp_lib_shared_mutex                                  201505L <shared_mutex>
 __cpp_lib_shared_ptr_arrays                             201707L <memory>
                                                         201611L // C++17
@@ -170,28 +218,40 @@ __cpp_lib_shared_ptr_weak_type                          201606L <memory>
 __cpp_lib_shared_timed_mutex                            201402L <shared_mutex>
 __cpp_lib_shift                                         201806L <algorithm>
 __cpp_lib_smart_ptr_for_overwrite                       202002L <memory>
+__cpp_lib_smart_ptr_owner_equality                      202306L <memory>
 __cpp_lib_source_location                               201907L <source_location>
 __cpp_lib_span                                          202002L <span>
+__cpp_lib_span_at                                       202311L <span>
+__cpp_lib_span_initializer_list                         202311L <span>
 __cpp_lib_spanstream                                    202106L <spanstream>
 __cpp_lib_ssize                                         201902L <iterator>
+__cpp_lib_sstream_from_string_view                      202306L <sstream>
 __cpp_lib_stacktrace                                    202011L <stacktrace>
 __cpp_lib_starts_ends_with                              201711L <string> <string_view>
 __cpp_lib_stdatomic_h                                   202011L <stdatomic.h>
 __cpp_lib_string_contains                               202011L <string> <string_view>
 __cpp_lib_string_resize_and_overwrite                   202110L <string>
 __cpp_lib_string_udls                                   201304L <string>
-__cpp_lib_string_view                                   201803L <string> <string_view>
+__cpp_lib_string_view                                   202403L <string> <string_view>
+                                                        201803L // C++20
                                                         201606L // C++17
+__cpp_lib_submdspan                                     202306L <mdspan>
 __cpp_lib_syncbuf                                       201803L <syncstream>
-__cpp_lib_three_way_comparison                          201907L <compare>
+__cpp_lib_text_encoding                                 202306L <text_encoding>
+__cpp_lib_three_way_comparison                          201711L <compare>
 __cpp_lib_to_address                                    201711L <memory>
 __cpp_lib_to_array                                      201907L <array>
-__cpp_lib_to_chars                                      201611L <charconv>
+__cpp_lib_to_chars                                      202306L <charconv>
+                                                        201611L // C++17
+__cpp_lib_to_string                                     202306L <string>
 __cpp_lib_to_underlying                                 202102L <utility>
 __cpp_lib_transformation_trait_aliases                  201304L <type_traits>
 __cpp_lib_transparent_operators                         201510L <functional> <memory>
                                                         201210L // C++14
 __cpp_lib_tuple_element_t                               201402L <tuple>
+__cpp_lib_tuple_like                                    202311L <map> <tuple> <unordered_map>
+                                                                <utility>
+                                                        202207L // C++23
 __cpp_lib_tuples_by_type                                201304L <tuple> <utility>
 __cpp_lib_type_identity                                 201806L <type_traits>
 __cpp_lib_type_trait_variable_templates                 201510L <type_traits>
@@ -204,7 +264,6 @@ __cpp_lib_void_t                                        201411L <type_traits>
 
 */
 
-#include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -225,10 +284,12 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_make_reverse_iterator                201402L
 # define __cpp_lib_make_unique                          201304L
 # define __cpp_lib_null_iterators                       201304L
-# define __cpp_lib_quoted_string_io                     201304L
+# if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   define __cpp_lib_quoted_string_io                   201304L
+# endif
 # define __cpp_lib_result_of_sfinae                     201210L
 # define __cpp_lib_robust_nonmodifying_seq_ops          201304L
-# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX)
+# if !defined(_LIBCPP_HAS_NO_THREADS)
 #   define __cpp_lib_shared_timed_mutex                 201402L
 # endif
 # define __cpp_lib_string_udls                          201304L
@@ -253,7 +314,7 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_clamp                                201603L
 # define __cpp_lib_enable_shared_from_this              201603L
 // # define __cpp_lib_execution                            201603L
-# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_FILESYSTEM)
+# if !defined(_LIBCPP_HAS_NO_FILESYSTEM) && _LIBCPP_AVAILABILITY_HAS_FILESYSTEM_LIBRARY
 #   define __cpp_lib_filesystem                         201703L
 # endif
 # define __cpp_lib_gcd_lcm                              201606L
@@ -272,7 +333,9 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_make_from_tuple                      201606L
 # define __cpp_lib_map_try_emplace                      201411L
 // # define __cpp_lib_math_special_functions               201603L
-# define __cpp_lib_memory_resource                      201603L
+# if _LIBCPP_AVAILABILITY_HAS_PMR
+#   define __cpp_lib_memory_resource                    201603L
+# endif
 # define __cpp_lib_node_extract                         201606L
 # define __cpp_lib_nonmember_container_access           201411L
 # define __cpp_lib_not_fn                               201603L
@@ -280,8 +343,10 @@ __cpp_lib_void_t                                        201411L <type_traits>
 // # define __cpp_lib_parallel_algorithm                   201603L
 # define __cpp_lib_raw_memory_algorithms                201606L
 # define __cpp_lib_sample                               201603L
-# define __cpp_lib_scoped_lock                          201703L
-# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SHARED_MUTEX)
+# if !defined(_LIBCPP_HAS_NO_THREADS)
+#   define __cpp_lib_scoped_lock                        201703L
+# endif
+# if !defined(_LIBCPP_HAS_NO_THREADS)
 #   define __cpp_lib_shared_mutex                       201505L
 # endif
 # define __cpp_lib_shared_ptr_arrays                    201611L
@@ -304,18 +369,18 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_atomic_flag_test                     201907L
 // # define __cpp_lib_atomic_float                         201711L
 # define __cpp_lib_atomic_lock_free_type_aliases        201907L
-// # define __cpp_lib_atomic_ref                           201806L
+# define __cpp_lib_atomic_ref                           201806L
 // # define __cpp_lib_atomic_shared_ptr                    201711L
 # define __cpp_lib_atomic_value_initialization          201911L
-# if !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
+# if _LIBCPP_AVAILABILITY_HAS_SYNC
 #   define __cpp_lib_atomic_wait                        201907L
 # endif
-# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && _LIBCPP_AVAILABILITY_HAS_SYNC
 #   define __cpp_lib_barrier                            201907L
 # endif
 # define __cpp_lib_bind_front                           201907L
 # define __cpp_lib_bit_cast                             201806L
-// # define __cpp_lib_bitops                               201907L
+# define __cpp_lib_bitops                               201907L
 # define __cpp_lib_bounded_array_traits                 201902L
 # if !defined(_LIBCPP_HAS_NO_CHAR8_T)
 #   define __cpp_lib_char8_t                            201907L
@@ -341,7 +406,8 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_erase_if                             202002L
 # undef  __cpp_lib_execution
 // # define __cpp_lib_execution                            201902L
-// # define __cpp_lib_format                               202106L
+# define __cpp_lib_format                               202110L
+# define __cpp_lib_format_uchar                         202311L
 # define __cpp_lib_generic_unordered_lookup             201811L
 # define __cpp_lib_int_pow2                             202002L
 # define __cpp_lib_integer_comparison_functions         202002L
@@ -350,35 +416,37 @@ __cpp_lib_void_t                                        201411L <type_traits>
 // # define __cpp_lib_is_layout_compatible                 201907L
 # define __cpp_lib_is_nothrow_convertible               201806L
 // # define __cpp_lib_is_pointer_interconvertible          201907L
-# if !defined(_LIBCPP_HAS_NO_THREADS)
-// #   define __cpp_lib_jthread                            201911L
+# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN) && _LIBCPP_AVAILABILITY_HAS_SYNC
+#   define __cpp_lib_jthread                            201911L
 # endif
-# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && _LIBCPP_AVAILABILITY_HAS_SYNC
 #   define __cpp_lib_latch                              201907L
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
 # define __cpp_lib_math_constants                       201907L
 # define __cpp_lib_move_iterator_concept                202207L
-# define __cpp_lib_polymorphic_allocator                201902L
-# define __cpp_lib_ranges                               202106L
+# if _LIBCPP_AVAILABILITY_HAS_PMR
+#   define __cpp_lib_polymorphic_allocator              201902L
+# endif
+# define __cpp_lib_ranges                               202207L
 # define __cpp_lib_remove_cvref                         201711L
-# if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_HAS_NO_SYNC)
+# if !defined(_LIBCPP_HAS_NO_THREADS) && _LIBCPP_AVAILABILITY_HAS_SYNC
 #   define __cpp_lib_semaphore                          201907L
 # endif
 # undef  __cpp_lib_shared_ptr_arrays
 # define __cpp_lib_shared_ptr_arrays                    201707L
 # define __cpp_lib_shift                                201806L
 // # define __cpp_lib_smart_ptr_for_overwrite              202002L
-# if __has_builtin(__builtin_source_location) && !(defined(_LIBCPP_APPLE_CLANG_VER) && _LIBCPP_APPLE_CLANG_VER <= 1403)
-#   define __cpp_lib_source_location                    201907L
-# endif
+# define __cpp_lib_source_location                      201907L
 # define __cpp_lib_span                                 202002L
 # define __cpp_lib_ssize                                201902L
 # define __cpp_lib_starts_ends_with                     201711L
 # undef  __cpp_lib_string_view
 # define __cpp_lib_string_view                          201803L
-// # define __cpp_lib_syncbuf                              201803L
-// # define __cpp_lib_three_way_comparison                 201907L
+# if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_SYNCSTREAM)
+#   define __cpp_lib_syncbuf                            201803L
+# endif
+# define __cpp_lib_three_way_comparison                 201711L
 # define __cpp_lib_to_address                           201711L
 # define __cpp_lib_to_array                             201907L
 # define __cpp_lib_type_identity                        201806L
@@ -387,9 +455,9 @@ __cpp_lib_void_t                                        201411L <type_traits>
 
 #if _LIBCPP_STD_VER >= 23
 # define __cpp_lib_adaptor_iterator_pair_constructor    202106L
-# define __cpp_lib_allocate_at_least                    202106L
+# define __cpp_lib_allocate_at_least                    202302L
 // # define __cpp_lib_associative_heterogeneous_erasure    202110L
-// # define __cpp_lib_bind_back                            202202L
+# define __cpp_lib_bind_back                            202202L
 # define __cpp_lib_byteswap                             202110L
 # define __cpp_lib_constexpr_bitset                     202207L
 # define __cpp_lib_constexpr_charconv                   202207L
@@ -397,25 +465,33 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # undef  __cpp_lib_constexpr_memory
 # define __cpp_lib_constexpr_memory                     202202L
 # define __cpp_lib_constexpr_typeinfo                   202106L
+# define __cpp_lib_containers_ranges                    202202L
 # define __cpp_lib_expected                             202211L
 # define __cpp_lib_format_ranges                        202207L
 // # define __cpp_lib_formatters                           202302L
 # define __cpp_lib_forward_like                         202207L
 # define __cpp_lib_invoke_r                             202106L
+# define __cpp_lib_ios_noreplace                        202207L
 # define __cpp_lib_is_scoped_enum                       202011L
-// # define __cpp_lib_mdspan                               202207L
+# define __cpp_lib_mdspan                               202207L
+# define __cpp_lib_modules                              202207L
 // # define __cpp_lib_move_only_function                   202110L
 # undef  __cpp_lib_optional
 # define __cpp_lib_optional                             202110L
-// # define __cpp_lib_out_ptr                              202106L
+# define __cpp_lib_out_ptr                              202106L
+# define __cpp_lib_print                                202207L
+// # define __cpp_lib_ranges_as_const                      202207L
 # define __cpp_lib_ranges_as_rvalue                     202207L
 // # define __cpp_lib_ranges_chunk                         202202L
-// # define __cpp_lib_ranges_chunk_by                      202202L
+# define __cpp_lib_ranges_chunk_by                      202202L
+# define __cpp_lib_ranges_contains                      202207L
+# define __cpp_lib_ranges_find_last                     202207L
 // # define __cpp_lib_ranges_iota                          202202L
 // # define __cpp_lib_ranges_join_with                     202202L
+# define __cpp_lib_ranges_repeat                        202207L
 // # define __cpp_lib_ranges_slide                         202202L
-// # define __cpp_lib_ranges_starts_ends_with              202106L
-// # define __cpp_lib_ranges_to_container                  202202L
+# define __cpp_lib_ranges_starts_ends_with              202106L
+# define __cpp_lib_ranges_to_container                  202202L
 // # define __cpp_lib_ranges_zip                           202110L
 // # define __cpp_lib_reference_from_temporary             202202L
 // # define __cpp_lib_spanstream                           202106L
@@ -424,11 +500,65 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_string_contains                      202011L
 # define __cpp_lib_string_resize_and_overwrite          202110L
 # define __cpp_lib_to_underlying                        202102L
+// # define __cpp_lib_tuple_like                           202207L
 # define __cpp_lib_unreachable                          202202L
 #endif
 
 #if _LIBCPP_STD_VER >= 26
-
+// # define __cpp_lib_associative_heterogeneous_insertion  202306L
+// # define __cpp_lib_atomic_min_max                       202403L
+# undef  __cpp_lib_bind_front
+# define __cpp_lib_bind_front                           202306L
+# define __cpp_lib_bitset                               202306L
+// # define __cpp_lib_constexpr_new                        202406L
+// # define __cpp_lib_constrained_equality                 202403L
+// # define __cpp_lib_copyable_function                    202306L
+// # define __cpp_lib_debugging                            202311L
+// # define __cpp_lib_default_template_type_for_algorithm_values 202403L
+// # define __cpp_lib_format_path                          202403L
+// # define __cpp_lib_freestanding_algorithm               202311L
+// # define __cpp_lib_freestanding_array                   202311L
+// # define __cpp_lib_freestanding_cstring                 202306L
+// # define __cpp_lib_freestanding_expected                202311L
+// # define __cpp_lib_freestanding_mdspan                  202311L
+// # define __cpp_lib_freestanding_optional                202311L
+// # define __cpp_lib_freestanding_string_view             202311L
+// # define __cpp_lib_freestanding_variant                 202311L
+# if !defined(_LIBCPP_HAS_NO_FILESYSTEM) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#   define __cpp_lib_fstream_native_handle              202306L
+# endif
+// # define __cpp_lib_function_ref                         202306L
+// # define __cpp_lib_generate_random                      202403L
+// # define __cpp_lib_hazard_pointer                       202306L
+// # define __cpp_lib_inplace_vector                       202406L
+// # define __cpp_lib_is_virtual_base_of                   202406L
+// # define __cpp_lib_is_within_lifetime                   202306L
+// # define __cpp_lib_linalg                               202311L
+# undef  __cpp_lib_mdspan
+# define __cpp_lib_mdspan                               202406L
+// # define __cpp_lib_optional_range_support               202406L
+# undef  __cpp_lib_out_ptr
+# define __cpp_lib_out_ptr                              202311L
+// # define __cpp_lib_philox_engine                        202406L
+// # define __cpp_lib_ranges_concat                        202403L
+# define __cpp_lib_ratio                                202306L
+// # define __cpp_lib_rcu                                  202306L
+# define __cpp_lib_reference_wrapper                    202403L
+# define __cpp_lib_saturation_arithmetic                202311L
+// # define __cpp_lib_senders                              202406L
+// # define __cpp_lib_smart_ptr_owner_equality             202306L
+# define __cpp_lib_span_at                              202311L
+# define __cpp_lib_span_initializer_list                202311L
+# define __cpp_lib_sstream_from_string_view             202306L
+# undef  __cpp_lib_string_view
+# define __cpp_lib_string_view                          202403L
+// # define __cpp_lib_submdspan                            202306L
+// # define __cpp_lib_text_encoding                        202306L
+# undef  __cpp_lib_to_chars
+// # define __cpp_lib_to_chars                             202306L
+// # define __cpp_lib_to_string                            202306L
+# undef  __cpp_lib_tuple_like
+// # define __cpp_lib_tuple_like                           202311L
 #endif
 
 // clang-format on
diff --git a/third_party/libcxx/wchar.h b/third_party/libcxx/wchar.h
index eeccf3e93..d4268c6d2 100644
--- a/third_party/libcxx/wchar.h
+++ b/third_party/libcxx/wchar.h
@@ -9,14 +9,14 @@
 
 #if defined(__need_wint_t) || defined(__need_mbstate_t)
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
-#include_next <wchar.h>
+#  include_next <wchar.h>
 
 #elif !defined(_LIBCPP_WCHAR_H)
-#define _LIBCPP_WCHAR_H
+#  define _LIBCPP_WCHAR_H
 
 /*
     wchar.h synopsis
@@ -105,22 +105,23 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
 
 */
 
-#include <__config>
-#include <stddef.h>
+#  include <__config>
+#  include <stddef.h>
 
-#if defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
-#   error "The <wchar.h> header is not supported since libc++ has been configured with LIBCXX_ENABLE_WIDE_CHARACTERS disabled"
-#endif
+#  if defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+#    error                                                                                                             \
+        "The <wchar.h> header is not supported since libc++ has been configured with LIBCXX_ENABLE_WIDE_CHARACTERS disabled"
+#  endif
 
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
+#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#    pragma GCC system_header
+#  endif
 
 // We define this here to support older versions of glibc <wchar.h> that do
 // not define this for clang.
-#ifdef __cplusplus
-#define __CORRECT_ISO_CPP_WCHAR_H_PROTO
-#endif
+#  ifdef __cplusplus
+#    define __CORRECT_ISO_CPP_WCHAR_H_PROTO
+#  endif
 
 #  if __has_include_next(<wchar.h>)
 #    include_next <wchar.h>
@@ -129,64 +130,82 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
 #  endif
 
 // Determine whether we have const-correct overloads for wcschr and friends.
-#if defined(_WCHAR_H_CPLUSPLUS_98_CONFORMANCE_)
-#  define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
-#elif defined(__GLIBC_PREREQ)
-#  if __GLIBC_PREREQ(2, 10)
+#  if defined(_WCHAR_H_CPLUSPLUS_98_CONFORMANCE_)
 #    define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
+#  elif defined(__GLIBC_PREREQ)
+#    if __GLIBC_PREREQ(2, 10)
+#      define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
+#    endif
+#  elif defined(_LIBCPP_MSVCRT)
+#    if defined(_CRT_CONST_CORRECT_OVERLOADS)
+#      define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
+#    endif
 #  endif
-#elif defined(_LIBCPP_MSVCRT)
-#  if defined(_CRT_CONST_CORRECT_OVERLOADS)
-#    define _LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS 1
-#  endif
-#endif
 
-#if defined(__cplusplus) && !defined(_LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS) && defined(_LIBCPP_PREFERRED_OVERLOAD)
+#  if defined(__cplusplus) && !defined(_LIBCPP_WCHAR_H_HAS_CONST_OVERLOADS) && defined(_LIBCPP_PREFERRED_OVERLOAD)
 extern "C++" {
-inline _LIBCPP_INLINE_VISIBILITY
-wchar_t* __libcpp_wcschr(const wchar_t* __s, wchar_t __c) {return (wchar_t*)wcschr(__s, __c);}
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-const wchar_t* wcschr(const wchar_t* __s, wchar_t __c) {return __libcpp_wcschr(__s, __c);}
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-      wchar_t* wcschr(      wchar_t* __s, wchar_t __c) {return __libcpp_wcschr(__s, __c);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-wchar_t* __libcpp_wcspbrk(const wchar_t* __s1, const wchar_t* __s2) {return (wchar_t*)wcspbrk(__s1, __s2);}
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-const wchar_t* wcspbrk(const wchar_t* __s1, const wchar_t* __s2) {return __libcpp_wcspbrk(__s1, __s2);}
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-      wchar_t* wcspbrk(      wchar_t* __s1, const wchar_t* __s2) {return __libcpp_wcspbrk(__s1, __s2);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-wchar_t* __libcpp_wcsrchr(const wchar_t* __s, wchar_t __c) {return (wchar_t*)wcsrchr(__s, __c);}
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-const wchar_t* wcsrchr(const wchar_t* __s, wchar_t __c) {return __libcpp_wcsrchr(__s, __c);}
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-      wchar_t* wcsrchr(      wchar_t* __s, wchar_t __c) {return __libcpp_wcsrchr(__s, __c);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-wchar_t* __libcpp_wcsstr(const wchar_t* __s1, const wchar_t* __s2) {return (wchar_t*)wcsstr(__s1, __s2);}
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-const wchar_t* wcsstr(const wchar_t* __s1, const wchar_t* __s2) {return __libcpp_wcsstr(__s1, __s2);}
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-      wchar_t* wcsstr(      wchar_t* __s1, const wchar_t* __s2) {return __libcpp_wcsstr(__s1, __s2);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-wchar_t* __libcpp_wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return (wchar_t*)wmemchr(__s, __c, __n);}
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-const wchar_t* wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-      wchar_t* wmemchr(      wchar_t* __s, wchar_t __c, size_t __n) {return __libcpp_wmemchr(__s, __c, __n);}
+inline _LIBCPP_HIDE_FROM_ABI wchar_t* __libcpp_wcschr(const wchar_t* __s, wchar_t __c) {
+  return (wchar_t*)wcschr(__s, __c);
+}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD const wchar_t* wcschr(const wchar_t* __s, wchar_t __c) {
+  return __libcpp_wcschr(__s, __c);
+}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD wchar_t* wcschr(wchar_t* __s, wchar_t __c) {
+  return __libcpp_wcschr(__s, __c);
 }
-#endif
 
-#if defined(__cplusplus) && (defined(_LIBCPP_MSVCRT_LIKE) || defined(__MVS__))
+inline _LIBCPP_HIDE_FROM_ABI wchar_t* __libcpp_wcspbrk(const wchar_t* __s1, const wchar_t* __s2) {
+  return (wchar_t*)wcspbrk(__s1, __s2);
+}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD const wchar_t*
+wcspbrk(const wchar_t* __s1, const wchar_t* __s2) {
+  return __libcpp_wcspbrk(__s1, __s2);
+}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD wchar_t* wcspbrk(wchar_t* __s1, const wchar_t* __s2) {
+  return __libcpp_wcspbrk(__s1, __s2);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI wchar_t* __libcpp_wcsrchr(const wchar_t* __s, wchar_t __c) {
+  return (wchar_t*)wcsrchr(__s, __c);
+}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD const wchar_t* wcsrchr(const wchar_t* __s, wchar_t __c) {
+  return __libcpp_wcsrchr(__s, __c);
+}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD wchar_t* wcsrchr(wchar_t* __s, wchar_t __c) {
+  return __libcpp_wcsrchr(__s, __c);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI wchar_t* __libcpp_wcsstr(const wchar_t* __s1, const wchar_t* __s2) {
+  return (wchar_t*)wcsstr(__s1, __s2);
+}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD const wchar_t*
+wcsstr(const wchar_t* __s1, const wchar_t* __s2) {
+  return __libcpp_wcsstr(__s1, __s2);
+}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD wchar_t* wcsstr(wchar_t* __s1, const wchar_t* __s2) {
+  return __libcpp_wcsstr(__s1, __s2);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI wchar_t* __libcpp_wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {
+  return (wchar_t*)wmemchr(__s, __c, __n);
+}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD const wchar_t*
+wmemchr(const wchar_t* __s, wchar_t __c, size_t __n) {
+  return __libcpp_wmemchr(__s, __c, __n);
+}
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD wchar_t* wmemchr(wchar_t* __s, wchar_t __c, size_t __n) {
+  return __libcpp_wmemchr(__s, __c, __n);
+}
+}
+#  endif
+
+#  if defined(__cplusplus) && (defined(_LIBCPP_MSVCRT_LIKE) || defined(__MVS__))
 extern "C" {
-size_t mbsnrtowcs(wchar_t *__restrict __dst, const char **__restrict __src,
-                  size_t __nmc, size_t __len, mbstate_t *__restrict __ps);
-size_t wcsnrtombs(char *__restrict __dst, const wchar_t **__restrict __src,
-                  size_t __nwc, size_t __len, mbstate_t *__restrict __ps);
-}  // extern "C"
-#endif  // __cplusplus && (_LIBCPP_MSVCRT || __MVS__)
+size_t mbsnrtowcs(
+    wchar_t* __restrict __dst, const char** __restrict __src, size_t __nmc, size_t __len, mbstate_t* __restrict __ps);
+size_t wcsnrtombs(
+    char* __restrict __dst, const wchar_t** __restrict __src, size_t __nwc, size_t __len, mbstate_t* __restrict __ps);
+} // extern "C"
+#  endif // __cplusplus && (_LIBCPP_MSVCRT || __MVS__)
 
 #endif // _LIBCPP_WCHAR_H
diff --git a/third_party/libcxx/wctype.h b/third_party/libcxx/wctype.h
index e4dc61ad5..c76ec5a3f 100644
--- a/third_party/libcxx/wctype.h
+++ b/third_party/libcxx/wctype.h
@@ -47,7 +47,8 @@ wctrans_t wctrans(const char* property);
 #include <__config>
 
 #if defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
-#   error "The <wctype.h> header is not supported since libc++ has been configured with LIBCXX_ENABLE_WIDE_CHARACTERS disabled"
+#  error                                                                                                               \
+      "The <wctype.h> header is not supported since libc++ has been configured with LIBCXX_ENABLE_WIDE_CHARACTERS disabled"
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -64,30 +65,30 @@ wctrans_t wctrans(const char* property);
 // of these declarations (e.g. <wchar.h>), the second `using ::wint_t` with using_if_exists
 // will fail because it does not refer to the same declaration.
 #if __has_include_next(<wctype.h>)
-#   include_next <wctype.h>
-#   define _LIBCPP_INCLUDED_C_LIBRARY_WCTYPE_H
+#  include_next <wctype.h>
+#  define _LIBCPP_INCLUDED_C_LIBRARY_WCTYPE_H
 #endif
 
 #ifdef __cplusplus
 
-#undef iswalnum
-#undef iswalpha
-#undef iswblank
-#undef iswcntrl
-#undef iswdigit
-#undef iswgraph
-#undef iswlower
-#undef iswprint
-#undef iswpunct
-#undef iswspace
-#undef iswupper
-#undef iswxdigit
-#undef iswctype
-#undef wctype
-#undef towlower
-#undef towupper
-#undef towctrans
-#undef wctrans
+#  undef iswalnum
+#  undef iswalpha
+#  undef iswblank
+#  undef iswcntrl
+#  undef iswdigit
+#  undef iswgraph
+#  undef iswlower
+#  undef iswprint
+#  undef iswpunct
+#  undef iswspace
+#  undef iswupper
+#  undef iswxdigit
+#  undef iswctype
+#  undef wctype
+#  undef towlower
+#  undef towupper
+#  undef towctrans
+#  undef wctrans
 
 #endif // __cplusplus
 
diff --git a/third_party/libcxxabi/BUILD.mk b/third_party/libcxxabi/BUILD.mk
index 062c9e827..24ec19276 100644
--- a/third_party/libcxxabi/BUILD.mk
+++ b/third_party/libcxxabi/BUILD.mk
@@ -90,9 +90,6 @@ $(THIRD_PARTY_LIBCXXABI_A_OBJS): private				\
 			-frtti						\
 			-D_LIBCXXABI_BUILDING_LIBRARY			\
 			-D_LIBCPP_BUILDING_LIBRARY			\
-			-DHAVE___CXA_THREAD_ATEXIT_IMPL			\
-			-D_LIBCPP_CONSTINIT=__constinit			\
-			-Dconstinit=__constinit
 
 # ttypeIndex is initialized and used only when native_old_exception is true.
 # GCC does not seem to allow this.
diff --git a/third_party/libcxxabi/cxa_default_handlers.cc b/third_party/libcxxabi/cxa_default_handlers.cc
index 34fec2e38..493bbda72 100644
--- a/third_party/libcxxabi/cxa_default_handlers.cc
+++ b/third_party/libcxxabi/cxa_default_handlers.cc
@@ -17,7 +17,7 @@
 #include "third_party/libcxxabi/cxa_handlers.h"
 #include "third_party/libcxxabi/cxa_exception.h"
 #include "third_party/libcxxabi/private_typeinfo.h"
-#include "third_party/libcxx/src/include/atomic_support.h" // from libc++
+#include "third_party/libcxx/atomic_support.h" // from libc++
 
 #if !defined(LIBCXXABI_SILENT_TERMINATE)
 
diff --git a/third_party/libcxxabi/cxa_exception.cc b/third_party/libcxxabi/cxa_exception.cc
index b2ea940ea..a389775da 100644
--- a/third_party/libcxxabi/cxa_exception.cc
+++ b/third_party/libcxxabi/cxa_exception.cc
@@ -11,13 +11,14 @@
 //===----------------------------------------------------------------------===//
 
 #include "third_party/libcxxabi/include/cxxabi.h"
+#include "third_party/libcxx/__thread/support.h"
 
-#include "third_party/libcxx/exception"        // for std::terminate
-#include "libc/isystem/string.h"         // for memset
-#include "third_party/libcxxabi/cxa_exception.h"
-#include "third_party/libcxxabi/cxa_handlers.h"
-#include "third_party/libcxxabi/fallback_malloc.h"
-#include "third_party/libcxx/src/include/atomic_support.h" // from libc++
+#include <exception>        // for std::terminate
+#include <string.h>         // for memset
+#include "cxa_exception.h"
+#include "cxa_handlers.h"
+#include "fallback_malloc.h"
+#include "third_party/libcxx/atomic_support.h" // from libc++
 
 #if __has_feature(address_sanitizer)
 #include <sanitizer/asan_interface.h>
@@ -206,6 +207,24 @@ void __cxa_free_exception(void *thrown_object) throw() {
     __aligned_free_with_fallback((void *)raw_buffer);
 }
 
+__cxa_exception* __cxa_init_primary_exception(void* object, std::type_info* tinfo,
+#ifdef __wasm__
+// In Wasm, a destructor returns its argument
+                                              void *(_LIBCXXABI_DTOR_FUNC* dest)(void*)) throw() {
+#else
+                                              void(_LIBCXXABI_DTOR_FUNC* dest)(void*)) throw() {
+#endif
+  __cxa_exception* exception_header = cxa_exception_from_thrown_object(object);
+  exception_header->referenceCount = 0;
+  exception_header->unexpectedHandler = std::get_unexpected();
+  exception_header->terminateHandler = std::get_terminate();
+  exception_header->exceptionType = tinfo;
+  exception_header->exceptionDestructor = dest;
+  setOurExceptionClass(&exception_header->unwindHeader);
+  exception_header->unwindHeader.exception_cleanup = exception_cleanup_func;
+
+  return exception_header;
+}
 
 //  This function shall allocate a __cxa_dependent_exception and
 //  return a pointer to it. (Really to the object, not past its' end).
@@ -254,23 +273,21 @@ will call terminate, assuming that there was no handler for the
 exception.
 */
 void
+#ifdef __wasm__
+// In Wasm, a destructor returns its argument
+__cxa_throw(void *thrown_object, std::type_info *tinfo, void *(_LIBCXXABI_DTOR_FUNC *dest)(void *)) {
+#else
 __cxa_throw(void *thrown_object, std::type_info *tinfo, void (_LIBCXXABI_DTOR_FUNC *dest)(void *)) {
-    __cxa_eh_globals *globals = __cxa_get_globals();
-    __cxa_exception* exception_header = cxa_exception_from_thrown_object(thrown_object);
+#endif
+  __cxa_eh_globals* globals = __cxa_get_globals();
+  globals->uncaughtExceptions += 1; // Not atomically, since globals are thread-local
 
-    exception_header->unexpectedHandler = std::get_unexpected();
-    exception_header->terminateHandler  = std::get_terminate();
-    exception_header->exceptionType = tinfo;
-    exception_header->exceptionDestructor = dest;
-    setOurExceptionClass(&exception_header->unwindHeader);
-    exception_header->referenceCount = 1;  // This is a newly allocated exception, no need for thread safety.
-    globals->uncaughtExceptions += 1;   // Not atomically, since globals are thread-local
-
-    exception_header->unwindHeader.exception_cleanup = exception_cleanup_func;
+  __cxa_exception* exception_header = __cxa_init_primary_exception(thrown_object, tinfo, dest);
+  exception_header->referenceCount = 1; // This is a newly allocated exception, no need for thread safety.
 
 #if __has_feature(address_sanitizer)
-    // Inform the ASan runtime that now might be a good time to clean stuff up.
-    __asan_handle_no_return();
+  // Inform the ASan runtime that now might be a good time to clean stuff up.
+  __asan_handle_no_return();
 #endif
 
 #ifdef __USING_SJLJ_EXCEPTIONS__
@@ -573,6 +590,11 @@ void __cxa_end_catch() {
     }
 }
 
+void __cxa_call_terminate(void* unwind_arg) throw() {
+  __cxa_begin_catch(unwind_arg);
+  std::terminate();
+}
+
 // Note:  exception_header may be masquerading as a __cxa_dependent_exception
 //        and that's ok.  exceptionType is there too.
 //        However watch out for foreign exceptions.  Return null for them.
@@ -771,6 +793,6 @@ __cxa_uncaught_exceptions() throw()
     return globals->uncaughtExceptions;
 }
 
-}  // extern "C"
+} // extern "C"
 
 }  // abi
diff --git a/third_party/libcxxabi/cxa_exception_storage.cc b/third_party/libcxxabi/cxa_exception_storage.cc
index cff0dedf0..505221f51 100644
--- a/third_party/libcxxabi/cxa_exception_storage.cc
+++ b/third_party/libcxxabi/cxa_exception_storage.cc
@@ -11,8 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "third_party/libcxxabi/cxa_exception.h"
-
-#include "third_party/libcxx/__threading_support"
+#include "third_party/libcxx/__thread/support.h"
 
 #if defined(_LIBCXXABI_HAS_NO_THREADS)
 
diff --git a/third_party/libcxxabi/cxa_guard.cc b/third_party/libcxxabi/cxa_guard.cc
index 7f89c4939..e374ae304 100644
--- a/third_party/libcxxabi/cxa_guard.cc
+++ b/third_party/libcxxabi/cxa_guard.cc
@@ -8,6 +8,7 @@
 
 #include "third_party/libcxxabi/include/__cxxabi_config.h"
 #include "third_party/libcxxabi/include/cxxabi.h"
+#include "third_party/libcxx/__thread/support.h"
 
 // Tell the implementation that we're building the actual implementation
 // (and not testing it)
diff --git a/third_party/libcxxabi/cxa_guard_impl.h b/third_party/libcxxabi/cxa_guard_impl.h
index c4adeb50f..568170507 100644
--- a/third_party/libcxxabi/cxa_guard_impl.h
+++ b/third_party/libcxxabi/cxa_guard_impl.h
@@ -45,7 +45,8 @@
  */
 
 #include "third_party/libcxxabi/include/__cxxabi_config.h"
-#include "third_party/libcxx/src/include/atomic_support.h" // from libc++
+#include "third_party/libcxx/__thread/support.h"
+#include "third_party/libcxx/atomic_support.h" // from libc++
 #if defined(__has_include)
 #  if __has_include(<sys/syscall.h>)
 #    include <sys/syscall.h>
@@ -55,7 +56,6 @@
 #  endif
 #endif
 
-#include "third_party/libcxx/__threading_support"
 #include "third_party/libcxx/cstdint"
 #include "third_party/libcxx/cstring"
 #include "libc/isystem/limits.h"
@@ -338,7 +338,10 @@ public:
       return true;
 
     if (has_thread_id_support)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
       *thread_id_address = current_thread_id.get();
+#pragma GCC diagnostic pop
 
     *init_byte_address = PENDING_BIT;
     return false;
diff --git a/third_party/libcxxabi/cxa_handlers.cc b/third_party/libcxxabi/cxa_handlers.cc
index 244e0ae7e..dc6a43331 100644
--- a/third_party/libcxxabi/cxa_handlers.cc
+++ b/third_party/libcxxabi/cxa_handlers.cc
@@ -17,7 +17,7 @@
 #include "third_party/libcxxabi/cxa_handlers.h"
 #include "third_party/libcxxabi/cxa_exception.h"
 #include "third_party/libcxxabi/private_typeinfo.h"
-#include "third_party/libcxx/src/include/atomic_support.h" // from libc++
+#include "third_party/libcxx/atomic_support.h" // from libc++
 
 namespace std
 {
diff --git a/third_party/libcxxabi/cxa_thread_atexit.cc b/third_party/libcxxabi/cxa_thread_atexit.cc
index a8f5b0b02..8f89bff37 100644
--- a/third_party/libcxxabi/cxa_thread_atexit.cc
+++ b/third_party/libcxxabi/cxa_thread_atexit.cc
@@ -8,7 +8,7 @@
 
 #include "third_party/libcxxabi/abort_message.h"
 #include "third_party/libcxxabi/include/cxxabi.h"
-#include "third_party/libcxx/__threading_support"
+#include "third_party/libcxx/__thread/support.h"
 #ifndef _LIBCXXABI_HAS_NO_THREADS
 #if defined(__ELF__) && defined(_LIBCXXABI_LINK_PTHREAD_LIB)
 #pragma comment(lib, "pthread")
diff --git a/third_party/libcxxabi/fallback_malloc.cc b/third_party/libcxxabi/fallback_malloc.cc
index f6ff0fc79..aa7a56e12 100644
--- a/third_party/libcxxabi/fallback_malloc.cc
+++ b/third_party/libcxxabi/fallback_malloc.cc
@@ -7,8 +7,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "third_party/libcxxabi/fallback_malloc.h"
+#include "third_party/libcxx/__thread/support.h"
 
-#include "third_party/libcxx/__threading_support"
 #ifndef _LIBCXXABI_HAS_NO_THREADS
 #if defined(__ELF__) && defined(_LIBCXXABI_LINK_PTHREAD_LIB)
 #pragma comment(lib, "pthread")
diff --git a/third_party/libcxxabi/stdlib_stdexcept.cc b/third_party/libcxxabi/stdlib_stdexcept.cc
index 1d7651846..9b49780db 100644
--- a/third_party/libcxxabi/stdlib_stdexcept.cc
+++ b/third_party/libcxxabi/stdlib_stdexcept.cc
@@ -12,7 +12,7 @@
 #include "third_party/libcxx/cstring"
 #include "third_party/libcxx/cstdint"
 #include "third_party/libcxx/cstddef"
-#include "third_party/libcxx/src/include/refstring.h" // from libc++
+#include "third_party/libcxx/refstring.h" // from libc++
 
 static_assert(sizeof(std::__libcpp_refstring) == sizeof(const char *), "");
 
diff --git a/third_party/libcxxabi/test/BUILD.mk b/third_party/libcxxabi/test/BUILD.mk
index 6899daa64..5eb752f80 100644
--- a/third_party/libcxxabi/test/BUILD.mk
+++ b/third_party/libcxxabi/test/BUILD.mk
@@ -133,8 +133,7 @@ $(THIRD_PARTY_LIBCXXABI_TEST_OBJS): private				\
 			-fexceptions					\
 			-frtti						\
 			-D_LIBCXXABI_BUILDING_LIBRARY			\
-			-D_LIBCPP_BUILDING_LIBRARY			\
-			-D_LIBCPP_CONSTINIT=__constinit
+			-D_LIBCPP_BUILDING_LIBRARY
 
 $(THIRD_PARTY_LIBCXXABI_TEST_OBJS): private CONFIG_CPPFLAGS += -UNDEBUG
 o/$(MODE)/third_party/libcxxabi/test/catch_multi_level_pointer.pass.o: private COPTS += -O0
diff --git a/third_party/libcxxabi/test/catch_const_pointer_nullptr.pass.cc b/third_party/libcxxabi/test/catch_const_pointer_nullptr.pass.cc
index bc19d293e..56a80d98e 100644
--- a/third_party/libcxxabi/test/catch_const_pointer_nullptr.pass.cc
+++ b/third_party/libcxxabi/test/catch_const_pointer_nullptr.pass.cc
@@ -17,6 +17,8 @@
 #pragma clang diagnostic ignored "-Wexceptions"
 #endif
 
+#pragma GCC diagnostic ignored "-Wexceptions"
+
 #if __has_feature(cxx_nullptr)
 
 struct A {};
diff --git a/third_party/libcxxabi/test/test_exception_storage.pass.cc b/third_party/libcxxabi/test/test_exception_storage.pass.cc
index 3027a8c0f..4929463e3 100644
--- a/third_party/libcxxabi/test/test_exception_storage.pass.cc
+++ b/third_party/libcxxabi/test/test_exception_storage.pass.cc
@@ -9,7 +9,6 @@
 #include "third_party/libcxx/algorithm"
 #include "third_party/libcxx/cstdio"
 #include "third_party/libcxx/cstdlib"
-#include "third_party/libcxx/__threading_support"
 #include "libc/isystem/unistd.h"
 
 #include "third_party/libcxxabi/cxa_exception.h"
diff --git a/third_party/libcxxabi/test/test_fallback_malloc.pass.cc b/third_party/libcxxabi/test/test_fallback_malloc.pass.cc
index 38723bf46..cf794bfff 100644
--- a/third_party/libcxxabi/test/test_fallback_malloc.pass.cc
+++ b/third_party/libcxxabi/test/test_fallback_malloc.pass.cc
@@ -11,8 +11,6 @@
 #include "third_party/libcxx/cassert"
 #include "libc/isystem/inttypes.h"
 
-#include "third_party/libcxx/__threading_support"
-
 // UNSUPPORTED: c++03
 // UNSUPPORTED: modules-build && no-threads
 
diff --git a/third_party/libunwind/AddressSpace.hpp b/third_party/libunwind/AddressSpace.hpp
index f7c627141..26ee10c52 100644
--- a/third_party/libunwind/AddressSpace.hpp
+++ b/third_party/libunwind/AddressSpace.hpp
@@ -94,12 +94,12 @@ namespace libunwind {
 //   __eh_frame_hdr_start = SIZEOF(.eh_frame_hdr) > 0 ? ADDR(.eh_frame_hdr) : 0;
 //   __eh_frame_hdr_end = SIZEOF(.eh_frame_hdr) > 0 ? . : 0;
 
-extern char __eh_frame_start;
-extern char __eh_frame_end;
+extern char __eh_frame_start __attribute__((__weak__)); // [jart]
+extern char __eh_frame_end __attribute__((__weak__)); // [jart]
 
 #if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
-extern char __eh_frame_hdr_start;
-extern char __eh_frame_hdr_end;
+extern char __eh_frame_hdr_start __attribute__((__weak__)); // [jart]
+extern char __eh_frame_hdr_end __attribute__((__weak__)); // [jart]
 #endif
 
 #elif defined(_LIBUNWIND_ARM_EHABI) && defined(_LIBUNWIND_IS_BAREMETAL)
diff --git a/third_party/libunwind/BUILD.mk b/third_party/libunwind/BUILD.mk
index 242d4f8d1..560df58b4 100644
--- a/third_party/libunwind/BUILD.mk
+++ b/third_party/libunwind/BUILD.mk
@@ -20,6 +20,7 @@ THIRD_PARTY_LIBUNWIND_A_HDRS =						\
 	third_party/libunwind/include/__libunwind_config.h		\
 	third_party/libunwind/include/libunwind.h			\
 	third_party/libunwind/include/unwind.h				\
+	third_party/libunwind/assembly.h				\
 	third_party/libunwind/config.h					\
 	third_party/libunwind/cet_unwind.h				\
 	third_party/libunwind/dwarf2.h					\
@@ -35,18 +36,23 @@ THIRD_PARTY_LIBUNWIND_A_SRCS_CC =					\
 	third_party/libunwind/libunwind.cc
 
 THIRD_PARTY_LIBUNWIND_A_SRCS_C =					\
-	third_party/libunwind/Unwind-sjlj.c				\
 	third_party/libunwind/UnwindLevel1-gcc-ext.c			\
 	third_party/libunwind/UnwindLevel1.c				\
 	third_party/libunwind/gcc_personality_v0.c
 
+THIRD_PARTY_LIBUNWIND_A_SRCS_S =					\
+	third_party/libunwind/UnwindRegistersRestore.S			\
+	third_party/libunwind/UnwindRegistersSave.S			\
+
 THIRD_PARTY_LIBUNWIND_A_SRCS =						\
 	$(THIRD_PARTY_LIBUNWIND_A_SRCS_C)				\
-	$(THIRD_PARTY_LIBUNWIND_A_SRCS_CC)
+	$(THIRD_PARTY_LIBUNWIND_A_SRCS_CC)				\
+	$(THIRD_PARTY_LIBUNWIND_A_SRCS_S)				\
 
 THIRD_PARTY_LIBUNWIND_A_OBJS =						\
 	$(THIRD_PARTY_LIBUNWIND_A_SRCS_C:%.c=o/$(MODE)/%.o)		\
-	$(THIRD_PARTY_LIBUNWIND_A_SRCS_CC:%.cc=o/$(MODE)/%.o)
+	$(THIRD_PARTY_LIBUNWIND_A_SRCS_CC:%.cc=o/$(MODE)/%.o)		\
+	$(THIRD_PARTY_LIBUNWIND_A_SRCS_S:%.S=o/$(MODE)/%.o)		\
 
 THIRD_PARTY_LIBUNWIND_A_CHECKS =					\
 	$(THIRD_PARTY_LIBUNWIND_A).pkg					\
@@ -55,7 +61,9 @@ THIRD_PARTY_LIBUNWIND_A_CHECKS =					\
 THIRD_PARTY_LIBUNWIND_A_DIRECTDEPS =					\
 	LIBC_CALLS							\
 	LIBC_INTRIN							\
-	LIBC_STDIO
+	LIBC_STDIO							\
+	LIBC_MEM							\
+	LIBC_THREAD							\
 
 THIRD_PARTY_LIBUNWIND_A_DEPS :=						\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_LIBUNWIND_A_DIRECTDEPS),$($(x))))
@@ -75,7 +83,20 @@ $(THIRD_PARTY_LIBUNWIND_A_OBJS): private				\
 			-fno-sanitize=all				\
 			-ffunction-sections				\
 			-fdata-sections					\
-			-D_LIBUNWIND_USE_DLADDR=0
+			-D_LIBUNWIND_USE_DLADDR=0			\
+			-D_LIBUNWIND_IS_BAREMETAL=1			\
+
+# avoid cyclic dependency on libcxxabi
+o/$(MODE)/third_party/libunwind/libunwind.o:				\
+		COPTS +=						\
+			-fno-rtti					\
+
+o/$(MODE)/third_party/libunwind/UnwindRegistersRestore.o: third_party/libunwind/UnwindRegistersRestore.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+o/$(MODE)/third_party/libunwind/UnwindRegistersSave.o: third_party/libunwind/UnwindRegistersSave.S
+	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
+
+$(THIRD_PARTY_LIBUNWIND_A_OBJS): third_party/libunwind/BUILD.mk
 
 THIRD_PARTY_LIBUNWIND_LIBS = $(foreach x,$(THIRD_PARTY_LIBUNWIND_ARTIFACTS),$($(x)))
 THIRD_PARTY_LIBUNWIND_SRCS = $(foreach x,$(THIRD_PARTY_LIBUNWIND_ARTIFACTS),$($(x)_SRCS))
diff --git a/third_party/libunwind/Unwind-sjlj.c b/third_party/libunwind/Unwind-sjlj.c
deleted file mode 100644
index 514358e5b..000000000
--- a/third_party/libunwind/Unwind-sjlj.c
+++ /dev/null
@@ -1,530 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//
-//  Implements setjump-longjump based C++ exceptions
-//
-//===----------------------------------------------------------------------===//
-
-#include "third_party/libunwind/include/unwind.h"
-
-#include "libc/isystem/inttypes.h"
-#include "libc/isystem/stdint.h"
-#include "libc/isystem/stdbool.h"
-#include "libc/isystem/stdlib.h"
-
-#include "third_party/libunwind/config.h"
-
-/// With SJLJ based exceptions, any function that has a catch clause or needs to
-/// do any clean up when an exception propagates through it, needs to call
-/// \c _Unwind_SjLj_Register at the start of the function and
-/// \c _Unwind_SjLj_Unregister at the end.  The register function is called with
-/// the address of a block of memory in the function's stack frame.  The runtime
-/// keeps a linked list (stack) of these blocks - one per thread.  The calling
-/// function also sets the personality and lsda fields of the block.
-
-#if defined(_LIBUNWIND_BUILD_SJLJ_APIS)
-
-typedef uintptr_t _Unwind_Word __attribute__((__mode__(__unwind_word__)));
-
-struct _Unwind_FunctionContext {
-  // next function in stack of handlers
-  struct _Unwind_FunctionContext *prev;
-
-#if defined(__ve__)
-  // VE requires to store 64 bit pointers in the buffer for SjLj exception.
-  // We expand the size of values defined here.  This size must be matched
-  // to the size returned by TargetMachine::getSjLjDataSize().
-
-  // set by calling function before registering to be the landing pad
-  uint64_t                        resumeLocation;
-
-  // set by personality handler to be parameters passed to landing pad function
-  uint64_t                        resumeParameters[4];
-#else
-  // set by calling function before registering to be the landing pad
-  uint32_t                        resumeLocation;
-
-  // set by personality handler to be parameters passed to landing pad function
-  _Unwind_Word                    resumeParameters[4];
-#endif
-
-  // set by calling function before registering
-  _Unwind_Personality_Fn personality;          // arm offset=24
-  uintptr_t                       lsda;        // arm offset=28
-
-  // variable length array, contains registers to restore
-  // 0 = r7, 1 = pc, 2 = sp
-  void                           *jbuf[];
-};
-
-#if defined(_LIBUNWIND_HAS_NO_THREADS)
-# define _LIBUNWIND_THREAD_LOCAL
-#else
-# if __STDC_VERSION__ >= 201112L
-#  define _LIBUNWIND_THREAD_LOCAL _Thread_local
-# elif defined(_MSC_VER)
-#  define _LIBUNWIND_THREAD_LOCAL __declspec(thread)
-# elif defined(__GNUC__) || defined(__clang__)
-#  define _LIBUNWIND_THREAD_LOCAL __thread
-# else
-#  error Unable to create thread local storage
-# endif
-#endif
-
-
-#if !defined(FOR_DYLD)
-
-#if defined(__APPLE__)
-#include <System/pthread_machdep.h>
-#else
-static _LIBUNWIND_THREAD_LOCAL struct _Unwind_FunctionContext *stack = NULL;
-#endif
-
-static struct _Unwind_FunctionContext *__Unwind_SjLj_GetTopOfFunctionStack() {
-#if defined(__APPLE__)
-  return _pthread_getspecific_direct(__PTK_LIBC_DYLD_Unwind_SjLj_Key);
-#else
-  return stack;
-#endif
-}
-
-static void
-__Unwind_SjLj_SetTopOfFunctionStack(struct _Unwind_FunctionContext *fc) {
-#if defined(__APPLE__)
-  _pthread_setspecific_direct(__PTK_LIBC_DYLD_Unwind_SjLj_Key, fc);
-#else
-  stack = fc;
-#endif
-}
-
-#endif
-
-
-/// Called at start of each function that catches exceptions
-_LIBUNWIND_EXPORT void
-_Unwind_SjLj_Register(struct _Unwind_FunctionContext *fc) {
-  fc->prev = __Unwind_SjLj_GetTopOfFunctionStack();
-  __Unwind_SjLj_SetTopOfFunctionStack(fc);
-}
-
-
-/// Called at end of each function that catches exceptions
-_LIBUNWIND_EXPORT void
-_Unwind_SjLj_Unregister(struct _Unwind_FunctionContext *fc) {
-  __Unwind_SjLj_SetTopOfFunctionStack(fc->prev);
-}
-
-
-static _Unwind_Reason_Code
-unwind_phase1(struct _Unwind_Exception *exception_object) {
-  _Unwind_FunctionContext_t c = __Unwind_SjLj_GetTopOfFunctionStack();
-  _LIBUNWIND_TRACE_UNWINDING("unwind_phase1: initial function-context=%p",
-                             (void *)c);
-
-  // walk each frame looking for a place to stop
-  for (bool handlerNotFound = true; handlerNotFound; c = c->prev) {
-
-    // check for no more frames
-    if (c == NULL) {
-      _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): reached "
-                                 "bottom => _URC_END_OF_STACK",
-                                 (void *)exception_object);
-      return _URC_END_OF_STACK;
-    }
-
-    _LIBUNWIND_TRACE_UNWINDING("unwind_phase1: function-context=%p", (void *)c);
-    // if there is a personality routine, ask it if it will want to stop at this
-    // frame
-    if (c->personality != NULL) {
-      _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): calling "
-                                 "personality function %p",
-                                 (void *)exception_object,
-                                 (void *)c->personality);
-      _Unwind_Reason_Code personalityResult = (*c->personality)(
-          1, _UA_SEARCH_PHASE, exception_object->exception_class,
-          exception_object, (struct _Unwind_Context *)c);
-      switch (personalityResult) {
-      case _URC_HANDLER_FOUND:
-        // found a catch clause or locals that need destructing in this frame
-        // stop search and remember function context
-        handlerNotFound = false;
-        exception_object->private_2 = (uintptr_t) c;
-        _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): "
-                                   "_URC_HANDLER_FOUND",
-                                   (void *)exception_object);
-        return _URC_NO_REASON;
-
-      case _URC_CONTINUE_UNWIND:
-        _LIBUNWIND_TRACE_UNWINDING("unwind_phase1(ex_ojb=%p): "
-                                   "_URC_CONTINUE_UNWIND",
-                                   (void *)exception_object);
-        // continue unwinding
-        break;
-
-      default:
-        // something went wrong
-        _LIBUNWIND_TRACE_UNWINDING(
-            "unwind_phase1(ex_ojb=%p): _URC_FATAL_PHASE1_ERROR",
-            (void *)exception_object);
-        return _URC_FATAL_PHASE1_ERROR;
-      }
-    }
-  }
-  return _URC_NO_REASON;
-}
-
-
-static _Unwind_Reason_Code
-unwind_phase2(struct _Unwind_Exception *exception_object) {
-  _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p)",
-                             (void *)exception_object);
-
-  // walk each frame until we reach where search phase said to stop
-  _Unwind_FunctionContext_t c = __Unwind_SjLj_GetTopOfFunctionStack();
-  while (true) {
-    _LIBUNWIND_TRACE_UNWINDING("unwind_phase2s(ex_ojb=%p): context=%p",
-                               (void *)exception_object, (void *)c);
-
-    // check for no more frames
-    if (c == NULL) {
-      _LIBUNWIND_TRACE_UNWINDING(
-          "unwind_phase2(ex_ojb=%p): __unw_step() reached "
-          "bottom => _URC_END_OF_STACK",
-          (void *)exception_object);
-      return _URC_END_OF_STACK;
-    }
-
-    // if there is a personality routine, tell it we are unwinding
-    if (c->personality != NULL) {
-      _Unwind_Action action = _UA_CLEANUP_PHASE;
-      if ((uintptr_t) c == exception_object->private_2)
-        action = (_Unwind_Action)(
-            _UA_CLEANUP_PHASE |
-            _UA_HANDLER_FRAME); // tell personality this was the frame it marked
-                                // in phase 1
-      _Unwind_Reason_Code personalityResult =
-          (*c->personality)(1, action, exception_object->exception_class,
-                            exception_object, (struct _Unwind_Context *)c);
-      switch (personalityResult) {
-      case _URC_CONTINUE_UNWIND:
-        // continue unwinding
-        _LIBUNWIND_TRACE_UNWINDING(
-            "unwind_phase2(ex_ojb=%p): _URC_CONTINUE_UNWIND",
-            (void *)exception_object);
-        if ((uintptr_t) c == exception_object->private_2) {
-          // phase 1 said we would stop at this frame, but we did not...
-          _LIBUNWIND_ABORT("during phase1 personality function said it would "
-                           "stop here, but now if phase2 it did not stop here");
-        }
-        break;
-      case _URC_INSTALL_CONTEXT:
-        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2(ex_ojb=%p): "
-                                   "_URC_INSTALL_CONTEXT, will resume at "
-                                   "landing pad %p",
-                                   (void *)exception_object, c->jbuf[1]);
-        // personality routine says to transfer control to landing pad
-        // we may get control back if landing pad calls _Unwind_Resume()
-        __Unwind_SjLj_SetTopOfFunctionStack(c);
-        __builtin_longjmp(c->jbuf, 1);
-        // __unw_resume() only returns if there was an error
-        return _URC_FATAL_PHASE2_ERROR;
-      default:
-        // something went wrong
-        _LIBUNWIND_DEBUG_LOG("personality function returned unknown result %d",
-                      personalityResult);
-        return _URC_FATAL_PHASE2_ERROR;
-      }
-    }
-    c = c->prev;
-  }
-
-  // clean up phase did not resume at the frame that the search phase said it
-  // would
-  return _URC_FATAL_PHASE2_ERROR;
-}
-
-
-static _Unwind_Reason_Code
-unwind_phase2_forced(struct _Unwind_Exception *exception_object,
-                     _Unwind_Stop_Fn stop, void *stop_parameter) {
-  // walk each frame until we reach where search phase said to stop
-  _Unwind_FunctionContext_t c = __Unwind_SjLj_GetTopOfFunctionStack();
-  while (true) {
-
-    // get next frame (skip over first which is _Unwind_RaiseException)
-    if (c == NULL) {
-      _LIBUNWIND_TRACE_UNWINDING(
-          "unwind_phase2(ex_ojb=%p): __unw_step() reached "
-          "bottom => _URC_END_OF_STACK",
-          (void *)exception_object);
-      return _URC_END_OF_STACK;
-    }
-
-    // call stop function at each frame
-    _Unwind_Action action =
-        (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE);
-    _Unwind_Reason_Code stopResult =
-        (*stop)(1, action, exception_object->exception_class, exception_object,
-                (struct _Unwind_Context *)c, stop_parameter);
-    _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
-                               "stop function returned %d",
-                               (void *)exception_object, stopResult);
-    if (stopResult != _URC_NO_REASON) {
-      _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
-                                 "stopped by stop function",
-                                 (void *)exception_object);
-      return _URC_FATAL_PHASE2_ERROR;
-    }
-
-    // if there is a personality routine, tell it we are unwinding
-    if (c->personality != NULL) {
-      _Unwind_Personality_Fn p = (_Unwind_Personality_Fn)c->personality;
-      _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
-                                 "calling personality function %p",
-                                 (void *)exception_object, (void *)p);
-      _Unwind_Reason_Code personalityResult =
-          (*p)(1, action, exception_object->exception_class, exception_object,
-               (struct _Unwind_Context *)c);
-      switch (personalityResult) {
-      case _URC_CONTINUE_UNWIND:
-        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p):  "
-                                   "personality returned _URC_CONTINUE_UNWIND",
-                                   (void *)exception_object);
-        // destructors called, continue unwinding
-        break;
-      case _URC_INSTALL_CONTEXT:
-        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
-                                   "personality returned _URC_INSTALL_CONTEXT",
-                                   (void *)exception_object);
-        // we may get control back if landing pad calls _Unwind_Resume()
-        __Unwind_SjLj_SetTopOfFunctionStack(c);
-        __builtin_longjmp(c->jbuf, 1);
-        break;
-      default:
-        // something went wrong
-        _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): "
-                                   "personality returned %d, "
-                                   "_URC_FATAL_PHASE2_ERROR",
-                                   (void *)exception_object, personalityResult);
-        return _URC_FATAL_PHASE2_ERROR;
-      }
-    }
-    c = c->prev;
-  }
-
-  // call stop function one last time and tell it we've reached the end of the
-  // stack
-  _LIBUNWIND_TRACE_UNWINDING("unwind_phase2_forced(ex_ojb=%p): calling stop "
-                             "function with _UA_END_OF_STACK",
-                             (void *)exception_object);
-  _Unwind_Action lastAction =
-      (_Unwind_Action)(_UA_FORCE_UNWIND | _UA_CLEANUP_PHASE | _UA_END_OF_STACK);
-  (*stop)(1, lastAction, exception_object->exception_class, exception_object,
-          (struct _Unwind_Context *)c, stop_parameter);
-
-  // clean up phase did not resume at the frame that the search phase said it
-  // would
-  return _URC_FATAL_PHASE2_ERROR;
-}
-
-
-/// Called by __cxa_throw.  Only returns if there is a fatal error
-_LIBUNWIND_EXPORT _Unwind_Reason_Code
-_Unwind_SjLj_RaiseException(struct _Unwind_Exception *exception_object) {
-  _LIBUNWIND_TRACE_API("_Unwind_SjLj_RaiseException(ex_obj=%p)",
-                       (void *)exception_object);
-
-  // mark that this is a non-forced unwind, so _Unwind_Resume() can do the right
-  // thing
-  exception_object->private_1 = 0;
-  exception_object->private_2 = 0;
-
-  // phase 1: the search phase
-  _Unwind_Reason_Code phase1 = unwind_phase1(exception_object);
-  if (phase1 != _URC_NO_REASON)
-    return phase1;
-
-  // phase 2: the clean up phase
-  return unwind_phase2(exception_object);
-}
-
-
-
-/// When _Unwind_RaiseException() is in phase2, it hands control
-/// to the personality function at each frame.  The personality
-/// may force a jump to a landing pad in that function, the landing
-/// pad code may then call _Unwind_Resume() to continue with the
-/// unwinding.  Note: the call to _Unwind_Resume() is from compiler
-/// generated user code.  All other _Unwind_* routines are called
-/// by the C++ runtime __cxa_* routines.
-///
-/// Re-throwing an exception is implemented by having the code call
-/// __cxa_rethrow() which in turn calls _Unwind_Resume_or_Rethrow()
-_LIBUNWIND_EXPORT void
-_Unwind_SjLj_Resume(struct _Unwind_Exception *exception_object) {
-  _LIBUNWIND_TRACE_API("_Unwind_SjLj_Resume(ex_obj=%p)",
-                       (void *)exception_object);
-
-  if (exception_object->private_1 != 0)
-    unwind_phase2_forced(exception_object,
-                         (_Unwind_Stop_Fn) exception_object->private_1,
-                         (void *)exception_object->private_2);
-  else
-    unwind_phase2(exception_object);
-
-  // clients assume _Unwind_Resume() does not return, so all we can do is abort.
-  _LIBUNWIND_ABORT("_Unwind_SjLj_Resume() can't return");
-}
-
-
-///  Called by __cxa_rethrow().
-_LIBUNWIND_EXPORT _Unwind_Reason_Code
-_Unwind_SjLj_Resume_or_Rethrow(struct _Unwind_Exception *exception_object) {
-  _LIBUNWIND_TRACE_API("__Unwind_SjLj_Resume_or_Rethrow(ex_obj=%p), "
-                       "private_1=%" PRIuPTR,
-                       (void *)exception_object, exception_object->private_1);
-  // If this is non-forced and a stopping place was found, then this is a
-  // re-throw.
-  // Call _Unwind_RaiseException() as if this was a new exception.
-  if (exception_object->private_1 == 0) {
-    return _Unwind_SjLj_RaiseException(exception_object);
-    // should return if there is no catch clause, so that __cxa_rethrow can call
-    // std::terminate()
-  }
-
-  // Call through to _Unwind_Resume() which distinguishes between forced and
-  // regular exceptions.
-  _Unwind_SjLj_Resume(exception_object);
-  _LIBUNWIND_ABORT("__Unwind_SjLj_Resume_or_Rethrow() called "
-                    "_Unwind_SjLj_Resume() which unexpectedly returned");
-}
-
-
-/// Called by personality handler during phase 2 to get LSDA for current frame.
-_LIBUNWIND_EXPORT uintptr_t
-_Unwind_GetLanguageSpecificData(struct _Unwind_Context *context) {
-  _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
-  _LIBUNWIND_TRACE_API("_Unwind_GetLanguageSpecificData(context=%p) "
-                       "=> 0x%" PRIuPTR,
-                       (void *)context, ufc->lsda);
-  return ufc->lsda;
-}
-
-
-/// Called by personality handler during phase 2 to get register values.
-_LIBUNWIND_EXPORT uintptr_t _Unwind_GetGR(struct _Unwind_Context *context,
-                                          int index) {
-  _LIBUNWIND_TRACE_API("_Unwind_GetGR(context=%p, reg=%d)", (void *)context,
-                       index);
-  _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
-  return ufc->resumeParameters[index];
-}
-
-
-/// Called by personality handler during phase 2 to alter register values.
-_LIBUNWIND_EXPORT void _Unwind_SetGR(struct _Unwind_Context *context, int index,
-                                     uintptr_t new_value) {
-  _LIBUNWIND_TRACE_API("_Unwind_SetGR(context=%p, reg=%d, value=0x%" PRIuPTR
-                       ")",
-                       (void *)context, index, new_value);
-  _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
-  ufc->resumeParameters[index] = new_value;
-}
-
-
-/// Called by personality handler during phase 2 to get instruction pointer.
-_LIBUNWIND_EXPORT uintptr_t _Unwind_GetIP(struct _Unwind_Context *context) {
-  _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
-  _LIBUNWIND_TRACE_API("_Unwind_GetIP(context=%p) => 0x%" PRIu32,
-                       (void *)context, ufc->resumeLocation + 1);
-  return ufc->resumeLocation + 1;
-}
-
-
-/// Called by personality handler during phase 2 to get instruction pointer.
-/// ipBefore is a boolean that says if IP is already adjusted to be the call
-/// site address.  Normally IP is the return address.
-_LIBUNWIND_EXPORT uintptr_t _Unwind_GetIPInfo(struct _Unwind_Context *context,
-                                              int *ipBefore) {
-  _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
-  *ipBefore = 0;
-  _LIBUNWIND_TRACE_API("_Unwind_GetIPInfo(context=%p, %p) => 0x%" PRIu32,
-                       (void *)context, (void *)ipBefore,
-                       ufc->resumeLocation + 1);
-  return ufc->resumeLocation + 1;
-}
-
-
-/// Called by personality handler during phase 2 to alter instruction pointer.
-_LIBUNWIND_EXPORT void _Unwind_SetIP(struct _Unwind_Context *context,
-                                     uintptr_t new_value) {
-  _LIBUNWIND_TRACE_API("_Unwind_SetIP(context=%p, value=0x%" PRIuPTR ")",
-                       (void *)context, new_value);
-  _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
-  ufc->resumeLocation = new_value - 1;
-}
-
-
-/// Called by personality handler during phase 2 to find the start of the
-/// function.
-_LIBUNWIND_EXPORT uintptr_t
-_Unwind_GetRegionStart(struct _Unwind_Context *context) {
-  // Not supported or needed for sjlj based unwinding
-  (void)context;
-  _LIBUNWIND_TRACE_API("_Unwind_GetRegionStart(context=%p)", (void *)context);
-  return 0;
-}
-
-
-/// Called by personality handler during phase 2 if a foreign exception
-/// is caught.
-_LIBUNWIND_EXPORT void
-_Unwind_DeleteException(struct _Unwind_Exception *exception_object) {
-  _LIBUNWIND_TRACE_API("_Unwind_DeleteException(ex_obj=%p)",
-                       (void *)exception_object);
-  if (exception_object->exception_cleanup != NULL)
-    (*exception_object->exception_cleanup)(_URC_FOREIGN_EXCEPTION_CAUGHT,
-                                           exception_object);
-}
-
-
-
-/// Called by personality handler during phase 2 to get base address for data
-/// relative encodings.
-_LIBUNWIND_EXPORT uintptr_t
-_Unwind_GetDataRelBase(struct _Unwind_Context *context) {
-  // Not supported or needed for sjlj based unwinding
-  (void)context;
-  _LIBUNWIND_TRACE_API("_Unwind_GetDataRelBase(context=%p)", (void *)context);
-  _LIBUNWIND_ABORT("_Unwind_GetDataRelBase() not implemented");
-}
-
-
-/// Called by personality handler during phase 2 to get base address for text
-/// relative encodings.
-_LIBUNWIND_EXPORT uintptr_t
-_Unwind_GetTextRelBase(struct _Unwind_Context *context) {
-  // Not supported or needed for sjlj based unwinding
-  (void)context;
-  _LIBUNWIND_TRACE_API("_Unwind_GetTextRelBase(context=%p)", (void *)context);
-  _LIBUNWIND_ABORT("_Unwind_GetTextRelBase() not implemented");
-}
-
-
-/// Called by personality handler to get "Call Frame Area" for current frame.
-_LIBUNWIND_EXPORT uintptr_t _Unwind_GetCFA(struct _Unwind_Context *context) {
-  _LIBUNWIND_TRACE_API("_Unwind_GetCFA(context=%p)", (void *)context);
-  if (context != NULL) {
-    _Unwind_FunctionContext_t ufc = (_Unwind_FunctionContext_t) context;
-    // Setjmp/longjmp based exceptions don't have a true CFA.
-    // Instead, the SP in the jmpbuf is the closest approximation.
-    return (uintptr_t) ufc->jbuf[2];
-  }
-  return 0;
-}
-
-#endif // defined(_LIBUNWIND_BUILD_SJLJ_APIS)
diff --git a/third_party/libunwind/UnwindRegistersRestore.S b/third_party/libunwind/UnwindRegistersRestore.S
new file mode 100644
index 000000000..180a66582
--- /dev/null
+++ b/third_party/libunwind/UnwindRegistersRestore.S
@@ -0,0 +1,1256 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "assembly.h"
+
+#define FROM_0_TO_15 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+#define FROM_16_TO_31 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
+
+#define FROM_0_TO_31 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
+#define FROM_32_TO_63 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63
+
+#if defined(_AIX)
+  .toc
+#else
+  .text
+#endif
+
+#if !defined(__USING_SJLJ_EXCEPTIONS__) && !defined(__wasm__)
+
+#if defined(__i386__)
+DEFINE_LIBUNWIND_FUNCTION(__libunwind_Registers_x86_jumpto)
+#
+# extern "C" void __libunwind_Registers_x86_jumpto(Registers_x86 *);
+#
+# On entry:
+#  +                       +
+#  +-----------------------+
+#  + thread_state pointer  +
+#  +-----------------------+
+#  + return address        +
+#  +-----------------------+   <-- SP
+#  +                       +
+
+  _LIBUNWIND_CET_ENDBR
+  movl   4(%esp), %eax
+  # set up eax and ret on new stack location
+  movl  28(%eax), %edx # edx holds new stack pointer
+  subl  $8,%edx
+  movl  %edx, 28(%eax)
+  movl  0(%eax), %ebx
+  movl  %ebx, 0(%edx)
+  movl  40(%eax), %ebx
+  movl  %ebx, 4(%edx)
+  # we now have ret and eax pushed onto where new stack will be
+  # restore all registers
+  movl   4(%eax), %ebx
+  movl   8(%eax), %ecx
+  movl  12(%eax), %edx
+  movl  16(%eax), %edi
+  movl  20(%eax), %esi
+  movl  24(%eax), %ebp
+  movl  28(%eax), %esp
+  # skip ss
+  # skip eflags
+  pop    %eax  # eax was already pushed on new stack
+  pop    %ecx
+  jmp    *%ecx
+  # skip cs
+  # skip ds
+  # skip es
+  # skip fs
+  # skip gs
+
+#elif defined(__x86_64__)
+
+DEFINE_LIBUNWIND_FUNCTION(__libunwind_Registers_x86_64_jumpto)
+#
+# extern "C" void __libunwind_Registers_x86_64_jumpto(Registers_x86_64 *);
+#
+#if defined(_WIN64)
+# On entry, thread_state pointer is in rcx; move it into rdi
+# to share restore code below. Since this routine restores and
+# overwrites all registers, we can use the same registers for
+# pointers and temporaries as on unix even though win64 normally
+# mustn't clobber some of them.
+  movq  %rcx, %rdi
+#else
+# On entry, thread_state pointer is in rdi
+#endif
+
+  _LIBUNWIND_CET_ENDBR
+  movq  56(%rdi), %rax # rax holds new stack pointer
+  subq  $16, %rax
+  movq  %rax, 56(%rdi)
+  movq  32(%rdi), %rbx  # store new rdi on new stack
+  movq  %rbx, 0(%rax)
+  movq  128(%rdi), %rbx # store new rip on new stack
+  movq  %rbx, 8(%rax)
+  # restore all registers
+  movq    0(%rdi), %rax
+  movq    8(%rdi), %rbx
+  movq   16(%rdi), %rcx
+  movq   24(%rdi), %rdx
+  # restore rdi later
+  movq   40(%rdi), %rsi
+  movq   48(%rdi), %rbp
+  # restore rsp later
+  movq   64(%rdi), %r8
+  movq   72(%rdi), %r9
+  movq   80(%rdi), %r10
+  movq   88(%rdi), %r11
+  movq   96(%rdi), %r12
+  movq  104(%rdi), %r13
+  movq  112(%rdi), %r14
+  movq  120(%rdi), %r15
+  # skip rflags
+  # skip cs
+  # skip fs
+  # skip gs
+
+#if defined(_WIN64)
+  movdqu 176(%rdi),%xmm0
+  movdqu 192(%rdi),%xmm1
+  movdqu 208(%rdi),%xmm2
+  movdqu 224(%rdi),%xmm3
+  movdqu 240(%rdi),%xmm4
+  movdqu 256(%rdi),%xmm5
+  movdqu 272(%rdi),%xmm6
+  movdqu 288(%rdi),%xmm7
+  movdqu 304(%rdi),%xmm8
+  movdqu 320(%rdi),%xmm9
+  movdqu 336(%rdi),%xmm10
+  movdqu 352(%rdi),%xmm11
+  movdqu 368(%rdi),%xmm12
+  movdqu 384(%rdi),%xmm13
+  movdqu 400(%rdi),%xmm14
+  movdqu 416(%rdi),%xmm15
+#endif
+  movq  56(%rdi), %rsp  # cut back rsp to new location
+  pop    %rdi      # rdi was saved here earlier
+  pop    %rcx
+  jmpq   *%rcx
+
+
+#elif defined(__powerpc64__)
+
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind15Registers_ppc646jumptoEv)
+//
+// void libunwind::Registers_ppc64::jumpto()
+//
+// On entry:
+//  thread_state pointer is in r3
+//
+
+// load register (GPR)
+#define PPC64_LR(n) \
+  ld    n, (8 * (n + 2))(3)
+
+  // restore integral registers
+  // skip r0 for now
+  // skip r1 for now
+  PPC64_LR(2)
+  // skip r3 for now
+  // skip r4 for now
+  // skip r5 for now
+  PPC64_LR(6)
+  PPC64_LR(7)
+  PPC64_LR(8)
+  PPC64_LR(9)
+  PPC64_LR(10)
+  PPC64_LR(11)
+  PPC64_LR(12)
+  PPC64_LR(13)
+  PPC64_LR(14)
+  PPC64_LR(15)
+  PPC64_LR(16)
+  PPC64_LR(17)
+  PPC64_LR(18)
+  PPC64_LR(19)
+  PPC64_LR(20)
+  PPC64_LR(21)
+  PPC64_LR(22)
+  PPC64_LR(23)
+  PPC64_LR(24)
+  PPC64_LR(25)
+  PPC64_LR(26)
+  PPC64_LR(27)
+  PPC64_LR(28)
+  PPC64_LR(29)
+  PPC64_LR(30)
+  PPC64_LR(31)
+
+#if defined(__VSX__)
+
+  // restore VS registers
+  // (note that this also restores floating point registers and V registers,
+  // because part of VS is mapped to these registers)
+
+  addi  4, 3, PPC64_OFFS_FP
+
+// load VS register
+#ifdef __LITTLE_ENDIAN__
+// For little-endian targets, we need a swap since lxvd2x will load the register
+// in the incorrect doubleword order.
+// FIXME: when supporting targets older than Power9 on LE is no longer required,
+//        this can be changed to simply `lxv n, (16 * n)(4)`.
+#define PPC64_LVS(n)         \
+  lxvd2x  n, 0, 4           ;\
+  xxswapd n, n              ;\
+  addi    4, 4, 16
+#else
+#define PPC64_LVS(n)         \
+  lxvd2x  n, 0, 4           ;\
+  addi    4, 4, 16
+#endif
+
+  // restore the first 32 VS regs (and also all floating point regs)
+  PPC64_LVS(0)
+  PPC64_LVS(1)
+  PPC64_LVS(2)
+  PPC64_LVS(3)
+  PPC64_LVS(4)
+  PPC64_LVS(5)
+  PPC64_LVS(6)
+  PPC64_LVS(7)
+  PPC64_LVS(8)
+  PPC64_LVS(9)
+  PPC64_LVS(10)
+  PPC64_LVS(11)
+  PPC64_LVS(12)
+  PPC64_LVS(13)
+  PPC64_LVS(14)
+  PPC64_LVS(15)
+  PPC64_LVS(16)
+  PPC64_LVS(17)
+  PPC64_LVS(18)
+  PPC64_LVS(19)
+  PPC64_LVS(20)
+  PPC64_LVS(21)
+  PPC64_LVS(22)
+  PPC64_LVS(23)
+  PPC64_LVS(24)
+  PPC64_LVS(25)
+  PPC64_LVS(26)
+  PPC64_LVS(27)
+  PPC64_LVS(28)
+  PPC64_LVS(29)
+  PPC64_LVS(30)
+  PPC64_LVS(31)
+
+#ifdef __LITTLE_ENDIAN__
+#define PPC64_CLVS_RESTORE(n)                    \
+  addi   4, 3, PPC64_OFFS_FP + n * 16           ;\
+  lxvd2x n, 0, 4                                ;\
+  xxswapd n, n
+#else
+#define PPC64_CLVS_RESTORE(n)                    \
+  addi   4, 3, PPC64_OFFS_FP + n * 16           ;\
+  lxvd2x n, 0, 4
+#endif
+
+#if !defined(_AIX)
+  // use VRSAVE to conditionally restore the remaining VS regs, that are
+  // where the V regs are mapped. In the AIX ABI, VRSAVE is not used.
+  ld    5, PPC64_OFFS_VRSAVE(3)   // test VRsave
+  cmpwi 5, 0
+  beq   Lnovec
+
+// conditionally load VS
+#define PPC64_CLVSl(n)                           \
+  andis. 0, 5, (1 PPC_LEFT_SHIFT(47-n))         ;\
+  beq    Ldone##n                               ;\
+  PPC64_CLVS_RESTORE(n)                         ;\
+Ldone##n:
+
+#define PPC64_CLVSh(n)                           \
+  andi.  0, 5, (1 PPC_LEFT_SHIFT(63-n))         ;\
+  beq    Ldone##n                               ;\
+  PPC64_CLVS_RESTORE(n)                         ;\
+Ldone##n:
+
+#else
+
+#define PPC64_CLVSl(n) PPC64_CLVS_RESTORE(n)
+#define PPC64_CLVSh(n) PPC64_CLVS_RESTORE(n)
+
+#endif // !defined(_AIX)
+
+  PPC64_CLVSl(32)
+  PPC64_CLVSl(33)
+  PPC64_CLVSl(34)
+  PPC64_CLVSl(35)
+  PPC64_CLVSl(36)
+  PPC64_CLVSl(37)
+  PPC64_CLVSl(38)
+  PPC64_CLVSl(39)
+  PPC64_CLVSl(40)
+  PPC64_CLVSl(41)
+  PPC64_CLVSl(42)
+  PPC64_CLVSl(43)
+  PPC64_CLVSl(44)
+  PPC64_CLVSl(45)
+  PPC64_CLVSl(46)
+  PPC64_CLVSl(47)
+  PPC64_CLVSh(48)
+  PPC64_CLVSh(49)
+  PPC64_CLVSh(50)
+  PPC64_CLVSh(51)
+  PPC64_CLVSh(52)
+  PPC64_CLVSh(53)
+  PPC64_CLVSh(54)
+  PPC64_CLVSh(55)
+  PPC64_CLVSh(56)
+  PPC64_CLVSh(57)
+  PPC64_CLVSh(58)
+  PPC64_CLVSh(59)
+  PPC64_CLVSh(60)
+  PPC64_CLVSh(61)
+  PPC64_CLVSh(62)
+  PPC64_CLVSh(63)
+
+#else
+
+// load FP register
+#define PPC64_LF(n) \
+  lfd   n, (PPC64_OFFS_FP + n * 16)(3)
+
+  // restore float registers
+  PPC64_LF(0)
+  PPC64_LF(1)
+  PPC64_LF(2)
+  PPC64_LF(3)
+  PPC64_LF(4)
+  PPC64_LF(5)
+  PPC64_LF(6)
+  PPC64_LF(7)
+  PPC64_LF(8)
+  PPC64_LF(9)
+  PPC64_LF(10)
+  PPC64_LF(11)
+  PPC64_LF(12)
+  PPC64_LF(13)
+  PPC64_LF(14)
+  PPC64_LF(15)
+  PPC64_LF(16)
+  PPC64_LF(17)
+  PPC64_LF(18)
+  PPC64_LF(19)
+  PPC64_LF(20)
+  PPC64_LF(21)
+  PPC64_LF(22)
+  PPC64_LF(23)
+  PPC64_LF(24)
+  PPC64_LF(25)
+  PPC64_LF(26)
+  PPC64_LF(27)
+  PPC64_LF(28)
+  PPC64_LF(29)
+  PPC64_LF(30)
+  PPC64_LF(31)
+
+#if defined(__ALTIVEC__)
+
+#define PPC64_CLV_UNALIGNED_RESTORE(n)       \
+  ld     0, (PPC64_OFFS_V + n * 16)(3)      ;\
+  std    0, 0(4)                            ;\
+  ld     0, (PPC64_OFFS_V + n * 16 + 8)(3)  ;\
+  std    0, 8(4)                            ;\
+  lvx    n, 0, 4
+
+#if !defined(_AIX)
+  // restore vector registers if any are in use. In the AIX ABI, VRSAVE is
+  // not used.
+  ld    5, PPC64_OFFS_VRSAVE(3)   // test VRsave
+  cmpwi 5, 0
+  beq   Lnovec
+
+#define PPC64_CLV_UNALIGNEDl(n)              \
+  andis. 0, 5, (1 PPC_LEFT_SHIFT(15-n))     ;\
+  beq    Ldone##n                           ;\
+  PPC64_CLV_UNALIGNED_RESTORE(n)            ;\
+Ldone  ## n:
+
+#define PPC64_CLV_UNALIGNEDh(n)              \
+  andi.  0, 5, (1 PPC_LEFT_SHIFT(31-n))     ;\
+  beq    Ldone##n                           ;\
+  PPC64_CLV_UNALIGNED_RESTORE(n)            ;\
+Ldone  ## n:
+
+#else
+
+#define PPC64_CLV_UNALIGNEDl(n) PPC64_CLV_UNALIGNED_RESTORE(n)
+#define PPC64_CLV_UNALIGNEDh(n) PPC64_CLV_UNALIGNED_RESTORE(n)
+
+#endif // !defined(_AIX)
+
+  subi  4, 1, 16
+  // r4 is now a 16-byte aligned pointer into the red zone
+  // the _vectorScalarRegisters may not be 16-byte aligned
+  // so copy via red zone temp buffer
+
+  PPC64_CLV_UNALIGNEDl(0)
+  PPC64_CLV_UNALIGNEDl(1)
+  PPC64_CLV_UNALIGNEDl(2)
+  PPC64_CLV_UNALIGNEDl(3)
+  PPC64_CLV_UNALIGNEDl(4)
+  PPC64_CLV_UNALIGNEDl(5)
+  PPC64_CLV_UNALIGNEDl(6)
+  PPC64_CLV_UNALIGNEDl(7)
+  PPC64_CLV_UNALIGNEDl(8)
+  PPC64_CLV_UNALIGNEDl(9)
+  PPC64_CLV_UNALIGNEDl(10)
+  PPC64_CLV_UNALIGNEDl(11)
+  PPC64_CLV_UNALIGNEDl(12)
+  PPC64_CLV_UNALIGNEDl(13)
+  PPC64_CLV_UNALIGNEDl(14)
+  PPC64_CLV_UNALIGNEDl(15)
+  PPC64_CLV_UNALIGNEDh(16)
+  PPC64_CLV_UNALIGNEDh(17)
+  PPC64_CLV_UNALIGNEDh(18)
+  PPC64_CLV_UNALIGNEDh(19)
+  PPC64_CLV_UNALIGNEDh(20)
+  PPC64_CLV_UNALIGNEDh(21)
+  PPC64_CLV_UNALIGNEDh(22)
+  PPC64_CLV_UNALIGNEDh(23)
+  PPC64_CLV_UNALIGNEDh(24)
+  PPC64_CLV_UNALIGNEDh(25)
+  PPC64_CLV_UNALIGNEDh(26)
+  PPC64_CLV_UNALIGNEDh(27)
+  PPC64_CLV_UNALIGNEDh(28)
+  PPC64_CLV_UNALIGNEDh(29)
+  PPC64_CLV_UNALIGNEDh(30)
+  PPC64_CLV_UNALIGNEDh(31)
+
+#endif
+#endif
+
+Lnovec:
+  ld    0, PPC64_OFFS_CR(3)
+  mtcr  0
+  ld    0, PPC64_OFFS_SRR0(3)
+  mtctr 0
+
+#if defined(_AIX)
+  // After setting GPR1 to a higher address, AIX wipes out the original
+  // stack space below that address invalidated by the new GPR1 value. Use
+  // GPR0 to save the value of GPR3 in the context before it is wiped out.
+  // This compromises the content of GPR0 which is a volatile register.
+  ld 0, (8 * (3 + 2))(3)
+#else
+  PPC64_LR(0)
+#endif
+  PPC64_LR(5)
+  PPC64_LR(4)
+  PPC64_LR(1)
+#if defined(_AIX)
+  mr 3, 0
+#else
+  PPC64_LR(3)
+#endif
+  bctr
+
+#elif defined(__powerpc__)
+
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_ppc6jumptoEv)
+//
+// void libunwind::Registers_ppc::jumpto()
+//
+// On entry:
+//  thread_state pointer is in r3
+//
+
+  // restore integral registers
+  // skip r0 for now
+  // skip r1 for now
+  lwz     2,  16(3)
+  // skip r3 for now
+  // skip r4 for now
+  // skip r5 for now
+  lwz     6,  32(3)
+  lwz     7,  36(3)
+  lwz     8,  40(3)
+  lwz     9,  44(3)
+  lwz     10, 48(3)
+  lwz     11, 52(3)
+  lwz     12, 56(3)
+  lwz     13, 60(3)
+  lwz     14, 64(3)
+  lwz     15, 68(3)
+  lwz     16, 72(3)
+  lwz     17, 76(3)
+  lwz     18, 80(3)
+  lwz     19, 84(3)
+  lwz     20, 88(3)
+  lwz     21, 92(3)
+  lwz     22, 96(3)
+  lwz     23,100(3)
+  lwz     24,104(3)
+  lwz     25,108(3)
+  lwz     26,112(3)
+  lwz     27,116(3)
+  lwz     28,120(3)
+  lwz     29,124(3)
+  lwz     30,128(3)
+  lwz     31,132(3)
+
+#ifndef __NO_FPRS__
+  // restore float registers
+  lfd     0, 160(3)
+  lfd     1, 168(3)
+  lfd     2, 176(3)
+  lfd     3, 184(3)
+  lfd     4, 192(3)
+  lfd     5, 200(3)
+  lfd     6, 208(3)
+  lfd     7, 216(3)
+  lfd     8, 224(3)
+  lfd     9, 232(3)
+  lfd     10,240(3)
+  lfd     11,248(3)
+  lfd     12,256(3)
+  lfd     13,264(3)
+  lfd     14,272(3)
+  lfd     15,280(3)
+  lfd     16,288(3)
+  lfd     17,296(3)
+  lfd     18,304(3)
+  lfd     19,312(3)
+  lfd     20,320(3)
+  lfd     21,328(3)
+  lfd     22,336(3)
+  lfd     23,344(3)
+  lfd     24,352(3)
+  lfd     25,360(3)
+  lfd     26,368(3)
+  lfd     27,376(3)
+  lfd     28,384(3)
+  lfd     29,392(3)
+  lfd     30,400(3)
+  lfd     31,408(3)
+#endif
+
+#if defined(__ALTIVEC__)
+
+#define LOAD_VECTOR_RESTORE(_index)                 \
+  lwz     0, 424+_index*16(3)             SEPARATOR \
+  stw     0, 0(4)                         SEPARATOR \
+  lwz     0, 424+_index*16+4(3)           SEPARATOR \
+  stw     0, 4(4)                         SEPARATOR \
+  lwz     0, 424+_index*16+8(3)           SEPARATOR \
+  stw     0, 8(4)                         SEPARATOR \
+  lwz     0, 424+_index*16+12(3)          SEPARATOR \
+  stw     0, 12(4)                        SEPARATOR \
+  lvx     _index, 0, 4
+
+#if !defined(_AIX)
+  // restore vector registers if any are in use. In the AIX ABI, VRSAVE
+  // is not used.
+  lwz     5, 156(3)       // test VRsave
+  cmpwi   5, 0
+  beq     Lnovec
+
+#define LOAD_VECTOR_UNALIGNEDl(_index)                   \
+  andis.  0, 5, (1 PPC_LEFT_SHIFT(15-_index))  SEPARATOR \
+  beq     Ldone ## _index                      SEPARATOR \
+  LOAD_VECTOR_RESTORE(_index)                  SEPARATOR \
+  Ldone ## _index:
+
+#define LOAD_VECTOR_UNALIGNEDh(_index)                   \
+  andi.   0, 5, (1 PPC_LEFT_SHIFT(31-_index))  SEPARATOR \
+  beq     Ldone ## _index                      SEPARATOR \
+  LOAD_VECTOR_RESTORE(_index)                  SEPARATOR \
+  Ldone ## _index:
+
+#else
+
+#define LOAD_VECTOR_UNALIGNEDl(_index) LOAD_VECTOR_RESTORE(_index)
+#define LOAD_VECTOR_UNALIGNEDh(_index) LOAD_VECTOR_RESTORE(_index)
+
+#endif // !defined(_AIX)
+
+  subi    4, 1, 16
+  rlwinm  4, 4, 0, 0, 27  // mask low 4-bits
+  // r4 is now a 16-byte aligned pointer into the red zone
+  // the _vectorRegisters may not be 16-byte aligned so copy via red zone temp buffer
+
+  LOAD_VECTOR_UNALIGNEDl(0)
+  LOAD_VECTOR_UNALIGNEDl(1)
+  LOAD_VECTOR_UNALIGNEDl(2)
+  LOAD_VECTOR_UNALIGNEDl(3)
+  LOAD_VECTOR_UNALIGNEDl(4)
+  LOAD_VECTOR_UNALIGNEDl(5)
+  LOAD_VECTOR_UNALIGNEDl(6)
+  LOAD_VECTOR_UNALIGNEDl(7)
+  LOAD_VECTOR_UNALIGNEDl(8)
+  LOAD_VECTOR_UNALIGNEDl(9)
+  LOAD_VECTOR_UNALIGNEDl(10)
+  LOAD_VECTOR_UNALIGNEDl(11)
+  LOAD_VECTOR_UNALIGNEDl(12)
+  LOAD_VECTOR_UNALIGNEDl(13)
+  LOAD_VECTOR_UNALIGNEDl(14)
+  LOAD_VECTOR_UNALIGNEDl(15)
+  LOAD_VECTOR_UNALIGNEDh(16)
+  LOAD_VECTOR_UNALIGNEDh(17)
+  LOAD_VECTOR_UNALIGNEDh(18)
+  LOAD_VECTOR_UNALIGNEDh(19)
+  LOAD_VECTOR_UNALIGNEDh(20)
+  LOAD_VECTOR_UNALIGNEDh(21)
+  LOAD_VECTOR_UNALIGNEDh(22)
+  LOAD_VECTOR_UNALIGNEDh(23)
+  LOAD_VECTOR_UNALIGNEDh(24)
+  LOAD_VECTOR_UNALIGNEDh(25)
+  LOAD_VECTOR_UNALIGNEDh(26)
+  LOAD_VECTOR_UNALIGNEDh(27)
+  LOAD_VECTOR_UNALIGNEDh(28)
+  LOAD_VECTOR_UNALIGNEDh(29)
+  LOAD_VECTOR_UNALIGNEDh(30)
+  LOAD_VECTOR_UNALIGNEDh(31)
+#endif
+
+Lnovec:
+  lwz     0, 136(3)   // __cr
+  mtcr    0
+  lwz     0, 148(3)   // __ctr
+  mtctr   0
+  lwz     0,   0(3)   // __ssr0
+  mtctr   0
+  lwz     0,   8(3)   // do r0 now
+  lwz     5,  28(3)   // do r5 now
+  lwz     4,  24(3)   // do r4 now
+  lwz     1,  12(3)   // do sp now
+  lwz     3,  20(3)   // do r3 last
+  bctr
+
+#elif defined(__aarch64__)
+
+#if defined(__ARM_FEATURE_GCS_DEFAULT)
+.arch_extension gcs
+#endif
+
+//
+// extern "C" void __libunwind_Registers_arm64_jumpto(Registers_arm64 *);
+//
+// On entry:
+//  thread_state pointer is in x0
+//
+  .p2align 2
+DEFINE_LIBUNWIND_FUNCTION(__libunwind_Registers_arm64_jumpto)
+  // skip restore of x0,x1 for now
+  ldp    x2, x3,  [x0, #0x010]
+  ldp    x4, x5,  [x0, #0x020]
+  ldp    x6, x7,  [x0, #0x030]
+  ldp    x8, x9,  [x0, #0x040]
+  ldp    x10,x11, [x0, #0x050]
+  ldp    x12,x13, [x0, #0x060]
+  ldp    x14,x15, [x0, #0x070]
+  // x16 and x17 were clobbered by the call into the unwinder, so no point in
+  // restoring them.
+  ldp    x18,x19, [x0, #0x090]
+  ldp    x20,x21, [x0, #0x0A0]
+  ldp    x22,x23, [x0, #0x0B0]
+  ldp    x24,x25, [x0, #0x0C0]
+  ldp    x26,x27, [x0, #0x0D0]
+  ldp    x28,x29, [x0, #0x0E0]
+  ldr    x30,     [x0, #0x100]  // restore pc into lr
+
+  ldp    d0, d1,  [x0, #0x110]
+  ldp    d2, d3,  [x0, #0x120]
+  ldp    d4, d5,  [x0, #0x130]
+  ldp    d6, d7,  [x0, #0x140]
+  ldp    d8, d9,  [x0, #0x150]
+  ldp    d10,d11, [x0, #0x160]
+  ldp    d12,d13, [x0, #0x170]
+  ldp    d14,d15, [x0, #0x180]
+  ldp    d16,d17, [x0, #0x190]
+  ldp    d18,d19, [x0, #0x1A0]
+  ldp    d20,d21, [x0, #0x1B0]
+  ldp    d22,d23, [x0, #0x1C0]
+  ldp    d24,d25, [x0, #0x1D0]
+  ldp    d26,d27, [x0, #0x1E0]
+  ldp    d28,d29, [x0, #0x1F0]
+  ldr    d30,     [x0, #0x200]
+  ldr    d31,     [x0, #0x208]
+
+  // Finally, restore sp. This must be done after the last read from the
+  // context struct, because it is allocated on the stack, and an exception
+  // could clobber the de-allocated portion of the stack after sp has been
+  // restored.
+  ldr    x16,     [x0, #0x0F8]
+  ldp    x0, x1,  [x0, #0x000]  // restore x0,x1
+  mov    sp,x16                 // restore sp
+#if defined(__ARM_FEATURE_GCS_DEFAULT)
+  // If GCS is enabled we need to push the address we're returning to onto the
+  // GCS stack. We can't just return using br, as there won't be a BTI landing
+  // pad instruction at the destination.
+  mov      x16, #1
+  chkfeat  x16
+  cbnz     x16, Lnogcs
+  gcspushm x30
+Lnogcs:
+#endif
+  ret    x30                    // jump to pc
+
+#elif defined(__arm__) && !defined(__APPLE__)
+
+#if !defined(__ARM_ARCH_ISA_ARM)
+#if (__ARM_ARCH_ISA_THUMB == 2)
+  .syntax unified
+#endif
+  .thumb
+#endif
+
+@
+@ void libunwind::Registers_arm::restoreCoreAndJumpTo()
+@
+@ On entry:
+@  thread_state pointer is in r0
+@
+  .p2align 2
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm20restoreCoreAndJumpToEv)
+#if !defined(__ARM_ARCH_ISA_ARM) && __ARM_ARCH_ISA_THUMB == 1
+  @ r8-r11: ldm into r1-r4, then mov to r8-r11
+  adds r0, #0x20
+  ldm r0!, {r1-r4}
+  subs r0, #0x30
+  mov r8, r1
+  mov r9, r2
+  mov r10, r3
+  mov r11, r4
+  @ r12 does not need loading, it it the intra-procedure-call scratch register
+  ldr r2, [r0, #0x34]
+  ldr r3, [r0, #0x3c]
+  mov sp, r2
+  mov lr, r3         @ restore pc into lr
+  ldm r0, {r0-r7}
+#else
+  @ Use lr as base so that r0 can be restored.
+  mov lr, r0
+  @ 32bit thumb-2 restrictions for ldm:
+  @ . the sp (r13) cannot be in the list
+  @ . the pc (r15) and lr (r14) cannot both be in the list in an LDM instruction
+  ldm lr, {r0-r12}
+  ldr sp, [lr, #52]
+  ldr lr, [lr, #60]  @ restore pc into lr
+#endif
+#if defined(__ARM_FEATURE_BTI_DEFAULT) && !defined(__ARM_ARCH_ISA_ARM)
+  // 'bx' is not BTI setting when used with lr, therefore r12 is used instead
+  mov r12, lr
+  JMP(r12)
+#else
+  JMP(lr)
+#endif
+
+@
+@ static void libunwind::Registers_arm::restoreVFPWithFLDMD(unw_fpreg_t* values)
+@
+@ On entry:
+@  values pointer is in r0
+@
+  .p2align 2
+#if defined(__ELF__)
+  .fpu vfpv3-d16
+#endif
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm19restoreVFPWithFLDMDEPv)
+  @ VFP and iwMMX instructions are only available when compiling with the flags
+  @ that enable them. We do not want to do that in the library (because we do not
+  @ want the compiler to generate instructions that access those) but this is
+  @ only accessed if the personality routine needs these registers. Use of
+  @ these registers implies they are, actually, available on the target, so
+  @ it's ok to execute.
+  @ So, generate the instruction using the corresponding coprocessor mnemonic.
+  vldmia r0, {d0-d15}
+  JMP(lr)
+
+@
+@ static void libunwind::Registers_arm::restoreVFPWithFLDMX(unw_fpreg_t* values)
+@
+@ On entry:
+@  values pointer is in r0
+@
+  .p2align 2
+#if defined(__ELF__)
+  .fpu vfpv3-d16
+#endif
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm19restoreVFPWithFLDMXEPv)
+  vldmia r0, {d0-d15} @ fldmiax is deprecated in ARMv7+ and now behaves like vldmia
+  JMP(lr)
+
+@
+@ static void libunwind::Registers_arm::restoreVFPv3(unw_fpreg_t* values)
+@
+@ On entry:
+@  values pointer is in r0
+@
+  .p2align 2
+#if defined(__ELF__)
+  .fpu vfpv3
+#endif
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm12restoreVFPv3EPv)
+  vldmia r0, {d16-d31}
+  JMP(lr)
+
+#if defined(__ARM_WMMX)
+
+@
+@ static void libunwind::Registers_arm::restoreiWMMX(unw_fpreg_t* values)
+@
+@ On entry:
+@  values pointer is in r0
+@
+  .p2align 2
+#if defined(__ELF__)
+  .arch armv5te
+#endif
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm12restoreiWMMXEPv)
+  ldcl p1, cr0, [r0], #8  @ wldrd wR0, [r0], #8
+  ldcl p1, cr1, [r0], #8  @ wldrd wR1, [r0], #8
+  ldcl p1, cr2, [r0], #8  @ wldrd wR2, [r0], #8
+  ldcl p1, cr3, [r0], #8  @ wldrd wR3, [r0], #8
+  ldcl p1, cr4, [r0], #8  @ wldrd wR4, [r0], #8
+  ldcl p1, cr5, [r0], #8  @ wldrd wR5, [r0], #8
+  ldcl p1, cr6, [r0], #8  @ wldrd wR6, [r0], #8
+  ldcl p1, cr7, [r0], #8  @ wldrd wR7, [r0], #8
+  ldcl p1, cr8, [r0], #8  @ wldrd wR8, [r0], #8
+  ldcl p1, cr9, [r0], #8  @ wldrd wR9, [r0], #8
+  ldcl p1, cr10, [r0], #8  @ wldrd wR10, [r0], #8
+  ldcl p1, cr11, [r0], #8  @ wldrd wR11, [r0], #8
+  ldcl p1, cr12, [r0], #8  @ wldrd wR12, [r0], #8
+  ldcl p1, cr13, [r0], #8  @ wldrd wR13, [r0], #8
+  ldcl p1, cr14, [r0], #8  @ wldrd wR14, [r0], #8
+  ldcl p1, cr15, [r0], #8  @ wldrd wR15, [r0], #8
+  JMP(lr)
+
+@
+@ static void libunwind::Registers_arm::restoreiWMMXControl(unw_uint32_t* values)
+@
+@ On entry:
+@  values pointer is in r0
+@
+  .p2align 2
+#if defined(__ELF__)
+  .arch armv5te
+#endif
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm19restoreiWMMXControlEPj)
+  ldc2 p1, cr8, [r0], #4  @ wldrw wCGR0, [r0], #4
+  ldc2 p1, cr9, [r0], #4  @ wldrw wCGR1, [r0], #4
+  ldc2 p1, cr10, [r0], #4  @ wldrw wCGR2, [r0], #4
+  ldc2 p1, cr11, [r0], #4  @ wldrw wCGR3, [r0], #4
+  JMP(lr)
+
+#endif
+
+#elif defined(__or1k__)
+
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind14Registers_or1k6jumptoEv)
+#
+# void libunwind::Registers_or1k::jumpto()
+#
+# On entry:
+#  thread_state pointer is in r3
+#
+
+  # restore integral registers
+  l.lwz     r0,  0(r3)
+  l.lwz     r1,  4(r3)
+  l.lwz     r2,  8(r3)
+  # skip r3 for now
+  l.lwz     r4, 16(r3)
+  l.lwz     r5, 20(r3)
+  l.lwz     r6, 24(r3)
+  l.lwz     r7, 28(r3)
+  l.lwz     r8, 32(r3)
+  # skip r9
+  l.lwz    r10, 40(r3)
+  l.lwz    r11, 44(r3)
+  l.lwz    r12, 48(r3)
+  l.lwz    r13, 52(r3)
+  l.lwz    r14, 56(r3)
+  l.lwz    r15, 60(r3)
+  l.lwz    r16, 64(r3)
+  l.lwz    r17, 68(r3)
+  l.lwz    r18, 72(r3)
+  l.lwz    r19, 76(r3)
+  l.lwz    r20, 80(r3)
+  l.lwz    r21, 84(r3)
+  l.lwz    r22, 88(r3)
+  l.lwz    r23, 92(r3)
+  l.lwz    r24, 96(r3)
+  l.lwz    r25,100(r3)
+  l.lwz    r26,104(r3)
+  l.lwz    r27,108(r3)
+  l.lwz    r28,112(r3)
+  l.lwz    r29,116(r3)
+  l.lwz    r30,120(r3)
+  l.lwz    r31,124(r3)
+
+  # load new pc into ra
+  l.lwz    r9, 128(r3)
+
+  # at last, restore r3
+  l.lwz    r3,  12(r3)
+
+  # jump to pc
+  l.jr     r9
+   l.nop
+
+#elif defined(__hexagon__)
+# On entry:
+#  thread_state pointer is in r2
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind17Registers_hexagon6jumptoEv)
+#
+# void libunwind::Registers_hexagon::jumpto()
+#
+  r8 = memw(r0+#32)
+  r9 = memw(r0+#36)
+  r10 = memw(r0+#40)
+  r11 = memw(r0+#44)
+
+  r12 = memw(r0+#48)
+  r13 = memw(r0+#52)
+  r14 = memw(r0+#56)
+  r15 = memw(r0+#60)
+
+  r16 = memw(r0+#64)
+  r17 = memw(r0+#68)
+  r18 = memw(r0+#72)
+  r19 = memw(r0+#76)
+
+  r20 = memw(r0+#80)
+  r21 = memw(r0+#84)
+  r22 = memw(r0+#88)
+  r23 = memw(r0+#92)
+
+  r24 = memw(r0+#96)
+  r25 = memw(r0+#100)
+  r26 = memw(r0+#104)
+  r27 = memw(r0+#108)
+
+  r28 = memw(r0+#112)
+  r29 = memw(r0+#116)
+  r30 = memw(r0+#120)
+  r31 = memw(r0+#132)
+
+  r1 = memw(r0+#128)
+  c4 = r1   // Predicate register
+  r1 = memw(r0+#4)
+  r0 = memw(r0)
+  jumpr r31
+#elif defined(__mips__) && defined(_ABIO32) && _MIPS_SIM == _ABIO32
+
+//
+// void libunwind::Registers_mips_o32::jumpto()
+//
+// On entry:
+//  thread state pointer is in a0 ($4)
+//
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind18Registers_mips_o326jumptoEv)
+  .set push
+  .set noat
+  .set noreorder
+  .set nomacro
+#ifdef __mips_hard_float
+#if __mips_fpr != 64
+  ldc1  $f0, (4 * 36 + 8 * 0)($4)
+  ldc1  $f2, (4 * 36 + 8 * 2)($4)
+  ldc1  $f4, (4 * 36 + 8 * 4)($4)
+  ldc1  $f6, (4 * 36 + 8 * 6)($4)
+  ldc1  $f8, (4 * 36 + 8 * 8)($4)
+  ldc1  $f10, (4 * 36 + 8 * 10)($4)
+  ldc1  $f12, (4 * 36 + 8 * 12)($4)
+  ldc1  $f14, (4 * 36 + 8 * 14)($4)
+  ldc1  $f16, (4 * 36 + 8 * 16)($4)
+  ldc1  $f18, (4 * 36 + 8 * 18)($4)
+  ldc1  $f20, (4 * 36 + 8 * 20)($4)
+  ldc1  $f22, (4 * 36 + 8 * 22)($4)
+  ldc1  $f24, (4 * 36 + 8 * 24)($4)
+  ldc1  $f26, (4 * 36 + 8 * 26)($4)
+  ldc1  $f28, (4 * 36 + 8 * 28)($4)
+  ldc1  $f30, (4 * 36 + 8 * 30)($4)
+#else
+  ldc1  $f0, (4 * 36 + 8 * 0)($4)
+  ldc1  $f1, (4 * 36 + 8 * 1)($4)
+  ldc1  $f2, (4 * 36 + 8 * 2)($4)
+  ldc1  $f3, (4 * 36 + 8 * 3)($4)
+  ldc1  $f4, (4 * 36 + 8 * 4)($4)
+  ldc1  $f5, (4 * 36 + 8 * 5)($4)
+  ldc1  $f6, (4 * 36 + 8 * 6)($4)
+  ldc1  $f7, (4 * 36 + 8 * 7)($4)
+  ldc1  $f8, (4 * 36 + 8 * 8)($4)
+  ldc1  $f9, (4 * 36 + 8 * 9)($4)
+  ldc1  $f10, (4 * 36 + 8 * 10)($4)
+  ldc1  $f11, (4 * 36 + 8 * 11)($4)
+  ldc1  $f12, (4 * 36 + 8 * 12)($4)
+  ldc1  $f13, (4 * 36 + 8 * 13)($4)
+  ldc1  $f14, (4 * 36 + 8 * 14)($4)
+  ldc1  $f15, (4 * 36 + 8 * 15)($4)
+  ldc1  $f16, (4 * 36 + 8 * 16)($4)
+  ldc1  $f17, (4 * 36 + 8 * 17)($4)
+  ldc1  $f18, (4 * 36 + 8 * 18)($4)
+  ldc1  $f19, (4 * 36 + 8 * 19)($4)
+  ldc1  $f20, (4 * 36 + 8 * 20)($4)
+  ldc1  $f21, (4 * 36 + 8 * 21)($4)
+  ldc1  $f22, (4 * 36 + 8 * 22)($4)
+  ldc1  $f23, (4 * 36 + 8 * 23)($4)
+  ldc1  $f24, (4 * 36 + 8 * 24)($4)
+  ldc1  $f25, (4 * 36 + 8 * 25)($4)
+  ldc1  $f26, (4 * 36 + 8 * 26)($4)
+  ldc1  $f27, (4 * 36 + 8 * 27)($4)
+  ldc1  $f28, (4 * 36 + 8 * 28)($4)
+  ldc1  $f29, (4 * 36 + 8 * 29)($4)
+  ldc1  $f30, (4 * 36 + 8 * 30)($4)
+  ldc1  $f31, (4 * 36 + 8 * 31)($4)
+#endif
+#endif
+#if __mips_isa_rev < 6
+  // restore hi and lo
+  lw    $8, (4 * 33)($4)
+  mthi  $8
+  lw    $8, (4 * 34)($4)
+  mtlo  $8
+#endif
+  // r0 is zero
+  lw    $1, (4 * 1)($4)
+  lw    $2, (4 * 2)($4)
+  lw    $3, (4 * 3)($4)
+  // skip a0 for now
+  lw    $5, (4 * 5)($4)
+  lw    $6, (4 * 6)($4)
+  lw    $7, (4 * 7)($4)
+  lw    $8, (4 * 8)($4)
+  lw    $9, (4 * 9)($4)
+  lw    $10, (4 * 10)($4)
+  lw    $11, (4 * 11)($4)
+  lw    $12, (4 * 12)($4)
+  lw    $13, (4 * 13)($4)
+  lw    $14, (4 * 14)($4)
+  lw    $15, (4 * 15)($4)
+  lw    $16, (4 * 16)($4)
+  lw    $17, (4 * 17)($4)
+  lw    $18, (4 * 18)($4)
+  lw    $19, (4 * 19)($4)
+  lw    $20, (4 * 20)($4)
+  lw    $21, (4 * 21)($4)
+  lw    $22, (4 * 22)($4)
+  lw    $23, (4 * 23)($4)
+  lw    $24, (4 * 24)($4)
+  lw    $25, (4 * 25)($4)
+  lw    $26, (4 * 26)($4)
+  lw    $27, (4 * 27)($4)
+  lw    $28, (4 * 28)($4)
+  lw    $29, (4 * 29)($4)
+  lw    $30, (4 * 30)($4)
+  // load new pc into ra
+  lw    $31, (4 * 32)($4)
+  // jump to ra, load a0 in the delay slot
+  jr    $31
+  lw    $4, (4 * 4)($4)
+  .set pop
+
+#elif defined(__mips64)
+
+//
+// void libunwind::Registers_mips_newabi::jumpto()
+//
+// On entry:
+//  thread state pointer is in a0 ($4)
+//
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind21Registers_mips_newabi6jumptoEv)
+  .set push
+  .set noat
+  .set noreorder
+  .set nomacro
+#ifdef __mips_hard_float
+  .irp i,FROM_0_TO_31
+    ldc1 $f\i, (280+8*\i)($4)
+  .endr
+#endif
+#if __mips_isa_rev < 6
+  // restore hi and lo
+  ld    $8, (8 * 33)($4)
+  mthi  $8
+  ld    $8, (8 * 34)($4)
+  mtlo  $8
+#endif
+  // r0 is zero
+  ld    $1, (8 * 1)($4)
+  ld    $2, (8 * 2)($4)
+  ld    $3, (8 * 3)($4)
+  // skip a0 for now
+  .irp i,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30
+    ld $\i, (8 * \i)($4)
+  .endr
+  // load new pc into ra
+  ld    $31, (8 * 32)($4)
+  // jump to ra, load a0 in the delay slot
+  jr    $31
+  ld    $4, (8 * 4)($4)
+  .set pop
+
+#elif defined(__sparc__) && defined(__arch64__)
+
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind17Registers_sparc646jumptoEv)
+//
+// void libunwind::Registers_sparc64::jumpto()
+//
+// On entry:
+//  thread_state pointer is in %o0
+//
+  .register %g2, #scratch
+  .register %g3, #scratch
+  .register %g6, #scratch
+  .register %g7, #scratch
+  flushw
+  ldx  [%o0 + 0x08], %g1
+  ldx  [%o0 + 0x10], %g2
+  ldx  [%o0 + 0x18], %g3
+  ldx  [%o0 + 0x20], %g4
+  ldx  [%o0 + 0x28], %g5
+  ldx  [%o0 + 0x30], %g6
+  ldx  [%o0 + 0x38], %g7
+  ldx  [%o0 + 0x48], %o1
+  ldx  [%o0 + 0x50], %o2
+  ldx  [%o0 + 0x58], %o3
+  ldx  [%o0 + 0x60], %o4
+  ldx  [%o0 + 0x68], %o5
+  ldx  [%o0 + 0x70], %o6
+  ldx  [%o0 + 0x78], %o7
+  ldx  [%o0 + 0x80], %l0
+  ldx  [%o0 + 0x88], %l1
+  ldx  [%o0 + 0x90], %l2
+  ldx  [%o0 + 0x98], %l3
+  ldx  [%o0 + 0xa0], %l4
+  ldx  [%o0 + 0xa8], %l5
+  ldx  [%o0 + 0xb0], %l6
+  ldx  [%o0 + 0xb8], %l7
+  ldx  [%o0 + 0xc0], %i0
+  ldx  [%o0 + 0xc8], %i1
+  ldx  [%o0 + 0xd0], %i2
+  ldx  [%o0 + 0xd8], %i3
+  ldx  [%o0 + 0xe0], %i4
+  ldx  [%o0 + 0xe8], %i5
+  ldx  [%o0 + 0xf0], %i6
+  ldx  [%o0 + 0xf8], %i7
+  jmp  %o7
+   ldx [%o0 + 0x40], %o0
+
+#elif defined(__sparc__)
+
+//
+// void libunwind::Registers_sparc_o32::jumpto()
+//
+// On entry:
+//  thread_state pointer is in o0
+//
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind15Registers_sparc6jumptoEv)
+  ta 3
+  ldd [%o0 + 64],  %l0
+  ldd [%o0 + 72],  %l2
+  ldd [%o0 + 80],  %l4
+  ldd [%o0 + 88],  %l6
+  ldd [%o0 + 96],  %i0
+  ldd [%o0 + 104], %i2
+  ldd [%o0 + 112], %i4
+  ldd [%o0 + 120], %i6
+  ld  [%o0 + 60],  %o7
+  jmp %o7
+   nop
+
+#elif defined(__riscv)
+
+//
+// void libunwind::Registers_riscv::jumpto()
+//
+// On entry:
+//  thread_state pointer is in a0
+//
+  .p2align 2
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind15Registers_riscv6jumptoEv)
+# if defined(__riscv_flen)
+  .irp i,FROM_0_TO_31
+    FLOAD f\i, (RISCV_FOFFSET + RISCV_FSIZE * \i)(a0)
+  .endr
+# endif
+
+  // x0 is zero
+  ILOAD    x1, (RISCV_ISIZE * 0)(a0) // restore pc into ra
+  .irp i,2,3,4,5,6,7,8,9
+    ILOAD x\i, (RISCV_ISIZE * \i)(a0)
+  .endr
+  // skip a0 for now
+#if defined(__riscv_32e)
+  .irp i,11,12,13,14,15
+#else
+  .irp i,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
+#endif
+    ILOAD x\i, (RISCV_ISIZE * \i)(a0)
+  .endr
+  ILOAD    x10, (RISCV_ISIZE * 10)(a0)   // restore a0
+
+  ret                       // jump to ra
+
+#elif defined(__s390x__)
+
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind15Registers_s390x6jumptoEv)
+//
+// void libunwind::Registers_s390x::jumpto()
+//
+// On entry:
+//  thread_state pointer is in r2
+//
+
+  // Skip PSWM, but load PSWA into r1
+  lg %r1, 8(%r2)
+
+  // Restore FPRs
+  .irp i,FROM_0_TO_15
+    ld %f\i, (144+8*\i)(%r2)
+  .endr
+
+  // Restore GPRs - skipping %r0 and %r1
+  lmg  %r2, %r15, 32(%r2)
+
+  // Return to PSWA (was loaded into %r1 above)
+  br %r1
+
+#elif defined(__loongarch__) && __loongarch_grlen == 64
+
+//
+// void libunwind::Registers_loongarch::jumpto()
+//
+// On entry:
+//  thread_state pointer is in $a0($r4)
+//
+  .p2align 2
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind19Registers_loongarch6jumptoEv)
+# if __loongarch_frlen == 64
+  .irp i,FROM_0_TO_31
+    fld.d $f\i, $a0, (8 * 33 + 8 * \i)
+  .endr
+# endif
+
+  // $r0 is zero
+  .irp i,1,2,3
+    ld.d $r\i, $a0, (8 * \i)
+  .endr
+  // skip $a0 for now
+  .irp i,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
+    ld.d $r\i, $a0, (8 * \i)
+  .endr
+
+  ld.d    $ra,  $a0, (8 * 32)  // load new pc into $ra
+  ld.d    $a0,  $a0, (8 * 4)   // restore $a0 last
+
+  jr      $ra
+
+#endif
+
+#endif /* !defined(__USING_SJLJ_EXCEPTIONS__) && !defined(__wasm__) */
+
+NO_EXEC_STACK_DIRECTIVE
+
diff --git a/third_party/libunwind/UnwindRegistersSave.S b/third_party/libunwind/UnwindRegistersSave.S
new file mode 100644
index 000000000..fab234fcd
--- /dev/null
+++ b/third_party/libunwind/UnwindRegistersSave.S
@@ -0,0 +1,1186 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "assembly.h"
+
+#define FROM_0_TO_15 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+#define FROM_16_TO_31 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
+
+#define FROM_0_TO_31 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
+#define FROM_32_TO_63 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63
+
+#if defined(_AIX)
+    .toc
+#else
+    .text
+#endif
+
+#if !defined(__USING_SJLJ_EXCEPTIONS__) && !defined(__wasm__)
+
+#if defined(__i386__)
+
+#
+# extern int __unw_getcontext(unw_context_t* thread_state)
+#
+# On entry:
+#   +                       +
+#   +-----------------------+
+#   + thread_state pointer  +
+#   +-----------------------+
+#   + return address        +
+#   +-----------------------+   <-- SP
+#   +                       +
+#
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+
+  _LIBUNWIND_CET_ENDBR
+  push  %eax
+  movl  8(%esp), %eax
+  movl  %ebx,  4(%eax)
+  movl  %ecx,  8(%eax)
+  movl  %edx, 12(%eax)
+  movl  %edi, 16(%eax)
+  movl  %esi, 20(%eax)
+  movl  %ebp, 24(%eax)
+  movl  %esp, %edx
+  addl  $8, %edx
+  movl  %edx, 28(%eax)  # store what sp was at call site as esp
+  # skip ss
+  # skip eflags
+  movl  4(%esp), %edx
+  movl  %edx, 40(%eax)  # store return address as eip
+  # skip cs
+  # skip ds
+  # skip es
+  # skip fs
+  # skip gs
+  movl  (%esp), %edx
+  movl  %edx, (%eax)  # store original eax
+  popl  %eax
+  xorl  %eax, %eax    # return UNW_ESUCCESS
+  ret
+
+#elif defined(__x86_64__)
+
+#
+# extern int __unw_getcontext(unw_context_t* thread_state)
+#
+# On entry:
+#  thread_state pointer is in rdi
+#
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+#if defined(_WIN64)
+#define PTR %rcx
+#define TMP %rdx
+#else
+#define PTR %rdi
+#define TMP %rsi
+#endif
+
+  _LIBUNWIND_CET_ENDBR
+  movq  %rax,   (PTR)
+  movq  %rbx,  8(PTR)
+  movq  %rcx, 16(PTR)
+  movq  %rdx, 24(PTR)
+  movq  %rdi, 32(PTR)
+  movq  %rsi, 40(PTR)
+  movq  %rbp, 48(PTR)
+  movq  %rsp, 56(PTR)
+  addq  $8,   56(PTR)
+  movq  %r8,  64(PTR)
+  movq  %r9,  72(PTR)
+  movq  %r10, 80(PTR)
+  movq  %r11, 88(PTR)
+  movq  %r12, 96(PTR)
+  movq  %r13,104(PTR)
+  movq  %r14,112(PTR)
+  movq  %r15,120(PTR)
+  movq  (%rsp),TMP
+  movq  TMP,128(PTR) # store return address as rip
+  # skip rflags
+  # skip cs
+  # skip fs
+  # skip gs
+
+#if defined(_WIN64)
+  movdqu %xmm0,176(PTR)
+  movdqu %xmm1,192(PTR)
+  movdqu %xmm2,208(PTR)
+  movdqu %xmm3,224(PTR)
+  movdqu %xmm4,240(PTR)
+  movdqu %xmm5,256(PTR)
+  movdqu %xmm6,272(PTR)
+  movdqu %xmm7,288(PTR)
+  movdqu %xmm8,304(PTR)
+  movdqu %xmm9,320(PTR)
+  movdqu %xmm10,336(PTR)
+  movdqu %xmm11,352(PTR)
+  movdqu %xmm12,368(PTR)
+  movdqu %xmm13,384(PTR)
+  movdqu %xmm14,400(PTR)
+  movdqu %xmm15,416(PTR)
+#endif
+  xorl  %eax, %eax    # return UNW_ESUCCESS
+  ret
+
+#elif defined(__mips__) && defined(_ABIO32) && _MIPS_SIM == _ABIO32
+
+#
+# extern int __unw_getcontext(unw_context_t* thread_state)
+#
+# On entry:
+#  thread_state pointer is in a0 ($4)
+#
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+  .set push
+  .set noat
+  .set noreorder
+  .set nomacro
+  sw    $1, (4 * 1)($4)
+  sw    $2, (4 * 2)($4)
+  sw    $3, (4 * 3)($4)
+  sw    $4, (4 * 4)($4)
+  sw    $5, (4 * 5)($4)
+  sw    $6, (4 * 6)($4)
+  sw    $7, (4 * 7)($4)
+  sw    $8, (4 * 8)($4)
+  sw    $9, (4 * 9)($4)
+  sw    $10, (4 * 10)($4)
+  sw    $11, (4 * 11)($4)
+  sw    $12, (4 * 12)($4)
+  sw    $13, (4 * 13)($4)
+  sw    $14, (4 * 14)($4)
+  sw    $15, (4 * 15)($4)
+  sw    $16, (4 * 16)($4)
+  sw    $17, (4 * 17)($4)
+  sw    $18, (4 * 18)($4)
+  sw    $19, (4 * 19)($4)
+  sw    $20, (4 * 20)($4)
+  sw    $21, (4 * 21)($4)
+  sw    $22, (4 * 22)($4)
+  sw    $23, (4 * 23)($4)
+  sw    $24, (4 * 24)($4)
+  sw    $25, (4 * 25)($4)
+  sw    $26, (4 * 26)($4)
+  sw    $27, (4 * 27)($4)
+  sw    $28, (4 * 28)($4)
+  sw    $29, (4 * 29)($4)
+  sw    $30, (4 * 30)($4)
+  sw    $31, (4 * 31)($4)
+  # Store return address to pc
+  sw    $31, (4 * 32)($4)
+#if __mips_isa_rev < 6
+  # hi and lo
+  mfhi  $8
+  sw    $8,  (4 * 33)($4)
+  mflo  $8
+  sw    $8,  (4 * 34)($4)
+#endif
+#ifdef __mips_hard_float
+#if __mips_fpr != 64
+  sdc1  $f0, (4 * 36 + 8 * 0)($4)
+  sdc1  $f2, (4 * 36 + 8 * 2)($4)
+  sdc1  $f4, (4 * 36 + 8 * 4)($4)
+  sdc1  $f6, (4 * 36 + 8 * 6)($4)
+  sdc1  $f8, (4 * 36 + 8 * 8)($4)
+  sdc1  $f10, (4 * 36 + 8 * 10)($4)
+  sdc1  $f12, (4 * 36 + 8 * 12)($4)
+  sdc1  $f14, (4 * 36 + 8 * 14)($4)
+  sdc1  $f16, (4 * 36 + 8 * 16)($4)
+  sdc1  $f18, (4 * 36 + 8 * 18)($4)
+  sdc1  $f20, (4 * 36 + 8 * 20)($4)
+  sdc1  $f22, (4 * 36 + 8 * 22)($4)
+  sdc1  $f24, (4 * 36 + 8 * 24)($4)
+  sdc1  $f26, (4 * 36 + 8 * 26)($4)
+  sdc1  $f28, (4 * 36 + 8 * 28)($4)
+  sdc1  $f30, (4 * 36 + 8 * 30)($4)
+#else
+  sdc1  $f0, (4 * 36 + 8 * 0)($4)
+  sdc1  $f1, (4 * 36 + 8 * 1)($4)
+  sdc1  $f2, (4 * 36 + 8 * 2)($4)
+  sdc1  $f3, (4 * 36 + 8 * 3)($4)
+  sdc1  $f4, (4 * 36 + 8 * 4)($4)
+  sdc1  $f5, (4 * 36 + 8 * 5)($4)
+  sdc1  $f6, (4 * 36 + 8 * 6)($4)
+  sdc1  $f7, (4 * 36 + 8 * 7)($4)
+  sdc1  $f8, (4 * 36 + 8 * 8)($4)
+  sdc1  $f9, (4 * 36 + 8 * 9)($4)
+  sdc1  $f10, (4 * 36 + 8 * 10)($4)
+  sdc1  $f11, (4 * 36 + 8 * 11)($4)
+  sdc1  $f12, (4 * 36 + 8 * 12)($4)
+  sdc1  $f13, (4 * 36 + 8 * 13)($4)
+  sdc1  $f14, (4 * 36 + 8 * 14)($4)
+  sdc1  $f15, (4 * 36 + 8 * 15)($4)
+  sdc1  $f16, (4 * 36 + 8 * 16)($4)
+  sdc1  $f17, (4 * 36 + 8 * 17)($4)
+  sdc1  $f18, (4 * 36 + 8 * 18)($4)
+  sdc1  $f19, (4 * 36 + 8 * 19)($4)
+  sdc1  $f20, (4 * 36 + 8 * 20)($4)
+  sdc1  $f21, (4 * 36 + 8 * 21)($4)
+  sdc1  $f22, (4 * 36 + 8 * 22)($4)
+  sdc1  $f23, (4 * 36 + 8 * 23)($4)
+  sdc1  $f24, (4 * 36 + 8 * 24)($4)
+  sdc1  $f25, (4 * 36 + 8 * 25)($4)
+  sdc1  $f26, (4 * 36 + 8 * 26)($4)
+  sdc1  $f27, (4 * 36 + 8 * 27)($4)
+  sdc1  $f28, (4 * 36 + 8 * 28)($4)
+  sdc1  $f29, (4 * 36 + 8 * 29)($4)
+  sdc1  $f30, (4 * 36 + 8 * 30)($4)
+  sdc1  $f31, (4 * 36 + 8 * 31)($4)
+#endif
+#endif
+  jr	$31
+  # return UNW_ESUCCESS
+  or    $2, $0, $0
+  .set pop
+
+#elif defined(__mips64)
+
+#
+# extern int __unw_getcontext(unw_context_t* thread_state)
+#
+# On entry:
+#  thread_state pointer is in a0 ($4)
+#
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+  .set push
+  .set noat
+  .set noreorder
+  .set nomacro
+  .irp i,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
+    sd $\i, (8 * \i)($4)
+  .endr
+  # Store return address to pc
+  sd    $31, (8 * 32)($4)
+#if __mips_isa_rev < 6
+  # hi and lo
+  mfhi  $8
+  sd    $8,  (8 * 33)($4)
+  mflo  $8
+  sd    $8,  (8 * 34)($4)
+#endif
+#ifdef __mips_hard_float
+  .irp i,FROM_0_TO_31
+    sdc1 $f\i, (280+8*\i)($4)
+  .endr
+#endif
+  jr	$31
+  # return UNW_ESUCCESS
+  or    $2, $0, $0
+  .set pop
+
+# elif defined(__mips__)
+
+#
+# extern int __unw_getcontext(unw_context_t* thread_state)
+#
+# Just trap for the time being.
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+  teq $0, $0
+
+#elif defined(__powerpc64__)
+
+//
+// extern int __unw_getcontext(unw_context_t* thread_state)
+//
+// On entry:
+//  thread_state pointer is in r3
+//
+#if defined(_AIX)
+DEFINE_LIBUNWIND_FUNCTION_AND_WEAK_ALIAS(__unw_getcontext, unw_getcontext)
+#else
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+#endif
+// store register (GPR)
+#define PPC64_STR(n) \
+  std   n, (8 * (n + 2))(3)
+
+  // save GPRs
+  PPC64_STR(0)
+  mflr  0
+  std   0, PPC64_OFFS_SRR0(3) // store lr as ssr0
+  PPC64_STR(1)
+  PPC64_STR(4)        // Save r4 first since it will be used for fixing r2.
+#if defined(_AIX)
+  // The TOC register (r2) was changed by the glue code if unw_getcontext
+  // is called from a different module. Save the original TOC register
+  // in the context if this is the case.
+  mflr   4
+  lwz    4, 0(4)      // Get the first instruction at the return address.
+  xoris  0, 4, 0xe841 // Is it reloading the TOC register "ld 2,40(1)"?
+  cmplwi 0, 0x28
+  bne    0, LnoR2Fix  // No need to fix up r2 if it is not.
+  ld     2, 40(1)     // Use the saved TOC register in the stack.
+LnoR2Fix:
+#endif
+  PPC64_STR(2)
+  PPC64_STR(3)
+  PPC64_STR(5)
+  PPC64_STR(6)
+  PPC64_STR(7)
+  PPC64_STR(8)
+  PPC64_STR(9)
+  PPC64_STR(10)
+  PPC64_STR(11)
+  PPC64_STR(12)
+  PPC64_STR(13)
+  PPC64_STR(14)
+  PPC64_STR(15)
+  PPC64_STR(16)
+  PPC64_STR(17)
+  PPC64_STR(18)
+  PPC64_STR(19)
+  PPC64_STR(20)
+  PPC64_STR(21)
+  PPC64_STR(22)
+  PPC64_STR(23)
+  PPC64_STR(24)
+  PPC64_STR(25)
+  PPC64_STR(26)
+  PPC64_STR(27)
+  PPC64_STR(28)
+  PPC64_STR(29)
+  PPC64_STR(30)
+  PPC64_STR(31)
+
+  mfcr  0
+  std   0,  PPC64_OFFS_CR(3)
+  mfxer 0
+  std   0,  PPC64_OFFS_XER(3)
+#if defined(_AIX)
+  // LR value saved from the register is not used, initialize it to 0.
+  li    0,  0
+#else
+  mflr  0
+#endif
+  std   0,  PPC64_OFFS_LR(3)
+  mfctr 0
+  std   0,  PPC64_OFFS_CTR(3)
+  mfvrsave    0
+  std   0,  PPC64_OFFS_VRSAVE(3)
+
+#if defined(__VSX__)
+  // save VS registers
+  // (note that this also saves floating point registers and V registers,
+  // because part of VS is mapped to these registers)
+
+  addi  4, 3, PPC64_OFFS_FP
+
+// store VS register
+#ifdef __LITTLE_ENDIAN__
+// For little-endian targets, we need a swap since stxvd2x will store the
+// register in the incorrect doubleword order.
+// FIXME: when supporting targets older than Power9 on LE is no longer required
+//        this can be changed to simply `stxv n, 16 * n(4)`.
+#define PPC64_STVS(n)      \
+  xxswapd n, n            ;\
+  stxvd2x n, 0, 4         ;\
+  addi    4, 4, 16
+#else
+#define PPC64_STVS(n)      \
+  stxvd2x n, 0, 4         ;\
+  addi    4, 4, 16
+#endif
+
+  PPC64_STVS(0)
+  PPC64_STVS(1)
+  PPC64_STVS(2)
+  PPC64_STVS(3)
+  PPC64_STVS(4)
+  PPC64_STVS(5)
+  PPC64_STVS(6)
+  PPC64_STVS(7)
+  PPC64_STVS(8)
+  PPC64_STVS(9)
+  PPC64_STVS(10)
+  PPC64_STVS(11)
+  PPC64_STVS(12)
+  PPC64_STVS(13)
+  PPC64_STVS(14)
+  PPC64_STVS(15)
+  PPC64_STVS(16)
+  PPC64_STVS(17)
+  PPC64_STVS(18)
+  PPC64_STVS(19)
+  PPC64_STVS(20)
+  PPC64_STVS(21)
+  PPC64_STVS(22)
+  PPC64_STVS(23)
+  PPC64_STVS(24)
+  PPC64_STVS(25)
+  PPC64_STVS(26)
+  PPC64_STVS(27)
+  PPC64_STVS(28)
+  PPC64_STVS(29)
+  PPC64_STVS(30)
+  PPC64_STVS(31)
+  PPC64_STVS(32)
+  PPC64_STVS(33)
+  PPC64_STVS(34)
+  PPC64_STVS(35)
+  PPC64_STVS(36)
+  PPC64_STVS(37)
+  PPC64_STVS(38)
+  PPC64_STVS(39)
+  PPC64_STVS(40)
+  PPC64_STVS(41)
+  PPC64_STVS(42)
+  PPC64_STVS(43)
+  PPC64_STVS(44)
+  PPC64_STVS(45)
+  PPC64_STVS(46)
+  PPC64_STVS(47)
+  PPC64_STVS(48)
+  PPC64_STVS(49)
+  PPC64_STVS(50)
+  PPC64_STVS(51)
+  PPC64_STVS(52)
+  PPC64_STVS(53)
+  PPC64_STVS(54)
+  PPC64_STVS(55)
+  PPC64_STVS(56)
+  PPC64_STVS(57)
+  PPC64_STVS(58)
+  PPC64_STVS(59)
+  PPC64_STVS(60)
+  PPC64_STVS(61)
+  PPC64_STVS(62)
+  PPC64_STVS(63)
+
+#else
+
+// store FP register
+#define PPC64_STF(n) \
+  stfd  n, (PPC64_OFFS_FP + n * 16)(3)
+
+  // save float registers
+  PPC64_STF(0)
+  PPC64_STF(1)
+  PPC64_STF(2)
+  PPC64_STF(3)
+  PPC64_STF(4)
+  PPC64_STF(5)
+  PPC64_STF(6)
+  PPC64_STF(7)
+  PPC64_STF(8)
+  PPC64_STF(9)
+  PPC64_STF(10)
+  PPC64_STF(11)
+  PPC64_STF(12)
+  PPC64_STF(13)
+  PPC64_STF(14)
+  PPC64_STF(15)
+  PPC64_STF(16)
+  PPC64_STF(17)
+  PPC64_STF(18)
+  PPC64_STF(19)
+  PPC64_STF(20)
+  PPC64_STF(21)
+  PPC64_STF(22)
+  PPC64_STF(23)
+  PPC64_STF(24)
+  PPC64_STF(25)
+  PPC64_STF(26)
+  PPC64_STF(27)
+  PPC64_STF(28)
+  PPC64_STF(29)
+  PPC64_STF(30)
+  PPC64_STF(31)
+
+#if defined(__ALTIVEC__)
+  // save vector registers
+
+  // Use 16-bytes below the stack pointer as an
+  // aligned buffer to save each vector register.
+  // Note that the stack pointer is always 16-byte aligned.
+  subi  4, 1, 16
+
+#define PPC64_STV_UNALIGNED(n)             \
+  stvx  n, 0, 4                           ;\
+  ld    5, 0(4)                           ;\
+  std   5, (PPC64_OFFS_V + n * 16)(3)     ;\
+  ld    5, 8(4)                           ;\
+  std   5, (PPC64_OFFS_V + n * 16 + 8)(3)
+
+  PPC64_STV_UNALIGNED(0)
+  PPC64_STV_UNALIGNED(1)
+  PPC64_STV_UNALIGNED(2)
+  PPC64_STV_UNALIGNED(3)
+  PPC64_STV_UNALIGNED(4)
+  PPC64_STV_UNALIGNED(5)
+  PPC64_STV_UNALIGNED(6)
+  PPC64_STV_UNALIGNED(7)
+  PPC64_STV_UNALIGNED(8)
+  PPC64_STV_UNALIGNED(9)
+  PPC64_STV_UNALIGNED(10)
+  PPC64_STV_UNALIGNED(11)
+  PPC64_STV_UNALIGNED(12)
+  PPC64_STV_UNALIGNED(13)
+  PPC64_STV_UNALIGNED(14)
+  PPC64_STV_UNALIGNED(15)
+  PPC64_STV_UNALIGNED(16)
+  PPC64_STV_UNALIGNED(17)
+  PPC64_STV_UNALIGNED(18)
+  PPC64_STV_UNALIGNED(19)
+  PPC64_STV_UNALIGNED(20)
+  PPC64_STV_UNALIGNED(21)
+  PPC64_STV_UNALIGNED(22)
+  PPC64_STV_UNALIGNED(23)
+  PPC64_STV_UNALIGNED(24)
+  PPC64_STV_UNALIGNED(25)
+  PPC64_STV_UNALIGNED(26)
+  PPC64_STV_UNALIGNED(27)
+  PPC64_STV_UNALIGNED(28)
+  PPC64_STV_UNALIGNED(29)
+  PPC64_STV_UNALIGNED(30)
+  PPC64_STV_UNALIGNED(31)
+
+#endif
+#endif
+
+  li    3,  0   // return UNW_ESUCCESS
+  blr
+
+
+#elif defined(__powerpc__)
+
+//
+// extern int unw_getcontext(unw_context_t* thread_state)
+//
+// On entry:
+//  thread_state pointer is in r3
+//
+#if defined(_AIX)
+DEFINE_LIBUNWIND_FUNCTION_AND_WEAK_ALIAS(__unw_getcontext, unw_getcontext)
+#else
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+#endif
+  stw     0,   8(3)
+  mflr    0
+  stw     0,   0(3) // store lr as ssr0
+  stw     1,  12(3)
+  stw     4,  24(3) // Save r4 first since it will be used for fixing r2.
+#if defined(_AIX)
+  // The TOC register (r2) was changed by the glue code if unw_getcontext
+  // is called from a different module. Save the original TOC register
+  // in the context if this is the case.
+  mflr    4
+  lwz     4,  0(4)      // Get the instruction at the return address.
+  xoris   0,  4, 0x8041 // Is it reloading the TOC register "lwz 2,20(1)"?
+  cmplwi  0,  0x14
+  bne     0,  LnoR2Fix  // No need to fix up r2 if it is not.
+  lwz     2,  20(1)     // Use the saved TOC register in the stack.
+LnoR2Fix:
+#endif
+  stw     2,  16(3)
+  stw     3,  20(3)
+  stw     5,  28(3)
+  stw     6,  32(3)
+  stw     7,  36(3)
+  stw     8,  40(3)
+  stw     9,  44(3)
+  stw     10, 48(3)
+  stw     11, 52(3)
+  stw     12, 56(3)
+  stw     13, 60(3)
+  stw     14, 64(3)
+  stw     15, 68(3)
+  stw     16, 72(3)
+  stw     17, 76(3)
+  stw     18, 80(3)
+  stw     19, 84(3)
+  stw     20, 88(3)
+  stw     21, 92(3)
+  stw     22, 96(3)
+  stw     23,100(3)
+  stw     24,104(3)
+  stw     25,108(3)
+  stw     26,112(3)
+  stw     27,116(3)
+  stw     28,120(3)
+  stw     29,124(3)
+  stw     30,128(3)
+  stw     31,132(3)
+
+#if defined(__ALTIVEC__)
+  // save VRSave register
+  mfspr   0, 256
+  stw     0, 156(3)
+#endif
+  // save CR registers
+  mfcr    0
+  stw     0, 136(3)
+#if defined(_AIX)
+  // LR value from the register is not used, initialize it to 0.
+  li      0, 0
+  stw     0, 144(3)
+#endif
+  // save CTR register
+  mfctr   0
+  stw     0, 148(3)
+
+#if !defined(__NO_FPRS__)
+  // save float registers
+  stfd    0, 160(3)
+  stfd    1, 168(3)
+  stfd    2, 176(3)
+  stfd    3, 184(3)
+  stfd    4, 192(3)
+  stfd    5, 200(3)
+  stfd    6, 208(3)
+  stfd    7, 216(3)
+  stfd    8, 224(3)
+  stfd    9, 232(3)
+  stfd    10,240(3)
+  stfd    11,248(3)
+  stfd    12,256(3)
+  stfd    13,264(3)
+  stfd    14,272(3)
+  stfd    15,280(3)
+  stfd    16,288(3)
+  stfd    17,296(3)
+  stfd    18,304(3)
+  stfd    19,312(3)
+  stfd    20,320(3)
+  stfd    21,328(3)
+  stfd    22,336(3)
+  stfd    23,344(3)
+  stfd    24,352(3)
+  stfd    25,360(3)
+  stfd    26,368(3)
+  stfd    27,376(3)
+  stfd    28,384(3)
+  stfd    29,392(3)
+  stfd    30,400(3)
+  stfd    31,408(3)
+#endif
+
+#if defined(__ALTIVEC__)
+  // save vector registers
+
+  subi    4, 1, 16
+  rlwinm  4, 4, 0, 0, 27  // mask low 4-bits
+  // r4 is now a 16-byte aligned pointer into the red zone
+
+#define SAVE_VECTOR_UNALIGNED(_vec, _offset) \
+  stvx    _vec, 0, 4               SEPARATOR \
+  lwz     5, 0(4)                  SEPARATOR \
+  stw     5, _offset(3)            SEPARATOR \
+  lwz     5, 4(4)                  SEPARATOR \
+  stw     5, _offset+4(3)          SEPARATOR \
+  lwz     5, 8(4)                  SEPARATOR \
+  stw     5, _offset+8(3)          SEPARATOR \
+  lwz     5, 12(4)                 SEPARATOR \
+  stw     5, _offset+12(3)
+
+  SAVE_VECTOR_UNALIGNED( 0, 424+0x000)
+  SAVE_VECTOR_UNALIGNED( 1, 424+0x010)
+  SAVE_VECTOR_UNALIGNED( 2, 424+0x020)
+  SAVE_VECTOR_UNALIGNED( 3, 424+0x030)
+  SAVE_VECTOR_UNALIGNED( 4, 424+0x040)
+  SAVE_VECTOR_UNALIGNED( 5, 424+0x050)
+  SAVE_VECTOR_UNALIGNED( 6, 424+0x060)
+  SAVE_VECTOR_UNALIGNED( 7, 424+0x070)
+  SAVE_VECTOR_UNALIGNED( 8, 424+0x080)
+  SAVE_VECTOR_UNALIGNED( 9, 424+0x090)
+  SAVE_VECTOR_UNALIGNED(10, 424+0x0A0)
+  SAVE_VECTOR_UNALIGNED(11, 424+0x0B0)
+  SAVE_VECTOR_UNALIGNED(12, 424+0x0C0)
+  SAVE_VECTOR_UNALIGNED(13, 424+0x0D0)
+  SAVE_VECTOR_UNALIGNED(14, 424+0x0E0)
+  SAVE_VECTOR_UNALIGNED(15, 424+0x0F0)
+  SAVE_VECTOR_UNALIGNED(16, 424+0x100)
+  SAVE_VECTOR_UNALIGNED(17, 424+0x110)
+  SAVE_VECTOR_UNALIGNED(18, 424+0x120)
+  SAVE_VECTOR_UNALIGNED(19, 424+0x130)
+  SAVE_VECTOR_UNALIGNED(20, 424+0x140)
+  SAVE_VECTOR_UNALIGNED(21, 424+0x150)
+  SAVE_VECTOR_UNALIGNED(22, 424+0x160)
+  SAVE_VECTOR_UNALIGNED(23, 424+0x170)
+  SAVE_VECTOR_UNALIGNED(24, 424+0x180)
+  SAVE_VECTOR_UNALIGNED(25, 424+0x190)
+  SAVE_VECTOR_UNALIGNED(26, 424+0x1A0)
+  SAVE_VECTOR_UNALIGNED(27, 424+0x1B0)
+  SAVE_VECTOR_UNALIGNED(28, 424+0x1C0)
+  SAVE_VECTOR_UNALIGNED(29, 424+0x1D0)
+  SAVE_VECTOR_UNALIGNED(30, 424+0x1E0)
+  SAVE_VECTOR_UNALIGNED(31, 424+0x1F0)
+#endif
+
+  li      3, 0  // return UNW_ESUCCESS
+  blr
+
+
+#elif defined(__aarch64__)
+
+//
+// extern int __unw_getcontext(unw_context_t* thread_state)
+//
+// On entry:
+//  thread_state pointer is in x0
+//
+  .p2align 2
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+  stp    x0, x1,  [x0, #0x000]
+  stp    x2, x3,  [x0, #0x010]
+  stp    x4, x5,  [x0, #0x020]
+  stp    x6, x7,  [x0, #0x030]
+  stp    x8, x9,  [x0, #0x040]
+  stp    x10,x11, [x0, #0x050]
+  stp    x12,x13, [x0, #0x060]
+  stp    x14,x15, [x0, #0x070]
+  stp    x16,x17, [x0, #0x080]
+  stp    x18,x19, [x0, #0x090]
+  stp    x20,x21, [x0, #0x0A0]
+  stp    x22,x23, [x0, #0x0B0]
+  stp    x24,x25, [x0, #0x0C0]
+  stp    x26,x27, [x0, #0x0D0]
+  stp    x28,x29, [x0, #0x0E0]
+  str    x30,     [x0, #0x0F0]
+  mov    x1,sp
+  str    x1,      [x0, #0x0F8]
+  str    x30,     [x0, #0x100]    // store return address as pc
+  // skip cpsr
+  stp    d0, d1,  [x0, #0x110]
+  stp    d2, d3,  [x0, #0x120]
+  stp    d4, d5,  [x0, #0x130]
+  stp    d6, d7,  [x0, #0x140]
+  stp    d8, d9,  [x0, #0x150]
+  stp    d10,d11, [x0, #0x160]
+  stp    d12,d13, [x0, #0x170]
+  stp    d14,d15, [x0, #0x180]
+  stp    d16,d17, [x0, #0x190]
+  stp    d18,d19, [x0, #0x1A0]
+  stp    d20,d21, [x0, #0x1B0]
+  stp    d22,d23, [x0, #0x1C0]
+  stp    d24,d25, [x0, #0x1D0]
+  stp    d26,d27, [x0, #0x1E0]
+  stp    d28,d29, [x0, #0x1F0]
+  str    d30,     [x0, #0x200]
+  str    d31,     [x0, #0x208]
+  mov    x0, #0                   // return UNW_ESUCCESS
+  ret
+
+#elif defined(__arm__) && !defined(__APPLE__)
+
+#if !defined(__ARM_ARCH_ISA_ARM)
+#if (__ARM_ARCH_ISA_THUMB == 2)
+  .syntax unified
+#endif
+  .thumb
+#endif
+
+@
+@ extern int __unw_getcontext(unw_context_t* thread_state)
+@
+@ On entry:
+@  thread_state pointer is in r0
+@
+@ Per EHABI #4.7 this only saves the core integer registers.
+@ EHABI #7.4.5 notes that in general all VRS registers should be restored
+@ however this is very hard to do for VFP registers because it is unknown
+@ to the library how many registers are implemented by the architecture.
+@ Instead, VFP registers are demand saved by logic external to __unw_getcontext.
+@
+  .p2align 2
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+#if !defined(__ARM_ARCH_ISA_ARM) && __ARM_ARCH_ISA_THUMB == 1
+  stm r0!, {r0-r7}
+  mov r1, r8
+  mov r2, r9
+  mov r3, r10
+  stm r0!, {r1-r3}
+  mov r1, r11
+  mov r2, sp
+  mov r3, lr
+  str r1, [r0, #0]   @ r11
+  @ r12 does not need storing, it it the intra-procedure-call scratch register
+  str r2, [r0, #8]   @ sp
+  str r3, [r0, #12]  @ lr
+  str r3, [r0, #16]  @ store return address as pc
+  @ T1 does not have a non-cpsr-clobbering register-zeroing instruction.
+  @ It is safe to use here though because we are about to return, and cpsr is
+  @ not expected to be preserved.
+  movs r0, #0        @ return UNW_ESUCCESS
+#else
+  @ 32bit thumb-2 restrictions for stm:
+  @ . the sp (r13) cannot be in the list
+  @ . the pc (r15) cannot be in the list in an STM instruction
+  stm r0, {r0-r12}
+  str sp, [r0, #52]
+  str lr, [r0, #56]
+  str lr, [r0, #60]  @ store return address as pc
+  mov r0, #0         @ return UNW_ESUCCESS
+#endif
+  JMP(lr)
+
+@
+@ static void libunwind::Registers_arm::saveVFPWithFSTMD(unw_fpreg_t* values)
+@
+@ On entry:
+@  values pointer is in r0
+@
+  .p2align 2
+#if defined(__ELF__)
+  .fpu vfpv3-d16
+#endif
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm16saveVFPWithFSTMDEPv)
+  vstmia r0, {d0-d15}
+  JMP(lr)
+
+@
+@ static void libunwind::Registers_arm::saveVFPWithFSTMX(unw_fpreg_t* values)
+@
+@ On entry:
+@  values pointer is in r0
+@
+  .p2align 2
+#if defined(__ELF__)
+  .fpu vfpv3-d16
+#endif
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm16saveVFPWithFSTMXEPv)
+  vstmia r0, {d0-d15} @ fstmiax is deprecated in ARMv7+ and now behaves like vstmia
+  JMP(lr)
+
+@
+@ static void libunwind::Registers_arm::saveVFPv3(unw_fpreg_t* values)
+@
+@ On entry:
+@  values pointer is in r0
+@
+  .p2align 2
+#if defined(__ELF__)
+  .fpu vfpv3
+#endif
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm9saveVFPv3EPv)
+  @ VFP and iwMMX instructions are only available when compiling with the flags
+  @ that enable them. We do not want to do that in the library (because we do not
+  @ want the compiler to generate instructions that access those) but this is
+  @ only accessed if the personality routine needs these registers. Use of
+  @ these registers implies they are, actually, available on the target, so
+  @ it's ok to execute.
+  @ So, generate the instructions using the corresponding coprocessor mnemonic.
+  vstmia r0, {d16-d31}
+  JMP(lr)
+
+#if defined(_LIBUNWIND_ARM_WMMX)
+
+@
+@ static void libunwind::Registers_arm::saveiWMMX(unw_fpreg_t* values)
+@
+@ On entry:
+@  values pointer is in r0
+@
+  .p2align 2
+#if defined(__ELF__)
+  .arch armv5te
+#endif
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm9saveiWMMXEPv)
+  stcl p1, cr0, [r0], #8  @ wstrd wR0, [r0], #8
+  stcl p1, cr1, [r0], #8  @ wstrd wR1, [r0], #8
+  stcl p1, cr2, [r0], #8  @ wstrd wR2, [r0], #8
+  stcl p1, cr3, [r0], #8  @ wstrd wR3, [r0], #8
+  stcl p1, cr4, [r0], #8  @ wstrd wR4, [r0], #8
+  stcl p1, cr5, [r0], #8  @ wstrd wR5, [r0], #8
+  stcl p1, cr6, [r0], #8  @ wstrd wR6, [r0], #8
+  stcl p1, cr7, [r0], #8  @ wstrd wR7, [r0], #8
+  stcl p1, cr8, [r0], #8  @ wstrd wR8, [r0], #8
+  stcl p1, cr9, [r0], #8  @ wstrd wR9, [r0], #8
+  stcl p1, cr10, [r0], #8  @ wstrd wR10, [r0], #8
+  stcl p1, cr11, [r0], #8  @ wstrd wR11, [r0], #8
+  stcl p1, cr12, [r0], #8  @ wstrd wR12, [r0], #8
+  stcl p1, cr13, [r0], #8  @ wstrd wR13, [r0], #8
+  stcl p1, cr14, [r0], #8  @ wstrd wR14, [r0], #8
+  stcl p1, cr15, [r0], #8  @ wstrd wR15, [r0], #8
+  JMP(lr)
+
+@
+@ static void libunwind::Registers_arm::saveiWMMXControl(unw_uint32_t* values)
+@
+@ On entry:
+@  values pointer is in r0
+@
+  .p2align 2
+#if defined(__ELF__)
+  .arch armv5te
+#endif
+DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_arm16saveiWMMXControlEPj)
+  stc2 p1, cr8, [r0], #4  @ wstrw wCGR0, [r0], #4
+  stc2 p1, cr9, [r0], #4  @ wstrw wCGR1, [r0], #4
+  stc2 p1, cr10, [r0], #4  @ wstrw wCGR2, [r0], #4
+  stc2 p1, cr11, [r0], #4  @ wstrw wCGR3, [r0], #4
+  JMP(lr)
+
+#endif
+
+#elif defined(__or1k__)
+
+#
+# extern int __unw_getcontext(unw_context_t* thread_state)
+#
+# On entry:
+#  thread_state pointer is in r3
+#
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+  l.sw       0(r3), r0
+  l.sw       4(r3), r1
+  l.sw       8(r3), r2
+  l.sw      12(r3), r3
+  l.sw      16(r3), r4
+  l.sw      20(r3), r5
+  l.sw      24(r3), r6
+  l.sw      28(r3), r7
+  l.sw      32(r3), r8
+  l.sw      36(r3), r9
+  l.sw      40(r3), r10
+  l.sw      44(r3), r11
+  l.sw      48(r3), r12
+  l.sw      52(r3), r13
+  l.sw      56(r3), r14
+  l.sw      60(r3), r15
+  l.sw      64(r3), r16
+  l.sw      68(r3), r17
+  l.sw      72(r3), r18
+  l.sw      76(r3), r19
+  l.sw      80(r3), r20
+  l.sw      84(r3), r21
+  l.sw      88(r3), r22
+  l.sw      92(r3), r23
+  l.sw      96(r3), r24
+  l.sw     100(r3), r25
+  l.sw     104(r3), r26
+  l.sw     108(r3), r27
+  l.sw     112(r3), r28
+  l.sw     116(r3), r29
+  l.sw     120(r3), r30
+  l.sw     124(r3), r31
+  # store ra to pc
+  l.sw     128(r3), r9
+  # zero epcr
+  l.sw     132(r3), r0
+
+#elif defined(__hexagon__)
+#
+# extern int unw_getcontext(unw_context_t* thread_state)
+#
+# On entry:
+#  thread_state pointer is in r0
+#
+#define OFFSET(offset) (offset/4)
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+  memw(r0+#32) = r8
+  memw(r0+#36) = r9
+  memw(r0+#40) = r10
+  memw(r0+#44) = r11
+
+  memw(r0+#48) = r12
+  memw(r0+#52) = r13
+  memw(r0+#56) = r14
+  memw(r0+#60) = r15
+
+  memw(r0+#64) = r16
+  memw(r0+#68) = r17
+  memw(r0+#72) = r18
+  memw(r0+#76) = r19
+
+  memw(r0+#80) = r20
+  memw(r0+#84) = r21
+  memw(r0+#88) = r22
+  memw(r0+#92) = r23
+
+  memw(r0+#96) = r24
+  memw(r0+#100) = r25
+  memw(r0+#104) = r26
+  memw(r0+#108) = r27
+
+  memw(r0+#112) = r28
+  memw(r0+#116) = r29
+  memw(r0+#120) = r30
+  memw(r0+#124) = r31
+  r1 = c4   // Predicate register
+  memw(r0+#128) = r1
+  r1 = memw(r30)           // *FP == Saved FP
+  r1 = r31
+  memw(r0+#132) = r1
+
+  jumpr r31
+
+#elif defined(__sparc__) && defined(__arch64__)
+
+#
+# extern int __unw_getcontext(unw_context_t* thread_state)
+#
+# On entry:
+#  thread_state pointer is in %o0
+#
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+  .register %g2, #scratch
+  .register %g3, #scratch
+  .register %g6, #scratch
+  .register %g7, #scratch
+  stx  %g1, [%o0 + 0x08]
+  stx  %g2, [%o0 + 0x10]
+  stx  %g3, [%o0 + 0x18]
+  stx  %g4, [%o0 + 0x20]
+  stx  %g5, [%o0 + 0x28]
+  stx  %g6, [%o0 + 0x30]
+  stx  %g7, [%o0 + 0x38]
+  stx  %o0, [%o0 + 0x40]
+  stx  %o1, [%o0 + 0x48]
+  stx  %o2, [%o0 + 0x50]
+  stx  %o3, [%o0 + 0x58]
+  stx  %o4, [%o0 + 0x60]
+  stx  %o5, [%o0 + 0x68]
+  stx  %o6, [%o0 + 0x70]
+  stx  %o7, [%o0 + 0x78]
+  stx  %l0, [%o0 + 0x80]
+  stx  %l1, [%o0 + 0x88]
+  stx  %l2, [%o0 + 0x90]
+  stx  %l3, [%o0 + 0x98]
+  stx  %l4, [%o0 + 0xa0]
+  stx  %l5, [%o0 + 0xa8]
+  stx  %l6, [%o0 + 0xb0]
+  stx  %l7, [%o0 + 0xb8]
+  stx  %i0, [%o0 + 0xc0]
+  stx  %i1, [%o0 + 0xc8]
+  stx  %i2, [%o0 + 0xd0]
+  stx  %i3, [%o0 + 0xd8]
+  stx  %i4, [%o0 + 0xe0]
+  stx  %i5, [%o0 + 0xe8]
+  stx  %i6, [%o0 + 0xf0]
+  stx  %i7, [%o0 + 0xf8]
+
+  # save StackGhost cookie
+  mov  %i7, %g4
+  save %sp, -176, %sp
+  # register window flush necessary even without StackGhost
+  flushw
+  restore
+  ldx  [%sp + 2047 + 0x78], %g5
+  xor  %g4, %g5, %g4
+  stx  %g4, [%o0 + 0x100]
+  retl
+  # return UNW_ESUCCESS
+   clr %o0
+
+#elif defined(__sparc__)
+
+#
+# extern int __unw_getcontext(unw_context_t* thread_state)
+#
+# On entry:
+#  thread_state pointer is in o0
+#
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+  ta 3
+  add %o7, 8, %o7
+  std %g0, [%o0 +   0]
+  std %g2, [%o0 +   8]
+  std %g4, [%o0 +  16]
+  std %g6, [%o0 +  24]
+  std %o0, [%o0 +  32]
+  std %o2, [%o0 +  40]
+  std %o4, [%o0 +  48]
+  std %o6, [%o0 +  56]
+  std %l0, [%o0 +  64]
+  std %l2, [%o0 +  72]
+  std %l4, [%o0 +  80]
+  std %l6, [%o0 +  88]
+  std %i0, [%o0 +  96]
+  std %i2, [%o0 + 104]
+  std %i4, [%o0 + 112]
+  std %i6, [%o0 + 120]
+  jmp %o7
+   clr %o0                   // return UNW_ESUCCESS
+
+#elif defined(__riscv)
+
+#
+# extern int __unw_getcontext(unw_context_t* thread_state)
+#
+# On entry:
+#  thread_state pointer is in a0
+#
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+  ISTORE    x1, (RISCV_ISIZE * 0)(a0) // store ra as pc
+#if defined(__riscv_32e)
+  .irp i,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+#else
+  .irp i,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
+#endif
+    ISTORE x\i, (RISCV_ISIZE * \i)(a0)
+  .endr
+
+# if defined(__riscv_flen)
+  .irp i,FROM_0_TO_31
+    FSTORE f\i, (RISCV_FOFFSET + RISCV_FSIZE * \i)(a0)
+  .endr
+# endif
+
+  li     a0, 0  // return UNW_ESUCCESS
+  ret           // jump to ra
+
+#elif defined(__s390x__)
+
+//
+// extern int __unw_getcontext(unw_context_t* thread_state)
+//
+// On entry:
+//  thread_state pointer is in r2
+//
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+
+  // Save GPRs
+  stmg %r0, %r15, 16(%r2)
+
+  // Save PSWM
+  epsw %r0, %r1
+  stm %r0, %r1, 0(%r2)
+
+  // Store return address as PSWA
+  stg %r14, 8(%r2)
+
+  // Save FPRs
+  .irp i,FROM_0_TO_15
+    std %f\i, (144+8*\i)(%r2)
+  .endr
+
+  // Return UNW_ESUCCESS
+  lghi %r2, 0
+  br %r14
+
+#elif defined(__loongarch__) && __loongarch_grlen == 64
+
+#
+# extern int __unw_getcontext(unw_context_t* thread_state)
+#
+# On entry:
+#  thread_state pointer is in $a0($r4)
+#
+DEFINE_LIBUNWIND_FUNCTION(__unw_getcontext)
+  .irp i,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
+    st.d $r\i, $a0, (8*\i)
+  .endr
+  st.d    $r1,  $a0, (8 * 32) // store $ra to pc
+
+# if __loongarch_frlen == 64
+  .irp i,FROM_0_TO_31
+    fst.d $f\i, $a0, (8 * 33 + 8 * \i)
+  .endr
+# endif
+
+  move     $a0, $zero  // UNW_ESUCCESS
+  jr       $ra
+
+#endif
+
+  WEAK_ALIAS(__unw_getcontext, unw_getcontext)
+
+#endif /* !defined(__USING_SJLJ_EXCEPTIONS__) && !defined(__wasm__) */
+
+NO_EXEC_STACK_DIRECTIVE
diff --git a/third_party/libunwind/assembly.h b/third_party/libunwind/assembly.h
new file mode 100644
index 000000000..f8e83e138
--- /dev/null
+++ b/third_party/libunwind/assembly.h
@@ -0,0 +1,303 @@
+/* ===-- assembly.h - libUnwind assembler support macros -------------------===
+ *
+ * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+ * See https://llvm.org/LICENSE.txt for license information.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ * ===----------------------------------------------------------------------===
+ *
+ * This file defines macros for use in libUnwind assembler source.
+ * This file is not part of the interface of this library.
+ *
+ * ===----------------------------------------------------------------------===
+ */
+
+#ifndef UNWIND_ASSEMBLY_H
+#define UNWIND_ASSEMBLY_H
+
+#if defined(__linux__) && defined(__CET__)
+#include <cet.h>
+#define _LIBUNWIND_CET_ENDBR _CET_ENDBR
+#else
+#define _LIBUNWIND_CET_ENDBR
+#endif
+
+#if defined(__powerpc64__)
+#define SEPARATOR ;
+#define PPC64_OFFS_SRR0   0
+#define PPC64_OFFS_CR     272
+#define PPC64_OFFS_XER    280
+#define PPC64_OFFS_LR     288
+#define PPC64_OFFS_CTR    296
+#define PPC64_OFFS_VRSAVE 304
+#define PPC64_OFFS_FP     312
+#define PPC64_OFFS_V      824
+#elif defined(__APPLE__) && defined(__aarch64__)
+#define SEPARATOR %%
+#elif defined(__riscv)
+# define RISCV_ISIZE (__riscv_xlen / 8)
+# define RISCV_FOFFSET (RISCV_ISIZE * 32)
+# if defined(__riscv_flen)
+#  define RISCV_FSIZE (__riscv_flen / 8)
+# endif
+
+# if __riscv_xlen == 64
+#  define ILOAD ld
+#  define ISTORE sd
+# elif __riscv_xlen == 32
+#  define ILOAD lw
+#  define ISTORE sw
+# else
+#  error "Unsupported __riscv_xlen"
+# endif
+
+# if defined(__riscv_flen)
+#  if __riscv_flen == 64
+#   define FLOAD fld
+#   define FSTORE fsd
+#  elif __riscv_flen == 32
+#   define FLOAD flw
+#   define FSTORE fsw
+#  else
+#   error "Unsupported __riscv_flen"
+#  endif
+# endif
+# define SEPARATOR ;
+#else
+#define SEPARATOR ;
+#endif
+
+#if defined(__powerpc64__) && (!defined(_CALL_ELF) || _CALL_ELF == 1) &&       \
+    !defined(_AIX)
+#define PPC64_OPD1 .section .opd,"aw",@progbits SEPARATOR
+#define PPC64_OPD2 SEPARATOR \
+  .p2align 3 SEPARATOR \
+  .quad .Lfunc_begin0 SEPARATOR \
+  .quad .TOC.@tocbase SEPARATOR \
+  .quad 0 SEPARATOR \
+  .text SEPARATOR \
+.Lfunc_begin0:
+#else
+#define PPC64_OPD1
+#define PPC64_OPD2
+#endif
+
+#if defined(__aarch64__)
+#if defined(__ARM_FEATURE_GCS_DEFAULT) && defined(__ARM_FEATURE_BTI_DEFAULT)
+// Set BTI, PAC, and GCS gnu property bits
+#define GNU_PROPERTY 7
+// We indirectly branch to __libunwind_Registers_arm64_jumpto from
+// __unw_phase2_resume, so we need to use bti jc.
+#define AARCH64_BTI bti jc
+#elif defined(__ARM_FEATURE_GCS_DEFAULT)
+// Set GCS gnu property bit
+#define GNU_PROPERTY 4
+#elif defined(__ARM_FEATURE_BTI_DEFAULT)
+// Set BTI and PAC gnu property bits
+#define GNU_PROPERTY 3
+#define AARCH64_BTI bti c
+#endif
+#ifdef GNU_PROPERTY
+  .pushsection ".note.gnu.property", "a" SEPARATOR                             \
+  .balign 8 SEPARATOR                                                          \
+  .long 4 SEPARATOR                                                            \
+  .long 0x10 SEPARATOR                                                         \
+  .long 0x5 SEPARATOR                                                          \
+  .asciz "GNU" SEPARATOR                                                       \
+  .long 0xc0000000 SEPARATOR /* GNU_PROPERTY_AARCH64_FEATURE_1_AND */          \
+  .long 4 SEPARATOR                                                            \
+  .long GNU_PROPERTY SEPARATOR                                                 \
+  .long 0 SEPARATOR                                                            \
+  .popsection SEPARATOR
+#endif
+#endif
+#if !defined(AARCH64_BTI)
+#define AARCH64_BTI
+#endif
+
+#if !defined(__aarch64__)
+#ifdef __ARM_FEATURE_PAC_DEFAULT
+  .eabi_attribute Tag_PAC_extension, 2
+  .eabi_attribute Tag_PACRET_use, 1
+#endif
+#ifdef __ARM_FEATURE_BTI_DEFAULT
+  .eabi_attribute Tag_BTI_extension, 1
+  .eabi_attribute Tag_BTI_use, 1
+#endif
+#endif
+
+#define GLUE2(a, b) a ## b
+#define GLUE(a, b) GLUE2(a, b)
+#define SYMBOL_NAME(name) GLUE(__USER_LABEL_PREFIX__, name)
+
+#if defined(__APPLE__)
+
+#define SYMBOL_IS_FUNC(name)
+#define HIDDEN_SYMBOL(name) .private_extern name
+#if defined(_LIBUNWIND_HIDE_SYMBOLS)
+#define EXPORT_SYMBOL(name) HIDDEN_SYMBOL(name)
+#else
+#define EXPORT_SYMBOL(name)
+#endif
+#define WEAK_ALIAS(name, aliasname)                                            \
+  .globl SYMBOL_NAME(aliasname) SEPARATOR                                      \
+  EXPORT_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                              \
+  SYMBOL_NAME(aliasname) = SYMBOL_NAME(name)
+
+#define NO_EXEC_STACK_DIRECTIVE
+
+#elif defined(__ELF__)
+
+#if defined(__arm__)
+#define SYMBOL_IS_FUNC(name) .type name,%function
+#else
+#define SYMBOL_IS_FUNC(name) .type name,@function
+#endif
+#define HIDDEN_SYMBOL(name) .hidden name
+#if defined(_LIBUNWIND_HIDE_SYMBOLS)
+#define EXPORT_SYMBOL(name) HIDDEN_SYMBOL(name)
+#else
+#define EXPORT_SYMBOL(name)
+#endif
+#define WEAK_SYMBOL(name) .weak name
+
+#if defined(__hexagon__)
+#define WEAK_ALIAS(name, aliasname)                                            \
+  EXPORT_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                              \
+  WEAK_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                                \
+  .equiv SYMBOL_NAME(aliasname), SYMBOL_NAME(name)
+#else
+#define WEAK_ALIAS(name, aliasname)                                            \
+  EXPORT_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                              \
+  WEAK_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                                \
+  SYMBOL_NAME(aliasname) = SYMBOL_NAME(name)
+#endif
+
+#if defined(__GNU__) || defined(__FreeBSD__) || defined(__Fuchsia__) || \
+    defined(__linux__)
+#define NO_EXEC_STACK_DIRECTIVE .section .note.GNU-stack,"",%progbits
+#else
+#define NO_EXEC_STACK_DIRECTIVE
+#endif
+
+#elif defined(_WIN32)
+
+#define SYMBOL_IS_FUNC(name)                                                   \
+  .def name SEPARATOR                                                          \
+    .scl 2 SEPARATOR                                                           \
+    .type 32 SEPARATOR                                                         \
+  .endef
+#define EXPORT_SYMBOL2(name)                                                   \
+  .section .drectve,"yn" SEPARATOR                                             \
+  .ascii "-export:", #name, "\0" SEPARATOR                                     \
+  .text
+#if defined(_LIBUNWIND_HIDE_SYMBOLS)
+#define EXPORT_SYMBOL(name)
+#else
+#define EXPORT_SYMBOL(name) EXPORT_SYMBOL2(name)
+#endif
+#define HIDDEN_SYMBOL(name)
+
+#if defined(__MINGW32__)
+#define WEAK_ALIAS(name, aliasname)                                            \
+  .globl SYMBOL_NAME(aliasname) SEPARATOR                                      \
+  EXPORT_SYMBOL(aliasname) SEPARATOR                                           \
+  SYMBOL_NAME(aliasname) = SYMBOL_NAME(name)
+#else
+#define WEAK_ALIAS3(name, aliasname)                                           \
+  .section .drectve,"yn" SEPARATOR                                             \
+  .ascii "-alternatename:", #aliasname, "=", #name, "\0" SEPARATOR             \
+  .text
+#define WEAK_ALIAS2(name, aliasname)                                           \
+  WEAK_ALIAS3(name, aliasname)
+#define WEAK_ALIAS(name, aliasname)                                            \
+  EXPORT_SYMBOL(SYMBOL_NAME(aliasname)) SEPARATOR                              \
+  WEAK_ALIAS2(SYMBOL_NAME(name), SYMBOL_NAME(aliasname))
+#endif
+
+#define NO_EXEC_STACK_DIRECTIVE
+
+#elif defined(__sparc__)
+
+#elif defined(_AIX)
+
+#if defined(__powerpc64__)
+#define VBYTE_LEN 8
+#define CSECT_ALIGN 3
+#else
+#define VBYTE_LEN 4
+#define CSECT_ALIGN 2
+#endif
+
+// clang-format off
+#define DEFINE_LIBUNWIND_FUNCTION_AND_WEAK_ALIAS(name, aliasname)              \
+  .csect .text[PR], 2 SEPARATOR                                                \
+  .csect .name[PR], 2 SEPARATOR                                                \
+  .globl name[DS] SEPARATOR                                                    \
+  .globl .name[PR] SEPARATOR                                                   \
+  .align 4 SEPARATOR                                                           \
+  .csect name[DS], CSECT_ALIGN SEPARATOR                                       \
+aliasname:                                                                     \
+  .vbyte VBYTE_LEN, .name[PR] SEPARATOR                                        \
+  .vbyte VBYTE_LEN, TOC[TC0] SEPARATOR                                         \
+  .vbyte VBYTE_LEN, 0 SEPARATOR                                                \
+  .weak  aliasname SEPARATOR                                                   \
+  .weak  .aliasname SEPARATOR                                                  \
+  .csect .name[PR], 2 SEPARATOR                                                \
+.aliasname:                                                                    \
+
+#define WEAK_ALIAS(name, aliasname)
+#define NO_EXEC_STACK_DIRECTIVE
+
+// clang-format on
+#else
+
+#error Unsupported target
+
+#endif
+
+#if defined(_AIX)
+  // clang-format off
+#define DEFINE_LIBUNWIND_FUNCTION(name)                                        \
+  .globl name[DS] SEPARATOR                                                    \
+  .globl .name SEPARATOR                                                       \
+  .align 4 SEPARATOR                                                           \
+  .csect name[DS], CSECT_ALIGN SEPARATOR                                       \
+  .vbyte VBYTE_LEN, .name SEPARATOR                                            \
+  .vbyte VBYTE_LEN, TOC[TC0] SEPARATOR                                         \
+  .vbyte VBYTE_LEN, 0 SEPARATOR                                                \
+  .csect .text[PR], 2 SEPARATOR                                                \
+.name:
+  // clang-format on
+#else
+#define DEFINE_LIBUNWIND_FUNCTION(name)                                        \
+  .globl SYMBOL_NAME(name) SEPARATOR                                           \
+  HIDDEN_SYMBOL(SYMBOL_NAME(name)) SEPARATOR                                   \
+  SYMBOL_IS_FUNC(SYMBOL_NAME(name)) SEPARATOR                                  \
+  PPC64_OPD1                                                                   \
+  SYMBOL_NAME(name):                                                           \
+  PPC64_OPD2                                                                   \
+  AARCH64_BTI
+#endif
+
+#if defined(__arm__)
+#if !defined(__ARM_ARCH)
+#define __ARM_ARCH 4
+#endif
+
+#if defined(__ARM_ARCH_4T__) || __ARM_ARCH >= 5
+#define ARM_HAS_BX
+#endif
+
+#ifdef ARM_HAS_BX
+#define JMP(r) bx r
+#else
+#define JMP(r) mov pc, r
+#endif
+#endif /* __arm__ */
+
+#if defined(__powerpc__)
+#define PPC_LEFT_SHIFT(index) << (index)
+#endif
+
+#endif /* UNWIND_ASSEMBLY_H */
diff --git a/third_party/libunwind/libunwind.cc b/third_party/libunwind/libunwind.cc
index 4f58a27a0..053b972a7 100644
--- a/third_party/libunwind/libunwind.cc
+++ b/third_party/libunwind/libunwind.cc
@@ -321,7 +321,7 @@ void __unw_remove_dynamic_fde(unw_word_t fde) {
 void __unw_add_dynamic_eh_frame_section(unw_word_t eh_frame_start) {
   // The eh_frame section start serves as the mh_group
   unw_word_t mh_group = eh_frame_start;
-  CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
+  CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo = {};
   CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
   auto p = (LocalAddressSpace::pint_t)eh_frame_start;
   while (true) {
diff --git a/third_party/linenoise/BUILD.mk b/third_party/linenoise/BUILD.mk
index 70414264f..8ee501529 100644
--- a/third_party/linenoise/BUILD.mk
+++ b/third_party/linenoise/BUILD.mk
@@ -19,16 +19,17 @@ THIRD_PARTY_LINENOISE_A_DIRECTDEPS =				\
 	LIBC_CALLS						\
 	LIBC_FMT						\
 	LIBC_INTRIN						\
-	LIBC_NEXGEN32E						\
+	LIBC_LOG						\
 	LIBC_MEM						\
-	LIBC_SYSV						\
+	LIBC_NEXGEN32E						\
+	LIBC_RUNTIME						\
 	LIBC_SOCK						\
 	LIBC_STDIO						\
-	LIBC_RUNTIME						\
-	LIBC_LOG						\
-	LIBC_SYSV_CALLS						\
 	LIBC_STR						\
-	NET_HTTP
+	LIBC_SYSV						\
+	LIBC_SYSV_CALLS						\
+	NET_HTTP						\
+	THIRD_PARTY_MUSL					\
 
 THIRD_PARTY_LINENOISE_A_DEPS :=					\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_LINENOISE_A_DIRECTDEPS),$($(x))))
diff --git a/third_party/linenoise/linenoise.c b/third_party/linenoise/linenoise.c
index 8c7c0d144..fffa024e4 100644
--- a/third_party/linenoise/linenoise.c
+++ b/third_party/linenoise/linenoise.c
@@ -140,11 +140,11 @@
 #include "libc/fmt/conv.h"
 #include "libc/serialize.h"
 #include "libc/intrin/bsr.h"
-#include "libc/intrin/nomultics.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/nomultics.h"
+#include "libc/intrin/strace.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/rdtsc.h"
@@ -155,7 +155,7 @@
 #include "libc/stdio/append.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/str/unicode.h"
 #include "libc/sysv/consts/fileno.h"
 #include "libc/sysv/consts/map.h"
@@ -168,6 +168,7 @@
 #include "libc/sysv/consts/termios.h"
 #include "libc/sysv/errfuns.h"
 #include "net/http/escape.h"
+#include "libc/wctype.h"
 #include "tool/build/lib/case.h"
 
 __notice(linenoise_notice, "\
@@ -407,9 +408,7 @@ static int linenoiseIsUnsupportedTerm(void) {
   char *term;
   static char once, res;
   if (!once) {
-    if (IsWindows()) {
-      res = 1;
-    } else if ((term = getenv("TERM"))) {
+    if ((term = getenv("TERM"))) {
       for (i = 0; i < sizeof(kUnsupported) / sizeof(*kUnsupported); i++) {
         if (!strcasecmp(term, kUnsupported[i])) {
           res = 1;
diff --git a/third_party/lua/BUILD.mk b/third_party/lua/BUILD.mk
index 6fe58a0c9..1adb27977 100644
--- a/third_party/lua/BUILD.mk
+++ b/third_party/lua/BUILD.mk
@@ -131,6 +131,7 @@ THIRD_PARTY_LUA_A_DIRECTDEPS =					\
 	LIBC_RUNTIME						\
 	LIBC_STDIO						\
 	LIBC_STR						\
+	LIBC_SYSTEM						\
 	LIBC_SYSV						\
 	LIBC_THREAD						\
 	LIBC_TINYMATH						\
@@ -139,7 +140,8 @@ THIRD_PARTY_LUA_A_DIRECTDEPS =					\
 	THIRD_PARTY_DOUBLECONVERSION				\
 	THIRD_PARTY_GDTOA					\
 	THIRD_PARTY_LINENOISE					\
-	THIRD_PARTY_TZ
+	THIRD_PARTY_MUSL					\
+	THIRD_PARTY_TZ						\
 
 THIRD_PARTY_LUA_A_DEPS :=					\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_LUA_A_DIRECTDEPS),$($(x))))
diff --git a/third_party/lua/lbaselib.c b/third_party/lua/lbaselib.c
index 10a0e75f1..f8b778d33 100644
--- a/third_party/lua/lbaselib.c
+++ b/third_party/lua/lbaselib.c
@@ -32,6 +32,7 @@
 #include "third_party/lua/lauxlib.h"
 #include "third_party/lua/lprefix.h"
 #include "third_party/lua/lua.h"
+#include "libc/ctype.h"
 #include "third_party/lua/lualib.h"
 __static_yoink("lua_notice");
 
diff --git a/third_party/lua/liolib.c b/third_party/lua/liolib.c
index a668b0c1c..18bba75a1 100644
--- a/third_party/lua/liolib.c
+++ b/third_party/lua/liolib.c
@@ -37,6 +37,7 @@
 #include "third_party/lua/lauxlib.h"
 #include "third_party/lua/lprefix.h"
 #include "third_party/lua/lua.h"
+#include "libc/ctype.h"
 #include "third_party/lua/lualib.h"
 __static_yoink("lua_notice");
 
diff --git a/third_party/lua/llock.c b/third_party/lua/llock.c
index 9a0f0bfbb..359140f55 100644
--- a/third_party/lua/llock.c
+++ b/third_party/lua/llock.c
@@ -19,12 +19,16 @@
 #include "libc/thread/thread.h"
 #include "third_party/lua/lrepl.h"
 
-static pthread_mutex_t lua_repl_lock_obj;
+static pthread_mutex_t lua_repl_lock_obj = PTHREAD_MUTEX_INITIALIZER;
 
-void(lua_repl_lock)(void) {
+void lua_repl_wock(void) {
+  lua_repl_lock_obj = (pthread_mutex_t)PTHREAD_MUTEX_INITIALIZER;
+}
+
+void lua_repl_lock(void) {
   pthread_mutex_lock(&lua_repl_lock_obj);
 }
 
-void(lua_repl_unlock)(void) {
+void lua_repl_unlock(void) {
   pthread_mutex_unlock(&lua_repl_lock_obj);
 }
diff --git a/third_party/lua/lrepl.c b/third_party/lua/lrepl.c
index b56548a6b..5201f1e7b 100644
--- a/third_party/lua/lrepl.c
+++ b/third_party/lua/lrepl.c
@@ -30,9 +30,9 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/errno.h"
-#include "libc/intrin/nomultics.internal.h"
+#include "libc/intrin/nomultics.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
@@ -335,7 +335,7 @@ void lua_initrepl(lua_State *L) {
     prompt = get_prompt(L, 1);
     if ((g_historypath = linenoiseGetHistoryPath(lua_progname))) {
       if (linenoiseHistoryLoad(g_historypath) == -1) {
-        fprintf(stderr, "%r%s: failed to load history: %m%n", g_historypath);
+        fprintf(stderr, "%r%s: failed to load history: %m\n", g_historypath);
         free(g_historypath);
         g_historypath = 0;
       }
diff --git a/third_party/lua/lrepl.h b/third_party/lua/lrepl.h
index a2294c5ca..7d08b0730 100644
--- a/third_party/lua/lrepl.h
+++ b/third_party/lua/lrepl.h
@@ -11,6 +11,7 @@ extern struct linenoiseState *lua_repl_linenoise;
 extern linenoiseCompletionCallback *lua_repl_completions_callback;
 
 void lua_freerepl(void);
+void lua_repl_wock(void);
 void lua_repl_lock(void);
 void lua_repl_unlock(void);
 int lua_loadline(lua_State *);
diff --git a/third_party/lua/lstrlib.c b/third_party/lua/lstrlib.c
index 9c8c7a1ba..7fd3a842c 100644
--- a/third_party/lua/lstrlib.c
+++ b/third_party/lua/lstrlib.c
@@ -34,6 +34,7 @@
 #include "third_party/lua/lauxlib.h"
 #include "third_party/lua/lprefix.h"
 #include "third_party/lua/lua.h"
+#include "libc/ctype.h"
 #include "third_party/lua/lualib.h"
 __static_yoink("lua_notice");
 
diff --git a/third_party/lua/ltests.c b/third_party/lua/ltests.c
index 8a9a66347..851284956 100644
--- a/third_party/lua/ltests.c
+++ b/third_party/lua/ltests.c
@@ -28,25 +28,39 @@
 #define ltests_c
 #define LUA_CORE
 
-#include "third_party/lua/lapi.h"
-#include "third_party/lua/lauxlib.h"
-#include "third_party/lua/lcode.h"
-#include "third_party/lua/lctype.h"
-#include "third_party/lua/ldebug.h"
-#include "third_party/lua/ldo.h"
-#include "third_party/lua/lfunc.h"
-#include "third_party/lua/lmem.h"
-#include "third_party/lua/lopcodes.h"
-#include "third_party/lua/lopnames.inc"
-#include "third_party/lua/lprefix.h"
-#include "third_party/lua/lstate.h"
-#include "third_party/lua/lstring.h"
-#include "third_party/lua/ltable.h"
-#include "third_party/lua/lua.h"
-#include "third_party/lua/lualib.h"
+#include "lprefix.h"
+
+#include <limits.h>
+#include <setjmp.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "libc/mem/gc.h"
+#include "libc/log/log.h"
+
+#include "lua.h"
+
+#include "lapi.h"
+#include "lauxlib.h"
+#include "lcode.h"
+#include "lctype.h"
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lmem.h"
+#include "lopcodes.h"
+#include "lopnames.inc"
+#include "lprefix.h"
+#include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
+#include "lualib.h"
+#include "ltm.h"
+
 __static_yoink("lua_notice");
 
 
+
 /*
 ** The whole module only makes sense with LUA_DEBUG on
 */
diff --git a/third_party/lua/lua.h b/third_party/lua/lua.h
index f17da40f3..470e0f423 100644
--- a/third_party/lua/lua.h
+++ b/third_party/lua/lua.h
@@ -133,6 +133,14 @@ typedef struct lua_Debug lua_Debug;
 typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
 
 
+/*
+** [jart] support ltests.h without unsafe LUA_USER_H kludge
+**        use `make MODE=dbg` to get this functionality
+*/
+#ifdef MODE_DBG
+#include "ltests.h"
+#endif
+
 /*
 ** generic extra include file
 */
diff --git a/third_party/lua/lua.main.c b/third_party/lua/lua.main.c
index 469c5638f..9a0cee129 100644
--- a/third_party/lua/lua.main.c
+++ b/third_party/lua/lua.main.c
@@ -50,8 +50,8 @@
 #include "third_party/lua/lrepl.h"
 #include "third_party/lua/lualib.h"
 #include "third_party/lua/lunix.h"
+#include "libc/cosmo.h"
 #include "libc/mem/leaks.h"
-#include "tool/args/args.h"
 __static_yoink("lua_notice");
 
 #if !defined(LUA_PROGNAME)
diff --git a/third_party/lua/luac.main.c b/third_party/lua/luac.main.c
index 456343e2b..2898af946 100644
--- a/third_party/lua/luac.main.c
+++ b/third_party/lua/luac.main.c
@@ -43,6 +43,7 @@
 #include "third_party/lua/lstate.h"
 #include "third_party/lua/lua.h"
 #include "third_party/lua/lualib.h"
+#include "libc/ctype.h"
 #include "third_party/lua/lundump.h"
 __static_yoink("lua_notice");
 
diff --git a/third_party/lua/luacallwithtrace.c b/third_party/lua/luacallwithtrace.c
index 7dee8c79f..5c0ac4d93 100644
--- a/third_party/lua/luacallwithtrace.c
+++ b/third_party/lua/luacallwithtrace.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "third_party/lua/cosmo.h"
 #include "third_party/lua/lauxlib.h"
 
diff --git a/third_party/lua/lunix.c b/third_party/lua/lunix.c
index 8f6c36c17..f5007e414 100644
--- a/third_party/lua/lunix.c
+++ b/third_party/lua/lunix.c
@@ -46,10 +46,10 @@
 #include "libc/fmt/magnumstrs.internal.h"
 #include "libc/intrin/atomic.h"
 #include "libc/serialize.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/limits.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/process.h"
 #include "libc/nt/runtime.h"
@@ -109,7 +109,9 @@
 #include "third_party/lua/lgc.h"
 #include "third_party/lua/lua.h"
 #include "third_party/lua/luaconf.h"
-#include "third_party/nsync/futex.internal.h"
+#include "libc/sysv/consts/clock.h"
+#include "libc/cosmo.h"
+#include "libc/cosmo.h"
 #include "tool/net/luacheck.h"
 
 #define DNS_NAME_MAX  253
@@ -129,9 +131,10 @@ static void *LuaRealloc(lua_State *L, void *p, size_t n) {
   if (n < 0x100000000000) {
     WARNF("reacting to malloc() failure by running lua garbage collector...");
     luaC_fullgc(L, 1);
-    p2 = realloc(p, n);
+    if ((p2 = realloc(p, n)))
+      return p2;
   }
-  return p2;
+  return p;
 }
 
 static void *LuaAlloc(lua_State *L, size_t n) {
@@ -1006,7 +1009,7 @@ static int LuaUnixOpen(lua_State *L) {
   return SysretInteger(
       L, "open", olderr,
       openat(luaL_optinteger(L, 4, AT_FDCWD), luaL_checkstring(L, 1),
-             luaL_optinteger(L, 2, O_RDONLY), luaL_optinteger(L, 3, 0)));
+             luaL_optinteger(L, 2, O_RDONLY), luaL_optinteger(L, 3, 0644)));
 }
 
 // unix.tmpfd()
@@ -1565,7 +1568,10 @@ static int LuaUnixPoll(lua_State *L) {
         fds = fds2;
         ++nfds;
       } else {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wuse-after-free"
         free(fds);
+#pragma GCC diagnostic pop
         return LuaUnixSysretErrno(L, "poll", olderr);
       }
     } else {
@@ -2850,8 +2856,8 @@ static int LuaUnixMemoryWait(lua_State *L) {
     deadline = &ts;
   }
   BEGIN_CANCELATION_POINT;
-  rc = nsync_futex_wait_((atomic_int *)GetWord(L), expect,
-                         PTHREAD_PROCESS_SHARED, deadline);
+  rc = cosmo_futex_wait((atomic_int *)GetWord(L), expect,
+                         PTHREAD_PROCESS_SHARED, CLOCK_REALTIME, deadline);
   END_CANCELATION_POINT;
   if (rc < 0) errno = -rc, rc = -1;
   return SysretInteger(L, "futex_wait", olderr, rc);
@@ -2862,7 +2868,7 @@ static int LuaUnixMemoryWait(lua_State *L) {
 static int LuaUnixMemoryWake(lua_State *L) {
   int count, woken;
   count = luaL_optinteger(L, 3, INT_MAX);
-  woken = nsync_futex_wake_((atomic_int *)GetWord(L), count,
+  woken = cosmo_futex_wake((atomic_int *)GetWord(L), count,
                             PTHREAD_PROCESS_SHARED);
   npassert(woken >= 0);
   return ReturnInteger(L, woken);
@@ -2953,7 +2959,7 @@ static int LuaUnixMapshared(lua_State *L) {
   m->mapsize = c;
   m->lock = (pthread_mutex_t *)p;
   pthread_mutexattr_init(&mattr);
-  pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_NORMAL);
+  pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_DEFAULT);
   pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
   pthread_mutex_init(m->lock, &mattr);
   pthread_mutexattr_destroy(&mattr);
@@ -3434,12 +3440,14 @@ int LuaUnix(lua_State *L) {
   LuaSetIntField(L, "SHUT_RDWR", SHUT_RDWR);
 
   // recvfrom() / sendto() flags
-  LuaSetIntField(L, "MSG_WAITALL", MSG_WAITALL);
-  LuaSetIntField(L, "MSG_DONTROUTE", MSG_DONTROUTE);
-  LuaSetIntField(L, "MSG_PEEK", MSG_PEEK);
   LuaSetIntField(L, "MSG_OOB", MSG_OOB);
+  LuaSetIntField(L, "MSG_PEEK", MSG_PEEK);
+  LuaSetIntField(L, "MSG_DONTROUTE", MSG_DONTROUTE);
+  LuaSetIntField(L, "MSG_DONTWAIT", MSG_DONTWAIT);
   LuaSetIntField(L, "MSG_NOSIGNAL", MSG_NOSIGNAL);
-  LuaSetIntField(L, "MSG_MORE", MSG_MORE);
+  LuaSetIntField(L, "MSG_WAITALL", MSG_WAITALL);
+  LuaSetIntField(L, "MSG_TRUNC", MSG_TRUNC);
+  LuaSetIntField(L, "MSG_CTRUNC", MSG_CTRUNC);
 
   // readdir() type
   LuaSetIntField(L, "DT_UNKNOWN", DT_UNKNOWN);
diff --git a/third_party/lua/test/literals.lua b/third_party/lua/test/literals.lua
index 4831534a2..6394c4f88 100644
--- a/third_party/lua/test/literals.lua
+++ b/third_party/lua/test/literals.lua
@@ -294,30 +294,31 @@ end
 
 
 -- testing decimal point locale
-if os.setlocale("pt_BR") or os.setlocale("ptb") then
-  assert(tonumber("3,4") == 3.4 and tonumber"3.4" == 3.4)
-  assert(tonumber("  -.4  ") == -0.4)
-  assert(tonumber("  +0x.41  ") == 0X0.41)
-  assert(not load("a = (3,4)"))
-  assert(assert(load("return 3.4"))() == 3.4)
-  assert(assert(load("return .4,3"))() == .4)
-  assert(assert(load("return 4."))() == 4.)
-  assert(assert(load("return 4.+.5"))() == 4.5)
+-- <disabled by jart: doesn't play nice with musl locale faking>
+-- if os.setlocale("pt_BR") or os.setlocale("ptb") then
+--   assert(tonumber("3,4") == 3.4 and tonumber"3.4" == 3.4)
+--   assert(tonumber("  -.4  ") == -0.4)
+--   assert(tonumber("  +0x.41  ") == 0X0.41)
+--   assert(not load("a = (3,4)"))
+--   assert(assert(load("return 3.4"))() == 3.4)
+--   assert(assert(load("return .4,3"))() == .4)
+--   assert(assert(load("return 4."))() == 4.)
+--   assert(assert(load("return 4.+.5"))() == 4.5)
 
-  assert(" 0x.1 " + " 0x,1" + "-0X.1\t" == 0x0.1)
+--   assert(" 0x.1 " + " 0x,1" + "-0X.1\t" == 0x0.1)
 
-  assert(not tonumber"inf" and not tonumber"NAN")
+--   assert(not tonumber"inf" and not tonumber"NAN")
 
-  assert(assert(load(string.format("return %q", 4.51)))() == 4.51)
+--   assert(assert(load(string.format("return %q", 4.51)))() == 4.51)
 
-  local a,b = load("return 4.5.")
-  assert(string.find(b, "'4%.5%.'"))
+--   local a,b = load("return 4.5.")
+--   assert(string.find(b, "'4%.5%.'"))
 
-  assert(os.setlocale("C"))
-else
-  (Message or print)(
-   '\n >>> pt_BR locale not available: skipping decimal point tests <<<\n')
-end
+--   assert(os.setlocale("C"))
+-- else
+--   (Message or print)(
+--    '\n >>> pt_BR locale not available: skipping decimal point tests <<<\n')
+-- end
 
 
 -- testing %q x line ends
diff --git a/third_party/lua/test/strings.lua b/third_party/lua/test/strings.lua
index 3af86efd0..bc62cf192 100644
--- a/third_party/lua/test/strings.lua
+++ b/third_party/lua/test/strings.lua
@@ -430,14 +430,18 @@ if not _port then
   end
 
   if trylocale("collate")  then
-    assert("alo" < "�lo" and "�lo" < "amo")
+    -- <disabled by jart: doesn't play nice with musl locale faking>
+    -- assert("alo" < "�lo" and "�lo" < "amo")
+    -- </disabled by jart>
   end
 
   if trylocale("ctype") then
-    assert(string.gsub("�����", "%a", "x") == "xxxxx")
-    assert(string.gsub("����", "%l", "x") == "x�x�")
-    assert(string.gsub("����", "%u", "x") == "�x�x")
-    assert(string.upper"���{xuxu}��o" == "���{XUXU}��O")
+    -- <disabled by jart: doesn't play nice with musl locale faking>
+    -- assert(string.gsub("�����", "%a", "x") == "xxxxx")
+    -- assert(string.gsub("����", "%l", "x") == "x�x�")
+    -- assert(string.gsub("����", "%u", "x") == "�x�x")
+    -- assert(string.upper"���{xuxu}��o" == "���{XUXU}��O")
+    -- </disabled by jart>
   end
 
   os.setlocale("C")
diff --git a/third_party/make/getopt.c b/third_party/make/getopt.c
index 7b4202bce..99646b8fe 100644
--- a/third_party/make/getopt.c
+++ b/third_party/make/getopt.c
@@ -27,6 +27,7 @@ this program.  If not, see <https://www.gnu.org/licenses/>.  */
 #endif
 
 #ifdef HAVE_CONFIG_H
+#include "libc/runtime/runtime.h"
 #include "config.h"
 #endif
 
@@ -201,10 +202,6 @@ static char *posixly_correct;
 /* Avoid depending on library functions or files
    whose names are inconsistent.  */
 
-#ifndef getenv
-extern char *getenv ();
-#endif
-
 static char *
 my_index (const char *str, int chr)
 {
diff --git a/third_party/make/getopt.h b/third_party/make/getopt.h
index df18ceeb9..bc576d706 100644
--- a/third_party/make/getopt.h
+++ b/third_party/make/getopt.h
@@ -1,5 +1,7 @@
 /* Declarations for getopt.
 Copyright (C) 1989-2023 Free Software Foundation, Inc.
+#include "third_party/getopt/long2.h"
+#include "third_party/getopt/getopt.internal.h"
 
 NOTE: The canonical source of this file is maintained with the GNU C Library.
 Bugs can be reported to bug-glibc@gnu.org.
@@ -101,8 +103,6 @@ struct option
    differences in the consts, in stdlib.h.  To avoid compilation
    errors, only prototype getopt for the GNU C library.  */
 extern int getopt (int argc, char *const *argv, const char *shortopts);
-#else /* not __GNU_LIBRARY__ */
-extern int getopt ();
 #endif /* __GNU_LIBRARY__ */
 extern int getopt_long (int argc, char *const *argv, const char *shortopts,
 		        const struct option *longopts, int *longind);
@@ -116,11 +116,10 @@ extern int _getopt_internal (int argc, char *const *argv,
 		             const struct option *longopts, int *longind,
 			     int long_only);
 #else /* not __STDC__ */
-extern int getopt ();
-extern int getopt_long ();
-extern int getopt_long_only ();
-
-extern int _getopt_internal ();
+// extern int getopt ();
+// extern int getopt_long ();
+// extern int getopt_long_only ();
+// extern int _getopt_internal ();
 #endif /* __STDC__ */
 
 #ifdef	__cplusplus
diff --git a/third_party/make/job.c b/third_party/make/job.c
index 9b0399d98..66c2f27ff 100644
--- a/third_party/make/job.c
+++ b/third_party/make/job.c
@@ -427,6 +427,7 @@ is_bourne_compatible_shell (const char *path)
     "sh",
     "bash",
     "dash",
+    "cocmd",
     "ksh",
     "rksh",
     "zsh",
diff --git a/third_party/maxmind/getmetroname.c b/third_party/maxmind/getmetroname.c
index 2326f2ddb..79a6e1ca7 100644
--- a/third_party/maxmind/getmetroname.c
+++ b/third_party/maxmind/getmetroname.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "third_party/maxmind/maxminddb.h"
 
 const struct thatispacked MetroName {
diff --git a/third_party/mbedtls/bigmul.c b/third_party/mbedtls/bigmul.c
index 8d84456ae..2233ea644 100644
--- a/third_party/mbedtls/bigmul.c
+++ b/third_party/mbedtls/bigmul.c
@@ -17,7 +17,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/log/backtrace.internal.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "third_party/mbedtls/bignum.h"
diff --git a/third_party/mbedtls/bignum.c b/third_party/mbedtls/bignum.c
index 96f0eb1a1..6bcf0f029 100644
--- a/third_party/mbedtls/bignum.c
+++ b/third_party/mbedtls/bignum.c
@@ -19,7 +19,7 @@
 #include "libc/serialize.h"
 #include "libc/intrin/bsf.h"
 #include "libc/intrin/bswap.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/nexgen32e.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/runtime/runtime.h"
diff --git a/third_party/mbedtls/bigshift.c b/third_party/mbedtls/bigshift.c
index d6be87e91..0c056a145 100644
--- a/third_party/mbedtls/bigshift.c
+++ b/third_party/mbedtls/bigshift.c
@@ -15,7 +15,7 @@
 │ See the License for the specific language governing permissions and          │
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "third_party/mbedtls/bignum.h"
 #include "third_party/mbedtls/bignum_internal.h"
diff --git a/third_party/mbedtls/ecp.c b/third_party/mbedtls/ecp.c
index 4b696ef83..60870d240 100644
--- a/third_party/mbedtls/ecp.c
+++ b/third_party/mbedtls/ecp.c
@@ -16,7 +16,7 @@
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/mbedtls/ecp.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
 #include "libc/runtime/runtime.h"
diff --git a/third_party/mbedtls/fastdiv.h b/third_party/mbedtls/fastdiv.h
index 16d866a5c..df177adfd 100644
--- a/third_party/mbedtls/fastdiv.h
+++ b/third_party/mbedtls/fastdiv.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_FASTDIV_H_
 #define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_FASTDIV_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 COSMOPOLITAN_C_START_
 
 struct Divisor {
diff --git a/third_party/mbedtls/formatclientciphers.c b/third_party/mbedtls/formatclientciphers.c
index 3b2b04c3b..392373a0c 100644
--- a/third_party/mbedtls/formatclientciphers.c
+++ b/third_party/mbedtls/formatclientciphers.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/serialize.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/stdio/append.h"
 #include "third_party/mbedtls/iana.h"
 
diff --git a/third_party/mbedtls/profile.h b/third_party/mbedtls/profile.h
index 8c8553e7b..3143d73eb 100644
--- a/third_party/mbedtls/profile.h
+++ b/third_party/mbedtls/profile.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PROFILE_H_
 #define COSMOPOLITAN_THIRD_PARTY_MBEDTLS_PROFILE_H_
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/log/log.h"
 #include "libc/nexgen32e/bench.h"
 #include "libc/nexgen32e/rdtsc.h"
diff --git a/third_party/mbedtls/rsa.c b/third_party/mbedtls/rsa.c
index edc6ae58f..5ecfe67bb 100644
--- a/third_party/mbedtls/rsa.c
+++ b/third_party/mbedtls/rsa.c
@@ -16,7 +16,7 @@
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/mbedtls/rsa.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/rand.h"
 #include "third_party/mbedtls/common.h"
diff --git a/third_party/mbedtls/sha1.c b/third_party/mbedtls/sha1.c
index 7507a7445..193a4c3a5 100644
--- a/third_party/mbedtls/sha1.c
+++ b/third_party/mbedtls/sha1.c
@@ -17,7 +17,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/mbedtls/sha1.h"
 #include "libc/serialize.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/sha.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/str/str.h"
diff --git a/third_party/mbedtls/sha256.c b/third_party/mbedtls/sha256.c
index 03e979011..6112e6c77 100644
--- a/third_party/mbedtls/sha256.c
+++ b/third_party/mbedtls/sha256.c
@@ -17,7 +17,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/mbedtls/sha256.h"
 #include "libc/dce.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/nexgen32e.h"
 #include "libc/nexgen32e/sha.h"
 #include "libc/nexgen32e/x86feature.h"
diff --git a/third_party/mbedtls/sha512.c b/third_party/mbedtls/sha512.c
index 82469e893..e4c551962 100644
--- a/third_party/mbedtls/sha512.c
+++ b/third_party/mbedtls/sha512.c
@@ -17,7 +17,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/mbedtls/sha512.h"
 #include "libc/literal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/nexgen32e.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/str/str.h"
diff --git a/third_party/mbedtls/sha512t.c b/third_party/mbedtls/sha512t.c
index 5e4730831..33180e110 100644
--- a/third_party/mbedtls/sha512t.c
+++ b/third_party/mbedtls/sha512t.c
@@ -15,7 +15,7 @@
 │ See the License for the specific language governing permissions and          │
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "third_party/mbedtls/platform.h"
 #include "third_party/mbedtls/sha512.h"
diff --git a/third_party/mbedtls/ssl_msg.c b/third_party/mbedtls/ssl_msg.c
index 41fb201d3..22164b2ca 100644
--- a/third_party/mbedtls/ssl_msg.c
+++ b/third_party/mbedtls/ssl_msg.c
@@ -1206,7 +1206,11 @@ static void mbedtls_ssl_cf_memcpy_if_eq( unsigned char *dst,
         __builtin_memcpy( &x, dst + i, 8 );
         __builtin_memcpy( &y, src + i, 8 );
         x = ( x & ~-equal ) | ( y & -equal );
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-overflow"
+        // TODO(jart): What is this mysterious confusing GCC warning?
         __builtin_memcpy( dst + i, &x, 8 );
+#pragma GCC diagnostic pop
     }
     for( ; i < len; i++ )
         dst[i] = ( src[i] & mask ) | ( dst[i] & ~mask );
diff --git a/third_party/mbedtls/ssl_srv.c b/third_party/mbedtls/ssl_srv.c
index 5b2cbe2e8..b58d403fe 100644
--- a/third_party/mbedtls/ssl_srv.c
+++ b/third_party/mbedtls/ssl_srv.c
@@ -16,7 +16,7 @@
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/time.h"
 #include "third_party/mbedtls/common.h"
diff --git a/third_party/mbedtls/test/lib.c b/third_party/mbedtls/test/lib.c
index 7e9de24be..fbe2fa9ab 100644
--- a/third_party/mbedtls/test/lib.c
+++ b/third_party/mbedtls/test/lib.c
@@ -22,8 +22,8 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
-#include "libc/intrin/describebacktrace.internal.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/describebacktrace.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/log/backtrace.internal.h"
 #include "libc/log/check.h"
diff --git a/third_party/mbedtls/test/test.inc b/third_party/mbedtls/test/test.inc
index f4a992d4e..8c10d98da 100644
--- a/third_party/mbedtls/test/test.inc
+++ b/third_party/mbedtls/test/test.inc
@@ -2,7 +2,7 @@
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/sysv/consts/exit.h"
 #include "third_party/mbedtls/config.h"
 #include "third_party/mbedtls/test/lib.h"
diff --git a/third_party/mbedtls/test/test_suite_ssl.c b/third_party/mbedtls/test/test_suite_ssl.c
index 0c9f6e54c..6c3c7bb1e 100644
--- a/third_party/mbedtls/test/test_suite_ssl.c
+++ b/third_party/mbedtls/test/test_suite_ssl.c
@@ -20,7 +20,7 @@
 #include "libc/log/log.h"
 #include "libc/time.h"
 #include "libc/stdio/rand.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "third_party/mbedtls/test/test.inc"
 /*
  * *** THIS FILE WAS MACHINE GENERATED ***
diff --git a/third_party/musl/BUILD.mk b/third_party/musl/BUILD.mk
index b8b2c98fd..940bd7cf9 100644
--- a/third_party/musl/BUILD.mk
+++ b/third_party/musl/BUILD.mk
@@ -11,6 +11,7 @@ THIRD_PARTY_MUSL = $(THIRD_PARTY_MUSL_A_DEPS) $(THIRD_PARTY_MUSL_A)
 THIRD_PARTY_MUSL_A = o/$(MODE)/third_party/musl/musl.a
 THIRD_PARTY_MUSL_A_FILES := $(wildcard third_party/musl/*)
 THIRD_PARTY_MUSL_A_HDRS = $(filter %.h,$(THIRD_PARTY_MUSL_A_FILES))
+THIRD_PARTY_MUSL_A_INCS = $(filter %.inc,$(THIRD_PARTY_MUSL_A_FILES))
 THIRD_PARTY_MUSL_A_SRCS = $(filter %.c,$(THIRD_PARTY_MUSL_A_FILES))
 
 THIRD_PARTY_MUSL_A_OBJS =				\
@@ -30,7 +31,8 @@ THIRD_PARTY_MUSL_A_DIRECTDEPS =				\
 	LIBC_STR					\
 	LIBC_SYSV					\
 	LIBC_THREAD					\
-	THIRD_PARTY_ZLIB
+	THIRD_PARTY_TZ					\
+	THIRD_PARTY_ZLIB				\
 
 THIRD_PARTY_MUSL_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_MUSL_A_DIRECTDEPS),$($(x))))
@@ -59,6 +61,8 @@ $(THIRD_PARTY_MUSL_A_OBJS): private COPTS += -Wframe-larger-than=4096 -Walloca-l
 
 THIRD_PARTY_MUSL_LIBS = $(foreach x,$(THIRD_PARTY_MUSL_ARTIFACTS),$($(x)))
 THIRD_PARTY_MUSL_SRCS = $(foreach x,$(THIRD_PARTY_MUSL_ARTIFACTS),$($(x)_SRCS))
+THIRD_PARTY_MUSL_HDRS = $(foreach x,$(THIRD_PARTY_MUSL_ARTIFACTS),$($(x)_HDRS))
+THIRD_PARTY_MUSL_INCS = $(foreach x,$(THIRD_PARTY_MUSL_ARTIFACTS),$($(x)_INCS))
 THIRD_PARTY_MUSL_CHECKS = $(foreach x,$(THIRD_PARTY_MUSL_ARTIFACTS),$($(x)_CHECKS))
 THIRD_PARTY_MUSL_OBJS = $(foreach x,$(THIRD_PARTY_MUSL_ARTIFACTS),$($(x)_OBJS))
 $(THIRD_PARTY_MUSL_OBJS): third_party/musl/BUILD.mk
diff --git a/third_party/musl/__mo_lookup.c b/third_party/musl/__mo_lookup.c
new file mode 100644
index 000000000..1ef350aec
--- /dev/null
+++ b/third_party/musl/__mo_lookup.c
@@ -0,0 +1,72 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/str/str.h"
+#include "libc/str/locale.internal.h"
+__static_yoink("musl_libc_notice");
+
+#pragma GCC diagnostic ignored "-Wparentheses"
+
+static inline uint32_t swapc(uint32_t x, int c)
+{
+	return c ? x>>24 | x>>8&0xff00 | x<<8&0xff0000 | x<<24 : x;
+}
+
+const char *__mo_lookup(const void *p, size_t size, const char *s)
+{
+	const uint32_t *mo = p;
+	int sw = *mo - 0x950412de;
+	uint32_t b = 0, n = swapc(mo[2], sw);
+	uint32_t o = swapc(mo[3], sw);
+	uint32_t t = swapc(mo[4], sw);
+	if (n>=size/4 || o>=size-4*n || t>=size-4*n || ((o|t)%4))
+		return 0;
+	o/=4;
+	t/=4;
+	for (;;) {
+		uint32_t ol = swapc(mo[o+2*(b+n/2)], sw);
+		uint32_t os = swapc(mo[o+2*(b+n/2)+1], sw);
+		if (os >= size || ol >= size-os || ((char *)p)[os+ol])
+			return 0;
+		int sign = strcmp(s, (char *)p + os);
+		if (!sign) {
+			uint32_t tl = swapc(mo[t+2*(b+n/2)], sw);
+			uint32_t ts = swapc(mo[t+2*(b+n/2)+1], sw);
+			if (ts >= size || tl >= size-ts || ((char *)p)[ts+tl])
+				return 0;
+			return (char *)p + ts;
+		}
+		else if (n == 1) return 0;
+		else if (sign < 0)
+			n /= 2;
+		else {
+			b += n/2;
+			n -= n/2;
+		}
+	}
+	return 0;
+}
diff --git a/third_party/musl/__month_to_secs.c b/third_party/musl/__month_to_secs.c
new file mode 100644
index 000000000..43248fb3c
--- /dev/null
+++ b/third_party/musl/__month_to_secs.c
@@ -0,0 +1,10 @@
+int __month_to_secs(int month, int is_leap)
+{
+	static const int secs_through_month[] = {
+		0, 31*86400, 59*86400, 90*86400,
+		120*86400, 151*86400, 181*86400, 212*86400,
+		243*86400, 273*86400, 304*86400, 334*86400 };
+	int t = secs_through_month[month];
+	if (is_leap && month >= 2) t+=86400;
+	return t;
+}
diff --git a/third_party/musl/__secs_to_tm.c b/third_party/musl/__secs_to_tm.c
new file mode 100644
index 000000000..093d9021a
--- /dev/null
+++ b/third_party/musl/__secs_to_tm.c
@@ -0,0 +1,82 @@
+#include "time_impl.h"
+#include <limits.h>
+
+/* 2000-03-01 (mod 400 year, immediately after feb29 */
+#define LEAPOCH (946684800LL + 86400*(31+29))
+
+#define DAYS_PER_400Y (365*400 + 97)
+#define DAYS_PER_100Y (365*100 + 24)
+#define DAYS_PER_4Y   (365*4   + 1)
+
+int __secs_to_tm(long long t, struct tm *tm)
+{
+	long long days, secs, years;
+	int remdays, remsecs, remyears;
+	int qc_cycles, c_cycles, q_cycles;
+	int months;
+	int wday, yday, leap;
+	static const char days_in_month[] = {31,30,31,30,31,31,30,31,30,31,31,29};
+
+	/* Reject time_t values whose year would overflow int */
+	if (t < INT_MIN * 31622400LL || t > INT_MAX * 31622400LL)
+		return -1;
+
+	secs = t - LEAPOCH;
+	days = secs / 86400;
+	remsecs = secs % 86400;
+	if (remsecs < 0) {
+		remsecs += 86400;
+		days--;
+	}
+
+	wday = (3+days)%7;
+	if (wday < 0) wday += 7;
+
+	qc_cycles = days / DAYS_PER_400Y;
+	remdays = days % DAYS_PER_400Y;
+	if (remdays < 0) {
+		remdays += DAYS_PER_400Y;
+		qc_cycles--;
+	}
+
+	c_cycles = remdays / DAYS_PER_100Y;
+	if (c_cycles == 4) c_cycles--;
+	remdays -= c_cycles * DAYS_PER_100Y;
+
+	q_cycles = remdays / DAYS_PER_4Y;
+	if (q_cycles == 25) q_cycles--;
+	remdays -= q_cycles * DAYS_PER_4Y;
+
+	remyears = remdays / 365;
+	if (remyears == 4) remyears--;
+	remdays -= remyears * 365;
+
+	leap = !remyears && (q_cycles || !c_cycles);
+	yday = remdays + 31 + 28 + leap;
+	if (yday >= 365+leap) yday -= 365+leap;
+
+	years = remyears + 4*q_cycles + 100*c_cycles + 400LL*qc_cycles;
+
+	for (months=0; days_in_month[months] <= remdays; months++)
+		remdays -= days_in_month[months];
+
+	if (months >= 10) {
+		months -= 12;
+		years++;
+	}
+
+	if (years+100 > INT_MAX || years+100 < INT_MIN)
+		return -1;
+
+	tm->tm_year = years + 100;
+	tm->tm_mon = months + 2;
+	tm->tm_mday = remdays + 1;
+	tm->tm_wday = wday;
+	tm->tm_yday = yday;
+
+	tm->tm_hour = remsecs / 3600;
+	tm->tm_min = remsecs / 60 % 60;
+	tm->tm_sec = remsecs % 60;
+
+	return 0;
+}
diff --git a/third_party/musl/__tm_to_secs.c b/third_party/musl/__tm_to_secs.c
new file mode 100644
index 000000000..c29fa985a
--- /dev/null
+++ b/third_party/musl/__tm_to_secs.c
@@ -0,0 +1,24 @@
+#include "time_impl.h"
+
+long long __tm_to_secs(const struct tm *tm)
+{
+	int is_leap;
+	long long year = tm->tm_year;
+	int month = tm->tm_mon;
+	if (month >= 12 || month < 0) {
+		int adj = month / 12;
+		month %= 12;
+		if (month < 0) {
+			adj--;
+			month += 12;
+		}
+		year += adj;
+	}
+	long long t = __year_to_secs(year, &is_leap);
+	t += __month_to_secs(month, is_leap);
+	t += 86400LL * (tm->tm_mday-1);
+	t += 3600LL * tm->tm_hour;
+	t += 60LL * tm->tm_min;
+	t += tm->tm_sec;
+	return t;
+}
diff --git a/third_party/musl/__year_to_secs.c b/third_party/musl/__year_to_secs.c
new file mode 100644
index 000000000..b42f5a6d2
--- /dev/null
+++ b/third_party/musl/__year_to_secs.c
@@ -0,0 +1,47 @@
+long long __year_to_secs(long long year, int *is_leap)
+{
+	if (year-2ULL <= 136) {
+		int y = year;
+		int leaps = (y-68)>>2;
+		if (!((y-68)&3)) {
+			leaps--;
+			if (is_leap) *is_leap = 1;
+		} else if (is_leap) *is_leap = 0;
+		return 31536000*(y-70) + 86400*leaps;
+	}
+
+	int cycles, centuries, leaps, rem, dummy;
+
+	if (!is_leap) is_leap = &dummy;
+	cycles = (year-100) / 400;
+	rem = (year-100) % 400;
+	if (rem < 0) {
+		cycles--;
+		rem += 400;
+	}
+	if (!rem) {
+		*is_leap = 1;
+		centuries = 0;
+		leaps = 0;
+	} else {
+		if (rem >= 200) {
+			if (rem >= 300) centuries = 3, rem -= 300;
+			else centuries = 2, rem -= 200;
+		} else {
+			if (rem >= 100) centuries = 1, rem -= 100;
+			else centuries = 0;
+		}
+		if (!rem) {
+			*is_leap = 0;
+			leaps = 0;
+		} else {
+			leaps = rem / 4U;
+			rem %= 4U;
+			*is_leap = !rem;
+		}
+	}
+
+	leaps += 97*cycles + 24*centuries - *is_leap;
+
+	return (year-100) * 31536000LL + leaps * 86400LL + 946684800 + 86400;
+}
diff --git a/third_party/musl/alpha.inc b/third_party/musl/alpha.inc
new file mode 100644
index 000000000..4167f3876
--- /dev/null
+++ b/third_party/musl/alpha.inc
@@ -0,0 +1,172 @@
+18,17,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,17,34,35,36,17,37,38,39,40,
+41,42,43,44,17,45,46,47,16,16,48,16,16,16,16,16,16,16,49,50,51,16,52,53,16,16,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,54,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,55,17,17,17,17,56,17,57,58,59,60,61,62,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,63,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,64,65,17,66,67,
+68,69,70,71,72,73,74,17,75,76,77,78,79,80,81,16,82,83,84,85,86,87,88,89,90,91,
+92,93,16,94,95,96,16,17,17,17,97,98,99,16,16,16,16,16,16,16,16,16,16,17,17,17,
+17,100,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,101,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,17,17,102,103,16,16,104,105,17,17,17,17,17,17,17,17,17,17,17,17,17,17,
+17,17,17,17,17,17,17,17,17,106,17,17,107,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,
+108,109,16,16,16,16,16,16,16,16,16,110,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,111,112,113,114,16,16,16,16,16,16,16,16,115,116,
+117,16,16,16,16,16,118,119,16,16,16,16,120,16,16,121,16,16,16,16,16,16,16,16,
+16,16,16,16,16,
+16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,254,255,255,7,254,
+255,255,7,0,0,0,0,0,4,32,4,255,255,127,255,255,255,127,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,195,255,3,0,31,80,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,223,188,64,215,255,255,
+251,255,255,255,255,255,255,255,255,255,191,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,3,252,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,254,255,255,255,127,2,255,255,255,
+255,255,1,0,0,0,0,255,191,182,0,255,255,255,135,7,0,0,0,255,7,255,255,255,255,
+255,255,255,254,255,195,255,255,255,255,255,255,255,255,255,255,255,255,239,
+31,254,225,255,
+159,0,0,255,255,255,255,255,255,0,224,255,255,255,255,255,255,255,255,255,255,
+255,255,3,0,255,255,255,255,255,7,48,4,255,255,255,252,255,31,0,0,255,255,255,
+1,255,7,0,0,0,0,0,0,255,255,223,63,0,0,240,255,248,3,255,255,255,255,255,255,
+255,255,255,239,255,223,225,255,207,255,254,255,239,159,249,255,255,253,197,
+227,159,89,128,176,207,255,3,16,238,135,249,255,255,253,109,195,135,25,2,94,
+192,255,63,0,238,191,251,255,255,253,237,227,191,27,1,0,207,255,0,30,238,159,
+249,255,255,253,237,227,159,25,192,176,207,255,2,0,236,199,61,214,24,199,255,
+195,199,29,129,0,192,255,0,0,239,223,253,255,255,253,255,227,223,29,96,7,207,
+255,0,0,239,223,253,255,255,253,239,227,223,29,96,64,207,255,6,0,239,223,253,
+255,255,255,255,231,223,93,240,128,207,255,0,252,236,255,127,252,255,255,251,
+47,127,128,95,255,192,255,12,0,254,255,255,255,255,127,255,7,63,32,255,3,0,0,
+0,0,214,247,255,255,175,255,255,59,95,32,255,243,0,0,0,
+0,1,0,0,0,255,3,0,0,255,254,255,255,255,31,254,255,3,255,255,254,255,255,255,
+31,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,249,255,3,255,255,255,255,255,
+255,255,255,255,63,255,255,255,255,191,32,255,255,255,255,255,247,255,255,255,
+255,255,255,255,255,255,61,127,61,255,255,255,255,255,61,255,255,255,255,61,
+127,61,255,127,255,255,255,255,255,255,255,61,255,255,255,255,255,255,255,255,
+7,0,0,0,0,255,255,0,0,255,255,255,255,255,255,255,255,255,255,63,63,254,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,159,255,255,254,255,255,7,255,255,255,255,255,255,255,255,
+255,199,255,1,255,223,15,0,255,255,15,0,255,255,15,0,255,223,13,0,255,255,255,
+255,255,255,207,255,255,1,128,16,255,3,0,0,0,0,255,3,255,255,255,255,255,255,
+255,255,255,255,255,1,255,255,255,255,255,7,255,255,255,255,255,255,255,255,
+63,
+0,255,255,255,127,255,15,255,1,192,255,255,255,255,63,31,0,255,255,255,255,
+255,15,255,255,255,3,255,3,0,0,0,0,255,255,255,15,255,255,255,255,255,255,255,
+127,254,255,31,0,255,3,255,3,128,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,
+255,239,255,239,15,255,3,0,0,0,0,255,255,255,255,255,243,255,255,255,255,255,
+255,191,255,3,0,255,255,255,255,255,255,127,0,255,227,255,255,255,255,255,63,
+255,1,255,255,255,255,255,231,0,0,0,0,0,222,111,4,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,
+128,255,31,0,255,255,63,63,255,255,255,255,63,63,255,170,255,255,255,63,255,
+255,255,255,255,255,223,95,220,31,207,15,255,31,220,31,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,2,128,0,0,255,31,0,0,0,0,0,0,0,0,0,0,0,0,132,252,47,62,80,189,255,243,
+224,67,0,0,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,255,255,255,255,255,255,3,0,
+0,255,255,255,255,255,127,255,255,255,255,255,127,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,31,120,12,0,255,255,255,255,191,32,255,
+255,255,255,255,255,255,128,0,0,255,255,127,0,127,127,127,127,127,127,127,127,
+255,255,255,255,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,224,0,0,0,254,3,62,31,254,255,255,255,255,255,255,255,255,255,127,224,254,
+255,255,255,255,255,255,255,255,255,255,247,224,255,255,255,255,255,254,255,
+255,255,255,255,255,255,255,255,255,127,0,0,255,255,255,7,0,0,0,0,0,0,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,63,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,
+0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,
+0,0,0,0,0,0,255,255,255,255,255,63,255,31,255,255,255,15,0,0,255,255,255,255,
+255,127,240,143,255,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,
+0,128,255,252,255,255,255,255,255,255,255,255,255,255,255,255,249,255,255,255,
+255,255,255,124,0,0,0,0,0,128,255,191,255,255,255,255,0,0,0,255,255,255,255,
+255,255,15,0,255,255,255,255,255,255,255,255,47,0,255,3,0,0,252,232,255,255,
+255,255,255,7,255,255,255,255,7,0,255,255,255,31,255,255,255,255,255,255,247,
+255,0,128,255,3,255,255,255,127,255,255,255,255,255,255,127,0,255,63,255,3,
+255,255,127,252,255,255,255,255,255,255,255,127,5,0,0,56,255,255,60,0,126,126,
+126,0,127,127,255,255,255,255,255,247,255,0,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,7,255,3,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,15,0,255,255,127,248,255,255,255,255,
+255,
+15,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,255,255,
+255,255,255,255,255,255,255,255,3,0,0,0,0,127,0,248,224,255,253,127,95,219,
+255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,0,248,255,255,255,
+255,255,255,255,255,255,255,255,255,63,0,0,255,255,255,255,255,255,255,255,
+252,255,255,255,255,255,255,0,0,0,0,0,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,223,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,31,0,0,255,3,
+254,255,255,7,254,255,255,7,192,255,255,255,255,255,255,255,255,255,255,127,
+252,252,252,28,0,0,0,0,255,239,255,255,127,255,255,183,255,63,255,63,0,0,0,0,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,7,0,0,0,0,0,0,0,0,
+255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,255,255,255,31,255,255,255,255,255,255,1,0,0,0,0,
+0,255,255,255,255,0,224,255,255,255,7,255,255,255,255,255,7,255,255,255,63,
+255,255,255,255,15,255,62,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,63,255,3,255,255,255,255,15,255,255,255,
+255,15,255,255,255,255,255,0,255,255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,255,255,63,0,255,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,63,253,255,255,255,255,191,145,255,255,63,0,255,255,
+127,0,255,255,255,127,0,0,0,0,0,0,0,0,255,255,55,0,255,255,63,0,255,255,255,3,
+0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,192,0,0,0,0,0,0,0,0,111,240,239,
+254,255,255,63,0,0,0,0,0,255,255,255,31,255,255,255,31,0,0,0,0,255,254,255,
+255,31,0,0,0,255,255,255,255,255,255,63,0,255,255,63,0,255,255,7,0,255,255,3,
+0,0,0,0,0,0,0,0,0,0,0,0,
+0,255,255,255,255,255,255,255,255,255,1,0,0,0,0,0,0,255,255,255,255,255,255,7,
+0,255,255,255,255,255,255,7,0,255,255,255,255,255,0,255,3,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,31,128,0,255,255,63,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,255,255,127,0,255,255,255,255,255,255,255,255,63,0,0,0,
+192,255,0,0,252,255,255,255,255,255,255,1,0,0,255,255,255,1,255,3,255,255,255,
+255,255,255,199,255,112,0,255,255,255,255,71,0,255,255,255,255,255,255,255,
+255,30,0,255,23,0,0,0,0,255,255,251,255,255,255,159,64,0,0,0,0,0,0,0,0,127,
+189,255,191,255,1,255,255,255,255,255,255,255,1,255,3,239,159,249,255,255,253,
+237,227,159,25,129,224,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,
+255,255,255,255,255,187,7,255,131,0,0,0,0,255,255,255,255,255,255,255,255,179,
+0,255,3,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,63,127,0,0,0,63,0,0,
+0,0,255,255,255,255,255,255,255,127,17,0,255,3,0,0,0,0,255,255,255,255,255,
+255,63,1,255,3,0,0,0,0,0,0,255,255,255,231,255,7,255,3,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,
+0,255,255,255,255,255,255,255,255,255,3,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,255,252,255,255,255,255,255,252,26,0,0,0,255,255,255,255,255,255,231,
+127,0,0,255,255,255,255,255,255,255,255,255,32,0,0,0,0,255,255,255,255,255,
+255,255,1,255,253,255,255,255,255,127,127,1,0,255,3,0,0,252,255,255,255,252,
+255,255,254,127,0,0,0,0,0,0,0,0,0,127,251,255,255,255,255,127,180,203,0,255,3,
+191,253,255,255,255,127,123,1,255,3,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,127,0,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,3,0,0,
+0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,127,0,
+0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
+255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
+255,255,255,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,
+255,255,255,255,255,255,1,255,255,255,127,255,3,0,0,0,0,0,0,0,0,0,0,0,0,255,
+255,255,63,0,0,255,255,255,255,255,255,0,0,15,0,255,3,248,255,255,224,255,255,
+0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,255,255,255,255,255,255,255,255,255,135,255,255,255,255,255,255,255,128,
+255,255,0,0,0,0,0,0,0,0,11,0,0,0,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,7,0,255,255,255,127,0,0,0,0,0,
+0,7,0,240,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,15,255,255,255,255,
+255,255,255,255,255,255,255,255,255,7,255,31,255,1,255,67,0,0,0,0,0,0,0,0,0,0,
+0,0,255,255,255,255,255,255,255,255,255,255,223,255,255,255,255,255,255,255,
+255,223,100,222,255,235,239,255,255,255,255,255,255,
+255,191,231,223,223,255,255,255,123,95,252,253,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,63,255,255,255,
+253,255,255,247,255,255,255,247,255,255,223,255,255,255,223,255,255,127,255,
+255,255,127,255,255,255,253,255,255,255,253,255,255,247,207,255,255,255,255,
+255,255,127,255,255,249,219,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,255,255,255,255,255,31,128,63,255,67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,
+15,255,3,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,31,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,
+143,8,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,239,255,255,255,150,254,247,10,132,234,150,170,150,247,247,94,255,251,255,
+15,238,251,255,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,3,255,255,255,3,255,
+255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
diff --git a/third_party/musl/asctime.c b/third_party/musl/asctime.c
new file mode 100644
index 000000000..7ba0e5581
--- /dev/null
+++ b/third_party/musl/asctime.c
@@ -0,0 +1,10 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/time.h"
+
+char *asctime(const struct tm *tm)
+{
+	static char buf[26];
+	return asctime_r(tm, buf);
+}
diff --git a/third_party/musl/asctime_r.c b/third_party/musl/asctime_r.c
new file mode 100644
index 000000000..6f62b1242
--- /dev/null
+++ b/third_party/musl/asctime_r.c
@@ -0,0 +1,52 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/stdio/stdio.h"
+#include "libc/str/langinfo.h"
+#include "libc/str/locale.internal.h"
+__static_yoink("musl_libc_notice");
+
+char *asctime_r(const struct tm *tm, char *buf)
+{
+	if (snprintf(buf, 26, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
+		nl_langinfo_l(ABDAY_1+tm->tm_wday, C_LOCALE),
+		nl_langinfo_l(ABMON_1+tm->tm_mon, C_LOCALE),
+		tm->tm_mday, tm->tm_hour,
+		tm->tm_min, tm->tm_sec,
+		1900 + tm->tm_year) >= 26)
+	{
+		/* ISO C requires us to use the above format string,
+		 * even if it will not fit in the buffer. Thus asctime_r
+		 * is _supposed_ to crash if the fields in tm are too large.
+		 * We follow this behavior and crash "gracefully" to warn
+		 * application developers that they may not be so lucky
+		 * on other implementations (e.g. stack smashing..).
+		 */
+		__builtin_trap();
+	}
+	return buf;
+}
diff --git a/third_party/musl/bsearch.c b/third_party/musl/bsearch.c
new file mode 100644
index 000000000..fe050ea30
--- /dev/null
+++ b/third_party/musl/bsearch.c
@@ -0,0 +1,20 @@
+#include <stdlib.h>
+
+void *bsearch(const void *key, const void *base, size_t nel, size_t width, int (*cmp)(const void *, const void *))
+{
+	void *try;
+	int sign;
+	while (nel > 0) {
+		try = (char *)base + width*(nel/2);
+		sign = cmp(key, try);
+		if (sign < 0) {
+			nel /= 2;
+		} else if (sign > 0) {
+			base = (char *)try + width;
+			nel -= nel/2+1;
+		} else {
+			return try;
+		}
+	}
+	return NULL;
+}
diff --git a/libc/str/btowc.c b/third_party/musl/btowc.c
similarity index 86%
rename from libc/str/btowc.c
rename to third_party/musl/btowc.c
index 4e3cb74ab..557146e94 100644
--- a/libc/str/btowc.c
+++ b/third_party/musl/btowc.c
@@ -1,5 +1,5 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
 ╚──────────────────────────────────────────────────────────────────────────────╝
 │                                                                              │
 │  Musl Libc                                                                   │
@@ -25,13 +25,14 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/limits.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
+#include <stdio.h>
+#include <wchar.h>
+#include <stdlib.h>
+#include "multibyte.h"
 __static_yoink("musl_libc_notice");
 
-wint_t btowc(int c) {
-  int b = (unsigned char)c;
-  return b < 128U ? b : (MB_CUR_MAX == 1 && c != EOF) ? CODEUNIT(c) : WEOF;
+wint_t btowc(int c)
+{
+	int b = (unsigned char)c;
+	return b<128U ? b : (MB_CUR_MAX==1 && c!=EOF) ? CODEUNIT(c) : WEOF;
 }
diff --git a/libc/str/c16rtomb.c b/third_party/musl/c16rtomb.c
similarity index 76%
rename from libc/str/c16rtomb.c
rename to third_party/musl/c16rtomb.c
index 546f40741..10fbcfa89 100644
--- a/libc/str/c16rtomb.c
+++ b/third_party/musl/c16rtomb.c
@@ -1,5 +1,5 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
 ╚──────────────────────────────────────────────────────────────────────────────╝
 │                                                                              │
 │  Musl Libc                                                                   │
@@ -25,40 +25,41 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
+#include <uchar.h>
+#include <errno.h>
+#include <wchar.h>
 __static_yoink("musl_libc_notice");
 
-size_t c16rtomb(char *restrict s, char16_t c16, mbstate_t *restrict ps) {
-  static unsigned internal_state;
-  if (!ps)
-    ps = (void *)&internal_state;
-  unsigned *x = (unsigned *)ps;
-  wchar_t wc;
-  if (!s) {
-    if (*x)
-      goto ilseq;
-    return 1;
-  }
-  if (!*x && c16 - 0xd800u < 0x400) {
-    *x = (c16 - 0xd7c0) << 10;
-    return 0;
-  }
-  if (*x) {
-    if (c16 - 0xdc00u >= 0x400)
-      goto ilseq;
-    else
-      wc = *x + c16 - 0xdc00;
-    *x = 0;
-  } else {
-    wc = c16;
-  }
-  return wcrtomb(s, wc, 0);
+#pragma GCC diagnostic ignored "-Wparentheses"
+
+size_t c16rtomb(char *restrict s, char16_t c16, mbstate_t *restrict ps)
+{
+	static unsigned internal_state;
+	if (!ps) ps = (void *)&internal_state;
+	unsigned *x = (unsigned *)ps;
+	wchar_t wc;
+
+	if (!s) {
+		if (*x) goto ilseq;
+		return 1;
+	}
+
+	if (!*x && c16 - 0xd800u < 0x400) {
+		*x = c16 - 0xd7c0 << 10;
+		return 0;
+	}
+
+	if (*x) {
+		if (c16 - 0xdc00u >= 0x400) goto ilseq;
+		else wc = *x + c16 - 0xdc00;
+		*x = 0;
+	} else {
+		wc = c16;
+	}
+	return wcrtomb(s, wc, 0);
+
 ilseq:
-  *x = 0;
-  errno = EILSEQ;
-  return -1;
+	*x = 0;
+	errno = EILSEQ;
+	return -1;
 }
diff --git a/third_party/musl/c32rtomb.c b/third_party/musl/c32rtomb.c
new file mode 100644
index 000000000..d23efca16
--- /dev/null
+++ b/third_party/musl/c32rtomb.c
@@ -0,0 +1,35 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <uchar.h>
+#include <wchar.h>
+__static_yoink("musl_libc_notice");
+
+size_t c32rtomb(char *restrict s, char32_t c32, mbstate_t *restrict ps)
+{
+	return wcrtomb(s, c32, ps);
+}
diff --git a/third_party/musl/casemap.inc b/third_party/musl/casemap.inc
new file mode 100644
index 000000000..6ee1209b9
--- /dev/null
+++ b/third_party/musl/casemap.inc
@@ -0,0 +1,297 @@
+static const unsigned char tab[] = {
+	7, 8, 9, 10, 11, 12, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	13, 6, 6, 14, 6, 6, 6, 6, 6, 6, 6, 6, 15, 16, 17, 18,
+	6, 19, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 20, 21, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 22, 23, 6, 6, 6, 24, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 25,
+	6, 6, 6, 6, 26, 6, 6, 6, 6, 6, 6, 6, 27, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 28, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 29, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 30, 6, 6, 6, 6, 6, 6,
+	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36,
+	43, 43, 43, 43, 43, 43, 43, 43, 1, 0, 84, 86, 86, 86, 86, 86,
+	86, 86, 86, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 43, 43, 43, 43, 43, 43,
+	43, 7, 43, 43, 91, 86, 86, 86, 86, 86, 86, 86, 74, 86, 86, 5,
+	49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80,
+	36, 80, 121, 49, 80, 49, 80, 49, 56, 80, 49, 80, 49, 80, 49, 80,
+	49, 80, 49, 80, 49, 80, 49, 80, 78, 49, 2, 78, 13, 13, 78, 3,
+	78, 0, 36, 110, 0, 78, 49, 38, 110, 81, 78, 36, 80, 78, 57, 20,
+	129, 27, 29, 29, 83, 49, 80, 49, 80, 13, 49, 80, 49, 80, 49, 80,
+	27, 83, 36, 80, 49, 2, 92, 123, 92, 123, 92, 123, 92, 123, 92, 123,
+	20, 121, 92, 123, 92, 123, 92, 45, 43, 73, 3, 72, 3, 120, 92, 123,
+	20, 0, 150, 10, 1, 43, 40, 6, 6, 0, 42, 6, 42, 42, 43, 7,
+	187, 181, 43, 30, 0, 43, 7, 43, 43, 43, 1, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 1, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 42, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 205, 70, 205, 43, 0, 37, 43, 7, 1, 6, 1, 85, 86, 86, 86,
+	86, 86, 85, 86, 86, 2, 36, 129, 129, 129, 129, 129, 21, 129, 129, 129,
+	0, 0, 43, 0, 178, 209, 178, 209, 178, 209, 178, 209, 0, 0, 205, 204,
+	1, 0, 215, 215, 215, 215, 215, 131, 129, 129, 129, 129, 129, 129, 129, 129,
+	129, 129, 172, 172, 172, 172, 172, 172, 172, 172, 172, 172, 28, 0, 0, 0,
+	0, 0, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 2, 0, 0,
+	49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80,
+	49, 80, 78, 49, 80, 49, 80, 78, 49, 80, 49, 80, 49, 80, 49, 80,
+	49, 80, 49, 80, 49, 80, 49, 2, 135, 166, 135, 166, 135, 166, 135, 166,
+	135, 166, 135, 166, 135, 166, 135, 166, 42, 43, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 0, 0, 0, 84, 86, 86, 86, 86, 86, 86, 86,
+	86, 86, 86, 86, 86, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 84, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
+	12, 0, 12, 42, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 7, 42, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 86, 86, 108, 129, 21, 0, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 7, 108, 3, 65, 43, 43, 86, 86, 86, 86, 86, 86,
+	86, 86, 86, 86, 86, 86, 86, 86, 44, 86, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 1,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 12, 108, 0, 0, 0, 0, 0, 6,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 6, 37, 6, 37, 6, 37, 6, 37, 6, 37,
+	6, 37, 6, 37, 6, 37, 6, 37, 6, 37, 6, 37, 6, 37, 6, 37,
+	6, 37, 6, 37, 6, 37, 6, 37, 6, 37, 6, 37, 6, 37, 6, 37,
+	6, 37, 6, 37, 6, 37, 6, 37, 86, 122, 158, 38, 6, 37, 6, 37,
+	6, 37, 6, 37, 6, 37, 6, 37, 6, 37, 6, 37, 6, 37, 6, 37,
+	6, 37, 6, 37, 6, 37, 6, 37, 6, 37, 6, 1, 43, 43, 79, 86,
+	86, 44, 43, 127, 86, 86, 57, 43, 43, 85, 86, 86, 43, 43, 79, 86,
+	86, 44, 43, 127, 86, 86, 129, 55, 117, 91, 123, 92, 43, 43, 79, 86,
+	86, 2, 172, 4, 0, 0, 57, 43, 43, 85, 86, 86, 43, 43, 79, 86,
+	86, 44, 43, 43, 86, 86, 50, 19, 129, 87, 0, 111, 129, 126, 201, 215,
+	126, 45, 129, 129, 14, 126, 57, 127, 111, 87, 0, 129, 129, 126, 21, 0,
+	126, 3, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 7, 43,
+	36, 43, 151, 43, 43, 43, 43, 43, 43, 43, 43, 43, 42, 43, 43, 43,
+	43, 43, 86, 86, 86, 86, 86, 128, 129, 129, 129, 129, 57, 187, 42, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 1, 129, 129, 129, 129, 129, 129, 129, 129,
+	129, 129, 129, 129, 129, 129, 129, 201, 172, 172, 172, 172, 172, 172, 172, 172,
+	172, 172, 172, 172, 172, 172, 172, 208, 13, 0, 78, 49, 2, 180, 193, 193,
+	215, 215, 36, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80,
+	49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80, 49, 80,
+	49, 80, 49, 80, 215, 215, 83, 193, 71, 212, 215, 215, 215, 5, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 7, 1, 0, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 78, 49, 80, 49, 80, 49, 80,
+	49, 80, 49, 80, 49, 80, 49, 80, 13, 0, 0, 0, 0, 0, 36, 80,
+	49, 80, 49, 80, 49, 80, 49, 80, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 121, 92, 123, 92, 123, 79, 123, 92, 123, 92, 123,
+	92, 123, 92, 123, 92, 123, 92, 123, 92, 123, 92, 123, 92, 123, 92, 45,
+	43, 43, 121, 20, 92, 123, 92, 45, 121, 42, 92, 39, 92, 123, 92, 123,
+	92, 123, 164, 0, 10, 180, 92, 123, 92, 123, 79, 3, 42, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 1,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 72, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 42, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 43, 43, 43, 43, 43, 43, 43, 43, 7, 0, 72, 86, 86, 86, 86,
+	86, 86, 86, 86, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 85, 86, 86, 86, 86, 86, 86,
+	86, 86, 86, 86, 86, 86, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 36, 43, 43, 43, 43, 43, 43, 43, 43, 43,
+	43, 43, 7, 0, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 36, 43, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 7, 0, 0,
+	0, 0, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
+	86, 86, 86, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 43, 43,
+	43, 43, 43, 43, 43, 43, 43, 43, 86, 86, 86, 86, 86, 86, 86, 86,
+	86, 86, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 42, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 86, 86,
+	86, 86, 86, 86, 86, 86, 86, 86, 14, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 85,
+	86, 86, 86, 86, 86, 86, 86, 86, 86, 86, 14, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+static const int rules[] = {
+	0x0, 0x2001, -0x2000, 0x1dbf00, 0x2e700, 0x7900,
+	0x2402, 0x101, -0x100, 0x0, 0x201, -0x200,
+	-0xc6ff, -0xe800, -0x78ff, -0x12c00, 0xc300, 0xd201,
+	0xce01, 0xcd01, 0x4f01, 0xca01, 0xcb01, 0xcf01,
+	0x6100, 0xd301, 0xd101, 0xa300, 0xd501, 0x8200,
+	0xd601, 0xda01, 0xd901, 0xdb01, 0x3800, 0x3,
+	-0x4f00, -0x60ff, -0x37ff, 0x242802, 0x0, 0x101,
+	-0x100, -0xcd00, -0xda00, -0x81ff, 0x2a2b01, -0xa2ff,
+	0x2a2801, 0x2a3f00, -0xc2ff, 0x4501, 0x4701, 0x2a1f00,
+	0x2a1c00, 0x2a1e00, -0xd200, -0xce00, -0xca00, -0xcb00,
+	0xa54f00, 0xa54b00, -0xcf00, 0xa52800, 0xa54400, -0xd100,
+	-0xd300, 0x29f700, 0xa54100, 0x29fd00, -0xd500, -0xd600,
+	0x29e700, 0xa54300, 0xa52a00, -0x4500, -0xd900, -0x4700,
+	-0xdb00, 0xa51500, 0xa51200, 0x4c2402, 0x0, 0x2001,
+	-0x2000, 0x101, -0x100, 0x5400, 0x7401, 0x2601,
+	0x2501, 0x4001, 0x3f01, -0x2600, -0x2500, -0x1f00,
+	-0x4000, -0x3f00, 0x801, -0x3e00, -0x3900, -0x2f00,
+	-0x3600, -0x800, -0x5600, -0x5000, 0x700, -0x7400,
+	-0x3bff, -0x6000, -0x6ff, 0x701a02, 0x101, -0x100,
+	0x2001, -0x2000, 0x5001, 0xf01, -0xf00, 0x0,
+	0x3001, -0x3000, 0x101, -0x100, 0x0, 0xbc000,
+	0x1c6001, 0x0, 0x97d001, 0x801, -0x800, 0x8a0502,
+	0x0, -0xbbfff, -0x186200, 0x89c200, -0x182500, -0x186e00,
+	-0x186d00, -0x186400, -0x186300, -0x185c00, 0x0, 0x8a3800,
+	0x8a0400, 0xee600, 0x101, -0x100, 0x0, -0x3b00,
+	-0x1dbeff, 0x8f1d02, 0x800, -0x7ff, 0x0, 0x5600,
+	-0x55ff, 0x4a00, 0x6400, 0x8000, 0x7000, 0x7e00,
+	0x900, -0x49ff, -0x8ff, -0x1c2500, -0x63ff, -0x6fff,
+	-0x7fff, -0x7dff, 0xac0502, 0x0, 0x1001, -0x1000,
+	0x1c01, 0x101, -0x1d5cff, -0x20beff, -0x2045ff, -0x1c00,
+	0xb10b02, 0x101, -0x100, 0x3001, -0x3000, 0x0,
+	-0x29f6ff, -0xee5ff, -0x29e6ff, -0x2a2b00, -0x2a2800, -0x2a1bff,
+	-0x29fcff, -0x2a1eff, -0x2a1dff, -0x2a3eff, 0x0, -0x1c6000,
+	0x0, 0x101, -0x100, 0xbc0c02, 0x0, 0x101,
+	-0x100, -0xa543ff, 0x3a001, -0x8a03ff, -0xa527ff, 0x3000,
+	-0xa54eff, -0xa54aff, -0xa540ff, -0xa511ff, -0xa529ff, -0xa514ff,
+	-0x2fff, -0xa542ff, -0x8a37ff, 0x0, -0x97d000, -0x3a000,
+	0x0, 0x2001, -0x2000, 0x0, 0x2801, -0x2800,
+	0x0, 0x4001, -0x4000, 0x0, 0x2001, -0x2000,
+	0x0, 0x2001, -0x2000, 0x0, 0x2201, -0x2200,
+};
+static const unsigned char rulebases[] = {
+	0, 6, 39, 81, 111, 119, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	124, 0, 0, 127, 0, 0, 0, 0, 0, 0, 0, 0, 131, 142, 146, 151,
+	0, 170, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 180, 196, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 198, 201, 0, 0, 0, 219, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 222,
+	0, 0, 0, 0, 225, 0, 0, 0, 0, 0, 0, 0, 228, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 231, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 234, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 237, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+static const unsigned char exceptions[][2] = {
+	{ 48, 12 }, { 49, 13 }, { 120, 14 }, { 127, 15 },
+	{ 128, 16 }, { 129, 17 }, { 134, 18 }, { 137, 19 },
+	{ 138, 19 }, { 142, 20 }, { 143, 21 }, { 144, 22 },
+	{ 147, 19 }, { 148, 23 }, { 149, 24 }, { 150, 25 },
+	{ 151, 26 }, { 154, 27 }, { 156, 25 }, { 157, 28 },
+	{ 158, 29 }, { 159, 30 }, { 166, 31 }, { 169, 31 },
+	{ 174, 31 }, { 177, 32 }, { 178, 32 }, { 183, 33 },
+	{ 191, 34 }, { 197, 35 }, { 200, 35 }, { 203, 35 },
+	{ 221, 36 }, { 242, 35 }, { 246, 37 }, { 247, 38 },
+	{ 32, 45 }, { 58, 46 }, { 61, 47 }, { 62, 48 },
+	{ 63, 49 }, { 64, 49 }, { 67, 50 }, { 68, 51 },
+	{ 69, 52 }, { 80, 53 }, { 81, 54 }, { 82, 55 },
+	{ 83, 56 }, { 84, 57 }, { 89, 58 }, { 91, 59 },
+	{ 92, 60 }, { 97, 61 }, { 99, 62 }, { 101, 63 },
+	{ 102, 64 }, { 104, 65 }, { 105, 66 }, { 106, 64 },
+	{ 107, 67 }, { 108, 68 }, { 111, 66 }, { 113, 69 },
+	{ 114, 70 }, { 117, 71 }, { 125, 72 }, { 130, 73 },
+	{ 135, 74 }, { 137, 75 }, { 138, 76 }, { 139, 76 },
+	{ 140, 77 }, { 146, 78 }, { 157, 79 }, { 158, 80 },
+	{ 69, 87 }, { 123, 29 }, { 124, 29 }, { 125, 29 },
+	{ 127, 88 }, { 134, 89 }, { 136, 90 }, { 137, 90 },
+	{ 138, 90 }, { 140, 91 }, { 142, 92 }, { 143, 92 },
+	{ 172, 93 }, { 173, 94 }, { 174, 94 }, { 175, 94 },
+	{ 194, 95 }, { 204, 96 }, { 205, 97 }, { 206, 97 },
+	{ 207, 98 }, { 208, 99 }, { 209, 100 }, { 213, 101 },
+	{ 214, 102 }, { 215, 103 }, { 240, 104 }, { 241, 105 },
+	{ 242, 106 }, { 243, 107 }, { 244, 108 }, { 245, 109 },
+	{ 249, 110 }, { 253, 45 }, { 254, 45 }, { 255, 45 },
+	{ 80, 105 }, { 81, 105 }, { 82, 105 }, { 83, 105 },
+	{ 84, 105 }, { 85, 105 }, { 86, 105 }, { 87, 105 },
+	{ 88, 105 }, { 89, 105 }, { 90, 105 }, { 91, 105 },
+	{ 92, 105 }, { 93, 105 }, { 94, 105 }, { 95, 105 },
+	{ 130, 0 }, { 131, 0 }, { 132, 0 }, { 133, 0 },
+	{ 134, 0 }, { 135, 0 }, { 136, 0 }, { 137, 0 },
+	{ 192, 117 }, { 207, 118 }, { 128, 137 }, { 129, 138 },
+	{ 130, 139 }, { 133, 140 }, { 134, 141 }, { 112, 157 },
+	{ 113, 157 }, { 118, 158 }, { 119, 158 }, { 120, 159 },
+	{ 121, 159 }, { 122, 160 }, { 123, 160 }, { 124, 161 },
+	{ 125, 161 }, { 179, 162 }, { 186, 163 }, { 187, 163 },
+	{ 188, 164 }, { 190, 165 }, { 195, 162 }, { 204, 164 },
+	{ 218, 166 }, { 219, 166 }, { 229, 106 }, { 234, 167 },
+	{ 235, 167 }, { 236, 110 }, { 243, 162 }, { 248, 168 },
+	{ 249, 168 }, { 250, 169 }, { 251, 169 }, { 252, 164 },
+	{ 38, 176 }, { 42, 177 }, { 43, 178 }, { 78, 179 },
+	{ 132, 8 }, { 98, 186 }, { 99, 187 }, { 100, 188 },
+	{ 101, 189 }, { 102, 190 }, { 109, 191 }, { 110, 192 },
+	{ 111, 193 }, { 112, 194 }, { 126, 195 }, { 127, 195 },
+	{ 125, 207 }, { 141, 208 }, { 148, 209 }, { 171, 210 },
+	{ 172, 211 }, { 173, 212 }, { 176, 213 }, { 177, 214 },
+	{ 178, 215 }, { 196, 216 }, { 197, 217 }, { 198, 218 },
+};
diff --git a/third_party/musl/catclose.c b/third_party/musl/catclose.c
index f3f3b73f1..76140f687 100644
--- a/third_party/musl/catclose.c
+++ b/third_party/musl/catclose.c
@@ -30,6 +30,7 @@
 #include <stdint.h>
 #include <endian.h>
 #include <sys/mman.h>
+__static_yoink("musl_libc_notice");
 
 #define V(p) be32toh(*(uint32_t *)(p))
 
diff --git a/third_party/musl/catgets.c b/third_party/musl/catgets.c
index 8921ffc4c..cca0b16e8 100644
--- a/third_party/musl/catgets.c
+++ b/third_party/musl/catgets.c
@@ -31,6 +31,7 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <errno.h>
+__static_yoink("musl_libc_notice");
 
 #define V(p) be32toh(*(uint32_t *)(p))
 
diff --git a/third_party/musl/catopen.c b/third_party/musl/catopen.c
index 8bcaff432..fcc09b126 100644
--- a/third_party/musl/catopen.c
+++ b/third_party/musl/catopen.c
@@ -35,6 +35,7 @@
 #include <locale.h>
 #include "third_party/musl/mapfile.internal.h"
 #include <sys/mman.h>
+__static_yoink("musl_libc_notice");
 
 #define V(p) be32toh(*(uint32_t *)(p))
 
diff --git a/third_party/musl/crypt_sha256.c b/third_party/musl/crypt_sha256.c
index d5e2f8059..57d311911 100644
--- a/third_party/musl/crypt_sha256.c
+++ b/third_party/musl/crypt_sha256.c
@@ -39,6 +39,7 @@
 #include "libc/str/str.h"
 #include "libc/sysv/consts/exit.h"
 #include "third_party/gdtoa/gdtoa.h"
+#include "libc/ctype.h"
 #include "third_party/musl/crypt.internal.h"
 __static_yoink("musl_libc_notice");
 
diff --git a/third_party/musl/crypt_sha512.c b/third_party/musl/crypt_sha512.c
index 7d3b4414b..a0e8bcc1a 100644
--- a/third_party/musl/crypt_sha512.c
+++ b/third_party/musl/crypt_sha512.c
@@ -39,6 +39,7 @@
 #include "libc/str/str.h"
 #include "libc/sysv/consts/exit.h"
 #include "third_party/gdtoa/gdtoa.h"
+#include "libc/ctype.h"
 #include "third_party/musl/crypt.internal.h"
 __static_yoink("musl_libc_notice");
 
diff --git a/third_party/tz/ctime.c b/third_party/musl/ctime.c
similarity index 100%
rename from third_party/tz/ctime.c
rename to third_party/musl/ctime.c
diff --git a/third_party/tz/ctime_r.c b/third_party/musl/ctime_r.c
similarity index 100%
rename from third_party/tz/ctime_r.c
rename to third_party/musl/ctime_r.c
diff --git a/third_party/musl/duplocale.c b/third_party/musl/duplocale.c
new file mode 100644
index 000000000..7633f6e4b
--- /dev/null
+++ b/third_party/musl/duplocale.c
@@ -0,0 +1,45 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/runtime/runtime.h"
+#include "libc/str/locale.internal.h"
+#include "libc/str/str.h"
+__static_yoink("musl_libc_notice");
+
+#define malloc _mapanon
+#define calloc undef
+#define realloc undef
+#define free undef
+
+locale_t duplocale(locale_t old)
+{
+	locale_t new = malloc(sizeof *new);
+	if (!new) return 0;
+	if (old == LC_GLOBAL_LOCALE) old = &__global_locale;
+	*new = *old;
+	return new;
+}
diff --git a/third_party/musl/fnmatch.c b/third_party/musl/fnmatch.c
index d2f32e259..e48d7b998 100644
--- a/third_party/musl/fnmatch.c
+++ b/third_party/musl/fnmatch.c
@@ -25,9 +25,12 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/limits.h"
-#include "libc/str/str.h"
-#include "third_party/musl/fnmatch.h"
+#include <string.h>
+#include <fnmatch.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <wctype.h>
+#include "libc/str/locale.internal.h"
 __static_yoink("musl_libc_notice");
 
 /*
@@ -45,284 +48,279 @@ __static_yoink("musl_libc_notice");
  * - Rich Felker, April 2012
  */
 
-#define END         0
+#define END 0
 #define UNMATCHABLE -2
-#define BRACKET     -3
-#define QUESTION    -4
-#define STAR        -5
+#define BRACKET -3
+#define QUESTION -4
+#define STAR -5
 
-static int FnmatchNextString(const char *str, size_t n, size_t *step) {
-  if (!n) {
-    *step = 0;
-    return 0;
-  }
-  if (str[0] >= 128U) {
-    wchar_t wc;
-    int k = mbtowc(&wc, str, n);
-    if (k < 0) {
-      *step = 1;
-      return -1;
-    }
-    *step = k;
-    return wc;
-  }
-  *step = 1;
-  return str[0];
+static int str_next(const char *str, size_t n, size_t *step)
+{
+	if (!n) {
+		*step = 0;
+		return 0;
+	}
+	if (str[0] >= 128U) {
+		wchar_t wc;
+		int k = mbtowc(&wc, str, n);
+		if (k<0) {
+			*step = 1;
+			return -1;
+		}
+		*step = k;
+		return wc;
+	}
+	*step = 1;
+	return str[0];
 }
 
-static int FnmatchNextPattern(const char *pat, size_t m, size_t *step,
-                              int flags) {
-  int esc = 0;
-  if (!m || !*pat) {
-    *step = 0;
-    return END;
-  }
-  *step = 1;
-  if (pat[0] == '\\' && pat[1] && !(flags & FNM_NOESCAPE)) {
-    *step = 2;
-    pat++;
-    esc = 1;
-    goto escaped;
-  }
-  if (pat[0] == '[') {
-    size_t k = 1;
-    if (k < m)
-      if (pat[k] == '^' || pat[k] == '!') k++;
-    if (k < m)
-      if (pat[k] == ']') k++;
-    for (; k < m && pat[k] && pat[k] != ']'; k++) {
-      if (k + 1 < m && pat[k + 1] && pat[k] == '[' &&
-          (pat[k + 1] == ':' || pat[k + 1] == '.' || pat[k + 1] == '=')) {
-        int z = pat[k + 1];
-        k += 2;
-        if (k < m && pat[k]) k++;
-        while (k < m && pat[k] && (pat[k - 1] != z || pat[k] != ']')) k++;
-        if (k == m || !pat[k]) break;
-      }
-    }
-    if (k == m || !pat[k]) {
-      *step = 1;
-      return '[';
-    }
-    *step = k + 1;
-    return BRACKET;
-  }
-  if (pat[0] == '*') return STAR;
-  if (pat[0] == '?') return QUESTION;
+static int pat_next(const char *pat, size_t m, size_t *step, int flags)
+{
+	int esc = 0;
+	if (!m || !*pat) {
+		*step = 0;
+		return END;
+	}
+	*step = 1;
+	if (pat[0]=='\\' && pat[1] && !(flags & FNM_NOESCAPE)) {
+		*step = 2;
+		pat++;
+		esc = 1;
+		goto escaped;
+	}
+	if (pat[0]=='[') {
+		size_t k = 1;
+		if (k<m) if (pat[k] == '^' || pat[k] == '!') k++;
+		if (k<m) if (pat[k] == ']') k++;
+		for (; k<m && pat[k] && pat[k]!=']'; k++) {
+			if (k+1<m && pat[k+1] && pat[k]=='[' && (pat[k+1]==':' || pat[k+1]=='.' || pat[k+1]=='=')) {
+				int z = pat[k+1];
+				k+=2;
+				if (k<m && pat[k]) k++;
+				while (k<m && pat[k] && (pat[k-1]!=z || pat[k]!=']')) k++;
+				if (k==m || !pat[k]) break;
+			}
+		}
+		if (k==m || !pat[k]) {
+			*step = 1;
+			return '[';
+		}
+		*step = k+1;
+		return BRACKET;
+	}
+	if (pat[0] == '*')
+		return STAR;
+	if (pat[0] == '?')
+		return QUESTION;
 escaped:
-  if (pat[0] >= 128U) {
-    wchar_t wc;
-    int k = mbtowc(&wc, pat, m);
-    if (k < 0) {
-      *step = 0;
-      return UNMATCHABLE;
-    }
-    *step = k + esc;
-    return wc;
-  }
-  return pat[0];
+	if (pat[0] >= 128U) {
+		wchar_t wc;
+		int k = mbtowc(&wc, pat, m);
+		if (k<0) {
+			*step = 0;
+			return UNMATCHABLE;
+		}
+		*step = k + esc;
+		return wc;
+	}
+	return pat[0];
 }
 
-static int FnmatchCaseFold(int k) {
-  int c = towupper(k);
-  return c == k ? towlower(k) : c;
+static int casefold(int k)
+{
+	int c = towupper(k);
+	return c == k ? towlower(k) : c;
 }
 
-static int FnmatchBracket(const char *p, int k, int kfold) {
-  wchar_t wc;
-  int inv = 0;
-  p++;
-  if (*p == '^' || *p == '!') {
-    inv = 1;
-    p++;
-  }
-  if (*p == ']') {
-    if (k == ']') return !inv;
-    p++;
-  } else if (*p == '-') {
-    if (k == '-') return !inv;
-    p++;
-  }
-  wc = p[-1];
-  for (; *p != ']'; p++) {
-    if (p[0] == '-' && p[1] != ']') {
-      wchar_t wc2;
-      int l = mbtowc(&wc2, p + 1, 4);
-      if (l < 0) return 0;
-      if (wc <= wc2)
-        if ((unsigned)k - wc <= wc2 - wc || (unsigned)kfold - wc <= wc2 - wc)
-          return !inv;
-      p += l - 1;
-      continue;
-    }
-    if (p[0] == '[' && (p[1] == ':' || p[1] == '.' || p[1] == '=')) {
-      const char *p0 = p + 2;
-      int z = p[1];
-      p += 3;
-      while (p[-1] != z || p[0] != ']') p++;
-      if (z == ':' && p - 1 - p0 < 16) {
-        char buf[16];
-        memcpy(buf, p0, p - 1 - p0);
-        buf[p - 1 - p0] = 0;
-        if (iswctype(k, wctype(buf)) || iswctype(kfold, wctype(buf)))
-          return !inv;
-      }
-      continue;
-    }
-    if (*p < 128U) {
-      wc = (unsigned char)*p;
-    } else {
-      int l = mbtowc(&wc, p, 4);
-      if (l < 0) return 0;
-      p += l - 1;
-    }
-    if (wc == k || wc == kfold) return !inv;
-  }
-  return inv;
+static int match_bracket(const char *p, int k, int kfold)
+{
+	wchar_t wc;
+	int inv = 0;
+	p++;
+	if (*p=='^' || *p=='!') {
+		inv = 1;
+		p++;
+	}
+	if (*p==']') {
+		if (k==']') return !inv;
+		p++;
+	} else if (*p=='-') {
+		if (k=='-') return !inv;
+		p++;
+	}
+	wc = p[-1];
+	for (; *p != ']'; p++) {
+		if (p[0]=='-' && p[1]!=']') {
+			wchar_t wc2;
+			int l = mbtowc(&wc2, p+1, 4);
+			if (l < 0) return 0;
+			if (wc <= wc2)
+				if ((unsigned)k-wc <= wc2-wc ||
+				    (unsigned)kfold-wc <= wc2-wc)
+					return !inv;
+			p += l-1;
+			continue;
+		}
+		if (p[0]=='[' && (p[1]==':' || p[1]=='.' || p[1]=='=')) {
+			const char *p0 = p+2;
+			int z = p[1];
+			p+=3;
+			while (p[-1]!=z || p[0]!=']') p++;
+			if (z == ':' && p-1-p0 < 16) {
+				char buf[16];
+				memcpy(buf, p0, p-1-p0);
+				buf[p-1-p0] = 0;
+				if (iswctype(k, wctype(buf)) ||
+				    iswctype(kfold, wctype(buf)))
+					return !inv;
+			}
+			continue;
+		}
+		if (*p < 128U) {
+			wc = (unsigned char)*p;
+		} else {
+			int l = mbtowc(&wc, p, 4);
+			if (l < 0) return 0;
+			p += l-1;
+		}
+		if (wc==k || wc==kfold) return !inv;
+	}
+	return inv;
 }
 
-static int FnmatchPerform(const char *pat, size_t m, const char *str, size_t n,
-                          int flags) {
-  const char *p, *ptail, *endpat;
-  const char *s, *stail, *endstr;
-  size_t pinc, sinc, tailcnt = 0;
-  int c, k, kfold;
+static int fnmatch_internal(const char *pat, size_t m, const char *str, size_t n, int flags)
+{
+	const char *p, *ptail, *endpat;
+	const char *s, *stail, *endstr;
+	size_t pinc, sinc, tailcnt=0;
+	int c, k, kfold;
 
-  if (flags & FNM_PERIOD) {
-    if (*str == '.' && *pat != '.') {
-      return FNM_NOMATCH;
-    }
-  }
+	if (flags & FNM_PERIOD) {
+		if (*str == '.' && *pat != '.')
+			return FNM_NOMATCH;
+	}
+	for (;;) {
+		switch ((c = pat_next(pat, m, &pinc, flags))) {
+		case UNMATCHABLE:
+			return FNM_NOMATCH;
+		case STAR:
+			pat++;
+			m--;
+			break;
+		default:
+			k = str_next(str, n, &sinc);
+			if (k <= 0)
+				return (c==END) ? 0 : FNM_NOMATCH;
+			str += sinc;
+			n -= sinc;
+			kfold = flags & FNM_CASEFOLD ? casefold(k) : k;
+			if (c == BRACKET) {
+				if (!match_bracket(pat, k, kfold))
+					return FNM_NOMATCH;
+			} else if (c != QUESTION && k != c && kfold != c) {
+				return FNM_NOMATCH;
+			}
+			pat+=pinc;
+			m-=pinc;
+			continue;
+		}
+		break;
+	}
 
-  for (;;) {
-    switch ((c = FnmatchNextPattern(pat, m, &pinc, flags))) {
-      case UNMATCHABLE:
-        return FNM_NOMATCH;
-      case STAR:
-        pat++;
-        m--;
-        break;
-      default:
-        k = FnmatchNextString(str, n, &sinc);
-        if (k <= 0) return (c == END) ? 0 : FNM_NOMATCH;
-        str += sinc;
-        n -= sinc;
-        kfold = flags & FNM_CASEFOLD ? FnmatchCaseFold(k) : k;
-        if (c == BRACKET) {
-          if (!FnmatchBracket(pat, k, kfold)) return FNM_NOMATCH;
-        } else if (c != QUESTION && k != c && kfold != c) {
-          return FNM_NOMATCH;
-        }
-        pat += pinc;
-        m -= pinc;
-        continue;
-    }
-    break;
-  }
+	/* Compute real pat length if it was initially unknown/-1 */
+	m = strnlen(pat, m);
+	endpat = pat + m;
 
-  /* Compute real pat length if it was initially unknown/-1 */
-  m = strnlen(pat, m);
-  endpat = pat + m;
+	/* Find the last * in pat and count chars needed after it */
+	for (p=ptail=pat; p<endpat; p+=pinc) {
+		switch (pat_next(p, endpat-p, &pinc, flags)) {
+		case UNMATCHABLE:
+			return FNM_NOMATCH;
+		case STAR:
+			tailcnt=0;
+			ptail = p+1;
+			break;
+		default:
+			tailcnt++;
+			break;
+		}
+	}
 
-  /* Find the last * in pat and count chars needed after it */
-  for (p = ptail = pat; p < endpat; p += pinc) {
-    switch (FnmatchNextPattern(p, endpat - p, &pinc, flags)) {
-      case UNMATCHABLE:
-        return FNM_NOMATCH;
-      case STAR:
-        tailcnt = 0;
-        ptail = p + 1;
-        break;
-      default:
-        tailcnt++;
-        break;
-    }
-  }
+	/* Past this point we need not check for UNMATCHABLE in pat,
+	 * because all of pat has already been parsed once. */
 
-  /* Past this point we need not check for UNMATCHABLE in pat,
-   * because all of pat has already been parsed once. */
+	/* Compute real str length if it was initially unknown/-1 */
+	n = strnlen(str, n);
+	endstr = str + n;
+	if (n < tailcnt) return FNM_NOMATCH;
 
-  /* Compute real str length if it was initially unknown/-1 */
-  n = strnlen(str, n);
-  endstr = str + n;
-  if (n < tailcnt) {
-    return FNM_NOMATCH;
-  }
+	/* Find the final tailcnt chars of str, accounting for UTF-8.
+	 * On illegal sequences we may get it wrong, but in that case
+	 * we necessarily have a matching failure anyway. */
+	for (s=endstr; s>str && tailcnt; tailcnt--) {
+		if (s[-1] < 128U || MB_CUR_MAX==1) s--;
+		else while ((unsigned char)*--s-0x80U<0x40 && s>str);
+	}
+	if (tailcnt) return FNM_NOMATCH;
+	stail = s;
 
-  /* Find the final tailcnt chars of str, accounting for UTF-8.
-   * On illegal sequences we may get it wrong, but in that case
-   * we necessarily have a matching failure anyway. */
-  for (s = endstr; s > str && tailcnt; tailcnt--) {
-    if (s[-1] < 128U || MB_CUR_MAX == 1) {
-      s--;
-    } else {
-      while ((unsigned char)*--s - 0x80U < 0x40 && s > str)
-        ;
-    }
-  }
-  if (tailcnt) return FNM_NOMATCH;
-  stail = s;
+	/* Check that the pat and str tails match */
+	p = ptail;
+	for (;;) {
+		c = pat_next(p, endpat-p, &pinc, flags);
+		p += pinc;
+		if ((k = str_next(s, endstr-s, &sinc)) <= 0) {
+			if (c != END) return FNM_NOMATCH;
+			break;
+		}
+		s += sinc;
+		kfold = flags & FNM_CASEFOLD ? casefold(k) : k;
+		if (c == BRACKET) {
+			if (!match_bracket(p-pinc, k, kfold))
+				return FNM_NOMATCH;
+		} else if (c != QUESTION && k != c && kfold != c) {
+			return FNM_NOMATCH;
+		}
+	}
 
-  /* Check that the pat and str tails match */
-  p = ptail;
-  for (;;) {
-    c = FnmatchNextPattern(p, endpat - p, &pinc, flags);
-    p += pinc;
-    if ((k = FnmatchNextString(s, endstr - s, &sinc)) <= 0) {
-      if (c != END) return FNM_NOMATCH;
-      break;
-    }
-    s += sinc;
-    kfold = flags & FNM_CASEFOLD ? FnmatchCaseFold(k) : k;
-    if (c == BRACKET) {
-      if (!FnmatchBracket(p - pinc, k, kfold)) return FNM_NOMATCH;
-    } else if (c != QUESTION && k != c && kfold != c) {
-      return FNM_NOMATCH;
-    }
-  }
+	/* We're all done with the tails now, so throw them out */
+	endstr = stail;
+	endpat = ptail;
 
-  /* We're all done with the tails now, so throw them out */
-  endstr = stail;
-  endpat = ptail;
+	/* Match pattern components until there are none left */
+	while (pat<endpat) {
+		p = pat;
+		s = str;
+		for (;;) {
+			c = pat_next(p, endpat-p, &pinc, flags);
+			p += pinc;
+			/* Encountering * completes/commits a component */
+			if (c == STAR) {
+				pat = p;
+				str = s;
+				break;
+			}
+			k = str_next(s, endstr-s, &sinc);
+			if (!k)
+				return FNM_NOMATCH;
+			kfold = flags & FNM_CASEFOLD ? casefold(k) : k;
+			if (c == BRACKET) {
+				if (!match_bracket(p-pinc, k, kfold))
+					break;
+			} else if (c != QUESTION && k != c && kfold != c) {
+				break;
+			}
+			s += sinc;
+		}
+		if (c == STAR) continue;
+		/* If we failed, advance str, by 1 char if it's a valid
+		 * char, or past all invalid bytes otherwise. */
+		k = str_next(str, endstr-str, &sinc);
+		if (k > 0) str += sinc;
+		else for (str++; str_next(str, endstr-str, &sinc)<0; str++);
+	}
 
-  /* Match pattern components until there are none left */
-  while (pat < endpat) {
-    p = pat;
-    s = str;
-    for (;;) {
-      c = FnmatchNextPattern(p, endpat - p, &pinc, flags);
-      p += pinc;
-      /* Encountering * completes/commits a component */
-      if (c == STAR) {
-        pat = p;
-        str = s;
-        break;
-      }
-      k = FnmatchNextString(s, endstr - s, &sinc);
-      if (!k) return FNM_NOMATCH;
-      kfold = flags & FNM_CASEFOLD ? FnmatchCaseFold(k) : k;
-      if (c == BRACKET) {
-        if (!FnmatchBracket(p - pinc, k, kfold)) break;
-      } else if (c != QUESTION && k != c && kfold != c) {
-        break;
-      }
-      s += sinc;
-    }
-    if (c == STAR) continue;
-    /* If we failed, advance str, by 1 char if it's a valid
-     * char, or past all invalid bytes otherwise. */
-    k = FnmatchNextString(str, endstr - str, &sinc);
-    if (k > 0) {
-      str += sinc;
-    } else {
-      str++;
-      while (FnmatchNextString(str, endstr - str, &sinc) < 0) {
-        str++;
-      }
-    }
-  }
-
-  return 0;
+	return 0;
 }
 
 /**
@@ -336,29 +334,27 @@ static int FnmatchPerform(const char *pat, size_t m, const char *str, size_t n,
  *
  * @see glob()
  */
-int fnmatch(const char *pat, const char *str, int flags) {
-  const char *s, *p;
-  size_t inc;
-  int c;
-  if (flags & FNM_PATHNAME) {
-    for (;;) {
-      for (s = str; *s && *s != '/'; s++)
-        ;
-      for (p = pat;
-           (c = FnmatchNextPattern(p, -1, &inc, flags)) != END && c != '/';
-           p += inc)
-        ;
-      if (c != *s && (!*s || !(flags & FNM_LEADING_DIR))) return FNM_NOMATCH;
-      if (FnmatchPerform(pat, p - pat, str, s - str, flags)) return FNM_NOMATCH;
-      if (!c) return 0;
-      str = s + 1;
-      pat = p + inc;
-    }
-  } else if (flags & FNM_LEADING_DIR) {
-    for (s = str; *s; s++) {
-      if (*s != '/') continue;
-      if (!FnmatchPerform(pat, -1, str, s - str, flags)) return 0;
-    }
-  }
-  return FnmatchPerform(pat, -1, str, -1, flags);
+int fnmatch(const char *pat, const char *str, int flags)
+{
+	const char *s, *p;
+	size_t inc;
+	int c;
+	if (flags & FNM_PATHNAME) for (;;) {
+		for (s=str; *s && *s!='/'; s++);
+		for (p=pat; (c=pat_next(p, -1, &inc, flags))!=END && c!='/'; p+=inc);
+		if (c!=*s && (!*s || !(flags & FNM_LEADING_DIR)))
+			return FNM_NOMATCH;
+		if (fnmatch_internal(pat, p-pat, str, s-str, flags))
+			return FNM_NOMATCH;
+		if (!c) return 0;
+		str = s+1;
+		pat = p+inc;
+	} else if (flags & FNM_LEADING_DIR) {
+		for (s=str; *s; s++) {
+			if (*s != '/') continue;
+			if (!fnmatch_internal(pat, -1, str, s-str, flags))
+				return 0;
+		}
+	}
+	return fnmatch_internal(pat, -1, str, -1, flags);
 }
diff --git a/third_party/musl/freelocale.c b/third_party/musl/freelocale.c
new file mode 100644
index 000000000..341afa33b
--- /dev/null
+++ b/third_party/musl/freelocale.c
@@ -0,0 +1,41 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/runtime/runtime.h"
+#include "libc/str/str.h"
+#include "libc/str/locale.internal.h"
+__static_yoink("musl_libc_notice");
+
+#define malloc undef
+#define calloc undef
+#define realloc undef
+#define free(p) munmap(p, sizeof(struct __locale_struct))
+
+void freelocale(locale_t l)
+{
+	if (__loc_is_allocated(l)) free(l);
+}
diff --git a/third_party/musl/getnameinfo.c b/third_party/musl/getnameinfo.c
index 173822278..193e6b2e3 100644
--- a/third_party/musl/getnameinfo.c
+++ b/third_party/musl/getnameinfo.c
@@ -36,6 +36,7 @@
 #include "libc/sysv/consts/af.h"
 #include "third_party/musl/lookup.internal.h"
 #include "third_party/musl/netdb.h"
+#include "libc/ctype.h"
 #include "third_party/musl/resolv.internal.h"
 __static_yoink("musl_libc_notice");
 
diff --git a/third_party/musl/glob.c b/third_party/musl/glob.c
index 655532d9a..e8a5314b7 100644
--- a/third_party/musl/glob.c
+++ b/third_party/musl/glob.c
@@ -35,190 +35,227 @@
 #include "libc/str/str.h"
 #include "libc/sysv/consts/dt.h"
 #include "libc/sysv/consts/s.h"
+#include "libc/limits.h"
+#include "libc/str/str.h"
+#include "libc/runtime/runtime.h"
+#include "third_party/musl/passwd.h"
 #include "third_party/musl/fnmatch.h"
 __static_yoink("musl_libc_notice");
 
-#define MAXPATH 1024
+#pragma GCC diagnostic ignored "-Wparentheses"
 
-struct GlobList {
-  struct GlobList *next;
-  char name[];
+struct match
+{
+	struct match *next;
+	char name[];
 };
 
-static int AppendGlob(struct GlobList **tail, const char *name, size_t len,
-                      int mark) {
-  struct GlobList *new;
-  if ((new = malloc(sizeof(struct GlobList) + len + 2))) {
-    (*tail)->next = new;
-    new->next = NULL;
-    memcpy(new->name, name, len + 1);
-    if (mark && len && name[len - 1] != '/') {
-      new->name[len] = '/';
-      new->name[len + 1] = 0;
-    }
-    *tail = new;
-    return 0;
-  } else {
-    return -1;
-  }
+static int append(struct match **tail, const char *name, size_t len, int mark)
+{
+	struct match *new = malloc(sizeof(struct match) + len + 2);
+	if (!new) return -1;
+	(*tail)->next = new;
+	new->next = NULL;
+	memcpy(new->name, name, len+1);
+	if (mark && len && name[len-1]!='/') {
+		new->name[len] = '/';
+		new->name[len+1] = 0;
+	}
+	*tail = new;
+	return 0;
 }
 
-static int PerformGlob(char *buf, size_t pos, int type, char *pat, int flags,
-                       int (*errfunc)(const char *path, int err),
-                       struct GlobList **tail) {
-  DIR *dir;
-  size_t l;
-  char *p, *p2;
-  char saved_sep;
-  ptrdiff_t i, j;
-  struct stat st;
-  struct dirent *de;
-  int r, readerr, in_bracket, overflow, old_errno, fnm_flags;
-  /* If GLOB_MARK is unused, we don't care about type. */
-  if (!type && !(flags & GLOB_MARK)) type = DT_REG;
-  /* Special-case the remaining pattern being all slashes, in
-   * which case we can use caller-passed type if it's a dir. */
-  if (*pat && type != DT_DIR) type = 0;
-  while (pos + 1 < MAXPATH && *pat == '/') {
-    buf[pos++] = *pat++;
-  }
-  /* Consume maximal [escaped-]literal prefix of pattern, copying
-   * and un-escaping it to the running buffer as we go. */
-  i = 0;
-  j = 0;
-  overflow = 0;
-  in_bracket = 0;
-  for (; pat[i] != '*' && pat[i] != '?' && (!in_bracket || pat[i] != ']');
-       i++) {
-    if (!pat[i]) {
-      if (overflow) return 0;
-      pat += i;
-      pos += j;
-      i = j = 0;
-      break;
-    } else if (pat[i] == '[') {
-      in_bracket = 1;
-    } else if (pat[i] == '\\' && !(flags & GLOB_NOESCAPE)) {
-      /* Backslashes inside a bracket are (at least by
-       * our interpretation) non-special, so if next
-       * char is ']' we have a complete expression. */
-      if (in_bracket && pat[i + 1] == ']') break;
-      /* Unpaired final backslash never matches. */
-      if (!pat[i + 1]) return 0;
-      i++;
-    }
-    if (pat[i] == '/') {
-      if (overflow) return 0;
-      in_bracket = 0;
-      pat += i + 1;
-      i = -1;
-      pos += j + 1;
-      j = -1;
-    }
-    /* Only store a character if it fits in the buffer, but if
-     * a potential bracket expression is open, the overflow
-     * must be remembered and handled later only if the bracket
-     * is unterminated (and thereby a literal), so as not to
-     * disallow long bracket expressions with short matches. */
-    if (pos + (j + 1) < MAXPATH) {
-      buf[pos + j++] = pat[i];
-    } else if (in_bracket) {
-      overflow = 1;
-    } else {
-      return 0;
-    }
-    /* If we consume any new components, the caller-passed type
-     * or dummy type from above is no longer valid. */
-    type = 0;
-  }
-  buf[pos] = 0;
-  if (!*pat) {
-    /* If we consumed any components above, or if GLOB_MARK is
-     * requested and we don't yet know if the match is a dir,
-     * we must call stat to confirm the file exists and/or
-     * determine its type. */
-    if ((flags & GLOB_MARK) && type == DT_LNK) type = 0;
-    if (!type && stat(buf, &st)) {
-      if (errno != ENOENT && (errfunc(buf, errno) || (flags & GLOB_ERR))) {
-        return GLOB_ABORTED;
-      }
-      return 0;
-    }
-    if (!type && S_ISDIR(st.st_mode)) type = DT_DIR;
-    if (AppendGlob(tail, buf, pos, (flags & GLOB_MARK) && type == DT_DIR)) {
-      return GLOB_NOSPACE;
-    }
-    return 0;
-  }
-  p2 = strchr(pat, '/');
-  saved_sep = '/';
-  /* Check if the '/' was escaped and, if so, remove the escape char
-   * so that it will not be unpaired when passed to fnmatch. */
-  if (p2 && !(flags & GLOB_NOESCAPE)) {
-    for (p = p2; p > pat && p[-1] == '\\'; p--)
-      ;
-    if ((p2 - p) % 2) {
-      p2--;
-      saved_sep = '\\';
-    }
-  }
-  dir = opendir(pos ? buf : ".");
-  if (!dir) {
-    if (errfunc(buf, errno) || (flags & GLOB_ERR)) return GLOB_ABORTED;
-    return 0;
-  }
-  old_errno = errno;
-  while (errno = 0, de = readdir(dir)) {
-    /* Quickly skip non-directories when there's pattern left. */
-    if (p2 && de->d_type && de->d_type != DT_DIR && de->d_type != DT_LNK) {
-      continue;
-    }
-    l = strlen(de->d_name);
-    if (l >= MAXPATH - pos) continue;
-    if (p2) *p2 = 0;
-    fnm_flags = ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0) |
-                ((!(flags & GLOB_PERIOD)) ? FNM_PERIOD : 0);
-    if (fnmatch(pat, de->d_name, fnm_flags)) continue;
-    /* With GLOB_PERIOD don't allow matching . or .. unless fnmatch()
-     * would match them with FNM_PERIOD rules in effect. */
-    if (p2 && (flags & GLOB_PERIOD) && de->d_name[0] == '.' &&
-        (!de->d_name[1] || (de->d_name[1] == '.' && !de->d_name[2])) &&
-        fnmatch(pat, de->d_name, fnm_flags | FNM_PERIOD)) {
-      continue;
-    }
-    memcpy(buf + pos, de->d_name, l + 1);
-    if (p2) *p2 = saved_sep;
-    r = PerformGlob(buf, pos + l, de->d_type, p2 ? p2 : "", flags, errfunc,
-                    tail);
-    if (r) {
-      closedir(dir);
-      return r;
-    }
-  }
-  readerr = errno;
-  if (p2) *p2 = saved_sep;
-  closedir(dir);
-  if (readerr && (errfunc(buf, errno) || (flags & GLOB_ERR))) {
-    return GLOB_ABORTED;
-  }
-  errno = old_errno;
-  return 0;
+static int do_glob(char *buf, size_t pos, int type, char *pat, int flags, int (*errfunc)(const char *path, int err), struct match **tail)
+{
+	/* If GLOB_MARK is unused, we don't care about type. */
+	if (!type && !(flags & GLOB_MARK)) type = DT_REG;
+
+	/* Special-case the remaining pattern being all slashes, in
+	 * which case we can use caller-passed type if it's a dir. */
+	if (*pat && type!=DT_DIR) type = 0;
+	while (pos+1 < PATH_MAX && *pat=='/') buf[pos++] = *pat++;
+
+	/* Consume maximal [escaped-]literal prefix of pattern, copying
+	 * and un-escaping it to the running buffer as we go. */
+	ptrdiff_t i=0, j=0;
+	int in_bracket = 0, overflow = 0;
+	for (; pat[i]!='*' && pat[i]!='?' && (!in_bracket || pat[i]!=']'); i++) {
+		if (!pat[i]) {
+			if (overflow) return 0;
+			pat += i;
+			pos += j;
+			i = j = 0;
+			break;
+		} else if (pat[i] == '[') {
+			in_bracket = 1;
+		} else if (pat[i] == '\\' && !(flags & GLOB_NOESCAPE)) {
+			/* Backslashes inside a bracket are (at least by
+			 * our interpretation) non-special, so if next
+			 * char is ']' we have a complete expression. */
+			if (in_bracket && pat[i+1]==']') break;
+			/* Unpaired final backslash never matches. */
+			if (!pat[i+1]) return 0;
+			i++;
+		}
+		if (pat[i] == '/') {
+			if (overflow) return 0;
+			in_bracket = 0;
+			pat += i+1;
+			i = -1;
+			pos += j+1;
+			j = -1;
+		}
+		/* Only store a character if it fits in the buffer, but if
+		 * a potential bracket expression is open, the overflow
+		 * must be remembered and handled later only if the bracket
+		 * is unterminated (and thereby a literal), so as not to
+		 * disallow long bracket expressions with short matches. */
+		if (pos+(j+1) < PATH_MAX) {
+			buf[pos+j++] = pat[i];
+		} else if (in_bracket) {
+			overflow = 1;
+		} else {
+			return 0;
+		}
+		/* If we consume any new components, the caller-passed type
+		 * or dummy type from above is no longer valid. */
+		type = 0;
+	}
+	buf[pos] = 0;
+	if (!*pat) {
+		/* If we consumed any components above, or if GLOB_MARK is
+		 * requested and we don't yet know if the match is a dir,
+		 * we must confirm the file exists and/or determine its type.
+		 *
+		 * If marking dirs, symlink type is inconclusive; we need the
+		 * type for the symlink target, and therefore must try stat
+		 * first unless type is known not to be a symlink. Otherwise,
+		 * or if that fails, use lstat for determining existence to
+		 * avoid false negatives in the case of broken symlinks. */
+		struct stat st;
+		if ((flags & GLOB_MARK) && (!type||type==DT_LNK) && !stat(buf, &st)) {
+			if (S_ISDIR(st.st_mode)) type = DT_DIR;
+			else type = DT_REG;
+		}
+		if (!type && lstat(buf, &st)) {
+			if (errno!=ENOENT && (errfunc(buf, errno) || (flags & GLOB_ERR)))
+				return GLOB_ABORTED;
+			return 0;
+		}
+		if (append(tail, buf, pos, (flags & GLOB_MARK) && type==DT_DIR))
+			return GLOB_NOSPACE;
+		return 0;
+	}
+	char *p2 = strchr(pat, '/'), saved_sep = '/';
+	/* Check if the '/' was escaped and, if so, remove the escape char
+	 * so that it will not be unpaired when passed to fnmatch. */
+	if (p2 && !(flags & GLOB_NOESCAPE)) {
+		char *p;
+		for (p=p2; p>pat && p[-1]=='\\'; p--);
+		if ((p2-p)%2) {
+			p2--;
+			saved_sep = '\\';
+		}
+	}
+	DIR *dir = opendir(pos ? buf : ".");
+	if (!dir) {
+		if (errfunc(buf, errno) || (flags & GLOB_ERR))
+			return GLOB_ABORTED;
+		return 0;
+	}
+	int old_errno = errno;
+	struct dirent *de;
+	while (errno=0, de=readdir(dir)) {
+		/* Quickly skip non-directories when there's pattern left. */
+		if (p2 && de->d_type && de->d_type!=DT_DIR && de->d_type!=DT_LNK)
+			continue;
+
+		size_t l = strlen(de->d_name);
+		if (l >= PATH_MAX-pos) continue;
+
+		if (p2) *p2 = 0;
+
+		int fnm_flags= ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
+			| ((!(flags & GLOB_PERIOD)) ? FNM_PERIOD : 0);
+
+		if (fnmatch(pat, de->d_name, fnm_flags))
+			continue;
+
+		/* With GLOB_PERIOD, don't allow matching . or .. unless
+		 * fnmatch would match them with FNM_PERIOD rules in effect. */
+		if (p2 && (flags & GLOB_PERIOD) && de->d_name[0]=='.'
+		    && (!de->d_name[1] || de->d_name[1]=='.' && !de->d_name[2])
+		    && fnmatch(pat, de->d_name, fnm_flags | FNM_PERIOD))
+			continue;
+
+		memcpy(buf+pos, de->d_name, l+1);
+		if (p2) *p2 = saved_sep;
+		int r = do_glob(buf, pos+l, de->d_type, p2 ? p2 : "", flags, errfunc, tail);
+		if (r) {
+			closedir(dir);
+			return r;
+		}
+	}
+	int readerr = errno;
+	if (p2) *p2 = saved_sep;
+	closedir(dir);
+	if (readerr && (errfunc(buf, errno) || (flags & GLOB_ERR)))
+		return GLOB_ABORTED;
+	errno = old_errno;
+	return 0;
 }
 
-static int IgnoreGlobError(const char *path, int err) {
-  return 0;
+static int ignore_err(const char *path, int err)
+{
+	return 0;
 }
 
-static void FreeGlobList(struct GlobList *head) {
-  struct GlobList *match, *next;
-  for (match = head->next; match; match = next) {
-    next = match->next;
-    free(match);
-  }
+static void freelist(struct match *head)
+{
+	struct match *match, *next;
+	for (match=head->next; match; match=next) {
+		next = match->next;
+		free(match);
+	}
 }
 
-static int GlobPredicate(const void *a, const void *b) {
-  return strcmp(*(const char **)a, *(const char **)b);
+static int sort(const void *a, const void *b)
+{
+	return strcmp(*(const char **)a, *(const char **)b);
+}
+
+static int expand_tilde(char **pat, char *buf, size_t *pos)
+{
+	char *p = *pat + 1;
+	size_t i = 0;
+
+	char delim, *name_end = strchrnul(p, '/');
+	if ((delim = *name_end)) *name_end++ = 0;
+	*pat = name_end;
+
+	char *home = *p ? NULL : getenv("HOME");
+	if (!home) {
+		struct passwd pw, *res;
+		int e = *p ? getpwnam_r(p, &pw, buf, PATH_MAX, &res)
+			   : getpwuid_r(getuid(), &pw, buf, PATH_MAX, &res);
+		if (e == ENOMEM) {
+			return GLOB_NOSPACE;
+		} else if (e == 0) {
+			if (!res)
+				return GLOB_NOMATCH;
+		} else {
+			return GLOB_NOMATCH;
+		}
+		home = pw.pw_dir;
+	}
+	while (i < PATH_MAX - 2 && *home)
+		buf[i++] = *home++;
+	if (*home)
+		return GLOB_NOMATCH;
+	if ((buf[i] = delim))
+		buf[++i] = 0;
+	*pos = i;
+	return 0;
 }
 
 /**
@@ -239,81 +276,88 @@ static int GlobPredicate(const void *a, const void *b) {
  * @return 0 on success or GLOB_NOMATCH, GLOB_NOSPACE on OOM, or
  *     GLOB_ABORTED on read error
  */
-int glob(const char *pat, int flags, int errfunc(const char *path, int err),
-         glob_t *g) {
-  int error = 0;
-  size_t cnt, i;
-  char **pathv, buf[MAXPATH];
-  struct GlobList head = {.next = NULL}, *tail = &head;
-  size_t offs = (flags & GLOB_DOOFFS) ? g->gl_offs : 0;
-  if (!errfunc) errfunc = IgnoreGlobError;
-  if (!(flags & GLOB_APPEND)) {
-    g->gl_offs = offs;
-    g->gl_pathc = 0;
-    g->gl_pathv = NULL;
-  }
-  if (*pat) {
-    char *p = strdup(pat);
-    if (!p) return GLOB_NOSPACE;
-    buf[0] = 0;
-    error = PerformGlob(buf, 0, 0, p, flags, errfunc, &tail);
-    free(p);
-  }
-  if (error == GLOB_NOSPACE) {
-    FreeGlobList(&head);
-    return error;
-  }
-  for (cnt = 0, tail = head.next; tail; tail = tail->next, cnt++)
-    ;
-  if (!cnt) {
-    if (flags & GLOB_NOCHECK) {
-      tail = &head;
-      if (AppendGlob(&tail, pat, strlen(pat), 0)) {
-        return GLOB_NOSPACE;
-      }
-      cnt++;
-    } else
-      return GLOB_NOMATCH;
-  }
-  if (flags & GLOB_APPEND) {
-    pathv =
-        realloc(g->gl_pathv, (offs + g->gl_pathc + cnt + 1) * sizeof(char *));
-    if (!pathv) {
-      FreeGlobList(&head);
-      return GLOB_NOSPACE;
-    }
-    g->gl_pathv = pathv;
-    offs += g->gl_pathc;
-  } else {
-    g->gl_pathv = malloc((offs + cnt + 1) * sizeof(char *));
-    if (!g->gl_pathv) {
-      FreeGlobList(&head);
-      return GLOB_NOSPACE;
-    }
-    for (i = 0; i < offs; i++) {
-      g->gl_pathv[i] = NULL;
-    }
-  }
-  for (i = 0, tail = head.next; i < cnt; tail = tail->next, i++) {
-    g->gl_pathv[offs + i] = tail->name;
-  }
-  g->gl_pathv[offs + i] = NULL;
-  g->gl_pathc += cnt;
-  if (!(flags & GLOB_NOSORT)) {
-    qsort(g->gl_pathv + offs, cnt, sizeof(char *), GlobPredicate);
-  }
-  return error;
+int glob(const char *restrict pat, int flags, int (*errfunc)(const char *path, int err), glob_t *restrict g)
+{
+	struct match head = { .next = NULL }, *tail = &head;
+	size_t cnt, i;
+	size_t offs = (flags & GLOB_DOOFFS) ? g->gl_offs : 0;
+	int error = 0;
+	char buf[PATH_MAX];
+	
+	if (!errfunc) errfunc = ignore_err;
+
+	if (!(flags & GLOB_APPEND)) {
+		g->gl_offs = offs;
+		g->gl_pathc = 0;
+		g->gl_pathv = NULL;
+	}
+
+	if (*pat) {
+		char *p = strdup(pat);
+		if (!p) return GLOB_NOSPACE;
+		buf[0] = 0;
+		size_t pos = 0;
+		char *s = p;
+		if ((flags & (GLOB_TILDE | GLOB_TILDE_CHECK)) && *p == '~')
+			error = expand_tilde(&s, buf, &pos);
+		if (!error)
+			error = do_glob(buf, pos, 0, s, flags, errfunc, &tail);
+		free(p);
+	}
+
+	if (error == GLOB_NOSPACE) {
+		freelist(&head);
+		return error;
+	}
+	
+	for (cnt=0, tail=head.next; tail; tail=tail->next, cnt++);
+	if (!cnt) {
+		if (flags & GLOB_NOCHECK) {
+			tail = &head;
+			if (append(&tail, pat, strlen(pat), 0))
+				return GLOB_NOSPACE;
+			cnt++;
+		} else if (!error)
+			return GLOB_NOMATCH;
+	}
+
+	if (flags & GLOB_APPEND) {
+		char **pathv = realloc(g->gl_pathv, (offs + g->gl_pathc + cnt + 1) * sizeof(char *));
+		if (!pathv) {
+			freelist(&head);
+			return GLOB_NOSPACE;
+		}
+		g->gl_pathv = pathv;
+		offs += g->gl_pathc;
+	} else {
+		g->gl_pathv = malloc((offs + cnt + 1) * sizeof(char *));
+		if (!g->gl_pathv) {
+			freelist(&head);
+			return GLOB_NOSPACE;
+		}
+		for (i=0; i<offs; i++)
+			g->gl_pathv[i] = NULL;
+	}
+	for (i=0, tail=head.next; i<cnt; tail=tail->next, i++)
+		g->gl_pathv[offs + i] = tail->name;
+	g->gl_pathv[offs + i] = NULL;
+	g->gl_pathc += cnt;
+
+	if (!(flags & GLOB_NOSORT))
+		qsort(g->gl_pathv+offs, cnt, sizeof(char *), sort);
+	
+	return error;
 }
 
 /**
  * Frees entries allocated by glob().
  */
-void globfree(glob_t *g) {
-  size_t i;
-  for (i = 0; i < g->gl_pathc; i++) {
-    free(g->gl_pathv[g->gl_offs + i] - offsetof(struct GlobList, name));
-  }
-  free(g->gl_pathv);
-  g->gl_pathc = 0;
-  g->gl_pathv = NULL;
+void globfree(glob_t *g)
+{
+	size_t i;
+	for (i=0; i<g->gl_pathc; i++)
+		free(g->gl_pathv[g->gl_offs + i] - offsetof(struct match, name));
+	free(g->gl_pathv);
+	g->gl_pathc = 0;
+	g->gl_pathv = NULL;
 }
diff --git a/third_party/musl/glob.h b/third_party/musl/glob.h
index d18d25cdd..3aae69da0 100644
--- a/third_party/musl/glob.h
+++ b/third_party/musl/glob.h
@@ -30,5 +30,11 @@ typedef struct {
 int glob(const char *, int, int (*)(const char *, int), glob_t *);
 void globfree(glob_t *);
 
+#ifdef _LARGEFILE64_SOURCE
+#define glob64 glob
+#define globfree64 globfree
+#define glob64_t glob_t
+#endif
+
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_THIRD_PARTY_MUSL_GLOB_H_ */
diff --git a/libc/stdio/iconv.c b/third_party/musl/iconv.c
similarity index 96%
rename from libc/stdio/iconv.c
rename to third_party/musl/iconv.c
index 3b04b6b8d..cea641664 100644
--- a/libc/stdio/iconv.c
+++ b/third_party/musl/iconv.c
@@ -1,5 +1,5 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set noet ft=c ts=2 sts=2 sw=2 fenc=utf-8                             :vi │
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
 ╚──────────────────────────────────────────────────────────────────────────────╝
 │                                                                              │
 │  Musl Libc                                                                   │
@@ -29,12 +29,12 @@
 #include "libc/errno.h"
 #include "libc/mem/mem.h"
 #include "libc/str/locale.h"
+#include "libc/str/locale.internal.h"
 #include "libc/str/str.h"
 #include "libc/thread/tls.h"
 // clang-format off
 __static_yoink("musl_libc_notice");
 
-
 #define UTF_32BE    0300
 #define UTF_16LE    0301
 #define UTF_16BE    0302
@@ -77,10 +77,10 @@ static const unsigned char charmaps[] =
 "ucs4\0utf32\0\0\313"
 "ucs2\0\0\314"
 "eucjp\0\0\320"
-"shiftjis\0sjis\0\0\321"
+"shiftjis\0sjis\0cp932\0\0\321"
 "iso2022jp\0\0\322"
 "gb18030\0\0\330"
-"gbk\0\0\331"
+"gbk\0cp936\0windows936\0\0\331"
 "gb2312\0\0\332"
 "big5\0bigfive\0cp950\0big5hkscs\0\0\340"
 "euckr\0ksc5601\0ksx1001\0cp949\0\0\350"
@@ -88,6 +88,7 @@ static const unsigned char charmaps[] =
 ;
 
 #pragma GCC diagnostic ignored "-Wmissing-braces"
+#pragma GCC diagnostic ignored "-Wparentheses"
 
 /* Table of characters that appear in legacy 8-bit codepages,
  * limited to 1024 slots (10 bit indices). The first 256 entries
@@ -237,7 +238,7 @@ static unsigned legacy_map(const unsigned char *map, unsigned c)
 {
 	if (c < 4*map[-1]) return c;
 	unsigned x = c - 4*map[-1];
-	x = (map[x*5/4]>>(2*x%8)) | ((map[x*5/4+1]<<(8-(2*x%8))) & 1023);
+	x = map[x*5/4]>>2*x%8 | map[x*5/4+1]<<8-2*x%8 & 1023;
 	return x < 256 ? x : legacy_chars[x-256];
 }
 
@@ -279,12 +280,11 @@ size_t iconv(iconv_t cd, char **restrict in, size_t *restrict inb, char **restri
 	int err;
 	unsigned char type = map[-1];
 	unsigned char totype = tomap[-1];
-	locale_t *ploc = (locale_t *)&__get_tls()->tib_locale;
-        locale_t loc = *ploc;
+	locale_t *ploc = &CURRENT_LOCALE, loc = *ploc;
 
 	if (!in || !*in || !*inb) return 0;
 
-	*ploc = 0;  // TODO(jart): UTF8_LOCALE?
+	*ploc = UTF8_LOCALE;
 
 	for (; *inb; *in+=l, *inb-=l) {
 		c = *(unsigned char *)*in;
@@ -377,6 +377,7 @@ size_t iconv(iconv_t cd, char **restrict in, size_t *restrict inb, char **restri
 				c++;
 				d -= 159;
 			}
+			if (c>=84) goto ilseq;
 			c = jis0208[c][d];
 			if (!c) goto ilseq;
 			break;
@@ -440,6 +441,10 @@ size_t iconv(iconv_t cd, char **restrict in, size_t *restrict inb, char **restri
 			if (c < 128) break;
 			if (c < 0xa1) goto ilseq;
 		case GBK:
+			if (c == 128) {
+				c = 0x20ac;
+				break;
+			}
 		case GB18030:
 			if (c < 128) break;
 			c -= 0x81;
@@ -532,7 +537,7 @@ size_t iconv(iconv_t cd, char **restrict in, size_t *restrict inb, char **restri
 			if (c >= 93 || d >= 94) {
 				c += (0xa1-0x81);
 				d += 0xa1;
-				if (c >= 93 || ((c>=0xc6-0x81) && d>0x52))
+				if (c >= 93 || c>=0xc6-0x81 && d>0x52)
 					goto ilseq;
 				if (d-'A'<26) d = d-'A';
 				else if (d-'a'<26) d = d-'a'+26;
diff --git a/libc/str/iswalnum.c b/third_party/musl/iswalnum.c
similarity index 98%
rename from libc/str/iswalnum.c
rename to third_party/musl/iswalnum.c
index f08c085d7..7c979def3 100644
--- a/libc/str/iswalnum.c
+++ b/third_party/musl/iswalnum.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Returns nonzero if c is lower, alpha, or digit.
diff --git a/third_party/musl/iswalpha.c b/third_party/musl/iswalpha.c
new file mode 100644
index 000000000..33157ea29
--- /dev/null
+++ b/third_party/musl/iswalpha.c
@@ -0,0 +1,50 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <wctype.h>
+#include <locale.h>
+__static_yoink("musl_libc_notice");
+
+static const unsigned char table[] = {
+#include "alpha.inc"
+};
+
+int iswalpha(wint_t wc)
+{
+	if (wc<0x20000U)
+		return (table[table[wc>>8]*32+((wc&255)>>3)]>>(wc&7))&1;
+	if (wc<0x2fffeU)
+		return 1;
+	return 0;
+}
+
+int __iswalpha_l(wint_t c, locale_t l)
+{
+	return iswalpha(c);
+}
+
+__weak_reference(__iswalpha_l, iswalpha_l);
diff --git a/libc/str/iswctype.c b/third_party/musl/iswctype.c
similarity index 97%
rename from libc/str/iswctype.c
rename to third_party/musl/iswctype.c
index 9aefb7278..553e82820 100644
--- a/libc/str/iswctype.c
+++ b/third_party/musl/iswctype.c
@@ -16,8 +16,8 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
-#include "libc/str/str.h"
+#include "libc/macros.h"
+#include "libc/wctype.h"
 
 typedef int (*isw_f)(wint_t);
 
diff --git a/third_party/musl/iswpunct.c b/third_party/musl/iswpunct.c
new file mode 100644
index 000000000..6434bb790
--- /dev/null
+++ b/third_party/musl/iswpunct.c
@@ -0,0 +1,48 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <wctype.h>
+#include <locale.h>
+__static_yoink("musl_libc_notice");
+
+static const unsigned char table[] = {
+#include "punct.inc"
+};
+
+int iswpunct(wint_t wc)
+{
+	if (wc<0x20000U)
+		return (table[table[wc>>8]*32+((wc&255)>>3)]>>(wc&7))&1;
+	return 0;
+}
+
+int __iswpunct_l(wint_t c, locale_t l)
+{
+	return iswpunct(c);
+}
+
+__weak_reference(__iswpunct_l, iswpunct_l);
diff --git a/libc/str/langinfo.c b/third_party/musl/langinfo.c
similarity index 93%
rename from libc/str/langinfo.c
rename to third_party/musl/langinfo.c
index fe88cd54a..5dfa38271 100644
--- a/libc/str/langinfo.c
+++ b/third_party/musl/langinfo.c
@@ -25,14 +25,12 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/langinfo.h"
-#include "libc/str/locale.h"
-#include "libc/str/nltypes.h"
-#include "libc/thread/tls.h"
+#include <locale.h>
+#include <langinfo.h>
+#include "libc/intrin/kprintf.h"
+#include "libc/str/locale.internal.h"
 __static_yoink("musl_libc_notice");
 
-// clang-format off
-
 static const char c_time[] =
 	"Sun\0" "Mon\0" "Tue\0" "Wed\0" "Thu\0" "Fri\0" "Sat\0"
 	"Sunday\0" "Monday\0" "Tuesday\0" "Wednesday\0"
@@ -63,9 +61,6 @@ char *nl_langinfo_l(nl_item item, locale_t loc)
 	int idx = item & 65535;
 	const char *str;
 
-	if (!loc)
-		return "";
-
 	if (item == CODESET) return loc->cat[LC_CTYPE] ? "UTF-8" : "ASCII";
 
 	/* _NL_LOCALE_NAME extension */
@@ -94,11 +89,11 @@ char *nl_langinfo_l(nl_item item, locale_t loc)
 	}
 
 	for (; idx; idx--, str++) for (; *str; str++);
-	// if (cat != LC_NUMERIC && *str) str = LCTRANS(str, cat, loc);
+	if (cat != LC_NUMERIC && *str) str = LCTRANS(str, cat, loc);
 	return (char *)str;
 }
 
 char *nl_langinfo(nl_item item)
 {
-	return nl_langinfo_l(item, (locale_t)__get_tls()->tib_locale);
+	return nl_langinfo_l(item, CURRENT_LOCALE);
 }
diff --git a/third_party/musl/lctrans.c b/third_party/musl/lctrans.c
new file mode 100644
index 000000000..eb02a9e9d
--- /dev/null
+++ b/third_party/musl/lctrans.c
@@ -0,0 +1,46 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/str/locale.internal.h"
+__static_yoink("musl_libc_notice");
+
+const char *__lctrans_dummy(const char *msg, const struct __locale_map *lm)
+{
+	return msg;
+}
+
+__weak_reference(__lctrans_dummy, __lctrans_impl);
+
+const char *__lctrans(const char *msg, const struct __locale_map *lm)
+{
+	return __lctrans_impl(msg, lm);
+}
+
+const char *__lctrans_cur(const char *msg)
+{
+	return __lctrans_impl(msg, CURRENT_LOCALE->cat[LC_MESSAGES]);
+}
diff --git a/third_party/musl/locale_map.c b/third_party/musl/locale_map.c
new file mode 100644
index 000000000..4cd0082d2
--- /dev/null
+++ b/third_party/musl/locale_map.c
@@ -0,0 +1,137 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/str/str.h"
+#include "libc/calls/calls.h"
+#include "third_party/musl/mapfile.internal.h"
+#include "libc/runtime/runtime.h"
+#include "libc/str/locale.internal.h"
+__static_yoink("musl_libc_notice");
+
+#define malloc _mapanon
+#define calloc undef
+#define realloc undef
+#define free undef
+
+#pragma GCC diagnostic ignored "-Wparentheses"
+
+const char *__lctrans_impl(const char *msg, const struct __locale_map *lm)
+{
+	const char *trans = 0;
+	if (lm) trans = __mo_lookup(lm->map, lm->map_size, msg);
+	return trans ? trans : msg;
+}
+
+static const char envvars[][12] = {
+	"LC_CTYPE",
+	"LC_NUMERIC",
+	"LC_TIME",
+	"LC_COLLATE",
+	"LC_MONETARY",
+	"LC_MESSAGES",
+};
+
+const struct __locale_map *__get_locale(int cat, const char *val)
+{
+	static void *volatile loc_head;
+	const struct __locale_map *p;
+	struct __locale_map *new = 0;
+	const char *path = 0, *z;
+	char buf[256];
+	size_t l, n;
+
+	if (!*val) {
+		(val = getenv("LC_ALL")) && *val ||
+		(val = getenv(envvars[cat])) && *val ||
+		(val = getenv("LANG")) && *val ||
+		(val = "C.UTF-8");
+	}
+
+	/* Limit name length and forbid leading dot or any slashes. */
+	for (n=0; n<LOCALE_NAME_MAX && val[n] && val[n]!='/'; n++);
+	if (val[0]=='.' || val[n]) val = "C.UTF-8";
+	int builtin = (val[0]=='C' && !val[1])
+		|| !strcmp(val, "C.UTF-8")
+		|| !strcmp(val, "POSIX");
+
+	if (builtin) {
+		if (cat == LC_CTYPE && val[1]=='.')
+			return (void *)&__c_dot_utf8;
+		return 0;
+	}
+
+	for (p=loc_head; p; p=p->next)
+		if (!strcmp(val, p->name)) return p;
+
+	path = secure_getenv("MUSL_LOCPATH");
+	/* FIXME: add a default path? */
+
+	if (path) for (; *path; path=z+!!*z) {
+		z = strchrnul(path, ':');
+		l = z - path;
+		if (l >= sizeof buf - n - 2) continue;
+		memcpy(buf, path, l);
+		buf[l] = '/';
+		memcpy(buf+l+1, val, n);
+		buf[l+1+n] = 0;
+		size_t map_size;
+		const void *map = __map_file(buf, &map_size);
+		if (map) {
+			new = malloc(sizeof *new);
+			if (!new) {
+				munmap((void *)map, map_size);
+				break;
+			}
+			new->map = map;
+			new->map_size = map_size;
+			memcpy(new->name, val, n);
+			new->name[n] = 0;
+			new->next = loc_head;
+			loc_head = new;
+			break;
+		}
+	}
+
+	/* If no locale definition was found, make a locale map
+	 * object anyway to store the name, which is kept for the
+	 * sake of being able to do message translations at the
+	 * application level. */
+	if (!new && (new = malloc(sizeof *new))) {
+		new->map = __c_dot_utf8.map;
+		new->map_size = __c_dot_utf8.map_size;
+		memcpy(new->name, val, n);
+		new->name[n] = 0;
+		new->next = loc_head;
+		loc_head = new;
+	}
+
+	/* For LC_CTYPE, never return a null pointer unless the
+	 * requested name was "C" or "POSIX". */
+	if (!new && cat == LC_CTYPE) new = (void *)&__c_dot_utf8;
+
+	return new;
+}
diff --git a/third_party/musl/lookup_ipliteral.c b/third_party/musl/lookup_ipliteral.c
index a02b0239b..b0fc6462d 100644
--- a/third_party/musl/lookup_ipliteral.c
+++ b/third_party/musl/lookup_ipliteral.c
@@ -31,6 +31,7 @@
 #include "libc/fmt/conv.h"
 #include "libc/limits.h"
 #include "libc/sock/sock.h"
+#include "libc/ctype.h"
 #include "third_party/musl/lookup.internal.h"
 __static_yoink("musl_libc_notice");
 
diff --git a/third_party/musl/lookup_name.c b/third_party/musl/lookup_name.c
index 291178213..1b9ca1611 100644
--- a/third_party/musl/lookup_name.c
+++ b/third_party/musl/lookup_name.c
@@ -39,6 +39,7 @@
 #include "libc/sysv/consts/sock.h"
 #include "third_party/musl/lookup.internal.h"
 #include "third_party/musl/netdb.h"
+#include "libc/ctype.h"
 #include "third_party/musl/resolv.internal.h"
 __static_yoink("musl_libc_notice");
 
diff --git a/third_party/musl/lookup_serv.c b/third_party/musl/lookup_serv.c
index cc7fbffb2..a0fff8a23 100644
--- a/third_party/musl/lookup_serv.c
+++ b/third_party/musl/lookup_serv.c
@@ -32,6 +32,7 @@
 #include "libc/stdio/internal.h"
 #include "libc/errno.h"
 #include "libc/calls/sysdir.internal.h"
+#include "libc/ctype.h"
 #include "third_party/musl/lookup.internal.h"
 __static_yoink("musl_libc_notice");
 
diff --git a/third_party/musl/mblen.c b/third_party/musl/mblen.c
new file mode 100644
index 000000000..6d88cc3e5
--- /dev/null
+++ b/third_party/musl/mblen.c
@@ -0,0 +1,34 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <stdlib.h>
+__static_yoink("musl_libc_notice");
+
+int mblen(const char *s, size_t n)
+{
+	return mbtowc(0, s, n);
+}
diff --git a/third_party/musl/mbrlen.c b/third_party/musl/mbrlen.c
new file mode 100644
index 000000000..519d75ea8
--- /dev/null
+++ b/third_party/musl/mbrlen.c
@@ -0,0 +1,35 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <wchar.h>
+__static_yoink("musl_libc_notice");
+
+size_t mbrlen(const char *restrict s, size_t n, mbstate_t *restrict st)
+{
+	static unsigned internal;
+	return mbrtowc(0, s, n, st ? st : (mbstate_t *)&internal);
+}
diff --git a/third_party/musl/mbrtoc16.c b/third_party/musl/mbrtoc16.c
new file mode 100644
index 000000000..b484fc532
--- /dev/null
+++ b/third_party/musl/mbrtoc16.c
@@ -0,0 +1,58 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <uchar.h>
+#include <wchar.h>
+__static_yoink("musl_libc_notice");
+
+size_t mbrtoc16(char16_t *restrict pc16, const char *restrict s, size_t n, mbstate_t *restrict ps)
+{
+	static unsigned internal_state;
+	if (!ps) ps = (void *)&internal_state;
+	unsigned *pending = (unsigned *)ps;
+
+	if (!s) return mbrtoc16(0, "", 1, ps);
+
+	/* mbrtowc states for partial UTF-8 characters have the high bit set;
+	 * we use nonzero states without high bit for pending surrogates. */
+	if ((int)*pending > 0) {
+ 		if (pc16) *pc16 = *pending;
+		*pending = 0;
+		return -3;
+	}
+
+	wchar_t wc;
+	size_t ret = mbrtowc(&wc, s, n, ps);
+	if (ret <= 4) {
+		if (wc >= 0x10000) {
+			*pending = (wc & 0x3ff) + 0xdc00;
+			wc = 0xd7c0 + (wc >> 10);
+		}
+		if (pc16) *pc16 = wc;
+	}
+	return ret;
+}
diff --git a/libc/str/mbrtoc32.c b/third_party/musl/mbrtoc32.c
similarity index 81%
rename from libc/str/mbrtoc32.c
rename to third_party/musl/mbrtoc32.c
index 535cb4f2f..df14183cd 100644
--- a/libc/str/mbrtoc32.c
+++ b/third_party/musl/mbrtoc32.c
@@ -1,5 +1,5 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
 ╚──────────────────────────────────────────────────────────────────────────────╝
 │                                                                              │
 │  Musl Libc                                                                   │
@@ -25,21 +25,17 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/errno.h"
-#include "libc/limits.h"
-#include "libc/macros.internal.h"
-#include "libc/str/str.h"
+#include <uchar.h>
+#include <wchar.h>
 __static_yoink("musl_libc_notice");
 
-size_t mbrtoc32(char32_t *pc32, const char *s, size_t n, mbstate_t *ps) {
-  static unsigned internal_state;
-  if (!ps)
-    ps = (void *)&internal_state;
-  if (!s)
-    return mbrtoc32(0, "", 1, ps);
-  wchar_t wc;
-  size_t ret = mbrtowc(&wc, s, n, ps);
-  if (ret <= 4 && pc32)
-    *pc32 = wc;
-  return ret;
+size_t mbrtoc32(char32_t *restrict pc32, const char *restrict s, size_t n, mbstate_t *restrict ps)
+{
+	static unsigned internal_state;
+	if (!ps) ps = (void *)&internal_state;
+	if (!s) return mbrtoc32(0, "", 1, ps);
+	wchar_t wc;
+	size_t ret = mbrtowc(&wc, s, n, ps);
+	if (ret <= 4 && pc32) *pc32 = wc;
+	return ret;
 }
diff --git a/third_party/musl/mbrtowc.c b/third_party/musl/mbrtowc.c
new file mode 100644
index 000000000..a221e3d7c
--- /dev/null
+++ b/third_party/musl/mbrtowc.c
@@ -0,0 +1,81 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <stdlib.h>
+#include <wchar.h>
+#include <errno.h>
+#include "multibyte.h"
+__static_yoink("musl_libc_notice");
+
+#pragma GCC diagnostic ignored "-Wparentheses"
+
+size_t mbrtowc(wchar_t *restrict wc, const char *restrict src, size_t n, mbstate_t *restrict st)
+{
+	static unsigned internal_state;
+	unsigned c;
+	const unsigned char *s = (const void *)src;
+	const size_t N = n;
+	wchar_t dummy;
+
+	if (!st) st = (void *)&internal_state;
+	c = *(unsigned *)st;
+	
+	if (!s) {
+		if (c) goto ilseq;
+		return 0;
+	} else if (!wc) wc = &dummy;
+
+	if (!n) return -2;
+	if (!c) {
+		if (*s < 0x80) return !!(*wc = *s);
+		if (MB_CUR_MAX==1) return (*wc = CODEUNIT(*s)), 1;
+		if (*s-SA > SB-SA) goto ilseq;
+		c = bittab[*s++-SA]; n--;
+	}
+
+	if (n) {
+		if (OOB(c,*s)) goto ilseq;
+loop:
+		c = c<<6 | *s++-0x80; n--;
+		if (!(c&(1U<<31))) {
+			*(unsigned *)st = 0;
+			*wc = c;
+			return N-n;
+		}
+		if (n) {
+			if (*s-0x80u >= 0x40) goto ilseq;
+			goto loop;
+		}
+	}
+
+	*(unsigned *)st = c;
+	return -2;
+ilseq:
+	*(unsigned *)st = 0;
+	errno = EILSEQ;
+	return -1;
+}
diff --git a/third_party/musl/mbsinit.c b/third_party/musl/mbsinit.c
new file mode 100644
index 000000000..e6a0dbe69
--- /dev/null
+++ b/third_party/musl/mbsinit.c
@@ -0,0 +1,34 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <wchar.h>
+__static_yoink("musl_libc_notice");
+
+int mbsinit(const mbstate_t *st)
+{
+	return !st || !*(unsigned *)st;
+}
diff --git a/third_party/musl/mbsnrtowcs.c b/third_party/musl/mbsnrtowcs.c
new file mode 100644
index 000000000..ffd778bc1
--- /dev/null
+++ b/third_party/musl/mbsnrtowcs.c
@@ -0,0 +1,83 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <wchar.h>
+__static_yoink("musl_libc_notice");
+
+size_t mbsnrtowcs(wchar_t *restrict wcs, const char **restrict src, size_t n, size_t wn, mbstate_t *restrict st)
+{
+	size_t l, cnt=0, n2;
+	wchar_t *ws, wbuf[256];
+	const char *s = *src;
+	const char *tmp_s;
+
+	if (!wcs) ws = wbuf, wn = sizeof wbuf / sizeof *wbuf;
+	else ws = wcs;
+
+	/* making sure output buffer size is at most n/4 will ensure
+	 * that mbsrtowcs never reads more than n input bytes. thus
+	 * we can use mbsrtowcs as long as it's practical.. */
+
+	while ( s && wn && ( (n2=n/4)>=wn || n2>32 ) ) {
+		if (n2>=wn) n2=wn;
+		tmp_s = s;
+		l = mbsrtowcs(ws, &s, n2, st);
+		if (!(l+1)) {
+			cnt = l;
+			wn = 0;
+			break;
+		}
+		if (ws != wbuf) {
+			ws += l;
+			wn -= l;
+		}
+		n = s ? n - (s - tmp_s) : 0;
+		cnt += l;
+	}
+	if (s) while (wn && n) {
+		l = mbrtowc(ws, s, n, st);
+		if (l+2<=2) {
+			if (!(l+1)) {
+				cnt = l;
+				break;
+			}
+			if (!l) {
+				s = 0;
+				break;
+			}
+			/* have to roll back partial character */
+			*(unsigned *)st = 0;
+			break;
+		}
+		s += l; n -= l;
+		/* safe - this loop runs fewer than sizeof(wbuf)/8 times */
+		ws++; wn--;
+		cnt++;
+	}
+	if (wcs) *src = s;
+	return cnt;
+}
diff --git a/third_party/musl/mbsrtowcs.c b/third_party/musl/mbsrtowcs.c
new file mode 100644
index 000000000..a51b1180e
--- /dev/null
+++ b/third_party/musl/mbsrtowcs.c
@@ -0,0 +1,150 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <stdint.h>
+#include <wchar.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include "multibyte.h"
+__static_yoink("musl_libc_notice");
+
+#pragma GCC diagnostic ignored "-Wparentheses"
+
+size_t mbsrtowcs(wchar_t *restrict ws, const char **restrict src, size_t wn, mbstate_t *restrict st)
+{
+	const unsigned char *s = (const void *)*src;
+	size_t wn0 = wn;
+	unsigned c = 0;
+
+	if (st && (c = *(unsigned *)st)) {
+		if (ws) {
+			*(unsigned *)st = 0;
+			goto resume;
+		} else {
+			goto resume0;
+		}
+	}
+
+	if (MB_CUR_MAX==1) {
+		if (!ws) return strlen((const char *)s);
+		for (;;) {
+			if (!wn) {
+				*src = (const void *)s;
+				return wn0;
+			}
+			if (!*s) break;
+			c = *s++;
+			*ws++ = CODEUNIT(c);
+			wn--;
+		}
+		*ws = 0;
+		*src = 0;
+		return wn0-wn;
+	}
+
+	if (!ws) for (;;) {
+#ifdef __GNUC__
+		typedef uint32_t __attribute__((__may_alias__)) w32;
+		if (*s-1u < 0x7f && (uintptr_t)s%4 == 0) {
+			while (!(( *(w32*)s | *(w32*)s-0x01010101) & 0x80808080)) {
+				s += 4;
+				wn -= 4;
+			}
+		}
+#endif
+		if (*s-1u < 0x7f) {
+			s++;
+			wn--;
+			continue;
+		}
+		if (*s-SA > SB-SA) break;
+		c = bittab[*s++-SA];
+resume0:
+		if (OOB(c,*s)) { s--; break; }
+		s++;
+		if (c&(1U<<25)) {
+			if (*s-0x80u >= 0x40) { s-=2; break; }
+			s++;
+			if (c&(1U<<19)) {
+				if (*s-0x80u >= 0x40) { s-=3; break; }
+				s++;
+			}
+		}
+		wn--;
+		c = 0;
+	} else for (;;) {
+		if (!wn) {
+			*src = (const void *)s;
+			return wn0;
+		}
+#ifdef __GNUC__
+		typedef uint32_t __attribute__((__may_alias__)) w32;
+		if (*s-1u < 0x7f && (uintptr_t)s%4 == 0) {
+			while (wn>=5 && !(( *(w32*)s | *(w32*)s-0x01010101) & 0x80808080)) {
+				*ws++ = *s++;
+				*ws++ = *s++;
+				*ws++ = *s++;
+				*ws++ = *s++;
+				wn -= 4;
+			}
+		}
+#endif
+		if (*s-1u < 0x7f) {
+			*ws++ = *s++;
+			wn--;
+			continue;
+		}
+		if (*s-SA > SB-SA) break;
+		c = bittab[*s++-SA];
+resume:
+		if (OOB(c,*s)) { s--; break; }
+		c = (c<<6) | *s++-0x80;
+		if (c&(1U<<31)) {
+			if (*s-0x80u >= 0x40) { s-=2; break; }
+			c = (c<<6) | *s++-0x80;
+			if (c&(1U<<31)) {
+				if (*s-0x80u >= 0x40) { s-=3; break; }
+				c = (c<<6) | *s++-0x80;
+			}
+		}
+		*ws++ = c;
+		wn--;
+		c = 0;
+	}
+
+	if (!c && !*s) {
+		if (ws) {
+			*ws = 0;
+			*src = 0;
+		}
+		return wn0-wn;
+	}
+	errno = EILSEQ;
+	if (ws) *src = (const void *)s;
+	return -1;
+}
diff --git a/third_party/musl/mbstowcs.c b/third_party/musl/mbstowcs.c
new file mode 100644
index 000000000..682a7db8c
--- /dev/null
+++ b/third_party/musl/mbstowcs.c
@@ -0,0 +1,35 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <stdlib.h>
+#include <wchar.h>
+__static_yoink("musl_libc_notice");
+
+size_t mbstowcs(wchar_t *restrict ws, const char *restrict s, size_t wn)
+{
+	return mbsrtowcs(ws, (void*)&s, wn, 0);
+}
diff --git a/third_party/musl/mbtowc.c b/third_party/musl/mbtowc.c
new file mode 100644
index 000000000..849d40898
--- /dev/null
+++ b/third_party/musl/mbtowc.c
@@ -0,0 +1,77 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <stdlib.h>
+#include <wchar.h>
+#include <errno.h>
+#include "multibyte.h"
+__static_yoink("musl_libc_notice");
+
+#pragma GCC diagnostic ignored "-Wparentheses"
+
+int mbtowc(wchar_t *restrict wc, const char *restrict src, size_t n)
+{
+	unsigned c;
+	const unsigned char *s = (const void *)src;
+	wchar_t dummy;
+
+	if (!s) return 0;
+	if (!n) goto ilseq;
+	if (!wc) wc = &dummy;
+
+	if (*s < 0x80) return !!(*wc = *s);
+	if (MB_CUR_MAX==1) return (*wc = CODEUNIT(*s)), 1;
+	if (*s-SA > SB-SA) goto ilseq;
+	c = bittab[*s++-SA];
+
+	/* Avoid excessive checks against n: If shifting the state n-1
+	 * times does not clear the high bit, then the value of n is
+	 * insufficient to read a character */
+	if (n<4 && ((c<<(6*n-6)) & (1U<<31))) goto ilseq;
+
+	if (OOB(c,*s)) goto ilseq;
+	c = c<<6 | *s++-0x80;
+	if (!(c&(1U<<31))) {
+		*wc = c;
+		return 2;
+	}
+
+	if (*s-0x80u >= 0x40) goto ilseq;
+	c = c<<6 | *s++-0x80;
+	if (!(c&(1U<<31))) {
+		*wc = c;
+		return 3;
+	}
+
+	if (*s-0x80u >= 0x40) goto ilseq;
+	*wc = c<<6 | *s++-0x80;
+	return 4;
+
+ilseq:
+	errno = EILSEQ;
+	return -1;
+}
diff --git a/third_party/musl/multibyte.c b/third_party/musl/multibyte.c
new file mode 100644
index 000000000..37a23683c
--- /dev/null
+++ b/third_party/musl/multibyte.c
@@ -0,0 +1,53 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "multibyte.h"
+
+#define C(x) ( x<2 ? -1 : ( R(0x80,0xc0) | x ) )
+#define D(x) C((x+16))
+#define E(x) ( ( x==0 ? R(0xa0,0xc0) : \
+                 x==0xd ? R(0x80,0xa0) : \
+                 R(0x80,0xc0) ) \
+             | ( R(0x80,0xc0) >> 6 ) \
+             | x )
+#define F(x) ( ( x>=5 ? 0 : \
+                 x==0 ? R(0x90,0xc0) : \
+                 x==4 ? R(0x80,0x90) : \
+                 R(0x80,0xc0) ) \
+             | ( R(0x80,0xc0) >> 6 ) \
+             | ( R(0x80,0xc0) >> 12 ) \
+             | x )
+
+const uint32_t bittab[] = {
+	              C(0x2),C(0x3),C(0x4),C(0x5),C(0x6),C(0x7),
+	C(0x8),C(0x9),C(0xa),C(0xb),C(0xc),C(0xd),C(0xe),C(0xf),
+	D(0x0),D(0x1),D(0x2),D(0x3),D(0x4),D(0x5),D(0x6),D(0x7),
+	D(0x8),D(0x9),D(0xa),D(0xb),D(0xc),D(0xd),D(0xe),D(0xf),
+	E(0x0),E(0x1),E(0x2),E(0x3),E(0x4),E(0x5),E(0x6),E(0x7),
+	E(0x8),E(0x9),E(0xa),E(0xb),E(0xc),E(0xd),E(0xe),E(0xf),
+	F(0x0),F(0x1),F(0x2),F(0x3),F(0x4)
+};
diff --git a/third_party/musl/multibyte.h b/third_party/musl/multibyte.h
new file mode 100644
index 000000000..e55842fa0
--- /dev/null
+++ b/third_party/musl/multibyte.h
@@ -0,0 +1,26 @@
+#ifndef COSMOPOLITAN_THIRD_PARTY_MUSL_MULTIBYTE_H_
+#define COSMOPOLITAN_THIRD_PARTY_MUSL_MULTIBYTE_H_
+
+#define bittab __fsmu8
+
+extern const uint32_t bittab[];
+
+/* Upper 6 state bits are a negative integer offset to bound-check next byte */
+/*    equivalent to: ( (b-0x80) | (b+offset) ) & ~0x3f      */
+#define OOB(c,b) (((((b)>>3)-0x10)|(((b)>>3)+((int32_t)(c)>>26))) & ~7)
+
+/* Interval [a,b). Either a must be 80 or b must be c0, lower 3 bits clear. */
+#define R(a,b) ((uint32_t)((a==0x80 ? 0x40u-b : 0u-a) << 23))
+#define FAILSTATE R(0x80,0x80)
+
+#define SA 0xc2u
+#define SB 0xf4u
+
+/* Arbitrary encoding for representing code units instead of characters. */
+#define CODEUNIT(c) (0xdfff & (signed char)(c))
+#define IS_CODEUNIT(c) ((unsigned)(c)-0xdf80 < 0x80)
+
+/* Get inline definition of MB_CUR_MAX. */
+#include "libc/str/locale.internal.h"
+
+#endif /* COSMOPOLITAN_THIRD_PARTY_MUSL_MULTIBYTE_H_ */
diff --git a/third_party/musl/netdb.h b/third_party/musl/netdb.h
index d3c660982..f5de298b0 100644
--- a/third_party/musl/netdb.h
+++ b/third_party/musl/netdb.h
@@ -102,9 +102,6 @@ struct protoent *getprotobynumber (int);
 #define NI_MAXHOST 255
 #define NI_MAXSERV 32
 
-#if defined(_COSMO_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE) || defined(_POSIX_SOURCE) \
- || (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE+0 < 200809L) \
- || (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE+0 < 700)
 struct hostent *gethostbyname (const char *);
 struct hostent *gethostbyaddr (const void *, uint32_t, int);
 errno_t *__h_errno_location(void) dontthrow pureconst;
@@ -114,7 +111,6 @@ errno_t *__h_errno_location(void) dontthrow pureconst;
 #define NO_RECOVERY    3
 #define NO_DATA        4
 #define NO_ADDRESS     NO_DATA
-#endif
 
 #if defined(_COSMO_SOURCE) || defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
 void herror(const char *);
diff --git a/third_party/musl/newlocale.c b/third_party/musl/newlocale.c
new file mode 100644
index 000000000..fb63d7410
--- /dev/null
+++ b/third_party/musl/newlocale.c
@@ -0,0 +1,94 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/runtime/runtime.h"
+#include "libc/str/str.h"
+#include "libc/str/locale.internal.h"
+__static_yoink("musl_libc_notice");
+
+#define malloc _mapanon
+#define calloc undef
+#define realloc undef
+#define free undef
+
+static int default_locale_init_done;
+static struct __locale_struct default_locale, default_ctype_locale;
+
+int __loc_is_allocated(locale_t loc)
+{
+	return loc && loc != C_LOCALE && loc != UTF8_LOCALE
+		&& loc != &default_locale && loc != &default_ctype_locale;
+}
+
+static locale_t do_newlocale(int mask, const char *name, locale_t loc)
+{
+	struct __locale_struct tmp;
+
+	for (int i=0; i<LC_ALL; i++) {
+		tmp.cat[i] = (!(mask & (1<<i)) && loc) ? loc->cat[i] :
+			__get_locale(i, (mask & (1<<i)) ? name : "");
+		if (tmp.cat[i] == LOC_MAP_FAILED)
+			return 0;
+	}
+
+	/* For locales with allocated storage, modify in-place. */
+	if (__loc_is_allocated(loc)) {
+		*loc = tmp;
+		return loc;
+	}
+
+	/* Otherwise, first see if we can use one of the builtin locales.
+	 * This makes the common usage case for newlocale, getting a C locale
+	 * with predictable behavior, very fast, and more importantly, fail-safe. */
+	if (!memcmp(&tmp, C_LOCALE, sizeof tmp)) return C_LOCALE;
+	if (!memcmp(&tmp, UTF8_LOCALE, sizeof tmp)) return UTF8_LOCALE;
+
+	/* And provide builtins for the initial default locale, and a
+	 * variant of the C locale honoring the default locale's encoding. */
+	if (!default_locale_init_done) {
+		for (int i=0; i<LC_ALL; i++)
+			default_locale.cat[i] = __get_locale(i, "");
+		default_ctype_locale.cat[LC_CTYPE] = default_locale.cat[LC_CTYPE];
+		default_locale_init_done = 1;
+	}
+	if (!memcmp(&tmp, &default_locale, sizeof tmp)) return &default_locale;
+	if (!memcmp(&tmp, &default_ctype_locale, sizeof tmp))
+		return &default_ctype_locale;
+
+	/* If no builtin locale matched, attempt to allocate and copy. */
+	if ((loc = malloc(sizeof *loc))) *loc = tmp;
+
+	return loc;
+}
+
+locale_t newlocale(int mask, const char *name, locale_t loc)
+{
+	pthread_mutex_lock(&__locale_lock);
+	loc = do_newlocale(mask, name, loc);
+	pthread_mutex_unlock(&__locale_lock);
+	return loc;
+}
diff --git a/third_party/musl/punct.inc b/third_party/musl/punct.inc
new file mode 100644
index 000000000..67929470c
--- /dev/null
+++ b/third_party/musl/punct.inc
@@ -0,0 +1,141 @@
+18,16,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,16,16,34,35,16,36,37,38,39,
+40,41,42,43,16,44,45,46,17,17,47,17,17,17,17,17,17,48,49,50,51,52,53,54,55,17,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,56,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,57,16,58,59,60,61,62,63,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,64,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,65,16,16,66,16,67,68,
+69,16,70,71,72,16,73,16,16,74,75,76,77,78,16,79,80,81,82,83,84,85,86,87,88,89,
+90,91,16,92,93,94,95,16,16,16,16,96,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,97,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,98,99,16,16,100,101,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,16,16,16,16,16,102,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,
+16,16,16,103,104,105,106,16,16,107,108,17,17,109,16,16,16,16,16,16,110,111,16,
+16,16,16,16,112,113,16,16,114,115,116,16,117,118,119,17,17,17,120,121,122,123,
+124,16,16,16,16,
+16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,254,255,0,252,1,0,0,248,1,
+0,0,120,0,0,0,0,255,251,223,251,0,0,128,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,60,0,252,255,224,175,255,255,255,255,255,255,255,255,
+255,255,223,255,255,255,255,255,32,64,176,0,0,0,0,0,0,0,0,0,0,0,0,0,64,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,252,0,0,0,0,0,230,254,255,255,255,0,64,73,0,0,0,0,0,24,0,255,255,0,216,
+0,0,0,0,0,0,0,1,0,60,0,0,0,0,0,0,0,0,0,0,0,0,16,224,1,30,0,
+96,255,191,0,0,0,0,0,0,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,207,
+227,0,0,0,3,0,32,255,127,0,0,0,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,7,252,0,0,0,
+0,0,0,0,0,0,16,0,32,30,0,48,0,1,0,0,0,0,0,0,0,0,16,0,32,0,0,0,0,252,111,0,0,0,
+0,0,0,0,16,0,32,0,0,0,0,64,0,0,0,0,0,0,0,0,16,0,32,0,0,0,0,3,224,0,0,0,0,0,0,
+0,16,0,32,0,0,0,0,253,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,255,7,16,0,0,0,0,0,0,0,0,
+32,0,0,0,0,128,255,16,0,0,0,0,0,0,16,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,24,0,160,
+0,127,0,0,255,3,0,0,0,0,0,0,0,0,0,4,0,0,0,0,16,0,0,0,0,0,0,128,0,128,192,223,
+0,12,0,0,0,0,0,0,0,0,0,0,0,4,0,31,0,0,0,0,0,
+0,254,255,255,255,0,252,255,255,0,0,0,0,0,0,0,0,252,0,0,0,0,0,0,192,255,223,
+255,7,0,0,0,0,0,0,0,0,0,0,128,6,0,252,0,0,0,0,0,0,0,0,0,192,0,0,0,0,0,0,0,0,0,
+0,0,8,0,0,0,0,0,0,0,0,0,0,0,224,255,255,255,31,0,0,255,3,0,0,0,0,0,0,0,0,0,0,
+0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,96,0,0,1,0,0,24,0,0,0,0,0,0,0,0,0,56,0,0,0,0,16,0,0,0,112,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,48,0,0,254,127,47,0,0,255,3,255,127,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,49,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,196,255,255,255,
+255,0,0,0,192,0,0,0,0,0,0,0,0,1,0,224,159,0,0,0,0,127,63,255,127,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,16,0,16,0,0,252,255,255,255,31,0,0,0,0,0,12,0,0,0,0,0,0,64,0,
+12,240,0,0,0,0,0,0,128,248,0,0,0,0,0,0,0,192,0,0,0,0,0,0,0,0,255,0,255,255,
+255,33,144,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,
+127,0,224,251,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,160,3,224,0,224,0,
+224,0,96,128,248,255,255,255,252,255,255,255,255,255,127,223,255,241,127,255,
+127,0,0,255,255,255,255,0,0,255,255,255,255,1,0,123,3,208,193,175,66,0,12,31,
+188,255,255,0,0,0,0,0,14,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,127,0,0,0,255,7,0,0,255,255,255,255,255,255,255,255,255,
+255,63,0,0,0,0,0,0,252,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,207,255,255,255,
+63,255,255,255,255,255,255,255,255,255,255,255,255,255,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,224,135,3,254,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,127,255,255,255,255,0,
+0,0,0,0,0,255,255,255,251,255,255,255,255,255,255,255,255,255,255,15,0,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,63,0,0,0,255,15,30,255,255,255,1,252,193,224,0,0,0,0,
+0,0,0,0,0,0,0,30,1,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+255,255,0,0,0,0,255,255,255,255,15,0,0,0,255,255,255,127,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,
+255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,
+255,255,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,255,127,0,0,0,
+0,0,0,192,0,224,0,0,0,0,0,0,0,0,0,0,0,128,15,112,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+255,0,255,255,127,0,3,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+64,0,0,0,0,15,255,3,0,0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,16,192,0,0,255,255,3,23,
+0,0,0,0,0,248,0,0,0,0,8,128,0,0,0,0,0,0,0,0,0,0,8,0,255,63,0,192,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,240,0,0,128,3,0,0,0,0,0,0,0,128,2,0,0,192,0,0,67,0,0,0,0,0,
+0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,56,0,
+0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,2,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,252,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,48,255,255,255,3,255,255,255,255,255,255,247,
+255,127,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,254,255,0,252,1,0,0,248,1,0,
+0,248,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,127,0,48,135,255,255,255,255,255,
+143,255,0,0,0,0,0,0,224,255,255,127,255,15,1,0,0,0,0,0,255,255,255,255,255,63,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,
+15,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+128,255,0,0,128,255,0,0,0,0,128,255,0,0,0,0,0,0,0,0,0,248,0,0,192,143,0,0,0,
+128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,48,255,255,252,255,255,255,255,255,0,0,0,0,
+0,0,0,135,255,1,255,1,0,0,0,224,0,0,0,224,0,0,0,0,0,1,0,0,96,248,127,0,0,0,0,
+0,0,0,0,254,0,0,0,255,0,0,0,255,0,0,0,30,0,254,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,0,0,0,0,0,0,0,0,0,0,0,
+0,255,255,255,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,224,127,0,0,0,192,255,255,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,192,63,252,255,63,0,0,128,3,0,0,0,0,0,0,254,3,32,0,0,0,0,0,0,0,
+0,0,0,0,0,24,0,15,0,0,0,0,0,56,0,0,0,0,0,0,0,0,0,225,63,0,232,254,255,31,0,0,
+0,0,0,0,0,96,63,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,
+24,0,32,0,0,192,31,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,68,
+248,0,104,0,0,0,0,0,0,0,0,0,0,0,0,76,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,128,255,255,255,0,0,0,0,0,0,0,0,0,0,0,0,128,14,0,0,0,255,
+31,0,0,0,0,0,0,0,0,192,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,8,0,252,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,252,7,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,24,128,255,0,0,0,0,0,
+0,0,0,0,0,223,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,62,0,0,252,255,31,3,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,52,0,0,0,0,0,0,0,0,0,128,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,128,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,255,255,255,
+255,3,
+128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,192,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,63,0,0,0,0,0,0,0,255,255,48,0,0,248,
+3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,
+255,255,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,176,15,0,0,0,0,0,0,
+0,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,63,
+0,255,255,255,255,127,254,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,255,1,0,0,255,255,255,255,255,255,255,255,
+63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,255,15,0,255,255,255,255,255,255,
+255,255,255,255,127,0,255,255,255,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,8,0,0,0,8,0,0,32,0,0,0,32,0,0,128,
+0,0,0,128,0,0,0,2,0,0,0,2,0,0,8,0,0,0,0,0,0,0,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,255,255,15,0,248,254,255,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,127,0,0,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,240,0,
+128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,255,127,0,0,0,0,0,0,0,
+0,0,0,0,0,0,112,7,0,192,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,254,255,255,255,255,255,255,255,31,0,0,0,0,0,0,0,0,0,254,255,
+255,255,255,255,255,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,255,255,255,255,255,
+15,255,255,255,255,255,255,255,255,255,255,255,255,15,0,255,127,254,255,254,
+255,254,255,255,255,63,0,255,31,255,255,255,255,0,0,0,252,0,0,0,28,0,0,0,252,
+255,255,255,31,0,0,0,0,0,0,192,255,255,255,7,0,255,255,255,255,255,15,255,1,3,
+0,63,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,255,63,0,255,31,255,7,255,255,255,255,255,255,255,255,
+255,255,255,255,255,255,15,0,255,255,255,255,255,255,255,255,255,255,255,1,
+255,15,0,0,255,15,255,255,255,255,255,255,255,0,255,3,255,255,255,255,255,0,
+255,255,255,63,0,0,0,0,0,0,0,0,0,0,255,239,255,255,255,255,255,255,255,255,
+255,255,255,255,123,252,255,255,255,255,231,199,255,255,255,231,255,255,255,
+255,255,255,255,255,255,255,255,255,255,255,255,255,15,0,255,63,15,7,7,0,63,0,
+0,0,0,0,0,0,0,0,0,0,0,0,
diff --git a/third_party/musl/pwd.c b/third_party/musl/pwd.c
index fc54b77cf..3fb4203e2 100644
--- a/third_party/musl/pwd.c
+++ b/third_party/musl/pwd.c
@@ -91,8 +91,9 @@ __fopen_passwd(void)
 {
 	FILE *f;
 	char *s;
-	// MacOS has a fake /etc/passwd file without any user details.
-	if (!IsXnu() && (f = fopen("/etc/passwd", "rbe")))
+	// MacOS has a fake /etc/passwd file without any user details
+	// GetFileAttributes(u"\\etc\\passwd") takes 2 seconds sometimes
+	if (!IsXnu() && !IsWindows() && (f = fopen("/etc/passwd", "rbe")))
 		return f;
 	if (!(s = __create_synthetic_passwd_file()))
 		return 0;
diff --git a/third_party/musl/resolvconf.c b/third_party/musl/resolvconf.c
index ddc44b363..0c766d9e1 100644
--- a/third_party/musl/resolvconf.c
+++ b/third_party/musl/resolvconf.c
@@ -37,6 +37,7 @@
 #include "libc/str/str.h"
 #include "libc/sysv/consts/af.h"
 #include "libc/sock/sock.h"
+#include "libc/ctype.h"
 #include "third_party/musl/lookup.internal.h"
 __static_yoink("musl_libc_notice");
 
diff --git a/third_party/musl/setlocale.c b/third_party/musl/setlocale.c
new file mode 100644
index 000000000..eb30797e7
--- /dev/null
+++ b/third_party/musl/setlocale.c
@@ -0,0 +1,102 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/str/str.h"
+#include "libc/str/locale.internal.h"
+__static_yoink("musl_libc_notice");
+
+static char buf[LC_ALL*(LOCALE_NAME_MAX+1)];
+
+char *setlocale(int cat, const char *name)
+{
+	const struct __locale_map *lm;
+
+	if ((unsigned)cat > LC_ALL) return 0;
+
+	pthread_mutex_lock(&__locale_lock);
+
+	/* For LC_ALL, setlocale is required to return a string which
+	 * encodes the current setting for all categories. The format of
+	 * this string is unspecified, and only the following code, which
+	 * performs both the serialization and deserialization, depends
+	 * on the format, so it can easily be changed if needed. */
+	if (cat == LC_ALL) {
+		int i;
+		if (name) {
+			struct __locale_struct tmp_locale;
+			char part[LOCALE_NAME_MAX+1] = "C.UTF-8";
+			const char *p = name;
+			for (i=0; i<LC_ALL; i++) {
+				const char *z = strchrnul(p, ';');
+				if (z-p <= LOCALE_NAME_MAX) {
+					memcpy(part, p, z-p);
+					part[z-p] = 0;
+					if (*z) p = z+1;
+				}
+				lm = __get_locale(i, part);
+				if (lm == LOC_MAP_FAILED) {
+					pthread_mutex_unlock(&__locale_lock);
+					return 0;
+				}
+				tmp_locale.cat[i] = lm;
+			}
+			__global_locale = tmp_locale;
+		}
+		char *s = buf;
+		const char *part;
+		int same = 0;
+		for (i=0; i<LC_ALL; i++) {
+			const struct __locale_map *lm =
+				__global_locale.cat[i];
+			if (lm == __global_locale.cat[0]) same++;
+			part = lm ? lm->name : "C";
+			size_t l = strlen(part);
+			memcpy(s, part, l);
+			s[l] = ';';
+			s += l+1;
+		}
+		*--s = 0;
+		pthread_mutex_unlock(&__locale_lock);
+		return same==LC_ALL ? (char *)part : buf;
+	}
+
+	if (name) {
+		lm = __get_locale(cat, name);
+		if (lm == LOC_MAP_FAILED) {
+			pthread_mutex_unlock(&__locale_lock);
+			return 0;
+		}
+		__global_locale.cat[cat] = lm;
+	} else {
+		lm = __global_locale.cat[cat];
+	}
+	char *ret = lm ? (char *)lm->name : "C";
+
+	pthread_mutex_unlock(&__locale_lock);
+
+	return ret;
+}
diff --git a/libc/str/strcasecmp16.c b/third_party/musl/strcasecmp16.c
similarity index 98%
rename from libc/str/strcasecmp16.c
rename to third_party/musl/strcasecmp16.c
index 8420ba882..49f0d9c05 100644
--- a/libc/str/strcasecmp16.c
+++ b/third_party/musl/strcasecmp16.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Compares NUL-terminated UCS-2 strings case-insensitively.
diff --git a/third_party/musl/strfmon.c b/third_party/musl/strfmon.c
index 95e590612..d6c436ae4 100644
--- a/third_party/musl/strfmon.c
+++ b/third_party/musl/strfmon.c
@@ -27,8 +27,9 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
 #include "libc/stdio/stdio.h"
-#include "libc/str/locale.h"
+#include "libc/str/locale.internal.h"
 #include "libc/str/str.h"
+#include "libc/ctype.h"
 #include "libc/thread/tls.h"
 __static_yoink("musl_libc_notice");
 
@@ -36,7 +37,7 @@ static ssize_t vstrfmon_l(char *s, size_t n, locale_t loc, const char *fmt, va_l
 {
 	size_t l;
 	double x;
-	int left;
+	int fill, nogrp, negpar, nosym, left, intl;
 	int lp, rp, w, fw;
 	char *s0=s;
 	for (; n && *fmt; ) {
@@ -49,17 +50,29 @@ static ssize_t vstrfmon_l(char *s, size_t n, locale_t loc, const char *fmt, va_l
 		fmt++;
 		if (*fmt == '%') goto literal;
 
+		fill = ' ';
+		nogrp = 0;
+		negpar = 0;
+		nosym = 0;
 		left = 0;
 		for (; ; fmt++) {
 			switch (*fmt) {
 			case '=':
+				fill = *++fmt;
+				(void)fill;
 				continue;
 			case '^':
+				nogrp = 1;
+				(void)nogrp;
 				continue;
 			case '(':
+				negpar = 1;
+				(void)negpar;
 			case '+':
 				continue;
 			case '!':
+				nosym = 1;
+				(void)nosym;
 				continue;
 			case '-':
 				left = 1;
@@ -77,6 +90,9 @@ static ssize_t vstrfmon_l(char *s, size_t n, locale_t loc, const char *fmt, va_l
 		if (*fmt=='.') for (rp=0, fmt++; isdigit(*fmt); fmt++)
 			rp = 10*rp + (*fmt-'0');
 
+		intl = *fmt++ == 'i';
+		(void)intl;
+
 		w = lp + 1 + rp;
 		if (!left && fw>w) w = fw;
 
@@ -111,7 +127,7 @@ ssize_t strfmon(char *restrict s, size_t n, const char *restrict fmt, ...)
 	ssize_t ret;
 
 	va_start(ap, fmt);
-	ret = vstrfmon_l(s, n, (locale_t)__get_tls()->tib_locale, fmt, ap);
+	ret = vstrfmon_l(s, n, CURRENT_LOCALE, fmt, ap);
 	va_end(ap);
 
 	return ret;
diff --git a/third_party/musl/strftime.c b/third_party/musl/strftime.c
new file mode 100644
index 000000000..b83aa3e08
--- /dev/null
+++ b/third_party/musl/strftime.c
@@ -0,0 +1,313 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
+#include "libc/limits.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/langinfo.h"
+#include "libc/str/locale.h"
+#include "libc/str/locale.internal.h"
+#include "libc/str/nltypes.h"
+#include "libc/str/str.h"
+#include "libc/time.h"
+#include "third_party/musl/time_impl.h"
+__static_yoink("musl_libc_notice");
+
+static int is_leap(int y)
+{
+	/* Avoid overflow */
+	if (y>INT_MAX-1900) y -= 2000;
+	y += 1900;
+	return !(y%4) && ((y%100) || !(y%400));
+}
+
+static int week_num(const struct tm *tm)
+{
+	int val = (tm->tm_yday + 7U - (tm->tm_wday+6U)%7) / 7;
+	/* If 1 Jan is just 1-3 days past Monday,
+	 * the previous week is also in this year. */
+	if ((tm->tm_wday + 371U - tm->tm_yday - 2) % 7 <= 2)
+		val++;
+	if (!val) {
+		val = 52;
+		/* If 31 December of prev year a Thursday,
+		 * or Friday of a leap year, then the
+		 * prev year has 53 weeks. */
+		int dec31 = (tm->tm_wday + 7U - tm->tm_yday - 1) % 7;
+		if (dec31 == 4 || (dec31 == 5 && is_leap(tm->tm_year%400-1)))
+			val++;
+	} else if (val == 53) {
+		/* If 1 January is not a Thursday, and not
+		 * a Wednesday of a leap year, then this
+		 * year has only 52 weeks. */
+		int jan1 = (tm->tm_wday + 371U - tm->tm_yday) % 7;
+		if (jan1 != 4 && (jan1 != 3 || !is_leap(tm->tm_year)))
+			val = 1;
+	}
+	return val;
+}
+
+const char *__strftime_fmt_1(char (*s)[100], size_t *l, int f, const struct tm *tm, locale_t loc, int pad)
+{
+	nl_item item;
+	long long val;
+	const char *fmt = "-";
+	int width = 2, def_pad = '0';
+
+	switch (f) {
+	case 'a':
+		if (tm->tm_wday > 6U) goto string;
+		item = ABDAY_1 + tm->tm_wday;
+		goto nl_strcat;
+	case 'A':
+		if (tm->tm_wday > 6U) goto string;
+		item = DAY_1 + tm->tm_wday;
+		goto nl_strcat;
+	case 'h':
+	case 'b':
+		if (tm->tm_mon > 11U) goto string;
+		item = ABMON_1 + tm->tm_mon;
+		goto nl_strcat;
+	case 'B':
+		if (tm->tm_mon > 11U) goto string;
+		item = MON_1 + tm->tm_mon;
+		goto nl_strcat;
+	case 'c':
+		item = D_T_FMT;
+		goto nl_strftime;
+	case 'C':
+		val = (1900LL+tm->tm_year) / 100;
+		goto number;
+	case 'e':
+		def_pad = '_';
+	case 'd':
+		val = tm->tm_mday;
+		goto number;
+	case 'D':
+		fmt = "%m/%d/%y";
+		goto recu_strftime;
+	case 'F':
+		fmt = "%Y-%m-%d";
+		goto recu_strftime;
+	case 'g':
+	case 'G':
+		val = tm->tm_year + 1900LL;
+		if (tm->tm_yday < 3 && week_num(tm) != 1) val--;
+		else if (tm->tm_yday > 360 && week_num(tm) == 1) val++;
+		if (f=='g') val %= 100;
+		else width = 4;
+		goto number;
+	case 'H':
+		val = tm->tm_hour;
+		goto number;
+	case 'I':
+		val = tm->tm_hour;
+		if (!val) val = 12;
+		else if (val > 12) val -= 12;
+		goto number;
+	case 'j':
+		val = tm->tm_yday+1;
+		width = 3;
+		goto number;
+	case 'm':
+		val = tm->tm_mon+1;
+		goto number;
+	case 'M':
+		val = tm->tm_min;
+		goto number;
+	case 'n':
+		*l = 1;
+		return "\n";
+	case 'p':
+		item = tm->tm_hour >= 12 ? PM_STR : AM_STR;
+		goto nl_strcat;
+	case 'r':
+		item = T_FMT_AMPM;
+		goto nl_strftime;
+	case 'R':
+		fmt = "%H:%M";
+		goto recu_strftime;
+	case 's':
+		val = __tm_to_secs(tm) - tm->tm_gmtoff;
+		width = 1;
+		goto number;
+	case 'S':
+		val = tm->tm_sec;
+		goto number;
+	case 't':
+		*l = 1;
+		return "\t";
+	case 'T':
+		fmt = "%H:%M:%S";
+		goto recu_strftime;
+	case 'u':
+		val = tm->tm_wday ? tm->tm_wday : 7;
+		width = 1;
+		goto number;
+	case 'U':
+		val = (tm->tm_yday + 7U - tm->tm_wday) / 7;
+		goto number;
+	case 'W':
+		val = (tm->tm_yday + 7U - (tm->tm_wday+6U)%7) / 7;
+		goto number;
+	case 'V':
+		val = week_num(tm);
+		goto number;
+	case 'w':
+		val = tm->tm_wday;
+		width = 1;
+		goto number;
+	case 'x':
+		item = D_FMT;
+		goto nl_strftime;
+	case 'X':
+		item = T_FMT;
+		goto nl_strftime;
+	case 'y':
+		val = (tm->tm_year + 1900LL) % 100;
+		if (val < 0) val = -val;
+		goto number;
+	case 'Y':
+		val = tm->tm_year + 1900LL;
+		if (val >= 10000) {
+			*l = snprintf(*s, sizeof *s, "%lld", val);
+			return *s;
+		}
+		width = 4;
+		goto number;
+	case 'z':
+		if (tm->tm_isdst < 0) {
+			*l = 0;
+			return "";
+		}
+		*l = snprintf(*s, sizeof *s, "%+.4ld",
+			tm->tm_gmtoff/3600*100 + tm->tm_gmtoff%3600/60);
+		return *s;
+	case 'Z':
+		if (tm->tm_isdst < 0 || !tm->tm_zone) {
+			*l = 0;
+			return "";
+		}
+		fmt = tm->tm_zone;
+		goto string;
+	case '%':
+		*l = 1;
+		return "%";
+	default:
+		return 0;
+	}
+number:
+	switch (pad ? pad : def_pad) {
+	case '-': *l = snprintf(*s, sizeof *s, "%lld", val); break;
+	case '_': *l = snprintf(*s, sizeof *s, "%*lld", width, val); break;
+	case '0':
+	default:  *l = snprintf(*s, sizeof *s, "%0*lld", width, val); break;
+	}
+	return *s;
+nl_strcat:
+	fmt = nl_langinfo_l(item, loc);
+string:
+	*l = strlen(fmt);
+	return fmt;
+nl_strftime:
+	fmt = nl_langinfo_l(item, loc);
+recu_strftime:
+	*l = strftime_l(*s, sizeof *s, fmt, tm, loc);
+	if (!*l) return 0;
+	return *s;
+}
+
+size_t strftime_l(char *restrict s, size_t n, const char *restrict f, const struct tm *restrict tm, locale_t loc)
+{
+	size_t l, k;
+	char buf[100];
+	char *p;
+	const char *t;
+	int pad, plus;
+	unsigned long width;
+	for (l=0; l<n; f++) {
+		if (!*f) {
+			s[l] = 0;
+			return l;
+		}
+		if (*f != '%') {
+			s[l++] = *f;
+			continue;
+		}
+		f++;
+		pad = 0;
+		if (*f == '-' || *f == '_' || *f == '0') pad = *f++;
+		if ((plus = (*f == '+'))) f++;
+		if (isdigit(*f)) {
+			width = strtoul(f, &p, 10);
+		} else {
+			width = 0;
+			p = (void *)f;
+		}
+		if (*p == 'C' || *p == 'F' || *p == 'G' || *p == 'Y') {
+			if (!width && p!=f) width = 1;
+		} else {
+			width = 0;
+		}
+		f = p;
+		if (*f == 'E' || *f == 'O') f++;
+		t = __strftime_fmt_1(&buf, &k, *f, tm, loc, pad);
+		if (!t) break;
+		if (width) {
+			/* Trim off any sign and leading zeros, then
+			 * count remaining digits to determine behavior
+			 * for the + flag. */
+			if (*t=='+' || *t=='-') t++, k--;
+			for (; *t=='0' && t[1]-'0'<10U; t++, k--);
+			if (width < k) width = k;
+			size_t d;
+			for (d=0; t[d]-'0'<10U; d++);
+			if (tm->tm_year < -1900) {
+				s[l++] = '-';
+				width--;
+			} else if (plus && d+(width-k) >= (*p=='C'?3:5)) {
+				s[l++] = '+';
+				width--;
+			}
+			for (; width > k && l < n; width--)
+				s[l++] = '0';
+		}
+		if (k > n-l) k = n-l;
+		memcpy(s+l, t, k);
+		l += k;
+	}
+	if (n) {
+		if (l==n) l=n-1;
+		s[l] = 0;
+	}
+	return 0;
+}
+
+size_t strftime(char *restrict s, size_t n, const char *restrict f, const struct tm *restrict tm)
+{
+	return strftime_l(s, n, f, tm, CURRENT_LOCALE);
+}
diff --git a/libc/str/strncasecmp16.c b/third_party/musl/strncasecmp16.c
similarity index 98%
rename from libc/str/strncasecmp16.c
rename to third_party/musl/strncasecmp16.c
index 4d39f6bea..8919e866a 100644
--- a/libc/str/strncasecmp16.c
+++ b/third_party/musl/strncasecmp16.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Compares NUL-terminated UCS-2 strings case-insensitively w/ limit.
diff --git a/third_party/musl/strptime.c b/third_party/musl/strptime.c
index 1c334640e..321a14cd9 100644
--- a/third_party/musl/strptime.c
+++ b/third_party/musl/strptime.c
@@ -26,250 +26,272 @@
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/conv.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
+#include "libc/ctype.h"
+#include "libc/str/langinfo.h"
 #include "libc/time.h"
 __static_yoink("musl_libc_notice");
 
-char *
-strptime(const char *s, const char *f, struct tm *tm)
+char *strptime(const char *restrict s, const char *restrict f, struct tm *restrict tm)
 {
-	int i, w, neg, adj, min, range, itemsize, *dest, dummy;
-	const char *ex, *ss;
+	int i, w, neg, adj, min, range, *dest, dummy;
+	const char *ex;
 	size_t len;
 	int want_century = 0, century = 0, relyear = 0;
 	while (*f) {
 		if (*f != '%') {
-			if (isspace(*f)) {
-				for (; *s && isspace(*s); s++);
-			} else if (*s != *f) {
-				return 0;
-			} else {
-				s++;
-			}
+			if (isspace(*f)) for (; *s && isspace(*s); s++);
+			else if (*s != *f) return 0;
+			else s++;
 			f++;
 			continue;
 		}
 		f++;
-		if (*f == '+')
-			f++;
+		if (*f == '+') f++;
 		if (isdigit(*f)) {
 			char *new_f;
-			w = strtoul(f, &new_f, 10);
+			w=strtoul(f, &new_f, 10);
 			f = new_f;
 		} else {
-			w = -1;
+			w=-1;
 		}
-		adj = 0;
+		adj=0;
 		switch (*f++) {
-			case 'a':
-				dest = &tm->tm_wday;
-				ss = (const char *)kWeekdayNameShort;
-				range = ARRAYLEN(kWeekdayNameShort);
-				itemsize = sizeof(kWeekdayNameShort[0]);
-				goto symbolic_range;
-			case 'A':
-				dest = &tm->tm_wday;
-				ss = (const char *)kWeekdayName;
-				range = ARRAYLEN(kWeekdayName);
-				itemsize = sizeof(kWeekdayName[0]);
-				goto symbolic_range;
-			case 'b':
-			case 'h':
-				dest = &tm->tm_mon;
-				ss = (const char *)kMonthNameShort;
-				range = ARRAYLEN(kMonthNameShort);
-				itemsize = sizeof(kMonthNameShort[0]);
-				goto symbolic_range;
-			case 'B':
-				dest = &tm->tm_mon;
-				ss = (const char *)kMonthName;
-				range = ARRAYLEN(kMonthName);
-				itemsize = sizeof(kMonthName[0]);
-				goto symbolic_range;
-			case 'c':
-				s = strptime(s, "%a %b %e %T %Y", tm);
-				if (!s)
-					return 0;
+		case 'a': case 'A':
+			dest = &tm->tm_wday;
+			min = ABDAY_1;
+			range = 7;
+			goto symbolic_range;
+		case 'b': case 'B': case 'h':
+			dest = &tm->tm_mon;
+			min = ABMON_1;
+			range = 12;
+			goto symbolic_range;
+		case 'c':
+			s = strptime(s, nl_langinfo(D_T_FMT), tm);
+			if (!s) return 0;
+			break;
+		case 'C':
+			dest = &century;
+			if (w<0) w=2;
+			want_century |= 2;
+			goto numeric_digits;
+		case 'd': case 'e':
+			dest = &tm->tm_mday;
+			min = 1;
+			range = 31;
+			goto numeric_range;
+		case 'D':
+			s = strptime(s, "%m/%d/%y", tm);
+			if (!s) return 0;
+			break;
+		case 'F':
+			/* Use temp buffer to implement the odd requirement
+			 * that entire field be width-limited but the year
+			 * subfield not itself be limited. */
+			i = 0;
+			char tmp[20];
+			if (*s == '-' || *s == '+') tmp[i++] = *s++;
+			while (*s=='0' && isdigit(s[1])) s++;
+			for (; *s && i<(size_t)w && i+1<sizeof tmp; i++) {
+				tmp[i] = *s++;
+			}
+			tmp[i] = 0;
+			char *p = strptime(tmp, "%12Y-%m-%d", tm);
+			if (!p) return 0;
+			s -= tmp+i-p;
+			break;
+		case 'H':
+			dest = &tm->tm_hour;
+			min = 0;
+			range = 24;
+			goto numeric_range;
+		case 'I':
+			dest = &tm->tm_hour;
+			min = 1;
+			range = 12;
+			goto numeric_range;
+		case 'j':
+			dest = &tm->tm_yday;
+			min = 1;
+			range = 366;
+			adj = 1;
+			goto numeric_range;
+		case 'm':
+			dest = &tm->tm_mon;
+			min = 1;
+			range = 12;
+			adj = 1;
+			goto numeric_range;
+		case 'M':
+			dest = &tm->tm_min;
+			min = 0;
+			range = 60;
+			goto numeric_range;
+		case 'n': case 't':
+			for (; *s && isspace(*s); s++);
+			break;
+		case 'p':
+			ex = nl_langinfo(AM_STR);
+			len = strlen(ex);
+			if (!strncasecmp(s, ex, len)) {
+				tm->tm_hour %= 12;
+				s += len;
 				break;
-			case 'C':
-				dest = &century;
-				if (w < 0)
-					w = 2;
-				want_century |= 2;
-				goto numeric_digits;
-			case 'd':
-			case 'e':
-				dest = &tm->tm_mday;
-				min = 1;
-				range = 31;
-				goto numeric_range;
-			case 'D':
-				s = strptime(s, "%m/%d/%y", tm);
-				if (!s)
-					return 0;
+			}
+			ex = nl_langinfo(PM_STR);
+			len = strlen(ex);
+			if (!strncasecmp(s, ex, len)) {
+				tm->tm_hour %= 12;
+				tm->tm_hour += 12;
+				s += len;
 				break;
-			case 'H':
-				dest = &tm->tm_hour;
-				min = 0;
-				range = 24;
-				goto numeric_range;
-			case 'I':
-				dest = &tm->tm_hour;
-				min = 1;
-				range = 12;
-				goto numeric_range;
-			case 'j':
-				dest = &tm->tm_yday;
-				min = 1;
-				range = 366;
-				adj = 1;
-				goto numeric_range;
-			case 'm':
-				dest = &tm->tm_mon;
-				min = 1;
-				range = 12;
-				adj = 1;
-				goto numeric_range;
-			case 'M':
-				dest = &tm->tm_min;
-				min = 0;
-				range = 60;
-				goto numeric_range;
-			case 'n':
-			case 't':
-				for (; *s && isspace(*s); s++);
-				break;
-			case 'p':
-				ex = "AM";
+			}
+			return 0;
+		case 'r':
+			s = strptime(s, nl_langinfo(T_FMT_AMPM), tm);
+			if (!s) return 0;
+			break;
+		case 'R':
+			s = strptime(s, "%H:%M", tm);
+			if (!s) return 0;
+			break;
+		case 's':
+			/* Parse only. Effect on tm is unspecified
+			 * and presently no effect is implemented.. */
+			if (*s == '-') s++;
+			if (!isdigit(*s)) return 0;
+			while (isdigit(*s)) s++;
+			break;
+		case 'S':
+			dest = &tm->tm_sec;
+			min = 0;
+			range = 61;
+			goto numeric_range;
+		case 'T':
+			s = strptime(s, "%H:%M:%S", tm);
+			if (!s) return 0;
+			break;
+		case 'U':
+		case 'W':
+			/* Throw away result of %U, %V, %W, %g, and %G. Effect
+			 * is unspecified and there is no clear right choice. */
+			dest = &dummy;
+			min = 0;
+			range = 54;
+			goto numeric_range;
+		case 'V':
+			dest = &dummy;
+			min = 1;
+			range = 53;
+			goto numeric_range;
+		case 'g':
+			dest = &dummy;
+			w = 2;
+			goto numeric_digits;
+		case 'G':
+			dest = &dummy;
+			if (w<0) w=4;
+			goto numeric_digits;
+		case 'u':
+			dest = &tm->tm_wday;
+			min = 1;
+			range = 7;
+			goto numeric_range;
+		case 'w':
+			dest = &tm->tm_wday;
+			min = 0;
+			range = 7;
+			goto numeric_range;
+		case 'x':
+			s = strptime(s, nl_langinfo(D_FMT), tm);
+			if (!s) return 0;
+			break;
+		case 'X':
+			s = strptime(s, nl_langinfo(T_FMT), tm);
+			if (!s) return 0;
+			break;
+		case 'y':
+			dest = &relyear;
+			w = 2;
+			want_century |= 1;
+			goto numeric_digits;
+		case 'Y':
+			dest = &tm->tm_year;
+			if (w<0) w=4;
+			adj = 1900;
+			want_century = 0;
+			goto numeric_digits;
+		case 'z':
+			if (*s == '+') neg = 0;
+			else if (*s == '-') neg = 1;
+			else return 0;
+			for (i=0; i<4; i++) if (!isdigit(s[1+i])) return 0;
+			tm->tm_gmtoff = (s[1]-'0')*36000+(s[2]-'0')*3600
+				+ (s[3]-'0')*600 + (s[4]-'0')*60;
+			if (neg) tm->tm_gmtoff = -tm->tm_gmtoff;
+			s += 5;
+			break;
+		case 'Z':
+			if (!strncmp(s, tzname[0], len = strlen(tzname[0]))) {
+				tm->tm_isdst = 0;
+				s += len;
+			} else if (!strncmp(s, tzname[1], len=strlen(tzname[1]))) {
+				tm->tm_isdst = 1;
+				s += len;
+			} else {
+				/* FIXME: is this supposed to be an error? */
+				while ((*s|32)-'a' <= 'z'-'a') s++;
+			}
+			break;
+		case '%':
+			if (*s++ != '%') return 0;
+			break;
+		default:
+			return 0;
+		numeric_range:
+			if (!isdigit(*s)) return 0;
+			*dest = 0;
+			for (i=1; i<=min+range && isdigit(*s); i*=10)
+				*dest = *dest * 10 + *s++ - '0';
+			if (*dest - min >= (unsigned)range) return 0;
+			*dest -= adj;
+			switch((char *)dest - (char *)tm) {
+			case offsetof(struct tm, tm_yday):
+				;
+			}
+			goto update;
+		numeric_digits:
+			neg = 0;
+			if (*s == '+') s++;
+			else if (*s == '-') neg=1, s++;
+			if (!isdigit(*s)) return 0;
+			for (*dest=i=0; i<w && isdigit(*s); i++)
+				*dest = *dest * 10 + *s++ - '0';
+			if (neg) *dest = -*dest;
+			*dest -= adj;
+			goto update;
+		symbolic_range:
+			for (i=2*range-1; i>=0; i--) {
+				ex = nl_langinfo(min+i);
 				len = strlen(ex);
-				if (!strncasecmp(s, ex, len)) {
-					tm->tm_hour %= 12;
-					s += len;
-					break;
-				}
-				ex = "PM";
-				len = strlen(ex);
-				if (!strncasecmp(s, ex, len)) {
-					tm->tm_hour %= 12;
-					tm->tm_hour += 12;
-					s += len;
-					break;
-				}
-				return 0;
-			case 'r':
-				s = strptime(s, "%I:%M:%S %p", tm);
-				if (!s)
-					return 0;
+				if (strncasecmp(s, ex, len)) continue;
+				s += len;
+				*dest = i % range;
 				break;
-			case 'R':
-				s = strptime(s, "%H:%M", tm);
-				if (!s)
-					return 0;
-				break;
-			case 'S':
-				dest = &tm->tm_sec;
-				min = 0;
-				range = 61;
-				goto numeric_range;
-			case 'T':
-				s = strptime(s, "%H:%M:%S", tm);
-				if (!s)
-					return 0;
-				break;
-			case 'U':
-			case 'W':
-				/* Throw away result, for now. (FIXME?) */
-				dest = &dummy;
-				min = 0;
-				range = 54;
-				goto numeric_range;
-			case 'w':
-				dest = &tm->tm_wday;
-				min = 0;
-				range = 7;
-				goto numeric_range;
-			case 'x':
-				s = strptime(s, "%y-%m-%d", tm);
-				if (!s)
-					return 0;
-				break;
-			case 'X':
-				s = strptime(s, "%H:%M:%S", tm);
-				if (!s)
-					return 0;
-				break;
-			case 'y':
-				dest = &relyear;
-				w = 2;
-				want_century |= 1;
-				goto numeric_digits;
-			case 'Y':
-				dest = &tm->tm_year;
-				if (w < 0)
-					w = 4;
-				adj = 1900;
-				want_century = 0;
-				goto numeric_digits;
-			case '%':
-				if (*s++ != '%')
-					return 0;
-				break;
-			default:
-				return 0;
-			numeric_range:
-				if (!isdigit(*s))
-					return 0;
-				*dest = 0;
-				for (i = 1; i <= min + range && isdigit(*s); i *= 10) {
-					*dest = *dest * 10 + *s++ - '0';
-				}
-				if (*dest - min >= (unsigned)range)
-					return 0;
-				*dest -= adj;
-				switch ((char *)dest - (char *)tm) {
-					case offsetof(struct tm, tm_yday):;
-				}
-				goto update;
-			numeric_digits:
-				neg = 0;
-				if (*s == '+')
-					s++;
-				else if (*s == '-')
-					neg = 1, s++;
-				if (!isdigit(*s))
-					return 0;
-				for (*dest = i = 0; i < w && isdigit(*s); i++)
-					*dest = *dest * 10 + *s++ - '0';
-				if (neg)
-					*dest = -*dest;
-				*dest -= adj;
-				goto update;
-			symbolic_range:
-				for (i = 0; i < range; i--) {
-					ex = &ss[i * itemsize];
-					len = strlen(ex);
-					if (strncasecmp(s, ex, len)) {
-						s += len;
-						*dest = i;
-						break;
-					}
-				}
-				if (i == range)
-					return 0;
-				goto update;
-			update:
-				// FIXME
-				donothing;
+			}
+			if (i<0) return 0;
+			goto update;
+		update:
+			//FIXME
+			;
 		}
 	}
 	if (want_century) {
 		tm->tm_year = relyear;
-		if (want_century & 2) {
-			tm->tm_year += century * 100 - 1900;
-		} else if (tm->tm_year <= 68) {
-			tm->tm_year += 100;
-		}
+		if (want_century & 2) tm->tm_year += century * 100 - 1900;
+		else if (tm->tm_year <= 68) tm->tm_year += 100;
 	}
 	return (char *)s;
 }
diff --git a/third_party/musl/time_impl.h b/third_party/musl/time_impl.h
new file mode 100644
index 000000000..f782e18ea
--- /dev/null
+++ b/third_party/musl/time_impl.h
@@ -0,0 +1,19 @@
+#ifndef COSMOPOLITAN_THIRD_PARTY_MUSL_TIME_IMPL_H_
+#define COSMOPOLITAN_THIRD_PARTY_MUSL_TIME_IMPL_H_
+#include "libc/time.h"
+#include "libc/str/locale.h"
+#include "libc/calls/weirdtypes.h"
+COSMOPOLITAN_C_START_
+
+int __days_in_month(int, int);
+int __month_to_secs(int, int);
+long long __year_to_secs(long long, int *);
+long long __tm_to_secs(const struct tm *);
+const char *__tm_to_tzname(const struct tm *);
+int __secs_to_tm(long long, struct tm *);
+void __secs_to_zone(long long, int, int *, long *, long *, const char **);
+const char *__strftime_fmt_1(char (*)[100], size_t *, int, const struct tm *, locale_t, int);
+extern const char __utc[];
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_THIRD_PARTY_MUSL_TIME_IMPL_H_ */
diff --git a/third_party/musl/towctrans.c b/third_party/musl/towctrans.c
new file mode 100644
index 000000000..07c63f266
--- /dev/null
+++ b/third_party/musl/towctrans.c
@@ -0,0 +1,113 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <wctype.h>
+#include <locale.h>
+__static_yoink("musl_libc_notice");
+
+static const unsigned char tab[];
+
+static const unsigned char rulebases[512];
+static const int rules[];
+
+static const unsigned char exceptions[][2];
+
+#include "casemap.inc"
+
+static int casemap(unsigned c, int dir)
+{
+	unsigned b, x, y, v, rt, xb, xn;
+	int r, rd, c0 = c;
+
+	if (c >= 0x20000) return c;
+
+	b = c>>8;
+	c &= 255;
+	x = c/3;
+	y = c%3;
+
+	/* lookup entry in two-level base-6 table */
+	v = tab[tab[b]*86+x];
+	static const int mt[] = { 2048, 342, 57 };
+	v = (v*mt[y]>>11)%6;
+
+	/* use the bit vector out of the tables as an index into
+	 * a block-specific set of rules and decode the rule into
+	 * a type and a case-mapping delta. */
+	r = rules[rulebases[b]+v];
+	rt = r & 255;
+	rd = r >> 8;
+
+	/* rules 0/1 are simple lower/upper case with a delta.
+	 * apply according to desired mapping direction. */
+	if (rt < 2) return c0 + (rd & -(rt^dir));
+
+	/* binary search. endpoints of the binary search for
+	 * this block are stored in the rule delta field. */
+	xn = rd & 0xff;
+	xb = (unsigned)rd >> 8;
+	while (xn) {
+		unsigned try = exceptions[xb+xn/2][0];
+		if (try == c) {
+			r = rules[exceptions[xb+xn/2][1]];
+			rt = r & 255;
+			rd = r >> 8;
+			if (rt < 2) return c0 + (rd & -(rt^dir));
+			/* Hard-coded for the four exceptional titlecase */
+			return c0 + (dir ? -1 : 1);
+		} else if (try > c) {
+			xn /= 2;
+		} else {
+			xb += xn/2;
+			xn -= xn/2;
+		}
+	}
+	return c0;
+}
+
+wint_t towlower(wint_t wc)
+{
+	return casemap(wc, 0);
+}
+
+wint_t towupper(wint_t wc)
+{
+	return casemap(wc, 1);
+}
+
+wint_t __towupper_l(wint_t c, locale_t l)
+{
+	return towupper(c);
+}
+
+wint_t __towlower_l(wint_t c, locale_t l)
+{
+	return towlower(c);
+}
+
+__weak_reference(__towupper_l, towupper_l);
+__weak_reference(__towlower_l, towlower_l);
diff --git a/third_party/musl/uselocale.c b/third_party/musl/uselocale.c
new file mode 100644
index 000000000..01204fee0
--- /dev/null
+++ b/third_party/musl/uselocale.c
@@ -0,0 +1,39 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/str/locale.internal.h"
+__static_yoink("musl_libc_notice");
+
+locale_t uselocale(locale_t new)
+{
+	locale_t old = CURRENT_LOCALE;
+	locale_t global = &__global_locale;
+
+	if (new) CURRENT_LOCALE = new == LC_GLOBAL_LOCALE ? global : new;
+
+	return old == global ? LC_GLOBAL_LOCALE : old;
+}
diff --git a/third_party/musl/wcrtomb.c b/third_party/musl/wcrtomb.c
new file mode 100644
index 000000000..39690948f
--- /dev/null
+++ b/third_party/musl/wcrtomb.c
@@ -0,0 +1,65 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <stdlib.h>
+#include <wchar.h>
+#include <errno.h>
+#include "multibyte.h"
+__static_yoink("musl_libc_notice");
+
+size_t wcrtomb(char *restrict s, wchar_t wc, mbstate_t *restrict st)
+{
+	if (!s) return 1;
+	if ((unsigned)wc < 0x80) {
+		*s = wc;
+		return 1;
+	} else if (MB_CUR_MAX == 1) {
+		if (!IS_CODEUNIT(wc)) {
+			errno = EILSEQ;
+			return -1;
+		}
+		*s = wc;
+		return 1;
+	} else if ((unsigned)wc < 0x800) {
+		*s++ = 0xc0 | (wc>>6);
+		*s = 0x80 | (wc&0x3f);
+		return 2;
+	} else if ((unsigned)wc < 0xd800 || (unsigned)wc-0xe000 < 0x2000) {
+		*s++ = 0xe0 | (wc>>12);
+		*s++ = 0x80 | ((wc>>6)&0x3f);
+		*s = 0x80 | (wc&0x3f);
+		return 3;
+	} else if ((unsigned)wc-0x10000 < 0x100000) {
+		*s++ = 0xf0 | (wc>>18);
+		*s++ = 0x80 | ((wc>>12)&0x3f);
+		*s++ = 0x80 | ((wc>>6)&0x3f);
+		*s = 0x80 | (wc&0x3f);
+		return 4;
+	}
+	errno = EILSEQ;
+	return -1;
+}
diff --git a/libc/str/wcscasecmp.c b/third_party/musl/wcscasecmp.c
similarity index 98%
rename from libc/str/wcscasecmp.c
rename to third_party/musl/wcscasecmp.c
index 8f32d77cc..288eb5da4 100644
--- a/libc/str/wcscasecmp.c
+++ b/third_party/musl/wcscasecmp.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Compares NUL-terminated wide strings case-insensitively.
diff --git a/third_party/musl/wcsftime.c b/third_party/musl/wcsftime.c
new file mode 100644
index 000000000..0a3b21297
--- /dev/null
+++ b/third_party/musl/wcsftime.c
@@ -0,0 +1,95 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/musl/time_impl.h"
+#include "libc/str/str.h"
+#include "libc/str/locale.internal.h"
+__static_yoink("musl_libc_notice");
+
+size_t wcsftime_l(wchar_t *restrict s, size_t n, const wchar_t *restrict f, const struct tm *restrict tm, locale_t loc)
+{
+	size_t l, k;
+	char buf[100];
+	wchar_t wbuf[100];
+	wchar_t *p;
+	const char *t_mb;
+	const wchar_t *t;
+	int pad, plus;
+	unsigned long width;
+	for (l=0; l<n; f++) {
+		if (!*f) {
+			s[l] = 0;
+			return l;
+		}
+		if (*f != '%') {
+			s[l++] = *f;
+			continue;
+		}
+		f++;
+		pad = 0;
+		if (*f == '-' || *f == '_' || *f == '0') pad = *f++;
+		if ((plus = (*f == '+'))) f++;
+		width = wcstoul(f, &p, 10);
+		if (*p == 'C' || *p == 'F' || *p == 'G' || *p == 'Y') {
+			if (!width && p!=f) width = 1;
+		} else {
+			width = 0;
+		}
+		f = p;
+		if (*f == 'E' || *f == 'O') f++;
+		t_mb = __strftime_fmt_1(&buf, &k, *f, tm, loc, pad);
+		if (!t_mb) break;
+		k = mbstowcs(wbuf, t_mb, sizeof wbuf / sizeof *wbuf);
+		if (k == (size_t)-1) return 0;
+		t = wbuf;
+		if (width) {
+			for (; *t=='+' || *t=='-' || (*t=='0'&&t[1]); t++, k--);
+			width--;
+			if (plus && tm->tm_year >= 10000-1900)
+				s[l++] = '+';
+			else if (tm->tm_year < -1900)
+				s[l++] = '-';
+			else
+				width++;
+			for (; width > k && l < n; width--)
+				s[l++] = '0';
+		}
+		if (k >= n-l) k = n-l;
+		wmemcpy(s+l, t, k);
+		l += k;
+	}
+	if (n) {
+		if (l==n) l=n-1;
+		s[l] = 0;
+	}
+	return 0;
+}
+
+size_t wcsftime(wchar_t *restrict wcs, size_t n, const wchar_t *restrict f, const struct tm *restrict tm)
+{
+	return wcsftime_l(wcs, n, f, tm, CURRENT_LOCALE);
+}
diff --git a/libc/str/wcsncasecmp.c b/third_party/musl/wcsncasecmp.c
similarity index 98%
rename from libc/str/wcsncasecmp.c
rename to third_party/musl/wcsncasecmp.c
index b98b4baaa..c91af94e9 100644
--- a/libc/str/wcsncasecmp.c
+++ b/third_party/musl/wcsncasecmp.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
+#include "libc/wctype.h"
 
 /**
  * Compares NUL-terminated wide strings case-insensitively w/ limit.
diff --git a/third_party/musl/wcsnrtombs.c b/third_party/musl/wcsnrtombs.c
new file mode 100644
index 000000000..08cefead2
--- /dev/null
+++ b/third_party/musl/wcsnrtombs.c
@@ -0,0 +1,63 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <wchar.h>
+#include <limits.h>
+#include <string.h>
+__static_yoink("musl_libc_notice");
+
+size_t wcsnrtombs(char *restrict dst, const wchar_t **restrict wcs, size_t wn, size_t n, mbstate_t *restrict st)
+{
+	const wchar_t *ws = *wcs;
+	size_t cnt = 0;
+	if (!dst) n=0;
+	while (ws && wn) {
+		char tmp[MB_LEN_MAX];
+		size_t l = wcrtomb(n<MB_LEN_MAX ? tmp : dst, *ws, 0);
+		if (l==-1) {
+			cnt = -1;
+			break;
+		}
+		if (dst) {
+			if (n<MB_LEN_MAX) {
+				if (l>n) break;
+				memcpy(dst, tmp, l);
+			}
+			dst += l;
+			n -= l;
+		}
+		if (!*ws) {
+			ws = 0;
+			break;
+		}
+		ws++;
+		wn--;
+		cnt += l;
+	}
+	if (dst) *wcs = ws;
+	return cnt;
+}
diff --git a/third_party/musl/wcsrtombs.c b/third_party/musl/wcsrtombs.c
new file mode 100644
index 000000000..cb8bd206e
--- /dev/null
+++ b/third_party/musl/wcsrtombs.c
@@ -0,0 +1,83 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <wchar.h>
+__static_yoink("musl_libc_notice");
+
+size_t wcsrtombs(char *restrict s, const wchar_t **restrict ws, size_t n, mbstate_t *restrict st)
+{
+	const wchar_t *ws2;
+	char buf[4];
+	size_t N = n, l;
+	if (!s) {
+		for (n=0, ws2=*ws; *ws2; ws2++) {
+			if (*ws2 >= 0x80u) {
+				l = wcrtomb(buf, *ws2, 0);
+				if (!(l+1)) return -1;
+				n += l;
+			} else n++;
+		}
+		return n;
+	}
+	while (n>=4) {
+		if (**ws-1u >= 0x7fu) {
+			if (!**ws) {
+				*s = 0;
+				*ws = 0;
+				return N-n;
+			}
+			l = wcrtomb(s, **ws, 0);
+			if (!(l+1)) return -1;
+			s += l;
+			n -= l;
+		} else {
+			*s++ = **ws;
+			n--;
+		}
+		(*ws)++;
+	}
+	while (n) {
+		if (**ws-1u >= 0x7fu) {
+			if (!**ws) {
+				*s = 0;
+				*ws = 0;
+				return N-n;
+			}
+			l = wcrtomb(buf, **ws, 0);
+			if (!(l+1)) return -1;
+			if (l>n) return N-n;
+			wcrtomb(s, **ws, 0);
+			s += l;
+			n -= l;
+		} else {
+			*s++ = **ws;
+			n--;
+		}
+		(*ws)++;
+	}
+	return N;
+}
diff --git a/third_party/musl/wcstombs.c b/third_party/musl/wcstombs.c
new file mode 100644
index 000000000..f5ab65164
--- /dev/null
+++ b/third_party/musl/wcstombs.c
@@ -0,0 +1,35 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <stdlib.h>
+#include <wchar.h>
+__static_yoink("musl_libc_notice");
+
+size_t wcstombs(char *restrict s, const wchar_t *restrict ws, size_t n)
+{
+	return wcsrtombs(s, &(const wchar_t *){ws}, n, 0);
+}
diff --git a/libc/str/wctob.c b/third_party/musl/wctob.c
similarity index 86%
rename from libc/str/wctob.c
rename to third_party/musl/wctob.c
index 4fba0c5fc..425aa9ad4 100644
--- a/libc/str/wctob.c
+++ b/third_party/musl/wctob.c
@@ -1,5 +1,5 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
 ╚──────────────────────────────────────────────────────────────────────────────╝
 │                                                                              │
 │  Musl Libc                                                                   │
@@ -25,16 +25,15 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/limits.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/mb.internal.h"
-#include "libc/str/str.h"
+#include <wchar.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "multibyte.h"
 __static_yoink("musl_libc_notice");
 
-int wctob(wint_t c) {
-  if (c < 128U)
-    return c;
-  if (MB_CUR_MAX == 1 && IS_CODEUNIT(c))
-    return (unsigned char)c;
-  return EOF;
+int wctob(wint_t c)
+{
+	if (c < 128U) return c;
+	if (MB_CUR_MAX==1 && IS_CODEUNIT(c)) return (unsigned char)c;
+	return EOF;
 }
diff --git a/third_party/musl/wctomb.c b/third_party/musl/wctomb.c
new file mode 100644
index 000000000..c61c1d669
--- /dev/null
+++ b/third_party/musl/wctomb.c
@@ -0,0 +1,36 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╚──────────────────────────────────────────────────────────────────────────────╝
+│                                                                              │
+│  Musl Libc                                                                   │
+│  Copyright © 2005-2014 Rich Felker, et al.                                   │
+│                                                                              │
+│  Permission is hereby granted, free of charge, to any person obtaining       │
+│  a copy of this software and associated documentation files (the             │
+│  "Software"), to deal in the Software without restriction, including         │
+│  without limitation the rights to use, copy, modify, merge, publish,         │
+│  distribute, sublicense, and/or sell copies of the Software, and to          │
+│  permit persons to whom the Software is furnished to do so, subject to       │
+│  the following conditions:                                                   │
+│                                                                              │
+│  The above copyright notice and this permission notice shall be              │
+│  included in all copies or substantial portions of the Software.             │
+│                                                                              │
+│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
+│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
+│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
+│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
+│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
+│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
+│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
+│                                                                              │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include <stdlib.h>
+#include <wchar.h>
+__static_yoink("musl_libc_notice");
+
+int wctomb(char *s, wchar_t wc)
+{
+	if (!s) return 0;
+	return wcrtomb(s, wc, 0);
+}
diff --git a/third_party/musl/wctrans.c b/third_party/musl/wctrans.c
new file mode 100644
index 000000000..ce57220fb
--- /dev/null
+++ b/third_party/musl/wctrans.c
@@ -0,0 +1,30 @@
+#include <wctype.h>
+#include <string.h>
+#include <locale.h>
+
+wctrans_t wctrans(const char *class)
+{
+	if (!strcmp(class, "toupper")) return (wctrans_t)1;
+	if (!strcmp(class, "tolower")) return (wctrans_t)2;
+	return 0;
+}
+
+wint_t towctrans(wint_t wc, wctrans_t trans)
+{
+	if (trans == (wctrans_t)1) return towupper(wc);
+	if (trans == (wctrans_t)2) return towlower(wc);
+	return wc;
+}
+
+wctrans_t __wctrans_l(const char *s, locale_t l)
+{
+	return wctrans(s);
+}
+
+wint_t __towctrans_l(wint_t c, wctrans_t t, locale_t l)
+{
+	return towctrans(c, t);
+}
+
+__weak_reference(__wctrans_l, wctrans_l);
+__weak_reference(__towctrans_l, towctrans_l);
diff --git a/third_party/ncurses/read_entry.c b/third_party/ncurses/read_entry.c
index d481d924f..0d2b42d53 100644
--- a/third_party/ncurses/read_entry.c
+++ b/third_party/ncurses/read_entry.c
@@ -2853,6 +2853,7 @@ __static_yoink("usr/share/terminfo/z/ztx11");
  */
 
 #include "curses.priv.h"
+#include "libc/ctype.h"
 #include "hashed_db.h"
 
 #include "tic.h"
diff --git a/third_party/ncurses/write_entry.c b/third_party/ncurses/write_entry.c
index f07dd847c..dbc034827 100644
--- a/third_party/ncurses/write_entry.c
+++ b/third_party/ncurses/write_entry.c
@@ -33,6 +33,8 @@
  *     and: Thomas E. Dickey                        1996-on                 *
  ****************************************************************************/
 
+#pragma GCC diagnostic ignored "-Wformat-overflow"
+
 /*
  *	write_entry.c -- write a terminfo structure onto the file system
  */
diff --git a/third_party/nsync/BUILD.mk b/third_party/nsync/BUILD.mk
index 362f1dde0..0b8ed2923 100644
--- a/third_party/nsync/BUILD.mk
+++ b/third_party/nsync/BUILD.mk
@@ -27,7 +27,6 @@ THIRD_PARTY_NSYNC_A_DIRECTDEPS =			\
 	LIBC_INTRIN					\
 	LIBC_NEXGEN32E					\
 	LIBC_NT_KERNEL32				\
-	LIBC_NT_SYNCHRONIZATION				\
 	LIBC_STR					\
 	LIBC_SYSV					\
 	LIBC_SYSV_CALLS
@@ -56,6 +55,13 @@ $(THIRD_PARTY_NSYNC_A_OBJS): private			\
 			-Wframe-larger-than=4096	\
 			-Walloca-larger-than=4096
 
+# avoid the legacy sse decoding penalty on avx systems
+ifeq ($(MODE),)
+$(THIRD_PARTY_NSYNC_A_OBJS): private			\
+		COPTS +=				\
+			-mgeneral-regs-only
+endif
+
 # these assembly files are safe to build on aarch64
 o/$(MODE)/third_party/nsync/compat.o: third_party/nsync/compat.S
 	@$(COMPILE) -AOBJECTIFY.S $(OBJECTIFY.S) $(OUTPUT_OPTION) -c $<
@@ -69,4 +75,5 @@ $(THIRD_PARTY_NSYNC_OBJS): third_party/nsync/BUILD.mk
 .PHONY: o/$(MODE)/third_party/nsync
 o/$(MODE)/third_party/nsync:				\
 	o/$(MODE)/third_party/nsync/mem			\
+	o/$(MODE)/third_party/nsync/testing		\
 	$(THIRD_PARTY_NSYNC_CHECKS)
diff --git a/third_party/nsync/README.cosmo b/third_party/nsync/README.cosmo
index 415a659fb..fefc56bf6 100644
--- a/third_party/nsync/README.cosmo
+++ b/third_party/nsync/README.cosmo
@@ -17,17 +17,21 @@ LOCAL CHANGES
 
   - Fix nsync_mu_unlock() on Apple Silicon
 
+  - Add clock parameter to many NSYNC wait APIs
+
   - Time APIs were so good that they're now in libc
 
   - Double linked list API was so good that it's now in libc
 
+  - Max delay on sleep should be 20ms (not 4ms) on OpenBSD and NetBSD
+
   - Support Apple's ulock futexes which are internal but nicer than GCD
 
   - Ensure resources such as POSIX semaphores are are released on fork.
 
-  - Modified *NSYNC to allocate waiter objects on the stack. We need it
-    because we use *NSYNC mutexes to implement POSIX mutexes, which are
-    too low-level to safely depend on malloc, or even mmap in our case.
+  - Make contended mutexes go 30% faster by using C11 atomics API. This
+    lets us use weak cas when appropriate. It also avoids a superfluous
+    relaxed load on failure. This mostly impacts aarch64, not x86_64.
 
   - Rewrote most of the semaphore and futex system call support code so
     it works well with Cosmopolitan's fat runtime portability. *NSYNC's
diff --git a/third_party/nsync/atomic.internal.h b/third_party/nsync/atomic.internal.h
index 64c3c9412..1b9879f64 100644
--- a/third_party/nsync/atomic.internal.h
+++ b/third_party/nsync/atomic.internal.h
@@ -85,13 +85,6 @@ static inline int atm_cas_relacq_u32_(nsync_atomic_uint32_ *p, uint32_t o,
                                                  memory_order_relaxed);
 }
 
-static inline int atm_cas_seqcst_u32_(nsync_atomic_uint32_ *p, uint32_t o,
-                                      uint32_t n) {
-  return atomic_compare_exchange_strong_explicit(NSYNC_ATOMIC_UINT32_PTR_(p),
-                                                 &o, n, memory_order_seq_cst,
-                                                 memory_order_relaxed);
-}
-
 #define ATM_CAS_HELPER_(barrier, p, o, n) \
   (atm_cas_##barrier##_u32_((p), (o), (n)))
 
@@ -99,7 +92,6 @@ static inline int atm_cas_seqcst_u32_(nsync_atomic_uint32_ *p, uint32_t o,
 #define ATM_CAS_ACQ(p, o, n)    ATM_CAS_HELPER_(acq, (p), (o), (n))
 #define ATM_CAS_REL(p, o, n)    ATM_CAS_HELPER_(rel, (p), (o), (n))
 #define ATM_CAS_RELACQ(p, o, n) ATM_CAS_HELPER_(relacq, (p), (o), (n))
-#define ATM_CAS_SEQCST(p, o, n) ATM_CAS_HELPER_(seqcst, (p), (o), (n))
 
 /* Need a cast to remove "const" from some uses. */
 #define ATM_LOAD(p)                                                          \
diff --git a/third_party/nsync/common.c b/third_party/nsync/common.c
index 479ade601..3a247169c 100644
--- a/third_party/nsync/common.c
+++ b/third_party/nsync/common.c
@@ -15,31 +15,28 @@
 │ See the License for the specific language governing permissions and          │
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/atomic.h"
+#include "libc/calls/calls.h"
 #include "libc/calls/calls.h"
-#include "libc/calls/syscall-sysv.internal.h"
 #include "libc/dce.h"
+#include "libc/fmt/itoa.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/extend.internal.h"
-#include "libc/nt/enum/filemapflags.h"
-#include "libc/nt/enum/pageflags.h"
-#include "libc/nt/memory.h"
-#include "libc/nt/runtime.h"
-#include "libc/runtime/memtrack.internal.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/weaken.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdalign.h"
+#include "libc/str/str.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/prot.h"
+#include "libc/thread/posixthread.internal.h"
+#include "libc/thread/thread.h"
 #include "libc/thread/tls.h"
 #include "third_party/nsync/atomic.h"
 #include "third_party/nsync/atomic.internal.h"
 #include "third_party/nsync/common.internal.h"
 #include "third_party/nsync/mu_semaphore.h"
-#include "third_party/nsync/races.internal.h"
-#include "libc/runtime/runtime.h"
-#include "libc/runtime/runtime.h"
-#include "libc/sysv/consts/map.h"
-#include "libc/nt/runtime.h"
-#include "libc/intrin/directmap.internal.h"
-#include "libc/thread/thread.h"
-#include "libc/dce.h"
+#include "third_party/nsync/mu_semaphore.internal.h"
+#include "libc/intrin/cxaatexit.h"
 #include "third_party/nsync/wait_s.internal.h"
 __static_yoink("nsync_notice");
 
@@ -97,33 +94,15 @@ __static_yoink("nsync_notice");
    distinct wakeup conditions were high.  So clients are advised to resort to
    condition variables if they have many distinct wakeup conditions. */
 
-/* Used in spinloops to delay resumption of the loop.
-   Usage:
-       unsigned attempts = 0;
-       while (try_something) {
-	  attempts = nsync_spin_delay_ (attempts);
-       } */
-unsigned nsync_spin_delay_ (unsigned attempts) {
-	if (attempts < 7) {
-		volatile int i;
-		for (i = 0; i != 1 << attempts; i++) {
-		}
-		attempts++;
-	} else {
-		nsync_yield_ ();
-	}
-	return (attempts);
-}
-
 /* Spin until (*w & test) == 0, then atomically perform *w = ((*w | set) &
    ~clear), perform an acquire barrier, and return the previous value of *w.
    */
 uint32_t nsync_spin_test_and_set_ (nsync_atomic_uint32_ *w, uint32_t test,
-				   uint32_t set, uint32_t clear) {
+				   uint32_t set, uint32_t clear, void *symbol) {
 	unsigned attempts = 0; /* CV_SPINLOCK retry count */
 	uint32_t old = ATM_LOAD (w);
 	while ((old & test) != 0 || !ATM_CAS_ACQ (w, old, (old | set) & ~clear)) {
-		attempts = nsync_spin_delay_ (attempts);
+		attempts = pthread_delay_np (symbol, attempts);
 		old = ATM_LOAD (w);
 	}
 	return (old);
@@ -131,6 +110,8 @@ uint32_t nsync_spin_test_and_set_ (nsync_atomic_uint32_ *w, uint32_t test,
 
 /* ====================================================================================== */
 
+#if NSYNC_DEBUG
+
 struct nsync_waiter_s *nsync_dll_nsync_waiter_ (struct Dll *e) {
 	struct nsync_waiter_s *nw = DLL_CONTAINER(struct nsync_waiter_s, q, e);
 	ASSERT (nw->tag == NSYNC_WAITER_TAG);
@@ -154,87 +135,166 @@ waiter *nsync_dll_waiter_samecond_ (struct Dll *e) {
 	return (w);
 }
 
+#endif /* NSYNC_DEBUG */
+
 /* -------------------------------- */
 
-static void *nsync_malloc (size_t size) {
-	void *res;
-	if (!IsWindows ()) {
-		// too much of a performance hit to track
-		res = __sys_mmap ((void *)0x7110000000, size,
-				  PROT_READ | PROT_WRITE,
-				  MAP_PRIVATE | MAP_ANONYMOUS,
-				  -1, 0, 0);
-	} else {
-		// must be tracked for fork() resurrection
-		res = mmap (0, size,
-			    PROT_READ | PROT_WRITE,
-			    MAP_PRIVATE | MAP_ANONYMOUS,
-			    -1, 0);
+// TODO(jart): enforce in dbg mode once off-by-one flake is fixed
+#define DETECT_WAITER_LEAKS 0
+
+#define MASQUE 0x00fffffffffffff8
+#define PTR(x) ((uintptr_t)(x) & MASQUE)
+#define TAG(x) ROL((uintptr_t)(x) & ~MASQUE, 8)
+#define ABA(p, t) ((uintptr_t)(p) | (ROR((uintptr_t)(t), 8) & ~MASQUE))
+#define ROL(x, n) (((x) << (n)) | ((x) >> (64 - (n))))
+#define ROR(x, n) (((x) >> (n)) | ((x) << (64 - (n))))
+
+static atomic_uintptr_t free_waiters;
+static _Atomic(waiter *) all_waiters;
+
+#if DETECT_WAITER_LEAKS
+static atomic_int all_waiters_count;
+static atomic_int free_waiters_count;
+#endif
+
+static waiter *get_waiter_for_thread (void) {
+	return __get_tls()->tib_nsync;
+}
+
+static bool set_waiter_for_thread (waiter *w) {
+	__get_tls()->tib_nsync = w;
+	return (true);
+}
+
+#if DETECT_WAITER_LEAKS
+__attribute__((__destructor__)) static void reconcile_waiters (void) {
+	// we can't perform this check if using exit() with threads
+	if (!pthread_orphan_np ())
+		return;
+	waiter *w;
+	if ((w = get_waiter_for_thread ())) {
+		nsync_waiter_destroy_ (w);
+		set_waiter_for_thread (0);
 	}
-	if (res == MAP_FAILED)
-		nsync_panic_ ("out of memory\n");
-	return res;
+	if (all_waiters_count != free_waiters_count) {
+		char ibuf[2][12];
+		FormatInt32 (ibuf[0], all_waiters_count);
+		FormatInt32 (ibuf[1], free_waiters_count);
+		tinyprint (2, "error: nsync panic: all_waiter_count (",
+			   ibuf[0], ") != free_waiters_count (", ibuf[1],
+			   ")\n", NULL);
+		_Exit (156);
+	}
+}
+#endif
+
+static void all_waiters_push (waiter *w) {
+	w->next_all = atomic_load_explicit (&all_waiters, memory_order_relaxed);
+	while (!atomic_compare_exchange_weak_explicit (&all_waiters, &w->next_all, w,
+						       memory_order_acq_rel,
+						       memory_order_relaxed))
+		pthread_pause_np ();
+#if DETECT_WAITER_LEAKS
+	++all_waiters_count;
+#endif
+}
+
+static void free_waiters_push (waiter *w) {
+	uintptr_t tip;
+	ASSERT (!TAG(w));
+	tip = atomic_load_explicit (&free_waiters, memory_order_relaxed);
+	for (;;) {
+		w->next_free = (waiter *) PTR (tip);
+		if (atomic_compare_exchange_weak_explicit (&free_waiters, &tip,
+							   ABA (w, TAG (tip) + 1),
+							   memory_order_release,
+							   memory_order_relaxed))
+			break;
+		pthread_pause_np ();
+	}
+#if DETECT_WAITER_LEAKS
+	++free_waiters_count;
+#endif
+}
+
+static waiter *free_waiters_pop (void) {
+	waiter *w;
+	uintptr_t tip;
+	tip = atomic_load_explicit (&free_waiters, memory_order_relaxed);
+	while ((w = (waiter *) PTR (tip))) {
+		if (atomic_compare_exchange_weak_explicit (&free_waiters, &tip,
+							   ABA (w->next_free, TAG (tip) + 1),
+							   memory_order_acquire,
+							   memory_order_relaxed))
+			break;
+		pthread_pause_np ();
+	}
+#if DETECT_WAITER_LEAKS
+	if (w)
+		--free_waiters_count;
+#endif
+	return (w);
+}
+
+static bool free_waiters_populate (void) {
+	int n;
+	if (IsNetbsd ()) {
+		// netbsd semaphores are file descriptors
+		n = 1;
+	} else {
+		// don't create too much fork() overhead
+		n = 16;
+	}
+	waiter *waiters = mmap (0, n * sizeof(waiter),
+				PROT_READ | PROT_WRITE,
+				MAP_PRIVATE | MAP_ANONYMOUS,
+				-1, 0);
+	if (waiters == MAP_FAILED)
+		return (false);
+	for (size_t i = 0; i < n; ++i) {
+		waiter *w = &waiters[i];
+#if NSYNC_DEBUG
+		w->tag = WAITER_TAG;
+		w->nw.tag = NSYNC_WAITER_TAG;
+#endif
+		if (!nsync_mu_semaphore_init (&w->sem)) {
+			if (!i) {
+				// netbsd can run out of semaphores
+				munmap (waiters, n * sizeof (waiter));
+				return (false);
+			}
+			break;
+		}
+		w->nw.sem = &w->sem;
+		dll_init (&w->nw.q);
+		w->nw.flags = NSYNC_WAITER_FLAG_MUCV;
+		dll_init (&w->same_condition);
+		free_waiters_push (w);
+		all_waiters_push (w);
+	}
+	return (true);
 }
 
 /* -------------------------------- */
 
-static struct Dll *free_waiters = NULL;
-
-/* free_waiters points to a doubly-linked list of free waiter structs. */
-nsync_atomic_uint32_ free_waiters_mu; /* spinlock; protects free_waiters */
-
-#define waiter_for_thread __get_tls()->tib_nsync
-
-void nsync_waiter_destroy (void *v) {
-	waiter *w = (waiter *) v;
-	/* Reset waiter_for_thread in case another thread-local variable reuses
-	   the waiter in its destructor while the waiter is taken by the other
-	   thread from free_waiters. This can happen as the destruction order
-	   of thread-local variables can be arbitrary in some platform e.g.
-	   POSIX. */
-	waiter_for_thread = NULL;
-	IGNORE_RACES_START ();
-	ASSERT ((w->flags & (WAITER_RESERVED|WAITER_IN_USE)) == WAITER_RESERVED);
-	w->flags &= ~WAITER_RESERVED;
-	nsync_spin_test_and_set_ (&free_waiters_mu, 1, 1, 0);
-	dll_make_first (&free_waiters, &w->nw.q);
-	ATM_STORE_REL (&free_waiters_mu, 0); /* release store */
-	IGNORE_RACES_END ();
-}
-
 /* Return a pointer to an unused waiter struct.
    Ensures that the enclosed timer is stopped and its channel drained. */
 waiter *nsync_waiter_new_ (void) {
-	struct Dll *q;
-	waiter *tw;
 	waiter *w;
-	tw = waiter_for_thread;
-	w = tw;
+	waiter *tw;
+	bool out_of_semaphores = false;
+	w = tw = get_waiter_for_thread ();
 	if (w == NULL || (w->flags & (WAITER_RESERVED|WAITER_IN_USE)) != WAITER_RESERVED) {
-		w = NULL;
-		nsync_spin_test_and_set_ (&free_waiters_mu, 1, 1, 0);
-		q = dll_first (free_waiters);
-		if (q != NULL) { /* If free list is non-empty, dequeue an item. */
-			dll_remove (&free_waiters, q);
-			w = DLL_WAITER (q);
-		}
-		ATM_STORE_REL (&free_waiters_mu, 0); /* release store */
-		if (w == NULL) { /* If free list was empty, allocate an item. */
-			w = (waiter *) nsync_malloc (sizeof (*w));
-			w->tag = WAITER_TAG;
-			w->nw.tag = NSYNC_WAITER_TAG;
-			nsync_mu_semaphore_init (&w->sem);
-			w->nw.sem = &w->sem;
-			dll_init (&w->nw.q);
-			NSYNC_ATOMIC_UINT32_STORE_ (&w->nw.waiting, 0);
-			w->nw.flags = NSYNC_WAITER_FLAG_MUCV;
-			ATM_STORE (&w->remove_count, 0);
-			dll_init (&w->same_condition);
-			w->flags = 0;
+		while (!(w = free_waiters_pop ())) {
+			if (!out_of_semaphores)
+				if (!free_waiters_populate ())
+					out_of_semaphores = true;
+			if (out_of_semaphores)
+				pthread_yield_np ();
 		}
 		if (tw == NULL) {
-			w->flags |= WAITER_RESERVED;
-			waiter_for_thread = w;
+			if (set_waiter_for_thread (w))
+				w->flags |= WAITER_RESERVED;
 		}
 	}
 	w->flags |= WAITER_IN_USE;
@@ -244,16 +304,75 @@ waiter *nsync_waiter_new_ (void) {
 /* Return an unused waiter struct *w to the free pool. */
 void nsync_waiter_free_ (waiter *w) {
 	ASSERT ((w->flags & WAITER_IN_USE) != 0);
+	w->wipe_mu = NULL;
+	w->wipe_cv = NULL;
 	w->flags &= ~WAITER_IN_USE;
 	if ((w->flags & WAITER_RESERVED) == 0) {
-		nsync_spin_test_and_set_ (&free_waiters_mu, 1, 1, 0);
-		dll_make_first (&free_waiters, &w->nw.q);
-		ATM_STORE_REL (&free_waiters_mu, 0); /* release store */
-		if (w == waiter_for_thread)
-			waiter_for_thread = 0;
+		if (w == get_waiter_for_thread ())
+			set_waiter_for_thread (0);
+		free_waiters_push (w);
 	}
 }
 
+/* Destroys waiter associated with dead thread. */
+void nsync_waiter_destroy_ (void *v) {
+	waiter *w = (waiter *) v;
+	ASSERT ((w->flags & (WAITER_RESERVED|WAITER_IN_USE)) == WAITER_RESERVED);
+	w->flags &= ~WAITER_RESERVED;
+	free_waiters_push (w);
+}
+
+/* Ravages nsync waiters/locks/conds after fork(). */
+void nsync_waiter_wipe_ (void) {
+	int n = 0;
+	waiter *w;
+	waiter *next;
+	waiter *prev = 0;
+	waiter *wall = atomic_load_explicit (&all_waiters, memory_order_relaxed);
+	for (w = wall; w; w = w->next_all)
+		nsync_mu_semaphore_destroy (&w->sem);
+	for (w = wall; w; w = next) {
+		next = w->next_all;
+		w->flags = 0;
+#if NSYNC_DEBUG
+		w->tag = WAITER_TAG;
+		w->nw.tag = NSYNC_WAITER_TAG;
+#endif
+		w->nw.flags = NSYNC_WAITER_FLAG_MUCV;
+		atomic_init(&w->nw.waiting, 0);
+		w->l_type = 0;
+		w->cond.f = 0;
+		w->cond.v = 0;
+		w->cond.eq = 0;
+		dll_init (&w->same_condition);
+		if (w->wipe_mu) {
+			atomic_init(&w->wipe_mu->word, 0);
+			w->wipe_mu->waiters = 0;
+		}
+		if (w->wipe_cv) {
+			atomic_init(&w->wipe_cv->word, 0);
+			w->wipe_cv->waiters = 0;
+		}
+		if (!nsync_mu_semaphore_init (&w->sem))
+			continue;  /* leak it */
+		w->next_free = prev;
+		w->next_all = prev;
+		prev = w;
+		++n;
+	}
+#if DETECT_WAITER_LEAKS
+	atomic_init (&all_waiters_count, n);
+	atomic_init (&free_waiters_count, n);
+#else
+	(void)n;
+#endif
+	atomic_init (&free_waiters, prev);
+	atomic_init (&all_waiters, prev);
+	for (struct Dll *e = dll_first (_pthread_list); e;
+	     e = dll_next (_pthread_list, e))
+		POSIXTHREAD_CONTAINER (e)->tib->tib_nsync = 0;
+}
+
 /* ====================================================================================== */
 
 /* writer_type points to a lock_type that describes how to manipulate a mu for a writer. */
diff --git a/third_party/nsync/common.internal.h b/third_party/nsync/common.internal.h
index 90205e102..e24d1071a 100644
--- a/third_party/nsync/common.internal.h
+++ b/third_party/nsync/common.internal.h
@@ -9,34 +9,21 @@
 #include "third_party/nsync/mu_semaphore.h"
 #include "third_party/nsync/note.h"
 #include "third_party/nsync/time.h"
+#include "third_party/nsync/defs.h"
 #include "third_party/nsync/wait_s.internal.h"
 COSMOPOLITAN_C_START_
 
-#ifdef MODE_DBG
-#define NSYNC_DEBUG 1
-#else
-#define NSYNC_DEBUG 0
-#endif
-
 /* Yield the CPU. Platform specific. */
 void nsync_yield_(void);
 
 /* Retrieve the per-thread cache of the waiter object.  Platform specific. */
 void *nsync_per_thread_waiter_(void (*dest)(void *));
 
-/* Used in spinloops to delay resumption of the loop.
-   Usage:
-       unsigned attempts = 0;
-       while (try_something) {
-          attempts = nsync_spin_delay_ (attempts);
-       } */
-unsigned nsync_spin_delay_(unsigned attempts);
-
 /* Spin until (*w & test) == 0, then atomically perform *w = ((*w | set) &
    ~clear), perform an acquire barrier, and return the previous value of *w.
    */
 uint32_t nsync_spin_test_and_set_(nsync_atomic_uint32_ *w, uint32_t test,
-                                  uint32_t set, uint32_t clear);
+                                  uint32_t set, uint32_t clear, void *symbol);
 
 /* Abort after printing the nul-temrinated string s[]. */
 void nsync_panic_(const char *s) wontreturn;
@@ -162,7 +149,7 @@ extern lock_type *nsync_reader_type_;
 
 /* ---------- */
 
-/* Hold a pair of  condition function and its argument. */
+/* Hold a pair of condition function and its argument. */
 struct wait_condition_s {
   int (*f)(const void *v);
   const void *v;
@@ -199,17 +186,21 @@ struct wait_condition_s {
     ATM_STORE_REL (&w.waiting, 0);
     nsync_mu_semaphore_v (&w.sem); */
 typedef struct waiter_s {
-  uint32_t tag; /* debug DLL_NSYNC_WAITER, DLL_WAITER, DLL_WAITER_SAMECOND */
-  int flags;    /* see WAITER_* bits below */
-  nsync_semaphore sem;       /* Thread waits on this semaphore. */
-  struct nsync_waiter_s nw;  /* An embedded nsync_waiter_s. */
-  struct nsync_mu_s_ *cv_mu; /* pointer to nsync_mu associated with a cv wait */
-  lock_type
-      *l_type; /* Lock type of the mu, or nil if not associated with a mu. */
-  nsync_atomic_uint32_ remove_count; /* count of removals from queue */
+#if NSYNC_DEBUG
+  uint32_t tag;                      /* Debug DLL_NSYNC_WAITER, DLL_WAITER, DLL_WAITER_SAMECOND. */
+#endif
+  int flags;                         /* See WAITER_* bits below. */
+  nsync_atomic_uint32_ remove_count; /* Monotonic count of removals from queue. */
+  nsync_semaphore sem;               /* Thread waits on this semaphore. */
+  struct nsync_waiter_s nw;          /* An embedded nsync_waiter_s. */
+  struct nsync_mu_s_ *cv_mu;         /* Pointer to nsync_mu associated with a cv wait. */
+  lock_type *l_type;                 /* Lock type of the mu, or nil if not associated with a mu. */
   struct wait_condition_s cond;      /* A condition on which to acquire a mu. */
-  struct Dll same_condition;         /* Links neighbours in nw.q with same
-                                        non-nil condition. */
+  struct Dll same_condition;         /* Links neighbours in nw.q with same non-nil condition. */
+  struct waiter_s * next_all;
+  struct waiter_s * next_free;
+  struct nsync_mu_s_ *wipe_mu;
+  struct nsync_cv_s_ *wipe_cv;
 } waiter;
 static const uint32_t WAITER_TAG = 0x0590239f;
 static const uint32_t NSYNC_WAITER_TAG = 0x726d2ba9;
@@ -218,7 +209,7 @@ static const uint32_t NSYNC_WAITER_TAG = 0x726d2ba9;
   0x1 /* waiter reserved by a thread, even when not in use */
 #define WAITER_IN_USE 0x2 /* waiter in use by a thread */
 
-#define ASSERT(x) npassert(x)
+#define ASSERT(x) unassert(x)
 
 /* Return a pointer to the nsync_waiter_s containing struct Dll *e. */
 #define DLL_NSYNC_WAITER(e)                 \
@@ -253,6 +244,7 @@ void nsync_waiter_free_(waiter *w);
    discipline.  */
 struct nsync_note_s_ {
   struct Dll parent_child_link; /* parent's children, under parent->note_mu  */
+  int clock; /* system clock that should be used */
   int expiry_time_valid; /* whether expiry_time is valid; r/o after init */
   nsync_time
       expiry_time;  /* expiry time, if expiry_time_valid != 0; r/o after init */
@@ -273,7 +265,7 @@ void nsync_mu_unlock_slow_(nsync_mu *mu, lock_type *l_type);
 struct Dll *nsync_remove_from_mu_queue_(struct Dll *mu_queue, struct Dll *e);
 void nsync_maybe_merge_conditions_(struct Dll *p, struct Dll *n);
 nsync_time nsync_note_notified_deadline_(nsync_note n);
-int nsync_sem_wait_with_cancel_(waiter *w, nsync_time abs_deadline,
+int nsync_sem_wait_with_cancel_(waiter *w, int clock, nsync_time abs_deadline,
                                 nsync_note cancel_note);
 
 COSMOPOLITAN_C_END_
diff --git a/third_party/nsync/compat.S b/third_party/nsync/compat.S
index bcd4d8cd3..5d8b382cc 100644
--- a/third_party/nsync/compat.S
+++ b/third_party/nsync/compat.S
@@ -17,11 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timespec.h"
-#include "libc/macros.internal.h"
-
-nsync_time_now:
-	jmp	timespec_real
-	.endfn	nsync_time_now,globl
+#include "libc/macros.h"
 
 nsync_time_add:
 	jmp	timespec_add
diff --git a/third_party/nsync/counter.h b/third_party/nsync/counter.h
index 227fa4333..8b99335bc 100644
--- a/third_party/nsync/counter.h
+++ b/third_party/nsync/counter.h
@@ -33,7 +33,7 @@ uint32_t nsync_counter_value(nsync_counter c);
    a waiter may have been woken due to the counter reaching zero.
    If abs_deadline==nsync_time_no_deadline, the deadline
    is far in the future. */
-uint32_t nsync_counter_wait(nsync_counter c, nsync_time abs_deadline);
+uint32_t nsync_counter_wait(nsync_counter c, int clock, nsync_time abs_deadline);
 
 COSMOPOLITAN_C_END_
 #endif /* NSYNC_COUNTER_H_ */
diff --git a/third_party/nsync/cv.h b/third_party/nsync/cv.h
index 4209a7909..a02b587b8 100644
--- a/third_party/nsync/cv.h
+++ b/third_party/nsync/cv.h
@@ -144,7 +144,7 @@ int nsync_cv_wait(nsync_cv *cv, nsync_mu *mu);
    mostly in tests and trivial examples than they are in real
    programmes. */
 int nsync_cv_wait_with_deadline(nsync_cv *cv, nsync_mu *mu,
-                                nsync_time abs_deadline,
+                                int clock, nsync_time abs_deadline,
                                 struct nsync_note_s_ *cancel_note);
 
 /* Like nsync_cv_wait_with_deadline(), but allow an arbitrary lock *v to be
@@ -152,7 +152,7 @@ int nsync_cv_wait_with_deadline(nsync_cv *cv, nsync_mu *mu,
 int nsync_cv_wait_with_deadline_generic(nsync_cv *cv, void *mu,
                                         void (*lock)(void *),
                                         void (*unlock)(void *),
-                                        nsync_time abs_deadline,
+                                        int clock, nsync_time abs_deadline,
                                         struct nsync_note_s_ *cancel_note);
 
 COSMOPOLITAN_C_END_
diff --git a/third_party/nsync/defs.h b/third_party/nsync/defs.h
new file mode 100644
index 000000000..73b5c0752
--- /dev/null
+++ b/third_party/nsync/defs.h
@@ -0,0 +1,12 @@
+#ifndef COSMOPOLITAN_THIRD_PARTY_NSYNC_DEFS_H_
+#define COSMOPOLITAN_THIRD_PARTY_NSYNC_DEFS_H_
+COSMOPOLITAN_C_START_
+
+#ifdef MODE_DBG
+#define NSYNC_DEBUG 1
+#else
+#define NSYNC_DEBUG 0
+#endif
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_THIRD_PARTY_NSYNC_DEFS_H_ */
diff --git a/third_party/nsync/futex.c b/third_party/nsync/futex.c
deleted file mode 100644
index feb8c49ef..000000000
--- a/third_party/nsync/futex.c
+++ /dev/null
@@ -1,385 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2022 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/sysv/consts/futex.h"
-#include "libc/assert.h"
-#include "libc/atomic.h"
-#include "libc/calls/calls.h"
-#include "libc/calls/internal.h"
-#include "libc/calls/sig.internal.h"
-#include "libc/calls/state.internal.h"
-#include "libc/calls/struct/sigset.h"
-#include "libc/calls/struct/sigset.internal.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/calls/struct/timespec.internal.h"
-#include "libc/calls/syscall_support-nt.internal.h"
-#include "libc/cosmo.h"
-#include "libc/dce.h"
-#include "libc/errno.h"
-#include "libc/intrin/atomic.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/intrin/ulock.h"
-#include "libc/intrin/weaken.h"
-#include "libc/limits.h"
-#include "libc/nexgen32e/vendor.internal.h"
-#include "libc/nt/runtime.h"
-#include "libc/nt/synchronization.h"
-#include "libc/runtime/clktck.h"
-#include "libc/sysv/consts/clock.h"
-#include "libc/sysv/consts/sicode.h"
-#include "libc/sysv/consts/timer.h"
-#include "libc/sysv/errfuns.h"
-#include "libc/thread/freebsd.internal.h"
-#include "libc/thread/posixthread.internal.h"
-#include "libc/thread/thread.h"
-#include "libc/thread/tls.h"
-#include "third_party/nsync/atomic.h"
-#include "third_party/nsync/common.internal.h"
-#include "third_party/nsync/futex.internal.h"
-#include "third_party/nsync/time.h"
-
-#define FUTEX_WAIT_BITS_ FUTEX_BITSET_MATCH_ANY
-
-errno_t _futex (atomic_int *, int, int, const struct timespec *, int *, int);
-errno_t _futex_wake (atomic_int *, int, int) asm ("_futex");
-int sys_futex_cp (atomic_int *, int, int, const struct timespec *, int *, int);
-
-static struct NsyncFutex {
-	atomic_uint once;
-	int FUTEX_WAIT_;
-	int FUTEX_PRIVATE_FLAG_;
-	bool is_supported;
-	bool timeout_is_relative;
-} nsync_futex_;
-
-static void nsync_futex_init_ (void) {
-	int e;
-	atomic_int x;
-
-	nsync_futex_.FUTEX_WAIT_ = FUTEX_WAIT;
-
-	if (IsWindows ()) {
-		nsync_futex_.is_supported = true;
-		return;
-	}
-
-	if (IsXnu ()) {
-		nsync_futex_.is_supported = true;
-		nsync_futex_.timeout_is_relative = true;
-		return;
-	}
-
-	if (IsFreebsd ()) {
-		nsync_futex_.is_supported = true;
-		nsync_futex_.FUTEX_PRIVATE_FLAG_ = FUTEX_PRIVATE_FLAG;
-		return;
-	}
-
-        if (!(nsync_futex_.is_supported = IsLinux () || IsOpenbsd ())) {
-		return;
-	}
-
-	// In our testing, we found that the monotonic clock on various
-	// popular systems (such as Linux, and some BSD variants) was no
-	// better behaved than the realtime clock, and routinely took
-	// large steps backwards, especially on multiprocessors. Given
-	// that "monotonic" doesn't seem to mean what it says,
-	// implementers of nsync_time might consider retaining the
-	// simplicity of a single epoch within an address space, by
-	// configuring any time synchronization mechanism (like ntp) to
-	// adjust for leap seconds by adjusting the rate, rather than
-	// with a backwards step.
-	e = errno;
-	atomic_store_explicit (&x, 0, memory_order_relaxed);
-	if (IsLinux () &&
-	    _futex (&x, FUTEX_WAIT_BITSET | FUTEX_CLOCK_REALTIME,
-		    1, 0, 0, FUTEX_BITSET_MATCH_ANY) == -EAGAIN) {
-		nsync_futex_.FUTEX_WAIT_ =
-			FUTEX_WAIT_BITSET | FUTEX_CLOCK_REALTIME;
-		nsync_futex_.FUTEX_PRIVATE_FLAG_ = FUTEX_PRIVATE_FLAG;
-	} else if (!IsTiny () && IsLinux () &&
-		   _futex (&x, FUTEX_WAIT_BITSET, 1, 0, 0,
-			   FUTEX_BITSET_MATCH_ANY) == -EAGAIN) {
-		nsync_futex_.FUTEX_WAIT_ = FUTEX_WAIT_BITSET;
-		nsync_futex_.FUTEX_PRIVATE_FLAG_ = FUTEX_PRIVATE_FLAG;
-	} else if (IsOpenbsd () ||
-		   (!IsTiny () && IsLinux () &&
-		    !_futex_wake (&x, FUTEX_WAKE_PRIVATE, 1))) {
-		nsync_futex_.FUTEX_WAIT_ = FUTEX_WAIT;
-		nsync_futex_.FUTEX_PRIVATE_FLAG_ = FUTEX_PRIVATE_FLAG;
-		nsync_futex_.timeout_is_relative = true;
-	} else {
-		nsync_futex_.FUTEX_WAIT_ = FUTEX_WAIT;
-		nsync_futex_.timeout_is_relative = true;
-	}
-	errno = e;
-}
-
-static int nsync_futex_polyfill_ (atomic_int *w, int expect, struct timespec *abstime) {
-	for (;;) {
-		if (atomic_load_explicit (w, memory_order_acquire) != expect) {
-			return 0;
-		}
-		if (_weaken (pthread_testcancel_np) &&
-		    _weaken (pthread_testcancel_np) ()) {
-			return -ETIMEDOUT;
-		}
-		if (abstime && timespec_cmp (timespec_real (), *abstime) >= 0) {
-			return -ETIMEDOUT;
-		}
-		pthread_yield_np ();
-	}
-}
-
-static int nsync_futex_wait_win32_ (atomic_int *w, int expect, char pshare,
-				    const struct timespec *timeout,
-				    struct PosixThread *pt,
-				    sigset_t waitmask) {
-	int sig;
-	bool32 ok;
-	struct timespec deadline, wait, now;
-
-	if (timeout) {
-		deadline = *timeout;
-	} else {
-		deadline = timespec_max;
-	}
-
-	for (;;) {
-		now = timespec_real ();
-		if (timespec_cmp (now, deadline) > 0) {
-			return etimedout();
-		}
-		wait = timespec_sub (deadline, now);
-		if (atomic_load_explicit (w, memory_order_acquire) != expect) {
-			return 0;
-		}
-		if (pt) {
-			if (_check_cancel () == -1) {
-				return -1; /* ECANCELED */
-			}
-			if ((sig = __sig_get (waitmask))) {
-				__sig_relay (sig, SI_KERNEL, waitmask);
-				if (_check_cancel () == -1) {
-					return -1; /* ECANCELED */
-				}
-				return eintr ();
-			}
-			pt->pt_blkmask = waitmask;
-			atomic_store_explicit (&pt->pt_blocker, w, memory_order_release);
-		}
-		ok = WaitOnAddress (w, &expect, sizeof(int), timespec_tomillis (wait));
-		if (pt) {
-			/* __sig_cancel wakes our futex without changing `w` after enqueing signals */
-			atomic_store_explicit (&pt->pt_blocker, 0, memory_order_release);
-			if (ok && atomic_load_explicit (w, memory_order_acquire) == expect && (sig = __sig_get (waitmask))) {
-				__sig_relay (sig, SI_KERNEL, waitmask);
-				if (_check_cancel () == -1) {
-					return -1; /* ECANCELED */
-				}
-				return eintr ();
-			}
-		}
-		if (ok) {
-			return 0;
-		} else {
-			ASSERT (GetLastError () == ETIMEDOUT);
-		}
-	}
-}
-
-static struct timespec *nsync_futex_timeout_ (struct timespec *memory,
-					      const struct timespec *abstime) {
-	struct timespec now;
-	if (!abstime) {
-		return 0;
-	} else if (!nsync_futex_.timeout_is_relative) {
-		*memory = *abstime;
-		return memory;
-	} else {
-		now = timespec_real ();
-		*memory = timespec_subz (*abstime, now);
-		return memory;
-	}
-}
-
-int nsync_futex_wait_ (atomic_int *w, int expect, char pshare, const struct timespec *abstime) {
-	int e, rc, op;
-	struct CosmoTib *tib;
-	struct PosixThread *pt;
-	struct timespec tsmem, *timeout;
-
-	cosmo_once (&nsync_futex_.once, nsync_futex_init_);
-
-	op = nsync_futex_.FUTEX_WAIT_;
-	if (pshare == PTHREAD_PROCESS_PRIVATE) {
-		op |= nsync_futex_.FUTEX_PRIVATE_FLAG_;
-	}
-
-	if (abstime && timespec_cmp (*abstime, timespec_zero) <= 0) {
-		rc = -ETIMEDOUT;
-		goto Finished;
-	}
-
-	if (atomic_load_explicit (w, memory_order_acquire) != expect) {
-		rc = -EAGAIN;
-		goto Finished;
-	}
-
-	timeout = nsync_futex_timeout_ (&tsmem, abstime);
-
-	LOCKTRACE ("futex(%t [%d], %s, %#x, %s) → ...",
-		   w, atomic_load_explicit (w, memory_order_relaxed),
-		   DescribeFutexOp (op), expect,
-		   DescribeTimespec (0, timeout));
-
-	tib = __get_tls();
-	pt = (struct PosixThread *)tib->tib_pthread;
-
-	if (nsync_futex_.is_supported) {
-		e = errno;
-		if (IsWindows ()) {
-			// Windows 8 futexes don't support multiple processes :(
-			if (pshare) goto Polyfill;
-			sigset_t m = __sig_block ();
-			rc = nsync_futex_wait_win32_ (w, expect, pshare, timeout, pt, m);
-			__sig_unblock (m);
-		} else if (IsXnu ()) {
-			uint32_t op, us;
-			if (pshare) {
-				op = UL_COMPARE_AND_WAIT_SHARED;
-			} else {
-				op = UL_COMPARE_AND_WAIT;
-			}
-			if (timeout) {
-				us = timespec_tomicros (*timeout);
-			} else {
-				us = -1u;
-			}
-			rc = ulock_wait (op, w, expect, us);
-			if (rc > 0) rc = 0; // don't care about #waiters
-		} else if (IsFreebsd ()) {
-			rc = sys_umtx_timedwait_uint (w, expect, pshare, timeout);
-		} else {
-			if (IsOpenbsd()) {
-				// OpenBSD 6.8 futex() returns errors as
-				// positive numbers, without setting CF.
-				// This irregularity is fixed in 7.2 but
-				// unfortunately OpenBSD futex() defines
-				// its own ECANCELED condition, and that
-				// overlaps with our system call wrapper
-				if (pt) pt->pt_flags &= ~PT_OPENBSD_KLUDGE;
-			}
-			rc = sys_futex_cp (w, op, expect, timeout, 0, FUTEX_WAIT_BITS_);
-			if (IsOpenbsd()) {
-				// Handle the OpenBSD 6.x irregularity.
-				if (rc > 0) {
-					errno = rc;
-					rc = -1;
-				}
-				// Check if ECANCELED came from the kernel
-				// because a SA_RESTART signal handler was
-				// invoked, such as our SIGTHR callback.
-				if (rc == -1 && errno == ECANCELED &&
-				    pt && (~pt->pt_flags & PT_OPENBSD_KLUDGE)) {
-					errno = EINTR;
-				}
-			}
-		}
-		if (rc == -1) {
-			rc = -errno;
-			errno = e;
-		}
-	} else {
-	Polyfill:
-		rc = nsync_futex_polyfill_ (w, expect, timeout);
-	}
-
-Finished:
-	STRACE ("futex(%t [%d], %s, %#x, %s) → %s",
-		w, atomic_load_explicit (w, memory_order_relaxed),
-		DescribeFutexOp (op), expect,
-		DescribeTimespec (0, abstime),
-		DescribeErrno (rc));
-
-	return rc;
-}
-
-int nsync_futex_wake_ (atomic_int *w, int count, char pshare) {
-	int rc, op, fop;
-
-	ASSERT (count == 1 || count == INT_MAX);
-
-	cosmo_once (&nsync_futex_.once, nsync_futex_init_);
-
-	op = FUTEX_WAKE;
-	if (pshare == PTHREAD_PROCESS_PRIVATE) {
-		op |= nsync_futex_.FUTEX_PRIVATE_FLAG_;
-	}
-
-	if (nsync_futex_.is_supported) {
-		if (IsWindows ()) {
-			if (pshare) {
-				goto Polyfill;
-			}
-			if (count == 1) {
-				WakeByAddressSingle (w);
-			} else {
-				WakeByAddressAll (w);
-			}
-			rc = 0;
-		} else if (IsXnu ()) {
-			uint32_t op;
-			if (pshare) {
-				op = UL_COMPARE_AND_WAIT_SHARED;
-			} else {
-				op = UL_COMPARE_AND_WAIT;
-			}
-			if (count > 1) {
-				op |= ULF_WAKE_ALL;
-			}
-			rc = ulock_wake (op, w, 0);
-			ASSERT (!rc || rc == -ENOENT);
-			if (!rc) {
-				rc = 1;
-			} else if (rc == -ENOENT) {
-				rc = 0;
-			}
-		} else if (IsFreebsd ()) {
-			if (pshare) {
-				fop = UMTX_OP_WAKE;
-			} else {
-				fop = UMTX_OP_WAKE_PRIVATE;
-			}
-			rc = _futex_wake (w, fop, count);
-		} else {
-			rc = _futex_wake (w, op, count);
-		}
-	} else {
-	Polyfill:
-		pthread_yield_np ();
-		rc = 0;
-	}
-
-	STRACE ("futex(%t [%d], %s, %d) → %d woken",
-		w, atomic_load_explicit (w, memory_order_relaxed),
-		DescribeFutexOp (op), count, rc);
-
-	return rc;
-}
diff --git a/third_party/nsync/futex.internal.h b/third_party/nsync/futex.internal.h
deleted file mode 100644
index 1128479c5..000000000
--- a/third_party/nsync/futex.internal.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef NSYNC_FUTEX_INTERNAL_H_
-#define NSYNC_FUTEX_INTERNAL_H_
-#include "libc/calls/struct/timespec.h"
-#include "libc/dce.h"
-COSMOPOLITAN_C_START_
-
-int nsync_futex_wake_(_Atomic(int) *, int, char);
-int nsync_futex_wait_(_Atomic(int) *, int, char, const struct timespec *);
-
-COSMOPOLITAN_C_END_
-#endif /* NSYNC_FUTEX_INTERNAL_H_ */
diff --git a/third_party/nsync/mem/BUILD.mk b/third_party/nsync/mem/BUILD.mk
index aa5c3c1e3..a947a2e18 100644
--- a/third_party/nsync/mem/BUILD.mk
+++ b/third_party/nsync/mem/BUILD.mk
@@ -49,6 +49,13 @@ $(THIRD_PARTY_NSYNC_MEM_A_OBJS): private		\
 			-Wframe-larger-than=4096	\
 			-Walloca-larger-than=4096
 
+# avoid the legacy sse decoding penalty on avx systems
+ifeq ($(MODE),)
+$(THIRD_PARTY_NSYNC_MEM_A_OBJS): private		\
+		COPTS +=				\
+			-mgeneral-regs-only
+endif
+
 THIRD_PARTY_NSYNC_MEM_LIBS = $(foreach x,$(THIRD_PARTY_NSYNC_MEM_ARTIFACTS),$($(x)))
 THIRD_PARTY_NSYNC_MEM_SRCS = $(foreach x,$(THIRD_PARTY_NSYNC_MEM_ARTIFACTS),$($(x)_SRCS))
 THIRD_PARTY_NSYNC_MEM_CHECKS = $(foreach x,$(THIRD_PARTY_NSYNC_MEM_ARTIFACTS),$($(x)_CHECKS))
diff --git a/third_party/nsync/mem/nsync_counter.c b/third_party/nsync/mem/nsync_counter.c
index c508797fc..0eccec105 100644
--- a/third_party/nsync/mem/nsync_counter.c
+++ b/third_party/nsync/mem/nsync_counter.c
@@ -19,6 +19,7 @@
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "third_party/nsync/atomic.h"
+#include "third_party/nsync/time.h"
 #include "third_party/nsync/atomic.internal.h"
 #include "third_party/nsync/common.internal.h"
 #include "third_party/nsync/counter.h"
@@ -94,13 +95,13 @@ uint32_t nsync_counter_value (nsync_counter c) {
 	return (result);
 }
 
-uint32_t nsync_counter_wait (nsync_counter c, nsync_time abs_deadline) {
+uint32_t nsync_counter_wait (nsync_counter c, int clock, nsync_time abs_deadline) {
 	struct nsync_waitable_s waitable;
 	struct nsync_waitable_s *pwaitable = &waitable;
 	uint32_t result = 0;
 	waitable.v = c;
 	waitable.funcs = &nsync_counter_waitable_funcs;
-	if (nsync_wait_n (NULL, NULL, NULL, abs_deadline, 1, &pwaitable) != 0) {
+	if (nsync_wait_n (NULL, NULL, NULL, clock, abs_deadline, 1, &pwaitable) != 0) {
 		IGNORE_RACES_START ();
 		result = ATM_LOAD_ACQ (&c->value);
 		IGNORE_RACES_END ();
diff --git a/third_party/nsync/mem/nsync_cv.c b/third_party/nsync/mem/nsync_cv.c
index 926379340..c871c581d 100644
--- a/third_party/nsync/mem/nsync_cv.c
+++ b/third_party/nsync/mem/nsync_cv.c
@@ -175,6 +175,7 @@ struct nsync_cv_wait_with_deadline_s {
 	void *pmu;
 	void (*lock) (void *);
 	nsync_mu *cv_mu;
+	int clock;
 	nsync_time abs_deadline;
 	nsync_note cancel_note;
 	waiter *w;
@@ -187,13 +188,13 @@ static int nsync_cv_wait_with_deadline_impl_ (struct nsync_cv_wait_with_deadline
 	IGNORE_RACES_START ();
 	while (ATM_LOAD_ACQ (&c->w->nw.waiting) != 0) { /* acquire load */
 		if (c->sem_outcome == 0) {
-			c->sem_outcome = nsync_sem_wait_with_cancel_ (c->w, c->abs_deadline, c->cancel_note);
+			c->sem_outcome = nsync_sem_wait_with_cancel_ (c->w, c->clock, c->abs_deadline, c->cancel_note);
 		}
 		if (c->sem_outcome != 0 && ATM_LOAD (&c->w->nw.waiting) != 0) {
 			/* A timeout or cancellation occurred, and no wakeup.
 			   Acquire *pcv's spinlock, and confirm.  */
 			c->old_word = nsync_spin_test_and_set_ (&c->pcv->word, CV_SPINLOCK,
-								CV_SPINLOCK, 0);
+								CV_SPINLOCK, 0, c->cv_mu);
 			/* Check that w wasn't removed from the queue after we
 			   checked above, but before we acquired the spinlock.
 			   The test of remove_count confirms that the waiter *w
@@ -226,14 +227,16 @@ static int nsync_cv_wait_with_deadline_impl_ (struct nsync_cv_wait_with_deadline
                            has not yet set the waiting field to zero; a
                            cancellation or timeout may prevent this thread
                            from blocking above on the semaphore.  */
-			attempts = nsync_spin_delay_ (attempts);
+			attempts = pthread_delay_np (c->cv_mu, attempts);
 		}
 	}
 	if (c->cv_mu != NULL && c->w->cv_mu == NULL) { /* waiter was moved to *pmu's queue, and woken. */
 		/* Requeue on *pmu using existing waiter struct; current thread
 		   is the designated waker.  */
 		nsync_mu_lock_slow_ (c->cv_mu, c->w, MU_DESIG_WAKER, c->w->l_type);
+		nsync_waiter_free_ (c->w);
 	} else {
+		nsync_waiter_free_ (c->w);
 		/* Traditional case: We've woken from the cv, and need to reacquire *pmu. */
 		if (c->is_reader_mu) {
 			nsync_mu_rlock (c->cv_mu);
@@ -241,7 +244,6 @@ static int nsync_cv_wait_with_deadline_impl_ (struct nsync_cv_wait_with_deadline
 			(*c->lock) (c->pmu);
 		}
 	}
-	nsync_waiter_free_ (c->w);
 	IGNORE_RACES_END ();
 	return (outcome);
 }
@@ -277,13 +279,16 @@ static void nsync_cv_wait_with_deadline_unwind_ (void *arg) {
    programmes. */
 int nsync_cv_wait_with_deadline_generic (nsync_cv *pcv, void *pmu,
 					 void (*lock) (void *), void (*unlock) (void *),
-					 nsync_time abs_deadline,
+					 int clock, nsync_time abs_deadline,
 					 nsync_note cancel_note) {
 	int outcome;
 	struct nsync_cv_wait_with_deadline_s c;
 	IGNORE_RACES_START ();
 
 	c.w = nsync_waiter_new_ ();
+	c.w->wipe_cv = pcv;
+	c.w->wipe_mu = pmu;
+	c.clock = clock;
 	c.abs_deadline = abs_deadline;
 	c.cancel_note = cancel_note;
 	c.cv_mu = NULL;
@@ -323,7 +328,7 @@ int nsync_cv_wait_with_deadline_generic (nsync_cv *pcv, void *pmu,
 	}
 
 	/* acquire spinlock, set non-empty */
-	c.old_word = nsync_spin_test_and_set_ (&pcv->word, CV_SPINLOCK, CV_SPINLOCK|CV_NON_EMPTY, 0);
+	c.old_word = nsync_spin_test_and_set_ (&pcv->word, CV_SPINLOCK, CV_SPINLOCK|CV_NON_EMPTY, 0, pmu);
 	dll_make_last (&pcv->waiters, &c.w->nw.q);
 	c.remove_count = ATM_LOAD (&c.w->remove_count);
 	/* Release the spin lock. */
@@ -355,7 +360,7 @@ void nsync_cv_signal (nsync_cv *pcv) {
 		int all_readers = 0;
 		/* acquire spinlock */
 		uint32_t old_word = nsync_spin_test_and_set_ (&pcv->word, CV_SPINLOCK,
-							      CV_SPINLOCK, 0);
+							      CV_SPINLOCK, 0, pcv);
 		if (!dll_is_empty (pcv->waiters)) {
 			/* Point to first waiter that enqueued itself, and
 			   detach it from all others.  */
@@ -438,7 +443,7 @@ void nsync_cv_broadcast (nsync_cv *pcv) {
 		int all_readers;
 		struct Dll *to_wake_list = NULL;   /* waiters that we will wake */
 		/* acquire spinlock */
-		nsync_spin_test_and_set_ (&pcv->word, CV_SPINLOCK, CV_SPINLOCK, 0);
+		nsync_spin_test_and_set_ (&pcv->word, CV_SPINLOCK, CV_SPINLOCK, 0, pcv);
 		p = NULL;
 		next = NULL;
 		all_readers = 1;
@@ -469,10 +474,10 @@ void nsync_cv_broadcast (nsync_cv *pcv) {
 
 /* Wait with deadline, using an nsync_mu. */
 errno_t nsync_cv_wait_with_deadline (nsync_cv *pcv, nsync_mu *pmu,
-				     nsync_time abs_deadline,
+				     int clock, nsync_time abs_deadline,
 				     nsync_note cancel_note) {
 	return (nsync_cv_wait_with_deadline_generic (pcv, pmu, &void_mu_lock,
-						     &void_mu_unlock,
+						     &void_mu_unlock, clock,
 						     abs_deadline, cancel_note));
 }
 
@@ -485,7 +490,7 @@ errno_t nsync_cv_wait_with_deadline (nsync_cv *pcv, nsync_mu *pmu,
    ECANCELED may be returned if calling POSIX thread is cancelled only when
    the PTHREAD_CANCEL_MASKED mode is in play. */
 errno_t nsync_cv_wait (nsync_cv *pcv, nsync_mu *pmu) {
-	return nsync_cv_wait_with_deadline (pcv, pmu, nsync_time_no_deadline, NULL);
+	return nsync_cv_wait_with_deadline (pcv, pmu, 0, nsync_time_no_deadline, NULL);
 }
 
 static nsync_time cv_ready_time (void *v, struct nsync_waiter_s *nw) {
@@ -497,7 +502,7 @@ static nsync_time cv_ready_time (void *v, struct nsync_waiter_s *nw) {
 static int cv_enqueue (void *v, struct nsync_waiter_s *nw) {
 	nsync_cv *pcv = (nsync_cv *) v;
 	/* acquire spinlock */
-	uint32_t old_word = nsync_spin_test_and_set_ (&pcv->word, CV_SPINLOCK, CV_SPINLOCK, 0);
+	uint32_t old_word = nsync_spin_test_and_set_ (&pcv->word, CV_SPINLOCK, CV_SPINLOCK, 0, pcv);
 	dll_make_last (&pcv->waiters, &nw->q);
 	ATM_STORE (&nw->waiting, 1);
 	/* Release spinlock. */
@@ -509,7 +514,7 @@ static int cv_dequeue (void *v, struct nsync_waiter_s *nw) {
 	nsync_cv *pcv = (nsync_cv *) v;
 	int was_queued = 0;
 	/* acquire spinlock */
-	uint32_t old_word = nsync_spin_test_and_set_ (&pcv->word, CV_SPINLOCK, CV_SPINLOCK, 0);
+	uint32_t old_word = nsync_spin_test_and_set_ (&pcv->word, CV_SPINLOCK, CV_SPINLOCK, 0, pcv);
 	if (ATM_LOAD_ACQ (&nw->waiting) != 0) {
 		dll_remove (&pcv->waiters, &nw->q);
 		ATM_STORE (&nw->waiting, 0);
diff --git a/third_party/nsync/mem/nsync_debug.c b/third_party/nsync/mem/nsync_debug.c
index 1b72c1175..8c7d7e124 100644
--- a/third_party/nsync/mem/nsync_debug.c
+++ b/third_party/nsync/mem/nsync_debug.c
@@ -20,6 +20,7 @@
 #include "third_party/nsync/common.internal.h"
 #include "third_party/nsync/mu_semaphore.h"
 #include "third_party/nsync/races.internal.h"
+#include "third_party/nsync/defs.h"
 #include "third_party/nsync/wait_s.internal.h"
 __static_yoink("nsync_notice");
 
@@ -148,15 +149,23 @@ static void emit_waiters (struct emit_buf *b, struct Dll *list) {
                 waiter *w = DLL_WAITER (p);
                 next = NULL;
                 emit_print (b, "   %i", (uintptr_t) w);
+#if NSYNC_DEBUG
                 if (w->tag != WAITER_TAG) {
                         emit_print (b, "bad WAITER_TAG %i",
                                     (uintptr_t) w->tag);
                 } else {
+#else
+		{
+#endif
                         next = dll_next (list, p);
+#if NSYNC_DEBUG
                         if (nw->tag != NSYNC_WAITER_TAG) {
                                 emit_print (b, " bad WAITER_TAG %i",
                                             (uintptr_t) nw->tag);
                         } else {
+#else
+			{
+#endif
                                 emit_print (b, " embedded=%i waiting=%i",
                                             (uintptr_t) (w->flags & NSYNC_WAITER_FLAG_MUCV),
                                             (uintptr_t) ATM_LOAD (&nw->waiting));
@@ -197,7 +206,7 @@ static char *emit_mu_state (struct emit_buf *b, nsync_mu *mu,
         word = ATM_LOAD (&mu->word);
         if ((word & MU_WAITING) != 0 && print_waiters &&  /* can benefit from lock */
 	    (blocking || (word & MU_SPINLOCK) == 0)) {  /* willing, or no need to wait */
-                word = nsync_spin_test_and_set_ (&mu->word, MU_SPINLOCK, MU_SPINLOCK, 0);
+                word = nsync_spin_test_and_set_ (&mu->word, MU_SPINLOCK, MU_SPINLOCK, 0, mu);
                 acquired = 1;
         }
         readers = word / MU_RLOCK;
@@ -234,7 +243,7 @@ static char *emit_cv_state (struct emit_buf *b, nsync_cv *cv,
         word = ATM_LOAD (&cv->word);
         if ((word & CV_NON_EMPTY) != 0 && print_waiters &&  /* can benefit from lock */
 	    (blocking || (word & CV_SPINLOCK) == 0)) {  /* willing, or no need to wait */
-                word = nsync_spin_test_and_set_ (&cv->word, CV_SPINLOCK, CV_SPINLOCK, 0);
+                word = nsync_spin_test_and_set_ (&cv->word, CV_SPINLOCK, CV_SPINLOCK, 0, cv);
                 acquired = 1;
         }
         emit_print (b, "cv 0x%i -> 0x%i = {", (uintptr_t) cv, word);
diff --git a/third_party/nsync/mem/nsync_mu_wait.c b/third_party/nsync/mem/nsync_mu_wait.c
index 3c48ea599..785823c5c 100644
--- a/third_party/nsync/mem/nsync_mu_wait.c
+++ b/third_party/nsync/mem/nsync_mu_wait.c
@@ -21,6 +21,7 @@
 #include "third_party/nsync/common.internal.h"
 #include "third_party/nsync/mu_semaphore.h"
 #include "third_party/nsync/races.internal.h"
+#include "libc/thread/thread.h"
 #include "third_party/nsync/wait_s.internal.h"
 __static_yoink("nsync_notice");
 
@@ -84,7 +85,7 @@ static int mu_try_acquire_after_timeout_or_cancel (nsync_mu *mu, lock_type *l_ty
 			ATM_CAS_RELACQ (&mu->word, old_word,
 					old_word|MU_WRITER_WAITING);
 		}
-		spin_attempts = nsync_spin_delay_ (spin_attempts);
+		spin_attempts = pthread_delay_np (mu, spin_attempts);
 		old_word = ATM_LOAD (&mu->word);
 	}
 	/* Check that w wasn't removed from the queue after our caller checked,
@@ -140,7 +141,7 @@ int nsync_mu_wait_with_deadline (nsync_mu *mu,
 				 int (*condition) (const void *condition_arg),
 				 const void *condition_arg,
 				 int (*condition_arg_eq) (const void *a, const void *b),
-				 nsync_time abs_deadline, nsync_note cancel_note) {
+				 int clock, nsync_time abs_deadline, nsync_note cancel_note) {
 	lock_type *l_type;
 	int first_wait;
 	int condition_is_true;
@@ -194,7 +195,7 @@ int nsync_mu_wait_with_deadline (nsync_mu *mu,
 
 		/* Acquire spinlock. */
 		old_word = nsync_spin_test_and_set_ (&mu->word, MU_SPINLOCK,
-			MU_SPINLOCK|MU_WAITING|has_condition, MU_ALL_FALSE);
+			MU_SPINLOCK|MU_WAITING|has_condition, MU_ALL_FALSE, mu);
 		had_waiters = ((old_word & (MU_DESIG_WAKER | MU_WAITING)) == MU_WAITING);
 		/* Queue the waiter. */
 		if (first_wait) {
@@ -230,7 +231,7 @@ int nsync_mu_wait_with_deadline (nsync_mu *mu,
 		have_lock = 0;
 		while (ATM_LOAD_ACQ (&w->nw.waiting) != 0) { /* acquire load */
 			if (sem_outcome == 0) {
-				sem_outcome = nsync_sem_wait_with_cancel_ (w, abs_deadline,
+				sem_outcome = nsync_sem_wait_with_cancel_ (w, clock, abs_deadline,
 									   cancel_note);
 				if (sem_outcome != 0 && ATM_LOAD (&w->nw.waiting) != 0) {
 					/* A timeout or cancellation occurred, and no wakeup.
@@ -244,7 +245,7 @@ int nsync_mu_wait_with_deadline (nsync_mu *mu,
 			}
 
 			if (ATM_LOAD (&w->nw.waiting) != 0) {
-				attempts = nsync_spin_delay_ (attempts); /* will ultimately yield */
+				attempts = pthread_delay_np (mu, attempts); /* will ultimately yield */
 			}
 		}
 
@@ -279,7 +280,7 @@ void nsync_mu_wait (nsync_mu *mu, int (*condition) (const void *condition_arg),
                     const void *condition_arg,
 		    int (*condition_arg_eq) (const void *a, const void *b)) {
 	if (nsync_mu_wait_with_deadline (mu, condition, condition_arg, condition_arg_eq,
-					 nsync_time_no_deadline, NULL) != 0) {
+					 0, nsync_time_no_deadline, NULL) != 0) {
 		nsync_panic_ ("nsync_mu_wait woke but condition not true\n");
 	}
 }
diff --git a/third_party/nsync/mem/nsync_note.c b/third_party/nsync/mem/nsync_note.c
index bdf8e9ad0..6b68b164a 100644
--- a/third_party/nsync/mem/nsync_note.c
+++ b/third_party/nsync/mem/nsync_note.c
@@ -19,6 +19,7 @@
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "third_party/nsync/atomic.h"
+#include "third_party/nsync/time.h"
 #include "third_party/nsync/common.internal.h"
 #include "third_party/nsync/mu_semaphore.h"
 #include "third_party/nsync/mu_wait.h"
@@ -151,7 +152,7 @@ nsync_time nsync_note_notified_deadline_ (nsync_note n) {
 		ntime = NOTIFIED_TIME (n);
 		nsync_mu_unlock (&n->note_mu);
 		if (nsync_time_cmp (ntime, nsync_time_zero) > 0) {
-			if (nsync_time_cmp (ntime, nsync_time_now ()) <= 0) {
+			if (nsync_time_cmp (ntime, nsync_time_now (n->clock)) <= 0) {
 				notify (n);
 				ntime = nsync_time_zero;
 			}
@@ -168,11 +169,12 @@ int nsync_note_is_notified (nsync_note n) {
 	return (result);
 }
 
-nsync_note nsync_note_new (nsync_note parent,
+nsync_note nsync_note_new (nsync_note parent, int clock,
 			   nsync_time abs_deadline) {
 	nsync_note n = (nsync_note) malloc (sizeof (*n));
 	if (n != NULL) {
 		bzero (n, sizeof (*n));
+		n->clock = clock;
 		dll_init (&n->parent_child_link);
 		set_expiry_time (n, abs_deadline);
 		if (!nsync_note_is_notified (n) && parent != NULL) {
@@ -247,7 +249,7 @@ int nsync_note_wait (nsync_note n, nsync_time abs_deadline) {
 	struct nsync_waitable_s *pwaitable = &waitable;
 	waitable.v = n;
 	waitable.funcs = &nsync_note_waitable_funcs;
-	return (nsync_wait_n (NULL, NULL, NULL, abs_deadline, 1, &pwaitable) == 0);
+	return (nsync_wait_n (NULL, NULL, NULL, n->clock, abs_deadline, 1, &pwaitable) == 0);
 }
 
 nsync_time nsync_note_expiry (nsync_note n) {
diff --git a/third_party/nsync/mem/nsync_once.c b/third_party/nsync/mem/nsync_once.c
index 163923359..5f355dc7a 100644
--- a/third_party/nsync/mem/nsync_once.c
+++ b/third_party/nsync/mem/nsync_once.c
@@ -17,10 +17,12 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/nsync/atomic.h"
 #include "third_party/nsync/atomic.internal.h"
+#include "third_party/nsync/time.h"
 #include "third_party/nsync/common.internal.h"
 #include "third_party/nsync/mu_semaphore.h"
 #include "third_party/nsync/once.h"
 #include "third_party/nsync/races.internal.h"
+#include "libc/thread/thread.h"
 #include "third_party/nsync/wait_s.internal.h"
 __static_yoink("nsync_notice");
 
@@ -89,10 +91,10 @@ static void nsync_run_once_impl (nsync_once *once, struct once_sync_s *s,
 				if (attempts < 50) {
 					attempts += 10;
 				}
-				deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (attempts));
-				nsync_cv_wait_with_deadline (&s->once_cv, &s->once_mu, deadline, NULL);
+				deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (attempts));
+				nsync_cv_wait_with_deadline (&s->once_cv, &s->once_mu, NSYNC_CLOCK, deadline, NULL);
 			} else {
-				attempts = nsync_spin_delay_ (attempts);
+				attempts = pthread_delay_np (once, attempts);
 			}
 		}
 		if (s != NULL) {
diff --git a/third_party/nsync/mem/nsync_sem_wait.c b/third_party/nsync/mem/nsync_sem_wait.c
index 62507d686..059fd456a 100644
--- a/third_party/nsync/mem/nsync_sem_wait.c
+++ b/third_party/nsync/mem/nsync_sem_wait.c
@@ -29,18 +29,20 @@ __static_yoink("nsync_notice");
      w->sem is non-zero----decrement it and return 0.
      abs_deadline expires---return ETIMEDOUT.
      cancel_note is non-NULL and *cancel_note becomes notified---return ECANCELED. */
-int nsync_sem_wait_with_cancel_ (waiter *w, nsync_time abs_deadline,
+int nsync_sem_wait_with_cancel_ (waiter *w, int clock, nsync_time abs_deadline,
 			         nsync_note cancel_note) {
 	int sem_outcome;
 	if (cancel_note == NULL) {
-		sem_outcome = nsync_mu_semaphore_p_with_deadline (&w->sem, abs_deadline);
+		sem_outcome = nsync_mu_semaphore_p_with_deadline (&w->sem, clock, abs_deadline);
 	} else {
 		nsync_time cancel_time;
 		cancel_time = nsync_note_notified_deadline_ (cancel_note);
 		sem_outcome = ECANCELED;
 		if (nsync_time_cmp (cancel_time, nsync_time_zero) > 0) {
 			struct nsync_waiter_s nw;
+#if NSYNC_DEBUG
 			nw.tag = NSYNC_WAITER_TAG;
+#endif
 			nw.sem = &w->sem;
 			dll_init (&nw.q);
 			ATM_STORE (&nw.waiting, 1);
@@ -58,7 +60,7 @@ int nsync_sem_wait_with_cancel_ (waiter *w, nsync_time abs_deadline,
 				}
 				nsync_mu_unlock (&cancel_note->note_mu);
 				sem_outcome = nsync_mu_semaphore_p_with_deadline (&w->sem,
-					local_abs_deadline);
+					clock, local_abs_deadline);
 				if (sem_outcome == ETIMEDOUT && !deadline_is_nearer) {
 					sem_outcome = ECANCELED;
 					nsync_note_notify (cancel_note);
diff --git a/third_party/nsync/mem/nsync_wait.c b/third_party/nsync/mem/nsync_wait.c
index 9d8e95b7d..1bf5bdeb2 100644
--- a/third_party/nsync/mem/nsync_wait.c
+++ b/third_party/nsync/mem/nsync_wait.c
@@ -28,7 +28,7 @@
 __static_yoink("nsync_notice");
 
 int nsync_wait_n (void *mu, void (*lock) (void *), void (*unlock) (void *),
-		  nsync_time abs_deadline,
+		  int clock, nsync_time abs_deadline,
 		  int count, struct nsync_waitable_s *waitable[]) {
 	int ready;
 	IGNORE_RACES_START ();
@@ -51,7 +51,9 @@ int nsync_wait_n (void *mu, void (*lock) (void *), void (*unlock) (void *),
 			nw = (struct nsync_waiter_s *) malloc (count * sizeof (nw[0]));
 		}
 		for (i = 0; i != count && enqueued; i++) {
+#if NSYNC_DEBUG
 			nw[i].tag = NSYNC_WAITER_TAG;
+#endif
 			nw[i].sem = &w->sem;
 			dll_init (&nw[i].q);
 			ATM_STORE (&nw[i].waiting, 0);
@@ -77,7 +79,7 @@ int nsync_wait_n (void *mu, void (*lock) (void *), void (*unlock) (void *),
 				}
 			} while (nsync_time_cmp (min_ntime, nsync_time_zero) > 0 &&
 				 nsync_mu_semaphore_p_with_deadline (&w->sem,
-					min_ntime) == 0);
+					clock, min_ntime) == 0);
 		}
 
 		/* An attempt was made above to enqueue waitable[0..i-1].
diff --git a/third_party/nsync/mu.c b/third_party/nsync/mu.c
index 4cae68328..6da4d14a8 100644
--- a/third_party/nsync/mu.c
+++ b/third_party/nsync/mu.c
@@ -22,6 +22,8 @@
 #include "third_party/nsync/common.internal.h"
 #include "third_party/nsync/mu_semaphore.h"
 #include "third_party/nsync/races.internal.h"
+#include "libc/thread/thread.h"
+#include "libc/intrin/strace.h"
 #include "third_party/nsync/wait_s.internal.h"
 __static_yoink("nsync_notice");
 
@@ -32,9 +34,11 @@ void nsync_mu_init (nsync_mu *mu) {
 
 /* Release the mutex spinlock. */
 static void mu_release_spinlock (nsync_mu *mu) {
-	uint32_t old_word = ATM_LOAD (&mu->word);
-	while (!ATM_CAS_REL (&mu->word, old_word, old_word & ~MU_SPINLOCK)) {
-		old_word = ATM_LOAD (&mu->word);
+	uint32_t old_word = atomic_load_explicit (&mu->word,
+						  memory_order_relaxed);
+	while (!atomic_compare_exchange_weak_explicit (
+		       &mu->word, &old_word, old_word & ~MU_SPINLOCK,
+		       memory_order_release, memory_order_relaxed)) {
 	}
 }
 
@@ -53,6 +57,7 @@ void nsync_mu_lock_slow_ (nsync_mu *mu, waiter *w, uint32_t clear, lock_type *l_
 	w->cond.f = NULL; /* Not using a conditional critical section. */
 	w->cond.v = NULL;
 	w->cond.eq = NULL;
+	w->wipe_mu = mu;
 	w->l_type = l_type;
 	zero_to_acquire = l_type->zero_to_acquire;
 	if (clear != 0) {
@@ -66,15 +71,17 @@ void nsync_mu_lock_slow_ (nsync_mu *mu, waiter *w, uint32_t clear, lock_type *l_
 		if ((old_word & zero_to_acquire) == 0) {
 			/* lock can be acquired; try to acquire, possibly
 			   clearing MU_DESIG_WAKER and MU_LONG_WAIT.  */
-			if (ATM_CAS_ACQ (&mu->word, old_word,
-					 (old_word+l_type->add_to_acquire) &
-					  ~(clear|long_wait|l_type->clear_on_acquire))) {
+			if (atomic_compare_exchange_weak_explicit (&mu->word, &old_word,
+								   (old_word+l_type->add_to_acquire) &
+								   ~(clear|long_wait|l_type->clear_on_acquire),
+								   memory_order_acquire, memory_order_relaxed)) {
 				break;
 			}
 		} else if ((old_word&MU_SPINLOCK) == 0 &&
-			   ATM_CAS_ACQ (&mu->word, old_word,
-					(old_word|MU_SPINLOCK|long_wait|
-					 l_type->set_when_waiting) & ~(clear | MU_ALL_FALSE))) {
+			   atomic_compare_exchange_weak_explicit (&mu->word, &old_word,
+								  (old_word|MU_SPINLOCK|long_wait|
+								   l_type->set_when_waiting) & ~(clear | MU_ALL_FALSE),
+								  memory_order_acquire, memory_order_relaxed)) {
 
 			/* Spinlock is now held, and lock is held by someone
 			   else; MU_WAITING has also been set; queue ourselves.
@@ -120,7 +127,7 @@ void nsync_mu_lock_slow_ (nsync_mu *mu, waiter *w, uint32_t clear, lock_type *l_
 			   about waiting writers or long waiters. */
 			zero_to_acquire &= ~(MU_WRITER_WAITING | MU_LONG_WAIT);
 		}
-		attempts = nsync_spin_delay_ (attempts);
+		attempts = pthread_delay_np (mu, attempts);
 	}
 	ALLOW_CANCELATION;
 }
@@ -131,13 +138,16 @@ void nsync_mu_lock_slow_ (nsync_mu *mu, waiter *w, uint32_t clear, lock_type *l_
 int nsync_mu_trylock (nsync_mu *mu) {
 	int result;
 	IGNORE_RACES_START ();
-	if (ATM_CAS_ACQ (&mu->word, 0, MU_WADD_TO_ACQUIRE)) { /* acquire CAS */
+	uint32_t old_word = 0;
+	if (atomic_compare_exchange_strong_explicit (&mu->word, &old_word, MU_WADD_TO_ACQUIRE,
+						     memory_order_acquire, memory_order_relaxed)) {
 		result = 1;
 	} else {
-		uint32_t old_word = ATM_LOAD (&mu->word);
 		result = ((old_word & MU_WZERO_TO_ACQUIRE) == 0 &&
-			  ATM_CAS_ACQ (&mu->word, old_word,
-				       (old_word + MU_WADD_TO_ACQUIRE) & ~MU_WCLEAR_ON_ACQUIRE));
+			  atomic_compare_exchange_strong_explicit (
+				  &mu->word, &old_word,
+				  (old_word + MU_WADD_TO_ACQUIRE) & ~MU_WCLEAR_ON_ACQUIRE,
+				  memory_order_acquire, memory_order_relaxed));
 	}
 	IGNORE_RACES_END ();
 	return (result);
@@ -146,11 +156,14 @@ int nsync_mu_trylock (nsync_mu *mu) {
 /* Block until *mu is free and then acquire it in writer mode. */
 void nsync_mu_lock (nsync_mu *mu) {
 	IGNORE_RACES_START ();
-	if (!ATM_CAS_ACQ (&mu->word, 0, MU_WADD_TO_ACQUIRE)) { /* acquire CAS */
-		uint32_t old_word = ATM_LOAD (&mu->word);
+	uint32_t old_word = 0;
+	if (!atomic_compare_exchange_strong_explicit (&mu->word, &old_word, MU_WADD_TO_ACQUIRE,
+						      memory_order_acquire, memory_order_relaxed)) {
 		if ((old_word&MU_WZERO_TO_ACQUIRE) != 0 ||
-		    !ATM_CAS_ACQ (&mu->word, old_word,
-				  (old_word+MU_WADD_TO_ACQUIRE) & ~MU_WCLEAR_ON_ACQUIRE)) {
+		    !atomic_compare_exchange_strong_explicit (&mu->word, &old_word,
+							      (old_word+MU_WADD_TO_ACQUIRE) & ~MU_WCLEAR_ON_ACQUIRE,
+							      memory_order_acquire, memory_order_relaxed)) {
+			LOCKTRACE("acquiring nsync_mu_lock(%t)...", mu);
 			waiter *w = nsync_waiter_new_ ();
 			nsync_mu_lock_slow_ (mu, w, 0, nsync_writer_type_);
 			nsync_waiter_free_ (w);
@@ -166,13 +179,15 @@ void nsync_mu_lock (nsync_mu *mu) {
 int nsync_mu_rtrylock (nsync_mu *mu) {
 	int result;
 	IGNORE_RACES_START ();
-	if (ATM_CAS_ACQ (&mu->word, 0, MU_RADD_TO_ACQUIRE)) { /* acquire CAS */
+	uint32_t old_word = 0;
+	if (atomic_compare_exchange_strong_explicit (&mu->word, &old_word, MU_RADD_TO_ACQUIRE,
+						     memory_order_acquire, memory_order_relaxed)) {
 		result = 1;
 	} else {
-		uint32_t old_word = ATM_LOAD (&mu->word);
 		result = ((old_word&MU_RZERO_TO_ACQUIRE) == 0 &&
-			  ATM_CAS_ACQ (&mu->word, old_word,
-				       (old_word+MU_RADD_TO_ACQUIRE) & ~MU_RCLEAR_ON_ACQUIRE));
+			  atomic_compare_exchange_strong_explicit (&mu->word, &old_word,
+								   (old_word+MU_RADD_TO_ACQUIRE) & ~MU_RCLEAR_ON_ACQUIRE,
+								   memory_order_acquire, memory_order_relaxed));
 	}
 	IGNORE_RACES_END ();
 	return (result);
@@ -181,11 +196,14 @@ int nsync_mu_rtrylock (nsync_mu *mu) {
 /* Block until *mu can be acquired in reader mode and then acquire it. */
 void nsync_mu_rlock (nsync_mu *mu) {
 	IGNORE_RACES_START ();
-	if (!ATM_CAS_ACQ (&mu->word, 0, MU_RADD_TO_ACQUIRE)) { /* acquire CAS */
-		uint32_t old_word = ATM_LOAD (&mu->word);
+	uint32_t old_word = 0;
+	if (!atomic_compare_exchange_strong_explicit (&mu->word, &old_word, MU_RADD_TO_ACQUIRE,
+						      memory_order_acquire, memory_order_relaxed)) {
 		if ((old_word&MU_RZERO_TO_ACQUIRE) != 0 ||
-		    !ATM_CAS_ACQ (&mu->word, old_word,
-				  (old_word+MU_RADD_TO_ACQUIRE) & ~MU_RCLEAR_ON_ACQUIRE)) {
+		    !atomic_compare_exchange_strong_explicit (&mu->word, &old_word,
+							      (old_word+MU_RADD_TO_ACQUIRE) & ~MU_RCLEAR_ON_ACQUIRE,
+							      memory_order_acquire, memory_order_relaxed)) {
+			LOCKTRACE("acquiring nsync_mu_rlock(%t)...", mu);
 			waiter *w = nsync_waiter_new_ ();
 			nsync_mu_lock_slow_ (mu, w, 0, nsync_reader_type_);
 			nsync_waiter_free_ (w);
@@ -233,16 +251,16 @@ struct Dll *nsync_remove_from_mu_queue_ (struct Dll *mu_queue, struct Dll *e) {
 	/* Record previous and next elements in the original queue. */
 	struct Dll *prev = e->prev;
 	struct Dll *next = e->next;
-	uint32_t old_value;
 	/* Remove. */
 	dll_remove (&mu_queue, e);
-        do {    
-                old_value = ATM_LOAD (&DLL_WAITER (e)->remove_count);
-        } while (!ATM_CAS (&DLL_WAITER (e)->remove_count, old_value, old_value+1));
+	uint32_t old_value = ATM_LOAD (&DLL_WAITER (e)->remove_count);
+        while (!atomic_compare_exchange_weak_explicit (
+		       &DLL_WAITER (e)->remove_count, &old_value, old_value+1,
+		       memory_order_relaxed, memory_order_relaxed)) {
+	}
 	if (!dll_is_empty (mu_queue)) {
 		/* Fix up same_condition. */
 		struct Dll *e_same_condition = &DLL_WAITER (e)->same_condition;
-
 		if (e_same_condition->next != e_same_condition) {
 			/* *e is linked to a same_condition neighbour---just remove it. */
 			e_same_condition->next->prev = e_same_condition->prev;
@@ -287,14 +305,18 @@ void nsync_mu_unlock_slow_ (nsync_mu *mu, lock_type *l_type) {
 			/* no one to wake, there's a designated waker waking
 			   up, there are still readers, or it's a reader and all waiters
 			   have false conditions */
-			if (ATM_CAS_REL (&mu->word, old_word,
-					 (old_word - l_type->add_to_acquire) &
-					 ~l_type->clear_on_uncontended_release)) {
+			if (atomic_compare_exchange_weak_explicit (
+				    &mu->word, &old_word,
+				    (old_word - l_type->add_to_acquire) &
+				    ~l_type->clear_on_uncontended_release,
+				    memory_order_release, memory_order_relaxed)) {
 				return;
 			}
 		} else if ((old_word&MU_SPINLOCK) == 0 &&
-			   ATM_CAS_SEQCST (&mu->word, old_word, /* [jart] fixes issues on apple silicon */
-                                           (old_word-early_release_mu)|MU_SPINLOCK|MU_DESIG_WAKER)) {
+			   atomic_compare_exchange_weak_explicit (
+				   &mu->word, &old_word,
+				   (old_word-early_release_mu)|MU_SPINLOCK|MU_DESIG_WAKER,
+				   memory_order_acq_rel, memory_order_relaxed)) {
 			struct Dll *wake;
 			lock_type *wake_type;
 			uint32_t clear_on_release;
@@ -393,7 +415,7 @@ void nsync_mu_unlock_slow_ (nsync_mu *mu, lock_type *l_type) {
 				   released above. */
 				if (testing_conditions) {
 					nsync_spin_test_and_set_ (&mu->word, MU_SPINLOCK,
-								  MU_SPINLOCK, 0);
+								  MU_SPINLOCK, 0, mu);
 				}
 
 				/* add the new_waiters to the last of the waiters. */
@@ -430,10 +452,10 @@ void nsync_mu_unlock_slow_ (nsync_mu *mu, lock_type *l_type) {
 			   whether any waiters remain, and whether any of them
 			   are writers.  */
 			old_word = ATM_LOAD (&mu->word);
-			while (!ATM_CAS_REL (&mu->word, old_word,
-					     ((old_word-late_release_mu)|set_on_release) &
-					     ~clear_on_release)) { /* release CAS */
-				old_word = ATM_LOAD (&mu->word);
+			while (!atomic_compare_exchange_weak_explicit (
+				       &mu->word, &old_word,
+				       ((old_word - late_release_mu) | set_on_release) & ~clear_on_release,
+				       memory_order_release, memory_order_relaxed)) {
 			}
 			/* Wake the waiters. */
 			for (p = dll_first (wake); p != NULL; p = next) {
@@ -444,7 +466,7 @@ void nsync_mu_unlock_slow_ (nsync_mu *mu, lock_type *l_type) {
 			}
 			return;
 		}
-		attempts = nsync_spin_delay_ (attempts);
+		attempts = pthread_delay_np (mu, attempts);
 	}
 }
 
@@ -456,8 +478,10 @@ void nsync_mu_unlock (nsync_mu *mu) {
 	   waiter.  Another thread could acquire, decrement a reference count
 	   and deallocate the mutex before the current thread touched the mutex
 	   word again. */
-	if (!ATM_CAS_REL (&mu->word, MU_WLOCK, 0)) {
-		uint32_t old_word = ATM_LOAD (&mu->word);
+	uint32_t old_word = MU_WLOCK;
+	if (!atomic_compare_exchange_strong_explicit (&mu->word, &old_word, 0,
+						      memory_order_release,
+						      memory_order_relaxed)) {
                 /* Clear MU_ALL_FALSE because the critical section we're just
                    leaving may have made some conditions true.  */
 		uint32_t new_word = (old_word - MU_WLOCK) & ~MU_ALL_FALSE;
@@ -485,8 +509,10 @@ void nsync_mu_unlock (nsync_mu *mu) {
 void nsync_mu_runlock (nsync_mu *mu) {
 	IGNORE_RACES_START ();
 	/* See comment in nsync_mu_unlock(). */
-	if (!ATM_CAS_REL (&mu->word, MU_RLOCK, 0)) {
-		uint32_t old_word = ATM_LOAD (&mu->word);
+	uint32_t old_word = MU_RLOCK;
+	if (!atomic_compare_exchange_strong_explicit (&mu->word, &old_word, 0,
+						      memory_order_release,
+						      memory_order_relaxed)) {
                 /* Sanity check:  mutex must not be held in write mode and
                    reader count must not be 0.  */
 		if (((old_word ^ MU_WLOCK) & (MU_WLOCK | MU_RLOCK_FIELD)) == 0) {
diff --git a/third_party/nsync/mu.h b/third_party/nsync/mu.h
index dab1ed722..4831cacd8 100644
--- a/third_party/nsync/mu.h
+++ b/third_party/nsync/mu.h
@@ -48,7 +48,6 @@ COSMOPOLITAN_C_START_
 */
 typedef struct nsync_mu_s_ {
   nsync_atomic_uint32_ word; /* internal use only */
-  int _zero;                 /* c pthread_mutex_t */
   struct Dll *waiters;       /* internal use only */
 } nsync_mu;
 
diff --git a/third_party/nsync/mu_semaphore.c b/third_party/nsync/mu_semaphore.c
index 493efa2c4..cc6906400 100644
--- a/third_party/nsync/mu_semaphore.c
+++ b/third_party/nsync/mu_semaphore.c
@@ -15,28 +15,30 @@
 │ See the License for the specific language governing permissions and          │
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "third_party/nsync/mu_semaphore.h"
+#include "third_party/nsync/mu_semaphore.internal.h"
 #include "libc/calls/cp.internal.h"
 #include "libc/dce.h"
-#include "third_party/nsync/mu_semaphore.internal.h"
+#include "third_party/nsync/mu_semaphore.h"
 __static_yoink("nsync_notice");
 
-/* Apple's ulock (part by Cosmo futexes) is an internal API, but:
-   1. Unlike GCD it's cancellable, i.e. can be EINTR'd by signals
-   2. We currently always use ulock anyway for joining threads */
-#define PREFER_GCD_OVER_ULOCK 1
-
 /* Initialize *s; the initial value is 0. */
-void nsync_mu_semaphore_init (nsync_semaphore *s) {
-	if (PREFER_GCD_OVER_ULOCK && IsXnuSilicon ()) {
-		return nsync_mu_semaphore_init_gcd (s);
-	} else if (IsNetbsd ()) {
+bool nsync_mu_semaphore_init (nsync_semaphore *s) {
+	if (IsNetbsd ()) {
 		return nsync_mu_semaphore_init_sem (s);
 	} else {
 		return nsync_mu_semaphore_init_futex (s);
 	}
 }
 
+/* Destroy *s. */
+void nsync_mu_semaphore_destroy (nsync_semaphore *s) {
+	if (IsNetbsd ()) {
+		return nsync_mu_semaphore_destroy_sem (s);
+	} else {
+		return nsync_mu_semaphore_destroy_futex (s);
+	}
+}
+
 /* Wait until the count of *s exceeds 0, and decrement it. If POSIX cancellations
    are currently disabled by the thread, then this function always succeeds. When
    they're enabled in MASKED mode, this function may return ECANCELED. Otherwise,
@@ -44,9 +46,7 @@ void nsync_mu_semaphore_init (nsync_semaphore *s) {
 errno_t nsync_mu_semaphore_p (nsync_semaphore *s) {
 	errno_t err;
 	BEGIN_CANCELATION_POINT;
-	if (PREFER_GCD_OVER_ULOCK && IsXnuSilicon ()) {
-		err = nsync_mu_semaphore_p_gcd (s);
-	} else if (IsNetbsd ()) {
+	if (IsNetbsd ()) {
 		err = nsync_mu_semaphore_p_sem (s);
 	} else {
 		err = nsync_mu_semaphore_p_futex (s);
@@ -59,15 +59,13 @@ errno_t nsync_mu_semaphore_p (nsync_semaphore *s) {
    while additionally supporting a time parameter specifying at what point
    in the future ETIMEDOUT should be returned, if neither cancelation, or
    semaphore release happens. */
-errno_t nsync_mu_semaphore_p_with_deadline (nsync_semaphore *s, nsync_time abs_deadline) {
+errno_t nsync_mu_semaphore_p_with_deadline (nsync_semaphore *s, int clock, nsync_time abs_deadline) {
 	errno_t err;
 	BEGIN_CANCELATION_POINT;
-	if (PREFER_GCD_OVER_ULOCK && IsXnuSilicon ()) {
-		err = nsync_mu_semaphore_p_with_deadline_gcd (s, abs_deadline);
-	} else if (IsNetbsd ()) {
-		err = nsync_mu_semaphore_p_with_deadline_sem (s, abs_deadline);
+	if (IsNetbsd ()) {
+		err = nsync_mu_semaphore_p_with_deadline_sem (s, clock, abs_deadline);
 	} else {
-		err = nsync_mu_semaphore_p_with_deadline_futex (s, abs_deadline);
+		err = nsync_mu_semaphore_p_with_deadline_futex (s, clock, abs_deadline);
 	}
 	END_CANCELATION_POINT;
 	return err;
@@ -75,9 +73,7 @@ errno_t nsync_mu_semaphore_p_with_deadline (nsync_semaphore *s, nsync_time abs_d
 
 /* Ensure that the count of *s is at least 1. */
 void nsync_mu_semaphore_v (nsync_semaphore *s) {
-	if (PREFER_GCD_OVER_ULOCK && IsXnuSilicon ()) {
-		return nsync_mu_semaphore_v_gcd (s);
-	} else if (IsNetbsd ()) {
+	if (IsNetbsd ()) {
 		return nsync_mu_semaphore_v_sem (s);
 	} else {
 		return nsync_mu_semaphore_v_futex (s);
diff --git a/third_party/nsync/mu_semaphore.h b/third_party/nsync/mu_semaphore.h
index 64c7d563d..fffb99e51 100644
--- a/third_party/nsync/mu_semaphore.h
+++ b/third_party/nsync/mu_semaphore.h
@@ -8,7 +8,10 @@ typedef struct nsync_semaphore_s_ {
 } nsync_semaphore;
 
 /* Initialize *s; the initial value is 0. */
-void nsync_mu_semaphore_init(nsync_semaphore *s);
+bool nsync_mu_semaphore_init(nsync_semaphore *s);
+
+/* Destroy *s. */
+void nsync_mu_semaphore_destroy(nsync_semaphore *s);
 
 /* Wait until the count of *s exceeds 0, and decrement it. */
 errno_t nsync_mu_semaphore_p(nsync_semaphore *s);
@@ -16,7 +19,7 @@ errno_t nsync_mu_semaphore_p(nsync_semaphore *s);
 /* Wait until one of: the count of *s is non-zero, in which case
    decrement *s and return 0; or abs_deadline expires, in which case
    return ETIMEDOUT. */
-errno_t nsync_mu_semaphore_p_with_deadline(nsync_semaphore *s,
+errno_t nsync_mu_semaphore_p_with_deadline(nsync_semaphore *s, int clock,
                                            nsync_time abs_deadline);
 
 /* Ensure that the count of *s is at least 1. */
diff --git a/third_party/nsync/mu_semaphore.internal.h b/third_party/nsync/mu_semaphore.internal.h
index ce3181fc3..6fe15090f 100755
--- a/third_party/nsync/mu_semaphore.internal.h
+++ b/third_party/nsync/mu_semaphore.internal.h
@@ -4,20 +4,17 @@
 #include "third_party/nsync/time.h"
 COSMOPOLITAN_C_START_
 
-void nsync_mu_semaphore_init_futex(nsync_semaphore *);
+bool nsync_mu_semaphore_init_futex(nsync_semaphore *);
+void nsync_mu_semaphore_destroy_futex(nsync_semaphore *);
 errno_t nsync_mu_semaphore_p_futex(nsync_semaphore *);
-errno_t nsync_mu_semaphore_p_with_deadline_futex(nsync_semaphore *, nsync_time);
+errno_t nsync_mu_semaphore_p_with_deadline_futex(nsync_semaphore *, int, nsync_time);
 void nsync_mu_semaphore_v_futex(nsync_semaphore *);
 
-void nsync_mu_semaphore_init_sem(nsync_semaphore *);
+bool nsync_mu_semaphore_init_sem(nsync_semaphore *);
+void nsync_mu_semaphore_destroy_sem(nsync_semaphore *);
 errno_t nsync_mu_semaphore_p_sem(nsync_semaphore *);
-errno_t nsync_mu_semaphore_p_with_deadline_sem(nsync_semaphore *, nsync_time);
+errno_t nsync_mu_semaphore_p_with_deadline_sem(nsync_semaphore *, int, nsync_time);
 void nsync_mu_semaphore_v_sem(nsync_semaphore *);
 
-void nsync_mu_semaphore_init_gcd(nsync_semaphore *);
-errno_t nsync_mu_semaphore_p_gcd(nsync_semaphore *);
-errno_t nsync_mu_semaphore_p_with_deadline_gcd(nsync_semaphore *, nsync_time);
-void nsync_mu_semaphore_v_gcd(nsync_semaphore *);
-
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_THIRD_PARTY_NSYNC_MU_SEMAPHORE_INTERNAL_H_ */
diff --git a/third_party/nsync/mu_semaphore_futex.c b/third_party/nsync/mu_semaphore_futex.c
index 14d0ec20e..cc556267d 100644
--- a/third_party/nsync/mu_semaphore_futex.c
+++ b/third_party/nsync/mu_semaphore_futex.c
@@ -21,14 +21,16 @@
 #include "libc/thread/thread.h"
 #include "third_party/nsync/atomic.h"
 #include "third_party/nsync/atomic.internal.h"
-#include "third_party/nsync/futex.internal.h"
+#include "libc/cosmo.h"
+#include "libc/calls/struct/timespec.h"
+#include "libc/cosmo.h"
 #include "third_party/nsync/mu_semaphore.internal.h"
 
 /**
  * @fileoverview Semaphores w/ Linux Futexes API.
  */
 
-#define ASSERT(x) npassert(x)
+#define ASSERT(x) unassert(x)
 
 /* Check that atomic operations on nsync_atomic_uint32_ can be applied to int. */
 static const int assert_int_size = 1 /
@@ -43,9 +45,13 @@ static nsync_semaphore *sem_big_enough_for_futex = (nsync_semaphore *) (uintptr_
 	(sizeof (struct futex) <= sizeof (*sem_big_enough_for_futex)));
 
 /* Initialize *s; the initial value is 0. */
-void nsync_mu_semaphore_init_futex (nsync_semaphore *s) {
+bool nsync_mu_semaphore_init_futex (nsync_semaphore *s) {
 	struct futex *f = (struct futex *) s;
 	f->i = 0;
+	return true;
+}
+
+void nsync_mu_semaphore_destroy_futex (nsync_semaphore *s) {
 }
 
 /* Wait until the count of *s exceeds 0, and decrement it. If POSIX cancellations
@@ -60,9 +66,9 @@ errno_t nsync_mu_semaphore_p_futex (nsync_semaphore *s) {
 		i = ATM_LOAD ((nsync_atomic_uint32_ *) &f->i);
 		if (i == 0) {
 			int futex_result;
-			futex_result = -nsync_futex_wait_ (
+			futex_result = -cosmo_futex_wait (
 				(atomic_int *)&f->i, i,
-				PTHREAD_PROCESS_PRIVATE, 0);
+				PTHREAD_PROCESS_PRIVATE, 0, 0);
 			ASSERT (futex_result == 0 ||
 				futex_result == EINTR ||
 				futex_result == EAGAIN ||
@@ -72,7 +78,10 @@ errno_t nsync_mu_semaphore_p_futex (nsync_semaphore *s) {
 				result = ECANCELED;
 			}
 		}
-	} while (result == 0 && (i == 0 || !ATM_CAS_ACQ ((nsync_atomic_uint32_ *) &f->i, i, i-1)));
+	} while (result == 0 && (i == 0 ||
+				 !atomic_compare_exchange_weak_explicit (
+					 (nsync_atomic_uint32_ *) &f->i, &i, i-1,
+					 memory_order_acquire, memory_order_relaxed)));
 	return result;
 }
 
@@ -80,7 +89,7 @@ errno_t nsync_mu_semaphore_p_futex (nsync_semaphore *s) {
    while additionally supporting a time parameter specifying at what point
    in the future ETIMEDOUT should be returned, if neither cancellation, or
    semaphore release happens. */
-errno_t nsync_mu_semaphore_p_with_deadline_futex (nsync_semaphore *s, nsync_time abs_deadline) {
+errno_t nsync_mu_semaphore_p_with_deadline_futex (nsync_semaphore *s, int clock, nsync_time abs_deadline) {
 	struct futex *f = (struct futex *)s;
 	int i;
 	int result = 0;
@@ -96,8 +105,9 @@ errno_t nsync_mu_semaphore_p_with_deadline_futex (nsync_semaphore *s, nsync_time
 				ts_buf.tv_nsec = NSYNC_TIME_NSEC (abs_deadline);
 				ts = &ts_buf;
 			}
-			futex_result = nsync_futex_wait_ ((atomic_int *)&f->i, i,
-							  PTHREAD_PROCESS_PRIVATE, ts);
+			futex_result = cosmo_futex_wait ((atomic_int *)&f->i, i,
+							 PTHREAD_PROCESS_PRIVATE,
+							 clock, ts);
 			ASSERT (futex_result == 0 ||
 				futex_result == -EINTR ||
 				futex_result == -EAGAIN ||
@@ -105,24 +115,31 @@ errno_t nsync_mu_semaphore_p_with_deadline_futex (nsync_semaphore *s, nsync_time
 				futex_result == -ETIMEDOUT ||
 				futex_result == -EWOULDBLOCK);
 			/* Some systems don't wait as long as they are told. */
-			if (futex_result == -ETIMEDOUT &&
-			    nsync_time_cmp (abs_deadline, nsync_time_now ()) <= 0) {
-				result = ETIMEDOUT;
+			if (futex_result == -ETIMEDOUT) {
+				nsync_time now;
+				if (clock_gettime (clock, &now))
+					result = EINVAL;
+				if (nsync_time_cmp (now, abs_deadline) >= 0)
+					result = ETIMEDOUT;
 			}
 			if (futex_result == -ECANCELED) {
 				result = ECANCELED;
 			}
 		}
-	} while (result == 0 && (i == 0 || !ATM_CAS_ACQ ((nsync_atomic_uint32_ *) &f->i, i, i - 1)));
+	} while (result == 0 && (i == 0 ||
+				 !atomic_compare_exchange_weak_explicit (
+					 (nsync_atomic_uint32_ *) &f->i, &i, i-1,
+					 memory_order_acquire, memory_order_relaxed)));
 	return (result);
 }
 
 /* Ensure that the count of *s is at least 1. */
 void nsync_mu_semaphore_v_futex (nsync_semaphore *s) {
 	struct futex *f = (struct futex *) s;
-        uint32_t old_value;
-	do {
-		old_value = ATM_LOAD ((nsync_atomic_uint32_ *) &f->i);
-	} while (!ATM_CAS_REL ((nsync_atomic_uint32_ *) &f->i, old_value, old_value+1));
-	ASSERT (nsync_futex_wake_ ((atomic_int *)&f->i, 1, PTHREAD_PROCESS_PRIVATE) >= 0);
+        uint32_t old_value = ATM_LOAD ((nsync_atomic_uint32_ *) &f->i);
+	while (!atomic_compare_exchange_weak_explicit (
+		       (nsync_atomic_uint32_ *) &f->i, &old_value, old_value+1,
+		       memory_order_release, memory_order_relaxed)) {
+	}
+	ASSERT (cosmo_futex_wake ((atomic_int *)&f->i, 1, PTHREAD_PROCESS_PRIVATE) >= 0);
 }
diff --git a/third_party/nsync/mu_semaphore_gcd.c b/third_party/nsync/mu_semaphore_gcd.c
deleted file mode 100644
index fd36135de..000000000
--- a/third_party/nsync/mu_semaphore_gcd.c
+++ /dev/null
@@ -1,140 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2016 Google Inc.                                                   │
-│                                                                              │
-│ 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.                                               │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/calls/sig.internal.h"
-#include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/intrin/weaken.h"
-#include "libc/runtime/clktck.h"
-#include "libc/runtime/syslib.internal.h"
-#include "libc/str/str.h"
-#include "libc/thread/posixthread.internal.h"
-#include "libc/thread/thread.h"
-#include "libc/thread/tls.h"
-#include "third_party/nsync/atomic.h"
-#include "third_party/nsync/atomic.internal.h"
-#include "third_party/nsync/futex.internal.h"
-#include "third_party/nsync/mu_semaphore.internal.h"
-#include "third_party/nsync/time.h"
-
-/**
- * @fileoverview Semaphores w/ Apple's Grand Central Dispatch API.
- */
-
-#define DISPATCH_TIME_FOREVER ~0ull
-
-static dispatch_semaphore_t dispatch_semaphore_create(long count) {
-	dispatch_semaphore_t ds;
-	ds = __syslib->__dispatch_semaphore_create (count);
-	STRACE ("dispatch_semaphore_create(%ld) → %#lx", count, ds);
-	return (ds);
-}
-
-static void dispatch_release (dispatch_semaphore_t ds) {
-	__syslib->__dispatch_release (ds);
-	STRACE ("dispatch_release(%#lx)", ds);
-}
-
-static long dispatch_semaphore_wait (dispatch_semaphore_t ds,
-				     dispatch_time_t dt) {
-	long rc = __syslib->__dispatch_semaphore_wait (ds, dt);
-	STRACE ("dispatch_semaphore_wait(%#lx, %ld) → %ld", ds, dt, rc);
-	return (rc);
-}
-
-static long dispatch_semaphore_signal (dispatch_semaphore_t ds) {
-	long rc = __syslib->__dispatch_semaphore_signal (ds);
-	(void)rc;
-	STRACE ("dispatch_semaphore_signal(%#lx) → %ld", ds, rc);
-	return (ds);
-}
-
-static dispatch_time_t dispatch_walltime (const struct timespec *base,
-					  int64_t offset) {
-	return __syslib->__dispatch_walltime (base, offset);
-}
-
-static errno_t nsync_dispatch_semaphore_wait (nsync_semaphore *s,
-					      nsync_time abs_deadline) {
-	errno_t result = 0;
-	dispatch_time_t dt;
-	if (nsync_time_cmp (abs_deadline, nsync_time_no_deadline) == 0) {
-		dt = DISPATCH_TIME_FOREVER;
-	} else {
-		dt = dispatch_walltime (&abs_deadline, 0);
-	}
-	if (dispatch_semaphore_wait (*(dispatch_semaphore_t *)s, dt) != 0) {
-		result = ETIMEDOUT;
-	}
-	return (result);
-}
-
-/* Initialize *s; the initial value is 0.  */
-void nsync_mu_semaphore_init_gcd (nsync_semaphore *s) {
-	*(dispatch_semaphore_t *)s = dispatch_semaphore_create (0);
-}
-
-/* Wait until the count of *s exceeds 0, and decrement it. If POSIX cancellations
-   are currently disabled by the thread, then this function always succeeds. When
-   they're enabled in MASKED mode, this function may return ECANCELED. Otherwise,
-   cancellation will occur by unwinding cleanup handlers pushed to the stack. */
-errno_t nsync_mu_semaphore_p_gcd (nsync_semaphore *s) {
-	return nsync_mu_semaphore_p_with_deadline_gcd (s, nsync_time_no_deadline);
-}
-
-/* Like nsync_mu_semaphore_p() this waits for the count of *s to exceed 0,
-   while additionally supporting a time parameter specifying at what point
-   in the future ETIMEDOUT should be returned, if neither cancellation, or
-   semaphore release happens. */
-errno_t nsync_mu_semaphore_p_with_deadline_gcd (nsync_semaphore *s,
-						nsync_time abs_deadline) {
-	errno_t result = 0;
-	struct PosixThread *pt;
-	if (!__tls_enabled ||
-	    !_weaken (pthread_testcancel_np) ||
-	    !(pt = _pthread_self()) ||
-	    (pt->pt_flags & PT_NOCANCEL)) {
-		result = nsync_dispatch_semaphore_wait (s, abs_deadline);
-	} else {
-		struct timespec now, until, slice = {0, 1000000000 / CLK_TCK};
-		for (;;) {
-			if (_weaken (pthread_testcancel_np) () == ECANCELED) {
-				result = ECANCELED;
-				break;
-			}
-			now = timespec_real();
-			if (timespec_cmp (now, abs_deadline) >= 0) {
-				result = ETIMEDOUT;
-				break;
-			}
-			until = timespec_add (now, slice);
-			if (timespec_cmp (until, abs_deadline) > 0) {
-				until = abs_deadline;
-			}
-			if (!nsync_dispatch_semaphore_wait (s, until)) {
-				break;
-			}
-		}
-	}
-	return (result);
-}
-
-/* Ensure that the count of *s is at least 1. */
-void nsync_mu_semaphore_v_gcd (nsync_semaphore *s) {
-	dispatch_semaphore_signal (*(dispatch_semaphore_t *)s);
-}
diff --git a/third_party/nsync/mu_semaphore_sem.c b/third_party/nsync/mu_semaphore_sem.c
index d2c6377ac..a42b2e8c3 100644
--- a/third_party/nsync/mu_semaphore_sem.c
+++ b/third_party/nsync/mu_semaphore_sem.c
@@ -25,70 +25,53 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/dll.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/f.h"
 #include "libc/sysv/consts/fd.h"
 #include "libc/thread/thread.h"
+#include "third_party/nsync/time.h"
 #include "third_party/nsync/mu_semaphore.h"
+#include "libc/intrin/atomic.h"
 #include "third_party/nsync/time.h"
 
 /**
  * @fileoverview Semaphores w/ POSIX Semaphores API.
  */
 
-#define ASSERT(x) npassert(x)
-#define SEM_CONTAINER(e) DLL_CONTAINER(struct sem, list, e)
+#define ASSERT(x) unassert(x)
 
 struct sem {
 	int64_t id;
-	struct Dll list;
 };
 
-static struct {
-	atomic_uint once;
-	pthread_spinlock_t lock;
-	struct Dll *list;
-} g_sems;
-
 static nsync_semaphore *sem_big_enough_for_sem = (nsync_semaphore *) (uintptr_t)(1 /
 	(sizeof (struct sem) <= sizeof (*sem_big_enough_for_sem)));
 
-static void nsync_mu_semaphore_sem_create (struct sem *f) {
+/* Initialize *s; the initial value is 0. */
+bool nsync_mu_semaphore_init_sem (nsync_semaphore *s) {
+	struct sem *f = (struct sem *) s;
+	int rc;
 	int lol;
 	f->id = 0;
-	ASSERT (!sys_sem_init (0, &f->id));
-	if ((lol = __sys_fcntl (f->id, F_DUPFD_CLOEXEC, 50)) >= 50) {
-		sys_close (f->id);
+	rc = sys_sem_init (0, &f->id);
+	STRACE ("sem_init(0, [%ld]) → %d", f->id, rc);
+	if (rc != 0)
+		return false;
+	lol = __sys_fcntl (f->id, F_DUPFD_CLOEXEC, 50);
+	STRACE ("fcntl(%ld, F_DUPFD_CLOEXEC, 50) → %d", f->id, lol);
+	if (lol >= 50) {
+		rc = sys_close (f->id);
+		STRACE ("close(%ld) → %d", f->id, rc);
 		f->id = lol;
 	}
+	return true;
 }
 
-static void nsync_mu_semaphore_sem_fork_child (void) {
-	struct Dll *e;
-	struct sem *f;
-	for (e = dll_first (g_sems.list); e; e = dll_next (g_sems.list, e)) {
-		f = SEM_CONTAINER (e);
-		sys_close (f->id);
-		nsync_mu_semaphore_sem_create (f);
-	}
-	(void) pthread_spin_init (&g_sems.lock, 0);
-}
-
-static void nsync_mu_semaphore_sem_init (void) {
-	pthread_atfork (0, 0, nsync_mu_semaphore_sem_fork_child);
-}
-
-/* Initialize *s; the initial value is 0. */
-void nsync_mu_semaphore_init_sem (nsync_semaphore *s) {
+/* Destroys *s. */
+void nsync_mu_semaphore_destroy_sem (nsync_semaphore *s) {
 	struct sem *f = (struct sem *) s;
-	nsync_mu_semaphore_sem_create (f);
-	cosmo_once (&g_sems.once, nsync_mu_semaphore_sem_init);
-	pthread_spin_lock (&g_sems.lock);
-	dll_init (&f->list);
-	dll_make_first (&g_sems.list, &f->list);
-	pthread_spin_unlock (&g_sems.lock);
-	STRACE ("sem_init(0, [%ld]) → 0", f->id);
+	sys_close (f->id);
 }
 
 /* Wait until the count of *s exceeds 0, and decrement it. If POSIX cancellations
@@ -116,10 +99,22 @@ errno_t nsync_mu_semaphore_p_sem (nsync_semaphore *s) {
    while additionally supporting a time parameter specifying at what point
    in the future ETIMEDOUT should be returned, if neither cancellation, or
    semaphore release happens. */
-errno_t nsync_mu_semaphore_p_with_deadline_sem (nsync_semaphore *s, nsync_time abs_deadline) {
+errno_t nsync_mu_semaphore_p_with_deadline_sem (nsync_semaphore *s, int clock,
+						nsync_time abs_deadline) {
 	int e, rc;
 	errno_t result;
 	struct sem *f = (struct sem *) s;
+
+	// convert monotonic back to realtime just for netbsd
+	if (clock && nsync_time_cmp (abs_deadline, nsync_time_no_deadline)) {
+		struct timespec now, delta;
+		if (clock_gettime (clock, &now))
+			return EINVAL;
+		delta = timespec_subz (abs_deadline, now);
+		clock_gettime (CLOCK_REALTIME, &now);
+		abs_deadline = timespec_add (now, delta);
+	}
+
 	e = errno;
 	rc = sys_sem_timedwait (f->id, &abs_deadline);
 	STRACE ("sem_timedwait(%ld, %s) → %d% m", f->id,
diff --git a/third_party/nsync/mu_wait.h b/third_party/nsync/mu_wait.h
index 3ee9d9793..d17a10c9d 100644
--- a/third_party/nsync/mu_wait.h
+++ b/third_party/nsync/mu_wait.h
@@ -97,7 +97,7 @@ void nsync_mu_wait(nsync_mu *mu, int (*condition)(const void *condition_arg),
 int nsync_mu_wait_with_deadline(
     nsync_mu *mu, int (*condition)(const void *condition_arg),
     const void *condition_arg,
-    int (*condition_arg_eq)(const void *a, const void *b),
+    int (*condition_arg_eq)(const void *a, const void *b), int clock,
     nsync_time abs_deadline, struct nsync_note_s_ *cancel_note);
 
 /* Unlock *mu, which must be held in write mode, and wake waiters, if
diff --git a/third_party/nsync/note.h b/third_party/nsync/note.h
index 008166aab..0d46e92ee 100644
--- a/third_party/nsync/note.h
+++ b/third_party/nsync/note.h
@@ -19,7 +19,7 @@ typedef struct nsync_note_s_ *nsync_note;
    abs_deadline==nsync_zero_time.
 
    nsync_notes should be passed to nsync_note_free() when no longer needed. */
-nsync_note nsync_note_new(nsync_note parent, nsync_time abs_deadline);
+nsync_note nsync_note_new(nsync_note parent, int clock, nsync_time abs_deadline);
 
 /* Free resources associated with n. Requires that n was allocated by
    nsync_note_new(), and no concurrent or future operations are applied
diff --git a/third_party/nsync/panic.c b/third_party/nsync/panic.c
index dcb09dd7b..7c6cebf38 100644
--- a/third_party/nsync/panic.c
+++ b/third_party/nsync/panic.c
@@ -18,15 +18,15 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
-#include "libc/intrin/describebacktrace.internal.h"
+#include "libc/intrin/describebacktrace.h"
 #include "libc/runtime/runtime.h"
 #include "third_party/nsync/common.internal.h"
 
 /* Aborts after printing the nul-terminated string s[]. */
 void nsync_panic_ (const char *s) {
-	tinyprint(2, "error: nsync panic: ", s,
-		"cosmoaddr2line ", program_invocation_name, " ",
-		DescribeBacktrace (__builtin_frame_address (0)), "\n",
-		NULL);
-	_Exit (44);
+	tinyprint (2, "error: nsync panic: ", s,
+		   "cosmoaddr2line ", program_invocation_name, " ",
+		   DescribeBacktrace (__builtin_frame_address (0)), "\n",
+		   NULL);
+	__builtin_trap ();
 }
diff --git a/third_party/nsync/testing/BUILD.mk b/third_party/nsync/testing/BUILD.mk
index 1ddb4368b..d7e261430 100644
--- a/third_party/nsync/testing/BUILD.mk
+++ b/third_party/nsync/testing/BUILD.mk
@@ -8,12 +8,13 @@ THIRD_PARTY_NSYNC_TESTING_A = o/$(MODE)/third_party/nsync/testing/lib.a
 THIRD_PARTY_NSYNC_TESTING_FILES = $(wildcard third_party/nsync/testing/*)
 THIRD_PARTY_NSYNC_TESTING_SRCS = $(filter %.c,$(THIRD_PARTY_NSYNC_TESTING_FILES))
 THIRD_PARTY_NSYNC_TESTING_HDRS = $(filter %.h,$(THIRD_PARTY_NSYNC_TESTING_FILES))
+THIRD_PARTY_NSYNC_TESTING_INCS = $(filter %.inc,$(THIRD_PARTY_NSYNC_TESTING_FILES))
 THIRD_PARTY_NSYNC_TESTING_SRCS_TEST = $(filter %_test.c,$(THIRD_PARTY_NSYNC_TESTING_SRCS))
 THIRD_PARTY_NSYNC_TESTING_OBJS = $(THIRD_PARTY_NSYNC_TESTING_SRCS:%.c=o/$(MODE)/%.o)
 THIRD_PARTY_NSYNC_TESTING_COMS = $(THIRD_PARTY_NSYNC_TESTING_SRCS_TEST:%.c=o/$(MODE)/%)
 THIRD_PARTY_NSYNC_TESTING_BINS = $(THIRD_PARTY_NSYNC_TESTING_COMS) $(THIRD_PARTY_NSYNC_TESTING_COMS:%=%.dbg)
-THIRD_PARTY_NSYNC_TESTING_TESTS_ = $(THIRD_PARTY_NSYNC_TESTING_SRCS_TEST:%.c=o/$(MODE)/%.ok)
-THIRD_PARTY_NSYNC_TESTING_CHECKS_ = $(THIRD_PARTY_NSYNC_TESTING_SRCS_TEST:%.c=o/$(MODE)/%.runs)
+THIRD_PARTY_NSYNC_TESTING_TESTS = $(THIRD_PARTY_NSYNC_TESTING_SRCS_TEST:%.c=o/$(MODE)/%.ok)
+THIRD_PARTY_NSYNC_TESTING_CHECKS = $(THIRD_PARTY_NSYNC_TESTING_SRCS_TEST:%.c=o/$(MODE)/%.runs)
 
 THIRD_PARTY_NSYNC_TESTING_DIRECTDEPS =				\
 	LIBC_CALLS						\
@@ -51,15 +52,28 @@ o/$(MODE)/third_party/nsync/testing/%_test.dbg:			\
 		$(APE_NO_MODIFY_SELF)
 	@$(APELINK)
 
+o/$(MODE)/third_party/nsync/testing/mu_starvation_test.ok: private QUOTA = -L300
+o/$(MODE)/third_party/nsync/testing/mu_starvation_test.runs: private QUOTA = -C128 -L300
+o/$(MODE)/third_party/nsync/testing/mu_test.ok: private QUOTA = -L300
+o/$(MODE)/third_party/nsync/testing/mu2_test.ok: private QUOTA = -L300
+o/$(MODE)/third_party/nsync/testing/mu3_test.ok: private QUOTA = -L300
+o/$(MODE)/third_party/nsync/testing/cv_mu_timeout_stress_test.ok: private QUOTA = -L300
+o/$(MODE)/third_party/nsync/testing/cv_mu_timeout_stress2_test.ok: private QUOTA = -L300
+o/$(MODE)/third_party/nsync/testing/cv_mu_timeout_stress3_test.ok: private QUOTA = -L300
+o/$(MODE)/third_party/nsync/testing/mu_test.runs: private QUOTA = -C128 -L300
+o/$(MODE)/third_party/nsync/testing/mu2_test.runs: private QUOTA = -C128 -L300
+o/$(MODE)/third_party/nsync/testing/mu3_test.runs: private QUOTA = -C128 -L300
+o/$(MODE)/third_party/nsync/testing/wait_test.ok: private QUOTA = -P65536
+o/$(MODE)/third_party/nsync/testing/wait_test.runs: private QUOTA = -P65536
+
 $(THIRD_PARTY_NSYNC_TESTING_OBJS): third_party/nsync/testing/BUILD.mk
-o/$(MODE)/third_party/nsync/testing/mu_test.runs: private QUOTA = -C64
 
 .PHONY: o/$(MODE)/third_party/nsync/testing
 o/$(MODE)/third_party/nsync/testing:				\
-	$(THIRD_PARTY_NSYNC_TESTING_CHECKS_)			\
-	$(THIRD_PARTY_NSYNC_TESTING_BINS_)
+	$(THIRD_PARTY_NSYNC_TESTING_CHECKS)			\
+	$(THIRD_PARTY_NSYNC_TESTING_BINS)
 
 .PHONY: o/$(MODE)/third_party/nsync/test
 o/$(MODE)/third_party/nsync/test:				\
-	$(THIRD_PARTY_NSYNC_TESTING_CHECKS_)			\
-	$(THIRD_PARTY_NSYNC_TESTING_TESTS_)
+	$(THIRD_PARTY_NSYNC_TESTING_CHECKS)			\
+	$(THIRD_PARTY_NSYNC_TESTING_TESTS)
diff --git a/third_party/nsync/testing/counter_test.c b/third_party/nsync/testing/counter_test.c
index 99a9c0b95..eb53a702a 100644
--- a/third_party/nsync/testing/counter_test.c
+++ b/third_party/nsync/testing/counter_test.c
@@ -19,6 +19,7 @@
 #include "third_party/nsync/testing/closure.h"
 #include "third_party/nsync/testing/smprintf.h"
 #include "third_party/nsync/testing/testing.h"
+#include "third_party/nsync/time.h"
 #include "third_party/nsync/testing/time_extra.h"
 
 /* Verify the properties of a zero counter. */
@@ -29,10 +30,10 @@ static void test_counter_zero (testing t) {
 		if (nsync_counter_value (c) != 0) {
 			TEST_ERROR (t, ("zero counter is not zero (test, %d)", i));
 		}
-		if (nsync_counter_wait (c, nsync_time_zero) != 0) {
+		if (nsync_counter_wait (c, NSYNC_CLOCK, nsync_time_zero) != 0) {
 			TEST_ERROR (t, ("zero counter is not zero (poll, %d)", i));
 		}
-		if (nsync_counter_wait (c, nsync_time_no_deadline) != 0) {
+		if (nsync_counter_wait (c, NSYNC_CLOCK, nsync_time_no_deadline) != 0) {
 			TEST_ERROR (t, ("zero counter is not zero (infinite wait, %d)", i));
 		}
 		nsync_counter_add (c, 0);
@@ -50,15 +51,15 @@ static void test_counter_non_zero (testing t) {
 	if (nsync_counter_value (c) != 1) {
 		TEST_ERROR (t, ("counter is not 1 (test)"));
 	}
-	if (nsync_counter_wait (c, nsync_time_zero) != 1) {
+	if (nsync_counter_wait (c, NSYNC_CLOCK, nsync_time_zero) != 1) {
 		TEST_ERROR (t, ("counter is not 1 (poll)"));
 	}
-	start = nsync_time_now ();
-	abs_deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (1000));
-	if (nsync_counter_wait (c, abs_deadline) != 1) {
+	start = nsync_time_now (NSYNC_CLOCK);
+	abs_deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1000));
+	if (nsync_counter_wait (c, NSYNC_CLOCK, abs_deadline) != 1) {
 		TEST_ERROR (t, ("counter is not 1 (1s wait)"));
 	}
-	waited = nsync_time_sub (nsync_time_now (), start);
+	waited = nsync_time_sub (nsync_time_now (NSYNC_CLOCK), start);
 	if (nsync_time_cmp (waited, nsync_time_ms (900)) < 0) {
 		TEST_ERROR (t, ("timed wait on non-zero counter returned too quickly (1s wait took %s)",
 			   nsync_time_str (waited, 2)));
@@ -75,17 +76,17 @@ static void test_counter_non_zero (testing t) {
 	if (nsync_counter_value (c) != 0) {
 		TEST_ERROR (t, ("zero counter note is not 0 (test)"));
 	}
-	if (nsync_counter_wait (c, nsync_time_zero) != 0) {
+	if (nsync_counter_wait (c, NSYNC_CLOCK, nsync_time_zero) != 0) {
 		TEST_ERROR (t, ("zero counter note is not 0 (poll)"));
 	}
-	if (nsync_counter_wait (c, nsync_time_no_deadline) != 0) {
+	if (nsync_counter_wait (c, NSYNC_CLOCK, nsync_time_no_deadline) != 0) {
 		TEST_ERROR (t, ("zero counter note is not 0 (infinite wait)"));
 	}
 	nsync_counter_free (c);
 }
 
 static void decrement_at (nsync_counter c, nsync_time abs_deadline) {
-	nsync_time_sleep_until (abs_deadline);
+	nsync_time_sleep_until (NSYNC_CLOCK, abs_deadline);
 	nsync_counter_add (c, -1);
 }
 
@@ -97,12 +98,12 @@ static void test_counter_decrement (testing t) {
 	nsync_time waited;
 	nsync_counter c = nsync_counter_new (1);
 	closure_fork (closure_decrement (&decrement_at, c,
-		nsync_time_add (nsync_time_now (), nsync_time_ms (1000))));
-	start = nsync_time_now ();
-	if (nsync_counter_wait (c, nsync_time_no_deadline) != 0) {
+		nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1000))));
+	start = nsync_time_now (NSYNC_CLOCK);
+	if (nsync_counter_wait (c, NSYNC_CLOCK, nsync_time_no_deadline) != 0) {
 		TEST_ERROR (t, ("counter is not 0"));
 	}
-	waited = nsync_time_sub (nsync_time_now (), start);
+	waited = nsync_time_sub (nsync_time_now (NSYNC_CLOCK), start);
 	if (nsync_time_cmp (waited, nsync_time_ms (900)) < 0) {
 		TEST_ERROR (t, ("counter wait too fast (1s delay took %s)", nsync_time_str (waited, 2)));
 	}
@@ -112,22 +113,22 @@ static void test_counter_decrement (testing t) {
 	if (nsync_counter_value (c) != 0) {
 		TEST_ERROR (t, ("counter is not 0 (test)"));
 	}
-	if (nsync_counter_wait (c, nsync_time_zero) != 0) {
+	if (nsync_counter_wait (c, NSYNC_CLOCK, nsync_time_zero) != 0) {
 		TEST_ERROR (t, ("counter is not 0 (poll)"));
 	}
-	if (nsync_counter_wait (c, nsync_time_no_deadline) != 0) {
+	if (nsync_counter_wait (c, NSYNC_CLOCK, nsync_time_no_deadline) != 0) {
 		TEST_ERROR (t, ("counter is not 0 (infinite wait)"));
 	}
 	nsync_counter_free (c);
 
 	c = nsync_counter_new (1);
 	closure_fork (closure_decrement (&decrement_at, c,
-		nsync_time_add (nsync_time_now (), nsync_time_ms (1000))));
-	start = nsync_time_now ();
+		nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1000))));
+	start = nsync_time_now (NSYNC_CLOCK);
 	while (nsync_counter_value (c) != 0) {
-		nsync_time_sleep (nsync_time_ms (10));
+		nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (10));
 	}
-	waited = nsync_time_sub (nsync_time_now (), start);
+	waited = nsync_time_sub (nsync_time_now (NSYNC_CLOCK), start);
 	if (nsync_time_cmp (waited, nsync_time_ms (900)) < 0) {
 		TEST_ERROR (t, ("counter wait too fast (1s delay took %s)", nsync_time_str (waited, 2)));
 	}
@@ -137,10 +138,10 @@ static void test_counter_decrement (testing t) {
 	if (nsync_counter_value (c) != 0) {
 		TEST_ERROR (t, ("counter is not 0 (test)"));
 	}
-	if (nsync_counter_wait (c, nsync_time_zero) != 0) {
+	if (nsync_counter_wait (c, NSYNC_CLOCK, nsync_time_zero) != 0) {
 		TEST_ERROR (t, ("counter is not 0 (poll)"));
 	}
-	if (nsync_counter_wait (c, nsync_time_no_deadline) != 0) {
+	if (nsync_counter_wait (c, NSYNC_CLOCK, nsync_time_no_deadline) != 0) {
 		TEST_ERROR (t, ("counter is not 0 (infinite wait)"));
 	}
 	nsync_counter_free (c);
diff --git a/third_party/nsync/testing/cv2_test.c b/third_party/nsync/testing/cv2_test.c
new file mode 100644
index 000000000..47cc96485
--- /dev/null
+++ b/third_party/nsync/testing/cv2_test.c
@@ -0,0 +1,24 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/testing/cv_test.inc"
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+	TEST_RUN (tb, test_cv_deadline);
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/cv3_test.c b/third_party/nsync/testing/cv3_test.c
new file mode 100644
index 000000000..52e0e9839
--- /dev/null
+++ b/third_party/nsync/testing/cv3_test.c
@@ -0,0 +1,24 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/testing/cv_test.inc"
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+	TEST_RUN (tb, test_cv_cancel);
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/cv_mu_timeout_stress2_test.c b/third_party/nsync/testing/cv_mu_timeout_stress2_test.c
new file mode 100644
index 000000000..94127460d
--- /dev/null
+++ b/third_party/nsync/testing/cv_mu_timeout_stress2_test.c
@@ -0,0 +1,24 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/testing/cv_mu_timeout_stress_test.inc"
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+	TEST_RUN (tb, test_mu_timeout_stress);
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/cv_mu_timeout_stress3_test.c b/third_party/nsync/testing/cv_mu_timeout_stress3_test.c
new file mode 100644
index 000000000..8b74d34be
--- /dev/null
+++ b/third_party/nsync/testing/cv_mu_timeout_stress3_test.c
@@ -0,0 +1,24 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/testing/cv_mu_timeout_stress_test.inc"
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+	TEST_RUN (tb, test_mu_cv_timeout_stress);
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/cv_mu_timeout_stress_test.c b/third_party/nsync/testing/cv_mu_timeout_stress_test.c
new file mode 100644
index 000000000..6c9cf3a63
--- /dev/null
+++ b/third_party/nsync/testing/cv_mu_timeout_stress_test.c
@@ -0,0 +1,24 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/testing/cv_mu_timeout_stress_test.inc"
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+	TEST_RUN (tb, test_cv_timeout_stress);
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/cv_mu_timeout_stress_test.inc b/third_party/nsync/testing/cv_mu_timeout_stress_test.inc
new file mode 100644
index 000000000..ea9f259a9
--- /dev/null
+++ b/third_party/nsync/testing/cv_mu_timeout_stress_test.inc
@@ -0,0 +1,553 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/stdio/rand.h"
+#include "libc/str/str.h"
+#include "third_party/nsync/time.h"
+#include "third_party/nsync/cv.h"
+#include "third_party/nsync/mu.h"
+#include "third_party/nsync/mu_wait.h"
+#include "third_party/nsync/testing/closure.h"
+#include "third_party/nsync/testing/smprintf.h"
+#include "libc/dce.h"
+#include "third_party/nsync/testing/testing.h"
+
+/* A cv_stress_data represents the data used by the threads of the tests below. */
+typedef struct cv_stress_data_s {
+	nsync_mu mu; /* protects fields below */
+	uintmax_t count;   /* incremented by the various threads */
+	uintmax_t timeouts;   /* incremented on each timeout */
+	uintmax_t reader_loops;   /* the number of loops executed by the reader threads, if any */
+
+	unsigned refs; /* ref count: one per normal test thread, decremented on its exit */
+	unsigned reader_refs; /* ref count: one per reader test thread, decremented on its exit */
+
+	int use_cv;        /* threads are using CVs; under mu */
+	nsync_cv count_is_imod4[4]; /* element i signalled when count==i mod 4 if use_cv non-0. */
+	nsync_cv refs_is_zero;    /* signalled when refs==0 */
+	nsync_cv reader_refs_is_zero;    /* signalled when reader_refs==0 */
+
+
+	/* iterations per writer thread; under mu--increased until deadline exceeded */
+	uintmax_t loop_count;
+
+	/* number of various types of thread to create -- r/o after init */
+	uintmax_t cv_threads_per_value;
+	uintmax_t cv_reader_threads_per_value;
+	uintmax_t mu_threads_per_value;
+	uintmax_t mu_reader_threads_per_value;
+
+	/* end times */
+	nsync_time deadline;  /* r/o after init */
+} cv_stress_data;
+
+/* --------------------------- */
+
+/* The delays in cv_stress_inc_loop(), cv_stress_reader_loop(), mu_stress_inc_loop(),
+   and mu_stress_reader_loop() are uniformly distributed from 0 to
+   STRESS_MAX_DELAY_MICROS-1 microseconds. */
+#define STRESS_MAX_DELAY_MICROS (IsNetbsd() || IsOpenbsd() ? 30000 : 4000)  /* maximum delay */
+#define STRESS_MEAN_DELAY_MICROS (STRESS_MAX_DELAY_MICROS / 2)              /* mean delay */
+#define STRESS_EXPECT_TIMEOUTS_PER_SEC (1000000 / STRESS_MEAN_DELAY_MICROS) /* expect timeouts/s*/
+
+/* Acquire s.mu, then increment s.count n times, each time
+   waiting until condition is true.  Use a random delay between 0us and 999us
+   for each wait; if the timeout expires, increment s.timeouts, and
+   retry the wait.  Decrement s.refs before the returning. */
+static void cv_stress_inc_loop (cv_stress_data *s, uintmax_t count_imod4) {
+	uintmax_t i;
+	nsync_mu_lock (&s->mu);
+	s->use_cv = 1;
+	nsync_mu_assert_held (&s->mu);
+	for (i = 0; i != s->loop_count; i++) {
+		nsync_mu_assert_held (&s->mu);
+		while ((s->count & 3) != count_imod4) {
+			nsync_time abs_deadline;
+			abs_deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK),
+				nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
+			while (nsync_cv_wait_with_deadline (
+					&s->count_is_imod4[count_imod4],
+					&s->mu, NSYNC_CLOCK, abs_deadline, NULL) != 0 &&
+			       (s->count&3) != count_imod4) {
+				nsync_mu_assert_held (&s->mu);
+				s->timeouts++;
+				nsync_mu_assert_held (&s->mu);
+				abs_deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK),
+				       nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
+			}
+		}
+		nsync_mu_assert_held (&s->mu);
+		s->count++;
+		nsync_cv_signal (&s->count_is_imod4[s->count&3]);
+	}
+	s->refs--;
+	if (s->refs == 0) {
+		if (s->reader_refs != 0) { /* wake any readers so they will exit */
+			for (i = 0; i != 4; i++) {
+				nsync_cv_broadcast (&s->count_is_imod4[i]);
+			}
+		}
+		nsync_cv_signal (&s->refs_is_zero);
+	}
+	nsync_mu_assert_held (&s->mu);
+	nsync_mu_unlock (&s->mu);
+}
+
+CLOSURE_DECL_BODY2 (cv_stress_inc_loop, cv_stress_data *, uintmax_t)
+
+/* Acquires s.u in reader mode, and wait until a
+   condition is true or a timeout occurs on a random wait between 0us and 999us, repeatedly.
+   Every 16 times, release the reader lock, but immediately reacquire it.
+   Once the count of threads running cv_stress_inc_loop() reaches zero (s.refs == 0),
+   sum the number of loops complete into s.reader_loops, and
+   the number of timeouts experience into s.timeouts.
+   Then decrement s.reader_refs before returning. */
+static void cv_stress_reader_loop (cv_stress_data *s, uintmax_t count_imod4) {
+	uintmax_t loops;
+	uintmax_t timeouts = 0;
+	nsync_mu_lock (&s->mu);
+	s->use_cv = 1;
+	nsync_mu_unlock (&s->mu);
+	nsync_mu_rlock (&s->mu);
+	nsync_mu_rassert_held (&s->mu);
+	loops = 0;
+	while (s->refs != 0) {
+		nsync_mu_rassert_held (&s->mu);
+		while ((s->count&3) != count_imod4 && s->refs != 0) {
+			nsync_time abs_deadline;
+			abs_deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK),
+				nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
+			while (nsync_cv_wait_with_deadline (&s->count_is_imod4[count_imod4],
+							    &s->mu, NSYNC_CLOCK,
+							    abs_deadline, NULL) != 0 &&
+			       (s->count&3) != count_imod4 && s->refs != 0) {
+
+				nsync_mu_rassert_held (&s->mu);
+				timeouts++;
+				abs_deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK),
+					nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
+			}
+		}
+		nsync_mu_rassert_held (&s->mu);
+		loops++;
+		if ((loops & 0xf) == 0) {
+			nsync_mu_runlock (&s->mu);
+			if ((loops & 0xfff) == 0) {
+				nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (1));
+			}
+			nsync_mu_rlock (&s->mu);
+		}
+	}
+	nsync_mu_rassert_held (&s->mu);
+	nsync_mu_runlock (&s->mu);
+
+	nsync_mu_lock (&s->mu);
+	s->reader_loops += loops;
+	s->timeouts += timeouts;
+	s->reader_refs--;
+	if (s->reader_refs == 0) {
+		nsync_cv_signal (&s->reader_refs_is_zero);
+	}
+	nsync_mu_assert_held (&s->mu);
+	nsync_mu_unlock (&s->mu);
+}
+
+CLOSURE_DECL_BODY2 (cv_stress_reader_loop, cv_stress_data *, uintmax_t)
+
+
+
+/* --------------------------- */
+
+/* These tests use the data structure cv_stress_data defined above.
+   One test uses nsync_mu and nsync_cv, one nsync_mu and its conditional critical sections, while
+   a third mixes conditional critical sections and condition variables; they
+   all the routines above */
+
+/* ---------------------------
+   The various conditions that threads wait for on cv_stress_data. */
+static int count_is0mod4 (const void *v) {
+	const cv_stress_data *s = (const cv_stress_data *) v;
+	nsync_mu_rassert_held (&s->mu);
+	return ((s->count & 3) == 0);
+}
+static int count_is1mod4 (const void *v) {
+	const cv_stress_data *s = (const cv_stress_data *) v;
+	nsync_mu_rassert_held (&s->mu);
+	return ((s->count & 3) == 1);
+}
+static int count_is2mod4 (const void *v) {
+	const cv_stress_data *s = (const cv_stress_data *) v;
+	nsync_mu_rassert_held (&s->mu);
+	return ((s->count & 3) == 2);
+}
+static int count_is3mod4 (const void *v) {
+	const cv_stress_data *s = (const cv_stress_data *) v;
+	nsync_mu_rassert_held (&s->mu);
+	return ((s->count & 3) == 3);
+}
+static int count_is0mod4or_refs_is0 (const void *v) {
+	const cv_stress_data *s = (const cv_stress_data *) v;
+	nsync_mu_rassert_held (&s->mu);
+	return ((s->count&3) == 0 || s->refs == 0);
+}
+static int count_is1mod4or_refs_is0 (const void *v) {
+	const cv_stress_data *s = (const cv_stress_data *) v;
+	nsync_mu_rassert_held (&s->mu);
+	return ((s->count&3) == 1 || s->refs == 0);
+}
+static int count_is2mod4or_refs_is0 (const void *v) {
+	const cv_stress_data *s = (const cv_stress_data *) v;
+	nsync_mu_rassert_held (&s->mu);
+	return ((s->count&3) == 2 || s->refs == 0);
+}
+static int count_is3mod4or_refs_is0 (const void *v) {
+	const cv_stress_data *s = (const cv_stress_data *) v;
+	nsync_mu_rassert_held (&s->mu);
+	return ((s->count&3) == 3 || s->refs == 0);
+}
+
+/* --------------------------- */
+
+typedef int (*condition_func) (const void *);
+
+/* Acquire s.mu, then increment s.count n times, each time
+   waiting until condition is true.  Use a random delay between 0us and 999us
+   for each wait; if the timeout expires, increment s.timeouts, and
+   the retry the wait.  Decrement s.refs before returning. */
+static void mu_stress_inc_loop (cv_stress_data *s, condition_func condition,
+				const void *condition_arg) {
+	uintmax_t i;
+	nsync_mu_lock (&s->mu);
+	nsync_mu_assert_held (&s->mu);
+	for (i = 0; i != s->loop_count; i++) {
+		nsync_time abs_deadline;
+		nsync_mu_assert_held (&s->mu);
+
+		abs_deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK),
+			nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
+		while (nsync_mu_wait_with_deadline (&s->mu, condition, condition_arg, NULL,
+						    NSYNC_CLOCK, abs_deadline, NULL) != 0) {
+			nsync_mu_assert_held (&s->mu);
+			s->timeouts++;
+			nsync_mu_assert_held (&s->mu);
+			abs_deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK),
+				nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
+		}
+
+		nsync_mu_assert_held (&s->mu);
+		s->count++;
+		if (s->use_cv) {
+			nsync_cv_signal (&s->count_is_imod4[s->count&3]);
+		}
+	}
+	s->refs--;
+	if (s->refs == 0) {
+		if (s->use_cv && s->reader_refs != 0) { /* wake any readers so they will exit */
+			for (i = 0; i != 4; i++) {
+				nsync_cv_broadcast (&s->count_is_imod4[i]);
+			}
+		}
+		nsync_cv_signal (&s->refs_is_zero);
+	}
+	nsync_mu_assert_held (&s->mu);
+	nsync_mu_unlock (&s->mu);
+}
+
+CLOSURE_DECL_BODY3 (mu_stress_inc_loop, cv_stress_data *, condition_func, const void *)
+
+
+/* Acquire s.u in reader mode, and wait until a
+   condition is true or a timeout occurs on a random wait between 0us and 999us, repeatedly.
+   Every 16 times, release the reader lock, but immediately reacquire it.
+   Once the count of threads running mu_stress_inc_loop() reaches zero (s.refs == 0),
+   sum the number of loops completed into s.reader_loops, and
+   the number of timeouts it experienced into s.timeouts.
+   Then decrement s.reader_refs before returning. */
+static void mu_stress_reader_loop (cv_stress_data *s, condition_func condition,
+				   const void *condition_arg) {
+	uintmax_t loops;
+	uintmax_t timeouts = 0;
+	nsync_mu_rlock (&s->mu);
+	nsync_mu_rassert_held (&s->mu);
+	loops = 0;
+	while (s->refs != 0) {
+		nsync_time abs_deadline;
+		nsync_mu_rassert_held (&s->mu);
+		abs_deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK),
+			nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
+		while (nsync_mu_wait_with_deadline (&s->mu, condition, condition_arg, NULL,
+						    NSYNC_CLOCK, abs_deadline, NULL) != 0) {
+			nsync_mu_rassert_held (&s->mu);
+			s->timeouts++;
+			nsync_mu_rassert_held (&s->mu);
+			abs_deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK),
+				nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
+		}
+
+		nsync_mu_rassert_held (&s->mu);
+		loops++;
+		if ((loops & 0xf) == 0) {
+			nsync_mu_runlock (&s->mu);
+			if ((loops & 0xfff) == 0) {
+				nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (1));
+			}
+			nsync_mu_rlock (&s->mu);
+		}
+	}
+	nsync_mu_rassert_held (&s->mu);
+	nsync_mu_runlock (&s->mu);
+
+	nsync_mu_lock (&s->mu);
+	s->reader_loops += loops;
+	s->timeouts += timeouts;
+	s->reader_refs--;
+	if (s->reader_refs == 0) {
+		nsync_cv_signal (&s->reader_refs_is_zero);
+	}
+	nsync_mu_assert_held (&s->mu);
+	nsync_mu_unlock (&s->mu);
+}
+
+CLOSURE_DECL_BODY3 (mu_stress_reader_loop, cv_stress_data *, condition_func, const void *)
+
+static const condition_func is_n_mod_4[] = {
+	&count_is0mod4,
+	&count_is1mod4,
+	&count_is2mod4,
+	&count_is3mod4
+};
+static const condition_func is_n_mod_4_or_refs0[] = {
+	&count_is0mod4or_refs_is0,
+	&count_is1mod4or_refs_is0,
+	&count_is2mod4or_refs_is0,
+	&count_is3mod4or_refs_is0
+};
+
+/* Create cv_threads_per_value threads using cv_stress_inc_loop(),
+   and mu_threads_per_value threads using mu_stress_inc_loop(), all trying to
+   increment s.count from 1 to 2 mod 4, plus the same from 2 to 3 mod 4, and
+   again from 3 to 0 mod 4, using random delays in their waits.  Sleep a few seconds,
+   ensuring many random timeouts by these threads, because there is no thread
+   incrementing s.count from 0 (which is 0 mod 4).  Then create
+   cv_threads_per_value threads using cv_stress_inc_loop(), and mu_threads_per_value
+   threads using mu_stress_inc_loop(), all trying to increment s.count from 0 to 1
+   mod 4.  This allows all the threads to run to completion, since there are
+   equal numbers for each condition.
+
+   At the same time, create cv_reader_threads_per_value threads using cv_stress_reader_loop
+   and mu_reader_threads_per_value using mu_stress_reader_loop, for each of the transitions
+   0 to 1, 1, to 2, 2 to 3, and 3 to 0 mod 4.
+
+   All these loops count how many timeouts they encounter.  The reader loops
+   count how many times they manage to run.
+
+   These counts are tested against expected values.
+
+   Finally, it waits for all threads to exit.
+
+   It returns whether the deadlie has expired. */
+static int run_stress_test (cv_stress_data *s, testing t,
+			    const char *test_name) {
+	int done = 0;
+	uintmax_t expected_timeouts;
+	uintmax_t timeouts_seen;
+	uintmax_t expected_count;
+	uintmax_t i;
+	static const int sleep_seconds = 1;
+
+	nsync_mu_lock (&s->mu);
+	nsync_mu_assert_held (&s->mu);
+	/* Create threads trying to increment from 1, 2, and 3 mod 4.
+	   They will continually hit their timeouts because s.count==0 */
+	for (i = 0; i != s->cv_threads_per_value; i++) {
+		nsync_mu_assert_held (&s->mu);
+		s->refs++;
+		closure_fork (closure_cv_stress_inc_loop (&cv_stress_inc_loop, s, 1));
+		s->refs++;
+		closure_fork (closure_cv_stress_inc_loop (&cv_stress_inc_loop, s, 2));
+		s->refs++;
+		closure_fork (closure_cv_stress_inc_loop (&cv_stress_inc_loop, s, 3));
+	}
+	for (i = 0; i != s->cv_reader_threads_per_value; i++) {
+		nsync_mu_assert_held (&s->mu);
+		s->reader_refs++;
+		closure_fork (closure_cv_stress_reader_loop (&cv_stress_reader_loop, s, 1));
+		s->reader_refs++;
+		closure_fork (closure_cv_stress_reader_loop (&cv_stress_reader_loop, s, 2));
+		s->reader_refs++;
+		closure_fork (closure_cv_stress_reader_loop (&cv_stress_reader_loop, s, 3));
+	}
+	for (i = 0; i != s->mu_threads_per_value; i++) {
+		nsync_mu_assert_held (&s->mu);
+		s->refs++;
+		closure_fork (closure_mu_stress_inc_loop (&mu_stress_inc_loop,
+							  s, is_n_mod_4[1], s));
+		s->refs++;
+		closure_fork (closure_mu_stress_inc_loop (&mu_stress_inc_loop,
+							  s, is_n_mod_4[2], s));
+		s->refs++;
+		closure_fork (closure_mu_stress_inc_loop (&mu_stress_inc_loop,
+							  s, is_n_mod_4[3], s));
+	}
+	for (i = 0; i != s->mu_reader_threads_per_value; i++) {
+		nsync_mu_assert_held (&s->mu);
+		s->reader_refs++;
+		closure_fork (closure_mu_stress_reader_loop (&mu_stress_reader_loop,
+							     s, is_n_mod_4_or_refs0[1], s));
+		s->reader_refs++;
+		closure_fork (closure_mu_stress_reader_loop (&mu_stress_reader_loop,
+							     s, is_n_mod_4_or_refs0[2], s));
+		s->reader_refs++;
+		closure_fork (closure_mu_stress_reader_loop (&mu_stress_reader_loop,
+							     s, is_n_mod_4_or_refs0[3], s));
+	}
+	nsync_mu_assert_held (&s->mu);
+	nsync_mu_unlock (&s->mu);
+
+	/* Sleep a while to cause many timeouts. */
+	nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (sleep_seconds * 1000));
+
+	nsync_mu_lock (&s->mu);
+	nsync_mu_assert_held (&s->mu);
+
+	/* Check that approximately the right number of timeouts have occurred.
+	   The 3 below is the three classes of thread produced before the Sleep().
+	   The factor of 1/8 is to allow for randomness and slow test machines. */
+	expected_timeouts = (s->cv_threads_per_value + s->mu_threads_per_value) * 3 *
+			     sleep_seconds * STRESS_EXPECT_TIMEOUTS_PER_SEC / 8;
+	timeouts_seen = s->timeouts;
+	/* actual check is below. */
+
+	/* Create the threads that increment from 0 mod 4.   s.count will then be incremented. */
+	for (i = 0; i != s->cv_threads_per_value; i++) {
+		nsync_mu_assert_held (&s->mu);
+		s->refs++;
+		closure_fork (closure_cv_stress_inc_loop (&cv_stress_inc_loop, s, 0));
+	}
+	for (i = 0; i != s->cv_reader_threads_per_value; i++) {
+		nsync_mu_assert_held (&s->mu);
+		s->reader_refs++;
+		closure_fork (closure_cv_stress_reader_loop (&cv_stress_reader_loop, s, 0));
+	}
+	for (i = 0; i != s->mu_threads_per_value; i++) {
+		nsync_mu_assert_held (&s->mu);
+		s->refs++;
+		closure_fork (closure_mu_stress_inc_loop (&mu_stress_inc_loop,
+							  s, is_n_mod_4[0], s));
+	}
+	for (i = 0; i != s->mu_reader_threads_per_value; i++) {
+		nsync_mu_assert_held (&s->mu);
+		s->reader_refs++;
+		closure_fork (closure_mu_stress_reader_loop (&mu_stress_reader_loop,
+							     s, is_n_mod_4_or_refs0[0], s));
+	}
+
+	/* wait for threads to exit. */
+	nsync_mu_assert_held (&s->mu);
+	while (s->refs != 0) {
+		nsync_cv_wait (&s->refs_is_zero, &s->mu);
+	}
+	while (s->reader_refs != 0) {
+		nsync_cv_wait (&s->reader_refs_is_zero, &s->mu);
+	}
+
+	nsync_mu_assert_held (&s->mu);
+	nsync_mu_unlock (&s->mu);
+
+	if (nsync_time_cmp (s->deadline, nsync_time_now (NSYNC_CLOCK)) < 0) {
+		if (timeouts_seen < expected_timeouts && !testing_is_uniprocessor (t)) {
+			TEST_ERROR (t, ("%s: expected more than %d timeouts, got %d",
+				   test_name, expected_timeouts, timeouts_seen));
+		}
+
+		/* Check that s.count has the right value. */
+		expected_count = s->loop_count * (s->cv_threads_per_value +
+						  s->mu_threads_per_value) * 4;
+		if (s->count != expected_count) {
+			TEST_ERROR (t, ("%s: expected to increment s->count to %d, got %d",
+				   test_name, expected_count, s->count));
+		}
+
+		/* Some timeouts should have happened while the counts were being incremented. */
+		expected_timeouts = timeouts_seen + 1;
+		if (s->timeouts < expected_timeouts) {
+			TEST_ERROR (t, ("%s: expected more than %d timeouts, got %d",
+				   test_name, expected_timeouts, s->timeouts));
+		}
+		done = 1;
+	}
+	return (done);
+}
+
+/* Test many threads using a single lock, using
+   condition variables and timeouts.  See run_stress_test() for details. */
+static void test_cv_timeout_stress (testing t) {
+	uintmax_t loop_count = 3;
+	cv_stress_data s;
+	nsync_time deadline;
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (5000));
+	do {
+		bzero ((void *) &s, sizeof (s));
+		s.loop_count = loop_count;
+		s.cv_threads_per_value = 4;
+		s.cv_reader_threads_per_value = 2;
+		s.mu_threads_per_value = 0;
+		s.mu_reader_threads_per_value = 0;
+		s.deadline = deadline;
+		loop_count *= 2;
+	} while (!run_stress_test (&s, t, "test_cv_timeout_stress"));
+}
+
+
+/* Test many threads using a single lock, using
+   conditional critical sections and timeouts. See run_stress_test() for details. */
+static void test_mu_timeout_stress (testing t) {
+	uintmax_t loop_count = 3;
+	cv_stress_data s;
+	nsync_time deadline;
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (5000));
+	do {
+		bzero ((void *) &s, sizeof (s));
+		s.loop_count = loop_count;
+		s.cv_threads_per_value = 0;
+		s.cv_reader_threads_per_value = 0;
+		s.mu_threads_per_value = 4;
+		s.mu_reader_threads_per_value = 2;
+		s.deadline = deadline;
+		loop_count *= 2;
+	} while (!run_stress_test (&s, t, "test_mu_timeout_stress"));
+}
+
+/* Like test_mu_timeout_stress() but has both threads that use conditional
+   critical sections and threads that use condition variables, to ensure that
+   they work together.  */
+static void test_mu_cv_timeout_stress (testing t) {
+	uintmax_t loop_count = 3;
+	cv_stress_data s;
+	nsync_time deadline;
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (5000));
+	do {
+		bzero ((void *) &s, sizeof (s));
+		s.loop_count = loop_count;
+		s.cv_threads_per_value = 4;
+		s.cv_reader_threads_per_value = 1;
+		s.mu_threads_per_value = 4;
+		s.mu_reader_threads_per_value = 1;
+		s.deadline = deadline;
+		loop_count *= 2;
+	} while (!run_stress_test (&s, t, "test_mu_cv_timeout_stress"));
+}
diff --git a/third_party/nsync/testing/cv_mu_timeout_stress_test_.c b/third_party/nsync/testing/cv_mu_timeout_stress_test_.c
deleted file mode 100644
index 302ec90f5..000000000
--- a/third_party/nsync/testing/cv_mu_timeout_stress_test_.c
+++ /dev/null
@@ -1,558 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2016 Google Inc.                                                   │
-│                                                                              │
-│ 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.                                               │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdio/rand.h"
-#include "libc/str/str.h"
-#include "third_party/nsync/cv.h"
-#include "third_party/nsync/mu.h"
-#include "third_party/nsync/mu_wait.h"
-#include "third_party/nsync/testing/closure.h"
-#include "third_party/nsync/testing/smprintf.h"
-#include "third_party/nsync/testing/testing.h"
-
-/* A cv_stress_data represents the data used by the threads of the tests below. */
-typedef struct cv_stress_data_s {
-	nsync_mu mu; /* protects fields below */
-	uintmax_t count;   /* incremented by the various threads */
-	uintmax_t timeouts;   /* incremented on each timeout */
-	uintmax_t reader_loops;   /* the number of loops executed by the reader threads, if any */
-
-	unsigned refs; /* ref count: one per normal test thread, decremented on its exit */
-	unsigned reader_refs; /* ref count: one per reader test thread, decremented on its exit */
-
-	int use_cv;        /* threads are using CVs; under mu */
-	nsync_cv count_is_imod4[4]; /* element i signalled when count==i mod 4 if use_cv non-0. */
-	nsync_cv refs_is_zero;    /* signalled when refs==0 */
-	nsync_cv reader_refs_is_zero;    /* signalled when reader_refs==0 */
-
-
-	/* iterations per writer thread; under mu--increased until deadline exceeded */
-	uintmax_t loop_count;
-
-	/* number of various types of thread to create -- r/o after init */
-	uintmax_t cv_threads_per_value;
-	uintmax_t cv_reader_threads_per_value;
-	uintmax_t mu_threads_per_value;
-	uintmax_t mu_reader_threads_per_value;
-
-	/* end times */
-	nsync_time deadline;  /* r/o after init */
-} cv_stress_data;
-
-/* --------------------------- */
-
-/* The delays in cv_stress_inc_loop(), cv_stress_reader_loop(), mu_stress_inc_loop(),
-   and mu_stress_reader_loop() are uniformly distributed from 0 to
-   STRESS_MAX_DELAY_MICROS-1 microseconds. */
-#define STRESS_MAX_DELAY_MICROS (4000)                                    /* maximum delay */
-#define STRESS_MEAN_DELAY_MICROS (STRESS_MAX_DELAY_MICROS / 2)               /* mean delay */
-#define STRESS_EXPECT_TIMEOUTS_PER_SEC (1000000 / STRESS_MEAN_DELAY_MICROS) /* expect timeouts/s*/
-
-/* Acquire s.mu, then increment s.count n times, each time
-   waiting until condition is true.  Use a random delay between 0us and 999us
-   for each wait; if the timeout expires, increment s.timeouts, and
-   retry the wait.  Decrement s.refs before the returning. */
-static void cv_stress_inc_loop (cv_stress_data *s, uintmax_t count_imod4) {
-	uintmax_t i;
-	nsync_mu_lock (&s->mu);
-	s->use_cv = 1;
-	nsync_mu_assert_held (&s->mu);
-	for (i = 0; i != s->loop_count; i++) {
-		nsync_mu_assert_held (&s->mu);
-		while ((s->count & 3) != count_imod4) {
-			nsync_time abs_deadline;
-			abs_deadline = nsync_time_add (nsync_time_now (),
-				nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
-			while (nsync_cv_wait_with_deadline (
-					&s->count_is_imod4[count_imod4],
-					&s->mu, abs_deadline, NULL) != 0 &&
-			       (s->count&3) != count_imod4) {
-				nsync_mu_assert_held (&s->mu);
-				s->timeouts++;
-				nsync_mu_assert_held (&s->mu);
-				abs_deadline = nsync_time_add (nsync_time_now (),
-				       nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
-			}
-		}
-		nsync_mu_assert_held (&s->mu);
-		s->count++;
-		nsync_cv_signal (&s->count_is_imod4[s->count&3]);
-	}
-	s->refs--;
-	if (s->refs == 0) {
-		if (s->reader_refs != 0) { /* wake any readers so they will exit */
-			for (i = 0; i != 4; i++) {
-				nsync_cv_broadcast (&s->count_is_imod4[i]);
-			}
-		}
-		nsync_cv_signal (&s->refs_is_zero);
-	}
-	nsync_mu_assert_held (&s->mu);
-	nsync_mu_unlock (&s->mu);
-}
-
-CLOSURE_DECL_BODY2 (cv_stress_inc_loop, cv_stress_data *, uintmax_t)
-
-/* Acquires s.u in reader mode, and wait until a
-   condition is true or a timeout occurs on a random wait between 0us and 999us, repeatedly.
-   Every 16 times, release the reader lock, but immediately reacquire it.
-   Once the count of threads running cv_stress_inc_loop() reaches zero (s.refs == 0),
-   sum the number of loops complete into s.reader_loops, and
-   the number of timeouts experience into s.timeouts.
-   Then decrement s.reader_refs before returning. */
-static void cv_stress_reader_loop (cv_stress_data *s, uintmax_t count_imod4) {
-	uintmax_t loops;
-	uintmax_t timeouts = 0;
-	nsync_mu_lock (&s->mu);
-	s->use_cv = 1;
-	nsync_mu_unlock (&s->mu);
-	nsync_mu_rlock (&s->mu);
-	nsync_mu_rassert_held (&s->mu);
-	loops = 0;
-	while (s->refs != 0) {
-		nsync_mu_rassert_held (&s->mu);
-		while ((s->count&3) != count_imod4 && s->refs != 0) {
-			nsync_time abs_deadline;
-			abs_deadline = nsync_time_add (nsync_time_now (),
-				nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
-			while (nsync_cv_wait_with_deadline (&s->count_is_imod4[count_imod4],
-							    &s->mu, abs_deadline, NULL) != 0 &&
-			       (s->count&3) != count_imod4 && s->refs != 0) {
-
-				nsync_mu_rassert_held (&s->mu);
-				timeouts++;
-				abs_deadline = nsync_time_add (nsync_time_now (),
-					nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
-			}
-		}
-		nsync_mu_rassert_held (&s->mu);
-		loops++;
-		if ((loops & 0xf) == 0) {
-			nsync_mu_runlock (&s->mu);
-			if ((loops & 0xfff) == 0) {
-				nsync_time_sleep (nsync_time_ms (1));
-			}
-			nsync_mu_rlock (&s->mu);
-		}
-	}
-	nsync_mu_rassert_held (&s->mu);
-	nsync_mu_runlock (&s->mu);
-
-	nsync_mu_lock (&s->mu);
-	s->reader_loops += loops;
-	s->timeouts += timeouts;
-	s->reader_refs--;
-	if (s->reader_refs == 0) {
-		nsync_cv_signal (&s->reader_refs_is_zero);
-	}
-	nsync_mu_assert_held (&s->mu);
-	nsync_mu_unlock (&s->mu);
-}
-
-CLOSURE_DECL_BODY2 (cv_stress_reader_loop, cv_stress_data *, uintmax_t)
-
-
-
-/* --------------------------- */
-
-/* These tests use the data structure cv_stress_data defined above.
-   One test uses nsync_mu and nsync_cv, one nsync_mu and its conditional critical sections, while
-   a third mixes conditional critical sections and condition variables; they
-   all the routines above */
-
-/* ---------------------------
-   The various conditions that threads wait for on cv_stress_data. */
-static int count_is0mod4 (const void *v) {
-	const cv_stress_data *s = (const cv_stress_data *) v;
-	nsync_mu_rassert_held (&s->mu);
-	return ((s->count & 3) == 0);
-}
-static int count_is1mod4 (const void *v) {
-	const cv_stress_data *s = (const cv_stress_data *) v;
-	nsync_mu_rassert_held (&s->mu);
-	return ((s->count & 3) == 1);
-}
-static int count_is2mod4 (const void *v) {
-	const cv_stress_data *s = (const cv_stress_data *) v;
-	nsync_mu_rassert_held (&s->mu);
-	return ((s->count & 3) == 2);
-}
-static int count_is3mod4 (const void *v) {
-	const cv_stress_data *s = (const cv_stress_data *) v;
-	nsync_mu_rassert_held (&s->mu);
-	return ((s->count & 3) == 3);
-}
-static int count_is0mod4or_refs_is0 (const void *v) {
-	const cv_stress_data *s = (const cv_stress_data *) v;
-	nsync_mu_rassert_held (&s->mu);
-	return ((s->count&3) == 0 || s->refs == 0);
-}
-static int count_is1mod4or_refs_is0 (const void *v) {
-	const cv_stress_data *s = (const cv_stress_data *) v;
-	nsync_mu_rassert_held (&s->mu);
-	return ((s->count&3) == 1 || s->refs == 0);
-}
-static int count_is2mod4or_refs_is0 (const void *v) {
-	const cv_stress_data *s = (const cv_stress_data *) v;
-	nsync_mu_rassert_held (&s->mu);
-	return ((s->count&3) == 2 || s->refs == 0);
-}
-static int count_is3mod4or_refs_is0 (const void *v) {
-	const cv_stress_data *s = (const cv_stress_data *) v;
-	nsync_mu_rassert_held (&s->mu);
-	return ((s->count&3) == 3 || s->refs == 0);
-}
-
-/* --------------------------- */
-
-typedef int (*condition_func) (const void *);
-
-/* Acquire s.mu, then increment s.count n times, each time
-   waiting until condition is true.  Use a random delay between 0us and 999us
-   for each wait; if the timeout expires, increment s.timeouts, and
-   the retry the wait.  Decrement s.refs before returning. */
-static void mu_stress_inc_loop (cv_stress_data *s, condition_func condition,
-				const void *condition_arg) {
-	uintmax_t i;
-	nsync_mu_lock (&s->mu);
-	nsync_mu_assert_held (&s->mu);
-	for (i = 0; i != s->loop_count; i++) {
-		nsync_time abs_deadline;
-		nsync_mu_assert_held (&s->mu);
-
-		abs_deadline = nsync_time_add (nsync_time_now (),
-			nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
-		while (nsync_mu_wait_with_deadline (&s->mu, condition, condition_arg, NULL,
-						    abs_deadline, NULL) != 0) {
-			nsync_mu_assert_held (&s->mu);
-			s->timeouts++;
-			nsync_mu_assert_held (&s->mu);
-			abs_deadline = nsync_time_add (nsync_time_now (),
-				nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
-		}
-
-		nsync_mu_assert_held (&s->mu);
-		s->count++;
-		if (s->use_cv) {
-			nsync_cv_signal (&s->count_is_imod4[s->count&3]);
-		}
-	}
-	s->refs--;
-	if (s->refs == 0) {
-		if (s->use_cv && s->reader_refs != 0) { /* wake any readers so they will exit */
-			for (i = 0; i != 4; i++) {
-				nsync_cv_broadcast (&s->count_is_imod4[i]);
-			}
-		}
-		nsync_cv_signal (&s->refs_is_zero);
-	}
-	nsync_mu_assert_held (&s->mu);
-	nsync_mu_unlock (&s->mu);
-}
-
-CLOSURE_DECL_BODY3 (mu_stress_inc_loop, cv_stress_data *, condition_func, const void *)
-
-
-/* Acquire s.u in reader mode, and wait until a
-   condition is true or a timeout occurs on a random wait between 0us and 999us, repeatedly.
-   Every 16 times, release the reader lock, but immediately reacquire it.
-   Once the count of threads running mu_stress_inc_loop() reaches zero (s.refs == 0),
-   sum the number of loops completed into s.reader_loops, and
-   the number of timeouts it experienced into s.timeouts.
-   Then decrement s.reader_refs before returning. */
-static void mu_stress_reader_loop (cv_stress_data *s, condition_func condition,
-				   const void *condition_arg) {
-	uintmax_t loops;
-	uintmax_t timeouts = 0;
-	nsync_mu_rlock (&s->mu);
-	nsync_mu_rassert_held (&s->mu);
-	loops = 0;
-	while (s->refs != 0) {
-		nsync_time abs_deadline;
-		nsync_mu_rassert_held (&s->mu);
-		abs_deadline = nsync_time_add (nsync_time_now (),
-			nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
-		while (nsync_mu_wait_with_deadline (&s->mu, condition, condition_arg, NULL,
-						    abs_deadline, NULL) != 0) {
-			nsync_mu_rassert_held (&s->mu);
-			s->timeouts++;
-			nsync_mu_rassert_held (&s->mu);
-			abs_deadline = nsync_time_add (nsync_time_now (),
-				nsync_time_us (rand () % STRESS_MAX_DELAY_MICROS));
-		}
-
-		nsync_mu_rassert_held (&s->mu);
-		loops++;
-		if ((loops & 0xf) == 0) {
-			nsync_mu_runlock (&s->mu);
-			if ((loops & 0xfff) == 0) {
-				nsync_time_sleep (nsync_time_ms (1));
-			}
-			nsync_mu_rlock (&s->mu);
-		}
-	}
-	nsync_mu_rassert_held (&s->mu);
-	nsync_mu_runlock (&s->mu);
-
-	nsync_mu_lock (&s->mu);
-	s->reader_loops += loops;
-	s->timeouts += timeouts;
-	s->reader_refs--;
-	if (s->reader_refs == 0) {
-		nsync_cv_signal (&s->reader_refs_is_zero);
-	}
-	nsync_mu_assert_held (&s->mu);
-	nsync_mu_unlock (&s->mu);
-}
-
-CLOSURE_DECL_BODY3 (mu_stress_reader_loop, cv_stress_data *, condition_func, const void *)
-
-static const condition_func is_n_mod_4[] = {
-	&count_is0mod4,
-	&count_is1mod4,
-	&count_is2mod4,
-	&count_is3mod4
-};
-static const condition_func is_n_mod_4_or_refs0[] = {
-	&count_is0mod4or_refs_is0,
-	&count_is1mod4or_refs_is0,
-	&count_is2mod4or_refs_is0,
-	&count_is3mod4or_refs_is0
-};
-
-/* Create cv_threads_per_value threads using cv_stress_inc_loop(),
-   and mu_threads_per_value threads using mu_stress_inc_loop(), all trying to
-   increment s.count from 1 to 2 mod 4, plus the same from 2 to 3 mod 4, and
-   again from 3 to 0 mod 4, using random delays in their waits.  Sleep a few seconds,
-   ensuring many random timeouts by these threads, because there is no thread
-   incrementing s.count from 0 (which is 0 mod 4).  Then create
-   cv_threads_per_value threads using cv_stress_inc_loop(), and mu_threads_per_value
-   threads using mu_stress_inc_loop(), all trying to increment s.count from 0 to 1
-   mod 4.  This allows all the threads to run to completion, since there are
-   equal numbers for each condition.
-
-   At the same time, create cv_reader_threads_per_value threads using cv_stress_reader_loop
-   and mu_reader_threads_per_value using mu_stress_reader_loop, for each of the transitions
-   0 to 1, 1, to 2, 2 to 3, and 3 to 0 mod 4.
-
-   All these loops count how many timeouts they encounter.  The reader loops
-   count how many times they manage to run.
-
-   These counts are tested against expected values.
-
-   Finally, it waits for all threads to exit.
-
-   It returns whether the deadlie has expired. */
-static int run_stress_test (cv_stress_data *s, testing t,
-			    const char *test_name) {
-	int done = 0;
-	uintmax_t expected_timeouts;
-	uintmax_t timeouts_seen;
-	uintmax_t expected_count;
-	uintmax_t i;
-	static const int sleep_seconds = 1;
-
-	nsync_mu_lock (&s->mu);
-	nsync_mu_assert_held (&s->mu);
-	/* Create threads trying to increment from 1, 2, and 3 mod 4.
-	   They will continually hit their timeouts because s.count==0 */
-	for (i = 0; i != s->cv_threads_per_value; i++) {
-		nsync_mu_assert_held (&s->mu);
-		s->refs++;
-		closure_fork (closure_cv_stress_inc_loop (&cv_stress_inc_loop, s, 1));
-		s->refs++;
-		closure_fork (closure_cv_stress_inc_loop (&cv_stress_inc_loop, s, 2));
-		s->refs++;
-		closure_fork (closure_cv_stress_inc_loop (&cv_stress_inc_loop, s, 3));
-	}
-	for (i = 0; i != s->cv_reader_threads_per_value; i++) {
-		nsync_mu_assert_held (&s->mu);
-		s->reader_refs++;
-		closure_fork (closure_cv_stress_reader_loop (&cv_stress_reader_loop, s, 1));
-		s->reader_refs++;
-		closure_fork (closure_cv_stress_reader_loop (&cv_stress_reader_loop, s, 2));
-		s->reader_refs++;
-		closure_fork (closure_cv_stress_reader_loop (&cv_stress_reader_loop, s, 3));
-	}
-	for (i = 0; i != s->mu_threads_per_value; i++) {
-		nsync_mu_assert_held (&s->mu);
-		s->refs++;
-		closure_fork (closure_mu_stress_inc_loop (&mu_stress_inc_loop,
-							  s, is_n_mod_4[1], s));
-		s->refs++;
-		closure_fork (closure_mu_stress_inc_loop (&mu_stress_inc_loop,
-							  s, is_n_mod_4[2], s));
-		s->refs++;
-		closure_fork (closure_mu_stress_inc_loop (&mu_stress_inc_loop,
-							  s, is_n_mod_4[3], s));
-	}
-	for (i = 0; i != s->mu_reader_threads_per_value; i++) {
-		nsync_mu_assert_held (&s->mu);
-		s->reader_refs++;
-		closure_fork (closure_mu_stress_reader_loop (&mu_stress_reader_loop,
-							     s, is_n_mod_4_or_refs0[1], s));
-		s->reader_refs++;
-		closure_fork (closure_mu_stress_reader_loop (&mu_stress_reader_loop,
-							     s, is_n_mod_4_or_refs0[2], s));
-		s->reader_refs++;
-		closure_fork (closure_mu_stress_reader_loop (&mu_stress_reader_loop,
-							     s, is_n_mod_4_or_refs0[3], s));
-	}
-	nsync_mu_assert_held (&s->mu);
-	nsync_mu_unlock (&s->mu);
-
-	/* Sleep a while to cause many timeouts. */
-	nsync_time_sleep (nsync_time_ms (sleep_seconds * 1000));
-
-	nsync_mu_lock (&s->mu);
-	nsync_mu_assert_held (&s->mu);
-
-	/* Check that approximately the right number of timeouts have occurred.
-	   The 3 below is the three classes of thread produced before the Sleep().
-	   The factor of 1/8 is to allow for randomness and slow test machines. */
-	expected_timeouts = (s->cv_threads_per_value + s->mu_threads_per_value) * 3 *
-			     sleep_seconds * STRESS_EXPECT_TIMEOUTS_PER_SEC / 8;
-	timeouts_seen = s->timeouts;
-	/* actual check is below. */
-
-	/* Create the threads that increment from 0 mod 4.   s.count will then be incremented. */
-	for (i = 0; i != s->cv_threads_per_value; i++) {
-		nsync_mu_assert_held (&s->mu);
-		s->refs++;
-		closure_fork (closure_cv_stress_inc_loop (&cv_stress_inc_loop, s, 0));
-	}
-	for (i = 0; i != s->cv_reader_threads_per_value; i++) {
-		nsync_mu_assert_held (&s->mu);
-		s->reader_refs++;
-		closure_fork (closure_cv_stress_reader_loop (&cv_stress_reader_loop, s, 0));
-	}
-	for (i = 0; i != s->mu_threads_per_value; i++) {
-		nsync_mu_assert_held (&s->mu);
-		s->refs++;
-		closure_fork (closure_mu_stress_inc_loop (&mu_stress_inc_loop,
-							  s, is_n_mod_4[0], s));
-	}
-	for (i = 0; i != s->mu_reader_threads_per_value; i++) {
-		nsync_mu_assert_held (&s->mu);
-		s->reader_refs++;
-		closure_fork (closure_mu_stress_reader_loop (&mu_stress_reader_loop,
-							     s, is_n_mod_4_or_refs0[0], s));
-	}
-
-	/* wait for threads to exit. */
-	nsync_mu_assert_held (&s->mu);
-	while (s->refs != 0) {
-		nsync_cv_wait (&s->refs_is_zero, &s->mu);
-	}
-	while (s->reader_refs != 0) {
-		nsync_cv_wait (&s->reader_refs_is_zero, &s->mu);
-	}
-
-	nsync_mu_assert_held (&s->mu);
-	nsync_mu_unlock (&s->mu);
-
-	if (nsync_time_cmp (s->deadline, nsync_time_now ()) < 0) {
-		if (timeouts_seen < expected_timeouts && !testing_is_uniprocessor (t)) {
-			TEST_ERROR (t, ("%s: expected more than %d timeouts, got %d",
-				   test_name, expected_timeouts, timeouts_seen));
-		}
-
-		/* Check that s.count has the right value. */
-		expected_count = s->loop_count * (s->cv_threads_per_value +
-						  s->mu_threads_per_value) * 4;
-		if (s->count != expected_count) {
-			TEST_ERROR (t, ("%s: expected to increment s->count to %d, got %d",
-				   test_name, expected_count, s->count));
-		}
-
-		/* Some timeouts should have happened while the counts were being incremented. */
-		expected_timeouts = timeouts_seen + 1;
-		if (s->timeouts < expected_timeouts) {
-			TEST_ERROR (t, ("%s: expected more than %d timeouts, got %d",
-				   test_name, expected_timeouts, s->timeouts));
-		}
-		done = 1;
-	}
-	return (done);
-}
-
-/* Test many threads using a single lock, using
-   condition variables and timeouts.  See run_stress_test() for details. */
-static void test_cv_timeout_stress (testing t) {
-	uintmax_t loop_count = 3;
-	cv_stress_data s;
-	nsync_time deadline;
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (5000));
-	do {
-		bzero ((void *) &s, sizeof (s));
-		s.loop_count = loop_count;
-		s.cv_threads_per_value = 4;
-		s.cv_reader_threads_per_value = 2;
-		s.mu_threads_per_value = 0;
-		s.mu_reader_threads_per_value = 0;
-		s.deadline = deadline;
-		loop_count *= 2;
-	} while (!run_stress_test (&s, t, "test_cv_timeout_stress"));
-}
-
-
-/* Test many threads using a single lock, using
-   conditional critical sections and timeouts. See run_stress_test() for details. */
-static void test_mu_timeout_stress (testing t) {
-	uintmax_t loop_count = 3;
-	cv_stress_data s;
-	nsync_time deadline;
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (5000));
-	do {
-		bzero ((void *) &s, sizeof (s));
-		s.loop_count = loop_count;
-		s.cv_threads_per_value = 0;
-		s.cv_reader_threads_per_value = 0;
-		s.mu_threads_per_value = 4;
-		s.mu_reader_threads_per_value = 2;
-		s.deadline = deadline;
-		loop_count *= 2;
-	} while (!run_stress_test (&s, t, "test_mu_timeout_stress"));
-}
-
-/* Like test_mu_timeout_stress() but has both threads that use conditional
-   critical sections and threads that use condition variables, to ensure that
-   they work together.  */
-static void test_mu_cv_timeout_stress (testing t) {
-	uintmax_t loop_count = 3;
-	cv_stress_data s;
-	nsync_time deadline;
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (5000));
-	do {
-		bzero ((void *) &s, sizeof (s));
-		s.loop_count = loop_count;
-		s.cv_threads_per_value = 4;
-		s.cv_reader_threads_per_value = 1;
-		s.mu_threads_per_value = 4;
-		s.mu_reader_threads_per_value = 1;
-		s.deadline = deadline;
-		loop_count *= 2;
-	} while (!run_stress_test (&s, t, "test_mu_cv_timeout_stress"));
-}
-
-int main (int argc, char *argv[]) {
-	testing_base tb = testing_new (argc, argv, 0);
-	TEST_RUN (tb, test_cv_timeout_stress);
-	TEST_RUN (tb, test_mu_timeout_stress);
-	TEST_RUN (tb, test_mu_cv_timeout_stress);
-	return (testing_base_exit (tb));
-}
diff --git a/third_party/nsync/testing/cv_test.c b/third_party/nsync/testing/cv_test.c
index d31413d4f..09fb43d88 100644
--- a/third_party/nsync/testing/cv_test.c
+++ b/third_party/nsync/testing/cv_test.c
@@ -15,766 +15,7 @@
 │ See the License for the specific language governing permissions and          │
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "third_party/nsync/cv.h"
-#include "libc/errno.h"
-#include "libc/mem/mem.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "third_party/nsync/debug.h"
-#include "third_party/nsync/mu.h"
-#include "third_party/nsync/mu_wait.h"
-#include "third_party/nsync/note.h"
-#include "third_party/nsync/testing/closure.h"
-#include "third_party/nsync/testing/smprintf.h"
-#include "third_party/nsync/testing/testing.h"
-#include "third_party/nsync/testing/time_extra.h"
-#include "third_party/nsync/time.h"
-
-/* --------------------------- */
-
-/* A cv_queue represents a FIFO queue with up to limit elements.
-   The storage for the queue expands as necessary up to limit. */
-typedef struct cv_queue_s {
-	int limit;          /* max value of count---should not be changed after initialization */
-	nsync_cv non_empty; /* signalled when count transitions from zero to non-zero */
-	nsync_cv non_full;  /* signalled when count transitions from limit to less than limit */
-	nsync_mu mu;        /* protects fields below */
-	int pos;            /* index of first in-use element */
-	int count;          /* number of elements in use */
-	void *data[1];      /* in use elements are data[pos, ..., (pos+count-1)%limit] */
-} cv_queue;
-
-/* Return a pointer to new cv_queue. */
-static cv_queue *cv_queue_new (int limit) {
-	cv_queue *q;
-	int size = offsetof (struct cv_queue_s, data) + sizeof (q->data[0]) * limit;
-	q = (cv_queue *) malloc (size);
-	bzero ((void *) q, size);
-	q->limit = limit;
-	return (q);
-}
-
-/* Add v to the end of the FIFO *q and return non-zero, or if the FIFO already
-   has limit elements and continues to do so until abs_deadline, do nothing and
-   return 0. */
-static int cv_queue_put (cv_queue *q, void *v, nsync_time abs_deadline) {
-	int added = 0;
-	int wake = 0;
-	nsync_mu_lock (&q->mu);
-	while (q->count == q->limit &&
-	       nsync_cv_wait_with_deadline (&q->non_full, &q->mu, abs_deadline, NULL) == 0) {
-	}
-	if (q->count != q->limit) {
-		int i = q->pos + q->count;
-		if (q->limit <= i) {
-			i -= q->limit;
-		}
-		q->data[i] = v;
-		if (q->count == 0) {
-			wake = 1;
-		}
-		q->count++;
-		added = 1;
-	}
-	nsync_mu_unlock (&q->mu);
-	if (wake) {
-		nsync_cv_broadcast (&q->non_empty);
-	}
-	return (added);
-}
-
-/* Remove the first value from the front of the FIFO *q and return it,
-   or if the FIFO is empty and continues to be so until abs_deadline,
-   do nothing and return NULL. */
-static void *cv_queue_get (cv_queue *q, nsync_time abs_deadline) {
-	void *v = NULL;
-	nsync_mu_lock (&q->mu);
-	while (q->count == 0 &&
-	       nsync_cv_wait_with_deadline (&q->non_empty, &q->mu, abs_deadline, NULL) == 0) {
-	}
-	if (q->count != 0) {
-		v = q->data[q->pos];
-		q->data[q->pos] = NULL;
-		if (q->count == q->limit) {
-			nsync_cv_broadcast (&q->non_full);
-		}
-		q->pos++;
-		q->count--;
-		if (q->pos == q->limit) {
-			q->pos = 0;
-		}
-	}
-	nsync_mu_unlock (&q->mu);
-	return (v);
-}
-
-/* --------------------------- */
-
-static char ptr_to_int_c;
-#define INT_TO_PTR(x) ((x) + &ptr_to_int_c)
-#define PTR_TO_INT(p) (((char *) (p)) - &ptr_to_int_c)
-
-/* Put count integers on *q, in the sequence start*3, (start+1)*3, (start+2)*3, .... */
-static void producer_cv_n (testing t, cv_queue *q, int start, int count) {
-	int i;
-	for (i = 0; i != count; i++) {
-		if (!cv_queue_put (q, INT_TO_PTR ((start+i)*3), nsync_time_no_deadline)) {
-			TEST_FATAL (t, ("cv_queue_put() returned 0 with no deadline"));
-		}
-	}
-}
-CLOSURE_DECL_BODY4 (producer_cv_n, testing, cv_queue *, int, int)
-
-/* Get count integers from *q, and check that they are in the
-   sequence start*3, (start+1)*3, (start+2)*3, .... */
-static void consumer_cv_n (testing t, cv_queue *q, int start, int count) {
-	int i;
-	for (i = 0; i != count; i++) {
-		void *v = cv_queue_get (q, nsync_time_no_deadline);
-		int x;
-		if (v == NULL) {
-			TEST_FATAL (t, ("cv_queue_get() returned NULL with no deadline"));
-		}
-		x = PTR_TO_INT (v);
-		if (x != (start+i)*3) {
-			TEST_FATAL (t, ("cv_queue_get() returned bad value; want %d, got %d",
-				   (start+i)*3, x));
-		}
-	}
-}
-
-/* CV_PRODUCER_CONSUMER_N is the number of elements passed from producer to consumer in the
-   test_cv_producer_consumer*() tests below. */
-#define CV_PRODUCER_CONSUMER_N 100000
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**0. */
-static void test_cv_producer_consumer0 (testing t) {
-	cv_queue *q = cv_queue_new (1);
-	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
-	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**1. */
-static void test_cv_producer_consumer1 (testing t) {
-	cv_queue *q = cv_queue_new (10);
-	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
-	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**2. */
-static void test_cv_producer_consumer2 (testing t) {
-	cv_queue *q = cv_queue_new (100);
-	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
-	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**3. */
-static void test_cv_producer_consumer3 (testing t) {
-	cv_queue *q = cv_queue_new (1000);
-	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
-	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**4. */
-static void test_cv_producer_consumer4 (testing t) {
-	cv_queue *q = cv_queue_new (10 * 1000);
-	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
-	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**5. */
-static void test_cv_producer_consumer5 (testing t) {
-	cv_queue *q = cv_queue_new (100 * 1000);
-	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
-	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**6. */
-static void test_cv_producer_consumer6 (testing t) {
-	cv_queue *q = cv_queue_new (1000 * 1000);
-	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
-	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* The following values control how aggressively we police the timeout. */
-#define TOO_EARLY_MS 1
-#define TOO_LATE_MS 100   /* longer, to accommodate scheduling delays */
-#define TOO_LATE_ALLOWED 25         /* number of iterations permitted to violate too_late */
-
-/* Check timeouts on a CV wait_with_deadline(). */
-static void test_cv_deadline (testing t) {
-	int too_late_violations;
-	nsync_mu mu;
-	nsync_cv cv;
-	int i;
-	nsync_time too_early;
-	nsync_time too_late;
-
-	nsync_mu_init (&mu);
-	nsync_cv_init (&cv);
-	too_early = nsync_time_ms (TOO_EARLY_MS);
-	too_late = nsync_time_ms (TOO_LATE_MS);
-	too_late_violations = 0;
-	nsync_mu_lock (&mu);
-	for (i = 0; i != 50; i++) {
-		nsync_time end_time;
-		nsync_time start_time;
-		nsync_time expected_end_time;
-		start_time = nsync_time_now ();
-		expected_end_time = nsync_time_add (start_time, nsync_time_ms (87));
-		if (nsync_cv_wait_with_deadline (&cv, &mu, expected_end_time,
-						 NULL) != ETIMEDOUT) {
-			TEST_FATAL (t, ("nsync_cv_wait() returned non-expired for a timeout"));
-		}
-		end_time = nsync_time_now ();
-		if (nsync_time_cmp (end_time, nsync_time_sub (expected_end_time, too_early)) < 0) {
-			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
-			TEST_ERROR (t, ("nsync_cv_wait() returned %s too early", elapsed_str));
-			free (elapsed_str);
-		}
-		if (nsync_time_cmp (nsync_time_add (expected_end_time, too_late), end_time) < 0) {
-			too_late_violations++;
-		}
-	}
-	nsync_mu_unlock (&mu);
-	if (too_late_violations > TOO_LATE_ALLOWED) {
-		TEST_ERROR (t, ("nsync_cv_wait() returned too late %d times", too_late_violations));
-	}
-}
-
-/* Check cancellations with nsync_cv_wait_with_deadline(). */
-static void test_cv_cancel (testing t) {
-	nsync_time future_time;
-	int too_late_violations;
-	nsync_mu mu;
-	nsync_cv cv;
-	int i;
-	nsync_time too_early;
-	nsync_time too_late;
-
-	nsync_mu_init (&mu);
-	nsync_cv_init (&cv);
-	too_early = nsync_time_ms (TOO_EARLY_MS);
-	too_late = nsync_time_ms (TOO_LATE_MS);
-
-	/* The loops below cancel after 87 milliseconds, like the timeout tests above. */
-
-	future_time = nsync_time_add (nsync_time_now (), nsync_time_ms (3600000)); /* test cancels with timeout */
-
-	too_late_violations = 0;
-	nsync_mu_lock (&mu);
-	for (i = 0; i != 50; i++) {
-		int x;
-		nsync_note cancel;
-		nsync_time end_time;
-		nsync_time start_time;
-		nsync_time expected_end_time;
-		start_time = nsync_time_now ();
-		expected_end_time = nsync_time_add (start_time, nsync_time_ms (87));
-
-		cancel = nsync_note_new (NULL, expected_end_time);
-
-		x = nsync_cv_wait_with_deadline (&cv, &mu, future_time, cancel);
-		if (x != ECANCELED) {
-			TEST_FATAL (t, ("nsync_cv_wait() returned non-cancelled (%d) for "
-				   "a cancellation; expected %d",
-				   x, ECANCELED));
-		}
-		end_time = nsync_time_now ();
-		if (nsync_time_cmp (end_time, nsync_time_sub (expected_end_time, too_early)) < 0) {
-			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
-			TEST_ERROR (t, ("nsync_cv_wait() returned %s too early", elapsed_str));
-			free (elapsed_str);
-		}
-		if (nsync_time_cmp (nsync_time_add (expected_end_time, too_late), end_time) < 0) {
-			too_late_violations++;
-		}
-
-		/* Check that an already cancelled wait returns immediately. */
-		start_time = nsync_time_now ();
-
-		x = nsync_cv_wait_with_deadline (&cv, &mu, nsync_time_no_deadline, cancel);
-		if (x != ECANCELED) {
-			TEST_FATAL (t, ("nsync_cv_wait() returned non-cancelled (%d) for "
-				   "a cancellation; expected %d",
-				   x, ECANCELED));
-		}
-		end_time = nsync_time_now ();
-		if (nsync_time_cmp (end_time, start_time) < 0) {
-			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
-			TEST_ERROR (t, ("nsync_cv_wait() returned %s too early", elapsed_str));
-			free (elapsed_str);
-		}
-		if (nsync_time_cmp (nsync_time_add (start_time, too_late), end_time) < 0) {
-			too_late_violations++;
-		}
-		nsync_note_notify (cancel);
-
-		nsync_note_free (cancel);
-	}
-	nsync_mu_unlock (&mu);
-	if (too_late_violations > TOO_LATE_ALLOWED) {
-		TEST_ERROR (t, ("nsync_cv_wait() returned too late %d times", too_late_violations));
-	}
-}
-
-/* --------------------------- */
-
-/* Names of debug results for test_cv_debug. */
-static const char *result_name[] = {
-	"init_mu0",
-	"init_cv0",
-	"init_mu1",
-	"init_cv1",
-	"init_mu2",
-	"init_cv2",
-	"held_mu",
-	"wait0_mu",
-	"wait0_cv",
-	"wait1_mu",
-	"wait1_cv",
-	"wait2_mu",
-	"wait2_cv",
-	"wait3_mu",
-	"wait3_cv",
-	"rheld1_mu",
-	"rheld2_mu",
-	"rheld1again_mu",
-	NULL /* sentinel */
-};
-
-/* state for test_cv_debug() */
-struct debug_state {
-	nsync_mu mu;  /* protects flag field */
-	nsync_cv cv;  /* signalled when flag becomes zero */
-	int flag;     /* 0 => threads proceed; non-zero => threads block */
-
-	/* result[] is an array of nul-terminated string values, accessed via
-	   name (in result_name[]) via slot().  Entries accessed from multiple
-	   threads are protected by result_mu.  */
-	char *result[sizeof (result_name) / sizeof (result_name[0])];
-	nsync_mu result_mu;
-};
-
-/* Return a pointer to the slot in s->result[] associated with the
-   nul-terminated name[] */
-static char **slot (struct debug_state *s, const char *name) {
-	int i = 0;
-	while (result_name[i] != NULL && strcmp (result_name[i], name) != 0) {
-		i++;
-	}
-	if (result_name[i] == NULL) {  /* caller gave non-existent name */
-		abort ();
-	}
-	return (&s->result[i]);
-}
-
-/* Check that the strings associated with nul-terminated strings name0[] and
-   name1[] have the same values in s->result[].  */
-static void check_same (testing t, struct debug_state *s,
-			     const char *name0, const char *name1) {
-	if (strcmp (*slot (s, name0), *slot (s, name1)) != 0) {
-		TEST_ERROR (t, ("nsync_mu_debug_state() %s state != %s state (%s vs. %s)",
-				name0, name1, *slot (s, name0), *slot (s, name1)));
-	}
-}
-
-/* Check that the strings associated with nul-terminated strings name0[] and
-   name1[] have different values in s->result[].  */
-static void check_different (testing t, struct debug_state *s,
-			     const char *name0, const char *name1) {
-	if (strcmp (*slot (s, name0), *slot (s, name1)) == 0) {
-		TEST_ERROR (t, ("nsync_mu_debug_state() %s state == %s state",
-				name0, name1));
-	}
-}
-
-/* Return whether the integer at address v is zero. */
-static int int_is_zero (const void *v) {
-	return (*(int *)v == 0);
-}
-
-/* Acquire and release s->mu in write mode, waiting for s->flag==0
-   using nsync_mu_wait(). */
-static void debug_thread_writer (struct debug_state *s) {
-	nsync_mu_lock (&s->mu);
-	nsync_mu_wait (&s->mu, &int_is_zero, &s->flag, NULL);
-	nsync_mu_unlock (&s->mu);
-}
-
-/* Acquire and release s->mu in write mode, waiting for s->flag==0
-   using nsync_cv_wait(). */
-static void debug_thread_writer_cv (struct debug_state *s) {
-	nsync_mu_lock (&s->mu);
-	while (s->flag != 0) {
-		nsync_cv_wait (&s->cv, &s->mu);
-	}
-	nsync_mu_unlock (&s->mu);
-}
-
-/* Acquire and release s->mu in read mode, waiting for s->flag==0
-   using nsync_mu_wait().
-   If name!=NULL, record state of s->mu while held using name[]. */
-static void debug_thread_reader (struct debug_state *s,
-				 const char *name) {
-	nsync_mu_rlock (&s->mu);
-	nsync_mu_wait (&s->mu, &int_is_zero, &s->flag, NULL);
-	if (name != NULL) {
-		int len = 1024;
-		nsync_mu_lock (&s->result_mu);
-		*slot (s, name) = nsync_mu_debug_state_and_waiters (
-			&s->mu, (char *) malloc (len), len);
-		nsync_mu_unlock (&s->result_mu);
-	}
-	nsync_mu_runlock (&s->mu);
-}
-
-/* Acquire and release s->mu in read mode, waiting for s->flag==0
-   using nsync_cv_wait().
-   If name!=NULL, record state of s->mu while held using name[]. */
-static void debug_thread_reader_cv (struct debug_state *s,
-				    const char *name) {
-	nsync_mu_rlock (&s->mu);
-	while (s->flag != 0) {
-		nsync_cv_wait (&s->cv, &s->mu);
-	}
-	if (name != NULL) {
-		int len = 1024;
-		nsync_mu_lock (&s->result_mu);
-		*slot (s, name) = nsync_mu_debug_state_and_waiters (
-			&s->mu, (char *) malloc (len), len);
-		nsync_mu_unlock (&s->result_mu);
-	}
-	nsync_mu_runlock (&s->mu);
-}
-
-CLOSURE_DECL_BODY1 (debug_thread, struct debug_state *)
-CLOSURE_DECL_BODY2 (debug_thread_reader, struct debug_state *, const char *)
-
-/* Check that nsync_mu_debug_state() and nsync_cv_debug_state()
-   and their variants yield reasonable results.
-
-   The specification of those routines is intentionally loose,
-   so this do not check much, but the various possibilities can be 
-   examined using the verbose testing flag (-v). */
-static void test_cv_debug (testing t) {
-	int i;
-	int len = 1024;
-	char *tmp;
-	char *buf;
-	int buflen;
-	struct debug_state xs;
-	struct debug_state *s = &xs;
-	bzero ((void *) s, sizeof (*s));
-
-	/* Use nsync_*_debugger to check that they work. */
-	tmp = nsync_mu_debugger (&s->mu);
-	buflen = strlen (tmp)+1;
-	buf = (char *) malloc (buflen);
-	snprintf (buf, buflen, "%s", tmp);
-	*slot (s, "init_mu0") = buf;
-
-	tmp = nsync_cv_debugger (&s->cv);
-	buflen = strlen (tmp)+1;
-	buf = (char *) malloc (buflen);
-	snprintf (buf, buflen, "%s", tmp);
-	*slot (s, "init_cv0") = buf;
-
-	/* Get the same information via the other routines */
-	*slot (s, "init_mu1") = nsync_mu_debug_state (
-		&s->mu, (char *) malloc (len), len);
-	*slot (s, "init_cv1") = nsync_cv_debug_state (
-		&s->cv, (char *) malloc (len), len);
-	*slot (s, "init_mu2") = nsync_mu_debug_state_and_waiters (
-		&s->mu, (char *) malloc (len), len);
-	*slot (s, "init_cv2") = nsync_cv_debug_state_and_waiters (
-		&s->cv, (char *) malloc (len), len);
-
-	nsync_mu_lock (&s->mu);
-	*slot (s, "held_mu") = nsync_mu_debug_state_and_waiters (
-		&s->mu, (char *) malloc (len), len);
-	nsync_mu_unlock (&s->mu);
-
-	/* set up several threads waiting on the mutex */
-	nsync_mu_lock (&s->mu);
-	s->flag = 1;   /* so thread will block on conditions */
-	closure_fork (closure_debug_thread (&debug_thread_writer, s));
-	closure_fork (closure_debug_thread (&debug_thread_writer, s));
-	closure_fork (closure_debug_thread (&debug_thread_writer, s));
-	closure_fork (closure_debug_thread_reader (&debug_thread_reader, s, NULL));
-	closure_fork (closure_debug_thread (&debug_thread_writer_cv, s));
-	closure_fork (closure_debug_thread (&debug_thread_writer_cv, s));
-	closure_fork (closure_debug_thread (&debug_thread_writer_cv, s));
-	closure_fork (closure_debug_thread_reader (&debug_thread_reader_cv, s, NULL));
-	nsync_time_sleep (nsync_time_ms (500));
-	*slot (s, "wait0_mu") = nsync_mu_debug_state_and_waiters (
-		&s->mu, (char *) malloc (len), len);
-	*slot (s, "wait0_cv") = nsync_cv_debug_state_and_waiters (
-		&s->cv, (char *) malloc (len), len);
-
-	/* allow the threads to proceed to their conditional waits */
-	nsync_mu_unlock (&s->mu);
-	nsync_time_sleep (nsync_time_ms (500));
-	*slot (s, "wait1_mu") = nsync_mu_debug_state_and_waiters (
-		&s->mu, (char *) malloc (len), len);
-	*slot (s, "wait1_cv") = nsync_cv_debug_state_and_waiters (
-		&s->cv, (char *) malloc (len), len);
-
-	nsync_mu_lock (&s->mu);
-	/* move cv waiters to mutex queue */
-	nsync_cv_broadcast (&s->cv);
-	*slot (s, "wait2_mu") = nsync_mu_debug_state_and_waiters (
-		&s->mu, (char *) malloc (len), len);
-	*slot (s, "wait2_cv") = nsync_cv_debug_state_and_waiters (
-		&s->cv, (char *) malloc (len), len);
-
-	/* allow all threads to proceed and exit */
-	s->flag = 0;
-	nsync_mu_unlock (&s->mu);
-	nsync_time_sleep (nsync_time_ms (500));
-	*slot (s, "wait3_mu") = nsync_mu_debug_state_and_waiters (
-		&s->mu, (char *) malloc (len), len);
-	*slot (s, "wait3_cv") = nsync_cv_debug_state_and_waiters (
-		&s->cv, (char *) malloc (len), len);
-
-	/* Test with more than one reader */
-	nsync_mu_rlock (&s->mu);
-	*slot (s, "rheld1_mu") = nsync_mu_debug_state_and_waiters (
-		&s->mu, (char *) malloc (len), len);
-	closure_fork (closure_debug_thread_reader (
-		&debug_thread_reader, s, "rheld2_mu"));
-	nsync_time_sleep (nsync_time_ms (500));
-	*slot (s, "rheld1again_mu") = nsync_mu_debug_state_and_waiters (
-		&s->mu, (char *) malloc (len), len);
-	nsync_mu_runlock (&s->mu);
-
-	check_same (t, s, "init_mu0", "init_mu1");
-	check_same (t, s, "init_mu0", "init_mu2");
-	check_same (t, s, "init_cv0", "init_cv1");
-	check_same (t, s, "init_cv0", "init_cv2");
-	check_different (t, s, "init_mu0", "held_mu");
-	check_different (t, s, "rheld1_mu", "held_mu");
-	/* Must acquire result_mu, because the "rheld2_mu" slot is accessed
-	   from the debug_thread_reader() thread created above.  */
-	nsync_mu_lock (&s->result_mu);
-	check_different (t, s, "rheld1_mu", "rheld2_mu");
-	nsync_mu_unlock (&s->result_mu);
-	check_different (t, s, "init_mu0", "init_cv0");
-
-	for (i = 0; result_name[i] != NULL; i++) {
-		if (testing_verbose (t)) {
-			const char *str = *slot (s, result_name[i]);
-			TEST_LOG (t, ("%-16s  %s\n", result_name[i], str));
-		}
-		if (strlen (s->result[i]) == 0) {
-			TEST_ERROR (t, ("nsync_mu_debug_state() %s empty",
-					result_name[i]));
-		}
-		free (s->result[i]);
-	}
-}
-
-/* --------------------------- */
-
-/* Max number of waiter threads used in transfer test.
-   The last uses a conditional critical section, and others
-   use a condition variable.   */
-#define TRANSFER_MAX_WAITERS 8
-
-/* A struct cv_transfer is used to test cv-to-mu thread transfer.
-   There are up to TRANSFER_MAX_WAITERS waiter threads, and a wakeup thread.
-   Some threads wait using conditional critical sections,
-   and others using a condition variable. */
-struct cv_transfer {
-	nsync_mu mu;
-
-	nsync_cv cv;  /* signalled each time a cond[] element becomes non-zero */
-	/* Thread i waits for cond[i] to be non-zero; under mu.  */
-        int cond[TRANSFER_MAX_WAITERS];
-
-	nsync_mu control_mu;  /* protects fields below */
-	nsync_cv done_cv; /* signalled each time an element of done[] becomes non-zero */
-	int ready[TRANSFER_MAX_WAITERS];  /* set by waiters as they wait */
-	int done[TRANSFER_MAX_WAITERS];   /* set by completed waiters: to 1 by readers, and to 2 by writers */
-};
-
-/* Return whether *(int *)v != 0.  Used as a condition for nsync_mu_wait().  */
-static int int_is_non_zero (const void *v) {
-	return (0 != *(const int *)v);
-}
-
-/* Return when *pi becomes non-zero, where *pi is protected by *mu.
-   Acquires and releases *mu. */
-static void transfer_await_nonzero (nsync_mu *mu, int *pi) {
-	nsync_mu_lock (mu);
-	nsync_mu_wait (mu, &int_is_non_zero, pi, NULL);
-	nsync_mu_unlock (mu);
-}
-
-/* Set *pi to x value, where *pi is protected by *mu.
-   Acquires and releases *mu. */
-static void transfer_set (nsync_mu *mu, int *pi, int x) {
-	nsync_mu_lock (mu);
-	*pi = x;
-	nsync_mu_unlock (mu);
-}
-
-/* Lock and unlock routines for writers (index 0), and readers (index 1).  */
-static const struct {
-	void (*lock) (nsync_mu *);
-	void (*unlock) (nsync_mu *);
-} lock_type[2] = {
-	{ &nsync_mu_lock, &nsync_mu_unlock },
-	{ &nsync_mu_rlock, &nsync_mu_runlock },
-};
-
-/* Signal and broadcast routines */
-typedef void (*wakeup_func_type) (nsync_cv *);
-static wakeup_func_type wakeup_func[2] = { &nsync_cv_broadcast, &nsync_cv_signal };
-
-/* Acquire cvt->mu in write or read mode (depending on "reader"),
-   set cvt->ready[i], wait for cvt->cond[i] to become non-zero (using
-   a condition variable if use_cv!=0), then release cvt->mu, and
-   set cvt->done[i].
-   Used as the body of waiter threads created by test_cv_transfer(). */
-static void transfer_waiter_thread (struct cv_transfer *cvt, int i, int reader, int use_cv) {
-	(*lock_type[reader].lock) (&cvt->mu);
-	transfer_set (&cvt->control_mu, &cvt->ready[i], 1);
-	if (use_cv) {
-		while (!cvt->cond[i]) {
-			nsync_cv_wait (&cvt->cv, &cvt->mu);
-		}
-	} else {
-		nsync_mu_wait (&cvt->mu, &int_is_non_zero, &cvt->cond[i], NULL);
-	}
-	(*lock_type[reader].unlock) (&cvt->mu);
-
-	transfer_set (&cvt->control_mu, &cvt->done[i], reader? 1 : 2);
-	nsync_cv_broadcast (&cvt->done_cv);
-}
-
-/* Return whether all the elements a[0..n-1] are less than x. */
-static int are_all_below (int a[], int n, int x) {
-	int i;
-	for (i = 0; i != n && a[i] < x; i++) {
-	}
-	return (i == n);
-}
-
-CLOSURE_DECL_BODY4 (transfer_thread, struct cv_transfer *, int, int, int)
-
-/* Test cv-to-mutex queue transfer.  (See the code in cv.c, wake_waiters().)
-
-   The queue transfer needs to work regardless of:
-   - whether the mutex is also being used with conditional critical sections,
-   - whether reader locks are used,
-   - whether the waker signals from within the critical section (as it would in
-     a traditional monitor), or after that critical section, and
-   - the number of threads that might be awoken.  */
-static void test_cv_transfer (testing t) {
-	int waiters;	 /* number of waiters (in [2, TRANSFER_MAX_WAITERS]). */
-	int cv_writers;  /* number of cv_writers: -1 means all */
-	int ccs_reader; /* ccs waiter is a reader */
-	int wakeup_type; /* bits: use_signal and after_region */
-	enum { use_signal = 0x1 };  /* use signal rather than broadcast */
-	enum { after_region = 0x2 };  /* perform wakeup after region, rather than within */
-	struct cv_transfer Xcvt;
-	struct cv_transfer *cvt = &Xcvt;  /* So all accesses are of form cvt-> */
-	int i;
-
-	/* for all settings of all of wakeup_type, ccs_reader, cv_writers,
-	   and various different numbers of waiters */
-	for (waiters = 2; waiters <= TRANSFER_MAX_WAITERS; waiters <<= 1) {
-		for (wakeup_type = 0; wakeup_type != 4; wakeup_type++) {
-			for (cv_writers = -1; cv_writers != 3; cv_writers++) {
-				for (ccs_reader = 0; ccs_reader != 2; ccs_reader++) {
-					if (testing_verbose (t)) {
-						TEST_LOG (t, ("transfer waiters %d wakeup_type %d  cv_writers %d  ccs_reader %d\n",
-							      waiters, wakeup_type, cv_writers, ccs_reader));
-					}
-					bzero ((void *) cvt, sizeof (*cvt));
-
-					/* Start the waiter threads that use condition variables. */
-					for (i = 0; i < waiters-1; i++) {
-						int is_reader = (cv_writers != -1 && i < waiters-1-cv_writers);
-						closure_fork (closure_transfer_thread (&transfer_waiter_thread, cvt, i,
-										       is_reader, 1/*use_cv*/));
-						transfer_await_nonzero (&cvt->control_mu, &cvt->ready[i]);
-					}
-					/* Start the waiter thread that uses conditional critical sections. */
-					closure_fork (closure_transfer_thread (&transfer_waiter_thread, cvt, i,
-									       ccs_reader, 0/*use_cv*/));
-					/* Wait for all waiters to enter their regions. */
-					for (i = 0; i != waiters; i++) {
-						transfer_await_nonzero (&cvt->control_mu, &cvt->ready[i]);
-					}
-
-					nsync_mu_lock (&cvt->mu);
-					/* At this point, all the waiter threads are in waiting: 
-					   they have set their ready[] flags, and have released cvt->mu. */
-
-					/* Mark all the condition-variable as runnable,
-					   and signal at least one of them.
-					   This may wake more than one, depending on
-					   the presence of readers, and the use of
-					   signal vs broadcast.  */
-					for (i = 0; i != waiters-1; i++) {
-						cvt->cond[i] = 1;
-					}
-					if ((wakeup_type & after_region) == 0) {
-						(*wakeup_func[wakeup_type & use_signal]) (&cvt->cv);
-					}
-					nsync_mu_unlock (&cvt->mu);
-					if ((wakeup_type & after_region) != 0) {
-						for (i = 0; i != waiters-1; i++) {
-							(*wakeup_func[wakeup_type & use_signal]) (&cvt->cv);
-						}
-					}
-
-					/* Wait for at least one woken waiter to proceed,
-					   and at least one writer if there is one.  */
-					nsync_mu_lock (&cvt->control_mu);
-					while (are_all_below (&cvt->done[0], waiters-1, cv_writers!=0? 2 : 1)) {
-						nsync_cv_wait (&cvt->done_cv, &cvt->control_mu);
-					}
-					nsync_mu_unlock (&cvt->control_mu);
-
-					/* Wake all remaining threads. */
-					nsync_cv_broadcast (&cvt->cv);
-					transfer_set (&cvt->mu, &cvt->cond[waiters-1], 1);
-
-					/* And wait for all to finish. */
-					for (i = 0; i != waiters; i++) {
-						transfer_await_nonzero (&cvt->control_mu, &cvt->done[i]);
-					}
-
-					if (testing_verbose (t)) {
-						TEST_LOG (t, ("transfer waiters %d wakeup_type %d  cv_writers %d  ccs_reader %d complete\n",
-							      waiters, wakeup_type, cv_writers, ccs_reader));
-					}
-				}
-			}
-		}
-	}
-}
-
-
-/* --------------------------- */
+#include "third_party/nsync/testing/cv_test.inc"
 
 int main (int argc, char *argv[]) {
 	testing_base tb = testing_new (argc, argv, 0);
@@ -785,8 +26,6 @@ int main (int argc, char *argv[]) {
 	TEST_RUN (tb, test_cv_producer_consumer4);
 	TEST_RUN (tb, test_cv_producer_consumer5);
 	TEST_RUN (tb, test_cv_producer_consumer6);
-	TEST_RUN (tb, test_cv_deadline);
-	TEST_RUN (tb, test_cv_cancel);
 	TEST_RUN (tb, test_cv_debug);
 	TEST_RUN (tb, test_cv_transfer);
 	return (testing_base_exit (tb));
diff --git a/third_party/nsync/testing/cv_test.inc b/third_party/nsync/testing/cv_test.inc
new file mode 100644
index 000000000..6a1f656b3
--- /dev/null
+++ b/third_party/nsync/testing/cv_test.inc
@@ -0,0 +1,774 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/cv.h"
+#include "libc/errno.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "third_party/nsync/debug.h"
+#include "third_party/nsync/mu.h"
+#include "third_party/nsync/mu_wait.h"
+#include "third_party/nsync/note.h"
+#include "third_party/nsync/testing/closure.h"
+#include "third_party/nsync/testing/smprintf.h"
+#include "third_party/nsync/testing/testing.h"
+#include "third_party/nsync/testing/time_extra.h"
+#include "third_party/nsync/time.h"
+
+/* --------------------------- */
+
+/* A cv_queue represents a FIFO queue with up to limit elements.
+   The storage for the queue expands as necessary up to limit. */
+typedef struct cv_queue_s {
+	int limit;          /* max value of count---should not be changed after initialization */
+	nsync_cv non_empty; /* signalled when count transitions from zero to non-zero */
+	nsync_cv non_full;  /* signalled when count transitions from limit to less than limit */
+	nsync_mu mu;        /* protects fields below */
+	int pos;            /* index of first in-use element */
+	int count;          /* number of elements in use */
+	void *data[1];      /* in use elements are data[pos, ..., (pos+count-1)%limit] */
+} cv_queue;
+
+/* Return a pointer to new cv_queue. */
+static cv_queue *cv_queue_new (int limit) {
+	cv_queue *q;
+	int size = offsetof (struct cv_queue_s, data) + sizeof (q->data[0]) * limit;
+	q = (cv_queue *) malloc (size);
+	bzero ((void *) q, size);
+	q->limit = limit;
+	return (q);
+}
+
+/* Add v to the end of the FIFO *q and return non-zero, or if the FIFO already
+   has limit elements and continues to do so until abs_deadline, do nothing and
+   return 0. */
+static int cv_queue_put (cv_queue *q, void *v, nsync_time abs_deadline) {
+	int added = 0;
+	int wake = 0;
+	nsync_mu_lock (&q->mu);
+	while (q->count == q->limit &&
+	       nsync_cv_wait_with_deadline (&q->non_full, &q->mu, NSYNC_CLOCK, abs_deadline, NULL) == 0) {
+	}
+	if (q->count != q->limit) {
+		int i = q->pos + q->count;
+		if (q->limit <= i) {
+			i -= q->limit;
+		}
+		q->data[i] = v;
+		if (q->count == 0) {
+			wake = 1;
+		}
+		q->count++;
+		added = 1;
+	}
+	nsync_mu_unlock (&q->mu);
+	if (wake) {
+		nsync_cv_broadcast (&q->non_empty);
+	}
+	return (added);
+}
+
+/* Remove the first value from the front of the FIFO *q and return it,
+   or if the FIFO is empty and continues to be so until abs_deadline,
+   do nothing and return NULL. */
+static void *cv_queue_get (cv_queue *q, nsync_time abs_deadline) {
+	void *v = NULL;
+	nsync_mu_lock (&q->mu);
+	while (q->count == 0 &&
+	       nsync_cv_wait_with_deadline (&q->non_empty, &q->mu, NSYNC_CLOCK, abs_deadline, NULL) == 0) {
+	}
+	if (q->count != 0) {
+		v = q->data[q->pos];
+		q->data[q->pos] = NULL;
+		if (q->count == q->limit) {
+			nsync_cv_broadcast (&q->non_full);
+		}
+		q->pos++;
+		q->count--;
+		if (q->pos == q->limit) {
+			q->pos = 0;
+		}
+	}
+	nsync_mu_unlock (&q->mu);
+	return (v);
+}
+
+/* --------------------------- */
+
+static char ptr_to_int_c;
+#define INT_TO_PTR(x) ((x) + &ptr_to_int_c)
+#define PTR_TO_INT(p) (((char *) (p)) - &ptr_to_int_c)
+
+/* Put count integers on *q, in the sequence start*3, (start+1)*3, (start+2)*3, .... */
+static void producer_cv_n (testing t, cv_queue *q, int start, int count) {
+	int i;
+	for (i = 0; i != count; i++) {
+		if (!cv_queue_put (q, INT_TO_PTR ((start+i)*3), nsync_time_no_deadline)) {
+			TEST_FATAL (t, ("cv_queue_put() returned 0 with no deadline"));
+		}
+	}
+}
+CLOSURE_DECL_BODY4 (producer_cv_n, testing, cv_queue *, int, int)
+
+/* Get count integers from *q, and check that they are in the
+   sequence start*3, (start+1)*3, (start+2)*3, .... */
+static void consumer_cv_n (testing t, cv_queue *q, int start, int count) {
+	int i;
+	for (i = 0; i != count; i++) {
+		void *v = cv_queue_get (q, nsync_time_no_deadline);
+		int x;
+		if (v == NULL) {
+			TEST_FATAL (t, ("cv_queue_get() returned NULL with no deadline"));
+		}
+		x = PTR_TO_INT (v);
+		if (x != (start+i)*3) {
+			TEST_FATAL (t, ("cv_queue_get() returned bad value; want %d, got %d",
+				   (start+i)*3, x));
+		}
+	}
+}
+
+/* CV_PRODUCER_CONSUMER_N is the number of elements passed from producer to consumer in the
+   test_cv_producer_consumer*() tests below. */
+#define CV_PRODUCER_CONSUMER_N 100000
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**0. */
+static void test_cv_producer_consumer0 (testing t) {
+	cv_queue *q = cv_queue_new (1);
+	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
+	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**1. */
+static void test_cv_producer_consumer1 (testing t) {
+	cv_queue *q = cv_queue_new (10);
+	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
+	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**2. */
+static void test_cv_producer_consumer2 (testing t) {
+	cv_queue *q = cv_queue_new (100);
+	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
+	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**3. */
+static void test_cv_producer_consumer3 (testing t) {
+	cv_queue *q = cv_queue_new (1000);
+	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
+	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**4. */
+static void test_cv_producer_consumer4 (testing t) {
+	cv_queue *q = cv_queue_new (10 * 1000);
+	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
+	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**5. */
+static void test_cv_producer_consumer5 (testing t) {
+	cv_queue *q = cv_queue_new (100 * 1000);
+	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
+	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**6. */
+static void test_cv_producer_consumer6 (testing t) {
+	cv_queue *q = cv_queue_new (1000 * 1000);
+	closure_fork (closure_producer_cv_n (&producer_cv_n, t, q, 0, CV_PRODUCER_CONSUMER_N));
+	consumer_cv_n (t, q, 0, CV_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* The following values control how aggressively we police the timeout. */
+#define TOO_EARLY_MS 1
+#define TOO_LATE_MS 100   /* longer, to accommodate scheduling delays */
+#define TOO_LATE_ALLOWED 25         /* number of iterations permitted to violate too_late */
+
+/* Check timeouts on a CV wait_with_deadline(). */
+static void test_cv_deadline (testing t) {
+	int too_late_violations;
+	nsync_mu mu;
+	nsync_cv cv;
+	int i;
+	nsync_time too_early;
+	nsync_time too_late;
+
+	nsync_mu_init (&mu);
+	nsync_cv_init (&cv);
+	too_early = nsync_time_ms (TOO_EARLY_MS);
+	too_late = nsync_time_ms (TOO_LATE_MS);
+	too_late_violations = 0;
+	nsync_mu_lock (&mu);
+	for (i = 0; i != 50; i++) {
+		nsync_time end_time;
+		nsync_time start_time;
+		nsync_time expected_end_time;
+		start_time = nsync_time_now (NSYNC_CLOCK);
+		expected_end_time = nsync_time_add (start_time, nsync_time_ms (87));
+		if (nsync_cv_wait_with_deadline (&cv, &mu, NSYNC_CLOCK, expected_end_time,
+						 NULL) != ETIMEDOUT) {
+			TEST_FATAL (t, ("nsync_cv_wait() returned non-expired for a timeout"));
+		}
+		end_time = nsync_time_now (NSYNC_CLOCK);
+		if (nsync_time_cmp (end_time, nsync_time_sub (expected_end_time, too_early)) < 0) {
+			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
+			TEST_ERROR (t, ("nsync_cv_wait() returned %s too early", elapsed_str));
+			free (elapsed_str);
+		}
+		if (nsync_time_cmp (nsync_time_add (expected_end_time, too_late), end_time) < 0) {
+			too_late_violations++;
+		}
+	}
+	nsync_mu_unlock (&mu);
+	if (too_late_violations > TOO_LATE_ALLOWED) {
+		TEST_ERROR (t, ("nsync_cv_wait() returned too late %d times", too_late_violations));
+	}
+}
+
+/* Check cancellations with nsync_cv_wait_with_deadline(). */
+static void test_cv_cancel (testing t) {
+	nsync_time future_time;
+	int too_late_violations;
+	nsync_mu mu;
+	nsync_cv cv;
+	int i;
+	nsync_time too_early;
+	nsync_time too_late;
+
+	nsync_mu_init (&mu);
+	nsync_cv_init (&cv);
+	too_early = nsync_time_ms (TOO_EARLY_MS);
+	too_late = nsync_time_ms (TOO_LATE_MS);
+
+	/* The loops below cancel after 87 milliseconds, like the timeout tests above. */
+
+	future_time = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (3600000)); /* test cancels with timeout */
+
+	too_late_violations = 0;
+	nsync_mu_lock (&mu);
+	for (i = 0; i != 50; i++) {
+		int x;
+		nsync_note cancel;
+		nsync_time end_time;
+		nsync_time start_time;
+		nsync_time expected_end_time;
+		start_time = nsync_time_now (NSYNC_CLOCK);
+		expected_end_time = nsync_time_add (start_time, nsync_time_ms (87));
+
+		cancel = nsync_note_new (NULL, NSYNC_CLOCK, expected_end_time);
+
+		x = nsync_cv_wait_with_deadline (&cv, &mu, NSYNC_CLOCK, future_time, cancel);
+		if (x != ECANCELED) {
+			TEST_FATAL (t, ("nsync_cv_wait() returned non-cancelled (%d) for "
+				   "a cancellation; expected %d",
+				   x, ECANCELED));
+		}
+		end_time = nsync_time_now (NSYNC_CLOCK);
+		if (nsync_time_cmp (end_time, nsync_time_sub (expected_end_time, too_early)) < 0) {
+			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
+			TEST_ERROR (t, ("nsync_cv_wait() returned %s too early", elapsed_str));
+			free (elapsed_str);
+		}
+		if (nsync_time_cmp (nsync_time_add (expected_end_time, too_late), end_time) < 0) {
+			too_late_violations++;
+		}
+
+		/* Check that an already cancelled wait returns immediately. */
+		start_time = nsync_time_now (NSYNC_CLOCK);
+
+		x = nsync_cv_wait_with_deadline (&cv, &mu, NSYNC_CLOCK, nsync_time_no_deadline, cancel);
+		if (x != ECANCELED) {
+			TEST_FATAL (t, ("nsync_cv_wait() returned non-cancelled (%d) for "
+				   "a cancellation; expected %d",
+				   x, ECANCELED));
+		}
+		end_time = nsync_time_now (NSYNC_CLOCK);
+		if (nsync_time_cmp (end_time, start_time) < 0) {
+			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
+			TEST_ERROR (t, ("nsync_cv_wait() returned %s too early", elapsed_str));
+			free (elapsed_str);
+		}
+		if (nsync_time_cmp (nsync_time_add (start_time, too_late), end_time) < 0) {
+			too_late_violations++;
+		}
+		nsync_note_notify (cancel);
+
+		nsync_note_free (cancel);
+	}
+	nsync_mu_unlock (&mu);
+	if (too_late_violations > TOO_LATE_ALLOWED) {
+		TEST_ERROR (t, ("nsync_cv_wait() returned too late %d times", too_late_violations));
+	}
+}
+
+/* --------------------------- */
+
+/* Names of debug results for test_cv_debug. */
+static const char *result_name[] = {
+	"init_mu0",
+	"init_cv0",
+	"init_mu1",
+	"init_cv1",
+	"init_mu2",
+	"init_cv2",
+	"held_mu",
+	"wait0_mu",
+	"wait0_cv",
+	"wait1_mu",
+	"wait1_cv",
+	"wait2_mu",
+	"wait2_cv",
+	"wait3_mu",
+	"wait3_cv",
+	"rheld1_mu",
+	"rheld2_mu",
+	"rheld1again_mu",
+	NULL /* sentinel */
+};
+
+/* state for test_cv_debug() */
+struct debug_state {
+	nsync_mu mu;  /* protects flag field */
+	nsync_cv cv;  /* signalled when flag becomes zero */
+	int flag;     /* 0 => threads proceed; non-zero => threads block */
+
+	/* result[] is an array of nul-terminated string values, accessed via
+	   name (in result_name[]) via slot().  Entries accessed from multiple
+	   threads are protected by result_mu.  */
+	char *result[sizeof (result_name) / sizeof (result_name[0])];
+	nsync_mu result_mu;
+};
+
+/* Return a pointer to the slot in s->result[] associated with the
+   nul-terminated name[] */
+static char **slot (struct debug_state *s, const char *name) {
+	int i = 0;
+	while (result_name[i] != NULL && strcmp (result_name[i], name) != 0) {
+		i++;
+	}
+	if (result_name[i] == NULL) {  /* caller gave non-existent name */
+		abort ();
+	}
+	return (&s->result[i]);
+}
+
+/* Check that the strings associated with nul-terminated strings name0[] and
+   name1[] have the same values in s->result[].  */
+static void check_same (testing t, struct debug_state *s,
+			     const char *name0, const char *name1) {
+	if (strcmp (*slot (s, name0), *slot (s, name1)) != 0) {
+		TEST_ERROR (t, ("nsync_mu_debug_state() %s state != %s state (%s vs. %s)",
+				name0, name1, *slot (s, name0), *slot (s, name1)));
+	}
+}
+
+/* Check that the strings associated with nul-terminated strings name0[] and
+   name1[] have different values in s->result[].  */
+static void check_different (testing t, struct debug_state *s,
+			     const char *name0, const char *name1) {
+	if (strcmp (*slot (s, name0), *slot (s, name1)) == 0) {
+		TEST_ERROR (t, ("nsync_mu_debug_state() %s state == %s state",
+				name0, name1));
+	}
+}
+
+/* Return whether the integer at address v is zero. */
+static int int_is_zero (const void *v) {
+	return (*(int *)v == 0);
+}
+
+/* Acquire and release s->mu in write mode, waiting for s->flag==0
+   using nsync_mu_wait(). */
+static void debug_thread_writer (struct debug_state *s) {
+	nsync_mu_lock (&s->mu);
+	nsync_mu_wait (&s->mu, &int_is_zero, &s->flag, NULL);
+	nsync_mu_unlock (&s->mu);
+}
+
+/* Acquire and release s->mu in write mode, waiting for s->flag==0
+   using nsync_cv_wait(). */
+static void debug_thread_writer_cv (struct debug_state *s) {
+	nsync_mu_lock (&s->mu);
+	while (s->flag != 0) {
+		nsync_cv_wait (&s->cv, &s->mu);
+	}
+	nsync_mu_unlock (&s->mu);
+}
+
+/* Acquire and release s->mu in read mode, waiting for s->flag==0
+   using nsync_mu_wait().
+   If name!=NULL, record state of s->mu while held using name[]. */
+static void debug_thread_reader (struct debug_state *s,
+				 const char *name) {
+	nsync_mu_rlock (&s->mu);
+	nsync_mu_wait (&s->mu, &int_is_zero, &s->flag, NULL);
+	if (name != NULL) {
+		int len = 1024;
+		nsync_mu_lock (&s->result_mu);
+		*slot (s, name) = nsync_mu_debug_state_and_waiters (
+			&s->mu, (char *) malloc (len), len);
+		nsync_mu_unlock (&s->result_mu);
+	}
+	nsync_mu_runlock (&s->mu);
+}
+
+/* Acquire and release s->mu in read mode, waiting for s->flag==0
+   using nsync_cv_wait().
+   If name!=NULL, record state of s->mu while held using name[]. */
+static void debug_thread_reader_cv (struct debug_state *s,
+				    const char *name) {
+	nsync_mu_rlock (&s->mu);
+	while (s->flag != 0) {
+		nsync_cv_wait (&s->cv, &s->mu);
+	}
+	if (name != NULL) {
+		int len = 1024;
+		nsync_mu_lock (&s->result_mu);
+		*slot (s, name) = nsync_mu_debug_state_and_waiters (
+			&s->mu, (char *) malloc (len), len);
+		nsync_mu_unlock (&s->result_mu);
+	}
+	nsync_mu_runlock (&s->mu);
+}
+
+CLOSURE_DECL_BODY1 (debug_thread, struct debug_state *)
+CLOSURE_DECL_BODY2 (debug_thread_reader, struct debug_state *, const char *)
+
+/* Check that nsync_mu_debug_state() and nsync_cv_debug_state()
+   and their variants yield reasonable results.
+
+   The specification of those routines is intentionally loose,
+   so this do not check much, but the various possibilities can be 
+   examined using the verbose testing flag (-v). */
+static void test_cv_debug (testing t) {
+	int i;
+	int len = 1024;
+	char *tmp;
+	char *buf;
+	int buflen;
+	struct debug_state xs;
+	struct debug_state *s = &xs;
+	bzero ((void *) s, sizeof (*s));
+
+	/* Use nsync_*_debugger to check that they work. */
+	tmp = nsync_mu_debugger (&s->mu);
+	buflen = strlen (tmp)+1;
+	buf = (char *) malloc (buflen);
+	snprintf (buf, buflen, "%s", tmp);
+	*slot (s, "init_mu0") = buf;
+
+	tmp = nsync_cv_debugger (&s->cv);
+	buflen = strlen (tmp)+1;
+	buf = (char *) malloc (buflen);
+	snprintf (buf, buflen, "%s", tmp);
+	*slot (s, "init_cv0") = buf;
+
+	/* Get the same information via the other routines */
+	*slot (s, "init_mu1") = nsync_mu_debug_state (
+		&s->mu, (char *) malloc (len), len);
+	*slot (s, "init_cv1") = nsync_cv_debug_state (
+		&s->cv, (char *) malloc (len), len);
+	*slot (s, "init_mu2") = nsync_mu_debug_state_and_waiters (
+		&s->mu, (char *) malloc (len), len);
+	*slot (s, "init_cv2") = nsync_cv_debug_state_and_waiters (
+		&s->cv, (char *) malloc (len), len);
+
+	nsync_mu_lock (&s->mu);
+	*slot (s, "held_mu") = nsync_mu_debug_state_and_waiters (
+		&s->mu, (char *) malloc (len), len);
+	nsync_mu_unlock (&s->mu);
+
+	/* set up several threads waiting on the mutex */
+	nsync_mu_lock (&s->mu);
+	s->flag = 1;   /* so thread will block on conditions */
+	closure_fork (closure_debug_thread (&debug_thread_writer, s));
+	closure_fork (closure_debug_thread (&debug_thread_writer, s));
+	closure_fork (closure_debug_thread (&debug_thread_writer, s));
+	closure_fork (closure_debug_thread_reader (&debug_thread_reader, s, NULL));
+	closure_fork (closure_debug_thread (&debug_thread_writer_cv, s));
+	closure_fork (closure_debug_thread (&debug_thread_writer_cv, s));
+	closure_fork (closure_debug_thread (&debug_thread_writer_cv, s));
+	closure_fork (closure_debug_thread_reader (&debug_thread_reader_cv, s, NULL));
+	nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (500));
+	*slot (s, "wait0_mu") = nsync_mu_debug_state_and_waiters (
+		&s->mu, (char *) malloc (len), len);
+	*slot (s, "wait0_cv") = nsync_cv_debug_state_and_waiters (
+		&s->cv, (char *) malloc (len), len);
+
+	/* allow the threads to proceed to their conditional waits */
+	nsync_mu_unlock (&s->mu);
+	nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (500));
+	*slot (s, "wait1_mu") = nsync_mu_debug_state_and_waiters (
+		&s->mu, (char *) malloc (len), len);
+	*slot (s, "wait1_cv") = nsync_cv_debug_state_and_waiters (
+		&s->cv, (char *) malloc (len), len);
+
+	nsync_mu_lock (&s->mu);
+	/* move cv waiters to mutex queue */
+	nsync_cv_broadcast (&s->cv);
+	*slot (s, "wait2_mu") = nsync_mu_debug_state_and_waiters (
+		&s->mu, (char *) malloc (len), len);
+	*slot (s, "wait2_cv") = nsync_cv_debug_state_and_waiters (
+		&s->cv, (char *) malloc (len), len);
+
+	/* allow all threads to proceed and exit */
+	s->flag = 0;
+	nsync_mu_unlock (&s->mu);
+	nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (500));
+	*slot (s, "wait3_mu") = nsync_mu_debug_state_and_waiters (
+		&s->mu, (char *) malloc (len), len);
+	*slot (s, "wait3_cv") = nsync_cv_debug_state_and_waiters (
+		&s->cv, (char *) malloc (len), len);
+
+	/* Test with more than one reader */
+	nsync_mu_rlock (&s->mu);
+	*slot (s, "rheld1_mu") = nsync_mu_debug_state_and_waiters (
+		&s->mu, (char *) malloc (len), len);
+	closure_fork (closure_debug_thread_reader (
+		&debug_thread_reader, s, "rheld2_mu"));
+	nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (500));
+	*slot (s, "rheld1again_mu") = nsync_mu_debug_state_and_waiters (
+		&s->mu, (char *) malloc (len), len);
+	nsync_mu_runlock (&s->mu);
+
+	check_same (t, s, "init_mu0", "init_mu1");
+	check_same (t, s, "init_mu0", "init_mu2");
+	check_same (t, s, "init_cv0", "init_cv1");
+	check_same (t, s, "init_cv0", "init_cv2");
+	check_different (t, s, "init_mu0", "held_mu");
+	check_different (t, s, "rheld1_mu", "held_mu");
+	/* Must acquire result_mu, because the "rheld2_mu" slot is accessed
+	   from the debug_thread_reader() thread created above.  */
+	nsync_mu_lock (&s->result_mu);
+	check_different (t, s, "rheld1_mu", "rheld2_mu");
+	nsync_mu_unlock (&s->result_mu);
+	check_different (t, s, "init_mu0", "init_cv0");
+
+	for (i = 0; result_name[i] != NULL; i++) {
+		if (testing_verbose (t)) {
+			const char *str = *slot (s, result_name[i]);
+			TEST_LOG (t, ("%-16s  %s\n", result_name[i], str));
+		}
+		if (strlen (s->result[i]) == 0) {
+			TEST_ERROR (t, ("nsync_mu_debug_state() %s empty",
+					result_name[i]));
+		}
+		free (s->result[i]);
+	}
+}
+
+/* --------------------------- */
+
+/* Max number of waiter threads used in transfer test.
+   The last uses a conditional critical section, and others
+   use a condition variable.   */
+#define TRANSFER_MAX_WAITERS 8
+
+/* A struct cv_transfer is used to test cv-to-mu thread transfer.
+   There are up to TRANSFER_MAX_WAITERS waiter threads, and a wakeup thread.
+   Some threads wait using conditional critical sections,
+   and others using a condition variable. */
+struct cv_transfer {
+	nsync_mu mu;
+
+	nsync_cv cv;  /* signalled each time a cond[] element becomes non-zero */
+	/* Thread i waits for cond[i] to be non-zero; under mu.  */
+        int cond[TRANSFER_MAX_WAITERS];
+
+	nsync_mu control_mu;  /* protects fields below */
+	nsync_cv done_cv; /* signalled each time an element of done[] becomes non-zero */
+	int ready[TRANSFER_MAX_WAITERS];  /* set by waiters as they wait */
+	int done[TRANSFER_MAX_WAITERS];   /* set by completed waiters: to 1 by readers, and to 2 by writers */
+};
+
+/* Return whether *(int *)v != 0.  Used as a condition for nsync_mu_wait().  */
+static int int_is_non_zero (const void *v) {
+	return (0 != *(const int *)v);
+}
+
+/* Return when *pi becomes non-zero, where *pi is protected by *mu.
+   Acquires and releases *mu. */
+static void transfer_await_nonzero (nsync_mu *mu, int *pi) {
+	nsync_mu_lock (mu);
+	nsync_mu_wait (mu, &int_is_non_zero, pi, NULL);
+	nsync_mu_unlock (mu);
+}
+
+/* Set *pi to x value, where *pi is protected by *mu.
+   Acquires and releases *mu. */
+static void transfer_set (nsync_mu *mu, int *pi, int x) {
+	nsync_mu_lock (mu);
+	*pi = x;
+	nsync_mu_unlock (mu);
+}
+
+/* Lock and unlock routines for writers (index 0), and readers (index 1).  */
+static const struct {
+	void (*lock) (nsync_mu *);
+	void (*unlock) (nsync_mu *);
+} lock_type[2] = {
+	{ &nsync_mu_lock, &nsync_mu_unlock },
+	{ &nsync_mu_rlock, &nsync_mu_runlock },
+};
+
+/* Signal and broadcast routines */
+typedef void (*wakeup_func_type) (nsync_cv *);
+static wakeup_func_type wakeup_func[2] = { &nsync_cv_broadcast, &nsync_cv_signal };
+
+/* Acquire cvt->mu in write or read mode (depending on "reader"),
+   set cvt->ready[i], wait for cvt->cond[i] to become non-zero (using
+   a condition variable if use_cv!=0), then release cvt->mu, and
+   set cvt->done[i].
+   Used as the body of waiter threads created by test_cv_transfer(). */
+static void transfer_waiter_thread (struct cv_transfer *cvt, int i, int reader, int use_cv) {
+	(*lock_type[reader].lock) (&cvt->mu);
+	transfer_set (&cvt->control_mu, &cvt->ready[i], 1);
+	if (use_cv) {
+		while (!cvt->cond[i]) {
+			nsync_cv_wait (&cvt->cv, &cvt->mu);
+		}
+	} else {
+		nsync_mu_wait (&cvt->mu, &int_is_non_zero, &cvt->cond[i], NULL);
+	}
+	(*lock_type[reader].unlock) (&cvt->mu);
+
+	transfer_set (&cvt->control_mu, &cvt->done[i], reader? 1 : 2);
+	nsync_cv_broadcast (&cvt->done_cv);
+}
+
+/* Return whether all the elements a[0..n-1] are less than x. */
+static int are_all_below (int a[], int n, int x) {
+	int i;
+	for (i = 0; i != n && a[i] < x; i++) {
+	}
+	return (i == n);
+}
+
+CLOSURE_DECL_BODY4 (transfer_thread, struct cv_transfer *, int, int, int)
+
+/* Test cv-to-mutex queue transfer.  (See the code in cv.c, wake_waiters().)
+
+   The queue transfer needs to work regardless of:
+   - whether the mutex is also being used with conditional critical sections,
+   - whether reader locks are used,
+   - whether the waker signals from within the critical section (as it would in
+     a traditional monitor), or after that critical section, and
+   - the number of threads that might be awoken.  */
+static void test_cv_transfer (testing t) {
+	int waiters;	 /* number of waiters (in [2, TRANSFER_MAX_WAITERS]). */
+	int cv_writers;  /* number of cv_writers: -1 means all */
+	int ccs_reader; /* ccs waiter is a reader */
+	int wakeup_type; /* bits: use_signal and after_region */
+	enum { use_signal = 0x1 };  /* use signal rather than broadcast */
+	enum { after_region = 0x2 };  /* perform wakeup after region, rather than within */
+	struct cv_transfer Xcvt;
+	struct cv_transfer *cvt = &Xcvt;  /* So all accesses are of form cvt-> */
+	int i;
+
+	/* for all settings of all of wakeup_type, ccs_reader, cv_writers,
+	   and various different numbers of waiters */
+	for (waiters = 2; waiters <= TRANSFER_MAX_WAITERS; waiters <<= 1) {
+		for (wakeup_type = 0; wakeup_type != 4; wakeup_type++) {
+			for (cv_writers = -1; cv_writers != 3; cv_writers++) {
+				for (ccs_reader = 0; ccs_reader != 2; ccs_reader++) {
+					if (testing_verbose (t)) {
+						TEST_LOG (t, ("transfer waiters %d wakeup_type %d  cv_writers %d  ccs_reader %d\n",
+							      waiters, wakeup_type, cv_writers, ccs_reader));
+					}
+					bzero ((void *) cvt, sizeof (*cvt));
+
+					/* Start the waiter threads that use condition variables. */
+					for (i = 0; i < waiters-1; i++) {
+						int is_reader = (cv_writers != -1 && i < waiters-1-cv_writers);
+						closure_fork (closure_transfer_thread (&transfer_waiter_thread, cvt, i,
+										       is_reader, 1/*use_cv*/));
+						transfer_await_nonzero (&cvt->control_mu, &cvt->ready[i]);
+					}
+					/* Start the waiter thread that uses conditional critical sections. */
+					closure_fork (closure_transfer_thread (&transfer_waiter_thread, cvt, i,
+									       ccs_reader, 0/*use_cv*/));
+					/* Wait for all waiters to enter their regions. */
+					for (i = 0; i != waiters; i++) {
+						transfer_await_nonzero (&cvt->control_mu, &cvt->ready[i]);
+					}
+
+					nsync_mu_lock (&cvt->mu);
+					/* At this point, all the waiter threads are in waiting: 
+					   they have set their ready[] flags, and have released cvt->mu. */
+
+					/* Mark all the condition-variable as runnable,
+					   and signal at least one of them.
+					   This may wake more than one, depending on
+					   the presence of readers, and the use of
+					   signal vs broadcast.  */
+					for (i = 0; i != waiters-1; i++) {
+						cvt->cond[i] = 1;
+					}
+					if ((wakeup_type & after_region) == 0) {
+						(*wakeup_func[wakeup_type & use_signal]) (&cvt->cv);
+					}
+					nsync_mu_unlock (&cvt->mu);
+					if ((wakeup_type & after_region) != 0) {
+						for (i = 0; i != waiters-1; i++) {
+							(*wakeup_func[wakeup_type & use_signal]) (&cvt->cv);
+						}
+					}
+
+					/* Wait for at least one woken waiter to proceed,
+					   and at least one writer if there is one.  */
+					nsync_mu_lock (&cvt->control_mu);
+					while (are_all_below (&cvt->done[0], waiters-1, cv_writers!=0? 2 : 1)) {
+						nsync_cv_wait (&cvt->done_cv, &cvt->control_mu);
+					}
+					nsync_mu_unlock (&cvt->control_mu);
+
+					/* Wake all remaining threads. */
+					nsync_cv_broadcast (&cvt->cv);
+					transfer_set (&cvt->mu, &cvt->cond[waiters-1], 1);
+
+					/* And wait for all to finish. */
+					for (i = 0; i != waiters; i++) {
+						transfer_await_nonzero (&cvt->control_mu, &cvt->done[i]);
+					}
+
+					if (testing_verbose (t)) {
+						TEST_LOG (t, ("transfer waiters %d wakeup_type %d  cv_writers %d  ccs_reader %d complete\n",
+							      waiters, wakeup_type, cv_writers, ccs_reader));
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/third_party/nsync/testing/cv_wait_example.c b/third_party/nsync/testing/cv_wait_example.c
new file mode 100644
index 000000000..f94092987
--- /dev/null
+++ b/third_party/nsync/testing/cv_wait_example.c
@@ -0,0 +1,184 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "third_party/nsync/array.internal.h"
+#include "third_party/nsync/time.h"
+#include "third_party/nsync/cv.h"
+#include "third_party/nsync/heap.internal.h"
+#include "third_party/nsync/mu.h"
+#include "third_party/nsync/testing/closure.h"
+#include "third_party/nsync/testing/smprintf.h"
+#include "third_party/nsync/testing/testing.h"
+#include "libc/dce.h"
+#include "third_party/nsync/testing/time_extra.h"
+
+/* Example use of CV.wait():  A priority queue of strings whose
+   "remove_with_deadline" operation has a deadline. */
+
+/* --------------------------------------- */
+
+typedef A_TYPE (const char *) a_string; /* An array used as a heap of strings. */
+
+/* heap comparison function */
+static int str_lt (const char *e0, const char *e1) {
+	return (strcmp (e0, e1) < 0);
+}
+
+static void no_set (const char *a, int b) {
+}
+
+/* --------------------------------------- */
+
+/* A string_priority_queue_cv is a priority queue of strings, which emits the
+   lexicographically least string available. */
+typedef struct string_priority_queue_cv_s {
+	nsync_cv non_empty; /* signalled when heap becomes non-empty */
+	nsync_mu mu; /* protects heap */
+	a_string heap;
+} string_priority_queue_cv;
+
+
+/* Add "s" to the queue *q. */
+static void string_priority_queue_cv_add (string_priority_queue_cv *q, const char *s) {
+	int alen;
+	nsync_mu_lock (&q->mu);
+	alen = A_LEN (&q->heap);
+	if (alen == 0) {
+		nsync_cv_broadcast (&q->non_empty);
+	}
+	A_PUSH (&q->heap) = s;
+	heap_add (&A (&q->heap, 0), alen, str_lt, no_set, s);
+	nsync_mu_unlock (&q->mu);
+}
+
+/* Wait until queue *q is non-empty, then remove a string from its
+   beginning, and return it; or if abs_deadline is reached before the
+   queue becomes non-empty, return NULL. */
+static const char *string_priority_queue_cv_remove_with_deadline (string_priority_queue_cv *q,
+							          nsync_time abs_deadline) {
+	int alen;
+	const char *s = NULL;
+	nsync_mu_lock (&q->mu);
+	while (A_LEN (&q->heap) == 0 &&
+	       nsync_cv_wait_with_deadline (&q->non_empty, &q->mu, NSYNC_CLOCK,
+					    abs_deadline, NULL) == 0) {
+	}
+	alen = A_LEN (&q->heap);
+	if (alen != 0) {
+		s = A (&q->heap, 0);
+		heap_remove (&A (&q->heap, 0), alen, str_lt, no_set, 0);
+		A_DISCARD (&q->heap, 1);
+	}
+	nsync_mu_unlock (&q->mu);
+	return (s);
+}
+
+/* Free resources associates with *q */
+static void string_priority_queue_cv_destroy (string_priority_queue_cv *q) {
+	A_FREE (&q->heap);
+}
+
+/* --------------------------------------- */
+
+/* Add strings s[0, ..., n-1] to *q, with the specified delay between additions. */
+static void add_and_wait_cv (string_priority_queue_cv *q, nsync_time delay,
+			     int n, const char *s[]) {
+	int i;
+	for (i = 0; i != n; i++) {
+		string_priority_queue_cv_add (q, s[i]);
+		nsync_time_sleep (NSYNC_CLOCK, delay);
+	}
+}
+
+CLOSURE_DECL_BODY4 (add_and_wait_cv, string_priority_queue_cv *,
+		    nsync_time, int, const char **)
+
+typedef A_TYPE (char) a_char; /* an array or characters */
+
+/* Append the nul-terminated string str[] to *a. */
+static void a_char_append (a_char *a, const char *str) {
+	while (*str != 0) {
+		A_PUSH (a) = *str;
+		str++;
+	}
+}
+
+/* Remove the first item from *q and output it on stdout,
+   or output "timeout: <delay>" if no value can be found before "delay" elapses. */
+static void remove_and_print_cv (string_priority_queue_cv *q, nsync_time delay, a_char *output) {
+	const char *s;
+	if ((s = string_priority_queue_cv_remove_with_deadline (
+			q, nsync_time_add (nsync_time_now (NSYNC_CLOCK), delay))) != NULL) {
+		a_char_append (output, s);
+		a_char_append (output, "\n");
+	} else {
+		char buf[64];
+		snprintf (buf, sizeof (buf), "timeout %gs\n",
+			  nsync_time_to_dbl (delay));
+		a_char_append (output, buf);
+	}
+}
+
+/* Demonstrates the use of nsync_mu_wait() via a priority queue of strings.
+   See the routine string_priority_queue_cv_remove_with_deadline(), above. */
+static void example_cv_wait (testing t) {
+	static const char *input[] = { "one", "two", "three", "four", "five" };
+	string_priority_queue_cv q;
+	a_char output;
+	static const char *expected =
+		"one\n"
+		"three\n"
+		"two\n"
+		"timeout 0.1s\n"
+		"four\n"
+		"timeout 0.1s\n"
+		"five\n"
+		"timeout 1s\n";
+
+	bzero ((void *) &q, sizeof (q));
+	bzero (&output, sizeof (output));
+
+	closure_fork (closure_add_and_wait_cv (&add_and_wait_cv, &q,
+					       nsync_time_ms (500), NELEM (input), input));
+
+	/* delay: "one", "two", "three" are queued; not "four" */
+	nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (1200));
+
+	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* "one" */
+	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* "three" (less than "two") */
+	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* "two" */
+	remove_and_print_cv (&q, nsync_time_ms (100), &output); /* time out because 1.3 < 0.5*3 */
+	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* "four" */
+	remove_and_print_cv (&q, nsync_time_ms (100), &output); /* time out because 0.1 < 0.5 */
+	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* "five" */
+	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* time out: no more to fetch */
+
+	A_PUSH (&output) = 0;
+	if (strcmp (&A (&output, 0), expected) != 0) {
+		TEST_ERROR (t, ("expected = %s\ngot      = %s\n", expected, &A (&output, 0)));
+	}
+	A_FREE (&output);
+	string_priority_queue_cv_destroy (&q);
+}
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+	TEST_RUN (tb, example_cv_wait);
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/cv_wait_example_test.c b/third_party/nsync/testing/cv_wait_example_test.c
deleted file mode 100644
index 20f7ac000..000000000
--- a/third_party/nsync/testing/cv_wait_example_test.c
+++ /dev/null
@@ -1,181 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2016 Google Inc.                                                   │
-│                                                                              │
-│ 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.                                               │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "third_party/nsync/array.internal.h"
-#include "third_party/nsync/cv.h"
-#include "third_party/nsync/heap.internal.h"
-#include "third_party/nsync/mu.h"
-#include "third_party/nsync/testing/closure.h"
-#include "third_party/nsync/testing/smprintf.h"
-#include "third_party/nsync/testing/testing.h"
-#include "third_party/nsync/testing/time_extra.h"
-
-/* Example use of CV.wait():  A priority queue of strings whose
-   "remove_with_deadline" operation has a deadline. */
-
-/* --------------------------------------- */
-
-typedef A_TYPE (const char *) a_string; /* An array used as a heap of strings. */
-
-/* heap comparison function */
-static int str_lt (const char *e0, const char *e1) {
-	return (strcmp (e0, e1) < 0);
-}
-
-static void no_set (const char *a, int b) {
-}
-
-/* --------------------------------------- */
-
-/* A string_priority_queue_cv is a priority queue of strings, which emits the
-   lexicographically least string available. */
-typedef struct string_priority_queue_cv_s {
-	nsync_cv non_empty; /* signalled when heap becomes non-empty */
-	nsync_mu mu; /* protects heap */
-	a_string heap;
-} string_priority_queue_cv;
-
-
-/* Add "s" to the queue *q. */
-static void string_priority_queue_cv_add (string_priority_queue_cv *q, const char *s) {
-	int alen;
-	nsync_mu_lock (&q->mu);
-	alen = A_LEN (&q->heap);
-	if (alen == 0) {
-		nsync_cv_broadcast (&q->non_empty);
-	}
-	A_PUSH (&q->heap) = s;
-	heap_add (&A (&q->heap, 0), alen, str_lt, no_set, s);
-	nsync_mu_unlock (&q->mu);
-}
-
-/* Wait until queue *q is non-empty, then remove a string from its
-   beginning, and return it; or if abs_deadline is reached before the
-   queue becomes non-empty, return NULL. */
-static const char *string_priority_queue_cv_remove_with_deadline (string_priority_queue_cv *q,
-							          nsync_time abs_deadline) {
-	int alen;
-	const char *s = NULL;
-	nsync_mu_lock (&q->mu);
-	while (A_LEN (&q->heap) == 0 &&
-	       nsync_cv_wait_with_deadline (&q->non_empty, &q->mu, abs_deadline, NULL) == 0) {
-	}
-	alen = A_LEN (&q->heap);
-	if (alen != 0) {
-		s = A (&q->heap, 0);
-		heap_remove (&A (&q->heap, 0), alen, str_lt, no_set, 0);
-		A_DISCARD (&q->heap, 1);
-	}
-	nsync_mu_unlock (&q->mu);
-	return (s);
-}
-
-/* Free resources associates with *q */
-static void string_priority_queue_cv_destroy (string_priority_queue_cv *q) {
-	A_FREE (&q->heap);
-}
-
-/* --------------------------------------- */
-
-/* Add strings s[0, ..., n-1] to *q, with the specified delay between additions. */
-static void add_and_wait_cv (string_priority_queue_cv *q, nsync_time delay,
-			     int n, const char *s[]) {
-	int i;
-	for (i = 0; i != n; i++) {
-		string_priority_queue_cv_add (q, s[i]);
-		nsync_time_sleep (delay);
-	}
-}
-
-CLOSURE_DECL_BODY4 (add_and_wait_cv, string_priority_queue_cv *,
-		    nsync_time, int, const char **)
-
-typedef A_TYPE (char) a_char; /* an array or characters */
-
-/* Append the nul-terminated string str[] to *a. */
-static void a_char_append (a_char *a, const char *str) {
-	while (*str != 0) {
-		A_PUSH (a) = *str;
-		str++;
-	}
-}
-
-/* Remove the first item from *q and output it on stdout,
-   or output "timeout: <delay>" if no value can be found before "delay" elapses. */
-static void remove_and_print_cv (string_priority_queue_cv *q, nsync_time delay, a_char *output) {
-	const char *s;
-	if ((s = string_priority_queue_cv_remove_with_deadline (
-			q, nsync_time_add (nsync_time_now(), delay))) != NULL) {
-		a_char_append (output, s);
-		a_char_append (output, "\n");
-	} else {
-		char buf[64];
-		snprintf (buf, sizeof (buf), "timeout %gs\n",
-			  nsync_time_to_dbl (delay));
-		a_char_append (output, buf);
-	}
-}
-
-/* Demonstrates the use of nsync_mu_wait() via a priority queue of strings.
-   See the routine string_priority_queue_cv_remove_with_deadline(), above. */
-static void example_cv_wait (testing t) {
-	static const char *input[] = { "one", "two", "three", "four", "five" };
-	string_priority_queue_cv q;
-	a_char output;
-	static const char *expected =
-		"one\n"
-		"three\n"
-		"two\n"
-		"timeout 0.1s\n"
-		"four\n"
-		"timeout 0.1s\n"
-		"five\n"
-		"timeout 1s\n";
-
-	bzero ((void *) &q, sizeof (q));
-	bzero (&output, sizeof (output));
-
-	closure_fork (closure_add_and_wait_cv (&add_and_wait_cv, &q,
-					       nsync_time_ms (500), NELEM (input), input));
-
-	/* delay: "one", "two", "three" are queued; not "four" */
-	nsync_time_sleep (nsync_time_ms (1200));
-
-	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* "one" */
-	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* "three" (less than "two") */
-	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* "two" */
-	remove_and_print_cv (&q, nsync_time_ms (100), &output); /* time out because 1.3 < 0.5*3 */
-	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* "four" */
-	remove_and_print_cv (&q, nsync_time_ms (100), &output); /* time out because 0.1 < 0.5 */
-	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* "five" */
-	remove_and_print_cv (&q, nsync_time_ms (1000), &output);    /* time out: no more to fetch */
-
-	A_PUSH (&output) = 0;
-	if (strcmp (&A (&output, 0), expected) != 0) {
-		TEST_ERROR (t, ("expected = %s\ngot      = %s\n", expected, &A (&output, 0)));
-	}
-	A_FREE (&output);
-	string_priority_queue_cv_destroy (&q);
-}
-
-int main (int argc, char *argv[]) {
-	testing_base tb = testing_new (argc, argv, 0);
-	TEST_RUN (tb, example_cv_wait);
-	return (testing_base_exit (tb));
-}
diff --git a/third_party/nsync/testing/mu2_test.c b/third_party/nsync/testing/mu2_test.c
new file mode 100644
index 000000000..938100063
--- /dev/null
+++ b/third_party/nsync/testing/mu2_test.c
@@ -0,0 +1,27 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/testing/mu_test.inc"
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+
+	TEST_RUN (tb, test_mutex_nthread);
+	TEST_RUN (tb, test_xmutex_nthread);
+
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/mu3_test.c b/third_party/nsync/testing/mu3_test.c
new file mode 100644
index 000000000..2aac65baa
--- /dev/null
+++ b/third_party/nsync/testing/mu3_test.c
@@ -0,0 +1,27 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/testing/mu_test.inc"
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+
+	TEST_RUN (tb, test_rwmutex_nthread);
+	TEST_RUN (tb, test_try_mu_nthread);
+
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/mu_starvation_test.c b/third_party/nsync/testing/mu_starvation_test.c
deleted file mode 100644
index f6df7cd5c..000000000
--- a/third_party/nsync/testing/mu_starvation_test.c
+++ /dev/null
@@ -1,346 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2016 Google Inc.                                                   │
-│                                                                              │
-│ 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.                                               │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/str/str.h"
-#include "libc/thread/thread.h"
-#include "third_party/nsync/mu.h"
-#include "third_party/nsync/mu_wait.h"
-#include "third_party/nsync/testing/closure.h"
-#include "third_party/nsync/testing/smprintf.h"
-#include "third_party/nsync/testing/testing.h"
-#include "third_party/nsync/testing/time_extra.h"
-#include "third_party/nsync/time.h"
-
-/* Test the behaviour of mu in situations where starvation might be expected. */
-
-/* starve_data is the data used by the starvation tests */
-typedef struct starve_data_s {
-	nsync_mu mu; /* precedes control_mu in locking order */
-	int cancel;     /* whether threads should shutdown; under mu */
-	nsync_time start;  /* when test started */
-
-	nsync_mu control_mu;
-	int not_yet_started; /* threads not yet started; under control_mu */
-	int not_yet_done; /* threads not yet done; under control_mu */
-} starve_data;
-
-/* initialize *sd */
-static void starve_data_init (starve_data *sd, int threads) {
-	bzero ((void *) sd, sizeof (*sd));
-	sd->not_yet_started = threads;
-	sd->not_yet_done = threads;
-	sd->start = nsync_time_now ();
-}
-
-/* Loop until *cancel or deadline, and on each iteration
-   acquire *mu in reader mode, and hold it until the next odd or even
-   multiple of period, according to parity.  Just before return, decrement *done
-   under *mu.  Two threads using these calls are used to hold the
-   mutex continually, in the absence of other activity. */
-static void starve_with_readers (starve_data *sd, nsync_time period,
-				 uint32_t parity, nsync_time deadline) {
-	nsync_time now;
-	uint32_t period_us = (uint32_t) (nsync_time_to_dbl (period) * 1e6);
-	nsync_mu_rlock (&sd->mu);
-
-	nsync_mu_lock (&sd->control_mu);
-	sd->not_yet_started--;
-	nsync_mu_unlock (&sd->control_mu);
-
-	for (now = nsync_time_now ();
-	     !sd->cancel && nsync_time_cmp (now, deadline) < 0;
-	     now = nsync_time_now ()) {
-		uint32_t new_us;
-		uint32_t now_us = (uint32_t) (nsync_time_to_dbl (nsync_time_sub (now, sd->start)) * 1e6);
-		uint32_t index = (now_us + period_us - 1) / period_us;
-		if ((index & 1) != parity) {
-			index++;
-		}
-		new_us = index * period_us;
-		nsync_time_sleep (nsync_time_from_dbl (1e-6 * (double) (new_us-now_us)));
-		nsync_mu_runlock (&sd->mu);
-		nsync_mu_rlock (&sd->mu);
-	}
-	nsync_mu_runlock (&sd->mu);
-
-	nsync_mu_lock (&sd->control_mu);
-	sd->not_yet_done--;
-	nsync_mu_unlock (&sd->control_mu);
-}
-
-CLOSURE_DECL_BODY4 (starve_with_readers, starve_data *, nsync_time, uint32_t, nsync_time)
-
-static int started (const void *v) {
-	return (((const starve_data *) v)->not_yet_started == 0);
-}
-
-static int done (const void *v) {
-	return (((const starve_data *) v)->not_yet_done == 0);
-}
-
-/* Verify the behaviour of nsync_mu in the face of reader threads that conspire
-   keep the lock held continuously in reader mode, even though each of the
-   threads releases and reacquires periodically (while another thread holds the
-   lock).  The routine starve_with_readers() is used to achieve this effect.
-
-   We expect that nsync_mu_trylock() will not be able to acquire while this is
-   happening, but that nsync_mu_lock() will be able to acquire, due to the action of the
-   mu's mu_writer_waiting bit. */
-static void test_starve_with_readers (testing t) {
-	nsync_time finish;
-	int trylock_acquires;
-	int expected_lo;
-	int lock_acquires;
-
-	nsync_time deadline;
-
-	starve_data sd;
-	starve_data_init (&sd, 2); /* two threads, started below */
-
-	/* Threads run for at most 10s. */
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (10000));
-
-	/* These two threads will try to hold a reader lock
-	   continuously until cancel is set or deadline is reached,
-	   even though each will release the lock every 20ms. */
-	closure_fork (closure_starve_with_readers (
-		&starve_with_readers, &sd, nsync_time_ms (10), 0, deadline));
-	closure_fork (closure_starve_with_readers (
-		&starve_with_readers, &sd, nsync_time_ms (10), 1, deadline));
-
-	/* wait for the threads to acquire their first lock. */
-	nsync_mu_lock (&sd.control_mu);
-	nsync_mu_wait (&sd.control_mu, &started, &sd, NULL);
-	nsync_mu_unlock (&sd.control_mu);
-
-	/* If using an nsync_mu, use nsync_mu_trylock() to attempt to acquire while the
-	   readers are hogging the lock.  We expect no acquisitions to succeed. */
-	finish = nsync_time_add (nsync_time_now (), nsync_time_ms (500));
-	trylock_acquires = 0; /* number of acquires */
-	while (nsync_time_cmp (nsync_time_now (), finish) < 0) {
-		if (nsync_mu_trylock (&sd.mu)) {
-			trylock_acquires++;
-			nsync_mu_unlock (&sd.mu);
-		}
-		pthread_yield ();
-	}
-	if (trylock_acquires != 0) {
-		TEST_ERROR (t, ("expected no acquisitions via nsync_mu_trylock(), got %d\n",
-			   trylock_acquires));
-	}
-
-	/* Use nsync_mu_lock() to attempt to acquire while the readers are hogging
-	   the lock.  We expect several acquisitions to succeed. */
-	expected_lo = 2;
-	finish = nsync_time_add (nsync_time_now (), nsync_time_ms (5000));
-	lock_acquires = 0; /* number of acquires */
-	while (nsync_time_cmp (nsync_time_now (), finish) < 0 && lock_acquires < expected_lo) {
-		nsync_mu_lock (&sd.mu);
-		lock_acquires++;
-		nsync_mu_unlock (&sd.mu);
-		nsync_time_sleep (nsync_time_ms (1));
-	}
-	if (nsync_time_cmp (nsync_time_now (), deadline) > 0 && lock_acquires == 1) {
-		lock_acquires = 0; /* hog threads timed out */
-	}
-	if (lock_acquires < expected_lo) {
-		TEST_ERROR (t, ("expected at least %d acquisitions via nsync_mu_lock(), got %d\n",
-			   expected_lo, lock_acquires));
-	}
-
-	nsync_mu_lock (&sd.mu);
-	sd.cancel = 1; /* Tell threads to exit. */
-	nsync_mu_unlock (&sd.mu);
-
-	nsync_mu_lock (&sd.control_mu);
-	nsync_mu_wait (&sd.control_mu, &done, &sd, NULL); /* wait for exit. */
-	nsync_mu_unlock (&sd.control_mu);
-}
-
-/* Loop until sd.cancel or deadline.  On each iteration<
-   acquire sd.mu in writer mode, sleep for hold_time, and release sd.mu.
-   Just before return, decrement sd.not_yet_done under sd.control_mu. */
-static void starve_with_writer (starve_data *sd, nsync_time hold_time,
-			        nsync_time deadline) {
-	nsync_time now;
-
-	nsync_mu_lock (&sd->mu);
-
-	nsync_mu_lock (&sd->control_mu);
-	sd->not_yet_started--;
-	nsync_mu_unlock (&sd->control_mu);
-
-	for (now = nsync_time_now ();
-	     !sd->cancel && nsync_time_cmp (now, deadline) < 0;
-	     now = nsync_time_now ()) {
-		nsync_time_sleep (hold_time);
-		nsync_mu_unlock (&sd->mu);
-		nsync_mu_lock (&sd->mu);
-	}
-	nsync_mu_unlock (&sd->mu);
-
-	nsync_mu_lock (&sd->control_mu);
-	sd->not_yet_done--;
-	nsync_mu_unlock (&sd->control_mu);
-}
-
-CLOSURE_DECL_BODY3 (starve_with_writer, starve_data *, nsync_time, nsync_time)
-
-/* Verify the behaviour of nsync_mu in the face of a
-   single writer thread that repeatedly hogs the lock by acquiring it and
-   holding it for longer than the runtime's wakeup time, then releasing.  The
-   next iteration reacquires the lock moments later, a time much shorter than
-   the runtime's wakeup time.  The routine starve_with_writer() is used to
-   achieve this effect.
-
-   These circumstances can make it hard for another thread T to acquire.  T
-   will first wait on the mutex's queue.  Eventually, it will be woken by the
-   hog thread, but under normal circumstances T will take so long to run that
-   the hog will have reacquired the mutex.  Because the hog keeps the lock for
-   longer than the runtime's wakeup time, T will go back to sleep again, and
-   the process repeats indefinitely.
-
-   We expect that incessant attempts via nsync_mu_trylock() and nsync_mu_rtrylock() will
-   occasionally manage to hit the moments when the lock is not held.  nsync_mu_lock()
-   and nsync_mu_rlock() will succeed only because of the action of mu's mu_long_wait bit,
-   which will eventually force the hog to wait itself, and allow a waiter
-   to acquire.  We expect few acquires because mu_long_wait kicks in only
-   when things look dire. */
-static void test_starve_with_writer (testing t) {
-	int expected_lo;
-	nsync_time finish;
-	int lock_acquires;
-	int rlock_acquires;
-	int trylock_acquires;
-	int rtrylock_acquires;
-	nsync_time deadline;
-	starve_data sd;
-	starve_data_init (&sd, 1); /* one thread, started below */
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (25000)); /* runs for at most 25s. */
-
-	/* This thread will try to hold a writer lock almost
-	   continuously, releasing momentarily every 10ms. */
-	closure_fork (closure_starve_with_writer (&starve_with_writer, &sd,
-						  nsync_time_ms (10), deadline));
-
-	nsync_mu_lock (&sd.control_mu);
-	nsync_mu_wait (&sd.control_mu, &started, &sd, NULL);
-	nsync_mu_unlock (&sd.control_mu);
-
-	expected_lo = 0;   /* minimum expected operations at each test */
-	finish = nsync_time_zero; /* finish time for each test */
-
-	if (!testing_is_uniprocessor (t)) {  /* this test won't work on a uniprocessor */
-		/* Use nsync_mu_trylock() to attempt to acquire while the writer is hogging the
-		   lock.  We expect some acquisitions to succeed. */
-		expected_lo = 1;
-		finish = nsync_time_add (nsync_time_now (), nsync_time_ms (30000));
-		trylock_acquires = 0; /* number of acquires */
-		while (nsync_time_cmp (nsync_time_now (), finish) < 0 && trylock_acquires < expected_lo) {
-			if (nsync_mu_trylock (&sd.mu)) {
-				trylock_acquires++;
-				nsync_mu_unlock (&sd.mu);
-			}
-			pthread_yield ();
-		}
-		if (trylock_acquires < expected_lo) {
-			TEST_ERROR (t, ("expected at least %d acquisitions via "
-				   "nsync_mu_trylock(), got %d\n",
-				   expected_lo, trylock_acquires));
-		}
-	}
-
-	if (!testing_is_uniprocessor (t)) {  /* this test won't work on a uniprocessor */
-		/* Use nsync_mu_rtrylock() to attempt to read-acquire while the writer is
-		   hogging the lock.  We expect some acquisitions to succeed. */
-		expected_lo = 1;
-		finish = nsync_time_add (nsync_time_now (), nsync_time_ms (30000));
-		rtrylock_acquires = 0; /* number of acquires */
-		while (nsync_time_cmp (nsync_time_now (), finish) < 0 && rtrylock_acquires < expected_lo) {
-			if (nsync_mu_rtrylock (&sd.mu)) {
-				rtrylock_acquires++;
-				nsync_mu_runlock (&sd.mu);
-			}
-			pthread_yield ();
-		}
-		if (rtrylock_acquires < expected_lo) {
-			TEST_ERROR (t, ("expected at least %d acquisitions via "
-				   "nsync_mu_rtrylock(), got %d\n",
-				   expected_lo, rtrylock_acquires));
-		}
-	}
-
-	/* Use nsync_mu_lock() to attempt to acquire while the writer is hogging
-	   the lock.  We expect several acquisitions to succeed. */
-	expected_lo = 2;
-	finish = nsync_time_add (nsync_time_now (), nsync_time_ms (5000));
-	lock_acquires = 0; /* number of acquires */
-	while (nsync_time_cmp (nsync_time_now (), finish) < 0 && lock_acquires < expected_lo) {
-		nsync_mu_lock (&sd.mu);
-		lock_acquires++;
-		nsync_mu_unlock (&sd.mu);
-		nsync_time_sleep (nsync_time_ms (2));
-	}
-	if (lock_acquires == 1 && nsync_time_cmp (nsync_time_now (), deadline) > 0) {
-		lock_acquires = 0; /* hog thread timed out */
-	}
-	if (lock_acquires < expected_lo) {
-		TEST_ERROR (t, ("expected at least %d acquisitions via nsync_mu_lock(), got %d\n",
-			   expected_lo, lock_acquires));
-	}
-
-	/* If enough time remains to run the test, use nsync_mu_rlock() to attempt to
-	   acquire while the writer is hogging the lock.  We expect several
-	   acquisitions to succeed.  It's ok not to run the test if we ran out
-	   time----it means that a writer couldn't break in (the test case
-	   above failed), so a reader is unlikely to manage it either. */
-	expected_lo = 2;
-	finish = nsync_time_add (nsync_time_now (), nsync_time_ms (5000));
-	rlock_acquires = 0; /* number of acquires */
-	if (nsync_time_cmp (finish, deadline) < 0) {
-		while (nsync_time_cmp (nsync_time_now (), finish) < 0 && rlock_acquires < expected_lo) {
-			nsync_mu_rlock (&sd.mu);
-			rlock_acquires++;
-			nsync_mu_runlock (&sd.mu);
-			nsync_time_sleep (nsync_time_ms (2));
-		}
-		if (rlock_acquires == 1 && nsync_time_cmp (nsync_time_now (), deadline) > 0) {
-			rlock_acquires = 0; /* hog thread timed out */
-		}
-		if (rlock_acquires < expected_lo) {
-			TEST_ERROR (t, ("expected at least %d acquisitions via "
-				   "nsync_mu_rlock(), got %d\n",
-				   expected_lo, rlock_acquires));
-		}
-	}
-
-	nsync_mu_lock (&sd.mu);
-	sd.cancel = 1; /* Tell threads to exit. */
-	nsync_mu_unlock (&sd.mu);
-
-	nsync_mu_lock (&sd.control_mu);
-	nsync_mu_wait (&sd.control_mu, &done, &sd, NULL); /* wait for exit. */
-	nsync_mu_unlock (&sd.control_mu);
-}
-
-int main (int argc, char *argv[]) {
-	testing_base tb = testing_new (argc, argv, 0);
-	TEST_RUN (tb, test_starve_with_readers);
-	TEST_RUN (tb, test_starve_with_writer);
-	return (testing_base_exit (tb));
-}
diff --git a/third_party/nsync/testing/mu_starvation_test_.c b/third_party/nsync/testing/mu_starvation_test_.c
new file mode 100644
index 000000000..a84e31af9
--- /dev/null
+++ b/third_party/nsync/testing/mu_starvation_test_.c
@@ -0,0 +1,346 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/str/str.h"
+#include "libc/thread/thread.h"
+#include "third_party/nsync/mu.h"
+#include "third_party/nsync/mu_wait.h"
+#include "third_party/nsync/testing/closure.h"
+#include "third_party/nsync/testing/smprintf.h"
+#include "third_party/nsync/testing/testing.h"
+#include "third_party/nsync/testing/time_extra.h"
+#include "third_party/nsync/time.h"
+
+/* Test the behaviour of mu in situations where starvation might be expected. */
+
+/* starve_data is the data used by the starvation tests */
+typedef struct starve_data_s {
+	nsync_mu mu; /* precedes control_mu in locking order */
+	int cancel;     /* whether threads should shutdown; under mu */
+	nsync_time start;  /* when test started */
+
+	nsync_mu control_mu;
+	int not_yet_started; /* threads not yet started; under control_mu */
+	int not_yet_done; /* threads not yet done; under control_mu */
+} starve_data;
+
+/* initialize *sd */
+static void starve_data_init (starve_data *sd, int threads) {
+	bzero ((void *) sd, sizeof (*sd));
+	sd->not_yet_started = threads;
+	sd->not_yet_done = threads;
+	sd->start = nsync_time_now (NSYNC_CLOCK);
+}
+
+/* Loop until *cancel or deadline, and on each iteration
+   acquire *mu in reader mode, and hold it until the next odd or even
+   multiple of period, according to parity.  Just before return, decrement *done
+   under *mu.  Two threads using these calls are used to hold the
+   mutex continually, in the absence of other activity. */
+static void starve_with_readers (starve_data *sd, nsync_time period,
+				 uint32_t parity, nsync_time deadline) {
+	nsync_time now;
+	uint32_t period_us = (uint32_t) (nsync_time_to_dbl (period) * 1e6);
+	nsync_mu_rlock (&sd->mu);
+
+	nsync_mu_lock (&sd->control_mu);
+	sd->not_yet_started--;
+	nsync_mu_unlock (&sd->control_mu);
+
+	for (now = nsync_time_now (NSYNC_CLOCK);
+	     !sd->cancel && nsync_time_cmp (now, deadline) < 0;
+	     now = nsync_time_now (NSYNC_CLOCK)) {
+		uint32_t new_us;
+		uint32_t now_us = (uint32_t) (nsync_time_to_dbl (nsync_time_sub (now, sd->start)) * 1e6);
+		uint32_t index = (now_us + period_us - 1) / period_us;
+		if ((index & 1) != parity) {
+			index++;
+		}
+		new_us = index * period_us;
+		nsync_time_sleep (NSYNC_CLOCK, nsync_time_from_dbl (1e-6 * (double) (new_us-now_us)));
+		nsync_mu_runlock (&sd->mu);
+		nsync_mu_rlock (&sd->mu);
+	}
+	nsync_mu_runlock (&sd->mu);
+
+	nsync_mu_lock (&sd->control_mu);
+	sd->not_yet_done--;
+	nsync_mu_unlock (&sd->control_mu);
+}
+
+CLOSURE_DECL_BODY4 (starve_with_readers, starve_data *, nsync_time, uint32_t, nsync_time)
+
+static int started (const void *v) {
+	return (((const starve_data *) v)->not_yet_started == 0);
+}
+
+static int done (const void *v) {
+	return (((const starve_data *) v)->not_yet_done == 0);
+}
+
+/* Verify the behaviour of nsync_mu in the face of reader threads that conspire
+   keep the lock held continuously in reader mode, even though each of the
+   threads releases and reacquires periodically (while another thread holds the
+   lock).  The routine starve_with_readers() is used to achieve this effect.
+
+   We expect that nsync_mu_trylock() will not be able to acquire while this is
+   happening, but that nsync_mu_lock() will be able to acquire, due to the action of the
+   mu's mu_writer_waiting bit. */
+static void test_starve_with_readers (testing t) {
+	nsync_time finish;
+	int trylock_acquires;
+	int expected_lo;
+	int lock_acquires;
+
+	nsync_time deadline;
+
+	starve_data sd;
+	starve_data_init (&sd, 2); /* two threads, started below */
+
+	/* Threads run for at most 10s. */
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (10000));
+
+	/* These two threads will try to hold a reader lock
+	   continuously until cancel is set or deadline is reached,
+	   even though each will release the lock every 20ms. */
+	closure_fork (closure_starve_with_readers (
+		&starve_with_readers, &sd, nsync_time_ms (10), 0, deadline));
+	closure_fork (closure_starve_with_readers (
+		&starve_with_readers, &sd, nsync_time_ms (10), 1, deadline));
+
+	/* wait for the threads to acquire their first lock. */
+	nsync_mu_lock (&sd.control_mu);
+	nsync_mu_wait (&sd.control_mu, &started, &sd, NULL);
+	nsync_mu_unlock (&sd.control_mu);
+
+	/* If using an nsync_mu, use nsync_mu_trylock() to attempt to acquire while the
+	   readers are hogging the lock.  We expect no acquisitions to succeed. */
+	finish = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (500));
+	trylock_acquires = 0; /* number of acquires */
+	while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), finish) < 0) {
+		if (nsync_mu_trylock (&sd.mu)) {
+			trylock_acquires++;
+			nsync_mu_unlock (&sd.mu);
+		}
+		pthread_yield ();
+	}
+	if (trylock_acquires != 0) {
+		TEST_ERROR (t, ("expected no acquisitions via nsync_mu_trylock(), got %d\n",
+			   trylock_acquires));
+	}
+
+	/* Use nsync_mu_lock() to attempt to acquire while the readers are hogging
+	   the lock.  We expect several acquisitions to succeed. */
+	expected_lo = 2;
+	finish = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (5000));
+	lock_acquires = 0; /* number of acquires */
+	while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), finish) < 0 && lock_acquires < expected_lo) {
+		nsync_mu_lock (&sd.mu);
+		lock_acquires++;
+		nsync_mu_unlock (&sd.mu);
+		nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (1));
+	}
+	if (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), deadline) > 0 && lock_acquires == 1) {
+		lock_acquires = 0; /* hog threads timed out */
+	}
+	if (lock_acquires < expected_lo) {
+		TEST_ERROR (t, ("expected at least %d acquisitions via nsync_mu_lock(), got %d\n",
+			   expected_lo, lock_acquires));
+	}
+
+	nsync_mu_lock (&sd.mu);
+	sd.cancel = 1; /* Tell threads to exit. */
+	nsync_mu_unlock (&sd.mu);
+
+	nsync_mu_lock (&sd.control_mu);
+	nsync_mu_wait (&sd.control_mu, &done, &sd, NULL); /* wait for exit. */
+	nsync_mu_unlock (&sd.control_mu);
+}
+
+/* Loop until sd.cancel or deadline.  On each iteration<
+   acquire sd.mu in writer mode, sleep for hold_time, and release sd.mu.
+   Just before return, decrement sd.not_yet_done under sd.control_mu. */
+static void starve_with_writer (starve_data *sd, nsync_time hold_time,
+			        nsync_time deadline) {
+	nsync_time now;
+
+	nsync_mu_lock (&sd->mu);
+
+	nsync_mu_lock (&sd->control_mu);
+	sd->not_yet_started--;
+	nsync_mu_unlock (&sd->control_mu);
+
+	for (now = nsync_time_now (NSYNC_CLOCK);
+	     !sd->cancel && nsync_time_cmp (now, deadline) < 0;
+	     now = nsync_time_now (NSYNC_CLOCK)) {
+		nsync_time_sleep (NSYNC_CLOCK, hold_time);
+		nsync_mu_unlock (&sd->mu);
+		nsync_mu_lock (&sd->mu);
+	}
+	nsync_mu_unlock (&sd->mu);
+
+	nsync_mu_lock (&sd->control_mu);
+	sd->not_yet_done--;
+	nsync_mu_unlock (&sd->control_mu);
+}
+
+CLOSURE_DECL_BODY3 (starve_with_writer, starve_data *, nsync_time, nsync_time)
+
+/* Verify the behaviour of nsync_mu in the face of a
+   single writer thread that repeatedly hogs the lock by acquiring it and
+   holding it for longer than the runtime's wakeup time, then releasing.  The
+   next iteration reacquires the lock moments later, a time much shorter than
+   the runtime's wakeup time.  The routine starve_with_writer() is used to
+   achieve this effect.
+
+   These circumstances can make it hard for another thread T to acquire.  T
+   will first wait on the mutex's queue.  Eventually, it will be woken by the
+   hog thread, but under normal circumstances T will take so long to run that
+   the hog will have reacquired the mutex.  Because the hog keeps the lock for
+   longer than the runtime's wakeup time, T will go back to sleep again, and
+   the process repeats indefinitely.
+
+   We expect that incessant attempts via nsync_mu_trylock() and nsync_mu_rtrylock() will
+   occasionally manage to hit the moments when the lock is not held.  nsync_mu_lock()
+   and nsync_mu_rlock() will succeed only because of the action of mu's mu_long_wait bit,
+   which will eventually force the hog to wait itself, and allow a waiter
+   to acquire.  We expect few acquires because mu_long_wait kicks in only
+   when things look dire. */
+static void test_starve_with_writer (testing t) {
+	int expected_lo;
+	nsync_time finish;
+	int lock_acquires;
+	int rlock_acquires;
+	int trylock_acquires;
+	int rtrylock_acquires;
+	nsync_time deadline;
+	starve_data sd;
+	starve_data_init (&sd, 1); /* one thread, started below */
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (25000)); /* runs for at most 25s. */
+
+	/* This thread will try to hold a writer lock almost
+	   continuously, releasing momentarily every 10ms. */
+	closure_fork (closure_starve_with_writer (&starve_with_writer, &sd,
+						  nsync_time_ms (10), deadline));
+
+	nsync_mu_lock (&sd.control_mu);
+	nsync_mu_wait (&sd.control_mu, &started, &sd, NULL);
+	nsync_mu_unlock (&sd.control_mu);
+
+	expected_lo = 0;   /* minimum expected operations at each test */
+	finish = nsync_time_zero; /* finish time for each test */
+
+	if (!testing_is_uniprocessor (t)) {  /* this test won't work on a uniprocessor */
+		/* Use nsync_mu_trylock() to attempt to acquire while the writer is hogging the
+		   lock.  We expect some acquisitions to succeed. */
+		expected_lo = 1;
+		finish = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (30000));
+		trylock_acquires = 0; /* number of acquires */
+		while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), finish) < 0 && trylock_acquires < expected_lo) {
+			if (nsync_mu_trylock (&sd.mu)) {
+				trylock_acquires++;
+				nsync_mu_unlock (&sd.mu);
+			}
+			pthread_yield ();
+		}
+		if (trylock_acquires < expected_lo) {
+			TEST_ERROR (t, ("expected at least %d acquisitions via "
+				   "nsync_mu_trylock(), got %d\n",
+				   expected_lo, trylock_acquires));
+		}
+	}
+
+	if (!testing_is_uniprocessor (t)) {  /* this test won't work on a uniprocessor */
+		/* Use nsync_mu_rtrylock() to attempt to read-acquire while the writer is
+		   hogging the lock.  We expect some acquisitions to succeed. */
+		expected_lo = 1;
+		finish = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (30000));
+		rtrylock_acquires = 0; /* number of acquires */
+		while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), finish) < 0 && rtrylock_acquires < expected_lo) {
+			if (nsync_mu_rtrylock (&sd.mu)) {
+				rtrylock_acquires++;
+				nsync_mu_runlock (&sd.mu);
+			}
+			pthread_yield ();
+		}
+		if (rtrylock_acquires < expected_lo) {
+			TEST_ERROR (t, ("expected at least %d acquisitions via "
+				   "nsync_mu_rtrylock(), got %d\n",
+				   expected_lo, rtrylock_acquires));
+		}
+	}
+
+	/* Use nsync_mu_lock() to attempt to acquire while the writer is hogging
+	   the lock.  We expect several acquisitions to succeed. */
+	expected_lo = 2;
+	finish = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (5000));
+	lock_acquires = 0; /* number of acquires */
+	while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), finish) < 0 && lock_acquires < expected_lo) {
+		nsync_mu_lock (&sd.mu);
+		lock_acquires++;
+		nsync_mu_unlock (&sd.mu);
+		nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (2));
+	}
+	if (lock_acquires == 1 && nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), deadline) > 0) {
+		lock_acquires = 0; /* hog thread timed out */
+	}
+	if (lock_acquires < expected_lo) {
+		TEST_ERROR (t, ("expected at least %d acquisitions via nsync_mu_lock(), got %d\n",
+			   expected_lo, lock_acquires));
+	}
+
+	/* If enough time remains to run the test, use nsync_mu_rlock() to attempt to
+	   acquire while the writer is hogging the lock.  We expect several
+	   acquisitions to succeed.  It's ok not to run the test if we ran out
+	   time----it means that a writer couldn't break in (the test case
+	   above failed), so a reader is unlikely to manage it either. */
+	expected_lo = 2;
+	finish = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (5000));
+	rlock_acquires = 0; /* number of acquires */
+	if (nsync_time_cmp (finish, deadline) < 0) {
+		while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), finish) < 0 && rlock_acquires < expected_lo) {
+			nsync_mu_rlock (&sd.mu);
+			rlock_acquires++;
+			nsync_mu_runlock (&sd.mu);
+			nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (2));
+		}
+		if (rlock_acquires == 1 && nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), deadline) > 0) {
+			rlock_acquires = 0; /* hog thread timed out */
+		}
+		if (rlock_acquires < expected_lo) {
+			TEST_ERROR (t, ("expected at least %d acquisitions via "
+				   "nsync_mu_rlock(), got %d\n",
+				   expected_lo, rlock_acquires));
+		}
+	}
+
+	nsync_mu_lock (&sd.mu);
+	sd.cancel = 1; /* Tell threads to exit. */
+	nsync_mu_unlock (&sd.mu);
+
+	nsync_mu_lock (&sd.control_mu);
+	nsync_mu_wait (&sd.control_mu, &done, &sd, NULL); /* wait for exit. */
+	nsync_mu_unlock (&sd.control_mu);
+}
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+	TEST_RUN (tb, test_starve_with_readers);
+	TEST_RUN (tb, test_starve_with_writer);
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/mu_test.c b/third_party/nsync/testing/mu_test.c
index 5229e6957..fb4713f31 100644
--- a/third_party/nsync/testing/mu_test.c
+++ b/third_party/nsync/testing/mu_test.c
@@ -15,1056 +15,23 @@
 │ See the License for the specific language governing permissions and          │
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "third_party/nsync/mu.h"
-#include "libc/calls/calls.h"
-#include "libc/str/str.h"
-#include "libc/thread/thread.h"
-#include "third_party/nsync/cv.h"
-#include "third_party/nsync/mu_wait.h"
-#include "third_party/nsync/testing/closure.h"
-#include "third_party/nsync/testing/smprintf.h"
-#include "third_party/nsync/testing/testing.h"
-#include "third_party/nsync/testing/time_extra.h"
-
-/* The state shared between the threads in each of the tests below. */
-typedef struct test_data_s {
-	testing t;
-	int n_threads;  /* Number of test threads; constant after init. */
-	int loop_count; /* Iteration count for each test thread; constant after init */
-	
-	/* mu_in_use protects i, id, loop_count, and finished_threads. */
-	void *mu_in_use; /* points at mu, mutex, or rwmutex depending on which is in use. */
-	void (*lock) (void *);  /* operations on mu_in_use */
-	void (*unlock) (void *);
-	
-	nsync_mu mu;
-	pthread_mutex_t mutex;
-	pthread_rwlock_t rwmutex;
-	
-	int i; /* counter incremented by test loops. */
-	volatile int id; /* id of current lock-holding thread in some tests. */
-	
-	nsync_cv done; /* Signalled when finished_threads==n_threads. */
-	int finished_threads;      /* Count of threads that have finished. */
-} test_data;
-
-/* Indicate that a thread has finished its operations on test_data
-   by incrementing td.finished_threads, and signal td.done when it reaches td.n_threads.
-   See test_data_wait_for_all_threads(). */
-static void test_data_thread_finished (test_data *td) {
-	(*td->lock) (td->mu_in_use);
-	td->finished_threads++;
-	if (td->finished_threads == td->n_threads) {
-		nsync_cv_broadcast (&td->done);
-	}
-	(*td->unlock) (td->mu_in_use);
-}
-
-/* Wait until all td.n_threads have called test_data_thread_finished(),
-   and then return. */
-static void test_data_wait_for_all_threads (test_data *td) {
-	(*td->lock) (td->mu_in_use);
-	while (td->finished_threads != td->n_threads) {
-		nsync_cv_wait_with_deadline_generic (&td->done, td->mu_in_use,
-						     td->lock, td->unlock,
-						     nsync_time_no_deadline, NULL);
-	}
-	(*td->unlock) (td->mu_in_use);
-}
-
-/* --------------------------------------- */
-
-/* The body of each thread executed by test_mu_nthread()
-   and test_mutex_nthread.
-   *td represents the test data that the threads share, and id is an integer
-   unique to each test thread. */
-static void counting_loop (test_data *td, int id) {
-	int n = td->loop_count;
-	int i = 0;
-	for (i = 0; i != n; i++) {
-		(*td->lock) (td->mu_in_use);
-		td->id = id;
-		td->i++;
-		if (td->id != id) {
-			testing_panic ("td->id != id");
-		}
-		(*td->unlock) (td->mu_in_use);
-	}
-	test_data_thread_finished (td);
-}
-
-CLOSURE_DECL_BODY2 (counting, test_data *, int)
-
-/* Versions of nsync_mu_lock() and nsync_mu_unlock() that take "void *"
-   arguments, to avoid call through a function pointer of a different type,
-   which is undefined.  */
-static void void_mu_lock (void *mu) {
-	nsync_mu_lock ((nsync_mu *) mu);
-}
-static void void_mu_unlock (void *mu) {
-	nsync_mu_unlock((nsync_mu *) mu);
-}
-
-/* Create a few threads, each of which increments an
-   integer a fixed number of times, using an nsync_mu for mutual exclusion.
-   It checks that the integer is incremented the correct number of times. */
-static void test_mu_nthread (testing t) {
-	int loop_count = 100000;
-	nsync_time deadline;
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (1500));
-	do {
-		int i;
-		test_data td;
-		bzero ((void *) &td, sizeof (td));
-		td.t = t;
-		td.n_threads = 5;
-		td.loop_count = loop_count;
-		td.mu_in_use = &td.mu;
-		td.lock = &void_mu_lock;
-		td.unlock = &void_mu_unlock;
-		for (i = 0; i != td.n_threads; i++) {
-			closure_fork (closure_counting (&counting_loop, &td, i));
-		}
-		test_data_wait_for_all_threads (&td);
-		if (td.i != td.n_threads*td.loop_count) {
-			TEST_FATAL (t, ("test_mu_nthread final count inconsistent: want %d, got %d",
-				   td.n_threads*td.loop_count, td.i));
-		}
-		loop_count *= 2;
-	} while (nsync_time_cmp (nsync_time_now (), deadline) < 0);
-}
-
-/* void pthread_mutex_lock */
-static void void_pthread_mutex_lock (void *mu) {
-        pthread_mutex_lock ((pthread_mutex_t *) mu);
-}
-
-/* void pthread_mutex_unlock */
-static void void_pthread_mutex_unlock (void *mu) {
-        pthread_mutex_unlock ((pthread_mutex_t *) mu);
-}
-
-/* Create a few threads, each of which increments an
-   integer a fixed number of times, using a pthread_mutex_t for mutual exclusion.
-   It checks that the integer is incremented the correct number of times. */
-static void test_mutex_nthread (testing t) {
-	int loop_count = 100000;
-	nsync_time deadline;
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (1500));
-	do {
-		int i;
-		test_data td;
-		bzero ((void *) &td, sizeof (td));
-		td.t = t;
-		td.n_threads = 5;
-		td.loop_count = loop_count;
-		td.mu_in_use = &td.mutex;
-		td.lock = &void_pthread_mutex_lock;
-		td.unlock = &void_pthread_mutex_unlock;
-		pthread_mutex_init (&td.mutex, NULL);
-		for (i = 0; i != td.n_threads; i++) {
-			closure_fork (closure_counting (&counting_loop, &td, i));
-		}
-		test_data_wait_for_all_threads (&td);
-		if (td.i != td.n_threads*td.loop_count) {
-			TEST_FATAL (t, ("test_mutex_nthread final count inconsistent: want %d, got %d",
-				   td.n_threads*td.loop_count, td.i));
-		}
-		pthread_mutex_destroy (&td.mutex);
-		loop_count *= 2;
-	} while (nsync_time_cmp (nsync_time_now (), deadline) < 0);
-}
-
-/* void pthread_rwlock_wrlock */
-static void void_pthread_rwlock_wrlock (void *mu) {
-        pthread_rwlock_wrlock ((pthread_rwlock_t *) mu);
-}
-
-/* void pthread_rwlock_unlock */
-static void void_pthread_rwlock_unlock (void *mu) {
-        pthread_rwlock_unlock ((pthread_rwlock_t *) mu);
-}
-
-/* Create a few threads, each of which increments an
-   integer a fixed number of times, using a pthread_rwlock_t for mutual exclusion.
-   It checks that the integer is incremented the correct number of times. */
-static void test_rwmutex_nthread (testing t) {
-	int loop_count = 100000;
-	nsync_time deadline;
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (1500));
-	do {
-		int i;
-		test_data td;
-		bzero ((void *) &td, sizeof (td));
-		td.t = t;
-		td.n_threads = 5;
-		td.loop_count = loop_count;
-		td.mu_in_use = &td.rwmutex;
-		td.lock = &void_pthread_rwlock_wrlock;
-		td.unlock = &void_pthread_rwlock_unlock;
-		pthread_rwlock_init (&td.rwmutex, NULL);
-		for (i = 0; i != td.n_threads; i++) {
-			closure_fork (closure_counting (&counting_loop, &td, i));
-		}
-		test_data_wait_for_all_threads (&td);
-		if (td.i != td.n_threads*td.loop_count) {
-			TEST_FATAL (t, ("test_mutex_nthread final count inconsistent: want %d, got %d",
-				   td.n_threads*td.loop_count, td.i));
-		}
-		pthread_rwlock_destroy (&td.rwmutex);
-		loop_count *= 2;
-	} while (nsync_time_cmp (nsync_time_now (), deadline) < 0);
-}
-
-/* --------------------------------------- */
-
-/* The body of each thread executed by test_try_mu_nthread().
-   *td represents the test data that the threads share, and id is an integer
-   unique to each test thread. */
-static void counting_loop_try_mu (test_data *td, int id) {
-	int i;
-	int n = td->loop_count;
-	for (i = 0; i != n; i++) {
-		while (!nsync_mu_trylock (&td->mu)) {
-			pthread_yield ();
-		}
-		td->id = id;
-		td->i++;
-		if (td->id != id) {
-			testing_panic ("td->id != id");
-		}
-		n = td->loop_count;
-		nsync_mu_unlock (&td->mu);
-	}
-	test_data_thread_finished (td);
-}
-
-/* Test that acquiring an nsync_mu with nsync_mu_trylock()
-   using several threads provides mutual exclusion. */
-static void test_try_mu_nthread (testing t) {
-	int loop_count = 100000;
-	nsync_time deadline;
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (1500));
-	do {
-		int i;
-		test_data td;
-		bzero ((void *) &td, sizeof (td));
-		td.t = t;
-		td.n_threads = 5;
-		td.loop_count = loop_count;
-		td.mu_in_use = &td.mu;
-		td.lock = &void_mu_lock;
-		td.unlock = &void_mu_unlock;
-		for (i = 0; i != td.n_threads; i++) {
-			closure_fork (closure_counting (&counting_loop_try_mu, &td, i));
-		}
-		test_data_wait_for_all_threads (&td);
-		if (td.i != td.n_threads*td.loop_count) {
-			TEST_FATAL (t, ("test_try_mu_nthread final count inconsistent: want %d, got %d",
-				   td.n_threads*td.loop_count, td.i));
-		}
-		loop_count *= 2;
-	} while (nsync_time_cmp (nsync_time_now (), deadline) < 0);
-}
-
-/* --------------------------------------- */
-
-/* An integer protected by a mutex, and with an associated
-   condition variable that is signalled when the counter reaches 0. */
-typedef struct counter_s {
-	nsync_mu mu; /* protects value */
-	int value;
-	nsync_cv cv; /* signalled when value becomes 0 */
-} counter;
-
-/* Return a counter with initial value "initial". */
-static counter *counter_new (int initial) {
-	counter *c = (counter *) malloc (sizeof (*c));
-	bzero ((void *) c, sizeof (*c));
-	c->value = initial;
-	return (c);
-}
-
-/* Increment *c by "increment". */
-static void counter_inc (counter *c, int increment) {
-	if (increment != 0) {
-		nsync_mu_lock (&c->mu);
-		c->value += increment;
-		if (c->value == 0) {
-			nsync_cv_broadcast (&c->cv);
-		}
-		nsync_mu_unlock (&c->mu);
-	}
-}
-
-/* Wait on *c's condition variable until the counter
-   becomes 0, or abs_deadline is reached. */
-static int counter_wait_for_zero_with_deadline (counter *c, nsync_time abs_deadline) {
-	int value;
-	nsync_mu_rlock (&c->mu);
-	while (c->value != 0 &&
-	       nsync_cv_wait_with_deadline (&c->cv, &c->mu, abs_deadline, NULL) == 0) {
-	}
-	value = c->value;
-	nsync_mu_runlock (&c->mu);
-	return (value);
-}
-
-/* Wait on *c's condition variable until the counter becomes 0. */
-static void counter_wait_for_zero (counter *c) {
-	int value = counter_wait_for_zero_with_deadline (c, nsync_time_no_deadline);
-	if (value != 0) {
-		testing_panic (smprintf ("wait_for_zero() about to return with "
-					 "non-zero value %d", value));
-	}
-}
-
-/* Return the current value of *c. */
-static int counter_value (counter *c) {
-	int value;
-	nsync_mu_rlock (&c->mu);
-	value = c->value;
-	nsync_mu_runlock (&c->mu);
-	return (value);
-}
-
-/* --------------------------------------- */
-
-CLOSURE_DECL_BODY9 (attempt_trylock, testing , const char *, int, nsync_mu *,
-		    int, int, int *, int, counter *)
-
-/* Call nsync_mu_trylock(), and compares the result to expected_acquire.
-   If the lock was acquired, then:
-   - if expected_value != -1, compare *value against expected_value.
-   - increment *value.
-   - if release is non-zero, release the lock before returning.
-   In any case, the counter *done is decremented. */
-static void attempt_trylock (testing t, const char *id, int verbose,
-			     nsync_mu *mu, int expected_acquire, int release,
-			     int *value, int expected_value, counter *done) {
-	int acquired = nsync_mu_trylock (mu);
-	if (acquired != expected_acquire) {
-		testing_panic (smprintf ("attempt_trylock %s:  expected "
-					 "nsync_mu_trylock() to return %d but got %d",
-					 id, expected_acquire, acquired));
-	}
-	if (verbose) {
-		TEST_LOG (t, ("attempt_trylock %s %d\n", id, acquired));
-	}
-	if (acquired) {
-		nsync_mu_assert_held (mu);
-		if (expected_value != -1 && *value != expected_value) {
-			testing_panic (smprintf ("attempt_trylock %s expected "
-						 "value %d, *value=%d",
-						 id, expected_value, *value));
-		}
-		(*value)++;
-		if (verbose) {
-			TEST_LOG (t, ("attempt_trylock %s incremented value to %d\n", id, *value));
-		}
-		if (release) {
-			nsync_mu_unlock (mu);
-		}
-	}
-	counter_inc (done, -1);
-}
-
-/* Call nsync_mu_rtrylock(), and compare the result to expected_acquire.
-   If the lock was acquired, then:
-   - if expected_value != -1, compare *value against expected_value.
-   - if release is non-zero, release the lock before returning.
-   In any case, decrement *done. */
-static void attempt_rtrylock (testing t, const char *id, int verbose,
-			      nsync_mu *mu, int expected_acquire, int release,
-			      int *value, int expected_value, counter *done) {
-	int acquired = nsync_mu_rtrylock (mu);
-	if (acquired != expected_acquire) {
-		testing_panic (smprintf ("attempt_rtrylock %s: expected "
-					 "nsync_mu_rtrylock() to return %d but got %d",
-					 id, expected_acquire, acquired));
-	}
-	if (verbose) {
-		TEST_LOG (t, ("attempt_rtrylock %s %d\n", id, acquired));
-	}
-	if (acquired) {
-		nsync_mu_rassert_held (mu);
-		if (expected_value != -1 && *value != expected_value) {
-			testing_panic (smprintf ("attempt_rtrylock %s expected "
-						 "value %d, *value=%d",
-						 id, expected_value, *value));
-		}
-		if (release) {
-			nsync_mu_runlock (mu);
-		}
-	}
-	counter_inc (done, -1);
-}
-
-CLOSURE_DECL_BODY9 (lock_unlock, testing, const char *, int, nsync_mu *,
-		    int *, int, nsync_time, counter *, counter *)
-
-/* First acquire *mu, then:
-   - if expected_value != -1, compare *value against expected_value.
-   - increment *value.
-   - sleep for "sleep".
-   Then release *mu and decrement *done. */
-static void lock_unlock (testing t, const char *id, int verbose, nsync_mu *mu, int *value,
-		  int expected_value, nsync_time sleep, counter *sleeping, counter *done) {
-	if (verbose) {
-		TEST_LOG (t, ("lock_unlock %s\n", id));
-	}
-	if (sleeping != NULL) {
-		counter_inc (sleeping, -1);
-	}
-	nsync_mu_lock (mu);
-	nsync_mu_assert_held (mu);
-	if (expected_value != -1 && *value != expected_value) {
-		testing_panic (smprintf ("lock_unlock %s expected "
-					 "value %d, *value=%d",
-					 id, expected_value, *value));
-	}
-	(*value)++;
-	if (verbose) {
-		TEST_LOG (t, ("lock_unlock %s incremented value to %d\n", id, *value));
-	}
-	nsync_time_sleep (sleep);
-	nsync_mu_unlock (mu);
-	counter_inc (done, -1);
-}
-
-/* First acquire *mu in read mode, then:
-   - if expected_value != -1, compare *value against expected_value.
-   - sleep for "sleep".
-   Then release *mu and decrement *done. */
-static void rlock_runlock (testing t, const char *id, int verbose, nsync_mu *mu,
-			   int *value, int expected_value, nsync_time sleep,
-			   counter *sleeping, counter *done) {
-	if (verbose) {
-		TEST_LOG (t, ("rlock_runlock %s\n", id));
-	}
-	if (sleeping != NULL) {
-		counter_inc (sleeping, -1);
-	}
-	nsync_mu_rlock (mu);
-	nsync_mu_rassert_held (mu);
-	if (expected_value != -1 && *value != expected_value) {
-		testing_panic (smprintf ("rlock_runlock %s expected "
-					 "value %d, *value=%d", id, expected_value, *value));
-	}
-	nsync_time_sleep (sleep);
-	nsync_mu_runlock (mu);
-	counter_inc (done, -1);
-}
-
-/* Check that the time since start_time is between expected_duration-1ms.
-   If the time exceeds expected_duration+slop_duration, return 1, else 0. */
-static int check_times (testing t, const char *id, nsync_time start_time,
-			nsync_time expected_duration, nsync_time slop_duration) {
-	int exceeds_count = 0;
-	nsync_time now;
-	nsync_time measured_duration;
-	now = nsync_time_now ();
-	measured_duration = nsync_time_sub (now, start_time);
-	if (nsync_time_cmp (measured_duration,
-			    nsync_time_sub (expected_duration, nsync_time_ms (5))) < 0) {
-		char *m_str = nsync_time_str (measured_duration, 2);
-		char *e_str = nsync_time_str (expected_duration, 2);
-		TEST_ERROR (t, ("check_times %s too short a delay: %s instead of %s",
-			   id, m_str, e_str));
-		free (m_str);
-		free (e_str);
-	}
-	if (nsync_time_cmp (nsync_time_add (expected_duration, slop_duration), measured_duration) < 0) {
-		exceeds_count++;
-	}
-	return (exceeds_count);
-}
-
-/* Check the operation of nsync_mu as a reader/writer lock. */
-static void test_rlock (testing t) {
-	int loop;
-	int i;
-	int max_write_wait_exceeded;
-	int max_read_wait_exceeded;
-	nsync_time time_unit;
-	nsync_time slop_duration;
-	nsync_time delay_duration;
-	nsync_time writer_duration;
-	nsync_time reader_duration;
-	static const int loop_count = 5;
-	static const int read_threads = 3;
-	static const int limit = 3;
-	static const int verbose = 0;
-	max_write_wait_exceeded = 0;
-	max_read_wait_exceeded = 0;
-
-	time_unit = nsync_time_ms (100);
-	slop_duration = nsync_time_add (nsync_time_add (time_unit, time_unit), time_unit);
-	delay_duration = time_unit;
-	writer_duration = time_unit;
-	reader_duration = nsync_time_add (time_unit, time_unit);
-
-	max_write_wait_exceeded = 0;
-	max_read_wait_exceeded = 0;
-	for (loop = 0; loop != loop_count; loop++) {
-		counter *lock_unlock_sleeping;
-		counter *rlock_runlock_sleeping;
-		counter *lock_unlock_done;
-		counter *rlock_runlock_done;
-		nsync_time read_start_time;
-		nsync_mu mu;
-		int value = 0;
-		counter *thread_done;
-
-		nsync_time start_time;
-		nsync_mu_init (&mu);
-		start_time = nsync_time_now ();
-
-		/* ------------------------------------ */
-		/* Acquire lock with nsync_mu_rtrylock().  This thread will
-		   hold a read lock until the next line with =====.  */
-		thread_done = counter_new (1);
-		attempt_rtrylock (t, "a", verbose, &mu, 1, 0, &value, 0, thread_done);
-		counter_wait_for_zero (thread_done);
-
-		nsync_mu_rassert_held (&mu);
-
-		counter_inc (thread_done, 1);
-		/* Can get read lock holding read lock. */
-		closure_fork (closure_attempt_trylock (&attempt_rtrylock,
-			t, "b", verbose, &mu, 1, 1, &value, 0, thread_done));
-		counter_wait_for_zero (thread_done);
-
-		nsync_mu_rassert_held (&mu);
-
-		counter_inc (thread_done, 1);
-		/* Can't get write lock holding read lock. */
-		closure_fork (closure_attempt_trylock (&attempt_trylock, t, "c", verbose,
-						       &mu, 0, 1, &value, -1, thread_done));
-		counter_wait_for_zero (thread_done);
-
-		if (!nsync_mu_is_reader (&mu)) {
-			TEST_FATAL(t, ("expected mu held in reader mode"));
-		}
-
-		counter_inc (thread_done, 1);
-		closure_fork (closure_lock_unlock (&rlock_runlock, t, "d", verbose,
-						   &mu, &value, 0, nsync_time_zero /*no delay*/,
-						   NULL, thread_done));
-		counter_wait_for_zero (thread_done);
-
-		nsync_mu_rassert_held (&mu);
-
-		lock_unlock_done = counter_new (1);
-		lock_unlock_sleeping = counter_new (1);
-		closure_fork (closure_lock_unlock (&lock_unlock, t, "e", verbose,
-						   &mu, &value, 0, writer_duration,
-						   lock_unlock_sleeping, lock_unlock_done));
-
-		counter_wait_for_zero (lock_unlock_sleeping);
-		nsync_time_sleep (delay_duration); /* give time for lock_unlock() thread to wait. */
-
-		nsync_mu_rassert_held (&mu);
-
-		rlock_runlock_done = counter_new (read_threads);
-		rlock_runlock_sleeping = counter_new (read_threads);
-		for (i = 0; i != read_threads; i++) {
-			/* read lock will be acquired after lock_unlock() completes */
-			closure_fork (closure_lock_unlock (&rlock_runlock, t, "f", verbose,
-							   &mu, &value, 1, reader_duration,
-							   rlock_runlock_sleeping,
-							   rlock_runlock_done));
-		}
-
-		nsync_mu_rassert_held (&mu);
-
-		counter_wait_for_zero (rlock_runlock_sleeping);
-		nsync_time_sleep (delay_duration); /* time for rlock_runlock() threads to wait. */
-
-		nsync_mu_rassert_held (&mu);
-
-		if (counter_value (lock_unlock_done) == 0) {
-			TEST_FATAL (t, ("thread was able to acquire write lock while read lock held"));
-		}
-		if (counter_value (rlock_runlock_done) == 0) {
-			TEST_FATAL (t, ("thread was able to acquire read lock with "
-				   "other reader and waiting writer"));
-		}
-
-		nsync_mu_rassert_held (&mu);
-
-		counter_inc (thread_done, 1);
-	       /* Still can't get write lock. */
-		closure_fork (closure_attempt_trylock (&attempt_trylock, t, "g", verbose,
-						       &mu, 0, 1, &value, -1, thread_done));
-		counter_wait_for_zero (thread_done);
-
-		counter_inc (thread_done, 1);
-		/* Now can't get read lock because a writer is waiting. */
-		closure_fork (closure_attempt_trylock (&attempt_rtrylock, t, "h", verbose,
-						       &mu, 0, 1, &value, -1, thread_done));
-		counter_wait_for_zero (thread_done);
-
-		nsync_mu_runlock (&mu);
-		/* ==================================== */
-
-		read_start_time = nsync_time_now ();
-		counter_wait_for_zero (lock_unlock_done); /* Now can get write lock. */
-		max_write_wait_exceeded += check_times (t, "i", start_time,
-			nsync_time_add (nsync_time_add (delay_duration, delay_duration), writer_duration),
-			slop_duration);
-
-		counter_wait_for_zero (rlock_runlock_done); /* And now an get read lock again. */
-		max_read_wait_exceeded += check_times (t, "j", read_start_time,
-						       reader_duration, slop_duration);
-
-		free (thread_done);
-		free (lock_unlock_done);
-		free (rlock_runlock_done);
-		free (lock_unlock_sleeping);
-		free (rlock_runlock_sleeping);
-	}
-	if (verbose) {
-		TEST_LOG (t, ("read lock max_write_wait_exceeded %d max_read_wait_exceeded %d\n",
-			 max_write_wait_exceeded, max_read_wait_exceeded));
-	}
-	if (max_write_wait_exceeded > limit) {
-		TEST_ERROR (t, ("lock_unlock() took too long %d "
-			   "(more than %d) times out of %d",
-			   max_write_wait_exceeded, limit, loop_count));
-	}
-	if (max_read_wait_exceeded > limit) {
-		TEST_ERROR (t, ("rlock_runlock() took too long %d "
-			   "(more than %d) times out of %d",
-			   max_read_wait_exceeded, limit, loop_count));
-	}
-
-	max_write_wait_exceeded = 0;
-	max_read_wait_exceeded = 0;
-	for (loop = 0; loop != loop_count; loop++) {
-		counter *lock_unlock_sleeping;
-		counter *rlock_runlock_sleeping;
-		counter *lock_unlock_done;
-		counter *rlock_runlock_done;
-		nsync_time read_start_time;
-		nsync_mu mu;
-		int value = 0;
-		counter *thread_done;
-
-		nsync_time start_time;
-
-		nsync_mu_init (&mu);
-		start_time = nsync_time_now ();
-
-		/* ------------------------------------ */
-		/* Acquire lock with nsync_mu_trylock().  This thread will hold
-		   a write lock until the next line with =====.  */
-		thread_done = counter_new (1);
-		attempt_trylock (t, "A", verbose, &mu, 1, 0, &value, 0, thread_done);
-		counter_wait_for_zero (thread_done);
-
-		nsync_mu_assert_held (&mu);
-		nsync_mu_rassert_held (&mu);
-
-		counter_inc (thread_done, 1);
-		/* Can't get read lock while holding write lock. */
-		closure_fork (closure_attempt_trylock (&attempt_rtrylock, t, "B", verbose,
-						       &mu, 0, 1, &value, -1, thread_done));
-		counter_wait_for_zero (thread_done);
-
-		if (nsync_mu_is_reader (&mu)) {
-			TEST_FATAL (t, ("expected mu held in write mode"));
-		}
-		nsync_mu_assert_held (&mu);
-		nsync_mu_rassert_held (&mu);
-
-		counter_inc (thread_done, 1);
-		/* Can't get write lock while holding write lock. */
-		closure_fork (closure_attempt_trylock (&attempt_trylock, t, "C", verbose,
-						       &mu, 0, 1, &value, -1, thread_done));
-		counter_wait_for_zero (thread_done);
-
-		nsync_mu_assert_held (&mu);
-		nsync_mu_rassert_held (&mu);
-
-		lock_unlock_done = counter_new (1);
-		lock_unlock_sleeping = counter_new (1);
-		closure_fork (closure_lock_unlock (&lock_unlock, t, "D", verbose,
-						   &mu, &value, 1, writer_duration,
-						   lock_unlock_sleeping, lock_unlock_done));
-
-		counter_wait_for_zero (lock_unlock_sleeping);
-		nsync_time_sleep (delay_duration); /* give time for lock_unlock() thread to wait. */
-
-		nsync_mu_assert_held (&mu);
-		nsync_mu_rassert_held (&mu);
-
-		rlock_runlock_done = counter_new (read_threads);
-		rlock_runlock_sleeping = counter_new (read_threads);
-		for (i = 0; i != read_threads; i++) {
-			/* not guaranteed will complete after lock_unlock() above */
-			closure_fork (closure_lock_unlock (&rlock_runlock, t, "E", verbose,
-							   &mu, &value, -1, reader_duration,
-							   rlock_runlock_sleeping,
-							   rlock_runlock_done));
-		}
-
-		nsync_mu_assert_held (&mu);
-		nsync_mu_rassert_held (&mu);
-
-		counter_wait_for_zero (rlock_runlock_sleeping);
-		nsync_time_sleep (delay_duration); /* time for rlock_runlock() threads to wait. */
-
-		nsync_mu_assert_held (&mu);
-		nsync_mu_rassert_held (&mu);
-
-		if (counter_value (lock_unlock_done) == 0) {
-			TEST_FATAL (t, ("thread was able to acquire write lock "
-				   "while other write lock held"));
-		}
-		if (counter_value (rlock_runlock_done) == 0) {
-			TEST_FATAL (t, ("thread was able to acquire read lock "
-				   "while  write lock held"));
-		}
-
-		nsync_mu_assert_held (&mu);
-		nsync_mu_rassert_held (&mu);
-
-		counter_inc (thread_done, 1);
-		/* Still can't get read lock while holding write lock. */
-		closure_fork (closure_attempt_trylock (&attempt_rtrylock, t, "F", verbose,
-						       &mu, 0, 1, &value, -1, thread_done));
-		counter_wait_for_zero (thread_done);
-
-		nsync_mu_assert_held (&mu);
-		nsync_mu_rassert_held (&mu);
-
-		counter_inc (thread_done, 1);
-		/* Still can't get write lock while holding write lock. */
-		closure_fork (closure_attempt_trylock (&attempt_trylock, t, "G", verbose,
-						       &mu, 0, 1, &value, -1, thread_done));
-		counter_wait_for_zero (thread_done);
-
-		nsync_mu_assert_held (&mu);
-		nsync_mu_rassert_held (&mu);
-
-		nsync_mu_unlock (&mu);
-		/* ==================================== */
-
-		read_start_time = nsync_time_now ();
-		counter_wait_for_zero (lock_unlock_done); /* Now can get write lock. */
-		max_write_wait_exceeded += check_times (t, "H", start_time,
-			nsync_time_add (nsync_time_add (delay_duration, delay_duration), writer_duration),
-			slop_duration);
-
-		counter_wait_for_zero (rlock_runlock_done); /* And now can get read lock again. */
-		max_read_wait_exceeded += check_times (t, "I", read_start_time,
-						       reader_duration, slop_duration);
-
-		free (thread_done);
-		free (lock_unlock_done);
-		free (rlock_runlock_done);
-		free (lock_unlock_sleeping);
-		free (rlock_runlock_sleeping);
-	}
-	if (verbose) {
-		TEST_LOG (t, ("write lock max_write_wait_exceeded %d "
-			 "max_read_wait_exceeded %d\n",
-			 max_write_wait_exceeded, max_read_wait_exceeded));
-	}
-	if (max_write_wait_exceeded > limit) {
-		TEST_ERROR (t, ("lock_unlock() took too long %d (more than %d) "
-			   "times out of %d",
-			   max_write_wait_exceeded, limit, loop_count));
-	}
-	if (max_read_wait_exceeded > limit) {
-		TEST_ERROR (t, ("rlock_runlock() took too long %d (more than %d) "
-			   "times out of %d",
-			   max_read_wait_exceeded, limit, loop_count));
-	}
-}
-
-/* --------------------------------------- */
-
-/* Measure the performance of an uncontended nsync_mu. */
-static void benchmark_mu_uncontended (testing t) {
-	int i;
-	int n = testing_n (t);
-	nsync_mu mu;
-	nsync_mu_init (&mu);
-	for (i = 0; i != n; i++) {
-		nsync_mu_lock (&mu);
-		nsync_mu_unlock (&mu);
-	}
-}
-
-/* Return whether int *value is one. */
-static int int_is_1 (const void *value) { return (*(const int *)value == 1); }
-
-/* Return whether int *value is two. */
-static int int_is_2 (const void *value) { return (*(const int *)value == 2); }
-
-/* Return whether int *value is three. */
-static int int_is_3 (const void *value) { return (*(const int *)value == 3); }
-
-/* Set *value to 1, wait for it to become 2, then set it to 3.  *value is under
-   *mu */
-static void waiter (nsync_mu *mu, int *value) {
-	nsync_mu_lock (mu);
-	*value = 1;
-	nsync_mu_wait (mu, &int_is_2, value, NULL);
-	*value = 3;
-	nsync_mu_unlock (mu);
-}
-
-CLOSURE_DECL_BODY2 (waiter, nsync_mu *, int *)
-
-/* Measure the performance of an uncontended nsync_mu
-   with a blocked waiter. */
-static void benchmark_mu_uncontended_waiter (testing t) {
-	int i;
-	int n = testing_n (t);
-	nsync_mu mu;
-	int value = 0;
-	nsync_mu_init (&mu);
-	closure_fork (closure_waiter (&waiter, &mu, &value));
-	nsync_mu_lock (&mu);
-	nsync_mu_wait (&mu, &int_is_1, &value, NULL);
-	nsync_mu_unlock (&mu);
-	for (i = 0; i != n; i++) {
-		nsync_mu_lock (&mu);
-		nsync_mu_unlock (&mu);
-	}
-	nsync_mu_lock (&mu);
-	value = 2;
-	nsync_mu_wait (&mu, &int_is_3, &value, NULL);
-	nsync_mu_unlock (&mu);
-}
-
-/* Measure the performance of an uncontended nsync_mu
-   with a blocked waiter using nsync_mu_unlock_without_wakeup. */
-static void benchmark_mu_uncontended_no_wakeup (testing t) {
-	int i;
-	int n = testing_n (t);
-	nsync_mu mu;
-	int value = 0;
-	nsync_mu_init (&mu);
-	closure_fork (closure_waiter (&waiter, &mu, &value));
-	nsync_mu_lock (&mu);
-	nsync_mu_wait (&mu, &int_is_1, &value, NULL);
-	nsync_mu_unlock (&mu);
-	for (i = 0; i != n; i++) {
-		nsync_mu_lock (&mu);
-		nsync_mu_unlock_without_wakeup (&mu);
-	}
-	nsync_mu_lock (&mu);
-	value = 2;
-	nsync_mu_wait (&mu, &int_is_3, &value, NULL);
-	nsync_mu_unlock (&mu);
-}
-
-/* Measure the performance of an uncontended
-   nsync_mu in read mode. */
-static void benchmark_rmu_uncontended (testing t) {
-	int i;
-	int n = testing_n (t);
-	nsync_mu mu;
-	nsync_mu_init (&mu);
-	for (i = 0; i != n; i++) {
-		nsync_mu_rlock (&mu);
-		nsync_mu_runlock (&mu);
-	}
-}
-
-/* Measure the performance of an uncontended nsync_mu
-   in read mode with a blocked waiter. */
-static void benchmark_rmu_uncontended_waiter (testing t) {
-	int i;
-	int n = testing_n (t);
-	nsync_mu mu;
-	int value = 0;
-	nsync_mu_init (&mu);
-	closure_fork (closure_waiter (&waiter, &mu, &value));
-	nsync_mu_lock (&mu);
-	nsync_mu_wait (&mu, &int_is_1, &value, NULL);
-	nsync_mu_unlock (&mu);
-	for (i = 0; i != n; i++) {
-		nsync_mu_rlock (&mu);
-		nsync_mu_runlock (&mu);
-	}
-	nsync_mu_lock (&mu);
-	value = 2;
-	nsync_mu_wait (&mu, &int_is_3, &value, NULL);
-	nsync_mu_unlock (&mu);
-}
-
-/* Measure the performance of an uncontended pthread_mutex_t. */
-static void benchmark_mutex_uncontended (testing t) {
-	int i;
-	int n = testing_n (t);
-	pthread_mutex_t mu;
-	pthread_mutex_init (&mu, NULL);
-	for (i = 0; i != n; i++) {
-		pthread_mutex_lock (&mu);
-		pthread_mutex_unlock (&mu);
-	}
-	pthread_mutex_destroy (&mu);
-}
-
-/* Measure the performance of an uncontended pthread_rwlock_t. */
-static void benchmark_wmutex_uncontended (testing t) {
-	int i;
-	int n = testing_n (t);
-	pthread_rwlock_t mu;
-	pthread_rwlock_init (&mu, NULL);
-	for (i = 0; i != n; i++) {
-		pthread_rwlock_wrlock (&mu);
-		pthread_rwlock_unlock (&mu);
-	}
-	pthread_rwlock_destroy (&mu);
-}
-
-/* Measure the performance of an uncontended
-   pthread_rwlock_t in read mode. */
-static void benchmark_rmutex_uncontended (testing t) {
-	int i;
-	int n = testing_n (t);
-	pthread_rwlock_t mu;
-	pthread_rwlock_init (&mu, NULL);
-	for (i = 0; i != n; i++) {
-		pthread_rwlock_rdlock (&mu);
-		pthread_rwlock_unlock (&mu);
-	}
-	pthread_rwlock_destroy (&mu);
-}
-
-/* ---------------------------------------
-   Benchmarks for contended locks. */
-
-/* It's hard to write these as benchmark functions, since we wish to measure
-   throughput over an extended period (a second or two), rather than get the
-   latency of a few iterations. */
-
-/* A contended_state represents state shared between threads
-   in the contended benchmarks. */
-typedef struct contended_state_s {
-	testing t;
-
-	/* locks to test */
-	nsync_mu mu;
-	pthread_mutex_t mutex;
-	pthread_rwlock_t rwmutex;
-	int count; /* counter protected by a lock above */
-	
-	nsync_mu start_done_mu;
-	int start; /* whether threads should start, under start_done_mu */
-	int not_yet_done;  /* threads not yet complete, under start_done_mu */
-} contended_state;
-
-static int contended_state_may_start (const void *v) {
-	return (((const contended_state *)v)->start);
-}
-
-static int contended_state_all_done (const void *v) {
-	return (((const contended_state *)v)->not_yet_done == 0);
-}
-
-/* Wait for cs.start to become non-zero, then loop, acquiring and
-   releasing mu on each iteration until cs.deadline is reached, then decrement
-   cs.not_yet_done. */
-static void contended_state_contend_loop (contended_state *cs,
-					  void *mu, void (*lock) (void *),
-					  void (*unlock) (void *)) {
-	int n = testing_n (cs->t);
-	int j;
-	int i;
-	nsync_mu_rlock (&cs->start_done_mu);
-	nsync_mu_wait (&cs->start_done_mu, &contended_state_may_start, cs, NULL);
-	nsync_mu_runlock (&cs->start_done_mu);
-
-	for (j = 0; j < n; j += 10000) {
-		for (i = 0; i != 10000; i++) {
-			(*lock) (mu);
-			cs->count++;
-			(*unlock) (mu);
-		}
-	}
-
-	nsync_mu_lock (&cs->start_done_mu);
-	cs->not_yet_done--;
-	nsync_mu_unlock (&cs->start_done_mu);
-}
-
-typedef void (*func_any) (void *);
-CLOSURE_DECL_BODY4 (contended_state_contend_loop, contended_state *, void *, func_any, func_any)
-
-/* Start the threads in a contended test, wait for them to finish,
-   and print the number of iterations achieved. */
-static void contended_state_run_test (contended_state *cs, testing t,
-				      void *mu, void (*lock) (void *),
-				      void (*unlock) (void *)) {
-	int i;
-	cs->t = t;
-	cs->not_yet_done = 4; /* number of threads */
-	cs->start = 0;
-	cs->count = 0;
-	for (i = 0; i != cs->not_yet_done; i++) {
-		closure_fork (closure_contended_state_contend_loop (
-			&contended_state_contend_loop, cs, mu, lock, unlock));
-	}
-	nsync_mu_lock (&cs->start_done_mu);
-	cs->start = 1;
-	nsync_mu_wait (&cs->start_done_mu, &contended_state_all_done, cs, NULL);
-	nsync_mu_unlock (&cs->start_done_mu);
-}
-
-/* Measure the performance of highly contended
-   nsync_mu locks, with small critical sections.  */
-static void benchmark_mu_contended (testing t) {
-	contended_state cs;
-	bzero ((void *) &cs, sizeof (cs));
-	contended_state_run_test (&cs, t, &cs.mu, (void (*) (void*))&nsync_mu_lock,
-				  (void (*) (void*))&nsync_mu_unlock);
-}
-
-/* Measure the performance of highly contended
-   pthread_mutex_t locks, with small critical sections.  */
-static void benchmark_mutex_contended (testing t) {
-	contended_state cs;
-	bzero ((void *) &cs, sizeof (cs));
-	pthread_mutex_init (&cs.mutex, NULL);
-	contended_state_run_test (&cs, t, &cs.mutex, &void_pthread_mutex_lock,
-				  &void_pthread_mutex_unlock);
-	pthread_mutex_destroy (&cs.mutex);
-}
-
-/* Measure the performance of highly contended
-   pthread_rwlock_t locks, with small critical sections.  */
-static void benchmark_wmutex_contended (testing t) {
-	contended_state cs;
-	bzero ((void *) &cs, sizeof (cs));
-	pthread_rwlock_init (&cs.rwmutex, NULL);
-	contended_state_run_test (&cs, t, &cs.rwmutex, &void_pthread_rwlock_wrlock,
-				  &void_pthread_rwlock_unlock);
-	pthread_rwlock_destroy (&cs.rwmutex);
-}
+#include "third_party/nsync/testing/mu_test.inc"
 
 int main (int argc, char *argv[]) {
 	testing_base tb = testing_new (argc, argv, 0);
 
 	TEST_RUN (tb, test_rlock);
 	TEST_RUN (tb, test_mu_nthread);
-	TEST_RUN (tb, test_mutex_nthread);
-	TEST_RUN (tb, test_rwmutex_nthread);
-	TEST_RUN (tb, test_try_mu_nthread);
 
 	BENCHMARK_RUN (tb, benchmark_mu_contended);
 	BENCHMARK_RUN (tb, benchmark_mutex_contended);
+	BENCHMARK_RUN (tb, benchmark_xmutex_contended);
 	BENCHMARK_RUN (tb, benchmark_wmutex_contended);
 
 	BENCHMARK_RUN (tb, benchmark_mu_uncontended);
 	BENCHMARK_RUN (tb, benchmark_rmu_uncontended);
 	BENCHMARK_RUN (tb, benchmark_mutex_uncontended);
+	BENCHMARK_RUN (tb, benchmark_xmutex_uncontended);
 	BENCHMARK_RUN (tb, benchmark_wmutex_uncontended);
 	BENCHMARK_RUN (tb, benchmark_rmutex_uncontended);
 	BENCHMARK_RUN (tb, benchmark_mu_uncontended_waiter);
diff --git a/third_party/nsync/testing/mu_test.inc b/third_party/nsync/testing/mu_test.inc
new file mode 100644
index 000000000..086520f2c
--- /dev/null
+++ b/third_party/nsync/testing/mu_test.inc
@@ -0,0 +1,1119 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/mu.h"
+#include "libc/calls/calls.h"
+#include "libc/str/str.h"
+#include "libc/thread/thread.h"
+#include "third_party/nsync/time.h"
+#include "third_party/nsync/cv.h"
+#include "third_party/nsync/mu_wait.h"
+#include "third_party/nsync/testing/closure.h"
+#include "third_party/nsync/testing/smprintf.h"
+#include "third_party/nsync/testing/testing.h"
+#include "third_party/nsync/testing/time_extra.h"
+
+/* The state shared between the threads in each of the tests below. */
+typedef struct test_data_s {
+	testing t;
+	int n_threads;  /* Number of test threads; constant after init. */
+	int loop_count; /* Iteration count for each test thread; constant after init */
+	
+	/* mu_in_use protects i, id, loop_count, and finished_threads. */
+	void *mu_in_use; /* points at mu, mutex, or rwmutex depending on which is in use. */
+	void (*lock) (void *);  /* operations on mu_in_use */
+	void (*unlock) (void *);
+	
+	nsync_mu mu;
+	pthread_mutex_t mutex;
+	pthread_rwlock_t rwmutex;
+	
+	int i; /* counter incremented by test loops. */
+	volatile int id; /* id of current lock-holding thread in some tests. */
+	
+	nsync_cv done; /* Signalled when finished_threads==n_threads. */
+	int finished_threads;      /* Count of threads that have finished. */
+} test_data;
+
+/* Indicate that a thread has finished its operations on test_data
+   by incrementing td.finished_threads, and signal td.done when it reaches td.n_threads.
+   See test_data_wait_for_all_threads(). */
+static void test_data_thread_finished (test_data *td) {
+	(*td->lock) (td->mu_in_use);
+	td->finished_threads++;
+	if (td->finished_threads == td->n_threads) {
+		nsync_cv_broadcast (&td->done);
+	}
+	(*td->unlock) (td->mu_in_use);
+}
+
+/* Wait until all td.n_threads have called test_data_thread_finished(),
+   and then return. */
+static void test_data_wait_for_all_threads (test_data *td) {
+	(*td->lock) (td->mu_in_use);
+	while (td->finished_threads != td->n_threads) {
+		nsync_cv_wait_with_deadline_generic (&td->done, td->mu_in_use,
+						     td->lock, td->unlock,
+						     NSYNC_CLOCK,
+						     nsync_time_no_deadline, NULL);
+	}
+	(*td->unlock) (td->mu_in_use);
+}
+
+/* --------------------------------------- */
+
+/* The body of each thread executed by test_mu_nthread()
+   and test_mutex_nthread.
+   *td represents the test data that the threads share, and id is an integer
+   unique to each test thread. */
+static void counting_loop (test_data *td, int id) {
+	int n = td->loop_count;
+	int i = 0;
+	for (i = 0; i != n; i++) {
+		(*td->lock) (td->mu_in_use);
+		td->id = id;
+		td->i++;
+		if (td->id != id) {
+			testing_panic ("td->id != id");
+		}
+		(*td->unlock) (td->mu_in_use);
+	}
+	test_data_thread_finished (td);
+}
+
+CLOSURE_DECL_BODY2 (counting, test_data *, int)
+
+/* Versions of nsync_mu_lock() and nsync_mu_unlock() that take "void *"
+   arguments, to avoid call through a function pointer of a different type,
+   which is undefined.  */
+static void void_mu_lock (void *mu) {
+	nsync_mu_lock ((nsync_mu *) mu);
+}
+static void void_mu_unlock (void *mu) {
+	nsync_mu_unlock((nsync_mu *) mu);
+}
+
+/* Create a few threads, each of which increments an
+   integer a fixed number of times, using an nsync_mu for mutual exclusion.
+   It checks that the integer is incremented the correct number of times. */
+static void test_mu_nthread (testing t) {
+	int loop_count = 100000;
+	nsync_time deadline;
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1500));
+	do {
+		int i;
+		test_data td;
+		bzero ((void *) &td, sizeof (td));
+		td.t = t;
+		td.n_threads = 5;
+		td.loop_count = loop_count;
+		td.mu_in_use = &td.mu;
+		td.lock = &void_mu_lock;
+		td.unlock = &void_mu_unlock;
+		for (i = 0; i != td.n_threads; i++) {
+			closure_fork (closure_counting (&counting_loop, &td, i));
+		}
+		test_data_wait_for_all_threads (&td);
+		if (td.i != td.n_threads*td.loop_count) {
+			TEST_FATAL (t, ("test_mu_nthread final count inconsistent: want %d, got %d",
+				   td.n_threads*td.loop_count, td.i));
+		}
+		loop_count *= 2;
+	} while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), deadline) < 0);
+}
+
+/* void pthread_mutex_lock */
+static void void_pthread_mutex_lock (void *mu) {
+        pthread_mutex_lock ((pthread_mutex_t *) mu);
+}
+
+/* void pthread_mutex_unlock */
+static void void_pthread_mutex_unlock (void *mu) {
+        pthread_mutex_unlock ((pthread_mutex_t *) mu);
+}
+
+/* Create a few threads, each of which increments an
+   integer a fixed number of times, using a pthread_mutex_t for mutual exclusion.
+   It checks that the integer is incremented the correct number of times. */
+static void test_mutex_nthread (testing t) {
+	int loop_count = 100000;
+	nsync_time deadline;
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1500));
+	do {
+		int i;
+		test_data td;
+		bzero ((void *) &td, sizeof (td));
+		td.t = t;
+		td.n_threads = 5;
+		td.loop_count = loop_count;
+		td.mu_in_use = &td.mutex;
+		td.lock = &void_pthread_mutex_lock;
+		td.unlock = &void_pthread_mutex_unlock;
+		pthread_mutex_init (&td.mutex, NULL);
+		for (i = 0; i != td.n_threads; i++) {
+			closure_fork (closure_counting (&counting_loop, &td, i));
+		}
+		test_data_wait_for_all_threads (&td);
+		if (td.i != td.n_threads*td.loop_count) {
+			TEST_FATAL (t, ("test_mutex_nthread final count inconsistent: want %d, got %d",
+				   td.n_threads*td.loop_count, td.i));
+		}
+		pthread_mutex_destroy (&td.mutex);
+		loop_count *= 2;
+	} while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), deadline) < 0);
+}
+
+/* Create a few threads, each of which increments an integer a fixed
+   number of times, using a recursive pthread_mutex_t for mutual exclusion.
+   It checks that the integer is incremented the correct number of times. */
+static void test_xmutex_nthread (testing t) {
+	int loop_count = 100000;
+	nsync_time deadline;
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1500));
+	do {
+		int i;
+		test_data td;
+		pthread_mutexattr_t attr;
+		bzero ((void *) &td, sizeof (td));
+		td.t = t;
+		td.n_threads = 5;
+		td.loop_count = loop_count;
+		td.mu_in_use = &td.mutex;
+		td.lock = &void_pthread_mutex_lock;
+		td.unlock = &void_pthread_mutex_unlock;
+		pthread_mutexattr_init (&attr);
+		pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
+		pthread_mutex_init (&td.mutex, &attr);
+		pthread_mutexattr_destroy (&attr);
+		for (i = 0; i != td.n_threads; i++) {
+			closure_fork (closure_counting (&counting_loop, &td, i));
+		}
+		test_data_wait_for_all_threads (&td);
+		if (td.i != td.n_threads*td.loop_count) {
+			TEST_FATAL (t, ("test_mutex_nthread final count inconsistent: want %d, got %d",
+				   td.n_threads*td.loop_count, td.i));
+		}
+		pthread_mutex_destroy (&td.mutex);
+		loop_count *= 2;
+	} while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), deadline) < 0);
+}
+
+/* void pthread_rwlock_wrlock */
+static void void_pthread_rwlock_wrlock (void *mu) {
+        pthread_rwlock_wrlock ((pthread_rwlock_t *) mu);
+}
+
+/* void pthread_rwlock_unlock */
+static void void_pthread_rwlock_unlock (void *mu) {
+        pthread_rwlock_unlock ((pthread_rwlock_t *) mu);
+}
+
+/* Create a few threads, each of which increments an
+   integer a fixed number of times, using a pthread_rwlock_t for mutual exclusion.
+   It checks that the integer is incremented the correct number of times. */
+static void test_rwmutex_nthread (testing t) {
+	int loop_count = 100000;
+	nsync_time deadline;
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1500));
+	do {
+		int i;
+		test_data td;
+		bzero ((void *) &td, sizeof (td));
+		td.t = t;
+		td.n_threads = 5;
+		td.loop_count = loop_count;
+		td.mu_in_use = &td.rwmutex;
+		td.lock = &void_pthread_rwlock_wrlock;
+		td.unlock = &void_pthread_rwlock_unlock;
+		pthread_rwlock_init (&td.rwmutex, NULL);
+		for (i = 0; i != td.n_threads; i++) {
+			closure_fork (closure_counting (&counting_loop, &td, i));
+		}
+		test_data_wait_for_all_threads (&td);
+		if (td.i != td.n_threads*td.loop_count) {
+			TEST_FATAL (t, ("test_mutex_nthread final count inconsistent: want %d, got %d",
+				   td.n_threads*td.loop_count, td.i));
+		}
+		pthread_rwlock_destroy (&td.rwmutex);
+		loop_count *= 2;
+	} while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), deadline) < 0);
+}
+
+/* --------------------------------------- */
+
+/* The body of each thread executed by test_try_mu_nthread().
+   *td represents the test data that the threads share, and id is an integer
+   unique to each test thread. */
+static void counting_loop_try_mu (test_data *td, int id) {
+	int i;
+	int n = td->loop_count;
+	for (i = 0; i != n; i++) {
+		while (!nsync_mu_trylock (&td->mu)) {
+			pthread_yield ();
+		}
+		td->id = id;
+		td->i++;
+		if (td->id != id) {
+			testing_panic ("td->id != id");
+		}
+		n = td->loop_count;
+		nsync_mu_unlock (&td->mu);
+	}
+	test_data_thread_finished (td);
+}
+
+/* Test that acquiring an nsync_mu with nsync_mu_trylock()
+   using several threads provides mutual exclusion. */
+static void test_try_mu_nthread (testing t) {
+	int loop_count = 100000;
+	nsync_time deadline;
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1500));
+	do {
+		int i;
+		test_data td;
+		bzero ((void *) &td, sizeof (td));
+		td.t = t;
+		td.n_threads = 5;
+		td.loop_count = loop_count;
+		td.mu_in_use = &td.mu;
+		td.lock = &void_mu_lock;
+		td.unlock = &void_mu_unlock;
+		for (i = 0; i != td.n_threads; i++) {
+			closure_fork (closure_counting (&counting_loop_try_mu, &td, i));
+		}
+		test_data_wait_for_all_threads (&td);
+		if (td.i != td.n_threads*td.loop_count) {
+			TEST_FATAL (t, ("test_try_mu_nthread final count inconsistent: want %d, got %d",
+				   td.n_threads*td.loop_count, td.i));
+		}
+		loop_count *= 2;
+	} while (nsync_time_cmp (nsync_time_now (NSYNC_CLOCK), deadline) < 0);
+}
+
+/* --------------------------------------- */
+
+/* An integer protected by a mutex, and with an associated
+   condition variable that is signalled when the counter reaches 0. */
+typedef struct counter_s {
+	nsync_mu mu; /* protects value */
+	int value;
+	nsync_cv cv; /* signalled when value becomes 0 */
+} counter;
+
+/* Return a counter with initial value "initial". */
+static counter *counter_new (int initial) {
+	counter *c = (counter *) malloc (sizeof (*c));
+	bzero ((void *) c, sizeof (*c));
+	c->value = initial;
+	return (c);
+}
+
+/* Increment *c by "increment". */
+static void counter_inc (counter *c, int increment) {
+	if (increment != 0) {
+		nsync_mu_lock (&c->mu);
+		c->value += increment;
+		if (c->value == 0) {
+			nsync_cv_broadcast (&c->cv);
+		}
+		nsync_mu_unlock (&c->mu);
+	}
+}
+
+/* Wait on *c's condition variable until the counter
+   becomes 0, or abs_deadline is reached. */
+static int counter_wait_for_zero_with_deadline (counter *c, nsync_time abs_deadline) {
+	int value;
+	nsync_mu_rlock (&c->mu);
+	while (c->value != 0 &&
+	       nsync_cv_wait_with_deadline (&c->cv, &c->mu, NSYNC_CLOCK, abs_deadline, NULL) == 0) {
+	}
+	value = c->value;
+	nsync_mu_runlock (&c->mu);
+	return (value);
+}
+
+/* Wait on *c's condition variable until the counter becomes 0. */
+static void counter_wait_for_zero (counter *c) {
+	int value = counter_wait_for_zero_with_deadline (c, nsync_time_no_deadline);
+	if (value != 0) {
+		testing_panic (smprintf ("wait_for_zero() about to return with "
+					 "non-zero value %d", value));
+	}
+}
+
+/* Return the current value of *c. */
+static int counter_value (counter *c) {
+	int value;
+	nsync_mu_rlock (&c->mu);
+	value = c->value;
+	nsync_mu_runlock (&c->mu);
+	return (value);
+}
+
+/* --------------------------------------- */
+
+CLOSURE_DECL_BODY9 (attempt_trylock, testing , const char *, int, nsync_mu *,
+		    int, int, int *, int, counter *)
+
+/* Call nsync_mu_trylock(), and compares the result to expected_acquire.
+   If the lock was acquired, then:
+   - if expected_value != -1, compare *value against expected_value.
+   - increment *value.
+   - if release is non-zero, release the lock before returning.
+   In any case, the counter *done is decremented. */
+static void attempt_trylock (testing t, const char *id, int verbose,
+			     nsync_mu *mu, int expected_acquire, int release,
+			     int *value, int expected_value, counter *done) {
+	int acquired = nsync_mu_trylock (mu);
+	if (acquired != expected_acquire) {
+		testing_panic (smprintf ("attempt_trylock %s:  expected "
+					 "nsync_mu_trylock() to return %d but got %d",
+					 id, expected_acquire, acquired));
+	}
+	if (verbose) {
+		TEST_LOG (t, ("attempt_trylock %s %d\n", id, acquired));
+	}
+	if (acquired) {
+		nsync_mu_assert_held (mu);
+		if (expected_value != -1 && *value != expected_value) {
+			testing_panic (smprintf ("attempt_trylock %s expected "
+						 "value %d, *value=%d",
+						 id, expected_value, *value));
+		}
+		(*value)++;
+		if (verbose) {
+			TEST_LOG (t, ("attempt_trylock %s incremented value to %d\n", id, *value));
+		}
+		if (release) {
+			nsync_mu_unlock (mu);
+		}
+	}
+	counter_inc (done, -1);
+}
+
+/* Call nsync_mu_rtrylock(), and compare the result to expected_acquire.
+   If the lock was acquired, then:
+   - if expected_value != -1, compare *value against expected_value.
+   - if release is non-zero, release the lock before returning.
+   In any case, decrement *done. */
+static void attempt_rtrylock (testing t, const char *id, int verbose,
+			      nsync_mu *mu, int expected_acquire, int release,
+			      int *value, int expected_value, counter *done) {
+	int acquired = nsync_mu_rtrylock (mu);
+	if (acquired != expected_acquire) {
+		testing_panic (smprintf ("attempt_rtrylock %s: expected "
+					 "nsync_mu_rtrylock() to return %d but got %d",
+					 id, expected_acquire, acquired));
+	}
+	if (verbose) {
+		TEST_LOG (t, ("attempt_rtrylock %s %d\n", id, acquired));
+	}
+	if (acquired) {
+		nsync_mu_rassert_held (mu);
+		if (expected_value != -1 && *value != expected_value) {
+			testing_panic (smprintf ("attempt_rtrylock %s expected "
+						 "value %d, *value=%d",
+						 id, expected_value, *value));
+		}
+		if (release) {
+			nsync_mu_runlock (mu);
+		}
+	}
+	counter_inc (done, -1);
+}
+
+CLOSURE_DECL_BODY9 (lock_unlock, testing, const char *, int, nsync_mu *,
+		    int *, int, nsync_time, counter *, counter *)
+
+/* First acquire *mu, then:
+   - if expected_value != -1, compare *value against expected_value.
+   - increment *value.
+   - sleep for "sleep".
+   Then release *mu and decrement *done. */
+static void lock_unlock (testing t, const char *id, int verbose, nsync_mu *mu, int *value,
+		  int expected_value, nsync_time sleep, counter *sleeping, counter *done) {
+	if (verbose) {
+		TEST_LOG (t, ("lock_unlock %s\n", id));
+	}
+	if (sleeping != NULL) {
+		counter_inc (sleeping, -1);
+	}
+	nsync_mu_lock (mu);
+	nsync_mu_assert_held (mu);
+	if (expected_value != -1 && *value != expected_value) {
+		testing_panic (smprintf ("lock_unlock %s expected "
+					 "value %d, *value=%d",
+					 id, expected_value, *value));
+	}
+	(*value)++;
+	if (verbose) {
+		TEST_LOG (t, ("lock_unlock %s incremented value to %d\n", id, *value));
+	}
+	nsync_time_sleep (NSYNC_CLOCK, sleep);
+	nsync_mu_unlock (mu);
+	counter_inc (done, -1);
+}
+
+/* First acquire *mu in read mode, then:
+   - if expected_value != -1, compare *value against expected_value.
+   - sleep for "sleep".
+   Then release *mu and decrement *done. */
+static void rlock_runlock (testing t, const char *id, int verbose, nsync_mu *mu,
+			   int *value, int expected_value, nsync_time sleep,
+			   counter *sleeping, counter *done) {
+	if (verbose) {
+		TEST_LOG (t, ("rlock_runlock %s\n", id));
+	}
+	if (sleeping != NULL) {
+		counter_inc (sleeping, -1);
+	}
+	nsync_mu_rlock (mu);
+	nsync_mu_rassert_held (mu);
+	if (expected_value != -1 && *value != expected_value) {
+		testing_panic (smprintf ("rlock_runlock %s expected "
+					 "value %d, *value=%d", id, expected_value, *value));
+	}
+	nsync_time_sleep (NSYNC_CLOCK, sleep);
+	nsync_mu_runlock (mu);
+	counter_inc (done, -1);
+}
+
+/* Check that the time since start_time is between expected_duration-1ms.
+   If the time exceeds expected_duration+slop_duration, return 1, else 0. */
+static int check_times (testing t, const char *id, nsync_time start_time,
+			nsync_time expected_duration, nsync_time slop_duration) {
+	int exceeds_count = 0;
+	nsync_time now;
+	nsync_time measured_duration;
+	now = nsync_time_now (NSYNC_CLOCK);
+	measured_duration = nsync_time_sub (now, start_time);
+	if (nsync_time_cmp (measured_duration,
+			    nsync_time_sub (expected_duration, nsync_time_ms (5))) < 0) {
+		char *m_str = nsync_time_str (measured_duration, 2);
+		char *e_str = nsync_time_str (expected_duration, 2);
+		TEST_ERROR (t, ("check_times %s too short a delay: %s instead of %s",
+			   id, m_str, e_str));
+		free (m_str);
+		free (e_str);
+	}
+	if (nsync_time_cmp (nsync_time_add (expected_duration, slop_duration), measured_duration) < 0) {
+		exceeds_count++;
+	}
+	return (exceeds_count);
+}
+
+/* Check the operation of nsync_mu as a reader/writer lock. */
+static void test_rlock (testing t) {
+	int loop;
+	int i;
+	int max_write_wait_exceeded;
+	int max_read_wait_exceeded;
+	nsync_time time_unit;
+	nsync_time slop_duration;
+	nsync_time delay_duration;
+	nsync_time writer_duration;
+	nsync_time reader_duration;
+	static const int loop_count = 5;
+	static const int read_threads = 3;
+	static const int limit = 3;
+	static const int verbose = 0;
+	max_write_wait_exceeded = 0;
+	max_read_wait_exceeded = 0;
+
+	time_unit = nsync_time_ms (100);
+	slop_duration = nsync_time_add (nsync_time_add (time_unit, time_unit), time_unit);
+	delay_duration = time_unit;
+	writer_duration = time_unit;
+	reader_duration = nsync_time_add (time_unit, time_unit);
+
+	max_write_wait_exceeded = 0;
+	max_read_wait_exceeded = 0;
+	for (loop = 0; loop != loop_count; loop++) {
+		counter *lock_unlock_sleeping;
+		counter *rlock_runlock_sleeping;
+		counter *lock_unlock_done;
+		counter *rlock_runlock_done;
+		nsync_time read_start_time;
+		nsync_mu mu;
+		int value = 0;
+		counter *thread_done;
+
+		nsync_time start_time;
+		nsync_mu_init (&mu);
+		start_time = nsync_time_now (NSYNC_CLOCK);
+
+		/* ------------------------------------ */
+		/* Acquire lock with nsync_mu_rtrylock().  This thread will
+		   hold a read lock until the next line with =====.  */
+		thread_done = counter_new (1);
+		attempt_rtrylock (t, "a", verbose, &mu, 1, 0, &value, 0, thread_done);
+		counter_wait_for_zero (thread_done);
+
+		nsync_mu_rassert_held (&mu);
+
+		counter_inc (thread_done, 1);
+		/* Can get read lock holding read lock. */
+		closure_fork (closure_attempt_trylock (&attempt_rtrylock,
+			t, "b", verbose, &mu, 1, 1, &value, 0, thread_done));
+		counter_wait_for_zero (thread_done);
+
+		nsync_mu_rassert_held (&mu);
+
+		counter_inc (thread_done, 1);
+		/* Can't get write lock holding read lock. */
+		closure_fork (closure_attempt_trylock (&attempt_trylock, t, "c", verbose,
+						       &mu, 0, 1, &value, -1, thread_done));
+		counter_wait_for_zero (thread_done);
+
+		if (!nsync_mu_is_reader (&mu)) {
+			TEST_FATAL(t, ("expected mu held in reader mode"));
+		}
+
+		counter_inc (thread_done, 1);
+		closure_fork (closure_lock_unlock (&rlock_runlock, t, "d", verbose,
+						   &mu, &value, 0, nsync_time_zero /*no delay*/,
+						   NULL, thread_done));
+		counter_wait_for_zero (thread_done);
+
+		nsync_mu_rassert_held (&mu);
+
+		lock_unlock_done = counter_new (1);
+		lock_unlock_sleeping = counter_new (1);
+		closure_fork (closure_lock_unlock (&lock_unlock, t, "e", verbose,
+						   &mu, &value, 0, writer_duration,
+						   lock_unlock_sleeping, lock_unlock_done));
+
+		counter_wait_for_zero (lock_unlock_sleeping);
+		nsync_time_sleep (NSYNC_CLOCK, delay_duration); /* give time for lock_unlock() thread to wait. */
+
+		nsync_mu_rassert_held (&mu);
+
+		rlock_runlock_done = counter_new (read_threads);
+		rlock_runlock_sleeping = counter_new (read_threads);
+		for (i = 0; i != read_threads; i++) {
+			/* read lock will be acquired after lock_unlock() completes */
+			closure_fork (closure_lock_unlock (&rlock_runlock, t, "f", verbose,
+							   &mu, &value, 1, reader_duration,
+							   rlock_runlock_sleeping,
+							   rlock_runlock_done));
+		}
+
+		nsync_mu_rassert_held (&mu);
+
+		counter_wait_for_zero (rlock_runlock_sleeping);
+		nsync_time_sleep (NSYNC_CLOCK, delay_duration); /* time for rlock_runlock() threads to wait. */
+
+		nsync_mu_rassert_held (&mu);
+
+		if (counter_value (lock_unlock_done) == 0) {
+			TEST_FATAL (t, ("thread was able to acquire write lock while read lock held"));
+		}
+		if (counter_value (rlock_runlock_done) == 0) {
+			TEST_FATAL (t, ("thread was able to acquire read lock with "
+				   "other reader and waiting writer"));
+		}
+
+		nsync_mu_rassert_held (&mu);
+
+		counter_inc (thread_done, 1);
+	       /* Still can't get write lock. */
+		closure_fork (closure_attempt_trylock (&attempt_trylock, t, "g", verbose,
+						       &mu, 0, 1, &value, -1, thread_done));
+		counter_wait_for_zero (thread_done);
+
+		counter_inc (thread_done, 1);
+		/* Now can't get read lock because a writer is waiting. */
+		closure_fork (closure_attempt_trylock (&attempt_rtrylock, t, "h", verbose,
+						       &mu, 0, 1, &value, -1, thread_done));
+		counter_wait_for_zero (thread_done);
+
+		nsync_mu_runlock (&mu);
+		/* ==================================== */
+
+		read_start_time = nsync_time_now (NSYNC_CLOCK);
+		counter_wait_for_zero (lock_unlock_done); /* Now can get write lock. */
+		max_write_wait_exceeded += check_times (t, "i", start_time,
+			nsync_time_add (nsync_time_add (delay_duration, delay_duration), writer_duration),
+			slop_duration);
+
+		counter_wait_for_zero (rlock_runlock_done); /* And now an get read lock again. */
+		max_read_wait_exceeded += check_times (t, "j", read_start_time,
+						       reader_duration, slop_duration);
+
+		free (thread_done);
+		free (lock_unlock_done);
+		free (rlock_runlock_done);
+		free (lock_unlock_sleeping);
+		free (rlock_runlock_sleeping);
+	}
+	if (verbose) {
+		TEST_LOG (t, ("read lock max_write_wait_exceeded %d max_read_wait_exceeded %d\n",
+			 max_write_wait_exceeded, max_read_wait_exceeded));
+	}
+	if (max_write_wait_exceeded > limit) {
+		TEST_ERROR (t, ("lock_unlock() took too long %d "
+			   "(more than %d) times out of %d",
+			   max_write_wait_exceeded, limit, loop_count));
+	}
+	if (max_read_wait_exceeded > limit) {
+		TEST_ERROR (t, ("rlock_runlock() took too long %d "
+			   "(more than %d) times out of %d",
+			   max_read_wait_exceeded, limit, loop_count));
+	}
+
+	max_write_wait_exceeded = 0;
+	max_read_wait_exceeded = 0;
+	for (loop = 0; loop != loop_count; loop++) {
+		counter *lock_unlock_sleeping;
+		counter *rlock_runlock_sleeping;
+		counter *lock_unlock_done;
+		counter *rlock_runlock_done;
+		nsync_time read_start_time;
+		nsync_mu mu;
+		int value = 0;
+		counter *thread_done;
+
+		nsync_time start_time;
+
+		nsync_mu_init (&mu);
+		start_time = nsync_time_now (NSYNC_CLOCK);
+
+		/* ------------------------------------ */
+		/* Acquire lock with nsync_mu_trylock().  This thread will hold
+		   a write lock until the next line with =====.  */
+		thread_done = counter_new (1);
+		attempt_trylock (t, "A", verbose, &mu, 1, 0, &value, 0, thread_done);
+		counter_wait_for_zero (thread_done);
+
+		nsync_mu_assert_held (&mu);
+		nsync_mu_rassert_held (&mu);
+
+		counter_inc (thread_done, 1);
+		/* Can't get read lock while holding write lock. */
+		closure_fork (closure_attempt_trylock (&attempt_rtrylock, t, "B", verbose,
+						       &mu, 0, 1, &value, -1, thread_done));
+		counter_wait_for_zero (thread_done);
+
+		if (nsync_mu_is_reader (&mu)) {
+			TEST_FATAL (t, ("expected mu held in write mode"));
+		}
+		nsync_mu_assert_held (&mu);
+		nsync_mu_rassert_held (&mu);
+
+		counter_inc (thread_done, 1);
+		/* Can't get write lock while holding write lock. */
+		closure_fork (closure_attempt_trylock (&attempt_trylock, t, "C", verbose,
+						       &mu, 0, 1, &value, -1, thread_done));
+		counter_wait_for_zero (thread_done);
+
+		nsync_mu_assert_held (&mu);
+		nsync_mu_rassert_held (&mu);
+
+		lock_unlock_done = counter_new (1);
+		lock_unlock_sleeping = counter_new (1);
+		closure_fork (closure_lock_unlock (&lock_unlock, t, "D", verbose,
+						   &mu, &value, 1, writer_duration,
+						   lock_unlock_sleeping, lock_unlock_done));
+
+		counter_wait_for_zero (lock_unlock_sleeping);
+		nsync_time_sleep (NSYNC_CLOCK, delay_duration); /* give time for lock_unlock() thread to wait. */
+
+		nsync_mu_assert_held (&mu);
+		nsync_mu_rassert_held (&mu);
+
+		rlock_runlock_done = counter_new (read_threads);
+		rlock_runlock_sleeping = counter_new (read_threads);
+		for (i = 0; i != read_threads; i++) {
+			/* not guaranteed will complete after lock_unlock() above */
+			closure_fork (closure_lock_unlock (&rlock_runlock, t, "E", verbose,
+							   &mu, &value, -1, reader_duration,
+							   rlock_runlock_sleeping,
+							   rlock_runlock_done));
+		}
+
+		nsync_mu_assert_held (&mu);
+		nsync_mu_rassert_held (&mu);
+
+		counter_wait_for_zero (rlock_runlock_sleeping);
+		nsync_time_sleep (NSYNC_CLOCK, delay_duration); /* time for rlock_runlock() threads to wait. */
+
+		nsync_mu_assert_held (&mu);
+		nsync_mu_rassert_held (&mu);
+
+		if (counter_value (lock_unlock_done) == 0) {
+			TEST_FATAL (t, ("thread was able to acquire write lock "
+				   "while other write lock held"));
+		}
+		if (counter_value (rlock_runlock_done) == 0) {
+			TEST_FATAL (t, ("thread was able to acquire read lock "
+				   "while  write lock held"));
+		}
+
+		nsync_mu_assert_held (&mu);
+		nsync_mu_rassert_held (&mu);
+
+		counter_inc (thread_done, 1);
+		/* Still can't get read lock while holding write lock. */
+		closure_fork (closure_attempt_trylock (&attempt_rtrylock, t, "F", verbose,
+						       &mu, 0, 1, &value, -1, thread_done));
+		counter_wait_for_zero (thread_done);
+
+		nsync_mu_assert_held (&mu);
+		nsync_mu_rassert_held (&mu);
+
+		counter_inc (thread_done, 1);
+		/* Still can't get write lock while holding write lock. */
+		closure_fork (closure_attempt_trylock (&attempt_trylock, t, "G", verbose,
+						       &mu, 0, 1, &value, -1, thread_done));
+		counter_wait_for_zero (thread_done);
+
+		nsync_mu_assert_held (&mu);
+		nsync_mu_rassert_held (&mu);
+
+		nsync_mu_unlock (&mu);
+		/* ==================================== */
+
+		read_start_time = nsync_time_now (NSYNC_CLOCK);
+		counter_wait_for_zero (lock_unlock_done); /* Now can get write lock. */
+		max_write_wait_exceeded += check_times (t, "H", start_time,
+			nsync_time_add (nsync_time_add (delay_duration, delay_duration), writer_duration),
+			slop_duration);
+
+		counter_wait_for_zero (rlock_runlock_done); /* And now can get read lock again. */
+		max_read_wait_exceeded += check_times (t, "I", read_start_time,
+						       reader_duration, slop_duration);
+
+		free (thread_done);
+		free (lock_unlock_done);
+		free (rlock_runlock_done);
+		free (lock_unlock_sleeping);
+		free (rlock_runlock_sleeping);
+	}
+	if (verbose) {
+		TEST_LOG (t, ("write lock max_write_wait_exceeded %d "
+			 "max_read_wait_exceeded %d\n",
+			 max_write_wait_exceeded, max_read_wait_exceeded));
+	}
+	if (max_write_wait_exceeded > limit) {
+		TEST_ERROR (t, ("lock_unlock() took too long %d (more than %d) "
+			   "times out of %d",
+			   max_write_wait_exceeded, limit, loop_count));
+	}
+	if (max_read_wait_exceeded > limit) {
+		TEST_ERROR (t, ("rlock_runlock() took too long %d (more than %d) "
+			   "times out of %d",
+			   max_read_wait_exceeded, limit, loop_count));
+	}
+}
+
+/* --------------------------------------- */
+
+/* Measure the performance of an uncontended nsync_mu. */
+static void benchmark_mu_uncontended (testing t) {
+	int i;
+	int n = testing_n (t);
+	nsync_mu mu;
+	nsync_mu_init (&mu);
+	for (i = 0; i != n; i++) {
+		nsync_mu_lock (&mu);
+		nsync_mu_unlock (&mu);
+	}
+}
+
+/* Return whether int *value is one. */
+static int int_is_1 (const void *value) { return (*(const int *)value == 1); }
+
+/* Return whether int *value is two. */
+static int int_is_2 (const void *value) { return (*(const int *)value == 2); }
+
+/* Return whether int *value is three. */
+static int int_is_3 (const void *value) { return (*(const int *)value == 3); }
+
+/* Set *value to 1, wait for it to become 2, then set it to 3.  *value is under
+   *mu */
+static void waiter (nsync_mu *mu, int *value) {
+	nsync_mu_lock (mu);
+	*value = 1;
+	nsync_mu_wait (mu, &int_is_2, value, NULL);
+	*value = 3;
+	nsync_mu_unlock (mu);
+}
+
+CLOSURE_DECL_BODY2 (waiter, nsync_mu *, int *)
+
+/* Measure the performance of an uncontended nsync_mu
+   with a blocked waiter. */
+static void benchmark_mu_uncontended_waiter (testing t) {
+	int i;
+	int n = testing_n (t);
+	nsync_mu mu;
+	int value = 0;
+	nsync_mu_init (&mu);
+	closure_fork (closure_waiter (&waiter, &mu, &value));
+	nsync_mu_lock (&mu);
+	nsync_mu_wait (&mu, &int_is_1, &value, NULL);
+	nsync_mu_unlock (&mu);
+	for (i = 0; i != n; i++) {
+		nsync_mu_lock (&mu);
+		nsync_mu_unlock (&mu);
+	}
+	nsync_mu_lock (&mu);
+	value = 2;
+	nsync_mu_wait (&mu, &int_is_3, &value, NULL);
+	nsync_mu_unlock (&mu);
+}
+
+/* Measure the performance of an uncontended nsync_mu
+   with a blocked waiter using nsync_mu_unlock_without_wakeup. */
+static void benchmark_mu_uncontended_no_wakeup (testing t) {
+	int i;
+	int n = testing_n (t);
+	nsync_mu mu;
+	int value = 0;
+	nsync_mu_init (&mu);
+	closure_fork (closure_waiter (&waiter, &mu, &value));
+	nsync_mu_lock (&mu);
+	nsync_mu_wait (&mu, &int_is_1, &value, NULL);
+	nsync_mu_unlock (&mu);
+	for (i = 0; i != n; i++) {
+		nsync_mu_lock (&mu);
+		nsync_mu_unlock_without_wakeup (&mu);
+	}
+	nsync_mu_lock (&mu);
+	value = 2;
+	nsync_mu_wait (&mu, &int_is_3, &value, NULL);
+	nsync_mu_unlock (&mu);
+}
+
+/* Measure the performance of an uncontended
+   nsync_mu in read mode. */
+static void benchmark_rmu_uncontended (testing t) {
+	int i;
+	int n = testing_n (t);
+	nsync_mu mu;
+	nsync_mu_init (&mu);
+	for (i = 0; i != n; i++) {
+		nsync_mu_rlock (&mu);
+		nsync_mu_runlock (&mu);
+	}
+}
+
+/* Measure the performance of an uncontended nsync_mu
+   in read mode with a blocked waiter. */
+static void benchmark_rmu_uncontended_waiter (testing t) {
+	int i;
+	int n = testing_n (t);
+	nsync_mu mu;
+	int value = 0;
+	nsync_mu_init (&mu);
+	closure_fork (closure_waiter (&waiter, &mu, &value));
+	nsync_mu_lock (&mu);
+	nsync_mu_wait (&mu, &int_is_1, &value, NULL);
+	nsync_mu_unlock (&mu);
+	for (i = 0; i != n; i++) {
+		nsync_mu_rlock (&mu);
+		nsync_mu_runlock (&mu);
+	}
+	nsync_mu_lock (&mu);
+	value = 2;
+	nsync_mu_wait (&mu, &int_is_3, &value, NULL);
+	nsync_mu_unlock (&mu);
+}
+
+/* Measure the performance of an uncontended pthread_mutex_t. */
+static void benchmark_mutex_uncontended (testing t) {
+	int i;
+	int n = testing_n (t);
+	pthread_mutex_t mu;
+	pthread_mutex_init (&mu, NULL);
+	for (i = 0; i != n; i++) {
+		pthread_mutex_lock (&mu);
+		pthread_mutex_unlock (&mu);
+	}
+	pthread_mutex_destroy (&mu);
+}
+
+/* Measure the performance of an uncontended recursive pthread_mutex_t. */
+static void benchmark_xmutex_uncontended (testing t) {
+	int i;
+	int n = testing_n (t);
+	pthread_mutex_t mu;
+	pthread_mutexattr_t attr;
+	pthread_mutexattr_init (&attr);
+	pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
+	pthread_mutex_init (&mu, &attr);
+	pthread_mutexattr_destroy (&attr);
+	for (i = 0; i != n; i++) {
+		pthread_mutex_lock (&mu);
+		pthread_mutex_unlock (&mu);
+	}
+	pthread_mutex_destroy (&mu);
+}
+
+/* Measure the performance of an uncontended pthread_rwlock_t. */
+static void benchmark_wmutex_uncontended (testing t) {
+	int i;
+	int n = testing_n (t);
+	pthread_rwlock_t mu;
+	pthread_rwlock_init (&mu, NULL);
+	for (i = 0; i != n; i++) {
+		pthread_rwlock_wrlock (&mu);
+		pthread_rwlock_unlock (&mu);
+	}
+	pthread_rwlock_destroy (&mu);
+}
+
+/* Measure the performance of an uncontended
+   pthread_rwlock_t in read mode. */
+static void benchmark_rmutex_uncontended (testing t) {
+	int i;
+	int n = testing_n (t);
+	pthread_rwlock_t mu;
+	pthread_rwlock_init (&mu, NULL);
+	for (i = 0; i != n; i++) {
+		pthread_rwlock_rdlock (&mu);
+		pthread_rwlock_unlock (&mu);
+	}
+	pthread_rwlock_destroy (&mu);
+}
+
+/* ---------------------------------------
+   Benchmarks for contended locks. */
+
+/* It's hard to write these as benchmark functions, since we wish to measure
+   throughput over an extended period (a second or two), rather than get the
+   latency of a few iterations. */
+
+/* A contended_state represents state shared between threads
+   in the contended benchmarks. */
+typedef struct contended_state_s {
+	testing t;
+
+	/* locks to test */
+	nsync_mu mu;
+	pthread_mutex_t mutex;
+	pthread_rwlock_t rwmutex;
+	int count; /* counter protected by a lock above */
+	
+	nsync_mu start_done_mu;
+	int start; /* whether threads should start, under start_done_mu */
+	int not_yet_done;  /* threads not yet complete, under start_done_mu */
+} contended_state;
+
+static int contended_state_may_start (const void *v) {
+	return (((const contended_state *)v)->start);
+}
+
+static int contended_state_all_done (const void *v) {
+	return (((const contended_state *)v)->not_yet_done == 0);
+}
+
+/* Wait for cs.start to become non-zero, then loop, acquiring and
+   releasing mu on each iteration until cs.deadline is reached, then decrement
+   cs.not_yet_done. */
+static void contended_state_contend_loop (contended_state *cs,
+					  void *mu, void (*lock) (void *),
+					  void (*unlock) (void *)) {
+	int n = testing_n (cs->t);
+	int j;
+	int i;
+	nsync_mu_rlock (&cs->start_done_mu);
+	nsync_mu_wait (&cs->start_done_mu, &contended_state_may_start, cs, NULL);
+	nsync_mu_runlock (&cs->start_done_mu);
+
+	for (j = 0; j < n; j += 10000) {
+		for (i = 0; i != 10000; i++) {
+			(*lock) (mu);
+			cs->count++;
+			(*unlock) (mu);
+		}
+	}
+
+	nsync_mu_lock (&cs->start_done_mu);
+	cs->not_yet_done--;
+	nsync_mu_unlock (&cs->start_done_mu);
+}
+
+typedef void (*func_any) (void *);
+CLOSURE_DECL_BODY4 (contended_state_contend_loop, contended_state *, void *, func_any, func_any)
+
+/* Start the threads in a contended test, wait for them to finish,
+   and print the number of iterations achieved. */
+static void contended_state_run_test (contended_state *cs, testing t,
+				      void *mu, void (*lock) (void *),
+				      void (*unlock) (void *)) {
+	int i;
+	cs->t = t;
+	cs->not_yet_done = 4; /* number of threads */
+	cs->start = 0;
+	cs->count = 0;
+	for (i = 0; i != cs->not_yet_done; i++) {
+		closure_fork (closure_contended_state_contend_loop (
+			&contended_state_contend_loop, cs, mu, lock, unlock));
+	}
+	nsync_mu_lock (&cs->start_done_mu);
+	cs->start = 1;
+	nsync_mu_wait (&cs->start_done_mu, &contended_state_all_done, cs, NULL);
+	nsync_mu_unlock (&cs->start_done_mu);
+}
+
+/* Measure the performance of highly contended
+   nsync_mu locks, with small critical sections.  */
+static void benchmark_mu_contended (testing t) {
+	contended_state cs;
+	bzero ((void *) &cs, sizeof (cs));
+	contended_state_run_test (&cs, t, &cs.mu, (void (*) (void*))&nsync_mu_lock,
+				  (void (*) (void*))&nsync_mu_unlock);
+}
+
+/* Measure the performance of highly contended
+   pthread_mutex_t locks, with small critical sections.  */
+static void benchmark_mutex_contended (testing t) {
+	contended_state cs;
+	bzero ((void *) &cs, sizeof (cs));
+	pthread_mutex_init (&cs.mutex, NULL);
+	contended_state_run_test (&cs, t, &cs.mutex, &void_pthread_mutex_lock,
+				  &void_pthread_mutex_unlock);
+	pthread_mutex_destroy (&cs.mutex);
+}
+
+/* Measure the performance of highly contended recursive
+   pthread_mutex_t locks, with small critical sections.  */
+static void benchmark_xmutex_contended (testing t) {
+	contended_state cs;
+	pthread_mutexattr_t attr;
+	bzero ((void *) &cs, sizeof (cs));
+	pthread_mutexattr_init (&attr);
+	pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
+	pthread_mutex_init (&cs.mutex, &attr);
+	pthread_mutexattr_destroy (&attr);
+	contended_state_run_test (&cs, t, &cs.mutex, &void_pthread_mutex_lock,
+				  &void_pthread_mutex_unlock);
+	pthread_mutex_destroy (&cs.mutex);
+}
+
+/* Measure the performance of highly contended
+   pthread_rwlock_t locks, with small critical sections.  */
+static void benchmark_wmutex_contended (testing t) {
+	contended_state cs;
+	bzero ((void *) &cs, sizeof (cs));
+	pthread_rwlock_init (&cs.rwmutex, NULL);
+	contended_state_run_test (&cs, t, &cs.rwmutex, &void_pthread_rwlock_wrlock,
+				  &void_pthread_rwlock_unlock);
+	pthread_rwlock_destroy (&cs.rwmutex);
+}
diff --git a/third_party/nsync/testing/mu_wait2_test.c b/third_party/nsync/testing/mu_wait2_test.c
new file mode 100644
index 000000000..30f65a2b0
--- /dev/null
+++ b/third_party/nsync/testing/mu_wait2_test.c
@@ -0,0 +1,27 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/testing/mu_wait_test.inc"
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+	TEST_RUN (tb, test_mu_producer_consumer0);
+	TEST_RUN (tb, test_mu_producer_consumer3);
+	TEST_RUN (tb, test_mu_producer_consumer4);
+	TEST_RUN (tb, test_mu_producer_consumer5);
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/mu_wait3_test.c b/third_party/nsync/testing/mu_wait3_test.c
new file mode 100644
index 000000000..37c9ee382
--- /dev/null
+++ b/third_party/nsync/testing/mu_wait3_test.c
@@ -0,0 +1,25 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/testing/mu_wait_test.inc"
+
+int main (int argc, char *argv[]) {
+	testing_base tb = testing_new (argc, argv, 0);
+	TEST_RUN (tb, test_mu_producer_consumer6);
+	TEST_RUN (tb, test_mu_cancel);
+	return (testing_base_exit (tb));
+}
diff --git a/third_party/nsync/testing/mu_wait_example_test.c b/third_party/nsync/testing/mu_wait_example_test.c
index 220e473dd..90c8bf86b 100644
--- a/third_party/nsync/testing/mu_wait_example_test.c
+++ b/third_party/nsync/testing/mu_wait_example_test.c
@@ -18,6 +18,7 @@
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "third_party/nsync/array.internal.h"
+#include "third_party/nsync/time.h"
 #include "third_party/nsync/heap.internal.h"
 #include "third_party/nsync/mu.h"
 #include "third_party/nsync/mu_wait.h"
@@ -74,7 +75,7 @@ static const char *string_priority_queue_mu_remove_with_deadline (
 	const char *s = NULL;
 	nsync_mu_lock (&q->mu);
 	if (nsync_mu_wait_with_deadline (&q->mu, &spq_is_non_empty, q, NULL,
-					 abs_deadline, NULL) == 0) {
+					 NSYNC_CLOCK, abs_deadline, NULL) == 0) {
 		int alen = A_LEN (&q->heap);
 		if (alen != 0) {
 			s = A (&q->heap, 0);
@@ -99,7 +100,7 @@ static void add_and_wait_mu (string_priority_queue_mu *q,
 	int i;
 	for (i = 0; i != n; i++) {
 		string_priority_queue_mu_add (q, s[i]);
-		nsync_time_sleep (delay);
+		nsync_time_sleep (NSYNC_CLOCK, delay);
 	}
 }
 
@@ -120,7 +121,7 @@ static void a_char_append (a_char *a, const char *str) {
 static void remove_and_print_mu (string_priority_queue_mu *q, nsync_time delay, a_char *output) {
 	const char *s;
 	if ((s = string_priority_queue_mu_remove_with_deadline (q,
-			nsync_time_add (nsync_time_now (), delay))) != NULL) {
+			nsync_time_add (nsync_time_now (NSYNC_CLOCK), delay))) != NULL) {
 		a_char_append (output, s);
 		a_char_append (output, "\n");
 	} else {
@@ -154,7 +155,7 @@ static void example_mu_wait (testing t) {
 					       NELEM (input), input));
 
 	/* delay: "one", "two", "three"; not yet "four" */
-	nsync_time_sleep (nsync_time_ms (1200));
+	nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (1200));
 
 	remove_and_print_mu (&q, nsync_time_ms (1000), &output);    /* "one" */
 	remove_and_print_mu (&q, nsync_time_ms (1000), &output);    /* "three" (less than "two") */
diff --git a/third_party/nsync/testing/mu_wait_test.c b/third_party/nsync/testing/mu_wait_test.c
index 5ba1c6b53..955733856 100644
--- a/third_party/nsync/testing/mu_wait_test.c
+++ b/third_party/nsync/testing/mu_wait_test.c
@@ -15,331 +15,12 @@
 │ See the License for the specific language governing permissions and          │
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "third_party/nsync/mu_wait.h"
-#include "libc/errno.h"
-#include "libc/str/str.h"
-#include "third_party/nsync/mu.h"
-#include "third_party/nsync/note.h"
-#include "third_party/nsync/testing/closure.h"
-#include "third_party/nsync/testing/smprintf.h"
-#include "third_party/nsync/testing/testing.h"
-#include "third_party/nsync/testing/time_extra.h"
-#include "third_party/nsync/time.h"
-
-/* --------------------------- */
-
-/* A FIFO queue with up to limit elements.
-   The storage for the queue expands as necessary up to limit. */
-typedef struct mu_queue_s {
-	int limit;     /* max value of count---should not be changed after initialization */
-	nsync_mu mu;   /* protects fields below */
-	int pos;       /* index of first in-use element */
-	int count;     /* number of elements in use */
-	void *data[1]; /* in use elements are data[pos, ..., (pos+count-1)%limit] */
-} mu_queue;
-
-/* Return a pointer to new mu_queue. */
-static mu_queue *mu_queue_new (int limit) {
-	mu_queue *q;
-	int size = offsetof (struct mu_queue_s, data) + sizeof (q->data[0]) * limit;
-	q = (mu_queue *) malloc (size);
-	bzero ((void *) q, size);
-	q->limit = limit;
-	return (q);
-}
-
-static int mu_queue_non_empty (const void *v) {
-	const mu_queue *q = (const mu_queue *) v;
-	return (q->count != 0);
-}
-static int mu_queue_non_full (const void *v) {
-	const mu_queue *q = (const mu_queue *) v;
-	return (q->count != q->limit);
-}
-
-/* Add v to the end of the FIFO *q and return non-zero, or if the FIFO already
-   has limit elements and continues to do so until abs_deadline, do nothing and
-   return 0. */
-static int mu_queue_put (mu_queue *q, void *v, nsync_time abs_deadline) {
-	int added = 0;
-	nsync_mu_lock (&q->mu);
-	if (nsync_mu_wait_with_deadline (&q->mu, &mu_queue_non_full,
-					 q, NULL, abs_deadline, NULL) == 0) {
-		int i = q->pos + q->count;
-		if (q->count == q->limit) {
-			testing_panic ("q->count == q->limit");
-		}
-		if (q->limit <= i) {
-			i -= q->limit;
-		}
-		q->data[i] = v;
-		q->count++;
-		added = 1;
-	}
-	nsync_mu_unlock (&q->mu);
-	return (added);
-}
-
-/* Remove the first value from the front of the FIFO *q and return it,
-   or if the FIFO is empty and continues to be so until abs_deadline,
-   do nothing and return NULL. */
-static void *mu_queue_get (mu_queue *q, nsync_time abs_deadline) {
-	void *v = NULL;
-	nsync_mu_lock (&q->mu);
-	if (nsync_mu_wait_with_deadline (&q->mu, &mu_queue_non_empty,
-					 q, NULL, abs_deadline, NULL) == 0) {
-		if (q->count == 0) {
-			testing_panic ("q->count == 0");
-		}
-		v = q->data[q->pos];
-		q->data[q->pos] = NULL;
-		q->pos++;
-		q->count--;
-		if (q->pos == q->limit) {
-			q->pos = 0;
-		}
-	}
-	nsync_mu_unlock (&q->mu);
-	return (v);
-}
-
-/* --------------------------- */
-
-static char ptr_to_int_c;
-#define INT_TO_PTR(x) ((x) + &ptr_to_int_c)
-#define PTR_TO_INT(p) (((char *) (p)) - &ptr_to_int_c)
-
-/* Put count integers on *q, in the sequence start*3, (start+1)*3, (start+2)*3, .... */
-static void producer_mu_n (testing t, mu_queue *q, int start, int count) {
-	int i;
-	for (i = 0; i != count; i++) {
-		if (!mu_queue_put (q, INT_TO_PTR ((start+i)*3), nsync_time_no_deadline)) {
-			TEST_FATAL (t, ("mu_queue_put() returned 0 with no deadline"));
-		}
-	}
-}
-
-CLOSURE_DECL_BODY4 (producer_mu_n, testing , mu_queue *, int, int)
-
-/* Get count integers from *q, and check that they are in the
-   sequence start*3, (start+1)*3, (start+2)*3, .... */
-static void consumer_mu_n (testing t, mu_queue *q, int start, int count) {
-	int i;
-	for (i = 0; i != count; i++) {
-		void *v = mu_queue_get (q, nsync_time_no_deadline);
-		int x;
-		if (v == NULL) {
-			TEST_FATAL (t, ("mu_queue_get() returned 0 with no deadline"));
-		}
-		x = PTR_TO_INT (v);
-		if (x != (start+i)*3) {
-			TEST_FATAL (t, ("mu_queue_get() returned bad value; want %d, got %d",
-				   (start+i)*3, x));
-		}
-	}
-}
-
-/* The number of elements passed from producer to consumer in the
-   test_mu_producer_consumer*() tests below. */
-#define MU_PRODUCER_CONSUMER_N (100000)
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**0. */
-static void test_mu_producer_consumer0 (testing t) {
-	mu_queue *q = mu_queue_new (1);
-	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
-	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**1. */
-static void test_mu_producer_consumer1 (testing t) {
-	mu_queue *q = mu_queue_new (10);
-	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
-	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**2. */
-static void test_mu_producer_consumer2 (testing t) {
-	mu_queue *q = mu_queue_new (100);
-	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
-	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**3. */
-static void test_mu_producer_consumer3 (testing t) {
-	mu_queue *q = mu_queue_new (1000);
-	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
-	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**4. */
-static void test_mu_producer_consumer4 (testing t) {
-	mu_queue *q = mu_queue_new (10000);
-	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
-	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**5. */
-static void test_mu_producer_consumer5 (testing t) {
-	mu_queue *q = mu_queue_new (100000);
-	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
-	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* Send a stream of integers from a producer thread to
-   a consumer thread via a queue with limit 10**6. */
-static void test_mu_producer_consumer6 (testing t) {
-	mu_queue *q = mu_queue_new (1000000);
-	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
-	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
-	free (q);
-}
-
-/* A perpetually false wait condition. */
-static int false_condition (const void *v) {
-	return (0);
-}
-
-/* The following values control how aggressively we police the timeout. */
-#define TOO_EARLY_MS 1  
-#define TOO_LATE_MS 100   /* longer, to accommodate scheduling delays */
-#define TOO_LATE_ALLOWED 25       /* number of iterations permitted to violate too_late */
-
-/* Check timeouts on a mu wait_with_deadline(). */
-static void test_mu_deadline (testing t) {
-	int i;
-	int too_late_violations;
-	nsync_mu mu;
-	nsync_time too_early;
-	nsync_time too_late;
-
-	nsync_mu_init (&mu);
-	too_early = nsync_time_ms (TOO_EARLY_MS);
-	too_late = nsync_time_ms (TOO_LATE_MS);
-	too_late_violations = 0;
-	nsync_mu_lock (&mu);;
-	for (i = 0; i != 50; i++) {
-		nsync_time end_time;
-		nsync_time start_time;
-		nsync_time expected_end_time;
-		start_time = nsync_time_now ();
-		expected_end_time = nsync_time_add (start_time, nsync_time_ms (87));
-		if (nsync_mu_wait_with_deadline (&mu, &false_condition, NULL, NULL,
-						 expected_end_time, NULL) != ETIMEDOUT) {
-			TEST_FATAL (t, ("nsync_mu_wait() returned non-expired for a timeout"));
-		}
-		end_time = nsync_time_now ();
-		if (nsync_time_cmp (end_time, nsync_time_sub (expected_end_time, too_early)) < 0) {
-			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
-			TEST_ERROR (t, ("nsync_mu_wait() returned %s too early", elapsed_str));
-			free (elapsed_str);
-		}
-		if (nsync_time_cmp (nsync_time_add (expected_end_time, too_late),  end_time) < 0) {
-			too_late_violations++;
-		}
-	}
-	nsync_mu_unlock (&mu);
-	if (too_late_violations > TOO_LATE_ALLOWED) {
-		TEST_ERROR (t, ("nsync_mu_wait() returned too late %d (> %d) times",
-			   too_late_violations, TOO_LATE_ALLOWED));
-	}
-}
-
-/* Check cancellations on a mu wait_with_deadline(). */
-static void test_mu_cancel (testing t) {
-	int i;
-	nsync_time future_time;
-	int too_late_violations;
-	nsync_mu mu;
-	nsync_time too_early;
-	nsync_time too_late;
-
-	nsync_mu_init (&mu);
-	too_early = nsync_time_ms (TOO_EARLY_MS);
-	too_late = nsync_time_ms (TOO_LATE_MS);
-
-	/* The loops below cancel after 87 milliseconds, like the timeout tests above. */
-
-	future_time = nsync_time_add (nsync_time_now (), nsync_time_ms (3600000)); /* test cancels with timeout */
-
-	too_late_violations = 0;
-	nsync_mu_lock (&mu);
-	for (i = 0; i != 50; i++) {
-		nsync_time end_time;
-		nsync_time start_time;
-		nsync_time expected_end_time;
-		int x;
-		nsync_note cancel;
-
-		start_time = nsync_time_now ();
-		expected_end_time = nsync_time_add (start_time, nsync_time_ms (87));
-		cancel = nsync_note_new (NULL, expected_end_time);
-
-		x = nsync_mu_wait_with_deadline (&mu, &false_condition, NULL, NULL,
-						 future_time, cancel);
-		if (x != ECANCELED) {
-			TEST_FATAL (t, ("nsync_mu_wait() return non-cancelled (%d) for "
-				   "a cancellation; expected %d",
-				   x, ECANCELED));
-		}
-		end_time = nsync_time_now ();
-		if (nsync_time_cmp (end_time, nsync_time_sub (expected_end_time, too_early)) < 0) {
-			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
-			TEST_ERROR (t, ("nsync_mu_wait() returned %s too early", elapsed_str));
-			free (elapsed_str);
-		}
-		if (nsync_time_cmp (nsync_time_add (expected_end_time, too_late), end_time) < 0) {
-			too_late_violations++;
-		}
-
-		/* Check that an already cancelled wait returns immediately. */
-		start_time = nsync_time_now ();
-		x = nsync_mu_wait_with_deadline (&mu, &false_condition, NULL, NULL,
-						 nsync_time_no_deadline, cancel);
-		if (x != ECANCELED) {
-			TEST_FATAL (t, ("nsync_mu_wait() returned non-cancelled for a "
-				   "cancellation; expected %d",
-				   x, ECANCELED));
-		}
-		end_time = nsync_time_now ();
-		if (nsync_time_cmp (end_time, start_time) < 0) {
-			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
-			TEST_ERROR (t, ("nsync_mu_wait() returned %s too early", elapsed_str));
-			free (elapsed_str);
-		}
-		if (nsync_time_cmp (nsync_time_add (start_time, too_late), end_time) < 0) {
-			too_late_violations++;
-		}
-		nsync_note_free (cancel);
-	}
-	nsync_mu_unlock (&mu);
-	if (too_late_violations > TOO_LATE_ALLOWED) {
-		TEST_ERROR (t, ("nsync_mu_wait() returned too late %d (> %d) times",
-			   too_late_violations, TOO_LATE_ALLOWED));
-	}
-}
+#include "third_party/nsync/testing/mu_wait_test.inc"
 
 int main (int argc, char *argv[]) {
 	testing_base tb = testing_new (argc, argv, 0);
-	TEST_RUN (tb, test_mu_producer_consumer0);
 	TEST_RUN (tb, test_mu_producer_consumer1);
 	TEST_RUN (tb, test_mu_producer_consumer2);
-	TEST_RUN (tb, test_mu_producer_consumer3);
-	TEST_RUN (tb, test_mu_producer_consumer4);
-	TEST_RUN (tb, test_mu_producer_consumer5);
-	TEST_RUN (tb, test_mu_producer_consumer6);
 	TEST_RUN (tb, test_mu_deadline);
-	TEST_RUN (tb, test_mu_cancel);
 	return (testing_base_exit (tb));
 }
diff --git a/third_party/nsync/testing/mu_wait_test.inc b/third_party/nsync/testing/mu_wait_test.inc
new file mode 100644
index 000000000..5ab4dedcc
--- /dev/null
+++ b/third_party/nsync/testing/mu_wait_test.inc
@@ -0,0 +1,333 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/mu_wait.h"
+#include "libc/errno.h"
+#include "libc/str/str.h"
+#include "third_party/nsync/time.h"
+#include "third_party/nsync/mu.h"
+#include "third_party/nsync/note.h"
+#include "third_party/nsync/testing/closure.h"
+#include "third_party/nsync/testing/smprintf.h"
+#include "third_party/nsync/testing/testing.h"
+#include "third_party/nsync/testing/time_extra.h"
+
+/* --------------------------- */
+
+/* A FIFO queue with up to limit elements.
+   The storage for the queue expands as necessary up to limit. */
+typedef struct mu_queue_s {
+	int limit;     /* max value of count---should not be changed after initialization */
+	nsync_mu mu;   /* protects fields below */
+	int pos;       /* index of first in-use element */
+	int count;     /* number of elements in use */
+	void *data[1]; /* in use elements are data[pos, ..., (pos+count-1)%limit] */
+} mu_queue;
+
+/* Return a pointer to new mu_queue. */
+static mu_queue *mu_queue_new (int limit) {
+	mu_queue *q;
+	int size = offsetof (struct mu_queue_s, data) + sizeof (q->data[0]) * limit;
+	q = (mu_queue *) malloc (size);
+	bzero ((void *) q, size);
+	q->limit = limit;
+	return (q);
+}
+
+static int mu_queue_non_empty (const void *v) {
+	const mu_queue *q = (const mu_queue *) v;
+	return (q->count != 0);
+}
+static int mu_queue_non_full (const void *v) {
+	const mu_queue *q = (const mu_queue *) v;
+	return (q->count != q->limit);
+}
+
+/* Add v to the end of the FIFO *q and return non-zero, or if the FIFO already
+   has limit elements and continues to do so until abs_deadline, do nothing and
+   return 0. */
+static int mu_queue_put (mu_queue *q, void *v, nsync_time abs_deadline) {
+	int added = 0;
+	nsync_mu_lock (&q->mu);
+	if (nsync_mu_wait_with_deadline (&q->mu, &mu_queue_non_full,
+					 q, NULL, 0, abs_deadline, NULL) == 0) {
+		int i = q->pos + q->count;
+		if (q->count == q->limit) {
+			testing_panic ("q->count == q->limit");
+		}
+		if (q->limit <= i) {
+			i -= q->limit;
+		}
+		q->data[i] = v;
+		q->count++;
+		added = 1;
+	}
+	nsync_mu_unlock (&q->mu);
+	return (added);
+}
+
+/* Remove the first value from the front of the FIFO *q and return it,
+   or if the FIFO is empty and continues to be so until abs_deadline,
+   do nothing and return NULL. */
+static void *mu_queue_get (mu_queue *q, nsync_time abs_deadline) {
+	void *v = NULL;
+	nsync_mu_lock (&q->mu);
+	if (nsync_mu_wait_with_deadline (&q->mu, &mu_queue_non_empty,
+					 q, NULL, NSYNC_CLOCK,
+					 abs_deadline, NULL) == 0) {
+		if (q->count == 0) {
+			testing_panic ("q->count == 0");
+		}
+		v = q->data[q->pos];
+		q->data[q->pos] = NULL;
+		q->pos++;
+		q->count--;
+		if (q->pos == q->limit) {
+			q->pos = 0;
+		}
+	}
+	nsync_mu_unlock (&q->mu);
+	return (v);
+}
+
+/* --------------------------- */
+
+static char ptr_to_int_c;
+#define INT_TO_PTR(x) ((x) + &ptr_to_int_c)
+#define PTR_TO_INT(p) (((char *) (p)) - &ptr_to_int_c)
+
+/* Put count integers on *q, in the sequence start*3, (start+1)*3, (start+2)*3, .... */
+static void producer_mu_n (testing t, mu_queue *q, int start, int count) {
+	int i;
+	for (i = 0; i != count; i++) {
+		if (!mu_queue_put (q, INT_TO_PTR ((start+i)*3), nsync_time_no_deadline)) {
+			TEST_FATAL (t, ("mu_queue_put() returned 0 with no deadline"));
+		}
+	}
+}
+
+CLOSURE_DECL_BODY4 (producer_mu_n, testing , mu_queue *, int, int)
+
+/* Get count integers from *q, and check that they are in the
+   sequence start*3, (start+1)*3, (start+2)*3, .... */
+static void consumer_mu_n (testing t, mu_queue *q, int start, int count) {
+	int i;
+	for (i = 0; i != count; i++) {
+		void *v = mu_queue_get (q, nsync_time_no_deadline);
+		int x;
+		if (v == NULL) {
+			TEST_FATAL (t, ("mu_queue_get() returned 0 with no deadline"));
+		}
+		x = PTR_TO_INT (v);
+		if (x != (start+i)*3) {
+			TEST_FATAL (t, ("mu_queue_get() returned bad value; want %d, got %d",
+				   (start+i)*3, x));
+		}
+	}
+}
+
+/* The number of elements passed from producer to consumer in the
+   test_mu_producer_consumer*() tests below. */
+#define MU_PRODUCER_CONSUMER_N (100000)
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**0. */
+static void test_mu_producer_consumer0 (testing t) {
+	mu_queue *q = mu_queue_new (1);
+	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
+	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**1. */
+static void test_mu_producer_consumer1 (testing t) {
+	mu_queue *q = mu_queue_new (10);
+	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
+	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**2. */
+static void test_mu_producer_consumer2 (testing t) {
+	mu_queue *q = mu_queue_new (100);
+	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
+	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**3. */
+static void test_mu_producer_consumer3 (testing t) {
+	mu_queue *q = mu_queue_new (1000);
+	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
+	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**4. */
+static void test_mu_producer_consumer4 (testing t) {
+	mu_queue *q = mu_queue_new (10000);
+	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
+	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**5. */
+static void test_mu_producer_consumer5 (testing t) {
+	mu_queue *q = mu_queue_new (100000);
+	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
+	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* Send a stream of integers from a producer thread to
+   a consumer thread via a queue with limit 10**6. */
+static void test_mu_producer_consumer6 (testing t) {
+	mu_queue *q = mu_queue_new (1000000);
+	closure_fork (closure_producer_mu_n (&producer_mu_n, t, q, 0, MU_PRODUCER_CONSUMER_N));
+	consumer_mu_n (t, q, 0, MU_PRODUCER_CONSUMER_N);
+	free (q);
+}
+
+/* A perpetually false wait condition. */
+static int false_condition (const void *v) {
+	return (0);
+}
+
+/* The following values control how aggressively we police the timeout. */
+#define TOO_EARLY_MS 1  
+#define TOO_LATE_MS 100   /* longer, to accommodate scheduling delays */
+#define TOO_LATE_ALLOWED 25       /* number of iterations permitted to violate too_late */
+
+/* Check timeouts on a mu wait_with_deadline(). */
+static void test_mu_deadline (testing t) {
+	int i;
+	int too_late_violations;
+	nsync_mu mu;
+	nsync_time too_early;
+	nsync_time too_late;
+
+	nsync_mu_init (&mu);
+	too_early = nsync_time_ms (TOO_EARLY_MS);
+	too_late = nsync_time_ms (TOO_LATE_MS);
+	too_late_violations = 0;
+	nsync_mu_lock (&mu);
+	for (i = 0; i != 50; i++) {
+		nsync_time end_time;
+		nsync_time start_time;
+		nsync_time expected_end_time;
+		start_time = nsync_time_now (NSYNC_CLOCK);
+		expected_end_time = nsync_time_add (start_time, nsync_time_ms (87));
+		if (nsync_mu_wait_with_deadline (&mu, &false_condition, NULL, NULL, NSYNC_CLOCK,
+						 expected_end_time, NULL) != ETIMEDOUT) {
+			TEST_FATAL (t, ("nsync_mu_wait() returned non-expired for a timeout"));
+		}
+		end_time = nsync_time_now (NSYNC_CLOCK);
+		if (nsync_time_cmp (end_time, nsync_time_sub (expected_end_time, too_early)) < 0) {
+			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
+			TEST_ERROR (t, ("nsync_mu_wait() returned %s too early", elapsed_str));
+			free (elapsed_str);
+		}
+		if (nsync_time_cmp (nsync_time_add (expected_end_time, too_late),  end_time) < 0) {
+			too_late_violations++;
+		}
+	}
+	nsync_mu_unlock (&mu);
+	if (too_late_violations > TOO_LATE_ALLOWED) {
+		TEST_ERROR (t, ("nsync_mu_wait() returned too late %d (> %d) times",
+			   too_late_violations, TOO_LATE_ALLOWED));
+	}
+}
+
+/* Check cancellations on a mu wait_with_deadline(). */
+static void test_mu_cancel (testing t) {
+	int i;
+	nsync_time future_time;
+	int too_late_violations;
+	nsync_mu mu;
+	nsync_time too_early;
+	nsync_time too_late;
+
+	nsync_mu_init (&mu);
+	too_early = nsync_time_ms (TOO_EARLY_MS);
+	too_late = nsync_time_ms (TOO_LATE_MS);
+
+	/* The loops below cancel after 87 milliseconds, like the timeout tests above. */
+
+	future_time = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (3600000)); /* test cancels with timeout */
+
+	too_late_violations = 0;
+	nsync_mu_lock (&mu);
+	for (i = 0; i != 50; i++) {
+		nsync_time end_time;
+		nsync_time start_time;
+		nsync_time expected_end_time;
+		int x;
+		nsync_note cancel;
+
+		start_time = nsync_time_now (NSYNC_CLOCK);
+		expected_end_time = nsync_time_add (start_time, nsync_time_ms (87));
+		cancel = nsync_note_new (NULL, NSYNC_CLOCK, expected_end_time);
+
+		x = nsync_mu_wait_with_deadline (&mu, &false_condition, NULL, NULL,
+						 NSYNC_CLOCK, future_time, cancel);
+		if (x != ECANCELED) {
+			TEST_FATAL (t, ("nsync_mu_wait() return non-cancelled (%d) for "
+				   "a cancellation; expected %d",
+				   x, ECANCELED));
+		}
+		end_time = nsync_time_now (NSYNC_CLOCK);
+		if (nsync_time_cmp (end_time, nsync_time_sub (expected_end_time, too_early)) < 0) {
+			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
+			TEST_ERROR (t, ("nsync_mu_wait() returned %s too early", elapsed_str));
+			free (elapsed_str);
+		}
+		if (nsync_time_cmp (nsync_time_add (expected_end_time, too_late), end_time) < 0) {
+			too_late_violations++;
+		}
+
+		/* Check that an already cancelled wait returns immediately. */
+		start_time = nsync_time_now (NSYNC_CLOCK);
+		x = nsync_mu_wait_with_deadline (&mu, &false_condition, NULL, NULL,
+						 NSYNC_CLOCK, nsync_time_no_deadline,
+						 cancel);
+		if (x != ECANCELED) {
+			TEST_FATAL (t, ("nsync_mu_wait() returned non-cancelled for a "
+				   "cancellation; expected %d",
+				   x, ECANCELED));
+		}
+		end_time = nsync_time_now (NSYNC_CLOCK);
+		if (nsync_time_cmp (end_time, start_time) < 0) {
+			char *elapsed_str = nsync_time_str (nsync_time_sub (expected_end_time, end_time), 2);
+			TEST_ERROR (t, ("nsync_mu_wait() returned %s too early", elapsed_str));
+			free (elapsed_str);
+		}
+		if (nsync_time_cmp (nsync_time_add (start_time, too_late), end_time) < 0) {
+			too_late_violations++;
+		}
+		nsync_note_free (cancel);
+	}
+	nsync_mu_unlock (&mu);
+	if (too_late_violations > TOO_LATE_ALLOWED) {
+		TEST_ERROR (t, ("nsync_mu_wait() returned too late %d (> %d) times",
+			   too_late_violations, TOO_LATE_ALLOWED));
+	}
+}
diff --git a/third_party/nsync/testing/note_test.c b/third_party/nsync/testing/note_test.c
index 57298683f..4321c1e75 100644
--- a/third_party/nsync/testing/note_test.c
+++ b/third_party/nsync/testing/note_test.c
@@ -20,12 +20,13 @@
 #include "third_party/nsync/testing/smprintf.h"
 #include "third_party/nsync/testing/testing.h"
 #include "third_party/nsync/testing/time_extra.h"
+#include "libc/dce.h"
 #include "third_party/nsync/time.h"
 
 /* Verify the properties of a prenotified note. */
 static void test_note_prenotified (testing t) {
 	int i;
-	nsync_note n = nsync_note_new (NULL, nsync_time_zero /* prenotified */);
+	nsync_note n = nsync_note_new (NULL, NSYNC_CLOCK, nsync_time_zero /* prenotified */);
 	nsync_time expiry;
 	expiry = nsync_note_expiry (n);
 	if (nsync_time_cmp (expiry, nsync_time_zero) != 0) {
@@ -55,7 +56,7 @@ static void test_note_unnotified (testing t) {
 	nsync_time start;
 	nsync_time waited;
 	nsync_time deadline;
-	nsync_note n = nsync_note_new (NULL, nsync_time_no_deadline);
+	nsync_note n = nsync_note_new (NULL, NSYNC_CLOCK, nsync_time_no_deadline);
 	nsync_time expiry;
 	expiry = nsync_note_expiry (n);
 	if (nsync_time_cmp (expiry, nsync_time_no_deadline) != 0) {
@@ -68,17 +69,17 @@ static void test_note_unnotified (testing t) {
 	if (nsync_note_wait (n, nsync_time_zero)) {
 		TEST_ERROR (t, ("notified note is notified (poll)"));
 	}
-	start = nsync_time_now ();
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (1000));
+	start = nsync_time_now (NSYNC_CLOCK);
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1000));
 	if (nsync_note_wait (n, deadline)) {
 		TEST_ERROR (t, ("unnotified note is notified (1s wait)"));
 	}
-	waited = nsync_time_sub (nsync_time_now (), start);
+	waited = nsync_time_sub (nsync_time_now (NSYNC_CLOCK), start);
 	if (nsync_time_cmp (waited, nsync_time_ms (900)) < 0) {
 		TEST_ERROR (t, ("timed wait on unnotified note returned too quickly (1s wait took %s)",
 			   nsync_time_str (waited, 2)));
 	}
-	if (nsync_time_cmp (waited, nsync_time_ms (2000)) > 0) {
+	if (nsync_time_cmp (waited, nsync_time_ms (IsNetbsd() || IsOpenbsd() || IsFreebsd() ? 4000 : 2000)) > 0) {
 		TEST_ERROR (t, ("timed wait on unnotified note returned too slowly (1s wait took %s)",
 			   nsync_time_str (waited, 2)));
 	}
@@ -110,13 +111,13 @@ static void test_note_expiry (testing t) {
 	nsync_time deadline;
 	nsync_note n;
 
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (1000));
-	n = nsync_note_new (NULL, deadline);
-	start = nsync_time_now ();
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1000));
+	n = nsync_note_new (NULL, NSYNC_CLOCK, deadline);
+	start = nsync_time_now (NSYNC_CLOCK);
 	if (!nsync_note_wait (n, nsync_time_no_deadline)) {
 		TEST_ERROR (t, ("expired note is not notified"));
 	}
-	waited = nsync_time_sub (nsync_time_now (), start);
+	waited = nsync_time_sub (nsync_time_now (NSYNC_CLOCK), start);
 	if (nsync_time_cmp (waited, nsync_time_ms (900)) < 0) {
 		TEST_ERROR (t, ("note expired too quickly (1s expiry took %s)",
 			   nsync_time_str (waited, 2)));
@@ -136,13 +137,13 @@ static void test_note_expiry (testing t) {
 	}
 	nsync_note_free (n);
 
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (1000));
-	n = nsync_note_new (NULL, deadline);
-	start = nsync_time_now ();
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1000));
+	n = nsync_note_new (NULL, NSYNC_CLOCK, deadline);
+	start = nsync_time_now (NSYNC_CLOCK);
 	while (!nsync_note_is_notified (n)) {
-		nsync_time_sleep (nsync_time_ms (10));
+		nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (10));
 	}
-	waited = nsync_time_sub (nsync_time_now (), start);
+	waited = nsync_time_sub (nsync_time_now (NSYNC_CLOCK), start);
 	if (nsync_time_cmp (waited, nsync_time_ms (900)) < 0) {
 		TEST_ERROR (t, ("note expired too quickly (1s expiry took %s)",
 			   nsync_time_str (waited, 2)));
@@ -164,7 +165,7 @@ static void test_note_expiry (testing t) {
 }
 
 static void notify_at (nsync_note n, nsync_time abs_deadline) {
-	nsync_time_sleep_until (abs_deadline);
+	nsync_time_sleep_until (NSYNC_CLOCK, abs_deadline);
 	nsync_note_notify (n);
 }
 
@@ -177,14 +178,14 @@ static void test_note_notify (testing t) {
 	nsync_time deadline;
 	nsync_note n;
 
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (10000));
-	n = nsync_note_new (NULL, deadline);
-	closure_fork (closure_notify (&notify_at, n, nsync_time_add (nsync_time_now (), nsync_time_ms (1000))));
-	start = nsync_time_now ();
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (10000));
+	n = nsync_note_new (NULL, NSYNC_CLOCK, deadline);
+	closure_fork (closure_notify (&notify_at, n, nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1000))));
+	start = nsync_time_now (NSYNC_CLOCK);
 	if (!nsync_note_wait (n, nsync_time_no_deadline)) {
 		TEST_ERROR (t, ("expired note is not notified"));
 	}
-	waited = nsync_time_sub (nsync_time_now (), start);
+	waited = nsync_time_sub (nsync_time_now (NSYNC_CLOCK), start);
 	if (nsync_time_cmp (waited, nsync_time_ms (900)) < 0) {
 		TEST_ERROR (t, ("note expired too quickly (1s expiry took %s)",
 			   nsync_time_str (waited, 2)));
@@ -204,14 +205,14 @@ static void test_note_notify (testing t) {
 	}
 	nsync_note_free (n);
 
-	deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (10000));
-	n = nsync_note_new (NULL, deadline);
-	closure_fork (closure_notify (&notify_at, n, nsync_time_add (nsync_time_now (), nsync_time_ms (1000))));
-	start = nsync_time_now ();
+	deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (10000));
+	n = nsync_note_new (NULL, NSYNC_CLOCK, deadline);
+	closure_fork (closure_notify (&notify_at, n, nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1000))));
+	start = nsync_time_now (NSYNC_CLOCK);
 	while (!nsync_note_is_notified (n)) {
-		nsync_time_sleep (nsync_time_ms (10));
+		nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (10));
 	}
-	waited = nsync_time_sub (nsync_time_now (), start);
+	waited = nsync_time_sub (nsync_time_now (NSYNC_CLOCK), start);
 	if (nsync_time_cmp (waited, nsync_time_ms (900)) < 0) {
 		TEST_ERROR (t, ("note expired too quickly (1s expiry took %s)",
 			   nsync_time_str (waited, 2)));
@@ -253,9 +254,9 @@ static void test_note_in_tree (testing t) {
 	nsync_note node[count_i];
 
 	/* Initialize heap structure in the nodes.  No deadlines. */
-	node[0] = nsync_note_new (NULL, nsync_time_no_deadline);
+	node[0] = nsync_note_new (NULL, NSYNC_CLOCK, nsync_time_no_deadline);
 	for (i = 1; i != count_i; i++) {
-		node[i] = nsync_note_new (node[(i-1)/2], nsync_time_no_deadline);
+		node[i] = nsync_note_new (node[(i-1)/2], NSYNC_CLOCK, nsync_time_no_deadline);
 	}
 
 	/* check that the nodes are not yet notified. */
@@ -285,14 +286,14 @@ static void test_note_in_tree (testing t) {
 	}
 
 	/* Initialize heap structure in the nodes.  The focus node has a 1s deadline. */
-	node[0] = nsync_note_new (NULL, nsync_time_no_deadline);
+	node[0] = nsync_note_new (NULL, NSYNC_CLOCK, nsync_time_no_deadline);
 	for (i = 1; i != count_i; i++) {
 		nsync_time deadline;
-		deadline = nsync_time_add (nsync_time_now (), nsync_time_ms (1000));
+		deadline = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (1000));
 		if (i != focus_i) {
 			deadline = nsync_time_no_deadline;
 		}
-		node[i] = nsync_note_new (node[(i - 1) / 2], deadline);
+		node[i] = nsync_note_new (node[(i - 1) / 2], NSYNC_CLOCK, deadline);
 	}
 
 	/* check that the nodes are not yet notified. */
@@ -303,7 +304,7 @@ static void test_note_in_tree (testing t) {
 	}
 
 	/* Wait for timer to go off. */
-	nsync_time_sleep (nsync_time_ms (1100));
+	nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (1100));
 
 	/* Check that the right nodes have been notified. */
 	for (i = 0; i != count_i; i++) {
diff --git a/third_party/nsync/testing/once_test.c b/third_party/nsync/testing/once_test.c
index 6e411d761..0114d7286 100644
--- a/third_party/nsync/testing/once_test.c
+++ b/third_party/nsync/testing/once_test.c
@@ -76,7 +76,7 @@ static void once_thread (struct once_test_thread_s *lott) {
 	nsync_mu_lock (&ott_s_mu);
         s = lott->s;
 	nsync_mu_unlock (&ott_s_mu);
-        nsync_time_sleep (nsync_time_s_ns (0, 1 * 1000 * 1000));
+        nsync_time_sleep (NSYNC_CLOCK, nsync_time_s_ns (0, 1 * 1000 * 1000));
         switch (lott->id & 3) {
         case 0:  nsync_run_once (&s->once, &once_func0); break;
         case 1:  nsync_run_once_spin (&s->once, &once_func1); break;
@@ -111,7 +111,7 @@ static void test_once_run (testing t) {
                         closure_fork (closure_once_thread (&once_thread,
                                                            &ott[j]));
                 }
-                if (nsync_counter_wait (s->done,
+                if (nsync_counter_wait (s->done, NSYNC_CLOCK,
                                         nsync_time_no_deadline) != 0) {
                         TEST_ERROR (t, ("s.done not decremented to 0"));
                 }
diff --git a/third_party/nsync/testing/pingpong_test.c b/third_party/nsync/testing/pingpong_test.c
index 5d653bb95..67eeb6ede 100644
--- a/third_party/nsync/testing/pingpong_test.c
+++ b/third_party/nsync/testing/pingpong_test.c
@@ -17,9 +17,9 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/struct/timespec.h"
 #include "libc/str/str.h"
-#include "libc/sysv/consts/clock.h"
 #include "libc/thread/thread.h"
 #include "libc/thread/thread2.h"
+#include "third_party/nsync/time.h"
 #include "third_party/nsync/cv.h"
 #include "third_party/nsync/mu.h"
 #include "third_party/nsync/mu_wait.h"
@@ -107,6 +107,7 @@ static void mutex_cv_ping_pong (ping_pong *pp, int parity) {
 			nsync_cv_wait_with_deadline_generic (&pp->cv[parity], &pp->mutex,
 						             &void_pthread_mutex_lock,
 						             &void_pthread_mutex_unlock,
+							     NSYNC_CLOCK,
 						             nsync_time_no_deadline, NULL);
 		}
 		pp->i++;
@@ -158,12 +159,13 @@ static void benchmark_ping_pong_mu_cv (testing t) {
 /* Run by each thread in benchmark_ping_pong_mu_cv_unexpired_deadline(). */
 static void mu_cv_unexpired_deadline_ping_pong (ping_pong *pp, int parity) {
 	nsync_time deadline_in1hour;
-	deadline_in1hour = nsync_time_add (nsync_time_now (), nsync_time_ms (3600000));
+	deadline_in1hour = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (3600000));
 	nsync_mu_lock (&pp->mu);
 	while (pp->i < pp->limit) {
 		while ((pp->i & 1) == parity) {
 			nsync_cv_wait_with_deadline (&pp->cv[parity], &pp->mu,
-						     deadline_in1hour, NULL);
+						     NSYNC_CLOCK, deadline_in1hour,
+						     NULL);
 		}
 		pp->i++;
 		nsync_cv_signal (&pp->cv[1 - parity]);
@@ -198,11 +200,11 @@ static const condition_func condition[] = { &even_ping_pong, &odd_ping_pong };
 /* Run by each thread in benchmark_ping_pong_mu_unexpired_deadline(). */
 static void mu_unexpired_deadline_ping_pong (ping_pong *pp, int parity) {
 	nsync_time deadline_in1hour;
-	deadline_in1hour = nsync_time_add (nsync_time_now (), nsync_time_ms (3600000));
+	deadline_in1hour = nsync_time_add (nsync_time_now (NSYNC_CLOCK), nsync_time_ms (3600000));
 	nsync_mu_lock (&pp->mu);
 	while (pp->i < pp->limit) {
 		nsync_mu_wait_with_deadline (&pp->mu, condition[parity], pp, NULL,
-					     deadline_in1hour, NULL);
+					     NSYNC_CLOCK, deadline_in1hour, NULL);
 		pp->i++;
 	}
 	nsync_mu_unlock (&pp->mu);
@@ -225,7 +227,7 @@ static void benchmark_ping_pong_mu_unexpired_deadline (testing t) {
 /* Run by each thread in benchmark_ping_pong_mutex_cond_unexpired_deadline(). */
 static void mutex_cond_unexpired_deadline_ping_pong (ping_pong *pp, int parity) {
 	struct timespec ts;
-	clock_gettime (CLOCK_REALTIME, &ts);
+	clock_gettime (NSYNC_CLOCK, &ts);
 	ts.tv_sec += 3600;
 	pthread_mutex_lock (&pp->mutex);
 	while (pp->i < pp->limit) {
@@ -318,6 +320,7 @@ static void rw_mutex_cv_ping_pong (ping_pong *pp, int parity) {
 			nsync_cv_wait_with_deadline_generic (&pp->cv[parity], &pp->rwmutex,
 						             &void_pthread_rwlock_wrlock,
 						             &void_pthread_rwlock_unlock,
+							     NSYNC_CLOCK,
 						             nsync_time_no_deadline, NULL);
 		}
 		pp->i++;
@@ -350,7 +353,8 @@ static void wait_n_cv_ping_pong (ping_pong *pp, int parity) {
 		while ((pp->i & 1) == parity) {
 			nsync_wait_n (&pp->mu, (void (*) (void *)) &nsync_mu_lock,
 				      (void (*) (void *)) &nsync_mu_unlock,
-				      nsync_time_no_deadline, 1, &pwaitable);
+				      NSYNC_CLOCK, nsync_time_no_deadline, 1,
+				      &pwaitable);
 		}
 		pp->i++;
 		nsync_cv_signal (&pp->cv[1 - parity]);
diff --git a/third_party/nsync/testing/start_thread.c b/third_party/nsync/testing/start_thread.c
index f4e122d9c..b025e710d 100644
--- a/third_party/nsync/testing/start_thread.c
+++ b/third_party/nsync/testing/start_thread.c
@@ -16,6 +16,9 @@
 │ limitations under the License.                                               │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/mem/mem.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/runtime/runtime.h"
 #include "libc/thread/thread.h"
 
 struct thd_args {
@@ -35,6 +38,10 @@ void nsync_start_thread_ (void (*f) (void *), void *arg) {
 	pthread_t t;
 	args->f = f;
 	args->arg = arg;
-	pthread_create (&t, NULL, body, args);
+	errno_t err = pthread_create (&t, NULL, body, args);
+	if (err) {
+		fprintf(stderr, "pthread_create: %s\n", strerror(err));
+		exit(1);
+	}
 	pthread_detach (t);
 }
diff --git a/third_party/nsync/testing/testing.c b/third_party/nsync/testing/testing.c
index 321e752b0..062dee306 100644
--- a/third_party/nsync/testing/testing.c
+++ b/third_party/nsync/testing/testing.c
@@ -239,9 +239,9 @@ static void run_test (testing t) {
 	t->test_status = 0;
 	t->n = 0;
 	t->stop_time = nsync_time_zero;
-	t->start_time = nsync_time_now ();
+	t->start_time = nsync_time_now (NSYNC_CLOCK);
 	(*t->f) (t);
-	elapsed_str = nsync_time_str (nsync_time_sub (nsync_time_now (), t->start_time), 2);
+	elapsed_str = nsync_time_str (nsync_time_sub (nsync_time_now (NSYNC_CLOCK), t->start_time), 2);
 	if (!ATM_LOAD (&t->partial_line)) {
 		fprintf (t->fp, "%-25s %-45s  %s %8s\n", tb->prog, t->name,
 		         t->test_status != 0? "failed": "passed", elapsed_str);
@@ -275,9 +275,9 @@ static void run_benchmark (testing t) {
 		t->test_status = 0;
 		t->n = n;
 		t->stop_time = nsync_time_zero;
-		t->start_time = nsync_time_now ();
+		t->start_time = nsync_time_now (NSYNC_CLOCK);
 		(*t->f) (t);
-		elapsed = nsync_time_to_dbl (nsync_time_sub (nsync_time_now (), t->start_time));
+		elapsed = nsync_time_to_dbl (nsync_time_sub (nsync_time_now (NSYNC_CLOCK), t->start_time));
 		if (elapsed < 1e-1) {
 			elapsed = 1e-1;
 		}
@@ -445,9 +445,9 @@ int testing_is_uniprocessor (testing t) {
 
 		ATM_STORE_REL (&state, 0);
 		closure_fork (closure_uniprocessor_check (&uniprocessor_check, &state, &s[0]));
-		nsync_time_sleep (nsync_time_ms (100));
+		nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (100));
 		ATM_STORE_REL (&state, 1);
-		nsync_time_sleep (nsync_time_ms (400));
+		nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (400));
 		ATM_STORE_REL (&state, 2);
 		while (!ATM_LOAD_ACQ (&s[0].done)) {
 		}
@@ -455,9 +455,9 @@ int testing_is_uniprocessor (testing t) {
 		ATM_STORE_REL (&state, 0);
 		closure_fork (closure_uniprocessor_check (&uniprocessor_check, &state, &s[1]));
 		closure_fork (closure_uniprocessor_check (&uniprocessor_check, &state, &s[2]));
-		nsync_time_sleep (nsync_time_ms (100));
+		nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (100));
 		ATM_STORE_REL (&state, 1);
-		nsync_time_sleep (nsync_time_ms (400));
+		nsync_time_sleep (NSYNC_CLOCK, nsync_time_ms (400));
 		ATM_STORE_REL (&state, 2);
 		while (!ATM_LOAD_ACQ (&s[1].done) || !ATM_LOAD_ACQ (&s[2].done)) {
 		}
@@ -472,7 +472,7 @@ void testing_stop_timer (testing t) {
 	if (nsync_time_cmp (t->stop_time, nsync_time_zero) != 0) {
 		abort ();
 	}
-	t->stop_time = nsync_time_now ();
+	t->stop_time = nsync_time_now (NSYNC_CLOCK);
 }
 
 void testing_start_timer (testing t) {
@@ -480,7 +480,7 @@ void testing_start_timer (testing t) {
 		abort ();
 	}
 	t->start_time = nsync_time_add (t->start_time,
-		nsync_time_sub (nsync_time_now (), t->stop_time));
+		nsync_time_sub (nsync_time_now (NSYNC_CLOCK), t->stop_time));
 	t->stop_time = nsync_time_zero;
 }
 
diff --git a/third_party/nsync/testing/wait_test.c b/third_party/nsync/testing/wait_test.c
index 6e3c51161..567f35979 100644
--- a/third_party/nsync/testing/wait_test.c
+++ b/third_party/nsync/testing/wait_test.c
@@ -17,6 +17,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
 #include "third_party/nsync/array.internal.h"
+#include "third_party/nsync/time.h"
 #include "third_party/nsync/counter.h"
 #include "third_party/nsync/note.h"
 #include "third_party/nsync/testing/closure.h"
@@ -24,10 +25,12 @@
 #include "third_party/nsync/testing/testing.h"
 #include "third_party/nsync/testing/time_extra.h"
 #include "third_party/nsync/time.h"
+#include "libc/calls/calls.h"
+#include "libc/dce.h"
 #include "third_party/nsync/waiter.h"
 
 static void decrement_at (nsync_counter c, nsync_time abs_deadline, nsync_counter done) {
-	nsync_time_sleep_until (abs_deadline);
+	nsync_time_sleep_until (NSYNC_CLOCK, abs_deadline);
 	nsync_counter_add (c, -1);
 	nsync_counter_add (done, -1);
 }
@@ -35,7 +38,7 @@ static void decrement_at (nsync_counter c, nsync_time abs_deadline, nsync_counte
 CLOSURE_DECL_BODY3 (decrement, nsync_counter, nsync_time, nsync_counter)
 
 static void notify_at (nsync_note n, nsync_time abs_deadline, nsync_counter done) {
-	nsync_time_sleep_until (abs_deadline);
+	nsync_time_sleep_until (NSYNC_CLOCK, abs_deadline);
 	nsync_note_notify (n);
 	nsync_counter_add (done, -1);
 }
@@ -61,7 +64,7 @@ static void test_wait_n (testing t) {
 		a_pwaitable apw;
 		bzero (&aw, sizeof (aw));
 		bzero (&apw, sizeof (apw));
-		now = nsync_time_now ();
+		now = nsync_time_now (NSYNC_CLOCK);
 		deadline = nsync_time_add (now, nsync_time_ms (100));
 		for (j = A_LEN (&aw); A_LEN (&aw) < j+ncounter;) {
 			nsync_counter c = nsync_counter_new (0);
@@ -75,28 +78,28 @@ static void test_wait_n (testing t) {
 			}
 		}
 		for (j = A_LEN (&aw); A_LEN (&aw) < j+nnote;) {
-			nsync_note n = nsync_note_new (NULL, nsync_time_no_deadline);
+			nsync_note n = nsync_note_new (NULL, NSYNC_CLOCK, nsync_time_no_deadline);
 			struct nsync_waitable_s *w = &A_PUSH (&aw);
 			w->v = n;
 			w->funcs = &nsync_note_waitable_funcs;
 			nsync_counter_add (done, 1);
 			closure_fork (closure_notify (&notify_at, n, deadline, done));
 			for (k = 0; k != 4 && A_LEN (&aw) < j+nnote; k++) {
-				nsync_note cn = nsync_note_new (n, nsync_time_no_deadline);
+				nsync_note cn = nsync_note_new (n, NSYNC_CLOCK, nsync_time_no_deadline);
 				struct nsync_waitable_s *lw = &A_PUSH (&aw);
 				lw->v = cn;
 				lw->funcs = &nsync_note_waitable_funcs;
 			}
 		}
 		for (j = A_LEN (&aw); A_LEN (&aw) < j+nnote_expire;) {
-			nsync_note n = nsync_note_new (NULL, deadline);
+			nsync_note n = nsync_note_new (NULL, NSYNC_CLOCK, deadline);
 			struct nsync_waitable_s *w = &A_PUSH (&aw);
 			w->v = n;
 			w->funcs = &nsync_note_waitable_funcs;
 			nsync_counter_add (done, 1);
 			closure_fork (closure_notify (&notify_at, n, deadline, done));
 			for (k = 0; k != 4 && A_LEN (&aw) < j+nnote; k++) {
-				nsync_note cn = nsync_note_new (n, nsync_time_no_deadline);
+				nsync_note cn = nsync_note_new (n, NSYNC_CLOCK, nsync_time_no_deadline);
 				struct nsync_waitable_s *lw = &A_PUSH (&aw);
 				lw->v = cn;
 				lw->funcs = &nsync_note_waitable_funcs;
@@ -109,7 +112,8 @@ static void test_wait_n (testing t) {
 			A_PUSH (&apw) = &A (&aw, j);
 		}
 		while (A_LEN (&apw) != 0) {
-			k = nsync_wait_n (NULL, NULL, NULL, nsync_time_no_deadline,
+			k = nsync_wait_n (NULL, NULL, NULL,
+					  NSYNC_CLOCK, nsync_time_no_deadline,
 					  A_LEN (&apw), &A (&apw, 0));
 			if (k == A_LEN (&apw)) {
 				TEST_ERROR (t, ("nsync_wait_n returned with no waiter ready"));
@@ -117,7 +121,7 @@ static void test_wait_n (testing t) {
 			A (&apw, k) = A (&apw, A_LEN (&apw) - 1);
 			A_DISCARD (&apw, 1);
 		}
-		nsync_counter_wait (done, nsync_time_no_deadline);
+		nsync_counter_wait (done, NSYNC_CLOCK, nsync_time_no_deadline);
 		for (k = 0; k != ncounter; k++) {
 			nsync_counter_free ((nsync_counter) A (&aw, k).v);
 		}
@@ -159,7 +163,7 @@ static void test_wait_n_ready_while_queuing (testing t) {
 	wrapped_note_waitable_funcs.ready_time = &note_ready_time_wrapper;
 
 	for (count = 0; count != sizeof (w) / sizeof (w[0]); count++) {
-		nsync_note n = nsync_note_new (NULL, nsync_time_no_deadline);
+		nsync_note n = nsync_note_new (NULL, NSYNC_CLOCK, nsync_time_no_deadline);
 		if (nsync_note_is_notified (n)) {
 			TEST_ERROR (t, ("nsync_note is unexpectedly notified"));
 		}
@@ -167,8 +171,8 @@ static void test_wait_n_ready_while_queuing (testing t) {
 		w[count].funcs = &wrapped_note_waitable_funcs;
 		pw[count] = &w[count];
 	}
-	woken = nsync_wait_n (NULL, NULL, NULL, nsync_time_no_deadline,
-			      count, pw);
+	woken = nsync_wait_n (NULL, NULL, NULL, NSYNC_CLOCK,
+			      nsync_time_no_deadline, count, pw);
 	if (woken != 0) {
 		TEST_ERROR (t, ("nsync_wait_n unexpectedly failed to find pw[0] notified"));
 	}
@@ -183,6 +187,9 @@ static void test_wait_n_ready_while_queuing (testing t) {
 
 int main (int argc, char *argv[]) {
 	testing_base tb = testing_new (argc, argv, 0);
+	// TODO(jart): remove after cosmocc update when process rlimit flake is solved
+	if (IsAarch64 () && IsQemuUser ())
+		return 0;
 	TEST_RUN (tb, test_wait_n);
 	TEST_RUN (tb, test_wait_n_ready_while_queuing);
 	return (testing_base_exit (tb));
diff --git a/third_party/nsync/time.c b/third_party/nsync/time.c
new file mode 100644
index 000000000..996459176
--- /dev/null
+++ b/third_party/nsync/time.c
@@ -0,0 +1,26 @@
+/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
+│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2016 Google Inc.                                                   │
+│                                                                              │
+│ 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.                                               │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "third_party/nsync/time.h"
+
+/* Return the current time since the epoch.  */
+nsync_time nsync_time_now(int clock) {
+	nsync_time result;
+	if (clock_gettime (clock, &result))
+		__builtin_trap();
+	return result;
+}
diff --git a/third_party/nsync/time.h b/third_party/nsync/time.h
index badd254cd..774555685 100644
--- a/third_party/nsync/time.h
+++ b/third_party/nsync/time.h
@@ -1,8 +1,11 @@
 #ifndef NSYNC_TIME_H_
 #define NSYNC_TIME_H_
+#include "libc/sysv/consts/clock.h"
 #include "libc/calls/struct/timespec.h"
 COSMOPOLITAN_C_START_
 
+#define NSYNC_CLOCK CLOCK_REALTIME
+
 #define NSYNC_TIME_SEC(t)  ((t).tv_sec)
 #define NSYNC_TIME_NSEC(t) ((t).tv_nsec)
 #define NSYNC_TIME_STATIC_INIT(t, ns) \
@@ -22,15 +25,15 @@ typedef struct timespec nsync_time;
 #define nsync_time_zero timespec_zero
 
 /* Return the current time since the epoch.  */
-#define nsync_time_now() timespec_real()
+nsync_time nsync_time_now(int clock);
 
 /* Sleep for the specified delay. Returns the unslept time which may be
    non-zero if the call was interrupted. */
-#define nsync_time_sleep(a) timespec_sleep(a)
+#define nsync_time_sleep(c,a) timespec_sleep(c,a)
 
 /* Sleep until the specified time.  Returns 0 on success, and EINTR
    if the call was interrupted. */
-#define nsync_time_sleep_until(a) timespec_sleep_until(a)
+#define nsync_time_sleep_until(c,a) timespec_sleep_until(c,a)
 
 /* Return a+b */
 #define nsync_time_add(a, b) timespec_add(a, b)
diff --git a/third_party/nsync/wait_s.internal.h b/third_party/nsync/wait_s.internal.h
index 3d1d1de88..a4cb868ef 100644
--- a/third_party/nsync/wait_s.internal.h
+++ b/third_party/nsync/wait_s.internal.h
@@ -1,6 +1,7 @@
 #ifndef COSMOPOLITAN_LIBC_THREAD_WAIT_INTERNAL_H_
 #define COSMOPOLITAN_LIBC_THREAD_WAIT_INTERNAL_H_
 #include "libc/intrin/dll.h"
+#include "third_party/nsync/defs.h"
 #include "third_party/nsync/atomic.h"
 COSMOPOLITAN_C_START_
 
@@ -10,17 +11,19 @@ COSMOPOLITAN_C_START_
    with v pointing to the client's object and nw pointing to a struct
    nsync_waiter_s. */
 struct nsync_waiter_s {
+#if NSYNC_DEBUG
   uint32_t tag;                   /* used for debugging */
+#endif
   uint32_t flags;                 /* see below */
-  struct Dll q;                   /* used to link children of parent */
   nsync_atomic_uint32_ waiting;   /* non-zero <=> the waiter is waiting */
+  struct Dll q;                   /* used to link children of parent */
   struct nsync_semaphore_s_ *sem; /* *sem will be Ved when waiter is woken */
 };
 
 /* set if waiter is embedded in Mu/CV's internal structures */
 #define NSYNC_WAITER_FLAG_MUCV 0x1
 
-void nsync_waiter_destroy(void *);
+void nsync_waiter_destroy_(void *);
 
 COSMOPOLITAN_C_END_
 #endif /* COSMOPOLITAN_LIBC_THREAD_WAIT_INTERNAL_H_ */
diff --git a/third_party/nsync/waiter.h b/third_party/nsync/waiter.h
index b1eeba29f..4bf9b801c 100644
--- a/third_party/nsync/waiter.h
+++ b/third_party/nsync/waiter.h
@@ -102,7 +102,7 @@ struct nsync_waitable_s {
    mu/lock/unlock are used to acquire and release the relevant locks
    whan waiting on condition variables. */
 int nsync_wait_n(void *mu, void (*lock)(void *), void (*unlock)(void *),
-                 nsync_time abs_deadline, int count,
+                 int clock, nsync_time abs_deadline, int count,
                  struct nsync_waitable_s *waitable[]);
 
 /* A "struct nsync_waitable_s" implementation must implement these
diff --git a/third_party/nsync/yield.c b/third_party/nsync/yield.c
index f15b29f6c..588d8650d 100644
--- a/third_party/nsync/yield.c
+++ b/third_party/nsync/yield.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/thread/thread.h"
 #include "third_party/nsync/common.internal.h"
 
diff --git a/third_party/openmp/BUILD.mk b/third_party/openmp/BUILD.mk
index a916aa22d..7e6dde1f1 100644
--- a/third_party/openmp/BUILD.mk
+++ b/third_party/openmp/BUILD.mk
@@ -33,6 +33,8 @@ THIRD_PARTY_OPENMP_A_DIRECTDEPS =				\
 	THIRD_PARTY_COMPILER_RT					\
 	THIRD_PARTY_GDTOA					\
 	THIRD_PARTY_LIBCXX					\
+	THIRD_PARTY_LIBCXXABI					\
+	THIRD_PARTY_LIBUNWIND					\
 	THIRD_PARTY_NSYNC					\
 	THIRD_PARTY_MUSL
 
diff --git a/third_party/openmp/kmp_lock.cpp b/third_party/openmp/kmp_lock.cpp
index 8f871319d..593d805b8 100644
--- a/third_party/openmp/kmp_lock.cpp
+++ b/third_party/openmp/kmp_lock.cpp
@@ -23,7 +23,7 @@
 
 #if KMP_USE_FUTEX
 #ifdef __COSMOPOLITAN__
-#include "third_party/nsync/futex.internal.h"
+#include <cosmo.h>
 #else
 #include <sys/syscall.h>
 #include <unistd.h>
@@ -380,9 +380,9 @@ __kmp_acquire_futex_lock_timed_template(kmp_futex_lock_t *lck, kmp_int32 gtid) {
 
     long rc;
 #ifdef __COSMOPOLITAN__
-    if ((rc = nsync_futex_wait_((_Atomic(int) *)&(lck->lk.poll), poll_val, false, NULL)) != 0) {
+    if ((rc = cosmo_futex_wait((int *)&(lck->lk.poll), poll_val, false, 0, NULL)) != 0) {
 #else
-    if ((rc = syscall(__NR_futex, (_Atomic(int) *)&(lck->lk.poll), FUTEX_WAIT, poll_val, NULL,
+    if ((rc = syscall(__NR_futex, (int *)&(lck->lk.poll), FUTEX_WAIT, poll_val, NULL,
                       NULL, 0)) != 0) {
 #endif
       KA_TRACE(1000, ("__kmp_acquire_futex_lock: lck:%p, T#%d futex_wait(0x%x) "
@@ -462,7 +462,7 @@ int __kmp_release_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid) {
              ("__kmp_release_futex_lock: lck:%p, T#%d futex_wake 1 thread\n",
               lck, gtid));
 #ifdef __COSMOPOLITAN__
-    nsync_futex_wake_((_Atomic(int) *)&(lck->lk.poll), 1, false);
+    cosmo_futex_wake((int *)&(lck->lk.poll), 1, false);
 #else
     syscall(__NR_futex, &(lck->lk.poll), FUTEX_WAKE, KMP_LOCK_BUSY(1, futex),
             NULL, NULL, 0);
diff --git a/third_party/pcre/BUILD.mk b/third_party/pcre/BUILD.mk
index 3a32a0cfe..817aee016 100644
--- a/third_party/pcre/BUILD.mk
+++ b/third_party/pcre/BUILD.mk
@@ -26,7 +26,8 @@ THIRD_PARTY_PCRE_A_DIRECTDEPS =				\
 	LIBC_RUNTIME					\
 	LIBC_STDIO					\
 	LIBC_STR					\
-	LIBC_SYSV
+	LIBC_SYSV					\
+	THIRD_PARTY_MUSL				\
 
 THIRD_PARTY_PCRE_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_PCRE_A_DIRECTDEPS),$($(x))))
diff --git a/third_party/pcre/pcre2_compile.c b/third_party/pcre/pcre2_compile.c
index 4fc63cd57..01deb23de 100644
--- a/third_party/pcre/pcre2_compile.c
+++ b/third_party/pcre/pcre2_compile.c
@@ -1,3 +1,4 @@
+#include "libc/ctype.h"
 #include "libc/str/str.h"
 
 /*************************************************
@@ -8168,7 +8169,10 @@ if (*code == OP_CBRA)
   capitem.number = capnumber;
   capitem.next = cb->open_caps;
   capitem.assert_depth = cb->assert_depth;
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdangling-pointer"
   cb->open_caps = &capitem;
+#pragma GCC diagnostic pop
   }
 
 /* Offset is set zero to mark that this bracket is still open */
diff --git a/third_party/pcre/pcre2_context.c b/third_party/pcre/pcre2_context.c
index 9788a6336..d573debe9 100644
--- a/third_party/pcre/pcre2_context.c
+++ b/third_party/pcre/pcre2_context.c
@@ -1,4 +1,5 @@
 #include "libc/mem/mem.h"
+#include "libc/ctype.h"
 #include "libc/str/str.h"
 
 /*************************************************
diff --git a/third_party/pcre/pcre2_convert.c b/third_party/pcre/pcre2_convert.c
index 79d7ce86a..7a352cbb0 100644
--- a/third_party/pcre/pcre2_convert.c
+++ b/third_party/pcre/pcre2_convert.c
@@ -1,3 +1,4 @@
+#include "libc/ctype.h"
 #include "libc/str/str.h"
 
 /*************************************************
diff --git a/third_party/pcre/pcre2_maketables.c b/third_party/pcre/pcre2_maketables.c
index ab0aa5d6e..771396de9 100644
--- a/third_party/pcre/pcre2_maketables.c
+++ b/third_party/pcre/pcre2_maketables.c
@@ -2,6 +2,7 @@
 *      Perl-Compatible Regular Expressions       *
 *************************************************/
 #include "libc/str/str.h"
+#include "libc/ctype.h"
 #include "libc/mem/mem.h"
 
 /* PCRE is a library of functions to support regular expressions whose syntax
diff --git a/third_party/python/BUILD.mk b/third_party/python/BUILD.mk
index 1fe2638b9..48b001176 100644
--- a/third_party/python/BUILD.mk
+++ b/third_party/python/BUILD.mk
@@ -34,6 +34,7 @@ THIRD_PARTY_PYTHON_CHECKS =						\
 
 # TODO: Deal with aarch64 under qemu not making execve() easy.
 ifneq ($(MODE), dbg)
+ifneq ($(MODE), x86_64-dbg)
 ifeq ($(ARCH), x86_64)
 ifneq ($(UNAME_S), Windows)
 THIRD_PARTY_PYTHON_CHECKS +=						\
@@ -41,6 +42,7 @@ THIRD_PARTY_PYTHON_CHECKS +=						\
 endif
 endif
 endif
+endif
 
 ################################################################################
 # STAGE ONE - BOOTSTRAPPING PYTHON
@@ -474,6 +476,7 @@ THIRD_PARTY_PYTHON_STAGE1_A_DIRECTDEPS =				\
 	LIBC_X								\
 	THIRD_PARTY_DLMALLOC						\
 	THIRD_PARTY_GETOPT						\
+	THIRD_PARTY_MUSL						\
 	THIRD_PARTY_TZ							\
 	THIRD_PARTY_XED							\
 	TOOL_BUILD_LIB							\
@@ -526,7 +529,6 @@ THIRD_PARTY_PYTHON_STAGE2_A_SRCS =					\
 	third_party/python/runpythonmodule.c				\
 	third_party/python/launch.c					\
 	third_party/python/Objects/fromfd.c				\
-	third_party/python/Objects/unicodeobject-deadcode.c		\
 	third_party/python/Modules/_bisectmodule.c			\
 	third_party/python/Modules/_bz2module.c				\
 	third_party/python/Modules/_codecsmodule.c			\
@@ -1174,12 +1176,13 @@ THIRD_PARTY_PYTHON_STAGE2_A_DIRECTDEPS =				\
 	LIBC_NT_KERNEL32						\
 	LIBC_PROC							\
 	LIBC_RUNTIME							\
-	LIBC_THREAD							\
 	LIBC_SOCK							\
 	LIBC_STDIO							\
 	LIBC_STR							\
+	LIBC_SYSTEM							\
 	LIBC_SYSV							\
 	LIBC_SYSV_CALLS							\
+	LIBC_THREAD							\
 	LIBC_TINYMATH							\
 	LIBC_X								\
 	NET_HTTP							\
@@ -1187,14 +1190,14 @@ THIRD_PARTY_PYTHON_STAGE2_A_DIRECTDEPS =				\
 	THIRD_PARTY_BZIP2						\
 	THIRD_PARTY_GDTOA						\
 	THIRD_PARTY_LINENOISE						\
-	THIRD_PARTY_MUSL						\
 	THIRD_PARTY_MBEDTLS						\
+	THIRD_PARTY_MUSL						\
 	THIRD_PARTY_PYTHON_STAGE1					\
 	THIRD_PARTY_SQLITE3						\
 	THIRD_PARTY_TZ							\
-	THIRD_PARTY_ZLIB						\
 	THIRD_PARTY_XED							\
-	TOOL_ARGS
+	THIRD_PARTY_ZLIB						\
+	TOOL_ARGS							\
 
 THIRD_PARTY_PYTHON_STAGE2_A_DEPS =					\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_PYTHON_STAGE2_A_DIRECTDEPS),$($(x))))
@@ -1746,7 +1749,6 @@ THIRD_PARTY_PYTHON_PYTEST_A_DIRECTDEPS =					\
 THIRD_PARTY_PYTHON_PYTEST_PYMAINS =						\
 	third_party/python/Lib/test/signalinterproctester.py			\
 	third_party/python/Lib/test/test___future__.py				\
-	third_party/python/Lib/test/test__locale.py				\
 	third_party/python/Lib/test/test__opcode.py				\
 	third_party/python/Lib/test/test_abc.py					\
 	third_party/python/Lib/test/test_abstract_numbers.py			\
@@ -1843,7 +1845,6 @@ THIRD_PARTY_PYTHON_PYTEST_PYMAINS =						\
 	third_party/python/Lib/test/test_enum.py				\
 	third_party/python/Lib/test/test_enumerate.py				\
 	third_party/python/Lib/test/test_eof.py					\
-	third_party/python/Lib/test/test_epoll.py				\
 	third_party/python/Lib/test/test_errno.py				\
 	third_party/python/Lib/test/test_exception_hierarchy.py			\
 	third_party/python/Lib/test/test_exception_variations.py		\
@@ -1964,7 +1965,6 @@ THIRD_PARTY_PYTHON_PYTEST_PYMAINS =						\
 	third_party/python/Lib/test/test_string.py				\
 	third_party/python/Lib/test/test_string_literals.py			\
 	third_party/python/Lib/test/test_stringprep.py				\
-	third_party/python/Lib/test/test_strptime.py				\
 	third_party/python/Lib/test/test_strtod.py				\
 	third_party/python/Lib/test/test_struct.py				\
 	third_party/python/Lib/test/test_structmembers.py			\
@@ -2148,8 +2148,6 @@ o/$(MODE)/third_party/python/Lib/test/test_wsgiref.py.runs: private	\
 			/usr/local/etc/httpd/conf/mime.types		\
 			/usr/local/etc/mime.types
 
-o/$(MODE)/third_party/python/Lib/test/test_epoll.py.runs:		\
-		private .PLEDGE = stdio rpath wpath cpath fattr proc inet
 o/$(MODE)/third_party/python/Lib/test/test_wsgiref.py.runs:		\
 		private .PLEDGE = stdio rpath wpath cpath fattr proc inet
 o/$(MODE)/third_party/python/Lib/test/test_fcntl.py.runs:		\
@@ -2198,8 +2196,8 @@ o/$(MODE)/third_party/python/Lib/test/test_binhex.py.runs: $(PYTHONTESTER)
 o/$(MODE)/third_party/python/Lib/test/test_capi.py.runs: $(PYTHONTESTER)
 	@$(COMPILE) -ACHECK -wtT$@ $(PYHARNESSARGS) $(PYTHONTESTER) -m test.test_capi $(PYTESTARGS)
 
-o/$(MODE)/third_party/python/Lib/test/test__locale.py.runs: $(PYTHONTESTER)
-	@$(COMPILE) -ACHECK -wtT$@ $(PYHARNESSARGS) $(PYTHONTESTER) -m test.test__locale $(PYTESTARGS)
+# o/$(MODE)/third_party/python/Lib/test/test__locale.py.runs: $(PYTHONTESTER)
+# 	@$(COMPILE) -ACHECK -wtT$@ $(PYHARNESSARGS) $(PYTHONTESTER) -m test.test__locale $(PYTESTARGS)
 
 o/$(MODE)/third_party/python/Lib/test/test_binop.py.runs: $(PYTHONTESTER)
 	@$(COMPILE) -ACHECK -wtT$@ $(PYHARNESSARGS) $(PYTHONTESTER) -m test.test_binop $(PYTESTARGS)
@@ -2787,9 +2785,6 @@ o/$(MODE)/third_party/python/Lib/test/test_dis.py.runs: $(PYTHONTESTER)
 o/$(MODE)/third_party/python/Lib/test/test_asyncore.py.runs: $(PYTHONTESTER)
 	@$(COMPILE) -ACHECK -wtT$@ $(PYHARNESSARGS) $(PYTHONTESTER) -m test.test_asyncore $(PYTESTARGS)
 
-o/$(MODE)/third_party/python/Lib/test/test_epoll.py.runs: $(PYTHONTESTER)
-	@$(COMPILE) -ACHECK -wtT$@ $(PYHARNESSARGS) $(PYTHONTESTER) -m test.test_epoll $(PYTESTARGS)
-
 o/$(MODE)/third_party/python/Lib/test/test_cmd_line.py.runs: $(PYTHONTESTER)
 	@$(COMPILE) -ACHECK -wtT$@ $(PYHARNESSARGS) $(PYTHONTESTER) -m test.test_cmd_line $(PYTESTARGS)
 
diff --git a/third_party/python/Include/pyatomic.h b/third_party/python/Include/pyatomic.h
index b1b49d9de..c49ccf4f4 100644
--- a/third_party/python/Include/pyatomic.h
+++ b/third_party/python/Include/pyatomic.h
@@ -2,6 +2,7 @@
 #define Py_ATOMIC_H
 #include "libc/assert.h"
 #include "third_party/python/Include/dynamic_annotations.h"
+#include "libc/intrin/atomic.h"
 #include "third_party/python/pyconfig.h"
 
 /* This is modeled after the atomics interface from C1x, according to
diff --git a/third_party/python/Include/pyctype.h b/third_party/python/Include/pyctype.h
index 58ad51ca4..dabcae58a 100644
--- a/third_party/python/Include/pyctype.h
+++ b/third_party/python/Include/pyctype.h
@@ -1,7 +1,7 @@
 #ifndef Py_LIMITED_API
 #ifndef PYCTYPE_H
 #define PYCTYPE_H
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 #define Py_TOLOWER(c) kToLower[255 & (c)]
 #define Py_TOUPPER(c) kToUpper[255 & (c)]
diff --git a/third_party/python/Lib/_sysconfigdata_m_cosmo_x86_64_cosmo.py b/third_party/python/Lib/_sysconfigdata_m_cosmo_x86_64_cosmo.py
index f371f4236..349ed7400 100644
--- a/third_party/python/Lib/_sysconfigdata_m_cosmo_x86_64_cosmo.py
+++ b/third_party/python/Lib/_sysconfigdata_m_cosmo_x86_64_cosmo.py
@@ -486,7 +486,7 @@ build_time_vars = {'ABIFLAGS': 'm',
  'HAVE_SYS_DEVPOLL_H': 0,
  'HAVE_SYS_DIR_H': 1,
  'HAVE_SYS_ENDIAN_H': 0,
- 'HAVE_SYS_EPOLL_H': 1,
+ 'HAVE_SYS_EPOLL_H': 0,
  'HAVE_SYS_EVENT_H': 0,
  'HAVE_SYS_FILE_H': 1,
  'HAVE_SYS_IOCTL_H': 1,
diff --git a/third_party/python/Lib/test/test_re.py b/third_party/python/Lib/test/test_re.py
index 55871b8a3..1a492c6a6 100644
--- a/third_party/python/Lib/test/test_re.py
+++ b/third_party/python/Lib/test/test_re.py
@@ -1754,11 +1754,11 @@ SUBPATTERN None 0 0
                 self.skipTest('test needs %s locale' % loc)
 
         re.purge()
-        self.check_en_US_iso88591()
+        # self.check_en_US_iso88591()
         self.check_en_US_utf8()
         re.purge()
         self.check_en_US_utf8()
-        self.check_en_US_iso88591()
+        # self.check_en_US_iso88591()
 
     def check_en_US_iso88591(self):
         locale.setlocale(locale.LC_CTYPE, 'en_US.iso88591')
diff --git a/third_party/python/Modules/_decimal/_decimal.c b/third_party/python/Modules/_decimal/_decimal.c
index 3940663c9..7c3a66c54 100644
--- a/third_party/python/Modules/_decimal/_decimal.c
+++ b/third_party/python/Modules/_decimal/_decimal.c
@@ -46,6 +46,7 @@
 #include "third_party/python/Include/tupleobject.h"
 #include "third_party/python/Include/yoink.h"
 #include "third_party/python/Modules/_decimal/docstrings.h"
+#include "libc/ctype.h"
 #include "third_party/python/Modules/_decimal/libmpdec/mpdecimal.h"
 
 PYTHON_PROVIDE("_decimal");
diff --git a/third_party/python/Modules/_decimal/libmpdec/io.c b/third_party/python/Modules/_decimal/libmpdec/io.c
index 687417335..86e1ea79f 100644
--- a/third_party/python/Modules/_decimal/libmpdec/io.c
+++ b/third_party/python/Modules/_decimal/libmpdec/io.c
@@ -34,6 +34,7 @@
 #include "third_party/python/Modules/_decimal/libmpdec/constants.h"
 #include "third_party/python/Modules/_decimal/libmpdec/io.h"
 #include "third_party/python/Modules/_decimal/libmpdec/mpdecimal.h"
+#include "libc/ctype.h"
 #include "third_party/python/Modules/_decimal/libmpdec/typearith.h"
 __static_yoink("libmpdec_notice");
 
diff --git a/third_party/python/Modules/_hashmbedtls.c b/third_party/python/Modules/_hashmbedtls.c
index d045940c8..75db2c482 100644
--- a/third_party/python/Modules/_hashmbedtls.c
+++ b/third_party/python/Modules/_hashmbedtls.c
@@ -18,7 +18,7 @@
 #define PY_SSIZE_T_CLEAN
 #include "libc/calls/calls.h"
 #include "libc/log/backtrace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
@@ -32,6 +32,7 @@
 #include "third_party/python/Include/pystrhex.h"
 #include "third_party/python/Include/structmember.h"
 #include "third_party/python/Include/yoink.h"
+#include "libc/ctype.h"
 #include "third_party/python/Modules/hashlib.h"
 
 PYTHON_PROVIDE("_hashlib");
diff --git a/third_party/python/Modules/selectmodule.c b/third_party/python/Modules/selectmodule.c
index 37ba974fa..e79dafb11 100644
--- a/third_party/python/Modules/selectmodule.c
+++ b/third_party/python/Modules/selectmodule.c
@@ -9,12 +9,9 @@
 #include "libc/errno.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
-#include "libc/nt/efi.h"
-#include "libc/sock/epoll.h"
 #include "libc/sock/select.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/pollfd.h"
-#include "libc/sysv/consts/epoll.h"
 #include "libc/sysv/consts/poll.h"
 #include "third_party/python/Include/abstract.h"
 #include "third_party/python/Include/boolobject.h"
@@ -35,21 +32,6 @@
 #include "third_party/python/pyconfig.h"
 
 PYTHON_PROVIDE("select");
-PYTHON_PROVIDE("select.EPOLLERR");
-PYTHON_PROVIDE("select.EPOLLET");
-PYTHON_PROVIDE("select.EPOLLEXCLUSIVE");
-PYTHON_PROVIDE("select.EPOLLHUP");
-PYTHON_PROVIDE("select.EPOLLIN");
-PYTHON_PROVIDE("select.EPOLLMSG");
-PYTHON_PROVIDE("select.EPOLLONESHOT");
-PYTHON_PROVIDE("select.EPOLLOUT");
-PYTHON_PROVIDE("select.EPOLLPRI");
-PYTHON_PROVIDE("select.EPOLLRDBAND");
-PYTHON_PROVIDE("select.EPOLLRDHUP");
-PYTHON_PROVIDE("select.EPOLLRDNORM");
-PYTHON_PROVIDE("select.EPOLLWRBAND");
-PYTHON_PROVIDE("select.EPOLLWRNORM");
-PYTHON_PROVIDE("select.EPOLL_CLOEXEC");
 PYTHON_PROVIDE("select.POLLERR");
 PYTHON_PROVIDE("select.POLLHUP");
 PYTHON_PROVIDE("select.POLLIN");
@@ -61,7 +43,6 @@ PYTHON_PROVIDE("select.POLLRDHUP");
 PYTHON_PROVIDE("select.POLLRDNORM");
 PYTHON_PROVIDE("select.POLLWRBAND");
 PYTHON_PROVIDE("select.POLLWRNORM");
-PYTHON_PROVIDE("select.epoll");
 PYTHON_PROVIDE("select.error");
 PYTHON_PROVIDE("select.poll");
 PYTHON_PROVIDE("select.select");
diff --git a/third_party/python/Modules/socketmodule.c b/third_party/python/Modules/socketmodule.c
index a44040bbb..a8e368268 100644
--- a/third_party/python/Modules/socketmodule.c
+++ b/third_party/python/Modules/socketmodule.c
@@ -52,6 +52,8 @@
 #include "third_party/python/Include/warnings.h"
 #include "third_party/python/Include/yoink.h"
 #include "third_party/musl/netdb.h"
+#include "libc/sysv/consts/af.h"
+#include "libc/sysv/consts/af.h"
 #include "third_party/python/pyconfig.h"
 
 PYTHON_PROVIDE("_socket");
@@ -1043,16 +1045,15 @@ setipaddr(const char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int
             set_gaierror(error);
             return -1;
         }
-        switch (res->ai_family) {
-        case AF_INET:
+        if (res->ai_family == AF_INET) {
             siz = 4;
-            break;
+        }
 #ifdef ENABLE_IPV6
-        case AF_INET6:
+        else if (res->ai_family == AF_INET6) {
             siz = 16;
-            break;
+        }
 #endif
-        default:
+        else {
             freeaddrinfo(res);
             PyErr_SetString(PyExc_OSError,
                 "unsupported address family");
@@ -1159,17 +1160,14 @@ setipaddr(const char *name, struct sockaddr *addr_ret, size_t addr_ret_size, int
         addr_ret_size = res->ai_addrlen;
     memcpy((char *) addr_ret, res->ai_addr, addr_ret_size);
     freeaddrinfo(res);
-    switch (addr_ret->sa_family) {
-    case AF_INET:
+    if (addr_ret->sa_family == AF_INET)
         return 4;
 #ifdef ENABLE_IPV6
-    case AF_INET6:
+    if (addr_ret->sa_family == AF_INET6)
         return 16;
 #endif
-    default:
-        PyErr_SetString(PyExc_OSError, "unknown address family");
-        return -1;
-    }
+    PyErr_SetString(PyExc_OSError, "unknown address family");
+    return -1;
 }
 
 
@@ -6792,24 +6790,9 @@ PyInit__socket(void)
     PyModule_AddIntMacro(m, MSG_TRUNC);
     PyModule_AddIntMacro(m, MSG_CTRUNC);
     PyModule_AddIntMacro(m, MSG_WAITALL);
-    if (MSG_DONTWAIT) PyModule_AddIntMacro(m, MSG_DONTWAIT);
-    if (MSG_EOR) PyModule_AddIntMacro(m, MSG_EOR);
-    if (MSG_NOSIGNAL) PyModule_AddIntMacro(m, MSG_NOSIGNAL);
-    if (MSG_BCAST) PyModule_AddIntMacro(m, MSG_BCAST);
-    if (MSG_MCAST) PyModule_AddIntMacro(m, MSG_MCAST);
-    if (MSG_CMSG_CLOEXEC) PyModule_AddIntMacro(m, MSG_CMSG_CLOEXEC);
-    if (MSG_ERRQUEUE) PyModule_AddIntMacro(m, MSG_ERRQUEUE);
-    if (MSG_CONFIRM) PyModule_AddIntMacro(m, MSG_CONFIRM);
-    if (MSG_MORE) PyModule_AddIntMacro(m, MSG_MORE);
-    if (MSG_NOTIFICATION) PyModule_AddIntMacro(m, MSG_NOTIFICATION);
-    if (MSG_EOF) PyModule_AddIntMacro(m, MSG_EOF);
-    if (MSG_FASTOPEN) PyModule_AddIntMacro(m, MSG_FASTOPEN);
-#ifdef MSG_BTAG
-    if (MSG_BTAG) PyModule_AddIntMacro(m, MSG_BTAG);
-#endif
-#ifdef MSG_ETAG
-    if (MSG_ETAG) PyModule_AddIntMacro(m, MSG_ETAG);
-#endif
+    PyModule_AddIntMacro(m, MSG_DONTWAIT);
+    PyModule_AddIntMacro(m, MSG_NOSIGNAL);
+    if (MSG_FASTOPEN != -1) PyModule_AddIntMacro(m, MSG_FASTOPEN);
 
     /* Protocol level and numbers, usable for [gs]etsockopt */
     PyModule_AddIntMacro(m, SOL_SOCKET);
@@ -7017,12 +7000,6 @@ PyInit__socket(void)
     PyModule_AddIntMacro(m, IP_MULTICAST_LOOP);
     PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_TTL);
     PyModule_AddIntMacro(m, IP_DEFAULT_MULTICAST_LOOP);
-    PyModule_AddIntMacro(m, IP_MAX_MEMBERSHIPS);
-    if (IP_RECVOPTS) PyModule_AddIntMacro(m, IP_RECVOPTS);
-    if (IP_RECVRETOPTS) PyModule_AddIntMacro(m, IP_RECVRETOPTS);
-    if (IP_RECVDSTADDR) PyModule_AddIntMacro(m, IP_RECVDSTADDR);
-    if (IP_RETOPTS) PyModule_AddIntMacro(m, IP_RETOPTS);
-    if (IP_TRANSPARENT) PyModule_AddIntMacro(m, IP_TRANSPARENT);
 
 #ifdef ENABLE_IPV6
     /* IPv6 [gs]etsockopt options, defined in RFC2553 */
diff --git a/third_party/python/Modules/socketmodule.h b/third_party/python/Modules/socketmodule.h
index c135b85a7..05c1e6239 100644
--- a/third_party/python/Modules/socketmodule.h
+++ b/third_party/python/Modules/socketmodule.h
@@ -3,6 +3,7 @@
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/sockaddr.h"
 #include "third_party/python/Include/object.h"
+#include "libc/sock/struct/sockaddr6.h"
 #include "third_party/python/Include/pytime.h"
 COSMOPOLITAN_C_START_
 
diff --git a/third_party/python/Modules/timemodule.c b/third_party/python/Modules/timemodule.c
index 9dbabc98c..136696c69 100644
--- a/third_party/python/Modules/timemodule.c
+++ b/third_party/python/Modules/timemodule.c
@@ -1052,14 +1052,9 @@ _PyTime_GetProcessTimeWithInfo(_PyTime_t *tp, _Py_clock_info_t *info)
         *tp = (ReadFileTime(kernel_time) + ReadFileTime(user_time)) * 100;
         return 0;
     }
-    if (CLOCK_PROF != -1 || CLOCK_PROCESS_CPUTIME_ID != -1) {
-        if (CLOCK_PROF != -1) {
-            clk_id = CLOCK_PROF;
-            function = "clock_gettime(CLOCK_PROF)";
-        } else {
-            clk_id = CLOCK_PROCESS_CPUTIME_ID;
-            function = "clock_gettime(CLOCK_PROCESS_CPUTIME_ID)";
-        }
+    if (CLOCK_PROCESS_CPUTIME_ID != -1) {
+        clk_id = CLOCK_PROCESS_CPUTIME_ID;
+        function = "clock_gettime(CLOCK_PROCESS_CPUTIME_ID)";
         if (!clock_gettime(clk_id, &ts)) {
             if (info) {
                 info->implementation = function;
diff --git a/third_party/python/Modules/tlsmodule.c b/third_party/python/Modules/tlsmodule.c
index 1fca255fa..6ef1d7762 100644
--- a/third_party/python/Modules/tlsmodule.c
+++ b/third_party/python/Modules/tlsmodule.c
@@ -19,7 +19,7 @@
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/str/str.h"
 #include "net/https/https.h"
diff --git a/third_party/python/Modules/tokenbucket.c b/third_party/python/Modules/tokenbucket.c
index 22cd4f05a..4f9bb7ced 100644
--- a/third_party/python/Modules/tokenbucket.c
+++ b/third_party/python/Modules/tokenbucket.c
@@ -24,7 +24,7 @@
 #include "libc/calls/struct/timespec.h"
 #include "libc/errno.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/sockaddr.h"
diff --git a/third_party/python/Objects/bytesobject.c b/third_party/python/Objects/bytesobject.c
index 8190e3c4d..803c2a2b1 100644
--- a/third_party/python/Objects/bytesobject.c
+++ b/third_party/python/Objects/bytesobject.c
@@ -26,6 +26,7 @@
 #include "third_party/python/Include/pystrhex.h"
 #include "third_party/python/Include/pystrtod.h"
 #include "third_party/python/Include/sliceobject.h"
+#include "libc/ctype.h"
 #include "third_party/python/Include/warnings.h"
 
 /*[clinic input]
diff --git a/third_party/python/Objects/unicodeobject-deadcode.c b/third_party/python/Objects/unicodeobject-deadcode.c
deleted file mode 100644
index a007f1ec4..000000000
--- a/third_party/python/Objects/unicodeobject-deadcode.c
+++ /dev/null
@@ -1,430 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=4 sts=4 sw=4 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Python 3                                                                     │
-│ https://docs.python.org/3/license.html                                       │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#define PY_SSIZE_T_CLEAN
-#include "libc/assert.h"
-#include "third_party/python/Include/codecs.h"
-#include "third_party/python/Include/pyerrors.h"
-#include "third_party/python/Include/pymem.h"
-#include "third_party/python/Include/unicodeobject.h"
-#include "third_party/python/Include/warnings.h"
-
-#define _PyUnicode_STATE(op)                            \
-    (((PyASCIIObject *)(op))->state)
-
-int ensure_unicode(PyObject *);
-PyObject *unicode_result(PyObject *);
-int unicode_check_modifiable(PyObject *);
-PyObject *unicode_encode_ucs1(PyObject *, const char *, const Py_UCS4);
-PyObject *_PyUnicode_TranslateCharmap(PyObject *, PyObject *, const char *);
-
-/* The max unicode value is always 0x10FFFF while using the PEP-393 API.
-   This function is kept for backward compatibility with the old API. */
-Py_UNICODE
-PyUnicode_GetMax(void)
-{
-#ifdef Py_UNICODE_WIDE
-    return 0x10FFFF;
-#else
-    /* This is actually an illegal character, so it should
-       not be passed to unichr. */
-    return 0xFFFF;
-#endif
-}
-
-PyObject *
-PyUnicode_AsDecodedObject(PyObject *unicode,
-                          const char *encoding,
-                          const char *errors)
-{
-    if (!PyUnicode_Check(unicode)) {
-        PyErr_BadArgument();
-        return NULL;
-    }
-    if (PyErr_WarnEx(PyExc_DeprecationWarning,
-                     "PyUnicode_AsDecodedObject() is deprecated; "
-                     "use PyCodec_Decode() to decode from str", 1) < 0)
-        return NULL;
-    if (encoding == NULL)
-        encoding = PyUnicode_GetDefaultEncoding();
-    /* Decode via the codec registry */
-    return PyCodec_Decode(unicode, encoding, errors);
-}
-
-PyObject *
-PyUnicode_AsDecodedUnicode(PyObject *unicode,
-                           const char *encoding,
-                           const char *errors)
-{
-    PyObject *v;
-    if (!PyUnicode_Check(unicode)) {
-        PyErr_BadArgument();
-        goto onError;
-    }
-    if (PyErr_WarnEx(PyExc_DeprecationWarning,
-                     "PyUnicode_AsDecodedUnicode() is deprecated; "
-                     "use PyCodec_Decode() to decode from str to str", 1) < 0)
-        return NULL;
-    if (encoding == NULL)
-        encoding = PyUnicode_GetDefaultEncoding();
-    /* Decode via the codec registry */
-    v = PyCodec_Decode(unicode, encoding, errors);
-    if (v == NULL)
-        goto onError;
-    if (!PyUnicode_Check(v)) {
-        PyErr_Format(PyExc_TypeError,
-                     "'%.400s' decoder returned '%.400s' instead of 'str'; "
-                     "use codecs.decode() to decode to arbitrary types",
-                     encoding,
-                     Py_TYPE(unicode)->tp_name);
-        Py_DECREF(v);
-        goto onError;
-    }
-    return unicode_result(v);
-  onError:
-    return NULL;
-}
-
-PyObject *
-PyUnicode_AsEncodedObject(PyObject *unicode,
-                          const char *encoding,
-                          const char *errors)
-{
-    PyObject *v;
-    if (!PyUnicode_Check(unicode)) {
-        PyErr_BadArgument();
-        goto onError;
-    }
-    if (PyErr_WarnEx(PyExc_DeprecationWarning,
-                     "PyUnicode_AsEncodedObject() is deprecated; "
-                     "use PyUnicode_AsEncodedString() to encode from str to bytes "
-                     "or PyCodec_Encode() for generic encoding", 1) < 0)
-        return NULL;
-    if (encoding == NULL)
-        encoding = PyUnicode_GetDefaultEncoding();
-    /* Encode via the codec registry */
-    v = PyCodec_Encode(unicode, encoding, errors);
-    if (v == NULL)
-        goto onError;
-    return v;
-  onError:
-    return NULL;
-}
-
-PyObject *
-PyUnicode_AsEncodedUnicode(PyObject *unicode,
-                           const char *encoding,
-                           const char *errors)
-{
-    PyObject *v;
-    if (!PyUnicode_Check(unicode)) {
-        PyErr_BadArgument();
-        goto onError;
-    }
-    if (PyErr_WarnEx(PyExc_DeprecationWarning,
-                     "PyUnicode_AsEncodedUnicode() is deprecated; "
-                     "use PyCodec_Encode() to encode from str to str", 1) < 0)
-        return NULL;
-    if (encoding == NULL)
-        encoding = PyUnicode_GetDefaultEncoding();
-    /* Encode via the codec registry */
-    v = PyCodec_Encode(unicode, encoding, errors);
-    if (v == NULL)
-        goto onError;
-    if (!PyUnicode_Check(v)) {
-        PyErr_Format(PyExc_TypeError,
-                     "'%.400s' encoder returned '%.400s' instead of 'str'; "
-                     "use codecs.encode() to encode to arbitrary types",
-                     encoding,
-                     Py_TYPE(v)->tp_name);
-        Py_DECREF(v);
-        goto onError;
-    }
-    return v;
-  onError:
-    return NULL;
-}
-
-wchar_t *
-_PyUnicode_AsWideCharString(PyObject *unicode)
-{
-    const wchar_t *wstr;
-    wchar_t *buffer;
-    Py_ssize_t buflen;
-    if (unicode == NULL) {
-        PyErr_BadInternalCall();
-        return NULL;
-    }
-    wstr = PyUnicode_AsUnicodeAndSize(unicode, &buflen);
-    if (wstr == NULL) {
-        return NULL;
-    }
-    if (wcslen(wstr) != (size_t)buflen) {
-        PyErr_SetString(PyExc_ValueError,
-                        "embedded null character");
-        return NULL;
-    }
-    buffer = PyMem_NEW(wchar_t, buflen + 1);
-    if (buffer == NULL) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-    memcpy(buffer, wstr, (buflen + 1) * sizeof(wchar_t));
-    return buffer;
-}
-
-const Py_UNICODE *
-_PyUnicode_AsUnicode(PyObject *unicode)
-{
-    Py_ssize_t size;
-    const Py_UNICODE *wstr;
-    wstr = PyUnicode_AsUnicodeAndSize(unicode, &size);
-    if (wstr && wcslen(wstr) != (size_t)size) {
-        PyErr_SetString(PyExc_ValueError, "embedded null character");
-        return NULL;
-    }
-    return wstr;
-}
-
-Py_ssize_t
-PyUnicode_GetSize(PyObject *unicode)
-{
-    if (!PyUnicode_Check(unicode)) {
-        PyErr_BadArgument();
-        goto onError;
-    }
-    return PyUnicode_GET_SIZE(unicode);
-  onError:
-    return -1;
-}
-
-int
-PyUnicode_WriteChar(PyObject *unicode, Py_ssize_t index, Py_UCS4 ch)
-{
-    if (!PyUnicode_Check(unicode) || !PyUnicode_IS_COMPACT(unicode)) {
-        PyErr_BadArgument();
-        return -1;
-    }
-    assert(PyUnicode_IS_READY(unicode));
-    if (index < 0 || index >= PyUnicode_GET_LENGTH(unicode)) {
-        PyErr_SetString(PyExc_IndexError, "string index out of range");
-        return -1;
-    }
-    if (unicode_check_modifiable(unicode))
-        return -1;
-    if (ch > PyUnicode_MAX_CHAR_VALUE(unicode)) {
-        PyErr_SetString(PyExc_ValueError, "character out of range");
-        return -1;
-    }
-    PyUnicode_WRITE(PyUnicode_KIND(unicode), PyUnicode_DATA(unicode),
-                    index, ch);
-    return 0;
-}
-
-/* Deprecated */
-PyObject *
-PyUnicode_EncodeLatin1(const Py_UNICODE *p,
-                       Py_ssize_t size,
-                       const char *errors)
-{
-    PyObject *result;
-    PyObject *unicode = PyUnicode_FromUnicode(p, size);
-    if (unicode == NULL)
-        return NULL;
-    result = unicode_encode_ucs1(unicode, errors, 256);
-    Py_DECREF(unicode);
-    return result;
-}
-
-/* Deprecated */
-PyObject *
-PyUnicode_EncodeASCII(const Py_UNICODE *p,
-                      Py_ssize_t size,
-                      const char *errors)
-{
-    PyObject *result;
-    PyObject *unicode = PyUnicode_FromUnicode(p, size);
-    if (unicode == NULL)
-        return NULL;
-    result = unicode_encode_ucs1(unicode, errors, 128);
-    Py_DECREF(unicode);
-    return result;
-}
-
-PyObject *
-PyUnicode_Encode(const Py_UNICODE *s,
-                 Py_ssize_t size,
-                 const char *encoding,
-                 const char *errors)
-{
-    PyObject *v, *unicode;
-    unicode = PyUnicode_FromUnicode(s, size);
-    if (unicode == NULL)
-        return NULL;
-    v = PyUnicode_AsEncodedString(unicode, encoding, errors);
-    Py_DECREF(unicode);
-    return v;
-}
-
-/* Deprecated */
-PyObject *
-PyUnicode_EncodeCharmap(const Py_UNICODE *p,
-                        Py_ssize_t size,
-                        PyObject *mapping,
-                        const char *errors)
-{
-    PyObject *result;
-    PyObject *unicode = PyUnicode_FromUnicode(p, size);
-    if (unicode == NULL)
-        return NULL;
-    result = _PyUnicode_EncodeCharmap(unicode, mapping, errors);
-    Py_DECREF(unicode);
-    return result;
-}
-
-/* Deprecated. Use PyUnicode_Translate instead. */
-PyObject *
-PyUnicode_TranslateCharmap(const Py_UNICODE *p,
-                           Py_ssize_t size,
-                           PyObject *mapping,
-                           const char *errors)
-{
-    PyObject *result;
-    PyObject *unicode = PyUnicode_FromUnicode(p, size);
-    if (!unicode)
-        return NULL;
-    result = _PyUnicode_TranslateCharmap(unicode, mapping, errors);
-    Py_DECREF(unicode);
-    return result;
-}
-
-void
-PyUnicode_InternImmortal(PyObject **p)
-{
-    PyUnicode_InternInPlace(p);
-    if (PyUnicode_CHECK_INTERNED(*p) != SSTATE_INTERNED_IMMORTAL) {
-        _PyUnicode_STATE(*p).interned = SSTATE_INTERNED_IMMORTAL;
-        Py_INCREF(*p);
-    }
-}
-
-Py_UNICODE*
-Py_UNICODE_strcpy(Py_UNICODE *s1, const Py_UNICODE *s2)
-{
-    Py_UNICODE *u = s1;
-    while ((*u++ = *s2++));
-    return s1;
-}
-
-Py_UNICODE*
-Py_UNICODE_strncpy(Py_UNICODE *s1, const Py_UNICODE *s2, size_t n)
-{
-    Py_UNICODE *u = s1;
-    while ((*u++ = *s2++))
-        if (n-- == 0)
-            break;
-    return s1;
-}
-
-Py_UNICODE*
-Py_UNICODE_strcat(Py_UNICODE *s1, const Py_UNICODE *s2)
-{
-    Py_UNICODE *u1 = s1;
-    u1 += Py_UNICODE_strlen(u1);
-    Py_UNICODE_strcpy(u1, s2);
-    return s1;
-}
-
-int
-Py_UNICODE_strcmp(const Py_UNICODE *s1, const Py_UNICODE *s2)
-{
-    while (*s1 && *s2 && *s1 == *s2)
-        s1++, s2++;
-    if (*s1 && *s2)
-        return (*s1 < *s2) ? -1 : +1;
-    if (*s1)
-        return 1;
-    if (*s2)
-        return -1;
-    return 0;
-}
-
-int
-Py_UNICODE_strncmp(const Py_UNICODE *s1, const Py_UNICODE *s2, size_t n)
-{
-    Py_UNICODE u1, u2;
-    for (; n != 0; n--) {
-        u1 = *s1;
-        u2 = *s2;
-        if (u1 != u2)
-            return (u1 < u2) ? -1 : +1;
-        if (u1 == '\0')
-            return 0;
-        s1++;
-        s2++;
-    }
-    return 0;
-}
-
-Py_UNICODE*
-Py_UNICODE_strchr(const Py_UNICODE *s, Py_UNICODE c)
-{
-    const Py_UNICODE *p;
-    for (p = s; *p; p++)
-        if (*p == c)
-            return (Py_UNICODE*)p;
-    return NULL;
-}
-
-Py_UNICODE*
-Py_UNICODE_strrchr(const Py_UNICODE *s, Py_UNICODE c)
-{
-    const Py_UNICODE *p;
-    p = s + Py_UNICODE_strlen(s);
-    while (p != s) {
-        p--;
-        if (*p == c)
-            return (Py_UNICODE*)p;
-    }
-    return NULL;
-}
-
-size_t
-Py_UNICODE_strlen(const Py_UNICODE *u)
-{
-    int res = 0;
-    while(*u++)
-        res++;
-    return res;
-}
-
-Py_UNICODE*
-PyUnicode_AsUnicodeCopy(PyObject *unicode)
-{
-    Py_UNICODE *u, *copy;
-    Py_ssize_t len, size;
-    if (!PyUnicode_Check(unicode)) {
-        PyErr_BadArgument();
-        return NULL;
-    }
-    u = PyUnicode_AsUnicodeAndSize(unicode, &len);
-    if (u == NULL)
-        return NULL;
-    /* Ensure we won't overflow the size. */
-    if (len > ((PY_SSIZE_T_MAX / (Py_ssize_t)sizeof(Py_UNICODE)) - 1)) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-    size = len + 1; /* copy the null character */
-    size *= sizeof(Py_UNICODE);
-    copy = PyMem_Malloc(size);
-    if (copy == NULL) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-    memcpy(copy, u, size);
-    return copy;
-}
diff --git a/third_party/python/Objects/unicodeobject.c b/third_party/python/Objects/unicodeobject.c
index 37ed619e7..4bc672f47 100644
--- a/third_party/python/Objects/unicodeobject.c
+++ b/third_party/python/Objects/unicodeobject.c
@@ -3158,6 +3158,37 @@ PyUnicode_AsWideCharString(PyObject *unicode,
     return buffer;
 }
 
+wchar_t*
+_PyUnicode_AsWideCharString(PyObject *unicode)
+{
+    const wchar_t *wstr;
+    wchar_t *buffer;
+    Py_ssize_t buflen;
+
+    if (unicode == NULL) {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+
+    wstr = PyUnicode_AsUnicodeAndSize(unicode, &buflen);
+    if (wstr == NULL) {
+        return NULL;
+    }
+    if (wcslen(wstr) != (size_t)buflen) {
+        PyErr_SetString(PyExc_ValueError,
+                        "embedded null character");
+        return NULL;
+    }
+
+    buffer = PyMem_NEW(wchar_t, buflen + 1);
+    if (buffer == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    memcpy(buffer, wstr, (buflen + 1) * sizeof(wchar_t));
+    return buffer;
+}
+
 PyObject *
 PyUnicode_FromOrdinal(int ordinal)
 {
diff --git a/third_party/python/Parser/grammar.c b/third_party/python/Parser/grammar.c
index f8e113451..b4c385dc2 100644
--- a/third_party/python/Parser/grammar.c
+++ b/third_party/python/Parser/grammar.c
@@ -9,6 +9,7 @@
 #include "third_party/python/Include/objimpl.h"
 #include "third_party/python/Include/pgenheaders.h"
 #include "third_party/python/Include/pyerrors.h"
+#include "libc/ctype.h"
 #include "third_party/python/Include/token.h"
 
 extern int Py_DebugFlag;
diff --git a/third_party/python/Parser/tokenizer.c b/third_party/python/Parser/tokenizer.c
index bdf7615a4..c87720ea9 100644
--- a/third_party/python/Parser/tokenizer.c
+++ b/third_party/python/Parser/tokenizer.c
@@ -23,6 +23,7 @@
 #include "third_party/python/Include/pymacro.h"
 #include "third_party/python/Include/pymem.h"
 #include "third_party/python/Include/sysmodule.h"
+#include "libc/ctype.h"
 #include "third_party/python/Include/unicodeobject.h"
 #endif
 
diff --git a/third_party/python/Python/cosmomodule.c b/third_party/python/Python/cosmomodule.c
index fa82214ed..1ce9343bd 100644
--- a/third_party/python/Python/cosmomodule.c
+++ b/third_party/python/Python/cosmomodule.c
@@ -23,7 +23,7 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/intrin/popcnt.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/crc32.h"
diff --git a/third_party/python/Python/import.c b/third_party/python/Python/import.c
index 1ed177be9..9b8c1d723 100644
--- a/third_party/python/Python/import.c
+++ b/third_party/python/Python/import.c
@@ -10,7 +10,7 @@
 #include "libc/calls/struct/stat.macros.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/libgen.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
diff --git a/third_party/python/Python/marshal.c b/third_party/python/Python/marshal.c
index 573e7689b..53984862a 100644
--- a/third_party/python/Python/marshal.c
+++ b/third_party/python/Python/marshal.c
@@ -5,7 +5,6 @@
 │ https://docs.python.org/3/license.html                                       │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #define PY_SSIZE_T_CLEAN
-#include "dsp/mpeg/video.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/weirdtypes.h"
 #include "libc/mem/mem.h"
diff --git a/third_party/python/Python/pystate.c b/third_party/python/Python/pystate.c
index 11dc33893..4bab4fc6e 100644
--- a/third_party/python/Python/pystate.c
+++ b/third_party/python/Python/pystate.c
@@ -6,7 +6,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/python/Include/pystate.h"
 #include "libc/errno.h"
-#include "libc/intrin/pushpop.internal.h"
+#include "libc/intrin/pushpop.h"
 #include "libc/dlopen/dlfcn.h"
 #include "third_party/python/Include/ceval.h"
 #include "third_party/python/Include/dictobject.h"
diff --git a/third_party/python/Python/random.c b/third_party/python/Python/random.c
index 673907859..8f3fc9b75 100644
--- a/third_party/python/Python/random.c
+++ b/third_party/python/Python/random.c
@@ -9,7 +9,7 @@
 #include "libc/calls/weirdtypes.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/rand.h"
diff --git a/third_party/python/pyconfig.h b/third_party/python/pyconfig.h
index 1cfe5bb40..fe9749bd4 100644
--- a/third_party/python/pyconfig.h
+++ b/third_party/python/pyconfig.h
@@ -122,8 +122,8 @@
 #define HAVE_DIRENT_D_TYPE 1
 #define HAVE_DUP2          1
 #define HAVE_DUP3          1
-#define HAVE_EPOLL         1
-#define HAVE_EPOLL_CREATE1 1
+// #define HAVE_EPOLL         1
+// #define HAVE_EPOLL_CREATE1 1
 #define HAVE_ERF           1
 #define HAVE_ERFC          1
 #define HAVE_EXECV         1
@@ -318,8 +318,9 @@
 #define HAVE_WAIT4            1
 #define HAVE_WAITPID          1
 #define HAVE_STATVFS          1
+#define HAVE_STD_ATOMIC       1
+#define HAVE_MREMAP           1
 
-/* #define HAVE_MREMAP 1 */
 /* #undef HAVE_PLOCK */
 /* #undef HAVE_POSIX_FALLOCATE */
 /* #undef HAVE_PRLIMIT */
@@ -335,16 +336,15 @@
 /* #undef HAVE_SIGWAITINFO */
 /* #undef HAVE_SOCKADDR_ALG */
 /* #undef HAVE_SOCKADDR_SA_LEN */
-/* #undef HAVE_STD_ATOMIC */
 
 #define HAVE_SNPRINTF 1
 #define HAVE_STRDUP   1
 #define HAVE_STRFTIME 1
 #define HAVE_STRLCPY  1
 #define HAVE_WMEMCMP  1
-/* #undef HAVE_WCSCOLL */
-/* #undef HAVE_WCSFTIME */
-/* #undef HAVE_WCSXFRM */
+#define HAVE_WCSCOLL  1
+#define HAVE_WCSXFRM  1
+#define HAVE_WCSFTIME 1
 
 #define HAVE_USABLE_WCHAR_T                 1
 #define HAVE_SOCKETPAIR                     1
@@ -532,7 +532,7 @@
 /* define to 1 if your sem_getvalue is broken. */
 /* #define HAVE_BROKEN_SEM_GETVALUE 1 */
 /* Define if --enable-ipv6 is specified */
-/* #undef ENABLE_IPV6 */
+// #define ENABLE_IPV6 1
 /* Define if flock needs to be linked with bsd library. */
 /* #undef FLOCK_NEEDS_LIBBSD */
 /* Define if getpgrp() must be called as getpgrp(0). */
diff --git a/third_party/python/pyobj.c b/third_party/python/pyobj.c
index 4f9def529..927155d3f 100644
--- a/third_party/python/pyobj.c
+++ b/third_party/python/pyobj.c
@@ -24,7 +24,7 @@
 #include "libc/fmt/conv.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
@@ -35,7 +35,7 @@
 #include "libc/sysv/consts/o.h"
 #include "libc/time.h"
 #include "libc/x/x.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "third_party/getopt/getopt.internal.h"
 #include "third_party/python/Include/abstract.h"
 #include "third_party/python/Include/bytesobject.h"
diff --git a/third_party/python/python3.c b/third_party/python/python3.c
index 907bd32a7..8f6bf3865 100644
--- a/third_party/python/python3.c
+++ b/third_party/python/python3.c
@@ -6,7 +6,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/python/Include/yoink.h"
 #include "third_party/python/runpythonmodule.h"
-#include "tool/args/args.h"
+#include "libc/cosmo.h"
 
 PYTHON_YOINK("xed");
 PYTHON_YOINK("xterm");
diff --git a/third_party/python/pythontester.c b/third_party/python/pythontester.c
index 07549673b..e55e63edd 100644
--- a/third_party/python/pythontester.c
+++ b/third_party/python/pythontester.c
@@ -8,7 +8,7 @@
 #include "libc/runtime/runtime.h"
 #include "third_party/python/Include/yoink.h"
 #include "third_party/python/runpythonmodule.h"
-#include "tool/args/args.h"
+#include "libc/cosmo.h"
 
 int
 main(int argc, char **argv)
diff --git a/third_party/python/repl.c b/third_party/python/repl.c
index 9528e4e83..4b4aa7c22 100644
--- a/third_party/python/repl.c
+++ b/third_party/python/repl.c
@@ -6,7 +6,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/python/Include/yoink.h"
 #include "third_party/python/runpythonmodule.h"
-#include "tool/args/args.h"
+#include "libc/cosmo.h"
 
 int
 main(int argc, char **argv)
diff --git a/third_party/python/runpythonmodule.c b/third_party/python/runpythonmodule.c
index 1ce15f005..f4c41e38e 100644
--- a/third_party/python/runpythonmodule.c
+++ b/third_party/python/runpythonmodule.c
@@ -12,11 +12,11 @@
 #include "libc/calls/ucontext.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/intrin/weaken.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
@@ -49,6 +49,7 @@
 #include "third_party/python/Include/unicodeobject.h"
 #include "third_party/python/Include/yoink.h"
 #include "libc/runtime/stack.h"
+#include "libc/ctype.h"
 #include "third_party/xed/x86.h"
 
 STATIC_STACK_SIZE(0x100000);
diff --git a/third_party/regex/BUILD.mk b/third_party/regex/BUILD.mk
index 79b93315f..a9bbc59ef 100644
--- a/third_party/regex/BUILD.mk
+++ b/third_party/regex/BUILD.mk
@@ -20,7 +20,8 @@ THIRD_PARTY_REGEX_A_DIRECTDEPS =			\
 	LIBC_MEM					\
 	LIBC_NEXGEN32E					\
 	LIBC_RUNTIME					\
-	LIBC_STR
+	LIBC_STR					\
+	THIRD_PARTY_MUSL				\
 
 THIRD_PARTY_REGEX_A_DEPS :=				\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_REGEX_A_DIRECTDEPS),$($(x))))
diff --git a/third_party/regex/regcomp.c b/third_party/regex/regcomp.c
index fbec0a48f..0031fe059 100644
--- a/third_party/regex/regcomp.c
+++ b/third_party/regex/regcomp.c
@@ -56,11 +56,16 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/mem/alg.h"
-#include "third_party/regex/tre.inc"
+#include <string.h>
+#include <stdlib.h>
+#include <regex.h>
+#include <limits.h>
+#include <stdint.h>
+#include <ctype.h>
 
-#define CHARCLASS_NAME_MAX 14
-#define RE_DUP_MAX         255
+#include "tre.inc"
+
+#include <assert.h>
 
 /***********************************************************************
  from tre-compile.h
@@ -77,30 +82,37 @@ typedef struct {
   int backref;
 } tre_pos_and_tags_t;
 
+
 /***********************************************************************
  from tre-ast.c and tre-ast.h
 ***********************************************************************/
 
 /* The different AST node types. */
-typedef enum { LITERAL, CATENATION, ITERATION, UNION } tre_ast_type_t;
+typedef enum {
+  LITERAL,
+  CATENATION,
+  ITERATION,
+  UNION
+} tre_ast_type_t;
 
 /* Special subtypes of TRE_LITERAL. */
-#define EMPTY     -1 /* Empty leaf (denotes empty string). */
-#define ASSERTION -2 /* Assertion leaf. */
-#define TAG       -3 /* Tag leaf. */
-#define BACKREF   -4 /* Back reference leaf. */
+#define EMPTY	  -1   /* Empty leaf (denotes empty string). */
+#define ASSERTION -2   /* Assertion leaf. */
+#define TAG	  -3   /* Tag leaf. */
+#define BACKREF	  -4   /* Back reference leaf. */
 
-#define IS_SPECIAL(x)   ((x)->code_min < 0)
-#define IS_EMPTY(x)     ((x)->code_min == EMPTY)
+#define IS_SPECIAL(x)	((x)->code_min < 0)
+#define IS_EMPTY(x)	((x)->code_min == EMPTY)
 #define IS_ASSERTION(x) ((x)->code_min == ASSERTION)
-#define IS_TAG(x)       ((x)->code_min == TAG)
-#define IS_BACKREF(x)   ((x)->code_min == BACKREF)
+#define IS_TAG(x)	((x)->code_min == TAG)
+#define IS_BACKREF(x)	((x)->code_min == BACKREF)
+
 
 /* A generic AST node.  All AST nodes consist of this node on the top
    level with `obj' pointing to the actual content. */
 typedef struct {
-  tre_ast_type_t type; /* Type of the node. */
-  void *obj;           /* Pointer to actual node. */
+  tre_ast_type_t type;   /* Type of the node. */
+  void *obj;             /* Pointer to actual node. */
   int nullable;
   int submatch_id;
   int num_submatches;
@@ -109,6 +121,7 @@ typedef struct {
   tre_pos_and_tags_t *lastpos;
 } tre_ast_node_t;
 
+
 /* A "literal" node.  These are created for assertions, back references,
    tags, matching parameter settings, and all expressions that match one
    character. */
@@ -141,7 +154,7 @@ typedef struct {
   /* If 0, match as many characters as possible, if 1 match as few as
      possible.	Note that this does not always mean the same thing as
      matching as many/few repetitions as possible. */
-  unsigned int minimal : 1;
+  unsigned int minimal:1;
 } tre_iteration_t;
 
 /* An "union" node.  These are created for the "|" operator. */
@@ -150,77 +163,91 @@ typedef struct {
   tre_ast_node_t *right;
 } tre_union_t;
 
-static tre_ast_node_t *tre_ast_new_node(tre_mem_t mem, int type, void *obj) {
-  tre_ast_node_t *node = tre_mem_calloc(mem, sizeof *node);
-  if (!node || !obj) return 0;
-  node->obj = obj;
-  node->type = type;
-  node->nullable = -1;
-  node->submatch_id = -1;
-  return node;
+
+static tre_ast_node_t *
+tre_ast_new_node(tre_mem_t mem, int type, void *obj)
+{
+	tre_ast_node_t *node = tre_mem_calloc(mem, sizeof *node);
+	if (!node || !obj)
+		return 0;
+	node->obj = obj;
+	node->type = type;
+	node->nullable = -1;
+	node->submatch_id = -1;
+	return node;
 }
 
-static tre_ast_node_t *tre_ast_new_literal(tre_mem_t mem, int code_min,
-                                           int code_max, int position) {
-  tre_ast_node_t *node;
-  tre_literal_t *lit;
+static tre_ast_node_t *
+tre_ast_new_literal(tre_mem_t mem, int code_min, int code_max, int position)
+{
+	tre_ast_node_t *node;
+	tre_literal_t *lit;
 
-  lit = tre_mem_calloc(mem, sizeof *lit);
-  node = tre_ast_new_node(mem, LITERAL, lit);
-  if (!node) return 0;
-  lit->code_min = code_min;
-  lit->code_max = code_max;
-  lit->position = position;
-  return node;
+	lit = tre_mem_calloc(mem, sizeof *lit);
+	node = tre_ast_new_node(mem, LITERAL, lit);
+	if (!node)
+		return 0;
+	lit->code_min = code_min;
+	lit->code_max = code_max;
+	lit->position = position;
+	return node;
 }
 
-static tre_ast_node_t *tre_ast_new_iter(tre_mem_t mem, tre_ast_node_t *arg,
-                                        int min, int max, int minimal) {
-  tre_ast_node_t *node;
-  tre_iteration_t *iter;
+static tre_ast_node_t *
+tre_ast_new_iter(tre_mem_t mem, tre_ast_node_t *arg, int min, int max, int minimal)
+{
+	tre_ast_node_t *node;
+	tre_iteration_t *iter;
 
-  iter = tre_mem_calloc(mem, sizeof *iter);
-  node = tre_ast_new_node(mem, ITERATION, iter);
-  if (!node) return 0;
-  iter->arg = arg;
-  iter->min = min;
-  iter->max = max;
-  iter->minimal = minimal;
-  node->num_submatches = arg->num_submatches;
-  return node;
+	iter = tre_mem_calloc(mem, sizeof *iter);
+	node = tre_ast_new_node(mem, ITERATION, iter);
+	if (!node)
+		return 0;
+	iter->arg = arg;
+	iter->min = min;
+	iter->max = max;
+	iter->minimal = minimal;
+	node->num_submatches = arg->num_submatches;
+	return node;
 }
 
-static tre_ast_node_t *tre_ast_new_union(tre_mem_t mem, tre_ast_node_t *left,
-                                         tre_ast_node_t *right) {
-  tre_ast_node_t *node;
-  tre_union_t *un;
+static tre_ast_node_t *
+tre_ast_new_union(tre_mem_t mem, tre_ast_node_t *left, tre_ast_node_t *right)
+{
+	tre_ast_node_t *node;
+	tre_union_t *un;
 
-  if (!left) return right;
-  un = tre_mem_calloc(mem, sizeof *un);
-  node = tre_ast_new_node(mem, UNION, un);
-  if (!node || !right) return 0;
-  un->left = left;
-  un->right = right;
-  node->num_submatches = left->num_submatches + right->num_submatches;
-  return node;
+	if (!left)
+		return right;
+	un = tre_mem_calloc(mem, sizeof *un);
+	node = tre_ast_new_node(mem, UNION, un);
+	if (!node || !right)
+		return 0;
+	un->left = left;
+	un->right = right;
+	node->num_submatches = left->num_submatches + right->num_submatches;
+	return node;
 }
 
-static tre_ast_node_t *tre_ast_new_catenation(tre_mem_t mem,
-                                              tre_ast_node_t *left,
-                                              tre_ast_node_t *right) {
-  tre_ast_node_t *node;
-  tre_catenation_t *cat;
+static tre_ast_node_t *
+tre_ast_new_catenation(tre_mem_t mem, tre_ast_node_t *left, tre_ast_node_t *right)
+{
+	tre_ast_node_t *node;
+	tre_catenation_t *cat;
 
-  if (!left) return right;
-  cat = tre_mem_calloc(mem, sizeof *cat);
-  node = tre_ast_new_node(mem, CATENATION, cat);
-  if (!node) return 0;
-  cat->left = left;
-  cat->right = right;
-  node->num_submatches = left->num_submatches + right->num_submatches;
-  return node;
+	if (!left)
+		return right;
+	cat = tre_mem_calloc(mem, sizeof *cat);
+	node = tre_ast_new_node(mem, CATENATION, cat);
+	if (!node)
+		return 0;
+	cat->left = left;
+	cat->right = right;
+	node->num_submatches = left->num_submatches + right->num_submatches;
+	return node;
 }
 
+
 /***********************************************************************
  from tre-stack.c and tre-stack.h
 ***********************************************************************/
@@ -231,20 +258,23 @@ typedef struct tre_stack_rec tre_stack_t;
    is maximum size, and `increment' specifies how much more space will be
    allocated with realloc() if all space gets used up.	Returns the stack
    object or NULL if out of memory. */
-static tre_stack_t *tre_stack_new(int size, int max_size, int increment);
+static tre_stack_t *
+tre_stack_new(int size, int max_size, int increment);
 
 /* Frees the stack object. */
-static void tre_stack_destroy(tre_stack_t *s);
+static void
+tre_stack_destroy(tre_stack_t *s);
 
 /* Returns the current number of objects in the stack. */
-static int tre_stack_num_objects(tre_stack_t *s);
+static int
+tre_stack_num_objects(tre_stack_t *s);
 
 /* Each tre_stack_push_*(tre_stack_t *s, <type> value) function pushes
    `value' on top of stack `s'.  Returns REG_ESPACE if out of memory.
    This tries to realloc() more space before failing if maximum size
    has not yet been reached.  Returns REG_OK if successful. */
-#define declare_pushf(typetag, type) \
-  static reg_errcode_t tre_stack_push_##typetag(tre_stack_t *s, type value)
+#define declare_pushf(typetag, type)					      \
+  static reg_errcode_t tre_stack_push_ ## typetag(tre_stack_t *s, type value)
 
 declare_pushf(voidptr, void *);
 declare_pushf(int, int);
@@ -252,29 +282,33 @@ declare_pushf(int, int);
 /* Each tre_stack_pop_*(tre_stack_t *s) function pops the topmost
    element off of stack `s' and returns it.  The stack must not be
    empty. */
-#define declare_popf(typetag, type) \
-  static type tre_stack_pop_##typetag(tre_stack_t *s)
+#define declare_popf(typetag, type)		  \
+  static type tre_stack_pop_ ## typetag(tre_stack_t *s)
 
 declare_popf(voidptr, void *);
 declare_popf(int, int);
 
 /* Just to save some typing. */
-#define STACK_PUSH(s, typetag, value)            \
-  do {                                           \
-    status = tre_stack_push_##typetag(s, value); \
-  } while (/*CONSTCOND*/ 0)
+#define STACK_PUSH(s, typetag, value)					      \
+  do									      \
+    {									      \
+      status = tre_stack_push_ ## typetag(s, value);			      \
+    }									      \
+  while (/*CONSTCOND*/0)
 
-#define STACK_PUSHX(s, typetag, value)           \
-  {                                              \
-    status = tre_stack_push_##typetag(s, value); \
-    if (status != REG_OK) break;                 \
+#define STACK_PUSHX(s, typetag, value)					      \
+  {									      \
+    status = tre_stack_push_ ## typetag(s, value);			      \
+    if (status != REG_OK)						      \
+      break;								      \
   }
 
-#define STACK_PUSHR(s, typetag, value)            \
-  {                                               \
-    reg_errcode_t _status;                        \
-    _status = tre_stack_push_##typetag(s, value); \
-    if (_status != REG_OK) return _status;        \
+#define STACK_PUSHR(s, typetag, value)					      \
+  {									      \
+    reg_errcode_t _status;						      \
+    _status = tre_stack_push_ ## typetag(s, value);			      \
+    if (_status != REG_OK)						      \
+      return _status;							      \
   }
 
 union tre_stack_item {
@@ -290,193 +324,215 @@ struct tre_stack_rec {
   union tre_stack_item *stack;
 };
 
-static tre_stack_t *tre_stack_new(int size, int max_size, int increment) {
+
+static tre_stack_t *
+tre_stack_new(int size, int max_size, int increment)
+{
   tre_stack_t *s;
 
-  s = malloc(sizeof(*s));
-  if (s != NULL) {
-    s->stack = malloc(sizeof(*s->stack) * size);
-    if (s->stack == NULL) {
-      free(s), s = NULL;
-      return NULL;
+  s = xmalloc(sizeof(*s));
+  if (s != NULL)
+    {
+      s->stack = xmalloc(sizeof(*s->stack) * size);
+      if (s->stack == NULL)
+	{
+	  xfree(s);
+	  return NULL;
+	}
+      s->size = size;
+      s->max_size = max_size;
+      s->increment = increment;
+      s->ptr = 0;
     }
-    s->size = size;
-    s->max_size = max_size;
-    s->increment = increment;
-    s->ptr = 0;
-  }
   return s;
 }
 
-static void tre_stack_destroy(tre_stack_t *s) {
-  free(s->stack), s->stack = NULL;
-  free(s), s = NULL;
+static void
+tre_stack_destroy(tre_stack_t *s)
+{
+  xfree(s->stack);
+  xfree(s);
 }
 
-static int tre_stack_num_objects(tre_stack_t *s) {
+static int
+tre_stack_num_objects(tre_stack_t *s)
+{
   return s->ptr;
 }
 
-static reg_errcode_t tre_stack_push(tre_stack_t *s,
-                                    union tre_stack_item value) {
-  if (s->ptr < s->size) {
-    s->stack[s->ptr] = value;
-    s->ptr++;
-  } else {
-    if (s->size >= s->max_size) {
-      return REG_ESPACE;
-    } else {
-      union tre_stack_item *new_buffer;
-      int new_size;
-      new_size = s->size + s->increment;
-      if (new_size > s->max_size) new_size = s->max_size;
-      new_buffer = realloc(s->stack, sizeof(*new_buffer) * new_size);
-      if (new_buffer == NULL) {
-        return REG_ESPACE;
-      }
-      unassert(new_size > s->size);
-      s->size = new_size;
-      s->stack = new_buffer;
-      tre_stack_push(s, value);
+static reg_errcode_t
+tre_stack_push(tre_stack_t *s, union tre_stack_item value)
+{
+  if (s->ptr < s->size)
+    {
+      s->stack[s->ptr] = value;
+      s->ptr++;
+    }
+  else
+    {
+      if (s->size >= s->max_size)
+	{
+	  return REG_ESPACE;
+	}
+      else
+	{
+	  union tre_stack_item *new_buffer;
+	  int new_size;
+	  new_size = s->size + s->increment;
+	  if (new_size > s->max_size)
+	    new_size = s->max_size;
+	  new_buffer = xrealloc(s->stack, sizeof(*new_buffer) * new_size);
+	  if (new_buffer == NULL)
+	    {
+	      return REG_ESPACE;
+	    }
+	  assert(new_size > s->size);
+	  s->size = new_size;
+	  s->stack = new_buffer;
+	  tre_stack_push(s, value);
+	}
     }
-  }
   return REG_OK;
 }
 
-#define define_pushf(typetag, type) \
-  declare_pushf(typetag, type) {    \
-    union tre_stack_item item;      \
-    item.typetag##_value = value;   \
-    return tre_stack_push(s, item); \
+#define define_pushf(typetag, type)  \
+  declare_pushf(typetag, type) {     \
+    union tre_stack_item item;	     \
+    item.typetag ## _value = value;  \
+    return tre_stack_push(s, item);  \
+}
+
+define_pushf(int, int)
+define_pushf(voidptr, void *)
+
+#define define_popf(typetag, type)		    \
+  declare_popf(typetag, type) {			    \
+    return s->stack[--s->ptr].typetag ## _value;    \
   }
 
-define_pushf(int, int) define_pushf(voidptr, void *)
-#define define_popf(typetag, type)             \
-  declare_popf(typetag, type) {                \
-    return s->stack[--s->ptr].typetag##_value; \
-  }
+define_popf(int, int)
+define_popf(voidptr, void *)
 
-    define_popf(int, int) define_popf(voidptr, void *)
 
-    /***********************************************************************
-     from tre-parse.c and tre-parse.h
-    ***********************************************************************/
+/***********************************************************************
+ from tre-parse.c and tre-parse.h
+***********************************************************************/
 
-    /* Parse context. */
-    typedef struct {
-  /* Memory allocator. The AST is allocated using this. */
-  tre_mem_t mem;
-  /* Stack used for keeping track of regexp syntax. */
-  tre_stack_t *stack;
-  /* The parsed node after a parse function returns. */
-  tre_ast_node_t *n;
-  /* Position in the regexp pattern after a parse function returns. */
-  const char *s;
-  /* The first character of the last subexpression parsed. */
-  const char *start;
-  /* Current submatch ID. */
-  int submatch_id;
-  /* Current position (number of literal). */
-  int position;
-  /* The highest back reference or -1 if none seen so far. */
-  int max_backref;
-  /* Compilation flags. */
-  int cflags;
+/* Parse context. */
+typedef struct {
+	/* Memory allocator. The AST is allocated using this. */
+	tre_mem_t mem;
+	/* Stack used for keeping track of regexp syntax. */
+	tre_stack_t *stack;
+	/* The parsed node after a parse function returns. */
+	tre_ast_node_t *n;
+	/* Position in the regexp pattern after a parse function returns. */
+	const char *s;
+	/* The first character of the last subexpression parsed. */
+	const char *start;
+	/* Current submatch ID. */
+	int submatch_id;
+	/* Current position (number of literal). */
+	int position;
+	/* The highest back reference or -1 if none seen so far. */
+	int max_backref;
+	/* Compilation flags. */
+	int cflags;
 } tre_parse_ctx_t;
 
 /* Some macros for expanding \w, \s, etc. */
 static const struct {
-  char c;
-  const char *expansion;
+	char c;
+	const char *expansion;
 } tre_macros[] = {
-    {'t', "\t"},
-    {'n', "\n"},
-    {'r', "\r"},
-    {'f', "\f"},
-    {'a', "\a"},
-    {'e', "\033"},
-    {'w', "[[:alnum:]_]"},
-    {'W', "[^[:alnum:]_]"},
-    {'s', "[[:space:]]"},
-    {'S', "[^[:space:]]"},
-    {'d', "[[:digit:]]"},
-    {'D', "[^[:digit:]]"},
-    {0, 0},
+	{'t', "\t"}, {'n', "\n"}, {'r', "\r"},
+	{'f', "\f"}, {'a', "\a"}, {'e', "\033"},
+	{'w', "[[:alnum:]_]"}, {'W', "[^[:alnum:]_]"}, {'s', "[[:space:]]"},
+	{'S', "[^[:space:]]"}, {'d', "[[:digit:]]"}, {'D', "[^[:digit:]]"},
+	{ 0, 0 }
 };
 
 /* Expands a macro delimited by `regex' and `regex_end' to `buf', which
    must have at least `len' items.  Sets buf[0] to zero if the there
    is no match in `tre_macros'. */
-static const char *tre_expand_macro(const char *s) {
-  int i;
-  for (i = 0; tre_macros[i].c && tre_macros[i].c != *s; i++)
-    ;
-  return tre_macros[i].expansion;
+static const char *tre_expand_macro(const char *s)
+{
+	int i;
+	for (i = 0; tre_macros[i].c && tre_macros[i].c != *s; i++);
+	return tre_macros[i].expansion;
 }
 
-static int tre_compare_lit(const void *a, const void *b) {
-  const tre_literal_t *const *la = a;
-  const tre_literal_t *const *lb = b;
-  /* assumes the range of valid code_min is < INT_MAX */
-  return la[0]->code_min - lb[0]->code_min;
+static int
+tre_compare_lit(const void *a, const void *b)
+{
+	const tre_literal_t *const *la = a;
+	const tre_literal_t *const *lb = b;
+	/* assumes the range of valid code_min is < INT_MAX */
+	return la[0]->code_min - lb[0]->code_min;
 }
 
 struct literals {
-  tre_mem_t mem;
-  tre_literal_t **a;
-  int len;
-  int cap;
+	tre_mem_t mem;
+	tre_literal_t **a;
+	int len;
+	int cap;
 };
 
-static tre_literal_t *tre_new_lit(struct literals *p) {
-  tre_literal_t **a;
-  if (p->len >= p->cap) {
-    if (p->cap >= 1 << 15) return 0;
-    p->cap *= 2;
-    a = realloc(p->a, p->cap * sizeof *p->a);
-    if (!a) return 0;
-    p->a = a;
-  }
-  a = p->a + p->len++;
-  *a = tre_mem_calloc(p->mem, sizeof **a);
-  return *a;
+static tre_literal_t *tre_new_lit(struct literals *p)
+{
+	tre_literal_t **a;
+	if (p->len >= p->cap) {
+		if (p->cap >= 1<<15)
+			return 0;
+		p->cap *= 2;
+		a = xrealloc(p->a, p->cap * sizeof *p->a);
+		if (!a)
+			return 0;
+		p->a = a;
+	}
+	a = p->a + p->len++;
+	*a = tre_mem_calloc(p->mem, sizeof **a);
+	return *a;
 }
 
-static int add_icase_literals(struct literals *ls, int min, int max) {
-  tre_literal_t *lit;
-  int b, e, c;
-  for (c = min; c <= max;) {
-    /* assumes islower(c) and isupper(c) are exclusive
-       and toupper(c)!=c if islower(c).
-       multiple opposite case characters are not supported */
-    if (tre_islower(c)) {
-      b = e = tre_toupper(c);
-      for (c++, e++; c <= max; c++, e++)
-        if (tre_toupper(c) != e) break;
-    } else if (tre_isupper(c)) {
-      b = e = tre_tolower(c);
-      for (c++, e++; c <= max; c++, e++)
-        if (tre_tolower(c) != e) break;
-    } else {
-      c++;
-      continue;
-    }
-    lit = tre_new_lit(ls);
-    if (!lit) return -1;
-    lit->code_min = b;
-    lit->code_max = e - 1;
-    lit->position = -1;
-  }
-  return 0;
+static int add_icase_literals(struct literals *ls, int min, int max)
+{
+	tre_literal_t *lit;
+	int b, e, c;
+	for (c=min; c<=max; ) {
+		/* assumes islower(c) and isupper(c) are exclusive
+		   and toupper(c)!=c if islower(c).
+		   multiple opposite case characters are not supported */
+		if (tre_islower(c)) {
+			b = e = tre_toupper(c);
+			for (c++, e++; c<=max; c++, e++)
+				if (tre_toupper(c) != e) break;
+		} else if (tre_isupper(c)) {
+			b = e = tre_tolower(c);
+			for (c++, e++; c<=max; c++, e++)
+				if (tre_tolower(c) != e) break;
+		} else {
+			c++;
+			continue;
+		}
+		lit = tre_new_lit(ls);
+		if (!lit)
+			return -1;
+		lit->code_min = b;
+		lit->code_max = e-1;
+		lit->position = -1;
+	}
+	return 0;
 }
 
+
 /* Maximum number of character classes in a negated bracket expression. */
 #define MAX_NEG_CLASSES 64
 
 struct neg {
-  int negate;
-  int len;
-  tre_ctype_t a[MAX_NEG_CLASSES];
+	int negate;
+	int len;
+	tre_ctype_t a[MAX_NEG_CLASSES];
 };
 
 // TODO: parse bracket into a set of non-overlapping [lo,hi] ranges
@@ -499,525 +555,565 @@ coll_single is a single char collating element but it can be
  '^' anywhere except after the openning '['
 */
 
-static reg_errcode_t parse_bracket_terms(tre_parse_ctx_t *ctx, const char *s,
-                                         struct literals *ls, struct neg *neg) {
-  const char *start = s;
-  tre_ctype_t class;
-  int min, max;
-  wchar_t wc;
-  int len;
+static reg_errcode_t parse_bracket_terms(tre_parse_ctx_t *ctx, const char *s, struct literals *ls, struct neg *neg)
+{
+	const char *start = s;
+	tre_ctype_t class;
+	int min, max;
+	wchar_t wc;
+	int len;
 
-  for (;;) {
-    class = 0;
-    len = mbtowc(&wc, s, -1);
-    if (len <= 0) return *s ? REG_BADPAT : REG_EBRACK;
-    if (*s == ']' && s != start) {
-      ctx->s = s + 1;
-      return REG_OK;
-    }
-    if (*s == '-' && s != start && s[1] != ']' &&
-        /* extension: [a-z--@] is accepted as [a-z]|[--@] */
-        (s[1] != '-' || s[2] == ']')) {
-      return REG_ERANGE;
-    }
-    if (*s == '[' && (s[1] == '.' || s[1] == '=')) {
-      /* collating symbols and equivalence classes are not supported */
-      return REG_ECOLLATE;
-    }
-    if (*s == '[' && s[1] == ':') {
-      char tmp[CHARCLASS_NAME_MAX + 1];
-      s += 2;
-      for (len = 0; len < CHARCLASS_NAME_MAX && s[len]; len++) {
-        if (s[len] == ':') {
-          memcpy(tmp, s, len);
-          tmp[len] = 0;
-          class = tre_ctype(tmp);
-          break;
-        }
-      }
-      if (!class || s[len + 1] != ']') return REG_ECTYPE;
-      min = 0;
-      max = TRE_CHAR_MAX;
-      s += len + 2;
-    } else {
-      min = max = wc;
-      s += len;
-      if (*s == '-' && s[1] != ']') {
-        s++;
-        len = mbtowc(&wc, s, -1);
-        max = wc;
-        /* XXX - Should use collation order instead of
-           encoding values in character ranges. */
-        if (len <= 0 || min > max) {
-          return REG_ERANGE;
-        }
-        s += len;
-      }
-    }
+	for (;;) {
+		class = 0;
+		len = mbtowc(&wc, s, -1);
+		if (len <= 0)
+			return *s ? REG_BADPAT : REG_EBRACK;
+		if (*s == ']' && s != start) {
+			ctx->s = s+1;
+			return REG_OK;
+		}
+		if (*s == '-' && s != start && s[1] != ']' &&
+		    /* extension: [a-z--@] is accepted as [a-z]|[--@] */
+		    (s[1] != '-' || s[2] == ']'))
+			return REG_ERANGE;
+		if (*s == '[' && (s[1] == '.' || s[1] == '='))
+			/* collating symbols and equivalence classes are not supported */
+			return REG_ECOLLATE;
+		if (*s == '[' && s[1] == ':') {
+			char tmp[CHARCLASS_NAME_MAX+1];
+			s += 2;
+			for (len=0; len < CHARCLASS_NAME_MAX && s[len]; len++) {
+				if (s[len] == ':') {
+					memcpy(tmp, s, len);
+					tmp[len] = 0;
+					class = tre_ctype(tmp);
+					break;
+				}
+			}
+			if (!class || s[len+1] != ']')
+				return REG_ECTYPE;
+			min = 0;
+			max = TRE_CHAR_MAX;
+			s += len+2;
+		} else {
+			min = max = wc;
+			s += len;
+			if (*s == '-' && s[1] != ']') {
+				s++;
+				len = mbtowc(&wc, s, -1);
+				max = wc;
+				/* XXX - Should use collation order instead of
+				   encoding values in character ranges. */
+				if (len <= 0 || min > max)
+					return REG_ERANGE;
+				s += len;
+			}
+		}
 
-    if (class && neg->negate) {
-      if (neg->len >= MAX_NEG_CLASSES) return REG_ESPACE;
-      neg->a[neg->len++] = class;
-    } else {
-      tre_literal_t *lit = tre_new_lit(ls);
-      if (!lit) return REG_ESPACE;
-      lit->code_min = min;
-      lit->code_max = max;
-      lit->class = class;
-      lit->position = -1;
+		if (class && neg->negate) {
+			if (neg->len >= MAX_NEG_CLASSES)
+				return REG_ESPACE;
+			neg->a[neg->len++] = class;
+		} else  {
+			tre_literal_t *lit = tre_new_lit(ls);
+			if (!lit)
+				return REG_ESPACE;
+			lit->code_min = min;
+			lit->code_max = max;
+			lit->class = class;
+			lit->position = -1;
 
-      /* Add opposite-case codepoints if REG_ICASE is present.
-         It seems that POSIX requires that bracket negation
-         should happen before case-folding, but most practical
-         implementations do it the other way around. Changing
-         the order would need efficient representation of
-         case-fold ranges and bracket range sets even with
-         simple patterns so this is ok for now. */
-      if (ctx->cflags & REG_ICASE && !class)
-        if (add_icase_literals(ls, min, max)) return REG_ESPACE;
-    }
-  }
+			/* Add opposite-case codepoints if REG_ICASE is present.
+			   It seems that POSIX requires that bracket negation
+			   should happen before case-folding, but most practical
+			   implementations do it the other way around. Changing
+			   the order would need efficient representation of
+			   case-fold ranges and bracket range sets even with
+			   simple patterns so this is ok for now. */
+			if (ctx->cflags & REG_ICASE && !class)
+				if (add_icase_literals(ls, min, max))
+					return REG_ESPACE;
+		}
+	}
 }
 
-static reg_errcode_t parse_bracket(tre_parse_ctx_t *ctx, const char *s) {
-  int i, max, min, negmax, negmin;
-  tre_ast_node_t *node = 0, *n;
-  tre_ctype_t *nc = 0;
-  tre_literal_t *lit;
-  struct literals ls;
-  struct neg neg;
-  reg_errcode_t err;
+static reg_errcode_t parse_bracket(tre_parse_ctx_t *ctx, const char *s)
+{
+	int i, max, min, negmax, negmin;
+	tre_ast_node_t *node = 0, *n;
+	tre_ctype_t *nc = 0;
+	tre_literal_t *lit;
+	struct literals ls;
+	struct neg neg;
+	reg_errcode_t err;
 
-  ls.mem = ctx->mem;
-  ls.len = 0;
-  ls.cap = 32;
-  ls.a = malloc(ls.cap * sizeof *ls.a);
-  if (!ls.a) return REG_ESPACE;
-  neg.len = 0;
-  neg.negate = *s == '^';
-  if (neg.negate) s++;
+	ls.mem = ctx->mem;
+	ls.len = 0;
+	ls.cap = 32;
+	ls.a = xmalloc(ls.cap * sizeof *ls.a);
+	if (!ls.a)
+		return REG_ESPACE;
+	neg.len = 0;
+	neg.negate = *s == '^';
+	if (neg.negate)
+		s++;
 
-  err = parse_bracket_terms(ctx, s, &ls, &neg);
-  if (err != REG_OK) goto parse_bracket_done;
+	err = parse_bracket_terms(ctx, s, &ls, &neg);
+	if (err != REG_OK)
+		goto parse_bracket_done;
 
-  if (neg.negate) {
-    /*
-     * With REG_NEWLINE, POSIX requires that newlines are not matched by
-     * any form of a non-matching list.
-     */
-    if (ctx->cflags & REG_NEWLINE) {
-      lit = tre_new_lit(&ls);
-      if (!lit) {
-        err = REG_ESPACE;
-        goto parse_bracket_done;
-      }
-      lit->code_min = '\n';
-      lit->code_max = '\n';
-      lit->position = -1;
-    }
-    /* Sort the array if we need to negate it. */
-    qsort(ls.a, ls.len, sizeof *ls.a, tre_compare_lit);
-    /* extra lit for the last negated range */
-    lit = tre_new_lit(&ls);
-    if (!lit) {
-      err = REG_ESPACE;
-      goto parse_bracket_done;
-    }
-    lit->code_min = TRE_CHAR_MAX + 1;
-    lit->code_max = TRE_CHAR_MAX + 1;
-    lit->position = -1;
-    /* negated classes */
-    if (neg.len) {
-      nc = tre_mem_alloc(ctx->mem, (neg.len + 1) * sizeof *neg.a);
-      if (!nc) {
-        err = REG_ESPACE;
-        goto parse_bracket_done;
-      }
-      memcpy(nc, neg.a, neg.len * sizeof *neg.a);
-      nc[neg.len] = 0;
-    }
-  }
+	if (neg.negate) {
+		/*
+		 * With REG_NEWLINE, POSIX requires that newlines are not matched by
+		 * any form of a non-matching list.
+		 */
+		if (ctx->cflags & REG_NEWLINE) {
+			lit = tre_new_lit(&ls);
+			if (!lit) {
+				err = REG_ESPACE;
+				goto parse_bracket_done;
+			}
+			lit->code_min = '\n';
+			lit->code_max = '\n';
+			lit->position = -1;
+		}
+		/* Sort the array if we need to negate it. */
+		qsort(ls.a, ls.len, sizeof *ls.a, tre_compare_lit);
+		/* extra lit for the last negated range */
+		lit = tre_new_lit(&ls);
+		if (!lit) {
+			err = REG_ESPACE;
+			goto parse_bracket_done;
+		}
+		lit->code_min = TRE_CHAR_MAX+1;
+		lit->code_max = TRE_CHAR_MAX+1;
+		lit->position = -1;
+		/* negated classes */
+		if (neg.len) {
+			nc = tre_mem_alloc(ctx->mem, (neg.len+1)*sizeof *neg.a);
+			if (!nc) {
+				err = REG_ESPACE;
+				goto parse_bracket_done;
+			}
+			memcpy(nc, neg.a, neg.len*sizeof *neg.a);
+			nc[neg.len] = 0;
+		}
+	}
 
-  /* Build a union of the items in the array, negated if necessary. */
-  negmax = negmin = 0;
-  for (i = 0; i < ls.len; i++) {
-    lit = ls.a[i];
-    min = lit->code_min;
-    max = lit->code_max;
-    if (neg.negate) {
-      if (min <= negmin) {
-        /* Overlap. */
-        negmin = MAX(max + 1, negmin);
-        continue;
-      }
-      negmax = min - 1;
-      lit->code_min = negmin;
-      lit->code_max = negmax;
-      negmin = max + 1;
-    }
-    lit->position = ctx->position;
-    lit->neg_classes = nc;
-    n = tre_ast_new_node(ctx->mem, LITERAL, lit);
-    node = tre_ast_new_union(ctx->mem, node, n);
-    if (!node) {
-      err = REG_ESPACE;
-      break;
-    }
-  }
+	/* Build a union of the items in the array, negated if necessary. */
+	negmax = negmin = 0;
+	for (i = 0; i < ls.len; i++) {
+		lit = ls.a[i];
+		min = lit->code_min;
+		max = lit->code_max;
+		if (neg.negate) {
+			if (min <= negmin) {
+				/* Overlap. */
+				negmin = MAX(max + 1, negmin);
+				continue;
+			}
+			negmax = min - 1;
+			lit->code_min = negmin;
+			lit->code_max = negmax;
+			negmin = max + 1;
+		}
+		lit->position = ctx->position;
+		lit->neg_classes = nc;
+		n = tre_ast_new_node(ctx->mem, LITERAL, lit);
+		node = tre_ast_new_union(ctx->mem, node, n);
+		if (!node) {
+			err = REG_ESPACE;
+			break;
+		}
+	}
 
 parse_bracket_done:
-  free(ls.a), ls.a = NULL;
-  ctx->position++;
-  ctx->n = node;
-  return err;
+	xfree(ls.a);
+	ctx->position++;
+	ctx->n = node;
+	return err;
 }
 
-static const char *parse_dup_count(const char *s, int *n) {
-  *n = -1;
-  if (!isdigit(*s)) return s;
-  *n = 0;
-  for (;;) {
-    *n = 10 * *n + (*s - '0');
-    s++;
-    if (!isdigit(*s) || *n > RE_DUP_MAX) break;
-  }
-  return s;
+static const char *parse_dup_count(const char *s, int *n)
+{
+	*n = -1;
+	if (!isdigit(*s))
+		return s;
+	*n = 0;
+	for (;;) {
+		*n = 10 * *n + (*s - '0');
+		s++;
+		if (!isdigit(*s) || *n > RE_DUP_MAX)
+			break;
+	}
+	return s;
 }
 
-static const char *parse_dup(const char *s, int ere, int *pmin, int *pmax) {
-  int min, max;
+static const char *parse_dup(const char *s, int ere, int *pmin, int *pmax)
+{
+	int min, max;
 
-  s = parse_dup_count(s, &min);
-  if (*s == ',')
-    s = parse_dup_count(s + 1, &max);
-  else
-    max = min;
+	s = parse_dup_count(s, &min);
+	if (*s == ',')
+		s = parse_dup_count(s+1, &max);
+	else
+		max = min;
 
-  if ((max < min && max >= 0) || max > RE_DUP_MAX || min > RE_DUP_MAX ||
-      min < 0 || (!ere && *s++ != '\\') || *s++ != '}')
-    return 0;
-  *pmin = min;
-  *pmax = max;
-  return s;
+	if (
+		(max < min && max >= 0) ||
+		max > RE_DUP_MAX ||
+		min > RE_DUP_MAX ||
+		min < 0 ||
+		(!ere && *s++ != '\\') ||
+		*s++ != '}'
+	)
+		return 0;
+	*pmin = min;
+	*pmax = max;
+	return s;
 }
 
-static int hexval(unsigned c) {
-  if (c - '0' < 10) return c - '0';
-  c |= 32;
-  if (c - 'a' < 6) return c - 'a' + 10;
-  return -1;
+static int hexval(unsigned c)
+{
+	if (c-'0'<10) return c-'0';
+	c |= 32;
+	if (c-'a'<6) return c-'a'+10;
+	return -1;
 }
 
-static reg_errcode_t marksub(tre_parse_ctx_t *ctx, tre_ast_node_t *node,
-                             int subid) {
-  if (node->submatch_id >= 0) {
-    tre_ast_node_t *n = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
-    if (!n) return REG_ESPACE;
-    n = tre_ast_new_catenation(ctx->mem, n, node);
-    if (!n) return REG_ESPACE;
-    n->num_submatches = node->num_submatches;
-    node = n;
-  }
-  node->submatch_id = subid;
-  node->num_submatches++;
-  ctx->n = node;
-  return REG_OK;
+static reg_errcode_t marksub(tre_parse_ctx_t *ctx, tre_ast_node_t *node, int subid)
+{
+	if (node->submatch_id >= 0) {
+		tre_ast_node_t *n = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
+		if (!n)
+			return REG_ESPACE;
+		n = tre_ast_new_catenation(ctx->mem, n, node);
+		if (!n)
+			return REG_ESPACE;
+		n->num_submatches = node->num_submatches;
+		node = n;
+	}
+	node->submatch_id = subid;
+	node->num_submatches++;
+	ctx->n = node;
+	return REG_OK;
 }
 
 /*
 BRE grammar:
-Regex  =  Branch  |  '^'  |  '$'  |  '^$'  |  '^' Branch  |  Branch '$'  |  '^'
-Branch '$' Branch =  Atom  |  Branch Atom Atom   =  char  |  quoted_char  |  '.'
-|  Bracket  |  Atom Dup  |  '\(' Branch '\)'  |  back_ref Dup    =  '*'  |  '\{'
-Count '\}'  |  '\{' Count ',\}'  |  '\{' Count ',' Count '\}'
+Regex  =  Branch  |  '^'  |  '$'  |  '^$'  |  '^' Branch  |  Branch '$'  |  '^' Branch '$'
+Branch =  Atom  |  Branch Atom
+Atom   =  char  |  quoted_char  |  '.'  |  Bracket  |  Atom Dup  |  '\(' Branch '\)'  |  back_ref
+Dup    =  '*'  |  '\{' Count '\}'  |  '\{' Count ',\}'  |  '\{' Count ',' Count '\}'
 
 (leading ^ and trailing $ in a sub expr may be an anchor or literal as well)
 
 ERE grammar:
 Regex  =  Branch  |  Regex '|' Branch
 Branch =  Atom  |  Branch Atom
-Atom   =  char  |  quoted_char  |  '.'  |  Bracket  |  Atom Dup  |  '(' Regex
-')'  |  '^'  |  '$' Dup    =  '*'  |  '+'  |  '?'  |  '{' Count '}'  |  '{'
-Count ',}'  |  '{' Count ',' Count '}'
+Atom   =  char  |  quoted_char  |  '.'  |  Bracket  |  Atom Dup  |  '(' Regex ')'  |  '^'  |  '$'
+Dup    =  '*'  |  '+'  |  '?'  |  '{' Count '}'  |  '{' Count ',}'  |  '{' Count ',' Count '}'
 
 (a*+?, ^*, $+, \X, {, (|a) are unspecified)
 */
 
-static reg_errcode_t parse_atom(tre_parse_ctx_t *ctx, const char *s) {
-  int len, ere = ctx->cflags & REG_EXTENDED;
-  const char *p;
-  tre_ast_node_t *node;
-  wchar_t wc;
-  switch (*s) {
-    case '[':
-      return parse_bracket(ctx, s + 1);
-    case '\\':
-      p = tre_expand_macro(s + 1);
-      if (p) {
-        /* assume \X expansion is a single atom */
-        reg_errcode_t err = parse_atom(ctx, p);
-        ctx->s = s + 2;
-        return err;
-      }
-      /* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */
-      switch (*++s) {
-        case 0:
-          return REG_EESCAPE;
-        case 'b':
-          node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_WB, -1);
-          break;
-        case 'B':
-          node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_WB_NEG, -1);
-          break;
-        case '<':
-          node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_BOW, -1);
-          break;
-        case '>':
-          node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_EOW, -1);
-          break;
-        case 'x':
-          s++;
-          int i, v = 0, c;
-          len = 2;
-          if (*s == '{') {
-            len = 8;
-            s++;
-          }
-          for (i = 0; i < len && v < 0x110000; i++) {
-            c = hexval(s[i]);
-            if (c < 0) break;
-            v = 16 * v + c;
-          }
-          s += i;
-          if (len == 8) {
-            if (*s != '}') return REG_EBRACE;
-            s++;
-          }
-          node = tre_ast_new_literal(ctx->mem, v, v, ctx->position++);
-          s--;
-          break;
-        case '{':
-        case '+':
-        case '?':
-          /* extension: treat \+, \? as repetitions in BRE */
-          /* reject repetitions after empty expression in BRE */
-          if (!ere) return REG_BADRPT;
-          /* fallthrough */
-        case '|':
-          /* extension: treat \| as alternation in BRE */
-          if (!ere) {
-            node = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
-            s--;
-            goto end;
-          }
-          /* fallthrough */
-        default:
-          if (!ere && (unsigned)*s - '1' < 9) {
-            /* back reference */
-            int val = *s - '0';
-            node = tre_ast_new_literal(ctx->mem, BACKREF, val, ctx->position++);
-            ctx->max_backref = MAX(val, ctx->max_backref);
-          } else {
-            /* extension: accept unknown escaped char
-               as a literal */
-            goto parse_literal;
-          }
-      }
-      s++;
-      break;
-    case '.':
-      if (ctx->cflags & REG_NEWLINE) {
-        tre_ast_node_t *tmp1, *tmp2;
-        tmp1 = tre_ast_new_literal(ctx->mem, 0, '\n' - 1, ctx->position++);
-        tmp2 = tre_ast_new_literal(ctx->mem, '\n' + 1, TRE_CHAR_MAX,
-                                   ctx->position++);
-        if (tmp1 && tmp2)
-          node = tre_ast_new_union(ctx->mem, tmp1, tmp2);
-        else
-          node = 0;
-      } else {
-        node = tre_ast_new_literal(ctx->mem, 0, TRE_CHAR_MAX, ctx->position++);
-      }
-      s++;
-      break;
-    case '^':
-      /* '^' has a special meaning everywhere in EREs, and at beginning of BRE.
-       */
-      if (!ere && s != ctx->start) goto parse_literal;
-      node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_BOL, -1);
-      s++;
-      break;
-    case '$':
-      /* '$' is special everywhere in EREs, and at the end of a BRE
-       * subexpression. */
-      if (!ere && s[1] && (s[1] != '\\' || (s[2] != ')' && s[2] != '|')))
-        goto parse_literal;
-      node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_EOL, -1);
-      s++;
-      break;
-    case '*':
-    case '{':
-    case '+':
-    case '?':
-      /* reject repetitions after empty expression in ERE */
-      if (ere) return REG_BADRPT;
-      /* fallthrough */
-    case '|':
-      if (!ere) goto parse_literal;
-      /* fallthrough */
-    case 0:
-      node = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
-      break;
-    default:
-    parse_literal:
-      len = mbtowc(&wc, s, -1);
-      if (len < 0) return REG_BADPAT;
-      if (ctx->cflags & REG_ICASE && (tre_isupper(wc) || tre_islower(wc))) {
-        tre_ast_node_t *tmp1, *tmp2;
-        /* multiple opposite case characters are not supported */
-        tmp1 = tre_ast_new_literal(ctx->mem, tre_toupper(wc), tre_toupper(wc),
-                                   ctx->position);
-        tmp2 = tre_ast_new_literal(ctx->mem, tre_tolower(wc), tre_tolower(wc),
-                                   ctx->position);
-        if (tmp1 && tmp2)
-          node = tre_ast_new_union(ctx->mem, tmp1, tmp2);
-        else
-          node = 0;
-      } else {
-        node = tre_ast_new_literal(ctx->mem, wc, wc, ctx->position);
-      }
-      ctx->position++;
-      s += len;
-      break;
-  }
+static reg_errcode_t parse_atom(tre_parse_ctx_t *ctx, const char *s)
+{
+	int len, ere = ctx->cflags & REG_EXTENDED;
+	const char *p;
+	tre_ast_node_t *node;
+	wchar_t wc;
+	switch (*s) {
+	case '[':
+		return parse_bracket(ctx, s+1);
+	case '\\':
+		p = tre_expand_macro(s+1);
+		if (p) {
+			/* assume \X expansion is a single atom */
+			reg_errcode_t err = parse_atom(ctx, p);
+			ctx->s = s+2;
+			return err;
+		}
+		/* extensions: \b, \B, \<, \>, \xHH \x{HHHH} */
+		switch (*++s) {
+		case 0:
+			return REG_EESCAPE;
+		case 'b':
+			node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_WB, -1);
+			break;
+		case 'B':
+			node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_WB_NEG, -1);
+			break;
+		case '<':
+			node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_BOW, -1);
+			break;
+		case '>':
+			node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_EOW, -1);
+			break;
+		case 'x':
+			s++;
+			int i, v = 0, c;
+			len = 2;
+			if (*s == '{') {
+				len = 8;
+				s++;
+			}
+			for (i=0; i<len && v<0x110000; i++) {
+				c = hexval(s[i]);
+				if (c < 0) break;
+				v = 16*v + c;
+			}
+			s += i;
+			if (len == 8) {
+				if (*s != '}')
+					return REG_EBRACE;
+				s++;
+			}
+			node = tre_ast_new_literal(ctx->mem, v, v, ctx->position++);
+			s--;
+			break;
+		case '{':
+		case '+':
+		case '?':
+			/* extension: treat \+, \? as repetitions in BRE */
+			/* reject repetitions after empty expression in BRE */
+			if (!ere)
+				return REG_BADRPT;
+		case '|':
+			/* extension: treat \| as alternation in BRE */
+			if (!ere) {
+				node = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
+				s--;
+				goto end;
+			}
+			/* fallthrough */
+		default:
+			if (!ere && (unsigned)*s-'1' < 9) {
+				/* back reference */
+				int val = *s - '0';
+				node = tre_ast_new_literal(ctx->mem, BACKREF, val, ctx->position++);
+				ctx->max_backref = MAX(val, ctx->max_backref);
+			} else {
+				/* extension: accept unknown escaped char
+				   as a literal */
+				goto parse_literal;
+			}
+		}
+		s++;
+		break;
+	case '.':
+		if (ctx->cflags & REG_NEWLINE) {
+			tre_ast_node_t *tmp1, *tmp2;
+			tmp1 = tre_ast_new_literal(ctx->mem, 0, '\n'-1, ctx->position++);
+			tmp2 = tre_ast_new_literal(ctx->mem, '\n'+1, TRE_CHAR_MAX, ctx->position++);
+			if (tmp1 && tmp2)
+				node = tre_ast_new_union(ctx->mem, tmp1, tmp2);
+			else
+				node = 0;
+		} else {
+			node = tre_ast_new_literal(ctx->mem, 0, TRE_CHAR_MAX, ctx->position++);
+		}
+		s++;
+		break;
+	case '^':
+		/* '^' has a special meaning everywhere in EREs, and at beginning of BRE. */
+		if (!ere && s != ctx->start)
+			goto parse_literal;
+		node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_BOL, -1);
+		s++;
+		break;
+	case '$':
+		/* '$' is special everywhere in EREs, and at the end of a BRE subexpression. */
+		if (!ere && s[1] && (s[1]!='\\'|| (s[2]!=')' && s[2]!='|')))
+			goto parse_literal;
+		node = tre_ast_new_literal(ctx->mem, ASSERTION, ASSERT_AT_EOL, -1);
+		s++;
+		break;
+	case '*':
+	case '{':
+	case '+':
+	case '?':
+		/* reject repetitions after empty expression in ERE */
+		if (ere)
+			return REG_BADRPT;
+	case '|':
+		if (!ere)
+			goto parse_literal;
+	case 0:
+		node = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
+		break;
+	default:
+parse_literal:
+		len = mbtowc(&wc, s, -1);
+		if (len < 0)
+			return REG_BADPAT;
+		if (ctx->cflags & REG_ICASE && (tre_isupper(wc) || tre_islower(wc))) {
+			tre_ast_node_t *tmp1, *tmp2;
+			/* multiple opposite case characters are not supported */
+			tmp1 = tre_ast_new_literal(ctx->mem, tre_toupper(wc), tre_toupper(wc), ctx->position);
+			tmp2 = tre_ast_new_literal(ctx->mem, tre_tolower(wc), tre_tolower(wc), ctx->position);
+			if (tmp1 && tmp2)
+				node = tre_ast_new_union(ctx->mem, tmp1, tmp2);
+			else
+				node = 0;
+		} else {
+			node = tre_ast_new_literal(ctx->mem, wc, wc, ctx->position);
+		}
+		ctx->position++;
+		s += len;
+		break;
+	}
 end:
-  if (!node) return REG_ESPACE;
-  ctx->n = node;
-  ctx->s = s;
-  return REG_OK;
+	if (!node)
+		return REG_ESPACE;
+	ctx->n = node;
+	ctx->s = s;
+	return REG_OK;
 }
 
-#define PUSHPTR(err, s, v)                                          \
-  do {                                                              \
-    if ((err = tre_stack_push_voidptr(s, v)) != REG_OK) return err; \
-  } while (0)
+#define PUSHPTR(err, s, v) do { \
+	if ((err = tre_stack_push_voidptr(s, v)) != REG_OK) \
+		return err; \
+} while(0)
 
-#define PUSHINT(err, s, v)                                      \
-  do {                                                          \
-    if ((err = tre_stack_push_int(s, v)) != REG_OK) return err; \
-  } while (0)
+#define PUSHINT(err, s, v) do { \
+	if ((err = tre_stack_push_int(s, v)) != REG_OK) \
+		return err; \
+} while(0)
 
-static reg_errcode_t tre_parse(tre_parse_ctx_t *ctx) {
-  tre_ast_node_t *nbranch = 0, *nunion = 0;
-  int ere = ctx->cflags & REG_EXTENDED;
-  const char *s = ctx->start;
-  int subid = 0;
-  int depth = 0;
-  reg_errcode_t err;
-  tre_stack_t *stack = ctx->stack;
+static reg_errcode_t tre_parse(tre_parse_ctx_t *ctx)
+{
+	tre_ast_node_t *nbranch=0, *nunion=0;
+	int ere = ctx->cflags & REG_EXTENDED;
+	const char *s = ctx->start;
+	int subid = 0;
+	int depth = 0;
+	reg_errcode_t err;
+	tre_stack_t *stack = ctx->stack;
 
-  PUSHINT(err, stack, subid++);
-  for (;;) {
-    if ((!ere && *s == '\\' && s[1] == '(') || (ere && *s == '(')) {
-      PUSHPTR(err, stack, nunion);
-      PUSHPTR(err, stack, nbranch);
-      PUSHINT(err, stack, subid++);
-      s++;
-      if (!ere) s++;
-      depth++;
-      nbranch = nunion = 0;
-      ctx->start = s;
-      continue;
-    }
-    if ((!ere && *s == '\\' && s[1] == ')') || (ere && *s == ')' && depth)) {
-      ctx->n = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
-      if (!ctx->n) return REG_ESPACE;
-    } else {
-      err = parse_atom(ctx, s);
-      if (err != REG_OK) return err;
-      s = ctx->s;
-    }
+	PUSHINT(err, stack, subid++);
+	for (;;) {
+		if ((!ere && *s == '\\' && s[1] == '(') ||
+		    (ere && *s == '(')) {
+			PUSHPTR(err, stack, nunion);
+			PUSHPTR(err, stack, nbranch);
+			PUSHINT(err, stack, subid++);
+			s++;
+			if (!ere)
+				s++;
+			depth++;
+			nbranch = nunion = 0;
+			ctx->start = s;
+			continue;
+		}
+		if ((!ere && *s == '\\' && s[1] == ')') ||
+		    (ere && *s == ')' && depth)) {
+			ctx->n = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
+			if (!ctx->n)
+				return REG_ESPACE;
+		} else {
+			err = parse_atom(ctx, s);
+			if (err != REG_OK)
+				return err;
+			s = ctx->s;
+		}
 
-  parse_iter:
-    for (;;) {
-      int min, max;
+	parse_iter:
+		for (;;) {
+			int min, max;
 
-      if (*s != '\\' && *s != '*') {
-        if (!ere) break;
-        if (*s != '+' && *s != '?' && *s != '{') break;
-      }
-      if (*s == '\\' && ere) break;
-      /* extension: treat \+, \? as repetitions in BRE */
-      if (*s == '\\' && s[1] != '+' && s[1] != '?' && s[1] != '{') break;
-      if (*s == '\\') s++;
+			if (*s!='\\' && *s!='*') {
+				if (!ere)
+					break;
+				if (*s!='+' && *s!='?' && *s!='{')
+					break;
+			}
+			if (*s=='\\' && ere)
+				break;
+			/* extension: treat \+, \? as repetitions in BRE */
+			if (*s=='\\' && s[1]!='+' && s[1]!='?' && s[1]!='{')
+				break;
+			if (*s=='\\')
+				s++;
 
-      /* handle ^* at the start of a BRE. */
-      if (!ere && s == ctx->start + 1 && s[-1] == '^') break;
+			/* handle ^* at the start of a BRE. */
+			if (!ere && s==ctx->start+1 && s[-1]=='^')
+				break;
 
-      /* extension: multiple consecutive *+?{,} is unspecified,
-         but (a+)+ has to be supported so accepting a++ makes
-         sense, note however that the RE_DUP_MAX limit can be
-         circumvented: (a{255}){255} uses a lot of memory.. */
-      if (*s == '{') {
-        s = parse_dup(s + 1, ere, &min, &max);
-        if (!s) return REG_BADBR;
-      } else {
-        min = 0;
-        max = -1;
-        if (*s == '+') min = 1;
-        if (*s == '?') max = 1;
-        s++;
-      }
-      if (max == 0)
-        ctx->n = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
-      else
-        ctx->n = tre_ast_new_iter(ctx->mem, ctx->n, min, max, 0);
-      if (!ctx->n) return REG_ESPACE;
-    }
+			/* extension: multiple consecutive *+?{,} is unspecified,
+			   but (a+)+ has to be supported so accepting a++ makes
+			   sense, note however that the RE_DUP_MAX limit can be
+			   circumvented: (a{255}){255} uses a lot of memory.. */
+			if (*s=='{') {
+				s = parse_dup(s+1, ere, &min, &max);
+				if (!s)
+					return REG_BADBR;
+			} else {
+				min=0;
+				max=-1;
+				if (*s == '+')
+					min = 1;
+				if (*s == '?')
+					max = 1;
+				s++;
+			}
+			if (max == 0)
+				ctx->n = tre_ast_new_literal(ctx->mem, EMPTY, -1, -1);
+			else
+				ctx->n = tre_ast_new_iter(ctx->mem, ctx->n, min, max, 0);
+			if (!ctx->n)
+				return REG_ESPACE;
+		}
 
-    nbranch = tre_ast_new_catenation(ctx->mem, nbranch, ctx->n);
-    if ((ere && *s == '|') || (ere && *s == ')' && depth) ||
-        (!ere && *s == '\\' && s[1] == ')') ||
-        /* extension: treat \| as alternation in BRE */
-        (!ere && *s == '\\' && s[1] == '|') || !*s) {
-      /* extension: empty branch is unspecified (), (|a), (a|)
-         here they are not rejected but match on empty string */
-      int c = *s;
-      nunion = tre_ast_new_union(ctx->mem, nunion, nbranch);
-      nbranch = 0;
+		nbranch = tre_ast_new_catenation(ctx->mem, nbranch, ctx->n);
+		if ((ere && *s == '|') ||
+		    (ere && *s == ')' && depth) ||
+		    (!ere && *s == '\\' && s[1] == ')') ||
+		    /* extension: treat \| as alternation in BRE */
+		    (!ere && *s == '\\' && s[1] == '|') ||
+		    !*s) {
+			/* extension: empty branch is unspecified (), (|a), (a|)
+			   here they are not rejected but match on empty string */
+			int c = *s;
+			nunion = tre_ast_new_union(ctx->mem, nunion, nbranch);
+			nbranch = 0;
 
-      if (c == '\\' && s[1] == '|') {
-        s += 2;
-        ctx->start = s;
-      } else if (c == '|') {
-        s++;
-        ctx->start = s;
-      } else {
-        if (c == '\\') {
-          if (!depth) return REG_EPAREN;
-          s += 2;
-        } else if (c == ')')
-          s++;
-        depth--;
-        err = marksub(ctx, nunion, tre_stack_pop_int(stack));
-        if (err != REG_OK) return err;
-        if (!c && depth < 0) {
-          ctx->submatch_id = subid;
-          return REG_OK;
-        }
-        if (!c || depth < 0) return REG_EPAREN;
-        nbranch = tre_stack_pop_voidptr(stack);
-        nunion = tre_stack_pop_voidptr(stack);
-        goto parse_iter;
-      }
-    }
-  }
+			if (c == '\\' && s[1] == '|') {
+				s+=2;
+				ctx->start = s;
+			} else if (c == '|') {
+				s++;
+				ctx->start = s;
+			} else {
+				if (c == '\\') {
+					if (!depth) return REG_EPAREN;
+					s+=2;
+				} else if (c == ')')
+					s++;
+				depth--;
+				err = marksub(ctx, nunion, tre_stack_pop_int(stack));
+				if (err != REG_OK)
+					return err;
+				if (!c && depth<0) {
+					ctx->submatch_id = subid;
+					return REG_OK;
+				}
+				if (!c || depth<0)
+					return REG_EPAREN;
+				nbranch = tre_stack_pop_voidptr(stack);
+				nunion = tre_stack_pop_voidptr(stack);
+				goto parse_iter;
+			}
+		}
+	}
 }
 
+
 /***********************************************************************
  from tre-compile.c
 ***********************************************************************/
 
+
 /*
   TODO:
    - Fix tre_ast_to_tnfa() to recurse using a stack instead of recursive
@@ -1028,19 +1124,24 @@ static reg_errcode_t tre_parse(tre_parse_ctx_t *ctx) {
   Algorithms to setup tags so that submatch addressing can be done.
 */
 
+
 /* Inserts a catenation node to the root of the tree given in `node'.
    As the left child a new tag with number `tag_id' to `node' is added,
    and the right child is the old root. */
-static reg_errcode_t tre_add_tag_left(tre_mem_t mem, tre_ast_node_t *node,
-                                      int tag_id) {
+static reg_errcode_t
+tre_add_tag_left(tre_mem_t mem, tre_ast_node_t *node, int tag_id)
+{
   tre_catenation_t *c;
 
   c = tre_mem_alloc(mem, sizeof(*c));
-  if (c == NULL) return REG_ESPACE;
+  if (c == NULL)
+    return REG_ESPACE;
   c->left = tre_ast_new_literal(mem, TAG, tag_id, -1);
-  if (c->left == NULL) return REG_ESPACE;
+  if (c->left == NULL)
+    return REG_ESPACE;
   c->right = tre_mem_alloc(mem, sizeof(tre_ast_node_t));
-  if (c->right == NULL) return REG_ESPACE;
+  if (c->right == NULL)
+    return REG_ESPACE;
 
   c->right->obj = node->obj;
   c->right->type = node->type;
@@ -1058,16 +1159,20 @@ static reg_errcode_t tre_add_tag_left(tre_mem_t mem, tre_ast_node_t *node,
 /* Inserts a catenation node to the root of the tree given in `node'.
    As the right child a new tag with number `tag_id' to `node' is added,
    and the left child is the old root. */
-static reg_errcode_t tre_add_tag_right(tre_mem_t mem, tre_ast_node_t *node,
-                                       int tag_id) {
+static reg_errcode_t
+tre_add_tag_right(tre_mem_t mem, tre_ast_node_t *node, int tag_id)
+{
   tre_catenation_t *c;
 
   c = tre_mem_alloc(mem, sizeof(*c));
-  if (c == NULL) return REG_ESPACE;
+  if (c == NULL)
+    return REG_ESPACE;
   c->right = tre_ast_new_literal(mem, TAG, tag_id, -1);
-  if (c->right == NULL) return REG_ESPACE;
+  if (c->right == NULL)
+    return REG_ESPACE;
   c->left = tre_mem_alloc(mem, sizeof(tre_ast_node_t));
-  if (c->left == NULL) return REG_ESPACE;
+  if (c->left == NULL)
+    return REG_ESPACE;
 
   c->left->obj = node->obj;
   c->left->type = node->type;
@@ -1092,31 +1197,39 @@ typedef enum {
   ADDTAGS_SET_SUBMATCH_END
 } tre_addtags_symbol_t;
 
+
 typedef struct {
   int tag;
   int next_tag;
 } tre_tag_states_t;
 
+
 /* Go through `regset' and set submatch data for submatches that are
    using this tag. */
-static void tre_purge_regset(int *regset, tre_tnfa_t *tnfa, int tag) {
+static void
+tre_purge_regset(int *regset, tre_tnfa_t *tnfa, int tag)
+{
   int i;
 
-  for (i = 0; regset[i] >= 0; i++) {
-    int id = regset[i] / 2;
-    int start = !(regset[i] % 2);
-    if (start)
-      tnfa->submatch_data[id].so_tag = tag;
-    else
-      tnfa->submatch_data[id].eo_tag = tag;
-  }
+  for (i = 0; regset[i] >= 0; i++)
+    {
+      int id = regset[i] / 2;
+      int start = !(regset[i] % 2);
+      if (start)
+	tnfa->submatch_data[id].so_tag = tag;
+      else
+	tnfa->submatch_data[id].eo_tag = tag;
+    }
   regset[0] = -1;
 }
 
+
 /* Adds tags to appropriate locations in the parse tree in `tree', so that
    subexpressions marked for submatch addressing can be traced. */
-static reg_errcode_t tre_add_tags(tre_mem_t mem, tre_stack_t *stack,
-                                  tre_ast_node_t *tree, tre_tnfa_t *tnfa) {
+static reg_errcode_t
+tre_add_tags(tre_mem_t mem, tre_stack_t *stack, tre_ast_node_t *tree,
+	     tre_tnfa_t *tnfa)
+{
   reg_errcode_t status = REG_OK;
   tre_addtags_symbol_t symbol;
   tre_ast_node_t *node = tree; /* Tree node we are currently looking at. */
@@ -1124,422 +1237,484 @@ static reg_errcode_t tre_add_tags(tre_mem_t mem, tre_stack_t *stack,
   /* True for first pass (counting number of needed tags) */
   int first_pass = (mem == NULL || tnfa == NULL);
   int *regset, *orig_regset;
-  int num_tags = 0;     /* Total number of tags. */
-  int num_minimals = 0; /* Number of special minimal tags. */
-  int tag = 0;          /* The tag that is to be added next. */
-  int next_tag = 1;     /* Next tag to use after this one. */
-  int *parents;         /* Stack of submatches the current submatch is
-                           contained in. */
+  int num_tags = 0; /* Total number of tags. */
+  int num_minimals = 0;	 /* Number of special minimal tags. */
+  int tag = 0;	    /* The tag that is to be added next. */
+  int next_tag = 1; /* Next tag to use after this one. */
+  int *parents;	    /* Stack of submatches the current submatch is
+		       contained in. */
   int minimal_tag = -1; /* Tag that marks the beginning of a minimal match. */
   tre_tag_states_t *saved_states;
 
   tre_tag_direction_t direction = TRE_TAG_MINIMIZE;
-  if (!first_pass) {
-    tnfa->end_tag = 0;
-    tnfa->minimal_tags[0] = -1;
-  }
+  if (!first_pass)
+    {
+      tnfa->end_tag = 0;
+      tnfa->minimal_tags[0] = -1;
+    }
 
-  regset = malloc(sizeof(*regset) * ((tnfa->num_submatches + 1) * 2));
-  if (regset == NULL) return REG_ESPACE;
+  regset = xmalloc(sizeof(*regset) * ((tnfa->num_submatches + 1) * 2));
+  if (regset == NULL)
+    return REG_ESPACE;
   regset[0] = -1;
   orig_regset = regset;
 
-  parents = malloc(sizeof(*parents) * (tnfa->num_submatches + 1));
-  if (parents == NULL) {
-    free(regset), regset = NULL;
-    return REG_ESPACE;
-  }
+  parents = xmalloc(sizeof(*parents) * (tnfa->num_submatches + 1));
+  if (parents == NULL)
+    {
+      xfree(regset);
+      return REG_ESPACE;
+    }
   parents[0] = -1;
 
-  saved_states = malloc(sizeof(*saved_states) * (tnfa->num_submatches + 1));
-  if (saved_states == NULL) {
-    free(regset), regset = NULL;
-    free(parents), parents = NULL;
-    return REG_ESPACE;
-  } else {
-    unsigned int i;
-    for (i = 0; i <= tnfa->num_submatches; i++) saved_states[i].tag = -1;
-  }
+  saved_states = xmalloc(sizeof(*saved_states) * (tnfa->num_submatches + 1));
+  if (saved_states == NULL)
+    {
+      xfree(regset);
+      xfree(parents);
+      return REG_ESPACE;
+    }
+  else
+    {
+      unsigned int i;
+      for (i = 0; i <= tnfa->num_submatches; i++)
+	saved_states[i].tag = -1;
+    }
 
   STACK_PUSH(stack, voidptr, node);
   STACK_PUSH(stack, int, ADDTAGS_RECURSE);
 
-  while (tre_stack_num_objects(stack) > bottom) {
-    if (status != REG_OK) break;
+  while (tre_stack_num_objects(stack) > bottom)
+    {
+      if (status != REG_OK)
+	break;
 
-    symbol = (tre_addtags_symbol_t)tre_stack_pop_int(stack);
-    switch (symbol) {
-      case ADDTAGS_SET_SUBMATCH_END: {
-        int id = tre_stack_pop_int(stack);
-        int i;
+      symbol = (tre_addtags_symbol_t)tre_stack_pop_int(stack);
+      switch (symbol)
+	{
 
-        /* Add end of this submatch to regset. */
-        for (i = 0; regset[i] >= 0; i++)
-          ;
-        regset[i] = id * 2 + 1;
-        regset[i + 1] = -1;
+	case ADDTAGS_SET_SUBMATCH_END:
+	  {
+	    int id = tre_stack_pop_int(stack);
+	    int i;
 
-        /* Pop this submatch from the parents stack. */
-        for (i = 0; parents[i] >= 0; i++)
-          ;
-        parents[i - 1] = -1;
-        break;
-      }
+	    /* Add end of this submatch to regset. */
+	    for (i = 0; regset[i] >= 0; i++);
+	    regset[i] = id * 2 + 1;
+	    regset[i + 1] = -1;
 
-      case ADDTAGS_RECURSE:
-        node = tre_stack_pop_voidptr(stack);
+	    /* Pop this submatch from the parents stack. */
+	    for (i = 0; parents[i] >= 0; i++);
+	    parents[i - 1] = -1;
+	    break;
+	  }
 
-        if (node->submatch_id >= 0) {
-          int id = node->submatch_id;
-          int i;
+	case ADDTAGS_RECURSE:
+	  node = tre_stack_pop_voidptr(stack);
 
-          /* Add start of this submatch to regset. */
-          for (i = 0; regset[i] >= 0; i++)
-            ;
-          regset[i] = id * 2;
-          regset[i + 1] = -1;
+	  if (node->submatch_id >= 0)
+	    {
+	      int id = node->submatch_id;
+	      int i;
 
-          if (!first_pass) {
-            for (i = 0; parents[i] >= 0; i++)
-              ;
-            tnfa->submatch_data[id].parents = NULL;
-            if (i > 0) {
-              int *p = malloc(sizeof(*p) * (i + 1));
-              if (p == NULL) {
-                status = REG_ESPACE;
-                break;
-              }
-              unassert(tnfa->submatch_data[id].parents == NULL);
-              tnfa->submatch_data[id].parents = p;
-              for (i = 0; parents[i] >= 0; i++) p[i] = parents[i];
-              p[i] = -1;
-            }
-          }
 
-          /* Add end of this submatch to regset after processing this
-             node. */
-          STACK_PUSHX(stack, int, node->submatch_id);
-          STACK_PUSHX(stack, int, ADDTAGS_SET_SUBMATCH_END);
-        }
+	      /* Add start of this submatch to regset. */
+	      for (i = 0; regset[i] >= 0; i++);
+	      regset[i] = id * 2;
+	      regset[i + 1] = -1;
 
-        switch (node->type) {
-          case LITERAL: {
-            tre_literal_t *lit = node->obj;
+	      if (!first_pass)
+		{
+		  for (i = 0; parents[i] >= 0; i++);
+		  tnfa->submatch_data[id].parents = NULL;
+		  if (i > 0)
+		    {
+		      int *p = xmalloc(sizeof(*p) * (i + 1));
+		      if (p == NULL)
+			{
+			  status = REG_ESPACE;
+			  break;
+			}
+		      assert(tnfa->submatch_data[id].parents == NULL);
+		      tnfa->submatch_data[id].parents = p;
+		      for (i = 0; parents[i] >= 0; i++)
+			p[i] = parents[i];
+		      p[i] = -1;
+		    }
+		}
 
-            if (!IS_SPECIAL(lit) || IS_BACKREF(lit)) {
-              int i;
-              if (regset[0] >= 0) {
-                /* Regset is not empty, so add a tag before the
-                   literal or backref. */
-                if (!first_pass) {
-                  status = tre_add_tag_left(mem, node, tag);
-                  tnfa->tag_directions[tag] = direction;
-                  if (minimal_tag >= 0) {
-                    for (i = 0; tnfa->minimal_tags[i] >= 0; i++)
-                      ;
-                    tnfa->minimal_tags[i] = tag;
-                    tnfa->minimal_tags[i + 1] = minimal_tag;
-                    tnfa->minimal_tags[i + 2] = -1;
-                    minimal_tag = -1;
-                    num_minimals++;
-                  }
-                  tre_purge_regset(regset, tnfa, tag);
-                } else {
-                  node->num_tags = 1;
-                }
+	      /* Add end of this submatch to regset after processing this
+		 node. */
+	      STACK_PUSHX(stack, int, node->submatch_id);
+	      STACK_PUSHX(stack, int, ADDTAGS_SET_SUBMATCH_END);
+	    }
 
-                regset[0] = -1;
-                tag = next_tag;
-                num_tags++;
-                next_tag++;
-              }
-            } else {
-              unassert(!IS_TAG(lit));
-            }
-            break;
-          }
-          case CATENATION: {
-            tre_catenation_t *cat = node->obj;
-            tre_ast_node_t *left = cat->left;
-            tre_ast_node_t *right = cat->right;
-            int reserved_tag = -1;
+	  switch (node->type)
+	    {
+	    case LITERAL:
+	      {
+		tre_literal_t *lit = node->obj;
 
-            /* After processing right child. */
-            STACK_PUSHX(stack, voidptr, node);
-            STACK_PUSHX(stack, int, ADDTAGS_AFTER_CAT_RIGHT);
+		if (!IS_SPECIAL(lit) || IS_BACKREF(lit))
+		  {
+		    int i;
+		    if (regset[0] >= 0)
+		      {
+			/* Regset is not empty, so add a tag before the
+			   literal or backref. */
+			if (!first_pass)
+			  {
+			    status = tre_add_tag_left(mem, node, tag);
+			    tnfa->tag_directions[tag] = direction;
+			    if (minimal_tag >= 0)
+			      {
+				for (i = 0; tnfa->minimal_tags[i] >= 0; i++);
+				tnfa->minimal_tags[i] = tag;
+				tnfa->minimal_tags[i + 1] = minimal_tag;
+				tnfa->minimal_tags[i + 2] = -1;
+				minimal_tag = -1;
+				num_minimals++;
+			      }
+			    tre_purge_regset(regset, tnfa, tag);
+			  }
+			else
+			  {
+			    node->num_tags = 1;
+			  }
 
-            /* Process right child. */
-            STACK_PUSHX(stack, voidptr, right);
-            STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
+			regset[0] = -1;
+			tag = next_tag;
+			num_tags++;
+			next_tag++;
+		      }
+		  }
+		else
+		  {
+		    assert(!IS_TAG(lit));
+		  }
+		break;
+	      }
+	    case CATENATION:
+	      {
+		tre_catenation_t *cat = node->obj;
+		tre_ast_node_t *left = cat->left;
+		tre_ast_node_t *right = cat->right;
+		int reserved_tag = -1;
 
-            /* After processing left child. */
-            STACK_PUSHX(stack, int, next_tag + left->num_tags);
-            if (left->num_tags > 0 && right->num_tags > 0) {
-              /* Reserve the next tag to the right child. */
-              reserved_tag = next_tag;
-              next_tag++;
-            }
-            STACK_PUSHX(stack, int, reserved_tag);
-            STACK_PUSHX(stack, int, ADDTAGS_AFTER_CAT_LEFT);
 
-            /* Process left child. */
-            STACK_PUSHX(stack, voidptr, left);
-            STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
+		/* After processing right child. */
+		STACK_PUSHX(stack, voidptr, node);
+		STACK_PUSHX(stack, int, ADDTAGS_AFTER_CAT_RIGHT);
 
-          } break;
-          case ITERATION: {
-            tre_iteration_t *iter = node->obj;
+		/* Process right child. */
+		STACK_PUSHX(stack, voidptr, right);
+		STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
 
-            if (first_pass) {
-              STACK_PUSHX(stack, int, regset[0] >= 0 || iter->minimal);
-            } else {
-              STACK_PUSHX(stack, int, tag);
-              STACK_PUSHX(stack, int, iter->minimal);
-            }
-            STACK_PUSHX(stack, voidptr, node);
-            STACK_PUSHX(stack, int, ADDTAGS_AFTER_ITERATION);
+		/* After processing left child. */
+		STACK_PUSHX(stack, int, next_tag + left->num_tags);
+		if (left->num_tags > 0 && right->num_tags > 0)
+		  {
+		    /* Reserve the next tag to the right child. */
+		    reserved_tag = next_tag;
+		    next_tag++;
+		  }
+		STACK_PUSHX(stack, int, reserved_tag);
+		STACK_PUSHX(stack, int, ADDTAGS_AFTER_CAT_LEFT);
 
-            STACK_PUSHX(stack, voidptr, iter->arg);
-            STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
+		/* Process left child. */
+		STACK_PUSHX(stack, voidptr, left);
+		STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
 
-            /* Regset is not empty, so add a tag here. */
-            if (regset[0] >= 0 || iter->minimal) {
-              if (!first_pass) {
-                int i;
-                status = tre_add_tag_left(mem, node, tag);
-                if (iter->minimal)
-                  tnfa->tag_directions[tag] = TRE_TAG_MAXIMIZE;
-                else
-                  tnfa->tag_directions[tag] = direction;
-                if (minimal_tag >= 0) {
-                  for (i = 0; tnfa->minimal_tags[i] >= 0; i++)
-                    ;
-                  tnfa->minimal_tags[i] = tag;
-                  tnfa->minimal_tags[i + 1] = minimal_tag;
-                  tnfa->minimal_tags[i + 2] = -1;
-                  minimal_tag = -1;
-                  num_minimals++;
-                }
-                tre_purge_regset(regset, tnfa, tag);
-              }
+		}
+	      break;
+	    case ITERATION:
+	      {
+		tre_iteration_t *iter = node->obj;
 
-              regset[0] = -1;
-              tag = next_tag;
-              num_tags++;
-              next_tag++;
-            }
-            direction = TRE_TAG_MINIMIZE;
-          } break;
-          case UNION: {
-            tre_union_t *uni = node->obj;
-            tre_ast_node_t *left = uni->left;
-            tre_ast_node_t *right = uni->right;
-            int left_tag;
-            int right_tag;
+		if (first_pass)
+		  {
+		    STACK_PUSHX(stack, int, regset[0] >= 0 || iter->minimal);
+		  }
+		else
+		  {
+		    STACK_PUSHX(stack, int, tag);
+		    STACK_PUSHX(stack, int, iter->minimal);
+		  }
+		STACK_PUSHX(stack, voidptr, node);
+		STACK_PUSHX(stack, int, ADDTAGS_AFTER_ITERATION);
 
-            if (regset[0] >= 0) {
-              left_tag = next_tag;
-              right_tag = next_tag + 1;
-            } else {
-              left_tag = tag;
-              right_tag = next_tag;
-            }
+		STACK_PUSHX(stack, voidptr, iter->arg);
+		STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
 
-            /* After processing right child. */
-            STACK_PUSHX(stack, int, right_tag);
-            STACK_PUSHX(stack, int, left_tag);
-            STACK_PUSHX(stack, voidptr, regset);
-            STACK_PUSHX(stack, int, regset[0] >= 0);
-            STACK_PUSHX(stack, voidptr, node);
-            STACK_PUSHX(stack, voidptr, right);
-            STACK_PUSHX(stack, voidptr, left);
-            STACK_PUSHX(stack, int, ADDTAGS_AFTER_UNION_RIGHT);
+		/* Regset is not empty, so add a tag here. */
+		if (regset[0] >= 0 || iter->minimal)
+		  {
+		    if (!first_pass)
+		      {
+			int i;
+			status = tre_add_tag_left(mem, node, tag);
+			if (iter->minimal)
+			  tnfa->tag_directions[tag] = TRE_TAG_MAXIMIZE;
+			else
+			  tnfa->tag_directions[tag] = direction;
+			if (minimal_tag >= 0)
+			  {
+			    for (i = 0; tnfa->minimal_tags[i] >= 0; i++);
+			    tnfa->minimal_tags[i] = tag;
+			    tnfa->minimal_tags[i + 1] = minimal_tag;
+			    tnfa->minimal_tags[i + 2] = -1;
+			    minimal_tag = -1;
+			    num_minimals++;
+			  }
+			tre_purge_regset(regset, tnfa, tag);
+		      }
 
-            /* Process right child. */
-            STACK_PUSHX(stack, voidptr, right);
-            STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
+		    regset[0] = -1;
+		    tag = next_tag;
+		    num_tags++;
+		    next_tag++;
+		  }
+		direction = TRE_TAG_MINIMIZE;
+	      }
+	      break;
+	    case UNION:
+	      {
+		tre_union_t *uni = node->obj;
+		tre_ast_node_t *left = uni->left;
+		tre_ast_node_t *right = uni->right;
+		int left_tag;
+		int right_tag;
 
-            /* After processing left child. */
-            STACK_PUSHX(stack, int, ADDTAGS_AFTER_UNION_LEFT);
+		if (regset[0] >= 0)
+		  {
+		    left_tag = next_tag;
+		    right_tag = next_tag + 1;
+		  }
+		else
+		  {
+		    left_tag = tag;
+		    right_tag = next_tag;
+		  }
 
-            /* Process left child. */
-            STACK_PUSHX(stack, voidptr, left);
-            STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
+		/* After processing right child. */
+		STACK_PUSHX(stack, int, right_tag);
+		STACK_PUSHX(stack, int, left_tag);
+		STACK_PUSHX(stack, voidptr, regset);
+		STACK_PUSHX(stack, int, regset[0] >= 0);
+		STACK_PUSHX(stack, voidptr, node);
+		STACK_PUSHX(stack, voidptr, right);
+		STACK_PUSHX(stack, voidptr, left);
+		STACK_PUSHX(stack, int, ADDTAGS_AFTER_UNION_RIGHT);
 
-            /* Regset is not empty, so add a tag here. */
-            if (regset[0] >= 0) {
-              if (!first_pass) {
-                int i;
-                status = tre_add_tag_left(mem, node, tag);
-                tnfa->tag_directions[tag] = direction;
-                if (minimal_tag >= 0) {
-                  for (i = 0; tnfa->minimal_tags[i] >= 0; i++)
-                    ;
-                  tnfa->minimal_tags[i] = tag;
-                  tnfa->minimal_tags[i + 1] = minimal_tag;
-                  tnfa->minimal_tags[i + 2] = -1;
-                  minimal_tag = -1;
-                  num_minimals++;
-                }
-                tre_purge_regset(regset, tnfa, tag);
-              }
+		/* Process right child. */
+		STACK_PUSHX(stack, voidptr, right);
+		STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
 
-              regset[0] = -1;
-              tag = next_tag;
-              num_tags++;
-              next_tag++;
-            }
+		/* After processing left child. */
+		STACK_PUSHX(stack, int, ADDTAGS_AFTER_UNION_LEFT);
 
-            if (node->num_submatches > 0) {
-              /* The next two tags are reserved for markers. */
-              next_tag++;
-              tag = next_tag;
-              next_tag++;
-            }
+		/* Process left child. */
+		STACK_PUSHX(stack, voidptr, left);
+		STACK_PUSHX(stack, int, ADDTAGS_RECURSE);
 
-            break;
-          }
-        }
+		/* Regset is not empty, so add a tag here. */
+		if (regset[0] >= 0)
+		  {
+		    if (!first_pass)
+		      {
+			int i;
+			status = tre_add_tag_left(mem, node, tag);
+			tnfa->tag_directions[tag] = direction;
+			if (minimal_tag >= 0)
+			  {
+			    for (i = 0; tnfa->minimal_tags[i] >= 0; i++);
+			    tnfa->minimal_tags[i] = tag;
+			    tnfa->minimal_tags[i + 1] = minimal_tag;
+			    tnfa->minimal_tags[i + 2] = -1;
+			    minimal_tag = -1;
+			    num_minimals++;
+			  }
+			tre_purge_regset(regset, tnfa, tag);
+		      }
 
-        if (node->submatch_id >= 0) {
-          int i;
-          /* Push this submatch on the parents stack. */
-          for (i = 0; parents[i] >= 0; i++)
-            ;
-          parents[i] = node->submatch_id;
-          parents[i + 1] = -1;
-        }
+		    regset[0] = -1;
+		    tag = next_tag;
+		    num_tags++;
+		    next_tag++;
+		  }
 
-        break; /* end case: ADDTAGS_RECURSE */
+		if (node->num_submatches > 0)
+		  {
+		    /* The next two tags are reserved for markers. */
+		    next_tag++;
+		    tag = next_tag;
+		    next_tag++;
+		  }
 
-      case ADDTAGS_AFTER_ITERATION: {
-        int minimal = 0;
-        int enter_tag;
-        node = tre_stack_pop_voidptr(stack);
-        if (first_pass) {
-          node->num_tags = ((tre_iteration_t *)node->obj)->arg->num_tags +
-                           tre_stack_pop_int(stack);
-          minimal_tag = -1;
-        } else {
-          minimal = tre_stack_pop_int(stack);
-          enter_tag = tre_stack_pop_int(stack);
-          if (minimal) minimal_tag = enter_tag;
-        }
+		break;
+	      }
+	    }
 
-        if (!first_pass) {
-          if (minimal)
-            direction = TRE_TAG_MINIMIZE;
-          else
-            direction = TRE_TAG_MAXIMIZE;
-        }
-        break;
-      }
+	  if (node->submatch_id >= 0)
+	    {
+	      int i;
+	      /* Push this submatch on the parents stack. */
+	      for (i = 0; parents[i] >= 0; i++);
+	      parents[i] = node->submatch_id;
+	      parents[i + 1] = -1;
+	    }
 
-      case ADDTAGS_AFTER_CAT_LEFT: {
-        int new_tag = tre_stack_pop_int(stack);
-        next_tag = tre_stack_pop_int(stack);
-        if (new_tag >= 0) {
-          tag = new_tag;
-        }
-        break;
-      }
+	  break; /* end case: ADDTAGS_RECURSE */
 
-      case ADDTAGS_AFTER_CAT_RIGHT:
-        node = tre_stack_pop_voidptr(stack);
-        if (first_pass)
-          node->num_tags = ((tre_catenation_t *)node->obj)->left->num_tags +
-                           ((tre_catenation_t *)node->obj)->right->num_tags;
-        break;
+	case ADDTAGS_AFTER_ITERATION:
+	  {
+	    int minimal = 0;
+	    int enter_tag;
+	    node = tre_stack_pop_voidptr(stack);
+	    if (first_pass)
+	      {
+		node->num_tags = ((tre_iteration_t *)node->obj)->arg->num_tags
+		  + tre_stack_pop_int(stack);
+		minimal_tag = -1;
+	      }
+	    else
+	      {
+		minimal = tre_stack_pop_int(stack);
+		enter_tag = tre_stack_pop_int(stack);
+		if (minimal)
+		  minimal_tag = enter_tag;
+	      }
 
-      case ADDTAGS_AFTER_UNION_LEFT:
-        /* Lift the bottom of the `regset' array so that when processing
-           the right operand the items currently in the array are
-           invisible.	 The original bottom was saved at ADDTAGS_UNION and
-           will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */
-        while (*regset >= 0) regset++;
-        break;
+	    if (!first_pass)
+	      {
+		if (minimal)
+		  direction = TRE_TAG_MINIMIZE;
+		else
+		  direction = TRE_TAG_MAXIMIZE;
+	      }
+	    break;
+	  }
 
-      case ADDTAGS_AFTER_UNION_RIGHT: {
-        int added_tags, tag_left, tag_right;
-        tre_ast_node_t *left = tre_stack_pop_voidptr(stack);
-        tre_ast_node_t *right = tre_stack_pop_voidptr(stack);
-        node = tre_stack_pop_voidptr(stack);
-        added_tags = tre_stack_pop_int(stack);
-        if (first_pass) {
-          node->num_tags = ((tre_union_t *)node->obj)->left->num_tags +
-                           ((tre_union_t *)node->obj)->right->num_tags +
-                           added_tags + ((node->num_submatches > 0) ? 2 : 0);
-        }
-        regset = tre_stack_pop_voidptr(stack);
-        tag_left = tre_stack_pop_int(stack);
-        tag_right = tre_stack_pop_int(stack);
+	case ADDTAGS_AFTER_CAT_LEFT:
+	  {
+	    int new_tag = tre_stack_pop_int(stack);
+	    next_tag = tre_stack_pop_int(stack);
+	    if (new_tag >= 0)
+	      {
+		tag = new_tag;
+	      }
+	    break;
+	  }
 
-        /* Add tags after both children, the left child gets a smaller
-           tag than the right child.  This guarantees that we prefer
-           the left child over the right child. */
-        /* XXX - This is not always necessary (if the children have
-           tags which must be seen for every match of that child). */
-        /* XXX - Check if this is the only place where tre_add_tag_right
-           is used.	 If so, use tre_add_tag_left (putting the tag before
-           the child as opposed after the child) and throw away
-           tre_add_tag_right. */
-        if (node->num_submatches > 0) {
-          if (!first_pass) {
-            status = tre_add_tag_right(mem, left, tag_left);
-            tnfa->tag_directions[tag_left] = TRE_TAG_MAXIMIZE;
-            if (status == REG_OK)
-              status = tre_add_tag_right(mem, right, tag_right);
-            tnfa->tag_directions[tag_right] = TRE_TAG_MAXIMIZE;
-          }
-          num_tags += 2;
-        }
-        direction = TRE_TAG_MAXIMIZE;
-        break;
-      }
+	case ADDTAGS_AFTER_CAT_RIGHT:
+	  node = tre_stack_pop_voidptr(stack);
+	  if (first_pass)
+	    node->num_tags = ((tre_catenation_t *)node->obj)->left->num_tags
+	      + ((tre_catenation_t *)node->obj)->right->num_tags;
+	  break;
 
-      default:
-        __builtin_unreachable();
+	case ADDTAGS_AFTER_UNION_LEFT:
+	  /* Lift the bottom of the `regset' array so that when processing
+	     the right operand the items currently in the array are
+	     invisible.	 The original bottom was saved at ADDTAGS_UNION and
+	     will be restored at ADDTAGS_AFTER_UNION_RIGHT below. */
+	  while (*regset >= 0)
+	    regset++;
+	  break;
 
-    } /* end switch(symbol) */
-  }   /* end while(tre_stack_num_objects(stack) > bottom) */
+	case ADDTAGS_AFTER_UNION_RIGHT:
+	  {
+	    int added_tags, tag_left, tag_right;
+	    tre_ast_node_t *left = tre_stack_pop_voidptr(stack);
+	    tre_ast_node_t *right = tre_stack_pop_voidptr(stack);
+	    node = tre_stack_pop_voidptr(stack);
+	    added_tags = tre_stack_pop_int(stack);
+	    if (first_pass)
+	      {
+		node->num_tags = ((tre_union_t *)node->obj)->left->num_tags
+		  + ((tre_union_t *)node->obj)->right->num_tags + added_tags
+		  + ((node->num_submatches > 0) ? 2 : 0);
+	      }
+	    regset = tre_stack_pop_voidptr(stack);
+	    tag_left = tre_stack_pop_int(stack);
+	    tag_right = tre_stack_pop_int(stack);
 
-  if (!first_pass) tre_purge_regset(regset, tnfa, tag);
+	    /* Add tags after both children, the left child gets a smaller
+	       tag than the right child.  This guarantees that we prefer
+	       the left child over the right child. */
+	    /* XXX - This is not always necessary (if the children have
+	       tags which must be seen for every match of that child). */
+	    /* XXX - Check if this is the only place where tre_add_tag_right
+	       is used.	 If so, use tre_add_tag_left (putting the tag before
+	       the child as opposed after the child) and throw away
+	       tre_add_tag_right. */
+	    if (node->num_submatches > 0)
+	      {
+		if (!first_pass)
+		  {
+		    status = tre_add_tag_right(mem, left, tag_left);
+		    tnfa->tag_directions[tag_left] = TRE_TAG_MAXIMIZE;
+		    if (status == REG_OK)
+		      status = tre_add_tag_right(mem, right, tag_right);
+		    tnfa->tag_directions[tag_right] = TRE_TAG_MAXIMIZE;
+		  }
+		num_tags += 2;
+	      }
+	    direction = TRE_TAG_MAXIMIZE;
+	    break;
+	  }
 
-  if (!first_pass && minimal_tag >= 0) {
-    int i;
-    for (i = 0; tnfa->minimal_tags[i] >= 0; i++)
-      ;
-    tnfa->minimal_tags[i] = tag;
-    tnfa->minimal_tags[i + 1] = minimal_tag;
-    tnfa->minimal_tags[i + 2] = -1;
-    minimal_tag = -1;
-    num_minimals++;
-  }
+	default:
+	  assert(0);
+	  break;
 
-  unassert(tree->num_tags == num_tags);
+	} /* end switch(symbol) */
+    } /* end while(tre_stack_num_objects(stack) > bottom) */
+
+  if (!first_pass)
+    tre_purge_regset(regset, tnfa, tag);
+
+  if (!first_pass && minimal_tag >= 0)
+    {
+      int i;
+      for (i = 0; tnfa->minimal_tags[i] >= 0; i++);
+      tnfa->minimal_tags[i] = tag;
+      tnfa->minimal_tags[i + 1] = minimal_tag;
+      tnfa->minimal_tags[i + 2] = -1;
+      minimal_tag = -1;
+      num_minimals++;
+    }
+
+  assert(tree->num_tags == num_tags);
   tnfa->end_tag = num_tags;
   tnfa->num_tags = num_tags;
   tnfa->num_minimals = num_minimals;
-  free(orig_regset), orig_regset = NULL;
-  free(parents), parents = NULL;
-  free(saved_states), saved_states = NULL;
+  xfree(orig_regset);
+  xfree(parents);
+  xfree(saved_states);
   return status;
 }
 
+
+
 /*
   AST to TNFA compilation routines.
 */
 
-typedef enum { COPY_RECURSE, COPY_SET_RESULT_PTR } tre_copyast_symbol_t;
+typedef enum {
+  COPY_RECURSE,
+  COPY_SET_RESULT_PTR
+} tre_copyast_symbol_t;
 
 /* Flags for tre_copy_ast(). */
-#define COPY_REMOVE_TAGS        1
-#define COPY_MAXIMIZE_FIRST_TAG 2
+#define COPY_REMOVE_TAGS	 1
+#define COPY_MAXIMIZE_FIRST_TAG	 2
 
-static reg_errcode_t tre_copy_ast(tre_mem_t mem, tre_stack_t *stack,
-                                  tre_ast_node_t *ast, int flags, int *pos_add,
-                                  tre_tag_direction_t *tag_directions,
-                                  tre_ast_node_t **copy, int *max_pos) {
+static reg_errcode_t
+tre_copy_ast(tre_mem_t mem, tre_stack_t *stack, tre_ast_node_t *ast,
+	     int flags, int *pos_add, tre_tag_direction_t *tag_directions,
+	     tre_ast_node_t **copy, int *max_pos)
+{
   reg_errcode_t status = REG_OK;
   int bottom = tre_stack_num_objects(stack);
   int num_copied = 0;
@@ -1550,121 +1725,143 @@ static reg_errcode_t tre_copy_ast(tre_mem_t mem, tre_stack_t *stack,
   STACK_PUSH(stack, voidptr, ast);
   STACK_PUSH(stack, int, COPY_RECURSE);
 
-  while (status == REG_OK && tre_stack_num_objects(stack) > bottom) {
-    tre_ast_node_t *node;
-    if (status != REG_OK) break;
+  while (status == REG_OK && tre_stack_num_objects(stack) > bottom)
+    {
+      tre_ast_node_t *node;
+      if (status != REG_OK)
+	break;
 
-    symbol = (tre_copyast_symbol_t)tre_stack_pop_int(stack);
-    switch (symbol) {
-      case COPY_SET_RESULT_PTR:
-        result = tre_stack_pop_voidptr(stack);
-        break;
-      case COPY_RECURSE:
-        node = tre_stack_pop_voidptr(stack);
-        switch (node->type) {
-          case LITERAL: {
-            tre_literal_t *lit = node->obj;
-            int pos = lit->position;
-            int min = lit->code_min;
-            int max = lit->code_max;
-            if (!IS_SPECIAL(lit) || IS_BACKREF(lit)) {
-              /* XXX - e.g. [ab] has only one position but two
-                 nodes, so we are creating holes in the state space
-                 here.  Not fatal, just wastes memory. */
-              pos += *pos_add;
-              num_copied++;
-            } else if (IS_TAG(lit) && (flags & COPY_REMOVE_TAGS)) {
-              /* Change this tag to empty. */
-              min = EMPTY;
-              max = pos = -1;
-            } else if (IS_TAG(lit) && (flags & COPY_MAXIMIZE_FIRST_TAG) &&
-                       first_tag) {
-              /* Maximize the first tag. */
-              tag_directions[max] = TRE_TAG_MAXIMIZE;
-              first_tag = 0;
-            }
-            *result = tre_ast_new_literal(mem, min, max, pos);
-            if (*result == NULL)
-              status = REG_ESPACE;
-            else {
-              tre_literal_t *p = (*result)->obj;
-              p->class = lit->class;
-              p->neg_classes = lit->neg_classes;
-            }
+      symbol = (tre_copyast_symbol_t)tre_stack_pop_int(stack);
+      switch (symbol)
+	{
+	case COPY_SET_RESULT_PTR:
+	  result = tre_stack_pop_voidptr(stack);
+	  break;
+	case COPY_RECURSE:
+	  node = tre_stack_pop_voidptr(stack);
+	  switch (node->type)
+	    {
+	    case LITERAL:
+	      {
+		tre_literal_t *lit = node->obj;
+		int pos = lit->position;
+		int min = lit->code_min;
+		int max = lit->code_max;
+		if (!IS_SPECIAL(lit) || IS_BACKREF(lit))
+		  {
+		    /* XXX - e.g. [ab] has only one position but two
+		       nodes, so we are creating holes in the state space
+		       here.  Not fatal, just wastes memory. */
+		    pos += *pos_add;
+		    num_copied++;
+		  }
+		else if (IS_TAG(lit) && (flags & COPY_REMOVE_TAGS))
+		  {
+		    /* Change this tag to empty. */
+		    min = EMPTY;
+		    max = pos = -1;
+		  }
+		else if (IS_TAG(lit) && (flags & COPY_MAXIMIZE_FIRST_TAG)
+			 && first_tag)
+		  {
+		    /* Maximize the first tag. */
+		    tag_directions[max] = TRE_TAG_MAXIMIZE;
+		    first_tag = 0;
+		  }
+		*result = tre_ast_new_literal(mem, min, max, pos);
+		if (*result == NULL)
+		  status = REG_ESPACE;
+		else {
+		  tre_literal_t *p = (*result)->obj;
+		  p->class = lit->class;
+		  p->neg_classes = lit->neg_classes;
+		}
 
-            if (pos > *max_pos) *max_pos = pos;
-            break;
-          }
-          case UNION: {
-            tre_union_t *uni = node->obj;
-            tre_union_t *tmp;
-            *result = tre_ast_new_union(mem, uni->left, uni->right);
-            if (*result == NULL) {
-              status = REG_ESPACE;
-              break;
-            }
-            tmp = (*result)->obj;
-            result = &tmp->left;
-            STACK_PUSHX(stack, voidptr, uni->right);
-            STACK_PUSHX(stack, int, COPY_RECURSE);
-            STACK_PUSHX(stack, voidptr, &tmp->right);
-            STACK_PUSHX(stack, int, COPY_SET_RESULT_PTR);
-            STACK_PUSHX(stack, voidptr, uni->left);
-            STACK_PUSHX(stack, int, COPY_RECURSE);
-            break;
-          }
-          case CATENATION: {
-            tre_catenation_t *cat = node->obj;
-            tre_catenation_t *tmp;
-            *result = tre_ast_new_catenation(mem, cat->left, cat->right);
-            if (*result == NULL) {
-              status = REG_ESPACE;
-              break;
-            }
-            tmp = (*result)->obj;
-            tmp->left = NULL;
-            tmp->right = NULL;
-            result = &tmp->left;
+		if (pos > *max_pos)
+		  *max_pos = pos;
+		break;
+	      }
+	    case UNION:
+	      {
+		tre_union_t *uni = node->obj;
+		tre_union_t *tmp;
+		*result = tre_ast_new_union(mem, uni->left, uni->right);
+		if (*result == NULL)
+		  {
+		    status = REG_ESPACE;
+		    break;
+		  }
+		tmp = (*result)->obj;
+		result = &tmp->left;
+		STACK_PUSHX(stack, voidptr, uni->right);
+		STACK_PUSHX(stack, int, COPY_RECURSE);
+		STACK_PUSHX(stack, voidptr, &tmp->right);
+		STACK_PUSHX(stack, int, COPY_SET_RESULT_PTR);
+		STACK_PUSHX(stack, voidptr, uni->left);
+		STACK_PUSHX(stack, int, COPY_RECURSE);
+		break;
+	      }
+	    case CATENATION:
+	      {
+		tre_catenation_t *cat = node->obj;
+		tre_catenation_t *tmp;
+		*result = tre_ast_new_catenation(mem, cat->left, cat->right);
+		if (*result == NULL)
+		  {
+		    status = REG_ESPACE;
+		    break;
+		  }
+		tmp = (*result)->obj;
+		tmp->left = NULL;
+		tmp->right = NULL;
+		result = &tmp->left;
 
-            STACK_PUSHX(stack, voidptr, cat->right);
-            STACK_PUSHX(stack, int, COPY_RECURSE);
-            STACK_PUSHX(stack, voidptr, &tmp->right);
-            STACK_PUSHX(stack, int, COPY_SET_RESULT_PTR);
-            STACK_PUSHX(stack, voidptr, cat->left);
-            STACK_PUSHX(stack, int, COPY_RECURSE);
-            break;
-          }
-          case ITERATION: {
-            tre_iteration_t *iter = node->obj;
-            STACK_PUSHX(stack, voidptr, iter->arg);
-            STACK_PUSHX(stack, int, COPY_RECURSE);
-            *result = tre_ast_new_iter(mem, iter->arg, iter->min, iter->max,
-                                       iter->minimal);
-            if (*result == NULL) {
-              status = REG_ESPACE;
-              break;
-            }
-            iter = (*result)->obj;
-            result = &iter->arg;
-            break;
-          }
-          default:
-            __builtin_unreachable();
-        }
-        break;
+		STACK_PUSHX(stack, voidptr, cat->right);
+		STACK_PUSHX(stack, int, COPY_RECURSE);
+		STACK_PUSHX(stack, voidptr, &tmp->right);
+		STACK_PUSHX(stack, int, COPY_SET_RESULT_PTR);
+		STACK_PUSHX(stack, voidptr, cat->left);
+		STACK_PUSHX(stack, int, COPY_RECURSE);
+		break;
+	      }
+	    case ITERATION:
+	      {
+		tre_iteration_t *iter = node->obj;
+		STACK_PUSHX(stack, voidptr, iter->arg);
+		STACK_PUSHX(stack, int, COPY_RECURSE);
+		*result = tre_ast_new_iter(mem, iter->arg, iter->min,
+					   iter->max, iter->minimal);
+		if (*result == NULL)
+		  {
+		    status = REG_ESPACE;
+		    break;
+		  }
+		iter = (*result)->obj;
+		result = &iter->arg;
+		break;
+	      }
+	    default:
+	      assert(0);
+	      break;
+	    }
+	  break;
+	}
     }
-  }
   *pos_add += num_copied;
   return status;
 }
 
-typedef enum { EXPAND_RECURSE, EXPAND_AFTER_ITER } tre_expand_ast_symbol_t;
+typedef enum {
+  EXPAND_RECURSE,
+  EXPAND_AFTER_ITER
+} tre_expand_ast_symbol_t;
 
 /* Expands each iteration node that has a finite nonzero minimum or maximum
    iteration count to a catenated sequence of copies of the node. */
-static reg_errcode_t tre_expand_ast(tre_mem_t mem, tre_stack_t *stack,
-                                    tre_ast_node_t *ast, int *position,
-                                    tre_tag_direction_t *tag_directions) {
+static reg_errcode_t
+tre_expand_ast(tre_mem_t mem, tre_stack_t *stack, tre_ast_node_t *ast,
+	       int *position, tre_tag_direction_t *tag_directions)
+{
   reg_errcode_t status = REG_OK;
   int bottom = tre_stack_num_objects(stack);
   int pos_add = 0;
@@ -1674,133 +1871,165 @@ static reg_errcode_t tre_expand_ast(tre_mem_t mem, tre_stack_t *stack,
 
   STACK_PUSHR(stack, voidptr, ast);
   STACK_PUSHR(stack, int, EXPAND_RECURSE);
-  while (status == REG_OK && tre_stack_num_objects(stack) > bottom) {
-    tre_ast_node_t *node;
-    tre_expand_ast_symbol_t symbol;
+  while (status == REG_OK && tre_stack_num_objects(stack) > bottom)
+    {
+      tre_ast_node_t *node;
+      tre_expand_ast_symbol_t symbol;
 
-    if (status != REG_OK) break;
+      if (status != REG_OK)
+	break;
 
-    symbol = (tre_expand_ast_symbol_t)tre_stack_pop_int(stack);
-    node = tre_stack_pop_voidptr(stack);
-    switch (symbol) {
-      case EXPAND_RECURSE:
-        switch (node->type) {
-          case LITERAL: {
-            tre_literal_t *lit = node->obj;
-            if (!IS_SPECIAL(lit) || IS_BACKREF(lit)) {
-              lit->position += pos_add;
-              if (lit->position > max_pos) max_pos = lit->position;
-            }
-            break;
-          }
-          case UNION: {
-            tre_union_t *uni = node->obj;
-            STACK_PUSHX(stack, voidptr, uni->right);
-            STACK_PUSHX(stack, int, EXPAND_RECURSE);
-            STACK_PUSHX(stack, voidptr, uni->left);
-            STACK_PUSHX(stack, int, EXPAND_RECURSE);
-            break;
-          }
-          case CATENATION: {
-            tre_catenation_t *cat = node->obj;
-            STACK_PUSHX(stack, voidptr, cat->right);
-            STACK_PUSHX(stack, int, EXPAND_RECURSE);
-            STACK_PUSHX(stack, voidptr, cat->left);
-            STACK_PUSHX(stack, int, EXPAND_RECURSE);
-            break;
-          }
-          case ITERATION: {
-            tre_iteration_t *iter = node->obj;
-            STACK_PUSHX(stack, int, pos_add);
-            STACK_PUSHX(stack, voidptr, node);
-            STACK_PUSHX(stack, int, EXPAND_AFTER_ITER);
-            STACK_PUSHX(stack, voidptr, iter->arg);
-            STACK_PUSHX(stack, int, EXPAND_RECURSE);
-            /* If we are going to expand this node at EXPAND_AFTER_ITER
-               then don't increase the `pos' fields of the nodes now, it
-               will get done when expanding. */
-            if (iter->min > 1 || iter->max > 1) pos_add = 0;
-            iter_depth++;
-            break;
-          }
-          default:
-            __builtin_unreachable();
-        }
-        break;
-      case EXPAND_AFTER_ITER: {
-        tre_iteration_t *iter = node->obj;
-        int pos_add_last;
-        pos_add = tre_stack_pop_int(stack);
-        pos_add_last = pos_add;
-        if (iter->min > 1 || iter->max > 1) {
-          tre_ast_node_t *seq1 = NULL, *seq2 = NULL;
-          int j;
-          int pos_add_save = pos_add;
+      symbol = (tre_expand_ast_symbol_t)tre_stack_pop_int(stack);
+      node = tre_stack_pop_voidptr(stack);
+      switch (symbol)
+	{
+	case EXPAND_RECURSE:
+	  switch (node->type)
+	    {
+	    case LITERAL:
+	      {
+		tre_literal_t *lit= node->obj;
+		if (!IS_SPECIAL(lit) || IS_BACKREF(lit))
+		  {
+		    lit->position += pos_add;
+		    if (lit->position > max_pos)
+		      max_pos = lit->position;
+		  }
+		break;
+	      }
+	    case UNION:
+	      {
+		tre_union_t *uni = node->obj;
+		STACK_PUSHX(stack, voidptr, uni->right);
+		STACK_PUSHX(stack, int, EXPAND_RECURSE);
+		STACK_PUSHX(stack, voidptr, uni->left);
+		STACK_PUSHX(stack, int, EXPAND_RECURSE);
+		break;
+	      }
+	    case CATENATION:
+	      {
+		tre_catenation_t *cat = node->obj;
+		STACK_PUSHX(stack, voidptr, cat->right);
+		STACK_PUSHX(stack, int, EXPAND_RECURSE);
+		STACK_PUSHX(stack, voidptr, cat->left);
+		STACK_PUSHX(stack, int, EXPAND_RECURSE);
+		break;
+	      }
+	    case ITERATION:
+	      {
+		tre_iteration_t *iter = node->obj;
+		STACK_PUSHX(stack, int, pos_add);
+		STACK_PUSHX(stack, voidptr, node);
+		STACK_PUSHX(stack, int, EXPAND_AFTER_ITER);
+		STACK_PUSHX(stack, voidptr, iter->arg);
+		STACK_PUSHX(stack, int, EXPAND_RECURSE);
+		/* If we are going to expand this node at EXPAND_AFTER_ITER
+		   then don't increase the `pos' fields of the nodes now, it
+		   will get done when expanding. */
+		if (iter->min > 1 || iter->max > 1)
+		  pos_add = 0;
+		iter_depth++;
+		break;
+	      }
+	    default:
+	      assert(0);
+	      break;
+	    }
+	  break;
+	case EXPAND_AFTER_ITER:
+	  {
+	    tre_iteration_t *iter = node->obj;
+	    int pos_add_last;
+	    pos_add = tre_stack_pop_int(stack);
+	    pos_add_last = pos_add;
+	    if (iter->min > 1 || iter->max > 1)
+	      {
+		tre_ast_node_t *seq1 = NULL, *seq2 = NULL;
+		int j;
+		int pos_add_save = pos_add;
 
-          /* Create a catenated sequence of copies of the node. */
-          for (j = 0; j < iter->min; j++) {
-            tre_ast_node_t *copy;
-            /* Remove tags from all but the last copy. */
-            int flags = ((j + 1 < iter->min) ? COPY_REMOVE_TAGS
-                                             : COPY_MAXIMIZE_FIRST_TAG);
-            pos_add_save = pos_add;
-            status = tre_copy_ast(mem, stack, iter->arg, flags, &pos_add,
-                                  tag_directions, &copy, &max_pos);
-            if (status != REG_OK) return status;
-            if (seq1 != NULL)
-              seq1 = tre_ast_new_catenation(mem, seq1, copy);
-            else
-              seq1 = copy;
-            if (seq1 == NULL) return REG_ESPACE;
-          }
+		/* Create a catenated sequence of copies of the node. */
+		for (j = 0; j < iter->min; j++)
+		  {
+		    tre_ast_node_t *copy;
+		    /* Remove tags from all but the last copy. */
+		    int flags = ((j + 1 < iter->min)
+				 ? COPY_REMOVE_TAGS
+				 : COPY_MAXIMIZE_FIRST_TAG);
+		    pos_add_save = pos_add;
+		    status = tre_copy_ast(mem, stack, iter->arg, flags,
+					  &pos_add, tag_directions, &copy,
+					  &max_pos);
+		    if (status != REG_OK)
+		      return status;
+		    if (seq1 != NULL)
+		      seq1 = tre_ast_new_catenation(mem, seq1, copy);
+		    else
+		      seq1 = copy;
+		    if (seq1 == NULL)
+		      return REG_ESPACE;
+		  }
 
-          if (iter->max == -1) {
-            /* No upper limit. */
-            pos_add_save = pos_add;
-            status = tre_copy_ast(mem, stack, iter->arg, 0, &pos_add, NULL,
-                                  &seq2, &max_pos);
-            if (status != REG_OK) return status;
-            seq2 = tre_ast_new_iter(mem, seq2, 0, -1, 0);
-            if (seq2 == NULL) return REG_ESPACE;
-          } else {
-            for (j = iter->min; j < iter->max; j++) {
-              tre_ast_node_t *tmp, *copy;
-              pos_add_save = pos_add;
-              status = tre_copy_ast(mem, stack, iter->arg, 0, &pos_add, NULL,
-                                    &copy, &max_pos);
-              if (status != REG_OK) return status;
-              if (seq2 != NULL)
-                seq2 = tre_ast_new_catenation(mem, copy, seq2);
-              else
-                seq2 = copy;
-              if (seq2 == NULL) return REG_ESPACE;
-              tmp = tre_ast_new_literal(mem, EMPTY, -1, -1);
-              if (tmp == NULL) return REG_ESPACE;
-              seq2 = tre_ast_new_union(mem, tmp, seq2);
-              if (seq2 == NULL) return REG_ESPACE;
-            }
-          }
+		if (iter->max == -1)
+		  {
+		    /* No upper limit. */
+		    pos_add_save = pos_add;
+		    status = tre_copy_ast(mem, stack, iter->arg, 0,
+					  &pos_add, NULL, &seq2, &max_pos);
+		    if (status != REG_OK)
+		      return status;
+		    seq2 = tre_ast_new_iter(mem, seq2, 0, -1, 0);
+		    if (seq2 == NULL)
+		      return REG_ESPACE;
+		  }
+		else
+		  {
+		    for (j = iter->min; j < iter->max; j++)
+		      {
+			tre_ast_node_t *tmp, *copy;
+			pos_add_save = pos_add;
+			status = tre_copy_ast(mem, stack, iter->arg, 0,
+					      &pos_add, NULL, &copy, &max_pos);
+			if (status != REG_OK)
+			  return status;
+			if (seq2 != NULL)
+			  seq2 = tre_ast_new_catenation(mem, copy, seq2);
+			else
+			  seq2 = copy;
+			if (seq2 == NULL)
+			  return REG_ESPACE;
+			tmp = tre_ast_new_literal(mem, EMPTY, -1, -1);
+			if (tmp == NULL)
+			  return REG_ESPACE;
+			seq2 = tre_ast_new_union(mem, tmp, seq2);
+			if (seq2 == NULL)
+			  return REG_ESPACE;
+		      }
+		  }
 
-          pos_add = pos_add_save;
-          if (seq1 == NULL)
-            seq1 = seq2;
-          else if (seq2 != NULL)
-            seq1 = tre_ast_new_catenation(mem, seq1, seq2);
-          if (seq1 == NULL) return REG_ESPACE;
-          node->obj = seq1->obj;
-          node->type = seq1->type;
-        }
+		pos_add = pos_add_save;
+		if (seq1 == NULL)
+		  seq1 = seq2;
+		else if (seq2 != NULL)
+		  seq1 = tre_ast_new_catenation(mem, seq1, seq2);
+		if (seq1 == NULL)
+		  return REG_ESPACE;
+		node->obj = seq1->obj;
+		node->type = seq1->type;
+	      }
 
-        iter_depth--;
-        pos_add_total += pos_add - pos_add_last;
-        if (iter_depth == 0) pos_add = pos_add_total;
+	    iter_depth--;
+	    pos_add_total += pos_add - pos_add_last;
+	    if (iter_depth == 0)
+	      pos_add = pos_add_total;
 
-        break;
-      }
-      default:
-        __builtin_unreachable();
+	    break;
+	  }
+	default:
+	  assert(0);
+	  break;
+	}
     }
-  }
 
   *position += pos_add_total;
 
@@ -1808,16 +2037,20 @@ static reg_errcode_t tre_expand_ast(tre_mem_t mem, tre_stack_t *stack,
      code works, but just an extra safeguard let's make sure
      `*position' is set large enough so enough memory will be
      allocated for the transition table. */
-  if (max_pos > *position) *position = max_pos;
+  if (max_pos > *position)
+    *position = max_pos;
 
   return status;
 }
 
-static tre_pos_and_tags_t *tre_set_empty(tre_mem_t mem) {
+static tre_pos_and_tags_t *
+tre_set_empty(tre_mem_t mem)
+{
   tre_pos_and_tags_t *new_set;
 
   new_set = tre_mem_calloc(mem, sizeof(*new_set));
-  if (new_set == NULL) return NULL;
+  if (new_set == NULL)
+    return NULL;
 
   new_set[0].position = -1;
   new_set[0].code_min = -1;
@@ -1826,14 +2059,15 @@ static tre_pos_and_tags_t *tre_set_empty(tre_mem_t mem) {
   return new_set;
 }
 
-static tre_pos_and_tags_t *tre_set_one(tre_mem_t mem, int position,
-                                       int code_min, int code_max,
-                                       tre_ctype_t class,
-                                       tre_ctype_t *neg_classes, int backref) {
+static tre_pos_and_tags_t *
+tre_set_one(tre_mem_t mem, int position, int code_min, int code_max,
+	    tre_ctype_t class, tre_ctype_t *neg_classes, int backref)
+{
   tre_pos_and_tags_t *new_set;
 
   new_set = tre_mem_calloc(mem, sizeof(*new_set) * 2);
-  if (new_set == NULL) return NULL;
+  if (new_set == NULL)
+    return NULL;
 
   new_set[0].position = position;
   new_set[0].code_min = code_min;
@@ -1848,67 +2082,73 @@ static tre_pos_and_tags_t *tre_set_one(tre_mem_t mem, int position,
   return new_set;
 }
 
-static tre_pos_and_tags_t *tre_set_union(tre_mem_t mem,
-                                         tre_pos_and_tags_t *set1,
-                                         tre_pos_and_tags_t *set2, int *tags,
-                                         int assertions) {
+static tre_pos_and_tags_t *
+tre_set_union(tre_mem_t mem, tre_pos_and_tags_t *set1, tre_pos_and_tags_t *set2,
+	      int *tags, int assertions)
+{
   int s1, s2, i, j;
   tre_pos_and_tags_t *new_set;
   int *new_tags;
   int num_tags;
 
-  for (num_tags = 0; tags != NULL && tags[num_tags] >= 0; num_tags++)
-    ;
-  for (s1 = 0; set1[s1].position >= 0; s1++)
-    ;
-  for (s2 = 0; set2[s2].position >= 0; s2++)
-    ;
+  for (num_tags = 0; tags != NULL && tags[num_tags] >= 0; num_tags++);
+  for (s1 = 0; set1[s1].position >= 0; s1++);
+  for (s2 = 0; set2[s2].position >= 0; s2++);
   new_set = tre_mem_calloc(mem, sizeof(*new_set) * (s1 + s2 + 1));
-  if (!new_set) return NULL;
+  if (!new_set )
+    return NULL;
 
-  for (s1 = 0; set1[s1].position >= 0; s1++) {
-    new_set[s1].position = set1[s1].position;
-    new_set[s1].code_min = set1[s1].code_min;
-    new_set[s1].code_max = set1[s1].code_max;
-    new_set[s1].assertions = set1[s1].assertions | assertions;
-    new_set[s1].class = set1[s1].class;
-    new_set[s1].neg_classes = set1[s1].neg_classes;
-    new_set[s1].backref = set1[s1].backref;
-    if (set1[s1].tags == NULL && tags == NULL)
-      new_set[s1].tags = NULL;
-    else {
-      for (i = 0; set1[s1].tags != NULL && set1[s1].tags[i] >= 0; i++)
-        ;
-      new_tags = tre_mem_alloc(mem, (sizeof(*new_tags) * (i + num_tags + 1)));
-      if (new_tags == NULL) return NULL;
-      for (j = 0; j < i; j++) new_tags[j] = set1[s1].tags[j];
-      for (i = 0; i < num_tags; i++) new_tags[j + i] = tags[i];
-      new_tags[j + i] = -1;
-      new_set[s1].tags = new_tags;
+  for (s1 = 0; set1[s1].position >= 0; s1++)
+    {
+      new_set[s1].position = set1[s1].position;
+      new_set[s1].code_min = set1[s1].code_min;
+      new_set[s1].code_max = set1[s1].code_max;
+      new_set[s1].assertions = set1[s1].assertions | assertions;
+      new_set[s1].class = set1[s1].class;
+      new_set[s1].neg_classes = set1[s1].neg_classes;
+      new_set[s1].backref = set1[s1].backref;
+      if (set1[s1].tags == NULL && tags == NULL)
+	new_set[s1].tags = NULL;
+      else
+	{
+	  for (i = 0; set1[s1].tags != NULL && set1[s1].tags[i] >= 0; i++);
+	  new_tags = tre_mem_alloc(mem, (sizeof(*new_tags)
+					 * (i + num_tags + 1)));
+	  if (new_tags == NULL)
+	    return NULL;
+	  for (j = 0; j < i; j++)
+	    new_tags[j] = set1[s1].tags[j];
+	  for (i = 0; i < num_tags; i++)
+	    new_tags[j + i] = tags[i];
+	  new_tags[j + i] = -1;
+	  new_set[s1].tags = new_tags;
+	}
     }
-  }
 
-  for (s2 = 0; set2[s2].position >= 0; s2++) {
-    new_set[s1 + s2].position = set2[s2].position;
-    new_set[s1 + s2].code_min = set2[s2].code_min;
-    new_set[s1 + s2].code_max = set2[s2].code_max;
-    /* XXX - why not | assertions here as well? */
-    new_set[s1 + s2].assertions = set2[s2].assertions;
-    new_set[s1 + s2].class = set2[s2].class;
-    new_set[s1 + s2].neg_classes = set2[s2].neg_classes;
-    new_set[s1 + s2].backref = set2[s2].backref;
-    if (set2[s2].tags == NULL)
-      new_set[s1 + s2].tags = NULL;
-    else {
-      for (i = 0; set2[s2].tags[i] >= 0; i++)
-        ;
-      new_tags = tre_mem_alloc(mem, sizeof(*new_tags) * (i + 1));
-      if (new_tags == NULL) return NULL;
-      for (j = 0; j < i; j++) new_tags[j] = set2[s2].tags[j];
-      new_tags[j] = -1;
-      new_set[s1 + s2].tags = new_tags;
+  for (s2 = 0; set2[s2].position >= 0; s2++)
+    {
+      new_set[s1 + s2].position = set2[s2].position;
+      new_set[s1 + s2].code_min = set2[s2].code_min;
+      new_set[s1 + s2].code_max = set2[s2].code_max;
+      /* XXX - why not | assertions here as well? */
+      new_set[s1 + s2].assertions = set2[s2].assertions;
+      new_set[s1 + s2].class = set2[s2].class;
+      new_set[s1 + s2].neg_classes = set2[s2].neg_classes;
+      new_set[s1 + s2].backref = set2[s2].backref;
+      if (set2[s2].tags == NULL)
+	new_set[s1 + s2].tags = NULL;
+      else
+	{
+	  for (i = 0; set2[s2].tags[i] >= 0; i++);
+	  new_tags = tre_mem_alloc(mem, sizeof(*new_tags) * (i + 1));
+	  if (new_tags == NULL)
+	    return NULL;
+	  for (j = 0; j < i; j++)
+	    new_tags[j] = set2[s2].tags[j];
+	  new_tags[j] = -1;
+	  new_set[s1 + s2].tags = new_tags;
+	}
     }
-  }
   new_set[s1 + s2].position = -1;
   return new_set;
 }
@@ -1917,9 +2157,10 @@ static tre_pos_and_tags_t *tre_set_union(tre_mem_t mem,
    taken according to POSIX.2 rules, and adds the tags on that path to
    `tags'.   `tags' may be NULL.  If `num_tags_seen' is not NULL, it is
    set to the number of tags seen on the path. */
-static reg_errcode_t tre_match_empty(tre_stack_t *stack, tre_ast_node_t *node,
-                                     int *tags, int *assertions,
-                                     int *num_tags_seen) {
+static reg_errcode_t
+tre_match_empty(tre_stack_t *stack, tre_ast_node_t *node, int *tags,
+		int *assertions, int *num_tags_seen)
+{
   tre_literal_t *lit;
   tre_union_t *uni;
   tre_catenation_t *cat;
@@ -1927,80 +2168,95 @@ static reg_errcode_t tre_match_empty(tre_stack_t *stack, tre_ast_node_t *node,
   int i;
   int bottom = tre_stack_num_objects(stack);
   reg_errcode_t status = REG_OK;
-  if (num_tags_seen) *num_tags_seen = 0;
+  if (num_tags_seen)
+    *num_tags_seen = 0;
 
   status = tre_stack_push_voidptr(stack, node);
 
   /* Walk through the tree recursively. */
-  while (status == REG_OK && tre_stack_num_objects(stack) > bottom) {
-    node = tre_stack_pop_voidptr(stack);
+  while (status == REG_OK && tre_stack_num_objects(stack) > bottom)
+    {
+      node = tre_stack_pop_voidptr(stack);
 
-    switch (node->type) {
-      case LITERAL:
-        lit = (tre_literal_t *)node->obj;
-        switch (lit->code_min) {
-          case TAG:
-            if (lit->code_max >= 0) {
-              if (tags != NULL) {
-                /* Add the tag to `tags'. */
-                for (i = 0; tags[i] >= 0; i++)
-                  if (tags[i] == lit->code_max) break;
-                if (tags[i] < 0) {
-                  tags[i] = lit->code_max;
-                  tags[i + 1] = -1;
-                }
-              }
-              if (num_tags_seen) (*num_tags_seen)++;
-            }
-            break;
-          case ASSERTION:
-            unassert(lit->code_max >= 1 || lit->code_max <= ASSERT_LAST);
-            if (assertions != NULL) *assertions |= lit->code_max;
-            break;
-          case EMPTY:
-            break;
-          default:
-            __builtin_unreachable();
-        }
-        break;
+      switch (node->type)
+	{
+	case LITERAL:
+	  lit = (tre_literal_t *)node->obj;
+	  switch (lit->code_min)
+	    {
+	    case TAG:
+	      if (lit->code_max >= 0)
+		{
+		  if (tags != NULL)
+		    {
+		      /* Add the tag to `tags'. */
+		      for (i = 0; tags[i] >= 0; i++)
+			if (tags[i] == lit->code_max)
+			  break;
+		      if (tags[i] < 0)
+			{
+			  tags[i] = lit->code_max;
+			  tags[i + 1] = -1;
+			}
+		    }
+		  if (num_tags_seen)
+		    (*num_tags_seen)++;
+		}
+	      break;
+	    case ASSERTION:
+	      assert(lit->code_max >= 1
+		     || lit->code_max <= ASSERT_LAST);
+	      if (assertions != NULL)
+		*assertions |= lit->code_max;
+	      break;
+	    case EMPTY:
+	      break;
+	    default:
+	      assert(0);
+	      break;
+	    }
+	  break;
 
-      case UNION:
-        /* Subexpressions starting earlier take priority over ones
-           starting later, so we prefer the left subexpression over the
-           right subexpression. */
-        uni = (tre_union_t *)node->obj;
-        if (uni->left->nullable)
-          STACK_PUSHX(stack, voidptr, uni->left)
-        else if (uni->right->nullable)
-          STACK_PUSHX(stack, voidptr, uni->right)
-        else
-          __builtin_unreachable();
-        break;
+	case UNION:
+	  /* Subexpressions starting earlier take priority over ones
+	     starting later, so we prefer the left subexpression over the
+	     right subexpression. */
+	  uni = (tre_union_t *)node->obj;
+	  if (uni->left->nullable)
+	    STACK_PUSHX(stack, voidptr, uni->left)
+	  else if (uni->right->nullable)
+	    STACK_PUSHX(stack, voidptr, uni->right)
+	  else
+	    assert(0);
+	  break;
 
-      case CATENATION:
-        /* The path must go through both children. */
-        cat = (tre_catenation_t *)node->obj;
-        unassert(cat->left->nullable);
-        unassert(cat->right->nullable);
-        STACK_PUSHX(stack, voidptr, cat->left);
-        STACK_PUSHX(stack, voidptr, cat->right);
-        break;
+	case CATENATION:
+	  /* The path must go through both children. */
+	  cat = (tre_catenation_t *)node->obj;
+	  assert(cat->left->nullable);
+	  assert(cat->right->nullable);
+	  STACK_PUSHX(stack, voidptr, cat->left);
+	  STACK_PUSHX(stack, voidptr, cat->right);
+	  break;
 
-      case ITERATION:
-        /* A match with an empty string is preferred over no match at
-           all, so we go through the argument if possible. */
-        iter = (tre_iteration_t *)node->obj;
-        if (iter->arg->nullable) STACK_PUSHX(stack, voidptr, iter->arg);
-        break;
+	case ITERATION:
+	  /* A match with an empty string is preferred over no match at
+	     all, so we go through the argument if possible. */
+	  iter = (tre_iteration_t *)node->obj;
+	  if (iter->arg->nullable)
+	    STACK_PUSHX(stack, voidptr, iter->arg);
+	  break;
 
-      default:
-        __builtin_unreachable();
+	default:
+	  assert(0);
+	  break;
+	}
     }
-  }
 
   return status;
 }
 
+
 typedef enum {
   NFL_RECURSE,
   NFL_POST_UNION,
@@ -2008,211 +2264,263 @@ typedef enum {
   NFL_POST_ITERATION
 } tre_nfl_stack_symbol_t;
 
+
 /* Computes and fills in the fields `nullable', `firstpos', and `lastpos' for
    the nodes of the AST `tree'. */
-static reg_errcode_t tre_compute_nfl(tre_mem_t mem, tre_stack_t *stack,
-                                     tre_ast_node_t *tree) {
+static reg_errcode_t
+tre_compute_nfl(tre_mem_t mem, tre_stack_t *stack, tre_ast_node_t *tree)
+{
   int bottom = tre_stack_num_objects(stack);
 
   STACK_PUSHR(stack, voidptr, tree);
   STACK_PUSHR(stack, int, NFL_RECURSE);
 
-  while (tre_stack_num_objects(stack) > bottom) {
-    tre_nfl_stack_symbol_t symbol;
-    tre_ast_node_t *node;
+  while (tre_stack_num_objects(stack) > bottom)
+    {
+      tre_nfl_stack_symbol_t symbol;
+      tre_ast_node_t *node;
 
-    symbol = (tre_nfl_stack_symbol_t)tre_stack_pop_int(stack);
-    node = tre_stack_pop_voidptr(stack);
-    switch (symbol) {
-      case NFL_RECURSE:
-        switch (node->type) {
-          case LITERAL: {
-            tre_literal_t *lit = (tre_literal_t *)node->obj;
-            if (IS_BACKREF(lit)) {
-              /* Back references: nullable = false, firstpos = {i},
-                 lastpos = {i}. */
-              node->nullable = 0;
-              node->firstpos =
-                  tre_set_one(mem, lit->position, 0, TRE_CHAR_MAX, 0, NULL, -1);
-              if (!node->firstpos) return REG_ESPACE;
-              node->lastpos = tre_set_one(mem, lit->position, 0, TRE_CHAR_MAX,
-                                          0, NULL, (int)lit->code_max);
-              if (!node->lastpos) return REG_ESPACE;
-            } else if (lit->code_min < 0) {
-              /* Tags, empty strings, params, and zero width assertions:
-                 nullable = true, firstpos = {}, and lastpos = {}. */
-              node->nullable = 1;
-              node->firstpos = tre_set_empty(mem);
-              if (!node->firstpos) return REG_ESPACE;
-              node->lastpos = tre_set_empty(mem);
-              if (!node->lastpos) return REG_ESPACE;
-            } else {
-              /* Literal at position i: nullable = false, firstpos = {i},
-                 lastpos = {i}. */
-              node->nullable = 0;
-              node->firstpos =
-                  tre_set_one(mem, lit->position, (int)lit->code_min,
-                              (int)lit->code_max, 0, NULL, -1);
-              if (!node->firstpos) return REG_ESPACE;
-              node->lastpos = tre_set_one(
-                  mem, lit->position, (int)lit->code_min, (int)lit->code_max,
-                  lit->class, lit->neg_classes, -1);
-              if (!node->lastpos) return REG_ESPACE;
-            }
-            break;
-          }
+      symbol = (tre_nfl_stack_symbol_t)tre_stack_pop_int(stack);
+      node = tre_stack_pop_voidptr(stack);
+      switch (symbol)
+	{
+	case NFL_RECURSE:
+	  switch (node->type)
+	    {
+	    case LITERAL:
+	      {
+		tre_literal_t *lit = (tre_literal_t *)node->obj;
+		if (IS_BACKREF(lit))
+		  {
+		    /* Back references: nullable = false, firstpos = {i},
+		       lastpos = {i}. */
+		    node->nullable = 0;
+		    node->firstpos = tre_set_one(mem, lit->position, 0,
+					     TRE_CHAR_MAX, 0, NULL, -1);
+		    if (!node->firstpos)
+		      return REG_ESPACE;
+		    node->lastpos = tre_set_one(mem, lit->position, 0,
+						TRE_CHAR_MAX, 0, NULL,
+						(int)lit->code_max);
+		    if (!node->lastpos)
+		      return REG_ESPACE;
+		  }
+		else if (lit->code_min < 0)
+		  {
+		    /* Tags, empty strings, params, and zero width assertions:
+		       nullable = true, firstpos = {}, and lastpos = {}. */
+		    node->nullable = 1;
+		    node->firstpos = tre_set_empty(mem);
+		    if (!node->firstpos)
+		      return REG_ESPACE;
+		    node->lastpos = tre_set_empty(mem);
+		    if (!node->lastpos)
+		      return REG_ESPACE;
+		  }
+		else
+		  {
+		    /* Literal at position i: nullable = false, firstpos = {i},
+		       lastpos = {i}. */
+		    node->nullable = 0;
+		    node->firstpos =
+		      tre_set_one(mem, lit->position, (int)lit->code_min,
+				  (int)lit->code_max, 0, NULL, -1);
+		    if (!node->firstpos)
+		      return REG_ESPACE;
+		    node->lastpos = tre_set_one(mem, lit->position,
+						(int)lit->code_min,
+						(int)lit->code_max,
+						lit->class, lit->neg_classes,
+						-1);
+		    if (!node->lastpos)
+		      return REG_ESPACE;
+		  }
+		break;
+	      }
 
-          case UNION:
-            /* Compute the attributes for the two subtrees, and after that
-               for this node. */
-            STACK_PUSHR(stack, voidptr, node);
-            STACK_PUSHR(stack, int, NFL_POST_UNION);
-            STACK_PUSHR(stack, voidptr, ((tre_union_t *)node->obj)->right);
-            STACK_PUSHR(stack, int, NFL_RECURSE);
-            STACK_PUSHR(stack, voidptr, ((tre_union_t *)node->obj)->left);
-            STACK_PUSHR(stack, int, NFL_RECURSE);
-            break;
+	    case UNION:
+	      /* Compute the attributes for the two subtrees, and after that
+		 for this node. */
+	      STACK_PUSHR(stack, voidptr, node);
+	      STACK_PUSHR(stack, int, NFL_POST_UNION);
+	      STACK_PUSHR(stack, voidptr, ((tre_union_t *)node->obj)->right);
+	      STACK_PUSHR(stack, int, NFL_RECURSE);
+	      STACK_PUSHR(stack, voidptr, ((tre_union_t *)node->obj)->left);
+	      STACK_PUSHR(stack, int, NFL_RECURSE);
+	      break;
 
-          case CATENATION:
-            /* Compute the attributes for the two subtrees, and after that
-               for this node. */
-            STACK_PUSHR(stack, voidptr, node);
-            STACK_PUSHR(stack, int, NFL_POST_CATENATION);
-            STACK_PUSHR(stack, voidptr, ((tre_catenation_t *)node->obj)->right);
-            STACK_PUSHR(stack, int, NFL_RECURSE);
-            STACK_PUSHR(stack, voidptr, ((tre_catenation_t *)node->obj)->left);
-            STACK_PUSHR(stack, int, NFL_RECURSE);
-            break;
+	    case CATENATION:
+	      /* Compute the attributes for the two subtrees, and after that
+		 for this node. */
+	      STACK_PUSHR(stack, voidptr, node);
+	      STACK_PUSHR(stack, int, NFL_POST_CATENATION);
+	      STACK_PUSHR(stack, voidptr, ((tre_catenation_t *)node->obj)->right);
+	      STACK_PUSHR(stack, int, NFL_RECURSE);
+	      STACK_PUSHR(stack, voidptr, ((tre_catenation_t *)node->obj)->left);
+	      STACK_PUSHR(stack, int, NFL_RECURSE);
+	      break;
 
-          case ITERATION:
-            /* Compute the attributes for the subtree, and after that for
-               this node. */
-            STACK_PUSHR(stack, voidptr, node);
-            STACK_PUSHR(stack, int, NFL_POST_ITERATION);
-            STACK_PUSHR(stack, voidptr, ((tre_iteration_t *)node->obj)->arg);
-            STACK_PUSHR(stack, int, NFL_RECURSE);
-            break;
-        }
-        break; /* end case: NFL_RECURSE */
+	    case ITERATION:
+	      /* Compute the attributes for the subtree, and after that for
+		 this node. */
+	      STACK_PUSHR(stack, voidptr, node);
+	      STACK_PUSHR(stack, int, NFL_POST_ITERATION);
+	      STACK_PUSHR(stack, voidptr, ((tre_iteration_t *)node->obj)->arg);
+	      STACK_PUSHR(stack, int, NFL_RECURSE);
+	      break;
+	    }
+	  break; /* end case: NFL_RECURSE */
 
-      case NFL_POST_UNION: {
-        tre_union_t *uni = (tre_union_t *)node->obj;
-        node->nullable = uni->left->nullable || uni->right->nullable;
-        node->firstpos = tre_set_union(mem, uni->left->firstpos,
-                                       uni->right->firstpos, NULL, 0);
-        if (!node->firstpos) return REG_ESPACE;
-        node->lastpos = tre_set_union(mem, uni->left->lastpos,
-                                      uni->right->lastpos, NULL, 0);
-        if (!node->lastpos) return REG_ESPACE;
-        break;
-      }
+	case NFL_POST_UNION:
+	  {
+	    tre_union_t *uni = (tre_union_t *)node->obj;
+	    node->nullable = uni->left->nullable || uni->right->nullable;
+	    node->firstpos = tre_set_union(mem, uni->left->firstpos,
+					   uni->right->firstpos, NULL, 0);
+	    if (!node->firstpos)
+	      return REG_ESPACE;
+	    node->lastpos = tre_set_union(mem, uni->left->lastpos,
+					  uni->right->lastpos, NULL, 0);
+	    if (!node->lastpos)
+	      return REG_ESPACE;
+	    break;
+	  }
 
-      case NFL_POST_ITERATION: {
-        tre_iteration_t *iter = (tre_iteration_t *)node->obj;
+	case NFL_POST_ITERATION:
+	  {
+	    tre_iteration_t *iter = (tre_iteration_t *)node->obj;
 
-        if (iter->min == 0 || iter->arg->nullable)
-          node->nullable = 1;
-        else
-          node->nullable = 0;
-        node->firstpos = iter->arg->firstpos;
-        node->lastpos = iter->arg->lastpos;
-        break;
-      }
+	    if (iter->min == 0 || iter->arg->nullable)
+	      node->nullable = 1;
+	    else
+	      node->nullable = 0;
+	    node->firstpos = iter->arg->firstpos;
+	    node->lastpos = iter->arg->lastpos;
+	    break;
+	  }
 
-      case NFL_POST_CATENATION: {
-        int num_tags, *tags, assertions;
-        reg_errcode_t status;
-        tre_catenation_t *cat = node->obj;
-        node->nullable = cat->left->nullable && cat->right->nullable;
+	case NFL_POST_CATENATION:
+	  {
+	    int num_tags, *tags, assertions;
+	    reg_errcode_t status;
+	    tre_catenation_t *cat = node->obj;
+	    node->nullable = cat->left->nullable && cat->right->nullable;
 
-        /* Compute firstpos. */
-        if (cat->left->nullable) {
-          /* The left side matches the empty string.  Make a first pass
-             with tre_match_empty() to get the number of tags and
-             parameters. */
-          status = tre_match_empty(stack, cat->left, NULL, NULL, &num_tags);
-          if (status != REG_OK) return status;
-          /* Allocate arrays for the tags and parameters. */
-          tags = malloc(sizeof(*tags) * (num_tags + 1));
-          if (!tags) return REG_ESPACE;
-          tags[0] = -1;
-          assertions = 0;
-          /* Second pass with tre_mach_empty() to get the list of
-             tags and parameters. */
-          status = tre_match_empty(stack, cat->left, tags, &assertions, NULL);
-          if (status != REG_OK) {
-            free(tags), tags = NULL;
-            return status;
-          }
-          node->firstpos = tre_set_union(mem, cat->right->firstpos,
-                                         cat->left->firstpos, tags, assertions);
-          free(tags), tags = NULL;
-          if (!node->firstpos) return REG_ESPACE;
-        } else {
-          node->firstpos = cat->left->firstpos;
-        }
+	    /* Compute firstpos. */
+	    if (cat->left->nullable)
+	      {
+		/* The left side matches the empty string.  Make a first pass
+		   with tre_match_empty() to get the number of tags and
+		   parameters. */
+		status = tre_match_empty(stack, cat->left,
+					 NULL, NULL, &num_tags);
+		if (status != REG_OK)
+		  return status;
+		/* Allocate arrays for the tags and parameters. */
+		tags = xmalloc(sizeof(*tags) * (num_tags + 1));
+		if (!tags)
+		  return REG_ESPACE;
+		tags[0] = -1;
+		assertions = 0;
+		/* Second pass with tre_mach_empty() to get the list of
+		   tags and parameters. */
+		status = tre_match_empty(stack, cat->left, tags,
+					 &assertions, NULL);
+		if (status != REG_OK)
+		  {
+		    xfree(tags);
+		    return status;
+		  }
+		node->firstpos =
+		  tre_set_union(mem, cat->right->firstpos, cat->left->firstpos,
+				tags, assertions);
+		xfree(tags);
+		if (!node->firstpos)
+		  return REG_ESPACE;
+	      }
+	    else
+	      {
+		node->firstpos = cat->left->firstpos;
+	      }
 
-        /* Compute lastpos. */
-        if (cat->right->nullable) {
-          /* The right side matches the empty string.  Make a first pass
-             with tre_match_empty() to get the number of tags and
-             parameters. */
-          status = tre_match_empty(stack, cat->right, NULL, NULL, &num_tags);
-          if (status != REG_OK) return status;
-          /* Allocate arrays for the tags and parameters. */
-          tags = malloc(sizeof(int) * (num_tags + 1));
-          if (!tags) return REG_ESPACE;
-          tags[0] = -1;
-          assertions = 0;
-          /* Second pass with tre_mach_empty() to get the list of
-             tags and parameters. */
-          status = tre_match_empty(stack, cat->right, tags, &assertions, NULL);
-          if (status != REG_OK) {
-            free(tags), tags = NULL;
-            return status;
-          }
-          node->lastpos = tre_set_union(mem, cat->left->lastpos,
-                                        cat->right->lastpos, tags, assertions);
-          free(tags), tags = NULL;
-          if (!node->lastpos) return REG_ESPACE;
-        } else {
-          node->lastpos = cat->right->lastpos;
-        }
-        break;
-      }
+	    /* Compute lastpos. */
+	    if (cat->right->nullable)
+	      {
+		/* The right side matches the empty string.  Make a first pass
+		   with tre_match_empty() to get the number of tags and
+		   parameters. */
+		status = tre_match_empty(stack, cat->right,
+					 NULL, NULL, &num_tags);
+		if (status != REG_OK)
+		  return status;
+		/* Allocate arrays for the tags and parameters. */
+		tags = xmalloc(sizeof(int) * (num_tags + 1));
+		if (!tags)
+		  return REG_ESPACE;
+		tags[0] = -1;
+		assertions = 0;
+		/* Second pass with tre_mach_empty() to get the list of
+		   tags and parameters. */
+		status = tre_match_empty(stack, cat->right, tags,
+					 &assertions, NULL);
+		if (status != REG_OK)
+		  {
+		    xfree(tags);
+		    return status;
+		  }
+		node->lastpos =
+		  tre_set_union(mem, cat->left->lastpos, cat->right->lastpos,
+				tags, assertions);
+		xfree(tags);
+		if (!node->lastpos)
+		  return REG_ESPACE;
+	      }
+	    else
+	      {
+		node->lastpos = cat->right->lastpos;
+	      }
+	    break;
+	  }
 
-      default:
-        __builtin_unreachable();
+	default:
+	  assert(0);
+	  break;
+	}
     }
-  }
 
   return REG_OK;
 }
 
+
 /* Adds a transition from each position in `p1' to each position in `p2'. */
-static reg_errcode_t tre_make_trans(tre_pos_and_tags_t *p1,
-                                    tre_pos_and_tags_t *p2,
-                                    tre_tnfa_transition_t *transitions,
-                                    int *counts, int *offs) {
+static reg_errcode_t
+tre_make_trans(tre_pos_and_tags_t *p1, tre_pos_and_tags_t *p2,
+	       tre_tnfa_transition_t *transitions,
+	       int *counts, int *offs)
+{
   tre_pos_and_tags_t *orig_p2 = p2;
   tre_tnfa_transition_t *trans;
   int i, j, k, l, dup, prev_p2_pos;
 
   if (transitions != NULL)
-    while (p1->position >= 0) {
-      p2 = orig_p2;
-      prev_p2_pos = -1;
-      while (p2->position >= 0) {
-        /* Optimization: if this position was already handled, skip it. */
-        if (p2->position == prev_p2_pos) {
-          p2++;
-          continue;
-        }
-        prev_p2_pos = p2->position;
-        /* Set `trans' to point to the next unused transition from
-           position `p1->position'. */
-        trans = transitions + offs[p1->position];
-        while (trans->state != NULL) {
+    while (p1->position >= 0)
+      {
+	p2 = orig_p2;
+	prev_p2_pos = -1;
+	while (p2->position >= 0)
+	  {
+	    /* Optimization: if this position was already handled, skip it. */
+	    if (p2->position == prev_p2_pos)
+	      {
+		p2++;
+		continue;
+	      }
+	    prev_p2_pos = p2->position;
+	    /* Set `trans' to point to the next unused transition from
+	       position `p1->position'. */
+	    trans = transitions + offs[p1->position];
+	    while (trans->state != NULL)
+	      {
 #if 0
 		/* If we find a previous transition from `p1->position' to
 		   `p2->position', it is overwritten.  This can happen only
@@ -2230,92 +2538,108 @@ static reg_errcode_t tre_make_trans(tre_pos_and_tags_t *p1,
 		    break;
 		  }
 #endif
-          trans++;
-        }
+		trans++;
+	      }
 
-        if (trans->state == NULL) (trans + 1)->state = NULL;
-        /* Use the character ranges, assertions, etc. from `p1' for
-           the transition from `p1' to `p2'. */
-        trans->code_min = p1->code_min;
-        trans->code_max = p1->code_max;
-        trans->state = transitions + offs[p2->position];
-        trans->state_id = p2->position;
-        trans->assertions =
-            p1->assertions | p2->assertions |
-            (p1->class ? ASSERT_CHAR_CLASS : 0) |
-            (p1->neg_classes != NULL ? ASSERT_CHAR_CLASS_NEG : 0);
-        if (p1->backref >= 0) {
-          unassert((trans->assertions & ASSERT_CHAR_CLASS) == 0);
-          unassert(p2->backref < 0);
-          trans->u.backref = p1->backref;
-          trans->assertions |= ASSERT_BACKREF;
-        } else
-          trans->u.class = p1->class;
-        if (p1->neg_classes != NULL) {
-          for (i = 0; p1->neg_classes[i] != (tre_ctype_t)0; i++)
-            ;
-          trans->neg_classes = malloc(sizeof(*trans->neg_classes) * (i + 1));
-          if (trans->neg_classes == NULL) return REG_ESPACE;
-          for (i = 0; p1->neg_classes[i] != (tre_ctype_t)0; i++)
-            trans->neg_classes[i] = p1->neg_classes[i];
-          trans->neg_classes[i] = (tre_ctype_t)0;
-        } else
-          trans->neg_classes = NULL;
+	    if (trans->state == NULL)
+	      (trans + 1)->state = NULL;
+	    /* Use the character ranges, assertions, etc. from `p1' for
+	       the transition from `p1' to `p2'. */
+	    trans->code_min = p1->code_min;
+	    trans->code_max = p1->code_max;
+	    trans->state = transitions + offs[p2->position];
+	    trans->state_id = p2->position;
+	    trans->assertions = p1->assertions | p2->assertions
+	      | (p1->class ? ASSERT_CHAR_CLASS : 0)
+	      | (p1->neg_classes != NULL ? ASSERT_CHAR_CLASS_NEG : 0);
+	    if (p1->backref >= 0)
+	      {
+		assert((trans->assertions & ASSERT_CHAR_CLASS) == 0);
+		assert(p2->backref < 0);
+		trans->u.backref = p1->backref;
+		trans->assertions |= ASSERT_BACKREF;
+	      }
+	    else
+	      trans->u.class = p1->class;
+	    if (p1->neg_classes != NULL)
+	      {
+		for (i = 0; p1->neg_classes[i] != (tre_ctype_t)0; i++);
+		trans->neg_classes =
+		  xmalloc(sizeof(*trans->neg_classes) * (i + 1));
+		if (trans->neg_classes == NULL)
+		  return REG_ESPACE;
+		for (i = 0; p1->neg_classes[i] != (tre_ctype_t)0; i++)
+		  trans->neg_classes[i] = p1->neg_classes[i];
+		trans->neg_classes[i] = (tre_ctype_t)0;
+	      }
+	    else
+	      trans->neg_classes = NULL;
 
-        /* Find out how many tags this transition has. */
-        i = 0;
-        if (p1->tags != NULL)
-          while (p1->tags[i] >= 0) i++;
-        j = 0;
-        if (p2->tags != NULL)
-          while (p2->tags[j] >= 0) j++;
+	    /* Find out how many tags this transition has. */
+	    i = 0;
+	    if (p1->tags != NULL)
+	      while(p1->tags[i] >= 0)
+		i++;
+	    j = 0;
+	    if (p2->tags != NULL)
+	      while(p2->tags[j] >= 0)
+		j++;
 
-        /* If we are overwriting a transition, free the old tag array. */
-        if (trans->tags != NULL) free(trans->tags), trans->tags = NULL;
-        trans->tags = NULL;
+	    /* If we are overwriting a transition, free the old tag array. */
+	    if (trans->tags != NULL)
+	      xfree(trans->tags);
+	    trans->tags = NULL;
 
-        /* If there were any tags, allocate an array and fill it. */
-        if (i + j > 0) {
-          trans->tags = malloc(sizeof(*trans->tags) * (i + j + 1));
-          if (!trans->tags) return REG_ESPACE;
-          i = 0;
-          if (p1->tags != NULL)
-            while (p1->tags[i] >= 0) {
-              trans->tags[i] = p1->tags[i];
-              i++;
-            }
-          l = i;
-          j = 0;
-          if (p2->tags != NULL)
-            while (p2->tags[j] >= 0) {
-              /* Don't add duplicates. */
-              dup = 0;
-              for (k = 0; k < i; k++)
-                if (trans->tags[k] == p2->tags[j]) {
-                  dup = 1;
-                  break;
-                }
-              if (!dup) trans->tags[l++] = p2->tags[j];
-              j++;
-            }
-          trans->tags[l] = -1;
-        }
+	    /* If there were any tags, allocate an array and fill it. */
+	    if (i + j > 0)
+	      {
+		trans->tags = xmalloc(sizeof(*trans->tags) * (i + j + 1));
+		if (!trans->tags)
+		  return REG_ESPACE;
+		i = 0;
+		if (p1->tags != NULL)
+		  while(p1->tags[i] >= 0)
+		    {
+		      trans->tags[i] = p1->tags[i];
+		      i++;
+		    }
+		l = i;
+		j = 0;
+		if (p2->tags != NULL)
+		  while (p2->tags[j] >= 0)
+		    {
+		      /* Don't add duplicates. */
+		      dup = 0;
+		      for (k = 0; k < i; k++)
+			if (trans->tags[k] == p2->tags[j])
+			  {
+			    dup = 1;
+			    break;
+			  }
+		      if (!dup)
+			trans->tags[l++] = p2->tags[j];
+		      j++;
+		    }
+		trans->tags[l] = -1;
+	      }
 
-        p2++;
+	    p2++;
+	  }
+	p1++;
       }
-      p1++;
-    }
   else
     /* Compute a maximum limit for the number of transitions leaving
        from each state. */
-    while (p1->position >= 0) {
-      p2 = orig_p2;
-      while (p2->position >= 0) {
-        counts[p1->position]++;
-        p2++;
+    while (p1->position >= 0)
+      {
+	p2 = orig_p2;
+	while (p2->position >= 0)
+	  {
+	    counts[p1->position]++;
+	    p2++;
+	  }
+	p1++;
       }
-      p1++;
-    }
   return REG_OK;
 }
 
@@ -2323,60 +2647,72 @@ static reg_errcode_t tre_make_trans(tre_pos_and_tags_t *p1,
    labelled with one character range (there are no transitions on empty
    strings).  The TNFA takes O(n^2) space in the worst case, `n' is size of
    the regexp. */
-static reg_errcode_t tre_ast_to_tnfa(tre_ast_node_t *node,
-                                     tre_tnfa_transition_t *transitions,
-                                     int *counts, int *offs) {
+static reg_errcode_t
+tre_ast_to_tnfa(tre_ast_node_t *node, tre_tnfa_transition_t *transitions,
+		int *counts, int *offs)
+{
   tre_union_t *uni;
   tre_catenation_t *cat;
   tre_iteration_t *iter;
   reg_errcode_t errcode = REG_OK;
 
   /* XXX - recurse using a stack!. */
-  switch (node->type) {
+  switch (node->type)
+    {
     case LITERAL:
       break;
     case UNION:
       uni = (tre_union_t *)node->obj;
       errcode = tre_ast_to_tnfa(uni->left, transitions, counts, offs);
-      if (errcode != REG_OK) return errcode;
+      if (errcode != REG_OK)
+	return errcode;
       errcode = tre_ast_to_tnfa(uni->right, transitions, counts, offs);
       break;
 
     case CATENATION:
       cat = (tre_catenation_t *)node->obj;
       /* Add a transition from each position in cat->left->lastpos
-         to each position in cat->right->firstpos. */
+	 to each position in cat->right->firstpos. */
       errcode = tre_make_trans(cat->left->lastpos, cat->right->firstpos,
-                               transitions, counts, offs);
-      if (errcode != REG_OK) return errcode;
+			       transitions, counts, offs);
+      if (errcode != REG_OK)
+	return errcode;
       errcode = tre_ast_to_tnfa(cat->left, transitions, counts, offs);
-      if (errcode != REG_OK) return errcode;
+      if (errcode != REG_OK)
+	return errcode;
       errcode = tre_ast_to_tnfa(cat->right, transitions, counts, offs);
       break;
 
     case ITERATION:
       iter = (tre_iteration_t *)node->obj;
-      unassert(iter->max == -1 || iter->max == 1);
+      assert(iter->max == -1 || iter->max == 1);
 
-      if (iter->max == -1) {
-        unassert(iter->min == 0 || iter->min == 1);
-        /* Add a transition from each last position in the iterated
-           expression to each first position. */
-        errcode = tre_make_trans(iter->arg->lastpos, iter->arg->firstpos,
-                                 transitions, counts, offs);
-        if (errcode != REG_OK) return errcode;
-      }
+      if (iter->max == -1)
+	{
+	  assert(iter->min == 0 || iter->min == 1);
+	  /* Add a transition from each last position in the iterated
+	     expression to each first position. */
+	  errcode = tre_make_trans(iter->arg->lastpos, iter->arg->firstpos,
+				   transitions, counts, offs);
+	  if (errcode != REG_OK)
+	    return errcode;
+	}
       errcode = tre_ast_to_tnfa(iter->arg, transitions, counts, offs);
       break;
-  }
+    }
   return errcode;
 }
 
-#define ERROR_EXIT(err)                   \
-  do {                                    \
-    errcode = err;                        \
-    if (/*CONSTCOND*/ 1) goto error_exit; \
-  } while (/*CONSTCOND*/ 0)
+
+#define ERROR_EXIT(err)		  \
+  do				  \
+    {				  \
+      errcode = err;		  \
+      if (/*CONSTCOND*/1)	  \
+      	goto error_exit;	  \
+    }				  \
+ while (/*CONSTCOND*/0)
+
 
 /**
  * Compiles regular expression, e.g.
@@ -2395,7 +2731,9 @@ static reg_errcode_t tre_ast_to_tnfa(tre_ast_node_t *node,
  * @return REG_OK, REG_NOMATCH, REG_BADPAT, etc.
  * @see regexec(), regfree(), regerror()
  */
-int regcomp(regex_t *preg, const char *regex, int cflags) {
+int
+regcomp(regex_t *restrict preg, const char *restrict regex, int cflags)
+{
   tre_stack_t *stack;
   tre_ast_node_t *tree, *tmp_ast_l, *tmp_ast_r;
   tre_pos_and_tags_t *p;
@@ -2414,23 +2752,26 @@ int regcomp(regex_t *preg, const char *regex, int cflags) {
   /* Allocate a stack used throughout the compilation process for various
      purposes. */
   stack = tre_stack_new(512, 1024000, 128);
-  if (!stack) return REG_ESPACE;
+  if (!stack)
+    return REG_ESPACE;
   /* Allocate a fast memory allocator. */
   mem = tre_mem_new();
-  if (!mem) {
-    tre_stack_destroy(stack);
-    return REG_ESPACE;
-  }
+  if (!mem)
+    {
+      tre_stack_destroy(stack);
+      return REG_ESPACE;
+    }
 
   /* Parse the regexp. */
-  bzero(&parse_ctx, sizeof(parse_ctx));
+  memset(&parse_ctx, 0, sizeof(parse_ctx));
   parse_ctx.mem = mem;
   parse_ctx.stack = stack;
   parse_ctx.start = regex;
   parse_ctx.cflags = cflags;
   parse_ctx.max_backref = -1;
   errcode = tre_parse(&parse_ctx);
-  if (errcode != REG_OK) ERROR_EXIT(errcode);
+  if (errcode != REG_OK)
+    ERROR_EXIT(errcode);
   preg->re_nsub = parse_ctx.submatch_id - 1;
   tree = parse_ctx.n;
 
@@ -2439,115 +2780,141 @@ int regcomp(regex_t *preg, const char *regex, int cflags) {
 #endif /* TRE_DEBUG */
 
   /* Referring to nonexistent subexpressions is illegal. */
-  if (parse_ctx.max_backref > (int)preg->re_nsub) ERROR_EXIT(REG_ESUBREG);
+  if (parse_ctx.max_backref > (int)preg->re_nsub)
+    ERROR_EXIT(REG_ESUBREG);
 
   /* Allocate the TNFA struct. */
-  tnfa = calloc(1, sizeof(tre_tnfa_t));
-  if (tnfa == NULL) ERROR_EXIT(REG_ESPACE);
+  tnfa = xcalloc(1, sizeof(tre_tnfa_t));
+  if (tnfa == NULL)
+    ERROR_EXIT(REG_ESPACE);
   tnfa->have_backrefs = parse_ctx.max_backref >= 0;
   tnfa->have_approx = 0;
   tnfa->num_submatches = parse_ctx.submatch_id;
 
   /* Set up tags for submatch addressing.  If REG_NOSUB is set and the
      regexp does not have back references, this can be skipped. */
-  if (tnfa->have_backrefs || !(cflags & REG_NOSUB)) {
-    /* Figure out how many tags we will need. */
-    errcode = tre_add_tags(NULL, stack, tree, tnfa);
-    if (errcode != REG_OK) ERROR_EXIT(errcode);
+  if (tnfa->have_backrefs || !(cflags & REG_NOSUB))
+    {
+
+      /* Figure out how many tags we will need. */
+      errcode = tre_add_tags(NULL, stack, tree, tnfa);
+      if (errcode != REG_OK)
+	ERROR_EXIT(errcode);
+
+      if (tnfa->num_tags > 0)
+	{
+	  tag_directions = xmalloc(sizeof(*tag_directions)
+				   * (tnfa->num_tags + 1));
+	  if (tag_directions == NULL)
+	    ERROR_EXIT(REG_ESPACE);
+	  tnfa->tag_directions = tag_directions;
+	  memset(tag_directions, -1,
+		 sizeof(*tag_directions) * (tnfa->num_tags + 1));
+	}
+      tnfa->minimal_tags = xcalloc((unsigned)tnfa->num_tags * 2 + 1,
+				   sizeof(*tnfa->minimal_tags));
+      if (tnfa->minimal_tags == NULL)
+	ERROR_EXIT(REG_ESPACE);
+
+      submatch_data = xcalloc((unsigned)parse_ctx.submatch_id,
+			      sizeof(*submatch_data));
+      if (submatch_data == NULL)
+	ERROR_EXIT(REG_ESPACE);
+      tnfa->submatch_data = submatch_data;
+
+      errcode = tre_add_tags(mem, stack, tree, tnfa);
+      if (errcode != REG_OK)
+	ERROR_EXIT(errcode);
 
-    if (tnfa->num_tags > 0) {
-      tag_directions = malloc(sizeof(*tag_directions) * (tnfa->num_tags + 1));
-      if (tag_directions == NULL) ERROR_EXIT(REG_ESPACE);
-      tnfa->tag_directions = tag_directions;
-      memset(tag_directions, -1,
-             sizeof(*tag_directions) * (tnfa->num_tags + 1));
     }
-    tnfa->minimal_tags =
-        calloc((unsigned)tnfa->num_tags * 2 + 1, sizeof(*tnfa->minimal_tags));
-    if (tnfa->minimal_tags == NULL) ERROR_EXIT(REG_ESPACE);
-
-    submatch_data =
-        calloc((unsigned)parse_ctx.submatch_id, sizeof(*submatch_data));
-    if (submatch_data == NULL) ERROR_EXIT(REG_ESPACE);
-    tnfa->submatch_data = submatch_data;
-
-    errcode = tre_add_tags(mem, stack, tree, tnfa);
-    if (errcode != REG_OK) ERROR_EXIT(errcode);
-  }
 
   /* Expand iteration nodes. */
-  errcode =
-      tre_expand_ast(mem, stack, tree, &parse_ctx.position, tag_directions);
-  if (errcode != REG_OK) ERROR_EXIT(errcode);
+  errcode = tre_expand_ast(mem, stack, tree, &parse_ctx.position,
+			   tag_directions);
+  if (errcode != REG_OK)
+    ERROR_EXIT(errcode);
 
   /* Add a dummy node for the final state.
      XXX - For certain patterns this dummy node can be optimized away,
-           for example "a*" or "ab*".	Figure out a simple way to detect
-           this possibility. */
+	   for example "a*" or "ab*".	Figure out a simple way to detect
+	   this possibility. */
   tmp_ast_l = tree;
   tmp_ast_r = tre_ast_new_literal(mem, 0, 0, parse_ctx.position++);
-  if (tmp_ast_r == NULL) ERROR_EXIT(REG_ESPACE);
+  if (tmp_ast_r == NULL)
+    ERROR_EXIT(REG_ESPACE);
 
   tree = tre_ast_new_catenation(mem, tmp_ast_l, tmp_ast_r);
-  if (tree == NULL) ERROR_EXIT(REG_ESPACE);
+  if (tree == NULL)
+    ERROR_EXIT(REG_ESPACE);
 
   errcode = tre_compute_nfl(mem, stack, tree);
-  if (errcode != REG_OK) ERROR_EXIT(errcode);
+  if (errcode != REG_OK)
+    ERROR_EXIT(errcode);
 
-  counts = malloc(sizeof(int) * parse_ctx.position);
-  if (counts == NULL) ERROR_EXIT(REG_ESPACE);
+  counts = xmalloc(sizeof(int) * parse_ctx.position);
+  if (counts == NULL)
+    ERROR_EXIT(REG_ESPACE);
 
-  offs = malloc(sizeof(int) * parse_ctx.position);
-  if (offs == NULL) ERROR_EXIT(REG_ESPACE);
+  offs = xmalloc(sizeof(int) * parse_ctx.position);
+  if (offs == NULL)
+    ERROR_EXIT(REG_ESPACE);
 
-  for (i = 0; i < parse_ctx.position; i++) counts[i] = 0;
+  for (i = 0; i < parse_ctx.position; i++)
+    counts[i] = 0;
   tre_ast_to_tnfa(tree, NULL, counts, NULL);
 
   add = 0;
-  for (i = 0; i < parse_ctx.position; i++) {
-    offs[i] = add;
-    add += counts[i] + 1;
-    counts[i] = 0;
-  }
-  transitions = calloc((unsigned)add + 1, sizeof(*transitions));
-  if (transitions == NULL) ERROR_EXIT(REG_ESPACE);
+  for (i = 0; i < parse_ctx.position; i++)
+    {
+      offs[i] = add;
+      add += counts[i] + 1;
+      counts[i] = 0;
+    }
+  transitions = xcalloc((unsigned)add + 1, sizeof(*transitions));
+  if (transitions == NULL)
+    ERROR_EXIT(REG_ESPACE);
   tnfa->transitions = transitions;
   tnfa->num_transitions = add;
 
   errcode = tre_ast_to_tnfa(tree, transitions, counts, offs);
-  if (errcode != REG_OK) ERROR_EXIT(errcode);
+  if (errcode != REG_OK)
+    ERROR_EXIT(errcode);
 
   tnfa->firstpos_chars = NULL;
 
   p = tree->firstpos;
   i = 0;
-  while (p->position >= 0) {
-    i++;
-    p++;
-  }
+  while (p->position >= 0)
+    {
+      i++;
+      p++;
+    }
 
-  initial = calloc((unsigned)i + 1, sizeof(tre_tnfa_transition_t));
-  if (initial == NULL) ERROR_EXIT(REG_ESPACE);
+  initial = xcalloc((unsigned)i + 1, sizeof(tre_tnfa_transition_t));
+  if (initial == NULL)
+    ERROR_EXIT(REG_ESPACE);
   tnfa->initial = initial;
 
   i = 0;
-  for (p = tree->firstpos; p->position >= 0; p++) {
-    initial[i].state = transitions + offs[p->position];
-    initial[i].state_id = p->position;
-    initial[i].tags = NULL;
-    /* Copy the arrays p->tags, and p->params, they are allocated
-       from a tre_mem object. */
-    if (p->tags) {
-      int j;
-      for (j = 0; p->tags[j] >= 0; j++)
-        ;
-      initial[i].tags = malloc(sizeof(*p->tags) * (j + 1));
-      if (!initial[i].tags) ERROR_EXIT(REG_ESPACE);
-      memcpy(initial[i].tags, p->tags, sizeof(*p->tags) * (j + 1));
+  for (p = tree->firstpos; p->position >= 0; p++)
+    {
+      initial[i].state = transitions + offs[p->position];
+      initial[i].state_id = p->position;
+      initial[i].tags = NULL;
+      /* Copy the arrays p->tags, and p->params, they are allocated
+	 from a tre_mem object. */
+      if (p->tags)
+	{
+	  int j;
+	  for (j = 0; p->tags[j] >= 0; j++);
+	  initial[i].tags = xmalloc(sizeof(*p->tags) * (j + 1));
+	  if (!initial[i].tags)
+	    ERROR_EXIT(REG_ESPACE);
+	  memcpy(initial[i].tags, p->tags, sizeof(*p->tags) * (j + 1));
+	}
+      initial[i].assertions = p->assertions;
+      i++;
     }
-    initial[i].assertions = p->assertions;
-    i++;
-  }
   initial[i].state = NULL;
 
   tnfa->num_transitions = add;
@@ -2557,23 +2924,29 @@ int regcomp(regex_t *preg, const char *regex, int cflags) {
 
   tre_mem_destroy(mem);
   tre_stack_destroy(stack);
-  free(counts), counts = NULL;
-  free(offs), offs = NULL;
+  xfree(counts);
+  xfree(offs);
 
   preg->TRE_REGEX_T_FIELD = (void *)tnfa;
   return REG_OK;
 
-error_exit:
+ error_exit:
   /* Free everything that was allocated and return the error code. */
   tre_mem_destroy(mem);
-  if (stack != NULL) tre_stack_destroy(stack);
-  if (counts != NULL) free(counts), counts = NULL;
-  if (offs != NULL) free(offs), offs = NULL;
+  if (stack != NULL)
+    tre_stack_destroy(stack);
+  if (counts != NULL)
+    xfree(counts);
+  if (offs != NULL)
+    xfree(offs);
   preg->TRE_REGEX_T_FIELD = (void *)tnfa;
   regfree(preg);
   return errcode;
 }
 
+
+
+
 /**
  * Frees any memory allocated by regcomp().
  *
@@ -2581,43 +2954,51 @@ error_exit:
  * which case subsequent calls do nothing. Once a regex is freed, it may
  * be passed to regcomp() to reinitialize it.
  */
-void regfree(regex_t *preg) {
-  unsigned int i;
+void
+regfree(regex_t *preg)
+{
   tre_tnfa_t *tnfa;
+  unsigned int i;
   tre_tnfa_transition_t *trans;
-  if ((tnfa = preg->TRE_REGEX_T_FIELD)) {
-    preg->TRE_REGEX_T_FIELD = 0;
-    for (i = 0; i < tnfa->num_transitions; i++)
-      if (tnfa->transitions[i].state) {
-        if (tnfa->transitions[i].tags) {
-          free(tnfa->transitions[i].tags);
-        }
-        if (tnfa->transitions[i].neg_classes) {
-          free(tnfa->transitions[i].neg_classes);
-        }
+
+  tnfa = (void *)preg->TRE_REGEX_T_FIELD;
+  if (!tnfa)
+    return;
+
+  for (i = 0; i < tnfa->num_transitions; i++)
+    if (tnfa->transitions[i].state)
+      {
+	if (tnfa->transitions[i].tags)
+	  xfree(tnfa->transitions[i].tags);
+	if (tnfa->transitions[i].neg_classes)
+	  xfree(tnfa->transitions[i].neg_classes);
       }
-    if (tnfa->transitions) {
-      free(tnfa->transitions);
+  if (tnfa->transitions)
+    xfree(tnfa->transitions);
+
+  if (tnfa->initial)
+    {
+      for (trans = tnfa->initial; trans->state; trans++)
+	{
+	  if (trans->tags)
+	    xfree(trans->tags);
+	}
+      xfree(tnfa->initial);
     }
-    if (tnfa->initial) {
-      for (trans = tnfa->initial; trans->state; trans++) {
-        if (trans->tags) {
-          free(trans->tags);
-        }
-      }
-      free(tnfa->initial);
+
+  if (tnfa->submatch_data)
+    {
+      for (i = 0; i < tnfa->num_submatches; i++)
+	if (tnfa->submatch_data[i].parents)
+	  xfree(tnfa->submatch_data[i].parents);
+      xfree(tnfa->submatch_data);
     }
-    if (tnfa->submatch_data) {
-      for (i = 0; i < tnfa->num_submatches; i++) {
-        if (tnfa->submatch_data[i].parents) {
-          free(tnfa->submatch_data[i].parents);
-        }
-      }
-      free(tnfa->submatch_data);
-    }
-    if (tnfa->tag_directions) free(tnfa->tag_directions);
-    if (tnfa->firstpos_chars) free(tnfa->firstpos_chars);
-    if (tnfa->minimal_tags) free(tnfa->minimal_tags);
-    free(tnfa);
-  }
+
+  if (tnfa->tag_directions)
+    xfree(tnfa->tag_directions);
+  if (tnfa->firstpos_chars)
+    xfree(tnfa->firstpos_chars);
+  if (tnfa->minimal_tags)
+    xfree(tnfa->minimal_tags);
+  xfree(tnfa);
 }
diff --git a/third_party/regex/regerror.c b/third_party/regex/regerror.c
index 8564b2ed1..dbd4b763d 100644
--- a/third_party/regex/regerror.c
+++ b/third_party/regex/regerror.c
@@ -1,65 +1,37 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "third_party/regex/regex.h"
+#include <string.h>
+#include <regex.h>
+#include <stdio.h>
+#include "libc/str/locale.internal.h"
 
 /* Error message strings for error codes listed in `regex.h'.  This list
    needs to be in sync with the codes listed there, naturally. */
 
-static const char kRegexErrors[] =
-    "No error\0"
-    "No match\0"
-    "Invalid regexp\0"
-    "Unknown collating element\0"
-    "Unknown character class name\0"
-    "Trailing backslash\0"
-    "Invalid back reference\0"
-    "Missing ']'\0"
-    "Missing ')'\0"
-    "Missing '}'\0"
-    "Invalid contents of {}\0"
-    "Invalid character range\0"
-    "Out of memory\0"
-    "Repetition not preceded by valid expression\0";
+/* Converted to single string by Rich Felker to remove the need for
+ * data relocations at runtime, 27 Feb 2006. */
 
-static const char *IndexDoubleNulString(const char *s, unsigned i) {
-  size_t n;
-  while (i--) {
-    if ((n = strlen(s))) {
-      s += n + 1;
-    } else {
-      return NULL;
-    }
-  }
-  return s;
-}
+static const char messages[] = {
+  "No error\0"
+  "No match\0"
+  "Invalid regexp\0"
+  "Unknown collating element\0"
+  "Unknown character class name\0"
+  "Trailing backslash\0"
+  "Invalid back reference\0"
+  "Missing ']'\0"
+  "Missing ')'\0"
+  "Missing '}'\0"
+  "Invalid contents of {}\0"
+  "Invalid character range\0"
+  "Out of memory\0"
+  "Repetition not preceded by valid expression\0"
+  "\0Unknown error"
+};
 
-/**
- * Converts regular expression error code to string.
- *
- * @param e is error code
- * @return number of bytes needed to hold entire string
- */
-size_t regerror(int e, const regex_t *preg, char *buf, size_t size) {
-  return 1 + (snprintf)(buf, size, "%s",
-                        firstnonnull(IndexDoubleNulString(kRegexErrors, e),
-                                     "Unknown error"));
+size_t regerror(int e, const regex_t *restrict preg, char *restrict buf, size_t size)
+{
+	const char *s;
+	for (s=messages; e && *s; e--, s+=strlen(s)+1);
+	if (!*s) s++;
+	s = LCTRANS_CUR(s);
+	return 1+snprintf(buf, size, "%s", s);
 }
diff --git a/third_party/regex/regexec.c b/third_party/regex/regexec.c
index fd4b4446f..d99696d8a 100644
--- a/third_party/regex/regexec.c
+++ b/third_party/regex/regexec.c
@@ -65,86 +65,99 @@ TRE regex (BSD-2 License)\n\
 Copyright 2001-2009 Ville Laurikari <vl@iki.fi>\n\
 Copyright 2016 Szabolcs Nagy");
 
-static void tre_fill_pmatch(size_t nmatch, regmatch_t pmatch[], int cflags,
-                            const tre_tnfa_t *tnfa, regoff_t *tags,
-                            regoff_t match_eo);
+static void
+tre_fill_pmatch(size_t nmatch, regmatch_t pmatch[], int cflags,
+		const tre_tnfa_t *tnfa, regoff_t *tags, regoff_t match_eo);
 
 /***********************************************************************
  from tre-match-utils.h
 ***********************************************************************/
 
-#define GET_NEXT_WCHAR()                                               \
-  do {                                                                 \
-    prev_c = next_c;                                                   \
-    pos += pos_add_next;                                               \
-    if ((pos_add_next = mbtowc(&next_c, str_byte, MB_LEN_MAX)) <= 0) { \
-      if (pos_add_next < 0) {                                          \
-        ret = REG_NOMATCH;                                             \
-        goto error_exit;                                               \
-      } else                                                           \
-        pos_add_next++;                                                \
-    }                                                                  \
-    str_byte += pos_add_next;                                          \
+#define GET_NEXT_WCHAR() do {                                                 \
+    prev_c = next_c; pos += pos_add_next;                                     \
+    if ((pos_add_next = mbtowc(&next_c, str_byte, MB_LEN_MAX)) <= 0) {        \
+        if (pos_add_next < 0) { ret = REG_NOMATCH; goto error_exit; }         \
+        else pos_add_next++;                                                  \
+    }                                                                         \
+    str_byte += pos_add_next;                                                 \
   } while (0)
 
-#define IS_WORD_CHAR(c) ((c) == L'_' || tre_isalnum(c))
+#define IS_WORD_CHAR(c)	 ((c) == L'_' || tre_isalnum(c))
+
+#define CHECK_ASSERTIONS(assertions)					      \
+  (((assertions & ASSERT_AT_BOL)					      \
+    && (pos > 0 || reg_notbol)						      \
+    && (prev_c != L'\n' || !reg_newline))				      \
+   || ((assertions & ASSERT_AT_EOL)					      \
+       && (next_c != L'\0' || reg_noteol)				      \
+       && (next_c != L'\n' || !reg_newline))				      \
+   || ((assertions & ASSERT_AT_BOW)					      \
+       && (IS_WORD_CHAR(prev_c) || !IS_WORD_CHAR(next_c)))	              \
+   || ((assertions & ASSERT_AT_EOW)					      \
+       && (!IS_WORD_CHAR(prev_c) || IS_WORD_CHAR(next_c)))		      \
+   || ((assertions & ASSERT_AT_WB)					      \
+       && (pos != 0 && next_c != L'\0'					      \
+	   && IS_WORD_CHAR(prev_c) == IS_WORD_CHAR(next_c)))		      \
+   || ((assertions & ASSERT_AT_WB_NEG)					      \
+       && (pos == 0 || next_c == L'\0'					      \
+	   || IS_WORD_CHAR(prev_c) != IS_WORD_CHAR(next_c))))
+
+#define CHECK_CHAR_CLASSES(trans_i, tnfa, eflags)                             \
+  (((trans_i->assertions & ASSERT_CHAR_CLASS)                                 \
+       && !(tnfa->cflags & REG_ICASE)                                         \
+       && !tre_isctype((tre_cint_t)prev_c, trans_i->u.class))                 \
+    || ((trans_i->assertions & ASSERT_CHAR_CLASS)                             \
+        && (tnfa->cflags & REG_ICASE)                                         \
+        && !tre_isctype(tre_tolower((tre_cint_t)prev_c),trans_i->u.class)     \
+	&& !tre_isctype(tre_toupper((tre_cint_t)prev_c),trans_i->u.class))    \
+    || ((trans_i->assertions & ASSERT_CHAR_CLASS_NEG)                         \
+        && tre_neg_char_classes_match(trans_i->neg_classes,(tre_cint_t)prev_c,\
+                                      tnfa->cflags & REG_ICASE)))
+
 
-#define CHECK_ASSERTIONS(assertions)                                   \
-  (((assertions & ASSERT_AT_BOL) && (pos > 0 || reg_notbol) &&         \
-    (prev_c != L'\n' || !reg_newline)) ||                              \
-   ((assertions & ASSERT_AT_EOL) && (next_c != L'\0' || reg_noteol) && \
-    (next_c != L'\n' || !reg_newline)) ||                              \
-   ((assertions & ASSERT_AT_BOW) &&                                    \
-    (IS_WORD_CHAR(prev_c) || !IS_WORD_CHAR(next_c))) ||                \
-   ((assertions & ASSERT_AT_EOW) &&                                    \
-    (!IS_WORD_CHAR(prev_c) || IS_WORD_CHAR(next_c))) ||                \
-   ((assertions & ASSERT_AT_WB) &&                                     \
-    (pos != 0 && next_c != L'\0' &&                                    \
-     IS_WORD_CHAR(prev_c) == IS_WORD_CHAR(next_c))) ||                 \
-   ((assertions & ASSERT_AT_WB_NEG) &&                                 \
-    (pos == 0 || next_c == L'\0' ||                                    \
-     IS_WORD_CHAR(prev_c) != IS_WORD_CHAR(next_c))))
 
-#define CHECK_CHAR_CLASSES(trans_i, tnfa, eflags)                              \
-  (((trans_i->assertions & ASSERT_CHAR_CLASS) &&                               \
-    !(tnfa->cflags & REG_ICASE) &&                                             \
-    !tre_isctype((tre_cint_t)prev_c, trans_i->u.class)) ||                     \
-   ((trans_i->assertions & ASSERT_CHAR_CLASS) && (tnfa->cflags & REG_ICASE) && \
-    !tre_isctype(tre_tolower((tre_cint_t)prev_c), trans_i->u.class) &&         \
-    !tre_isctype(tre_toupper((tre_cint_t)prev_c), trans_i->u.class)) ||        \
-   ((trans_i->assertions & ASSERT_CHAR_CLASS_NEG) &&                           \
-    tre_neg_char_classes_match(trans_i->neg_classes, (tre_cint_t)prev_c,       \
-                               tnfa->cflags & REG_ICASE)))
 
 /* Returns 1 if `t1' wins `t2', 0 otherwise. */
-static int tre_tag_order(int num_tags, tre_tag_direction_t *tag_directions,
-                         regoff_t *t1, regoff_t *t2) {
+static int
+tre_tag_order(int num_tags, tre_tag_direction_t *tag_directions,
+	      regoff_t *t1, regoff_t *t2)
+{
   int i;
-  for (i = 0; i < num_tags; i++) {
-    if (tag_directions[i] == TRE_TAG_MINIMIZE) {
-      if (t1[i] < t2[i]) return 1;
-      if (t1[i] > t2[i]) return 0;
-    } else {
-      if (t1[i] > t2[i]) return 1;
-      if (t1[i] < t2[i]) return 0;
+  for (i = 0; i < num_tags; i++)
+    {
+      if (tag_directions[i] == TRE_TAG_MINIMIZE)
+	{
+	  if (t1[i] < t2[i])
+	    return 1;
+	  if (t1[i] > t2[i])
+	    return 0;
+	}
+      else
+	{
+	  if (t1[i] > t2[i])
+	    return 1;
+	  if (t1[i] < t2[i])
+	    return 0;
+	}
     }
-  }
   /*  assert(0);*/
   return 0;
 }
 
-static int tre_neg_char_classes_match(tre_ctype_t *classes, tre_cint_t wc,
-                                      int icase) {
+static int
+tre_neg_char_classes_match(tre_ctype_t *classes, tre_cint_t wc, int icase)
+{
   while (*classes != (tre_ctype_t)0)
-    if ((!icase && tre_isctype(wc, *classes)) ||
-        (icase && (tre_isctype(tre_toupper(wc), *classes) ||
-                   tre_isctype(tre_tolower(wc), *classes))))
+    if ((!icase && tre_isctype(wc, *classes))
+	|| (icase && (tre_isctype(tre_toupper(wc), *classes)
+		      || tre_isctype(tre_tolower(wc), *classes))))
       return 1; /* Match. */
     else
       classes++;
   return 0; /* No match. */
 }
 
+
 /***********************************************************************
  from tre-match-parallel.c
 ***********************************************************************/
@@ -175,10 +188,12 @@ typedef struct {
   regoff_t **tags;
 } tre_reach_pos_t;
 
-static reg_errcode_t tre_tnfa_run_parallel(const tre_tnfa_t *tnfa,
-                                           const void *string,
-                                           regoff_t *match_tags, int eflags,
-                                           regoff_t *match_end_ofs) {
+
+static reg_errcode_t
+tre_tnfa_run_parallel(const tre_tnfa_t *tnfa, const void *string,
+		      regoff_t *match_tags, int eflags,
+		      regoff_t *match_end_ofs)
+{
   /* State variables required by GET_NEXT_WCHAR. */
   tre_char_t prev_c = 0, next_c = 0;
   const char *str_byte = string;
@@ -199,13 +214,13 @@ static reg_errcode_t tre_tnfa_run_parallel(const tre_tnfa_t *tnfa,
   int *tag_i;
   int num_tags, i;
 
-  regoff_t match_eo = -1; /* end offset of match (-1 if no match found yet) */
+  regoff_t match_eo = -1;	   /* end offset of match (-1 if no match found yet) */
   int new_match = 0;
   regoff_t *tmp_tags = NULL;
   regoff_t *tmp_iptr;
 
 #ifdef TRE_MBSTATE
-  bzero(&mbstate, sizeof(mbstate));
+  memset(&mbstate, '\0', sizeof(mbstate));
 #endif /* TRE_MBSTATE */
 
   if (!match_tags)
@@ -222,15 +237,15 @@ static reg_errcode_t tre_tnfa_run_parallel(const tre_tnfa_t *tnfa,
 
     /* Ensure that tbytes and xbytes*num_states cannot overflow, and that
      * they don't contribute more than 1/8 of SIZE_MAX to total_bytes. */
-    if (num_tags > SIZE_MAX / (8 * sizeof(regoff_t) * tnfa->num_states))
+    if (num_tags > SIZE_MAX/(8 * sizeof(regoff_t) * tnfa->num_states))
       return REG_ESPACE;
 
     /* Likewise check rbytes. */
-    if (tnfa->num_states + 1 > SIZE_MAX / (8 * sizeof(*reach_next)))
+    if (tnfa->num_states+1 > SIZE_MAX/(8 * sizeof(*reach_next)))
       return REG_ESPACE;
 
     /* Likewise check pbytes. */
-    if (tnfa->num_states > SIZE_MAX / (8 * sizeof(*reach_pos)))
+    if (tnfa->num_states > SIZE_MAX/(8 * sizeof(*reach_pos)))
       return REG_ESPACE;
 
     /* Compute the length of the block we need. */
@@ -238,12 +253,14 @@ static reg_errcode_t tre_tnfa_run_parallel(const tre_tnfa_t *tnfa,
     rbytes = sizeof(*reach_next) * (tnfa->num_states + 1);
     pbytes = sizeof(*reach_pos) * tnfa->num_states;
     xbytes = sizeof(regoff_t) * num_tags;
-    total_bytes = (sizeof(long) - 1) * 4 /* for alignment paddings */
-                  + (rbytes + xbytes * tnfa->num_states) * 2 + tbytes + pbytes;
+    total_bytes =
+      (sizeof(long) - 1) * 4 /* for alignment paddings */
+      + (rbytes + xbytes * tnfa->num_states) * 2 + tbytes + pbytes;
 
     /* Allocate the memory. */
     buf = calloc(total_bytes, 1);
-    if (buf == NULL) return REG_ESPACE;
+    if (buf == NULL)
+      return REG_ESPACE;
 
     /* Get the various pointers within tmp_buf (properly aligned). */
     tmp_tags = (void *)buf;
@@ -258,177 +275,216 @@ static reg_errcode_t tre_tnfa_run_parallel(const tre_tnfa_t *tnfa,
     reach_pos = (void *)tmp_buf;
     tmp_buf += pbytes;
     tmp_buf += ALIGN(tmp_buf, long);
-    for (i = 0; i < tnfa->num_states; i++) {
-      reach[i].tags = (void *)tmp_buf;
-      tmp_buf += xbytes;
-      reach_next[i].tags = (void *)tmp_buf;
-      tmp_buf += xbytes;
-    }
+    for (i = 0; i < tnfa->num_states; i++)
+      {
+	reach[i].tags = (void *)tmp_buf;
+	tmp_buf += xbytes;
+	reach_next[i].tags = (void *)tmp_buf;
+	tmp_buf += xbytes;
+      }
   }
 
-  for (i = 0; i < tnfa->num_states; i++) reach_pos[i].pos = -1;
+  for (i = 0; i < tnfa->num_states; i++)
+    reach_pos[i].pos = -1;
 
   GET_NEXT_WCHAR();
   pos = 0;
 
   reach_next_i = reach_next;
-  while (1) {
-    /* If no match found yet, add the initial states to `reach_next'. */
-    if (match_eo < 0) {
-      trans_i = tnfa->initial;
-      while (trans_i->state != NULL) {
-        if (reach_pos[trans_i->state_id].pos < pos) {
-          if (trans_i->assertions && CHECK_ASSERTIONS(trans_i->assertions)) {
-            trans_i++;
-            continue;
-          }
+  while (1)
+    {
+      /* If no match found yet, add the initial states to `reach_next'. */
+      if (match_eo < 0)
+	{
+	  trans_i = tnfa->initial;
+	  while (trans_i->state != NULL)
+	    {
+	      if (reach_pos[trans_i->state_id].pos < pos)
+		{
+		  if (trans_i->assertions
+		      && CHECK_ASSERTIONS(trans_i->assertions))
+		    {
+		      trans_i++;
+		      continue;
+		    }
 
-          reach_next_i->state = trans_i->state;
-          for (i = 0; i < num_tags; i++) reach_next_i->tags[i] = -1;
-          tag_i = trans_i->tags;
-          if (tag_i)
-            while (*tag_i >= 0) {
-              if (*tag_i < num_tags) reach_next_i->tags[*tag_i] = pos;
-              tag_i++;
-            }
-          if (reach_next_i->state == tnfa->final) {
-            match_eo = pos;
-            new_match = 1;
-            for (i = 0; i < num_tags; i++)
-              match_tags[i] = reach_next_i->tags[i];
-          }
-          reach_pos[trans_i->state_id].pos = pos;
-          reach_pos[trans_i->state_id].tags = &reach_next_i->tags;
-          reach_next_i++;
-        }
-        trans_i++;
-      }
-      reach_next_i->state = NULL;
-    } else {
-      if (num_tags == 0 || reach_next_i == reach_next)
-        /* We have found a match. */
-        break;
-    }
+		  reach_next_i->state = trans_i->state;
+		  for (i = 0; i < num_tags; i++)
+		    reach_next_i->tags[i] = -1;
+		  tag_i = trans_i->tags;
+		  if (tag_i)
+		    while (*tag_i >= 0)
+		      {
+			if (*tag_i < num_tags)
+			  reach_next_i->tags[*tag_i] = pos;
+			tag_i++;
+		      }
+		  if (reach_next_i->state == tnfa->final)
+		    {
+		      match_eo = pos;
+		      new_match = 1;
+		      for (i = 0; i < num_tags; i++)
+			match_tags[i] = reach_next_i->tags[i];
+		    }
+		  reach_pos[trans_i->state_id].pos = pos;
+		  reach_pos[trans_i->state_id].tags = &reach_next_i->tags;
+		  reach_next_i++;
+		}
+	      trans_i++;
+	    }
+	  reach_next_i->state = NULL;
+	}
+      else
+	{
+	  if (num_tags == 0 || reach_next_i == reach_next)
+	    /* We have found a match. */
+	    break;
+	}
 
-    /* Check for end of string. */
-    if (!next_c) break;
+      /* Check for end of string. */
+      if (!next_c) break;
 
-    GET_NEXT_WCHAR();
-
-    /* Swap `reach' and `reach_next'. */
-    reach_i = reach;
-    reach = reach_next;
-    reach_next = reach_i;
-
-    /* For each state in `reach', weed out states that don't fulfill the
-       minimal matching conditions. */
-    if (tnfa->num_minimals && new_match) {
-      new_match = 0;
-      reach_next_i = reach_next;
-      for (reach_i = reach; reach_i->state; reach_i++) {
-        int skip = 0;
-        for (i = 0; tnfa->minimal_tags[i] >= 0; i += 2) {
-          int end = tnfa->minimal_tags[i];
-          int start = tnfa->minimal_tags[i + 1];
-          if (end >= num_tags) {
-            skip = 1;
-            break;
-          } else if (reach_i->tags[start] == match_tags[start] &&
-                     reach_i->tags[end] < match_tags[end]) {
-            skip = 1;
-            break;
-          }
-        }
-        if (!skip) {
-          reach_next_i->state = reach_i->state;
-          tmp_iptr = reach_next_i->tags;
-          reach_next_i->tags = reach_i->tags;
-          reach_i->tags = tmp_iptr;
-          reach_next_i++;
-        }
-      }
-      reach_next_i->state = NULL;
+      GET_NEXT_WCHAR();
 
       /* Swap `reach' and `reach_next'. */
       reach_i = reach;
       reach = reach_next;
       reach_next = reach_i;
+
+      /* For each state in `reach', weed out states that don't fulfill the
+	 minimal matching conditions. */
+      if (tnfa->num_minimals && new_match)
+	{
+	  new_match = 0;
+	  reach_next_i = reach_next;
+	  for (reach_i = reach; reach_i->state; reach_i++)
+	    {
+	      int skip = 0;
+	      for (i = 0; tnfa->minimal_tags[i] >= 0; i += 2)
+		{
+		  int end = tnfa->minimal_tags[i];
+		  int start = tnfa->minimal_tags[i + 1];
+		  if (end >= num_tags)
+		    {
+		      skip = 1;
+		      break;
+		    }
+		  else if (reach_i->tags[start] == match_tags[start]
+			   && reach_i->tags[end] < match_tags[end])
+		    {
+		      skip = 1;
+		      break;
+		    }
+		}
+	      if (!skip)
+		{
+		  reach_next_i->state = reach_i->state;
+		  tmp_iptr = reach_next_i->tags;
+		  reach_next_i->tags = reach_i->tags;
+		  reach_i->tags = tmp_iptr;
+		  reach_next_i++;
+		}
+	    }
+	  reach_next_i->state = NULL;
+
+	  /* Swap `reach' and `reach_next'. */
+	  reach_i = reach;
+	  reach = reach_next;
+	  reach_next = reach_i;
+	}
+
+      /* For each state in `reach' see if there is a transition leaving with
+	 the current input symbol to a state not yet in `reach_next', and
+	 add the destination states to `reach_next'. */
+      reach_next_i = reach_next;
+      for (reach_i = reach; reach_i->state; reach_i++)
+	{
+	  for (trans_i = reach_i->state; trans_i->state; trans_i++)
+	    {
+	      /* Does this transition match the input symbol? */
+	      if (trans_i->code_min <= (tre_cint_t)prev_c &&
+		  trans_i->code_max >= (tre_cint_t)prev_c)
+		{
+		  if (trans_i->assertions
+		      && (CHECK_ASSERTIONS(trans_i->assertions)
+			  || CHECK_CHAR_CLASSES(trans_i, tnfa, eflags)))
+		    {
+		      continue;
+		    }
+
+		  /* Compute the tags after this transition. */
+		  for (i = 0; i < num_tags; i++)
+		    tmp_tags[i] = reach_i->tags[i];
+		  tag_i = trans_i->tags;
+		  if (tag_i != NULL)
+		    while (*tag_i >= 0)
+		      {
+			if (*tag_i < num_tags)
+			  tmp_tags[*tag_i] = pos;
+			tag_i++;
+		      }
+
+		  if (reach_pos[trans_i->state_id].pos < pos)
+		    {
+		      /* Found an unvisited node. */
+		      reach_next_i->state = trans_i->state;
+		      tmp_iptr = reach_next_i->tags;
+		      reach_next_i->tags = tmp_tags;
+		      tmp_tags = tmp_iptr;
+		      reach_pos[trans_i->state_id].pos = pos;
+		      reach_pos[trans_i->state_id].tags = &reach_next_i->tags;
+
+		      if (reach_next_i->state == tnfa->final
+			  && (match_eo == -1
+			      || (num_tags > 0
+				  && reach_next_i->tags[0] <= match_tags[0])))
+			{
+			  match_eo = pos;
+			  new_match = 1;
+			  for (i = 0; i < num_tags; i++)
+			    match_tags[i] = reach_next_i->tags[i];
+			}
+		      reach_next_i++;
+
+		    }
+		  else
+		    {
+		      assert(reach_pos[trans_i->state_id].pos == pos);
+		      /* Another path has also reached this state.  We choose
+			 the winner by examining the tag values for both
+			 paths. */
+		      if (tre_tag_order(num_tags, tnfa->tag_directions,
+					tmp_tags,
+					*reach_pos[trans_i->state_id].tags))
+			{
+			  /* The new path wins. */
+			  tmp_iptr = *reach_pos[trans_i->state_id].tags;
+			  *reach_pos[trans_i->state_id].tags = tmp_tags;
+			  if (trans_i->state == tnfa->final)
+			    {
+			      match_eo = pos;
+			      new_match = 1;
+			      for (i = 0; i < num_tags; i++)
+				match_tags[i] = tmp_tags[i];
+			    }
+			  tmp_tags = tmp_iptr;
+			}
+		    }
+		}
+	    }
+	}
+      reach_next_i->state = NULL;
     }
 
-    /* For each state in `reach' see if there is a transition leaving with
-       the current input symbol to a state not yet in `reach_next', and
-       add the destination states to `reach_next'. */
-    reach_next_i = reach_next;
-    for (reach_i = reach; reach_i->state; reach_i++) {
-      for (trans_i = reach_i->state; trans_i->state; trans_i++) {
-        /* Does this transition match the input symbol? */
-        if (trans_i->code_min <= (tre_cint_t)prev_c &&
-            trans_i->code_max >= (tre_cint_t)prev_c) {
-          if (trans_i->assertions &&
-              (CHECK_ASSERTIONS(trans_i->assertions) ||
-               CHECK_CHAR_CLASSES(trans_i, tnfa, eflags))) {
-            continue;
-          }
-
-          /* Compute the tags after this transition. */
-          for (i = 0; i < num_tags; i++) tmp_tags[i] = reach_i->tags[i];
-          tag_i = trans_i->tags;
-          if (tag_i != NULL)
-            while (*tag_i >= 0) {
-              if (*tag_i < num_tags) tmp_tags[*tag_i] = pos;
-              tag_i++;
-            }
-
-          if (reach_pos[trans_i->state_id].pos < pos) {
-            /* Found an unvisited node. */
-            reach_next_i->state = trans_i->state;
-            tmp_iptr = reach_next_i->tags;
-            reach_next_i->tags = tmp_tags;
-            tmp_tags = tmp_iptr;
-            reach_pos[trans_i->state_id].pos = pos;
-            reach_pos[trans_i->state_id].tags = &reach_next_i->tags;
-
-            if (reach_next_i->state == tnfa->final &&
-                (match_eo == -1 ||
-                 (num_tags > 0 && reach_next_i->tags[0] <= match_tags[0]))) {
-              match_eo = pos;
-              new_match = 1;
-              for (i = 0; i < num_tags; i++)
-                match_tags[i] = reach_next_i->tags[i];
-            }
-            reach_next_i++;
-
-          } else {
-            unassert(reach_pos[trans_i->state_id].pos == pos);
-            /* Another path has also reached this state.  We choose
-               the winner by examining the tag values for both
-               paths. */
-            if (tre_tag_order(num_tags, tnfa->tag_directions, tmp_tags,
-                              *reach_pos[trans_i->state_id].tags)) {
-              /* The new path wins. */
-              tmp_iptr = *reach_pos[trans_i->state_id].tags;
-              *reach_pos[trans_i->state_id].tags = tmp_tags;
-              if (trans_i->state == tnfa->final) {
-                match_eo = pos;
-                new_match = 1;
-                for (i = 0; i < num_tags; i++) match_tags[i] = tmp_tags[i];
-              }
-              tmp_tags = tmp_iptr;
-            }
-          }
-        }
-      }
-    }
-    reach_next_i->state = NULL;
-  }
-
   *match_end_ofs = match_eo;
   ret = match_eo >= 0 ? REG_OK : REG_NOMATCH;
 error_exit:
-  free(buf), buf = NULL;
+  xfree(buf);
   return ret;
 }
 
+
+
 /***********************************************************************
  from tre-match-backtrack.c
 ***********************************************************************/
@@ -472,7 +528,7 @@ typedef struct tre_backtrack_struct {
   tre_backtrack_item_t item;
   struct tre_backtrack_struct *prev;
   struct tre_backtrack_struct *next;
-} * tre_backtrack_t;
+} *tre_backtrack_t;
 
 #ifdef TRE_MBSTATE
 #define BT_STACK_MBSTATE_IN  stack->item.mbstate = (mbstate)
@@ -482,67 +538,84 @@ typedef struct tre_backtrack_struct {
 #define BT_STACK_MBSTATE_OUT
 #endif /* !TRE_MBSTATE */
 
-#define tre_bt_mem_new     tre_mem_new
-#define tre_bt_mem_alloc   tre_mem_alloc
-#define tre_bt_mem_destroy tre_mem_destroy
+#define tre_bt_mem_new		  tre_mem_new
+#define tre_bt_mem_alloc	  tre_mem_alloc
+#define tre_bt_mem_destroy	  tre_mem_destroy
 
-#define BT_STACK_PUSH(_pos, _str_byte, _str_wide, _state, _state_id, _next_c, \
-                      _tags, _mbstate)                                        \
-  do {                                                                        \
-    int i;                                                                    \
-    if (!stack->next) {                                                       \
-      tre_backtrack_t s;                                                      \
-      s = tre_bt_mem_alloc(mem, sizeof(*s));                                  \
-      if (!s) {                                                               \
-        tre_bt_mem_destroy(mem);                                              \
-        if (tags) free(tags), tags = NULL;                                    \
-        if (pmatch) free(pmatch), pmatch = NULL;                              \
-        if (states_seen) free(states_seen), states_seen = NULL;               \
-        return REG_ESPACE;                                                    \
-      }                                                                       \
-      s->prev = stack;                                                        \
-      s->next = NULL;                                                         \
-      s->item.tags = tre_bt_mem_alloc(mem, sizeof(*tags) * tnfa->num_tags);   \
-      if (!s->item.tags) {                                                    \
-        tre_bt_mem_destroy(mem);                                              \
-        if (tags) free(tags), tags = NULL;                                    \
-        if (pmatch) free(pmatch), pmatch = NULL;                              \
-        if (states_seen) free(states_seen), states_seen = NULL;               \
-        return REG_ESPACE;                                                    \
-      }                                                                       \
-      stack->next = s;                                                        \
-      stack = s;                                                              \
-    } else                                                                    \
-      stack = stack->next;                                                    \
-    stack->item.pos = (_pos);                                                 \
-    stack->item.str_byte = (_str_byte);                                       \
-    stack->item.state = (_state);                                             \
-    stack->item.state_id = (_state_id);                                       \
-    stack->item.next_c = (_next_c);                                           \
-    for (i = 0; i < tnfa->num_tags; i++) stack->item.tags[i] = (_tags)[i];    \
-    BT_STACK_MBSTATE_IN;                                                      \
-  } while (0)
 
-#define BT_STACK_POP()                                                  \
-  do {                                                                  \
-    int i;                                                              \
-    unassert(stack->prev);                                              \
-    pos = stack->item.pos;                                              \
-    str_byte = stack->item.str_byte;                                    \
-    state = stack->item.state;                                          \
-    next_c = stack->item.next_c;                                        \
-    for (i = 0; i < tnfa->num_tags; i++) tags[i] = stack->item.tags[i]; \
-    BT_STACK_MBSTATE_OUT;                                               \
-    stack = stack->prev;                                                \
-  } while (0)
+#define BT_STACK_PUSH(_pos, _str_byte, _str_wide, _state, _state_id, _next_c, _tags, _mbstate) \
+  do									      \
+    {									      \
+      int i;								      \
+      if (!stack->next)							      \
+	{								      \
+	  tre_backtrack_t s;						      \
+	  s = tre_bt_mem_alloc(mem, sizeof(*s));			      \
+	  if (!s)							      \
+	    {								      \
+	      tre_bt_mem_destroy(mem);					      \
+	      if (tags)							      \
+		xfree(tags);						      \
+	      if (pmatch)						      \
+		xfree(pmatch);						      \
+	      if (states_seen)						      \
+		xfree(states_seen);					      \
+	      return REG_ESPACE;					      \
+	    }								      \
+	  s->prev = stack;						      \
+	  s->next = NULL;						      \
+	  s->item.tags = tre_bt_mem_alloc(mem,				      \
+					  sizeof(*tags) * tnfa->num_tags);    \
+	  if (!s->item.tags)						      \
+	    {								      \
+	      tre_bt_mem_destroy(mem);					      \
+	      if (tags)							      \
+		xfree(tags);						      \
+	      if (pmatch)						      \
+		xfree(pmatch);						      \
+	      if (states_seen)						      \
+		xfree(states_seen);					      \
+	      return REG_ESPACE;					      \
+	    }								      \
+	  stack->next = s;						      \
+	  stack = s;							      \
+	}								      \
+      else								      \
+	stack = stack->next;						      \
+      stack->item.pos = (_pos);						      \
+      stack->item.str_byte = (_str_byte);				      \
+      stack->item.state = (_state);					      \
+      stack->item.state_id = (_state_id);				      \
+      stack->item.next_c = (_next_c);					      \
+      for (i = 0; i < tnfa->num_tags; i++)				      \
+	stack->item.tags[i] = (_tags)[i];				      \
+      BT_STACK_MBSTATE_IN;						      \
+    }									      \
+  while (0)
+
+#define BT_STACK_POP()							      \
+  do									      \
+    {									      \
+      int i;								      \
+      assert(stack->prev);						      \
+      pos = stack->item.pos;						      \
+      str_byte = stack->item.str_byte;					      \
+      state = stack->item.state;					      \
+      next_c = stack->item.next_c;					      \
+      for (i = 0; i < tnfa->num_tags; i++)				      \
+	tags[i] = stack->item.tags[i];					      \
+      BT_STACK_MBSTATE_OUT;						      \
+      stack = stack->prev;						      \
+    }									      \
+  while (0)
 
 #undef MIN
 #define MIN(a, b) ((a) <= (b) ? (a) : (b))
 
-static reg_errcode_t tre_tnfa_run_backtrack(const tre_tnfa_t *tnfa,
-                                            const void *string,
-                                            regoff_t *match_tags, int eflags,
-                                            regoff_t *match_end_ofs) {
+static reg_errcode_t
+tre_tnfa_run_backtrack(const tre_tnfa_t *tnfa, const void *string,
+		       regoff_t *match_tags, int eflags, regoff_t *match_end_ofs)
+{
   /* State variables required by GET_NEXT_WCHAR. */
   tre_char_t prev_c = 0, next_c = 0;
   const char *str_byte = string;
@@ -585,48 +658,60 @@ static reg_errcode_t tre_tnfa_run_backtrack(const tre_tnfa_t *tnfa,
   int ret;
 
 #ifdef TRE_MBSTATE
-  bzero(&mbstate, sizeof(mbstate));
+  memset(&mbstate, '\0', sizeof(mbstate));
 #endif /* TRE_MBSTATE */
 
-  if (!mem) return REG_ESPACE;
+  if (!mem)
+    return REG_ESPACE;
   stack = tre_bt_mem_alloc(mem, sizeof(*stack));
-  if (!stack) {
-    ret = REG_ESPACE;
-    goto error_exit;
-  }
+  if (!stack)
+    {
+      ret = REG_ESPACE;
+      goto error_exit;
+    }
   stack->prev = NULL;
   stack->next = NULL;
 
-  if (tnfa->num_tags) {
-    tags = malloc(sizeof(*tags) * tnfa->num_tags);
-    if (!tags) {
-      ret = REG_ESPACE;
-      goto error_exit;
+  if (tnfa->num_tags)
+    {
+      tags = xmalloc(sizeof(*tags) * tnfa->num_tags);
+      if (!tags)
+	{
+	  ret = REG_ESPACE;
+	  goto error_exit;
+	}
     }
-  }
-  if (tnfa->num_submatches) {
-    pmatch = malloc(sizeof(*pmatch) * tnfa->num_submatches);
-    if (!pmatch) {
-      ret = REG_ESPACE;
-      goto error_exit;
+  if (tnfa->num_submatches)
+    {
+      pmatch = xmalloc(sizeof(*pmatch) * tnfa->num_submatches);
+      if (!pmatch)
+	{
+	  ret = REG_ESPACE;
+	  goto error_exit;
+	}
     }
-  }
-  if (tnfa->num_states) {
-    states_seen = malloc(sizeof(*states_seen) * tnfa->num_states);
-    if (!states_seen) {
-      ret = REG_ESPACE;
-      goto error_exit;
+  if (tnfa->num_states)
+    {
+      states_seen = xmalloc(sizeof(*states_seen) * tnfa->num_states);
+      if (!states_seen)
+	{
+	  ret = REG_ESPACE;
+	  goto error_exit;
+	}
     }
-  }
 
-retry : {
-  int i;
-  for (i = 0; i < tnfa->num_tags; i++) {
-    tags[i] = -1;
-    if (match_tags) match_tags[i] = -1;
+ retry:
+  {
+    int i;
+    for (i = 0; i < tnfa->num_tags; i++)
+      {
+	tags[i] = -1;
+	if (match_tags)
+	  match_tags[i] = -1;
+      }
+    for (i = 0; i < tnfa->num_states; i++)
+      states_seen[i] = 0;
   }
-  for (i = 0; i < tnfa->num_states; i++) states_seen[i] = 0;
-}
 
   state = NULL;
   pos = pos_start;
@@ -640,174 +725,219 @@ retry : {
 
   /* Handle initial states. */
   next_tags = NULL;
-  for (trans_i = tnfa->initial; trans_i->state; trans_i++) {
-    if (trans_i->assertions && CHECK_ASSERTIONS(trans_i->assertions)) {
-      continue;
+  for (trans_i = tnfa->initial; trans_i->state; trans_i++)
+    {
+      if (trans_i->assertions && CHECK_ASSERTIONS(trans_i->assertions))
+	{
+	  continue;
+	}
+      if (state == NULL)
+	{
+	  /* Start from this state. */
+	  state = trans_i->state;
+	  next_tags = trans_i->tags;
+	}
+      else
+	{
+	  /* Backtrack to this state. */
+	  BT_STACK_PUSH(pos, str_byte, 0, trans_i->state,
+			trans_i->state_id, next_c, tags, mbstate);
+	  {
+	    int *tmp = trans_i->tags;
+	    if (tmp)
+	      while (*tmp >= 0)
+		stack->item.tags[*tmp++] = pos;
+	  }
+	}
     }
-    if (state == NULL) {
-      /* Start from this state. */
-      state = trans_i->state;
-      next_tags = trans_i->tags;
-    } else {
-      /* Backtrack to this state. */
-      BT_STACK_PUSH(pos, str_byte, 0, trans_i->state, trans_i->state_id, next_c,
-                    tags, mbstate);
-      {
-        int *tmp = trans_i->tags;
-        if (tmp)
-          while (*tmp >= 0) stack->item.tags[*tmp++] = pos;
-      }
-    }
-  }
 
   if (next_tags)
-    for (; *next_tags >= 0; next_tags++) tags[*next_tags] = pos;
+    for (; *next_tags >= 0; next_tags++)
+      tags[*next_tags] = pos;
 
-  if (state == NULL) goto backtrack;
 
-  while (1) {
-    tre_tnfa_transition_t *next_state;
-    int empty_br_match;
+  if (state == NULL)
+    goto backtrack;
 
-    if (state == tnfa->final) {
-      if (match_eo < pos || (match_eo == pos && match_tags &&
-                             tre_tag_order(tnfa->num_tags, tnfa->tag_directions,
-                                           tags, match_tags))) {
-        int i;
-        /* This match wins the previous match. */
-        match_eo = pos;
-        if (match_tags)
-          for (i = 0; i < tnfa->num_tags; i++) match_tags[i] = tags[i];
-      }
-      /* Our TNFAs never have transitions leaving from the final state,
-         so we jump right to backtracking. */
-      goto backtrack;
-    }
+  while (1)
+    {
+      tre_tnfa_transition_t *next_state;
+      int empty_br_match;
 
-    /* Go to the next character in the input string. */
-    empty_br_match = 0;
-    trans_i = state;
-    if (trans_i->state && trans_i->assertions & ASSERT_BACKREF) {
-      /* This is a back reference state.  All transitions leaving from
-         this state have the same back reference "assertion".  Instead
-         of reading the next character, we match the back reference. */
-      regoff_t so, eo;
-      int bt = trans_i->u.backref;
-      regoff_t bt_len;
-      int result;
+      if (state == tnfa->final)
+	{
+	  if (match_eo < pos
+	      || (match_eo == pos
+		  && match_tags
+		  && tre_tag_order(tnfa->num_tags, tnfa->tag_directions,
+				   tags, match_tags)))
+	    {
+	      int i;
+	      /* This match wins the previous match. */
+	      match_eo = pos;
+	      if (match_tags)
+		for (i = 0; i < tnfa->num_tags; i++)
+		  match_tags[i] = tags[i];
+	    }
+	  /* Our TNFAs never have transitions leaving from the final state,
+	     so we jump right to backtracking. */
+	  goto backtrack;
+	}
 
-      /* Get the substring we need to match against.  Remember to
-         turn off REG_NOSUB temporarily. */
-      tre_fill_pmatch(bt + 1, pmatch, tnfa->cflags & ~REG_NOSUB, tnfa, tags,
-                      pos);
-      so = pmatch[bt].rm_so;
-      eo = pmatch[bt].rm_eo;
-      bt_len = eo - so;
+      /* Go to the next character in the input string. */
+      empty_br_match = 0;
+      trans_i = state;
+      if (trans_i->state && trans_i->assertions & ASSERT_BACKREF)
+	{
+	  /* This is a back reference state.  All transitions leaving from
+	     this state have the same back reference "assertion".  Instead
+	     of reading the next character, we match the back reference. */
+	  regoff_t so, eo;
+	  int bt = trans_i->u.backref;
+	  regoff_t bt_len;
+	  int result;
 
-      result = strncmp((const char *)string + so, str_byte - 1, (size_t)bt_len);
+	  /* Get the substring we need to match against.  Remember to
+	     turn off REG_NOSUB temporarily. */
+	  tre_fill_pmatch(bt + 1, pmatch, tnfa->cflags & ~REG_NOSUB,
+			  tnfa, tags, pos);
+	  so = pmatch[bt].rm_so;
+	  eo = pmatch[bt].rm_eo;
+	  bt_len = eo - so;
 
-      if (result == 0) {
-        /* Back reference matched.  Check for infinite loop. */
-        if (bt_len == 0) empty_br_match = 1;
-        if (empty_br_match && states_seen[trans_i->state_id]) {
-          goto backtrack;
-        }
+	  result = strncmp((const char*)string + so, str_byte - 1,
+				 (size_t)bt_len);
 
-        states_seen[trans_i->state_id] = empty_br_match;
+	  if (result == 0)
+	    {
+	      /* Back reference matched.  Check for infinite loop. */
+	      if (bt_len == 0)
+		empty_br_match = 1;
+	      if (empty_br_match && states_seen[trans_i->state_id])
+		{
+		  goto backtrack;
+		}
 
-        /* Advance in input string and resync `prev_c', `next_c'
-           and pos. */
-        str_byte += bt_len - 1;
-        pos += bt_len - 1;
-        GET_NEXT_WCHAR();
-      } else {
-        goto backtrack;
-      }
-    } else {
-      /* Check for end of string. */
-      if (next_c == L'\0') goto backtrack;
+	      states_seen[trans_i->state_id] = empty_br_match;
 
-      /* Read the next character. */
-      GET_NEXT_WCHAR();
-    }
+	      /* Advance in input string and resync `prev_c', `next_c'
+		 and pos. */
+	      str_byte += bt_len - 1;
+	      pos += bt_len - 1;
+	      GET_NEXT_WCHAR();
+	    }
+	  else
+	    {
+	      goto backtrack;
+	    }
+	}
+      else
+	{
+	  /* Check for end of string. */
+	  if (next_c == L'\0')
+		goto backtrack;
 
-    next_state = NULL;
-    for (trans_i = state; trans_i->state; trans_i++) {
-      if (trans_i->code_min <= (tre_cint_t)prev_c &&
-          trans_i->code_max >= (tre_cint_t)prev_c) {
-        if (trans_i->assertions &&
-            (CHECK_ASSERTIONS(trans_i->assertions) ||
-             CHECK_CHAR_CLASSES(trans_i, tnfa, eflags))) {
-          continue;
-        }
+	  /* Read the next character. */
+	  GET_NEXT_WCHAR();
+	}
 
-        if (next_state == NULL) {
-          /* First matching transition. */
-          next_state = trans_i->state;
-          next_tags = trans_i->tags;
-        } else {
-          /* Second matching transition.  We may need to backtrack here
-             to take this transition instead of the first one, so we
-             push this transition in the backtracking stack so we can
-             jump back here if needed. */
-          BT_STACK_PUSH(pos, str_byte, 0, trans_i->state, trans_i->state_id,
-                        next_c, tags, mbstate);
-          {
-            int *tmp;
-            for (tmp = trans_i->tags; tmp && *tmp >= 0; tmp++)
-              stack->item.tags[*tmp] = pos;
-          }
-#if 0 /* XXX - it's important not to look at all transitions here to keep \
-         the stack small! */
+      next_state = NULL;
+      for (trans_i = state; trans_i->state; trans_i++)
+	{
+	  if (trans_i->code_min <= (tre_cint_t)prev_c
+	      && trans_i->code_max >= (tre_cint_t)prev_c)
+	    {
+	      if (trans_i->assertions
+		  && (CHECK_ASSERTIONS(trans_i->assertions)
+		      || CHECK_CHAR_CLASSES(trans_i, tnfa, eflags)))
+		{
+		  continue;
+		}
+
+	      if (next_state == NULL)
+		{
+		  /* First matching transition. */
+		  next_state = trans_i->state;
+		  next_tags = trans_i->tags;
+		}
+	      else
+		{
+		  /* Second matching transition.  We may need to backtrack here
+		     to take this transition instead of the first one, so we
+		     push this transition in the backtracking stack so we can
+		     jump back here if needed. */
+		  BT_STACK_PUSH(pos, str_byte, 0, trans_i->state,
+				trans_i->state_id, next_c, tags, mbstate);
+		  {
+		    int *tmp;
+		    for (tmp = trans_i->tags; tmp && *tmp >= 0; tmp++)
+		      stack->item.tags[*tmp] = pos;
+		  }
+#if 0 /* XXX - it's important not to look at all transitions here to keep
+	 the stack small! */
 		  break;
 #endif
-        }
-      }
-    }
+		}
+	    }
+	}
 
-    if (next_state != NULL) {
-      /* Matching transitions were found.  Take the first one. */
-      state = next_state;
+      if (next_state != NULL)
+	{
+	  /* Matching transitions were found.  Take the first one. */
+	  state = next_state;
 
-      /* Update the tag values. */
-      if (next_tags)
-        while (*next_tags >= 0) tags[*next_tags++] = pos;
-    } else {
-    backtrack:
-      /* A matching transition was not found.  Try to backtrack. */
-      if (stack->prev) {
-        if (stack->item.state->assertions & ASSERT_BACKREF) {
-          states_seen[stack->item.state_id] = 0;
-        }
+	  /* Update the tag values. */
+	  if (next_tags)
+	    while (*next_tags >= 0)
+	      tags[*next_tags++] = pos;
+	}
+      else
+	{
+	backtrack:
+	  /* A matching transition was not found.  Try to backtrack. */
+	  if (stack->prev)
+	    {
+	      if (stack->item.state->assertions & ASSERT_BACKREF)
+		{
+		  states_seen[stack->item.state_id] = 0;
+		}
 
-        BT_STACK_POP();
-      } else if (match_eo < 0) {
-        /* Try starting from a later position in the input string. */
-        /* Check for end of string. */
-        if (next_c == L'\0') {
-          break;
-        }
-        next_c = next_c_start;
+	      BT_STACK_POP();
+	    }
+	  else if (match_eo < 0)
+	    {
+	      /* Try starting from a later position in the input string. */
+	      /* Check for end of string. */
+	      if (next_c == L'\0')
+		    {
+		      break;
+		    }
+	      next_c = next_c_start;
 #ifdef TRE_MBSTATE
-        mbstate = mbstate_start;
+	      mbstate = mbstate_start;
 #endif /* TRE_MBSTATE */
-        str_byte = str_byte_start;
-        goto retry;
-      } else {
-        break;
-      }
+	      str_byte = str_byte_start;
+	      goto retry;
+	    }
+	  else
+	    {
+	      break;
+	    }
+	}
     }
-  }
 
   ret = match_eo >= 0 ? REG_OK : REG_NOMATCH;
   *match_end_ofs = match_eo;
 
-error_exit:
+ error_exit:
   tre_bt_mem_destroy(mem);
 #ifndef TRE_USE_ALLOCA
-  if (tags) free(tags), tags = NULL;
-  if (pmatch) free(pmatch), pmatch = NULL;
-  if (states_seen) free(states_seen), states_seen = NULL;
+  if (tags)
+    xfree(tags);
+  if (pmatch)
+    xfree(pmatch);
+  if (states_seen)
+    xfree(states_seen);
 #endif /* !TRE_USE_ALLOCA */
 
   return ret;
@@ -819,60 +949,72 @@ error_exit:
 
 /* Fills the POSIX.2 regmatch_t array according to the TNFA tag and match
    endpoint values. */
-static void tre_fill_pmatch(size_t nmatch, regmatch_t pmatch[], int cflags,
-                            const tre_tnfa_t *tnfa, regoff_t *tags,
-                            regoff_t match_eo) {
+static void
+tre_fill_pmatch(size_t nmatch, regmatch_t pmatch[], int cflags,
+		const tre_tnfa_t *tnfa, regoff_t *tags, regoff_t match_eo)
+{
   tre_submatch_data_t *submatch_data;
   unsigned int i, j;
   int *parents;
 
   i = 0;
-  if (match_eo >= 0 && !(cflags & REG_NOSUB)) {
-    /* Construct submatch offsets from the tags. */
-    submatch_data = tnfa->submatch_data;
-    while (i < tnfa->num_submatches && i < nmatch) {
-      if (submatch_data[i].so_tag == tnfa->end_tag)
-        pmatch[i].rm_so = match_eo;
-      else
-        pmatch[i].rm_so = tags[submatch_data[i].so_tag];
+  if (match_eo >= 0 && !(cflags & REG_NOSUB))
+    {
+      /* Construct submatch offsets from the tags. */
+      submatch_data = tnfa->submatch_data;
+      while (i < tnfa->num_submatches && i < nmatch)
+	{
+	  if (submatch_data[i].so_tag == tnfa->end_tag)
+	    pmatch[i].rm_so = match_eo;
+	  else
+	    pmatch[i].rm_so = tags[submatch_data[i].so_tag];
 
-      if (submatch_data[i].eo_tag == tnfa->end_tag)
-        pmatch[i].rm_eo = match_eo;
-      else
-        pmatch[i].rm_eo = tags[submatch_data[i].eo_tag];
+	  if (submatch_data[i].eo_tag == tnfa->end_tag)
+	    pmatch[i].rm_eo = match_eo;
+	  else
+	    pmatch[i].rm_eo = tags[submatch_data[i].eo_tag];
 
-      /* If either of the endpoints were not used, this submatch
-         was not part of the match. */
-      if (pmatch[i].rm_so == -1 || pmatch[i].rm_eo == -1)
-        pmatch[i].rm_so = pmatch[i].rm_eo = -1;
+	  /* If either of the endpoints were not used, this submatch
+	     was not part of the match. */
+	  if (pmatch[i].rm_so == -1 || pmatch[i].rm_eo == -1)
+	    pmatch[i].rm_so = pmatch[i].rm_eo = -1;
 
+	  i++;
+	}
+      /* Reset all submatches that are not within all of their parent
+	 submatches. */
+      i = 0;
+      while (i < tnfa->num_submatches && i < nmatch)
+	{
+	  if (pmatch[i].rm_eo == -1)
+	    assert(pmatch[i].rm_so == -1);
+	  assert(pmatch[i].rm_so <= pmatch[i].rm_eo);
+
+	  parents = submatch_data[i].parents;
+	  if (parents != NULL)
+	    for (j = 0; parents[j] >= 0; j++)
+	      {
+		if (pmatch[i].rm_so < pmatch[parents[j]].rm_so
+		    || pmatch[i].rm_eo > pmatch[parents[j]].rm_eo)
+		  pmatch[i].rm_so = pmatch[i].rm_eo = -1;
+	      }
+	  i++;
+	}
+    }
+
+  while (i < nmatch)
+    {
+      pmatch[i].rm_so = -1;
+      pmatch[i].rm_eo = -1;
       i++;
     }
-    /* Reset all submatches that are not within all of their parent
-       submatches. */
-    i = 0;
-    while (i < tnfa->num_submatches && i < nmatch) {
-      if (pmatch[i].rm_eo == -1) unassert(pmatch[i].rm_so == -1);
-      unassert(pmatch[i].rm_so <= pmatch[i].rm_eo);
-
-      parents = submatch_data[i].parents;
-      if (parents != NULL)
-        for (j = 0; parents[j] >= 0; j++) {
-          if (pmatch[i].rm_so < pmatch[parents[j]].rm_so ||
-              pmatch[i].rm_eo > pmatch[parents[j]].rm_eo)
-            pmatch[i].rm_so = pmatch[i].rm_eo = -1;
-        }
-      i++;
-    }
-  }
-
-  while (i < nmatch) {
-    pmatch[i].rm_so = -1;
-    pmatch[i].rm_eo = -1;
-    i++;
-  }
 }
 
+
+/*
+  Wrapper functions for POSIX compatible regexp matching.
+*/
+
 /**
  * Executes regular expression.
  *
@@ -880,26 +1022,37 @@ static void tre_fill_pmatch(size_t nmatch, regmatch_t pmatch[], int cflags,
  * @param eflags can have REG_NOTBOL, REG_NOTEOL
  * @return 0 or REG_NOMATCH
  */
-int regexec(const regex_t *preg, const char *string, size_t nmatch,
-            regmatch_t *pmatch, int eflags) {
+int
+regexec(const regex_t *restrict preg, const char *restrict string,
+	  size_t nmatch, regmatch_t pmatch[restrict], int eflags)
+{
   tre_tnfa_t *tnfa = (void *)preg->TRE_REGEX_T_FIELD;
   reg_errcode_t status;
   regoff_t *tags = NULL, eo;
   if (tnfa->cflags & REG_NOSUB) nmatch = 0;
-  if (tnfa->num_tags > 0 && nmatch > 0) {
-    tags = malloc(sizeof(*tags) * tnfa->num_tags);
-    if (tags == NULL) return REG_ESPACE;
-  }
+  if (tnfa->num_tags > 0 && nmatch > 0)
+    {
+      tags = xmalloc(sizeof(*tags) * tnfa->num_tags);
+      if (tags == NULL)
+	return REG_ESPACE;
+    }
+
   /* Dispatch to the appropriate matcher. */
-  if (tnfa->have_backrefs) {
-    /* The regex has back references, use the backtracking matcher. */
-    status = tre_tnfa_run_backtrack(tnfa, string, tags, eflags, &eo);
-  } else {
-    /* Exact matching, no back references, use the parallel matcher. */
-    status = tre_tnfa_run_parallel(tnfa, string, tags, eflags, &eo);
-  }
-  if (status == REG_OK) /* A match was found, so fill the submatch registers. */
+  if (tnfa->have_backrefs)
+    {
+      /* The regex has back references, use the backtracking matcher. */
+      status = tre_tnfa_run_backtrack(tnfa, string, tags, eflags, &eo);
+    }
+  else
+    {
+      /* Exact matching, no back references, use the parallel matcher. */
+      status = tre_tnfa_run_parallel(tnfa, string, tags, eflags, &eo);
+    }
+
+  if (status == REG_OK)
+    /* A match was found, so fill the submatch registers. */
     tre_fill_pmatch(nmatch, pmatch, tnfa->cflags, tnfa, tags, eo);
-  if (tags) free(tags), tags = NULL;
+  if (tags)
+    xfree(tags);
   return status;
 }
diff --git a/third_party/regex/tre-mem.c b/third_party/regex/tre-mem.c
index 971900a08..ce70ec6f1 100644
--- a/third_party/regex/tre-mem.c
+++ b/third_party/regex/tre-mem.c
@@ -56,7 +56,6 @@
 │  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
 │                                                                              │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "third_party/regex/tre.inc"
 
 /*
   This memory allocator is for allocating small memory blocks efficiently
@@ -65,6 +64,11 @@
   allocators, though.
 */
 
+#include <stdlib.h>
+#include <string.h>
+
+#include "tre.inc"
+
 /*
   This memory allocator is for allocating small memory blocks efficiently
   in terms of memory overhead and execution speed.  The allocated blocks
@@ -73,79 +77,110 @@
 */
 
 /* Returns a new memory allocator or NULL if out of memory. */
-tre_mem_t tre_mem_new_impl(int provided, void *provided_block) {
+tre_mem_t
+tre_mem_new_impl(int provided, void *provided_block)
+{
   tre_mem_t mem;
-  if (provided) {
-    mem = provided_block;
-    bzero(mem, sizeof(*mem));
-  } else
-    mem = calloc(1, sizeof(*mem));
-  if (mem == NULL) return NULL;
+  if (provided)
+    {
+      mem = provided_block;
+      memset(mem, 0, sizeof(*mem));
+    }
+  else
+    mem = xcalloc(1, sizeof(*mem));
+  if (mem == NULL)
+    return NULL;
   return mem;
 }
 
+
 /* Frees the memory allocator and all memory allocated with it. */
-void tre_mem_destroy(tre_mem_t mem) {
+void
+tre_mem_destroy(tre_mem_t mem)
+{
   tre_list_t *tmp, *l = mem->blocks;
-  while (l != NULL) {
-    free(l->data), l->data = NULL;
-    tmp = l->next;
-    free(l), l = tmp;
-  }
-  free(mem), mem = NULL;
+
+  while (l != NULL)
+    {
+      xfree(l->data);
+      tmp = l->next;
+      xfree(l);
+      l = tmp;
+    }
+  xfree(mem);
 }
 
+
 /* Allocates a block of `size' bytes from `mem'.  Returns a pointer to the
    allocated block or NULL if an underlying malloc() failed. */
-void *tre_mem_alloc_impl(tre_mem_t mem, int provided, void *provided_block,
-                         int zero, size_t size) {
+void *
+tre_mem_alloc_impl(tre_mem_t mem, int provided, void *provided_block,
+		   int zero, size_t size)
+{
   void *ptr;
-  if (mem->failed) {
-    return NULL;
-  }
-  if (mem->n < size) {
-    /* We need more memory than is available in the current block.
-       Allocate a new block. */
-    tre_list_t *l;
-    if (provided) {
-      if (provided_block == NULL) {
-        mem->failed = 1;
-        return NULL;
-      }
-      mem->ptr = provided_block;
-      mem->n = TRE_MEM_BLOCK_SIZE;
-    } else {
-      int block_size;
-      if (size * 8 > TRE_MEM_BLOCK_SIZE)
-        block_size = size * 8;
-      else
-        block_size = TRE_MEM_BLOCK_SIZE;
-      l = malloc(sizeof(*l));
-      if (l == NULL) {
-        mem->failed = 1;
-        return NULL;
-      }
-      l->data = malloc(block_size);
-      if (l->data == NULL) {
-        free(l), l = NULL;
-        mem->failed = 1;
-        return NULL;
-      }
-      l->next = NULL;
-      if (mem->current != NULL) mem->current->next = l;
-      if (mem->blocks == NULL) mem->blocks = l;
-      mem->current = l;
-      mem->ptr = l->data;
-      mem->n = block_size;
+
+  if (mem->failed)
+    {
+      return NULL;
     }
-  }
+
+  if (mem->n < size)
+    {
+      /* We need more memory than is available in the current block.
+	 Allocate a new block. */
+      tre_list_t *l;
+      if (provided)
+	{
+	  if (provided_block == NULL)
+	    {
+	      mem->failed = 1;
+	      return NULL;
+	    }
+	  mem->ptr = provided_block;
+	  mem->n = TRE_MEM_BLOCK_SIZE;
+	}
+      else
+	{
+	  int block_size;
+	  if (size * 8 > TRE_MEM_BLOCK_SIZE)
+	    block_size = size * 8;
+	  else
+	    block_size = TRE_MEM_BLOCK_SIZE;
+	  l = xmalloc(sizeof(*l));
+	  if (l == NULL)
+	    {
+	      mem->failed = 1;
+	      return NULL;
+	    }
+	  l->data = xmalloc(block_size);
+	  if (l->data == NULL)
+	    {
+	      xfree(l);
+	      mem->failed = 1;
+	      return NULL;
+	    }
+	  l->next = NULL;
+	  if (mem->current != NULL)
+	    mem->current->next = l;
+	  if (mem->blocks == NULL)
+	    mem->blocks = l;
+	  mem->current = l;
+	  mem->ptr = l->data;
+	  mem->n = block_size;
+	}
+    }
+
   /* Make sure the next pointer will be aligned. */
   size += ALIGN(mem->ptr + size, long);
+
   /* Allocate from current block. */
   ptr = mem->ptr;
   mem->ptr += size;
   mem->n -= size;
+
   /* Set to zero if needed. */
-  if (zero) bzero(ptr, size);
+  if (zero)
+    memset(ptr, 0, size);
+
   return ptr;
 }
diff --git a/third_party/regex/tre.inc b/third_party/regex/tre.inc
index 2f6e39854..b33e19973 100644
--- a/third_party/regex/tre.inc
+++ b/third_party/regex/tre.inc
@@ -1,78 +1,52 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╚──────────────────────────────────────────────────────────────────────────────╝
-│                                                                              │
-│  Musl Libc                                                                   │
-│  Copyright © 2005-2014 Rich Felker, et al.                                   │
-│                                                                              │
-│  Permission is hereby granted, free of charge, to any person obtaining       │
-│  a copy of this software and associated documentation files (the             │
-│  "Software"), to deal in the Software without restriction, including         │
-│  without limitation the rights to use, copy, modify, merge, publish,         │
-│  distribute, sublicense, and/or sell copies of the Software, and to          │
-│  permit persons to whom the Software is furnished to do so, subject to       │
-│  the following conditions:                                                   │
-│                                                                              │
-│  The above copyright notice and this permission notice shall be              │
-│  included in all copies or substantial portions of the Software.             │
-│                                                                              │
-│  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,             │
-│  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF          │
-│  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.      │
-│  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY        │
-│  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,        │
-│  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE           │
-│  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                      │
-│                                                                              │
-│──────────────────────────────────────────────────────────────────────────────│
-│                                                                              │
-│  tre-internal.h - TRE internal definitions                                   │
-│                                                                              │
-│  Copyright (c) 2001-2009 Ville Laurikari <vl@iki.fi>                         │
-│  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.                                                          │
-│                                                                              │
-│  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER 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 COPYRIGHT       │
-│  HOLDER 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.        │
-│                                                                              │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/assert.h"
-#include "libc/mem/alg.h"
-#include "libc/mem/mem.h"
-#include "libc/str/str.h"
-#include "third_party/regex/regex.h"
+/*
+  tre-internal.h - TRE internal definitions
 
-#undef TRE_MBSTATE
+  Copyright (c) 2001-2009 Ville Laurikari <vl@iki.fi>
+  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.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER 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 COPYRIGHT
+  HOLDER 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.
+
+*/
+
+#include <regex.h>
+#include <wchar.h>
+#include <wctype.h>
+
+#undef  TRE_MBSTATE
+
+#ifndef NDEBUG
+#define NDEBUG
+#endif
 
 #define TRE_REGEX_T_FIELD __opaque
 typedef int reg_errcode_t;
+
 typedef wchar_t tre_char_t;
 
-#define DPRINT(msg) \
-  do {              \
-  } while (0)
+#define DPRINT(msg) do { } while(0)
 
-#define elementsof(x) (sizeof(x) / sizeof(x[0]))
+#define elementsof(x)	( sizeof(x) / sizeof(x[0]) )
 
 #define tre_mbrtowc(pwc, s, n, ps) (mbtowc((pwc), (s), (n)))
 
@@ -80,17 +54,17 @@ typedef wchar_t tre_char_t;
 typedef wint_t tre_cint_t;
 #define TRE_CHAR_MAX 0x10ffff
 
-#define tre_isalnum  iswalnum
-#define tre_isalpha  iswalpha
-#define tre_isblank  iswblank
-#define tre_iscntrl  iswcntrl
-#define tre_isdigit  iswdigit
-#define tre_isgraph  iswgraph
-#define tre_islower  iswlower
-#define tre_isprint  iswprint
-#define tre_ispunct  iswpunct
-#define tre_isspace  iswspace
-#define tre_isupper  iswupper
+#define tre_isalnum iswalnum
+#define tre_isalpha iswalpha
+#define tre_isblank iswblank
+#define tre_iscntrl iswcntrl
+#define tre_isdigit iswdigit
+#define tre_isgraph iswgraph
+#define tre_islower iswlower
+#define tre_isprint iswprint
+#define tre_ispunct iswpunct
+#define tre_isspace iswspace
+#define tre_isupper iswupper
 #define tre_isxdigit iswxdigit
 
 #define tre_tolower towlower
@@ -104,10 +78,10 @@ typedef wctype_t tre_ctype_t;
 
 /* Returns number of bytes to add to (char *)ptr to make it
    properly aligned for the type. */
-#define ALIGN(ptr, type)                               \
-  ((((long)ptr) % sizeof(type))                        \
-       ? (sizeof(type) - (((long)ptr) % sizeof(type))) \
-       : 0)
+#define ALIGN(ptr, type) \
+  ((((long)ptr) % sizeof(type)) \
+   ? (sizeof(type) - (((long)ptr) % sizeof(type))) \
+   : 0)
 
 #undef MAX
 #undef MIN
@@ -141,20 +115,24 @@ struct tnfa_transition {
   tre_ctype_t *neg_classes;
 };
 
+
 /* Assertions. */
-#define ASSERT_AT_BOL         1   /* Beginning of line. */
-#define ASSERT_AT_EOL         2   /* End of line. */
-#define ASSERT_CHAR_CLASS     4   /* Character class in `class'. */
-#define ASSERT_CHAR_CLASS_NEG 8   /* Character classes in `neg_classes'. */
-#define ASSERT_AT_BOW         16  /* Beginning of word. */
-#define ASSERT_AT_EOW         32  /* End of word. */
-#define ASSERT_AT_WB          64  /* Word boundary. */
-#define ASSERT_AT_WB_NEG      128 /* Not a word boundary. */
-#define ASSERT_BACKREF        256 /* A back reference in `backref'. */
-#define ASSERT_LAST           256
+#define ASSERT_AT_BOL		  1   /* Beginning of line. */
+#define ASSERT_AT_EOL		  2   /* End of line. */
+#define ASSERT_CHAR_CLASS	  4   /* Character class in `class'. */
+#define ASSERT_CHAR_CLASS_NEG	  8   /* Character classes in `neg_classes'. */
+#define ASSERT_AT_BOW		 16   /* Beginning of word. */
+#define ASSERT_AT_EOW		 32   /* End of word. */
+#define ASSERT_AT_WB		 64   /* Word boundary. */
+#define ASSERT_AT_WB_NEG	128   /* Not a word boundary. */
+#define ASSERT_BACKREF		256   /* A back reference in `backref'. */
+#define ASSERT_LAST		256
 
 /* Tag directions. */
-typedef enum { TRE_TAG_MINIMIZE = 0, TRE_TAG_MAXIMIZE = 1 } tre_tag_direction_t;
+typedef enum {
+  TRE_TAG_MINIMIZE = 0,
+  TRE_TAG_MAXIMIZE = 1
+} tre_tag_direction_t;
 
 /* Instructions to compute submatch register values from tag values
    after a successful match.  */
@@ -169,6 +147,7 @@ struct tre_submatch_data {
 
 typedef struct tre_submatch_data tre_submatch_data_t;
 
+
 /* TNFA definition. */
 typedef struct tnfa tre_tnfa_t;
 
@@ -208,7 +187,7 @@ typedef struct tre_mem_struct {
   size_t n;
   int failed;
   void **provided;
-} * tre_mem_t;
+} *tre_mem_t;
 
 #define tre_mem_new_impl   __tre_mem_new_impl
 #define tre_mem_alloc_impl __tre_mem_alloc_impl
@@ -216,10 +195,10 @@ typedef struct tre_mem_struct {
 
 tre_mem_t tre_mem_new_impl(int provided, void *provided_block);
 void *tre_mem_alloc_impl(tre_mem_t mem, int provided, void *provided_block,
-                         int zero, size_t size);
+                                int zero, size_t size);
 
 /* Returns a new memory allocator or NULL if out of memory. */
-#define tre_mem_new() tre_mem_new_impl(0, NULL)
+#define tre_mem_new()  tre_mem_new_impl(0, NULL)
 
 /* Allocates a block of `size' bytes from `mem'.  Returns a pointer to the
    allocated block or NULL if an underlying malloc() failed. */
@@ -237,11 +216,18 @@ void *tre_mem_alloc_impl(tre_mem_t mem, int provided, void *provided_block,
 #define tre_mem_newa() \
   tre_mem_new_impl(1, alloca(sizeof(struct tre_mem_struct)))
 
-#define tre_mem_alloca(mem, size)                      \
-  ((mem)->n >= (size)                                  \
-       ? tre_mem_alloc_impl((mem), 1, NULL, 0, (size)) \
-       : tre_mem_alloc_impl((mem), 1, alloca(TRE_MEM_BLOCK_SIZE), 0, (size)))
+#define tre_mem_alloca(mem, size)					      \
+  ((mem)->n >= (size)							      \
+   ? tre_mem_alloc_impl((mem), 1, NULL, 0, (size))			      \
+   : tre_mem_alloc_impl((mem), 1, alloca(TRE_MEM_BLOCK_SIZE), 0, (size)))
 #endif /* TRE_USE_ALLOCA */
 
+
 /* Frees the memory allocator and all memory allocated with it. */
 void tre_mem_destroy(tre_mem_t mem);
+
+#define xmalloc malloc
+#define xcalloc calloc
+#define xfree free
+#define xrealloc realloc
+
diff --git a/third_party/sed/BUILD.mk b/third_party/sed/BUILD.mk
index 37cf771b4..cb708a5b8 100644
--- a/third_party/sed/BUILD.mk
+++ b/third_party/sed/BUILD.mk
@@ -23,6 +23,7 @@ THIRD_PARTY_SED_A_DIRECTDEPS =				\
 	LIBC_STR					\
 	LIBC_LOG					\
 	THIRD_PARTY_GETOPT				\
+	THIRD_PARTY_MUSL				\
 	THIRD_PARTY_REGEX
 
 THIRD_PARTY_SED_A_DEPS :=				\
diff --git a/third_party/sed/compile.c b/third_party/sed/compile.c
index 66758b242..1f86d24f1 100644
--- a/third_party/sed/compile.c
+++ b/third_party/sed/compile.c
@@ -47,6 +47,7 @@
 #include "libc/sysv/consts/s.h"
 #include "libc/sysv/consts/utime.h"
 #include "libc/mem/gc.h"
+#include "libc/ctype.h"
 #include "libc/time.h"
 
 #include "libc/str/str.h"
diff --git a/third_party/sed/defs.h b/third_party/sed/defs.h
index 54ac79922..84cba2337 100644
--- a/third_party/sed/defs.h
+++ b/third_party/sed/defs.h
@@ -3,6 +3,7 @@
 #include "libc/calls/typedef/u.h"
 #include "libc/limits.h"
 #include "third_party/regex/regex.h"
+#include "third_party/sed/shade.h"
 COSMOPOLITAN_C_START_
 
 /*
diff --git a/third_party/sed/extern.h b/third_party/sed/extern.h
index 0c190c9bc..fbeb0497a 100644
--- a/third_party/sed/extern.h
+++ b/third_party/sed/extern.h
@@ -4,6 +4,7 @@
 #include "libc/stdio/stdio.h"
 #include "third_party/regex/regex.h"
 #include "third_party/sed/defs.h"
+#include "third_party/sed/shade.h"
 COSMOPOLITAN_C_START_
 
 extern struct s_command *prog;
diff --git a/third_party/sed/process.c b/third_party/sed/process.c
index 1a50f1061..fbef8809a 100644
--- a/third_party/sed/process.c
+++ b/third_party/sed/process.c
@@ -47,6 +47,8 @@
 #include "libc/sysv/consts/s.h"
 #include "libc/sysv/consts/termios.h"
 #include "third_party/sed/defs.h"
+#include "libc/wctype.h"
+#include "libc/ctype.h"
 #include "third_party/sed/extern.h"
 
 static SPACE HS, PS, SS, YS;
diff --git a/third_party/sed/shade.h b/third_party/sed/shade.h
new file mode 100644
index 000000000..ceea8d4b5
--- /dev/null
+++ b/third_party/sed/shade.h
@@ -0,0 +1,31 @@
+#ifndef COSMOPOLITAN_THIRD_PARTY_SED_SHADE_H_
+#define COSMOPOLITAN_THIRD_PARTY_SED_SHADE_H_
+
+#define prog _sed_prog
+#define appends_ _sed_appends_
+#define g_match _sed_g_match
+#define maxnsub _sed_maxnsub
+#define linenum _sed_linenum
+#define appendnum _sed_appendnum
+#define aflag _sed_aflag
+#define eflag _sed_eflag
+#define nflag _sed_nflag
+#define fname _sed_fname
+#define outfname _sed_outfname
+#define infile _sed_infile
+#define outfile _sed_outfile
+#define rflags _sed_rflags
+#define cfclose _sed_cfclose
+#define compile _sed_compile
+#define cspace _sed_cspace
+#define cu_fgets _sed_cu_fgets
+#define mf_fgets _sed_mf_fgets
+#define lastline _sed_lastline
+#define process _sed_process
+#define resetstate _sed_resetstate
+#define strregerror _sed_strregerror
+#define xmalloc _sed_xmalloc
+#define xrealloc _sed_xrealloc
+#define xcalloc _sed_xcalloc
+
+#endif /* COSMOPOLITAN_THIRD_PARTY_SED_SHADE_H_ */
diff --git a/third_party/smallz4/BUILD.mk b/third_party/smallz4/BUILD.mk
index ecc92c5a3..c4e38d8e7 100644
--- a/third_party/smallz4/BUILD.mk
+++ b/third_party/smallz4/BUILD.mk
@@ -36,7 +36,9 @@ THIRD_PARTY_SMALLZ4_A_DIRECTDEPS =				\
 	LIBC_CALLS						\
 	LIBC_STDIO						\
 	LIBC_STR						\
-	THIRD_PARTY_LIBCXX
+	THIRD_PARTY_LIBCXX					\
+	THIRD_PARTY_LIBCXXABI					\
+	THIRD_PARTY_LIBUNWIND					\
 
 THIRD_PARTY_SMALLZ4_A_DEPS :=					\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_SMALLZ4_A_DIRECTDEPS),$($(x))))
diff --git a/third_party/sqlite3/BUILD.mk b/third_party/sqlite3/BUILD.mk
index 3410c4975..3ea4086fa 100644
--- a/third_party/sqlite3/BUILD.mk
+++ b/third_party/sqlite3/BUILD.mk
@@ -52,6 +52,7 @@ THIRD_PARTY_SQLITE3_A_DIRECTDEPS =					\
 	LIBC_RUNTIME							\
 	LIBC_STDIO							\
 	LIBC_STR							\
+	LIBC_SYSTEM							\
 	LIBC_SYSV							\
 	LIBC_SYSV_CALLS							\
 	LIBC_THREAD							\
@@ -62,7 +63,7 @@ THIRD_PARTY_SQLITE3_A_DIRECTDEPS =					\
 	THIRD_PARTY_MUSL						\
 	THIRD_PARTY_TZ							\
 	THIRD_PARTY_ZLIB						\
-	TOOL_ARGS
+	TOOL_ARGS							\
 
 THIRD_PARTY_SQLITE3_A_DEPS :=						\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_SQLITE3_A_DIRECTDEPS),$($(x))))
diff --git a/third_party/sqlite3/completion.c b/third_party/sqlite3/completion.c
index e7279f297..e47d66482 100644
--- a/third_party/sqlite3/completion.c
+++ b/third_party/sqlite3/completion.c
@@ -35,6 +35,7 @@
 */
 #include "libc/assert.h"
 #include "libc/str/str.h"
+#include "libc/ctype.h"
 #include "third_party/sqlite3/sqlite3ext.h"
 
 SQLITE_EXTENSION_INIT1
diff --git a/third_party/sqlite3/decimal.c b/third_party/sqlite3/decimal.c
index f6326842a..76d91ecf7 100644
--- a/third_party/sqlite3/decimal.c
+++ b/third_party/sqlite3/decimal.c
@@ -17,6 +17,7 @@
 #include "libc/assert.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
+#include "libc/ctype.h"
 #include "third_party/sqlite3/sqlite3ext.h"
 
 SQLITE_EXTENSION_INIT1
diff --git a/third_party/sqlite3/geopoly.inc b/third_party/sqlite3/geopoly.inc
index 8de1fdbee..5874571e1 100644
--- a/third_party/sqlite3/geopoly.inc
+++ b/third_party/sqlite3/geopoly.inc
@@ -16,6 +16,7 @@
 ** This file is #include-ed onto the end of "rtree.c" so that it has
 ** access to all of the R-Tree internals.
 */
+#include "libc/ctype.h"
 #include "libc/fmt/conv.h"
 
 /* Enable -DGEOPOLY_ENABLE_DEBUG for debugging facilities */
diff --git a/third_party/sqlite3/shell.c b/third_party/sqlite3/shell.c
index 1144c6e73..5c29318c1 100644
--- a/third_party/sqlite3/shell.c
+++ b/third_party/sqlite3/shell.c
@@ -30,6 +30,7 @@
 ** This file contains code to implement the "sqlite" command line
 ** utility for accessing SQLite databases.
 */
+#include "libc/ctype.h"
 #include "libc/dce.h"
 #if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
 /* This needs to come before any includes for MSVC compiler */
@@ -131,7 +132,7 @@ typedef unsigned short int u16;
 #include "libc/sysv/consts/s.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
-#include "tool/args/args.h"
+#include "libc/cosmo.h"
 #include "third_party/sqlite3/extensions.h"
 #include "third_party/sqlite3/sqlite3expert.h"
 #include "third_party/zlib/zlib.h"
diff --git a/third_party/sqlite3/uint.c b/third_party/sqlite3/uint.c
index 5bbc9ed08..835f78bed 100644
--- a/third_party/sqlite3/uint.c
+++ b/third_party/sqlite3/uint.c
@@ -29,6 +29,7 @@
 */
 #include "libc/assert.h"
 #include "libc/str/str.h"
+#include "libc/ctype.h"
 #include "third_party/sqlite3/sqlite3ext.h"
 
 SQLITE_EXTENSION_INIT1
diff --git a/third_party/stb/stb_image.c b/third_party/stb/stb_image.c
index f796a034b..74eca2447 100644
--- a/third_party/stb/stb_image.c
+++ b/third_party/stb/stb_image.c
@@ -25,7 +25,7 @@
 #include "libc/limits.h"
 #include "libc/log/gdb.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/x86feature.h"
@@ -4211,9 +4211,12 @@ static int stbi__parse_png_file(stbi__png *z, int scan, int req_comp) {
               tc16[k] = (uint16_t)stbi__get16be(s);  // copy the values as-is
           } else {
             for (k = 0; k < s->img_n; ++k)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-overflow"
               tc[k] = (unsigned char)(stbi__get16be(s) & 255) *
                       stbi__depth_scale_table[z->depth];  // non 8-bit images
                                                           // will be larger
+#pragma GCC diagnostic pop
           }
         }
         break;
diff --git a/third_party/stb/stb_image_resize.c b/third_party/stb/stb_image_resize.c
index 7fc71a33e..43fcb1710 100644
--- a/third_party/stb/stb_image_resize.c
+++ b/third_party/stb/stb_image_resize.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "third_party/stb/stb_image_resize.h"
 #include "libc/assert.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
diff --git a/third_party/stb/stb_image_write.c b/third_party/stb/stb_image_write.c
index 9af55ae36..573cb893b 100644
--- a/third_party/stb/stb_image_write.c
+++ b/third_party/stb/stb_image_write.c
@@ -21,7 +21,7 @@
 #include "libc/assert.h"
 #include "libc/fmt/conv.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/nexgen32e.h"
diff --git a/third_party/stb/stb_truetype.c b/third_party/stb/stb_truetype.c
index e1449c11b..ef59f4b6a 100644
--- a/third_party/stb/stb_truetype.c
+++ b/third_party/stb/stb_truetype.c
@@ -29,7 +29,7 @@
 #include "libc/assert.h"
 #include "libc/serialize.h"
 #include "libc/intrin/likely.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/third_party/tidy/attrs.c b/third_party/tidy/attrs.c
index 3b96f361f..b85208a7c 100644
--- a/third_party/tidy/attrs.c
+++ b/third_party/tidy/attrs.c
@@ -10,6 +10,7 @@
 #include "third_party/tidy/message.h"
 #include "third_party/tidy/tmbstr.h"
 #include "libc/assert.h"
+#include "libc/ctype.h"
 #include "third_party/tidy/utf8.h"
 
 #if __GNUC__ >= 11 /* [jart] this one looks legit */
diff --git a/third_party/tidy/language.c b/third_party/tidy/language.c
index ea80ad7a2..b540225c5 100644
--- a/third_party/tidy/language.c
+++ b/third_party/tidy/language.c
@@ -7,6 +7,7 @@
 
 #include "third_party/tidy/language.h"
 #include "third_party/tidy/tmbstr.h"
+#include "libc/ctype.h"
 #include "libc/assert.h"
 
 #include "third_party/tidy/language_en.inc"
diff --git a/third_party/tidy/pprint.c b/third_party/tidy/pprint.c
index d7a98f4cd..d77ae7844 100644
--- a/third_party/tidy/pprint.c
+++ b/third_party/tidy/pprint.c
@@ -14,6 +14,7 @@
 #include "third_party/tidy/tmbstr.h"
 #include "third_party/tidy/utf8.h"
 #include "libc/assert.h"
+#include "libc/ctype.h"
 #include "third_party/tidy/sprtf.h"
 
 
diff --git a/third_party/tidy/tidy.c b/third_party/tidy/tidy.c
index 4798eafda..02b2ef079 100644
--- a/third_party/tidy/tidy.c
+++ b/third_party/tidy/tidy.c
@@ -1202,7 +1202,10 @@ static tmbstr cleanup_description( ctmbstr description )
                             name = realloc(name, l_name);
                         }
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-truncation"
                         strncpy(name + i_name, &c, 1);
+#pragma GCC diagnostic pop
                         i_name++;
                         i++;
                         break;
diff --git a/third_party/tr/BUILD.mk b/third_party/tr/BUILD.mk
index 54a17731b..313bfe150 100644
--- a/third_party/tr/BUILD.mk
+++ b/third_party/tr/BUILD.mk
@@ -22,7 +22,8 @@ THIRD_PARTY_TR_DIRECTDEPS =			\
 	LIBC_RUNTIME				\
 	LIBC_STDIO				\
 	LIBC_STR				\
-	THIRD_PARTY_GETOPT
+	THIRD_PARTY_GETOPT			\
+	THIRD_PARTY_MUSL			\
 
 THIRD_PARTY_TR_DEPS :=				\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_TR_DIRECTDEPS),$($(x))))
diff --git a/third_party/tr/extern.h b/third_party/tr/extern.h
index 31b1ed884..14995931e 100644
--- a/third_party/tr/extern.h
+++ b/third_party/tr/extern.h
@@ -3,6 +3,8 @@
 #include "libc/limits.h"
 COSMOPOLITAN_C_START_
 
+#define next _tr_next
+
 typedef struct {
   enum { STRING1, STRING2 } which;
   enum { EOS, INFINITE, NORMAL, RANGE, SEQUENCE, SET } state;
diff --git a/third_party/tr/next.c b/third_party/tr/next.c
index 802197dd7..e71c31c97 100644
--- a/third_party/tr/next.c
+++ b/third_party/tr/next.c
@@ -35,6 +35,7 @@
 #include "libc/mem/alg.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
+#include "libc/ctype.h"
 #include "third_party/tr/extern.h"
 
 static int	backslash(STR *);
diff --git a/third_party/tr/tr.c b/third_party/tr/tr.c
index fd1fe6e11..d9c7f572a 100644
--- a/third_party/tr/tr.c
+++ b/third_party/tr/tr.c
@@ -42,8 +42,8 @@
 #include "third_party/tr/cmd.h"
 #include "third_party/tr/extern.h"
 
-int delete[NCHARS], squeeze[NCHARS];
-int translate[NCHARS] = {
+static int delete[NCHARS], squeeze[NCHARS];
+static int translate[NCHARS] = {
 	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,		/* ASCII */
 	0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
 	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
@@ -78,8 +78,8 @@ int translate[NCHARS] = {
 	0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
 };
 
-STR s1 = { STRING1, NORMAL, 0, OOBCH, { 0, OOBCH }, NULL, NULL };
-STR s2 = { STRING2, NORMAL, 0, OOBCH, { 0, OOBCH }, NULL, NULL };
+static STR s1 = { STRING1, NORMAL, 0, OOBCH, { 0, OOBCH }, NULL, NULL };
+static STR s2 = { STRING2, NORMAL, 0, OOBCH, { 0, OOBCH }, NULL, NULL };
 
 static void setup(int *, char *, STR *, int);
 static void usage(void);
@@ -90,9 +90,6 @@ _tr(int argc, char *argv[])
 	int ch, cnt, lastch, *p;
 	int cflag, dflag, sflag;
 
-	if (pledge("stdio", NULL) == -1)
-		err(1, "pledge");
-
 	cflag = dflag = sflag = 0;
 	while ((ch = getopt(argc, argv, "Ccds")) != -1)
 		switch(ch) {
diff --git a/third_party/tree/file.c b/third_party/tree/file.c
index bf0b19a47..3a637b3ba 100644
--- a/third_party/tree/file.c
+++ b/third_party/tree/file.c
@@ -25,7 +25,7 @@ extern bool noindent, force_color, matchdirs, fflinks;
 extern bool reverse;
 extern int pattern, ipattern;
 
-extern int (*topsort)();
+extern int (*topsort)(const void *, const void *);
 extern FILE *outfile;
 extern int Level, *dirs, maxdirs;
 
diff --git a/third_party/tree/html.c b/third_party/tree/html.c
index 41b731d19..c6f3a941e 100644
--- a/third_party/tree/html.c
+++ b/third_party/tree/html.c
@@ -15,6 +15,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
+#include "libc/ctype.h"
 #include "third_party/tree/tree.h"
 
 extern char *version, *hversion;
diff --git a/third_party/tree/json.c b/third_party/tree/json.c
index e9ef424e9..414b25975 100644
--- a/third_party/tree/json.c
+++ b/third_party/tree/json.c
@@ -16,6 +16,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include "libc/sysv/consts/s.h"
+#include "libc/ctype.h"
 #include "third_party/tree/tree.h"
 
 extern bool dflag, lflag, pflag, sflag, Fflag, aflag, fflag, uflag, gflag;
diff --git a/third_party/tree/list.c b/third_party/tree/list.c
index 865bbad86..8b42a594c 100644
--- a/third_party/tree/list.c
+++ b/third_party/tree/list.c
@@ -24,7 +24,7 @@ extern bool Dflag, Hflag, inodeflag, devflag, Rflag, duflag, pruneflag, metafirs
 extern bool Jflag, hflag, siflag, noreport, noindent, force_color, xdev, nolinks;
 
 extern struct _info **(*getfulltree)(char *d, u_long lev, dev_t dev, off_t *size, char **err);
-extern int (*topsort)();
+extern int (*topsort)(const void *, const void *);
 extern FILE *outfile;
 extern int flimit, Level, *dirs, maxdirs, errors;
 extern int htmldirlen;
diff --git a/third_party/tree/tree.c b/third_party/tree/tree.c
index d68e8ad96..9deb31bfb 100644
--- a/third_party/tree/tree.c
+++ b/third_party/tree/tree.c
@@ -29,6 +29,8 @@
 #include "libc/calls/struct/stat.macros.h"
 #include "libc/calls/struct/dirent.h"
 #include "libc/mem/alg.h"
+#include "libc/ctype.h"
+#include "libc/wctype.h"
 #include "third_party/tree/tree.h"
 
 char *version = "$Version: $ tree v2.1.1 %s 1996 - 2023 by Steve Baker, Thomas Moore, Francesc Rocher, Florian Sesser, Kyosuke Tokoro $";
@@ -59,8 +61,9 @@ const char *charset = NULL;
 
 struct _info **(*getfulltree)(char *d, u_long lev, dev_t dev, off_t *size, char **err) = unix_getfulltree;
 /* off_t (*listdir)(char *, int *, int *, u_long, dev_t) = unix_listdir; */
-int (*basesort)() = alnumsort;
-int (*topsort)() = NULL;
+int alnumsort(const void *, const void *);
+int (*basesort)(const void *, const void *) = alnumsort;
+int (*topsort)(const void *, const void *) = NULL;
 
 char *sLevel, *curdir;
 FILE *outfile = NULL;
@@ -87,7 +90,7 @@ const u_short ifmt[]={ FILE_ARCHIVED, FILE_DIRECTORY, FILE_SYSTEM, FILE_HIDDEN,
 
 struct sorts {
   char *name;
-  int (*cmpfunc)();
+  int (*cmpfunc)(const void *, const void *);
 } sorts[] = {
   {"name", alnumsort},
   {"version", versort},
@@ -1015,16 +1018,20 @@ struct _info **unix_getfulltree(char *d, u_long lev, dev_t dev, off_t *size, cha
 /**
  * filesfirst and dirsfirst are now top-level meta-sorts.
  */
-int filesfirst(struct _info **a, struct _info **b)
+int filesfirst(const void *a_, const void *b_)
 {
+  struct _info **a = (struct _info **)a_;
+  struct _info **b = (struct _info **)b_;
   if ((*a)->isdir != (*b)->isdir) {
     return (*a)->isdir ? 1 : -1;
   }
   return basesort(a, b);
 }
 
-int dirsfirst(struct _info **a, struct _info **b)
+int dirsfirst(const void *a_, const void *b_)
 {
+  struct _info **a = (struct _info **)a_;
+  struct _info **b = (struct _info **)b_;
   if ((*a)->isdir != (*b)->isdir) {
     return (*a)->isdir ? -1 : 1;
   }
@@ -1032,20 +1039,26 @@ int dirsfirst(struct _info **a, struct _info **b)
 }
 
 /* Sorting functions */
-int alnumsort(struct _info **a, struct _info **b)
+int alnumsort(const void *a_, const void *b_)
 {
+  struct _info **a = (struct _info **)a_;
+  struct _info **b = (struct _info **)b_;
   int v = strcoll((*a)->name,(*b)->name);
   return reverse? -v : v;
 }
 
-int versort(struct _info **a, struct _info **b)
+int versort(const void *a_, const void *b_)
 {
+  struct _info **a = (struct _info **)a_;
+  struct _info **b = (struct _info **)b_;
   int v = strverscmp((*a)->name,(*b)->name);
   return reverse? -v : v;
 }
 
-int mtimesort(struct _info **a, struct _info **b)
+int mtimesort(const void *a_, const void *b_)
 {
+  struct _info **a = (struct _info **)a_;
+  struct _info **b = (struct _info **)b_;
   int v;
 
   if ((*a)->mtime == (*b)->mtime) {
@@ -1056,8 +1069,10 @@ int mtimesort(struct _info **a, struct _info **b)
   return reverse? -v : v;
 }
 
-int ctimesort(struct _info **a, struct _info **b)
+int ctimesort(const void *a_, const void *b_)
 {
+  struct _info **a = (struct _info **)a_;
+  struct _info **b = (struct _info **)b_;
   int v;
 
   if ((*a)->ctime == (*b)->ctime) {
@@ -1073,8 +1088,10 @@ int sizecmp(off_t a, off_t b)
   return (a == b)? 0 : ((a < b)? 1 : -1);
 }
 
-int fsizesort(struct _info **a, struct _info **b)
+int fsizesort(const void *a_, const void *b_)
 {
+  struct _info **a = (struct _info **)a_;
+  struct _info **b = (struct _info **)b_;
   int v = sizecmp((*a)->size, (*b)->size);
   if (v == 0) v = strcoll((*a)->name,(*b)->name);
   return reverse? -v : v;
diff --git a/third_party/tree/tree.h b/third_party/tree/tree.h
index a57ae288c..473d487ee 100644
--- a/third_party/tree/tree.h
+++ b/third_party/tree/tree.h
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/stat.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 #ifdef __ANDROID
 #define mbstowcs(w,m,x) mbsrtowcs(w,(const char**)(& #m),x,NULL)
@@ -153,15 +153,15 @@ int patinclude(char *name, int isdir);
 struct _info **unix_getfulltree(char *d, u_long lev, dev_t dev, off_t *size, char **err);
 struct _info **read_dir(char *dir, int *n, int infotop);
 
-int filesfirst(struct _info **, struct _info **);
-int dirsfirst(struct _info **, struct _info **);
-int alnumsort(struct _info **, struct _info **);
-int versort(struct _info **a, struct _info **b);
-int reversealnumsort(struct _info **, struct _info **);
-int mtimesort(struct _info **, struct _info **);
-int ctimesort(struct _info **, struct _info **);
+int filesfirst(const void *, const void *);
+int dirsfirst(const void *, const void *);
+int alnumsort(const void *, const void *);
+int versort(const void *, const void *);
+int reversealnumsort(const void *, const void *);
+int mtimesort(const void *, const void *);
+int ctimesort(const void *, const void *);
 int sizecmp(off_t a, off_t b);
-int fsizesort(struct _info **a, struct _info **b);
+int fsizesort(const void *, const void *);
 
 void *xmalloc(size_t), *xrealloc(void *, size_t);
 char *gnu_getcwd();
diff --git a/third_party/tz/asctime.c b/third_party/tz/asctime.c
deleted file mode 100644
index eb257aa31..000000000
--- a/third_party/tz/asctime.c
+++ /dev/null
@@ -1,135 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/str.h"
-#include "libc/stdio/stdio.h"
-#include "private.h"
-
-/* asctime and asctime_r a la POSIX and ISO C, except pad years before 1000.  */
-
-/*
-** This file is in the public domain, so clarified as of
-** 1996-06-05 by Arthur David Olson.
-*/
-
-/*
-** Avoid the temptation to punt entirely to strftime;
-** the output of strftime is supposed to be locale specific
-** whereas the output of asctime is supposed to be constant.
-*/
-
-/*LINTLIBRARY*/
-
-/*
-** All years associated with 32-bit time_t values are exactly four digits long;
-** some years associated with 64-bit time_t values are not.
-** Vintage programs are coded for years that are always four digits long
-** and may assume that the newline always lands in the same place.
-** For years that are less than four digits, we pad the output with
-** leading zeroes to get the newline in the traditional place.
-** The -4 ensures that we get four characters of output even if
-** we call a strftime variant that produces fewer characters for some years.
-** The ISO C and POSIX standards prohibit padding the year,
-** but many implementations pad anyway; most likely the standards are buggy.
-*/
-static char const ASCTIME_FMT[] = "%s %s%3d %.2d:%.2d:%.2d %-4s\n";
-/*
-** For years that are more than four digits we put extra spaces before the year
-** so that code trying to overwrite the newline won't end up overwriting
-** a digit within a year and truncating the year (operating on the assumption
-** that no output is better than wrong output).
-*/
-static char const ASCTIME_FMT_B[] = "%s %s%3d %.2d:%.2d:%.2d     %s\n";
-
-enum { STD_ASCTIME_BUF_SIZE = 26 };
-/*
-** Big enough for something such as
-** ??? ???-2147483648 -2147483648:-2147483648:-2147483648     -2147483648\n
-** (two three-character abbreviations, five strings denoting integers,
-** seven explicit spaces, two explicit colons, a newline,
-** and a trailing NUL byte).
-** The values above are for systems where an int is 32 bits and are provided
-** as an example; the size expression below is a bound for the system at
-** hand.
-*/
-static char buf_asctime[2*3 + 5*INT_STRLEN_MAXIMUM(int) + 7 + 2 + 1 + 1];
-
-/* A similar buffer for ctime.
-   C89 requires that they be the same buffer.
-   This requirement was removed in C99, so support it only if requested,
-   as support is more likely to lead to bugs in badly written programs.  */
-#if SUPPORT_C89
-# define buf_ctime buf_asctime
-#else
-static char buf_ctime[sizeof buf_asctime];
-#endif
-
-char *
-asctime_r(struct tm const *restrict timeptr, char *restrict buf)
-{
-	static const char	wday_name[][4] = {
-		"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
-	};
-	static const char	mon_name[][4] = {
-		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-	};
-	register const char *	wn;
-	register const char *	mn;
-	char			year[INT_STRLEN_MAXIMUM(int) + 2];
-	char result[sizeof buf_asctime];
-
-	if (timeptr == NULL) {
-		errno = EINVAL;
-		return strcpy(buf, "??? ??? ?? ??:??:?? ????\n");
-	}
-	if (timeptr->tm_wday < 0 || timeptr->tm_wday >= DAYSPERWEEK)
-		wn = "???";
-	else	wn = wday_name[timeptr->tm_wday];
-	if (timeptr->tm_mon < 0 || timeptr->tm_mon >= MONSPERYEAR)
-		mn = "???";
-	else	mn = mon_name[timeptr->tm_mon];
-	/*
-	** Use strftime's %Y to generate the year, to avoid overflow problems
-	** when computing timeptr->tm_year + TM_YEAR_BASE.
-	** Assume that strftime is unaffected by other out-of-range members
-	** (e.g., timeptr->tm_mday) when processing "%Y".
-	*/
-	strftime(year, sizeof year, "%Y", timeptr);
-	/*
-	** We avoid using snprintf since it's not available on all systems.
-	*/
-	sprintf(result,
-		((strlen(year) <= 4) ? ASCTIME_FMT : ASCTIME_FMT_B),
-		wn, mn,
-		timeptr->tm_mday, timeptr->tm_hour,
-		timeptr->tm_min, timeptr->tm_sec,
-		year);
-	if (strlen(result) < STD_ASCTIME_BUF_SIZE
-	    || buf == buf_ctime || buf == buf_asctime)
-		return strcpy(buf, result);
-	else {
-		errno = EOVERFLOW;
-		return NULL;
-	}
-}
-
-char *
-asctime(register const struct tm *timeptr)
-{
-	return asctime_r(timeptr, buf_asctime);
-}
-
-char *
-ctime_r(const time_t *timep, char *buf)
-{
-	struct tm mytm;
-	struct tm *tmp = localtime_r(timep, &mytm);
-	return tmp ? asctime_r(tmp, buf) : NULL;
-}
-
-char *
-ctime(const time_t *timep)
-{
-	return ctime_r(timep, buf_ctime);
-}
diff --git a/third_party/tz/difftime.c b/third_party/tz/difftime.c
index 929dd5b14..33622f2ff 100644
--- a/third_party/tz/difftime.c
+++ b/third_party/tz/difftime.c
@@ -2,7 +2,7 @@
 │ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/weirdtypes.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/time.h"
 
 /* Return the difference between two timestamps.  */
diff --git a/third_party/tz/localtime.c b/third_party/tz/localtime.c
index 06139e49f..34f7cf648 100644
--- a/third_party/tz/localtime.c
+++ b/third_party/tz/localtime.c
@@ -2,6 +2,10 @@
 │ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #define LOCALTIME_IMPLEMENTATION
+#include "lock.h"
+#include "tzdir.h"
+#include "tzfile.h"
+#include "private.h"
 #include "libc/calls/blockcancel.internal.h"
 #include "libc/calls/calls.h"
 #include "libc/cxxabi.h"
@@ -10,20 +14,15 @@
 #include "libc/serialize.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/o.h"
-#include "libc/thread/thread.h"
-#include "libc/thread/tls.h"
 #include "libc/time.h"
 #include "libc/inttypes.h"
 #include "libc/sysv/consts/ok.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdckdint.h"
 #include "libc/time.h"
-#include "tzdir.h"
-#include "tzfile.h"
 #include "libc/nt/struct/timezoneinformation.h"
 #include "libc/nt/time.h"
 #include "libc/dce.h"
-#include "private.h"
 
 /* Convert timestamp from time_t to struct tm.  */
 
@@ -624,34 +623,10 @@ localtime_windows_init(void)
 	setenv("TZ", buf, true);
 }
 
-static pthread_mutex_t locallock = PTHREAD_MUTEX_INITIALIZER;
-
-static dontinline void
-localtime_wipe(void)
-{
-	pthread_mutex_init(&locallock, 0);
-}
-
-static dontinline void
-localtime_lock(void)
-{
-	pthread_mutex_lock(&locallock);
-}
-
-static dontinline void
-localtime_unlock(void)
-{
-	pthread_mutex_unlock(&locallock);
-}
-
 __attribute__((__constructor__(80)))
 textstartup static void
 localtime_init(void)
 {
-	localtime_wipe();
-	pthread_atfork(localtime_lock,
-		       localtime_unlock,
-		       localtime_wipe);
 	if (IsWindows())
 		localtime_windows_init();
 }
@@ -2052,9 +2027,9 @@ localtime_tzset_unlocked(void)
 void
 tzset(void)
 {
-	localtime_lock();
+	__localtime_lock();
 	localtime_tzset_unlocked();
-	localtime_unlock();
+	__localtime_unlock();
 }
 
 static void
@@ -2067,7 +2042,7 @@ static void
 localtime_gmtcheck(void)
 {
 	static bool gmt_is_set;
-	localtime_lock();
+	__localtime_lock();
 	if (! gmt_is_set) {
 #ifdef ALL_STATE
 		gmtptr = malloc(sizeof *gmtptr);
@@ -2077,7 +2052,7 @@ localtime_gmtcheck(void)
 			localtime_gmtload(gmtptr);
 		gmt_is_set = true;
 	}
-	localtime_unlock();
+	__localtime_unlock();
 }
 
 /*
@@ -2193,11 +2168,11 @@ localsub(struct state const *sp, time_t const *timep, int_fast32_t setname,
 static struct tm *
 localtime_tzset(time_t const *timep, struct tm *tmp, bool setname)
 {
-	localtime_lock();
+	__localtime_lock();
 	if (setname || !lcl_is_set)
 		localtime_tzset_unlocked();
 	tmp = localsub(lclptr, timep, setname, tmp);
-	localtime_unlock();
+	__localtime_unlock();
 	return tmp;
 }
 
@@ -2834,10 +2809,10 @@ time_t
 mktime(struct tm *tmp)
 {
 	time_t t;
-	localtime_lock();
+	__localtime_lock();
 	localtime_tzset_unlocked();
 	t = mktime_tzname(lclptr, tmp, true);
-	localtime_unlock();
+	__localtime_unlock();
 	return t;
 }
 
diff --git a/third_party/tz/lock.h b/third_party/tz/lock.h
new file mode 100644
index 000000000..501505478
--- /dev/null
+++ b/third_party/tz/lock.h
@@ -0,0 +1,11 @@
+#ifndef COSMOPOLITAN_THIRD_PARTY_TZ_LOCK_H_
+#define COSMOPOLITAN_THIRD_PARTY_TZ_LOCK_H_
+#include "libc/thread/thread.h"
+COSMOPOLITAN_C_START_
+
+void __localtime_lock(void);
+void __localtime_unlock(void);
+void __localtime_wipe(void);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_THIRD_PARTY_TZ_LOCK_H_ */
diff --git a/third_party/tz/strftime.c b/third_party/tz/strftime.c
deleted file mode 100644
index 372b98071..000000000
--- a/third_party/tz/strftime.c
+++ /dev/null
@@ -1,646 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8   -*-│
-│ vi: set noet ft=c ts=8 sw=8 fenc=utf-8                                   :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright (c) 1989 The Regents of the University of California.              │
-│ All rights reserved.                                                         │
-│                                                                              │
-│ Redistribution and use in source and binary forms are permitted              │
-│ provided that the above copyright notice and this paragraph are              │
-│ duplicated in all such forms and that any documentation,                     │
-│ advertising materials, and other materials related to such                   │
-│ distribution and use acknowledge that the software was developed             │
-│ by the University of California, Berkeley.  The name of the                  │
-│ University 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 WITHOUT ANY EXPRESS OR               │
-│ IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED               │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.          │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/str/locale.h"
-#include "libc/time.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
-#include "libc/inttypes.h"
-#include "private.h"
-
-__notice(strftime_notice, "strftime (BSD-3)\n\
-Copyright 1989 The Regents of the University of California");
-
-#ifndef DEPRECATE_TWO_DIGIT_YEARS
-# define DEPRECATE_TWO_DIGIT_YEARS false
-#endif
-
-struct lc_time_T {
-	const char *	mon[MONSPERYEAR];
-	const char *	month[MONSPERYEAR];
-	const char *	wday[DAYSPERWEEK];
-	const char *	weekday[DAYSPERWEEK];
-	const char *	X_fmt;
-	const char *	x_fmt;
-	const char *	c_fmt;
-	const char *	am;
-	const char *	pm;
-	const char *	date_fmt;
-};
-
-static const struct lc_time_T	C_time_locale = {
-	{
-		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-	}, {
-		"January", "February", "March", "April", "May", "June",
-		"July", "August", "September", "October", "November", "December"
-	}, {
-		"Sun", "Mon", "Tue", "Wed",
-		"Thu", "Fri", "Sat"
-	}, {
-		"Sunday", "Monday", "Tuesday", "Wednesday",
-		"Thursday", "Friday", "Saturday"
-	},
-
-	/* X_fmt */
-	"%H:%M:%S",
-
-	/*
-	** x_fmt
-	** C99 and later require this format.
-	** Using just numbers (as here) makes Quakers happier;
-	** it's also compatible with SVR4.
-	*/
-	"%m/%d/%y",
-
-	/*
-	** c_fmt
-	** C99 and later require this format.
-	** Previously this code used "%D %X", but we now conform to C99.
-	** Note that
-	**	"%a %b %d %H:%M:%S %Y"
-	** is used by Solaris 2.3.
-	*/
-	"%a %b %e %T %Y",
-
-	/* am */
-	"AM",
-
-	/* pm */
-	"PM",
-
-	/* date_fmt */
-	"%a %b %e %H:%M:%S %Z %Y"
-};
-
-enum warn { IN_NONE, IN_SOME, IN_THIS, IN_ALL };
-
-#ifndef YEAR_2000_NAME
-# define YEAR_2000_NAME "CHECK_STRFTIME_FORMATS_FOR_TWO_DIGIT_YEARS"
-#endif /* !defined YEAR_2000_NAME */
-
-static char *
-_add(const char *str, char *pt, const char *ptlim)
-{
-	while (pt < ptlim && (*pt = *str++) != '\0')
-		++pt;
-	return pt;
-}
-
-static char *
-_conv(int n, const char *format, char *pt, const char *ptlim)
-{
-	char	buf[INT_STRLEN_MAXIMUM(int) + 1];
-
-	sprintf(buf, format, n);
-	return _add(buf, pt, ptlim);
-}
-
-/*
-** POSIX and the C Standard are unclear or inconsistent about
-** what %C and %y do if the year is negative or exceeds 9999.
-** Use the convention that %C concatenated with %y yields the
-** same output as %Y, and that %Y contains at least 4 bytes,
-** with more only if necessary.
-*/
-
-static char *
-_yconv(int a, int b, bool convert_top, bool convert_yy,
-       char *pt, const char *ptlim)
-{
-	register int	lead;
-	register int	trail;
-
-	int DIVISOR = 100;
-	trail = a % DIVISOR + b % DIVISOR;
-	lead = a / DIVISOR + b / DIVISOR + trail / DIVISOR;
-	trail %= DIVISOR;
-	if (trail < 0 && lead > 0) {
-		trail += DIVISOR;
-		--lead;
-	} else if (lead < 0 && trail > 0) {
-		trail -= DIVISOR;
-		++lead;
-	}
-	if (convert_top) {
-		if (lead == 0 && trail < 0)
-			pt = _add("-0", pt, ptlim);
-		else	pt = _conv(lead, "%02d", pt, ptlim);
-	}
-	if (convert_yy)
-		pt = _conv(((trail < 0) ? -trail : trail), "%02d", pt, ptlim);
-	return pt;
-}
-
-static char *
-_fmt(const char *format, const struct tm *t, char *pt,
-     const char *ptlim, enum warn *warnp)
-{
-	struct lc_time_T const *Locale = &C_time_locale;
-
-	for ( ; *format; ++format) {
-		if (*format == '%') {
-label:
-			switch (*++format) {
-			case '\0':
-				--format;
-				break;
-			case 'A':
-				pt = _add((t->tm_wday < 0 ||
-					t->tm_wday >= DAYSPERWEEK) ?
-					"?" : Locale->weekday[t->tm_wday],
-					pt, ptlim);
-				continue;
-			case 'a':
-				pt = _add((t->tm_wday < 0 ||
-					t->tm_wday >= DAYSPERWEEK) ?
-					"?" : Locale->wday[t->tm_wday],
-					pt, ptlim);
-				continue;
-			case 'B':
-				pt = _add((t->tm_mon < 0 ||
-					t->tm_mon >= MONSPERYEAR) ?
-					"?" : Locale->month[t->tm_mon],
-					pt, ptlim);
-				continue;
-			case 'b':
-			case 'h':
-				pt = _add((t->tm_mon < 0 ||
-					t->tm_mon >= MONSPERYEAR) ?
-					"?" : Locale->mon[t->tm_mon],
-					pt, ptlim);
-				continue;
-			case 'C':
-				/*
-				** %C used to do a...
-				**	_fmt("%a %b %e %X %Y", t);
-				** ...whereas now POSIX 1003.2 calls for
-				** something completely different.
-				** (ado, 1993-05-24)
-				*/
-				pt = _yconv(t->tm_year, TM_YEAR_BASE,
-					    true, false, pt, ptlim);
-				continue;
-			case 'c':
-				{
-				enum warn warn2 = IN_SOME;
-
-				pt = _fmt(Locale->c_fmt, t, pt, ptlim, &warn2);
-				if (warn2 == IN_ALL)
-					warn2 = IN_THIS;
-				if (warn2 > *warnp)
-					*warnp = warn2;
-				}
-				continue;
-			case 'D':
-				pt = _fmt("%m/%d/%y", t, pt, ptlim, warnp);
-				continue;
-			case 'd':
-				pt = _conv(t->tm_mday, "%02d", pt, ptlim);
-				continue;
-			case 'E':
-			case 'O':
-				/*
-				** Locale modifiers of C99 and later.
-				** The sequences
-				**	%Ec %EC %Ex %EX %Ey %EY
-				**	%Od %oe %OH %OI %Om %OM
-				**	%OS %Ou %OU %OV %Ow %OW %Oy
-				** are supposed to provide alternative
-				** representations.
-				*/
-				goto label;
-			case 'e':
-				pt = _conv(t->tm_mday, "%2d", pt, ptlim);
-				continue;
-			case 'F':
-				pt = _fmt("%Y-%m-%d", t, pt, ptlim, warnp);
-				continue;
-			case 'H':
-				pt = _conv(t->tm_hour, "%02d", pt, ptlim);
-				continue;
-			case 'I':
-				pt = _conv((t->tm_hour % 12) ?
-					(t->tm_hour % 12) : 12,
-					"%02d", pt, ptlim);
-				continue;
-			case 'j':
-				pt = _conv(t->tm_yday + 1, "%03d", pt, ptlim);
-				continue;
-			case 'k':
-				/*
-				** This used to be...
-				**	_conv(t->tm_hour % 12 ?
-				**		t->tm_hour % 12 : 12, 2, ' ');
-				** ...and has been changed to the below to
-				** match SunOS 4.1.1 and Arnold Robbins'
-				** strftime version 3.0. That is, "%k" and
-				** "%l" have been swapped.
-				** (ado, 1993-05-24)
-				*/
-				pt = _conv(t->tm_hour, "%2d", pt, ptlim);
-				continue;
-#ifdef KITCHEN_SINK
-			case 'K':
-				/*
-				** After all this time, still unclaimed!
-				*/
-				pt = _add("kitchen sink", pt, ptlim);
-				continue;
-#endif /* defined KITCHEN_SINK */
-			case 'l':
-				/*
-				** This used to be...
-				**	_conv(t->tm_hour, 2, ' ');
-				** ...and has been changed to the below to
-				** match SunOS 4.1.1 and Arnold Robbin's
-				** strftime version 3.0. That is, "%k" and
-				** "%l" have been swapped.
-				** (ado, 1993-05-24)
-				*/
-				pt = _conv((t->tm_hour % 12) ?
-					(t->tm_hour % 12) : 12,
-					"%2d", pt, ptlim);
-				continue;
-			case 'M':
-				pt = _conv(t->tm_min, "%02d", pt, ptlim);
-				continue;
-			case 'm':
-				pt = _conv(t->tm_mon + 1, "%02d", pt, ptlim);
-				continue;
-			case 'n':
-				pt = _add("\n", pt, ptlim);
-				continue;
-			case 'p':
-				pt = _add((t->tm_hour >= (HOURSPERDAY / 2)) ?
-					Locale->pm :
-					Locale->am,
-					pt, ptlim);
-				continue;
-			case 'R':
-				pt = _fmt("%H:%M", t, pt, ptlim, warnp);
-				continue;
-			case 'r':
-				pt = _fmt("%I:%M:%S %p", t, pt, ptlim, warnp);
-				continue;
-			case 'S':
-				pt = _conv(t->tm_sec, "%02d", pt, ptlim);
-				continue;
-			case 's':
-				{
-					struct tm	tm;
-					char		buf[INT_STRLEN_MAXIMUM(
-								time_t) + 1];
-					time_t		mkt;
-
-					tm.tm_sec = t->tm_sec;
-					tm.tm_min = t->tm_min;
-					tm.tm_hour = t->tm_hour;
-					tm.tm_mday = t->tm_mday;
-					tm.tm_mon = t->tm_mon;
-					tm.tm_year = t->tm_year;
-#ifdef TM_GMTOFF
-					mkt = timeoff(&tm, t->TM_GMTOFF);
-#else
-					tm.tm_isdst = t->tm_isdst;
-					mkt = mktime(&tm);
-#endif
-					/* If mktime fails, %s expands to the
-					   value of (time_t) -1 as a failure
-					   marker; this is better in practice
-					   than strftime failing.  */
-					if (TYPE_SIGNED(time_t)) {
-					  intmax_t n = mkt;
-					  sprintf(buf, "%"PRIdMAX, n);
-					} else {
-					  uintmax_t n = mkt;
-					  sprintf(buf, "%"PRIuMAX, n);
-					}
-					pt = _add(buf, pt, ptlim);
-				}
-				continue;
-			case 'T':
-				pt = _fmt("%H:%M:%S", t, pt, ptlim, warnp);
-				continue;
-			case 't':
-				pt = _add("\t", pt, ptlim);
-				continue;
-			case 'U':
-				pt = _conv((t->tm_yday + DAYSPERWEEK -
-					t->tm_wday) / DAYSPERWEEK,
-					"%02d", pt, ptlim);
-				continue;
-			case 'u':
-				/*
-				** From Arnold Robbins' strftime version 3.0:
-				** "ISO 8601: Weekday as a decimal number
-				** [1 (Monday) - 7]"
-				** (ado, 1993-05-24)
-				*/
-				pt = _conv((t->tm_wday == 0) ?
-					DAYSPERWEEK : t->tm_wday,
-					"%d", pt, ptlim);
-				continue;
-			case 'V':	/* ISO 8601 week number */
-			case 'G':	/* ISO 8601 year (four digits) */
-			case 'g':	/* ISO 8601 year (two digits) */
-/*
-** From Arnold Robbins' strftime version 3.0: "the week number of the
-** year (the first Monday as the first day of week 1) as a decimal number
-** (01-53)."
-** (ado, 1993-05-24)
-**
-** From <https://www.cl.cam.ac.uk/~mgk25/iso-time.html> by Markus Kuhn:
-** "Week 01 of a year is per definition the first week which has the
-** Thursday in this year, which is equivalent to the week which contains
-** the fourth day of January. In other words, the first week of a new year
-** is the week which has the majority of its days in the new year. Week 01
-** might also contain days from the previous year and the week before week
-** 01 of a year is the last week (52 or 53) of the previous year even if
-** it contains days from the new year. A week starts with Monday (day 1)
-** and ends with Sunday (day 7). For example, the first week of the year
-** 1997 lasts from 1996-12-30 to 1997-01-05..."
-** (ado, 1996-01-02)
-*/
-				{
-					int	year;
-					int	base;
-					int	yday;
-					int	wday;
-					int	w;
-
-					year = t->tm_year;
-					base = TM_YEAR_BASE;
-					yday = t->tm_yday;
-					wday = t->tm_wday;
-					for ( ; ; ) {
-						int	len;
-						int	bot;
-						int	top;
-
-						len = isleap_sum(year, base) ?
-							DAYSPERLYEAR :
-							DAYSPERNYEAR;
-						/*
-						** What yday (-3 ... 3) does
-						** the ISO year begin on?
-						*/
-						bot = ((yday + 11 - wday) %
-							DAYSPERWEEK) - 3;
-						/*
-						** What yday does the NEXT
-						** ISO year begin on?
-						*/
-						top = bot -
-							(len % DAYSPERWEEK);
-						if (top < -3)
-							top += DAYSPERWEEK;
-						top += len;
-						if (yday >= top) {
-							++base;
-							w = 1;
-							break;
-						}
-						if (yday >= bot) {
-							w = 1 + ((yday - bot) /
-								DAYSPERWEEK);
-							break;
-						}
-						--base;
-						yday += isleap_sum(year, base) ?
-							DAYSPERLYEAR :
-							DAYSPERNYEAR;
-					}
-#ifdef XPG4_1994_04_09
-					if ((w == 52 &&
-						t->tm_mon == TM_JANUARY) ||
-						(w == 1 &&
-						t->tm_mon == TM_DECEMBER))
-							w = 53;
-#endif /* defined XPG4_1994_04_09 */
-					if (*format == 'V')
-						pt = _conv(w, "%02d",
-							pt, ptlim);
-					else if (*format == 'g') {
-						*warnp = IN_ALL;
-						pt = _yconv(year, base,
-							false, true,
-							pt, ptlim);
-					} else	pt = _yconv(year, base,
-							true, true,
-							pt, ptlim);
-				}
-				continue;
-			case 'v':
-				/*
-				** From Arnold Robbins' strftime version 3.0:
-				** "date as dd-bbb-YYYY"
-				** (ado, 1993-05-24)
-				*/
-				pt = _fmt("%e-%b-%Y", t, pt, ptlim, warnp);
-				continue;
-			case 'W':
-				pt = _conv((t->tm_yday + DAYSPERWEEK -
-					(t->tm_wday ?
-					(t->tm_wday - 1) :
-					(DAYSPERWEEK - 1))) / DAYSPERWEEK,
-					"%02d", pt, ptlim);
-				continue;
-			case 'w':
-				pt = _conv(t->tm_wday, "%d", pt, ptlim);
-				continue;
-			case 'X':
-				pt = _fmt(Locale->X_fmt, t, pt, ptlim, warnp);
-				continue;
-			case 'x':
-				{
-				enum warn warn2 = IN_SOME;
-
-				pt = _fmt(Locale->x_fmt, t, pt, ptlim, &warn2);
-				if (warn2 == IN_ALL)
-					warn2 = IN_THIS;
-				if (warn2 > *warnp)
-					*warnp = warn2;
-				}
-				continue;
-			case 'y':
-				*warnp = IN_ALL;
-				pt = _yconv(t->tm_year, TM_YEAR_BASE,
-					false, true,
-					pt, ptlim);
-				continue;
-			case 'Y':
-				pt = _yconv(t->tm_year, TM_YEAR_BASE,
-					true, true,
-					pt, ptlim);
-				continue;
-			case 'Z':
-#ifdef TM_ZONE
-				pt = _add(t->TM_ZONE, pt, ptlim);
-#elif HAVE_TZNAME
-				if (t->tm_isdst >= 0)
-					pt = _add(tzname[t->tm_isdst != 0],
-						pt, ptlim);
-#endif
-				/*
-				** C99 and later say that %Z must be
-				** replaced by the empty string if the
-				** time zone abbreviation is not
-				** determinable.
-				*/
-				continue;
-			case 'z':
-#if defined TM_GMTOFF || USG_COMPAT || ALTZONE
-				{
-				long		diff;
-				char const *	sign;
-				bool negative;
-
-# ifdef TM_GMTOFF
-				diff = t->TM_GMTOFF;
-# else
-				/*
-				** C99 and later say that the UT offset must
-				** be computed by looking only at
-				** tm_isdst. This requirement is
-				** incorrect, since it means the code
-				** must rely on magic (in this case
-				** altzone and timezone), and the
-				** magic might not have the correct
-				** offset. Doing things correctly is
-				** tricky and requires disobeying the standard;
-				** see GNU C strftime for details.
-				** For now, punt and conform to the
-				** standard, even though it's incorrect.
-				**
-				** C99 and later say that %z must be replaced by
-				** the empty string if the time zone is not
-				** determinable, so output nothing if the
-				** appropriate variables are not available.
-				*/
-				if (t->tm_isdst < 0)
-					continue;
-				if (t->tm_isdst == 0)
-#  if USG_COMPAT
-					diff = -timezone;
-#  else
-					continue;
-#  endif
-				else
-#  if ALTZONE
-					diff = -altzone;
-#  else
-					continue;
-#  endif
-# endif
-				negative = diff < 0;
-				if (diff == 0) {
-# ifdef TM_ZONE
-				  negative = t->TM_ZONE[0] == '-';
-# else
-				  negative = t->tm_isdst < 0;
-#  if HAVE_TZNAME
-				  if (tzname[t->tm_isdst != 0][0] == '-')
-				    negative = true;
-#  endif
-# endif
-				}
-				if (negative) {
-					sign = "-";
-					diff = -diff;
-				} else	sign = "+";
-				pt = _add(sign, pt, ptlim);
-				diff /= SECSPERMIN;
-				diff = (diff / MINSPERHOUR) * 100 +
-					(diff % MINSPERHOUR);
-				pt = _conv(diff, "%04d", pt, ptlim);
-				}
-#endif
-				continue;
-			case '+':
-				pt = _fmt(Locale->date_fmt, t, pt, ptlim,
-					warnp);
-				continue;
-			case '%':
-			/*
-			** X311J/88-090 (4.12.3.5): if conversion char is
-			** undefined, behavior is undefined. Print out the
-			** character itself as printf(3) also does.
-			*/
-			default:
-				break;
-			}
-		}
-		if (pt == ptlim)
-			break;
-		*pt++ = *format;
-	}
-	return pt;
-}
-
-/**
- * Converts time to string, e.g.
- *
- *     char b[64];
- *     int64_t sec;
- *     struct tm tm;
- *     time(&sec);
- *     localtime_r(&sec, &tm);
- *     strftime(b, sizeof(b), "%Y-%m-%dT%H:%M:%S%z", &tm);       // ISO8601
- *     strftime(b, sizeof(b), "%a, %d %b %Y %H:%M:%S %Z", &tm);  // RFC1123
- *
- * @return bytes copied excluding nul, or 0 on error
- * @see FormatHttpDateTime()
- */
-size_t
-strftime(char *restrict s, size_t maxsize, char const *restrict format,
-	 struct tm const *restrict t)
-{
-	char *	p;
-	int saved_errno = errno;
-	enum warn warn = IN_NONE;
-
-	tzset();
-	p = _fmt(format, t, s, s + maxsize, &warn);
-	if (!p) {
-	  errno = EOVERFLOW;
-	  return 0;
-	}
-	if (DEPRECATE_TWO_DIGIT_YEARS
-	    && warn != IN_NONE && getenv(YEAR_2000_NAME)) {
-		fprintf(stderr, "\n");
-		fprintf(stderr, "strftime format \"%s\" ", format);
-		fprintf(stderr, "yields only two digits of years in ");
-		if (warn == IN_SOME)
-			fprintf(stderr, "some locales");
-		else if (warn == IN_THIS)
-			fprintf(stderr, "the current locale");
-		else	fprintf(stderr, "all locales");
-		fprintf(stderr, "\n");
-	}
-	if (p == s + maxsize) {
-		errno = ERANGE;
-		return 0;
-	}
-	*p = '\0';
-	errno = saved_errno;
-	return p - s;
-}
-
-__weak_reference(strftime, strftime_l);
diff --git a/third_party/unzip/BUILD.mk b/third_party/unzip/BUILD.mk
index b1db75282..a55ca2ff6 100644
--- a/third_party/unzip/BUILD.mk
+++ b/third_party/unzip/BUILD.mk
@@ -24,7 +24,8 @@ THIRD_PARTY_UNZIP_A_DIRECTDEPS =						\
 	LIBC_STR								\
 	LIBC_SYSV								\
 	THIRD_PARTY_BZIP2							\
-	THIRD_PARTY_TZ
+	THIRD_PARTY_MUSL							\
+	THIRD_PARTY_TZ								\
 
 THIRD_PARTY_UNZIP_A_DEPS :=							\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_UNZIP_A_DIRECTDEPS),$($(x))))
diff --git a/third_party/unzip/envargs.c b/third_party/unzip/envargs.c
index 7d8e21eab..0b7a17b08 100644
--- a/third_party/unzip/envargs.c
+++ b/third_party/unzip/envargs.c
@@ -18,8 +18,6 @@
  |     to make the action of the code less obscure.
  |----------------------------------------------------------------
  | UnZip notes: 24 May 92 ("v1.4"):
-#include "libc/runtime/runtime.h"
-#include "libc/runtime/runtime.h"
  |  1. #include "third_party/unzip/unzip.h" for prototypes (24 May 92)
  |  2. changed ch to type char (24 May 92)
  |  3. added an ifdef to avoid Borland warnings (24 May 92)
@@ -33,6 +31,8 @@
 #define __ENVARGS_C     /* identifies this source module */
 #define UNZIP_INTERNAL
 #include "third_party/unzip/unzip.h"
+#include "libc/runtime/runtime.h"
+#include "libc/ctype.h"
 
 #ifdef __EMX__          /* emx isspace() returns TRUE on extended ASCII !! */
 #  define ISspace(c) ((c) & 0x80 ? 0 : isspace((unsigned)c))
diff --git a/third_party/unzip/unzpriv.h b/third_party/unzip/unzpriv.h
index 4be099f8b..51580e3d3 100644
--- a/third_party/unzip/unzpriv.h
+++ b/third_party/unzip/unzpriv.h
@@ -32,6 +32,7 @@
 #include "third_party/zip/crypt.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
+#include "libc/ctype.h"
 #include "third_party/unzip/unxcfg.h"
 
 /* First thing: Signal all following code that we compile UnZip utilities! */
diff --git a/third_party/xed/x86ild.greg.c b/third_party/xed/x86ild.greg.c
index fe70349e2..cf7749fda 100644
--- a/third_party/xed/x86ild.greg.c
+++ b/third_party/xed/x86ild.greg.c
@@ -21,7 +21,7 @@
 #include "libc/serialize.h"
 #include "libc/intrin/bsr.h"
 #include "libc/log/libfatal.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
 #include "third_party/xed/avx512.h"
diff --git a/third_party/xxhash/xxhash.h b/third_party/xxhash/xxhash.h
index b69ea3bad..a5e4fd471 100644
--- a/third_party/xxhash/xxhash.h
+++ b/third_party/xxhash/xxhash.h
@@ -1203,7 +1203,7 @@ struct XXH64_state_s {
 #ifndef XXH_NO_XXH3
 
 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) /* >= C11 */
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #  define XXH_ALIGN(n)      alignas(n)
 #elif defined(__cplusplus) && (__cplusplus >= 201103L) /* >= C++11 */
 /* In C++ alignas() is a keyword */
diff --git a/third_party/zip/BUILD.mk b/third_party/zip/BUILD.mk
index d0a163fc3..1a4ab4c20 100644
--- a/third_party/zip/BUILD.mk
+++ b/third_party/zip/BUILD.mk
@@ -85,15 +85,17 @@ THIRD_PARTY_ZIP_DIRECTDEPS =			\
 	LIBC_LOG				\
 	LIBC_MEM				\
 	LIBC_NEXGEN32E				\
+	LIBC_PROC				\
 	LIBC_RUNTIME				\
 	LIBC_STDIO				\
-	LIBC_PROC				\
 	LIBC_STR				\
+	LIBC_SYSTEM				\
 	LIBC_SYSV				\
 	LIBC_X					\
 	THIRD_PARTY_BZIP2			\
+	THIRD_PARTY_MUSL			\
 	THIRD_PARTY_TZ				\
-	THIRD_PARTY_ZLIB
+	THIRD_PARTY_ZLIB			\
 
 THIRD_PARTY_ZIP_DEPS :=				\
 	$(call uniq,$(foreach x,$(THIRD_PARTY_ZIP_DIRECTDEPS),$($(x))))
diff --git a/third_party/zip/README.cosmo b/third_party/zip/README.cosmo
index 69fbf8c30..309554994 100644
--- a/third_party/zip/README.cosmo
+++ b/third_party/zip/README.cosmo
@@ -11,4 +11,5 @@ ORIGIN
 LOCAL CHANGES
 
   - Use Cosmopolitan's PCLMUL optimized CRC32
+  - Don't magically append .zip extension to filename argument
   - Improve find_next_signature() performance using unlocked stdio
diff --git a/third_party/zip/fileio.c b/third_party/zip/fileio.c
index cb988b030..53904c8ba 100644
--- a/third_party/zip/fileio.c
+++ b/third_party/zip/fileio.c
@@ -14,6 +14,8 @@
 #define __FILEIO_C
 
 #include "third_party/zip/zip.h"
+#include "libc/ctype.h"
+#include "libc/wctype.h"
 #include "third_party/zip/crc32.h"
 
 #ifdef MACOS
diff --git a/third_party/zip/util.c b/third_party/zip/util.c
index 9845d4d3b..524d44a08 100644
--- a/third_party/zip/util.c
+++ b/third_party/zip/util.c
@@ -15,6 +15,7 @@
 
 #include "third_party/zip/zip.h"
 // MISSING #include "ebcdic.h"
+#include "libc/ctype.h"
 #include "libc/str/str.h"
 
 #ifdef MSDOS16
diff --git a/third_party/zip/zip.c b/third_party/zip/zip.c
index 8b064dd9e..2faa0bf1d 100644
--- a/third_party/zip/zip.c
+++ b/third_party/zip/zip.c
@@ -55,6 +55,7 @@
 #include "libc/str/str.h"
 #include "libc/errno.h"
 #include "libc/sysv/consts/sig.h"
+#include "libc/ctype.h"
 #include "third_party/bzip2/bzlib.h"
 
 #ifdef VMS
diff --git a/third_party/zip/zipfile.c b/third_party/zip/zipfile.c
index 7b923b80e..787e73ea4 100644
--- a/third_party/zip/zipfile.c
+++ b/third_party/zip/zipfile.c
@@ -19,6 +19,7 @@
 #include "libc/assert.h"
 #include "third_party/zip/crc32.h"
 #endif
+#include "libc/ctype.h"
 #include "third_party/zip/crc32.h"
 
 /* for realloc 2/6/2005 EG */
@@ -412,6 +413,10 @@ char *ziptyp(s)
   if ((t = malloc(strlen(s) + 5)) == NULL)
     return NULL;
   strcpy(t, s);
+
+  // [jart] don't magically append .zip extension to filename argument
+  if (1) return t;
+
 #  ifdef __human68k__
   _toslash(t);
 #  endif
diff --git a/third_party/zip/zipup.c b/third_party/zip/zipup.c
index fe531952f..182a3ed5a 100644
--- a/third_party/zip/zipup.c
+++ b/third_party/zip/zipup.c
@@ -47,9 +47,6 @@
 // MISSING #include "os2/os2zip.h"
 #endif
 
-#undef PAGESIZE
-#define PAGESIZE __granularity()
-
 #if defined(MMAP)
 #include "libc/calls/calls.h"
 #include "libc/calls/weirdtypes.h"
diff --git a/third_party/zlib/crc_folding.c b/third_party/zlib/crc_folding.c
index 2702f909a..cc2fa875a 100644
--- a/third_party/zlib/crc_folding.c
+++ b/third_party/zlib/crc_folding.c
@@ -406,7 +406,7 @@ partial:
     }
 #endif
 
-    _mm_storeu_si128((__m128i *)dst, xmm_crc_part);
+    memcpy(dst, src, len);  /* TODO: Possibly generate more efficient code. */
     partial_fold(s, len, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3,
         &xmm_crc_part);
 done:
diff --git a/third_party/zlib/deflate.c b/third_party/zlib/deflate.c
index 58f9474e7..64ebcddc4 100644
--- a/third_party/zlib/deflate.c
+++ b/third_party/zlib/deflate.c
@@ -229,6 +229,8 @@ int ZEXPORT deflateInit(strm, level)
     /* To do: ignore strm->next_in if we use it as window */
 }
 
+#define WINDOW_PADDING 8
+
 /* ========================================================================= */
 int ZEXPORT deflateInit2(strm, level, method, windowBits, memLevel, strategy)
     z_streamp strm;
@@ -238,7 +240,6 @@ int ZEXPORT deflateInit2(strm, level, method, windowBits, memLevel, strategy)
     int  memLevel;
     int  strategy;
 {
-    unsigned window_padding = 8;
     deflate_state *s;
     int wrap = 1;
 
@@ -325,12 +326,12 @@ int ZEXPORT deflateInit2(strm, level, method, windowBits, memLevel, strategy)
     s->hash_shift =  ((s->hash_bits + MIN_MATCH-1) / MIN_MATCH);
 
     s->window = (Bytef *) ZALLOC(strm,
-                                 s->w_size + window_padding,
+                                 s->w_size + WINDOW_PADDING,
                                  2*sizeof(Byte));
     /* Avoid use of unitialized values in the window, see crbug.com/1137613 and
      * crbug.com/1144420 */
     if (s->window) { /* [jart] fix regression in malloc failure checking */
-        zmemzero(s->window, (s->w_size + window_padding) * (2 * sizeof(Byte)));
+        zmemzero(s->window, (s->w_size + WINDOW_PADDING) * (2 * sizeof(Byte)));
     }
     s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
     /* Avoid use of uninitialized value, see:
@@ -770,6 +771,12 @@ uLong ZEXPORT deflateBound(strm, sourceLen)
         wraplen = 6;
     }
 
+    /* With Chromium's hashing, s->hash_bits may not correspond to the
+       memLevel, making the computations below incorrect. Return the
+       conservative bound. */
+    if (s->chromium_zlib_hash)
+        return (fixedlen > storelen ? fixedlen : storelen) + wraplen;
+
     /* if not default parameters, return one of the conservative bounds */
     if (s->w_bits != 15 || s->hash_bits != 8 + 7)
         return (s->w_bits <= s->hash_bits ? fixedlen : storelen) + wraplen;
@@ -1199,7 +1206,9 @@ int ZEXPORT deflateCopy(dest, source)
     zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state));
     ds->strm = dest;
 
-    ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
+    ds->window = (Bytef *) ZALLOC(dest,
+                                  ds->w_size + WINDOW_PADDING,
+                                  2*sizeof(Byte));
     ds->prev   = (Posf *)  ZALLOC(dest, ds->w_size, sizeof(Pos));
     ds->head   = (Posf *)  ZALLOC(dest, ds->hash_size, sizeof(Pos));
     ds->pending_buf = (uchf *) ZALLOC(dest, ds->lit_bufsize, 4);
@@ -1210,7 +1219,8 @@ int ZEXPORT deflateCopy(dest, source)
         return Z_MEM_ERROR;
     }
     /* following zmemcpy do not work for 16-bit MSDOS */
-    zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
+    zmemcpy(ds->window, ss->window,
+            (ds->w_size + WINDOW_PADDING) * 2 * sizeof(Byte));
     zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
     zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
     zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
diff --git a/third_party/zlib/inflate.c b/third_party/zlib/inflate.c
index 75fa6b56e..acc88d1dc 100644
--- a/third_party/zlib/inflate.c
+++ b/third_party/zlib/inflate.c
@@ -256,6 +256,8 @@ int value;
     struct inflate_state FAR *state;
 
     if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    if (bits == 0)
+        return Z_OK;
     state = (struct inflate_state FAR *)strm->state;
     if (bits < 0) {
         state->hold = 0;
@@ -1480,7 +1482,7 @@ z_streamp strm;
     /* if first time, start search in bit buffer */
     if (state->mode != SYNC) {
         state->mode = SYNC;
-        state->hold <<= state->bits & 7;
+        state->hold >>= state->bits & 7;
         state->bits -= state->bits & 7;
         len = 0;
         while (state->bits >= 8) {
@@ -1551,8 +1553,9 @@ z_streamp source;
     if (copy == Z_NULL) return Z_MEM_ERROR;
     window = Z_NULL;
     if (state->window != Z_NULL) {
-        window = (unsigned char FAR *)
-                 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
+        window = (unsigned char FAR *)ZALLOC(
+            source, (1U << state->wbits) + CHUNKCOPY_CHUNK_SIZE,
+            sizeof(unsigned char));
         if (window == Z_NULL) {
             ZFREE(source, copy);
             return Z_MEM_ERROR;
diff --git a/third_party/zlib/macros.internal.h b/third_party/zlib/macros.internal.h
index 752c125b9..80dda411d 100644
--- a/third_party/zlib/macros.internal.h
+++ b/third_party/zlib/macros.internal.h
@@ -2,6 +2,10 @@
 #define COSMOPOLITAN_THIRD_PARTY_ZLIB_MACROS_INTERNAL_H_
 COSMOPOLITAN_C_START_
 
+#ifndef STDC
+#define STDC
+#endif
+
 #ifndef OF /* function prototypes */
 #  ifdef STDC
 #    define OF(args)  args
diff --git a/third_party/zlib/trees.c b/third_party/zlib/trees.c
index 578ac9cf6..b3bcd67e5 100644
--- a/third_party/zlib/trees.c
+++ b/third_party/zlib/trees.c
@@ -10,6 +10,7 @@
 #include "libc/stdio/stdio.h"
 #include "libc/temp.h"
 #include "libc/str/str.h"
+#include "libc/ctype.h"
 #include "third_party/zlib/deflate.internal.h"
 
 /*
diff --git a/third_party/zstd/lib/common/compiler.h b/third_party/zstd/lib/common/compiler.h
index f4b6aec75..e0aee016d 100644
--- a/third_party/zstd/lib/common/compiler.h
+++ b/third_party/zstd/lib/common/compiler.h
@@ -288,7 +288,7 @@
 
 # elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
 /* C11 support */
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #  define ZSTD_ALIGNOF(T) alignof(T)
 
 # else
diff --git a/third_party/zstd/lib/common/xxhash.h b/third_party/zstd/lib/common/xxhash.h
index 6a4ea347b..fa8d21d69 100644
--- a/third_party/zstd/lib/common/xxhash.h
+++ b/third_party/zstd/lib/common/xxhash.h
@@ -1019,7 +1019,7 @@ struct XXH64_state_s {
 #ifndef XXH_NO_XXH3
 
 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) /* >= C11 */
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #  define XXH_ALIGN(n)      alignas(n)
 #elif defined(__cplusplus) && (__cplusplus >= 201103L) /* >= C++11 */
 /* In C++ alignas() is a keyword */
diff --git a/tool/args/BUILD.mk b/tool/args/BUILD.mk
index 40aca11cd..1ed3f664a 100644
--- a/tool/args/BUILD.mk
+++ b/tool/args/BUILD.mk
@@ -16,6 +16,7 @@ TOOL_ARGS_A_CHECKS =				\
 	$(TOOL_ARGS_A).pkg
 
 TOOL_ARGS_A_DIRECTDEPS =			\
+	LIBC_CALLS				\
 	LIBC_INTRIN				\
 	LIBC_MEM				\
 	LIBC_NEXGEN32E				\
diff --git a/tool/args/args.c b/tool/args/args.c
index cfb88fd59..380f70165 100644
--- a/tool/args/args.c
+++ b/tool/args/args.c
@@ -16,7 +16,6 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "tool/args/args.h"
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
@@ -134,6 +133,7 @@ int LoadZipArgsImpl(int *argc, char ***argv, char *data) {
  * replaced with whatever CLI args were specified by the user.
  *
  * @return 0 on success, or -1 if not found w/o errno clobber
+ * @deprecated please use `cosmo_args()` it's more powerful
  */
 int LoadZipArgs(int *argc, char ***argv) {
   int e;
diff --git a/tool/args/args.h b/tool/args/args.h
deleted file mode 100644
index dbb517888..000000000
--- a/tool/args/args.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef COSMOPOLITAN_TOOL_ARGS_ARGS_H_
-#define COSMOPOLITAN_TOOL_ARGS_ARGS_H_
-COSMOPOLITAN_C_START_
-
-int LoadZipArgs(int *, char ***) libcesque;
-
-COSMOPOLITAN_C_END_
-#endif /* COSMOPOLITAN_TOOL_ARGS_ARGS_H_ */
diff --git a/tool/args/args2.c b/tool/args/args2.c
new file mode 100644
index 000000000..6af066c4f
--- /dev/null
+++ b/tool/args/args2.c
@@ -0,0 +1,582 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/cosmo.h"
+#include "libc/ctype.h"
+#include "libc/cxxabi.h"
+#include "libc/errno.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/str/tab.h"
+#include "libc/sysv/consts/o.h"
+
+__static_yoink("zipos");
+
+#define CLEAR(b)                                        \
+  do {                                                  \
+    b##_cap = 8;                                        \
+    b##_len = 0;                                        \
+    if (!(b##_ptr = calloc(b##_cap, sizeof(*b##_ptr)))) \
+      goto Failure;                                     \
+  } while (0)
+
+#define APPEND(b, c)                                           \
+  do {                                                         \
+    if (b##_len + 2 > b##_cap) {                               \
+      b##_cap += b##_cap >> 1;                                 \
+      void *p_ = realloc(b##_ptr, b##_cap * sizeof(*b##_ptr)); \
+      if (!p_)                                                 \
+        goto Failure;                                          \
+      b##_ptr = p_;                                            \
+    }                                                          \
+    b##_ptr[b##_len++] = c;                                    \
+    b##_ptr[b##_len] = 0;                                      \
+  } while (0)
+
+#define APPEND_DUP(b, s)    \
+  do {                      \
+    char *tmp;              \
+    if (!(tmp = strdup(s))) \
+      goto Failure;         \
+    APPEND(args, tmp);      \
+  } while (0)
+
+static int esc(int c) {
+  switch (c) {
+    case 'a':
+      return '\a';
+    case 'b':
+      return '\b';
+    case 't':
+      return '\t';
+    case 'n':
+      return '\n';
+    case 'v':
+      return '\v';
+    case 'f':
+      return '\f';
+    case 'r':
+      return '\r';
+    case 'e':
+      return '\e';
+    default:
+      return -1;
+  }
+}
+
+static void cosmo_args_free(void *list) {
+  char **args = list;
+  char *arg;
+  while ((arg = *args++))
+    free(arg);
+  free(list);
+}
+
+/**
+ * Replaces argument list with `/zip/.args` contents if it exists.
+ *
+ * First read the documentation to LoadZipArgs(). This works basically
+ * the same, assuming you pass `"/zip/.args"` as the first argument. The
+ * difference is that arguments here are parsed more similarly to the
+ * shell. In the old version, if you wanted your zip .args config to
+ * insert three arguments at the beginning of your argv, you'd say:
+ *
+ *     arg1
+ *     arg2
+ *     arg3
+ *
+ * This will still work. You can also now say:
+ *
+ *     arg1 arg2
+ *     arg3
+ *
+ * This breaks backwards compatibility, since the old design was made
+ * for programs like ar.ape that wanted to be able to accept filename
+ * arguments that could potentially have spaces. This new parser, on the
+ * other hand, is designed to help offer the configurability a project
+ * like llamafile needs, without going so far as to be Turing complete.
+ * For example, you could say:
+ *
+ *     # this is a comment
+ *     this\ is' a single arg'"ok"# # comment
+ *
+ * Which will result in the C string `"this is a single argok#"`. You
+ * can even use $VAR notation to schlep in environment variables. Here's
+ * how this is different from shell:
+ *
+ * 1. We don't expand $foo into multiple arguments if it has spaces
+ * 2. Double quoted strings work like they do in C, e.g. `"\177\x7f\n"`
+ * 3. You can't recursively reference environment variables
+ *
+ * If the process was started in a degenerate state without argv[0] then
+ * GetProgramExecutableName() will be inserted in its place, on success.
+ *
+ * The `path` argument may be null, in which case only normalization is
+ * performed. It is not considered an error if `path` is specified and
+ * the file doesn't exist. The errno state will be left dirty if that
+ * happens, so it can be checked by clearing `errno` before calling.
+ *
+ * The returned memory is copied and automatically freed on exit().
+ *
+ * @return argc on success, or -1 w/ errno
+ */
+int cosmo_args(const char *path, char ***argv) {
+
+  // the file
+  int fd = -1;
+
+  // variable name builder
+  int var_cap = 0;
+  int var_len = 0;
+  char *var_ptr = 0;
+
+  // argument string builder
+  int arg_cap = 0;
+  int arg_len = 0;
+  char *arg_ptr = 0;
+
+  // argument array builder
+  int args_cap = 0;
+  int args_len = 0;
+  char **args_ptr = 0;
+
+  // initialize memory
+  CLEAR(var);
+  CLEAR(arg);
+  CLEAR(args);
+
+  // state machine
+  enum {
+    NORMAL,
+    COMMENT,
+    ARGUMENT,
+    BACKSLASH,
+    DOLLAR,
+    DOLLAR_VAR,
+    DOLLAR_LCB,
+    DOT,
+    DOT_DOT,
+    DOT_DOT_DOT,
+    QUOTE,
+    DQUOTE,
+    DQUOTE_DOLLAR,
+    DQUOTE_DOLLAR_VAR,
+    DQUOTE_DOLLAR_LCB,
+    DQUOTE_BACKSLASH,
+    DQUOTE_BACKSLASH_X,
+    DQUOTE_BACKSLASH_X_XDIGIT,
+    DQUOTE_BACKSLASH_DIGIT,
+    DQUOTE_BACKSLASH_DIGIT_DIGIT,
+  } t = NORMAL;
+
+  // extra state
+  int x, numba = 0;
+
+  // add program argument
+  char **argvp = *argv;
+  if (*argvp) {
+    APPEND_DUP(args, *argvp++);
+  } else {
+    APPEND_DUP(args, GetProgramExecutableName());
+  }
+
+  // perform i/o
+  if (path) {
+    if ((fd = open(path, O_RDONLY)) == -1)
+      if (errno != ENOENT && errno != ENOTDIR)
+        goto Failure;
+    if (fd != -1) {
+      for (;;) {
+        char buf[512];
+        int got = read(fd, buf, sizeof(buf));
+        if (got == -1)
+          goto Failure;
+        if (!got)
+          break;
+        for (int i = 0; i < got; ++i) {
+          int c = buf[i] & 255;
+          switch (t) {
+
+            case NORMAL:
+              switch (c) {
+                case ' ':
+                case '\t':
+                case '\r':
+                case '\n':
+                case '\f':
+                case '\v':
+                  break;
+                case '#':
+                  t = COMMENT;
+                  break;
+                case '\'':
+                  t = QUOTE;
+                  break;
+                case '"':
+                  t = DQUOTE;
+                  break;
+                case '$':
+                  t = DOLLAR;
+                  break;
+                case '.':
+                  t = DOT;
+                  break;
+                case '\\':
+                  t = BACKSLASH;
+                  break;
+                default:
+                  APPEND(arg, c);
+                  t = ARGUMENT;
+                  break;
+              }
+              break;
+
+            Argument:
+            case ARGUMENT:
+              switch (c) {
+                case ' ':
+                case '\t':
+                case '\r':
+                case '\n':
+                case '\f':
+                case '\v':
+                  APPEND(args, arg_ptr);
+                  CLEAR(arg);
+                  t = NORMAL;
+                  break;
+                case '\'':
+                  t = QUOTE;
+                  break;
+                case '"':
+                  t = DQUOTE;
+                  break;
+                case '$':
+                  t = DOLLAR;
+                  break;
+                case '\\':
+                  t = BACKSLASH;
+                  break;
+                default:
+                  APPEND(arg, c);
+                  break;
+              }
+              break;
+
+            case BACKSLASH:
+              if (c == '\r') {
+                // do nothing
+              } else if (c == '\n') {
+                t = NORMAL;
+              } else if ((x = esc(c)) != -1) {
+                APPEND(arg, x);
+                t = ARGUMENT;
+              } else {
+                APPEND(arg, c);
+                t = ARGUMENT;
+              }
+              break;
+
+            case COMMENT:
+              if (c == '\n')
+                t = NORMAL;
+              break;
+
+            case DOLLAR:
+              if (isalnum(c) || c == '_') {
+                APPEND(var, c);
+                t = DOLLAR_VAR;
+              } else if (c == '{') {
+                t = DOLLAR_LCB;
+              } else {
+                APPEND(arg, '$');
+                if (c != '$') {
+                  t = ARGUMENT;
+                  goto Argument;
+                }
+              }
+              break;
+
+            case DOLLAR_VAR:
+              if (isalnum(c) || c == '_') {
+                APPEND(var, c);
+              } else {
+                char *val = getenv(var_ptr);
+                if (!val)
+                  val = "";
+                free(var_ptr);
+                CLEAR(var);
+                while (*val)
+                  APPEND(arg, *val++);
+                t = ARGUMENT;
+                goto Argument;
+              }
+              break;
+
+            case DOLLAR_LCB:
+              if (c == '}') {
+                char *val = getenv(var_ptr);
+                if (!val)
+                  val = "";
+                free(var_ptr);
+                CLEAR(var);
+                while (*val)
+                  APPEND(arg, *val++);
+                t = ARGUMENT;
+              } else {
+                APPEND(var, c);
+              }
+              break;
+
+            case QUOTE:
+              if (c == '\'') {
+                t = ARGUMENT;
+              } else {
+                APPEND(arg, c);
+              }
+              break;
+
+            Dquote:
+            case DQUOTE:
+              if (c == '"') {
+                t = ARGUMENT;
+              } else if (c == '$') {
+                t = DQUOTE_DOLLAR;
+              } else if (c == '\\') {
+                t = DQUOTE_BACKSLASH;
+              } else {
+                APPEND(arg, c);
+              }
+              break;
+
+            case DQUOTE_DOLLAR:
+              if (isalnum(c) || c == '_') {
+                APPEND(var, c);
+                t = DQUOTE_DOLLAR_VAR;
+              } else if (c == '{') {
+                t = DQUOTE_DOLLAR_LCB;
+              } else {
+                APPEND(arg, '$');
+                if (c != '$') {
+                  t = DQUOTE;
+                  goto Dquote;
+                }
+              }
+              break;
+
+            case DQUOTE_DOLLAR_VAR:
+              if (isalnum(c) || c == '_') {
+                APPEND(var, c);
+              } else {
+                char *val = getenv(var_ptr);
+                if (!val)
+                  val = "";
+                free(var_ptr);
+                CLEAR(var);
+                while (*val)
+                  APPEND(arg, *val++);
+                t = DQUOTE;
+                goto Dquote;
+              }
+              break;
+
+            case DQUOTE_DOLLAR_LCB:
+              if (c == '}') {
+                char *val = getenv(var_ptr);
+                if (!val)
+                  val = "";
+                free(var_ptr);
+                CLEAR(var);
+                while (*val)
+                  APPEND(arg, *val++);
+                t = DQUOTE;
+              } else {
+                APPEND(var, c);
+              }
+              break;
+
+            case DQUOTE_BACKSLASH:
+              if (isdigit(c)) {
+                numba = c - '0';
+                t = DQUOTE_BACKSLASH_DIGIT;
+              } else if (c == 'x') {
+                t = DQUOTE_BACKSLASH_X;
+              } else if ((x = esc(c)) != -1) {
+                APPEND(arg, x);
+                t = DQUOTE;
+              } else if (c == '\r') {
+                // do nothing
+              } else if (c == '\n') {
+                t = DQUOTE;
+              } else {
+                APPEND(arg, c);
+                t = DQUOTE;
+              }
+              break;
+
+            case DQUOTE_BACKSLASH_DIGIT:
+              if (isdigit(c)) {
+                numba <<= 3;
+                numba += c - '0';
+                t = DQUOTE_BACKSLASH_DIGIT_DIGIT;
+              } else {
+                APPEND(arg, numba);
+                t = DQUOTE;
+                goto Dquote;
+              }
+              break;
+
+            case DQUOTE_BACKSLASH_DIGIT_DIGIT:
+              if (isdigit(c)) {
+                numba <<= 3;
+                numba += c - '0';
+                APPEND(arg, numba);
+                t = DQUOTE;
+              } else {
+                APPEND(arg, numba);
+                t = DQUOTE;
+                goto Dquote;
+              }
+              break;
+
+            case DQUOTE_BACKSLASH_X:
+              if ((x = kHexToInt[c]) != -1) {
+                numba = x;
+                t = DQUOTE_BACKSLASH_X_XDIGIT;
+              } else {
+                APPEND(arg, 'x');
+                t = DQUOTE;
+                goto Dquote;
+              }
+              break;
+
+            case DQUOTE_BACKSLASH_X_XDIGIT:
+              if ((x = kHexToInt[c]) != -1) {
+                numba <<= 4;
+                numba += x;
+                APPEND(arg, numba);
+                t = DQUOTE;
+              } else {
+                APPEND(arg, numba);
+                t = DQUOTE;
+                goto Dquote;
+              }
+              break;
+
+            case DOT:
+              if (c == '.') {
+                t = DOT_DOT;
+              } else {
+                APPEND(arg, '.');
+                t = ARGUMENT;
+                goto Argument;
+              }
+              break;
+
+            case DOT_DOT:
+              if (c == '.') {
+                t = DOT_DOT_DOT;
+              } else {
+                APPEND(arg, '.');
+                APPEND(arg, '.');
+                t = ARGUMENT;
+                goto Argument;
+              }
+              break;
+
+            case DOT_DOT_DOT:
+              if (isspace(c)) {
+                while (*argvp)
+                  APPEND_DUP(args, *argvp++);
+                t = NORMAL;
+              } else {
+                APPEND(arg, '.');
+                APPEND(arg, '.');
+                APPEND(arg, '.');
+                t = ARGUMENT;
+                goto Argument;
+              }
+              break;
+
+            default:
+              __builtin_unreachable();
+          }
+        }
+      }
+      if (close(fd))
+        goto Failure;
+
+      // clean up dirty state
+      switch (t) {
+        case DOT:
+          APPEND(arg, '.');
+          break;
+        case DOT_DOT:
+          APPEND(arg, '.');
+          APPEND(arg, '.');
+          break;
+        case DOT_DOT_DOT:
+          while (*argvp)
+            APPEND_DUP(args, *argvp++);
+          break;
+        case DOLLAR:
+          APPEND(arg, '$');
+          break;
+        case DOLLAR_VAR:
+        case DQUOTE_DOLLAR_VAR:
+          char *val = getenv(var_ptr);
+          if (!val)
+            val = "";
+          while (*val)
+            APPEND(arg, *val++);
+          break;
+        case DOLLAR_LCB:
+        case DQUOTE_DOLLAR_LCB:
+          APPEND(arg, '$');
+          APPEND(arg, '{');
+          for (int j = 0; var_ptr[j]; ++j)
+            APPEND(arg, var_ptr[j]);
+          break;
+        default:
+          break;
+      }
+      if (arg_len) {
+        APPEND(args, arg_ptr);
+        CLEAR(arg);
+      }
+    }
+  }
+
+  // append original argv if ... wasn't specified
+  while (*argvp)
+    APPEND_DUP(args, *argvp++);
+
+  // return result
+  __cxa_atexit(cosmo_args_free, args_ptr, 0);
+  *argv = args_ptr;
+  free(arg_ptr);
+  free(var_ptr);
+  return args_len;
+
+Failure:
+  cosmo_args_free(args_ptr);
+  free(arg_ptr);
+  if (fd != -1)
+    close(fd);
+  return -1;
+}
diff --git a/tool/build/BUILD.mk b/tool/build/BUILD.mk
index 844a0ab28..2d37a2bd0 100644
--- a/tool/build/BUILD.mk
+++ b/tool/build/BUILD.mk
@@ -42,6 +42,7 @@ TOOL_BUILD_DIRECTDEPS =							\
 	LIBC_SOCK							\
 	LIBC_STDIO							\
 	LIBC_STR							\
+	LIBC_SYSTEM							\
 	LIBC_SYSV							\
 	LIBC_SYSV_CALLS							\
 	LIBC_THREAD							\
@@ -60,7 +61,7 @@ TOOL_BUILD_DIRECTDEPS =							\
 	THIRD_PARTY_XED							\
 	THIRD_PARTY_ZLIB						\
 	THIRD_PARTY_ZLIB_GZ						\
-	TOOL_BUILD_LIB
+	TOOL_BUILD_LIB							\
 
 TOOL_BUILD_DEPS :=							\
 	$(call uniq,$(foreach x,$(TOOL_BUILD_DIRECTDEPS),$($(x))))
@@ -86,9 +87,11 @@ o/$(MODE)/tool/build/cocmd.zip.o: private				\
 
 # we need pic because:
 #   so it can be an LD_PRELOAD payload
+# we need fsanitize-trap=all becuase:
+#   so we don't need to pull in the entire ubsan runtime
 o/$(MODE)/tool/build/dso/sandbox.o: private				\
 		CFLAGS +=						\
-			-fPIC
+			-fPIC -fsanitize-trap=all
 
 o/$(MODE)/tool/build/dso/sandbox.o:					\
 		libc/calls/calls.h					\
@@ -96,7 +99,7 @@ o/$(MODE)/tool/build/dso/sandbox.o:					\
 		libc/calls/pledge.h					\
 		libc/runtime/runtime.h					\
 		libc/calls/pledge.internal.h				\
-		libc/intrin/promises.internal.h				\
+		libc/intrin/promises.h					\
 		tool/build/BUILD.mk
 
 o/$(MODE)/tool/build/dso/sandbox-$(ARCH).so:				\
@@ -135,8 +138,8 @@ o/$(MODE)/tool/build/dso/dlopen_helper.so:				\
 		o/$(MODE)/tool/build/dso/dlopen_helper.o		\
 		$(OUTPUT_OPTION)
 
-o/$(MODE)/tool/build/dlopen_test.runs:					\
-		o/$(MODE)/tool/build/dlopen_test			\
+o/$(MODE)/tool/build/dlopen_tester.runs:				\
+		o/$(MODE)/tool/build/dlopen_tester			\
 		o/$(MODE)/tool/build/dso/dlopen_helper.so
 	$< o/$(MODE)/tool/build/dso/dlopen_helper.so
 
diff --git a/tool/build/apelink.c b/tool/build/apelink.c
index cfdcaea61..f84b50ef2 100644
--- a/tool/build/apelink.c
+++ b/tool/build/apelink.c
@@ -19,8 +19,9 @@
 #include "ape/ape.h"
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
+#include "libc/ctype.h"
 #include "libc/dce.h"
-#include "libc/dos.internal.h"
+#include "libc/dos.h"
 #include "libc/elf/def.h"
 #include "libc/elf/elf.h"
 #include "libc/elf/scalar.h"
@@ -29,8 +30,8 @@
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
 #include "libc/limits.h"
-#include "libc/macho.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macho.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/pedef.internal.h"
 #include "libc/nt/struct/imageimportbyname.internal.h"
@@ -40,7 +41,7 @@
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/symbols.internal.h"
 #include "libc/serialize.h"
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #include "libc/stdckdint.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/blake2.h"
@@ -48,7 +49,7 @@
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "third_party/getopt/getopt.internal.h"
 #include "third_party/zlib/zlib.h"
 #include "tool/build/lib/lib.h"
@@ -84,6 +85,13 @@
   "             executable will self-modify its header on\n"   \
   "             the first run, to use the platform format\n"   \
   "\n"                                                         \
+  "  -k KERNEL  test for maching kernel name [repeatable]\n"   \
+  "             when set, the shell script for subsequent\n"   \
+  "             loader executables will check if uname -s\n"   \
+  "             output matches the kernel string, only if\n"   \
+  "             the loader executable architecture is not\n"   \
+  "             an architecture in the input binary list\n"    \
+  "\n"                                                         \
   "  -M PATH    bundle ape loader source code file for m1\n"   \
   "             processors running the xnu kernel so that\n"   \
   "             it can be compiled on the fly by xcode\n"      \
@@ -212,6 +220,7 @@ struct Loader {
   char *ddarg_size1;
   char *ddarg_skip2;
   char *ddarg_size2;
+  const char *kernel;
 };
 
 struct Loaders {
@@ -243,6 +252,7 @@ static struct Inputs inputs;
 static char ape_heredoc[15];
 static enum Strategy strategy;
 static struct Loaders loaders;
+static const char *loader_kernel;
 static const char *custom_sh_code;
 static bool force_bypass_binfmt_misc;
 static bool generate_debuggable_binary;
@@ -259,8 +269,6 @@ static Elf64_Xword notesize;
 
 static char *r_off32_e_lfanew;
 
-#include "libc/mem/tinymalloc.inc"
-
 static wontreturn void Die(const char *thing, const char *reason) {
   tinyprint(2, thing, ": ", reason, "\n", NULL);
   exit(1);
@@ -678,6 +686,8 @@ static void LoadSymbols(Elf64_Ehdr *e, Elf64_Off size, const char *path) {
   struct SymbolTable *st = OpenSymbolTable(path);
   if (!st)
     Die(path, "could not load elf symbol table");
+  st->names = 0;      // make this deterministic
+  st->name_base = 0;  // ready for serialization
   size_t data_size;
   void *data = Deflate(st, st->size, &data_size);
   uint32_t crc = crc32_z(0, st, st->size);
@@ -978,13 +988,19 @@ static void AddLoader(const char *path) {
   if (loaders.n == ARRAYLEN(loaders.p)) {
     Die(prog, "too many loaders");
   }
-  loaders.p[loaders.n++].path = path;
+  struct Loader *loader = &loaders.p[loaders.n++];
+  loader->path = path;
+  loader->kernel = loader_kernel;
+}
+
+static void SetLoaderKernel(const char *kernel) {
+  loader_kernel = kernel;
 }
 
 static void GetOpts(int argc, char *argv[]) {
   int opt, bits;
   bool got_support_vector = false;
-  while ((opt = getopt(argc, argv, "hvgsGBo:l:S:M:V:")) != -1) {
+  while ((opt = getopt(argc, argv, "hvgsGBo:l:k:S:M:V:")) != -1) {
     switch (opt) {
       case 'o':
         outpath = optarg;
@@ -1008,6 +1024,10 @@ static void GetOpts(int argc, char *argv[]) {
         HashInputString("-l");
         AddLoader(optarg);
         break;
+      case 'k':
+        HashInputString("-k");
+        SetLoaderKernel(optarg);
+        break;
       case 'S':
         HashInputString("-S");
         HashInputString(optarg);
@@ -1629,6 +1649,28 @@ static char *GenerateScriptIfMachine(char *p, struct Input *in) {
   }
 }
 
+static char *GenerateScriptIfLoaderMachine(char *p, struct Loader *loader) {
+  if (loader->machine == EM_NEXGEN32E) {
+    p = stpcpy(p, "if [ \"$m\" = x86_64 ] || [ \"$m\" = amd64 ]");
+  } else if (loader->machine == EM_AARCH64) {
+    p = stpcpy(p, "if [ \"$m\" = aarch64 ] || [ \"$m\" = arm64 ] || [ \"$m\" = evbarm ]");
+  } else if (loader->machine == EM_PPC64) {
+    p = stpcpy(p, "if [ \"$m\" = ppc64le ]");
+  } else if (loader->machine == EM_MIPS) {
+    p = stpcpy(p, "if [ \"$m\" = mips64 ]");
+  } else {
+    Die(loader->path, "unsupported cpu architecture");
+  }
+
+  if (loader->kernel) {
+    p = stpcpy(p, " && [ \"$k\" = ");
+    p = stpcpy(p, loader->kernel);
+    p = stpcpy(p, " ]");
+  }
+
+  return stpcpy(p, "; then\n");
+}
+
 static char *FinishGeneratingDosHeader(char *p) {
   p = WRITE16LE(p, 0x1000);  // 10: MZ: lowers upper bound load / 16
   p = WRITE16LE(p, 0xf800);  // 12: MZ: roll greed on bss
@@ -1878,7 +1920,15 @@ int main(int argc, char *argv[]) {
     for (j = i + 1; j < loaders.n; ++j) {
       if (loaders.p[i].os == loaders.p[j].os &&
           loaders.p[i].machine == loaders.p[j].machine) {
-        Die(prog, "multiple ape loaders specified for the same platform");
+        if (!loaders.p[i].kernel && !loaders.p[j].kernel) {
+          Die(prog, "multiple ape loaders specified for the same platform");
+        }
+        if (loaders.p[i].kernel != NULL &&
+            loaders.p[j].kernel != NULL &&
+            strcmp(loaders.p[i].kernel, loaders.p[j].kernel) == 0) {
+          Die(prog, "multiple ape loaders specified for the same platform "
+                    "with matching kernels");
+        }
       }
     }
   }
@@ -2189,6 +2239,36 @@ int main(int argc, char *argv[]) {
         gotsome = true;
       }
     }
+
+    // extract the ape loader for non-input architectures
+    // if the user requested a host kernel check, get the host kernel
+    if (loader_kernel) {
+      p = stpcpy(p, "k=$(uname -s 2>/dev/null) || k=unknown\n");
+    }
+    for (i = 0; i < loaders.n; ++i) {
+      struct Loader *loader = loaders.p + i;
+      if (loader->used) {
+        continue;
+      }
+      loader->used = true;
+      p = GenerateScriptIfLoaderMachine(p, loader);
+      p = stpcpy(p, "mkdir -p \"${t%/*}\" ||exit\n"
+                    "dd if=\"$o\"");
+      p = stpcpy(p, " skip=");
+      loader->ddarg_skip2 = p;
+      p = GenerateDecimalOffsetRelocation(p);
+      p = stpcpy(p, " count=");
+      loader->ddarg_size2 = p;
+      p = GenerateDecimalOffsetRelocation(p);
+      p = stpcpy(p, " bs=1 2>/dev/null | gzip -dc >\"$t.$$\" ||exit\n"
+                    "chmod 755 \"$t.$$\" ||exit\n"
+                    "mv -f \"$t.$$\" \"$t\" ||exit\n");
+      p = stpcpy(p, "exec \"$t\" \"$o\" \"$@\"\n"
+                    "fi\n");
+      gotsome = true;
+    }
+
+    // close if-statements
     if (inputs.n && (support_vector & _HOSTXNU)) {
       if (!gotsome) {
         p = stpcpy(p, "true\n");
diff --git a/tool/build/ar.c b/tool/build/ar.c
index 616ee56dd..29f9abb32 100644
--- a/tool/build/ar.c
+++ b/tool/build/ar.c
@@ -31,7 +31,7 @@
 #include "libc/fmt/magnumstrs.internal.h"
 #include "libc/intrin/bsr.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/serialize.h"
 #include "libc/stdckdint.h"
@@ -40,30 +40,74 @@
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
 #include "libc/sysv/consts/s.h"
+#include "tool/build/lib/ar.h"
 #include "tool/build/lib/getargs.h"
 
 /**
  * @fileoverview cosmopolitan ar
- *
- * This static archiver is superior:
- *
- * - Isn't "accidentally quadratic" like GNU ar
- * - Goes 2x faster than LLVM ar while using 100x less memory
- * - Can be built as a 52kb APE binary that works well on six OSes
- *
- * This static archiver introduces handy features:
- *
- * - Arguments may be supplied in an `@args.txt` file
- * - Directory arguments are ignored
- *
- * @see https://www.unix.com/man-page/opensolaris/3head/ar.h/
- * @see https://en.wikipedia.org/wiki/Ar_(Unix)
  */
 
-#define VERSION                     \
-  "cosmopolitan ar v2.0\n"          \
-  "copyright 2023 justine tunney\n" \
-  "https://github.com/jart/cosmopolitan\n"
+static wontreturn void ShowUsage(int rc, int fd) {
+  tinyprint(  //
+      fd,
+      "USAGE\n"
+      "\n",
+      "  ", program_invocation_name, " FLAGS ARCHIVE FILE...\n",
+      "\n"
+      "FLAGS\n"
+      "\n"
+      "  rcs        create new archive with index\n"
+      "  rcsD       always deterministic\n"
+      "  --help     show usage\n"
+      "  --version  show program details\n"
+      "\n"
+      "ARGUMENTS\n"
+      "\n"
+      "  ARCHIVE    should be foo.a\n"
+      "  FILE       should be foo.o, lib.a, or @args.txt\n"
+      "\n"
+      "DOCUMENTATION\n"
+      "\n"
+      "  Your Cosmopolitan Archiver is superior:\n"
+      "\n"
+      "  - Isn't accidentally quadratic like GNU ar. Cosmopolitan Libc is\n"
+      "    distributed as libcosmo.a which contains 5000+ object files and\n"
+      "    is tens of megabytes in size. GNU ar isn't capable of making an\n"
+      "    archive that large. So we invented this ar as a replacement.\n"
+      "\n"
+      "  - Goes 2x faster than LLVM ar thanks to modern system calls like\n"
+      "    copy_file_range(). This ar should also use 100x less memory.\n"
+      "\n"
+      "  - Can be built as a 96kb APE binary that works well on six OSes.\n"
+      "    Cosmopolitan uses the same dev tools on all OSes and archsr to\n"
+      "    ensure compilations are simple and deterministic for everyone.\n"
+      "\n"
+      "  This static archiver introduces handy features:\n"
+      "\n"
+      "  - Arguments may be supplied in an `@args.txt` file. This is useful\n"
+      "    for overcoming the `ARG_MAX` limit, which is especially important\n"
+      "    on Windows, where only very few command arguments can be passed.\n"
+      "    GNU Make can be easily configured to generate args files.\n"
+      "\n"
+      "  - You can merge many .a files into one big .a file. Args that end\n"
+      "    with .a will be opened as static archives. The .o files inside it\n"
+      "    will then be added to your new archive. It would be the same as if\n"
+      "    you passed all the .o files as args. This is fast. For example, to\n"
+      "    merge 37 .a files containing 5000 .o files takes ~38 milliseconds.\n"
+      "\n"
+      "  - Directory arguments are ignored. The biggest gotcha with makefiles\n"
+      "    that use wildcard globbing is that it can't detect when files are\n"
+      "    deleted, which means it can't invalidate the artifacts which had\n"
+      "    depended on that file, leading to nondeterminism and surprising\n"
+      "    build failures. The simplest way to solve that is to add the\n"
+      "    directory to the prerequisites list, since the directory modified\n"
+      "    time will be updated by the OS when files inside it are deleted.\n"
+      "    When doing this, it's simple and elegant to not need to filter\n"
+      "    the directory prerequisites before passing `$^` to `ar`.\n"
+      "\n",
+      NULL);
+  exit(rc);
+}
 
 #define HEAP_SIZE (256L * 1024 * 1024)
 
@@ -108,29 +152,6 @@ static wontreturn void SysDie(const char *path, const char *func) {
   exit(1);
 }
 
-static wontreturn void ShowUsage(int rc, int fd) {
-  tinyprint(fd, VERSION,
-            "\n"
-            "USAGE\n"
-            "\n",
-            "  ", program_invocation_name, " FLAGS ARCHIVE FILE...\n",
-            "\n"
-            "FLAGS\n"
-            "\n"
-            "  rcs        create new archive with index\n"
-            "  rcsD       always deterministic\n"
-            "  --help     show usage\n"
-            "  --version  show program details\n"
-            "\n"
-            "ARGUMENTS\n"
-            "\n"
-            "  ARCHIVE    should be foo.a\n"
-            "  FILE       should be foo.o or @args.txt\n"
-            "\n",
-            NULL);
-  exit(rc);
-}
-
 // allocates 𝑛 bytes of memory aligned on 𝑎 from .bss
 // - avoids binary bloat of mmap() and malloc()
 // - dies if out of memory or overflow occurs
@@ -159,13 +180,11 @@ static void *balloc(size_t n, size_t a) {
   } else {
     c = 2ull << (__builtin_clzll(n - 1) ^ (sizeof(long long) * CHAR_BIT - 1));
   }
-  if (c < a || c > HEAP_SIZE || p + c > h + HEAP_SIZE) {
+  if (c < a || c > HEAP_SIZE || p + c > h + HEAP_SIZE)
     Die(program_invocation_name, "out of memory");
-  }
   used = p - h + c;
-  if (resizable) {
+  if (resizable)
     memcpy((char *)p - sizeof(c), &c, sizeof(c));
-  }
   return (void *)p;
 }
 
@@ -258,21 +277,28 @@ static void MakeArHeader(struct ar_hdr *h,  //
 // - uses copy_file_range() if possible
 // - returns number of bytes exchanged
 // - dies if operation fails
-static int64_t CopyFileOrDie(const char *inpath, int infd,  //
-                             const char *outpath, int outfd) {
-  int64_t toto;
+static void CopyFileOrDie(const char *inpath, int infd,    //
+                          const char *outpath, int outfd,  //
+                          size_t offset, size_t size) {
   char buf[512];
   size_t exchanged;
-  ssize_t got, wrote;
   enum { CFR, RW } mode;
-  for (mode = CFR, toto = 0;; toto += exchanged) {
+  ssize_t want, got, wrote;
+  if (offset)
+    if (lseek(infd, offset, SEEK_SET) == -1)
+      SysDie(inpath, "lseek");
+  for (mode = CFR; size; size -= exchanged) {
     if (mode == CFR) {
-      got = copy_file_range(infd, 0, outfd, 0, 4194304, 0);
+      want = 4194304;
+      if (want > size)
+        want = size;
+      got = copy_file_range(infd, 0, outfd, 0, want, 0);
       if (!got)
-        break;
+        Die(inpath, "unexpected eof");
       if (got != -1) {
         exchanged = got;
       } else if (errno == EXDEV ||       // different partitions
+                 errno == EINVAL ||      // possible w/ ecryptfs
                  errno == ENOSYS ||      // not linux or freebsd
                  errno == ENOTSUP ||     // probably a /zip file
                  errno == EOPNOTSUPP) {  // technically the same
@@ -282,9 +308,12 @@ static int64_t CopyFileOrDie(const char *inpath, int infd,  //
         SysDie(inpath, "copy_file_range");
       }
     } else {
-      got = read(infd, buf, sizeof(buf));
+      want = sizeof(buf);
+      if (want > size)
+        want = size;
+      got = read(infd, buf, want);
       if (!got)
-        break;
+        Die(inpath, "unexpected eof");
       if (got == -1)
         SysDie(inpath, "read");
       wrote = write(outfd, buf, got);
@@ -295,7 +324,51 @@ static int64_t CopyFileOrDie(const char *inpath, int infd,  //
       exchanged = wrote;
     }
   }
-  return toto;
+}
+
+static void AppendName(const char *name, struct Args *names,
+                       struct Bytes *filenames) {
+  struct ar_hdr header1;
+  char bnbuf[PATH_MAX + 1];
+  strlcpy(bnbuf, name, sizeof(bnbuf));
+  char *aname = StrCat(basename(bnbuf), "/");
+  if (strlen(aname) <= sizeof(header1.ar_name)) {
+    AppendArg(names, aname);
+  } else {
+    char ibuf[21];
+    FormatUint64(ibuf, filenames->i);
+    AppendArg(names, StrCat("/", ibuf));
+    AppendBytes(filenames, aname, strlen(aname));
+    AppendBytes(filenames, "\n", 1);
+  }
+}
+
+static void AppendSymbols(const char *path, const Elf64_Ehdr *elf,
+                          size_t elfsize, struct Bytes *symbols,
+                          struct Ints *symnames, int objid) {
+  if (!IsElf64Binary(elf, elfsize))
+    Die(path, "not an elf64 binary");
+  char *strs = GetElfStringTable(elf, elfsize, ".strtab");
+  if (!strs)
+    Die(path, "elf .strtab not found");
+  Elf64_Xword symcount;
+  Elf64_Shdr *symsec = GetElfSymbolTable(elf, elfsize, SHT_SYMTAB, &symcount);
+  Elf64_Sym *syms = GetElfSectionAddress(elf, elfsize, symsec);
+  if (!syms)
+    Die(path, "elf symbol table not found");
+  for (Elf64_Xword j = symsec->sh_info; j < symcount; ++j) {
+    if (!syms[j].st_name)
+      continue;
+    if (syms[j].st_shndx == SHN_UNDEF)
+      continue;
+    if (syms[j].st_shndx == SHN_COMMON)
+      continue;
+    const char *symname = GetElfString(elf, elfsize, strs, syms[j].st_name);
+    if (!symname)
+      Die(path, "elf symbol name corrupted");
+    AppendBytes(symbols, symname, strlen(symname) + 1);
+    AppendInt(symnames, objid);
+  }
 }
 
 int main(int argc, char *argv[]) {
@@ -309,24 +382,26 @@ int main(int argc, char *argv[]) {
 
   // handle hardcoded flags
   if (argc == 2) {
-    if (IsEqual(argv[1], "-n")) {
+    if (IsEqual(argv[1], "-n"))
       exit(0);
-    }
     if (IsEqual(argv[1], "-h") ||  //
         IsEqual(argv[1], "-?") ||  //
         IsEqual(argv[1], "--help")) {
       ShowUsage(0, 1);
     }
     if (IsEqual(argv[1], "--version")) {
-      tinyprint(1, VERSION, NULL);
+      tinyprint(1,
+                "cosmopolitan ar v3.0\n"
+                "copyright 2024 justine tunney\n"
+                "https://github.com/jart/cosmopolitan\n",
+                NULL);
       exit(0);
     }
   }
 
   // get flags and output path
-  if (argc < 3) {
-    ShowUsage(1, 2);
-  }
+  if (argc < 3)
+    Die(argv[0], "missing argument");
   char *flags = argv[1];
   const char *outpath = argv[2];
 
@@ -347,8 +422,8 @@ int main(int argc, char *argv[]) {
 
   struct Args args = {reballoc(0, 4096, sizeof(char *))};
   struct Args names = {reballoc(0, 4096, sizeof(char *))};
-  struct Ints modes = {reballoc(0, 4096, sizeof(int))};
   struct Ints sizes = {reballoc(0, 4096, sizeof(int))};
+  struct Ints foffsets = {reballoc(0, 4096, sizeof(int))};
   struct Ints symnames = {reballoc(0, 16384, sizeof(int))};
   struct Bytes symbols = {reballoc(0, 131072, sizeof(char))};
   struct Bytes filenames = {reballoc(0, 16384, sizeof(char))};
@@ -365,63 +440,42 @@ int main(int argc, char *argv[]) {
       continue;
     if (endswith(arg, ".pkg"))
       continue;
-    if (stat(arg, &st))
-      SysDie(arg, "stat");
-    if (S_ISDIR(st.st_mode))
-      continue;
-    if (!st.st_size)
-      Die(arg, "file is empty");
-    if (st.st_size > 0x7ffff000)
-      Die(arg, "file too large");
-    if ((fd = open(arg, O_RDONLY)) == -1)
-      SysDie(arg, "open");
-    AppendArg(&args, StrDup(arg));
-    AppendInt(&sizes, st.st_size);
-    AppendInt(&modes, st.st_mode);
-    char bnbuf[PATH_MAX + 1];
-    strlcpy(bnbuf, arg, sizeof(bnbuf));
-    char *aname = StrCat(basename(bnbuf), "/");
-    if (strlen(aname) <= sizeof(header1.ar_name)) {
-      AppendArg(&names, aname);
+    if (endswith(arg, ".a")) {
+      struct Ar ar;
+      struct ArFile arf;
+      openar(&ar, arg);
+      while (readar(&ar, &arf)) {
+        AppendArg(&args, StrDup(arg));
+        AppendInt(&sizes, arf.size);
+        AppendInt(&foffsets, arf.offset);
+        AppendName(arf.name, &names, &filenames);
+        AppendSymbols(arg, arf.data, arf.size, &symbols, &symnames, objectid++);
+      }
+      closear(&ar);
     } else {
-      char ibuf[21];
-      FormatUint64(ibuf, filenames.i);
-      AppendArg(&names, StrCat("/", ibuf));
-      AppendBytes(&filenames, aname, strlen(aname));
-      AppendBytes(&filenames, "\n", 1);
+      if (stat(arg, &st))
+        SysDie(arg, "stat");
+      if (S_ISDIR(st.st_mode))
+        continue;
+      if (!st.st_size)
+        Die(arg, "file is empty");
+      if (st.st_size > 0x7ffff000)
+        Die(arg, "file too large");
+      if ((fd = open(arg, O_RDONLY)) == -1)
+        SysDie(arg, "open");
+      AppendArg(&args, StrDup(arg));
+      AppendInt(&sizes, st.st_size);
+      AppendInt(&foffsets, 0);
+      AppendName(arg, &names, &filenames);
+      void *elf = mmap(0, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+      if (elf == MAP_FAILED)
+        SysDie(arg, "mmap");
+      AppendSymbols(arg, elf, st.st_size, &symbols, &symnames, objectid++);
+      if (munmap(elf, st.st_size))
+        SysDie(arg, "munmap");
+      if (close(fd))
+        SysDie(arg, "close");
     }
-    size_t mapsize = st.st_size;
-    void *elf = mmap(0, mapsize, PROT_READ, MAP_PRIVATE, fd, 0);
-    if (elf == MAP_FAILED)
-      SysDie(arg, "mmap");
-    if (!IsElf64Binary(elf, mapsize))
-      Die(arg, "not an elf64 binary");
-    char *strs = GetElfStringTable(elf, mapsize, ".strtab");
-    if (!strs)
-      Die(arg, "elf .strtab not found");
-    Elf64_Xword symcount;
-    Elf64_Shdr *symsec = GetElfSymbolTable(elf, mapsize, SHT_SYMTAB, &symcount);
-    Elf64_Sym *syms = GetElfSectionAddress(elf, mapsize, symsec);
-    if (!syms)
-      Die(arg, "elf symbol table not found");
-    for (Elf64_Xword j = symsec->sh_info; j < symcount; ++j) {
-      if (!syms[j].st_name)
-        continue;
-      if (syms[j].st_shndx == SHN_UNDEF)
-        continue;
-      if (syms[j].st_shndx == SHN_COMMON)
-        continue;
-      const char *symname = GetElfString(elf, mapsize, strs, syms[j].st_name);
-      if (!symname)
-        Die(arg, "elf symbol name corrupted");
-      AppendBytes(&symbols, symname, strlen(symname) + 1);
-      AppendInt(&symnames, objectid);
-    }
-    if (munmap(elf, mapsize))
-      SysDie(arg, "munmap");
-    if (close(fd))
-      SysDie(arg, "close");
-    ++objectid;
   }
   getargs_destroy(&ga);
 
@@ -461,45 +515,37 @@ int main(int argc, char *argv[]) {
   MakeArHeader(&header1, "/", 0, tablebufsize + ROUNDUP(symbols.i, 2));
   MakeArHeader(&header2, "//", 0, ROUNDUP(filenames.i, 2));
   WRITE32BE(tablebuf, symnames.i);
-  for (size_t i = 0; i < symnames.i; ++i) {
+  for (size_t i = 0; i < symnames.i; ++i)
     WRITE32BE(tablebuf + 4 + i * 4, offsets[symnames.p[i]]);
-  }
 
   // write output archive
   int outfd;
-  if ((outfd = creat(outpath, 0644)) == -1) {
+  if ((outfd = creat(outpath, 0644)) == -1)
     SysDie(outpath, "creat");
-  }
-  if (ftruncate(outfd, outsize)) {
+  if (ftruncate(outfd, outsize))
     SysDie(outpath, "ftruncate");
-  }
-  if ((outsize = writev(outfd, iov, ARRAYLEN(iov))) == -1) {
+  if ((outsize = writev(outfd, iov, ARRAYLEN(iov))) == -1)
     SysDie(outpath, "writev[1]");
-  }
   for (size_t i = 0; i < args.i; ++i) {
     const char *inpath = args.p[i];
-    if ((fd = open(inpath, O_RDONLY)) == -1) {
-      SysDie(inpath, "open");
-    }
+    if (!(i && IsEqual(inpath, args.p[i - 1])))
+      if ((fd = open(inpath, O_RDONLY)) == -1)
+        SysDie(inpath, "open");
     iov[0].iov_base = "\n";
     outsize += (iov[0].iov_len = outsize & 1);
     iov[1].iov_base = &header1;
     outsize += (iov[1].iov_len = sizeof(struct ar_hdr));
-    MakeArHeader(&header1, names.p[i], modes.p[i], sizes.p[i]);
-    if (writev(outfd, iov, 2) == -1) {
+    MakeArHeader(&header1, names.p[i], 0100644, sizes.p[i]);
+    if (writev(outfd, iov, 2) == -1)
       SysDie(outpath, "writev[2]");
-    }
     outsize += sizes.p[i];
-    if (CopyFileOrDie(inpath, fd, outpath, outfd) != sizes.p[i]) {
-      Die(inpath, "file size changed");
-    }
-    if (close(fd)) {
-      SysDie(inpath, "close");
-    }
+    CopyFileOrDie(inpath, fd, outpath, outfd, foffsets.p[i], sizes.p[i]);
+    if (!(i + 1 < args.i && IsEqual(inpath, args.p[i + 1])))
+      if (close(fd))
+        SysDie(inpath, "close");
   }
-  if (close(outfd)) {
+  if (close(outfd))
     SysDie(outpath, "close");
-  }
 
   return 0;
 }
diff --git a/tool/build/assimilate.c b/tool/build/assimilate.c
index 8c6d4c1cf..eef749455 100644
--- a/tool/build/assimilate.c
+++ b/tool/build/assimilate.c
@@ -25,8 +25,8 @@
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/limits.h"
-#include "libc/macho.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macho.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/serialize.h"
 #include "libc/stdckdint.h"
@@ -67,8 +67,6 @@
 #define FORMAT_MACHO  2
 #define FORMAT_PE     3
 
-#include "libc/mem/tinymalloc.inc"
-
 static int g_arch;
 static int g_format;
 static bool g_force;
diff --git a/tool/build/bigmul.c b/tool/build/bigmul.c
index b731d9fc7..181f32df4 100644
--- a/tool/build/bigmul.c
+++ b/tool/build/bigmul.c
@@ -19,7 +19,7 @@
 #include "libc/assert.h"
 #include "libc/fmt/conv.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/stdio.h"
@@ -48,8 +48,10 @@ void Multiply%dx%d(uint64_t C[%d], const uint64_t A[%d], const uint64_t B[%d]) {
   uint64_t z,h,l;\n\
   uint64_t ",
          (n + m) * 64, n * 64, m * 64, n + m, n, m, n, m, n + m, n, m);
-  Rs = gc(calloc(sizeof(*Rs), n + m + 1));
-  Ra = gc(calloc(sizeof(*Ra), n + m + 1));
+  if (!(Rs = calloc(sizeof(*Rs), n + m + 1)))
+    __builtin_trap();
+  if (!(Ra = calloc(sizeof(*Ra), n + m + 1)))
+    __builtin_trap();
   for (j = 0; j < n; ++j) {
     if (j)
       printf(", ");
@@ -172,6 +174,8 @@ void Multiply%dx%d(uint64_t C[%d], const uint64_t A[%d], const uint64_t B[%d]) {
   }
   printf("}\n");
   fflush(stdout);
+  free(Ra);
+  free(Rs);
 }
 
 int main(int argc, char *argv[]) {
diff --git a/tool/build/compile.c b/tool/build/compile.c
index 8b2f35e16..2ade1ce7b 100644
--- a/tool/build/compile.c
+++ b/tool/build/compile.c
@@ -32,13 +32,13 @@
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/libgen.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/intrin/x86.h"
 #include "libc/limits.h"
 #include "libc/log/appendresourcereport.internal.h"
 #include "libc/log/color.internal.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/gc.h"
@@ -111,9 +111,9 @@ FLAGS\n\
   -T TARGET    specifies target name for V=0 logging\n\
   -A ACTION    specifies short command name for V=0 logging\n\
   -V NUMBER    specifies compiler version\n\
-  -C SECS      set cpu limit [default 16]\n\
+  -C SECS      set cpu limit [default 32]\n\
   -L SECS      set lat limit [default 90]\n\
-  -P PROCS     set pro limit [default 4096]\n\
+  -P PROCS     set pro limit [default 8192]\n\
   -S BYTES     set stk limit [default 8m]\n\
   -M BYTES     set mem limit [default 2048m]\n\
   -F BYTES     set fsz limit [default 256m]\n\
@@ -229,8 +229,6 @@ const char *const kSafeEnv[] = {
     "TMPDIR",       // needed by compiler
 };
 
-#include "libc/mem/tinymalloc.inc"
-
 void OnAlrm(int sig) {
   ++gotalrm;
 }
@@ -516,7 +514,11 @@ void AddArg(char *actual) {
 }
 
 static int GetBaseCpuFreqMhz(void) {
+#ifdef __x86_64__
   return KCPUIDS(16H, EAX) & 0x7fff;
+#else
+  return 0;
+#endif
 }
 
 void PlanResource(int resource, struct rlimit rlim) {
@@ -525,7 +527,7 @@ void PlanResource(int resource, struct rlimit rlim) {
     return;
   rlim.rlim_cur = MIN(rlim.rlim_cur, prior.rlim_max);
   rlim.rlim_max = MIN(rlim.rlim_max, prior.rlim_max);
-  posix_spawnattr_setrlimit(&spawnattr, resource, &rlim);
+  posix_spawnattr_setrlimit_np(&spawnattr, resource, &rlim);
 }
 
 void SetCpuLimit(int secs) {
@@ -647,7 +649,7 @@ int Launch(void) {
   posix_spawnattr_init(&spawnattr);
   posix_spawnattr_setsigmask(&spawnattr, &savemask);
   posix_spawnattr_setflags(&spawnattr,
-                           POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETRLIMIT);
+                           POSIX_SPAWN_SETSIGMASK | POSIX_SPAWN_SETRLIMIT_NP);
   SetCpuLimit(cpuquota);
   SetFszLimit(fszquota);
   SetMemLimit(memquota);
@@ -796,7 +798,11 @@ bool MovePreservingDestinationInode(const char *from, const char *to) {
     rc = copy_file_range(fdin, 0, fdout, 0, remain, 0);
     if (rc != -1) {
       remain -= rc;
-    } else if (errno == EXDEV || errno == ENOSYS) {
+    } else if (errno == EXDEV ||    // different partitions
+               errno == EINVAL ||   // possible w/ ecryptfs
+               errno == ENOSYS ||   // not linux or freebsd
+               errno == ENOTSUP ||  // no fs support for it
+               errno == EOPNOTSUPP) {
       if (lseek(fdin, 0, SEEK_SET) == -1) {
         res = false;
         break;
@@ -858,7 +864,7 @@ int main(int argc, char *argv[]) {
   verbose = 4;
   timeout = 90;                    // secs
   cpuquota = 32;                   // secs
-  proquota = 4096;                 // procs
+  proquota = 8192;                 // procs
   stkquota = 8 * 1024 * 1024;      // bytes
   fszquota = 256 * 1000 * 1000;    // bytes
   memquota = 2048L * 1024 * 1024;  // bytes
diff --git a/tool/build/cp.c b/tool/build/cp.c
index afd8e84cc..5aed44442 100644
--- a/tool/build/cp.c
+++ b/tool/build/cp.c
@@ -69,8 +69,6 @@ char linkbuf[PATH_MAX];
 
 void Cp(char *, char *);
 
-#include "libc/mem/tinymalloc.inc"
-
 bool IsDirectory(const char *path) {
   int e;
   bool res;
diff --git a/tool/build/dd.c b/tool/build/dd.c
index 77c7d6e26..5c5ce461b 100644
--- a/tool/build/dd.c
+++ b/tool/build/dd.c
@@ -19,6 +19,8 @@
 #include "libc/calls/calls.h"
 #include "libc/fmt/conv.h"
 #include "libc/limits.h"
+#include "libc/mem/gc.h"
+#include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
@@ -44,8 +46,8 @@ int main(int argc, char *argv[]) {
   long count = LONG_MAX;
   long blocksize = 1;
   int oflags = O_WRONLY | O_TRUNC | O_CREAT;
-  const char *infile = "/dev/stdin";
-  const char *oufile = "/dev/stdout";
+  char *infile = gc(strdup("/dev/stdin"));
+  char *oufile = gc(strdup("/dev/stdout"));
 
   prog = argv[0];
   if (!prog)
diff --git a/tool/build/dlopen_test.c b/tool/build/dlopen_tester.c
similarity index 100%
rename from tool/build/dlopen_test.c
rename to tool/build/dlopen_tester.c
diff --git a/tool/build/dso/sandbox.c b/tool/build/dso/sandbox.c
index ee7ccc12b..01569dc46 100644
--- a/tool/build/dso/sandbox.c
+++ b/tool/build/dso/sandbox.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/pledge.h"
 #include "libc/calls/pledge.internal.h"
-#include "libc/intrin/promises.internal.h"
+#include "libc/intrin/promises.h"
 #include "libc/runtime/runtime.h"
 
 // runs pledge at glibc executable load time, e.g.
diff --git a/tool/build/elf2pe.c b/tool/build/elf2pe.c
index 9403b0bef..c015132d2 100644
--- a/tool/build/elf2pe.c
+++ b/tool/build/elf2pe.c
@@ -25,10 +25,11 @@
 #include "libc/elf/struct/shdr.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/intrin/dll.h"
+#include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/pedef.internal.h"
 #include "libc/nt/struct/imagedatadirectory.internal.h"
@@ -158,8 +159,6 @@ static const char *stubpath;
 static long FLAG_SizeOfStackCommit = 64 * 1024;
 static long FLAG_SizeOfStackReserve = 8 * 1024 * 1024;
 
-#include "libc/mem/tinymalloc.inc"
-
 static wontreturn void Die(const char *thing, const char *reason) {
   tinyprint(2, thing, ": ", reason, "\n", NULL);
   exit(1);
@@ -186,6 +185,13 @@ static void *Calloc(size_t n) {
   return p;
 }
 
+static void *Memalign(size_t a, size_t n) {
+  void *p;
+  if (!(p = memalign(a, n)))
+    DieOom();
+  return p;
+}
+
 static void *Realloc(void *p, size_t n) {
   if (!(p = realloc(p, n)))
     DieOom();
@@ -220,6 +226,17 @@ static struct Segment *NewSegment(void) {
   return s;
 }
 
+static int ConvertElfMachineToPe(struct Elf *elf) {
+  switch (elf->ehdr->e_machine) {
+    case EM_NEXGEN32E:
+      return kNtImageFileMachineNexgen32e;
+    case EM_AARCH64:
+      return kNtImageFileMachineArm64;
+    default:
+      Die(elf->path, "unsupported e_machine");
+  }
+}
+
 static Elf64_Addr RelocateVaddrWithinSegment(struct Elf *elf,
                                              Elf64_Addr vaddr_old,
                                              struct Segment *segment) {
@@ -802,7 +819,17 @@ static uint32_t GetPeSectionCharacteristics(struct Segment *s) {
 // originally in the elf image that ld linked. in order for this to work
 // the executable needs to be linked in `ld -q` mode, since it'll retain
 // the .rela sections we'll need later to fixup the binary.
-static struct ImagePointer GeneratePe(struct Elf *elf, char *fp, int64_t vp) {
+static struct ImagePointer GeneratePe(struct Elf *elf, char *fp) {
+
+  int64_t vp = 0;
+  Elf64_Phdr *phdr;
+  for (int i = 0; i < elf->ehdr->e_phnum; ++i) {
+    if ((phdr = GetElfProgramHeaderAddress(elf->ehdr, elf->size, i)) &&
+        phdr->p_type == PT_LOAD) {
+      vp = phdr->p_vaddr;
+      break;
+    }
+  }
 
   Elf64_Sym *entry;
   if (!(entry = FindGlobal(elf, "__win32_start")) &&
@@ -846,7 +873,7 @@ static struct ImagePointer GeneratePe(struct Elf *elf, char *fp, int64_t vp) {
   struct NtImageFileHeader *filehdr;
   filehdr = (struct NtImageFileHeader *)fp;
   fp += sizeof(struct NtImageFileHeader);
-  filehdr->Machine = kNtImageFileMachineNexgen32e;
+  filehdr->Machine = ConvertElfMachineToPe(elf);
   filehdr->TimeDateStamp = 1690072024;
   filehdr->Characteristics =
       kNtPeFileExecutableImage | kNtImageFileLargeAddressAware |
@@ -864,7 +891,9 @@ static struct ImagePointer GeneratePe(struct Elf *elf, char *fp, int64_t vp) {
   opthdr->FileAlignment = 512;
   opthdr->SectionAlignment = MAX(4096, elf->align);
   opthdr->MajorOperatingSystemVersion = 6;
+  opthdr->MinorOperatingSystemVersion = 2;
   opthdr->MajorSubsystemVersion = 6;
+  opthdr->MinorSubsystemVersion = 2;
   opthdr->Subsystem = kNtImageSubsystemWindowsCui;
   opthdr->DllCharacteristics = kNtImageDllcharacteristicsNxCompat |
                                kNtImageDllcharacteristicsHighEntropyVa;
@@ -1106,8 +1135,8 @@ int main(int argc, char *argv[]) {
   GetOpts(argc, argv);
   // translate executable
   struct Elf *elf = OpenElf(argv[optind]);
-  char *buf = memalign(MAX_ALIGN, 134217728);
-  struct ImagePointer ip = GeneratePe(elf, buf, 0x00400000);
+  char *buf = Memalign(MAX_ALIGN, 134217728);
+  struct ImagePointer ip = GeneratePe(elf, buf);
   if (creat(outpath, 0755) == -1)
     DieSys(elf->path);
   Pwrite(3, buf, ip.fp - buf, 0);
diff --git a/tool/build/elf2pe.h b/tool/build/elf2pe.h
index 53312b1a2..49cb8e71e 100644
--- a/tool/build/elf2pe.h
+++ b/tool/build/elf2pe.h
@@ -1,8 +1,8 @@
 #ifndef COSMOPOLITAN_TOOL_BUILD_ELF2PE_H_
 #define COSMOPOLITAN_TOOL_BUILD_ELF2PE_H_
 
-#define __dll_import(DLL, RET, FUNC, ARGS)                      \
-  extern RET(*const __attribute__((__ms_abi__, __weak__)) FUNC) \
+#define __dll_import(DLL, RET, FUNC, ARGS)                  \
+  extern RET(*const __msabi __attribute__((__weak__)) FUNC) \
       ARGS __asm__("\"dll$" DLL "$" #FUNC "\"")
 
 #endif /* COSMOPOLITAN_TOOL_BUILD_ELF2PE_H_ */
diff --git a/tool/build/fixupobj.c b/tool/build/fixupobj.c
index 570cd3e4c..dfda7e877 100644
--- a/tool/build/fixupobj.c
+++ b/tool/build/fixupobj.c
@@ -31,12 +31,12 @@
 #include "libc/fmt/magnumstrs.internal.h"
 #include "libc/limits.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/serialize.h"
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #include "libc/stdckdint.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
@@ -44,7 +44,7 @@
 #include "libc/sysv/consts/msync.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "third_party/getopt/getopt.internal.h"
 
 /**
@@ -67,8 +67,6 @@ static Elf64_Ehdr *elf;
 static const char *epath;
 static Elf64_Xword symcount;
 
-#include "libc/mem/tinymalloc.inc"
-
 static wontreturn void Die(const char *reason) {
   tinyprint(2, epath, ": ", reason, "\n", NULL);
   exit(1);
@@ -245,7 +243,7 @@ static void CheckPrivilegedCrossReferences(void) {
       if (~shdr->sh_flags & SHF_EXECINSTR)
         continue;  // data reference
       if ((secname = GetElfString(elf, esize, secstrs, shdr->sh_name)) &&
-          strcmp(".privileged", secname)) {
+          !startswith(secname, ".privileged")) {
         tinyprint(2, epath,
                   ": code in .privileged section "
                   "references symbol '",
diff --git a/tool/build/freebsd2sysv.c b/tool/build/freebsd2sysv.c
index a0086c28d..c1e79528d 100644
--- a/tool/build/freebsd2sysv.c
+++ b/tool/build/freebsd2sysv.c
@@ -25,7 +25,7 @@
 #include "libc/sysv/consts/prot.h"
 
 int main(int argc, char *argv[]) {
-  open(argv[1], O_RDWR);
-  Elf64_Ehdr *e = mmap(0, 64, PROT_READ | PROT_WRITE, MAP_SHARED, 3, 0);
+  int fd = open(argv[1], O_RDWR);
+  Elf64_Ehdr *e = mmap(0, 64, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
   e->e_ident[EI_OSABI] = ELFOSABI_SYSV;
 }
diff --git a/tool/build/gzip.c b/tool/build/gzip.c
index c26d65a73..c2c436cac 100644
--- a/tool/build/gzip.c
+++ b/tool/build/gzip.c
@@ -71,8 +71,6 @@ const char *prog;
 char databuf[32768];
 char pathbuf[PATH_MAX];
 
-#include "libc/mem/tinymalloc.inc"
-
 wontreturn void PrintUsage(int rc, FILE *f) {
   fputs("usage: ", f);
   fputs(prog, f);
@@ -139,6 +137,7 @@ void Compress(const char *inpath) {
   FILE *input;
   gzFile output;
   int rc, errnum;
+  FILE *closeme = 0;
   const char *outpath;
   char *p, openflags[5];
   if ((!inpath || opt_usestdout) && (!isatty(1) || opt_force)) {
@@ -151,7 +150,7 @@ void Compress(const char *inpath) {
     exit(1);
   }
   if (inpath) {
-    input = fopen(inpath, "rb");
+    input = closeme = fopen(inpath, "rb");
   } else {
     inpath = "/dev/stdin";
     input = stdin;
@@ -178,8 +177,9 @@ void Compress(const char *inpath) {
   }
   if (!output) {
     fputs(outpath, stderr);
-    fputs(": gzopen() failed\n", stderr);
-    fputs(_strerdoc(errno), stderr);
+    fputs(": gzopen() failed: ", stderr);
+    const char *s = _strerdoc(errno);
+    fputs(s ? s : "EUNKNOWN", stderr);
     fputs("\n", stderr);
     exit(1);
   }
@@ -189,7 +189,8 @@ void Compress(const char *inpath) {
       errnum = 0;
       fputs(inpath, stderr);
       fputs(": read failed: ", stderr);
-      fputs(_strerdoc(ferror(input)), stderr);
+      const char *s = _strerdoc(ferror(input));
+      fputs(s ? s : "EUNKNOWN", stderr);
       fputs("\n", stderr);
       _Exit(1);
     }
@@ -201,8 +202,8 @@ void Compress(const char *inpath) {
       _Exit(1);
     }
   } while (rc == sizeof(databuf));
-  if (input != stdin) {
-    if (fclose(input)) {
+  if (closeme) {
+    if (fclose(closeme)) {
       fputs(inpath, stderr);
       fputs(": close failed\n", stderr);
       _Exit(1);
@@ -221,6 +222,7 @@ void Compress(const char *inpath) {
 void Decompress(const char *inpath) {
   FILE *output;
   gzFile input;
+  FILE *closeme = 0;
   int rc, n, errnum;
   const char *outpath;
   outpath = 0;
@@ -233,8 +235,9 @@ void Decompress(const char *inpath) {
   }
   if (!input) {
     fputs(inpath, stderr);
-    fputs(": gzopen() failed\n", stderr);
-    fputs(_strerdoc(errno), stderr);
+    fputs(": gzopen() failed: ", stderr);
+    const char *s = _strerdoc(errno);
+    fputs(s ? s : "EUNKNOWN", stderr);
     fputs("\n", stderr);
     exit(1);
   }
@@ -248,10 +251,11 @@ void Decompress(const char *inpath) {
     memcpy(pathbuf, inpath, n - 3);
     pathbuf[n - 3] = 0;
     outpath = pathbuf;
-    if (!(output = fopen(outpath, opt_append ? "wa" : "wb"))) {
+    if (!(output = closeme = fopen(outpath, opt_append ? "wa" : "wb"))) {
       fputs(outpath, stderr);
       fputs(": open failed: ", stderr);
-      fputs(_strerdoc(errno), stderr);
+      const char *s = _strerdoc(errno);
+      fputs(s ? s : "EUNKNOWN", stderr);
       fputs("\n", stderr);
       _Exit(1);
     }
@@ -273,7 +277,8 @@ void Decompress(const char *inpath) {
     if (fwrite(databuf, rc, 1, output) != 1) {
       fputs(outpath, stderr);
       fputs(": write failed: ", stderr);
-      fputs(_strerdoc(ferror(output)), stderr);
+      const char *s = _strerdoc(ferror(output));
+      fputs(s ? s : "EUNKNOWN", stderr);
       fputs("\n", stderr);
       _Exit(1);
     }
@@ -283,8 +288,8 @@ void Decompress(const char *inpath) {
     fputs(": gzclose failed\n", stderr);
     _Exit(1);
   }
-  if (output != stdout) {
-    if (fclose(output)) {
+  if (closeme) {
+    if (fclose(closeme)) {
       fputs(outpath, stderr);
       fputs(": close failed\n", stderr);
       _Exit(1);
diff --git a/tool/build/helpop.c b/tool/build/helpop.c
index 399372a0f..e5e0297c3 100644
--- a/tool/build/helpop.c
+++ b/tool/build/helpop.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
diff --git a/tool/build/killall.c b/tool/build/killall.c
index 7a250983b..c37102a48 100644
--- a/tool/build/killall.c
+++ b/tool/build/killall.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/dce.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/enum/formatmessageflags.h"
 #include "libc/nt/enum/lang.h"
@@ -30,6 +30,7 @@
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sig.h"
+#include "libc/wctype.h"
 #include "libc/x/x.h"
 #include "third_party/getopt/getopt.internal.h"
 
@@ -50,8 +51,6 @@ static const char *prog;
 static char16_t **filters;
 static uint32_t pids[10000];
 
-#include "libc/mem/tinymalloc.inc"
-
 static wontreturn void PrintUsage(int rc, FILE *f) {
   fprintf(f,
           "Usage: %s [-nshv] NAME...\n"
diff --git a/tool/build/lib/ar.c b/tool/build/lib/ar.c
new file mode 100644
index 000000000..5e09dd15c
--- /dev/null
+++ b/tool/build/lib/ar.c
@@ -0,0 +1,166 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "tool/build/lib/ar.h"
+#include "libc/ar.h"
+#include "libc/calls/calls.h"
+#include "libc/calls/struct/stat.h"
+#include "libc/ctype.h"
+#include "libc/fmt/conv.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/prot.h"
+
+/**
+ * @fileoverview static archive reader
+ *
+ * This file implements an API similar to opendir() for raeding the .o
+ * files within your .a file. This works by mapping the .a file into
+ * memory and then yielding pointers into the map where embedded files
+ * reside, along with their decoded filenames.
+ *
+ * To try this library:
+ *
+ *     make -j o//tool/decode/ar2 o//libc/str/str.a
+ *     o//tool/decode/ar2 o//libc/str/str.a
+ *
+ * This implementation currently dies on error. The intent is to make
+ * this as simple of an abstraction as possible for simple command line
+ * utilities like o//tool/build/ar. It shouldn't be considered a serious
+ * general purpose library. Another thing it can't do is decode symbol
+ * table information, since Cosmopolitan Ar currently doesn't need it.
+ */
+
+void openar(struct Ar *ar, const char *path) {
+  memset(ar, 0, sizeof(*ar));
+  ar->path = path;
+  if ((ar->fd = open(path, O_RDONLY)) == -1) {
+    perror(ar->path);
+    exit(1);
+  }
+  if (fstat(ar->fd, &ar->st)) {
+    perror(ar->path);
+    exit(1);
+  }
+  ar->map = mmap(0, ar->st.st_size, PROT_READ, MAP_PRIVATE, ar->fd, 0);
+  if (ar->map == MAP_FAILED) {
+    perror(ar->path);
+    exit(1);
+  }
+  if (!startswith(ar->map, ARMAG)) {
+    tinyprint(2, ar->path, ": not an ar file\n", NULL);
+    exit(1);
+  }
+  ar->offset = SARMAG;
+}
+
+void closear(struct Ar *ar) {
+  if (munmap(ar->map, ar->st.st_size)) {
+    perror(ar->path);
+    exit(1);
+  }
+  if (close(ar->fd)) {
+    perror(ar->path);
+    exit(1);
+  }
+}
+
+bool readar(struct Ar *ar, struct ArFile *arf) {
+  for (;;) {
+    ar->offset += 1;
+    ar->offset &= -2;
+    if (ar->offset + sizeof(struct ar_hdr) > ar->st.st_size)
+      return false;
+
+    struct ar_hdr *hdr = (struct ar_hdr *)(ar->map + ar->offset);
+    ar->offset += sizeof(struct ar_hdr);
+
+    char ar_fmag[sizeof(hdr->ar_fmag) + 1] = {0};
+    memcpy(ar_fmag, hdr->ar_fmag, sizeof(hdr->ar_fmag));
+    if (strcmp(ar_fmag, ARFMAG)) {
+      tinyprint(2, ar->path, ": corrupt ar file fmag\n", NULL);
+      exit(1);
+    }
+
+    char ar_name[sizeof(hdr->ar_name) + 1] = {0};
+    memcpy(ar_name, hdr->ar_name, sizeof(hdr->ar_name));
+    for (int j = sizeof(hdr->ar_name) - 1 + 1; j-- && isspace(ar_name[j]);)
+      ar_name[j] = '\0';
+
+    char ar_size[sizeof(hdr->ar_size) + 1] = {0};
+    memcpy(ar_size, hdr->ar_size, sizeof(hdr->ar_size));
+    int size = atoi(ar_size);
+    if (size < 0 || ar->offset + size > ar->st.st_size) {
+      tinyprint(2, ar->path, ": ar size overlaps eof\n", NULL);
+      exit(1);
+    }
+
+    // symbol table
+    if (!strcmp(ar_name, "/")) {
+      ar->offset += size;
+      continue;
+    }
+
+    // filename table
+    if (!strcmp(ar_name, "//")) {
+      ar->filenames = ar->map + ar->offset;
+      ar->filenames_size = size;
+      ar->offset += size;
+      continue;
+    }
+
+    // get name of object file
+    size_t len;
+    const char *e;
+    if (ar_name[0] == '/') {
+      int off = atoi(ar_name + 1);
+      if (off < 0 || off >= ar->filenames_size) {
+        tinyprint(2, ar->path, ": ar filename not found\n", NULL);
+        exit(1);
+      }
+      if (!(e = memchr(ar->filenames + off, '\n', ar->filenames_size - off))) {
+        tinyprint(2, ar->path, ": ar filename overlaps end\n", NULL);
+        exit(1);
+      }
+      if ((len = e - (ar->filenames + off)) >= PATH_MAX) {
+        tinyprint(2, ar->path, ": ar filename too long\n", NULL);
+        exit(1);
+      }
+      memcpy(arf->name, ar->filenames + off, len);
+      arf->name[len] = '\0';
+      if (len && arf->name[len - 1] == '/')
+        arf->name[--len] = '\0';
+    } else if ((len = strlen(ar_name)) && ar_name[len - 1] == '/') {
+      memcpy(arf->name, ar_name, len - 1);
+      arf->name[len - 1] = '\0';
+    } else {
+      tinyprint(2, ar->path, ": unsupported ar name: ", ar_name, "\n", NULL);
+      exit(1);
+    }
+
+    // return pointer to embedded file
+    arf->size = size;
+    arf->offset = ar->offset;
+    arf->data = ar->map + ar->offset;
+    ar->offset += size;
+    return true;
+  }
+}
diff --git a/tool/build/lib/ar.h b/tool/build/lib/ar.h
new file mode 100644
index 000000000..350ec27a3
--- /dev/null
+++ b/tool/build/lib/ar.h
@@ -0,0 +1,29 @@
+#ifndef COSMOPOLITAN_TOOL_BUILD_LIB_AR_H_
+#define COSMOPOLITAN_TOOL_BUILD_LIB_AR_H_
+#include "libc/calls/struct/stat.h"
+#include "libc/limits.h"
+COSMOPOLITAN_C_START_
+
+struct Ar {
+  const char *path;
+  int fd;
+  struct stat st;
+  char *map;
+  size_t offset;
+  const char *filenames;
+  size_t filenames_size;
+};
+
+struct ArFile {
+  void *data;
+  size_t size;
+  size_t offset;
+  char name[PATH_MAX];
+};
+
+void openar(struct Ar *, const char *);
+void closear(struct Ar *);
+bool readar(struct Ar *, struct ArFile *);
+
+COSMOPOLITAN_C_END_
+#endif /* COSMOPOLITAN_TOOL_BUILD_LIB_AR_H_ */
diff --git a/tool/build/lib/buffer.c b/tool/build/lib/buffer.c
index 037047f66..5fe539a56 100644
--- a/tool/build/lib/buffer.c
+++ b/tool/build/lib/buffer.c
@@ -19,7 +19,7 @@
 #include "tool/build/lib/buffer.h"
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/arraylist2.internal.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/stdio.h"
diff --git a/tool/build/lib/demangle.c b/tool/build/lib/demangle.c
index a2d11cd14..d2260fe3e 100644
--- a/tool/build/lib/demangle.c
+++ b/tool/build/lib/demangle.c
@@ -20,7 +20,7 @@
 #include "libc/assert.h"
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/iovec.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/o.h"
diff --git a/tool/build/lib/elfwriter.c b/tool/build/lib/elfwriter.c
index 0008815a7..32572c773 100644
--- a/tool/build/lib/elfwriter.c
+++ b/tool/build/lib/elfwriter.c
@@ -26,7 +26,7 @@
 #include "libc/mem/mem.h"
 #include "libc/runtime/memtrack.internal.h"
 #include "libc/runtime/runtime.h"
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/msync.h"
@@ -163,7 +163,7 @@ struct ElfWriter *elfwriter_open(const char *path, int mode, int arch) {
   CHECK_NOTNULL((elf = calloc(1, sizeof(struct ElfWriter))));
   CHECK_NOTNULL((elf->path = strdup(path)));
   CHECK_NE(-1, (elf->fd = open(elf->path, O_CREAT | O_TRUNC | O_RDWR, mode)));
-  CHECK_NE(-1, ftruncate(elf->fd, (elf->mapsize = __granularity())));
+  CHECK_NE(-1, ftruncate(elf->fd, (elf->mapsize = getgransize())));
   CHECK_NE(MAP_FAILED, (elf->map = mmap((void *)(intptr_t)kFixedmapStart,
                                         elf->mapsize, PROT_READ | PROT_WRITE,
                                         MAP_SHARED | MAP_FIXED, elf->fd, 0)));
@@ -234,7 +234,7 @@ void *elfwriter_reserve(struct ElfWriter *elf, size_t size) {
     do {
       greed = greed + (greed >> 1);
     } while (need > greed);
-    greed = ROUNDUP(greed, __granularity());
+    greed = ROUNDUP(greed, getgransize());
     CHECK_NE(-1, ftruncate(elf->fd, greed));
     CHECK_NE(MAP_FAILED, mmap((char *)elf->map + elf->mapsize,
                               greed - elf->mapsize, PROT_READ | PROT_WRITE,
diff --git a/tool/build/lib/elfwriter_zip.c b/tool/build/lib/elfwriter_zip.c
index dbe1562d1..886778038 100644
--- a/tool/build/lib/elfwriter_zip.c
+++ b/tool/build/lib/elfwriter_zip.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/dos.internal.h"
+#include "libc/dos.h"
 #include "libc/elf/def.h"
 #include "libc/fmt/wintime.internal.h"
 #include "libc/limits.h"
@@ -33,7 +33,7 @@
 #include "libc/time.h"
 #include "libc/x/x.h"
 #include "libc/x/xasprintf.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "net/http/http.h"
 #include "third_party/zlib/zlib.h"
 #include "tool/build/lib/elfwriter.h"
@@ -63,6 +63,13 @@ static int DetermineVersionNeededToExtract(int method) {
   }
 }
 
+static int NormalizeMode(int mode) {
+  int res = mode & S_IFMT;
+  if (mode & 0111)
+    res |= 0111;
+  return res | 0644;
+}
+
 static unsigned char *EmitZipLfileHdr(unsigned char *p, const void *name,
                                       size_t namesize, uint32_t crc,
                                       uint8_t era, uint16_t gflags,
@@ -87,10 +94,10 @@ static unsigned char *EmitZipLfileHdr(unsigned char *p, const void *name,
 static void EmitZipCdirHdr(unsigned char *p, const void *name, size_t namesize,
                            uint32_t crc, uint8_t era, uint16_t gflags,
                            uint16_t method, uint16_t mtime, uint16_t mdate,
-                           uint16_t iattrs, uint16_t dosmode, uint16_t unixmode,
-                           size_t compsize, size_t uncompsize,
-                           size_t commentsize, struct timespec mtim,
-                           struct timespec atim, struct timespec ctim) {
+                           uint16_t iattrs, uint16_t unixmode, size_t compsize,
+                           size_t uncompsize, size_t commentsize,
+                           struct timespec mtim, struct timespec atim,
+                           struct timespec ctim) {
   uint64_t mt, at, ct;
   p = WRITE32LE(p, kZipCfileHdrMagic);
   *p++ = kZipCosmopolitanVersion;
@@ -111,8 +118,8 @@ static void EmitZipCdirHdr(unsigned char *p, const void *name, size_t namesize,
   p = WRITE16LE(p, commentsize);
   p = WRITE16LE(p, 0); /* disk */
   p = WRITE16LE(p, iattrs);
-  p = WRITE16LE(p, dosmode);
-  p = WRITE16LE(p, unixmode);
+  p = WRITE16LE(p, 0);
+  p = WRITE16LE(p, NormalizeMode(unixmode));
   p = WRITE32LE(p, 0); /* RELOCATE ME (kZipCfileOffsetOffset) */
   /* 46 */
   memcpy(p, name, namesize);
@@ -142,8 +149,8 @@ void elfwriter_zip(struct ElfWriter *elf, const char *symbol, const char *cname,
   uint32_t crc;
   unsigned char *lfile, *cfile;
   struct ElfWriterSymRef lfilesym;
+  uint16_t method, gflags, mtime, mdate, iattrs;
   size_t lfilehdrsize, uncompsize, compsize, commentsize;
-  uint16_t method, gflags, mtime, mdate, iattrs, dosmode;
 
   CHECK_NE(0, mtim.tv_sec);
 
@@ -168,7 +175,6 @@ void elfwriter_zip(struct ElfWriter *elf, const char *symbol, const char *cname,
   if (S_ISREG(mode) && istext(data, size)) {
     iattrs |= kZipIattrText;
   }
-  dosmode = !(mode & 0200) ? kNtFileAttributeReadonly : 0;
   method = ShouldCompress(name, namesize, data, size, nocompress)
                ? kZipCompressionDeflate
                : kZipCompressionNone;
@@ -215,8 +221,8 @@ void elfwriter_zip(struct ElfWriter *elf, const char *symbol, const char *cname,
   elfwriter_startsection(elf, ".zip.cdir", SHT_PROGBITS, 0);
   EmitZipCdirHdr(
       (cfile = elfwriter_reserve(elf, ZIP_CFILE_HDR_SIZE + namesize)), name,
-      namesize, crc, era, gflags, method, mtime, mdate, iattrs, dosmode, mode,
-      compsize, uncompsize, commentsize, mtim, atim, ctim);
+      namesize, crc, era, gflags, method, mtime, mdate, iattrs, mode, compsize,
+      uncompsize, commentsize, mtim, atim, ctim);
   elfwriter_appendsym(elf, gc(xasprintf("%s%s", "zip+cdir:", name)),
                       ELF64_ST_INFO(STB_LOCAL, STT_OBJECT), STV_DEFAULT, 0,
                       ZIP_CFILE_HDR_SIZE + namesize);
diff --git a/tool/build/lib/eztls.c b/tool/build/lib/eztls.c
index 5ae728387..0e5de53ef 100644
--- a/tool/build/lib/eztls.c
+++ b/tool/build/lib/eztls.c
@@ -23,8 +23,8 @@
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/strace.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/strace.h"
+#include "libc/macros.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/thread/thread.h"
 #include "libc/x/x.h"
diff --git a/tool/build/lib/getargs.c b/tool/build/lib/getargs.c
index 3e31da96b..faf5fe68d 100644
--- a/tool/build/lib/getargs.c
+++ b/tool/build/lib/getargs.c
@@ -21,7 +21,7 @@
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/sysconf.h"
 #include "libc/stdio/stdio.h"
diff --git a/tool/build/lib/interner.c b/tool/build/lib/interner.c
index a287b1132..a491de30c 100644
--- a/tool/build/lib/interner.c
+++ b/tool/build/lib/interner.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "tool/build/lib/interner.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/crc32.h"
 #include "libc/runtime/runtime.h"
diff --git a/tool/build/lib/javadown.c b/tool/build/lib/javadown.c
index 476da98ca..313d95d0e 100644
--- a/tool/build/lib/javadown.c
+++ b/tool/build/lib/javadown.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "tool/build/lib/javadown.h"
+#include "libc/ctype.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 
diff --git a/tool/build/lib/panel.c b/tool/build/lib/panel.c
index 976d49aa5..072836bef 100644
--- a/tool/build/lib/panel.c
+++ b/tool/build/lib/panel.c
@@ -19,7 +19,7 @@
 #include "tool/build/lib/panel.h"
 #include "libc/fmt/conv.h"
 #include "libc/intrin/bsr.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "libc/str/unicode.h"
diff --git a/tool/build/lz4toasm.c b/tool/build/lz4toasm.c
index b13a16926..b7a8943aa 100644
--- a/tool/build/lz4toasm.c
+++ b/tool/build/lz4toasm.c
@@ -21,7 +21,7 @@
 #include "libc/fmt/conv.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/kompressor.h"
@@ -29,7 +29,7 @@
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/x/x.h"
 #include "third_party/getopt/getopt.internal.h"
 
@@ -108,7 +108,7 @@ int main(int argc, char *argv[]) {
 
   fprintf(fout,
           "/\t%s -o %s -s %s %s\n"
-          "#include \"libc/macros.internal.h\"\n"
+          "#include \"libc/macros.h\"\n"
           "\n",
           argv[0], outpath, symbol, lz4path);
 
diff --git a/tool/build/mkdeps.c b/tool/build/mkdeps.c
index baa6ba843..982615f05 100644
--- a/tool/build/mkdeps.c
+++ b/tool/build/mkdeps.c
@@ -22,10 +22,10 @@
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/libgen.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/kprintf.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
+#include "libc/mem/leaks.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/crc32.h"
 #include "libc/runtime/runtime.h"
@@ -33,7 +33,7 @@
 #include "libc/stdio/append.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
@@ -146,8 +146,6 @@ static const char *buildroot;
 static const char *genroot;
 static const char *outpath;
 
-#include "libc/mem/tinymalloc.inc"
-
 static inline bool IsBlank(int c) {
   return c == ' ' || c == '\t';
 }
@@ -345,9 +343,8 @@ static const char *FindIncludePath(const char *map, size_t mapsize,
 
   // scan backwards for hash character
   for (;;) {
-    if (q == map) {
+    if (q == map)
       return 0;
-    }
     if (IsBlank(q[-1])) {
       --q;
       continue;
@@ -414,17 +411,15 @@ static void LoadRelationships(int argc, char *argv[]) {
   static char srcdirbuf[PATH_MAX];
   const char *p, *pe, *src, *path, *pathend, *srcdir, *final;
   getargs_init(&ga, argv + optind);
-  while ((src = getargs_next(&ga))) {
+  while ((src = getargs_next(&ga)))
     CreateSourceId(src);
-  }
   getargs_destroy(&ga);
   getargs_init(&ga, argv + optind);
   while ((src = getargs_next(&ga))) {
     is_assembly = endswith(src, ".s");
     srcid = GetSourceId(src);
-    if (strlcpy(srcdirbuf, src, PATH_MAX) >= PATH_MAX) {
+    if (strlcpy(srcdirbuf, src, PATH_MAX) >= PATH_MAX)
       DiePathTooLong(src);
-    }
     srcdir = dirname(srcdirbuf);
     if ((fd = open(src, O_RDONLY)) == -1) {
       if (errno == ENOENT && ga.path) {
@@ -438,17 +433,14 @@ static void LoadRelationships(int argc, char *argv[]) {
       }
       DieSys(src);
     }
-    if ((rc = lseek(fd, 0, SEEK_END)) == -1) {
+    if ((rc = lseek(fd, 0, SEEK_END)) == -1)
       DieSys(src);
-    }
     if ((size = rc)) {
       // repeatedly map to same fixed address so in order to weasel out
       // of incurring the additional overhead of all these munmap calls
-      map = mmap((void *)0x311987030000, size, PROT_READ,
-                 MAP_SHARED | MAP_FIXED, fd, 0);
-      if (map == MAP_FAILED) {
+      map = mmap(0, size, PROT_READ, MAP_SHARED, fd, 0);
+      if (map == MAP_FAILED)
         DieSys(src);
-      }
       for (p = map, pe = map + size; p < pe; ++p) {
         if (!(p = memmem(p, pe - p, "include ", 8)))
           break;
@@ -477,12 +469,10 @@ static void LoadRelationships(int argc, char *argv[]) {
           dependency = -1;
           for (long i = 0; i < systempaths.n; ++i) {
             if (!(final =
-                      __join_paths(juf, PATH_MAX, systempaths.p[i], incpath))) {
+                      __join_paths(juf, PATH_MAX, systempaths.p[i], incpath)))
               DiePathTooLong(incpath);
-            }
-            if ((dependency = GetSourceId(final)) != -1) {
+            if ((dependency = GetSourceId(final)) != -1)
               break;
-            }
           }
           if (dependency != -1) {
             AppendEdge(&edges, dependency, srcid);
@@ -506,9 +496,8 @@ static void LoadRelationships(int argc, char *argv[]) {
           dependency = GetSourceId((final = incpath));
           // let foo/bar.c say `#include "hdr.h"`
           if (dependency == -1 && !strchr(final, '/')) {
-            if (!(final = __join_paths(juf, PATH_MAX, srcdir, final))) {
+            if (!(final = __join_paths(juf, PATH_MAX, srcdir, final)))
               DiePathTooLong(incpath);
-            }
             dependency = GetSourceId(final);
           }
           if (dependency == -1) {
@@ -526,10 +515,11 @@ static void LoadRelationships(int argc, char *argv[]) {
           p = pathend + 1;
         }
       }
+      if (munmap(map, size))
+        DieSys(src);
     }
-    if (close(fd)) {
+    if (close(fd))
       DieSys(src);
-    }
   }
   getargs_destroy(&ga);
 }
@@ -540,9 +530,8 @@ static wontreturn void ShowUsage(int rc, int fd) {
 }
 
 static void AddPath(struct Paths *paths, const char *path) {
-  if (paths->n == ARRAYLEN(paths->p)) {
+  if (paths->n == ARRAYLEN(paths->p))
     Die("too many path arguments");
-  }
   paths->p[paths->n++] = path;
 }
 
@@ -557,21 +546,18 @@ static void GetOpts(int argc, char *argv[]) {
         AddPath(&systempaths, optarg);
         break;
       case 'o':
-        if (outpath) {
+        if (outpath)
           Die("multiple output paths specified");
-        }
         outpath = optarg;
         break;
       case 'r':
-        if (buildroot) {
+        if (buildroot)
           Die("multiple build roots specified");
-        }
         buildroot = optarg;
         break;
       case 'g':
-        if (genroot) {
+        if (genroot)
           Die("multiple generated roots specified");
-        }
         genroot = optarg;
         break;
       case 'n':
@@ -582,31 +568,24 @@ static void GetOpts(int argc, char *argv[]) {
         ShowUsage(1, 2);
     }
   }
-  if (optind == argc) {
+  if (optind == argc)
     Die("missing input argument");
-  }
-  if (!genroot) {
+  if (!genroot)
     genroot = "o/";
-  }
-  if (!endswith(genroot, "/")) {
+  if (!endswith(genroot, "/"))
     Die("generated output path must end with slash");
-  }
-  if (!buildroot) {
+  if (!buildroot)
     Die("need build output path");
-  }
-  if (!endswith(buildroot, "/")) {
+  if (!endswith(buildroot, "/"))
     Die("build output path must end with slash");
-  }
-  if (!startswith(buildroot, genroot)) {
+  if (!startswith(buildroot, genroot))
     Die("build output path must start with generated output path");
-  }
   if (!systempaths.n && hermetic) {
     AddPath(&systempaths, "third_party/libcxx/include/");
     AddPath(&systempaths, "libc/isystem/");
   }
-  if (systempaths.n && !hermetic) {
+  if (systempaths.n && !hermetic)
     Die("system path can only be specified in hermetic mode");
-  }
   long j = 0;
   for (long i = 0; i < systempaths.n; ++i) {
     size_t n;
@@ -619,21 +598,18 @@ static void GetOpts(int argc, char *argv[]) {
         DieSys(path);
       }
     }
-    if ((n = strlen(path)) >= PATH_MAX) {
+    if ((n = strlen(path)) >= PATH_MAX)
       DiePathTooLong(path);
-    }
-    if (!n || path[n - 1] != '/') {
+    if (!n || path[n - 1] != '/')
       Die("system path must end with slash");
-    }
   }
   systempaths.n = j;
 }
 
 static const char *StripExt(char pathbuf[hasatleast PATH_MAX], const char *s) {
   static char *dot;
-  if (strlcpy(pathbuf, s, PATH_MAX) >= PATH_MAX) {
+  if (strlcpy(pathbuf, s, PATH_MAX) >= PATH_MAX)
     DiePathTooLong(s);
-  }
   dot = strrchr(pathbuf, '.');
   if (dot)
     *dot = '\0';
@@ -661,13 +637,10 @@ static uint32_t GetFileExtension(const char *s) {
 static bool IsObjectSource(const char *name) {
   int i;
   uint32_t ext;
-  if ((ext = GetFileExtension(name))) {
-    for (i = 0; i < ARRAYLEN(kSourceExts); ++i) {
-      if (ext == kSourceExts[i]) {
+  if ((ext = GetFileExtension(name)))
+    for (i = 0; i < ARRAYLEN(kSourceExts); ++i)
+      if (ext == kSourceExts[i])
         return true;
-      }
-    }
-  }
   return false;
 }
 
@@ -736,22 +709,18 @@ int main(int argc, char *argv[]) {
   LoadRelationships(argc, argv);
   Crunch();
   makefile = Explore();
-  if (outpath &&
-      (fd = open(outpath, O_WRONLY | O_CREAT | O_TRUNC, 0644)) == -1) {
+  if (outpath && (fd = open(outpath, O_WRONLY | O_CREAT | O_TRUNC, 0644)) == -1)
     DieSys(outpath);
-  }
   n = appendz(makefile).i;
-  for (i = 0; i < n; i += (size_t)rc) {
-    if ((rc = write(fd, makefile + i, n - i)) == -1) {
+  for (i = 0; i < n; i += (size_t)rc)
+    if ((rc = write(fd, makefile + i, n - i)) == -1)
       DieSys(outpath);
-    }
-  }
-  if (outpath && close(fd)) {
+  if (outpath && close(fd))
     DieSys(outpath);
-  }
   free(makefile);
   free(edges.p);
   free(sauces);
   free(names);
+  CheckForMemoryLeaks();
   return 0;
 }
diff --git a/tool/build/mv.c b/tool/build/mv.c
index 503a2855f..d1cc31b13 100644
--- a/tool/build/mv.c
+++ b/tool/build/mv.c
@@ -62,8 +62,6 @@ char linkbuf[PATH_MAX];
 
 void Mv(char *, char *);
 
-#include "libc/mem/tinymalloc.inc"
-
 wontreturn void Die(const char *path, const char *reason) {
   tinyprint(2, path, ": ", reason, "\n", NULL);
   exit(1);
diff --git a/tool/build/objbincopy.c b/tool/build/objbincopy.c
index ce08d0aed..42427c226 100644
--- a/tool/build/objbincopy.c
+++ b/tool/build/objbincopy.c
@@ -21,8 +21,8 @@
 #include "libc/elf/elf.h"
 #include "libc/elf/struct/ehdr.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macho.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macho.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
diff --git a/tool/build/package.c b/tool/build/package.c
index 57b5de82a..9c4c20519 100644
--- a/tool/build/package.c
+++ b/tool/build/package.c
@@ -30,7 +30,7 @@
 #include "libc/intrin/bswap.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/arraylist.internal.h"
 #include "libc/mem/mem.h"
@@ -151,8 +151,6 @@ struct Relas {
   } *p;
 } prtu;
 
-#include "libc/mem/tinymalloc.inc"
-
 static wontreturn void Die(const char *path, const char *reason) {
   tinyprint(2, path, ": ", reason, "\n", NULL);
   exit(1);
diff --git a/tool/build/pecheck.c b/tool/build/pecheck.c
index 3585f26e3..199cfed02 100644
--- a/tool/build/pecheck.c
+++ b/tool/build/pecheck.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/ctype.h"
 #include "libc/limits.h"
 #include "libc/nt/struct/imageimportbyname.internal.h"
 #include "libc/nt/struct/imageimportdescriptor.internal.h"
diff --git a/tool/build/pledge.c b/tool/build/pledge.c
index 874f76669..78f5527d5 100644
--- a/tool/build/pledge.c
+++ b/tool/build/pledge.c
@@ -29,6 +29,7 @@
 #include "libc/calls/syscall-nt.internal.h"
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/calls/syscall_support-sysv.internal.h"
+#include "libc/ctype.h"
 #include "libc/dce.h"
 #include "libc/elf/def.h"
 #include "libc/elf/elf.h"
@@ -38,10 +39,10 @@
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/promises.internal.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/promises.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/alloca.h"
 #include "libc/nexgen32e/kcpuids.h"
@@ -372,7 +373,11 @@ int SetLimit(int r, long lo, long hi) {
 }
 
 static int GetBaseCpuFreqMhz(void) {
+#ifdef __x86_64__
   return KCPUIDS(16H, EAX) & 0x7fff;
+#else
+  return 0;
+#endif
 }
 
 int SetCpuLimit(int secs) {
@@ -652,8 +657,8 @@ int main(int argc, char *argv[]) {
   bool hasfunbits;
   int useruid, usergid;
   int owneruid, ownergid;
-  int oldfsuid, oldfsgid;
   unsigned long ipromises;
+  int oldfsuid = 0, oldfsgid = 0;
 
   // parse flags
   GetOpts(argc, argv);
diff --git a/tool/build/renamestr.c b/tool/build/renamestr.c
new file mode 100644
index 000000000..1364bc6c3
--- /dev/null
+++ b/tool/build/renamestr.c
@@ -0,0 +1,283 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/elf/def.h"
+#include "libc/elf/elf.h"
+#include "libc/elf/scalar.h"
+#include "libc/elf/struct/ehdr.h"
+#include "libc/elf/struct/phdr.h"
+#include "libc/intrin/kprintf.h"
+#include "libc/intrin/likely.h"
+#include "libc/macros.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/runtime/symbols.internal.h"
+#include "libc/stdio/stdio.h"
+#include "libc/str/str.h"
+#include "libc/sysv/consts/map.h"
+#include "libc/sysv/consts/o.h"
+#include "libc/sysv/consts/prot.h"
+#include "third_party/getopt/getopt.internal.h"
+
+#define VERSION      \
+  "renamestr v0.1\n" \
+  "https://github.com/jart/cosmopolitan\n"
+
+#define MANUAL                                                \
+  " -f FROM -t TO INPUT \n"                                   \
+  "\n"                                                        \
+  "DESCRIPTION\n"                                             \
+  "\n"                                                        \
+  "  in-place string replacement in ELF binary .rodata\n"     \
+  "\n"                                                        \
+  "  this program may be used to replace strings in the\n"    \
+  "  .rodata sections of ELF binaries, in-place.\n"           \
+  "\n"                                                        \
+  "FLAGS\n"                                                   \
+  "\n"                                                        \
+  "  -h         show usage\n"                                 \
+  "\n"                                                        \
+  "  -v         show version\n"                               \
+  "\n"                                                        \
+  "  -f FROM    source string to replace\n"                   \
+  "\n"                                                        \
+  "  -t TO      target string replacement. must be shorter\n" \
+  "             than FROM string for replacement to work\n"   \
+  "\n"                                                        \
+  "  INPUT      ELF binary containing strings to replace\n"   \
+  "\n"
+
+static const char *prog;
+static const char *exepath;
+static Elf64_Shdr *rodata;
+static char *rostart;
+static char *roend;
+static int exefd;
+
+static wontreturn void Die(const char *thing, const char *reason) {
+  tinyprint(2, thing, ": ", reason, "\n", NULL);
+  exit(1);
+}
+
+static wontreturn void DieSys(const char *thing) {
+  perror(thing);
+  exit(1);
+}
+
+static wontreturn void ShowUsage(int rc, int fd) {
+  tinyprint(fd, "USAGE\n\n  ", prog, MANUAL, NULL);
+  exit(rc);
+}
+
+static void Pwrite(const void *data, size_t size, uint64_t offset) {
+  ssize_t rc;
+  const char *p, *e;
+  for (p = data, e = p + size; p < e; p += (size_t)rc, offset += (size_t)rc) {
+    if ((rc = pwrite(exefd, p, e - p, offset)) == -1) {
+      DieSys(exepath);
+    }
+  }
+}
+
+struct String {
+  const char *str;
+  size_t len;
+};
+
+struct Param {
+  struct String from;
+  struct String to;
+  int count;
+  char *roloc;
+};
+
+struct Params {
+  int n;
+  struct Param p[4];
+};
+
+static struct Params params;
+
+static void GetOpts(int argc, char *argv[]) {
+  int opt;
+  bool partial = false;
+  params.n = 0;
+  struct Param *param;
+  while ((opt = getopt(argc, argv, "hvf:t:")) != -1) {
+    if (params.n >= ARRAYLEN(params.p)) {
+      param = NULL;
+    } else {
+      param = &(params.p[params.n]);
+    }
+    switch (opt) {
+      case 'f':
+        if (!param) {
+          Die(prog, "too many replacements provided");
+        }
+        if (param->from.str) {
+          Die(prog, "from string already provided");
+        }
+        param->from.str = optarg;
+        param->from.len = strlen(optarg);
+        partial = !partial;
+        break;
+      case 't':
+        if (!param) {
+          Die(prog, "too many replacements provided");
+        }
+        if (param->to.str) {
+          Die(prog, "to string already provided");
+        }
+        param->to.str = optarg;
+        param->to.len = strlen(optarg);
+        partial = !partial;
+        break;
+      case 'v':
+        tinyprint(0, VERSION, NULL);
+        exit(0);
+      case 'h':
+        ShowUsage(0, 1);
+      default:
+        ShowUsage(1, 2);
+    }
+    if (param->from.str && param->to.str) {
+      if (param->from.len < param->to.len) {
+        Die(prog, "to.str longer than from.str, cannot replace");
+      }
+      params.n++;
+    }
+  }
+  if (params.n == 0) {
+    Die(prog, "no replacements provided");
+  }
+  if (partial) {
+    Die(prog, "partial replacement provided");
+  }
+  if (optind == argc) {
+    Die(prog, "missing input argument");
+  }
+  if (optind != argc - 1) {
+    Die(prog, "too many args");
+  }
+  exepath = argv[optind];
+}
+
+struct Input {
+  union {
+    char *map;
+    Elf64_Ehdr *elf;
+    unsigned char *umap;
+  };
+  size_t size;
+  const char *path;
+};
+
+static struct Input input;
+
+static void OpenInput(const char *path) {
+  int fd;
+  if ((fd = open(path, O_RDWR)) == -1)
+    DieSys(path);
+  if ((input.size = lseek(fd, 0, SEEK_END)) == -1)
+    DieSys(path);
+  input.path = path;
+  input.map = mmap(0, input.size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
+  if (input.map == MAP_FAILED)
+    DieSys(path);
+  if (!IsElf64Binary(input.elf, input.size))
+    Die(path, "not an elf64 binary");
+  exefd = fd;
+}
+
+static void ReplaceString(struct Param *param) {
+  size_t len;
+  char *x = (char *)memchr(param->roloc, 0, roend - param->roloc);
+  memmove(param->roloc, param->to.str, param->to.len);
+  if (UNLIKELY(x == NULL)) {
+    len = roend - param->roloc;
+    memmove(param->roloc + param->to.len, param->roloc + param->from.len,
+            len - param->from.len);
+  } else {
+    len = x - param->roloc;
+    memmove(param->roloc + param->to.len, param->roloc + param->from.len,
+            len + 1 - param->from.len);
+  }
+  param->roloc += param->to.len;
+}
+
+int main(int argc, char *argv[]) {
+#ifdef MODE_DBG
+  ShowCrashReports();
+#endif
+
+  prog = argv[0];
+
+  if (!prog)
+    prog = "renamestr";
+
+  GetOpts(argc, argv);
+  OpenInput(exepath);
+  rodata = FindElfSectionByName(
+      input.elf, input.size,
+      GetElfSectionNameStringTable(input.elf, input.size), ".rodata");
+  if (!rodata)
+    Die(exepath, "doesn't have .rodata");
+
+  rostart = GetElfSectionAddress(input.elf, input.size, rodata);
+  if (!rostart)
+    Die(prog, "could not get to start of .rodata");
+  roend = rostart + rodata->sh_size;
+
+#ifdef MODE_DBG
+  kprintf("elf file to process: %s\n", exepath);
+  kprintf("file size is %ld\n", input.size);
+#endif
+  for (int i = 0; i < params.n; ++i) {
+    struct Param *param = &(params.p[i]);
+    param->roloc = rostart;
+    param->count = 0;
+#ifdef MODE_DBG
+    kprintf("need to replace '%s' with '%s'\n", param->from.str, param->to.str);
+#endif
+  }
+
+#define NEXT_ROLOC(z) \
+  memmem((z)->roloc, roend - (z)->roloc, (z)->from.str, (z)->from.len)
+  for (int i = 0; i < params.n; ++i) {
+    struct Param *param = &(params.p[i]);
+    for (param->roloc = NEXT_ROLOC(param); param->roloc != NULL;
+         param->roloc = NEXT_ROLOC(param)) {
+      ReplaceString(param);
+      param->count++;
+    }
+  }
+#undef NEXT_ROLOC
+
+  Pwrite(input.map, input.size, 0);
+  if (close(exefd)) {
+    Die(prog, "unable to close file after writing");
+  }
+
+  for (int i = 0; i < params.n; ++i) {
+    struct Param *param = &(params.p[i]);
+    printf("'%s' -> '%s': %d replacements\n", param->from.str, param->to.str,
+           param->count);
+  }
+  return 0;
+}
diff --git a/tool/build/resymbol.c b/tool/build/resymbol.c
index f525324a2..4bf094ce6 100644
--- a/tool/build/resymbol.c
+++ b/tool/build/resymbol.c
@@ -33,8 +33,6 @@ const char *FLAG_prefix;
 const char *FLAG_suffix;
 const char *path;
 
-#include "libc/mem/tinymalloc.inc"
-
 wontreturn void PrintUsage(int fd, int exitcode) {
   tinyprint(fd, "\n\
 NAME\n\
diff --git a/tool/build/rm.c b/tool/build/rm.c
index e4a3a5077..c5a041dbc 100644
--- a/tool/build/rm.c
+++ b/tool/build/rm.c
@@ -48,8 +48,6 @@ static bool recursive;
 static bool doemptydirs;
 static const char *prog;
 
-#include "libc/mem/tinymalloc.inc"
-
 static wontreturn void PrintUsage(int rc, int fd) {
   tinyprint(fd, "USAGE\n\n  ", prog, USAGE, NULL);
   exit(rc);
diff --git a/tool/build/rollup.c b/tool/build/rollup.c
deleted file mode 100644
index 2dcc61596..000000000
--- a/tool/build/rollup.c
+++ /dev/null
@@ -1,177 +0,0 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
-│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Copyright 2020 Justine Alexandra Roberts Tunney                              │
-│                                                                              │
-│ Permission to use, copy, modify, and/or distribute this software for         │
-│ any purpose with or without fee is hereby granted, provided that the         │
-│ above copyright notice and this permission notice appear in all copies.      │
-│                                                                              │
-│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
-│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
-│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
-│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
-│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
-│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
-│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
-│ PERFORMANCE OF THIS SOFTWARE.                                                │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/calls/calls.h"
-#include "libc/calls/struct/stat.h"
-#include "libc/mem/mem.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/append.h"
-#include "libc/stdio/stdio.h"
-#include "libc/str/str.h"
-#include "libc/sysv/consts/map.h"
-#include "libc/sysv/consts/o.h"
-#include "libc/sysv/consts/prot.h"
-#include "tool/build/lib/getargs.h"
-#include "tool/build/lib/interner.h"
-
-#define LOOKINGAT(p, pe, s) LookingAt(p, pe, s, strlen(s))
-
-struct Visited {
-  size_t i, n;
-  const char **p;
-};
-
-char *output;
-const char *prog;
-struct Interner *visited;
-
-void Visit(const char *);
-
-static wontreturn void Die(const char *reason) {
-  tinyprint(2, prog, ": ", reason, "\n", NULL);
-  exit(1);
-}
-
-static wontreturn void DieSys(const char *thing) {
-  perror(thing);
-  exit(1);
-}
-
-static wontreturn void DieOom(void) {
-  Die("out of memory");
-}
-
-static void Appends(char **b, const char *s) {
-  if (appends(b, s) == -1)
-    DieOom();
-}
-
-static void Appendd(char **b, const void *p, size_t n) {
-  if (appendd(b, p, n) == -1)
-    DieOom();
-}
-
-size_t GetFdSize(int fd) {
-  struct stat st;
-  if (fstat(fd, &st)) {
-    DieSys("fstat");
-  }
-  return st.st_size;
-}
-
-bool LookingAt(const char *p, const char *pe, const char *s, size_t n) {
-  return pe - p >= n && memcmp(p, s, n) == 0;
-}
-
-void Process(const char *p, const char *pe, const char *path, bool isheader) {
-  int level;
-  bool noformat;
-  const char *p2, *dq, *name;
-  for (noformat = false, level = 0; p < pe; p = p2) {
-    p2 = memchr(p, '\n', pe - p);
-    p2 = p2 ? p2 + 1 : pe;
-    if (LOOKINGAT(p, pe, "#if")) {
-      if (isheader && !level++)
-        continue;
-    }
-    if (LOOKINGAT(p, pe, "#endif")) {
-      if (isheader && !--level)
-        continue;
-    }
-    if (LOOKINGAT(p, pe, "/* clang-format off */")) {
-      noformat = true;
-    } else if (LOOKINGAT(p, pe, "/* clang-format on */")) {
-      noformat = false;
-    }
-    if (LOOKINGAT(p, pe, "#include \"")) {
-      name = p + strlen("#include \"");
-      dq = memchr(name, '"', pe - name);
-      if (dq) {
-        Visit(strndup(name, dq - name));
-        continue;
-      }
-    }
-    Appendd(&output, p, p2 - p);
-  }
-  if (noformat) {
-    Appends(&output, "/* clang-format on */\n");
-  }
-}
-
-void Visit(const char *path) {
-  int fd;
-  char *map;
-  size_t size;
-  bool isheader;
-  if (!endswith(path, ".h") && !endswith(path, ".inc"))
-    return;
-  if (endswith(path, ".internal.h"))
-    return;
-  if (endswith(path, "/internal.h"))
-    return;
-  if (endswith(path, ".internal.inc"))
-    return;
-  if (endswith(path, "/internal.inc"))
-    return;
-  if (startswith(path, "libc/isystem/"))
-    return;
-  isheader = endswith(path, ".h");
-  if (isheader && isinterned(visited, path))
-    return;
-  Appends(&output, "\n\f\n/*!BEGIN ");
-  Appends(&output, path);
-  Appends(&output, " */\n\n");
-  intern(visited, path);
-  if ((fd = open(path, O_RDONLY)) == -1)
-    DieSys(path);
-  if ((size = GetFdSize(fd))) {
-    map = mmap(0, size, PROT_READ, MAP_PRIVATE, fd, 0);
-    if (map == MAP_FAILED)
-      DieSys(path);
-    Process(map, map + size, path, isheader);
-    if (munmap(map, size))
-      DieSys(path);
-  }
-  if (close(fd))
-    DieSys(path);
-}
-
-int main(int argc, char *argv[]) {
-  size_t bytes;
-  const char *src;
-  struct GetArgs ga;
-  prog = argv[0];
-  if (!prog)
-    prog = "rollup";
-  visited = newinterner();
-  Appends(&output, "#ifndef COSMOPOLITAN_H_\n");
-  Appends(&output, "#define COSMOPOLITAN_H_\n");
-  getargs_init(&ga, argv + 1);
-  while ((src = getargs_next(&ga))) {
-    Visit(src);
-  }
-  getargs_destroy(&ga);
-  Appends(&output, "\n");
-  Appends(&output, "#endif /* COSMOPOLITAN_H_ */\n");
-  bytes = appendz(output).i;
-  if (write(1, output, bytes) != bytes) {
-    DieSys(prog);
-  }
-  freeinterner(visited);
-  return 0;
-}
diff --git a/tool/build/runit.c b/tool/build/runit.c
index 3c0a55681..1b123f3ea 100644
--- a/tool/build/runit.c
+++ b/tool/build/runit.c
@@ -26,7 +26,7 @@
 #include "libc/errno.h"
 #include "libc/fmt/libgen.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
@@ -161,12 +161,12 @@ void Connect(void) {
   CHECK_NE(-1,
            (g_sock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol)));
   expo = INITIAL_CONNECT_TIMEOUT;
-  deadline = timespec_add(timespec_real(),
+  deadline = timespec_add(timespec_mono(),
                           timespec_fromseconds(MAX_WAIT_CONNECT_SECONDS));
   LOGIFNEG1(sigaction(SIGALRM, &(struct sigaction){.sa_handler = OnAlarm}, 0));
   DEBUGF("connecting to %s (%hhu.%hhu.%hhu.%hhu) to run %s", g_hostname, ip4[0],
          ip4[1], ip4[2], ip4[3], g_prog);
-  struct timespec start = timespec_real();
+  struct timespec start = timespec_mono();
 TryAgain:
   alarmed = false;
   LOGIFNEG1(setitimer(
@@ -178,7 +178,7 @@ TryAgain:
   if (rc == -1) {
     if (err == EINTR) {
       expo *= 1.5;
-      if (timespec_cmp(timespec_real(), deadline) >= 0) {
+      if (timespec_cmp(timespec_mono(), deadline) >= 0) {
         FATALF("timeout connecting to %s (%hhu.%hhu.%hhu.%hhu:%d)", g_hostname,
                ip4[0], ip4[1], ip4[2], ip4[3],
                ntohs(((struct sockaddr_in *)ai->ai_addr)->sin_port));
@@ -193,7 +193,7 @@ TryAgain:
   }
   setitimer(ITIMER_REAL, &(const struct itimerval){0}, 0);
   freeaddrinfo(ai);
-  connect_latency = timespec_tomicros(timespec_sub(timespec_real(), start));
+  connect_latency = timespec_tomicros(timespec_sub(timespec_mono(), start));
 }
 
 bool Send(int tmpfd, const void *output, size_t outputsize) {
@@ -204,7 +204,8 @@ bool Send(int tmpfd, const void *output, size_t outputsize) {
   static bool once;
   static z_stream zs;
   zsize = 32768;
-  zbuf = gc(malloc(zsize));
+  if (!(zbuf = malloc(zsize)))
+    __builtin_trap();
   if (!once) {
     CHECK_EQ(Z_OK, deflateInit2(&zs, 4, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
                                 Z_DEFAULT_STRATEGY));
@@ -226,6 +227,7 @@ bool Send(int tmpfd, const void *output, size_t outputsize) {
       break;
     }
   } while (!zs.avail_out);
+  free(zbuf);
   return ok;
 }
 
@@ -307,7 +309,7 @@ bool Recv(char *p, int n) {
 
 int ReadResponse(void) {
   int exitcode;
-  struct timespec start = timespec_real();
+  struct timespec start = timespec_mono();
   for (;;) {
     char msg[5];
     if (!Recv(msg, 5)) {
@@ -352,7 +354,7 @@ int ReadResponse(void) {
       break;
     }
   }
-  execute_latency = timespec_tomicros(timespec_sub(timespec_real(), start));
+  execute_latency = timespec_tomicros(timespec_sub(timespec_mono(), start));
   close(g_sock);
   return exitcode;
 }
@@ -377,11 +379,15 @@ int RunOnHost(char *spec) {
   for (;;) {
     Connect();
     EzFd(g_sock);
-    struct timespec start = timespec_real();
+    struct timespec start = timespec_mono();
     err = EzHandshake2();
-    handshake_latency = timespec_tomicros(timespec_sub(timespec_real(), start));
+    handshake_latency = timespec_tomicros(timespec_sub(timespec_mono(), start));
     if (!err)
       break;
+    if (err == MBEDTLS_ERR_NET_CONN_RESET) {
+      close(g_sock);
+      continue;
+    }
     WARNF("handshake with %s:%d failed -0x%04x (%s)",  //
           g_hostname, g_runitdport, err, GetTlsError(err));
     close(g_sock);
diff --git a/tool/build/runitd.c b/tool/build/runitd.c
index d1b0f375f..0287bd29a 100644
--- a/tool/build/runitd.c
+++ b/tool/build/runitd.c
@@ -33,7 +33,7 @@
 #include "libc/intrin/kprintf.h"
 #include "libc/log/appendresourcereport.internal.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/leaks.h"
 #include "libc/mem/mem.h"
@@ -49,6 +49,7 @@
 #include "libc/stdio/append.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
+#include "libc/stdio/sysparam.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/af.h"
 #include "libc/sysv/consts/at.h"
@@ -134,12 +135,12 @@
 #define INFOF(FMT, ...) LOGF(INFO, FMT, ##__VA_ARGS__)
 #define WARNF(FMT, ...) LOGF(WARN, FMT, ##__VA_ARGS__)
 
-#define LOGF(LVL, FMT, ...)                                               \
-  do {                                                                    \
-    if (g_log_level >= LOG_LEVEL_##LVL) {                                 \
-      kprintf("%r" #LVL " %6P %'18T %s:%d " FMT "\n", __FILE__, __LINE__, \
-              ##__VA_ARGS__);                                             \
-    }                                                                     \
+#define LOGF(LVL, FMT, ...)                                                   \
+  do {                                                                        \
+    if (g_log_level >= LOG_LEVEL_##LVL) {                                     \
+      kprintf("%r" #LVL " %6P %6H %'18T %s:%d " FMT "\n", __FILE__, __LINE__, \
+              ##__VA_ARGS__);                                                 \
+    }                                                                         \
   } while (0)
 
 struct Client {
@@ -443,12 +444,18 @@ void FreeClient(struct Client *client) {
 void *ClientWorker(void *arg) {
   uint32_t crc;
   sigset_t sigmask;
+  struct timespec ts0;
+  struct timespec ts1;
+  struct timespec ts2;
   int events, wstatus;
   struct Client *client = arg;
   uint32_t namesize, filesize;
   char *addrstr, *origname;
   unsigned char msg[4 + 1 + 4 + 4 + 4];
 
+  ts0 = timespec_mono();
+  ts1 = timespec_mono();
+
   SetupPresharedKeySsl(MBEDTLS_SSL_IS_SERVER, g_psk);
   defer(FreeClient, client);
 
@@ -458,9 +465,15 @@ void *ClientWorker(void *arg) {
   EzHandshake();
   addrstr = DescribeAddress(&client->addr);
   DEBUF("%s %s %s", DescribeAddress(&g_servaddr), "accepted", addrstr);
+  DEBUF("it took %'zu us to handshake client",
+        timespec_tomicros(timespec_sub(timespec_mono(), ts1)));
 
   // get the executable
+  ts1 = timespec_mono();
+  ts2 = timespec_mono();
   Recv(client, msg, sizeof(msg));
+  DEBUF("it took %'zu us to receive #1",
+        timespec_tomicros(timespec_sub(timespec_mono(), ts2)));
   if (READ32BE(msg) != RUNITD_MAGIC) {
     WARNF("%s magic mismatch!", addrstr);
     pthread_exit(0);
@@ -473,11 +486,19 @@ void *ClientWorker(void *arg) {
   filesize = READ32BE(msg + 9);
   crc = READ32BE(msg + 13);
   origname = gc(calloc(1, namesize + 1));
+  ts2 = timespec_mono();
   Recv(client, origname, namesize);
+  DEBUF("it took %'zu us to receive #2",
+        timespec_tomicros(timespec_sub(timespec_mono(), ts2)));
   VERBF("%s sent %#s (%'u bytes @ %#s)", addrstr, origname, filesize,
         client->tmpexepath);
   char *exedata = gc(malloc(filesize));
+  ts2 = timespec_mono();
   Recv(client, exedata, filesize);
+  DEBUF("it took %'zu us to receive #3",
+        timespec_tomicros(timespec_sub(timespec_mono(), ts2)));
+  DEBUF("it took %'zu us to receive executable from network",
+        timespec_tomicros(timespec_sub(timespec_mono(), ts1)));
   if (crc32_z(0, exedata, filesize) != crc) {
     WARNF("%s crc mismatch! %#s", addrstr, origname);
     pthread_exit(0);
@@ -488,6 +509,7 @@ void *ClientWorker(void *arg) {
   // condition can happen, where etxtbsy is raised by our execve
   // we're using o_cloexec so it's guaranteed to fix itself fast
   // thus we use an optimistic approach to avoid expensive locks
+  ts1 = timespec_mono();
   sprintf(client->tmpexepath, "o/%s.XXXXXX",
           basename(stripext(gc(strdup(origname)))));
   int exefd = openatemp(AT_FDCWD, client->tmpexepath, 0, O_CLOEXEC, 0700);
@@ -510,6 +532,8 @@ void *ClientWorker(void *arg) {
     WARNF("%s failed to close %#s due to %m", addrstr, origname);
     pthread_exit(0);
   }
+  DEBUF("it took %'zu us to write executable to disk",
+        timespec_tomicros(timespec_sub(timespec_mono(), ts1)));
 
   // do the args
   int i = 0;
@@ -550,7 +574,7 @@ RetryOnEtxtbsyRaceCondition:
   posix_spawnattr_t spawnattr;
   posix_spawn_file_actions_t spawnfila;
   sigemptyset(&sigmask);
-  started = timespec_real();
+  started = timespec_mono();
   pipe2(client->pipe, O_CLOEXEC);
   posix_spawnattr_init(&spawnattr);
   posix_spawnattr_setflags(&spawnattr,
@@ -560,8 +584,11 @@ RetryOnEtxtbsyRaceCondition:
   posix_spawn_file_actions_adddup2(&spawnfila, g_bogusfd, 0);
   posix_spawn_file_actions_adddup2(&spawnfila, client->pipe[1], 1);
   posix_spawn_file_actions_adddup2(&spawnfila, client->pipe[1], 2);
+  ts1 = timespec_mono();
   err = posix_spawn(&client->pid, client->tmpexepath, &spawnfila, &spawnattr,
                     args, environ);
+  DEBUF("it took %'zu us to call posix_spawn",
+        timespec_tomicros(timespec_sub(timespec_mono(), ts1)));
   if (err) {
     if (err == ETXTBSY) {
       goto RetryOnEtxtbsyRaceCondition;
@@ -576,7 +603,7 @@ RetryOnEtxtbsyRaceCondition:
 
   DEBUF("communicating %s[%d]", origname, client->pid);
   struct timespec deadline =
-      timespec_add(timespec_real(), timespec_fromseconds(DEATH_CLOCK_SECONDS));
+      timespec_add(timespec_mono(), timespec_fromseconds(DEATH_CLOCK_SECONDS));
   for (;;) {
     if (g_interrupted) {
       WARNF("killing %d %s and hanging up %d due to interrupt", client->fd,
@@ -588,7 +615,7 @@ RetryOnEtxtbsyRaceCondition:
       PrintProgramOutput(client);
       pthread_exit(0);
     }
-    struct timespec now = timespec_real();
+    struct timespec now = timespec_mono();
     if (timespec_cmp(now, deadline) >= 0) {
       WARNF("killing %s (pid %d) which timed out after %d seconds", origname,
             client->pid, DEATH_CLOCK_SECONDS);
@@ -599,8 +626,11 @@ RetryOnEtxtbsyRaceCondition:
     fds[0].events = POLLIN;
     fds[1].fd = client->pipe[0];
     fds[1].events = POLLIN;
-    events = poll(fds, ARRAYLEN(fds),
-                  timespec_tomillis(timespec_sub(deadline, now)));
+    ts1 = timespec_mono();
+    int64_t ms = timespec_tomillis(timespec_sub(deadline, now));
+    events = poll(fds, ARRAYLEN(fds), MIN(ms, -1u));
+    DEBUF("it took %'zu us to call poll",
+          timespec_tomicros(timespec_sub(timespec_mono(), ts1)));
     if (events == -1) {
       if (errno == EINTR) {
         INFOF("poll interrupted");
@@ -615,7 +645,10 @@ RetryOnEtxtbsyRaceCondition:
       if (fds[0].revents) {
         int received;
         char buf[512];
+        ts1 = timespec_mono();
         received = mbedtls_ssl_read(&ezssl, buf, sizeof(buf));
+        DEBUF("it took %'zu us to call mbedtls_ssl_read",
+              timespec_tomicros(timespec_sub(timespec_mono(), ts1)));
         if (!received) {
           WARNF("%s client disconnected so killing worker %d", origname,
                 client->pid);
@@ -640,7 +673,10 @@ RetryOnEtxtbsyRaceCondition:
       }
       if (fds[1].revents) {
         char buf[512];
+        ts1 = timespec_mono();
         ssize_t got = read(client->pipe[0], buf, sizeof(buf));
+        DEBUF("it took %'zu us to call read",
+              timespec_tomicros(timespec_sub(timespec_mono(), ts1)));
         if (got == -1) {
           WARNF("got %s reading %s output", strerror(errno), origname);
           goto HangupClientAndTerminateJob;
@@ -658,7 +694,10 @@ RetryOnEtxtbsyRaceCondition:
 WaitAgain:
   DEBUF("waitpid");
   struct rusage rusage;
+  ts1 = timespec_mono();
   int wrc = wait4(client->pid, &wstatus, 0, &rusage);
+  DEBUF("it took %'zu us to call wait4",
+        timespec_tomicros(timespec_sub(timespec_mono(), ts1)));
   if (wrc == -1) {
     if (errno == EINTR) {
       WARNF("waitpid interrupted; killing %s pid %d", origname, client->pid);
@@ -676,7 +715,7 @@ WaitAgain:
   }
   client->pid = 0;
   int exitcode;
-  struct timespec ended = timespec_real();
+  struct timespec ended = timespec_mono();
   int64_t micros = timespec_tomicros(timespec_sub(ended, started));
   if (WIFEXITED(wstatus)) {
     if (WEXITSTATUS(wstatus)) {
@@ -711,13 +750,18 @@ WaitAgain:
     AppendResourceReport(&client->output, &rusage, "\n");
     PrintProgramOutput(client);
   }
+  ts1 = timespec_mono();
   SendProgramOutput(client);
   SendExitMessage(exitcode);
   mbedtls_ssl_close_notify(&ezssl);
+  DEBUF("it took %'zu us to send result to client",
+        timespec_tomicros(timespec_sub(timespec_mono(), ts1)));
   if (etxtbsy_tries > 1) {
     WARNF("encountered %d ETXTBSY race conditions spawning %s",
           etxtbsy_tries - 1, origname);
   }
+  DEBUF("it took %'zu us TO DO EVERYTHING",
+        timespec_tomicros(timespec_sub(timespec_mono(), ts0)));
   pthread_exit(0);
 }
 
diff --git a/tool/build/sha256sum.c b/tool/build/sha256sum.c
index 369676127..50f461791 100644
--- a/tool/build/sha256sum.c
+++ b/tool/build/sha256sum.c
@@ -25,7 +25,7 @@
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "third_party/getopt/getopt.internal.h"
 #include "third_party/mbedtls/sha256.h"
 
diff --git a/tool/build/symtab.c b/tool/build/symtab.c
index b372d6f4d..3c3584be4 100644
--- a/tool/build/symtab.c
+++ b/tool/build/symtab.c
@@ -30,8 +30,6 @@
  * @fileoverview elf to symbol table file dump tool
  */
 
-#include "libc/mem/tinymalloc.inc"
-
 void PrintUsage(FILE *f) {
   fprintf(f, "%s%s%s\n", "usage: ", program_invocation_name,
           " [-?h] -o PATH COMDBG");
diff --git a/tool/build/zipcopy.c b/tool/build/zipcopy.c
index 125ab57ae..9f3aa8fd0 100644
--- a/tool/build/zipcopy.c
+++ b/tool/build/zipcopy.c
@@ -32,7 +32,7 @@
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "third_party/getopt/getopt.internal.h"
 
 static int infd;
diff --git a/tool/build/zipobj.c b/tool/build/zipobj.c
index 37cb3ef89..007bbfa7a 100644
--- a/tool/build/zipobj.c
+++ b/tool/build/zipobj.c
@@ -39,7 +39,7 @@
 #include "libc/sysv/consts/s.h"
 #include "libc/time.h"
 #include "libc/x/x.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "third_party/getopt/getopt.internal.h"
 #include "tool/build/lib/elfwriter.h"
 #include "tool/build/lib/stripcomponents.h"
diff --git a/tool/cosmocc/README.md b/tool/cosmocc/README.md
index ece1d107f..84802987e 100644
--- a/tool/cosmocc/README.md
+++ b/tool/cosmocc/README.md
@@ -1,7 +1,7 @@
 # Cosmopolitan Toolchain
 
 This toolchain can be used to compile executables that run on Linux /
-MacOS / Windows / FreeBSD / OpenBSD / NetBSD for both the x86_64 and
+MacOS / Windows / FreeBSD / OpenBSD 7.3 / NetBSD for both the x86_64 and
 AARCH64 architectures. In addition to letting you create portable
 binaries, your toolchain is itself comprised of portable binaries,
 enabling you to have a consistent development environment that lets you
@@ -9,13 +9,13 @@ reach a broader audience from the platform(s) of your choosing.
 
 ## What's Included
 
-This toolchain bundles GCC 12.3.0, Cosmopolitan Libc, LLVM LIBCXX, LLVM
-compiler-rt, and LLVM OpenMP. Additional libraries were provided by Musl
-Libc, and the venerable BSDs OSes. This lets you benefit from the
-awesome modern GCC compiler with the strongest GPL barrier possible. The
-preprocessor advertises cross compilers as both `__COSMOCC__` and
-`__COSMOPOLITAN__` whereas `cosmocc` additionally defines
-`__FATCOSMOCC__`.
+This toolchain bundles GCC 14.1.0, Clang 19, Cosmopolitan Libc, LLVM
+LIBCXX, LLVM compiler-rt, and LLVM OpenMP. Additional libraries were
+provided by Musl Libc, and the venerable BSDs OSes. This lets you
+benefit from the awesome modern GCC compiler with the strongest GPL
+barrier possible. The preprocessor advertises cross compilers as both
+`__COSMOCC__` and `__COSMOPOLITAN__` whereas `cosmocc` additionally
+defines `__FATCOSMOCC__`.
 
 ## Getting Started
 
@@ -88,6 +88,33 @@ format used by the host system; however it's also possible to explicitly
 convert APE programs to any architectures / OS combination. For further
 details on usage, run the `assimilate -h` command.
 
+
+## Binary archive format
+
+The APE format includes another portability superpower: the ability to 
+distribute application support files WITHIN the compiled executable file. 
+This is because APE files are also mostly regular zip files! You will 
+need a copy of a compatible zip tool like the modified version of 
+Info-ZIP available here: https://cosmo.zip/pub/cosmos/bin/zip. With this 
+in hand the following command:
+
+```sh
+zip [APE file] [support_file.txt]
+```
+
+adds support_file.txt to your executable. You can see it listed within 
+the archive with `unzip -l [APE file]`. 
+
+Cosmo libc includes compatible file handling functions for accessing the 
+contents of an APE file at the special '/zip' path. So your code is now 
+able to do the following:
+
+```c
+if (access( "/zip/support_file.txt", F_OK) == 0) {
+	fprintf(stderr, "/zip/support_file.txt FOUND and can be used as an asset\n");
+}
+```
+
 ## Gotchas
 
 If you use zsh and have trouble running APE programs try `sh -c ./prog`
@@ -142,6 +169,139 @@ and AARCH64, which is K8 and ARMv8.0. You can pass architecture specific
 flags to use newer ISAs by using the `-Xx86_64` and `-Xaarch64` prefixes
 like `-Xx86_64-mssse3` and `-Xaarch64-march=armv8.2-a+dotprod`.
 
+## Flags
+
+The following supplemental flags are defined by cosmocc:
+
+- `-mcosmo` causes `_COSMO_SOURCE` to be defined. This has a similar
+  effect to defining `_GNU_SOURCE`. When you use this flag, many
+  non-standard GNU, BSD, and Cosmo Libc APIs will become visible in
+  headers, e.g. `stdlib.h` will now define `ShowCrashReports()`.
+  Including `cosmo.h` has a similar effect, however it's recommended
+  that any program that uses cosmo-specific APIs pass this flag.
+
+- `-mclang` (experimental) may be passed to the `cosmocc` command to use
+  Clang instead of GCC under the hood. This can help C++ code compile 3x
+  faster.
+
+- `-mgcc` may be passed to the `cosmocc` command to use GCC instead of
+  Clang under the hood. Since this is the default mode, this flag may be
+  used to override the effect of passing the `-mclang` flag earlier.
+
+- `-mdbg` may be passed when linking programs. It has the same effect as
+  `export MODE=dbg` in that it will cause an alternative build of the
+  Cosmopolitan Libc runtime to be linked that was built with `-O0 -g`.
+  Under the normal build mode, `--ftrace` output generated by your libc
+  is oftentimes missing important details due to inlining. If your build
+  your code with `cosmocc -O0 -mdbg` then `--ftrace` will make much more
+  sense. It's also the only way to make using GDB to troubleshoot issues
+  inside Cosmo Libc work reliably. Please be warned, this flag enables
+  some heavy-hitting runtime checks, such such lock graph validation.
+  The debug Cosmopolitan runtime is able to detect lock cycles globally
+  automatically via your normal usage of `pthread_mutex_t` and then
+  report strongly connected components with C++ symbol demangling. This
+  runtime will absolutely crash your entire process, if it helps you
+  spot a bug. For example, debug cosmo is build with UBSAN so even an
+  undiscovered yet innocent bit shift of a negative number could take
+  you down. So you wouldn't want to use this in prod very often. Please
+  note that passing `-mdbg` doesn't imply `-g -O0 -fsanitize=undefined`
+  which must be passed separately if you want your code to be compiled
+  with the same stuff as libc.
+
+- `-mtiny` may be passed when linking programs. It has the same effect
+  as `export MODE=tiny` in that it will cause an alternative build of
+  the Cosmopolitan Libc runtime to be linked that's optimized for code
+  size. In the normal build mode, the smallest possible binary size will
+  be on the order of hundreds of kb, due to heavyweight features like
+  `--ftrace` and `--strace` being part of the mandatory runtime. Those
+  features don't exist in the tiny runtime, which should produce ~147kb
+  fat binaries and ~36kb x86-only binaries. You may also use this flag
+  when compiling objects. Since there's no function tracing, using this
+  will eliminate the NOPs that get inserted into the prologues of your
+  functions to make them hookable, which also greatly reduces code size.
+  Please note that this does not specify an `-O` flag, so you may want
+  to pass `-Os` too. Please note that this mode is granted leeway to
+  trade away performance whenever possible. Functions like memmove()
+  will stop using fancy vectorization which can dramatically decrease
+  the performance of certain use cases. malloc() will no longer be
+  scalable either. Cosmo malloc() will normally perform similarly to
+  things like jemalloc. But in -mtiny mode it's protected by a GIL that
+  may cause a multithreaded C++ HTTP server that makes intense usage of
+  the STL may drop from 3.7 million requests per second to just 17k.
+  We've seen it happen. malloc() will also stop using cookies which add
+  bloat but are considered important by some people for both security
+  and reporting errors on corruption. APIs will also begin refraining
+  from detecting usage errors that are the fault of the caller, so this
+  mode isn't recommended for development. Where -mtiny truly shines is
+  when you're writing tiny programs. Particularly if they're ephemeral
+  and frequent (e.g. build tooling), because the tiny runtime needs to
+  do less work at process startup.
+
+- `-moptlinux` uses the optimized Linux-only version of Cosmopolitan
+  Libc runtime libraries. Your program will only be able to run on
+  Linux. The runtime is compiled at `-O3` although it still supports AMD
+  K8+ (c. 2003). Optimizations like red zone that wouldn't otherwise be
+  possible are enabled. Function call tracing and system call logging is
+  disabled. All the Windows polyfills go away and your binaries will be
+  significantly tinier. The `cosmocc` compiler will generate a shell
+  script with the magic `jartsr='` so you won't get unwanted attention
+  from Windows virus scanners. You're even allowed to use flags like
+  `-fomit-frame-pointer` when you use this mode. Users report optlinux
+  has helped them make the Python interpreter 5% faster, like distros,
+  optlinux will salt the earth if it gains a 1% advantage on benchmark
+  games. Therefore this mode gives you an apples-to-apples comparison
+  between cosmocc versus the gcc/clang configs used by linux distros.
+
+## Raw Toolchains
+
+The `cosmocc` and `cosmoar` programs use shell script magic to run both
+toolchains under the hood. Sometimes this magic doesn't work when you're
+building software that needs to do things like run the C preprocessor in
+aarch64 mode. In such cases, cosmocc provides x86\_64 and aarch64 only
+toolchains which give you more power and control over your builds.
+
+- `x86_64-unknown-cosmo-cc`, `x86_64-unknown-cosmo-c++`, and
+  `x86_64-linux-cosmo-as` let you build multi-OS programs that only run
+  on x86\_64. You'll need this if you want to compile complex projects
+  like Emacs and OpenSSL. These are shell scripts that help you make
+  sure your software is compiled with the correct set of flags.
+
+- `aarch64-unknown-cosmo-cc`, `aarch64-unknown-cosmo-c++`, and
+  `aarch64-linux-cosmo-as` let you build multi-OS programs that only run
+  on ARM64. You'll need this if you want to compile complex projects
+  like Emacs and OpenSSL. These are shell scripts that help you make
+  sure your software is compiled with the correct set of flags.
+
+- `aarch64-linux-cosmo-cc`, `aarch64-linux-cosmo-c++`,
+  `aarch64-linux-cosmo-as`, and `aarch64-linux-cosmo-ld` are the actual
+  compiler executables. Using these grants full control over your
+  compiler and maximum performance. This is the approach favored for
+  instance by the Cosmopolitan Mono Repo's Makefile. If you use these,
+  then you should have zero expectation of support, because you'll be
+  assuming all responsibility for knowing about all the ABI-related
+  flags your Cosmopolitan runtime requires.
+
+When you use the "unknown" OS compilers, they'll link ELF executables
+which embed an APE program image. This is so it's possible to have DWARF
+debugging data. If you say:
+
+```
+x86_64-unknown-cosmo-cc -Os -mtiny -o hello hello.c
+./hello
+x86_64-linux-cosmo-objcopy -SO binary hello hello.com
+./hello.com
+```
+
+Then you can unwap the raw stripped APE executable and get a much
+smaller file than you otherwise would using the `-s` flag.
+
+If you compile your software twice, using both the x86\_64 and aarch64
+compilers, then it's possible to link the two binaries into a single fat
+binary yourself via the `apelink` program. To understand how this
+process works, it works best if you use the `BUILDLOG` variable, to see
+how the shell script wrappers are doing it. You can also consult the
+build configs of the ahgamut/superconfigure project on GitHub.
+
 ## Troubleshooting
 
 Your `cosmocc` compiler runs a number commands under the hood. If
@@ -297,9 +457,9 @@ EINVAL: ... }` in cases where constants like `EINVAL` are linkable
 symbols. Your code will be rewritten in such cases to use a series of if
 statements instead, so that Cosmopolitan Libc's system constants will
 work as expected. Our modifications to GNU GCC are published under the
-ISC license at <https://github.com/ahgamut/gcc/tree/portcosmo-12.3>. The
+ISC license at <https://github.com/ahgamut/gcc/tree/portcosmo-14.1>. The
 binaries you see here were first published at
-<https://github.com/ahgamut/superconfigure/releases/tag/z0.0.43> which
+<https://github.com/ahgamut/superconfigure/releases/tag/z0.0.60> which
 is regularly updated.
 
 ## Legal
diff --git a/tool/cosmocc/bin/cosmocc b/tool/cosmocc/bin/cosmocc
index d27802332..3019d0621 100755
--- a/tool/cosmocc/bin/cosmocc
+++ b/tool/cosmocc/bin/cosmocc
@@ -6,7 +6,7 @@
 BIN=${0%/*}
 PROG=${0##*/}
 ORIGINAL="$0 $*"
-GCC_VERSION=12.3.0
+GCC_VERSION=14.1.0
 TMPDIR=${TMPDIR:-/tmp}
 
 if [ "$1" = "--version" ]; then
@@ -75,10 +75,38 @@ elif [ ! -d "$TMPDIR" ]; then
   fi
 fi
 
+use_gcc() {
+  CLANG=0
+  CC_X86_64="$BIN/x86_64-linux-cosmo-gcc"
+  CC_AARCH64="$BIN/aarch64-linux-cosmo-gcc"
+  CXX_X86_64="$BIN/x86_64-linux-cosmo-g++"
+  CXX_AARCH64="$BIN/aarch64-linux-cosmo-g++"
+  TARGET_X86_64=
+  TARGET_AARCH64=
+  FPORTCOSMO="-fportcosmo"
+  FNO_INLINE_FUNCTIONS_CALLED_ONCE="-fno-inline-functions-called-once"
+}
+
+use_clang() {
+  CLANG=1
+  CC_X86_64="$BIN/../libexec/clang"
+  CC_AARCH64="$BIN/../libexec/clang"
+  CXX_X86_64="$BIN/../libexec/clang"
+  CXX_AARCH64="$BIN/../libexec/clang"
+  TARGET_X86_64="--target=x86_64"
+  TARGET_AARCH64="--target=aarch64"
+  FPORTCOSMO=
+  FNO_INLINE_FUNCTIONS_CALLED_ONCE=
+}
+
+use_gcc
+
+X=
 OPT=
 ARGS=
 FLAGS=
 OUTPUT=
+NEED_X=
 MDFLAG=0
 MCOSMO=0
 INTENT=ld
@@ -91,11 +119,11 @@ FLAGS_AARCH64=
 INPUT_FILE_COUNT=0
 DEPENDENCY_OUTPUT=
 NEED_DEPENDENCY_OUTPUT=
+
 for x; do
   if [ x"$x" != x"${x#* }" ]; then
     fatal_error "arguments containing spaces unsupported: $x"
-  fi
-  if [ -n "$NEED_OUTPUT" ]; then
+  elif [ -n "$NEED_OUTPUT" ]; then
     NEED_OUTPUT=
     OUTPUT=$x
     continue
@@ -109,6 +137,10 @@ for x; do
   elif [ -n "$NEED_EQUAL" ]; then
     x="${NEED_EQUAL}=${x}"
     NEED_EQUAL=
+  elif [ -n "$NEED_X" ]; then
+    NEED_X=
+    X=$x
+    x="-x${x}"
   elif [ x"$x" = x"-" ] ||           # is alias for stdin
        [ x"$x" = x"${x#-*}" ]; then  # !startswith(x, "-")
     if [ x"$x" != x"${x%.s}" ] ||
@@ -136,10 +168,25 @@ for x; do
   elif [ x"$x" != x"${x#-MF}" ]; then  # startswith(x, "-MF")
     DEPENDENCY_OUTPUT=${x#-MF}
     continue
+  elif [ x"$x" = x"-MQ" ]; then
+    NEED_DEPENDENCY_OUTPUT=1
+    continue
+  elif [ x"$x" = x"-Wl,--version" ]; then
+    cat <<EOF
+GNU ld (GNU Binutils) 2.42
+Copyright (C) 2024 Free Software Foundation, Inc.
+This program is free software; you may redistribute it under the terms of
+the GNU General Public License version 3 or (at your option) a later version.
+This program has absolutely no warranty.
+EOF
+    exit
   elif [ x"$x" != x"${x#-O}" ]; then  # startswith(x, "-O")
     OPT=$x
   elif [ x"$x" = x"-c" ]; then
-    INTENT=cc
+    if [ x"$INTENT" != x"cpp" ]; then
+      INTENT=cc
+    fi
+    continue
   elif [ x"$x" = x"-E" ] ||
        [ x"$x" = x"-M" ] ||
        [ x"$x" = x"-MM" ]; then
@@ -156,6 +203,23 @@ for x; do
   elif [ x"$x" = x"-mcosmo" ]; then
     MCOSMO=1
     continue
+  elif [ x"$x" = x"-mdbg" ]; then
+    MODE=dbg
+    continue
+  elif [ x"$x" = x"-mtiny" ]; then
+    MODE=tiny
+    continue
+  elif [ x"$x" = x"-moptlinux" ]; then
+    MODE=optlinux
+    continue
+  elif [ x"$x" = x"-mclang" ]; then
+    use_clang
+    continue
+  elif [ x"$x" = x"-mgcc" ]; then
+    use_gcc
+    continue
+  elif [ x"$x" = x"-m64" ]; then
+    continue
   elif [ x"$x" = x"-fomit-frame-pointer" ]; then
     # Quoth Apple: "The frame pointer register must always address a
     # valid frame record. Some functions — such as leaf functions or
@@ -201,8 +265,12 @@ for x; do
   elif [ x"$x" = x"-dumpversion" ]; then
     echo $GCC_VERSION
     Exit 0
-  elif [ x"$x" = x"-x" ] ||
-       [ x"$x" = x"-e" ] ||
+  elif [ x"$x" = x"-x" ]; then
+    NEED_X=1
+    continue
+  elif [ x"$x" != x"${x#-x}" ]; then
+    X=${x#-x}
+  elif [ x"$x" = x"-e" ] ||
        [ x"$x" = x"-z" ] ||
        [ x"$x" = x"-T" ] ||
        [ x"$x" = x"-L" ] ||
@@ -227,56 +295,116 @@ for x; do
   ARGS="$ARGS $x"
 done
 
+# precompiled header mode
+if [ $INTENT != cpp ]; then
+  if [ -z "$X" ]; then
+    ONLY_HEADER_INPUTS=1
+    for x in $ARGS; do
+      if [ x"$x" = x"${x#-*}" ] &&       # !startswith(x, "-")
+         [ x"$x" = x"${x%.h}" ] &&       # !endswith(x, ".h")
+         [ x"$x" = x"${x%.hpp}" ]; then  # !endswith(x, ".hpp")
+        ONLY_HEADER_INPUTS=0
+        break
+      fi
+    done
+    if [ $ONLY_HEADER_INPUTS -eq 1 ]; then
+      INTENT=gch
+    fi
+  elif [ x"$X" = x"c-header" ] ||
+       [ x"$X" = x"c++-header" ]; then
+    INTENT=gch
+  fi
+fi
+if [ $INTENT = gch ]; then
+  fatal_error "precompiled headers only supported with ARCH-unknown-cosmo-cc compilers"
+fi
+
+# check for incorrect usage
 if [ $INPUT_FILE_COUNT -eq 0 ]; then
   fatal_error "no input files"
-elif [ -z "$INPUT" ] &&
-     [ $INTENT != ld ] &&
-     [ $INPUT_FILE_COUNT -gt 1 ]; then
-  fatal_error "cannot specify '-o' with '-c', or '-E' with multiple files"
+elif [ -n "$OUTPUT" ] && [ $INPUT_FILE_COUNT -gt 1 ]; then
+  if [ $INTENT = cc ] || [ $INTENT = cpp ]; then
+    fatal_error "cannot specify '-o' with '-c' or '-E' with multiple files"
+  fi
+fi
+
+if [ $INTENT = ld ]; then
+  use_gcc
 fi
 
 PLATFORM="-D__COSMOPOLITAN__ -D__COSMOCC__ -D__FATCOSMOCC__"
 PREDEF="-include libc/integral/normalize.inc"
 CPPFLAGS="-fno-pie -nostdinc -isystem $BIN/../include"
-CFLAGS="-fportcosmo -fno-dwarf2-cfi-asm -fno-unwind-tables -fno-asynchronous-unwind-tables -fno-semantic-interposition"
+CFLAGS="$FPORTCOSMO -fno-semantic-interposition"
 LDFLAGS="-static -nostdlib -no-pie -fuse-ld=bfd -Wl,-z,noexecstack -Wl,-z,norelro -Wl,--gc-sections"
 PRECIOUS="-fno-omit-frame-pointer"
 
 # these features screw with backtraces so avoid them
-if [ x"$OPT" != x"-Os" ] && [ x"$MODE" != x"tiny" ]; then
+if [ x"$OPT" != x"-Os" ] && [ x"$MODE" != x"tiny" ] && [ x"$MODE" != x"optlinux" ]; then
   CFLAGS="$CFLAGS -fno-optimize-sibling-calls -mno-omit-leaf-frame-pointer"
 fi
-if [ x"$OPT" != x"-O3" ]; then
-  CFLAGS="$CFLAGS -fno-schedule-insns2"
+if [ x"$OPT" != x"-O3" ] && [ x"$MODE" != x"optlinux" ]; then
+  if [ $CLANG -eq 0 ]; then
+    CFLAGS="$CFLAGS -fno-schedule-insns2"
+  fi
 fi
 
-CC_X86_64="$BIN/x86_64-linux-cosmo-gcc"
-CC_AARCH64="$BIN/aarch64-linux-cosmo-gcc"
-if [ x"$PROG" != x"${PROG%++}" ]; then
-  CC_X86_64="$BIN/x86_64-linux-cosmo-g++"
-  CC_AARCH64="$BIN/aarch64-linux-cosmo-g++"
-  CFLAGS="$CFLAGS -fno-rtti -fno-exceptions -fuse-cxa-atexit"
+if [ x"$X" = x"c" ] || [ x"$X" = x"c-header" ]; then
+  CPLUSPLUS=0
+elif [ x"$X" = x"c++" ] || [ x"$X" = x"c++-header" ]; then
+  CPLUSPLUS=1
+elif [ x"$PROG" != x"${PROG%++}" ]; then
+  CPLUSPLUS=1
+else
+  CPLUSPLUS=0
+fi
+
+if [ $CPLUSPLUS -eq 1 ]; then
+  CC_X86_64=$CXX_X86_64
+  CC_AARCH64=$CXX_AARCH64
   CPPFLAGS="-isystem $BIN/../include/third_party/libcxx $CPPFLAGS"
+else
+  CFLAGS="$CFLAGS -Wno-implicit-int"
 fi
 
-CRT_X86_64="$BIN/../x86_64-linux-cosmo/lib/ape.o $BIN/../x86_64-linux-cosmo/lib/crt.o"
-CPPFLAGS_X86_64="$CPPFLAGS -mno-red-zone"
+if [ x"$MODE" = x"dbg" ]; then
+  LIB_X86_64="$BIN/../x86_64-linux-cosmo/lib/dbg"
+  LIB_AARCH64="$BIN/../aarch64-linux-cosmo/lib/dbg"
+elif [ x"$MODE" = x"tiny" ]; then
+  LIB_X86_64="$BIN/../x86_64-linux-cosmo/lib/tiny"
+  LIB_AARCH64="$BIN/../aarch64-linux-cosmo/lib/tiny"
+elif [ x"$MODE" = x"optlinux" ]; then
+  LIB_X86_64="$BIN/../x86_64-linux-cosmo/lib/optlinux"
+  LIB_AARCH64="$BIN/../aarch64-linux-cosmo/lib/optlinux"
+else
+  LIB_X86_64="$BIN/../x86_64-linux-cosmo/lib"
+  LIB_AARCH64="$BIN/../aarch64-linux-cosmo/lib"
+fi
+
+CRT_X86_64="$LIB_X86_64/ape.o $LIB_X86_64/crt.o"
+CPPFLAGS_X86_64="$CPPFLAGS"
 CFLAGS_X86_64="$CFLAGS -mno-tls-direct-seg-refs"
-LDFLAGS_X86_64="$LDFLAGS -L$BIN/../x86_64-linux-cosmo/lib -Wl,-T,$BIN/../x86_64-linux-cosmo/lib/ape.lds -Wl,-z,common-page-size=4096 -Wl,-z,max-page-size=16384"
+LDFLAGS_X86_64="$LDFLAGS -L$LIB_X86_64 -L$BIN/../x86_64-linux-cosmo/lib -Wl,-T,$LIB_X86_64/ape.lds -Wl,-z,common-page-size=4096 -Wl,-z,max-page-size=16384"
 LDLIBS_X86_64="-lcosmo"
 
-CRT_AARCH64="$BIN/../aarch64-linux-cosmo/lib/crt.o"
+CRT_AARCH64="$LIB_AARCH64/crt.o"
 CPPFLAGS_AARCH64="$CPPFLAGS -fsigned-char"
-CFLAGS_AARCH64="$CFLAGS -ffixed-x18 -ffixed-x28 -mno-outline-atomics"
-LDFLAGS_AARCH64="$LDFLAGS -L$BIN/../aarch64-linux-cosmo/lib -Wl,-T,$BIN/../aarch64-linux-cosmo/lib/aarch64.lds -Wl,-z,common-page-size=16384 -Wl,-z,max-page-size=16384"
+CFLAGS_AARCH64="$CFLAGS -ffixed-x18 -ffixed-x28"
+LDFLAGS_AARCH64="$LDFLAGS -L$LIB_AARCH64 -L$BIN/../aarch64-linux-cosmo/lib -Wl,-T,$LIB_AARCH64/aarch64.lds -Wl,-z,common-page-size=16384 -Wl,-z,max-page-size=16384"
 LDLIBS_AARCH64="-lcosmo"
 
-if [ x"$OPT" != x"-Os" ] && [ x"$MODE" != x"tiny" ]; then
-  CFLAGS_X86_64="${CFLAGS_X86_64} -fpatchable-function-entry=18,16 -fno-inline-functions-called-once -DFTRACE -DSYSDEBUG"
-  CFLAGS_AARCH64="${CFLAGS_AARCH64} -fpatchable-function-entry=7,6 -fno-inline-functions-called-once -DFTRACE -DSYSDEBUG"
+SUPPORT_VECTOR=-1
+if [ x"$MODE" = x"optlinux" ]; then
+  CPPFLAGS_X86_64="$CPPFLAGS_X86_64 -mno-red-zone"
+  SUPPORT_VECTOR=linux
 fi
 
-if [ x"$PROG" != x"${PROG%++}" ]; then
+if [ x"$OPT" != x"-Os" ] && [ x"$MODE" != x"tiny" ] && [ x"$MODE" != x"optlinux" ]; then
+  CFLAGS_X86_64="${CFLAGS_X86_64} -fpatchable-function-entry=18,16 $FNO_INLINE_FUNCTIONS_CALLED_ONCE -DFTRACE -DSYSDEBUG"
+  CFLAGS_AARCH64="${CFLAGS_AARCH64} -fpatchable-function-entry=7,6 $FNO_INLINE_FUNCTIONS_CALLED_ONCE -DFTRACE -DSYSDEBUG"
+fi
+
+if [ $CPLUSPLUS -eq 1 ]; then
   LDLIBS_X86_64="-lcxx ${LDLIBS_X86_64}"
   LDLIBS_AARCH64="-lcxx ${LDLIBS_AARCH64}"
 fi
@@ -292,6 +420,9 @@ if [ $INTENT = cpp ]; then
   if [ -n "$OUTPUT" ]; then
     ARGS="$ARGS -o$OUTPUT"
   fi
+  # undefine cpu-specific and linux-specific defines
+  # we get rid of long double too to not lead astray
+  # we shall leave behind unix, __unix, and __unix__
   set -- \
       "$CC_X86_64" \
       -U__k8 \
@@ -300,10 +431,21 @@ if [ $INTENT = cpp ]; then
       -U__amd64__ \
       -U__x86_64 \
       -U__x86_64__ \
+      -U__MMX__ \
+      -U__MMX_WITH_SSE__ \
+      -U__SSE_MATH__ \
+      -U__SEG_FS \
+      -U__SEG_GS \
       -U__SSE__ \
+      -U__FXSR__ \
       -U__SSE2__ \
       -U__SSE2_MATH__ \
+      -Ulinux \
+      -U__linux \
+      -U__linux__ \
+      -U__gnu_linux__ \
       -mno-red-zone \
+      -mlong-double-64 \
       $PLATFORM \
       $CPPFLAGS \
       $ARGS
@@ -353,6 +495,7 @@ build_object() {
   (
     set -- \
         "$CC_X86_64" \
+        $TARGET_X86_64 \
         -o"$OUTPUT_X86_64" \
         $PLATFORM \
         $PREDEF \
@@ -374,6 +517,7 @@ build_object() {
   (
     set -- \
         "$CC_AARCH64" \
+        $TARGET_AARCH64 \
         -o"$OUTPUT_AARCH64" \
         $PLATFORM \
         $PREDEF \
@@ -480,6 +624,7 @@ TEMP_FILES="${TEMP_FILES} $out2"
 (
   set -- \
       "$CC_X86_64" \
+      $TARGET_X86_64 \
       -o"$OUTPUT_X86_64"\
       $CRT_X86_64 \
       $LDFLAGS_X86_64 \
@@ -497,6 +642,7 @@ pid1=$!
 (
   set -- \
       "$CC_AARCH64" \
+      $TARGET_AARCH64 \
       -o"$OUTPUT_AARCH64"\
       $CRT_AARCH64 \
       $LDFLAGS_AARCH64 \
@@ -524,6 +670,7 @@ fi
 
 set -- \
 "$BIN/apelink" \
+  -V "$SUPPORT_VECTOR" \
   -l "$BIN/ape-x86_64.elf" \
   -l "$BIN/ape-aarch64.elf" \
   -M "$BIN/ape-m1.c" \
@@ -534,10 +681,12 @@ set -- \
 log_command "$@"
 "$@" || Exit
 
-set -- \
-"$BIN/pecheck" "$OUTPUT"
-log_command "$@"
-"$@" || Exit
+if [ x"$MODE" != "optlinux" ]; then
+  set -- \
+  "$BIN/pecheck" "$OUTPUT"
+  log_command "$@"
+  "$@" || Exit
+fi
 
 if [ $INTENT = ld ] && [ $SAVE_TEMPS -eq 0 ]; then
   mv -f "$OUTPUT_X86_64" "${OUTPUT%.com}.com.dbg" || Exit
diff --git a/tool/cosmocc/bin/cosmocross b/tool/cosmocc/bin/cosmocross
index 644c109c9..357239920 100755
--- a/tool/cosmocc/bin/cosmocross
+++ b/tool/cosmocc/bin/cosmocross
@@ -5,7 +5,7 @@
 
 BIN=${0%/*}
 PROG=${0##*/}
-GCC_VERSION=12.3.0
+GCC_VERSION=14.1.0
 
 if [ "$1" = "--version" ]; then
 cat <<EOF
@@ -47,7 +47,7 @@ log_command() {
 ORIGINAL="$0 $*"
 PLATFORM="-D__COSMOPOLITAN__ -D__COSMOCC__"
 PREDEF="-include libc/integral/normalize.inc"
-CFLAGS="-fportcosmo -fno-dwarf2-cfi-asm -fno-unwind-tables -fno-asynchronous-unwind-tables -fno-semantic-interposition"
+CFLAGS="-fportcosmo -fno-semantic-interposition"
 CPPFLAGS="-fno-pie -nostdinc -isystem $BIN/../include"
 LDFLAGS="-static -no-pie -nostdlib -fuse-ld=bfd -Wl,-z,noexecstack"
 APEFLAGS="-Wl,--gc-sections"
@@ -59,35 +59,79 @@ if [ x"$ARCH" = x"$PROG" ]; then
   fatal_error "cosmocross must be run via cross compiler"
 fi
 
+X=
+NEED_X=
+for x; do
+  if [ -n "$NEED_X" ]; then
+    NEED_X=
+    X=$x
+  elif [ x"$x" = x"-x" ]; then
+    NEED_X=1
+  elif [ x"$x" != x"${x#-x}" ]; then
+    X=${x#-x}
+  elif [ x"$x" = x"-mtiny" ]; then
+    MODE=tiny
+  elif [ x"$x" = x"-mdbg" ]; then
+    MODE=dbg
+  elif [ x"$x" = x"-moptlinux" ]; then
+    MODE=optlinux
+  fi
+done
+
+if [ x"$MODE" = x"dbg" ]; then
+  LIB="$BIN/../$ARCH-linux-cosmo/lib/dbg"
+elif [ x"$MODE" = x"tiny" ]; then
+  LIB="$BIN/../$ARCH-linux-cosmo/lib/tiny"
+elif [ x"$MODE" = x"optlinux" ]; then
+  LIB="$BIN/../$ARCH-linux-cosmo/lib/optlinux"
+else
+  LIB="$BIN/../$ARCH-linux-cosmo/lib"
+fi
+
+if [ x"$X" = x"c" ] || [ x"$X" = x"c-header" ]; then
+  CPLUSPLUS=0
+elif [ x"$X" = x"c++" ] || [ x"$X" = x"c++-header" ]; then
+  CPLUSPLUS=1
+elif [ x"$PROG" != x"${PROG%++}" ]; then
+  CPLUSPLUS=1
+else
+  CPLUSPLUS=0
+fi
+
 CC="$BIN/$ARCH-linux-cosmo-gcc"
-CRT="$BIN/../$ARCH-linux-cosmo/lib/crt.o"
+CRT="$LIB/crt.o"
 LDLIBS="-lcosmo"
 if [ -z "$COSMOS" ]; then
-    LDFLAGS="$LDFLAGS -L$BIN/../$ARCH-linux-cosmo/lib"
+  LDFLAGS="$LDFLAGS -L$LIB -L$BIN/../$ARCH-linux-cosmo/lib"
 else
-    LDFLAGS="$LDFLAGS -L$COSMOS/lib -L$BIN/../$ARCH-linux-cosmo/lib"
-    CPPFLAGS="$CPPFLAGS -I$COSMOS/include"
+  LDFLAGS="$LDFLAGS -L$COSMOS/lib -L$LIB -L$BIN/../$ARCH-linux-cosmo/lib"
+  CPPFLAGS="$CPPFLAGS -I$COSMOS/include"
 fi
-if [ x"$PROG" != x"${PROG%++}" ]; then
+if [ $CPLUSPLUS -eq 1 ]; then
   CC="$BIN/$ARCH-linux-cosmo-g++"
-  CFLAGS="$CFLAGS -fno-rtti -fno-exceptions -fuse-cxa-atexit"
   CPPFLAGS="-isystem $BIN/../include/third_party/libcxx $CPPFLAGS"
   LDLIBS="-lcxx $LDLIBS"
+else
+  CFLAGS="$CFLAGS -Wno-implicit-int"
 fi
 
 PAGESZ=4096
 if [ x"$ARCH" = x"x86_64" ]; then
   OBJCOPYFLAGS="-S -O binary"
-  CRT="$BIN/../$ARCH-linux-cosmo/lib/ape-no-modify-self.o $CRT"
-  CPPFLAGS="$CPPFLAGS -mno-red-zone"
+  CRT="$LIB/ape-no-modify-self.o $CRT"
   CFLAGS="$CFLAGS -mno-tls-direct-seg-refs"
-  LDFLAGS="$LDFLAGS -Wl,-T,$BIN/../$ARCH-linux-cosmo/lib/ape.lds"
+  LDFLAGS="$LDFLAGS -Wl,-T,$LIB/ape.lds"
+  if [ x"$MODE" = x"optlinux" ]; then
+    CPPFLAGS="$CPPFLAGS -mred-zone"
+  else
+    CPPFLAGS="$CPPFLAGS -mno-red-zone"
+  fi
 elif [ x"$ARCH" = x"aarch64" ]; then
   OBJCOPYFLAGS="-S"
   PAGESZ=16384
   CPPFLAGS="$CPPFLAGS -fsigned-char"
-  CFLAGS="$CFLAGS -ffixed-x18 -ffixed-x28 -mno-outline-atomics"
-  LDFLAGS="$LDFLAGS -Wl,-T,$BIN/../$ARCH-linux-cosmo/lib/aarch64.lds"
+  CFLAGS="$CFLAGS -ffixed-x18 -ffixed-x28"
+  LDFLAGS="$LDFLAGS -Wl,-T,$LIB/aarch64.lds"
 else
   fatal_error "$ARCH: unsupported architecture"
 fi
@@ -140,6 +184,14 @@ for x; do
   elif [ x"$x" = x"-mcosmo" ]; then
     CPPFLAGS="$CPPFLAGS -D_COSMO_SOURCE"
     continue
+  elif [ x"$x" = x"-mdbg" ]; then
+    continue
+  elif [ x"$x" = x"-mtiny" ]; then
+    continue
+  elif [ x"$x" = x"-moptlinux" ]; then
+    continue
+  elif [ x"$x" = x"-m64" ]; then
+    continue
   elif [ x"$x" != x"${x#-o}" ]; then
     OUTPUT=${x#-o}
   elif [ x"$x" = x"-fpic" ]; then
@@ -185,8 +237,30 @@ if [ $RELOCATABLE -eq 1 ]; then
   LDFLAGS="$LDFLAGS -r"
 fi
 
+# precompiled header mode
+if [ $INTENT != cpp ]; then
+  if [ -z "$X" ]; then
+    ONLY_HEADER_INPUTS=1
+    for x; do
+      if [ x"$x" = x"${x#-*}" ] &&       # !startswith(x, "-")
+         [ x"$x" = x"${x%.h}" ] &&       # !endswith(x, ".h")
+         [ x"$x" = x"${x%.hpp}" ]; then  # !endswith(x, ".hpp")
+        ONLY_HEADER_INPUTS=0
+        break
+      fi
+    done
+    if [ $ONLY_HEADER_INPUTS -eq 1 ]; then
+      INTENT=h
+    fi
+  elif [ x"$X" = x"c-header" ] ||
+       [ x"$X" = x"c++-header" ]; then
+    INTENT=h
+  fi
+fi
+
 # support --ftrace unless optimizing for size
 if [ x"$OPT" != x"-Os" ] &&                # $OPT != -Os
+   [ x"$MODE" != x"optlinux" ] &&          # $MODE not optlinux
    [ x"${MODE%tiny}" = x"${MODE}" ]; then  # $MODE not in (tiny, aarch64-tiny)
   if [ x"$ARCH" = x"x86_64" ]; then
     CFLAGS="$CFLAGS -fpatchable-function-entry=18,16 -fno-inline-functions-called-once"
@@ -197,16 +271,17 @@ fi
 
 # maximize frame pointers unless optimizing for size
 if [ x"$OPT" != x"-Os" ] &&               # $OPT != "-Os"
+   [ x"$MODE" != x"optlinux" ] &&         # $MODE not optlinux
    [ x"$MODE" != x"${MODE%tiny}" ]; then  # endswith($MODE, "tiny")
   CFLAGS="$CFLAGS -fno-optimize-sibling-calls -mno-omit-leaf-frame-pointer"
 fi
-if [ x"$OPT" != x"-O3" ]; then
+if [ x"$OPT" != x"-O3" ] && [ x"$MODE" != x"optlinux" ]; then
   CFLAGS="$CFLAGS -fno-schedule-insns2"
 fi
 
 if [ $INTENT = cpp ]; then
   set -- "$CC" $PLATFORM $CPPFLAGS "$@"
-elif [ $INTENT = cc ] || [ $INTENT = s ]; then
+elif [ $INTENT = cc ] || [ $INTENT = s ] || [ $INTENT = h ]; then
   set -- "$CC" $PLATFORM $PREDEF $CFLAGS $CPPFLAGS "$@" $PRECIOUS
 else
   set -- "$CC" $PLATFORM $PREDEF $CFLAGS $CPPFLAGS $CRT "$@" $LDFLAGS $LDLIBS $PRECIOUS
diff --git a/tool/cosmocc/bin/cosmoranlib b/tool/cosmocc/bin/cosmoranlib
new file mode 100755
index 000000000..b1015508b
--- /dev/null
+++ b/tool/cosmocc/bin/cosmoranlib
@@ -0,0 +1,2 @@
+#!/bin/sh
+exec x86_64-linux-cosmo-ranlib "$@"
diff --git a/tool/cosmocc/bin/unknown-unknown-cosmo-ranlib b/tool/cosmocc/bin/unknown-unknown-cosmo-ranlib
new file mode 120000
index 000000000..0f514249d
--- /dev/null
+++ b/tool/cosmocc/bin/unknown-unknown-cosmo-ranlib
@@ -0,0 +1 @@
+cosmoranlib
\ No newline at end of file
diff --git a/tool/cosmocc/package.sh b/tool/cosmocc/package.sh
index a2bb170a1..9c9ada64a 100755
--- a/tool/cosmocc/package.sh
+++ b/tool/cosmocc/package.sh
@@ -15,16 +15,49 @@ mode() {
   esac
 }
 
+_nproc() {
+  case $(uname -s) in
+    Darwin) sysctl -n hw.logicalcpu ;;
+    *)      nproc                   ;;
+  esac
+}
+
+TMPDIR=${TMPDIR:-/tmp}
 OUTDIR=${1:-cosmocc}
 APELINK=o/$(mode)/tool/build/apelink
 AMD64=${2:-x86_64}
 ARM64=${3:-aarch64}
-GCCVER=12.3.0
+NPROC=$(($(_nproc)/2))
+GCCVER=14.1.0
 
-make -j64 m= \
+if ! MAKE=$(command -v gmake); then
+  if ! MAKE=$(command -v make); then
+    echo please install gnu make >&2
+    exit 1
+  fi
+fi
+
+$MAKE -j$NPROC m= \
   $APELINK
 
-make -j64 m=$AMD64 \
+if ! APE=$(command -v ape); then
+  case $(uname -s) in
+    Darwin)
+      case $(mode) in
+        aarch64)
+          cc -O -o "$TMPDIR/ape.$$" .cosmocc/current/bin/ape-m1.c || exit
+          trap 'rm "$TMPDIR/ape.$$"' EXIT
+          APE=$TMPDIR/ape.$$
+        ;;
+        *) APE=.cosmocc/current/bin/ape-x86_64.macho ;;
+      esac
+      ;;
+    *) APE=.cosmocc/current/bin/ape-$(uname -m).elf ;;
+  esac
+fi
+stat $APE
+
+$MAKE -j$NPROC m=$AMD64 \
   o/cosmocc.h.txt \
   o/$AMD64/ape/ape.lds \
   o/$AMD64/libc/crt/crt.o \
@@ -44,15 +77,63 @@ make -j64 m=$AMD64 \
   o/$AMD64/tool/build/zipobj.dbg \
   o/$AMD64/tool/build/apelink.dbg \
   o/$AMD64/tool/build/pecheck.dbg \
+  o/$AMD64/tool/build/ar.dbg \
+  o/$AMD64/tool/build/chmod.dbg \
+  o/$AMD64/tool/build/cocmd.dbg \
+  o/$AMD64/tool/build/compile.dbg \
+  o/$AMD64/tool/build/mkdir.dbg \
+  o/$AMD64/tool/build/cp.dbg \
+  o/$AMD64/tool/build/echo.dbg \
+  o/$AMD64/tool/build/gzip.dbg \
+  o/$AMD64/tool/build/objbincopy.dbg \
+  o/$AMD64/tool/build/package.dbg \
+  o/$AMD64/tool/build/rm.dbg \
+  o/$AMD64/tool/build/touch.dbg \
+  o/$AMD64/tool/build/sha256sum.dbg \
+  o/$AMD64/tool/build/resymbol.dbg \
   o/$AMD64/third_party/make/make.dbg \
   o/$AMD64/third_party/ctags/ctags.dbg
 
-make -j64 m=$ARM64 \
+$MAKE -j$NPROC m=$AMD64-tiny \
+  o/cosmocc.h.txt \
+  o/$AMD64-tiny/ape/ape.lds \
+  o/$AMD64-tiny/libc/crt/crt.o \
+  o/$AMD64-tiny/ape/ape.elf \
+  o/$AMD64-tiny/ape/ape.macho \
+  o/$AMD64-tiny/ape/ape.o \
+  o/$AMD64-tiny/ape/ape-copy-self.o \
+  o/$AMD64-tiny/ape/ape-no-modify-self.o \
+  o/$AMD64-tiny/cosmopolitan.a \
+  o/$AMD64-tiny/third_party/libcxx/libcxx.a \
+
+$MAKE -j$NPROC m=$AMD64-dbg \
+  o/cosmocc.h.txt \
+  o/$AMD64-dbg/ape/ape.lds \
+  o/$AMD64-dbg/libc/crt/crt.o \
+  o/$AMD64-dbg/ape/ape.elf \
+  o/$AMD64-dbg/ape/ape.macho \
+  o/$AMD64-dbg/ape/ape.o \
+  o/$AMD64-dbg/ape/ape-copy-self.o \
+  o/$AMD64-dbg/ape/ape-no-modify-self.o \
+  o/$AMD64-dbg/cosmopolitan.a \
+  o/$AMD64-dbg/third_party/libcxx/libcxx.a \
+
+$MAKE CONFIG_TARGET_ARCH= -j$NPROC m=$AMD64-optlinux \
+  o/cosmocc.h.txt \
+  o/$AMD64-optlinux/ape/ape.lds \
+  o/$AMD64-optlinux/libc/crt/crt.o \
+  o/$AMD64-optlinux/ape/ape.elf \
+  o/$AMD64-optlinux/ape/ape.macho \
+  o/$AMD64-optlinux/ape/ape.o \
+  o/$AMD64-optlinux/ape/ape-copy-self.o \
+  o/$AMD64-optlinux/ape/ape-no-modify-self.o \
+  o/$AMD64-optlinux/cosmopolitan.a \
+  o/$AMD64-optlinux/third_party/libcxx/libcxx.a \
+
+$MAKE -j$NPROC m=$ARM64 \
   o/$ARM64/ape/ape.elf \
   o/$ARM64/ape/aarch64.lds \
   o/$ARM64/libc/crt/crt.o \
-  o/$ARM64/ape/ape-copy-self.o \
-  o/$ARM64/ape/ape-no-modify-self.o \
   o/$ARM64/cosmopolitan.a \
   o/$ARM64/third_party/libcxx/libcxx.a \
   o/$ARM64/tool/build/assimilate.dbg \
@@ -64,9 +145,44 @@ make -j64 m=$ARM64 \
   o/$ARM64/tool/build/zipobj.dbg \
   o/$ARM64/tool/build/apelink.dbg \
   o/$ARM64/tool/build/pecheck.dbg \
+  o/$ARM64/tool/build/ar.dbg \
+  o/$ARM64/tool/build/chmod.dbg \
+  o/$ARM64/tool/build/cocmd.dbg \
+  o/$ARM64/tool/build/compile.dbg \
+  o/$ARM64/tool/build/cp.dbg \
+  o/$ARM64/tool/build/echo.dbg \
+  o/$ARM64/tool/build/gzip.dbg \
+  o/$ARM64/tool/build/objbincopy.dbg \
+  o/$ARM64/tool/build/package.dbg \
+  o/$ARM64/tool/build/rm.dbg \
+  o/$ARM64/tool/build/touch.dbg \
+  o/$ARM64/tool/build/mkdir.dbg \
+  o/$ARM64/tool/build/sha256sum.dbg \
+  o/$ARM64/tool/build/resymbol.dbg \
   o/$ARM64/third_party/make/make.dbg \
   o/$ARM64/third_party/ctags/ctags.dbg
 
+$MAKE -j$NPROC m=$ARM64-tiny \
+  o/$ARM64-tiny/ape/ape.elf \
+  o/$ARM64-tiny/ape/aarch64.lds \
+  o/$ARM64-tiny/libc/crt/crt.o \
+  o/$ARM64-tiny/cosmopolitan.a \
+  o/$ARM64-tiny/third_party/libcxx/libcxx.a \
+
+$MAKE -j$NPROC m=$ARM64-dbg \
+  o/$ARM64-dbg/ape/ape.elf \
+  o/$ARM64-dbg/ape/aarch64.lds \
+  o/$ARM64-dbg/libc/crt/crt.o \
+  o/$ARM64-dbg/cosmopolitan.a \
+  o/$ARM64-dbg/third_party/libcxx/libcxx.a \
+
+$MAKE -j$NPROC m=$ARM64-optlinux \
+  o/$ARM64-optlinux/ape/ape.elf \
+  o/$ARM64-optlinux/ape/aarch64.lds \
+  o/$ARM64-optlinux/libc/crt/crt.o \
+  o/$ARM64-optlinux/cosmopolitan.a \
+  o/$ARM64-optlinux/third_party/libcxx/libcxx.a \
+
 mkdir -p "$OUTDIR/bin/"
 cp tool/cosmocc/README.md "$OUTDIR/"
 cp tool/cosmocc/LICENSE.* "$OUTDIR/"
@@ -85,17 +201,45 @@ fetch() {
   else
     curl -LO $1
   fi
+
+  if command -v sha256sum >/dev/null 2>&1; then
+    # can use system sha256sum
+    true
+  elif command -v shasum >/dev/null 2>&1; then
+    sha256sum() {
+      shasum -a 256 "$@"
+    }
+  elif command -v "$PWD/o/build/sha256sum" >/dev/null 2>&1; then
+    # should have been built by download-cosmocc.sh if a system
+    # sha256sum/shasum does not exist
+    sha256sum() {
+      "$PWD/o/build/sha256sum" "$@"
+    }
+  else
+    echo please install sha256sum >&2
+    exit 1
+  fi
+
+  filename=$(basename $1)
+  printf '%s\n' "$2 $filename" >$filename.sha256sum
+  sha256sum -c $filename.sha256sum || exit 1
 }
 
 OLD=$PWD
 cd "$OUTDIR/"
 if [ ! -x bin/x86_64-linux-cosmo-gcc ]; then
-  fetch https://github.com/ahgamut/superconfigure/releases/download/z0.0.43/aarch64-gcc.zip
-  unzip aarch64-gcc.zip
+  fetch https://github.com/ahgamut/superconfigure/releases/download/z0.0.60/aarch64-gcc.zip 6a07f915ec0296cd33b3142e75c00ed1a7072c75d92c82a0c0b5f5df2cff0dd2 &
+  fetch https://github.com/ahgamut/superconfigure/releases/download/z0.0.60/x86_64-gcc.zip cbb1659c56a0a4f95a71f59f94693515000d3dd53f79a597acacd53cbad2c7d8 &
+  fetch https://github.com/ahgamut/superconfigure/releases/download/z0.0.60/llvm.zip d42c2e46204d4332975d2d7464c5df63c898c34f8d9d2b83c168c14705ca8edd &
+  wait
+  unzip aarch64-gcc.zip &
+  unzip x86_64-gcc.zip &
+  unzip llvm.zip bin/clang-19 bin/clang-format &
+  wait
   rm -f aarch64-gcc.zip
-  fetch https://github.com/ahgamut/superconfigure/releases/download/z0.0.43/x86_64-gcc.zip
-  unzip x86_64-gcc.zip
   rm -f x86_64-gcc.zip
+  rm -f llvm.zip
+  mv bin/clang-19 libexec/clang  # use `cosmocc -mclang` instead
 fi
 rm -f bin/*-cpp
 rm -f bin/*-gcc-*
@@ -114,10 +258,10 @@ for arch in aarch64 x86_64; do
   ln -sf $arch-linux-cosmo-objdump bin/$arch-unknown-cosmo-objdump
   ln -sf $arch-linux-cosmo-readelf bin/$arch-unknown-cosmo-readelf
   ln -sf $arch-linux-cosmo-strip bin/$arch-unknown-cosmo-strip
-  cmp -s libexec/gcc/$arch-linux-cosmo/$GCCVER/ld.bfd libexec/gcc/$arch-linux-cosmo/$GCCVER/ld
-  ln -sf ld.bfd libexec/gcc/$arch-linux-cosmo/$GCCVER/ld
-  cmp -s libexec/gcc/$arch-linux-cosmo/$GCCVER/ld.bfd bin/$arch-linux-cosmo-ld
-  ln -sf ../libexec/gcc/$arch-linux-cosmo/$GCCVER/ld.bfd bin/$arch-linux-cosmo-ld
+  # cmp -s libexec/gcc/$arch-linux-cosmo/$GCCVER/ld.bfd libexec/gcc/$arch-linux-cosmo/$GCCVER/ld
+  # ln -sf ld.bfd libexec/gcc/$arch-linux-cosmo/$GCCVER/ld
+  # cmp -s libexec/gcc/$arch-linux-cosmo/$GCCVER/ld.bfd bin/$arch-linux-cosmo-ld
+  # ln -sf ../libexec/gcc/$arch-linux-cosmo/$GCCVER/ld.bfd bin/$arch-linux-cosmo-ld
   cmp -s libexec/gcc/$arch-linux-cosmo/$GCCVER/as bin/$arch-linux-cosmo-as
   ln -sf ../libexec/gcc/$arch-linux-cosmo/$GCCVER/as bin/$arch-linux-cosmo-as
   cmp -s libexec/gcc/$arch-linux-cosmo/$GCCVER/ld.bfd bin/$arch-linux-cosmo-ld.bfd
@@ -127,27 +271,62 @@ cd "$OLD"
 
 for arch in $AMD64 $ARM64; do
   mkdir -p "$OUTDIR/$arch-linux-cosmo/lib/"
+  mkdir -p "$OUTDIR/$arch-linux-cosmo/lib/dbg"
+  mkdir -p "$OUTDIR/$arch-linux-cosmo/lib/tiny"
+  mkdir -p "$OUTDIR/$arch-linux-cosmo/lib/optlinux"
+
   cp -f o/$arch/libc/crt/crt.o "$OUTDIR/$arch-linux-cosmo/lib/"
+  cp -f o/$arch-dbg/libc/crt/crt.o "$OUTDIR/$arch-linux-cosmo/lib/dbg/"
+  cp -f o/$arch-tiny/libc/crt/crt.o "$OUTDIR/$arch-linux-cosmo/lib/tiny/"
+  cp -f o/$arch-optlinux/libc/crt/crt.o "$OUTDIR/$arch-linux-cosmo/lib/optlinux/"
+
   cp -f o/$arch/cosmopolitan.a "$OUTDIR/$arch-linux-cosmo/lib/libcosmo.a"
+  cp -f o/$arch-dbg/cosmopolitan.a "$OUTDIR/$arch-linux-cosmo/lib/dbg/libcosmo.a"
+  cp -f o/$arch-tiny/cosmopolitan.a "$OUTDIR/$arch-linux-cosmo/lib/tiny/libcosmo.a"
+  cp -f o/$arch-optlinux/cosmopolitan.a "$OUTDIR/$arch-linux-cosmo/lib/optlinux/libcosmo.a"
+
   cp -f o/$arch/third_party/libcxx/libcxx.a "$OUTDIR/$arch-linux-cosmo/lib/"
+  cp -f o/$arch-dbg/third_party/libcxx/libcxx.a "$OUTDIR/$arch-linux-cosmo/lib/dbg/"
+  cp -f o/$arch-tiny/third_party/libcxx/libcxx.a "$OUTDIR/$arch-linux-cosmo/lib/tiny/"
+  cp -f o/$arch-optlinux/third_party/libcxx/libcxx.a "$OUTDIR/$arch-linux-cosmo/lib/optlinux/"
+
   for lib in c dl gcc_s m crypt pthread resolv rt dl unwind gomp stdc++; do
     printf '\041\074\141\162\143\150\076\012' >"$OUTDIR/$arch-linux-cosmo/lib/lib$lib.a"
   done
   mkdir -p "$OUTDIR/lib/gcc/"
   touch "$OUTDIR/lib/gcc/libgomp.spec"  # needed if user passes -fopenmp but not -lgomp
 done
+
 cp -f o/$AMD64/ape/ape.o "$OUTDIR/x86_64-linux-cosmo/lib/"
+cp -f o/$AMD64-dbg/ape/ape.o "$OUTDIR/x86_64-linux-cosmo/lib/dbg/"
+cp -f o/$AMD64-tiny/ape/ape.o "$OUTDIR/x86_64-linux-cosmo/lib/tiny/"
+cp -f o/$AMD64-optlinux/ape/ape.o "$OUTDIR/x86_64-linux-cosmo/lib/optlinux/"
+
 cp -f o/$AMD64/ape/ape.lds "$OUTDIR/x86_64-linux-cosmo/lib/"
+cp -f o/$AMD64-dbg/ape/ape.lds "$OUTDIR/x86_64-linux-cosmo/lib/dbg/"
+cp -f o/$AMD64-tiny/ape/ape.lds "$OUTDIR/x86_64-linux-cosmo/lib/tiny/"
+cp -f o/$AMD64-optlinux/ape/ape.lds "$OUTDIR/x86_64-linux-cosmo/lib/optlinux/"
+
 cp -f o/$ARM64/ape/aarch64.lds "$OUTDIR/aarch64-linux-cosmo/lib/"
+cp -f o/$ARM64-dbg/ape/aarch64.lds "$OUTDIR/aarch64-linux-cosmo/lib/dbg/"
+cp -f o/$ARM64-tiny/ape/aarch64.lds "$OUTDIR/aarch64-linux-cosmo/lib/tiny/"
+cp -f o/$ARM64-optlinux/ape/aarch64.lds "$OUTDIR/aarch64-linux-cosmo/lib/optlinux/"
+
 cp -f o/$AMD64/ape/ape-no-modify-self.o "$OUTDIR/x86_64-linux-cosmo/lib/"
+cp -f o/$AMD64-dbg/ape/ape-no-modify-self.o "$OUTDIR/x86_64-linux-cosmo/lib/dbg/"
+cp -f o/$AMD64-tiny/ape/ape-no-modify-self.o "$OUTDIR/x86_64-linux-cosmo/lib/tiny/"
+cp -f o/$AMD64-optlinux/ape/ape-no-modify-self.o "$OUTDIR/x86_64-linux-cosmo/lib/optlinux/"
 
 cp -f ape/ape-m1.c "$OUTDIR/bin/"
 cp -af tool/cosmocc/bin/* "$OUTDIR/bin/"
 cp -f o/$AMD64/ape/ape.elf "$OUTDIR/bin/ape-x86_64.elf"
 cp -f o/$AMD64/ape/ape.macho "$OUTDIR/bin/ape-x86_64.macho"
 cp -f o/$ARM64/ape/ape.elf "$OUTDIR/bin/ape-aarch64.elf"
-for x in assimilate march-native mktemper fixupobj zipcopy apelink pecheck mkdeps zipobj; do
-  ape $APELINK \
+
+for x in assimilate march-native mktemper fixupobj zipcopy apelink pecheck mkdeps zipobj \
+         ar chmod cocmd cp echo gzip objbincopy package rm touch mkdir compile sha256sum \
+         resymbol; do
+  $APE $APELINK \
     -l o/$AMD64/ape/ape.elf \
     -l o/$ARM64/ape/ape.elf \
     -M ape/ape-m1.c \
@@ -155,8 +334,13 @@ for x in assimilate march-native mktemper fixupobj zipcopy apelink pecheck mkdep
     o/$AMD64/tool/build/$x.dbg \
     o/$ARM64/tool/build/$x.dbg
 done
+
+for x in ar chmod cp echo gzip package rm touch mkdir compile sha256sum; do
+  mv "$OUTDIR/bin/$x" "$OUTDIR/bin/$x.ape"
+done
+
 for x in make ctags; do
-  ape $APELINK \
+  $APE $APELINK \
     -l o/$AMD64/ape/ape.elf \
     -l o/$ARM64/ape/ape.elf \
     -M ape/ape-m1.c \
diff --git a/tool/curl/curl.c b/tool/curl/curl.c
index c35812955..c108f0928 100644
--- a/tool/curl/curl.c
+++ b/tool/curl/curl.c
@@ -14,7 +14,7 @@
 #include "libc/errno.h"
 #include "libc/fmt/itoa.h"
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/tool/decode/BUILD.mk b/tool/decode/BUILD.mk
index 00318107c..d435d2e86 100644
--- a/tool/decode/BUILD.mk
+++ b/tool/decode/BUILD.mk
@@ -37,8 +37,10 @@ TOOL_DECODE_DIRECTDEPS =				\
 	LIBC_X						\
 	THIRD_PARTY_GDTOA				\
 	THIRD_PARTY_GETOPT				\
+	THIRD_PARTY_MUSL				\
 	THIRD_PARTY_TZ					\
 	THIRD_PARTY_XED					\
+	TOOL_BUILD_LIB					\
 	TOOL_DECODE_LIB
 
 TOOL_DECODE_DEPS :=					\
diff --git a/tool/decode/ar.c b/tool/decode/ar.c
index b1bd1892c..a4e7ee86e 100644
--- a/tool/decode/ar.c
+++ b/tool/decode/ar.c
@@ -110,9 +110,8 @@ static void Print(void) {
   printf("\n");
   printf("\t.long\t%-*.u# %s\n", 35, entries, "symbol table entries");
   table = 8 + 60 + 4;
-  for (i = 0; i < entries; ++i) {
+  for (i = 0; i < entries; ++i)
     printf("\t.long\t%#-*.x# %u\n", 35, READ32BE(data + table + i * 4), i);
-  }
   symbols = table + entries * 4;
   symbolslen = arsize - (entries + 1) * 4;
   for (i = o = 0; o < symbolslen; ++i, o += n + 1) {
diff --git a/tool/decode/ar2.c b/tool/decode/ar2.c
new file mode 100644
index 000000000..66e1fb74f
--- /dev/null
+++ b/tool/decode/ar2.c
@@ -0,0 +1,41 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/elf/elf.h"
+#include "libc/stdio/stdio.h"
+#include "tool/build/lib/ar.h"
+
+void ProcessFile(const char *path) {
+  struct Ar ar;
+  struct ArFile arf;
+  openar(&ar, path);
+  while (readar(&ar, &arf)) {
+    printf("%s: %s", path, arf.name);
+    if (IsElf64Binary(arf.data, arf.size))
+      printf(" is elf");
+    else
+      printf(" is not elf!!");
+    printf("\n");
+  }
+  closear(&ar);
+}
+
+int main(int argc, char *argv[]) {
+  for (int i = 1; i < argc; ++i)
+    ProcessFile(argv[i]);
+}
diff --git a/tool/decode/elf.c b/tool/decode/elf.c
index 741ad381f..2d62bab2e 100644
--- a/tool/decode/elf.c
+++ b/tool/decode/elf.c
@@ -26,10 +26,10 @@
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/libgen.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/tool/decode/ent.c b/tool/decode/ent.c
index ff4db3982..585452a61 100644
--- a/tool/decode/ent.c
+++ b/tool/decode/ent.c
@@ -30,6 +30,7 @@
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
+#include "libc/ctype.h"
 #include "third_party/getopt/getopt.internal.h"
 
 #define UPDATE  "January 28th, 2008"
diff --git a/tool/decode/lib/asmcodegen.c b/tool/decode/lib/asmcodegen.c
index 1e4520a3c..e63ea97fd 100644
--- a/tool/decode/lib/asmcodegen.c
+++ b/tool/decode/lib/asmcodegen.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "tool/decode/lib/asmcodegen.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/stdio.h"
diff --git a/tool/decode/lib/bitabuilder.c b/tool/decode/lib/bitabuilder.c
index 9fa598a81..f57a2d7cd 100644
--- a/tool/decode/lib/bitabuilder.c
+++ b/tool/decode/lib/bitabuilder.c
@@ -20,7 +20,7 @@
 #include "libc/assert.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
diff --git a/tool/decode/lib/disassemblehex.c b/tool/decode/lib/disassemblehex.c
index afa901259..d9859d890 100644
--- a/tool/decode/lib/disassemblehex.c
+++ b/tool/decode/lib/disassemblehex.c
@@ -19,7 +19,7 @@
 #include "tool/decode/lib/disassemblehex.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 static size_t countzeroes(const uint8_t *data, size_t size) {
   size_t i;
diff --git a/tool/decode/lib/machoidnames.c b/tool/decode/lib/machoidnames.c
index b2b1c5ecc..0755f31e3 100644
--- a/tool/decode/lib/machoidnames.c
+++ b/tool/decode/lib/machoidnames.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "tool/decode/lib/machoidnames.h"
-#include "libc/macho.internal.h"
+#include "libc/macho.h"
 
 const struct IdName kMachoArchitectures[] = {
     {MAC_CPU_MC680x0, "MAC_CPU_MC680x0"},              //
diff --git a/tool/decode/lib/zipnames.c b/tool/decode/lib/zipnames.c
index a5d834ff4..ae5ec5bcc 100644
--- a/tool/decode/lib/zipnames.c
+++ b/tool/decode/lib/zipnames.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "tool/decode/lib/zipnames.h"
 #include "libc/nt/enum/fileflagandattributes.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 
 const struct IdName kZipCompressionNames[] = {
     {kZipCompressionNone, "kZipCompressionNone"},
diff --git a/tool/decode/macho.c b/tool/decode/macho.c
index 736ad4078..b177d13aa 100644
--- a/tool/decode/macho.c
+++ b/tool/decode/macho.c
@@ -21,14 +21,14 @@
 #include "libc/calls/struct/stat.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/libgen.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/macho.internal.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/macho.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/sysv/consts/map.h"
 #include "libc/sysv/consts/o.h"
 #include "libc/sysv/consts/prot.h"
@@ -48,7 +48,7 @@ static size_t machosize;
 static void startfile(void) {
   showtitle("αcτµαlly pδrταblε εxεcµταblε", "tool/decode/macho", NULL, NULL,
             &kModelineAsm);
-  printf("#include \"libc/macho.internal.h\"\n\n", path);
+  printf("#include \"libc/macho.h\"\n\n", path);
 }
 
 static void showmachoheader(void) {
diff --git a/tool/decode/pe2.c b/tool/decode/pe2.c
index 7660aeee8..06ac8c888 100644
--- a/tool/decode/pe2.c
+++ b/tool/decode/pe2.c
@@ -20,7 +20,7 @@
 #include "libc/calls/struct/stat.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/libgen.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/struct/imagedosheader.internal.h"
diff --git a/tool/decode/unhex.c b/tool/decode/unhex.c
index c29e094aa..9440d5627 100644
--- a/tool/decode/unhex.c
+++ b/tool/decode/unhex.c
@@ -8,7 +8,7 @@
 #include "libc/calls/calls.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * @fileoverview Hex to binary converter program.
diff --git a/tool/decode/x86opinfo.c b/tool/decode/x86opinfo.c
index 79ac631e5..ee2d0bb11 100644
--- a/tool/decode/x86opinfo.c
+++ b/tool/decode/x86opinfo.c
@@ -16,12 +16,13 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/errno.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/sysv/consts/ex.h"
 #include "libc/sysv/consts/exit.h"
 #include "third_party/getopt/getopt.internal.h"
diff --git a/tool/decode/zip.c b/tool/decode/zip.c
index e0f8101f4..1d5d30ede 100644
--- a/tool/decode/zip.c
+++ b/tool/decode/zip.c
@@ -22,7 +22,7 @@
 #include "libc/fmt/libgen.h"
 #include "libc/fmt/wintime.internal.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
 #include "libc/mem/gc.h"
@@ -39,7 +39,7 @@
 #include "libc/sysv/consts/prot.h"
 #include "libc/time.h"
 #include "libc/x/xasprintf.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "tool/decode/lib/asmcodegen.h"
 #include "tool/decode/lib/disassemblehex.h"
 #include "tool/decode/lib/flagger.h"
@@ -78,7 +78,7 @@ char *xiso8601(struct timespec ts) {
   ptr += snprintf(ptr, end - ptr, "%09ld", ts.tv_nsec);
   ptr += strftime(ptr, end - ptr, "%z", &tm);
   unassert(ptr + 1 <= end);
-  unassert(realloc_in_place(res, ptr - end) == res);
+  unassert(realloc_in_place(res, ptr + 1 - res) == res);
   return res;
 }
 
diff --git a/tool/emacs/cosmo-asm-mode.el b/tool/emacs/cosmo-asm-mode.el
index b948e12af..98699ddf0 100644
--- a/tool/emacs/cosmo-asm-mode.el
+++ b/tool/emacs/cosmo-asm-mode.el
@@ -336,9 +336,10 @@
   (set (make-local-variable 'indent-tabs-mode) t)
   (set (make-local-variable 'tab-width) 8))
 
-(progn
-  (add-hook 'asm-mode-hook 'cosmo-asm-supplemental-hook)
-  (setq asm-font-lock-keywords cosmo-asm-font-lock-keywords))
+(eval-after-load 'asm-mode
+  '(progn
+     (add-hook 'asm-mode-hook 'cosmo-asm-supplemental-hook)
+     (setq asm-font-lock-keywords cosmo-asm-font-lock-keywords)))
 
 ;; Make -*-unix-assembly-*- mode line work correctly like GitHub.
 (define-derived-mode unix-assembly-mode asm-mode "UNIX Assembly")
diff --git a/tool/emacs/cosmo-c-builtins.el b/tool/emacs/cosmo-c-builtins.el
index ef7bfb4a4..bdb777018 100644
--- a/tool/emacs/cosmo-c-builtins.el
+++ b/tool/emacs/cosmo-c-builtins.el
@@ -46,6 +46,8 @@
 
         (gcc-builtin-functions
          '("__builtin_strlen"
+           "__builtin_memcpy"
+           "__builtin_memmove"
            "__builtin_setjmp"
            "__builtin_longjmp"
            "__builtin_va_start"
diff --git a/tool/emacs/cosmo-c-keywords.el b/tool/emacs/cosmo-c-keywords.el
index ff4acc144..e9a29cec5 100644
--- a/tool/emacs/cosmo-c-keywords.el
+++ b/tool/emacs/cosmo-c-keywords.el
@@ -218,7 +218,20 @@
            "__sysv_abi__"
            "__mode__"
            "__seg_fs"
-           "__seg_gs"))
+           "__seg_gs"
+           "__access__"
+           "__read_only__"
+           "__write_only__"
+           "__read_write__"
+           "__read_only"
+           "__write_only"
+           "__read_write"
+           "__fd_arg__"
+           "__fd_arg"
+           "__copy__"
+           "__retain__"
+           "__tainted_args__"
+           "__zero_call_used_regs__"))
 
         (clang
          '("__optnone__"
diff --git a/tool/emacs/cosmo-cpp-constants.el b/tool/emacs/cosmo-cpp-constants.el
index 5c244b7c0..80636c337 100644
--- a/tool/emacs/cosmo-cpp-constants.el
+++ b/tool/emacs/cosmo-cpp-constants.el
@@ -17,6 +17,7 @@
     "__GNUC__"
     "__APPLE__"
     "__linux__"
+    "__gnu_linux__"
     "__HAIKU__"
     "__CYGWIN__"
     "__EMSCRIPTEN__"
@@ -25,10 +26,13 @@
     "__NetBSD__"
     "__NetBSD_Version__"
     "__OpenBSD__"
+    "__Fuchsia__"
     "__COSMOPOLITAN__"
     "__COSMOCC__"
     "__FATCOSMOCC__"
     "__GLIBC__"
+    "__ELF__"
+    "__GNU__"
     "__linux"
     "__MACH__"
     "__GNUG__"
@@ -69,6 +73,7 @@
     "__BMI2__"
     "__FMA__"
     "__FAST_MATH__"
+    "__FINITE_MATH_ONLY__"
     "__ROUNDING_MATH__"
     "__NO_MATH_ERRNO__"
     "__FMA4__"
@@ -128,6 +133,8 @@
     "__ARM_FP16_IEEE"
     "__ARM_FP_FAST"
     "__powerpc__"
+    "__POWERPC__"
+    "__ppc__"
     "__powerpc64__"
     "__POWER9_VECTOR__"
     "__wasm_simd128__"
diff --git a/tool/emacs/cosmo-format.el b/tool/emacs/cosmo-format.el
index 107c201e9..140c9e2d2 100644
--- a/tool/emacs/cosmo-format.el
+++ b/tool/emacs/cosmo-format.el
@@ -104,7 +104,8 @@
                           cosmo-format-blacklist))
              (not (save-excursion
                     (beginning-of-buffer)
-                    (looking-at "/\\* clang-format off \\*/"))))
+                    (or (looking-at "/\\* clang-format off \\*/")
+                        (looking-at "// clang-format off")))))
     (let* ((bin (cosmo--find-clang-format-bin))
            (this (buffer-file-name))
            (root (locate-dominating-file this ".clang-format")))
diff --git a/tool/emacs/cosmo-platform-constants.el b/tool/emacs/cosmo-platform-constants.el
index caf232607..48b408b29 100644
--- a/tool/emacs/cosmo-platform-constants.el
+++ b/tool/emacs/cosmo-platform-constants.el
@@ -5,7 +5,6 @@
          '("__cplusplus"
            "__OBJC__"
            "__STRICT_ANSI__"
-           "__ELF__"
            "__VERSION__"
            "__OPTIMIZE__"
            "__OPTIMIZE_SIZE__"
@@ -29,6 +28,7 @@
            "__LP64__"
            "__SSP__"
            "__SSP_ALL__"
+           "__unix"
            "__unix__"
            "__vax__"
            "__ns16000__"
diff --git a/tool/emacs/cosmo-stuff.el b/tool/emacs/cosmo-stuff.el
index 1ca81f45a..ab45aeeb1 100644
--- a/tool/emacs/cosmo-stuff.el
+++ b/tool/emacs/cosmo-stuff.el
@@ -11,19 +11,19 @@
 
 ;;; Code:
 
-(require 'asm-mode)
-(require 'cc-mode)
-(require 'fortran)
-(require 'cosmo-c-types)
-(require 'cosmo-c-keywords)
-(require 'cosmo-c-builtins)
-(require 'cosmo-c-constants)
-(require 'cosmo-cpp-constants)
-(require 'cosmo-platform-constants)
-(require 'dired)
-(require 'javadown)
-(require 'ld-script)
-(require 'make-mode)
+;; (require 'asm-mode)
+;; (require 'cc-mode)
+;; (require 'fortran)
+;; (require 'cosmo-c-types)
+;; (require 'cosmo-c-keywords)
+;; (require 'cosmo-c-builtins)
+;; (require 'cosmo-c-constants)
+;; (require 'cosmo-cpp-constants)
+;; (require 'cosmo-platform-constants)
+;; (require 'dired)
+;; (require 'javadown)
+;; (require 'ld-script)
+;; (require 'make-mode)
 
 (setq cosmo-arch
       (let ((arch (string-trim-right
@@ -149,8 +149,12 @@
        (format "%s/TAGS"
                (or (locate-dominating-file (buffer-name) "Makefile")
                    (file-name-directory (buffer-name))))))
-(add-hook 'c-mode-common-hook 'stop-asking-questions-etags)
-(add-hook 'c++-mode-common-hook 'stop-asking-questions-etags)
+
+(eval-after-load 'cc-mode
+  '(progn
+     (add-hook 'c-mode-common-hook 'stop-asking-questions-etags)
+     (add-hook 'c++-mode-common-hook 'stop-asking-questions-etags)))
+
 (setq tags-revert-without-query t)
 (setq kill-buffer-query-functions ;; disable kill buffer w/ process question
       (delq 'process-kill-buffer-query-function kill-buffer-query-functions))
@@ -299,15 +303,30 @@
   (local-set-key (kbd "C-c C-c") 'cosmo-compile))
 
 (progn
-  (add-hook 'makefile-mode-hook 'cosmo-compile-hook)
-  (add-hook 'asm-mode-hook 'cosmo-compile-hook)
-  (add-hook 'ld-script-mode-hook 'cosmo-compile-hook)
-  (add-hook 'dired-mode-hook 'cosmo-compile-hook)
-  (add-hook 'c-mode-common-hook 'cosmo-compile-hook)
-  (add-hook 'c++-mode-common-hook 'cosmo-compile-hook)
   (add-hook 'fortran-mode-hook 'cosmo-compile-hook)
   (add-hook 'protobuf-mode-hook 'cosmo-compile-hook))
 
+(eval-after-load 'make-mode
+  '(progn
+     (add-hook 'makefile-mode-hook 'cosmo-compile-hook)))
+
+(eval-after-load 'asm-mode
+  '(progn
+     (add-hook 'asm-mode-hook 'cosmo-compile-hook)))
+
+(eval-after-load 'dired
+  '(progn
+     (add-hook 'dired-mode-hook 'cosmo-compile-hook)))
+
+(eval-after-load 'ld-script
+  '(progn
+     (add-hook 'ld-script-mode-hook 'cosmo-compile-hook)))
+
+(eval-after-load 'cc-mode
+  '(progn
+     (add-hook 'c-mode-common-hook 'cosmo-compile-hook)
+     (add-hook 'c++-mode-common-hook 'cosmo-compile-hook)))
+
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Display assembly for C/C++ buffer
@@ -606,10 +625,13 @@
   (add-hook 'asm-mode-hook 'cosmo-assemble-hook)
   (add-hook 'ld-script-mode-hook 'cosmo-assemble-hook)
   (add-hook 'dired-mode-hook 'cosmo-assemble-hook)
-  (add-hook 'c-mode-common-hook 'cosmo-assemble-hook)
   (add-hook 'fortran-mode-hook 'cosmo-assemble-hook)
   (add-hook 'protobuf-mode-hook 'cosmo-assemble-hook))
 
+(eval-after-load 'cc-mode
+  '(progn
+     (add-hook 'c-mode-common-hook 'cosmo-assemble-hook)))
+
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Run buffer.
@@ -688,18 +710,34 @@
               ('t
                (error "cosmo-run: unknown major mode")))))))
 
-(progn
-  (define-key asm-mode-map (kbd "C-c C-r") 'cosmo-run)
-  (define-key c-mode-base-map (kbd "C-c C-r") 'cosmo-run)
-  (define-key fortran-mode-map (kbd "C-c C-r") 'cosmo-run)
-  (define-key sh-mode-map (kbd "C-c C-r") 'cosmo-run)
-  (define-key lua-mode-map (kbd "C-c C-r") 'cosmo-run)
-  (define-key python-mode-map (kbd "C-c C-r") 'cosmo-run)
-  (define-key c-mode-map (kbd "C-c C-s") 'cosmo-run-test)
-  (define-key c++-mode-map (kbd "C-c C-s") 'cosmo-run-test)
-  (define-key c-mode-map (kbd "C-c C-_") 'cosmo-run-win7)
-  (define-key c-mode-map (kbd "C-c C-_") 'cosmo-run-win10)
-  (define-key c++-mode-map (kbd "C-c C-_") 'cosmo-run-win10))
+(eval-after-load 'cc-mode
+  '(progn
+     (define-key c-mode-base-map (kbd "C-c C-r") 'cosmo-run)
+     (define-key c-mode-map (kbd "C-c C-s") 'cosmo-run-test)
+     (define-key c++-mode-map (kbd "C-c C-s") 'cosmo-run-test)
+     (define-key c-mode-map (kbd "C-c C-_") 'cosmo-run-win7)
+     (define-key c-mode-map (kbd "C-c C-_") 'cosmo-run-win10)
+     (define-key c++-mode-map (kbd "C-c C-_") 'cosmo-run-win10)))
+
+(eval-after-load 'fortran-mode
+  '(progn
+     (define-key fortran-mode-map (kbd "C-c C-r") 'cosmo-run)))
+
+(eval-after-load 'asm-mode
+  '(progn
+     (define-key asm-mode-map (kbd "C-c C-r") 'cosmo-run)))
+
+(eval-after-load 'sh-script
+  '(progn
+     (define-key sh-mode-map (kbd "C-c C-r") 'cosmo-run)))
+
+(eval-after-load 'lua-mode
+  '(progn
+     (define-key lua-mode-map (kbd "C-c C-r") 'cosmo-run)))
+
+(eval-after-load 'python
+  '(progn
+     (define-key python-mode-map (kbd "C-c C-r") 'cosmo-run)))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -725,9 +763,13 @@
         (compile compile-command)
         (gdb (format "gdb -q -i=mi %s -ex run" exec))))))
 
-(progn
-  (define-key asm-mode-map (kbd "C-c C-d") 'cosmo-debug)
-  (define-key c-mode-base-map (kbd "C-c C-d") 'cosmo-debug))
+(eval-after-load 'cc-mode
+  '(progn
+     (define-key c-mode-base-map (kbd "C-c C-d") 'cosmo-debug)))
+
+(eval-after-load 'asm-mode
+  '(progn
+     (define-key asm-mode-map (kbd "C-c C-d") 'cosmo-debug)))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -771,7 +813,9 @@
                                                dots (cosmo-file-name-sans-extensions name))))
                        (if (file-exists-p cc-version)
                            cc-version
-                         c-version))
+                         (if (eq major-mode 'c++-mode)
+                             cc-version
+                           c-version)))
                      ))))
         (when buddy
           (find-file buddy))))))
@@ -817,10 +861,16 @@
       (message header))))
 
 (progn
-  (define-key prog-mode-map (kbd "C-c C-h") 'cosmo-add-include)
-  (define-key asm-mode-map (kbd "C-c C-h") 'cosmo-add-include)
-  (define-key c-mode-base-map (kbd "C-c C-h") 'cosmo-add-include)
-  (define-key c++-mode-map (kbd "C-c C-h") 'cosmo-add-include))
+  (define-key prog-mode-map (kbd "C-c C-h") 'cosmo-add-include))
+
+(eval-after-load 'cc-mode
+  '(progn
+     (define-key c-mode-base-map (kbd "C-c C-h") 'cosmo-add-include)
+     (define-key c++-mode-map (kbd "C-c C-h") 'cosmo-add-include)))
+
+(eval-after-load 'asm-mode
+  '(progn
+     (define-key asm-mode-map (kbd "C-c C-h") 'cosmo-add-include)))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -841,11 +891,17 @@
 
 (defun cosmo-lisp-is-the-best ()
   (define-key c-mode-base-map (kbd "C-c C-o") 'cosmo-show-optinfo))
-(add-hook 'c-mode-common-hook 'cosmo-lisp-is-the-best)
+
+(eval-after-load 'cc-mode
+  '(progn
+     (add-hook 'c-mode-common-hook 'cosmo-lisp-is-the-best)))
 
 (defun cosmo-lisp-is-the-best++ ()
   (define-key c++-mode-base-map (kbd "C-c C-o") 'cosmo-show-optinfo))
-(add-hook 'c++-mode-common-hook 'cosmo-lisp-is-the-best++)
+
+(eval-after-load 'cc-mode
+  '(progn
+     (add-hook 'c++-mode-common-hook 'cosmo-lisp-is-the-best++)))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -865,8 +921,8 @@
    nil `((,cosmo-cpp-constants-regex . font-lock-constant-face)
          (,cosmo-platform-constants-regex . font-lock-constant-face))))
 
-(add-hook 'c-mode-common-hook 'cosmo-c-keywords-hook)
-(add-hook 'c++-mode-common-hook 'cosmo-c-keywords-hook)
+;; (add-hook 'c-mode-common-hook 'cosmo-c-keywords-hook)
+;; (add-hook 'c++-mode-common-hook 'cosmo-c-keywords-hook)
 (add-hook 'asm-mode-hook 'cosmo-asm-keywords-hook)
 
 
diff --git a/tool/emacs/cosmo.el b/tool/emacs/cosmo.el
index 88fb36d7f..704bd9b39 100644
--- a/tool/emacs/cosmo.el
+++ b/tool/emacs/cosmo.el
@@ -1,7 +1,7 @@
-(require 'ld-script)
-(require 'optinfo-mode)
-(require 'protobuf-mode)
+;; (require 'ld-script)
+;; (require 'optinfo-mode)
+;; (require 'protobuf-mode)
 (require 'cosmo-format)
-(require 'cosmo-asm-mode)
+;; (require 'cosmo-asm-mode)
 (require 'cosmo-stuff)
 (provide 'cosmo)
diff --git a/tool/hello/BUILD.mk b/tool/hello/BUILD.mk
index 80648401c..aff7a82c0 100644
--- a/tool/hello/BUILD.mk
+++ b/tool/hello/BUILD.mk
@@ -79,7 +79,7 @@ o/$(MODE)/tool/hello/hello-pe.ape:			\
 # elf2pe can generate binaries that don't have dll imports
 o/$(MODE)/tool/hello/life-pe.dbg:			\
 		o/$(MODE)/tool/hello/life-pe.o
-	@$(COMPILE) -ALINK.elf $(LINK) $(LINKARGS) $(OUTPUT_OPTION) -q -e WinMain
+	@$(COMPILE) -ALINK.elf $(LINK) $(LINKARGS) $(OUTPUT_OPTION) -q -e WinMain -Ttext-segment=0x140000000
 o/$(MODE)/tool/hello/life-pe.ape:			\
 		o/$(MODE)/tool/hello/life-pe.dbg	\
 		o/$(MODE)/tool/build/elf2pe
@@ -94,4 +94,6 @@ o/$(MODE)/tool/hello/wait-pe.ape:			\
 		o/$(MODE)/tool/build/elf2pe
 	@$(COMPILE) -AELF2PE o/$(MODE)/tool/build/elf2pe -R 64kb -S 4kb -o $@ $<
 
+o/$(MODE)/tool/hello/life-pe.ape.zip.o: private ZIPOBJ_FLAGS += -B
+
 $(TOOL_HELLO_OBJS): tool/hello/BUILD.mk
diff --git a/tool/hello/hello-pe.c b/tool/hello/hello-pe.c
index c54ce5e08..47198ee76 100644
--- a/tool/hello/hello-pe.c
+++ b/tool/hello/hello-pe.c
@@ -7,6 +7,7 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
+#include "libc/nt/thunk/msabi.h"
 #include "tool/build/elf2pe.h"
 
 #define STD_OUTPUT_HANDLE -11u
@@ -15,7 +16,7 @@ __dll_import("kernel32.dll", long, GetStdHandle, (unsigned));
 __dll_import("kernel32.dll", int, WriteFile,
              (long, const void *, unsigned, unsigned *, void *));
 
-__attribute__((__ms_abi__)) long WinMain(void) {
+__msabi long WinMain(void) {
   WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), "hello world\n", 12, 0, 0);
   return 0;
 }
diff --git a/tool/hello/life-pe.c b/tool/hello/life-pe.c
index 6f6098d1d..5786749af 100644
--- a/tool/hello/life-pe.c
+++ b/tool/hello/life-pe.c
@@ -7,7 +7,8 @@
 │   • http://creativecommons.org/publicdomain/zero/1.0/            │
 ╚─────────────────────────────────────────────────────────────────*/
 #endif
+#include "libc/nt/thunk/msabi.h"
 
-__attribute__((__ms_abi__)) long WinMain(void) {
+__msabi long WinMain(void) {
   return 42 << 8;
 }
diff --git a/tool/lambda/BUILD.mk b/tool/lambda/BUILD.mk
index a22b63aea..aca58f545 100644
--- a/tool/lambda/BUILD.mk
+++ b/tool/lambda/BUILD.mk
@@ -28,6 +28,7 @@ TOOL_LAMBDA_DIRECTDEPS =					\
 	LIBC_SYSV						\
 	LIBC_X							\
 	THIRD_PARTY_GETOPT					\
+	THIRD_PARTY_MUSL					\
 	TOOL_LAMBDA_LIB
 
 TOOL_LAMBDA_DEPS :=						\
diff --git a/tool/lambda/bru2bin.c b/tool/lambda/bru2bin.c
index 2516ff0f9..dd317af19 100644
--- a/tool/lambda/bru2bin.c
+++ b/tool/lambda/bru2bin.c
@@ -23,6 +23,7 @@
 #include "libc/stdio/stdio.h"
 #include "libc/str/locale.h"
 #include "libc/str/str.h"
+#include "libc/wctype.h"
 #include "third_party/getopt/getopt.internal.h"
 
 #define USAGE \
diff --git a/tool/lambda/lam2bin.c b/tool/lambda/lam2bin.c
index 9c8dd8fb5..3e0efb9a2 100644
--- a/tool/lambda/lam2bin.c
+++ b/tool/lambda/lam2bin.c
@@ -17,12 +17,14 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
+#include "libc/ctype.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/locale.h"
 #include "libc/str/str.h"
+#include "libc/wctype.h"
 #include "third_party/getopt/getopt.internal.h"
 
 #define USAGE \
diff --git a/tool/lambda/lib/calloc.c b/tool/lambda/lib/calloc.c
index c09ddd3c5..185c91d33 100644
--- a/tool/lambda/lib/calloc.c
+++ b/tool/lambda/lib/calloc.c
@@ -28,14 +28,14 @@ void *Calloc(size_t a, size_t b) {
   static size_t n;
   z = a * b;
   if (!p) {
-    n = __granularity();
-    p = mmap((void *)0x300000000000, __granularity(), PROT_READ | PROT_WRITE,
+    n = getgransize();
+    p = mmap((void *)0x300000000000, getgransize(), PROT_READ | PROT_WRITE,
              MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);
   }
   if (i + z > n) {
-    mmap(p + i, __granularity(), PROT_READ | PROT_WRITE,
+    mmap(p + i, getgransize(), PROT_READ | PROT_WRITE,
          MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1, 0);
-    n += __granularity();
+    n += getgransize();
   }
   r = p + i;
   i += z;
diff --git a/tool/lambda/lib/debug.c b/tool/lambda/lib/debug.c
index f841a1ac3..8a6ea7a43 100644
--- a/tool/lambda/lib/debug.c
+++ b/tool/lambda/lib/debug.c
@@ -16,6 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/ctype.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/str/str.h"
diff --git a/tool/lambda/lib/getbit.c b/tool/lambda/lib/getbit.c
index 8c64eff0f..db22a1a67 100644
--- a/tool/lambda/lib/getbit.c
+++ b/tool/lambda/lib/getbit.c
@@ -17,6 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/str/str.h"
+#include "libc/wctype.h"
 #include "tool/lambda/lib/blc.h"
 
 char GetBit(FILE* f) {
diff --git a/tool/lambda/tromp.c b/tool/lambda/tromp.c
index b9dfbd32b..84a788bc3 100644
--- a/tool/lambda/tromp.c
+++ b/tool/lambda/tromp.c
@@ -4,6 +4,14 @@
 #include "libc/runtime/runtime.h"
 #include "tool/lambda/lib/blc.h"
 
+#if defined __GNUC__ && __GNUC__ >= 14
+#pragma GCC diagnostic ignored "-Wimplicit-function-declaration"
+#pragma GCC diagnostic ignored "-Wincompatible-pointer-types"
+#pragma GCC diagnostic ignored "-Wreturn-mismatch"
+#pragma GCC diagnostic ignored "-Wint-conversion"
+#pragma GCC diagnostic ignored "-Wimplicit-int"
+#endif
+
 #define A   500000
 #define X   8
 #define Int long
diff --git a/tool/net/BUILD.mk b/tool/net/BUILD.mk
index 52d55f7ec..06a80d5f8 100644
--- a/tool/net/BUILD.mk
+++ b/tool/net/BUILD.mk
@@ -117,7 +117,8 @@ o/$(MODE)/tool/net/redbean.dbg:						\
 
 o/$(MODE)/tool/net/lsqlite3.o: private					\
 		CFLAGS +=						\
-			-DSQLITE_ENABLE_SESSION
+			-DSQLITE_ENABLE_SESSION				\
+			-DSQLITE_ENABLE_DESERIALIZE
 
 # REDBEAN-DEMO
 #
diff --git a/tool/net/definitions.lua b/tool/net/definitions.lua
index f6fecffda..3732416b0 100644
--- a/tool/net/definitions.lua
+++ b/tool/net/definitions.lua
@@ -1981,6 +1981,10 @@ function Underlong(str) end
 --- @return string
 function UuidV4() end
 
+--- Generate a uuid_v7
+--- @return string
+function UuidV7() end
+
 ---@param x integer
 ---@return integer # position of first bit set.
 --- Passing `0` will raise an error. Same as the Intel x86 instruction BSF.
@@ -4125,38 +4129,22 @@ unix = {
     CLK_TCK = nil,
 
     --- @type integer
-    CLOCK_BOOTTIME = nil,
-    --- @type integer
-    CLOCK_BOOTTIME_ALARM = nil,
+    CLOCK_REALTIME = nil,
     --- @type integer
     CLOCK_MONOTONIC = nil,
     --- @type integer
-    CLOCK_MONOTONIC_COARSE = nil,
-    --- @type integer
-    CLOCK_MONOTONIC_PRECISE = nil,
-    --- @type integer
-    CLOCK_MONOTONIC_FAST = nil,
+    CLOCK_BOOTTIME = nil,
     --- @type integer
     CLOCK_MONOTONIC_RAW = nil,
     --- @type integer
-    CLOCK_PROCESS_CPUTIME_ID = nil,
-    --- @type integer
-    CLOCK_PROF = nil,
-    --- @type integer
-    CLOCK_REALTIME = nil,
-    --- @type integer
-    CLOCK_REALTIME_PRECISE = nil,
-    --- @type integer
-    CLOCK_REALTIME_ALARM = nil,
-    --- @type integer
     CLOCK_REALTIME_COARSE = nil,
     --- @type integer
-    CLOCK_REALTIME_FAST = nil,
-    --- @type integer
-    CLOCK_TAI = nil,
+    CLOCK_MONOTONIC_COARSE = nil,
     ---@type integer
     CLOCK_THREAD_CPUTIME_ID = nil,
     --- @type integer
+    CLOCK_PROCESS_CPUTIME_ID = nil,
+    --- @type integer
     DT_BLK = nil,
     --- @type integer
     DT_CHR = nil,
@@ -5200,11 +5188,14 @@ function unix.fork() end
 ---     unix.execve(prog, {prog, '-hal', '.'}, {'PATH=/bin'})
 ---     unix.exit(127)
 ---
---- We automatically suffix `.com` and `.exe` for all platforms when
---- path searching. By default, the current directory is not on the
---- path. If `prog` is an absolute path, then it's returned as-is. If
---- `prog` contains slashes then it's not path searched either and will
---- be returned if it exists.
+--- If `prog` is an absolute path, then it's returned as-is. If `prog`
+--- contains slashes then it's not path searched either and will be
+--- returned if it exists. On Windows, it's recommended that you install
+--- programs from cosmos to c:/bin/ without any .exe or .com suffix, so
+--- they can be discovered like they would on UNIX. If you want to find
+--- a program like notepad on the $PATH using this function, then you
+--- need to specify "notepad.exe" so it includes the extension.
+---
 ---@param prog string
 ---@return string path
 ---@overload fun(prog: string): nil, error: unix.Errno
@@ -6093,23 +6084,73 @@ function unix.syslog(priority, msg) end
 ---
 --- `clock` can be any one of of:
 ---
---- - `CLOCK_REALTIME`: universally supported
---- - `CLOCK_REALTIME_FAST`: ditto but faster on freebsd
---- - `CLOCK_REALTIME_PRECISE`: ditto but better on freebsd
---- - `CLOCK_REALTIME_COARSE`: : like `CLOCK_REALTIME_FAST` but needs Linux 2.6.32+
---- - `CLOCK_MONOTONIC`: universally supported
---- - `CLOCK_MONOTONIC_FAST`: ditto but faster on freebsd
---- - `CLOCK_MONOTONIC_PRECISE`: ditto but better on freebsd
---- - `CLOCK_MONOTONIC_COARSE`: : like `CLOCK_MONOTONIC_FAST` but needs Linux 2.6.32+
---- - `CLOCK_MONOTONIC_RAW`: is actually monotonic but needs Linux 2.6.28+
---- - `CLOCK_PROCESS_CPUTIME_ID`: linux and bsd
---- - `CLOCK_THREAD_CPUTIME_ID`: linux and bsd
---- - `CLOCK_MONOTONIC_COARSE`: linux, freebsd
---- - `CLOCK_PROF`: linux and netbsd
---- - `CLOCK_BOOTTIME`: linux and openbsd
---- - `CLOCK_REALTIME_ALARM`: linux-only
---- - `CLOCK_BOOTTIME_ALARM`: linux-only
---- - `CLOCK_TAI`: linux-only
+--- - `CLOCK_REALTIME` returns a wall clock timestamp represented in
+---   nanoseconds since the UNIX epoch (~1970). It'll count time in the
+---   suspend state. This clock is subject to being smeared by various
+---   adjustments made by NTP. These timestamps can have unpredictable
+---   discontinuous jumps when clock_settime() is used. Therefore this
+---   clock is the default clock for everything, even pthread condition
+---   variables. Cosmopoiltan guarantees this clock will never raise
+---   `EINVAL` and also guarantees `CLOCK_REALTIME == 0` will always be
+---   the case. On Windows this maps to GetSystemTimePreciseAsFileTime().
+---   On platforms with vDSOs like Linux, Windows, and MacOS ARM64 this
+---   should take about 20 nanoseconds.
+---
+--- - `CLOCK_MONOTONIC` returns a timestamp with an unspecified epoch,
+---   that should be when the system was powered on. These timestamps
+---   shouldn't go backwards. Timestamps shouldn't count time spent in
+---   the sleep, suspend, and hibernation states. These timestamps won't
+---   be impacted by clock_settime(). These timestamps may be impacted by
+---   frequency adjustments made by NTP. Cosmopoiltan guarantees this
+---   clock will never raise `EINVAL`. MacOS and BSDs use the word
+---   "uptime" to describe this clock. On Windows this maps to
+---   QueryUnbiasedInterruptTimePrecise().
+---
+--- - `CLOCK_BOOTTIME` is a monotonic clock returning a timestamp with an
+---   unspecified epoch, that should be relative to when the host system
+---   was powered on. These timestamps shouldn't go backwards. Timestamps
+---   should also include time spent in a sleep, suspend, or hibernation
+---   state. These timestamps aren't impacted by clock_settime(), but
+---   they may be impacted by frequency adjustments made by NTP. This
+---   clock will raise an `EINVAL` error on extremely old Linux distros
+---   like RHEL5. MacOS and BSDs use the word "monotonic" to describe
+---   this clock. On Windows this maps to QueryInterruptTimePrecise().
+---
+--- - `CLOCK_MONOTONIC_RAW` returns a timestamp from an unspecified
+---   epoch. These timestamps don't count time spent in the sleep,
+---   suspend, and hibernation states. Unlike `CLOCK_MONOTONIC` this
+---   clock is guaranteed to not be impacted by frequency adjustments or
+---   discontinuous jumps caused by clock_settime(). Providing this level
+---   of assurances may make this clock slower than the normal monotonic
+---   clock. Furthermore this clock may cause `EINVAL` to be raised if
+---   running on a host system that doesn't provide those guarantees,
+---   e.g. OpenBSD and MacOS on AMD64.
+---
+--- - `CLOCK_REALTIME_COARSE` is the same as `CLOCK_REALTIME` except
+---   it'll go faster if the host OS provides a cheaper way to read the
+---   wall time. Please be warned that coarse can be really coarse.
+---   Rather than nano precision, you're looking at `CLK_TCK` precision,
+---   which can lag as far as 30 milliseconds behind or possibly more.
+---   Cosmopolitan may fallback to `CLOCK_REALTIME` if a faster less
+---   accurate clock isn't provided by the system. This clock will raise
+---   an `EINVAL` error on extremely old Linux distros like RHEL5.
+---
+--- - `CLOCK_MONOTONIC_COARSE` is the same as `CLOCK_MONOTONIC` except
+---   it'll go faster if the host OS provides a cheaper way to read the
+---   unbiased time. Please be warned that coarse can be really coarse.
+---   Rather than nano precision, you're looking at `CLK_TCK` precision,
+---   which can lag as far as 30 milliseconds behind or possibly more.
+---   Cosmopolitan may fallback to `CLOCK_REALTIME` if a faster less
+---   accurate clock isn't provided by the system. This clock will raise
+---   an `EINVAL` error on extremely old Linux distros like RHEL5.
+---
+--- - `CLOCK_PROCESS_CPUTIME_ID` returns the amount of time this process
+---   was actively scheduled. This is similar to getrusage() and clock().
+---   Cosmopoiltan guarantees this clock will never raise `EINVAL`.
+---
+--- - `CLOCK_THREAD_CPUTIME_ID` returns the amount of time this thread
+---   was actively scheduled. This is similar to getrusage() and clock().
+---   Cosmopoiltan guarantees this clock will never raise `EINVAL`.
 ---
 --- Returns `EINVAL` if clock isn't supported on platform.
 ---
diff --git a/tool/net/fetch.inc b/tool/net/fetch.inc
index 16fa05a56..8be5775b0 100644
--- a/tool/net/fetch.inc
+++ b/tool/net/fetch.inc
@@ -378,7 +378,7 @@ static int LuaFetch(lua_State *L) {
           WARNF("(ftch) HTTP client %s error", "EOF headers");
           goto TransportError;
         }
-        rc = ParseHttpMessage(&msg, inbuf.p, inbuf.n, inbuf.c);
+        rc = ParseHttpMessage(&msg, inbuf.p, inbuf.n, SHRT_MAX);
         if (rc == -1) {
           WARNF("(ftch) HTTP client %s error", "ParseHttpMessage");
           goto TransportError;
diff --git a/tool/net/getadaptersaddresses.c b/tool/net/getadaptersaddresses.c
index 91ddbfa94..8dea1ab97 100644
--- a/tool/net/getadaptersaddresses.c
+++ b/tool/net/getadaptersaddresses.c
@@ -35,7 +35,7 @@
 #include "libc/serialize.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/sockaddr6.h"
-#include "libc/stdalign.internal.h"
+#include "libc/stdalign.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
 #include "libc/sysv/consts/af.h"
diff --git a/tool/net/help.txt b/tool/net/help.txt
index 4ea0be1f8..ab017578b 100644
--- a/tool/net/help.txt
+++ b/tool/net/help.txt
@@ -1,6 +1,6 @@
 SYNOPSIS
 
-  redbean [-?BVabdfghjkmsuvz] [-p PORT] [-D DIR] [-- SCRIPTARGS...]
+  redbean.com [-?BVabdfghjkmsuvz] [-p PORT] [-D DIR] [-- SCRIPTARGS...]
 
 DESCRIPTION
 
@@ -137,15 +137,15 @@ USAGE
   This executable is also a ZIP file that contains static assets.
   You can run redbean interactively in your terminal as follows:
 
-    ./redbean -vvvmbag        # starts server verbosely
+    ./redbean.com -vvvmbag        # starts server verbosely
     open http://127.0.0.1:8080/   # shows zip listing page
     CTRL-C                        # 1x: graceful shutdown
     CTRL-C                        # 2x: forceful shutdown
 
   You can override the default listing page by adding:
 
-    zip redbean index.lua     # lua server pages take priority
-    zip redbean index.html    # default page for directory
+    zip redbean.com index.lua     # lua server pages take priority
+    zip redbean.com index.html    # default page for directory
 
   The listing page only applies to the root directory. However the
   default index page applies to subdirectories too. In order for it
@@ -160,7 +160,7 @@ USAGE
       --no-parent            \
       --no-if-modified-since \
       http://a.example/index.html
-    zip -r redbean a.example/  # default page for directory
+    zip -r redbean.com a.example/  # default page for directory
 
   redbean normalizes the trailing slash for you automatically:
 
@@ -198,18 +198,18 @@ USAGE
   by default, embedded as a bas64 data uri. You can override the
   custom page for various errors by adding files to the zip root.
 
-    zip redbean 404.html      # custom not found page
+    zip redbean.com 404.html      # custom not found page
 
   Audio video content should not be compressed in your ZIP files.
   Uncompressed assets enable browsers to send Range HTTP request.
   On the other hand compressed assets are best for gzip encoding.
 
-    zip redbean index.html    # adds file
-    zip -0 redbean video.mp4  # adds without compression
+    zip redbean.com index.html    # adds file
+    zip -0 redbean.com video.mp4  # adds without compression
 
   You can have redbean run as a daemon by doing the following:
 
-    sudo ./redbean -vvdp80 -p443 -L redbean.log -P redbean.pid
+    sudo ./redbean.com -vvdp80 -p443 -L redbean.log -P redbean.pid
     kill -TERM $(cat redbean.pid) # 1x: graceful shutdown
     kill -TERM $(cat redbean.pid) # 2x: forceful shutdown
 
@@ -230,14 +230,7 @@ USAGE
   run on six different operating systems. To do that, it needs to
   extract a 4kb loader program to ${TMPDIR:-${HOME:-.}}/.ape that'll
   map your redbean into memory. It does however check to see if `ape`
-  is on the system path beforehand. You can also "assimilate" any
-  redbean into the platform-local executable format by running:
-
-      $ file redbean
-      redbean: DOS/MBR boot sector
-      $ ./redbean --assimilate
-      $ file redbean
-      redbean: ELF 64-bit LSB executable
+  is on the system path beforehand.
 
 ────────────────────────────────────────────────────────────────────────────────
 SECURITY
@@ -406,12 +399,14 @@ REPL
   encoded in its preferred executable format. You can assimilate your
   redbean into the local format using the following commands:
 
-      $ file redbean
-      redbean: DOS/MBR boot sector
-      $ ./redbean --assimilate
-      $ file redbean
-      redbean: ELF 64-bit LSB executable
-      $ sudo cp redbean /usr/bin/redbean
+      $ file redbean.com
+      redbean.com: DOS/MBR boot sector
+      $ curl -o assimilate https://cosmo.zip/pub/cosmos/bin/assimilate
+      $ chmod +x assimilate
+      $ ./assimilate ./redbean.com
+      $ file redbean.com
+      redbean.com: ELF 64-bit LSB executable
+      $ sudo cp redbean.com /usr/bin/redbean
 
   By following the above steps, redbean can be installed systemwide for
   multiple user accounts. It's also possible to chmod the binary to have
@@ -461,7 +456,7 @@ GLOBALS
 
           Then your `/.init.lua` file will have the `arg` array like:
 
-              arg[-1] = '/usr/bin/redbean'
+              arg[-1] = '/usr/bin/redbean
               arg[ 0] = '/zip/.init.lua'
               arg[ 1] = 'arg1'
               arg[ 2] = 'arg2'
@@ -469,11 +464,11 @@ GLOBALS
           If you launch redbean in interpreter mode (rather than web
           server) mode, then an invocation like this:
 
-              ./redbean -i script.lua arg1 arg2
+              ./redbean.com -i script.lua arg1 arg2
 
           Would have an `arg` array like this:
 
-              arg[-1] = './redbean'
+              arg[-1] = './redbean.com'
               arg[ 0] = 'script.lua'
               arg[ 1] = 'arg1'
               arg[ 2] = 'arg2'
@@ -574,7 +569,7 @@ HOOKS
           *). See functions like Route which asks redbean to do its default
           thing from the handler.
 
-  OnError(status:int, message:string)
+  OnError(status:int, message:string, details:string)
           If this function is defined and if any errors occurs in
           OnHttpRequest() then this method will be called instead of displaying
           the default error page. Useful if you need to display the error page
@@ -586,10 +581,10 @@ HOOKS
           `true`, redbean will close the connection without calling fork.
 
   OnLogLatency(reqtimeus:int, contimeus:int)
-          If this function is defined it'll be called from the main process
-          each time redbean completes handling of a request, but before the
-          response is sent. The handler received the time (in µs) since the
-          request handling and connection handling started.
+          If this function is defined it'll be called from the child worker
+          process each time redbean completes the handling of a request, but
+          before the response is sent. The handler receives the time (in µs)
+          since the request handling and connection handling started.
 
   OnProcessCreate(pid:int, ip:int, port:int, serverip:int, serverport:int)
           If this function is defined it'll be called from the main process
@@ -1063,7 +1058,10 @@ FUNCTIONS
           This function is not available in unsecure mode.
 
   UuidV4() -> str
-          Returns an uuid v4 string.
+          Returns a uuid v4 string.
+
+  UuidV7() -> str
+          Returns a uuid v7 string.
 
   Fetch(url:str[,body:str|{method=value:str,body=value:str,headers=table,...}])
       ├─→ status:int, {header:str=value:str,...}, body:str
@@ -2879,11 +2877,13 @@ UNIX MODULE
         unix.execve(prog, {prog, '-hal', '.'}, {'PATH=/bin'})
         unix.exit(127)
 
-    We automatically suffix `.com` and `.exe` for all platforms when
-    path searching. By default, the current directory is not on the
-    path. If `prog` is an absolute path, then it's returned as-is. If
-    `prog` contains slashes then it's not path searched either and will
-    be returned if it exists.
+    If `prog` is an absolute path, then it's returned as-is. If `prog`
+    contains slashes then it's not path searched either and will be
+    returned if it exists. On Windows, it's recommended that you install
+    programs from cosmos to c:/bin/ without any .exe or .com suffix, so
+    they can be discovered like they would on UNIX. If you want to find
+    a program like notepad on the $PATH using this function, then you
+    need to specify "notepad.exe" so it includes the extension.
 
   unix.execve(prog:str[, args:List<*>, env:List<*>])
       └─→ nil, unix.Errno
@@ -3675,23 +3675,73 @@ UNIX MODULE
 
     `clock` can be any one of of:
 
-    - `CLOCK_REALTIME`: universally supported
-    - `CLOCK_REALTIME_FAST`: ditto but faster on freebsd
-    - `CLOCK_REALTIME_PRECISE`: ditto but better on freebsd
-    - `CLOCK_REALTIME_COARSE`: : like `CLOCK_REALTIME_FAST` but needs Linux 2.6.32+
-    - `CLOCK_MONOTONIC`: universally supported
-    - `CLOCK_MONOTONIC_FAST`: ditto but faster on freebsd
-    - `CLOCK_MONOTONIC_PRECISE`: ditto but better on freebsd
-    - `CLOCK_MONOTONIC_COARSE`: : like `CLOCK_MONOTONIC_FAST` but needs Linux 2.6.32+
-    - `CLOCK_MONOTONIC_RAW`: is actually monotonic but needs Linux 2.6.28+
-    - `CLOCK_PROCESS_CPUTIME_ID`: linux and bsd
-    - `CLOCK_THREAD_CPUTIME_ID`: linux and bsd
-    - `CLOCK_MONOTONIC_COARSE`: linux, freebsd
-    - `CLOCK_PROF`: linux and netbsd
-    - `CLOCK_BOOTTIME`: linux and openbsd
-    - `CLOCK_REALTIME_ALARM`: linux-only
-    - `CLOCK_BOOTTIME_ALARM`: linux-only
-    - `CLOCK_TAI`: linux-only
+    - `CLOCK_REALTIME` returns a wall clock timestamp represented in
+      nanoseconds since the UNIX epoch (~1970). It'll count time in the
+      suspend state. This clock is subject to being smeared by various
+      adjustments made by NTP. These timestamps can have unpredictable
+      discontinuous jumps when clock_settime() is used. Therefore this
+      clock is the default clock for everything, even pthread condition
+      variables. Cosmopoiltan guarantees this clock will never raise
+      `EINVAL` and also guarantees `CLOCK_REALTIME == 0` will always be
+      the case. On Windows this maps to GetSystemTimePreciseAsFileTime().
+      On platforms with vDSOs like Linux, Windows, and MacOS ARM64 this
+      should take about 20 nanoseconds.
+
+    - `CLOCK_MONOTONIC` returns a timestamp with an unspecified epoch,
+      that should be when the system was powered on. These timestamps
+      shouldn't go backwards. Timestamps shouldn't count time spent in
+      the sleep, suspend, and hibernation states. These timestamps won't
+      be impacted by clock_settime(). These timestamps may be impacted by
+      frequency adjustments made by NTP. Cosmopoiltan guarantees this
+      clock will never raise `EINVAL`. MacOS and BSDs use the word
+      "uptime" to describe this clock. On Windows this maps to
+      QueryUnbiasedInterruptTimePrecise().
+
+    - `CLOCK_BOOTTIME` is a monotonic clock returning a timestamp with an
+      unspecified epoch, that should be relative to when the host system
+      was powered on. These timestamps shouldn't go backwards. Timestamps
+      should also include time spent in a sleep, suspend, or hibernation
+      state. These timestamps aren't impacted by clock_settime(), but
+      they may be impacted by frequency adjustments made by NTP. This
+      clock will raise an `EINVAL` error on extremely old Linux distros
+      like RHEL5. MacOS and BSDs use the word "monotonic" to describe
+      this clock. On Windows this maps to QueryInterruptTimePrecise().
+
+    - `CLOCK_MONOTONIC_RAW` returns a timestamp from an unspecified
+      epoch. These timestamps don't count time spent in the sleep,
+      suspend, and hibernation states. Unlike `CLOCK_MONOTONIC` this
+      clock is guaranteed to not be impacted by frequency adjustments or
+      discontinuous jumps caused by clock_settime(). Providing this level
+      of assurances may make this clock slower than the normal monotonic
+      clock. Furthermore this clock may cause `EINVAL` to be raised if
+      running on a host system that doesn't provide those guarantees,
+      e.g. OpenBSD and MacOS on AMD64.
+
+    - `CLOCK_REALTIME_COARSE` is the same as `CLOCK_REALTIME` except
+      it'll go faster if the host OS provides a cheaper way to read the
+      wall time. Please be warned that coarse can be really coarse.
+      Rather than nano precision, you're looking at `CLK_TCK` precision,
+      which can lag as far as 30 milliseconds behind or possibly more.
+      Cosmopolitan may fallback to `CLOCK_REALTIME` if a faster less
+      accurate clock isn't provided by the system. This clock will raise
+      an `EINVAL` error on extremely old Linux distros like RHEL5.
+
+    - `CLOCK_MONOTONIC_COARSE` is the same as `CLOCK_MONOTONIC` except
+      it'll go faster if the host OS provides a cheaper way to read the
+      unbiased time. Please be warned that coarse can be really coarse.
+      Rather than nano precision, you're looking at `CLK_TCK` precision,
+      which can lag as far as 30 milliseconds behind or possibly more.
+      Cosmopolitan may fallback to `CLOCK_REALTIME` if a faster less
+      accurate clock isn't provided by the system. This clock will raise
+      an `EINVAL` error on extremely old Linux distros like RHEL5.
+
+    - `CLOCK_PROCESS_CPUTIME_ID` returns the amount of time this process
+      was actively scheduled. This is similar to getrusage() and clock().
+      Cosmopoiltan guarantees this clock will never raise `EINVAL`.
+
+    - `CLOCK_THREAD_CPUTIME_ID` returns the amount of time this thread
+      was actively scheduled. This is similar to getrusage() and clock().
+      Cosmopoiltan guarantees this clock will never raise `EINVAL`.
 
     Returns `EINVAL` if clock isn't supported on platform.
 
@@ -4474,9 +4524,8 @@ UNIX MODULE
 
       If the executable in question needs a loader, then you will need
       "rpath prot_exec" too. With APE, security is strongest when you
-      assimilate your binaries beforehand, using the --assimilate flag,
-      or the o//tool/build/assimilate program. On OpenBSD this is
-      mandatory.
+      assimilate your binaries beforehand using the assimilate program.
+      On OpenBSD this is mandatory.
 
     prot_exec
 
@@ -4815,9 +4864,9 @@ UNIX MODULE
         end
 
     It's possible to accomplish the same thing as unix.mapshared()
-    using files and unix.fcntl() advisory locks. However this goes
-    significantly faster. For example, that's what SQLite does and
-    we recommend using SQLite for IPC in redbean. But, if your app
+    using files and unix.fcntl() advisory locks. For example, that's
+    what SQLite does and we recommend using SQLite for IPC in redbean.
+    However, unix.mapshared is significantly faster and if your app
     has thousands of forked processes fighting for a file lock you
     might need something lower level than file locks, to implement
     things like throttling. Shared memory is a good way to do that
diff --git a/tool/net/lfuncs.c b/tool/net/lfuncs.c
index e8d566d94..01b3ce19a 100644
--- a/tool/net/lfuncs.c
+++ b/tool/net/lfuncs.c
@@ -30,7 +30,7 @@
 #include "libc/intrin/popcnt.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
@@ -45,7 +45,7 @@
 #include "libc/str/highwayhash64.h"
 #include "libc/str/str.h"
 #include "libc/str/strwidth.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/sysv/consts/af.h"
 #include "libc/sysv/consts/ipproto.h"
 #include "libc/sysv/consts/o.h"
@@ -858,6 +858,74 @@ int LuaUuidV4(lua_State *L) {
   return 1;
 }
 
+int LuaUuidV7(lua_State *L) {
+  //See https://www.rfc-editor.org/rfc/rfc9562.html
+  char bin[16], uuid_str[37];
+  struct timespec ts = timespec_real();
+  uint64_t unix_ts_ms = (uint64_t)((ts.tv_sec * 1000) + (ts.tv_nsec / 1000000));
+  int fractional_ms = (int)floor((double)((double)(ts.tv_nsec - (ts.tv_nsec / 1000000) * 1000000)/1000000) * 4096) <<4;
+  uint64_t rand_b = _rand64();
+  int rand_a = fractional_ms | (rand_b & 0x000000000000000f); //use the last 4 bits of rand_b
+
+  bin[0]  = unix_ts_ms >> 050;
+  bin[1]  = unix_ts_ms >> 040;
+  bin[2]  = unix_ts_ms >> 030;
+  bin[3]  = unix_ts_ms >> 020;
+  bin[4]  = unix_ts_ms >> 010;
+  bin[5]  = unix_ts_ms >> 000;
+  bin[6]  = rand_a     >> 010;
+  bin[7]  = rand_a     >> 000;
+  bin[8]  = rand_b     >> 070;
+  bin[9]  = rand_b     >> 060;
+  bin[10] = rand_b     >> 050;
+  bin[11] = rand_b     >> 040;
+  bin[12] = rand_b     >> 030;
+  bin[13] = rand_b     >> 020;
+  bin[14] = rand_b     >> 010;
+  bin[15] = rand_b     >> 000;
+
+  uuid_str[0]  = "0123456789abcdef"[(bin[0] & 0xf0) >>4];
+  uuid_str[1]  = "0123456789abcdef"[(bin[0] & 0x0f)];
+  uuid_str[2]  = "0123456789abcdef"[(bin[1] & 0xf0) >>4];
+  uuid_str[3]  = "0123456789abcdef"[(bin[1] & 0x0f)];
+  uuid_str[4]  = "0123456789abcdef"[(bin[2] & 0xf0) >>4];
+  uuid_str[5]  = "0123456789abcdef"[(bin[2] & 0x0f)];
+  uuid_str[6]  = "0123456789abcdef"[(bin[3] & 0xf0) >>4];
+  uuid_str[7]  = "0123456789abcdef"[(bin[3] & 0x0f)];
+  uuid_str[8]  = '-';
+  uuid_str[9]  = "0123456789abcdef"[(bin[4] & 0xf0) >>4];
+  uuid_str[10] = "0123456789abcdef"[(bin[4] & 0x0f)];
+  uuid_str[11] = "0123456789abcdef"[(bin[5] & 0xf0) >>4];
+  uuid_str[12] = "0123456789abcdef"[(bin[5] & 0x0f)];
+  uuid_str[13] = '-';
+  uuid_str[14] = '7';
+  uuid_str[15] = "0123456789abcdef"[(bin[6] & 0xf0) >>4];
+  uuid_str[16] = "0123456789abcdef"[(bin[6] & 0x0f)];
+  uuid_str[17] = "0123456789abcdef"[(bin[7] & 0xf0) >>4];
+  uuid_str[18] = '-';
+  uuid_str[19] = "0123456789abcdef"[(0x8 | ((bin[7] & 0x0f) >>2))];
+  uuid_str[20] = "0123456789abcdef"[(bin[7] & 0x03) | (bin[8] & 0xf0) >>6]; //See https://www.rfc-editor.org/rfc/rfc9562.html#version_field
+  uuid_str[21] = "0123456789abcdef"[(bin[8] & 0x0f)];
+  uuid_str[22] = "0123456789abcdef"[(bin[9] & 0xf0) >>4];
+  uuid_str[23] = '-';
+  uuid_str[24] = "0123456789abcdef"[(bin[9]  & 0x0f)];
+  uuid_str[25] = "0123456789abcdef"[(bin[10] & 0xf0) >>4];
+  uuid_str[26] = "0123456789abcdef"[(bin[10] & 0x0f)];
+  uuid_str[27] = "0123456789abcdef"[(bin[11] & 0xf0) >>4];
+  uuid_str[28] = "0123456789abcdef"[(bin[11] & 0x0f)];
+  uuid_str[29] = "0123456789abcdef"[(bin[12] & 0xf0) >>4];
+  uuid_str[30] = "0123456789abcdef"[(bin[12] & 0x0f)];
+  uuid_str[31] = "0123456789abcdef"[(bin[13] & 0xf0) >>4];
+  uuid_str[32] = "0123456789abcdef"[(bin[13] & 0x0f)];
+  uuid_str[33] = "0123456789abcdef"[(bin[14] & 0xf0) >>4];
+  uuid_str[34] = "0123456789abcdef"[(bin[14] & 0x0f)];
+  uuid_str[35] = "0123456789abcdef"[(bin[15] & 0xf0) >>4];
+  uuid_str[36] = '\0';
+
+  lua_pushfstring(L, uuid_str);
+  return 1;
+}
+
 static dontinline int LuaHasherImpl(lua_State *L, size_t k,
                                     int H(const void *, size_t, uint8_t *)) {
   size_t n;
diff --git a/tool/net/lfuncs.h b/tool/net/lfuncs.h
index ab82c4e95..7bc3fc748 100644
--- a/tool/net/lfuncs.h
+++ b/tool/net/lfuncs.h
@@ -91,6 +91,7 @@ int LuaSlurp(lua_State *);
 int LuaUncompress(lua_State *);
 int LuaUnderlong(lua_State *);
 int LuaUuidV4(lua_State *);
+int LuaUuidV7(lua_State *);
 int LuaVisualizeControlCodes(lua_State *);
 
 void LuaPushUrlView(lua_State *, struct UrlView *);
diff --git a/tool/net/ljson.c b/tool/net/ljson.c
index 10a17c1f6..037cd097b 100644
--- a/tool/net/ljson.c
+++ b/tool/net/ljson.c
@@ -18,6 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "tool/net/ljson.h"
 #include "libc/assert.h"
+#include "libc/ctype.h"
 #include "libc/intrin/likely.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
@@ -26,7 +27,7 @@
 #include "libc/serialize.h"
 #include "libc/stdckdint.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/str/utf16.h"
 #include "libc/sysv/consts/auxv.h"
 #include "libc/thread/thread.h"
diff --git a/tool/net/lre.c b/tool/net/lre.c
index e24648e29..598b5b4b6 100644
--- a/tool/net/lre.c
+++ b/tool/net/lre.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "third_party/lua/lauxlib.h"
 #include "third_party/regex/regex.h"
diff --git a/tool/net/redbean.c b/tool/net/redbean.c
index 8696121e9..93816d1aa 100644
--- a/tool/net/redbean.c
+++ b/tool/net/redbean.c
@@ -31,8 +31,10 @@
 #include "libc/calls/struct/termios.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/calls/termios.h"
+#include "libc/cosmo.h"
+#include "libc/ctype.h"
 #include "libc/dce.h"
-#include "libc/dos.internal.h"
+#include "libc/dos.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
@@ -40,12 +42,12 @@
 #include "libc/intrin/atomic.h"
 #include "libc/intrin/bsr.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/nomultics.internal.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/nomultics.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/log/appendresourcereport.internal.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/alloca.h"
 #include "libc/mem/gc.h"
@@ -70,6 +72,7 @@
 #include "libc/stdio/hex.internal.h"
 #include "libc/stdio/rand.h"
 #include "libc/stdio/stdio.h"
+#include "libc/str/locale.h"
 #include "libc/str/slice.h"
 #include "libc/str/str.h"
 #include "libc/str/strwidth.h"
@@ -103,7 +106,7 @@
 #include "libc/thread/tls.h"
 #include "libc/x/x.h"
 #include "libc/x/xasprintf.h"
-#include "libc/zip.internal.h"
+#include "libc/zip.h"
 #include "net/http/escape.h"
 #include "net/http/http.h"
 #include "net/http/ip.h"
@@ -128,7 +131,6 @@
 #include "third_party/mbedtls/x509_crt.h"
 #include "third_party/musl/netdb.h"
 #include "third_party/zlib/zlib.h"
-#include "tool/args/args.h"
 #include "tool/build/lib/case.h"
 #include "tool/net/lfinger.h"
 #include "tool/net/lfuncs.h"
@@ -168,7 +170,8 @@ __static_yoink("blink_xnu_aarch64");    // is apple silicon
 #define REDBEAN "redbean"
 #endif
 
-#define VERSION          0x020200
+//                         XXYYZZ
+#define VERSION          0x030000
 #define HASH_LOAD_FACTOR /* 1. / */ 4
 #define READ(F, P, N)    readv(F, &(struct iovec){P, N}, 1)
 #define WRITE(F, P, N)   writev(F, &(struct iovec){P, N}, 1)
@@ -178,12 +181,8 @@ __static_yoink("blink_xnu_aarch64");    // is apple silicon
 #define HeaderLength(H)  (cpm.msg.headers[H].b - cpm.msg.headers[H].a)
 #define HeaderEqualCase(H, S) \
   SlicesEqualCase(S, strlen(S), HeaderData(H), HeaderLength(H))
-#define LockInc(P)                                            \
-  atomic_fetch_add_explicit((_Atomic(typeof(*(P))) *)(P), +1, \
-                            memory_order_relaxed)
-#define LockDec(P)                                            \
-  atomic_fetch_add_explicit((_Atomic(typeof(*(P))) *)(P), -1, \
-                            memory_order_relaxed)
+#define LockInc(P) atomic_fetch_add_explicit(P, +1, memory_order_relaxed)
+#define LockDec(P) atomic_fetch_add_explicit(P, -1, memory_order_relaxed)
 
 #define TRACE_BEGIN         \
   do {                      \
@@ -374,19 +373,21 @@ struct Blackhole {
 } blackhole;
 
 static struct Shared {
-  int workers;
-  struct timespec nowish;
-  struct timespec lastreindex;
+  _Atomic(int) workers;
   struct timespec lastmeltdown;
+  struct timespec nowish;
   char currentdate[32];
   struct rusage server;
   struct rusage children;
   struct Counters {
-#define C(x) long x;
+#define C(x) _Atomic(long) x;
 #include "tool/net/counters.inc"
 #undef C
   } c;
-  pthread_spinlock_t montermlock;
+  pthread_mutex_t datetime_mu;
+  pthread_mutex_t server_mu;
+  pthread_mutex_t children_mu;
+  pthread_mutex_t lastmeltdown_mu;
 } *shared;
 
 static const char kCounterNames[] =
@@ -1347,8 +1348,8 @@ static void CallSimpleHookIfDefined(const char *s) {
 }
 
 static void ReportWorkerExit(int pid, int ws) {
-  int workers;
-  workers = atomic_fetch_sub(&shared->workers, 1) - 1;
+  int workers =
+      atomic_fetch_sub_explicit(&shared->workers, 1, memory_order_release);
   if (WIFEXITED(ws)) {
     if (WEXITSTATUS(ws)) {
       LockInc(&shared->c.failedchildren);
@@ -1380,7 +1381,9 @@ static void ReportWorkerResources(int pid, struct rusage *ru) {
 
 static void HandleWorkerExit(int pid, int ws, struct rusage *ru) {
   LockInc(&shared->c.connectionshandled);
+  unassert(!pthread_mutex_lock(&shared->children_mu));
   rusage_add(&shared->children, ru);
+  unassert(!pthread_mutex_unlock(&shared->children_mu));
   ReportWorkerExit(pid, ws);
   ReportWorkerResources(pid, ru);
   if (hasonprocessdestroy) {
@@ -2126,9 +2129,11 @@ static void UpdateCurrentDate(struct timespec now) {
   int64_t t;
   struct tm tm;
   t = now.tv_sec;
-  shared->nowish = now;
   gmtime_r(&t, &tm);
+  unassert(!pthread_mutex_lock(&shared->datetime_mu));
+  shared->nowish = now;
   FormatHttpDateTime(shared->currentdate, &tm);
+  unassert(!pthread_mutex_unlock(&shared->datetime_mu));
 }
 
 static int64_t GetGmtOffset(int64_t t) {
@@ -2273,7 +2278,7 @@ static struct Asset *GetAssetZip(const char *path, size_t pathlen) {
   hash = Hash(path, pathlen);
   for (step = 0;; ++step) {
     i = (hash + ((step * (step + 1)) >> 1)) & (assets.n - 1);
-    if (!assets.p[i].hash)
+    if (i >= assets.n || !assets.p || !assets.p[i].hash)
       return NULL;
     if (hash == assets.p[i].hash &&
         pathlen == ZIP_CFILE_NAMESIZE(zmap + assets.p[i].cf) &&
@@ -2361,7 +2366,10 @@ static char *AppendCache(char *p, int64_t seconds, char *directive) {
     p = stpcpy(p, directive);
   }
   p = AppendCrlf(p);
-  return AppendExpires(p, shared->nowish.tv_sec + seconds);
+  unassert(!pthread_mutex_lock(&shared->datetime_mu));
+  long nowish_sec = shared->nowish.tv_sec;
+  unassert(!pthread_mutex_unlock(&shared->datetime_mu));
+  return AppendExpires(p, nowish_sec + seconds);
 }
 
 static inline char *AppendContentLength(char *p, size_t n) {
@@ -2544,7 +2552,7 @@ static char *CommitOutput(char *p) {
 
 static char *ServeDefaultErrorPage(char *p, unsigned code, const char *reason,
                                    const char *details) {
-  p = AppendContentType(p, "text/html; charset=ISO-8859-1");
+  p = AppendContentType(p, "text/html; charset=UTF-8");
   reason = FreeLater(EscapeHtml(reason, -1, 0));
   appends(&cpm.outbuf, "\
 <!doctype html>\r\n\
@@ -2617,7 +2625,8 @@ static char *ServeErrorImpl(unsigned code, const char *reason,
     lua_getglobal(L, "OnError");
     lua_pushinteger(L, code);
     lua_pushstring(L, reason);
-    if (LuaCallWithTrace(L, 2, 0, NULL) == LUA_OK) {
+    lua_pushstring(L, details);
+    if (LuaCallWithTrace(L, 3, 0, NULL) == LUA_OK) {
       return CommitOutput(GetLuaResponse());
     } else {
       return ServeErrorImplDefault(code, reason, details);
@@ -3099,9 +3108,12 @@ td { padding-right: 3em; }\r\n\
 <td valign=\"top\">\r\n\
 <a href=\"/statusz\">/statusz</a>\r\n\
 ");
-  if (shared->c.connectionshandled) {
+  if (atomic_load_explicit(&shared->c.connectionshandled,
+                           memory_order_acquire)) {
     appends(&cpm.outbuf, "says your redbean<br>\r\n");
+    unassert(!pthread_mutex_lock(&shared->children_mu));
     AppendResourceReport(&cpm.outbuf, &shared->children, "<br>\r\n");
+    unassert(!pthread_mutex_unlock(&shared->children_mu));
   }
   appends(&cpm.outbuf, "<td valign=\"top\">\r\n");
   and = "";
@@ -3123,12 +3135,12 @@ td { padding-right: 3em; }\r\n\
   }
   appendf(&cpm.outbuf, "%s%,ld second%s of operation<br>\r\n", and, y.rem,
           y.rem == 1 ? "" : "s");
-  x = shared->c.messageshandled;
+  x = atomic_load_explicit(&shared->c.messageshandled, memory_order_relaxed);
   appendf(&cpm.outbuf, "%,ld message%s handled<br>\r\n", x, x == 1 ? "" : "s");
-  x = shared->c.connectionshandled;
+  x = atomic_load_explicit(&shared->c.connectionshandled, memory_order_relaxed);
   appendf(&cpm.outbuf, "%,ld connection%s handled<br>\r\n", x,
           x == 1 ? "" : "s");
-  x = shared->workers;
+  x = atomic_load_explicit(&shared->workers, memory_order_relaxed);
   appendf(&cpm.outbuf, "%,ld connection%s active<br>\r\n", x,
           x == 1 ? "" : "s");
   appends(&cpm.outbuf, "</table>\r\n");
@@ -3180,11 +3192,11 @@ static void AppendRusage(const char *a, struct rusage *ru) {
 }
 
 static void ServeCounters(void) {
-  const long *c;
+  const _Atomic(long) *c;
   const char *s;
-  for (c = (const long *)&shared->c, s = kCounterNames; *s;
+  for (c = (const _Atomic(long) *)&shared->c, s = kCounterNames; *s;
        ++c, s += strlen(s) + 1) {
-    AppendLong1(s, *c);
+    AppendLong1(s, atomic_load_explicit(c, memory_order_relaxed));
   }
 }
 
@@ -3197,12 +3209,17 @@ static char *ServeStatusz(void) {
   AppendLong1("pid", getpid());
   AppendLong1("ppid", getppid());
   AppendLong1("now", timespec_real().tv_sec);
+  unassert(!pthread_mutex_lock(&shared->datetime_mu));
   AppendLong1("nowish", shared->nowish.tv_sec);
+  unassert(!pthread_mutex_unlock(&shared->datetime_mu));
   AppendLong1("gmtoff", gmtoff);
   AppendLong1("CLK_TCK", CLK_TCK);
   AppendLong1("startserver", startserver.tv_sec);
+  unassert(!pthread_mutex_lock(&shared->lastmeltdown_mu));
   AppendLong1("lastmeltdown", shared->lastmeltdown.tv_sec);
-  AppendLong1("workers", shared->workers);
+  unassert(!pthread_mutex_unlock(&shared->lastmeltdown_mu));
+  AppendLong1("workers",
+              atomic_load_explicit(&shared->workers, memory_order_relaxed));
   AppendLong1("assets.n", assets.n);
 #ifndef STATIC
   lua_State *L = GL;
@@ -3210,8 +3227,12 @@ static char *ServeStatusz(void) {
               lua_gc(L, LUA_GCCOUNT) * 1024 + lua_gc(L, LUA_GCCOUNTB));
 #endif
   ServeCounters();
+  unassert(!pthread_mutex_lock(&shared->server_mu));
   AppendRusage("server", &shared->server);
+  unassert(!pthread_mutex_unlock(&shared->server_mu));
+  unassert(!pthread_mutex_lock(&shared->children_mu));
   AppendRusage("children", &shared->children);
+  unassert(!pthread_mutex_unlock(&shared->children_mu));
   p = SetStatus(200, "OK");
   p = AppendContentType(p, "text/plain");
   if (cpm.msg.version >= 11) {
@@ -3976,7 +3997,9 @@ static int LuaNilTlsError(lua_State *L, const char *s, int r) {
 #include "tool/net/fetch.inc"
 
 static int LuaGetDate(lua_State *L) {
+  unassert(!pthread_mutex_lock(&shared->datetime_mu));
   lua_pushinteger(L, shared->nowish.tv_sec);
+  unassert(!pthread_mutex_unlock(&shared->datetime_mu));
   return 1;
 }
 
@@ -5019,7 +5042,7 @@ static int LuaProgramTokenBucket(lua_State *L) {
       VERBOSEF("(token) please run the blackholed program; see our website!");
     }
   }
-  tokenbucket.b = _mapshared(ROUNDUP(1ul << cidr, __granularity()));
+  tokenbucket.b = _mapshared(ROUNDUP(1ul << cidr, getgransize()));
   memset(tokenbucket.b, 127, 1ul << cidr);
   tokenbucket.cidr = cidr;
   tokenbucket.reject = reject;
@@ -5030,7 +5053,7 @@ static int LuaProgramTokenBucket(lua_State *L) {
   npassert(pid != -1);
   if (!pid)
     Replenisher();
-  ++shared->workers;
+  atomic_fetch_add_explicit(&shared->workers, 1, memory_order_acquire);
   return 0;
 }
 
@@ -5364,6 +5387,7 @@ static const luaL_Reg kLuaFuncs[] = {
     {"Uncompress", LuaUncompress},                              //
     {"Underlong", LuaUnderlong},                                //
     {"UuidV4", LuaUuidV4},                                      //
+    {"UuidV7", LuaUuidV7},                                      //
     {"VisualizeControlCodes", LuaVisualizeControlCodes},        //
     {"Write", LuaWrite},                                        //
     {"bin", LuaBin},                                            //
@@ -5674,7 +5698,8 @@ static void LogClose(const char *reason) {
   if (amtread || meltdown || killed) {
     LockInc(&shared->c.fumbles);
     INFOF("(stat) %s %s with %,ld unprocessed and %,d handled (%,d workers)",
-          DescribeClient(), reason, amtread, messageshandled, shared->workers);
+          DescribeClient(), reason, amtread, messageshandled,
+          atomic_load_explicit(&shared->workers, memory_order_relaxed));
   } else {
     DEBUGF("(stat) %s %s with %,d messages handled", DescribeClient(), reason,
            messageshandled);
@@ -5732,14 +5757,18 @@ Content-Length: 22\r\n\
 }
 
 static void EnterMeltdownMode(void) {
+  unassert(!pthread_mutex_lock(&shared->lastmeltdown_mu));
   if (timespec_cmp(timespec_sub(timespec_real(), shared->lastmeltdown),
                    (struct timespec){1}) < 0) {
+    unassert(!pthread_mutex_unlock(&shared->lastmeltdown_mu));
     return;
   }
-  WARNF("(srvr) server is melting down (%,d workers)", shared->workers);
-  LOGIFNEG1(kill(0, SIGUSR2));
   shared->lastmeltdown = timespec_real();
-  ++shared->c.meltdowns;
+  pthread_mutex_unlock(&shared->lastmeltdown_mu);
+  WARNF("(srvr) server is melting down (%,d workers)",
+        atomic_load_explicit(&shared->workers, memory_order_relaxed));
+  LOGIFNEG1(kill(0, SIGUSR2));
+  LockInc(&shared->c.meltdowns);
 }
 
 static char *HandlePayloadDisconnect(void) {
@@ -5856,7 +5885,9 @@ static void HandleHeartbeat(void) {
   size_t i;
   UpdateCurrentDate(timespec_real());
   Reindex();
+  unassert(!pthread_mutex_lock(&shared->server_mu));
   getrusage(RUSAGE_SELF, &shared->server);
+  unassert(!pthread_mutex_unlock(&shared->server_mu));
 #ifndef STATIC
   CallSimpleHookIfDefined("OnServerHeartbeat");
   CollectGarbage();
@@ -6476,7 +6507,9 @@ static bool HandleMessageActual(void) {
     DEBUGF("(clnt) could not synchronize message stream");
   }
   if (cpm.msg.version >= 10) {
+    unassert(!pthread_mutex_lock(&shared->datetime_mu));
     p = AppendCrlf(stpcpy(stpcpy(p, "Date: "), shared->currentdate));
+    unassert(!pthread_mutex_unlock(&shared->datetime_mu));
     if (!cpm.branded)
       p = stpcpy(p, serverheader);
     if (extrahdrs)
@@ -6746,7 +6779,9 @@ static int HandleConnection(size_t i) {
       DEBUGF("(token) can't acquire accept() token for client");
     }
     startconnection = timespec_real();
-    if (UNLIKELY(maxworkers) && shared->workers >= maxworkers) {
+    if (UNLIKELY(maxworkers) &&
+        atomic_load_explicit(&shared->workers, memory_order_relaxed) >=
+            maxworkers) {
       EnterMeltdownMode();
       SendServiceUnavailable();
       close(client);
@@ -6764,6 +6799,8 @@ static int HandleConnection(size_t i) {
     } else {
       switch ((pid = fork())) {
         case 0:
+          lua_repl_wock();
+          lua_repl_lock();
           meltdown = false;
           __isworker = true;
           connectionclose = false;
@@ -7338,9 +7375,17 @@ void RedBean(int argc, char *argv[]) {
   heartbeatinterval.tv_sec = 5;
   CHECK_GT(CLK_TCK, 0);
   CHECK_NE(MAP_FAILED,
-           (shared = mmap(NULL, ROUNDUP(sizeof(struct Shared), __granularity()),
+           (shared = mmap(NULL, ROUNDUP(sizeof(struct Shared), getgransize()),
                           PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS,
                           -1, 0)));
+  pthread_mutexattr_t attr;
+  unassert(!pthread_mutexattr_init(&attr));
+  unassert(!pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED));
+  unassert(!pthread_mutex_init(&shared->datetime_mu, &attr));
+  unassert(!pthread_mutex_init(&shared->server_mu, &attr));
+  unassert(!pthread_mutex_init(&shared->children_mu, &attr));
+  unassert(!pthread_mutex_init(&shared->lastmeltdown_mu, &attr));
+  unassert(!pthread_mutexattr_destroy(&attr));
   if (daemonize) {
     for (int i = 0; i < 256; ++i) {
       close(i);
@@ -7426,6 +7471,9 @@ int main(int argc, char *argv[]) {
   ShowCrashReports();
 #endif
 
+  // just in case
+  setlocale(LC_ALL, "C.UTF-8");
+
   LoadZipArgs(&argc, &argv);
   RedBean(argc, argv);
 
diff --git a/tool/net/winbench.c b/tool/net/winbench.c
index 5fad9df33..f54547d97 100644
--- a/tool/net/winbench.c
+++ b/tool/net/winbench.c
@@ -16,7 +16,7 @@
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nt/accounting.h"
 #include "libc/nt/enum/wsaid.h"
@@ -244,7 +244,7 @@ int main(int argc, char *argv[]) {
   sigset_t block;
   sigfillset(&block);
   pthread_attr_t attr;
-  int pagesz = getauxval(AT_PAGESZ);
+  int pagesz = getpagesize();
   pthread_t *threads = calloc(nthreads, sizeof(pthread_t));
   unassert(!pthread_attr_init(&attr));
   unassert(!pthread_attr_setstacksize(&attr, 65536));
diff --git a/tool/plinko/lib/gc.c b/tool/plinko/lib/gc.c
index 08ef948a8..33e320eb4 100644
--- a/tool/plinko/lib/gc.c
+++ b/tool/plinko/lib/gc.c
@@ -24,7 +24,7 @@
 #include "libc/log/check.h"
 #include "libc/log/countbranch.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "tool/plinko/lib/cons.h"
diff --git a/tool/plinko/lib/histo.h b/tool/plinko/lib/histo.h
index 4cdc63904..10025713e 100644
--- a/tool/plinko/lib/histo.h
+++ b/tool/plinko/lib/histo.h
@@ -1,7 +1,7 @@
 #ifndef COSMOPOLITAN_TOOL_PLINKO_LIB_HISTO_H_
 #define COSMOPOLITAN_TOOL_PLINKO_LIB_HISTO_H_
 #include "libc/intrin/bsr.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 COSMOPOLITAN_C_START_
 
 #define HISTO(H, X)                \
diff --git a/tool/plinko/lib/iswide.c b/tool/plinko/lib/iswide.c
index f458bfad5..087a21df3 100644
--- a/tool/plinko/lib/iswide.c
+++ b/tool/plinko/lib/iswide.c
@@ -16,327 +16,12 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/str/unicode.h"
 #include "tool/plinko/lib/char.h"
 
-static const unsigned short kWides[][2] = {
-    {0x1100, 0x115F},  // HANGUL CHOSEONG KIYEOK..HANGUL CHOSEONG FILLER
-    {0x231A, 0x231B},  // WATCH..HOURGLASS
-    {0x2329, 0x2329},  // LEFT-POINTING ANGLE BRACKET
-    {0x232A, 0x232A},  // RIGHT-POINTING ANGLE BRACKET
-    {0x23E9, 0x23EC},  // BLACK RIGHT-POINTING DOUBLE TRIANGLE...
-    {0x23F0, 0x23F0},  // ALARM CLOCK
-    {0x23F3, 0x23F3},  // HOURGLASS WITH FLOWING SAND
-    {0x25FD, 0x25FE},  // WHITE MEDIUM SMALL SQUARE..BLACK MEDIUM SMALL SQUARE
-    {0x2614, 0x2615},  // UMBRELLA WITH RAIN DROPS..HOT BEVERAGE
-    {0x2648, 0x2653},  // ARIES..PISCES
-    {0x267F, 0x267F},  // WHEELCHAIR SYMBOL
-    {0x2693, 0x2693},  // ANCHOR
-    {0x26A1, 0x26A1},  // HIGH VOLTAGE SIGN
-    {0x26AA, 0x26AB},  // MEDIUM WHITE CIRCLE..MEDIUM BLACK CIRCLE
-    {0x26BD, 0x26BE},  // SOCCER BALL..BASEBALL
-    {0x26C4, 0x26C5},  // SNOWMAN WITHOUT SNOW..SUN BEHIND CLOUD
-    {0x26CE, 0x26CE},  // OPHIUCHUS
-    {0x26D4, 0x26D4},  // NO ENTRY
-    {0x26EA, 0x26EA},  // CHURCH
-    {0x26F2, 0x26F3},  // FOUNTAIN..FLAG IN HOLE
-    {0x26F5, 0x26F5},  // SAILBOAT
-    {0x26FA, 0x26FA},  // TENT
-    {0x26FD, 0x26FD},  // FUEL PUMP
-    {0x2705, 0x2705},  // WHITE HEAVY CHECK MARK
-    {0x270A, 0x270B},  // RaiseD FIST..RaiseD HAND
-    {0x2728, 0x2728},  // SPARKLES
-    {0x274C, 0x274C},  // CROSS MARK
-    {0x274E, 0x274E},  // NEGATIVE SQUARED CROSS MARK
-    {0x2753, 0x2755},  // BLACK QUESTION MARK ORNAMENT..WHITE EXCLAMATION MARK
-    {0x2757, 0x2757},  // HEAVY EXCLAMATION MARK SYMBOL
-    {0x2795, 0x2797},  // HEAVY PLUS SIGN..HEAVY DIVISION SIGN
-    {0x27B0, 0x27B0},  // CURLY LOOP
-    {0x27BF, 0x27BF},  // DOUBLE CURLY LOOP
-    {0x2B1B, 0x2B1C},  // BLACK LARGE SQUARE..WHITE LARGE SQUARE
-    {0x2B50, 0x2B50},  // WHITE MEDIUM STAR
-    {0x2B55, 0x2B55},  // HEAVY LARGE CIRCLE
-    {0x2E80, 0x2E99},  // CJK RADICAL REPEAT..CJK RADICAL RAP
-    {0x2E9B, 0x2EF3},  // CJK RADICAL CHOKE..CJK RADICAL C-SIMPLIFIED TURTLE
-    {0x2F00, 0x2FD5},  // KANGXI RADICAL ONE..KANGXI RADICAL FLUTE
-    {0x2FF0, 0x2FFB},  // IDEOGRAPHIC DESCRIPTION CHARACTER LTR..OVERLAID
-    {0x3000, 0x3000},  // IDEOGRAPHIC SPACE
-    {0x3001, 0x3003},  // IDEOGRAPHIC COMMA..DITTO MARK
-    {0x3004, 0x3004},  // JAPANESE INDUSTRIAL STANDARD SYMBOL
-    {0x3005, 0x3005},  // IDEOGRAPHIC ITERATION MARK
-    {0x3006, 0x3006},  // IDEOGRAPHIC CLOSING MARK
-    {0x3007, 0x3007},  // IDEOGRAPHIC NUMBER ZERO
-    {0x3008, 0x3008},  // LEFT ANGLE BRACKET
-    {0x3009, 0x3009},  // RIGHT ANGLE BRACKET
-    {0x300A, 0x300A},  // LEFT DOUBLE ANGLE BRACKET
-    {0x300B, 0x300B},  // RIGHT DOUBLE ANGLE BRACKET
-    {0x300C, 0x300C},  // LEFT CORNER BRACKET
-    {0x300D, 0x300D},  // RIGHT CORNER BRACKET
-    {0x300E, 0x300E},  // LEFT WHITE CORNER BRACKET
-    {0x300F, 0x300F},  // RIGHT WHITE CORNER BRACKET
-    {0x3010, 0x3010},  // LEFT BLACK LENTICULAR BRACKET
-    {0x3011, 0x3011},  // RIGHT BLACK LENTICULAR BRACKET
-    {0x3012, 0x3013},  // POSTAL MARK..GETA MARK
-    {0x3014, 0x3014},  // LEFT TORTOISE SHELL BRACKET
-    {0x3015, 0x3015},  // RIGHT TORTOISE SHELL BRACKET
-    {0x3016, 0x3016},  // LEFT WHITE LENTICULAR BRACKET
-    {0x3017, 0x3017},  // RIGHT WHITE LENTICULAR BRACKET
-    {0x3018, 0x3018},  // LEFT WHITE TORTOISE SHELL BRACKET
-    {0x3019, 0x3019},  // RIGHT WHITE TORTOISE SHELL BRACKET
-    {0x301A, 0x301A},  // LEFT WHITE SQUARE BRACKET
-    {0x301B, 0x301B},  // RIGHT WHITE SQUARE BRACKET
-    {0x301C, 0x301C},  // WAVE DASH
-    {0x301D, 0x301D},  // REVERSED DOUBLE PRIME QUOTATION MARK
-    {0x301E, 0x301F},  // DOUBLE PRIME QUOTATION MARK..LOW DOUBLE PRIME
-    {0x3020, 0x3020},  // POSTAL MARK FACE
-    {0x3021, 0x3029},  // HANGZHOU NUMERAL ONE..HANGZHOU NUMERAL NINE
-    {0x302A, 0x302D},  // IDEOGRAPHIC LEVEL TONE MARK..ENTERING TONE MARK
-    {0x302E, 0x302F},  // HANGUL SINGLE DOT TONE MARK..DOUBLE DOT TONE MARK
-    {0x3030, 0x3030},  // WAVY DASH
-    {0x3031, 0x3035},  // VERTICAL KANA REPEAT MARK..KANA REPEAT MARK LOWER
-    {0x3036, 0x3037},  // CIRCLED POSTAL MARK..IDEOGRAPHIC TELEGRAPH LF SYMBOL
-    {0x3038, 0x303A},  // HANGZHOU NUMERAL TEN..HANGZHOU NUMERAL THIRTY
-    {0x303B, 0x303B},  // VERTICAL IDEOGRAPHIC ITERATION MARK
-    {0x303C, 0x303C},  // MASU MARK
-    {0x303D, 0x303D},  // PART ALTERNATION MARK
-    {0x303E, 0x303E},  // IDEOGRAPHIC VARIATION INDICATOR
-    {0x3041, 0x3096},  // HIRAGANA LETTER SMALL A..HIRAGANA LETTER SMALL KE
-    {0x3099, 0x309A},  // COMBINING KATAKANA-HIRAGANA VOICED SOUND MARK...
-    {0x309B, 0x309C},  // KATAKANA-HIRAGANA VOICED SOUND MARK...
-    {0x309D, 0x309E},  // HIRAGANA ITERATION MARK..VOICED ITERATION MARK
-    {0x309F, 0x309F},  // HIRAGANA DIGRAPH YORI
-    {0x30A0, 0x30A0},  // KATAKANA-HIRAGANA DOUBLE HYPHEN
-    {0x30A1, 0x30FA},  // KATAKANA LETTER SMALL A..KATAKANA LETTER VO
-    {0x30FB, 0x30FB},  // KATAKANA MIDDLE DOT
-    {0x30FC, 0x30FE},  // KATAKANA-HIRAGANA PROLONGED SOUND MARK..ITERATION
-    {0x30FF, 0x30FF},  // KATAKANA DIGRAPH KOTO
-    {0x3105, 0x312F},  // BOPOMOFO LETTER B..BOPOMOFO LETTER NN
-    {0x3131, 0x318E},  // HANGUL LETTER KIYEOK..HANGUL LETTER ARAEAE
-    {0x3190, 0x3191},  // IDEOGRAPHIC ANNOTATION LINKING MARK..REVERSE
-    {0x3192, 0x3195},  // IDEOGRAPHIC ANNOTATION ONE MARK..FOUR
-    {0x3196, 0x319F},  // IDEOGRAPHIC ANNOTATION TOP MARK..MAN
-    {0x31A0, 0x31BF},  // BOPOMOFO LETTER BU..BOPOMOFO LETTER AH
-    {0x31C0, 0x31E3},  // CJK STROKE T..CJK STROKE Q
-    {0x31F0, 0x31FF},  // KATAKANA LETTER SMALL KU..KATAKANA LETTER SMALL RO
-    {0x3200, 0x321E},  // PARENTHESIZED HANGUL KIYEOK..CHARACTER O HU
-    {0x3220, 0x3229},  // PARENTHESIZED IDEOGRAPH ONE..TEN
-    {0x322A, 0x3247},  // PARENTHESIZED IDEOGRAPH MOON..CIRCLED IDEOGRAPH KOTO
-    {0x3250, 0x3250},  // PARTNERSHIP SIGN
-    {0x3251, 0x325F},  // CIRCLED NUMBER TWENTY ONE..CIRCLED 35
-    {0x3260, 0x327F},  // CIRCLED HANGUL KIYEOK..KOREAN STANDARD SYMBOL
-    {0x3280, 0x3289},  // CIRCLED IDEOGRAPH ONE..CIRCLED IDEOGRAPH TEN
-    {0x328A, 0x32B0},  // CIRCLED IDEOGRAPH MOON..CIRCLED IDEOGRAPH NIGHT
-    {0x32B1, 0x32BF},  // CIRCLED NUMBER THIRTY SIX..CIRCLED NUMBER FIFTY
-    {0x32C0, 0x32FF},  // TELEGRAPH SYMBOL FOR JANUARY..SQUARE ERA NAME REIWA
-    {0x3300, 0x33FF},  // SQUARE APAATO..SQUARE GAL
-    {0x3400, 0x4DBF},  // CJK UNIFIED IDEOGRAPH
-    {0x4E00, 0x9FFF},  // CJK UNIFIED IDEOGRAPH
-    {0xA000, 0xA014},  // YI SYLLABLE IT..YI SYLLABLE E
-    {0xA015, 0xA015},  // YI SYLLABLE WU
-    {0xA016, 0xA48C},  // YI SYLLABLE BIT..YI SYLLABLE YYR
-    {0xA490, 0xA4C6},  // YI RADICAL QOT..YI RADICAL KE
-    {0xA960, 0xA97C},  // HANGUL CHOSEONG TIKEUT-MIEUM..SSANGYEORINHIEUH
-    {0xAC00, 0xD7A3},  // HANGUL SYLLABLE GA..HANGUL SYLLABLE HIH
-    {0xF900, 0xFA6D},  // CJK COMPATIBILITY IDEOGRAPH
-    {0xFA6E, 0xFA6F},  // RESERVED
-    {0xFA70, 0xFAD9},  // CJK COMPATIBILITY IDEOGRAPH
-    {0xFADA, 0xFAFF},  // RESERVED
-    {0xFE10, 0xFE16},  // PRESENTATION FORM FOR VERTICAL COMMA..QUESTION
-    {0xFE17, 0xFE17},  // VERTICAL LEFT WHITE LENTICULAR BRACKET
-    {0xFE18, 0xFE18},  // VERTICAL RIGHT WHITE LENTICULAR BRAKCET
-    {0xFE19, 0xFE19},  // PRESENTATION FORM FOR VERTICAL HORIZONTAL ELLIPSIS
-    {0xFE30, 0xFE30},  // PRESENTATION FORM FOR VERTICAL TWO DOT LEADER
-    {0xFE31, 0xFE32},  // VERTICAL EM DASH..VERTICAL EN DASH
-    {0xFE33, 0xFE34},  // VERTICAL LOW LINE..VERTICAL WAVY LOW LINE
-    {0xFE35, 0xFE35},  // PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS
-    {0xFE36, 0xFE36},  // PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS
-    {0xFE37, 0xFE37},  // PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET
-    {0xFE38, 0xFE38},  // PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET
-    {0xFE39, 0xFE39},  // VERTICAL LEFT TORTOISE SHELL BRACKET
-    {0xFE3A, 0xFE3A},  // VERTICAL RIGHT TORTOISE SHELL BRACKET
-    {0xFE3B, 0xFE3B},  // VERTICAL LEFT BLACK LENTICULAR BRACKET
-    {0xFE3C, 0xFE3C},  // VERTICAL RIGHT BLACK LENTICULAR BRACKET
-    {0xFE3D, 0xFE3D},  // VERTICAL LEFT DOUBLE ANGLE BRACKET
-    {0xFE3E, 0xFE3E},  // VERTICAL RIGHT DOUBLE ANGLE BRACKET
-    {0xFE3F, 0xFE3F},  // VERTICAL LEFT ANGLE BRACKET
-    {0xFE40, 0xFE40},  // VERTICAL RIGHT ANGLE BRACKET
-    {0xFE41, 0xFE41},  // VERTICAL LEFT CORNER BRACKET
-    {0xFE42, 0xFE42},  // VERTICAL RIGHT CORNER BRACKET
-    {0xFE43, 0xFE43},  // VERTICAL LEFT WHITE CORNER BRACKET
-    {0xFE44, 0xFE44},  // VERTICAL RIGHT WHITE CORNER BRACKET
-    {0xFE45, 0xFE46},  // SESAME DOT..WHITE SESAME DOT
-    {0xFE47, 0xFE47},  // VERTICAL LEFT SQUARE BRACKET
-    {0xFE48, 0xFE48},  // VERTICAL RIGHT SQUARE BRACKET
-    {0xFE49, 0xFE4C},  // DASHED OVERLINE..DOUBLE WAVY OVERLINE
-    {0xFE4D, 0xFE4F},  // DASHED LOW LINE..WAVY LOW LINE
-    {0xFE50, 0xFE52},  // SMALL COMMA..SMALL FULL STOP
-    {0xFE54, 0xFE57},  // SMALL SEMICOLON..SMALL EXCLAMATION MARK
-    {0xFE58, 0xFE58},  // SMALL EM DASH
-    {0xFE59, 0xFE59},  // SMALL LEFT PARENTHESIS
-    {0xFE5A, 0xFE5A},  // SMALL RIGHT PARENTHESIS
-    {0xFE5B, 0xFE5B},  // SMALL LEFT CURLY BRACKET
-    {0xFE5C, 0xFE5C},  // SMALL RIGHT CURLY BRACKET
-    {0xFE5D, 0xFE5D},  // SMALL LEFT TORTOISE SHELL BRACKET
-    {0xFE5E, 0xFE5E},  // SMALL RIGHT TORTOISE SHELL BRACKET
-    {0xFE5F, 0xFE61},  // SMALL NUMBER SIGN..SMALL ASTERISK
-    {0xFE62, 0xFE62},  // SMALL PLUS SIGN
-    {0xFE63, 0xFE63},  // SMALL HYPHEN-MINUS
-    {0xFE64, 0xFE66},  // SMALL LESS-THAN SIGN..SMALL EQUALS SIGN
-    {0xFE68, 0xFE68},  // SMALL REVERSE SOLIDUS
-    {0xFE69, 0xFE69},  // SMALL DOLLAR SIGN
-    {0xFE6A, 0xFE6B},  // SMALL PERCENT SIGN..SMALL COMMERCIAL AT
-    {0xFF01, 0xFF03},  // EXCLAMATION MARK..NUMBER SIGN
-    {0xFF04, 0xFF04},  // DOLLAR SIGN
-    {0xFF05, 0xFF07},  // PERCENT SIGN..APOSTROPHE
-    {0xFF08, 0xFF08},  // LEFT PARENTHESIS
-    {0xFF09, 0xFF09},  // RIGHT PARENTHESIS
-    {0xFF0A, 0xFF0A},  // ASTERISK
-    {0xFF0B, 0xFF0B},  // PLUS SIGN
-    {0xFF0C, 0xFF0C},  // COMMA
-    {0xFF0D, 0xFF0D},  // HYPHEN-MINUS
-    {0xFF0E, 0xFF0F},  // FULL STOP..SOLIDUS
-    {0xFF10, 0xFF19},  // DIGIT ZERO..DIGIT NINE
-    {0xFF1A, 0xFF1B},  // COLON..SEMICOLON
-    {0xFF1C, 0xFF1E},  // LESS-THAN..GREATER-THAN
-    {0xFF1F, 0xFF20},  // QUESTION MARK..COMMERCIAL AT
-    {0xFF21, 0xFF3A},  // LATIN CAPITAL LETTER A..Z
-    {0xFF3B, 0xFF3B},  // LEFT SQUARE BRACKET
-    {0xFF3C, 0xFF3C},  // REVERSE SOLIDUS
-    {0xFF3D, 0xFF3D},  // RIGHT SQUARE BRACKET
-    {0xFF3E, 0xFF3E},  // CIRCUMFLEX ACCENT
-    {0xFF3F, 0xFF3F},  // LOW LINE
-    {0xFF40, 0xFF40},  // GRAVE ACCENT
-    {0xFF41, 0xFF5A},  // LATIN SMALL LETTER A..Z
-    {0xFF5B, 0xFF5B},  // LEFT CURLY BRACKET
-    {0xFF5C, 0xFF5C},  // VERTICAL LINE
-    {0xFF5D, 0xFF5D},  // RIGHT CURLY BRACKET
-    {0xFF5E, 0xFF5E},  // TILDE
-    {0xFF5F, 0xFF5F},  // LEFT WHITE PARENTHESIS
-    {0xFF60, 0xFF60},  // RIGHT WHITE PARENTHESIS
-    {0xFFE0, 0xFFE1},  // CENT SIGN..POUND SIGN
-    {0xFFE2, 0xFFE2},  // NOT SIGN
-    {0xFFE3, 0xFFE3},  // MACRON
-    {0xFFE4, 0xFFE4},  // BROKEN BAR
-    {0xFFE5, 0xFFE6},  // YEN SIGN..WON SIGN
-};
-
-static const int kAstralWides[][2] = {
-    {0x16FE0, 0x16FE1},  // TANGUT ITERATION MARK..NUSHU ITERATION MARK
-    {0x16FE2, 0x16FE2},  // OLD CHINESE HOOK MARK
-    {0x16FE3, 0x16FE3},  // OLD CHINESE ITERATION MARK
-    {0x16FE4, 0x16FE4},  // KHITAN SMALL SCRIPT FILLER
-    {0x16FF0, 0x16FF1},  // VIETNAMESE ALTERNATE READING MARK CA..NHAY
-    {0x17000, 0x187F7},  // TANGUT IDEOGRAPH
-    {0x18800, 0x18AFF},  // TANGUT COMPONENT
-    {0x18B00, 0x18CD5},  // KHITAN SMALL SCRIPT CHARACTER
-    {0x18D00, 0x18D08},  // TANGUT IDEOGRAPH
-    {0x1AFF0, 0x1AFF3},  // KATAKANA LETTER MINNAN TONE-2..5
-    {0x1AFF5, 0x1AFFB},  // KATAKANA LETTER MINNAN TONE-7..5
-    {0x1AFFD, 0x1AFFE},  // KATAKANA LETTER MINNAN NASALIZED TONE-7..8
-    {0x1B000, 0x1B0FF},  // KATAKANA LETTER ARCHAIC E..HENTAIGANA LETTER RE-2
-    {0x1B100, 0x1B122},  // HENTAIGANA LETTER RE-3..KATAKANA LETTER ARCHAIC WU
-    {0x1B150, 0x1B152},  // HIRAGANA LETTER SMALL WI..HIRAGANA LETTER SMALL WO
-    {0x1B164, 0x1B167},  // KATAKANA LETTER SMALL WI..KATAKANA LETTER SMALL N
-    {0x1B170, 0x1B2FB},  // NUSHU CHARACTER-1B170..NUSHU CHARACTER-1B2FB
-    {0x1F004, 0x1F004},  // MAHJONG TILE RED DRAGON
-    {0x1F0CF, 0x1F0CF},  // PLAYING CARD BLACK JOKER
-    {0x1F18E, 0x1F18E},  // NEGATIVE SQUARED AB
-    {0x1F191, 0x1F19A},  // SQUARED CL..SQUARED VS
-    {0x1F200, 0x1F202},  // SQUARE HIRAGANA HOKA..SQUARED KATAKANA SA
-    {0x1F210, 0x1F23B},  // SQUARED CJK UNIFIED IDEOGRAPH
-    {0x1F240, 0x1F248},  // TORTOISE SHELL BRACKETED CJK UNIFIED IDEOGRAPH
-    {0x1F250, 0x1F251},  // CIRCLED IDEOGRAPH ADVANTAGE..ACCEPT
-    {0x1F260, 0x1F265},  // ROUNDED SYMBOL FOR FU..ROUNDED SYMBOL FOR CAI
-    {0x1F300, 0x1F320},  // CYCLONE..SHOOTING STAR
-    {0x1F32D, 0x1F335},  // HOT DOG..CACTUS
-    {0x1F337, 0x1F37C},  // TULIP..BABY BOTTLE
-    {0x1F37E, 0x1F393},  // BOTTLE WITH POPPING CORK..GRADUATION CAP
-    {0x1F3A0, 0x1F3CA},  // CAROUSEL HORSE..SWIMMER
-    {0x1F3CF, 0x1F3D3},  // CRICKET BAT AND BALL..TABLE TENNIS PADDLE AND BALL
-    {0x1F3E0, 0x1F3F0},  // HOUSE BUILDING..EUROPEAN CASTLE
-    {0x1F3F4, 0x1F3F4},  // WAVING BLACK FLAG
-    {0x1F3F8, 0x1F3FA},  // BADMINTON RACQUET AND SHUTTLECOCK..AMPHORA
-    {0x1F3FB, 0x1F3FF},  // EMOJI MODIFIER FITZPATRICK TYPE-1-2..6
-    {0x1F400, 0x1F43E},  // RAT..PAW PRINTS
-    {0x1F440, 0x1F440},  // EYES
-    {0x1F442, 0x1F4FC},  // EAR..VIDEOCASSETTE
-    {0x1F4FF, 0x1F53D},  // PRAYER BEADS..DOWN-POINTING SMALL RED TRIANGLE
-    {0x1F54B, 0x1F54E},  // KAABA..MENORAH WITH NINE BRANCHES
-    {0x1F550, 0x1F567},  // CLOCK FACE ONE OCLOCK..CLOCK FACE TWELVE-THIRTY
-    {0x1F57A, 0x1F57A},  // MAN DANCING
-    {0x1F595, 0x1F596},  // REVERSED HAND WITH MIDDLE FINGER EXTENDED..FINGERS
-    {0x1F5A4, 0x1F5A4},  // BLACK HEART
-    {0x1F5FB, 0x1F5FF},  // MOUNT FUJI..MOYAI
-    {0x1F600, 0x1F64F},  // GRINNING FACE..PERSON WITH FOLDED HANDS
-    {0x1F680, 0x1F6C5},  // ROCKET..LEFT LUGGAGE
-    {0x1F6CC, 0x1F6CC},  // SLEEPING ACCOMMODATION
-    {0x1F6D0, 0x1F6D2},  // PLACE OF WORSHIP..SHOPPING TROLLEY
-    {0x1F6D5, 0x1F6D7},  // HINDU TEMPLE..ELEVATOR
-    {0x1F6DD, 0x1F6DF},  // PLAYGROUND SLIDE..RING BUOY
-    {0x1F6EB, 0x1F6EC},  // AIRPLANE DEPARTURE..AIRPLANE ARRIVING
-    {0x1F6F4, 0x1F6FC},  // SCOOTER..ROLLER SKATE
-    {0x1F7E0, 0x1F7EB},  // LARGE ORANGE CIRCLE..LARGE BROWN SQUARE
-    {0x1F7F0, 0x1F7F0},  // HEAVY EQUALS SIGN
-    {0x1F90C, 0x1F93A},  // PINCHED FINGERS..FENCER
-    {0x1F93C, 0x1F945},  // WRESTLERS..GOAL NET
-    {0x1F947, 0x1F9FF},  // FIRST PLACE MEDAL..NAZAR AMULET
-    {0x1FA70, 0x1FA74},  // BALLET SHOES..THONG SANDAL
-    {0x1FA78, 0x1FA7C},  // DROP OF BLOOD..CRUTCH
-    {0x1FA80, 0x1FA86},  // YO-YO..NESTING DOLLS
-    {0x1FA90, 0x1FAAC},  // RINGED PLANET..HAMSA
-    {0x1FAB0, 0x1FABA},  // FLY..NEST WITH EGGS
-    {0x1FAC0, 0x1FAC5},  // ANATOMICAL HEART..PERSON WITH CROWN
-    {0x1FAD0, 0x1FAD9},  // BLUEBERRIES..JAR
-    {0x1FAE0, 0x1FAE7},  // MELTING FACE..BUBBLES
-    {0x1FAF0, 0x1FAF6},  // HAND WITH INDEX FINGER THUMB CROSSED..HEART HANDS
-    {0x20000, 0x2A6DF},  // CJK UNIFIED IDEOGRAPH
-    {0x2A6E0, 0x2A6FF},  // RESERVED
-    {0x2A700, 0x2B738},  // CJK UNIFIED IDEOGRAPH
-    {0x2B739, 0x2B73F},  // RESERVED
-    {0x2B740, 0x2B81D},  // CJK UNIFIED IDEOGRAPH
-    {0x2B81E, 0x2B81F},  // RESERVED
-    {0x2B820, 0x2CEA1},  // CJK UNIFIED IDEOGRAPH
-    {0x2CEA2, 0x2CEAF},  // RESERVED
-    {0x2CEB0, 0x2EBE0},  // CJK UNIFIED IDEOGRAPH
-    {0x2EBE1, 0x2F7FF},  // RESERVED
-    {0x2F800, 0x2FA1D},  // CJK COMPATIBILITY IDEOGRAPH
-    {0x2FA1E, 0x2FA1F},  // RESERVED
-    {0x2FA20, 0x2FFFD},  // RESERVED
-    {0x30000, 0x3134A},  // CJK UNIFIED IDEOGRAPH
-    {0x3134B, 0x3FFFD},  // RESERVED
-};
-
-pureconst bool IsWide(int c) {
-  int m, l, r, n;
-  if (c < 0x1100) {
-    return false;
-  } else if (c < 0x10000) {
-    l = 0;
-    r = n = sizeof(kWides) / sizeof(kWides[0]);
-    while (l < r) {
-      m = (l & r) + ((l ^ r) >> 1);  // floor((a+b)/2)
-      if (kWides[m][1] < c) {
-        l = m + 1;
-      } else {
-        r = m;
-      }
-    }
-    return l < n && kWides[l][0] <= c && c <= kWides[l][1];
-  } else {
-    l = 0;
-    r = n = sizeof(kAstralWides) / sizeof(kAstralWides[0]);
-    while (l < r) {
-      m = (l & r) + ((l ^ r) >> 1);  // floor((a+b)/2)
-      if (kAstralWides[m][1] < c) {
-        l = m + 1;
-      } else {
-        r = m;
-      }
-    }
-    return l < n && kAstralWides[l][0] <= c && c <= kAstralWides[l][1];
-  }
-}
-
-pureconst int GetMonospaceCharacterWidth(int c) {
-  return !IsControl(c) + IsWide(c);
+int GetMonospaceCharacterWidth(int c) {
+  int w = wcwidth(c);
+  if (w < 0)
+    w = 0;
+  return w;
 }
diff --git a/tool/plinko/lib/plinko.c b/tool/plinko/lib/plinko.c
index 26f9db1c6..00bb69622 100644
--- a/tool/plinko/lib/plinko.c
+++ b/tool/plinko/lib/plinko.c
@@ -22,11 +22,11 @@
 #include "libc/calls/syscall-sysv.internal.h"
 #include "libc/errno.h"
 #include "libc/intrin/likely.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/log/countbranch.h"
 #include "libc/log/countexpr.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/runtime/runtime.h"
 #include "libc/runtime/stack.h"
@@ -970,7 +970,7 @@ int Plinko(int argc, char *argv[]) {
   }
 
   if (mmap((void *)0x200000000000,
-           ROUNDUP((TERM + 1) * sizeof(g_mem[0]), __granularity()),
+           ROUNDUP((TERM + 1) * sizeof(g_mem[0]), getgransize()),
            PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1,
            0) == MAP_FAILED ||
       mmap((void *)(0x200000000000 +
@@ -979,7 +979,7 @@ int Plinko(int argc, char *argv[]) {
            PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1,
            0) == MAP_FAILED ||
       mmap((void *)0x400000000000,
-           ROUNDUP((TERM + 1) * sizeof(g_mem[0]), __granularity()),
+           ROUNDUP((TERM + 1) * sizeof(g_mem[0]), getgransize()),
            PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED, -1,
            0) == MAP_FAILED ||
       mmap((void *)(0x400000000000 +
diff --git a/tool/plinko/lib/printf.c b/tool/plinko/lib/printf.c
index 09b7da750..b7e058011 100644
--- a/tool/plinko/lib/printf.c
+++ b/tool/plinko/lib/printf.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "tool/plinko/lib/printf.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/nexgen32e/rdtsc.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
diff --git a/tool/plinko/lib/read.c b/tool/plinko/lib/read.c
index 04dd889a0..ad94f6370 100644
--- a/tool/plinko/lib/read.c
+++ b/tool/plinko/lib/read.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/strace.h"
 #include "libc/log/check.h"
 #include "libc/runtime/runtime.h"
 #include "libc/str/str.h"
diff --git a/tool/scripts/flakes b/tool/scripts/flakes
new file mode 100755
index 000000000..b054a336a
--- /dev/null
+++ b/tool/scripts/flakes
@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+import os
+import sys
+import subprocess
+import concurrent.futures
+from collections import Counter
+from typing import List, Dict, Tuple
+
+NUM_PARALLEL = int(os.cpu_count() * 20)
+
+def find_test_files(root: str) -> List[str]:
+    """Find all executable files ending with _test recursively."""
+    test_files = []
+    if os.path.isdir(root):
+        for root, _, files in os.walk(root):
+            for file in files:
+                if file.endswith('_test'):
+                    file_path = os.path.join(root, file)
+                    if os.access(file_path, os.X_OK):
+                        test_files.append(file_path)
+    elif root.endswith('_test'):
+        test_files.append(root)
+    return test_files
+
+def run_single_test(test_path: str) -> int:
+    """Run a single test and return its exit code."""
+    try:
+        result = subprocess.run(["ape", test_path], capture_output=False)
+        return result.returncode
+    except Exception as e:
+        print(f"Error running {test_path}: {e}")
+        return -1
+
+def run_test_multiple_times(test_path: str, iterations: int = NUM_PARALLEL) -> List[int]:
+    """Run a test multiple times in parallel and collect exit codes."""
+    with concurrent.futures.ProcessPoolExecutor() as executor:
+        futures = [executor.submit(run_single_test, test_path) for _ in range(iterations)]
+        return [f.result() for f in concurrent.futures.as_completed(futures)]
+
+def analyze_results(test_path: str, exit_codes: List[int]) -> Tuple[bool, Dict[int, int]]:
+    """Analyze test results and return if it flaked and error distribution."""
+    error_counts = Counter(code for code in exit_codes if code != 0)
+    return bool(error_counts), dict(error_counts)
+
+def print_flaky_report(test_path: str, error_distribution: Dict[int, int], total_runs: int):
+    """Print a report for a flaky test."""
+    print(f"{test_path} flaked!")
+    for exit_code, count in error_distribution.items():
+        print(f"* {count}/{total_runs} processes died with exit code {exit_code}")
+
+def main(directory = "o"):
+    test_files = find_test_files(directory)
+    for i, test_path in enumerate(test_files):
+        print("testing [%d/%d] %s..." % (i, len(test_files), test_path))
+        sys.stdout.flush()
+        exit_codes = run_test_multiple_times(test_path)
+        is_flaky, error_distribution = analyze_results(test_path, exit_codes)
+        if is_flaky:
+            print_flaky_report(test_path, error_distribution, len(exit_codes))
+            sys.exit(1)
+
+if __name__ == "__main__":
+    main(*sys.argv[1:])
diff --git a/tool/viz/BUILD.mk b/tool/viz/BUILD.mk
index a087fbf8e..5e2ced87d 100644
--- a/tool/viz/BUILD.mk
+++ b/tool/viz/BUILD.mk
@@ -16,6 +16,7 @@ TOOL_VIZ_BINS =						\
 	$(TOOL_VIZ_COMS:%=%.dbg)
 
 TOOL_VIZ_DIRECTDEPS =					\
+	DSP_AUDIO					\
 	DSP_CORE					\
 	DSP_MPEG					\
 	DSP_SCALE					\
@@ -27,6 +28,7 @@ TOOL_VIZ_DIRECTDEPS =					\
 	LIBC_MEM					\
 	LIBC_NEXGEN32E					\
 	LIBC_NT_COMDLG32				\
+	LIBC_NT_NTDLL					\
 	LIBC_NT_GDI32					\
 	LIBC_NT_KERNEL32				\
 	LIBC_NT_USER32					\
diff --git a/tool/viz/bin2asm.c b/tool/viz/bin2asm.c
index 37496fd93..99c785e5e 100644
--- a/tool/viz/bin2asm.c
+++ b/tool/viz/bin2asm.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 #define COLS 8
 
diff --git a/tool/viz/bing.c b/tool/viz/bing.c
index 1ded5fa49..750d0f032 100644
--- a/tool/viz/bing.c
+++ b/tool/viz/bing.c
@@ -22,7 +22,7 @@
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/sysv/consts/ex.h"
 #include "libc/sysv/consts/exit.h"
 #include "libc/sysv/consts/fileno.h"
diff --git a/tool/viz/clock_nanosleep_accuracy.c b/tool/viz/clock_nanosleep_accuracy.c
index b9a099fe7..6a8e162d0 100644
--- a/tool/viz/clock_nanosleep_accuracy.c
+++ b/tool/viz/clock_nanosleep_accuracy.c
@@ -16,46 +16,50 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include <assert.h>
+#include <stdio.h>
+#include <time.h>
 #include "libc/assert.h"
-#include "libc/calls/struct/timespec.h"
-#include "libc/intrin/kprintf.h"
-#include "libc/runtime/runtime.h"
-#include "libc/stdio/stdio.h"
-#include "libc/sysv/consts/clock.h"
+#include "libc/dce.h"
+#include "libc/nt/enum/processcreationflags.h"
+#include "libc/nt/enum/status.h"
+#include "libc/nt/enum/threadpriority.h"
+#include "libc/nt/ntdll.h"
+#include "libc/nt/process.h"
+#include "libc/nt/runtime.h"
+#include "libc/nt/thread.h"
+#include "libc/nt/windows.h"
 
-#define MAXIMUM    1e9
+#define MAXIMUM    1e8
 #define ITERATIONS 10
 
-void TestSleepRealRelative(void) {
-  printf("\n");
-  printf("testing: clock_nanosleep(CLOCK_REALTIME) with relative "
-         "timeout\n");
-  for (long nanos = 1; nanos < (long)MAXIMUM; nanos *= 2) {
-    struct timespec t1, t2, wf;
-    wf = timespec_fromnanos(nanos);
-    clock_gettime(CLOCK_REALTIME, &t1);
-    for (int i = 0; i < ITERATIONS; ++i) {
-      npassert(!clock_nanosleep(CLOCK_REALTIME, 0, &wf, 0));
-    }
-    clock_gettime(CLOCK_REALTIME, &t2);
-    long took = timespec_tonanos(timespec_sub(t2, t1)) / ITERATIONS;
-    printf("%,12ld ns sleep took %,12ld ns delta %,12ld ns\n", nanos, took,
-           took - nanos);
-  }
+const char *MyDescribeClockName(int clock) {
+  if (clock == CLOCK_REALTIME)
+    return "CLOCK_REALTIME";
+  if (clock == CLOCK_MONOTONIC)
+    return "CLOCK_MONOTONIC";
+  if (clock == CLOCK_BOOTTIME)
+    return "CLOCK_BOOTTIME";
+  if (clock == CLOCK_REALTIME_COARSE)
+    return "CLOCK_REALTIME_COARSE";
+  if (clock == CLOCK_MONOTONIC_COARSE)
+    return "CLOCK_MONOTONIC_COARSE";
+  __builtin_trap();
 }
 
-void TestSleepMonoRelative(void) {
+void TestSleepRelative(int clock) {
   printf("\n");
-  printf("testing: clock_nanosleep(CLOCK_MONOTONIC) with relative "
-         "timeout\n");
-  for (long nanos = 1; nanos < (long)MAXIMUM; nanos *= 2) {
+  printf("testing: clock_nanosleep(%s) with relative timeout\n",
+         MyDescribeClockName(clock));
+  for (long nanos = 1; nanos < (long)MAXIMUM; nanos *= 4) {
     struct timespec t1, t2, wf;
     wf = timespec_fromnanos(nanos);
-    clock_gettime(CLOCK_REALTIME, &t1);
+    if (clock_gettime(clock, &t1))
+      return;
     for (int i = 0; i < ITERATIONS; ++i) {
-      npassert(!clock_nanosleep(CLOCK_MONOTONIC, 0, &wf, 0));
+      unassert(!clock_nanosleep(clock, 0, &wf, 0));
     }
-    clock_gettime(CLOCK_REALTIME, &t2);
+    clock_gettime(clock, &t2);
     long took = timespec_tonanos(timespec_sub(t2, t1)) / ITERATIONS;
     printf("%,12ld ns sleep took %,12ld ns delta %,12ld ns\n", nanos, took,
            took - nanos);
@@ -63,6 +67,9 @@ void TestSleepMonoRelative(void) {
 }
 
 int main(int argc, char *argv[]) {
-  TestSleepRealRelative();
-  TestSleepMonoRelative();
+  TestSleepRelative(CLOCK_REALTIME);
+  TestSleepRelative(CLOCK_REALTIME_COARSE);
+  TestSleepRelative(CLOCK_MONOTONIC);
+  TestSleepRelative(CLOCK_BOOTTIME);
+  TestSleepRelative(CLOCK_MONOTONIC_COARSE);
 }
diff --git a/tool/viz/cpuid.c b/tool/viz/cpuid.c
index 0384d4f30..1e3e44a97 100644
--- a/tool/viz/cpuid.c
+++ b/tool/viz/cpuid.c
@@ -35,6 +35,15 @@
 #define CANIUSE(FEATURE) caniuse(#FEATURE, X86_HAVE(FEATURE))
 #define SHOW(CONSTANT)   show(#CONSTANT, CONSTANT)
 
+static void cpuid(unsigned leaf, unsigned subleaf, unsigned *eax, unsigned *ebx,
+                  unsigned *ecx, unsigned *edx) {
+  asm("movq\t%%rbx,%%rsi\n\t"
+      "cpuid\n\t"
+      "xchgq\t%%rbx,%%rsi"
+      : "=a"(*eax), "=S"(*ebx), "=c"(*ecx), "=d"(*edx)
+      : "0"(leaf), "2"(subleaf));
+}
+
 static void caniuse(const char *feature, bool present) {
   printf("%-20s%s%s%s\n", feature, present ? GREEN : RED,
          present ? "present" : "unavailable", RESET);
@@ -70,7 +79,7 @@ static void showstrata(void) {
   }
 }
 
-void showcachesizes(void) {
+void showcachesizes_intel(void) {
   unsigned i;
   CPUID4_ITERATE(i, {
     printf("%-19s%s%s %2u-way %,9u byte cache w/%s %,6u sets of %u byte lines "
@@ -90,6 +99,81 @@ void showcachesizes(void) {
   });
 }
 
+static const char *const kAmdAssociativityStr[16] = {
+    "Disabled",               //
+    "1 way (direct mapped)",  //
+    "2 way",                  //
+    "4 way",                  //
+    "8 way",                  //
+    "16 way",                 //
+    "32 way",                 //
+    "48 way",                 //
+    "64 way",                 //
+    "96 way",                 //
+    "128 way",                //
+    "Fully Associative",      //
+};
+
+void showcachesizes_amd() {
+  unsigned eax, ebx, ecx, edx;
+
+  cpuid(0x80000005, 0, &eax, &ebx, &ecx, &edx);
+
+  unsigned L1_dataCache_size = (ecx >> 24) & 0xff;
+  unsigned L1_dataCache_associativity = (ecx >> 16) & 0xff;
+  unsigned L1_dataCache_linesPerTag = (ecx >> 8) & 0xff;
+  unsigned L1_dataCache_lineSize = (ecx >> 0) & 0xff;
+
+  unsigned L1_instrCache_size = (ecx >> 24) & 0xff;
+  unsigned L1_instrCache_associativity = (ecx >> 16) & 0xff;
+  unsigned L1_instrCache_linesPerTag = (ecx >> 8) & 0xff;
+  unsigned L1_instrCache_lineSize = (ecx >> 0) & 0xff;
+
+  cpuid(0x80000006, 0, &eax, &ebx, &ecx, &edx);
+
+  unsigned L2_size = (ecx >> 16) & 0xffff;
+  unsigned L2_associativity = (ecx >> 12) & 0xf;
+  unsigned L2_linesPerTag = (ecx >> 8) & 0xf;
+  unsigned L2_lineSize = (ecx >> 0) & 0xff;
+
+  unsigned L3_size = (edx >> 18) & 0x3fff;
+  unsigned L3_associativity = (edx >> 12) & 0xf;
+  unsigned L3_linesPerTag = (edx >> 8) & 0xf;
+  unsigned L3_lineSize = (edx >> 0) & 0xff;
+
+  printf("L1 Data Cache:\n"
+         "\tSize: %d KB\n"
+         "\tAssociativity: %d way\n"
+         "\tLines per Tag: %d\n"
+         "\tLine Size: %d B\n"
+         "\n"
+         "L1 Instruction Cache:\n"
+         "\tSize: %d KB\n"
+         "\tAssociativity: %d way\n"
+         "\tLines per Tag: %d\n"
+         "\tLine Size: %d B\n",
+         L1_dataCache_size, L1_dataCache_associativity,
+         L1_dataCache_linesPerTag, L1_dataCache_lineSize, L1_instrCache_size,
+         L1_instrCache_associativity, L1_instrCache_linesPerTag,
+         L1_instrCache_lineSize);
+
+  printf("L2 Cache:\n"
+         "\tSize: %d KB\n"
+         "\tAssociativity: %s\n"
+         "\tLines per Tag: %d\n"
+         "\tLine Size: %d B\n"
+         "\n"
+         "L3 Cache:\n"
+         "\tSize: %d KB\n"
+         "\tAssociativity: %s\n"
+         "\tLines per Tag: %d\n"
+         "\tLine Size: %d B\n",
+         L2_size, kAmdAssociativityStr[L2_associativity & 15], L2_linesPerTag,
+         L2_lineSize, L3_size * 512,
+         kAmdAssociativityStr[L3_associativity & 15], L3_linesPerTag,
+         L3_lineSize);
+}
+
 int main(int argc, char *argv[]) {
   int x;
   long tsc_aux;
@@ -146,7 +230,8 @@ int main(int argc, char *argv[]) {
   printf("\n");
   printf("Caches\n");
   printf("──────\n");
-  showcachesizes();
+  showcachesizes_intel();
+  showcachesizes_amd();
 
   printf("\n");
   printf("Features\n");
@@ -163,15 +248,7 @@ int main(int argc, char *argv[]) {
          X86_HAVE(AVX2) ? "present" : "unavailable", RESET,
          (!X86_HAVE(AVX2) && ({
            unsigned eax, ebx, ecx, edx;
-           asm("push\t%%rbx\n\t"
-               "cpuid\n\t"
-               "mov\t%%ebx,%1\n\t"
-               "pop\t%%rbx"
-               : "=a"(eax), "=rm"(ebx), "=c"(ecx), "=d"(edx)
-               : "0"(7), "2"(0));
-           (void)eax;
-           (void)ecx;
-           (void)edx;
+           cpuid(7, 0, &eax, &ebx, &ecx, &edx);
            !!(ebx & (1u << 5));
          }))
              ? " (disabled by operating system)"
@@ -287,6 +364,7 @@ int main(int argc, char *argv[]) {
   CANIUSE(TM2);
   CANIUSE(TME);
   CANIUSE(TSC);
+  CANIUSE(INVTSC);
   CANIUSE(TSC_ADJUST);
   CANIUSE(TSC_DEADLINE_TIMER);
   CANIUSE(TSX_FORCE_ABORT);
diff --git a/tool/viz/deathstar.c b/tool/viz/deathstar.c
index f06a827fd..a5d0621dc 100644
--- a/tool/viz/deathstar.c
+++ b/tool/viz/deathstar.c
@@ -1,7 +1,7 @@
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/sigaction.h"
 #include "libc/calls/struct/termios.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/math.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
diff --git a/tool/viz/derasterize.c b/tool/viz/derasterize.c
index 5beaada39..abd982197 100644
--- a/tool/viz/derasterize.c
+++ b/tool/viz/derasterize.c
@@ -25,7 +25,7 @@
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
@@ -452,7 +452,6 @@ static void PrintImage(unsigned yn, unsigned xn,
   size_t size;
   char *v, *vt;
   size = yn * (xn * (32 + (2 + (1 + 3) * 3) * 2 + 1 + 3)) * 1 + 5 + 1;
-  size = ROUNDUP(size, __granularity());
   CHECK_NOTNULL((vt = _mapanon(size)));
   v = RenderImage(vt, yn, xn, rgb);
   *v++ = '\r';
@@ -550,8 +549,8 @@ static void LoadFile(const char *path, size_t yn, size_t xn, void *rgb) {
   stbir_resize_uint8(data, gotx, goty, 0, rgb, xn * XS, yn * YS, 0, CN);
 #else
   CHECK_EQ(CN, 3);
-  data2size = ROUNDUP(sizeof(float) * goty * gotx * CN, __granularity());
-  data3size = ROUNDUP(sizeof(float) * yn * YS * xn * XS * CN, __granularity());
+  data2size = sizeof(float) * goty * gotx * CN;
+  data3size = sizeof(float) * yn * YS * xn * XS * CN;
   CHECK_NOTNULL((data2 = _mapanon(data2size)));
   CHECK_NOTNULL((data3 = _mapanon(data3size)));
   rgb2lin(goty * gotx * CN, data2, data);
@@ -625,7 +624,7 @@ int main(int argc, char *argv[]) {
   // FIXME: on the conversion stage should do 2Y because of halfblocks
   // printf( "filename >%s<\tx >%d<\ty >%d<\n\n", filename, x_, y_);
   size = y_ * YS * x_ * XS * CN;
-  CHECK_NOTNULL((rgb = _mapanon(ROUNDUP(size, __granularity()))));
+  CHECK_NOTNULL((rgb = _mapanon(size)));
   for (i = optind; i < argc; ++i) {
     if (!argv[i])
       continue;
@@ -636,7 +635,7 @@ int main(int argc, char *argv[]) {
     }
     PrintImage(y_, x_, rgb);
   }
-  munmap(rgb, ROUNDUP(size, __granularity()));
+  munmap(rgb, size);
   return 0;
 }
 
diff --git a/tool/viz/dumphexc.c b/tool/viz/dumphexc.c
index d7f40a953..095b7804d 100644
--- a/tool/viz/dumphexc.c
+++ b/tool/viz/dumphexc.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/append.h"
 #include "libc/stdio/hex.internal.h"
diff --git a/tool/viz/fixconsole.c b/tool/viz/fixconsole.c
index ea656d477..8bd23e075 100644
--- a/tool/viz/fixconsole.c
+++ b/tool/viz/fixconsole.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/dce.h"
-#include "libc/intrin/describeflags.internal.h"
+#include "libc/intrin/describeflags.h"
 #include "libc/nt/console.h"
 #include "libc/nt/enum/consolemodeflags.h"
 #include "libc/nt/runtime.h"
diff --git a/tool/viz/fold.c b/tool/viz/fold.c
index 1663a3dfc..2fe852001 100644
--- a/tool/viz/fold.c
+++ b/tool/viz/fold.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
diff --git a/tool/viz/fontspace.c b/tool/viz/fontspace.c
index 875a73648..7e81629c8 100644
--- a/tool/viz/fontspace.c
+++ b/tool/viz/fontspace.c
@@ -24,7 +24,7 @@
 #include "libc/intrin/bsr.h"
 #include "libc/log/libfatal.internal.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/runtime/runtime.h"
diff --git a/tool/viz/getglyph.c b/tool/viz/getglyph.c
index 4a7d30f68..4c2a3b5f3 100644
--- a/tool/viz/getglyph.c
+++ b/tool/viz/getglyph.c
@@ -20,7 +20,7 @@
 #include "libc/fmt/conv.h"
 #include "libc/limits.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
 #include "libc/stdio/append.h"
diff --git a/tool/viz/getifaddrs.c b/tool/viz/getifaddrs.c
index bd9b22de8..142e8005e 100644
--- a/tool/viz/getifaddrs.c
+++ b/tool/viz/getifaddrs.c
@@ -33,7 +33,7 @@
    eth0
    addr: 10.10.10.237
    netmask: 255.255.255.0
-   broadcast: 255.255.255.0
+   broadcast: 10.10.10.255
    flags: IFF_UP IFF_BROADCAST IFF_MULTICAST IFF_RUNNING
 
    lo
@@ -74,13 +74,87 @@ int main(int argc, char *argv[]) {
       tinyprint(1, "netmask: ", buf, "\n", NULL);
     }
     if ((ifa->ifa_flags & IFF_BROADCAST) &&
-        sockaddr2str(ifa->ifa_netmask, buf, sizeof(buf))) {
+        sockaddr2str(ifa->ifa_broadaddr, buf, sizeof(buf))) {
       tinyprint(1, "broadcast: ", buf, "\n", NULL);
     } else if ((ifa->ifa_flags & IFF_POINTOPOINT) &&
                sockaddr2str(ifa->ifa_dstaddr, buf, sizeof(buf))) {
       tinyprint(1, "dstaddr: ", buf, "\n", NULL);
     }
 
+    if (ifa->ifa_addr->sa_family == AF_INET6) {
+      int scope = ((int *)ifa->ifa_data)[0];
+      int aflags = ((int *)ifa->ifa_data)[1];
+      // #define IPV6_ADDR_LOOPBACK	0x0010U
+      // #define IPV6_ADDR_LINKLOCAL	0x0020U
+      // #define IPV6_ADDR_SITELOCAL	0x0040U
+
+      // #define IFA_F_TEMPORARY		0x01
+      // #define	IFA_F_NODAD		0x02
+      // #define IFA_F_OPTIMISTIC	0x04
+      // #define IFA_F_DADFAILED		0x08
+      // #define	IFA_F_HOMEADDRESS	0x10
+      // #define IFA_F_DEPRECATED	0x20
+      // #define IFA_F_TENTATIVE		0x40
+      // #define IFA_F_PERMANENT		0x80
+      // #define IFA_F_MANAGETEMPADDR	0x100
+      // #define IFA_F_NOPREFIXROUTE	0x200
+      // #define IFA_F_MCAUTOJOIN	0x400
+      // #define IFA_F_STABLE_PRIVACY	0x800
+      tinyprint(1, "scope:", NULL);
+      if (scope == 0x10) {
+        tinyprint(1, " loopback", NULL);
+      }
+      if (scope == 0x20) {
+        tinyprint(1, " linklocal", NULL);
+      }
+      if (scope == 0x40) {
+        tinyprint(1, " sitelocal", NULL);
+      }
+      if (scope == 0x00) {
+        tinyprint(1, " global", NULL);
+      }
+      tinyprint(1, "\n", NULL);
+
+      tinyprint(1, "addr flags:", NULL);
+      if (aflags & 0x01) {
+        tinyprint(1, " temporary", NULL);
+      }
+      if (aflags & 0x02) {
+        tinyprint(1, " nodad", NULL);
+      }
+      if (aflags & 0x04) {
+        tinyprint(1, " optimistic", NULL);
+      }
+      if (aflags & 0x08) {
+        tinyprint(1, " dadfailed", NULL);
+      }
+      if (aflags & 0x10) {
+        tinyprint(1, " homeaddress", NULL);
+      }
+      if (aflags & 0x20) {
+        tinyprint(1, " deprecated", NULL);
+      }
+      if (aflags & 0x40) {
+        tinyprint(1, " tentative", NULL);
+      }
+      if (aflags & 0x80) {
+        tinyprint(1, " permanent", NULL);
+      }
+      if (aflags & 0x100) {
+        tinyprint(1, " managetempaddr", NULL);
+      }
+      if (aflags & 0x200) {
+        tinyprint(1, " noprefixroute", NULL);
+      }
+      if (aflags & 0x400) {
+        tinyprint(1, " mcautojoin", NULL);
+      }
+      if (aflags & 0x800) {
+        tinyprint(1, " stable_privacy", NULL);
+      }
+      tinyprint(1, "\n", NULL);
+    }
+
     tinyprint(1, "flags:", NULL);
     if (ifa->ifa_flags & IFF_UP) {
       tinyprint(1, " IFF_UP", NULL);
diff --git a/tool/viz/lib/BUILD.mk b/tool/viz/lib/BUILD.mk
index 92512372c..e76dd3e01 100644
--- a/tool/viz/lib/BUILD.mk
+++ b/tool/viz/lib/BUILD.mk
@@ -36,6 +36,7 @@ TOOL_VIZ_LIB_A_DIRECTDEPS =				\
 	LIBC_RUNTIME					\
 	LIBC_STDIO					\
 	LIBC_STR					\
+	LIBC_THREAD					\
 	LIBC_SYSV					\
 	LIBC_TESTLIB					\
 	LIBC_TINYMATH					\
diff --git a/tool/viz/lib/bilinearscale.c b/tool/viz/lib/bilinearscale.c
index fd58723a9..586e848bd 100644
--- a/tool/viz/lib/bilinearscale.c
+++ b/tool/viz/lib/bilinearscale.c
@@ -21,7 +21,7 @@
 #include "libc/intrin/bsr.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
diff --git a/tool/viz/lib/dither.c b/tool/viz/lib/dither.c
index d61a39049..dcb43ea7d 100644
--- a/tool/viz/lib/dither.c
+++ b/tool/viz/lib/dither.c
@@ -20,7 +20,7 @@
 #include "libc/intrin/hilbert.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
diff --git a/tool/viz/lib/doublechrominance.S b/tool/viz/lib/doublechrominance.S
index b316fb9b1..0db0eb343 100644
--- a/tool/viz/lib/doublechrominance.S
+++ b/tool/viz/lib/doublechrominance.S
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 
 //	Duplicates chrominance samples horizontally, e.g.
 //
diff --git a/tool/viz/lib/formatmatrix-byte.c b/tool/viz/lib/formatmatrix-byte.c
index cc3cb1e9f..ea899051e 100644
--- a/tool/viz/lib/formatmatrix-byte.c
+++ b/tool/viz/lib/formatmatrix-byte.c
@@ -52,7 +52,7 @@ char *StringifyMatrixByte(long yn, long xn, const unsigned char M[yn][xn],
                           StringTableFormatter formatter, const char *param1,
                           const char *param2, const char *param3) {
   struct StringBuilder *sb = NewStringBuilder();
-  FormatMatrixByte(yn, xn, M, StringBuilderAppend, sb, formatter, param1,
-                   param2, param3);
+  FormatMatrixByte(yn, xn, M, (void *)StringBuilderAppend, sb, formatter,
+                   param1, param2, param3);
   return FreeStringBuilder(sb);
 }
diff --git a/tool/viz/lib/formatmatrix-double.c b/tool/viz/lib/formatmatrix-double.c
index 108c932e9..8d2c93562 100644
--- a/tool/viz/lib/formatmatrix-double.c
+++ b/tool/viz/lib/formatmatrix-double.c
@@ -61,7 +61,7 @@ char *StringifyMatrixDouble(long yn, long xn, const double M[yn][xn],
                             const char *param2, const char *param3, double digs,
                             double rounder(double)) {
   struct StringBuilder *sb = NewStringBuilder();
-  FormatMatrixDouble(yn, xn, M, StringBuilderAppend, sb, formatter, param1,
-                     param2, param3, digs, rounder);
+  FormatMatrixDouble(yn, xn, M, (void *)StringBuilderAppend, sb, formatter,
+                     param1, param2, param3, digs, rounder);
   return FreeStringBuilder(sb);
 }
diff --git a/tool/viz/lib/formatmatrix-short.c b/tool/viz/lib/formatmatrix-short.c
index 586501cc1..1f41737a2 100644
--- a/tool/viz/lib/formatmatrix-short.c
+++ b/tool/viz/lib/formatmatrix-short.c
@@ -53,7 +53,7 @@ char *StringifyMatrixShort(long yn, long xn, const short M[yn][xn],
                            StringTableFormatter formatter, const char *param1,
                            const char *param2, const char *param3) {
   struct StringBuilder *sb = NewStringBuilder();
-  FormatMatrixShort(yn, xn, M, StringBuilderAppend, sb, formatter, param1,
-                    param2, param3);
+  FormatMatrixShort(yn, xn, M, (void *)StringBuilderAppend, sb, formatter,
+                    param1, param2, param3);
   return FreeStringBuilder(sb);
 }
diff --git a/tool/viz/lib/formatstringtable-assembly.c b/tool/viz/lib/formatstringtable-assembly.c
index b126c60bc..4e553b2e4 100644
--- a/tool/viz/lib/formatstringtable-assembly.c
+++ b/tool/viz/lib/formatstringtable-assembly.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/gc.h"
 #include "libc/str/str.h"
 #include "libc/str/strwidth.h"
@@ -77,31 +77,33 @@ static const char *GetStorageSpecifier(const char *type, int *out_width,
 
 static void EmitSection(long yn, long xn, int w, int arrayalign, int emit(),
                         void *a) {
+  void (*Emit)(const char *, void *) = (void (*)(const char *, void *))emit;
   char alignstr[21];
   FormatUint32(alignstr, arrayalign);
   if (arrayalign <= 8 && yn * xn * w == 8) {
-    emit("\t.rodata.cst", a);
-    emit("8\n", a);
+    Emit("\t.rodata.cst", a);
+    Emit("8\n", a);
   } else if (arrayalign <= 16 && yn * xn * w == 16) {
-    emit("\t.rodata.cst", a);
-    emit("16\n", a);
+    Emit("\t.rodata.cst", a);
+    Emit("16\n", a);
   } else if (arrayalign <= 32 && yn * xn * w == 32) {
-    emit("\t.rodata.cst", a);
-    emit("32\n", a);
+    Emit("\t.rodata.cst", a);
+    Emit("32\n", a);
   } else if (arrayalign <= 64 && yn * xn * w == 64) {
-    emit("\t.rodata.cst", a);
-    emit("64\n", a);
+    Emit("\t.rodata.cst", a);
+    Emit("64\n", a);
   } else {
-    emit("\t.rodata\n", a);
-    emit("\t.align\t", a);
-    emit(alignstr, a);
-    emit("\n", a);
+    Emit("\t.rodata\n", a);
+    Emit("\t.align\t", a);
+    Emit(alignstr, a);
+    Emit("\n", a);
   }
 }
 
 void *FormatStringTableAsAssembly(long yn, long xn, const char *const T[yn][xn],
                                   int emit(), void *a, const char *type,
                                   const char *name, const char *scope) {
+  void (*Emit)(const char *, void *) = (void (*)(const char *, void *))emit;
   int w, align;
   const char *storage;
   char ynstr[21], xnstr[21];
@@ -110,16 +112,16 @@ void *FormatStringTableAsAssembly(long yn, long xn, const char *const T[yn][xn],
   FormatUint64(ynstr, yn);
   FormatUint64(xnstr, xn);
   EmitSection(yn, xn, w, GetArrayAlignment(yn, xn, w, align), emit, a);
-  emit(name, a);
-  emit(":", a);
+  Emit(name, a);
+  Emit(":", a);
   if (strwidth(name, 0) >= 8)
-    emit("\n", a);
+    Emit("\n", a);
   FormatStringTable(yn, xn, T, emit, a, gc(xstrcat("\t.", storage, "\t")), ",",
                     "\n");
-  emit("\t.endobj\t", a);
-  emit(name, a);
-  emit(",", a);
-  emit(firstnonnull(scope, "globl"), a);
-  emit("\n\t.previous\n", a);
+  Emit("\t.endobj\t", a);
+  Emit(name, a);
+  Emit(",", a);
+  Emit(firstnonnull(scope, "globl"), a);
+  Emit("\n\t.previous\n", a);
   return (/* unconst */ void *)T;
 }
diff --git a/tool/viz/lib/formatstringtable-code.c b/tool/viz/lib/formatstringtable-code.c
index 1034dc875..cbda49336 100644
--- a/tool/viz/lib/formatstringtable-code.c
+++ b/tool/viz/lib/formatstringtable-code.c
@@ -17,24 +17,25 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/itoa.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "tool/viz/lib/formatstringtable.h"
 
 void *FormatStringTableAsCode(long yn, long xn, const char *const T[yn][xn],
                               int emit(), void *arg, const char *type,
                               const char *name, const char *ignored) {
+  void (*Emit)(const char *, void *) = (void (*)(const char *, void *))emit;
   char ynstr[21], xnstr[21];
   FormatUint64(ynstr, yn);
   FormatUint64(xnstr, xn);
-  emit(type, arg);
-  emit(" ", arg);
-  emit(firstnonnull(name, "M"), arg);
-  emit("[", arg);
-  emit(ynstr, arg);
-  emit("][", arg);
-  emit(xnstr, arg);
-  emit("] = {", arg);
+  Emit(type, arg);
+  Emit(" ", arg);
+  Emit(firstnonnull(name, "M"), arg);
+  Emit("[", arg);
+  Emit(ynstr, arg);
+  Emit("][", arg);
+  Emit(xnstr, arg);
+  Emit("] = {", arg);
   FormatStringTable(yn, xn, T, emit, arg, "\n    {", ", ", "},");
-  emit("\n};\n", arg);
+  Emit("\n};\n", arg);
   return (/* unconst */ void *)T;
 }
diff --git a/tool/viz/lib/formatstringtable-testlib.h b/tool/viz/lib/formatstringtable-testlib.h
index b4eb037c6..1b884965e 100644
--- a/tool/viz/lib/formatstringtable-testlib.h
+++ b/tool/viz/lib/formatstringtable-testlib.h
@@ -1,6 +1,6 @@
 #ifndef COSMOPOLITAN_TOOL_VIZ_LIB_FORMATSTRINGTABLE_TESTLIB_H_
 #define COSMOPOLITAN_TOOL_VIZ_LIB_FORMATSTRINGTABLE_TESTLIB_H_
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/str/str.h"
 #include "libc/testlib/testlib.h"
 #include "tool/viz/lib/formatstringtable.h"
diff --git a/tool/viz/lib/formatstringtable.c b/tool/viz/lib/formatstringtable.c
index af74d3b3b..3433fba75 100644
--- a/tool/viz/lib/formatstringtable.c
+++ b/tool/viz/lib/formatstringtable.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "tool/viz/lib/formatstringtable.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/mem/mem.h"
 #include "libc/str/strwidth.h"
 
@@ -46,18 +46,19 @@ static unsigned GetBiggestCellWidth(long yn, long xn,
 void *FormatStringTable(long yn, long xn, const char *const T[yn][xn],
                         int emit(), void *a, const char *startrow,
                         const char *comma, const char *endrow) {
+  void (*Emit)(const char *, void *) = (void (*)(const char *, void *))emit;
   long w, y, x, i, n;
   w = GetBiggestCellWidth(yn, xn, T);
   for (y = 0; y < yn; ++y) {
-    emit(startrow, a);
+    Emit(startrow, a);
     for (x = 0; x < xn; ++x) {
       if (x)
-        emit(comma, a);
+        Emit(comma, a);
       for (n = w - strwidth(T[y][x], 0), i = 0; i < n; ++i)
-        emit(" ", a);
-      emit(T[y][x], a);
+        Emit(" ", a);
+      Emit(T[y][x], a);
     }
-    emit(endrow, a);
+    Emit(endrow, a);
   }
   return (/* unconst */ void *)T;
 }
diff --git a/tool/viz/lib/gaussian.c b/tool/viz/lib/gaussian.c
index fb1cd87a8..c737b2240 100644
--- a/tool/viz/lib/gaussian.c
+++ b/tool/viz/lib/gaussian.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
diff --git a/tool/viz/lib/getxtermcodes.c b/tool/viz/lib/getxtermcodes.c
index 52908f3ab..0f00469e8 100644
--- a/tool/viz/lib/getxtermcodes.c
+++ b/tool/viz/lib/getxtermcodes.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/tty/quant.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "tool/viz/lib/graphic.h"
 
 void getxtermcodes(struct TtyRgb *p, const struct Graphic *g) {
diff --git a/tool/viz/lib/perlin3.c b/tool/viz/lib/perlin3.c
index 138296e11..f9f81e9c9 100644
--- a/tool/viz/lib/perlin3.c
+++ b/tool/viz/lib/perlin3.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "tool/viz/lib/graphic.h"
 
diff --git a/tool/viz/lib/sharpen.c b/tool/viz/lib/sharpen.c
index eec139e4d..c79586537 100644
--- a/tool/viz/lib/sharpen.c
+++ b/tool/viz/lib/sharpen.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "dsp/core/ks8.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
diff --git a/tool/viz/lib/sobel.c b/tool/viz/lib/sobel.c
index b26ad3113..1f83878ee 100644
--- a/tool/viz/lib/sobel.c
+++ b/tool/viz/lib/sobel.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/nexgen32e.h"
@@ -37,8 +37,7 @@ forceinline void ConvolveGradient(unsigned yn, unsigned xn,
   size_t size;
   unsigned y, x, i, j, k;
   float py[4], px[4], (*tmp)[yn][xn][4];
-  tmp =
-      _mapanon((size = ROUNDUP(sizeof(float) * 4 * xn * yn, __granularity())));
+  tmp = _mapanon((size = ROUNDUP(sizeof(float) * 4 * xn * yn, getgransize())));
   for (y = 0; y < yn - KW + 1; ++y) {
     for (x = 0; x < xn - KW + 1; ++x) {
       for (k = 0; k < 4; ++k)
diff --git a/tool/viz/lib/stringbuilder.c b/tool/viz/lib/stringbuilder.c
index f9419a41e..85906bf8b 100644
--- a/tool/viz/lib/stringbuilder.c
+++ b/tool/viz/lib/stringbuilder.c
@@ -18,7 +18,7 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "tool/viz/lib/stringbuilder.h"
 #include "libc/log/check.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "libc/x/x.h"
diff --git a/tool/viz/lib/unsharp.c b/tool/viz/lib/unsharp.c
index 8bd6f272c..4514f8265 100644
--- a/tool/viz/lib/unsharp.c
+++ b/tool/viz/lib/unsharp.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/str/str.h"
 #include "libc/sysv/errfuns.h"
diff --git a/tool/viz/lib/writetoframebuffer.c b/tool/viz/lib/writetoframebuffer.c
index f46d95387..9a2b7a116 100644
--- a/tool/viz/lib/writetoframebuffer.c
+++ b/tool/viz/lib/writetoframebuffer.c
@@ -16,7 +16,7 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "tool/viz/lib/graphic.h"
 
 void WriteToFrameBuffer(size_t dyn, size_t dxn, unsigned char dst[dyn][dxn][4],
diff --git a/tool/viz/lib/ycbcr2rgb3.c b/tool/viz/lib/ycbcr2rgb3.c
index 96d7d52ff..b400b961b 100644
--- a/tool/viz/lib/ycbcr2rgb3.c
+++ b/tool/viz/lib/ycbcr2rgb3.c
@@ -30,10 +30,9 @@
 #include "libc/calls/struct/sigset.h"
 #include "libc/calls/struct/timespec.h"
 #include "libc/intrin/bsr.h"
-#include "libc/intrin/pmulhrsw.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
@@ -44,6 +43,7 @@
 #include "libc/str/str.h"
 #include "libc/sysv/consts/sig.h"
 #include "libc/sysv/errfuns.h"
+#include "libc/thread/thread.h"
 #include "libc/time.h"
 #include "libc/x/x.h"
 #include "tool/viz/lib/graphic.h"
@@ -70,6 +70,7 @@ struct timespec magikarp_start_;
 
 struct YCbCr {
   bool yonly;
+  int cpu_count;
   int magnums[8][4];
   int lighting[6][4];
   unsigned char transfer[2][256];
@@ -166,6 +167,7 @@ void YCbCrInit(struct YCbCr **ycbcr, bool yonly, int swing, double gamma,
   if (!*ycbcr)
     *ycbcr = xcalloc(1, sizeof(struct YCbCr));
   (*ycbcr)->yonly = yonly;
+  (*ycbcr)->cpu_count = __get_cpu_count();
   bzero((*ycbcr)->magnums, sizeof((*ycbcr)->magnums));
   bzero((*ycbcr)->lighting, sizeof((*ycbcr)->lighting));
   YCbCrComputeCoefficients(swing, gamma, gamut, illuminant, (*ycbcr)->magnums,
@@ -264,14 +266,32 @@ void YCbCrConvert(struct YCbCr *me, long yn, long xn,
                   const unsigned char Y[restrict yys][yxs], long cys, long cxs,
                   unsigned char Cb[restrict cys][cxs],
                   unsigned char Cr[restrict cys][cxs]) {
-  struct timespec ts = timespec_real();
+  struct timespec ts = timespec_mono();
   if (!me->yonly) {
     YCbCr2Rgb(yn, xn, RGB, yys, yxs, Y, cys, cxs, Cb, Cr, me->magnums,
               me->lighting, me->transfer[pf10_]);
   } else {
     Y2Rgb(yn, xn, RGB, yys, yxs, Y, me->magnums, me->transfer[pf10_]);
   }
-  ycbcr2rgb_latency_ = timespec_tomicros(timespec_sub(timespec_real(), ts));
+  ycbcr2rgb_latency_ = timespec_tomicros(timespec_sub(timespec_mono(), ts));
+}
+
+struct YCbCr2RgbScalerThreadData {
+  long syw, sxw, dyw, dxw, dyn, dxn, syn, sxn;
+  unsigned char *src;
+  unsigned char *dst;
+  int min, max;
+  struct SamplingSolution *cy, *cx;
+  bool sharpen;
+};
+
+static void *YCbCr2RgbScalerThread(void *arg) {
+  struct YCbCr2RgbScalerThreadData *data =
+      (struct YCbCr2RgbScalerThreadData *)arg;
+  GyaradosUint8(data->syw, data->sxw, data->src, data->dyw, data->dxw,
+                data->dst, data->dyn, data->dxn, data->syn, data->sxn,
+                data->min, data->max, data->cy, data->cx, data->sharpen);
+  return NULL;
 }
 
 void YCbCr2RgbScaler(struct YCbCr *me, long dyn, long dxn,
@@ -298,7 +318,7 @@ void YCbCr2RgbScaler(struct YCbCr *me, long dyn, long dxn,
                     Magkern2xY(cys, cxs, Cr, scyn, scxn), HALF(yyn), yxn,
                     HALF(cyn), scxn, syn / 2, sxn, pry, prx);
   } else {
-    struct timespec ts = timespec_real();
+    struct timespec ts = timespec_mono();
     magikarp_latency_ = timespec_tomicros(timespec_sub(ts, magikarp_start_));
     yry = syn / dyn;
     yrx = sxn / dxn;
@@ -323,13 +343,83 @@ void YCbCr2RgbScaler(struct YCbCr *me, long dyn, long dxn,
       sharpen(1, yys, yxs, (void *)Y, yyn, yxn);
     if (pf9_)
       unsharp(1, yys, yxs, (void *)Y, yyn, yxn);
-    GyaradosUint8(yys, yxs, Y, yys, yxs, Y, dyn, dxn, syn, sxn, 0, 255,
-                  me->luma.cy, me->luma.cx, true);
-    GyaradosUint8(cys, cxs, Cb, cys, cxs, Cb, dyn, dxn, scyn, scxn, 0, 255,
-                  me->chroma.cy, me->chroma.cx, false);
-    GyaradosUint8(cys, cxs, Cr, cys, cxs, Cr, dyn, dxn, scyn, scxn, 0, 255,
-                  me->chroma.cy, me->chroma.cx, false);
-    gyarados_latency_ = timespec_tomicros(timespec_sub(timespec_real(), ts));
+
+    if (me->cpu_count < 6) {
+      GyaradosUint8(yys, yxs, Y, yys, yxs, Y, dyn, dxn, syn, sxn, 0, 255,
+                    me->luma.cy, me->luma.cx, true);
+      GyaradosUint8(cys, cxs, Cb, cys, cxs, Cb, dyn, dxn, scyn, scxn, 0, 255,
+                    me->chroma.cy, me->chroma.cx, false);
+      GyaradosUint8(cys, cxs, Cr, cys, cxs, Cr, dyn, dxn, scyn, scxn, 0, 255,
+                    me->chroma.cy, me->chroma.cx, false);
+    } else {
+      pthread_t threads[3];
+      struct YCbCr2RgbScalerThreadData thread_data[3];
+
+      // Set up thread data for Y plane.
+      thread_data[0] = (struct YCbCr2RgbScalerThreadData){
+          .syw = yys,
+          .sxw = yxs,
+          .dyw = yys,
+          .dxw = yxs,
+          .dyn = dyn,
+          .dxn = dxn,
+          .syn = syn,
+          .sxn = sxn,
+          .src = (unsigned char *)Y,
+          .dst = (unsigned char *)Y,
+          .min = 0,
+          .max = 255,
+          .cy = me->luma.cy,
+          .cx = me->luma.cx,
+          .sharpen = true,
+      };
+
+      // Set up thread data for Cb plane.
+      thread_data[1] = (struct YCbCr2RgbScalerThreadData){
+          .syw = cys,
+          .sxw = cxs,
+          .dyw = cys,
+          .dxw = cxs,
+          .dyn = dyn,
+          .dxn = dxn,
+          .syn = scyn,
+          .sxn = scxn,
+          .src = (unsigned char *)Cb,
+          .dst = (unsigned char *)Cb,
+          .min = 0,
+          .max = 255,
+          .cy = me->chroma.cy,
+          .cx = me->chroma.cx,
+          .sharpen = false,
+      };
+
+      // Set up thread data for Cr plane.
+      thread_data[2] = (struct YCbCr2RgbScalerThreadData){
+          .syw = cys,
+          .sxw = cxs,
+          .dyw = cys,
+          .dxw = cxs,
+          .dyn = dyn,
+          .dxn = dxn,
+          .syn = scyn,
+          .sxn = scxn,
+          .src = (unsigned char *)Cr,
+          .dst = (unsigned char *)Cr,
+          .min = 0,
+          .max = 255,
+          .cy = me->chroma.cy,
+          .cx = me->chroma.cx,
+          .sharpen = false,
+      };
+
+      // Dispatch threads.
+      for (int i = 0; i < 3; i++)
+        pthread_create(&threads[i], NULL, YCbCr2RgbScalerThread,
+                       &thread_data[i]);
+      for (int i = 3; i--;)
+        pthread_join(threads[i], NULL);
+    }
+    gyarados_latency_ = timespec_tomicros(timespec_sub(timespec_mono(), ts));
     YCbCrConvert(me, dyn, dxn, RGB, yys, yxs, Y, cys, cxs, Cb, Cr);
     INFOF("done");
   }
@@ -384,7 +474,7 @@ void *YCbCr2RgbScale(long dyn, long dxn,
   CHECK_LE(cyn, cys);
   CHECK_LE(cxn, cxs);
   INFOF("magikarp2x");
-  magikarp_start_ = timespec_real();
+  magikarp_start_ = timespec_mono();
   minyys = MAX(ceil(syn), MAX(yyn, ceil(dyn * pry)));
   minyxs = MAX(ceil(sxn), MAX(yxn, ceil(dxn * prx)));
   mincys = MAX(cyn, ceil(dyn * pry));
diff --git a/tool/viz/life.c b/tool/viz/life.c
index 896e19034..3b105eb6b 100644
--- a/tool/viz/life.c
+++ b/tool/viz/life.c
@@ -22,16 +22,17 @@
 #include "libc/calls/struct/termios.h"
 #include "libc/calls/struct/winsize.h"
 #include "libc/calls/termios.h"
+#include "libc/ctype.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/popcnt.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/intrin/xchg.internal.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/intrin/xchg.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/mem/mem.h"
 #include "libc/nexgen32e/nt2sysv.h"
 #include "libc/nt/comdlg.h"
@@ -497,18 +498,18 @@ static void *NewBoard(size_t *out_size) {
   char *p;
   size_t s, n, k;
   s = (byn * bxn) >> 3;
-  k = getauxval(AT_PAGESZ) + ROUNDUP(s, getauxval(AT_PAGESZ));
-  n = ROUNDUP(k + getauxval(AT_PAGESZ), sysconf(_SC_PAGESIZE));
+  k = getpagesize() + ROUNDUP(s, getpagesize());
+  n = ROUNDUP(k + getpagesize(), sysconf(_SC_PAGESIZE));
   p = _mapanon(n);
-  mprotect(p, getauxval(AT_PAGESZ), 0);
+  mprotect(p, getpagesize(), 0);
   mprotect(p + k, n - k, 0);
   if (out_size)
     *out_size = n;
-  return p + getauxval(AT_PAGESZ);
+  return p + getpagesize();
 }
 
 static void FreeBoard(void *p, size_t n) {
-  munmap((char *)p - getauxval(AT_PAGESZ), n);
+  munmap((char *)p - getpagesize(), n);
 }
 
 static void AllocateBoardsWithHardwareAcceleratedMemorySafety(void) {
@@ -1129,7 +1130,7 @@ static bool ShouldDraw(void) {
   static struct timespec next;
   if (!isdragging)
     return true;
-  now = timespec_real();
+  now = timespec_mono();
   if (timespec_cmp(now, next) > 0 && !HasPendingInput()) {
     next = timespec_add(now, timespec_frommicros(1. / 24 * 1e6));
     return true;
diff --git a/tool/viz/malloc_scalability.c b/tool/viz/malloc_scalability.c
new file mode 100644
index 000000000..6f9c71fbf
--- /dev/null
+++ b/tool/viz/malloc_scalability.c
@@ -0,0 +1,56 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/struct/timespec.h"
+#include "libc/mem/mem.h"
+#include "libc/runtime/runtime.h"
+#include "libc/stdio/stdio.h"
+#include "libc/thread/thread.h"
+
+#define ALLOCATIONS 1000
+
+void *worker(void *arg) {
+  void **ptrs = malloc(ALLOCATIONS * sizeof(void *));
+  for (int i = 0; i < ALLOCATIONS; ++i)
+    ptrs[i] = malloc(1);
+  for (int i = 0; i < ALLOCATIONS; ++i)
+    free(ptrs[i]);
+  free(ptrs);
+  return 0;
+}
+
+void test(int n) {
+  struct timespec start = timespec_mono();
+  pthread_t *th = malloc(sizeof(pthread_t) * n);
+  for (int i = 0; i < n; ++i)
+    pthread_create(th + i, 0, worker, 0);
+  for (int i = 0; i < n; ++i)
+    pthread_join(th[i], 0);
+  free(th);
+  struct timespec end = timespec_mono();
+  printf("%2d threads * %d allocs = %ld us\n", n, ALLOCATIONS,
+         timespec_tomicros(timespec_sub(end, start)));
+}
+
+int main(int argc, char *argv[]) {
+  int n = __get_cpu_count();
+  if (n < 8)
+    n = 8;
+  for (int i = 1; i <= n; ++i)
+    test(i);
+}
diff --git a/tool/viz/memzoom.c b/tool/viz/memzoom.c
index 21fbbd0d1..6481562d3 100644
--- a/tool/viz/memzoom.c
+++ b/tool/viz/memzoom.c
@@ -25,6 +25,7 @@
 #include "libc/calls/struct/winsize.h"
 #include "libc/calls/termios.h"
 #include "libc/calls/ucontext.h"
+#include "libc/ctype.h"
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
@@ -32,17 +33,18 @@
 #include "libc/intrin/bsf.h"
 #include "libc/intrin/bsr.h"
 #include "libc/intrin/hilbert.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/pollfd.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 #include "libc/str/unicode.h"
+#include "libc/sysv/consts/clock.h"
 #include "libc/sysv/consts/ex.h"
 #include "libc/sysv/consts/exit.h"
 #include "libc/sysv/consts/fileno.h"
@@ -281,8 +283,8 @@ static void SetupCanvas(void) {
     munmap(buffer, buffersize);
   }
   displaysize = ROUNDUP(ROUNDUP((tyn * txn) << zoom, 16), 1ul << zoom);
-  canvassize = ROUNDUP(displaysize, __granularity());
-  buffersize = ROUNDUP(tyn * txn * 16 + 4096, __granularity());
+  canvassize = ROUNDUP(displaysize, getgransize());
+  buffersize = ROUNDUP(tyn * txn * 16 + 4096, getgransize());
   canvas = Allocate(canvassize);
   buffer = Allocate(buffersize);
 }
@@ -333,10 +335,11 @@ static long Index(long y, long x) {
 static void PreventBufferbloat(void) {
   struct timespec now, rate;
   static struct timespec last;
-  now = timespec_real();
+  now = timespec_mono();
   rate = timespec_frommicros(1. / fps * 1e6);
   if (timespec_cmp(timespec_sub(now, last), rate) < 0) {
-    timespec_sleep(timespec_sub(rate, timespec_sub(now, last)));
+    timespec_sleep(CLOCK_MONOTONIC,
+                   timespec_sub(rate, timespec_sub(now, last)));
   }
   last = now;
 }
diff --git a/tool/viz/printansi.c b/tool/viz/printansi.c
index dd9ebaf59..900dd8b3a 100644
--- a/tool/viz/printansi.c
+++ b/tool/viz/printansi.c
@@ -29,11 +29,11 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
-#include "libc/intrin/safemacros.internal.h"
+#include "libc/intrin/safemacros.h"
 #include "libc/limits.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/gc.h"
 #include "libc/mem/mem.h"
diff --git a/tool/viz/printdos2errno.c b/tool/viz/printdos2errno.c
index 7f06d581f..4218f6968 100644
--- a/tool/viz/printdos2errno.c
+++ b/tool/viz/printdos2errno.c
@@ -17,7 +17,7 @@
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/fmt/magnumstrs.internal.h"
-#include "libc/intrin/dos2errno.internal.h"
+#include "libc/intrin/dos2errno.h"
 #include "libc/intrin/kprintf.h"
 #include "libc/str/str.h"
 
diff --git a/tool/viz/printvideo.c b/tool/viz/printvideo.c
index b348fabe5..cd35f672c 100644
--- a/tool/viz/printvideo.c
+++ b/tool/viz/printvideo.c
@@ -16,10 +16,11 @@
 │ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
 │ PERFORMANCE OF THIS SOFTWARE.                                                │
 ╚─────────────────────────────────────────────────────────────────────────────*/
+#include "dsp/audio/cosmoaudio/cosmoaudio.h"
 #include "dsp/core/core.h"
 #include "dsp/core/half.h"
 #include "dsp/core/illumination.h"
-#include "dsp/mpeg/mpeg.h"
+#include "dsp/mpeg/pl_mpeg.h"
 #include "dsp/scale/scale.h"
 #include "dsp/tty/quant.h"
 #include "dsp/tty/tty.h"
@@ -37,16 +38,18 @@
 #include "libc/calls/struct/winsize.h"
 #include "libc/calls/termios.h"
 #include "libc/calls/ucontext.h"
+#include "libc/ctype.h"
 #include "libc/cxxabi.h"
+#include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
 #include "libc/fmt/itoa.h"
 #include "libc/intrin/kprintf.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/intrin/xchg.internal.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/intrin/xchg.h"
 #include "libc/log/check.h"
 #include "libc/log/log.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/math.h"
 #include "libc/mem/alg.h"
 #include "libc/mem/arraylist.internal.h"
@@ -54,7 +57,9 @@
 #include "libc/nexgen32e/bench.h"
 #include "libc/nexgen32e/x86feature.h"
 #include "libc/nt/console.h"
+#include "libc/nt/enum/threadpriority.h"
 #include "libc/nt/runtime.h"
+#include "libc/nt/thread.h"
 #include "libc/runtime/runtime.h"
 #include "libc/sock/sock.h"
 #include "libc/sock/struct/pollfd.h"
@@ -141,8 +146,6 @@ Effects Shortcuts:\n\
   CTRL-G     {Unsharp,Sharp}\n\
 \n\
 Environment Variables:\n\
-  SOX        overrides location of SoX executable\n\
-  FFPLAY     overrides location of FFmpeg ffplay executable\n\
   ROWS=𝑦     sets height [inarticulate mode]\n\
   COLUMNS=𝑥  sets width  [inarticulate mode]\n\
   TERM=dumb  inarticulate mode\n\
@@ -157,11 +160,6 @@ in a different format, then it's fast and easy to convert them:\n\
 The terminal fonts we recommend are PragmataPro, Bitstream Vera Sans\n\
 Mono (known as DejaVu Sans Mono in the open source community), Menlo,\n\
 and Lucida Console.\n\
-\n\
-On Linux, playing audio requires either `sox` or `ffplay` being on\n\
-the $PATH. Kitty is the fastest terminal. Alacritty also has a fast\n\
-display. GNOME Terminal and xterm both work well in 256-color or ANSI\n\
-mode.\n\
 \n"
 
 #define CTRL(C)   ((C) ^ 0100)
@@ -177,9 +175,9 @@ mode.\n\
 
 #define TIMEIT(OUT_NANOS, FORM)                                           \
   do {                                                                    \
-    struct timespec Start = timespec_real();                              \
+    struct timespec Start = timespec_mono();                              \
     FORM;                                                                 \
-    (OUT_NANOS) = timespec_tonanos(timespec_sub(timespec_real(), Start)); \
+    (OUT_NANOS) = timespec_tonanos(timespec_sub(timespec_mono(), Start)); \
   } while (0)
 
 typedef bool (*openspeaker_f)(void);
@@ -225,16 +223,6 @@ struct FrameBuffer {
   struct FrameBufferVirtualScreenInfo vscreen;
 };
 
-static const struct itimerval kTimerDisarm = {
-    {0, 0},
-    {0, 0},
-};
-
-static const struct itimerval kTimerHalfSecondSingleShot = {
-    {0, 0},
-    {0, 500000},
-};
-
 static const struct NamedVector kPrimaries[] = {
     {"BT.601", &kBt601Primaries},
     {"BT.709", &kBt709Primaries},
@@ -254,7 +242,8 @@ static const struct NamedVector kLightings[] = {
 
 static plm_t *plm_;
 static float gamma_;
-static int volscale_;
+static float volscale_;
+struct CosmoAudio *ca_;
 static enum Blur blur_;
 static enum Sharp sharp_;
 static jmp_buf jb_, jbi_;
@@ -262,32 +251,27 @@ static double pary_, parx_;
 static struct TtyIdent ti_;
 static struct YCbCr *ycbcr_;
 static bool emboss_, sobel_;
-static volatile int playpid_;
+static const char *patharg_;
 static struct winsize wsize_;
 static float hue_, sat_, lit_;
+static volatile bool resized_;
 static void *xtcodes_, *audio_;
 static struct FrameBuffer fb0_;
 static unsigned chans_, srate_;
 static volatile bool ignoresigs_;
 static size_t dh_, dw_, framecount_;
 static struct FrameCountRing fcring_;
-static volatile bool resized_, piped_;
 static int lumakernel_, chromakernel_;
-static openspeaker_f tryspeakerfns_[4];
 static int primaries_, lighting_, swing_;
 static uint64_t t1, t2, t3, t4, t5, t6, t8;
-static const char *sox_, *ffplay_, *patharg_;
+static int homerow_, lastrow_, infd_, outfd_;
 static struct VtFrame vtframe_[2], *f1_, *f2_;
 static struct Graphic graphic_[2], *g1_, *g2_;
 static struct timespec deadline_, dura_, starttime_;
 static bool yes_, stats_, dither_, ttymode_, istango_;
 static struct timespec decode_start_, f1_start_, f2_start_;
-static int16_t pcm_[PLM_AUDIO_SAMPLES_PER_FRAME * 2 / 8][8];
-static int16_t pcmscale_[PLM_AUDIO_SAMPLES_PER_FRAME * 2 / 8][8];
 static bool fullclear_, historyclear_, tuned_, yonly_, gotvideo_;
-static int homerow_, lastrow_, playfd_, infd_, outfd_, speakerfails_;
-static char status_[7][200], logpath_[PATH_MAX], fifopath_[PATH_MAX],
-    chansstr_[32], sratestr_[32];
+static char status_[7][200], logpath_[PATH_MAX], chansstr_[32], sratestr_[32];
 
 static void OnCtrlC(void) {
   longjmp(jb_, 1);
@@ -297,29 +281,15 @@ static void OnResize(void) {
   resized_ = true;
 }
 
-static void OnSigPipe(void) {
-  piped_ = true;
-}
-
-static void OnSigChld(void) {
-  playpid_ = 0, piped_ = true;
-}
-
-static void StrikeDownCrapware(int sig) {
-  kill(playpid_, SIGKILL);
-}
-
 static struct timespec GetGraceTime(void) {
-  return timespec_sub(deadline_, timespec_real());
+  return timespec_sub(deadline_, timespec_mono());
 }
 
 static char *strntoupper(char *s, size_t n) {
   size_t i;
-  for (i = 0; s[i] && i < n; ++i) {
-    if ('a' <= s[i] && s[i] <= 'z') {
+  for (i = 0; s[i] && i < n; ++i)
+    if ('a' <= s[i] && s[i] <= 'z')
       s[i] -= 'a' - 'A';
-    }
-  }
   return s;
 }
 
@@ -332,11 +302,9 @@ static int GetNamedVector(const struct NamedVector *choices, size_t n,
   strncpy(name, s, sizeof(name));
 #pragma GCC pop_options
   strntoupper(name, sizeof(name));
-  for (i = 0; i < n; ++i) {
-    if (memcmp(choices[i].name, name, sizeof(name)) == 0) {
+  for (i = 0; i < n; ++i)
+    if (memcmp(choices[i].name, name, sizeof(name)) == 0)
       return i;
-    }
-  }
   return -1;
 }
 
@@ -348,32 +316,9 @@ static int GetLighting(const char *s) {
   return GetNamedVector(kLightings, ARRAYLEN(kLightings), s);
 }
 
-static bool CloseSpeaker(void) {
-  int rc, wstatus;
-  rc = 0;
-  pthread_yield();
-  if (playfd_) {
-    rc |= close(playfd_);
-    playfd_ = -1;
-  }
-  if (playpid_) {
-    kill(playpid_, SIGTERM);
-    xsigaction(SIGALRM, StrikeDownCrapware, SA_RESETHAND, 0, 0);
-    setitimer(ITIMER_REAL, &kTimerHalfSecondSingleShot, NULL);
-    while (playpid_) {
-      if (waitpid(playpid_, &wstatus, 0) != -1) {
-        rc |= WEXITSTATUS(wstatus);
-      } else if (errno == EINTR) {
-        continue;
-      } else {
-        rc = -1;
-      }
-      break;
-    }
-    playpid_ = 0;
-    setitimer(ITIMER_REAL, &kTimerDisarm, NULL);
-  }
-  return !!rc;
+static void CloseSpeaker(void) {
+  cosmoaudio_close(ca_);
+  ca_ = 0;
 }
 
 static void ResizeVtFrame(struct VtFrame *f, size_t yn, size_t xn) {
@@ -387,7 +332,7 @@ static float timespec_tofloat(struct timespec ts) {
 
 static void RecordFactThatFrameWasFullyRendered(void) {
   fcring_.p[fcring_.i] =
-      timespec_tofloat(timespec_sub(timespec_real(), starttime_));
+      timespec_tofloat(timespec_sub(timespec_mono(), starttime_));
   fcring_.n += 1;
   fcring_.i += 1;
   fcring_.i &= ARRAYLEN(fcring_.p) - 1;
@@ -437,9 +382,8 @@ static void DimensionDisplay(void) {
       wsize_.ws_row = 25;
       wsize_.ws_col = 80;
       wsize_ = (struct winsize){.ws_row = 40, .ws_col = 80};
-      if (tcgetwinsize(outfd_, &wsize_) == -1) {
+      if (tcgetwinsize(outfd_, &wsize_) == -1)
         tcgetwinsize(0, &wsize_);
-      }
       dh_ = wsize_.ws_row * 2;
       dw_ = wsize_.ws_col * 2;
     }
@@ -463,124 +407,37 @@ static void DimensionDisplay(void) {
     ResizeVtFrame(&vtframe_[1], (g2_->yn), g2_->xn);
     f1_ = &vtframe_[0];
     f2_ = &vtframe_[1];
-    if (ttymode_) {
+    if (ttymode_)
       homerow_ = MIN(wsize_.ws_row - HALF(g2_->yn),
                      HALF(wsize_.ws_row - HALF(g2_->yn)));
-    }
     lastrow_ = homerow_ + HALF(g2_->yn);
     ComputeColoringSolution();
   } while (resized_);
 }
 
-static int WriteAudio(int fd, const void *data, size_t size, int deadlinems) {
-  ssize_t rc;
-  const char *p;
-  size_t wrote, n;
-  p = data;
-  n = size;
-  do {
-  TryAgain:
-    if ((rc = write(fd, p, n)) != -1) {
-      wrote = rc;
-      p += wrote;
-      n -= wrote;
-    } else if (errno == EINTR) {
-      goto TryAgain;
-    } else if (errno == EAGAIN) {
-      if (poll((struct pollfd[]){{fd, POLLOUT}}, 1, deadlinems) == 0) {
-        return etimedout();
-      }
-    } else {
-      return -1;
-    }
-  } while (n);
-  return 0;
-}
-
-static bool TrySpeaker(const char *prog, char *const *args) {
-  int pipefds[2];
-  CHECK_NE(-1, pipe2(pipefds, O_CLOEXEC));
-  if (!(playpid_ = fork())) {
-    dup2(pipefds[0], 0);
-    dup2(fileno(__log_file), 1);
-    dup2(fileno(__log_file), 2);
-    close(fileno(__log_file));
-    execv(prog, args);
-    abort();
-  }
-  playfd_ = pipefds[1];
-  return true;
-}
-
-static bool TrySox(void) {
-  return TrySpeaker(sox_, ARGZ("play", "-q", "-c", chansstr_, "-traw",
-                               "-esigned", "-b16", "-r", sratestr_, "-"));
-}
-
-static bool TryFfplay(void) {
-  return TrySpeaker(ffplay_, ARGZ("ffplay", "-nodisp", "-loglevel", "quiet",
-                                  "-fflags", "nobuffer", "-ac", chansstr_,
-                                  "-ar", sratestr_, "-f", "s16le", "pipe:"));
-}
-
 static bool OpenSpeaker(void) {
-  size_t i;
-  static bool once, count;
-  if (!once) {
-    once = true;
-    i = 0;
-    if (ffplay_)
-      tryspeakerfns_[i++] = TryFfplay;
-    if (sox_)
-      tryspeakerfns_[i++] = TrySox;
-  }
-  snprintf(fifopath_, sizeof(fifopath_), "%s%s.%d.%d.wav", __get_tmpdir(),
-           firstnonnull(program_invocation_short_name, "unknown"), getpid(),
-           count);
-  for (i = 0; i < ARRAYLEN(tryspeakerfns_); ++i) {
-    if (tryspeakerfns_[i]) {
-      if (++speakerfails_ <= 2 && tryspeakerfns_[i]()) {
-        return true;
-      } else {
-        speakerfails_ = 0;
-        tryspeakerfns_[i] = NULL;
-      }
-    }
-  }
-  return false;
+  struct CosmoAudioOpenOptions cao = {};
+  cao.sizeofThis = sizeof(struct CosmoAudioOpenOptions);
+  cao.deviceType = kCosmoAudioDeviceTypePlayback;
+  cao.sampleRate = srate_;
+  cao.channels = chans_;
+  return cosmoaudio_open(&ca_, &cao) == COSMOAUDIO_SUCCESS;
 }
 
 static void OnAudio(plm_t *mpeg, plm_samples_t *samples, void *user) {
-  if (playfd_ != -1) {
-    DEBUGF("OnAudio() [grace=%,ldns]", timespec_tonanos(GetGraceTime()));
-    CHECK_EQ(2, chans_);
-    CHECK_EQ(ARRAYLEN(pcm_) * 8, samples->count * chans_);
-    float2short(ARRAYLEN(pcm_), pcm_, (void *)samples->interleaved);
-    scalevolume(ARRAYLEN(pcm_), pcm_, volscale_);
-    sad16x8n(ARRAYLEN(pcm_), pcm_, pcmscale_);
-    DEBUGF("transcoded audio");
-  TryAgain:
-    if (WriteAudio(playfd_, pcm_, sizeof(pcm_), 1000) != -1) {
-      DEBUGF("WriteAudio(%d, %zu) ok [grace=%,ldns]", playfd_,
-             samples->count * 2, timespec_tonanos(GetGraceTime()));
-    } else {
-      WARNF("WriteAudio(%d, %zu) failed: %s", playfd_, samples->count * 2,
-            strerror(errno));
-      CloseSpeaker();
-      if (OpenSpeaker()) {
-        goto TryAgain;
-      }
-    }
-  }
+  if (!ca_)
+    return;
+  if (volscale_ != 1.f)
+    for (unsigned i = 0; i < samples->count * chans_; ++i)
+      samples->interleaved[i] *= volscale_;
+  cosmoaudio_write(ca_, samples->interleaved, samples->count);
 }
 
 static void DescribeAlgorithms(char *p) {
-  if (dither_ && TTYQUANT()->alg != kTtyQuantTrue) {
+  if (dither_ && TTYQUANT()->alg != kTtyQuantTrue)
     p = stpcpy(p, " ℍithered");
-  }
-  if (yonly_) {
+  if (yonly_)
     p = stpcpy(p, " grayscaled");
-  }
   p += sprintf(p, " magikarp:%d:%d", lumakernel_, chromakernel_);
   switch (TTYQUANT()->alg) {
     case kTtyQuantTrue:
@@ -785,7 +642,7 @@ static void RasterIt(void) {
   static bool once;
   static void *buf;
   if (!once) {
-    buf = _mapanon(ROUNDUP(fb0_.size, __granularity()));
+    buf = _mapanon(ROUNDUP(fb0_.size, getgransize()));
     once = true;
   }
   WriteToFrameBuffer(fb0_.vscreen.yres_virtual, fb0_.vscreen.xres_virtual, buf,
@@ -842,9 +699,8 @@ static void TranscodeVideo(plm_frame_t *pf) {
       default:
         break;
     }
-    if (dither_ && TTYQUANT()->alg != kTtyQuantTrue) {
+    if (dither_ && TTYQUANT()->alg != kTtyQuantTrue)
       dither(g2_->yn, g2_->xn, g2_->b, g2_->yn, g2_->xn);
-    }
   });
 
   if (ShouldUseFrameBuffer()) {
@@ -884,7 +740,6 @@ static void OnVideo(plm_t *mpeg, plm_frame_t *pf, void *user) {
 
 static void OpenVideo(void) {
   size_t yn, xn;
-  playfd_ = -1;
   INFOF("%s(%`'s)", "OpenVideo", patharg_);
   CHECK_NOTNULL((plm_ = plm_create_with_filename(patharg_)));
   swing_ = 219;
@@ -899,9 +754,9 @@ static void OpenVideo(void) {
   FormatInt64(chansstr_, (chans_ = 2));
   FormatInt64(sratestr_, (srate_ = plm_get_samplerate(plm_)));
   if (plm_get_num_audio_streams(plm_) && OpenSpeaker()) {
-    plm_set_audio_enabled(plm_, true, 0);
+    plm_set_audio_enabled(plm_, true);
   } else {
-    plm_set_audio_enabled(plm_, false, 0);
+    plm_set_audio_enabled(plm_, false);
   }
   g2_ = g1_ = resizegraphic(&graphic_[0], yn, xn);
 }
@@ -912,13 +767,12 @@ static ssize_t WriteVideoCall(void) {
   amt = min(4096 * 4, f1_->n - f1_->i);
   if ((rc = write(outfd_, f1_->bytes + f1_->i, amt)) != -1) {
     if ((f1_->i += rc) == f1_->n) {
-      if (plm_get_audio_enabled(plm_)) {
+      if (plm_get_audio_enabled(plm_))
         plm_set_audio_lead_time(
             plm_,
             max(0,
-                min(timespec_tofloat(timespec_sub(timespec_real(), f1_start_)),
+                min(timespec_tofloat(timespec_sub(timespec_mono(), f1_start_)),
                     plm_get_samplerate(plm_) / PLM_AUDIO_SAMPLES_PER_FRAME)));
-      }
       f1_start_ = f2_start_;
       f1_->i = f1_->n = 0;
       struct VtFrame *t = f1_;
@@ -934,9 +788,8 @@ static void DrainVideo(void) {
     ttywrite(outfd_, f1_->bytes + f1_->i, f1_->n - f1_->i);
     f1_->i = f1_->n = 0;
   }
-  if (f2_ && f2_->n) {
+  if (f2_ && f2_->n)
     f2_->i = f2_->n = 0;
-  }
 }
 
 static void WriteVideo(void) {
@@ -1089,10 +942,10 @@ static optimizesize void ReadKeyboard(void) {
               case '[':
                 switch (b[i++]) {
                   case 'A': /* "\e[A" is up arrow */
-                    ++volscale_;
+                    volscale_ *= 1.05f;
                     break;
                   case 'B': /* "\e[B" is down arrow */
-                    --volscale_;
+                    volscale_ *= 0.95f;
                     break;
                   case 'C': /* "\e[C" is right arrow */
                     break;
@@ -1313,9 +1166,9 @@ static void PerformBestEffortIo(void) {
     DEBUGF("poll() toto=%d [grace=%,ldns]", toto,
            timespec_tonanos(GetGraceTime()));
     if (toto) {
-      if (fds[0].revents & (POLLIN | POLLERR))
+      if (fds[0].revents & (POLLIN | POLLHUP | POLLERR))
         ReadKeyboard();
-      if (fds[1].revents & (POLLOUT | POLLERR))
+      if (fds[1].revents & (POLLOUT | POLLHUP | POLLERR))
         WriteVideo();
     }
   } else if (errno == EINTR) {
@@ -1335,14 +1188,8 @@ static void RestoreTty(void) {
 }
 
 static void HandleSignals(void) {
-  if (piped_) {
-    WARNF("SIGPIPE");
-    CloseSpeaker();
-    piped_ = false;
-  }
-  if (resized_) {
+  if (resized_)
     RefreshDisplay();
-  }
 }
 
 static void PrintVideo(void) {
@@ -1350,20 +1197,19 @@ static void PrintVideo(void) {
   dura_ = timespec_frommicros(min(MAX_FRAMERATE, 1 / plm_get_framerate(plm_)) *
                               1e6);
   INFOF("framerate=%f dura=%f", plm_get_framerate(plm_), dura_);
-  next_tick = deadline_ = decode_last = timespec_real();
+  next_tick = deadline_ = decode_last = timespec_mono();
   next_tick = timespec_add(next_tick, dura_);
   deadline_ = timespec_add(deadline_, dura_);
   do {
     DEBUGF("plm_decode [grace=%,ldns]", timespec_tonanos(GetGraceTime()));
-    decode_start_ = timespec_real();
+    decode_start_ = timespec_mono();
     plm_decode(plm_,
                timespec_tofloat(timespec_sub(decode_start_, decode_last)));
     decode_last = decode_start_;
-    decode_end = timespec_real();
+    decode_end = timespec_mono();
     lag = timespec_sub(decode_end, decode_start_);
-    while (timespec_cmp(timespec_add(decode_end, lag), next_tick) > 0) {
+    while (timespec_cmp(timespec_add(decode_end, lag), next_tick) > 0)
       next_tick = timespec_add(next_tick, dura_);
-    }
     deadline_ = timespec_sub(next_tick, lag);
     if (gotvideo_ || !plm_get_video_enabled(plm_)) {
       gotvideo_ = false;
@@ -1371,9 +1217,8 @@ static void PrintVideo(void) {
             timespec_tonanos(lag), timespec_tonanos(GetGraceTime()));
     }
     do {
-      if (!setjmp(jbi_)) {
+      if (!setjmp(jbi_))
         PerformBestEffortIo();
-      }
       HandleSignals();
     } while (timespec_tomillis(GetGraceTime()) > 0);
   } while (plm_ && !plm_has_ended(plm_));
@@ -1392,17 +1237,6 @@ static bool AskUserYesOrNoQuestion(const char *prompt) {
   return c == 'y' || c == 'Y';
 }
 
-static bool CanPlayAudio(void) {
-  if (ffplay_ || sox_) {
-    return true;
-  } else if (AskUserYesOrNoQuestion(
-                 "ffplay not found; continue without audio?")) {
-    return false;
-  } else {
-    longjmp(jb_, 1);
-  }
-}
-
 static void PrintUsage(int rc, int fd) {
   tinyprint(fd, "Usage: ", program_invocation_name, USAGE, NULL);
   exit(rc);
@@ -1441,8 +1275,6 @@ static void GetOpts(int argc, char *argv[]) {
 }
 
 static void OnExit(void) {
-  if (playpid_)
-    kill(playpid_, SIGTERM), sched_yield();
   if (plm_)
     plm_destroy(plm_), plm_ = NULL;
   YCbCrFree(&ycbcr_);
@@ -1459,11 +1291,6 @@ static void OnExit(void) {
   CloseSpeaker();
 }
 
-static void MakeLatencyLittleLessBad(void) {
-  LOGIFNEG1(sys_mlockall(MCL_CURRENT));
-  LOGIFNEG1(nice(-5));
-}
-
 static void PickDefaults(void) {
   /*
    * Direct color ain't true color -- it just means xterm does the
@@ -1472,16 +1299,8 @@ static void PickDefaults(void) {
    *
    * strcmp(nulltoempty(getenv("TERM")), "xterm-direct") == 0
    */
-  if (strcmp(nulltoempty(getenv("TERM")), "xterm-kitty") == 0) {
+  if (IsWindows() || !strcmp(nulltoempty(getenv("TERM")), "xterm-kitty"))
     ttyquantsetup(kTtyQuantTrue, TTYQUANT()->chans, kTtyBlocksUnicode);
-  }
-}
-
-static void RenounceSpecialPrivileges(void) {
-  if (issetugid()) {
-    setegid(getgid());
-    seteuid(getuid());
-  }
 }
 
 #define FBIOGET_VSCREENINFO 0x4600
@@ -1581,10 +1400,13 @@ static void TryToOpenFrameBuffer(void) {
 
 int main(int argc, char *argv[]) {
   sigset_t wut;
-  const char *s;
   ShowCrashReports();
+#ifdef __x86_64__
+  if (IsWindows())
+    SetThreadPriority(GetCurrentThread(), kNtThreadPriorityHighest);
+#endif
   gamma_ = 2.4;
-  volscale_ -= 2;
+  volscale_ = 1.f;
   dither_ = true;
   sigemptyset(&wut);
   sigaddset(&wut, SIGCHLD);
@@ -1598,17 +1420,6 @@ int main(int argc, char *argv[]) {
   if (optind == argc)
     PrintUsage(EX_USAGE, STDERR_FILENO);
   patharg_ = argv[optind];
-  s = commandvenv("SOX", "sox");
-  sox_ = s ? strdup(s) : 0;
-  s = commandvenv("FFPLAY", "ffplay");
-  ffplay_ = s ? strdup(s) : 0;
-  if (!sox_ && !ffplay_) {
-    fprintf(stderr, "please install either the "
-                    "`play` (sox) or "
-                    "`ffplay` (ffmpeg) "
-                    "commands, so printvideo can play audio\n");
-    usleep(10000);
-  }
   infd_ = STDIN_FILENO;
   outfd_ = STDOUT_FILENO;
   if (!setjmp(jb_)) {
@@ -1616,27 +1427,22 @@ int main(int argc, char *argv[]) {
     xsigaction(SIGHUP, OnCtrlC, 0, 0, NULL);
     xsigaction(SIGTERM, OnCtrlC, 0, 0, NULL);
     xsigaction(SIGWINCH, OnResize, 0, 0, NULL);
-    xsigaction(SIGCHLD, OnSigChld, 0, 0, NULL);
-    xsigaction(SIGPIPE, OnSigPipe, 0, 0, NULL);
     if (ttyraw(kTtyLfToCrLf) != -1)
       ttymode_ = true;
     __cxa_atexit((void *)OnExit, NULL, NULL);
     __log_file = fopen(logpath_, "a");
     if (ischardev(infd_) && ischardev(outfd_)) {
-      /* CHECK_NE(-1, fcntl(infd_, F_SETFL, O_NONBLOCK)); */
+      /* CHECK_NE(-1, fcntl(outfd_, F_SETFL, O_NONBLOCK)); */
     } else if (infd_ != outfd_) {
       infd_ = -1;
     }
     /* CHECK_NE(-1, fcntl(outfd_, F_SETFL, O_NONBLOCK)); */
-    if (CanPlayAudio())
-      MakeLatencyLittleLessBad();
     TryToOpenFrameBuffer();
-    RenounceSpecialPrivileges();
     if (t2 > t1)
       longjmp(jb_, 1);
     OpenVideo();
     DimensionDisplay();
-    starttime_ = timespec_real();
+    starttime_ = timespec_mono();
     PrintVideo();
   }
   INFOF("jb_ triggered");
diff --git a/tool/viz/rlimit.c b/tool/viz/rlimit.c
index 3d3b84eb5..6923626ec 100644
--- a/tool/viz/rlimit.c
+++ b/tool/viz/rlimit.c
@@ -10,10 +10,10 @@
 #include "libc/calls/struct/rlimit.h"
 #include "libc/calls/calls.h"
 #include "libc/errno.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/intrin/strace.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/intrin/strace.h"
 #include "libc/log/color.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
@@ -43,7 +43,7 @@ static void SetLimit(int resource, uint64_t soft, uint64_t hard) {
         return;
       }
     }
-    fprintf(stderr, "ERROR: SETRLIMIT(%s, %,ld, %,ld) FAILED %m%n",
+    fprintf(stderr, "ERROR: SETRLIMIT(%s, %,ld, %,ld) FAILED %m\n",
             DescribeRlimitName(resource), soft, hard);
     exit(1);
   }
@@ -67,7 +67,7 @@ int main(int argc, char *argv[]) {
   for (i = 0; i < RLIM_NLIMITS; ++i) {
     rc = getrlimit(i, &rlim);
     printf("SETRLIMIT(%-20s, %,16ld, %,16ld) → %d %s\n",
-           (DescribeRlimitName)(rlnbuf, i), rlim.rlim_cur, rlim.rlim_max, rc,
+           _DescribeRlimitName(rlnbuf, i), rlim.rlim_cur, rlim.rlim_max, rc,
            !rc ? "" : strerror(errno));
   }
 
diff --git a/tool/viz/tailf.c b/tool/viz/tailf.c
index 9c97c516a..b2f7bb5d3 100644
--- a/tool/viz/tailf.c
+++ b/tool/viz/tailf.c
@@ -18,8 +18,8 @@
 ╚─────────────────────────────────────────────────────────────────────────────*/
 #include "libc/calls/calls.h"
 #include "libc/calls/struct/stat.h"
-#include "libc/intrin/safemacros.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/safemacros.h"
+#include "libc/macros.h"
 #include "libc/runtime/runtime.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
diff --git a/tool/viz/unbing.c b/tool/viz/unbing.c
index fc5074eb4..cbf6de954 100644
--- a/tool/viz/unbing.c
+++ b/tool/viz/unbing.c
@@ -19,7 +19,7 @@
 #include "libc/calls/calls.h"
 #include "libc/stdio/stdio.h"
 #include "libc/str/str.h"
-#include "libc/str/tab.internal.h"
+#include "libc/str/tab.h"
 
 /**
  * @fileoverview UnBing: Glyphs → Binary.
diff --git a/tool/viz/vdsodump.c b/tool/viz/vdsodump.c
new file mode 100644
index 000000000..22174a323
--- /dev/null
+++ b/tool/viz/vdsodump.c
@@ -0,0 +1,40 @@
+/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
+│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8                               :vi │
+╞══════════════════════════════════════════════════════════════════════════════╡
+│ Copyright 2024 Justine Alexandra Roberts Tunney                              │
+│                                                                              │
+│ Permission to use, copy, modify, and/or distribute this software for         │
+│ any purpose with or without fee is hereby granted, provided that the         │
+│ above copyright notice and this permission notice appear in all copies.      │
+│                                                                              │
+│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL                │
+│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED                │
+│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE             │
+│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL         │
+│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        │
+│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER               │
+│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR             │
+│ PERFORMANCE OF THIS SOFTWARE.                                                │
+╚─────────────────────────────────────────────────────────────────────────────*/
+#include "libc/calls/calls.h"
+#include "libc/intrin/getauxval.h"
+#include "libc/runtime/runtime.h"
+#include "libc/sysv/consts/auxv.h"
+
+int main(int argc, char *argv[]) {
+  struct AuxiliaryValue av;
+  av = __getauxval(AT_SYSINFO_EHDR);
+  if (!av.isfound)
+    return 2;
+  int fd = creat("vdso.so", 0644);
+  if (fd == -1)
+    return 3;
+  int i;
+  for (i = 0;; i += getpagesize())
+    if (write(fd, (char *)av.value + i, getpagesize()) == -1)
+      break;
+  if (!i)
+    return 4;
+  if (close(fd))
+    return 5;
+}
diff --git a/tool/viz/virtualquery.c b/tool/viz/virtualquery.c
index 7168c7202..92558fa60 100644
--- a/tool/viz/virtualquery.c
+++ b/tool/viz/virtualquery.c
@@ -19,8 +19,8 @@
 #include "libc/dce.h"
 #include "libc/errno.h"
 #include "libc/fmt/conv.h"
-#include "libc/intrin/describeflags.internal.h"
-#include "libc/macros.internal.h"
+#include "libc/intrin/describeflags.h"
+#include "libc/macros.h"
 #include "libc/nt/enum/memflags.h"
 #include "libc/nt/memory.h"
 #include "libc/nt/struct/memorybasicinformation.h"
@@ -40,8 +40,8 @@ static const struct DescribeFlags kNtMemState[] = {
 };
 
 const char *DescribeNtMemState(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kNtMemState, ARRAYLEN(kNtMemState), "kNtMem",
-                       x);
+  return _DescribeFlags(buf, 64, kNtMemState, ARRAYLEN(kNtMemState), "kNtMem",
+                        x);
 }
 
 static const struct DescribeFlags kNtMemType[] = {
@@ -51,7 +51,7 @@ static const struct DescribeFlags kNtMemType[] = {
 };
 
 const char *DescribeNtMemType(char buf[64], uint32_t x) {
-  return DescribeFlags(buf, 64, kNtMemType, ARRAYLEN(kNtMemType), "kNtMem", x);
+  return _DescribeFlags(buf, 64, kNtMemType, ARRAYLEN(kNtMemType), "kNtMem", x);
 }
 
 int main(int argc, char *argv[]) {
@@ -72,8 +72,8 @@ int main(int argc, char *argv[]) {
     printf("%.12lx %.12lx %10s %16s %16s %32s %32s\n", mi.AllocationBase,
            mi.BaseAddress, b[0], DescribeNtMemState(b[1], mi.State),
            DescribeNtMemType(b[2], mi.Type),
-           (DescribeNtPageFlags)(b[3], mi.AllocationProtect),
-           (DescribeNtPageFlags)(b[4], mi.Protect));
+           _DescribeNtPageFlags(b[3], mi.AllocationProtect),
+           _DescribeNtPageFlags(b[4], mi.Protect));
   }
 }
 
diff --git a/tool/zsh/mkofs b/tool/zsh/mkofs
index 8018d493a..9e3c8146c 100644
--- a/tool/zsh/mkofs
+++ b/tool/zsh/mkofs
@@ -17,7 +17,12 @@ cut -d' ' -f2 /proc/mounts | while read -r line; do
     return 0
   fi
 done
+if whence doas >/dev/null; then
+  doas=doas
+else
+  doas=sudo
+fi
 ( set -x
-  sudo mount -t tmpfs -o size=10G,noatime,nodiratime /dev/shm "$o"
+  $doas mount -t tmpfs -o size=10G,noatime,nodiratime /dev/shm "$o"
 )
 # vim:ft=zsh
diff --git a/tool/zsh/mmake b/tool/zsh/mmake
index 0b5315bae..5efe8cdad 100644
--- a/tool/zsh/mmake
+++ b/tool/zsh/mmake
@@ -38,8 +38,21 @@ done
   whence nproc >/dev/null || autoload -Uz nproc
   j=-j$(nproc)
 }
-local make=${MAKE:-${COSMOCC:-/opt/cosmocc/current}/bin/make}
-[[ -x $make ]] || make=${COSMO:-$PWD}/build/bootstrap/make
+local make=$(
+  case $MAKE in
+    */*)            echo $MAKE                        ;;
+    ?*)             command -v $MAKE                  ;;
+    *)              echo .cosmocc/current/bin/make    ;;
+  esac
+)
+if [[ ! -x $make ]]; then
+  { echo 'please install a suitable make, for example:'
+    echo
+    echo 'https://cosmo.zip/pub/cosmos/bin/make'
+    echo
+    echo 'then put it on $PATH or point $MAKE to it.'
+  } >&2; return 1
+fi
 ( set -x
   exec $make $j $flags MODE=$mode $targs )
 # vim:ft=zsh
diff --git a/usr/share/ssl/root/usertrust.pem b/usr/share/ssl/root/usertrust.pem
new file mode 100644
index 000000000..789fb50ae
--- /dev/null
+++ b/usr/share/ssl/root/usertrust.pem
@@ -0,0 +1,50 @@
+-----BEGIN CERTIFICATE-----
+MIICjzCCAhWgAwIBAgIQXIuZxVqUxdJxVt7NiYDMJjAKBggqhkjOPQQDAzCBiDEL
+MAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNl
+eSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMT
+JVVTRVJUcnVzdCBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMjAx
+MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT
+Ck5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVUaGUg
+VVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBFQ0MgQ2VydGlm
+aWNhdGlvbiBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQarFRaqflo
+I+d61SRvU8Za2EurxtW20eZzca7dnNYMYf3boIkDuAUU7FfO7l0/4iGzzvfUinng
+o4N+LZfQYcTxmdwlkWOrfzCjtHDix6EznPO/LlxTsV+zfTJ/ijTjeXmjQjBAMB0G
+A1UdDgQWBBQ64QmG1M8ZwpZ2dEl23OA1xmNjmjAOBgNVHQ8BAf8EBAMCAQYwDwYD
+VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjA2Z6EWCNzklwBBHU6+4WMB
+zzuqQhFkoJ2UOQIReVx7Hfpkue4WQrO/isIJxOzksU0CMQDpKmFHjFJKS04YcPbW
+RNZu9YO6bVi9JNlWSOrvxKJGgYhqOkbRqZtNyWHa0V1Xahg=
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
\ No newline at end of file